t value is "Hello world!".", html_escape::encode_double_quoted_attribute_to_string("The default value is \"Hello world!\".", &mut html));
html.push_str("\"/><script>alert('");
assert_eq!(r"<script>\'s end tag is <\/script>", html_escape::encode_script_single_quoted_text_to_string("<script>'s end tag is </script>", &mut html));
html.push_str("');</script>");

assert_eq!("<input value=Hello&#x20;world&#x21; placeholder=\"The default value is &quot;Hello world!&quot;.\"/><script>alert(\'<script>\\\'s end tag is <\\/script>\');</script>", html);
```

### Decoding

```rust
assert_eq!("Hello world!", html_escape::decode_html_entities("Hello&#x20;world&#x21;"));
```

```rust
assert_eq!("alert('<script></script>');", html_escape::decode_script(r"alert('<script><\/script>');"));
```

## No Std

Disable the default features to compile this crate without std.

```toml
[dependencies.html-escape]
version = "*"
default-features = false
```

## Benchmark

```bash
cargo bench
```
*/// Invariant: bytes contains valid UTF-8ByteStr/// In a debug build this will panic if `bytes` is not valid UTF-8./// `bytes` must contain valid UTF-8. In a release build it is undefined/// behavior to call this with `bytes` that is not valid UTF-8.if_downcast_intoMaxSizeReached/// A generic "error" for HTTP connections/// This error type is less specific than the error returned from other/// functions in this crate, but all other errors can be converted to this/// error. Consumers of this crate can typically consume and work with this form/// of error for conversions with the `?` operator./// A `Result` typedef to use with the `http::Error` typeInvalidStatusCodeStatusCodeInvalidMethodInvalidUriPartsUriPartsInvalidHeaderNameHeaderNameInvalidHeaderValueHeaderValue/// Return true if the underlying error has the same type as T./// Return a reference to the lower level, inner error.// Return any available cause from the inner error. Note the inner error is// not itself the cause.inner_error_is_invalid_status_codeAnyMapAnyCloneIdHasher// With TypeIds as keys, there's no need to hash them. They are already hashes// themselves, coming from the compiler. The IdHasher just holds the u64 of// the TypeId, and then returns it, instead of doing any bit fiddling.// If extensions are never used, no need to carry around an empty HashMap.// That's 3 words. Instead, this is only 1 word./// A type map of protocol extensions./// `Extensions` can be used by `Request` and `Response` to store/// extra data derived from the underlying protocol./// Create an empty `Extensions`./// Insert a type into this `Extensions`./// If a extension of this type already existed, it will/// be returned and replaced with the new one./// # use http::Extensions;/// let mut ext = Extensions::new();/// assert!(ext.insert(5i32).is_none());/// assert!(ext.insert(4u8).is_none());/// assert_eq!(ext.insert(9i32), Some(5i32));/// Get a reference to a type previously inserted on this `Extensions`./// assert!(ext.get::<i32>().is_none());/// ext.insert(5i32);/// assert_eq!(ext.get::<i32>(), Some(&5i32));/// Get a mutable reference to a type previously inserted on this `Extensions`./// ext.insert(String::from("Hello"));/// ext.get_mut::<String>().unwrap().push_str(" World");/// assert_eq!(ext.get::<String>().unwrap(), "Hello World");/// Get a mutable reference to a type, inserting `value` if not already present on this/// `Extensions`./// *ext.get_or_insert(1i32) += 2;/// assert_eq!(*ext.get::<i32>().unwrap(), 3);/// Get a mutable reference to a type, inserting the value created by `f` if not already present/// on this `Extensions`./// *ext.get_or_insert_with(|| 1i32) += 2;get_or_insert_default/// Get a mutable reference to a type, inserting the type's default value if not already present/// *ext.get_or_insert_default::<i32>() += 2;/// assert_eq!(*ext.get::<i32>().unwrap(), 2);/// Remove a type from this `Extensions`./// If a extension of this type existed, it will be returned./// assert_eq!(ext.remove::<i32>(), Some(5i32));/// Clear the `Extensions` of all inserted extensions./// ext.clear();/// Check whether the extension set is empty or not./// assert!(ext.is_empty());/// assert!(!ext.is_empty());/// Get the number of extensions available./// assert_eq!(ext.len(), 0);/// assert_eq!(ext.len(), 1);/// Extends `self` with another `Extensions`./// If an instance of a specific type exists in both, the one in `self` is overwritten with the/// one from `other`./// let mut ext_a = Extensions::new();/// ext_a.insert(8u8);/// ext_a.insert(16u16);/// let mut ext_b = Extensions::new();/// ext_b.insert(4u8);/// ext_b.insert("hello");/// ext_a.extend(ext_b);/// assert_eq!(ext_a.len(), 3);/// assert_eq!(ext_a.get::<u8>(), Some(&4u8));/// assert_eq!(ext_a.get::<u16>(), Some(&16u16));/// assert_eq!(ext_a.get::<&'static str>().copied(), Some("hello"));clone_boxtest_extensionsHdrNameas_header_nameAsHeaderNameinto_header_nameIntoHeaderName// Used to mask values to get an indexextra_valuesExtraValueDangerHeaderMap/// A set of HTTP headers/// `HeaderMap` is a multimap of [`HeaderName`] to values./// [`HeaderName`]: struct.HeaderName.html/// Basic usage/// # use http::HeaderMap;/// # use http::header::{CONTENT_LENGTH, HOST, LOCATION};/// let mut headers = HeaderMap::new();/// headers.insert(HOST, "example.com".parse().unwrap());/// headers.insert(CONTENT_LENGTH, "123".parse().unwrap());/// assert!(headers.contains_key(HOST));/// assert!(!headers.contains_key(LOCATION));/// assert_eq!(headers[HOST], "example.com");/// headers.remove(HOST);/// assert!(!headers.contains_key(HOST));/// `HeaderMap` entry iterator./// Yields `(&HeaderName, &value)` tuples. The same header name may be yielded/// more than once if it has more than one associated value./// `HeaderMap` mutable entry iterator/// Yields `(&HeaderName, &mut value)` tuples. The same header name may be/// yielded more than once if it has more than one associated value.// If None, pull from `entries`/// An owning iterator over the entries of a `HeaderMap`./// This struct is created by the `into_iter` method on `HeaderMap`./// An iterator over `HeaderMap` keys./// Each header name is yielded only once, even if it has more than one/// `HeaderMap` value iterator./// Each value contained in the `HeaderMap` will be yielded./// `HeaderMap` mutable value iterator/// A drain iterator for `HeaderMap`.GetAll/// A view to all values stored in a single entry./// This struct is returned by `HeaderMap::get_all`./// An occupied entry/// A vacant entry/// A view into a single location in a `HeaderMap`, which may be vacant or occupied.HashValue/// A view into a single empty location in a `HeaderMap`./// This struct is returned as part of the `Entry` enum./// A view into a single occupied location in a `HeaderMap`.ValueIter/// An iterator of all values associated with a single header name.ValueIterMut/// A mutable iterator of all values associated with a single header name.ValueDrain/// An drain iterator of all values associated with a single header name./// Error returned when max capacity of `HeaderMap` is exceeded/// Tracks the value iterator state/// Type used for representing the size of a HeaderMap value./// 32,768 is more than enough entries for a single header map. Setting this/// limit enables using `u16` to represent all offsets, which takes 2 bytes/// instead of 8 on 64 bit processors./// Setting this limit is especially beneficial for `indices`, making it more/// cache friendly. More hash codes can fit in a cache line./// You may notice that `u16` may represent more than 32,768 values. This is/// true, but 32,768 should be plenty and it allows us to reserve the top bit/// for future usage./// This limit falls out from above.// Index in the `entries` vec// Full hash value for the entry./// An entry in the hash table. This represents the full hash code for an entry/// as well as the position of the entry in the `entries` vector./// Hash values are limited to u16 as well. While `fast_hash` and `Hasher`/// return `usize` hash codes, limiting the effective hash code to the lower 16/// bits is fine since we know that the `indices` vector will never grow beyond/// that size.linksLinks/// Stores the data associated with a `HeaderMap` entry. Only the first value is/// included in this struct. If a header name has more than one associated/// value, all extra values are stored in the `extra_values` vector. A doubly/// linked list of entries is maintained. The doubly linked list is used so that/// removing a value is constant time. This also has the nice property of/// enabling double ended iteration./// The head and tail of the value linked list.RawLinks/// Access to the `links` value in a slice of buckets./// It's important that no other field is accessed, since it may have been/// freed in a `Drain` iterator./// Node in doubly-linked list of header value entries/// A header value node is either linked to another node in the `extra_values`/// list or it points to an entry in `entries`. The entry in `entries` is the/// start of the list and holds the associated header name./// Tracks the header map danger level! This relates to the adaptive hashing/// algorithm. A HeaderMap starts in the "green" state, when a large number of/// collisions are detected, it transitions to the yellow state. At this point,/// the header map will either grow and switch back to the green state OR it/// will transition to the red state./// When in the red state, a safe hashing algorithm is used and all values in/// the header map have to be rehashed.DISPLACEMENT_THRESHOLD// Constants related to detecting DOS attacks.// Displacement is the number of entries that get shifted when inserting a new// value. Forward shift is how far the entry gets stored from the ideal// position.// The current constant values were picked from another implementation. It could// be that there are different values better suited to the header map case.FORWARD_SHIFT_THRESHOLDLOAD_FACTOR_THRESHOLD// The default strategy for handling the yellow danger state is to increase the// header map capacity in order to (hopefully) reduce the number of collisions.// If growing the hash map would cause the load factor to drop bellow this// threshold, then instead of growing, the headermap is switched to the red// danger state and safe hashing is used instead.probe_loop// Macro used to iterate the hash table starting at a given point, looping when// the end is hit.insert_phase_one// First part of the robinhood algorithm. Given a key, find the slot in which it// will be inserted. This is done by starting at the "ideal" spot. Then scanning// until the destination slot is found. A destination slot is either the next// empty slot or the next slot that is occupied by an entry that has a lower// displacement (displacement is the distance from the ideal spot).// This is implemented as a macro instead of a function that takes a closure in// order to guarantee that it is "inlined". There is no way to annotate closures// to guarantee inlining./// Create an empty `HeaderMap`./// The map will be created without any capacity. This function will not/// allocate./// let map = HeaderMap::new();/// assert_eq!(0, map.capacity());/// Create an empty `HeaderMap` with the specified capacity./// The returned map will allocate internal storage in order to hold about/// `capacity` elements without reallocating. However, this is a "best/// effort" as there are usage patterns that could cause additional/// allocations before `capacity` headers are stored in the map./// More capacity than requested may be allocated./// This method panics if capacity exceeds max `HeaderMap` capacity./// let map: HeaderMap<u32> = HeaderMap::with_capacity(10);/// assert_eq!(12, map.capacity());/// This function may return an error if `HeaderMap` exceeds max capacity/// let map: HeaderMap<u32> = HeaderMap::try_with_capacity(10).unwrap();/// Returns the number of headers stored in the map./// This number represents the total number of **values** stored in the map./// This number can be greater than or equal to the number of **keys**/// stored given that a single key may have more than one associated value./// # use http::header::{ACCEPT, HOST};/// let mut map = HeaderMap::new();/// assert_eq!(0, map.len());/// map.insert(ACCEPT, "text/plain".parse().unwrap());/// map.insert(HOST, "localhost".parse().unwrap());/// assert_eq!(2, map.len());/// map.append(ACCEPT, "text/html".parse().unwrap());/// assert_eq!(3, map.len());keys_len/// Returns the number of keys stored in the map./// This number will be less than or equal to `len()` as each key may have/// more than one associated value./// assert_eq!(0, map.keys_len());/// assert_eq!(2, map.keys_len());/// map.insert(ACCEPT, "text/html".parse().unwrap());/// Returns true if the map contains no elements./// # use http::header::HOST;/// map.insert(HOST, "hello.world".parse().unwrap());/// assert!(!map.is_empty());/// map.clear();/// Returns the number of headers the map can hold without reallocating./// This number is an approximation as certain usage patterns could cause/// additional allocations before the returned capacity is filled./// assert_eq!(6, map.capacity());/// Reserves capacity for at least `additional` more headers to be inserted/// into the `HeaderMap`./// The header map may reserve more space to avoid frequent reallocations./// Like with `with_capacity`, this will be a "best effort" to avoid/// allocations until `additional` more headers are inserted. Certain usage/// patterns could cause additional allocations before the number is/// reached./// Panics if the new allocation size overflows `HeaderMap` `MAX_SIZE`./// # map.insert(HOST, "bar".parse().unwrap());/// This method differs from `reserve` by returning an error instead of/// panicking if the value is too large./// map.try_reserve(10).unwrap();/// # map.try_insert(HOST, "bar".parse().unwrap()).unwrap();/// Returns a reference to the value associated with the key./// If there are multiple values associated with the key, then the first one/// is returned. Use `get_all` to get all values associated with a given/// key. Returns `None` if there are no values associated with the key./// assert!(map.get("host").is_none());/// map.insert(HOST, "hello".parse().unwrap());/// assert_eq!(map.get(HOST).unwrap(), &"hello");/// assert_eq!(map.get("host").unwrap(), &"hello");/// map.append(HOST, "world".parse().unwrap());/// Returns a mutable reference to the value associated with the key./// is returned. Use `entry` to get all values associated with a given/// let mut map = HeaderMap::default();/// map.insert(HOST, "hello".to_string());/// map.get_mut("host").unwrap().push_str("-world");/// assert_eq!(map.get(HOST).unwrap(), &"hello-world");/// Returns a view of all values associated with a key./// The returned view does not incur any allocations and allows iterating/// the values associated with the key.  See [`GetAll`] for more details./// Returns `None` if there are no values associated with the key./// [`GetAll`]: struct.GetAll.html/// map.append(HOST, "goodbye".parse().unwrap());/// let view = map.get_all("host");/// let mut iter = view.iter();/// assert_eq!(&"hello", iter.next().unwrap());/// assert_eq!(&"goodbye", iter.next().unwrap());/// Returns true if the map contains a value for the specified key./// assert!(!map.contains_key(HOST));/// map.insert(HOST, "world".parse().unwrap());/// assert!(map.contains_key("host"));/// An iterator visiting all key-value pairs./// The iteration order is arbitrary, but consistent across platforms for/// the same crate version. Each key will be yielded once per associated/// value. So, if a key has 3 associated values, it will be yielded 3 times./// # use http::header::{CONTENT_LENGTH, HOST};/// map.insert(CONTENT_LENGTH, "123".parse().unwrap());/// for (key, value) in map.iter() {///     println!("{:?}: {:?}", key, value);/// An iterator visiting all key-value pairs, with mutable value references./// The iterator order is arbitrary, but consistent across platforms for the/// same crate version. Each key will be yielded once per associated value,/// so if a key has 3 associated values, it will be yielded 3 times./// map.append(HOST, "goodbye".to_string());/// map.insert(CONTENT_LENGTH, "123".to_string());/// for (key, value) in map.iter_mut() {///     value.push_str("-boop");/// An iterator visiting all keys./// the same crate version. Each key will be yielded only once even if it/// has multiple associated values.///     println!("{:?}", key);/// An iterator visiting all values./// the same crate version./// for value in map.values() {///     println!("{:?}", value);/// An iterator visiting all values mutably./// Clears the map, returning all entries as an iterator./// The internal memory is kept for reuse./// For each yielded item that has `None` provided for the `HeaderName`,/// then the associated header name is the same as that of the previously/// yielded item. The first yielded item will have `HeaderName` set./// let mut drain = map.drain();/// assert_eq!(drain.next(), Some((Some(HOST), "hello".parse().unwrap())));/// assert_eq!(drain.next(), Some((None, "goodbye".parse().unwrap())));/// assert_eq!(drain.next(), Some((Some(CONTENT_LENGTH), "123".parse().unwrap())));/// assert_eq!(drain.next(), None);value_itervalue_iter_mut/// Gets the given key's corresponding entry in the map for in-place/// manipulation./// This method panics if capacity exceeds max `HeaderMap` capacity/// let mut map: HeaderMap<u32> = HeaderMap::default();/// let headers = &[///     "content-length",///     "x-hello",///     "Content-Length",///     "x-world",/// for &header in headers {///     let counter = map.entry(header).or_insert(0);/// assert_eq!(map["content-length"], 2);/// assert_eq!(map["x-hello"], 1);/// This method differs from `entry` by allowing types that may not be/// valid `HeaderName`s to passed as the key (such as `String`). If they/// do not parse as a valid `HeaderName`, this returns an/// `InvalidHeaderName` error./// If reserving space goes over the maximum, this will also return an/// error. However, to prevent breaking changes to the return type, the/// error will still say `InvalidHeaderName`, unlike other `try_*` methods/// which return a `MaxSizeReached` error.try_entry2/// If the map did not previously have this key present, then `None` is/// If the map did have this key present, the new value is associated with/// the key and all previous values are removed. **Note** that only a single/// one of the previous values is returned. If there are multiple values/// that have been previously associated with the key, then the first one is/// returned. See `insert_mult` on `OccupiedEntry` for an API that returns/// all values./// The key is not updated, though; this matters for types that can be `==`/// without being identical./// assert!(map.insert(HOST, "world".parse().unwrap()).is_none());/// let mut prev = map.insert(HOST, "earth".parse().unwrap()).unwrap();/// assert_eq!("world", prev);/// assert!(map.try_insert(HOST, "world".parse().unwrap()).unwrap().is_none());/// let mut prev = map.try_insert(HOST, "earth".parse().unwrap()).unwrap().unwrap();try_insert2insert_occupied/// Set an occupied bucket to the given valueinsert_occupied_mult/// If the map did not previously have this key present, then `false` is/// If the map did have this key present, the new value is pushed to the end/// of the list of values currently associated with the key. The key is not/// updated, though; this matters for types that can be `==` without being/// identical./// map.append(HOST, "earth".parse().unwrap());/// let values = map.get_all("host");/// let mut i = values.iter();/// assert_eq!("world", *i.next().unwrap());/// assert_eq!("earth", *i.next().unwrap());try_append/// map.try_append(HOST, "earth".parse().unwrap()).unwrap();try_append2try_insert_phase_two/// phase 2 is post-insert where we forward-shift `Pos` in the indices./// Removes a key from the map, returning the value associated with the key./// Returns `None` if the map does not contain the key. If there are/// multiple values associated with the key, then the first one is returned./// See `remove_entry_mult` on `OccupiedEntry` for an API that yields all/// let prev = map.remove(HOST).unwrap();/// assert_eq!("hello.world", prev);/// assert!(map.remove(HOST).is_none());remove_found/// Remove an entry from the map./// Warning: To avoid inconsistent state, extra values _must_ be removed/// for the `found` index (via `remove_all_extra_values` or similar)/// _before_ this method is called.remove_extra_value/// Removes the `ExtraValue` at the given index.remove_all_extra_valuestry_insert_entryrebuildreinsert_entry_in_ordertry_reserve_onetry_growraw_linksdrain_all_extra_values/// Creates a consuming iterator, that is, one that moves keys and values/// out of the map in arbitrary order. The map cannot be used after calling/// Basic usage./// # use http::header;/// # use http::header::*;/// map.insert(header::CONTENT_LENGTH, "123".parse().unwrap());/// map.insert(header::CONTENT_TYPE, "json".parse().unwrap());/// assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap())));/// assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap())));/// Multiple values per key./// map.append(header::CONTENT_LENGTH, "123".parse().unwrap());/// map.append(header::CONTENT_LENGTH, "456".parse().unwrap());/// map.append(header::CONTENT_TYPE, "json".parse().unwrap());/// map.append(header::CONTENT_TYPE, "html".parse().unwrap());/// map.append(header::CONTENT_TYPE, "xml".parse().unwrap());/// assert_eq!(iter.next(), Some((None, "456".parse().unwrap())));/// assert_eq!(iter.next(), Some((None, "html".parse().unwrap())));/// assert_eq!(iter.next(), Some((None, "xml".parse().unwrap())));/// Try to convert a `HashMap` into a `HeaderMap`./// use http::HeaderMap;/// map.insert("X-Custom-Header".to_string(), "my value".to_string());/// let headers: HeaderMap = (&map).try_into().expect("valid headers");/// assert_eq!(headers["X-Custom-Header"], "my value");/// Extend a `HeaderMap` with the contents of another `HeaderMap`./// This function expects the yielded items to follow the same structure as/// `IntoIter`./// This panics if the first yielded item does not have a `HeaderName`./// let mut extra = HeaderMap::new();/// extra.insert(HOST, "foo.bar".parse().unwrap());/// extra.insert(COOKIE, "hello".parse().unwrap());/// extra.append(COOKIE, "world".parse().unwrap());/// map.extend(extra);/// assert_eq!(map["host"], "foo.bar");/// assert_eq!(map["accept"], "text/plain");/// assert_eq!(map["cookie"], "hello");/// let v = map.get_all("host");/// assert_eq!(1, v.iter().count());/// let v = map.get_all("cookie");/// assert_eq!(2, v.iter().count());/// Using the index operator will cause a panic if the header you're querying isn't set.do_insert_phase_two/// returns the number of displaced elementsappend_valuenext_unsafe/// Ensures a value is in the entry by inserting the default if empty./// Returns a mutable reference to the **first** value in the entry.///     let counter = map.entry(header)///         .or_insert(0);or_try_insert///         .or_try_insert(0)/// Ensures a value is in the entry by inserting the result of the default/// function if empty./// The default function is not called if the entry exists in the map./// let res = map.entry("x-hello")///     .or_insert_with(|| "world".parse().unwrap());/// assert_eq!(res, "world");/// map.try_insert(HOST, "world".parse().unwrap()).unwrap();/// let res = map.try_entry("host")///     .or_try_insert_with(|| unreachable!())/// Returns a reference to the entry's key/// assert_eq!(map.entry("x-hello").key(), "x-hello");/// assert_eq!(map.entry("x-hello").key().as_str(), "x-hello");/// Take ownership of the key/// # use http::header::{HeaderMap, Entry};/// if let Entry::Vacant(v) = map.entry("x-hello") {///     assert_eq!(v.into_key().as_str(), "x-hello");/// Insert the value into the entry./// The value will be associated with this entry's key. A mutable reference/// to the inserted value will be returned.///     v.insert("world".parse().unwrap());/// assert_eq!(map["x-hello"], "world");/// The value will be associated with this entry's key. The new/// `OccupiedEntry` is returned, allowing for further manipulation./// if let Entry::Vacant(v) = map.try_entry("x-hello").unwrap() {///     let mut e = v.try_insert_entry("world".parse().unwrap()).unwrap();///     e.insert("world2".parse().unwrap());/// assert_eq!(map["x-hello"], "world2");/// Returns an iterator visiting all values associated with the entry./// Values are iterated in insertion order./// map.append(HOST, "hello.earth".parse().unwrap());/// let mut iter = values.iter();/// assert_eq!(&"hello.world", iter.next().unwrap());/// assert_eq!(&"hello.earth", iter.next().unwrap());/// Returns a reference to the entry's key./// # use http::header::{HeaderMap, Entry, HOST};/// if let Entry::Occupied(e) = map.entry("host") {///     assert_eq!("host", e.key());/// Get a reference to the first value in the entry./// Values are stored in insertion order./// `get` panics if there are no values associated with the entry./// if let Entry::Occupied(mut e) = map.entry("host") {///     assert_eq!(e.get(), &"hello.world");///     e.append("hello.earth".parse().unwrap());/// Get a mutable reference to the first value in the entry./// `get_mut` panics if there are no values associated with the entry./// map.insert(HOST, "hello.world".to_string());///     e.get_mut().push_str("-2");///     assert_eq!(e.get(), &"hello.world-2");/// Converts the `OccupiedEntry` into a mutable reference to the **first**/// The lifetime of the returned reference is bound to the original map./// `into_mut` panics if there are no values associated with the entry./// map.append(HOST, "hello.earth".to_string());///     e.into_mut().push_str("-2");/// assert_eq!("hello.world-2", map["host"]);/// Sets the value of the entry./// All previous values associated with the entry are removed and the first/// one is returned. See `insert_mult` for an API that returns all values.///     let mut prev = e.insert("earth".parse().unwrap());///     assert_eq!("hello.world", prev);/// assert_eq!("earth", map["host"]);insert_mult/// This function does the same as `insert` except it returns an iterator/// that yields all values previously associated with the key./// map.append(HOST, "world2".parse().unwrap());///     let mut prev = e.insert_mult("earth".parse().unwrap());///     assert_eq!("world", prev.next().unwrap());///     assert_eq!("world2", prev.next().unwrap());///     assert!(prev.next().is_none());/// The new value is appended to the end of the entry's value list. All/// previous values associated with the entry are retained.///     e.append("earth".parse().unwrap());/// Remove the entry from the map./// All values associated with the entry are removed and the first one is/// returned. See `remove_entry_mult` for an API that returns all values.///     let mut prev = e.remove();///     assert_eq!("world", prev);/// assert!(!map.contains_key("host"));/// The key and all values associated with the entry are removed and the/// first one is returned. See `remove_entry_mult` for an API that returns///     let (key, mut prev) = e.remove_entry();///     assert_eq!("host", key.as_str());remove_entry_mult/// The key and all values associated with the entry are removed and///     let mut iter = e.iter();///     assert_eq!(&"world", iter.next().unwrap());///     assert_eq!(&"earth", iter.next().unwrap());///     assert!(iter.next().is_none());/// Returns an iterator mutably visiting all values associated with the/// entry./// map.insert(HOST, "world".to_string());/// map.append(HOST, "earth".to_string());///     for e in e.iter_mut() {///         e.push_str("-boop");/// let mut values = map.get_all("host");/// assert_eq!(&"world-boop", i.next().unwrap());/// assert_eq!(&"earth-boop", i.next().unwrap());is_redis_yellowset_yellowusable_capacityto_raw_capacitydesired_posprobe_distance/// The number of steps that `current` is forward of the desired position for hashhash_elem_using/// A marker trait used to identify values that can be used as insert keys/// to a `HeaderMap`.// All methods are on this pub(super) trait, instead of `IntoHeaderName`,// so that they aren't publicly exposed to the world.// Being on the `IntoHeaderName` trait would mean users could call// `"host".insert(&mut map, "localhost")`.// Ultimately, this allows us to adjust the signatures of these methods// without breaking any external crate.// ==== impls ====/// A marker trait used to identify values that can be used as search keysTryEntryError// Debug not currently needed, save on compiling it// All methods are on this pub(super) trait, instead of `AsHeaderName`,// Being on the `AsHeaderName` trait would mean users could call// `"host".find(&map)`.skip_duplicates_during_key_iteration// # Implementation notes// Below, you will find a fairly large amount of code. Most of this is to// provide the necessary functions to efficiently manipulate the header// multimap. The core hashing table is based on robin hood hashing [1]. While// this is the same hashing algorithm used as part of Rust's `HashMap` in// stdlib, many implementation details are different. The two primary reasons// for this divergence are that `HeaderMap` is a multimap and the structure has// been optimized to take advantage of the characteristics of HTTP headers.// ## Structure Layout// Most of the data contained by `HeaderMap` is *not* stored in the hash table.// Instead, pairs of header name and *first* associated header value are stored// in the `entries` vector. If the header name has more than one associated// header value, then additional values are stored in `extra_values`. The actual// hash table (`indices`) only maps hash codes to indices in `entries`. This// means that, when an eviction happens, the actual header name and value stay// put and only a tiny amount of memory has to be copied.// Extra values associated with a header name are tracked using a linked list.// Links are formed with offsets into `extra_values` and not pointers.// [1]: https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing// ===== impl HeaderMap =====// ===== impl Iter =====// ===== impl IterMut =====// ===== impl Keys =====// ===== impl Values ====// ===== impl ValuesMut ====// ===== impl Drain =====// ===== impl Entry =====// ===== impl VacantEntry =====// ===== impl GetAll =====// ===== impl ValueIter =====// ===== impl ValueIterMut =====// ===== impl IntoIter =====// ===== impl OccupiedEntry =====// ===== impl ValueDrain =====// ===== impl RawLinks =====// ===== impl Pos =====// ===== impl MaxSizeReached =====// ===== impl Utils =====/*
 *
 * ===== impl IntoHeaderName / AsHeaderName =====
 *
 */ToStrErrorACCEPTACCEPT_CHARSETACCEPT_ENCODINGACCEPT_LANGUAGEACCEPT_RANGESACCESS_CONTROL_ALLOW_CREDENTIALSACCESS_CONTROL_ALLOW_HEADERSACCESS_CONTROL_ALLOW_METHODSACCESS_CONTROL_ALLOW_ORIGINACCESS_CONTROL_EXPOSE_HEADERSACCESS_CONTROL_MAX_AGEACCESS_CONTROL_REQUEST_HEADERSACCESS_CONTROL_REQUEST_METHODALLOWALT_SVCAUTHORIZATIONCACHE_CONTROLCACHE_STATUSCDN_CACHE_CONTROLCONNECTIONCONTENT_DISPOSITIONCONTENT_ENCODINGCONTENT_LANGUAGECONTENT_LENGTHCONTENT_LOCATIONCONTENT_RANGECONTENT_SECURITY_POLICYCONTENT_SECURITY_POLICY_REPORT_ONLYCONTENT_TYPECOOKIEDNTDATEETAGEXPECTEXPIRESFORWARDEDFROMIF_MATCHIF_MODIFIED_SINCEIF_NONE_MATCHIF_RANGEIF_UNMODIFIED_SINCELAST_MODIFIEDLOCATIONMAX_FORWARDSORIGINPRAGMAPROXY_AUTHENTICATEPROXY_AUTHORIZATIONPUBLIC_KEY_PINSPUBLIC_KEY_PINS_REPORT_ONLYREFERERREFERRER_POLICYREFRESHRETRY_AFTERSEC_WEBSOCKET_ACCEPTSEC_WEBSOCKET_EXTENSIONSSEC_WEBSOCKET_KEYSEC_WEBSOCKET_PROTOCOLSEC_WEBSOCKET_VERSIONSERVERSET_COOKIESTRICT_TRANSPORT_SECURITYTRAILERTRANSFER_ENCODINGUPGRADEUPGRADE_INSECURE_REQUESTSUSER_AGENTVARYVIAWWW_AUTHENTICATEX_CONTENT_TYPE_OPTIONSX_DNS_PREFETCH_CONTROLX_FRAME_OPTIONSX_XSS_PROTECTION// Use header name constantsMAX_HEADER_NAME_LEN/// Maximum length of a header name/// Generally, 64kb for a header name is WAY too much than would ever be needed/// in practice. Restricting it to this size enables using `u16` values to/// represent offsets when dealing with header names.//! HTTP header types//! The module provides [`HeaderName`], [`HeaderMap`], and a number of types//! used for interacting with `HeaderMap`. These types allow representing both//! HTTP/1 and HTTP/2 headers.//! # `HeaderName`//! The `HeaderName` type represents both standard header names as well as//! custom header names. The type handles the case insensitive nature of header//! names and is used as the key portion of `HeaderMap`. Header names are//! normalized to lower case. In other words, when creating a `HeaderName` with//! a string, even if upper case characters are included, when getting a string//! representation of the `HeaderName`, it will be all lower case. This allows//! for faster `HeaderMap` comparison operations.//! The internal representation is optimized to efficiently handle the cases//! most commonly encountered when working with HTTP. Standard header names are//! special cased and are represented internally as an enum. Short custom//! headers will be stored directly in the `HeaderName` struct and will not//! incur any allocation overhead, however longer strings will require an//! allocation for storage.//! `HeaderName` has a max length of 32,768 for header names. Attempting to//! parse longer names will result in a panic.//! # `HeaderMap`//! `HeaderMap` is a map structure of header names highly optimized for use//! cases common with HTTP. It is a [multimap] structure, where each header name//! may have multiple associated header values. Given this, some of the APIs//! diverge from [`HashMap`].//! Just like `HashMap` in Rust's stdlib, `HeaderMap` is based on [Robin Hood//! hashing]. This algorithm tends to reduce the worst case search times in the//! table and enables high load factors without seriously affecting performance.//! Internally, keys and values are stored in vectors. As such, each insertion//! will not incur allocation overhead. However, once the underlying vector//! storage is full, a larger vector must be allocated and all values copied.//! ## Deterministic ordering//! Unlike Rust's `HashMap`, values in `HeaderMap` are deterministically//! ordered. Roughly, values are ordered by insertion. This means that a//! function that deterministically operates on a header map can rely on the//! iteration order to remain consistent across processes and platforms.//! ## Adaptive hashing//! `HeaderMap` uses an adaptive hashing strategy in order to efficiently handle//! most common cases. All standard headers have statically computed hash values//! which removes the need to perform any hashing of these headers at runtime.//! The default hash function emphasizes performance over robustness. However,//! `HeaderMap` detects high collision rates and switches to a secure hash//! function in those events. The threshold is set such that only denial of//! service attacks should trigger it.//! `HeaderMap` can store a maximum of 32,768 headers (header name / value//! pairs). Attempting to insert more will result in a panic.//! [`HeaderName`]: struct.HeaderName.html//! [`HeaderMap`]: struct.HeaderMap.html//! [multimap]: https://en.wikipedia.org/wiki/Multimap//! [`HashMap`]: https://doc.rust-lang.org/std/collections/struct.HashMap.html//! [Robin Hood hashing]: https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashingbyte_str/// Represents an HTTP header field name/// Header field names identify the header. Header sets may include multiple/// headers with the same name. The HTTP specification defines a number of/// standard headers, but HTTP messages may include non-standard header names as/// well as long as they adhere to the specification./// `HeaderName` is used as the [`HeaderMap`] key. Constants are available for/// all standard header names in the [`header`] module./// `HeaderName` represents standard header names using an `enum`, as such they/// will not require an allocation for storage. All custom header names are/// lower cased upon conversion to a `HeaderName` value. This avoids the/// overhead of dynamically doing lower case conversion during the hash code/// computation and the comparison operation./// [`HeaderMap`]: struct.HeaderMap.html/// [`header`]: index.htmlMaybeLower// Almost a full `HeaderName`StandardHeader// Used to hijack the Hash impl// Invariant: If lower then buf is valid UTF-8./// A possible error when converting a `HeaderName` from another type.standard_headersAcceptCharsetAcceptEncodingAcceptLanguageAcceptRangesAccessControlAllowCredentialsAccessControlAllowHeadersAccessControlAllowMethodsAccessControlAllowOriginAccessControlExposeHeadersAccessControlMaxAgeAccessControlRequestHeadersAccessControlRequestMethodAllowAltSvcCacheControlCacheStatusCdnCacheControlContentDispositionContentEncodingContentLanguageContentLengthContentLocationContentRangeContentSecurityPolicyContentSecurityPolicyReportOnlyDntEtagExpectExpiresForwardedIfMatchIfModifiedSinceIfNoneMatchIfRangeIfUnmodifiedSinceLastModifiedMaxForwardsOriginPragmaProxyAuthenticateProxyAuthorizationPublicKeyPinsPublicKeyPinsReportOnlyRefererReferrerPolicyRetryAfterSecWebSocketAcceptSecWebSocketExtensionsSecWebSocketKeySecWebSocketProtocolSecWebSocketVersionSetCookieStrictTransportSecurityTeTransferEncodingUserAgentUpgradeInsecureRequestsVaryViaWwwAuthenticateXContentTypeOptionsXDnsPrefetchControlXFrameOptionsXXssProtectionr" Advertises which content types the client is able to understand."r" The Accept request HTTP header advertises which content types, expressed"r" as MIME types, the client is able to understand. Using content"r" negotiation, the server then selects one of the proposals, uses it and"r" informs the client of its choice with the Content-Type response header."r" Browsers set adequate values for this header depending of the context"r" where the request is done: when fetching a CSS stylesheet a different"r" value is set for the request than when fetching an image, video or a"r" script."r" Advertises which character set the client is able to understand."r" The Accept-Charset request HTTP header advertises which character set"r" the client is able to understand. Using content negotiation, the server"r" then selects one of the proposals, uses it and informs the client of its"r" choice within the Content-Type response header. Browsers usually don't"r" set this header as the default value for each content type is usually"r" correct and transmitting it would allow easier fingerprinting."r" If the server cannot serve any matching character set, it can"r" theoretically send back a 406 (Not Acceptable) error code. But, for a"r" better user experience, this is rarely done and the more common way is"r" to ignore the Accept-Charset header in this case."r" Advertises which content encoding the client is able to understand."r" The Accept-Encoding request HTTP header advertises which content"r" encoding, usually a compression algorithm, the client is able to"r" understand. Using content negotiation, the server selects one of the"r" proposals, uses it and informs the client of its choice with the"r" Content-Encoding response header."r" Even if both the client and the server supports the same compression"r" algorithms, the server may choose not to compress the body of a"r" response, if the identity value is also acceptable. Two common cases"r" lead to this:"r" * The data to be sent is already compressed and a second compression"r" won't lead to smaller data to be transmitted. This may the case with"r" some image formats;"r" * The server is overloaded and cannot afford the computational overhead"r" induced by the compression requirement. Typically, Microsoft recommends"r" not to compress if a server use more than 80 % of its computational"r" power."r" As long as the identity value, meaning no compression, is not explicitly"r" forbidden, by an identity;q=0 or a *;q=0 without another explicitly set"r" value for identity, the server must never send back a 406 Not Acceptable"r" error."r" Advertises which languages the client is able to understand."r" The Accept-Language request HTTP header advertises which languages the"r" client is able to understand, and which locale variant is preferred."r" Using content negotiation, the server then selects one of the proposals,"r" uses it and informs the client of its choice with the Content-Language"r" response header. Browsers set adequate values for this header according"r" their user interface language and even if a user can change it, this"r" happens rarely (and is frown upon as it leads to fingerprinting)."r" This header is a hint to be used when the server has no way of"r" determining the language via another way, like a specific URL, that is"r" controlled by an explicit user decision. It is recommended that the"r" server never overrides an explicit decision. The content of the"r" Accept-Language is often out of the control of the user (like when"r" traveling and using an Internet Cafe in a different country); the user"r" may also want to visit a page in another language than the locale of"r" their user interface."r" If the server cannot serve any matching language, it can theoretically"r" send back a 406 (Not Acceptable) error code. But, for a better user"r" experience, this is rarely done and more common way is to ignore the"r" Accept-Language header in this case."r" Marker used by the server to advertise partial request support."r" The Accept-Ranges response HTTP header is a marker used by the server to"r" advertise its support of partial requests. The value of this field"r" indicates the unit that can be used to define a range."r" In presence of an Accept-Ranges header, the browser may try to resume an"r" interrupted download, rather than to start it from the start again."r" Preflight response indicating if the response to the request can be"r" exposed to the page."r" The Access-Control-Allow-Credentials response header indicates whether"r" or not the response to the request can be exposed to the page. It can be"r" exposed when the true value is returned; it can't in other cases."r" Credentials are cookies, authorization headers or TLS client"r" certificates."r" When used as part of a response to a preflight request, this indicates"r" whether or not the actual request can be made using credentials. Note"r" that simple GET requests are not preflighted, and so if a request is"r" made for a resource with credentials, if this header is not returned"r" with the resource, the response is ignored by the browser and not"r" returned to web content."r" The Access-Control-Allow-Credentials header works in conjunction with"r" the XMLHttpRequest.withCredentials property or with the credentials"r" option in the Request() constructor of the Fetch API. Credentials must"r" be set on both sides (the Access-Control-Allow-Credentials header and in"r" the XHR or Fetch request) in order for the CORS request with credentials"r" to succeed."r" Preflight response indicating permitted HTTP headers."r" The Access-Control-Allow-Headers response header is used in response to"r" a preflight request to indicate which HTTP headers will be available via"r" Access-Control-Expose-Headers when making the actual request."r" The simple headers, Accept, Accept-Language, Content-Language,"r" Content-Type (but only with a MIME type of its parsed value (ignoring"r" parameters) of either application/x-www-form-urlencoded,"r" multipart/form-data, or text/plain), are always available and don't need"r" to be listed by this header."r" This header is required if the request has an"r" Access-Control-Request-Headers header."r" Preflight header response indicating permitted access methods."r" The Access-Control-Allow-Methods response header specifies the method or"r" methods allowed when accessing the resource in response to a preflight"r" request."r" Indicates whether the response can be shared with resources with the"r" given origin."r" Indicates which headers can be exposed as part of the response by"r" listing their names."r" Indicates how long the results of a preflight request can be cached."r" Informs the server which HTTP headers will be used when an actual"r" request is made."r" Informs the server know which HTTP method will be used when the actual"r" Indicates the time in seconds the object has been in a proxy cache."r" The Age header is usually close to zero. If it is Age: 0, it was"r" probably just fetched from the origin server; otherwise It is usually"r" calculated as a difference between the proxy's current date and the Date"r" general header included in the HTTP response."r" Lists the set of methods support by a resource."r" This header must be sent if the server responds with a 405 Method Not"r" Allowed status code to indicate which request methods can be used. An"r" empty Allow header indicates that the resource allows no request"r" methods, which might occur temporarily for a given resource, for"r" example."r" Advertises the availability of alternate services to clients."r" Contains the credentials to authenticate a user agent with a server."r" Usually this header is included after the server has responded with a"r" 401 Unauthorized status and the WWW-Authenticate header."r" Specifies directives for caching mechanisms in both requests and"r" responses."r" Caching directives are unidirectional, meaning that a given directive in"r" a request is not implying that the same directive is to be given in the"r" response."r" Indicates how caches have handled a response and its corresponding request."r" See [RFC 9211](https://www.rfc-editor.org/rfc/rfc9211.html)."r" Specifies directives that allow origin servers to control the behavior of CDN caches"r" interposed between them and clients separately from other caches that might handle the"r" See [RFC 9213](https://www.rfc-editor.org/rfc/rfc9213.html)."r" Controls whether or not the network connection stays open after the"r" current transaction finishes."r" If the value sent is keep-alive, the connection is persistent and not"r" closed, allowing for subsequent requests to the same server to be done."r" Except for the standard hop-by-hop headers (Keep-Alive,"r" Transfer-Encoding, TE, Connection, Trailer, Upgrade, Proxy-Authorization"r" and Proxy-Authenticate), any hop-by-hop headers used by the message must"r" be listed in the Connection header, so that the first proxy knows he has"r" to consume them and not to forward them further. Standard hop-by-hop"r" headers can be listed too (it is often the case of Keep-Alive, but this"r" is not mandatory."r" Indicates if the content is expected to be displayed inline."r" In a regular HTTP response, the Content-Disposition response header is a"r" header indicating if the content is expected to be displayed inline in"r" the browser, that is, as a Web page or as part of a Web page, or as an"r" attachment, that is downloaded and saved locally."r" In a multipart/form-data body, the HTTP Content-Disposition general"r" header is a header that can be used on the subpart of a multipart body"r" to give information about the field it applies to. The subpart is"r" delimited by the boundary defined in the Content-Type header. Used on"r" the body itself, Content-Disposition has no effect."r" The Content-Disposition header is defined in the larger context of MIME"r" messages for e-mail, but only a subset of the possible parameters apply"r" to HTTP forms and POST requests. Only the value form-data, as well as"r" the optional directive name and filename, can be used in the HTTP"r" context."r" Used to compress the media-type."r" When present, its value indicates what additional content encoding has"r" been applied to the entity-body. It lets the client know, how to decode"r" in order to obtain the media-type referenced by the Content-Type header."r" It is recommended to compress data as much as possible and therefore to"r" use this field, but some types of resources, like jpeg images, are"r" already compressed.  Sometimes using additional compression doesn't"r" reduce payload size and can even make the payload longer."r" Used to describe the languages intended for the audience."r" This header allows a user to differentiate according to the users' own"r#" preferred language. For example, if "Content-Language: de-DE" is set, it"#r" says that the document is intended for German language speakers"r" (however, it doesn't indicate the document is written in German. For"r" example, it might be written in English as part of a language course for"r" German speakers)."r" If no Content-Language is specified, the default is that the content is"r" intended for all language audiences. Multiple language tags are also"r" possible, as well as applying the Content-Language header to various"r" media types and not only to textual documents."r" Indicates the size of the entity-body."r" The header value must be a decimal indicating the number of octets sent"r" to the recipient."r" Indicates an alternate location for the returned data."r" The principal use case is to indicate the URL of the resource"r" transmitted as the result of content negotiation."r" Location and Content-Location are different: Location indicates the"r" target of a redirection (or the URL of a newly created document), while"r" Content-Location indicates the direct URL to use to access the resource,"r" without the need of further content negotiation. Location is a header"r" associated with the response, while Content-Location is associated with"r" the entity returned."r" Indicates where in a full body message a partial message belongs."r" Allows controlling resources the user agent is allowed to load for a"r" given page."r" With a few exceptions, policies mostly involve specifying server origins"r" and script endpoints. This helps guard against cross-site scripting"r" attacks (XSS)."r" Allows experimenting with policies by monitoring their effects."r" The HTTP Content-Security-Policy-Report-Only response header allows web"r" developers to experiment with policies by monitoring (but not enforcing)"r" their effects. These violation reports consist of JSON documents sent"r" via an HTTP POST request to the specified URI."r" Used to indicate the media type of the resource."r" In responses, a Content-Type header tells the client what the content"r" type of the returned content actually is. Browsers will do MIME sniffing"r" in some cases and will not necessarily follow the value of this header;"r" to prevent this behavior, the header X-Content-Type-Options can be set"r" to nosniff."r" In requests, (such as POST or PUT), the client tells the server what"r" type of data is actually sent."r" Contains stored HTTP cookies previously sent by the server with the"r" Set-Cookie header."r" The Cookie header might be omitted entirely, if the privacy setting of"r" the browser are set to block them, for example."r" Indicates the client's tracking preference."r" This header lets users indicate whether they would prefer privacy rather"r" than personalized content."r" Contains the date and time at which the message was originated."r" Identifier for a specific version of a resource."r" This header allows caches to be more efficient, and saves bandwidth, as"r" a web server does not need to send a full response if the content has"r" not changed. On the other side, if the content has changed, etags are"r" useful to help prevent simultaneous updates of a resource from"r#" overwriting each other ("mid-air collisions")."#r" If the resource at a given URL changes, a new Etag value must be"r" generated. Etags are therefore similar to fingerprints and might also be"r" used for tracking purposes by some servers. A comparison of them allows"r" to quickly determine whether two representations of a resource are the"r" same, but they might also be set to persist indefinitely by a tracking"r" server."r" Indicates expectations that need to be fulfilled by the server in order"r" to properly handle the request."r" The only expectation defined in the specification is Expect:"r" 100-continue, to which the server shall respond with:"r" * 100 if the information contained in the header is sufficient to cause"r" an immediate success,"r" * 417 (Expectation Failed) if it cannot meet the expectation; or any"r" other 4xx status otherwise."r" For example, the server may reject a request if its Content-Length is"r" too large."r" No common browsers send the Expect header, but some other clients such"r" as cURL do so by default."r" Contains the date/time after which the response is considered stale."r" Invalid dates, like the value 0, represent a date in the past and mean"r" that the resource is already expired."r#" If there is a Cache-Control header with the "max-age" or "s-max-age""#r" directive in the response, the Expires header is ignored."r" Contains information from the client-facing side of proxy servers that"r" is altered or lost when a proxy is involved in the path of the request."r" The alternative and de-facto standard versions of this header are the"r" X-Forwarded-For, X-Forwarded-Host and X-Forwarded-Proto headers."r" This header is used for debugging, statistics, and generating"r" location-dependent content and by design it exposes privacy sensitive"r" information, such as the IP address of the client. Therefore the user's"r" privacy must be kept in mind when deploying this header."r" Contains an Internet email address for a human user who controls the"r" requesting user agent."r" If you are running a robotic user agent (e.g. a crawler), the From"r" header should be sent, so you can be contacted if problems occur on"r" servers, such as if the robot is sending excessive, unwanted, or invalid"r" requests."r" Specifies the domain name of the server and (optionally) the TCP port"r" number on which the server is listening."r" If no port is given, the default port for the service requested (e.g.,"r#" "80" for an HTTP URL) is implied."#r" A Host header field must be sent in all HTTP/1.1 request messages. A 400"r" (Bad Request) status code will be sent to any HTTP/1.1 request message"r" that lacks a Host header field or contains more than one."r" Makes a request conditional based on the E-Tag."r" For GET and HEAD methods, the server will send back the requested"r" resource only if it matches one of the listed ETags. For PUT and other"r" non-safe methods, it will only upload the resource in this case."r" The comparison with the stored ETag uses the strong comparison"r" algorithm, meaning two files are considered identical byte to byte only."r" This is weakened when the  W/ prefix is used in front of the ETag."r" There are two common use cases:"r" * For GET and HEAD methods, used in combination with an Range header, it"r" can guarantee that the new ranges requested comes from the same resource"r" than the previous one. If it doesn't match, then a 416 (Range Not"r" Satisfiable) response is returned."r" * For other methods, and in particular for PUT, If-Match can be used to"r" prevent the lost update problem. It can check if the modification of a"r" resource that the user wants to upload will not override another change"r" that has been done since the original resource was fetched. If the"r" request cannot be fulfilled, the 412 (Precondition Failed) response is"r" returned."r" Makes a request conditional based on the modification date."r" The If-Modified-Since request HTTP header makes the request conditional:"r" the server will send back the requested resource, with a 200 status,"r" only if it has been last modified after the given date. If the request"r" has not been modified since, the response will be a 304 without any"r" body; the Last-Modified header will contain the date of last"r" modification. Unlike If-Unmodified-Since, If-Modified-Since can only be"r" used with a GET or HEAD."r" When used in combination with If-None-Match, it is ignored, unless the"r" server doesn't support If-None-Match."r" The most common use case is to update a cached entity that has no"r" associated ETag."r" The If-None-Match HTTP request header makes the request conditional. For"r" GET and HEAD methods, the server will send back the requested resource,"r" with a 200 status, only if it doesn't have an ETag matching the given"r" ones. For other methods, the request will be processed only if the"r" eventually existing resource's ETag doesn't match any of the values"r" listed."r" When the condition fails for GET and HEAD methods, then the server must"r" return HTTP status code 304 (Not Modified). For methods that apply"r" server-side changes, the status code 412 (Precondition Failed) is used."r" Note that the server generating a 304 response MUST generate any of the"r" following header fields that would have been sent in a 200 (OK) response"r" to the same request: Cache-Control, Content-Location, Date, ETag,"r" Expires, and Vary."r" The comparison with the stored ETag uses the weak comparison algorithm,"r" meaning two files are considered identical not only if they are"r" identical byte to byte, but if the content is equivalent. For example,"r" two pages that would differ only by the date of generation in the footer"r" would be considered as identical."r" When used in combination with If-Modified-Since, it has precedence (if"r" the server supports it)."r" * For `GET` and `HEAD` methods, to update a cached entity that has an associated ETag."r" * For other methods, and in particular for `PUT`, `If-None-Match` used with"r" the `*` value can be used to save a file not known to exist,"r" guaranteeing that another upload didn't happen before, losing the data"r" of the previous put; this problems is the variation of the lost update"r" problem."r" Makes a request conditional based on range."r" The If-Range HTTP request header makes a range request conditional: if"r" the condition is fulfilled, the range request will be issued and the"r" server sends back a 206 Partial Content answer with the appropriate"r" body. If the condition is not fulfilled, the full resource is sent back,"r" with a 200 OK status."r" This header can be used either with a Last-Modified validator, or with"r" an ETag, but not with both."r" The most common use case is to resume a download, to guarantee that the"r" stored resource has not been modified since the last fragment has been"r" received."r" Makes the request conditional based on the last modification date."r" The If-Unmodified-Since request HTTP header makes the request"r" conditional: the server will send back the requested resource, or accept"r" it in the case of a POST or another non-safe method, only if it has not"r" been last modified after the given date. If the request has been"r" modified after the given date, the response will be a 412 (Precondition"r" Failed) error."r" * In conjunction non-safe methods, like POST, it can be used to"r" implement an optimistic concurrency control, like done by some wikis:"r" editions are rejected if the stored document has been modified since the"r" original has been retrieved."r" * In conjunction with a range request with a If-Range header, it can be"r" used to ensure that the new fragment requested comes from an unmodified"r" document."r" The Last-Modified header contains the date and time when the origin believes"r" the resource was last modified."r" The value is a valid Date/Time string defined in [RFC9910](https://datatracker.ietf.org/doc/html/rfc9110#section-5.6.7)"r" Allows the server to point an interested client to another resource"r" containing metadata about the requested resource."r" Indicates the URL to redirect a page to."r" The Location response header indicates the URL to redirect a page to. It"r" only provides a meaning when served with a 3xx status response."r" The HTTP method used to make the new request to fetch the page pointed"r" to by Location depends of the original method and of the kind of"r" redirection:"r" * If 303 (See Also) responses always lead to the use of a GET method,"r" 307 (Temporary Redirect) and 308 (Permanent Redirect) don't change the"r" method used in the original request;"r" * 301 (Permanent Redirect) and 302 (Found) doesn't change the method"r" most of the time, though older user-agents may (so you basically don't"r" know)."r" All responses with one of these status codes send a Location header."r" Beside redirect response, messages with 201 (Created) status also"r" include the Location header. It indicates the URL to the newly created"r" resource."r" target of a redirection (or the URL of a newly created resource), while"r" Content-Location indicates the direct URL to use to access the resource"r" when content negotiation happened, without the need of further content"r" negotiation. Location is a header associated with the response, while"r" Content-Location is associated with the entity returned."r" Indicates the max number of intermediaries the request should be sent"r" through."r" Indicates where a fetch originates from."r" It doesn't include any path information, but only the server name. It is"r" sent with CORS requests, as well as with POST requests. It is similar to"r" the Referer header, but, unlike this header, it doesn't disclose the"r" whole path."r" HTTP/1.0 header usually used for backwards compatibility."r" The Pragma HTTP/1.0 general header is an implementation-specific header"r" that may have various effects along the request-response chain. It is"r" used for backwards compatibility with HTTP/1.0 caches where the"r" Cache-Control HTTP/1.1 header is not yet present."r" Defines the authentication method that should be used to gain access to"r" a proxy."r" Unlike `www-authenticate`, the `proxy-authenticate` header field applies"r" only to the next outbound client on the response chain. This is because"r" only the client that chose a given proxy is likely to have the"r" credentials necessary for authentication. However, when multiple proxies"r" are used within the same administrative domain, such as office and"r" regional caching proxies within a large corporate network, it is common"r" for credentials to be generated by the user agent and passed through the"r" hierarchy until consumed. Hence, in such a configuration, it will appear"r" as if Proxy-Authenticate is being forwarded because each proxy will send"r" the same challenge set."r" The `proxy-authenticate` header is sent along with a `407 Proxy"r" Authentication Required`."r" Contains the credentials to authenticate a user agent to a proxy server."r" This header is usually included after the server has responded with a"r" 407 Proxy Authentication Required status and the Proxy-Authenticate"r" header."r" Associates a specific cryptographic public key with a certain server."r" This decreases the risk of MITM attacks with forged certificates. If one"r" or several keys are pinned and none of them are used by the server, the"r" browser will not accept the response as legitimate, and will not display"r" it."r" Sends reports of pinning violation to the report-uri specified in the"r" Unlike `Public-Key-Pins`, this header still allows browsers to connect"r" to the server if the pinning is violated."r" Indicates the part of a document that the server should return."r" Several parts can be requested with one Range header at once, and the"r" server may send back these ranges in a multipart document. If the server"r" sends back ranges, it uses the 206 Partial Content for the response. If"r" the ranges are invalid, the server returns the 416 Range Not Satisfiable"r" error. The server can also ignore the Range header and return the whole"r" document with a 200 status code."r" Contains the address of the previous web page from which a link to the"r" currently requested page was followed."r" The Referer header allows servers to identify where people are visiting"r" them from and may use that data for analytics, logging, or optimized"r" caching, for example."r" Governs which referrer information should be included with requests"r" made."r" Informs the web browser that the current page or frame should be"r" refreshed."r" The Retry-After response HTTP header indicates how long the user agent"r" should wait before making a follow-up request. There are two main cases"r" this header is used:"r" * When sent with a 503 (Service Unavailable) response, it indicates how"r" long the service is expected to be unavailable."r" * When sent with a redirect response, such as 301 (Moved Permanently),"r" it indicates the minimum time that the user agent is asked to wait"r" before issuing the redirected request."r" The |Sec-WebSocket-Accept| header field is used in the WebSocket"r" opening handshake. It is sent from the server to the client to"r" confirm that the server is willing to initiate the WebSocket"r" connection."r" The |Sec-WebSocket-Extensions| header field is used in the WebSocket"r" opening handshake. It is initially sent from the client to the"r" server, and then subsequently sent from the server to the client, to"r" agree on a set of protocol-level extensions to use for the duration"r" of the connection."r" The |Sec-WebSocket-Key| header field is used in the WebSocket opening"r" handshake. It is sent from the client to the server to provide part"r" of the information used by the server to prove that it received a"r" valid WebSocket opening handshake. This helps ensure that the server"r" does not accept connections from non-WebSocket clients (e.g., HTTP"r" clients) that are being abused to send data to unsuspecting WebSocket"r" servers."r" The |Sec-WebSocket-Protocol| header field is used in the WebSocket"r" opening handshake. It is sent from the client to the server and back"r" from the server to the client to confirm the subprotocol of the"r" connection.  This enables scripts to both select a subprotocol and be"r" sure that the server agreed to serve that subprotocol."r" The |Sec-WebSocket-Version| header field is used in the WebSocket"r" opening handshake.  It is sent from the client to the server to"r" indicate the protocol version of the connection.  This enables"r" servers to correctly interpret the opening handshake and subsequent"r" data being sent from the data, and close the connection if the server"r" cannot interpret that data in a safe manner."r" Contains information about the software used by the origin server to"r" handle the request."r" Overly long and detailed Server values should be avoided as they"r" potentially reveal internal implementation details that might make it"r" (slightly) easier for attackers to find and exploit known security"r" holes."r" Used to send cookies from the server to the user agent."r" Tells the client to communicate with HTTPS instead of using HTTP."r" Informs the server of transfer encodings willing to be accepted as part"r" of the response."r" See also the Transfer-Encoding response header for more details on"r" transfer encodings. Note that chunked is always acceptable for HTTP/1.1"r#" recipients and you that don't have to specify "chunked" using the TE"#r" header. However, it is useful for setting if the client is accepting"r#" trailer fields in a chunked transfer coding using the "trailers" value."#r" Allows the sender to include additional fields at the end of chunked"r" messages."r" Specifies the form of encoding used to safely transfer the entity to the"r" client."r" `transfer-encoding` is a hop-by-hop header, that is applying to a"r" message between two nodes, not to a resource itself. Each segment of a"r" multi-node connection can use different `transfer-encoding` values. If"r" you want to compress data over the whole connection, use the end-to-end"r" header `content-encoding` header instead."r" When present on a response to a `HEAD` request that has no body, it"r" indicates the value that would have applied to the corresponding `GET`"r" message."r" Contains a string that allows identifying the requesting client's"r" software."r" Used as part of the exchange to upgrade the protocol."r" Sends a signal to the server expressing the client’s preference for an"r" encrypted and authenticated response."r" Determines how to match future requests with cached responses."r" The `vary` HTTP response header determines how to match future request"r" headers to decide whether a cached response can be used rather than"r" requesting a fresh one from the origin server. It is used by the server"r" to indicate which headers it used when selecting a representation of a"r" resource in a content negotiation algorithm."r" The `vary` header should be set on a 304 Not Modified response exactly"r" like it would have been set on an equivalent 200 OK response."r" Added by proxies to track routing."r" The `via` general header is added by proxies, both forward and reverse"r" proxies, and can appear in the request headers and the response headers."r" It is used for tracking message forwards, avoiding request loops, and"r" identifying the protocol capabilities of senders along the"r" request/response chain."r" General HTTP header contains information about possible problems with"r" the status of the message."r" More than one `warning` header may appear in a response. Warning header"r" fields can in general be applied to any message, however some warn-codes"r" are specific to caches and can only be applied to response messages."r" a resource."r" Marker used by the server to indicate that the MIME types advertised in"r" the `content-type` headers should not be changed and be followed."r" This allows to opt-out of MIME type sniffing, or, in other words, it is"r" a way to say that the webmasters knew what they were doing."r" This header was introduced by Microsoft in IE 8 as a way for webmasters"r" to block content sniffing that was happening and could transform"r" non-executable MIME types into executable MIME types. Since then, other"r" browsers have introduced it, even if their MIME sniffing algorithms were"r" less aggressive."r" Site security testers usually expect this header to be set."r" Controls DNS prefetching."r" The `x-dns-prefetch-control` HTTP response header controls DNS"r" prefetching, a feature by which browsers proactively perform domain name"r" resolution on both links that the user may choose to follow as well as"r" URLs for items referenced by the document, including images, CSS,"r" JavaScript, and so forth."r" This prefetching is performed in the background, so that the DNS is"r" likely to have been resolved by the time the referenced items are"r" needed. This reduces latency when the user clicks a link."r" Indicates whether or not a browser should be allowed to render a page in"r" a frame."r" Sites can use this to avoid clickjacking attacks, by ensuring that their"r" content is not embedded into other sites."r" The added security is only provided if the user accessing the document"r" is using a browser supporting `x-frame-options`."r" Stop pages from loading when an XSS attack is detected."r" The HTTP X-XSS-Protection response header is a feature of Internet"r" Explorer, Chrome and Safari that stops pages from loading when they"r" detect reflected cross-site scripting (XSS) attacks. Although these"r" protections are largely unnecessary in modern browsers when sites"r" implement a strong Content-Security-Policy that disables the use of"r" inline JavaScript ('unsafe-inline'), they can still provide protections"r" for users of older web browsers that don't yet support CSP."TEST_HEADERStest_parse_standard_headerstest_standard_headers_into_bytes// Generate constants for all standard HTTP headers. This includes a static hash// code for the "fast hash" path. The hash code for static headers *do not* have// to match the text representation of those headers. This is because header// strings are always converted to the static values (when they match) before// being hashed. This means that it is impossible to compare the static hash// code of CONTENT_LENGTH with "content-length".HEADER_CHARS/// Valid header name characters/// ```not_rust///       field-name     = token///       separators     = "(" | ")" | "<" | ">" | "@"///                      | "," | ";" | ":" | "\" | <">///                      | "/" | "[" | "]" | "?" | "="///                      | "{" | "}" | SP | HT///       token          = 1*tchar///       tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"///                      / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"///                      / DIGIT / ALPHA///                      ; any VCHAR, except delimiters// HEADER_CHARS maps every byte that is 128 or larger to 0 so everything that is// mapped by HEADER_CHARS, maps to a valid single-byte UTF-8 codepoint.HEADER_CHARS_H2/// Valid header name characters for HTTP/2.0 and HTTP/3.0// HEADER_CHARS_H2 maps every byte that is 128 or larger to 0 so everything that is// mapped by HEADER_CHARS_H2, maps to a valid single-byte UTF-8 codepoint.parse_hdrSCRATCH_BUF_SIZE/// Converts a slice of bytes to an HTTP header name./// This function normalizes the input.from_lowercase/// This function expects the input to only contain lowercase characters./// This is useful when decoding HTTP/2.0 or HTTP/3.0 headers. Both/// require that all headers be represented in lower case./// // Parsing a lower case header/// let hdr = HeaderName::from_lowercase(b"content-length").unwrap();/// assert_eq!(CONTENT_LENGTH, hdr);/// // Parsing a header that contains uppercase characters/// assert!(HeaderName::from_lowercase(b"Content-Length").is_err());/// Converts a static string to a HTTP header name./// This function requires the static string to only contain lowercase/// characters, numerals and symbols, as per the HTTP/2.0 specification/// and header names internal representation within this library./// This function panics when the static string is a invalid header./// Until [Allow panicking in constants](https://github.com/rust-lang/rfcs/pull/2345)/// makes its way into stable, the panic message at compile-time is/// going to look cryptic, but should at least point at your header value:/// error: any use of this value will cause an error///     --> http/src/header/name.rs:1241:13///      |/// 1241 |             ([] as [u8; 0])[0]; // Invalid header name///      |             ^^^^^^^^^^^^^^^^^^///      |             |///      |             index out of bounds: the length is 0 but the index is 0///      |             inside `http::HeaderName::from_static` at http/src/header/name.rs:1241:13///      |             inside `INVALID_NAME` at src/main.rs:3:34///     ::: src/main.rs:3:1/// 3    | const INVALID_NAME: HeaderName = HeaderName::from_static("Capitalized");///      | ------------------------------------------------------------------------/// // Parsing a standard header/// let hdr = HeaderName::from_static("content-length");/// // Parsing a custom header/// let CUSTOM_HEADER: &'static str = "custom-header";/// let a = HeaderName::from_lowercase(b"custom-header").unwrap();/// let b = HeaderName::from_static(CUSTOM_HEADER);/// assert_eq!(a, b);/// // Parsing a header that contains invalid symbols(s):/// HeaderName::from_static("content{}{}length"); // This line panics!/// // Parsing a header that contains invalid uppercase characters./// let a = HeaderName::from_static("foobar");/// let b = HeaderName::from_static("FOOBAR"); // This line panics!// required for the panic circumvention/// Returns a `str` representation of the header./// The returned string will always be lower case./// Performs a case-insensitive comparison of the string against the header/// name/// use http::header::CONTENT_LENGTH;/// assert_eq!(CONTENT_LENGTH, "content-length");/// assert_eq!(CONTENT_LENGTH, "Content-Length");/// assert_ne!(CONTENT_LENGTH, "content length");// Precondition: if lower then buf is valid UTF-8eq_ignore_ascii_case// Assumes that the left hand side is already lower case// Utility functions for MaybeUninit<>. These are drawn from unstable API's on// MaybeUninit<> itself.SCRATCH_BUF_OVERFLOWuninit_u8_arrayslice_assume_init// Assuming all the elements are initialized, get a slice of them.// Safety: All elements of `slice` must be initialized to prevent// undefined behavior.test_parse_invalid_headersONE_TOO_LONGtest_invalid_name_lengthstest_static_invalid_name_lengthstest_from_hdr_nametest_eq_hdr_nametest_from_static_stdtest_from_static_std_uppercasetest_from_static_std_symboltest_from_static_custom_short// MaybeLower { lower: true }test_from_static_custom_short_uppercasetest_from_static_custom_short_symboltest_from_static_custom_long// MaybeLower { lower: false }test_from_static_custom_long_uppercasetest_from_static_custom_long_symboltest_from_static_custom_single_chartest_from_static_emptytest_all_tokenstest_from_lowercase// ===== HdrName =====// ===== Custom =====// ===== MaybeLower =====/// Represents an HTTP header field value./// In practice, HTTP header field values are usually valid ASCII. However, the/// HTTP spec allows for a header value to contain opaque bytes as well. In this/// case, the header field value is not able to be represented as a string./// To handle this, the `HeaderValue` is useable as a type and can be compared/// with strings and implements `Debug`. A `to_str` fn is provided that returns/// an `Err` if the header value contains non visible ascii characters./// A possible error when converting a `HeaderValue` from a string or byte/// A possible error when converting a `HeaderValue` to a string representation./// Header field values may contain opaque bytes, in which case it is not/// possible to represent the value as a string./// Convert a static string to a `HeaderValue`./// This function will not perform any copying, however the string is/// checked to ensure that no invalid characters are present. Only visible/// ASCII characters (32-127) are permitted./// This function panics if the argument contains invalid header value///   --> http/src/header/value.rs:67:17/// 67 |                 ([] as [u8; 0])[0]; // Invalid header value///    |                 ^^^^^^^^^^^^^^^^^^///    |                 |///    |                 index out of bounds: the length is 0 but the index is 0///    |                 inside `HeaderValue::from_static` at http/src/header/value.rs:67:17///    |                 inside `INVALID_HEADER` at src/main.rs:73:33///   ::: src/main.rs:73:1/// 73 | const INVALID_HEADER: HeaderValue = HeaderValue::from_static("жsome value");///    | ----------------------------------------------------------------------------/// # use http::header::HeaderValue;/// let val = HeaderValue::from_static("hello");/// assert_eq!(val, "hello");/// Attempt to convert a string to a `HeaderValue`./// If the argument contains invalid header value characters, an error is/// returned. Only visible ASCII characters (32-127) are permitted. Use/// `from_bytes` to create a `HeaderValue` that includes opaque octets/// (128-255)./// This function is intended to be replaced in the future by a `TryFrom`/// implementation once the trait is stabilized in std./// let val = HeaderValue::from_str("hello").unwrap();/// An invalid value/// let val = HeaderValue::from_str("\n");/// assert!(val.is_err());/// Converts a HeaderName into a HeaderValue/// Since every valid HeaderName is a valid HeaderValue this is done infallibly./// # use http::header::{HeaderValue, HeaderName};/// # use http::header::ACCEPT;/// let val = HeaderValue::from_name(ACCEPT);/// assert_eq!(val, HeaderValue::from_bytes(b"accept").unwrap());/// Attempt to convert a byte slice to a `HeaderValue`./// If the argument contains invalid header value bytes, an error is/// returned. Only byte values between 32 and 255 (inclusive) are permitted,/// excluding byte 127 (DEL)./// let val = HeaderValue::from_bytes(b"hello\xfa").unwrap();/// assert_eq!(val, &b"hello\xfa"[..]);/// let val = HeaderValue::from_bytes(b"\n");from_maybe_shared/// Attempt to convert a `Bytes` buffer to a `HeaderValue`./// This will try to prevent a copy if the type passed is the type used/// internally, and will copy the data if it is not.from_maybe_shared_unchecked/// Convert a `Bytes` directly into a `HeaderValue` without validating./// This function does NOT validate that illegal bytes are not contained/// within the buffer./// In a debug build this will panic if `src` is not valid UTF-8./// `src` must contain valid UTF-8. In a release build it is undefined/// behaviour to call this with `src` that is not valid UTF-8.from_sharedtry_from_generic/// Yields a `&str` slice if the `HeaderValue` only contains visible ASCII/// chars./// This function will perform a scan of the header value, checking all the/// assert_eq!(val.to_str().unwrap(), "hello");/// Returns the length of `self`./// This length is in bytes./// assert_eq!(val.len(), 5);/// Returns true if the `HeaderValue` has a length of zero bytes./// let val = HeaderValue::from_static("");/// assert!(val.is_empty());/// assert!(!val.is_empty());/// Converts a `HeaderValue` to a byte slice./// assert_eq!(val.as_bytes(), b"hello");/// Mark that the header value represents sensitive information./// let mut val = HeaderValue::from_static("my secret");/// val.set_sensitive(true);/// assert!(val.is_sensitive());/// val.set_sensitive(false);/// assert!(!val.is_sensitive());/// Returns `true` if the value represents sensitive data./// Sensitive data could represent passwords or other data that should not/// be stored on disk or in memory. By marking header values as sensitive,/// components using this crate can be instructed to treat them with special/// care for security reasons. For example, caches can avoid storing/// sensitive values, and HPACK encoders used by HTTP/2.0 implementations/// can choose not to compress them./// Additionally, sensitive values will be masked by the `Debug`/// implementation of `HeaderValue`./// Note that sensitivity is not factored into equality or ordering.from_integersfrom_isizeit_can_insert_header_name_as_header_valuefrom_header_name_testsit_converts_using_try_fromtry_from_header_name_testsis_visible_asciitest_try_from// ===== PartialEq / PartialOrd =====assert_send_syncrequest_satisfies_send_syncresponse_satisfies_send_sync//! A general purpose library of common HTTP types//! This crate is a general purpose library for common types found when working//! with the HTTP protocol. You'll find [`Request`] and [`Response`] types for//! working as either a client or a server as well as all of their components.//! Notably you'll find `Uri` for what a [`Request`] is requesting, a [`Method`]//! for how it's being requested, a [`StatusCode`] for what sort of response came//! back, a [`Version`] for how this was communicated, and//! [`HeaderName`]/[`HeaderValue`] definitions to get grouped in a [`HeaderMap`] to//! work with request/response headers.//! You will notably *not* find an implementation of sending requests or//! spinning up a server in this crate. It's intended that this crate is the//! "standard library" for HTTP clients and servers without dictating any//! particular implementation.//! ## Requests and Responses//! Perhaps the main two types in this crate are the [`Request`] and [`Response`]//! types. A [`Request`] could either be constructed to get sent off as a client//! or it can also be received to generate a [`Response`] for a server. Similarly//! as a client a [`Response`] is what you get after sending a [`Request`], whereas//! on a server you'll be manufacturing a [`Response`] to send back to the client.//! Each type has a number of accessors for the component fields. For as a//! server you might want to inspect a requests URI to dispatch it://! use http::{Request, Response};//! fn response(req: Request<()>) -> http::Result<Response<()>> {//!     match req.uri().path() {//!         "/" => index(req),//!         "/foo" => foo(req),//!         "/bar" => bar(req),//!         _ => not_found(req),//! # fn index(_req: Request<()>) -> http::Result<Response<()>> { panic!() }//! # fn foo(_req: Request<()>) -> http::Result<Response<()>> { panic!() }//! # fn bar(_req: Request<()>) -> http::Result<Response<()>> { panic!() }//! # fn not_found(_req: Request<()>) -> http::Result<Response<()>> { panic!() }//! On a [`Request`] you'll also find accessors like [`method`][Request::method] to return a//! [`Method`] and [`headers`][Request::method] to inspect the various headers. A [`Response`]//! has similar methods for headers, the status code, etc.//! In addition to getters, request/response types also have mutable accessors//! to edit the request/response://! use http::{HeaderValue, Response, StatusCode};//! use http::header::CONTENT_TYPE;//! fn add_server_headers<T>(response: &mut Response<T>) {//!     response.headers_mut()//!         .insert(CONTENT_TYPE, HeaderValue::from_static("text/html"));//!     *response.status_mut() = StatusCode::OK;//! And finally, one of the most important aspects of requests/responses, the//! body! The [`Request`] and [`Response`] types in this crate are *generic* in//! what their body is. This allows downstream libraries to use different//! representations such as `Request<Vec<u8>>`, `Response<impl Read>`,//! `Request<impl Stream<Item = Vec<u8>, Error = _>>`, or even//! `Response<MyCustomType>` where the custom type was deserialized from JSON.//! The body representation is intentionally flexible to give downstream//! libraries maximal flexibility in implementing the body as appropriate.//! ## HTTP Headers//! Another major piece of functionality in this library is HTTP header//! interpretation and generation. The `HeaderName` type serves as a way to//! define header *names*, or what's to the left of the colon. A `HeaderValue`//! conversely is the header *value*, or what's to the right of a colon.//! For example, if you have an HTTP request that looks like://! ```http//! GET /foo HTTP/1.1//! Accept: text/html//! Then `"Accept"` is a [`HeaderName`] while `"text/html"` is a [`HeaderValue`].//! Each of these is a dedicated type to allow for a number of interesting//! optimizations and to also encode the static guarantees of each type. For//! example a [`HeaderName`] is always a valid `&str`, but a [`HeaderValue`] may//! not be valid UTF-8.//! The most common header names are already defined for you as constant values//! in the [`header`] module of this crate. For example://! use http::header::{self, HeaderName};//! let name: HeaderName = header::ACCEPT;//! assert_eq!(name.as_str(), "accept");//! You can, however, also parse header names from strings://! let name = "Accept".parse::<HeaderName>().unwrap();//! assert_eq!(name, header::ACCEPT);//! Header values can be created from string literals through the [`from_static`][header::HeaderValue::from_static]//! function://! use http::HeaderValue;//! let value = HeaderValue::from_static("text/html");//! assert_eq!(value.as_bytes(), b"text/html");//! And header values can also be parsed like names://! let value = "text/html";//! let value = value.parse::<HeaderValue>().unwrap();//! Most HTTP requests and responses tend to come with more than one header, so//! it's not too useful to just work with names and values only! This crate also//! provides a [`HeaderMap`] type which is a specialized hash map for keys as//! [`HeaderName`] and generic values. This type, like header names, is optimized//! for common usage but should continue to scale with your needs over time.//! # URIs//! Each HTTP [`Request`] has an associated URI with it. This may just be a path//! like `/index.html` but it could also be an absolute URL such as//! `https://www.rust-lang.org/index.html`. A [`URI`][uri::Uri] has a number of accessors to//! interpret it://! use http::Uri;//! use http::uri::Scheme;//! let uri = "https://www.rust-lang.org/index.html".parse::<Uri>().unwrap();//! assert_eq!(uri.scheme(), Some(&Scheme::HTTPS));//! assert_eq!(uri.host(), Some("www.rust-lang.org"));//! assert_eq!(uri.path(), "/index.html");//! assert_eq!(uri.query(), None);AllocatedExtensionInlineExtension/// The Request Method (VERB)/// This type also contains constants for a number of common HTTP methods such/// as GET, POST, etc./// Currently includes 8 variants representing the 8 methods defined in/// [RFC 7230](https://tools.ietf.org/html/rfc7231#section-4.1), plus PATCH,/// and an Extension variant for all extensions./// use http::Method;/// assert_eq!(Method::GET, Method::from_bytes(b"GET").unwrap());/// assert!(Method::GET.is_idempotent());/// assert_eq!(Method::POST.as_str(), "POST");/// A possible error value when converting `Method` from bytes.ExtensionInline// If the extension is short enough, store it inlineExtensionAllocated// Otherwise, allocate it/// GET/// POST/// PUT/// DELETEHEAD/// HEADOPTIONSCONNECT/// CONNECTPATCH/// PATCHTRACE/// TRACE/// Converts a slice of bytes to an HTTP method.extension_inlineis_safe/// Whether a method is considered "safe", meaning the request is/// essentially read-only./// See [the spec](https://tools.ietf.org/html/rfc7231#section-4.2.1)/// for more words.is_idempotent/// Whether a method is considered "idempotent", meaning the request has/// the same result if executed multiple times./// See [the spec](https://tools.ietf.org/html/rfc7231#section-4.2.2) for/// more words./// Return a &str representation of the HTTP method// Invariant: the first self.1 bytes of self.0 are valid UTF-8.// Invariant: self.0 contains valid UTF-8.// Method::from_bytes() assumes this is at least 7METHOD_CHARS// From the RFC 9110 HTTP Semantics, section 9.1, the HTTP method is case-sensitive and can// contain the following characters:// method = token// token = 1*tchar// tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." ///     "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA// https://datatracker.ietf.org/doc/html/rfc9110#section-9.1// Note that this definition means that any &[u8] that consists solely of valid// characters is also valid UTF-8 because the valid method characters are a// subset of the valid 1 byte UTF-8 encoding.write_checked// write_checked ensures (among other things) that the first src.len() bytes// of dst are valid UTF-8test_method_eqtest_invalid_methodtest_is_idempotenttest_extension_methodtest_extension_method_chars//! The HTTP request method//! This module contains HTTP-method related structs and errors and such. The//! main type of this module, `Method`, is also reexported at the root of the//! crate as `http::Method` and is intended for import through that location//! primarily.//! use http::Method;//! assert_eq!(Method::GET, Method::from_bytes(b"GET").unwrap());//! assert!(Method::GET.is_idempotent());//! assert_eq!(Method::POST.as_str(), "POST");Parts/// Represents an HTTP request./// An HTTP request consists of a head and a potentially optional body. The body/// component is generic, enabling arbitrary types to represent the HTTP body./// For example, the body could be `Vec<u8>`, a `Stream` of byte chunks, or a/// value that has been deserialized./// Creating a `Request` to send/// use http::{Request, Response};/// let mut request = Request::builder()///     .uri("https://www.rust-lang.org/")///     .header("User-Agent", "my-awesome-agent/1.0");/// if needs_awesome_header() {///     request = request.header("Awesome", "yes");/// let response = send(request.body(()).unwrap());/// # fn needs_awesome_header() -> bool {/// fn send(req: Request<()>) -> Response<()> {/// # panic!()/// Inspecting a request to see what was sent./// use http::{Request, Response, StatusCode};/// fn respond_to(req: Request<()>) -> http::Result<Response<()>> {///     if req.uri() != "/awesome-url" {///         return Response::builder()///             .status(StatusCode::NOT_FOUND)///             .body(())///     let has_awesome_header = req.headers().contains_key("Awesome");///     let body = req.body();/// Deserialize a request of bytes via json:/// # extern crate serde;/// # extern crate serde_json;/// # extern crate http;/// use http::Request;/// use serde::de;/// fn deserialize<T>(req: Request<Vec<u8>>) -> serde_json::Result<Request<T>>///     where for<'de> T: de::Deserialize<'de>,///     let (parts, body) = req.into_parts();///     let body = serde_json::from_slice(&body)?;///     Ok(Request::from_parts(parts, body))/// Or alternatively, serialize the body of a request to json/// use serde::ser;/// fn serialize<T>(req: Request<T>) -> serde_json::Result<Request<Vec<u8>>>///     where T: ser::Serialize,///     let body = serde_json::to_vec(&body)?;/// The request's method/// The request's URI/// The request's version/// The request's headers/// The request's extensions/// Component parts of an HTTP `Request`/// The HTTP request head consists of a method, uri, version, and a set of/// header fields./// An HTTP request builder/// This type can be used to construct an instance or `Request`/// through a builder-like pattern./// Creates a new builder-style object to manufacture a `Request`/// This method returns an instance of `Builder` which can be used to/// create a `Request`./// # use http::*;/// let request = Request::builder()///     .method("GET")///     .header("X-Custom-Foo", "Bar")///     .body(())/// Creates a new `Builder` initialized with a GET method and the given URI./// let request = Request::get("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with a PUT method and the given URI./// let request = Request::put("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with a POST method and the given URI./// let request = Request::post("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with a DELETE method and the given URI./// let request = Request::delete("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with an OPTIONS method and the given URI./// let request = Request::options("https://www.rust-lang.org/")/// # assert_eq!(*request.method(), Method::OPTIONS);/// Creates a new `Builder` initialized with a HEAD method and the given URI./// let request = Request::head("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with a CONNECT method and the given URI./// let request = Request::connect("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with a PATCH method and the given URI./// let request = Request::patch("https://www.rust-lang.org/")/// Creates a new `Builder` initialized with a TRACE method and the given URI./// let request = Request::trace("https://www.rust-lang.org/")/// Creates a new blank `Request` with the body/// The component parts of this request will be set to their default, e.g./// the GET method, no headers, etc./// let request = Request::new("hello world");/// assert_eq!(*request.method(), Method::GET);/// assert_eq!(*request.body(), "hello world");from_parts/// Creates a new `Request` with the given components parts and body./// let (mut parts, body) = request.into_parts();/// parts.method = Method::POST;/// let request = Request::from_parts(parts, body);/// Returns a reference to the associated HTTP method./// let request: Request<()> = Request::default();method_mut/// Returns a mutable reference to the associated HTTP method./// let mut request: Request<()> = Request::default();/// *request.method_mut() = Method::PUT;/// assert_eq!(*request.method(), Method::PUT);/// Returns a reference to the associated URI./// assert_eq!(*request.uri(), *"/");uri_mut/// Returns a mutable reference to the associated URI./// *request.uri_mut() = "/hello".parse().unwrap();/// assert_eq!(*request.uri(), *"/hello");/// Returns the associated version./// assert_eq!(request.version(), Version::HTTP_11);version_mut/// Returns a mutable reference to the associated version./// *request.version_mut() = Version::HTTP_2;/// assert_eq!(request.version(), Version::HTTP_2);/// Returns a reference to the associated header field map./// assert!(request.headers().is_empty());headers_mut/// Returns a mutable reference to the associated header field map./// request.headers_mut().insert(HOST, HeaderValue::from_static("world"));/// assert!(!request.headers().is_empty());/// Returns a reference to the associated extensions./// assert!(request.extensions().get::<i32>().is_none());extensions_mut/// Returns a mutable reference to the associated extensions./// request.extensions_mut().insert("hello");/// assert_eq!(request.extensions().get(), Some(&"hello"));/// Returns a reference to the associated HTTP body./// let request: Request<String> = Request::default();/// assert!(request.body().is_empty());body_mut/// Returns a mutable reference to the associated HTTP body./// let mut request: Request<String> = Request::default();/// request.body_mut().push_str("hello world");/// assert!(!request.body().is_empty());into_body/// Consumes the request, returning just the body./// # use http::Request;/// let request = Request::new(10);/// let body = request.into_body();/// assert_eq!(body, 10);/// Consumes the request returning the head and body parts./// let request = Request::new(());/// let (parts, body) = request.into_parts();/// assert_eq!(parts.method, Method::GET);/// Consumes the request returning a new request with body mapped to the/// return type of the passed in function./// let request = Request::builder().body("some string").unwrap();/// let mapped_request: Request<&[u8]> = request.map(|b| {///   assert_eq!(b, "some string");///   b.as_bytes()/// assert_eq!(mapped_request.body(), &"some string".as_bytes());/// Creates a new default instance of `Parts`/// Creates a new default instance of `Builder` to construct a `Request`./// let req = request::Builder::new()///     .method("POST")/// Set the HTTP method for this request./// By default this is `GET`./// let req = Request::builder()method_ref/// Get the HTTP Method for this request./// By default this is `GET`. If builder has error, returns None./// let mut req = Request::builder();/// assert_eq!(req.method_ref(),Some(&Method::GET));/// req = req.method("POST");/// assert_eq!(req.method_ref(),Some(&Method::POST));/// Set the URI for this request./// By default this is `/`.uri_ref/// Get the URI for this request/// assert_eq!(req.uri_ref().unwrap(), "/" );/// req = req.uri("https://www.rust-lang.org/");/// assert_eq!(req.uri_ref().unwrap(), "https://www.rust-lang.org/" );/// Set the HTTP version for this request./// By default this is HTTP/1.1///     .version(Version::HTTP_2)version_ref/// Get the HTTP version for this request/// By default this is HTTP/1.1./// assert_eq!(req.version_ref().unwrap(), &Version::HTTP_11 );/// req = req.version(Version::HTTP_2);/// assert_eq!(req.version_ref().unwrap(), &Version::HTTP_2 );/// Appends a header to this request builder./// This function will append the provided key/value as a header to the/// internal `HeaderMap` being constructed. Essentially this is equivalent/// to calling `HeaderMap::append`.///     .header("Accept", "text/html")///     .header("X-Custom-Foo", "bar")headers_ref/// Get header on this request builder./// when builder has error returns None///     .header("X-Custom-Foo", "bar");/// let headers = req.headers_ref().unwrap();/// assert_eq!( headers["Accept"], "text/html" );/// assert_eq!( headers["X-Custom-Foo"], "bar" );/// Get headers on this request builder./// When builder has error returns None./// # use http::{header::HeaderValue, Request};///   let headers = req.headers_mut().unwrap();///   headers.insert("Accept", HeaderValue::from_static("text/html"));///   headers.insert("X-Custom-Foo", HeaderValue::from_static("bar"));/// Adds an extension to this builder///     .extension("My Extension")/// assert_eq!(req.extensions().get::<&'static str>(),///            Some(&"My Extension"));extensions_ref/// Get a reference to the extensions for this request builder./// If the builder has an error, this returns `None`./// let req = Request::builder().extension("My Extension").extension(5u32);/// let extensions = req.extensions_ref().unwrap();/// assert_eq!(extensions.get::<&'static str>(), Some(&"My Extension"));/// assert_eq!(extensions.get::<u32>(), Some(&5u32));/// Get a mutable reference to the extensions for this request builder./// let mut req = Request::builder().extension("My Extension");/// let mut extensions = req.extensions_mut().unwrap();/// extensions.insert(5u32);/// "Consumes" this builder, using the provided `body` to return a/// constructed `Request`./// This function may return an error if any previously configured argument/// failed to parse or get converted to the internal representation. For/// example if an invalid `head` was specified via `header("Foo",/// "Bar\r\n")` the error will be returned when this function is called/// rather than when `header` was called.it_can_map_a_body_from_one_type_to_another//! HTTP request types.//! This module contains structs related to HTTP requests, notably the//! `Request` type itself as well as a builder to create requests. Typically//! you'll import the `http::Request` type rather than reaching into this//! module itself.//! Creating a `Request` to send//! let mut request = Request::builder()//!     .uri("https://www.rust-lang.org/")//!     .header("User-Agent", "my-awesome-agent/1.0");//! if needs_awesome_header() {//!     request = request.header("Awesome", "yes");//! let response = send(request.body(()).unwrap());//! # fn needs_awesome_header() -> bool {//! #     true//! fn send(req: Request<()>) -> Response<()> {//! # panic!()//! Inspecting a request to see what was sent.//! use http::{Request, Response, StatusCode};//! fn respond_to(req: Request<()>) -> http::Result<Response<()>> {//!     if req.uri() != "/awesome-url" {//!         return Response::builder()//!             .status(StatusCode::NOT_FOUND)//!             .body(())//!     let has_awesome_header = req.headers().contains_key("Awesome");//!     let body = req.body();/// Represents an HTTP response/// An HTTP response consists of a head and a potentially optional body. The body/// Typically you'll work with responses on the client side as the result of/// sending a `Request` and on the server you'll be generating a `Response` to/// send back to the client./// Creating a `Response` to return///     let mut builder = Response::builder()///         .header("Foo", "Bar")///         .status(StatusCode::OK);///     if req.headers().contains_key("Another-Header") {///         builder = builder.header("Another-Header", "Ack");///     builder.body(())/// A simple 404 handler/// fn not_found(_req: Request<()>) -> http::Result<Response<()>> {///     Response::builder()///         .status(StatusCode::NOT_FOUND)///         .body(())/// Or otherwise inspecting the result of a request:/// fn get(url: &str) -> http::Result<Response<()>> {/// let response = get("https://www.rust-lang.org/").unwrap();/// if !response.status().is_success() {///     panic!("failed to get a successful response status!");/// if let Some(date) = response.headers().get("Date") {///     // we've got a `Date` header!/// let body = response.body();/// Deserialize a response of bytes via json:/// use http::Response;/// fn deserialize<T>(res: Response<Vec<u8>>) -> serde_json::Result<Response<T>>///     let (parts, body) = res.into_parts();///     Ok(Response::from_parts(parts, body))/// Or alternatively, serialize the body of a response to json/// fn serialize<T>(res: Response<T>) -> serde_json::Result<Response<Vec<u8>>>/// The response's status/// The response's version/// The response's headers/// The response's extensions/// Component parts of an HTTP `Response`/// The HTTP response head consists of a status, version, and a set of/// An HTTP response builder/// This type can be used to construct an instance of `Response` through a/// builder-like pattern./// Creates a new builder-style object to manufacture a `Response`/// create a `Response`./// let response = Response::builder()///     .status(200)/// Creates a new blank `Response` with the body/// The component parts of this response will be set to their default, e.g./// the ok status, no headers, etc./// let response = Response::new("hello world");/// assert_eq!(response.status(), StatusCode::OK);/// assert_eq!(*response.body(), "hello world");/// Creates a new `Response` with the given head and body/// let (mut parts, body) = response.into_parts();/// parts.status = StatusCode::BAD_REQUEST;/// let response = Response::from_parts(parts, body);/// assert_eq!(response.status(), StatusCode::BAD_REQUEST);/// Returns the `StatusCode`./// let response: Response<()> = Response::default();status_mut/// Returns a mutable reference to the associated `StatusCode`./// let mut response: Response<()> = Response::default();/// *response.status_mut() = StatusCode::CREATED;/// assert_eq!(response.status(), StatusCode::CREATED);/// Returns a reference to the associated version./// assert_eq!(response.version(), Version::HTTP_11);/// *response.version_mut() = Version::HTTP_2;/// assert_eq!(response.version(), Version::HTTP_2);/// assert!(response.headers().is_empty());/// response.headers_mut().insert(HOST, HeaderValue::from_static("world"));/// assert!(!response.headers().is_empty());/// assert!(response.extensions().get::<i32>().is_none());/// response.extensions_mut().insert("hello");/// assert_eq!(response.extensions().get(), Some(&"hello"));/// let response: Response<String> = Response::default();/// assert!(response.body().is_empty());/// let mut response: Response<String> = Response::default();/// response.body_mut().push_str("hello world");/// assert!(!response.body().is_empty());/// Consumes the response, returning just the body./// # use http::Response;/// let response = Response::new(10);/// let body = response.into_body();/// Consumes the response returning the head and body parts./// let (parts, body) = response.into_parts();/// assert_eq!(parts.status, StatusCode::OK);/// Consumes the response returning a new response with body mapped to the/// let response = Response::builder().body("some string").unwrap();/// let mapped_response: Response<&[u8]> = response.map(|b| {/// assert_eq!(mapped_response.body(), &"some string".as_bytes());/// Creates a new default instance of `Builder` to construct either a/// `Head` or a `Response`./// let response = response::Builder::new()/// Set the HTTP status for this response./// By default this is `200`./// Set the HTTP version for this response./// Appends a header to this response builder.///     .header("Content-Type", "text/html")///     .header("content-length", 0)/// Get header on this response builder./// let res = Response::builder()/// let headers = res.headers_ref().unwrap();/// # use http::response::Builder;/// let mut res = Response::builder();///   let headers = res.headers_mut().unwrap();/// assert_eq!(response.extensions().get::<&'static str>(),/// Get a reference to the extensions for this response builder./// let res = Response::builder().extension("My Extension").extension(5u32);/// let extensions = res.extensions_ref().unwrap();/// Get a mutable reference to the extensions for this response builder./// let mut res = Response::builder().extension("My Extension");/// let mut extensions = res.extensions_mut().unwrap();/// constructed `Response`.//! HTTP response types.//! This module contains structs related to HTTP responses, notably the//! `Response` type itself as well as a builder to create responses. Typically//! you'll import the `http::Response` type rather than reaching into this//! Creating a `Response` to return//!     let mut builder = Response::builder()//!         .header("Foo", "Bar")//!         .status(StatusCode::OK);//!     if req.headers().contains_key("Another-Header") {//!         builder = builder.header("Another-Header", "Ack");//!     builder.body(())//! A simple 404 handler//! fn not_found(_req: Request<()>) -> http::Result<Response<()>> {//!     Response::builder()//!         .status(StatusCode::NOT_FOUND)//!         .body(())//! Or otherwise inspecting the result of a request://! fn get(url: &str) -> http::Result<Response<()>> {//! let response = get("https://www.rust-lang.org/").unwrap();//! if !response.status().is_success() {//!     panic!("failed to get a successful response status!");//! if let Some(date) = response.headers().get("Date") {//!     // we've got a `Date` header!//! let body = response.body();/// An HTTP status code (`status-code` in RFC 9110 et al.)./// Constants are provided for known status codes, including those in the IANA/// [HTTP Status Code Registry](/// https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml)./// Status code values in the range 100-999 (inclusive) are supported by this/// type. Values in the range 100-599 are semantically classified by the most/// significant digit. See [`StatusCode::is_success`], etc. Values above 599/// are unclassified but allowed for legacy compatibility, though their use is/// discouraged. Applications may interpret such values as protocol errors./// use http::StatusCode;/// assert_eq!(StatusCode::from_u16(200).unwrap(), StatusCode::OK);/// assert_eq!(StatusCode::NOT_FOUND.as_u16(), 404);/// assert!(StatusCode::OK.is_success());/// A possible error value when converting a `StatusCode` from a `u16` or `&str`./// This error indicates that the supplied input was not a valid number, was less/// than 100, or was greater than 999./// Converts a u16 to a status code./// The function validates the correctness of the supplied u16. It must be/// greater or equal to 100 and less than 1000./// let ok = StatusCode::from_u16(200).unwrap();/// assert_eq!(ok, StatusCode::OK);/// let err = StatusCode::from_u16(99);/// Converts a `&[u8]` to a status code./// Returns the `u16` corresponding to this `StatusCode`./// This is the same as the `From<StatusCode>` implementation, but/// included as an inherent method because that implementation doesn't/// appear in rustdocs, as well as a way to force the type instead of/// relying on inference./// let status = http::StatusCode::OK;/// assert_eq!(status.as_u16(), 200);/// Returns a &str representation of the `StatusCode`/// The return value only includes a numerical representation of the/// status code. The canonical reason is not included./// assert_eq!(status.as_str(), "200");canonical_reason/// Get the standardised `reason-phrase` for this status code./// This is mostly here for servers writing responses, but could potentially have application/// at other times./// The reason phrase is defined as being exclusively for human readers. You should avoid/// deriving any meaning from it at all costs./// Bear in mind also that in HTTP/2.0 and HTTP/3.0 the reason phrase is abolished from/// transmission, and so this canonical reason phrase really is the only reason phrase you’ll/// find./// assert_eq!(status.canonical_reason(), Some("OK"));is_informational/// Check if status is within 100-199./// Check if status is within 200-299.is_redirection/// Check if status is within 300-399.is_client_error/// Check if status is within 400-499.is_server_error/// Check if status is within 500-599./// Formats the status code, *including* the canonical reason./// # use http::StatusCode;/// assert_eq!(format!("{}", StatusCode::OK), "200 OK");status_codesr" 100 Continue"r" [[RFC9110, Section 15.2.1](https://datatracker.ietf.org/doc/html/rfc9110#section-15.2.1)]"CONTINUEr" 101 Switching Protocols"r" [[RFC9110, Section 15.2.2](https://datatracker.ietf.org/doc/html/rfc9110#section-15.2.2)]"SWITCHING_PROTOCOLSr" 102 Processing"r" [[RFC2518, Section 10.1](https://datatracker.ietf.org/doc/html/rfc2518#section-10.1)]"PROCESSINGr" 200 OK"r" [[RFC9110, Section 15.3.1](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.1)]"r" 201 Created"r" [[RFC9110, Section 15.3.2](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.2)]"CREATEDr" 202 Accepted"r" [[RFC9110, Section 15.3.3](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.3)]"ACCEPTEDr" 203 Non-Authoritative Information"r" [[RFC9110, Section 15.3.4](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.4)]"NON_AUTHORITATIVE_INFORMATIONr" 204 No Content"r" [[RFC9110, Section 15.3.5](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.5)]"NO_CONTENTr" 205 Reset Content"r" [[RFC9110, Section 15.3.6](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.6)]"RESET_CONTENTr" 206 Partial Content"r" [[RFC9110, Section 15.3.7](https://datatracker.ietf.org/doc/html/rfc9110#section-15.3.7)]"PARTIAL_CONTENTr" 207 Multi-Status"r" [[RFC4918, Section 11.1](https://datatracker.ietf.org/doc/html/rfc4918#section-11.1)]"MULTI_STATUSr" 208 Already Reported"r" [[RFC5842, Section 7.1](https://datatracker.ietf.org/doc/html/rfc5842#section-7.1)]"ALREADY_REPORTEDr" 226 IM Used"r" [[RFC3229, Section 10.4.1](https://datatracker.ietf.org/doc/html/rfc3229#section-10.4.1)]"IM_USEDr" 300 Multiple Choices"r" [[RFC9110, Section 15.4.1](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.1)]"MULTIPLE_CHOICESr" 301 Moved Permanently"r" [[RFC9110, Section 15.4.2](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.2)]"MOVED_PERMANENTLYr" 302 Found"r" [[RFC9110, Section 15.4.3](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.3)]"FOUNDr" 303 See Other"r" [[RFC9110, Section 15.4.4](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.4)]"SEE_OTHERr" 304 Not Modified"r" [[RFC9110, Section 15.4.5](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.5)]"NOT_MODIFIEDr" 305 Use Proxy"r" [[RFC9110, Section 15.4.6](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.6)]"USE_PROXYr" 307 Temporary Redirect"r" [[RFC9110, Section 15.4.7](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.7)]"TEMPORARY_REDIRECTr" 308 Permanent Redirect"r" [[RFC9110, Section 15.4.8](https://datatracker.ietf.org/doc/html/rfc9110#section-15.4.8)]"PERMANENT_REDIRECTr" 400 Bad Request"r" [[RFC9110, Section 15.5.1](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.1)]"BAD_REQUESTr" 401 Unauthorized"r" [[RFC9110, Section 15.5.2](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.2)]"UNAUTHORIZEDr" 402 Payment Required"r" [[RFC9110, Section 15.5.3](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.3)]"PAYMENT_REQUIREDr" 403 Forbidden"r" [[RFC9110, Section 15.5.4](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.4)]"FORBIDDENr" 404 Not Found"r" [[RFC9110, Section 15.5.5](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.5)]"NOT_FOUNDr" 405 Method Not Allowed"r" [[RFC9110, Section 15.5.6](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.6)]"METHOD_NOT_ALLOWEDr" 406 Not Acceptable"r" [[RFC9110, Section 15.5.7](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.7)]"NOT_ACCEPTABLEr" 407 Proxy Authentication Required"r" [[RFC9110, Section 15.5.8](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.8)]"PROXY_AUTHENTICATION_REQUIREDr" 408 Request Timeout"r" [[RFC9110, Section 15.5.9](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.9)]"REQUEST_TIMEOUTr" 409 Conflict"r" [[RFC9110, Section 15.5.10](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.10)]"r" 410 Gone"r" [[RFC9110, Section 15.5.11](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.11)]"GONEr" 411 Length Required"r" [[RFC9110, Section 15.5.12](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.12)]"LENGTH_REQUIREDr" 412 Precondition Failed"r" [[RFC9110, Section 15.5.13](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.13)]"PRECONDITION_FAILEDr" 413 Payload Too Large"r" [[RFC9110, Section 15.5.14](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.14)]"PAYLOAD_TOO_LARGEr" 414 URI Too Long"r" [[RFC9110, Section 15.5.15](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.15)]"URI_TOO_LONGr" 415 Unsupported Media Type"r" [[RFC9110, Section 15.5.16](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.16)]"UNSUPPORTED_MEDIA_TYPEr" 416 Range Not Satisfiable"r" [[RFC9110, Section 15.5.17](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.17)]"RANGE_NOT_SATISFIABLEr" 417 Expectation Failed"r" [[RFC9110, Section 15.5.18](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.18)]"EXPECTATION_FAILEDr" 418 I'm a teapot"r" [curiously not registered by IANA but [RFC2324, Section 2.3.2](https://datatracker.ietf.org/doc/html/rfc2324#section-2.3.2)]"IM_A_TEAPOTr" 421 Misdirected Request"r" [[RFC9110, Section 15.5.20](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.20)]"MISDIRECTED_REQUESTr" 422 Unprocessable Entity"r" [[RFC9110, Section 15.5.21](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.21)]"UNPROCESSABLE_ENTITYr" 423 Locked"r" [[RFC4918, Section 11.3](https://datatracker.ietf.org/doc/html/rfc4918#section-11.3)]"r" 424 Failed Dependency"r" [[RFC4918, Section 11.4](https://tools.ietf.org/html/rfc4918#section-11.4)]"FAILED_DEPENDENCYr" 425 Too early"r" [[RFC8470, Section 5.2](https://httpwg.org/specs/rfc8470.html#status)]"TOO_EARLYr" 426 Upgrade Required"r" [[RFC9110, Section 15.5.22](https://datatracker.ietf.org/doc/html/rfc9110#section-15.5.22)]"UPGRADE_REQUIREDr" 428 Precondition Required"r" [[RFC6585, Section 3](https://datatracker.ietf.org/doc/html/rfc6585#section-3)]"PRECONDITION_REQUIREDr" 429 Too Many Requests"r" [[RFC6585, Section 4](https://datatracker.ietf.org/doc/html/rfc6585#section-4)]"TOO_MANY_REQUESTSr" 431 Request Header Fields Too Large"r" [[RFC6585, Section 5](https://datatracker.ietf.org/doc/html/rfc6585#section-5)]"REQUEST_HEADER_FIELDS_TOO_LARGEr" 451 Unavailable For Legal Reasons"r" [[RFC7725, Section 3](https://tools.ietf.org/html/rfc7725#section-3)]"UNAVAILABLE_FOR_LEGAL_REASONSr" 500 Internal Server Error"r" [[RFC9110, Section 15.6.1](https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.1)]"INTERNAL_SERVER_ERRORr" 501 Not Implemented"r" [[RFC9110, Section 15.6.2](https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.2)]"NOT_IMPLEMENTEDr" 502 Bad Gateway"r" [[RFC9110, Section 15.6.3](https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.3)]"BAD_GATEWAYr" 503 Service Unavailable"r" [[RFC9110, Section 15.6.4](https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.4)]"SERVICE_UNAVAILABLEr" 504 Gateway Timeout"r" [[RFC9110, Section 15.6.5](https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.5)]"GATEWAY_TIMEOUTr" 505 HTTP Version Not Supported"r" [[RFC9110, Section 15.6.6](https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.6)]"HTTP_VERSION_NOT_SUPPORTEDr" 506 Variant Also Negotiates"r" [[RFC2295, Section 8.1](https://datatracker.ietf.org/doc/html/rfc2295#section-8.1)]"VARIANT_ALSO_NEGOTIATESr" 507 Insufficient Storage"r" [[RFC4918, Section 11.5](https://datatracker.ietf.org/doc/html/rfc4918#section-11.5)]"INSUFFICIENT_STORAGEr" 508 Loop Detected"r" [[RFC5842, Section 7.2](https://datatracker.ietf.org/doc/html/rfc5842#section-7.2)]"LOOP_DETECTEDr" 510 Not Extended"r" [[RFC2774, Section 7](https://datatracker.ietf.org/doc/html/rfc2774#section-7)]"NOT_EXTENDEDr" 511 Network Authentication Required"r" [[RFC6585, Section 6](https://datatracker.ietf.org/doc/html/rfc6585#section-6)]"NETWORK_AUTHENTICATION_REQUIREDCODE_DIGITS// A string of packed 3-ASCII-digit status code values for the supported range// of [100, 999] (900 codes, 2700 bytes).//! HTTP status codes//! This module contains HTTP-status code related structs an errors. The main//! type in this module is `StatusCode` which is not intended to be used through//! this module but rather the `http::StatusCode` type.//! use http::StatusCode;//! assert_eq!(StatusCode::from_u16(200).unwrap(), StatusCode::OK);//! assert_eq!(StatusCode::NOT_FOUND, 404);//! assert!(StatusCode::OK.is_success());PortURI_CHARSAuthority/// Represents the authority component of a URI.// Not public while `bytes` is unstable./// Attempt to convert an `Authority` from a static string./// This function will not perform any copying, and the string will be/// checked if it is empty or contains an invalid character./// This function panics if the argument contains invalid characters or/// is empty./// # use http::uri::Authority;/// let authority = Authority::from_static("example.com");/// assert_eq!(authority.host(), "example.com");/// Attempt to convert a `Bytes` buffer to a `Authority`.// Note: this may return an *empty* Authority. You might want `parse_non_empty`.// Postcondition: for all Ok() returns, s[..ret.unwrap()] is valid UTF-8 where// ret is the return value.parse_non_empty// Parse bytes as an Authority, not allowing an empty string.// This should be used by functions that allow a user to parse// an `Authority` by itself./// Get the host of this `Authority`./// The host subcomponent of authority is identified by an IP literal/// encapsulated within square brackets, an IPv4 address in dotted- decimal/// form, or a registered name.  The host subcomponent is **case-insensitive**./// abc://username:password@example.com:123/path/data?key=value&key2=value2#fragid1///                         |---------|///                             host/// # use http::uri::*;/// let authority: Authority = "example.org:80".parse().unwrap();/// assert_eq!(authority.host(), "example.org");/// Get the port part of this `Authority`./// The port subcomponent of authority is designated by an optional port/// number following the host and delimited from it by a single colon (":")/// character. It can be turned into a decimal port number with the `as_u16`/// method or as a `str` with the `as_str` method.///                                     |-|///                                      |///                                     port/// Authority with port/// let port = authority.port().unwrap();/// assert_eq!(port.as_u16(), 80);/// assert_eq!(port.as_str(), "80");/// Authority without port/// let authority: Authority = "example.org".parse().unwrap();/// assert!(authority.port().is_none());port_u16/// Get the port of this `Authority` as a `u16`./// assert_eq!(authority.port_u16(), Some(80));/// Return a str representation of the authority/// Case-insensitive equality/// let authority: Authority = "HELLO.com".parse().unwrap();/// assert_eq!(authority, "hello.coM");/// assert_eq!("hello.com", authority);/// Case-insensitive ordering/// let authority: Authority = "DEF.com".parse().unwrap();/// assert!(authority < "ghi.com");/// assert!(authority > "abc.com");/// Case-insensitive hashing/// # use std::hash::{Hash, Hasher};/// # use std::collections::hash_map::DefaultHasher;/// let a: Authority = "HELLO.com".parse().unwrap();/// let b: Authority = "hello.coM".parse().unwrap();/// let mut s = DefaultHasher::new();/// a.hash(&mut s);/// let a = s.finish();/// b.hash(&mut s);/// let b = s.finish();create_authority// Precondition: f converts all of the bytes in the passed in B into the// returned Bytes.parse_empty_string_is_errorequal_to_self_of_same_authoritynot_equal_to_self_of_different_authorityequates_with_a_strfrom_static_equates_with_a_strnot_equal_with_a_str_of_a_different_authorityequates_with_a_stringequates_with_a_string_of_a_different_authoritycompares_to_selfcompares_with_a_strcompares_with_a_stringallows_percent_in_userinforejects_percent_in_hostnameallows_percent_in_ipv6_addressreject_obviously_invalid_ipv6_addressrejects_percent_outside_ipv6_addressrejects_invalid_utf8rejects_invalid_use_of_brackets// Purposefully not public while `bytes` is unstable.// impl TryFrom<Bytes> for AuthorityPathAndQuerySchemeparts/// A builder for `Uri`s./// This type can be used to construct an instance of `Uri`/// through a builder pattern./// Creates a new default instance of `Builder` to construct a `Uri`./// let uri = uri::Builder::new()///     .scheme("https")///     .authority("hyper.rs")///     .path_and_query("/")/// Set the `Scheme` for this URI./// let mut builder = uri::Builder::new();/// builder.scheme("https");authority/// Set the `Authority` for this URI.///     .authority("tokio.rs")path_and_query/// Set the `PathAndQuery` for this URI.///     .path_and_query("/hello?foo=bar")/// Consumes this builder, and tries to construct a valid `Uri` from/// the configured pieces./// example if an invalid `scheme` was specified via `scheme("!@#%/^")`/// the error will be returned when this function is called rather than/// when `scheme` was called./// Additionally, the various forms of URI require certain combinations of/// parts to be set to be valid. If the parts don't fit into any of the/// valid forms of URI, a new error is returned./// let uri = Uri::builder()build_from_strbuild_from_stringbuild_from_string_refbuild_from_uriScheme2/// The URI component of a request./// For HTTP 1, this is included as part of the request line. From Section 5.3,/// Request Target:/// > Once an inbound connection is obtained, the client sends an HTTP/// > request message (Section 3) with a request-target derived from the/// > target URI.  There are four distinct formats for the request-target,/// > depending on both the method being requested and whether the request/// > is to a proxy./// > ```notrust/// > request-target = origin-form/// >                / absolute-form/// >                / authority-form/// >                / asterisk-form/// > ```/// The URI is structured as follows:/// |-|   |-------------------------------||--------| |-------------------| |-----|///  |                  |                       |               |              |/// scheme          authority                 path            query         fragment/// For HTTP 2.0, the URI is encoded using pseudoheaders./// use http::Uri;/// let uri = "/foo/bar?baz".parse::<Uri>().unwrap();/// assert_eq!(uri.path(), "/foo/bar");/// assert_eq!(uri.query(), Some("baz"));/// assert_eq!(uri.host(), None);/// let uri = "https://www.rust-lang.org/install.html".parse::<Uri>().unwrap();/// assert_eq!(uri.scheme_str(), Some("https"));/// assert_eq!(uri.host(), Some("www.rust-lang.org"));/// assert_eq!(uri.path(), "/install.html");/// The scheme component of a URI/// The authority component of a URI/// The origin-form component of a URI/// Allow extending in the future/// The various parts of a URI./// This struct is used to provide to and retrieve from a URI./// An error resulting from a failed attempt to construct a URI.InvalidUriCharInvalidSchemeInvalidAuthorityInvalidPortSchemeMissingAuthorityMissingPathAndQueryMissingSchemeTooLongMAX_LEN// u16::MAX is reserved for None// URI_CHARS is a table of valid characters in a URI. An entry in the table is// 0 for invalid characters. For valid characters the entry is itself (i.e.// the entry for 33 is b'!' because b'!' == 33u8). An important characteristic// of this table is that all entries above 127 are invalid. This makes all of the// valid entries a valid single-byte UTF-8 code point. This means that a slice// of such valid entries is valid UTF-8./// Creates a new builder-style object to manufacture a `Uri`./// This method returns an instance of `Builder` which can be usd to/// create a `Uri`./// Attempt to convert a `Parts` into a `Uri`./// Relative URI/// let mut parts = Parts::default();/// parts.path_and_query = Some("/foo".parse().unwrap());/// let uri = Uri::from_parts(parts).unwrap();/// assert_eq!(uri.path(), "/foo");/// assert!(uri.scheme().is_none());/// assert!(uri.authority().is_none());/// Absolute URI/// parts.scheme = Some("http".parse().unwrap());/// parts.authority = Some("foo.com".parse().unwrap());/// assert_eq!(uri.scheme().unwrap().as_str(), "http");/// assert_eq!(uri.authority().unwrap(), "foo.com");/// Attempt to convert a `Bytes` buffer to a `Uri`./// Convert a `Uri` from a static string./// checked to ensure that it is valid./// This function panics if the argument is an invalid URI./// # use http::uri::Uri;/// let uri = Uri::from_static("http://example.com/foo");/// assert_eq!(uri.host().unwrap(), "example.com");/// Convert a `Uri` into `Parts`./// This is just an inherent method providing the same functionality as/// `let parts: Parts = uri.into()`/// let uri: Uri = "/foo".parse().unwrap();/// let parts = uri.into_parts();/// assert_eq!(parts.path_and_query.unwrap(), "/foo");/// assert!(parts.scheme.is_none());/// assert!(parts.authority.is_none());/// Returns the path & query components of the Uri/// Get the path of this `Uri`./// Both relative and absolute URIs contain a path component, though it/// might be the empty string. The path component is **case sensitive**.///                                        |--------|///                                             |///                                           path/// If the URI is `*` then the path component is equal to `*`./// A relative URI/// # use http::Uri;/// let uri: Uri = "/hello/world".parse().unwrap();/// assert_eq!(uri.path(), "/hello/world");/// An absolute URI/// let uri: Uri = "http://example.org/hello/world".parse().unwrap();/// Get the scheme of this `Uri`./// The URI scheme refers to a specification for assigning identifiers/// within that scheme. Only absolute URIs contain a scheme component, but/// not all absolute URIs will contain a scheme component.  Although scheme/// names are case-insensitive, the canonical form is lowercase./// |-|///  |/// scheme/// use http::uri::{Scheme, Uri};/// assert_eq!(uri.scheme(), Some(&Scheme::HTTP));scheme_str/// Get the scheme of this `Uri` as a `&str`./// assert_eq!(uri.scheme_str(), Some("http"));/// Get the authority of this `Uri`./// The authority is a hierarchical element for naming authority such that/// the remainder of the URI is delegated to that authority. For HTTP, the/// authority consists of the host and port. The host portion of the/// authority is **case-insensitive**./// The authority also includes a `username:password` component, however/// the use of this is deprecated and should be avoided.///       |-------------------------------|///                     |///                 authority/// let uri: Uri = "http://example.org:80/hello/world".parse().unwrap();/// assert_eq!(uri.authority().map(|a| a.as_str()), Some("example.org:80"));/// Get the host of this `Uri`./// assert_eq!(uri.host(), Some("example.org"));/// assert!(uri.host().is_none());/// Get the port part of this `Uri`./// Absolute URI with port/// let port = uri.port().unwrap();/// Absolute URI without port/// assert!(uri.port().is_none());/// Get the port of this `Uri` as a `u16`./// # use http::{Uri, uri::Port};/// assert_eq!(uri.port_u16(), Some(80));/// Get the query string of this `Uri`, starting after the `?`./// The query component contains non-hierarchical data that, along with data/// in the path component, serves to identify a resource within the scope of/// the URI's scheme and naming authority (if any). The query component is/// indicated by the first question mark ("?") character and terminated by a/// number sign ("#") character or by the end of the URI.///                                                   |-------------------|///                                                             |///                                                           query/// let uri: Uri = "http://example.org/hello/world?key=value".parse().unwrap();/// assert_eq!(uri.query(), Some("key=value"));/// Relative URI with a query string component/// let uri: Uri = "/hello/world?key=value&foo=bar".parse().unwrap();/// assert_eq!(uri.query(), Some("key=value&foo=bar"));/// Relative URI without a query string component/// assert!(uri.query().is_none());has_path/// Convert an `Authority` into a `Uri`./// Convert a `PathAndQuery` into a `Uri`./// Convert a `Uri` into `Parts`parse_full/// Returns a `Uri` representing `/`//! URI component of request and response lines//! This module primarily contains the `Uri` type which is a component of all//! HTTP requests and also reexports this type at the root of the crate. A URI//! is not always a "full URL" in the sense of something you'd type into a web//! browser, but HTTP requests may only have paths on servers but may have full//! schemes and hostnames on clients.//! let uri = "/foo/bar?baz".parse::<Uri>().unwrap();//! assert_eq!(uri.path(), "/foo/bar");//! assert_eq!(uri.query(), Some("baz"));//! assert_eq!(uri.host(), None);//! let uri = "https://www.rust-lang.org/install.html".parse::<Uri>().unwrap();//! assert_eq!(uri.scheme_str(), Some("https"));//! assert_eq!(uri.path(), "/install.html");/// Represents the path component of a URI/// Convert a `PathAndQuery` from a static string./// This function panics if the argument is an invalid path and query./// let v = PathAndQuery::from_static("/hello?world");/// assert_eq!(v.path(), "/hello");/// assert_eq!(v.query(), Some("world"));/// Attempt to convert a `Bytes` buffer to a `PathAndQuery`./// Returns the path component/// The path component is **case sensitive**./// let path_and_query: PathAndQuery = "/hello/world".parse().unwrap();/// assert_eq!(path_and_query.path(), "/hello/world");/// Returns the query string component/// With a query string component/// let path_and_query: PathAndQuery = "/hello/world?key=value&foo=bar".parse().unwrap();/// assert_eq!(path_and_query.query(), Some("key=value&foo=bar"));/// Without a query string component/// assert!(path_and_query.query().is_none());/// Returns the path and query as a string component./// assert_eq!(path_and_query.as_str(), "/hello/world?key=value&foo=bar");/// assert_eq!(path_and_query.as_str(), "/hello/world");equal_to_self_of_same_pathnot_equal_to_self_of_different_pathnot_equal_with_a_str_of_a_different_pathnot_equal_with_a_string_of_a_different_pathignores_valid_percent_encodingsignores_invalid_percent_encodingsallow_utf8_in_pathallow_utf8_in_queryrejects_invalid_utf8_in_pathrejects_invalid_utf8_in_queryjson_is_finepq/// The port component of a URI./// Returns the port number as a `u16`./// Port as `u16`./// Converts a `str` to a port number./// The supplied `str` must be a valid u16./// Returns the port number as a `str`./// Port as `str`.partialeq_portpartialeq_port_different_reprspartialeq_u16u16_from_port/// Represents the scheme component of a URIHttpsHTTP/// HTTP protocol schemeHTTPS/// HTTP protocol over TLS./// Return a str representation of the scheme/// let scheme: Scheme = "http".parse().unwrap();/// assert_eq!(scheme.as_str(), "http");/// # use http::uri::Scheme;/// let scheme: Scheme = "HTTP".parse().unwrap();/// assert_eq!(scheme, *"http");MAX_SCHEME_LEN// Require the scheme to not be too long in order to enable further// optimizations later.SCHEME_CHARS// scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )// SCHEME_CHARS is a table of valid characters in the scheme part of a URI.  An// entry in the table is 0 for invalid characters. For valid characters the// entry is itself (i.e.  the entry for 43 is b'+' because b'+' == 43u8). An// important characteristic of this table is that all entries above 127 are// invalid. This makes all of the valid entries a valid single-byte UTF-8 code// point. This means that a slice of such valid entries is valid UTF-8.parse_exact// Postcondition: On all Ok() returns, s is valid UTF-8scheme_eq_to_strinvalid_scheme_is_errortest_char_tableparttest_parsetest_uri_parse_path_and_querytest_uri_parse_absolute_formtest_uri_parse_absolute_form_without_pathtest_uri_parse_asterisk_formtest_uri_parse_authority_no_porttest_uri_authority_only_one_character_issue_197test_uri_parse_authority_formtest_uri_parse_absolute_with_default_port_httptest_uri_parse_absolute_with_default_port_httpstest_uri_parse_fragment_questionmarktest_uri_parse_path_with_terminating_questionmarktest_uri_parse_absolute_form_with_empty_path_and_nonempty_querytest_uri_parse_absolute_form_with_empty_path_and_fragment_with_slashtest_uri_parse_absolute_form_with_empty_path_and_fragment_with_questionmarktest_uri_parse_long_host_with_no_schemetest_uri_parse_long_host_with_port_and_no_schemetest_userinfo1test_userinfo2test_userinfo3test_userinfo_with_porttest_userinfo_pass_with_porttest_ipv6test_ipv6_shorthandtest_ipv6_shorthand2test_ipv6_shorthand3test_ipv6_with_porttest_percentage_encoded_pathtest_path_permissivetest_query_permissivetest_uri_parse_errortest_max_uri_lentest_overflowing_schemetest_max_length_schemetest_uri_to_path_and_querytest_authority_uri_parts_round_triptest_partial_eq_path_with_terminating_questionmark/// Represents a version of the HTTP spec.HTTP_09/// `HTTP/0.9`HTTP_10/// `HTTP/1.0`HTTP_11/// `HTTP/1.1`HTTP_2/// `HTTP/2.0`HTTP_3/// `HTTP/3.0`Http09Http10Http11//! HTTP version//! This module contains a definition of the `Version` type. The `Version`//! type is intended to be accessed through the root of the crate//! (`http::Version`) rather than this module.//! The `Version` type contains constants that represent the various versions//! of the HTTP protocol.//! use http::Version;//! let http11 = Version::HTTP_11;//! let http2 = Version::HTTP_2;//! assert!(http11 != http2);//! println!("{:?}", http2);/// A frame of any kind related to an HTTP stream (body).// The first two variants are "inlined" since they are undoubtedly// the most common. This saves us from having to allocate a// boxed trait object for them.Trailers//Unknown(Box<dyn Frameish>),/// Create a DATA frame with the provided `Buf`./// Create a trailers frame./// Maps this frame's data to a different type./// Returns whether this is a DATA frame./// Consumes self into the buf of the DATA frame./// Returns an [`Err`] containing the original [`Frame`] when frame is not a DATA frame./// `Frame::is_data` can also be used to determine if the frame is a DATA frame.data_ref/// If this is a DATA frame, returns a reference to it./// Returns `None` if not a DATA frame./// If this is a DATA frame, returns a mutable reference to it.is_trailers/// Returns whether this is a trailers frame.into_trailers/// Consumes self into the buf of the trailers frame./// Returns an [`Err`] containing the original [`Frame`] when frame is not a trailers frame./// `Frame::is_trailers` can also be used to determine if the frame is a trailers frame.trailers_ref/// If this is a trailers frame, returns a reference to it./// Returns `None` if not a trailers frame.trailers_mut/// If this is a trailers frame, returns a mutable reference to it.SizeHint/// Values yielded by the `Body`./// The error type this `Body` might generate./// Attempt to pull out the next data buffer of this stream.is_end_stream/// Returns `true` when the end of stream has been reached./// An end of stream means that `poll_frame` will return `None`./// A return value of `false` **does not** guarantee that a value will be/// returned from `poll_frame`./// When the **exact** remaining length of the stream is known, the upper bound will be set and/// will equal the lower bound./// Trait representing a streaming body of a Request or Response./// Individual frames are streamed via the `poll_frame` function, which asynchronously yields/// instances of [`Frame<Data>`]./// Frames can contain a data buffer of type `Self::Data`. Frames can also contain an optional/// set of trailers used to finalize the request/response exchange. This is mostly used when using/// the HTTP/2.0 protocol./// The `size_hint` function provides insight into the total number of bytes that will be streamed._assert_bounds//! Asynchronous HTTP request or response body.//! See [`Body`] for more details.//! [`Body`]: trait.Body.html/// A `Body` size hint/// The default implementation returns:/// * 0 for `lower`/// * `None` for `upper`./// Returns a new `SizeHint` with default valueswith_exact/// Returns a new `SizeHint` with both upper and lower bounds set to the/// Returns the lower bound of data that the `Body` will yield before/// completing./// Set the value of the `lower` hint./// The function panics if `value` is greater than `upper`./// Returns the upper bound of data the `Body` will yield before/// completing, or `None` if the value is unknown./// Set the value of the `upper` hint value./// This function panics if `value` is less than `lower`./// Returns the exact size of data that will be yielded **if** the/// `lower` and `upper` bounds are equal.set_exact/// Set the value of the `lower` and `upper` bounds to exactly the same./// Create a new channel body./// The channel will buffer up to the provided number of messages. Once the buffer is full,/// attempts to send new messages will wait until a message is received from the channel. The/// provided buffer capacity must be at least 1.tx_frametx_error/// A sender half created through [`Channel::new`]./// Send a frame on the channel.send_data/// Send data on data channel.send_trailers/// Send trailers on trailers channel./// Attempts to send a frame on this channel./// This function returns the unsent frame back as an `Err(_)` if the channel could not/// (currently) accept another frame./// This is mostly useful for when trying to send a frame from outside of an asynchronous/// context. If in an async context, prefer [`Sender::send_data()`] instead./// Returns the current capacity of the channel./// The capacity goes down when [`Frame<T>`]s are sent. The capacity goes up when these frames/// are received by the corresponding [`Channel<D, E>`]. This is distinct from/// [`max_capacity()`][Self::max_capacity], which always returns the buffer capacity initially/// specified when [`Channel::new()`][Channel::new] was called./// use http_body_util::{BodyExt, channel::Channel};/// #[tokio::main]/// async fn main() {///    let (mut tx, mut body) = Channel::<Bytes, Infallible>::new(4);///    assert_eq!(tx.capacity(), 4);///    // Sending a value decreases the available capacity.///    tx.send_data(Bytes::from("Hel")).await.unwrap();///    assert_eq!(tx.capacity(), 3);///    // Reading a value increases the available capacity.///    let _ = body.frame().await;max_capacity/// Returns the maximum capacity of the channel./// This function always returns the buffer capacity initially specified when/// [`Channel::new()`][Channel::new] was called. This is distinct from/// [`capacity()`][Self::capacity], which returns the currently available capacity.///    assert_eq!(tx.max_capacity(), 4);///    // Sending a value buffers it, but does not affect the maximum capacity reported./// Aborts the body in an abnormal fashion./// The error returned if [`Sender`] fails to send because the receiver is closed.BodyExtcan_send_datacan_send_trailerscan_send_both_data_and_trailerstry_send_works/// A stand-in for an error type, for unit tests./// An example error message.aborts_before_trailersaborts_after_trailers//! A body backed by a channel.BufListCollected/// A collected body produced by [`BodyExt::collect`] which collects all the DATA frames/// and trailers./// [`BodyExt::collect`]: crate::BodyExt::collect/// If there is a trailers frame buffered, returns a reference to it./// Returns `None` if the body contained no trailers./// Aggregate this buffered into a [`Buf`]./// Convert this body into a [`Bytes`].push_frameStreamBodyfull_bodysegmented_bodydelayed_segmentsempty_frame/// Test for issue [#88](https://github.com/hyperium/http-body/issues/88).BoxBody/// A boxed [`Body`] trait object.UnsyncBoxBody/// A boxed [`Body`] trait object that is !Sync./// Create a new `BoxBody`./// Create a new `UnsyncBoxBody`.// === UnsyncBoxBody ===r" Future that resolves into a [`Collected`]."r" [`Collected`]: crate::Collected"collected"futures don't do anything unless polled"/// Future that resolves to the next frame from a [`Body`].r" Body returned by the [`map_err`] combinator."r" [`map_err`]: crate::BodyExt::map_err"/// Get a reference to the inner body/// Get a mutable reference to the inner body/// Get a pinned mutable reference to the inner body/// Consume `self`, returning the inner bodyr" Body returned by the [`map_frame`] combinator."r" [`map_frame`]: crate::BodyExt::map_frame"MapFramebox_bodymap_framewith_trailersWithTrailers//! Combinators for the `Body` trait.r" Adds trailers to a body."r" See [`BodyExt::with_trailers`] for more details."PollBodyprev_trailersPollTrailersStateProjworksmerges_trailersunwrap_readyprojEitherProj/// A value of type `L`/// A value of type `R`/// Sum type with two cases: [`Left`] and [`Right`], used if a body can be one of/// two distinct types./// [`Left`]: Either::Left/// [`Right`]: Either::Rightproject/// This function is part of the generated code from `pin-project-lite`,/// for a more in depth explanation and the rest of the generated code refer/// to the [`proj`] module./// Convert [`Either`] into the inner type, if both `Left` and `Right` are/// of the same type.//! This code is the (cleaned output) generated by [pin-project-lite], as it//! does not support tuple variants.//! This is the altered expansion from the following snippet, expanded by//! `cargo-expand`://! use pin_project_lite::pin_project;//! pin_project! {//!     #[project = EitherProj]//!     pub enum Either<L, R> {//!         Left {#[pin] left: L},//!         Right {#[pin] right: R}//! [pin-project-lite]: https://docs.rs/pin-project-lite/latest/pin_project_lite/data_leftdata_right/// A body that is always empty./// Create a new `Empty`.r" A body that consists of a single chunk."/// Create a new `Full`./// Create an empty `Full`.full_returns_someempty_full_returns_nonecombinatorslimitedLengthLimitErrorBodyDataStreamBodyStream/// Returns a future that resolves to the next [`Frame`], if any./// [`Frame`]: combinators::Frame/// Maps this body's frame to a different kind./// Maps this body's error value to a different value./// Turn this body into a boxed trait object.boxed_unsync/// Turn this body into a boxed trait object that is !Sync./// Turn this body into [`Collected`] body which will collect all the DATA frames/// Add trailers to the body./// The trailers will be sent when all previous frames have been sent and the `trailers` future/// resolves./// use http_body_util::{Full, BodyExt};/// # #[tokio::main]/// let (tx, rx) = tokio::sync::oneshot::channel::<HeaderMap>();/// let body = Full::<Bytes>::from("Hello, World!")///     // add trailers via a future///     .with_trailers(async move {///         match rx.await {///             Ok(trailers) => Some(Ok(trailers)),///             Err(_err) => None,/// // compute the trailers in the background/// tokio::spawn(async move {///     let _ = tx.send(compute_trailers().await);/// async fn compute_trailers() -> HeaderMap {into_data_stream/// Turn this body into [`BodyDataStream`]./// An extension trait for [`http_body::Body`] adding various combinators and adapters//! Utilities for [`http_body::Body`].//! [`BodyExt`] adds extensions to the common trait.//! [`Empty`] and [`Full`] provide simple implementations.r" A length limited body."r" This body will return an error if more than the configured number"r" of bytes are returned on polling the wrapped body."/// Create a new `Limited`./// An error returned when body length exceeds the configured limit.read_for_body_under_limit_returns_dataread_for_body_over_limit_returns_errorbody_from_iterread_for_chunked_body_around_limit_returns_first_chunk_but_returns_error_on_over_limit_chunkread_for_chunked_body_over_limit_on_first_chunk_returns_errorread_for_chunked_body_under_limit_is_okaySomeTrailersread_for_trailers_propagates_inner_trailersErrorBodyErrorErrorBodyread_for_body_returning_error_propagates_errorr" A body created from a [`Stream`]."/// Create a new `StreamBody`.r" A stream created from a [`Body`]."/// Create a new `BodyStream`.r" A data stream created from a [`Body`]."/// Create a new `BodyDataStream`body_from_streamstream_from_bodyhello_world_bufto_bytes_shorterto_bytes_eqto_bytes_longerone_long_buf_to_bytesbuf_to_bytes_too_manyenable_new_featuresenable_simdvar_is/// INVARIANT: start <= cursor && cursor <= endpeek_ahead/// Peek at byte `n` ahead of cursor/// Caller must ensure that `n <= self.len()`, otherwise `self.cursor.add(n)` is UB./// That means there are at least `n-1` bytes between `self.cursor` and `self.end`/// and `self.cursor.add(n)` is either `self.end` or points to a valid byte.peek_nbump/// Advance by 1, equivalent to calling `advance(1)`./// Caller must ensure that Bytes hasn't been advanced/bumped by more than [`Bytes::len()`]./// Advance cursor by `n`slice_skip// TODO: this is an anti-pattern, should be removed/// Deprecated. Do not use!/// Caller must ensure that `skip` is at most the number of advances (i.e., `bytes.advance(3)`/// implies a skip of at most 3).advance_and_commit/// see [`Bytes::advance`] safety comment./// Must ensure invariant `bytes.start() <= ptr && ptr <= bytes.end()`.slice_from_ptr_range/// Must ensure start and end point to the same memory object to uphold memory safety.simdparse_method_benchable// Expose some internal functions so we can bench them individually// WARNING: Exported for internal benchmarks, not fit for public consumptionis_method_token/// Determines if byte is a method token char./// > token          = 1*tchar/// > tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"/// >                / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"/// >                / DIGIT / ALPHA/// >                ; any VCHAR, except delimitersURI_MAP// char codes to accept URI string.// i.e. b'!' <= char and char != 127// TODO: Make a stricter checking for URI string?is_uri_tokenTOKEN_MAPis_header_name_tokenHEADER_VALUE_MAPis_header_value_token/// Invalid byte in header name./// Invalid byte in header value.NewLine/// Invalid byte in new line./// Invalid byte in Response status./// Invalid byte where token is required.TooManyHeaders/// Parsed more headers than provided buffer can contain./// Invalid byte in HTTP version./// An error in parsing.description_strInvalidChunkSize/// An error in parsing a chunk size.// Note: Move this into the error enum once v2.0 is released./// A Result of any parsing action./// If the input is invalid, an `Error` will be returned. Note that incomplete/// data is not considered invalid, and so will not return an error, but rather/// a `Ok(Status::Partial)`./// The completed result./// A partial result./// The result of a successful parse pass./// `Complete` is used when the buffer contained the complete value./// `Partial` is used when parsing did not reach the end of the expected value,/// but no invalid data was found./// Convenience method to check if status is complete.is_partial/// Convenience method to check if status is partial./// Convenience method to unwrap a Complete value. Panics if the status is/// `Partial`.allow_spaces_after_header_name_in_responsesallow_obsolete_multiline_headers_in_responsesallow_multiple_spaces_in_request_line_delimitersallow_multiple_spaces_in_response_status_delimitersallow_space_before_first_header_nameignore_invalid_headers_in_responsesignore_invalid_headers_in_requestsParserConfig/// Parser configuration./// Sets whether spaces and tabs should be allowed after header names in responses./// Sets whether multiple spaces are allowed as delimiters in request lines./// # Background/// The [latest version of the HTTP/1.1 spec][spec] allows implementations to parse multiple/// whitespace characters in place of the `SP` delimiters in the request line, including:/// > SP, HTAB, VT (%x0B), FF (%x0C), or bare CR/// This option relaxes the parser to allow for multiple spaces, but does *not* allow the/// request line to contain the other mentioned whitespace characters./// [spec]: https://httpwg.org/http-core/draft-ietf-httpbis-messaging-latest.html#rfc.section.3.p.3multiple_spaces_in_request_line_delimiters_are_allowed/// Whether multiple spaces are allowed as delimiters in request lines./// Sets whether multiple spaces are allowed as delimiters in response status lines./// whitespace characters in place of the `SP` delimiters in the response status line,/// including:/// This option relaxes the parser to allow for multiple spaces, but does *not* allow the status/// line to contain the other mentioned whitespace characters./// [spec]: https://httpwg.org/http-core/draft-ietf-httpbis-messaging-latest.html#rfc.section.4.p.3multiple_spaces_in_response_status_delimiters_are_allowed/// Whether multiple spaces are allowed as delimiters in response status lines./// Sets whether obsolete multiline headers should be allowed./// This is an obsolete part of HTTP/1. Use at your own risk. If you are/// building an HTTP library, the newlines (`\r` and `\n`) should be/// replaced by spaces before handing the header value to the user./// let buf = b"HTTP/1.1 200 OK\r\nFolded-Header: hello\r\n there \r\n\r\n";/// let mut headers = [httparse::EMPTY_HEADER; 16];/// let mut response = httparse::Response::new(&mut headers);/// let res = httparse::ParserConfig::default()///     .allow_obsolete_multiline_headers_in_responses(true)///     .parse_response(&mut response, buf);/// assert_eq!(res, Ok(httparse::Status::Complete(buf.len())));/// assert_eq!(response.headers.len(), 1);/// assert_eq!(response.headers[0].name, "Folded-Header");/// assert_eq!(response.headers[0].value, b"hello\r\n there");obsolete_multiline_headers_in_responses_are_allowed/// Whether obsolete multiline headers should be allowed./// Sets whether white space before the first header is allowed/// This is not allowed by spec but some browsers ignore it. So this an option for/// compatibility./// See https://github.com/curl/curl/issues/11605 for reference/// let buf = b"HTTP/1.1 200 OK\r\n Space-Before-Header: hello there\r\n\r\n";/// let mut headers = [httparse::EMPTY_HEADER; 1];/// let mut response = httparse::Response::new(&mut headers[..]);/// let result = httparse::ParserConfig::default()///     .allow_space_before_first_header_name(true)/// assert_eq!(result, Ok(httparse::Status::Complete(buf.len())));/// assert_eq!(response.version.unwrap(), 1);/// assert_eq!(response.code.unwrap(), 200);/// assert_eq!(response.reason.unwrap(), "OK");/// assert_eq!(response.headers[0].name, "Space-Before-Header");/// assert_eq!(response.headers[0].value, &b"hello there"[..]);space_before_first_header_name_are_allowed/// Whether white space before first header is allowed or notparse_request/// Parses a request with the given config.'headersparse_request_with_uninit_headers/// Parses a request with the given config and buffer for headers/// Sets whether invalid header lines should be silently ignored in responses./// This mimicks the behaviour of major browsers. You probably don't want this./// You should only want this if you are implementing a proxy whose main/// purpose is to sit in front of browsers whose users access arbitrary content/// which may be malformed, and they expect everything that works without/// the proxy to keep working with the proxy./// This option will prevent `ParserConfig::parse_response` from returning/// an error encountered when parsing a header, except if the error was caused/// by the character NUL (ASCII code 0), as Chrome specifically always reject/// those, or if the error was caused by a lone character `\r`, as Firefox and/// Chrome behave differently in that case./// The ignorable errors are:/// * empty header names;/// * characters that are not allowed in header names, except for `\0` and `\r`;/// * when `allow_spaces_after_header_name_in_responses` is not enabled,///   spaces and tabs between the header name and the colon;/// * missing colon between header name and value;/// * when `allow_obsolete_multiline_headers_in_responses` is not enabled,///   headers using obsolete line folding./// * characters that are not allowed in header values except for `\0` and `\r`./// If an ignorable error is encountered, the parser tries to find the next/// line in the input to resume parsing the rest of the headers. As lines/// contributing to a header using obsolete line folding always start/// with whitespace, those will be ignored too. An error will be emitted/// nonetheless if it finds `\0` or a lone `\r` while looking for the/// next line./// Sets whether invalid header lines should be silently ignored in requests.parse_response/// Parses a response with the given config.parse_response_with_uninit_headers/// Parses a response with the given config and buffer for headers/// The request method, such as `GET`./// The request path, such as `/about-us`./// The request minor version, such as `1` for `HTTP/1.1`./// The request headers./// A parsed Request./// The optional values will be `None` if a parse was not complete, and did not/// parse the associated property. This allows you to inspect the parts that/// could be parsed, before reading more, in case you wish to exit early./// let buf = b"GET /404 HTTP/1.1\r\nHost:";/// let mut req = httparse::Request::new(&mut headers);/// let res = req.parse(buf).unwrap();/// if res.is_partial() {///     match req.path {///         Some(ref path) => {///             // check router for path.///             // /404 doesn't exist? we could stop parsing///         None => {///             // must read more and parse again/// Creates a new Request, using a slice of headers you allocate.parse_with_config_and_uninit_headersparse_with_uninit_headers/// Try to parse a buffer of bytes into the Request,/// except use an uninitialized slice of `Header`s./// For more information, see `parse`parse_with_config/// Try to parse a buffer of bytes into the Request./// Returns byte offset in `buf` to start of HTTP body.skip_empty_linesskip_spaces/// The response minor version, such as `1` for `HTTP/1.1`./// The response code, such as `200`./// The response reason-phrase, such as `OK`./// Contains an empty string if the reason-phrase was missing or contained invalid characters./// The response headers./// A parsed Response./// See `Request` docs for explanation of optional values./// Creates a new `Response` using a slice of `Header`s you have allocated./// Try to parse a buffer of bytes into this `Response`./// The name portion of a header./// A header name must be valid ASCII-US, so it's safe to store as a `&str`./// The value portion of a header./// While headers **should** be ASCII-US, the specification allows for/// values that may not be, and so the value is stored as bytes./// Represents a parsed header.EMPTY_HEADER/// An empty header, useful for constructing a `Header` array to pass in for/// let headers = [httparse::EMPTY_HEADER; 64];parse_reason/// From [RFC 7230](https://tools.ietf.org/html/rfc7230):/// > reason-phrase  = *( HTAB / SP / VCHAR / obs-text )/// > HTAB           = %x09        ; horizontal tab/// > VCHAR          = %x21-7E     ; visible (printing) characters/// > obs-text       = %x80-FF/// > A.2.  Changes from RFC 2616/// > Non-US-ASCII content in header fields and the reason phrase/// > has been obsoleted and made opaque (the TEXT rule was removed).parse_tokenparse_codeparse_headers/// Parse a buffer of bytes as headers./// The return value, if complete and successful, includes the index of the/// buffer that parsing stopped at, and a sliced reference to the parsed/// headers. The length of the slice will be equal to the number of properly/// parsed headers./// let buf = b"Host: foo.bar\nAccept: */*\n\nblah blah";/// let mut headers = [httparse::EMPTY_HEADER; 4];/// assert_eq!(httparse::parse_headers(buf, &mut headers),///            Ok(httparse::Status::Complete((27, &[///                httparse::Header { name: "Host", value: b"foo.bar" },///                httparse::Header { name: "Accept", value: b"*/*" }///            ][..]))));parse_headers_iterHeaderParserConfigdeinit_slice_mutassume_init_sliceallow_spaces_after_header_nameallow_obsolete_multiline_headersignore_invalid_headersparse_headers_iter_uninit/* Function which parsers headers into uninitialized buffer.
 *
 * Guarantees that it doesn't write garbage, so casting
 * &mut &mut [Header] -> &mut &mut [MaybeUninit<Header>]
 * is safe here.
 *
 * Also it promises `headers` get shrunk to number of initialized headers,
 * so casting the other way around after calling this function is safe
 */parse_chunk_size/// Parse a buffer of bytes as a chunk size./// buffer that parsing stopped at, and the size of the following chunk./// let buf = b"4\r\nRust\r\n0\r\n\r\n";/// assert_eq!(httparse::parse_chunk_size(buf),///            Ok(httparse::Status::Complete((3, 4))));NUM_OF_HEADERSreqtest_request_simpletest_request_simple_with_query_paramstest_request_simple_with_whatwg_query_paramstest_request_headerstest_request_headers_optional_whitespacetest_request_header_value_htab_shorttest_request_header_value_htab_medtest_request_header_value_htab_longtest_request_header_no_space_after_colontest_request_headers_maxtest_request_multibytetest_request_one_byte_method// A single byte which is part of a method is not invalidtest_request_partial_method// A subset of a method is a partial method, not invalidtest_request_method_no_delimiter// A method, without the delimiting space, is a partial requesttest_request_method_only// Regression test: assert that a partial read with just the method and// space results in a partial, rather than a token error from uri parsing.test_request_partialtest_request_partial_versiontest_request_method_path_no_delimitertest_request_method_path_onlytest_request_partial_parses_headers_as_much_as_it_cantest_request_newlinestest_request_empty_lines_prefixtest_request_empty_lines_prefix_lf_onlytest_request_path_backslashtest_request_with_invalid_token_delimitertest_request_with_invalid_but_short_versiontest_request_with_empty_methodtest_request_with_empty_pathtest_request_with_empty_method_and_pathtest_response_simpletest_response_newlinestest_response_reason_missingtest_response_reason_missing_no_spacetest_response_reason_missing_no_space_with_headerstest_response_reason_with_space_and_tabRESPONSE_REASON_WITH_OBS_TEXT_BYTEtest_response_reason_with_obsolete_text_bytetest_response_reason_with_nul_bytetest_response_version_missing_spacetest_response_code_missing_spacetest_response_partial_parses_headers_as_much_as_it_cantest_response_empty_lines_prefix_lf_onlytest_response_no_crpartial_permutations/// Check all subset permutations of a partial request line with no headersRESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLONtest_forbid_response_with_whitespace_between_header_name_and_colontest_allow_response_with_whitespace_between_header_name_and_colontest_ignore_header_line_with_whitespaces_after_header_name_in_responseREQUEST_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLONtest_forbid_request_with_whitespace_between_header_name_and_colontest_ignore_header_line_with_whitespaces_after_header_name_in_requestRESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_STARTtest_forbid_response_with_obsolete_line_folding_at_starttest_allow_response_with_obsolete_line_folding_at_startRESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_ENDtest_forbid_response_with_obsolete_line_folding_at_endtest_allow_response_with_obsolete_line_folding_at_endRESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_MIDDLEtest_forbid_response_with_obsolete_line_folding_in_middletest_allow_response_with_obsolete_line_folding_in_middleRESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_EMPTY_HEADERtest_forbid_response_with_obsolete_line_folding_in_empty_headertest_allow_response_with_obsolete_line_folding_in_empty_headertest_chunk_sizeRESPONSE_WITH_MULTIPLE_SPACE_DELIMITERStest_forbid_response_with_multiple_space_delimiterstest_allow_response_with_multiple_space_delimitersRESPONSE_WITH_WEIRD_WHITESPACE_DELIMITERS/// This is technically allowed by the spec, but we only support multiple spaces as an option,/// not stray `\r`s.test_forbid_response_with_weird_whitespace_delimiterstest_still_forbid_response_with_weird_whitespace_delimitersREQUEST_WITH_MULTIPLE_SPACE_DELIMITERStest_forbid_request_with_multiple_space_delimiterstest_allow_request_with_multiple_space_delimitersREQUEST_WITH_WEIRD_WHITESPACE_DELIMITERStest_forbid_request_with_weird_whitespace_delimiterstest_still_forbid_request_with_weird_whitespace_delimitersREQUEST_WITH_MULTIPLE_SPACES_AND_BAD_PATHtest_request_with_multiple_spaces_and_bad_pathREQUEST_WITH_DEL_IN_PATH// This test ensure there is an error when there is a DEL character in the path// since we allow all char from 0x21 code except DEL, this test ensure that DEL// is not allowed in the pathtest_request_with_del_in_pathtest_all_utf8_char_in_paths// Miri is too slow for this testRESPONSE_WITH_SPACES_IN_CODEtest_response_with_spaces_in_codetest_response_with_empty_header_nametest_request_with_empty_header_nametest_request_with_whitespace_between_header_name_and_colontest_response_with_invalid_char_between_header_name_and_colontest_request_with_invalid_char_between_header_name_and_colontest_ignore_header_line_with_missing_colon_in_responsetest_ignore_header_line_with_missing_colon_in_requesttest_response_header_with_missing_colon_with_foldingtest_request_header_with_missing_colon_with_foldingtest_response_header_with_nul_in_header_nametest_request_header_with_nul_in_header_nametest_header_with_cr_in_header_nametest_header_with_nul_in_whitespace_before_colontest_header_with_nul_in_valuetest_header_with_invalid_char_in_valuetest_header_with_invalid_char_in_value_with_foldingtest_method_within_bufferRESPONSE_WITH_SPACE_BEFORE_FIRST_HEADERtest_forbid_response_with_space_before_first_headertest_allow_response_response_with_space_before_first_headertest_no_space_after_colontest_request_with_leading_spacetest_request_with_invalid_methodtest_utf8_in_path_oktest_bad_utf8_in_path//! # httparse//! A push library for parsing HTTP/1.x requests and responses.//! The focus is on speed and safety. Unsafe code is used to keep parsing fast,//! but unsafety is contained in a submodule, with invariants enforced. The//! parsing internals use an `Iterator` instead of direct indexing, while//! skipping bounds checks.//! With Rust 1.27.0 or later, support for SIMD is enabled automatically.//! If building an executable to be run on multiple platforms, and thus//! not passing `target_feature` or `target_cpu` flags to the compiler,//! runtime detection can still detect SSE4.2 or AVX2 support to provide//! massive wins.//! If compiling for a specific target, remembering to include//! `-C target_cpu=native` allows the detection to become compile time checks,//! making it *even* faster.byte_mapnewline//! Utility macrosmatch_uri_vectoredmatch_url_char_32_avxmatch_header_value_vectoredmatch_header_value_char_32_avxavx2_code_matches_uri_chars_tableavx2_code_matches_header_value_chars_tablebyte_is_allowedsse42match_header_name_vectoredbit_setbuild_bitmap// A 256-bit bitmap, split into two halves// lower half contains bits whose higher nibble is <= 7// higher half contains bits whose higher nibble is >= 8BITMAPSmatch_header_name_char_16_neon// NOTE: adapted from 256-bit version, with upper 128-bit ops commented outmatch_url_char_16_neonmatch_header_value_char_16_neonoffsetzoffsetnzneon_code_matches_uri_chars_tableneon_code_matches_header_value_chars_tableneon_code_matches_header_name_chars_tableAVX2SSE42NOPdetect_runtime_featureRUNTIME_FEATUREget_runtime_featurematch_url_char_16_ssematch_header_value_char_16_ssesse_code_matches_uri_chars_tablesse_code_matches_header_value_chars_table/// SWAR: SIMD Within A Register/// SIMD validator backend that validates register-sized chunks of data at a time.// Adapt block-size to match native register size, i.e: 32bit => 4, 64bit => 8ByteBlockmatch_tail// Matches "tail", i.e: when we have <BLOCK_SIZE bytes in the buffer, should be uncommonmatch_block// Naive fallback block matcheruniform_block// A const alternative to u64::from_ne_bytes to avoid bumping MSRV (1.36 => 1.44)// creates a u64 whose bytes are each equal to bmatch_uri_char_8_swar// A byte-wise range-check on an entire word/block,// ensuring all bytes in the word satisfy `33 <= (x != 127) <= 255`match_header_value_char_8_swar// ensuring all bytes in the word satisfy `32 <= (x != 127) <= 255`/// Check block to find offset of first non-zero byte// NOTE: Curiously `block.trailing_zeros() >> 3` appears to be slower, maybe revisittest_is_header_value_blocktest_is_uri_blocktest_offsetnzSECONDSTIMESTAMP// last second of year 9999/// Numeric component is out of rangeInvalidDigit/// Bad character where digit is expected/// Other formatting errors/// Error parsing datetime (timestamp)PrecisionSmartRfc3339Timestamp/// A wrapper type that allows you to Display a SystemTime/// Parse RFC3339 timestamp `2018-02-14T00:28:07Z`/// Supported feature: any precision of fractional/// digits `2018-02-14T00:28:07.133Z`./// Unsupported feature: localized timestamps. Only UTC is supported.parse_rfc3339_weak/// Parse RFC3339-like timestamp `2018-02-14 00:28:07`/// Supported features:/// 1. Any precision of fractional digits `2018-02-14 00:28:07.133`./// 2. Supports timestamp with or without either of `T` or `Z`/// 3. Anything valid for `parse_3339` is valid for this function/// Unsupported feature: localized timestamps. Only UTC is supported, even if/// `Z` is not specified./// This function is intended to use for parsing human input. Whereas/// `parse_rfc3339` is for strings generated programmatically./// Format an RFC3339 timestamp `2018-02-14T00:28:07Z`/// This function formats timestamp with smart precision: i.e. if it has no/// fractional seconds, they aren't written at all. And up to nine digits if/// they are./// The value is always UTC and ignores system timezone./// This format always shows timestamp without fractional seconds./// Format an RFC3339 timestamp `2018-02-14T00:28:07.000Z`/// This format always shows milliseconds even if millisecond value is zero./// Format an RFC3339 timestamp `2018-02-14T00:28:07.000000Z`/// This format always shows microseconds even if microsecond value is zero./// Format an RFC3339 timestamp `2018-02-14T00:28:07.000000000Z`/// This format always shows nanoseconds even if nanosecond value is zero./// Returns a reference to the [`SystemTime`][] that is being formatted.from_secsmoke_tests_parsesmoke_tests_formatsmoke_tests_format_millissmoke_tests_format_microssmoke_tests_format_nanosupper_boundleap_secondfirst_731_daysthe_731_consecutive_daysall_86400_secondsrandom_pastrandom_wide_rangezero_monthbig_monthzero_daybig_daybig_day2big_secondbig_minutebig_hourbreak_dataweak_smoke_testsInvalidCharacter/// Invalid character during parsing/// More specifically anything that is not alphanumeric is prohibited/// The field is an byte offset of the character in the string.NumberExpected/// Non-numeric value where number is expected/// This usually means that either time unit is broken into words,/// e.g. `m sec` instead of `msec`, or just number is omitted,/// for example `2 hours min` instead of `2 hours 1 min`/// The field is an byte offset of the errorneous character/// in the string./// Start of the invalid unit inside the original string/// End of the invalid unit inside the original string/// The unit verbatim/// A number associated with the unitUnknownUnit/// Unit in the number is not one of allowed units/// See documentation of `parse_duration` for the list of supported/// time units./// The two fields are start and end (exclusive) of the slice from/// the original string, containing errorneous valueNumberOverflow/// The numeric value is too large/// Usually this means value is too large to be useful. If user writes/// data in subsecond units, then the maximum is about 3k years. When/// using seconds, or larger units, the limit is even larger./// The value was an empty string (or consists only whitespace)/// Error parsing human-friendly durationFormattedDuration/// A wrapper type that allows you to Display a DurationOverflowOpparse_first_charparse_unitparse_duration/// Parse duration object `1hour 12min 5s`/// The duration object is a concatenation of time spans. Where each time/// span is an integer number and a suffix. Supported suffixes:/// * `nsec`, `ns` -- nanoseconds/// * `usec`, `us` -- microseconds/// * `msec`, `ms` -- milliseconds/// * `seconds`, `second`, `sec`, `s`/// * `minutes`, `minute`, `min`, `m`/// * `hours`, `hour`, `hr`, `h`/// * `days`, `day`, `d`/// * `weeks`, `week`, `w`/// * `months`, `month`, `M` -- defined as 30.44 days/// * `years`, `year`, `y` -- defined as 365.25 days/// use humantime::parse_duration;/// assert_eq!(parse_duration("2h 37min"), Ok(Duration::new(9420, 0)));/// assert_eq!(parse_duration("32ms"), Ok(Duration::new(0, 32_000_000)));format_duration/// Formats duration into a human-readable string/// Note: this format is guaranteed to have same value when using/// parse_duration, but we can change some details of the exact composition/// of the value./// use humantime::format_duration;/// let val1 = Duration::new(9420, 0);/// assert_eq!(format_duration(val1).to_string(), "2h 37m");/// let val2 = Duration::new(0, 32_000_000);/// assert_eq!(format_duration(val2).to_string(), "32ms");item_plural/// Returns a reference to the [`Duration`][] that is being formatted.test_unitstest_comborandom_secondrandom_anytest_overlowtest_nice_error_messageDurationErrorTimestampError//! Human-friendly time parser and formatter//! Features://! * Parses durations in free form like `15days 2min 2s`//! * Formats durations in similar form `2years 2min 12us`//! * Parses and formats timestamp in `rfc3339` format: `2018-01-01T12:53:00Z`//! * Parses timestamps in a weaker format: `2018-01-01 12:53:00`//! Timestamp parsing/formatting is super-fast because format is basically//! fixed.//! See [humantime-serde] for serde integration (previous crate [serde-humantime] looks unmaintained).//! [serde-humantime]: https://docs.rs/serde-humantime/0.1.1/serde_humantime///! [humantime-serde]: https://docs.rs/humantime-serdeStdDuration/// A wrapper for duration that has `FromStr` implementation/// This is useful if you want to use it somewhere where `FromStr` is/// expected./// See `parse_duration` for the description of the format./// let x: Duration;/// x = "12h 5min 2ns".parse::<humantime::Duration>().unwrap().into();/// assert_eq!(x, Duration::new(12*3600 + 5*60, 2))/// A wrapper for SystemTime that has `FromStr` implementation/// See `parse_rfc3339_weak` for the description of the format. The "weak"/// format is used as it's more pemissive for human input as this is the/// expected use of the type (e.g. command-line parsing)./// use std::time::SystemTime;/// let x: SystemTime;/// x = "2018-02-16T00:31:37Z".parse::<humantime::Timestamp>().unwrap().into();/// assert_eq!(humantime::format_rfc3339(x).to_string(), "2018-02-16T00:31:37Z");// for mpsc::ReceiverDecodedLengthBodySenderTrailersSender/// A stream of `Bytes`, used when receiving bodies from the network./// Note that Users should not instantiate this struct directly. When working with the hyper client,/// `Incoming` is returned to you in responses. Similarly, when operating with the hyper server,/// it is provided within requests./// async fn echo(///    req: Request<hyper::body::Incoming>,/// ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {///    //Here, you can process `Incoming`content_lengthwant_txdata_rxtrailers_rx"Sender does nothing unless sent on"want_rxdata_txtrailers_tx/// A sender half created through [`Body::channel()`]./// Useful when wanting to stream chunks from another thread./// ## Body Closing/// Note that the request body will always be closed normally when the sender is dropped (meaning/// that the empty terminating chunk will be sent to the remote). If you desire to close the/// connection with an incomplete response (e.g. in the case of an error during asynchronous/// processing), call the [`Sender::abort()`] method to abort the body in an abnormal fashion./// [`Body::channel()`]: struct.Body.html#method.channel/// [`Sender::abort()`]: struct.Sender.html#method.abortWANT_PENDINGWANT_READY/// Create a `Body` stream with an associated sender half.new_channel/// Check to see if this `Sender` can send more data.poll_want/// Send data on data channel when it is ready.try_send_data/// Try to send data on this channel./// Returns `Err(Bytes)` if the channel could not (currently) accept/// another `Bytes`./// This is mostly useful for when trying to send from some other thread/// that doesn't have an async context. If in an async context, prefer/// `send_data()` instead.try_send_trailerssend_errortest_size_ofchannel_abortchannel_abort_when_buffer_is_fullchannel_buffers_onechannel_emptychannel_readychannel_wanterchannel_notices_closureCLOSE_DELIMITEDCHUNKEDdanger_len/// Takes the length as a content-length without other checks./// Should only be called if previously confirmed this isn't/// CLOSE_DELIMITED or CHUNKED.into_opt/// Converts to an Option<u64> representing a Known or Unknown length.checked_new/// Checks the `u64` is within the maximum allowed for content-length.sub_ifsub_if_knownsub_if_chunked//! Streaming bodies for Requests and Responses//! For both [Clients](crate::client) and [Servers](crate::server), requests and//! responses use streaming bodies, instead of complete buffering. This//! allows applications to not use memory they don't need, and allows exerting//! back-pressure on connections by only reading when asked.//! There are two pieces to this in hyper://! - **The [`Body`] trait** describes all possible bodies.//!   hyper allows any body type that implements `Body`, allowing//!   applications to have fine-grained control over their streaming.//! - **The [`Incoming`] concrete type**, which is an implementation//!   of `Body`, and returned by hyper as a "receive stream" (so, for server//!   requests and client responses).//! There are additional implementations available in [`http-body-util`][],//! such as a `Full` or `Empty` body.//! [`http-body-util`]: https://docs.rs/http-body-utilcfg_featurecfg_protocfg_clientcfg_serverIncomingBodyClientTransactionSendRequest/// The sender side of an established connection./// The original IO object used in the handshake./// A buffer of bytes that have been read but not processed as HTTP./// For instance, if the `Connection` is used for an HTTP upgrade request,/// it is possible the server sent back the first bytes of the new protocol/// along with the response upgrade./// You will want to check for any existing bytes if you plan to continue/// communicating on the IO object./// Deconstructed parts of a `Connection`./// This allows taking apart a `Connection` at a later time, in order to/// reclaim the IO object, and additional related pieces./// A future that processes all HTTP state for the IO object./// In most cases, this should just be spawned into an executor, so that it/// can process incoming and outgoing messages, notice hangups, and the like./// Instances of this type are typically created via the [`handshake`] function/// Return the inner IO object, and additional information./// Only works for HTTP/1 connections. HTTP/2 connections will panic.poll_without_shutdown/// Poll the connection for completion, but without calling `shutdown`/// on the underlying IO./// This is useful to allow running a connection while doing an HTTP/// upgrade. Once the upgrade is completed, the connection would be "done",/// but it is not desired to actually shutdown the IO object. Instead you/// would take it back using `into_parts`./// Use [`poll_fn`](https://docs.rs/futures/0.1.25/futures/future/fn.poll_fn.html)/// and [`try_ready!`](https://docs.rs/futures/0.1.25/futures/macro.try_ready.html)/// to work with this function; or use the `without_shutdown` wrapper.without_shutdown/// Prevent shutdown of the underlying IO object at the end of service the request,/// instead run `into_parts`. This is a convenience wrapper over `poll_without_shutdown`.h09_responsesh1_parser_configh1_writevh1_title_case_headersh1_preserve_header_caseh1_max_headersh1_read_buf_exact_sizeh1_max_buf_size/// A builder to configure an HTTP connection./// After setting options, the builder is used to create a handshake future./// **Note**: The default values of options are *not considered stable*. They/// are subject to change at any time./// Returns a handshake future over some IO./// This is a shortcut for `Builder::new().handshake(io)`./// See [`client::conn`](crate::client::conn) for more./// Polls to determine whether this sender can be used yet for a request./// If the associated connection is closed, this returns an Error./// Waits until the dispatcher is ready/// Checks if the connection is currently ready to send a request./// This is mostly a hint. Due to inherent latency of networks, it is/// possible that even after checking this is ready, sending a request/// may still fail because the connection was closed in the meantime./// Checks if the connection side has been closed./// Sends a `Request` on the associated connection./// Returns a future that if successful, yields the `Response`./// `req` must have a `Host` header./// # Uri/// The `Uri` of the request is serialized as-is./// - Usually you want origin-form (`/path?query`)./// - For sending to an HTTP proxy, you want to send in absolute-form///   (`https://hyper.rs/guides`)./// This is however not enforced or validated and it is up to the user/// of this method to ensure the `Uri` is correct for their intended purpose.try_send_request/// If there was an error before trying to serialize the request to the/// connection, the message will be returned as part of this error.with_upgradesupgradesUpgradeableConnection/// Enable this connection to support higher-level HTTP upgrades./// See [the `upgrade` module](crate::upgrade) for more./// Creates a new connection builder.http09_responses/// Set whether HTTP/0.9 responses should be tolerated./// Default is false./// Set whether HTTP/1 connections will accept spaces between header names/// and the colon that follow them in responses./// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has/// to say about it:/// > No whitespace is allowed between the header field-name and colon. In/// > the past, differences in the handling of such whitespace have led to/// > security vulnerabilities in request routing and response handling. A/// > server MUST reject any received request message that contains/// > whitespace between a header field-name and colon with a response code/// > of 400 (Bad Request). A proxy MUST remove any such whitespace from a/// > response message before forwarding the message downstream./// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4/// Set whether HTTP/1 connections will accept obsolete line folding for/// header values./// Newline codepoints (`\r` and `\n`) will be transformed to spaces when/// > A server that receives an obs-fold in a request message that is not/// > within a message/http container MUST either reject the message by/// > sending a 400 (Bad Request), preferably with a representation/// > explaining that obsolete line folding is unacceptable, or replace/// > each received obs-fold with one or more SP octets prior to/// > interpreting the field value or forwarding the message downstream./// > A proxy or gateway that receives an obs-fold in a response message/// > that is not within a message/http container MUST either discard the/// > message and replace it with a 502 (Bad Gateway) response, preferably/// > with a representation explaining that unacceptable line folding was/// > received, or replace each received obs-fold with one or more SP/// > octets prior to interpreting the field value or forwarding the/// > message downstream./// > A user agent that receives an obs-fold in a response message that is/// > not within a message/http container MUST replace each received/// > obs-fold with one or more SP octets prior to interpreting the field/// > value./// Set whether HTTP/1 connections will silently ignored malformed header lines./// If this is enabled and a header line does not start with a valid header/// name, or does not include a colon at all, the line will be silently ignored/// and no error will be reported.writev/// Set whether HTTP/1 connections should try to use vectored writes,/// or always flatten into a single buffer./// Note that setting this to false may mean more copies of body data,/// but may also improve performance when an IO transport doesn't/// support vectored writes well, such as most TLS implementations./// Setting this to true will force hyper to use queued strategy/// which may eliminate unnecessary cloning on some TLS backends/// Default is `auto`. In this mode hyper will try to guess which/// mode to usetitle_case_headers/// Set whether HTTP/1 connections will write header names as title case at/// the socket level.preserve_header_case/// Set whether to support preserving original header cases./// Currently, this will record the original cases received, and store them/// in a private extension on the `Response`. It will also look for and use/// such an extension in any provided `Request`./// Since the relevant extension is still private, there is no way to/// interact with the original cases. The only effect this can have now is/// to forward the cases in a proxy-like fashion.max_headers/// Set the maximum number of headers./// When a response is received, the parser will reserve a buffer to store headers for optimal/// If client receives more headers than the buffer size, the error "message header too large"/// Note that headers is allocated on the stack by default, which has higher performance. After/// setting this value, headers will be allocated in heap memory, that is, heap memory/// allocation will occur for each response, and there will be a performance drop of about 5%./// Default is 100.read_buf_exact_size/// Sets the exact size of the read buffer to *always* use./// Note that setting this option unsets the `max_buf_size` option./// Default is an adaptive read buffer.max_buf_size/// Set the maximum buffer size for the connection./// Default is ~400kb./// Note that setting this option unsets the `read_exact_buf_size` option./// The minimum value allowed is 8192. This method panics if the passed `max` is less than the minimum./// Constructs a connection with the configured options and IO./// Note, if [`Connection`] is not `await`-ed, [`SendRequest`] will/// do nothing.Upgraded// A future binding a connection with a Service with Upgrade support.// This type is unnameable outside the crate.//! HTTP/1 client connections// ===== impl SendRequest// ===== impl Connection// ===== impl BuilderHttp2ClientConnExecClientTaskh2_builder/// This is a shortcut for `Builder::new(exec).handshake(io)`./// Absolute-form `Uri`s are not required. If received, they will be serialized/// as-is.is_extended_connect_protocol_enabled/// Returns whether the [extended CONNECT protocol][1] is enabled or not./// This setting is configured by the server peer by sending the/// [`SETTINGS_ENABLE_CONNECT_PROTOCOL` parameter][2] in a `SETTINGS` frame./// This method returns the currently acknowledged value received from the/// [1]: https://datatracker.ietf.org/doc/html/rfc8441#section-4/// [2]: https://datatracker.ietf.org/doc/html/rfc8441#section-3/// Provide a timer to execute background HTTP2 tasks.initial_stream_window_size/// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2/// stream-level flow control./// Passing `None` will do nothing./// If not set, hyper will use a default./// [spec]: https://httpwg.org/specs/rfc9113.html#SETTINGS_INITIAL_WINDOW_SIZEinitial_connection_window_size/// Sets the max connection-level flow control for HTTP2initial_max_send_streams/// Sets the initial maximum of locally initiated (send) streams./// This value will be overwritten by the value included in the initial/// SETTINGS frame received from the peer as part of a [connection preface]./// [connection preface]: https://httpwg.org/specs/rfc9113.html#prefaceadaptive_window/// Sets whether to use an adaptive flow control./// Enabling this will override the limits set in/// `initial_stream_window_size` and/// `initial_connection_window_size`.max_frame_size/// Sets the maximum frame size to use for HTTP2./// Default is currently 16KB, but can change.max_header_list_size/// Sets the max size of received header frames.header_table_size/// Sets the header table size./// This setting informs the peer of the maximum size of the header compression/// table used to encode header blocks, in octets. The encoder may select any value/// equal to or less than the header table size specified by the sender./// The default value of crate `h2` is 4,096.max_concurrent_streams/// Sets the maximum number of concurrent streams./// The maximum concurrent streams setting only controls the maximum number/// of streams that can be initiated by the remote peer. In other words,/// when this setting is set to 100, this does not limit the number of/// concurrent streams that can be created by the caller./// It is recommended that this value be no smaller than 100, so as to not/// unnecessarily limit parallelism. However, any value is legal, including/// 0. If `max` is set to 0, then the remote will not be permitted to/// initiate streams./// Note that streams in the reserved state, i.e., push promises that have/// been reserved but the stream has not started, do not count against this/// setting./// Also note that if the remote *does* exceed the value set here, it is not/// a protocol level error. Instead, the `h2` library will immediately reset/// See [Section 5.1.2] in the HTTP/2 spec for more details./// [Section 5.1.2]: https://http2.github.io/http2-spec/#rfc.section.5.1.2keep_alive_interval/// Sets an interval for HTTP2 Ping frames should be sent to keep a/// connection alive./// Pass `None` to disable HTTP2 keep-alive./// Default is currently disabled.keep_alive_timeout/// Sets a timeout for receiving an acknowledgement of the keep-alive ping./// If the ping is not acknowledged within the timeout, the connection will/// be closed. Does nothing if `keep_alive_interval` is disabled./// Default is 20 seconds.keep_alive_while_idle/// Sets whether HTTP2 keep-alive should apply while the connection is idle./// If disabled, keep-alive pings are only sent while there are open/// request/responses streams. If enabled, pings are also sent when no/// streams are active. Does nothing if `keep_alive_interval` is/// disabled./// Default is `false`.max_concurrent_reset_streams/// Sets the maximum number of HTTP2 concurrent locally reset streams./// See the documentation of [`h2::client::Builder::max_concurrent_reset_streams`] for more/// The default value is determined by the `h2` crate./// [`h2::client::Builder::max_concurrent_reset_streams`]: https://docs.rs/h2/client/struct.Builder.html#method.max_concurrent_reset_streamsmax_send_buf_size/// Set the maximum write buffer size for each HTTP/2 stream./// Default is currently 1MB, but may change./// The value must be no larger than `u32::MAX`.max_pending_accept_reset_streams/// Configures the maximum number of pending reset streams allowed before a GOAWAY will be sent./// This will default to the default value set by the [`h2` crate](https://crates.io/crates/h2)./// As of v0.4.0, it is 20./// See <https://github.com/hyperium/hyper/issues/2877> for more information.send_sync_executor_of_non_send_futures// only compilation is checkednot_send_not_sync_executor_of_not_send_futuressend_not_sync_executor_of_not_send_futuressend_sync_executor_of_send_futuresnot_send_not_sync_executor_of_send_futuressend_not_sync_executor_of_send_futures//! HTTP/2 client connectionshttp1//! Lower-level client connection API.//! The types in this module are to provide a lower-level API based around a//! single connection. Connecting to a host, pooling connections, and the like//! are not handled at this level. This module provides the building blocks to//! customize those things externally.//! If you are looking for a convenient HTTP client, then you may wish to//! consider [reqwest](https://github.com/seanmonstar/reqwest) for a high level//! client or [`hyper-util`'s client](https://docs.rs/hyper-util/latest/hyper_util/client/index.html)//! if you want to keep it more low level / basic.//! See the [client guide](https://hyper.rs/guides/1/client/basic/).RetryPromise/// An error when calling `try_send_request`./// There is a possibility of an error occurring on a connection in-between the/// time that a request is queued and when it is actually written to the IO/// transport. If that happens, it is safe to return the request back to the/// caller, as it was never fully sent.buffered_once/// One message is always allowed, even if the Receiver hasn't asked/// for it yet. This boolean keeps track of whether we've sent one/// without notice.giverGiver/// The Giver helps watch that the Receiver side has been polled/// when the queue is empty. This helps us know when a request and/// response have been fully processed, and a connection is ready/// for more.Envelope/// Actually bounded by the Giver, plus `buffered_once`./// A bounded sender of requests and callbacks for when responses are ready./// While the inner sender is unbounded, the Giver is used to determine/// if the Receiver is ready for another request.can_sendtakerTakerpoll_recvNoRetrydispatch_gonetake_message/// Take the message from this error./// The message will not always have been recovered. If an error occurs/// after the message has been serialized onto the connection, it will not/// be available here./// Returns a reference to the recovered message./// Consumes this to return the inner error./// Returns a reference to the inner error./// Helper to check if the future is ready after polling once.drop_receiver_sends_cancel_errorssender_checks_for_want_on_send//! HTTP Client//! hyper provides HTTP over a single connection. See the [`conn`] module.//! * [`client`] - A simple CLI http client that requests the url passed in parameters and outputs the response content and details to the stdout, reading content chunk-by-chunk.//! * [`client_json`] - A simple program that GETs some json, reads the body asynchronously, parses it with serde and outputs the result.//! [`client`]: https://github.com/hyperium/hyper/blob/master/examples/client.rs//! [`client_json`]: https://github.com/hyperium/hyper/blob/master/examples/client_json.rs/*
// FIXME: re-implement tests with `async/await`
#[test]
fn retryable_request() {
    let _ = pretty_env_logger::try_init();

    let mut rt = Runtime::new().expect("new rt");
    let mut connector = MockConnector::new();

    let sock1 = connector.mock("http://mock.local");
    let sock2 = connector.mock("http://mock.local");

    let client = Client::builder()
        .build::<_, crate::Body>(connector);

    client.pool.no_timer();

    {

        let req = Request::builder()
            .uri("http://mock.local/a")
            .body(Default::default())
            .unwrap();
        let res1 = client.request(req);
        let srv1 = poll_fn(|| {
            try_ready!(sock1.read(&mut [0u8; 512]));
            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
        rt.block_on(res1.join(srv1)).expect("res1");
    }
    drop(sock1);

    let req = Request::builder()
        .uri("http://mock.local/b")
        .body(Default::default())
        .unwrap();
    let res2 = client.request(req)
        .map(|res| {
            assert_eq!(res.status().as_u16(), 222);
        });
    let srv2 = poll_fn(|| {
        try_ready!(sock2.read(&mut [0u8; 512]));
        try_ready!(sock2.write(b"HTTP/1.1 222 OK\r\nContent-Length: 0\r\n\r\n"));
        Ok(Async::Ready(()))
    }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));

    rt.block_on(res2.join(srv2)).expect("res2");
}

#[test]
fn conn_reset_after_write() {
    let _ = pretty_env_logger::try_init();

    let mut rt = Runtime::new().expect("new rt");
    let mut connector = MockConnector::new();

    let sock1 = connector.mock("http://mock.local");

    let client = Client::builder()
        .build::<_, crate::Body>(connector);

    client.pool.no_timer();

    {
        let req = Request::builder()
            .uri("http://mock.local/a")
            .body(Default::default())
            .unwrap();
        let res1 = client.request(req);
        let srv1 = poll_fn(|| {
            try_ready!(sock1.read(&mut [0u8; 512]));
            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
        rt.block_on(res1.join(srv1)).expect("res1");
    }

    let req = Request::builder()
        .uri("http://mock.local/a")
        .body(Default::default())
        .unwrap();
    let res2 = client.request(req);
    let mut sock1 = Some(sock1);
    let srv2 = poll_fn(|| {
        // We purposefully keep the socket open until the client
        // has written the second request, and THEN disconnect.
        //
        // Not because we expect servers to be jerks, but to trigger
        // state where we write on an assumedly good connection, and
        // only reset the close AFTER we wrote bytes.
        try_ready!(sock1.as_mut().unwrap().read(&mut [0u8; 512]));
        sock1.take();
        Ok(Async::Ready(()))
    }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
    let err = rt.block_on(res2.join(srv2)).expect_err("res2");
    assert!(err.is_incomplete_message(), "{:?}", err);
}

#[test]
fn checkout_win_allows_connect_future_to_be_pooled() {
    let _ = pretty_env_logger::try_init();

    let mut rt = Runtime::new().expect("new rt");
    let mut connector = MockConnector::new();


    let (tx, rx) = oneshot::channel::<()>();
    let sock1 = connector.mock("http://mock.local");
    let sock2 = connector.mock_fut("http://mock.local", rx);

    let client = Client::builder()
        .build::<_, crate::Body>(connector);

    client.pool.no_timer();

    let uri = "http://mock.local/a".parse::<crate::Uri>().expect("uri parse");

    // First request just sets us up to have a connection able to be put
    // back in the pool. *However*, it doesn't insert immediately. The
    // body has 1 pending byte, and we will only drain in request 2, once
    // the connect future has been started.
    let mut body = {
        let res1 = client.get(uri.clone())
            .map(|res| res.into_body().concat2());
        let srv1 = poll_fn(|| {
            try_ready!(sock1.read(&mut [0u8; 512]));
            // Chunked is used so as to force 2 body reads.
            try_ready!(sock1.write(b"\
                HTTP/1.1 200 OK\r\n\
                transfer-encoding: chunked\r\n\
                \r\n\
                1\r\nx\r\n\
                0\r\n\r\n\
            "));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));

        rt.block_on(res1.join(srv1)).expect("res1").0
    };


    // The second request triggers the only mocked connect future, but then
    // the drained body allows the first socket to go back to the pool,
    // "winning" the checkout race.
    {
        let res2 = client.get(uri.clone());
        let drain = poll_fn(move || {
            body.poll()
        });
        let srv2 = poll_fn(|| {
            try_ready!(sock1.read(&mut [0u8; 512]));
            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nx"));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));

        rt.block_on(res2.join(drain).join(srv2)).expect("res2");
    }

    // "Release" the mocked connect future, and let the runtime spin once so
    // it's all setup...
    {
        let mut tx = Some(tx);
        let client = &client;
        let key = client.pool.h1_key("http://mock.local");
        let mut tick_cnt = 0;
        let fut = poll_fn(move || {
            tx.take();

            if client.pool.idle_count(&key) == 0 {
                tick_cnt += 1;
                assert!(tick_cnt < 10, "ticked too many times waiting for idle");
                trace!("no idle yet; tick count: {}", tick_cnt);
                ::futures::task::current().notify();
                Ok(Async::NotReady)
            } else {
                Ok::<_, ()>(Async::Ready(()))
            }
        });
        rt.block_on(fut).unwrap();
    }

    // Third request just tests out that the "loser" connection was pooled. If
    // it isn't, this will panic since the MockConnector doesn't have any more
    // mocks to give out.
    {
        let res3 = client.get(uri);
        let srv3 = poll_fn(|| {
            try_ready!(sock2.read(&mut [0u8; 512]));
            try_ready!(sock2.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv3 poll_fn error: {}", e));

        rt.block_on(res3.join(srv3)).expect("res3");
    }
}

#[cfg(feature = "nightly")]
#[bench]
fn bench_http1_get_0b(b: &mut test::Bencher) {
    let _ = pretty_env_logger::try_init();

    let mut rt = Runtime::new().expect("new rt");
    let mut connector = MockConnector::new();


    let client = Client::builder()
        .build::<_, crate::Body>(connector.clone());

    client.pool.no_timer();

    let uri = Uri::from_static("http://mock.local/a");

    b.iter(move || {
        let sock1 = connector.mock("http://mock.local");
        let res1 = client
            .get(uri.clone())
            .and_then(|res| {
                res.into_body().for_each(|_| Ok(()))
            });
        let srv1 = poll_fn(|| {
            try_ready!(sock1.read(&mut [0u8; 512]));
            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
        rt.block_on(res1.join(srv1)).expect("res1");
    });
}

#[cfg(feature = "nightly")]
#[bench]
fn bench_http1_get_10b(b: &mut test::Bencher) {
    let _ = pretty_env_logger::try_init();

    let mut rt = Runtime::new().expect("new rt");
    let mut connector = MockConnector::new();


    let client = Client::builder()
        .build::<_, crate::Body>(connector.clone());

    client.pool.no_timer();

    let uri = Uri::from_static("http://mock.local/a");

    b.iter(move || {
        let sock1 = connector.mock("http://mock.local");
        let res1 = client
            .get(uri.clone())
            .and_then(|res| {
                res.into_body().for_each(|_| Ok(()))
            });
        let srv1 = poll_fn(|| {
            try_ready!(sock1.read(&mut [0u8; 512]));
            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\n0123456789"));
            Ok(Async::Ready(()))
        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
        rt.block_on(res1.join(srv1)).expect("res1");
    });
}
*/bufs_cnthttpdateHttpDateDATE_VALUE_LENGTH// "Sun, 06 Nov 1994 08:49:37 GMT".len()update_and_header_valueheader_valuenext_updateCachedDaterender_http2test_date_lenbench_date_checkbench_date_render// TODO: replace with `std::future::poll_fn` once MSRV >= 1.64/// This adapts from `hyper` IO traits to the ones in Tokio./// This is currently used by `h2`, and by hyper internal unit tests.ReadBufCursorrewind/// Combine a buffer with an IO, rewinding reads to use the buffer.new_buffered// pub(crate) fn get_mut(&mut self) -> &mut T {//     &mut self.innerpartial_rewindfull_rewind/// A function to help "yield" a future, such that it is re-scheduled immediately./// Useful for spin counts, so a future doesn't hog too much time.// TODO: replace with `std::task::Waker::noop()` once MSRV >= 1.85/// Poll the future once and return `Some` if it is ready, else `None`./// If the future wasn't ready, it future likely can't be driven to completion any more: the polling/// uses a no-op waker, so knowledge of what the pending future was waiting for is lost./// A user-provided timer to time background tasks.DurConfigured//! An SPSC broadcast channel.//! - The value can only be a `usize`.//! - The consumer is only notified if the value is different.//! - The value `0` is reserved for closed./// Result type often returned from methods that can have hyper `Error`s.Cause/// Represents errors that can occur handling HTTP streams./// # Formatting/// The `Display` implementation of this type will only print the details of/// this level of error, even though it may have been caused by another error/// and contain that error in its source. To print all the relevant/// information, including the source chain, using something like/// `std::error::Report`, or equivalent 3rd party types./// The contents of the formatted error message of this specific `Error` type/// is unspecified. **You must not depend on it.** The wording and details may/// change in any version, with the goal of improving error messages./// # Source/// A `hyper::Error` may be caused by another error. To aid in debugging,/// those are exposed in `Error::source()` as erased types. While it is/// possible to check the exact type of the sources, they **can not be depended/// on**. They may come from private internal dependencies, and are subject to/// change at any moment.IncompleteMessage/// A message reached EOF, but is not complete./// A connection received a message (or bytes) when not waiting for one./// A pending item was dropped before ever being processed.ChannelClosed/// Indicates a channel (client or body sender) is closed./// An `io::Error` that occurred while trying to read or write to a network stream./// Error while reading a body from connection.BodyWrite/// Error while writing a body to connection./// Error calling AsyncWrite::shutdown()VersionH2TooLargeContentLengthInvalidTransferEncodingUnexpected/// Error calling user's Body::poll_data().BodyWriteAborted/// The user aborted writing of the outgoing body./// Error from future of user's Service.NoUpgrade/// User tried polling for an upgrade that doesn't exist.ManualUpgrade/// User polled for an upgrade, but low-level API is not using upgrades.DispatchGone/// The dispatch task is gone.// Sentinel type to indicate the error was caused by a timeout.is_parse/// Returns true if this was an HTTP parse error.is_parse_status/// Returns true if this was an HTTP parse error caused by an invalid response status code or/// reason phrase.is_user/// Returns true if this error was caused by user code./// Returns true if this was about a `Request` that was canceled./// Returns true if a sender's channel is closed.is_incomplete_message/// Returns true if the connection closed before a message could complete.is_body_write_aborted/// Returns true if the body write was aborted./// Returns true if the error was caused while calling `AsyncWrite::shutdown()`./// Returns true if the error was caused by a timeout.find_sourcenew_cancelednew_incompletenew_too_largenew_version_h2new_unexpected_messagenew_ionew_closednew_bodynew_body_writenew_body_write_abortednew_usernew_user_no_upgradenew_user_manual_upgradenew_user_servicenew_user_bodynew_shutdownnew_user_dispatch_gonecontent_length_invalidtransfer_encoding_unexpectederror_satisfies_send_syncerror_size_of//! Error and Result module.// ===== impl TimedOut ====ReasonPhrase/// A reason phrase in an HTTP/1 response./// # Clients/// For clients, a `ReasonPhrase` will be present in the extensions of the `http::Response` returned/// for a request if the reason phrase is different from the canonical reason phrase for the/// response's status code. For example, if a server returns `HTTP/1.1 200 Awesome`, the/// `ReasonPhrase` will be present and contain `Awesome`, but if a server returns `HTTP/1.1 200 OK`,/// the response will not contain a `ReasonPhrase`./// # #[cfg(all(feature = "tcp", feature = "client", feature = "http1"))]/// # async fn fake_fetch() -> hyper::Result<()> {/// use hyper::{Client, Uri};/// use hyper::ext::ReasonPhrase;/// let res = Client::new().get(Uri::from_static("http://example.com/non_canonical_reason")).await?;/// // Print out the non-canonical reason phrase, if it has one.../// if let Some(reason) = res.extensions().get::<ReasonPhrase>() {///     println!("non-canonical reason: {}", std::str::from_utf8(reason.as_bytes()).unwrap());/// # Servers/// When a `ReasonPhrase` is present in the extensions of the `http::Response` written by a server,/// its contents will be written in place of the canonical reason phrase when responding via HTTP/1./// Gets the reason phrase as bytes./// Converts a static byte slice to a reason phrase.// Not public on purpose./// Converts a `Bytes` directly into a `ReasonPhrase` without validating./// Use with care; invalid bytes in a reason phrase can cause serious security problems if/// emitted in a response.InvalidReasonPhrasebad_byte/// Error indicating an invalid byte when constructing a `ReasonPhrase`./// See [the spec][spec] for details on allowed bytes./// [spec]: https://httpwg.org/http-core/draft-ietf-httpbis-messaging-latest.html#rfc.section.4.p.7is_valid_bytefind_invalid_bytebasic_validempty_validobs_text_validNEWLINE_PHRASEnewline_invalid_panicnewline_invalid_errCR_PHRASEcr_invalid_paniccr_invalid_errOnInformationalCallbackOnInformationalon_informational/// Add a callback for 1xx informational responses./// # let some_body = ();/// let mut req = hyper::Request::new(some_body);/// hyper::ext::on_informational(&mut req, |res| {///     println!("informational: {:?}", res.status());/// // send request on a client connection...on_informational_raw// Sealed, not actually nameable boundsOnInformationalClosure// A facade over http::Response.// It purposefully hides being able to move the response out of the closure,// while also not being able to expect it to be a reference `&Response`.// (Otherwise, a closure can be written as `|res: &_|`, and then be broken if// we make the closure take ownership.)// With the type not being nameable, we could change from being a facade to// being either a real reference, or moving the http::Response into the closure,// in a backwards-compatible change in the future.h1_reason_phraseinformationalHeaderCaseMap/// A map from header names to their original casing as received in an HTTP message./// If an HTTP/1 response `res` is parsed on a connection whose option/// [`preserve_header_case`] was set to true and the response included/// the following headers:/// x-Bread: Baguette/// X-BREAD: Pain/// x-bread: Ficelle/// Then `res.extensions().get::<HeaderCaseMap>()` will return a map with:/// HeaderCaseMap({///     "x-bread": ["x-Bread", "X-BREAD", "x-bread"],/// [`preserve_header_case`]: /client/struct.Client.html#method.preserve_header_case/// Returns a view of all spellings associated with that header name,/// in the order they were found.get_all_internal//! Extensions for HTTP messages in Hyper.//! This module provides types and utilities that extend the capabilities of HTTP requests and responses//! in Hyper. Extensions are additional pieces of information or features that can be attached to HTTP//! messages via the [`http::Extensions`] map, which is//! accessible through methods like [`http::Request::extensions`] and [`http::Response::extensions`].//! # What are extensions?//! Extensions allow Hyper to associate extra metadata or behaviors with HTTP messages, beyond the standard//! headers and body. These can be used by advanced users and library authors to access protocol-specific//! features, track original header casing, handle informational responses, and more.//! # How to access extensions//! Extensions are stored in the `Extensions` map of a request or response. You can access them using://! # let response = http::Response::new(());//! if let Some(ext) = response.extensions().get::<hyper::ext::ReasonPhrase>() {//!     // use the extension//! # Extension Groups//! The extensions in this module can be grouped as follows://! - **HTTP/1 Reason Phrase**: [`ReasonPhrase`] — Access non-canonical reason phrases in HTTP/1 responses.//! - **Informational Responses**: [`on_informational`] — Register callbacks for 1xx HTTP/1 responses on the client.//! - **Header Case Tracking**: Internal types for tracking the original casing and order of headers as received.//! - **HTTP/2 Protocol Extensions**: [`Protocol`] — Access the `:protocol` pseudo-header for Extended CONNECT in HTTP/2.//! Some extensions are only available for specific protocols (HTTP/1 or HTTP/2) or use cases (client, server, FFI).//! See the documentation on each item for details about its usage and requirements.hyper_contexthyper_taskhyper_task_return_typeAsTaskTypeUserDataPointerHYPER_ITER_CONTINUEhyper_body/// A streaming HTTP body./// This is used both for sending requests (with `hyper_request_set_body`) and/// for receiving responses (with `hyper_response_body`)./// For outgoing request bodies, call `hyper_body_set_data_func` to provide the/// For incoming response bodies, call `hyper_body_data` to get a task that will/// yield a chunk of data each time it is polled. That task must be then be/// added to the executor with `hyper_executor_push`./// Methods:/// - hyper_body_new:           Create a new “empty” body./// - hyper_body_set_userdata:  Set userdata on this body, which will be passed to callback functions./// - hyper_body_set_data_func: Set the data callback for this body./// - hyper_body_data:          Creates a task that will poll a response body for the next buffer of data./// - hyper_body_foreach:       Creates a task to execute the callback with each body chunk received./// - hyper_body_free:          Free a body.hyper_buf/// A buffer of bytes that is sent or received on a `hyper_body`./// Obtain one of these in the callback of `hyper_body_foreach` or by receiving/// a task of type `HYPER_TASK_BUF` from `hyper_executor_poll` (after calling/// `hyper_body_data` and pushing the resulting task)./// - hyper_buf_bytes: Get a pointer to the bytes in this buffer./// - hyper_buf_copy:  Create a new hyper_buf * by copying the provided bytes./// - hyper_buf_free:  Free this buffer./// - hyper_buf_len:   Get the length of the bytes this buffer contains.data_funchyper_body_data_callbackuserdataUserBodyhyper_body_foreach_callbackffi_fnpoll_datadata_noop/// cbindgen:ignoreas_task_type// ===== Body =====// ===== impl UserBody =====// ===== Bytes =====hyper_codehttp_typeshyper_requesthyper_responsehyper_iohyper_executorWeakExechttp1_allow_obsolete_multiline_headers_in_responseshttp1_preserve_header_casehttp1_preserve_header_orderhttp2/// Use a `Weak` to prevent cycles.hyper_clientconn_options/// An options builder to configure an HTTP client connection./// - hyper_clientconn_options_new:     Creates a new set of HTTP clientconn options to be used in a handshake./// - hyper_clientconn_options_exec:    Set the client background task executor./// - hyper_clientconn_options_http2:   Set whether to use HTTP2./// - hyper_clientconn_options_set_preserve_header_case:  Set whether header case is preserved./// - hyper_clientconn_options_set_preserve_header_order: Set whether header order is preserved./// - hyper_clientconn_options_http1_allow_multiline_headers: Set whether HTTP/1 connections accept obsolete line folding for header values./// - hyper_clientconn_options_free:    Free a set of HTTP clientconn options.Txhyper_clientconn/// An HTTP client connection handle./// These are used to send one or more requests on a single connection./// It's possible to send multiple requests on a single connection, such/// as when HTTP/1 keep-alive or HTTP/2 is used./// To create a `hyper_clientconn`:///   1. Create a `hyper_io` with `hyper_io_new`.///   2. Create a `hyper_clientconn_options` with `hyper_clientconn_options_new`.///   3. Call `hyper_clientconn_handshake` with the `hyper_io` and `hyper_clientconn_options`.///      This creates a `hyper_task`.///   5. Call `hyper_task_set_userdata` to assign an application-specific pointer to the task.///      This allows keeping track of multiple connections that may be handshaking///      simultaneously.///   4. Add the `hyper_task` to an executor with `hyper_executor_push`.///   5. Poll that executor until it yields a task of type `HYPER_TASK_CLIENTCONN`.///   6. Extract the `hyper_clientconn` from the task with `hyper_task_value`.///      This will require a cast from `void *` to `hyper_clientconn *`./// This process results in a `hyper_clientconn` that permanently owns the/// `hyper_io`. Because the `hyper_io` in turn owns a TCP or TLS connection, that means/// the `hyper_clientconn` owns the connection for both the clientconn's lifetime/// and the connection's lifetime./// In other words, each connection (`hyper_io`) must have exactly one `hyper_clientconn`/// associated with it. That's because `hyper_clientconn_handshake` sends the/// [HTTP/2 Connection Preface] (for HTTP/2 connections). Since that preface can't/// be sent twice, handshake can't be called twice./// [HTTP/2 Connection Preface]: https://datatracker.ietf.org/doc/html/rfc9113#name-http-2-connection-preface/// - hyper_clientconn_handshake:  Creates an HTTP client handshake task./// - hyper_clientconn_send:       Creates a task to send a request on the client connection./// - hyper_clientconn_free:       Free a hyper_clientconn *.Http1Http2// ===== impl hyper_clientconn =====// ===== impl hyper_clientconn_options =====hyper_error/// A more detailed error object returned by some hyper functions./// Compare with `hyper_code`, which is a simpler error returned from/// some hyper functions./// - hyper_error_code:  Get an equivalent hyper_code from this error./// - hyper_error_print: Print the details of this error to a buffer./// - hyper_error_free:  Frees a hyper_error.HYPERE_OK/// All is well.HYPERE_ERROR/// General error, details in the `hyper_error *`.HYPERE_INVALID_ARG/// A function argument was invalid.HYPERE_UNEXPECTED_EOF/// The IO transport returned an EOF when one wasn't expected./// This typically means an HTTP request or response was expected, but the/// connection closed cleanly without sending (all of) it.HYPERE_ABORTED_BY_CALLBACK/// Aborted by a user supplied callback.HYPERE_FEATURE_NOT_ENABLED/// An optional hyper feature was not enabled.HYPERE_INVALID_PEER_MESSAGE/// The peer sent an HTTP message that could not be parsed./// A return code for many of hyper's methods.print_to// ===== impl hyper_error =====OriginalHeaderOrder/// An HTTP request./// Once you've finished constructing a request, you can send it with/// `hyper_clientconn_send`./// - hyper_request_new:              Construct a new HTTP request./// - hyper_request_headers:          Gets a mutable reference to the HTTP headers of this request/// - hyper_request_set_body:         Set the body of the request./// - hyper_request_set_method:       Set the HTTP Method of the request./// - hyper_request_set_uri:          Set the URI of the request./// - hyper_request_set_uri_parts:    Set the URI of the request with separate scheme, authority, and path/query strings./// - hyper_request_set_version:      Set the preferred HTTP version of the request./// - hyper_request_on_informational: Set an informational (1xx) response callback./// - hyper_request_free:             Free an HTTP request./// An HTTP response./// Obtain one of these by making a request with `hyper_clientconn_send`, then/// polling the executor unntil you get a `hyper_task` of type/// `HYPER_TASK_RESPONSE`. To figure out which request this response/// corresponds to, check the userdata of the task, which you should/// previously have set to an application-specific identifier for the/// request./// - hyper_response_status:            Get the HTTP-Status code of this response./// - hyper_response_version:           Get the HTTP version used by this response./// - hyper_response_reason_phrase:     Get a pointer to the reason-phrase of this response./// - hyper_response_reason_phrase_len: Get the length of the reason-phrase of this response./// - hyper_response_headers:           Gets a reference to the HTTP headers of this response./// - hyper_response_body:              Take ownership of the body of this response./// - hyper_response_free:              Free an HTTP response.orig_casingorig_orderhyper_headers/// An HTTP header map./// These can be part of a request or response./// Obtain a pointer to read or modify these from `hyper_request_headers`/// or `hyper_response_headers`./// - hyper_headers_add:     Adds the provided value to the list of the provided name./// - hyper_headers_foreach: Iterates the headers passing each name and value pair to the callback./// - hyper_headers_set:     Sets the header with the provided name to the provided value.hyper_request_on_informational_callbackfinalize_requestreason_phrasehyper_headers_foreach_callbackget_or_defaultraw_name_valuetest_headers_foreach_cases_preservedtest_headers_foreach_order_preserved// ===== impl hyper_request =====// ===== impl hyper_response =====// ===== impl Headers =====// ===== impl OnInformational =====HYPER_IO_PENDING/// Sentinel value to return from a read or write callback that the operation/// is pending.HYPER_IO_ERROR/// has errored.hyper_io_read_callbackhyper_io_write_callback/// A read/write handle for a specific connection./// This owns a specific TCP or TLS connection for the lifetime of/// that connection. It contains a read and write callback, as well as a/// void *userdata. Typically the userdata will point to a struct/// containing a file descriptor and a TLS context./// - hyper_io_new:          Create a new IO type used to represent a transport./// - hyper_io_set_read:     Set the read function for this IO transport./// - hyper_io_set_write:    Set the write function for this IO transport./// - hyper_io_set_userdata: Set the user data pointer for this IO to some value./// - hyper_io_free:         Free an IO handle.read_noopwrite_noopnon_null// We may eventually allow the FFI to be enabled without `client` or `http1`,// that is why we don't auto enable them as `ffi = ["client", "http1"]` in// the `Cargo.toml`.// But for now, give a clear message that this compile error is expected./// Return in iter functions to continue iterating.HYPER_ITER_BREAK/// Return in iter functions to stop iterating.HYPER_HTTP_VERSION_NONE/// An HTTP Version that is unspecified.HYPER_HTTP_VERSION_1_0/// The HTTP/1.0 version.HYPER_HTTP_VERSION_1_1/// The HTTP/1.1 version.HYPER_HTTP_VERSION_2/// The HTTP/2 version.// We don't actually know anything about this pointer, it's up to the user// to do the right thing.VERSION_CSTR// `core::ffi::c_size_t` is a nightly-only experimental API.// https://github.com/rust-lang/rust/issues/88345// We have a lot of c-types in here, stop warning about their names!// fmt::Debug isn't helpful on FFI types// unreachable_pub warns `#[no_mangle] pub extern fn` in private mod.//! # hyper C API//! This part of the documentation describes the C API for hyper. That is, how//! to *use* the hyper library in C code. This is **not** a regular Rust//! module, and thus it is not accessible in Rust.//! ## Unstable//! The C API of hyper is currently **unstable**, which means it's not part of//! the semver contract as the rest of the Rust API is. Because of that, it's//! only accessible if `--cfg hyper_unstable_ffi` is passed to `rustc` when//! compiling. The easiest way to do that is setting the `RUSTFLAGS`//! environment variable.//! ## Building//! The C API is part of the Rust library, but isn't compiled by default. Using//! `cargo`, staring with `1.64.0`, it can be compiled with the following command://! ```notrust//! RUSTFLAGS="--cfg hyper_unstable_ffi" cargo rustc --crate-type cdylib --features client,http1,http2,ffiBoxAnyHYPER_POLL_READY/// Return in a poll function to indicate it was ready.HYPER_POLL_PENDING/// Return in a poll function to indicate it is still pending./// The passed in `hyper_waker` should be registered to wake up the task at/// some later point.HYPER_POLL_ERROR/// Return in a poll function indicate an error.TaskFuture/// The executor of all task futures./// There should never be contention on the mutex, as it is only locked/// to drive the futures. However, we cannot guarantee proper usage from/// `hyper_executor_poll()`, which in C could potentially be called inside/// one of the stored futures. The mutex isn't re-entrant, so doing so/// would result in a deadlock, but that's better than data corruption.spawn_queue/// The queue of futures that need to be pushed into the `driver`./// This is has a separate mutex since `spawn` could be called from inside/// a future, which would mean the driver's mutex is already locked.is_wokenExecWaker/// This is used to track when a future calls `wake` while we are within/// `hyper_executor::poll_next`./// A task executor for `hyper_task`s./// A task is a unit of work that may be blocked on IO, and can be polled to/// make progress on that work./// An executor can hold many tasks, included from unrelated HTTP connections./// An executor is single threaded. Typically you might have one executor per/// thread. Or, for simplicity, you may choose one executor per connection./// Progress on tasks happens only when `hyper_executor_poll` is called, and only/// on tasks whose corresponding `hyper_waker` has been called to indicate they/// are ready to make progress (for instance, because the OS has indicated there/// is more data to read or more buffer space available to write)./// Deadlock potential: `hyper_executor_poll` must not be called from within a task's/// callback. Doing so will result in a deadlock./// - hyper_executor_new:  Creates a new task executor./// - hyper_executor_push: Push a task onto the executor./// - hyper_executor_poll: Polls the executor, trying to make progress on any tasks that have notified that they are ready again./// - hyper_executor_free: Frees an executor and any incomplete tasks still part of it./// An async task./// A task represents a chunk of work that will eventually yield exactly one/// `hyper_task_value`. Tasks are pushed onto an executor, and that executor is/// responsible for calling the necessary private functions on the task to make/// progress. In most cases those private functions will eventually cause read/// or write callbacks on a `hyper_io` object to be called./// Tasks are created by various functions:/// - hyper_clientconn_handshake: Creates an HTTP client handshake task./// - hyper_clientconn_send:      Creates a task to send a request on the client connection./// - hyper_body_data:            Creates a task that will poll a response body for the next buffer of data./// - hyper_body_foreach:         Creates a task to execute the callback with each body chunk received./// Tasks then have a userdata associated with them using `hyper_task_set_userdata`. This/// is important, for instance, to associate a request id with a given request. When multiple/// tasks are running on the same executor, this allows distinguishing tasks for different/// requests./// Tasks are then pushed onto an executor, and eventually yielded from hyper_executor_poll:/// - hyper_executor_push:        Push a task onto the executor./// - hyper_executor_poll:        Polls the executor, trying to make progress on any tasks that have notified that they are ready again./// Once a task is yielded from poll, retrieve its userdata, check its type,/// and extract its value. This will require a case from void* to the appropriate type./// Methods on hyper_task:/// - hyper_task_type:            Query the return type of this task./// - hyper_task_value:           Takes the output value of this task./// - hyper_task_set_userdata:    Set a user data pointer to be associated with this task./// - hyper_task_userdata:        Retrieve the userdata that has been set via hyper_task_set_userdata./// - hyper_task_free:            Free a task./// An async context for a task that contains the related waker./// This is provided to `hyper_io`'s read and write callbacks. Currently/// its only purpose is to provide access to the waker. See `hyper_waker`./// Corresponding Rust type: <https://doc.rust-lang.org/std/task/struct.Context.html>hyper_waker/// A waker that is saved and used to waken a pending task./// This is provided to `hyper_io`'s read and write callbacks via `hyper_context`/// and `hyper_context_waker`./// When nonblocking I/O in one of those callbacks can't make progress (returns/// `EAGAIN` or `EWOULDBLOCK`), the callback has to return to avoid blocking the/// executor. But it also has to arrange to get called in the future when more/// data is available. That's the role of the async context and the waker. The/// waker can be used to tell the executor "this task is ready to make progress."/// The read or write callback, upon finding it can't make progress, must get a/// waker from the context (`hyper_context_waker`), arrange for that waker to be/// called in the future, and then return `HYPER_POLL_PENDING`./// The arrangements for the waker to be called in the future are up to the/// application, but usually it will involve one big `select(2)` loop that checks which/// FDs are ready, and a correspondence between FDs and waker objects. For each/// FD that is ready, the corresponding waker must be called. Then `hyper_executor_poll`/// must be called. That will cause the executor to attempt to make progress on each/// woken task./// Corresponding Rust type: <https://doc.rust-lang.org/std/task/struct.Waker.html>HYPER_TASK_EMPTY/// The value of this task is null (does not imply an error).HYPER_TASK_ERROR/// The value of this task is `hyper_error *`.HYPER_TASK_CLIENTCONN/// The value of this task is `hyper_clientconn *`.HYPER_TASK_RESPONSE/// The value of this task is `hyper_response *`.HYPER_TASK_BUF/// The value of this task is `hyper_buf *`./// A descriptor for what type a `hyper_task` value is.into_dyn_task_typeIntoDynTaskTypedrain_queue/// drain_queue locks both self.spawn_queue and self.driver, so it requires/// that neither of them be locked already.output_type// ===== impl hyper_executor =====// ===== impl WeakExec =====// ===== impl hyper_task =====// ===== impl AsTaskType =====// ===== impl hyper_context =====// ===== impl hyper_waker =====connection_keep_aliveconnection_closeconnection_hascontent_length_parse_allcontent_length_parse_all_valuesfrom_digitstransfer_encoding_is_chunkedis_chunkedis_chunked_add_chunkedmock//! # hyper//! hyper is a **fast** and **correct** HTTP implementation written in and for Rust.//! - HTTP/1 and HTTP/2//! - Asynchronous design//! - Leading in performance//! - Tested and **correct**//! - Extensive production use//! - [Client](client/index.html) and [Server](server/index.html) APIs//! If just starting out, **check out the [Guides](https://hyper.rs/guides/1/)//! first.**//! ## "Low-level"//! hyper is a lower-level HTTP library, meant to be a building block//! for libraries and applications.//! If looking for just a convenient HTTP client, consider the//! [reqwest](https://crates.io/crates/reqwest) crate.//! # Optional Features//! hyper uses a set of [feature flags] to reduce the amount of compiled code.//! It is possible to just enable certain features over others. By default,//! hyper does not enable any features but allows one to enable a subset for//! their use case. Below is a list of the available feature flags. You may//! also notice above each function, struct and trait there is listed one or//! more feature flags that are required for that item to be used.//! If you are new to hyper it is possible to enable the `full` feature flag//! which will enable all public APIs. Beware though that this will pull in//! many extra dependencies that you may not need.//! The following optional features are available://! - `http1`: Enables HTTP/1 support.//! - `http2`: Enables HTTP/2 support.//! - `client`: Enables the HTTP `client`.//! - `server`: Enables the HTTP `server`.//! [feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section//! ## Unstable Features//! hyper includes a set of unstable optional features that can be enabled through the use of a//! feature flag and a [configuration flag].//! The following is a list of feature flags and their corresponding `RUSTFLAG`://! - `ffi`: Enables C API for hyper `hyper_unstable_ffi`.//! - `tracing`: Enables debug logging with `hyper_unstable_tracing`.//! RUSTFLAGS="--cfg hyper_unstable_tracing" cargo build//! [configuration flag]: https://doc.rust-lang.org/reference/conditional-compilation.html//! # Stability//! It's worth talking a bit about the stability of hyper. hyper's API follows//! [SemVer](https://semver.org). Breaking changes will only be introduced in//! major versions, if ever. New additions to the API, such as new types,//! methods, or traits will only be added in minor versions.//! Some parts of hyper are documented as NOT being part of the stable API. The//! following is a brief list, you can read more about each one in the relevant//! part of the documentation.//! - Downcasting error types from `Error::source()` is not considered stable.//! - Private dependencies use of global variables is not considered stable.//!   So, if a dependency uses `log` or `tracing`, hyper doesn't promise it//!   will continue to do so.//! - Behavior from default options is not stable. hyper reserves the right to//!   add new options that are enabled by default which might alter the//!   behavior, for the purposes of protection. It is also possible to _change_//!   what the default options are set to, also in efforts to protect the//!   most people possible.// FIXME: re-implement tests with `async/await`/*
#[cfg(feature = "runtime")]
use std::collections::HashMap;
use std::cmp;
use std::io::{self, Read, Write};
#[cfg(feature = "runtime")]
use std::sync::{Arc, Mutex};

use bytes::Buf;
use futures::{Async, Poll};
#[cfg(feature = "runtime")]
use futures::Future;
use futures::task::{self, Task};
use tokio_io::{AsyncRead, AsyncWrite};

#[cfg(feature = "runtime")]
use crate::client::connect::{Connect, Connected, Destination};



#[cfg(feature = "runtime")]
pub struct Duplex {
    inner: Arc<Mutex<DuplexInner>>,
}

#[cfg(feature = "runtime")]
struct DuplexInner {
    handle_read_task: Option<Task>,
    read: AsyncIo<MockCursor>,
    write: AsyncIo<MockCursor>,
}

#[cfg(feature = "runtime")]
impl Duplex {
    pub(crate) fn channel() -> (Duplex, DuplexHandle) {
        let mut inner = DuplexInner {
            handle_read_task: None,
            read: AsyncIo::new_buf(Vec::new(), 0),
            write: AsyncIo::new_buf(Vec::new(), std::usize::MAX),
        };

        inner.read.park_tasks(true);
        inner.write.park_tasks(true);

        let inner = Arc::new(Mutex::new(inner));

        let duplex = Duplex {
            inner: inner.clone(),
        };
        let handle = DuplexHandle {
            inner: inner,
        };

        (duplex, handle)
    }
}

#[cfg(feature = "runtime")]
impl Read for Duplex {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        self.inner.lock().unwrap().read.read(buf)
    }
}

#[cfg(feature = "runtime")]
impl Write for Duplex {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        let mut inner = self.inner.lock().unwrap();
        let ret = inner.write.write(buf);
        if let Some(task) = inner.handle_read_task.take() {
            trace!("waking DuplexHandle read");
            task.notify();
        }
        ret
    }

    fn flush(&mut self) -> io::Result<()> {
        self.inner.lock().unwrap().write.flush()
    }
}

#[cfg(feature = "runtime")]
impl AsyncRead for Duplex {
}

#[cfg(feature = "runtime")]
impl AsyncWrite for Duplex {
    fn shutdown(&mut self) -> Poll<(), io::Error> {
        Ok(().into())
    }

    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
        let mut inner = self.inner.lock().unwrap();
        if let Some(task) = inner.handle_read_task.take() {
            task.notify();
        }
        inner.write.write_buf(buf)
    }
}

#[cfg(feature = "runtime")]
pub struct DuplexHandle {
    inner: Arc<Mutex<DuplexInner>>,
}

#[cfg(feature = "runtime")]
impl DuplexHandle {
    pub fn read(&self, buf: &mut [u8]) -> Poll<usize, io::Error> {
        let mut inner = self.inner.lock().unwrap();
        assert!(buf.len() >= inner.write.inner.len());
        if inner.write.inner.is_empty() {
            trace!("DuplexHandle read parking");
            inner.handle_read_task = Some(task::current());
            return Ok(Async::NotReady);
        }
        inner.write.read(buf).map(Async::Ready)
    }

    pub fn write(&self, bytes: &[u8]) -> Poll<usize, io::Error> {
        let mut inner = self.inner.lock().unwrap();
        assert_eq!(inner.read.inner.pos, 0);
        assert_eq!(inner.read.inner.vec.len(), 0, "write but read isn't empty");
        inner
            .read
            .inner
            .vec
            .extend(bytes);
        inner.read.block_in(bytes.len());
        Ok(Async::Ready(bytes.len()))
    }
}

#[cfg(feature = "runtime")]
impl Drop for DuplexHandle {
    fn drop(&mut self) {
        trace!("mock duplex handle drop");
        if !::std::thread::panicking() {
            let mut inner = self.inner.lock().unwrap();
            inner.read.close();
            inner.write.close();
        }
    }
}

#[cfg(feature = "runtime")]
type BoxedConnectFut = Box<dyn Future<Item=(Duplex, Connected), Error=io::Error> + Send>;

#[cfg(feature = "runtime")]
#[derive(Clone)]
pub struct MockConnector {
    mocks: Arc<Mutex<MockedConnections>>,
}

#[cfg(feature = "runtime")]
struct MockedConnections(HashMap<String, Vec<BoxedConnectFut>>);

#[cfg(feature = "runtime")]
impl MockConnector {
    pub fn new() -> MockConnector {
        MockConnector {
            mocks: Arc::new(Mutex::new(MockedConnections(HashMap::new()))),
        }
    }

    pub fn mock(&mut self, key: &str) -> DuplexHandle {
        use futures::future;
        self.mock_fut(key, future::ok::<_, ()>(()))
    }

    pub fn mock_fut<F>(&mut self, key: &str, fut: F) -> DuplexHandle
    where
        F: Future + Send + 'static,
    {
        self.mock_opts(key, Connected::new(), fut)
    }

    pub fn mock_opts<F>(&mut self, key: &str, connected: Connected, fut: F) -> DuplexHandle
    where
        F: Future + Send + 'static,
    {
        let key = key.to_owned();

        let (duplex, handle) = Duplex::channel();

        let fut = Box::new(fut.then(move |_| {
            trace!("MockConnector mocked fut ready");
            Ok((duplex, connected))
        }));
        self.mocks.lock().unwrap().0.entry(key)
            .or_insert(Vec::new())
            .push(fut);

        handle
    }
}

#[cfg(feature = "runtime")]
impl Connect for MockConnector {
    type Transport = Duplex;
    type Error = io::Error;
    type Future = BoxedConnectFut;

    fn connect(&self, dst: Destination) -> Self::Future {
        trace!("mock connect: {:?}", dst);
        let key = format!("{}://{}{}", dst.scheme(), dst.host(), if let Some(port) = dst.port() {
            format!(":{}", port)
        } else {
            "".to_owned()
        });
        let mut mocks = self.mocks.lock().unwrap();
        let mocks = mocks.0.get_mut(&key)
            .expect(&format!("unknown mocks uri: {}", key));
        assert!(!mocks.is_empty(), "no additional mocks for {}", key);
        mocks.remove(0)
    }
}


#[cfg(feature = "runtime")]
impl Drop for MockedConnections {
    fn drop(&mut self) {
        if !::std::thread::panicking() {
            for (key, mocks) in self.0.iter() {
                assert_eq!(
                    mocks.len(),
                    0,
                    "not all mocked connects for {:?} were used",
                    key,
                );
            }
        }
    }
}
*/EncodedBufHttp1TransactionWantsBodyLengthMessageHeadH2_PREFACE/// This handles a connection, which will have been established over an/// `Read + Write` (like a socket), and will likely include multiple/// `Transaction`s over HTTP./// The connection will determine when a message begins and ends as well as/// determine if this connection can be kept alive after the message,/// or if it is complete.set_write_strategy_queueset_max_buf_sizeset_read_buf_exact_sizeset_write_strategy_flattenset_h1_parser_configset_title_case_headersset_preserve_header_caseset_h09_responsesset_http1_max_headerspending_upgradeis_read_closedis_write_closedcan_read_headcan_read_bodyshould_error_on_eofhas_h2_prefixpoll_read_headon_read_head_errorpoll_read_bodywants_read_againpoll_read_keep_aliveis_mid_messagerequire_empty_read// This will check to make sure the io object read is empty.// This should only be called for Clients wanting to enter the idle// state.mid_message_detect_eofforce_io_readmaybe_notifytry_keep_alivecan_write_headcan_write_bodycan_buffer_bodywrite_headOutgoingencode_headfix_keep_alive// Fix keep-alive when Connection: keep-alive header is not presentenforce_version// If we know the remote speaks an older version, we try to fix up any messages// to work with our older peer.write_bodywrite_trailerswrite_body_and_endend_bodyon_parse_error// When we get a parse error, depending on what side we are, we might be able// to write a response before closing the connection.// - Client: there is nothing we can do// - Server: if Response hasn't been written yet, we can send a 4xx responsepoll_drain_or_close_read/// If the read side can be cheaply drained, do so. Otherwise, close.close_readclose_writetake_erroron_upgradeOnUpgrade// B and T are never pinnedallow_half_closecached_headers/// Re-usable HeaderMap to reduce allocating new ones./// If an error occurs when there wasn't a direct way to return it/// back to the user, this is set.keep_aliveKA/// Current keep-alive status./// If mid-message, the HTTP Method that started it./// This is used to know things such as if the message can include/// a body or not./// If set, called with each 1xx informational response received for/// the current request. MUST be unset after a non-1xx response is/// received.notify_read/// Set to true when the Dispatcher should poll read operations/// again. See the `maybe_notify` method for more.reading/// State of allowed reads/// State of allowed writes/// An expected pending HTTP upgrade./// Either HTTP/1.0 or 1.1 connectionallow_trailer_fields/// Flag to track if trailer fields are allowed to be sentKeepAlivewants_keep_alivedisable_keep_aliveprepare_upgrade/*
    //TODO: rewrite these using dispatch... someday...
    use futures::{Async, Future, Stream, Sink};
    use futures::future;

    use proto::{self, ClientTransaction, MessageHead, ServerTransaction};
    use super::super::Encoder;
    use mock::AsyncIo;

    use super::{Conn, Decoder, Reading, Writing};
    use ::uri::Uri;

    use std::str::FromStr;

    #[test]
    fn test_conn_init_read() {
        let good_message = b"GET / HTTP/1.1\r\n\r\n".to_vec();
        let len = good_message.len();
        let io = AsyncIo::new_buf(good_message, len);
        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);

        match conn.poll().unwrap() {
            Async::Ready(Some(Frame::Message { message, body: false })) => {
                assert_eq!(message, MessageHead {
                    subject: ::proto::RequestLine(::Get, Uri::from_str("/").unwrap()),
                    .. MessageHead::default()
                })
            },
            f => panic!("frame is not Frame::Message: {:?}", f)
        }
    }

    #[test]
    fn test_conn_parse_partial() {
        let _: Result<(), ()> = future::lazy(|| {
            let good_message = b"GET / HTTP/1.1\r\nHost: foo.bar\r\n\r\n".to_vec();
            let io = AsyncIo::new_buf(good_message, 10);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            assert!(conn.poll().unwrap().is_not_ready());
            conn.io.io_mut().block_in(50);
            let async = conn.poll().unwrap();
            assert!(async.is_ready());
            match async {
                Async::Ready(Some(Frame::Message { .. })) => (),
                f => panic!("frame is not Message: {:?}", f),
            }
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_init_read_eof_idle() {
        let io = AsyncIo::new_buf(vec![], 1);
        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
        conn.state.idle();

        match conn.poll().unwrap() {
            Async::Ready(None) => {},
            other => panic!("frame is not None: {:?}", other)
        }
    }

    #[test]
    fn test_conn_init_read_eof_idle_partial_parse() {
        let io = AsyncIo::new_buf(b"GET / HTTP/1.1".to_vec(), 100);
        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
        conn.state.idle();

        match conn.poll() {
            Err(ref err) if err.kind() == std::io::ErrorKind::UnexpectedEof => {},
            other => panic!("unexpected frame: {:?}", other)
        }
    }

    #[test]
    fn test_conn_init_read_eof_busy() {
        let _: Result<(), ()> = future::lazy(|| {
            // server ignores
            let io = AsyncIo::new_eof();
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.busy();

            match conn.poll().unwrap() {
                Async::Ready(None) => {},
                other => panic!("unexpected frame: {:?}", other)
            }

            // client
            let io = AsyncIo::new_eof();
            let mut conn = Conn::<_, proto::Bytes, ClientTransaction>::new(io);
            conn.state.busy();

            match conn.poll() {
                Err(ref err) if err.kind() == std::io::ErrorKind::UnexpectedEof => {},
                other => panic!("unexpected frame: {:?}", other)
            }
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_body_finish_read_eof() {
        let _: Result<(), ()> = future::lazy(|| {
            let io = AsyncIo::new_eof();
            let mut conn = Conn::<_, proto::Bytes, ClientTransaction>::new(io);
            conn.state.busy();
            conn.state.writing = Writing::KeepAlive;
            conn.state.reading = Reading::Body(Decoder::length(0));

            match conn.poll() {
                Ok(Async::Ready(Some(Frame::Body { chunk: None }))) => (),
                other => panic!("unexpected frame: {:?}", other)
            }

            // conn eofs, but tokio-proto will call poll() again, before calling flush()
            // the conn eof in this case is perfectly fine

            match conn.poll() {
                Ok(Async::Ready(None)) => (),
                other => panic!("unexpected frame: {:?}", other)
            }
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_message_empty_body_read_eof() {
        let _: Result<(), ()> = future::lazy(|| {
            let io = AsyncIo::new_buf(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n".to_vec(), 1024);
            let mut conn = Conn::<_, proto::Bytes, ClientTransaction>::new(io);
            conn.state.busy();
            conn.state.writing = Writing::KeepAlive;

            match conn.poll() {
                Ok(Async::Ready(Some(Frame::Message { body: false, .. }))) => (),
                other => panic!("unexpected frame: {:?}", other)
            }

            // conn eofs, but tokio-proto will call poll() again, before calling flush()
            // the conn eof in this case is perfectly fine

            match conn.poll() {
                Ok(Async::Ready(None)) => (),
                other => panic!("unexpected frame: {:?}", other)
            }
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_read_body_end() {
        let _: Result<(), ()> = future::lazy(|| {
            let io = AsyncIo::new_buf(b"POST / HTTP/1.1\r\nContent-Length: 5\r\n\r\n12345".to_vec(), 1024);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.busy();

            match conn.poll() {
                Ok(Async::Ready(Some(Frame::Message { body: true, .. }))) => (),
                other => panic!("unexpected frame: {:?}", other)
            }

            match conn.poll() {
                Ok(Async::Ready(Some(Frame::Body { chunk: Some(_) }))) => (),
                other => panic!("unexpected frame: {:?}", other)
            }

            // When the body is done, `poll` MUST return a `Body` frame with chunk set to `None`
            match conn.poll() {
                Ok(Async::Ready(Some(Frame::Body { chunk: None }))) => (),
                other => panic!("unexpected frame: {:?}", other)
            }

            match conn.poll() {
                Ok(Async::NotReady) => (),
                other => panic!("unexpected frame: {:?}", other)
            }
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_closed_read() {
        let io = AsyncIo::new_buf(vec![], 0);
        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
        conn.state.close();

        match conn.poll().unwrap() {
            Async::Ready(None) => {},
            other => panic!("frame is not None: {:?}", other)
        }
    }

    #[test]
    fn test_conn_body_write_length() {
        let _ = pretty_env_logger::try_init();
        let _: Result<(), ()> = future::lazy(|| {
            let io = AsyncIo::new_buf(vec![], 0);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            let max = super::super::io::DEFAULT_MAX_BUFFER_SIZE + 4096;
            conn.state.writing = Writing::Body(Encoder::length((max * 2) as u64));

            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'a'; max].into()) }).unwrap().is_ready());
            assert!(!conn.can_buffer_body());

            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'b'; 1024 * 8].into()) }).unwrap().is_not_ready());

            conn.io.io_mut().block_in(1024 * 3);
            assert!(conn.poll_complete().unwrap().is_not_ready());
            conn.io.io_mut().block_in(1024 * 3);
            assert!(conn.poll_complete().unwrap().is_not_ready());
            conn.io.io_mut().block_in(max * 2);
            assert!(conn.poll_complete().unwrap().is_ready());

            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'c'; 1024 * 8].into()) }).unwrap().is_ready());
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_body_write_chunked() {
        let _: Result<(), ()> = future::lazy(|| {
            let io = AsyncIo::new_buf(vec![], 4096);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.writing = Writing::Body(Encoder::chunked());

            assert!(conn.start_send(Frame::Body { chunk: Some("headers".into()) }).unwrap().is_ready());
            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'x'; 8192].into()) }).unwrap().is_ready());
            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_body_flush() {
        let _: Result<(), ()> = future::lazy(|| {
            let io = AsyncIo::new_buf(vec![], 1024 * 1024 * 5);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.writing = Writing::Body(Encoder::length(1024 * 1024));
            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'a'; 1024 * 1024].into()) }).unwrap().is_ready());
            assert!(!conn.can_buffer_body());
            conn.io.io_mut().block_in(1024 * 1024 * 5);
            assert!(conn.poll_complete().unwrap().is_ready());
            assert!(conn.can_buffer_body());
            assert!(conn.io.io_mut().flushed());

            Ok(())
        }).wait();
    }

    #[test]
    fn test_conn_parking() {
        use std::sync::Arc;
        use futures::executor::Notify;
        use futures::executor::NotifyHandle;

        struct Car {
            permit: bool,
        }
        impl Notify for Car {
            fn notify(&self, _id: usize) {
                assert!(self.permit, "unparked without permit");
            }
        }

        fn car(permit: bool) -> NotifyHandle {
            Arc::new(Car {
                permit: permit,
            }).into()
        }

        // test that once writing is done, unparks
        let f = future::lazy(|| {
            let io = AsyncIo::new_buf(vec![], 4096);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.reading = Reading::KeepAlive;
            assert!(conn.poll().unwrap().is_not_ready());

            conn.state.writing = Writing::KeepAlive;
            assert!(conn.poll_complete().unwrap().is_ready());
            Ok::<(), ()>(())
        });
        ::futures::executor::spawn(f).poll_future_notify(&car(true), 0).unwrap();


        // test that flushing when not waiting on read doesn't unpark
        let f = future::lazy(|| {
            let io = AsyncIo::new_buf(vec![], 4096);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.writing = Writing::KeepAlive;
            assert!(conn.poll_complete().unwrap().is_ready());
            Ok::<(), ()>(())
        });
        ::futures::executor::spawn(f).poll_future_notify(&car(false), 0).unwrap();


        // test that flushing and writing isn't done doesn't unpark
        let f = future::lazy(|| {
            let io = AsyncIo::new_buf(vec![], 4096);
            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
            conn.state.reading = Reading::KeepAlive;
            assert!(conn.poll().unwrap().is_not_ready());
            conn.state.writing = Writing::Body(Encoder::length(5_000));
            assert!(conn.poll_complete().unwrap().is_ready());
            Ok::<(), ()>(())
        });
        ::futures::executor::spawn(f).poll_future_notify(&car(false), 0).unwrap();
    }

    #[test]
    fn test_conn_closed_write() {
        let io = AsyncIo::new_buf(vec![], 0);
        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
        conn.state.close();

        match conn.start_send(Frame::Body { chunk: Some(b"foobar".to_vec().into()) }) {
            Err(_e) => {},
            other => panic!("did not return Err: {:?}", other)
        }

        assert!(conn.state.is_write_closed());
    }

    #[test]
    fn test_conn_write_empty_chunk() {
        let io = AsyncIo::new_buf(vec![], 0);
        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
        conn.state.writing = Writing::KeepAlive;

        assert!(conn.start_send(Frame::Body { chunk: None }).unwrap().is_ready());
        assert!(conn.start_send(Frame::Body { chunk: Some(Vec::new().into()) }).unwrap().is_ready());
        conn.start_send(Frame::Body { chunk: Some(vec![b'a'].into()) }).unwrap_err();
    }
    */MemReadDEFAULT_MAX_HEADERSChunkedCHUNKED_EXTENSIONS_LIMIT/// Maximum amount of bytes allowed in chunked extensions./// This limit is currentlty applied for the entire body, not per chunk.TRAILER_LIMIT/// Maximum number of bytes allowed for all trailer fields./// TODO: remove this when we land h1_max_header_size support/// Decoders to handle different Transfer-Encodings./// If a message body does not include a Transfer-Encoding, it *should*/// include a Content-Length header./// A Reader used when a Content-Length header is passed with a positive integer.ChunkedStatechunk_lenextensions_cnttrailers_buftrailers_cnth1_max_header_size/// A Reader used when Transfer-Encoding is `chunked`./// A Reader used for responses that don't indicate a length or chunked./// The bool tracks when EOF is seen on the transport./// Note: This should only used for `Response`s. It is illegal for a/// `Request` to be made with both `Content-Length` and/// `Transfer-Encoding: chunked` missing, as explained from the spec:/// > If a Transfer-Encoding header field is present in a response and/// > the chunked transfer coding is not the final encoding, the/// > message body length is determined by reading the connection until/// > it is closed by the server.  If a Transfer-Encoding header field/// > is present in a request and the chunked transfer coding is not/// > the final encoding, the message body length cannot be determined/// > reliably; the server MUST respond with the 400 (Bad Request)/// > status code and then close the connection.SizeLwsSizeLfBodyCrBodyLfTrailerLfEndCrEndLfchunkeddecode_fut// constructors// methodsor_overflowread_startread_sizeread_size_lwsread_extensionread_size_lfread_bodyread_body_crread_body_lfread_trailerread_trailer_lfread_end_crread_end_lfdecode_trailers// TODO: disallow Transfer-Encoding, Content-Length, Trailer, etc in trailers ??IncompleteBodyread_memtest_read_chunk_sizetest_read_sized_early_eoftest_read_chunked_early_eoftest_read_chunked_single_readtest_read_chunked_with_missing_zero_digittest_read_chunked_extensions_over_limittest_read_chunked_trailer_with_missing_lftest_read_chunked_after_eof// perform an async read using a custom buffer size and causing a blocking// read at the specified byteall_async_cases// iterate over the different ways that this async read could go.// tests blocking a read at each byte along the content - The shotgun approachtest_read_length_asynctest_read_chunked_asynctest_read_eof_asynctest_decode_trailerstest_trailer_max_headers_enforcedtest_trailer_max_header_size_huge_trailertest_trailer_max_header_size_many_small_trailers/*
    use std::io;
    use std::io::Write;
    use super::Decoder;
    use super::ChunkedState;
    use futures::{Async, Poll};
    use bytes::{BytesMut, Bytes};
    use crate::mock::AsyncIo;
    */DispatchedRequestHeadBsbody_txbody_rxPollItemPollErrorRecvItempoll_msgrecv_msgshould_pollClientRxrx_closed/// Run this dispatcher until HTTP says this connection is done,/// but don't call `Write::shutdown` on the underlying IO./// This is useful for old-style HTTP upgrades, but ignores/// newer-style upgrade API.poll_catchpoll_loopOptGuard/// A drop guard to allow a mutable borrow of an Option while being able to/// set whether the `Option` should be cleared on drop.guard_mutResponseHeadclient_read_bytes_before_writing_requestclient_flushing_is_not_ready_for_next_requestbody_empty_chunks_ignored// ===== impl OptGuard =====// ===== impl Server =====// ===== impl Client =====write_headers_title_caseStaticBufis_last/// Encoders to handle different Transfer-Encodings.BufKindNotEof/// An Encoder for when Transfer-Encoding includes `chunked`./// An Encoder for when Content-Length is set./// Enforces that the body is not longer than the Content-Length header.ChunkedEndinto_chunked_with_trailing_fieldsis_close_delimitedencode_trailersencode_and_endis_valid_trailer_fieldallowed_trailer_field_mapUSIZE_BYTESCHUNK_SIZE_MAX_BYTES// each byte will become 2 hexchunked_with_valid_trailerschunked_with_multiple_trailer_headerschunked_with_no_trailer_headerchunked_with_invalid_trailerschunked_with_title_case_headersParsedMessageINIT_BUFFER_SIZE/// The initial buffer size allocated before trying to read from IO.MINIMUM_MAX_BUFFER_SIZE/// The minimum value that can be set to max buffer size.DEFAULT_MAX_BUFFER_SIZE/// The default maximum read buffer size. If the buffer gets this big and/// a message is still not complete, a `TooLarge` error is triggered.// Note: if this changes, update server::conn::Http::max_buf_size docs.MAX_BUF_LIST_BUFFERS/// The maximum number of distinct `Buf`s to hold in a list before requiring/// a flush. Only affects when the buffer strategy is to queue buffers./// Note that a flush can happen before reaching the maximum. This simply/// forces a flush if the queue gets this big.flush_pipelinepartial_lenread_blockedread_buf_strategyReadStrategyread_buf_remaining_mut/// Return the "allocated" available space, not the potential space/// that could be allocated in the future.can_headers_buf/// Return whether we can append to the headers buffer./// Reasons we can't:/// - The write buf is in queue mode, and some of the past body is still///   needing to be flushed.headers_bufBBcan_bufferconsume_leading_linespoll_read_from_ioio_mutis_read_blockedpoll_flush_flattened/// Specialized version of `flush` when strategy is Flatten./// Since all buffered bytes are flattened into the single headers buffer,/// that skips some bookkeeping around using multiple buffers.// The `B` is a `Buf`, we never project a pin to it// TODO: This trait is old... at least rename to PollBytes or something...decrease_nowAdaptivewith_maxincr_power_of_twoprev_power_of_twomaybe_unshift/// If we've advanced the position a bit in this cursor, and wish to/// extend the underlying vector, we may wish to unshift the "read" bytes/// off, and move everything else over./// Re-usable buffer that holds message headers/// Deque of user buffers if strategy is QueueWriteStrategy// an internal buffer to collect writes before flushesset_strategytokio_testMockiobuf_write_empty_sliceparse_reads_until_blockedread_strategy_adaptive_incrementsread_strategy_adaptive_decrementsread_strategy_adaptive_stays_the_sameread_strategy_adaptive_max_fuzzwrite_buf_flattenwrite_buf_flatten_partially_flushedwrite_buf_queue_disable_auto// #[cfg(feature = "nightly")]// use test::Bencher;/*
    impl<T: Read> MemRead for AsyncIo<T> {
        fn read_mem(&mut self, len: usize) -> Poll<Bytes, io::Error> {
            let mut v = vec![0; len];
            let n = try_nb!(self.read(v.as_mut_slice()));
            Ok(Async::Ready(BytesMut::from(&v[..n]).freeze()))
        }
    }
    *//*
    TODO: needs tokio_test::io to allow configure write_buf calls
    #[test]
    fn write_buf_queue() {
        let _ = pretty_env_logger::try_init();

        let mock = AsyncIo::new_buf(vec![], 1024);
        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);


        buffered.headers_buf().extend(b"hello ");
        buffered.buffer(Cursor::new(b"world, ".to_vec()));
        buffered.buffer(Cursor::new(b"it's ".to_vec()));
        buffered.buffer(Cursor::new(b"hyper!".to_vec()));
        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 3);
        buffered.flush().unwrap();

        assert_eq!(buffered.io, b"hello world, it's hyper!");
        assert_eq!(buffered.io.num_writes(), 1);
        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 0);
    }
    */// #[bench]// fn bench_write_buf_flatten_buffer_chunk(b: &mut Bencher) {//     let s = "Hello, World!";//     b.bytes = s.len() as u64;//     let mut write_buf = WriteBuf::<bytes::Bytes>::new();//     write_buf.set_strategy(WriteStrategy::Flatten);//     b.iter(|| {//         let chunk = bytes::Bytes::from(s);//         write_buf.buffer(chunk);//         ::test::black_box(&write_buf);//         write_buf.headers.bytes.clear();//TODO: move out of h1::ioon_erroris_servershould_error_on_parse_eofshould_read_firstupdate_date/// Result newtype for Http1Transaction::parse.expect_continuewants_upgradereq_method/// Passed to Http1Transaction::encode/// Extra flags that a request "wants", like expect-continue or upgrades.smallvec_inlineRequestLineAVERAGE_HEADER_SIZEheader_namemaybe_panicis_complete_fast/// A fast scan for the end of a message./// Used when there was a partial read, to skip full parsing on a/// a slow connection.encode_headers/// Returns Some(length, wants_upgrade) if successful./// Returns None if this message head should be skipped (like a 100 status).obs_fold_lineHeaderIndicesset_content_lengthrecord_header_indicestitle_case// Write header names as title case. The header name is assumed to be ASCII.write_headers_original_caseFastWritetest_parse_responseH09_RESPONSEtest_parse_response_h09_allowedtest_parse_response_h09_rejectedtest_parse_allow_response_with_spaces_before_colonstest_parse_reject_response_with_spaces_before_colonstest_decoder_responsetest_client_obs_fold_linetest_client_request_encode_title_casetest_client_request_encode_orig_casetest_client_request_encode_orig_and_title_caseparse_header_htabstest_is_complete_fasttest_write_headers_orig_case_empty_valuetest_write_headers_orig_case_multiple_entries// There are 2 main roles, Client and Server.SendStreamPongerRecorderH2UpgradedPipeToSendStreamSendBufSendWhenUpgradedSendStreamResponseFutureConnDropRef///// An mpsc channel is used to help notify the `Connection` task when *all*///// other handles to it have been dropped, so that it can shutdown.ConnEof///// A oneshot channel watches the `Connection` task, and when it completes,///// the "dispatch" task will be notified and can shutdown sooner.DEFAULT_CONN_WINDOW// Our defaults are chosen for the "majority" case, which usually are not// resource constrained, and so the spec default of 64kb can be too limiting// for performance.DEFAULT_STREAM_WINDOW// 5mbDEFAULT_MAX_FRAME_SIZE// 2mbDEFAULT_MAX_SEND_BUF_SIZE// 16kbDEFAULT_MAX_HEADER_LIST_SIZE// 1mbDEFAULT_INITIAL_MAX_SEND_STREAMS// The maximum number of concurrent streams that the client is allowed to open// before it receives the initial SETTINGS frame from the server.// This default value is derived from what the HTTP/2 spec recommends as the// minimum value that endpoints advertise to their peers. It means that using// this value will minimize the chance of the failure where the local endpoint// attempts to open too many streams and gets rejected by the remote peer with// the `REFUSED_STREAM` error.initial_conn_window_sizemax_send_buffer_sizenew_buildernew_ping_configConnMapErrConnTaskH2ClientFutureis_connectFutCtxconn_drop_refconn_eofh2_txreq_rxfut_ctxPipeMappoll_pipeResponseFutMapSPEC_WINDOW_SIZE/// Default initial stream window size defined in HTTP2 spec.CONNECTION_HEADERS// List of connection headers from RFC 9110 Section 7.6.1// TE headers are allowed in HTTP/2 requests as long as the value is "trailers", so they're// tested separately.strip_connection_headerson_user_errsend_eos_frameSendStreamExtsend_streamrecv_streamh2_to_io_errorNeuteredreserve_capacitypoll_capacitypoll_resetas_inner_uncheckedimpossible// body adapters used by both Client and ServerWindowSizebdp_initial_window/// If no frames are received in this amount of time, a PING frame is sent./// After sending a keepalive PING, the connection will be closed if/// a pong is not received in this amount of time./// If true, sends pings even when there are no active streams.bdpBdpping_pongping_sent_at// bdp/// If `Some`, bdp is enabled, and this tracks how many bytes have been/// read during the current sample.next_bdp_at/// We delay a variable amount of time between BDP pings. This allows us/// to send less pings as the bandwidth stabilizes.last_read_at// keep-alive/// If `Some`, keep-alive is enabled, and the Instant is how long ago/// the connection read the last frame.is_keep_alive_timed_out/// Current BDP in bytesmax_bandwidth/// Largest bandwidth we've seen so far.rtt/// Round trip time in secondsping_delay/// Delay the next ping by this amount./// This will change depending on how stable the current bandwidth is.stable_count/// The count of ping round trips where BDP has stayed the same.while_idleKeepAliveStateScheduledPingSentPongedSizeUpdateKeepAliveTimedOutrecord_datarecord_non_datafor_stream/// If the incoming stream is already closed, convert self into/// a disabled reporter.ensure_not_timed_outis_ping_sentupdate_last_read_atBDP_LIMIT/// Any higher than this likely will be hitting the TCP flow control.stabilize_delaymaybe_schedulemaybe_pingmaybe_timeoutcrate_error//! HTTP2 Ping usage//! hyper uses HTTP2 pings for two purposes://! 1. Adaptive flow control using BDP//! 2. Connection keep-alive//! Both cases are optional.//! # BDP Algorithm//! 1. When receiving a DATA frame, if a BDP ping isn't outstanding://!    1a. Record current time.//!    1b. Send a BDP ping.//! 2. Increment the number of received bytes.//! 3. When the BDP ping ack is received://!    3a. Record duration from sent time.//!    3b. Merge RTT with a running average.//!    3c. Calculate bdp as bytes/rtt.//!    3d. If bdp is over 2/3 max, set new max to bdp and update windows.// ===== impl Config =====// ===== impl Recorder =====// ===== impl Ponger =====// ===== impl Shared =====// ===== impl Bdp =====// ===== impl KeepAlive =====// ===== impl KeepAliveTimedOut =====SendResponseHttp2ServerConnExecHttpService// At the same time, a server more often has multiple clients connected, and// so is more likely to use more resources than a client would.DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE// 400kbDEFAULT_MAX_LOCAL_ERROR_RESET_STREAMSenable_connect_protocolmax_local_error_reset_streamsdate_headerping_confighsHandshakingServingclosinggraceful_shutdownResBodypoll_serverpoll_pingConnectPartsH2Streampoll2/// HTTP version of the message.subject/// Subject (request line or status line) of Incoming message./// Headers of the Incoming message./// Extensions./// An Incoming Message head. Includes request/status line, and headers./// An incoming request message./// An incoming response message./// Content-Length/// Transfer-Encoding: chunked (if h1)/// Dispatcher completely shutdown connection./// Dispatcher has pending upgrade, and so did not shutdown./// Status of when a Dispatcher future completes.into_response//! Pieces pertaining to the HTTP message protocol.//! Trait aliases//! Traits in this module ease setting bounds and usually automatically//! implemented by implementing another trait./// Attempts to read bytes into the `buf`./// On success, returns `Poll::Ready(Ok(()))` and places data in the/// unfilled portion of `buf`. If no data was read (`buf.remaining()` is/// unchanged), it implies that EOF has been reached./// If no data is available for reading, the method returns `Poll::Pending`/// and arranges for the current task (via `cx.waker()`) to receive a/// notification when the object becomes readable or is closed./// Reads bytes from a source./// This trait is similar to `std::io::Read`, but supports asynchronous reads./// Attempt to write bytes from `buf` into the destination./// On success, returns `Poll::Ready(Ok(num_bytes_written)))`. If/// successful, it must be guaranteed that `n <= buf.len()`. A return value/// of `0` means that the underlying object is no longer able to accept/// bytes, or that the provided buffer is empty./// `Poll::Pending` and arranges for the current task (via `cx.waker()`) to/// receive a notification when the object becomes writable or is closed./// Attempts to flush the object./// receive a notification when the object can make progress./// Attempts to shut down this writer./// Returns whether this writer has an efficient `poll_write_vectored`/// The default implementation returns `false`./// Like `poll_write`, except that it writes from a slice of buffers./// This trait is similar to `std::io::Write`, but for asynchronous writes.filled/// A wrapper around a byte buffer that is incrementally filled and initialized./// This type is a sort of "double cursor". It tracks three regions in the/// buffer: a region at the beginning of the buffer that has been logically/// filled with data, a region that has been initialized at some point but not/// yet logically filled, and a region at the end that may be uninitialized./// The filled region is guaranteed to be a subset of the initialized region./// In summary, the contents of the buffer can be visualized as:/// [             capacity              ]/// [ filled |         unfilled         ]/// [    initialized    | uninitialized ]/// It is undefined behavior to de-initialize any bytes from the uninitialized/// region, since it is merely unknown whether this region is uninitialized or/// not, and if part of it turns out to be initialized, it must stay initialized./// The cursor part of a [`ReadBuf`]./// This is created by calling `ReadBuf::unfilled()`./// Create a new `ReadBuf` with a slice of initialized bytes./// Create a new `ReadBuf` with a slice of uninitialized bytes./// Get a slice of the buffer that has been filled in with bytes.'cursorunfilled/// Get a cursor to the unfilled portion of the buffer./// Access the unfilled part of the buffer./// The caller must not uninitialize any bytes that may have been/// initialized before./// Advance the `filled` cursor by `n` bytes./// The caller must take care that `n` more bytes have been initialized./// This value is equal to the length of the slice returned by `as_mut()``./// Transfer bytes into `self`` from `src` and advance the cursor/// by the number of bytes written.pin_as_deref_mut/// Polyfill for Pin::as_deref_mut()/// TODO: use Pin::as_deref_mut() instead once stabilized// New IO traits? What?! Why, are you bonkers?// I mean, yes, probably. But, here's the goals:// 1. Supports poll-based IO operations.// 2. Opt-in vectored IO.// 3. Can use an optional buffer pool.// 4. Able to add completion-based (uring) IO eventually.// Frankly, the last point is the entire reason we're doing this. We want to// have forwards-compatibility with an eventually stable io-uring runtime. We// don't need that to work right away. But it must be possible to add in here// without breaking hyper 1.0.// While in here, if there's small tweaks to poll_read or poll_write that would// allow even the "slow" path to be faster, such as if someone didn't remember// to forward along an `is_completion` call./// Place the future into the executor to be run./// An executor of futures./// This trait allows Hyper to abstract over async runtimes. Implement this trait for your own type./// # use hyper::rt::Executor;/// # use std::future::Future;/// struct TokioExecutor;/// impl<F> Executor<F> for TokioExecutor///     F: Future + Send + 'static,///     F::Output: Send + 'static,///     fn execute(&self, future: F) {///         tokio::spawn(future);//! Runtime components//! This module provides traits and types that allow hyper to be runtime-agnostic.//! By abstracting over async runtimes, hyper can work with different executors, timers, and IO transports.//! The main components in this module are://! - **Executors**: Traits for spawning and running futures, enabling integration with any async runtime.//! - **Timers**: Abstractions for sleeping and scheduling tasks, allowing time-based operations to be runtime-independent.//! - **IO Transports**: Traits for asynchronous reading and writing, so hyper can work with various IO backends.//! By implementing these traits, you can customize how hyper interacts with your chosen runtime environment.//! To learn more, [check out the runtime guide](https://hyper.rs/guides/1/init/runtime/)./// Return a future that resolves in `duration` time./// Return a future that resolves at `deadline`./// Reset a future to resolve at `new_deadline` instead./// A timer which provides timer-like functions.__type_id/// This method is private and can not be implemented by downstream crate/// A future returned by a `Timer`./// Check whether the type is the same as `T`downcast_mut_pin/// Downcast a pinned &mut Sleep object to its original type//! This is a re-implementation of downcast methods from std::any::Any//! Provides a timer trait with timer-like functions//! Example using tokio timer://! use std::{//!     future::Future,//!     pin::Pin,//!     task::{Context, Poll},//!     time::{Duration, Instant},//! use hyper::rt::{Timer, Sleep};//! #[derive(Clone, Debug)]//! pub struct TokioTimer;//! impl Timer for TokioTimer {//!     fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {//!         Box::pin(TokioSleep {//!             inner: tokio::time::sleep(duration),//!     fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {//!             inner: tokio::time::sleep_until(deadline.into()),//!     fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {//!         if let Some(sleep) = sleep.as_mut().downcast_mut_pin::<TokioSleep>() {//!             sleep.reset(new_deadline.into())//!     pub(crate) struct TokioSleep {//!         #[pin]//!         pub(crate) inner: tokio::time::Sleep,//! impl Future for TokioSleep {//!     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {//!         self.project().inner.poll(cx)//! impl Sleep for TokioSleep {}//! impl TokioSleep {//!     pub fn reset(self: Pin<&mut Self>, deadline: Instant) {//!         self.project().inner.as_mut().reset(deadline.into());Http1DispatcherServerTransactionh1_half_closeh1_keep_aliveh1_header_read_timeoutpipeline_flush/// A configuration builder for HTTP/1 server connections./// # use std::time::Duration;/// # use hyper::server::conn::http1::Builder;/// let mut http = Builder::new();/// // Set options one at a time/// http.half_close(false);/// // Or, chain multiple options/// http.keep_alive(false).title_case_headers(true).max_buf_size(8192);/// Use [`Builder::serve_connection`](struct.Builder.html#method.serve_connection)/// to bind the built connection to a service./// If the client sent additional bytes after its last request, and/// this connection "ended" with an upgrade, the read buffer will contain/// those bytes./// The `Service` used to serve this connection./// Start a graceful shutdown process for this connection./// This `Connection` should continue to be polled until shutdown/// can finish./// This should only be called while the `Connection` future is still/// pending. If called after `Connection::poll` has resolved, this does/// If the IO object has been "rewound" the io will not contain those bytes rewound./// This should only be called after `poll_without_shutdown` signals/// that the connection is "done". Otherwise, it may not have finished/// flushing all necessary HTTP bytes./// This method will panic if this connection is using an h2 protocol./// This errors if the underlying connection protocol is not HTTP/1./// Create a new connection builder.half_close/// Set whether HTTP/1 connections should support half-closures./// Clients can chose to shutdown their write-side while waiting/// for the server to respond. Setting this to `true` will/// prevent closing the connection immediately if `read`/// detects an EOF in the middle of a request./// Enables or disables HTTP/1 keep-alive./// Default is true./// Set whether multiple spaces are allowed as delimiters in request lines./// in a private extension on the `Request`. It will also look for and use/// such an extension in any provided `Response`./// When a request is received, the parser will reserve a buffer to store headers for optimal/// If server receives more headers than the buffer size, it responds to the client with/// "431 Request Header Fields Too Large"./// allocation will occur for each request, and there will be a performance drop of about 5%.header_read_timeout/// Set a timeout for reading client request headers. If a client does not/// transmit the entire header within this time, the connection is closed./// Requires a [`Timer`] set by [`Builder::timer`] to take effect. Panics if `header_read_timeout` is configured/// without a [`Timer`]./// Pass `None` to disable./// Default is 30 seconds.auto_date_header/// Set whether the `date` header should be included in HTTP responses./// Note that including the `date` header is recommended by RFC 7231./// Aggregates flushes to better support pipelined responses./// Experimental, may have bugs./// Set the timer used in background tasks.serve_connection/// Bind a connection together with a [`Service`](crate::service::Service)./// This returns a Future that must be polled in order for HTTP to be/// driven on the connection./// If a timeout option has been configured, but a `timer` has not been/// provided, calling `serve_connection` will panic./// # use hyper::{body::Incoming, Request, Response};/// # use hyper::service::Service;/// # use hyper::rt::{Read, Write};/// # async fn run<I, S>(some_io: I, some_service: S)/// # where/// #     I: Read + Write + Unpin + Send + 'static,/// #     S: Service<hyper::Request<Incoming>, Response=hyper::Response<Incoming>> + Send + 'static,/// #     S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,/// #     S::Future: Send,/// let http = Builder::new();/// let conn = http.serve_connection(some_io, some_service);/// if let Err(e) = conn.await {///     eprintln!("server connection error: {}", e);/// A future binding a connection with a Service with Upgrade support.//! HTTP/1 Server Connections// ===== impl Connection =====// ===== impl Builder =====/// A configuration builder for HTTP/2 server connections./// This starts with the default options, and an executor which is a type/// that implements [`Http2ServerConnExec`] trait./// [`Http2ServerConnExec`]: crate::rt::bounds::Http2ServerConnExec/// Configures the maximum number of local reset streams allowed before a GOAWAY will be sent./// If not set, hyper will use a default, currently of 1024./// If `None` is supplied, hyper will not apply any limit./// This is not advised, as it can potentially expose servers to DOS vulnerabilities./// See <https://rustsec.org/advisories/RUSTSEC-2024-0003.html> for more information./// Sets the max connection-level flow control for HTTP2./// Sets the [`SETTINGS_MAX_CONCURRENT_STREAMS`][spec] option for HTTP2/// connections./// Default is 200, but not part of the stability of hyper. It could change/// in a future release. You are encouraged to set your own limit./// Passing `None` will remove any limit./// [spec]: https://httpwg.org/specs/rfc9113.html#SETTINGS_MAX_CONCURRENT_STREAMS/// Default is currently ~400KB, but may change./// Enables the [extended CONNECT protocol]./// [extended CONNECT protocol]: https://datatracker.ietf.org/doc/html/rfc8441#section-4Bd//! HTTP/2 Server Connections//!  Server connection API.//! single connection. Accepting a connection and binding it with a service//! This module is split by HTTP version, providing a connection builder for//! each. They work similarly, but they each have specific options.//! If your server needs to support both versions, an auto-connection builder is//! provided in the [`hyper-util`](https://github.com/hyperium/hyper-util/tree/master)//! crate. This builder wraps the HTTP/1 and HTTP/2 connection builders from this//! module, allowing you to set configuration for both. The builder will then check//! the version of the incoming connection and serve it accordingly.//! HTTP Server//! A "server" is usually created by listening on a port for new connections,//! parse HTTP requests, and hand them off to a `Service`.//! How exactly you choose to listen for connections is not something hyper//! concerns itself with. After you have a connection, you can handle HTTP over//! it with the types in the [`conn`] module./// The [`Body`] body of the [`Response`]./// The error type that can occur within this [`Service`]./// Note: Returning an `Error` to a hyper server, the behavior depends on the protocol. In/// most cases, hyper will cause the connection to be abruptly aborted. In most cases, it is/// better to return a `Response` with a 4xx or 5xx status code./// See [`Service::Error`] for more information./// The [`Future`] returned by this [`Service`].ReqBody/// An asynchronous function from [`Request`] to [`Response`]./// This is a *sealed* trait, meaning that it can not be implemented directly. Rather, it is an/// alias for [`Service`]s that accept a [`Request`] and return a [`Future`] that resolves to a/// [`Response`]. External callers should implement [`Service`] instead./// Rather than being generic over the request and response, this trait is generic across the/// request [`Body`] and response [`Body`]./// See the crate-level [`service`][crate::service] documentation for more information./// See [`Service`] for more information.service_fn//! Asynchronous Services//! A [`Service`] is a trait representing an asynchronous//! function of a request to a response. It's similar to//! `async fn(Request) -> Result<Response, Error>`.//! The argument and return value isn't strictly required to be for HTTP.//! Therefore, hyper uses several "trait aliases" to reduce clutter around//! bounds. These are://! - `HttpService`: This is blanketly implemented for all types that//!   implement `Service<http::Request<B1>, Response = http::Response<B2>>`.//! # HttpService//! In hyper, especially in the server setting, a `Service` is usually bound//! to a single connection. It defines how to respond to **all** requests that//! connection will receive.//! The helper [`service_fn`] should be sufficient for most cases, but//! if you need to implement `Service` for a type manually, you can follow the example//! in `service_struct_impl.rs`./// Responses given by the service./// Errors produced by the service./// Note: Returning an `Error` to a hyper server, the behavior depends on the/// protocol. In most cases, hyper will cause the connection to be abruptly aborted./// It will abort the request however the protocol allows, either with some sort of RST_STREAM,/// or killing the connection if that doesn't exist./// The future response value./// Process the request and return the response asynchronously./// `call` takes `&self` instead of `mut &self` because:/// - It prepares the way for async fn,///   since then the future only borrows `&self`, and thus a Service can concurrently handle///   multiple outstanding requests at once./// - It's clearer that Services can likely be cloned./// - To share state across clones, you generally need `Arc<Mutex<_>>`///   That means you're not really using the `&mut self` and could do with a `&self`.///   The discussion on this is here: <https://github.com/hyperium/hyper/issues/3040>/// An asynchronous function from a `Request` to a `Response`./// The `Service` trait is a simplified interface making it easy to write/// network applications in a modular and reusable way, decoupled from the/// underlying protocol./// # Functional/// A `Service` is a function of a `Request`. It immediately returns a/// [`Future`] representing the eventual completion of processing the/// request. The actual request processing may happen at any time in the/// future, on any thread or executor. The processing may depend on calling/// other services. At some point in the future, the processing will complete,/// and the [`Future`] will resolve to a response or an error./// At a high level, the `Service::call` function represents an RPC request. The/// `Service` value can be a server or a client./// # Utilities/// The [`hyper-util`][util] crate provides facilities to bridge this trait to/// other libraries, such as [`tower`][tower], which might provide their/// own `Service` variants./// See [`hyper_util::service`][util-service] for more information./// [tower]: https://docs.rs/tower/// [util]: https://docs.rs/hyper-util/// [util-service]: https://docs.rs/hyper-util/latest/hyper_util/service/index.htmlServiceFn/// Create a `Service` from a function./// use hyper::{body, Request, Response, Version};/// use http_body_util::Full;/// use hyper::service::service_fn;/// let service = service_fn(|req: Request<body::Incoming>| async move {///     if req.version() == Version::HTTP_11 {///         Ok(Response::new(Full::<Bytes>::from("Hello World")))///         // Note: it's usually better to return a Response///         // with an appropriate StatusCode instead of an Err.///         Err("not HTTP/1.1, abort connection")_req/// Service returned by [`service_fn`]debug_spaninfo_spantrace_spanwarn_span// For completeness, wrappers around all of tracing's public logging and span macros are provided,// even if they are not used at the present time./// An upgraded HTTP connection./// This type holds a trait object internally of the original IO that/// was used to speak HTTP before the upgrade. It can be used directly/// as a [`Read`] or [`Write`] for convenience./// Alternatively, if the exact type is known, this can be deconstructed/// into its parts./// A future for a possible HTTP upgrade./// If no upgrade was available, or it doesn't succeed, yields an `Error`./// The original IO object used before the upgrade./// The deconstructed parts of an [`Upgraded`] type./// Includes the original IO type, and a read buffer of bytes that the/// HTTP state machine may have already read before completing an upgrade.CanUpgrade/// Gets a pending HTTP upgrade from this message./// This can be called on the following types:/// - `http::Request<B>`/// - `http::Response<B>`/// - `&mut http::Request<B>`/// - `&mut http::Response<B>`/// Tries to downcast the internal trait object to the type passed./// On success, returns the downcasted parts. On error, returns the/// `Upgraded` back./// Don't fulfill the pending Upgrade, but instead signal that/// upgrades are handled manually.UpgradeExpected/// Error cause returned when an upgrade was expected but canceled/// for whatever reason./// This likely means the actual `Conn` future wasn't polled and upgraded.__hyper_type_id__hyper_is__hyper_downcastupgraded_downcast// TODO: replace with tokio_test::io when it can test write_buf//! HTTP Upgrades//! This module deals with managing [HTTP Upgrades][mdn] in hyper. Since//! several concepts in HTTP allow for first talking HTTP, and then converting//! to a different protocol, this module conflates them into a single API.//! Those include://! - HTTP/1.1 Upgrades//! - HTTP `CONNECT`//! You are responsible for any other pre-requisites to establish an upgrade,//! such as sending the appropriate headers, methods, and status codes. You can//! then use [`on`][] to grab a `Future` which will resolve to the upgraded//! connection object, or an error if the upgrade fails.//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism//! # Client//! Sending an HTTP upgrade from the [`client`](super::client) involves setting//! either the appropriate method, if wanting to `CONNECT`, or headers such as//! `Upgrade` and `Connection`, on the `http::Request`. Once receiving the//! `http::Response` back, you must check for the specific information that the//! upgrade is agreed upon by the server (such as a `101` status code), and then//! get the `Future` from the `Response`.//! # Server//! Receiving upgrade requests in a server requires you to check the relevant//! headers in a `Request`, and if an upgrade should be done, you then send the//! corresponding headers in a response. To then wait for hyper to finish the//! upgrade, you call `on()` with the `Request`, and then can spawn a task//! awaiting it.//! See [this example][example] showing how upgrades work with both//! Clients and Servers.//! [example]: https://github.com/hyperium/hyper/blob/master/examples/upgrades.rs// ===== impl Upgraded =====// ===== impl OnUpgrade =====// ===== impl Pending =====// ===== impl UpgradeExpected =====// ===== impl Io =====WantsClientCertClientConfigConfigBuilderWantsVerifierCertificateResultwith_native_roots/// This configures the platform's trusted certs, as implemented by/// rustls-native-certs/// This will return an error if no valid certs were found. In that case,/// it's recommended to use `with_webpki_roots`.with_webpki_roots/// This configures the webpki roots, which are Mozilla's set of/// trusted roots as packaged by webpki-roots.ConfigBuilderExt/// Methods for configuring roots/// This adds methods (gated by crate features) for easily configuring/// TLS server roots a rustls ClientConfig will trust.HttpConnectorCryptoProviderDefaultServerNameResolverHttpsConnectorResolveServerNameConnectorBuilder/// A builder for an [`HttpsConnector`]/// This makes configuration flexible and explicit and ensures connector/// features match crate features/// use hyper_rustls::HttpsConnectorBuilder;/// # #[cfg(all(feature = "webpki-roots", feature = "http1", feature="aws-lc-rs"))]/// # let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();///     let https = HttpsConnectorBuilder::new()///     .with_webpki_roots()///     .https_only()///     .enable_http1()///     .build();WantsTlsConfig/// State of a builder that needs a TLS client config next/// Creates a new [`ConnectorBuilder`]with_tls_configWantsSchemes/// Passes a rustls [`ClientConfig`] to configure the TLS connection/// The [`alpn_protocols`](ClientConfig::alpn_protocols) field is/// required to be empty (or the function will panic) and will be/// rewritten to match the enabled schemes (see/// [`enable_http1`](ConnectorBuilder::enable_http1),/// [`enable_http2`](ConnectorBuilder::enable_http2)) before the/// connector is built./// Shorthand for using rustls' default crypto provider and safe defaults, with/// native roots./// See [`ConfigBuilderExt::with_native_roots`]with_provider_and_native_roots/// Shorthand for using a custom [`CryptoProvider`] and native roots/// Shorthand for using rustls' default crypto provider and its/// safe defaults./// See [`ConfigBuilderExt::with_webpki_roots`]with_provider_and_webpki_roots/// Shorthand for using a custom [`CryptoProvider`], Rustls' safe default/// protocol versions and Mozilla rootstls_config/// State of a builder that needs schemes (https:// and http://) to be/// configured nexthttps_onlyWantsProtocols1/// Enforce the use of HTTPS when connecting/// Only URLs using the HTTPS scheme will be connectable.https_or_http/// Allow both HTTPS and HTTP when connecting/// HTTPS URLs will be handled through rustls,/// HTTP URLs will be handled by the lower-level connector.server_name_resolver/// State of a builder that needs to have some protocols (HTTP1 or later)/// enabled next/// No protocol has been enabled at this point.wrap_connectorenable_http1WantsProtocols2/// Enable HTTP1/// This needs to be called explicitly, no protocol is enabled by defaultwith_server_name_resolver/// Override server name for the TLS stack/// By default, for each connection hyper-rustls will extract host portion/// of the destination URL and verify that server certificate contains/// If this method is called, hyper-rustls will instead use this resolver/// to compute the value used to verify the server certificate.with_server_name/// If this method is called, hyper-rustls will instead verify that server/// certificate contains `override_server_name`. Domain name included in/// the URL will not affect certificate validation./// State of a builder with HTTP1 enabled, that may have some other/// protocols (HTTP2 or later) enabled next/// At this point a connector can be built, see/// [`build`](ConnectorBuilder<WantsProtocols2>::build) and/// [`wrap_connector`](ConnectorBuilder<WantsProtocols2>::wrap_connector)./// This builds an [`HttpsConnector`] built on hyper's default [`HttpConnector`]/// This wraps an arbitrary low-level connector into an [`HttpsConnector`]// Typical usagetest_reject_predefined_alpnensure_global_stateTokioIoTlsConnectorMaybeHttpsStreamBoxErrorforce_https/// A Connector for the `https` scheme./// Creates a [`crate::HttpsConnectorBuilder`] to configure a `HttpsConnector`./// This is the same as [`crate::HttpsConnectorBuilder::new()`].enforce_https/// Force the use of HTTPS when connecting./// If a URL is not `https` when connecting, an error is returned./// The default server name resolver, which uses the hostname in the URI.FixedServerNameResolver/// A server name resolver which always returns the same fixed name./// Creates a new resolver returning the specified name./// Maps a [`Uri`] into a [`ServerName`]./// A trait implemented by types that can resolve a [`ServerName`] for a request.HttpsConnectorBuilderconnects_httpsconnects_httpconnects_https_onlyenforces_https_onlywarn_builderstates/// The various states of the [`HttpsConnectorBuilder`]//! # hyper-rustls//! A pure-Rust HTTPS connector for [hyper](https://hyper.rs), based on//! [Rustls](https://github.com/rustls/rustls).//! ## Example client//! # #[cfg(all(feature = "rustls-native-certs", feature = "http1"))]//! use http_body_util::Empty;//! use hyper::body::Bytes;//! use hyper_util::client::legacy::Client;//! use hyper_util::rt::TokioExecutor;//! let mut rt = tokio::runtime::Runtime::new().unwrap();//! let url = ("https://hyper.rs").parse().unwrap();//! let https = hyper_rustls::HttpsConnectorBuilder::new()//!     .with_native_roots()//!     .expect("no native root CA certificates found")//!     .https_only()//!     .enable_http1()//!     .build();//! let client: Client<_, Empty<Bytes>> = Client::builder(TokioExecutor::new()).build(https);//! let res = rt.block_on(client.get(url)).unwrap();//! assert_eq!(res.status(), StatusCode::OK);//! # #[cfg(not(all(feature = "rustls-native-certs", feature = "http1")))]// Copied from hyperium/hyper-tls#62e3376/src/stream.rsTlsStream/// A stream over plain text./// A stream protected with TLS./// A stream that might be protected with TLS.tls/// Construct a new `HttpsConnector`./// This uses hyper's default `HttpConnector`, and default `TlsConnector`./// If you wish to use something besides the defaults, use `From::from`./// By default this connector will use plain HTTP if the URL provided uses/// the HTTP scheme (eg: <http://example.com/>)./// If you would like to force the use of HTTPS then call `https_only(true)`/// on the returned connector./// This will panic if the underlying TLS context could not be created./// To handle that error yourself, you can use the `HttpsConnector::from`/// constructor after trying to make a `TlsConnector`.new_new_with_connector/// With connector constructorHttpsConnectingBoxedFut/// A Future representing work to connect to a URL, and a TLS handshake.ForceHttpsButUriNotHttps// ===== Custom Errors =====//! # hyper-tls//! An HTTPS connector to be used with [hyper][].//! [hyper]: https://hyper.rs//! use bytes::Bytes;//! use hyper_tls::HttpsConnector;//! use hyper_util::{client::legacy::Client, rt::TokioExecutor};//! #[tokio::main(flavor = "current_thread")]//! async fn main() -> Result<(), Box<dyn std::error::Error>>{//!     let https = HttpsConnector::new();//!     let client = Client::builder(TokioExecutor::new()).build::<_, Empty<Bytes>>(https);//!     let res = client.get("https://hyper.rs".parse()?).await?;//!     assert_eq!(res.status(), 200);//! ## Crate Features//! - `alpn`: Enables `native-tls/alpn`, and if `h2` is negotiated, tells hyper.// ===== impl MaybeHttpsStream =====ConnTrySendErrorCaptureConnectionExtensionAlpnVerhyper_lazySyncWrapperBoxSendFutureh1_builderPoolClientPoolKeyPool/// A Client to make outgoing HTTP requests./// `Client` is cheap to clone and cloning is the recommended way to share a `Client`. The/// underlying connection pool will be reused.retry_canceled_requestsset_hostverconnect_info/// Client errorsUserUnsupportedRequestMethodUserUnsupportedVersionUserAbsoluteUriRequired// We might change this... :shrug:connection_reusedRetryableNope/// A `Future` that will resolve to an HTTP Response./// This is returned by `Client::request` (and `Client::get`)./// Create a builder to configure a new `Client`./// # #[cfg(feature = "tokio")]/// # fn run () {/// use hyper_util::client::legacy::Client;/// use hyper_util::rt::{TokioExecutor, TokioTimer};/// let client = Client::builder(TokioExecutor::new())///     .pool_timer(TokioTimer::new())///     .pool_idle_timeout(Duration::from_secs(30))///     .http2_only(true)///     .build_http();/// # let infer: Client<_, http_body_util::Full<bytes::Bytes>> = client;/// # drop(infer);/// Send a `GET` request to the supplied `Uri`./// This requires that the `Body` type have a `Default` implementation./// It *should* return an "empty" version of itself, such that/// `Body::is_end_stream` is `true`./// use hyper::Uri;/// use hyper_util::rt::TokioExecutor;/// let client: Client<_, Full<Bytes>> = Client::builder(TokioExecutor::new()).build_http();/// let future = client.get(Uri::from_static("http://httpbin.org/ip"));/// Send a constructed `Request` using this `Client`./// use hyper::{Method, Request};/// let req: Request<Full<Bytes>> = Request::builder()///     .method(Method::POST)///     .uri("http://httpbin.org/post")///     .body(Full::from("Hallo!"))///     .expect("request builder");/// let future = client.request(req);connection_forPooledone_connection_forClientConnectErrorconnect_toerror_versionconn_infoPoolTx// FIXME: allow() required due to `impl Trait` leaking types to this lintis_http1is_http2Reservationcan_sharePoolableCheckoutIsClosedorigin_formabsolute_formauthority_formextract_domaindomain_as_uriget_non_default_portis_schema_secureclient_configpool_configpool_timer/// A builder to configure a new [`Client`](Client)./// Construct a new Builder.pool_idle_timeout/// Set an optional timeout for idle sockets being kept-alive./// A `Timer` is required for this to take effect. See `Builder::pool_timer`/// Pass `None` to disable timeout./// Default is 90 seconds.max_idle_per_hostpool_max_idle_per_host/// Sets the maximum idle connection per host allowed in the pool./// Default is `usize::MAX` (no limit).http1_read_buf_exact_size/// Note that setting this option unsets the `http1_max_buf_size` option.http1_max_buf_size/// Note that setting this option unsets the `http1_read_exact_buf_size` option.http1_allow_spaces_after_header_name_in_responses/// Note that this setting does not affect HTTP/2.http1_ignore_invalid_headers_in_responses/// Sets whether invalid header lines should be silently ignored in HTTP/1 responses./// This mimics the behaviour of major browsers. You probably don't want this./// This option will prevent Hyper's client from returning an error encountered/// when parsing a header, except if the error was caused by the character NUL/// (ASCII code 0), as Chrome specifically always reject those./// * missing colon between header name and colon;/// line in the input to resume parsing the rest of the headers. An error/// will be emitted nonetheless if it finds `\0` or a lone `\r` while/// looking for the next line.http1_writevhttp1_title_case_headershttp1_max_headers/// The headers is allocated on the stack by default, which has higher performance. After/// Provide a timer to be used for h2/// See the documentation of [`h2::client::Builder::timer`] for more/// [`h2::client::Builder::timer`]: https://docs.rs/h2/client/struct.Builder.html#method.timer/// Provide a timer to be used for timeouts and intervals in connection pools./// Set whether to retry requests that get disrupted before ever starting/// to write./// This means a request that is queued, and gets given an idle, reused/// connection, and then encounters an error immediately as the idle/// connection was found to be unusable./// When this is set to `false`, the related `ResponseFuture` would instead/// resolve to an `Error::Cancel`./// Set whether to automatically add the `Host` header to requests./// If true, and a request does not include a `Host` header, one will be/// added automatically, derived from the authority of the `Uri`.build_http/// Build a client with this configuration and the default `HttpConnector`./// Combine the configuration of this builder with a connector to create a `Client`.// HTTP/1 options/// Returns true if this was an error from `Connect`./// Returns the info of the client connection on which this error occurred.with_connect_info//! The legacy HTTP Client from 0.14.x//! This `Client` will eventually be deconstructed into more composable parts.//! For now, to enable people to use hyper 1.0 quicker, this `Client` exists//! in much the same way it did in hyper 0.14.// ===== impl ResponseFuture =====// ===== impl PoolClient =====// ==== impl Error ====CaptureConnection/// [`CaptureConnection`] allows callers to capture [`Connected`] information/// To capture a connection for a request, use [`capture_connection`].capture_connection/// Capture the connection for a given request/// When making a request with Hyper, the underlying connection must implement the [`Connection`] trait./// [`capture_connection`] allows a caller to capture the returned [`Connected`] structure as soon/// as the connection is established./// [`Connection`]: crate::client::legacy::connect::Connection/// *Note*: If establishing a connection fails, [`CaptureConnection::connection_metadata`] will always return none./// **Synchronous access**:/// The [`CaptureConnection::connection_metadata`] method allows callers to check if a connection has been/// established. This is ideal for situations where you are certain the connection has already/// been established (e.g. after the response future has already completed)./// use hyper_util::client::legacy::connect::capture_connection;/// let mut request = http::Request::builder()///   .uri("http://foo.com")///   .body(())///   .unwrap();/// let captured_connection = capture_connection(&mut request);/// // some time later after the request has been sent.../// let connection_info = captured_connection.connection_metadata();/// println!("we are connected! {:?}", connection_info.as_ref());/// **Asynchronous access**:/// The [`CaptureConnection::wait_for_connection_metadata`] method returns a future resolves as soon as the/// connection is available./// # #[cfg(feature  = "tokio")]/// # async fn example() {/// use http_body_util::Empty;///   .body(Empty::<Bytes>::new())/// let mut captured = capture_connection(&mut request);/// tokio::task::spawn(async move {///     let connection_info = captured.wait_for_connection_metadata().await;///     println!("we are connected! {:?}", connection_info.as_ref());/// let client = Client::builder(TokioExecutor::new()).build_http();/// client.request(request).await.expect("request failed");/// TxSide for [`CaptureConnection`]/// This is inserted into `Extensions` to allow Hyper to back channel connection info/// Internal API to create the tx and rx half of [`CaptureConnection`]connection_metadata/// Retrieve the connection metadata, if availablewait_for_connection_metadata/// Wait for the connection to be established/// If a connection was established, this will always return `Some(...)`. If the request never/// successfully connected (e.g. DNS resolution failure), this method will never return.test_sync_capture_connectionasync_capture_connectioncapture_connection_sender_side_droppedResolve/// A domain name to resolve into IP addresses.GaiResolver/// A resolver using blocking `getaddrinfo` calls in a threadpool.SocketAddrsGaiAddrs/// An iterator of IP addresses returned from `getaddrinfo`.GaiFuture/// A future to resolve a name returned by `GaiResolver`./// View the hostname as a string slice.InvalidNameError/// Error indicating a given string was not a valid domain name./// Construct a new `GaiResolver`.split_by_preferenceAddrs// "Trait alias" for `Service<Name, Response = Addrs>`test_ip_addrs_split_by_preferencetest_name_from_str//! DNS Resolution used by the `HttpConnector`.//! - A [`GaiResolver`] that is the default resolver for the `HttpConnector`.//! - The `Name` type used as an argument to custom resolvers.//! # Resolvers are `Service`s//! A resolver is just a//! `Service<Name, Response = impl Iterator<Item = SocketAddr>>`.//! A simple resolver that ignores the name and always returns a specific//! address://! use std::{convert::Infallible, iter, net::SocketAddr};//! let resolver = tower::service_fn(|_name| async {//!     Ok::<_, Infallible>(iter::once(SocketAddr::from(([127, 0, 0, 1], 8080))))TcpKeepaliveTcpSocketdns/// A connector for the `http` scheme./// Performs DNS resolution in a thread pool, and then connects over TCP./// Sets the [`HttpInfo`](HttpInfo) value on responses, which includes/// transport information such as the remote socket address used.HttpInfo/// Extra information about the transport when an HttpConnector is used./// # fn doc(res: http::Response<()>) {/// use hyper_util::client::legacy::connect::HttpInfo;/// // res = http::Response/// res///     .extensions()///     .get::<HttpInfo>()///     .map(|info| {///         println!("remote addr = {}", info.remote_addr());/// If a different connector is used besides [`HttpConnector`](HttpConnector),/// this value will not exist in the extensions. Consult that specific/// connector to see what "extra" information it might provide to responses.connect_timeoutenforce_httphappy_eyeballs_timeouttcp_keepalive_configTcpKeepaliveConfiglocal_address_ipv4local_address_ipv6reuse_addresssend_buffer_sizerecv_buffer_sizetcp_user_timeoutretriesinto_tcpkeepalive/// Converts into a `socket2::TcpKeealive` if there is any keep alive configuration.// See https://docs.rs/socket2/0.5.8/src/socket2/lib.rs.html#511-525ka_with_interval// See https://docs.rs/socket2/0.5.8/src/socket2/lib.rs.html#557-570ka_with_retries/// Construct a new HttpConnector.new_with_resolver/// Takes a [`Resolver`](crate::client::legacy::connect::dns#resolvers-are-services) to handle DNS lookups./// Option to enforce all `Uri`s have the `http` scheme./// Set that all sockets have `SO_KEEPALIVE` set with the supplied duration/// to remain idle before sending TCP keepalive probes./// If `None`, keepalive is disabled./// Default is `None`.set_keepalive_interval/// Set the duration between two successive TCP keepalive retransmissions,/// if acknowledgement to the previous keepalive transmission is not received.set_keepalive_retries/// Set the number of retransmissions to be carried out before declaring that remote end is not available.set_nodelay/// Set that all sockets have `SO_NODELAY` set to the supplied value `nodelay`.set_send_buffer_size/// Sets the value of the SO_SNDBUF option on the socket.set_recv_buffer_size/// Sets the value of the SO_RCVBUF option on the socket./// Set that all sockets are bound to the configured address before connection./// If `None`, the sockets will not be bound.set_local_addresses/// Set that all sockets are bound to the configured IPv4 or IPv6 address (depending on host's/// preferences) before connection.set_connect_timeout/// Set the connect timeout./// If a domain resolves to multiple IP addresses, the timeout will be/// evenly divided across them.set_happy_eyeballs_timeout/// Set timeout for [RFC 6555 (Happy Eyeballs)][RFC 6555] algorithm./// If hostname resolves to both IPv4 and IPv6 addresses and connection/// cannot be established using preferred address family before timeout/// elapses, then connector will in parallel attempt connection using other/// address family./// If `None`, parallel connection attempts are disabled./// Default is 300 milliseconds./// [RFC 6555]: https://tools.ietf.org/html/rfc6555set_reuse_address/// Set that all socket have `SO_REUSEADDR` set to the supplied value `reuse_address`./// Sets the name of the interface to bind sockets produced by this/// connector./// On Linux, this sets the `SO_BINDTODEVICE` option on this socket (see/// [`man 7 socket`] for details). On macOS (and macOS-derived systems like/// iOS), illumos, and Solaris, this will instead use the `IP_BOUND_IF`/// socket option (see [`man 7p ip`])./// If a socket is bound to an interface, only packets received from that particular/// interface are processed by the socket. Note that this only works for some socket/// types, particularly `AF_INET`` sockets./// On Linux it can be used to specify a [VRF], but the binary needs/// to either have `CAP_NET_RAW` or to be run as root./// This function is only available on the following operating systems:/// - Linux, including Android/// - Fuchsia/// - illumos and Solaris/// - macOS, iOS, visionOS, watchOS, and tvOS/// [VRF]: https://www.kernel.org/doc/Documentation/networking/vrf.txt/// [`man 7 socket`] https://man7.org/linux/man-pages/man7/socket.7.html/// [`man 7p ip`]: https://docs.oracle.com/cd/E86824_01/html/E54777/ip-7p.htmlset_tcp_user_timeout/// Sets the value of the TCP_USER_TIMEOUT option on the socket.config_mutINVALID_NOT_HTTPINVALID_MISSING_SCHEMEINVALID_MISSING_HOST// R: Debug required for now to allow adding it to debug output later...HttpConnecting'uget_host_port// Implement `Connection` for generic `TokioIo<T>` so that external crates can// implement their own `HttpConnector` with `TokioIo<CustomTcpStream>`./// Get the remote address of the transport used./// Get the local address of the transport used.BoxConnectingConnectResult// Not publicly exported (so missing_docs doesn't trigger).preferredConnectingTcpRemoteConnectingTcpFallbackConnectingTcpaddrsbind_local_address/// Respect explicit ports in the URI, if none, either/// keep non `0` ports resolved from a custom dns resolver,/// or use the default port for the scheme.ConnectSvc_Svctest_errors_enforce_httpget_local_ipsdefault_interfacetest_errors_missing_scheme"setting `SO_BINDTODEVICE` requires the `CAP_NET_RAW` capability (works when running as root)"client_happy_eyeballs// TODOno_tcp_keepalive_configtcp_keepalive_time_configtcp_keepalive_interval_configtcp_keepalive_retries_configtest_set_port// ===== impl HttpConnector =====/// Return metadata describing the connection./// Describes a type returned by a connector.alpnis_proxiedpoisonedPoisonPill/// Extra information about the connected transport./// This can be used to inform recipients about things like if ALPN/// was used, or if connected to an HTTP proxy.healthypoisonExtraInner/// Create new `Connected` type with empty metadata./// Set whether the connected transport is to an HTTP proxy./// This setting will affect if HTTP/1 requests written on the transport/// will have the request-target in absolute-form or origin-form:/// - When `proxy(false)`:/// ```http/// GET /guide HTTP/1.1/// - When `proxy(true)`:/// GET http://hyper.rs/guide HTTP/1.1/// Determines if the connected transport is to an HTTP proxy./// Set extra connection information to be set in the extensions of every `Response`.get_extras/// Copies the extra connection information into an `Extensions` map.negotiated_h2/// Set that the connected transport negotiated HTTP/2 as its next protocol.is_negotiated_h2/// Determines if the connected transport negotiated HTTP/2 as its next protocol./// Poison this connection/// A poisoned connection will not be reused for subsequent requests by the pool// Don't public expose that `Connected` is `Clone`, unsure if we want to// keep that contract...ExtraEnvelope// This indirection allows the `Connected` to have a type-erased "extra" value,// while that type still knows its inner extra type. This allows the correct// TypeId to be used when inserting into `res.extensions_mut()`.ExtraChain/// Connect to a destination, returning an IO transport./// A connector receives a [`Uri`](::http::Uri) and returns a `Future` of the/// ready connection./// # Trait Alias/// This is really just an *alias* for the `tower::Service` trait, with/// additional bounds set for convenience *inside* hyper. You don't actually/// implement this trait, but `tower::Service<Uri>` instead.// The `Sized` bound is to prevent creating `dyn Connect`, since they cannot// fit the `Connect` bounds because of the blanket impl for `Service`.OneshotEx1Ex2Ex3test_connected_extratest_connected_extra_chain//! Connectors used by the `Client`.//! - A default [`HttpConnector`][] that does DNS resolution and establishes//!   connections over TCP.//! - Types to build custom connectors.//! # Connectors//! A "connector" is a [`Service`][] that takes a [`Uri`][] destination, and//! its `Response` is some type implementing [`Read`][], [`Write`][],//! and [`Connection`][].//! ## Custom Connectors//! A simple connector that ignores the `Uri` destination and always returns//! a TCP connection to the same address could be written like this://! let connector = tower::service_fn(|_dst| async {//!     tokio::net::TcpStream::connect("127.0.0.1:1337")//! Or, fully written out://! use std::{future::Future, net::SocketAddr, pin::Pin, task::{self, Poll}};//! use tokio::net::TcpStream;//! use tower_service::Service;//! #[derive(Clone)]//! struct LocalConnector;//! impl Service<Uri> for LocalConnector {//!     type Response = TcpStream;//!     type Error = std::io::Error;//!     // We can't "name" an `async` generated future.//!     type Future = Pin<Box<//!         dyn Future<Output = Result<Self::Response, Self::Error>> + Send//!     >>;//!     fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {//!         // This connector is always ready, but others might not be.//!         Poll::Ready(Ok(()))//!     fn call(&mut self, _: Uri) -> Self::Future {//!         Box::pin(TcpStream::connect(SocketAddr::from(([127, 0, 0, 1], 1337))))//! It's worth noting that for `TcpStream`s, the [`HttpConnector`][] is a//! better starting place to extend from.//! [`HttpConnector`]: HttpConnector//! [`Service`]: tower_service::Service//! [`Uri`]: ::http::Uri//! [`Read`]: hyper::rt::Read//! [`Write`]: hyper::rt::Write//! [`Connection`]: Connection// ===== impl Extra =====sockstunnelSocksV4SocksV5//! Proxy helpersv5SocksV5ErrorSocksV4ErrorSocksErrorDnsFailureMissingHostMissingPortParsingErrorParsingWouldOverflowBoxHandshakingIpV6/// +-----+-----+----+----+----+----+----+----+-------------+------+------------+------+/// |  VN |  CD | DSTPORT |        DSTIP      |    USERID   | NULL |   DOMAIN   | NULL |/// |  1  |  1  |    2    |         4         |   Variable  |  1   |  Variable  |   1  |///                                                                ^^^^^^^^^^^^^^^^^^^^^///                                                      optional: only do IP is 0.0.0.X/// +-----+-----+----+----+----+----+----+----+/// |  VN |  CD | DSTPORT |       DSTIP       |/// |  1  |  1  |    2    |         4         |///             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^///              ignore: only for SOCKSv4 BINDIdentFailureIdentMismatchSocksConfig/// Tunnel Proxy via SOCKSv4/// This is a connector that can be used by the `legacy::Client`. It wraps/// another connector, and after getting an underlying connection, it established/// a TCP tunnel over it using SOCKSv4.local_dns/// Create a new SOCKSv4 handshake service/// Wraps an underlying connector and stores the address of a tunneling/// proxying server./// A `SocksV4` can then be called with any destination. The `dst` passed to/// `call` will not be used to create the underlying connection, but will/// be used in a SOCKS handshake with the proxy destination./// Resolve domain names locally on the client, rather than on the proxy server./// Disabled by default as local resolution of domain names can be detected as a/// DNS leak.HostTooLongAuthErrorMethodMismatchAuthMethodNegotiationReq///  +----+----------+----------+/// |VER | NMETHODS | METHODS  |/// +----+----------+----------+/// | 1  |    1     | 1 to 255 |NegotiationRes/// +----+--------+/// |VER | METHOD |/// | 1  |   1    |AuthenticationReq/// +----+------+----------+------+----------+/// |VER | ULEN |  UNAME   | PLEN |  PASSWD  |/// | 1  |  1   | 1 to 255 |  1   | 1 to 255 |AuthenticationRes/// |VER | STATUS |ProxyReq/// +----+-----+-------+------+----------+----------+/// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |/// | 1  |  1  | X'00' |  1   | Variable |    2     |ProxyRes/// |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |NoAuthUserPassNoneAcceptableGeneralServerFailureConnectionNotAllowed/// Tunnel Proxy via SOCKSv5/// a TCP tunnel over it using SOCKSv5.proxy_authSendingNegReqReadingNegResSendingAuthReqReadingAuthResSendingProxyReqReadingProxyRes/// Create a new SOCKSv5 handshake service./// A `SocksV5` can then be called with any destination. The `dst` passed towith_auth/// Use User/Pass authentication method during handshake./// Username and Password must be maximum of 255 characters each./// 0 length strings are allowed despite RFC prohibiting it. This is done so that/// for compatablity with server implementations that require it for IP authentication.send_optimistically/// Send all messages of the handshake optmistically (without waiting for server response)./// Typical SOCKS handshake with auithentication takes 3 round trips. Optimistic sending/// can reduce round trip times and dramatically increase speed of handshake at the cost of/// reduced portability; many server implementations do not support optimistic sending as it/// is not defined in the RFC (RFC 1928)./// Recommended to ensure connector works correctly without optimistic sending before trying/// with optimistic sending.proxy_dst/// Tunnel Proxy via HTTP CONNECT/// another connector, and after getting an underlying connection, it creates/// an HTTP CONNECT tunnel over it.TunnelErrorConnectFailedProxyAuthRequiredProxyHeadersTooLongTunnelUnexpectedEofTunnelUnsuccessfulBoxTunnelingTunneling/// Create a new Tunnel service./// This wraps an underlying connector, and stores the address of a/// tunneling proxy server./// A `Tunnel` can then be called with any destination. The `dst` passed to/// be used in an HTTP CONNECT request sent to the proxy destination./// Add `proxy-authorization` header value to the CONNECT request.with_headers/// Add extra headers to be sent with the CONNECT request./// If existing headers have been set, these will be merged.// Publicly available, but just for legacy purposes. A better pool will be// designed.PoolInner// If the pool is disabled, this is None./// Reserve this connection./// Allows for HTTP/2 to return a shared reservation.// Before using a pooled connection, make sure the sender is not dead.// This is a trait to allow the `client::pool::tests` to work for `i32`.// See https://github.com/hyperium/hyper/issues/1429/// A marker to identify what version a pooled connection is.Unique/// This connection requires unique access. It will be returned after/// use is complete./// When checking out a pooled connection, it might be that the connection/// only supports a single reservation, or it might be usable for many./// Specifically, HTTP/1 requires a unique reservation, but HTTP/2 can be/// used for multiple requests.connecting// A flag that a connection is being established, and the connection// should be shared. This prevents making multiple HTTP/2 connections// to the same host.// These are internal Conns sitting in the event loop in the KeepAlive// state, waiting to receive a new Request to send on the socket.// These are outstanding Checkouts that are waiting for a socket to be// able to send a Request one. This is used when "racing" for a new// connection.// The Client starts 2 tasks, 1 to connect a new socket, and 1 to wait// for the Pool to receive an idle Conn. When a Conn becomes idle,// this list is checked for any parked Checkouts, and tries to notify// them that the Conn could be used instead of waiting for a brand newidle_interval_ref// A oneshot channel is used to allow the interval to be notified when// the Pool completely drops. That way, the interval can cancel immediately.WeakOpt// This is because `Weak::new()` *allocates* space for `T`, even if it// doesn't need it!idle_timeoutno_timer/// Returns a `Checkout` which is a future that resolves if an idle/// connection becomes available./// Ensure that there is only ever 1 connecting task for HTTP/2/// connections. This does nothing for HTTP/1.pooled/* Used in client/tests.rs...
    #[cfg(test)]
    pub(super) fn h1_key(&self, s: &str) -> Key {
        Arc::new(s.to_string())
    }

    #[cfg(test)]
    pub(super) fn idle_count(&self, key: &Key) -> usize {
        self
            .locked()
            .idle
            .get(key)
            .map(|list| list.len())
            .unwrap_or(0)
    }
    */IdlePopper/// Pop off this list, looking for a usable connection that hasn't expired.Expiration/// A `Connecting` task is complete. Not necessarily successfully,/// but the lock is going away, so clean up.spawn_idle_intervalclean_waiters/// Any `FutureResponse`s that were created will have made a `Checkout`,/// and possibly inserted into the pool that it is waiting for an idle/// connection. If a user ever dropped that future, we need to clean out/// those parked senders.clear_expired/// This should *only* be called by the IdleTaskis_reused/// A wrapped poolable value that tries to reinsert to the Pool on Drop.// Note: The bounds `T: Poolable` is needed for the Drop impl.is_pool_enabledidle_atwaiterPoolDisabledCheckoutNoLongerWantedCheckedOutClosedValuepoll_waiteralpn_h2expirespool_drop_notifier// This allows the IdleTask to be notified as soon as the entire// Pool is fully dropped, and shutdown. This channel is never sent on,// but Err(Canceled) will be received when the Pool is dropped.IdleTaskTokioExecutorTokioTimerKeyImplKeyTupleUniq/// Test unique reservations.host_keypool_no_timerpool_max_idle_no_timertest_pool_checkout_smoketest_pool_checkout_returns_none_if_expiredtest_pool_checkout_removes_expiredtest_pool_max_idle_per_hosttest_pool_timer_removes_expiredtest_pool_checkout_task_unparkedtest_pool_checkout_drop_cleans_up_waitersCanClosepooled_drop_if_closed_doesnt_reinsert/// Simple type alias in case the key type needs to be adjusted.// pub type Key = (http::uri::Scheme, http::uri::Authority); //Arc<String>;/// Legacy implementations of `connect` module and `Client`//! HTTP client utilitiesIpNetpercent_decode_strIntoValueInterceptnoNoProxy/// A proxy matcher, usually built from environment variables./// A matched proxy,/// This is returned by a matcher if a proxy should be used.is_cgi/// A builder to create a [`Matcher`]./// Construct with [`Matcher::builder()`].ipsIpMatcherdomainsDomainMatcher/// A filter for proxy matchers./// This type is based off the `NO_PROXY` rules used by curl./// Create a matcher reading the current environment variables./// This checks for values in the following variables, treating them the/// same as curl does:/// - `ALL_PROXY`/`all_proxy`/// - `HTTPS_PROXY`/`https_proxy`/// - `HTTP_PROXY`/`http_proxy`/// - `NO_PROXY`/`no_proxy`from_system/// Create a matcher from the environment or system./// This checks the same environment variables as `from_env()`, and if not/// set, checks the system configuration for values for the OS./// This constructor is always available, but if the `client-proxy-system`/// feature is enabled, it will check more configuration. Use this/// constructor if you want to allow users to optionally enable more, or/// use `from_env` if you do not want the values to change based on an/// enabled feature./// Start a builder to configure a matcher.intercept/// Check if the destination should be intercepted by a proxy./// If the proxy rules match the destination, a new `Uri` will be returned/// to connect to./// Get the `http::Uri` for the target proxy.basic_auth/// Get any configured basic authorization./// This should usually be used with a `Proxy-Authorization` header, to/// send in Basic format./// # use hyper_util::client::proxy::matcher::Matcher;/// # let uri = http::Uri::from_static("https://hyper.rs");/// let m = Matcher::builder()///     .all("https://Aladdin:opensesame@localhost:8887")/// let proxy = m.intercept(&uri).expect("example");/// let auth = proxy.basic_auth().expect("example");/// assert_eq!(auth, "Basic QWxhZGRpbjpvcGVuc2VzYW1l");raw_auth/// Get any configured raw authorization./// If not detected as another scheme, this is the username and password/// that should be sent with whatever protocol the proxy handshake uses.///     .all("socks5h://Aladdin:opensesame@localhost:8887")/// let auth = proxy.raw_auth().expect("example");/// assert_eq!(auth, ("Aladdin", "opensesame"));/// Set the target proxy for all destinations./// Set the target proxy for HTTP destinations./// Set the target proxy for HTTPS destinations./// Set the "no" proxy filter./// The rules are as follows:/// * Entries are expected to be comma-separated (whitespace between entries is ignored)/// * IP addresses (both IPv4 and IPv6) are allowed, as are optional subnet masks (by adding /size,///   for example "`192.168.1.0/24`")./// * An entry "`*`" matches all hostnames (this is the only wildcard allowed)/// * Any other entry is considered a domain name (and may contain a leading dot, for example `google.com`///   and `.google.com` are equivalent) and would match both that domain AND all subdomains./// For example, if `"NO_PROXY=google.com, 192.168.1.0/24"` was set, all of the following would match/// (and therefore would bypass the proxy):/// * `http://google.com/`/// * `http://www.google.com/`/// * `http://192.168.1.42/`/// The URL `http://notgoogle.com/` would not match./// Construct a [`Matcher`] using the configured values.get_first_envparse_env_uriencode_basic_auth/// Returns a new no-proxy configuration based on a `no_proxy` string (or `None` if no variables/// are set)/// * The environment variable `NO_PROXY` is checked, if it is not set, `no_proxy` is checked/// * If neither environment variable is set, `None` is returned/// Return true if this matches the host (domain or IP)./*
    fn from_env() -> NoProxy {
        let raw = std::env::var("NO_PROXY")
            .or_else(|_| std::env::var("no_proxy"))
            .unwrap_or_default();

        Self::from_string(&raw)
    }
    */// The following links may be useful to understand the origin of these rules:// * https://curl.se/libcurl/c/CURLOPT_NOPROXY.html// * https://github.com/curl/curl/issues/1208/// A type that can used as a `Builder` value./// Private and sealed, only visible in docs.test_domain_matchertest_no_proxy_wildcardtest_no_proxy_ip_rangestest_all_proxytest_specific_overrides_alltest_parse_no_scheme_defaults_to_httptest_parse_http_authtest_parse_http_auth_without_schemetest_dont_parse_http_when_is_cgi//! Proxy matchers//! This module contains different matchers to configure rules for when a proxy//! should be used, and if so, with what arguments.//! A [`Matcher`] can be constructed either using environment variables, or//! a [`Matcher::builder()`].//! Once constructed, the `Matcher` can be asked if it intercepts a `Uri` by//! calling [`Matcher::intercept()`].//! An [`Intercept`] includes the destination for the proxy, and any parsed//! authentication to be used.// ===== impl Matcher =====// ===== impl Intercept =====//! Proxy utilities// Either the user provides an executor for background tasks, or we use// `tokio::spawn`.// ===== impl Exec =====InnerProjInnerProjReplace/*
#[cfg(test)]
mod tests {
    use super::Rewind;
    use bytes::Bytes;
    use tokio::io::AsyncReadExt;

    #[cfg(not(miri))]
    #[tokio::test]
    async fn partial_rewind() {
        let underlying = [104, 101, 108, 108, 111];

        let mock = tokio_test::io::Builder::new().read(&underlying).build();

        let mut stream = Rewind::new(mock);

        // Read off some bytes, ensure we filled o1
        let mut buf = [0; 2];
        stream.read_exact(&mut buf).await.expect("read1");

        // Rewind the stream so that it is as if we never read in the first place.
        stream.rewind(Bytes::copy_from_slice(&buf[..]));

        let mut buf = [0; 5];
        stream.read_exact(&mut buf).await.expect("read1");

        // At this point we should have read everything that was in the MockStream
        assert_eq!(&buf, &underlying);
    }

    #[cfg(not(miri))]
    #[tokio::test]
    async fn full_rewind() {
        let underlying = [104, 101, 108, 108, 111];

        let mock = tokio_test::io::Builder::new().read(&underlying).build();

        let mut stream = Rewind::new(mock);

        let mut buf = [0; 5];
        stream.read_exact(&mut buf).await.expect("read1");

        // Rewind the stream so that it is as if we never read in the first place.
        stream.rewind(Bytes::copy_from_slice(&buf[..]));

        let mut buf = [0; 5];
        stream.read_exact(&mut buf).await.expect("read1");
    }
}
*//// Creates a new SyncWrapper containing the given value./// use hyper::common::sync_wrapper::SyncWrapper;/// let wrapped = SyncWrapper::new(42);/// Acquires a reference to the protected value./// This is safe because it requires an exclusive reference to the wrapper. Therefore this method/// neither panics nor does it return an error. This is in contrast to [`Mutex::get_mut`] which/// returns an error if another thread panicked while holding the lock. It is not recommended/// to send an exclusive reference to a potentially damaged value to another thread for further/// [`Mutex::get_mut`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html#method.get_mut/// let mut wrapped = SyncWrapper::new(42);/// let value = wrapped.get_mut();/// *value = 0;/// assert_eq!(*wrapped.get_mut(), 0);/// Consumes this wrapper, returning the underlying data./// This is safe because it requires ownership of the wrapper, aherefore this method will neither/// panic nor does it return an error. This is in contrast to [`Mutex::into_inner`] which/// [`Mutex::into_inner`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html#method.into_inner/// assert_eq!(wrapped.into_inner(), 42);// this is safe because the only operations permitted on this data structure require exclusive// access or ownership// =====impl Timer=====/*
use std::error::Error;

pub(crate) fn find<'a, E: Error + 'static>(top: &'a (dyn Error + 'static)) -> Option<&'a E> {
    let mut err = Some(top);
    while let Some(src) = err {
        if src.is::<E>() {
            return src.downcast_ref();
        }
        err = src.source();
    }
    None
}
*///! Utilities for working with hyper.//! This crate is less-stable than [`hyper`](https://docs.rs/hyper). However,//! does respect Rust's semantic version regarding breaking changes.//! Runtime utilitiesr" Extends an underlying [`tokio`] I/O with [`hyper`] I/O implementations."r" This implements [`Read`] and [`Write`] given an inner type that implements [`AsyncRead`]"r" and [`AsyncWrite`], respectively."WithHyperIo/// Wraps the inner I/O in an [`WithHyperIo<I>`]/// Returns a reference to the inner type./// Returns a mutable reference to the inner type./// Consumes this wrapper and returns the inner type./// [`WithHyperIo<I>`] is [`Read`] if `I` is [`AsyncRead`]./// [`AsyncRead`]: tokio::io::AsyncRead/// [`Read`]: hyper::rt::Read/// [`WithHyperIo<I>`] is [`Write`] if `I` is [`AsyncWrite`]./// [`AsyncWrite`]: tokio::io::AsyncWrite/// [`Write`]: hyper::rt::Write/// [`WithHyperIo<I>`] exposes its inner `I`'s [`AsyncRead`] implementation./// [`WithHyperIo<I>`] exposes its inner `I`'s [`AsyncWrite`] implementation.// ==== impl WithHyperIo =====r" Extends an underlying [`hyper`] I/O with [`tokio`] I/O implementations."r" This implements [`AsyncRead`] and [`AsyncWrite`] given an inner type that implements"r" [`Read`] and [`Write`], respectively."WithTokioIo/// [`WithTokioIo<I>`] is [`AsyncRead`] if `I` is [`Read`]./// [`WithTokioIo<I>`] is [`AsyncWrite`] if `I` is [`Write`]./// [`WithTokioIo<I>`] exposes its inner `I`'s [`Write`] implementation./// Wraps the inner I/O in an [`WithTokioIo<I>`]/// [`WithTokioIo<I>`] exposes its inner `I`'s [`Read`] implementation.// ==== impl WithTokioIo =====with_hyper_iowith_tokio_io/// Future executor that utilises `tokio` threads.r" A wrapper that implements Tokio's IO traits for an inner type that"r" implements hyper's IO traits, or vice versa (implements hyper's IO"r" traits for a type that implements Tokio's IO traits)."/// A Timer that uses the tokio runtime.TokioSleep// Use TokioSleep to get tokio::time::Sleep to implement Unpin.// see https://docs.rs/tokio/latest/tokio/time/struct.Sleep.html/// Create new executor that relies on [`tokio::spawn`] to execute futures./// Wrap a type implementing Tokio's or hyper's IO traits./// Borrow the inner type./// Mut borrow the inner type./// Consume this wrapper and get the inner type./// Create a new TokioTimersimple_execute//! [`tokio`] runtime components integration for [`hyper`].//! [`hyper::rt`] exposes a set of traits to allow hyper to be agnostic to//! its underlying asynchronous runtime. This submodule provides glue for//! [`tokio`] users to bridge those types to [`hyper`]'s interfaces.//! # IO//! [`hyper`] abstracts over asynchronous readers and writers using [`Read`]//! and [`Write`], while [`tokio`] abstracts over this using [`AsyncRead`]//! and [`AsyncWrite`]. This submodule provides a collection of IO adaptors//! to bridge these two IO ecosystems together: [`TokioIo<I>`],//! [`WithHyperIo<I>`], and [`WithTokioIo<I>`].//! To compare and constrast these IO adaptors and to help explain which//! is the proper choice for your needs, here is a table showing which IO//! traits these implement, given two types `T` and `H` which implement//! Tokio's and Hyper's corresponding IO traits://! |                    | [`AsyncRead`]    | [`AsyncWrite`]    | [`Read`]     | [`Write`]    |//! |--------------------|------------------|-------------------|--------------|--------------|//! | `T`                | ✅ **true**      | ✅ **true**       | ❌ **false** | ❌ **false** |//! | `H`                | ❌ **false**     | ❌ **false**      | ✅ **true**  | ✅ **true**  |//! | [`TokioIo<T>`]     | ❌ **false**     | ❌ **false**      | ✅ **true**  | ✅ **true**  |//! | [`TokioIo<H>`]     | ✅ **true**      | ✅ **true**       | ❌ **false** | ❌ **false** |//! | [`WithHyperIo<T>`] | ✅ **true**      | ✅ **true**       | ✅ **true**  | ✅ **true**  |//! | [`WithHyperIo<H>`] | ❌ **false**     | ❌ **false**      | ❌ **false** | ❌ **false** |//! | [`WithTokioIo<T>`] | ❌ **false**     | ❌ **false**      | ❌ **false** | ❌ **false** |//! | [`WithTokioIo<H>`] | ✅ **true**      | ✅ **true**       | ✅ **true**  | ✅ **true**  |//! For most situations, [`TokioIo<I>`] is the proper choice. This should be//! constructed, wrapping some underlying [`hyper`] or [`tokio`] IO, at the//! call-site of a function like [`hyper::client::conn::http1::handshake`].//! [`TokioIo<I>`] switches across these ecosystems, but notably does not//! preserve the existing IO trait implementations of its underlying IO. If//! one wishes to _extend_ IO with additional implementations,//! [`WithHyperIo<I>`] and [`WithTokioIo<I>`] are the correct choice.//! For example, a Tokio reader/writer can be wrapped in [`WithHyperIo<I>`].//! That will implement _both_ sets of IO traits. Conversely,//! [`WithTokioIo<I>`] will implement both sets of IO traits given a//! reader/writer that implements Hyper's [`Read`] and [`Write`].//! See [`tokio::io`] and ["_Asynchronous IO_"][tokio-async-docs] for more//! [`AsyncRead`]: tokio::io::AsyncRead//! [`AsyncWrite`]: tokio::io::AsyncWrite//! [tokio-async-docs]: https://docs.rs/tokio/latest/tokio/#asynchronous-io// ===== impl TokioExecutor =====// ==== impl TokioIo =====// ==== impl TokioTimer =====HttpServerConnExec/// Exactly equivalent to [`Http2ServerConnExec`]._executor/// Http1 or Http2 connection builder./// Create a new auto connection builder./// `executor` parameter should be a type that implements/// [`Executor`](hyper::rt::Executor) trait./// use hyper_util::{///     rt::TokioExecutor,///     server::conn::auto,/// auto::Builder::new(TokioExecutor::new());Http1Builder/// Http1 configuration.Http2Builder/// Http2 configuration.http2_only/// Only accepts HTTP/2/// Does not do anything if used with [`serve_connection_with_upgrades`]/// [`serve_connection_with_upgrades`]: Builder::serve_connection_with_upgradeshttp1_only/// Only accepts HTTP/1is_http1_available/// Returns `true` if this builder can serve an HTTP/1.1-based connection.is_http2_available/// Returns `true` if this builder can serve an HTTP/2-based connection./// This setting only affects HTTP/1 connections. HTTP/2 connections are/// not affected by this setting./// auto::Builder::new(TokioExecutor::new())///     .title_case_headers(true);/// Set whether HTTP/1 connections will preserve the original case of header names.///     .preserve_header_case(true);/// Bind a connection together with a [`Service`].serve_connection_with_upgrades/// Bind a connection together with a [`Service`], with the ability to/// handle HTTP upgrades. This requires that the IO object implements/// `Send`./// Note that if you ever want to use [`hyper::upgrade::Upgraded::downcast`]/// with this crate, you'll need to use [`hyper_util::server::conn::auto::upgrade::downcast`]/// instead. See the documentation of the latter to understand why./// [`hyper_util::server::conn::auto::upgrade::downcast`]: crate::server::conn::auto::upgrade::downcastH1read_versionReadVersion// A custom COW, since the libstd is has ToOwned bounds that are too eager.Http1ConnectionHttp2Connection/// This `Connection` should continue to be polled until shutdown can finish./// This should only be called while the `Connection` future is still pending. If called after/// `Connection::poll` has resolved, this does nothing./// Make this Connection static, instead of borrowing from Builder.Http1UpgradeableConnection/// This `UpgradeableConnection` should continue to be polled until shutdown can finish./// This should only be called while the `Connection` future is still nothing. pending. If/// called after `UpgradeableConnection::poll` has resolved, this does nothing./// Http1 part of builder./// Requires a [`Timer`] set by [`Http1Builder::timer`] to take effect. Panics if `header_read_timeout` is configured/// Default is currently 30 seconds, but do not depend on that./// Http2 part of builder./// [spec]: https://http2.github.io/http2-spec/#SETTINGS_INITIAL_WINDOW_SIZE/// `http2_initial_stream_window_size` and/// `http2_initial_connection_window_size`./// Default is 200. Passing `None` will remove any limit./// [spec]: https://http2.github.io/http2-spec/#SETTINGS_MAX_CONCURRENT_STREAMS/// # Cargo Feature/// be closed. Does nothing if `http2_keep_alive_interval` is disabled./// Default is currently ~16MB, but may change.BODYtitle_case_headers_configurationpreserve_header_case_configurationhttp2_only_fail_if_client_is_http1http1_only_fail_if_client_is_http2connect_h1connect_h2start_server//! Http1 or Http2 connection./// On success, returns the downcasted parts. On error, returns the Upgraded back./// This is a kludge to work around the fact that the machinery provided by/// [`hyper_util::server::conn::auto`] wraps the inner `T` with a private type/// that is not reachable from outside the crate./// [`hyper_util::server::conn::auto`]: crate::server::conn::auto/// This kludge will be removed when this machinery is added back to the main/// `hyper` code.//! Upgrade utilities.//! Connection utilities.GracefulShutdown/// A graceful shutdown utility// Purposefully not `Clone`, see `watcher()` method for why.Watcher/// A watcher side of the graceful shutdown./// This type can only watch a connection, it cannot trigger a shutdown./// Call [`GracefulShutdown::watcher()`] to construct one of these./// Create a new graceful shutdown helper.GracefulConnection/// Wrap a future for graceful shutdown watching.watcher/// Create an owned type that can watch a connection./// This method allows created an owned type that can be sent onto another/// task before calling [`Watcher::watch()`].// Internal: this function exists because `Clone` allows footguns.// If the `tx` were cloned (or the `rx`), race conditions can happens where// one task starting a shutdown is scheduled and interwined with a task// starting to watch a connection, and the "watch version" is one behind./// Signal shutdown for all watched connections./// This returns a `Future` which will complete once all watched/// connections have shutdown./// Returns the number of the watching connections.GracefulConnectionFuture/// The error type returned by the connection when used as a future./// An internal utility trait as an umbrella target for all (hyper) connection/// types that the [`GracefulShutdown`] can watch.DummyConnectiontest_graceful_shutdown_oktest_graceful_shutdown_delayed_oktest_graceful_shutdown_multi_per_watcher_oktest_graceful_shutdown_timeout//! Utility to gracefully shutdown a server.//! This module provides a [`GracefulShutdown`] type,//! which can be used to gracefully shutdown a server.//! See <https://github.com/hyperium/hyper-util/blob/master/examples/server_graceful.rs>//! for an example of how to use this.graceful//! Server utilities.TowerToHyperService/// A tower [`Service`][tower-svc] converted into a hyper [`Service`][hyper-svc]./// This wraps an inner tower service `S` in a [`hyper::service::Service`] implementation. See/// the module-level documentation of [`service`][crate::service] for more information about using/// [`tower`][tower] services and middleware with [`hyper`]./// [hyper-svc]: hyper::service::Service/// [tower]: https://docs.rs/tower/latest/tower//// [tower-svc]: https://docs.rs/tower/latest/tower/trait.Service.html/// Create a new [`TowerToHyperService`] from a tower service.TowerToHyperServiceFuture//! Service utilities.//! [`hyper::service`] provides a [`Service`][hyper-svc] trait, representing an asynchronous//! function from a `Request` to a `Response`. This provides an interface allowing middleware for//! network application to be written in a modular and reusable way.//! This submodule provides an assortment of utilities for working with [`Service`][hyper-svc]s.//! See the module-level documentation of [`hyper::service`] for more information.//! # Tower//! While [`hyper`] uses its own notion of a [`Service`][hyper-svc] internally, many other//! libraries use a library such as [`tower`][tower] to provide the fundamental model of an//! asynchronous function.//! The [`TowerToHyperService`] type provided by this submodule can be used to bridge these//! ecosystems together. By wrapping a [`tower::Service`][tower-svc] in [`TowerToHyperService`],//! it can be passed into [`hyper`] interfaces that expect a [`hyper::service::Service`].//! [hyper-svc]: hyper::service::Service//! [tower]: https://docs.rs/tower/latest/tower///! [tower-svc]: https://docs.rs/tower/latest/tower/trait.Service.htmlsvcCalledOneshotProj// Not really pub, but used in a trait for bounds// Vendored from tower::util to reduce dependencies, the code is small enough.windows_coreIIterableRuntimeTypeIIteratorCanIntoIInspectableConstBufferIIterable_VtblComInterfacebase__IInspectable_VtblHasCurrentMoveNextGetManyIIterator_VtblAbiTypeIVectorViewGetAtIntoParamCanTryIntoVectorViewIteratorIVectorView_VtblCollectionsUniversalTimeCopyTypeICalendarICalendar_VtblSetToMinSetToMaxLanguagesNumeralSystemHSTRINGSetNumeralSystemGetCalendarSystemChangeCalendarSystemGetClockChangeClockGetDateTimeSetDateTimeSetToNowFirstEraLastEraNumberOfErasEraSetEraAddErasEraAsFullStringEraAsStringFirstYearInThisEraLastYearInThisEraNumberOfYearsInThisEraSetYearAddYearsYearAsStringYearAsTruncatedStringYearAsPaddedStringFirstMonthInThisYearLastMonthInThisYearNumberOfMonthsInThisYearSetMonthAddMonthsMonthAsFullStringMonthAsStringMonthAsFullSoloStringMonthAsSoloStringMonthAsNumericStringMonthAsPaddedNumericStringAddWeeksFirstDayInThisMonthLastDayInThisMonthNumberOfDaysInThisMonthSetDayAddDaysDayAsStringDayAsPaddedStringDayOfWeekDayOfWeekAsFullStringDayOfWeekAsStringDayOfWeekAsFullSoloStringDayOfWeekAsSoloStringFirstPeriodInThisDayLastPeriodInThisDayNumberOfPeriodsInThisDaySetPeriodAddPeriodsPeriodAsFullStringPeriodAsStringFirstHourInThisPeriodLastHourInThisPeriodNumberOfHoursInThisPeriodSetHourAddHoursHourAsStringHourAsPaddedStringSetMinuteAddMinutesMinuteAsStringMinuteAsPaddedStringSetSecondAddSecondsSecondAsStringSecondAsPaddedStringSetNanosecondAddNanosecondsNanosecondAsStringNanosecondAsPaddedStringCompareCompareDateTimeCopyToFirstMinuteInThisHourLastMinuteInThisHourNumberOfMinutesInThisHourFirstSecondInThisMinuteLastSecondInThisMinuteNumberOfSecondsInThisMinuteResolvedLanguageIsDaylightSavingTimeICalendarFactoryICalendarFactory_VtblCreateCalendarDefaultCalendarAndClockCreateCalendarICalendarFactory2ICalendarFactory2_VtblCreateCalendarWithTimeZoneITimeZoneOnCalendarITimeZoneOnCalendar_VtblGetTimeZoneChangeTimeZoneTimeZoneAsFullStringTimeZoneAsStringIGenericFactoryIActivationFactoryTryIntoParamRuntimeNameinterface_hierarchy// Bindings generated by `windows-bindgen` 0.51.1ANDROID_TIMEZONE_PROPERTY_NAME// The system property named 'persist.sys.timezone' contains the name of the// current timezone.// From https://android.googlesource.com/platform/bionic/+/gingerbread-release/libc/docs/OVERVIEW.TXT#79:// > The name of the current timezone is taken from the TZ environment variable,// > if defined. Otherwise, the system property named 'persist.sys.timezone' is// > checked instead.android_timezone_property_name/// Return a [`CStr`] to access the timezone from an Android system propertiestest_android_timezone_property_name_is_valid_cstrtest_android_timezone_property_name_getter//! Cross platform FFI helpers.ffi_utilsGetTimezoneErrorFailedParsingString/// Failed to parse/// Wrapped IO error/// Platform-specific error from the operating system/// Error typesget_timezone/// Get the current IANA time zone as a string./// See the module-level documentation for a usage example and more details/// about this function.//! get the IANA time zone for the current system//! This small utility crate provides the//! [`get_timezone()`](fn.get_timezone.html) function.//! // Get the current time zone as a string.//! let tz_str = iana_time_zone::get_timezone()?;//! println!("The current time zone is: {}", tz_str);//! # Ok::<(), iana_time_zone::GetTimezoneError>(())//! The resulting string can be parsed to a//! [`chrono-tz::Tz`](https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)//! variant like this://! let tz: chrono_tz::Tz = tz_str.parse()?;get_timezone_innerread_environmentandroid_system_propertiesAndroidSystemPropertiesetc_timezoneetc_localtimeetc_config_systemBrokenQuoteIterWords/// Iterated over all words in a OpenWRT config line./// Read the next word in a OpenWRT config line. Strip any surrounding quotation marks./// Returns///  * a tuple `Some((word, remaining_line))` if found,///  * `None` if the line is exhausted, or///  * `Err(BrokenQuote)` if the line could not be parsed.// needs to be compatile to 1.36test_read_wordopenwrtCFTypeRefCFTimeZoneCopySystemCFTimeZoneGetNameCFTimeZoneRefSystemTimeZonestring_ref/// Get the time zone name as a [super::string_ref::StringRef]./// The lifetime of the `StringRef` is bound to our lifetime. Mutable/// access is also prevented by taking a reference to `self`.//! create a safe wrapper around `CFTimeZoneRef`system_time_zoneCFRangeCFStringGetBytesCFStringGetLength_parent// We exclude mutable access to the parent by taking a reference to the// parent (rather than, for example, just using a marker to enforce the// parent's lifetime).// SAFETY: `StringRef` must be valid pointeras_utf8to_utf8//! create safe wrapper around `CFStringRef`Intl"Windows.rs"assert_matchespunycodeuts46ErrorsIdnadomain_to_ascii/// The [domain to ASCII](https://url.spec.whatwg.org/#concept-domain-to-ascii) algorithm./// Return the ASCII representation a domain name,/// normalizing characters (upper-case to lower-case and other kinds of equivalence)/// and using Punycode as necessary./// This process may fail.domain_to_ascii_strict/// The [domain to ASCII](https://url.spec.whatwg.org/#concept-domain-to-ascii) algorithm,/// with the `beStrict` flag set.domain_to_unicode/// The [domain to Unicode](https://url.spec.whatwg.org/#concept-domain-to-unicode) algorithm./// Return the Unicode representation of a domain name,/// and decoding Punycode as necessary./// This may indicate [syntax violations](https://url.spec.whatwg.org/#syntax-violation)/// but always returns a string for the mapped domain.// Copyright 2016 The rust-url developers.//! This Rust crate implements IDNA//! [per the WHATWG URL Standard](https://url.spec.whatwg.org/#idna).//! It also exposes the underlying algorithms from [*Unicode IDNA Compatibility Processing*//! (Unicode Technical Standard #46)](http://www.unicode.org/reports/tr46/)//! and [Punycode (RFC 3492)](https://tools.ietf.org/html/rfc3492).//! Quoting from [UTS #46’s introduction](http://www.unicode.org/reports/tr46/#Introduction)://! > Initially, domain names were restricted to ASCII characters.//! > A system was introduced in 2003 for internationalized domain names (IDN).//! > This system is called Internationalizing Domain Names for Applications,//! > or IDNA2003 for short.//! > This mechanism supports IDNs by means of a client software transformation//! > into a format known as Punycode.//! > A revision of IDNA was approved in 2010 (IDNA2008).//! > This revision has a number of incompatibilities with IDNA2003.//! >//! > The incompatibilities force implementers of client software,//! > such as browsers and emailers,//! > to face difficult choices during the transition period//! > as registries shift from IDNA2003 to IDNA2008.//! > This document specifies a mechanism//! > that minimizes the impact of this transition for client software,//! > allowing client software to access domains that are valid under either system.// Bootstring parameters for PunycodeT_MINT_MAXSKEWDAMPINITIAL_BIASINITIAL_NDELIMITERdecode_to_string/// Convert Punycode to an Unicode `String`./// This is a convenience wrapper around `decode`./// Convert Punycode to Unicode./// Return None on malformed input or overflow./// Overflow can only happen on inputs that take more than/// 63 encoded bytes, the DNS limit on domain name labels./// Split the input iterator and return a Vec with insertions of encoded characters/// Convert an Unicode `str` to Punycode./// This is a convenience wrapper around `encode`./// Convert Unicode to Punycode./// Return None on overflow, which can only happen on inputs that would take more thanencode_intovalue_to_digit"slow"huge_encode// Copyright 2013 The rust-url developers.//! Punycode ([RFC 3492](http://tools.ietf.org/html/rfc3492)) implementation.//! Since Punycode fundamentally works on unicode code points,//! `encode` and `decode` take and return slices and vectors of `char`.//! `encode_str` and `decode_to_string` provide convenience wrappers//! that convert from and to Rust’s UTF-8 based `str` and `String` types.bidi_classBidiClassis_combining_markis_nfcUnicodeNormalizationMAPPING_TABLESTRING_TABLEPUNYCODE_PREFIXbyte_start_lo// Store these as separate fields so the structure will have an// alignment of 1 and thus pack better into the Mapping enum, below.byte_start_hiStringTableSliceDeviationDisallowedDisallowedStd3ValidDisallowedStd3MappedDisallowedIdna2008find_charMapperpasses_bidi// http://tools.ietf.org/html/rfc5893#section-2check_validity/// Check the validity criteria for the given label/// V1 (NFC) and V8 (Bidi) are checked inside `processing()` to prevent doing duplicate work./// http://www.unicode.org/reports/tr46/#Validity_Criteriais_simple// Detect simple cases: all lowercase ASCII characters and digits where none// of the labels start with PUNYCODE_PREFIX and labels don't start or end with hyphen.processing/// http://www.unicode.org/reports/tr46/#Processingto_ascii_innerto_ascii/// http://www.unicode.org/reports/tr46/#ToASCII/// http://www.unicode.org/reports/tr46/#ToUnicodeuse_std3_ascii_rulestransitional_processingverify_dns_lengthcheck_hyphensuse_idna_2008_rules/// The defaults are that of https://url.spec.whatwg.org/#idnais_bidi_domaincheck_bidistart_combining_markinvalid_mappingnfcdisallowed_by_std3_ascii_rulesdisallowed_mapped_in_std3disallowed_charactertoo_long_for_dnstoo_short_for_dnsdisallowed_in_idna_2008/// Errors recorded during UTS #46 processing./// This is opaque for now, indicating what types of errors have been encountered at least once./// More details may be exposed in the future.mapping_fast_path// Copyright 2013-2014 The rust-url developers.//! [*Unicode IDNA Compatibility Processing*// Copyright 2013-2020 The rust-url developers.// Generated by make_idna_table.pyImageResult/// An implementation dependent iterator, reading the frames as requested/// Creates a new `Frames` from an implementation specific iterator.collect_frames/// Steps through the iterator from the current frame until the end and pushes each frame into/// a `Vec`./// If en error is encountered that error is returned instead./// Note: This is equivalent to `Frames::collect::<ImageResult<Vec<Frame>>>()`/// Delay between the frames in milliseconds/// x offset/// y offset/// A single animation frameRatio/// The delay of a frame relative to the previous one./// Constructs a new frame without any delay./// Constructs a new frame/// Delay of this frame/// Returns the image buffer/// Returns a mutable image buffer/// Returns the x offset/// Returns the y offsetfrom_numer_denom_ms/// Create a delay from a ratio of milliseconds./// use image::Delay;/// let delay_10ms = Delay::from_numer_denom_ms(10, 1);from_saturating_duration/// Convert from a duration, clamped between 0 and an implemented defined maximum./// The maximum is *at least* `i32::MAX` milliseconds. It should be noted that the accuracy of/// the result may be relative and very large delays have a coarse resolution./// let duration = Duration::from_millis(20);/// let delay = Delay::from_saturating_duration(duration);numer_denom_ms/// The numerator and denominator of the delay in milliseconds./// This is guaranteed to be an exact conversion if the `Delay` was previously created with the/// `from_numer_denom_ms` constructor.from_ratiointo_ratioclosest_bounded_fraction/// Given some fraction, compute an approximation with denominator bounded./// Note that `denom_bound` bounds nominator and denominator of all intermediate/// approximations and the end result.numerdenomfps_30duration_outlierduration_approxprecisesmallFromColordynimagesave_buffersave_buffer_with_formatwrite_buffer_with_formatflatSampleLayoutGenericImageGenericImageViewImageFormatImageOutputFormatEncodableLayoutPixelWithColorTypeexpand_packedDynamicImage/// Iterate over pixel refs.PixelsMut/// Iterate over mutable pixel refs.Rows/// Iterate over rows of an image/// This iterator is created with [`ImageBuffer::rows`]. See its document for details./// [`ImageBuffer::rows`]: ../struct.ImageBuffer.html#method.rowswith_image/// Construct the iterator from image pixels. This is not public since it has a (hidden) panic/// condition. The `pixels` slice must be large enough so that all pixels are addressable.RowsMut/// Iterate over mutable rows of an image/// This iterator is created with [`ImageBuffer::rows_mut`]. See its document for details./// [`ImageBuffer::rows_mut`]: ../struct.ImageBuffer.html#method.rows_mutEnumeratePixels/// Enumerate the pixels of an image.EnumerateRows/// Enumerate the rows of an image.EnumeratePixelsMutEnumerateRowsMut/// Generic image buffer/// This is an image parameterised by its Pixel types, represented by a width and height and a/// container of channel data. It provides direct access to its pixels and implements the/// [`GenericImageView`] and [`GenericImage`] traits. In many ways, this is the standard buffer/// implementing those traits. Using this concrete type instead of a generic type parameter has/// been shown to improve performance./// The crate defines a few type aliases with regularly used pixel types for your convenience, such/// as [`RgbImage`], [`GrayImage`] etc./// [`GenericImage`]: trait.GenericImage.html/// [`GenericImageView`]: trait.GenericImageView.html/// [`RgbImage`]: type.RgbImage.html/// [`GrayImage`]: type.GrayImage.html/// To convert between images of different Pixel types use [`DynamicImage`]./// You can retrieve a complete description of the buffer's layout and contents through/// [`as_flat_samples`] and [`as_flat_samples_mut`]. This can be handy to also use the contents in/// a foreign language, map it as a GPU host buffer or other similar tasks./// [`DynamicImage`]: enum.DynamicImage.html/// [`as_flat_samples`]: #method.as_flat_samples/// [`as_flat_samples_mut`]: #method.as_flat_samples_mut/// Create a simple canvas and paint a small cross./// use image::{RgbImage, Rgb};/// let mut img = RgbImage::new(32, 32);/// for x in 15..=17 {///     for y in 8..24 {///         img.put_pixel(x, y, Rgb([255, 0, 0]));///         img.put_pixel(y, x, Rgb([255, 0, 0]));/// Overlays an image on top of a larger background raster./// use image::{GenericImage, GenericImageView, ImageBuffer, open};/// let on_top = open("path/to/some.png").unwrap().into_rgb8();/// let mut img = ImageBuffer::from_fn(512, 512, |x, y| {///     if (x + y) % 2 == 0 {///         image::Rgb([0, 0, 0])///         image::Rgb([255, 255, 255])/// image::imageops::overlay(&mut img, &on_top, 128, 128);/// Convert an RgbaImage to a GrayImage./// use image::{open, DynamicImage};/// let rgba = open("path/to/some.png").unwrap().into_rgba8();/// let gray = DynamicImage::ImageRgba8(rgba).into_luma8();/// Constructs a buffer from a generic container/// (for example a `Vec` or a slice)/// Returns `None` if the container is not big enough (including when the image dimensions/// necessitate an allocation of more bytes than supported by the container)./// Returns the underlying raw buffer/// The width and height of this image./// The width of this image./// The height of this image.inner_pixels// TODO: choose name under which to expose./// Returns an iterator over the pixels of this image./// The iteration order is x = 0 to width then y = 0 to height/// Returns an iterator over the rows of this image./// Only non-empty rows can be iterated in this manner. In particular the iterator will not/// yield any item when the width of the image is `0` or a pixel type without any channels is/// used. This ensures that its length can always be represented by `usize`.enumerate_pixels/// Enumerates over the pixels of the image./// The iterator yields the coordinates of each pixel/// along with a reference to them./// Starting from the top left.enumerate_rows/// Enumerates over the rows of the image./// The iterator yields the y-coordinate of each row/// Gets a reference to the pixel at location `(x, y)`/// Panics if `(x, y)` is out of the bounds `(width, height)`.get_pixel_checked/// Gets a reference to the pixel at location `(x, y)` or returns `None` if/// the index is out of the bounds `(width, height)`.check_image_fits/// Test that the image fits inside the buffer./// Verifies that the maximum image of pixels inside the bounds is smaller than the provided/// length. Note that as a corrolary we also have that the index calculation of pixels inside/// the bounds will not overflow.image_buffer_lenpixel_indicespixel_indices_uncheckedsample_layout/// Get the format of the buffer when viewed as a matrix of samples.into_flat_samples/// Return the raw sample buffer with its stride an dimension information./// The returned buffer is guaranteed to be well formed in all cases. It is laid out by/// colors, width then height, meaning `channel_stride <= width_stride <= height_stride`. All/// strides are in numbers of elements but those are mostly `u8` in which case the strides are/// also byte strides.as_flat_samples/// Return a view on the raw sample buffer./// See [`into_flat_samples`](#method.into_flat_samples) for more details.as_flat_samples_mut/// Return a mutable view on the raw sample buffer.// generic implementation, shared along all image buffersinner_pixels_mutpixels_mut/// Returns an iterator over the mutable pixels of this image.rows_mut/// Returns an iterator over the mutable rows of this image.enumerate_pixels_mut/// along with a mutable reference to them.enumerate_rows_mutget_pixel_mut/// Gets a reference to the mutable pixel at location `(x, y)`get_pixel_mut_checked/// Gets a reference to the mutable pixel at location `(x, y)` or returns/// `None` if the index is out of the bounds `(width, height)`./// Puts a pixel at location `(x, y)`/// Saves the buffer to a file at the path specified./// The image format is derived from the file extension.save_with_format/// Saves the buffer to a file at the specified path in/// the specified format./// See [`save_buffer_with_format`](fn.save_buffer_with_format.html) for/// supported types./// Writes the buffer to a writer in the specified format./// Assumes the writer is buffered. In most cases,/// you should wrap your writer in a `BufWriter` for best performance./// See [`ImageOutputFormat`](enum.ImageOutputFormat.html) forwrite_with_encoder/// Writes the buffer with the given encoder.unsafe_get_pixel/// Returns the pixel located at (x, y), ignoring bounds checking.unsafe_put_pixel/// Puts a pixel at location (x, y), ignoring bounds checking.blend_pixel/// Put a pixel at location (x, y), taking into account alpha channels/// DEPRECATED: This method will be removed. Blend the pixel directly instead./// Creates a new image buffer based on a `Vec<P::Subpixel>`./// Panics when the resulting image is larger than the maximum size of a vector.from_pixel/// Constructs a new ImageBuffer by copying a pixel/// Panics when the resulting image is larger the the maximum size of a vector./// Constructs a new ImageBuffer by repeated application of the supplied function./// The arguments to the function are the pixel's x and y coordinates./// Creates an image buffer out of an existing buffer./// Returns None if the buffer is not big enough./// Consumes the image buffer and returns the underlying data/// as an owned buffer// concrete implementation for `Vec`-backed buffers// TODO: I think that rustc does not "see" this impl any more: the impl with// Container meets the same requirements. At least, I got compile errors that// there is no such function as `into_vec`, whereas `into_raw` did work, and// `into_vec` is redundant anyway, because `into_raw` will give you the vector,// and it is more generic./// Converts `self` to a buffer of type T/// A generic implementation is provided to convert any image buffer to a image buffer/// based on a `Vec<T>`./// Provides color conversions for whole image buffers.expand_palette/// Expands a color palette by re-using the existing buffer./// Assumes 8 bit per pixel. Uses an optionally transparent index to/// adjust it's alpha value accordingly.GrayImage// concrete implementation Luma -> RgbaToType/// Convert RGB image to gray image./// use image::buffer::ConvertBuffer;/// use image::GrayImage;/// let image_path = "examples/fractal.png";/// let image = image::open(&image_path)///     .expect("Open file failed")///     .to_rgba8();/// let gray_image: GrayImage = image.convert();FromType// TODO: Equality constraints are not yet supported in where clauses, when they// are, the T parameter should be removed in favor of ToType::Subpixel, which// will then be FromType::Subpixel./// Sendable Rgb image buffer/// Sendable Rgb + alpha channel image buffer/// Sendable grayscale image bufferGrayAlphaImage/// Sendable grayscale + alpha channel image bufferRgb16Image/// Sendable 16-bit Rgb image bufferRgba16Image/// Sendable 16-bit Rgb + alpha channel image bufferGray16Image/// Sendable 16-bit grayscale image bufferGrayAlpha16Image/// Sendable 16-bit grayscale + alpha channel image bufferRgb32FImage/// An image buffer for 32-bit float RGB pixels,/// where the backing container is a flattened vector of floats.Rgba32FImage/// An image buffer for 32-bit float RGBA pixels,slice_buffer/// Tests if image buffers from slices workmut_iterzero_width_zero_heightzero_width_nonzero_heightnonzero_width_zero_heightpixels_on_large_buffertest_image_buffer_copy_within_oobtest_image_buffer_copy_within_tltest_image_buffer_copy_within_trtest_image_buffer_copy_within_bltest_image_buffer_copy_within_brwrite_to_with_large_bufferexact_size_iter_size_hint//! Contains the generic `ImageBuffer` struct.IndexedParallelIteratorParallelSliceParallelSliceMutPixelsPar/// Parallel iterator over pixel refs.opt_lenConsumerProducerCallbackwith_producerPixelsMutPar/// Parallel iterator over mutable pixel refs.EnumeratePixelsPar/// Parallel iterator over pixel refs and their coordinates.EnumeratePixelsMutPar/// Parallel iterator over mutable pixel refs and their coordinates.par_pixels/// Returns a parallel iterator over the pixels of this image, usable with `rayon`./// See [`pixels`] for more information./// [`pixels`]: #method.pixelspar_enumerate_pixels/// Returns a parallel iterator over the pixels of this image and their coordinates, usable with `rayon`./// See [`enumerate_pixels`] for more information./// [`enumerate_pixels`]: #method.enumerate_pixelspar_pixels_mut/// Returns a parallel iterator over the mutable pixels of this image, usable with `rayon`./// See [`pixels_mut`] for more information./// [`pixels_mut`]: #method.pixels_mutpar_enumerate_pixels_mut/// Returns a parallel iterator over the mutable pixels of this image and their coordinates, usable with `rayon`./// See [`enumerate_pixels_mut`] for more information./// [`enumerate_pixels_mut`]: #method.enumerate_pixels_mutfrom_par_fn/// Constructs a new ImageBuffer by repeated application of the supplied function,/// utilizing multi-threading via `rayon`.test_width_heightiter_paritycreationcreation_parpixel_funcbenchmarks/// The [AVIF] specification defines an image derivative of the AV1 bitstream, an open video codec./// [AVIF]: https://aomediacodec.github.io/av1-avif/ImageFormatHintUnsupportedErrorUnsupportedErrorKindColorTypeImageDecoderImageErrordav1dPixelLayoutPlanarImageComponentdcv_color_primitivesdcpmp4parseread_avifParseStrictnesserror_mappicturealpha_pictureicc_profileAvifDecoder/// AVIF Decoder./// Reads one image into the chosen input./// Create a new decoder that reads its input from `r`.AvifReader/// Wrapper struct around a `Cursor<Vec<u8>>`color_typeinto_readerread_imageread_until_ready/// `get_picture` and `send_pending_data` yield `Again` as a non-fatal error requesting more data is sent to the decoder/// This ensures that in the case of `Again` all pending data is submitted/// This should be called after `send_data` (which does not yield `Again` when called the first time)//! Decoding of AVIF images.ParameterErrorParameterErrorKindravifImgRGB8RGBA8AsPixelsAvifEncoder/// AVIF Encoder./// Writes one image into the chosen output.ColorSpace/// sRGB colorspace/// BT.709 colorspace/// An enumeration over supported AVIF color spacesto_ravifRgb8Rgba8/// Create a new encoder that writes its output to `w`.new_with_speed_quality/// Create a new encoder with a specified speed and quality that writes its output to `w`./// `speed` accepts a value in the range 1-10, where 1 is the slowest and 10 is the fastest./// Slower speeds generally yield better compression results./// `quality` accepts a value in the range 1-100, where 1 is the worst and 100 is the best.with_colorspace/// Encode with the specified `color_space`.with_num_threads/// Configures `rayon` thread pool size./// The default `None` is to use all threads in the default `rayon` thread pool.write_image/// Encode image data with the indicated color type./// The encoder currently requires all data to be RGBA8, it will be converted internally if/// necessary. When data is suitably aligned, i.e. u16 channels to two bytes, then the/// conversion may be more efficient.// Does not currently do anything. Mirrors behaviour of old config function.encode_as_img//! Encoding of AVIF images.ImageDecoderRectBITMAPCOREHEADER_SIZEBITMAPINFOHEADER_SIZEBITMAPV2HEADER_SIZEBITMAPV3HEADER_SIZEBITMAPV4HEADER_SIZEBITMAPV5HEADER_SIZELOOKUP_TABLE_3_BIT_TO_8_BITLOOKUP_TABLE_4_BIT_TO_8_BITLOOKUP_TABLE_5_BIT_TO_8_BITLOOKUP_TABLE_6_BIT_TO_8_BITR5_G5_B5_COLOR_MASKR8_G8_B8_COLOR_MASKR8_G8_B8_A8_COLOR_MASKRLE_ESCAPERLE_ESCAPE_EOLRLE_ESCAPE_EOFRLE_ESCAPE_DELTAMAX_WIDTH_HEIGHT/// The maximum width/height the decoder will process.RGB16RGB24RGB32RGBA32RLE8RLE4Bitfields16Bitfields32BMPHeaderTypeFormatFullBytesFormat888ChunkerFromTopFromBottomRowIteratorCorruptRleData// Failed to decompress RLE data.BitfieldMaskNonContiguous/// The bitfield mask interleaves set and unset bitsBitfieldMaskInvalid/// Bitfield mask invalid (e.g. too long for specified type)BitfieldMaskMissing/// Bitfield (of the specified width – 16- or 32-bit) mask not presentBitfieldMasksMissing/// Bitfield (of the specified width – 16- or 32-bit) masks not presentBmpSignatureInvalid/// BMP's "BM" signature wrong or missingMoreThanOnePlane/// More than the exactly one allowed plane specified by the formatChannelWidthErrorInvalidChannelWidth/// Invalid amount of bits per channel for the specified image typeNegativeWidth/// The width is negativeImageTooLarge/// One of the dimensions is larger than a soft limitInvalidHeight/// The height is `i32::min_value()`/// General negative heights specify top-down DIBsImageTypeInvalidForTopDown/// Specified image type is invalid for top-down BMPs (i.e. is compressed)ImageTypeUnknown/// Image type not currently recognized by the decoderHeaderTooSmall/// Bitmap header smaller than the core headercolors_usedbit_countPaletteSizeExceeded/// The palette is bigger than allowed by the bit count of the BMP/// All errors that can occur when attempting to parse a BMP/// RGBRle8/// 8-bit run length encodingRle4/// 4-bit run length encoding/// Bitfields (16- or 32-bit)/// Distinct image types whose saved channel width can be invalidcheck_for_overflow/// Convenience function to check if the combination of width, length and number of/// channels would result in a buffer that would overflow./// Calculate how many many bytes a buffer holding a decoded image with these properties would/// require. Returns `None` if the buffer size would overflow or if one of the sizes are negative.with_rows/// Call the provided function on each row of the provided buffer, returning Err if the provided/// function returns an error, extends the buffer if it's not large enough.set_8bit_pixel_runset_4bit_pixel_runset_2bit_pixel_runset_1bit_pixel_runbmp_header_typeindexed_colordata_offsettop_downno_file_headeradd_alpha_channelhas_loaded_metadataimage_typeBmpDecoder/// A bmp decoderRLEInsnEndOfFileEndOfRowPixelRunnew_decoder/// Create a new decoder that decodes from the stream ```r```new_without_file_header/// Create a new decoder that decodes from the stream ```r``` without first/// reading a BITMAPFILEHEADER. This is useful for decoding the CF_DIB format/// directly from the Windows clipboard.new_with_ico_formatset_indexed_color/// If true, the palette in BMP does not apply to the image even if it is found./// In other words, the output image is the indexed color.read_file_headerread_bitmap_core_header/// Read BITMAPCOREHEADER https://msdn.microsoft.com/en-us/library/vs/alm/dd183372(v=vs.85).aspx/// returns Err if any of the values are invalid.read_bitmap_info_header/// Read BITMAPINFOHEADER https://msdn.microsoft.com/en-us/library/vs/alm/dd183376(v=vs.85).aspx/// or BITMAPV{2|3|4|5}HEADER.read_bitmasksread_metadataread_metadata_in_ico_formatget_palette_sizebytes_per_colorread_paletteget_palette/// Get the palette that is embedded in the BMP image, if any.num_channelsread_palettized_pixel_dataread_16_bit_pixel_dataread_32_bit_pixel_data/// Read image data from a reader in 32-bit formats that use bitfields.read_full_byte_pixel_data/// Read image data from a reader where the colours are stored as 8-bit values (24 or 32-bit).read_rle_dataread_image_data/// Read the actual data of the image. This function is deliberately not public because it/// cannot be called multiple times without seeking back the underlying reader in between.BmpReaderread_rect_with_progresstest_bitfield_lenread_rectread_rle_too_shorttest_no_headerBITMAPFILEHEADER_SIZEBmpEncoder/// The representation of a BMP encoder./// Create a new encoder that writes its output to ```w```./// Encodes the image `image` that has dimensions `width` and `height` and `ColorType` `c`./// Panics if `width * height * c.bytes_per_pixel() != image.len()`.encode_with_palette/// Same as `encode`, but allow a palette to be passed in. The `palette` is ignored for color/// types other than Luma/Luma-with-alpha.encode_rgbencode_rgbaencode_graywrite_row_padget_unsupported_error_messageget_pixel_info/// Returns a tuple representing: (dib header size, written pixel size, palette color count).round_trip_imageround_trip_single_pixel_rgbhuge_files_return_errorround_trip_single_pixel_rgbaround_trip_3px_rgbround_trip_grayround_trip_graya//!  Decoding and Encoding of BMP Images//!  A decoder and encoder for BMP (Windows Bitmap) images//!  # Related Links//!  * <https://msdn.microsoft.com/en-us/library/windows/desktop/dd183375%28v=vs.85%29.aspx>//!  * <https://en.wikipedia.org/wiki/BMP_file_format>dxtDxtDecoderDxtReaderDxtVariantPixelFormatSizeInvalid/// Wrong DDS channel widthHeaderSizeInvalid/// Wrong DDS header sizeHeaderFlagsInvalid/// Wrong DDS header flagsDxgiFormatInvalid/// Invalid DXGI format in DX10 headerResourceDimensionInvalid/// Invalid resource dimensionDx10FlagsInvalid/// Invalid flags in DX10 headerDx10ArraySizeInvalid/// Invalid array size in DX10 headerDdsSignatureInvalid/// DDS "DDS " signature invalid or missing/// Errors that can occur during decoding and parsing a DDS image_flags_pitch_or_linear_size_depth_mipmap_countPixelFormat_caps_caps2/// Header used by DDS image filesdxgi_formatresource_dimensionmisc_flagmisc_flags_2DX10Header/// Extended DX10 header used by some DDS image filesfourcc_rgb_bit_count_r_bit_mask_g_bit_mask_b_bit_mask_a_bit_mask/// DDS pixel formatfrom_readerDdsDecoder/// The representation of a DDS decoder/// Create a new decoder that decodes from the stream `r`scanline_bytesdimension_overflow//!  Decoding of DDS images//!  DDS (DirectDraw Surface) is a container format for storing DXT (S3TC) compressed images.//!  * <https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide> - Description of the DDS format.ImageReadBufferDXT1/// The DXT1 format. 48 bytes of RGB data in a 4x4 pixel square is/// compressed into an 8 byte block of DXT1 dataDXT3/// The DXT3 format. 64 bytes of RGBA data in a 4x4 pixel square is/// compressed into a 16 byte block of DXT3 dataDXT5/// The DXT5 format. 64 bytes of RGBA data in a 4x4 pixel square is/// compressed into a 16 byte block of DXT5 data/// What version of DXT compression are we using?/// Note that DXT2 and DXT4 are left away as they're/// just DXT3 and DXT5 with premultiplied alphadecoded_bytes_per_block/// Returns the amount of bytes of raw image data/// that is encoded in a single DXTn blockencoded_bytes_per_block/// Returns the amount of bytes per block of encoded DXTn data/// Returns the color type that is stored in this DXT variantwidth_blocksheight_blocks/// DXT decoder/// Create a new DXT decoder that decodes from the stream ```r```./// As DXT is often stored as raw buffers with the width/height/// somewhere else the width and height of the image need/// to be passed in ```width``` and ```height```, as well as the/// DXT variant in ```variant```./// width and height are required to be powers of 2 and at least 4./// otherwise an error will be returnedread_scanline// Note that, due to the way that DXT compression works, a scanline is considered to consist out of// 4 lines of pixels./// DXT readerDxtEncoder/// DXT encoder/// Create a new encoder that writes its output to ```w```/// Encodes the image data ```data```/// that has dimensions ```width``` and ```height```/// in ```DxtVariant``` ```variant```/// data is assumed to be in variant.color_type()/**
 * Actual encoding/decoding logic below.
 */enc565_decode/// decodes a 5-bit R, 6-bit G, 5-bit B 16-bit packed color value into 8-bit RGB/// mapping is done so min/max range values are preserved. So for 5-bit/// values 0x00 -> 0x00 and 0x1F -> 0xFFenc565_encode/// encodes an 8-bit RGB value into a 5-bit R, 6-bit G, 5-bit B 16-bit packed color value/// mapping preserves min/max values. It is guaranteed that i == encode(decode(i)) for all i/// utility function: squares a value/// returns the squared error between two RGB valuesalpha_table_dxt5/// Constructs the DXT5 alpha lookup table from the two alpha entries/// if alpha0 > alpha1, constructs a table of [a0, a1, 6 linearly interpolated values from a0 to a1]/// if alpha0 <= alpha1, constructs a table of [a0, a1, 4 linearly interpolated values from a0 to a1, 0, 0xFF]decode_dxt_colors/// decodes an 8-byte dxt color block into the RGB channels of a 16xRGB or 16xRGBA block./// source should have a length of 8, dest a length of 48 (RGB) or 64 (RGBA)decode_dxt5_block/// Decodes a 16-byte bock of dxt5 data to a 16xRGBA blockdecode_dxt3_block/// Decodes a 16-byte bock of dxt3 data to a 16xRGBA blockdecode_dxt1_block/// Decodes a 8-byte bock of dxt5 data to a 16xRGB blockdecode_dxt1_row/// Decode a row of DXT1 data to four rows of RGB data./// source.len() should be a multiple of 8, otherwise this panics.decode_dxt3_row/// Decode a row of DXT3 data to four rows of RGBA data./// source.len() should be a multiple of 16, otherwise this panics.decode_dxt5_row/// Decode a row of DXT5 data to four rows of RGBA data.encode_dxt_colors/// Tries to perform the color encoding part of dxt compression/// the approach taken is simple, it picks unique combinations/// of the colors present in the block, and attempts to encode the/// block with each, picking the encoding that yields the least/// squared error out of all of them./// This could probably be faster but is already reasonably fast/// and a good reference impl to optimize others against./// Another way to perform this analysis would be to perform a/// singular value decomposition of the different colors, and/// then pick 2 points on this line as the base colors. But/// this is still rather unwieldy math and has issues/// with the 3-linear-colors-and-0 case, it's also worse/// at conserving the original colors./// source: should be RGBAx16 or RGBx16 bytes of data,/// dest 8 bytes of resulting encoded color dataencode_dxt5_alpha/// Encodes a buffer of 16 alpha bytes into a dxt5 alpha index table,/// where the alpha table they are indexed against is created by/// calling alpha_table_dxt5(alpha0, alpha1)/// returns the resulting error and alpha tableencode_dxt5_block/// Encodes a RGBAx16 sequence of bytes to a 16 bytes DXT5 blockencode_dxt3_block/// Encodes a RGBAx16 sequence of bytes into a 16 bytes DXT3 blockencode_dxt1_block/// Encodes a RGBx16 sequence of bytes into a 8 bytes DXT1 blockencode_dxt1_row/// Decode a row of DXT1 data to four rows of RGBA data.encode_dxt3_rowencode_dxt5_row//!  Decoding of DXT (S3TC) compression//!  DXT is an image format that supports lossy compression//!  * <https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_texture_compression_s3tc.txt> - Description of the DXT compression OpenGL extensions.//!  Note: this module only implements bare DXT encoding/decoding, it does not parse formats that can contain DXT files like .dds/*
 * Functions for decoding DXT compression
 *//*
 * Functions for encoding DXT compression
 */current_offset/// Relative to the start of the pixel datacached_byteFarbfeldReader/// farbfeld Readerconsume_channelcache_byteFarbfeldDecoder/// farbfeld decoder/// Creates a new decoder that decodes from the stream ```r```FarbfeldEncoder/// farbfeld encoder/// Create a new encoder that writes its output to ```w```. The writer should be buffered./// Encodes the image `data` (native endian) that has dimensions `width` and `height`./// Panics if `width * height * 8 != data.len()`.farbfeldRECTANGLE_INread_rect_1x2read_rect_2x2read_rect_2x1read_rect_2x3read_rect_in_streamdegenerate_pixels//! Decoding of farbfeld images//! farbfeld is a lossless image format which is easy to parse, pipe and compress.//! It has the following format://! | Bytes  | Description                                             |//! |--------|---------------------------------------------------------|//! | 8      | "farbfeld" magic value                                  |//! | 4      | 32-Bit BE unsigned integer (width)                      |//! | 4      | 32-Bit BE unsigned integer (height)                     |//! | [2222] | 4⋅16-Bit BE unsigned integers [RGBA] / pixel, row-major |//! The RGB-data should be sRGB for best interoperability and not alpha-premultiplied.//! # Related Links//! * <https://tools.suckless.org/farbfeld/> - the farbfeld specificationLimitErrorLimitErrorKindAnimationDecoderLimitslimitsGifDecoder/// GIF decoder/// Creates a new decoder that decodes the input steam `r`with_limits/// Creates a new decoder that decodes the input steam `r`, using limits `limits`GifReaderset_limitsnon_disposed_frameGifFrameIteratorinto_framesdisposal_methodFrameInfonew_from_frame/// Looping GIF/// Number of repetitions for a GIF animationto_gif_enumgif_encoderspeedGifEncoder/// Creates a new GIF encoder with a speed of 1. This prioritizes quality over performance at any cost.new_with_speed/// Create a new GIF encoder, and has the speed parameter `speed`. See/// [`Frame::from_rgba_speed`](https://docs.rs/gif/latest/gif/struct.Frame.html#method.from_rgba_speed)/// Set the repeat behaviour of the encoded GIF/// Encode a single image.encode_frame/// Encode one frame of animation.encode_frames/// Encodes Frames./// Consider using `try_encode_frames` instead to encode an `animation::Frames` like iterator.try_encode_frames/// Try to encode a collection of `ImageResult<animation::Frame>` objects./// Use this function to encode an `animation::Frames` like iterator./// Whenever an `Err` item is encountered, that value is returned without further actions.convert_framegif_dimensionsencode_giffrom_decodingframes_exceeding_logical_screen_size//!  Decoding of GIF Images//!  GIF (Graphics Interchange Format) is an image format that supports lossless compression.//!  * <http://www.w3.org/Graphics/GIF/spec-gif89a.txt> - The GIF Specification//! use image::codecs::gif::{GifDecoder, GifEncoder};//! use image::{ImageDecoder, AnimationDecoder};//! # fn main() -> std::io::Result<()> {//! // Decode a gif into frames//! let file_in = File::open("foo.gif")?;//! let mut decoder = GifDecoder::new(file_in).unwrap();//! let frames = decoder.into_frames();//! let frames = frames.collect_frames().expect("error decoding gif");//! // Encode frames into a gif and save to a file//! let mut file_out = File::open("out.gif")?;//! let mut encoder = GifEncoder::new(file_out);//! encoder.encode_frames(frames.into_iter());identitiesRadianceHdrSignatureInvalid/// HDR's "#?RADIANCE" signature wrong or missingTruncatedHeader/// EOF before end of headerTruncatedDimensions/// EOF instead of image dimensionsLineTypeUnparsableF32/// A value couldn't be parsedUnparsableU32LineTooShort/// Not enough numbers in lineExtraneousColorcorrNumbers/// COLORCORR contains too many numbers in strict modeDimensionsLineTooShort/// Dimensions line had too few elementsDimensionsLineTooLong/// Dimensions line had too many elementsWrongScanlineLength/// The length of a scanline (1) wasn't a match for the specified length (2)FirstPixelRlMarker/// First pixel of a scanline is a run length marker/// Errors that can occur during decoding and parsing of a HDR imagePixaspectColorcorrDimensionsHeightDimensionsWidth/// Lines which contain parsable data that can failHdrDecoderHdrMetadata// data: Option<Vec<u8>>,HdrAdapter/// Adapter to conform to `ImageDecoder` trait/// Creates adapternew_nonstrict/// Allows reading old Radiance HDR images/// Read the actual data of the image, and store it in Self::data.HdrReader/// Radiance HDR file signature/// An Radiance HDR decoder/// Color components/// ExponentRgbe8Pixel/// Refer to [wikipedia](https://en.wikipedia.org/wiki/RGBE_image_format)rgbe8/// Creates `Rgbe8Pixel` from componentsto_hdr/// Converts `Rgbe8Pixel` into `Rgb<f32>` linearlyto_ldr/// Converts `Rgbe8Pixel` into `Rgb<T>` with scale=1 and gamma=2.2/// color_ldr = (color_hdr*scale)<sup>gamma</sup>/// Panics when `T::max_value()` cannot be represented as f32.to_ldr_scale_gamma/// Converts `Rgbe8Pixel` into `Rgb<T>` using provided scale and gamma/// Panics when scale or gamma is NaN/// Reads Radiance HDR image header from stream `r`/// if the header is valid, creates HdrDecoder/// strict mode is enabledwith_strictness/// Reads Radiance HDR image header from stream `reader`,/// if the header is valid, creates `HdrDecoder`./// strict enables strict mode/// Warning! Reading wrong file in non-strict mode///   could consume file size worth of memory in the process./// Returns file metadata. Refer to `HdrMetadata` for details.read_image_native/// Consumes decoder and returns a vector of RGBE8 pixelsread_image_transform/// Consumes decoder and returns a vector of transformed pixelsread_image_ldr/// Consumes decoder and returns a vector of `Rgb<u8>` pixels./// scale = 1, gamma = 2.2read_image_hdr/// Consumes decoder and returns a vector of `Rgb<f32>` pixels.// end with_strictnessHdrImageDecoderIteratorscanline_cntcol// scanline bufferscanline// current position in scanlinetrouble// current scanlineerror_encountered// optimization, true indicates that we need to check something/// Scanline buffered pixel by pixel iterator// Advances counter to the next pixel// Precondition: buf.len() > 0decode_component// Guarantees that first parameter of set_component will be within pos .. pos+widthdecode_old_rle// Decodes scanline, places it into buf// fb - first 4 bytes of scanlineread_rgbe/// Width of decoded image. It could be either scanline length,/// or scanline count, depending on image orientation./// Height of decoded image. It depends on orientation too./// Orientation matrix. For standard orientation it is ((1,0),(0,1)) - left to right, top to bottom./// First pair tells how resulting pixel coordinates change along a scanline./// Second pair tells how they change from one scanline to the next./// Divide color values by exposure to get to get physical radiance in/// watts/steradian/m<sup>2</sup>/// Image may not contain physical data, even if this field is set.color_correction/// Divide color values by corresponding tuple member (r, g, b) to get to get physical radiance/// in watts/steradian/m<sup>2</sup>pixel_aspect_ratio/// Pixel height divided by pixel widthcustom_attributes/// All lines contained in image header are put here. Ordering of lines is preserved./// Lines in the form "key=value" are represented as ("key", "value")./// All other lines are ("", "line")/// Metadata for Radiance HDR imageupdate_header_info// Updates header info, in strict mode returns error for malformed lines (no '=' separator)// unknown attributes are skippedparse_space_separated_f32parse_dimensions_line// Parses dimension line "-Y height +X width"// returns (width, height) or errorlimit_string_len// Returns string with no more than len+3 characterssplit_at_first// Splits string into (before separator, after separator) tuple// or None if separator isn't foundsplit_at_first_testread_line_u8// Reads input until b"\n" or EOF// Returns vector of read bytes NOT including end of line characters//   or return None to indicate end of fileread_line_u8_testread_raw_file/// Helper function for reading raw 3-channel f32 imagesHdrEncoder/// Radiance HDR encoder/// Creates encoder/// Encodes the image ```data```RunOrNotNorunRUN_MAX_LENNORUN_MAX_LENcuridxRunIteratorruniterNorunCombineIterator// Combines sequential noruns produced by RunIteratorrle_compress// Appends RLE compressed ```data``` to ```rle```write_rgbe8to_rgbe8/// Converts ```Rgb<f32>``` into ```Rgbe8Pixel```to_rgbe8_testruniterator_testnoruncombine_test//!  Decoding of Radiance HDR Images//!  A decoder for Radiance HDR images//!  * <http://radsite.lbl.gov/radiance/refer/filefmts.pdf>//!  * <http://www.graphics.cornell.edu/~bjw/rgbe/rgbe.c>InnerDecoderbmpPngDecoderPNG_SIGNATURENoEntries/// The ICO directory is emptyIcoEntryTooManyPlanesOrHotspot/// The number of color planes (0 or 1), or the horizontal coordinate of the hotspot for CUR files too big.IcoEntryTooManyBitsPerPixelOrHotspot/// The bit depth (may be 0 meaning unspecified), or the vertical coordinate of the hotspot for CUR files too big.PngShorterThanHeader/// The entry is in PNG format and specified a length that is shorter than PNG header.PngNotRgba/// The enclosed PNG is not in RGBA, which is invalid: https://blogs.msdn.microsoft.com/oldnewthing/20101022-00/?p=12473/.InvalidDataSize/// The entry is in BMP format and specified a data size that is not correct for the image and optional mask data.IcoEntryImageFormat/// The mismatched subimage's type/// The dimensions specified by the entry/// The dimensions of the image itselfImageEntryDimensionMismatch/// The dimensions specified by the entry does not match the dimensions in the header of the enclosed image./// Errors that can occur during decoding and parsing an ICO image or one of its enclosed images./// PNG in ARGBBmp/// BMP with optional alpha mask/// The image formats an ICO may containselected_entryinner_decoderIcoDecoder/// An ico decodercolor_count// We ignore some header fields as they will be replicated in the PNG, BMP and they are not// necessary for determining the best_entry.// Wikipedia has this to say:// Although Microsoft's technical documentation states that this value must be zero, the icon// encoder built into .NET (System.Drawing.Icon.Save) sets this value to 255. It appears that// the operating system ignores this value altogether.num_color_planesimage_lengthimage_offsetread_entriesread_entrybest_entry/// Find the entry with the highest (color depth, size).real_widthreal_heightmatches_dimensionsseek_to_startis_pngIcoReaderbmp_16_with_missing_alpha_channel// Test if BMP images without alpha channel inside ICOs don't panic.// Because the test data is invalid decoding should produce an error.ICO_IMAGE_TYPE// Enum value indicating an ICO image (as opposed to a CUR image):ICO_ICONDIR_SIZE// The length of an ICO file ICONDIR structure, in bytes:ICO_DIRENTRY_SIZE// The length of an ICO file DIRENTRY structure, in bytes:IcoEncoder/// ICO encoderencoded_image// Pre-encoded PNG or BMP// Stored as `0 => 256, n => n`IcoFrame/// An ICO image entrywith_encoded/// Construct a new `IcoFrame` using a pre-encoded PNG or BMP/// The `width` and `height` must be between 1 and 256 (inclusive).as_png/// Construct a new `IcoFrame` by encoding `buf` as a PNG/// The `width` and `height` must be between 1 and 256 (inclusive)"Use `IcoEncoder::write_image` instead. Beware that `write_image` has a different endianness convention"/// Encodes the image ```image``` that has dimensions ```width``` and/// ```height``` and ```ColorType``` ```c```.  The dimensions of the image/// must be between 1 and 256 (inclusive) or an error will be returned./// Expects data to be big endian.encode_images/// Takes some [`IcoFrame`]s and encodes them into an ICO./// `images` is a list of images, usually ordered by dimension, which/// must be between 1 and 65535 (inclusive) in length./// Write an ICO image with the specified width, height, and color type./// For color types with 16-bit per channel or larger, the contents of `buf` should be in/// native endian./// WARNING: In image 0.23.14 and earlier this method erroneously expected buf to be in big endian.write_icondirwrite_direntry//!  Decoding and Encoding of ICO files//!  A decoder and encoder for ICO (Windows Icon) image container files.//!  * <https://msdn.microsoft.com/en-us/library/ms997538.aspx>//!  * <https://en.wikipedia.org/wiki/ICO_%28file_format%29>ImageInfoJpegDecoder/// JPEG decoder/// Configure the decoder to scale the image during decoding./// This efficiently scales the image by the smallest supported/// scale factor that produces an image larger than or equal to/// the requested size in at least one axis. The currently/// implemented scale factors are 1/8, 1/4, 1/2 and 1./// To generate a thumbnail of an exact size, pass the desired/// size and then scale to the final size using a traditional/// resampling algorithm./// The size of the image to be loaded, with the scale factor/// applied, is returned.JpegReadercmyk_to_rgbfrom_jpegcmyk_to_rgb_correctsingle_pix_correcttest_assorted_colorsentropybuild_huff_lut_constSOF0// Markers// Baseline DCTDHT// Huffman TablesSOI// Start of Image (standalone)EOI// End of image (standalone)SOS// Start of ScanDQT// Quantization TablesAPP0// Application segments start and endSTD_LUMA_QTABLE// section K.1// table K.1STD_CHROMA_QTABLE// table K.2STD_LUMA_DC_CODE_LENGTHS// section K.3// Code lengths and values for table K.3STD_LUMA_DC_VALUESSTD_LUMA_DC_HUFF_LUTSTD_CHROMA_DC_CODE_LENGTHS// Code lengths and values for table K.4STD_CHROMA_DC_VALUESSTD_CHROMA_DC_HUFF_LUTSTD_LUMA_AC_CODE_LENGTHS// Code lengths and values for table k.5STD_LUMA_AC_VALUESSTD_LUMA_AC_HUFF_LUTSTD_CHROMA_AC_CODE_LENGTHS// Code lengths and values for table k.6STD_CHROMA_AC_VALUESSTD_CHROMA_AC_HUFF_LUTDCCLASSACCLASSLUMADESTINATIONCHROMADESTINATIONLUMAIDCHROMABLUEIDCHROMAREDIDUNZIGZAG/// The permutation of dct coefficients./// The Component's identifier/// Horizontal sampling factor/// Vertical sampling factortq/// The quantization table selectordc_table/// Index to the Huffman DC Tableac_table/// Index to the AC Huffman Table_dc_pred/// The dc prediction of the component/// A representation of a JPEG componentBitWriterpad_bytehuffman_encodewrite_blockwrite_segmentPixelDensityUnitPixelAspectRatio/// Represents the absence of a unit, the values indicate only a/// [pixel aspect ratio](https://en.wikipedia.org/wiki/Pixel_aspect_ratio)Inches/// Pixels per inch (2.54 cm)Centimeters/// Pixels per centimeter/// Represents a unit in which the density of an image is measureddensity/// A couple of values for (Xdensity, Ydensity)/// The unit in which the density is measuredPixelDensity/// Represents the pixel density of an image/// For example, a 300 DPI image is represented by:/// use image::codecs::jpeg::*;/// let hdpi = PixelDensity::dpi(300);/// assert_eq!(hdpi, PixelDensity {density: (300,300), unit: PixelDensityUnit::Inches})/// Creates the most common pixel density type:/// the horizontal and the vertical density are equal,/// and measured in pixels per inch./// Returns a pixel density with a pixel aspect ratio of 1luma_dctableluma_actablechroma_dctablechroma_actablepixel_densityJpegEncoder/// The representation of a JPEG encodernew_with_quality/// Create a new encoder that writes its output to ```w```, and has/// the quality parameter ```quality``` with a value in the range 1-100/// where 1 is the worst and 100 is the best.set_pixel_density/// Set the pixel density of the images the encoder will encode./// If this method is not called, then a default pixel aspect ratio of 1x1 will be applied,/// and no DPI information will be stored in the image./// Encodes the image stored in the raw byte buffer ```image```/// and ```ColorType``` ```c```/// The Image in encoded with subsampling ratio 4:2:2/// Panics if `width * height * color_type.bytes_per_pixel() != image.len()`.encode_image/// Encodes the given image./// As a special feature this does not require the whole image to be present in memory at the/// same time such that it may be computed on the fly, which is why this method exists on this/// encoder but not on others. Instead the encoder will iterate over 8-by-8 blocks of pixels at/// a time, inspecting each pixel exactly once. You can rely on this behaviour when callingbuild_jfif_headerbuild_frame_headerbuild_scan_headerbuild_huffman_segmentbuild_quantization_segmentencode_coefficientrgb_to_ycbcrpixel_at_or_near/// Returns the pixel at (x,y) if (x,y) is in the image,/// otherwise the closest pixel in the imagecopy_blocks_ycbcrcopy_blocks_grayDimensionMismatchroundtrip_sanity_checkgrayscale_roundtrip_sanity_checkjfif_header_density_checktest_image_too_largetest_build_jfif_headertest_build_frame_headertest_build_scan_headertest_build_huffman_segmenttest_build_quantization_segmentderive_codes_and_sizes/// Given an array containing the number of codes of each code length,/// this function generates the huffman codes lengths and their respective/// code lengths as specified by the JPEG spec.//! Decoding and Encoding of JPEG Images//! JPEG (Joint Photographic Experts Group) is an image format that supports lossy compression.//! This module implements the Baseline JPEG standard.//! * <http://www.w3.org/Graphics/JPEG/itu-t81.pdf> - The JPEG specificationCONST_BITSPASS1_BITSFIX_0_298631336FIX_0_390180644FIX_0_541196100FIX_0_765366865FIX_0_899976223FIX_1_175875602FIX_1_501321110FIX_1_847759065FIX_1_961570560FIX_2_053119869FIX_2_562915447FIX_3_072711026fdct/*
fdct is a Rust translation of jfdctint.c from the
Independent JPEG Group's libjpeg version 9a
obtained from http://www.ijg.org/files/jpegsr9a.zip
It comes with the following conditions of distribution and use:

    In plain English:

    1. We don't promise that this software works.  (But if you find any bugs,
        please let us know!)
    2. You can use this software for whatever you want.  You don't have to pay us.
    3. You may not pretend that you wrote this software.  If you use it in a
       program, you must acknowledge somewhere in your documentation that
       you've used the IJG code.

    In legalese:

    The authors make NO WARRANTY or representation, either express or implied,
    with respect to this software, its quality, accuracy, merchantability, or
    fitness for a particular purpose.  This software is provided "AS IS", and you,
    its user, assume the entire risk as to its quality and accuracy.

    This software is copyright (C) 1991-2014, Thomas G. Lane, Guido Vollbeding.
    All Rights Reserved except as specified below.

    Permission is hereby granted to use, copy, modify, and distribute this
    software (or portions thereof) for any purpose, without fee, subject to these
    conditions:
    (1) If any part of the source code for this software is distributed, then this
    README file must be included, with this copyright and no-warranty notice
    unaltered; and any additions, deletions, or changes to the original files
    must be clearly indicated in accompanying documentation.
    (2) If only executable code is distributed, then the accompanying
    documentation must state that "this software is based in part on the work of
    the Independent JPEG Group".
    (3) Permission for use of this software is granted only if the user accepts
    full responsibility for any undesirable consequences; the authors accept
    NO LIABILITY for damages of any kind.

    These conditions apply to any software derived from or based on the IJG code,
    not just to the unmodified library.  If you use our work, you ought to
    acknowledge us.

    Permission is NOT granted for the use of any IJG author's name or company name
    in advertising or publicity relating to this software or products derived from
    it.  This software may be referred to only as "the Independent JPEG Group's
    software".

    We specifically permit and encourage the use of this software as the basis of
    commercial products, provided that all warranty or liability claims are
    assumed by the product vendor.
*/decoder_to_vecexr_readerheader_index// select a header that is rgb and not deepalpha_preference// decode either rgb or rgba.// can be specified to include or discard alpha channels.// if none, the alpha channel will only be allocated where the file contains data for it.alpha_present_in_fileOpenExrDecoder/// An OpenEXR decoder. Immediately reads the meta data from the file./// Create a decoder. Consumes the first few bytes of the source to extract image dimensions./// Assumes the reader is buffered. In most cases,/// you should wrap your reader in a `BufReader` for best performance./// Loads an alpha channel if the file has alpha samples./// Use `with_alpha_preference` if you want to load or not load alpha unconditionally.with_alpha_preference/// If alpha preference is specified, an alpha channel will/// always be present or always be not present in the returned image./// If alpha preference is none, the alpha channel will only be returned if it is found in the file.selected_exr_header// does not leak exrs-specific meta data into public api, just does it for this moduleoriginal_color_type/// Use `read_image` instead if possible,/// as this method creates a whole new buffer just to contain the entire image.read_image_with_progress// reads with or without alpha, depending on `self.alpha_preference` and `self.alpha_present_in_file`/// Write a raw byte buffer of pixels,/// returning an Error if it has an invalid length.// private. access via `OpenExrEncoder`OpenExrEncoder// TODO is this struct and trait actually used anywhere?/// A thin wrapper that implements `ImageEncoder` for OpenEXR images. Will behave like `image::codecs::openexr::write_buffer`./// Create an `ImageEncoder`. Does not write anything yet. Writing later will behave like `image::codecs::openexr::write_buffer`.// use constructor, not public field, for future backwards-compatibility/// Writes the complete image./// Assumes the writer is buffered. In most cases, you should wrap your writer in a `BufWriter`/// for best performance.to_image_errbuffer_BASE_PATHwrite_rgb_image/// Write an `Rgb32FImage`.write_rgba_image/// Write an `Rgba32FImage`.read_as_rgba_image_from_file/// Read the file from the specified path into an `Rgba32FImage`.read_as_rgb_image_from_file/// Read the file from the specified path into an `Rgb32FImage`.read_as_rgb_imageread_as_rgba_imagecompare_exr_hdrroundtrip_rgbaroundtrip_rgbcompare_rgba_rgbcompare_cropped//! Decoding of OpenEXR (.exr) Images//! OpenEXR is an image format that is widely used, especially in VFX,//! because it supports lossless and lossy compression for float data.//! This decoder only supports RGB and RGBA images.//! If an image does not contain alpha information,//! it is defaulted to `1.0` (no transparency).//! * <https://www.openexr.com/documentation.html> - The OpenEXR reference.//! Current limitations (July 2021)://!     - only pixel type `Rgba32F` and `Rgba16F` are supported//!     - only non-deep rgb/rgba files supported, no conversion from/to YCbCr or similar//!     - only the first non-deep rgb layer is used//!     - only the largest mip map level is used//!     - pixels outside display window are lost//!     - meta data is lost//!     - dwaa/dwab compressed images not supported yet by the exr library//!     - (chroma) subsampling not supported yet by the exr libraryBlendOpDisposeOpBlend// http://www.w3.org/TR/PNG-Structure.html// The first eight bytes of a PNG file always contain the following (decimal) values:PngReader/// Png Reader/// This reader will try to read the png one row at a time,/// however for interlaced png files this is not possible and/// these are therefore read at once./// PNG decoder/// Creates a new decoder that decodes from the stream ```r``` with the given limits.gamma_value/// Returns the gamma value of the image or None if no gamma value is indicated./// If an sRGB chunk is present this method returns a gamma value of 0.45455 and ignores the/// value in the gAMA chunk. This is the recommended behavior according to the PNG standard:/// > When the sRGB chunk is present, [...] decoders that recognize the sRGB chunk but are not/// > capable of colour management are recommended to ignore the gAMA and cHRM chunks, and use/// > the values given above as if they had appeared in gAMA and cHRM chunks.apngApngDecoder/// Turn this into an iterator over the animation frames./// Reading the complete animation requires more memory than reading the data from the IDAT/// frame–multiple frame buffers need to be reserved at the same time. We further do not/// support compositing 16-bit colors. In any case this would be lossy as the interface of/// animation decoders does not support 16-bit colors./// If something is not supported or a limit is violated then the decoding step that requires/// them will fail and an error will be returned instead of the frame. No further frames willis_apng/// Returns if the image contains an animation./// Note that the file itself decides if the default image is considered to be part of the/// animation. When it is not the common interpretation is to use it as a thumbnail./// If a non-animated image is converted into an `ApngDecoder` then its iterator is empty.unsupported_color/// The current output buffer./// The previous output buffer, used for dispose op previous./// The dispose op of the current frame./// The number of image still expected to be able to load.has_thumbnail/// The next (first) image is the thumbnail./// An [`AnimationDecoder`] adapter of [`PngDecoder`]./// See [`PngDecoder::apng`] for more information./// [`AnimationDecoder`]: ../trait.AnimationDecoder.html/// [`PngDecoder`]: struct.PngDecoder.html/// [`PngDecoder::apng`]: struct.PngDecoder.html#method.apngmix_next_frame/// Decode one subframe and overlay it on the canvas.animatable_color_type// TODO: thumbnail(&mut self) -> Option<impl ImageDecoder<'_>>CompressionTypeFilterType/// PNG encoder/// Default compression level/// Fast, minimal compression/// High compression levelHuffman/// Huffman coding compression/// Run-length encoding compression/// Compression level of a PNG encoder. The default setting is `Fast`.NoFilter/// No processing done, best used for low bit depth grayscale or data with a/// low color count/// Filters based on previous pixel in the same scanline/// Filters based on the scanline aboveAvg/// Filters based on the average of left and right neighbor pixelsPaeth/// Algorithm that takes into account the left, upper left, and above pixels/// Uses a heuristic to select one of the preceding filters for each/// scanline rather than one filter for the entire image/// Filter algorithms used to process image data to improve compression./// The default filter is `Adaptive`.BadPngRepresentation/// Create a new encoder that writes its output to `w` with `CompressionType` `compression` and/// `FilterType` `filter`./// It is best to view the options as a _hint_ to the implementation on the smallest or fastest/// option for encoding a particular image. That is, using options that map directly to a PNG/// image parameter will use this parameter where possible. But variants that have no direct/// mapping may be interpreted differently in minor versions. The exact output is expressly/// __not__ part of the SemVer stability guarantee./// Note that it is not optimal to use a single filter type, so an adaptive/// filter type is selected as the default. The filter which best minimizes/// file size may change with the type of compression used."Use `PngEncoder::write_image` instead. Beware that `write_image` has a different endianness convention"/// Encodes the image `data` that has dimensions `width` and `height` and `ColorType` `c`./// Expects data in big endian.encode_inner/// Write a PNG image with the specified width, height, and color type./// native endian. PngEncoder will automatically convert to big endian as required by the/// underlying PNG format.from_pngensure_no_decoder_off_by_oneunderlying_errorencode_bad_color_type//! Decoding and Encoding of PNG Images//! PNG (Portable Network Graphics) is an image format that supports lossless compression.//! * <http://www.w3.org/TR/PNG/> - The PNG Specificationline_capacityhas_newline// see https://github.com/rust-lang/rust/issues/30888AutoBreak// The pnm standard says to insert line breaks after 70 characters. Assumes that no line breaks// are actually written. We have to be careful to fully commit buffers or not commit them at all,// otherwise we might insert a newline in the middle of a token.test_aligned_writestest_greater_writes//! Insert line breaks between written buffers when they would overflow the line length.ArbitraryHeaderArbitraryTuplTypeBitmapHeaderGraymapHeaderPixmapHeaderHeaderRecordPnmHeaderPnmSubtypeSampleEncodingPnmMagicInvalid/// PNM's "P[123456]" signature wrong or missingErrorDataSourceUnparsableValue/// Couldn't parse the specified string as an integer from the specified sourceNonAsciiByteInHeaderNonAsciiLineInPamHeader/// The PAM header contained a non-ASCII byteNonAsciiSample/// A sample string contained a non-ASCII byteNotNewlineAfterP7Magic/// The byte after the P7 magic was not 0x0A NEWLINEUnexpectedPnmHeaderEnd/// The PNM header had too few linesPnmHeaderLineHeaderLineDuplicated/// The specified line was specified twiceHeaderLineUnknown/// The line with the specified ID was not understoodmaxvalHeaderLineMissing/// At least one of the required lines were missing from the header (are `None` here)/// Same names as [`PnmHeaderLine`](enum.PnmHeaderLine.html)InputTooShort/// Not enough data was provided to the Decoder to decode the imageUnexpectedByteInRaster/// Sample raster contained unexpected byteSampleOutOfBounds/// Specified sample was out of bounds (e.g. >1 in B&W)MaxvalZero/// The image's maxval is zeroMaxvalTooBig/// The image's maxval exceeds 0xFFFFtuple_typeInvalidDepthOrMaxval/// The specified tuple type supports restricted depths and maxvals, those restrictions were not metInvalidDepth/// The specified tuple type supports restricted depths, those restrictions were not metTupleTypeUnrecognised/// The tuple type was not recognised by the parser/// Overflowed the specified value when parsing/// All errors that can occur when attempting to parse a PNM/// Note: should `pnm` be extracted into a separate crate,/// this will need to be hidden until that crate hits version `1.0`./// "HEIGHT"/// "WIDTH"/// "DEPTH"Maxval/// "MAXVAL", a.k.a. `maxwhite`/// Single-value lines in a PNM header/// One of the header linesPreamble/// Value in the preamble/// Sample/pixel dataTupleTypePbmBitBWBitGrayU8GrayU16RGBU8RGBU16/// Dynamic representation, represents all decodable (sample, depth) combinations.sample_size/// Representation size in bytesbytelenDecodableImageHeaderPnmDecoder/// PNM decoder/// Create a new decoder that decodes from the stream ```read```/// Extract the reader and header after an image has been read.read_bitmap_headerread_graymap_headerread_pixmap_headerread_arbitrary_headerread_magic_constant/// Reads the two magic constant bytesread_next_string/// Reads a string as well as a single whitespace after it, ignoring commentsread_next_u32HeaderReaderPnmReaderread_ascii/// Get the pnm subtype, depending on the magic constant contained in the headerread_separated_ascii// The image is encoded in rows of bits, high order bits first. Any bits beyond the row bits should// be ignored. Also, contrary to rgb, black pixels are encoded as a 1 while white is 0. This will// need to be reversed for the grayscale output.// Encoded just like a normal U8 but we check the values.pam_blackandwhite/// Tests reading of a valid blackandwhite pampam_grayscale/// Tests reading of a valid grayscale pampam_rgb/// Tests reading of a valid rgb pampbm_binarypbm_binary_ascii_termination/// A previous infinite loop.pbm_asciipbm_ascii_nospacepgm_binarypgm_asciippm_asciiissue_1508issue_1616_overflowHeaderStrategyChosenPnmEncoder/// Encodes images to any of the `pnm` image formats._image_width_height_colorCheckedImageBuffer/// Encapsulate the checking system in the type system. Non of the fields are actually accessed/// but requiring them forces us to validly construct the struct anyways.UncheckedHeader// Check the header against the buffer. Each struct produces the next after a check.uncheckedCheckedDimensionsCheckedHeaderColorTupleEncodingCheckedHeaderPbmBits/// Create new PnmEncoder from the `writer`./// The encoded images will have some `pnm` format. If more control over the image type is/// required, use either one of `with_subtype` or `with_header`. For more information on the/// behaviour, see `with_dynamic_header`.with_subtype/// Encode a specific pnm subtype image./// The magic number and encoding type will be chosen as provided while the rest of the header/// data will be generated dynamically. Trying to encode incompatible images (e.g. encoding an/// RGB image as Graymap) will result in an error./// This will overwrite the effect of earlier calls to `with_header` and `with_dynamic_header`.with_header/// Enforce the use of a chosen header./// While this option gives the most control over the actual written data, the encoding process/// will error in case the header data and image parameters do not agree. It is the users/// obligation to ensure that the width and height are set accordingly, for example./// Choose this option if you want a lossless decoding/encoding round trip./// This will overwrite the effect of earlier calls to `with_subtype` and `with_dynamic_header`.with_dynamic_header/// Create the header dynamically for each image./// This is the default option upon creation of the encoder. With this, most images should be/// encodable but the specific format chosen is out of the users control. The pnm subtype is/// chosen arbitrarily by the library./// This will overwrite the effect of earlier calls to `with_subtype` and `with_header`./// Encode an image whose samples are represented as `u8`./// Some `pnm` subtypes are incompatible with some color options, a chosen header most/// certainly with any deviation from the original decoded image.write_dynamic_header/// Choose any valid pnm format that the image can be expressed in and write its header./// Returns how the body should be written if successful.write_subtyped_header/// Try to encode the image with the chosen format, give its corresponding pixel encoding type.write_with_header/// Try to encode the image with the chosen header, checking if values are correct.check_header_dimensionscheck_header_color// Check color compatibility with the header. This will only error when we are certain that// the combination is bogus (e.g. combining Pixmap and Palette) but allows uncertain// combinations (basically a ArbitraryTuplType::Custom with any color of fitting depth).check_sample_valueswrite_samples_asciiwrite_pbm_bits/* Default gives 0 for all primitives. TODO: replace this with `Zeroable` once it hits stable */all_smallerencoding_for//! Encoding of PNM Images/// Samples are unsigned binary integers in big endian/// Samples are encoded as decimal ascii strings separated by whitespace/// The kind of encoding used to store sample valuesBitmap/// Magic numbers P1 and P4Graymap/// Magic numbers P2 and P5/// Magic numbers P3 and P6ArbitraryMap/// Magic number P7/// Denotes the category of the magic number/// Stores the complete header data of a file./// Internally, provides mechanisms for lossless reencoding. After reading a file with the decoder/// it is possible to recover the header and construct an encoder. Using the encoder on the just/// loaded image should result in a byte copy of the original file (for single image pnms without/// additional trailing data)./// Binary or Ascii encoded file/// Height of the image file/// Width of the image file/// Header produced by a `pbm` file ("Portable Bit Map")maxwhite/// Maximum sample value within the image/// Header produced by a `pgm` file ("Portable Gray Map")/// Header produced by a `ppm` file ("Portable Pixel Map")/// Number of color channelstupltype/// Color interpretation of image pixels/// Header produced by a `pam` file ("Portable Arbitrary Map")BlackAndWhite/// Pixels are either black (0) or white (1)BlackAndWhiteAlpha/// Pixels are either black (0) or white (1) and a second alpha channel/// Pixels represent the amount of whiteGrayscaleAlpha/// Grayscale with an additional alpha channel/// Three channels: Red, Green, BlueRGBAlpha/// Four channels: Red, Green, Blue, Alpha/// An image format which is not standardized/// Standardized tuple type specifiers in the header of a `pam`.magic_constant/// Get the two magic constant bytes corresponding to this format subtype.sample_encoding/// Whether samples are stored as binary or as decimal ascii/// Retrieve the format subtype from which the header was created./// The width of the image this header is for./// The height of the image this header is for.maximal_sample/// The biggest value a sample can have. In other words, the colour resolution.as_bitmap/// Retrieve the underlying bitmap header if anyas_graymap/// Retrieve the underlying graymap header if anyas_pixmap/// Retrieve the underlying pixmap header if anyas_arbitrary/// Retrieve the underlying arbitrary header if any/// Write the header back into a binary streamautobreakexecute_roundtrip_defaultexecute_roundtrip_with_subtypeexecute_roundtrip_u16roundtrip_grayroundtrip_u16//! Decoding of netpbm image formats (pbm, pgm, ppm and pam).//! The formats pbm, pgm and ppm are fully supported. The pam decoder recognizes the tuple types//! `BLACKANDWHITE`, `GRAYSCALE` and `RGB` and explicitly recognizes but rejects their `_ALPHA`//! variants for now as alpha color types are unsupported.QoiDecoder/// QOI decoder/// Creates a new decoder that decodes from the stream ```reader```decoding_errorencoding_errorQoiEncoder/// QOI encoder/// Creates a new encoder that writes its output to ```writer```decode_test_image//! Decoding and encoding of QOI imagesALPHA_BIT_MASKSCREEN_ORIGIN_BIT_MASK/// sizes in bytesentry_sizeColorMap/// Get one entry from the color mapcolor_mapline_read// Used in read_scanlineline_remain_buffTgaDecoder/// The representation of a TGA decoderread_color_information/// Loads the color information for the decoder/// To keep things simple, we won't handle bit depths that aren't divisible/// by 8 and are larger than 32.read_image_id/// Read the image id field/// We're not interested in this field, so this function skips it if it/// is presentread_color_mapexpand_color_map/// Expands indices into its mapped colorread_encoded_data/// Reads a run length encoded data for given number of bytesread_all_encoded_data/// Reads a run length encoded packetread_encoded_line/// Reads a run length encoded linereverse_encoding_in_output/// Reverse from BGR encoding to RGB encoding/// TGA files are stored in the BGRA encoding. This function swaps/// the blue and red bytes in the `pixels` array.flip_vertically/// Flip the image vertically depending on the screen origin bit/// The bit in position 5 of the image descriptor byte is the screen origin bit./// If it's 1, the origin is in the top left corner./// If it's 0, the origin is in the bottom left corner./// This function checks the bit, and if it's 0, flips the image vertically.is_flipped_vertically/// Check whether the image is vertically flippedTGAReadertgaEncoderErrorWidthInvalid/// Invalid TGA width.HeightInvalid/// Invalid TGA height./// Errors that can occur during encoding and saving of a TGA image.use_rle/// Run-length encodingTgaEncoder/// TGA encoder.PacketTypedisable_rle/// Disables run-length encodingwrite_raw_packet/// Writes a raw packet to the writerwrite_rle_encoded_packet/// Writes a run-length encoded packet to the writerrun_length_encode/// Writes the run-length encoded buffer to the writer/// Encodes the image ```buf``` that has dimensions ```width```/// and ```height``` and ```ColorType``` ```color_type```./// The dimensions of the image must be between 0 and 65535 (inclusive) or/// an error will be returned./// Panics if `width * height * color_type.bytes_per_pixel() != data.len()`.test_image_width_too_largetest_image_height_too_largetest_compression_diffmixed_packetsround_trip_three_pixel_rgbround_trip_differentround_trip_different_2round_trip_different_3round_trip_bwuncompressedNoImageDataRawColorMap/// Uncompressed images.RawTrueColorRawGrayScaleRunColorMap/// Run length encoded images.RunTrueColorRunGrayScale/// Create a new image type from a u8./// Check if the image format uses colors as opposed to gray scale.is_color_mapped/// Does the image use a color map.is_encoded/// Is the image run length encoded.id_lengthmap_type// length of ID string// color map typemap_origin// image type codemap_length// starting index of mapmap_entry_size// length of mapx_origin// size of map entries in bitsy_origin// x-origin of imageimage_width// y-origin of imageimage_height// width of imagepixel_depth// height of imageimage_desc// bits per pixel// image descriptor/// Header used by TGA image files.from_pixel_info/// Load the header with values from pixel information./// Load the header with values from the reader./// Write out the header values./// A decoder for TGA images/// Currently this decoder does not support 8, 15 and 16 bit color images.//! Decoding of TGA Images//! <http://googlesites.inequation.org/tgautilities>//TODO add 8, 15, 16 bit color support// We only use an Option here so we can call with_limits on the decoder without moving.TiffDecoder/// Decoder for TIFF images./// Create a new TiffDecoder.total_bytes_buffer// The buffer can be larger for CMYK than the RGB outputcheck_sample_formaterr_unknown_color_typefrom_tiff_decodeTiffErrorfrom_tiff_encodeTiffReaderTiffEncoder/// Encoder for tiff imagesu8_slice_as_u16// Utility to simplify and deduplicate error handling during 16-bit encoding./// Create a new encoder that writes its output to `w`/// 16-bit types assume the buffer is native endian.//! Decoding and Encoding of TIFF Images//! TIFF (Tagged Image File Format) is a versatile image format that supports//! lossless and lossy compression.//! * <http://partners.adobe.com/public/developer/tiff/index.html> - The TIFF specificationlosslessLosslessDecoderLosslessFrameVP8FrameVp8Decoderread_extended_headerExtendedImageRiffSignatureInvalid/// RIFF's "RIFF" signature not found or invalidWebpSignatureInvalid/// WebP's "WEBP" signature not found or invalidChunkHeaderInvalid/// Chunk Header was incorrect or invalid in its usage/// All errors that can occur when attempting to parse a WEBP containerWebPRiffChunkRIFFVP8LVP8XANIMANMFALPHICCPEXIFXMP/// All possible RIFF chunks in a WebP image fileto_fourccWebPImageLossyLosslessWebPDecoder/// WebP Image format decoder. Currently only supports lossy RGB images or lossless RGBA images./// Create a new WebPDecoder from the Reader ```r```./// This function takes ownership of the Reader.read_riff_header//reads the 12 bytes of the WebP file header//reads the chunk header, decodes the frame and returns the inner decoderread_datahas_animation/// Returns true if the image as described by the bitstream is animated.set_background_color/// Sets the background color if the image is an extended and animated webp.read_len_cursorread_fourcc/// Reads a chunk header FourCC/// Returns None if and only if we hit end of file reading the four character code of the chunk/// The inner error is `Err` if and only if the chunk header FourCC is present but unknownread_chunk/// Reads a chunk/// Returns an error if the chunk header is not a valid webp header or some other reading errorWebpReaderadd_with_overflow_size/// Uses the simple encoding API from the [libwebp] library./// [libwebp]: https://developers.google.com/speed/webp/docs/api#simple_encoding_apiWebPQualitychunk_bufferWebPEncoder/// WebP Encoder./// WebP encoder quality."Lossy encoding will be removed in a future version. See: https://github.com/image-rs/image/issues/1984"/// Minimum lossy quality value (0)./// Maximum lossy quality value (100)./// Default lossy quality (80), providing a balance of quality and file size./// Lossless encoding.lossy/// Lossy encoding. 0 = low quality, small size; 100 = high quality, large size./// Values are clamped from 0 to 100.new_lossless/// Uses "VP8L" lossless encoding.write_single_entry_huffman_treebuild_huffman_treewrite_huffman_treelength_to_symbolcount_runencode_lossless/// The encoder requires image data be Rgb8 or Rgba8./// Panics if `width * height * color.bytes_per_pixel() != data.len()`.write_webp//! Encoding of WebP images.InfoBitsInvalid// Some bits were invalidAlphaChunkSizeMismatch// Alpha chunk doesn't match the frame's size// Image is too large, either for the platform's pointer size or generallyFrameOutsideImage// Frame would go out of the canvas//all errors that can occur while parsing extended chunks in a WebP file_icc_profile_alpha_exif_metadata_xmp_metadata_animationcanvas_widthcanvas_heightWebPExtendedInfoExtendedImageDatafirst_frameAnimatedFrameanim_infoWebPAnimatedInfoWebPStaticread_extended_chunksread_anim_infodraw_subimagedo_alpha_blendingget_buf_sizeLossyWithAlphaLossyWithoutAlphafrom_alpha_lossyAlphaChunkget_predictorFilteringMethodfrom_lossy_loop_countoffset_xoffset_yuse_alpha_blendingread_extended_chunk/// Reads a chunk, but silently ignores unknown chunks at the end of a fileread_anim_frameread_3_bytesread_lossy_with_chunkread_lossy_preprocessingfiltering_methodread_alpha_chunkBitReaderMAX_ALLOWED_CODE_LENGTH/// Rudimentary utility for reading Canonical Huffman Codes./// Based off https://github.com/webmproject/libwebp/blob/7f8472a610b61ec780ef0a8873cd954ac512a505/src/utils/huffman.cHuffmanTreeNodeLeaf//offset in vector to children//symbol stored in leafmax_nodesnum_nodes/// Huffman treeassign_children/// Turns a node from empty into a branch and assigns its children/// Init a huffman treecode_lengths_to_codes/// Converts code lengths to codesadd_symbol/// Adds a symbol to a huffman treebuild_implicit/// Builds a tree implicitly, just from code lengthsbuild_explicit/// Builds a tree explicitly from lengths, codes and symbolsread_symbol/// Reads a symbol using the bitstream//unsigned to signed//signed to unsignedcommon_adjust//15.2simple_thresholdshould_filterhigh_edge_variancesimple_segment//simple filter//effects 4 pixels on an edge(2 each side)subblock_filter//normal filter//works on the 8 pixels on the edges between subblocks inside a macroblockmacroblock_filter//works on the 8 pixels on the edges between macroblocks//! Does loop filtering on webp lossy imageslossless_transformadd_pixelsTransformTypeCODE_LENGTH_CODE_ORDERDISTANCE_MAPDISTHUFFMAN_CODES_PER_META_CODEHuffmanCodeGroupsubsample_sizeLosslessSignatureInvalid/// Signature of 0x2f not foundVersionNumberInvalid/// Version Number must be 0InvalidColorCacheBitsHuffmanErrorBitStreamErrorTransformErrorNUM_TRANSFORM_TYPEStransformstransform_order//Decodes lossless WebP images/// Create a new decoderdecode_frame/// Reads the framedecode_frame_implicit_dims//used for alpha data in extended decodingdecode_image_stream/// Reads Image data from the bitstream/// Can be in any of the 5 roles described in the Specification/// ARGB Image role has different behaviour to the other 4/// xsize and ysize describe the size of the blocks where each block has its own entropy coderead_transforms/// Reads transforms and their data from the bitstreamadjust_color_map/// Adjusts the color map since it's subtraction codedread_huffman_codesColorCacheHuffmanInfo/// Reads huffman codes associated with an imageread_huffman_code/// Decodes and returns a single huffman treeread_huffman_code_lengths/// Reads huffman code lengthsdecode_image_data/// Decodes the image data using the huffman trees and either of the 3 methods of decodingread_color_cache/// Reads color cache data from the bitstreamget_copy_distance/// Gets the copy distance from the prefix code and bitstreamplane_code_to_distance/// Gets distance to pixelxsize_ysizecolor_cachehuffman_code_groupsget_huff_indexcolor_cache_bitsfill_rgba/// Fills a buffer by converting from argb to rgba/// Get buffer size from the imagefill_green/// Fills a buffer with just the green values from the lossless decoding/// Used in extended alpha decodingbit_read_testbit_read_error_test//! Decoding of lossless WebP images//! [Lossless spec](https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification)size_bitspredictor_dataPredictorTransformtransform_dataColorTransformSubtractGreentable_sizetable_dataColorIndexingTransformapply_transform/// Applies a transform to the image data/// Adds 2 pixels mod 256 for each pixelget_left/// Get left pixelget_top/// Get top pixelget_top_right/// Get pixel to top rightget_top_left/// Get pixel to top leftaverage2/// Get average of 2 pixelssub_average2/// Get average of 2 bytes/// Get a specific byte from argb pixelget_byte_i32/// Get byte as i32 for convenience/// Select left or top byte/// Clamp a to [0, 255]clamp_add_subtract_full_sub/// Clamp add subtract full on one partclamp_add_subtract_half_sub/// Clamp add subtract half on one partclamp_add_subtract_full/// Clamp add subtract full on 3 pixelsclamp_add_subtract_half/// Clamp add subtract half on 2 pixelsgreen_to_redgreen_to_bluered_to_blueColorTransformElementfrom_color_codecolor_transform/// Does color transform on red and blue transformed by greencolor_transform_delta/// Does color transform on 2 numberstransform_color// Does color transform on a pixel with a color transform elementadd_green/// Adds green to red and blue of a pixel//predictor functions//color transform//subtract green functionloop_filter//! Decoding and Encoding of WebP ImagesCONST1CONST2idct4x4iwht4x4// 14.3MAX_SEGMENTSNUM_DCT_TOKENSDC_PRED// Prediction modesV_PREDH_PREDTM_PREDB_PREDB_DC_PREDB_TM_PREDB_VE_PREDB_HE_PREDB_LD_PREDB_RD_PREDB_VR_PREDB_VL_PREDB_HD_PREDB_HU_PREDLumaMode/// Predict DC using row above and column to the left./// Predict rows using row above./// Predict columns using column to the left.TM/// Propagate second differences./// Each Y subblock is independently predicted.// Prediction mode enumChromaModeIntraModeVEHELDRDVRVLHDHUSEGMENT_ID_TREEKEYFRAME_YMODE_TREE// Section 11.2// Tree for determining the keyframe luma intra prediction modes:KEYFRAME_YMODE_PROBS// Default probabilities for decoding the keyframe luma modesKEYFRAME_BPRED_MODE_TREE// Tree for determining the keyframe B_PRED mode:KEYFRAME_BPRED_MODE_PROBS// Probabilities for the BPRED_MODE_TREEKEYFRAME_UV_MODE_TREE// Section 11.4 Tree for determining macroblock the chroma modeKEYFRAME_UV_MODE_PROBS// Probabilities for determining macroblock modeTokenProbTables// Section 13.4COEFF_UPDATE_PROBS// Probabilities that a token's probability will be updatedCOEFF_PROBS// Section 13.5// Default Probabilities for tokensDCT_0// DCT TokensDCT_1DCT_2DCT_3DCT_4DCT_CAT1DCT_CAT2DCT_CAT3DCT_CAT4DCT_CAT5DCT_CAT6DCT_EOBDCT_TOKEN_TREEPROB_DCT_CATDCT_CAT_BASECOEFF_BANDSDC_QUANTAC_QUANTZIGZAGVp8MagicInvalid/// VP8's `[0x9D, 0x01, 0x2A]` magic not found or invalidNotEnoughInitData/// Decoder initialisation wasn't provided with enough dataColorSpaceInvalid/// At time of writing, only the YUV colour-space encoded as `0` is specifiedLumaPredictionModeInvalid/// LUMA prediction mode was not recognisedIntraPredictionModeInvalid/// Intra-prediction mode was not recognisedChromaPredictionModeInvalid/// Chroma prediction mode was not recognised/// All errors that can occur when attempting to parse a VP8 codec inside WebPBoolReaderread_boolread_literalread_magnitude_and_signread_with_treeread_flagbpredcomplexityluma_modechroma_modesegmentidcoeffs_skippedMacroBlock/// The width of the luma plane/// The height of the luma planeybuf/// The luma plane of the frameubuf/// The blue plane of the framevbuf/// The red plane of the framekeyframe/// Indicates whether this frame is a keyframe/// Indicates whether this frame is intended for displaypixel_type// Section 9.2/// The pixel type of the frame as defined by Section 9.2/// of the VP8 Specificationfilter_type// Section 9.4 and 15//if true uses simple filter // if false uses normal filtersharpness_level/// A Representation of the last decoded video framechroma_width/// Chroma plane is half the size of the Luma planechroma_heightfill_rgb/// Fills an rgb buffer with the image/// Fills an rgba buffer by skipping the alpha valuesfill_single/// Conversion values from https://docs.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering#converting-8-bit-yuv-to-rgb888/// Gets the buffer sizeydcyacy2dcy2acuvdcuvacdelta_valuesquantizer_levelloopfilter_levelmbwidthmbheightmacroblockssegments_enabledsegments_update_mapref_deltamode_deltapartitionsnum_partitionssegment_tree_probstoken_probsprob_intra// Section 9.10prob_skip_false// Section 9.11top_borderleft_border/// VP8 Decoder/// Only decodes keyframes/// Create a new decoder./// The reader must present a raw vp8 bitstream to the decoderupdate_token_probabilitiesinit_partitionsread_quantization_indicesread_loop_filter_adjustmentsread_segment_updatesread_frame_headerread_macroblock_headerintra_predict_lumaintra_predict_chromaread_coefficientsread_residual_data/// Does loop filtering on the macroblockcalculate_filter_parameters//return values are the filter level, interior limit and hev threshold/// Decodes the current frameinto_intrainit_top_macroblockscreate_border_luma357avg3avg2add_residue// Only 16 elements from rblock are used to add residue, so it is restricted to 16 elements// to enable SIMD and other optimizations.predict_4x4predict_vpredpredict_hpredpredict_dcpredpredict_tmpredpredict_bdcpredtopleft_pixeltop_pixelsleft_pixelsedge_pixelspredict_bvepredpredict_bhepredpredict_bldpredpredict_brdpredpredict_bvrpredpredict_bvlpredpredict_bhdpredpredict_bhupredtest_avg2test_avg2_specifictest_avg3test_edge_pixelstest_top_pixelstest_add_residuetest_predict_bhepredtest_predict_brdpredtest_predict_bldpredtest_predict_bvepred//! An implementation of the VP8 Video Codec//! This module contains a partial implementation of the//! VP8 video format as defined in RFC-6386.//! It decodes Keyframes only.//! VP8 is the underpinning of the WebP image format//! * [rfc-6386](http://tools.ietf.org/html/rfc6386) - The VP8 Data Format and Decoding Guide//! * [VP8.pdf](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37073.pdf) - An overview of//! of the VP8 formatEnlargeable/// Pixel is 8-bit luminanceLa8/// Pixel is 8-bit luminance with an alpha channel/// Pixel contains 8-bit R, G and B channels/// Pixel is 8-bit RGB with an alpha channelL16/// Pixel is 16-bit luminanceLa16/// Pixel is 16-bit luminance with an alpha channel/// Pixel is 16-bit RGBRgba16/// Pixel is 16-bit RGBARgb32F/// Pixel is 32-bit float RGBRgba32F/// Pixel is 32-bit float RGBA/// An enumeration over supported color types and bit depths/// Returns the number of bytes contained in a pixel of `ColorType` ```c```/// Returns if there is an alpha channel.has_color/// Returns false if the color scheme is grayscale, true otherwise./// Returns the number of bits contained in a pixel of `ColorType` ```c``` (which will always be/// a multiple of 8).channel_count/// Returns the number of color channels that make up this pixel/// Pixel is 8-bit alpha/// Pixel is 1-bit luminanceLa1/// Pixel is 1-bit luminance with an alpha channelRgb1/// Pixel contains 1-bit R, G and B channelsRgba1/// Pixel is 1-bit RGB with an alpha channel/// Pixel is 2-bit luminanceLa2/// Pixel is 2-bit luminance with an alpha channelRgb2/// Pixel contains 2-bit R, G and B channelsRgba2/// Pixel is 2-bit RGB with an alpha channel/// Pixel is 4-bit luminanceLa4/// Pixel is 4-bit luminance with an alpha channelRgb4/// Pixel contains 4-bit R, G and B channelsRgba4/// Pixel is 4-bit RGB with an alpha channel/// Pixel contains 16-bit R, G and B channels/// Pixel is 16-bit RGB with an alpha channelBgr8/// Pixel contains 8-bit B, G and R channelsBgra8/// Pixel is 8-bit BGR with an alpha channel// TODO f16 types?Cmyk8/// Pixel is 8-bit CMYK/// Pixel is of unknown color type with the specified bits per pixel. This can apply to pixels/// which are associated with an external palette. In that case, the pixel value is an index/// into the palette./// An enumeration of color types encountered in image formats./// This is not exhaustive over all existing image formats but should be granular enough to allow/// round tripping of decoding and encoding as much as possible. The variants will be extended as/// necessary to enable this./// Another purpose is to advise users of a rough estimate of the accuracy and effort of the/// decoding from and encoding to such an image format./// Get the number of channels for colors of this type./// Note that the `Unknown` variant returns a value of `1` since pixels can only be treated as/// an opaque datum by the library.define_colorsr" RGB colors."r" For the purpose of color conversion, as well as blending, the implementation of `Pixel`"r" assumes an `sRGB` color space of its data."CHANNEL_COUNTCOLOR_MODELchannels4to_rgbto_rgbato_lumato_luma_alphamap_with_alphaapply_with_alphamap2apply2r" Grayscale colors."r" RGB colors + alpha channel"r" Grayscale colors + alpha channel"from_primitive/// Converts from any pixel component type to this type./// Convert from one pixel component type to another. For example, convert from `u8` to `f32` pixel values.from_color/// Changes `self` to represent `Other` in the color space of `Self`/// Provides color conversions for the different pixel types.into_color/// Constructs a pixel of the target type and converts this pixel into it.IntoColor/// Copy-based conversions to target pixel types using `FromColor`.// FIXME: this trait should be removed and replaced with real color space models// rather than assuming sRGB.SRGB_LUMA/// Coefficients to transform from sRGB to a CIE Y (luminance) value.SRGB_LUMA_DIVrgb_to_luma// `FromColor` for Luma/// Blends a color in-place./// Blends a color inter another one/// Inverts a color in-place./// Invert a colortest_apply_with_alpha_rgbatest_apply_with_alpha_rgbtest_map_with_alpha_rgbatest_map_with_alpha_rgbtest_blend_luma_alphatest_blend_rgbatest_apply_without_alpha_rgbatest_apply_without_alpha_rgbtest_map_without_alpha_rgbatest_map_without_alpha_rgbtest_lossless_conversiontest_lossless_conversionsaccuracy_conversion// from f32:// Note that in to-integer-conversion we are performing rounding but NumCast::from is implemented// as truncate towards zero. We emulate rounding by adding a bias.// from u16:// from u8:// `FromColor` for LumaA// `FromColor` for RGBA// `FromColor` for RGBpnmimageopsresize_dimensionsImageLuma8/// Each pixel in this image is 8-bit LumaImageLumaA8/// Each pixel in this image is 8-bit Luma with alphaImageRgb8/// Each pixel in this image is 8-bit RgbImageRgba8/// Each pixel in this image is 8-bit Rgb with alphaImageLuma16/// Each pixel in this image is 16-bit LumaImageLumaA16/// Each pixel in this image is 16-bit Luma with alphaImageRgb16/// Each pixel in this image is 16-bit RgbImageRgba16/// Each pixel in this image is 16-bit Rgb with alphaImageRgb32F/// Each pixel in this image is 32-bit float RgbImageRgba32F/// Each pixel in this image is 32-bit float Rgb with alpha/// A Dynamic Image/// This represents a _matrix_ of _pixels_ which are _convertible_ from and to an _RGBA_/// representation. More variants that adhere to these principles may get added in the future, in/// particular to cover other combinations typically used./// This type can act as a converter between specific `ImageBuffer` instances./// use image::{DynamicImage, GrayImage, RgbImage};/// let rgb: RgbImage = RgbImage::new(10, 10);/// let luma: GrayImage = DynamicImage::ImageRgb8(rgb).into_luma8();/// # Design/// There is no goal to provide an all-encompassing type with all possible memory layouts. This/// would hardly be feasible as a simple enum, due to the sheer number of combinations of channel/// kinds, channel order, and bit depth. Rather, this type provides an opinionated selection with/// normalized channel order which can store common pixel values without loss.dynamic_map/// Creates a dynamic image backed by a buffer depending on/// the color type given.new_luma8/// Creates a dynamic image backed by a buffer of gray pixels.new_luma_a8/// Creates a dynamic image backed by a buffer of gray/// pixels with transparency.new_rgb8/// Creates a dynamic image backed by a buffer of RGB pixels.new_rgba8/// Creates a dynamic image backed by a buffer of RGBA pixels.new_luma16new_luma_a16new_rgb16new_rgba16new_rgb32fnew_rgba32ffrom_decoder/// Decodes an encoded image into a dynamic image.to_rgb8/// Returns a copy of this image as an RGB image.to_rgb16to_rgb32fto_rgba8/// Returns a copy of this image as an RGBA image.to_rgba16to_rgba32fto_luma8/// Returns a copy of this image as a Luma image.to_luma16to_luma32fto_luma_alpha8/// Returns a copy of this image as a LumaA image.to_luma_alpha16to_luma_alpha32finto_rgb8/// Consume the image and returns a RGB image./// If the image was already the correct format, it is returned as is./// Otherwise, a copy is created.into_rgb16into_rgb32finto_rgba8/// Consume the image and returns a RGBA image.into_rgba16into_rgba32finto_luma8/// Consume the image and returns a Luma image.into_luma16into_luma_alpha8/// Consume the image and returns a LumaA image.into_luma_alpha16/// Return a cut-out of this image delimited by the bounding rectangle./// Note: this method does *not* modify the object,/// and its signature will be replaced with `crop_imm()`'s in the 0.24 releasecrop_immas_rgb8/// Return a reference to an 8bit RGB imageas_mut_rgb8/// Return a mutable reference to an 8bit RGB imageas_rgba8/// Return a reference to an 8bit RGBA imageas_mut_rgba8/// Return a mutable reference to an 8bit RGBA imageas_luma8/// Return a reference to an 8bit Grayscale imageas_mut_luma8/// Return a mutable reference to an 8bit Grayscale imageas_luma_alpha8/// Return a reference to an 8bit Grayscale image with an alpha channelas_mut_luma_alpha8/// Return a mutable reference to an 8bit Grayscale image with an alpha channelas_rgb16/// Return a reference to an 16bit RGB imageas_mut_rgb16/// Return a mutable reference to an 16bit RGB imageas_rgba16/// Return a reference to an 16bit RGBA imageas_mut_rgba16/// Return a mutable reference to an 16bit RGBA imageas_rgb32f/// Return a reference to an 32bit RGB imageas_mut_rgb32f/// Return a mutable reference to an 32bit RGB imageas_rgba32f/// Return a reference to an 32bit RGBA imageas_mut_rgba32fas_luma16/// Return a reference to an 16bit Grayscale imageas_mut_luma16/// Return a mutable reference to an 16bit Grayscale imageas_luma_alpha16/// Return a reference to an 16bit Grayscale image with an alpha channelas_mut_luma_alpha16/// Return a mutable reference to an 16bit Grayscale image with an alpha channelas_flat_samples_u8/// Return a view on the raw sample buffer for 8 bit per channel images.as_flat_samples_u16/// Return a view on the raw sample buffer for 16 bit per channel images.as_flat_samples_f32/// Return a view on the raw sample buffer for 32bit per channel images./// Return this image's pixels as a native endian byte slice.inner_bytes// TODO: choose a name under which to expose?/// Return this image's pixels as a byte vector. If the `ImageBuffer`/// container is `Vec<u8>`, this operation is free. Otherwise, a copy/// Return a copy of this image's pixels as a byte vector./// Deprecated, because it does nothing but hide an expensive clone operation./// Return this image's color type./// Returns the width of the underlying image/// Returns the height of the underlying imagegrayscale/// Return a grayscale version of this image./// Returns `Luma` images in most cases. However, for `f32` images,/// this will return a grayscale `Rgb/Rgba` image instead./// Invert the colors of this image./// This method operates inplace./// Resize this image using the specified filter algorithm./// Returns a new image. The image's aspect ratio is preserved./// The image is scaled to the maximum possible size that fits/// within the bounds specified by `nwidth` and `nheight`.resize_exact/// Returns a new image. Does not preserve aspect ratio./// `nwidth` and `nheight` are the new image's dimensionsthumbnail/// Scale this image down to fit within a specific size./// This method uses a fast integer algorithm where each source/// pixel contributes to exactly one target pixel./// May give aliasing artifacts if new size is close to old size.thumbnail_exact/// Scale this image down to a specific size./// `nwidth` and `nheight` are the new image's dimensions.resize_to_fill/// within the larger (relative to aspect ratio) of the bounds/// specified by `nwidth` and `nheight`, then cropped to/// fit within the other bound.blur/// Performs a Gaussian blur on this image./// `sigma` is a measure of how much to blur by.unsharpen/// Performs an unsharpen mask on this image./// `sigma` is the amount to blur the image by./// `threshold` is a control of how much to sharpen./// See <https://en.wikipedia.org/wiki/Unsharp_masking#Digital_unsharp_masking>filter3x3/// Filters this image with the specified 3x3 kernel.adjust_contrast/// Adjust the contrast of this image./// `contrast` is the amount to adjust the contrast by./// Negative values decrease the contrast and positive values increase the contrast.brighten/// Brighten the pixels of this image./// `value` is the amount to brighten each pixel by./// Negative values decrease the brightness and positive values increase it.huerotate/// Hue rotate the supplied image./// `value` is the degrees to rotate each pixel by./// 0 and 360 do nothing, the rest rotates by the given degree value./// just like the css webkit filter hue-rotate(180)flipv/// Flip this image verticallyfliph/// Flip this image horizontallyrotate90/// Rotate this image 90 degrees clockwise.rotate180/// Rotate this image 180 degrees clockwise.rotate270/// Rotate this image 270 degrees clockwise./// Encode this image and write it to ```w```./// Encode this image with the provided encoder.// TODO use f32 as default for best precision and unbounded color?/// Do not use is function: It is unimplemented!decoder_to_image/// Decodes an image and stores it into a dynamic image/// Open the image located at the path specified./// The image's format is determined from the path's file extension./// Try [`io::Reader`] for more advanced uses, including guessing the format based on the file's/// content before its path./// [`io::Reader`]: io/struct.Reader.htmlimage_dimensions/// Read a tuple containing the (width, height) of the image located at the specified path./// This is faster than fully loading the image and then getting its dimensions./// content before its path or manually supplying the format./// Saves the supplied buffer to a file at the path specified./// The image format is derived from the file extension. The buffer is assumed to have/// the correct format according to the specified color type./// This will lead to corrupted files if the buffer contains malformed data. Currently only/// jpeg, png, ico, pnm, bmp, exr and tiff files are supported./// Saves the supplied buffer to a file at the path specified/// in the specified format./// The buffer is assumed to have the correct format according/// to the specified color type./// This will lead to corrupted files if the buffer contains/// malformed data. Currently only jpeg, png, ico, bmp, exr and/// tiff files are supported./// Writes the supplied buffer to a writer in the specified format./// This will lead to corrupted writers if the buffer contains/// malformed data.load_from_memory/// Create a new image from a byte slice/// Makes an educated guess about the image format./// TGA is not supported by this function./// Try [`io::Reader`] for more advanced uses.load_from_memory_with_format/// This is just a simple wrapper that constructs an `std::io::Cursor` around the buffer and then/// calls `load` with that reader.test_empty_fileopen_16bpc_pngtest_grayscaletest_grayscale_alpha_discardedtest_grayscale_alpha_preservedtest_grayscale_luma8test_grayscale_luma_a8test_grayscale_rgb8test_grayscale_rgba8test_grayscale_luma16test_grayscale_luma_a16test_grayscale_rgb16test_grayscale_rgba16test_grayscale_rgb32ftest_grayscale_rgba32ftest_dynamic_image_default_implementationtest_to_vecu8issue_1705_can_turn_16bit_image_into_bytes/// An error was encountered while decoding./// This means that the input data did not conform to the specification of some image format,/// or that no format could be determined, or that it did not match format specific/// requirements set by the caller./// An error was encountered while encoding./// The input image can not be encoded with the chosen format, for example because the/// specification has no representation for its color space or because a necessary conversion/// is ambiguous. In some cases it might also happen that the dimensions can not be used with/// the format.Parameter/// An error was encountered in input arguments./// This is a catch-all case for strictly internal operations such as scaling, conversions,/// etc. that involve no external format specifications./// Completing the operation would have required more resources than allowed./// Errors of this type are limits set by the user or environment, *not* inherent in a specific/// format or operation that was executed./// An operation can not be completed by the chosen abstraction./// This means that it might be possible for the operation to succeed in general but/// * it requires a disabled feature,/// * the implementation does not yet exist, or/// * no abstraction for a lower level could be found./// An error occurred while interacting with the environment./// The generic error type for image operations./// This high level enum allows, by variant matching, a rough separation of concerns between/// underlying IO, the caller, format specifications, and the `image` implementation./// The implementation for an operation was not provided./// See the variant [`Unsupported`] for more documentation./// [`Unsupported`]: enum.ImageError.html#variant.Unsupported/// The required color type can not be handled./// An image format is not supported.GenericFeature/// Some feature specified by string./// This is discouraged and is likely to get deprecated (but not removed)./// Details what feature is not supported./// An error was encountered while encoding an image./// This is used as an opaque representation for the [`ImageError::Encoding`] variant. See its/// documentation for more information./// [`ImageError::Encoding`]: enum.ImageError.html#variant.Encoding/// An error was encountered in inputs arguments./// This is used as an opaque representation for the [`ImageError::Parameter`] variant. See its/// [`ImageError::Parameter`]: enum.ImageError.html#variant.Parameter/// The dimensions passed are wrong.FailedAlready/// Repeated an operation for which error that could not be cloned was emitted already./// A string describing the parameter.NoMoreData/// The end of the image has been reached./// Details how a parameter is malformed./// An error was encountered while decoding an image./// This is used as an opaque representation for the [`ImageError::Decoding`] variant. See its/// [`ImageError::Decoding`]: enum.ImageError.html#variant.Decoding// do we need an underlying error?/// This is used as an opaque representation for the [`ImageError::Limits`] variant. See its/// [`ImageError::Limits`]: enum.ImageError.html#variant.LimitsDimensionError/// The resulting image exceed dimension limits in either direction./// The operation would have performed an allocation larger than allowed./// The given limitsLimitSupport/// The supported strict limits/// The specified strict limits are not supported for this operation/// Indicates the limit that prevented an operation from completing./// Note that this enumeration is not exhaustive and may in the future be extended to provide more/// detailed information or to incorporate other resources types.// Might be non-Copy in the future./// The format is known exactly./// The format can be identified by a name.PathExtension/// A common path extension for the format is known./// The format is not known or could not be determined./// A best effort representation for image formats.from_format_and_kind/// Create an `UnsupportedError` for an image with details on the unsupported feature./// If the operation was not connected to a particular image format then the hint may be/// `Unknown`./// Returns the corresponding `UnsupportedErrorKind` of the error.format_hint/// Returns the image format associated with this error./// Create a `DecodingError` that stems from an arbitrary error of an underlying decoder.from_format_hint/// Create a `DecodingError` for an image format./// The error will not contain any further information but is very easy to create./// Create an `EncodingError` that stems from an arbitrary error of an underlying encoder./// Create an `EncodingError` for an image format./// Return the image format associated with this error.from_kind/// Construct a `ParameterError` directly from a corresponding kind./// Returns the corresponding `ParameterErrorKind` of the error./// Construct a generic `LimitError` directly from a corresponding kind./// Returns the corresponding `LimitErrorKind` of the error./// Result of an image decoding/encoding processASSERT_SMALLISH// This will fail to compile if the size of this type is large.test_send_sync_stability//! Contains detailed error representation.//! See the main [`ImageError`] which contains a variant for each specialized error type. The//! subtypes used in each variant are opaque by design. They can be roughly inspected through their//! respective `kind` methods which work similar to `std::io::Error::kind`.//! The error interface makes it possible to inspect the error of an underlying decoder or encoder,//! through the `Error::source` method. Note that this is not part of the stable interface and you//! may not rely on a particular error value for a particular operation. This means mainly that//! `image` does not promise to remain on a particular version of its underlying decoders but if//! you ensure to use the same version of the dependency (or at least of the error type) through//! external means then you could inspect the error type in slightly more detail.//! [`ImageError`]: enum.ImageError.html/// Underlying linear container holding sample values./// A `repr(C)` description of the layout of buffer samples.color_hint/// Supplementary color information./// You may keep this as `None` in most cases. This is NOT checked in `View` or other/// converters. It is intended mainly as a way for types that convert to this buffer type to/// attach their otherwise static color information. A dynamic image representation could/// however use this to resolve representational ambiguities such as the order of RGB channels./// A flat buffer over a (multi channel) image./// In contrast to `ImageBuffer`, this representation of a sample collection is much more lenient/// in the layout thereof. It also allows grouping by color planes instead of by pixel as long as/// the strides of each extent are constant. This struct itself has no invariants on the strides/// but not every possible configuration can be interpreted as a [`GenericImageView`] or/// [`GenericImage`]. The methods [`as_view`] and [`as_view_mut`] construct the actual implementors/// of these traits and perform necessary checks. To manually perform this and other layout checks/// use [`is_normal`] or [`has_aliased_samples`]./// Instances can be constructed not only by hand. The buffer instances returned by library/// functions such as [`ImageBuffer::as_flat_samples`] guarantee that the conversion to a generic/// image or generic view succeeds. A very different constructor is [`with_monocolor`]. It uses a/// single pixel as the backing storage for an arbitrarily sized read-only raster by mapping each/// pixel to the same samples by setting some strides to `0`./// [`GenericImage`]: ../trait.GenericImage.html/// [`GenericImageView`]: ../trait.GenericImageView.html/// [`ImageBuffer::as_flat_samples`]: ../struct.ImageBuffer.html#method.as_flat_samples/// [`is_normal`]: #method.is_normal/// [`has_aliased_samples`]: #method.has_aliased_samples/// [`as_view`]: #method.as_view/// [`as_view_mut`]: #method.as_view_mut/// [`with_monocolor`]: #method.with_monocolor/// The number of channels in the color representation of the image.channel_stride/// Add this to an index to get to the sample in the next channel./// The width of the represented image.width_stride/// Add this to an index to get to the next sample in x-direction./// The height of the represented image.height_stride/// Add this to an index to get to the next sample in y-direction./// A ffi compatible description of a sample buffer./// Helper struct for an unnamed (stride, length) pair.row_major_packed/// Describe a row-major image packed in all directions./// The resulting will surely be `NormalForm::RowMajorPacked`. It can therefore be converted to/// safely to an `ImageBuffer` with a large enough underlying buffer./// # use image::flat::{NormalForm, SampleLayout};/// let layout = SampleLayout::row_major_packed(3, 640, 480);/// assert!(layout.is_normal(NormalForm::RowMajorPacked));/// On platforms where `usize` has the same size as `u32` this panics when the resulting stride/// in the `height` direction would be larger than `usize::max_value()`. On other platforms/// where it can surely accommodate `u8::max_value() * u32::max_value(), this can never happen.column_major_packed/// Describe a column-major image packed in all directions./// The resulting will surely be `NormalForm::ColumnMajorPacked`. This is not particularly/// useful for conversion but can be used to describe such a buffer without pitfalls./// let layout = SampleLayout::column_major_packed(3, 640, 480);/// assert!(layout.is_normal(NormalForm::ColumnMajorPacked));/// in the `width` direction would be larger than `usize::max_value()`. On other platformsstrides_cwh/// Get the strides for indexing matrix-like `[(c, w, h)]`./// For a row-major layout with grouped samples, this tuple is strictly/// increasing./// Get the dimensions `(channels, width, height)`./// The interface is optimized for use with `strides_cwh` instead. The channel extent will be/// before width and height./// Tuple of bounds in the order of coordinate inputs./// This function should be used whenever working with image coordinates opposed to buffer/// coordinates. The only difference compared to `extents` is the output type.min_length/// Get the minimum length of a buffer such that all in-bounds samples have valid indices./// This method will allow zero strides, allowing compact representations of monochrome images./// To check that no aliasing occurs, try `check_alias_invariants`. For compact images (no/// aliasing and no unindexed samples) this is `width*height*channels`. But for both of the/// other cases, the reasoning is slightly more involved./// # Explanation/// Note that there is a difference between `min_length` and the index of the sample/// 'one-past-the-end`. This is due to strides that may be larger than the dimension below./// ## Example with holes/// Let's look at an example of a grayscale image with/// * `width_stride = 1`/// * `width = 2`/// * `height_stride = 3`/// * `height = 2`/// | x x   | x x m | $///  min_length m ^///                   ^ one-past-the-end $/// The difference is also extreme for empty images with large strides. The one-past-the-end/// sample index is still as large as the largest of these strides while `min_length = 0`./// ## Example with aliasing/// The concept gets even more important when you allow samples to alias each other. Here we/// have the buffer of a small grayscale image where this is the case, this time we will first/// show the buffer and then the individual rows below./// * `width = 3`/// * `height_stride = 2`///  1 2 3 4 5 m/// |1 2 3| row one///     |3 4 5| row two///            ^ m min_length///          ^ ??? one-past-the-end/// This time 'one-past-the-end' is not even simply the largest stride times the extent of its/// dimension. That still points inside the image because `height*height_stride = 4` but also/// `index_of(1, 2) = 4`.fits/// Check if a buffer of length `len` is large enough.increasing_stride_dims/// The extents of this array, in order of increasing strides.has_aliased_samples/// If there are any samples aliasing each other./// If this is not the case, it would always be safe to allow mutable access to two different/// samples at the same time. Otherwise, this operation would need additional checks. When one/// dimension overflows `usize` with its stride we also consider this aliasing.NormalForm/// Check if a buffer fulfills the requirements of a normal form./// Certain conversions have preconditions on the structure of the sample buffer that are not/// captured (by design) by the type system. These are then checked before the conversion. Such/// checks can all be done in constant time and will not inspect the buffer content. You can/// perform these checks yourself when the conversion is not required at this moment but maybe/// still performed later.in_bounds/// Check that the pixel and the channel index are in bounds./// An in-bound coordinate does not yet guarantee that the corresponding calculation of a/// buffer index does not overflow. However, if such a buffer large enough to hold all samples/// actually exists in memory, this property of course follows./// Resolve the index of a particular sample./// `None` if the index is outside the bounds or does not fit into a `usize`.index_ignoring_bounds/// Get the theoretical position of sample (channel, x, y)./// The 'check' is for overflow during index calculation, not that it is contained in the/// image. Two samples may return the same index, even when one of them is out of bounds. This/// happens when all strides are `0`, i.e. the image is an arbitrarily large monochrome image.in_bounds_index/// Get an index provided it is inbouds./// Assumes that the image is backed by some sufficiently large buffer. Then computation can/// not overflow as we could represent the maximum coordinate. Since overflow is defined either/// way, this method can not be unsafe./// Behavior is *unspecified* if the index is out of bounds or this sample layout would require/// a buffer larger than `isize::MAX` bytes./// Shrink the image to the minimum of current and given extents./// This does not modify the strides, so that the resulting sample buffer may have holes/// created by the shrinking operation. Shrinking could also lead to an non-aliasing image when/// samples had aliased each other before.checked_len/// Length of this dimension in memory./// Get a reference based version./// Get a mutable reference based version./// Copy the data into an owned vector.get_sample/// Get a reference to a single sample./// This more restrictive than the method based on `std::ops::Index` but guarantees to properly/// check all bounds and not panic as long as `Buffer::as_ref` does not do so./// # use image::{RgbImage};/// let flat = RgbImage::new(480, 640).into_flat_samples();/// // Get the blue channel at (10, 10)./// assert!(flat.get_sample(1, 10, 10).is_some());/// // There is no alpha channel./// assert!(flat.get_sample(3, 10, 10).is_none());/// For cases where a special buffer does not provide `AsRef<[T]>`, consider encapsulating/// bounds checks with `min_length` in a type similar to `View`. Then you may use/// `in_bounds_index` as a small speedup over the index calculation of this method which relies/// on `index_ignoring_bounds` since it can not have a-priori knowledge that the sample/// coordinate is in fact backed by any memory buffer.get_mut_sample/// Get a mutable reference to a single sample./// This more restrictive than the method based on `std::ops::IndexMut` but guarantees to/// properly check all bounds and not panic as long as `Buffer::as_ref` does not do so./// Contrary to conversion to `ViewMut`, this does not require that samples are packed since it/// does not need to convert samples to a color representation./// **WARNING**: Note that of course samples may alias, so that the mutable reference returned/// here can in fact modify more than the coordinate in the argument./// let mut flat = RgbImage::new(480, 640).into_flat_samples();/// // Assign some new color to the blue channel at (10, 10)./// *flat.get_mut_sample(1, 10, 10).unwrap() = 255;/// assert!(flat.get_mut_sample(3, 10, 10).is_none());as_view/// View this buffer as an image over some type of pixel./// This first ensures that all in-bounds coordinates refer to valid indices in the sample/// buffer. It also checks that the specified pixel format expects the same number of channels/// that are present in this buffer. Neither are larger nor a smaller number will be accepted./// There is no automatic conversion.as_view_with_mut_samples/// View this buffer but keep mutability at a sample level./// This is similar to `as_view` but subtly different from `as_view_mut`. The resulting type/// can be used as a `GenericImage` with the same prior invariants needed as for `as_view`./// It can not be used as a mutable `GenericImage` but does not need channels to be packed in/// their pixel representation./// for one sample can in fact modify other samples as well. Sometimes exactly this is/// intended.as_view_mutViewMut/// Interpret this buffer as a mutable image./// To succeed, the pixels in this buffer may not alias each other and the samples of each/// pixel must be packed (i.e. `channel_stride` is `1`). The number of channels must be/// consistent with the channel count expected by the pixel format./// This is similar to an `ImageBuffer` except it is a temporary view that is not normalized as/// strongly. To get an owning version, consider copying the data into an `ImageBuffer`. This/// provides many more operations, is possibly faster (if not you may want to open an issue) is/// generally polished. You can also try to convert this buffer inline, see/// `ImageBuffer::from_raw`./// View the samples as a slice./// The slice is not limited to the region of the image and not all sample indices are valid/// indices into this buffer. See `image_mut_slice` as an alternative.image_slice/// Return the portion of the buffer that holds sample values./// This may fail when the coordinates in this image are either out-of-bounds of the underlying/// buffer or can not be represented. Note that the slice may have holes that do not correspond/// to any sample in the image represented by it.image_mut_slice/// Mutable portion of the buffer that holds sample values.try_into_buffer/// Move the data into an image buffer./// This does **not** convert the sample layout. The buffer needs to be in packed row-major form/// before calling this function. In case of an error, returns the buffer again so that it does/// not release any allocation./// Get the theoretical position of sample (x, y, channel).with_monocolor/// Create a monocolor image from a single pixel./// This can be used as a very cheap source of a `GenericImageView` with an arbitrary number of/// pixels of a single color, without any dynamic allocation./// # fn paint_something<T>(_: T) {}/// use image::{flat::FlatSamples, GenericImage, RgbImage, Rgb};/// let background = Rgb([20, 20, 20]);/// let bg = FlatSamples::with_monocolor(&background, 200, 200);;/// let mut image = RgbImage::new(200, 200);/// paint_something(&mut image);/// // Reset the canvas/// image.copy_from(&bg.as_view().unwrap(), 0, 0);/// A flat buffer that can be used as an image view./// This is a nearly trivial wrapper around a buffer but at least sanitizes by checking the buffer/// length first and constraining the pixel type./// Note that this does not eliminate panics as the `AsRef<[T]>` implementation of `Buffer` may be/// unreliable, i.e. return different buffers at different times. This of course is a non-issue for/// all common collections where the bounds check once must be enough./// # Inner invariants/// * For all indices inside bounds, the corresponding index is valid in the buffer/// * `P::channel_count()` agrees with `self.inner.layout.channels`/// A mutable owning version of a flat buffer./// While this wraps a buffer similar to `ImageBuffer`, this is mostly intended as a utility. The/// library endorsed normalized representation is still `ImageBuffer`. Also, the implementation of/// `AsMut<[P::Subpixel]>` must always yield the same buffer. Therefore there is no public way to/// construct this with an owning buffer./// * There is no aliasing of samples/// * The samples are packed, i.e. `self.inner.layout.sample_stride == 1`/// The represented image was too large./// The optional value denotes a possibly accepted maximal bound.NormalFormRequired/// The represented image can not use this representation./// Has an additional value of the normalized form that would be accepted.ChannelCountMismatch/// The color format did not match the channel count./// In some cases you might be able to fix this by lowering the reported pixel count of the/// buffer without touching the strides./// In very special circumstances you *may* do the opposite. This is **VERY** dangerous but not/// directly memory unsafe although that will likely alias pixels. One scenario is when you/// want to construct an `Rgba` image but have only 3 bytes per pixel and for some reason don't/// care about the value of the alpha channel even though you need `Rgba`.WrongColor/// Deprecated - ChannelCountMismatch is used instead/// Denotes invalid flat sample buffers when trying to convert to stricter types./// The biggest use case being `ImageBuffer` which expects closely packed/// samples in a row major matrix representation. But this error type may be/// resused for other import functions. A more versatile user may also try to/// correct the underlying representation depending on the error variant.Unaliased/// No pixel aliases another./// Unaliased also guarantees that all index calculations in the image bounds using/// `dim_index*dim_stride` (such as `x*width_stride + y*height_stride`) do not overflow.PixelPacked/// At least pixels are packed./// Images of these types can wrap `[T]`-slices into the standard color types. This is a/// precondition for `GenericImage` which requires by-reference access to pixels.ImagePacked/// All samples are packed./// This is orthogonal to `PixelPacked`. It requires that there are no holes in the image but/// it is not necessary that the pixel samples themselves are adjacent. An example of this/// behaviour is a planar image layout.RowMajorPacked/// The samples are in row-major form and all samples are packed./// In addition to `PixelPacked` and `ImagePacked` this also asserts that the pixel matrix is/// in row-major form.ColumnMajorPacked/// The samples are in column-major form and all samples are packed./// in column-major form./// Different normal forms of buffers./// A normal form is an unaliased buffer with some additional constraints.  The `ÌmageBuffer` uses/// row major form with packed samples./// Take out the sample buffer./// Gives up the normalization invariants on the buffer format./// Get a reference on the inner sample descriptor./// There is no mutable counterpart as modifying the buffer format, including strides and/// lengths, could invalidate the accessibility invariants of the `View`. It is not specified/// if the inner buffer is the same as the buffer of the image from which this view was/// created. It might have been truncated as an optimization./// Get a reference on the inner buffer./// There is no mutable counter part since it is not intended to allow you to reassign the/// buffer or otherwise change its size or properties./// Get a reference to a selected subpixel if it is in-bounds./// This method will return `None` when the sample is out-of-bounds. All errors that could/// occur due to overflow have been eliminated while construction the `View`./// Get a mutable reference to a selected subpixel if it is in-bounds./// This is relevant only when constructed with `FlatSamples::as_view_with_mut_samples`.  This/// method will return `None` when the sample is out-of-bounds. All errors that could occur due/// to overflow have been eliminated while construction the `View`./// See `FlatSamples::min_length`. This method will always succeed./// While this can not fail–the validity of all coordinates has been validated during the/// conversion from `FlatSamples`–the resulting slice may still contain holes./// Return the mutable portion of the buffer that holds sample values./// This is relevant only when constructed with `FlatSamples::as_view_with_mut_samples`. While/// this can not fail–the validity of all coordinates has been validated during the conversion/// from `FlatSamples`–the resulting slice may still contain holes./// Shrink the inner image./// The new dimensions will be the minimum of the previous dimensions. Since the set of/// in-bounds pixels afterwards is a subset of the current ones, this is allowed on a `View`./// Note that you can not change the number of channels as an intrinsic property of `P`./// Try to convert this into an image with mutable pixels./// The resulting image implements `GenericImage` in addition to `GenericImageView`. While this/// has mutable samples, it does not enforce that pixel can not alias and that samples are/// packed enough for a mutable pixel reference. This is slightly cheaper than the chain/// `self.into_inner().as_view_mut()` and keeps the `View` alive on failure./// # use image::RgbImage;/// # use image::Rgb;/// let mut buffer = RgbImage::new(480, 640).into_flat_samples();/// let view = buffer.as_view_with_mut_samples::<Rgb<u8>>().unwrap();/// // Inspect some pixels, …/// // Doesn't fail because it was originally an `RgbImage`./// let view_mut = view.try_upgrade().unwrap();/// Get a reference on the sample buffer descriptor./// buffer or otherwise change its size or properties. However, its contents can be accessed/// mutable through a slice with `image_mut_slice`./// Get a reference to a selected subpixel./// Get a mutable reference to a selected sample./// Return the mutable buffer that holds sample values.panic_cwh_out_of_bounds// The out-of-bounds panic for single sample access similar to `slice::index`.panic_pixel_out_of_bounds// The out-of-bounds panic for pixel access similar to `slice::index`./// Return a reference to a single sample at specified coordinates./// When the coordinates are out of bounds or the index calculation fails./// Return a mutable reference to a single sample at specified coordinates./// Compares the logical preconditions./// `a < b` if the normal form `a` has less preconditions than `b`.aliasing_viewmutable_viewnormal_formsimage_buffer_conversion//! Image representations for ffi.//! Imagine you want to offer a very simple ffi interface: The caller provides an image buffer and//! your program creates a thumbnail from it and dumps that image as `png`. This module is designed//! to help you transition from raw memory data to Rust representation.//! use std::ptr;//! use std::slice;//! use image::Rgb;//! use image::flat::{FlatSamples, SampleLayout};//! use image::imageops::thumbnail;//! pub extern "C" fn store_rgb8_compressed(//!     data: *const u8, len: usize,//!     layout: *const SampleLayout//! )//!     -> bool//!     let samples = unsafe { slice::from_raw_parts(data, len) };//!     let layout = unsafe { ptr::read(layout) };//!     let buffer = FlatSamples {//!         samples,//!         layout,//!         color_hint: None,//!     let view = match buffer.as_view::<Rgb<u8>>() {//!         Err(_) => return false, // Invalid layout.//!         Ok(view) => view,//!     thumbnail(&view, 64, 64)//!         .save("output.png")//!         .map(|_| true)//!         .unwrap_or_else(|_| false)/// An Image in PNG Format/// An Image in JPEG FormatGif/// An Image in GIF FormatWebP/// An Image in WEBP FormatPnm/// An Image in general PNM FormatTiff/// An Image in TIFF FormatTga/// An Image in TGA FormatDds/// An Image in DDS Format/// An Image in BMP FormatIco/// An Image in ICO FormatHdr/// An Image in Radiance HDR FormatOpenExr/// An Image in OpenEXR FormatFarbfeld/// An Image in farbfeld FormatAvif/// An Image in AVIF format.Qoi/// An Image in QOI format./// An enumeration of supported image formats./// Not all formats support both encoding and decoding.from_extension/// Return the image format specified by a path's file extension./// use image::ImageFormat;/// let format = ImageFormat::from_extension("jpg");/// assert_eq!(format, Some(ImageFormat::Jpeg));/// Return the image format specified by the path's file extension./// let format = ImageFormat::from_path("images/ferris.png")?;/// assert_eq!(format, ImageFormat::Png);/// # Ok::<(), image::error::ImageError>(())from_mime_type/// Return the image format specified by a MIME type./// let format = ImageFormat::from_mime_type("image/png").unwrap();to_mime_type/// Return the MIME type for this image format or "application/octet-stream" if no MIME type/// exists for the format./// Some notes on a few of the MIME types:/// - The portable anymap format has a separate MIME type for the pixmap, graymap and bitmap///   formats, but this method returns the general "image/x-portable-anymap" MIME type./// - The Targa format has two common MIME types, "image/x-targa"  and "image/x-tga"; this///   method returns "image/x-targa" for that format./// - The QOI MIME type is still a work in progress. This method returns "image/x-qoi" for///   that format./// let mime_type = ImageFormat::Png.to_mime_type();/// assert_eq!(mime_type, "image/png");can_read/// Return if the ImageFormat can be decoded by the lib.can_write/// Return if the ImageFormat can be encoded by the lib.extensions_str/// Return a list of applicable extensions for this format./// All currently recognized image formats specify at least on extension but for future/// compatibility you should not rely on this fact. The list may be empty if the format has no/// recognized file representation, for example in case it is used as a purely transient memory/// The method name `extensions` remains reserved for introducing another method in the future/// that yields a slice of `OsStr` which is blocked by several features of const evaluation.reading_enabled/// Return the ImageFormats which are enabled for reading.writing_enabled/// Return the ImageFormats which are enabled for writing./// Return all ImageFormats/// An Image in JPEG Format with specified quality, up to 100/// An Image in one of the PNM Formats/// An image in QOI Format/// An image in WebP Format./// A value for signalling an error: An unsupported format was requested// Note: When TryFrom is stabilized, this value should not be needed, and// a TryInto<ImageOutputFormat> should be used instead of an Into<ImageOutputFormat>./// An enumeration of supported image formats for encoding.consumedtotal_bytes// This struct manages buffering associated with implementing `Read` and `Seek` on decoders that can// must decode ranges of bytes at a time.// When no image formats that use it are enabled/// Create a new ImageReadBuffer./// Panics if scanline_bytes doesn't fit into a usize, because that would mean reading anything/// from the image would take more RAM than the entire virtual address space. In other words,/// actually using this struct would instantly OOM so just get it out of the way now.load_rect/// Decodes a specific region of the image, represented by the rectangle/// starting from ```x``` and ```y``` and having ```length``` and ```width```/// Reads all of the bytes of a decoder into a Vec<T>. No particular alignment/// of the output buffer is guaranteed./// Panics if there isn't enough memory to decode the image./// Represents the progress of an image operation./// Note that this is not necessarily accurate and no change to the values passed to the progress/// function during decoding will be considered breaking. A decoder could in theory report the/// progress `(0, 0)` if progress is unknown, without violating the interface contract of the type./// Create Progress. Result in invalid progress if you provide a greater `current` than `total`./// A measure of completed decoding./// A measure of all necessary decoding work./// This is in general greater or equal than `current`./// Calculate a measure for remaining decoding work./// The type of reader produced by `into_reader`./// Returns a tuple containing the width and height of the image/// Returns the color type of the image data produced by this decoder/// Returns the color type of the image file before decoding/// Returns the ICC color profile embedded in the image/// For formats that don't support embedded profiles this function will always return `None`./// This feature is currently only supported for the JPEG, PNG, and AVIF formats."Planned for removal. See https://github.com/image-rs/image/issues/1989"/// Returns a reader that can be used to obtain the bytes of the image. For the best/// performance, always try to read at least `scanline_bytes` from the reader at a time. Reading/// fewer bytes will cause the reader to perform internal buffering./// Returns the total number of bytes in the decoded image./// This is the size of the buffer that must be passed to `read_image` or/// `read_image_with_progress`. The returned value may exceed usize::MAX, in/// which case it isn't actually possible to construct a buffer to decode all the image data/// into. If, however, the size does not fit in a u64 then u64::MAX is returned./// Returns the minimum number of bytes that can be efficiently read from this decoder. This may/// be as few as 1 or as many as `total_bytes()`./// Returns all the bytes in the image./// This function takes a slice of bytes and writes the pixel data of the image into it./// Although not required, for certain color types callers may want to pass buffers which are/// aligned to 2 or 4 byte boundaries to the slice can be cast to a [u16] or [u32]. To accommodate/// such casts, the returned contents will always be in native endian./// This function panics if buf.len() != self.total_bytes()./// use zerocopy::{AsBytes, FromBytes};/// fn read_16bit_image(decoder: impl ImageDecoder) -> Vec<16> {///     let mut buf: Vec<u16> = vec![0; decoder.total_bytes()/2];///     decoder.read_image(buf.as_bytes());///     buf"Use read_image instead. See https://github.com/image-rs/image/issues/1989"/// Same as `read_image` but periodically calls the provided callback to give updates on loading/// Set decoding limits for this decoder. See [`Limits`] for the different kinds of/// limits that is possible to set./// Note to implementors: make sure you call [`Limits::check_support`] so that/// decoding fails if any unsupported strict limits are set. Also make sure/// you call [`Limits::check_dimensions`] to check the `max_image_width` and/// `max_image_height` limits./// [`Limits`]: ./io/struct.Limits.html/// [`Limits::check_support`]: ./io/struct.Limits.html#method.check_support/// [`Limits::check_dimensions`]: ./io/struct.Limits.html#method.check_dimensions/// The trait that all decoders implement/// Decode a rectangular section of the image; see [`read_rect_with_progress()`](#fn.read_rect_with_progress)./// Decode a rectangular section of the image, periodically reporting progress./// The output buffer will be filled with fields specified by/// [`ImageDecoder::color_type()`](trait.ImageDecoder.html#fn.color_type),/// in that order, each field represented in native-endian./// The progress callback will be called at least once at the start and the end of decoding,/// implementations are encouraged to call this more often,/// with a frequency meaningful for display to the end-user./// This function will panic if the output buffer isn't at least/// `color_type().bytes_per_pixel() * color_type().channel_count() * width * height` bytes long./// Specialized image decoding not be supported by all formats/// Consume the decoder producing a series of frames./// AnimationDecoder trait/// Writes all the bytes in an image to the encoder./// This function takes a slice of bytes of the pixel data of the image/// and encodes them. Unlike particular format encoders inherent impl encode/// methods where endianness is not specified, here image data bytes should/// always be in native endian. The implementor will reorder the endianness/// as necessary for the target encoding format./// See also `ImageDecoder::read_image` which reads byte buffers into/// Panics if `width * height * color_type.bytes_per_pixel() != buf.len()`./// The trait all encoders implement/// Immutable pixel iterator/// The type of pixel."This method has inconsistent behavior between implementations (#1829). Use `dimensions` instead"/// The bounding rectangle of this image./// Returns true if this x, y coordinate is contained inside the image./// Returns the pixel located at (x, y). Indexed from top left./// Panics if `(x, y)` is out of bounds./// This function can be implemented in a way that ignores bounds checking./// The coordinates must be [`in_bounds`] of the image./// [`in_bounds`]: #method.in_bounds/// Returns an Iterator over the pixels of this image./// along with their valueSubImage/// Returns a subimage that is an immutable view into this image./// You can use [`GenericImage::sub_image`] if you need a mutable view instead./// The coordinates set the position of the top left corner of the view./// Trait to inspect an image./// use image::{GenericImageView, Rgb, RgbImage};/// let buffer = RgbImage::new(10, 10);/// let image: &dyn GenericImageView<Pixel=Rgb<u8>> = &buffer;/// Gets a reference to the mutable pixel at location `(x, y)`. Indexed from top left./// Panics for dynamic images (this method is deprecated and will be removed)./// ## Known issues/// This requires the buffer to contain a unique set of continuous channels in the exact order/// and byte representation that the pixel type requires. This is somewhat restrictive./// TODO: Maybe use some kind of entry API? this would allow pixel type conversion on the fly/// while still doing only one array lookup:/// let px = image.pixel_entry_at(x,y);/// px.set_from_rgba(rgba)/// Put a pixel at location (x, y). Indexed from top left./// Puts a pixel at location (x, y). Indexed from top left./// [`in_bounds`]: traits.GenericImageView.html#method.in_bounds/// Copies all of the pixels from another image into this image./// The other image is copied with the top-left corner of the/// other image placed at (x, y)./// In order to copy only a piece of the other image, use [`GenericImageView::view`]./// You can use [`FlatSamples`] to source pixels from an arbitrary regular raster of channel/// values, for example from a foreign interface or a fixed image./// Returns an error if the image is too large to be copied at the given position/// [`GenericImageView::view`]: trait.GenericImageView.html#method.view/// [`FlatSamples`]: flat/struct.FlatSamples.html/// Copies all of the pixels from one part of this image to another part of this image./// The destination rectangle of the copy is specified with the top-left corner placed at (x, y)./// `true` if the copy was successful, `false` if the image could not/// be copied due to size constraints./// Returns a mutable subimage that is a view into this image./// If you want an immutable subimage instead, use [`GenericImageView::view`]/// The coordinates set the position of the top left corner of the SubImage./// A trait for manipulating images.SubImageInner/// A View into another image/// Instances of this struct can be created using:///   - [`GenericImage::sub_image`] to create a mutable view,///   - [`GenericImageView::view`] to create an immutable view,///   - [`SubImage::new`] to instantiate the struct directly./// Note that this does _not_ implement `GenericImage`, but it dereferences to one which allows you/// to use it as if it did. See [Design Considerations](#Design-Considerations) below for details./// # Design Considerations/// For reasons relating to coherence, this is not itself a `GenericImage` or a `GenericImageView`./// In short, we want to reserve the ability of adding traits implemented for _all_ generic images/// but in a different manner for `SubImage`. This may be required to ensure that stacking/// sub-images comes at no double indirect cost./// If, ultimately, this is not needed then a directly implementation of `GenericImage` can and/// will get added. This inconvenience may alternatively get resolved if Rust allows some forms of/// specialization, which might make this trick unnecessary and thus also allows for a directyoffsetxstrideystride/// The inner type of `SubImage` that implements `GenericImage{,View}`./// This type is _nominally_ `pub` but it is not exported from the crate. It should be regarded as/// an existential type in any case.DerefPixel/// Alias to access Pixel behind a referenceDerefSubpixel/// Alias to access Subpixel behind a reference/// Construct a new subimagechange_bounds/// Change the coordinates of this subimage./// The offsets of this subimage relative to the underlying image.to_image/// Convert this subimage to an ImageBuffer/// Create a sub-view of the image./// The coordinates given are relative to the current view on the underlying image./// Note that this method is preferred to the one from `GenericImageView`. This is accessible/// with the explicit method call syntax but it should rarely be needed due to causing an/// extra level of indirection./// use image::{GenericImageView, RgbImage, SubImage};/// let subimage: SubImage<&RgbImage> = buffer.view(0, 0, 10, 10);/// let subview: SubImage<&RgbImage> = subimage.view(0, 0, 10, 10);/// // Less efficient and NOT &RgbImage/// let _: SubImage<&_> = GenericImageView::view(&*subimage, 0, 0, 10, 10);/// Get a reference to the underlying image./// Methods for readable images./// Create a mutable sub-view of the image./// Get a mutable reference to the underlying image.test_image_alpha_blending/// Test that alpha blending works as expectedtest_in_boundstest_can_subimage_clone_nonmuttest_can_nest_viewstest_view_out_of_boundstest_view_coordinates_out_of_boundstest_view_width_out_of_boundstest_view_height_out_of_boundstest_view_x_out_of_boundstest_view_y_out_of_boundstest_view_in_boundstest_copy_sub_imagetest_load_recttest_load_rect_single_scanlinetest_image_format_from_pathtest_generic_image_copy_within_oobtest_generic_image_copy_within_tltest_generic_image_copy_within_trtest_generic_image_copy_within_bltest_generic_image_copy_within_brimage_formats_are_recognizedtotal_bytes_overflow/// Rotate an image 90 degrees clockwise./// Rotate an image 180 degrees clockwise./// Rotate an image 270 degrees clockwise.rotate90_in/// Rotate an image 90 degrees clockwise and put the result into the destination [`ImageBuffer`].rotate180_in/// Rotate an image 180 degrees clockwise and put the result into the destination [`ImageBuffer`].rotate270_in/// Rotate an image 270 degrees clockwise and put the result into the destination [`ImageBuffer`].flip_horizontal/// Flip an image horizontallyflip_vertical/// Flip an image verticallyflip_horizontal_in/// Flip an image horizontally and put the result into the destination [`ImageBuffer`].flip_vertical_in/// Flip an image vertically and put the result into the destination [`ImageBuffer`].rotate180_in_place/// Rotate an image 180 degrees clockwise in place.flip_horizontal_in_place/// Flip an image horizontally in place.flip_vertical_in_place/// Flip an image vertically in place.assert_pixels_eqtest_rotate90test_rotate180test_rotate270test_rotate180_in_placetest_flip_horizontaltest_flip_verticaltest_flip_horizontal_in_placetest_flip_vertical_in_placepixel_diffs//! Functions for performing affine transformations./// Convert the supplied image to grayscale. Alpha channel is discarded.grayscale_alpha/// Convert the supplied image to grayscale. Alpha channel is preserved.NewPixelgrayscale_with_type/// Convert the supplied image to a grayscale image with the specified pixel type. Alpha channel is discarded.grayscale_with_type_alpha/// Convert the supplied image to a grayscale image with the specified pixel type. Alpha channel is preserved./// Invert each pixel within the supplied image./// This function operates in place.contrast/// Adjust the contrast of the supplied image./// ```contrast``` is the amount to adjust the contrast by./// *[See also `contrast_in_place`.][contrast_in_place]*contrast_in_place/// Adjust the contrast of the supplied image in place./// *[See also `contrast`.][contrast]*/// Brighten the supplied image./// ```value``` is the amount to brighten each pixel by./// *[See also `brighten_in_place`.][brighten_in_place]*brighten_in_place/// Brighten the supplied image in place./// *[See also `brighten`.][brighten]*/// *[See also `huerotate_in_place`.][huerotate_in_place]*huerotate_in_place/// Hue rotate the supplied image in place./// *[See also `huerotate`.][huerotate]*/// The color type on which the map operates on/// Returns the index of the closest match of `color`/// in the color map./// Looks up color by index in the color map.  If `idx` is out of range for the color map, or/// ColorMap doesn't implement `lookup` `None` is returned.has_lookup/// Determine if this implementation of ColorMap overrides the default `lookup`.map_color/// Maps `color` to the closest color in the color map./// A color mapBiLevel/// A bi-level color map/// use image::imageops::colorops::{index_colors, BiLevel, ColorMap};/// let (w, h) = (16, 16);/// // Create an image with a smooth horizontal gradient from black (0) to white (255)./// let gray = ImageBuffer::from_fn(w, h, |x, y| -> Luma<u8> { [(255 * x / w) as u8].into() });/// // Mapping the gray image through the `BiLevel` filter should map gray pixels less than half/// // intensity (127) to black (0), and anything greater to white (255)./// let cmap = BiLevel;/// let palletized = index_colors(&gray, &cmap);/// let mapped = ImageBuffer::from_fn(w, h, |x, y| {///     let p = palletized.get_pixel(x, y);///     cmap.lookup(p.0[0] as usize)///         .expect("indexed color out-of-range")/// // Create an black and white image of expected output./// let bw = ImageBuffer::from_fn(w, h, |x, y| -> Luma<u8> {///     if x <= (w / 2) {///         [0].into()///         [255].into()/// assert_eq!(mapped, bw);/// Indicate NeuQuant implements `lookup`.diffuse_err/// Floyd-Steinberg error diffusiondo_ditheringPix/// Reduces the colors of the image using the supplied `color_map` while applying/// Floyd-Steinberg dithering to improve the visual conceptionindex_colors/// Reduces the colors using the supplied `color_map` and returns an image of the indicestest_dithertest_inverttest_brightentest_brighten_place//! Functions for altering and converting the color of pixelbufsLerpCatmullRomLanczos3Triangleaffine/// Affine transformationsinterpolate_bilinearinterpolate_nearestsample_bilinearsample_nearest/// Image samplingcolorops/// Color operations// Public only because of Rust bug:// https://github.com/rust-lang/rust/issues/18241/// Return a mutable view into an image/// The coordinates set the position of the top left corner of the crop./// Return an immutable view into an imagecrop_dimmsoverlay_bounds/// Calculate the region that can be copied from top to bottom./// Given image size of bottom and top image, and a point at which we want to place the top image/// onto the bottom image, how large can we be? Have to wary of the following issues:/// * Top might be larger than bottom/// * Overflows in the computation/// * Coordinates could be completely out of bounds/// The main idea is to make use of inequalities provided by the nature of `saturating_add` and/// `saturating_sub`. These intrinsically validate that all resulting coordinates will be in bounds/// for both images./// We want that all these coordinate accesses are safe:/// 1. `bottom.get_pixel(x + [0..x_range), y + [0..y_range))`/// 2. `top.get_pixel([0..x_range), [0..y_range))`/// Proof that the function provides the necessary bounds for width. Note that all unaugmented math/// operations are to be read in standard arithmetic, not integer arithmetic. Since no direct/// integer arithmetic occurs in the implementation, this is unambiguous./// Three short notes/lemmata:/// - Iff `(a - b) <= 0` then `a.saturating_sub(b) = 0`/// - Iff `(a - b) >= 0` then `a.saturating_sub(b) = a - b`/// - If  `a <= c` then `a.saturating_sub(b) <= c.saturating_sub(b)`/// 1.1 We show that if `bottom_width <= x`, then `x_range = 0` therefore `x + [0..x_range)` is empty./// x_range///  = (top_width.saturating_add(x).min(bottom_width)).saturating_sub(x)/// <= bottom_width.saturating_sub(x)/// bottom_width <= x/// <==> bottom_width - x <= 0/// <==> bottom_width.saturating_sub(x) = 0///  ==> x_range <= 0///  ==> x_range  = 0/// 1.2 If `x < bottom_width` then `x + x_range < bottom_width`/// x + x_range/// <= x + bottom_width.saturating_sub(x)///  = x + (bottom_width - x)///  = bottom_width/// 2. We show that `x_range <= top_width`/// <= top_width.saturating_add(x).saturating_sub(x)/// <= (top_wdith + x).saturating_sub(x)///  = top_width (due to `top_width >= 0` and `x >= 0`)/// Proof is the same for height.overlay_bounds_ext/// The returned value is of the form:/// `(origin_bottom_x, origin_bottom_y, origin_top_x, origin_top_y, x_range, y_range)`/// The main idea is to do computations on i64's and then clamp to image dimensions./// In particular, we want to ensure that all these coordinate accesses are safe:/// 1. `bottom.get_pixel(origin_bottom_x + [0..x_range), origin_bottom_y + [0..y_range))`/// 2. `top.get_pixel(origin_top_y + [0..x_range), origin_top_y + [0..y_range))`/// Overlay an image at a given coordinate (x, y)/// Tile an image by repeating it multiple times/// use image::{RgbaImage};/// let mut img = RgbaImage::new(1920, 1080);/// let tile = image::open("tile.png").unwrap();/// image::imageops::tile(&mut img, &tile);/// img.save("tiled_wallpaper.png").unwrap();vertical_gradient/// Fill the image with a linear vertical gradient/// This function assumes a linear color space./// use image::{Rgba, RgbaImage, Pixel};/// let mut img = RgbaImage::new(100, 100);/// let start = Rgba::from_slice(&[0, 128, 0, 0]);/// let end = Rgba::from_slice(&[255, 255, 255, 255]);/// image::imageops::vertical_gradient(&mut img, start, end);/// img.save("vertical_gradient.png").unwrap();horizontal_gradient/// Fill the image with a linear horizontal gradient/// image::imageops::horizontal_gradient(&mut img, start, end);/// img.save("horizontal_gradient.png").unwrap();/// Replace the contents of an image at a given coordinate (x, y)test_overlay_bounds_exttest_image_in_image/// Test that images written into other images workstest_image_in_image_outside_of_bounds/// Test that images written outside of a frame doesn't blow uptest_image_outside_image_no_wrap_around/// Test that images written to coordinates out of the frame doesn't blow up/// (issue came up in #848)test_image_coordinate_overflow/// Test that images written to coordinates with overflow workstest_image_horizontal_gradient_limits/// Test that horizontal gradients are correctly generatedtest_image_vertical_gradient_limits/// Test that vertical gradients are correctly generatedtest_blur_zero/// Test blur doesn't panick when passed 0.0//! Image Processing Functions/// Nearest Neighbor/// Linear Filter/// Cubic Filter/// Gaussian Filter/// Lanczos with window 3/// Available Sampling Filters./// To test the different sampling filters on a real example, you can find two/// examples called/// [`scaledown`](https://github.com/image-rs/image/tree/master/examples/scaledown)/// [`scaleup`](https://github.com/image-rs/image/tree/master/examples/scaleup)/// in the `examples` directory of the crate source code./// Here is a 3.58 MiB/// [test image](https://github.com/image-rs/image/blob/master/examples/scaledown/test.jpg)/// that has been scaled down to 300x225 px:/// <!-- NOTE: To test new test images locally, replace the GitHub path with `../../../docs/` -->/// <div style="display: flex; flex-wrap: wrap; align-items: flex-start;">///   <div style="margin: 0 8px 8px 0;">///     <img src="https://raw.githubusercontent.com/image-rs/image/master/examples/scaledown/scaledown-test-near.png" title="Nearest"><br>///     Nearest Neighbor///   </div>///     <img src="https://raw.githubusercontent.com/image-rs/image/master/examples/scaledown/scaledown-test-tri.png" title="Triangle"><br>///     Linear: Triangle///     <img src="https://raw.githubusercontent.com/image-rs/image/master/examples/scaledown/scaledown-test-cmr.png" title="CatmullRom"><br>///     Cubic: Catmull-Rom///     <img src="https://raw.githubusercontent.com/image-rs/image/master/examples/scaledown/scaledown-test-gauss.png" title="Gaussian"><br>///     Gaussian///     <img src="https://raw.githubusercontent.com/image-rs/image/master/examples/scaledown/scaledown-test-lcz2.png" title="Lanczos3"><br>///     Lanczos with window 3/// ## Speed/// Time required to create each of the examples above, tested on an Intel/// i7-4770 CPU with Rust 1.37 in release mode:/// <table style="width: auto;">///   <tr>///     <th>Nearest</th>///     <td>31 ms</td>///   </tr>///     <th>Triangle</th>///     <td>414 ms</td>///     <th>CatmullRom</th>///     <td>817 ms</td>///     <th>Gaussian</th>///     <td>1180 ms</td>///     <th>Lanczos3</th>///     <td>1170 ms</td>/// </table>/// The filter's filter function./// The window on which this filter operates./// A Representation of a separable filter.FloatNearest// to_{i,u}64 is required, to_{i,u}{8,16} are useful.// If a usecase for full 32 bits is found its trivial to add// to_i64, to_u64, and to_f64 implicitly affect all other lower conversions.// Note that to_f64 by default calls to_i64 and thus needs to be overridden.// sinc function: the ideal sampling filter.lanczos// lanczos kernel function. A windowed sinc function.bc_cubic_spline// Calculate a splice based on the b and c parameters.// from authors Mitchell and Netravali.gaussian/// The Gaussian Function./// ```r``` is the standard deviation.lanczos3_kernel/// Calculate the lanczos kernel with a window of 3gaussian_kernel/// Calculate the gaussian function with a/// standard deviation of 0.5catmullrom_kernel/// Calculate the Catmull-Rom cubic spline./// Also known as a form of `BiCubic` sampling in two dimensions.triangle_kernel/// Calculate the triangle function./// Also known as `BiLinear` sampling in two dimensions.box_kernel/// Calculate the box kernel./// Only pixels inside the box should be considered, and those/// contribute equally.  So this method simply returns 1.horizontal_sample// Sample the rows of the supplied image using the provided filter.// The height of the image remains unchanged.// ```new_width``` is the desired width of the new image// ```filter``` is the filter to use for sampling.// ```image``` is not necessarily Rgba and the order of channels is passed through./// Linearly sample from an image using coordinates in [0, 1]./// Sample from an image using coordinates in [0, 1], taking the nearest coordinate./// Sample from an image using coordinates in [0, w-1] and [0, h-1], taking the/// nearest pixel./// Coordinates outside the image bounds will return `None`, however the/// behavior for points within half a pixel of the image bounds may change in/// the future./// Linearly sample from an image using coordinates in [0, w-1] and [0, h-1].vertical_sample// Sample the columns of the supplied image using the provided filter.// The width of the image remains unchanged.// ```new_height``` is the desired height of the new image// The return value is not necessarily Rgba, the underlying order of channels in ```image``` is// preserved.LargerThumbnailSum/// Local struct for keeping track of pixel sums for fast thumbnail averagingsample_val/// Resize the supplied image to the specific dimensions./// For downscaling, this method uses a fast integer algorithm where each source pixel contributes/// to exactly one target pixel.  May give aliasing artifacts if new size is close to old size./// In case the current width is smaller than the new width or similar for the height, another/// strategy is used instead.  For each pixel in the output, a rectangular region of the input is/// determined, just as previously.  But when no input pixel is part of this region, the nearest/// pixels are interpolated instead./// For speed reasons, all interpolation is performed linearly over the colour values.  It will not/// take the pixel colour spaces into account.thumbnail_sample_block/// Get a pixel for a thumbnail where the input window encloses at least a full pixel.thumbnail_sample_fraction_horizontal/// Get a thumbnail pixel where the input window encloses at least a vertical pixel.thumbnail_sample_fraction_vertical/// Get a thumbnail pixel where the input window encloses at least a horizontal pixel.thumbnail_sample_fraction_both/// Get a single pixel for a thumbnail where the input window does not enclose any full pixel./// Perform a 3x3 box filter on the supplied image./// ```kernel``` is an array of the filter weights of length 9./// Resize the supplied image to the specified dimensions./// ```nwidth``` and ```nheight``` are the new dimensions./// ```filter``` is the sampling filter to use./// Performs a Gaussian blur on the supplied image./// ```sigma``` is a measure of how much to blur by./// Performs an unsharpen mask on the supplied image./// ```sigma``` is the amount to blur the image by./// ```threshold``` is the threshold for minimal brightness change that will be sharpened.test_resize_same_sizetest_sample_bilineartest_sample_nearesttest_sample_bilinear_correctnesstest_sample_nearest_correctnesstest_issue_186resize_transparent_imagebug_1600//! Functions and filters for the sampling of pixels.// See http://cs.brown.edu/courses/cs123/lectures/08_Image_Processing_IV.pdf// for some of the theory behind image scaling and convolution// When no features are supportedopen_impl/// Create a new image from a Reader./// Assumes the reader is already buffered. For optimal performance,/// consider wrapping the reader with a `BufReader::new()`.// r is unused if no features are supported.visit_decoderDecoderVisitorload_decoderload_innerimage_dimensions_implimage_dimensions_with_format_impl// fin is unused if no features are supported.save_buffer_impl// Most variables when no features are supportedsave_buffer_with_format_implwrite_buffer_implMAGIC_BYTESguess_format/// Guess image format from memory block/// Makes an educated guess about the image format based on the Magic Bytes at the beginning./// This is not to be trusted on the validity of the whole memory blockguess_format_impl_non_exhaustive/// Set of supported strict limits for a decoder.max_image_width/// The maximum allowed image width. This limit is strict. The default is no limit.max_image_height/// The maximum allowed image height. This limit is strict. The default is no limit.max_alloc/// The maximum allowed sum of allocations allocated by the decoder at any one time excluding/// allocator overhead. This limit is non-strict by default and some decoders may ignore it./// The default is 512MiB./// Resource limits for decoding./// Limits can be either *strict* or *non-strict*. Non-strict limits are best-effort/// limits where the library does not guarantee that limit will not be exceeded. Do note/// that it is still considered a bug if a non-strict limit is exceeded, however as/// some of the underlying decoders do not support not support such limits one cannot/// rely on these limits being supported. For stric limits the library makes a stronger/// guarantee that the limit will not be exceeded. Exceeding a strict limit is considered/// a critical bug. If a decoder cannot guarantee that it will uphold a strict limit it/// *must* fail with `image::error::LimitErrorKind::Unsupported`./// Currently the only strict limits supported are the `max_image_width` and `max_image_height`/// limits, however more will be added in the future. [`LimitSupport`] will default to support/// being false and decoders should enable support for the limits they support in/// [`ImageDecoder::set_limits`]./// The limit check should only ever fail if a limit will be exceeded or an unsupported strict/// limit is used./// [`LimitSupport`]: ./struct.LimitSupport.html/// [`ImageDecoder::set_limits`]: ../trait.ImageDecoder.html#method.set_limitsno_limits/// Disable all limits./// This function checks that all currently set strict limits are supported.check_dimensions/// This function checks the `max_image_width` and `max_image_height` limits given/// the image width and height./// This function checks that the current limit allows for reserving the set amount/// of bytes, it then reduces the limit accordingly.reserve_usize/// This function acts identically to [`reserve`], but takes a `usize` for convenience.reserve_buffer/// This function acts identically to [`reserve`], but accepts the width, height and color type/// used to create an [`ImageBuffer`] and does all the math for you./// This function increases the `max_alloc` limit with amount. Should only be used/// together with [`reserve`]./// [`reserve`]: #method.reservefree_usize/// This function acts identically to [`free`], but takes a `usize` for convenience.//! Input and output of images./// The reader. Should be buffered./// The format, if one has been set or deduced./// Decoding limits/// A multi-format image reader./// Wraps an input reader to facilitate automatic detection of an image's format, appropriate/// decoding method, and dispatches into the set of supported [`ImageDecoder`] implementations./// Opening a file, deducing the format based on the file path automatically, and trying to decode/// the image contained can be performed by constructing the reader and immediately consuming it./// # use image::ImageError;/// # use image::io::Reader;/// # fn main() -> Result<(), ImageError> {/// let image = Reader::open("path/to/image.png")?///     .decode()?;/// It is also possible to make a guess based on the content. This is especially handy if the/// source is some blob in memory and you have constructed the reader in another way. Here is an/// example with a `pnm` black-and-white subformat that encodes its pixel matrix with ascii values./// let raw_data = b"P1 2 2\n\///     0 1\n\///     1 0\n";/// let mut reader = Reader::new(Cursor::new(raw_data))///     .with_guessed_format()///     .expect("Cursor io never fails");/// assert_eq!(reader.format(), Some(ImageFormat::Pnm));/// # #[cfg(feature = "pnm")]/// let image = reader.decode()?;/// As a final fallback or if only a specific format must be used, the reader always allows manual/// specification of the supposed image format with [`set_format`]./// [`set_format`]: #method.set_format/// [`ImageDecoder`]: ../trait.ImageDecoder.html/// Create a new image reader without a preset format./// It is possible to guess the format based on the content of the read object with/// [`with_guessed_format`], or to set the format directly with [`set_format`]./// [`with_guessed_format`]: #method.with_guessed_format/// [`set_format`]: method.set_formatwith_format/// Construct a reader with specified format./// Get the currently determined format./// Supply the format as which to interpret the read image.clear_format/// Remove the current information on the image format./// Note that many operations require format information to be present and will return e.g. an/// `ImageError::Unsupported` when the image format has not been set./// Disable all decoding limits./// Set a custom set of decoding limits./// Unwrap the reader./// Open a file to read, format will be guessed from path./// This will not attempt any io operation on the opened file./// If you want to inspect the content for a better guess on the format, which does not depend/// on file extensions, follow this call with a call to [`with_guessed_format`].with_guessed_format/// Make a format guess based on the content, replacing it on success./// Returns `Ok` with the guess if no io error occurs. Additionally, replaces the current/// format if the guess was successful. If the guess was unable to determine a format then/// the current format of the reader is unchanged./// Returns an error if the underlying reader fails. The format is unchanged. The error is a/// `std::io::Error` and not `ImageError` since the only error case is an error when the/// underlying reader seeks./// When an error occurs, the reader may not have been properly reset and it is potentially/// hazardous to continue with more io./// This supplements the path based type deduction from [`open`](Reader::open) with content based deduction./// This is more common in Linux and UNIX operating systems and also helpful if the path can/// not be directly controlled./// let image = Reader::open("image.unknown")?///     .with_guessed_format()?into_dimensions/// Read the image dimensions./// Uses the current format to construct the correct reader for the format./// If no format was determined, returns an `ImageError::Unsupported`./// Read the image (replaces `load`).require_format// Iterators// Image types// Opening and loading images// More detailed error type// Only those not exported at the top-level/// Iterators and other auxiliary structure for the `ImageBuffer` type.// Math utils// Image processing functions// Io bindings// Buffer representations for ffi.dds"DXT support will be removed or reworked in a future version. Prefer the `squish` crate instead. See https://github.com/image-rs/image/issues/1623"icoopenexrwebp/// Encoding and decoding for various image file formats./// # Supported formats/// <!--- NOTE: Make sure to keep this table in sync with the README -->/// | Format   | Decoding                                  | Encoding                                |/// | -------- | ----------------------------------------- | --------------------------------------- |/// | AVIF     | Only 8-bit                                | Lossy                                   |/// | BMP      | Yes                                       | Rgb8, Rgba8, Gray8, GrayA8              |/// | DDS      | DXT1, DXT3, DXT5                          | No                                      |/// | Farbfeld | Yes                                       | Yes                                     |/// | GIF      | Yes                                       | Yes                                     |/// | HDR      | Yes                                       | Yes                                     |/// | ICO      | Yes                                       | Yes                                     |/// | JPEG     | Baseline and progressive                  | Baseline JPEG                           |/// | OpenEXR  | Rgb32F, Rgba32F (no dwa compression)      | Rgb32F, Rgba32F (no dwa compression)    |/// | PNG      | All supported color types                 | Same as decoding                        |/// | PNM      | PBM, PGM, PPM, standard PAM               | Yes                                     |/// | QOI      | Yes                                       | Yes                                     |/// | TGA      | Yes                                       | Rgb8, Rgba8, Bgr8, Bgra8, Gray8, GrayA8 |/// | TIFF     | Baseline(no fax support) + LZW + PackBits | Rgb8, Rgba8, Gray8                      |/// | WebP     | Yes                                       | Rgb8, Rgba8                             |/// ## A note on format specific features/// One of the main goals of `image` is stability, in runtime but also for programmers. This/// ensures that performance as well as safety fixes reach a majority of its user base with little/// effort. Re-exporting all details of its dependencies would run counter to this goal as it/// linked _all_ major version bumps between them and `image`. As such, we are wary of exposing too/// many details, or configuration options, that are not shared between different image formats./// Nevertheless, the advantage of precise control is hard to ignore. We will thus consider/// _wrappers_, not direct re-exports, in either of the following cases:/// 1. A standard specifies that configuration _x_ is required for decoders/encoders and there///    exists an essentially canonical way to control it./// 2. At least two different implementations agree on some (sub-)set of features in practice./// 3. A technical argument including measurements of the performance, space benefits, or otherwise///    objectively quantified benefits can be made, and the added interface is unlikely to require///    breaking changes./// Features that fulfill two or more criteria are preferred./// Re-exports of dependencies that reach version `1` will be discussed when it happens."buffer.rs"// Can't use the macro-call itself within the `doc` attribute. So force it to eval it as part of// the macro invocation.// The inspiration for the macro and implementation is from// <https://github.com/GuillaumeGomez/doc-comment>// MIT License// Copyright (c) 2018 Guillaume Gomez//! # Overview//! This crate provides native rust implementations of image encoding and decoding as well as some//! basic image manipulation functions. Additional documentation can currently also be found in the//! [README.md file which is most easily viewed on//! github](https://github.com/image-rs/image/blob/master/README.md).//! There are two core problems for which this library provides solutions: a unified interface for image//! encodings and simple generic buffers for their content. It's possible to use either feature//! without the other. The focus is on a small and stable set of common operations that can be//! supplemented by other specialized crates. The library also prefers safe solutions with few//! dependencies.//! # High level API//! Load images using [`io::Reader`]://! use std::io::Cursor;//! use image::io::Reader as ImageReader;//! # fn main() -> Result<(), image::ImageError> {//! # let bytes = vec![0u8];//! let img = ImageReader::open("myimage.png")?.decode()?;//! let img2 = ImageReader::new(Cursor::new(bytes)).with_guessed_format()?.decode()?;//! And save them using [`save`] or [`write_to`] methods://! # use std::io::{Write, Cursor};//! # use image::{DynamicImage, ImageOutputFormat};//! # #[cfg(feature = "png")]//! # let img: DynamicImage = unimplemented!();//! # let img2: DynamicImage = unimplemented!();//! img.save("empty.jpg")?;//! let mut bytes: Vec<u8> = Vec::new();//! img2.write_to(&mut Cursor::new(&mut bytes), image::ImageOutputFormat::Png)?;//! # #[cfg(not(feature = "png"))] fn main() {}//! With default features, the crate includes support for [many common image formats](codecs/index.html#supported-formats).//! [`save`]: enum.DynamicImage.html#method.save//! [`write_to`]: enum.DynamicImage.html#method.write_to//! [`io::Reader`]: io/struct.Reader.html//! # Image buffers//! The two main types for storing images://! * [`ImageBuffer`] which holds statically typed image contents.//! * [`DynamicImage`] which is an enum over the supported ImageBuffer formats//!     and supports conversions between them.//! As well as a few more specialized options://! * [`GenericImage`] trait for a mutable image buffer.//! * [`GenericImageView`] trait for read only references to a GenericImage.//! * [`flat`] module containing types for interoperability with generic channel//!     matrices and foreign interfaces.//! [`GenericImageView`]: trait.GenericImageView.html//! [`GenericImage`]: trait.GenericImage.html//! [`ImageBuffer`]: struct.ImageBuffer.html//! [`DynamicImage`]: enum.DynamicImage.html//! [`flat`]: flat/index.html//! # Low level encoding/decoding API//! Implementations of [`ImageEncoder`] provides low level control over encoding://! # use std::io::Write;//! # use image::DynamicImage;//! # use image::ImageEncoder;//! # #[cfg(feature = "jpeg")]//! # use image::codecs::jpeg::JpegEncoder;//! # let writer: Box<dyn Write> = unimplemented!();//! let encoder = JpegEncoder::new_with_quality(&mut writer, 95);//! img.write_with_encoder(encoder)?;//! # #[cfg(not(feature = "jpeg"))] fn main() {}//! While [`ImageDecoder`] and [`ImageDecoderRect`] give access to more advanced decoding options://! # use std::io::Read;//! # use image::ImageDecoder;//! # use image::codecs::png::PngDecoder;//! # let reader: Box<dyn Read> = unimplemented!();//! let decoder = PngDecoder::new(&mut reader)?;//! let icc = decoder.icc_profile();//! let img = DynamicImage::from_decoder(decoder)?;//! [`DynamicImage::from_decoder`]: enum.DynamicImage.html#method.from_decoder//! [`ImageDecoderRect`]: trait.ImageDecoderRect.html//! [`ImageDecoder`]: trait.ImageDecoder.html//! [`ImageEncoder`]: trait.ImageEncoder.html// it's a backwards compatibility break//! Mathematical helper functions and types./// The x coordinate of the top left corner./// The y coordinate of the top left corner./// The rectangle's width./// The rectangle's height./// A Rectangle defined by its top left corner, width and height./// Calculates the width and height an image should be resized to./// This preserves aspect ratio, and based on the `fill` parameter/// will either fill the dimensions to fit inside the smaller constraint/// (will overflow the specified bounds on one axis to preserve/// aspect ratio), or will shrink so that both dimensions are/// completely contained within the given `width` and `height`,/// with empty space on one axis.resize_handles_fillresize_never_rounds_to_zeroresize_handles_overflowresize_roundsresize_handles_zero//! Shared mathematical utility functions./// Get the bytes of this value.seals/// Types which are safe to treat as an immutable byte slice in a pixel layout/// for image encoding.DEFAULT_MAX_VALUE/// The maximum value for this type of primitive within the context of color./// For floats, the maximum is `1.0`, whereas the integer types inherit their usual maximum values.DEFAULT_MIN_VALUE/// The minimum value for this type of primitive within the context of color./// For floats, the minimum is `0.0`, whereas the integer types inherit their usual minimum values./// The type of each channel in a pixel. For example, this can be `u8`, `u16`, `f32`.// TODO rename to `PixelComponent`? Split up into separate traits? Seal?declare_primitiveclamp_fromto_larger/// An Enlargable::Larger value should be enough to calculate/// the sum (average) of a few hundred or thousand Enlargeable values.// Note: On 32-bit architectures, u64 should be enough here.// Note: On 32-bit architectures, i64 should be enough here./// Linear interpolation without involving floating numbers.COLOR_TYPE/// This pixel has the format of one of the predefined `ColorType`s,/// such as `Rgb8`, `La16` or `Rgba32F`./// This is needed for automatically detecting/// a color format when saving an image as a file.SealedPixelWithColorType/// The pixel with an associated `ColorType`./// Not all possible pixels represent one of the predefined `ColorType`s./// Prevents down-stream users from implementing the `Primitive` trait/// The scalar type that is used to store each channel in this pixel./// The number of channels of this pixel type./// Returns the components as a slice./// Returns the components as a mutable slice/// A string that can help to interpret the meaning each channel/// See [gimp babl](http://gegl.org/babl/)./// Returns the channels of this pixel as a 4 tuple. If the pixel/// has less than 4 channels the remainder is filled with the maximum value/// Construct a pixel from the 4 channels a, b, c and d./// If the pixel does not contain 4 channels the extra are ignored./// Returns a view into a slice./// Note: The slice length is not checked on creation. Thus the caller has to ensure/// that the slice is long enough to prevent panics if the pixel is used later on./// Returns mutable view into a mutable slice./// Convert this pixel to RGB/// Convert this pixel to RGB with an alpha channel/// Convert this pixel to luma/// Convert this pixel to luma with an alpha channel/// Apply the function ```f``` to each channel of this pixel./// Apply the function ```f``` to each channel except the alpha channel./// Apply the function ```g``` to the alpha channel./// Apply the function ```g``` to the alpha channel. Works in-place.map_without_alphaapply_without_alpha/// Works in place./// Apply the function ```f``` to each channel of this pixel and/// ```other``` pairwise./// ```other``` pairwise. Works in-place./// Invert this pixel/// Blend the color of a given pixel into ourself, taking into account alpha channels/// A generalized pixel./// A pixel object is usually not used standalone but as a view into an image buffer./// Private module for supertraits of sealed traits.//! This module provides useful traits that were deprecated in rust// Note copied from the stdlib under MIT licenseexpand_bits/// Expand a buffer of packed 1, 2, or 4 bits integers into u8's. Assumes that/// every `row_size` entries there are padding bits up to the next byte boundary.check_dimension_overflow/// Checks if the provided dimensions would cause an overflow.vec_copy_to_u8gray_to_luma8_skip//!  Utilitiesread_image_boxed/// Encodes the image `image` that has dimensions `width` and `height` and `ExtendedColorType` `c`.//! use std::io::BufReader;//! let file_in = BufReader::new(File::open("foo.gif")?);/// Reads Radiance HDR image header from stream ```r```ZuneColorSpacezune_coreorig_color_space// For API compatibility with the previous jpeg_decoder wrapper.// Can be removed later, which would be an API break.to_supported_color_spacenew_zune_decoderzune_jpegDecodeErrorsbench_jpeg_encoder_newread_next_lineimage_webpfrom_webp_decodefrom_webp_encode/// Returns the number of bits per pixel for this color type./// Returns the number of bytes required to hold a width x height image of this color type./// The buffer is assumed to have the correct format according to the specified color type. This/// will lead to corrupted writers if the buffer contains malformed data./// Assumes the writer is buffered. In most cases, you should wrap your writer in a `BufWriter` for/// best performance./// Returns the ICC color profile embedded in the image, or `Ok(None)` if the image does not have one./// For formats that don't support embedded profiles this function should always return `Ok(None)`./// Set the decoder to have the specified limits. See [`Limits`] for the different kinds of/// Use `read_image` instead; this method is an implementation detail needed so the trait can/// be object safe./// Note to implementors: This method should be implemented by calling `read_image` on/// the boxed decoder...///     fn read_image_boxed(self: Box<Self>, buf: &mut [u8]) -> ImageResult<()> {///        (*self).read_image(buf)/// Decode a rectangular section of the image./// The rectangle is specified by the x and y coordinates of the top left corner, the width/// and height of the rectangle, and the row pitch of the buffer. The row pitch is the number/// of bytes between the start of one row and the start of the next row. The row pitch must be/// at least as large as the width of the rectangle in bytes./// The bytes required to store the output image count towards this value. The default is/// 512MiB.make_decoder/// Makes a decoder./// For all formats except PNG, the limits are ignored and can be set with/// ImageDecoder::set_limits after calling this function. PNG is handled specially because that/// decoder has a different API which does not allow setting limits after construction.into_decoder/// Convert the reader into a decoder./// | AVIF     | Yes (8-bit only) \*                       | Yes (lossy only)                        |/// | BMP      | Yes                                       | Yes                                     |/// | DDS      | Yes                                       | ---                                     |/// | JPEG     | Yes                                       | Yes                                     |/// | EXR      | Yes                                       | Yes                                     |/// | PNG      | Yes                                       | Yes                                     |/// | PNM      | Yes                                       | Yes                                     |/// | TGA      | Yes                                       | Yes                                     |/// | TIFF     | Yes                                       | Yes                                     |/// | WebP     | Yes                                       | Yes (lossless only)                     |/// - \* Requires the `avif-native` feature, uses the libdav1d C library.//! # use image::{DynamicImage, ImageFormat};//! img2.write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)?;//! # use std::io::{BufReader, Cursor};//! # let reader: BufReader<Cursor<&[u8]>> = unimplemented!();borshERROR_ZST_FORBIDDENBorshDeserializeBorshSerializedeserialize_readercheck_zstmap_borsh_roundtripset_borsh_roundtripborsh_tests/// Hash value newtype. Not larger than usize, since anything larger/// isn't used for selecting position anyway.key_ref// field accessors -- used for `f` instead of closures in `.map(f)`value_refkey_valuerefsref_mutmutsinto_entriesas_entriesas_entries_mutwith_entriesEntriesTryReserveErrorKind/// The error type for [`try_reserve`][IndexMap::try_reserve] methods.// The standard library's kind is currently opaque to us, otherwise we could unify this.from_allocfrom_hashbrown// These are not `From` so we don't expose them in our public API.// We *mostly* avoid unsafe code, but `map::core::raw` allows it to use `RawTable` buckets.//! [`IndexMap`] is a hash table where the iteration order of the key-value//! pairs is independent of the hash values of the keys.//! [`IndexSet`] is a corresponding hash set using the same implementation and//! with similar properties.//! ### Highlights//! [`IndexMap`] and [`IndexSet`] are drop-in compatible with the std `HashMap`//! and `HashSet`, but they also have some features of note://! - The ordering semantics (see their documentation for details)//! - Sorting methods and the [`.pop()`][IndexMap::pop] methods.//! - The [`Equivalent`] trait, which offers more flexible equality definitions//!   between borrowed and owned versions of keys.//! - The [`MutableKeys`][map::MutableKeys] trait, which gives opt-in mutable//!   access to map keys, and [`MutableValues`][set::MutableValues] for sets.//! ### Feature Flags//! To reduce the amount of compiled code in the crate by default, certain//! features are gated behind [feature flags]. These allow you to opt in to (or//! out of) functionality. Below is a list of the features available in this//! * `std`: Enables features which require the Rust standard library. For more//!   information see the section on [`no_std`].//! * `rayon`: Enables parallel iteration and other parallel methods.//! * `serde`: Adds implementations for [`Serialize`] and [`Deserialize`]//!   to [`IndexMap`] and [`IndexSet`]. Alternative implementations for//!   (de)serializing [`IndexMap`] as an ordered sequence are available in the//!   [`map::serde_seq`] module.//! * `borsh`: Adds implementations for [`BorshSerialize`] and [`BorshDeserialize`]//!   to [`IndexMap`] and [`IndexSet`].//! * `arbitrary`: Adds implementations for the [`arbitrary::Arbitrary`] trait//! * `quickcheck`: Adds implementations for the [`quickcheck::Arbitrary`] trait//! _Note: only the `std` feature is enabled by default._//! [`no_std`]: #no-standard-library-targets//! [`Serialize`]: `::serde::Serialize`//! [`Deserialize`]: `::serde::Deserialize`//! [`BorshSerialize`]: `::borsh::BorshSerialize`//! [`BorshDeserialize`]: `::borsh::BorshDeserialize`//! [`arbitrary::Arbitrary`]: `::arbitrary::Arbitrary`//! [`quickcheck::Arbitrary`]: `::quickcheck::Arbitrary`//! ### Alternate Hashers//! [`IndexMap`] and [`IndexSet`] have a default hasher type//! [`S = RandomState`][std::collections::hash_map::RandomState],//! just like the standard `HashMap` and `HashSet`, which is resistant to//! HashDoS attacks but not the most performant. Type aliases can make it easier//! to use alternate hashers://! use fnv::FnvBuildHasher;//! use fxhash::FxBuildHasher;//! use indexmap::{IndexMap, IndexSet};//! type FnvIndexMap<K, V> = IndexMap<K, V, FnvBuildHasher>;//! type FnvIndexSet<T> = IndexSet<T, FnvBuildHasher>;//! type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;//! type FxIndexSet<T> = IndexSet<T, FxBuildHasher>;//! let std: IndexSet<i32> = (0..100).collect();//! let fnv: FnvIndexSet<i32> = (0..100).collect();//! let fx: FxIndexSet<i32> = (0..100).collect();//! assert_eq!(std, fnv);//! assert_eq!(std, fx);//! This version of indexmap requires Rust 1.63 or later.//! The indexmap 2.x release series will use a carefully considered version//! upgrade policy, where in a later 2.x version, we will raise the minimum//! required Rust version.//! ## No Standard Library Targets//! This crate supports being built without `std`, requiring `alloc` instead.//! This is chosen by disabling the default "std" cargo feature, by adding//! `default-features = false` to your dependency specification.//! - Creating maps and sets using [`new`][IndexMap::new] and//! [`with_capacity`][IndexMap::with_capacity] is unavailable without `std`.//!   Use methods [`IndexMap::default`], [`with_hasher`][IndexMap::with_hasher],//!   [`with_capacity_and_hasher`][IndexMap::with_capacity_and_hasher] instead.//!   A no-std compatible hasher will be needed as well, for example//!   from the crate `twox-hash`.//! - Macros [`indexmap!`] and [`indexset!`] are unavailable without `std`.// shared private items/// Create an [`IndexMap`][crate::IndexMap] from a list of key-value pairs/// use indexmap::indexmap;/// let map = indexmap!{///     "a" => 1,///     "b" => 2,/// assert_eq!(map["a"], 1);/// assert_eq!(map["b"], 2);/// // "a" is the first key/// assert_eq!(map.keys().next(), Some(&"a"));indexset/// Create an [`IndexSet`][crate::IndexSet] from a list of values/// use indexmap::indexset;/// let set = indexset!{///     "a",///     "b",/// assert!(set.contains("a"));/// assert!(set.contains("b"));/// assert!(!set.contains("c"));/// // "a" is the first value/// assert_eq!(set.iter().next(), Some(&"a"));iterator_methods// $map_elt is the mapping function from the underlying iterator's element// same mapping function for both options and iterators// generate all the Iterator methods by just forwarding to the underlying// self.iter and mapping its element.double_ended_iterator_methodsRawTableEntryIndexMapCore/// Existing slot with equivalent key./// Vacant slot (no equivalent key in the map)./// Entry for an existing key-value pair in an [`IndexMap`][crate::IndexMap]/// or a vacant location to insert one./// Return the index where the key-value pair exists or will be inserted./// Inserts the given default value in the entry if it is vacant and returns a mutable/// reference to it. Otherwise a mutable reference to an already existent value is returned./// Computes in **O(1)** time (amortized average)./// Inserts the result of the `call` function in the entry if it is vacant and returns a mutable/// Inserts the result of the `call` function with a reference to the entry's key if it is/// vacant, and returns a mutable reference to the new value. Otherwise a mutable reference to/// an already existent value is returned./// Gets a reference to the entry's key, either within the map if occupied,/// or else the new key that was used to find the entry./// Modifies the entry if it is occupied./// Inserts a default-constructed value in the entry if it is vacant and returns a mutable/// A view into an occupied entry in an [`IndexMap`][crate::IndexMap]./// Return the index of the key-value pair/// Gets a reference to the entry's key in the map./// Note that this is not the key that was used to find the entry. There may be an observable/// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like/// extra fields or the memory address of an allocation./// Gets a reference to the entry's value in the map./// Gets a mutable reference to the entry's value in the map./// If you need a reference which may outlive the destruction of the/// [`Entry`] value, see [`into_mut`][Self::into_mut]./// Converts into a mutable reference to the entry's value in the map,/// Sets the value of the entry to `value`, and returns the entry's old value./// Remove the key, value pair stored in the map for this entry, and return the value./// **NOTE:** This is equivalent to [`.swap_remove()`][Self::swap_remove], replacing this/// entry's position with the last element, and it is deprecated in favor of calling that/// explicitly. If you need to preserve the relative order of the keys in the map, use/// [`.shift_remove()`][Self::shift_remove] instead./// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with/// the last element of the map and popping it off./// **This perturbs the position of what used to be the last element!**/// Computes in **O(1)** time (average).shift_remove/// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the/// elements that follow it, preserving their relative order./// **This perturbs the index of all of those elements!**/// Computes in **O(n)** time (average)./// Remove and return the key, value pair stored in the map for this entry/// **NOTE:** This is equivalent to [`.swap_remove_entry()`][Self::swap_remove_entry],/// replacing this entry's position with the last element, and it is deprecated in favor of/// calling that explicitly. If you need to preserve the relative order of the keys in the map,/// use [`.shift_remove_entry()`][Self::shift_remove_entry] instead.swap_remove_entryshift_remove_entrymove_index/// Moves the position of the entry to a new index/// by shifting all other entries in-between./// This is equivalent to [`IndexMap::move_index`][`crate::IndexMap::move_index`]/// coming `from` the current [`.index()`][Self::index]./// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up./// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down./// ***Panics*** if `to` is out of bounds.swap_indices/// Swaps the position of entry with another./// This is equivalent to [`IndexMap::swap_indices`][`crate::IndexMap::swap_indices`]/// with the current [`.index()`][Self::index] as one of the two being swapped./// ***Panics*** if the `other` index is out of bounds./// A view into a vacant entry in an [`IndexMap`][crate::IndexMap]./// Return the index where a key-value pair may be inserted./// Gets a reference to the key that was used to find the entry./// Takes ownership of the key, leaving the entry vacant./// Inserts the entry's key and the given value into the map, and returns a mutable reference/// to the value./// Inserts the entry's key and the given value into the map at its ordered/// position among sorted keys, and returns the new index and a mutable/// reference to the value./// If the existing keys are **not** already sorted, then the insertion/// index is unspecified (like [`slice::binary_search`]), but the key-value/// pair is inserted at that position regardless.shift_insert/// Inserts the entry's key and the given value into the map at the given index,/// shifting others to the right, and returns a mutable reference to the value./// ***Panics*** if `index` is out of bounds.// We have a mutable reference to the map, which keeps the index// valid and pointing to the correct entry.IndexedEntry/// A view into an occupied entry in an [`IndexMap`][crate::IndexMap] obtained by index./// This `struct` is created from the [`get_index_entry`][crate::IndexMap::get_index_entry] method./// `IndexedEntry` value, see [`into_mut`][Self::into_mut].RawBucketinsert_bulk_no_grow/// Inserts many entries into a raw table without reallocating./// ***Panics*** if there is not sufficient capacity already.erase_indices_sweep/// Sweep the whole table to erase indices start..endfind_or_insert/// Search for a key in the table and return `Ok(entry_index)` if found./// Otherwise, insert the key and return `Err(new_index)`./// Note that hashbrown may resize the table to reserve space for insertion,/// even before checking if it's already present, so this is somewhat biased/// towards new items.indices_mutraw_bucket/// A view into an occupied raw entry in an `IndexMap`.// SAFETY: The lifetime of the map reference also constrains the raw bucket,// which is essentially a raw pointer into the map indices.// `hashbrown::raw::Bucket` is only `Send`, not `Sync`.// SAFETY: `&self` only accesses the bucket to read it.bucket_mutinto_bucket/// Remove the index from indices, leaving the actual entries to the caller./// Take no action, just return the index and the original map reference.//! This module encapsulates the `unsafe` access to `hashbrown::raw::RawTable`,//! mostly in dealing with its bucket "pointers".raw_entry_v1/// Creates a raw immutable entry builder for the [`IndexMap`]./// * Using a search key that doesn't work with the [`Equivalent`] trait/// [`get`][IndexMap::get] should be preferred./// Immutable raw entries have very limited use; you might instead want/// [`raw_entry_mut_v1`][Self::raw_entry_mut_v1]./// use indexmap::map::{IndexMap, RawEntryApiV1};/// let mut map = IndexMap::new();///     let i = map.get_index_of(k);///     let v = map.get(k);///     let kv = map.get_key_value(k);///     let ikv = map.get_full(k);///     assert_eq!(map.raw_entry_v1().from_key(k), kv);///     assert_eq!(map.raw_entry_v1().from_hash(hash, |q| *q == k), kv);///     assert_eq!(map.raw_entry_v1().from_key_hashed_nocheck(hash, k), kv);///     assert_eq!(map.raw_entry_v1().from_hash_full(hash, |q| *q == k), ikv);///     assert_eq!(map.raw_entry_v1().index_from_hash(hash, |q| *q == k), i);raw_entry_mut_v1/// Creates a raw entry builder for the [`IndexMap`]./// to put the `IndexMap` into an inconsistent state which, while memory-safe,/// will cause the map to produce seemingly random results. Higher-level and more/// foolproof APIs like [`entry`][IndexMap::entry] should be preferred when possible./// use indexmap::map::raw_entry_v1::RawEntryMut;/// match map.raw_entry_mut_v1().from_key("a") {///         assert_eq!(view.index(), 0);/// let hash = compute_hash(map.hasher(), "c");/// match map.raw_entry_mut_v1().from_key_hashed_nocheck(hash, "c") {///         assert_eq!(view.index(), 2);///         assert_eq!(view.shift_remove_entry(), ("c", 300));/// assert_eq!(map.raw_entry_v1().from_key("c"), None);/// let hash = compute_hash(map.hasher(), key);/// match map.raw_entry_mut_v1().from_hash(hash, |q| *q == key) {/// assert_eq!(map["d"], 40000);///         assert_eq!(view.swap_remove_entry(), ("d", 40000));/// assert_eq!(map.get("d"), None);RawEntryApiV1/// Opt-in access to the experimental raw entry API./// See the [`raw_entry_v1`][self] module documentation for more information./// A builder for computing where in an [`IndexMap`] a key-value pair would be stored./// This `struct` is created by the [`IndexMap::raw_entry_v1`] method, provided by the/// [`RawEntryApiV1`] trait. See its documentation for more./// Access an entry by key./// Access an entry by a key and its hash./// Access an entry by hash.from_hash_full/// Access an entry by hash, including its index.index_from_hash/// Access the index of an entry by hash./// This `struct` is created by the [`IndexMap::raw_entry_mut_v1`] method, provided by the/// Raw entry for an existing key-value pair or a vacant location to/// insert one./// Return the index where the key-value pair exists or may be inserted./// Inserts the given default key and value in the entry if it is vacant and returns mutable/// references to them. Otherwise mutable references to an already existent pair are returned./// Inserts the result of the `call` function in the entry if it is vacant and returns mutable/// A raw view into an occupied entry in an [`IndexMap`]./// Gets a mutable reference to the entry's key in the map./// Converts into a mutable reference to the entry's key in the map,/// [`RawEntryMut`] value, see [`into_mut`][Self::into_mut]./// Gets a reference to the entry's key and value in the map.into_key_value_mut/// Converts into a mutable reference to the entry's key and value in the map,/// Sets the key of the entry, and returns the entry's old key./// This is equivalent to [`IndexMap::move_index`]/// This is equivalent to [`IndexMap::swap_indices`]/// A view into a vacant raw entry in an [`IndexMap`]./// Inserts the given key and value into the map,/// and returns mutable references to them./// Inserts the given key and value into the map with the provided hash,/// Inserts the given key and value into the map at the given index,/// shifting others to the right, and returns mutable references to them.shift_insert_hashed_nocheck/// Inserts the given key and value into the map with the provided hash/// at the given index, and returns mutable references to them.//! Opt-in access to the experimental raw entry API.//! This module is designed to mimic the raw entry API of [`HashMap`][std::collections::hash_map],//! matching its unstable state as of Rust 1.75. See the tracking issue//! [rust#56167](https://github.com/rust-lang/rust/issues/56167) for more details.//! The trait [`RawEntryApiV1`] and the `_v1` suffix on its methods are meant to insulate this for//! the future, in case later breaking changes are needed. If the standard library stabilizes its//! `hash_raw_entry` feature (or some replacement), matching *inherent* methods will be added to//! `IndexMap` without such an opt-in trait.simplify_range/// indices mapping from the entry hash to its index./// entries is a dense vec of entries in their order./// Core of the map that does not depend on Serase_indexMAX_ENTRIES_CAPACITY/// The maximum capacity before the `entries` allocation would exceed `isize::MAX`.split_spliceappend_unchecked/// Append from another map without checking whether items already exist./// Reserve capacity for `additional` more key-value pairs.reserve_entries/// Reserve entries capacity, rounded up to match the indices/// Reserve capacity for `additional` more key-value pairs, without over-allocating./// Try to reserve capacity for `additional` more key-value pairs.try_reserve_entries/// Try to reserve entries capacity, rounded up to match the indicestry_reserve_exact/// Try to reserve capacity for `additional` more key-value pairs, without over-allocating./// Shrink the capacity of the map with a lower bound/// Remove the last key-value pairpush_entry/// Append a key-value pair to `entries`, *without* checking whether it already exists./// Insert a key-value pair in `entries` at a particular index,/// *without* checking whether it already exists.get_index_of/// Return the index in `entries` where an equivalent key can be foundinsert_fullreplace_full/// Same as `insert_full`, except it also replaces the keyshift_insert_uniqueshift_remove_full/// Remove an entry by shifting all entries that follow itshift_remove_indexshift_remove_finish/// The index should already be removed from `self.indices`.decrement_indices/// Decrement all indices in the range `start..end`./// The index `start - 1` should not exist in `self.indices`./// All entries should still be in their original positions.increment_indices/// Increment all indices in the range `start..end`./// The index `end` should not exist in `self.indices`.swap_remove_full/// Remove an entry by swapping it with the lastswap_remove_indexswap_remove_finish/// Finish removing an entry by swapping it with the lasterase_indices/// Erase `start..end` from `indices`, and shift `end..` indices down to `start..`/// All of these items should still be at their original location in `entries`./// This is used by `drain`, which will let `Vec::drain` do the work on `entries`.retain_in_orderrebuild_hash_table//! This is the core implementation that doesn't depend on the hasher at all.//! The methods of `IndexMapCore` don't use any Hash properties of K.//! It's cleaner to separate them out, then the compiler checks that we are not//! using Hash at all in these methods.//! However, we should probably not let this show in the public API or docs./// An iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::iter`] method./// Returns a slice of the remaining entries in the iterator./// A mutable iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::iter_mut`] method./// Returns a mutable slice of the remaining entries in the iterator./// To avoid creating `&mut` references that alias, this is forced to consume the iterator./// An owning iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::into_iter`] method/// A draining iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::drain`] method./// An iterator over the keys of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::keys`] method./// Returns a reference to the key at the supplied `index`./// Access [`IndexMap`] keys at indexed positions./// While [`Index<usize> for IndexMap`][values] accesses a map's values,/// indexing through [`IndexMap::keys`] offers an alternative to access a map's/// keys instead./// [values]: IndexMap#impl-Index<usize>-for-IndexMap<K,+V,+S>/// Since `Keys` is also an iterator, consuming items from the iterator will/// offset the effective indexes. Similarly, if `Keys` is obtained from/// [`Slice::keys`], indexes will be interpreted relative to the position of/// that slice./// use indexmap::IndexMap;/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {///     map.insert(word.to_lowercase(), word.to_uppercase());/// assert_eq!(map[0], "LOREM");/// assert_eq!(map.keys()[0], "lorem");/// assert_eq!(map[1], "IPSUM");/// assert_eq!(map.keys()[1], "ipsum");/// map.reverse();/// assert_eq!(map.keys()[0], "amet");/// assert_eq!(map.keys()[1], "sit");/// map.sort_keys();/// assert_eq!(map.keys()[1], "dolor");/// // Advancing the iterator will offset the indexing/// assert_eq!(keys[0], "amet");/// assert_eq!(keys.next().map(|s| &**s), Some("amet"));/// assert_eq!(keys[0], "dolor");/// assert_eq!(keys[1], "ipsum");/// // Slices may have an offset as well/// let slice = &map[2..];/// assert_eq!(slice[0], "IPSUM");/// assert_eq!(slice.keys()[0], "ipsum");/// map.insert("foo", 1);/// println!("{:?}", map.keys()[10]); // panics!/// An owning iterator over the keys of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::into_keys`] method./// An iterator over the values of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::values`] method./// A mutable iterator over the values of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::values_mut`] method./// An owning iterator over the values of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::into_values`] method.replace_with/// A splicing iterator for `IndexMap`./// This `struct` is created by [`IndexMap::splice()`].get_full_mut2/// Return item index, mutable reference to key and valueget_index_mut2/// Return mutable reference to key and value at an index./// Valid indices are *0 <= index < self.len()*/// Computes in **O(1)** time.retain2/// Scan through each key-value pair in the map and keep those where the/// closure `keep` returns `true`./// The elements are visited in order, and remaining elements keep theirMutableKeys/// Opt-in mutable access to [`IndexMap`] keys./// These methods expose `&mut K`, mutable references to the key as it is stored/// in the map./// You are allowed to modify the keys in the map **if the modification/// does not change the key’s hash and equality**./// If keys are modified erroneously, you can no longer look them up./// This is sound (memory safe) but a logical error hazard (just like/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be)./// `use` this trait to enable its methods for `IndexMap`./// See [`MutableKeys`] for more information.MapSlicecautious_capacitySetSlice/// Serializes a [`map::Slice`][MapSlice] as an ordered sequence./// This behaves like [`crate::map::serde_seq`] for `IndexMap`, serializing a sequence/// of `(key, value)` pairs, rather than as a map that might not preserve order.Se/// Serializes a [`set::Slice`][SetSlice] as an ordered sequence./// Serializes an [`IndexMap`] as an ordered sequence./// This function may be used in a field attribute for deriving [`Serialize`]:/// # use indexmap::IndexMap;///     #[serde(serialize_with = "indexmap::map::serde_seq::serialize")]///     map: IndexMap<i32, u64>,SeqVisitor/// Visitor to deserialize a *sequenced* `IndexMap`/// Deserializes an [`IndexMap`] from an ordered sequence./// This function may be used in a field attribute for deriving [`Deserialize`]:///     #[serde(deserialize_with = "indexmap::map::serde_seq::deserialize")]//! Functions to serialize and deserialize an [`IndexMap`] as an ordered sequence.//! The default `serde` implementation serializes `IndexMap` as a normal map,//! but there is no guarantee that serialization formats will preserve the order//! of the key-value pairs. This module serializes `IndexMap` as a sequence of//! `(key, value)` elements instead, in order.//! This module may be used in a field attribute for derived implementations://! # use indexmap::IndexMap;//! # use serde_derive::{Deserialize, Serialize};//! #[derive(Deserialize, Serialize)]//! struct Data {//!     #[serde(with = "indexmap::map::serde_seq")]//!     map: IndexMap<i32, u64>,try_simplify_range/// A dynamically-sized slice of key-value pairs in an [`IndexMap`]./// This supports indexed operations much like a `[(K, V)]` slice,/// but not any hashed operations on the map keys./// Unlike `IndexMap`, `Slice` does consider the order for [`PartialEq`]/// and [`Eq`], and it also implements [`PartialOrd`], [`Ord`], and [`Hash`].into_boxed// SAFETY: `Slice<K, V>` is a transparent wrapper around `[Bucket<K, V>]`,// and reference lifetimes are bound together in function signatures./// Returns an empty slice./// Returns an empty mutable slice./// Return the number of key-value pairs in the map slice./// Returns true if the map slice contains no elements./// Get a key-value pair by index.get_index_mut/// Get a key-value pair by index, with mutable access to the value./// Returns a slice of key-value pairs in the given range of indices.get_range_mut/// Returns a mutable slice of key-value pairs in the given range of indices./// Get the first key-value pair./// Get the first key-value pair, with mutable access to the value./// Get the last key-value pair./// Get the last key-value pair, with mutable access to the value./// Divides one slice into two at an index./// ***Panics*** if `index > len`./// Divides one mutable slice into two at an index./// Returns the first key-value pair and the rest of the slice,/// or `None` if it is empty./// with mutable access to the value, or `None` if it is empty./// Returns the last key-value pair and the rest of the slice,/// Return an iterator over the key-value pairs of the map slice./// Return an iterator over the keys of the map slice./// Return an owning iterator over the keys of the map slice./// Return an iterator over the values of the map slice./// Return an iterator over mutable references to the the values of the map slice./// Return an owning iterator over the values of the map slice.binary_search_keys/// Search over a sorted map for a key./// Returns the position where that key is present, or the position where it can be inserted to/// maintain the sort. See [`slice::binary_search`] for more details./// Computes in **O(log(n))** time, which is notably less scalable than looking the key up in/// the map this is a slice from using [`IndexMap::get_index_of`], but this can also position/// missing keys.binary_search_by/// Search over a sorted map with a comparator function./// Returns the position where that value is present, or the position where it can be inserted/// to maintain the sort. See [`slice::binary_search_by`] for more details./// Computes in **O(log(n))** time.binary_search_by_key/// Search over a sorted map with an extraction function./// to maintain the sort. See [`slice::binary_search_by_key`] for more details.partition_point/// Returns the index of the partition point of a sorted map according to the given predicate/// (the index of the first element of the second partition)./// See [`slice::partition_point`] for more details.// We can't have `impl<I: RangeBounds<usize>> Index<I>` because that conflicts// both upstream with `Index<usize>` and downstream with `Index<&Q>`.// Instead, we repeat the implementations for all the core range types.slice_indexslice_index_mutinsert_2insert_orderremove_to_emptypartial_eq_and_eqentry_and_modifyentry_or_defaultoccupied_entry_keyget_index_entryiter_defaulttest_binary_search_bytest_binary_search_by_keytest_partition_pointthird/// A hash table where the iteration order of the key-value pairs is independent/// of the hash values of the keys./// The interface is closely compatible with the standard/// [`HashMap`][std::collections::HashMap],/// but also has additional features./// # Order/// The key-value pairs have a consistent order that is determined by/// the sequence of insertion and removal calls on the map. The order does/// not depend on the keys or the hash function at all./// All iterators traverse the map in *the order*./// The insertion order is preserved, with **notable exceptions** like the/// [`.remove()`][Self::remove] or [`.swap_remove()`][Self::swap_remove] methods./// Methods such as [`.sort_by()`][Self::sort_by] of/// course result in a new order, depending on the sorting order./// # Indices/// The key-value pairs are indexed in a compact range without holes in the/// range `0..self.len()`. For example, the method `.get_full` looks up the/// index for a key, and the method `.get_index` looks up the key-value pair by/// // count the frequency of each letter in a sentence./// let mut letters = IndexMap::new();///     *letters.entry(ch).or_insert(0) += 1;/// Create a new map. (Does not allocate.)/// Create a new map with capacity for `n` key-value pairs. (Does not/// allocate if `n` is zero.)/// Computes in **O(n)** time./// Create a new map with `hash_builder`./// This function is `const`, so it/// can be called in `static` contexts./// Return the number of elements the map can hold without reallocating./// This number is a lower bound; the map might be able to hold more,/// but is guaranteed to be able to hold at least this many./// Return a reference to the map's `BuildHasher`./// Return the number of key-value pairs in the map./// Return an iterator over the key-value pairs of the map, in their order/// Return an iterator over the keys of the map, in their order/// Return an owning iterator over the keys of the map, in their order/// Return an iterator over the values of the map, in their order/// Return an iterator over mutable references to the values of the map,/// in their order/// Return an owning iterator over the values of the map, in their order/// Remove all key-value pairs in the map, while preserving its capacity./// Shortens the map, keeping the first `len` elements and dropping the rest./// If `len` is greater than the map's current length, this has no effect./// Clears the `IndexMap` in the given index range, returning those/// key-value pairs as a drain iterator./// The range may be any type that implements [`RangeBounds<usize>`],/// including all of the `std::ops::Range*` types, or even a tuple pair of/// `Bound` start and end values. To drain the map entirely, use `RangeFull`/// like `map.drain(..)`./// This shifts down all entries following the drained range to fill the/// gap, and keeps the allocated memory for reuse./// ***Panics*** if the starting point is greater than the end point or if/// the end point is greater than the length of the map./// Splits the collection into two at the given index./// Returns a newly allocated map containing the elements in the range/// `[at, len)`. After the call, the original map will be left containing/// the elements `[0, at)` with its previous capacity unchanged./// ***Panics*** if `at > len`./// Unlike `reserve`, this does not deliberately over-allocate the entry capacity to avoid/// frequent re-allocations. However, the underlying data structures may still have internal/// capacity requirements, and the allocator itself may give more space than requested, so this/// cannot be relied upon to be precisely minimal./// Unlike `try_reserve`, this does not deliberately over-allocate the entry capacity to avoid/// Shrink the capacity of the map as much as possible./// Shrink the capacity of the map with a lower limit./// Insert a key-value pair in the map./// If an equivalent key already exists in the map: the key remains and/// retains in its place in the order, its corresponding value is updated/// with `value`, and the older value is returned inside `Some(_)`./// If no equivalent key existed in the map: the new key-value pair is/// inserted, last in order, and `None` is returned./// See also [`entry`][Self::entry] if you want to insert *or* modify,/// or [`insert_full`][Self::insert_full] if you need to get the index of/// the corresponding key-value pair./// Insert a key-value pair in the map, and get their index./// with `value`, and the older value is returned inside `(index, Some(_))`./// inserted, last in order, and `(index, None)` is returned./// See also [`entry`][Self::entry] if you want to insert *or* modify./// Insert a key-value pair in the map at its ordered position among sorted keys./// This is equivalent to finding the position with/// [`binary_search_keys`][Self::binary_search_keys], then either updating/// it or calling [`shift_insert`][Self::shift_insert] for a new key./// If the sorted key is found in the map, its corresponding value is/// updated with `value`, and the older value is returned inside/// `(index, Some(_))`. Otherwise, the new key-value pair is inserted at/// the sorted position, and `(index, None)` is returned./// pair is moved to or inserted at that position regardless./// Computes in **O(n)** time (average). Instead of repeating calls to/// `insert_sorted`, it may be faster to call batched [`insert`][Self::insert]/// or [`extend`][Self::extend] and only call [`sort_keys`][Self::sort_keys]/// or [`sort_unstable_keys`][Self::sort_unstable_keys] once./// Insert a key-value pair in the map at the given index./// is moved to the new position in the map, its corresponding value is updated/// inserted at the given index, and `None` is returned./// perhaps only using the index for new entries with [`VacantEntry::shift_insert`]./// Get the given key’s corresponding entry in the map for insertion and/or/// in-place manipulation./// Creates a splicing iterator that replaces the specified range in the map/// with the given `replace_with` key-value iterator and yields the removed/// items. `replace_with` does not need to be the same length as `range`./// The `range` is removed even if the iterator is not consumed until the/// end. It is unspecified how many elements are removed from the map if the/// `Splice` value is leaked./// The input iterator `replace_with` is only consumed when the `Splice`/// value is dropped. If a key from the iterator matches an existing entry/// in the map (outside of `range`), then the value will be updated in that/// position. Otherwise, the new key-value pair will be inserted in the/// replaced `range`./// let mut map = IndexMap::from([(0, '_'), (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);/// let new = [(5, 'E'), (4, 'D'), (3, 'C'), (2, 'B'), (1, 'A')];/// let removed: Vec<_> = map.splice(2..4, new).collect();/// // 1 and 4 got new values, while 5, 3, and 2 were newly inserted./// assert!(map.into_iter().eq([(0, '_'), (1, 'A'), (5, 'E'), (3, 'C'), (2, 'B'), (4, 'D')]));/// assert_eq!(removed, &[(2, 'b'), (3, 'c')]);/// Return `true` if an equivalent to `key` exists in the map./// Return a reference to the value stored for `key`, if it is present,/// else `None`./// Return references to the key-value pair stored for `key`,/// if it is present, else `None`.get_full/// Return item index, key and value/// Return item index, if it exists in the mapget_full_mut/// Remove the key-value pair equivalent to `key` and return/// its value./// **NOTE:** This is equivalent to [`.swap_remove(key)`][Self::swap_remove], replacing this/// [`.shift_remove(key)`][Self::shift_remove] instead./// Remove and return the key-value pair equivalent to `key`./// **NOTE:** This is equivalent to [`.swap_remove_entry(key)`][Self::swap_remove_entry],/// use [`.shift_remove_entry(key)`][Self::shift_remove_entry] instead./// Like [`Vec::swap_remove`], the pair is removed by swapping it with the/// last element of the map and popping it off. **This perturbs/// the position of what used to be the last element!**/// Return `None` if `key` is not in map./// Remove the key-value pair equivalent to `key` and return it and/// the index it had./// Like [`Vec::remove`], the pair is removed by shifting all of the/// This preserves the order of the remaining elements.sort_keys/// Sort the map’s key-value pairs by the default ordering of the keys./// This is a stable sort -- but equivalent keys should not normally coexist in/// a map at all, so [`sort_unstable_keys`][Self::sort_unstable_keys] is preferred/// because it is generally faster and doesn't allocate auxiliary memory./// See [`sort_by`](Self::sort_by) for details./// Sort the map’s key-value pairs in place using the comparison/// function `cmp`./// The comparison function receives two key and value pairs to compare (you/// can sort by keys or values or their combination as needed)./// Computes in **O(n log n + c)** time and **O(n)** space where *n* is/// the length of the map and *c* the capacity. The sort is stable.sorted_by/// Sort the key-value pairs of the map and return a by-value iterator of/// the key-value pairs with the result./// The sort is stable.sort_unstable_keys/// Sort the map's key-value pairs by the default ordering of the keys, but/// may not preserve the order of equal elements./// See [`sort_unstable_by`](Self::sort_unstable_by) for details.sort_unstable_by/// Sort the map's key-value pairs in place using the comparison function `cmp`, but/// Computes in **O(n log n + c)** time where *n* is/// the length of the map and *c* is the capacity. The sort is unstable.sorted_unstable_by/// The sort is unstable.sort_by_cached_key/// Sort the map’s key-value pairs in place using a sort-key extraction function./// During sorting, the function is called at most once per entry, by using temporary storage/// to remember the results of its evaluation. The order of calls to the function is/// unspecified and may change between versions of `indexmap` or the standard library./// Computes in **O(m n + n log n + c)** time () and **O(n)** space, where the function is/// **O(m)**, *n* is the length of the map, and *c* the capacity. The sort is stable./// Computes in **O(log(n))** time, which is notably less scalable than looking the key up/// using [`get_index_of`][IndexMap::get_index_of], but this can also position missing keys./// Reverses the order of the map’s key-value pairs in place./// Computes in **O(n)** time and **O(1)** space./// Returns a slice of all the key-value pairs in the map./// Returns a mutable slice of all the key-value pairs in the map./// Converts into a boxed slice of all the key-value pairs in the map./// Note that this will drop the inner hash table and any excess capacity./// Get a key-value pair by index/// Get an entry in the map by index for in-place manipulation./// Get the first key-value pair/// Get the first key-value pair, with mutable access to the value/// Get the last key-value pair/// Get the last key-value pair, with mutable access to the value/// Remove the key-value pair by index/// Moves the position of a key-value pair from one index to another/// by shifting all other pairs in-between./// * If `from < to`, the other pairs will shift down while the targeted pair moves up./// * If `from > to`, the other pairs will shift up while the targeted pair moves down./// ***Panics*** if `from` or `to` are out of bounds./// Swaps the position of two key-value pairs in the map./// ***Panics*** if `a` or `b` are out of bounds./// Returns a reference to the value corresponding to the supplied `key`./// ***Panics*** if `key` is not present in the map./// Access [`IndexMap`] values corresponding to a key./// assert_eq!(map["lorem"], "LOREM");/// assert_eq!(map["ipsum"], "IPSUM");/// println!("{:?}", map["bar"]); // panics!/// Returns a mutable reference to the value corresponding to the supplied `key`./// Mutable indexing allows changing / updating values of key-value/// pairs that are already present./// You can **not** insert new pairs with index syntax, use `.insert()`.///     map.insert(word.to_lowercase(), word.to_string());/// let lorem = &mut map["lorem"];/// assert_eq!(lorem, "Lorem");/// lorem.retain(char::is_lowercase);/// assert_eq!(map["lorem"], "orem");/// map["bar"] = 1; // panics!/// Returns a reference to the value at the supplied `index`./// Access [`IndexMap`] values at indexed positions./// See [`Index<usize> for Keys`][keys] to access a map's keys instead./// [keys]: Keys#impl-Index<usize>-for-Keys<'a,+K,+V>/// assert_eq!(map[0], "AMET");/// assert_eq!(map[1], "SIT");/// assert_eq!(map[1], "DOLOR");/// println!("{:?}", map[10]); // panics!/// Returns a mutable reference to the value at the supplied `index`./// Mutable indexing allows changing / updating indexed values/// that are already present./// You can **not** insert new values with index syntax -- use [`.insert()`][IndexMap::insert]./// let lorem = &mut map[0];/// map[10] = 1; // panics!/// Create an `IndexMap` from the sequence of key-value pairs in the/// iterable./// `from_iter` uses the same logic as `extend`. See/// [`extend`][IndexMap::extend] for more details./// let map1 = IndexMap::from([(1, 2), (3, 4)]);/// let map2: IndexMap<_, _> = [(1, 2), (3, 4)].into();/// Extend the map with all key-value pairs in the iterable./// This is equivalent to calling [`insert`][IndexMap::insert] for each of/// them in order, which means that for keys that already existed/// in the map, their value is updated but it keeps the existing order./// New keys are inserted in the order they appear in the sequence. If/// equivalents of a key occur more than once, the last corresponding value/// prevails./// See the first extend method for more details./// Return an empty [`IndexMap`]/// A parallel owning iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::into_par_iter`] method/// (provided by rayon's [`IntoParallelIterator`] trait). See its documentation for more.parallel_iterator_methodsindexed_parallel_iterator_methods/// A parallel iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::par_iter`] method/// (provided by rayon's [`IntoParallelRefIterator`] trait). See its documentation for more./// [`IndexMap::par_iter`]: ../struct.IndexMap.html#method.par_iter/// A parallel mutable iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::par_iter_mut`] method/// (provided by rayon's [`IntoParallelRefMutIterator`] trait). See its documentation for more./// [`IndexMap::par_iter_mut`]: ../struct.IndexMap.html#method.par_iter_mutParallelDrainRange/// A parallel draining iterator over the entries of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::par_drain`] method/// (provided by rayon's [`ParallelDrainRange`] trait). See its documentation for more./// [`IndexMap::par_drain`]: ../struct.IndexMap.html#method.par_drain/// Return a parallel iterator over the keys of the map./// While parallel iterators can process items in any order, their relative order/// in the map is still preserved for operations like `reduce` and `collect`./// Return a parallel iterator over the values of the map./// Parallel iterator methods and other parallel methods./// The following methods **require crate feature `"rayon"`**./// See also the `IntoParallelIterator` implementations./// Return a parallel iterator over the keys of the map slice./// in the slice is still preserved for operations like `reduce` and `collect`./// Return a parallel iterator over the values of the map slice./// Returns `true` if `self` contains all of the same key-value pairs as `other`,/// regardless of each map's indexed order, determined in parallel./// A parallel iterator over the keys of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::par_keys`] method./// A parallel iterator over the values of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::par_values`] method./// Return a parallel iterator over mutable references to the values of the map/// Return a parallel iterator over mutable references to the the values of the map slice.par_sort_keys/// Sort the map’s key-value pairs in parallel, by the default ordering of the keys.par_sort_by/// Sort the map’s key-value pairs in place and in parallel, using the comparisonpar_sorted_by/// Sort the key-value pairs of the map in parallel and return a by-value parallel/// iterator of the key-value pairs with the result.par_sort_unstable_keys/// Sort the map's key-value pairs in parallel, by the default ordering of the keys.par_sort_unstable_by/// Sort the map's key-value pairs in place and in parallel, using the comparisonpar_sorted_unstable_bypar_sort_by_cached_key/// Sort the map’s key-value pairs in place and in parallel, using a sort-key extraction/// A parallel mutable iterator over the values of an [`IndexMap`]./// This `struct` is created by the [`IndexMap::par_values_mut`] method.//! Parallel iterator types for [`IndexMap`] with [`rayon`][::rayon].//! You will rarely need to interact with this module directly unless you need to name one of the//! iterator types.// This form of intermediate collection is also how Rayon collects `HashMap`.// Note that the order will also be preserved!/// A parallel owning iterator over the items of an [`IndexSet`]./// This `struct` is created by the [`IndexSet::into_par_iter`] method/// A parallel iterator over the items of an [`IndexSet`]./// This `struct` is created by the [`IndexSet::par_iter`] method/// [`IndexSet::par_iter`]: ../struct.IndexSet.html#method.par_iter/// A parallel draining iterator over the items of an [`IndexSet`]./// This `struct` is created by the [`IndexSet::par_drain`] method/// [`IndexSet::par_drain`]: ../struct.IndexSet.html#method.par_drain/// Return a parallel iterator over the values that are in `self` but not `other`./// in the `self` set is still preserved for operations like `reduce` and `collect`./// Return a parallel iterator over the values that are in `self` or `other`,/// but not in both./// in the sets is still preserved for operations like `reduce` and `collect`./// Values from `self` are produced in their original order, followed by/// values from `other` in their original order./// Return a parallel iterator over the values that are in both `self` and `other`./// Return a parallel iterator over all values that are in `self` or `other`./// values that are unique to `other` in their original order./// Returns `true` if `self` contains all of the same values as `other`,/// regardless of each set's indexed order, determined in parallel./// Returns `true` if `self` has no elements in common with `other`,/// determined in parallel./// Returns `true` if all elements of `other` are contained in `self`,/// Returns `true` if all elements of `self` are contained in `other`,set1set2/// A parallel iterator producing elements in the difference of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::par_difference`] method./// A parallel iterator producing elements in the intersection of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::par_intersection`] method./// A parallel iterator producing elements in the symmetric difference of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::par_symmetric_difference`] method./// A parallel iterator producing elements in the union of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::par_union`] method.par_sort/// Sort the set’s values in parallel by their default ordering./// Sort the set’s values in place and in parallel, using the comparison function `cmp`./// Sort the values of the set in parallel and return a by-value parallel iterator of/// the values with the result.par_sort_unstable/// Sort the set's values in parallel by their default ordering./// Sort the set’s values in place and in parallel, using a key extraction function./// Parallel sorting methods.iter_comparisons//! Parallel iterator types for [`IndexSet`] with [rayon][::rayon].rustc_rayon//! Minimal support for `rustc-rayon`, not intended for general use.MapDeserializer/// Limit our preallocated capacity from a deserializer `size_hint()`./// We do account for the `Bucket` overhead from its saved `hash` field, but we don't count the/// `RawTable` allocation or the fact that its raw capacity will be rounded up to a power of two./// The "max" is an arbitrary choice anyway, not something that needs precise adherence./// This is based on the internal `serde::de::size_hint::cautious(hint)` function.IndexMapVisitorIndexSetVisitorSliceIter/// An iterator over the items of an [`IndexSet`]./// This `struct` is created by the [`IndexSet::iter`] method./// An owning iterator over the items of an [`IndexSet`]./// This `struct` is created by the [`IndexSet::into_iter`] method/// A draining iterator over the items of an [`IndexSet`]./// This `struct` is created by the [`IndexSet::drain`] method./// A lazy iterator producing elements in the difference of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::difference`] method./// A lazy iterator producing elements in the intersection of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::intersection`] method./// A lazy iterator producing elements in the symmetric difference of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::symmetric_difference`] method./// A lazy iterator producing elements in the union of [`IndexSet`]s./// This `struct` is created by the [`IndexSet::union`] method.UnitValue/// A splicing iterator for `IndexSet`./// This `struct` is created by [`IndexSet::splice()`]./// Return item index and mutable reference to the value/// Return mutable reference to the value at an index./// Scan through each value in the set and keep those where the/// The values are visited in order, and remaining values keep their order.MutableValues/// Opt-in mutable access to [`IndexSet`] values./// These methods expose `&mut T`, mutable references to the value as it is stored/// in the set./// You are allowed to modify the values in the set **if the modification/// does not change the value’s hash and equality**./// If values are modified erroneously, you can no longer look them up./// `use` this trait to enable its methods for `IndexSet`./// See [`MutableValues`] for more information./// A dynamically-sized slice of values in an [`IndexSet`]./// This supports indexed operations much like a `[T]` slice,/// but not any hashed operations on the values./// Unlike `IndexSet`, `Slice` does consider the order for [`PartialEq`]// SAFETY: `Slice<T>` is a transparent wrapper around `[Bucket<T>]`,/// Return the number of elements in the set slice./// Returns true if the set slice contains no elements./// Get a value by index./// Returns a slice of values in the given range of indices./// Get the first value./// Get the last value./// Returns the first value and the rest of the slice,/// Returns the last value and the rest of the slice,/// Return an iterator over the values of the set slice.binary_search/// Search over a sorted set for a value./// to maintain the sort. See [`slice::binary_search`] for more details./// Computes in **O(log(n))** time, which is notably less scalable than looking the value up in/// the set this is a slice from using [`IndexSet::get_index_of`], but this can also position/// missing values./// Search over a sorted set with a comparator function./// Search over a sorted set with an extraction function./// Returns the index of the partition point of a sorted set according to the given predicate// We can't have `impl<I: RangeBounds<usize>> Index<I>` because that conflicts with `Index<usize>`.insert_dupreplace_2replace_dupreplace_orderreplace_change/// A hash set where the iteration order of the values is independent of their/// hash values./// [`HashSet`][std::collections::HashSet],/// The values have a consistent order that is determined by the sequence of/// insertion and removal calls on the set. The order does not depend on the/// values or the hash function at all. Note that insertion order and value/// are not affected if a re-insertion is attempted once an element is/// already present./// All iterators traverse the set *in order*.  Set operation iterators like/// [`IndexSet::union`] produce a concatenated order, as do their matching "bitwise"/// operators.  See their documentation for specifics./// The values are indexed in a compact range without holes in the range/// `0..self.len()`. For example, the method `.get_full` looks up the index for/// a value, and the method `.get_index` looks up the value by index./// # Complexity/// Internally, `IndexSet<T, S>` just holds an [`IndexMap<T, (), S>`](IndexMap). Thus the complexity/// of the two are the same for most methods./// use indexmap::IndexSet;/// // Collects which letters appear in a sentence./// let letters: IndexSet<_> = "a short treatise on fungi".chars().collect();/// assert!(letters.contains(&'s'));/// assert!(letters.contains(&'t'));/// assert!(letters.contains(&'u'));/// assert!(!letters.contains(&'y'));/// Create a new set. (Does not allocate.)/// Create a new set with capacity for `n` elements./// (Does not allocate if `n` is zero.)/// Create a new set with `hash_builder`./// Return the number of elements the set can hold without reallocating./// This number is a lower bound; the set might be able to hold more,/// Return a reference to the set's `BuildHasher`./// Return the number of elements in the set./// Returns true if the set contains no elements./// Return an iterator over the values of the set, in their order/// Remove all elements in the set, while preserving its capacity./// Shortens the set, keeping the first `len` elements and dropping the rest./// If `len` is greater than the set's current length, this has no effect./// Clears the `IndexSet` in the given index range, returning those values/// as a drain iterator./// `Bound` start and end values. To drain the set entirely, use `RangeFull`/// like `set.drain(..)`./// the end point is greater than the length of the set./// Returns a newly allocated set containing the elements in the range/// `[at, len)`. After the call, the original set will be left containing/// Reserve capacity for `additional` more values./// Reserve capacity for `additional` more values, without over-allocating./// Try to reserve capacity for `additional` more values./// Try to reserve capacity for `additional` more values, without over-allocating./// Shrink the capacity of the set as much as possible./// Shrink the capacity of the set with a lower limit./// Insert the value into the set./// If an equivalent item already exists in the set, it returns/// `false` leaving the original value in the set and without/// altering its insertion order. Otherwise, it inserts the new/// item and returns `true`./// Insert the value into the set, and get its index./// the index of the existing item and `false`, leaving the/// original value in the set and without altering its insertion/// order. Otherwise, it inserts the new item and returns the index/// of the inserted item and `true`./// Insert the value into the set at its ordered position among sorted values./// [`binary_search`][Self::binary_search], and if needed calling/// [`shift_insert`][Self::shift_insert] for a new value./// If the sorted item is found in the set, it returns the index of that/// existing item and `false`, without any change. Otherwise, it inserts the/// new item and returns its sorted index and `true`./// If the existing items are **not** already sorted, then the insertion/// index is unspecified (like [`slice::binary_search`]), but the value/// is moved to or inserted at that position regardless./// or [`extend`][Self::extend] and only call [`sort`][Self::sort] or/// [`sort_unstable`][Self::sort_unstable] once./// Insert the value into the set at the given index./// `false` leaving the original value in the set, but moving it to/// the new position in the set. Otherwise, it inserts the new/// item at the given index and returns `true`./// Adds a value to the set, replacing the existing value, if any, that is/// equal to the given one, without altering its insertion order. Returns/// the replaced value./// the index of the item and its replaced value./// Return an iterator over the values that are in `self` but not `other`./// Values are produced in the same order that they appear in `self`./// Return an iterator over the values that are in `self` or `other`,/// Return an iterator over the values that are in both `self` and `other`./// Return an iterator over all values that are in `self` or `other`./// Creates a splicing iterator that replaces the specified range in the set/// with the given `replace_with` iterator and yields the removed items./// `replace_with` does not need to be the same length as `range`./// end. It is unspecified how many elements are removed from the set if the/// value is dropped. If a value from the iterator matches an existing entry/// in the set (outside of `range`), then the original will be unchanged./// Otherwise, the new value will be inserted in the replaced `range`./// let mut set = IndexSet::from([0, 1, 2, 3, 4]);/// let new = [5, 4, 3, 2, 1];/// let removed: Vec<_> = set.splice(2..4, new).collect();/// // 1 and 4 kept their positions, while 5, 3, and 2 were newly inserted./// assert!(set.into_iter().eq([0, 1, 5, 3, 2, 4]));/// assert_eq!(removed, &[2, 3]);/// Return `true` if an equivalent to `value` exists in the set./// Return a reference to the value stored in the set, if it is present,/// Return item index and value/// Return item index, if it exists in the set/// Remove the value from the set, and return `true` if it was present./// **NOTE:** This is equivalent to [`.swap_remove(value)`][Self::swap_remove], replacing this/// value's position with the last element, and it is deprecated in favor of calling that/// explicitly. If you need to preserve the relative order of the values in the set, use/// [`.shift_remove(value)`][Self::shift_remove] instead./// Like [`Vec::swap_remove`], the value is removed by swapping it with the/// last element of the set and popping it off. **This perturbs/// Return `false` if `value` was not in the set./// Like [`Vec::remove`], the value is removed by shifting all of the/// Removes and returns the value in the set, if any, that is equal to the/// given one./// **NOTE:** This is equivalent to [`.swap_take(value)`][Self::swap_take], replacing this/// [`.shift_take(value)`][Self::shift_take] instead.swap_take/// Return `None` if `value` was not in the set.shift_take/// Remove the value from the set return it and the index it had./// Remove the last value/// Sort the set’s values by their default ordering./// This is a stable sort -- but equivalent values should not normally coexist in/// a set at all, so [`sort_unstable`][Self::sort_unstable] is preferred/// Sort the set’s values in place using the comparison function `cmp`./// Computes in **O(n log n)** time and **O(n)** space. The sort is stable./// Sort the values of the set and return a by-value iterator ofsort_unstable/// Sort the set's values by their default ordering./// Sort the set's values in place using the comparison function `cmp`./// Computes in **O(n log n)** time. The sort is unstable./// Sort the set’s values in place using a key extraction function./// Computes in **O(log(n))** time, which is notably less scalable than looking the value up/// using [`get_index_of`][IndexSet::get_index_of], but this can also position missing values./// Reverses the order of the set’s values in place./// Returns a slice of all the values in the set./// Converts into a boxed slice of all the values in the set./// Get a value by index/// Get the first value/// Get the last value/// Remove the value by index/// Moves the position of a value from one index to another/// by shifting all other values in-between./// * If `from < to`, the other values will shift down while the targeted value moves up./// * If `from > to`, the other values will shift up while the targeted value moves down./// Swaps the position of two values in the set./// Access [`IndexSet`] values at indexed positions./// let mut set = IndexSet::new();///     set.insert(word.to_string());/// assert_eq!(set[0], "Lorem");/// assert_eq!(set[1], "ipsum");/// set.reverse();/// assert_eq!(set[0], "amet");/// assert_eq!(set[1], "sit");/// set.sort();/// assert_eq!(set[1], "amet");/// set.insert("foo");/// println!("{:?}", set[10]); // panics!/// let set1 = IndexSet::from([1, 2, 3, 4]);/// let set2: IndexSet<_> = [1, 2, 3, 4].into();/// Return an empty [`IndexSet`]/// Returns `true` if all elements of `self` are contained in `other`./// Returns `true` if all elements of `other` are contained in `self`./// Returns the set intersection, cloned into a new set./// Values are collected in the same order that they appear in `self`./// Returns the set union, cloned into a new set./// Values from `self` are collected in their original order, followed by/// Returns the set symmetric-difference, cloned into a new set./// Returns the set difference, cloned into a new set.//! A hash set implemented using [`IndexMap`]fd_guardFdGuardWatchDescriptor/// Iterator over inotify events/// Allows for iteration over the events returned by/// [`Inotify::read_events_blocking`] or [`Inotify::read_events`]./// [`Inotify::read_events_blocking`]: struct.Inotify.html#method.read_events_blocking/// [`Inotify::read_events`]: struct.Inotify.html#method.read_eventswd/// Identifies the watch this event originates from/// This [`WatchDescriptor`] is equal to the one that [`Watches::add`]/// returned when interest for this event was registered. The/// [`WatchDescriptor`] can be used to remove the watch using/// [`Watches::remove`], thereby preventing future events of this type/// from being created./// [`WatchDescriptor`]: struct.WatchDescriptor.html/// [`Watches::add`]: struct.Watches.html#method.add/// [`Watches::remove`]: struct.Watches.html#method.remove/// Indicates what kind of event this is/// Connects related events to each other/// When a file is renamed, this results two events: [`MOVED_FROM`] and/// [`MOVED_TO`]. The `cookie` field will be the same for both of them,/// thereby making is possible to connect the event pair./// [`MOVED_FROM`]: event_mask/constant.MOVED_FROM.html/// [`MOVED_TO`]: event_mask/constant.MOVED_TO.html/// The name of the file the event originates from/// This field is set only if the subject of the event is a file or directory in a/// watched directory. If the event concerns a file or directory that is/// watched directly, `name` will be `None`./// An inotify event/// A file system event that describes a change that the user previously/// registered interest in. To watch for events, call [`Watches::add`]. To/// retrieve events, call [`Inotify::read_events_blocking`] or/// [`Inotify::read_events`].inotify_event/// Create an `Event` from a buffer/// Assumes that a full `inotify_event` plus its name is located at the/// beginning of `buffer`./// Returns the number of bytes used from the buffer, and the event./// Panics if the buffer does not contain a full event, including its name."use `to_owned()` instead; methods named `into_owned()` usually take self by value"EventOwned/// Returns an owned copy of the event."cloning is often expensive and is not expected to have side effects"/// An owned version of `Event`r" Indicates the type of an event"r" This struct can be retrieved from an [`Event`] via its `mask` field."r" You can determine the [`Event`]'s type by comparing the `EventMask` to"r" its associated constants."r" Please refer to the documentation of [`Event`] for a usage example."r" [`Event`]: struct.Event.html"r" File was accessed"r" When watching a directory, this event is only triggered for objects"r" inside the directory, not the directory itself."r" See [`inotify_sys::IN_ACCESS`]."r" [`inotify_sys::IN_ACCESS`]: ../inotify_sys/constant.IN_ACCESS.html"ACCESSr" Metadata (permissions, timestamps, ...) changed"r" When watching a directory, this event can be triggered for the"r" directory itself, as well as objects inside the directory."r" See [`inotify_sys::IN_ATTRIB`]."r" [`inotify_sys::IN_ATTRIB`]: ../inotify_sys/constant.IN_ATTRIB.html"ATTRIBr" File opened for writing was closed"r" See [`inotify_sys::IN_CLOSE_WRITE`]."r" [`inotify_sys::IN_CLOSE_WRITE`]: ../inotify_sys/constant.IN_CLOSE_WRITE.html"CLOSE_WRITEr" File or directory not opened for writing was closed"r" See [`inotify_sys::IN_CLOSE_NOWRITE`]."r" [`inotify_sys::IN_CLOSE_NOWRITE`]: ../inotify_sys/constant.IN_CLOSE_NOWRITE.html"CLOSE_NOWRITEr" File/directory created in watched directory"r" See [`inotify_sys::IN_CREATE`]."r" [`inotify_sys::IN_CREATE`]: ../inotify_sys/constant.IN_CREATE.html"CREATEr" File/directory deleted from watched directory"r" See [`inotify_sys::IN_DELETE`]."r" [`inotify_sys::IN_DELETE`]: ../inotify_sys/constant.IN_DELETE.html"r" Watched file/directory was deleted"r" See [`inotify_sys::IN_DELETE_SELF`]."r" [`inotify_sys::IN_DELETE_SELF`]: ../inotify_sys/constant.IN_DELETE_SELF.html"DELETE_SELFr" File was modified"r" See [`inotify_sys::IN_MODIFY`]."r" [`inotify_sys::IN_MODIFY`]: ../inotify_sys/constant.IN_MODIFY.html"MODIFYr" Watched file/directory was moved"r" See [`inotify_sys::IN_MOVE_SELF`]."r" [`inotify_sys::IN_MOVE_SELF`]: ../inotify_sys/constant.IN_MOVE_SELF.html"MOVE_SELFr" File was renamed/moved; watched directory contained old name"r" See [`inotify_sys::IN_MOVED_FROM`]."r" [`inotify_sys::IN_MOVED_FROM`]: ../inotify_sys/constant.IN_MOVED_FROM.html"MOVED_FROMr" File was renamed/moved; watched directory contains new name"r" See [`inotify_sys::IN_MOVED_TO`]."r" [`inotify_sys::IN_MOVED_TO`]: ../inotify_sys/constant.IN_MOVED_TO.html"MOVED_TOr" File or directory was opened"r" See [`inotify_sys::IN_OPEN`]."r" [`inotify_sys::IN_OPEN`]: ../inotify_sys/constant.IN_OPEN.html"r" Watch was removed"r" This event will be generated, if the watch was removed explicitly"r" (via [`Watches::remove`]), or automatically (because the file was"r" deleted or the file system was unmounted)."r" See [`inotify_sys::IN_IGNORED`]."r" [`inotify_sys::IN_IGNORED`]: ../inotify_sys/constant.IN_IGNORED.html"r" Event related to a directory"r" The subject of the event is a directory."r" See [`inotify_sys::IN_ISDIR`]."r" [`inotify_sys::IN_ISDIR`]: ../inotify_sys/constant.IN_ISDIR.html"ISDIRr" Event queue overflowed"r" The event queue has overflowed and events have presumably been lost."r" See [`inotify_sys::IN_Q_OVERFLOW`]."r" [`inotify_sys::IN_Q_OVERFLOW`]: ../inotify_sys/constant.IN_Q_OVERFLOW.html"Q_OVERFLOWr" File system containing watched object was unmounted."r" File system was unmounted"r" The file system that contained the watched object has been"r" unmounted. An event with [`WatchMask::IGNORED`] will subsequently be"r" generated for the same watch descriptor."r" See [`inotify_sys::IN_UNMOUNT`]."r" [`WatchMask::IGNORED`]: #associatedconstant.IGNORED"r" [`inotify_sys::IN_UNMOUNT`]: ../inotify_sys/constant.IN_UNMOUNT.html"UNMOUNTfrom_buffer_should_not_mistake_next_event_for_name_of_previous_event/// A RAII guard around a `RawFd` that closes it automatically on drop.should_not_close/// Indicate that the wrapped file descriptor should _not_ be closed/// when the guard is dropped./// This should be called in cases where ownership of the wrapped file/// descriptor has been "moved" out of the guard./// This is factored out into a separate function to ensure that it's/// always used consistently.F_GETFLF_SETFLWatchMaskWatchesInotify/// Idiomatic Rust wrapper around Linux's inotify API/// `Inotify` is a wrapper around an inotify instance. It generally tries to/// adhere to the underlying inotify API closely, while making access to it/// safe and convenient./// Please refer to the [top-level documentation] for further details and a/// usage example./// [top-level documentation]: index.html/// Creates an [`Inotify`] instance/// Initializes an inotify instance by calling [`inotify_init1`]./// This method passes both flags accepted by [`inotify_init1`], not giving/// the user any choice in the matter, as not passing the flags would be/// inappropriate in the context of this wrapper:/// - [`IN_CLOEXEC`] prevents leaking file descriptors to other processes./// - [`IN_NONBLOCK`] controls the blocking behavior of the inotify API,///   which is entirely managed by this wrapper./// Directly returns the error from the call to [`inotify_init1`], without/// adding any error conditions of its own./// use inotify::Inotify;/// let inotify = Inotify::init()///     .expect("Failed to initialize an inotify instance");/// [`Inotify`]: struct.Inotify.html/// [`inotify_init1`]: ../inotify_sys/fn.inotify_init1.html/// [`IN_CLOEXEC`]: ../inotify_sys/constant.IN_CLOEXEC.html/// [`IN_NONBLOCK`]: ../inotify_sys/constant.IN_NONBLOCK.html/// Gets an interface that allows adding and removing watches./// See [`Watches::add`] and [`Watches::remove`]."use `Inotify.watches().add()` instead"/// Deprecated: use `Inotify.watches().add()` instead"use `Inotify.watches().remove()` instead"rm_watch/// Deprecated: use `Inotify.watches().remove()` insteadread_events_blocking/// Waits until events are available, then returns them/// Blocks the current thread until at least one event is available. If this/// is not desirable, please consider [`Inotify::read_events`]./// This method calls [`Inotify::read_events`] internally and behaves/// essentially the same, apart from the blocking behavior. Please refer to/// the documentation of [`Inotify::read_events`] for more information./// [`read`]: ../libc/fn.read.htmlread_events/// Returns one buffer's worth of available events/// Reads as many events as possible into `buffer`, and returns an iterator/// over them. If no events are available, an iterator is still returned. If/// you need a method that will block until at least one event is available,/// please consider [`read_events_blocking`]./// Please note that inotify will merge identical successive unread events /// into a single event. This means this method can not be used to count the /// number of file system events./// The `buffer` argument, as the name indicates, is used as a buffer for/// the inotify events. Its contents may be overwritten./// This function directly returns all errors from the call to [`read`]./// In addition, [`ErrorKind::UnexpectedEof`] is returned, if the call to/// [`read`] returns `0`, signaling end-of-file./// If `buffer` is too small, this will result in an error with/// [`ErrorKind::InvalidInput`]. On very old Linux kernels,/// [`ErrorKind::UnexpectedEof`] will be returned instead./// use std::io::ErrorKind;/// let mut inotify = Inotify::init()/// let mut buffer = [0; 1024];/// let events = loop {///     match inotify.read_events(&mut buffer) {///         Ok(events) => break events,///         Err(error) if error.kind() == ErrorKind::WouldBlock => continue,///         _ => panic!("Error while reading events"),/// for event in events {///     // Handle event/// [`read_events_blocking`]: struct.Inotify.html#method.read_events_blocking/// [`ErrorKind::UnexpectedEof`]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html#variant.UnexpectedEof/// [`ErrorKind::InvalidInput`]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html#variant.InvalidInput/// Closes the inotify instance/// Closes the file descriptor referring to the inotify instance. The user/// usually doesn't have to call this function, as the underlying inotify/// instance is closed automatically, when [`Inotify`] is dropped./// Directly returns the error from the call to [`close`], without adding any/// error conditions of its own./// inotify.close()///     .expect("Failed to close inotify instance");/// [`close`]: ../libc/fn.close.htmlget_buffer_sizeget_absolute_path_buffer_size//! Idiomatic inotify wrapper for the Rust programming language//! # About//! [inotify-rs] is an idiomatic wrapper around the Linux kernel's [inotify] API//! for the Rust programming language. It can be used for monitoring changes to//! files or directories.//! The [`Inotify`] struct is the main entry point into the API.//! use inotify::{//!     Inotify,//!     WatchMask,//! let mut inotify = Inotify::init()//!     .expect("Error while initializing inotify instance");//! # // Create a temporary file, so `Watches::add` won't return an error.//! # use std::fs::File;//! # let mut test_file = File::create("/tmp/inotify-rs-test-file")//! #     .expect("Failed to create test file");//! // Watch for modify and close events.//! inotify//!     .watches()//!     .add(//!         "/tmp/inotify-rs-test-file",//!         WatchMask::MODIFY | WatchMask::CLOSE,//!     .expect("Failed to add file watch");//! # // Modify file, so the following `read_events_blocking` won't block.//! # write!(&mut test_file, "something\n")//! #     .expect("Failed to write something to test file");//! // Read events that were added with `Watches::add` above.//! let mut buffer = [0; 1024];//! let events = inotify.read_events_blocking(&mut buffer)//!     .expect("Error while reading events");//! for event in events {//!     // Handle event//! # Attention: inotify gotchas//! inotify (as in, the Linux API, not this wrapper) has many edge cases, making//! it hard to use correctly. This can lead to weird and hard to find bugs in//! applications that are based on it. inotify-rs does its best to fix these//! issues, but sometimes this would require an amount of runtime overhead that//! is just unacceptable for a low-level wrapper such as this.//! We've documented any issues that inotify-rs has inherited from inotify, as//! far as we are aware of them. Please watch out for any further warnings//! throughout this documentation. If you want to be on the safe side, in case//! we have missed something, please read the [inotify man pages] carefully.//! [inotify-rs]: https://crates.io/crates/inotify//! [inotify]: https://en.wikipedia.org/wiki/Inotify//! [`Inotify`]: struct.Inotify.html//! [inotify man pages]: http://man7.org/linux/man-pages/man7/inotify.7.htmlAsyncFdArcFdGuardunused_bytesEventStream/// Stream of inotify events/// Allows for streaming events returned by [`Inotify::into_event_stream`]./// [`Inotify::into_event_stream`]: struct.Inotify.html#method.into_event_stream/// Returns a new `EventStream` associated with the default reactor./// Returns an instance of `Watches` to add and remove watches.into_inotify/// Consumes the `EventStream` instance and returns an `Inotify` using the original/// file descriptor that was passed from `Inotify` to create the `EventStream`.// Newtype wrapper because AsRawFd isn't implemented for Arc<T> where T: AsRawFd.INOTIFY_EVENT_SIZE/// Get the inotify event buffer size/// The maximum size of an inotify event and thus the buffer size to hold it/// can be calculated using this formula:/// `sizeof(struct inotify_event) + NAME_MAX + 1`/// See: [https://man7.org/linux/man-pages/man7/inotify.7.html](https://man7.org/linux/man-pages/man7/inotify.7.html)/// The NAME_MAX size formula is:/// `ABSOLUTE_PARENT_PATH_LEN + 1 + 255`/// - `ABSOLUTE_PARENT_PATH_LEN` will be calculated at runtime./// - Add 1 to account for a `/`, either in between the parent path and a filename/// or for the root directory./// - Add the maximum number of chars in a filename, 255./// See: [https://github.com/torvalds/linux/blob/master/include/uapi/linux/limits.h](https://github.com/torvalds/linux/blob/master/include/uapi/linux/limits.h)/// Unfortunately, we can't just do the same with max path length itself./// See: [https://eklitzke.org/path-max-is-tricky](https://eklitzke.org/path-max-is-tricky)/// This function is really just a fallible wrapper around `get_absolute_path_buffer_size()`./// path: A relative or absolute path for the inotify events./// Get the inotify event buffer size for an absolute path/// For relative paths, consider using `get_buffer_size()` which provides a fallible wrapper/// for this function./// path: An absolute path for the inotify events.r" Describes a file system watch"r" Passed to [`Watches::add`], to describe what file system events"r" to watch for, and how to do that."r" `WatchMask` constants can be passed to [`Watches::add`] as is. For"r" example, here's how to create a watch that triggers an event when a file"r" is accessed:"r" ``` rust"r" # use inotify::{"r" #     Inotify,"r" #     WatchMask,"r" # };"r" # let mut inotify = Inotify::init().unwrap();"r" # // Create a temporary file, so `Watches::add` won't return an error."r" # use std::fs::File;"r#" # File::create("/tmp/inotify-rs-test-file")"#r#" #     .expect("Failed to create test file");"#r#" inotify.watches().add("/tmp/inotify-rs-test-file", WatchMask::ACCESS)"#r#"    .expect("Error adding watch");"#r" You can also combine multiple `WatchMask` constants. Here we add a watch"r" this is triggered both when files are created or deleted in a directory:"r#" inotify.watches().add("/tmp/", WatchMask::CREATE | WatchMask::DELETE)"#r" [`Watches::add`]: struct.Watches.html#method.add"r" Watch for all events"r" This constant is simply a convenient combination of the following"r" other constants:"r" - [`ACCESS`]"r" - [`ATTRIB`]"r" - [`CLOSE_WRITE`]"r" - [`CLOSE_NOWRITE`]"r" - [`CREATE`]"r" - [`DELETE`]"r" - [`DELETE_SELF`]"r" - [`MODIFY`]"r" - [`MOVE_SELF`]"r" - [`MOVED_FROM`]"r" - [`MOVED_TO`]"r" - [`OPEN`]"r" See [`inotify_sys::IN_ALL_EVENTS`]."r" [`ACCESS`]: #associatedconstant.ACCESS"r" [`ATTRIB`]: #associatedconstant.ATTRIB"r" [`CLOSE_WRITE`]: #associatedconstant.CLOSE_WRITE"r" [`CLOSE_NOWRITE`]: #associatedconstant.CLOSE_NOWRITE"r" [`CREATE`]: #associatedconstant.CREATE"r" [`DELETE`]: #associatedconstant.DELETE"r" [`DELETE_SELF`]: #associatedconstant.DELETE_SELF"r" [`MODIFY`]: #associatedconstant.MODIFY"r" [`MOVE_SELF`]: #associatedconstant.MOVE_SELF"r" [`MOVED_FROM`]: #associatedconstant.MOVED_FROM"r" [`MOVED_TO`]: #associatedconstant.MOVED_TO"r" [`OPEN`]: #associatedconstant.OPEN"r" [`inotify_sys::IN_ALL_EVENTS`]: ../inotify_sys/constant.IN_ALL_EVENTS.html"ALL_EVENTSr" Watch for all move events"r" See [`inotify_sys::IN_MOVE`]."r" [`inotify_sys::IN_MOVE`]: ../inotify_sys/constant.IN_MOVE.html"r" Watch for all close events"r" See [`inotify_sys::IN_CLOSE`]."r" [`inotify_sys::IN_CLOSE`]: ../inotify_sys/constant.IN_CLOSE.html"r" Don't dereference the path if it is a symbolic link"r" See [`inotify_sys::IN_DONT_FOLLOW`]."r" [`inotify_sys::IN_DONT_FOLLOW`]: ../inotify_sys/constant.IN_DONT_FOLLOW.html"DONT_FOLLOWr" Filter events for directory entries that have been unlinked"r" See [`inotify_sys::IN_EXCL_UNLINK`]."r" [`inotify_sys::IN_EXCL_UNLINK`]: ../inotify_sys/constant.IN_EXCL_UNLINK.html"EXCL_UNLINKr" If a watch for the inode exists, amend it instead of replacing it"r" See [`inotify_sys::IN_MASK_ADD`]."r" [`inotify_sys::IN_MASK_ADD`]: ../inotify_sys/constant.IN_MASK_ADD.html"MASK_ADDr" Only receive one event, then remove the watch"r" See [`inotify_sys::IN_ONESHOT`]."r" [`inotify_sys::IN_ONESHOT`]: ../inotify_sys/constant.IN_ONESHOT.html"ONESHOTr" Only watch path, if it is a directory"r" See [`inotify_sys::IN_ONLYDIR`]."r" [`inotify_sys::IN_ONLYDIR`]: ../inotify_sys/constant.IN_ONLYDIR.html"ONLYDIRget_watch_descriptor_id/// Getter method for a watcher's id./// Can be used to distinguish events for files with the same name./// Interface for adding and removing watches/// Init watches with an inotify file descriptor/// Adds or updates a watch for the given path/// Adds a new watch or updates an existing one for the file referred to by/// `path`. Returns a watch descriptor that can be used to refer to this/// watch later./// The `mask` argument defines what kind of changes the file should be/// watched for, and how to do that. See the documentation of [`WatchMask`]/// If this method is used to add a new watch, a new [`WatchDescriptor`] is/// returned. If it is used to update an existing watch, a/// [`WatchDescriptor`] that equals the previously returned/// [`WatchDescriptor`] for that watch is returned instead./// Under the hood, this method just calls [`inotify_add_watch`] and does/// some trivial translation between the types on the Rust side and the C/// side./// # Attention: Updating watches and hardlinks/// As mentioned above, this method can be used to update an existing watch./// This is usually done by calling this method with the same `path`/// argument that it has been called with before. But less obviously, it can/// also happen if the method is called with a different path that happens/// to link to the same inode./// You can detect this by keeping track of [`WatchDescriptor`]s and the/// paths they have been returned for. If the same [`WatchDescriptor`] is/// returned for a different path (and you haven't freed the/// [`WatchDescriptor`] by removing the watch), you know you have two paths/// pointing to the same inode, being watched by the same watch./// Directly returns the error from the call to/// [`inotify_add_watch`][`inotify_add_watch`] (translated into an/// `io::Error`), without adding any error conditions of/// its own./// use inotify::{///     Inotify,///     WatchMask,/// # // Create a temporary file, so `Watches::add` won't return an error./// # use std::fs::File;/// # File::create("/tmp/inotify-rs-test-file")/// #     .expect("Failed to create test file");/// inotify.watches().add("/tmp/inotify-rs-test-file", WatchMask::MODIFY)///     .expect("Failed to add file watch");/// // Handle events for the file here/// [`inotify_add_watch`]: ../inotify_sys/fn.inotify_add_watch.html/// [`WatchMask`]: struct.WatchMask.html/// Stops watching a file/// Removes the watch represented by the provided [`WatchDescriptor`] by/// calling [`inotify_rm_watch`]. [`WatchDescriptor`]s can be obtained via/// [`Watches::add`], or from the `wd` field of [`Event`]./// Directly returns the error from the call to [`inotify_rm_watch`]./// Returns an [`io::Error`] with [`ErrorKind`]`::InvalidInput`, if the given/// [`WatchDescriptor`] did not originate from this [`Inotify`] instance./// # let mut test_file = File::create("/tmp/inotify-rs-test-file")/// # // Add a watch and modify the file, so the code below doesn't block/// # // forever./// # use inotify::WatchMask;/// # inotify.watches().add("/tmp/inotify-rs-test-file", WatchMask::MODIFY)/// #     .expect("Failed to add file watch");/// # write!(&mut test_file, "something\n")/// #     .expect("Failed to write something to test file");/// let events = inotify///     .read_events_blocking(&mut buffer)///     .expect("Error while waiting for events");/// let mut watches = inotify.watches();///     watches.remove(event.wd);/// [`inotify_rm_watch`]: ../inotify_sys/fn.inotify_rm_watch.html/// [`Event`]: struct.Event.html/// [`io::Error`]: https://doc.rust-lang.org/std/io/struct.Error.html/// [`ErrorKind`]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html/// Represents a watch on an inode/// Can be obtained from [`Watches::add`] or from an [`Event`]. A watch/// descriptor can be used to get inotify to stop watching an inode by passing/// it to [`Watches::remove`].IN_CLOEXEC/// Set the `FD_CLOEXEC` flag for an inotify instance/// Can be passed to [`inotify_init1`] to set the `FD_CLOEXEC` flag for the/// inotify instance. This changes the behavior of file descriptor when/// [execve(2)]'d. From [fcntl(2)]:/// > If the FD_CLOEXEC bit is 0, the file descriptor will/// > remain open across an [execve(2)], otherwise it will be/// > closed./// See [open(2)] and [fcntl(2)] for details./// [`inotify_init1`]: fn.inotify_init1.html/// [execve(2)]: http://man7.org/linux/man-pages/man2/execve.2.html/// [open(2)]: http://man7.org/linux/man-pages/man2/open.2.html/// [fcntl(2)]: http://man7.org/linux/man-pages/man2/fcntl.2.htmlIN_NONBLOCK/// Set an inotify instance to non-blocking mode/// Can be passed to [`inotify_init1`] to set the `O_NONBLOCK` flag for the/// inotify instance./// See [open(2)] for details.IN_ACCESS/// Event: File was accessed/// This constant can be passed to [`inotify_add_watch`], to register interest/// in this type of event, or it can be used to check (via [`inotify_event`]'s/// [`mask`] field) whether an event is of this type./// When monitoring a directory, this event will be triggered only for files/// within the directory./// See [man page] for additional details./// [`inotify_add_watch`]: fn.inotify_add_watch.html/// [`inotify_event`]: struct.inotify_event.html/// [`mask`]: struct.inotify_event.html#structfield.mask/// [man page]: http://man7.org/linux/man-pages/man7/inotify.7.htmlIN_MODIFY/// Event: File was modifiedIN_ATTRIB/// Event: Metadata was changed/// This can include e.g./// - permissions, see [chmod(2)];/// - timestamps, see [utimensat(2)];/// - extended attributes, see [setxattr(2)];/// - link count, see [link(2)] and [unlink(2)];/// - user/group, see [chown(2)]./// When monitoring a directory, this event can be triggered for both for the/// directory itself and the files within./// [chmod(2)]: http://man7.org/linux/man-pages/man2/chmod.2.html/// [utimensat(2)]: http://man7.org/linux/man-pages/man2/utimensat.2.html/// [setxattr(2)]: http://man7.org/linux/man-pages/man2/fsetxattr.2.html/// [link(2)]: http://man7.org/linux/man-pages/man2/link.2.html/// [unlink(2)]: http://man7.org/linux/man-pages/man2/unlink.2.html/// [chown(2)]: http://man7.org/linux/man-pages/man2/chown.2.htmlIN_CLOSE_WRITE/// Event: Writable file was closedIN_CLOSE_NOWRITE/// Event: Non-writable file or directory was closedIN_OPEN/// Event: File or directory was openedIN_MOVED_FROM/// Event: File or directory was moved out of watched directoryIN_MOVED_TO/// Event: File or directory was moved into watched directoryIN_CREATE/// Event: File or directory was created in watched directory/// This may also include hard links, symlinks, and UNIX sockets.IN_DELETE/// Event: File or directory in watched directory was deletedIN_DELETE_SELF/// Event: Watched file or directory was deleted/// This may also occur if the object is moved to another filesystem, since/// [mv(1)] in effect copies the file to the other filesystem and then deletes/// it from the original./// An IN_IGNORED event will subsequently be generated./// [mv(1)]: http://man7.org/linux/man-pages/man1/mv.1.htmlIN_MOVE_SELF/// Event: Watched file or directory was movedIN_MOVE/// Event: File or directory within watched directory was moved/// This is a combination of [`IN_MOVED_FROM`] and [`IN_MOVED_TO`]./// [`IN_MOVED_FROM`]: constant.IN_MOVED_FROM.html/// [`IN_MOVED_TO`]: constant.IN_MOVED_TO.htmlIN_CLOSE/// Event: File was closed/// This is a combination of [`IN_CLOSE_WRITE`] and [`IN_CLOSE_NOWRITE`]./// [`IN_CLOSE_WRITE`]: constant.IN_CLOSE_WRITE.html/// [`IN_CLOSE_NOWRITE`]: constant.IN_CLOSE_NOWRITE.htmlIN_ALL_EVENTS/// Event: Any event occured/// This is a combination of all the other event constants:/// - [`IN_ACCESS`]/// - [`IN_ATTRIB`]/// - [`IN_CLOSE_WRITE`]/// - [`IN_CLOSE_NOWRITE`]/// - [`IN_MODIFY`]/// - [`IN_CREATE`]/// - [`IN_DELETE`]/// - [`IN_DELETE_SELF`]/// - [`IN_MOVE_SELF`]/// - [`IN_MOVED_FROM`]/// - [`IN_MOVED_TO`]/// - [`IN_OPEN`]/// in any type of event./// [`IN_ACCESS`]: constant.IN_ACCESS.html/// [`IN_ATTRIB`]: constant.IN_ATTRIB.html/// [`IN_MODIFY`]: constant.IN_MODIFY.html/// [`IN_CREATE`]: constant.IN_CREATE.html/// [`IN_DELETE`]: constant.IN_DELETE.html/// [`IN_DELETE_SELF`]: constant.IN_DELETE_SELF.html/// [`IN_MOVE_SELF`]: constant.IN_MOVE_SELF.html/// [`IN_OPEN`]: constant.IN_OPEN.htmlIN_ONLYDIR/// Only watch path, if it is a directory/// This bit can be set in [`inotify_add_watch`]'s `mask` parameter, to/// configure the watch.IN_DONT_FOLLOW/// Don't dereference path, if it is a symbolic linkIN_EXCL_UNLINK/// Ignore events for children, that have been unlinked from watched directoryIN_MASK_ADD/// Update existing watch mask, instead of replacing itIN_ONESHOT/// Remove watch after one eventIN_ISDIR/// Indicates that the subject of an event is a directory/// This constant can be used to check against the [`mask`] field in/// [`inotify_event`].IN_UNMOUNT/// Indicates that file system containing a watched object has been unmounted/// An [`IN_IGNORED`] event will be generated subsequently./// [`IN_IGNORED`]: constant.IN_IGNORED.htmlIN_Q_OVERFLOW/// Indicates that the event queue has overflowedIN_IGNORED/// Indicates that a file system watch was removed/// This can occur as a result of [`inotify_rm_watch`], because a watched item///  was deleted, the containing filesystem was unmounted, or after a/// [`IN_ONESHOT`] watch is complete./// [`inotify_rm_watch`]: fn.inotify_rm_watch.html/// [`IN_ONESHOT`]: constant.IN_ONESHOT.html/// Identifies the watch for which this event occurs/// This is one of the watch descriptors returned by a previous call to/// [`inotify_add_watch()`]./// [`inotify_add_watch()`]: fn.inotify_add_watch.html/// Describes the type file system event/// One of the following bits will be set, to identify the type of event:/// - [`IN_IGNORED`]/// - [`IN_Q_OVERFLOW`]/// - [`IN_UNMOUNT`]/// Some constants cover multiple bits, and can be used for a less precise/// check of the event type:/// - [`IN_CLOSE`]/// - [`IN_MOVE`]/// In addition, the [`IN_ISDIR`] bit can be set./// [`IN_CLOSE`]: constant.IN_CLOSE.html/// [`IN_ISDIR`]: constant.IN_ISDIR.html/// [`IN_MOVE`]: constant.IN_MOVE.html/// [`IN_Q_OVERFLOW`]: constant.IN_Q_OVERFLOW.html/// [`IN_UNMOUNT`]: constant.IN_UNMOUNT.html/// A number that connects related events/// Currently used only for rename events. A related pair of/// [`IN_MOVED_FROM`] and [`IN_MOVED_TO`] events will have the same,/// non-zero, cookie. For all other events, cookie is 0./// The length of `name`/// Used to determine the size of this structure. When `name`/// isn't present (`name` is only present when an event occurs/// for a file inside a watched directory), it is 0. When `name`/// *is* present, it counts all of `name`'s bytes, including `\0`./// > The `name` field is present only when an event is returned for/// > a file inside a watched directory; it identifies the file/// > pathname relative to the watched directory. This pathname is/// > null-terminated, and may include further null bytes ('\0') to/// > align subsequent reads to a suitable address boundary./// The `name` field has been ommited in this struct's definition./// Describes a file system event/// From [inotify(7)]:/// > To determine what events have occurred, an application [read(2)]s/// > from the inotify file descriptor.  If no events have so far occurred,/// > then, assuming a blocking file descriptor, [read(2)] will block until/// > at least one event occurs (unless interrupted by a signal, in which/// > case the call fails with the error EINTR; see [signal(7)])./// > Each successful [read(2)] returns a buffer containing one or more of/// > this structure./// [inotify(7)]: http://man7.org/linux/man-pages/man7/inotify.7.html/// [read(2)]: http://man7.org/linux/man-pages/man2/read.2.html/// [signal(7)]: http://man7.org/linux/man-pages/man7/signal.7.htmlinotify_init/// Creates an inotify instance/// If you need more flexibility, consider using [`inotify_init1`] instead./// Returns `-1`, if an error occured, or an inotify file descriptor/// Please refer to the [man page] for additional details./// [man page]: http://man7.org/linux/man-pages/man2/inotify_init.2.htmlinotify_init1/// Takes an argument to configure the new inotify instance. The following/// flags can be set:/// - [`IN_CLOEXEC`]/// - [`IN_NONBLOCK`]/// [`IN_CLOEXEC`]: constant.IN_CLOEXEC.html/// [`IN_NONBLOCK`]: constant.IN_NONBLOCK.html/// [man page]: http://man7.org/linux/man-pages/man2/inotify_init1.2.htmlinotify_add_watch/// Adds or updates an inotify watch/// Adds an item to the watch list of an inotify instance, or modifies an/// item on that list. This function takes the following arguments:/// - `fd` is the file descriptor of the inotify instance (created by///   [`inotify_init`] or [`inotify_init1`])/// - `pathname` is the path of the file or directory watch/// - `mask` defines the behavior of this function and configures the watch/// The following flags in `mask` control the type of events to watch for:/// The following constants can be used as shortcuts to set multiple event/// flags:/// - [`IN_ALL_EVENTS`]/// In addition, the following flags can be set to control the behaviors of/// the watch and this function:/// - [`IN_DONT_FOLLOW`]/// - [`IN_EXCL_UNLINK`]/// - [`IN_MASK_ADD`]/// - [`IN_ONESHOT`]/// - [`IN_ONLYDIR`]/// The function returns `-1` if an error occured. Otherwise, it returns a/// watch descriptor that can be used to remove the watch using/// [`inotify_rm_watch`] or identify the watch via [`inotify_event`]'s [wd`]/// [`inotify_init`]: fn.inotify_init.html/// [`IN_ALL_EVENTS`]: constant.IN_ALL_EVENTS.html/// [`IN_DONT_FOLLOW`]: constant.IN_DONT_FOLLOW.html/// [`IN_EXCL_UNLINK`]: constant.IN_EXCL_UNLINK.html/// [`IN_MASK_ADD`]: constant.IN_MASK_ADD.html/// [`IN_ONLYDIR`]: constant.IN_ONLYDIR.html/// [`wd`]: struct.inotify_event.html#structfield.wd/// [man page]: http://man7.org/linux/man-pages/man2/inotify_add_watch.2.htmlinotify_rm_watch/// Removes an inotify watch/// Removes an item from the watch list of an inotify instance. The inotify/// instance is identified by the `fd` argument. The watch is identified by/// the `wd` argument./// Returns `0` on success, `-1` on failure./// [man page]: http://man7.org/linux/man-pages/man2/inotify_rm_watch.2.html//! # inotify bindings for the Rust programming language//! Please note that these are direct, low-level bindings to C functions that//! form the inotify C API. Unless you have a specific reason to use this crate,//! [inotify-rs], which is an idiomatic wrapper, is a much better choice.//! In general, inotify usage follows the following pattern://! 1. Create an inotify instance using [`inotify_init`] or [`inotify_init1`].//! 2. Manage watches with [`inotify_add_watch`] and [`inotify_rm_watch`].//! 3. Read event using [`read`].//! 4. Close the inotify instance using [`close`], once you're done.//! Please refer to the [inotify man page] and the rest of this documentation//! for full details.//! [`inotify_init`]: fn.inotify_init.html//! [`inotify_init1`]: fn.inotify_init1.html//! [`inotify_add_watch`]: fn.inotify_add_watch.html//! [`inotify_rm_watch`]: fn.inotify_rm_watch.html//! [`read`]: fn.read.html//! [`close`]: fn.close.html//! [inotify man page]: http://man7.org/linux/man-pages/man7/inotify.7.htmlIntoArrayError/// The error returned when slice can not be converted into array./// The error returned when input and output slices have different length/// and thus can not be converted to `InOutBuf`./// Padding error. Usually emitted when size of output buffer is insufficient.OutIsTooSmallError/// Output buffer is smaller than input buffer.in_ptrout_ptr/// Custom pointer type which contains one immutable (input) and one mutable/// (output) pointer, which are either equal or non-overlapping./// Reborrow `self`.get_in/// Get immutable reference to the input value.get_out/// Get mutable reference to the output value./// Convert `self` to a pair of raw input and output pointers./// Create `InOut` from raw input and output pointers./// - `in_ptr` must point to a properly initialized value of type `T` and/// must be valid for reads./// - `out_ptr` must point to a properly initialized value of type `T` and/// must be valid for both reads and writes./// - `in_ptr` and `out_ptr` must be either equal or non-overlapping./// - If `in_ptr` and `out_ptr` are equal, then the memory referenced by/// them must not be accessed through any other pointer (not derived from/// the return value) for the duration of lifetime 'a. Both read and write/// accesses are forbidden./// - If `in_ptr` and `out_ptr` are not equal, then the memory referenced by/// `out_ptr` must not be accessed through any other pointer (not derived from/// the return value) for the duration of lifetime `'a`. Both read and write/// accesses are forbidden. The memory referenced by `in_ptr` must not be/// mutated for the duration of lifetime `'a`, except inside an `UnsafeCell`.clone_in/// Clone input value and return it./// Returns `InOut` for the given position./// If `pos` greater or equal to array length.into_buf/// Convert `InOut` array to `InOutBuf`.xor_in2out/// XOR `data` with values behind the input slice and write/// result to the output slice./// If `data` length is not equal to the buffer length./// Custom slice type which references one immutable (input) slice and one/// mutable (output) slice of equal length. Input and output slices are/// either the same or do not overlap./// Create `InOutBuf` from a single mutable reference.InOutBufIterfrom_ref_mut/// Create `InOutBuf` from a pair of immutable and mutable references./// Create `InOutBuf` from immutable and mutable slices./// Returns an error if length of slices is not equal to each other./// Get length of the inner buffers./// Returns `true` if the buffer has a length of 0./// Returns `InOut` for given position./// If `pos` greater or equal to buffer length./// Get input slice./// Get output slice.into_out/// Consume self and return output slice with lifetime `'a`./// Get raw input and output pointers./// Create [`InOutBuf`] from raw input and output pointers./// must be valid for reads for `len * mem::size_of::<T>()` many bytes./// must be valid for both reads and writes for `len * mem::size_of::<T>()`/// many bytes./// - The total size `len * mem::size_of::<T>()`  must be no larger than `isize::MAX`./// Divides one buffer into two at `mid` index./// The first will contain all indices from `[0, mid)` (excluding/// the index `mid` itself) and the second will contain all/// indices from `[mid, len)` (excluding the index `len` itself)./// Panics if `mid > len`./// XORs `data` with values behind the input slice and write/// Iterator over [`InOutBuf`].inout_buf//! Collection of custom reference types for code generic over in-place and//! buffer-to-buffer modes of operation.in_len/// mutable (output) slice. Input and output slices are either the same or/// do not overlap. Length of the output slice is always equal or bigger than/// length of the input slice./// Crate [`InOutBufReserved`] from a single mutable slice./// Create [`InOutBufReserved`] from raw input and output pointers./// must be valid for reads for `in_len * mem::size_of::<T>()` many bytes./// must be valid for both reads and writes for `out_len * mem::size_of::<T>()`/// - The total size `in_len * mem::size_of::<T>()` and/// `out_len * mem::size_of::<T>()`  must be no larger than `isize::MAX`.get_in_len/// Get input buffer length.get_out_len/// Get output buffer length.from_slices/// Crate [`InOutBufReserved`] from two separate slices.into_padded_blocksPaddedInOutBuf/// Transform buffer into [`PaddedInOutBuf`] using padding algorithm `P`.tail_intail_out/// Variant of [`InOutBuf`] with optional padded tail block.get_blocks/// Get full blocks.get_tail_block/// Get padded tail block./// For paddings with `P::TYPE = PadType::Reversible` it always returns `Some`./// Convert buffer into output slice.native/// The current time, expressed in milliseconds since the Unix Epoch.
duration_since/// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
/// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
/// otherwise.
/// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
checked_duration_since/// Returns the amount of time elapsed from another instant to this one, or None if that
/// instant is later than this one.
saturating_duration_since/// Returns the amount of time elapsed from another instant to this one, or zero duration if
/// that instant is later than this one.
duration_from_f64// Needed because the js macro triggers it.
_emscripten_get_nowjs// The JS now function is in a module so it won't have to be renamed
// Make the unsafe extern function "safe" so it can be called like the other 'now' functions
/// Returns the number of millisecods elapsed since January 1, 1970 00:00:00 UTC.
stream_infoStreamInfointerceptorsInterceptor/// Chain is an interceptor that runs all child interceptors in order./// new returns a new Chain interceptor." bind_rtcp_reader lets you modify any incoming RTCP packets. It is called once per sender/receiver, however this might"" change in the future. The returned method will be called once per packet batch."bind_rtcp_readerRTCPReader" bind_rtcp_writer lets you modify any outgoing RTCP packets. It is called once per PeerConnection. The returned method"" will be called once per packet batch."bind_rtcp_writerRTCPWriter" bind_local_stream lets you modify any outgoing RTP packets. It is called once for per LocalStream. The returned method"" will be called once per rtp packet."bind_local_streamRTPWriter" unbind_local_stream is called when the Stream is removed. It can be used to clean up any data related to that track."unbind_local_stream" bind_remote_stream lets you modify any incoming RTP packets. It is called once for per RemoteStream. The returned method"bind_remote_streamRTPReader" unbind_remote_stream is called when the Stream is removed. It can be used to clean up any data related to that track."unbind_remote_stream" close closes the Interceptor, cleaning up any data if necessary."ErrInvalidParentRtcpReaderErrInvalidParentRtpReaderErrInvalidNextRtpWriterErrInvalidCloseRxErrInvalidPacketRxErrIoEOFErrShortBufferErrInvalidSizeSrtpRtcpRtpflatten_errs/// flatten_errs flattens multiple errors into onenackstream_readertwcc/// Attributes are a generic key/value store used by interceptorsInterceptorBuilder/// InterceptorBuilder provides an interface for constructing interceptors" Interceptor can be used to add functionality to you PeerConnections by modifying any incoming/outgoing rtp/rtcp"" packets, or sending your own packets as needed."" write a rtp packet"" RTPWriter is used by Interceptor.bind_local_stream."RTPWriterBoxFnRTPWriterFn" read a rtp packet"" RTPReader is used by Interceptor.bind_remote_stream."RTPReaderBoxFnRTPReaderFn" write a batch of rtcp packets"" RTCPWriter is used by Interceptor.bind_rtcpwriter."RTCPWriterBoxFnRTCPWriterFn" read a batch of rtcp packets"" RTCPReader is used by Interceptor.bind_rtcpreader."RTCPReaderBoxFnRTCPReaderFntimeout_or_fail/// Helper for the tests.MockBuilderResultMockBuilder/// MockBuilder is a mock Builder for testing.BindRtcpReaderFnBindRtcpWriterFnBindLocalStreamFnUnbindLocalStreamFnBindRemoteStreamFnUnbindRemoteStreamFnCloseFnbind_rtcp_reader_fnbind_rtcp_writer_fnbind_local_stream_fnunbind_local_stream_fnbind_remote_stream_fnunbind_remote_stream_fnMockInterceptor/// MockInterceptor is an mock Interceptor for testing.MarshalRTCPPacketsrtcp_writerrtp_writerMockStreamInternalMockStream/// MockStream is a helper struct for testing interceptors.rtcp_out_modified_txrtp_out_modified_txrtcp_in_rxrtp_in_rxrtcp_out_modified_rxrtp_out_modified_rxrtcp_in_txrtp_in_txrtcp_in_modified_rxrtp_in_modified_rx/// new creates a new MockStreamwrite_rtcp/// write_rtcp writes a batch of rtcp packet to the stream, using the interceptorwrite_rtp/// write_rtp writes an rtp packet to the stream, using the interceptorreceive_rtcp/// receive_rtcp schedules a new rtcp batch, so it can be read be the streamreceive_rtp/// receive_rtp schedules a rtp packet, so it can be read be the streamwritten_rtcp/// written_rtcp returns a channel containing the rtcp batches written, modified by the interceptorlast_written_rtcp/// Returns the last rtcp packet bacth that was written, modified by the interceptor./// NB: This method discards all other previously recoreded packet batches.written_rtp/// written_rtp returns a channel containing rtp packets written, modified by the interceptorread_rtcp/// read_rtcp returns a channel containing the rtcp batched read, modified by the interceptorread_rtp/// read_rtp returns a channel containing the rtp packets read, modified by the interceptor/// close closes the streamNoOptest_mock_streamcur_nowMockTime/// MockTime is a helper to replace SystemTime::now() for testing purposes.set_now/// set_now sets the current time./// now returns the current time./// advance advances duration dmock_buildermock_interceptormock_streammock_timeUINT16SIZE_HALFlast_consecutiveGeneratorStreamInternalmissing_seq_numbersset_receiveddel_receivedget_receivedfix_last_consecutiveparent_rtp_readerGeneratorStreamtest_generator_streamtest_generator_stream_rollovertransport_feedbackstransport_layer_nackTransportLayerNackRTCPFeedbacktest_generator_interceptorgenerator_streamgenerator_testnack_pairs_from_sequence_numbersstream_support_nacklog2_size_minus_6skip_last_nGeneratorBuilder/// GeneratorBuilder can be used to configure Generator Interceptorwith_log2_size_minus_6/// with_size sets the size of the interceptor./// Size must be one of: 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768with_skip_last_n/// with_skip_last_n sets the number of packets (n-1 packets before the last received packets) to ignore when generating/// nack requests.with_interval/// with_interval sets the nack send interval for the interceptorGeneratorInternalwgclose_tx/// Generator interceptor generates nack feedback messages./// builder returns a new GeneratorBuilder.responderresponder_streamresponder_testResponderStreamlog2_sizeResponderBuilder/// GeneratorBuilder can be used to configure Responder Interceptorwith_log2_size/// with_log2_size sets the size of the interceptor./// Size must be one of: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768ResponderInternalresend_packetsparent_rtcp_readerResponderRtcpReaderResponder/// Responder responds to nack feedback messages/// builder returns a new ResponderBuilder.last_addedResponderStreamInternalnext_rtp_writertest_responder_streamNackPairtest_responder_interceptor/// NoOp is an Interceptor that does not modify any packets. It can embedded in other interceptors, so it's/// possible to implement only a subset of the methods./// Registry is a collector for interceptors./// add adds a new InterceptorBuilder to the registry./// build constructs a single Interceptor from an InterceptorRegistrybuild_chain/// build_chain constructs a non-type erased Chain from an Interceptor registry.ReceiverReportReceiverReportInternalSenderReportSenderReportInternalFnTimeGenis_rrReportBuilder/// ReceiverBuilder can be used to configure ReceiverReport Interceptor./// with_interval sets send interval for the interceptor.with_now_fn/// with_now_fn sets an alternative for the time.Now function.build_rrbuild_srreceiver_streamreceiver_testReceiverStreamReceiverReportRtcpReader/// ReceiverReport interceptor generates receiver reports./// builder returns a new ReportBuilder." UnbindLocalStream is called when the Stream is removed. It can be used to clean up any data related to that track."ssrcreceiver_ssrcclock_rateseq_num_cycleslast_seq_numlast_report_seq_numlast_rtp_time_rtplast_rtp_time_timejitterlast_sender_reportlast_sender_report_timetotal_lostReceiverStreamInternalprocess_rtpprocess_sender_reportsender_reportgenerate_reportreceiver_report//use bytes::Bytes;abs_send_time_extensionunix2ntptest_receiver_interceptor_before_any_packettest_receiver_interceptor_after_rtp_packetstest_receiver_interceptor_after_rtp_and_rtcp_packetstest_receiver_interceptor_overflowtest_receiver_interceptor_overflow_five_pktstest_receiver_interceptor_packet_losstest_receiver_interceptor_overflow_and_packet_losstest_receiver_interceptor_reordered_packetstest_receiver_interceptor_jittertest_receiver_interceptor_delaysender_streamsender_testSenderStream/// SenderReport interceptor generates sender reports./// data from rtp packetscountersCountersSenderStreamInternalincrement_packetscount_octetspacket_countoctet_count/// Wrapping counters used for generating [`rtcp::sender_report::SenderReport`]test_sender_interceptor_before_any_packettest_sender_interceptor_after_rtp_packetstest_sender_interceptor_after_rtp_packets_overflowtest_stream_counters_initially_zerotest_stream_packet_counter_wraps_on_overflowtest_stream_octet_counter_wraps_on_overflowtest_stream_octet_counter_saturates_u32_from_usizeextended_reportDLRRReportBlockExtendedReportpayload_feedbacksfull_intra_requestFullIntraRequestpicture_loss_indicationPictureLossIndicationMarshalSizeinboundoutboundStatsContainerStatsUpdateStatUpdatessrcsStatsSnapshotRequestInboundSnapshotRequestOutboundSnapshotheader_bytespayload_byteslast_packet_timestampInboundRTP/// Stats collected on the receiving end(inbound) of an RTP stream.OutboundRTP/// Stats collected on the sending end(outbound) of an RTP stream.fir_countpli_countnack_countInboundRTCP/// Stats collected from received RTCP packets.OutboundRTCP/// Stats collected from sent RTCP packets.seq_numOutboundSRExtSeqNum/// An extended sequence number sent in an SR.ext_seq_numrtt_msfraction_lostInboundReceiverReport/// Stats collected from received Receiver Reports i.e. where we have an outbound RTP stream.packets_and_bytes_sentInboundSenderRerport/// Stats collected from received Sender Reports i.e. where we have an inbound RTP stream.recv_streamsRTPReadRecorder// Wrapped RTP streamssend_streamsRTPWriteRecordernow_genStatsInterceptorwith_time_genfetch_inbound_statsfetch_outbound_statsrun_stats_reducerhandle_stats_updatertcp_readerRTCPReadInterceptorRTCPWriteInterceptorrtp_readercalculate_rtt_ms/// Calculate the round trip time for a given peer as described in/// [RFC3550 6.4.1](https://datatracker.ietf.org/doc/html/rfc3550#section-6.4.1)./// ## Params/// - `now` the current middle 32 bits of an NTP timestamp for the current time./// - `delay` the delay(`DLSR`) since last sender report expressed as fractions of a second in 32 bits./// - `last_report` the middle 32 bits of an NTP timestamp for the most recent sender report(LSR) or Receiver Report(LRR).assert_feqDLRRReportFirEntryreception_reportReceptionReporttest_stats_interceptor_rtptest_stats_interceptor_rtcp// Silence warning on `..Default::default()` with no effect:make_stats_interceptorRTCPStatsRTPStatsrtp_stats/// Received RTP stats.rtcp_stats/// Common RTCP stats derived from inbound and outbound RTCP packets./// The last time any stats where update, used for garbage collection to remove obsolete stats.remote_packets_sent/// The number of packets sent as reported in the latest SR from the remote.remote_bytes_sent/// The number of bytes sent as reported in the latest SR from the remote.remote_reports_sent/// The total number of sender reports sent by the remote and received.remote_round_trip_time/// The last remote round trip time measurement in ms. [`None`] if no round trip time has/// been derived yet, or if it wasn't possible to derive it.remote_total_round_trip_time/// The cumulative total round trip times reported in ms.remote_round_trip_time_measurements/// The total number of measurements of the remote round trip time.StreamStats/// Stats collected for an inbound RTP stream./// Contains both stats relating to the inbound stream and remote stats for the corresponding/// outbound stream at the remote end.mark_updatedduration_since_last_updaterecord_sender_reportrecord_remote_round_trip_time/// A point in time snapshot of the stream stats for an inbound RTP stream./// Created by [`StreamStats::snapshot`].payload_bytes_receivedheader_bytes_receivedlast_packet_received_timestampnacks_sentfirs_sentplis_sent/// Types related to inbound RTP streams./// Sent RTP stats.initial_outbound_ext_seq_num/// The first value of extended seq num that was sent in an SR for this SSRC. [`None`] before/// the first SR is sent./// Used to calculate packet statistic for remote stats.remote_packets_received/// The number of inbound packets received by the remote side for this stream.remote_total_lost/// The number of lost packets reported by the remote for this tream.remote_jitter/// The estimated remote jitter for this stream in timestamp units.remote_fraction_lost/// The latest fraction lost value from RR./// Stats collected for an outbound RTP stream./// Contains both stats relating to the outbound stream and remote stats for the corresponding/// inbound stream.update_remote_inbound_packets_receivedrecord_sr_ext_seq_numupdate_remote_fraction_lostupdate_remote_jitterupdate_remote_total_lost/// The most recent remote round trip time in milliseconds./// The fraction of packets lost reported for this stream./// Calculated as defined in [RFC3550](https://www.rfc-editor.org/rfc/rfc3550) section 6.4.1 and Appendix A.3./// A point in time snapshot of the stream stats for an outbound RTP stream.packets_sentpayload_bytes_sentheader_bytes_sentlast_packet_sent_timestampnacks_receivedfirs_receivedplis_received/// Packets received on the remote side./// The latest RTT in ms if enough data is available to measure it./// Total RTT in ms./// The number of RTT measurements so far./// The latest fraction lost value from the remote or None if it hasn't been reported yet./// Types related to outbound RTP streams.inbound_statsoutbound_statsget_or_create_inbound_stream_statsget_or_create_outbound_stream_statsget_inbound_statsget_outbound_statsremove_stale_entries/// Packets sent or received/// Payload bytes sent or received/// Header bytes sent or received/// A wall clock timestamp for when the last packet was sent or received encoded as milliseconds since/// [`SystemTime::UNIX_EPOCH`]./// Records stats about a given RTP stream./// The number of FIRs sent or received/// The number of PLIs sent or received/// The number of NACKs sent or receivedtest_rtp_statstest_rtcp_statstest_rtp_stats_send_synctest_rtcp_stats_send_syncRTPHeaderExtension/// RTPHeaderExtension represents a negotiated RFC5285 RTP header extension.payload_typertp_header_extensionssdp_fmtp_linertcp_feedbackassociated_streamAssociatedStreamInfo/// StreamInfo is the Context passed when a StreamLocal or StreamRemote has been Binded or Unbinded/// AssociatedStreamInfo provides a mapping from an auxiliary stream (RTX, FEC,/// etc.) back to the original stream./// Type is the type of feedback./// see: <https://draft.ortc.org/#dom-rtcrtcpfeedback>/// valid: ack, ccm, nack, goog-remb, transport-ccparameter/// The parameter value depends on the type./// For example, type="nack" parameter="pli" will send Picture Loss Indicator packets./// RTCPFeedback signals the connection to use additional RTCP packet types./// <https://draft.ortc.org/#dom-rtcrtcpfeedback>twcc_testtransport_layer_ccPacketStatusChunkRecvDeltaRunLengthChunkStatusChunkTypeTccStatusVectorChunkSymbolSizeTypeTccSymbolTypeTccTransportLayerCcarrival_timePktInforeceived_packetscycleslast_sequence_numbersender_ssrcmedia_ssrcfb_pkt_cnt/// Recorder records incoming RTP packets and their delays and creates/// transport wide congestion control feedback reports as specified in/// <https://datatracker.ietf.org/doc/html/draft-holmer-rmcat-transport-wide-cc-extensions-01>/// new creates a new Recorder which uses the given sender_ssrc in the created/// feedback packets./// record marks a packet with media_ssrc and a transport wide sequence number sequence_number as received at arrival_time.build_feedback_packet/// build_feedback_packet creates a new RTCP packet containing a TWCC feedback report.base_sequence_numberref_timestamp64mslast_timestamp_usnext_sequence_numbersequence_number_countlast_chunkFeedbackget_rtcpadd_receivedMAX_RUN_LENGTH_CAPMAX_ONE_BIT_CAP// 13 bitsMAX_TWO_BIT_CAP// bitshas_large_deltahas_different_typescan_addtransport_cc_extensionTransportCcExtensionMissedTickBehaviorUnmarshalTRANSPORT_CC_URIReceiverBuilder/// ReceiverBuilder is a InterceptorBuilder for a SenderInterceptorrecorderpacket_chan_rxReceiverInternal// we use tokio's Instant because it makes testing easier via `tokio::time::advance`.packet_chan_tx/// Receiver sends transport-wide congestion control reports as specified in:/// builder returns a new ReceiverBuilder.hdr_ext_idtest_twcc_receiver_interceptor_before_any_packetstest_twcc_receiver_interceptor_after_rtp_packetstest_twcc_receiver_interceptor_different_delays_between_rtp_packetstest_twcc_receiver_interceptor_packet_losstest_twcc_receiver_interceptor_overflowinit_sequence_nrSenderBuilder/// HeaderExtensionBuilder is a InterceptorBuilder for a HeaderExtension Interceptorwith_init_sequence_nr/// with_init_sequence_nr sets the init sequence number of the interceptor./// build constructs a new SenderInterceptornext_sequence_nr/// Sender adds transport wide sequence numbers as header extension to each RTP packet/// builder returns a new SenderBuilder." bind_local_stream returns a writer that adds a rtp TransportCCExtension"" header with increasing sequence numbers to each outgoing packet."test_twcc_sender_interceptortest_chunk_addtest_feedbackadd_runTYPE_TCC_DELTA_SCALE_FACTORSCALE_FACTOR_REFERENCE_TIMEincrease_timemarshal_alltest_build_feedback_packettest_build_feedback_packet_rollinguse_feature_or_nothinguse_featurehas_feature/// Test whether the rustc at `var("RUSTC")` supports the given feature.can_compile/// Test whether the rustc at `var("RUSTC")` can compile the given code.has_panic_in_const_fn/// Test whether the rustc at `var("RUSTC")` supports panic in `const fn`.has_io_safety/// Test whether the rustc at `var("RUSTC")` supports the I/O safety feature.O_CLOEXECO_CREATO_RDONLYO_RDWRO_TRUNC//! This is just a sample of what FFI using this crate can look like.// Declare a few FFI functions ourselves, to show off the FFI ergonomics.// The Windows analogs of the above. Note the use of [`HandleOrInvalid`] as// the return type for `CreateFileW`, since that function is defined to return// [`INVALID_HANDLE_VALUE`] on error instead of null.FromFdIntoFdAsSocketFromHandleFromSocketIntoHandleIntoSocketOwnedSocketasync_stdFilelikeViewTypeinto_handleas_socketinto_socketfrom_socket//! Implementations of io-lifetimes' traits for async-std's types. In the//! future, we'll prefer to have crates provide their own impls; this is//! just a temporary measure.fs_err//! Implementations of io-lifetimes' traits for fs_err's types. In the//! Implementations of io-lifetimes' traits for mio's types. In thePipeReaderPipeWriter//! Implementations of io-lifetimes' traits for os_pipe's types. In the//! Implementations of io-lifetimes' traits for socket2's types. In theHandleOrInvalid// Don't warn on `IntoFd` and `FromFd` impls.//! Implementations of io-lifetimes' traits for tokio's types. In theportability// io-lifetimes defined `FromFd`/`IntoFd` traits instead of just using// `From`/`Into` because that allowed it to implement them for foreign types,// including std types like File and TcpStream, and popular third-party types.// std just uses `From`/`Into`, because it defines those traits itself so it// can implement them for std types itself, and std won't be implementing them// for third-party types. However, this means that until `OwnedFd` et al are// stabilized, there will be no impls for third-party traits.// So we define `FromFd`/`IntoFd` traits, and implement them in terms of// `From`/`Into`,AsFilelikeAsSocketlikeBorrowedFilelikeBorrowedSocketlikeFromFilelikeFromSocketlikeIntoFilelikeIntoSocketlikeOwnedFilelikeOwnedSocketlikeexample_ffi//! Experimental new types and traits to replace the `Raw` family of types and//! This API has much conceptual similarity with the `Raw` API, but introduces//! explicit concepts of ownership and borrowing://! | `Raw` API  | This experimental API    |//! | ---------- | ------------------------ |//! | `Raw*`     | `Borrowed*` and `Owned*` |//! | `AsRaw*`   | `As*`                    |//! | `IntoRaw*` | `Into*`                  |//! | `FromRaw*` | `From*`                  |//! This gives it several advantages://!  - Less `unsafe` in user code!//!  - Easier to understand ownership.//!  - It avoids the inconsistency where `AsRawFd` and `IntoRawFd` return//!    `RawFd` values that users ought to be able to trust, but aren't unsafe,//!    so it's possible to fail to uphold this trust in purely safe Rust.//!  - It enables a number of safe and portable convenience features, such as//!    [safe typed views] and [from+into conversions].//! [safe typed views]: AsFilelike::as_filelike_view//! [from+into conversions]: FromFilelike::from_into_filelike// Work around <https://github.com/rust-lang/rust/issues/103306>.// Currently supported platforms.FilelikeViewSocketlikeViewSocketlikeViewType'filelike/// A reference to a filelike object./// This is a portability abstraction over Unix-like [`BorrowedFd`] and/// Windows' `BorrowedHandle`.'socketlike/// A reference to a socketlike object./// Windows' `BorrowedSocket`./// An owned filelike object./// This is a portability abstraction over Unix-like [`OwnedFd`] and/// Windows' `OwnedHandle`./// An owned socketlike object./// Windows' `OwnedSocket`.as_filelike/// Borrows the reference./// use io_lifetimes::{AsFilelike, BorrowedFilelike};/// let mut f = File::open("foo.txt")?;/// let borrowed_filelike: BorrowedFilelike<'_> = f.as_filelike();/// # Ok::<(), io::Error>(())as_filelike_view/// Return a borrowing view of a resource which dereferences to a/// `&Target`./// Note that [`Read`] or [`Write`] require `&mut Target`, but in some/// cases, such as [`File`], `Read` and `Write` are implemented for/// `&Target` in addition to `Target`, and you can get a `&mut &Target`/// by doing `&*` on the resuting view, like this:/// let v = f.as_filelike_view::<std::fs::File>();/// (&*v).read(&mut buf).unwrap();/// [`File`]: std::fs::File/// [`Read`]: std::io::Read/// A portable trait to borrow a reference from an underlying filelike object./// This is a portability abstraction over Unix-like [`AsFd`] and Windows'/// `AsHandle`. It also provides the `as_filelike_view` convenience function/// providing typed views.as_socketlikeas_socketlike_view/// cases, such as [`TcpStream`], `Read` and `Write` are implemented/// for `&Target` in addition to `Target`, and you can get a `&mut/// &Target` by doing `&*` on the resuting view, like this:/// let v = s.as_socketlike_view::<std::net::TcpStream>();/// [`TcpStream`]: std::net::TcpStream/// A portable trait to borrow a reference from an underlying socketlike/// `AsSocket`. It also provides the `as_socketlike_view` convenience/// function providing typed views.into_filelike/// Consumes this object, returning the underlying filelike object./// use io_lifetimes::{IntoFilelike, OwnedFilelike};/// let f = File::open("foo.txt")?;/// let owned_filelike: OwnedFilelike = f.into_filelike();/// A portable trait to express the ability to consume an object and acquire/// ownership of its filelike object./// This is a portability abstraction over Unix-like [`Into<OwnedFd>`] and/// Windows' `Into<OwnedHandle>`.into_socketlike/// Consumes this object, returning the underlying socketlike object./// ownership of its socketlike object./// Windows' `Into<OwnedSocket>`.from_filelike/// Constructs a new instance of `Self` from the given filelike object./// use io_lifetimes::{FromFilelike, IntoFilelike, OwnedFilelike};/// let f = File::from_filelike(owned_filelike);from_into_filelike/// Constructs a new instance of `Self` from the given filelike object/// converted from `into_owned`./// use io_lifetimes::{FromFilelike, IntoFilelike};/// let f = File::from_into_filelike(f);/// A portable trait to express the ability to construct an object from a/// filelike object./// This is a portability abstraction over Unix-like [`From<OwnedFd>`] and/// Windows' `From<OwnedHandle>`. It also provides the `from_into_filelike`/// convenience function providing simplified from+into conversions.from_socketlike/// Constructs a new instance of `Self` from the given socketlike object.from_into_socketlike/// Constructs a new instance of `Self` from the given socketlike object/// socketlike object./// Windows' `From<OwnedSocketFrom<OwnedSocket>` It also provides the/// `from_into_socketlike` convenience function providing simplified from+into/// conversions.//! Portability abstractions over `Owned*` and `Borrowed*`.//! On Unix, "everything is a file descriptor". On Windows, file/pipe/process//! handles are distinct from socket descriptors. This file provides a minimal//! layer of portability over this difference.RawFilelike/// A raw filelike object./// This is a portability abstraction over Unix-like [`RawFd`] and/// Windows' `RawHandle`.RawSocketlike/// A raw socketlike object./// Windows' `RawSocket`.as_raw_filelike/// Returns the raw value.AsRawFilelike/// A portable trait to obtain the raw value of an underlying filelike object./// This is a portability abstraction over Unix-like [`AsRawFd`] and Windows'/// `AsRawHandle`.as_raw_socketlikeAsRawSocketlikeinto_raw_filelikeIntoRawFilelike/// This is a portability abstraction over Unix-like [`IntoRawFd`] and Windows'/// `IntoRawHandle`.into_raw_socketlikeIntoRawSocketlike/// `IntoRawSocket`.from_raw_filelike/// Constructs `Self` from the raw value./// This is `unsafe` for the same reason as [`from_raw_fd`] and/// [`from_raw_handle`]./// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.from_raw_fd/// [`from_raw_handle`]: https://doc.rust-lang.org/stable/std/os/windows/io/trait.FromRawHandle.html#tymethod.from_raw_handleFromRawFilelike/// This is a portability abstraction over Unix-like [`FromRawFd`] and Windows'/// `FromRawHandle`.from_raw_socketlike/// [`from_raw_socket`]./// [`from_raw_socket`]: https://doc.rust-lang.org/stable/std/os/windows/io/trait.FromRawSocket.html#tymethod.from_raw_socketFromRawSocketlike/// `FromRawSocket`.//! Portability abstractions over `Raw*`./// Consumes this object, returning the underlying file descriptor./// use io_lifetimes::{IntoFd, OwnedFd};/// let owned_fd: OwnedFd = f.into_fd();/// A trait to express the ability to consume an object and acquire ownership/// of its file descriptor./// Constructs a new instance of `Self` from the given file descriptor./// use io_lifetimes::{FromFd, IntoFd, OwnedFd};/// let f = File::from_fd(owned_fd);from_into_fd/// Constructs a new instance of `Self` from the given file descriptor/// use io_lifetimes::{FromFd, IntoFd};/// let f = File::from_into_fd(f);/// A trait to express the ability to construct an object from a fileDuplicateHandleSetHandleInformationDUPLICATE_HANDLE_OPTIONSDUPLICATE_SAME_ACCESSHANDLE_FLAG_INHERITINVALID_HANDLE_VALUEWSADuplicateSocketWSOCKET_ERRORWSAEINVALWSAEPROTOTYPEWSAPROTOCOL_INFOWWSA_FLAG_OVERLAPPEDGetCurrentProcessId'fd/// A borrowed file descriptor./// This has a lifetime parameter to tie it to the lifetime of something that/// owns the file descriptor./// This uses `repr(transparent)` and has the representation of a host file/// descriptor, so it can be used in FFI in places where a file descriptor is/// passed as an argument, it is not captured or consumed, and it never has the/// value `-1`./// This type's `.to_owned()` implementation returns another `BorrowedFd`/// rather than an `OwnedFd`. It just makes a trivial copy of the raw file/// descriptor, which is then borrowed under the same lifetime.'handle/// A borrowed handle./// owns the handle./// This uses `repr(transparent)` and has the representation of a host handle,/// so it can be used in FFI in places where a handle is passed as an argument,/// it is not captured or consumed, and it is never null./// Note that it *may* have the value `-1`, which in `BorrowedHandle` always/// represents a valid handle value, such as [the current process handle], and/// not `INVALID_HANDLE_VALUE`, despite the two having the same value. See/// [here] for the full story./// This type's `.to_owned()` implementation returns another `BorrowedHandle`/// rather than an `OwnedHandle`. It just makes a trivial copy of the raw/// handle, which is then borrowed under the same lifetime./// [here]: https://devblogs.microsoft.com/oldnewthing/20040302-00/?p=40443/// [the current process handle]: https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getcurrentprocess#remarks'socket/// A borrowed socket./// owns the socket./// This uses `repr(transparent)` and has the representation of a host socket,/// so it can be used in FFI in places where a socket is passed as an argument,/// it is not captured or consumed, and it never has the value/// [`INVALID_SOCKET`]./// This type's `.to_owned()` implementation returns another `BorrowedSocket`/// rather than an `OwnedSocket`. It just makes a trivial copy of the raw/// socket, which is then borrowed under the same lifetime./// An owned file descriptor./// This closes the file descriptor on drop./// passed as a consumed argument or returned as an owned value, and it never/// has the value `-1`./// Creates a new `OwnedFd` instance that shares the same underlying file/// description as the existing `OwnedFd` instance.try_clone_to_owned/// description as the existing `BorrowedFd` instance./// An owned handle./// This closes the handle on drop./// Note that it *may* have the value `-1`, which in `OwnedHandle` always/// And, it *may* have the value `NULL` (0), which can occur when consoles are/// detached from processes, or when `windows_subsystem` is used./// `OwnedHandle` uses [`CloseHandle`] to close its handle on drop. As such,/// it must not be used with handles to open registry keys which need to be/// closed with [`RegCloseKey`] instead./// [`CloseHandle`]: https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-closehandle/// [`RegCloseKey`]: https://docs.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regclosekey/// Creates a new `OwnedHandle` instance that shares the same underlying/// object as the existing `OwnedHandle` instance./// object as the existing `BorrowedHandle` instance./// An owned socket./// This closes the socket on drop./// so it can be used in FFI in places where a socket is passed as a consumed/// argument or returned as an owned value, and it never has the value/// Creates a new `OwnedSocket` instance that shares the same underlying/// object as the existing `OwnedSocket` instance.set_no_inherit/// object as the existing `BorrowedSocket` instance./// FFI type for handles in return values or out parameters, where `INVALID_HANDLE_VALUE` is used/// as a sentry value to indicate errors, such as in the return value of `CreateFileW`. This uses/// `repr(transparent)` and has the representation of a host handle, so that it can be used in such/// FFI declarations./// The only thing you can usefully do with a `HandleOrInvalid` is to convert it into an/// `OwnedHandle` using its [`TryFrom`] implementation; this conversion takes care of the check for/// `INVALID_HANDLE_VALUE`. This ensures that such FFI calls cannot start using the handle without/// checking for `INVALID_HANDLE_VALUE` first./// This type may hold any handle value that [`OwnedHandle`] may hold, except that when it holds/// `-1`, that value is interpreted to mean `INVALID_HANDLE_VALUE`./// If holds a handle other than `INVALID_HANDLE_VALUE`, it will close the handle on drop.HandleOrNull/// FFI type for handles in return values or out parameters, where `NULL` is used/// as a sentry value to indicate errors, such as in the return value of `CreateThread`. This uses/// The only thing you can usefully do with a `HandleOrNull` is to convert it into an/// `NULL`. This ensures that such FFI calls cannot start using the handle without/// checking for `NULL` first./// This type may hold any handle value that [`OwnedHandle`] may hold. As with `OwnedHandle`, when/// it holds `-1`, that value is interpreted as a valid handle value, such as/// [the current process handle], and not `INVALID_HANDLE_VALUE`./// If this holds a non-null handle, it will close the handle on drop.// The Windows [`HANDLE`] type may be transferred across and shared between// thread boundaries (despite containing a `*mut void`, which in general isn't// `Send` or `Sync`).// [`HANDLE`]: std::os::windows::raw::HANDLEborrow_raw/// Return a `BorrowedFd` holding the given raw file descriptor./// The resource pointed to by `raw` must remain open for the duration of/// the returned `BorrowedFd`, and it must not have the value `-1`./// Return a `BorrowedHandle` holding the given raw handle./// The resource pointed to by `handle` must be a valid open handle, it/// must remain open for the duration of the returned `BorrowedHandle`./// Note that it *may* have the value `INVALID_HANDLE_VALUE` (-1), which is/// sometimes a valid handle value. See [here] for the full story./// Return a `BorrowedSocket` holding the given raw socket./// the returned `BorrowedSocket`, and it must not have the valueInvalidHandleErrorNullHandleError/// This is the error type used by [`HandleOrNull`] when attempting to convert/// into a handle, to indicate that the value is null./// This is the error type used by [`HandleOrInvalid`] when attempting to/// convert into a handle, to indicate that the value is/// `INVALID_HANDLE_VALUE`./// Constructs a new instance of `Self` from the given raw file descriptor./// The resource pointed to by `raw` must be open and suitable for assuming/// ownership./// Constructs a new instance of `Self` from the given `RawHandle` returned/// from a Windows API that uses `INVALID_HANDLE_VALUE` to indicate/// failure, such as `CreateFileW`./// Use `HandleOrNull` instead of `HandleOrInvalid` for APIs that/// use null to indicate failure./// The passed `handle` value must either satisfy the safety requirements/// of [`FromRawHandle::from_raw_handle`], or be/// `INVALID_HANDLE_VALUE` (-1). Note that not all Windows APIs use/// `INVALID_HANDLE_VALUE` for errors; see [here] for the full story./// from a Windows API that uses null to indicate failure, such as/// `CreateThread`./// Use `HandleOrInvalid` instead of `HandleOrNull` for APIs that/// use `INVALID_HANDLE_VALUE` to indicate failure./// of [`FromRawHandle::from_raw_handle`], or be null. Note that not all/// Windows APIs use null for errors; see [here] for the full story./// Declare that a type is safe to use in a [`FilelikeView`]./// Types implementing this trait declare that if they are constructed with/// [`FromFilelike`] and consumed with [`IntoFilelike`], their `IntoFilelike`/// will return the same `OwnedFd` value that was passed to their/// `FromFilelike`./// Declare that a type is safe to use in a [`SocketlikeView`]./// [`FromSocketlike`] and consumed with [`IntoSocketlike`], their/// `IntoSocketlike` will return the same `OwnedFd` value that was passed to/// their `FromSocketlike`./// The value to dereference to. This is a `ManuallyDrop` so that we can/// consume it in our `Drop` impl./// This field exists because we don't otherwise explicitly use/// `'filelike`./// A non-owning view of a resource which dereferences to a `&Target` or/// `&mut Target`. These are returned by [`AsFilelike::as_filelike_view`]./// `'socketlike`./// `&mut Target`. These are returned by [`AsSocketlike::as_socketlike_view`]./// Construct a temporary `Target` and wrap it in a `FilelikeView` object.view_raw/// Construct a temporary `Target` from raw and wrap it in a `FilelikeView`/// `raw` must be a valid raw filelike referencing a resource that outlives/// the resulting view./// Construct a temporary `Target` and wrap it in a `SocketlikeView`/// Construct a temporary `Target` from raw and wrap it in a/// `SocketlikeView` object./// `raw` must be a valid raw socketlike referencing a resource that/// outlives the resulting view.//! Typed views using temporary objects.//! This module defines the return types for [`AsFilelike::as_filelike_view`]//! and [`AsSocketlike::as_socketlike_view`].//! [`AsSocketlike::as_socketlike_view`]: crate::AsSocketlike::as_socketlike_viewtiocexcl/// Put the terminal in exclusive mode.tiocnxcl/// Disable exclusive mode.tiocmget/// Get the status of modem bits.tiocmset/// Set the status of modem bits.tiocmbis/// Set the indicated modem bits.tiocmbic/// Clear the indicated modem bits.FIOSETOWNSIOCSPGRPFIOGETOWNSIOCGPGRPTIOCEXCLTIOCNXCLTIOCSCTTYTIOCGPGRPTIOCSPGRPTIOCOUTQTIOCSTITIOCGWINSZTIOCSWINSZTIOCMGETTIOCMBISTIOCMBICTIOCMSETFIONREADTIOCCONSTIOCPKTFIONBIOTIOCNOTTYTIOCSETDTIOCGETDFIONCLEXFIOCLEXFIOASYNCSIOCGIFCONFSIOCGIFFLAGSSIOCSIFFLAGSSIOCGIFADDRSIOCSIFADDRSIOCGIFDSTADDRSIOCSIFDSTADDRSIOCGIFBRDADDRSIOCSIFBRDADDRSIOCGIFNETMASKSIOCSIFNETMASKSIOCGIFMETRICSIOCSIFMETRICSIOCGIFMTUSIOCSIFMTUSIOCADDMULTISIOCDELMULTITIOCM_LETIOCM_DTRTIOCM_RTSTIOCM_STTIOCM_SRTIOCM_CTSTIOCM_CARTIOCM_CDTIOCM_RNGTIOCM_RITIOCM_DSR// socket// termios// sockios// modem control linesSIOCGSTAMPTCGETSTCSETSTCSETSWTCSETSFTCGETATCSETATCSETAWTCSETAFTCSBRKTCXONCTCFLSHTIOCGSOFTCARTIOCSSOFTCARTIOCINQTIOCLINUXTIOCGSERIALTIOCSSERIALTCSBRKPTIOCSERCONFIGTIOCSERGWILDTIOCSERSWILDTIOCGLCKTRMIOSTIOCSLCKTRMIOSTIOCSERGSTRUCTTIOCSERGETLSRTIOCSERGETMULTITIOCSERSETMULTISIOCADDRTSIOCDELRTSIOCGIFNAMESIOCSIFLINKSIOCGIFMEMSIOCSIFMEMSIOCSIFHWADDRSIOCGIFENCAPSIOCSIFENCAPSIOCGIFHWADDRSIOCGIFSLAVESIOCSIFSLAVESIOCDARPSIOCGARPSIOCSARPSIOCDRARPSIOCGRARPSIOCSRARPSIOCGIFMAPSIOCSIFMAPIOSSDATALATIOSSDATALAT_32IOSSDATALAT_64IOSSIOSPEEDIOSSIOSPEED_32IOSSIOSPEED_64// IOKitRHSIpAdd/// Provides a `saturating_add()` method for `Ipv4Addr` and `Ipv6Addr`./// Adding an integer to an IP address returns the modified IP address./// A `u32` may added to an IPv4 address and a `u128` may be added to/// an IPv6 address./// # #[cfg(not(feature = "std"))]/// # use core::net::{Ipv4Addr, Ipv6Addr};/// # #[cfg(feature = "std")]/// use std::net::{Ipv4Addr, Ipv6Addr};/// use ipnet::IpAdd;/// let ip0: Ipv4Addr = "192.168.0.0".parse().unwrap();/// let ip1: Ipv4Addr = "192.168.0.5".parse().unwrap();/// let ip2: Ipv4Addr = "255.255.255.254".parse().unwrap();/// let max: Ipv4Addr = "255.255.255.255".parse().unwrap();/// assert_eq!(ip0.saturating_add(5), ip1);/// assert_eq!(ip2.saturating_add(1), max);/// assert_eq!(ip2.saturating_add(5), max);/// let ip0: Ipv6Addr = "fd00::".parse().unwrap();/// let ip1: Ipv6Addr = "fd00::5".parse().unwrap();/// let ip2: Ipv6Addr = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe".parse().unwrap();/// let max: Ipv6Addr = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff".parse().unwrap();IpSub/// Provides a `saturating_sub()` method for `Ipv4Addr` and `Ipv6Addr`./// Subtracting an integer from an IP address returns the modified IP/// address. A `u32` may be subtracted from an IPv4 address and a `u128`/// may be subtracted from an IPv6 address./// Subtracting an IP address from another IP address of the same type/// returns an integer of the appropriate width. A `u32` for IPv4 and a/// `u128` for IPv6. Subtracting IP addresses is useful for getting/// the range between two IP addresses./// use ipnet::IpSub;/// let min: Ipv4Addr = "0.0.0.0".parse().unwrap();/// let ip1: Ipv4Addr = "192.168.1.5".parse().unwrap();/// let ip2: Ipv4Addr = "192.168.1.100".parse().unwrap();/// assert_eq!(min.saturating_sub(ip1), 0);/// assert_eq!(ip2.saturating_sub(ip1), 95);/// assert_eq!(min.saturating_sub(5), min);/// assert_eq!(ip2.saturating_sub(95), ip1);/// let min: Ipv6Addr = "::".parse().unwrap();/// let ip2: Ipv6Addr = "fd00::64".parse().unwrap();/// assert_eq!(min.saturating_sub(5u128), min);/// assert_eq!(ip2.saturating_sub(95u128), ip1);IpBitAnd/// Provides a `bitand()` method for `Ipv4Addr` and `Ipv6Addr`./// use ipnet::IpBitAnd;/// let ip: Ipv4Addr = "192.168.1.1".parse().unwrap();/// let mask: Ipv4Addr = "255.255.0.0".parse().unwrap();/// let res: Ipv4Addr = "192.168.0.0".parse().unwrap();/// assert_eq!(ip.bitand(mask), res);/// assert_eq!(ip.bitand(0xffff0000), res);/// let ip: Ipv6Addr = "fd00:1234::1".parse().unwrap();/// let mask: Ipv6Addr = "ffff::".parse().unwrap();/// let res: Ipv6Addr = "fd00::".parse().unwrap();/// assert_eq!(ip.bitand(0xffff_0000_0000_0000_0000_0000_0000_0000u128), res);IpBitOr/// Provides a `bitor()` method for `Ipv4Addr` and `Ipv6Addr`./// use ipnet::IpBitOr;/// let ip: Ipv4Addr = "10.1.1.1".parse().unwrap();/// let mask: Ipv4Addr = "0.0.0.255".parse().unwrap();/// let res: Ipv4Addr = "10.1.1.255".parse().unwrap();/// assert_eq!(ip.bitor(mask), res);/// assert_eq!(ip.bitor(0x000000ff), res);/// let ip: Ipv6Addr = "fd00::1".parse().unwrap();/// let mask: Ipv6Addr = "::ffff:ffff".parse().unwrap();/// let res: Ipv6Addr = "fd00::ffff:ffff".parse().unwrap();/// assert_eq!(ip.bitor(u128::from(0xffffffffu32)), res);ip_add_implip_sub_implip_bitops_implreplace_onereplace_zeroadd_onesub_oneIpStep// A barebones copy of the current unstable Step trait used by the// IpAddrRange, Ipv4AddrRange, and Ipv6AddrRange types below, and the// Subnets types in ipnet.IpAddrRangeIpv4AddrRangeIpv6AddrRange/// An `Iterator` over a range of IP addresses, either IPv4 or IPv6./// use std::net::IpAddr;/// use ipnet::{IpAddrRange, Ipv4AddrRange, Ipv6AddrRange};/// let hosts = IpAddrRange::from(Ipv4AddrRange::new(///     "10.0.0.0".parse().unwrap(),///     "10.0.0.3".parse().unwrap(),/// assert_eq!(hosts.collect::<Vec<IpAddr>>(), vec![///     "10.0.0.0".parse::<IpAddr>().unwrap(),///     "10.0.0.1".parse().unwrap(),///     "10.0.0.2".parse().unwrap(),/// let hosts = IpAddrRange::from(Ipv6AddrRange::new(///     "fd00::".parse().unwrap(),///     "fd00::3".parse().unwrap(),///     "fd00::0".parse::<IpAddr>().unwrap(),///     "fd00::1".parse().unwrap(),///     "fd00::2".parse().unwrap(),/// An `Iterator` over a range of IPv4 addresses./// # use core::net::Ipv4Addr;/// use std::net::Ipv4Addr;/// use ipnet::Ipv4AddrRange;/// let hosts = Ipv4AddrRange::new(/// assert_eq!(hosts.collect::<Vec<Ipv4Addr>>(), vec![///     "10.0.0.0".parse::<Ipv4Addr>().unwrap(),/// An `Iterator` over a range of IPv6 addresses./// ``` /// # use core::net::Ipv6Addr;/// use std::net::Ipv6Addr;/// use ipnet::Ipv6AddrRange;/// let hosts = Ipv6AddrRange::new(/// assert_eq!(hosts.collect::<Vec<Ipv6Addr>>(), vec![///     "fd00::".parse::<Ipv6Addr>().unwrap(),count_u64/// Counts the number of Ipv4Addr in this range./// This method will never overflow or panic.count_u128/// Counts the number of Ipv6Addr in this range./// This method may overflow or panic if start/// is 0 and end is u128::MAXcan_count_u128/// True only if count_u128 does not overflowtest_ipaddrrange//! Extensions to the standard IP address types for common operations.//! The [`IpAdd`], [`IpSub`], [`IpBitAnd`], [`IpBitOr`] traits extend//! the `Ipv4Addr` and `Ipv6Addr` types with methods to perform theseipextip_mask_to_prefixipv4_mask_to_prefixipv6_mask_to_prefix/// An IP network address, either IPv4 or IPv6./// This enum can contain either an [`Ipv4Net`] or an [`Ipv6Net`]. A/// [`From`] implementation is provided to convert these into an/// `IpNet`./// # Textual representation/// `IpNet` provides a [`FromStr`] implementation for parsing network/// addresses represented in CIDR notation. See [IETF RFC 4632] for the/// CIDR notation./// [`Ipv4Net`]: struct.Ipv4Net.html/// [`Ipv6Net`]: struct.Ipv6Net.html/// [IETF RFC 4632]: https://tools.ietf.org/html/rfc4632/// use ipnet::IpNet;/// let net: IpNet = "10.1.1.0/24".parse().unwrap();/// assert_eq!(Ok(net.network()), "10.1.1.0".parse());/// let net: IpNet = "fd00::/32".parse().unwrap();/// assert_eq!(Ok(net.network()), "fd00::".parse());/// An IPv4 network address./// See [`IpNet`] for a type encompassing both IPv4 and IPv6 network/// addresses./// `Ipv4Net` provides a [`FromStr`] implementation for parsing network/// [`IpNet`]: enum.IpNet.html/// # use std::net::Ipv6Addr;/// use ipnet::Ipv4Net;/// let net: Ipv4Net = "10.1.1.0/24".parse().unwrap();/// An IPv6 network address./// `Ipv6Net` provides a [`FromStr`] implementation for parsing network/// use ipnet::Ipv6Net;/// let net: Ipv6Net = "fd00::/32".parse().unwrap();PrefixLenError/// An error which can be returned when the prefix length is invalid./// Valid prefix lengths are 0 to 32 for IPv4 and 0 to 128 for IPv6./// Creates a new IP network address from an `IpAddr` and prefix/// use ipnet::{IpNet, PrefixLenError};/// let net = IpNet::new(Ipv6Addr::LOCALHOST.into(), 48);/// assert!(net.is_ok());/// let bad_prefix_len = IpNet::new(Ipv6Addr::LOCALHOST.into(), 129);/// assert_eq!(bad_prefix_len, Err(PrefixLenError));new_assert/// length. If called from a const context it will verify prefix length/// at compile time. Otherwise it will panic at runtime if prefix length/// is incorrect for a given IpAddr type./// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};/// use ipnet::{IpNet};/// // This code is verified at compile time:/// const NET: IpNet = IpNet::new_assert(IpAddr::V4(Ipv4Addr::new(10, 1, 1, 0)), 24);/// assert_eq!(NET.prefix_len(), 24);/// // This code is verified at runtime:/// let net = IpNet::new_assert(Ipv6Addr::LOCALHOST.into(), 24);/// assert_eq!(net.prefix_len(), 24);/// // This code does not compile:/// // const BAD_PREFIX_LEN: IpNet = IpNet::new_assert(IpAddr::V4(Ipv4Addr::new(10, 1, 1, 0)), 33);/// // This code panics at runtime:/// // let bad_prefix_len = IpNet::new_assert(Ipv6Addr::LOCALHOST.into(), 129);with_netmask/// Creates a new IP network address from an `IpAddr` and netmask./// let net = IpNet::with_netmask(Ipv6Addr::LOCALHOST.into(), Ipv6Addr::from(0xffff_ffff_ffff_0000_0000_0000_0000_0000).into());/// let bad_prefix_len = IpNet::with_netmask(Ipv6Addr::LOCALHOST.into(), Ipv6Addr::from(0xffff_ffff_ffff_0000_0001_0000_0000_0000).into());/// Returns a copy of the network with the address truncated to the/// prefix length./// # use ipnet::IpNet;///     "192.168.12.34/16".parse::<IpNet>().unwrap().trunc(),///     "192.168.0.0/16".parse().unwrap()///     "fd00::1:2:3:4/16".parse::<IpNet>().unwrap().trunc(),///     "fd00::/16".parse().unwrap()/// Returns the address./// Returns the prefix length.max_prefix_len/// Returns the maximum valid prefix length./// Returns the network mask./// # use std::net::IpAddr;/// let net: IpNet = "10.1.0.0/20".parse().unwrap();/// assert_eq!(Ok(net.netmask()), "255.255.240.0".parse());/// let net: IpNet = "fd00::/24".parse().unwrap();/// assert_eq!(Ok(net.netmask()), "ffff:ff00::".parse());hostmask/// Returns the host mask./// assert_eq!(Ok(net.hostmask()), "0.0.15.255".parse());/// assert_eq!(Ok(net.hostmask()), "::ff:ffff:ffff:ffff:ffff:ffff:ffff".parse());/// Returns the network address./// let net: IpNet = "172.16.123.123/16".parse().unwrap();/// assert_eq!(Ok(net.network()), "172.16.0.0".parse());/// let net: IpNet = "fd00:1234:5678::/24".parse().unwrap();/// assert_eq!(Ok(net.network()), "fd00:1200::".parse());/// Returns the broadcast address./// let net: IpNet = "172.16.0.0/22".parse().unwrap();/// assert_eq!(Ok(net.broadcast()), "172.16.3.255".parse());/// assert_eq!(Ok(net.broadcast()), "fd00:12ff:ffff:ffff:ffff:ffff:ffff:ffff".parse());supernet/// Returns the `IpNet` that contains this one./// let n1: IpNet = "172.16.1.0/24".parse().unwrap();/// let n2: IpNet = "172.16.0.0/23".parse().unwrap();/// let n3: IpNet = "172.16.0.0/0".parse().unwrap();/// assert_eq!(n1.supernet().unwrap(), n2);/// assert_eq!(n3.supernet(), None);/// let n1: IpNet = "fd00:ff00::/24".parse().unwrap();/// let n2: IpNet = "fd00:fe00::/23".parse().unwrap();/// let n3: IpNet = "fd00:fe00::/0".parse().unwrap();is_sibling/// Returns `true` if this network and the given network are /// children of the same supernet./// let n4_1: IpNet = "10.1.0.0/24".parse().unwrap();/// let n4_2: IpNet = "10.1.1.0/24".parse().unwrap();/// let n4_3: IpNet = "10.1.2.0/24".parse().unwrap();/// let n6_1: IpNet = "fd00::/18".parse().unwrap();/// let n6_2: IpNet = "fd00:4000::/18".parse().unwrap();/// let n6_3: IpNet = "fd00:8000::/18".parse().unwrap();/// assert!( n4_1.is_sibling(&n4_2));/// assert!(!n4_2.is_sibling(&n4_3));/// assert!( n6_1.is_sibling(&n6_2));/// assert!(!n6_2.is_sibling(&n6_3));/// assert!(!n4_1.is_sibling(&n6_2));hosts/// Return an `Iterator` over the host addresses in this network./// let net: IpNet = "10.0.0.0/30".parse().unwrap();/// assert_eq!(net.hosts().collect::<Vec<IpAddr>>(), vec![///     "10.0.0.1".parse::<IpAddr>().unwrap(),/// let net: IpNet = "10.0.0.0/31".parse().unwrap();/// let net: IpNet = "fd00::/126".parse().unwrap();///     "fd00::".parse::<IpAddr>().unwrap(),subnetsIpSubnets/// Returns an `Iterator` over the subnets of this network with the/// given prefix length./// # use ipnet::{IpNet, PrefixLenError};/// let net: IpNet = "10.0.0.0/24".parse().unwrap();/// assert_eq!(net.subnets(26).unwrap().collect::<Vec<IpNet>>(), vec![///     "10.0.0.0/26".parse::<IpNet>().unwrap(),///     "10.0.0.64/26".parse().unwrap(),///     "10.0.0.128/26".parse().unwrap(),///     "10.0.0.192/26".parse().unwrap(),/// let net: IpNet = "fd00::/16".parse().unwrap();/// assert_eq!(net.subnets(18).unwrap().collect::<Vec<IpNet>>(), vec![///     "fd00::/18".parse::<IpNet>().unwrap(),///     "fd00:4000::/18".parse().unwrap(),///     "fd00:8000::/18".parse().unwrap(),///     "fd00:c000::/18".parse().unwrap(),/// assert_eq!(net.subnets(23), Err(PrefixLenError));/// assert_eq!(net.subnets(33), Err(PrefixLenError));/// assert_eq!(net.subnets(15), Err(PrefixLenError));/// assert_eq!(net.subnets(129), Err(PrefixLenError));/// Test if a network address contains either another network/// address or an IP address./// let net4: IpNet = "192.168.0.0/24".parse().unwrap();/// let net4_yes: IpNet = "192.168.0.0/25".parse().unwrap();/// let net4_no: IpNet = "192.168.0.0/23".parse().unwrap();/// let ip4_yes: IpAddr = "192.168.0.1".parse().unwrap();/// let ip4_no: IpAddr = "192.168.1.0".parse().unwrap();/// assert!(net4.contains(&net4));/// assert!(net4.contains(&net4_yes));/// assert!(!net4.contains(&net4_no));/// assert!(net4.contains(&ip4_yes));/// assert!(!net4.contains(&ip4_no));/// let net6: IpNet = "fd00::/16".parse().unwrap();/// let net6_yes: IpNet = "fd00::/17".parse().unwrap();/// let net6_no: IpNet = "fd00::/15".parse().unwrap();/// let ip6_yes: IpAddr = "fd00::1".parse().unwrap();/// let ip6_no: IpAddr = "fd01::".parse().unwrap();/// assert!(net6.contains(&net6));/// assert!(net6.contains(&net6_yes));/// assert!(!net6.contains(&net6_no));/// assert!(net6.contains(&ip6_yes));/// assert!(!net6.contains(&ip6_no));/// assert!(!net4.contains(&net6));/// assert!(!net6.contains(&net4));/// assert!(!net4.contains(&ip6_no));/// assert!(!net6.contains(&ip4_no));/// Aggregate a `Vec` of `IpNet`s and return the result as a new/// `Vec`./// let nets = vec![///     "10.0.0.0/24".parse::<IpNet>().unwrap(),///     "10.0.1.0/24".parse().unwrap(),///     "10.0.2.0/24".parse().unwrap(),///     "fd00::/18".parse().unwrap(),/// assert_eq!(IpNet::aggregate(&nets), vec![///     "10.0.0.0/23".parse::<IpNet>().unwrap(),///     "fd00::/17".parse().unwrap(),/// Creates a new IPv4 network address from an `Ipv4Addr` and prefix/// use ipnet::{Ipv4Net, PrefixLenError};/// let net = Ipv4Net::new(Ipv4Addr::new(10, 1, 1, 0), 24);/// let bad_prefix_len = Ipv4Net::new(Ipv4Addr::new(10, 1, 1, 0), 33);/// is not less then or equal to 32./// use ipnet::{Ipv4Net};/// const NET: Ipv4Net = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 24);/// let net = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 24);/// // const BAD_PREFIX_LEN: Ipv4Net = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 33);/// // let bad_prefix_len = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 33);/// Creates a new IPv4 network address from an `Ipv4Addr` and netmask./// let net = Ipv4Net::with_netmask(Ipv4Addr::new(10, 1, 1, 0), Ipv4Addr::new(255, 255, 255, 0));/// let bad_prefix_len = Ipv4Net::with_netmask(Ipv4Addr::new(10, 1, 1, 0), Ipv4Addr::new(255, 255, 0, 1));/// # use ipnet::Ipv4Net;///     "192.168.12.34/16".parse::<Ipv4Net>().unwrap().trunc(),/// # use std::net::Ipv4Addr;/// let net: Ipv4Net = "10.1.0.0/20".parse().unwrap();netmask_u32hostmask_u32/// let net: Ipv4Net = "172.16.123.123/16".parse().unwrap();/// let net: Ipv4Net = "172.16.0.0/22".parse().unwrap();/// Returns the `Ipv4Net` that contains this one./// let n1: Ipv4Net = "172.16.1.0/24".parse().unwrap();/// let n2: Ipv4Net = "172.16.0.0/23".parse().unwrap();/// let n3: Ipv4Net = "172.16.0.0/0".parse().unwrap();/// let n1: Ipv4Net = "10.1.0.0/24".parse().unwrap();/// let n2: Ipv4Net = "10.1.1.0/24".parse().unwrap();/// let n3: Ipv4Net = "10.1.2.0/24".parse().unwrap();/// assert!(n1.is_sibling(&n2));/// assert!(!n2.is_sibling(&n3));/// If the prefix length is less than 31 both the network address/// and broadcast address are excluded. These are only valid host/// addresses when the prefix length is 31./// let net: Ipv4Net = "10.0.0.0/30".parse().unwrap();/// assert_eq!(net.hosts().collect::<Vec<Ipv4Addr>>(), vec![///     "10.0.0.1".parse::<Ipv4Addr>().unwrap(),/// let net: Ipv4Net = "10.0.0.0/31".parse().unwrap();Ipv4Subnets/// # use ipnet::{Ipv4Net, PrefixLenError};/// let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();/// assert_eq!(net.subnets(26).unwrap().collect::<Vec<Ipv4Net>>(), vec![///     "10.0.0.0/26".parse::<Ipv4Net>().unwrap(),/// assert_eq!(net.subnets(32).unwrap().collect::<Vec<Ipv4Net>>(), vec![///     "10.0.0.0/32".parse::<Ipv4Net>().unwrap(),///     "10.0.0.1/32".parse().unwrap(),///     "10.0.0.2/32".parse().unwrap(),///     "10.0.0.3/32".parse().unwrap(),/// let net: Ipv4Net = "192.168.0.0/24".parse().unwrap();/// let net_yes: Ipv4Net = "192.168.0.0/25".parse().unwrap();/// let net_no: Ipv4Net = "192.168.0.0/23".parse().unwrap();/// let ip_yes: Ipv4Addr = "192.168.0.1".parse().unwrap();/// let ip_no: Ipv4Addr = "192.168.1.0".parse().unwrap();/// assert!(net.contains(&net));/// assert!(net.contains(&net_yes));/// assert!(!net.contains(&net_no));/// assert!(net.contains(&ip_yes));/// assert!(!net.contains(&ip_no));// It is significantly faster to work on u32 than Ipv4Addr./// Aggregate a `Vec` of `Ipv4Net`s and return the result as a new///     "10.0.0.0/24".parse::<Ipv4Net>().unwrap(),/// assert_eq!(Ipv4Net::aggregate(&nets), vec![///     "10.0.0.0/23".parse::<Ipv4Net>().unwrap(),/// Creates a new IPv6 network address from an `Ipv6Addr` and prefix/// use ipnet::{Ipv6Net, PrefixLenError};/// let net = Ipv6Net::new(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 24);/// let bad_prefix_len = Ipv6Net::new(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 129);/// is not less then or equal to 128./// use ipnet::{Ipv6Net};/// const NET: Ipv6Net = Ipv6Net::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 24);/// let net = Ipv6Net::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 24);/// // const BAD_PREFIX_LEN: Ipv6Net = Ipv6Net::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 129);/// // let bad_prefix_len = Ipv6Addr::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 129);/// Creates a new IPv6 network address from an `Ipv6Addr` and netmask./// let net = Ipv6Net::with_netmask(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), Ipv6Addr::from(0xffff_ff00_0000_0000_0000_0000_0000_0000));/// let bad_prefix_len = Ipv6Net::with_netmask(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), Ipv6Addr::from(0xffff_ff00_0000_0000_0001_0000_0000_0000));/// # use ipnet::Ipv6Net;///     "fd00::1:2:3:4/16".parse::<Ipv6Net>().unwrap().trunc(),/// let net: Ipv6Net = "fd00::/24".parse().unwrap();netmask_u128hostmask_u128/// let net: Ipv6Net = "fd00:1234:5678::/24".parse().unwrap();/// Returns the last address./// Technically there is no such thing as a broadcast address for/// IPv6. The name is used for consistency with colloquial usage./// Returns the `Ipv6Net` that contains this one./// # use std::str::FromStr;/// let n1: Ipv6Net = "fd00:ff00::/24".parse().unwrap();/// let n2: Ipv6Net = "fd00:fe00::/23".parse().unwrap();/// let n3: Ipv6Net = "fd00:fe00::/0".parse().unwrap();/// let n1: Ipv6Net = "fd00::/18".parse().unwrap();/// let n2: Ipv6Net = "fd00:4000::/18".parse().unwrap();/// let n3: Ipv6Net = "fd00:8000::/18".parse().unwrap();/// let net: Ipv6Net = "fd00::/126".parse().unwrap();/// assert_eq!(net.hosts().collect::<Vec<Ipv6Addr>>(), vec![Ipv6Subnets/// # use ipnet::{Ipv6Net, PrefixLenError};/// let net: Ipv6Net = "fd00::/16".parse().unwrap();/// assert_eq!(net.subnets(18).unwrap().collect::<Vec<Ipv6Net>>(), vec![///     "fd00::/18".parse::<Ipv6Net>().unwrap(),/// assert_eq!(net.subnets(128).unwrap().collect::<Vec<Ipv6Net>>(), vec![///     "fd00::/128".parse::<Ipv6Net>().unwrap(),///     "fd00::1/128".parse().unwrap(),///     "fd00::2/128".parse().unwrap(),///     "fd00::3/128".parse().unwrap(),/// let net_yes: Ipv6Net = "fd00::/17".parse().unwrap();/// let net_no: Ipv6Net = "fd00::/15".parse().unwrap();/// let ip_yes: Ipv6Addr = "fd00::1".parse().unwrap();/// let ip_no: Ipv6Addr = "fd01::".parse().unwrap();// It is significantly faster to work on u128 that Ipv6Addr./// Aggregate a `Vec` of `Ipv6Net`s and return the result as a new/// assert_eq!(Ipv6Net::aggregate(&nets), vec![///     "fd00::/17".parse::<Ipv6Net>().unwrap(),/// Provides a method to test if a network address contains either/// another network address or an IP address./// let n4_1: IpNet = "10.1.1.0/24".parse().unwrap();/// let n4_2: IpNet = "10.1.1.0/26".parse().unwrap();/// let n4_3: IpNet = "10.1.2.0/26".parse().unwrap();/// let ip4_1: IpAddr = "10.1.1.1".parse().unwrap();/// let ip4_2: IpAddr = "10.1.2.1".parse().unwrap();/// let n6_1: IpNet = "fd00::/16".parse().unwrap();/// let n6_2: IpNet = "fd00::/17".parse().unwrap();/// let n6_3: IpNet = "fd01::/17".parse().unwrap();/// let ip6_1: IpAddr = "fd00::1".parse().unwrap();/// let ip6_2: IpAddr = "fd01::1".parse().unwrap();/// assert!(n4_1.contains(&n4_2));/// assert!(!n4_1.contains(&n4_3));/// assert!(n4_1.contains(&ip4_1));/// assert!(!n4_1.contains(&ip4_2));/// assert!(n6_1.contains(&n6_2));/// assert!(!n6_1.contains(&n6_3));/// assert!(n6_1.contains(&ip6_1));/// assert!(!n6_1.contains(&ip6_2));/// assert!(!n4_1.contains(&n6_1) && !n6_1.contains(&n4_1));/// assert!(!n4_1.contains(&ip6_1) && !n6_1.contains(&ip4_1));/// An `Iterator` that generates IP network addresses, either IPv4 or/// IPv6./// Generates the subnets between the provided `start` and `end` IP/// addresses inclusive of `end`. Each iteration generates the next/// network address of the largest valid size it can, while using a/// prefix length not less than `min_prefix_len`./// # use std::net::{Ipv4Addr, Ipv6Addr};/// # use ipnet::{IpNet, IpSubnets, Ipv4Subnets, Ipv6Subnets};/// let subnets = IpSubnets::from(Ipv4Subnets::new(///     "10.0.0.239".parse().unwrap(),///     26,/// assert_eq!(subnets.collect::<Vec<IpNet>>(), vec![///     "10.0.0.0/26".parse().unwrap(),///     "10.0.0.192/27".parse().unwrap(),///     "10.0.0.224/28".parse().unwrap(),/// let subnets = IpSubnets::from(Ipv6Subnets::new(///     "fd00:ef:ffff:ffff:ffff:ffff:ffff:ffff".parse().unwrap(),///     "fd00::/26".parse().unwrap(),///     "fd00:40::/26".parse().unwrap(),///     "fd00:80::/26".parse().unwrap(),///     "fd00:c0::/27".parse().unwrap(),///     "fd00:e0::/28".parse().unwrap(),min_prefix_len// end is inclusive/// An `Iterator` that generates IPv4 network addresses./// # use ipnet::{Ipv4Net, Ipv4Subnets};/// let subnets = Ipv4Subnets::new(/// assert_eq!(subnets.collect::<Vec<Ipv4Net>>(), vec![/// An `Iterator` that generates IPv6 network addresses./// # use ipnet::{Ipv6Net, Ipv6Subnets};/// let subnets = Ipv6Subnets::new(/// assert_eq!(subnets.collect::<Vec<Ipv6Net>>(), vec![next_ipv4_subnetnext_ipv6_subnetmerge_intervals// Generic function for merging a vector of intervals.make_ipnet_vectest_make_ipnet_vectest_merge_intervalsmake_ipv4_subnets_testmake_ipv6_subnets_testtest_ipv4_subnets_zero_zerotest_ipv4_subnets_zero_maxtest_ipv4_subnets_max_maxtest_ipv4_subnets_nonetest_ipv4_subnets_onetest_ipv4_subnets_twotest_ipv4_subnets_tapertest_ipv6_subnets_zero_zerotest_ipv6_subnets_zero_maxtest_ipv6_subnets_max_maxtest_ipv6_subnets_nonetest_ipv6_subnets_onetest_ipv6_subnets_twotest_ipv6_subnets_tapertest_aggregatetest_aggregate_issue44ipnet_defaultipv4net_defaultipv6net_defaultipv4net_new_assert_panicsipv6net_new_assert_panicsschemarsJsonSchemaschema_namejson_schemaSchemaGeneratorSchematest_serialize_ipnet_v4test_serialize_ipnet_v6test_serialize_ipv4_nettest_serialize_ipv6_netAddrParseError//! Types for IPv4 and IPv6 network addresses.//! This module provides types and useful methods for working with IPv4//! and IPv6 network addresses, commonly called IP prefixes. The new//! [`IpNet`], [`Ipv4Net`], and [`Ipv6Net`] types build on the existing//! [`IpAddr`], [`Ipv4Addr`], and [`Ipv6Addr`] types already provided in//! Rust's standard library and align to their design to stay//! consistent.//! The module also provides the [`IpSubnets`], [`Ipv4Subnets`], and//! [`Ipv6Subnets`] types for iterating over the subnets contained in//! an IP address range. The [`IpAddrRange`], [`Ipv4AddrRange`], and//! [`Ipv6AddrRange`] types for iterating over IP addresses in a range.//! And traits that extend `Ipv4Addr` and `Ipv6Addr` with methods for//! addition, subtraction, bitwise-and, and bitwise-or operations that//! are missing in Rust's standard library.//! The module only uses stable features so it is guaranteed to compile//! using the stable toolchain.//! * [`IpNet`] represents an IP network address, either IPv4 or IPv6.//! * [`Ipv4Net`] and [`Ipv6Net`] are respectively IPv4 and IPv6 network//!   addresses.//! * [`IpSubnets`], [`Ipv4Subnets`], and [`Ipv6Subnets`] are iterators//!   that generate the smallest set of IP network addresses bound by an//!   IP address range and minimum prefix length. These can be created//!   using their constructors. They are also returned by the//!   [`subnets()`] methods and used within the [`aggregate()`] methods.//! * [`IpAddrRange`], [`Ipv4AddrRange`], and [`Ipv6AddrRange`] are//!   iterators that generate IP addresses. These can be created using//!   their constructors. They are also returned by the [`hosts()`]//!   methods.//! * The [`IpAdd`], [`IpSub`], [`IpBitAnd`], [`IpBitOr`] traits extend//!   the [`Ipv4Addr`] and [`Ipv6Addr`] types with methods to perform//!   these operations.//! [`IpNet`]: enum.IpNet.html//! [`Ipv4Net`]: struct.Ipv4Net.html//! [`Ipv6Net`]: struct.Ipv6Net.html//! [`IpAddr`]: https://doc.rust-lang.org/std/net/enum.IpAddr.html//! [`Ipv4Addr`]: https://doc.rust-lang.org/std/net/struct.Ipv4Addr.html//! [`Ipv6Addr`]: https://doc.rust-lang.org/std/net/struct.Ipv6Addr.html//! [`IpSubnets`]: enum.IpSubnets.html//! [`Ipv4Subnets`]: struct.Ipv4Subnets.html//! [`Ipv6Subnets`]: struct.Ipv6Subnets.html//! [`subnets()`]: enum.IpNet.html#method.subnets//! [`aggregate()`]: enum.IpNet.html#method.aggregate//! [`IpAddrRange`]: enum.IpAddrRange.html//! [`Ipv4AddrRange`]: struct.Ipv4AddrRange.html//! [`Ipv6AddrRange`]: struct.Ipv6AddrRange.html//! [`hosts()`]: enum.IpNet.html#method.hosts//! [`IpAdd`]: trait.IpAdd.html//! [`IpSub`]: trait.IpSub.html//! [`IpBitAnd`]: trait.IpBitAnd.html//! [`IpBitOr`]: trait.IpBitOr.html//! # Serde support//! This library comes with support for [serde](https://serde.rs) but//! it's not enabled by default. Use the `serde` [feature] to enable.//! ipnet = { version = "2", features = ["serde"] }//! For human readable formats (e.g. JSON) the `IpNet`, `Ipv4Net`, and//! `Ipv6Net` types will serialize to their `Display` strings.//! For compact binary formats (e.g. Bincode) the `Ipv4Net` and//! `Ipv6Net` types will serialize to a string of 5 and 17 bytes that//! consist of the network address octects followed by the prefix//! length. The `IpNet` type will serialize to an Enum with the V4 or V6//! variant index prepending the above string of 5 or 17 bytes.//! [feature]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section/// Converts a `IpAddr` network mask into a prefix./// If the mask is invalid this will return an `PrefixLenError`./// Converts a `Ipv4Addr` network mask into a prefix./// Converts a `Ipv6Addr` network mask into a prefix.v4_mask_to_prefixv4_mask_to_prefix_maxinvalid_v4_mask_to_prefixipv4net_with_netmaskv6_mask_to_prefixv6_mask_to_prefix_maxinvalid_v6_mask_to_prefixipv6net_with_netmask// parsing as ASCII, so can use byte arrayread_atomically// Commit only if parser returns Someread_till_eof// Commit only if parser read till EOFread_or// Return result of first successful parserPAPBread_seq_3// Apply 3 parsers sequentiallyread_char// Read next charread_given_char// Return char and advance iff next char is equal to requestedread_digit// Read digitread_number_implread_number// Read number, failing if max_digits of number value exceededread_ipv4_addr_implread_ipv4_addr// Read IPv4 addressread_ipv6_addr_implread_ipv6_addrread_ipv4_net// Read IPv4 networkread_ipv6_net// Read Ipv6 networkread_ip_net/* Additions for IpNet below. *//* Additions for IpNet above. *//// An error which can be returned when parsing an IP network address./// This error is used as the error type for the [`FromStr`] implementation for/// [`IpNet`], [`Ipv4Net`], and [`Ipv6Net`].//! A private parser implementation of IPv4 and IPv6 network addresses.//! The existing `std::net::parser` module cannot be extended because it//! is private. It is copied and extended here with methods for parsing//! IP network addresses.CensoredToDedicatedStringToStringFallibleNormalizationModePathCharacteristicPctCaseNormalizedfind_splitprior_byte2RiAbsoluteStrRiReferenceStrRiRelativeStrRiStrRiAbsoluteStringRiReferenceStringRiRelativeStringRiStringPortBuilderReprPortBuilder/// Port builder./// This type is intended to be created by `From` trait implementations, and/// to be passed to [`Builder::port`] method./// Empty port./// Port as an integer./// Note that RFC 3986 accepts any number of digits as a port, but/// practically (at least in TCP/IP) `u16` is enough./// Port as a string./// Internal representation of a port builder.UserinfoReprUserinfoBuilder/// Userinfo builder./// to be passed to [`Builder::userinfo`] method.to_user_password/// Decomposes the userinfo into `user` and `password`./// Not specified (absent)./// Direct `userinfo` content./// User name and password./// Internal representation of a userinfo builder.HostRepr/// Host./// Port./// Userinfo.AuthorityBuilder/// URI/IRI authority builder.fmt_write_to/// Writes the authority to the given formatter./// Direct string representation./// Dedicated IP address type./// Host representation./// Scheme./// Authority./// Path./// Query (without the leading `?`)./// Fragment (without the leading `#`)./// Normalization mode./// URI/IRI reference builder./// 1. Create builder by [`Builder::new()`][`Self::new`]./// 2. Set (or unset) components and set normalization mode as you wish./// 3. Validate by [`Builder::build()`][`Self::build`] and get [`Built`] value./// 4. Use [`core::fmt::Display`] trait to serialize the resulting [`Built`],///    or use [`From`]/[`Into`] traits to convert into an allocated string types./// # use iri_string::validate::Error;/// use iri_string::build::Builder;/// # #[cfg(not(feature = "alloc"))]/// # use iri_string::types::IriStr;/// use iri_string::types::{IriStr, IriString};/// // 1. Create builder./// // 2. Set (or unset) component and normalization mode./// builder.scheme("http");/// builder.host("example.com");/// builder.path("/foo/../");/// builder.normalize();/// // 3. Validate and create the result./// let built = builder.build::<IriStr>()?;/// // 4a. Serialize by `Display` trait (or `ToString`)./// let s = built.to_string();/// assert_eq!(s, "http://example.com/");/// // 4b. Convert into an allocated string types./// // Thanks to pre-validation by `.build::<IriStr>()`, this conversion is infallible!/// let s: IriString = built.into();/// # Ok::<_, Error>(())/// Creates a builder with empty data./// use iri_string::types::IriReferenceStr;/// let builder = Builder::new();/// let iri = builder.build::<IriReferenceStr>()?;/// assert_eq!(iri.to_string(), "");/// Don't expose this as public, since this method does not validate./// # Preconditions/// The IRI string to be built should be a valid IRI reference./// Callers are responsible to validate the component values before calling/// Builds the proxy object that can be converted to the desired IRI string type./// use iri_string::types::IriStr;/// use iri_string::types::IriString;/// builder.path("/foo/bar");/// // The returned value implements `core::fmt::Display` and/// // `core::string::ToString`./// assert_eq!(built.to_string(), "http://example.com/foo/bar");/// // The returned value implements `Into<{iri_owned_string_type}>`./// let iri = IriString::from(built);/// // `let iri: IriString = built.into();` is also OK./// Sets the scheme./// builder.scheme("foo");/// assert_eq!(iri.to_string(), "foo:");unset_scheme/// Unsets the scheme./// builder.unset_scheme();/// Sets the path./// Note that no methods are provided to "unset" path since every IRI/// references has a path component (although it can be empty)./// If you want to "unset" the path, just set the empty string./// builder.path("foo/bar");/// assert_eq!(iri.to_string(), "foo/bar");authority_builder/// Initializes the authority builder.unset_authority/// Unsets the authority./// builder.unset_authority();/// Sets the userinfo./// `userinfo` component always have `user` part (but it can be empty)./// Note that `("", None)` is considered as an empty userinfo, rather than/// unset userinfo./// Also note that the user part cannot have colon characters./// builder.userinfo("user:pass");/// assert_eq!(iri.to_string(), "//user:pass@");/// You can specify `(user, password)` pair./// builder.userinfo(("user", Some("pass")));///     builder.clone().build::<IriReferenceStr>()?.to_string(),///     "//user:pass@"/// `("", None)` is considered as an empty userinfo./// builder.userinfo(("", None));/// assert_eq!(iri.to_string(), "//@");unset_userinfo/// Unsets the port./// // Note that this does not unset the entire authority./// // Now empty authority is set./// builder.unset_userinfo();/// assert_eq!(iri.to_string(), "//");/// Sets the reg-name or IP address (i.e. host) without port./// Note that no methods are provided to "unset" host./// Depending on your situation, set empty string as a reg-name, or unset/// the authority entirely by [`unset_authority`][`Self::unset_authority`]/// assert_eq!(iri.to_string(), "//example.com");ip_address/// Sets the IP address as a host./// builder.ip_address(std::net::Ipv4Addr::new(192, 0, 2, 0));/// assert_eq!(iri.to_string(), "//192.0.2.0");/// Sets the port./// builder.port(80_u16);/// // Accepts other types that implements `Into<PortBuilder<'a>>`./// //builder.port(80_u8);/// //builder.port("80");/// assert_eq!(iri.to_string(), "//:80");unset_port/// builder.unset_port();/// Sets the query./// The string after `?` should be specified./// builder.query("q=example");/// assert_eq!(iri.to_string(), "?q=example");unset_query/// Unsets the query./// builder.unset_query();/// Sets the fragment./// The string after `#` should be specified./// builder.fragment("anchor");/// assert_eq!(iri.to_string(), "#anchor");unset_fragment/// Unsets the fragment./// builder.unset_fragment();unset_normalize/// Stop normalizing the result./// // `%75%73%65%72` is "user"./// builder.userinfo("%75%73%65%72");/// builder.host("EXAMPLE.COM");/// builder.port("");/// builder.path("/foo/../%2e%2e/bar/%2e/baz/.");/// builder.unset_normalize();///     iri.to_string(),///     "http://%75%73%65%72@EXAMPLE.COM:/foo/../%2e%2e/bar/%2e/baz/."/// Normalizes the result using RFC 3986 syntax-based normalization and/// WHATWG URL Standard algorithm./// # Normalization/// If `scheme` or `authority` component is present or the path is absolute,/// the build result will fully normalized using full syntax-based normalization:/// * case normalization ([RFC 3986 6.2.2.1]),/// * percent-encoding normalization ([RFC 3986 6.2.2.2]), and/// * path segment normalization ([RFC 3986 6.2.2.2])./// However, if both `scheme` and `authority` is absent and the path is relative/// (including empty), i.e. the IRI reference to be built starts with the/// relative `path` component, path segment normalization will be omitted./// This is because the path segment normalization depends on presence or/// absense of the `authority` components, and will remove extra `..`/// segments which should not be ignored./// Note that `path` must already be empty or start with a slash **before/// the normalizaiton** if `authority` is present./// # WHATWG URL Standard/// If you need to avoid WHATWG URL Standard serialization, use/// [`Built::ensure_rfc3986_normalizable`] method to test if the result is/// normalizable without WHATWG spec./// assert_eq!(iri.to_string(), "http://user@example.com/bar/baz/");// Setters does not return `&mut Self` or `Self` since it introduces needless// ambiguity for users.// For example, if setters return something and allows method chaining, can you// correctly explain what happens with the code below without reading document?// ```text// let mut builder = Builder::new().foo("foo").bar("bar");// let baz = builder.baz("baz").clone().build();// // Should the result be foo+bar+qux, or foo+bar+baz+qux?// let qux = builder.qux("qux").build();/// Builder with the validated content./// Whether the path is absolute._ty_str/// String type./// [`Display`]-able IRI build result./// The value of this type can generate an IRI using [`From`]/[`Into`] traits or/// [`Display`] trait./// # Security consideration/// This can be stringified or directly printed by `std::fmt::Display`, but note/// that this `Display` **does not hide the password part**. Be careful **not to/// print the value using `Display for Built<_>` in public context**./// [`From`]: `core::convert::From`/// [`Into`]: `core::convert::Into`/// [`Display`]: `core::fmt::Display`impl_stringifiers/// Implements conversions to a string.r" Returns Ok`(())` if the IRI is normalizable by the RFC 3986 algorithm."ensure_rfc3986_normalizabletry_to_dedicated_string/// A trait for borrowed IRI string types buildable by the [`Builder`].validate_buildervalidate_builder_for_iri_reference/// Checks whether the builder output is valid IRI reference./// Returns whether the path is absolute./// Validates the content of the builder and returns the validated type if possible./// A trait for types buildable by the [`Builder`]./// Private module to put the trait to seal.//! URI/IRI builder.//! See the documentation of [`Builder`] type.trustedtrusted_parser/// Authority string, excluding the leading `//`.host_start/// Start position of the `host`.host_end/// End position of the `host`.AuthorityComponents/// Subcomponents of authority./// This is a return type of the `authority_components` method of the string/// types (for example [`RiStr::authority_components`]./// [`RiStr::authority_components`]: `crate::types::RiStr::authority_components`from_iri/// Creates a new `AuthorityComponents` from the IRI./// Returns the `userinfo` part, excluding the following `@`./// Returns the `host` part./// Returns the `port` part, excluding the following `:`.IriReferenceStrUSERINFOPORTcompose_to_relative_iritest_decompose_authority//! Subcomponents of authority.scheme_end/// Scheme end.authority_end/// Authority end./// Note that absence of the authority and the empty authority is/// distinguished.query_start/// Query start (after the leading `?`).fragment_start/// Fragment start (after the leading `#`).Splitter/// Positions to split an IRI into components./// Creates a new splitter.split_into_major/// Decomposes an IRI into five major components: scheme, authority, path, query, and fragment.scheme_range/// Returns the range for the scheme part./// Returns the scheme as a string.has_scheme/// Returns true if the IRI has a scheme part, false otherwise.authority_range/// Returns the range for the authority part.authority_str/// Returns the authority as a string.has_authority/// Returns true if the IRI has an authority part, false otherwise.path_range/// Returns the range for the path part.path_str/// Returns the path as a string.is_path_empty/// Returns true if the path part of the IRI is empty.query_range/// Returns the range for the query part excluding a prefix `?`./// Returns the query as a string.has_query/// Returns true if the IRI has a query part, false otherwise.fragment_range/// Returns the range for the fragment part excluding a prefix `#`.fragment_str/// Returns the fragment as a string.iri/// Original complete string.splitter/// Positions to split the IRI into components.RiReferenceComponents/// Components of an IRI reference./// See <https://tools.ietf.org/html/rfc3986#section-5.2.2>.to_major/// Returns five major components: scheme, authority, path, query, and fragment./// Returns the IRI reference.//! Components of IRIs.RiFragmentStrRiQueryStrRiFragmentStringRiQueryStringUriAbsoluteStringUriFragmentStringUriQueryStringUriReferenceStringUriRelativeStringUriStringHEXDIGITS/// Hexadecimal digits for a nibble.MappedToUri/// A resource identifier mapped to a URI of some kind./// Supported `Src` type are:/// * IRIs:///     + [`IriAbsoluteStr`] (alias of `RiAbsoluteStr<IriSpec>`)///     + [`IriReferenceStr`] (alias of `RiReferenceStr<IriSpec>`)///     + [`IriRelativeStr`] (alias of `RiRelativeStr<IriSpec>`)///     + [`IriStr`] (alias of `RiStr<IriSpec>`)/// * URIs:///     + [`UriAbsoluteStr`] (alias of `RiAbsoluteStr<UriSpec>`)///     + [`UriReferenceStr`] (alias of `RiReferenceStr<UriSpec>`)///     + [`UriRelativeStr`] (alias of `RiRelativeStr<UriSpec>`)///     + [`UriStr`] (alias of `RiStr<UriSpec>`)/// use iri_string::convert::MappedToUri;/// use iri_string::types::{IriStr, UriStr};/// let src = IriStr::new("http://example.com/?alpha=\u{03B1}")?;/// // The type is `MappedToUri<IriStr>`, but you usually don't need to specify./// let mapped = MappedToUri::from(src).to_string();/// assert_eq!(mapped, "http://example.com/?alpha=%CE%B1");/// # Ok::<_, iri_string::validate::Error>(())/// [`IriAbsoluteStr`]: crate::types::IriAbsoluteStr/// [`IriReferenceStr`]: crate::types::IriReferenceStr/// [`IriRelativeStr`]: crate::types::IriRelativeStr/// [`IriStr`]: crate::types::IriStr/// [`UriAbsoluteStr`]: crate::types::UriAbsoluteStr/// [`UriReferenceStr`]: crate::types::UriReferenceStr/// [`UriRelativeStr`]: crate::types::UriRelativeStr/// [`UriStr`]: crate::types::UriStrimpl_for_iri/// Implement conversions for an IRI string type.write_percent_encoded/// Percent-encodes and writes the IRI string using the given buffer.percent_encode_bytes/// Percent-encode the string and pass the encoded chunks to the given function./// `buf` is used as a temporary working buffer. It is initialized by this/// function, so users can pass any mutable byte slice with enough size./// # Precondition/// The length of `buf` must be 3 bytes or more.try_percent_encode_iri_inline/// Percent-encodes the given IRI using the given buffer.count_nonascii/// Returns the number of non-ASCII characters.//! Conversion between URI/IRI types.CapacityOverflowError/// Output buffer capacity overflow error./// Destination buffer./// Position to write the next string fragment.ByteBufWriter/// Writer to the bytes buffer.write_to_slice/// Writes to the bytes buffer./// Memory allocation error.StringWriter/// Writer that fails (not panics) on OOM.try_append_to_string/// Appends the data to the string./// When allocation failure happens, incompletely appended strings won't be/// stripped. Callers are responsible to clean up the destination if necessary.eq_str_display/// Returns true if the two equals after they are converted to strings./// A debug-printable type to hide the sensitive information.try_to_string/// [`ToString::to_string`][`alloc::string::ToString::to_string`], but without panic on OOM./// [`ToString`][`alloc::string::ToString`], but without panic./// Conversion target type./// Converts the value to the allocated string.to_dedicated_string/// Panics if memory allocation error occured./// A trait for types that can be converted to a dedicated allocated string types.eq_str_display_1//! Utilities for formatting (especially `Display` trait).//! This module contains utilities for [`Display`][`core::fmt::Display`]-ablemask_passwordpercent_encode//! String types for [RFC 3987 Internationalized Resource Identifiers (IRIs)][RFC 3987] and//! [RFC 3986 Uniform Resource Identifiers (URIs)][RFC 3986].//! Note that this crate does not have any extra knowledge about protocols.//! Comparisons between IRI strings by `PartialEq` and `Eq` is implemented as [simple string//! comparison](https://tools.ietf.org/html/rfc3986#section-6.2.1).//! You should implement by yourself or use another crate to use such extra knowledge to compare//! IRIs / URIs.//! # Capability//! This crate provides many features for IRIs / URIs.//! ## String types//! [`types` module][`types`] module provides various string types for IRIs and URIs.//! The borrowed string types are unsized slice types (such as `[u8]` and `str`)//! and not a sized struct, so they are highly interoperable with for example//! `Cow` and `Rc`. Conversions between `&str` and borrwed IRI string types are easy.//! ## Resolvers//! [`resolve` module][`resolve`] provides IRI / URI references resolver.//! However, you are recommended to use methods of string types such as//! [`RiReferenceStr::resolve_against()`] or [`RiRelativeStr::resolve_against()`]//! if you don't intend to resolve multiple IRIs against the same base.//! ## Validators//! Validator functions are provided from [`validate` module][`validate`].//! ## Percent encoding//! [`percent_encode` module][`percent_encode`] provides a converter to encode//! user-provided string into percent-encoded one (if syntax requires so).//! ## IRI builder//! [`build` module][`build`] provides IRI builder.//! ## URI template (RFC 6570)//! [`template` module][`template`] provides an RFC 6570 URI Template processor.//! # Feature flags//! ## `std` and `alloc` support//! This crate supports `no_std` usage.//! * `alloc` feature://!     + Std library or `alloc` crate is required.//!     + This feature enables types and functions which require memory allocation,//!       e.g. `types::IriString` and `types::IriRelativeStr::resolve_against()`.//! * `std` feature (**enabled by default**)://!     + Std library is required.//!     + This automatically enables `alloc` feature.//!     + The feature let the crate utilize std-specific stuff, such as `std::error::Error` trait.//! * With neither of them://!     + The crate can be used in `no_std` environment.//! ## Other features//! * `serde`//!     + Enables serde support.//!     + Implement `Serailize` and `Deserialize` traits for IRI / URI types.//! * `memchr`//!     + Enables faster internal character search.//! # Rationale//! ## `foo:`, `foo:/`, `foo://`, `foo:///`, `foo:////`, ... are valid IRIs//! All of these are valid IRIs.//! (On the other hand, all of them are invalid as relative IRI reference, because they don't//! match `relative-part` rule, especially `path-noscheme`, as the first path component of the//! relative path contains a colon.)//! * `foo:`//!     + Decomposed to `<scheme="foo">:<path-empty="">`.//! * `foo:/`//!     + Decomposed to `<scheme="foo">:<path-absolute="/">`.//! * `foo://`//!     + Decomposed to `<scheme="foo">://<authority=""><path-absolute="">`.//! * `foo:///`//!     + Decomposed to `<scheme="foo">://<authority=""><path-absolute="/">`.//! * `foo:////`//!     + Decomposed to `<scheme="foo">://<authority=""><path-absolute="//">`.//! * `foo://///`//!     + Decomposed to `<scheme="foo">://<authority=""><path-absolute="///">`.//! RFC 3986 says that "if authority is absent, path cannot start with `//`".//! > When authority is present, the path must either be empty or begin with a slash ("/")//! > character. When authority is not present, the path cannot begin with two slash characters//! > ("//").//! > --- [RFC 3986, section 3. Syntax Components](https://tools.ietf.org/html/rfc3986#section-3).//! > If a URI contains an authority component, then the path component must either be empty or//! > begin with a slash ("/") character. If a URI does not contain an authority component, then the//! > path cannot begin with two slash characters ("//").//! > --- [RFC 3986, section 3.3. Path](https://tools.ietf.org/html/rfc3986#section-3.3)//! We should interpret them as "if `authority` rule is completely unused (i.e. does not match any//! strings **including empty string**), path cannot start with `//`".//! In other words, we should consider this as **explaining the ABNF of `hier-part` rule**//! (especially why it does not use `path` rule), but **not adding extra restriction to the rule//! written in ABNF**.//! This restriction is necessary to remove ambiguity in decomposition of some strings.//! For example, it is natural to decompose `foo://` to `<scheme="foo">:<path="//">` or//! `<scheme="foo">://<authority=""><path="">`.//! The restriction, **which is already encoded to the ABNF rule**, tells us to always decompose to//! the latter form, rather than the former one.//! Readers of the spec might be confused by "when authority is **present**" and "if a URI//! **contains** an authority component, which is unclear.//! However, based on the interpretation above, we should consider authority part with empty string//! as satisfying the condition "authority is **present**".//! ## IRI resolution can fail//! For some inputs, resulting string of IRI normalization and resolution can be syntactically//! correct but semantically wrong. In such cases, the normalizer and resolver provided by this//! crate do not silently "fix" the IRI by non-standard processing, but just//! fail by returning `Err(_)`.//! For details, see the documentation of [`normalize`] module.//! [RFC 3986]: https://tools.ietf.org/html/rfc3986//! [RFC 3987]: https://tools.ietf.org/html/rfc3987//! [`RiReferenceStr::resolve_against()`]: `types::RiReferenceStr::resolve_against`//! [`RiRelativeStr::resolve_against()`]: `types::RiRelativeStr::resolve_against`password_range_to_hide/// Returns the range of the password to hide.write_with_masked_password/// Writes the URI with the password part replaced.write_trim_password/// Writes an IRI with the password part trimmed.iri_ref/// IRI reference.PasswordMasked/// A wrapper of an IRI string that masks the non-empty password when `Display`ed./// This is a retrun type of `mask_password` method of IRI string types (such as/// [`RiStr::mask_password`])./// use iri_string::types::UriReferenceStr;/// let iri = UriReferenceStr::new("http://user:password@example.com/path?query")?;/// let masked = iri.mask_password();/// assert_eq!(masked.to_string(), "http://user:@example.com/path?query");///     masked.replace_password("${password}").to_string(),///     "http://user:${password}@example.com/path?query"/// [`RiStr::mask_password`]: `crate::types::RiStr::mask_password`/// Creates a new `PasswordMasked` object.impl_mask/// Implements traits for `PasswordMasked`.r" Replaces the password with the given arbitrary content."r" Note that the result might be invalid as an IRI since arbitrary string"r" can go to the place of the password."r" # use iri_string::validate::Error;"r#" # #[cfg(feature = "alloc")] {"#r" use iri_string::format::ToDedicatedString;"r" use iri_string::types::IriReferenceStr;"r#" let iri = IriReferenceStr::new("http://user:password@example.com/path?query")?;"#r" let masked = iri.mask_password();"r" assert_eq!("r#"     masked.replace_password("${password}").to_string(),"#r#"     "http://user:${password}@example.com/path?query""#r" );"r" # Ok::<_, Error>(())"replace_passwordPasswordReplacedr" let replaced = masked"r#"     .replace_password_with(|password| format!("{{{} chars}}", password.len()));"#r"     replaced.to_string(),"r#"     "http://user:{8 chars}@example.com/path?query""#replace_password_with/// Password range and alternative content./// A wrapper of an IRI string that replaces the non-empty password when `Display`ed./// Note that the result might be invalid as an IRI since arbitrary string can/// go to the place of the password./// [`PasswordMasked::replace_password`]: `PasswordMasked::replace_password`with_replacer/// The given string must be a valid IRI reference.impl_replace/// Implements traits for `PasswordReplaced`.//! Password masker./// IRI normalization and resolution error./// For detail about resolution failure, see [the module documentation][`crate::resolve`].//! Normalization and resolution error.find_split_holeUriSpecpct_caseNormalizationOp/// The result. No more processing is needed.PathToNormalizeNeedsProcessing/// Not yet completely processed path./// Path that is (possibly) not yet processed or being processed./// Path that needs merge and/or dot segment removal./// # Invariants/// If the first field (prefix field) is not `None`, it must end with a slash.from_single_path/// Creates a `PathToNormalize` from the given single path.from_paths_to_be_resolved/// Creates a `PathToNormalize` from the given base and reference paths to be resolved./// Returns true if the path is empty string./// Returns the length of the not yet normalized path.len_prefix/// Returns the length of the prefix part./// Returns 0 if the prefix part is empty.byte_at/// Returns a byte at the given position.find_next_slash/// Returns the position of the next slash of the byte at the given position.remove_start/// Removes the `len` characters from the beginning of `self`.remove_ignorable_prefix/// Removes the prefix that are ignorable on normalization.// Skips the prefix dot segments without leading slashes (such as `./`,// `../`, and `../.././`).// This is necessary because such segments should be removed with the// FOLLOWING slashes, not leading slashes.fmt_write_normalize/// Writes the normalized path.emit_segment/// Emits a non-dot segment and update the current state.// `first_segment_has_leading_slash` can be any value if the segment is not the first one.ensure_rfc3986_normalizable_with_authority_absent/// Checks if the path is normalizable by RFC 3986 algorithm when the authority is absent./// Returns `Ok(())` when normalizable, returns `Err(_)` if not.CommonAbsolute/// Absolute path, not special.CommonRelativeRelativeFirstSegmentHasColon/// The first path segment of the relative path has one or more colon characters.StartsWithDoubleSlash/// The path starts with the double slash./// Characteristic of a path.is_absolute/// Returns true if the path is absolute.from_path_to_display/// Returns the characteristic of the path.SegmentKind/// `.` or the equivalents.DotDot/// `..` or the equivalents./// Other normal (not special) segments./// Path segment kind.from_segment/// Creates a new `SegmentKind` from the given segment name.has_leading_slash/// Presence of a leading slash./// Range of the segment name (without any slashes)./// A segment with optional leading slash./// Returns the segment without any slashes./// Returns the segment kind./// Current cursor position.PathSegmentsIter/// Iterator of path segments./// Creates a new iterator of path segments.//! Path normalization.is_ascii_unreservedis_unreservedis_utf8_byte_continuetake_first_chartake_xdigits2is_pct_case_normalized/// Returns true if the given string is percent-encoding normalized and case/// normalized./// Note that normalization of ASCII-only host requires additional case/// normalization, so checking by this function is not sufficient for that case.into_char_trusted/// Returns a character for the slice./// Essentially equivalent to `core::str::from_utf8(bytes).unwrap().and_then(|s| s.get(0))`,/// but this function fully trusts that the input is a valid UTF-8 string with/// only one character.segname/// Valid segment name to normalize._spec/// Spec./// Writable as a normalized path segment percent-encoding IRI./// This wrapper does the things below when being formatted:/// * Decode unnecessarily percent-encoded characters./// * Convert alphabetic characters uppercase in percent-encoded triplets./// Note that this does not newly encode raw characters./// The given string should be the valid path segment./// Creates a new `PctCaseNormalized` value.host_port/// Valid host (and additionaly port) to normalize.NormalizedAsciiOnlyHost/// Writable as a normalized ASCII-only `host` (and optionally `port` followed)./// Creates a new `NormalizedAsciiOnlyHost` value./// The given string should be the valid ASCII-only `host` or/// `host ":" port` after percent-encoding normalization./// In other words, [`parser::trusted::is_ascii_only_host`] should return/// true for the given value./// [`parser::trusted::is_ascii_only_host`]: `crate::parser::trusted::is_ascii_only_host`IriSpeciri_unreservediri_middle_decodeascii_reservedascii_forbiddenascii_unreserved//! Percent-encoding normalization and case normalization.rfind_split_holeis_ascii_only_host/// No normalization./// Default normalization mode./// Applies RFC 3986 normalization whenever possible. When not possible,/// applies serialization algorithm defined in WHATWG URL standard.PreserveAuthoritylessRelativePath/// WHATWG-like normalization mode./// Preserves relative path as is (modulo case/pct normalization) when the/// authority component is absent./// Normalization algorithm.case_pct_normalization/// Returns true if case normalization and percent-encoding normalization should be applied./// Note that even when this option is `true`, plain US-ASCII characters/// won't be automatically lowered. Users should apply case normalization/// for US-ASCII only `host` component by themselves.NormalizednessCheckMode/// Default algorithm (corresponding to [`NormalizationMode::Default`]).Rfc3986/// Strict RFC 3986 normalization./// WHATWG-like normalization algorithm (corresponding to/// [`NormalizationMode::PreserveAuthoritylessRelativePath`])./// Normalizedness check algorithm./// Normalization operation./// Target scheme./// Target authority./// Target path without dot-removal./// Target query./// Target fragment./// Normalization type.NormalizationInput/// Spec-agnostic IRI normalization/resolution input.with_resolution_params/// Creates a `NormalizedInput` from IRIs to resolve.create_normalization_input/// Creates a `NormalizationInput` from components to resolve an IRI./// Checks if the path is normalizable by RFC 3986 algorithm./// Spec-agnostic normalization input.NormalizedInner/// Writable as a normalized IRI./// Note that this implicitly apply serialization rule defined by WHATWG URL/// Standard (to handle normalization impossible by RFC 3986) because `Display`/// should not fail by reasons other than backend I/O failure. If you make the/// normalization fail in such cases, check if the path starts with `/./`./// When the normalization succeeds by RFC 3986 algorithm, the path never starts/// with `/./`.from_input/// Creates a new `Normalized` object from the given input.normalize_scheme/// Writes the normalized scheme.normalize_authority/// Writes the normalized authority.normalize_host_port/// Writes the normalized host and port.normalize_query/// Writes the normalized query without the '?' prefix.normalize_fragment/// Writes the normalized query without the '#' prefix./// Expected result type./// Normalized OR resolved IRI./// Resolved IRI can be represented by this type. In that case, the result might/// not be normalized. If you want the IRI resolution result to be normalized,/// use [`enable_normalization`][`Self::enable_normalization`] method.enable_normalization/// Enables the normalization./// This lets the normalizer apply the case normalization, percent-encoding/// normalization, and dot segments removal.enable_normalization_preserving_authorityless_relative_path/// Enables the normalization that preserve relative path under some condition./// Note that this normalization algorithm is not compatible with RFC 3986/// algorithm for some inputs./// See [`RiStr::normalize_but_preserve_authorityless_relative_path()`]/// for detail.and_normalize/// Returns `Self` with normalization enabled.and_normalize_but_preserve_authorityless_relative_path/// Returns `Self` with special normalization enabled.//! Normalization.//! # IRI normalization (and resolution) can fail//! Though this is not explicitly stated in RFC 3986, IRI normalization can fail.//! For example, `foo:.///bar`, `foo:./..//bar`, and `foo:/..//bar` are all//! normalized to `foo://bar` as a string. However, IRI without authority (note//! that this is different from "with empty authority") cannot have a path//! starting with `//`, since it is ambiguous and can be interpreted as an IRI//! with authority. So, `foo://bar` is decomposed as scheme `foo`, authority//! `bar`, and empty path. The expected result is the combination of scheme//! `foo`, no authority, and path `//bar` (though this is not possible to//! serialize), so the algorithm fails as it cannot return the intended result.//! IRI resolution can also fail since it (conditionally) invokes normalization//! during the resolution process. For example, resolving a reference `.///bar`//! or `/..//bar` against the base `foo:` fail.//! Thus, IRI resolution can fail for some abnormal cases.//! Note that this kind of failure can happen only when the base IRI has no//! authority and empty path. This would be rare in the wild, since many people//! would use an IRI with authority part, such as `http://`.//! If you are handling `scheme://`-style URIs and IRIs, don't worry about the//! failure. Currently no cases are known to fail when at least one of the base//! IRI or the relative IRI contains authorities.//! To know what will happen on resolution failure, see the module documentation//! for [`resolve`][`crate::resolve`].//! ### Normalization failure//! use iri_string::normalize::Error;//! use iri_string::types::{IriAbsoluteStr, IriReferenceStr};//! let base = IriAbsoluteStr::new("foo:.///bar")?;//! assert!(//!     base.normalize().ensure_rfc3986_normalizable().is_err(),//!     "this normalization should fails without WAHTWG URL Standard serialization"//! # Ok::<_, iri_string::validate::Error>(())//! ### Resolution failure//! let base = IriAbsoluteStr::new("scheme:")?;//!     let reference = IriReferenceStr::new(".///bar")?;//!     let result = reference.resolve_against(base)//!         .ensure_rfc3986_normalizable();//!     assert!(result.is_err());//!     let reference2 = IriReferenceStr::new("/..//bar")?;//!     // Resulting string will be `scheme://bar`, but `bar` should be a path//!     // segment, not a host. So, the semantically correct target IRI cannot//!     // be represented.//!     let result2 = reference2.resolve_against(base)//!     assert!(result2.is_err());MASK_SCHEME_CONTINUE/// A mask to test whether the character is continue character of `scheme`.// `ALPHA / DIGIT / "+" / "-" / "."`MASK_UNRESERVED/// A mask to test whether the character matches `unreserved`.// `unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"`MASK_GEN_DELIMS/// A mask to test whether the character matches `gen-delims`.// `gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"`MASK_SUB_DELIMS/// A mask to test whether the character matches `sub-delims`.// `sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="`MASK_PCHAR/// A mask to test whether the character matches `pchar` (modulo percent-encoded bytes).// `pchar = unreserved / pct-encoded / sub-delims / ":" / "@"`MASK_FRAG_QUERY/// A mask to test whether the character can appear in `query` and `fragment`.// `query = *( pchar / "/" / "?" )`// `fragment = *( pchar / "/" / "?" )`MASK_USERINFO_IPVFUTUREADDR/// A mask to test whether the character can appear in `userinfo` and address of `IPvFuture`.// `userinfo = *( unreserved / pct-encoded / sub-delims / ":" )`MASK_PCHAR_SLASH/// A mask to test whether the character matches `pchar` (modulo percent-encoded bytes) or slash./// ASCII characters' properties.is_ascii_scheme_continue/// Returns `true` if the given ASCII character is allowed as continue character of `scheme` part./// Returns `true` if the given ASCII character matches `unreserved`./// Returns true if the character is unreserved.is_ascii_pchar/// Returns `true` if the given ASCII character matches `pchar` modulo `pct-encoded`.is_ascii_frag_query/// Returns `true` if the given ASCII character is allowed to appear in `query` and `fragment`.is_nonascii_query/// Returns `true` if the given non-ASCII character is allowed to appear in `iquery`.is_nonascii_fragment/// Returns `true` if the given non-ASCII character is allowed to appear in `ifragment`.is_ascii_userinfo_ipvfutureaddr/// Returns `true` if the given ASCII character is allowed to appear in `userinfo` and `IPvFuture`.is_nonascii_userinfo/// Returns `true` if the given non-ASCII character is allowed to appear in `iuserinfo`.is_ascii_regname/// Returns `true` if the given ASCII character is allowed to appear in `reg-name`is_nonascii_regname/// Returns `true` if the given non-ASCII character is allowed to appear in `ireg-name`.is_ascii_pchar_slash/// Returns `true` if the given ASCII character matches `pchar` modulo `pct-encoded` or a slash.is_ucschar/// Checks if the given character matches `ucschar` rule./// Returns true if the given value is a continue byte of UTF-8.is_ascii_unreserved_or_reserved/// Returns true if the given ASCII character is `unreserved` or `reserved`.//! Characters.///// Returns `true` if the given ASCII character matches `gen-delims`.//#[inline]//pub(crate) const fn is_ascii_gen_delims(c: u8) -> bool {//    (TABLE[c as usize] & MASK_GEN_DELIMS) != 0///// Returns `true` if the given ASCII character matches `sub-delims`.//pub(crate) const fn is_ascii_sub_delims(c: u8) -> bool {//    (TABLE[c as usize] & MASK_SUB_DELIMS) != 0///// Returns `true` if the given ASCII character matches `reserved`.//pub(crate) const fn is_ascii_reserved(c: u8) -> bool {//    (TABLE[c as usize] & (MASK_GEN_DELIMS | MASK_SUB_DELIMS)) != 0hexdigits_to_bytePctEncodedFragmentsNoPctStr/// String fragment without percent-encoded triplets.StrayPercent/// Stray `%` (percent) character./// Valid percent-encoded triplets for a character.InvalidUtf8PctTriplets/// Percent-encoded triplets that does not consists of a valid UTF-8 sequence./// Fragment in a possibly percent-encoded (and possibly broken) string.process_percent_encoded_best_effort/// Processes characters in a string which may contain (possibly invalid) percent-encoded triplets./// Output function.DecoderBuffer/// Decoder./// Buffer./// Result of the last output function call._r/// Dummy field for the type parameter of the return type of the function `f`.DecomposeWriter/// Writer to decompose the input into fragments.result_continue_or_err/// Returns `Ok(_)` if the stored result is `Continue`, and `Err(_)` otherwise.output_as_undecodable/// Calls the output functions with the undecodable fragments.PushResultNeedMoreBytes/// Input is still incomplete, needs more bytes to get the decoding result./// Bytes decodable to valid UTF-8 sequence.// `.0`: Length of decodable fragment.// `.1`: Decoded character.Undecodable/// Valid percent-encoded triplets but not decodable to valid UTF-8 sequence.// `.0`: Length of undecodable fragment./// A type for result of feeding data to [`DecoderBuffer`]./// Percent-encoded triplets that possibly consists a valid UTF-8 sequence after decoded.// `3 * 4`: 3 ASCII characters for single percent-encoded triplet, and// 4 triplets at most for single Unicode codepoint in UTF-8./// Decoded bytes.len_encoded/// Number of bytes available in `buf_encoded` buffer./// `buf_encoded_len / 3` also indicates the length of data in `decoded`./// Buffer to contain (and to decode) incomplete percent-encoded triplets.write_and_pop/// Writes the data of the given length to the destination, and remove that part from buffer.push_single_encoded_byte/// Pushes a byte of a (possible) percent-encoded tripet to the buffer.push_encoded/// Pushes the (possibly) encoded string to the buffer./// When the push result is not `PctTripletPushResult::NeedMoreBytes`, the/// caller should call `Self::clear()` before pushing more bytes./// * `buf` should be more than 12 bytes. If not, this method may panic./// Writes the incomplete data completely to the destination, and clears the internal buffer.//! Processor for possibly- or invalidly-percent-encoded strings.maybe_pct_encodedget_wrapped_inner/// Returns the inner string if wrapped./// Returns the byte that appears first./// (Possibly) faster version of `haystack.rfind(needle)` when `needle` is an ASCII character./// Finds the first needle, and returns the string before it and the rest./// If `needle` is not found, returns `None`.rfind_split2/// Finds the last needle, and returns the string before it and the rest./// If no needles are found, returns `None`.find_split2find_split3/// Finds the first needle, and returns the string before it and after it.find_split2_hole/// Finds the first needle, and returns the string before it, the needle, and the string after it.find_split4_hole/// Finds the last needle, and returns the string before it and after it.satisfy_chars/// Returns `true` if the string only contains the allowed characters.satisfy_chars_with_pct_encoded/// Returns `true` if the string only contains the allowed characters and percent-encoded char.starts_with_double_hexdigits/// Returns `true` if the given string starts with two hexadecimal digits.strip_ascii_char_prefix/// Strips the first character if it is the given ASCII character, and returns the rest./// The given ASCII character (`prefix`) should be an ASCII character./// Splits the given string into the first character and the rest./// Returns `(first_char, rest_str)`.//! Functions for common string operations.decompose_authority/// Decomposes the authority into `(userinfo, host, port)`./// The leading `:` is truncated.//! Parsers for trusted `authority` string.scheme_colon/// Eats a `scheme` and a following colon, and returns the rest and the scheme./// Returns `(rest, scheme)`./// This should be called at the head of an absolute IRIs/URIs.scheme_colon_opt/// Eats a `scheme` and a following colon if available, and returns the rest and the scheme./// This should be called at the head of an `IRI-reference` or similar.slash_slash_authority_opt/// Eats double slash and the following authority if available, and returns the authority./// This should be called at the head of an `IRI-reference`, or at the result of `scheme_colon`.until_query/// Eats a string until the query, and returns that part (excluding `?` for the query).decompose_query_and_fragment/// Decomposes query and fragment, if available./// The string must starts with `?`, or `#`, or be empty.decompose_iri_reference/// Decomposes the given valid `IRI-reference`.extract_scheme/// Extracts `scheme` part from an IRI reference.extract_scheme_absolute/// Extracts `scheme` part from an absolute IRI./// The given string must be a valid absolute IRI.extract_authority/// Extracts `authority` part from an IRI reference.extract_authority_absolute/// Extracts `authority` part from an absolute IRI.extract_authority_relative/// Extracts `authority` part from a relative IRI./// The given string must be a valid relative IRI.extract_path/// Extracts `path` part from an IRI reference.extract_path_absolute/// Extracts `path` part from an absolute IRI.extract_path_relative/// Extracts `path` part from a relative IRI.extract_query/// Extracts `query` part from an IRI reference.extract_query_absolute_iri/// Extracts `query` part from an `absolute-IRI` string./// The given string must be a valid `absolute-IRI` string.split_fragment/// Splits an IRI string into the prefix and the fragment part./// A leading `#` character is truncated if the fragment part exists.extract_fragment/// Returns the fragment part of the given IRI./// A leading `#` character of the fragment is truncated.is_normalized/// Returns `Ok(_)` if the string is normalized./// If this function returns `true`, normalization input and output will be identical./// In this function, "normalized" means that any of the normalization below/// won't change the input on normalization:/// * syntax-based normalization,/// * case normalization,/// * percent-encoding normalization, and/// * path segment normalizaiton./// Note that scheme-based normalization is not considered./// Decodes two hexdigits into a byte./// The parameters `upper` and `lower` should be an ASCII hexadecimal digit./// Converts the first two hexdigit bytes in the buffer into a byte./// Panics if the string does not start with two hexdigits./// Returns true if the given `host`/`ihost` string consists of only US-ASCII characters./// The given string should be valid `host` or `host ":" port` string.//! Fast parsers for trusted (already validated) input.//! Using this in wrong way will lead to unexpected wrong result.validate_userinfo/// Returns `Ok(_)` if the string matches `userinfo` or `iuserinfo`.is_dec_octet/// Returns `true` if the string matches `dec-octet`./// In other words, this tests whether the string is decimal "0" to "255".validate_ipv4address/// Returns `Ok(_)` if the string matches `IPv4address`.V6AddrPartH16Omit/// `[0-9a-fA-F]{1,4}::`.H16Cont/// `[0-9a-fA-F]{1,4}:`.H16End/// `[0-9a-fA-F]{1,4}`./// IPv4 address.Omit/// `::`./// A part of IPv6 addr.split_v6_addr_part/// Splits the IPv6 address string into the next component and the rest substring.validate_ipv6address/// Returns `Ok(_)` if the string matches `IPv6address`.validate_authority/// Returns `Ok(_)` if the string matches `authority` or `iauthority`.validate_host/// Validates `host`.assert_validatetest_ipv6address//! Parsers for authority.validate_path_abempty/// Returns `Ok(_)` if the string matches `path-abempty` or `ipath-abempty`.validate_path_absolute_authority_absent/// Returns `Ok(_)` if the string matches `hier-part` or `ihier-part` modulo/// `"//" authority path-abempty`.validate_path_relative_authority_absent/// Returns `Ok(_)` if the string matches `relative-part` or `irelative-part` modulovalidate_path/// Returns `Ok(_)` if the string matches `path`/`ipath` rules.//! Parsers for path.validate_scheme/// Returns `Ok(_)` if the string matches `scheme`.validate_query/// Returns `Ok(_)` if the string matches `query` or `iquery`.validate_authority_path_abempty/// Returns `Ok(_)` if the string matches `authority path-abempty` rule sequence.validate_uri/// Returns `Ok(_)` if the string matches `URI`/`IRI` rules.validate_uri_reference/// Returns `Ok(_)` if the string matches `URI-reference`/`IRI-reference` rules.validate_absolute_uri/// Returns `Ok(_)` if the string matches `absolute-URI`/`absolute-IRI` rules.UriReferenceRule/// `URI` and `IRI`./// This can have a fragment.AbsoluteWithoutFragment/// `absolute-URI` and `absolute-IRI`./// This cannot have a fragment./// `URI-reference` and `IRI-reference`./// This can be relative./// Syntax rule for URI/IRI references.is_relative_allowed/// Returns `true` is the relative reference is allowed.is_fragment_allowed/// Returns `true` is the fragment part is allowed.validate_uri_reference_commonvalidate_relative_ref/// Returns `Ok(_)` if the string matches `relative-ref`/`irelative-ref` rules.validate_after_path/// Returns `Ok(_)` if the string matches `[ "?" query ] [ "#" fragment ]` (or IRI version).validate_fragment/// Returns `Ok(_)` if the string matches `fragment`/`ifragment` rules.//! Validating parsers for non-trusted (possibly invalid) input.//! Common stuff for parsing.PercentEncodedForUriPercentEncoded/// A proxy to percent-encode a string as a part of URI.PercentEncodedForIri/// A proxy to percent-encode a string as a part of IRI.RegName/// Encode the string as a reg-name (usually called as "hostname").UserOrPassword/// Encode the string as a user name or a password (inside the `userinfo` component)./// Encode the string as a path segment./// A slash (`/`) will be encoded to `%2F`./// Encode the string as path segments joined with `/`./// A slash (`/`) will be used as is./// Encode the string as a query string (without the `?` prefix)./// Encode the string as a fragment string (without the `#` prefix).Unreserve/// Encode all characters except for `unreserved` characters./// Encode characters only if they cannot appear anywhere in an IRI reference./// `%` character will be always encoded./// Context for percent encoding./// Source string context./// Raw string before being encoded./// A proxy to percent-encode a string./// Type aliases [`PercentEncodedForIri`] and [`PercentEncodedForUri`] are provided./// You can use them to make the expression simpler, for example write/// `PercentEncodedForUri::from_path(foo)` instead of/// `PercentEncoded::<_, UriSpec>::from_path(foo)`.from_reg_name/// Creates an encoded string from a raw reg-name (i.e. hostname or domain)./// use iri_string::percent_encode::PercentEncoded;/// use iri_string::spec::UriSpec;/// let raw = "alpha.\u{03B1}.example.com";/// let encoded = "alpha.%CE%B1.example.com";///     PercentEncoded::<_, UriSpec>::from_reg_name(raw).to_string(),///     encodedfrom_user/// Creates an encoded string from a raw user name (inside `userinfo` component)./// let raw = "user:\u{03B1}";/// // The first `:` will be interpreted as a delimiter, so colons will be escaped./// let encoded = "user%3A%CE%B1";///     PercentEncoded::<_, UriSpec>::from_user(raw).to_string(),from_password/// let raw = "password:\u{03B1}";/// // The first `:` will be interpreted as a delimiter, and the colon/// // inside the password will be the first one if the user name is empty,/// // so colons will be escaped./// let encoded = "password%3A%CE%B1";///     PercentEncoded::<_, UriSpec>::from_password(raw).to_string(),from_path_segment/// Creates an encoded string from a raw path segment./// let raw = "alpha/\u{03B1}?#";/// // Note that `/` is encoded to `%2F`./// let encoded = "alpha%2F%CE%B1%3F%23";///     PercentEncoded::<_, UriSpec>::from_path_segment(raw).to_string(),/// Creates an encoded string from a raw path./// // Note that `/` is NOT percent encoded./// let encoded = "alpha/%CE%B1%3F%23";///     PercentEncoded::<_, UriSpec>::from_path(raw).to_string(),from_query/// Creates an encoded string from a raw query./// let encoded = "alpha/%CE%B1?%23";///     PercentEncoded::<_, UriSpec>::from_query(raw).to_string(),from_fragment/// Creates an encoded string from a raw fragment.///     PercentEncoded::<_, UriSpec>::from_fragment(raw).to_string(),unreserve/// Creates a string consists of only `unreserved` string and percent-encoded triplets./// let unreserved = "%a0-._~\u{03B1}";/// let unreserved_encoded = "%25a0-._~%CE%B1";///     PercentEncoded::<_, UriSpec>::unreserve(unreserved).to_string(),///     unreserved_encoded/// let reserved = ":/?#[]@ !$&'()*+,;=";/// let reserved_encoded =///     "%3A%2F%3F%23%5B%5D%40%20%21%24%26%27%28%29%2A%2B%2C%3B%3D";///     PercentEncoded::<_, UriSpec>::unreserve(reserved).to_string(),///     reserved_encodedcharacters/// Percent-encodes characters only if they cannot appear anywhere in an IRI reference./// `%` character will be always encoded. In other words, this conversion/// is not aware of percent-encoded triplets./// Note that this encoding process does not guarantee that the resulting/// string is a valid IRI reference.///     PercentEncoded::<_, UriSpec>::characters(unreserved).to_string(),/// // Note that `%20` cannot appear directly in an IRI reference./// let expected = ":/?#[]@%20!$&'()*+,;=";///     PercentEncoded::<_, UriSpec>::characters(reserved).to_string(),///     expectedwrite_pct_encoded_char/// Percent-encodes the given character and writes it.//! Percent encoding.set_fragment/// Sets the fragment part to the given string./// Removes fragment part (and following `#` character) if `None` is given.remove_fragment/// Removes the fragment part from the string.split_fragment_owned/// Splits the string into the prefix and the fragment part.//! Raw IRI strings manipulation.//! Note that functions in this module may operates on raw `&str` types.//! It is caller's responsilibility to guarantee that the given string satisfies the precondition.base_components/// Components of the base IRI.FixedBaseResolver/// A resolver against the fixed base./// Creates a new resolver with the given base./// # // `ToDedicatedString` is available only when/// # // `alloc` feature is enabled./// #[cfg(feature = "alloc")] {/// use iri_string::format::ToDedicatedString;/// use iri_string::resolve::FixedBaseResolver;/// use iri_string::types::{IriAbsoluteStr, IriReferenceStr};/// let base = IriAbsoluteStr::new("http://example.com/base/")?;/// let resolver = FixedBaseResolver::new(base);/// let reference = IriReferenceStr::new("../there")?;/// let resolved = resolver.resolve(reference);/// assert_eq!(resolved.to_dedicated_string(), "http://example.com/there");/// Returns the base./// assert_eq!(resolver.base(), base);/// Returns the scheme./// The following colon is truncated./// use iri_string::types::IriAbsoluteStr;/// let base = IriAbsoluteStr::new("http://example.com/base/?query")?;/// assert_eq!(resolver.scheme_str(), "http");/// assert_eq!(base.scheme_str(), "http");/// Returns the authority./// The leading `//` is truncated./// let base = IriAbsoluteStr::new("http://user:pass@example.com/base/?query")?;/// assert_eq!(resolver.authority_str(), Some("user:pass@example.com"));/// assert_eq!(base.authority_str(), Some("user:pass@example.com"));/// Returns the path./// assert_eq!(resolver.path_str(), "/base/");/// assert_eq!(base.path_str(), "/base/");/// Returns the query./// The leading question mark (`?`) is truncated./// use iri_string::types::{IriAbsoluteStr, IriQueryStr};/// let query = IriQueryStr::new("query")?;/// assert_eq!(resolver.query(), Some(query));/// assert_eq!(base.query(), Some(query));/// Returns the query in a raw string slice./// assert_eq!(resolver.query_str(), Some("query"));/// assert_eq!(base.query_str(), Some("query"));/// Components getters./// These getters are more efficient than calling through the result of `.base()`./// Resolves the given reference against the fixed base./// The task returned by this method does **not** normalize the resolution/// result. However, `..` and `.` are recognized even when they are/// percent-encoded./// # Failures/// This function itself does not fail, but resolution algorithm defined by/// RFC 3986 can fail. In that case, serialization algorithm defined by/// WHATWG URL Standard would be automatically applied./// See the documentation of [`Normalized`]./// Note that `..` and `.` path segments are recognized even when they are/// let base = IriAbsoluteStr::new("HTTP://example.COM/base/base2/")?;/// // `%2e%2e` is recognized as `..`./// // However, `dot%2edot` is NOT normalized into `dot.dot`./// let reference = IriReferenceStr::new("%2e%2e/../dot%2edot")?;/// // Resolved but not normalized./// assert_eq!(resolved.to_dedicated_string(), "HTTP://example.COM/dot%2edot");//! URI and IRI resolvers.//! # IRI resolution can fail without WHATWG URL Standard serialization//! ## Pure RFC 3986 algorithm//! Though this is not explicitly stated in RFC 3986, IRI resolution can fail.//! Below are examples://! * base=`scheme:`, ref=`.///bar`.//!     + Resulting IRI should have scheme `scheme` and path `//bar`, but does not have authority.//! * base=`scheme:foo`, ref=`.///bar`.//! * base=`scheme:`, ref=`/..//baz`.//! * base=`scheme:foo/bar`, ref=`..//baz`.//! IRI without authority (note that this is different from "with empty authority")//! cannot have a path starting with `//`, since it is ambiguous and can be//! interpreted as an IRI with authority. For the above examples, `scheme://bar`//! is not valid output, as `bar` in `scheme://bar` will be interpreted as an//! authority, not a path.//! Thus, IRI resolution by pure RFC 3986 algorithm can fail for some abnormal//! cases.//! If you want this kind of abnormal IRI resolution to succeed and to be//! idempotent, check the resolution result using//! [`Normalized::ensure_rfc3986_normalizable`] (see the section below).//! ## WHATWG serialization//! To handle IRI resolution failure, WHATWG URL Standard defines serialization//! algorithm for this kind of result, and it makes IRI resolution (and even//! normalization) infallible and idempotent.//! IRI resolution and normalization provided by this crate automatically//! applies this special rule if necessary, so they are infallible. If you want//! to detect resolution/normalization failure, use//! [`Normalized::ensure_rfc3986_normalizable`] method.//! use iri_string::format::ToDedicatedString;//!     let reference = IriReferenceStr::new(".///not-a-host")?;//!     let result = reference.resolve_against(base);//!     assert!(result.ensure_rfc3986_normalizable().is_err());//!     assert_eq!(result.to_dedicated_string(), "scheme:/.//not-a-host");//!     let reference2 = IriReferenceStr::new("/..//not-a-host")?;//!     // Resulting string will be `scheme://not-a-host`, but `not-a-host`//!     // should be a path segment, not a host. So, the semantically correct//!     // target IRI cannot be represented by RFC 3986 IRI resolution.//!     let result2 = reference2.resolve_against(base);//!     assert!(result2.ensure_rfc3986_normalizable().is_err());//!     // Algorithm defined in WHATWG URL Standard addresses this case.//!     assert_eq!(result2.to_dedicated_string(), "scheme:/.//not-a-host");SpecInternal/// A trait to prohibit user-defined types from implementing `Spec`./// About sealed trait, see [Rust API Guidelines][future-proofing]./// [future-proofing]: https://rust-lang.github.io/api-guidelines/future-proofing.htmlis_nonascii_char_unreserved/// Checks if the given non-ASCII character matches `unreserved` or `iunreserved` rule.is_nonascii_char_private/// Checks if the given character matches `iprivate` rule./// Internal implementations for spec types.//! A private module for sealed trait and internal implementations.//! Note that this MUST be a private module.//! See [Rust API Guidelines][sealed-trait] about the necessity of being private.//! [sealed-trait]://! https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed// Note that this MUST be private module.// See <https://rust-lang.github.io/api-guidelines/future-proofing.html> about// sealed trait./// A trait for spec types./// This trait is not intended to be implemented by crate users.// Note that all types which implement `Spec` also implement `SpecInternal`./// A type that represents specification of IRI./// About IRI, see [RFC 3987]./// [RFC 3987]: https://tools.ietf.org/html/rfc3987/// A type that represents specification of URI./// About URI, see [RFC 3986]./// [RFC 3986]: https://tools.ietf.org/html/rfc3986//! IRI specs.validate_parserExprBody/// Expression body./// This does not contain the wrapping braces (`{` and `}`)./// Creates a new expression body./// The given string should be a valid expression body.VarListStr/// Decomposes the expression into an `operator` and `variable-list`./// May panic if the input is invalid./// Returns the raw expression in a string slice.VarName/// Variable name.// QUESTION: Should hexdigits in percent-encoded triplets be compared case sensitively?from_trusted/// Creates a `VarName` from the trusted string./// The given string should be a valid variable name./// Creates a `VarName` from the string./// # use iri_string::template::Error;/// use iri_string::template::context::VarName;/// let name = VarName::new("hello")?;/// assert_eq!(name.as_str(), "hello");/// assert!(VarName::new("0+non-variable-name").is_err());/// Returns the varibale name./// Variable modifier.VarSpec/// Variable specifier./// Returns the modifier.parse_trusted/// Parses the trusted varspec string./// Variable list./// Creates a new variable list./// The given string should be a valid variable list.VarListIter/// Remaining input./// Iterator of variable specs./// A pair of the length of the varspec and the varspec itself./// No modifiers.MaxLen/// Max length, greater than 0 and less than 10000.Explode/// Explode the variable, e.g. the var spec has `*`.MaybeOperator/// Working operator.OperatorReservedForFutureReserved/// Reserved for future extensions./// Operator that is possibly reserved for future extension./// Returns the operator for the given character./// No operator. String expansion./// Reserved expansion by `+`./// Fragment expansion by `#`./// Label expansion by `.`./// Path segments by `/`.PathParams/// Path-style parameters by `;`.FormQuery/// Form-style query by `?`.FormQueryCont/// Form-style query continuation by `&`./// Returns the string length of the operator./// Reserved `=` operator./// Reserved `,` operator./// Reserved `!` operator.AtSign/// Reserved `@` operator./// Reserved `|` operator./// Operator reserved for future extension.//! Syntax components of URI templates./// Visits a variable./// To get variable name, use [`Visitor::var_name()`]./// A trait for types that can behave as a static URI template expansion context./// This type is for use with [`UriTemplateStr::expand`] method./// See [the module documentation][`crate::template`] for usage./// [`UriTemplateStr::expand`]: `crate::template::UriTemplateStr::expand`visit_dynamic/// # Restriction/// The visit results should be consistent and unchanged between the last/// time [`on_expansion_start`][`Self::on_expansion_start`] was called and/// the next time [`on_expansion_end`][`Self::on_expansion_end`] will be/// called. If this condition is violated, template expansion will produce/// wrong result or may panic at worst.on_expansion_start/// A callback that is called before the expansion of a URI template.on_expansion_end/// A callback that is called after the expansion of a URI template./// A trait for types that can behave as a dynamic (mutable) URI template expansion context./// This type is for use with [`UriTemplateStr::expand_dynamic`] method and its/// family./// Note that "dynamic" here does not mean that the value of variables can/// change during a template expansion. The value should be fixed and consistent/// during each expansion, but the context is allowed to mutate itself if it/// does not break this rule./// # Exmaples/// # extern crate alloc;/// # use alloc::string::String;/// use iri_string::template::UriTemplateStr;/// use iri_string::template::context::{DynamicContext, Visitor, VisitPurpose};/// struct MyContext<'a> {///     /// Target path.///     target: &'a str,///     /// Username.///     username: Option<&'a str>,///     /// A flag to remember whether the URI template///     /// attempted to use `username` variable.///     username_visited: bool,/// impl DynamicContext for MyContext<'_> {///     fn on_expansion_start(&mut self) {///         // Reset the state.///         self.username_visited = false;///     fn visit_dynamic<V: Visitor>(&mut self, visitor: V) -> V::Result {///         match visitor.var_name().as_str() {///             "target" => visitor.visit_string(self.target),///             "username" => {///                 if visitor.purpose() == VisitPurpose::Expand {///                     // The variable `username` is being used///                     // on the template expansion.///                     // Don't care whether `username` is defined or not.///                     self.username_visited = true;///                 if let Some(username) = &self.username {///                     visitor.visit_string(username)///                 } else {///                     visitor.visit_undefined()///             _ => visitor.visit_undefined(),/// let mut context = MyContext {///     target: "/posts/1",///     username: Some("the_admin"),///     username_visited: false,/// // No access to the variable `username`./// let template1 = UriTemplateStr::new("{+target}")?;/// template1.expand_dynamic::<UriSpec, _, _>(&mut buf, &mut context)?;/// assert_eq!(buf, "/posts/1");/// assert!(!context.username_visited);/// // Will access to the variable `username`./// let template2 = UriTemplateStr::new("{+target}{?username}")?;/// template2.expand_dynamic::<UriSpec, _, _>(&mut buf, &mut context)?;/// assert_eq!(buf, "/posts/1?username=the_admin");/// assert!(context.username_visited);/// context.username = None;/// // Will access to the variable `username` but it is undefined.///     context.username_visited,///     "`MyContext` can know and remember whether `visit_dynamic()` is called///      for `username`, even if its value is undefined"/// [`UriTemplateStr::expand_dynamic`]: `crate::template::UriTemplateStr::expand_dynamic`VisitPurposeTypecheck/// A visit for type checking./// A visit for template expansion to retrieve the value./// A purpose of a visit./// This enum is nonexhaustive since this partially exposes the internal/// implementation of the template expansion, and thus this is subject to/// Result of the visit.ListVisitor/// List visitor.AssocVisitor/// Associative array visitor.var_name/// Returns the name of the variable to visit.purpose/// Returns the purpose of the visit./// The template expansion algorithm checks the types for some variables/// depending on its usage. To get the usage count correctly, you should/// only count visits with [`VisitPurpose::Expand`]./// If you need to know whether the variable is accessed and does not/// need dynamic context generation or access counts, consider using/// [`UriTemplateStr::variables`] method to iterate the variables in the/// URI template./// [`UriTemplateStr::variables`]: `crate::template::UriTemplateStr::variables`visit_undefined/// Visits an undefined variable, i.e. indicates that the requested variable is unavailable./// Visits a string variable.visit_list/// Visits a list variable.visit_assoc/// Visits an associative array variable./// Variable visitor./// See [the module documentation][self] for usage.// NOTE (internal): Visitor types **should not** be cloneable.visit_item/// Visits an item./// If this returned `ControlFlow::Break(v)`, [`Context::visit`] should also/// return this `v`./// To feed multiple items at once, do/// `items.into_iter().try_for_each(|item| self.visit_item(item))` for example./// Finishes visiting the list.visit_items_and_finish/// Visits items and finish.visit_entry/// Visits an entry./// `entries.into_iter().try_for_each(|(key, value)| self.visit_entry(key, value))`/// for example./// Finishes visiting the associative array.visit_entries_and_finish/// Visits entries and finish./// A trait for visitor types of variables in a context.//! Template expansion context.//! 1. Define your context type.//! 2. Implement [`Context`] trait (and [`Context::visit`] method) for the type.//!     1. Get variable name by [`Visitor::var_name`] method.//!     2. Feed the corresponding value(s) by one of `Visitor::visit_*` methods.//! Note that contexts should return consistent result across multiple visits for//! the same variable. In other words, `Context::visit` should return the same//! result for the same `Visitor::var_name()` during the context is borrowed.//! If this condition is violated, the URI template processor can return//! invalid result or panic at worst.//! use iri_string::template::context::{Context, Visitor, ListVisitor, AssocVisitor};//! struct MyContext {//!     name: &'static str,//!     id: u64,//!     tags: &'static [&'static str],//!     children: &'static [(&'static str, usize)],//! impl Context for MyContext {//!     fn visit<V: Visitor>(&self, visitor: V) -> V::Result {//!         let name = visitor.var_name().as_str();//!         match name {//!             "name" => visitor.visit_string(self.name),//!             "id" => visitor.visit_string(self.id),//!             "tags" => visitor.visit_list().visit_items_and_finish(self.tags),//!             "children" => visitor//!                 .visit_assoc()//!                 .visit_entries_and_finish(self.children.iter().copied()),//!             _ => visitor.visit_undefined(),// # Developers note// Visitor types **should not** be cloneable in order to enforce just one// visitor is used to visit a variable. If visitors are cloneable, it can make// the wrong usage to be available, i.e. storing cloned visitors somewhere and// using the wrong one.// However, if visitors are made cloneable by any chance, it does not indicate// the whole implementation will be broken. Users can only use the visitors// through visitor traits (and their API do not allow cloning), so the logic// would work as expected if the internal usage of the visitors are correct.// Making visitors noncloneable is an optional safety guard (with no overhead).WriteFailed/// Cannot write to the backend.ExpressionNotClosed/// Expression is not closed./// Invalid character./// Invalid expression.InvalidPercentEncoding/// Invalid percent-encoded triplets./// Invalid UTF-8 bytes.UnexpectedValueType/// Unexpected value type for the variable.UnsupportedOperator/// Unsupported operator, including operators reserved for future./// Template construction and expansion error kind./// Returns the error message./// Error kind./// Location (byte position of the error)./// Template construction and expansion error.// Note that this type should implement `Copy` trait.// To return additional non-`Copy` data as an error, use wrapper type// (as `std::string::FromUtf8Error` contains `std::str::Utf8Error`)./// Creates a new `Error`./// For internal use./// Returns the byte position the error is detected./// NOTE: This is not a part of the public API since the value to be/// returned (i.e., the definition of the "position" of an error) is not/// guaranteed to be stable./// Soruce data./// Validation error./// Error on conversion into a URI template type.// TODO: Unifiable to `types::CreationError`?/// Returns the source data.validation_error/// Returns the validation error./// Creates a new `CreationError`.//! Errors related to URI templates.VisitorSealedUriTemplateStr/// Literal./// Expression excluding the wrapping braces./// A chunk in a template string./// Template./// Iterator of template chunks./// Creates a new iterator./// Compiled template./// Context./// Template expansion result./// Creates a new `Expanded` object.typecheck_context/// Checks if the types of variables are allowed for the corresponding expressions in the template.impl_try_from_expanded/// Implement `TryFrom<Expanded<...>> for SomeUriStringType`.// Not implementing `TryFrom<Expand<...>>` for query and fragment strings// since they cannot behave as a query or a fragment only by themselves.// Query strings in practical starts with `?` prefix but `RiQueryStr{,ing}`// strips that, and so do fragment strings (but `#` instead of `?`).// Because of this, query and fragment string types won't be used to represent// a relative IRIs without combining the prefix.// In contrast, RFC 6570 URI Template expects that the users are constructing a// "working" IRIs, including the necessary prefixes for syntax components.// For example, fragment expansion `{#var}`, where `var` is "hello", expands to// `#hello`, including the prefix `#`. This means that a URI template will be// used to generate neither `RiQueryStr{,ing}` nor `RiFragmentStr{,ing}` strings.expand_whole_dynamic/// Expands the whole template with the dynamic context.expand_whole_dynamic_impl/// Note that the caller is responsible to set up or finalize the `context`.expand_expr_mut/// Expands the expression using the given operator and the dynamic context./// Prefix for the first element./// Separator./// Whether or not the expansion includes the variable or key name.ifemp/// Result string if the variable is empty.allow_reserved/// Whether or not the reserved values can be written without being encoded.OpProps/// Properties of an operator./// See [RFC 6570 Appendix A](https://www.rfc-editor.org/rfc/rfc6570#appendix-A).PROPS/// Properties for all known operators.from_op/// Returns the properties for the operator./// Expands the expression using the given operator.escape_write/// Escapes the given value and writes it.escape_write_with_maxlenPrefixOnceWriter/// Truncates the given value as a string, escapes the value, and writes it./// Inner writer.rest_num_chars/// Maximum number of characters to be written.TruncatePercentEncodeWriter/// A writer that truncates the input to the given length and writes to the backend./// Prefix to write./// A writer that writes a prefix only once if and only if some value is written./// Creates a new writer with no prefix.with_prefix/// Creates a new writer with a prefix.has_unwritten_prefix/// Returns true if the writer have not yet written the prefix.ValueVisitorVisitDoneToken/// An opaque token value that proves some variable is visited.// This should not be able to be created by any means other than `VarVisitor::visit_foo()`.// Do not derive any traits that allows the value to be generated or cloned./// Creates a new token.writer_ptr/// Returns the raw pointer to the backend formatter./// Formatter.varspec/// Varspec./// Operator.is_first_varspec/// Whether the variable to visit is the first one in an expression./// Visitor to retrieve a variable value.// Single `ValueVisitor` should be used for single expansion./// Creates a visitor.ListValueVisitorAssocValueVisitorvisitor/// Visitor.num_elems/// Number of already emitted elements.oppr/// Operator props./// Visitor to retrieve value of a list variable.// RFC 6570 section 2.3:// > A variable defined as a list value is considered undefined if the// > list contains zero members.  A variable defined as an associative// > array of (name, value) pairs is considered undefined if the array// > contains zero members or if all member names in the array are// > associated with undefined values.// Single variable visitor should be used for single expansion.visit_item_impl/// Visitor to retrieve entries of an associative array variable.visit_entry_implTypeVisitor/// Visitor to retrieve effective type of a variable./// Creates a new type visitor.ListTypeVisitorAssocTypeVisitor/// Visitor to retrieve effective type of a list variable./// Visitor to retrieve effective type of an associative array variable.//! Expansion.CHARS_TABLE/// Properties of ASCII characters./// About `'` (single quote) being considered as a literal: see/// [Errata ID 6937](https://www.rfc-editor.org/errata/eid6937).CHARS_TABLE_MASK_LITERAL/// A mask to test whether the character matches `literals` rule defined in [RFC 6570]./// [RFC 6570]: https://www.rfc-editor.org/rfc/rfc6570.html#section-2.1CHARS_TABLE_MASK_VARCHAR_START/// A mask to test whether the character matches `varchar` rule defined in [RFC 6570]./// [RFC 6570]: https://www.rfc-editor.org/rfc/rfc6570.html#section-2.3CHARS_TABLE_MASK_VARCHAR_CONTINUE/// A mask to test whether the character matches `varchar` rule defined in [RFC 6570] or a period.is_ascii_literal_char/// Returns true if the given ASCII character is allowed in a literal string./// The given byte should be an ASCII character, i.e. should be less than 128.is_ascii_varchar_start/// Returns true if the given ASCII character is allowed as the beginning of the `varname`./// Note that this does not return true for `%` character. It is caller's/// responsibility to test validity of percent-encoded triplets.is_ascii_varchar_continue/// Returns true if the given ASCII character is allowed as the non-beginning of the `varname`.validate_literal/// Returns `Ok(())` if the given string is a valid literal.validate_varspec/// Returns `Ok(())` if the given string is a valid varspec.validate_varname/// Returns `Ok(())` if the given string is a valid varname.validate_expr_body/// Returns `Ok(())` if the given string is a valid expression./// "Expression" here is the expression body inside `{` and `}`, but not including braces.validate_template_str/// Validates whether the given string is valid as a URI template./// Returns `Ok(())` if the given string is a valid URI template.//! Validating parsers.//! URI Template parser./// Undefined (i.e. null)./// String value./// List.Assoc/// Associative array./// Value.variables/// Variable values.// Any map types (including `HashMap`) is ok, but the hash map is not provided by `alloc`.// QUESTION: Should hexdigits in percent-encoded triplets in varnames be// compared case sensitively?SimpleContext/// Simple template expansion context./// Creates a new empty context./// use iri_string::template::simple_context::SimpleContext;/// let empty_ctx = SimpleContext::new();/// let template = UriTemplateStr::new("{no_such_variable}")?;/// let expanded = template.expand::<UriSpec, _>(&empty_ctx)?;///     expanded.to_string(),///     ""/// Inserts a variable./// Passing [`Value::Undefined`] removes the value from the context./// The entry will be inserted or removed even if the key is invalid as a/// variable name. Such entries will be simply ignored on expansion./// let mut context = SimpleContext::new();/// context.insert("username", "foo");/// let template = UriTemplateStr::new("/users/{username}")?;/// let expanded = template.expand::<UriSpec, _>(&context)?;///     "/users/foo"/// ## [cfg(feature = "alloc")] {/// use iri_string::template::simple_context::{SimpleContext, Value};/// context.insert("username", Value::Undefined);///     "/users/"/// Removes all entries in the context./// let template = UriTemplateStr::new("{foo,bar}")?;/// context.insert("foo", "FOO");/// context.insert("bar", "BAR");///     template.expand::<UriSpec, _>(&context)?.to_string(),///     "FOO,BAR"/// context.clear();/// Returns a reference to the value for the key.//! Simple general-purpose context type./// Inner data.UriTemplateString/// An owned slice of a URI template./// URI Template is defined by [RFC 6570]./// Note that "URI Template" can also be used for IRI./// [RFC 6570]: https://www.rfc-editor.org/rfc/rfc6570.html/// # Valid values/// This type can have a URI template string.// Note that `From<$ty> for {Arc,Rc}<$slice>` is currently not implemented since// this won't reuse allocated memory and hides internal memory reallocation. See// <https://github.com/lo48576/iri-string/issues/20#issuecomment-1105207849>.// However, this is not decided with firm belief or opinion, so there would be// a chance that they are implemented in future./// Creates a new string without validation./// This does not validate the given string, so it is caller's/// responsibility to ensure the given string is valid./// The given string must be syntactically valid as `Self` type./// If not, any use of the returned value or the call of this/// function itself may result in undefined behavior./// Shrinks the capacity of the inner buffer to match its length./// Returns the internal buffer capacity in bytes./// Returns the borrowed IRI string slice./// This is equivalent to `&*self`./// Appends the template string.//! Owned `UriTemplateString`./// Implements `PartialEq` and `PartialOrd`./// The raw string./// A borrowed slice of a URI template./// # Applied errata/// [Errata ID 6937](https://www.rfc-editor.org/errata/eid6937) is applied, so/// single quotes are allowed to appear in an URI template./// let template = UriTemplateStr::new("'quoted'")?;/// Creates a new string.new_always_unchecked/// Creates a new string without any validation./// This does not validate the given string at any time./// Intended for internal use./// The given string must be valid./// Returns the template as a plain `&str`./// assert_eq!(template.as_str(), "/users/{username}");/// Returns the template string length./// assert_eq!(template.len(), "/users/{username}".len());/// assert!(!template.is_empty());/// let empty = UriTemplateStr::new("")?;/// Expands the template with the given context./// You can control allowed characters in the output by changing spec type./// use iri_string::spec::{IriSpec, UriSpec};/// context.insert("alpha", "\u{03B1}");/// let template = UriTemplateStr::new("{?alpha}")?;///     "?alpha=%CE%B1",///     "a URI cannot contain Unicode alpha (U+03B1), so it should be escaped"///     template.expand::<IriSpec, _>(&context)?.to_string(),///     "?alpha=\u{03B1}",///     "an IRI can contain Unicode alpha (U+03B1), so it written as is"expand_dynamic/// Expands the template with the given dynamic context./// See the documentation for [`DynamicContext`] for usage.expand_dynamic_to_string/// Expands the template into a string, with the given dynamic context./// This is basically [`expand_dynamic`][`Self::expand_dynamic`] method/// that returns an owned string instead of writing to the given writer./// # use iri_string::template::context::{DynamicContext, Visitor, VisitPurpose};///     // See the documentation for `DynamicContext`./// #     /// Target path./// #     target: &'a str,/// #     /// Username./// #     username: Option<&'a str>,/// #     /// A flag to remember whether the URI template/// #     /// attempted to use `username` variable./// #     username_visited: bool,/// # impl DynamicContext for MyContext<'_> {/// #     fn on_expansion_start(&mut self) {/// #         // Reset the state./// #         self.username_visited = false;/// #     fn visit_dynamic<V: Visitor>(&mut self, visitor: V) -> V::Result {/// #         match visitor.var_name().as_str() {/// #             "target" => visitor.visit_string(self.target),/// #             "username" => {/// #                 if visitor.purpose() == VisitPurpose::Expand {/// #                     // The variable `username` is being used/// #                     // on the template expansion./// #                     // Don't care whether `username` is defined or not./// #                     self.username_visited = true;/// #                 }/// #                 if let Some(username) = &self.username {/// #                     visitor.visit_string(username)/// #                 } else {/// #                     visitor.visit_undefined()/// #             }/// #             _ => visitor.visit_undefined(),/// let template = UriTemplateStr::new("{+target}{?username}")?;/// let s = template.expand_dynamic_to_string::<UriSpec, _>(&mut context)?;/// assert_eq!(s, "/posts/1?username=the_admin");UriTemplateVariables/// Returns an iterator of variables in the template./// let template = UriTemplateStr::new("foo{/bar*,baz:4}{?qux}{&bar*}")?;/// let mut vars = template.variables();/// assert_eq!(vars.next().map(|var| var.as_str()), Some("bar"));/// assert_eq!(vars.next().map(|var| var.as_str()), Some("baz"));/// assert_eq!(vars.next().map(|var| var.as_str()), Some("qux"));/// Chunks iterator.vars_in_chunk/// Variables in the last chunk./// An iterator of variables in a URI template./// Creates a variables iterator from the URI template.TestContextexpand_error_pos//! Template string types.simple_context/// Deprecated old name of [`template::context::VarName`]./// [`template::context::VarName`]: `components::VarName`/// Variable value type.undefined/// Returns the value type for an undefined variable./// Returns the value type for a string variable.empty_list/// Returns the value type for an empty list variable.nonempty_list/// Returns the value type for a nonempty list variable.empty_assoc/// Returns the value type for an empty associative array variable.nonempty_assoc/// Returns the value type for a nonempty associative array variable.//! Processor for [RFC 6570] URI Template.//! [RFC 6570]: https://www.rfc-editor.org/rfc/rfc6570.html//! 1. Prepare a template.//!     * You can create a template as [`UriTemplateStr`]//! 2. Prepare a context.//!     * Create a value of type that implements [`Context`] trait.//! 3. Expand.//!     * Pass the context to [`UriTemplateStr::expand`] method of the template.//! 4. Use the result.//!     * Returned [`Expanded`] object can be directly printed since it//!       implements [`Display`][`core::fmt::Display`] trait. Or, you can call//!       `.to_string()` method of the `alloc::string::ToString` trait to//!       convert it to a `String`.//! ## Custom context type//! For details, see [the documentation of `context` module][`context`].//! # use iri_string::template::Error;//! use core::fmt;//! use iri_string::spec::{IriSpec, Spec, UriSpec};//! use iri_string::template::UriTemplateStr;//! use iri_string::template::context::{Context, VarName, Visitor};//! struct UserInfo {//!     username: &'static str,//!     utf8_available: bool,//! impl Context for UserInfo {//!     fn visit<V: Visitor>(//!         visitor: V,//!     ) -> V::Result {//!         match visitor.var_name().as_str() {//!             "username" => visitor.visit_string(self.username),//!             "utf8" => {//!                 if self.utf8_available {//!                     // U+2713 CHECK MARK//!                     visitor.visit_string("\u{2713}")//!                 } else {//!                     visitor.visit_undefined()//!             _ => visitor.visit_undefined()//! let context = UserInfo {//!     username: "foo",//!     utf8_available: true,//! let template = UriTemplateStr::new("/users/{username}{?utf8}")?;//!     template.expand::<UriSpec, _>(&context)?.to_string(),//!     "/users/foo?utf8=%E2%9C%93"//!     template.expand::<IriSpec, _>(&context)?.to_string(),//!     "/users/foo?utf8=\u{2713}"//! # Ok::<_, Error>(())//! ## `SimpleContext` type (enabled by `alloc` feature flag)//! use iri_string::spec::{IriSpec, UriSpec};//! use iri_string::template::simple_context::SimpleContext;//! let mut context = SimpleContext::new();//! context.insert("username", "foo");//! // U+2713 CHECK MARK//! context.insert("utf8", "\u{2713}");absolute_iridefine_custom_string_slicer" A borrowed slice of an absolute IRI without fragment part."r" This corresponds to [`absolute-IRI` rule] in [RFC 3987]"r" (and [`absolute-URI` rule] in [RFC 3986])."r" In other words, this is [`RiStr`] without fragment part."r" If you want to accept fragment part, use [`RiStr`]."r" # Valid values"r" This type can have an absolute IRI without fragment part."r" # use iri_string::types::IriAbsoluteStr;"r#" assert!(IriAbsoluteStr::new("https://example.com/foo?bar=baz").is_ok());"#r#" assert!(IriAbsoluteStr::new("foo:bar").is_ok());"#r" // Scheme `foo` and empty path."r#" assert!(IriAbsoluteStr::new("foo:").is_ok());"#r" // `foo://.../` below are all allowed. See the crate documentation for detail."r#" assert!(IriAbsoluteStr::new("foo:/").is_ok());"#r#" assert!(IriAbsoluteStr::new("foo://").is_ok());"#r#" assert!(IriAbsoluteStr::new("foo:///").is_ok());"#r#" assert!(IriAbsoluteStr::new("foo:////").is_ok());"#r#" assert!(IriAbsoluteStr::new("foo://///").is_ok());"#r" Relative IRI is not allowed."r" // This is relative path."r#" assert!(IriAbsoluteStr::new("foo/bar").is_err());"#r" // `/foo/bar` is an absolute path, but it is authority-relative."r#" assert!(IriAbsoluteStr::new("/foo/bar").is_err());"#r#" // `//foo/bar` is termed "network-path reference","#r#" // or usually called "protocol-relative reference"."#r#" assert!(IriAbsoluteStr::new("//foo/bar").is_err());"#r" // Empty string is not a valid absolute IRI."r#" assert!(IriAbsoluteStr::new("").is_err());"#r" Fragment part (such as trailing `#foo`) is not allowed."r" // Fragment part is not allowed."r#" assert!(IriAbsoluteStr::new("https://example.com/foo?bar=baz#qux").is_err());"#r" Some characters and sequences cannot used in an absolute IRI."r" // `<` and `>` cannot directly appear in an absolute IRI."r#" assert!(IriAbsoluteStr::new("<not allowed>").is_err());"#r" // Broken percent encoding cannot appear in an absolute IRI."r#" assert!(IriAbsoluteStr::new("%").is_err());"#r#" assert!(IriAbsoluteStr::new("%GG").is_err());"#r" [RFC 3986]: https://tools.ietf.org/html/rfc3986"r" [RFC 3987]: https://tools.ietf.org/html/rfc3987"r" [`absolute-IRI` rule]: https://tools.ietf.org/html/rfc3987#section-2.2"r" [`absolute-URI` rule]: https://tools.ietf.org/html/rfc3986#section-4.3"r" [`RiStr`]: struct.RiStr.html"r" Spec."r" Inner data."r" Creates a new string."r" Creates a new string without validation."r" This does not validate the given string, so it is caller's"r" responsibility to ensure the given string is valid."r" The given string must be syntactically valid as `Self` type."r" If not, any use of the returned value or the call of this"r" function itself may result in undefined behavior."r" Creates a new string maybe without validation."r" This does validation on debug build."new_maybe_uncheckedr" Creates a new string without any validation."r" This does not validate the given string at any time."r" Intended for internal use."r" Returns `&str`."r" Returns the string length."r" Returns whether the string is empty."impl_from_slice_into_smartptrimpl_cmp2define_custom_string_ownedr" An owned string of an absolute IRI without fragment part."r#" The rule for `absolute-IRI` is `scheme ":" ihier-part [ "?" iquery ]`."#r" In other words, this is [`RiString`] without fragment part."r" If you want to accept fragment part, use [`RiString`]."r" For details, see the document for [`RiAbsoluteStr`]."r" Enabled by `alloc` or `std` feature."r" [`RiAbsoluteStr`]: struct.RiAbsoluteStr.html"r" [`RiString`]: struct.RiString.html"r" Returns a mutable reference to the inner string buffer."r" This may be useful to implement inline modification algorithm,"r" but be careful as this method itself cannot validate the new"r" content."r" The content after modification must be syntactically valid as"r" `Self` type."as_inner_mutr" Shrinks the capacity of the inner buffer to match its length."r" Returns the internal buffer capacity in bytes."r" Returns the borrowed IRI string slice."r" This is equivalent to `&*self`."impl_cmp2_as_str/// Returns Ok`(())` if the IRI is normalizable by the RFC 3986 algorithm./// let iri = IriAbsoluteStr::new("HTTP://example.COM/foo/%2e/bar/..")?;/// assert!(iri.ensure_rfc3986_normalizable().is_ok());/// let iri2 = IriAbsoluteStr::new("scheme:/..//bar")?;/// // The normalization result would be `scheme://bar` according to RFC/// // 3986, but it is unintended and should be treated as a failure./// // This crate automatically handles this case so that `.normalize()` won't fail./// assert!(!iri.ensure_rfc3986_normalizable().is_err());/// Returns `true` if the IRI is already normalized./// This returns the same result as `self.normalize().to_string() == self`,/// but does this more efficiently without heap allocation./// let iri = IriAbsoluteStr::new("HTTP://example.COM/foo/./bar/%2e%2e/../baz?query")?;/// assert!(!iri.is_normalized());/// let normalized = iri.normalize().to_dedicated_string();/// assert_eq!(normalized, "http://example.com/baz?query");/// assert!(normalized.is_normalized());/// let iri = IriAbsoluteStr::new("scheme:/.///foo")?;/// // Already normalized./// assert!(iri.is_normalized());/// let iri = IriAbsoluteStr::new("scheme:relative/..//not-a-host")?;/// // Default normalization algorithm assumes the path part to be NOT opaque./// assert_eq!(normalized, "scheme:/.//not-a-host");is_normalized_rfc3986/// This returns the same result as/// `self.ensure_rfc3986_normalizable() && (self.normalize().to_string() == self)`,/// does this more efficiently without heap allocation./// assert!(!iri.is_normalized_rfc3986());/// assert!(normalized.is_normalized_rfc3986());/// // Not normalized in the sense of RFC 3986./// // RFC 3986 normalization algorithm assumes the path part to be NOT opaque.is_normalized_but_authorityless_relative_path_preserved/// Returns `true` if the IRI is already normalized in the sense of/// [`normalize_but_preserve_authorityless_relative_path`] method./// `self.normalize_but_preserve_authorityless_relative_path().to_string() == self`,/// assert!(!iri.is_normalized_but_authorityless_relative_path_preserved());/// let normalized = iri///     .normalize_but_preserve_authorityless_relative_path()///     .to_dedicated_string();/// // Already normalized in the sense of/// // `normalize_but_opaque_authorityless_relative_path()` method./// assert!(iri.is_normalized_but_authorityless_relative_path_preserved());/// // Relative path is treated as opaque since the autority component is absent./// [`normalize_but_preserve_authorityless_relative_path`]:///     `Self::normalize_but_preserve_authorityless_relative_path`/// Returns the normalized IRI./// For some abnormal IRIs, the normalization can produce semantically/// incorrect string that looks syntactically valid. To avoid security/// issues by this trap, the normalization algorithm by this crate/// automatically applies the workaround./// If you worry about this, test by/// [`RiAbsoluteStr::ensure_rfc3986_normalizable`] method or/// [`Normalized::ensure_rfc3986_normalizable`] before using the resultnormalize_but_preserve_authorityless_relative_path/// Returns the normalized IRI, but preserving dot segments in relative path/// if the authority component is absent./// This normalization would be similar to that of [WHATWG URL Standard]/// while this implementation is not guaranteed to stricly follow the spec./// Note that case normalization and percent-encoding normalization will/// still be applied to any path./// let iri = IriAbsoluteStr::new("scheme:relative/../f%6f%6f")?;/// assert_eq!(normalized, "scheme:relative/../foo");/// // `.normalize()` would normalize this to `scheme:/foo`./// # assert_eq!(iri.normalize().to_dedicated_string(), "scheme:/foo");/// [WHATWG URL Standard]: https://url.spec.whatwg.org//// Returns the proxy to the IRI with password masking feature./// let iri = IriAbsoluteStr::new("http://user:password@example.com/path?query")?;/// assert_eq!(masked.to_dedicated_string(), "http://user:@example.com/path?query");/// let iri = IriAbsoluteStr::new("http://example.com/pathpath?queryquery")?;/// assert_eq!(iri.scheme_str(), "http");/// assert_eq!(iri.authority_str(), Some("example.com"));/// let iri = IriAbsoluteStr::new("urn:uuid:10db315b-fcd1-4428-aca8-15babc9a2da2")?;/// assert_eq!(iri.authority_str(), None);/// assert_eq!(iri.path_str(), "/pathpath");/// assert_eq!(iri.path_str(), "uuid:10db315b-fcd1-4428-aca8-15babc9a2da2");/// let query = IriQueryStr::new("queryquery")?;/// assert_eq!(iri.query(), Some(query));/// assert_eq!(iri.query(), None);/// assert_eq!(iri.query_str(), Some("queryquery"));/// assert_eq!(iri.query_str(), None);authority_components/// Returns the authority components./// let iri = IriAbsoluteStr::new("http://user:pass@example.com:8080/pathpath?queryquery")?;/// let authority = iri.authority_components()///     .expect("authority is available");/// assert_eq!(authority.userinfo(), Some("user:pass"));/// assert_eq!(authority.port(), Some("8080"));remove_password_inline/// Removes the password completely (including separator colon) from `self` even if it is empty./// use iri_string::types::IriAbsoluteString;/// let mut iri = IriAbsoluteString::try_from("http://user:password@example.com/path?query")?;/// iri.remove_password_inline();/// assert_eq!(iri, "http://user@example.com/path?query");/// Even if the password is empty, the password and separator will be removed./// let mut iri = IriAbsoluteString::try_from("http://user:@example.com/path?query")?;remove_nonempty_password_inline/// Replaces the non-empty password in `self` to the empty password./// This leaves the separator colon if the password part was available./// iri.remove_nonempty_password_inline();/// assert_eq!(iri, "http://user:@example.com/path?query");/// If the password is empty, it is left as is.impl_trivial_conv_between_iri//! Absolute IRI (without fragment part)./// Error on conversion into an IRI type./// Enabled by `alloc` or `std` feature.// This type itself does not require `alloc` or `std, but the type is used only when `alloc`// feature is enabled. To avoid exporting unused stuff, the type (and the `types::generic::error`// module) is available only when necessary.//! Resource identifier creation error.r" A borrowed slice of an IRI fragment (i.e. after the first `#` character)."r" This corresponds to [`ifragment` rule] in [RFC 3987] (and [`fragment` rule] in [RFC 3986])."r#" The rule for `ifragment` is `*( ipchar / "/" / "?" )`."#r" This type can have an IRI fragment."r" Note that the IRI `foo://bar/baz#qux` has the fragment `qux`, **not** `#qux`."r" # use iri_string::types::IriFragmentStr;"r#" assert!(IriFragmentStr::new("").is_ok());"#r#" assert!(IriFragmentStr::new("foo").is_ok());"#r#" assert!(IriFragmentStr::new("foo/bar").is_ok());"#r#" assert!(IriFragmentStr::new("/foo/bar").is_ok());"#r#" assert!(IriFragmentStr::new("//foo/bar").is_ok());"#r#" assert!(IriFragmentStr::new("https://user:pass@example.com:8080").is_ok());"#r#" assert!(IriFragmentStr::new("https://example.com/").is_ok());"#r" Some characters and sequences cannot used in a fragment."r" // `<` and `>` cannot directly appear in an IRI reference."r#" assert!(IriFragmentStr::new("<not allowed>").is_err());"#r" // Broken percent encoding cannot appear in an IRI reference."r#" assert!(IriFragmentStr::new("%").is_err());"#r#" assert!(IriFragmentStr::new("%GG").is_err());"#r" // Hash sign `#` cannot appear in an IRI fragment."r##" assert!(IriFragmentStr::new("#hash").is_err());"##r" [`fragment` rule]: https://tools.ietf.org/html/rfc3986#section-3.5"r" [`ifragment` rule]: https://tools.ietf.org/html/rfc3987#section-2.2"r" An owned string of an IRI fragment (i.e. after the first `#` character)."r#" The rule for `absolute-IRI` is `*( ipchar / "/" / "?" )`."#r" For details, see the documentation for [`RiFragmentStr`]."r" [`RiFragmentStr`]: struct.RiFragmentStr.html"from_prefixed/// Creates a new `&RiFragmentStr` from the fragment part prefixed by `#`./// # use iri_string::types::IriFragmentStr;/// assert!(IriFragmentStr::from_prefixed("#").is_ok());/// assert!(IriFragmentStr::from_prefixed("#foo").is_ok());/// assert!(IriFragmentStr::from_prefixed("#foo/bar").is_ok());/// assert!(IriFragmentStr::from_prefixed("#/foo/bar").is_ok());/// assert!(IriFragmentStr::from_prefixed("#//foo/bar").is_ok());/// assert!(IriFragmentStr::from_prefixed("#https://user:pass@example.com:8080").is_ok());/// assert!(IriFragmentStr::from_prefixed("#https://example.com/").is_ok());/// // `<` and `>` cannot directly appear in an IRI./// assert!(IriFragmentStr::from_prefixed("#<not allowed>").is_err());/// // Broken percent encoding cannot appear in an IRI./// assert!(IriFragmentStr::new("#%").is_err());/// assert!(IriFragmentStr::new("#%GG").is_err());/// // `#` prefix is expected./// assert!(IriFragmentStr::from_prefixed("").is_err());/// assert!(IriFragmentStr::from_prefixed("foo").is_err());/// // Hash sign `#` cannot appear in an IRI fragment./// assert!(IriFragmentStr::from_prefixed("##hash").is_err());//! Fragment string./// Implements type conversion from slice into smart pointer./// Implements `PartialEq` and `PartialOrd` with two independent spec type parameter./// Define the custom string slice type, and implements methods and traits./// Methods to be implemented:/// * `pub fn new()`/// * `pub fn new_unchecked()`/// * `pub(crate) fn new_maybe_unchecked()`/// * `fn new_always_unchecked()`/// * `pub fn as_str()`/// * `pub fn len()`/// * `pub fn is_empty()`/// Traits to be implemented:/// * fundamental///     + `Debug for $ty`///     + `Eq for $ty`///     + `Ord for $ty`///     + `Hash for $ty`/// * type conversion///     + `AsRef<&str> for $ty`///     + `AsRef<&$ty> for $ty`///     + `From<&$ty>` for Cow<$ty>`///     + `From<&$ty>` for Arc<$ty>`///     + `From<&$ty>` for Box<$ty>`///     + `From<&$ty>` for Rc<$ty>`///     + `From<&$ty> for &str`///     + `TryFrom<&str> for &$ty`///     + `TryFrom<&[u8]> for &$ty`/// * comparison (only `PartialEq` impls are listed, but `PartialOrd` is also implemented).///     + `PartialEq<$ty> for $ty`///     + `str` and `$ty`///         - `PartialEq<str> for $ty`///         - `PartialEq<$ty> for str`///         - `PartialEq<&str> for $ty`///         - `PartialEq<$ty> for &str`///         - `PartialEq<str> for &$ty`///         - `PartialEq<&$ty> for str`///     + `$ty` and `$ty`///         - `PartialEq<&$ty> for $ty`///         - `PartialEq<$ty> for &$ty`/// * other///     + `Display for $ty`/// * serde///     + `serde::Serialize`///     + `serde::Deserialize`/// Define the custom owned string type, and implements methods and traits./// * `pub(crate) fn new_always_unchecked()`/// * `pub fn shrink_to_fit()`///     + `Clone for $ty`///     + `AsRef<str> for $ty`///     + `AsRef<$slice> for $ty`///     + `Borrow<str> for $ty`///     + `Borrow<$slice> for $ty`///     + `ToOwned<Owned = $ty> for $slice`///     + `From<&$slice> for $ty`///     + `From<$ty> for String`///     + `From<$ty> for Cow<'_, $slice>`///     + `From<$ty> for Box<$slice>`///     + `TryFrom<&str> for $ty`///     + `TryFrom<&[u8]> for $ty`///     + `TryFrom<String> for $ty`///     + `FromStr for $ty`///     + `Deref<Target = $slice> for $ty`/// * comparison (only `PartialEq` impls are listed, but `PartialOrd` is also implemented.///     + `$slice` and `str`///         - `PartialEq<$slice> for Cow<'_, str>`///         - `PartialEq<Cow<'_, str>> for $slice`///         - `PartialEq<&$slice> for Cow<'_, str>`///         - `PartialEq<Cow<'_, str>> for &$slice`///     + `$slice` and `Cow<$slice>`///         - `PartialEq<$slice> for Cow<'_, $slice>`///         - `PartialEq<Cow<'_, $slice>> for $slice`///         - `PartialEq<&$slice> for Cow<'_, $slice>`///         - `PartialEq<Cow<'_, $slice>> for &$slice`///         - `PartialEq<Cow<'_, str>> for $ty`///         - `PartialEq<$ty> for Cow<'_, str>`///     + `String` and `$ty`///         - `PartialEq<String> for $ty`///         - `PartialEq<$ty> for String`///     + `$slice` and `$ty`///         - `PartialEq<$slice> for $ty`///         - `PartialEq<$ty> for $slice`///         - `PartialEq<&$slice> for $ty`///         - `PartialEq<$ty> for &$slice`///         - `PartialEq<Cow<'_, $slice>> for $ty`///         - `PartialEq<$ty> for Cow<'_, $slice>`/// Implements trivial conversions and other useful traits between two IRI types./// Implemented traits:///     + `AsRef<$to_slice> for $from_slice`///     + `AsRef<$to_slice> for $from_owned`///     + `From<$from_slice> for $to_slice`///     + `From<$from_owned> for $to_owned`///     + `TryFrom<&$to_slice> for &$from_slice`///     + `TryFrom<$to_owned> for $from_owned`///     + `$from_slice` and `$to_slice`///         - `PartialEq<$from_slice> for $to_slice`///         - `PartialEq<$to_slice> for $from_slice`///         - `PartialEq<&$from_slice> for $to_slice`///         - `PartialEq<$to_slice> for &$from_slice`///         - `PartialEq<$from_slice> for &$to_slice`///         - `PartialEq<&$to_slice> for $from_slice`///         - `PartialEq<$from_slice> for Cow<'_, $to_slice>`///         - `PartialEq<Cow<'_, $to_slice>> for $from_slice`///         - `PartialEq<&$from_slice> for Cow<'_, $to_slice>`///         - `PartialEq<Cow<'_, $to_slice>> for &$from_slice`///         - `PartialEq<Cow<'_, $from_slice>> for $to_slice`///         - `PartialEq<$to_slice> for Cow<'_, $from_slice>`///         - `PartialEq<Cow<'_, $from_slice>> for &$to_slice`///         - `PartialEq<&$to_slice> for Cow<'_, $from_slice>`///     + `$from_slice` and `$to_owned`///         - `PartialEq<$from_slice> for $to_owned`///         - `PartialEq<$to_owned> for $from_slice`///         - `PartialEq<&$from_slice> for $to_owned`///         - `PartialEq<$to_owned> for &$from_slice`///         - `PartialEq<Cow<'_, $from_slice>> for $to_owned`///         - `PartialEq<$to_owned> for Cow<'_, $from_slice>`///     + `$from_owned` and `$to_slice`///         - `PartialEq<$from_owned> for $to_slice`///         - `PartialEq<$to_slice> for $from_owned`///         - `PartialEq<$from_owned> for &$to_slice`///         - `PartialEq<&$to_slice> for $from_owned`///         - `PartialEq<$from_owned> for Cow<'_, $to_slice>`///         - `PartialEq<Cow<'_, $to_slice>> for $from_owned`///     + `$from_owned` and `$to_owned`///         - `PartialEq<$from_owned> for $to_owned`///         - `PartialEq<$to_owned> for $from_owned`//! Macros to define resource identifier types.r" A borrowed string of an absolute IRI possibly with fragment part."r" This corresponds to [`IRI` rule] in [RFC 3987] (and [`URI` rule] in [RFC 3986])."r##" The rule for `IRI` is `scheme ":" ihier-part [ "?" iquery ] [ "#" ifragment ]`."##r" In other words, this is [`RiAbsoluteStr`] with fragment part allowed."r" This type can have an IRI (which is absolute, and may have fragment part)."r" # use iri_string::types::IriStr;"r#" assert!(IriStr::new("https://user:pass@example.com:8080").is_ok());"#r#" assert!(IriStr::new("https://example.com/").is_ok());"#r#" assert!(IriStr::new("https://example.com/foo?bar=baz").is_ok());"#r#" assert!(IriStr::new("https://example.com/foo?bar=baz#qux").is_ok());"#r#" assert!(IriStr::new("foo:bar").is_ok());"#r#" assert!(IriStr::new("foo:").is_ok());"#r#" assert!(IriStr::new("foo:/").is_ok());"#r#" assert!(IriStr::new("foo://").is_ok());"#r#" assert!(IriStr::new("foo:///").is_ok());"#r#" assert!(IriStr::new("foo:////").is_ok());"#r#" assert!(IriStr::new("foo://///").is_ok());"#r" Relative IRI reference is not allowed."r#" assert!(IriStr::new("foo/bar").is_err());"#r#" assert!(IriStr::new("/foo/bar").is_err());"#r#" assert!(IriStr::new("//foo/bar").is_err());"#r" // Same-document reference is relative."r##" assert!(IriStr::new("#foo").is_err());"##r#" assert!(IriStr::new("").is_err());"#r" Some characters and sequences cannot used in an IRI."r" // `<` and `>` cannot directly appear in an IRI."r#" assert!(IriStr::new("<not allowed>").is_err());"#r" // Broken percent encoding cannot appear in an IRI."r#" assert!(IriStr::new("%").is_err());"#r#" assert!(IriStr::new("%GG").is_err());"#r" [`IRI` rule]: https://tools.ietf.org/html/rfc3987#section-2.2"r" [`URI` rule]: https://tools.ietf.org/html/rfc3986#section-3"r" An owned string of an absolute IRI possibly with fragment part."r" In other words, this is [`RiAbsoluteString`] with fragment part allowed."r" For details, see the document for [`RiStr`]."r" [`RiAbsoluteString`]: struct.RiAbsoluteString.html"to_absolute_and_fragment/// Splits the IRI into an absolute IRI part and a fragment part./// If the IRI has a fragment part, `Some(_)` is returned./// # use iri_string::{spec::IriSpec, types::{IriFragmentStr, IriStr}, validate::Error};/// let iri = IriStr::new("foo://bar/baz?qux=quux#corge")?;/// let (absolute, fragment) = iri.to_absolute_and_fragment();/// let fragment_expected = IriFragmentStr::new("corge")?;/// assert_eq!(absolute, "foo://bar/baz?qux=quux");/// assert_eq!(fragment, Some(fragment_expected));/// When the fragment part exists but is empty string, `Some(_)` is returned./// let iri = IriStr::new("foo://bar/baz?qux=quux#")?;/// let fragment_expected = IriFragmentStr::new("")?;/// If the IRI has no fragment, `None` is returned./// # use iri_string::{spec::IriSpec, types::IriStr, validate::Error};/// let iri = IriStr::new("foo://bar/baz?qux=quux")?;/// assert_eq!(fragment, None);to_absolute/// Strips the fragment part if exists, and returns [`&RiAbsoluteStr`][`RiAbsoluteStr`]./// assert_eq!(iri.to_absolute(), "foo://bar/baz?qux=quux");/// [`RiAbsoluteStr`]: struct.RiAbsoluteStr.html/// let iri = IriStr::new("HTTP://example.COM/foo/%2e/bar/..")?;/// let iri2 = IriStr::new("scheme:/..//bar")?;/// let iri = IriStr::new("HTTP://example.COM/foo/./bar/%2e%2e/../baz?query#fragment")?;/// assert_eq!(normalized, "http://example.com/baz?query#fragment");/// let iri = IriStr::new("scheme:/.///foo")?;/// let iri = IriStr::new("scheme:relative/..//not-a-host")?;/// Returns `true` if the IRI is already normalized in the sense of RFC 3986./// If you worry about this, test by [`RiStr::ensure_rfc3986_normalizable`]/// method or [`Normalized::ensure_rfc3986_normalizable`] before using the/// result string./// let iri = IriStr::new("scheme:relative/../f%6f%6f")?;/// let iri = IriStr::new("http://user:password@example.com/path?query")?;/// let iri = IriStr::new("http://example.com/pathpath?queryquery#fragfrag")?;/// let iri = IriStr::new("urn:uuid:10db315b-fcd1-4428-aca8-15babc9a2da2")?;/// use iri_string::types::{IriQueryStr, IriStr};/// Returns the fragment part if exists./// let fragment = IriFragmentStr::new("corge")?;/// assert_eq!(iri.fragment(), Some(fragment));/// let fragment = IriFragmentStr::new("")?;/// assert_eq!(iri.fragment(), None);/// Returns the fragment part as a raw string slice if exists./// assert_eq!(iri.fragment_str(), Some("corge"));/// assert_eq!(iri.fragment_str(), Some(""));/// assert_eq!(iri.fragment_str(), None);/// let iri = IriStr::new("http://user:pass@example.com:8080/pathpath?queryquery")?;into_absolute_and_fragment/// # use iri_string::{spec::IriSpec, types::{IriFragmentString, IriString}, validate::Error};/// let iri = "foo://bar/baz?qux=quux#corge".parse::<IriString>()?;/// let (absolute, fragment) = iri.into_absolute_and_fragment();/// let fragment_expected = IriFragmentString::try_from("corge".to_owned())///     .map_err(|e| e.validation_error())?;/// let iri = "foo://bar/baz?qux=quux#".parse::<IriString>()?;/// let fragment_expected = IriFragmentString::try_from("".to_owned())/// # use iri_string::{spec::IriSpec, types::IriString, validate::Error};/// let iri = "foo://bar/baz?qux=quux".parse::<IriString>()?;into_absolute/// Strips the fragment part if exists, and returns an [`RiAbsoluteString`]./// assert_eq!(iri.into_absolute(), "foo://bar/baz?qux=quux");/// [`RiAbsoluteString`]: struct.RiAbsoluteString.html/// let mut iri = IriString::try_from("http://user:password@example.com/path?query")?;/// let mut iri = IriString::try_from("http://user:@example.com/path?query")?;//! Usual absolute IRI (fragment part being allowed).r" A borrowed slice of an IRI query (i.e. after the first `?` and before the first `#`)."r" This corresponds to [`iquery` rule] in [RFC 3987] (and [`query` rule] in [RFC 3986])."r#" The rule for `ifragment` is `*( ipchar / iprivate / "/" / "?" )`."#r" use iri_string::types::IriQueryStr;"r#" assert!(IriQueryStr::new("").is_ok());"#r#" assert!(IriQueryStr::new("foo").is_ok());"#r#" assert!(IriQueryStr::new("foo/bar").is_ok());"#r#" assert!(IriQueryStr::new("/foo/bar").is_ok());"#r#" assert!(IriQueryStr::new("//foo/bar").is_ok());"#r#" assert!(IriQueryStr::new("https://user:pass@example.com:8080").is_ok());"#r#" assert!(IriQueryStr::new("https://example.com/").is_ok());"#r" // Question sign `?` can appear in an IRI query."r#" assert!(IriQueryStr::new("query?again").is_ok());"#r" Some characters and sequences cannot used in a query."r#" assert!(IriQueryStr::new("<not allowed>").is_err());"#r#" assert!(IriQueryStr::new("%").is_err());"#r#" assert!(IriQueryStr::new("%GG").is_err());"#r" // Hash sign `#` cannot appear in an IRI query."r##" assert!(IriQueryStr::new("#hash").is_err());"##r" [`query` rule]: https://tools.ietf.org/html/rfc3986#section-3.4"r" [`iquery` rule]: https://tools.ietf.org/html/rfc3987#section-2.2"r#" The rule for `absolute-IRI` is `*( ipchar / iprivate / "/" / "?" )`."#r" For details, see the documentation for [`RiQueryStr`]."r" [`RiQueryStr`]: struct.RiQueryStr.html"/// Creates a new `&RiQueryStr` from the query part prefixed by `?`./// # use iri_string::types::IriQueryStr;/// assert!(IriQueryStr::from_prefixed("?").is_ok());/// assert!(IriQueryStr::from_prefixed("?foo").is_ok());/// assert!(IriQueryStr::from_prefixed("?foo/bar").is_ok());/// assert!(IriQueryStr::from_prefixed("?/foo/bar").is_ok());/// assert!(IriQueryStr::from_prefixed("?//foo/bar").is_ok());/// assert!(IriQueryStr::from_prefixed("?https://user:pass@example.com:8080").is_ok());/// assert!(IriQueryStr::from_prefixed("?https://example.com/").is_ok());/// // Question sign `?` can appear in an IRI query./// assert!(IriQueryStr::from_prefixed("?query?again").is_ok());/// assert!(IriQueryStr::from_prefixed("?<not allowed>").is_err());/// assert!(IriQueryStr::new("?%").is_err());/// assert!(IriQueryStr::new("?%GG").is_err());/// // `?` prefix is expected./// assert!(IriQueryStr::from_prefixed("").is_err());/// assert!(IriQueryStr::from_prefixed("foo").is_err());/// // Hash sign `#` cannot appear in an IRI query./// assert!(IriQueryStr::from_prefixed("?#hash").is_err());//! Query string.iri_referencer" This corresponds to [`IRI-reference` rule] in [RFC 3987]"r" (and [`URI-reference` rule] in [RFC 3986])."r" The rule for `IRI-reference` is `IRI / irelative-ref`."r" In other words, this is union of [`RiStr`] and [`RiRelativeStr`]."r" This type can have an IRI reference (which can be absolute or relative)."r" # use iri_string::types::IriReferenceStr;"r#" assert!(IriReferenceStr::new("https://user:pass@example.com:8080").is_ok());"#r#" assert!(IriReferenceStr::new("https://example.com/").is_ok());"#r#" assert!(IriReferenceStr::new("https://example.com/foo?bar=baz").is_ok());"#r#" assert!(IriReferenceStr::new("https://example.com/foo?bar=baz#qux").is_ok());"#r#" assert!(IriReferenceStr::new("foo:bar").is_ok());"#r#" assert!(IriReferenceStr::new("foo:").is_ok());"#r#" assert!(IriReferenceStr::new("foo:/").is_ok());"#r#" assert!(IriReferenceStr::new("foo://").is_ok());"#r#" assert!(IriReferenceStr::new("foo:///").is_ok());"#r#" assert!(IriReferenceStr::new("foo:////").is_ok());"#r#" assert!(IriReferenceStr::new("foo://///").is_ok());"#r#" assert!(IriReferenceStr::new("foo/bar").is_ok());"#r#" assert!(IriReferenceStr::new("/foo/bar").is_ok());"#r#" assert!(IriReferenceStr::new("//foo/bar").is_ok());"#r##" assert!(IriReferenceStr::new("#foo").is_ok());"##r" Some characters and sequences cannot used in an IRI reference."r#" assert!(IriReferenceStr::new("<not allowed>").is_err());"#r#" assert!(IriReferenceStr::new("%").is_err());"#r#" assert!(IriReferenceStr::new("%GG").is_err());"#r" [`IRI-reference` rule]: https://tools.ietf.org/html/rfc3987#section-2.2"r" [`URI-reference` rule]: https://tools.ietf.org/html/rfc3986#section-4.1"r" [`RiRelativeStr`]: struct.RiRelativeStr.html"r" In other words, this is union of [`RiString`] and [`RiRelativeString`]."r" For details, see the document for [`RiReferenceStr`]."r" [`RiReferenceStr`]: struct.RiReferenceString.html"r" [`RiRelativeString`]: struct.RiRelativeString.html"to_iri/// Returns the string as [`&RiStr`][`RiStr`], if it is valid as an IRI./// If it is not an IRI, then [`&RiRelativeStr`][`RiRelativeStr`] is returned as `Err(_)`./// [`RiRelativeStr`]: struct.RiRelativeStr.html/// [`RiStr`]: struct.RiStr.htmlto_relative_iri/// Returns the string as [`&RiRelativeStr`][`RiRelativeStr`], if it is valid as an IRI./// If it is not an IRI, then [`&RiStr`][`RiStr`] is returned as `Err(_)`.resolve_against/// Returns resolved IRI against the given base IRI./// For IRI reference resolution output examples, see [RFC 3986 section 5.4]./// If you are going to resolve multiple references against the common base,/// consider using [`FixedBaseResolver`]./// # Strictness/// The IRI parsers provided by this crate is strict (e.g. `http:g` is/// always interpreted as a composition of the scheme `http` and the path/// `g`), so backward compatible parsing and resolution are not provided./// About parser and resolver strictness, see [RFC 3986 section 5.4.2]:/// > Some parsers allow the scheme name to be present in a relative/// > reference if it is the same as the base URI scheme. This is considered/// > to be a loophole in prior specifications of partial URI/// > [RFC1630](https://tools.ietf.org/html/rfc1630). Its use should be/// > avoided but is allowed for backward compatibility./// > --- <https://tools.ietf.org/html/rfc3986#section-5.4.2>/// This method itself does not fail, but IRI resolution without WHATWG URL/// Standard serialization can fail in some minor cases./// To see examples of such unresolvable IRIs, visit the documentation/// for [`normalize`][`crate::normalize`] module./// [RFC 3986 section 5.4]: https://tools.ietf.org/html/rfc3986#section-5.4/// [RFC 3986 section 5.4.2]: https://tools.ietf.org/html/rfc3986#section-5.4.2/// let iri = IriReferenceStr::new("http://user:password@example.com/path?query")?;/// let iri = IriReferenceStr::new("http://example.com/pathpath?queryquery#fragfrag")?;/// assert_eq!(iri.scheme_str(), Some("http"));/// let iri = IriReferenceStr::new("foo/bar:baz")?;/// assert_eq!(iri.scheme_str(), None);/// let iri = IriReferenceStr::new("urn:uuid:10db315b-fcd1-4428-aca8-15babc9a2da2")?;/// assert_eq!(iri.path_str(), "foo/bar:baz");/// use iri_string::types::{IriQueryStr, IriReferenceStr};/// let iri = IriReferenceStr::new("foo/bar:baz?")?;/// let query = IriQueryStr::new("")?;/// Returns the query as a raw string slice./// assert_eq!(iri.query_str(), Some(""));/// # use iri_string::{spec::IriSpec, types::{IriFragmentStr, IriReferenceStr}, validate::Error};/// let iri = IriReferenceStr::new("foo://bar/baz?qux=quux#corge")?;/// let iri = IriReferenceStr::new("#foo")?;/// let fragment = IriFragmentStr::new("foo")?;/// let iri = IriReferenceStr::new("foo://bar/baz?qux=quux#")?;/// let iri = IriReferenceStr::new("#")?;/// # use iri_string::{spec::IriSpec, types::IriReferenceStr, validate::Error};/// let iri = IriReferenceStr::new("foo://bar/baz?qux=quux")?;/// let iri = IriReferenceStr::new("")?;/// assert_eq!(iri.fragment_str(), Some("foo"));/// let iri = IriReferenceStr::new("http://user:pass@example.com:8080/pathpath?queryquery")?;/// let iri = IriReferenceStr::new("foo//bar:baz")?;into_iri/// Returns the string as [`RiString`], if it is valid as an IRI./// If it is not an IRI, then [`RiRelativeString`] is returned as `Err(_)`./// [`RiRelativeString`]: struct.RiRelativeString.html/// [`RiString`]: struct.RiString.htmlinto_relative_iri/// Returns the string as [`RiRelativeString`], if it is valid as an IRI./// If it is not an IRI, then [`RiString`] is returned as `Err(_)`./// use iri_string::types::IriReferenceString;/// let mut iri = IriReferenceString::try_from("http://user:password@example.com/path?query")?;/// let mut iri = IriReferenceString::try_from("http://user:@example.com/path?query")?;//! IRI reference.relative_refr" A borrowed slice of a relative IRI reference."r" This corresponds to [`irelative-ref` rule] in [RFC 3987]"r" (and [`relative-ref` rule] in [RFC 3986])."r##" The rule for `irelative-ref` is `irelative-part [ "?" iquery ] [ "#" ifragment ]`."##r" This type can have a relative IRI reference."r" # use iri_string::types::IriRelativeStr;"r#" assert!(IriRelativeStr::new("foo").is_ok());"#r#" assert!(IriRelativeStr::new("foo/bar").is_ok());"#r#" assert!(IriRelativeStr::new("/foo").is_ok());"#r#" assert!(IriRelativeStr::new("//foo/bar").is_ok());"#r#" assert!(IriRelativeStr::new("?foo").is_ok());"#r##" assert!(IriRelativeStr::new("#foo").is_ok());"##r#" assert!(IriRelativeStr::new("foo/bar?baz#qux").is_ok());"#r" // The first path component can have colon if the path is absolute."r#" assert!(IriRelativeStr::new("/foo:bar/").is_ok());"#r" // Second or following path components can have colon."r#" assert!(IriRelativeStr::new("foo/bar://baz/").is_ok());"#r#" assert!(IriRelativeStr::new("./foo://bar").is_ok());"#r" Absolute form of a reference is not allowed."r#" assert!(IriRelativeStr::new("https://example.com/").is_err());"#r" // The first path component cannot have colon, if the path is not absolute."r#" assert!(IriRelativeStr::new("foo:bar").is_err());"#r#" assert!(IriRelativeStr::new("foo:").is_err());"#r#" assert!(IriRelativeStr::new("foo:/").is_err());"#r#" assert!(IriRelativeStr::new("foo://").is_err());"#r#" assert!(IriRelativeStr::new("foo:///").is_err());"#r#" assert!(IriRelativeStr::new("foo:////").is_err());"#r#" assert!(IriRelativeStr::new("foo://///").is_err());"#r" // `<` and `>` cannot directly appear in a relative IRI reference."r#" assert!(IriRelativeStr::new("<not allowed>").is_err());"#r" // Broken percent encoding cannot appear in a relative IRI reference."r#" assert!(IriRelativeStr::new("%").is_err());"#r#" assert!(IriRelativeStr::new("%GG").is_err());"#r" [`irelative-ref` rule]: https://tools.ietf.org/html/rfc3987#section-2.2"r" [`relative-ref` rule]: https://tools.ietf.org/html/rfc3986#section-4.2"r" An owned string of a relative IRI reference."r" For details, see the document for [`RiRelativeStr`]."/// use iri_string::types::IriRelativeStr;/// let iri = IriRelativeStr::new("//user:password@example.com/path?query")?;/// assert_eq!(masked.to_dedicated_string(), "//user:@example.com/path?query");///     "//user:${password}@example.com/path?query"/// let iri = IriRelativeStr::new("//example.com/pathpath?queryquery#fragfrag")?;/// let iri = IriRelativeStr::new("foo//bar:baz")?;/// assert_eq!(iri.path_str(), "foo//bar:baz");/// use iri_string::types::{IriQueryStr, IriRelativeStr};/// let iri = IriRelativeStr::new("foo//bar:baz?")?;/// # use iri_string::{spec::IriSpec, types::{IriFragmentStr, IriRelativeStr}, validate::Error};/// let iri = IriRelativeStr::new("?foo#bar")?;/// let fragment = IriFragmentStr::new("bar")?;/// let iri = IriRelativeStr::new("#foo")?;/// let iri = IriRelativeStr::new("#")?;/// # use iri_string::{spec::IriSpec, types::IriRelativeStr, validate::Error};/// let iri = IriRelativeStr::new("")?;/// assert_eq!(iri.fragment_str(), Some("bar"));/// let iri = IriRelativeStr::new("//user:pass@example.com:8080/pathpath?queryquery")?;/// use iri_string::types::{IriFragmentStr, IriRelativeString};/// let mut iri = IriRelativeString::try_from("//user:password@example.com/path?query#frag.old")?;/// assert_eq!(iri.fragment_str(), Some("frag.old"));/// iri.set_fragment(None);/// let frag_new = IriFragmentStr::new("frag-new")?;/// iri.set_fragment(Some(frag_new));/// assert_eq!(iri.fragment_str(), Some("frag-new"));/// Fragment can be empty, and it is distinguished from the absense of a fragment./// use iri_string::types::IriRelativeString;/// let mut iri = IriRelativeString::try_from("/path#")?;/// assert_eq!(iri, "/path#");/// assert_eq!(iri.fragment_str(), Some(""), "Fragment is present and empty");/// assert_eq!(iri, "/path", "Note that # is now removed");/// assert_eq!(iri.fragment_str(), None, "Fragment is absent");/// let mut iri = IriRelativeString::try_from("//user:password@example.com/path?query")?;/// assert_eq!(iri, "//user@example.com/path?query");/// let mut iri = IriRelativeString::try_from("//user:@example.com/path?query")?;/// assert_eq!(iri, "//user:@example.com/path?query");//! Relative IRI reference.absolute//! Generic resource identifier types.//! IRI           = scheme ":" ihier-part [ "?" iquery ] [ "#" ifragment ]//! IRI-reference = IRI / irelative-ref//! absolute-IRI  = scheme ":" ihier-part [ "?" iquery ]//! irelative-ref = irelative-part [ "?" iquery ] [ "#" ifragment ]//!     (`irelative-part` is roughly same as `ihier-part`.)//! Hierarchy://! RiReferenceStr//! |-- RiStr//! |   `-- RiAbsoluteStr//! `-- RiRelativeStr//! Therefore, the conversions below are safe and cheap://! * `RiStr -> RiReferenceStr`//! * `RiAbsoluteStr -> RiStr`//! * `RiAbsoluteStr -> RiReferenceStr`//! * `RiRelativeStr -> RiReferenceStr`//! For safely convertible types (consider `FooStr -> BarStr` is safe), traits//! below are implemented://! * `AsRef<BarStr> for FooStr`//! * `AsRef<BarStr> for FooString`//! * `From<FooString> for BarString`//! * `PartialEq<FooStr> for BarStr` and lots of impls like that//!     + `PartialEq` and `ParitalOrd`.//!     + Slice, owned, `Cow`, reference, etc...UriAbsoluteStrUriFragmentStrUriQueryStrUriReferenceStrUriRelativeStrUriStrIriAbsoluteStr/// A type alias for [`RiAbsoluteStr`]`<`[`IriSpec`]`>`.IriAbsoluteString/// A type alias for [`RiAbsoluteString`]`<`[`IriSpec`]`>`.IriFragmentStr/// A type alias for [`RiFragmentStr`]`<`[`IriSpec`]`>`.IriFragmentString/// A type alias for [`RiFragmentString`]`<`[`IriSpec`]`>`.IriStr/// A type alias for [`RiStr`]`<`[`IriSpec`]`>`.IriString/// A type alias for [`RiString`]`<`[`IriSpec`]`>`./// A type alias for [`RiReferenceStr`]`<`[`IriSpec`]`>`.IriReferenceString/// A type alias for [`RiReferenceString`]`<`[`IriSpec`]`>`.IriRelativeStr/// A type alias for [`RiRelativeStr`]`<`[`IriSpec`]`>`.IriRelativeString/// A type alias for [`RiRelativeString`]`<`[`IriSpec`]`>`.IriQueryStr/// A type alias for [`RiQueryStr`]`<`[`IriSpec`]`>`.IriQueryString/// A type alias for [`RiQueryString`]`<`[`IriSpec`]`>`.impl_conversion_between_uri/// Implements the conversion from an IRI into a URI.r" Percent-encodes the IRI into a valid URI that identifies the equivalent resource."r" If you need more precise control over memory allocation and buffer"r" handling, use [`MappedToUri`][`crate::convert::MappedToUri`] type."r" // Type annotation here is not necessary."encode_to_urir" Converts an IRI into a URI without modification, if possible."r" This is semantically equivalent to"r"     ascii_iri.as_uri().map(AsRef::as_ref),"r" assert_eq!(nonascii_iri.as_uri(), None);"as_urir" Conversion from an IRI into a URI."r" After the encode, the IRI is also a valid URI."r" If you want a new URI string rather than modifying the IRI"r" string, or if you need more precise control over memory"r" allocation and buffer handling, use"r" Panics if the memory allocation failed."r#" #[cfg(feature = "alloc")] {"#r" iri.encode_to_uri_inline();"encode_to_uri_inliner" iri.try_encode_to_uri_inline()"r#"     .expect("failed to allocate memory");"#try_encode_to_uri_inlineencode_into_uritry_encode_into_urir"     ascii_iri.try_into_uri().map(|uri| uri.to_string()),"r"     nonascii_iri.try_into_uri().map_err(|iri| iri.to_string()),"try_into_uri//! IRI-specific implementations./// A type alias for [`RiAbsoluteStr`]`<`[`UriSpec`]`>`./// A type alias for [`RiAbsoluteString`]`<`[`UriSpec`]`>`./// A type alias for [`RiFragmentStr`]`<`[`UriSpec`]`>`./// A type alias for [`RiFragmentString`]`<`[`UriSpec`]`>`./// A type alias for [`RiStr`]`<`[`UriSpec`]`>`./// A type alias for [`RiString`]`<`[`UriSpec`]`>`./// A type alias for [`RiReferenceStr`]`<`[`UriSpec`]`>`./// A type alias for [`RiReferenceString`]`<`[`UriSpec`]`>`./// A type alias for [`RiRelativeStr`]`<`[`UriSpec`]`>`./// A type alias for [`RiRelativeString`]`<`[`UriSpec`]`>`./// A type alias for [`RiQueryStr`]`<`[`UriSpec`]`>`./// A type alias for [`RiQueryString`]`<`[`UriSpec`]`>`.impl_conversions_between_iri/// Implements the trivial conversions between a URI and an IRI.//! URI-specific implementations.//! URI and IRI types.//! # URI and IRI//! IRIs (Internationalized Resource Identifiers) are defined in [RFC 3987],//! and URIs (Uniform Resource Identifiers) are defined in [RFC 3986].//! URI consists of only ASCII characters, and is a subset of IRI.//! IRIs are defined as below://! Definitions for URIs are almost same, but they cannot have non-ASCII characters.//! # Types//! Types can be categorized by://! * syntax,//! * spec, and//! * ownership.//! ## Syntax//! Since URIs and IRIs have almost same syntax and share algorithms, they are implemented by//! generic types.//! * [`RiStr`] and [`RiString`]//!     + String types for `IRI` and `URI` rules.//! * [`RiAbsoluteStr`] and [`RiAbsoluteString`]//!     + String types for `absolute-IRI` and `absolute-URI` rules.//! * [`RiReferenceStr`] and [`RiReferenceString`]//!     + String types for `IRI-reference` and `URI-reference` rules.//! * [`RiRelativeStr`] and [`RiRelativeString`]//!     + String types for `irelative-ref` and `relative-ref` rules.//! * [`RiFragmentStr`] and [`RiFragmentString`]//!     + String types for `ifragment` and `fragment` rules.//!     + Note that these types represents a substring of an IRI / URI references.//!       They are not intended to used directly as an IRI / URI references.//! "Ri" stands for "Resource Identifier".//! ## Spec//! These types have a type parameter, which represents RFC specification.//! [`IriSpec`] represents [RFC 3987] spec, and [`UriSpec`] represents [RFC 3986] spec.//! For example, `RiAbsoluteStr<IriSpec>` can have `absolute-IRI` string value,//! and `RiReferenceStr<UriSpec>` can have `URI-reference` string value.//! ## Ownership//! String-like types have usually two variations, borrowed and owned.//! Borrowed types (such as `str`, `Path`, `OsStr`) are unsized, and used by reference style.//! Owned types (such as `String`, `PathBuf`, `OsString`) are sized, and requires heap allocation.//! Owned types can be coerced to a borrowed type (for example, `&String` is automatically coerced//! to `&str` in many context).//! IRI / URI types have same variations, `RiFooStr` and `RiFooString`//! (`Foo` part represents syntax).//! They are very similar to `&str` and `String`.//! `Deref` is implemented, `RiFooStr::len()` is available, `&RiFooString` can be coerced to//! `&RiFooStr`, `Cow<'_, RiFooStr>` and `Box<RiFooStr>` is available, and so on.//! # Hierarchy and safe conversion//! IRI syntaxes have the hierarchy below.//! * `PartialEq<FooStr> for BarStr`, and lots of impls like that//! ## Fallible conversions//! Fallible conversions are implemented from plain string into IRI strings.//! * `TryFrom<&str> for &FooStr`//! * `TryFrom<&str> for FooString`//! * `TryFrom<String> for FooString`//! * `FromStr for FooString`//! Some IRI string types provide more convenient methods to convert between IRI types.//! For example, [`RiReferenceString::into_iri()`] tries to convert an IRI reference into an IRI,//! and returns `Result<IriString, IriRelativeString>`.//! This is because an IRI reference is valid as an IRI or a relative IRI reference.//! Such methods are usually more efficient than using `TryFrom` for plain strings, because they//! prevents you from losing ownership of a string, and does a conversion without extra memory//! allocation.//! # Aliases//! This module contains type aliases for RFC 3986 URI types and RFC 3987 IRI types.//! `IriFooStr{,ing}` are aliases of `RiFooStr{,ing}<IriSpec>`, and `UriFooStr{,ing}` are aliases//! of `RiFooStr{,ing}<UriSpec>`.//! # Wrapped string types//! Similar to string types in std (such as `str`, `std::path::Path`, and `std::ffi::OsStr`),//! IRI string types in this crate provides convenient conversions to://! * `std::box::Box`,//! * `std::borrow::Cow`,//! * `std::rc::Rc`, and//! * `std::sync::Arc`.//! # use iri_string::validate::Error;//! use iri_string::types::IriStr;//! let iri = IriStr::new("http://example.com/")?;//! let iri_owned = iri.to_owned();//! // From slice.//! let cow_1_1: Cow<'_, IriStr> = iri.into();//! let cow_1_2 = Cow::<'_, IriStr>::from(iri);//! assert!(matches!(cow_1_1, Cow::Borrowed(_)));//! assert!(matches!(cow_1_2, Cow::Borrowed(_)));//! // From owned.//! let cow_2_1: Cow<'_, IriStr> = iri_owned.clone().into();//! let cow_2_2 = Cow::<'_, IriStr>::from(iri_owned.clone());//! assert!(matches!(cow_2_1, Cow::Owned(_)));//! assert!(matches!(cow_2_2, Cow::Owned(_)));//! let box_1_1: Box<IriStr> = iri.into();//! let box_1_2 = Box::<IriStr>::from(iri);//! let box_2_1: Box<IriStr> = iri_owned.clone().into();//! let box_2_2 = Box::<IriStr>::from(iri_owned.clone());//! let rc_1_1: Rc<IriStr> = iri.into();//! let rc_1_2 = Rc::<IriStr>::from(iri);//! // Note that `From<owned> for Rc<borrowed>` is not implemented for now.//! // Get borrowed string by `.as_slice()` and convert it.//! let rc_2_1: Rc<IriStr> = iri_owned.clone().as_slice().into();//! let rc_2_2 = Rc::<IriStr>::from(iri_owned.clone().as_slice());//! let arc_1_1: Arc<IriStr> = iri.into();//! let arc_1_2 = Arc::<IriStr>::from(iri);//! // Note that `From<owned> for Arc<borrowed>` is not implemented for now.//! let arc_2_1: Arc<IriStr> = iri_owned.clone().as_slice().into();//! let arc_2_2 = Arc::<IriStr>::from(iri_owned.clone().as_slice());//! [`RiStr`]: struct.RiStr.html//! [`RiString`]: struct.RiString.html//! [`RiAbsoluteStr`]: struct.RiAbsoluteStr.html//! [`RiAbsoluteString`]: struct.RiAbsoluteString.html//! [`RiFragmentStr`]: struct.RiFragmentStr.html//! [`RiFragmentString`]: struct.RiFragmentString.html//! [`RiReferenceStr`]: struct.RiReferenceStr.html//! [`RiReferenceString`]: struct.RiReferenceString.html//! [`RiReferenceString::into_iri()`]: struct.RiReferenceString.html#method.into_iri//! [`RiRelativeStr`]: struct.RiRelativeStr.html//! [`RiRelativeString`]: struct.RiRelativeString.html//! [`IriSpec`]: ../spec/enum.IriSpec.html//! [`UriSpec`]: ../spec/enum.UriSpec.html/// Resource identifier validation error./// Validates [IRI][uri]./// This validator corresponds to [`RiStr`] and [`RiString`] types./// This type can have an IRI (which is absolute, and may have fragment part)./// use iri_string::{spec::UriSpec, validate::iri};/// assert!(iri::<UriSpec>("https://user:pass@example.com:8080").is_ok());/// assert!(iri::<UriSpec>("https://example.com/").is_ok());/// assert!(iri::<UriSpec>("https://example.com/foo?bar=baz").is_ok());/// assert!(iri::<UriSpec>("https://example.com/foo?bar=baz#qux").is_ok());/// assert!(iri::<UriSpec>("foo:bar").is_ok());/// assert!(iri::<UriSpec>("foo:").is_ok());/// // `foo://.../` below are all allowed. See the crate documentation for detail./// assert!(iri::<UriSpec>("foo:/").is_ok());/// assert!(iri::<UriSpec>("foo://").is_ok());/// assert!(iri::<UriSpec>("foo:///").is_ok());/// assert!(iri::<UriSpec>("foo:////").is_ok());/// assert!(iri::<UriSpec>("foo://///").is_ok());/// Relative IRI reference is not allowed./// // This is relative path./// assert!(iri::<UriSpec>("foo/bar").is_err());/// // `/foo/bar` is an absolute path, but it is authority-relative./// assert!(iri::<UriSpec>("/foo/bar").is_err());/// // `//foo/bar` is termed "network-path reference",/// // or usually called "protocol-relative reference"./// assert!(iri::<UriSpec>("//foo/bar").is_err());/// // Same-document reference is relative./// assert!(iri::<UriSpec>("#foo").is_err());/// // Empty string is not a valid absolute IRI./// assert!(iri::<UriSpec>("").is_err());/// Some characters and sequences cannot used in an IRI./// assert!(iri::<UriSpec>("<not allowed>").is_err());/// assert!(iri::<UriSpec>("%").is_err());/// assert!(iri::<UriSpec>("%GG").is_err());/// [uri]: https://tools.ietf.org/html/rfc3986#section-3/// [`RiStr`]: ../types/struct.RiStr.html/// [`RiString`]: ../types/struct.RiString.html/// Validates [IRI reference][uri-reference]./// This validator corresponds to [`RiReferenceStr`] and [`RiReferenceString`] types./// This type can have an IRI reference (which can be absolute or relative)./// use iri_string::{spec::UriSpec, validate::iri_reference};/// assert!(iri_reference::<UriSpec>("https://user:pass@example.com:8080").is_ok());/// assert!(iri_reference::<UriSpec>("https://example.com/").is_ok());/// assert!(iri_reference::<UriSpec>("https://example.com/foo?bar=baz").is_ok());/// assert!(iri_reference::<UriSpec>("https://example.com/foo?bar=baz#qux").is_ok());/// assert!(iri_reference::<UriSpec>("foo:bar").is_ok());/// assert!(iri_reference::<UriSpec>("foo:").is_ok());/// assert!(iri_reference::<UriSpec>("foo:/").is_ok());/// assert!(iri_reference::<UriSpec>("foo://").is_ok());/// assert!(iri_reference::<UriSpec>("foo:///").is_ok());/// assert!(iri_reference::<UriSpec>("foo:////").is_ok());/// assert!(iri_reference::<UriSpec>("foo://///").is_ok());/// assert!(iri_reference::<UriSpec>("foo/bar").is_ok());/// assert!(iri_reference::<UriSpec>("/foo/bar").is_ok());/// assert!(iri_reference::<UriSpec>("//foo/bar").is_ok());/// assert!(iri_reference::<UriSpec>("#foo").is_ok());/// Some characters and sequences cannot used in an IRI reference./// // `<` and `>` cannot directly appear in an IRI reference./// assert!(iri_reference::<UriSpec>("<not allowed>").is_err());/// // Broken percent encoding cannot appear in an IRI reference./// assert!(iri_reference::<UriSpec>("%").is_err());/// assert!(iri_reference::<UriSpec>("%GG").is_err());/// [uri-reference]: https://tools.ietf.org/html/rfc3986#section-4.1/// [`RiReferenceStr`]: ../types/struct.RiReferenceStr.html/// [`RiReferenceString`]: ../types/struct.RiReferenceString.html/// Validates [absolute IRI][absolute-uri]./// This validator corresponds to [`RiAbsoluteStr`] and [`RiAbsoluteString`] types./// This type can have an absolute IRI without fragment part./// use iri_string::{spec::UriSpec, validate::absolute_iri};/// assert!(absolute_iri::<UriSpec>("https://example.com/foo?bar=baz").is_ok());/// assert!(absolute_iri::<UriSpec>("foo:bar").is_ok());/// // Scheme `foo` and empty path./// assert!(absolute_iri::<UriSpec>("foo:").is_ok());/// assert!(absolute_iri::<UriSpec>("foo:/").is_ok());/// assert!(absolute_iri::<UriSpec>("foo://").is_ok());/// assert!(absolute_iri::<UriSpec>("foo:///").is_ok());/// assert!(absolute_iri::<UriSpec>("foo:////").is_ok());/// assert!(absolute_iri::<UriSpec>("foo://///").is_ok());/// Relative IRI is not allowed./// assert!(absolute_iri::<UriSpec>("foo/bar").is_err());/// assert!(absolute_iri::<UriSpec>("/foo/bar").is_err());/// assert!(absolute_iri::<UriSpec>("//foo/bar").is_err());/// assert!(absolute_iri::<UriSpec>("").is_err());/// Fragment part (such as trailing `#foo`) is not allowed./// // Fragment part is not allowed./// assert!(absolute_iri::<UriSpec>("https://example.com/foo?bar=baz#qux").is_err());/// Some characters and sequences cannot used in an absolute IRI./// // `<` and `>` cannot directly appear in an absolute IRI./// assert!(absolute_iri::<UriSpec>("<not allowed>").is_err());/// // Broken percent encoding cannot appear in an absolute IRI./// assert!(absolute_iri::<UriSpec>("%").is_err());/// assert!(absolute_iri::<UriSpec>("%GG").is_err());/// [absolute-uri]: https://tools.ietf.org/html/rfc3986#section-4.3/// [`RiAbsoluteStr`]: ../types/struct.RiAbsoluteStr.html/// [`RiAbsoluteString`]: ../types/struct.RiAbsoluteString.html/// Validates [relative reference][relative-ref]./// This validator corresponds to [`RiRelativeStr`] and [`RiRelativeString`] types./// This type can have a relative IRI reference./// use iri_string::{spec::UriSpec, validate::relative_ref};/// assert!(relative_ref::<UriSpec>("foo").is_ok());/// assert!(relative_ref::<UriSpec>("foo/bar").is_ok());/// assert!(relative_ref::<UriSpec>("/foo").is_ok());/// assert!(relative_ref::<UriSpec>("//foo/bar").is_ok());/// assert!(relative_ref::<UriSpec>("?foo").is_ok());/// assert!(relative_ref::<UriSpec>("#foo").is_ok());/// assert!(relative_ref::<UriSpec>("foo/bar?baz#qux").is_ok());/// // The first path component can have colon if the path is absolute./// assert!(relative_ref::<UriSpec>("/foo:bar/").is_ok());/// // Second or following path components can have colon./// assert!(relative_ref::<UriSpec>("foo/bar://baz/").is_ok());/// assert!(relative_ref::<UriSpec>("./foo://bar").is_ok());/// Absolute form of a reference is not allowed./// assert!(relative_ref::<UriSpec>("https://example.com/").is_err());/// // The first path component cannot have colon, if the path is not absolute./// assert!(relative_ref::<UriSpec>("foo:bar").is_err());/// assert!(relative_ref::<UriSpec>("foo:").is_err());/// assert!(relative_ref::<UriSpec>("foo:/").is_err());/// assert!(relative_ref::<UriSpec>("foo://").is_err());/// assert!(relative_ref::<UriSpec>("foo:///").is_err());/// assert!(relative_ref::<UriSpec>("foo:////").is_err());/// assert!(relative_ref::<UriSpec>("foo://///").is_err());/// // `<` and `>` cannot directly appear in a relative IRI reference./// assert!(relative_ref::<UriSpec>("<not allowed>").is_err());/// // Broken percent encoding cannot appear in a relative IRI reference./// assert!(relative_ref::<UriSpec>("%").is_err());/// assert!(relative_ref::<UriSpec>("%GG").is_err());/// [relative-ref]: https://tools.ietf.org/html/rfc3986#section-4.2/// [`RiRelativeStr`]: ../types/struct.RiRelativeStr.html/// [`RiRelativeString`]: ../types/struct.RiRelativeString.html/// Validates [IRI path][path]./// [path]: https://tools.ietf.org/html/rfc3986#section-3.3/// Validates [IRI query][query]./// This validator corresponds to [`RiQueryStr`] and [`RiQueryString`] types./// Note that the first `?` character in an IRI is not a part of a query./// For example, `https://example.com/?foo#bar` has a query `foo`, **not** `?foo`./// This type can have an IRI query./// Note that the IRI `foo://bar/baz?qux#quux` has the query `qux`, **not** `?qux`./// use iri_string::{spec::UriSpec, validate::query};/// assert!(query::<UriSpec>("").is_ok());/// assert!(query::<UriSpec>("foo").is_ok());/// assert!(query::<UriSpec>("foo/bar").is_ok());/// assert!(query::<UriSpec>("/foo/bar").is_ok());/// assert!(query::<UriSpec>("//foo/bar").is_ok());/// assert!(query::<UriSpec>("https://user:pass@example.com:8080").is_ok());/// assert!(query::<UriSpec>("https://example.com/").is_ok());/// assert!(query::<UriSpec>("query?again").is_ok());/// Some characters and sequences cannot used in a query./// assert!(query::<UriSpec>("<not allowed>").is_err());/// assert!(query::<UriSpec>("%").is_err());/// assert!(query::<UriSpec>("%GG").is_err());/// assert!(query::<UriSpec>("#hash").is_err());/// [query]: https://tools.ietf.org/html/rfc3986#section-3.4/// [`RiQueryStr`]: ../types/struct.RiQueryStr.html/// [`RiQueryString`]: ../types/struct.RiQueryString.html/// Validates [IRI fragment][fragment]./// This validator corresponds to [`RiFragmentStr`] and [`RiFragmentString`] types./// Note that the first `#` character in an IRI is not a part of a fragment./// For example, `https://example.com/#foo` has a fragment `foo`, **not** `#foo`./// This type can have an IRI fragment./// Note that the IRI `foo://bar/baz#qux` has the fragment `qux`, **not** `#qux`./// use iri_string::{spec::UriSpec, validate::fragment};/// assert!(fragment::<UriSpec>("").is_ok());/// assert!(fragment::<UriSpec>("foo").is_ok());/// assert!(fragment::<UriSpec>("foo/bar").is_ok());/// assert!(fragment::<UriSpec>("/foo/bar").is_ok());/// assert!(fragment::<UriSpec>("//foo/bar").is_ok());/// assert!(fragment::<UriSpec>("https://user:pass@example.com:8080").is_ok());/// assert!(fragment::<UriSpec>("https://example.com/").is_ok());/// Some characters and sequences cannot used in a fragment./// assert!(fragment::<UriSpec>("<not allowed>").is_err());/// assert!(fragment::<UriSpec>("%").is_err());/// assert!(fragment::<UriSpec>("%GG").is_err());/// assert!(fragment::<UriSpec>("#hash").is_err());/// [fragment]: https://tools.ietf.org/html/rfc3986#section-3.5/// [`RiFragmentStr`]: ../types/struct.RiFragmentStr.html/// [`RiFragmentString`]: ../types/struct.RiFragmentString.html//! Validators./// Returns true if this is a terminal./// use is_terminal::IsTerminal;/// if std::io::stdout().is_terminal() {///     println!("stdout is a terminal")/// Extension trait to check whether something is a terminal./// Returns `true` if `this` is a terminal./// This is equivalent to calling `this.is_terminal()` and exists only as a/// convenience to calling the trait method [`IsTerminal::is_terminal`]/// without importing the trait./// if is_terminal::is_terminal(&std::io::stdout()) {stdin_vs_libcstdout_vs_libcstderr_vs_libc//! is-terminal is a simple utility that answers one question://! > Is this a terminal?//! A "terminal", also known as a "tty", is an I/O device which may be//! interactive and may support color and other special features. This crate//! doesn't provide any of those features; it just answers this one question.//! On Unix-family platforms, this is effectively the same as the [`isatty`]//! function for testing whether a given stream is a terminal, though it//! accepts high-level stream types instead of raw file descriptors.//! On Windows, it uses a variety of techniques to determine whether the//! given stream is a terminal.//! use is_terminal::IsTerminal;//! if std::io::stdout().is_terminal() {//!     println!("stdout is a terminal")//! [`isatty`]: https://man7.org/linux/man-pages/man3/isatty.3.html// The Windows implementation here is copied from `handle_is_console` in// library/std/src/sys/pal/windows/io.rs in Rust at revision// e74c667a53c6368579867a74494e6fb7a7f17d13.BuildModelbuild_channelis_release/// On platforms where Rust does not know how to detect a terminal yet, this will return/// `false`. This will also return `false` if an unexpected error occurred, such as from/// passing an invalid file descriptor./// On Windows, in addition to detecting consoles, this currently uses some heuristics to/// detect older msys/cygwin/mingw pseudo-terminals based on device name: devices with names/// starting with `msys-` or `cygwin-` and ending in `-pty` will be considered terminals./// Note that this [may change in the future][changes]./// [changes]: std::io#platform-specific-behaviorimpl_is_terminal//! > Polyfill for `is_terminal` stdlib feature for use with older MSRVs"iterator adaptors are lazy and do nothing unless consumed"CItem/// `last` is `None` while no item have been taken out of `iter` (at definition)./// Then `last` will be `Some(Some(item))` until `iter` is exhausted,/// in which case `last` will be `Some(None)`.CoalesceByCountItemclone_fieldsdebug_fmt_fieldscoalesce_pairCoalescePredicateFnAccNoCountWithCountCoalesce/// An iterator adaptor that may join together adjacent elements./// See [`.coalesce()`](crate::Itertools::coalesce) for more information.coalesce/// Create a new `Coalesce`.PredDedupByDedupPred2CoalescePred/// An iterator adaptor that removes repeated duplicates, determining equality using a comparison function./// See [`.dedup_by()`](crate::Itertools::dedup_by) or [`.dedup()`](crate::Itertools::dedup) for more information.DPdedup_pair// TODO replace by Fn(&T, &T)->bool once Rust supports itDedupPredicateDedupEqdedup_by/// Create a new `DedupBy`.Dedup/// An iterator adaptor that removes repeated duplicates./// See [`.dedup()`](crate::Itertools::dedup) for more information.dedup/// Create a new `Dedup`.DedupByWithCountDedupPredWithCount2CoalescePred/// An iterator adaptor that removes repeated duplicates, while keeping a count of how many/// repeated elements were present. This will determine equality using a comparison function./// See [`.dedup_by_with_count()`](crate::Itertools::dedup_by_with_count) or/// [`.dedup_with_count()`](crate::Itertools::dedup_with_count) for more information.DedupWithCount/// repeated elements were present./// See [`.dedup_with_count()`](crate::Itertools::dedup_with_count) for more information.dedup_by_with_count/// Create a new `DedupByWithCount`.dedup_with_count/// Create a new `DedupWithCount`.MapSpecialCaseMapSpecialCaseFnMapSpecialCaseFnOk/// An iterator adapter to apply a transformation within a nested `Result::Ok`./// See [`.map_ok()`](crate::Itertools::map_ok) for more information.MapResults/// See [`MapOk`]./// Create a new `MapOk` iterator.MapSpecialCaseFnInto/// An iterator adapter to apply `Into` conversion to each element./// See [`.map_into()`](crate::Itertools::map_into) for more information./// Create a new [`MapInto`] iterator.multi_productnext_coming_from_jInterleave/// An iterator adaptor that alternates elements from two iterators until both/// run out./// This iterator is *fused*./// See [`.interleave()`](crate::Itertools::interleave) for more information.interleave/// Create an iterator that interleaves elements in `i` and `j`./// [`IntoIterator`] enabled version of `[Itertools::interleave]`.InterleaveShortest/// An iterator adaptor that alternates elements from the two iterators until/// one of them runs out./// See [`.interleave_shortest()`](crate::Itertools::interleave_shortest)interleave_shortest/// Create a new `InterleaveShortest` iterator.PutBack/// An iterator adaptor that allows putting back a single/// item to the front of the iterator./// Iterator element type is `I::Item`.put_back/// Create an iterator where you can put back a single item/// put back value `value` (builder method)/// Split the `PutBack` into its parts./// Put back a single value to the front of the iterator./// If a value is already in the put back slot, it is overwritten.a_cur/// `a_cur` is `None` while no item have been taken out of `a` (at definition)./// Then `a_cur` will be `Some(Some(item))` until `a` is exhausted,/// in which case `a_cur` will be `Some(None)`.b_orig/// An iterator adaptor that iterates over the cartesian product of/// the element sets of two iterators `I` and `J`./// Iterator element type is `(I::Item, J::Item)`./// See [`.cartesian_product()`](crate::Itertools::cartesian_product) for more information.cartesian_product/// Create a new cartesian product iteratorBatching/// A “meta iterator adaptor”. Its closure receives a reference to the iterator/// and may pick off as many elements as it likes, to produce the next iterator element./// Iterator element type is *X*, if the return type of `F` is *Option\<X\>*./// See [`.batching()`](crate::Itertools::batching) for more information.batching/// Create a new Batching iterator./// An iterator adaptor that steps a number elements in the base iterator/// for each iteration./// The iterator steps by yielding the next element from the base iterator,/// then skipping forward *n-1* elements./// See [`.step()`](crate::Itertools::step) for more information./// Create a `Step` iterator./// **Panics** if the step is 0.// known sizeTakeWhileRef/// An iterator adaptor that borrows from a `Clone`-able iterator/// to only pick off elements while the predicate returns `true`./// See [`.take_while_ref()`](crate::Itertools::take_while_ref) for more information.take_while_ref/// Create a new `TakeWhileRef` from a reference to clonable iterator.WhileSome/// An iterator adaptor that filters `Option<A>` iterator elements/// and produces `A`. Stops on the first `None` encountered./// See [`.while_some()`](crate::Itertools::while_some) for more information.while_some/// Create a new `WhileSome<I>`.Combination_miTupleCombinationsHasCombination/// An iterator to iterate through all combinations in a `Clone`-able iterator that produces tuples/// of a specific size./// See [`.tuple_combinations()`](crate::Itertools::tuple_combinations) for moretuple_combinations/// Create a new `TupleCombinations` from a clonable iterator.Tuple1Combinationimpl_tuple_combinationTuple2Combinationignore_ident// This snippet generates the twelve `impl_tuple_combination!` invocations://    use core::iter;//    use itertools::Itertools;//    for i in 2..=12 {//        println!("impl_tuple_combination!(Tuple{arity}Combination Tuple{prev}Combination; {idents});",//            arity = i,//            prev = i - 1,//            idents = ('a'..'z').take(i - 1).join(" "),//        );// It could probably be replaced by a bit more macro cleverness.Tuple3CombinationTuple4CombinationTuple5CombinationTuple6CombinationTuple7CombinationTuple8CombinationTuple9CombinationTuple10CombinationTuple11CombinationTuple12Combinationchecked_binomial// https://en.wikipedia.org/wiki/Binomial_coefficient#In_programming_languagestest_checked_binomialFilterOk/// An iterator adapter to filter values within a nested `Result::Ok`./// See [`.filter_ok()`](crate::Itertools::filter_ok) for more information.filter_ok/// Create a new `FilterOk` iterator.FilterMapOk/// An iterator adapter to filter and apply a transformation on values within a nested `Result::Ok`./// See [`.filter_map_ok()`](crate::Itertools::filter_map_ok) for more information.transpose_resultfilter_map_okPositions/// An iterator adapter to get the positions of each element that matches a predicate./// See [`.positions()`](crate::Itertools::positions) for more information.positions/// Create a new `Positions` iterator./// An iterator adapter to apply a mutating function to each element before yielding it./// See [`.update()`](crate::Itertools::update) for more information./// Create a new `Update` iterator.// if possible, re-use inner iterator specializations in collect//! Licensed under the Apache License, Version 2.0//! <https://www.apache.org/licenses/LICENSE-2.0> or the MIT license//! <https://opensource.org/licenses/MIT>, at your//! option. This file may not be copied, modified, or distributed//! except according to those terms.MultiProductIterMultiProduct/// multiple iterators of type `I`./// An iterator element type is `Vec<I>`./// See [`.multi_cartesian_product()`](crate::Itertools::multi_cartesian_product)multi_cartesian_product/// Create a new cartesian product iterator over an arbitrary number/// of iterators of the same type./// Iterator element is of type `Vec<H::Item::Item>`.iter_orig/// Holds the state of a single iterator within a `MultiProduct`.MultiProductIterStateStartOfIteron_first_iterMidIter/// Holds the current state during an iteration of a `MultiProduct`.iterate_last/// Iterates the rightmost iterator, then recursively iterates iterators/// to the left if necessary./// Returns true if the iteration succeeded, else false.curr_iterator/// Returns the unwrapped value of the next iteration.in_progress/// Returns true if iteration has started and has not yet finished; falseiterate/// Iterate the managed iterator./// Reset the managed iterator./// Returns true if the current iterator has been started and has not yet/// finished; false otherwise.lazy_bufferadaptorsCombinations/// An iterator to iterate through all the `k`-length combinations in an iterator./// See [`.combinations()`](crate::Itertools::combinations) for more information.combinations/// Create a new `Combinations` from a clonable iterator./// Returns the length of a combination produced by this iterator./// Returns the (current) length of the pool from which combination elements are/// selected. This value can change between invocations of [`next`](Combinations::next)./// Returns a reference to the source pool./// Resets this `Combinations` back to an initial state for combinations of length/// `k` over the same pool data source. If `k` is larger than the current length/// of the data pool an attempt is made to prefill the pool so that it holds `k`n_and_countremaining_for/// For a given size `n`, return the count of remaining combinations or None if it would overflow.CombinationsWithReplacement/// An iterator to iterate through all the `n`-length combinations in an iterator, with replacement./// See [`.combinations_with_replacement()`](crate::Itertools::combinations_with_replacement)/// Map the current mask over the pool to get an output combinationcombinations_with_replacement/// Create a new `CombinationsWithReplacement` from a clonable iterator./// For a given size `n`, return the count of remaining combinations with replacement or None if it would overflow./// Combine all an iterator's elements into one element by using [`Extend`]./// [`IntoIterator`]-enabled version of [`Itertools::concat`]./// This combinator will extend the first item with each of the rest of the/// items of the iterator. If the iterator is empty, the default value of/// `I::Item` is returned./// use itertools::concat;/// let input = vec![vec![1], vec![2, 3], vec![4, 5, 6]];/// assert_eq!(concat(input), vec![1, 2, 3, 4, 5, 6]);impl_cons_iter// stopConsTuples/// An iterator that maps an iterator of tuples like/// `((A, B), C)` to an iterator of `(A, B, C)`./// Used by the `iproduct!()` macro.cons_tuples/// Create an iterator that maps for example iterators of/// `((A, B), C)` to `(A, B, C)`.FirstMismatch/// The index of the first non-matching element along with both iterator's remaining elements/// starting with the first mis-match./// The total number of elements that were in `J` along with the remaining elements of `I`./// The total number of elements that were in `I` along with the remaining elements of `J`./// A type returned by the [`diff_with`] function./// `Diff` represents the way in which the elements yielded by the iterator `I` differ to some/// iterator `J`.diff_with/// Compares every element yielded by both `i` and `j` with the given function in lock-step and/// returns a [`Diff`] which describes how `j` differs from `i`./// If the number of elements yielded by `j` is less than the number of elements yielded by `i`,/// the number of `j` elements yielded will be returned along with `i`'s remaining elements as/// `Diff::Shorter`./// If the two elements of a step differ, the index of those elements along with the remaining/// elements of both `i` and `j` are returned as `Diff::FirstMismatch`./// If `i` becomes exhausted before `j` becomes exhausted, the number of elements in `i` along with/// the remaining `j` elements will be returned as `Diff::Longer`.//! "Diff"ing iterators for caching elements to sequential collections without requiring the new//! elements' iterator to be `Clone`.//! - [`Diff`] (produced by the [`diff_with`] function)//! describes the difference between two non-`Clone` iterators `I` and `J` after breaking ASAP from//! a lock-step comparison.DuplicatesBykey_methodKeyMethod/// Takes an item and returns it back to the caller if it's the second time we see it./// Otherwise the item is consumed and None is returnedKeyXorValue/// A keying method for use with `DuplicatesBy`ById/// Apply the identity function to elements before checking them for equality.JustValueByFn/// Apply a user-supplied function to elements before checking them for equality.// Implementors of this trait can hold onto a key and a value but only give access to one of them// at a time. This allows the key and the value to be the same value internally/// An iterator adapter to filter for duplicate elements./// See [`.duplicates_by()`](crate::Itertools::duplicates_by) for more information.duplicates_by/// Create a new `DuplicatesBy` iterator./// An iterator adapter to filter out duplicate elements./// See [`.duplicates()`](crate::Itertools::duplicates) for more information.duplicates/// Create a new `Duplicates` iterator.EitherOrBoth/// Both values are present./// Only the left value of type `A` is present./// Only the right value of type `B` is present./// Value that either holds a single A or B, or both.has_left/// If `Left`, or `Both`, return true. Otherwise, return false.has_right/// If `Right`, or `Both`, return true, otherwise, return false./// If `Left`, return true. Otherwise, return false./// Exclusive version of [`has_left`](EitherOrBoth::has_left)./// If `Right`, return true. Otherwise, return false./// Exclusive version of [`has_right`](EitherOrBoth::has_right).is_both/// If `Both`, return true. Otherwise, return false./// If `Left`, or `Both`, return `Some` with the left value. Otherwise, return `None`./// If `Right`, or `Both`, return `Some` with the right value. Otherwise, return `None`.left_and_right/// Return tuple of options corresponding to the left and right value respectively/// If `Left` return `(Some(..), None)`, if `Right` return `(None,Some(..))`, else return/// `(Some(..),Some(..))`just_left/// If `Left`, return `Some` with the left value. If `Right` or `Both`, return `None`./// // On the `Left` variant./// # use itertools::{EitherOrBoth, EitherOrBoth::{Left, Right, Both}};/// let x: EitherOrBoth<_, ()> = Left("bonjour");/// assert_eq!(x.just_left(), Some("bonjour"));/// // On the `Right` variant./// let x: EitherOrBoth<(), _> = Right("hola");/// assert_eq!(x.just_left(), None);/// // On the `Both` variant./// let x = Both("bonjour", "hola");just_right/// If `Right`, return `Some` with the right value. If `Left` or `Both`, return `None`./// # use itertools::{EitherOrBoth::{Left, Right, Both}, EitherOrBoth};/// let x: EitherOrBoth<_, ()> = Left("auf wiedersehen");/// assert_eq!(x.just_left(), Some("auf wiedersehen"));/// let x: EitherOrBoth<(), _> = Right("adios");/// let x = Both("auf wiedersehen", "adios");/// If `Both`, return `Some` containing the left and right values. Otherwise, return `None`.into_left/// If `Left` or `Both`, return the left value. Otherwise, convert the right value and return it.into_right/// If `Right` or `Both`, return the right value. Otherwise, convert the left value and return it./// Converts from `&EitherOrBoth<A, B>` to `EitherOrBoth<&A, &B>`./// Converts from `&mut EitherOrBoth<A, B>` to `EitherOrBoth<&mut A, &mut B>`.as_deref/// Converts from `&EitherOrBoth<A, B>` to `EitherOrBoth<&_, &_>` using the [`Deref`] trait.as_deref_mut/// Converts from `&mut EitherOrBoth<A, B>` to `EitherOrBoth<&mut _, &mut _>` using the [`DerefMut`] trait./// Convert `EitherOrBoth<A, B>` to `EitherOrBoth<B, A>`./// Apply the function `f` on the value `a` in `Left(a)` or `Both(a, b)` variants. If it is/// present rewrapping the result in `self`'s original variant./// Apply the function `f` on the value `b` in `Right(b)` or `Both(a, b)` variants./// If it is present rewrapping the result in `self`'s original variant.map_any/// Apply the functions `f` and `g` on the value `a` and `b` respectively;/// found in `Left(a)`, `Right(b)`, or `Both(a, b)` variants./// The Result is rewrapped `self`'s original variant./// Apply the function `f` on the value `a` in `Left(a)` or `Both(a, _)` variants if it is/// Apply the function `f` on the value `b`/// in `Right(b)` or `Both(_, b)` variants if it is present./// Returns a tuple consisting of the `l` and `r` in `Both(l, r)`, if present./// Otherwise, returns the wrapped value for the present element, and the supplied/// value for the other. The first (`l`) argument is used for a missing `Left`/// value. The second (`r`) argument is used for a missing `Right` value./// Arguments passed to `or` are eagerly evaluated; if you are passing/// the result of a function call, it is recommended to use [`or_else`],/// which is lazily evaluated./// [`or_else`]: EitherOrBoth::or_else/// # use itertools::EitherOrBoth;/// assert_eq!(EitherOrBoth::Both("tree", 1).or("stone", 5), ("tree", 1));/// assert_eq!(EitherOrBoth::Left("tree").or("stone", 5), ("tree", 5));/// assert_eq!(EitherOrBoth::Right(1).or("stone", 5), ("stone", 1));/// Otherwise, returns the wrapped value for the present element, and the [`default`](Default::default)/// for the other./// Otherwise, returns the wrapped value for the present element, and computes the/// missing value with the supplied closure. The first argument (`l`) is used for a/// missing `Left` value. The second argument (`r`) is used for a missing `Right` value./// let k = 10;/// assert_eq!(EitherOrBoth::Both("tree", 1).or_else(|| "stone", || 2 * k), ("tree", 1));/// assert_eq!(EitherOrBoth::Left("tree").or_else(|| "stone", || 2 * k), ("tree", 20));/// assert_eq!(EitherOrBoth::Right(1).or_else(|| "stone", || 2 * k), ("stone", 1));left_or_insert/// Returns a mutable reference to the left value. If the left value is not present,/// it is replaced with `val`.right_or_insert/// Returns a mutable reference to the right value. If the right value is not present,left_or_insert_with/// If the left value is not present, replace it the value computed by the closure `f`./// Returns a mutable reference to the now-present left value.right_or_insert_with/// If the right value is not present, replace it the value computed by the closure `f`./// Returns a mutable reference to the now-present right value.insert_left/// Sets the `left` value of this instance, and returns a mutable reference to it./// Does not affect the `right` value./// // Overwriting a pre-existing value./// let mut either: EitherOrBoth<_, ()> = Left(0_u32);/// assert_eq!(*either.insert_left(69), 69);/// // Inserting a second value./// let mut either = Right("no");/// assert_eq!(*either.insert_left("yes"), "yes");/// assert_eq!(either, Both("yes", "no"));insert_right/// Sets the `right` value of this instance, and returns a mutable reference to it./// Does not affect the `left` value./// # use itertools::{EitherOrBoth, EitherOrBoth::{Left, Both}};/// let mut either = Left("what's");/// assert_eq!(*either.insert_right(9 + 10), 21 - 2);/// assert_eq!(either, Both("what's", 9+10));insert_both/// Set `self` to `Both(..)`, containing the specified left and right values,/// and returns a mutable reference to those values./// Return either value of left, right, or apply a function `f` to both values if both are present./// The input function has to return the same type as both Right and Left carry./// This function can be used to preferrably extract the left resp. right value,/// but fall back to the other (i.e. right resp. left) if the preferred one is not present./// assert_eq!(EitherOrBoth::Both(3, 7).reduce(u32::max), 7);/// assert_eq!(EitherOrBoth::Left(3).reduce(u32::max), 3);/// assert_eq!(EitherOrBoth::Right(7).reduce(u32::max), 7);/// // Extract the left value if present, fall back to the right otherwise./// assert_eq!(EitherOrBoth::Left("left").reduce(|l, _r| l), "left");/// assert_eq!(EitherOrBoth::Right("right").reduce(|l, _r| l), "right");/// assert_eq!(EitherOrBoth::Both("left", "right").reduce(|l, _r| l), "left");first_twoExactlyOneError/// Iterator returned for the error case of `Itertools::exactly_one()`/// This iterator yields exactly the same elements as the input iterator./// During the execution of `exactly_one` the iterator must be mutated.  This wrapper/// effectively "restores" the state of the input iterator when it's handed back./// This is very similar to `PutBackN` except this iterator only supports 0-2 elements and does not/// use a `Vec`./// Creates a new `ExactlyOneErr` iterator.additional_lenmin_set_impl/// Implementation guts for `min_set`, `min_set_by`, and `min_set_by_key`.max_set_impl/// Implementation guts for `ax_set`, `max_set_by`, and `max_set_by_key`.flatten_okFlattenOkinner_frontinner_back/// An iterator adaptor that flattens `Result::Ok` values and/// allows `Result::Err` values through unchanged./// See [`.flatten_ok()`](crate::Itertools::flatten_ok) for more information./// Only the iterator being flattened needs to implement [`FusedIterator`]./// FormatWith uses interior mutability because Display::fmt takes &self.FormatWith/// Format all iterator elements lazily, separated by `sep`./// The format value can only be formatted once, after that the iterator is/// exhausted./// See [`.format_with()`](crate::Itertools::format_with) for more information./// Format uses interior mutability because Display::fmt takes &self./// See [`.format()`](crate::Itertools::format)new_formatnew_format_defaultimpl_formatintersperseIntersperseIntersperseWithmerge_joinmerge_join_byzip_eq_implzip_eq/// Iterate `iterable` with a particular value inserted between each element./// [`IntoIterator`] enabled version of [`Iterator::intersperse`]./// use itertools::intersperse;/// itertools::assert_equal(intersperse((0..3), 8), vec![0, 8, 1, 8, 2]);intersperse_with/// Iterate `iterable` with a particular value created by a function inserted/// between each element./// [`IntoIterator`] enabled version of [`Iterator::intersperse_with`]./// use itertools::intersperse_with;/// let mut i = 10;/// itertools::assert_equal(intersperse_with((0..3), || { i -= 1; i }), vec![0, 9, 1, 8, 2]);/// assert_eq!(i, 8);/// Iterate `iterable` with a running index./// [`IntoIterator`] enabled version of [`Iterator::enumerate`]./// use itertools::enumerate;/// for (i, elt) in enumerate(&[1, 2, 3]) {///     /* loop body *//// Iterate `iterable` in reverse./// [`IntoIterator`] enabled version of [`Iterator::rev`]./// use itertools::rev;/// for elt in rev(&[1, 2, 3]) {/// Converts the arguments to iterators and zips them./// [`IntoIterator`] enabled version of [`Iterator::zip`]./// use itertools::zip;/// let mut result: Vec<(i32, char)> = Vec::new();/// for (a, b) in zip(&[1, 2, 3, 4, 5], &['a', 'b', 'c']) {///     result.push((*a, *b));/// assert_eq!(result, vec![(1, 'a'),(2, 'b'),(3, 'c')]);/// Takes two iterables and creates a new iterator over both in sequence./// [`IntoIterator`] enabled version of [`Iterator::chain`]./// use itertools::chain;/// let mut result:Vec<i32> = Vec::new();/// for element in chain(&[1, 2, 3], &[4]) {///     result.push(*element);/// assert_eq!(result, vec![1, 2, 3, 4]);/// Create an iterator that clones each element from &T to T/// [`IntoIterator`] enabled version of [`Iterator::cloned`]./// use itertools::cloned;/// assert_eq!(cloned(b"abc").next(), Some(b'a'));/// Perform a fold operation over the iterable./// [`IntoIterator`] enabled version of [`Iterator::fold`]./// use itertools::fold;/// assert_eq!(fold(&[1., 2., 3.], 0., |a, &b| f32::max(a, b)), 3.);/// Test whether the predicate holds for all elements in the iterable./// [`IntoIterator`] enabled version of [`Iterator::all`]./// use itertools::all;/// assert!(all(&[1, 2, 3], |elt| *elt > 0));/// Test whether the predicate holds for any elements in the iterable./// [`IntoIterator`] enabled version of [`Iterator::any`]./// use itertools::any;/// assert!(any(&[0, -1, 2], |elt| *elt > 0));/// Return the maximum value of the iterable./// [`IntoIterator`] enabled version of [`Iterator::max`]./// use itertools::max;/// assert_eq!(max(0..10), Some(9));/// Return the minimum value of the iterable./// [`IntoIterator`] enabled version of [`Iterator::min`]./// use itertools::min;/// assert_eq!(min(0..10), Some(0));//! Free functions that create iterator adaptors or call iterator methods.//! The benefit of free functions is that they accept any [`IntoIterator`] as//! argument, so the resulting code may be easier to read.into_group_map/// Return a `HashMap` of keys mapped to a list of their corresponding values./// See [`.into_group_map()`](crate::Itertools::into_group_map)into_group_map_byKeyFunction/// A trait to unify `FnMut` for `GroupBy` with the chunk key in `IntoChunks`ChunkIndex/// `ChunkIndex` acts like the grouping key function for `IntoChunks`current_keycurrent_elt/// flag set if iterator is exhaustedtop_group/// Index of group we are currently buffering or visitingoldest_buffered_group/// Least index for which we still have elements bufferedbottom_group/// Group index for `buffer[0]` -- the slots/// bottom_group..oldest_buffered_group are unused and will be erased when/// that range is large enough./// Buffered groups, from `bottom_group` (index 0) to `top_group`.dropped_group/// index of last group iter that was dropped, usize::MAX == noneGroupInner/// `client`: Index of group that requests next elementlookup_buffernext_element/// Take the next element from the iterator, and set the done/// flag if exhausted. Must not be called after done.step_bufferingpush_next_groupstep_current/// This is the immediate case, where we use no bufferinggroup_key/// Request the just started groups' key./// `client`: Index of group/// **Panics** if no group key is available./// Called when a group is dropped// the group iterator's current index. Keep this in the main value// so that simultaneous iterators all use the same state.GroupBy/// `GroupBy` is the storage for the lazy grouping operation./// If the groups are consumed in their original order, or if each/// group is dropped without keeping it around, then `GroupBy` uses/// no allocations. It needs allocations only if several group iterators/// are alive at the same time./// This type implements [`IntoIterator`] (it is **not** an iterator/// itself), because the group iterators need to borrow from this/// value. It should be stored in a local variable or temporary and/// iterated./// See [`.group_by()`](crate::Itertools::group_by) for more information./// Create a newGroups/// An iterator that yields the Group iterators./// Iterator element type is `(K, Group)`:/// the group's key `K` and the group's iterator./// An iterator for the elements in a single group.new_chunksIntoChunks// the chunk iterator's current index. Keep this in the main value/// `ChunkLazy` is the storage for a lazy chunking operation./// `IntoChunks` behaves just like `GroupBy`: it is iterable, and/// it only buffers if several chunk iterators are alive at the same time./// itself), because the chunk iterators need to borrow from this/// Iterator element type is `Chunk`, each chunk's iterator./// See [`.chunks()`](crate::Itertools::chunks) for more information./// `client`: Index of chunk that requests next element/// `client`: Index of chunk/// An iterator that yields the Chunk iterators./// Iterator element type is `Chunk`./// An iterator for the elements in a single chunk.///// IntoChunks /////MinMaxResultMapForGrouping/// A wrapper to allow for an easy [`into_grouping_map_by`](crate::Itertools::into_grouping_map_by)GroupingMap/// Creates a new `GroupingMap` from `iter`GroupingMapBy/// `GroupingMapBy` is an intermediate struct for efficient group-and-fold operations./// See [`GroupingMap`] for more informations."GroupingMap is lazy and do nothing unless consumed"/// `GroupingMap` is an intermediate struct for efficient group-and-fold operations./// It groups elements by their key and at the same time fold each group/// using some aggregating operation./// No method on this struct performs temporary allocations.FO/// This is the generic way to perform any operation on a `GroupingMap`./// It's suggested to use this method only to implement custom operations/// when the already provided ones are not enough./// Groups elements from the `GroupingMap` source by key and applies `operation` to the elements/// of each group sequentially, passing the previously accumulated value, a reference to the key/// and the current element as arguments, and stores the results in an `HashMap`./// The `operation` function is invoked on each element with the following parameters:///  - the current value of the accumulator of the group if there is currently one;///  - a reference to the key of the group this element belongs to;///  - the element from the source being aggregated;/// If `operation` returns `Some(element)` then the accumulator is updated with `element`,/// otherwise the previous accumulation is discarded./// Return a `HashMap` associating the key of each group with the result of aggregation of/// that group's elements. If the aggregation of the last element of a group discards the/// accumulator then there won't be an entry associated to that group's key./// use itertools::Itertools;/// let data = vec![2, 8, 5, 7, 9, 0, 4, 10];/// let lookup = data.into_iter()///     .into_grouping_map_by(|&n| n % 4)///     .aggregate(|acc, _key, val| {///         if val == 0 || val == 10 {///             None///             Some(acc.unwrap_or(0) + val)/// assert_eq!(lookup[&0], 4);        // 0 resets the accumulator so only 4 is summed/// assert_eq!(lookup[&1], 5 + 9);/// assert_eq!(lookup.get(&2), None); // 10 resets the accumulator and nothing is summed afterward/// assert_eq!(lookup[&3], 7);/// assert_eq!(lookup.len(), 3);      // The final keys are only 0, 1 and 2FI/// and the current element as arguments, and stores the results in a new map./// `init` is called to obtain the initial value of each accumulator./// `operation` is a function that is invoked on each element with the following parameters:///  - the current value of the accumulator of the group;///  - the element from the source being accumulated./// Return a `HashMap` associating the key of each group with the result of folding that group's elements./// #[derive(Debug, Default)]/// struct Accumulator {///   acc: usize,/// let lookup = (1..=7)///     .into_grouping_map_by(|&n| n % 3)///     .fold_with(|_key, _val| Default::default(), |Accumulator { acc }, _key, val| {///         let acc = acc + val;///         Accumulator { acc }///      });/// assert_eq!(lookup[&0].acc, 3 + 6);/// assert_eq!(lookup[&1].acc, 1 + 4 + 7);/// assert_eq!(lookup[&2].acc, 2 + 5);/// assert_eq!(lookup.len(), 3);/// `init` is the value from which will be cloned the initial value of each accumulator.///     .fold(0, |acc, _key, val| acc + val);/// assert_eq!(lookup[&0], 3 + 6);/// assert_eq!(lookup[&1], 1 + 4 + 7);/// assert_eq!(lookup[&2], 2 + 5);fold_first/// This is similar to [`fold`] but the initial value of the accumulator is the first element of the group./// [`fold`]: GroupingMap::fold///     .fold_first(|acc, _key, val| acc + val);/// Groups elements from the `GroupingMap` source by key and collects the elements of each group in/// an instance of `C`. The iteration order is preserved when inserting elements./// Return a `HashMap` associating the key of each group with the collection containing that group's elements./// use std::collections::HashSet;/// let lookup = vec![0, 1, 2, 3, 4, 5, 6, 2, 3, 6].into_iter()///     .collect::<HashSet<_>>();/// assert_eq!(lookup[&0], vec![0, 3, 6].into_iter().collect::<HashSet<_>>());/// assert_eq!(lookup[&1], vec![1, 4].into_iter().collect::<HashSet<_>>());/// assert_eq!(lookup[&2], vec![2, 5].into_iter().collect::<HashSet<_>>());/// Groups elements from the `GroupingMap` source by key and finds the maximum of each group./// If several elements are equally maximum, the last element is picked./// Returns a `HashMap` associating the key of each group with the maximum of that group's elements./// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()///     .max();/// assert_eq!(lookup[&0], 12);/// assert_eq!(lookup[&1], 7);/// assert_eq!(lookup[&2], 8);max_by/// Groups elements from the `GroupingMap` source by key and finds the maximum of each group/// with respect to the specified comparison function.///     .max_by(|_key, x, y| y.cmp(x));/// assert_eq!(lookup[&0], 3);/// assert_eq!(lookup[&1], 1);/// assert_eq!(lookup[&2], 5);CKmax_by_key/// Groups elements from the `GroupingMap` source by key and finds the element of each group/// that gives the maximum from the specified function.///     .max_by_key(|_key, &val| val % 4);/// Groups elements from the `GroupingMap` source by key and finds the minimum of each group./// If several elements are equally minimum, the first element is picked./// Returns a `HashMap` associating the key of each group with the minimum of that group's elements.///     .min();min_by/// Groups elements from the `GroupingMap` source by key and finds the minimum of each group///     .min_by(|_key, x, y| y.cmp(x));min_by_key/// that gives the minimum from the specified function.///     .min_by_key(|_key, &val| val % 4);/// assert_eq!(lookup[&1], 4);minmax/// Groups elements from the `GroupingMap` source by key and find the maximum and minimum of/// each group./// See [.minmax()](crate::Itertools::minmax) for the non-grouping version./// Differences from the non grouping version:/// - It never produces a `MinMaxResult::NoElements`/// - It doesn't have any speedup/// Returns a `HashMap` associating the key of each group with the minimum and maximum of that group's elements./// use itertools::MinMaxResult::{OneElement, MinMax};/// let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()///     .minmax();/// assert_eq!(lookup[&0], MinMax(3, 12));/// assert_eq!(lookup[&1], MinMax(1, 7));/// assert_eq!(lookup[&2], OneElement(5));minmax_by/// each group with respect to the specified comparison function./// It has the same differences from the non-grouping version as `minmax`.///     .minmax_by(|_key, x, y| y.cmp(x));/// assert_eq!(lookup[&0], MinMax(12, 3));/// assert_eq!(lookup[&1], MinMax(7, 1));minmax_by_key/// Groups elements from the `GroupingMap` source by key and find the elements of each group/// that gives the minimum and maximum from the specified function.///     .minmax_by_key(|_key, &val| val % 4);/// assert_eq!(lookup[&1], MinMax(4, 7));/// Groups elements from the `GroupingMap` source by key and sums them./// This is just a shorthand for `self.fold_first(|acc, _, val| acc + val)`./// It is more limited than `Iterator::sum` since it doesn't use the `Sum` trait./// Returns a `HashMap` associating the key of each group with the sum of that group's elements.///     .sum();/// assert_eq!(lookup[&0], 3 + 9 + 12);/// assert_eq!(lookup[&2], 5 + 8);/// Groups elements from the `GroupingMap` source by key and multiply them./// This is just a shorthand for `self.fold_first(|acc, _, val| acc * val)`./// It is more limited than `Iterator::product` since it doesn't use the `Product` trait./// Returns a `HashMap` associating the key of each group with the product of that group's elements.///     .product();/// assert_eq!(lookup[&0], 3 * 9 * 12);/// assert_eq!(lookup[&1], 1 * 4 * 7);/// assert_eq!(lookup[&2], 5 * 8);count_ident//! Implementation's internal macrosIntersperseElementIntersperseElementSimple/// An iterator adaptor to insert a particular value/// between each element of the adapted iterator./// Iterator element type is `I::Item`/// See [`.intersperse()`](crate::Itertools::intersperse) for more information./// Create a new Intersperse iteratorElemF/// `peek` is None while no item have been taken out of `iter` (at definition)./// Then `peek` will alternatively be `Some(None)` and `Some(Some(item))`,/// where `None` indicates it's time to generate from `element` (unless `iter` is empty)./// An iterator adaptor to insert a particular value created by a function/// See [`.intersperse_with()`](crate::Itertools::intersperse_with) for more information./// Create a new `IntersperseWith` iteratork_smallestHeadTail/// Head element and Tail iterator pair/// `PartialEq`, `Eq`, `PartialOrd` and `Ord` are implemented by comparing sequences based on/// first items (which are guaranteed to exist)./// The meanings of `PartialOrd` and `Ord` are reversed so as to turn the heap used in/// `KMerge` into a min-heap./// Constructs a `HeadTail` from an `Iterator`. Returns `None` if the `Iterator` is empty./// Get the next element and update `head`, returning the old head in `Some`./// Returns `None` when the tail is exhausted (only `head` then remains)./// Hints at the size of the sequence, same as the `Iterator` method.heapify/// Make `data` a heap (min-heap w.r.t the sorting).sift_down/// Sift down element at `index` (`heap` is a min-heap wrt the ordering)KMergeKMergeByLtKMergeBy/// An iterator adaptor that merges an abitrary number of base iterators in ascending order./// If all base iterators are sorted (ascending), the result is sorted./// See [`.kmerge()`](crate::Itertools::kmerge) for more information.kmerge_predKMergePredicatekmerge/// Create an iterator that merges elements of the contained iterators using/// the ordering function./// [`IntoIterator`] enabled version of [`Itertools::kmerge`]./// use itertools::kmerge;/// for elt in kmerge(vec![vec![0, 2, 4], vec![1, 3, 5], vec![6, 7]]) {less_than/// An iterator adaptor that merges an abitrary number of base iterators/// according to an ordering function./// See [`.kmerge_by()`](crate::Itertools::kmerge_by) for morekmerge_by/// Create an iterator that merges elements of the contained iterators./// [`IntoIterator`] enabled version of [`Itertools::kmerge_by`].prefill"itertools"impl_macros__std_iter// for compatibility with no std and macroscons_tuples_implexactly_one_errMergeByMergeJoinBypad_tailPadUsingPeekingTakeWhileprocess_results_implProcessResultsrepeatnRepeatNIterateRepeatCalltake_while_inclusiveTakeWhileInclusivetuple_implCircularTupleWindowsTupleBufferTupleWindowsTuplesWithPositionZipEqzip_longestZipLongestziptuple/// The concrete iterator types.HomogeneousTuple/// Traits helpful for using certain `Itertools` methods in generic contexts.concat_implPeekingNextprocess_resultsrepeat_nrepeat_callunziptuplemultiunzipMultiUnzipmultizipeither_or_bothiproduct/// Create an iterator over the “cartesian product” of iterators./// Iterator element type is like `(A, B, ..., E)` if formed/// from iterators `(I, J, ..., M)` with element types `I::Item = A`, `J::Item = B`, etc./// # use itertools::iproduct;/// // Iterate over the coordinates of a 4 x 4 x 4 grid/// // from (0, 0, 0), (0, 0, 1), .., (0, 1, 0), (0, 1, 1), .. etc until (3, 3, 3)/// for (i, j, k) in iproduct!(0..4, 0..4, 0..4) {///    // ..izip// @closure creates a tuple-flattening closure for .map() call. usage:// @closure partial_pattern => partial_tuple , rest , of , iterators// eg. izip!( @closure ((a, b), c) => (a, b, c) , dd , ee )// The "b" identifier is a different identifier on each recursion level thanks to hygiene.// unary// binary// n-ary where n > 2/// Create an iterator running multiple iterators in lockstep./// The `izip!` iterator yields elements until any subiterator/// returns `None`./// This is a version of the standard ``.zip()`` that's supporting more than/// two iterators. The iterator element type is a tuple with one element/// from each of the input iterators. Just like ``.zip()``, the iteration stops/// when the shortest of the inputs reaches its end./// **Note:** The result of this macro is in the general case an iterator/// composed of repeated `.zip()` and a `.map()`; it has an anonymous type./// The special cases of one and two arguments produce the equivalent of/// `$a.into_iter()` and `$a.into_iter().zip($b)` respectively./// Prefer this macro `izip!()` over [`multizip`] for the performance benefits/// of using the standard library `.zip()`./// # use itertools::izip;/// // iterate over three sequences side-by-side/// let mut results = [0, 0, 0, 0];/// let inputs = [3, 7, 9, 6];/// for (r, index, input) in izip!(&mut results, 0..10, &inputs) {///     *r = index * 10 + input;/// assert_eq!(results, [0 + 3, 10 + 7, 29, 36]);/// [Chain][`chain`] zero or more iterators together into one sequence./// The comma-separated arguments must implement [`IntoIterator`]./// The final argument may be followed by a trailing comma./// [`chain`]: Iterator::chain/// Empty invocations of `chain!` expand to an invocation of [`std::iter::empty`]:/// use std::iter;/// let _: iter::Empty<()> = chain!();/// let _: iter::Empty<i8> = chain!();/// Invocations of `chain!` with one argument expand to [`arg.into_iter()`](IntoIterator):/// use std::{ops::Range, slice};/// let _: <Range<_> as IntoIterator>::IntoIter = chain!((2..6),); // trailing comma optional!/// let _:     <&[_] as IntoIterator>::IntoIter = chain!(&[2, 3, 4]);/// Invocations of `chain!` with multiple arguments [`.into_iter()`](IntoIterator) each/// argument, and then [`chain`] them together:/// use std::{iter::*, ops::Range, slice};/// use itertools::{assert_equal, chain};/// // e.g., this:/// let with_macro:  Chain<Chain<Once<_>, Take<Repeat<_>>>, slice::Iter<_>> =///     chain![once(&0), repeat(&1).take(2), &[2, 3, 5],];/// // ...is equivalent to this:/// let with_method: Chain<Chain<Once<_>, Take<Repeat<_>>>, slice::Iter<_>> =///     once(&0)///         .chain(repeat(&1).take(2))///         .chain(&[2, 3, 5]);/// assert_equal(with_macro, with_method);/// Alternate elements from two iterators until both have run out./// Iterator element type is `Self::Item`./// let it = (1..7).interleave(vec![-1, -2]);/// itertools::assert_equal(it, vec![1, -1, 2, -2, 3, 4, 5, 6]);/// Alternate elements from two iterators until at least one of them has run/// out./// let it = (1..7).interleave_shortest(vec![-1, -2]);/// itertools::assert_equal(it, vec![1, -1, 2, -2, 3]);/// itertools::assert_equal((0..3).intersperse(8), vec![0, 8, 1, 8, 2]);/// itertools::assert_equal((0..3).intersperse_with(|| { i -= 1; i }), vec![0, 9, 1, 8, 2]);/// Create an iterator which iterates over both this and the specified/// iterator simultaneously, yielding pairs of two optional elements./// As long as neither input iterator is exhausted yet, it yields two values/// via `EitherOrBoth::Both`./// When the parameter iterator is exhausted, it only yields a value from the/// `self` iterator via `EitherOrBoth::Left`./// When the `self` iterator is exhausted, it only yields a value from the/// parameter iterator via `EitherOrBoth::Right`./// When both iterators return `None`, all further invocations of `.next()`/// will return `None`./// Iterator element type is/// [`EitherOrBoth<Self::Item, J::Item>`](EitherOrBoth)./// use itertools::EitherOrBoth::{Both, Right};/// let it = (0..1).zip_longest(1..3);/// itertools::assert_equal(it, vec![Both(0, 1), Right(2)]);/// iterator simultaneously, yielding pairs of elements./// **Panics** if the iterators reach an end and they are not of equal/// A “meta iterator adaptor”. Its closure receives a reference to the/// iterator and may pick off as many elements as it likes, to produce the/// next iterator element./// Iterator element type is `B`./// // An adaptor that gathers elements in pairs/// let pit = (0..4).batching(|it| {///            match it.next() {///                None => None,///                Some(x) => match it.next() {///                    None => None,///                    Some(y) => Some((x, y)),///                }///            }///        });/// itertools::assert_equal(pit, vec![(0, 1), (2, 3)]);tuple_windows/// Return an iterator over all contiguous windows producing tuples of/// a specific size (up to 12)./// `tuple_windows` clones the iterator elements so that they can be/// part of successive windows, this makes it most suited for iterators/// of references and other values that are cheap to copy./// let mut v = Vec::new();/// // pairwise iteration/// for (a, b) in (1..5).tuple_windows() {///     v.push((a, b));/// assert_eq!(v, vec![(1, 2), (2, 3), (3, 4)]);/// let mut it = (1..5).tuple_windows();/// assert_eq!(Some((1, 2, 3)), it.next());/// assert_eq!(Some((2, 3, 4)), it.next());/// assert_eq!(None, it.next());/// // this requires a type hint/// let it = (1..5).tuple_windows::<(_, _, _)>();/// itertools::assert_equal(it, vec![(1, 2, 3), (2, 3, 4)]);/// // you can also specify the complete type/// use itertools::TupleWindows;/// let it: TupleWindows<Range<u32>, (u32, u32, u32)> = (1..5).tuple_windows();circular_tuple_windowsTupleCollect/// Return an iterator over all windows, wrapping back to the first/// elements when the window would otherwise exceed the length of the/// iterator, producing tuples of a specific size (up to 12)./// `circular_tuple_windows` clones the iterator elements so that they can be/// for (a, b) in (1..5).circular_tuple_windows() {/// assert_eq!(v, vec![(1, 2), (2, 3), (3, 4), (4, 1)]);/// let mut it = (1..5).circular_tuple_windows();/// assert_eq!(Some((3, 4, 1)), it.next());/// assert_eq!(Some((4, 1, 2)), it.next());/// let it = (1..5).circular_tuple_windows::<(_, _, _)>();/// itertools::assert_equal(it, vec![(1, 2, 3), (2, 3, 4), (3, 4, 1), (4, 1, 2)]);/// Return an iterator that groups the items in tuples of a specific size/// (up to 12)./// See also the method [`.next_tuple()`](Itertools::next_tuple)./// for (a, b) in (1..5).tuples() {/// assert_eq!(v, vec![(1, 2), (3, 4)]);/// let mut it = (1..7).tuples();/// assert_eq!(Some((4, 5, 6)), it.next());/// let it = (1..7).tuples::<(_, _, _)>();/// itertools::assert_equal(it, vec![(1, 2, 3), (4, 5, 6)]);/// use itertools::Tuples;/// let it: Tuples<Range<u32>, (u32, u32, u32)> = (1..7).tuples();/// See also [`Tuples::into_buffer`]./// Return an iterator adaptor that steps `n` elements in the base iterator/// then skipping forward `n - 1` elements./// let it = (0..8).step(3);/// itertools::assert_equal(it, vec![0, 3, 6]);/// Convert each item of the iterator using the [`Into`] trait./// (1i32..42i32).map_into::<f64>().collect_vec();map_results/// See [`.map_ok()`](Itertools::map_ok)./// Return an iterator adaptor that applies the provided closure/// to every `Result::Ok` value. `Result::Err` values are/// let input = vec![Ok(41), Err(false), Ok(11)];/// let it = input.into_iter().map_ok(|i| i + 1);/// itertools::assert_equal(it, vec![Ok(42), Err(false), Ok(12)]);/// Return an iterator adaptor that filters every `Result::Ok`/// value with the provided closure. `Result::Err` values are/// let input = vec![Ok(22), Err(false), Ok(11)];/// let it = input.into_iter().filter_ok(|&i| i > 20);/// itertools::assert_equal(it, vec![Ok(22), Err(false)]);/// Return an iterator adaptor that filters and transforms every/// `Result::Ok` value with the provided closure. `Result::Err`/// values are unchanged./// let it = input.into_iter().filter_map_ok(|i| if i > 20 { Some(i * 2) } else { None });/// itertools::assert_equal(it, vec![Ok(44), Err(false)]);/// Return an iterator adaptor that flattens every `Result::Ok` value into/// a series of `Result::Ok` values. `Result::Err` values are unchanged./// This is useful when you have some common error type for your crate and/// need to propagate it upwards, but the `Result::Ok` case needs to be flattened./// let input = vec![Ok(0..2), Err(false), Ok(2..4)];/// let it = input.iter().cloned().flatten_ok();/// itertools::assert_equal(it.clone(), vec![Ok(0), Ok(1), Err(false), Ok(2), Ok(3)]);/// // This can also be used to propagate errors when collecting./// let output_result: Result<Vec<i32>, bool> = it.collect();/// assert_eq!(output_result, Err(false));/// “Lift” a function of the values of the current iterator so as to process/// an iterator of `Result` values instead./// `processor` is a closure that receives an adapted version of the iterator/// as the only argument — the adapted iterator produces elements of type `T`,/// as long as the original iterator produces `Ok` values./// If the original iterable produces an error at any point, the adapted/// iterator ends and it will return the error iself./// Otherwise, the return value from the closure is returned wrapped/// inside `Ok`./// type Item = Result<i32, &'static str>;/// let first_values: Vec<Item> = vec![Ok(1), Ok(0), Ok(3)];/// let second_values: Vec<Item> = vec![Ok(2), Ok(1), Err("overflow")];/// // “Lift” the iterator .max() method to work on the Ok-values./// let first_max = first_values.into_iter().process_results(|iter| iter.max().unwrap_or(0));/// let second_max = second_values.into_iter().process_results(|iter| iter.max().unwrap_or(0));/// assert_eq!(first_max, Ok(3));/// assert!(second_max.is_err());/// Return an iterator adaptor that merges the two base iterators in/// ascending order.  If both base iterators are sorted (ascending), the/// result is sorted./// let a = (0..11).step_by(3);/// let b = (0..11).step_by(5);/// let it = a.merge(b);/// itertools::assert_equal(it, vec![0, 0, 3, 5, 6, 9, 10]);merge_by/// Return an iterator adaptor that merges the two base iterators in order./// This is much like [`.merge()`](Itertools::merge) but allows for a custom ordering./// This can be especially useful for sequences of tuples./// let a = (0..).zip("bc".chars());/// let b = (0..).zip("ad".chars());/// let it = a.merge_by(b, |x, y| x.1 <= y.1);/// itertools::assert_equal(it, vec![(0, 'a'), (0, 'b'), (1, 'c'), (1, 'd')]);/// Create an iterator that merges items from both this and the specified/// iterator in ascending order./// The function can either return an `Ordering` variant or a boolean./// If `cmp_fn` returns `Ordering`,/// it chooses whether to pair elements based on the `Ordering` returned by the/// specified compare function. At any point, inspecting the tip of the/// iterators `I` and `J` as items `i` of type `I::Item` and `j` of type/// `J::Item` respectively, the resulting iterator will:/// - Emit `EitherOrBoth::Left(i)` when `i < j`,///   and remove `i` from its source iterator/// - Emit `EitherOrBoth::Right(j)` when `i > j`,///   and remove `j` from its source iterator/// - Emit `EitherOrBoth::Both(i, j)` when  `i == j`,///   and remove both `i` and `j` from their respective source iterators/// use itertools::EitherOrBoth::{Left, Right, Both};/// let a = vec![0, 2, 4, 6, 1].into_iter();/// let b = (0..10).step_by(3);/// itertools::assert_equal(///     a.merge_join_by(b, |i, j| i.cmp(j)),///     vec![Both(0, 0), Left(2), Right(3), Left(4), Both(6, 6), Left(1), Right(9)]/// If `cmp_fn` returns `bool`,/// it chooses whether to pair elements based on the boolean returned by the/// specified function. At any point, inspecting the tip of the/// - Emit `Either::Left(i)` when `true`,/// - Emit `Either::Right(j)` when `false`,/// It is similar to the `Ordering` case if the first argument is considered/// "less" than the second argument./// use itertools::Either::{Left, Right};///     a.merge_join_by(b, |i, j| i <= j),///     vec![Left(0), Right(0), Left(2), Right(3), Left(4), Left(6), Left(1), Right(6), Right(9)]/// Return an iterator adaptor that iterates over the cartesian product of/// the element sets of two iterators `self` and `J`./// Iterator element type is `(Self::Item, J::Item)`./// let it = (0..2).cartesian_product("αβ".chars());/// itertools::assert_equal(it, vec![(0, 'α'), (0, 'β'), (1, 'α'), (1, 'β')]);/// Return an iterator adaptor that uses the passed-in closure to/// optionally merge together consecutive elements./// The closure `f` is passed two elements, `previous` and `current` and may/// return either (1) `Ok(combined)` to merge the two values or/// (2) `Err((previous', current'))` to indicate they can't be merged./// In (2), the value `previous'` is emitted by the iterator./// Either (1) `combined` or (2) `current'` becomes the previous value/// when coalesce continues with the next pair of elements to merge. The/// value that remains at the end is also emitted by the iterator./// // sum same-sign runs together/// let data = vec![-1., -2., -3., 3., 1., 0., -1.];/// itertools::assert_equal(data.into_iter().coalesce(|x, y|///         if (x >= 0.) == (y >= 0.) {///             Ok(x + y)///             Err((x, y))///         }),///         vec![-6., 4., -1.]);/// Remove duplicates from sections of consecutive identical elements./// If the iterator is sorted, all elements will be unique./// let data = vec![1., 1., 2., 3., 3., 2., 2.];/// itertools::assert_equal(data.into_iter().dedup(),///                         vec![1., 2., 3., 2.]);/// Remove duplicates from sections of consecutive identical elements,/// determining equality using a comparison function./// let data = vec![(0, 1.), (1, 1.), (0, 2.), (0, 3.), (1, 3.), (1, 2.), (2, 2.)];/// itertools::assert_equal(data.into_iter().dedup_by(|x, y| x.1 == y.1),///                         vec![(0, 1.), (0, 2.), (0, 3.), (1, 2.)]);/// Remove duplicates from sections of consecutive identical elements, while keeping a count of/// how many repeated elements were present./// Iterator element type is `(usize, Self::Item)`./// let data = vec!['a', 'a', 'b', 'c', 'c', 'b', 'b'];/// itertools::assert_equal(data.into_iter().dedup_with_count(),///                         vec![(2, 'a'), (1, 'b'), (2, 'c'), (2, 'b')]);/// This will determine equality using a comparison function./// let data = vec![(0, 'a'), (1, 'a'), (0, 'b'), (0, 'c'), (1, 'c'), (1, 'b'), (2, 'b')];/// itertools::assert_equal(data.into_iter().dedup_by_with_count(|x, y| x.1 == y.1),///                         vec![(2, (0, 'a')), (1, (0, 'b')), (2, (0, 'c')), (2, (1, 'b'))]);/// Return an iterator adaptor that borrows from this iterator and/// takes items while the closure `accept` returns `true`./// This adaptor can only be used on iterators that implement `PeekingNext`/// like `.peekable()`, `put_back` and a few other collection iterators./// The last and rejected element (first `false`) is still available when/// `peeking_take_while` is done./// See also [`.take_while_ref()`](Itertools::take_while_ref)/// which is a similar adaptor./// Return an iterator adaptor that borrows from a `Clone`-able iterator/// to only pick off elements while the predicate `accept` returns `true`./// It uses the `Clone` trait to restore the original iterator so that the/// last and rejected element (first `false`) is still available when/// `take_while_ref` is done./// let mut hexadecimals = "0123456789abcdef".chars();/// let decimals = hexadecimals.take_while_ref(|c| c.is_numeric())///                            .collect::<String>();/// assert_eq!(decimals, "0123456789");/// assert_eq!(hexadecimals.next(), Some('a'));/// Returns an iterator adaptor that consumes elements while the given/// predicate is `true`, *including* the element for which the predicate/// first returned `false`./// The [`.take_while()`][std::iter::Iterator::take_while] adaptor is useful/// when you want items satisfying a predicate, but to know when to stop/// taking elements, we have to consume that first element that doesn't/// satisfy the predicate. This adaptor includes that element where/// [`.take_while()`][std::iter::Iterator::take_while] would drop it./// The [`.take_while_ref()`][crate::Itertools::take_while_ref] adaptor/// serves a similar purpose, but this adaptor doesn't require [`Clone`]ing/// the underlying elements./// # use itertools::Itertools;/// let items = vec![1, 2, 3, 4, 5];/// let filtered: Vec<_> = items///     .take_while_inclusive(|&n| n % 3 != 0)/// assert_eq!(filtered, vec![1, 2, 3]);/// let take_while_inclusive_result: Vec<_> = items/// let take_while_result: Vec<_> = items///     .take_while(|&n| n % 3 != 0)/// assert_eq!(take_while_inclusive_result, vec![1, 2, 3]);/// assert_eq!(take_while_result, vec![1, 2]);/// // both iterators have the same items remaining at this point---the 3/// // is lost from the `take_while` vec/// #[derive(Debug, PartialEq)]/// struct NoCloneImpl(i32);/// let non_clonable_items: Vec<_> = vec![1, 2, 3, 4, 5]///     .map(NoCloneImpl)/// let filtered: Vec<_> = non_clonable_items///     .take_while_inclusive(|n| n.0 % 3 != 0)/// let expected: Vec<_> = vec![1, 2, 3].into_iter().map(NoCloneImpl).collect();/// assert_eq!(filtered, expected);/// Return an iterator adaptor that filters `Option<A>` iterator elements/// Iterator element type is `A`, the unwrapped element./// // List all hexadecimal digits///     (0..).map(|i| std::char::from_digit(i, 16)).while_some(),///     "0123456789abcdef".chars());/// Return an iterator adaptor that iterates over the combinations of the/// elements from an iterator./// Iterator element can be any homogeneous tuple of type `Self::Item` with/// size up to 12./// for (a, b) in (1..5).tuple_combinations() {/// assert_eq!(v, vec![(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]);/// let mut it = (1..5).tuple_combinations();/// assert_eq!(Some((1, 2, 4)), it.next());/// assert_eq!(Some((1, 3, 4)), it.next());/// let it = (1..5).tuple_combinations::<(_, _, _)>();/// itertools::assert_equal(it, vec![(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]);/// use itertools::TupleCombinations;/// let it: TupleCombinations<Range<u32>, (u32, u32, u32)> = (1..5).tuple_combinations();/// If the adapted iterator is deterministic,/// this iterator adapter yields items in a reliable order.pad_using/// Return an iterator adaptor that pads the sequence to a minimum length of/// `min` by filling missing elements using a closure `f`./// let it = (0..5).pad_using(10, |i| 2*i);/// itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 10, 12, 14, 16, 18]);/// let it = (0..10).pad_using(5, |i| 2*i);/// itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);/// let it = (0..5).pad_using(10, |i| 2*i).rev();/// itertools::assert_equal(it, vec![18, 16, 14, 12, 10, 4, 3, 2, 1, 0]);/// Return an iterator adaptor that combines each element with a `Position` to/// ease special-case handling of the first or last elements./// [`(Position, Self::Item)`](Position)/// use itertools::{Itertools, Position};/// let it = (0..4).with_position();/// itertools::assert_equal(it,///                         vec![(Position::First, 0),///                              (Position::Middle, 1),///                              (Position::Middle, 2),///                              (Position::Last, 3)]);/// let it = (0..1).with_position();/// itertools::assert_equal(it, vec![(Position::Only, 0)]);/// Return an iterator adaptor that yields the indices of all elements/// satisfying a predicate, counted from the start of the iterator./// Equivalent to `iter.enumerate().filter(|(_, v)| predicate(*v)).map(|(i, _)| i)`./// let data = vec![1, 2, 3, 3, 4, 6, 7, 9];/// itertools::assert_equal(data.iter().positions(|v| v % 2 == 0), vec![1, 4, 5]);/// itertools::assert_equal(data.iter().positions(|v| v % 2 == 1).rev(), vec![7, 6, 3, 2, 0]);/// Return an iterator adaptor that applies a mutating function/// to each element before yielding it./// let input = vec![vec![1], vec![3, 2, 1]];/// let it = input.into_iter().update(|mut v| v.push(0));/// itertools::assert_equal(it, vec![vec![1, 0], vec![3, 2, 1, 0]]);next_tuple// non-adaptor methods/// Advances the iterator and returns the next items grouped in a tuple of/// If there are enough elements to be grouped in a tuple, then the tuple is/// returned inside `Some`, otherwise `None` is returned./// let mut iter = 1..5;/// assert_eq!(Some((1, 2)), iter.next_tuple());collect_tuple/// Collects all items from the iterator into a tuple of a specific size/// If the number of elements inside the iterator is **exactly** equal to/// the tuple size, then the tuple is returned inside `Some`, otherwise/// let iter = 1..3;/// if let Some((x, y)) = iter.collect_tuple() {///     assert_eq!((x, y), (1, 2))///     panic!("Expected two elements")find_position/// Find the position and value of the first element satisfying a predicate./// The iterator is not advanced past the first element found./// let text = "Hα";/// assert_eq!(text.chars().find_position(|ch| ch.is_lowercase()), Some((1, 'α')));find_or_last/// Find the value of the first element satisfying a predicate or return the last element, if any./// let numbers = [1, 2, 3, 4];/// assert_eq!(numbers.iter().find_or_last(|&&x| x > 5), Some(&4));/// assert_eq!(numbers.iter().find_or_last(|&&x| x > 2), Some(&3));/// assert_eq!(std::iter::empty::<i32>().find_or_last(|&x| x > 5), None);find_or_first/// Find the value of the first element satisfying a predicate or return the first element, if any./// assert_eq!(numbers.iter().find_or_first(|&&x| x > 5), Some(&1));/// assert_eq!(numbers.iter().find_or_first(|&&x| x > 2), Some(&3));/// assert_eq!(std::iter::empty::<i32>().find_or_first(|&x| x > 5), None);/// Returns `true` if the given item is present in this iterator./// This method is short-circuiting. If the given item is present in this/// iterator, this method will consume the iterator up-to-and-including/// the item. If the given item is not present in this iterator, the/// iterator will be exhausted./// enum Enum { A, B, C, D, E, }/// let mut iter = vec![Enum::A, Enum::B, Enum::C, Enum::D].into_iter();/// // search `iter` for `B`/// assert_eq!(iter.contains(&Enum::B), true);/// // `B` was found, so the iterator now rests at the item after `B` (i.e, `C`)./// assert_eq!(iter.next(), Some(Enum::C));/// // search `iter` for `E`/// assert_eq!(iter.contains(&Enum::E), false);/// // `E` wasn't found, so `iter` is now exhaustedall_equal/// Check whether all elements compare equal./// Empty iterators are considered to have equal elements:/// let data = vec![1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5];/// assert!(!data.iter().all_equal());/// assert!(data[0..3].iter().all_equal());/// assert!(data[3..5].iter().all_equal());/// assert!(data[5..8].iter().all_equal());/// let data : Option<usize> = None;/// assert!(data.into_iter().all_equal());all_equal_value/// If there are elements and they are all equal, return a single copy of that element./// If there are no elements, return an Error containing None./// If there are elements and they are not all equal, return a tuple containing the first/// two non-equal elements found./// assert_eq!(data.iter().all_equal_value(), Err(Some((&1, &2))));/// assert_eq!(data[0..3].iter().all_equal_value(), Ok(&1));/// assert_eq!(data[3..5].iter().all_equal_value(), Ok(&2));/// assert_eq!(data[5..8].iter().all_equal_value(), Ok(&3));/// assert_eq!(data.into_iter().all_equal_value(), Err(None));dropping/// Consume the first `n` elements from the iterator eagerly,/// and return the same iterator again./// It works similarly to *.skip(* `n` *)* except it is eager and/// preserves the iterator type./// let mut iter = "αβγ".chars().dropping(2);/// itertools::assert_equal(iter, "γ".chars());/// *Fusing notes: if the iterator is exhausted by dropping,/// the result of calling `.next()` again depends on the iterator implementation.*dropping_back/// Consume the last `n` elements from the iterator eagerly,/// This is only possible on double ended iterators. `n` may be/// larger than the number of elements./// Note: This method is eager, dropping the back elements immediately and/// let init = vec![0, 3, 6, 9].into_iter().dropping_back(1);/// itertools::assert_equal(init, vec![0, 3, 6]);/// Run the closure `f` eagerly on each element of the iterator./// Consumes the iterator until its end./// use std::sync::mpsc::channel;/// let (tx, rx) = channel();/// // use .foreach() to apply a function to each value -- sending it/// (0..5).map(|x| x * 2 + 1).foreach(|x| { tx.send(x).unwrap(); } );/// itertools::assert_equal(rx.iter(), vec![1, 3, 5, 7, 9]);/// assert_eq!(input.into_iter().concat(),///            vec![1, 2, 3, 4, 5, 6]);/// `.try_collect()` is more convenient way of writing/// `.collect::<Result<_, _>>()`/// use std::{fs, io};/// fn process_dir_entries(entries: &[fs::DirEntry]) {/// fn do_stuff() -> std::io::Result<()> {///     let entries: Vec<_> = fs::read_dir(".")?.try_collect()?;///     process_dir_entries(&entries);set_from/// Assign to each reference in `self` from the `from` iterator,/// stopping at the shortest of the two iterators./// The `from` iterator is queried for its next element before the `self`/// iterator, and if either is exhausted the method is done./// Return the number of elements written./// let mut xs = [0; 4];/// xs.iter_mut().set_from(1..);/// assert_eq!(xs, [1, 2, 3, 4]);/// Format all iterator elements, separated by `sep`./// All elements are formatted (any formatting trait)/// with `sep` inserted between each element./// **Panics** if the formatter helper is formatted more than once./// let data = [1.1, 2.71828, -3.];///     format!("{:.2}", data.iter().format(", ")),///            "1.10, 2.72, -3.00");/// This is a customizable version of [`.format()`](Itertools::format)./// The supplied closure `format` is called once per iterator element,/// with two arguments: the element and a callback that takes a/// `&Display` value, i.e. any reference to type that implements `Display`./// Using `&format_args!(...)` is the most versatile way to apply custom/// element formatting. The callback can be called multiple times if needed./// let data_formatter = data.iter().format_with(", ", |elt, f| f(&format_args!("{:.2}", elt)));/// assert_eq!(format!("{}", data_formatter),/// // .format_with() is recursively composable/// let matrix = [[1., 2., 3.],///               [4., 5., 6.]];/// let matrix_formatter = matrix.iter().format_with("\n", |row, f| {///                                 f(&row.iter().format_with(", ", |elt, g| g(&elt)))///                              });/// assert_eq!(format!("{}", matrix_formatter),///            "1, 2, 3\n4, 5, 6");fold_results/// See [`.fold_ok()`](Itertools::fold_ok).fold_ok/// Fold `Result` values from an iterator./// Only `Ok` values are folded. If no error is encountered, the folded/// value is returned inside `Ok`. Otherwise, the operation terminates/// and returns the first `Err` value it encounters. No iterator elements are/// consumed after the first error./// The first accumulator value is the `start` parameter./// Each iteration passes the accumulator value and the next value inside `Ok`/// to the fold function `f` and its return value becomes the new accumulator value./// For example the sequence *Ok(1), Ok(2), Ok(3)* will result in a/// computation like this:/// # let start = 0;/// # let f = |x, y| x + y;/// let mut accum = start;/// accum = f(accum, 1);/// accum = f(accum, 2);/// accum = f(accum, 3);/// With a `start` value of 0 and an addition as folding function,/// this effectively results in *((0 + 1) + 2) + 3*/// use std::ops::Add;/// let values = [1, 2, -2, -1, 2, 1];///     values.iter()///           .map(Ok::<_, ()>)///           .fold_ok(0, Add::add),///     Ok(3)///           .map(|&x| if x >= 0 { Ok(x) } else { Err("Negative number") })///           .fold_ok(0, Add::add)///           .is_err()fold_options/// Fold `Option` values from an iterator./// Only `Some` values are folded. If no `None` is encountered, the folded/// value is returned inside `Some`. Otherwise, the operation terminates/// and returns `None`. No iterator elements are consumed after the `None`./// This is the `Option` equivalent to [`fold_ok`](Itertools::fold_ok)./// let mut values = vec![Some(1), Some(2), Some(-2)].into_iter();/// assert_eq!(values.fold_options(5, Add::add), Some(5 + 1 + 2 - 2));/// let mut more_values = vec![Some(2), None, Some(0)].into_iter();/// assert!(more_values.fold_options(0, Add::add).is_none());/// assert_eq!(more_values.next().unwrap(), Some(0));fold1/// Accumulator of the elements in the iterator./// Like `.fold()`, without a base case. If the iterator is/// empty, return `None`. With just one element, return it./// Otherwise elements are accumulated in sequence using the closure `f`./// assert_eq!((0..10).fold1(|x, y| x + y).unwrap_or(0), 45);/// assert_eq!((0..0).fold1(|x, y| x * y), None);tree_fold1/// Accumulate the elements in the iterator in a tree-like manner./// You can think of it as, while there's more than one item, repeatedly/// combining adjacent items.  It does so in bottom-up-merge-sort order,/// however, so that it needs only logarithmic stack space./// This produces a call tree like the following (where the calls under/// an item are done after reading that item):/// 1 2 3 4 5 6 7/// │ │ │ │ │ │ │/// └─f └─f └─f │///   │   │   │ │///   └───f   └─f///       │     │///       └─────f/// Which, for non-associative functions, will typically produce a different/// result than the linear call tree used by [`Iterator::reduce`]:/// └─f─f─f─f─f─f/// If `f` is associative you should also decide carefully:/// - if `f` is a trivial operation like `u32::wrapping_add`, prefer the normal/// [`Iterator::reduce`] instead since it will most likely result in the generation of simpler/// code because the compiler is able to optimize it/// - otherwise if `f` is non-trivial like `format!`, you should use `tree_fold1` since it/// reduces the number of operations from `O(n)` to `O(ln(n))`/// Here "non-trivial" means:/// - any allocating operation/// - any function that is a composition of many operations/// // The same tree as above/// let num_strings = (1..8).map(|x| x.to_string());/// assert_eq!(num_strings.tree_fold1(|x, y| format!("f({}, {})", x, y)),///     Some(String::from("f(f(f(1, 2), f(3, 4)), f(f(5, 6), 7))")));/// // Like fold1, an empty iterator produces None/// assert_eq!((0..0).tree_fold1(|x, y| x * y), None);/// // tree_fold1 matches fold1 for associative operations.../// assert_eq!((0..10).tree_fold1(|x, y| x + y),///     (0..10).fold1(|x, y| x + y));/// // ...but not for non-associative ones/// assert_ne!((0..10).tree_fold1(|x, y| x - y),///     (0..10).fold1(|x, y| x - y));fold_whileFoldWhile/// An iterator method that applies a function, producing a single, final value./// `fold_while()` is basically equivalent to [`Iterator::fold`] but with additional support for/// early exit via short-circuiting./// use itertools::FoldWhile::{Continue, Done};/// let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];/// let mut result = 0;/// // for loop:/// for i in &numbers {///     if *i > 5 {///     result = result + i;/// // fold:/// let result2 = numbers.iter().fold(0, |acc, x| {///     if *x > 5 { acc } else { acc + x }/// // fold_while:/// let result3 = numbers.iter().fold_while(0, |acc, x| {///     if *x > 5 { Done(acc) } else { Continue(acc + x) }/// }).into_inner();/// // they're the same/// assert_eq!(result, result2);/// assert_eq!(result2, result3);/// The big difference between the computations of `result2` and `result3` is that while/// `fold()` called the provided closure for every item of the callee iterator,/// `fold_while()` actually stopped iterating as soon as it encountered `Fold::Done(_)`.sum1/// Iterate over the entire iterator and add all the elements./// An empty iterator returns `None`, otherwise `Some(sum)`./// When calling `sum1()` and a primitive integer type is being returned, this/// method will panic if the computation overflows and debug assertions are/// let empty_sum = (1..1).sum1::<i32>();/// assert_eq!(empty_sum, None);/// let nonempty_sum = (1..11).sum1::<i32>();/// assert_eq!(nonempty_sum, Some(55));product1/// Iterate over the entire iterator and multiply all the elements./// An empty iterator returns `None`, otherwise `Some(product)`./// When calling `product1()` and a primitive integer type is being returned,/// let empty_product = (1..1).product1::<i32>();/// assert_eq!(empty_product, None);/// let nonempty_product = (1..11).product1::<i32>();/// assert_eq!(nonempty_product, Some(3628800));partition_map/// Collect all iterator elements into one of two/// partitions. Unlike [`Iterator::partition`], each partition may/// have a distinct type./// use itertools::{Itertools, Either};/// let successes_and_failures = vec![Ok(1), Err(false), Err(true), Ok(2)];/// let (successes, failures): (Vec<_>, Vec<_>) = successes_and_failures///     .partition_map(|r| {///         match r {///             Ok(v) => Either::Left(v),///             Err(v) => Either::Right(v),/// assert_eq!(successes, [1, 2]);/// assert_eq!(failures, [false, true]);partition_result/// Partition a sequence of `Result`s into one list of all the `Ok` elements/// and another list of all the `Err` elements.///     .partition_result();/// Return the minimum and maximum elements in the iterator./// The return type `MinMaxResult` is an enum of three variants:/// - `NoElements` if the iterator is empty./// - `OneElement(x)` if the iterator has exactly one element./// - `MinMax(x, y)` is returned otherwise, where `x <= y`. Two///    values are equal if and only if there is more than one///    element in the iterator and all elements are equal./// On an iterator of length `n`, `minmax` does `1.5 * n` comparisons,/// and so is faster than calling `min` and `max` separately which does/// `2 * n` comparisons./// use itertools::MinMaxResult::{NoElements, OneElement, MinMax};/// let a: [i32; 0] = [];/// assert_eq!(a.iter().minmax(), NoElements);/// let a = [1];/// assert_eq!(a.iter().minmax(), OneElement(&1));/// let a = [1, 2, 3, 4, 5];/// assert_eq!(a.iter().minmax(), MinMax(&1, &5));/// let a = [1, 1, 1, 1];/// assert_eq!(a.iter().minmax(), MinMax(&1, &1));/// The elements can be floats but no particular result is guaranteed/// if an element is NaN./// Return the minimum and maximum element of an iterator, as determined by/// the specified function./// The return value is a variant of [`MinMaxResult`] like for [`.minmax()`](Itertools::minmax)./// For the minimum, the first minimal element is returned.  For the maximum,/// the last maximal element wins.  This matches the behavior of the standard/// [`Iterator::min`] and [`Iterator::max`] methods./// The keys can be floats but no particular result is guaranteed/// if a key is NaN./// the specified comparison function.position_max/// Return the position of the maximum element in the iterator./// If several elements are equally maximum, the position of the/// last of them is returned./// assert_eq!(a.iter().position_max(), None);/// let a = [-3, 0, 1, 5, -10];/// assert_eq!(a.iter().position_max(), Some(3));/// let a = [1, 1, -1, -1];/// assert_eq!(a.iter().position_max(), Some(1));position_max_by_key/// Return the position of the maximum element in the iterator, as/// determined by the specified function./// assert_eq!(a.iter().position_max_by_key(|x| x.abs()), None);/// let a = [-3_i32, 0, 1, 5, -10];/// assert_eq!(a.iter().position_max_by_key(|x| x.abs()), Some(4));/// let a = [1_i32, 1, -1, -1];/// assert_eq!(a.iter().position_max_by_key(|x| x.abs()), Some(3));position_max_by/// determined by the specified comparison function./// assert_eq!(a.iter().position_max_by(|x, y| x.cmp(y)), None);/// assert_eq!(a.iter().position_max_by(|x, y| x.cmp(y)), Some(3));/// assert_eq!(a.iter().position_max_by(|x, y| x.cmp(y)), Some(1));position_min/// Return the position of the minimum element in the iterator./// If several elements are equally minimum, the position of the/// first of them is returned./// assert_eq!(a.iter().position_min(), None);/// assert_eq!(a.iter().position_min(), Some(4));/// assert_eq!(a.iter().position_min(), Some(2));position_min_by_key/// Return the position of the minimum element in the iterator, as/// assert_eq!(a.iter().position_min_by_key(|x| x.abs()), None);/// assert_eq!(a.iter().position_min_by_key(|x| x.abs()), Some(1));/// assert_eq!(a.iter().position_min_by_key(|x| x.abs()), Some(0));position_min_by/// assert_eq!(a.iter().position_min_by(|x, y| x.cmp(y)), None);/// assert_eq!(a.iter().position_min_by(|x, y| x.cmp(y)), Some(4));/// assert_eq!(a.iter().position_min_by(|x, y| x.cmp(y)), Some(2));position_minmax/// Return the positions of the minimum and maximum elements in/// The return type [`MinMaxResult`] is an enum of three variants:/// - `OneElement(xpos)` if the iterator has exactly one element./// - `MinMax(xpos, ypos)` is returned otherwise, where the///    element at `xpos` ≤ the element at `ypos`. While the///    referenced elements themselves may be equal, `xpos` cannot///    be equal to `ypos`./// On an iterator of length `n`, `position_minmax` does `1.5 * n`/// comparisons, and so is faster than calling `position_min` and/// `position_max` separately which does `2 * n` comparisons./// For the minimum, if several elements are equally minimum, the/// position of the first of them is returned. For the maximum, if/// several elements are equally maximum, the position of the last/// of them is returned./// The elements can be floats but no particular result is/// guaranteed if an element is NaN./// assert_eq!(a.iter().position_minmax(), NoElements);/// let a = [10];/// assert_eq!(a.iter().position_minmax(), OneElement(0));/// assert_eq!(a.iter().position_minmax(), MinMax(4, 3));/// assert_eq!(a.iter().position_minmax(), MinMax(2, 1));position_minmax_by_key/// Return the postions of the minimum and maximum elements of an/// iterator, as determined by the specified function./// The return value is a variant of [`MinMaxResult`] like for/// [`position_minmax`]./// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), NoElements);/// let a = [10_i32];/// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), OneElement(0));/// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), MinMax(1, 4));/// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), MinMax(0, 3));/// [`position_minmax`]: Self::position_minmaxposition_minmax_by/// iterator, as determined by the specified comparison function./// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), NoElements);/// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), OneElement(0));/// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), MinMax(4, 3));/// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), MinMax(2, 1));/// If the iterator yields exactly one element, that element will be returned, otherwise/// an error will be returned containing an iterator that has the same output as the input/// This provides an additional layer of validation over just calling `Iterator::next()`./// If your assumption that there should only be one element yielded is false this provides/// the opportunity to detect and handle that, preventing errors at a distance./// assert_eq!((0..10).filter(|&x| x == 2).exactly_one().unwrap(), 2);/// assert!((0..10).filter(|&x| x > 1 && x < 4).exactly_one().unwrap_err().eq(2..4));/// assert!((0..10).filter(|&x| x > 1 && x < 5).exactly_one().unwrap_err().eq(2..5));/// assert!((0..10).filter(|&_| false).exactly_one().unwrap_err().eq(0..0));at_most_one/// If the iterator yields no elements, Ok(None) will be returned. If the iterator yields/// exactly one element, that element will be returned, otherwise an error will be returned/// containing an iterator that has the same output as the input iterator./// If your assumption that there should be at most one element yielded is false this provides/// assert_eq!((0..10).filter(|&x| x == 2).at_most_one().unwrap(), Some(2));/// assert!((0..10).filter(|&x| x > 1 && x < 4).at_most_one().unwrap_err().eq(2..4));/// assert!((0..10).filter(|&x| x > 1 && x < 5).at_most_one().unwrap_err().eq(2..5));/// assert_eq!((0..10).filter(|&_| false).at_most_one().unwrap(), None);FromI/// Converts an iterator of tuples into a tuple of containers./// `unzip()` consumes an entire iterator of n-ary tuples, producing `n` collections, one for each/// This function is, in some sense, the opposite of [`multizip`]./// let inputs = vec![(1, 2, 3), (4, 5, 6), (7, 8, 9)];/// let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = inputs///     .multiunzip();/// assert_eq!(a, vec![1, 4, 7]);/// assert_eq!(b, vec![2, 5, 8]);/// assert_eq!(c, vec![3, 6, 9]);try_len/// Returns the length of the iterator if one exists./// Otherwise return `self.size_hint()`./// Fallible [`ExactSizeIterator::len`]./// Inherits guarantees and restrictions from [`Iterator::size_hint`]./// assert_eq!([0; 10].iter().try_len(), Ok(10));/// assert_eq!((10..15).try_len(), Ok(5));/// assert_eq!((15..10).try_len(), Ok(0));/// assert_eq!((10..).try_len(), Err((usize::MAX, None)));/// assert_eq!((10..15).filter(|x| x % 2 == 0).try_len(), Err((0, Some(5))));// adaptors/// An [`Iterator`] blanket implementation that provides extra adaptors and/// This trait defines a number of methods. They are divided into two groups:/// * *Adaptors* take an iterator and parameter as input, and return/// a new iterator value. These are listed first in the trait. An example/// of an adaptor is [`.interleave()`](Itertools::interleave)/// * *Regular methods* are those that don't return iterators and instead/// return a regular value of some other kind./// [`.next_tuple()`](Itertools::next_tuple) is an example and the first regular/// method in the list./// Return `true` if both iterables produce equal sequences/// (elements pairwise equal and sequences of the same length),/// [`IntoIterator`] enabled version of [`Iterator::eq`]./// assert!(itertools::equal(vec![1, 2, 3], 1..4));/// assert!(!itertools::equal(&[0, 0], &[0, 0, 0]));assert_equal/// Assert that two iterables produce equal sequences, with the same/// semantics as [`equal(a, b)`](equal)./// **Panics** on assertion failure with a message that shows the/// two iteration elements./// # use itertools::assert_equal;/// assert_equal("exceed".split('c'), "excess".split('c'));/// // ^PANIC: panicked at 'Failed assertion Some("eed") == Some("ess") for iteration 1'./// Partition a sequence using predicate `pred` so that elements/// that map to `true` are placed before elements which map to `false`./// The order within the partitions is arbitrary./// Return the index of the split point./// use itertools::partition;/// # // use repeated numbers to not promise any ordering/// let mut data = [7, 1, 1, 7, 1, 1, 7];/// let split_index = partition(&mut data, |elt| *elt >= 3);/// assert_eq!(data, [7, 7, 7, 1, 1, 1, 1]);/// assert_eq!(split_index, 3);/// Continue folding with this value/// Fold is complete and will return this value/// An enum used for controlling the execution of `fold_while`./// See [`.fold_while()`](Itertools::fold_while) for more information./// Return the value in the continue or done./// Return true if `self` is `Done`, false if it is `Continue`.//! Extra iterator adaptors, functions and macros.//! To extend [`Iterator`] with methods in this crate, import//! the [`Itertools`] trait://! use itertools::Itertools;//! Now, new methods like [`interleave`](Itertools::interleave)//! are available on all iterators://! let it = (1..3).interleave(vec![-1, -2]);//! itertools::assert_equal(it, vec![1, -1, 2, -2]);//! Most iterator methods are also provided as functions (with the benefit//! that they convert parameters using [`IntoIterator`])://! use itertools::interleave;//! for elt in interleave(&[1, 2, 3], &[2, 3, 4]) {//!     /* loop body *///! - `use_std`//!   - Enabled by default.//!   - Disable to compile itertools using `#![no_std]`. This disables//!     any items that depend on collections (like `group_by`, `unique`,//!     `kmerge`, `join` and many more).//! This version of itertools requires Rust 1.43.1 or later.MergeLte/// An iterator adaptor that merges the two base iterators in ascending order./// If both base iterators are sorted (ascending), the result is sorted./// See [`.merge()`](crate::Itertools::merge_by) for more information./// Create an iterator that merges elements in `i` and `j`./// [`IntoIterator`] enabled version of [`Itertools::merge`](crate::Itertools::merge)./// use itertools::merge;/// for elt in merge(&[1, 2, 3], &[2, 3, 4]) {cmp_fn/// See [`.merge_by()`](crate::Itertools::merge_by) for more information.merge_by_new/// Create a `MergeBy` iterator./// Return an iterator adaptor that merge-joins items from the two base iterators in ascending order./// [`IntoIterator`] enabled version of [`Itertools::merge_join_by`].FuncLRMergeFuncLR/// An iterator adaptor that merge-joins items from the two base iterators in ascending order./// See [`.merge_join_by()`](crate::Itertools::merge_join_by) for more information.MergeResult// "merge" never returns (Some(...), Some(...), ...) so Option<Either<I::Item, J::Item>>// is appealing but it is always followed by two put_backs, so we think the compiler is// smart enough to optimize it. Or we could move put_backs into "merge".OrderingOrBoolNoElements/// Empty iteratorOneElement/// Iterator with one element, so the minimum and maximum are the sameMinMax/// More than one element in the iterator, the first element is not larger/// than the second/// `MinMaxResult` is an enum returned by `minmax`./// See [`.minmax()`](crate::Itertools::minmax) for more detail./// `into_option` creates an `Option` of type `(T, T)`. The returned `Option`/// has variant `None` if and only if the `MinMaxResult` has variant/// `NoElements`. Otherwise `Some((x, y))` is returned where `x <= y`./// If the `MinMaxResult` has variant `OneElement(x)`, performing this/// operation will make one clone of `x`./// use itertools::MinMaxResult::{self, NoElements, OneElement, MinMax};/// let r: MinMaxResult<i32> = NoElements;/// assert_eq!(r.into_option(), None);/// let r = OneElement(1);/// assert_eq!(r.into_option(), Some((1, 1)));/// let r = MinMax(1, 2);/// assert_eq!(r.into_option(), Some((1, 2)));minmax_impl/// Implementation guts for `minmax` and `minmax_by_key`.MultiPeek/// See [`multipeek()`] for more information.multipeek/// An iterator adaptor that allows the user to peek at multiple `.next()`/// values without advancing the base iterator./// [`IntoIterator`] enabled version of [`Itertools::multipeek`].reset_peek/// Reset the peeking “cursor”/// Works exactly like `.next()` with the only difference that it doesn't/// advance itself. `.peek()` can be called multiple times, to peek/// further ahead./// When `.next()` is called, reset the peeking “cursor”.peeking_next// Same sizefiller/// An iterator adaptor that pads a sequence to a minimum length by filling/// missing elements using a closure./// See [`.pad_using()`](crate::Itertools::pad_using) for more information./// Create a new `PadUsing` iterator.PeekNth/// See [`peek_nth()`] for more information.peek_nth/// A drop-in replacement for [`std::iter::Peekable`] which adds a `peek_nth`/// method allowing the user to `peek` at a value several iterations forward/// without advancing the base iterator./// This differs from `multipeek` in that subsequent calls to `peek` or/// `peek_nth` will always return the same value until `next` is called/// (making `reset_peek` unnecessary)./// Works exactly like the `peek` method in `std::iter::Peekable`/// Works exactly like the `peek_mut` method in `std::iter::Peekable`/// Returns a reference to the `nth` value without advancing the iterator./// use itertools::peek_nth;/// let xs = vec![1, 2, 3];/// let mut iter = peek_nth(xs.into_iter());/// assert_eq!(iter.peek_nth(0), Some(&1));/// // The iterator does not advance even if we call `peek_nth` multiple times/// assert_eq!(iter.peek_nth(0), Some(&2));/// assert_eq!(iter.peek_nth(1), Some(&3));/// // Calling `peek_nth` past the end of the iterator will return `None`/// assert_eq!(iter.peek_nth(1), None);peek_nth_mut/// Returns a mutable reference to the `nth` value without advancing the iterator./// let xs = vec![1, 2, 3, 4, 5];/// assert_eq!(iter.peek_nth_mut(0), Some(&mut 1));/// // The iterator does not advance even if we call `peek_nth_mut` multiple times/// assert_eq!(iter.peek_nth_mut(0), Some(&mut 2));/// assert_eq!(iter.peek_nth_mut(1), Some(&mut 3));/// // Peek into the iterator and set the value behind the mutable reference./// if let Some(p) = iter.peek_nth_mut(1) {///     assert_eq!(*p, 4);///     *p = 9;/// // The value we put in reappears as the iterator continues./// assert_eq!(iter.next(), Some(9));/// // Calling `peek_nth_mut` past the end of the iterator will return `None`/// assert_eq!(iter.peek_nth_mut(1), None);/// Works exactly like the `next_if` method in `std::iter::Peekable`/// Works exactly like the `next_if_eq` method in `std::iter::Peekable`/// Pass a reference to the next iterator element to the closure `accept`;/// if `accept` returns true, return it as the next element,/// else None./// An iterator that allows peeking at an element before deciding to accept it./// See [`.peeking_take_while()`](crate::Itertools::peeking_take_while)/// This is implemented by peeking adaptors like peekable and put back,/// but also by a few iterators that can be peeked natively, like the slice’s/// by reference iterator (`std::slice::Iter`)./// An iterator adaptor that takes items while a closure returns `true`./// Create a `PeekingTakeWhile`peeking_next_by_clone// Some iterators are so lightweight we can simply clone them to save their// state and use that for peeking.// cloning a Rev has no extra overhead; peekable and put backs are never DEI.PermutationStatePermutations/// An iterator adaptor that iterates through all the `k`-permutations of the/// See [`.permutations()`](crate::Itertools::permutations) for/// No permutation generated yet.min_n/// Values from the iterator are not fully loaded yet so `n` is still unknown.Loaded/// All values from the iterator are known so `n` is known./// No permutation left to generate.permutationssize_hint_forcombsPowerset/// An iterator to iterate through the powerset of the elements from an iterator./// See [`.powerset()`](crate::Itertools::powerset) for morepowerset/// Create a new `Powerset` from a clonable iterator./// An iterator that produces only the `T` values as long as the/// inner iterator produces `Ok(T)`./// Used by [`process_results`](crate::process_results), see its docs/// “Lift” a function of the values of an iterator so that it can process/// [`IntoIterator`] enabled version of [`Itertools::process_results`].PutBackN/// An iterator adaptor that allows putting multiple/// items in front of the iterator.put_back_n/// Create an iterator where you can put back multiple values to the front/// of the iteration./// Puts x in front of the iterator./// The values are yielded in order of the most recently put back/// values first./// use itertools::put_back_n;/// let mut it = put_back_n(1..5);/// it.next();/// it.put_back(1);/// it.put_back(0);/// assert!(itertools::equal(it, 0..5));rciter/// The boxed iterator.RcIter/// A wrapper for `Rc<RefCell<I>>`, that implements the `Iterator` trait./// Return an iterator inside a `Rc<RefCell<_>>` wrapper./// The returned `RcIter` can be cloned, and each clone will refer back to the/// same original iterator./// `RcIter` allows doing interesting things like using `.zip()` on an iterator with/// itself, at the cost of runtime borrow checking which may have a performance/// penalty./// use itertools::rciter;/// // In this example a range iterator is created and we iterate it using/// // three separate handles (two of them given to zip)./// // We also use the IntoIterator implementation for `&RcIter`./// let mut iter = rciter(0..9);/// let mut z = zip(&iter, &iter);/// assert_eq!(z.next(), Some((0, 1)));/// assert_eq!(z.next(), Some((2, 3)));/// assert_eq!(z.next(), Some((4, 5)));/// assert_eq!(iter.next(), Some(6));/// assert_eq!(z.next(), Some((7, 8)));/// assert_eq!(z.next(), None);/// **Panics** in iterator methods if a borrow error is encountered in the/// iterator methods. It can only happen if the `RcIter` is reentered in/// `.next()`, i.e. if it somehow participates in an “iterator knot”/// where it is an adaptor of itself./// Return an iterator from `&RcIter<I>` (by simply cloning it).elt/// An iterator that produces *n* repetitions of an element./// See [`repeat_n()`](crate::repeat_n) for more information./// Create an iterator that produces `n` repetitions of `element`./// `SizeHint` is the return type of `Iterator::size_hint()`./// Add `SizeHint` correctly.add_scalar/// Add `x` correctly to a `SizeHint`.sub_scalar/// Subtract `x` correctly from a `SizeHint`./// Multiply `SizeHint` correctlymul_scalar/// Multiply `x` correctly with a `SizeHint`./// Return the maximum/// Return the minimummul_size_hints//! Arithmetic on `Iterator.size_hint()` values./// See [`repeat_call`](crate::repeat_call) for more information./// An iterator source that produces elements indefinitely by calling/// a given closure./// Iterator element type is the return type of the closure./// use itertools::repeat_call;/// let mut heap = BinaryHeap::from(vec![2, 5, 3, 7, 8]);/// // extract each element in sorted order/// for element in repeat_call(|| heap.pop()).while_some() {///     print!("{}", element);///     repeat_call(|| 1).take(5),///     vec![1, 1, 1, 1, 1]/// Creates a new unfold source with the specified closure as the "iterator/// function" and an initial state to eventually pass to the closure/// `unfold` is a general iterator builder: it has a mutable state value,/// and a closure with access to the state that produces the next value./// This more or less equivalent to a regular struct with an [`Iterator`]/// implementation, and is useful for one-off iterators./// // an iterator that yields sequential Fibonacci numbers,/// // and stops at the maximum representable value./// use itertools::unfold;/// let mut fibonacci = unfold((1u32, 1u32), |(x1, x2)| {///     // Attempt to get the next Fibonacci number///     let next = x1.saturating_add(*x2);///     // Shift left: ret <- x1 <- x2 <- next///     let ret = *x1;///     *x1 = *x2;///     *x2 = next;///     // If addition has saturated at the maximum, we are finished///     if ret == *x1 && ret > 1 {///         Some(ret)/// itertools::assert_equal(fibonacci.by_ref().take(8),///                         vec![1, 1, 2, 3, 5, 8, 13, 21]);/// assert_eq!(fibonacci.last(), Some(2_971_215_073))/// Internal state that will be passed to the closure on the next iteration/// See [`unfold`](crate::unfold) for more information./// An iterator that infinitely applies function to value and yields results./// This `struct` is created by the [`iterate()`](crate::iterate) function./// Creates a new iterator that infinitely applies function to value and yields results./// use itertools::iterate;/// itertools::assert_equal(iterate(1, |i| i % 3 + 1).take(5), vec![1, 2, 3, 1, 2]);/// **Panics** if compute the next value does./// # use itertools::iterate;/// let mut it = iterate(25u32, |x| x - 10).take_while(|&x| x > 10);/// assert_eq!(it.next(), Some(25)); // `Iterate` holds 15./// assert_eq!(it.next(), Some(15)); // `Iterate` holds 5./// it.next(); // `5 - 10` overflows./// You can alternatively use [`core::iter::successors`] as it better describes a finite iterator.//! Iterators that are sources (produce elements from parameters,//! not from another iterator)./// An iterator adaptor that consumes elements while the given predicate is/// `true`, including the element for which the predicate first returned/// See [`.take_while_inclusive()`](crate::Itertools::take_while_inclusive)/// Create a new [`TakeWhileInclusive`] from an iterator and a predicate.backlog/// The owner field indicates which id should read from the backlogTeeBuffer/// Common buffer object for the two tee halvesrcbuffer/// One half of an iterator pair where both return the same elements./// See [`.tee()`](crate::Itertools::tee) for more information./// Implemented for homogeneous tuples of size up to 12./// An iterator over a incomplete tuple./// See [`.tuples()`](crate::Itertools::tuples) and/// [`Tuples::into_buffer()`]./// An iterator that groups the items in tuples of a specific size./// See [`.tuples()`](crate::Itertools::tuples) for more information./// Create a new tuples iterator.add_then_div/// `(n + a) / d` avoiding overflow when possible, returns `None` if it overflows./// Return a buffer with the produced items that was not enough to be grouped in a tuple./// let mut iter = (0..5).tuples();/// assert_eq!(Some((0, 1, 2)), iter.next());/// itertools::assert_equal(vec![3, 4], iter.into_buffer());/// An iterator over all contiguous windows that produces tuples of a specific size./// See [`.tuple_windows()`](crate::Itertools::tuple_windows) for more/// Create a new tuple windows iterator./// An iterator over all windows, wrapping back to the first elements when the/// window would otherwise exceed the length of the iterator, producing tuples/// See [`.circular_tuple_windows()`](crate::Itertools::circular_tuple_windows) for morebuffer_lencollect_from_itercollect_from_iter_no_bufnum_itemsleft_shift_pushrev_for_each_identimpl_tuple_collect//! Some iterator that produces tuples// `HomogeneousTuple` is a public facade for `TupleCollect`, allowing// tuple-related methods to be used by clients in generic contexts, while// hiding the implementation details of `TupleCollect`.// See https://github.com/rust-itertools/itertools/issues/387// Use a Hashmap for the Entry API in order to prevent hashing twice.// This can maybe be replaced with a HashSet once `get_or_insert_with`// or a proper Entry API for Hashset is stable and meets this msrvUniqueBy/// See [`.unique_by()`](crate::Itertools::unique) for more information.unique_by/// Create a new `UniqueBy` iterator.count_new_keys// count the number of new unique keys in iterable (`used` is the set already seen)/// See [`.unique()`](crate::Itertools::unique) for more information./// `multiunzip()` consumes an entire iterator of n-ary tuples, producing `n` collections, one for each/// use itertools::multiunzip;/// let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = multiunzip(inputs);/// [`multizip`]: crate::multizip/// Unzip this iterator into multiple collections./// An iterator that can be unzipped into multiple collections./// See [`.multiunzip()`](crate::Itertools::multiunzip) for more information.impl_unzip_iterFromCFromDFromEFromFFromGFromHFromJFromKFromLhandled_first/// An iterator adaptor that wraps each element in an [`Position`]./// Iterator element type is `(Position, I::Item)`./// See [`.with_position()`](crate::Itertools::with_position) for more information./// Create a new `WithPosition` iterator./// This is the first element./// This is neither the first nor the last element./// This is the last element.Only/// This is the only element./// The first component of the value yielded by `WithPosition`./// Indicates the position of this element in the iterator results./// An iterator which iterates two other iterators simultaneously/// See [`.zip_eq()`](crate::Itertools::zip_eq) for more information./// Iterate `i` and `j` in lock step./// **Panics** if the iterators are not of the same length./// [`IntoIterator`] enabled version of [`Itertools::zip_eq`](crate::Itertools::zip_eq)./// use itertools::zip_eq;/// let data = [1, 2, 3, 4, 5];/// for (a, b) in zip_eq(&data[..data.len() - 1], &data[1..]) {/// See [`.zip_longest()`](crate::Itertools::zip_longest) for more information./// Create a new `ZipLongest` iterator.// ZipLongest originally written by SimonSapin,// and dedicated to itertools https://github.com/rust-lang/rust/pull/19283/// See [`multizip`] for more information./// An iterator that generalizes *.zip()* and allows running multiple iterators in lockstep./// The iterator `Zip<(I, J, ..., M)>` is formed from a tuple of iterators (or values that/// implement [`IntoIterator`]) and yields elements/// until any of the subiterators yields `None`./// The iterator element type is a tuple like like `(A, B, ..., E)` where `A` to `E` are the/// element types of the subiterator./// **Note:** The result of this macro is a value of a named type (`Zip<(I, J,/// ..)>` of each component iterator `I, J, ...`) if each component iterator is/// nameable./// Prefer [`izip!()`] over `multizip` for the performance benefits of using the/// standard library `.zip()`. Prefer `multizip` if a nameable type is needed./// use itertools::multizip;/// for (r, index, input) in multizip((&mut results, 0..10, &inputs)) {/// [`izip!()`]: crate::izipimpl_zip_iter/// See [`.interleave()`](../trait.Itertools.html#method.interleave) for more information./// `IntoIterator` enabled version of `i.interleave(j)`./// use itertools::interleave;/// for elt in interleave(&[1, 2, 3], &[2, 3, 4]) {it0it1// false ==> it0, true ==> it1/// See [`.interleave_shortest()`](../trait.Itertools.html#method.interleave_shortest)/// See [`.cartesian_product()`](../trait.Itertools.html#method.cartesian_product) for more information./// See [`.batching()`](../trait.Itertools.html#method.batching) for more information./// See [`.step()`](../trait.Itertools.html#method.step) for more information.merge_predMergePredicate/// See [`.merge()`](../trait.Itertools.html#method.merge_by) for more information./// `IntoIterator` enabled version of `i.merge(j)`.fused/// See [`.merge_by()`](../trait.Itertools.html#method.merge_by) for more information.CoalesceCorenext_with/// See [`.coalesce()`](../trait.Itertools.html#method.coalesce) for more information.dedup_pred/// See [`.dedup_by()`](../trait.Itertools.html#method.dedup_by) or [`.dedup()`](../trait.Itertools.html#method.dedup) for more information./// See [`.dedup()`](../trait.Itertools.html#method.dedup) for more information./// See [`.take_while_ref()`](../trait.Itertools.html#method.take_while_ref) for more information./// See [`.while_some()`](../trait.Itertools.html#method.while_some) for more information._mt/// See [`.tuple_combinations()`](../trait.Itertools.html#method.tuple_combinations) for more_res/// See [`.map_into()`](../trait.Itertools.html#method.map_into) for more information./// Create a new [`MapInto`](struct.MapInto.html) iterator./// An iterator adapter to apply a transformation within a nested `Result`./// See [`.map_results()`](../trait.Itertools.html#method.map_results) for more information./// Create a new `MapResults` iterator./// See [`.positions()`](../trait.Itertools.html#method.positions) for more information./// See [`.update()`](../trait.Itertools.html#method.update) for more information.//! http://www.apache.org/licenses/LICENSE-2.0 or the MIT license//! http://opensource.org/licenses/MIT, at your/// See [`.multi_cartesian_product()`](../trait.Itertools.html#method.multi_cartesian_product)/// Holds the state of a single iterator within a MultiProduct./// Holds the current state during an iteration of a MultiProduct./// See [`.combinations()`](../trait.Itertools.html#method.combinations) for more information.max_index// The current known max index value. This increases as pool grows./// See [`.combinations_with_replacement()`](../trait.Itertools.html#method.combinations_with_replacement) for more information./// Combine all an iterator's elements into one element by using `Extend`./// `IntoIterator`-enabled version of `.concat()`/// A type returned by the [`diff_with`](./fn.diff_with.html) function./// returns a `Diff` which describes how `j` differs from `i`.//! - [**Diff**](./enum.Diff.html) (produced by the [**diff_with**](./fn.diff_with.html) function)/// If `Left`, or `Both`, return true, otherwise, return false./// If Left, return true otherwise, return false./// Exclusive version of [`has_left`]./// If Right, return true otherwise, return false./// Exclusive version of [`has_right`]./// Equivalent to `self.as_ref().both().is_some()`./// If `Left`, or `Both`, return `Some` with the left value, otherwise, return `None`./// If `Right`, or `Both`, return `Some` with the right value, otherwise, return `None`./// If Both, return `Some` tuple containing left and right./// Apply the function `f` on the value `b` in `Right(b)` or `Both(a, _)` variants if it is/// Apply the function `f` on the value `a`/// in `Left(a)` or `Both(a, _)` variants if it is present./// Return either value of left, right, or the product of `f` applied where `Both` are present./// Iterator returned for the error case of `IterTools::exactly_one()`/// During the execution of exactly_one the iterator must be mutated.  This wrapper/// This is very similar to PutBackN except this iterator only supports 0-2 elements and does not/// See [`.format_with()`](../trait.Itertools.html#method.format_with) for more information./// See [`.format()`](../trait.Itertools.html#method.format)VecIntoIterput_back_n_implmultipeek_implkmerge_implrciter_impl/// `IntoIterator` enabled version of `.enumerate()`./// `IntoIterator` enabled version of `.rev()`./// `IntoIterator` enabled version of `i.zip(j)`./// for (a, b) in zip(&data, &data[1..]) {/// Create an iterator that first iterates `i` and then `j`./// `IntoIterator` enabled version of `i.chain(j)`./// for elt in chain(&[1, 2, 3], &[4]) {/// `IntoIterator` enabled version of `i.cloned()`./// `IntoIterator` enabled version of `i.fold(init, f)`/// `IntoIterator` enabled version of `i.all(f)`/// `IntoIterator` enabled version of `i.any(f)`/// `IntoIterator` enabled version of `i.max()`./// `IntoIterator` enabled version of `i.min()`./// Combine all iterator elements into one String, seperated by `sep`./// `IntoIterator` enabled version of `iterable.join(sep)`./// use itertools::join;/// assert_eq!(join(&[1, 2, 3], ", "), "1, 2, 3");sorted/// Sort all iterator elements into a new iterator in ascending order./// `IntoIterator` enabled version of [`iterable.sorted()`][1]./// [1]: trait.Itertools.html#method.sorted/// use itertools::sorted;/// use itertools::assert_equal;/// assert_equal(sorted("rust".chars()), "rstu".chars());//! The benefit of free functions is that they accept any `IntoIterator` as/// See [`.into_group_map()`](../trait.Itertools.html#method.into_group_map)/// A trait to unify FnMut for GroupBy with the chunk key in IntoChunks/// ChunkIndex acts like the grouping key function for IntoChunks/// This type implements `IntoIterator` (it is **not** an iterator/// See [`.group_by()`](../trait.Itertools.html#method.group_by) for more information./// See [`.chunks()`](../trait.Itertools.html#method.chunks) for more information./// See [`.intersperse()`](../trait.Itertools.html#method.intersperse) for more information./// See [`.kmerge()`](../trait.Itertools.html#method.kmerge) for more information./// Equivalent to `iterable.into_iter().kmerge()`./// See [`.kmerge_by()`](../trait.Itertools.html#method.kmerge_by) for more/// Equivalent to `iterable.into_iter().kmerge_by(less_than)`.groupbylazyteeunique_implgroup_map/// [`multizip`]: fn.multizip.html/// [`EitherOrBoth<Self::Item, J::Item>`](enum.EitherOrBoth.html).group_by/// Return an *iterable* that can group iterator elements./// Consecutive elements that map to the same key (“runs”), are assigned/// to the same group./// If the groups are consumed in order, or if each group's iterator is/// dropped without keeping it around, then `GroupBy` uses no/// allocations.  It needs allocations only if several group iterators/// Iterator element type is `(K, Group)`: the group's key and the/// group iterator./// // group data into runs of larger than zero or not./// let data = vec![1, 3, -2, -2, 1, 0, 1, 2];/// // groups:     |---->|------>|--------->|/// // Note: The `&` is significant here, `GroupBy` is iterable/// // only by reference. You can also call `.into_iter()` explicitly./// let mut data_grouped = Vec::new();/// for (key, group) in &data.into_iter().group_by(|elt| *elt >= 0) {///     data_grouped.push((key, group.collect()));/// assert_eq!(data_grouped, vec![(true, vec![1, 3]), (false, vec![-2, -2]), (true, vec![1, 0, 1, 2])]);/// Return an *iterable* that can chunk the iterator./// Yield subiterators (chunks) that each yield a fixed number elements,/// determined by `size`. The last chunk will be shorter if there aren't/// enough elements./// `IntoChunks` is based on `GroupBy`: it is iterable (implements/// `IntoIterator`, **not** `Iterator`), and it only buffers if several/// chunk iterators are alive at the same time./// **Panics** if `size` is 0./// let data = vec![1, 1, 2, -2, 6, 0, 3, 1];/// //chunk size=3 |------->|-------->|--->|/// // Note: The `&` is significant here, `IntoChunks` is iterable/// for chunk in &data.into_iter().chunks(3) {///     // Check that the sum of each chunk is 4.///     assert_eq!(4, chunk.sum());/// a specific size (up to 4)./// (up to 4)./// See also the method [`.next_tuple()`](#method.next_tuple)./// See also [`Tuples::into_buffer`](structs/struct.Tuples.html#method.into_buffer)./// Split into an iterator pair that both yield all elements from/// the original iterator./// **Note:** If the iterator is clonable, prefer using that instead/// of using this method. It is likely to be more efficient./// let xs = vec![0, 1, 2, 3];/// let (mut t1, t2) = xs.into_iter().tee();/// itertools::assert_equal(t1.next(), Some(0));/// itertools::assert_equal(t2, 0..4);/// itertools::assert_equal(t1, 1..4);/// Convert each item of the iterator using the `Into` trait./// let it = input.into_iter().map_results(|i| i + 1);/// let a = (0..11).step(3);/// let b = (0..11).step(5);/// This is much like `.merge()` but allows for a custom ordering./// It chooses whether to pair elements based on the `Ordering` returned by the/// let ki = (0..10).step(3);/// let ku = (0..10).step(5);/// let ki_ku = ki.merge_join_by(ku, |i, j| i.cmp(j)).map(|either| {///     match either {///         Left(_) => "Ki",///         Right(_) => "Ku",///         Both(_, _) => "KiKu"/// itertools::assert_equal(ki_ku, vec!["KiKu", "Ki", "Ku", "Ki", "Ki"]);/// Return an iterator adaptor that flattens an iterator of iterators by/// merging them in ascending order./// let a = (0..6).step(3);/// let b = (1..6).step(3);/// let c = (2..6).step(3);/// let it = vec![a, b, c].into_iter().kmerge();/// itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 5]);/// merging them according to the given closure./// The closure `first` is called with two elements *a*, *b* and should/// return `true` if *a* is ordered before *b*./// If all base iterators are sorted according to `first`, the result is/// sorted./// let a = vec![-1f64, 2., 3., -5., 6., -7.];/// let b = vec![0., 2., -4.];/// let mut it = vec![a, b].into_iter().kmerge_by(|a, b| a.abs() < b.abs());/// assert_eq!(it.next(), Some(0.));/// assert_eq!(it.last(), Some(-7.));/// all subiterators returned by meta-iterator `self`./// All provided iterators must yield the same `Item` type. To generate/// the product of iterators yielding multiple types, use the/// [`iproduct`](macro.iproduct.html) macro instead./// The iterator element type is `Vec<T>`, where `T` is the iterator element/// of the subiterators./// let mut multi_prod = (0..3).map(|i| (i * 2)..(i * 2 + 2))///     .multi_cartesian_product();/// assert_eq!(multi_prod.next(), Some(vec![0, 2, 4]));/// assert_eq!(multi_prod.next(), Some(vec![0, 2, 5]));/// assert_eq!(multi_prod.next(), Some(vec![0, 3, 4]));/// assert_eq!(multi_prod.next(), Some(vec![0, 3, 5]));/// assert_eq!(multi_prod.next(), Some(vec![1, 2, 4]));/// assert_eq!(multi_prod.next(), Some(vec![1, 2, 5]));/// assert_eq!(multi_prod.next(), Some(vec![1, 3, 4]));/// assert_eq!(multi_prod.next(), Some(vec![1, 3, 5]));/// assert_eq!(multi_prod.next(), None);/// itertools::assert_equal(data.into_iter().dedup_by(|x, y| x.1==y.1),/// Return an iterator adaptor that filters out elements that have/// already been produced once during the iteration. Duplicates/// are detected using hash and equality./// Clones of visited elements are stored in a hash set in the/// let data = vec![10, 20, 30, 20, 40, 10, 50];/// itertools::assert_equal(data.into_iter().unique(),///                         vec![10, 20, 30, 40, 50]);/// already been produced once during the iteration./// Duplicates are detected by comparing the key they map to/// with the keying function `f` by hash and equality./// The keys are stored in a hash set in the iterator./// let data = vec!["a", "bb", "aa", "c", "ccc"];/// itertools::assert_equal(data.into_iter().unique_by(|s| s.len()),///                         vec!["a", "bb", "ccc"]);/// See also [`.take_while_ref()`](#method.take_while_ref)/// size up to 4./// Return an iterator adaptor that iterates over the `k`-length combinations of/// the elements from an iterator./// Iterator element type is `Vec<Self::Item>`. The iterator produces a new Vec per iteration,/// and clones the iterator elements./// let it = (1..5).combinations(3);/// itertools::assert_equal(it, vec![///     vec![1, 2, 3],///     vec![1, 2, 4],///     vec![1, 3, 4],///     vec![2, 3, 4],/// Note: Combinations does not take into account the equality of the iterated values./// let it = vec![1, 2, 2].into_iter().combinations(2);///     vec![1, 2], // Note: these are the same///     vec![2, 2],/// Return an iterator that iterates over the `k`-length combinations of/// the elements from an iterator, with replacement./// let it = (1..4).combinations_with_replacement(2);///     vec![1, 1],///     vec![1, 2],///     vec![1, 3],///     vec![2, 3],///     vec![3, 3],/// Return an iterator adaptor that iterates over all k-permutations of the/// Iterator element type is `Vec<Self::Item>` with length `k`. The iterator/// produces a new Vec per iteration, and clones the iterator elements./// If `k` is greater than the length of the input iterator, the resultant/// iterator adaptor will be empty./// let perms = (5..8).permutations(2);/// itertools::assert_equal(perms, vec![///     vec![5, 6],///     vec![5, 7],///     vec![6, 5],///     vec![6, 7],///     vec![7, 5],///     vec![7, 6],/// Note: Permutations does not take into account the equality of the iterated values./// let it = vec![2, 2].into_iter().permutations(2);///     vec![2, 2], // Note: these are the same/// Note: The source iterator is collected lazily, and will not be/// re-iterated if the permutations adaptor is completed and re-iterated./// Return an iterator adaptor that wraps each element in a `Position` to/// [`Position<Self::Item>`](enum.Position.html)///                         vec![Position::First(0),///                              Position::Middle(1),///                              Position::Middle(2),///                              Position::Last(3)]);/// itertools::assert_equal(it, vec![Position::Only(0)]);/// Equivalent to `iter.enumerate().filter(|(_, v)| predicate(v)).map(|(i, _)| i)`.collect_vec/// `.collect_vec()` is simply a type specialization of `.collect()`,/// Combine all iterator elements into one String, separated by `sep`./// Use the `Display` implementation of each element./// assert_eq!(["a", "b", "c"].iter().join(", "), "a, b, c");/// assert_eq!([1, 2, 3].iter().join(", "), "1, 2, 3");/// This is a customizable version of `.format()`.///           .fold_results(0, Add::add),///           .fold_results(0, Add::add)/// This is the `Option` equivalent to `fold_results`./// result than the linear call tree used by `fold1`:/// If `f` is associative, prefer the normal `fold1` instead./// `fold_while()` is basically equivalent to `fold()` but with additional support for/// **Note:** This consumes the entire iterator, uses the/// `slice::sort()` method and returns the result as a new/// iterator that owns its elements./// The sorted iterator, if directly collected to a `Vec`, is converted/// without any extra copying or allocation cost./// // sort the letters of the text in ascending order/// let text = "bdacfe";/// itertools::assert_equal(text.chars().sorted(),///                         "abcdef".chars());/// `slice::sort_by()` method and returns the result as a new/// // sort people in descending order by age/// let people = vec![("Jane", 20), ("John", 18), ("Jill", 30), ("Jack", 27)];/// let oldest_people_first = people///     .sorted_by(|a, b| Ord::cmp(&b.1, &a.1))///     .map(|(person, _age)| person);/// itertools::assert_equal(oldest_people_first,///                         vec!["Jill", "Jack", "Jane", "John"]);sorted_by_key/// `slice::sort_by_key()` method and returns the result as a new///     .sorted_by_key(|x| -x.1)/// partitions. Unlike `Iterator::partition`, each partition may/// Return a `HashMap` of keys mapped to `Vec`s of values. Keys and values/// are taken from `(Key, Value)` tuple pairs yielded by the input iterator./// let data = vec![(0, 10), (2, 12), (3, 13), (0, 20), (3, 33), (2, 42)];/// let lookup = data.into_iter().into_group_map();/// assert_eq!(lookup[&0], vec![10, 20]);/// assert_eq!(lookup.get(&1), None);/// assert_eq!(lookup[&2], vec![12, 42]);/// assert_eq!(lookup[&3], vec![13, 33]);/// The return value is a variant of `MinMaxResult` like for `minmax()`./// `Iterator::min()` and `Iterator::max()` methods./// comparisons, and so is faster than calling `positon_min` and/// [`MinMaxResult`]: enum.MinMaxResult.html/// [`position_minmax`]: #method.position_minmax/// of an adaptor is [`.interleave()`](#method.interleave)/// [`.next_tuple()`](#method.next_tuple) is an example and the first regular/// This is an `IntoIterator` enabled function that is similar to the standard/// library method `Iterator::eq`./// semantics as *equal(a, b)*./// // ^PANIC: panicked at 'Failed assertion Some("eed") == Some("ess") for iteration 1',/// An enum used for controlling the execution of `.fold_while()`./// See [`.fold_while()`](trait.Itertools.html#method.fold_while) for more information.//! the [`Itertools` trait](./trait.Itertools.html)://! Now, new methods like [`interleave`](./trait.Itertools.html#method.interleave)//! This version of itertools requires Rust 1.32 or later.//! [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html/// See [`.merge_join_by()`](trait.Itertools.html#method.merge_join_by) for more information./// See [`.merge_join_by()`](../trait.Itertools.html#method.merge_join_by) for more information./// `MinMaxResult` is an enum returned by `minmax`. See `Itertools::minmax()` for/// See [`multipeek()`](../fn.multipeek.html) for more information./// See [`.pad_using()`](../trait.Itertools.html#method.pad_using) for more information./// Create a new **PadUsing** iterator./// See [`.peeking_take_while()`](trait.Itertools.html#method.peeking_take_while)/// See [`.peeking_take_while()`](../trait.Itertools.html#method.peeking_take_while)/// Create a PeekingTakeWhilelinked_list/// See [`.permutations()`](../trait.Itertools.html#method.permutations) forStartUnknownLenOngoingUnknownLenCompleteStateOngoingCompleteStateRemaining/// Used by [`process_results`](../fn.process_results.html), see its docs/// `iterable` is an iterator or iterable with `Result<T, E>` elements, where/// `T` is the value type and `E` the error type./// `processor` is a closure that receives an adapted version of the iterable/// iterator ends and the `process_results` function will return the/// error iself./// use itertools::process_results;/// type R = Result<i32, &'static str>;/// let first_values: Vec<R> = vec![Ok(1), Ok(0), Ok(3)];/// let second_values: Vec<R> = vec![Ok(2), Ok(1), Err("overflow")];/// // “Lift” the iterator .max() method to work on the values in Results using process_results/// let first_max = process_results(first_values, |iter| iter.max().unwrap_or(0));/// let second_max = process_results(second_values, |iter| iter.max().unwrap_or(0));/// See [`repeat_n()`](../fn.repeat_n.html) for more information./// **SizeHint** is the return type of **Iterator::size_hint()**./// Add **SizeHint** correctly./// Add **x** correctly to a **SizeHint**./// Sbb **x** correctly to a **SizeHint**./// Multiply **SizeHint** correctly/// use itertools::size_hint;/// assert_eq!(size_hint::mul((3, Some(4)), (3, Some(4))),///            (9, Some(16)));/// assert_eq!(size_hint::mul((3, Some(4)), (usize::MAX, None)),///            (usize::MAX, None));/// assert_eq!(size_hint::mul((3, None), (0, Some(0))),///            (0, Some(0)));/// Multiply **x** correctly with a **SizeHint**.//! Arithmetic on **Iterator** *.size_hint()* values./// See [`repeat_call`](../fn.repeat_call.html) for more information./// This more or less equivalent to a regular struct with an `Iterator`/// let (mut x1, mut x2) = (1u32, 1u32);/// let mut fibonacci = unfold((), move |_| {///     let next = x1.saturating_add(x2);///     let ret = x1;///     x1 = x2;///     x2 = next;///     if ret == x1 && ret > 1 {///         return None;///     Some(ret)/// See [`unfold`](../fn.unfold.html) for more information./// This `struct` is created by the [`iterate()`] function. See its documentation for more./// [`iterate()`]: ../fn.iterate.html/// itertools::assert_equal(iterate(1, |&i| i * 3).take(5), vec![1, 3, 9, 27, 81]);/// See [`.tee()`](../trait.Itertools.html#method.tee) for more information./// Implemented for homogeneous tuples of size up to 4./// See [`.tuples()`](../trait.Itertools.html#method.tuples) and/// [`Tuples::into_buffer()`](struct.Tuples.html#method.into_buffer)./// See [`.tuples()`](../trait.Itertools.html#method.tuples) for more information./// See [`.tuple_windows()`](../trait.Itertools.html#method.tuple_windows) for more// Use a hashmap for the entry API/// See [`.unique_by()`](../trait.Itertools.html#method.unique) for more information./// See [`.unique()`](../trait.Itertools.html#method.unique) for more information./// An iterator adaptor that wraps each element in an [`Position`](../enum.Position.html)./// Iterator element type is `Position<I::Item>`./// See [`.with_position()`](../trait.Itertools.html#method.with_position) for more information./// A value yielded by `WithPosition`./// See [`.with_position()`](trait.Itertools.html#method.with_position) for more information./// Return the inner value./// See [`.zip_eq()`](../trait.Itertools.html#method.zip_eq) for more information./// `IntoIterator` enabled version of `i.zip_eq(j)`./// See [`.zip_longest()`](../trait.Itertools.html#method.zip_longest) for more information./// See [`multizip`](../fn.multizip.html) for more information./// implement `IntoIterator`) and yields elements/// [`izip!()`]: macro.izip.htmlIntegerPrivateimpl_Integer// Adaptation of the original implementation at// https://github.com/rust-lang/rust/blob/b8214dc6c6fc20d0a660fb5700dca9ebf51ebe89/src/libcore/fmt/num.rs#L188-L266// Copyright 2016 Itoa Developers// i128::MIN (including minus sign)udivmod_1e19// Copyright 2009-2016 compiler-builtins Developers// The compiler-builtins crate is dual licensed under both the University of// Illinois "BSD-Like" license and the MIT license.  As a user of this code you may// choose to use it under either license. As a contributor, you agree to allow// your code to be used under both.// Full text of the relevant licenses is found here:// https://github.com/rust-lang-nursery/compiler-builtins/blob/master/LICENSE.TXT// The following code is based on Rust’s [compiler-builtins crate]// (https://github.com/rust-lang-nursery/compiler-builtins) which// provides runtime functions for the Rust programs. The Rust// compiler will automatically link your programs against this crate.// We copied the implementation of '__udivmodti4()' which is an intrinsic// implementing division with remainder for architectures without 128-bit integer support.// We have done this two reasons, to work around [bad optimization by LLVM]// (https://github.com/rust-lang/rust/issues/44545) and to allow function// inlining which doesn’t happen with the intrinsic.udiv128I128_MAX_LEN/// A correctly sized stack allocation for the formatted integer to be written/// into./// let mut buffer = itoa::Buffer::new();/// let printed = buffer.format(1234);/// assert_eq!(printed, "1234");// false positive https://github.com/rust-lang/rust-clippy/issues/11072/// This is a cheap operation; you don't need to worry about reusing buffers/// for efficiency./// Print an integer into this buffer and return a reference to its string/// representation within the buffer./// An integer that can be written into an [`itoa::Buffer`][Buffer]./// This trait is sealed and cannot be implemented for types outside of itoa.// Seal to prevent downstream implementations of the Integer trait.I8_MAX_LENU8_MAX_LENI16_MAX_LENU16_MAX_LENI32_MAX_LENU32_MAX_LENI64_MAX_LENU64_MAX_LENimpl_Integer128U128_MAX_LEN//! [![github]](https://github.com/dtolnay/itoa)&ensp;[![crates-io]](https://crates.io/crates/itoa)&ensp;[![docs-rs]](https://docs.rs/itoa)//! This crate provides a fast conversion of integer primitives to decimal//! strings. The implementation comes straight from [libcore] but avoids the//! performance penalty of going through [`core::fmt::Formatter`].//! See also [`ryu`] for printing floating point primitives.//! [libcore]: https://github.com/rust-lang/rust/blob/b8214dc6c6fc20d0a660fb5700dca9ebf51ebe89/src/libcore/fmt/num.rs#L201-L254//! [`core::fmt::Formatter`]: https://doc.rust-lang.org/std/fmt/struct.Formatter.html//! [`ryu`]: https://github.com/dtolnay/ryu//!     let mut buffer = itoa::Buffer::new();//!     let printed = buffer.format(128u64);//!     assert_eq!(printed, "128");//! # Performance (lower is better)//! ![performance](https://raw.githubusercontent.com/dtolnay/itoa/master/performance.png)u128_mulhi/// Multiply unsigned 128 bit integers, return upper 128 bits of the result/// Divide `n` by 1e19 and return quotient and remainder/// Integer division algorithm is based on the following paper:///   T. Granlund and P. Montgomery, “Division by Invariant Integers Using Multiplication”///   in Proc. of the SIGPLAN94 Conference on Programming Language Design and///   Implementation, 1994, pp. 61–72FromEnvErrorInnerFromEnvError/// Error type for [`Client::from_env_ext`] function.
/// [`Client::from_env_ext`]: crate::Client::from_env_ext
FromEnvErrorKindNoEnvVar/// There is no environment variable that describes jobserver to inherit.
NoJobserver/// There is no jobserver in the environment variable.
/// Variables associated with Make can be used for passing data other than jobserver info.
CannotParse/// Cannot parse jobserver environment variable value, incorrect format.
CannotOpenPath/// Cannot open path or name from the jobserver environment variable value.
CannotOpenFd/// Cannot open file descriptor from the jobserver environment variable value.
NegativeFd/// The jobserver style is a simple pipe, but at least one of the file descriptors
/// is negative, which means it is disabled for this process
/// ([GNU `make` manual: POSIX Jobserver Interaction](https://www.gnu.org/software/make/manual/make.html#POSIX-Jobserver)).
NotAPipe/// File descriptor from the jobserver environment variable value is not a pipe.
/// Jobserver inheritance is not supported on this platform.
/// Kind of an error returned from [`Client::from_env_ext`] function.
/// Get the error kind.
/// A client of a jobserver
/// This structure is the main type exposed by this library, and is where
/// interaction to a jobserver is configured through. Clients are either created
/// from scratch in which case the internal semphore is initialied on the spot,
/// or a client is created from the environment to connect to a jobserver
/// already created.
/// Some usage examples can be found in the crate documentation for using a
/// client.
/// Note that a [`Client`] implements the [`Clone`] trait, and all instances of
/// a [`Client`] refer to the same jobserver instance.
/// An acquired token from a jobserver.
/// This token will be released back to the jobserver when it is dropped and
/// otherwise represents the ability to spawn off another thread of work.
drop_without_releasing/// This drops the [`Acquired`] token without releasing the associated token.
/// This is not generally useful, but can be helpful if you do not have the
/// ability to store an Acquired token but need to not yet release it.
/// You'll typically want to follow this up with a call to
/// [`Client::release_raw`] or similar to actually release the token later on.
HelperInnerHelperStaterequestsproducer_doneconsumer_done/// Result of trying to get jobserver client from env.
/// Name and value of the environment variable.
/// `None` if no relevant environment variable is found.
FromEnv/// Return type for [`Client::from_env_ext`] function.
new_oknew_err/// Creates a new jobserver initialized with the given parallelism limit.
/// A client to the jobserver created will be returned. This client will
/// allow at most `limit` tokens to be acquired from it in parallel. More
/// calls to [`Client::acquire`] will cause the calling thread to block.
/// Note that the created [`Client`] is not automatically inherited into
/// spawned child processes from this program. Manual usage of the
/// [`Client::configure`] function is required for a child process to have
/// access to a job server.
/// use jobserver::Client;
/// let client = Client::new(4).expect("failed to create jobserver");
/// # Errors
/// Returns an error if any I/O error happens when attempting to create the
/// jobserver client.
from_env_ext/// Attempts to connect to the jobserver specified in this process's
/// environment.
/// When the a `make` executable calls a child process it will configure the
/// environment of the child to ensure that it has handles to the jobserver
/// it's passing down. This function will attempt to look for these details
/// and connect to the jobserver.
/// # Return value
/// [`FromEnv`] contains result and relevant environment variable.
/// If a jobserver was found in the environment and it looks correct then
/// result with the connected client will be returned. In other cases
/// result will contain `Err(FromEnvErr)`.
/// Additionally on Unix this function will configure the file descriptors
/// with `CLOEXEC` so they're not automatically inherited by spawned
/// children.
/// On unix if `check_pipe` enabled this function will check if provided
/// files are actually pipes.
/// # Safety
/// This function is `unsafe` to call on Unix specifically as it
/// transitively requires usage of the `from_raw_fd` function, which is
/// itself unsafe in some circumstances.
/// It's recommended to call this function very early in the lifetime of a
/// program before any other file descriptors are opened. That way you can
/// make sure to take ownership properly of the file descriptors passed
/// down, if any.
/// It is ok to call this function any number of times.
/// Wraps [`Client::from_env_ext`] and discards error details.
/// Acquires a token from this jobserver client.
/// This function will block the calling thread until a new token can be
/// acquired from the jobserver.
/// On successful acquisition of a token an instance of [`Acquired`] is
/// returned. This structure, when dropped, will release the token back to
/// the jobserver. It's recommended to avoid leaking this value.
/// If an I/O error happens while acquiring a token then this function will
/// return immediately with the error. If an error is returned then a token
/// was not acquired.
/// Acquires a token from this jobserver client in a non-blocking way.
/// If non-blocking acquire is not supported, the return error will have its `kind()`
/// set to [`io::ErrorKind::Unsupported`].
/// Returns amount of tokens in the read-side pipe.
/// Number of bytes available to be read from the jobserver pipe
/// Underlying errors from the ioctl will be passed up.
/// Configures a child process to have access to this client's jobserver as
/// well.
/// This function is required to be called to ensure that a jobserver is
/// properly inherited to a child process. If this function is *not* called
/// then this [`Client`] will not be accessible in the child process. In
/// other words, if not called, then [`Client::from_env`] will return `None`
/// in the child process (or the equivalent of [`Client::from_env`] that
/// `make` uses).
/// ## Platform-specific behavior
/// On Unix and Windows this will clobber the `CARGO_MAKEFLAGS` environment
/// variables for the child process, and on Unix this will also allow the
/// two file descriptors for this client to be inherited to the child.
/// On platforms other than Unix and Windows this panics.
configure_make/// On Unix and Windows this will clobber the `CARGO_MAKEFLAGS`,
/// `MAKEFLAGS` and `MFLAGS` environment variables for the child process,
/// and on Unix this will also allow the two file descriptors for
/// this client to be inherited to the child.
mflags_envinto_helper_thread/// Converts this [`Client`] into a helper thread to deal with a blocking
/// [`Client::acquire`] function a little more easily.
/// The fact that the [`Client::acquire`] isn't always the easiest to work
/// with. Typically you're using a jobserver to manage running other events
/// in parallel! This means that you need to either (a) wait for an existing
/// job to finish or (b) wait for a new token to become available.
/// Unfortunately the blocking in [`Client::acquire`] happens at the
/// implementation layer of jobservers. On Unix this requires a blocking
/// call to `read` and on Windows this requires one of the `WaitFor*`
/// functions. Both of these situations aren't the easiest to deal with:
/// * On Unix there's basically only one way to wake up a `read` early, and
///   that's through a signal. This is what the `make` implementation
///   itself uses, relying on `SIGCHLD` to wake up a blocking acquisition
///   of a new job token. Unfortunately nonblocking I/O is not an option
///   here, so it means that "waiting for one of two events" means that
///   the latter event must generate a signal! This is not always the case
///   on unix for all jobservers.
/// * On Windows you'd have to basically use the `WaitForMultipleObjects`
///   which means that you've got to canonicalize all your event sources
///   into a `HANDLE` which also isn't the easiest thing to do
///   unfortunately.
/// This function essentially attempts to ease these limitations by
/// converting this [`Client`] into a helper thread spawned into this
/// process. The application can then request that the helper thread
/// acquires tokens and the provided closure will be invoked for each token
/// acquired.
/// The intention is that this function can be used to translate the event
/// of a token acquisition into an arbitrary user-defined event.
/// # Arguments
/// This function will consume the [`Client`] provided to be transferred to
/// the helper thread that is spawned. Additionally a closure `f` is
/// provided to be invoked whenever a token is acquired.
/// This closure is only invoked after calls to
/// [`HelperThread::request_token`] have been made and a token itself has
/// been acquired. If an error happens while acquiring the token then
/// an error will be yielded to the closure as well.
/// # Return Value
/// This function will return an instance of the [`HelperThread`] structure
/// which is used to manage the helper thread associated with this client.
/// Through the [`HelperThread`] you'll request that tokens are acquired.
/// When acquired, the closure provided here is invoked.
/// When the [`HelperThread`] structure is returned it will be gracefully
/// torn down, and the calling thread will be blocked until the thread is
/// torn down (which should be prompt).
/// This function may fail due to creation of the helper thread or
/// auxiliary I/O objects to manage the helper thread. In any of these
/// situations the error is propagated upwards.
/// # Platform-specific behavior
/// On Windows this function behaves pretty normally as expected, but on
/// Unix the implementation is... a little heinous. As mentioned above
/// we're forced into blocking I/O for token acquisition, namely a blocking
/// call to `read`. We must be able to unblock this, however, to tear down
/// the helper thread gracefully!
/// Essentially what happens is that we'll send a signal to the helper
/// thread spawned and rely on `EINTR` being returned to wake up the helper
/// thread. This involves installing a global `SIGUSR1` handler that does
/// nothing along with sending signals to that thread. This may cause
/// odd behavior in some applications, so it's recommended to review and
/// test thoroughly before using this.
acquire_raw/// Blocks the current thread until a token is acquired.
/// This is the same as [`Client::acquire`], except that it doesn't return
/// an RAII helper. If successful the process will need to guarantee that
/// [`Client::release_raw`] is called in the future.
release_raw/// Releases a jobserver token back to the original jobserver.
/// This is intended to be paired with [`Client::acquire_raw`] if it was
/// called, but in some situations it could also be called to relinquish a
/// process's implicit token temporarily which is then re-acquired later.
Helper/// Structure returned from [`Client::into_helper_thread`] to manage the lifetime
/// of the helper thread returned, see those associated docs for more info.
request_token/// Request that the helper thread acquires a token, eventually calling the
/// original closure with a token when it's available.
/// For more information, see the docs on [`Client::into_helper_thread`].
for_each_request/// Executes `f` for each request for a token, where `f` is expected to
/// block and then provide the original closure with a token once it's
/// This is an infinite loop until the helper thread is dropped, at which
/// point everything should get interrupted.
find_jobserver_auth/// Finds and returns the value of `--jobserver-auth=<VALUE>` in the given
/// environment variable.
/// Precedence rules:
/// * The last instance wins [^1].
/// * `--jobserver-fds=` as a fallback when no `--jobserver-auth=` is present [^2].
/// [^1]: See ["GNU `make` manual: Sharing Job Slots with GNU `make`"](https://www.gnu.org/software/make/manual/make.html#Job-Slots)
/// _"Be aware that the `MAKEFLAGS` variable may contain multiple instances of
/// the `--jobserver-auth=` option. Only the last instance is relevant."_
/// [^2]: Refer to [the release announcement](https://git.savannah.gnu.org/cgit/make.git/tree/NEWS?h=4.2#n31)
/// of GNU Make 4.2, which states that `--jobserver-fds` was initially an
/// internal-only flag and was later renamed to `--jobserver-auth`.
run_named_fifo_try_acquire_testsno_helper_deadlocktest_find_jobserver_auth//! An implementation of the GNU make jobserver.
//! This crate is an implementation, in Rust, of the GNU `make` jobserver for
//! CLI tools that are interoperating with make or otherwise require some form
//! of parallelism limiting across process boundaries. This was originally
//! written for usage in Cargo to both (a) work when `cargo` is invoked from
//! `make` (using `make`'s jobserver) and (b) work when `cargo` invokes build
//! scripts, exporting a jobserver implementation for `make` processes to
//! transitively use.
//! The jobserver implementation can be found in [detail online][docs] but
//! basically boils down to a cross-process semaphore. On Unix this is
//! implemented with the `pipe` syscall and read/write ends of a pipe and on
//! Windows this is implemented literally with IPC semaphores. Starting from
//! GNU `make` version 4.4, named pipe becomes the default way in communication
//! on Unix. This crate also supports that feature in the sense of inheriting
//! and forwarding the correct environment.
//! The jobserver protocol in `make` also dictates when tokens are acquired to
//! run child work, and clients using this crate should take care to implement
//! such details to ensure correct interoperation with `make` itself.
//! Connect to a jobserver that was set up by `make` or a different process:
//! use jobserver::Client;
//! // See API documentation for why this is `unsafe`
//! let client = match unsafe { Client::from_env() } {
//!     Some(client) => client,
//!     None => panic!("client not configured"),
//! };
//! Acquire and release token from a jobserver:
//! let client = unsafe { Client::from_env().unwrap() };
//! let token = client.acquire().unwrap(); // blocks until it is available
//! drop(token); // releases the token when the work is done
//! Create a new jobserver and configure a child process to have access:
//! use std::process::Command;
//! let client = Client::new(4).expect("failed to create jobserver");
//! let mut cmd = Command::new("make");
//! client.configure(&mut cmd);
//! ## Caveats
//! This crate makes no attempt to release tokens back to a jobserver on
//! abnormal exit of a process. If a process which acquires a token is killed
//! with ctrl-c or some similar signal then tokens will not be released and the
//! jobserver may be in a corrupt state.
//! Note that this is typically ok as ctrl-c means that an entire build process
//! is being torn down, but it's worth being aware of at least!
//! ## Windows caveats
//! There appear to be two implementations of `make` on Windows. On MSYS2 one
//! typically comes as `mingw32-make` and the other as `make` itself. I'm not
//! personally too familiar with what's going on here, but for jobserver-related
//! information the `mingw32-make` implementation uses Windows semaphores
//! whereas the `make` program does not. The `make` program appears to use file
//! descriptors and I'm not really sure how it works, so this crate is not
//! compatible with `make` on Windows. It is, however, compatible with
//! `mingw32-make`.
//! [docs]: https://make.mad-scientist.net/papers/jobserver-implementation/
/// `--jobserver-auth=R,W`
/// it can only go from false -> true but not the other way around, since that
///  could cause a race condition.
/// `--jobserver-auth=fifo:PATH`
from_fifofrom_pipefrom_fds/// Gets the read end of our jobserver client.
/// Gets the write end of our jobserver client.
acquire_allow_interrupts/// Block waiting for a token, returning `None` if we're interrupted with
/// EINTR.
string_argspawn_helperfcntl_checkfd_checkclone_fd_and_set_cloexecset_cloexecsigusr1_handlersiginfo_tClientImpfrom_imp_clienttest_try_acquire_named_fifosemERROR_ALREADY_EXISTSSYNCHRONIZESetEventWaitForMultipleObjectsOpenSemaphoreA// Note that we ideally would use the `getrandom` crate, but unfortunately
// that causes build issues when this crate is used in rust-lang/rust (see
// rust-lang/rust#65014 for more information). As a result we just inline
// the pretty simple Windows-specific implementation of generating
// randomness.
// HANDLE is a raw ptr, but we're send/sync
ssse3is_x86_feature_detectedget_color_convert_line_ycbcr/// Arch-specific implementation of YCbCr conversion. Returns the number of pixels that were/// converted.get_dequantize_and_idct_block_8x8/// Arch-specific implementation of 8x8 IDCT.idct8transpose8dequantize_and_idct_block_8x8color_convert_line_ycbcrMAX_COMPONENTSHuffmanDecoderMarkerPredictorScanInfodecode_scan_lossless/// decode_scan_losslesspredict/// H.1.2.1compute_image_losslessconvert_to_u8UnsupportedFeaturefill_default_mjpeg_tablesHuffmanTableparse_appparse_comparse_dhtparse_dqtparse_driparse_sofparse_sosAdobeColorTransformAppDataCodingProcessDimensionsEntropyCodingIccChunkupsamplerUpsamplercompute_image_parallelPreferWorkerKindRowDataWorkerScope/// Luminance (grayscale), 8 bits/// Luminance (grayscale), 16 bits/// RGB, 8 bits per channelCMYK32/// CMYK, 8 bits per channel/// An enumeration over combinations of color spaces and bit depths a pixel can have./// Determine the size in bytes of each pixel in this format/// The width of the image, in pixels./// The height of the image, in pixels./// The pixel format of the image.coding_process/// The coding process of the image./// Represents metadata of an image./// No transform should be applied and the data is returned as-is./// Unknown colour transformation/// Grayscale transform should be applied (expects 1 channel)/// RGB transform should be applied.YCbCr/// YCbCr transform should be applied.CMYK/// CMYK transform should be applied.YCCK/// YCCK transform should be applied.JcsBgYcc/// big gamut Y/Cb/Cr, bg-sYCCJcsBgRgb/// big gamut red/green/blue, bg-sRGB/// Describes the colour transform to apply before binary data is returneddc_huffman_tablesac_huffman_tablesquantization_tablesrestart_intervaladobe_color_transformis_jfifis_mjpegicc_markersexif_dataxmp_datapsir_datacoefficients// Used for progressive JPEGs.coefficients_finished// Bitmask of which coefficients has been completely decoded.decoding_buffer_size_limit// Maximum allowed size of decoded image buffer/// Creates a new `Decoder` using the reader `reader`.set_color_transform/// Colour transform to use when decoding the image. App segments relating to colour transformsset_max_decoding_buffer_size/// Set maximum buffer size allowed for decoded images/// Returns metadata about the image./// The returned value will be `None` until a call to either `read_info` or `decode` has/// returned `Ok`./// Returns raw exif data, starting at the TIFF header, if the image contains any./// The returned value will be `None` until a call to `decode` has returned `Ok`.    /// Returns the raw XMP packet if there is any./// The returned value will be `None` until a call to `decode` has returned `Ok`./// Returns the embeded icc profile if the image contains one.select_worker/// Heuristic to avoid starting thread, synchronization if we expect a small amount of/// parallelism to be utilized./// Tries to read metadata from the image without decoding it./// If successful, the metadata can be obtained using the `info` method./// This efficiently scales the image by the smallest supported scale/// factor that produces an image larger than or equal to the requested/// size in at least one axis. The currently implemented scale factors/// are 1/8, 1/4, 1/2 and 1./// To generate a thumbnail of an exact size, pass the desired size and/// then scale to the final size using a traditional resampling algorithm./// Decodes the image and returns the decoded pixels if successful.decode_internaldecode_planesdetermine_color_transformread_markerdecode_scandecode_block_successive_approximationrefine_non_zeroescompute_imagechoose_color_convert_funccolor_convert_line_rgbcolor_convert_line_ycckcolor_convert_line_cmykcolor_no_convertFIXED_POINT_OFFSETHALFycbcr_to_rgb// ITU-R BT.601// Based on libjpeg-turbo's jdcolext.cstbi_f2fclamp_fixed_pointHierarchical/// Hierarchical JPEG.ArithmeticEntropyCoding/// JPEG using arithmetic entropy coding instead of Huffman coding.SamplePrecision/// Sample precision in bits. 8 bit sample precision is what is currently supported in non-lossless coding process.ComponentCount/// Number of components in an image. 1, 3 and 4 components are currently supported.DNL/// An image can specify a zero height in the frame header and use the DNL (Define Number of/// Lines) marker at the end of the first scan to define the number of lines in the frame.SubsamplingRatio/// Subsampling ratio.NonIntegerSubsamplingRatio/// A subsampling ratio not representable as an integer./// Colour transform/// An enumeration over JPEG features (currently) unsupported by this library./// Support for features listed here may be included in future versions of this library./// The image is not formatted properly. The string contains detailed information about the/// The image makes use of a JPEG feature not (currently) supported by this library./// An I/O error occurred while decoding the image./// An internal error occurred while decoding the image.//TODO: not used, can be removed with the next version bump/// Errors that can occur while decoding a JPEG image.LUT_BITSnum_bits// Section F.2.2.3// Figure F.16decode_fast_acreceive_extendtake_markerpeek_bits// Section F.2.2.1// Figure F.12HuffmanTableClassmaxcodelutac_lutderive_huffman_codes// Section C.2// https://www.loc.gov/preservation/digital/formats/fdd/fdd000063.shtml// "Avery Lee, writing in the rec.video.desktop newsgroup in 2001, commented that "MJPEG, or at//  least the MJPEG in AVIs having the MJPG fourcc, is restricted JPEG with a fixed -- and//  *omitted* -- Huffman table. The JPEG must be YCbCr colorspace, it must be 4:2:2, and it must//  use basic Huffman encoding, not arithmetic or progressive.... You can indeed extract the//  MJPEG frames and decode them with a regular JPEG decoder, but you have to prepend the DHT//  segment to them, or else the decoder won't have any idea how to decompress the data.//  The exact table necessary is given in the OpenDML spec.""choose_idct_sizetest_choose_idct_sizedequantize_and_idct_blockdequantize_and_idct_block_8x8_inner// This is based on stb_image's 'stbi__idct_block'.kernel_xkernel_tdequantizedequantize_and_idct_block_4x4// 4x4 and 2x2 IDCT based on Rakesh Dugad and Narendra Ahuja: "A Fast Scheme for Image Size Change in the Compressed Domain" (2001).// http://sylvana.net/jpegcrop/jidctred/dequantize_and_idct_block_2x2dequantize_and_idct_block_1x1stbi_clamp// take a -128..127 value and stbi__clamp it and convert to 0..255stbi_fshtest_dequantize_and_idct_block_8x8test_dequantize_and_idct_block_8x8_all_zerotest_dequantize_and_idct_block_8x8_saturated// Malicious JPEG files can cause operations in the idct to overflow.// One example is tests/crashtest/images/imagetestsuite/b0b8914cc5f7a6eff409f16d8cc236c5.jpg// That's why wrapping operators are needed.// Note: we have many values that are straight from a reference.// Do not warn on them or try to automatically change them.// Note: consistency for unrolled, scaled offset loopsidctread_u16_from_be//! This crate contains a JPEG decoder.//! use jpeg_decoder::Decoder;//! let file = File::open("tests/reftest/images/extraneous-data.jpg").expect("failed to open file");//! let mut decoder = Decoder::new(BufReader::new(file));//! let pixels = decoder.decode().expect("failed to decode image");//! let metadata = decoder.info().unwrap();//! Get metadata from a file without decoding it://! decoder.read_info().expect("failed to read metadata");SOF/// Start Of Frame markers/// - SOF(0):  Baseline DCT (Huffman coding)/// - SOF(1):  Extended sequential DCT (Huffman coding)/// - SOF(2):  Progressive DCT (Huffman coding)/// - SOF(3):  Lossless (sequential) (Huffman coding)/// - SOF(5):  Differential sequential DCT (Huffman coding)/// - SOF(6):  Differential progressive DCT (Huffman coding)/// - SOF(7):  Differential lossless (sequential) (Huffman coding)/// - SOF(9):  Extended sequential DCT (arithmetic coding)/// - SOF(10): Progressive DCT (arithmetic coding)/// - SOF(11): Lossless (sequential) (arithmetic coding)/// - SOF(13): Differential sequential DCT (arithmetic coding)/// - SOF(14): Differential progressive DCT (arithmetic coding)/// - SOF(15): Differential lossless (sequential) (arithmetic coding)/// Reserved for JPEG extensions/// Define Huffman table(s)/// Define arithmetic coding conditioning(s)/// Restart with modulo 8 count `m`/// Start of image/// End of image/// Start of scan/// Define quantization table(s)/// Define number of linesDRI/// Define restart intervalDHP/// Define hierarchical progressionEXP/// Expand reference component(s)APP/// Reserved for application segmentsJPGnCOM/// CommentTEM/// For temporary private use in arithmetic codingRES/// Reserved// Table B.1// Note: Established names.has_lengthArithmeticDctSequential/// Sequential Discrete Cosine TransformDctProgressive/// Progressive Discrete Cosine Transform/// Lossless/// Represents the coding process of an image.NoPredictionRaRbRaRbRc1RaRbRc2// Ra + Rb - RcRaRbRc3// Ra + ((Rb - Rc) >> 1)RaRb// Rb + ((Ra - Rb) >> 1)// (Ra + Rb)/2// Table H.1is_baselineis_differentialentropy_codingmcu_sizecomponent_indicesdc_table_indicesac_table_indicesspectral_selectionpredictor_selectionsuccessive_approximation_high// for losslesssuccessive_approximation_lowpoint_transformhorizontal_sampling_factorvertical_sampling_factorquantization_table_indexdct_scaleAdobeJfifAvi1IccExifXmpPsir// RGB or CMYK// YCbCrK// http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobenum_markersseq_noupdate_idct_size// Section B.2.2ceil_div/// Returns ceil(x/y), requires x>0update_component_sizestest_update_component_sizes// Section B.2.3// Section B.2.4.1// Section B.2.4.2// Section B.2.4.4// Section B.2.4.5// Section B.2.4.6UpsamplerComponentline_buffer_sizeUpsampleupsample_and_interleave_rowUpsamplerH1V1UpsamplerH2V1UpsamplerH1V2UpsamplerH2V2horizontal_scaling_factorvertical_scaling_factorUpsamplerGenericchoose_upsamplerupsample_row// Uses nearest neighbor samplingImmediateWorkerstart_immediateappend_row_immediateget_result_immediateappend_rowmultithreadedquantization_tableappend_rows/// Default implementation for spawning multiple tasks.MultithreadedWorkerScopeInnerScopedRayonMpscWorkerget_or_init_workerWorkerMsgAppendRowGetResultstart_withget_result_withcreate_workerspawn_worker_threadcollect_worker_thread//! This module implements per-component parallelism.//! It should be possible to implement per-row parallelism as well,//! which should also boost performance of grayscale images//! and allow scaling to more cores.//! However, that would be more complex, so we use this as a starting point./// Technically similar to `immediate::ImmediateWorker` but we copy it since we may prefer/// different style of managing the memory allocation, something that multiple actors can access inblock_widthblock_countline_strideComponentMetadatacomponent_metadataappend_row_locked// Magic sauce, these _may_ run in parallel.bytes_used/// <code class="keycap">`~</code> on a US keyboard. This is the <code class="keycap">半角/全角/漢字</code> (<span class="unicode">hankaku/zenkaku/kanji</span>) key on Japanese keyboards/// Used for both the US <code class="keycap">\|</code> (on the 101-key layout) and also for the key/// located between the <code class="keycap">"</code> and <code class="keycap">Enter</code> keys on row C of the 102-,/// Labelled <code class="keycap">#~</code> on a UK (102) keyboard./// <code class="keycap">[{</code> on a US keyboard./// <code class="keycap">]}</code> on a US keyboard./// <code class="keycap">,&lt;</code> on a US keyboard./// <code class="keycap">0)</code> on a US keyboard./// <code class="keycap">1!</code> on a US keyboard./// <code class="keycap">2@</code> on a US keyboard./// <code class="keycap">3#</code> on a US keyboard./// <code class="keycap">4$</code> on a US keyboard./// <code class="keycap">5%</code> on a US keyboard./// <code class="keycap">6^</code> on a US keyboard./// <code class="keycap">7&amp;</code> on a US keyboard./// <code class="keycap">8*</code> on a US keyboard./// <code class="keycap">9(</code> on a US keyboard./// <code class="keycap">=+</code> on a US keyboard./// Located between the left <code class="keycap">Shift</code> and <code class="keycap">Z</code> keys./// Labelled <code class="keycap">\|</code> on a UK keyboard./// Located between the <code class="keycap">/</code> and right <code class="keycap">Shift</code> keys./// Labelled <code class="keycap">\ろ</code> (<span class="unicode">ro</span>) on a Japanese keyboard./// Located between the <code class="keycap">=</code> and <code class="keycap">Backspace</code> keys./// Labelled <code class="keycap">¥</code> (<span class="unicode">yen</span>) on a Japanese keyboard. <code class="keycap">\/</code> on a/// <code class="keycap">a</code> on a US keyboard./// Labelled <code class="keycap">q</code> on an AZERTY (e.g., French) keyboard./// <code class="keycap">b</code> on a US keyboard./// <code class="keycap">c</code> on a US keyboard./// <code class="keycap">d</code> on a US keyboard./// <code class="keycap">e</code> on a US keyboard./// <code class="keycap">f</code> on a US keyboard./// <code class="keycap">g</code> on a US keyboard./// <code class="keycap">h</code> on a US keyboard./// <code class="keycap">i</code> on a US keyboard./// <code class="keycap">j</code> on a US keyboard./// <code class="keycap">k</code> on a US keyboard./// <code class="keycap">l</code> on a US keyboard./// <code class="keycap">m</code> on a US keyboard./// <code class="keycap">n</code> on a US keyboard./// <code class="keycap">o</code> on a US keyboard./// <code class="keycap">p</code> on a US keyboard./// <code class="keycap">q</code> on a US keyboard./// Labelled <code class="keycap">a</code> on an AZERTY (e.g., French) keyboard./// <code class="keycap">r</code> on a US keyboard./// <code class="keycap">s</code> on a US keyboard./// <code class="keycap">t</code> on a US keyboard./// <code class="keycap">u</code> on a US keyboard./// <code class="keycap">v</code> on a US keyboard./// <code class="keycap">w</code> on a US keyboard./// Labelled <code class="keycap">z</code> on an AZERTY (e.g., French) keyboard./// <code class="keycap">x</code> on a US keyboard./// <code class="keycap">y</code> on a US keyboard./// Labelled <code class="keycap">z</code> on a QWERTZ (e.g., German) keyboard./// <code class="keycap">z</code> on a US keyboard./// Labelled <code class="keycap">w</code> on an AZERTY (e.g., French) keyboard, and <code class="keycap">y</code> on a/// <code class="keycap">-_</code> on a US keyboard./// <code class="keycap">.></code> on a US keyboard./// <code class="keycap">'"</code> on a US keyboard./// <code class="keycap">;:</code> on a US keyboard./// <code class="keycap">/?</code> on a US keyboard./// <code class="keycap">Alt</code>, <code class="keycap">Option</code> or <code class="keycap">⌥</code>./// This is labelled <code class="keycap">AltGr</code> key on many keyboard layouts./// <code class="keycap">Backspace</code> or <code class="keycap">⌫</code>./// Labelled <code class="keycap">Delete</code> on Apple keyboards./// <code class="keycap">CapsLock</code> or <code class="keycap">⇪</code>/// The application context menu key, which is typically found between the right <code class="keycap">Meta</code> key and the right <code class="keycap">Control</code> key./// <code class="keycap">Control</code> or <code class="keycap">⌃</code>/// <code class="keycap">Enter</code> or <code class="keycap">↵</code>. Labelled <code class="keycap">Return</code> on Apple keyboards./// The Windows, <code class="keycap">⌘</code>, <code class="keycap">Command</code> or other OS symbol key./// <code class="keycap">Shift</code> or <code class="keycap">⇧</code>/// <code class="keycap"> </code> (space)/// <code class="keycap">Tab</code> or <code class="keycap">⇥</code>/// Japanese: <code class="keycap">変換</code> (<span class="unicode">henkan</span>)/// Japanese: <code class="keycap">カタカナ/ひらがな/ローマ字</code> (<span class="unicode">katakana/hiragana/romaji</span>)/// Korean: HangulMode <code class="keycap">한/영</code> (<span class="unicode">han/yeong</span>)<br>Japanese (Mac keyboard): <code class="keycap">かな</code> (<span class="unicode">kana</span>)/// Korean: Hanja <code class="keycap">한자</code> (<span class="unicode">hanja</span>)<br>Japanese (Mac keyboard): <code class="keycap">英数</code> (<span class="unicode">eisu</span>)/// Japanese: <code class="keycap">無変換</code> (<span class="unicode">muhenkan</span>)/// <code class="keycap">⌦</code>. The forward delete key./// Note that on Apple keyboards, the key labelled <code class="keycap">Delete</code> on the main part of/// the keyboard should be encoded as <code class="code">"Backspace"</code>./// <code class="keycap">End</code> or <code class="keycap">↘</code>/// <code class="keycap">Help</code>. Not present on standard PC keyboards./// <code class="keycap">Home</code> or <code class="keycap">↖</code>/// <code class="keycap">Insert</code> or <code class="keycap">Ins</code>. Not present on Apple keyboards./// <code class="keycap">Page Down</code>, <code class="keycap">PgDn</code> or <code class="keycap">⇟</code>/// <code class="keycap">Page Up</code>, <code class="keycap">PgUp</code> or <code class="keycap">⇞</code>/// <code class="keycap">↓</code>/// <code class="keycap">←</code>/// <code class="keycap">→</code>/// <code class="keycap">↑</code>/// On the Mac, the <code class="code">"NumLock"</code> code should be used for the numpad <code class="keycap">Clear</code> key./// <code class="keycap">0 Ins</code> on a keyboard<br><code class="keycap">0</code> on a phone or remote control/// <code class="keycap">1 End</code> on a keyboard<br><code class="keycap">1</code> or <code class="keycap">1 QZ</code> on a phone or/// remote control/// <code class="keycap">2 ↓</code> on a keyboard<br><code class="keycap">2 ABC</code> on a phone or remote control/// <code class="keycap">3 PgDn</code> on a keyboard<br><code class="keycap">3 DEF</code> on a phone or remote control/// <code class="keycap">4 ←</code> on a keyboard<br><code class="keycap">4 GHI</code> on a phone or remote control/// <code class="keycap">5</code> on a keyboard<br><code class="keycap">5 JKL</code> on a phone or remote control/// <code class="keycap">6 →</code> on a keyboard<br><code class="keycap">6 MNO</code> on a phone or remote control/// <code class="keycap">7 Home</code> on a keyboard<br><code class="keycap">7 PQRS</code> or <code class="keycap">7 PRS</code> on a phone/// <code class="keycap">8 ↑</code> on a keyboard<br><code class="keycap">8 TUV</code> on a phone or remote control/// <code class="keycap">9 PgUp</code> on a keyboard<br><code class="keycap">9 WXYZ</code> or <code class="keycap">9 WXY</code> on a phone/// <code class="keycap">+</code>/// <code class="keycap">C</code> or <code class="keycap">AC</code> (All Clear). Also for use with numpads that have a <code class="keycap">Clear</code> key that is separate from the <code class="keycap">NumLock</code> key. On the Mac, the numpad <code class="keycap">Clear</code> key should always/// be encoded as <code class="code">"NumLock"</code>./// <code class="keycap">CE</code> (Clear Entry)/// <code class="keycap">,</code> (thousands separator). For locales where the thousands separator/// is a "." (e.g., Brazil), this key may generate a <code class="keycap">.</code>./// <code class="keycap">. Del</code>. For locales where the decimal separator is "," (e.g.,/// Brazil), this key may generate a <code class="keycap">,</code>./// <code class="keycap">/</code>/// <code class="keycap">=</code>/// <code class="keycap">#</code> on a phone or remote control device. This key is typically found/// below the <code class="keycap">9</code> key and to the right of the <code class="keycap">0</code> key./// <code class="keycap">M+</code> Add current entry to the value stored in memory./// <code class="keycap">MC</code> Clear the value stored in memory./// <code class="keycap">MR</code> Replace the current entry with the value stored in memory./// <code class="keycap">MS</code> Replace the value stored in memory with the current entry./// <code class="keycap">M-</code> Subtract current entry from the value stored in memory./// <code class="keycap">*</code> on a keyboard. For use with numpads that provide mathematical/// operations (<code class="keycap">+</code>, <code class="keycap">-</code>, <code class="keycap">*</code> and <code class="keycap">/</code>).<br>Use <code class="code">"NumpadStar"</code> for the <code class="keycap">*</code> key on phones and remote controls./// <code class="keycap">(</code> Found on the Microsoft Natural Keyboard./// <code class="keycap">)</code> Found on the Microsoft Natural Keyboard./// <code class="keycap">*</code> on a phone or remote control device./// This key is typically found below the <code class="keycap">7</code> key and to the left of/// the <code class="keycap">0</code> key.<br>Use <code class="code">"NumpadMultiply"</code> for the <code class="keycap">*</code> key on/// <code class="keycap">-</code>/// <code class="keycap">Esc</code> or <code class="keycap">⎋</code>/// <code class="keycap">Fn</code> This is typically a hardware key that does not generate a separate/// code. Most keyboards do not place this key in the function section, but it is/// included here to keep it with related keys./// <code class="keycap">FLock</code> or <code class="keycap">FnLock</code>. Function Lock key. Found on the Microsoft/// <code class="keycap">PrtScr SysRq</code> or <code class="keycap">Print Screen</code>/// <code class="keycap">Scroll Lock</code>/// <code class="keycap">Pause Break</code>/// Some laptops place this key to the left of the <code class="keycap">↑</code> key./// Some laptops place this key to the right of the <code class="keycap">↑</code> key./// <code class="keycap">Eject</code> or <code class="keycap">⏏</code>. This key is placed in the <a data-link-type="dfn" href="#function-section" id="ref-for-function-section①①">function/// section</a> on some Apple keyboards./// Sometimes labelled <code class="keycap">My Computer</code> on the keyboard/// Sometimes labelled <code class="keycap">Calculator</code> on the keyboard/// This key is placed in the function section on some Apple keyboards,/// replacing the <code class="keycap">Eject</code> key./// Use for dedicated <code class="keycap">ひらがな</code> key found on some Japanese word processing keyboards./// Use for dedicated <code class="keycap">カタカナ</code> key found on some Japanese word processing keyboards./// This value code should be used when no other/// value given in this specification is appropriate./// <code class="keycap">F1</code>/// <code class="keycap">F2</code>/// <code class="keycap">F3</code>/// <code class="keycap">F4</code>/// <code class="keycap">F5</code>/// <code class="keycap">F6</code>/// <code class="keycap">F7</code>/// <code class="keycap">F8</code>/// <code class="keycap">F9</code>/// <code class="keycap">F10</code>/// <code class="keycap">F11</code>/// <code class="keycap">F12</code>/// <code class="keycap">F13</code>/// <code class="keycap">F14</code>/// <code class="keycap">F15</code>/// <code class="keycap">F16</code>/// <code class="keycap">F17</code>/// <code class="keycap">F18</code>/// <code class="keycap">F19</code>/// <code class="keycap">F20</code>/// <code class="keycap">F21</code>/// <code class="keycap">F22</code>/// <code class="keycap">F23</code>/// <code class="keycap">F24</code>/// <code class="keycap">F25</code>/// <code class="keycap">F26</code>/// <code class="keycap">F27</code>/// <code class="keycap">F28</code>/// <code class="keycap">F29</code>/// <code class="keycap">F30</code>/// <code class="keycap">F31</code>/// <code class="keycap">F32</code>/// <code class="keycap">F33</code>/// <code class="keycap">F34</code>/// <code class="keycap">F35</code>/// Non-standard code value supported by Chromium.DisplayToggleIntExtKeyboardLayoutSelectLaunchAssistantLaunchControlPanelMicrophoneMuteTogglePrivacyScreenToggleSelectTaskShowAllWindows/// Code is the physical position of a key./// The names are based on the US keyboard. If the key/// is not present on US keyboards a name from another/// layout is used./// Specification:/// <https://w3c.github.io/uievents-code/>UnrecognizedCodeError/// Parse from string error, returned when string does not match to any Code variant.// AUTO GENERATED CODE - DO NOT EDIT/// A key string that corresponds to the character typed by the user,/// taking into account the user’s current locale setting, modifier state,/// and any system-level keyboard mapping overrides that are in effect./// This key value is used when an implementation is unable to/// identify another key value, due to either hardware,/// platform, or software constraints./// The <code class="keycap">Alt</code> (Alternative) key.<br> This key enables the alternate modifier function for interpreting concurrent or subsequent keyboard input.<br> This key value is also used for the Apple <code class="keycap">Option</code> key./// The Alternate Graphics (<code class="keycap">AltGr</code> or <code class="keycap">AltGraph</code>) key./// This key is used enable the ISO Level 3 shift modifier (the standard <code class="keycap">Shift</code> key is the level 2 modifier)./// See [ISO9995-1]./// The <code class="keycap">Caps Lock</code> (Capital) key./// The <code class="keycap">Control</code> or <code class="keycap">Ctrl</code> key, to enable control modifier function for interpreting concurrent or subsequent keyboard input./// The Function switch <code class="keycap">Fn</code> key.<br> Activating this key simultaneously with another key changes that key’s value to an alternate character or function./// This key is often handled directly in the keyboard hardware and does not usually generate key events./// The Function-Lock (<code class="keycap">FnLock</code> or <code class="keycap">F-Lock</code>) key./// Activating this key switches the mode of the keyboard to changes some keys' values to an alternate character or function./// The <code class="keycap">Meta</code> key, to enable meta modifier function for interpreting concurrent or subsequent keyboard input./// This key value is used for the <q>Windows Logo</q> key and the Apple <code class="keycap">Command</code> or <code class="keycap">⌘</code> key./// The <code class="keycap">NumLock</code> or Number Lock key, to toggle numpad mode function for interpreting subsequent keyboard input./// The <code class="keycap">Scroll Lock</code> key, to toggle between scrolling and cursor movement modes./// The <code class="keycap">Shift</code> key, to enable shift modifier function for interpreting concurrent or subsequent keyboard input./// The Symbol Lock key./// The <code class="keycap">Hyper</code> key./// The <code class="keycap">Super</code> key./// The <code class="keycap">Enter</code> or <code class="keycap">↵</code> key, to activate current selection or accept current input.<br> This key value is also used for the <code class="keycap">Return</code> (Macintosh numpad) key.<br> This key value is also used for the Android <code class="android">KEYCODE_DPAD_CENTER</code>./// The Horizontal Tabulation <code class="keycap">Tab</code> key./// The down arrow key, to navigate or traverse downward. (<code class="android">KEYCODE_DPAD_DOWN</code>)/// The left arrow key, to navigate or traverse leftward. (<code class="android">KEYCODE_DPAD_LEFT</code>)/// The right arrow key, to navigate or traverse rightward. (<code class="android">KEYCODE_DPAD_RIGHT</code>)/// The up arrow key, to navigate or traverse upward. (<code class="android">KEYCODE_DPAD_UP</code>)/// The End key, used with keyboard entry to go to the end of content (<code class="android">KEYCODE_MOVE_END</code>)./// The Home key, used with keyboard entry, to go to start of content (<code class="android">KEYCODE_MOVE_HOME</code>).<br> For the mobile phone <code class="keycap">Home</code> key (which goes to the phone’s main screen), use <code class="key">"GoHome"</code>./// The Page Down key, to scroll down or display next page of content./// The Page Up key, to scroll up or display previous page of content./// The Backspace key. This key value is also used for the key labeled <code class="keycap">Delete</code> on MacOS keyboards./// Copy the current selection. (<code class="appcommand">APPCOMMAND_COPY</code>)/// The Cursor Select (Crsel) key./// Cut the current selection. (<code class="appcommand">APPCOMMAND_CUT</code>)/// The Delete (Del) Key./// This key value is also used for the key labeled <code class="keycap">Delete</code> on MacOS keyboards when modified by the <code class="keycap">Fn</code> key./// The Erase to End of Field key./// This key deletes all characters from the current cursor position to the end of the current field./// The Insert (Ins) key, to toggle between text modes for insertion or overtyping. (<code class="android">KEYCODE_INSERT</code>)/// The Paste key. (<code class="appcommand">APPCOMMAND_PASTE</code>)/// Redo the last action. (<code class="appcommand">APPCOMMAND_REDO</code>)/// Undo the last action. (<code class="appcommand">APPCOMMAND_UNDO</code>)/// The Again key, to redo or repeat an action./// The Cancel key./// This key is commonly found between the right <code class="keycap">Meta</code> key and the right <code class="keycap">Control</code> key./// The <code class="keycap">Esc</code> key. This key was originally used to initiate an escape sequence, but is/// The Execute key./// Open the Find dialog. (<code class="appcommand">APPCOMMAND_FIND</code>)/// Open a help dialog or toggle display of help information. (<code class="appcommand"><code class="appcommand">APPCOMMAND_HELP</code></code>, <code class="android"><code class="android">KEYCODE_HELP</code></code>)/// <p class="note" role="note">Do not use this value for the <code class="keycap">Pause</code> button on media controllers. Use <code class="key">"MediaPause"</code> instead.</p>/// <p class="note" role="note">Do not use this value for the <code class="keycap">Play</code> button on media controllers. Use <code class="key">"MediaPlay"</code> instead.</p>/// The Select key./// The ZoomIn key. (<code class="android">KEYCODE_ZOOM_IN</code>)/// The ZoomOut key. (<code class="android">KEYCODE_ZOOM_OUT</code>)/// The Brightness Down key. Typically controls the display brightness. (<code class="android">KEYCODE_BRIGHTNESS_DOWN</code>)/// The Brightness Up key. Typically controls the display brightness. (<code class="android">KEYCODE_BRIGHTNESS_UP</code>)/// Toggle removable media to eject (open) and insert (close) state. (<code class="android">KEYCODE_MEDIA_EJECT</code>)/// The LogOff key./// Toggle power state. (<code class="android">KEYCODE_POWER</code>)/// <p class="note" role="note">Note: Some devices might not expose this key to the operating environment.</p>/// The <code class="keycap">PowerOff</code> key. Sometime called <code class="keycap">PowerDown</code>./// The <code class="keycap">Print Screen</code> or <code class="keycap">SnapShot</code> key, to initiate print-screen function./// The Hibernate key./// This key saves the current state of the computer to disk so that it can be restored. The computer will then shutdown./// The Standby key./// This key turns off the display and places the computer into a low-power mode without completely shutting down./// It is sometimes labelled <code class="keycap">Suspend</code> or <code class="keycap">Sleep</code> key. (<code class="android"><code class="android">KEYCODE_SLEEP</code></code>)/// The WakeUp key. (<code class="android">KEYCODE_WAKEUP</code>)/// The All Candidates key, to initate the multi-candidate mode./// The Alphanumeric key./// The Code Input key, to initiate the Code Input mode to allow characters to be entered by their code points./// The Compose key, also known as <em>Multi_key</em> on the X Window System./// This key acts in a manner similar to a/// dead key, triggering a mode where subsequent key presses are combined to produce a different character./// The Convert key, to convert the current input method sequence./// A dead key combining key. It may be any combining key from any keyboard layout. For example, on a/// PC/AT French keyboard, using a French mapping and without any modifier activiated, this is the key value <code class="unicode">U+0302</code> COMBINING CIRCUMFLEX ACCENT. In another layout this might be a different unicode combining key.<br> For applications that need to differentiate between specific combining characters, the associated compositionupdate event’s data attribute provides the specific key value./// The Final Mode <code class="keycap">Final</code> key used on some Asian keyboards, to enable the final mode for IMEs./// The Mode Change key, to toggle between or cycle through input modes of IMEs./// The Next Candidate function key./// The NonConvert ("Don’t Convert") key, to accept current input method sequence without conversion in IMEs./// The Previous Candidate function key./// The Process key./// The Single Candidate function key./// The Hangul (Korean characters) Mode key, to toggle between Hangul and English modes./// The Hanja (Korean characters) Mode key./// The Junja (Korean characters) Mode key./// The Eisu key. This key may close the IME, but its purpose/// is defined by the current IME. (<code class="android">KEYCODE_EISU</code>)/// The Hiragana/Katakana toggle key. (<code class="android">KEYCODE_KATAKANA_HIRAGANA</code>)/// The Kana Mode (Kana Lock) key. This key is used to enter/// hiragana mode (typically from romaji mode)./// The Kanji (Japanese name for ideographic characters of Chinese origin) Mode key./// This key is typically used to switch to a hiragana keyboard for/// the purpose of converting input into kanji. (<code class="android">KEYCODE_KANA</code>)/// The Zenkaku/Hankaku (full-width/half-width) toggle key. (<code class="android">KEYCODE_ZENKAKU_HANKAKU</code>)/// Select next (numerically or logically) lower channel. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_CHANNEL_DOWN</code></code>, <code class="android"><code class="android">KEYCODE_CHANNEL_DOWN</code></code>)/// Select next (numerically or logically) higher channel. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_CHANNEL_UP</code></code>, <code class="android"><code class="android">KEYCODE_CHANNEL_UP</code></code>)/// Close the current document or message (Note: This doesn’t close the application). (<code class="appcommand">APPCOMMAND_CLOSE</code>)/// Open an editor to forward the current message. (<code class="appcommand">APPCOMMAND_FORWARD_MAIL</code>)/// Open an editor to reply to the current message. (<code class="appcommand">APPCOMMAND_REPLY_TO_MAIL</code>)/// Send the current message. (<code class="appcommand">APPCOMMAND_SEND_MAIL</code>)/// Close the current media, for example to close a CD or DVD tray. (<code class="android">KEYCODE_MEDIA_CLOSE</code>)/// Initiate or continue forward playback at faster than normal speed, or increase speed if already fast forwarding. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_FAST_FORWARD</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_FAST_FORWARD</code></code>)/// Pause the currently playing media. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_PAUSE</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_PAUSE</code></code>)/// <p class="note" role="note">Media controller devices should use this value rather than <code class="key">"Pause"</code> for their pause keys.</p>/// Initiate or continue media playback at normal speed, if not currently playing at normal speed. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_PLAY</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_PLAY</code></code>)/// Toggle media between play and pause states. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_PLAY_PAUSE</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_PLAY_PAUSE</code></code>)/// Initiate or resume recording of currently selected media. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_RECORD</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_RECORD</code></code>)/// Initiate or continue reverse playback at faster than normal speed, or increase speed if already rewinding. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_REWIND</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_REWIND</code></code>)/// Stop media playing, pausing, forwarding, rewinding, or recording, if not already stopped. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_STOP</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_STOP</code></code>)/// Seek to next media or program track. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_NEXTTRACK</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_NEXT</code></code>)/// Seek to previous media or program track. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MEDIA_PREVIOUSTRACK</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_PREVIOUS</code></code>)/// Open a new document or message. (<code class="appcommand">APPCOMMAND_NEW</code>)/// Open an existing document or message. (<code class="appcommand">APPCOMMAND_OPEN</code>)/// Print the current document or message. (<code class="appcommand">APPCOMMAND_PRINT</code>)/// Save the current document or message. (<code class="appcommand">APPCOMMAND_SAVE</code>)/// Spellcheck the current document or selection. (<code class="appcommand">APPCOMMAND_SPELL_CHECK</code>)/// The <code class="keycap">11</code> key found on media numpads that/// have buttons from <code class="keycap">1</code> ... <code class="keycap">12</code>./// The <code class="keycap">12</code> key found on media numpads that/// Adjust audio balance leftward. (<code class="vk">VK_AUDIO_BALANCE_LEFT</code>)/// Adjust audio balance rightward. (<code class="vk">VK_AUDIO_BALANCE_RIGHT</code>)/// Decrease audio bass boost or cycle down through bass boost states. (<code class="appcommand"><code class="appcommand">APPCOMMAND_BASS_DOWN</code></code>, <code class="vk"><code class="vk">VK_BASS_BOOST_DOWN</code></code>)/// Toggle bass boost on/off. (<code class="appcommand">APPCOMMAND_BASS_BOOST</code>)/// Increase audio bass boost or cycle up through bass boost states. (<code class="appcommand"><code class="appcommand">APPCOMMAND_BASS_UP</code></code>, <code class="vk"><code class="vk">VK_BASS_BOOST_UP</code></code>)/// Adjust audio fader towards front. (<code class="vk">VK_FADER_FRONT</code>)/// Adjust audio fader towards rear. (<code class="vk">VK_FADER_REAR</code>)/// Advance surround audio mode to next available mode. (<code class="vk">VK_SURROUND_MODE_NEXT</code>)/// Decrease treble. (<code class="appcommand">APPCOMMAND_TREBLE_DOWN</code>)/// Increase treble. (<code class="appcommand">APPCOMMAND_TREBLE_UP</code>)/// Decrease audio volume. (<code class="appcommand"><code class="appcommand">APPCOMMAND_VOLUME_DOWN</code></code>, <code class="android"><code class="android">KEYCODE_VOLUME_DOWN</code></code>)/// Increase audio volume. (<code class="appcommand"><code class="appcommand">APPCOMMAND_VOLUME_UP</code></code>, <code class="android"><code class="android">KEYCODE_VOLUME_UP</code></code>)/// Toggle between muted state and prior volume level. (<code class="appcommand"><code class="appcommand">APPCOMMAND_VOLUME_MUTE</code></code>, <code class="android"><code class="android">KEYCODE_VOLUME_MUTE</code></code>)/// Toggle the microphone on/off. (<code class="appcommand">APPCOMMAND_MIC_ON_OFF_TOGGLE</code>)/// Decrease microphone volume. (<code class="appcommand">APPCOMMAND_MICROPHONE_VOLUME_DOWN</code>)/// Increase microphone volume. (<code class="appcommand">APPCOMMAND_MICROPHONE_VOLUME_UP</code>)/// Mute the microphone. (<code class="appcommand"><code class="appcommand">APPCOMMAND_MICROPHONE_VOLUME_MUTE</code></code>, <code class="android"><code class="android">KEYCODE_MUTE</code></code>)/// Show correction list when a word is incorrectly identified. (<code class="appcommand">APPCOMMAND_CORRECTION_LIST</code>)/// Toggle between dictation mode and command/control mode. (<code class="appcommand">APPCOMMAND_DICTATE_OR_COMMAND_CONTROL_TOGGLE</code>)/// The first generic "LaunchApplication" key. This is commonly associated with launching "My Computer", and may have a computer symbol on the key. (<code class="appcommand">APPCOMMAND_LAUNCH_APP1</code>)/// The second generic "LaunchApplication" key. This is commonly associated with launching "Calculator", and may have a calculator symbol on the key. (<code class="appcommand"><code class="appcommand">APPCOMMAND_LAUNCH_APP2</code></code>, <code class="android"><code class="android">KEYCODE_CALCULATOR</code></code>)/// The "Calendar" key. (<code class="android">KEYCODE_CALENDAR</code>)/// The "Contacts" key. (<code class="android">KEYCODE_CONTACTS</code>)/// The "Mail" key. (<code class="appcommand">APPCOMMAND_LAUNCH_MAIL</code>)/// The "Media Player" key. (<code class="appcommand">APPCOMMAND_LAUNCH_MEDIA_SELECT</code>)/// The "Music Player" key./// The "Phone" key./// The "Screen Saver" key./// The "Spreadsheet" key./// The "Web Browser" key./// The "WebCam" key./// The "Word Processor" key./// Navigate to previous content or page in current history. (<code class="appcommand">APPCOMMAND_BROWSER_BACKWARD</code>)/// Open the list of browser favorites. (<code class="appcommand">APPCOMMAND_BROWSER_FAVORITES</code>)/// Navigate to next content or page in current history. (<code class="appcommand">APPCOMMAND_BROWSER_FORWARD</code>)/// Go to the user’s preferred home page. (<code class="appcommand">APPCOMMAND_BROWSER_HOME</code>)/// Refresh the current page or content. (<code class="appcommand">APPCOMMAND_BROWSER_REFRESH</code>)/// Call up the user’s preferred search page. (<code class="appcommand">APPCOMMAND_BROWSER_SEARCH</code>)/// Stop loading the current page or content. (<code class="appcommand">APPCOMMAND_BROWSER_STOP</code>)/// The Application switch key, which provides a list of recent apps to switch between. (<code class="android">KEYCODE_APP_SWITCH</code>)/// The Call key. (<code class="android">KEYCODE_CALL</code>)/// The Camera key. (<code class="android">KEYCODE_CAMERA</code>)/// The Camera focus key. (<code class="android">KEYCODE_FOCUS</code>)/// The End Call key. (<code class="android">KEYCODE_ENDCALL</code>)/// The Back key. (<code class="android">KEYCODE_BACK</code>)/// The Home key, which goes to the phone’s main screen. (<code class="android">KEYCODE_HOME</code>)/// The Headset Hook key. (<code class="android">KEYCODE_HEADSETHOOK</code>)/// The Last Number Redial key./// The Notification key. (<code class="android">KEYCODE_NOTIFICATION</code>)/// Toggle between manner mode state: silent, vibrate, ring, ... (<code class="android">KEYCODE_MANNER_MODE</code>)/// The Voice Dial key./// Switch to viewing TV. (<code class="android">KEYCODE_TV</code>)/// TV 3D Mode. (<code class="android">KEYCODE_3D_MODE</code>)/// Toggle between antenna and cable input. (<code class="android">KEYCODE_TV_ANTENNA_CABLE</code>)/// Audio description. (<code class="android">KEYCODE_TV_AUDIO_DESCRIPTION</code>)/// Audio description mixing volume down. (<code class="android">KEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN</code>)/// Audio description mixing volume up. (<code class="android">KEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP</code>)/// Contents menu. (<code class="android">KEYCODE_TV_CONTENTS_MENU</code>)/// Contents menu. (<code class="android">KEYCODE_TV_DATA_SERVICE</code>)/// Switch the input mode on an external TV. (<code class="android">KEYCODE_TV_INPUT</code>)/// Switch to component input #1. (<code class="android">KEYCODE_TV_INPUT_COMPONENT_1</code>)/// Switch to component input #2. (<code class="android">KEYCODE_TV_INPUT_COMPONENT_2</code>)/// Switch to composite input #1. (<code class="android">KEYCODE_TV_INPUT_COMPOSITE_1</code>)/// Switch to composite input #2. (<code class="android">KEYCODE_TV_INPUT_COMPOSITE_2</code>)/// Switch to HDMI input #1. (<code class="android">KEYCODE_TV_INPUT_HDMI_1</code>)/// Switch to HDMI input #2. (<code class="android">KEYCODE_TV_INPUT_HDMI_2</code>)/// Switch to HDMI input #3. (<code class="android">KEYCODE_TV_INPUT_HDMI_3</code>)/// Switch to HDMI input #4. (<code class="android">KEYCODE_TV_INPUT_HDMI_4</code>)/// Switch to VGA input #1. (<code class="android">KEYCODE_TV_INPUT_VGA_1</code>)/// Media context menu. (<code class="android">KEYCODE_TV_MEDIA_CONTEXT_MENU</code>)/// Toggle network. (<code class="android">KEYCODE_TV_NETWORK</code>)/// Number entry. (<code class="android">KEYCODE_TV_NUMBER_ENTRY</code>)/// Toggle the power on an external TV. (<code class="android">KEYCODE_TV_POWER</code>)/// Radio. (<code class="android">KEYCODE_TV_RADIO_SERVICE</code>)/// Satellite. (<code class="android">KEYCODE_TV_SATELLITE</code>)/// Broadcast Satellite. (<code class="android">KEYCODE_TV_SATELLITE_BS</code>)/// Communication Satellite. (<code class="android">KEYCODE_TV_SATELLITE_CS</code>)/// Toggle between available satellites. (<code class="android">KEYCODE_TV_SATELLITE_SERVICE</code>)/// Analog Terrestrial. (<code class="android">KEYCODE_TV_TERRESTRIAL_ANALOG</code>)/// Digital Terrestrial. (<code class="android">KEYCODE_TV_TERRESTRIAL_DIGITAL</code>)/// Timer programming. (<code class="android">KEYCODE_TV_TIMER_PROGRAMMING</code>)/// Switch the input mode on an external AVR (audio/video receiver). (<code class="android">KEYCODE_AVR_INPUT</code>)/// Toggle the power on an external AVR (audio/video receiver). (<code class="android">KEYCODE_AVR_POWER</code>)/// General purpose color-coded media function key, as index 0 (red). (<code class="vk"><code class="vk">VK_COLORED_KEY_0</code></code>, <code class="android"><code class="android">KEYCODE_PROG_RED</code></code>)/// General purpose color-coded media function key, as index 1 (green). (<code class="vk"><code class="vk">VK_COLORED_KEY_1</code></code>, <code class="android"><code class="android">KEYCODE_PROG_GREEN</code></code>)/// General purpose color-coded media function key, as index 2 (yellow). (<code class="vk"><code class="vk">VK_COLORED_KEY_2</code></code>, <code class="android"><code class="android">KEYCODE_PROG_YELLOW</code></code>)/// General purpose color-coded media function key, as index 3 (blue). (<code class="vk"><code class="vk">VK_COLORED_KEY_3</code></code>, <code class="android"><code class="android">KEYCODE_PROG_BLUE</code></code>)/// General purpose color-coded media function key, as index 4 (grey). (<code class="vk">VK_COLORED_KEY_4</code>)/// General purpose color-coded media function key, as index 5 (brown). (<code class="vk">VK_COLORED_KEY_5</code>)/// Toggle the display of Closed Captions. (<code class="vk"><code class="vk">VK_CC</code></code>, <code class="android"><code class="android">KEYCODE_CAPTIONS</code></code>)/// Adjust brightness of device, by toggling between or cycling through states. (<code class="vk">VK_DIMMER</code>)/// Swap video sources. (<code class="vk">VK_DISPLAY_SWAP</code>)/// Select Digital Video Rrecorder. (<code class="android">KEYCODE_DVR</code>)/// Exit the current application. (<code class="vk">VK_EXIT</code>)/// Clear program or content stored as favorite 0. (<code class="vk">VK_CLEAR_FAVORITE_0</code>)/// Clear program or content stored as favorite 1. (<code class="vk">VK_CLEAR_FAVORITE_1</code>)/// Clear program or content stored as favorite 2. (<code class="vk">VK_CLEAR_FAVORITE_2</code>)/// Clear program or content stored as favorite 3. (<code class="vk">VK_CLEAR_FAVORITE_3</code>)/// Select (recall) program or content stored as favorite 0. (<code class="vk">VK_RECALL_FAVORITE_0</code>)/// Select (recall) program or content stored as favorite 1. (<code class="vk">VK_RECALL_FAVORITE_1</code>)/// Select (recall) program or content stored as favorite 2. (<code class="vk">VK_RECALL_FAVORITE_2</code>)/// Select (recall) program or content stored as favorite 3. (<code class="vk">VK_RECALL_FAVORITE_3</code>)/// Store current program or content as favorite 0. (<code class="vk">VK_STORE_FAVORITE_0</code>)/// Store current program or content as favorite 1. (<code class="vk">VK_STORE_FAVORITE_1</code>)/// Store current program or content as favorite 2. (<code class="vk">VK_STORE_FAVORITE_2</code>)/// Store current program or content as favorite 3. (<code class="vk">VK_STORE_FAVORITE_3</code>)/// Toggle display of program or content guide. (<code class="vk"><code class="vk">VK_GUIDE</code></code>, <code class="android"><code class="android">KEYCODE_GUIDE</code></code>)/// If guide is active and displayed, then display next day’s content. (<code class="vk">VK_NEXT_DAY</code>)/// If guide is active and displayed, then display previous day’s content. (<code class="vk">VK_PREV_DAY</code>)/// Toggle display of information about currently selected context or media. (<code class="vk"><code class="vk">VK_INFO</code></code>, <code class="android"><code class="android">KEYCODE_INFO</code></code>)/// Toggle instant replay. (<code class="vk">VK_INSTANT_REPLAY</code>)/// Launch linked content, if available and appropriate. (<code class="vk">VK_LINK</code>)/// List the current program. (<code class="vk">VK_LIST</code>)/// Toggle display listing of currently available live content or programs. (<code class="vk">VK_LIVE</code>)/// Lock or unlock current content or program. (<code class="vk">VK_LOCK</code>)/// Show a list of media applications: audio/video players and image viewers. (<code class="vk">VK_APPS</code>)/// <p class="note" role="note">Do not confuse this key value with the Windows' <code class="vk"><code class="vk">VK_APPS</code></code> / <code class="vk"><code class="vk">VK_CONTEXT_MENU</code></code> key, which is encoded as <code class="key">"ContextMenu"</code>.</p>/// Audio track key. (<code class="android">KEYCODE_MEDIA_AUDIO_TRACK</code>)/// Select previously selected channel or media. (<code class="vk"><code class="vk">VK_LAST</code></code>, <code class="android"><code class="android">KEYCODE_LAST_CHANNEL</code></code>)/// Skip backward to next content or program. (<code class="android">KEYCODE_MEDIA_SKIP_BACKWARD</code>)/// Skip forward to next content or program. (<code class="vk"><code class="vk">VK_SKIP</code></code>, <code class="android"><code class="android">KEYCODE_MEDIA_SKIP_FORWARD</code></code>)/// Step backward to next content or program. (<code class="android">KEYCODE_MEDIA_STEP_BACKWARD</code>)/// Step forward to next content or program. (<code class="android">KEYCODE_MEDIA_STEP_FORWARD</code>)/// Media top menu. (<code class="android">KEYCODE_MEDIA_TOP_MENU</code>)/// Navigate in. (<code class="android">KEYCODE_NAVIGATE_IN</code>)/// Navigate to next key. (<code class="android">KEYCODE_NAVIGATE_NEXT</code>)/// Navigate out. (<code class="android">KEYCODE_NAVIGATE_OUT</code>)/// Navigate to previous key. (<code class="android">KEYCODE_NAVIGATE_PREVIOUS</code>)/// Cycle to next favorite channel (in favorites list). (<code class="vk">VK_NEXT_FAVORITE_CHANNEL</code>)/// Cycle to next user profile (if there are multiple user profiles). (<code class="vk">VK_USER</code>)/// Access on-demand content or programs. (<code class="vk">VK_ON_DEMAND</code>)/// Pairing key to pair devices. (<code class="android">KEYCODE_PAIRING</code>)/// Move picture-in-picture window down. (<code class="vk">VK_PINP_DOWN</code>)/// Move picture-in-picture window. (<code class="vk">VK_PINP_MOVE</code>)/// Toggle display of picture-in-picture window. (<code class="vk">VK_PINP_TOGGLE</code>)/// Move picture-in-picture window up. (<code class="vk">VK_PINP_UP</code>)/// Decrease media playback speed. (<code class="vk">VK_PLAY_SPEED_DOWN</code>)/// Reset playback to normal speed. (<code class="vk">VK_PLAY_SPEED_RESET</code>)/// Increase media playback speed. (<code class="vk">VK_PLAY_SPEED_UP</code>)/// Toggle random media or content shuffle mode. (<code class="vk">VK_RANDOM_TOGGLE</code>)/// Not a physical key, but this key code is sent when the remote control battery is low. (<code class="vk">VK_RC_LOW_BATTERY</code>)/// Toggle or cycle between media recording speeds. (<code class="vk">VK_RECORD_SPEED_NEXT</code>)/// Toggle RF (radio frequency) input bypass mode (pass RF input directly to the RF output). (<code class="vk">VK_RF_BYPASS</code>)/// Toggle scan channels mode. (<code class="vk">VK_SCAN_CHANNELS_TOGGLE</code>)/// Advance display screen mode to next available mode. (<code class="vk">VK_SCREEN_MODE_NEXT</code>)/// Toggle display of device settings screen. (<code class="vk"><code class="vk">VK_SETTINGS</code></code>, <code class="android"><code class="android">KEYCODE_SETTINGS</code></code>)/// Toggle split screen mode. (<code class="vk">VK_SPLIT_SCREEN_TOGGLE</code>)/// Switch the input mode on an external STB (set top box). (<code class="android">KEYCODE_STB_INPUT</code>)/// Toggle the power on an external STB (set top box). (<code class="android">KEYCODE_STB_POWER</code>)/// Toggle display of subtitles, if available. (<code class="vk">VK_SUBTITLE</code>)/// Toggle display of teletext, if available (<code class="vk"><code class="vk">VK_TELETEXT</code></code>, <code class="android"><code class="android">KEYCODE_TV_TELETEXT</code></code>)./// Advance video mode to next available mode. (<code class="vk">VK_VIDEO_MODE_NEXT</code>)/// Cause device to identify itself in some manner, e.g., audibly or visibly. (<code class="vk">VK_WINK</code>)/// Toggle between full-screen and scaled content, or alter magnification level. (<code class="vk"><code class="vk">VK_ZOOM</code></code>, <code class="android"><code class="android">KEYCODE_TV_ZOOM_MODE</code></code>)/// The F1 key, a general purpose function key, as index 1./// The F2 key, a general purpose function key, as index 2./// The F3 key, a general purpose function key, as index 3./// The F4 key, a general purpose function key, as index 4./// The F5 key, a general purpose function key, as index 5./// The F6 key, a general purpose function key, as index 6./// The F7 key, a general purpose function key, as index 7./// The F8 key, a general purpose function key, as index 8./// The F9 key, a general purpose function key, as index 9./// The F10 key, a general purpose function key, as index 10./// The F11 key, a general purpose function key, as index 11./// The F12 key, a general purpose function key, as index 12./// The F13 key, a general purpose function key, as index 13./// The F14 key, a general purpose function key, as index 14./// The F15 key, a general purpose function key, as index 15./// The F16 key, a general purpose function key, as index 16./// The F17 key, a general purpose function key, as index 17./// The F18 key, a general purpose function key, as index 18./// The F19 key, a general purpose function key, as index 19./// The F20 key, a general purpose function key, as index 20./// The F21 key, a general purpose function key, as index 21./// The F22 key, a general purpose function key, as index 22./// The F23 key, a general purpose function key, as index 23./// The F24 key, a general purpose function key, as index 24./// The F25 key, a general purpose function key, as index 25./// The F26 key, a general purpose function key, as index 26./// The F27 key, a general purpose function key, as index 27./// The F28 key, a general purpose function key, as index 28./// The F29 key, a general purpose function key, as index 29./// The F30 key, a general purpose function key, as index 30./// The F31 key, a general purpose function key, as index 31./// The F32 key, a general purpose function key, as index 32./// The F33 key, a general purpose function key, as index 33./// The F34 key, a general purpose function key, as index 34./// The F35 key, a general purpose function key, as index 35./// <https://w3c.github.io/uievents-key/>UnrecognizedKeyError/// Parse from string error, returned when string does not match to any Key variant.is_key_string/// Check if string can be used as a `Key::Character` _keystring_./// This check is simple and is meant to prevents common mistakes like mistyped keynames/// (e.g. `Ennter`) from being recognized as characters.test_is_key_stringModifiersshortcutsShortcutMatcherwebdriverKeyState/// Key is pressed./// In JS: "keydown" event firing./// Key is released./// In JS: "keyup event"./// Describes the state the key is in./// Whether the key is pressed or released./// Logical key value./// Physical key position./// Location for keys with multiple instances on common keyboards./// Flags for pressed modifier keys./// True if the key is currently auto-repeated.is_composing/// Events with this flag should be ignored in a text editor/// and instead composition events should be used./// Keyboard events are issued for all pressed and released keys.CompositionState/// In JS: "compositionstart" event./// In JS: "compositionupdate" event./// In JS: "compositionend" event./// In a text editor in this state the data/// should be added to the input./// Describes the state of a composition session./// Describes the event kind./// Current composition data. May be empty.CompositionEvent/// Event to expose input methods to program logic./// Provides information about entered sequences from/// dead key combinations and IMEs./// A composition session is always started by a "compositionstart"/// event followed my zero or more "compositionupdate" events/// and terminated by a single "compositionend" event.legacy_charcode/// Determine a *charCode* value for a key with a character value./// For all other keys the value is zero./// The *charCode* is an implementation specific legacy property of DOM keyboard events./// Specification: <https://w3c.github.io/uievents/#dom-keyboardevent-charcode>legacy_keycode/// Determine a *keyCode* value for a key./// The *keyCode* is an implementation specific legacy property of DOM keyboard events./// Specification: <https://w3c.github.io/uievents/#dom-keyboardevent-keycode>first_char/// Return the first codepoint of a string./// Panics if the string is empty.//! Contains types to define keyboard related events.//! The naming and conventions follow the UI Events specification//! but this crate should be useful for anyone implementing keyboard//! input in a cross-platform way./// The key activation MUST NOT be distinguished as the left or right/// version of the key, and (other than the NumLock key) did not/// originate from the numeric keypad (or did not originate with a/// virtual key corresponding to the numeric keypad)./// The key activated originated from the left key location (when there/// is more than one possible location for this key)./// The key activation originated from the right key location (when/// there is more than one possible location for this key)./// The key activation originated on the numeric keypad or with a virtual/// key corresponding to the numeric keypad (when there is more than one/// possible location for this key). Note that the NumLock key should/// always be encoded with a location of `Location::Standard`./// The location attribute contains an indication of the logical location/// of the key on the device.r" Pressed modifier keys."r" Specification:"r" <https://w3c.github.io/uievents-key/#keys-modifier>"ALT_GRAPHCAPS_LOCKFNFN_LOCKNUM_LOCKSCROLL_LOCKSYMBOL_LOCKHYPER/// Return `true` if a shift key is pressed./// Return `true` if a control key is pressed./// Return `true` if an alt key is pressed./// Return `true` if a meta key is pressed.//! Modifier key data.//! Modifier keys like Shift and Control alter the character value//! and are used in keyboard shortcuts.//! Use the constants to match for combinations of the modifier keys./// Match keyboard shortcuts and excute actions./// Every shortcut consists of a list of modifier keys pressed and a/// single non-modifier key pressed./// The Control + C shortcut requires the user to hold down the Control/// modifier key. When the C key is pressed the action (usually copy)/// is triggered. The event is consumed so other matchers don't also/// act on the shortcut. This is also true for the release of the/// C key as else only key release events would be forwarded./// ASCII letters are compared ignoring case. Only takes/// the shift, control, alt and meta modifiers into account./// If other modifiers beside those expected are found/// the shortcut is not matched./// Create a new shortcut matcher./// Create a new matcher from an event./// Only state, key and modifiers are stored. The other attributes are discarded.MatchKey/// Test a keyboard shortcut./// If the modifiers are active and the key is pressed/// execute the provided function./// # use keyboard_types::{Key, KeyboardEvent, Modifiers, ShortcutMatcher};/// # fn do_something() {}/// # fn forward_event() {}/// # let event = KeyboardEvent {/// #     state: keyboard_types::KeyState::Down,/// #     key: Key::Enter,/// #     code: keyboard_types::Code::Enter,/// #     location: keyboard_types::Location::Standard,/// #     modifiers: Modifiers::empty(),/// #     repeat: false,/// #     is_composing: false,/// // Create a matcher from a keyboard event./// // Shortcuts are tested in-order./// ShortcutMatcher::from_event(event)/// // Do something if the Tab key is pressed./// .shortcut(Modifiers::empty(), Key::Tab, do_something)/// // If Shift + Tab are pressed do something./// // This is executed because the previous shortcut requires modifiers to be empty./// .shortcut(Modifiers::SHIFT, Key::Tab, do_something)/// // Instead of named keys letters and other characters can be used./// .shortcut(Modifiers::CONTROL, 'L', do_something)/// // Multiple modifiers are combined with bitwise OR (`|`) to form a new mask./// .shortcut(Modifiers::CONTROL | Modifiers::SHIFT, 'X', do_something)/// // If none of the previous shortcuts matched forward the event./// .otherwise(forward_event);optional_shortcut/// Only test a shortcut if the enabled flag is set./// If the `enabled` flag is true behaves the same as/// `shortcut` otherwise does nothing./// This is especially useful for platform specific shortcuts./// # fn copy() {}/// # fn quit() {}/// .shortcut(Modifiers::CONTROL, 'c', copy)/// .optional_shortcut(cfg!(target_os="macos"), Modifiers::META, 'q', quit)/// .shortcut(Modifiers::CONTROL, 'w', quit);/// In the example the app supports the copy action on all platforms/// and can be closed with Control&nbsp;+&nbsp;W everywhere but additionally/// with Command&nbsp;+&nbsp;Q on Mac OS.otherwise/// Execute the function is no keyboard shortcut matched./// Note that the passed function is executed on both/// keydown and keyup unlike the shortcuts which only/// run on keydown.match_keynormalised_key_value// Spec: <https://w3c.github.io/webdriver/#keyboard-actions>// normalised (sic) as in british spelling/// Spec: <https://w3c.github.io/webdriver/#dfn-code>is_shifted_characterkey_locationKeyInputState/// Store pressed keys and modifiers./// Spec: <https://w3c.github.io/webdriver/#dfn-key-input-state>/// New state without any keys or modifiers pressed./// Same as the default value.dispatch_keydown/// Get a keyboard-keydown event from a WebDriver key value./// Stores that the key is pressed in the state object./// The input cancel list is not implemented here but can be emulated/// by adding the `raw_key` value with a `keyUp` action to a list/// before executing this function./// Specification: <https://w3c.github.io/webdriver/#dfn-dispatch-a-keydown-action>dispatch_keyup/// Get a keyboard-keyup event from a WebDriver key value./// Updates state. Returns `None` if the key is not listed as pressed./// Specification: <https://w3c.github.io/webdriver/#dfn-dispatch-a-keyup-action>dispatch_typeableComposition/// Either a `KeyboardEvent` or a `CompositionEvent`./// Returned by the `send_keys` function.send_keys/// Compute the events resulting from a WebDriver *Element Send Keys* command./// Spec: <https://w3c.github.io/webdriver/#element-send-keys>//! Keyboard related WebDriver functionality.//! The low-level `dispatch_keydown` and `dispatch_keyup` API//! creates keyboard events from WebDriver codes. It is used//! in the *Perform Actions* API.//! # extern crate keyboard_types;//! # use keyboard_types::*;//! # use keyboard_types::webdriver::*;//! let mut state = KeyInputState::new();//! let mut keyboard_event = state.dispatch_keydown('a');//! assert_eq!(keyboard_event.state, KeyState::Down);//! assert_eq!(keyboard_event.key, Key::Character("a".to_owned()));//! assert_eq!(keyboard_event.code, Code::KeyA);//! // The `\u{E029}` code is the WebDriver id for the Numpad divide key.//! keyboard_event = state.dispatch_keydown('\u{E050}');//! assert_eq!(keyboard_event.key, Key::Shift);//! assert_eq!(keyboard_event.code, Code::ShiftRight);//! assert_eq!(keyboard_event.location, Location::Right);//! keyboard_event = state.dispatch_keyup('\u{E050}').expect("key is released");//! keyboard_event = state.dispatch_keyup('a').expect("key is released");//! The higher level `send_keys` function is used for the *Element Send Keys*//! WebDriver API. It accepts a string and returns a sequence of `KeyboardEvent`//! and `CompositionEvent` values.//! let events = send_keys("Hello world!\u{E006}");//! println!("{:#?}", events);//! let events = send_keys("A\u{0308}");//! Specification: <https://w3c.github.io/webdriver/>__lazy_static_create// Copyright 2016 lazy-static.rs Developers// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or// https://opensource.org/licenses/MIT>, at your option. This file may not beONCE_INIT// Used in macros// optional visibility restrictions are wrapped in `()` to allow for// explicitly passing otherwise implicit information about private items// `vis` is wrapped in `()` to prevent parsing ambiguity/// Support trait for enabling a few common operation on lazy static values./// This is implemented by each defined lazy static, and/// used by the free functions in this crate./// Takes a shared reference to a lazy static and initializes/// it if it has not been already./// This can be used to control the initialization point of a lazy static./// use lazy_static::lazy_static;/// lazy_static! {///     static ref BUFFER: Vec<u8> = (0..255).collect();///     lazy_static::initialize(&BUFFER);///     work_with_initialized_data(&BUFFER);/// # fn work_with_initialized_data(_: &[u8]) {}/*!
A macro for declaring lazily evaluated statics.

Using this macro, it is possible to have `static`s that require code to be
executed at runtime in order to be initialized.
This includes anything requiring heap allocations, like vectors or hash maps,
as well as anything that requires function calls to be computed.

# Syntax

```ignore
lazy_static! {
    [pub] static ref NAME_1: TYPE_1 = EXPR_1;
    [pub] static ref NAME_2: TYPE_2 = EXPR_2;
    ...
    [pub] static ref NAME_N: TYPE_N = EXPR_N;
}
```

Attributes (including doc comments) are supported as well:

```rust
use lazy_static::lazy_static;

# fn main() {
lazy_static! {
    /// This is an example for using doc comment attributes
    static ref EXAMPLE: u8 = 42;
}
# }
```

# Semantics

For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that
implements `Deref<TYPE>` and stores it in a static with name `NAME`. (Attributes end up
attaching to this type.)

On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
can return a reference to the same object. Note that this can lead to deadlocks
if you have multiple lazy statics that depend on each other in their initialization.

Apart from the lazy initialization, the resulting "static ref" variables
have generally the same properties as regular "static" variables:

- Any type in them needs to fulfill the `Sync` trait.
- If the type has a destructor, then it will not run when the process exits.

# Example

Using the macro:

```rust
use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
    static ref HASHMAP: HashMap<u32, &'static str> = {
        let mut m = HashMap::new();
        m.insert(0, "foo");
        m.insert(1, "bar");
        m.insert(2, "baz");
        m
    };
    static ref COUNT: usize = HASHMAP.len();
    static ref NUMBER: u32 = times_two(21);
}

fn times_two(n: u32) -> u32 { n * 2 }

fn main() {
    println!("The map has {} entries.", *COUNT);
    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
    println!("A expensive calculation on a static results in: {}.", *NUMBER);
}
```

# Implementation details

The `Deref` implementation uses a hidden static variable that is guarded by an atomic check on each access.

# Cargo features

This crate provides one cargo feature:

- `spin_no_std`: This allows using this crate in a no-std environment, by depending on the standalone `spin` crate.

*//// A lazily filled `Cell`, with mutable contents./// A `LazyCell` is completely frozen once filled, **unless** you have `&mut`/// access to it, in which case `LazyCell::borrow_mut` may be used to mutate the/// contents./// Creates a new, empty, `LazyCell`./// Put a value into this cell./// This function will return `Err(value)` if the cell is already full./// Note that this function is infallible but requires `&mut self`. By/// requiring `&mut self` we're guaranteed that no active borrows to this/// cell can exist so we can always fill in the value. This may not always/// be usable, however, as `&mut self` may not be possible to borrow./// This function returns the previous value, if any./// Test whether this cell has been previously filled./// Borrows the contents of this lazy cell for the duration of the cell/// This function will return `Some` if the cell has been previously/// initialized, and `None` if it has not yet been initialized./// Borrows the contents of this lazy cell mutably for the duration of the cell/// If the cell has not yet been filled, the cell is first filled using the/// function provided./// Panics if the cell becomes filled as a side effect of `f`.borrow_mut_with/// Borrows the contents of this `LazyCell` mutably for the duration of the/// cell itself.try_borrow_with/// Same as `borrow_with`, but allows the initializing function to fail.try_borrow_mut_with/// Same as `borrow_mut_with`, but allows the initializing function to fail./// Consumes this `LazyCell`, returning the underlying value./// Returns a copy of the contents of the lazy cell./// This function will return `Some` if the cell has been previously initialized,/// and `None` if it has not yet been initialized./// Create a clone of this `LazyCell`/// If self has not been initialized, returns an uninitialized `LazyCell`/// otherwise returns a `LazyCell` already initialized with a clone of the/// contents of self.// Tracks the AtomicLazyCell inner stateSOMEAtomicLazyCell/// A lazily filled and thread-safe `Cell`, with frozen contents./// An empty `AtomicLazyCell`./// Creates a new, empty, `AtomicLazyCell`./// Create a clone of this `AtomicLazyCell`/// If self has not been initialized, returns an uninitialized `AtomicLazyCell`/// otherwise returns an `AtomicLazyCell` already initialized with a clone of thetest_borrow_from_emptytest_fill_and_borrowtest_borrow_muttest_already_filled_errortest_borrow_withtest_borrow_with_already_filledtest_borrow_with_not_called_when_filledtest_borrow_with_sound_with_reentrancytest_borrow_mut_withtest_borrow_mut_with_already_filledtest_borrow_mut_with_not_called_when_filledtest_try_borrow_with_oktest_try_borrow_with_errtest_try_borrow_with_already_filledtest_try_borrow_with_sound_with_reentrancytest_try_borrow_mut_with_oktest_try_borrow_mut_with_errtest_try_borrow_mut_with_already_filledtest_atomic_borrow_from_emptytest_atomic_fill_and_borrowtest_atomic_already_filled_panictest_atomic_into_innernormal_replaceatomic_replaceclone_atomic// Original work Copyright (c) 2014 The Rust Project Developers// Modified work Copyright (c) 2016-2020 Nikita Pekin and the lazycell contributors// See the README.md file at the top-level directory of this distribution.//! This crate provides a `LazyCell` struct which acts as a lazily filled//! `Cell`.//! With a `RefCell`, the inner contents cannot be borrowed for the lifetime of//! the entire object, but only of the borrows returned. A `LazyCell` is a//! variation on `RefCell` which allows borrows to be tied to the lifetime of//! the outer object.//! The following example shows a quick example of the basic functionality of//! `LazyCell`.//! use lazycell::LazyCell;//! let lazycell = LazyCell::new();//! assert_eq!(lazycell.borrow(), None);//! assert!(!lazycell.filled());//! lazycell.fill(1).ok();//! assert!(lazycell.filled());//! assert_eq!(lazycell.borrow(), Some(&1));//! assert_eq!(lazycell.into_inner(), Some(1));//! `AtomicLazyCell` is a variant that uses an atomic variable to manage//! coordination in a thread-safe fashion. The limitation of an `AtomicLazyCell`//! is that after it is initialized, it can't be modified.// Copyright (c) 2020 Nikita Pekin and the lazycell contributors// except according to those terms.use serde::ser::{Serialize, Serializer};LazyCellVisitorAtomicLazyCellVisitorReadEndian/// Exports some of the most common types.
/// Swaps all bytes in this value, inverting its endianness.
/// On a little endian machine, this does nothing.
/// On a big endian machine, the bytes of this value are reversed.
convert_current_to_big_endian/// On a big endian machine, this does nothing.
/// On a little endian machine, the bytes of this value are reversed.
convert_big_endian_to_currentfrom_current_into_little_endianfrom_current_into_big_endianfrom_little_endian_into_currentfrom_big_endian_into_current/// Represents values that can swap their bytes to reverse their endianness.
/// Supports converting values in-place using [`swap_bytes`] or [`convert_current_to_little_endian`]:
/// Supports converting while transferring ownership using
/// [`from_little_endian_into_current`] or [`from_current_into_little_endian`].
/// For the types `u8`, `i8`, `&[u8]` and `&[i8]`, this trait will never transform any data,
/// as they are just implemented for completeness.
call_single_arg_macro_for_each// call a macro for each argument
implement_simple_primitive_endian// implement this interface for primitive signed and unsigned integers
// no-op implementations
implement_float_primitive_by_bits// implement this interface for primitive floats, because they do not have a `swap_bytes()` in `std`
implement_slice_by_elementslice_as_bytes/// View this slice of values as a slice of bytes.
slice_as_bytes_mut/// View this slice of values as a mutable slice of bytes.
value_as_bytes/// View this reference as a slice of bytes.
value_as_bytes_mut/// View this reference as a mutable slice of bytes.
/// View this slice as a mutable slice of bytes and write it.
/// Read a slice of bytes into the specified slice.
write_value/// View this reference as a mutable slice of bytes and write it.
read_value/// Read a slice of bytes into the specified reference.
/// Reinterpret values as byte slices and byte slices as values unsafely.
write_as_little_endian/// Write the byte value of the specified reference, converting it to little endianness
write_as_big_endian/// Write the byte value of the specified reference, converting it to big endianness
write_as_native_endian/// Write the byte value of the specified reference, not converting it
/// A `std::io::Write` output stream which supports writing any primitive values as bytes.
/// Will encode the values to be either little endian or big endian, as desired.
/// This extension trait is implemented for all `Write` types.
/// Add `use lebe::io::WriteEndian;` to your code
/// to automatically unlock this functionality for all types that implement `Write`.
read_from_little_endian_into/// Read into the supplied reference. Acts the same as `std::io::Read::read_exact`.
read_from_big_endian_intoread_from_native_endian_intoread_from_little_endian/// Read the byte value of the inferred type
read_from_big_endianread_from_native_endian/// A `std::io::Read` input stream which supports reading any primitive values from bytes.
/// Will decode the values from either little endian or big endian, as desired.
/// This extension trait is implemented for all `Read` types.
/// Add `use lebe::io::ReadEndian;` to your code
/// to automatically unlock this functionality for all types that implement `Read`.
// implement primitive for all types that are implemented by `Read`
/// Read this value from the supplied reader. Same as `ReadEndian::read_from_little_endian()`.
/// Read this value from the supplied reader. Same as `ReadEndian::read_from_big_endian()`.
/// Read this value from the supplied reader. Same as `ReadEndian::read_from_native_endian()`.
/// Offers a prettier versions of reading a primitive number.
/// The default way of reading a value is:
/// # use std::io::Read;
/// # use lebe::prelude::*;
/// # let mut reader : &[u8] = &[2, 1];
/// let number: u16 = reader.read_from_little_endian()?;
/// println!("{}", number);
/// # Ok::<(), std::io::Error>(())
/// This trait enables you to use expressions:
/// println!("{}", u16::read_from_little_endian(&mut reader)?);
/// .
implement_simple_primitive_writeimplement_slice_io// TODO: SIMD
/*impl<R: Read> ReadEndian<[f32]> for R {
        fn read_from_little_endian_into(&mut self, value: &mut [f32]) -> Result<()> {
            unsafe { bytes::read_slice(self, value)? };
            value.convert_little_endian_to_current();
            Ok(())
        }

        fn read_from_big_endian_into(&mut self, value: &mut [f32]) -> Result<()> {
            unsafe { bytes::read_slice(self, value)? };
            value.convert_big_endian_to_current();
            Ok(())
        }
    }

    impl<W: Write> WriteEndian<[f32]> for W {
        fn write_as_big_endian(&mut self, value: &[f32]) -> Result<()> {
            if cfg!(target_endian = "little") {

                // FIX ME this SIMD optimization makes no difference ... why? like, ZERO difference, not even worse
//                #[cfg(feature = "simd")]
                #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
                unsafe {
                    if is_x86_feature_detected!("avx2") {
                        write_bytes_avx(self, value);
                        return Ok(());
                    }
                }

                // otherwise (no avx2 available)
//                for number in value {
//                    self.write_as_little_endian(number);
//                }
//
//                return Ok(());
                unimplemented!();

                #[target_feature(enable = "avx2")]
                #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
                unsafe fn write_bytes_avx(write: &mut impl Write, slice: &[f32]) -> Result<()> {
                    #[cfg(target_arch = "x86")] use std::arch::x86 as mm;
                    #[cfg(target_arch = "x86_64")] use std::arch::x86_64 as mm;

                    let bytes: &[u8] = crate::io::bytes::slice_as_bytes(slice);
                    let mut chunks = bytes.chunks_exact(32);

                    let indices = mm::_mm256_set_epi8(
                        0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
                        0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
//                        3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12,
//                        3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12
                    );

                    for chunk in &mut chunks {
                        let data = mm::_mm256_loadu_si256(chunk.as_ptr() as _);
                        let result = mm::_mm256_shuffle_epi8(data, indices);
                        let mut out = [0_u8; 32];
                        mm::_mm256_storeu_si256(out.as_mut_ptr() as _, result);
                        write.write_all(&out)?;
                    }

                    let remainder = chunks.remainder();

                    { // copy remainder into larger slice, with zeroes at the end
                        let mut last_chunk = [0_u8; 32];
                        last_chunk[0..remainder.len()].copy_from_slice(remainder);
                        let data = mm::_mm256_loadu_si256(last_chunk.as_ptr() as _);
                        let result = mm::_mm256_shuffle_epi8(data, indices);
                        mm::_mm256_storeu_si256(last_chunk.as_mut_ptr() as _, result);
                        write.write_all(&last_chunk[0..remainder.len()])?;
                    }

                    Ok(())
                }
            }

            else {
                unsafe { bytes::write_slice(self, value)?; }
                Ok(())
            }
        }

        fn write_as_little_endian(&mut self, value: &[f32]) -> Result<()> {
            for number in value {
                self.write_as_little_endian(number)?;
            }

            Ok(())
        }
    }*//// Easily write primitives and slices of primitives to
/// binary `std::io::Write` streams and easily read from binary `std::io::Read` streams.
/// Also contains the unsafe `bytes` module for reinterpreting values as byte slices and vice versa.
//! Dead simple endianness conversions.
//! The following operations are implemented on
//! `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `u128`, `i128`, `f32`, `f64`:
//! ### Read Numbers
//! use lebe::prelude::*;
//! let mut reader: &[u8] = &[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
//! let number : u64 = reader.read_from_little_endian()?;
//! let number = u64::read_from_big_endian(&mut reader)?;
//! # Ok::<(), std::io::Error>(())
//! ### Read Slices
//! use std::io::Read;
//! let mut numbers: &mut [u64] = &mut [0, 0];
//! reader.read_from_little_endian_into(numbers)?;
//! ### Write Numbers
//! let mut writer: Vec<u8> = Vec::new();
//! let number: u64 = 1237691;
//! writer.write_as_big_endian(&number)?;
//! ### Write Slices
//! use std::io::Write;
//! let numbers: &[u64] = &[1_u64, 234545_u64];
//! writer.write_as_little_endian(numbers)?;
AppIndicatorRawairAppIndicatorCategoryApplicationStatusCommunicationsHardwarePassiveAttentionset_statusset_icon_theme_pathset_icon_fullset_attention_iconset_attention_icon_full// Copyright 2017-2021 qDot// Copyright 2021 Tauri Programme within The Commons ConservancyLIBguint32gint64guint64gsizegcharglonggintgulongguintgfloatgdouble_GSListbindgen_test_layout__GSList_GValue_GTypeClass_GTypeInstance" GTypeClass:"" An opaque structure used as the base of all classes."bindgen_test_layout__GTypeClass" GTypeInstance:"" An opaque structure used as the base of all type instances."bindgen_test_layout__GTypeInstance" GValue:"" An opaque structure used to hold different types of values."" The data within the structure has protected scope: it is accessible only"" to functions within a #GTypeValueTable structure, or implementations of"" the g_value_*() API. That is, code portions which implement new fundamental"" types."" #GValue users cannot make any assumptions about how data is stored"" within the 2 element @data union, and the @g_type member should"" only be accessed through the G_VALUE_TYPE() macro."2usize_GValue__bindgen_ty_1bindgen_test_layout__GValue__bindgen_ty_1bindgen_test_layout__GValueGParamFlags_G_PARAM_READABLEGParamFlags_G_PARAM_WRITABLEGParamFlags_G_PARAM_READWRITEGParamFlags_G_PARAM_CONSTRUCTGParamFlags_G_PARAM_CONSTRUCT_ONLYGParamFlags_G_PARAM_LAX_VALIDATIONGParamFlags_G_PARAM_STATIC_NAMEGParamFlags_G_PARAM_PRIVATEGParamFlags_G_PARAM_STATIC_NICKGParamFlags_G_PARAM_STATIC_BLURBGParamFlags_G_PARAM_EXPLICIT_NOTIFYGParamFlags_G_PARAM_DEPRECATED" GParamFlags:"" @G_PARAM_READABLE: the parameter is readable"" @G_PARAM_WRITABLE: the parameter is writable"" @G_PARAM_READWRITE: alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE"" @G_PARAM_CONSTRUCT: the parameter will be set upon object construction"" @G_PARAM_CONSTRUCT_ONLY: the parameter can only be set upon object construction"" @G_PARAM_LAX_VALIDATION: upon parameter conversion (see g_param_value_convert())""  strict validation is not required"" @G_PARAM_STATIC_NAME: the string used as name when constructing the""  parameter is guaranteed to remain valid and""  unmodified for the lifetime of the parameter.""  Since 2.8"" @G_PARAM_STATIC_NICK: the string used as nick when constructing the""  unmmodified for the lifetime of the parameter."" @G_PARAM_STATIC_BLURB: the string used as blurb when constructing the"" @G_PARAM_EXPLICIT_NOTIFY: calls to g_object_set_property() for this""   property will not automatically result in a \"notify\" signal being""   emitted: the implementation must call g_object_notify() themselves""   in case the property actually changes.  Since: 2.42."" @G_PARAM_PRIVATE: internal"" @G_PARAM_DEPRECATED: the parameter is deprecated and will be removed""  in a future version. A warning will be generated if it is used""  while running with G_ENABLE_DIAGNOSTIC=1.""  Since 2.26"" Through the #GParamFlags flag values, certain aspects of parameters"" can be configured. See also #G_PARAM_STATIC_STRINGS."_GParamSpec" GParamSpec: (ref-func g_param_spec_ref_sink) (unref-func g_param_spec_uref) (set-value-func g_value_set_param) (get-value-func g_value_get_param)"" @g_type_instance: private #GTypeInstance portion"" @name: name of this parameter: always an interned string"" @flags: #GParamFlags flags for this parameter"" @value_type: the #GValue type for this parameter"" @owner_type: #GType type that uses (introduces) this parameter"" All other fields of the GParamSpec struct are private and"" should not be used directly."bindgen_test_layout__GParamSpec_GObject" GObject:"" All the fields in the GObject structure are private"" to the #GObject implementation and should never be accessed directly."bindgen_test_layout__GObjectGdkScrollDirection_GDK_SCROLL_UPGdkScrollDirection_GDK_SCROLL_DOWNGdkScrollDirection_GDK_SCROLL_LEFTGdkScrollDirection_GDK_SCROLL_RIGHTGdkScrollDirection_GDK_SCROLL_SMOOTH" GdkScrollDirection:"" @GDK_SCROLL_UP: the window is scrolled up."" @GDK_SCROLL_DOWN: the window is scrolled down."" @GDK_SCROLL_LEFT: the window is scrolled to the left."" @GDK_SCROLL_RIGHT: the window is scrolled to the right."" @GDK_SCROLL_SMOOTH: the scrolling is determined by the delta values""   in #GdkEventScroll. See gdk_event_get_scroll_deltas(). Since: 3.4"" Specifies the direction for #GdkEventScroll."_GtkWidgetbindgen_test_layout__GtkWidget_GtkContainerbindgen_test_layout__GtkContainer_GtkMenuShellbindgen_test_layout__GtkMenuShell_GtkMenubindgen_test_layout__GtkMenu_GtkStatusIconbindgen_test_layout__GtkStatusIconAppIndicatorCategory_APP_INDICATOR_CATEGORY_APPLICATION_STATUSAppIndicatorCategory_APP_INDICATOR_CATEGORY_COMMUNICATIONSAppIndicatorCategory_APP_INDICATOR_CATEGORY_SYSTEM_SERVICESAppIndicatorCategory_APP_INDICATOR_CATEGORY_HARDWAREAppIndicatorCategory_APP_INDICATOR_CATEGORY_OTHER" AppIndicatorCategory:"" @APP_INDICATOR_CATEGORY_APPLICATION_STATUS: The indicator is used to display the status of the application."" @APP_INDICATOR_CATEGORY_COMMUNICATIONS: The application is used for communication with other people."" @APP_INDICATOR_CATEGORY_SYSTEM_SERVICES: A system indicator relating to something in the user's system."" @APP_INDICATOR_CATEGORY_HARDWARE: An indicator relating to the user's hardware."" @APP_INDICATOR_CATEGORY_OTHER: Something not defined in this enum, please don't use unless you really need it."" The category provides grouping for the indicators so that"" users can find indicators that are similar together."AppIndicatorStatus_APP_INDICATOR_STATUS_PASSIVEAppIndicatorStatus_APP_INDICATOR_STATUS_ACTIVEAppIndicatorStatus_APP_INDICATOR_STATUS_ATTENTION" AppIndicatorStatus:"" @APP_INDICATOR_STATUS_PASSIVE: The indicator should not be shown to the user."" @APP_INDICATOR_STATUS_ACTIVE: The indicator should be shown in it's default state."" @APP_INDICATOR_STATUS_ATTENTION: The indicator should show it's attention icon."" These are the states that the indicator can be on in"" the user's panel.  The indicator by default starts"" in the state @APP_INDICATOR_STATUS_PASSIVE and can be"" shown by setting it to @APP_INDICATOR_STATUS_ACTIVE."_AppIndicator_AppIndicatorPrivateAppIndicatorPrivate" AppIndicator:"" A application indicator represents the values that are needed to show a"" unique status in the panel for an application.  In general, applications"" should try to fit in the other indicators that are available on the"" panel before using this.  But, sometimes it is necissary.""  Private fields"" @parent: Parent object."" @priv: Internal data."bindgen_test_layout__AppIndicatorapp_indicator_get_typeapp_indicator_new// TODO use OnceCell to store symbols.app_indicator_new_with_pathapp_indicator_set_statusapp_indicator_set_attention_iconapp_indicator_set_attention_icon_fullapp_indicator_set_menuapp_indicator_set_iconapp_indicator_set_icon_fullapp_indicator_set_labelapp_indicator_set_icon_theme_pathapp_indicator_set_ordering_indexapp_indicator_set_secondary_activate_targetapp_indicator_set_titleapp_indicator_get_idapp_indicator_get_categoryapp_indicator_get_statusapp_indicator_get_iconapp_indicator_get_icon_descapp_indicator_get_icon_theme_pathapp_indicator_get_attention_iconapp_indicator_get_attention_icon_descapp_indicator_get_titleapp_indicator_get_menuapp_indicator_get_labelapp_indicator_get_label_guideapp_indicator_get_ordering_indexapp_indicator_get_secondary_activate_targetapp_indicator_build_menu_from_desktopALLOWED_CFGS// List of cfgs this build script is allowed to set. The list is needed to support check-cfg, as we// need to know all the possible cfgs that this script will set. If you need to set another cfg// make sure to add it to this list as well.CHECK_CFG_EXTRA// Extra values to allow for check-cfg.rustc_version_cmd/// Run `rustc --version` and capture the output, adjusting arguments as needed if `clippy-driver`/// is used instead.rustc_minor_nightly/// Return the minor version of `rustc`, as well as a bool indicating whether or not the version/// is a nightly.which_freebsdemcc_version_codeset_cfgoff_tnlink_tblksize_tMINSIGSTKSZ// From https://cs.opensource.google/fuchsia/fuchsia/+/main:zircon/third_party/ulib/musl/include/bits/signal.h;l=20-21;drc=0827b18ab9540c46f8037f407d17ea15a79e9ba7SIGSTKSZlocale_tptrdiff_tin_addr_tin_port_tsighandler_tcc_tsa_family_tpthread_key_tspeed_ttcflag_tclockid_tkey_tid_tuseconds_tdev_tsocklen_tpthread_tino64_toff64_tblkcnt64_trlim64_tmqd_tnfds_tnl_itemidtype_tloff_t__s16Elf32_HalfElf32_WordElf32_OffElf32_AddrElf64_HalfElf64_WordElf64_OffElf64_AddrElf64_Xwordclock_tsuseconds_tino_tblkcnt_tshmatt_tmsgqnum_tmsglen_tfsblkcnt_tfsfilcnt_trlim_t// FIXME(fuchsia): why are these uninhabited types? that seems... wrong?// Presumably these should be `()` or an `extern type` (when that stabilizes).DIRfpos64_t// FIXME(fuchsia): fill this out with a structs_no_extra_traitsINT_MININT_MAXSIG_DFLSIG_IGNSIG_ERRDT_UNKNOWNDT_FIFODT_CHRDT_DIRDT_BLKDT_REGDT_LNKDT_SOCKFD_CLOEXECUSRQUOTAGRPQUOTASIGIOTS_ISUIDS_ISGIDS_ISVTXLOG_EMERGLOG_ALERTLOG_CRITLOG_ERRLOG_WARNINGLOG_NOTICELOG_INFOLOG_DEBUGLOG_KERNLOG_USERLOG_MAILLOG_DAEMONLOG_AUTHLOG_SYSLOGLOG_LPRLOG_NEWSLOG_UUCPLOG_LOCAL0LOG_LOCAL1LOG_LOCAL2LOG_LOCAL3LOG_LOCAL4LOG_LOCAL5LOG_LOCAL6LOG_LOCAL7LOG_PIDLOG_CONSLOG_ODELAYLOG_NDELAYLOG_NOWAITLOG_PRIMASKLOG_FACMASKPRIO_PROCESSPRIO_PGRPPRIO_USERPRIO_MINPRIO_MAXIPPROTO_ICMPIPPROTO_ICMPV6IPPROTO_TCPIPPROTO_UDPIPPROTO_IPIPPROTO_IPV6INADDR_ANYINADDR_BROADCASTINADDR_NONEEXIT_FAILUREEXIT_SUCCESSRAND_MAXEOFSEEK_SETSEEK_CURSEEK_END_IOFBF_IONBF_IOLBFF_DUPFDF_GETFDF_SETFDF_SETLEASE// Linux-specific fcntlsF_GETLEASEF_NOTIFYF_CANCELLKF_DUPFD_CLOEXECF_SETPIPE_SZF_GETPIPE_SZF_ADD_SEALSF_GET_SEALSF_SEAL_SEALF_SEAL_SHRINKF_SEAL_GROWF_SEAL_WRITEPTHREAD_CREATE_JOINABLEPTHREAD_CREATE_DETACHEDCLOCK_REALTIMECLOCK_MONOTONICCLOCK_PROCESS_CPUTIME_IDCLOCK_THREAD_CPUTIME_IDCLOCK_MONOTONIC_RAWCLOCK_REALTIME_COARSECLOCK_MONOTONIC_COARSECLOCK_BOOTTIMECLOCK_REALTIME_ALARMCLOCK_BOOTTIME_ALARMCLOCK_SGI_CYCLECLOCK_TAITIMER_ABSTIMERLIMIT_CPURLIMIT_FSIZERLIMIT_DATARLIMIT_STACKRLIMIT_CORERLIMIT_LOCKSRLIMIT_SIGPENDINGRLIMIT_MSGQUEUERLIMIT_NICERLIMIT_RTPRIORUSAGE_SELFS_IFIFOS_IFCHRS_IFBLKS_IFDIRS_IFREGS_IFLNKS_IFSOCKS_IFMTS_IRWXUS_IXUSRS_IWUSRS_IRUSRS_IRWXGS_IXGRPS_IWGRPS_IRGRPS_IRWXOS_IXOTHS_IWOTHS_IROTHF_OKR_OKW_OKX_OKSTDIN_FILENOSTDOUT_FILENOSTDERR_FILENOPROT_NONEPROT_READPROT_WRITEPROT_EXECLC_CTYPELC_NUMERICLC_TIMELC_COLLATELC_MONETARYLC_MESSAGESLC_ALLLC_CTYPE_MASKLC_NUMERIC_MASKLC_TIME_MASKLC_COLLATE_MASKLC_MONETARY_MASKLC_MESSAGES_MASKMAP_FILEMAP_SHAREDMAP_PRIVATEMAP_FIXEDMAP_FAILEDMS_ASYNC// MS_ flags for msync(2)MS_INVALIDATEMS_SYNCMS_RDONLY// MS_ flags for mount(2)MS_NOSUIDMS_NODEVMS_NOEXECMS_SYNCHRONOUSMS_REMOUNTMS_MANDLOCKMS_DIRSYNCMS_NOATIMEMS_NODIRATIMEMS_BINDMS_MOVEMS_RECMS_SILENTMS_POSIXACLMS_UNBINDABLEMS_PRIVATEMS_SLAVEMS_SHAREDMS_RELATIMEMS_KERNMOUNTMS_I_VERSIONMS_STRICTATIMEMS_ACTIVEMS_NOUSERMS_MGC_VALMS_MGC_MSKMS_RMT_MASKSCM_RIGHTSSCM_CREDENTIALSPROT_GROWSDOWNPROT_GROWSUPMAP_TYPEMADV_NORMALMADV_RANDOMMADV_SEQUENTIALMADV_WILLNEEDMADV_DONTNEEDMADV_FREEMADV_REMOVEMADV_DONTFORKMADV_DOFORKMADV_MERGEABLEMADV_UNMERGEABLEMADV_HUGEPAGEMADV_NOHUGEPAGEMADV_DONTDUMPMADV_DODUMPMADV_HWPOISONMADV_SOFT_OFFLINEIFF_DEBUGIFF_NOTRAILERSIFF_RUNNINGIFF_NOARPIFF_PROMISCIFF_ALLMULTIIFF_MASTERIFF_SLAVEIFF_PORTSELIFF_AUTOMEDIAIFF_DYNAMICIFF_TUNIFF_TAPIFF_NO_PISOL_IPSOL_TCPSOL_UDPSOL_IPV6SOL_ICMPV6SOL_RAWSOL_DECNETSOL_X25SOL_PACKETSOL_ATMSOL_AALSOL_IRDASOL_NETBEUISOL_LLCSOL_DCCPSOL_NETLINKSOL_TIPCAF_UNIXAF_LOCALAF_AX25AF_IPXAF_APPLETALKAF_NETROMAF_BRIDGEAF_ATMPVCAF_X25AF_ROSEAF_DECnetAF_NETBEUIAF_SECURITYAF_KEYAF_NETLINKAF_ROUTEAF_PACKETAF_ASHAF_ECONETAF_ATMSVCAF_RDSAF_SNAAF_IRDAAF_PPPOXAF_WANPIPEAF_LLCAF_CANAF_TIPCAF_BLUETOOTHAF_IUCVAF_RXRPCAF_ISDNAF_PHONETAF_IEEE802154AF_CAIFAF_ALGPF_UNSPECPF_UNIXPF_LOCALPF_INETPF_AX25PF_IPXPF_APPLETALKPF_NETROMPF_BRIDGEPF_ATMPVCPF_X25PF_INET6PF_ROSEPF_DECnetPF_NETBEUIPF_SECURITYPF_KEYPF_NETLINKPF_PACKETPF_ASHPF_ECONETPF_ATMSVCPF_RDSPF_SNAPF_IRDAPF_PPPOXPF_WANPIPEPF_LLCPF_CANPF_TIPCPF_BLUETOOTHPF_IUCVPF_RXRPCPF_ISDNPF_PHONETPF_IEEE802154PF_CAIFPF_ALGSOMAXCONNMSG_OOBMSG_PEEKMSG_DONTROUTEMSG_CTRUNCMSG_TRUNCMSG_DONTWAITMSG_EORMSG_WAITALLMSG_FINMSG_SYNMSG_CONFIRMMSG_RSTMSG_ERRQUEUEMSG_NOSIGNALMSG_MOREMSG_WAITFORONEMSG_FASTOPENMSG_CMSG_CLOEXECSCM_TIMESTAMPSOCK_RAWSOCK_RDMIP_TOSIP_TTLIP_HDRINCLIP_RECVTOSIP_FREEBINDIP_TRANSPARENTIP_MULTICAST_IFIP_MULTICAST_TTLIP_MULTICAST_LOOPIP_ADD_MEMBERSHIPIP_DROP_MEMBERSHIPIPV6_UNICAST_HOPSIPV6_MULTICAST_IFIPV6_MULTICAST_HOPSIPV6_MULTICAST_LOOPIPV6_ADD_MEMBERSHIPIPV6_DROP_MEMBERSHIPIPV6_V6ONLYIPV6_RECVPKTINFOIPV6_RECVTCLASSIPV6_TCLASSTCP_NODELAYTCP_MAXSEGTCP_CORKTCP_KEEPIDLETCP_KEEPINTVLTCP_KEEPCNTTCP_SYNCNTTCP_LINGER2TCP_DEFER_ACCEPTTCP_WINDOW_CLAMPTCP_INFOTCP_QUICKACKTCP_CONGESTIONSO_DEBUGSHUT_RDSHUT_WRSHUT_RDWRLOCK_SHLOCK_EXLOCK_NBLOCK_UNSS_ONSTACKSS_DISABLEFD_SETSIZEEPOLLRDNORMEPOLLRDBANDEPOLLWRNORMEPOLLWRBANDEPOLLMSGMNT_DETACHMNT_EXPIREQ_GETFMTQ_GETINFOQ_SETINFOQIF_BLIMITSQIF_SPACEQIF_ILIMITSQIF_INODESQIF_BTIMEQIF_ITIMEQIF_LIMITSQIF_USAGEQIF_TIMESQIF_ALLMNT_FORCEQ_SYNCQ_QUOTAONQ_QUOTAOFFQ_GETQUOTAQ_SETQUOTATCIOFFTCIONTCOOFFTCOONTCIFLUSHTCOFLUSHTCIOFLUSHNL0NL1TAB0FF0BS0VT0VERASEVKILLVINTRVQUITVLNEXTIGNBRKBRKINTIGNPARPARMRKINPCKISTRIPINLCRIGNCRICRNLIXANYIMAXBELOPOSTCS5CRTSCTSECHOOCRNLONOCRONLRETOFILLOFDELCLONE_VMCLONE_FSCLONE_FILESCLONE_SIGHANDCLONE_PTRACECLONE_VFORKCLONE_PARENTCLONE_THREADCLONE_NEWNSCLONE_SYSVSEMCLONE_SETTLSCLONE_PARENT_SETTIDCLONE_CHILD_CLEARTIDCLONE_DETACHEDCLONE_UNTRACEDCLONE_CHILD_SETTIDCLONE_NEWUTSCLONE_NEWIPCCLONE_NEWUSERCLONE_NEWPIDCLONE_NEWNETCLONE_IOCLONE_NEWCGROUPWNOHANGWUNTRACEDWSTOPPEDWEXITEDWCONTINUEDWNOWAITPTRACE_O_TRACESYSGOOD// Options set using PTRACE_SETOPTIONS.PTRACE_O_TRACEFORKPTRACE_O_TRACEVFORKPTRACE_O_TRACECLONEPTRACE_O_TRACEEXECPTRACE_O_TRACEVFORKDONEPTRACE_O_TRACEEXITPTRACE_O_TRACESECCOMPPTRACE_O_EXITKILLPTRACE_O_SUSPEND_SECCOMPPTRACE_O_MASKPTRACE_EVENT_FORK// Wait extended result codes for the above trace options.PTRACE_EVENT_VFORKPTRACE_EVENT_CLONEPTRACE_EVENT_EXECPTRACE_EVENT_VFORK_DONEPTRACE_EVENT_EXITPTRACE_EVENT_SECCOMP__WNOTHREAD__WALL__WCLONESPLICE_F_MOVESPLICE_F_NONBLOCKSPLICE_F_MORESPLICE_F_GIFTPOSIX_FADV_NORMALPOSIX_FADV_RANDOMPOSIX_FADV_SEQUENTIALPOSIX_FADV_WILLNEEDAT_FDCWDAT_SYMLINK_NOFOLLOWAT_REMOVEDIRAT_EACCESSAT_SYMLINK_FOLLOWAT_NO_AUTOMOUNTAT_EMPTY_PATHLOG_CRONLOG_AUTHPRIVLOG_FTPLOG_PERRORPIPE_BUFSI_LOAD_SHIFTCLD_EXITEDCLD_KILLEDCLD_DUMPEDCLD_TRAPPEDCLD_STOPPEDCLD_CONTINUEDSIGEV_SIGNALSIGEV_NONESIGEV_THREADP_ALLP_PIDP_PGIDUTIME_OMITUTIME_NOWPOLLPRIPOLLNVALPOLLRDNORMPOLLRDBANDABDAY_1ABDAY_2ABDAY_3ABDAY_4ABDAY_5ABDAY_6ABDAY_7DAY_1DAY_2DAY_3DAY_4DAY_5DAY_6DAY_7ABMON_1ABMON_2ABMON_3ABMON_4ABMON_5ABMON_6ABMON_7ABMON_8ABMON_9ABMON_10ABMON_11ABMON_12MON_1MON_2MON_3MON_4MON_5MON_6MON_7MON_8MON_9MON_10MON_11MON_12AM_STRPM_STRD_T_FMTD_FMTT_FMTT_FMT_AMPMERAERA_D_FMTALT_DIGITSERA_D_T_FMTERA_T_FMTCODESETCRNCYSTRRUSAGE_THREADRUSAGE_CHILDRENRADIXCHARTHOUSEPYESEXPRNOEXPRYESSTRNOSTRFILENAME_MAXL_tmpnam_PC_LINK_MAX_PC_MAX_CANON_PC_MAX_INPUT_PC_NAME_MAX_PC_PATH_MAX_PC_PIPE_BUF_PC_CHOWN_RESTRICTED_PC_NO_TRUNC_PC_VDISABLE_PC_SYNC_IO_PC_ASYNC_IO_PC_PRIO_IO_PC_SOCK_MAXBUF_PC_FILESIZEBITS_PC_REC_INCR_XFER_SIZE_PC_REC_MAX_XFER_SIZE_PC_REC_MIN_XFER_SIZE_PC_REC_XFER_ALIGN_PC_ALLOC_SIZE_MIN_PC_SYMLINK_MAX_PC_2_SYMLINKS_SC_ARG_MAX_SC_CHILD_MAX_SC_NGROUPS_MAX_SC_OPEN_MAX_SC_STREAM_MAX_SC_TZNAME_MAX_SC_JOB_CONTROL_SC_SAVED_IDS_SC_REALTIME_SIGNALS_SC_PRIORITY_SCHEDULING_SC_TIMERS_SC_ASYNCHRONOUS_IO_SC_PRIORITIZED_IO_SC_SYNCHRONIZED_IO_SC_FSYNC_SC_MAPPED_FILES_SC_MEMLOCK_SC_MEMLOCK_RANGE_SC_MEMORY_PROTECTION_SC_MESSAGE_PASSING_SC_SEMAPHORES_SC_SHARED_MEMORY_OBJECTS_SC_AIO_LISTIO_MAX_SC_AIO_MAX_SC_AIO_PRIO_DELTA_MAX_SC_DELAYTIMER_MAX_SC_MQ_OPEN_MAX_SC_MQ_PRIO_MAX_SC_VERSION_SC_PAGE_SIZE_SC_RTSIG_MAX_SC_SEM_NSEMS_MAX_SC_SEM_VALUE_MAX_SC_SIGQUEUE_MAX_SC_TIMER_MAX_SC_BC_BASE_MAX_SC_BC_DIM_MAX_SC_BC_SCALE_MAX_SC_BC_STRING_MAX_SC_COLL_WEIGHTS_MAX_SC_EXPR_NEST_MAX_SC_LINE_MAX_SC_RE_DUP_MAX_SC_2_VERSION_SC_2_C_BIND_SC_2_C_DEV_SC_2_FORT_DEV_SC_2_FORT_RUN_SC_2_SW_DEV_SC_2_LOCALEDEF_SC_UIO_MAXIOV_SC_IOV_MAX_SC_THREADS_SC_THREAD_SAFE_FUNCTIONS_SC_GETGR_R_SIZE_MAX_SC_GETPW_R_SIZE_MAX_SC_LOGIN_NAME_MAX_SC_TTY_NAME_MAX_SC_THREAD_DESTRUCTOR_ITERATIONS_SC_THREAD_KEYS_MAX_SC_THREAD_STACK_MIN_SC_THREAD_THREADS_MAX_SC_THREAD_ATTR_STACKADDR_SC_THREAD_ATTR_STACKSIZE_SC_THREAD_PRIORITY_SCHEDULING_SC_THREAD_PRIO_INHERIT_SC_THREAD_PRIO_PROTECT_SC_THREAD_PROCESS_SHARED_SC_NPROCESSORS_CONF_SC_NPROCESSORS_ONLN_SC_PHYS_PAGES_SC_AVPHYS_PAGES_SC_ATEXIT_MAX_SC_PASS_MAX_SC_XOPEN_VERSION_SC_XOPEN_XCU_VERSION_SC_XOPEN_UNIX_SC_XOPEN_CRYPT_SC_XOPEN_ENH_I18N_SC_XOPEN_SHM_SC_2_CHAR_TERM_SC_2_UPE_SC_XOPEN_XPG2_SC_XOPEN_XPG3_SC_XOPEN_XPG4_SC_NZERO_SC_XBS5_ILP32_OFF32_SC_XBS5_ILP32_OFFBIG_SC_XBS5_LP64_OFF64_SC_XBS5_LPBIG_OFFBIG_SC_XOPEN_LEGACY_SC_XOPEN_REALTIME_SC_XOPEN_REALTIME_THREADS_SC_ADVISORY_INFO_SC_BARRIERS_SC_CLOCK_SELECTION_SC_CPUTIME_SC_THREAD_CPUTIME_SC_MONOTONIC_CLOCK_SC_READER_WRITER_LOCKS_SC_SPIN_LOCKS_SC_REGEXP_SC_SHELL_SC_SPAWN_SC_SPORADIC_SERVER_SC_THREAD_SPORADIC_SERVER_SC_TIMEOUTS_SC_TYPED_MEMORY_OBJECTS_SC_2_PBS_SC_2_PBS_ACCOUNTING_SC_2_PBS_LOCATE_SC_2_PBS_MESSAGE_SC_2_PBS_TRACK_SC_SYMLOOP_MAX_SC_STREAMS_SC_2_PBS_CHECKPOINT_SC_V6_ILP32_OFF32_SC_V6_ILP32_OFFBIG_SC_V6_LP64_OFF64_SC_V6_LPBIG_OFFBIG_SC_TRACE_SC_TRACE_EVENT_FILTER_SC_TRACE_INHERIT_SC_TRACE_LOG_SC_IPV6_SC_RAW_SOCKETS_SC_V7_ILP32_OFF32_SC_V7_ILP32_OFFBIG_SC_V7_LP64_OFF64_SC_V7_LPBIG_OFFBIG_SC_SS_REPL_MAX_SC_TRACE_EVENT_NAME_MAX_SC_TRACE_NAME_MAX_SC_TRACE_SYS_MAX_SC_TRACE_USER_EVENT_MAX_SC_XOPEN_STREAMS_SC_THREAD_ROBUST_PRIO_INHERIT_SC_THREAD_ROBUST_PRIO_PROTECTRLIM_SAVED_MAXRLIM_SAVED_CURGLOB_ERRGLOB_MARKGLOB_NOSORTGLOB_DOOFFSGLOB_NOCHECKGLOB_APPENDGLOB_NOESCAPEGLOB_NOSPACEGLOB_ABORTEDGLOB_NOMATCHPOSIX_MADV_NORMALPOSIX_MADV_RANDOMPOSIX_MADV_SEQUENTIALPOSIX_MADV_WILLNEEDS_IEXECS_IWRITES_IREADF_LOCKF_TESTF_TLOCKF_ULOCKIFF_LOWER_UPIFF_DORMANTIFF_ECHOST_RDONLYST_NOSUIDST_NODEVST_NOEXECST_SYNCHRONOUSST_MANDLOCKST_WRITEST_APPENDST_IMMUTABLEST_NOATIMEST_NODIRATIMERTLD_NEXTRTLD_DEFAULTRTLD_NODELETERTLD_NOWTCP_MD5SIGPTHREAD_MUTEX_INITIALIZERPTHREAD_COND_INITIALIZERpthread_cond_tPTHREAD_RWLOCK_INITIALIZERpthread_rwlock_tPTHREAD_MUTEX_NORMALPTHREAD_MUTEX_RECURSIVEPTHREAD_MUTEX_ERRORCHECKPTHREAD_MUTEX_DEFAULTPTHREAD_PROCESS_PRIVATEPTHREAD_PROCESS_SHARED__SIZEOF_PTHREAD_COND_TRENAME_NOREPLACERENAME_EXCHANGERENAME_WHITEOUTSCHED_OTHERSCHED_FIFOSCHED_RRSCHED_BATCHSCHED_IDLEIPPROTO_HOPOPTS// IPPROTO_IP defined in src/unix/mod.rs/// Hop-by-hop option headerIPPROTO_IGMP// IPPROTO_ICMP defined in src/unix/mod.rs/// group mgmt protocolIPPROTO_IPIP/// for compatibilityIPPROTO_EGP// IPPROTO_TCP defined in src/unix/mod.rs/// exterior gateway protocolIPPROTO_PUP/// pupIPPROTO_IDP// IPPROTO_UDP defined in src/unix/mod.rs/// xns idpIPPROTO_TP/// tp-4 w/ class negotiationIPPROTO_DCCP/// DCCPIPPROTO_ROUTING// IPPROTO_IPV6 defined in src/unix/mod.rs/// IP6 routing headerIPPROTO_FRAGMENT/// IP6 fragmentation headerIPPROTO_RSVP/// resource reservationIPPROTO_GRE/// General Routing Encap.IPPROTO_ESP/// IP6 Encap Sec. PayloadIPPROTO_AH/// IP6 Auth HeaderIPPROTO_NONE// IPPROTO_ICMPV6 defined in src/unix/mod.rs/// IP6 no next headerIPPROTO_DSTOPTS/// IP6 destination optionIPPROTO_MTPIPPROTO_BEETPHIPPROTO_ENCAP/// encapsulation headerIPPROTO_PIM/// Protocol indep. multicastIPPROTO_COMP/// IP Payload Comp. ProtocolIPPROTO_SCTP/// SCTPIPPROTO_MHIPPROTO_UDPLITEIPPROTO_MPLSIPPROTO_RAW/// raw IP packetIPPROTO_MAXAF_IBAF_MPLSAF_NFCAF_VSOCKPF_IBPF_MPLSPF_NFCPF_VSOCKIPC_PRIVATE// System V IPCIPC_CREATIPC_EXCLIPC_NOWAITIPC_RMIDIPC_SETIPC_STATIPC_INFOMSG_STATMSG_INFOMSG_NOERRORMSG_EXCEPTMSG_COPYSHM_RSHM_WSHM_RDONLYSHM_RNDSHM_REMAPSHM_EXECSHM_LOCKSHM_UNLOCKSHM_HUGETLBSHM_NORESERVEQFMT_VFS_OLDQFMT_VFS_V0QFMT_VFS_V1EFD_SEMAPHORELOG_NFACILITIESSEM_FAILEDsem_tRB_AUTOBOOTRB_HALT_SYSTEMRB_ENABLE_CADRB_DISABLE_CADRB_POWER_OFFRB_SW_SUSPENDRB_KEXECAI_PASSIVEAI_CANONNAMEAI_NUMERICHOSTAI_V4MAPPEDAI_ALLAI_ADDRCONFIGAI_NUMERICSERVEAI_BADFLAGSEAI_NONAMEEAI_AGAINEAI_FAILEAI_FAMILYEAI_SOCKTYPEEAI_SERVICEEAI_MEMORYEAI_OVERFLOWNI_NUMERICHOSTNI_NUMERICSERVNI_NOFQDNNI_NAMEREQDNI_DGRAMSYNC_FILE_RANGE_WAIT_BEFORESYNC_FILE_RANGE_WRITESYNC_FILE_RANGE_WAIT_AFTEREAI_SYSTEMAIO_CANCELEDAIO_NOTCANCELEDAIO_ALLDONELIO_READLIO_WRITELIO_NOPLIO_WAITLIO_NOWAITMREMAP_MAYMOVEMREMAP_FIXEDPR_SET_PDEATHSIGPR_GET_PDEATHSIGPR_GET_DUMPABLEPR_SET_DUMPABLEPR_GET_UNALIGNPR_SET_UNALIGNPR_UNALIGN_NOPRINTPR_UNALIGN_SIGBUSPR_GET_KEEPCAPSPR_SET_KEEPCAPSPR_GET_FPEMUPR_SET_FPEMUPR_FPEMU_NOPRINTPR_FPEMU_SIGFPEPR_GET_FPEXCPR_SET_FPEXCPR_FP_EXC_SW_ENABLEPR_FP_EXC_DIVPR_FP_EXC_OVFPR_FP_EXC_UNDPR_FP_EXC_RESPR_FP_EXC_INVPR_FP_EXC_DISABLEDPR_FP_EXC_NONRECOVPR_FP_EXC_ASYNCPR_FP_EXC_PRECISEPR_GET_TIMINGPR_SET_TIMINGPR_TIMING_STATISTICALPR_TIMING_TIMESTAMPPR_SET_NAMEPR_GET_NAMEPR_GET_ENDIANPR_SET_ENDIANPR_ENDIAN_BIGPR_ENDIAN_LITTLEPR_ENDIAN_PPC_LITTLEPR_GET_SECCOMPPR_CAPBSET_READPR_CAPBSET_DROPPR_GET_TSCPR_SET_TSCPR_TSC_ENABLEPR_TSC_SIGSEGVPR_GET_SECUREBITSPR_SET_SECUREBITSPR_SET_TIMERSLACKPR_GET_TIMERSLACKPR_TASK_PERF_EVENTS_DISABLEPR_TASK_PERF_EVENTS_ENABLEPR_MCE_KILLPR_MCE_KILL_CLEARPR_MCE_KILL_SETPR_MCE_KILL_LATEPR_MCE_KILL_EARLYPR_MCE_KILL_DEFAULTPR_MCE_KILL_GETPR_SET_MMPR_SET_MM_START_CODEPR_SET_MM_END_CODEPR_SET_MM_START_DATAPR_SET_MM_END_DATAPR_SET_MM_START_STACKPR_SET_MM_START_BRKPR_SET_MM_BRKPR_SET_MM_ARG_STARTPR_SET_MM_ARG_ENDPR_SET_MM_ENV_STARTPR_SET_MM_ENV_ENDPR_SET_MM_AUXVPR_SET_MM_EXE_FILEPR_SET_MM_MAPPR_SET_MM_MAP_SIZEPR_SET_PTRACERPR_SET_PTRACER_ANYPR_SET_CHILD_SUBREAPERPR_GET_CHILD_SUBREAPERPR_SET_NO_NEW_PRIVSPR_GET_NO_NEW_PRIVSPR_GET_TID_ADDRESSPR_SET_THP_DISABLEPR_GET_THP_DISABLEPR_MPX_ENABLE_MANAGEMENTPR_MPX_DISABLE_MANAGEMENTPR_SET_FP_MODEPR_GET_FP_MODEPR_FP_MODE_FRPR_FP_MODE_FREPR_CAP_AMBIENTPR_CAP_AMBIENT_IS_SETPR_CAP_AMBIENT_RAISEPR_CAP_AMBIENT_LOWERPR_CAP_AMBIENT_CLEAR_ALLITIMER_REALITIMER_VIRTUALITIMER_PROFTFD_CLOEXECTFD_NONBLOCKTFD_TIMER_ABSTIMEXATTR_CREATEXATTR_REPLACE_POSIX_VDISABLEFALLOC_FL_KEEP_SIZEFALLOC_FL_PUNCH_HOLEFALLOC_FL_COLLAPSE_RANGEFALLOC_FL_ZERO_RANGEFALLOC_FL_INSERT_RANGEFALLOC_FL_UNSHARE_RANGEENOATTR// On Linux, libc doesn't define this constant, libattr does instead.// We still define it for Linux as it's defined by libc on other platforms,// and it's mentioned in the man pages for getxattr and setxattr.SO_ORIGINAL_DSTIUTF8CMSPARMFD_CLOEXECMFD_ALLOW_SEALINGPT_NULL// these are used in the p_type field of Elf32_Phdr and Elf64_Phdr, which has// the type Elf32Word and Elf64Word respectively. Luckily, both of those are u32// so we can use that type here to avoid having to cast.PT_DYNAMICPT_INTERPPT_SHLIBPT_PHDRPT_TLSPT_NUMPT_LOOSPT_GNU_EH_FRAMEPT_GNU_STACKPT_GNU_RELROETH_P_LOOP// Ethernet protocol IDs.ETH_P_PUPETH_P_PUPATETH_P_IPETH_P_X25ETH_P_ARPETH_P_BPQETH_P_IEEEPUPETH_P_IEEEPUPATETH_P_BATMANETH_P_DECETH_P_DNA_DLETH_P_DNA_RCETH_P_DNA_RTETH_P_LATETH_P_DIAGETH_P_CUSTETH_P_SCAETH_P_TEBETH_P_RARPETH_P_ATALKETH_P_AARPETH_P_8021QETH_P_IPXETH_P_IPV6ETH_P_PAUSEETH_P_SLOWETH_P_WCCPETH_P_MPLS_UCETH_P_MPLS_MCETH_P_ATMMPOAETH_P_PPP_DISCETH_P_PPP_SESETH_P_LINK_CTLETH_P_ATMFATEETH_P_PAEETH_P_AOEETH_P_8021ADETH_P_802_EX1ETH_P_TIPCETH_P_8021AHETH_P_MVRPETH_P_1588ETH_P_PRPETH_P_FCOEETH_P_TDLSETH_P_FIPETH_P_80221ETH_P_LOOPBACKETH_P_QINQ1ETH_P_QINQ2ETH_P_QINQ3ETH_P_EDSAETH_P_AF_IUCVETH_P_802_3_MINETH_P_802_3ETH_P_AX25ETH_P_ALLETH_P_802_2ETH_P_SNAPETH_P_DDCMPETH_P_WAN_PPPETH_P_PPP_MPETH_P_LOCALTALKETH_P_CANETH_P_CANFDETH_P_PPPTALKETH_P_TR_802_2ETH_P_MOBITEXETH_P_CONTROLETH_P_IRDAETH_P_ECONETETH_P_HDLCETH_P_ARCNETETH_P_DSAETH_P_TRAILERETH_P_PHONETETH_P_IEEE802154ETH_P_CAIFSFD_CLOEXECNCCSO_NOATIMEO_TMPFILEEBFONTENOSTRETIMEENOSRENONETENOPKGEADVESRMNTECOMMEDOTDOTSA_NODEFERSA_RESETHANDSA_RESTARTSA_NOCLDSTOPEPOLL_CLOEXECEFD_CLOEXECBUFSIZTMP_MAXFOPEN_MAXO_PATHO_EXECO_SEARCHO_ACCMODEO_NDELAYNI_MAXHOSTPTHREAD_STACK_MINPOSIX_FADV_DONTNEEDPOSIX_FADV_NOREUSEPOSIX_MADV_DONTNEEDRLIM_INFINITYRLIMIT_RTTIMERLIMIT_NLIMITSRLIM_NLIMITSMAP_ANONYMOUSSOCK_DCCPSOCK_PACKETTCP_COOKIE_TRANSACTIONSTCP_THIN_LINEAR_TIMEOUTSTCP_THIN_DUPACKTCP_USER_TIMEOUTTCP_REPAIRTCP_REPAIR_QUEUETCP_QUEUE_SEQTCP_REPAIR_OPTIONSTCP_FASTOPENTCP_TIMESTAMPSIGUNUSED__SIZEOF_PTHREAD_CONDATTR_T__SIZEOF_PTHREAD_MUTEXATTR_T__SIZEOF_PTHREAD_RWLOCKATTR_TCPU_SETSIZEPTRACE_TRACEMEPTRACE_PEEKTEXTPTRACE_PEEKDATAPTRACE_PEEKUSERPTRACE_POKETEXTPTRACE_POKEDATAPTRACE_POKEUSERPTRACE_CONTPTRACE_KILLPTRACE_SINGLESTEPPTRACE_GETREGSPTRACE_SETREGSPTRACE_GETFPREGSPTRACE_SETFPREGSPTRACE_ATTACHPTRACE_DETACHPTRACE_GETFPXREGSPTRACE_SETFPXREGSPTRACE_SYSCALLPTRACE_SETOPTIONSPTRACE_GETEVENTMSGPTRACE_GETSIGINFOPTRACE_SETSIGINFOPTRACE_GETREGSETPTRACE_SETREGSETPTRACE_SEIZEPTRACE_INTERRUPTPTRACE_LISTENPTRACE_PEEKSIGINFOEFD_NONBLOCKSFD_NONBLOCKTCSANOWTCSADRAINTCSAFLUSHRTLD_GLOBALRTLD_NOLOADMCL_CURRENTMCL_FUTURECBAUDTAB1TAB2TAB3FF1BS1VT1VWERASEVREPRINTVSUSPVSTARTVSTOPVDISCARDVTIMEIXONIXOFFONLCRCSIZECS6CS7CS8CSTOPBCREADPARENBPARODDHUPCLCLOCALECHOKEECHOEECHOKECHONLECHOPRTECHOCTLISIGICANONPENDINNOFLSHCIBAUDCBAUDEXVSWTCOLCUCNLDLYCRDLYTABDLYBSDLYFFDLYVTDLYXTABSB50B75B110B134B150B200B300B600B1200B1800B2400B4800B9600B19200B38400EXTAEXTBB57600B115200B230400B460800B500000B576000B921600B1000000B1152000B1500000B2000000B2500000B3000000B3500000B4000000SO_BINDTODEVICESO_TIMESTAMPSO_MARKSO_RXQ_OVFLSO_PEEK_OFFSO_BUSY_POLLSO_BINDTOIFINDEX__SIZEOF_PTHREAD_RWLOCK_T__SIZEOF_PTHREAD_MUTEX_TO_ASYNCRLIMIT_RSSRLIMIT_NOFILERLIMIT_ASRLIMIT_NPROCRLIMIT_MEMLOCKO_APPENDO_EXCLO_NOCTTYO_SYNCO_RSYNCO_DSYNCSOCK_CLOEXECSOCK_NONBLOCKMAP_ANONMAP_GROWSDOWNMAP_DENYWRITEMAP_EXECUTABLEMAP_LOCKEDMAP_NORESERVEMAP_POPULATEMAP_NONBLOCKMAP_STACKSOCK_DGRAMSOCK_SEQPACKETECHRNGEL2NSYNCEL3HLTEL3RSTELNRNGEUNATCHENOCSIEL2HLTEBADEEBADREXFULLENOANOEBADRQCEBADSLTEDEADLOCKENOTUNIQEBADFDEREMCHGELIBACCELIBBADELIBSCNELIBMAXELIBEXECERESTARTESTRPIPEEUCLEANENOTNAMENAVAILEISNAMEREMOTEIOENOMEDIUMEMEDIUMTYPEENOKEYEKEYEXPIREDEKEYREVOKEDEKEYREJECTEDERFKILLEHWPOISONSO_REUSEADDRSO_TYPESO_DONTROUTESO_BROADCASTSO_SNDBUFSO_RCVBUFSO_KEEPALIVESO_OOBINLINESO_NO_CHECKSO_PRIORITYSO_LINGERSO_BSDCOMPATSO_REUSEPORTSO_PASSCREDSO_PEERCREDSO_RCVLOWATSO_SNDLOWATSO_RCVTIMEOSO_SNDTIMEOSO_ACCEPTCONNSO_SNDBUFFORCESO_RCVBUFFORCESO_PROTOCOLSO_DOMAINSA_ONSTACKSA_SIGINFOSA_NOCLDWAITSIGSTKFLTSIGPOLLSIGPWRSIG_SETMASKSIG_BLOCKSIG_UNBLOCKEXTPROCMAP_HUGETLBF_GETLKF_GETOWNF_SETLKF_SETLKWF_SETOWNVEOFVEOLVEOL2VMINIEXTENTOSTOPFLUSHOPOLLWRNORMPOLLWRBANDO_DIRECTORYO_DIRECTO_LARGEFILEO_NOFOLLOWHUGETLB_FLAG_ENCODE_SHIFTMAP_HUGE_SHIFT// intentionally not public, only used for fd_setsafe_f__CMSG_LENcmsghdr__CMSG_NEXT__MHDR_ENDmsghdrfpos_tisalnumisalphaiscntrlisdigitisgraphislowerisprintispunctisspaceisupperisxdigitisblanktolowertoupperfopenfreopenfflushfclosetmpfilesetvbufsetbufgetcharputcharfgetcfgetsfputcfputsputsungetcfreadfwritefseekftellfgetposfsetposfeofferrorperroratofatoiatolatollstrtodstrtofstrtolstrtollstrtoull_exitatexitstrcpystrncpystrcatstrncatstrncmpstrcollstrchrstrrchrstrspnstrcspnstrpbrkstrstrstrnlenstrtokstrxfrmwcstombswmemchrmemcmpmemmovelabssrandgetpwnamgetpwuidfprintfprintfsnprintfsprintffscanfscanfsscanfgetchar_unlockedputchar_unlockedgetpeernamesetsockoptsendtofchmodfstatstatpclosefdopenfilenocreatreaddir_rclosedirrewinddiropenatfchmodatfchownfchownatfstatatlinkatmkdiratreadlinkatrenameatsymlinkatunlinkatalarmchownlchownexeclexecleexeclpexecv// DIFF(main): changed to `*const *mut` in e77f551de9execveexecvpfpathconfgetcwdgetegidgetgidgetgroupsgetlogingetoptgetpgidgetpgrpgetpidgetppidgetuidisattypathconfposix_memalignseteuidsetegidsetgidsetpgidsetsidsetuidnanosleeptcgetpgrptcsetpgrpttynamewaitpidpreadpwriteutimbufmlockmunlockmlockallmunlockallif_nametoindexif_indextonamelstatftruncateflockgettimeofdaytimestmspthread_selfpthread_joinpthread_exitpthread_attr_initpthread_attr_tpthread_attr_destroypthread_attr_getstacksizepthread_attr_setstacksizepthread_attr_setdetachstatepthread_detachsched_yieldpthread_key_createpthread_key_deletepthread_getspecificpthread_setspecificpthread_mutex_initpthread_mutexattr_tpthread_mutex_destroypthread_mutex_lockpthread_mutex_trylockpthread_mutex_unlockpthread_mutexattr_initpthread_mutexattr_destroypthread_mutexattr_settypepthread_cond_initpthread_condattr_tpthread_cond_waitpthread_cond_timedwaitpthread_cond_signalpthread_cond_broadcastpthread_cond_destroypthread_condattr_initpthread_condattr_destroypthread_rwlock_initpthread_rwlockattr_tpthread_rwlock_destroypthread_rwlock_rdlockpthread_rwlock_tryrdlockpthread_rwlock_wrlockpthread_rwlock_trywrlockpthread_rwlock_unlockpthread_rwlockattr_initpthread_rwlockattr_destroypthread_getname_nppthread_setname_npsigactiongetaddrinfoaddrinfofreeaddrinfogai_strerrorres_initgmtime_rtmlocaltime_rmktimegmtimelocaltimeunameutsnamegetservbynameserventgetprotobynameprotoentgetprotobynumbersetlocalelocaleconvlconvsem_destroysem_waitsem_trywaitsem_postsem_initfstatvfssigemptysetsigset_tsigaddsetsigfillsetsigdelsetsigismembersigprocmasksigpendingtimegmgetsidmkfifopselectfseekoftellotcdraincfgetispeedcfgetospeedcfmakerawcfsetispeedcfsetospeedcfsetspeedtcgetattrtcsetattrtcflowtcflushtcgetsidtcsendbreaktmpnamopenlogcloselogsetlogmasksysloggrantptposix_openptptsnameunlockptclock_getresclock_gettimeclock_settimedirfdpthread_getattr_nppthread_attr_getstackmemalignsetgroupsfstatfsmemrchrposix_fadviseduplocalefreelocalenewlocaleuselocalefdopendirmknodatpthread_condattr_getclockpthread_condattr_setclockaccept4ptsname_rclearenvwaitidsetreuidsetregidgetresuidgetresgidacctbrksetresgidsetresuidexecvpefexecvelutimesshm_openshmgetshmatshmdtshmctlshmid_dsftoksemgetsemopsembufsemctlmsgctlmsqid_dsmsggetmsgrcvmsgsndmprotectposix_fallocatereadaheadtimerfd_createtimerfd_gettimeitimerspectimerfd_settimepwriteviovecpreadvquotactldup3mkostempmkostempssigtimedwaitsigwaitinfonl_langinfo_lgetnameinforebootsetfsgidsetfsuidmkfifoat// Not available now on Androidif_nameindexif_freenameindexsync_file_rangegetifaddrsfreeifaddrsglob_tglobfreeposix_madviseshm_unlinkseekdirtelldirmadvisemsyncrecvfrommkstempsfutimesnl_langinforeadvsendmsgrecvmsggetdomainnamesetdomainnamevhangupsendmmsgmmsghdrrecvmmsgsched_getaffinitycpu_set_tsched_setaffinityumountsched_get_priority_maxsettimeofdaysched_rr_get_intervalsem_timedwaitsem_getvaluesched_setparamsched_paramswapoffvmsplicesched_getparamppollpthread_mutex_timedlocksched_getschedulerclock_nanosleeppthread_attr_getguardsizepthread_attr_setguardsizesethostnamesched_get_priority_minumount2swaponsched_setschedulersigsuspendsigaltstackstack_tsem_closegetdtablesizegetgrnam_rinitgroupspthread_sigmasksem_opengetgrnampthread_cancelpthread_killsem_unlinkdaemongetpwnam_rgetpwuid_rsigwaitpthread_atforkgetgrgidsetgrentendgrentgetgrentpopenfaccessatpthread_create//! Definitions found commonly among almost all Unix derivatives//! More functions and definitions can be found in the more specific modules//! according to the platform in question.// PUB_TYPE// PUB_STRUCT// PUB_CONST// FIXME(#235): Include file sealing fcntls once we have a way to verify them.// LC_ALL_MASK defined per platform// PTRACE_EVENT_STOP was added to glibc in 2.26// pub const PTRACE_EVENT_STOP: c_int = 128;// netinet/in.h// NOTE: These are in addition to the constants defined in src/unix/mod.rs// END_PUB_CONST// EXTERN_FN// From psABI Calling Convention for RV64stat64// offsets in user_regs_structs, from sys/reg.hORIG_RAXRIPEFLAGSMAP_32BITDT_WHTEAI_NODATAFUTEX_RELATIVE_TIMEOUTPOLLRDHUP"sys_alloc""sys_alloc_zeroed""sys_realloc""sys_dealloc""sys_exit""sys_abort""sys_errno""sys_clock_gettime""sys_nanosleep""sys_available_parallelism"available_parallelism"sys_futex_wait"futex_wait"sys_futex_wake"futex_wake"sys_stat""sys_fstat""sys_lstat""sys_open""sys_unlink""sys_mkdir""sys_rmdir""sys_read""sys_write""sys_readv""sys_writev""sys_close""sys_dup""sys_fcntl""sys_getdents64"getdents64dirent64"sys_getaddrinfo""sys_freeaddrinfo""sys_socket""sys_bind""sys_listen""sys_accept""sys_connect""sys_recv""sys_recvfrom""sys_send""sys_sendto""sys_getpeername""sys_getsockname""sys_getsockopt""sys_setsockopt""sys_ioctl""sys_shutdown""sys_eventfd""sys_poll"//! Hermit C type definitions"libc"// Keep this order.// This lint is renamed but we run CI for old stable rustc so should be here.// FIXME(1.0): temporarily allow dead_code to fix CI:// - https://github.com/rust-lang/libc/issues/3740// - https://github.com/rust-lang/rust/pull/126456r" Frequently-used types that are available on all platforms"r" We need to reexport the core types so this works with `rust-dep-of-std`."//! libc - Raw FFI bindings to platforms' system libraries// Attributes needed when building as part of the standard library// DIFF(1.0): The thread local references that raise this lint were removed in 1.0// Enable extra lints:// Collects all the negated `cfg`s in a list at the beginning and after the/// A macro for defining #[cfg] if-else statements./// This is similar to the `if/elif` C preprocessor macro by allowing definition/// of a cascade of `#[cfg]` cases, emitting the implementation which matches/// This allows you to conveniently provide a long list #[cfg]'d blocks of code/// without having to rewrite each clause multiple times./// Create an internal crate prelude with `core` reexports and common types./// Implement `Clone` and `Copy` for a struct, as well as `Debug`, `Eq`, `Hash`, and/// `PartialEq` if the `extra_traits` feature is enabled./// Use [`s_no_extra_traits`] for structs where the `extra_traits` feature does not/// make sense, and for unions.s_paren/// Implement `Clone` and `Copy` for a tuple struct, as well as `Debug`, `Eq`, `Hash`,/// and `PartialEq` if the `extra_traits` feature is enabled./// This is the same as [`s`] but works for tuple structs./// Implement `Clone` and `Copy` for a struct with no `extra_traits` feature./// Most items will prefer to use [`s`].missing/// Specify that an enum should have no traits that aren't specified in the macro/// invocation, i.e. no `Clone` or `Copy`./// Implement `Clone` and `Copy` for an enum, as well as `Debug`, `Eq`, `Hash`, andr" Define an `unsafe` function that is const as long as `libc_const_extern_fn` is enabled."r" Define a safe function that is const as long as `libc_const_extern_fn` is enabled."r" A nonpublic function that is const as long as `libc_const_extern_fn` is enabled."// FIXME(ctest): ctest can't handle `const extern` functions, we should be able to remove this// cfg completely.// FIXME(ctest): ctest can't handle `$(,)?` so we use `$(,)*` which isn't quite correct.__itemdeprecated_mach// This macro is used to deprecate items that should be accessed via the mach2 crate// This is a pretty horrible hack to allow us to conditionally mark some functions as 'const',// without requiring users of this macro to care "libc_const_extern_fn".// When 'libc_const_extern_fn' is enabled, we emit the captured 'const' keyword in the expanded// When 'libc_const_extern_fn' is disabled, we always emit a plain 'pub unsafe extern fn'.// Note that the expression matched by the macro is exactly the same - this allows// users of this macro to work whether or not 'libc_const_extern_fn' is enabled// Unfortunately, we need to duplicate most of this macro between the 'cfg_if' blocks.// This is because 'const unsafe extern fn' won't even parse on older compilers,// so we need to avoid emitting it at all of 'libc_const_extern_fn'.// Specifically, moving the 'cfg_if' into the macro body will *not* work. Doing so would cause the// '#[cfg(libc_const_extern_fn)]' to be emitted into user code. The 'cfg' gate will not stop Rust// from trying to parse the 'pub const unsafe extern fn', so users would get a compiler error even// when the 'libc_const_extern_fn' feature is disabled.int8_tint16_tint32_tint64_tuint8_tuint16_tuint32_tuint64_t//! This module contains type aliases for C's platform-specific types//! and fixed-width integer types.//! The platform-specific types definitions were taken from rust-lang/rust in//! library/core/src/ffi/primitives.rs//! The fixed-width integer aliases are deprecated: use the Rust types instead.SceKernelVTimerHandlerSceUidSceKernelSysClockSceKernelVTimerHandlerWideSceKernelThreadEventHandlerSceKernelAlarmHandlerSceKernelCallbackFunctionSceKernelThreadEntryPowerCallbackIoPermissionsUmdCallbackSceMpegRingbufferCbGuCallbackGuSwapBuffersCallbackSceNetAdhocctlHandlerAdhocMatchingCallbackSceNetApctlHandlerHttpMallocFunctionHttpReallocFunctionHttpFreeFunctionHttpPasswordCBHttpAuthTypeAUDIO_VOLUME_MAXAUDIO_CHANNEL_MAXAUDIO_NEXT_CHANNELAUDIO_SAMPLE_MINAUDIO_SAMPLE_MAXPSP_CTRL_SELECTPSP_CTRL_STARTPSP_CTRL_UPPSP_CTRL_RIGHTPSP_CTRL_DOWNPSP_CTRL_LEFTPSP_CTRL_LTRIGGERPSP_CTRL_RTRIGGERPSP_CTRL_TRIANGLEPSP_CTRL_CIRCLEPSP_CTRL_CROSSPSP_CTRL_SQUAREPSP_CTRL_HOMEPSP_CTRL_HOLDPSP_CTRL_NOTEPSP_CTRL_SCREENPSP_CTRL_VOLUPPSP_CTRL_VOLDOWNPSP_CTRL_WLAN_UPPSP_CTRL_REMOTEPSP_CTRL_DISCPSP_CTRL_MSUSB_CAM_PIDUSB_BUS_DRIVER_NAMEUSB_CAM_DRIVER_NAMEUSB_CAM_MIC_DRIVER_NAMEUSB_STOR_DRIVER_NAMEACTIVATEDCONNECTEDESTABLISHEDUSB_CAM_FLIPUSB_CAM_MIRRORTHREAD_ATTR_VFPUTHREAD_ATTR_USERTHREAD_ATTR_USBWLANTHREAD_ATTR_VSHTHREAD_ATTR_SCRATCH_SRAMTHREAD_ATTR_NO_FILLSTACKTHREAD_ATTR_CLEAR_STACKEVENT_WAIT_MULTIPLEEVENT_WAIT_ANDEVENT_WAIT_OREVENT_WAIT_CLEARPOWER_INFO_POWER_SWITCHPOWER_INFO_HOLD_SWITCHPOWER_INFO_STANDBYPOWER_INFO_RESUME_COMPLETEPOWER_INFO_RESUMINGPOWER_INFO_SUSPENDINGPOWER_INFO_AC_POWERPOWER_INFO_BATTERY_LOWPOWER_INFO_BATTERY_EXISTPOWER_INFO_BATTERY_POWERFIO_S_IFLNKFIO_S_IFDIRFIO_S_IFREGFIO_S_ISUIDFIO_S_ISGIDFIO_S_ISVTXFIO_S_IRUSRFIO_S_IWUSRFIO_S_IXUSRFIO_S_IRGRPFIO_S_IWGRPFIO_S_IXGRPFIO_S_IROTHFIO_S_IWOTHFIO_S_IXOTHFIO_SO_IFLNKFIO_SO_IFDIRFIO_SO_IFREGFIO_SO_IROTHFIO_SO_IWOTHFIO_SO_IXOTHPSP_O_RD_ONLYPSP_O_WR_ONLYPSP_O_RD_WRPSP_O_NBLOCKPSP_O_DIRPSP_O_APPENDPSP_O_CREATPSP_O_TRUNCPSP_O_EXCLPSP_O_NO_WAITUMD_NOT_PRESENTUMD_PRESENTUMD_CHANGEDUMD_INITINGUMD_INITEDUMD_READYPLAY_PAUSEFORWARDBACKVOL_UPVOL_DOWNHOLDGU_PIGU_TEXTURE_8BITGU_TEXTURE_16BITGU_TEXTURE_32BITFGU_COLOR_5650GU_COLOR_5551GU_COLOR_4444GU_COLOR_8888GU_NORMAL_8BITGU_NORMAL_16BITGU_NORMAL_32BITFGU_VERTEX_8BITGU_VERTEX_16BITGU_VERTEX_32BITFGU_WEIGHT_8BITGU_WEIGHT_16BITGU_WEIGHT_32BITFGU_INDEX_8BITGU_INDEX_16BITGU_WEIGHTS1GU_WEIGHTS2GU_WEIGHTS3GU_WEIGHTS4GU_WEIGHTS5GU_WEIGHTS6GU_WEIGHTS7GU_WEIGHTS8GU_VERTICES1GU_VERTICES2GU_VERTICES3GU_VERTICES4GU_VERTICES5GU_VERTICES6GU_VERTICES7GU_VERTICES8GU_TRANSFORM_2DGU_TRANSFORM_3DGU_COLOR_BUFFER_BITGU_STENCIL_BUFFER_BITGU_DEPTH_BUFFER_BITGU_FAST_CLEAR_BITGU_AMBIENTGU_DIFFUSEGU_SPECULARGU_UNKNOWN_LIGHT_COMPONENTSYSTEM_REGISTRYREG_KEYNAME_SIZEUTILITY_MSGDIALOG_ERRORUTILITY_MSGDIALOG_TEXTUTILITY_MSGDIALOG_YES_NO_BUTTONSUTILITY_MSGDIALOG_DEFAULT_NOUTILITY_HTMLVIEWER_OPEN_SCE_START_PAGEUTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITSUTILITY_HTMLVIEWER_DISABLE_EXIT_DIALOGUTILITY_HTMLVIEWER_DISABLE_CURSORUTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_COMPLETE_DIALOGUTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_START_DIALOGUTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_DESTINATION_DIALOGUTILITY_HTMLVIEWER_LOCK_DOWNLOAD_DESTINATION_DIALOGUTILITY_HTMLVIEWER_DISABLE_TAB_DISPLAYUTILITY_HTMLVIEWER_ENABLE_ANALOG_HOLDUTILITY_HTMLVIEWER_ENABLE_FLASHUTILITY_HTMLVIEWER_DISABLE_LRTRIGGERsceAudioChReserveAudioFormatsceAudioChReleasesceAudioOutputsceAudioOutputBlockingsceAudioOutputPannedsceAudioOutputPannedBlockingsceAudioGetChannelRestLensceAudioGetChannelRestLengthsceAudioSetChannelDataLensceAudioChangeChannelConfigsceAudioChangeChannelVolumesceAudioOutput2ReservesceAudioOutput2ReleasesceAudioOutput2ChangeLengthsceAudioOutput2OutputBlockingsceAudioOutput2GetRestSamplesceAudioSRCChReserveAudioOutputFrequencysceAudioSRCChReleasesceAudioSRCOutputBlockingsceAudioInputInitsceAudioInputInitExAudioInputParamssceAudioInputBlockingAudioInputFrequencysceAudioInputsceAudioGetInputLengthsceAudioWaitInputEndsceAudioPollInputEndsceAtracGetAtracIDsceAtracSetDataAndGetIDsceAtracDecodeDatasceAtracGetRemainFramesceAtracGetStreamDataInfosceAtracAddStreamDatasceAtracGetBitratesceAtracSetLoopNumsceAtracReleaseAtracIDsceAtracGetNextSamplesceAtracGetMaxSamplesceAtracGetBufferInfoForResetingAtrac3BufferInfosceAtracGetChannelsceAtracGetInternalErrorInfosceAtracGetLoopStatussceAtracGetNextDecodePositionsceAtracGetSecondBufferInfosceAtracGetSoundSamplesceAtracResetPlayPositionsceAtracSetDatasceAtracSetHalfwayBuffersceAtracSetHalfwayBufferAndGetIDsceAtracSetSecondBuffersceCtrlSetSamplingCyclesceCtrlGetSamplingCyclesceCtrlSetSamplingModeCtrlModesceCtrlGetSamplingModesceCtrlPeekBufferPositiveSceCtrlDatasceCtrlPeekBufferNegativesceCtrlReadBufferPositivesceCtrlReadBufferNegativesceCtrlPeekLatchSceCtrlLatchsceCtrlReadLatchsceCtrlSetIdleCancelThresholdsceCtrlGetIdleCancelThresholdsceDisplaySetModeDisplayModesceDisplayGetModesceDisplaySetFrameBufDisplayPixelFormatDisplaySetBufSyncsceDisplayGetFrameBufsceDisplayGetVcountsceDisplayWaitVblanksceDisplayWaitVblankCBsceDisplayWaitVblankStartsceDisplayWaitVblankStartCBsceDisplayGetAccumulatedHcountsceDisplayGetCurrentHcountsceDisplayGetFramePerSecsceDisplayIsForegroundsceDisplayIsVblanksceGeEdramGetSizesceGeEdramGetAddrsceGeEdramSetAddrTranslationsceGeGetCmdsceGeGetMtxGeMatrixTypesceGeGetStackGeStacksceGeSaveContextGeContextsceGeRestoreContextsceGeListEnQueueGeListArgssceGeListEnQueueHeadsceGeListDeQueuesceGeListUpdateStallAddrsceGeListSyncGeListStatesceGeDrawSyncsceGeBreakGeBreakParamsceGeContinuesceGeSetCallbackGeCallbackDatasceGeUnsetCallbacksceKernelExitGamesceKernelRegisterExitCallbacksceKernelLoadExecSceKernelLoadExecParamsceKernelAllocPartitionMemorySceSysMemPartitionIdSceSysMemBlockTypessceKernelGetBlockHeadAddrsceKernelFreePartitionMemorysceKernelTotalFreeMemSizesceKernelMaxFreeMemSizesceKernelDevkitVersionsceKernelSetCompiledSdkVersionsceKernelGetCompiledSdkVersionsceKernelLibcTimesceKernelLibcClocksceKernelLibcGettimeofdaysceKernelDcacheWritebackAllsceKernelDcacheWritebackInvalidateAllsceKernelDcacheWritebackRangesceKernelDcacheWritebackInvalidateRangesceKernelDcacheInvalidateRangesceKernelIcacheInvalidateAllsceKernelIcacheInvalidateRangesceKernelUtilsMt19937InitSceKernelUtilsMt19937ContextsceKernelUtilsMt19937UIntsceKernelUtilsMd5DigestsceKernelUtilsMd5BlockInitSceKernelUtilsMd5ContextsceKernelUtilsMd5BlockUpdatesceKernelUtilsMd5BlockResultsceKernelUtilsSha1DigestsceKernelUtilsSha1BlockInitSceKernelUtilsSha1ContextsceKernelUtilsSha1BlockUpdatesceKernelUtilsSha1BlockResultsceKernelRegisterSubIntrHandlersceKernelReleaseSubIntrHandlersceKernelEnableSubIntrsceKernelDisableSubIntrQueryIntrHandlerInfoIntrHandlerOptionParamsceKernelCpuSuspendIntrsceKernelCpuResumeIntrsceKernelCpuResumeIntrWithSyncsceKernelIsCpuIntrSuspendedsceKernelIsCpuIntrEnablesceKernelLoadModuleSceKernelLMOptionsceKernelLoadModuleMssceKernelLoadModuleByIDsceKernelLoadModuleBufferUsbWlansceKernelStartModuleSceKernelSMOptionsceKernelStopModulesceKernelUnloadModulesceKernelSelfStopUnloadModulesceKernelStopUnloadSelfModulesceKernelQueryModuleInfoSceKernelModuleInfosceKernelGetModuleIdListsceKernelVolatileMemLocksceKernelVolatileMemTryLocksceKernelVolatileMemUnlocksceKernelStdinsceKernelStdoutsceKernelStderrsceKernelGetThreadmanIdTypeSceKernelIdListTypesceKernelCreateThreadSceKernelThreadOptParamsceKernelDeleteThreadsceKernelStartThreadsceKernelExitThreadsceKernelExitDeleteThreadsceKernelTerminateThreadsceKernelTerminateDeleteThreadsceKernelSuspendDispatchThreadsceKernelResumeDispatchThreadsceKernelSleepThreadsceKernelSleepThreadCBsceKernelWakeupThreadsceKernelCancelWakeupThreadsceKernelSuspendThreadsceKernelResumeThreadsceKernelWaitThreadEndsceKernelWaitThreadEndCBsceKernelDelayThreadsceKernelDelayThreadCBsceKernelDelaySysClockThreadsceKernelDelaySysClockThreadCBsceKernelChangeCurrentThreadAttrsceKernelChangeThreadPrioritysceKernelRotateThreadReadyQueuesceKernelReleaseWaitThreadsceKernelGetThreadIdsceKernelGetThreadCurrentPrioritysceKernelGetThreadExitStatussceKernelCheckThreadStacksceKernelGetThreadStackFreeSizesceKernelReferThreadStatusSceKernelThreadInfosceKernelReferThreadRunStatusSceKernelThreadRunStatussceKernelCreateSemaSceKernelSemaOptParamsceKernelDeleteSemasceKernelSignalSemasceKernelWaitSemasceKernelWaitSemaCBsceKernelPollSemasceKernelReferSemaStatusSceKernelSemaInfosceKernelCreateEventFlagSceKernelEventFlagOptParamsceKernelSetEventFlagsceKernelClearEventFlagsceKernelPollEventFlagsceKernelWaitEventFlagsceKernelWaitEventFlagCBsceKernelDeleteEventFlagsceKernelReferEventFlagStatusSceKernelEventFlagInfosceKernelCreateMbxSceKernelMbxOptParamsceKernelDeleteMbxsceKernelSendMbxsceKernelReceiveMbxsceKernelReceiveMbxCBsceKernelPollMbxsceKernelCancelReceiveMbxsceKernelReferMbxStatusSceKernelMbxInfosceKernelSetAlarmsceKernelSetSysClockAlarmsceKernelCancelAlarmsceKernelReferAlarmStatusSceKernelAlarmInfosceKernelCreateCallbacksceKernelReferCallbackStatusSceKernelCallbackInfosceKernelDeleteCallbacksceKernelNotifyCallbacksceKernelCancelCallbacksceKernelGetCallbackCountsceKernelCheckCallbacksceKernelGetThreadmanIdListsceKernelReferSystemStatusSceKernelSystemStatussceKernelCreateMsgPipesceKernelDeleteMsgPipesceKernelSendMsgPipesceKernelSendMsgPipeCBsceKernelTrySendMsgPipesceKernelReceiveMsgPipesceKernelReceiveMsgPipeCBsceKernelTryReceiveMsgPipesceKernelCancelMsgPipesceKernelReferMsgPipeStatusSceKernelMppInfosceKernelCreateVplSceKernelVplOptParamsceKernelDeleteVplsceKernelAllocateVplsceKernelAllocateVplCBsceKernelTryAllocateVplsceKernelFreeVplsceKernelCancelVplsceKernelReferVplStatusSceKernelVplInfosceKernelCreateFplSceKernelFplOptParamsceKernelDeleteFplsceKernelAllocateFplsceKernelAllocateFplCBsceKernelTryAllocateFplsceKernelFreeFplsceKernelCancelFplsceKernelReferFplStatusSceKernelFplInfosceKernelUSec2SysClocksceKernelUSec2SysClockWidesceKernelSysClock2USecsceKernelSysClock2USecWidesceKernelGetSystemTimesceKernelGetSystemTimeWidesceKernelGetSystemTimeLowsceKernelCreateVTimerSceKernelVTimerOptParamsceKernelDeleteVTimersceKernelGetVTimerBasesceKernelGetVTimerBaseWidesceKernelGetVTimerTimesceKernelGetVTimerTimeWidesceKernelSetVTimerTimesceKernelSetVTimerTimeWidesceKernelStartVTimersceKernelStopVTimersceKernelSetVTimerHandlersceKernelSetVTimerHandlerWidesceKernelCancelVTimerHandlersceKernelReferVTimerStatusSceKernelVTimerInfosceKernelRegisterThreadEventHandlersceKernelReleaseThreadEventHandlersceKernelReferThreadEventHandlerStatusSceKernelThreadEventHandlerInfosceKernelReferThreadProfilerDebugProfilerRegssceKernelReferGlobalProfilersceUsbStartsceUsbStopsceUsbActivatesceUsbDeactivatesceUsbGetStatesceUsbGetDrvStatesceUsbCamSetupStillUsbCamSetupStillParamsceUsbCamSetupStillExUsbCamSetupStillExParamsceUsbCamStillInputBlockingsceUsbCamStillInputsceUsbCamStillWaitInputEndsceUsbCamStillPollInputEndsceUsbCamStillCancelInputsceUsbCamStillGetInputLengthsceUsbCamSetupVideoUsbCamSetupVideoParamsceUsbCamSetupVideoExUsbCamSetupVideoExParamsceUsbCamStartVideosceUsbCamStopVideosceUsbCamReadVideoFrameBlockingsceUsbCamReadVideoFramesceUsbCamWaitReadVideoFrameEndsceUsbCamPollReadVideoFrameEndsceUsbCamGetReadVideoFrameSizesceUsbCamSetSaturationsceUsbCamSetBrightnesssceUsbCamSetContrastsceUsbCamSetSharpnesssceUsbCamSetImageEffectModeUsbCamEffectModesceUsbCamSetEvLevelUsbCamEvLevelsceUsbCamSetReverseModesceUsbCamSetZoomsceUsbCamGetSaturationsceUsbCamGetBrightnesssceUsbCamGetContrastsceUsbCamGetSharpnesssceUsbCamGetImageEffectModesceUsbCamGetEvLevelsceUsbCamGetReverseModesceUsbCamGetZoomsceUsbCamAutoImageReverseSWsceUsbCamGetAutoImageReverseStatesceUsbCamGetLensDirectionsceUsbstorBootRegisterNotifysceUsbstorBootUnregisterNotifysceUsbstorBootSetCapacityscePowerRegisterCallbackscePowerUnregisterCallbackscePowerIsPowerOnlinescePowerIsBatteryExistscePowerIsBatteryChargingscePowerGetBatteryChargingStatusscePowerIsLowBatteryscePowerGetBatteryLifePercentscePowerGetBatteryLifeTimescePowerGetBatteryTempscePowerGetBatteryElecscePowerGetBatteryVoltscePowerSetCpuClockFrequencyscePowerSetBusClockFrequencyscePowerGetCpuClockFrequencyscePowerGetCpuClockFrequencyIntscePowerGetCpuClockFrequencyFloatscePowerGetBusClockFrequencyscePowerGetBusClockFrequencyIntscePowerGetBusClockFrequencyFloatscePowerSetClockFrequencyscePowerLockscePowerUnlockscePowerTickPowerTickscePowerGetIdleTimerscePowerIdleTimerEnablescePowerIdleTimerDisablescePowerRequestStandbyscePowerRequestSuspendsceWlanDevIsPowerOnsceWlanGetSwitchStatesceWlanGetEtherAddrsceWlanDevAttachsceWlanDevDetachsceRtcGetTickResolutionsceRtcGetCurrentTicksceRtcGetCurrentClockScePspDateTimesceRtcGetCurrentClockLocalTimesceRtcConvertUtcToLocalTimesceRtcConvertLocalTimeToUTCsceRtcIsLeapYearsceRtcGetDaysInMonthsceRtcGetDayOfWeeksceRtcCheckValidsceRtcSetTicksceRtcGetTicksceRtcCompareTicksceRtcTickAddTickssceRtcTickAddMicrosecondssceRtcTickAddSecondssceRtcTickAddMinutessceRtcTickAddHourssceRtcTickAddDayssceRtcTickAddWeekssceRtcTickAddMonthssceRtcTickAddYearssceRtcSetTime_tsceRtcGetTime_tsceRtcSetTime64_tsceRtcGetTime64_tsceRtcSetDosTimesceRtcGetDosTimesceRtcSetWin32FileTimesceRtcGetWin32FileTimesceRtcParseDateTimesceRtcFormatRFC3339sceRtcFormatRFC3339LocalTimesceRtcParseRFC3339sceRtcFormatRFC2822sceRtcFormatRFC2822LocalTimesceIoOpensceIoOpenAsyncsceIoClosesceIoCloseAsyncsceIoReadsceIoReadAsyncsceIoWritesceIoWriteAsyncsceIoLseekIoWhencesceIoLseekAsyncsceIoLseek32sceIoLseek32AsyncsceIoRemovesceIoMkdirsceIoRmdirsceIoChdirsceIoRenamesceIoDopensceIoDreadSceIoDirentsceIoDclosesceIoDevctlsceIoAssignIoAssignPermssceIoUnassignsceIoGetstatSceIoStatsceIoChstatsceIoIoctlsceIoIoctlAsyncsceIoSyncsceIoWaitAsyncsceIoWaitAsyncCBsceIoPollAsyncsceIoGetAsyncStatsceIoCancelsceIoGetDevTypesceIoChangeAsyncPrioritysceIoSetAsyncCallbacksceJpegInitMJpegsceJpegFinishMJpegsceJpegCreateMJpegsceJpegDeleteMJpegsceJpegDecodeMJpegsceUmdCheckMediumsceUmdGetDiscInfoUmdInfosceUmdActivatesceUmdDeactivatesceUmdWaitDriveStatsceUmdWaitDriveStatWithTimersceUmdWaitDriveStatCBsceUmdCancelWaitDriveStatsceUmdGetDriveStatsceUmdGetErrorStatsceUmdRegisterUMDCallBacksceUmdUnRegisterUMDCallBacksceUmdReplacePermitsceUmdReplaceProhibitsceMpegInitsceMpegFinishsceMpegRingbufferQueryMemSizesceMpegRingbufferConstructSceMpegRingbuffersceMpegRingbufferDestructsceMpegRingbufferAvailableSizesceMpegRingbufferPutsceMpegQueryMemSizesceMpegCreateSceMpegsceMpegDeletesceMpegQueryStreamOffsetsceMpegQueryStreamSizesceMpegRegistStreamSceMpegStreamsceMpegUnRegistStreamsceMpegFlushAllStreamsceMpegMallocAvcEsBufsceMpegFreeAvcEsBufsceMpegQueryAtracEsSizesceMpegInitAuSceMpegAusceMpegGetAvcAusceMpegAvcDecodeModeSceMpegAvcModesceMpegAvcDecodesceMpegAvcDecodeStopsceMpegGetAtracAusceMpegAtracDecodesceMpegBaseYCrCbCopyVmesceMpegBaseCscInitsceMpegBaseCscVmeSceMpegYCrCbBuffersceMpegbase_BEA18F91SceMpegLLIsceHprmPeekCurrentKeysceHprmPeekLatchsceHprmReadLatchsceHprmIsHeadphoneExistsceHprmIsRemoteExistsceHprmIsMicrophoneExistsceGuDepthBuffersceGuDispBuffersceGuDrawBuffersceGuDrawBufferListsceGuDisplaysceGuDepthFuncDepthFuncsceGuDepthMasksceGuDepthOffsetsceGuDepthRangesceGuFogsceGuInitsceGuTermsceGuBreaksceGuContinuesceGuSetCallbackGuCallbackIdsceGuSignalSignalBehaviorsceGuSendCommandfGeCommandsceGuSendCommandisceGuGetMemorysceGuStartGuContextTypesceGuFinishsceGuFinishIdsceGuCallListsceGuCallModesceGuCheckListsceGuSendListGuQueueModesceGuSwapBufferssceGuSyncGuSyncModeGuSyncBehaviorsceGuDrawArrayGuPrimitivesceGuBeginObjectsceGuEndObjectsceGuSetStatusGuStatesceGuGetStatussceGuSetAllStatussceGuGetAllStatussceGuEnablesceGuDisablesceGuLightLightTypeScePspFVector3sceGuLightAttsceGuLightColorsceGuLightModeLightModesceGuLightSpotsceGuClearsceGuClearColorsceGuClearDepthsceGuClearStencilsceGuPixelMasksceGuColorsceGuColorFuncColorFuncsceGuColorMaterialsceGuAlphaFuncAlphaFuncsceGuAmbientsceGuAmbientColorsceGuBlendFuncBlendSrcBlendDstsceGuMaterialsceGuModelColorsceGuStencilFuncStencilFuncsceGuStencilOpStencilOperationsceGuSpecularsceGuFrontFaceFrontFaceDirectionsceGuLogicalOpLogicalOperationsceGuSetDitherScePspIMatrix4sceGuShadeModelShadingModelsceGuCopyImagesceGuTexEnvColorsceGuTexFilterTextureFiltersceGuTexFlushsceGuTexFuncTextureEffectTextureColorComponentsceGuTexImageMipmapLevelsceGuTexLevelModeTextureLevelModesceGuTexMapModeTextureMapModesceGuTexModeTexturePixelFormatsceGuTexOffsetsceGuTexProjMapModeTextureProjectionMapModesceGuTexScalesceGuTexSlopesceGuTexSyncsceGuTexWrapGuTexWrapModesceGuClutLoadsceGuClutModeClutPixelFormatsceGuOffsetsceGuScissorsceGuViewportsceGuDrawBeziersceGuPatchDividesceGuPatchFrontFacesceGuPatchPrimPatchPrimitivesceGuDrawSplinesceGuSetMatrixMatrixModeScePspFMatrix4sceGuBoneMatrixsceGuMorphWeightsceGuDrawArrayNsceGumDrawArraysceGumDrawArrayNsceGumDrawBeziersceGumDrawSplinesceGumFastInversesceGumFullInversesceGumLoadIdentitysceGumLoadMatrixsceGumLookAtsceGumMatrixModesceGumMultMatrixsceGumOrthosceGumPerspectivesceGumPopMatrixsceGumPushMatrixsceGumRotateXsceGumRotateYsceGumRotateZsceGumRotateXYZsceGumRotateZYXsceGumScalesceGumStoreMatrixsceGumTranslatesceGumUpdateMatrixsceMp3ReserveMp3HandleSceMp3InitArgsceMp3ReleaseMp3HandleMp3HandlesceMp3InitResourcesceMp3TermResourcesceMp3InitsceMp3DecodesceMp3GetInfoToAddStreamDatasceMp3NotifyAddStreamDatasceMp3CheckStreamDataNeededsceMp3SetLoopNumsceMp3GetLoopNumsceMp3GetSumDecodedSamplesceMp3GetMaxOutputSamplesceMp3GetSamplingRatesceMp3GetBitRatesceMp3GetMp3ChannelNumsceMp3ResetPlayPositionsceRegOpenRegistryRegHandlesceRegFlushRegistrysceRegCloseRegistrysceRegOpenCategorysceRegRemoveCategorysceRegCloseCategorysceRegFlushCategorysceRegGetKeyInfosceRegGetKeyInfoByNamesceRegGetKeyValuesceRegGetKeyValueByNamesceRegSetKeyValuesceRegGetKeysNumsceRegGetKeyssceRegCreateKeysceRegRemoveRegistrysceOpenPSIDGetOpenPSIDOpenPSIDsceUtilityMsgDialogInitStartUtilityMsgDialogParamssceUtilityMsgDialogShutdownStartsceUtilityMsgDialogGetStatussceUtilityMsgDialogUpdatesceUtilityMsgDialogAbortsceUtilityNetconfInitStartUtilityNetconfDatasceUtilityNetconfShutdownStartsceUtilityNetconfUpdatesceUtilityNetconfGetStatussceUtilityCheckNetParamsceUtilityGetNetParamNetParamUtilityNetDatasceUtilitySavedataInitStartSceUtilitySavedataParamsceUtilitySavedataGetStatussceUtilitySavedataShutdownStartsceUtilitySavedataUpdatesceUtilityGameSharingInitStartUtilityGameSharingParamssceUtilityGameSharingShutdownStartsceUtilityGameSharingGetStatussceUtilityGameSharingUpdatesceUtilityHtmlViewerInitStartUtilityHtmlViewerParamsceUtilityHtmlViewerShutdownStartsceUtilityHtmlViewerUpdatesceUtilityHtmlViewerGetStatussceUtilitySetSystemParamIntSystemParamIdsceUtilitySetSystemParamStringsceUtilityGetSystemParamIntsceUtilityGetSystemParamStringsceUtilityOskInitStartSceUtilityOskParamssceUtilityOskShutdownStartsceUtilityOskUpdatesceUtilityOskGetStatussceUtilityLoadNetModuleNetModulesceUtilityUnloadNetModulesceUtilityLoadAvModuleAvModulesceUtilityUnloadAvModulesceUtilityLoadUsbModuleUsbModulesceUtilityUnloadUsbModulesceUtilityLoadModulesceUtilityUnloadModulesceUtilityCreateNetParamsceUtilitySetNetParamsceUtilityCopyNetParamsceUtilityDeleteNetParamsceNetInitsceNetTermsceNetFreeThreadinfosceNetThreadAbortsceNetEtherStrtonsceNetEtherNtostrsceNetGetLocalEtherAddrsceNetGetMallocStatSceNetMallocStatsceNetAdhocctlInitSceNetAdhocctlAdhocIdsceNetAdhocctlTermsceNetAdhocctlConnectsceNetAdhocctlDisconnectsceNetAdhocctlGetStatesceNetAdhocctlCreatesceNetAdhocctlJoinSceNetAdhocctlScanInfosceNetAdhocctlGetAdhocIdsceNetAdhocctlCreateEnterGameModesceNetAdhocctlJoinEnterGameModesceNetAdhocctlGetGameModeInfoSceNetAdhocctlGameModeInfosceNetAdhocctlExitGameModesceNetAdhocctlGetPeerListsceNetAdhocctlGetPeerInfoSceNetAdhocctlPeerInfosceNetAdhocctlScansceNetAdhocctlGetScanInfosceNetAdhocctlAddHandlersceNetAdhocctlDelHandlersceNetAdhocctlGetNameByAddrsceNetAdhocctlGetAddrByNamesceNetAdhocctlGetParameterSceNetAdhocctlParamssceNetAdhocInitsceNetAdhocTermsceNetAdhocPdpCreatesceNetAdhocPdpDeletesceNetAdhocPdpSendsceNetAdhocPdpRecvsceNetAdhocGetPdpStatSceNetAdhocPdpStatsceNetAdhocGameModeCreateMastersceNetAdhocGameModeCreateReplicasceNetAdhocGameModeUpdateMastersceNetAdhocGameModeUpdateReplicasceNetAdhocGameModeDeleteMastersceNetAdhocGameModeDeleteReplicasceNetAdhocPtpOpensceNetAdhocPtpConnectsceNetAdhocPtpListensceNetAdhocPtpAcceptsceNetAdhocPtpSendsceNetAdhocPtpRecvsceNetAdhocPtpFlushsceNetAdhocPtpClosesceNetAdhocGetPtpStatSceNetAdhocPtpStatsceNetAdhocMatchingInitsceNetAdhocMatchingTermsceNetAdhocMatchingCreateAdhocMatchingModesceNetAdhocMatchingDeletesceNetAdhocMatchingStartsceNetAdhocMatchingStopsceNetAdhocMatchingSelectTargetsceNetAdhocMatchingCancelTargetsceNetAdhocMatchingCancelTargetWithOptsceNetAdhocMatchingSendDatasceNetAdhocMatchingAbortSendDatasceNetAdhocMatchingSetHelloOptsceNetAdhocMatchingGetHelloOptsceNetAdhocMatchingGetMemberssceNetAdhocMatchingGetPoolMaxAllocsceNetAdhocMatchingGetPoolStatAdhocPoolStatsceNetApctlInitsceNetApctlTermsceNetApctlGetInfoApctlInfoSceNetApctlInfosceNetApctlAddHandlersceNetApctlDelHandlersceNetApctlConnectsceNetApctlDisconnectsceNetApctlGetStateApctlStatesceNetInetInitsceNetInetTermsceNetInetAcceptsceNetInetBindsceNetInetConnectsceNetInetGetsockoptsceNetInetListensceNetInetRecvsceNetInetRecvfromsceNetInetSendsceNetInetSendtosceNetInetSetsockoptsceNetInetShutdownsceNetInetSocketsceNetInetClosesceNetInetGetErrnosceSslInitsceSslEndsceSslGetUsedMemoryMaxsceSslGetUsedMemoryCurrentsceHttpInitsceHttpEndsceHttpCreateTemplatesceHttpDeleteTemplatesceHttpCreateConnectionsceHttpCreateConnectionWithURLsceHttpDeleteConnectionsceHttpCreateRequestHttpMethodsceHttpCreateRequestWithURLsceHttpDeleteRequestsceHttpSendRequestsceHttpAbortRequestsceHttpReadDatasceHttpGetContentLengthsceHttpGetStatusCodesceHttpSetResolveTimeOutsceHttpSetResolveRetrysceHttpSetConnectTimeOutsceHttpSetSendTimeOutsceHttpSetRecvTimeOutsceHttpEnableKeepAlivesceHttpDisableKeepAlivesceHttpEnableRedirectsceHttpDisableRedirectsceHttpEnableCookiesceHttpDisableCookiesceHttpSaveSystemCookiesceHttpLoadSystemCookiesceHttpAddExtraHeadersceHttpDeleteHeadersceHttpsInitsceHttpsEndsceHttpsLoadDefaultCertsceHttpDisableAuthsceHttpDisableCachesceHttpEnableAuthsceHttpEnableCachesceHttpEndCachesceHttpGetAllHeadersceHttpGetNetworkErrnosceHttpGetProxysceHttpInitCachesceHttpSetAuthInfoCBsceHttpSetProxysceHttpSetResHeaderMaxSizesceHttpSetMallocFunctionsceNetResolverInitsceNetResolverCreatesceNetResolverDeletesceNetResolverStartNtoAsceNetResolverStartAtoNsceNetResolverStopsceNetResolverTerm//! PSP C type definitions//! These type declarations are not enough, as they must be ultimately resolved//! by the linker. Crates that use these definitions must, somewhere in the//! crate graph, include a stub provider crate such as the `psp` crate.//! SGX C types definitiontimer_t__caddr_t// sys/ansi.h__gid_t__in_addr_t__in_port_t__mode_t__off_t__pid_t__sa_family_t__socklen_t__uid_t__fsblkcnt_t__fsfilcnt_t// locale.h// nl_types.h__va_list// sys/types.hu_int8_tu_int16_tu_int32_tu_int64_tu_charu_shortu_intu_longuncharushortu_quad_tquad_tqaddr_tlonglong_tu_longlong_tcaddr_tdaddr_tfixpt_tlwpid_tsegsz_tswblk_tcpuid_tpsetid_tO_TEXTO_BINARY_LC_LASTEFTYPE// signal codesSIGEMTSIGINFO// ctype.h__get_stdio_file// stdio.hclearerrgetcputcvfprintfvprintfgetsvsprintfasiprintffiprintffiscanfiprintfiscanfsiprintfsiscanfsniprintfvasiprintfvfiprintfvfiscanfviprintfviscanfvsiprintfvsiscanfvsniprintfvdiprintfdiprintfflockfileftrylockfilefunlockfilegetc_unlockedputc_unlockedvsnprintfgetwputwtempnam// stdlib.hdrand48erand48strtoldstrtod_lstrtof_lstrtold_l_Exitltoaultoabsearchdiv_tldivldiv_tqsortmblenmbstowcswctombmbtowcrand_rjrand48lcong48lrand48mrand48nrand48seed48srand48a64ll64asetstateinitstatesrandommktempllabslldivlldiv_taligned_allocat_quick_exitquick_exithumanize_numberdehumanize_numbergetenv_rheapsortmergesortradixsortsradixsortgetprognamesetprognameqabsstrtoqstrtouqstrsuftollstrsuftollxl64a_rqdivqdiv_tstrtol_lstrtoul_lstrtoll_lstrtoull_lstrtoq_lstrtouq_l_mb_cur_max_lmblen_lmbstowcs_lwctomb_lmbtowc_lwcstombs_lstrtok_rmemccpystpncpystrcasestrstrlcatstrlcpystrsepstresepstrndupexplicit_memsetconsttime_memequalstrcoll_lstrxfrm_lstrerror_lbcmp// strings.hbcopyffspopcountpopcountlpopcountllpopcount32popcount64rindexstrcasecmpstrncasecmp// signal.hasctime// time.hdifftimeasctime_rctime_r// sys/stat.hgetwdoptargopterroptindoptresetsuboptarggetsuboptlocaleconv_l// langinfo.h// malloc.h//! Interface to the [SOLID] C library//! [SOLID]: https://solid.kmckk.com///! Switch C type definitionsc_boolc_longdouble_CLongDouble// long double in C means A float point value, which has 128bit length.// but some bit maybe not used, so the real length of long double could be 80(x86) or 128(power pc/IEEE)// this is different from f128(not stable and not included default) in Rust, so we use u128 for FFI(Rust to C).// this is unstable and will cause to memfault/data abort.pthread_spinlock_tonce_fnpthread_once_tcmpfunc__sizetv_nsectm_sectm_mintm_hourtm_mdaytm_montm_yeartm_wdaytm_ydaytm_isdst__tm_gmtoff__tm_zone__opaque1__opaque2__val// fcntlF_SETSIGF_GETSIGF_SETOWN_EXF_GETOWN_EXF_GETOWNER_UIDS// mmanMAP_FIXED_NOREPLACEMAP_SHARED_VALIDATEMAP_SYNCMAP_HUGE_MASKMAP_HUGE_16KBMAP_HUGE_64KBMAP_HUGE_512KBMAP_HUGE_1MBMAP_HUGE_2MBMAP_HUGE_8MBMAP_HUGE_16MBMAP_HUGE_32MBMAP_HUGE_256MBMAP_HUGE_512MBMAP_HUGE_1GBMAP_HUGE_2GBMAP_HUGE_16GBMCL_ONFAULTWCTYPE_ALNUM// wctypeWCTYPE_ALPHAWCTYPE_BLANKWCTYPE_CNTRLWCTYPE_DIGITWCTYPE_GRAPHWCTYPE_LOWERWCTYPE_PRINTWCTYPE_PUNCTWCTYPE_SPACEWCTYPE_UPPERWCTYPE_XDIGIT// locale// pthreadEPROTONOSUPPORESOCKTNOSUPPORTEESMP_THREAD_ATTR_CA_WILDCARD// pthread_attr.hTEESMP_THREAD_ATTR_CA_INHERITTEESMP_THREAD_ATTR_TASK_ID_INHERITTEESMP_THREAD_ATTR_HAS_SHADOWTEESMP_THREAD_ATTR_NO_SHADOWPTHREAD_KEYS_MAX// limits.hPTHREAD_DESTRUCTOR_ITERATIONSSEM_VALUE_MAXSEM_NSEMS_MAXDELAYTIMER_MAXMQ_PRIO_MAXLOGIN_NAME_MAXPTHREAD_MUTEX_STALLEDPTHREAD_MUTEX_ROBUST// ---- ALLOC -----------------------------------------------------------------------------// ----- PTHREAD ---------------------------------------------------------------------------pthread_attr_settee// C-TA API do not include this interface, but TA can use.pthread_mutexattr_setpsharedpthread_mutexattr_setrobustpthread_spin_initpthread_spin_destroypthread_spin_lockpthread_spin_trylockpthread_spin_unlockpthread_setschedpriopthread_oncepthread_equalpthread_mutexattr_setprotocolpthread_attr_setstackpthread_setaffinity_nppthread_getaffinity_np// sysconf is currently only implemented as a stub.// mman.h// unistd// time// semmbrtowc// multibytewcrtombwctob// prngwcschr// ctypeisasciiiswctypeiswdigitiswloweriswspaceiswuppertowuppertowlower// cmathceilffabsfrexproundfscalbn// stdlibecvtwcstod// detach or pthread_attr_setdetachstate must not be called!//pub fn pthread_detach(thread: pthread_t) -> c_int;// Not available.//pub fn pthread_setname_np(thread: pthread_t, name: *const c_char) -> c_int;//pub fn prctl(op: c_int, ...) -> c_int;CPU_COUNT_SCPU_COUNT//! Libc bindings for teeos//! Apparently the loader just dynamically links it anyway, but fails//! when linking is explicitly requested./* !! */c_uint8_tc_uint16_tc_uint32_tc_uint64_tc_int8_tc_int16_tc_int32_tc_int64_t// Trusty only supports `CLOCK_BOOTTIME`.AT_PAGESZgetauxvaltime64_tprojid_tblksize64_tsctp_assoc_tsignal_tthread_tregoff_tpollset_tpthread_barrierattr_tposix_spawn_file_actions_ticonv_t// dlfcn.hRTLD_MEMBERRTLD_NOAUTODEFERRTLD_MYSELFO_TTY_INITF_CLOSEMF_GETLK64F_SETLK64F_SETLKW64F_DUP2FDF_TSTLKFASYNC// glob.hGLOB_NOSYSLC_GLOBAL_LOCALELC_ALL_MASK// netdb.hNI_MAXSERVNI_NUMERICSCOPEAI_EXTFLAGSAI_DEFAULTIPV6_ADDRFORMIPV6_ADDR_PREFERENCESIPV6_CHECKSUMIPV6_DONTFRAGIPV6_DSTOPTSIPV6_FLOWINFO_FLOWLABELIPV6_FLOWINFO_PRIORITYIPV6_HOPLIMITIPV6_HOPOPTSIPV6_NEXTHOPIPV6_PATHMTUIPV6_PKTINFOIPV6_PREFER_SRC_CGAIPV6_PREFER_SRC_COAIPV6_PREFER_SRC_HOMEIPV6_PREFER_SRC_NONCGAIPV6_PREFER_SRC_PUBLICIPV6_PREFER_SRC_TMPIPV6_RECVDSTOPTSIPV6_RECVHOPLIMITIPV6_RECVHOPOPTSIPV6_RECVPATHMTUIPV6_RECVRTHDRIPV6_RTHDRIPV6_RTHDRDSTOPTS// net/bpf.hDLT_EN10MBDLT_EN3MBDLT_AX25DLT_PRONETDLT_IEEE802DLT_ARCNETDLT_SLIPDLT_PPPDLT_FDDIDLT_ATMDLT_IPOIBBIOCSETFBIOCGRTIMEOUTBIOCGBLENBIOCFLUSHBIOCPROMISCBIOCSRTIMEOUTBIOCGSTATSBIOCVERSIONBIOCSDEVNOBIOCGETIFBPF_ABSBPF_ADDBPF_ALUBPF_ANDBPF_BBPF_DIVBPF_HBPF_IMMBPF_INDBPF_JABPF_JEQBPF_JGEBPF_JGTBPF_JMPBPF_JSETBPF_KBPF_LDBPF_LDXBPF_LENBPF_LSHBPF_MAXINSNSBPF_MEMBPF_MEMWORDSBPF_MISCBPF_MSHBPF_MULBPF_NEGBPF_ORBPF_RETBPF_RSHBPF_STBPF_STXBPF_SUBBPF_WBPF_XIFNET_SLOWHZ// net/if.hIFQ_MAXLENIFF_LINK0IFF_LINK1IFF_LINK2IFF_OACTIVEIFF_SIMPLEXARPHRD_ETHER// net/if_arp.hARPHRD_802_5ARPHRD_802_3ARPHRD_FDDIRTM_ADD// net/route.hRTM_DELETERTM_CHANGERTM_GETRTM_LOSINGRTM_REDIRECTRTM_MISSRTM_LOCKRTM_OLDADDRTM_OLDDELRTM_RESOLVERTM_NEWADDRRTM_DELADDRRTM_IFINFORTM_EXPIRERTM_RTLOSTRTM_GETNEXTRTM_SAMEADDRRTM_SETRTV_MTURTV_HOPCOUNTRTV_EXPIRERTV_RPIPERTV_SPIPERTV_SSTHRESHRTV_RTTRTV_RTTVARRTA_DSTRTA_GATEWAYRTA_NETMASKRTA_GENMASKRTA_IFPRTA_IFARTA_AUTHORRTA_BRDRTA_DOWNSTREAMRTAX_DSTRTAX_GATEWAYRTAX_NETMASKRTAX_GENMASKRTAX_IFPRTAX_IFARTAX_AUTHORRTAX_BRDRTAX_MAXRTF_UPRTF_GATEWAYRTF_HOSTRTF_REJECTRTF_DYNAMICRTF_MODIFIEDRTF_DONERTF_MASKRTF_CLONINGRTF_XRESOLVERTF_LLINFORTF_STATICRTF_BLACKHOLERTF_BULRTF_PROTO2RTF_PROTO1RTF_CLONERTF_CLONEDRTF_PROTO3RTF_BCERTF_PINNEDRTF_LOCALRTF_BROADCASTRTF_MULTICASTRTF_ACTIVE_DGDRTF_STOPSRCHRTF_FREE_IN_PROGRTF_PERMANENT6RTF_UNREACHABLERTF_CACHEDRTF_SMALLMTUIPPROTO_GGPIPPROTO_QOSIPPROTO_LOCALIPPROTO_EONIPPROTO_BIPIPPROTO_GIFIP_OPTIONSIP_UNICAST_HOPSIP_RECVOPTSIP_RECVRETOPTSIP_RECVDSTADDRIP_RETOPTSIP_MULTICAST_HOPSIP_RECVMACHDRIP_RECVIFINFOIP_BROADCAST_IFIP_DHCPMODEIP_RECVIFIP_ADDRFORMIP_DONTFRAGIP_FINDPMTUIP_PMTUAGEIP_RECVINTERFACEIP_RECVTTLIP_BLOCK_SOURCEIP_UNBLOCK_SOURCEIP_ADD_SOURCE_MEMBERSHIPIP_DROP_SOURCE_MEMBERSHIPIP_DEFAULT_MULTICAST_TTLIP_DEFAULT_MULTICAST_LOOPIP_INC_MEMBERSHIPSIP_INIT_MEMBERSHIPIPV6_JOIN_GROUPIPV6_LEAVE_GROUPMCAST_BLOCK_SOURCEMCAST_EXCLUDEMCAST_INCLUDEMCAST_JOIN_GROUPMCAST_JOIN_SOURCE_GROUPMCAST_LEAVE_GROUPMCAST_LEAVE_SOURCE_GROUPMCAST_UNBLOCK_SOURCEMAXTTL// netinet/ip.hIPDEFTTLIPOPT_CONTROLIPOPT_EOLIPOPT_LSRRIPOPT_MINOFFIPOPT_NOPIPOPT_OFFSETIPOPT_OLENIPOPT_OPTVALIPOPT_RESERVED1IPOPT_RESERVED2IPOPT_RRIPOPT_SSRRIPOPT_TSIPOPT_TS_PRESPECIPOPT_TS_TSANDADDRIPOPT_TS_TSONLYIPTOS_LOWDELAYIPTOS_PREC_CRITIC_ECPIPTOS_PREC_FLASHIPTOS_PREC_FLASHOVERRIDEIPTOS_PREC_IMMEDIATEIPTOS_PREC_INTERNETCONTROLIPTOS_PREC_NETCONTROLIPTOS_PREC_PRIORITYIPTOS_PREC_ROUTINEIPTOS_RELIABILITYIPTOS_THROUGHPUTIPVERSION// netinet/tcp.hTCP_RFC1323TCP_KEEPALIVETCP_NODELAYACKPTHREAD_BARRIER_SERIAL_THREAD// pthread.hPTHREAD_PRIO_INHERITPTHREAD_PRIO_NONEPTHREAD_PRIO_PROTECTREG_EXTENDED// regex.hREG_ICASEREG_NEWLINEREG_NOSUBREG_NOTBOLREG_NOTEOLREG_NOMATCHREG_BADPATREG_ECOLLATEREG_ECTYPEREG_EESCAPEREG_ESUBREGREG_EBRACKREG_EPARENREG_EBRACEREG_BADBRREG_ERANGEREG_ESPACEREG_BADRPTREG_ECHARREG_EBOLREG_EEOLREG_ENOSYSNFSMNT_ACDIRMAX// rpcsvc/mount.hNFSMNT_ACDIRMINNFSMNT_ACREGMAXNFSMNT_ACREGMINNFSMNT_INTNFSMNT_NOACNFSMNT_RETRANSNFSMNT_RSIZENFSMNT_SOFTNFSMNT_TIMEONFSMNT_WSIZECPUSTATES// rpcsvc/rstat.hFIND// search.hENTER// semaphore.hPOSIX_SPAWN_SETPGROUP// spawn.h// DIFF(main): changed to `c_short` in f62eb023abPOSIX_SPAWN_SETSIGMASKPOSIX_SPAWN_SETSIGDEFPOSIX_SPAWN_SETSCHEDULERPOSIX_SPAWN_SETSCHEDPARAMPOSIX_SPAWN_RESETIDSPOSIX_SPAWN_FORK_HANDLERS// sys/access.h// sys/aio.h// sys/errno.hEPROCLIMESADENOTRUSTLPAR_INFO_FORMAT1// sys/dr.hLPAR_INFO_FORMAT2WPAR_INFO_FORMATPROC_MODULE_INFONUM_PROC_MODULE_TYPESLPAR_INFO_VRME_NUM_POOLSLPAR_INFO_VRME_POOLSLPAR_INFO_VRME_LPARLPAR_INFO_VRME_RESET_HWMARKSLPAR_INFO_VRME_ALLOW_DESIREDEMTP_INFO_FORMATLPAR_INFO_LPM_CAPABILITYENERGYSCALE_INFO// sys/file.hF_RDLCK// sys/flock.hF_WRLCKF_UNLCK// sys/fs/quota_common.hQ_SETUSEQ_SETQLIM// sys/ioctl.hIOC_VOIDTIOCHPCLTIOCMODGTIOCMODSTIOCGETPTIOCSETPTIOCSETNTIOCFLUSHTIOCSETCTIOCGETCTANDEMCBREAKLCASEMDMBUFSIOCDIFADDRTIOCUCNTLTIOCPKT_DATATIOCPKT_FLUSHREADTIOCPKT_FLUSHWRITETIOCPKT_NOSTOPTIOCPKT_DOSTOPTIOCPKT_STARTTIOCPKT_STOPIPC_ALLOC// sys/ipc.hIPC_RIPC_WIPC_OIPC_NOERRORL_GETINFO// sys/ldr.hL_GETMESSAGEL_GETLIBPATHL_GETXINFO// sys/limits.hPAGESIZEIOV_MAXAIO_LISTIO_MAXOPEN_MAXMAX_INPUTMAX_CANONARG_MAXBC_BASE_MAXBC_DIM_MAXBC_SCALE_MAXBC_STRING_MAXCHARCLASS_NAME_MAXCHILD_MAXCOLL_WEIGHTS_MAXEXPR_NEST_MAXNZERO// sys/lockf.hBIG_ENDIAN// sys/machine.hLITTLE_ENDIANPDP_ENDIAN// sys/mman.h// sys/mode.h// sys/msg.h// sys/m_signal.hMAXPATHLEN// sys/params.hMAXSYMLINKSMAXHOSTNAMELENMAXUPRCNGROUPS_MAXNGROUPSNOFILE// sys/poll.hPOLLMSGPOLLSYNCPOLLNORMPS_ADD// sys/pollset.hPS_MODPS_DELETEPS_REPLACEPT_TRACE_ME// sys/ptrace.hPT_READ_IPT_READ_DPT_WRITE_IPT_WRITE_DPT_CONTINUEPT_KILLPT_STEPPT_READ_GPRPT_READ_FPRPT_WRITE_GPRPT_WRITE_FPRPT_READ_BLOCKPT_WRITE_BLOCKPT_ATTACHPT_DETACHPT_REGSETPT_REATTPT_LDINFOPT_MULTIPT_NEXTPT_SETPT_CLEARPT_LDXINFOPT_QUERYPT_WATCHPTT_CONTINUEPTT_STEPPTT_READ_SPRSPTT_WRITE_SPRSPTT_READ_GPRSPTT_WRITE_GPRSPTT_READ_FPRSPTT_WRITE_FPRSPTT_READ_VECPTT_WRITE_VECPTT_WATCHPTT_SET_TRAPPTT_CLEAR_TRAPPTT_READ_UKEYSETPT_GET_UKEYPTT_READ_FPSCR_HIPTT_WRITE_FPSCR_HIPTT_READ_VSXPTT_WRITE_VSXPTT_READ_TM// sys/resource.hRLIMIT_THREADS// sys/sched.hSCHED_LOCALSCHED_GLOBALSCHED_FIFO2SCHED_FIFO3SCHED_FIFO4SEM_UNDO// sys/sem.hGETNCNTGETPIDGETVALGETALLGETZCNTSETVALSETALLSHMLBA// sys/shm.hSHMLBA_EXTSHMSHM_SHMATSHM_PINSHM_LGPAGESHM_MAPSHM_FMAPSHM_COPYSHM_CLEARSHM_HGSEGSHM_DEST// sys/signal.hSIGCLDSIGRTMAXSIGRTMINSI_USERSI_UNDEFINEDSI_EMPTYBUS_ADRALNBUS_ADRERRBUS_OBJERRBUS_UEGARDFPE_INTDIVFPE_INTOVFFPE_FLTDIVFPE_FLTOVFFPE_FLTUNDFPE_FLTRESFPE_FLTINVFPE_FLTSUBILL_ILLOPCILL_ILLOPNILL_ILLADRILL_ILLTRPILL_PRVOPCILL_PRVREGILL_COPROCILL_BADSTKILL_TMBADTHINGPOLL_INPOLL_OUTPOLL_MSGPOLL_ERRPOLL_PRIPOLL_HUPSEGV_MAPERRSEGV_ACCERRSEGV_KEYERRTRAP_BRKPTTRAP_TRACESI_QUEUESI_TIMERSI_ASYNCIOSI_MESGQ// sys/socket.hAF_IMPLINKAF_PUPAF_CHAOSAF_NSAF_ECMAAF_DATAKITAF_CCITTAF_DLIAF_LATSO_TIMESTAMPNSUIO_MAXIOVpseudo_AF_XTPAF_HYLINKAF_ISOAF_OSIAF_INTFAF_RIFAF_NDDAF_MAXPF_IMPLINKPF_PUPPF_CHAOSPF_NSPF_ISOPF_OSIPF_ECMAPF_DATAKITPF_CCITTPF_DLIPF_LATPF_HYLINKPF_LINKPF_XTPPF_RIFPF_INTFPF_NDDPF_MAXSF_CLOSESF_REUSESF_DONT_CACHESF_SYNC_CACHESO_USELOOPBACKSO_USE_IFBUFSSO_CKSUMRECVSO_NOREUSEADDRSO_KERNACCEPTSO_NOMULTIPATHSO_AUDITMSG_MPEG2MSG_ARGEXTMSG_NONBLOCKMSG_COMPATMSG_MAXIOVLEN// sys/statvfs.hI_NREAD// sys/stropts.hI_PUSHI_POPI_LOOKI_FLUSHI_SRDOPTI_GRDOPTI_STRI_SETSIGI_GETSIGI_FINDI_LINKI_UNLINKI_PEEKI_FDINSERTI_SENDFDI_RECVFDI_SWROPTI_GWROPTI_LISTI_PLINKI_PUNLINKI_FLUSHBANDI_CKBANDI_GETBANDI_ATMARKI_SETCLTIMEI_GETCLTIMEI_CANPUT// sys/syslog.hSC_ARCH// sys/systemcfg.hSC_IMPLSC_VERSSC_WIDTHSC_NCPUSSC_L1C_ATTRSC_L1C_ISZSC_L1C_DSZSC_L1C_ICASC_L1C_DCASC_L1C_IBSSC_L1C_DBSSC_L1C_ILSSC_L1C_DLSSC_L2C_SZSC_L2C_ASSC_TLB_ATTRSC_ITLB_SZSC_DTLB_SZSC_ITLB_ATTSC_DTLB_ATTSC_RESRV_SZSC_PRI_LCSC_PRO_LCSC_RTC_TYPESC_VIRT_ALSC_CAC_CONGSC_MOD_ARCHSC_MOD_IMPLSC_XINTSC_XFRACSC_KRN_ATTRSC_PHYSMEMSC_SLB_ATTRSC_SLB_SZSC_MAX_NCPUSSC_MAX_REALADDRSC_ORIG_ENT_CAPSC_ENT_CAPSC_DISP_WHESC_CAPINCSC_VCAPWSC_SPLP_STATSC_SMT_STATSC_SMT_TCSC_VMX_VERSC_LMB_SZSC_MAX_XCPUSC_EC_LVLSC_AME_STATSC_ECO_STATSC_DFP_VERSC_VRM_STATSC_PHYS_IMPSC_PHYS_VERSC_SPCM_STATUSSC_SPCM_MAXSC_TM_VERSC_NX_CAPSC_PKS_STATESC_MMA_VERPOWER_RSPOWER_PCIA64POWER_RS1POWER_RSCPOWER_RS2POWER_601POWER_604POWER_603POWER_620POWER_630POWER_A35POWER_RS64IIPOWER_RS64IIIPOWER_4POWER_RS64IVPOWER_MPC7450POWER_5POWER_6POWER_7POWER_8POWER_9// sys/time.hTIMEOFDAYITIMER_VIRTITIMER_REAL1ITIMER_REAL_THDST_AUSTDST_CANDST_EETDST_METDST_NONEDST_USADST_WETCSTART// sys/termio.hCSTOPTIOCTIOCLBISTIOCLBICTIOCLSETTIOCLGETTIOCSBRKTIOCCBRKTIOCSDTRTIOCCDTRTIOCSLTCTIOCGLTCTIOCSTOPTIOCSTARTTIOCGSIDTIOCREMOTEMAXCOMLEN// sys/user.hUF_SYSTEMAT_FLAGS// sys/vattr.hAT_GIDAT_UID// sys/wait.h_W_STOPPED_W_SLWTED_W_SEWTED_W_SFWTED_W_STRC// termios.hVDSUSPVDISCRDVWERSEIUCLCOXTABSONOEOTIBSHIFTPAREXTXCASEALTWERASE_PC_TIMESTAMP_RESOLUTION_SC_2_C_VERSION_SC_T_IOV_MAX// utmp.hRUN_LVLBOOT_TIMEOLD_TIMENEW_TIMEINIT_PROCESSLOGIN_PROCESSUSER_PROCESSDEAD_PROCESSACCOUNTINGthr_killthr_selfpthread_attr_getschedparampthread_attr_setschedparampthread_barrier_destroypthread_barrier_tpthread_barrier_initpthread_barrier_waitpthread_barrierattr_destroypthread_barrierattr_getpsharedpthread_barrierattr_initpthread_barrierattr_setpsharedpthread_condattr_getpsharedpthread_condattr_setpsharedpthread_getcpuclockidpthread_getschedparampthread_mutex_consistentpthread_mutexattr_getprotocolpthread_mutexattr_getpsharedpthread_mutexattr_getrobustpthread_rwlockattr_getpsharedpthread_rwlockattr_setpsharedpthread_setschedparamiconv_closeiconv_openaio_cancelaiocbaio_error"_posix_aio_fsync"aio_fsyncaio_read// pub fn aio_suspend// pub fn aio_writeclock_getcpuclockidcreat64ctermiddirnameendmntentendutentendutxentfattachffslffsllfgetgrentfgetpos64fgetpwentfopen64freopen64fseeko64fsetpos64fstat64fstatfs64statfs64fstatvfs64statvfs64ftello64ftruncate64getcontextucontext_tgetgrsetgethostidgetmntentmntentgetpagesizegetpeereidgetprioritygetrlimitrlimitgetrlimit64rlimit64getitimeritimervalgetutentutmpgetutidgetutlinegetutxentutmpxgetutxidgetutxlinehasmntopthcreatehdestroyhsearchlfindlio_listiosigeventloadquerylpar_get_infolpar_set_resourceslsearchlseek64lstat64makecontextmallinfomalloptmemset_smincoremq_closemq_getattrmq_attrmq_notifymq_openmq_receivemq_sendmq_setattrmq_timedreceivemq_timedsendmq_unlinkopen64pollset_createpollset_ctlpoll_ctlpollset_destroypollset_pollpollset_queryposix_fadvise64posix_fallocate64posix_spawnposix_spawnattr_tposix_spawn_file_actions_addcloseposix_spawn_file_actions_adddup2posix_spawn_file_actions_addopenposix_spawn_file_actions_destroyposix_spawn_file_actions_initposix_spawnattr_destroyposix_spawnattr_getflagsposix_spawnattr_getpgroupposix_spawnattr_getschedparamposix_spawnattr_getschedpolicyposix_spawnattr_getsigdefaultposix_spawnattr_getsigmaskposix_spawnattr_initposix_spawnattr_setflagsposix_spawnattr_setpgroupposix_spawnattr_setschedparamposix_spawnattr_setschedpolicyposix_spawnattr_setsigdefaultposix_spawnattr_setsigmaskposix_spawnppread64ptrace64pututlinepututxlinepwrite64"__linux_quotactl"regcompregex_tregerrorregexecregmatch_tregfreesbrksctp_opt_infosctp_peeloffsend_filesf_parmssetcontextsethostidsetmntentsetprioritysetrlimitsetrlimit64setitimersetutentsetutxentstat64atstatxstrcasecmp_lstrncasecmp_lstrptimeswapcontexttimer_createtimer_deletetimer_getoverruntimer_gettimetimer_settimetruncate64updwtmputmpnamewait4rusage_Errno// Use AIX thread-safe version errno.si_addrsi_valuesigvalsi_pidsi_uidsi_statusgetsystemcfgNET_RT_MAXID__PTHREAD_MUTEX_SIZE____PTHREAD_COND_SIZE____PTHREAD_CONDATTR_SIZE____PTHREAD_ONCE_SIZE____PTHREAD_RWLOCK_SIZE____PTHREAD_RWLOCKATTR_SIZE__TIOCTIMESTAMPTIOCDCDTIMESTAMPBIOCSETFNR_PTHREAD_ONCE_SIG_INITPTHREAD_ONCE_INITexchangedata//! 32-bit specific Apple (ios/darwin) definitionsmcontext_t__darwin_mcontext64//! 64-bit specific Apple (ios/darwin) definitionsinteger_tcpu_type_tcpu_subtype_tmach_msg_type_number_tuuid_ttask_info_thost_info_ttask_flavor_trusage_info_tvm_offset_tvm_size_tvm_address_tsae_associd_tsae_connid_thost_thost_flavor_thost_info64_tprocessor_flavor_tthread_flavor_tthread_inspect_tthread_act_tthread_act_array_tpolicy_tmach_error_tmach_vm_address_tmach_vm_offset_tmach_vm_size_tvm_map_tmem_entry_name_port_tmemory_object_tmemory_object_offset_tvm_inherit_tvm_prot_tledger_tledger_array_thost_cpu_load_info_thost_cpu_load_info// mach/host_info.hhost_cpu_load_info_data_t// mach/processor_info.hprocessor_cpu_load_info_data_tprocessor_basic_info_tprocessor_basic_infoprocessor_basic_info_data_tprocessor_set_basic_info_data_tprocessor_set_basic_infoprocessor_set_basic_info_tprocessor_set_load_info_data_tprocessor_set_load_infoprocessor_set_load_info_tprocessor_info_tprocessor_info_array_tmach_task_basic_info_data_tmach_task_basic_infomach_task_basic_info_ttask_thread_times_info_data_ttask_thread_times_infotask_thread_times_info_tthread_info_tthread_basic_info_tthread_basic_infothread_basic_info_data_tthread_identifier_info_tthread_identifier_infothread_identifier_info_data_tthread_extended_info_tthread_extended_infothread_extended_info_data_tthread_policy_flavor_tthread_policy_tthread_latency_qos_tthread_throughput_qos_tthread_standard_policy_data_tthread_standard_policythread_standard_policy_tthread_extended_policy_data_tthread_extended_policythread_extended_policy_tthread_time_constraint_policy_data_tthread_time_constraint_policythread_time_constraint_policy_tthread_precedence_policy_data_tthread_precedence_policythread_precedence_policy_tthread_affinity_policy_data_tthread_affinity_policythread_affinity_policy_tthread_background_policy_data_tthread_background_policythread_background_policy_tthread_latency_qos_policy_data_tthread_latency_qos_policythread_latency_qos_policy_tthread_throughput_qos_policy_data_tthread_throughput_qos_policythread_throughput_qos_policy_tpthread_introspection_hook_tpthread_jit_write_callback_tos_clockid_tos_sync_wait_on_address_flags_tos_sync_wake_by_address_flags_tos_unfair_lockos_unfair_lock_sos_unfair_lock_tos_log_tos_log_type_tos_signpost_id_tos_signpost_type_tvm_statistics_tvm_statisticsvm_statistics_data_tvm_statistics64_tvm_statistics64_data_ttask_inspect_tsysdir_search_path_enumeration_stateCCStatusCCCryptorStatusCCRNGStatuscopyfile_state_tcopyfile_flags_tcopyfile_callback_tattrgroup_tvol_capabilities_set_tqos_class_tQOS_CLASS_USER_INTERACTIVEQOS_CLASS_USER_INITIATEDQOS_CLASS_DEFAULT0x11QOS_CLASS_UTILITY0x09QOS_CLASS_BACKGROUNDQOS_CLASS_UNSPECIFIEDsysdir_search_path_directory_tSYSDIR_DIRECTORY_APPLICATIONSYSDIR_DIRECTORY_DEMO_APPLICATIONSYSDIR_DIRECTORY_DEVELOPER_APPLICATIONSYSDIR_DIRECTORY_ADMIN_APPLICATIONSYSDIR_DIRECTORY_LIBRARYSYSDIR_DIRECTORY_DEVELOPERSYSDIR_DIRECTORY_USERSYSDIR_DIRECTORY_DOCUMENTATIONSYSDIR_DIRECTORY_DOCUMENTSYSDIR_DIRECTORY_CORESERVICESYSDIR_DIRECTORY_AUTOSAVED_INFORMATIONSYSDIR_DIRECTORY_DESKTOPSYSDIR_DIRECTORY_CACHESSYSDIR_DIRECTORY_APPLICATION_SUPPORTSYSDIR_DIRECTORY_DOWNLOADSSYSDIR_DIRECTORY_INPUT_METHODSSYSDIR_DIRECTORY_MOVIESSYSDIR_DIRECTORY_MUSICSYSDIR_DIRECTORY_PICTURESSYSDIR_DIRECTORY_PRINTER_DESCRIPTIONSYSDIR_DIRECTORY_SHARED_PUBLICSYSDIR_DIRECTORY_PREFERENCE_PANESSYSDIR_DIRECTORY_ALL_APPLICATIONSSYSDIR_DIRECTORY_ALL_LIBRARIESsysdir_search_path_domain_mask_tSYSDIR_DOMAIN_MASK_USERSYSDIR_DOMAIN_MASK_LOCALSYSDIR_DOMAIN_MASK_NETWORKSYSDIR_DOMAIN_MASK_SYSTEM0x0ffffSYSDIR_DOMAIN_MASK_ALL_UTX_USERSIZE_UTX_LINESIZE_UTX_IDSIZE_UTX_HOSTSIZESHUTDOWN_TIMECLOCK_MONOTONIC_RAW_APPROXCLOCK_UPTIME_RAWCLOCK_UPTIME_RAW_APPROXD_MD_ORDERSEEK_HOLESEEK_DATA_PC_NAME_CHARS_MAX_PC_CASE_SENSITIVE_PC_CASE_PRESERVING_PC_EXTENDED_SECURITY_NP_PC_AUTH_OPAQUE_NP_PC_XATTR_SIZE_BITS_PC_MIN_HOLE_SIZEO_EVTONLYO_SYMLINKO_NOFOLLOW_ANYPT_READ_UPT_WRITE_UPT_SIGEXCPT_THUPDATEPT_ATTACHEXCPT_FORCEQUOTAPT_DENY_ATTACHPT_FIRSTMACHCPU_STATE_USERCPU_STATE_SYSTEMCPU_STATE_IDLECPU_STATE_NICECPU_STATE_MAXPROCESSOR_BASIC_INFOPROCESSOR_PM_REGS_INFOPROCESSOR_TEMPERATUREPROCESSOR_SET_LOAD_INFOPROCESSOR_SET_BASIC_INFOMS_KILLPAGESMS_DEACTIVATEEBADRPCERPCMISMATCHEPROGUNAVAILEPROGMISMATCHEPROCUNAVAILEAUTHENEEDAUTHEPWROFFEDEVERREBADEXECEBADARCHESHLIBVERSEBADMACHOENOPOLICYEQFULLELASTF_PREALLOCATEF_RDADVISEF_RDAHEADF_NOCACHEF_LOG2PHYSF_GETPATHF_FULLFSYNCF_FREEZE_FSF_THAW_FSF_GLOBAL_NOCACHEF_NODIRECTF_LOG2PHYS_EXTF_BARRIERFSYNCF_OFD_SETLK// See https://github.com/apple/darwin-xnu/blob/main/bsd/sys/fcntl.hF_OFD_SETLKW/* Acquire or release open file description lock */F_OFD_GETLK/* (as F_OFD_SETLK but blocking if conflicting lock) */F_PUNCHHOLE/* Examine OFD lock */F_TRIM_ACTIVE_FILEF_SPECULATIVE_READF_GETPATH_NOFIRMLINKF_TRANSFEREXTENTSF_ALLOCATECONTIGF_ALLOCATEALLF_ALLOCATEPERSISTF_PEOFPOSMODEF_VOLPOSMODEPTHREAD_INTROSPECTION_THREAD_CREATEPTHREAD_INTROSPECTION_THREAD_STARTPTHREAD_INTROSPECTION_THREAD_TERMINATEPTHREAD_INTROSPECTION_THREAD_DESTROYTIOCIXONTIOCIXOFFTIOCPKT_IOCTLTIOCSTATTIOCSCONSTIOCEXTTIOCSIGTIOCDRAINTIOCMSDTRWAITTIOCMGDTRWAITTIOCSDRAINWAITTIOCGDRAINWAITTIOCDSIMICROCODETIOCPTYGRANTTIOCPTYGNAMETIOCPTYUNLKBIOCGRSIGBIOCSRSIGBIOCSDLTBIOCGSEESENTBIOCSSEESENTBIOCGDLTLISTFIODTYPEB7200B14400B28800B76800PTHREAD_INHERIT_SCHEDPTHREAD_EXPLICIT_SCHEDPTHREAD_CANCEL_ENABLEPTHREAD_CANCEL_DISABLEPTHREAD_CANCEL_DEFERREDPTHREAD_CANCEL_ASYNCHRONOUSPTHREAD_CANCELEDPTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_PROCESS_RLIMIT_POSIX_FLAGMADV_ZERO_WIRED_PAGESMADV_FREE_REUSABLEMADV_FREE_REUSEMADV_CAN_REUSEMINCORE_INCOREMINCORE_REFERENCEDMINCORE_MODIFIEDMINCORE_REFERENCED_OTHERMINCORE_MODIFIED_OTHERCTLIOCGINFO/// IP6 hop-by-hop options/// gateway<sup>2</sup> (deprecated)IPPROTO_ST/// Stream protocol II.IPPROTO_PIGP/// private interior gatewayIPPROTO_RCCMON/// BBN RCC MonitoringIPPROTO_NVPII/// network voice protocolIPPROTO_ARGUS/// ArgusIPPROTO_EMCON/// EMCONIPPROTO_XNET/// Cross Net DebuggerIPPROTO_CHAOS/// ChaosIPPROTO_MUX/// MultiplexingIPPROTO_MEAS/// DCN Measurement SubsystemsIPPROTO_HMP/// Host MonitoringIPPROTO_PRM/// Packet Radio MeasurementIPPROTO_TRUNK1/// Trunk-1IPPROTO_TRUNK2/// Trunk-2IPPROTO_LEAF1/// Leaf-1IPPROTO_LEAF2/// Leaf-2IPPROTO_RDP/// Reliable DataIPPROTO_IRTP/// Reliable TransactionIPPROTO_BLT/// Bulk Data TransferIPPROTO_NSP/// Network ServicesIPPROTO_INP/// Merit InternodalIPPROTO_SEP/// Sequential ExchangeIPPROTO_3PC/// Third Party ConnectIPPROTO_IDPR/// InterDomain Policy RoutingIPPROTO_XTP/// XTPIPPROTO_DDP/// Datagram DeliveryIPPROTO_CMTP/// Control Message TransportIPPROTO_TPXX/// TP++ TransportIPPROTO_IL/// IL transport protocolIPPROTO_SDRP/// Source Demand RoutingIPPROTO_IDRP/// InterDomain RoutingIPPROTO_MHRP/// Mobile Host RoutingIPPROTO_BHA/// BHAIPPROTO_INLSP/// Integ. Net Layer SecurityIPPROTO_SWIPE/// IP with encryptionIPPROTO_NHRP/// Next Hop Resolution/* 55-57: Unassigned */IPPROTO_AHIP/// any host internal protocolIPPROTO_CFTP/// CFTPIPPROTO_HELLO/// "hello" routing protocolIPPROTO_SATEXPAK/// SATNET/Backroom EXPAKIPPROTO_KRYPTOLAN/// KryptolanIPPROTO_RVD/// Remote Virtual DiskIPPROTO_IPPC/// Pluribus Packet CoreIPPROTO_ADFS/// Any distributed FSIPPROTO_SATMON/// Satnet MonitoringIPPROTO_VISA/// VISA ProtocolIPPROTO_IPCV/// Packet Core UtilityIPPROTO_CPNX/// Comp. Prot. Net. ExecutiveIPPROTO_CPHB/// Comp. Prot. HeartBeatIPPROTO_WSN/// Wang Span NetworkIPPROTO_PVP/// Packet Video ProtocolIPPROTO_BRSATMON/// BackRoom SATNET MonitoringIPPROTO_ND/// Sun net disk proto (temp.)IPPROTO_WBMON/// WIDEBAND MonitoringIPPROTO_WBEXPAK/// WIDEBAND EXPAK/// ISO cnlpIPPROTO_VMTP/// VMTPIPPROTO_SVMTP/// Secure VMTPIPPROTO_VINES/// Banyon VINESIPPROTO_TTP/// TTPIPPROTO_IGP/// NSFNET-IGPIPPROTO_DGP/// dissimilar gateway prot.IPPROTO_TCF/// TCFIPPROTO_IGRP/// Cisco/GXS IGRPIPPROTO_OSPFIGP/// OSPFIGPIPPROTO_SRPC/// Strite RPC protocolIPPROTO_LARP/// Locus Address Resoloution/// Multicast TransportIPPROTO_AX25/// AX.25 FramesIPPROTO_IPEIP/// IP encapsulated in IPIPPROTO_MICP/// Mobile Int.ing controlIPPROTO_SCCSP/// Semaphore Comm. securityIPPROTO_ETHERIP/// Ethernet IP encapsulationIPPROTO_APES/// any private encr. schemeIPPROTO_GMTP/// GMTP/* 101-254: Partly Unassigned *//// Protocol Independent McastIPPROTO_IPCOMP/// payload compression (IPComp)IPPROTO_PGM/// PGMIPPROTO_DIVERT/* 255: Reserved *//* BSD Private, local use, namespace incursion *//// divert pseudo-protocolIPPROTO_DONE/// last return value of *_input(), meaning "all job for this pkt is done".AF_COIPAF_CNTpseudo_AF_RTIPAF_SIPpseudo_AF_PIPAF_NDRVAF_E164pseudo_AF_KEYAF_NATMAF_SYSTEMAF_NETBIOSAF_PPPpseudo_AF_HDRCMPLTAF_IEEE80211AF_UTUNAF_SYS_CONTROLSYSPROTO_EVENTSYSPROTO_CONTROLPF_COIPPF_CNTPF_SIPPF_RTIPPF_PIPPF_NDRVPF_NATMPF_SYSTEMPF_NETBIOSPF_PPPNET_RT_DUMPNET_RT_FLAGSNET_RT_IFLISTSOCK_MAXADDRLENIP_BOUND_IFIP_PKTINFOIPV6_BOUND_IFTCP_NOPUSHTCP_NOOPT/// Enable/Disable TCP Fastopen on this socketTCP_CONNECTION_INFOSOL_LOCALLOCAL_PEERCRED/// Retrieve peer credentials.LOCAL_PEERPID/// Retrieve peer PID.LOCAL_PEEREPID/// Retrieve effective peer PID.LOCAL_PEERUUID/// Retrieve peer UUID.LOCAL_PEEREUUID/// Retrieve effective peer UUID.LOCAL_PEERTOKEN/// Retrieve peer audit token.SO_TIMESTAMP_MONOTONICSO_DONTTRUNCSO_WANTMORESO_WANTOOBFLAGSO_LABELSO_PEERLABELSO_NREADSO_NKESO_NOSIGPIPESO_NOADDRERRSO_NWRITESO_REUSESHAREUIDSO_NOTIFYCONFLICTSO_LINGER_SECSO_RANDOMPORTSO_NP_EXTENSIONSMSG_EOFMSG_FLUSHMSG_HOLDMSG_SENDMSG_HAVEMOREMSG_RCVMOREMSG_NEEDSASCM_CREDS// https://github.com/aosm/xnu/blob/HEAD/bsd/net/if.h#L140-L156// interface is up// broadcast address valid// turn on debugging// is a loopback net// interface is point-to-point link// obsolete: avoid use of trailers// resources allocated// no address resolution protocol// receive all packets// receive all multicast packets// transmission in progress// can't hear own transmissions// per link layer defined bitIFF_ALTPHYS// use alternate physical connectionSCOPE6_ID_MAXSAE_ASSOCID_ANYSAE_ASSOCID_ALL/// ((sae_associd_t)(-1ULL))SAE_CONNID_ANYSAE_CONNID_ALL/// ((sae_connid_t)(-1ULL))CONNECT_RESUME_ON_READ_WRITE/// resume connect() on read/writeCONNECT_DATA_IDEMPOTENT/// data is idempotentCONNECT_DATA_AUTHENTICATED/// data includes security that replaces the TFO-cookieMAP_COPYMAP_RENAMEMAP_NOEXTENDMAP_HASSEMAPHOREMAP_NOCACHEMAP_JIT_SC_FILE_LOCKING_CS_PATH// `confstr` keys (only the values guaranteed by `man confstr`)._CS_DARWIN_USER_DIR_CS_DARWIN_USER_TEMP_DIR_CS_DARWIN_USER_CACHE_DIR_PTHREAD_MUTEX_SIG_init_PTHREAD_COND_SIG_init_PTHREAD_RWLOCK_SIG_initOS_UNFAIR_LOCK_INITOS_LOG_TYPE_DEFAULTOS_LOG_TYPE_INFOOS_LOG_TYPE_DEBUGOS_LOG_TYPE_ERROROS_LOG_TYPE_FAULTOS_SIGNPOST_EVENTOS_SIGNPOST_INTERVAL_BEGINOS_SIGNPOST_INTERVAL_ENDEVFILT_READEVFILT_WRITEEVFILT_AIOEVFILT_VNODEEVFILT_PROCEVFILT_SIGNALEVFILT_TIMEREVFILT_MACHPORTEVFILT_FSEVFILT_USEREVFILT_VMEV_ADDEV_DELETEEV_ENABLEEV_DISABLEEV_ONESHOTEV_CLEAREV_RECEIPTEV_DISPATCHEV_FLAG0EV_POLLEV_FLAG1EV_OOBANDEV_ERROREV_EOFEV_SYSFLAGSNOTE_TRIGGERNOTE_FFNOPNOTE_FFANDNOTE_FFORNOTE_FFCOPYNOTE_FFCTRLMASKNOTE_FFLAGSMASKNOTE_LOWATNOTE_DELETENOTE_WRITENOTE_EXTENDNOTE_ATTRIBNOTE_LINKNOTE_RENAMENOTE_REVOKENOTE_NONENOTE_EXITNOTE_FORKNOTE_EXECNOTE_REAPNOTE_SIGNALNOTE_EXITSTATUSNOTE_EXIT_DETAILNOTE_PDATAMASKNOTE_PCTRLMASKNOTE_EXIT_REPARENTEDNOTE_EXIT_DETAIL_MASKNOTE_EXIT_DECRYPTFAILNOTE_EXIT_MEMORYNOTE_EXIT_CSERRORNOTE_VM_PRESSURENOTE_VM_PRESSURE_TERMINATENOTE_VM_PRESSURE_SUDDEN_TERMINATENOTE_VM_ERRORNOTE_SECONDSNOTE_USECONDSNOTE_NSECONDSNOTE_ABSOLUTENOTE_LEEWAYNOTE_CRITICALNOTE_BACKGROUNDNOTE_MACH_CONTINUOUS_TIMENOTE_MACHTIMENOTE_TRACKNOTE_TRACKERRNOTE_CHILDRENAME_SWAPRENAME_EXCLRTLD_FIRSTRTLD_MAIN_ONLY_WSTOPPEDLOG_NETINFOLOG_REMOTEAUTHLOG_INSTALLLOG_RASLOG_LAUNCHDCTLTYPECTLTYPE_NODECTLTYPE_INTCTLTYPE_STRINGCTLTYPE_QUADCTLTYPE_OPAQUECTLTYPE_STRUCTCTLFLAG_RDCTLFLAG_WRCTLFLAG_RWCTLFLAG_NOLOCKCTLFLAG_ANYBODYCTLFLAG_SECURECTLFLAG_MASKEDCTLFLAG_NOAUTOCTLFLAG_KERNCTLFLAG_LOCKEDCTLFLAG_OID2CTL_UNSPECCTL_KERNCTL_VMCTL_VFSCTL_DEBUGCTL_HWCTL_MACHDEPCTL_USERCTL_MAXIDKERN_OSTYPEKERN_OSRELEASEKERN_OSREVKERN_VERSIONKERN_MAXVNODESKERN_MAXPROCKERN_MAXFILESKERN_ARGMAXKERN_SECURELVLKERN_HOSTNAMEKERN_HOSTIDKERN_CLOCKRATEKERN_VNODEKERN_PROCKERN_FILEKERN_PROFKERN_POSIX1KERN_NGROUPSKERN_JOB_CONTROLKERN_SAVED_IDSKERN_BOOTTIMEKERN_NISDOMAINNAMEKERN_DOMAINNAMEKERN_MAXPARTITIONSKERN_KDEBUGKERN_UPDATEINTERVALKERN_OSRELDATEKERN_NTP_PLLKERN_BOOTFILEKERN_MAXFILESPERPROCKERN_MAXPROCPERUIDKERN_DUMPDEVKERN_IPCKERN_DUMMYKERN_PS_STRINGSKERN_USRSTACK32KERN_LOGSIGEXITKERN_SYMFILEKERN_PROCARGSKERN_NETBOOTKERN_SYSVKERN_AFFINITYKERN_TRANSLATEKERN_CLASSICKERN_EXECKERN_CLASSICHANDLERKERN_AIOMAXKERN_AIOPROCMAXKERN_AIOTHREADSKERN_COREFILEKERN_COREDUMPKERN_SUGID_COREDUMPKERN_PROCDELAYTERMKERN_SHREG_PRIVATIZABLEKERN_LOW_PRI_WINDOWKERN_LOW_PRI_DELAYKERN_POSIXKERN_USRSTACK64KERN_NX_PROTECTIONKERN_TFPKERN_PROCNAMEKERN_THALTSTACKKERN_SPECULATIVE_READSKERN_OSVERSIONKERN_SAFEBOOTKERN_RAGEVNODEKERN_TTYKERN_CHECKOPENEVTKERN_THREADNAMEKERN_MAXIDKERN_RAGE_PROCKERN_RAGE_THREADKERN_UNRAGE_PROCKERN_UNRAGE_THREADKERN_OPENEVT_PROCKERN_UNOPENEVT_PROCKERN_TFP_POLICYKERN_TFP_POLICY_DENYKERN_TFP_POLICY_DEFAULTKERN_KDEFLAGSKERN_KDDFLAGSKERN_KDENABLEKERN_KDSETBUFKERN_KDGETBUFKERN_KDSETUPKERN_KDREMOVEKERN_KDSETREGKERN_KDGETREGKERN_KDREADTRKERN_KDPIDTRKERN_KDTHRMAPKERN_KDPIDEXKERN_KDSETRTCDECKERN_KDGETENTROPYKERN_KDWRITETRKERN_KDWRITEMAPKERN_KDENABLE_BG_TRACEKERN_KDDISABLE_BG_TRACEKERN_KDREADCURTHRMAPKERN_KDSET_TYPEFILTERKERN_KDBUFWAITKERN_KDCPUMAPKERN_PROC_ALLKERN_PROC_PIDKERN_PROC_PGRPKERN_PROC_SESSIONKERN_PROC_TTYKERN_PROC_UIDKERN_PROC_RUIDKERN_PROC_LCIDKERN_SUCCESSKERN_INVALID_ADDRESSKERN_PROTECTION_FAILUREKERN_NO_SPACEKERN_INVALID_ARGUMENTKERN_FAILUREKERN_RESOURCE_SHORTAGEKERN_NOT_RECEIVERKERN_NO_ACCESSKERN_MEMORY_FAILUREKERN_MEMORY_ERRORKERN_ALREADY_IN_SETKERN_NOT_IN_SETKERN_NAME_EXISTSKERN_ABORTEDKERN_INVALID_NAMEKERN_INVALID_TASKKERN_INVALID_RIGHTKERN_INVALID_VALUEKERN_UREFS_OVERFLOWKERN_INVALID_CAPABILITYKERN_RIGHT_EXISTSKERN_INVALID_HOSTKERN_MEMORY_PRESENTKERN_MEMORY_DATA_MOVEDKERN_MEMORY_RESTART_COPYKERN_INVALID_PROCESSOR_SETKERN_POLICY_LIMITKERN_INVALID_POLICYKERN_INVALID_OBJECTKERN_ALREADY_WAITINGKERN_DEFAULT_SETKERN_EXCEPTION_PROTECTEDKERN_INVALID_LEDGERKERN_INVALID_MEMORY_CONTROLKERN_INVALID_SECURITYKERN_NOT_DEPRESSEDKERN_TERMINATEDKERN_LOCK_SET_DESTROYEDKERN_LOCK_UNSTABLEKERN_LOCK_OWNEDKERN_LOCK_OWNED_SELFKERN_SEMAPHORE_DESTROYEDKERN_RPC_SERVER_TERMINATEDKERN_RPC_TERMINATE_ORPHANKERN_RPC_CONTINUE_ORPHANKERN_NOT_SUPPORTEDKERN_NODE_DOWNKERN_NOT_WAITINGKERN_OPERATION_TIMED_OUTKERN_CODESIGN_ERRORKERN_POLICY_STATICKERN_INSUFFICIENT_BUFFER_SIZEKIPC_MAXSOCKBUFKIPC_SOCKBUF_WASTEKIPC_SOMAXCONNKIPC_MAX_LINKHDRKIPC_MAX_PROTOHDRKIPC_MAX_HDRKIPC_MAX_DATALENKIPC_MBSTATKIPC_NMBCLUSTERSKIPC_SOQLIMITCOMPATVM_METERVM_LOADAVGVM_MACHFACTORVM_SWAPUSAGEVM_MAXIDVM_PROT_NONEVM_PROT_READVM_PROT_WRITEVM_PROT_EXECUTEMEMORY_OBJECT_NULLHW_MACHINEHW_MODELHW_NCPUHW_BYTEORDERHW_PHYSMEMHW_USERMEMHW_PAGESIZEHW_DISKNAMESHW_DISKSTATSHW_EPOCHHW_FLOATINGPTHW_MACHINE_ARCHHW_VECTORUNITHW_BUS_FREQHW_CPU_FREQHW_CACHELINEHW_L1ICACHESIZEHW_L1DCACHESIZEHW_L2SETTINGSHW_L2CACHESIZEHW_L3SETTINGSHW_L3CACHESIZEHW_TB_FREQHW_MEMSIZEHW_AVAILCPUHW_TARGETHW_PRODUCTHW_MAXIDUSER_CS_PATHUSER_BC_BASE_MAXUSER_BC_DIM_MAXUSER_BC_SCALE_MAXUSER_BC_STRING_MAXUSER_COLL_WEIGHTS_MAXUSER_EXPR_NEST_MAXUSER_LINE_MAXUSER_RE_DUP_MAXUSER_POSIX2_VERSIONUSER_POSIX2_C_BINDUSER_POSIX2_C_DEVUSER_POSIX2_CHAR_TERMUSER_POSIX2_FORT_DEVUSER_POSIX2_FORT_RUNUSER_POSIX2_LOCALEDEFUSER_POSIX2_SW_DEVUSER_POSIX2_UPEUSER_STREAM_MAXUSER_TZNAME_MAXUSER_MAXIDCTL_DEBUG_NAMECTL_DEBUG_VALUECTL_DEBUG_MAXIDPRIO_DARWIN_THREADPRIO_DARWIN_PROCESSPRIO_DARWIN_BGPRIO_DARWIN_NONUIAI_MASKAI_V4MAPPED_CFGAI_UNUSABLEXATTR_NOFOLLOWXATTR_NOSECURITYXATTR_NODEFAULTXATTR_SHOWCOMPRESSIONRTF_DELCLONERTF_NOIFREFRTF_PRCLONINGRTF_WASCLONEDRTF_IFSCOPERTF_CONDEMNEDRTF_IFREFRTF_PROXYRTF_ROUTERRTF_DEADRTF_GLOBALRTM_VERSION// Message typesRTM_NEWMADDRRTM_DELMADDRRTM_NEWMADDR2RTM_GET2// Bitmask values for rtm_inits and rmx_locks.KERN_PROCARGS2PROC_PIDTASKALLINFOPROC_PIDTBSDINFOPROC_PIDTASKINFOPROC_PIDTHREADINFOPROC_PIDVNODEPATHINFOPROC_PIDPATHINFO_MAXSIZEPROC_PIDLISTFDSPROC_PIDLISTFD_SIZEPROX_FDTYPE_ATALKPROX_FDTYPE_VNODEPROX_FDTYPE_SOCKETPROX_FDTYPE_PSHMPROX_FDTYPE_PSEMPROX_FDTYPE_KQUEUEPROX_FDTYPE_PIPEPROX_FDTYPE_FSEVENTSPROX_FDTYPE_NETPOLICYPROX_FDTYPE_CHANNELPROX_FDTYPE_NEXUSPROC_CSM_ALLPROC_CSM_NOSMTPROC_CSM_TECSMAXTHREADNAMESIZEXUCRED_VERSIONLC_SEGMENTLC_SEGMENT_64MH_MAGICMH_MAGIC_64UTUN_OPT_FLAGS// net/if_utun.hUTUN_OPT_IFNAME// no link-layer encapsulation// Ethernet (10Mb)// Experimental Ethernet (3Mb)// Amateur Radio AX.25DLT_CHAOS// Proteon ProNET Token Ring// Chaos// IEEE 802 Networks// ARCNET// Serial Line IP// Point-to-point ProtocolDLT_ATM_RFC1483// FDDIDLT_RAW// LLC/SNAP encapsulated atmDLT_LOOP// raw IP// https://github.com/apple/darwin-xnu/blob/HEAD/bsd/net/bpf.h#L100// sizeof(i32)MNT_NODEV// sys/mount.hMNT_UNIONMNT_CPROTECTMNT_QUARANTINE// MAC labeled / "quarantined" flagMNT_LOCAL// Flags set by internal operations.MNT_QUOTAMNT_ROOTFSMNT_DOVOLFSMNT_DONTBROWSEMNT_IGNORE_OWNERSHIPMNT_AUTOMOUNTEDMNT_JOURNALEDMNT_NOUSERXATTRMNT_DEFWRITEMNT_MULTILABELMNT_NOATIMEMNT_SNAPSHOTMNT_NOBLOCK// External filesystem command modifier flags.// sys/spawn.h:POSIX_SPAWN_SETEXECPOSIX_SPAWN_START_SUSPENDEDPOSIX_SPAWN_CLOEXEC_DEFAULT// sys/ipc.h:IPC_MUF_SETTABLE// Flags for chflags(2)UF_NODUMPUF_IMMUTABLEUF_APPENDUF_OPAQUEUF_COMPRESSEDUF_TRACKEDSF_SETTABLESF_ARCHIVEDSF_IMMUTABLESF_APPENDUF_HIDDENNTP_API//<sys/timex.h>MAXPHASEMAXFREQMINSECMAXSECNANOSECONDSCALE_PPMMAXTCMOD_OFFSETMOD_FREQUENCYMOD_MAXERRORMOD_ESTERRORMOD_STATUSMOD_TIMECONSTMOD_PPSMAXMOD_TAIMOD_MICROMOD_NANOMOD_CLKBMOD_CLKASTA_PLLSTA_PPSFREQSTA_PPSTIMESTA_FLLSTA_INSSTA_DELSTA_UNSYNCSTA_FREQHOLDSTA_PPSSIGNALSTA_PPSJITTERSTA_PPSWANDERSTA_PPSERRORSTA_CLOCKERRSTA_NANOSTA_MODESTA_CLKSTA_RONLYTIME_OKTIME_INSTIME_DELTIME_OOPTIME_WAITTIME_ERRORMNT_WAIT// <sys/mount.h>MNT_NOWAITTHREAD_STANDARD_POLICY// <mach/thread_policy.h>THREAD_STANDARD_POLICY_COUNTTHREAD_EXTENDED_POLICYTHREAD_TIME_CONSTRAINT_POLICYTHREAD_PRECEDENCE_POLICYTHREAD_AFFINITY_POLICYTHREAD_AFFINITY_TAG_NULLTHREAD_BACKGROUND_POLICYTHREAD_BACKGROUND_POLICY_DARWIN_BGTHREAD_LATENCY_QOS_POLICYTHREAD_THROUGHPUT_QOS_POLICYTH_STATE_RUNNING// <mach/thread_info.h>TH_STATE_STOPPEDTH_STATE_WAITINGTH_STATE_UNINTERRUPTIBLETH_STATE_HALTEDTH_FLAGS_SWAPPEDTH_FLAGS_IDLETH_FLAGS_GLOBAL_FORCED_IDLETHREAD_BASIC_INFOTHREAD_IDENTIFIER_INFOTHREAD_EXTENDED_INFOkCCSuccess// CommonCrypto/CommonCryptoError.hkCCParamErrorkCCBufferTooSmallkCCMemoryFailurekCCAlignmentErrorkCCDecodeErrorkCCUnimplementedkCCOverflowkCCRNGFailurekCCUnspecifiedErrorkCCCallSequenceErrorkCCKeySizeErrorkCCInvalidKeyHOST_LOAD_INFOHOST_VM_INFOHOST_CPU_LOAD_INFOHOST_VM_INFO64HOST_EXTMOD_INFO64HOST_EXPIRED_TASK_INFOVM_PAGE_QUERY_PAGE_PRESENT// mach/vm_statistics.hVM_PAGE_QUERY_PAGE_FICTITIOUSVM_PAGE_QUERY_PAGE_REFVM_PAGE_QUERY_PAGE_DIRTYVM_PAGE_QUERY_PAGE_PAGED_OUTVM_PAGE_QUERY_PAGE_COPIEDVM_PAGE_QUERY_PAGE_SPECULATIVEVM_PAGE_QUERY_PAGE_EXTERNALVM_PAGE_QUERY_PAGE_CS_VALIDATEDVM_PAGE_QUERY_PAGE_CS_TAINTEDVM_PAGE_QUERY_PAGE_CS_NXTASK_THREAD_TIMES_INFO// mach/task_info.hHOST_CPU_LOAD_INFO_COUNTMACH_TASK_BASIC_INFOMACH_PORT_NULLRUSAGE_INFO_V0RUSAGE_INFO_V1RUSAGE_INFO_V2RUSAGE_INFO_V3RUSAGE_INFO_V4COPYFILE_ACL// copyfile.hCOPYFILE_STATCOPYFILE_XATTRCOPYFILE_DATACOPYFILE_SECURITYCOPYFILE_METADATACOPYFILE_RECURSIVECOPYFILE_CHECKCOPYFILE_EXCLCOPYFILE_NOFOLLOW_SRCCOPYFILE_NOFOLLOW_DSTCOPYFILE_MOVECOPYFILE_UNLINKCOPYFILE_NOFOLLOWCOPYFILE_PACKCOPYFILE_UNPACKCOPYFILE_CLONECOPYFILE_CLONE_FORCECOPYFILE_RUN_IN_PLACECOPYFILE_DATA_SPARSECOPYFILE_PRESERVE_DST_TRACKEDCOPYFILE_VERBOSECOPYFILE_RECURSE_ERRORCOPYFILE_RECURSE_FILECOPYFILE_RECURSE_DIRCOPYFILE_RECURSE_DIR_CLEANUPCOPYFILE_COPY_DATACOPYFILE_COPY_XATTRCOPYFILE_STARTCOPYFILE_FINISHCOPYFILE_ERRCOPYFILE_PROGRESSCOPYFILE_CONTINUECOPYFILE_SKIPCOPYFILE_QUITCOPYFILE_STATE_SRC_FDCOPYFILE_STATE_SRC_FILENAMECOPYFILE_STATE_DST_FDCOPYFILE_STATE_DST_FILENAMECOPYFILE_STATE_QUARANTINECOPYFILE_STATE_STATUS_CBCOPYFILE_STATE_STATUS_CTXCOPYFILE_STATE_COPIEDCOPYFILE_STATE_XATTRNAMECOPYFILE_STATE_WAS_CLONEDCOPYFILE_STATE_SRC_BSIZECOPYFILE_STATE_DST_BSIZECOPYFILE_STATE_BSIZEATTR_BIT_MAP_COUNT// <sys/attr.h>FSOPT_NOFOLLOWFSOPT_NOFOLLOW_ANYFSOPT_REPORT_FULLSIZEFSOPT_PACK_INVAL_ATTRSFSOPT_ATTR_CMN_EXTENDEDFSOPT_RETURN_REALDEVATTR_CMN_NAMEATTR_CMN_DEVIDATTR_CMN_FSIDATTR_CMN_OBJTYPEATTR_CMN_OBJTAGATTR_CMN_OBJIDATTR_CMN_OBJPERMANENTIDATTR_CMN_PAROBJIDATTR_CMN_SCRIPTATTR_CMN_CRTIMEATTR_CMN_MODTIMEATTR_CMN_CHGTIMEATTR_CMN_ACCTIMEATTR_CMN_BKUPTIMEATTR_CMN_FNDRINFOATTR_CMN_OWNERIDATTR_CMN_GRPIDATTR_CMN_ACCESSMASKATTR_CMN_FLAGSATTR_CMN_GEN_COUNTATTR_CMN_DOCUMENT_IDATTR_CMN_USERACCESSATTR_CMN_EXTENDED_SECURITYATTR_CMN_UUIDATTR_CMN_GRPUUIDATTR_CMN_FILEIDATTR_CMN_PARENTIDATTR_CMN_FULLPATHATTR_CMN_ADDEDTIMEATTR_CMN_DATA_PROTECT_FLAGSATTR_CMN_RETURNED_ATTRSATTR_VOL_FSTYPEATTR_VOL_SIGNATUREATTR_VOL_SIZEATTR_VOL_SPACEFREEATTR_VOL_SPACEAVAILATTR_VOL_MINALLOCATIONATTR_VOL_ALLOCATIONCLUMPATTR_VOL_IOBLOCKSIZEATTR_VOL_OBJCOUNTATTR_VOL_FILECOUNTATTR_VOL_DIRCOUNTATTR_VOL_MAXOBJCOUNTATTR_VOL_MOUNTPOINTATTR_VOL_NAMEATTR_VOL_MOUNTFLAGSATTR_VOL_MOUNTEDDEVICEATTR_VOL_ENCODINGSUSEDATTR_VOL_CAPABILITIESATTR_VOL_UUIDATTR_VOL_SPACEUSEDATTR_VOL_QUOTA_SIZEATTR_VOL_RESERVED_SIZEATTR_VOL_ATTRIBUTESATTR_VOL_INFOATTR_DIR_LINKCOUNTATTR_DIR_ENTRYCOUNTATTR_DIR_MOUNTSTATUSATTR_DIR_ALLOCSIZEATTR_DIR_IOBLOCKSIZEATTR_DIR_DATALENGTHATTR_FILE_LINKCOUNTATTR_FILE_TOTALSIZEATTR_FILE_ALLOCSIZEATTR_FILE_IOBLOCKSIZEATTR_FILE_DEVTYPEATTR_FILE_FORKCOUNTATTR_FILE_FORKLISTATTR_FILE_DATALENGTHATTR_FILE_DATAALLOCSIZEATTR_FILE_RSRCLENGTHATTR_FILE_RSRCALLOCSIZEATTR_CMNEXT_RELPATHATTR_CMNEXT_PRIVATESIZEATTR_CMNEXT_LINKIDATTR_CMNEXT_NOFIRMLINKPATHATTR_CMNEXT_REALDEVIDATTR_CMNEXT_REALFSIDATTR_CMNEXT_CLONEIDATTR_CMNEXT_EXT_FLAGSATTR_CMNEXT_RECURSIVE_GENCOUNTDIR_MNTSTATUS_MNTPOINTVOL_CAPABILITIES_FORMATVOL_CAPABILITIES_INTERFACESVOL_CAP_FMT_PERSISTENTOBJECTIDSVOL_CAP_FMT_SYMBOLICLINKSVOL_CAP_FMT_HARDLINKSVOL_CAP_FMT_JOURNALVOL_CAP_FMT_JOURNAL_ACTIVEVOL_CAP_FMT_NO_ROOT_TIMESVOL_CAP_FMT_SPARSE_FILESVOL_CAP_FMT_ZERO_RUNSVOL_CAP_FMT_CASE_SENSITIVEVOL_CAP_FMT_CASE_PRESERVINGVOL_CAP_FMT_FAST_STATFSVOL_CAP_FMT_2TB_FILESIZEVOL_CAP_FMT_OPENDENYMODESVOL_CAP_FMT_HIDDEN_FILESVOL_CAP_FMT_PATH_FROM_IDVOL_CAP_FMT_NO_VOLUME_SIZESVOL_CAP_FMT_DECMPFS_COMPRESSIONVOL_CAP_FMT_64BIT_OBJECT_IDSVOL_CAP_FMT_DIR_HARDLINKSVOL_CAP_FMT_DOCUMENT_IDVOL_CAP_FMT_WRITE_GENERATION_COUNTVOL_CAP_FMT_NO_IMMUTABLE_FILESVOL_CAP_FMT_NO_PERMISSIONSVOL_CAP_FMT_SHARED_SPACEVOL_CAP_FMT_VOL_GROUPSVOL_CAP_FMT_SEALEDVOL_CAP_INT_SEARCHFSVOL_CAP_INT_ATTRLISTVOL_CAP_INT_NFSEXPORTVOL_CAP_INT_READDIRATTRVOL_CAP_INT_EXCHANGEDATAVOL_CAP_INT_COPYFILEVOL_CAP_INT_ALLOCATEVOL_CAP_INT_VOL_RENAMEVOL_CAP_INT_ADVLOCKVOL_CAP_INT_FLOCKVOL_CAP_INT_EXTENDED_SECURITYVOL_CAP_INT_USERACCESSVOL_CAP_INT_MANLOCKVOL_CAP_INT_NAMEDSTREAMSVOL_CAP_INT_EXTENDED_ATTRVOL_CAP_INT_CLONEVOL_CAP_INT_SNAPSHOTVOL_CAP_INT_RENAME_SWAPVOL_CAP_INT_RENAME_EXCLVOL_CAP_INT_RENAME_OPENFAILOS_CLOCK_MACH_ABSOLUTE_TIME// os/clock.hOS_SYNC_WAIT_ON_ADDRESS_NONE// os/os_sync_wait_on_address.hOS_SYNC_WAIT_ON_ADDRESS_SHAREDOS_SYNC_WAKE_BY_ADDRESS_NONEOS_SYNC_WAKE_BY_ADDRESS_SHAREDSIDL// <proc.h>SRUN/// Currently runnable.SSLEEPSSTOPSZOMB/// Awaiting collection by parent.VMADDR_CID_ANY// sys/vsock.hVMADDR_CID_HYPERVISORVMADDR_CID_RESERVEDVMADDR_CID_HOSTVMADDR_PORT_ANY__DARWIN_ALIGN32THREAD_EXTENDED_POLICY_COUNTTHREAD_TIME_CONSTRAINT_POLICY_COUNTTHREAD_PRECEDENCE_POLICY_COUNTTHREAD_AFFINITY_POLICY_COUNTTHREAD_BACKGROUND_POLICY_COUNTTHREAD_LATENCY_QOS_POLICY_COUNTTHREAD_THROUGHPUT_QOS_POLICY_COUNTTHREAD_BASIC_INFO_COUNTTHREAD_IDENTIFIER_INFO_COUNTTHREAD_EXTENDED_INFO_COUNTTASK_THREAD_TIMES_INFO_COUNTMACH_TASK_BASIC_INFO_COUNTHOST_VM_INFO64_COUNTIFMIB_SYSTEM// bsd/net/if_mib.h/// Non-interface-specificIFMIB_IFDATA/// Per-interface data tableIFMIB_IFALLDATA/// All interfaces data at onceIFDATA_GENERAL/// Generic stats for all kinds of ifacesIFDATA_LINKSPECIFIC/// Specific to the type of interfaceIFDATA_ADDRS/// Addresses assigned to interfaceIFDATA_MULTIADDRS/// Multicast addresses assigned to interfaceIFMIB_IFCOUNT/// Number of interfaces configuredNETLINK_GENERIC/// Functions not specific to a type of ifaceDOT3COMPLIANCE_STATSDOT3COMPLIANCE_COLLSMAX_KCTL_NAME// kern_control.haio_writeaio_returnaio_suspendchflagsfchflagsutmpxnamegetdatesysctlnametomibmach_absolute_timemach_host_selfmach_thread_selfpthread_attr_getinheritschedpthread_attr_getschedpolicypthread_attr_getscopepthread_attr_getstackaddrpthread_attr_getdetachstatepthread_attr_setinheritschedpthread_attr_setschedpolicypthread_attr_setscopepthread_attr_setstackaddrpthread_mach_thread_nppthread_from_mach_thread_nppthread_create_from_mach_threadpthread_stack_frame_decode_nppthread_get_stackaddr_nppthread_get_stacksize_nppthread_main_nppthread_threadid_nppthread_attr_set_qos_class_nppthread_attr_get_qos_class_nppthread_set_qos_class_self_nppthread_get_qos_class_nppthread_introspection_hook_install// Available from Big Surpthread_introspection_setspecific_nppthread_introspection_getspecific_nppthread_jit_write_protect_nppthread_jit_write_protect_supported_nppthread_jit_write_with_callback_np// An array of pthread_jit_write_with_callback_np must declare// the list of callbacks e.g.// #[link_section = "__DATA_CONST,__pth_jit_func"]// static callbacks: [libc::pthread_jit_write_callback_t; 2] = [native_jit_write_cb,// std::mem::transmute::<libc::pthread_jit_write_callback_t>(std::ptr::null())];// (a handy PTHREAD_JIT_WRITE_CALLBACK_NP macro for other languages).pthread_jit_write_freeze_callbacks_nppthread_cpu_number_npos_sync_wait_on_address// Available starting with macOS 14.4.os_sync_wait_on_address_with_deadlineos_sync_wait_on_address_with_timeoutos_sync_wake_by_address_anyos_sync_wake_by_address_allos_unfair_lock_lockos_unfair_lock_trylockos_unfair_lock_unlockos_unfair_lock_assert_owneros_unfair_lock_assert_not_owneros_log_createos_log_type_enabledos_signpost_id_make_with_pointeros_signpost_id_generateos_signpost_enabledthread_policy_setthread_policy_getthread_info__errorbacktrace_symbolsbacktrace_symbols_fdbacktrace_from_fpbacktrace_image_offsetsbacktrace_asynckeventkevent64kevent64_sfmountptracesendfilesf_hdtrforkptylogin_ttyquerylocalefgetxattrfsetxattrflistxattrrenamex_nprenameatx_npfremovexattr_dyld_image_count_dyld_get_image_headermach_header_dyld_get_image_vmaddr_slide_dyld_get_image_nameposix_spawnattr_setarchpref_npposix_spawnattr_getarchpref_npposix_spawnattr_getbinpref_npposix_spawnattr_setbinpref_npposix_spawnattr_set_qos_class_npposix_spawnattr_get_qos_class_npconnectxsa_endpoints_tdisconnectxntp_adjtimetimexntp_gettimentptimevalgetmntinfogetfsstatclonefile// Copy-on-write functions.// According to the man page `flags` is an `int` but in the header// this is a `uint32_t`.clonefileatfclonefileatcopyfilefcopyfilecopyfile_state_freecopyfile_state_alloccopyfile_state_getcopyfile_state_setmach_error_string// Added in macOS 10.13// ISO/IEC 9899:2011 ("ISO C11") K.3.7.4.1memset_pattern4// Added in macOS 10.5memset_pattern8memset_pattern16strtonum// Inherited from BSD but available from Big Sur onlymstatsmalloc_printfmalloc_zone_checkmalloc_zone_tmalloc_zone_printmalloc_zone_statisticsmalloc_statistics_tmalloc_zone_logmalloc_zone_print_ptr_infomalloc_default_zonemalloc_zone_from_ptrmalloc_zone_mallocmalloc_zone_vallocmalloc_zone_callocmalloc_zone_reallocmalloc_zone_freeproc_listpidsproc_listallpidsproc_listpgrppidsproc_listchildpidsproc_pidinfoproc_pidfdinfoproc_pidfileportinfoproc_pidpathproc_nameproc_regionfilenameproc_kmsgbufproc_libversionproc_pid_rusageproc_set_no_smtproc_setthread_no_smtproc_set_csmproc_setthread_csmgethostuuid/// `id` is of type [`uuid_t`].getentropy_NSGetExecutablePath// FIXME(1.0): should this actually be deprecated?_NSGetArgv// crt_externs.h_NSGetArgc_NSGetEnviron_NSGetPrognamemach_vm_mapvm_allocatevm_deallocatetask_for_pidtask_infotask_createtask_terminatetask_threadshost_statisticssysdir_start_search_path_enumeration// sysdir.hsysdir_get_next_search_path_enumerationgetattrlistfgetattrlistgetattrlistatsetattrlistfsetattrlistsetattrlistatgetattrlistbulkmalloc_sizemalloc_good_sizefreadlinkexecvP//! Apple (ios/darwin)-specific definitions//! This covers *-apple-* triples currently// sys/netinet/in.h// Protocols (RFC 1700)// supports multicast// connectx() flag parameters// These require a dependency on `libiconv`, and including this when built as// part of `std` means every Rust program gets it. Ideally we would have a link// modifier to only include these if they are used, but we do not.// DragonFlyBSD's __error function is declared with "static inline", so it must// be implemented in the libc crate, as a pointer to a static thread_local./* DIFF(main): module removed in de76fee6 */cpuset_tcpumask_tregister_tumtx_tvm_maptype_tvm_subsys_tvm_eflags_t__c_anonymous_vm_mapvm_map_entry_tvm_map_entrypmap__c_anonymous_pmapSIGCKPTSIGCKPTEXITCKPT_FREEZECKPT_THAWMADV_INVALMADV_SETMAPEASYNCRLIMIT_POSIXLOCKSCTL_P1003_1BCTL_LWKTKERN_USRSTACKKERN_IOV_MAXKERN_MAXPOSIXLOCKSPERUIDKERN_PROC_ARGSKERN_PROC_CWDKERN_PROC_PATHNAMEKERN_PROC_FLAGMASKKERN_PROC_FLAG_LWPHW_MACHINE_PLATFORMHW_SENSORSCTL_P1003_1B_ASYNCHRONOUS_IOCTL_P1003_1B_MAPPED_FILESCTL_P1003_1B_MEMLOCKCTL_P1003_1B_MEMLOCK_RANGECTL_P1003_1B_MEMORY_PROTECTIONCTL_P1003_1B_MESSAGE_PASSINGCTL_P1003_1B_PRIORITIZED_IOCTL_P1003_1B_PRIORITY_SCHEDULINGCTL_P1003_1B_REALTIME_SIGNALSCTL_P1003_1B_SEMAPHORESCTL_P1003_1B_FSYNCCTL_P1003_1B_SHARED_MEMORY_OBJECTSCTL_P1003_1B_SYNCHRONIZED_IOCTL_P1003_1B_TIMERSCTL_P1003_1B_AIO_LISTIO_MAXCTL_P1003_1B_AIO_MAXCTL_P1003_1B_AIO_PRIO_DELTA_MAXCTL_P1003_1B_DELAYTIMER_MAXCTL_P1003_1B_UNUSED1CTL_P1003_1B_PAGESIZECTL_P1003_1B_RTSIG_MAXCTL_P1003_1B_SEM_NSEMS_MAXCTL_P1003_1B_SEM_VALUE_MAXCTL_P1003_1B_SIGQUEUE_MAXCTL_P1003_1B_TIMER_MAXCTL_P1003_1B_MAXIDCPUCTL_RSMSRCPUCTL_WRMSRCPUCTL_CPUIDCPUCTL_UPDATECPUCTL_MSRSBITCPUCTL_MSRCBITCPUCTL_CPUID_COUNTEVFILT_EXCEPTEV_NODATAEV_HUPFIODNAMENOTE_OOBSO_SNDSPACESO_CPUHINTPROC_REAP_ACQUIREPROC_REAP_RELEASEPROC_REAP_STATUSPROC_PDEATHSIG_CTLPROC_PDEATHSIG_STATUS// https://github.com/DragonFlyBSD/DragonFlyBSD/blob/HEAD/sys/net/if.h#L101IFF_SMART// interface manages own routesIFF_OACTIVE_COMPAT// was transmission in progressIFF_POLLING_COMPAT// was interface is in polling modeIFF_PPROMISCIFF_MONITOR// user-requested promisc modeIFF_STATICARP// user-requested monitor modeIFF_NPOLLING// static ARPIFF_IDIRECT// interface is in polling mode/// gateway^2 (deprecated)IPPROTO_MOBILE/// IP MobilityIPPROTO_TLSP/// Transport Layer SecurityIPPROTO_SKIP/// SKIPIPPROTO_CARP/// CARPIPPROTO_PFSYNC/// PFSYNC/* BSD Private, local use, namespace incursion, no longer used */IPPROTO_UNKNOWN/// Used by RSS: the layer3 protocol is unknownTCP_SIGNATURE_ENABLE// sys/netinet/tcp.hTCP_KEEPINITTCP_FASTKEEPSOMAXOPT_SIZEMSG_UNUSED09MSG_SYNCMSG_FBLOCKINGMSG_FNONBLOCKINGMSG_FMASKMNT_TRIMMNT_USERMNT_IGNORE// utmpx entry typesDOWNTIMEUTX_DB_UTMPX// utmpx database typesUTX_DB_WTMPXUTX_DB_LASTLOGBTUARTDISCTIOCISPTMASTER// Constants used by "at" family of system calls.// invalid file descriptorVCHECKPTWTRAPPED// Similar to FreeBSD, only the standardized ones are exposed.// There are more.RTP_PRIO_REALTIME// Values for struct rtprio (type_ field)RTP_PRIO_NORMALRTP_PRIO_IDLERTP_PRIO_THREADUF_NOHISTORYUF_CACHEUF_XLINKSF_NOHISTORYSF_CACHESF_XLINK// timespec constantsMINCORE_SUPER// kinfo_proc constantsMAXLOGNAMERB_PAUSERB_VIDEORTF_MPLSOPSRTAX_MPLS1RTAX_MPLS2RTAX_MPLS3setutxdbaio_waitcompletedevname_rlwp_rtpriortpriosched_getcpusetproctitleprocctlupdwtmpxgetlastlogxlastlogxupdlastlogxgetutxusersys_checkpointumtx_sleepumtx_wakeupgetmntvinfoclosefromreallocffreezerokvm_vm_map_entry_firstkvm_vm_map_entry_next// DIFF(main): module removed in de76fee6// direct input_ALIGNBYTES// 1024 * 4__greg_t__gregset_tst_devst_inost_modest_nlinkst_uidst_gidst_rdevst_atimest_atime_nsecst_mtimest_mtime_nsecst_ctimest_ctime_nsecst_sizest_blocksst_blksizest_flagsfflags_tst_genst_lsparest_birthtimest_birthtime_nsec__unused// The type of `nlink_t` changed from `u16` to `u64` in FreeBSD 12:// Type of `dev_t` changed from `u32` to `u64` in FreeBSD 12:// Type of `ino_t` changed from `__uint32_t` to `__uint64_t` in FreeBSD 12:KI_NSPARE_PTRSPECNAMELEN/// max length of devicename// Return type c_int was removed in FreeBSD 12// Type of `addr` argument changed from `const void*` to `void*`// in FreeBSD 12// Return type c_int changed to ssize_t in FreeBSD 12:// Type of `path` argument changed from `const void*` to `void*`// APIs that were changed after FreeBSD 11// APIs in FreeBSD 12 that have changed since 11.PROC_KPTI_CTLPROC_KPTI_CTL_ENABLE_ON_EXECPROC_KPTI_CTL_DISABLE_ON_EXECPROC_KPTI_STATUSPROC_KPTI_STATUS_ACTIVEkpaddr_tkssize_tdomainset_t__c_anonymous_domainsetKF_TYPE_EVENTFDDOMAINSET_POLICY_INVALID/// domainset policiesDOMAINSET_POLICY_ROUNDROBINDOMAINSET_POLICY_FIRSTTOUCHDOMAINSET_POLICY_PREFERDOMAINSET_POLICY_INTERLEAVEcpuset_getdomaincpulevel_tcpuwhich_tcpuset_setdomainkvm_kerndisp// APIs in FreeBSD 13 that have changed since 11.// APIs in FreeBSD 14 that have changed since 11.PROC_LA_CTLPROC_LA_STATUSPROC_LA_CTL_LA48_ON_EXECPROC_LA_CTL_LA57_ON_EXECPROC_LA_CTL_DEFAULT_ON_EXECPROC_LA_STATUS_LA48PROC_LA_STATUS_LA57// APIs in FreeBSD 15 that have changed since 11.kvaddr_t__fixpt_t__lwpid_t_sem__c_anonymous__timer__c_anonymous_pthread_spinlock__c_anonymous_pthread_barrierattr__c_anonymous_pthread_barrierfhandle_tfhandleau_id_tau_asid_tcpusetid_teventfd_tdevstat_support_flagsDEVSTAT_ALL_SUPPORTEDDEVSTAT_NO_BLOCKSIZEDEVSTAT_NO_ORDERED_TAGSDEVSTAT_BS_UNAVAILABLEdevstat_trans_flagsDEVSTAT_NO_DATADEVSTAT_READDEVSTAT_WRITEDEVSTAT_FREEdevstat_tag_typeDEVSTAT_TAG_SIMPLEDEVSTAT_TAG_HEADDEVSTAT_TAG_ORDEREDDEVSTAT_TAG_NONEdevstat_match_flagsDEVSTAT_MATCH_NONEDEVSTAT_MATCH_TYPEDEVSTAT_MATCH_IFDEVSTAT_MATCH_PASSdevstat_priority0x000DEVSTAT_PRIORITY_MIN0x020DEVSTAT_PRIORITY_OTHER0x030DEVSTAT_PRIORITY_PASS0x040DEVSTAT_PRIORITY_FD0x050DEVSTAT_PRIORITY_WFD0x060DEVSTAT_PRIORITY_TAPE0x090DEVSTAT_PRIORITY_CD0x110DEVSTAT_PRIORITY_DISK0x120DEVSTAT_PRIORITY_ARRAY0xfffDEVSTAT_PRIORITY_MAXdevstat_type_flagsDEVSTAT_TYPE_DIRECT0x001DEVSTAT_TYPE_SEQUENTIAL0x002DEVSTAT_TYPE_PRINTER0x003DEVSTAT_TYPE_PROCESSOR0x004DEVSTAT_TYPE_WORM0x005DEVSTAT_TYPE_CDROM0x006DEVSTAT_TYPE_SCANNER0x007DEVSTAT_TYPE_OPTICAL0x008DEVSTAT_TYPE_CHANGER0x009DEVSTAT_TYPE_COMM0x00aDEVSTAT_TYPE_ASC00x00bDEVSTAT_TYPE_ASC10x00cDEVSTAT_TYPE_STORARRAY0x00dDEVSTAT_TYPE_ENCLOSURE0x00eDEVSTAT_TYPE_FLOPPY0x00fDEVSTAT_TYPE_MASK0x010DEVSTAT_TYPE_IF_SCSIDEVSTAT_TYPE_IF_IDEDEVSTAT_TYPE_IF_OTHER0x0f0DEVSTAT_TYPE_IF_MASKDEVSTAT_TYPE_PASSdevstat_metricDSM_NONEDSM_TOTAL_BYTESDSM_TOTAL_BYTES_READDSM_TOTAL_BYTES_WRITEDSM_TOTAL_TRANSFERSDSM_TOTAL_TRANSFERS_READDSM_TOTAL_TRANSFERS_WRITEDSM_TOTAL_TRANSFERS_OTHERDSM_TOTAL_BLOCKSDSM_TOTAL_BLOCKS_READDSM_TOTAL_BLOCKS_WRITEDSM_KB_PER_TRANSFERDSM_KB_PER_TRANSFER_READDSM_KB_PER_TRANSFER_WRITEDSM_TRANSFERS_PER_SECONDDSM_TRANSFERS_PER_SECOND_READDSM_TRANSFERS_PER_SECOND_WRITEDSM_TRANSFERS_PER_SECOND_OTHERDSM_MB_PER_SECONDDSM_MB_PER_SECOND_READDSM_MB_PER_SECOND_WRITEDSM_BLOCKS_PER_SECONDDSM_BLOCKS_PER_SECOND_READDSM_BLOCKS_PER_SECOND_WRITEDSM_MS_PER_TRANSACTIONDSM_MS_PER_TRANSACTION_READDSM_MS_PER_TRANSACTION_WRITEDSM_SKIPDSM_TOTAL_BYTES_FREEDSM_TOTAL_TRANSFERS_FREEDSM_TOTAL_BLOCKS_FREEDSM_KB_PER_TRANSFER_FREEDSM_MB_PER_SECOND_FREEDSM_TRANSFERS_PER_SECOND_FREEDSM_BLOCKS_PER_SECOND_FREEDSM_MS_PER_TRANSACTION_OTHERDSM_MS_PER_TRANSACTION_FREEDSM_BUSY_PCTDSM_QUEUE_LENGTHDSM_TOTAL_DURATIONDSM_TOTAL_DURATION_READDSM_TOTAL_DURATION_WRITEDSM_TOTAL_DURATION_FREEDSM_TOTAL_DURATION_OTHERDSM_TOTAL_BUSY_TIMEDSM_MAXdevstat_select_modeDS_SELECT_ADDDS_SELECT_ONLYDS_SELECT_REMOVEDS_SELECT_ADDONLYdot3Vendorsdot3VendorAMDdot3VendorInteldot3VendorNationaldot3VendorFujitsudot3VendorDigitaldot3VendorWesternDigitalLIO_VECTORED// aio.hLIO_WRITEVLIO_READVCAP_RIGHTS_VERSION_00// sys/caprights.hCAP_RIGHTS_VERSIONcap_right// sys/capsicum.hCAP_READCAP_WRITECAP_SEEK_TELLCAP_SEEKCAP_PREADCAP_PWRITECAP_MMAPCAP_MMAP_RCAP_MMAP_WCAP_MMAP_XCAP_MMAP_RWCAP_MMAP_RXCAP_MMAP_WXCAP_MMAP_RWXCAP_CREATECAP_FEXECVECAP_FSYNCCAP_FTRUNCATECAP_LOOKUPCAP_FCHDIRCAP_FCHFLAGSCAP_CHFLAGSATCAP_FCHMODCAP_FCHMODATCAP_FCHOWNCAP_FCHOWNATCAP_FCNTLCAP_FLOCKCAP_FPATHCONFCAP_FSCKCAP_FSTATCAP_FSTATATCAP_FSTATFSCAP_FUTIMESCAP_FUTIMESATCAP_LINKAT_TARGET// Note: this was named CAP_LINKAT prior to FreeBSD 11.0.CAP_MKDIRATCAP_MKFIFOATCAP_MKNODATCAP_RENAMEAT_SOURCE// Note: this was named CAP_RENAMEAT prior to FreeBSD 11.0.CAP_SYMLINKATCAP_UNLINKATCAP_ACCEPTCAP_BINDCAP_CONNECTCAP_GETPEERNAMECAP_GETSOCKNAMECAP_GETSOCKOPTCAP_LISTENCAP_PEELOFFCAP_RECVCAP_SENDCAP_SETSOCKOPTCAP_SHUTDOWNCAP_BINDATCAP_CONNECTATCAP_LINKAT_SOURCECAP_RENAMEAT_TARGETCAP_SOCK_CLIENTCAP_SOCK_SERVERCAP_ALL0CAP_UNUSED0_44CAP_UNUSED0_57CAP_MAC_GETCAP_MAC_SETCAP_SEM_GETVALUECAP_SEM_POSTCAP_SEM_WAITCAP_EVENTCAP_KQUEUE_EVENTCAP_IOCTLCAP_TTYHOOKCAP_PDGETPIDCAP_PDWAITCAP_PDKILLCAP_EXTATTR_DELETECAP_EXTATTR_GETCAP_EXTATTR_LISTCAP_EXTATTR_SETCAP_ACL_CHECKCAP_ACL_DELETECAP_ACL_GETCAP_ACL_SETCAP_KQUEUE_CHANGECAP_KQUEUECAP_ALL1CAP_UNUSED1_22CAP_UNUSED1_57CAP_FCNTL_GETFLCAP_FCNTL_SETFLCAP_FCNTL_GETOWNCAP_FCNTL_SETOWNDEVSTAT_N_TRANS_FLAGS// sys/devicestat.hDEVSTAT_NAME_LEN// sys/cpuset.hSIGEV_THREAD_IDEXTATTR_NAMESPACE_EMPTYEXTATTR_NAMESPACE_USEREXTATTR_NAMESPACE_SYSTEMPTHREAD_MUTEX_ADAPTIVE_NPSF_NODISKIOSF_MNOWAITSF_SYNCSF_USER_READAHEADSF_NOCACHEO_EMPTY_PATHO_RESOLVE_BENEATHO_VERIFYENOTCAPABLEECAPMODEEINTEGRITYRLIMIT_NPTSRLIMIT_SWAPRLIMIT_KQUEUESRLIMIT_UMTXPCP_USERCP_NICECP_SYSCP_INTRCP_IDLEXU_NGROUPSMAP_GUARDMAP_EXCLMAP_PREFAULT_READMAP_ALIGNMENT_SHIFTMAP_ALIGNMENT_MASKMAP_ALIGNED_SUPERPOLLINIGNEOFEVFILT_PROCDESCEVFILT_LIOEVFILT_SENDFILEEVFILT_EMPTYEV_FORCEONESHOTEV_KEEPUDATAEV_DROPEV_FLAG2NOTE_FILE_POLLNOTE_OPENNOTE_CLOSENOTE_CLOSE_WRITENOTE_READNOTE_MSECONDSNOTE_ABSTIMEMADV_PROTECTCTL_SYSCTLCTL_MAXNAME// sys/sysctl.hCTLTYPE_S64CTLTYPE_UINTCTLTYPE_LONGCTLTYPE_ULONGCTLTYPE_U64CTLTYPE_U8CTLTYPE_U16CTLTYPE_S8CTLTYPE_S16CTLTYPE_S32CTLTYPE_U32CTLFLAG_DORMANTCTLFLAG_PRISONCTLFLAG_DYNCTLFLAG_SKIPCTLMASK_SECURECTLFLAG_TUNCTLFLAG_RDTUNCTLFLAG_RWTUNCTLFLAG_MPSAFECTLFLAG_VNETCTLFLAG_DYINGCTLFLAG_CAPRDCTLFLAG_CAPWRCTLFLAG_STATSCTLFLAG_NOFETCHCTLFLAG_CAPRWCTLFLAG_NEEDGIANTCTLSHIFT_SECURECTLFLAG_SECURE1CTLFLAG_SECURE2CTLFLAG_SECURE3OID_AUTOCTL_SYSCTL_DEBUGCTL_SYSCTL_NAMECTL_SYSCTL_NEXTCTL_SYSCTL_NAME2OIDCTL_SYSCTL_OIDFMTCTL_SYSCTL_OIDDESCRCTL_SYSCTL_OIDLABELCTL_SYSCTL_NEXTNOSKIPKERN_HOSTUUIDKERN_ARNDKERN_MAXPHYSKERN_PROC_PROCKERN_PROC_SV_NAMEKERN_PROC_RGIDKERN_PROC_GIDKERN_PROC_OVMMAPKERN_PROC_OFILEDESCKERN_PROC_KSTACKKERN_PROC_INC_THREADKERN_PROC_VMMAPKERN_PROC_FILEDESCKERN_PROC_GROUPSKERN_PROC_ENVKERN_PROC_AUXVKERN_PROC_RLIMITKERN_PROC_PS_STRINGSKERN_PROC_UMASKKERN_PROC_OSRELKERN_PROC_SIGTRAMPKERN_PROC_NFDSKERN_PROC_SIGFASTBLKHW_REALMEMUSER_LOCALBASECTL_P1003_1B_MQ_OPEN_MAXTIOCGPTNTIOCPTMASTERTIOCM_DCDH4DISCVM_TOTALFIONWRITEFIONSPACEFIOSEEKDATAFIOSEEKHOLEFIOSSHMLPGCNFJAIL_API_VERSIONJAIL_CREATEJAIL_UPDATEJAIL_ATTACHJAIL_DYINGJAIL_SET_MASKJAIL_GET_MASKJAIL_SYS_DISABLEJAIL_SYS_NEWJAIL_SYS_INHERITMNT_ACLSMNT_BYFSIDMNT_GJOURNALMNT_NFS4ACLSMNT_NONBUSYSCM_BINTIMESCM_REALTIMESCM_MONOTONICSCM_TIME_INFOSCM_CREDS2SO_BINTIMESO_NO_OFFLOADSO_NO_DDPSO_REUSEPORT_LBSO_LISTENQLIMITSO_LISTENQLENSO_LISTENINCQLENSO_SETFIBSO_USER_COOKIESO_PROTOTYPESO_TS_CLOCKSO_VENDORSO_TS_REALTIME_MICROSO_TS_BINTIMESO_TS_REALTIMESO_TS_MONOTONICSO_TS_DEFAULTSO_TS_CLOCK_MAXLOCAL_CREDSLOCAL_CREDS_PERSISTENTLOCAL_CONNWAITLOCAL_VENDORPL_EVENT_NONEPL_EVENT_SIGNALPL_FLAG_SAPL_FLAG_BOUNDPL_FLAG_SCEPL_FLAG_SCXPL_FLAG_EXECPL_FLAG_SIPL_FLAG_FORKEDPL_FLAG_CHILDPL_FLAG_BORNPL_FLAG_EXITEDPL_FLAG_VFORKEDPL_FLAG_VFORK_DONEPT_LWPINFOPT_GETNUMLWPSPT_GETLWPLISTPT_CLEARSTEPPT_SETSTEPPT_SUSPENDPT_RESUMEPT_TO_SCEPT_TO_SCXPT_SYSCALLPT_FOLLOW_FORKPT_LWP_EVENTSPT_GET_EVENT_MASKPT_SET_EVENT_MASKPT_GET_SC_ARGSPT_GET_SC_RETPT_COREDUMPPT_GETREGSPT_SETREGSPT_GETFPREGSPT_SETFPREGSPT_GETDBREGSPT_SETDBREGSPT_VM_TIMESTAMPPT_VM_ENTRYPT_GETREGSETPT_SETREGSETPT_SC_REMOTEPTRACE_EXECPTRACE_SCEPTRACE_SCXPTRACE_FORKPTRACE_LWPPTRACE_VFORKPTRACE_DEFAULTPC_COMPRESSPC_ALLPROC_SPROTECTPROC_REAP_GETPIDSPROC_REAP_KILLPROC_TRACE_CTLPROC_TRACE_STATUSPROC_TRAPCAP_CTLPROC_TRAPCAP_STATUSPROC_ASLR_CTLPROC_ASLR_STATUSPROC_PROTMAX_CTLPROC_PROTMAX_STATUSPROC_STACKGAP_CTLPROC_STACKGAP_STATUSPROC_NO_NEW_PRIVS_CTLPROC_NO_NEW_PRIVS_STATUSPROC_WXMAP_CTLPROC_WXMAP_STATUSPROC_PROCCTL_MD_MINPPROT_SETPPROT_CLEARPPROT_DESCENDPPROT_INHERITPROC_TRACE_CTL_ENABLEPROC_TRACE_CTL_DISABLEPROC_TRACE_CTL_DISABLE_EXECPROC_TRAPCAP_CTL_ENABLEPROC_TRAPCAP_CTL_DISABLEPROC_ASLR_FORCE_ENABLEPROC_ASLR_FORCE_DISABLEPROC_ASLR_NOFORCEPROC_ASLR_ACTIVEPROC_PROTMAX_FORCE_ENABLEPROC_PROTMAX_FORCE_DISABLEPROC_PROTMAX_NOFORCEPROC_PROTMAX_ACTIVEPROC_STACKGAP_ENABLEPROC_STACKGAP_DISABLEPROC_STACKGAP_ENABLE_EXECPROC_STACKGAP_DISABLE_EXECPROC_NO_NEW_PRIVS_ENABLEPROC_NO_NEW_PRIVS_DISABLEPROC_WX_MAPPINGS_PERMITPROC_WX_MAPPINGS_DISALLOW_EXECPROC_WXORX_ENFORCEAF_SLOWAF_SCLUSTERAF_ARPAF_INET_SDPAF_INET6_SDPIF_MAXUNIT// sys/net/if.h/// (n) interface is up/// (i) broadcast address valid/// (n) turn on debugging/// (i) is a loopback net/// (i) is a point-to-point linkIFF_KNOWSEPOCH/// (i) calls if_input in net epoch/// (d) resources allocatedIFF_DRV_RUNNING/// (d) resources allocate/// (n) no address resolution protocol/// (n) receive all packets/// (n) receive all multicast packets/// (d) tx hardware queue is fullIFF_DRV_OACTIVE/// (i) can't hear own transmissions/// per link layer defined bit/// use alternate physical connection/// (i) supports multicastIFF_CANTCONFIG/// (i) unconfigurable using ioctl(2)/// (n) user-requested promisc mode/// (n) user-requested monitor mode/// (n) static ARPIFF_DYING/// (n) interface is winding downIFF_RENAMING/// (n) interface is being renamedIFF_NOGROUP/// interface is not part of any groupsLINK_STATE_UNKNOWN/// link invalid/unknownLINK_STATE_DOWN/// link is downLINK_STATE_UP/// link is upIFCAP_RXCSUM/// can offload checksum on RXIFCAP_TXCSUM/// can offload checksum on TXIFCAP_NETCONS/// can be a network consoleIFCAP_VLAN_MTU/// VLAN-compatible MTUIFCAP_VLAN_HWTAGGING/// hardware VLAN tag supportIFCAP_JUMBO_MTU/// 9000 byte MTU supportedIFCAP_POLLING/// driver supports pollingIFCAP_VLAN_HWCSUM/// can do IFCAP_HWCSUM on VLANsIFCAP_TSO4/// can do TCP Segmentation OffloadIFCAP_TSO6/// can do TCP6 Segmentation OffloadIFCAP_LRO/// can do Large Receive OffloadIFCAP_WOL_UCAST/// wake on any unicast frameIFCAP_WOL_MCAST/// wake on any multicast frameIFCAP_WOL_MAGIC/// wake on any Magic PacketIFCAP_TOE4/// interface can offload TCPIFCAP_TOE6/// interface can offload TCP6IFCAP_VLAN_HWFILTER/// interface hw can filter vlan tagIFCAP_NV/// can do SIOCGIFCAPNV/SIOCSIFCAPNVIFCAP_VLAN_HWTSO/// can do IFCAP_TSO on VLANsIFCAP_LINKSTATE/// the runtime link state is dynamicIFCAP_NETMAP/// netmap mode supported/enabledIFCAP_RXCSUM_IPV6/// can offload checksum on IPv6 RXIFCAP_TXCSUM_IPV6/// can offload checksum on IPv6 TXIFCAP_HWSTATS/// manages counters internallyIFCAP_TXRTLMT/// hardware supports TX rate limitingIFCAP_HWRXTSTMP/// hardware rx timestampingIFCAP_MEXTPG/// understands M_EXTPG mbufsIFCAP_TXTLS4/// can do TLS encryption and segmentation for TCPIFCAP_TXTLS6/// can do TLS encryption and segmentation for TCP6IFCAP_VXLAN_HWCSUM/// can do IFCAN_HWCSUM on VXLANsIFCAP_VXLAN_HWTSO/// can do IFCAP_TSO on VXLANsIFCAP_TXTLS_RTLMT/// can do TLS with rate limitingIFCAP_HWCSUM_IPV6IFCAP_HWCSUMIFCAP_TSOIFCAP_WOLIFCAP_TOEIFCAP_TXTLSIFCAP_CANTCHANGEIFAN_ARRIVALIFAN_DEPARTUREIFSTATMAXRSS_FUNC_NONERSS_FUNC_PRIVATERSS_FUNC_TOEPLITZRSS_TYPE_IPV4RSS_TYPE_TCP_IPV4RSS_TYPE_IPV6RSS_TYPE_IPV6_EXRSS_TYPE_TCP_IPV6RSS_TYPE_TCP_IPV6_EXRSS_TYPE_UDP_IPV4RSS_TYPE_UDP_IPV6RSS_TYPE_UDP_IPV6_EXRSS_KEYLENIFNET_PCP_NONEIFDR_MSG_SIZEIFDR_REASON_MSGIFDR_REASON_VENDOR/// non-interface-specific/// per-interface data table/// generic stats for all kinds of ifaces/// specific to the type of interfaceIFDATA_DRIVERNAME/// driver name and unit/// number of interfaces configured/// functions not specific to a type of ifacedot3ChipSetAMD7990dot3ChipSetAMD79900dot3ChipSetAMD79C940dot3ChipSetIntel82586dot3ChipSetIntel82596dot3ChipSetIntel82557dot3ChipSetNational8390dot3ChipSetNationalSonicdot3ChipSetFujitsu86950dot3ChipSetDigitalDC21040dot3ChipSetDigitalDC21140dot3ChipSetDigitalDC21041dot3ChipSetDigitalDC21140Adot3ChipSetDigitalDC21142dot3ChipSetWesternDigital83C690dot3ChipSetWesternDigital83C790/// Datagram Congestion Control Protocol/// IPv6 Mobility Header/// UDP-LiteIPPROTO_HIP/// IP6 Host Identity ProtocolIPPROTO_SHIM6/// IP6 Shim6 Protocol/// MPLS-in-IPIPPROTO_OLD_DIVERT/// OLD divert pseudo-proto/* Only used internally, so can be outside the range of valid IP protocols. */IPPROTO_SEND/// SeND pseudo-protocol// sys/netinet/TCP.hTCP_CCALGOOPTTCP_MAXUNACKTIMETCP_MAXPEAKRATETCP_IDLE_REDUCETCP_REMOTE_UDP_ENCAPS_PORTTCP_DELACKTCP_FIN_IS_RSTTCP_LOG_LIMITTCP_SHARED_CWND_ALLOWEDTCP_PROC_ACCOUNTINGTCP_USE_CMP_ACKSTCP_PERF_INFOTCP_LRDTCP_PCAP_OUTTCP_PCAP_INTCP_FUNCTION_BLKTCP_FUNCTION_ALIASTCP_FASTOPEN_PSK_LENTCP_FUNCTION_NAME_LEN_MAXTCP_REUSPORT_LB_NUMATCP_RACK_MBUF_QUEUETCP_RACK_TLP_REDUCETCP_RACK_PACE_MAX_SEGTCP_RACK_PACE_ALWAYSTCP_RACK_PRR_SENDALOTTCP_RACK_MIN_TOTCP_RACK_EARLY_SEGTCP_RACK_REORD_THRESHTCP_RACK_REORD_FADETCP_RACK_TLP_THRESHTCP_RACK_PKT_DELAYTCP_BBR_IWINTSOTCP_BBR_STARTUP_PGTCP_BBR_DRAIN_PGTCP_BBR_PROBE_RTT_INTTCP_BBR_STARTUP_LOSS_EXITTCP_BBR_TSLIMITSTCP_BBR_PACE_OHTCP_BBR_USEDEL_RATETCP_BBR_MIN_RTOTCP_BBR_MAX_RTOTCP_BBR_ALGORITHMIP_BINDANYIP_BINDMULTIIP_RSS_LISTEN_BUCKETIP_ORIGDSTADDRIP_RECVORIGDSTADDRIPV6_BINDANYIPV6_ORIGDSTADDRIPV6_RECVORIGDSTADDRPF_SLOWPF_SCLUSTERPF_ARPPF_IEEE80211PF_INET_SDPPF_INET6_SDPNET_RT_IFMALISTNET_RT_IFLISTLSHM_STATSHM_INFOSHM_ANON// The *_MAXID constants never should've been used outside of the// FreeBSD base system.  And with the exception of CTL_P1003_1B_MAXID,// they were all removed in svn r262489.  They remain here for backwards// compatibility only, and are scheduled to be removed in libc 1.0.0.MSG_NOTIFICATIONMSG_NBIOUTXDB_ACTIVE// utmp database typesUTXDB_LASTLOGINUTXDB_LOG// same as WUNTRACED// FreeBSD defines a great many more of these, we only expose the// standardized ones.AT_RESOLVE_BENEATHAT_NULLAT_IGNOREAT_EXECFDAT_PHDRAT_PHENTAT_PHNUMAT_BASEAT_ENTRYAT_NOTELFAT_EUIDAT_EGIDAT_EXECPATHAT_CANARYAT_OSRELDATEAT_NCPUSAT_PAGESIZESAT_TIMEKEEPAT_HWCAPAT_HWCAP2AT_USRSTACKBASEAT_USRSTACKLIM_PC_ACL_NFS4_SC_CPUSET_SIZE_UUID_NODE_LENPD_DAEMON// Flags which can be passed to pdfork(2)PD_CLOEXECPD_ALLOWED_AT_FORKUF_SPARSEUF_OFFLINEUF_REPARSEUF_ARCHIVEUF_READONLYSF_SNAPSHOT// fcntl commandsF_OGETLKF_OSETLKF_OSETLKWF_READAHEADF_SETLK_REMOTEF_KINFO// for use with F_ADD_SEALSSPACECTL_DEALLOC// for use with fspacectlHOSTNAME_FOUND// For realhostname* apiHOSTNAME_INCORRECTNAMEHOSTNAME_INVALIDADDRHOSTNAME_INVALIDNAMERFFDG// For rforkRFPROCRFMEMRFNOWAITRFCFDGRFTHREADRFSIGSHARERFLINUXTHPNRFTSIGZMBRFSPAWN// For eventfdMALLOCX_ZEROWMESGLEN/// size of returned wchan messageLOCKNAMELEN/// size of returned lock nameTDNAMLEN/// size of returned thread nameCOMMLEN/// size of returned ki_comm nameKI_EMULNAMELEN/// size of returned ki_emulKI_NGROUPS/// number of groups in ki_groupsKI_NSPARE_LONGKI_CRF_CAPABILITY_MODE/// Flags for the process credential.KI_CRF_GRP_OVERFLOW/// Steal a bit from ki_cr_flags to indicate that the cred had more than/// KI_NGROUPS groups.KI_CTTY/// controlling tty vnode activeKI_SLEADER/// session leaderKI_LOCKBLOCK/// proc blocked on lock ki_locknameLOGNAMELEN/// size of returned ki_loginLOGINCLASSLEN/// size of returned ki_loginclassKF_ATTR_VALIDKF_TYPE_NONEKF_TYPE_VNODEKF_TYPE_SOCKETKF_TYPE_PIPEKF_TYPE_FIFOKF_TYPE_KQUEUEKF_TYPE_MQUEUEKF_TYPE_SHMKF_TYPE_SEMKF_TYPE_PTSKF_TYPE_PROCDESCKF_TYPE_DEVKF_TYPE_UNKNOWNKF_VTYPE_VNONKF_VTYPE_VREGKF_VTYPE_VDIRKF_VTYPE_VBLKKF_VTYPE_VCHRKF_VTYPE_VLNKKF_VTYPE_VSOCKKF_VTYPE_VFIFOKF_VTYPE_VBADKF_VTYPE_UNKNOWNKF_FD_TYPE_CWD/// Current working directoryKF_FD_TYPE_ROOT/// Root directoryKF_FD_TYPE_JAIL/// Jail directoryKF_FD_TYPE_TRACE/// Ktrace vnodeKF_FD_TYPE_TEXTKF_FD_TYPE_CTTY/// Controlling terminalKF_FLAG_READKF_FLAG_WRITEKF_FLAG_APPENDKF_FLAG_ASYNCKF_FLAG_FSYNCKF_FLAG_NONBLOCKKF_FLAG_DIRECTKF_FLAG_HASLOCKKF_FLAG_SHLOCKKF_FLAG_EXLOCKKF_FLAG_NOFOLLOWKF_FLAG_CREATKF_FLAG_TRUNCKF_FLAG_EXCLKF_FLAG_EXECKVME_TYPE_NONEKVME_TYPE_DEFAULTKVME_TYPE_VNODEKVME_TYPE_SWAPKVME_TYPE_DEVICEKVME_TYPE_PHYSKVME_TYPE_DEADKVME_TYPE_SGKVME_TYPE_MGTDEVICEKVME_TYPE_UNKNOWN// Present in `sys/user.h` but is undefined for whatever reason...// pub const KVME_TYPE_GUARD: c_int = 9;KVME_PROT_READKVME_PROT_WRITEKVME_PROT_EXECKVME_FLAG_COWKVME_FLAG_NEEDS_COPYKVME_FLAG_NOCOREDUMPKVME_FLAG_SUPERKVME_FLAG_GROWS_UPKVME_FLAG_GROWS_DOWNKVME_FLAG_USER_WIREDKKST_MAXLENKKST_STATE_STACKOK/// Stack is valid.KKST_STATE_SWAPPED/// Stack swapped out.KKST_STATE_RUNNINGPRI_MIN// Constants about priority.PRI_MAXPRI_MIN_ITHDPRI_MAX_ITHDPI_REALTIMEPI_AVPI_NETPI_DISKPI_TTYPI_DULLPI_SOFTPRI_MIN_REALTIMEPRI_MAX_REALTIMEPRI_MIN_KERNPRI_MAX_KERNPSWPPVMPINODPRIBIOPVFSPZEROPSOCKPWAITPLOCKPPAUSEPRI_MIN_TIMESHAREPRI_MAX_TIMESHAREPUSERPRI_MIN_IDLEPRI_MAX_IDLE// Resource utilization information./// max command name rememberedMAXINTERP/// max interpreter file name length/// max login name length (incl. NUL)/// max simultaneous processesNCARGS/// max bytes for an exec function///  /* max number groups/// max open files per processNOGROUP/// marker for empty group set member/// max hostname size/// max bytes in term canon input line/// max bytes in terminal inputNAME_MAX/// max bytes in a file name/// max supplemental group id's_POSIX_ARG_MAX_POSIX_LINK_MAX_POSIX_MAX_CANON_POSIX_MAX_INPUT_POSIX_NAME_MAX_POSIX_PIPE_BUF_POSIX_SSIZE_MAX_POSIX_STREAM_MAX/// max ibase/obase values in bc(1)/// max array elements in bc(1)/// max scale value in bc(1)/// max const string length in bc(1)/// max character class name size/// max weights for order keyword/// max expressions nested in expr(1)LINE_MAX/// max bytes in an input lineRE_DUP_MAX/// max RE's in interval notation_POSIX2_BC_BASE_MAX_POSIX2_BC_DIM_MAX_POSIX2_BC_SCALE_MAX_POSIX2_BC_STRING_MAX_POSIX2_CHARCLASS_NAME_MAX_POSIX2_COLL_WEIGHTS_MAX_POSIX2_EQUIV_CLASS_MAX_POSIX2_EXPR_NEST_MAX_POSIX2_LINE_MAX_POSIX2_RE_DUP_MAXTDF_BORROWING// sys/proc.hTDF_INPANICTDF_INMEMTDF_SINTRTDF_TIMEOUTTDF_IDLETDTDF_CANSWAPTDF_KTH_SUSPTDF_ALLPROCSUSPTDF_BOUNDARYTDF_ASTPENDINGTDF_SBDRYTDF_UPIBLOCKEDTDF_NEEDSUSPCHKTDF_NEEDRESCHEDTDF_NEEDSIGCHKTDF_NOLOADTDF_SERESTARTTDF_THRWAKEUPTDF_SEINTRTDF_SWAPINREQTDF_UNUSED23TDF_SCHED0TDF_SCHED1TDF_SCHED2TDF_SCHED3TDF_ALRMPENDTDF_PROFPENDTDF_MACPENDTDB_SUSPENDTDB_XSIGTDB_USERWRTDB_SCETDB_SCXTDB_EXECTDB_FORKTDB_STOPATFORKTDB_CHILDTDB_BORNTDB_EXITTDB_VFORKTDB_FSTPTDB_STEPTDP_OLDMASKTDP_INKTRTDP_INKTRACETDP_BUFNEEDTDP_COWINPROGRESSTDP_ALTSTACKTDP_DEADLKTREATTDP_NOFAULTINGTDP_OWEUPCTDP_ITHREADTDP_SYNCIOTDP_SCHED1TDP_SCHED2TDP_SCHED3TDP_SCHED4TDP_GEOMTDP_SOFTDEPTDP_NORUNNINGBUFTDP_WAKEUPTDP_INBDFLUSHTDP_KTHREADTDP_CALLCHAINTDP_IGNSUSPTDP_AUDITRECTDP_RFPPWAITTDP_RESETSPURTDP_NERRNOTDP_EXECVMSPCTDI_SUSPENDEDTDI_SLEEPINGTDI_SWAPPEDTDI_LOCKTDI_IWAITP_ADVLOCKP_CONTROLTP_KPROCP_UNUSED3P_PPWAITP_PROFILP_STOPPROFP_HADTHREADSP_SUGIDP_SYSTEMP_SINGLE_EXITP_TRACEDP_WAITEDP_WEXITP_EXECP_WKILLEDP_CONTINUEDP_STOPPED_SIGP_STOPPED_TRACEP_STOPPED_SINGLEP_PROTECTEDP_SIGEVENTP_SINGLE_BOUNDARYP_HWPMCP_JAILEDP_TOTAL_STOPP_INEXECP_STATCHILDP_INMEMP_SWAPPINGOUTP_SWAPPINGINP_PPTRACEP_STOPPEDP2_INHERIT_PROTECTEDP2_NOTRACEP2_NOTRACE_EXECP2_AST_SUP2_PTRACE_FSTPP2_TRAPCAPP2_STKGAP_DISABLEP2_STKGAP_DISABLE_EXECP_TREE_ORPHANEDP_TREE_FIRST_ORPHANP_TREE_REAPERSWAITSLOCKP_MAGICTDP_SIGFASTBLOCKTDP_UIOHELDTDP_SIGFASTPENDINGTDP2_COMPAT32RBP2_PROTMAX_ENABLEP2_PROTMAX_DISABLETDP2_SBPAGESP2_ASLR_ENABLEP2_ASLR_DISABLEP2_ASLR_IGNSTARTP_TREE_GRPEXITEDPS_FST_VTYPE_VNON// libprocstat.hPS_FST_VTYPE_VREGPS_FST_VTYPE_VDIRPS_FST_VTYPE_VBLKPS_FST_VTYPE_VCHRPS_FST_VTYPE_VLNKPS_FST_VTYPE_VSOCKPS_FST_VTYPE_VFIFOPS_FST_VTYPE_VBADPS_FST_VTYPE_UNKNOWNPS_FST_TYPE_VNODEPS_FST_TYPE_FIFOPS_FST_TYPE_SOCKETPS_FST_TYPE_PIPEPS_FST_TYPE_PTSPS_FST_TYPE_KQUEUEPS_FST_TYPE_MQUEUEPS_FST_TYPE_SHMPS_FST_TYPE_SEMPS_FST_TYPE_UNKNOWNPS_FST_TYPE_NONEPS_FST_TYPE_PROCDESCPS_FST_TYPE_DEVPS_FST_TYPE_EVENTFDPS_FST_UFLAG_RDIRPS_FST_UFLAG_CDIRPS_FST_UFLAG_JAILPS_FST_UFLAG_TRACEPS_FST_UFLAG_TEXTPS_FST_UFLAG_MMAPPS_FST_UFLAG_CTTYPS_FST_FFLAG_READPS_FST_FFLAG_WRITEPS_FST_FFLAG_NONBLOCKPS_FST_FFLAG_APPENDPS_FST_FFLAG_SHLOCKPS_FST_FFLAG_EXLOCKPS_FST_FFLAG_ASYNCPS_FST_FFLAG_SYNCPS_FST_FFLAG_NOFOLLOWPS_FST_FFLAG_CREATPS_FST_FFLAG_TRUNCPS_FST_FFLAG_EXCLPS_FST_FFLAG_DIRECTPS_FST_FFLAG_EXECPS_FST_FFLAG_HASLOCKMAXFIDSZ/// File identifier./// These are unique per filesystem on a single machine./// Note that the offset of fid_data is 4 bytes, so care must be taken to avoid/// undefined behavior accessing unaligned fields within an embedded struct.MFSNAMELEN/// Length of type name including null.MNT_SUJ/// Using journaled soft updates./// Mounted by automountd(8).MNT_UNTRUSTED/// Filesys metadata untrusted.MNT_EXTLS/// Require TLS.MNT_EXTLSCERT/// Require TLS with client cert.MNT_EXTLSCERTUSER/// Require TLS with user cert./// Filesystem is stored locally./// Quotas are enabled on fs./// Identifies the root fs./// Mounted by a user./// Do not show entry in df.MNT_VERIFIED/// Filesystem is verified.MNT_NOCOVER/// Do not cover a mount point.MNT_EMPTYDIR/// Only mount on empty dir.MNT_RECURSE/// Recursively unmount uppers.MNT_DEFERRED/// Unmount in async context.VFS_VFSCONF/// Get configured filesystems.VFS_GENERIC/// Generic filesystem information.VFS_MAXTYPENUM/// int: highest defined filesystem type.VFS_CONF/// struct: vfsconf for filesystem given as next argument./// Synchronously wait for I/O to complete./// Start all I/O, but do not wait for it.MNT_LAZY/// Push data not written by filesystem syncer.MNT_SUSPEND/// Suspend file system after sync.MAXSECFLAVORSVFCF_STATIC/// Statically compiled into kernel.VFCF_NETWORK/// May get data over the network.VFCF_READONLY/// Writes are not implemented.VFCF_SYNTHETIC/// Data does not represent real files.VFCF_LOOPBACK/// Aliases some other mounted FS.VFCF_UNICODE/// Stores file names as Unicode.VFCF_JAIL/// Can be mounted from within a jail.VFCF_DELEGADMIN/// Supports delegated administration.VFCF_SBDRY/// Stop at Boundary: defer stop requests to kernel->user (AST) transition./// not on dst/// USA style dst/// Australian style dst/// Western European dst/// Middle European dst/// Eastern European dst/// CanadaCPUCLOCK_WHICH_PIDCPUCLOCK_WHICH_TIDMFD_HUGETLBMFD_HUGE_MASKMFD_HUGE_64KBMFD_HUGE_512KBMFD_HUGE_1MBMFD_HUGE_2MBMFD_HUGE_8MBMFD_HUGE_16MBMFD_HUGE_32MBMFD_HUGE_256MBMFD_HUGE_512MBMFD_HUGE_1GBMFD_HUGE_2GBMFD_HUGE_16GBSHM_LARGEPAGE_ALLOC_DEFAULTSHM_LARGEPAGE_ALLOC_NOWAITSHM_LARGEPAGE_ALLOC_HARDSHM_RENAME_NOREPLACESHM_RENAME_EXCHANGEUMTX_OP_WAITUMTX_OP_WAKEUMTX_OP_MUTEX_TRYLOCKUMTX_OP_MUTEX_LOCKUMTX_OP_MUTEX_UNLOCKUMTX_OP_SET_CEILINGUMTX_OP_CV_WAITUMTX_OP_CV_SIGNALUMTX_OP_CV_BROADCASTUMTX_OP_WAIT_UINTUMTX_OP_RW_RDLOCKUMTX_OP_RW_WRLOCKUMTX_OP_RW_UNLOCKUMTX_OP_WAIT_UINT_PRIVATEUMTX_OP_WAKE_PRIVATEUMTX_OP_MUTEX_WAITUMTX_OP_NWAKE_PRIVATEUMTX_OP_MUTEX_WAKE2UMTX_OP_SEM2_WAITUMTX_OP_SEM2_WAKEUMTX_OP_SHMUMTX_OP_ROBUST_LISTSUMTX_ABSTIMECPU_LEVEL_ROOTCPU_LEVEL_CPUSETCPU_LEVEL_WHICHCPU_WHICH_TIDCPU_WHICH_PIDCPU_WHICH_CPUSETCPU_WHICH_IRQCPU_WHICH_JAILRTF_LLDATARTF_FIXEDMTUSIGTHRSIGLWPSIGLIBRTSCTP_FUTURE_ASSOC// netinet/sctp.hSCTP_CURRENT_ASSOCSCTP_ALL_ASSOCSCTP_NO_NEXT_MSGSCTP_NEXT_MSG_AVAILSCTP_NEXT_MSG_ISCOMPLETESCTP_NEXT_MSG_IS_UNORDEREDSCTP_NEXT_MSG_IS_NOTIFICATIONSCTP_RECVV_NOINFOSCTP_RECVV_RCVINFOSCTP_RECVV_NXTINFOSCTP_RECVV_RNSCTP_SENDV_NOINFOSCTP_SENDV_SNDINFOSCTP_SENDV_PRINFOSCTP_SENDV_AUTHINFOSCTP_SENDV_SPASCTP_SEND_SNDINFO_VALIDSCTP_SEND_PRINFO_VALIDSCTP_SEND_AUTHINFO_VALIDSCTP_NOTIFICATIONSCTP_COMPLETESCTP_EOFSCTP_ABORTSCTP_UNORDEREDSCTP_ADDR_OVERSCTP_SENDALLSCTP_EORSCTP_SACK_IMMEDIATELYSCTP_PR_SCTP_NONESCTP_PR_SCTP_TTLSCTP_PR_SCTP_PRIOSCTP_PR_SCTP_BUFSCTP_PR_SCTP_RTXSCTP_PR_SCTP_MAXSCTP_PR_SCTP_ALLSCTP_INITSCTP_SNDRCVSCTP_EXTRCVSCTP_SNDINFOSCTP_RCVINFOSCTP_NXTINFOSCTP_PRINFOSCTP_AUTHINFOSCTP_DSTADDRV4SCTP_DSTADDRV6SCTP_RTOINFOSCTP_ASSOCINFOSCTP_INITMSGSCTP_NODELAYSCTP_AUTOCLOSESCTP_SET_PEER_PRIMARY_ADDRSCTP_PRIMARY_ADDRSCTP_ADAPTATION_LAYERSCTP_ADAPTION_LAYERSCTP_DISABLE_FRAGMENTSSCTP_PEER_ADDR_PARAMSSCTP_DEFAULT_SEND_PARAMSCTP_EVENTSSCTP_I_WANT_MAPPED_V4_ADDRSCTP_MAXSEGSCTP_DELAYED_SACKSCTP_FRAGMENT_INTERLEAVESCTP_PARTIAL_DELIVERY_POINTSCTP_AUTH_CHUNKSCTP_AUTH_KEYSCTP_HMAC_IDENTSCTP_AUTH_ACTIVE_KEYSCTP_AUTH_DELETE_KEYSCTP_USE_EXT_RCVINFOSCTP_AUTO_ASCONFSCTP_MAXBURSTSCTP_MAX_BURSTSCTP_CONTEXTSCTP_EXPLICIT_EORSCTP_REUSE_PORTSCTP_AUTH_DEACTIVATE_KEYSCTP_EVENTSCTP_RECVRCVINFOSCTP_RECVNXTINFOSCTP_DEFAULT_SNDINFOSCTP_DEFAULT_PRINFOSCTP_PEER_ADDR_THLDSSCTP_REMOTE_UDP_ENCAPS_PORTSCTP_ECN_SUPPORTEDSCTP_AUTH_SUPPORTEDSCTP_ASCONF_SUPPORTEDSCTP_RECONFIG_SUPPORTEDSCTP_NRSACK_SUPPORTEDSCTP_PKTDROP_SUPPORTEDSCTP_MAX_CWNDSCTP_STATUSSCTP_GET_PEER_ADDR_INFOSCTP_PEER_AUTH_CHUNKSSCTP_LOCAL_AUTH_CHUNKSSCTP_GET_ASSOC_NUMBERSCTP_GET_ASSOC_ID_LISTSCTP_TIMEOUTSSCTP_PR_STREAM_STATUSSCTP_PR_ASSOC_STATUSSCTP_COMM_UPSCTP_COMM_LOSTSCTP_RESTARTSCTP_SHUTDOWN_COMPSCTP_CANT_STR_ASSOCSCTP_ASSOC_SUPPORTS_PRSCTP_ASSOC_SUPPORTS_AUTHSCTP_ASSOC_SUPPORTS_ASCONFSCTP_ASSOC_SUPPORTS_MULTIBUFSCTP_ASSOC_SUPPORTS_RE_CONFIGSCTP_ASSOC_SUPPORTS_INTERLEAVINGSCTP_ASSOC_SUPPORTS_MAXSCTP_ADDR_AVAILABLESCTP_ADDR_UNREACHABLESCTP_ADDR_REMOVEDSCTP_ADDR_ADDEDSCTP_ADDR_MADE_PRIMSCTP_ADDR_CONFIRMEDSCTP_ACTIVESCTP_INACTIVESCTP_UNCONFIRMEDSCTP_DATA_UNSENTSCTP_DATA_SENTSCTP_PARTIAL_DELIVERY_ABORTEDSCTP_AUTH_NEW_KEYSCTP_AUTH_NEWKEYSCTP_AUTH_NO_AUTHSCTP_AUTH_FREE_KEYSCTP_STREAM_RESET_INCOMING_SSNSCTP_STREAM_RESET_OUTGOING_SSNSCTP_STREAM_RESET_DENIEDSCTP_STREAM_RESET_FAILEDSCTP_ASSOC_RESET_DENIEDSCTP_ASSOC_RESET_FAILEDSCTP_STREAM_CHANGE_DENIEDSCTP_STREAM_CHANGE_FAILEDKENV_DUMP_LOADERKENV_DUMP_STATICRB_REROOTRB_POWERCYCLERB_PROBERB_MULTIPLETFD_TIMER_CANCEL_ON_SETCLOSE_RANGE_CLOEXECKCMP_FILEKCMP_FILEOBJKCMP_FILESKCMP_SIGHANDKCMP_VMMAP_ALIGNEDaio_readvaio_writevextattr_delete_fdextattr_delete_fileextattr_delete_linkextattr_get_fdextattr_get_fileextattr_get_linkextattr_list_fdextattr_list_fileextattr_list_linkextattr_set_fdextattr_set_fileextattr_set_linkfspacectlspacectl_rangejailjail_attachjail_removejail_getjail_setmq_getfd_npcfmakesanepdforkpdgetpidpdkillrtprio_threaduuidgenthr_kill2pthread_getthreadid_np// sched.h linux compatibility api__xunamefhopenfhstatfhstatfsgetfhlgetfhnmountrforkcpuset_getaffinitycpuset_setaffinitycpusetcpuset_getidcpuset_setidcap_entercap_getmodecap_fcntls_getcap_fcntls_limitcap_ioctls_getcap_ioctls_limit__cap_rights_initcap_rights_t__cap_rights_get__cap_rights_set__cap_rights_clear__cap_rights_is_setcap_rights_is_validcap_rights_limitcap_rights_mergecap_rights_removecap_rights_containscap_sandboxedreallocarrayflsflslflsllmalloc_stats_printmallctlmallctlnametomibmallctlbymibmallocxrallocxxallocxsallocxdallocxsdallocxnallocxgetpagesizesclock_getcpuclockid2strchrnulshm_create_largepageshm_renamememfd_createsetauditauditinfo_teventfd_readeventfd_writeelf_aux_infosetproctitle_fasttimingsafe_bcmptimingsafe_memcmp_umtx_opsctp_bindxsctp_connectxsctp_getaddrlensctp_getpaddrssctp_freepaddrssctp_getladdrssctp_freeladdrssctp_sendvsctp_recvvclose_rangekcmpmemstat_strerrormemstat_mtl_allocmemory_type_listmemstat_mtl_firstmemory_typememstat_mtl_nextmemstat_mtl_findmemstat_mtl_freememstat_mtl_geterrormemstat_get_namekvm_dpcpu_setcpukvm_getargvkvm_getcptimekvm_getenvvkvm_geterrkvm_getmaxcpukvm_getncpuskvm_getpcpukvm_counter_u64_fetchkvm_getswapinfokvm_swapkvm_nativekvm_nlistnlistkvm_nlist2kvm_read_zpcpukvm_read2extattr_namespace_to_stringextattr_string_to_namespacerealhostnamerealhostname_sakld_isloadedkld_loadkinfo_getvmmapkinfo_vmentryhexdumpflopenflopenatgetlocalbasepidfile_openpidfhpidfile_writepidfile_closepidfile_removepidfile_fileno// FIXME(freebsd): pidfile_signal in due time (both manpage present and updated image snapshot)procstat_open_sysctlprocstat_getfilesfilestat_listprocstat_freefilesprocstat_getprocsprocstat_freeprocsprocstat_getvmmapprocstat_freevmmapprocstat_closeprocstat_freeargvprocstat_freeenvvprocstat_freegroupsprocstat_freeptlwpinfoptrace_lwpinfoprocstat_getargvprocstat_getenvvprocstat_getgroupsprocstat_getosrelprocstat_getpathnameprocstat_getrlimitprocstat_getumaskprocstat_open_coreprocstat_open_kvmprocstat_get_socket_infofilestatsockstatprocstat_get_vnode_infovnstatprocstat_get_pts_infoptsstatprocstat_get_shm_infoshmstatdevstat_getnumdevsdevstat_getgenerationdevstat_getversiondevstat_checkversiondevstat_selectdevsdevice_selectiondevstatdevstat_matchdevstat_buildmatch// sys/net/if_mib.h// sys/umtx.h// sys/timerfd.h// sys/unistd.h// 512 * 4KINFO_FILE_SIZE_MC_HASSEGS_MC_HASBASES_MC_HASFPXSTATE_MC_FLAG_MASK_MC_FPFMT_NODEV_MC_FPFMT_XMM_MC_FPOWNED_NONE_MC_FPOWNED_FPU_MC_FPOWNED_PCBElf32_LwordElf32_SwordElf64_LwordElf64_SwordElf64_Sxword// It's an alias over "struct __kvm_t". However, its fields aren't supposed to be used directly,// making the type definition system dependent. Better not bind it exactly.SIZEOF_LONG// Non-public helper constantSIGEV_KEVENTALTMON_1ALTMON_2ALTMON_3ALTMON_4ALTMON_5ALTMON_6ALTMON_7ALTMON_8ALTMON_9ALTMON_10ALTMON_11ALTMON_12F_DUP2FD_CLOEXECMNT_EXPUBLICMNT_NOCLUSTERRMNT_NOCLUSTERWMNT_NOSYMFOLLOWMNT_SOFTDEPMNT_SUIDDIRMNT_EXRDONLYMNT_DEFEXPORTEDMNT_EXPORTANONMNT_EXKERBMNT_DELEXPORTEDOOFUSPOLLSTANDARDRLIMIT_SBSIZERLIMIT_VMEMCLOCK_VIRTUALCLOCK_PROFCLOCK_UPTIMECLOCK_UPTIME_PRECISECLOCK_UPTIME_FASTCLOCK_REALTIME_PRECISECLOCK_REALTIME_FASTCLOCK_MONOTONIC_PRECISECLOCK_MONOTONIC_FASTCLOCK_SECONDMADV_NOSYNCMADV_AUTOSYNCMADV_NOCOREMADV_COREAF_ATMAF_NETGRAPHPF_ATMPF_NETGRAPHPIOD_READ_DPIOD_WRITE_DPIOD_READ_IPIOD_WRITE_IPT_IOIP_SENDSRCADDRSO_ACCEPTFILTERRTM_IFANNOUNCERTM_IEEE80211MAP_NOSYNCMAP_NOCORE_PC_ACL_EXTENDED_PC_ACL_PATH_MAX_PC_CAP_PRESENT_PC_INF_PRESENT_PC_MAC_PRESENTLOG_NTPLOG_SECURITYLOG_CONSOLETIOCGETATIOCSETATIOCSETAWTIOCSETAFTTYDISCSLIPDISCPPPDISCNETGRAPHDISCFIOGETLBACCTS_OFLOWCRTS_IFLOWCDTR_IFLOWCDSR_OFLOWCCAR_OFLOWVERASE2CMGROUP_MAXEUI64_LEN// https://github.com/freebsd/freebsd/blob/HEAD/sys/net/bpf.hRTP_PRIO_MIN// Values for rtprio struct (prio field) and syscall (function argument)RTP_PRIO_MAXRTP_LOOKUPRTP_SETUF_NOUNLINKSF_NOUNLINKREG_ILLSEQKENV_GETKENV_SETKENV_UNSETKENV_DUMPKENV_MNAMELENKENV_MVALLENRB_ASKNAMERB_SINGLERB_NOSYNCRB_HALTRB_INITNAMERB_DFLTROOTRB_KDBRB_RDONLYRB_DUMPRB_MINIROOTRB_VERBOSERB_SERIALRB_CDROMRB_POWEROFFRB_GDBRB_MUTERB_SELFTESTGRND_NONBLOCK// For getrandom()GRND_RANDOMGRND_INSECUREchflagsatgetgrent_rgetpwent_rlchflagsmalloc_usable_sizepthread_attr_get_nppthread_get_name_nppthread_set_name_nputrace// #include <link.h>explicit_bzero// Added in `FreeBSD` 11.0// Added in `DragonFly BSD` 5.4eui64_atoneui64eui64_ntoaeui64_ntohosteui64_hosttoneaccesskenvexectfparselnkvm_openkvm_closekvm_getprocskvm_getloadavgkvm_openfileskvm_readkvm_write// elf.h// link.hIPTOS_ECN_NOTECTIPTOS_ECN_MASKIPTOS_ECN_ECT1IPTOS_ECN_ECT0IPTOS_ECN_CEO_SHLOCKO_EXLOCKO_FSYNCMNT_RDONLYMNT_SYNCHRONOUSMNT_NOEXECMNT_NOSUIDMNT_ASYNCMNT_EXPORTEDMNT_UPDATEMNT_RELOADVSTATUSCIGNORENOKERNINFO// si_code values for SIGBUS signal// si_code values for SIGCHLD signalBIOCGHDRCMPLTREG_BASICREG_NOSPECREG_PENDREG_DUMPREG_EMPTYREG_ASSERTREG_INVARGREG_ATOIREG_ITOAREG_STARTENDREG_TRACEREG_LARGEREG_BACKR// Bitmask values for rtm_addrs.// Index offsets for sockaddr array for alternate internal encoding.setlogingetloadavgarc4randomarc4random_bufarc4random_uniformgetopt_longstrftime_ldevnamePIOD_READ_AUXV// http://man.openbsd.org/OpenBSD-current/man2/clock_getres.2// The man page says clock_gettime(3) can accept various values as clockid_t but// http://fxr.watson.org/fxr/source/kern/kern_time.c?v=OPENBSD;im=excerpts#L161// the implementation rejects anything other than the below two// http://netbsd.gw.com/cgi-bin/man-cgi?clock_gettime// https://github.com/jsonn/src/blob/HEAD/sys/kern/subr_time.c#L222// Basically the same goes for NetBSD// sys/fstypes.h in NetBSD, or sys/mount.h in OpenBSDMSG_BCASTMSG_MCAST__errno// sys/reboot.hgreg_t__cpu_simple_lock_nv_t_REG_R0_REG_R1_REG_R2_REG_R3_REG_R4_REG_R5_REG_R6_REG_R7_REG_R8_REG_R9_REG_R10_REG_R11_REG_R12_REG_R13_REG_R14_REG_R15_REG_CPSR_REG_X0_REG_X1_REG_X2_REG_X3_REG_X4_REG_X5_REG_X6_REG_X7_REG_X8_REG_X9_REG_X10_REG_X11_REG_X12_REG_X13_REG_X14_REG_X15_REG_X16_REG_X17_REG_X18_REG_X19_REG_X20_REG_X21_REG_X22_REG_X23_REG_X24_REG_X25_REG_X26_REG_X27_REG_X28_REG_X29_REG_X30_REG_X31_REG_ELR_REG_SPSR_REG_TIPDR_REG_RV_REG_FP_REG_LR_REG_SP_REG_PC__pthread_spin_t// FIXME(deprecated): deprecated since long time_cpusetpthread_spin_tsi_codesi_errnoAT_DCACHEBSIZEAT_ICACHEBSIZEAT_UCACHEBSIZEAT_STACKBASEAT_RUIDAT_RGIDAT_SUN_LDELFAT_SUN_LDSHDRAT_SUN_LDNAMEAT_SUN_LDPGSIZEAT_SUN_PLATFORMAT_SUN_HWCAPAT_SUN_IFLUSHAT_SUN_CPUAT_SUN_EMUL_ENTRYAT_SUN_EMUL_EXECFDAT_SUN_EXECNAMEO_ALT_IOO_NOSIGPIPE// Here because they are not present on OpenBSD// (https://github.com/openbsd/src/blob/HEAD/sys/sys/resource.h)RLIMIT_NTHRF_GETNOSIGPIPEF_SETNOSIGPIPEF_MAXFDFUTEX_WAITFUTEX_WAKEFUTEX_FDFUTEX_REQUEUEFUTEX_CMP_REQUEUEFUTEX_WAKE_OPFUTEX_LOCK_PIFUTEX_UNLOCK_PIFUTEX_TRYLOCK_PIFUTEX_WAIT_BITSETFUTEX_WAKE_BITSETFUTEX_WAIT_REQUEUE_PIFUTEX_CMP_REQUEUE_PIFUTEX_PRIVATE_FLAGFUTEX_CLOCK_REALTIMEFUTEX_CMD_MASKFUTEX_WAITERSFUTEX_OWNER_DIEDFUTEX_SYNCOBJ_1FUTEX_SYNCOBJ_0FUTEX_TID_MASKFUTEX_BITSET_MATCH_ANYIP_RECVPKTINFOTCP_CONGCTLSOCK_CONN_DGRAMSOCK_NOSIGPIPESOCK_FLAGS_MASKSO_OVERFLOWEDSO_NOHEADERLOCAL_OCREDS// http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/sys/un.h?annotate// pass credentials to receiverLOCAL_PEEREID// connects block until accepted// get peer identification// https://github.com/NetBSD/src/blob/trunk/sys/net/if.h#L373// avoid use of trailers/// IP Mobility RFC 2004IPPROTO_IPV6_ICMP/// IPv6 ICMP/// Ethernet-in-IPIPPROTO_VRRP/// VRRP RFC 2338/// Common Address Resolution ProtocolIPPROTO_L2TP/// L2TPv3CTL_IPPROTO_IPSEC/// sysctl placeholder for (FAST_)IPSECAF_OROUTENET_RT_OOOIFLISTNET_RT_OOIFLISTNET_RT_OIFLISTPF_OROUTEMAP_TRYFIXEDMAP_WIRED// map alignment aliases for MAP_ALIGNEDMAP_ALIGNMENT_64KBMAP_ALIGNMENT_16MBMAP_ALIGNMENT_4GBMAP_ALIGNMENT_1TBMAP_ALIGNMENT_256TBMAP_ALIGNMENT_64PBMAP_REMAPDUP// mremap flagDCCP_TYPE_REQUESTDCCP_TYPE_RESPONSEDCCP_TYPE_DATADCCP_TYPE_ACKDCCP_TYPE_DATAACKDCCP_TYPE_CLOSEREQDCCP_TYPE_CLOSEDCCP_TYPE_RESETDCCP_TYPE_MOVEDCCP_FEATURE_CCDCCP_FEATURE_ECNDCCP_FEATURE_ACKRATIODCCP_FEATURE_ACKVECTORDCCP_FEATURE_MOBILITYDCCP_FEATURE_LOSSWINDOWDCCP_FEATURE_CONN_NONCEDCCP_FEATURE_IDENTREGDCCP_OPT_PADDINGDCCP_OPT_DATA_DISCARDDCCP_OPT_SLOW_RECVDCCP_OPT_BUF_CLOSEDDCCP_OPT_CHANGE_LDCCP_OPT_CONFIRM_LDCCP_OPT_CHANGE_RDCCP_OPT_CONFIRM_RDCCP_OPT_INIT_COOKIEDCCP_OPT_NDP_COUNTDCCP_OPT_ACK_VECTOR0DCCP_OPT_ACK_VECTOR1DCCP_OPT_RECV_BUF_DROPSDCCP_OPT_TIMESTAMPDCCP_OPT_TIMESTAMP_ECHODCCP_OPT_ELAPSEDTIMEDCCP_OPT_DATACHECKSUMDCCP_REASON_UNSPECDCCP_REASON_CLOSEDDCCP_REASON_INVALIDDCCP_REASON_OPTION_ERRDCCP_REASON_FEA_ERRDCCP_REASON_CONN_REFDCCP_REASON_BAD_SNAMEDCCP_REASON_BAD_COOKIEDCCP_REASON_INV_MOVEDCCP_REASON_UNANSW_CHDCCP_REASON_FRUITLESS_NEGDCCP_CCIDDCCP_CSLENDCCP_MAXSEGDCCP_SERVICEDCCP_NDP_LIMITDCCP_SEQ_NUM_LIMITDCCP_MAX_OPTIONSDCCP_MAX_PKTS// These two variables will be supported in NetBSD 8.0// pub const _SC_SIGQUEUE_MAX : c_int = 93;// pub const _SC_REALTIME_SIGNALS : c_int = 94;_SC_SCHED_RT_TS_SC_SCHED_PRI_MIN_SC_SCHED_PRI_MAX// <sys/fstypes.h>MNT_NOCOREDUMPMNT_RELATIMEMNT_DISCARDMNT_EXTATTRMNT_LOGMNT_SYMPERMMNT_NODEVMTIMEMNT_POSIX1EACLSPL_EVENT_SUSPENDEDSCHED_NONEAI_SRVNI_WITHSCOPEIDSYSCTL_NAMELENSYSCTL_DEFSIZECTLTYPE_BOOLCTLFLAG_READONLYCTLFLAG_READWRITECTLFLAG_ANYWRITECTLFLAG_PRIVATECTLFLAG_PERMANENTCTLFLAG_OWNDATACTLFLAG_IMMEDIATECTLFLAG_HEXCTLFLAG_ROOTCTLFLAG_ANYNUMBERCTLFLAG_HIDDENCTLFLAG_ALIASCTLFLAG_MMAPCTLFLAG_OWNDESCCTLFLAG_UNSIGNEDSYSCTL_VERS_MASKSYSCTL_VERS_0SYSCTL_VERS_1SYSCTL_VERSIONCTL_EOLCTL_QUERYCTL_CREATECTL_CREATESYMCTL_DESTROYCTL_MMAPCTL_DESCRIBECTL_DDBCTL_PROCCTL_VENDORCTL_EMULCTL_SECURITYKERN_OBOOTTIMEKERN_RAWPARTITIONKERN_NTPTIMEKERN_TIMEXKERN_AUTONICETIMEKERN_AUTONICEVALKERN_RTC_OFFSETKERN_ROOT_DEVICEKERN_MSGBUFSIZEKERN_FSYNCKERN_OLDSYSVMSGKERN_OLDSYSVSEMKERN_OLDSYSVSHMKERN_OLDSHORTCORENAMEKERN_SYNCHRONIZED_IOKERN_MBUFKERN_MAPPED_FILESKERN_MEMLOCKKERN_MEMLOCK_RANGEKERN_MEMORY_PROTECTIONKERN_LOGIN_NAME_MAXKERN_DEFCORENAMEKERN_PROC2KERN_FSCALEKERN_CCPUKERN_CP_TIMEKERN_OLDSYSVIPC_INFOKERN_MSGBUFKERN_CONSDEVKERN_MAXPTYSKERN_PIPEKERN_SBMAXKERN_TKSTATKERN_MONOTONIC_CLOCKKERN_URNDKERN_LABELSECTORKERN_LABELOFFSETKERN_LWPKERN_FORKFSLEEPKERN_POSIX_THREADSKERN_POSIX_SEMAPHORESKERN_POSIX_BARRIERSKERN_POSIX_TIMERSKERN_POSIX_SPIN_LOCKSKERN_POSIX_READER_WRITER_LOCKSKERN_DUMP_ON_PANICKERN_SOMAXKVAKERN_ROOT_PARTITIONKERN_DRIVERSKERN_BUFKERN_FILE2KERN_VERIEXECKERN_CP_IDKERN_HARDCLOCK_TICKSKERN_SYSVIPCKERN_EVCNTKERN_PROC_ARGVKERN_PROC_NARGVKERN_PROC_NENVVM_PROCVM_PROC_MAPWALTSIGWALLSIGWNOZOMBIECDTRCTSCHWFLOWUT_NAMESIZE// pub const _PATH_UTMPX: &[c_char; 14] = b"/var/run/utmpx";// pub const _PATH_WTMPX: &[c_char; 14] = b"/var/log/wtmpx";// pub const _PATH_LASTLOGX: &[c_char; 17] = b"/var/log/lastlogx";// pub const _PATH_UTMP_UPDATE: &[c_char; 24] = b"/usr/libexec/utmp_update";UT_LINESIZEUT_HOSTSIZE_UTX_PADSIZEDOWN_TIMEOFIOGETBMAP// Uncomment on next NetBSD release// pub const FIOSEEKDATA: c_ulong = 0xc0086661;// pub const FIOSEEKHOLE: c_ulong = 0xc0086662;FIOGETBMAPFIBMAPPT_DUMPCOREPT_SYSCALLEMUPT_GET_PROCESS_STATEPT_SET_SIGINFOPT_GET_SIGINFOPT_STOPPT_LWPSTATUSPT_LWPNEXTPT_SET_SIGPASSPT_GET_SIGPASSPOSIX_SPAWN_RETURNERRORSF_LOGSF_SNAPINVALKVME_FLAG_PAGEABLEKI_MAXCOMLENKI_WMESGLENKI_MAXLOGNAMEKI_MAXEMULLENKI_LNAMELENLSIDL// sys/lwp.hLSRUNLSSLEEPLSSTOPLSZOMBLSONPROCLSSUSPENDED// sys/xattr.h// sys/extattr.hRB_STRINGRB_POWERDOWNRB_USERCONFRTF_CONNECTEDRTF_ANNOUNCERTF_SRCRTF_UPDATINGRTF_DONTCHANGEIFARTM_SETGATERTM_LLINFO_UPDRTM_OCHGADDRRTM_CHGADDRRTA_TAGRTAX_TAGreallocarr"__lutimes50""__gettimeofday50""__kevent50""__mount50""__mq_timedreceive50""__mq_timedsend50"_cpuset_create_cpuset_destroy_cpuset_clr_cpuset_set_cpuset_isset_cpuset_size_cpuset_zero"__sigtimedwait50""__settimeofday50"kqueue1_lwp_self_dlauxinfo// Added in `NetBSD` 7.0mremap"__pollts50"pollts"___lwp_park60"_lwp_park_lwp_unpark_lwp_unpark_all"__getmntinfo13"getvfsstat"__aio_suspend50"getutmpgetutmpxutpnameefopenemallocecallocereallocereallocarrestrdupestrndupestrlcpyestrlcatestrtoiestrtoueasprintfevasprintfesetfuncsecure_pathsnprintbsnprintb_mgetbootfilegetbyteordergetdiskrawnamegetdiskcookednamegetfsspecnamestrpctstrspct"__login50""__loginx50"loginxlogoutlogoutxlogwtmplogwtmpxlgetxattrlsetxattrllistxattrlremovexattrstring_to_flagsflags_to_stringbacktrace_symbols_fmtbacktrace_symbols_fd_fmt__gregset_NGREG__fregset_NFREG__freg_REG_RA_REG_GP_REG_TP_REG_S0_REG_A0_REG_F0_REG_FPCSR// should be pub(crate), but that requires Rust 1.18.0c___greg_t_REG_RDI_REG_RSI_REG_RDX_REG_RCX_REG_RBP_REG_RBX_REG_RAX_REG_GS_REG_FS_REG_ES_REG_DS_REG_TRAPNO_REG_ERR_REG_RIP_REG_CS_REG_RFLAGS_REG_RSP_REG_SSsigcontext_MAX_PAGE_SHIFTbsdENTRYSO_BINDANYSO_NETPROCSO_RTABLESO_SPLICE/// unicast MPLS packet// Only used internally, so it can be outside the range of valid IP protocolsAF_ENCAPpseudo_AF_PFLOWpseudo_AF_PIPEXNET_RT_STATSNET_RT_TABLENET_RT_IFNAMESPF_ENCAPPF_BPFPF_PFLOWPF_PIPEXEIPSEC_SC_XOPEN_UUCPPTHREAD_MUTEX_STRICT_NPEVFILT_DEVICENOTE_EOFNOTE_TRUNCATENOTE_CHANGEAI_EXTAI_FQDNCTL_FSHW_NCPUONLINEKERN_MAXTHREADKERN_NTHREADSKERN_SOMAXCONNKERN_SOMINCONNKERN_USERMOUNTKERN_NOSUIDCOREDUMPKERN_SYSVMSGKERN_SYSVSEMKERN_SYSVSHMKERN_MALLOCSTATSKERN_CPTIMEKERN_NCHSTATSKERN_FORKSTATKERN_NSELCOLLKERN_NPROCSKERN_POOLKERN_STACKGAPRANDOMKERN_SYSVIPC_INFOKERN_SPLASSERTKERN_NFILESKERN_TTYCOUNTKERN_NUMVNODESKERN_MBSTATKERN_SEMINFOKERN_SHMINFOKERN_INTRCNTKERN_WATCHDOGKERN_MAXCLUSTERSKERN_EVCOUNTKERN_TIMECOUNTERKERN_MAXLOCKSPERUIDKERN_CPTIME2KERN_CACHEPCTKERN_NETLIVELOCKSKERN_POOL_DEBUGKERN_PROC_NOBROADCASTKILLKERN_GLOBAL_PTRACEKERN_CONSBUFSIZEKERN_CONSBUFKERN_AUDIOKERN_CPUSTATSKERN_PFSTATUSKERN_TIMEOUT_STATSKERN_PROC_KTHREADKERN_PROC_SHOW_THREADSKERN_SYSVIPC_MSG_INFOKERN_SYSVIPC_SEM_INFOKERN_SYSVIPC_SHM_INFOKVE_ET_OBJKVE_ET_SUBMAPKVE_ET_COPYONWRITEKVE_ET_NEEDSCOPYKVE_ET_HOLEKVE_ET_NOFAULTKVE_ET_STACKKVE_ET_WCKVE_ET_CONCEALKVE_ET_SYSCALLKVE_ET_FREEMAPPEDKVE_PROT_NONEKVE_PROT_READKVE_PROT_WRITEKVE_PROT_EXECKVE_ADV_NORMALKVE_ADV_RANDOMKVE_ADV_SEQUENTIALKVE_INH_SHAREKVE_INH_COPYKVE_INH_NONEKVE_INH_ZEROKVE_F_STATICKVE_F_KMEMISOFSMNT_NORRIP//https://github.com/openbsd/src/blob/HEAD/sys/sys/mount.hISOFSMNT_GENS// disable Rock Ridge ExtISOFSMNT_EXTATT// enable generation numbersISOFSMNT_NOJOLIET// enable extended attrISOFSMNT_SESS// disable Joliet ExtNFS_ARGSVERSIONNFSMNT_RESVPORT// always use reserved ports// soft mount (hard is default)// set write size// set read size// set initial timeoutNFSMNT_MAXGRPS// set number of request retries// set maximum grouplist sizeNFSMNT_NOCONN// allow interrupts on hard mountNFSMNT_NQNFS// Don't Connect the socketNFSMNT_NFSV3// Use Nqnfs protocolNFSMNT_KERB// Use NFS Version 3 protocolNFSMNT_DUMBTIMR// Use Kerberos authenticationNFSMNT_LEASETERM// Don't estimate rtt dynamicallyNFSMNT_READAHEAD// set lease term (nqnfs)NFSMNT_DEADTHRESH// set read ahead// set dead server retry threshNFSMNT_RDIRPLUS// disable attribute cacheNFSMNT_READDIRSIZE// Use Readdirplus for V3/* Flags valid only in mount syscall arguments */// acregmin field valid// acregmax field valid// acdirmin field validNFSMNT_INTERNAL/* Flags valid only in kernel */NFSMNT_HASWRITEVERF// Bits set internallyNFSMNT_GOTPATHCONF// Has write verifier for V3NFSMNT_GOTFSINFO// Got the V3 pathconf infoNFSMNT_MNTD// Got the V3 fsinfoNFSMNT_DISMINPROG// Mnt server for mnt pointNFSMNT_DISMNT// Dismount in progressNFSMNT_SNDLOCK// DismountedNFSMNT_WANTSND// Send socket lockNFSMNT_RCVLOCK// Want aboveNFSMNT_WANTRCV// Rcv socket lockNFSMNT_WAITAUTHNFSMNT_HASAUTH// Wait for authenticationNFSMNT_WANTAUTH// Has authenticatorNFSMNT_AUTHERR// Wants an authenticatorMSDOSFSMNT_SHORTNAMEMSDOSFSMNT_LONGNAME// Force old DOS short names onlyMSDOSFSMNT_NOWIN95// Force Win'95 long namesNTFS_MFLAG_CASEINSNTFS_MFLAG_ALLNAMESTMPFS_ARGS_VERSIONSI_MAXSZSI_PADMAP_CONCEAL// https://github.com/openbsd/src/blob/HEAD/sys/net/if.h#L187// only static ARPPT_GET_THREAD_FIRSTPT_GET_THREAD_NEXTSOCK_DNS// futex.hEPROC_CTTY// sysctl.h, kinfo_proc p_eflag constantsEPROC_SLEADER// controlling tty vnode activeEPROC_UNVEIL// session leaderEPROC_LKUNVEIL// has unveil settings// sys/exec_elf.h - Legal values for p_type (segment type).PT_HIOSPT_LOPROCPT_HIPROCPF_X// sys/exec_elf.h - Legal values for p_flags (segment flags).PF_WPF_RPF_MASKOSPF_MASKPROCMNT_NOPERMMNT_WXALLOWEDMNT_STALLEDMNT_SWAPPABLEMNT_WANTRDWRMNT_DOOMED// For use with vfs_fsync and getfsstat// sys/_time.hRB_CONFIGRB_TIMEBADRB_SERCONSRB_USERREQRB_RESETRB_GOODRANDOMRB_UNHIBERNATERTF_MPATHRTF_MPLSRTF_BFDRTF_FMASKRTM_DESYNCRTM_INVALIDATERTM_BFDRTM_PROPOSALRTM_CHGADDRATTRRTM_80211INFORTM_SOURCERTA_SRCRTA_SRCMASKRTA_LABELRTA_BFDRTA_DNSRTA_STATICRTA_SEARCHRTAX_SRCRTAX_SRCMASKRTAX_LABELRTAX_BFDRTAX_DNSRTAX_STATICRTAX_SEARCHpledgeunveilgetthridpthread_stackseg_np// Added in `OpenBSD` 5.5malloc_concealcalloc_concealsrand48_deterministicseed48_deterministiclcong48_deterministicfutexmimmutable// use iso_args.sess// change when nfs_args changes// Set readdir size// acdirmax field valid// Authentication error// Completely ignore Win95 entries// unveil is locked_off64_tfd_mask// Must be usize due to libstd/sys_common/thread_local.rs,// should technically be *mut c_void// The following ones should be *mut c_void// FIXME: does not exist on Cygwin!// driver signals L1 upSIOCGIFINDEXSIOGIFINDEXIP_UNICAST_IFIPV6_UNICAST_IFS_BLKSIZES_ENFMTFORK_RELOADFORK_NO_RELOADRTLD_DEEPBIND/// gateway mgmt protocol/// IPIP tunnels (older KA9Q tunnels use 94)_SC_THREAD_PRIO_CEILING_SC_LEVEL1_ICACHE_SIZE_SC_LEVEL1_ICACHE_ASSOC_SC_LEVEL1_ICACHE_LINESIZE_SC_LEVEL1_DCACHE_SIZE_SC_LEVEL1_DCACHE_ASSOC_SC_LEVEL1_DCACHE_LINESIZE_SC_LEVEL2_CACHE_SIZE_SC_LEVEL2_CACHE_ASSOC_SC_LEVEL2_CACHE_LINESIZE_SC_LEVEL3_CACHE_SIZE_SC_LEVEL3_CACHE_ASSOC_SC_LEVEL3_CACHE_LINESIZE_SC_LEVEL4_CACHE_SIZE_SC_LEVEL4_CACHE_ASSOC_SC_LEVEL4_CACHE_LINESIZEF_RGETLKF_RSETLKF_CNVTF_RSETLKWPTHREAD_RECURSIVE_MUTEX_INITIALIZER_NPPTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NPWINDOWS_POSTWINDOWS_SENDWINDOWS_HWNDMOUNT_TEXTMOUNT_SYSTEMMOUNT_EXECMOUNT_CYGDRIVEMOUNT_CYGWIN_EXECMOUNT_SPARSEMOUNT_NOTEXECMOUNT_DEVFSMOUNT_PROCMOUNT_ROMOUNT_NOACLMOUNT_NOPOSIXMOUNT_OVERRIDEMOUNT_IMMUTABLEMOUNT_AUTOMATICMOUNT_DOSMOUNT_IHASHMOUNT_BINDMOUNT_USER_TEMPMOUNT_DONT_USEfutimesatdlforkgetptqsort_r"__xpg_strerror_r""__gnu_basename"euidaccesspthread_sigqueuecygwin_umount// pub fn execlpe(path: *const c_char, arg0: *const c_char, ...) -> c_int;// driver signals dormant/* Operation would block */Elf_AddrElf_HalfElf32_PhdrElf64_PhdrStringList_stringlistL_SETL_INCRL_XTNDRLIMIT_NOVMON// Haiku specificO_NOTRAVERSEO_NOCACHESIGKILLTHR// FIXME(haiku): Haiku does not have MAP_FILE, but library/std/os.rs requires itEFPOSESIGPARM// INT_MIN// POSIX errors that can be mapped to BeOS error codes// These are prefixed with POSIX_ on Haiku// https://github.com/haiku/haiku/blob/HEAD/headers/posix/net/if.h#L80// valid broadcast address// point-to-point linkIFF_AUTOUP// no address resolution// auto dialIFF_LINK// doesn't receive own transmissionsIFF_AUTO_CONFIGURED// has linkIFF_CONFIGURINGAF_NOTIFYSA_NOMASKSA_STACKSA_ONESHOT// DIFF(main): changed to `c_int` in 500365e1_PC_XATTR_EXISTS_PC_XATTR_ENABLED_SC_PIPE_SC_SELECT_SC_POLLSO_NONBLOCKVSWTCHXLOBLKCTSFLOWRTSFLOWTCGB_CTSTCGB_DSRTCGB_RITCGB_DCDB31250TCGETBITSTCSETDTRTCSETRTSLOG_SERIALPOSIX_SPAWN_SETSIDendusershellgetpassgetusershellissetugidsetusershell_errnopgetspentspwdgetspent_rsetspentendspentgetspnamgetspnam_rsgetspentsgetspent_rfgetspentfgetspent_rvallocsl_initsl_addsl_freesl_find// FIXME(haiku): does not exist on Haiku!haiku_constantstatus_t// support/SupportDefs.hbigtime_tnanotime_ttype_codeperform_codearea_id// kernel/OS.hport_idsem_idteam_idthread_funcimage_id// kernel/image.hB_OS_NAME_LENGTHB_PAGE_SIZEB_INFINITE_TIMEOUTB_RELATIVE_TIMEOUTB_ABSOLUTE_TIMEOUTB_TIMEOUT_REAL_TIME_BASEB_ABSOLUTE_REAL_TIME_TIMEOUTB_NO_LOCKB_LAZY_LOCKB_FULL_LOCKB_CONTIGUOUSB_LOMEMB_32_BIT_FULL_LOCKB_32_BIT_CONTIGUOUSB_ANY_ADDRESSB_EXACT_ADDRESSB_BASE_ADDRESSB_CLONE_ADDRESSB_ANY_KERNEL_ADDRESSB_RANDOMIZED_ANY_ADDRESSB_RANDOMIZED_BASE_ADDRESSB_READ_AREAB_WRITE_AREAB_EXECUTE_AREAB_STACK_AREAB_CLONEABLE_AREAB_CAN_INTERRUPTB_CHECK_PERMISSIONB_KILL_CAN_INTERRUPTB_DO_NOT_RESCHEDULEB_RELEASE_ALLB_RELEASE_IF_WAITING_ONLYB_CURRENT_TEAMB_SYSTEM_TEAMB_TEAM_USAGE_SELFB_TEAM_USAGE_CHILDRENB_IDLE_PRIORITYB_LOWEST_ACTIVE_PRIORITYB_LOW_PRIORITYB_NORMAL_PRIORITYB_DISPLAY_PRIORITYB_URGENT_DISPLAY_PRIORITYB_REAL_TIME_DISPLAY_PRIORITYB_URGENT_PRIORITYB_REAL_TIME_PRIORITYB_SYSTEM_TIMEBASEB_FIRST_REAL_TIME_PRIORITYB_ONE_SHOT_ABSOLUTE_ALARMB_ONE_SHOT_RELATIVE_ALARMB_PERIODIC_ALARMB_OBJECT_TYPE_FDB_OBJECT_TYPE_SEMAPHOREB_OBJECT_TYPE_PORTB_OBJECT_TYPE_THREADB_EVENT_READB_EVENT_WRITEB_EVENT_ERRORB_EVENT_PRIORITY_READB_EVENT_PRIORITY_WRITEB_EVENT_HIGH_PRIORITY_READB_EVENT_HIGH_PRIORITY_WRITEB_EVENT_DISCONNECTEDB_EVENT_ACQUIRE_SEMAPHOREB_EVENT_INVALIDB_FS_IS_READONLY// kernel/fs_info.hB_FS_IS_REMOVABLEB_FS_IS_PERSISTENTB_FS_IS_SHAREDB_FS_HAS_MIMEB_FS_HAS_ATTRB_FS_HAS_QUERYB_FS_HAS_SELF_HEALING_LINKSB_FS_HAS_ALIASESB_FS_SUPPORTS_NODE_MONITORINGB_FS_SUPPORTS_MONITOR_CHILDRENB_LIVE_QUERY// kernel/fs_query.hB_QUERY_NON_INDEXEDB_MOUNT_READ_ONLY// kernel/fs_volume.hB_MOUNT_VIRTUAL_DEVICEB_FORCE_UNMOUNTB_FLUSH_DCACHEB_FLUSH_ICACHEB_INVALIDATE_DCACHEB_INVALIDATE_ICACHEB_SYMBOL_TYPE_DATAB_SYMBOL_TYPE_TEXTB_SYMBOL_TYPE_ANYB_DEV_NAME_LENGTH// storage/StorageDefs.hB_FILE_NAME_LENGTHB_PATH_NAME_LENGTHB_ATTR_NAME_LENGTHB_MIME_TYPE_LENGTHB_MAX_SYMLINKSB_READ_ONLY// Haiku open modes in BFile are passed as u32B_WRITE_ONLYB_READ_WRITEB_FAIL_IF_EXISTSB_CREATE_FILEB_ERASE_FILEB_OPEN_AT_ENDB_FILE_NODEB_SYMLINK_NODEB_DIRECTORY_NODEB_ANY_NODEB_GENERAL_ERROR_BASE// support/Errors.hB_OS_ERROR_BASEB_APP_ERROR_BASEB_INTERFACE_ERROR_BASEB_MEDIA_ERROR_BASEB_TRANSLATION_ERROR_BASEB_MIDI_ERROR_BASEB_STORAGE_ERROR_BASEB_POSIX_ERROR_BASEB_MAIL_ERROR_BASEB_PRINT_ERROR_BASEB_DEVICE_ERROR_BASEB_ERRORS_ENDB_NO_MEMORY// General errorsB_IO_ERRORB_PERMISSION_DENIEDB_BAD_INDEXB_BAD_TYPEB_BAD_VALUEB_MISMATCHED_VALUESB_NAME_NOT_FOUNDB_NAME_IN_USEB_TIMED_OUTB_INTERRUPTEDB_WOULD_BLOCKB_CANCELEDB_NO_INITB_NOT_INITIALIZEDB_BUSYB_NOT_ALLOWEDB_BAD_DATAB_DONT_DO_THATB_ERRORB_OKB_NO_ERRORB_BAD_SEM_ID// Kernel kit errorsB_NO_MORE_SEMSB_BAD_THREAD_IDB_NO_MORE_THREADSB_BAD_THREAD_STATEB_BAD_TEAM_IDB_NO_MORE_TEAMSB_BAD_PORT_IDB_NO_MORE_PORTSB_BAD_IMAGE_IDB_BAD_ADDRESSB_NOT_AN_EXECUTABLEB_MISSING_LIBRARYB_MISSING_SYMBOLB_UNKNOWN_EXECUTABLEB_LEGACY_EXECUTABLEB_DEBUGGER_ALREADY_INSTALLEDB_BAD_REPLY// Application kit errorsB_DUPLICATE_REPLYB_MESSAGE_TO_SELFB_BAD_HANDLERB_ALREADY_RUNNINGB_LAUNCH_FAILEDB_AMBIGUOUS_APP_LAUNCHB_UNKNOWN_MIME_TYPEB_BAD_SCRIPT_SYNTAXB_LAUNCH_FAILED_NO_RESOLVE_LINKB_LAUNCH_FAILED_EXECUTABLEB_LAUNCH_FAILED_APP_NOT_FOUNDB_LAUNCH_FAILED_APP_IN_TRASHB_LAUNCH_FAILED_NO_PREFERRED_APPB_LAUNCH_FAILED_FILES_APP_NOT_FOUNDB_BAD_MIME_SNIFFER_RULEB_NOT_A_MESSAGEB_SHUTDOWN_CANCELLEDB_SHUTTING_DOWNB_FILE_ERROR// Storage kit errorsB_FILE_EXISTSB_ENTRY_NOT_FOUNDB_NAME_TOO_LONGB_NOT_A_DIRECTORYB_DIRECTORY_NOT_EMPTYB_DEVICE_FULLB_READ_ONLY_DEVICEB_IS_A_DIRECTORYB_NO_MORE_FDSB_CROSS_DEVICE_LINKB_LINK_LIMITB_BUSTED_PIPEB_UNSUPPORTEDB_PARTITION_TOO_SMALLB_PARTIAL_READB_PARTIAL_WRITEB_BUFFER_OVERFLOW// Mapped posix errorsB_TOO_MANY_ARGSB_FILE_TOO_LARGEB_RESULT_NOT_REPRESENTABLEB_DEVICE_NOT_FOUNDB_NOT_SUPPORTEDB_STREAM_NOT_FOUND// Media kit errorsB_SERVER_NOT_FOUNDB_RESOURCE_NOT_FOUNDB_RESOURCE_UNAVAILABLEB_BAD_SUBSCRIBERB_SUBSCRIBER_NOT_ENTEREDB_BUFFER_NOT_AVAILABLEB_LAST_BUFFER_ERRORB_MEDIA_SYSTEM_FAILUREB_MEDIA_BAD_NODEB_MEDIA_NODE_BUSYB_MEDIA_BAD_FORMATB_MEDIA_BAD_BUFFERB_MEDIA_TOO_MANY_NODESB_MEDIA_TOO_MANY_BUFFERSB_MEDIA_NODE_ALREADY_EXISTSB_MEDIA_BUFFER_ALREADY_EXISTSB_MEDIA_CANNOT_SEEKB_MEDIA_CANNOT_CHANGE_RUN_MODEB_MEDIA_APP_ALREADY_REGISTEREDB_MEDIA_APP_NOT_REGISTEREDB_MEDIA_CANNOT_RECLAIM_BUFFERSB_MEDIA_BUFFERS_NOT_RECLAIMEDB_MEDIA_TIME_SOURCE_STOPPEDB_MEDIA_TIME_SOURCE_BUSYB_MEDIA_BAD_SOURCEB_MEDIA_BAD_DESTINATIONB_MEDIA_ALREADY_CONNECTEDB_MEDIA_NOT_CONNECTEDB_MEDIA_BAD_CLIP_FORMATB_MEDIA_ADDON_FAILEDB_MEDIA_ADDON_DISABLEDB_MEDIA_CHANGE_IN_PROGRESSB_MEDIA_STALE_CHANGE_COUNTB_MEDIA_ADDON_RESTRICTEDB_MEDIA_NO_HANDLERB_MEDIA_DUPLICATE_FORMATB_MEDIA_REALTIME_DISABLEDB_MEDIA_REALTIME_UNAVAILABLEB_MAIL_NO_DAEMON// Mail kit errorsB_MAIL_UNKNOWN_USERB_MAIL_WRONG_PASSWORDB_MAIL_UNKNOWN_HOSTB_MAIL_ACCESS_ERRORB_MAIL_UNKNOWN_FIELDB_MAIL_NO_RECIPIENTB_MAIL_INVALID_MAILB_NO_PRINT_SERVER// Print kit errorsB_DEV_INVALID_IOCTL// Device kit errorsB_DEV_NO_MEMORYB_DEV_BAD_DRIVE_NUMB_DEV_NO_MEDIAB_DEV_UNREADABLEB_DEV_FORMAT_ERRORB_DEV_TIMEOUTB_DEV_RECALIBRATE_ERRORB_DEV_SEEK_ERRORB_DEV_ID_ERRORB_DEV_READ_ERRORB_DEV_WRITE_ERRORB_DEV_NOT_READYB_DEV_MEDIA_CHANGEDB_DEV_MEDIA_CHANGE_REQUESTEDB_DEV_RESOURCE_CONFLICTB_DEV_CONFIGURATION_ERRORB_DEV_DISABLED_BY_USERB_DEV_DOOR_OPENB_DEV_INVALID_PIPEB_DEV_CRC_ERRORB_DEV_STALLEDB_DEV_BAD_PIDB_DEV_UNEXPECTED_PIDB_DEV_DATA_OVERRUNB_DEV_DATA_UNDERRUNB_DEV_FIFO_OVERRUNB_DEV_FIFO_UNDERRUNB_DEV_PENDINGB_DEV_MULTIPLE_ERRORSB_DEV_TOO_LATEB_TRANSLATION_BASE_ERROR// translation kit errorsB_NO_TRANSLATORB_ILLEGAL_DATAB_AFFINE_TRANSFORM_TYPE// support/TypeConstants.hB_ALIGNMENT_TYPEB_ANY_TYPEB_ATOM_TYPEB_ATOMREF_TYPEB_BOOL_TYPEB_CHAR_TYPEB_COLOR_8_BIT_TYPEB_DOUBLE_TYPEB_FLOAT_TYPEB_GRAYSCALE_8_BIT_TYPEB_INT16_TYPEB_INT32_TYPEB_INT64_TYPEB_INT8_TYPEB_LARGE_ICON_TYPEB_MEDIA_PARAMETER_GROUP_TYPEB_MEDIA_PARAMETER_TYPEB_MEDIA_PARAMETER_WEB_TYPEB_MESSAGE_TYPEB_MESSENGER_TYPEB_MIME_TYPEB_MINI_ICON_TYPEB_MONOCHROME_1_BIT_TYPEB_OBJECT_TYPEB_OFF_T_TYPEB_PATTERN_TYPEB_POINTER_TYPEB_POINT_TYPEB_PROPERTY_INFO_TYPEB_RAW_TYPEB_RECT_TYPEB_REF_TYPEB_RGB_32_BIT_TYPEB_RGB_COLOR_TYPEB_SIZE_TYPEB_SIZE_T_TYPEB_SSIZE_T_TYPEB_STRING_TYPEB_STRING_LIST_TYPEB_TIME_TYPEB_UINT16_TYPEB_UINT32_TYPEB_UINT64_TYPEB_UINT8_TYPEB_VECTOR_ICON_TYPEB_XATTR_TYPEB_NETWORK_ADDRESS_TYPEB_MIME_STRING_TYPEB_ASCII_TYPEB_APP_IMAGE_SYMBOLcreate_areaclone_areafind_areaarea_fordelete_arearesize_areaset_area_protection_get_area_infoarea_info_get_next_area_infocreate_portfind_portread_portread_port_etcwrite_portwrite_port_etcclose_portdelete_portport_buffer_sizeport_buffer_size_etcport_countset_port_owner_get_port_infoport_info_get_next_port_info_get_port_message_info_etcport_message_infocreate_semdelete_semacquire_semacquire_sem_etcrelease_semrelease_sem_etcswitch_semswitch_sem_etcget_sem_countset_sem_owner_get_sem_infosem_info_get_next_sem_infokill_team_get_team_infoteam_info_get_next_team_infospawn_threadkill_threadresume_threadsuspend_threadrename_threadset_thread_prioritysuggest_thread_priorityestimate_max_scheduling_latencyexit_threadwait_for_threadon_exit_threadfind_threadget_scheduler_modeset_scheduler_modereceive_datasnooze_etcsnooze_until_get_thread_info_get_next_thread_infoget_pthread_thread_id_get_team_usage_infoteam_usage_inforeal_time_clockset_real_time_clockreal_time_clock_usecssystem_timesystem_time_nsecsset_alarmdebuggerdisable_debugger_get_cpu_info_etcget_cpu_topology_infocpu_topology_node_infois_computer_onis_computer_on_fireset_signal_stackwait_for_objectsobject_wait_infowait_for_objects_etcfs_read_attr// kernel/fs_attr.hfs_write_attrfs_remove_attrfs_stat_attrattr_infofs_open_attrfs_fopen_attrfs_close_attrfs_open_attr_dirfs_lopen_attr_dirfs_fopen_attr_dirfs_close_attr_dirfs_read_attr_dirfs_rewind_attr_dirfs_create_index// kernel/fs_image.hfs_remove_indexfs_stat_indexindex_infofs_open_index_dirfs_close_index_dirfs_read_index_dirfs_rewind_index_dirdev_for_pathnext_devfs_stat_devfs_infofs_open_queryfs_open_live_queryfs_close_queryfs_read_queryget_path_for_direntfs_mount_volumefs_unmount_volumeload_imageload_add_onunload_add_onget_image_symbolget_nth_image_symbolclear_caches_get_image_infoimage_info_get_next_image_infofind_pathpath_base_directoryfind_path_etcfind_path_for_pathfind_path_for_path_etcfind_pathsfind_paths_etcfind_directorydirectory_whichget_cpuidcpuid_info// set_timezone() is deprecated and a no-opget_cpu_info// The following functions are defined as macros in C/C++get_area_infoget_next_area_infoget_port_infoget_next_port_infoget_port_message_info_etcget_sem_infoget_next_sem_infoget_team_infoget_next_team_infoget_team_usage_infoget_thread_infoget_next_thread_infoget_image_infoget_next_image_info// This module contains bindings to the native Haiku API. The Haiku API// originates from BeOS, and it was the original way to perform low level// system and IO operations. The POSIX API was in that era was like a// compatibility layer. In current Haiku development, both the POSIX API and// the Haiku API are considered to be co-equal status. However, they are not// integrated like they are on other UNIX platforms, which means that for many// low level concepts there are two versions, like processes (POSIX) and// teams (Haiku), or pthreads and native threads.// Both the POSIX API and the Haiku API live in libroot.so, the library that is// linked to any binary by default.// This file follows the Haiku API for Haiku R1 beta 2. It is organized by the// C/C++ header files in which the concepts can be found, while adhering to the// style guide for this crate.// Helper macro to generate u32 constants. The Haiku API uses (non-standard)// multi-character constants (like 'UPDA' or 'MSGM') to represent 32 bit// integer constants.__int64_t__quad_t__u_quad_t__intmax_t__uintmax_t__squad_type__uquad_type__sword_type__uword_type__slong32_type__ulong32_type__s64_type__u64_type__ipc_pid_tElf32_SectionElf_EhdrElf32_EhdrElf_ShdrElf32_ShdrElf_SymElf32_SymElf64_SectionElf64_EhdrElf64_ShdrElf64_Sym__s16_type__u16_type__s32_type__u32_type__slongword_type__ulongword_type__u_char__u_short__u_int__u_long__int8_t__int16_t__uint16_t__int32_t__int_least8_t__uint_least8_t__int_least16_t__uint_least16_t__int_least32_t__uint_least32_t__int_least64_t__uint_least64_t__dev_t__ino_t__ino64_t__nlink_t__off64_t__rlim_t__rlim64_t__blkcnt_t__blkcnt64_t__fsblkcnt64_t__fsfilcnt64_t__fsword_t__id_t__clock_t__time_t__useconds_t__suseconds_t__suseconds64_t__daddr_t__key_t__clockid_t__timer_t__blksize_t__fsid_t__ssize_t__syscall_slong_t__syscall_ulong_t__cpu_mask__loff_t__intptr_t__ptrdiff_t__sig_atomic_t_Float32_Float64_Float32x_Float64x__locale_t__locale_structfsid_t__sigset_t__fd_maskfsblkcnt64_tfsfilcnt64_t__pthread_spinlock_t__tss_t__thrd_t__pthread_t__pthread_process_shared__pthread_inheritsched__pthread_contentionscope__pthread_detachstate__pthread_attr__pthread_mutex_protocol__pthread_mutex_type__pthread_mutex_robustness__pthread_mutexattr__pthread_mutex__pthread_condattr__pthread_cond__pthread_rwlockattr__pthread_rwlock__pthread_barrierattr__pthread_barrier__pthread_key__pthread_once__rlimit_resource__rlimit_resource_t__rusage_who__priority_which__sigval_tsigevent_tsigval_tgregset_t19usize__ioctl_dir__ioctl_datum__error_t_codestcp_seqtcp_ca_stateLmid_t// FIXME(hurd): fill this out with a structGLOB_PERIODGLOB_ALTDIRFUNCGLOB_BRACEGLOB_NOMAGICGLOB_TILDEGLOB_ONLYDIRGLOB_TILDE_CHECK// ipc.h// shm.h__FD_SETSIZE__W_CONTINUED__WCOREFLAG__LITTLE_ENDIAN__BIG_ENDIAN__PDP_ENDIAN__BYTE_ORDER__FLOAT_WORD_ORDERBYTE_ORDER// sys/select.h__SIZEOF_PTHREAD_ATTR_T__SIZEOF_PTHREAD_BARRIER_T__SIZEOF_PTHREAD_BARRIERATTR_T__SIZEOF_PTHREAD_ONCE_T__PTHREAD_SPIN_LOCK_INITIALIZERRLIM64_INFINITYNSS_BUFLEN_PASSWD// pwd.hSOCK_TYPE_MASKPF_FILEAF_FILE_SS_SIZEIPV6_2292PKTINFOIPV6_2292HOPOPTSIPV6_2292DSTOPTSIPV6_2292RTHDRIPV6_2292PKTOPTIONSIPV6_2292HOPLIMITIPV6_RXINFOIPV6_TXINFOSCM_SRCINFOIPV6_ROUTER_ALERTIPV6_MTU_DISCOVERIPV6_MTUIPV6_RECVERRIPV6_JOIN_ANYCASTIPV6_LEAVE_ANYCASTIPV6_MINHOPCOUNTIPV6_RXHOPOPTSIPV6_RXDSTOPTSIPV6_RTHDR_LOOSEIPV6_RTHDR_STRICTIPV6_RTHDR_TYPE_0IN_CLASSA_NETIN_CLASSA_NSHIFTIN_CLASSA_HOSTIN_CLASSA_MAXIN_CLASSB_NETIN_CLASSB_NSHIFTIN_CLASSB_HOSTIN_CLASSB_MAXIN_CLASSC_NETIN_CLASSC_NSHIFTIN_CLASSC_HOSTIN_LOOPBACKNETINET_ADDRSTRLENINET6_ADDRSTRLENIPTOS_TOS_MASKIPTOS_PREC_MASKIPTOS_ECN_NOT_ECTIPTOS_MINCOSTIPOPT_COPYIPOPT_CLASS_MASKIPOPT_NUMBER_MASKIPOPT_MEASUREMENTIPOPT_ENDIPOPT_NOOPIPOPT_SECIPOPT_TIMESTAMPIPOPT_SIDIPOPT_RAMAX_IPOPTLENARPOP_REQUESTARPOP_REPLYARPOP_RREQUESTARPOP_RREPLYARPOP_InREQUESTARPOP_InREPLYARPOP_NAKMAX_ADDR_LENARPD_UPDATEARPD_LOOKUPARPD_FLUSHATF_MAGICATF_NETMASKATF_DONTPUBARPHRD_NETROMARPHRD_EETHERARPHRD_AX25ARPHRD_PRONETARPHRD_CHAOSARPHRD_IEEE802ARPHRD_ARCNETARPHRD_APPLETLKARPHRD_DLCIARPHRD_ATMARPHRD_METRICOMARPHRD_IEEE1394ARPHRD_EUI64ARPHRD_INFINIBANDARPHRD_SLIPARPHRD_CSLIPARPHRD_SLIP6ARPHRD_CSLIP6ARPHRD_RSRVDARPHRD_ADAPTARPHRD_ROSEARPHRD_X25ARPHRD_HWX25ARPHRD_CANARPHRD_PPPARPHRD_CISCOARPHRD_HDLCARPHRD_LAPBARPHRD_DDCMPARPHRD_RAWHDLCARPHRD_TUNNELARPHRD_TUNNEL6ARPHRD_FRADARPHRD_SKIPARPHRD_LOOPBACKARPHRD_LOCALTLKARPHRD_BIFARPHRD_SITARPHRD_IPDDPARPHRD_IPGREARPHRD_PIMREGARPHRD_HIPPIARPHRD_ASHARPHRD_ECONETARPHRD_IRDAARPHRD_FCPPARPHRD_FCALARPHRD_FCPLARPHRD_FCFABRICARPHRD_IEEE802_TRARPHRD_IEEE80211ARPHRD_IEEE80211_PRISMARPHRD_IEEE80211_RADIOTAPARPHRD_IEEE802154ARPHRD_VOIDARPHRD_NONE_POSIX_AIO_LISTIO_MAX// bits/posix1_lim.h_POSIX_AIO_MAX_POSIX_CHILD_MAX_POSIX_DELAYTIMER_MAX_POSIX_HOST_NAME_MAX_POSIX_LOGIN_NAME_MAX_POSIX_MQ_OPEN_MAX_POSIX_MQ_PRIO_MAX_POSIX_NGROUPS_MAX_POSIX_OPEN_MAX_POSIX_FD_SETSIZE_POSIX_PATH_MAX_POSIX_RE_DUP_MAX_POSIX_RTSIG_MAX_POSIX_SEM_NSEMS_MAX_POSIX_SEM_VALUE_MAX_POSIX_SIGQUEUE_MAX_POSIX_SYMLINK_MAX_POSIX_SYMLOOP_MAX_POSIX_TIMER_MAX_POSIX_TTY_NAME_MAX_POSIX_TZNAME_MAX_POSIX_QLIMIT_POSIX_HIWAT_POSIX_UIO_MAXIOV_POSIX_CLOCKRES_MIN_POSIX_THREAD_KEYS_MAX_POSIX_THREAD_DESTRUCTOR_ITERATIONS_POSIX_THREAD_THREADS_MAXMAXNAMLEN_PATH_HEQUIV17usize_PATH_HOSTS11usize_PATH_NETWORKS14usize_PATH_NSSWITCH_CONF_PATH_PROTOCOLS_PATH_SERVICESHOST_NOT_FOUNDTRY_AGAINNO_RECOVERYNO_DATANETDB_INTERNALNETDB_SUCCESSNO_ADDRESSIPPORT_RESERVEDSCOPE_DELIMITERGAI_WAITGAI_NOWAITAI_IDNAI_CANONIDNEAI_ADDRFAMILYEAI_INPROGRESSEAI_CANCELEDEAI_NOTCANCELEDEAI_ALLDONEEAI_INTREAI_IDN_ENCODENI_IDNTIME_UTC__LC_CTYPE__LC_NUMERIC__LC_TIME__LC_COLLATE__LC_MONETARY__LC_MESSAGES__LC_ALL__LC_PAPER__LC_NAME__LC_ADDRESS__LC_TELEPHONE__LC_MEASUREMENT__LC_IDENTIFICATIONLC_PAPERLC_NAMELC_ADDRESSLC_TELEPHONELC_MEASUREMENTLC_IDENTIFICATIONLC_PAPER_MASKLC_NAME_MASKLC_ADDRESS_MASKLC_TELEPHONE_MASKLC_MEASUREMENT_MASKLC_IDENTIFICATION_MASK// reboot.hRB_KBDRB_NOBOOTRCRB_ALTBOOTRB_UNIPROCRB_DEBUGGER__SIZEOF_SEM_T_ECHOE_ECHOK_ECHO_ECHONL_ISIG_ICANON_IEXTEN_TOSTOP_NOFLSHTCSASOFTTTYDEF_IFLAGTTYDEF_LFLAGTTYDEF_CFLAGTTYDEF_SPEEDCEOLCERASECMINCQUITCTIMECBRKRTLD_BINDING_MASKDLFO_STRUCT_HAS_EH_DBASEDLFO_STRUCT_HAS_EH_COUNTLM_ID_BASELM_ID_NEWLM// bits/signum_generic.hSIGLOST__SIGRTMIN__SIGRTMAX_NSIGNSIG// bits/sigaction.hSA_INTERRUPTFPC_IE// bits/sigcontext.hFPC_IMFPC_DEFPC_DMFPC_ZEFPC_ZMFPC_OEFPC_OMFPC_UEFPC_PEFPC_PCFPC_PC_24FPC_PC_53FPC_PC_64FPC_RCFPC_RC_RNFPC_RC_RDFPC_RC_RUFPC_RC_CHOPFPC_ICFPC_IC_PROJFPC_IC_AFFFPS_IEFPS_DEFPS_ZEFPS_OEFPS_UEFPS_PEFPS_SFFPS_ESFPS_C0FPS_C1FPS_C2FPS_TOSFPS_TOS_SHIFTFPS_C3FPS_BUSYFPE_INTOVF_TRAPFPE_INTDIV_FAULTFPE_FLTOVF_FAULTFPE_FLTDIV_FAULTFPE_FLTUND_FAULTFPE_SUBRNG_FAULTFPE_FLTDNR_FAULTFPE_FLTINX_FAULTFPE_EMERR_FAULTFPE_EMBND_FAULTILL_INVOPR_FAULTILL_STACK_FAULTILL_FPEOPR_FAULTDBG_SINGLE_TRAPDBG_BRKPNT_FAULT__NGREGNGREG// bits/sigstack.h__S_IFMT__S_IFDIR__S_IFCHR__S_IFBLK__S_IFREG__S_IFLNK__S_IFSOCK__S_IFIFO__S_ISUID__S_ISGID__S_ISVTX__S_IREAD__S_IWRITE__S_IEXECS_INOCACHES_IUSEUNKS_IUNKNOWNS_IUNKSHIFTS_IPTRANSS_IATRANSS_IROOTS_ITRANSS_IMMAP0CMASKACCESSPERMSALLPERMSDEFFILEMODESTATX_TYPESTATX_MODESTATX_NLINKSTATX_UIDSTATX_GIDSTATX_ATIMESTATX_MTIMESTATX_CTIMESTATX_INOSTATX_SIZESTATX_BLOCKSSTATX_BASIC_STATSSTATX_ALLSTATX_BTIMESTATX_MNT_IDSTATX_DIOALIGNSTATX__RESERVEDSTATX_ATTR_COMPRESSEDSTATX_ATTR_IMMUTABLESTATX_ATTR_APPENDSTATX_ATTR_NODUMPSTATX_ATTR_ENCRYPTEDSTATX_ATTR_AUTOMOUNTSTATX_ATTR_MOUNT_ROOTSTATX_ATTR_VERITYSTATX_ATTR_DAXTABLDISCCRMODODDPEVENPANYPNLDELAYNL2NL3TBDELAYCRDELAYVTDELAYBSDELAYALLDELAYCRTBSPRTERACRTERATILDELITOUTNOHANGL001000CRTKILPASS8CTLECHDECCTQO_NORWO_NOLINKO_NOTRANSO_HURDO_IGNORE_CTTYFREADFWRITEFCREATFEXCLFTRUNCFNOCTTYFFSYNCFSYNCFAPPENDFNONBLOCKFNDELAYAT_STATX_SYNC_TYPEAT_STATX_SYNC_AS_STATAT_STATX_FORCE_SYNCAT_STATX_DONT_SYNCAT_RECURSIVERWF_HIPRI// sys/uio.hRWF_DSYNCRWF_SYNCRWF_NOWAITRWF_APPENDEBACKGROUNDEDIEDEGREGIOUSEIEIOEGRATUITOUSEMACH_SEND_IN_PROGRESSEMACH_SEND_INVALID_DATAEMACH_SEND_INVALID_DESTEMACH_SEND_TIMED_OUTEMACH_SEND_WILL_NOTIFYEMACH_SEND_NOTIFY_IN_PROGRESSEMACH_SEND_INTERRUPTEDEMACH_SEND_MSG_TOO_SMALLEMACH_SEND_INVALID_REPLYEMACH_SEND_INVALID_RIGHTEMACH_SEND_INVALID_NOTIFYEMACH_SEND_INVALID_MEMORYEMACH_SEND_NO_BUFFEREMACH_SEND_NO_NOTIFYEMACH_SEND_INVALID_TYPEEMACH_SEND_INVALID_HEADEREMACH_RCV_IN_PROGRESSEMACH_RCV_INVALID_NAMEEMACH_RCV_TIMED_OUTEMACH_RCV_TOO_LARGEEMACH_RCV_INTERRUPTEDEMACH_RCV_PORT_CHANGEDEMACH_RCV_INVALID_NOTIFYEMACH_RCV_INVALID_DATAEMACH_RCV_PORT_DIEDEMACH_RCV_IN_SETEMACH_RCV_HEADER_ERROREMACH_RCV_BODY_ERROREKERN_INVALID_ADDRESSEKERN_PROTECTION_FAILUREEKERN_NO_SPACEEKERN_INVALID_ARGUMENTEKERN_FAILUREEKERN_RESOURCE_SHORTAGEEKERN_NOT_RECEIVEREKERN_NO_ACCESSEKERN_MEMORY_FAILUREEKERN_MEMORY_ERROREKERN_NOT_IN_SETEKERN_NAME_EXISTSEKERN_ABORTEDEKERN_INVALID_NAMEEKERN_INVALID_TASKEKERN_INVALID_RIGHTEKERN_INVALID_VALUEEKERN_UREFS_OVERFLOWEKERN_INVALID_CAPABILITYEKERN_RIGHT_EXISTSEKERN_INVALID_HOSTEKERN_MEMORY_PRESENTEKERN_WRITE_PROTECTION_FAILUREEKERN_TERMINATEDEKERN_TIMEDOUTEKERN_INTERRUPTEDEMIG_TYPE_ERROREMIG_REPLY_MISMATCHEMIG_REMOTE_ERROREMIG_BAD_IDEMIG_BAD_ARGUMENTSEMIG_NO_REPLYEMIG_EXCEPTIONEMIG_ARRAY_TOO_LARGEEMIG_SERVER_DIEDEMIG_DESTROY_REQUESTED_IO_ERRORED_WOULD_BLOCKED_NO_SUCH_DEVICEED_ALREADY_OPENED_DEVICE_DOWNED_INVALID_OPERATIONED_INVALID_RECNUMED_INVALID_SIZEED_NO_MEMORYED_READ_ONLY_HURD_ERRNOS// sched.h_BITS_TYPES_STRUCT_SCHED_PARAM__CPU_SETSIZEPTHREAD_SPINLOCK_INITIALIZERTCP_NOTSENT_LOWATTCP_CC_INFOTCP_SAVE_SYNTCP_SAVED_SYNTCP_REPAIR_WINDOWTCP_FASTOPEN_CONNECTTCP_ULPTCP_MD5SIG_EXTTCP_FASTOPEN_KEYTCP_FASTOPEN_NO_COOKIETCP_ZEROCOPY_RECEIVETCP_INQTCP_CM_INQTCP_TX_DELAYTCP_REPAIR_ONTCP_REPAIR_OFFTCP_REPAIR_OFF_NO_WPINT8_MIN// stdint.hINT16_MININT32_MININT8_MAXINT16_MAXINT32_MAXUINT8_MAXUINT16_MAXUINT32_MAXINT_LEAST8_MININT_LEAST16_MININT_LEAST32_MININT_LEAST8_MAXINT_LEAST16_MAXINT_LEAST32_MAXUINT_LEAST8_MAXUINT_LEAST16_MAXUINT_LEAST32_MAXINT_FAST8_MININT_FAST16_MININT_FAST32_MININT_FAST8_MAXINT_FAST16_MAXINT_FAST32_MAXUINT_FAST8_MAXUINT_FAST16_MAXUINT_FAST32_MAXINTPTR_MININTPTR_MAXUINTPTR_MAXPTRDIFF_MINPTRDIFF_MAXSIG_ATOMIC_MINSIG_ATOMIC_MAXSIZE_MAXINT8_WIDTHUINT8_WIDTHINT16_WIDTHUINT16_WIDTHINT32_WIDTHUINT32_WIDTHINT64_WIDTHUINT64_WIDTHINT_LEAST8_WIDTHUINT_LEAST8_WIDTHINT_LEAST16_WIDTHUINT_LEAST16_WIDTHINT_LEAST32_WIDTHUINT_LEAST32_WIDTHINT_LEAST64_WIDTHUINT_LEAST64_WIDTHINT_FAST8_WIDTHUINT_FAST8_WIDTHINT_FAST16_WIDTHUINT_FAST16_WIDTHINT_FAST32_WIDTHUINT_FAST32_WIDTHINT_FAST64_WIDTHUINT_FAST64_WIDTHINTPTR_WIDTHUINTPTR_WIDTHINTMAX_WIDTHUINTMAX_WIDTHPTRDIFF_WIDTHSIG_ATOMIC_WIDTHSIZE_WIDTHWCHAR_WIDTHWINT_WIDTHTH_FINTH_SYNTH_RSTTH_PUSHTH_ACKTH_URGTCPOPT_EOLTCPOPT_NOPTCPOPT_MAXSEGTCPOLEN_MAXSEGTCPOPT_WINDOWTCPOLEN_WINDOWTCPOPT_SACK_PERMITTEDTCPOLEN_SACK_PERMITTEDTCPOPT_SACKTCPOPT_TIMESTAMPTCPOLEN_TIMESTAMPTCPOLEN_TSTAMP_APPATCPOPT_TSTAMP_HDRTCP_MSSTCP_MAXWINTCP_MAX_WINSHIFTTCPI_OPT_TIMESTAMPSTCPI_OPT_SACKTCPI_OPT_WSCALETCPI_OPT_ECNTCPI_OPT_ECN_SEENTCPI_OPT_SYN_DATATCP_MD5SIG_MAXKEYLENTCP_MD5SIG_FLAG_PREFIXTCP_COOKIE_MINTCP_COOKIE_MAXTCP_COOKIE_PAIR_SIZETCP_COOKIE_IN_ALWAYSTCP_COOKIE_OUT_NEVERTCP_S_DATA_INTCP_S_DATA_OUTTCP_MSS_DEFAULTTCP_MSS_DESIREDWCOREFLAGWAIT_ANYWAIT_MYPGRPMAP_INHERITPOSIX_MADV_WONTNEEDPOSIX_SPAWN_USEVFORK// random.h_SC_EQUIV_CLASS_MAX_SC_CHARCLASS_NAME_MAX_SC_PII_SC_PII_XTI_SC_PII_SOCKET_SC_PII_INTERNET_SC_PII_OSI_SC_PII_INTERNET_STREAM_SC_PII_INTERNET_DGRAM_SC_PII_OSI_COTS_SC_PII_OSI_CLTS_SC_PII_OSI_M_SC_CHAR_BIT_SC_CHAR_MAX_SC_CHAR_MIN_SC_INT_MAX_SC_INT_MIN_SC_LONG_BIT_SC_WORD_BIT_SC_MB_LEN_MAX_SC_SSIZE_MAX_SC_SCHAR_MAX_SC_SCHAR_MIN_SC_SHRT_MAX_SC_SHRT_MIN_SC_UCHAR_MAX_SC_UINT_MAX_SC_ULONG_MAX_SC_USHRT_MAX_SC_NL_ARGMAX_SC_NL_LANGMAX_SC_NL_MSGMAX_SC_NL_NMAX_SC_NL_SETMAX_SC_NL_TEXTMAX_SC_BASE_SC_C_LANG_SUPPORT_SC_C_LANG_SUPPORT_R_SC_DEVICE_IO_SC_DEVICE_SPECIFIC_SC_DEVICE_SPECIFIC_R_SC_FD_MGMT_SC_FIFO_SC_FILE_ATTRIBUTES_SC_FILE_SYSTEM_SC_MULTI_PROCESS_SC_SINGLE_PROCESS_SC_NETWORKING_SC_REGEX_VERSION_SC_SIGNALS_SC_SYSTEM_DATABASE_SC_SYSTEM_DATABASE_R_SC_USER_GROUPS_SC_USER_GROUPS_R_SC_MINSIGSTKSZ_SC_SIGSTKSZ_CS_V6_WIDTH_RESTRICTED_ENVS_CS_GNU_LIBC_VERSION_CS_GNU_LIBPTHREAD_VERSION_CS_V5_WIDTH_RESTRICTED_ENVS_CS_V7_WIDTH_RESTRICTED_ENVS_CS_LFS_CFLAGS_CS_LFS_LDFLAGS_CS_LFS_LIBS_CS_LFS_LINTFLAGS_CS_LFS64_CFLAGS_CS_LFS64_LDFLAGS_CS_LFS64_LIBS_CS_LFS64_LINTFLAGS_CS_XBS5_ILP32_OFF32_CFLAGS_CS_XBS5_ILP32_OFF32_LDFLAGS_CS_XBS5_ILP32_OFF32_LIBS_CS_XBS5_ILP32_OFF32_LINTFLAGS_CS_XBS5_ILP32_OFFBIG_CFLAGS_CS_XBS5_ILP32_OFFBIG_LDFLAGS_CS_XBS5_ILP32_OFFBIG_LIBS_CS_XBS5_ILP32_OFFBIG_LINTFLAGS_CS_XBS5_LP64_OFF64_CFLAGS_CS_XBS5_LP64_OFF64_LDFLAGS_CS_XBS5_LP64_OFF64_LIBS_CS_XBS5_LP64_OFF64_LINTFLAGS_CS_XBS5_LPBIG_OFFBIG_CFLAGS_CS_XBS5_LPBIG_OFFBIG_LDFLAGS_CS_XBS5_LPBIG_OFFBIG_LIBS_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS_CS_POSIX_V6_ILP32_OFF32_CFLAGS_CS_POSIX_V6_ILP32_OFF32_LDFLAGS_CS_POSIX_V6_ILP32_OFF32_LIBS_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS_CS_POSIX_V6_ILP32_OFFBIG_LIBS_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS_CS_POSIX_V6_LP64_OFF64_CFLAGS_CS_POSIX_V6_LP64_OFF64_LDFLAGS_CS_POSIX_V6_LP64_OFF64_LIBS_CS_POSIX_V6_LP64_OFF64_LINTFLAGS_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS_CS_POSIX_V6_LPBIG_OFFBIG_LIBS_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS_CS_POSIX_V7_ILP32_OFF32_CFLAGS_CS_POSIX_V7_ILP32_OFF32_LDFLAGS_CS_POSIX_V7_ILP32_OFF32_LIBS_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS_CS_POSIX_V7_ILP32_OFFBIG_LIBS_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS_CS_POSIX_V7_LP64_OFF64_CFLAGS_CS_POSIX_V7_LP64_OFF64_LDFLAGS_CS_POSIX_V7_LP64_OFF64_LIBS_CS_POSIX_V7_LP64_OFF64_LINTFLAGS_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS_CS_POSIX_V7_LPBIG_OFFBIG_LIBS_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS_CS_V6_ENV_CS_V7_ENVPTHREAD_MUTEX_TIMEDRLIMIT_OFILE__UT_LINESIZE__UT_NAMESIZE__UT_HOSTSIZESO_STYLEIPPROTO_ETHERNETIPPROTO_MPTCPIPPORT_ECHOIPPORT_DISCARDIPPORT_SYSTATIPPORT_DAYTIMEIPPORT_NETSTATIPPORT_FTPIPPORT_TELNETIPPORT_SMTPIPPORT_TIMESERVERIPPORT_NAMESERVERIPPORT_WHOISIPPORT_MTPIPPORT_TFTPIPPORT_RJEIPPORT_FINGERIPPORT_TTYLINKIPPORT_SUPDUPIPPORT_EXECSERVERIPPORT_LOGINSERVERIPPORT_CMDSERVERIPPORT_EFSSERVERIPPORT_BIFFUDPIPPORT_WHOSERVERIPPORT_ROUTESERVERIPPORT_USERRESERVEDST_RELATIMERTLD_DI_LMIDRTLD_DI_CONFIGADDRRTLD_DI_SERINFORTLD_DI_SERINFOSIZERTLD_DI_ORIGINRTLD_DI_PROFILENAMERTLD_DI_PROFILEOUTRTLD_DI_TLS_MODIDRTLD_DI_TLS_DATARTLD_DI_PHDRRTLD_DI_MAXREG_GSREG_FSREG_ESREG_DSREG_EDIREG_ESIREG_EBPREG_ESPREG_EBXREG_EDXREG_ECXREG_EAXREG_TRAPNOREG_ERRREG_EIPREG_CSREG_EFLREG_UESPREG_SSIOC_8IOC_16IOC_32IOC_64TCP_ESTABLISHEDTCP_SYN_SENTTCP_SYN_RECVTCP_FIN_WAIT1TCP_FIN_WAIT2TCP_TIME_WAITTCP_CLOSETCP_CLOSE_WAITTCP_LAST_ACKTCP_LISTENTCP_CLOSINGTCP_CA_OpenTCP_CA_DisorderTCP_CA_CWRTCP_CA_RecoveryTCP_CA_LossTCP_NO_QUEUETCP_RECV_QUEUETCP_SEND_QUEUETCP_QUEUES_NR_UTSNAME_LENGTH// Non-public helper constants__libc_current_sigrtmin__libc_current_sigrtmaxpreadv64pwritev64fread_unlockedsendfile64fgetpwent_rfgetgrent_rputpwentputgrentgetmntent_r// mntent.haddmntent__pthread_equalfstatat64openat64tmpfile64// Added in `glibc` 2.34execveat// posix/spawn.hposix_spawn_file_actions_addchdir_np// Added in `glibc` 2.29posix_spawn_file_actions_addfchdir_npposix_spawn_file_actions_addclosefrom_npposix_spawn_file_actions_addtcsetpgrp_np// Added in `glibc` 2.35readdir64readdir64_rsyncfsfallocate64mallinfo2malloc_infomalloc_trimglob64glob64_tglobfree64"__xpg_basename"posix_basename/// POSIX version of `basename(3)`, defined in `libgen.h`."basename"gnu_basename/// GNU version of `basename(3)`, defined in `string.h`.dlmopendladdr1gnu_get_libc_releasegnu_get_libc_version// constSYS_restart_syscallSYS_exitSYS_forkSYS_readSYS_writeSYS_openSYS_closeSYS_creatSYS_linkSYS_unlinkSYS_execveSYS_chdirSYS_mknodSYS_chmodSYS_lchownSYS_lseekSYS_getpidSYS_mountSYS_setuidSYS_getuidSYS_ptraceSYS_pauseSYS_accessSYS_niceSYS_syncSYS_killSYS_renameSYS_mkdirSYS_rmdirSYS_dupSYS_pipeSYS_timesSYS_brkSYS_setgidSYS_getgidSYS_geteuidSYS_getegidSYS_acctSYS_umount2SYS_ioctlSYS_fcntlSYS_setpgidSYS_umaskSYS_chrootSYS_ustatSYS_dup2SYS_getppidSYS_getpgrpSYS_setsidSYS_sigactionSYS_setreuidSYS_setregidSYS_sigsuspendSYS_sigpendingSYS_sethostnameSYS_setrlimitSYS_getrusageSYS_gettimeofdaySYS_settimeofdaySYS_getgroupsSYS_setgroupsSYS_symlinkSYS_readlinkSYS_uselibSYS_swaponSYS_rebootSYS_munmapSYS_truncateSYS_ftruncateSYS_fchmodSYS_fchownSYS_getprioritySYS_setprioritySYS_statfsSYS_fstatfsSYS_syslogSYS_setitimerSYS_getitimerSYS_statSYS_lstatSYS_fstatSYS_vhangupSYS_wait4SYS_swapoffSYS_sysinfoSYS_fsyncSYS_sigreturnSYS_cloneSYS_setdomainnameSYS_unameSYS_adjtimexSYS_mprotectSYS_sigprocmaskSYS_init_moduleSYS_delete_moduleSYS_quotactlSYS_getpgidSYS_fchdirSYS_bdflushSYS_sysfsSYS_personalitySYS_setfsuidSYS_setfsgidSYS_getdentsSYS_flockSYS_msyncSYS_readvSYS_writevSYS_getsidSYS_fdatasyncSYS_mlockSYS_munlockSYS_mlockallSYS_munlockallSYS_sched_setparamSYS_sched_getparamSYS_sched_setschedulerSYS_sched_getschedulerSYS_sched_yieldSYS_sched_get_priority_maxSYS_sched_get_priority_minSYS_sched_rr_get_intervalSYS_nanosleepSYS_mremapSYS_setresuidSYS_getresuidSYS_pollSYS_nfsservctlSYS_setresgidSYS_getresgidSYS_prctlSYS_rt_sigreturnSYS_rt_sigactionSYS_rt_sigprocmaskSYS_rt_sigpendingSYS_rt_sigtimedwaitSYS_rt_sigqueueinfoSYS_rt_sigsuspendSYS_pread64SYS_pwrite64SYS_chownSYS_getcwdSYS_capgetSYS_capsetSYS_sigaltstackSYS_sendfileSYS_vforkSYS_ugetrlimitSYS_mmap2SYS_truncate64SYS_ftruncate64SYS_stat64SYS_lstat64SYS_fstat64SYS_lchown32SYS_getuid32SYS_getgid32SYS_geteuid32SYS_getegid32SYS_setreuid32SYS_setregid32SYS_getgroups32SYS_setgroups32SYS_fchown32SYS_setresuid32SYS_getresuid32SYS_setresgid32SYS_getresgid32SYS_chown32SYS_setuid32SYS_setgid32SYS_setfsuid32SYS_setfsgid32SYS_getdents64SYS_pivot_rootSYS_mincoreSYS_madviseSYS_fcntl64SYS_gettidSYS_readaheadSYS_setxattrSYS_lsetxattrSYS_fsetxattrSYS_getxattrSYS_lgetxattrSYS_fgetxattrSYS_listxattrSYS_llistxattrSYS_flistxattrSYS_removexattrSYS_lremovexattrSYS_fremovexattrSYS_tkillSYS_sendfile64SYS_futexSYS_sched_setaffinitySYS_sched_getaffinitySYS_io_setupSYS_io_destroySYS_io_geteventsSYS_io_submitSYS_io_cancelSYS_exit_groupSYS_lookup_dcookieSYS_epoll_createSYS_epoll_ctlSYS_epoll_waitSYS_remap_file_pagesSYS_set_tid_addressSYS_timer_createSYS_timer_settimeSYS_timer_gettimeSYS_timer_getoverrunSYS_timer_deleteSYS_clock_settimeSYS_clock_gettimeSYS_clock_getresSYS_clock_nanosleepSYS_statfs64SYS_fstatfs64SYS_tgkillSYS_utimesSYS_arm_fadvise64_64SYS_pciconfig_iobaseSYS_pciconfig_readSYS_pciconfig_writeSYS_mq_openSYS_mq_unlinkSYS_mq_timedsendSYS_mq_timedreceiveSYS_mq_notifySYS_mq_getsetattrSYS_waitidSYS_socketSYS_bindSYS_connectSYS_listenSYS_acceptSYS_getsocknameSYS_getpeernameSYS_socketpairSYS_sendSYS_sendtoSYS_recvSYS_recvfromSYS_shutdownSYS_setsockoptSYS_getsockoptSYS_sendmsgSYS_recvmsgSYS_semopSYS_semgetSYS_semctlSYS_msgsndSYS_msgrcvSYS_msggetSYS_msgctlSYS_shmatSYS_shmdtSYS_shmgetSYS_shmctlSYS_add_keySYS_request_keySYS_keyctlSYS_semtimedopSYS_vserverSYS_ioprio_setSYS_ioprio_getSYS_inotify_initSYS_inotify_add_watchSYS_inotify_rm_watchSYS_mbindSYS_get_mempolicySYS_set_mempolicySYS_openatSYS_mkdiratSYS_mknodatSYS_fchownatSYS_futimesatSYS_fstatat64SYS_unlinkatSYS_renameatSYS_linkatSYS_symlinkatSYS_readlinkatSYS_fchmodatSYS_faccessatSYS_pselect6SYS_ppollSYS_unshareSYS_set_robust_listSYS_get_robust_listSYS_spliceSYS_arm_sync_file_rangeSYS_teeSYS_vmspliceSYS_move_pagesSYS_getcpuSYS_epoll_pwaitSYS_kexec_loadSYS_utimensatSYS_signalfdSYS_timerfd_createSYS_eventfdSYS_fallocateSYS_timerfd_settimeSYS_timerfd_gettimeSYS_signalfd4SYS_eventfd2SYS_epoll_create1SYS_dup3SYS_pipe2SYS_inotify_init1SYS_preadvSYS_pwritevSYS_rt_tgsigqueueinfoSYS_perf_event_openSYS_recvmmsgSYS_accept4SYS_fanotify_initSYS_fanotify_markSYS_prlimit64SYS_name_to_handle_atSYS_open_by_handle_atSYS_clock_adjtimeSYS_syncfsSYS_sendmmsgSYS_setnsSYS_process_vm_readvSYS_process_vm_writevSYS_kcmpSYS_finit_moduleSYS_sched_setattrSYS_sched_getattrSYS_renameat2SYS_seccompSYS_getrandomSYS_memfd_createSYS_bpfSYS_execveatSYS_userfaultfdSYS_membarrierSYS_mlock2SYS_copy_file_rangeSYS_preadv2SYS_pwritev2SYS_pkey_mprotectSYS_pkey_allocSYS_pkey_freeSYS_statxSYS_pidfd_send_signalSYS_io_uring_setupSYS_io_uring_enterSYS_io_uring_registerSYS_open_treeSYS_move_mountSYS_fsopenSYS_fsconfigSYS_fsmountSYS_fspickSYS_pidfd_openSYS_clone3SYS_close_rangeSYS_openat2SYS_pidfd_getfdSYS_faccessat2SYS_process_madviseSYS_epoll_pwait2SYS_mount_setattrSYS_quotactl_fdSYS_landlock_create_rulesetSYS_landlock_add_ruleSYS_landlock_restrict_selfSYS_process_mreleaseSYS_futex_waitvSYS_set_mempolicy_home_nodeREG_R0// offsets in mcontext_t.gregs from sys/ucontext.hREG_R1REG_R2REG_R3REG_R4REG_R5REG_R6REG_R7REG_R8REG_R9REG_R10REG_R11REG_R12REG_R13REG_R14REG_R15AT_SYSINFO_EHDR// From NDK's asm/auxvec.h// These constants must be of the same type of sigaction.sa_flags__CPU_BITStimegm64// The following definitions are correct for arm and i686,// but may be wrong for mips// Syscall tableSYS_waitpidSYS_timeSYS_breakSYS_oldstatSYS_umountSYS_stimeSYS_alarmSYS_oldfstatSYS_utimeSYS_sttySYS_gttySYS_ftimeSYS_profSYS_signalSYS_lockSYS_mpxSYS_ulimitSYS_oldoldunameSYS_sgetmaskSYS_ssetmaskSYS_getrlimitSYS_selectSYS_oldlstatSYS_readdirSYS_mmapSYS_profilSYS_iopermSYS_socketcallSYS_oldunameSYS_ioplSYS_idleSYS_vm86oldSYS_ipcSYS_modify_ldtSYS_create_moduleSYS_get_kernel_symsSYS_afs_syscall// FIXME(android): SYS__llseek is in the NDK sources but for some reason is//        not available in the tests// pub const SYS__llseek: c_long = 140;// FIXME(android): SYS__newselect is in the NDK sources but for some reason is// pub const SYS__newselect: c_long = 142;// pub const SYS__sysctl: c_long = 149;SYS_vm86SYS_query_moduleSYS_getpmsgSYS_putpmsgSYS_set_thread_areaSYS_get_thread_areaSYS_fadvise64SYS_fadvise64_64SYS_migrate_pagesSYS_sync_file_rangeSYS_memfd_secretORIG_EAXEIPEFLUESPAT_SYSINFOAT_VECTOR_SIZE_ARCHSYS_ACCEPT4// socketcall values from linux/net.h (only the needed ones, and not public)HWCAP_FP// From NDK's asm/hwcap.hHWCAP_ASIMDHWCAP_EVTSTRMHWCAP_AESHWCAP_PMULLHWCAP_SHA1HWCAP_SHA2HWCAP_CRC32HWCAP_ATOMICSHWCAP_FPHPHWCAP_ASIMDHPHWCAP_CPUIDHWCAP_ASIMDRDMHWCAP_JSCVTHWCAP_FCMAHWCAP_LRCPCHWCAP_DCPOPHWCAP_SHA3HWCAP_SM3HWCAP_SM4HWCAP_ASIMDDPHWCAP_SHA512HWCAP_SVEHWCAP_ASIMDFHMHWCAP_DITHWCAP_USCATHWCAP_ILRCPCHWCAP_FLAGMHWCAP_SSBSHWCAP_SBHWCAP_PACAHWCAP_PACGHWCAP2_DCPODPHWCAP2_SVE2HWCAP2_SVEAESHWCAP2_SVEPMULLHWCAP2_SVEBITPERMHWCAP2_SVESHA3HWCAP2_SVESM4HWCAP2_FLAGM2HWCAP2_FRINTHWCAP2_SVEI8MMHWCAP2_SVEF32MMHWCAP2_SVEF64MMHWCAP2_SVEBF16HWCAP2_I8MMHWCAP2_BF16HWCAP2_DGHHWCAP2_RNGHWCAP2_BTIHWCAP2_MTEHWCAP2_ECVHWCAP2_AFPHWCAP2_RPRESHWCAP2_MTE3HWCAP2_SMEHWCAP2_SME_I16I64HWCAP2_SME_F64F64HWCAP2_SME_I8I32HWCAP2_SME_F16F32HWCAP2_SME_B16F32HWCAP2_SME_F32F32HWCAP2_SME_FA64HWCAP2_WFXTHWCAP2_EBF16HWCAP2_SVE_EBF16SYS_arch_specific_syscallSYS_syscallsPROT_BTIPROT_MTE__system_property_waitprop_info// The following definitions are correct for aarch64 and x86_64,// but may be wrong for mips64COMPAT_HWCAP_ISA_ICOMPAT_HWCAP_ISA_MCOMPAT_HWCAP_ISA_ACOMPAT_HWCAP_ISA_FCOMPAT_HWCAP_ISA_DCOMPAT_HWCAP_ISA_CAT_L1I_CACHESIZEAT_L1I_CACHEGEOMETRYAT_L1D_CACHESIZEAT_L1D_CACHEGEOMETRYAT_L2_CACHESIZEAT_L2_CACHEGEOMETRYAT_L3_CACHESIZEAT_L3_CACHEGEOMETRY// FIXME(android): SYS__sysctl is in the NDK sources but for some reason is// pub const SYS__sysctl: c_long = 156;SYS_arch_prctlSYS_tuxcallSYS_securitySYS_epoll_ctl_oldSYS_epoll_wait_oldSYS_newfstatatSYS_kexec_file_loadREG_RDIREG_RSIREG_RBPREG_RBXREG_RDXREG_RAXREG_RCXREG_RSPREG_RIPREG_CSGSFSREG_OLDMASKREG_CR2__CPU_BITTYPE__kernel_loff_t__kernel_pid_t// these structs sit behind a heap allocation on Android// sys/eventfd.h// linux/falloc.hFALLOC_FL_NO_HIDE_STALEF_SEAL_FUTURE_WRITEF_SEAL_EXECSOL_SCTPSOL_IPXSOL_AX25SOL_ATALKSOL_NETROMSOL_ROSEDCCP_SOCKOPT_PACKET_SIZE/* DCCP socket options */DCCP_SOCKOPT_SERVICEDCCP_SOCKOPT_CHANGE_LDCCP_SOCKOPT_CHANGE_RDCCP_SOCKOPT_GET_CUR_MPSDCCP_SOCKOPT_SERVER_TIMEWAITDCCP_SOCKOPT_SEND_CSCOVDCCP_SOCKOPT_RECV_CSCOVDCCP_SOCKOPT_AVAILABLE_CCIDSDCCP_SOCKOPT_CCIDDCCP_SOCKOPT_TX_CCIDDCCP_SOCKOPT_RX_CCIDDCCP_SOCKOPT_QPOLICY_IDDCCP_SOCKOPT_QPOLICY_TXQLENDCCP_SOCKOPT_CCID_RX_INFODCCP_SOCKOPT_CCID_TX_INFODCCP_SERVICE_LIST_MAX_LEN/// maximum number of services provided on the same listening portSO_ATTACH_FILTERSO_DETACH_FILTERSO_GET_FILTERSO_PEERSECSO_PASSSEC// pub const SO_TIMESTAMPNS_OLD: c_int = 35;SO_TIMESTAMPING// pub const SO_TIMESTAMPING_OLD: c_int = 37;SCM_TIMESTAMPING_OPT_STATSSCM_TIMESTAMPING_PKTINFOSO_TIMESTAMP_NEWSO_TIMESTAMPNS_NEWSO_TIMESTAMPING_NEWSCM_TIMESTAMPNS// Defined in unix/linux_like/mod.rs// pub const SCM_TIMESTAMP: c_int = SO_TIMESTAMP;SCM_TIMESTAMPINGPTRACE_SECCOMP_GET_METADATAPTRACE_EVENT_STOPTCGETS2TCSETS2TCSETSW2TCSETSF2KEXEC_ON_CRASH// linux/kexec.hKEXEC_PRESERVE_CONTEXTKEXEC_ARCH_MASKKEXEC_FILE_UNLOADKEXEC_FILE_ON_CRASHKEXEC_FILE_NO_INITRAMFSLINUX_REBOOT_MAGIC1LINUX_REBOOT_MAGIC2LINUX_REBOOT_MAGIC2ALINUX_REBOOT_MAGIC2BLINUX_REBOOT_MAGIC2CLINUX_REBOOT_CMD_RESTARTLINUX_REBOOT_CMD_HALTLINUX_REBOOT_CMD_CAD_ONLINUX_REBOOT_CMD_CAD_OFFLINUX_REBOOT_CMD_POWER_OFFLINUX_REBOOT_CMD_RESTART2LINUX_REBOOT_CMD_SW_SUSPENDLINUX_REBOOT_CMD_KEXECBOTHERBLKIOMINBLKIOOPTBLKSSZGETBLKPBSZGETNETLINK_UNUSEDNETLINK_USERSOCKNETLINK_FIREWALLNETLINK_SOCK_DIAGNETLINK_NFLOGNETLINK_XFRMNETLINK_SELINUXNETLINK_ISCSINETLINK_AUDITNETLINK_FIB_LOOKUPNETLINK_CONNECTORNETLINK_NETFILTERNETLINK_IP6_FWNETLINK_DNRTMSGNETLINK_KOBJECT_UEVENTNETLINK_SCSITRANSPORTNETLINK_ECRYPTFSNETLINK_RDMANETLINK_CRYPTONETLINK_INET_DIAGMAX_LINKSNLM_F_MULTINLM_F_ACKNLM_F_ECHONLM_F_DUMP_INTRNLM_F_DUMP_FILTEREDNLM_F_ROOTNLM_F_MATCHNLM_F_ATOMICNLM_F_REPLACENLM_F_EXCLNLM_F_CREATENLM_F_APPENDNLMSG_NOOPNLMSG_ERRORNLMSG_DONENLMSG_OVERRUNNLMSG_MIN_TYPENFNLGRP_NONE// linux/netfilter/nfnetlink.hNFNLGRP_CONNTRACK_NEWNFNLGRP_CONNTRACK_UPDATENFNLGRP_CONNTRACK_DESTROYNFNLGRP_CONNTRACK_EXP_NEWNFNLGRP_CONNTRACK_EXP_UPDATENFNLGRP_CONNTRACK_EXP_DESTROYNFNLGRP_NFTABLESNFNLGRP_ACCT_QUOTANFNETLINK_V0NFNL_SUBSYS_NONENFNL_SUBSYS_CTNETLINKNFNL_SUBSYS_CTNETLINK_EXPNFNL_SUBSYS_QUEUENFNL_SUBSYS_ULOGNFNL_SUBSYS_OSFNFNL_SUBSYS_IPSETNFNL_SUBSYS_ACCTNFNL_SUBSYS_CTNETLINK_TIMEOUTNFNL_SUBSYS_CTHELPERNFNL_SUBSYS_NFTABLESNFNL_SUBSYS_NFT_COMPATNFNL_SUBSYS_COUNTNFNL_MSG_BATCH_BEGINNFNL_MSG_BATCH_ENDNFULNL_MSG_PACKET// linux/netfilter/nfnetlink_log.hNFULNL_MSG_CONFIGNFULA_UNSPECNFULA_PACKET_HDRNFULA_MARKNFULA_TIMESTAMPNFULA_IFINDEX_INDEVNFULA_IFINDEX_OUTDEVNFULA_IFINDEX_PHYSINDEVNFULA_IFINDEX_PHYSOUTDEVNFULA_HWADDRNFULA_PAYLOADNFULA_PREFIXNFULA_UIDNFULA_SEQNFULA_SEQ_GLOBALNFULA_GIDNFULA_HWTYPENFULA_HWHEADERNFULA_HWLENNFULA_CTNFULA_CT_INFONFULNL_CFG_CMD_NONENFULNL_CFG_CMD_BINDNFULNL_CFG_CMD_UNBINDNFULNL_CFG_CMD_PF_BINDNFULNL_CFG_CMD_PF_UNBINDNFULA_CFG_UNSPECNFULA_CFG_CMDNFULA_CFG_MODENFULA_CFG_NLBUFSIZNFULA_CFG_TIMEOUTNFULA_CFG_QTHRESHNFULA_CFG_FLAGSNFULNL_COPY_NONENFULNL_COPY_METANFULNL_COPY_PACKETNFULNL_CFG_F_SEQNFULNL_CFG_F_SEQ_GLOBALNFULNL_CFG_F_CONNTRACKNFQNL_MSG_PACKETNFQNL_MSG_VERDICTNFQNL_MSG_CONFIGNFQNL_MSG_VERDICT_BATCHNFQA_UNSPECNFQA_PACKET_HDRNFQA_VERDICT_HDRNFQA_MARKNFQA_TIMESTAMPNFQA_IFINDEX_INDEVNFQA_IFINDEX_OUTDEVNFQA_IFINDEX_PHYSINDEVNFQA_IFINDEX_PHYSOUTDEVNFQA_HWADDRNFQA_PAYLOADNFQA_CTNFQA_CT_INFONFQA_CAP_LENNFQA_SKB_INFONFQA_EXPNFQA_UIDNFQA_GIDNFQA_SECCTXNFQNL_CFG_CMD_NONENFQNL_CFG_CMD_BINDNFQNL_CFG_CMD_UNBINDNFQNL_CFG_CMD_PF_BINDNFQNL_CFG_CMD_PF_UNBINDNFQNL_COPY_NONENFQNL_COPY_METANFQNL_COPY_PACKETNFQA_CFG_UNSPECNFQA_CFG_CMDNFQA_CFG_PARAMSNFQA_CFG_QUEUE_MAXLENNFQA_CFG_MASKNFQA_CFG_FLAGSNFQA_CFG_F_FAIL_OPENNFQA_CFG_F_CONNTRACKNFQA_CFG_F_GSONFQA_CFG_F_UID_GIDNFQA_CFG_F_SECCTXNFQA_CFG_F_MAXNFQA_SKB_CSUMNOTREADYNFQA_SKB_GSONFQA_SKB_CSUM_NOTVERIFIEDGENL_NAMSIZGENL_MIN_IDGENL_MAX_IDGENL_ADMIN_PERMGENL_CMD_CAP_DOGENL_CMD_CAP_DUMPGENL_CMD_CAP_HASPOLGENL_UNS_ADMIN_PERMGENL_ID_CTRLGENL_ID_VFS_DQUOTGENL_ID_PMCRAIDCTRL_CMD_UNSPECCTRL_CMD_NEWFAMILYCTRL_CMD_DELFAMILYCTRL_CMD_GETFAMILYCTRL_CMD_NEWOPSCTRL_CMD_DELOPSCTRL_CMD_GETOPSCTRL_CMD_NEWMCAST_GRPCTRL_CMD_DELMCAST_GRPCTRL_CMD_GETMCAST_GRPCTRL_ATTR_UNSPECCTRL_ATTR_FAMILY_IDCTRL_ATTR_FAMILY_NAMECTRL_ATTR_VERSIONCTRL_ATTR_HDRSIZECTRL_ATTR_MAXATTRCTRL_ATTR_OPSCTRL_ATTR_MCAST_GROUPSCTRL_ATTR_OP_UNSPECCTRL_ATTR_OP_IDCTRL_ATTR_OP_FLAGSCTRL_ATTR_MCAST_GRP_UNSPECCTRL_ATTR_MCAST_GRP_NAMECTRL_ATTR_MCAST_GRP_IDNETLINK_ADD_MEMBERSHIPNETLINK_DROP_MEMBERSHIPNETLINK_PKTINFONETLINK_BROADCAST_ERRORNETLINK_NO_ENOBUFSNETLINK_RX_RINGNETLINK_TX_RINGNETLINK_LISTEN_ALL_NSIDNETLINK_LIST_MEMBERSHIPSNETLINK_CAP_ACKNETLINK_EXT_ACKNETLINK_GET_STRICT_CHKSECCOMP_MODE_DISABLEDSECCOMP_MODE_FILTERSECCOMP_FILTER_FLAG_TSYNCSECCOMP_FILTER_FLAG_LOGSECCOMP_FILTER_FLAG_SPEC_ALLOWSECCOMP_FILTER_FLAG_NEW_LISTENERSECCOMP_RET_ACTION_FULLSECCOMP_RET_ACTIONSECCOMP_RET_DATASECCOMP_RET_KILL_PROCESSSECCOMP_RET_KILL_THREADSECCOMP_RET_KILLSECCOMP_RET_TRAPSECCOMP_RET_ERRNOSECCOMP_RET_USER_NOTIFSECCOMP_RET_TRACESECCOMP_RET_LOGSECCOMP_RET_ALLOWNLA_F_NESTEDNLA_F_NET_BYTEORDERNLA_TYPE_MASKNLA_ALIGNTOIP_RECVFRAGSIZEIPV6_FLOWINFOIPV6_MULTICAST_ALLIPV6_ROUTER_ALERT_ISOLATEIPV6_FLOWLABEL_MGRIPV6_FLOWINFO_SENDIPV6_RECVFRAGSIZEIPV6_FREEBINDMFD_NOEXEC_SEALMFD_EXECMFD_HUGE_SHIFTOPEN_TREE_CLONE// uapi/linux/mount.hOPEN_TREE_CLOEXECNF_DROP// linux/netfilter.hNF_ACCEPTNF_STOLENNF_QUEUENF_REPEATNF_STOPNF_MAX_VERDICTNF_VERDICT_MASKNF_VERDICT_FLAG_QUEUE_BYPASSNF_VERDICT_QMASKNF_VERDICT_QBITSNF_VERDICT_BITSNF_INET_PRE_ROUTINGNF_INET_LOCAL_INNF_INET_FORWARDNF_INET_LOCAL_OUTNF_INET_POST_ROUTINGNF_INET_NUMHOOKSNF_INET_INGRESSNF_NETDEV_INGRESSNF_NETDEV_EGRESSNF_NETDEV_NUMHOOKSNFPROTO_UNSPECNFPROTO_INETNFPROTO_IPV4NFPROTO_ARPNFPROTO_NETDEVNFPROTO_BRIDGENFPROTO_IPV6NFPROTO_DECNETNFPROTO_NUMPROTONF_ARP// linux/netfilter_arp.hNF_ARP_INNF_ARP_OUTNF_ARP_FORWARDNF_ARP_NUMHOOKSNF_BR_PRE_ROUTING// linux/netfilter_bridge.hNF_BR_LOCAL_INNF_BR_FORWARDNF_BR_LOCAL_OUTNF_BR_POST_ROUTINGNF_BR_BROUTINGNF_BR_NUMHOOKSNF_BR_PRI_FIRSTNF_BR_PRI_NAT_DST_BRIDGEDNF_BR_PRI_FILTER_BRIDGEDNF_BR_PRI_BRNFNF_BR_PRI_NAT_DST_OTHERNF_BR_PRI_FILTER_OTHERNF_BR_PRI_NAT_SRCNF_BR_PRI_LASTNF_IP_PRE_ROUTING// linux/netfilter_ipv4.hNF_IP_LOCAL_INNF_IP_FORWARDNF_IP_LOCAL_OUTNF_IP_POST_ROUTINGNF_IP_NUMHOOKSNF_IP_PRI_FIRSTNF_IP_PRI_RAW_BEFORE_DEFRAGNF_IP_PRI_CONNTRACK_DEFRAGNF_IP_PRI_RAWNF_IP_PRI_SELINUX_FIRSTNF_IP_PRI_CONNTRACKNF_IP_PRI_MANGLENF_IP_PRI_NAT_DSTNF_IP_PRI_FILTERNF_IP_PRI_SECURITYNF_IP_PRI_NAT_SRCNF_IP_PRI_SELINUX_LASTNF_IP_PRI_CONNTRACK_HELPERNF_IP_PRI_CONNTRACK_CONFIRMNF_IP_PRI_LASTNF_IP6_PRE_ROUTING// linux/netfilter_ipv6.hNF_IP6_LOCAL_INNF_IP6_FORWARDNF_IP6_LOCAL_OUTNF_IP6_POST_ROUTINGNF_IP6_NUMHOOKSNF_IP6_PRI_FIRSTNF_IP6_PRI_RAW_BEFORE_DEFRAGNF_IP6_PRI_CONNTRACK_DEFRAGNF_IP6_PRI_RAWNF_IP6_PRI_SELINUX_FIRSTNF_IP6_PRI_CONNTRACKNF_IP6_PRI_MANGLENF_IP6_PRI_NAT_DSTNF_IP6_PRI_FILTERNF_IP6_PRI_SECURITYNF_IP6_PRI_NAT_SRCNF_IP6_PRI_SELINUX_LASTNF_IP6_PRI_CONNTRACK_HELPERNF_IP6_PRI_LASTIP6T_SO_ORIGINAL_DST// linux/netfilter_ipv6/ip6_tables.hNFT_TABLE_MAXNAMELEN// linux/netfilter/nf_tables.hNFT_CHAIN_MAXNAMELENNFT_SET_MAXNAMELENNFT_OBJ_MAXNAMELENNFT_USERDATA_MAXLENNFT_REG_VERDICTNFT_REG_1NFT_REG_2NFT_REG_3NFT_REG_4__NFT_REG_MAXNFT_REG32_00NFT_REG32_01NFT_REG32_02NFT_REG32_03NFT_REG32_04NFT_REG32_05NFT_REG32_06NFT_REG32_07NFT_REG32_08NFT_REG32_09NFT_REG32_10NFT_REG32_11NFT_REG32_12NFT_REG32_13NFT_REG32_14NFT_REG32_15NFT_REG_SIZENFT_REG32_SIZENFT_CONTINUENFT_BREAKNFT_JUMPNFT_GOTONFT_RETURNNFT_MSG_NEWTABLENFT_MSG_GETTABLENFT_MSG_DELTABLENFT_MSG_NEWCHAINNFT_MSG_GETCHAINNFT_MSG_DELCHAINNFT_MSG_NEWRULENFT_MSG_GETRULENFT_MSG_DELRULENFT_MSG_NEWSETNFT_MSG_GETSETNFT_MSG_DELSETNFT_MSG_NEWSETELEMNFT_MSG_GETSETELEMNFT_MSG_DELSETELEMNFT_MSG_NEWGENNFT_MSG_GETGENNFT_MSG_TRACENFT_MSG_NEWOBJNFT_MSG_GETOBJNFT_MSG_DELOBJNFT_MSG_GETOBJ_RESETNFT_MSG_MAXNFT_SET_ANONYMOUSNFT_SET_CONSTANTNFT_SET_INTERVALNFT_SET_MAPNFT_SET_TIMEOUTNFT_SET_EVALNFT_SET_POL_PERFORMANCENFT_SET_POL_MEMORYNFT_SET_ELEM_INTERVAL_ENDNFT_DATA_VALUENFT_DATA_VERDICTNFT_DATA_RESERVED_MASKNFT_DATA_VALUE_MAXLENNFT_BYTEORDER_NTOHNFT_BYTEORDER_HTONNFT_CMP_EQNFT_CMP_NEQNFT_CMP_LTNFT_CMP_LTENFT_CMP_GTNFT_CMP_GTENFT_RANGE_EQNFT_RANGE_NEQNFT_LOOKUP_F_INVNFT_DYNSET_OP_ADDNFT_DYNSET_OP_UPDATENFT_DYNSET_F_INVNFT_PAYLOAD_LL_HEADERNFT_PAYLOAD_NETWORK_HEADERNFT_PAYLOAD_TRANSPORT_HEADERNFT_PAYLOAD_CSUM_NONENFT_PAYLOAD_CSUM_INETNFT_META_LENNFT_META_PROTOCOLNFT_META_PRIORITYNFT_META_MARKNFT_META_IIFNFT_META_OIFNFT_META_IIFNAMENFT_META_OIFNAMENFT_META_IIFTYPENFT_META_OIFTYPENFT_META_SKUIDNFT_META_SKGIDNFT_META_NFTRACENFT_META_RTCLASSIDNFT_META_SECMARKNFT_META_NFPROTONFT_META_L4PROTONFT_META_BRI_IIFNAMENFT_META_BRI_OIFNAMENFT_META_PKTTYPENFT_META_CPUNFT_META_IIFGROUPNFT_META_OIFGROUPNFT_META_CGROUPNFT_META_PRANDOMNFT_CT_STATENFT_CT_DIRECTIONNFT_CT_STATUSNFT_CT_MARKNFT_CT_SECMARKNFT_CT_EXPIRATIONNFT_CT_HELPERNFT_CT_L3PROTOCOLNFT_CT_SRCNFT_CT_DSTNFT_CT_PROTOCOLNFT_CT_PROTO_SRCNFT_CT_PROTO_DSTNFT_CT_LABELSNFT_CT_PKTSNFT_CT_BYTESNFT_CT_AVGPKTNFT_CT_ZONENFT_CT_EVENTMASKNFT_CT_SRC_IPNFT_CT_DST_IPNFT_CT_SRC_IP6NFT_CT_DST_IP6NFT_CT_IDNFT_LIMIT_PKTSNFT_LIMIT_PKT_BYTESNFT_LIMIT_F_INVNFT_QUEUE_FLAG_BYPASSNFT_QUEUE_FLAG_CPU_FANOUTNFT_QUEUE_FLAG_MASKNFT_QUOTA_F_INVNFT_REJECT_ICMP_UNREACHNFT_REJECT_TCP_RSTNFT_REJECT_ICMPX_UNREACHNFT_REJECT_ICMPX_NO_ROUTENFT_REJECT_ICMPX_PORT_UNREACHNFT_REJECT_ICMPX_HOST_UNREACHNFT_REJECT_ICMPX_ADMIN_PROHIBITEDNFT_NAT_SNATNFT_NAT_DNATNFT_TRACETYPE_UNSPECNFT_TRACETYPE_POLICYNFT_TRACETYPE_RETURNNFT_TRACETYPE_RULENFT_NG_INCREMENTALNFT_NG_RANDOMFF_MAX// linux/input.hFF_CNTINPUT_PROP_MAX// linux/input-event-codes.hINPUT_PROP_CNTKEY_MAXKEY_CNTREL_MAXREL_CNTABS_MAXABS_CNTSW_MAXSW_CNTMSC_MAXMSC_CNTLED_MAXLED_CNTREP_MAXREP_CNTSND_MAXSND_CNTUINPUT_VERSION// linux/uinput.h// bionic/libc/kernel/uapi/linux/if_tun.hIFF_NAPIIFF_NAPI_FRAGSIFF_NO_CARRIERIFF_ONE_QUEUEIFF_VNET_HDRIFF_TUN_EXCLIFF_MULTI_QUEUEIFF_ATTACH_QUEUEIFF_DETACH_QUEUEIFF_PERSISTIFF_NOFILTERTUN_F_CSUM// Features for GSO (TUNSETOFFLOAD)TUN_F_TSO4TUN_F_TSO6TUN_F_TSO_ECNTUN_F_UFOTUN_F_USO4TUN_F_USO6ETH_ALEN// start android/platform/bionic/libc/kernel/uapi/linux/if_ether.h// from https://android.googlesource.com/platform/bionic/+/HEAD/libc/kernel/uapi/linux/if_ether.hETH_HLENETH_ZLENETH_DATA_LENETH_FRAME_LENETH_FCS_LENETH_MIN_MTUETH_MAX_MTUETH_P_TSN/* see rust-lang/libc#924 pub const ETH_P_ERSPAN: c_int = 0x88BE;*/ETH_P_MACSECETH_P_NCSI/* see rust-lang/libc#924 pub const ETH_P_IBOE: c_int = 0x8915;*/ETH_P_HSR/* see rust-lang/libc#924 pub const ETH_P_NSH: c_int = 0x894F;*//* see rust-lang/libc#924 pub const ETH_P_IFE: c_int = 0xED3E;*/ETH_P_XDSANDA_UNSPEC// start android/platform/bionic/libc/kernel/uapi/linux/neighbour.hNDA_DSTNDA_LLADDRNDA_CACHEINFONDA_PROBESNDA_VLANNDA_PORTNDA_VNINDA_IFINDEXNDA_MASTERNDA_LINK_NETNSIDNDA_SRC_VNINDA_PROTOCOLNDA_NH_IDNDA_FDB_EXT_ATTRSNDA_FLAGS_EXTNDA_NDM_STATE_MASKNDA_NDM_FLAGS_MASKNTF_USENTF_SELFNTF_MASTERNTF_PROXYNTF_EXT_LEARNEDNTF_OFFLOADEDNTF_STICKYNTF_ROUTERNTF_EXT_MANAGEDNTF_EXT_LOCKEDNUD_NONENUD_INCOMPLETENUD_REACHABLENUD_STALENUD_DELAYNUD_PROBENUD_FAILEDNUD_NOARPNUD_PERMANENTNDTPA_UNSPECNDTPA_IFINDEXNDTPA_REFCNTNDTPA_REACHABLE_TIMENDTPA_BASE_REACHABLE_TIMENDTPA_RETRANS_TIMENDTPA_GC_STALETIMENDTPA_DELAY_PROBE_TIMENDTPA_QUEUE_LENNDTPA_APP_PROBESNDTPA_UCAST_PROBESNDTPA_MCAST_PROBESNDTPA_ANYCAST_DELAYNDTPA_PROXY_DELAYNDTPA_PROXY_QLENNDTPA_LOCKTIMENDTPA_QUEUE_LENBYTESNDTPA_MCAST_REPROBESNDTPA_PADNDTPA_INTERVAL_PROBE_TIME_MSNDTA_UNSPECNDTA_NAMENDTA_THRESH1NDTA_THRESH2NDTA_THRESH3NDTA_CONFIGNDTA_PARMSNDTA_STATSNDTA_GC_INTERVALNDTA_PADFDB_NOTIFY_BITFDB_NOTIFY_INACTIVE_BITNFEA_UNSPECNFEA_ACTIVITY_NOTIFYNFEA_DONT_REFRESHSIOCRTMSGSIOCSIFNAMESIOCSIFPFLAGSSIOCGIFPFLAGSSIOCSIFHWBROADCASTSIOCGIFCOUNTSIOCGIFBRSIOCSIFBRSIOCGIFTXQLENSIOCSIFTXQLENSIOCETHTOOLSIOCGMIIPHYSIOCGMIIREGSIOCSMIIREGSIOCWANDEVSIOCOUTQNSDSIOCGSKNSSIOCADDDLCISIOCDELDLCISIOCGIFVLANSIOCSIFVLANSIOCBONDENSLAVESIOCBONDRELEASESIOCBONDSETHWADDRSIOCBONDSLAVEINFOQUERYSIOCBONDINFOQUERYSIOCBONDCHANGEACTIVESIOCBRADDBRSIOCBRDELBRSIOCBRADDIFSIOCBRDELIFSIOCSHWTSTAMPSIOCGHWTSTAMPSIOCDEVPRIVATESIOCPROTOPRIVATEMODULE_INIT_IGNORE_MODVERSIONS// linux/module.hMODULE_INIT_IGNORE_VERMAGICSOF_TIMESTAMPING_TX_HARDWARE// linux/net_tstamp.hSOF_TIMESTAMPING_TX_SOFTWARESOF_TIMESTAMPING_RX_HARDWARESOF_TIMESTAMPING_RX_SOFTWARESOF_TIMESTAMPING_SOFTWARESOF_TIMESTAMPING_SYS_HARDWARESOF_TIMESTAMPING_RAW_HARDWARESOF_TIMESTAMPING_OPT_IDSOF_TIMESTAMPING_TX_SCHEDSOF_TIMESTAMPING_TX_ACKSOF_TIMESTAMPING_OPT_CMSGSOF_TIMESTAMPING_OPT_TSONLYSOF_TIMESTAMPING_OPT_STATSSOF_TIMESTAMPING_OPT_PKTINFOSOF_TIMESTAMPING_OPT_TX_SWHWSOF_TIMESTAMPING_BIND_PHCSOF_TIMESTAMPING_OPT_ID_TCPSOF_TIMESTAMPING_OPT_RX_FILTERALG_SET_KEY// linux/if_alg.hALG_SET_IVALG_SET_OPALG_SET_AEAD_ASSOCLENALG_SET_AEAD_AUTHSIZEALG_SET_DRBG_ENTROPYALG_OP_DECRYPTALG_OP_ENCRYPTMLOCK_ONFAULT// uapi/linux/vm_sockets.hVMADDR_CID_LOCAL// uapi/linux/inotify.hIN_MASK_CREATEFUTEX_LOCK_PI2SO_EE_ORIGIN_NONE// linux/errqueue.hSO_EE_ORIGIN_LOCALSO_EE_ORIGIN_ICMPSO_EE_ORIGIN_ICMP6SO_EE_ORIGIN_TXSTATUSSO_EE_ORIGIN_TIMESTAMPINGSCHED_NORMAL// linux/sched.hSCHED_DEADLINESCHED_RESET_ON_FORKCLONE_PIDFDMEMBARRIER_CMD_QUERY// linux/membarrier.hMEMBARRIER_CMD_GLOBALMEMBARRIER_CMD_GLOBAL_EXPEDITEDMEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITEDMEMBARRIER_CMD_PRIVATE_EXPEDITEDMEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITEDMEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_COREMEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_COREMEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQMEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQMPOL_DEFAULT// linux/mempolicy.hMPOL_PREFERREDMPOL_BINDMPOL_INTERLEAVEMPOL_LOCALMPOL_F_NUMA_BALANCINGMPOL_F_RELATIVE_NODESMPOL_F_STATIC_NODES// bits/seek_constants.h// sys/prctl.hPROP_VALUE_MAX// sys/system_properties.hPROP_NAME_MAXPR_SET_VMAPR_SET_VMA_ANON_NAMEIFA_UNSPEC// linux/if_addr.hIFA_ADDRESSIFA_LOCALIFA_LABELIFA_BROADCASTIFA_ANYCASTIFA_CACHEINFOIFA_MULTICASTIFA_F_SECONDARYIFA_F_TEMPORARYIFA_F_NODADIFA_F_OPTIMISTICIFA_F_DADFAILEDIFA_F_HOMEADDRESSIFA_F_DEPRECATEDIFA_F_TENTATIVEIFA_F_PERMANENTIFLA_UNSPEC// linux/if_link.hIFLA_ADDRESSIFLA_BROADCASTIFLA_IFNAMEIFLA_MTUIFLA_LINKIFLA_QDISCIFLA_STATSIFLA_COSTIFLA_PRIORITYIFLA_MASTERIFLA_WIRELESSIFLA_PROTINFOIFLA_TXQLENIFLA_MAPIFLA_WEIGHTIFLA_OPERSTATEIFLA_LINKMODEIFLA_LINKINFOIFLA_NET_NS_PIDIFLA_IFALIASIFLA_NUM_VFIFLA_VFINFO_LISTIFLA_STATS64IFLA_VF_PORTSIFLA_PORT_SELFIFLA_AF_SPECIFLA_GROUPIFLA_NET_NS_FDIFLA_EXT_MASKIFLA_PROMISCUITYIFLA_NUM_TX_QUEUESIFLA_NUM_RX_QUEUESIFLA_CARRIERIFLA_PHYS_PORT_IDIFLA_CARRIER_CHANGESIFLA_PHYS_SWITCH_IDIFLA_LINK_NETNSIDIFLA_PHYS_PORT_NAMEIFLA_PROTO_DOWNIFLA_GSO_MAX_SEGSIFLA_GSO_MAX_SIZEIFLA_PADIFLA_XDPIFLA_EVENTIFLA_NEW_NETNSIDIFLA_IF_NETNSIDIFLA_TARGET_NETNSIDIFLA_CARRIER_UP_COUNTIFLA_CARRIER_DOWN_COUNTIFLA_NEW_IFINDEXIFLA_MIN_MTUIFLA_MAX_MTUIFLA_PROP_LISTIFLA_ALT_IFNAMEIFLA_PERM_ADDRESSIFLA_PROTO_DOWN_REASONIFLA_PARENT_DEV_NAMEIFLA_PARENT_DEV_BUS_NAMEIFLA_GRO_MAX_SIZEIFLA_TSO_MAX_SIZEIFLA_TSO_MAX_SEGSIFLA_ALLMULTIIFLA_DEVLINK_PORTIFLA_GSO_IPV4_MAX_SIZEIFLA_GRO_IPV4_MAX_SIZEIFLA_INFO_UNSPECIFLA_INFO_KINDIFLA_INFO_DATAIFLA_INFO_XSTATSIFLA_INFO_SLAVE_KINDIFLA_INFO_SLAVE_DATATCA_UNSPEC// linux/rtnetlink.hTCA_KINDTCA_OPTIONSTCA_STATSTCA_XSTATSTCA_RATETCA_FCNTTCA_STATS2TCA_STABRTM_NEWLINKRTM_DELLINKRTM_GETLINKRTM_SETLINKRTM_GETADDRRTM_NEWROUTERTM_DELROUTERTM_GETROUTERTM_NEWNEIGHRTM_DELNEIGHRTM_GETNEIGHRTM_NEWRULERTM_DELRULERTM_GETRULERTM_NEWQDISCRTM_DELQDISCRTM_GETQDISCRTM_NEWTCLASSRTM_DELTCLASSRTM_GETTCLASSRTM_NEWTFILTERRTM_DELTFILTERRTM_GETTFILTERRTM_NEWACTIONRTM_DELACTIONRTM_GETACTIONRTM_NEWPREFIXRTM_GETMULTICASTRTM_GETANYCASTRTM_NEWNEIGHTBLRTM_GETNEIGHTBLRTM_SETNEIGHTBLRTM_NEWNDUSEROPTRTM_NEWADDRLABELRTM_DELADDRLABELRTM_GETADDRLABELRTM_GETDCBRTM_SETDCBRTM_NEWNETCONFRTM_GETNETCONFRTM_NEWMDBRTM_DELMDBRTM_GETMDBRTM_NEWNSIDRTM_DELNSIDRTM_GETNSIDRTM_F_NOTIFYRTM_F_CLONEDRTM_F_EQUALIZERTM_F_PREFIXRTA_UNSPECRTA_IIFRTA_OIFRTA_PRIORITYRTA_PREFSRCRTA_METRICSRTA_MULTIPATHRTA_PROTOINFORTA_FLOW// No longer usedRTA_CACHEINFORTA_SESSIONRTA_MP_ALGORTA_TABLERTA_MARKRTA_MFC_STATSRTN_UNSPECRTN_UNICASTRTN_LOCALRTN_BROADCASTRTN_ANYCASTRTN_MULTICASTRTN_BLACKHOLERTN_UNREACHABLERTN_PROHIBITRTN_THROWRTN_NATRTN_XRESOLVERTPROT_UNSPECRTPROT_REDIRECTRTPROT_KERNELRTPROT_BOOTRTPROT_STATICRT_SCOPE_UNIVERSERT_SCOPE_SITERT_SCOPE_LINKRT_SCOPE_HOSTRT_SCOPE_NOWHERERT_TABLE_UNSPECRT_TABLE_COMPATRT_TABLE_DEFAULTRT_TABLE_MAINRT_TABLE_LOCALRTMSG_NEWDEVICERTMSG_DELDEVICERTMSG_NEWROUTERTMSG_DELROUTECTL_DEVCTL_BUSCTL_ABICTL_CPUCTL_BUS_ISAINOTIFY_MAX_USER_INSTANCESINOTIFY_MAX_USER_WATCHESINOTIFY_MAX_QUEUED_EVENTSKERN_SECUREMASKKERN_NODENAMEKERN_PANICKERN_REALROOTDEVKERN_SPARC_REBOOTKERN_CTLALTDELKERN_PRINTKKERN_NAMETRANSKERN_PPC_HTABRECLAIMKERN_PPC_ZEROPAGEDKERN_PPC_POWERSAVE_NAPKERN_MODPROBEKERN_SG_BIG_BUFFKERN_ACCTKERN_PPC_L2CRKERN_RTSIGNRKERN_RTSIGMAXKERN_SHMMAXKERN_MSGMAXKERN_MSGMNBKERN_MSGPOOLKERN_SYSRQKERN_MAX_THREADSKERN_RANDOMKERN_SHMALLKERN_MSGMNIKERN_SEMKERN_SPARC_STOP_AKERN_SHMMNIKERN_OVERFLOWUIDKERN_OVERFLOWGIDKERN_SHMPATHKERN_HOTPLUGKERN_IEEE_EMULATION_WARNINGSKERN_S390_USER_DEBUG_LOGGINGKERN_CORE_USES_PIDKERN_TAINTEDKERN_CADPIDKERN_PIDMAXKERN_CORE_PATTERNKERN_PANIC_ON_OOPSKERN_HPPA_PWRSWKERN_HPPA_UNALIGNEDKERN_PRINTK_RATELIMITKERN_PRINTK_RATELIMIT_BURSTKERN_PTYKERN_NGROUPS_MAXKERN_SPARC_SCONS_PWROFFKERN_HZ_TIMERKERN_UNKNOWN_NMI_PANICKERN_BOOTLOADER_TYPEKERN_RANDOMIZEKERN_SETUID_DUMPABLEKERN_SPIN_RETRYKERN_ACPI_VIDEO_FLAGSKERN_IA64_UNALIGNEDKERN_COMPAT_LOGKERN_MAX_LOCK_DEPTHVM_OVERCOMMIT_MEMORYVM_PAGE_CLUSTERVM_DIRTY_BACKGROUNDVM_DIRTY_RATIOVM_DIRTY_WB_CSVM_DIRTY_EXPIRE_CSVM_NR_PDFLUSH_THREADSVM_OVERCOMMIT_RATIOVM_PAGEBUFVM_HUGETLB_PAGESVM_SWAPPINESSVM_LOWMEM_RESERVE_RATIOVM_MIN_FREE_KBYTESVM_MAX_MAP_COUNTVM_LAPTOP_MODEVM_BLOCK_DUMPVM_HUGETLB_GROUPVM_VFS_CACHE_PRESSUREVM_LEGACY_VA_LAYOUTVM_SWAP_TOKEN_TIMEOUTVM_DROP_PAGECACHEVM_PERCPU_PAGELIST_FRACTIONVM_ZONE_RECLAIM_MODEVM_MIN_UNMAPPEDVM_PANIC_ON_OOMVM_VDSO_ENABLEDNET_CORENET_ETHERNET_802NET_UNIXNET_IPV4NET_IPXNET_ATALKNET_NETROMNET_AX25NET_BRIDGENET_ROSENET_IPV6NET_X25NET_TRNET_DECNETNET_ECONETNET_SCTPNET_LLCNET_NETFILTERNET_DCCPPF_VCPU// include/linux/sched.hPF_IDLEPF_EXITINGPF_POSTCOREDUMPPF_IO_WORKERPF_WQ_WORKERPF_FORKNOEXECPF_MCE_PROCESSPF_SUPERPRIVPF_DUMPCOREPF_SIGNALEDPF_MEMALLOCPF_NPROC_EXCEEDEDPF_USED_MATHPF_USER_WORKERPF_NOFREEZEPF_KSWAPDPF_MEMALLOC_NOFSPF_MEMALLOC_NOIOPF_LOCAL_THROTTLEPF_KTHREADPF_RANDOMIZEPF_NO_SETAFFINITYPF_MCE_EARLYPF_MEMALLOC_PINPF_SUSPEND_TASKKLOG_CLOSEKLOG_OPENKLOG_READKLOG_READ_ALLKLOG_READ_CLEARKLOG_CLEARKLOG_CONSOLE_OFFKLOG_CONSOLE_ONKLOG_CONSOLE_LEVELKLOG_SIZE_UNREADKLOG_SIZE_BUFFER// From NDK's linux/auxvec.hAT_PLATFORMAT_CLKTCKAT_SECUREAT_BASE_PLATFORMAT_RANDOMAT_RSEQ_FEATURE_SIZEAT_RSEQ_ALIGNAT_EXECFNAT_MINSIGSTKSZSI_DETHREAD// siginfo.hTRAP_PERF// Most `*_SUPER_MAGIC` constants are defined at the `linux_like` level; the// following are only available on newer Linux versions than the versions// currently used in CI in some configurations, so we define them here.prlimitprlimit64mlock2process_vm_readvprocess_vm_writev__sched_cpualloc__sched_cpufree__sched_cpucount// available from API 23epoll_createepoll_create1epoll_waitepoll_eventepoll_ctlunsharesetnsandroid_set_abort_messagegettid/// Only available in API Version 28+__system_property_set__system_property_get__system_property_find__system_property_find_nth__system_property_foreach/// Only available in API Version 21+fwrite_unlockedfflush_unlockedfgets_unlockedklogctlrenameat2si_utimesi_stimesifields_sigchld// Internal, for casts to access union fieldssifields_align_pointer_siginfo_basesiginfo_f// Internal, for casts to access union fields. Note that some variants// of sifields start with a pointer, which makes the alignment of// sifields vary on 32-bit and 64-bit architectures.//! Android-specific definitions for linux-like values// linux/elf.h/*
 FIXME: These are not yet available in musl sanitized kernel headers and
 make the tests fail. Enable them once musl has them.

 See https://github.com/rust-lang/libc/pull/1628 for more details.
pub const NFQA_VLAN: c_int = 19;
pub const NFQA_L2HDR: c_int = 20;

pub const NFQA_VLAN_UNSPEC: c_int = 0;
pub const NFQA_VLAN_PROTO: c_int = 1;
pub const NFQA_VLAN_TCI: c_int = 2;
*//* see rust-lang/libc#924 pub const ETH_P_MAP: c_int = 0x00F9;*/// end android/platform/bionic/libc/kernel/uapi/linux/if_ether.h// end android/platform/bionic/libc/kernel/uapi/linux/neighbour.h// These functions are variadic in the C ABI since the `mode` argument is "optional".  Variadic// `extern "C"` functions are unstable in Rust so we cannot write a shim function for these// entrypoints.  See https://github.com/rust-lang/rust/issues/44930.// These aliases are mostly fine though, neither function takes a LFS64-namespaced type as an// argument, nor do their names clash with any declared types.// In-sync with ../linux/musl/lfs64.rs except for fallocate64, prlimit64 and sendfile64flock64// FIXME(emscripten): fill this out with a struct// Defined as wasi value.// grp.hlfs64// Alias <foo> to <foo>64 to mimic glibc's LFS64 support// Valid for arm (32-bit) and x86 (32-bit)c_iflagc_oflagc_cflagc_lflagc_linec_ccc_ispeedc_ospeedtermios2// include/uapi/asm-generic/socket.h// arch/alpha/include/uapi/asm/socket.h// tools/include/uapi/asm-generic/socket.h// arch/mips/include/uapi/asm/socket.h// pub const SO_DEBUG: c_int = 1;SO_RCVTIMEO_OLDSO_SNDTIMEO_OLDSO_SECURITY_AUTHENTICATIONSO_SECURITY_ENCRYPTION_TRANSPORTSO_SECURITY_ENCRYPTION_NETWORKSO_PEERNAMESO_TIMESTAMP_OLDSO_TIMESTAMPNS_OLDSO_TIMESTAMPING_OLDSO_WIFI_STATUSSCM_WIFI_STATUSSO_NOFCSSO_LOCK_FILTERSO_SELECT_ERR_QUEUESO_MAX_PACING_RATESO_BPF_EXTENSIONSSO_INCOMING_CPUSO_ATTACH_BPFSO_DETACH_BPFSO_ATTACH_REUSEPORT_CBPFSO_ATTACH_REUSEPORT_EBPFSO_CNX_ADVICESO_MEMINFOSO_INCOMING_NAPI_IDSO_COOKIESO_PEERGROUPSSO_ZEROCOPYSO_TXTIMESCM_TXTIMESO_RCVTIMEO_NEWSO_SNDTIMEO_NEWSO_DETACH_REUSEPORT_BPFSO_PREFER_BUSY_POLLSO_BUSY_POLL_BUDGETSO_NETNS_COOKIESO_BUF_LOCKSO_RESERVE_MEMSO_TXREHASHSO_RCVMARKSO_PASSPIDFDSO_PEERPIDFDSO_DEVMEM_LINEARSO_DEVMEM_DMABUFSO_DEVMEM_DONTNEEDFICLONEFICLONERANGESCM_DEVMEM_LINEARSCM_DEVMEM_DMABUFTIOCGRS485TIOCSRS485TIOCSPTLCKTIOCGDEVTCGETXTCSETXTCSETXFTCSETXWTIOCVHANGUPTIOCGPKTTIOCGPTLCKTIOCGEXCLTIOCGPTPEER// pub const TIOCGISO7816: Ioctl = 0x80285442;// pub const TIOCSISO7816: Ioctl = 0xc0285443;TIOCMIWAITTIOCGICOUNTTUNSETNOCSUM// linux/if_tun.hTUNSETDEBUGTUNSETIFFTUNSETPERSISTTUNSETOWNERTUNSETLINKTUNSETGROUPTUNGETFEATURESTUNSETOFFLOADTUNSETTXFILTERTUNGETIFFTUNGETSNDBUFTUNSETSNDBUFTUNGETVNETHDRSZTUNSETVNETHDRSZTUNSETQUEUETUNSETIFINDEXTUNSETVNETLETUNGETVNETLETUNSETVNETBE/* The TUNSETVNETBE and TUNGETVNETBE ioctls are for cross-endian support on
 * little-endian hosts. Not all kernel configurations support them, but all
 * configurations that support SET also support GET.
 */TUNGETVNETBETUNSETSTEERINGEBPFTUNSETFILTEREBPFFS_IOC_GETFLAGSFS_IOC_SETFLAGSFS_IOC_GETVERSIONFS_IOC_SETVERSIONFS_IOC32_GETFLAGSFS_IOC32_SETFLAGSFS_IOC32_GETVERSIONFS_IOC32_SETVERSIONTUNATTACHFILTERTUNDETACHFILTERTUNGETFILTERFIOQSIZE// Ioctl Constants// RLIMIT Constants// pub const SO_DEBUG: c_int = 0x0001;// pub const SO_STYLE: c_int = SO_TYPE;// NOTE: These definitions are now being renamed with _OLD postfix,// but CI haven't support them yet.// Some related consts could be found in b32.rs and b64.rs// pub const SO_DETACH_REUSEPORT_BPF: c_int = 68;//pub const TIOCGISO7816: Ioctl = 0x40285442;//pub const TIOCSISO7816: Ioctl = 0xc0285443;// powerpc only differs in these// pub const SO_RCVTIMEO_OLD: c_int = 18;// pub const SO_SNDTIMEO_OLD: c_int = 19;// end//pub const FIOQSIZE: Ioctl = 0x40086680;// arch/powerpc/include/uapi/asm/socket.h// arch/sparc/include/uapi/asm/socket.h// pub const SO_RCVTIMEO_OLD: c_int = 0x2000;// pub const SO_SNDTIMEO_OLD: c_int = 0x4000;// pub const SO_TIMESTAMP_OLD: c_int = 0x001d;// pub const SO_TIMESTAMPNS_OLD: c_int = 0x0021;// pub const SO_TIMESTAMPING_OLD: c_int = 0x0023;// pub const SO_TIMESTAMP_NEW: c_int = 0x0046;// pub const SO_TIMESTAMPNS_NEW: c_int = 0x0042;// pub const SO_TIMESTAMPING_NEW: c_int = 0x0043;// pub const SO_RCVTIMEO_NEW: c_int = 0x0044;// pub const SO_SNDTIMEO_NEW: c_int = 0x0045;// pub const SO_DETACH_REUSEPORT_BPF: c_int = 0x0047;//pub const FIOASYNC: Ioctl = 0x4004667d;//pub const FIOQSIZE: Ioctl = ;//pub const TIOCGISO7816: Ioctl = 0x40285443;//pub const TIOCSISO7816: Ioctl = 0xc0285444;//pub const TIOCGRS485: Ioctl = 0x40205441;//pub const TIOCSRS485: Ioctl = 0xc0205442;SYS__llseekSYS__newselectSYS__sysctlSYS_rseqSYS_msealSYS_syscallPTRACE_SYSEMUPTRACE_SYSEMU_SINGLESTEPSYS_time32SYS_chown16SYS_oldumountSYS_setuid16SYS_getuid16SYS_stime32SYS_utime32SYS_setgid16SYS_getgid16SYS_geteuid16SYS_getegid16SYS_setreuid16SYS_setregid16SYS_old_getrlimitSYS_getgroups16SYS_setgroups16SYS_old_selectSYS_old_readdirSYS_old_mmapSYS_fchown16SYS_newstatSYS_newlstatSYS_newfstatSYS_newunameSYS_cacheflushSYS_adjtimex_time32SYS_setfsuid16SYS_setfsgid16SYS_llseekSYS_sched_rr_get_interval_time32SYS_nanosleep_time32SYS_setresuid16SYS_getresuid16SYS_getpagesizeSYS_setresgid16SYS_getresgid16SYS_rt_sigtimedwait_time32SYS_lchown16SYS_futex_time32SYS_io_getevents_time32SYS_timer_settime32SYS_timer_gettime32SYS_clock_settime32SYS_clock_gettime32SYS_clock_getres_time32SYS_clock_nanosleep_time32SYS_utimes_time32SYS_mq_timedsend_time32SYS_mq_timedreceive_time32SYS_futimesat_time32SYS_pselect6_time32SYS_ppoll_time32SYS_utimensat_time32SYS_timerfd_settime32SYS_timerfd_gettime32SYS_atomic_cmpxchg_32SYS_atomic_barrierSYS_clock_adjtime32SYS_recvmmsg_time32SYS_io_pgeteventsSYS_cachectlSYS_sysmips/* pub const SYS_sys_setaltroot: c_long = 4000 + 279; */SYS_timerfdPTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP//! 32-bit specific definitions for linux-like values/* Syscall for Andrew File System *//* some people actually want streams *//* SuS compliant getrlimit */SYS_multiplexerSYS_swapcontextSYS_rtasSYS_sys_debug_setcontextSYS_spu_runSYS_spu_createSYS_sync_file_range2SYS_subpage_protSYS_switch_endianREG_PCREG_RAREG_SPREG_TPREG_S0REG_S1REG_A0REG_S2REG_NARGS//! RISC-V-specific definitions for 32-bit linux-like valuesB153600B307200B614400SYS_execvSYS_perfctrSYS_sched_set_affinitySYS_sched_get_affinitySYS_getdomainnameSYS_kern_features// Reserved in the kernel, but not actually implemented yet//! SPARC-specific definitions for 32-bit linux-like valuesSYS_fchmodat2// sys/auxv.hPR_PAC_RESET_KEYS// linux/prctl.hPR_SET_TAGGED_ADDR_CTRLPR_GET_TAGGED_ADDR_CTRLPR_PAC_SET_ENABLED_KEYSPR_PAC_GET_ENABLED_KEYSPR_TAGGED_ADDR_ENABLEPR_PAC_APIAKEYPR_PAC_APIBKEYPR_PAC_APDAKEYPR_PAC_APDBKEYPR_PAC_APGAKEYPR_SME_SET_VLPR_SME_GET_VLPR_SME_VL_LEN_MAXPR_SME_SET_VL_INHERITPR_SME_SET_VL_ONE_EXEC// 38 is renameat only on LP64// 84 sync_file_range on LP64 and sync_file_range2 on ILP32// 163 is getrlimit only on LP64// 164 is setrlimit only on LP64//! AArch64-specific definitions for 64-bit linux-like values// FIXME(linux): enable these again once linux-api-headers are up to date enough on CI.// See discussion in https://github.com/rust-lang/libc/pull/1638//pub const HWCAP2_DCPODP: c_ulong = 1 << 0;//pub const HWCAP2_SVE2: c_ulong = 1 << 1;//pub const HWCAP2_SVEAES: c_ulong = 1 << 2;//pub const HWCAP2_SVEPMULL: c_ulong = 1 << 3;//pub const HWCAP2_SVEBITPERM: c_ulong = 1 << 4;//pub const HWCAP2_SVESHA3: c_ulong = 1 << 5;//pub const HWCAP2_SVESM4: c_ulong = 1 << 6;//pub const HWCAP2_FLAGM2: c_ulong = 1 << 7;//pub const HWCAP2_FRINT: c_ulong = 1 << 8;//pub const HWCAP2_MTE: c_ulong = 1 << 18;HWCAP_LOONGARCH_CPUCFGHWCAP_LOONGARCH_LAMHWCAP_LOONGARCH_UALHWCAP_LOONGARCH_FPUHWCAP_LOONGARCH_LSXHWCAP_LOONGARCH_LASXHWCAP_LOONGARCH_CRC32HWCAP_LOONGARCH_COMPLEXHWCAP_LOONGARCH_CRYPTOHWCAP_LOONGARCH_LVZHWCAP_LOONGARCH_LBT_X86HWCAP_LOONGARCH_LBT_ARMHWCAP_LOONGARCH_LBT_MIPSHWCAP_LOONGARCH_PTW//pub const SYS_arch_specific_syscall: c_long = 244;/* pub const SYS_sys_setaltroot: c_long = 5000 + 238; */loadstotalramfreeramsharedrambufferramtotalswapfreeswapprocstotalhighfreehighmem_unitmsg_permipc_permmsg_stimemsg_rtimemsg_ctime__msg_cbytesmsg_qnummsg_qbytesmsg_lspidmsg_lrpid__glibc_reserved4__glibc_reserved5sem_permsem_otime__reservedsem_ctime__reserved2sem_nsems__glibc_reserved3semid_ds//! 64-bit specific definitions for linux-like values//! PowerPC64-specific definitions for 64-bit linux-like valuesCOMPAT_HWCAP_ISA_V//! RISC-V-specific definitions for 64-bit linux-like valuesSYS_s390_runtime_instrSYS_s390_pci_mmio_writeSYS_s390_pci_mmio_read//! s390xSYS_memory_orderingSYS_utrap_install//! SPARC64-specific definitions for 64-bit linux-like valuessa_sigactionsa_masksa_flagssa_restorerf_typef_bsizef_blocksf_bfreef_bavailf_filesf_ffreef_fsidf_namelenf_frsizef_sparel_typel_whencel_startl_lenl_pidsi_signo_alignss_spss_flagsss_size__pad0f_flagsf_favailf_flagf_namemax__f_sparesignificand_libc_fpxreg_libc_xmmregswdftwfopriprdpmxcsrmxcr_mask_st_xmm_libc_fpstater15r14r13r12rbprbxr11r10r9r8raxrcxrdxrsirdiorig_raxcseflagsrspssfs_basegs_basedsesgsuser_regs_structregsu_fpvalidi387user_fpregs_structu_tsizeu_dsizeu_ssizestart_codestart_stacku_ar0u_fpstateu_commu_debugreggregsfpregs__keycuidcgid__pad1__seq__pad2__unused1__unused2shm_permshm_segszshm_atimeshm_dtimeshm_ctimeshm_cpidshm_lpidshm_nattch__unused4__unused5rseq_abi_pointerrseq_abi_sizeptrace_rseq_configurationpidfdchild_tidparent_tidexit_signalset_tidset_tid_sizecgroupclone_argsst_spacexmm_spaceuc_flagsuc_linkuc_stackuc_mcontextuc_sigmaskmax_align_tPTRACE_GET_RSEQ_CONFIGURATIONPTRACE_PEEKSIGINFO_SHAREDPR_GET_SPECULATION_CTRLPR_SET_SPECULATION_CTRLPR_SPEC_NOT_AFFECTEDPR_SPEC_PRCTLPR_SPEC_ENABLEPR_SPEC_DISABLEPR_SPEC_FORCE_DISABLEPR_SPEC_DISABLE_NOEXECPR_SPEC_STORE_BYPASSPR_SPEC_INDIRECT_BRANCHnot_x32//! x86_64-specific definitions for 64-bit linux-like values// FIXME(linux): perharps for later//pub const PR_SPEC_L1D_FLUSH: c_int = 2;__X32_SYSCALL_BIT__priority_which_t__kernel_rwf_taio_fildesaio_lio_opcodeaio_reqprioaio_bufaio_nbytesaio_sigevent__next_prio__abs_prio__policy__error_code__return_valueaio_offset__glibc_reservede_terminatione_exit__exit_status__timevalgl_pathcgl_pathvgl_offsgl_flags__unused3msg_namemsg_namelenmsg_iovmsg_iovlenmsg_controlmsg_controllenmsg_flagscmsg_lencmsg_levelcmsg_typearenaordblkssmblkshblkshblkhdusmblksfsmblksuordblksfordblkskeepcostnl_pktinfonm_block_sizenm_block_nrnm_frame_sizenm_frame_nrnl_mmap_reqnm_statusnm_lennm_groupnm_pidnm_uidnm_gidnl_mmap_hdrrt_pad1rt_dstrt_gatewayrt_genmaskrt_flagsrt_pad2rt_pad3rt_tosrt_classrt_pad4rt_metricrt_devrt_mturt_windowrt_irttrtentrymaxerroresterrorppsfreqstabiljitcntcalcnterrcntstbcnttai__unused6__unused7__unused8__unused9__unused10__unused11__glibc_reserved1__glibc_reserved2__buffer__allocated__used__syntax__fastmap__translate__re_nsub__bitfieldch_typech_reservedch_sizech_addralignElf64_ChdrElf32_Chdrsemmapsemmnisemmnssemmnusemmslsemopmsemumesemuszsemvmxsemaemseminfonrptrace_peeksiginfo_args__c_anonymous_ptrace_syscall_info_entrysval__c_anonymous_ptrace_syscall_info_exitret_data__c_anonymous_ptrace_syscall_info_seccompinstruction_pointerstack_pointer__c_anonymous_ptrace_syscall_info_dataptrace_syscall_infoaio_dataaio_keyaio_rw_flagsaio_reserved2aio_flagsaio_resfdiocbtcpi_statetcpi_ca_statetcpi_retransmitstcpi_probestcpi_backofftcpi_optionsr" This contains the bitfields `tcpi_snd_wscale` and `tcpi_rcv_wscale`."r" Each is 4 bits."tcpi_snd_rcv_wscaletcpi_rtotcpi_atotcpi_snd_msstcpi_rcv_msstcpi_unackedtcpi_sackedtcpi_losttcpi_retranstcpi_facketstcpi_last_data_senttcpi_last_ack_senttcpi_last_data_recvtcpi_last_ack_recvtcpi_pmtutcpi_rcv_ssthreshtcpi_rtttcpi_rttvartcpi_snd_ssthreshtcpi_snd_cwndtcpi_advmsstcpi_reorderingtcpi_rcv_rtttcpi_rcv_spacetcpi_total_retranstcp_infofanotify_event_info_headerfanotify_event_info_pidfderror_countfanotify_event_info_errorseccomput_typeut_pidut_lineut_idut_userut_hostut_exitut_sessionut_tvut_addr_v6// include/uapi/asm-generic/hugetlb_encode.hHUGETLB_FLAG_ENCODE_MASKHUGETLB_FLAG_ENCODE_64KBHUGETLB_FLAG_ENCODE_512KBHUGETLB_FLAG_ENCODE_1MBHUGETLB_FLAG_ENCODE_2MBHUGETLB_FLAG_ENCODE_8MBHUGETLB_FLAG_ENCODE_16MBHUGETLB_FLAG_ENCODE_32MBHUGETLB_FLAG_ENCODE_256MBHUGETLB_FLAG_ENCODE_512MBHUGETLB_FLAG_ENCODE_1GBHUGETLB_FLAG_ENCODE_2GBHUGETLB_FLAG_ENCODE_16GB// include/uapi/linux/mman.h/*
 * Huge page size encoding when MAP_HUGETLB is specified, and a huge page
 * size other than the default is desired.  See hugetlb_encode.h.
 * All known huge page size encodings are provided here.  It is the
 * responsibility of the application to know which sizes are supported on
 * the running system.  See mmap(2) man page for details.
 */PIDFD_NONBLOCKSOL_RXRPCSOL_PPPOL2TPSOL_PNPIPESOL_RDSSOL_IUCVSOL_CAIFSOL_NFCMSG_TRYHARDAF_XDPPF_XDPBINDERFS_SUPER_MAGICXFS_SUPER_MAGICPTRACE_GETSIGMASKPTRACE_SETSIGMASKPTRACE_GET_SYSCALL_INFOPTRACE_SYSCALL_INFO_NONEPTRACE_SYSCALL_INFO_ENTRYPTRACE_SYSCALL_INFO_EXITPTRACE_SYSCALL_INFO_SECCOMP// Flags for preadv2/pwritev2TCA_PADTCA_DUMP_INVISIBLETCA_CHAINTCA_HW_OFFLOADRTM_DELNETCONFRTM_NEWSTATSRTM_GETSTATSRTM_NEWCACHEREPORTRTM_F_LOOKUP_TABLERTM_F_FIB_MATCHRTA_VIARTA_NEWDSTRTA_PREFRTA_ENCAP_TYPERTA_ENCAPRTA_EXPIRESRTA_PADRTA_UIDRTA_TTL_PROPAGATE// linux/neighbor.hUNAME26// linux/personality.hFDPIC_FUNCPTRSELFOSABI_ARM_AEABICLONE_NEWTIMECLONE_CLEAR_SIGHAND// DIFF(main): changed to `c_ulonglong` in e9abac9ac2CLONE_INTO_CGROUPKEYCTL_DH_COMPUTE// linux/keyctl.hKEYCTL_PKEY_QUERYKEYCTL_PKEY_ENCRYPTKEYCTL_PKEY_DECRYPTKEYCTL_PKEY_SIGNKEYCTL_PKEY_VERIFYKEYCTL_RESTRICT_KEYRINGKEYCTL_SUPPORTS_ENCRYPTKEYCTL_SUPPORTS_DECRYPTKEYCTL_SUPPORTS_SIGNKEYCTL_SUPPORTS_VERIFYKEYCTL_MOVEKEYCTL_CAPABILITIESKEYCTL_CAPS0_CAPABILITIESKEYCTL_CAPS0_PERSISTENT_KEYRINGSKEYCTL_CAPS0_DIFFIE_HELLMANKEYCTL_CAPS0_PUBLIC_KEYKEYCTL_CAPS0_BIG_KEYKEYCTL_CAPS0_INVALIDATEKEYCTL_CAPS0_RESTRICT_KEYRINGKEYCTL_CAPS0_MOVEKEYCTL_CAPS1_NS_KEYRING_NAMEKEYCTL_CAPS1_NS_KEY_TAGM_MXFASTM_NLBLKSM_GRAINM_KEEPM_TRIM_THRESHOLDM_TOP_PADM_MMAP_THRESHOLDM_MMAP_MAXM_CHECK_ACTIONM_PERTURBM_ARENA_TESTM_ARENA_MAXMOVE_MOUNT_F_SYMLINKS// linux/mount.hMOVE_MOUNT_F_AUTOMOUNTSMOVE_MOUNT_F_EMPTY_PATHMOVE_MOUNT_T_SYMLINKSMOVE_MOUNT_T_AUTOMOUNTSMOVE_MOUNT_T_EMPTY_PATHMOVE_MOUNT_SET_GROUPMOVE_MOUNT_BENEATHADJ_OFFSET// sys/timex.hADJ_FREQUENCYADJ_MAXERRORADJ_ESTERRORADJ_STATUSADJ_TIMECONSTADJ_TAIADJ_SETOFFSETADJ_MICROADJ_NANOADJ_TICKADJ_OFFSET_SINGLESHOTADJ_OFFSET_SS_READTIME_BAD// Portable GLOB_* flags are defined at the `linux_like` level.// The following are GNU extensions.MADV_COLLAPSEREG_EENDREG_ESIZEREG_ERPARENTUNSETCARRIERTUNGETDEVNETNSadjtimex"ntp_gettimex"clock_adjtimefanotify_markpreadv2pwritev2preadv64v2pwritev64v2// Added in `glibc` 2.25pthread_attr_getaffinity_nppthread_attr_setaffinity_nppthread_rwlockattr_getkind_nppthread_rwlockattr_setkind_npmalloc_statsepoll_pwait2mempcpyb64// linux/fs.h__kernel_fsid_t__c_anonymous__kernel_fsid_t__kernel_clockid_tElf32_XwordElf32_RelrElf64_RelrElf32_Rel__c_anonymous_elf32_relElf64_Rel__c_anonymous_elf64_relElf32_Rela__c_anonymous_elf32_relaElf64_Rela__c_anonymous_elf64_relacanid_t// linux/can.hcan_err_mask_t// linux/can/j1939.hpgn_tpriority_tname_t// linux/sctp.htpacket_versionsTPACKET_V1TPACKET_V2TPACKET_V3pw_namepw_passwdpw_uidpw_gidpw_gecospw_dirpw_shellsp_nampsp_pwdpsp_lstchgsp_minsp_maxsp_warnsp_inactsp_expiresp_flagdqb_bhardlimitdqb_bsoftlimitdqb_curspacedqb_ihardlimitdqb_isoftlimitdqb_curinodesdqb_btimedqb_itimedqb_validdqblkssi_signossi_errnossi_codessi_pidssi_uidssi_fdssi_tidssi_bandssi_overrunssi_trapnossi_statusssi_intssi_ptrssi_utimessi_stimessi_addrssi_addr_lsb_pad2ssi_syscallssi_call_addrssi_archsignalfd_siginfoit_intervalit_valuemax_num_membersfanout_argsmr_ifindexmr_typemr_alenmr_addresspacket_mreqspkt_familyspkt_devicespkt_protocolsockaddr_pkttp_statustp_lentp_snaplentp_mactp_nettp_vlan_tcitp_vlan_tpidtpacket_auxdatatp_sectp_usectpacket_hdrtp_rxhashtp_paddingtpacket_hdr_variant1tp_nsectpacket2_hdrtp_block_sizetp_block_nrtp_frame_sizetp_frame_nrtpacket_reqtp_retire_blk_tovtp_sizeof_privtp_feature_req_wordtpacket_req3tp_alltp_hugetp_failedtpacket_rollover_statstp_packetstp_dropstpacket_statstp_freeze_q_cnttpacket_stats_v3tp_next_offsethv1tpacket3_hdrts_sects_usectpacket_bd_tsblock_statusnum_pktsoffset_to_first_pktblk_lents_first_pktts_last_pkttpacket_hdr_v1if_indexif_namemsgpoolmsgmapmsgmaxmsgmnbmsgmnimsgsszmsgtqlmsgsegmsginfosem_numsem_opsem_flgfuzzcodes_sizecodes_ptrinput_maskff_replayff_triggerattack_lengthattack_levelfade_lengthfade_levelff_envelopeff_constant_effectstart_levelend_levelff_ramp_effectright_saturationleft_saturationright_coeffleft_coeffdeadbandff_condition_effectwaveformmagnitudecustom_lencustom_dataff_periodic_effectstrong_magnitudeweak_magnitudeff_rumble_effectreplayuinput_ff_uploadeffect_iduinput_ff_eraseabsinfouinput_abs_setupdlpi_addrdlpi_namedlpi_phdrdlpi_phnumdlpi_addsdlpi_subsdlpi_tls_modiddlpi_tls_datae_idente_typee_machinee_versione_entrye_phoffe_shoffe_flagse_ehsizee_phentsizee_phnume_shentsizee_shnume_shstrndxst_namest_valuest_infost_otherst_shndxsh_namesh_typesh_flagssh_addrsh_offsetsh_sizesh_linksh_infosh_addralignsh_entsizer_offsetr_infoucredmnt_fsnamemnt_dirmnt_typemnt_optsmnt_freqmnt_passno__actions__pad__flags__pgrp__sd__ss__spgenlmsghdripi6_addrin6_addripi6_ifindexin6_pktinfohaarpd_requestfanotify_responseinfo_typefsidfanotify_event_info_fidsvm_familysvm_reserved1svm_portsvm_cidsvm_zerosockaddr_vmrm_sorm_eoee_errnoee_originee_typeee_codeee_padee_infoee_datasock_extended_errrx_idtx_id__c_anonymous_sockaddr_can_tppgn__c_anonymous_sockaddr_can_j1939can_idcan_maskcan_filtername_maskpgn_maskj1939_filterjtjfsock_filtersock_fprogseccomp_dataseccomp_notifseccomp_notif_respseccomp_notif_sizessrcfdnewfdnewfd_flagsseccomp_notif_addfdnlmsg_lennlmsg_typenlmsg_flagsnlmsg_seqnlmsg_pidnlmsghdrnlmsgerrnla_lennla_typenlattrsrc_offsetsrc_lengthdest_offsetfile_clone_rangemem_startmem_endbase_addrdma__c_anonymous_ifru_mapifr6_addrifr6_prefixlenifr6_ifindexin6_ifreqopen_howsecptp_clock_timeptp_extts_requestn_samplesclockidPTP_MAX_SAMPLESptp_sys_offset_extendedsys_realtimesys_monorawptp_sys_offset_preciseptp_extts_eventsinit_num_ostreamssinit_max_instreamssinit_max_attemptssinit_max_init_timeosctp_initmsgsinfo_streamsinfo_ssnsinfo_flagssinfo_ppidsinfo_contextsinfo_timetolivesinfo_tsnsinfo_cumtsnsinfo_assoc_idsctp_sndrcvinfosnd_sidsnd_flagssnd_ppidsnd_contextsnd_assoc_idsctp_sndinforcv_sidrcv_ssnrcv_flagsrcv_ppidrcv_tsnrcv_cumtsnrcv_contextrcv_assoc_idsctp_rcvinfonxt_sidnxt_flagsnxt_ppidnxt_lengthnxt_assoc_idsctp_nxtinfopr_policypr_valuesctp_prinfoauth_keynumbersctp_authinforlim_currlim_maxcipher_typetls_crypto_infoTLS_CIPHER_AES_GCM_128_IV_SIZETLS_CIPHER_AES_GCM_128_KEY_SIZETLS_CIPHER_AES_GCM_128_SALT_SIZErec_seqTLS_CIPHER_AES_GCM_128_REC_SEQ_SIZEtls12_crypto_info_aes_gcm_128TLS_CIPHER_AES_GCM_256_IV_SIZETLS_CIPHER_AES_GCM_256_KEY_SIZETLS_CIPHER_AES_GCM_256_SALT_SIZETLS_CIPHER_AES_GCM_256_REC_SEQ_SIZEtls12_crypto_info_aes_gcm_256TLS_CIPHER_CHACHA20_POLY1305_IV_SIZETLS_CIPHER_CHACHA20_POLY1305_KEY_SIZETLS_CIPHER_CHACHA20_POLY1305_SALT_SIZETLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZEtls12_crypto_info_chacha20_poly1305iw_paramiw_pointiw_freqiw_qualitynwidpubmisciw_discardedbeaconiw_missedscan_typeessid_lenbssidessidIW_ESSID_MAX_SIZEmin_channel_timemax_channel_timechannel_listIW_MAX_FREQUENCIESiw_scan_reqext_flagstx_seqIW_ENCODE_SEQ_MAX_SIZErx_seqalgkey_leniw_encode_extpmkidIW_PMKID_LENiw_pmksaiw_pmkid_candmissiw_statisticsthroughputmin_nwidmax_nwidold_num_channelsold_num_frequencyscan_capaevent_capasensitivitymax_qualavg_qualnum_bitratesbitrateIW_MAX_BITRATESmin_rtsmax_rtsmin_fragmax_fragmin_pmpmax_pmpmin_pmtmax_pmtpmp_flagspmt_flagspm_capaencoding_sizeIW_MAX_ENCODING_SIZESnum_encoding_sizesmax_encoding_tokensencoding_login_indextxpower_capanum_txpowertxpowerIW_MAX_TXPOWERwe_version_compiledwe_version_sourceretry_caparetry_flagsr_time_flagsmin_retrymax_retrymin_r_timemax_r_timenum_frequencyenc_capaiw_rangeset_argsiw_priv_argsbusy_poll_usecsbusy_poll_budgetprefer_busy_pollepoll_paramsevent_lenmetadata_lenfanotify_event_metadataptp_sys_offsetptp_pin_descmax_adjn_alarmn_ext_tsn_per_outppsn_pinscross_timestampingadjust_phasemax_phase_adjptp_clock_capssxdp_familysxdp_flagssxdp_ifindexsxdp_queue_idsxdp_shared_umem_fdsockaddr_xdpproducerconsumerxdp_ring_offsetfrxdp_mmap_offsetsxdp_ring_offset_v1xdp_mmap_offsets_v1chunk_sizeheadroomtx_metadata_lenxdp_umem_regxdp_umem_reg_v1rx_droppedrx_invalid_descstx_invalid_descsrx_ring_fullrx_fill_ring_empty_descstx_ring_empty_descsxdp_statisticsxdp_statistics_v1xdp_optionsxdp_desctx_timestampxsk_tx_metadata_completioncsum_startcsum_offsetxsk_tx_metadata_requestattr_setattr_clrpropagationuserns_fdmount_attrfrag_offsetfrag_sizefrag_tokendmabuf_iddmabuf_cmsgtoken_startdmabuf_tokenlowhighiw_thrspyreason_codeiw_mlmesrc_addrtsciw_michaelmicfailurer_addendnl_familynl_padnl_pidnl_groupssockaddr_nld_inod_offd_reclend_typed_namesalg_familysalg_typesalg_featsalg_masksalg_namesockaddr_algabsmaxabsminabsfuzzabsflatuinput_user_devr" WARNING: The `PartialEq`, `Eq` and `Hash` implementations of this"r" type are unsound and will be removed in the future."ivlenaf_alg_ivmq_flagsmq_maxmsgmq_msgsizemq_curmsgs__c_anonymous_ifr_ifruifru_dstaddrifru_broadaddrifru_netmaskifru_hwaddrifru_flagsifru_ifindexifru_metricifru_mtuifru_mapifru_slaveifru_newnameifru_datar#" interface name, e.g. "en0""#ifr_ifru__c_anonymous_ifc_ifcuifcu_bufifcu_reqr" Structure used in SIOCGIFCONF request.  Used to retrieve interface configuration for"r" machine (useful for programs which must know all networks accessible)."r" Size of buffer"ifc_lenifc_ifcuifconftx_typerx_filterhwtstamp_configsched_policysched_flagssched_nicesched_prioritysched_runtimesched_deadlinesched_periodsched_attrtpacket_req_ureq3tpacket_bd_header_ubh1offset_to_privtpacket_block_descsock_txtimecan_dlc__res0len8_dlcCAN_MAX_DLENcan_frame__res1CANFD_MAX_DLENcanfd_framepriosdtafCANXL_MAX_DLENcanxl_frame__c_anonymous_sockaddr_can_can_addrtpj1939can_familycan_ifindexcan_addrsockaddr_caniwreq_datasensrtsretrypowerap_addriw_event__c_anonymous_iwreqifrn_nameifr_ifrniwreq__c_anonymous_ptp_perout_request_1__c_anonymous_ptp_perout_request_2anonymous_1anonymous_2ptp_perout_requestxsk_tx_metadata_union__c_anonymous_xsk_tx_metadata_unionxsk_tx_metadata_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS_CS_POSIX_V5_WIDTH_RESTRICTED_ENVS_CS_POSIX_V7_WIDTH_RESTRICTED_ENVSEI_NIDENT// elf.h - Fields in the e_ident array.EI_MAG0ELFMAG0EI_MAG1ELFMAG1EI_MAG2ELFMAG2EI_MAG3ELFMAG3SELFMAGEI_CLASSELFCLASSNONEELFCLASS32ELFCLASS64ELFCLASSNUMEI_DATAELFDATANONEELFDATA2LSBELFDATA2MSBELFDATANUMEI_VERSIONEI_OSABIELFOSABI_NONEELFOSABI_SYSVELFOSABI_HPUXELFOSABI_NETBSDELFOSABI_GNUELFOSABI_LINUXELFOSABI_SOLARISELFOSABI_AIXELFOSABI_IRIXELFOSABI_FREEBSDELFOSABI_TRU64ELFOSABI_MODESTOELFOSABI_OPENBSDELFOSABI_ARMELFOSABI_STANDALONEEI_ABIVERSIONEI_PADET_NONE// elf.h - Legal values for e_type (object file type).ET_RELET_EXECET_DYNET_COREET_NUMET_LOOSET_HIOSET_LOPROCET_HIPROCEM_NONE// elf.h - Legal values for e_machine (architecture).EM_M32EM_SPARCEM_386EM_68KEM_88KEM_860EM_MIPSEM_S370EM_MIPS_RS3_LEEM_PARISCEM_VPP500EM_SPARC32PLUSEM_960EM_PPCEM_PPC64EM_S390EM_V800EM_FR20EM_RH32EM_RCEEM_ARMEM_FAKE_ALPHAEM_SHEM_SPARCV9EM_TRICOREEM_ARCEM_H8_300EM_H8_300HEM_H8SEM_H8_500EM_IA_64EM_MIPS_XEM_COLDFIREEM_68HC12EM_MMAEM_PCPEM_NCPUEM_NDR1EM_STARCOREEM_ME16EM_ST100EM_TINYJEM_X86_64EM_PDSPEM_FX66EM_ST9PLUSEM_ST7EM_68HC16EM_68HC11EM_68HC08EM_68HC05EM_SVXEM_ST19EM_VAXEM_CRISEM_JAVELINEM_FIREPATHEM_ZSPEM_MMIXEM_HUANYEM_PRISMEM_AVREM_FR30EM_D10VEM_D30VEM_V850EM_M32REM_MN10300EM_MN10200EM_PJEM_OPENRISCEM_ARC_A5EM_XTENSAEM_AARCH64EM_TILEPROEM_TILEGXEM_ALPHAEV_NONE// elf.h - Legal values for e_version (version).EV_CURRENTEV_NUM// elf.h - Legal values for p_type (segment type).PT_LOSUNWPT_SUNWBSSPT_SUNWSTACKPT_HISUNW// Legal values for p_flags (segment flags).// elf.h - Legal values for a_type (entry type).// defined in arch/<arch>/include/uapi/asm/auxvec.h but has the same value// wherever it is defined.IFA_FLAGSIFA_F_MANAGETEMPADDRIFA_F_NOPREFIXROUTEIFA_F_MCAUTOJOINIFA_F_STABLE_PRIVACY/* TUNSETIFF ifr flags */// Used in TUNSETIFF to bring up tun/tap without carrierTUN_READQ_SIZE// Read queue sizeTUN_TUN_DEV// TUN device type flags: deprecated. Use IFF_TUN/IFF_TAP instead.TUN_TAP_DEVTUN_TYPE_MASK// This flag has no real effect// read-only flagTUN_TX_TIMESTAMP// Socket optionsTUN_PKT_STRIP// Protocol info prepended to the packets (when IFF_NO_PI is not set)TUN_FLT_ALLMULTI// Accept all multicast packets// Since Linux 3.1MSG_ZEROCOPYSEM_STATSEM_INFOSEM_STAT_ANYPACKET_MR_UNICASTUDP_SEGMENTUDP_GROMREMAP_DONTUNMAPPR_SCHED_COREPR_SCHED_CORE_GETPR_SCHED_CORE_CREATEPR_SCHED_CORE_SHARE_TOPR_SCHED_CORE_SHARE_FROMPR_SCHED_CORE_MAXPR_SCHED_CORE_SCOPE_THREADPR_SCHED_CORE_SCOPE_THREAD_GROUPPR_SCHED_CORE_SCOPE_PROCESS_GROUP// <linux/seccomp.h>SECCOMP_SET_MODE_STRICTSECCOMP_SET_MODE_FILTERSECCOMP_GET_ACTION_AVAILSECCOMP_GET_NOTIF_SIZESSECCOMP_FILTER_FLAG_TSYNC_ESRCHSECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECVSECCOMP_USER_NOTIF_FLAG_CONTINUESECCOMP_ADDFD_FLAG_SETFDSECCOMP_ADDFD_FLAG_SENDSK_MEMINFO_RMEM_ALLOC// SO_MEMINFO offsetsSK_MEMINFO_RCVBUFSK_MEMINFO_WMEM_ALLOCSK_MEMINFO_SNDBUFSK_MEMINFO_FWD_ALLOCSK_MEMINFO_WMEM_QUEUEDSK_MEMINFO_OPTMEMSK_MEMINFO_BACKLOGSK_MEMINFO_DROPSCLOSE_RANGE_UNSHARE// linux/close_range.hSKF_AD_OFF// linux/filter.hSKF_AD_PROTOCOLSKF_AD_PKTTYPESKF_AD_IFINDEXSKF_AD_NLATTRSKF_AD_NLATTR_NESTSKF_AD_MARKSKF_AD_QUEUESKF_AD_HATYPESKF_AD_RXHASHSKF_AD_CPUSKF_AD_ALU_XOR_XSKF_AD_VLAN_TAGSKF_AD_VLAN_TAG_PRESENTSKF_AD_PAY_OFFSETSKF_AD_RANDOMSKF_AD_VLAN_TPIDSKF_AD_MAXSKF_NET_OFFSKF_LL_OFFBPF_NET_OFFBPF_LL_OFF// linux/bpf_common.hBPF_MODBPF_XORRESOLVE_NO_XDEV// linux/openat2.hRESOLVE_NO_MAGICLINKSRESOLVE_NO_SYMLINKSRESOLVE_BENEATHRESOLVE_IN_ROOTRESOLVE_CACHED// linux/if_ether.h// These are the defined Ethernet Protocol ID's.// Non DIX types. Won't clash for 1500 types.NFNLGRP_NFTRACENFNL_SUBSYS_HOOKNFNL_BATCH_UNSPECNFNL_BATCH_GENIDNFULA_VLAN_UNSPECNFULA_VLAN_PROTONFULA_VLAN_TCINFULA_VLANNFULA_L2HDR// linux/netfilter/nfnetlink_queue.hNFQA_VLANNFQA_L2HDRNFQA_PRIORITYNFQA_VLAN_UNSPECNFQA_VLAN_PROTONFQA_VLAN_TCIPACKET_HOST// linux/if_packet.hPACKET_BROADCASTPACKET_MULTICASTPACKET_OTHERHOSTPACKET_OUTGOINGPACKET_LOOPBACKPACKET_USERPACKET_KERNELPACKET_ADD_MEMBERSHIPPACKET_DROP_MEMBERSHIPPACKET_RX_RINGPACKET_STATISTICSPACKET_AUXDATAPACKET_VERSIONPACKET_RESERVEPACKET_TX_RINGPACKET_LOSSPACKET_TIMESTAMPPACKET_FANOUTPACKET_QDISC_BYPASSPACKET_FANOUT_HASHPACKET_FANOUT_LBPACKET_FANOUT_CPUPACKET_FANOUT_ROLLOVERPACKET_FANOUT_RNDPACKET_FANOUT_QMPACKET_FANOUT_CBPFPACKET_FANOUT_EBPFPACKET_FANOUT_FLAG_ROLLOVERPACKET_FANOUT_FLAG_UNIQUEIDPACKET_FANOUT_FLAG_DEFRAGPACKET_MR_MULTICASTPACKET_MR_PROMISCPACKET_MR_ALLMULTITP_STATUS_KERNELTP_STATUS_USERTP_STATUS_COPYTP_STATUS_LOSINGTP_STATUS_CSUMNOTREADYTP_STATUS_VLAN_VALIDTP_STATUS_BLK_TMOTP_STATUS_VLAN_TPID_VALIDTP_STATUS_CSUM_VALIDTP_STATUS_AVAILABLETP_STATUS_SEND_REQUESTTP_STATUS_SENDINGTP_STATUS_WRONG_FORMATTP_STATUS_TS_SOFTWARETP_STATUS_TS_SYS_HARDWARETP_STATUS_TS_RAW_HARDWARETP_FT_REQ_FILL_RXHASHTPACKET_ALIGNMENTTPACKET_HDRLENTPACKET2_HDRLENTPACKET3_HDRLEN// Some NFPROTO are not compatible with musl and are defined in submodules.WIRELESS_EXT// wireless.hSIOCSIWCOMMITSIOCGIWNAMESIOCSIWNWIDSIOCGIWNWIDSIOCSIWFREQSIOCGIWFREQSIOCSIWMODESIOCGIWMODESIOCSIWSENSSIOCGIWSENSSIOCSIWRANGESIOCGIWRANGESIOCSIWPRIVSIOCGIWPRIVSIOCSIWSTATSSIOCGIWSTATSSIOCSIWSPYSIOCGIWSPYSIOCSIWTHRSPYSIOCGIWTHRSPYSIOCSIWAPSIOCGIWAPSIOCGIWAPLISTSIOCSIWSCANSIOCGIWSCANSIOCSIWESSIDSIOCGIWESSIDSIOCSIWNICKNSIOCGIWNICKNSIOCSIWRATESIOCGIWRATESIOCSIWRTSSIOCGIWRTSSIOCSIWFRAGSIOCGIWFRAGSIOCSIWTXPOWSIOCGIWTXPOWSIOCSIWRETRYSIOCGIWRETRYSIOCSIWENCODESIOCGIWENCODESIOCSIWPOWERSIOCGIWPOWERSIOCSIWGENIESIOCGIWGENIESIOCSIWMLMESIOCSIWAUTHSIOCGIWAUTHSIOCSIWENCODEEXTSIOCGIWENCODEEXTSIOCSIWPMKSASIOCIWFIRSTPRIVSIOCIWLASTPRIVSIOCIWFIRSTSIOCIWLASTIWEVTXDROPIWEVQUALIWEVCUSTOMIWEVREGISTEREDIWEVEXPIREDIWEVGENIEIWEVMICHAELMICFAILUREIWEVASSOCREQIEIWEVASSOCRESPIEIWEVPMKIDCANDIWEVFIRSTIW_PRIV_TYPE_MASKIW_PRIV_TYPE_NONEIW_PRIV_TYPE_BYTEIW_PRIV_TYPE_CHARIW_PRIV_TYPE_INTIW_PRIV_TYPE_FLOATIW_PRIV_TYPE_ADDRIW_PRIV_SIZE_FIXEDIW_PRIV_SIZE_MASKIW_MAX_SPYIW_MAX_APIW_MODE_AUTOIW_MODE_ADHOCIW_MODE_INFRAIW_MODE_MASTERIW_MODE_REPEATIW_MODE_SECONDIW_MODE_MONITORIW_MODE_MESHIW_QUAL_QUAL_UPDATEDIW_QUAL_LEVEL_UPDATEDIW_QUAL_NOISE_UPDATEDIW_QUAL_ALL_UPDATEDIW_QUAL_DBMIW_QUAL_QUAL_INVALIDIW_QUAL_LEVEL_INVALIDIW_QUAL_NOISE_INVALIDIW_QUAL_RCPIIW_QUAL_ALL_INVALIDIW_FREQ_AUTOIW_FREQ_FIXEDIW_ENCODING_TOKEN_MAXIW_ENCODE_INDEXIW_ENCODE_FLAGSIW_ENCODE_MODEIW_ENCODE_DISABLEDIW_ENCODE_ENABLEDIW_ENCODE_RESTRICTEDIW_ENCODE_OPENIW_ENCODE_NOKEYIW_ENCODE_TEMPIW_POWER_ONIW_POWER_TYPEIW_POWER_PERIODIW_POWER_TIMEOUTIW_POWER_MODEIW_POWER_UNICAST_RIW_POWER_MULTICAST_RIW_POWER_ALL_RIW_POWER_FORCE_SIW_POWER_REPEATERIW_POWER_MODIFIERIW_POWER_MINIW_POWER_MAXIW_POWER_RELATIVEIW_TXPOW_TYPEIW_TXPOW_DBMIW_TXPOW_MWATTIW_TXPOW_RELATIVEIW_TXPOW_RANGEIW_RETRY_ONIW_RETRY_TYPEIW_RETRY_LIMITIW_RETRY_LIFETIMEIW_RETRY_MODIFIERIW_RETRY_MINIW_RETRY_MAXIW_RETRY_RELATIVEIW_RETRY_SHORTIW_RETRY_LONGIW_SCAN_DEFAULTIW_SCAN_ALL_ESSIDIW_SCAN_THIS_ESSIDIW_SCAN_ALL_FREQIW_SCAN_THIS_FREQIW_SCAN_ALL_MODEIW_SCAN_THIS_MODEIW_SCAN_ALL_RATEIW_SCAN_THIS_RATEIW_SCAN_TYPE_ACTIVEIW_SCAN_TYPE_PASSIVEIW_SCAN_MAX_DATAIW_SCAN_CAPA_NONEIW_SCAN_CAPA_ESSIDIW_SCAN_CAPA_BSSIDIW_SCAN_CAPA_CHANNELIW_SCAN_CAPA_MODEIW_SCAN_CAPA_RATEIW_SCAN_CAPA_TYPEIW_SCAN_CAPA_TIMEIW_CUSTOM_MAXIW_GENERIC_IE_MAXIW_MLME_DEAUTHIW_MLME_DISASSOCIW_MLME_AUTHIW_MLME_ASSOCIW_AUTH_INDEXIW_AUTH_FLAGSIW_AUTH_WPA_VERSIONIW_AUTH_CIPHER_PAIRWISEIW_AUTH_CIPHER_GROUPIW_AUTH_KEY_MGMTIW_AUTH_TKIP_COUNTERMEASURESIW_AUTH_DROP_UNENCRYPTEDIW_AUTH_80211_AUTH_ALGIW_AUTH_WPA_ENABLEDIW_AUTH_RX_UNENCRYPTED_EAPOLIW_AUTH_ROAMING_CONTROLIW_AUTH_PRIVACY_INVOKEDIW_AUTH_CIPHER_GROUP_MGMTIW_AUTH_MFPIW_AUTH_WPA_VERSION_DISABLEDIW_AUTH_WPA_VERSION_WPAIW_AUTH_WPA_VERSION_WPA2IW_AUTH_CIPHER_NONEIW_AUTH_CIPHER_WEP40IW_AUTH_CIPHER_TKIPIW_AUTH_CIPHER_CCMPIW_AUTH_CIPHER_WEP104IW_AUTH_CIPHER_AES_CMACIW_AUTH_KEY_MGMT_802_1XIW_AUTH_KEY_MGMT_PSKIW_AUTH_ALG_OPEN_SYSTEMIW_AUTH_ALG_SHARED_KEYIW_AUTH_ALG_LEAPIW_AUTH_ROAMING_ENABLEIW_AUTH_ROAMING_DISABLEIW_AUTH_MFP_DISABLEDIW_AUTH_MFP_OPTIONALIW_AUTH_MFP_REQUIREDIW_ENCODE_ALG_NONEIW_ENCODE_ALG_WEPIW_ENCODE_ALG_TKIPIW_ENCODE_ALG_CCMPIW_ENCODE_ALG_PMKIW_ENCODE_ALG_AES_CMACIW_ENCODE_EXT_TX_SEQ_VALIDIW_ENCODE_EXT_RX_SEQ_VALIDIW_ENCODE_EXT_GROUP_KEYIW_ENCODE_EXT_SET_TX_KEYIW_MICFAILURE_KEY_IDIW_MICFAILURE_GROUPIW_MICFAILURE_PAIRWISEIW_MICFAILURE_STAKEYIW_MICFAILURE_COUNTIW_ENC_CAPA_WPAIW_ENC_CAPA_WPA2IW_ENC_CAPA_CIPHER_TKIPIW_ENC_CAPA_CIPHER_CCMPIW_ENC_CAPA_4WAY_HANDSHAKEIW_EVENT_CAPA_K_0IW_EVENT_CAPA_K_1//   IW_EVENT_CAPA_MASK(0x8B04) | IW_EVENT_CAPA_MASK(0x8B06) | IW_EVENT_CAPA_MASK(0x8B1A);IW_PMKSA_ADDIW_PMKSA_REMOVEIW_PMKSA_FLUSHIW_PMKID_CAND_PREAUTHIW_EV_LCP_PK_LENIW_EV_CHAR_PK_LENIW_EV_UINT_PK_LEN// IW_EV_LCP_PK_LEN + crate::IFNAMSIZ;IW_EV_FREQ_PK_LEN// IW_EV_LCP_PK_LEN + size_of::<u32>();IW_EV_PARAM_PK_LEN// IW_EV_LCP_PK_LEN + size_of::<iw_freq>();IW_EV_ADDR_PK_LEN// IW_EV_LCP_PK_LEN + size_of::<iw_param>();IW_EV_QUAL_PK_LEN// IW_EV_LCP_PK_LEN + size_of::<crate::sockaddr>();IW_EV_POINT_PK_LEN// IW_EV_LCP_PK_LEN + size_of::<iw_quality>();RTF_REINSTATERTF_MTURTF_MSSRTF_WINDOWRTF_IRTTRTF_NOFORWARDRTF_THROWRTF_NOPMTUDISCRTF_DEFAULTRTF_ALLONLINKRTF_ADDRCONFRTF_LINKRTRTF_NONEXTHOPRTF_CACHERTF_FLOWRTF_POLICYRTCF_VALVERTCF_MASQRTCF_NATRTCF_DOREDIRECTRTCF_LOGRTCF_DIRECTSRCRTF_INTERFACERTF_NATRTF_ADDRCLASSMASKRT_CLASS_UNSPECRT_CLASS_DEFAULTRT_CLASS_MAINRT_CLASS_LOCALRT_CLASS_MAX// linux/netlink.hRTMSG_OVERRUNRTMSG_NEWRULERTMSG_DELRULERTMSG_CONTROLRTMSG_AR_FAILEDRTEXT_FILTER_VFRTEXT_FILTER_BRVLANRTEXT_FILTER_BRVLAN_COMPRESSEDRTEXT_FILTER_SKIP_STATSRTEXT_FILTER_MRPRTEXT_FILTER_CFM_CONFIGRTEXT_FILTER_CFM_STATUSRTMGRP_LINK// userspace compat definitions for RTNLGRP_*RTMGRP_NOTIFYRTMGRP_NEIGHRTMGRP_TCRTMGRP_IPV4_IFADDRRTMGRP_IPV4_MROUTERTMGRP_IPV4_ROUTERTMGRP_IPV4_RULERTMGRP_IPV6_IFADDRRTMGRP_IPV6_MROUTERTMGRP_IPV6_ROUTERTMGRP_IPV6_IFINFORTMGRP_DECnet_IFADDRRTMGRP_DECnet_ROUTERTMGRP_IPV6_PREFIXRTNLGRP_NONE// enum rtnetlink_groupsRTNLGRP_LINKRTNLGRP_NOTIFYRTNLGRP_NEIGHRTNLGRP_TCRTNLGRP_IPV4_IFADDRRTNLGRP_IPV4_MROUTERTNLGRP_IPV4_ROUTERTNLGRP_IPV4_RULERTNLGRP_IPV6_IFADDRRTNLGRP_IPV6_MROUTERTNLGRP_IPV6_ROUTERTNLGRP_IPV6_IFINFORTNLGRP_DECnet_IFADDRRTNLGRP_NOP2RTNLGRP_DECnet_ROUTERTNLGRP_DECnet_RULERTNLGRP_NOP4RTNLGRP_IPV6_PREFIXRTNLGRP_IPV6_RULERTNLGRP_ND_USEROPTRTNLGRP_PHONET_IFADDRRTNLGRP_PHONET_ROUTERTNLGRP_DCBRTNLGRP_IPV4_NETCONFRTNLGRP_IPV6_NETCONFRTNLGRP_MDBRTNLGRP_MPLS_ROUTERTNLGRP_NSIDRTNLGRP_MPLS_NETCONFRTNLGRP_IPV4_MROUTE_RRTNLGRP_IPV6_MROUTE_RRTNLGRP_NEXTHOPRTNLGRP_BRVLANRTNLGRP_MCTP_IFADDRRTNLGRP_TUNNELRTNLGRP_STATSSOF_TXTIME_DEADLINE_MODESOF_TXTIME_REPORT_ERRORSHWTSTAMP_TX_OFFHWTSTAMP_TX_ONHWTSTAMP_TX_ONESTEP_SYNCHWTSTAMP_TX_ONESTEP_P2PHWTSTAMP_FILTER_NONEHWTSTAMP_FILTER_ALLHWTSTAMP_FILTER_SOMEHWTSTAMP_FILTER_PTP_V1_L4_EVENTHWTSTAMP_FILTER_PTP_V1_L4_SYNCHWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQHWTSTAMP_FILTER_PTP_V2_L4_EVENTHWTSTAMP_FILTER_PTP_V2_L4_SYNCHWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQHWTSTAMP_FILTER_PTP_V2_L2_EVENTHWTSTAMP_FILTER_PTP_V2_L2_SYNCHWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQHWTSTAMP_FILTER_PTP_V2_EVENTHWTSTAMP_FILTER_PTP_V2_SYNCHWTSTAMP_FILTER_PTP_V2_DELAY_REQHWTSTAMP_FILTER_NTP_ALL// linux/ptp_clock.hPTP_CLK_MAGICPTP_CLOCK_GETCAPSPTP_EXTTS_REQUESTPTP_PEROUT_REQUESTPTP_ENABLE_PPSPTP_SYS_OFFSETPTP_PIN_GETFUNCPTP_PIN_SETFUNCPTP_SYS_OFFSET_PRECISEPTP_SYS_OFFSET_EXTENDEDPTP_CLOCK_GETCAPS2PTP_EXTTS_REQUEST2PTP_PEROUT_REQUEST2PTP_ENABLE_PPS2PTP_SYS_OFFSET2PTP_PIN_GETFUNC2PTP_PIN_SETFUNC2PTP_SYS_OFFSET_PRECISE2PTP_SYS_OFFSET_EXTENDED2PTP_PF_NONE// enum ptp_pin_functionPTP_PF_EXTTSPTP_PF_PEROUTPTP_PF_PHYSYNCTLS_TX// linux/tls.hTLS_RXTLS_1_2_VERSION_MAJORTLS_1_2_VERSION_MINORTLS_1_2_VERSIONTLS_1_3_VERSION_MAJORTLS_1_3_VERSION_MINORTLS_1_3_VERSIONTLS_CIPHER_AES_GCM_128TLS_CIPHER_AES_GCM_128_TAG_SIZETLS_CIPHER_AES_GCM_256TLS_CIPHER_AES_GCM_256_TAG_SIZETLS_CIPHER_CHACHA20_POLY1305TLS_CIPHER_CHACHA20_POLY1305_TAG_SIZETLS_SET_RECORD_TYPETLS_GET_RECORD_TYPESOL_TLSALG_SET_KEY_BY_KEY_SERIALIF_OPER_UNKNOWN// include/uapi/linux/if.hIF_OPER_NOTPRESENTIF_OPER_DOWNIF_OPER_LOWERLAYERDOWNIF_OPER_TESTINGIF_OPER_DORMANTIF_OPER_UPIF_LINK_MODE_DEFAULTIF_LINK_MODE_DORMANTIF_LINK_MODE_TESTINGUDP_CORK// include/uapi/linux/udp.hUDP_ENCAPUDP_NO_CHECK6_TXUDP_NO_CHECK6_RXMAP_DROPPABLE// include/uapi/asm-generic/mman-common.hKEY_SPEC_THREAD_KEYRINGKEY_SPEC_PROCESS_KEYRINGKEY_SPEC_SESSION_KEYRINGKEY_SPEC_USER_KEYRINGKEY_SPEC_USER_SESSION_KEYRINGKEY_SPEC_GROUP_KEYRINGKEY_SPEC_REQKEY_AUTH_KEYKEY_SPEC_REQUESTOR_KEYRINGKEY_REQKEY_DEFL_NO_CHANGEKEY_REQKEY_DEFL_DEFAULTKEY_REQKEY_DEFL_THREAD_KEYRINGKEY_REQKEY_DEFL_PROCESS_KEYRINGKEY_REQKEY_DEFL_SESSION_KEYRINGKEY_REQKEY_DEFL_USER_KEYRINGKEY_REQKEY_DEFL_USER_SESSION_KEYRINGKEY_REQKEY_DEFL_GROUP_KEYRINGKEY_REQKEY_DEFL_REQUESTOR_KEYRINGKEYCTL_GET_KEYRING_IDKEYCTL_JOIN_SESSION_KEYRINGKEYCTL_UPDATEKEYCTL_REVOKEKEYCTL_CHOWNKEYCTL_SETPERMKEYCTL_DESCRIBEKEYCTL_CLEARKEYCTL_LINKKEYCTL_UNLINKKEYCTL_SEARCHKEYCTL_READKEYCTL_INSTANTIATEKEYCTL_NEGATEKEYCTL_SET_REQKEY_KEYRINGKEYCTL_SET_TIMEOUTKEYCTL_ASSUME_AUTHORITYKEYCTL_GET_SECURITYKEYCTL_SESSION_TO_PARENTKEYCTL_REJECTKEYCTL_INSTANTIATE_IOVKEYCTL_INVALIDATEKEYCTL_GET_PERSISTENT// uapi/linux/netfilter/nf_tables.hFAN_ACCESS// uapi/linux/fanotify.hFAN_MODIFYFAN_ATTRIBFAN_CLOSE_WRITEFAN_CLOSE_NOWRITEFAN_OPENFAN_MOVED_FROMFAN_MOVED_TOFAN_CREATEFAN_DELETEFAN_DELETE_SELFFAN_MOVE_SELFFAN_OPEN_EXECFAN_Q_OVERFLOWFAN_FS_ERRORFAN_OPEN_PERMFAN_ACCESS_PERMFAN_OPEN_EXEC_PERMFAN_EVENT_ON_CHILDFAN_RENAMEFAN_ONDIRFAN_CLOSEFAN_MOVEFAN_CLOEXECFAN_NONBLOCKFAN_CLASS_NOTIFFAN_CLASS_CONTENTFAN_CLASS_PRE_CONTENTFAN_UNLIMITED_QUEUEFAN_UNLIMITED_MARKSFAN_ENABLE_AUDITFAN_REPORT_PIDFDFAN_REPORT_TIDFAN_REPORT_FIDFAN_REPORT_DIR_FIDFAN_REPORT_NAMEFAN_REPORT_TARGET_FIDFAN_REPORT_DFID_NAMEFAN_REPORT_DFID_NAME_TARGETFAN_MARK_ADDFAN_MARK_REMOVEFAN_MARK_DONT_FOLLOWFAN_MARK_ONLYDIRFAN_MARK_IGNORED_MASKFAN_MARK_IGNORED_SURV_MODIFYFAN_MARK_FLUSHFAN_MARK_EVICTABLEFAN_MARK_IGNOREFAN_MARK_INODEFAN_MARK_MOUNTFAN_MARK_FILESYSTEMFAN_MARK_IGNORE_SURVFANOTIFY_METADATA_VERSIONFAN_EVENT_INFO_TYPE_FIDFAN_EVENT_INFO_TYPE_DFID_NAMEFAN_EVENT_INFO_TYPE_DFIDFAN_EVENT_INFO_TYPE_PIDFDFAN_EVENT_INFO_TYPE_ERRORFAN_EVENT_INFO_TYPE_OLD_DFID_NAMEFAN_EVENT_INFO_TYPE_NEW_DFID_NAMEFAN_RESPONSE_INFO_NONEFAN_RESPONSE_INFO_AUDIT_RULEFAN_ALLOWFAN_DENYFAN_AUDITFAN_INFOFAN_NOFDFAN_NOPIDFDFAN_EPIDFD// linux/futex.hFUTEX_OP_SETFUTEX_OP_ADDFUTEX_OP_ORFUTEX_OP_ANDNFUTEX_OP_XORFUTEX_OP_OPARG_SHIFTFUTEX_OP_CMP_EQFUTEX_OP_CMP_NEFUTEX_OP_CMP_LTFUTEX_OP_CMP_LEFUTEX_OP_CMP_GTFUTEX_OP_CMP_GEFUTEX_OP// linux/reboot.hCAN_EFF_FLAGCAN_RTR_FLAGCAN_ERR_FLAGCAN_SFF_MASKCAN_EFF_MASKCAN_ERR_MASKCANXL_PRIO_MASKCAN_SFF_ID_BITSCAN_EFF_ID_BITSCANXL_PRIO_BITSCAN_MAX_DLCCANFD_MAX_DLCCANFD_BRSCANFD_ESICANFD_FDFCANXL_MIN_DLCCANXL_MAX_DLCCANXL_MAX_DLC_MASKCANXL_MIN_DLENCANXL_XLFCANXL_SECCAN_MTUCANFD_MTUCANXL_MTUCANXL_HDR_SIZE// FIXME(offset_of): use `core::mem::offset_of!` once that is available// https://github.com/rust-lang/rfcs/pull/3308// pub const CANXL_HDR_SIZE: usize = core::mem::offset_of!(canxl_frame, data);CANXL_MIN_MTUCANXL_MAX_MTUCAN_RAWCAN_BCMCAN_TP16CAN_TP20CAN_MCNETCAN_ISOTPCAN_J1939CAN_NPROTOSOL_CAN_BASECAN_INV_FILTERCAN_RAW_FILTER_MAXSOL_CAN_RAW// linux/can/raw.hCAN_RAW_FILTERCAN_RAW_ERR_FILTERCAN_RAW_LOOPBACKCAN_RAW_RECV_OWN_MSGSCAN_RAW_FD_FRAMESCAN_RAW_JOIN_FILTERSCAN_RAW_XL_FRAMESSOL_CAN_J1939J1939_MAX_UNICAST_ADDRJ1939_IDLE_ADDRJ1939_NO_ADDRJ1939_NO_NAMEJ1939_PGN_REQUESTJ1939_PGN_ADDRESS_CLAIMEDJ1939_PGN_ADDRESS_COMMANDEDJ1939_PGN_PDU1_MAXJ1939_PGN_MAXJ1939_NO_PGNSO_J1939_FILTERSO_J1939_PROMISCSO_J1939_SEND_PRIOSO_J1939_ERRQUEUESCM_J1939_DEST_ADDRSCM_J1939_DEST_NAMESCM_J1939_PRIOSCM_J1939_ERRQUEUEJ1939_NLA_PADJ1939_NLA_BYTES_ACKEDJ1939_NLA_TOTAL_SIZEJ1939_NLA_PGNJ1939_NLA_SRC_NAMEJ1939_NLA_DEST_NAMEJ1939_NLA_SRC_ADDRJ1939_NLA_DEST_ADDRJ1939_EE_INFO_NONEJ1939_EE_INFO_TX_ABORTJ1939_EE_INFO_RX_RTSJ1939_EE_INFO_RX_DPOJ1939_EE_INFO_RX_ABORTJ1939_FILTER_MAXSCTP_DELAYED_ACK_TIMESCTP_DELAYED_ACKSCTP_PEER_ADDR_THLDS_V2SCTP_PR_SCTP_MASKSCTP_ENABLE_RESET_STREAM_REQSCTP_ENABLE_RESET_ASSOC_REQSCTP_ENABLE_CHANGE_ASSOC_REQSCTP_ENABLE_STRRESET_MASKSCTP_STREAM_RESET_INCOMINGSCTP_STREAM_RESET_OUTGOINGKERN_NMI_WATCHDOGKERN_PANIC_ON_NMIVM_MIN_SLABNET_IRDA/// I'm a virtual CPU./// I am an IDLE thread./// Getting shut down./// Coredumps should ignore this task./// Task is an IO worker./// I'm a workqueue worker./// Forked but didn't exec./// Process policy on mce errors./// Used super-user privileges./// Dumped core./// Killed by a signal./// Allocating memory to free memory./// See `memalloc_noreclaim_save()`./// `set_user()` noticed that `RLIMIT_NPROC` was exceeded./// If unset the fpu must be initialized before use./// Kernel thread cloned from userspace thread./// This thread should not be frozen./// I am `kswapd`./// All allocations inherit `GFP_NOFS`./// See `memalloc_nfs_save()`./// All allocations inherit `GFP_NOIO`./// See `memalloc_noio_save()`./// Throttle writes only against the bdi I write to, I am cleaning/// dirty pages from some other bdi./// I am a kernel thread./// Randomize virtual address space./// Userland is not allowed to meddle with `cpus_mask`./// Early kill for mce process policy./// Allocations constrained to zones which allow long term pinning./// See `memalloc_pin_save()`.PF_BLOCK_TS/// Plug has ts that needs updating./// This thread called `freeze_processes()` and should not be frozen.PF_SUSPEND_TASK_UINT// The used value is the highest possible bit fitting on 32 bits, so directly// defining it as a signed integer causes the compiler to report an overflow.// Use instead a private intermediary that assuringly has the correct type and// cast it where necessary to the wanted final type, which preserves the// desired information as-is in terms of integer representation.CSIGNALSCHED_FLAG_RESET_ON_FORKSCHED_FLAG_RECLAIMSCHED_FLAG_DL_OVERRUNSCHED_FLAG_KEEP_POLICYSCHED_FLAG_KEEP_PARAMSSCHED_FLAG_UTIL_CLAMP_MINSCHED_FLAG_UTIL_CLAMP_MAXXDP_SHARED_UMEM// linux/if_xdp.hXDP_COPYXDP_ZEROCOPYXDP_USE_NEED_WAKEUPXDP_USE_SGXDP_UMEM_UNALIGNED_CHUNK_FLAGXDP_RING_NEED_WAKEUPXDP_MMAP_OFFSETSXDP_RX_RINGXDP_TX_RINGXDP_UMEM_REGXDP_UMEM_FILL_RINGXDP_UMEM_COMPLETION_RINGXDP_STATISTICSXDP_OPTIONSXDP_OPTIONS_ZEROCOPYXDP_PGOFF_RX_RINGXDP_PGOFF_TX_RINGXDP_UMEM_PGOFF_FILL_RINGXDP_UMEM_PGOFF_COMPLETION_RINGXSK_UNALIGNED_BUF_OFFSET_SHIFTXSK_UNALIGNED_BUF_ADDR_MASKXDP_PKT_CONTDXDP_UMEM_TX_SW_CSUMXDP_UMEM_TX_METADATA_LENXDP_TXMD_FLAGS_TIMESTAMPXDP_TXMD_FLAGS_CHECKSUMXDP_TX_METADATASOL_XDPMOUNT_ATTR_RDONLYMOUNT_ATTR_NOSUIDMOUNT_ATTR_NODEVMOUNT_ATTR_NOEXECMOUNT_ATTR__ATIMEMOUNT_ATTR_RELATIMEMOUNT_ATTR_NOATIMEMOUNT_ATTR_STRICTATIMEMOUNT_ATTR_NODIRATIMEMOUNT_ATTR_IDMAPMOUNT_ATTR_NOSYMFOLLOWMOUNT_ATTR_SIZE_VER0NT_PRSTATUSNT_PRFPREGNT_FPREGSETNT_PRPSINFONT_PRXREGNT_TASKSTRUCTNT_PLATFORMNT_AUXVNT_GWINDOWSNT_ASRSNT_PSTATUSNT_PSINFONT_PRCREDNT_UTSNAMENT_LWPSTATUSNT_LWPSINFONT_PRFPXREGSCHED_FLAG_KEEP_ALLSCHED_FLAG_UTIL_CLAMPSCHED_FLAG_ALLEPIOCSPARAMS// ioctl_eventpoll: added in Linux 6.9EPIOCGPARAMS// https://github.com/search?q=repo%3Atorvalds%2Flinux+%22%23define+_IOC_NONE%22&type=code/// Build an ioctl number, analogous to the C macro of the same name./// Build an ioctl number for an argumentless ioctl./// Build an ioctl number for an read-only ioctl./// Build an ioctl number for an write-only ioctl._IOWR/// Build an ioctl number for a read-write ioctl.NLA_ALIGNCMSG_NXTHDRCPU_ALLOC_SIZECPU_ZEROCPU_SETCPU_CLRCPU_ISSETCPU_EQUALSCTP_PR_INDEXSCTP_PR_POLICYSCTP_PR_SET_POLICYIPTOS_TOSIPTOS_PRECRT_TOSRT_ADDRCLASSRT_LOCALADDRSO_EE_OFFENDERTPACKET_ALIGNBPF_RVALBPF_MISCOPBPF_STMTBPF_JUMPELF32_R_SYMELF32_R_TYPEELF32_R_INFOELF64_R_SYMELF64_R_TYPEELF64_R_INFOmakedevSCTP_PR_TTL_ENABLEDSCTP_PR_RTX_ENABLEDSCTP_PR_PRIO_ENABLEDioplioperm// These functions are not available on OpenHarmonyepoll_pwaitremap_file_pagesfanotify_init// LFS64 extensions// * musl has 64-bit versions only so aliases the LFS64 symbols to the standard ones//! Linux-specific definitions for linux-like values// linux/genetlink.h//   W_EVENT_CAPA_MASK(0x8B2A);// IW_EV_LCP_PK_LEN + 4;// Maximum allowed offset measurement samples.// adapted from https://github.com/torvalds/linux/blob/8a696a29c6905594e4abf78eaafcb62165ac61f1/rust/kernel/ioctl.rsAF_KCMAF_QIPCRTRF_EXLCKF_LINUX_SPECIFIC_BASEF_OWNER_PGRPF_OWNER_PIDF_OWNER_TIDF_SHLCKMAP_UNINITIALIZEDPF_KCMPF_QIPCRTR// FIXME(musl) check theseSOL_KCMSYS3264_fadvise64SYS3264_fcntlSYS3264_fstatatSYS3264_fstatSYS3264_fstatfsSYS3264_ftruncateSYS3264_lseekSYS3264_lstatSYS3264_mmapSYS3264_sendfileSYS3264_statSYS3264_statfsSYS3264_truncate// FIXME(hexagon)SYS_oldwait4TIOCM_LOOPTIOCM_OUT1TIOCM_OUT2TIOCSER_TEMT//pub const RLIM_INFINITY: crate::rlim_t = !0;//pub const RLIMIT_RSS: crate::__rlimit_resource_t = 5;//pub const RLIMIT_AS: crate::__rlimit_resource_t = 9;//pub const RLIMIT_MEMLOCK: crate::__rlimit_resource_t = 8;//pub const RLIMIT_NOFILE: crate::__rlimit_resource_t = 7;//pub const RLIMIT_NPROC: crate::__rlimit_resource_t = 6;// bits/hwcap.hSYS_cachestatSYS_map_shadow_stackSYS_futex_wakeSYS_futex_waitSYS_futex_requeue//! LoongArch-specific definitions for 64-bit linux-like valuesSYS_s390_guarded_storageSYS_s390_sthyiSYS_fadvise// Syscall aliases for WALI//! Wasm32 definitions conforming to the WALI ABI.//! The WALI ABI closely mirrors `x86_64` Linux and is thus implemented within the `b64` module as opposed to `b32`"SYS_read"__syscall_SYS_read/* 0 */"SYS_write"__syscall_SYS_write/* 1 */"SYS_open"__syscall_SYS_open/* 2 */"SYS_close"__syscall_SYS_close/* 3 */"SYS_stat"__syscall_SYS_stat/* 4 */"SYS_fstat"__syscall_SYS_fstat/* 5 */"SYS_lstat"__syscall_SYS_lstat/* 6 */"SYS_poll"__syscall_SYS_poll/* 7 */"SYS_lseek"__syscall_SYS_lseek/* 8 */"SYS_mmap"__syscall_SYS_mmap/* 9 */"SYS_mprotect"__syscall_SYS_mprotect/* 10 */"SYS_munmap"__syscall_SYS_munmap/* 11 */"SYS_brk"__syscall_SYS_brk/* 12 */"SYS_rt_sigaction"__syscall_SYS_rt_sigaction/* 13 */"SYS_rt_sigprocmask"__syscall_SYS_rt_sigprocmask/* 14 */"SYS_rt_sigreturn"__syscall_SYS_rt_sigreturn/* 15 */"SYS_ioctl"__syscall_SYS_ioctl/* 16 */"SYS_pread64"__syscall_SYS_pread64/* 17 */"SYS_pwrite64"__syscall_SYS_pwrite64/* 18 */"SYS_readv"__syscall_SYS_readv/* 19 */"SYS_writev"__syscall_SYS_writev/* 20 */"SYS_access"__syscall_SYS_access/* 21 */"SYS_pipe"__syscall_SYS_pipe/* 22 */"SYS_select"__syscall_SYS_select/* 23 */"SYS_sched_yield"__syscall_SYS_sched_yield/* 24 */"SYS_mremap"__syscall_SYS_mremap/* 25 */"SYS_msync"__syscall_SYS_msync/* 26 */"SYS_madvise"__syscall_SYS_madvise/* 28 */"SYS_dup"__syscall_SYS_dup/* 32 */"SYS_dup2"__syscall_SYS_dup2/* 33 */"SYS_nanosleep"__syscall_SYS_nanosleep/* 35 */"SYS_alarm"__syscall_SYS_alarm/* 37 */"SYS_setitimer"__syscall_SYS_setitimer/* 38 */"SYS_getpid"__syscall_SYS_getpid/* 39 */"SYS_socket"__syscall_SYS_socket/* 41 */"SYS_connect"__syscall_SYS_connect/* 42 */"SYS_accept"__syscall_SYS_accept/* 43 */"SYS_sendto"__syscall_SYS_sendto/* 44 */"SYS_recvfrom"__syscall_SYS_recvfrom/* 45 */"SYS_sendmsg"__syscall_SYS_sendmsg/* 46 */"SYS_recvmsg"__syscall_SYS_recvmsg/* 47 */"SYS_shutdown"__syscall_SYS_shutdown/* 48 */"SYS_bind"__syscall_SYS_bind/* 49 */"SYS_listen"__syscall_SYS_listen/* 50 */"SYS_getsockname"__syscall_SYS_getsockname/* 51 */"SYS_getpeername"__syscall_SYS_getpeername/* 52 */"SYS_socketpair"__syscall_SYS_socketpair/* 53 */"SYS_setsockopt"__syscall_SYS_setsockopt/* 54 */"SYS_getsockopt"__syscall_SYS_getsockopt/* 55 */"SYS_fork"__syscall_SYS_fork/* 57 */"SYS_execve"__syscall_SYS_execve/* 59 */"SYS_exit"__syscall_SYS_exit/* 60 */"SYS_wait4"__syscall_SYS_wait4/* 61 */"SYS_kill"__syscall_SYS_kill/* 62 */"SYS_uname"__syscall_SYS_uname/* 63 */"SYS_fcntl"__syscall_SYS_fcntl/* 72 */"SYS_flock"__syscall_SYS_flock/* 73 */"SYS_fsync"__syscall_SYS_fsync/* 74 */"SYS_fdatasync"__syscall_SYS_fdatasync/* 75 */"SYS_ftruncate"__syscall_SYS_ftruncate/* 77 */"SYS_getdents"__syscall_SYS_getdents/* 78 */"SYS_getcwd"__syscall_SYS_getcwd/* 79 */"SYS_chdir"__syscall_SYS_chdir/* 80 */"SYS_fchdir"__syscall_SYS_fchdir/* 81 */"SYS_rename"__syscall_SYS_rename/* 82 */"SYS_mkdir"__syscall_SYS_mkdir/* 83 */"SYS_rmdir"__syscall_SYS_rmdir/* 84 */"SYS_link"__syscall_SYS_link/* 86 */"SYS_unlink"__syscall_SYS_unlink/* 87 */"SYS_symlink"__syscall_SYS_symlink/* 88 */"SYS_readlink"__syscall_SYS_readlink/* 89 */"SYS_chmod"__syscall_SYS_chmod/* 90 */"SYS_fchmod"__syscall_SYS_fchmod/* 91 */"SYS_chown"__syscall_SYS_chown/* 92 */"SYS_fchown"__syscall_SYS_fchown/* 93 */"SYS_umask"__syscall_SYS_umask/* 95 */"SYS_getrlimit"__syscall_SYS_getrlimit/* 97 */"SYS_getrusage"__syscall_SYS_getrusage/* 98 */"SYS_sysinfo"__syscall_SYS_sysinfo/* 99 */"SYS_getuid"__syscall_SYS_getuid/* 102 */"SYS_getgid"__syscall_SYS_getgid/* 104 */"SYS_setuid"__syscall_SYS_setuid/* 105 */"SYS_setgid"__syscall_SYS_setgid/* 106 */"SYS_geteuid"__syscall_SYS_geteuid/* 107 */"SYS_getegid"__syscall_SYS_getegid/* 108 */"SYS_setpgid"__syscall_SYS_setpgid/* 109 */"SYS_getppid"__syscall_SYS_getppid/* 110 */"SYS_setsid"__syscall_SYS_setsid/* 112 */"SYS_setreuid"__syscall_SYS_setreuid/* 113 */"SYS_setregid"__syscall_SYS_setregid/* 114 */"SYS_getgroups"__syscall_SYS_getgroups/* 115 */"SYS_setgroups"__syscall_SYS_setgroups/* 116 */"SYS_setresuid"__syscall_SYS_setresuid/* 117 */"SYS_setresgid"__syscall_SYS_setresgid/* 119 */"SYS_getpgid"__syscall_SYS_getpgid/* 121 */"SYS_getsid"__syscall_SYS_getsid/* 124 */"SYS_rt_sigpending"__syscall_SYS_rt_sigpending/* 127 */"SYS_rt_sigsuspend"__syscall_SYS_rt_sigsuspend/* 130 */"SYS_sigaltstack"__syscall_SYS_sigaltstack/* 131 */"SYS_utime"__syscall_SYS_utime/* 132 */"SYS_statfs"__syscall_SYS_statfs/* 137 */"SYS_fstatfs"__syscall_SYS_fstatfs/* 138 */"SYS_prctl"__syscall_SYS_prctl/* 157 */"SYS_setrlimit"__syscall_SYS_setrlimit/* 160 */"SYS_chroot"__syscall_SYS_chroot/* 161 */"SYS_gettid"__syscall_SYS_gettid/* 186 */"SYS_tkill"__syscall_SYS_tkill/* 200 */"SYS_futex"__syscall_SYS_futex/* 202 */"SYS_sched_getaffinity"__syscall_SYS_sched_getaffinity/* 204 */"SYS_getdents64"__syscall_SYS_getdents64/* 217 */"SYS_set_tid_address"__syscall_SYS_set_tid_address/* 218 */"SYS_fadvise"__syscall_SYS_fadvise/* 221 */"SYS_clock_gettime"__syscall_SYS_clock_gettime/* 228 */"SYS_clock_getres"__syscall_SYS_clock_getres/* 229 */"SYS_clock_nanosleep"__syscall_SYS_clock_nanosleep/* 230 */"SYS_exit_group"__syscall_SYS_exit_group/* 231 */"SYS_epoll_ctl"__syscall_SYS_epoll_ctl/* 233 */"SYS_openat"__syscall_SYS_openat/* 257 */"SYS_mkdirat"__syscall_SYS_mkdirat/* 258 */"SYS_fchownat"__syscall_SYS_fchownat/* 260 */"SYS_fstatat"__syscall_SYS_fstatat/* 262 */"SYS_unlinkat"__syscall_SYS_unlinkat/* 263 */"SYS_linkat"__syscall_SYS_linkat/* 265 */"SYS_symlinkat"__syscall_SYS_symlinkat/* 266 */"SYS_readlinkat"__syscall_SYS_readlinkat/* 267 */"SYS_fchmodat"__syscall_SYS_fchmodat/* 268 */"SYS_faccessat"__syscall_SYS_faccessat/* 269 */"SYS_pselect6"__syscall_SYS_pselect6/* 270 */"SYS_ppoll"__syscall_SYS_ppoll/* 271 */"SYS_utimensat"__syscall_SYS_utimensat/* 280 */"SYS_epoll_pwait"__syscall_SYS_epoll_pwait/* 281 */"SYS_eventfd"__syscall_SYS_eventfd/* 284 */"SYS_accept4"__syscall_SYS_accept4/* 288 */"SYS_eventfd2"__syscall_SYS_eventfd2/* 290 */"SYS_epoll_create1"__syscall_SYS_epoll_create1/* 291 */"SYS_dup3"__syscall_SYS_dup3/* 292 */"SYS_pipe2"__syscall_SYS_pipe2/* 293 */"SYS_prlimit64"__syscall_SYS_prlimit64/* 302 */"SYS_renameat2"__syscall_SYS_renameat2/* 316 */"SYS_getrandom"__syscall_SYS_getrandom/* 318 */"SYS_statx"__syscall_SYS_statx/* 332 */"SYS_faccessat2"__syscall_SYS_faccessat2/* 439 *///! WebAssembly Linux Interface syscall specification// --- Autogenerated from WALI/scripts/autogen.py ---// offsets in mcontext_t.gregs from bits/signal.h// GitHub repo: ifduyue/musl/// commit: b4b1e10364c8737a632be61582e05a8d3acf5690// file: arch/x86_64/bits/signal.h#L9-L56// include/sys/mman.h// include/utmpx.hREG_OK// Musl targets need the `mask` argument of `fanotify_mark` be specified// `c_ulonglong` instead of `u64` or there will be a type mismatch between// `long long unsigned int` and the expected `uint64_t`.// Added in `musl` 1.1.20// Added in `musl` 1.2.2// Added in `musl` 1.1.24// musl does not define ACCOUNTING__SIZEOF_PTHREAD_COND_COMPAT_T// I wasn't able to find those constants// in uclibc build environment for armv7// autogenerated constants with hand tuned types// These are typed unsigned to match sigaction// Syscall table is copied from src/unix/notbsd/linux/musl/b32/arm.rs// FIXME(linux): should be a `c_long` too, but a bug slipped in.// from linux/other/mod.rs// Valid for n64// These are different than GNU!// These are different from GNU// Different than Gnu.// end different sectionl4_umword_t/// L4Re specifics/// This module contains definitions required by various L4Re libc backends./// Some of them are formally not part of the libc, but are a dependency of the/// libc and hence we should provide them here.// Unsigned machine word.__detachstate__schedpolicy__schedparam__sched_param__inheritsched__scope__guardsize__stackaddr_set__stackaddr__stacksize// better don't use itaffinityl4_sched_cpu_set_t// L4Re specificscreate_flags// L4Re requires a min stack size of 64k; that isn't defined in uClibc, but// somewhere in the core libraries. uClibc wants 16k, but that's not enough.// Misc other constants required for building.fsword_t// [uClibc docs] Note stat64 has the same shape as stat for x86-64.// File name too long// Directory not empty// Too many symbolic links encountered// Address already in use// Cannot assign requested address// Network is down// Network is unreachable// Software caused connection abort// Connection refused// Connection reset by peer// Resource deadlock would occur// Function not implemented// Transport endpoint is not connected// connection timed out// Stale file handle// No route to host// Quota exceeded// Set the set of blocked signals// connectionless, unreliable datagrams// …/common/bits/socket_type.h//! Definitions for uclibc on 64bit systems// Thestyle checker discourages the use of #[cfg], so this has to go into a// separate modules_addrimr_multiaddrimr_interfaceip_mreqimr_addressimr_ifindexip_mreqnimr_sourceaddrip_mreq_sourcesa_familysa_datasin_familysin_portsin_addrsin_zerosin6_familysin6_portsin6_flowinfosin6_addrsin6_scope_idai_flagsai_familyai_socktypeai_protocolai_addrlenai_addrai_canonnameai_nextsll_familysll_protocolsll_ifindexsll_hatypesll_pkttypesll_halensll_addrsockaddr_llfds_bitsULONG_SIZEtm_gmtofftm_zonedli_fnamedli_fbasedli_snamedli_saddrthousands_sepgroupingint_curr_symbolcurrency_symbolmon_decimal_pointmon_thousands_sepmon_groupingpositive_signnegative_signint_frac_digitsfrac_digitsp_cs_precedesp_sep_by_spacen_cs_precedesn_sep_by_spacep_sign_posnn_sign_posnint_p_cs_precedesint_p_sep_by_spaceint_n_cs_precedesint_n_sep_by_spaceint_p_sign_posnint_n_sign_posnipi_ifindexipi_spec_dstipi_addrin_pktinfoifa_nextifa_nameifa_flagsifa_addrifa_netmaskifa_ifuifa_datartmsg_dstrtmsg_srcrtmsg_gatewayrtmsg_typertmsg_dst_lenrtmsg_src_lenrtmsg_metricrtmsg_infortmsg_flagsrtmsg_ifindexin6_rtmsgarp_paarp_haarp_flagsarp_netmaskarp_devarpreqarpreq_oldar_hrdar_proar_hlnar_plnar_oparphdrmsg_hdrmsg_lenstx_maskstx_blksizestx_attributesstx_nlinkstx_uidstx_gidstx_mode__statx_pad1stx_inostx_sizestx_blocksstx_attributes_maskstx_atimestatx_timestampstx_btimestx_ctimestx_mtimestx_rdev_majorstx_rdev_minorstx_dev_majorstx_dev_minorstx_mnt_idstx_dio_mem_alignstx_dio_offset_align__statx_pad3__statx_timestamp_pad1sun_familysun_pathsockaddr_unss_family__ss_pad2__ss_alignsysnamenodenamemachinedomainnamesigev_valuesigev_signosigev_notifysigev_notify_thread_idMS_LAZYTIMEMADV_WIPEONFORKMADV_KEEPONFORKMADV_COLDMADV_PAGEOUTMADV_POPULATE_READMADV_POPULATE_WRITEMADV_DONTNEED_LOCKEDSOL_BLUETOOTHSOL_ALGIP_ROUTER_ALERTIP_PKTOPTIONSIP_MTU_DISCOVERIP_RECVERRIP_MTUIP_IPSEC_POLICYIP_XFRM_POLICYIP_PASSSECIP_MINTTLIP_NODEFRAGIP_CHECKSUMIP_BIND_ADDRESS_NO_PORTIP_MSFILTERIP_MULTICAST_ALLIP_PMTUDISC_DONTIP_PMTUDISC_WANTIP_PMTUDISC_DOIP_PMTUDISC_PROBEIP_PMTUDISC_INTERFACEIP_PMTUDISC_OMIT/// Multipath TCP/// Ethernet-within-IPv6 encapsulation.MCAST_MSFILTERIPV6_AUTHHDRIPV6_IPSEC_POLICYIPV6_XFRM_POLICYIPV6_HDRINCLIPV6_AUTOFLOWLABELIPV6_TRANSPARENTIPV6_PREFER_SRC_PUBTMP_DEFAULTIPV6_PMTUDISC_DONTIPV6_PMTUDISC_WANTIPV6_PMTUDISC_DOIPV6_PMTUDISC_PROBEIPV6_PMTUDISC_INTERFACEIPV6_PMTUDISC_OMITUMOUNT_NOFOLLOWADDR_NO_RANDOMIZE// Options for personality(2).MMAP_PAGE_ZEROADDR_COMPAT_LAYOUTREAD_IMPLIES_EXECADDR_LIMIT_32BITSHORT_INODEWHOLE_SECONDSSTICKY_TIMEOUTSADDR_LIMIT_3GB// si_code valuesSI_KERNELSI_SIGIOSI_TKILLSI_ASYNCNLBUS_MCEERR_AR// Linux-specific si_code values for SIGBUS signalBUS_MCEERR_AO// si_code values for SIGTRAPTRAP_BRANCHTRAP_HWBKPTTRAP_UNKP_PIDFDADFS_SUPER_MAGICAFFS_SUPER_MAGICAFS_SUPER_MAGICAUTOFS_SUPER_MAGICBPF_FS_MAGICBTRFS_SUPER_MAGICCGROUP2_SUPER_MAGICCGROUP_SUPER_MAGICCODA_SUPER_MAGICCRAMFS_MAGICDEBUGFS_MAGICDEVPTS_SUPER_MAGICECRYPTFS_SUPER_MAGICEFS_SUPER_MAGICEXT2_SUPER_MAGICEXT3_SUPER_MAGICEXT4_SUPER_MAGICF2FS_SUPER_MAGICFUSE_SUPER_MAGICFUTEXFS_SUPER_MAGICHOSTFS_SUPER_MAGICHPFS_SUPER_MAGICHUGETLBFS_MAGICISOFS_SUPER_MAGICJFFS2_SUPER_MAGICMINIX2_SUPER_MAGIC2MINIX2_SUPER_MAGICMINIX3_SUPER_MAGICMINIX_SUPER_MAGIC2MINIX_SUPER_MAGICMSDOS_SUPER_MAGICNCP_SUPER_MAGICNFS_SUPER_MAGICNILFS_SUPER_MAGICOCFS2_SUPER_MAGICOPENPROM_SUPER_MAGICOVERLAYFS_SUPER_MAGICPROC_SUPER_MAGICQNX4_SUPER_MAGICQNX6_SUPER_MAGICRDTGROUP_SUPER_MAGICREISERFS_SUPER_MAGICSECURITYFS_MAGICSELINUX_MAGICSMACK_MAGICSMB_SUPER_MAGICSYSFS_MAGICTMPFS_MAGICTRACEFS_MAGICUDF_SUPER_MAGICUSBDEVICE_SUPER_MAGICXENFS_SUPER_MAGICNSFS_MAGICCMSG_ALIGNCMSG_FIRSTHDRCMSG_DATACMSG_SPACECMSG_LENFD_CLRFD_ISSETFD_SETFD_ZEROWIFSTOPPEDWSTOPSIGWIFCONTINUEDWIFSIGNALEDWTERMSIGWIFEXITEDWEXITSTATUSWCOREDUMPW_EXITCODEW_STOPCODEQCMDIPOPT_COPIEDIPOPT_CLASSIPOPT_NUMBERIPTOS_ECNKERNEL_VERSIONvfork// * musl and Emscripten has 64-bit versions only so aliases the LFS64 symbols to the standard ones// * ulibc doesn't have preadv64/pwritev64// The statx syscall, available on some libcs.gr_namegr_passwdgr_gidgr_memactimemodtimeru_utimeru_stimeru_maxrssru_ixrssru_idrssru_isrssru_minfltru_majfltru_nswapru_inblockru_oublockru_msgsndru_msgrcvru_nsignalsru_nvcswru_nivcswipv6mr_multiaddripv6mr_interfaceipv6_mreqh_nameh_aliasesh_addrtypeh_lengthh_addr_listhostentiov_baseiov_lenws_rowws_colws_xpixelws_ypixell_onoffl_lingerlingersival_ptrtms_utimetms_stimetms_cutimetms_cstimes_names_aliasess_ports_protop_namep_aliasesp_protos6_addrIN6ADDR_LOOPBACK_INITIN6ADDR_ANY_INITATF_COMATF_PERMATF_PUBLATF_USETRAILERSFNM_PERIODFNM_NOMATCHFNM_CASEFOLDFNM_PATHNAMEFNM_NOESCAPEin6addr_loopbackin6addr_anystrsignalfchdirttyname_rkillpggetrusagehstrerror// FIXME(time): for `time_t`// FIXME: for `time_t`endserventgetservbyportgetserventsetserventchrootgetlinelockfhtonsntohladjtimeconfstropen_wmemstreamr" The 64-bit libc on Solaris and illumos only has readdir_r. If a"r" 32-bit Solaris or illumos target is ever created, it should use"r" __posix_readdir_r. See libc(3LIB) on Solaris or illumos:"r" https://illumos.org/man/3lib/libc"r" https://docs.oracle.com/cd/E36784_01/html/E36873/libc-3lib.html"r" https://www.unix.com/man-page/opensolaris/3LIB/libc/"fmemopenopen_memstreamfnmatch"lwip_sendmsg""lwip_recvmsg"//! Common types used by most newlib platformsu_register_tsbintime_tCLOCK_ENABLEDCLOCK_DISABLEDCLOCK_ALLOWEDCLOCK_DISALLOWEDSOL_CONFIGEAI_BADHINTSEAI_PROTOCOLEAI_MAX// For pthread get/setschedparam// Horizon OS works doesn't or can't hold any of this informationpthread_attr_getprocessorid_nppthread_attr_setprocessorid_nppthread_getprocessorid_np//! ARMv6K Nintendo 3DS C Newlib definitions// unverified constants__PTHREAD_MUTEX_HAVE_PREV__PTHREAD_RWLOCK_INT_FLAGS_SHARED// Other constants// https://github.com/bminor/newlib/blob/HEAD/newlib/libc/sys/linux/include/net/if.h#L121// the newlib shipped with devkitPPC does not support the following components:// - sockaddr// - AF_INET6// - FIONBIO// - POLL*// - SOL_SOCKET// - MSG_*// defined in architecture specific module_Time32tsync_t_sync_attr_SYSNAME_SIZEIP_IPSEC_POLICY_COMPATIPV6_IPSEC_POLICY_COMPATEOKENOREMOTEENONDPEBADFSYSEMOREECTRLTERMENOLICESRVRFAULTEENDIANESECTYPEINVALF_ALLOCSPF_FREESP_TIO_CBAUDHW_IOSTATSHW_ALIGNBYTESHW_CNMAGICHW_PHYSMEM64HW_USERMEM64HW_IOSTATNAMESCTL_QNXCHAR_BITD_FLAG_FILTERD_FLAG_STATD_FLAG_STAT_FORM_MASKD_FLAG_STAT_FORM_T32_2001D_FLAG_STAT_FORM_T32_2008D_FLAG_STAT_FORM_T64_2008D_FLAG_STAT_FORM_UNSETD_GETFLAGD_SETFLAGIFF_ACCEPTRTADVIFF_IP6FORWARDINGIFF_SHIMIHFLOWIIDLEOHFLOWPARSTKSCHED_ADJTOHEADSCHED_ADJTOTAILSCHED_MAXPOLICYSCHED_SETPRIOSCHED_SPORADICSIGDEADLKSO_FIBSO_TXPRIOSO_VLANPRIO_SS_ALIGNSIZE_SS_MAXSIZE_SS_PAD1SIZE_SS_PAD2SIZETC_CPOSIXTC_IPOSIXTC_LPOSIXTC_OPOSIXUSER_ATEXIT_MAXVDOWNVINSVDELVRUBVCANVHOMEVENDVSPARE3VSPARE4VFWDVLOGINVPREFIXVSUFFIXVLEFTVRIGHTVUP// The original .h file declares this as *const, but for consistency with other platforms,// changing this to *mut to make it easier to use.// Maybe in v0.3 all platforms should use this as a *const.dircntl__get_errno_ptr_syspage_ptrsyspage_entry// System page, see https://www.qnx.com/developers/docs/7.1#com.qnx.doc.neutrino.building/topic/syspage/syspage_about.html__my_thread_exit// Function on the stack after a call to pthread_create().  This is used// as a sentinel to work around an infitnite loop in the unwinding code.// Models the implementation in stdlib.h.  Ctest will fail if trying to use the// default symbol from libcneutrino// Network related functions are provided by libsocket and regex// functions are provided by libregex.// In QNX <=7.0, libregex functions were included in libc itself.nto_job_tSYSMGR_PIDSYSMGR_CHIDSYSMGR_COIDSYSMGR_HANDLESTATE_DEADSTATE_RUNNINGSTATE_STOPPEDSTATE_SENDSTATE_RECEIVESTATE_REPLYSTATE_STACKSTATE_WAITTHREADSTATE_WAITPAGESTATE_SIGSUSPENDSTATE_SIGWAITINFOSTATE_NANOSLEEPSTATE_MUTEXSTATE_CONDVARSTATE_JOINSTATE_INTRSTATE_SEMSTATE_WAITCTXSTATE_NET_SENDSTATE_NET_REPLYSTATE_MAX_NTO_TIMEOUT_RECEIVE_NTO_TIMEOUT_SEND_NTO_TIMEOUT_REPLY_NTO_TIMEOUT_SIGSUSPEND_NTO_TIMEOUT_SIGWAITINFO_NTO_TIMEOUT_NANOSLEEP_NTO_TIMEOUT_MUTEX_NTO_TIMEOUT_CONDVAR_NTO_TIMEOUT_JOIN_NTO_TIMEOUT_INTR_NTO_TIMEOUT_SEM_NTO_MI_ENDIAN_BIG_NTO_MI_ENDIAN_DIFF_NTO_MI_UNBLOCK_REQ_NTO_MI_NET_CRED_DIRTY_NTO_MI_CONSTRAINED_NTO_MI_CHROOT_NTO_MI_BITS_64_NTO_MI_BITS_DIFF_NTO_MI_SANDBOX_NTO_CI_ENDIAN_BIG_NTO_CI_BKGND_PGRP_NTO_CI_ORPHAN_PGRP_NTO_CI_STOPPED_NTO_CI_UNABLE_NTO_CI_TYPE_ID_NTO_CI_CHROOT_NTO_CI_BITS_64_NTO_CI_SANDBOX_NTO_CI_LOADER_NTO_CI_FULL_GROUPS_NTO_TI_ACTIVE_NTO_TI_ABSOLUTE_NTO_TI_EXPIRED_NTO_TI_TOD_BASED_NTO_TI_TARGET_PROCESS_NTO_TI_REPORT_TOLERANCE_NTO_TI_PRECISE_NTO_TI_TOLERANT_NTO_TI_WAKEUP_NTO_TI_PROCESS_TOLERANT_NTO_TI_HIGH_RESOLUTION_PULSE_TYPE_PULSE_SUBTYPE_PULSE_CODE_UNBLOCK_PULSE_CODE_DISCONNECT_PULSE_CODE_THREADDEATH_PULSE_CODE_COIDDEATH_PULSE_CODE_NET_ACK_PULSE_CODE_NET_UNBLOCK_PULSE_CODE_NET_DETACH_PULSE_CODE_RESTART_PULSE_CODE_NORESTART_PULSE_CODE_UNBLOCK_RESTART_PULSE_CODE_UNBLOCK_TIMER_PULSE_CODE_MINAVAIL_PULSE_CODE_MAXAVAIL_NTO_HARD_FLAGS_END_NTO_PULSE_IF_UNIQUE_NTO_PULSE_REPLACE_NTO_PF_NOCLDSTOP_NTO_PF_LOADING_NTO_PF_TERMING_NTO_PF_ZOMBIE_NTO_PF_NOZOMBIE_NTO_PF_FORKED_NTO_PF_ORPHAN_PGRP_NTO_PF_STOPPED_NTO_PF_DEBUG_STOPPED_NTO_PF_BKGND_PGRP_NTO_PF_NOISYNC_NTO_PF_CONTINUED_NTO_PF_CHECK_INTR_NTO_PF_COREDUMP_NTO_PF_RING0_NTO_PF_SLEADER_NTO_PF_WAITINFO_NTO_PF_DESTROYALL_NTO_PF_NOCOREDUMP_NTO_PF_WAITDONE_NTO_PF_TERM_WAITING_NTO_PF_ASLR_NTO_PF_EXECED_NTO_PF_APP_STOPPED_NTO_PF_64BIT_NTO_PF_NET_NTO_PF_NOLAZYSTACK_NTO_PF_NOEXEC_STACK_NTO_PF_LOADER_PERMS_NTO_TF_INTR_PENDING_NTO_TF_DETACHED_NTO_TF_SHR_MUTEX_NTO_TF_SHR_MUTEX_EUID_NTO_TF_THREADS_HOLD_NTO_TF_UNBLOCK_REQ_NTO_TF_ALIGN_FAULT_NTO_TF_SSTEP_NTO_TF_ALLOCED_STACK_NTO_TF_NOMULTISIG_NTO_TF_LOW_LATENCY_NTO_TF_IOPRIV_NTO_TCTL_IO_PRIV_NTO_TCTL_THREADS_HOLD_NTO_TCTL_THREADS_CONT_NTO_TCTL_RUNMASK_NTO_TCTL_ALIGN_FAULT_NTO_TCTL_RUNMASK_GET_AND_SET_NTO_TCTL_PERFCOUNT_NTO_TCTL_ONE_THREAD_HOLD_NTO_TCTL_ONE_THREAD_CONT_NTO_TCTL_RUNMASK_GET_AND_SET_INHERIT_NTO_TCTL_NAME_NTO_TCTL_RCM_GET_AND_SET_NTO_TCTL_SHR_MUTEX_NTO_TCTL_IO_NTO_TCTL_NET_KIF_GET_AND_SET_NTO_TCTL_LOW_LATENCY_NTO_TCTL_ADD_EXIT_EVENT_NTO_TCTL_DEL_EXIT_EVENT_NTO_TCTL_IO_LEVEL_NTO_TCTL_RESERVED_NTO_TCTL_IO_LEVEL_INHERIT_NTO_IO_LEVEL_NONE_NTO_IO_LEVEL_1_NTO_IO_LEVEL_2_NTO_THREAD_NAME_MAX_NTO_CHF_FIXED_PRIORITY_NTO_CHF_UNBLOCK_NTO_CHF_THREAD_DEATH_NTO_CHF_DISCONNECT_NTO_CHF_NET_MSG_NTO_CHF_SENDER_LEN_NTO_CHF_COID_DISCONNECT_NTO_CHF_REPLY_LEN_NTO_CHF_PULSE_POOL_NTO_CHF_ASYNC_NONBLOCK_NTO_CHF_ASYNC_NTO_CHF_GLOBAL_NTO_CHF_PRIVATE_NTO_CHF_MSG_PAUSING_NTO_CHF_INHERIT_RUNMASK_NTO_CHF_UNBLOCK_TIMER_NTO_CHO_CUSTOM_EVENT_NTO_COF_CLOEXEC_NTO_COF_DEAD_NTO_COF_NOSHARE_NTO_COF_NETCON_NTO_COF_NONBLOCK_NTO_COF_ASYNC_NTO_COF_GLOBAL_NTO_COF_NOEVENT_NTO_COF_INSECURE_NTO_COF_REG_EVENTS_NTO_COF_UNREG_EVENTS_NTO_COF_MASK_NTO_SIDE_CHANNEL_NTO_CONNECTION_SCOID_NTO_GLOBAL_CHANNEL_NTO_TIMEOUT_MASK_NTO_TIMEOUT_ACTIVE_NTO_TIMEOUT_IMMEDIATE_NTO_IC_LATENCY_NTO_INTR_FLAGS_END_NTO_INTR_FLAGS_NO_UNMASK_NTO_INTR_FLAGS_PROCESS_NTO_INTR_FLAGS_TRK_MSK_NTO_INTR_FLAGS_ARRAY_NTO_INTR_FLAGS_EXCLUSIVE_NTO_INTR_FLAGS_FPU_NTO_INTR_CLASS_EXTERNAL_NTO_INTR_CLASS_SYNTHETIC_NTO_INTR_SPARE_NTO_HOOK_IDLE_NTO_HOOK_OVERDRIVE_NTO_HOOK_LAST_NTO_HOOK_IDLE2_FLAG_NTO_IH_CMD_SLEEP_SETUP_NTO_IH_CMD_SLEEP_BLOCK_NTO_IH_CMD_SLEEP_WAKEUP_NTO_IH_CMD_SLEEP_ONLINE_NTO_IH_RESP_NEEDS_BLOCK_NTO_IH_RESP_NEEDS_WAKEUP_NTO_IH_RESP_NEEDS_ONLINE_NTO_IH_RESP_SYNC_TIME_NTO_IH_RESP_SYNC_TLB_NTO_IH_RESP_SUGGEST_OFFLINE_NTO_IH_RESP_SLEEP_MODE_REACHED_NTO_IH_RESP_DELIVER_INTRS_NTO_READIOV_SEND_NTO_READIOV_REPLY_NTO_KEYDATA_VTID_NTO_KEYDATA_PATHSIGN_NTO_KEYDATA_OP_MASK_NTO_KEYDATA_VERIFY_NTO_KEYDATA_CALCULATE_NTO_KEYDATA_CALCULATE_REUSE_NTO_KEYDATA_PATHSIGN_VERIFY_NTO_KEYDATA_PATHSIGN_CALCULATE_NTO_KEYDATA_PATHSIGN_CALCULATE_REUSE_NTO_SCTL_SETPRIOCEILING_NTO_SCTL_GETPRIOCEILING_NTO_SCTL_SETEVENT_NTO_SCTL_MUTEX_WAKEUP_NTO_SCTL_MUTEX_CONSISTENT_NTO_SCTL_SEM_VALUE_NTO_CLIENTINFO_GETGROUPS_NTO_CLIENTINFO_GETTYPEIDChannelCreateChannelCreate_rChannelCreatePulsePoolnto_channel_configChannelCreateExt_cred_infoChannelDestroyChannelDestroy_rConnectAttachConnectAttach_rConnectDetach// TODO: The following function uses a structure defined in a header file//       which doesn't appear as part of the default headers found in a//       standard installation of Neutrino 7.1 SDP.  Commented out for now.//pub fn ConnectAttachExt(//    __nd: u32,//    __pid: crate::pid_t,//    __chid: c_int,//    __index: c_uint,//    __flags: c_int,//    __cd: *mut _asyncmsg_connection_descriptor,//) -> c_int;ConnectDetach_rConnectServerInfo_msg_info64ConnectServerInfo_rConnectClientInfoExtraArgs_client_info_client_ableConnectClientInfoExtraArgs_rConnectClientInfoConnectClientInfo_rConnectClientInfoExtClientInfoExtFreeConnectClientInfoAbleConnectFlagsConnectFlags_rChannelConnectAttr_channel_connect_attrMsgSendMsgSend_rMsgSendncMsgSendnc_rMsgSendsvMsgSendsv_rMsgSendsvncMsgSendsvnc_rMsgSendvsMsgSendvs_rMsgSendvsncMsgSendvsnc_rMsgSendvMsgSendv_rMsgSendvncMsgSendvnc_rMsgReceiveMsgReceive_rMsgReceivevMsgReceivev_rMsgReceivePulseMsgReceivePulse_rMsgReceivePulsevMsgReceivePulsev_rMsgReplyMsgReply_rMsgReplyvMsgReplyv_rMsgReadiovMsgReadiov_rMsgReadMsgRead_rMsgReadvMsgReadv_rMsgWriteMsgWrite_rMsgWritevMsgWritev_rMsgSendPulseMsgSendPulse_rMsgSendPulsePtrMsgSendPulsePtr_rMsgDeliverEventMsgDeliverEvent_rMsgVerifyEventMsgVerifyEvent_rMsgRegisterEventMsgRegisterEvent_rMsgUnregisterEventMsgUnregisterEvent_rMsgInfoMsgInfo_rMsgKeyDataMsgKeyData_rMsgErrorMsgError_rMsgCurrentMsgCurrent_rMsgSendAsyncGblMsgSendAsyncMsgReceiveAsyncGblMsgReceiveAsyncMsgPauseMsgPause_rSignalKillSignalKill_rSignalKillSigvalSignalKillSigval_rSignalReturn_sighandler_infoSignalFaultSignalActionSignalAction_rSignalProcmaskSignalProcmask_rSignalSuspendSignalSuspend_rSignalWaitinfoSignalWaitinfo_rSignalWaitinfoMaskSignalWaitinfoMask_rThreadCreate_thread_attrThreadCreate_rThreadDestroyThreadDestroy_rThreadDetachThreadDetach_rThreadJoinThreadJoin_rThreadCancelThreadCancel_rThreadCtlThreadCtl_rThreadCtlExtThreadCtlExt_rInterruptHookTraceInterruptHookIdleqtime_entryInterruptHookIdle2_idle_hookInterruptHookOverdriveEventInterruptAttachEventInterruptAttachEvent_rInterruptAttachInterruptAttach_rInterruptAttachArrayInterruptAttachArray_rInterruptDetachInterruptDetach_rInterruptWaitInterruptWait_rInterruptCharacteristicInterruptCharacteristic_rSchedGetSchedGet_rSchedGetCpuNumSchedSetSchedSet_rSchedInfo_sched_infoSchedInfo_rSchedYieldSchedYield_rSchedCtlSchedCtl_rSchedJobCreateSchedJobCreate_rSchedJobDestroySchedJobDestroy_rSchedWaypointSchedWaypoint_rTimerCreateTimerCreate_rTimerDestroyTimerDestroy_rTimerSettime_itimerTimerSettime_rTimerInfo_timer_infoTimerInfo_rTimerAlarmTimerAlarm_rTimerTimeoutTimerTimeout_rSyncTypeCreateSyncTypeCreate_rSyncDestroySyncDestroy_rSyncCtlSyncCtl_rSyncMutexEventSyncMutexEvent_rSyncMutexLockSyncMutexLock_rSyncMutexUnlockSyncMutexUnlock_rSyncMutexReviveSyncMutexRevive_rSyncCondvarWaitSyncCondvarWait_rSyncCondvarSignalSyncCondvarSignal_rSyncSemPostSyncSemPost_rSyncSemWaitSyncSemWait_rClockTime_rClockAdjust_clockadjustClockAdjust_rClockPeriod_clockperiodClockPeriod_rClockId_rInterruptMask//TODO: The following commented out functions are implemented in assembly.//      We can implmement them either via a C stub or rust's inline assembly.//pub fn InterruptEnable();//pub fn InterruptDisable();InterruptUnmask//pub fn InterruptLock(__spin: *mut intrspin);//pub fn InterruptUnlock(__spin: *mut intrspin);//pub fn InterruptStatus() -> c_uint;__DEFAULT_RESERVED_SIZE____SOCKADDR_STORAGE_SIZE____PTHREAD_ATTR_SIZE____SEM_SIZE____NAME_MAX____FDSET_SIZE____SIGSET_SIZE__ELBINENMFILEENOSHAREECASECLASH// nuttx/fs/ioctl.h// Reserved two pointer size for reserved area for some structures.// This ensures that the size of these structures is large enough// if more fields are added in the NuttX side.// These structures are that defined by POSIX but only necessary fields are included,// for example, struct passwd, https://pubs.opengroup.org/onlinepubs/009695399/basedefs/pwd.h.html,// POSIX only defines following fields in struct passwd:// char    *pw_name   User's login name.// char    *pw_passwd Encrypted password.// uid_t    pw_uid    Numerical user ID.// gid_t    pw_gid    Numerical group ID.// char    *pw_dir    Initial working directory.// char    *pw_shell  Program to use as shell.// Other fields can be different depending on the implementation.// Must be usize due to library/std/sys_common/thread_local.rs,_PTHREAD_ATTR_SIZE_PTHREAD_RWLOCKATTR_SIZE_PTHREAD_RWLOCK_SIZE_PTHREAD_BARRIER_SIZE_PTHREAD_BARRIERATTR_SIZE_PTHREAD_CONDATTR_SIZE_PTHREAD_COND_SIZE_PTHREAD_MUTEX_SIZE_PTHREAD_MUTEXATTR_SIZE_PTHREAD_ONCE_SIZE_PTHREAD_SPINLOCK_SIZEUTSLENGTH// FIXME(redox): relibc {/* Operation not permitted *//* No such file or directory *//* No such process *//* Interrupted system call *//* I/O error *//* No such device or address *//* Argument list too long *//* Exec format error *//* Bad file number *//* No child processes *//* Try again *//* Out of memory *//* Permission denied *//* Bad address *//* Block device required *//* Device or resource busy *//* File exists *//* Cross-device link *//* No such device *//* Not a directory *//* Is a directory *//* Invalid argument *//* File table overflow *//* Too many open files *//* Not a typewriter *//* Text file busy *//* File too large *//* No space left on device *//* Illegal seek *//* Read-only file system *//* Too many links *//* Broken pipe *//* Math argument out of domain of func *//* Math result not representable *//* Resource deadlock would occur *//* File name too long *//* No record locks available *//* Function not implemented *//* Directory not empty *//* Too many symbolic links encountered *//* No message of desired type *//* Identifier removed *//* Channel number out of range *//* Level 2 not synchronized *//* Level 3 halted *//* Level 3 reset *//* Link number out of range *//* Protocol driver not attached *//* No CSI structure available *//* Level 2 halted *//* Invalid exchange *//* Invalid request descriptor *//* Exchange full *//* No anode *//* Invalid request code *//* Invalid slot *//* Bad font file format *//* Device not a stream *//* No data available *//* Timer expired *//* Out of streams resources *//* Machine is not on the network *//* Package not installed *//* Object is remote *//* Link has been severed *//* Advertise error *//* Srmount error *//* Communication error on send *//* Protocol error *//* Multihop attempted *//* RFS specific error *//* Not a data message *//* Value too large for defined data type *//* Name not unique on network *//* File descriptor in bad state *//* Remote address changed *//* Can not access a needed shared library *//* Accessing a corrupted shared library *//* .lib section in a.out corrupted *//* Attempting to link in too many shared libraries *//* Cannot exec a shared library directly *//* Illegal byte sequence *//* Interrupted system call should be restarted *//* Streams pipe error *//* Too many users *//* Socket operation on non-socket *//* Destination address required *//* Message too long *//* Protocol wrong type for socket *//* Protocol not available *//* Protocol not supported *//* Socket type not supported *//* Operation not supported on transport endpoint *//* Protocol family not supported *//* Address family not supported by protocol *//* Address already in use *//* Cannot assign requested address *//* Network is down *//* Network is unreachable *//* Network dropped connection because of reset *//* Software caused connection abort *//* Connection reset by peer *//* No buffer space available *//* Transport endpoint is already connected *//* Transport endpoint is not connected *//* Cannot send after transport endpoint shutdown *//* Too many references: cannot splice *//* Connection timed out *//* Connection refused *//* Host is down *//* No route to host *//* Operation already in progress *//* Operation now in progress *//* Stale NFS file handle *//* Structure needs cleaning *//* Not a XENIX named type file *//* No XENIX semaphores available *//* Is a named type file *//* Remote I/O error *//* Quota exceeded *//* No medium found *//* Wrong medium type *//* Operation Canceled *//* Required key not available *//* Key has expired *//* Key has been revoked *//* Key was rejected by service *//* Owner died */// Negative to allow it to be used as int// FIXME(redox): Fix negative values missing from includes// poll.hSA_RESTORER// sys/epoll.hEPOLLNVAL// sys/termios.hCLOCKS_PER_SEC// POSIX.1 {// wait.h//pty.h// sys/utsname.h/* State not recoverable */// } POSIX.1// Common functions that are unfortunately missing on illumos and// Solaris, but often needed by other crates.solarishPTEMLDTERMNET_MAC_AWARENET_MAC_AWARE_INHERITPRIV_AWARE_RESETPRIV_DEBUGPRIV_PFEXECPRIV_XPOLICYlgrp_rsrc_tlgrp_affinity_t// AF_UNIX// These constants are correct for 64-bit programs or 32-bit programs that are// not using large-file mode.  If Rust ever supports anything other than 64-bit// compilation on illumos, this may require adjustment:F_FLOCKF_FLOCKWF_DUPFD_CLOFORKF_DUP2FD_CLOFORKF_DUP3FDFD_CLOFORKFIL_ATTACHFIL_DETACHFIL_LISTFILNAME_MAXFILF_PROGFILF_AUTOFILF_BYPASSSOL_FILTERMADV_PURGEO_CLOFORKMSG_CMSG_CLOFORKPBIND_HARDprocessorid_tPBIND_SOFTPS_SYSTEMAF_NCAPF_NCA_PC_LASTPRIV_USERLGRP_RSRC_COUNTLGRP_RSRC_CPULGRP_RSRC_MEMP_DISABLEDAT_SUN_HWCAP2AT_SUN_FPTYPESI_ADDRESS_WIDTH// sys/systeminfo.hpset_bind_lwppset_getloadavggetpagesizes2major_tminor_tzoneid_tchipid_tctid_tlgrp_id_tlgrp_mem_size_tlgrp_cookie_tlgrp_content_tlgrp_lat_between_tlgrp_mem_size_flag_tlgrp_view_tucred_ttrapnosiginfo_faultsiginfo_cldval// Pad out to match the SIGCLD value sizesiginfo_killvalctidzoneidsiginfo_sigcldsiginfo_killsidata_DATE_FMTMAXSTRMSGSIGEV_PORTIP_SEC_OPTIPV6_SEC_OPTO_XATTRF_BLOCKSF_BLKSIZEF_SHAREF_UNSHAREF_ISSTREAMF_PRIVF_NPRIVF_QUOTACTLF_REVOKEF_HASREMOTELOCKS_AT_TRIGGERP_PPIDP_SIDP_CIDP_UIDP_GIDP_LWPIDP_TASKIDP_PROJIDP_POOLIDP_ZONEIDP_CTIDP_CPUIDP_PSETIDPBIND_NONEPBIND_QUERYPS_NONEPS_QUERYPS_MYIDPS_SOFTPS_HARDPS_QUERY_TYPEPS_PRIVATEMAP_ALIGNMAP_TEXTMAP_INITDATAMMOBJ_PADDINGMMOBJ_INTERPRETMR_PADDINGMR_HDR_ELFELOCKUNMAPPEDENOTACTIVEEADIF_GETXFL/* POLLOUT */POSIX_SPAWN_SETSIGIGN_NPPOSIX_SPAWN_NOSIGCHLD_NPPOSIX_SPAWN_WAITPID_NPPOSIX_SPAWN_NOEXECERR_NP// https://illumos.org/man/3c/clock_gettime// https://github.com/illumos/illumos-gate///   blob/HEAD/usr/src/lib/libc/amd64/sys/__clock_gettime.s// clock_gettime(3c) doesn't seem to accept anything other than CLOCK_REALTIME// or __CLOCK_REALTIME0//   blob/HEAD/usr/src/uts/common/sys/time_impl.h// Confusing! CLOCK_HIGHRES==CLOCK_MONOTONIC==4// __CLOCK_REALTIME0==0 is an obsoleted version of CLOCK_REALTIME==3TIMER_RELTIMEMADV_ACCESS_DEFAULTMADV_ACCESS_LWPMADV_ACCESS_MANYAF_NBSAF_NITAF_802AF_OSINETAF_GOSIPAF_POLICYAF_INET_OFFLOADAF_TRILLPF_NBSPF_NITPF_802PF_OSINETPF_GOSIPPF_POLICYPF_INET_OFFLOADPF_TRILL// These TCP socket options are common between illumos and Solaris, while higher// numbers have generally diverged:TCP_NOTIFY_THRESHOLDTCP_ABORT_THRESHOLDTCP_CONN_NOTIFY_THRESHOLDTCP_CONN_ABORT_THRESHOLDTCP_RECVDSTADDRTCP_INIT_CWNDTCP_KEEPALIVE_THRESHOLDTCP_KEEPALIVE_ABORT_THRESHOLDTCP_RTO_INITIALTCP_RTO_MINTCP_RTO_MAXUDP_NAT_T_ENDPOINTSO_EXCLBINDSCM_UCREDMSG_DUPCTRLMSG_XPG4_2// https://docs.oracle.com/cd/E23824_01/html/821-1475/if-7p.html// Address is up// Broadcast address valid// Turn on debugging// Loopback net// Interface is p-to-p// Avoid use of trailers// Resources allocated// No address res. protocol// Receive all packetsIFF_INTELLIGENT// Receive all multicast pkts// Protocol code on boardIFF_MULTI_BCAST// Multicast using broadcst. add.IFF_UNNUMBEREDIFF_DHCPRUNNING// Non-unique addressIFF_PRIVATE// DHCP controls interfaceIFF_NOXMIT// Do not advertiseIFF_NOLOCAL// No address - just on-link subnetIFF_DEPRECATEDIFF_ADDRCONF// Address is deprecatedIFF_ROUTER// Addr. from stateless addrconfIFF_NONUD// Router on interfaceIFF_ANYCAST// No NUD on interfaceIFF_NORTEXCH// Anycast addressIFF_IPV4// Don't xchange rout. infoIFF_IPV6// IPv4 interfaceIFF_NOFAILOVER// IPv6 interfaceIFF_FAILED// in.mpathd test addressIFF_STANDBY// Interface has failedIFF_INACTIVE// Interface is a hot-spareIFF_OFFLINE// Functioning but not usedIFF_COS_ENABLED// Interface is offline// If CoS marking is supportedIFF_PREFERREDIFF_TEMPORARY// Prefer as source addr.IFF_FIXEDMTU// RFC3041IFF_VIRTUAL// MTU set with SIOCSLIFMTUIFF_DUPLICATE// Cannot send/receive pktsIFF_IPMP// Local address in useIPC_SEATSHM_SHARE_MMUSHM_PAGEABLE_PC_ACL_ENABLED_PC_CASE_BEHAVIOR_PC_SATTR_ENABLED_PC_SATTR_EXISTS_PC_ACCESS_FILTERING_SC_LOGNAME_MAX_SC_SIGRT_MIN_SC_SIGRT_MAX_SC_COHER_BLKSZ_SC_SPLIT_CACHE_SC_ICACHE_SZ_SC_DCACHE_SZ_SC_ICACHE_LINESZ_SC_DCACHE_LINESZ_SC_ICACHE_BLKSZ_SC_DCACHE_BLKSZ_SC_DCACHE_TBLKSZ_SC_ICACHE_ASSOC_SC_DCACHE_ASSOC_SC_MAXPID_SC_STACK_PROT_SC_NPROCESSORS_MAX_SC_CPUID_MAX_SC_EPHID_MAX_ST_FSTYPSZ_MUTEX_MAGIC_COND_MAGIC// MX_RWL_MAGIC// CVRTLD_PROBERTLD_PARENTRTLD_GROUPRTLD_WORLDRTLD_CONFGENPORT_SOURCE_AIOPORT_SOURCE_TIMERPORT_SOURCE_USERPORT_SOURCE_FDPORT_SOURCE_ALERTPORT_SOURCE_MQPORT_SOURCE_FILENONROOT_USR_TIOCtIOCTCDSETTIOCKBONTIOCKBOFTIOCGPPSTIOCSPPSTIOCGPPSEVTIOCSILOOPTIOCCILOOPTIOCSIGNAL/* termios */CSWTCHCBAUDEXTCIBAUDEXTDOSMODECRTSXOFF// <sys/stropts.h>I_ANCHORI_SERROPTI_GERROPTI_ESETSIGI_EGETSIG__I_PUSH_NOCTTY// 3SOCKET flagsSOCK_NDELAYSCALE_KGSCALE_KFSCALE_KHSCALE_PHASESCALE_USECSCALE_UPDATEFINEUSECMAXTIMEPPS_AVGPPS_SHIFTPPS_SHIFTMAXPPS_VALIDMAXGLITCHSCHED_SYSSCHED_IASCHED_FSSSCHED_FX// sys/priv.hPRIV_AWAREPRIV_AWARE_INHERIT__PROC_PROTECTSI_SYSNAMESI_HOSTNAMESI_RELEASESI_VERSIONSI_MACHINESI_ARCHITECTURESI_HW_SERIALSI_HW_PROVIDERSI_SET_HOSTNAMESI_SET_SRPC_DOMAINSI_PLATFORMSI_ISALISTSI_DHCP_CACHESI_ARCHITECTURE_32SI_ARCHITECTURE_64SI_ARCHITECTURE_KSI_ARCHITECTURE_NATIVELGRP_COOKIE_NONE// sys/lgrp_user.hLGRP_AFF_NONELGRP_AFF_WEAKLGRP_AFF_STRONGLGRP_CONTENT_ALLLGRP_CONTENT_HIERARCHYLGRP_CONTENT_DIRECTLGRP_LAT_CPU_TO_MEMLGRP_MEM_SZ_FREELGRP_MEM_SZ_INSTALLEDLGRP_VIEW_CALLERLGRP_VIEW_OSP_OFFLINEP_ONLINEP_STATUSP_FAULTEDP_POWEROFFP_NOINTRP_SPAREP_FORCEDPI_TYPELENPI_FPUTYPE_CMSG_HDR_ALIGNMENT// As per sys/socket.h, header alignment must be 8 bytes on SPARC// and 4 bytes everywhere else:_CMSG_DATA_ALIGNMENTNEWDEVSFV_FD_SELF// sys/sendfile.hstack_getbounds___errnoposix_spawn_file_actions_addchdirposix_spawn_file_actions_addfchdirposix_spawnattr_setsigignore_npposix_spawnattr_getsigignore_np"__xnet_bind""__xnet_sendmsg""__xnet_recvmsg"port_createport_associateport_dissociateport_getport_eventport_getnport_sendport_sendnnative_getpwent_rnative_getgrent_rmakeutxmodutxucred_getgetpeerucreducred_freeucred_geteuiducred_getruiducred_getsuiducred_getegiducred_getrgiducred_getsgiducred_getgroupsucred_getpiducred_getprojiducred_getzoneiducred_getpflagsucred_sizepset_createpset_destroypset_assignpset_infopset_bindpset_listpset_setattrpset_getattrprocessor_bindp_onlineprocessor_infogetexecnamegetpflagssetpflagsmmapobjmmapobj_result_tmeminfogetisaxaio_waitn__major__minor__makedevsendfilevsendfilevec_tlgrp_initlgrp_finilgrp_affinity_getlgrp_affinity_setlgrp_cpuslgrp_mem_sizelgrp_nlgrpslgrp_viewlgrp_homelgrp_versionlgrp_resourceslgrp_root// Supports multicast// Do not transmit pkts// IPMP IP interface// RW// sys/processor.hdoor_attr_tdoor_id_t_UTMP_USER_LEN_UTMP_LINE_LEN_UTMP_ID_LENPORT_SOURCE_POSTWAITPORT_SOURCE_SIGNALPRIV_PROC_SENSITIVEPRIV_PFEXEC_AUTHPRIV_PROC_TPDPRIV_TPD_UNSAFEPRIV_PROC_TPD_RESETPRIV_TPD_KILLABLEdoor_calldoor_arg_tdoor_returndoor_desc_tdoor_create__c_anonymous_Elf32_Phdr__c_anonymous_Elf64_PhdrREG_GSBASEREG_FSBASEREG_RFL// sys/regset.hAV_386_FPU// AT_SUN_HWCAPAV_386_TSCAV_386_CX8AV_386_SEPAV_386_AMD_SYSCAV_386_CMOVAV_386_MMXAV_386_AMD_MMXAV_386_AMD_3DNowAV_386_AMD_3DNowxAV_386_FXSRAV_386_SSEAV_386_SSE2AV_386_CX16AV_386_AHFAV_386_TSCPAV_386_AMD_SSE4AAV_386_POPCNTAV_386_AMD_LZCNTAV_386_SSSE3AV_386_SSE4_1AV_386_SSE4_2AV_386_MOVBEAV_386_AESAV_386_PCLMULQDQAV_386_XSAVEAV_386_AVX//defined for the structs// From b_off_t.h// From b_BOOL.h_Vx_OBJ_HANDLE// From vxWind.h .._Vx_TASK_ID_Vx_MSG_Q_ID_Vx_SEM_ID_KERNEL_Vx_RTP_ID_Vx_SD_ID_Vx_CONDVAR_ID_Vx_SEM_ID_Vx_semaphoreOBJ_HANDLETASK_IDMSG_Q_IDSEM_ID_KERNELRTP_IDSD_IDCONDVAR_IDSTATUS_Vx_usr_arg_t// From vxTypes.h_Vx_exit_code_t_Vx_ticks_t_Vx_ticks64_t// mqueue.h// FIXME(vxworks): This is not defined in vxWorks, but we have to define it here// to make the building pass for getrandom and std//Clock Lib StuffPTHREAD_INITIALIZED_OBJ// PTHREAD STUFFPTHREAD_DESTROYED_OBJPTHREAD_VALID_OBJPTHREAD_INVALID_OBJPTHREAD_UNUSED_YET_OBJ_PTHREAD_SHARED_SEM_NAME_MAX//sched.hSCHED_FIFO_HIGH_PRISCHED_FIFO_LOW_PRISCHED_RR_HIGH_PRISCHED_RR_LOW_PRISCHED_SPORADIC_HIGH_PRISCHED_SPORADIC_LOW_PRI// ERRNO STUFF/* Not owner *//* Arg list too long *//* No children *//* No more processes *//* Not enough core */M_nfsStat// NFS errnos: Refer to pkgs_v2/storage/fs/nfs/h/nfs/nfsCommon.hnfsstatNFSERR_REMOTENFSERR_WFLUSH10001NFSERR_BADHANDLE10002NFSERR_NOT_SYNC10003NFSERR_BAD_COOKIE10005NFSERR_TOOSMALL10007NFSERR_BADTYPE10008NFSERR_JUKEBOXS_nfsLib_NFS_OKS_nfsLib_NFSERR_PERMS_nfsLib_NFSERR_NOENTS_nfsLib_NFSERR_IOS_nfsLib_NFSERR_NXIOS_nfsLib_NFSERR_ACCESSS_nfsLib_NFSERR_EXISTS_nfsLib_NFSERR_ENODEVS_nfsLib_NFSERR_NOTDIRS_nfsLib_NFSERR_ISDIRS_nfsLib_NFSERR_INVALS_nfsLib_NFSERR_FBIGS_nfsLib_NFSERR_NOSPCS_nfsLib_NFSERR_ROFSS_nfsLib_NFSERR_NAMETOOLONGS_nfsLib_NFSERR_NOTEMPTYS_nfsLib_NFSERR_DQUOTS_nfsLib_NFSERR_STALES_nfsLib_NFSERR_WFLUSHS_nfsLib_NFSERR_REMOTES_nfsLib_NFSERR_BADHANDLES_nfsLib_NFSERR_NOT_SYNCS_nfsLib_NFSERR_BAD_COOKIES_nfsLib_NFSERR_NOTSUPPS_nfsLib_NFSERR_TOOSMALLS_nfsLib_NFSERR_SERVERFAULTS_nfsLib_NFSERR_BADTYPES_nfsLib_NFSERR_JUKEBOXtaskErrorBase// internal offset values for below constantssemErrorBaseobjErrorBaseS_taskLib_NAME_NOT_FOUND// taskLibCommon.hS_taskLib_TASK_HOOK_TABLE_FULLS_taskLib_TASK_HOOK_NOT_FOUNDS_taskLib_ILLEGAL_PRIORITYVX_TASK_NAME_LENGTH// FIXME(vxworks): could also be useful for TASK_DESC typeS_semLib_INVALID_STATE// semLibCommon.hS_semLib_INVALID_OPTIONS_semLib_INVALID_QUEUE_TYPES_semLib_INVALID_OPERATIONS_objLib_OBJ_ID_ERROR// objLibCommon.hS_objLib_OBJ_UNAVAILABLES_objLib_OBJ_DELETEDS_objLib_OBJ_TIMEOUTS_objLib_OBJ_NO_METHOD// in.h// in6.h// STAT StuffS_IFSHMS_ISTXT// socket.hSO_VLANSO_CONNTIMEOMSG_EXPMSG_MBUFAF_SOCKDEVAF_MIPCAF_MIPC_SAFE// ioLib.hFIOFLUSHFIOOPTIONSFIOBAUDRATEFIODISKFORMATFIODISKINITFIOSEEKFIOWHEREFIODIRENTRYFIORENAMEFIOREADYCHANGEFIODISKCHANGEFIOCANCELFIOSQUEEZEFIOGETNAME// Some poll stuff// fnctlcom.hSIGFMTSIGCNCLSI_SYNCSI_CHILDSI_KILL_PARM_NAME_MAX// vxParams.h definitions_PARM_PATH_MAX// WAIT STUFFPTHREAD_MUTEXATTR_INITIALIZERPTHREAD_CONDATTR_INITIALIZERPTHREAD_RWLOCKATTR_INITIALIZERVX_RTP_NAME_LENGTH// rtpLibCommon.hRTP_ID_ERROR// h/public/unistd.h// Via unistd.h// fcntlcomMAP_CONTIG// FIXME(vxworks): fill this out with a struct"_rtld_dlopen""_rtld_dlerror""_rtld_dlsym""_rtld_dlclose""_rtld_dladdr"pthread_attr_setname//pthread.h// int pthread_atfork (void (*)(void), void (*)(void), void (*)(void));// stat.h// dirent.h// fcntl.h orpthread_rwlockattr_setmaxreaderspthread_rwlock_timedrdlockpthread_rwlock_timedwrlockpthread_attr_getname// clockLib.h// timerLib.h// icotl.h// ntp_rfc2553.h for kernel// netdb.h for user// ioLib.h or// unistd.h and// setenv.cerrnoSet// errnoLib.herrnoGet// pthread.h for kernel// signal.h for usersigqueue_sigqueuetaskKilltaskIdSelftaskDelaytaskNameSet// taskLib.htaskNameGetrtpInfoGetRTP_DESCrtpSpawn_realpath_pathIsAbsolute// pathLib.hrandBytes// randomNumGen.hrandABytesrandUBytesrandSecurevxCpuEnabledGet// vxCpuLib.hvxCpuConfiguredGet// Get set of running CPU's in the system// Get set of Configured CPU's in the system// wait.h macros//! Interface to VxWorks C library//Dummy functions, these don't really exist in VxWorks.__wasi_rights_t/// d_name is declared in WASI libc as a flexible array member, which/// can't be directly expressed in Rust. As an imperfect workaround,/// declare it as a zero-length array instead.// Declare dirent outside of s! so that it doesn't implement Copy, Eq, Hash,// etc., since it contains a flexible array member with a dynamic size._CLOCK_MONOTONIC_CLOCK_PROCESS_CPUTIME_ID_CLOCK_REALTIME_CLOCK_THREAD_CPUTIME_ID__wasilibc_register_preopened_fd__wasilibc_fd_renumber__wasilibc_unlinkat__wasilibc_rmdirat__wasilibc_find_relpath__wasilibc_tell__wasilibc_nocwd___wasilibc_unlinkat__wasilibc_nocwd___wasilibc_rmdirat__wasilibc_nocwd_linkat__wasilibc_nocwd_symlinkat__wasilibc_nocwd_readlinkat__wasilibc_nocwd_faccessat__wasilibc_nocwd_renameat__wasilibc_nocwd_openat_nomode__wasilibc_nocwd_fstatat__wasilibc_nocwd_mkdirat_nomode__wasilibc_nocwd_utimensat__wasilibc_nocwd_opendirat__wasilibc_access__wasilibc_stat__wasilibc_utimens__wasilibc_link__wasilibc_link_oldat__wasilibc_link_newat__wasilibc_rename_oldat__wasilibc_rename_newat//! [wasi-libc](https://github.com/WebAssembly/wasi-libc) definitions.//! `wasi-libc` project provides multiple libraries including emulated features, but we list only//! basic features with `libc.a` here.// stdio file descriptor numbers// NOTE: For MSVC target, `wmemchr` is only a inline function in `<wchar.h>`//      header file. We cannot find a way to link to that symbol from Rust._O_WTEXT_O_U16TEXT_O_U8TEXTO_RAWO_NOINHERITO_TEMPORARY_O_SHORT_LIVED_O_OBTAIN_DIRO_SEQUENTIALO_RANDOMSTRUNCATE// POSIX Supplement (from errno.h)SIG_GETSIG_SGESIG_ACK// " if "// FIXME(windows): fill this out with a struct// Special handling for all print and scan type functions because of https://github.com/rust-lang/libc/issues/2860_msize"_gmtime64_s"gmtime_s"_localtime64_s"localtime_s"_time64""_chmod""_wchmod"wchmod"_mkdir""_wrmdir"wrmdir"_fstat64""_stat64""_wstat64"wstat"_wutime64"wutime"_popen""_pclose""_fdopen""_fileno""_open""_wopen"wopen"_creat""_access""_chdir""_close""_dup""_dup2""_execl""_wexecl"wexecl"_execle""_wexecle"wexecle"_execlp""_wexeclp"wexeclp"_execlpe"execlpe"_wexeclpe"wexeclpe"_execv"// DIFF(main): changed to `intptr_t` in e77f551de9"_execve""_execvp""_execvpe""_wexecv"wexecv"_wexecve"wexecve"_wexecvp"wexecvp"_wexecvpe"wexecvpe"_getcwd""_getpid""_isatty""_lseek""_lseeki64""_pipe""_read""_rmdir""_unlink""_write""_commit""_get_osfhandle"get_osfhandle"_open_osfhandle"open_osfhandle"_wsetlocale"wsetlocale"_aligned_malloc"aligned_malloc"_aligned_free"aligned_free"_aligned_realloc"aligned_realloc"_putenv""_wputenv"wputenv"_putenv_s"putenv_s"_wputenv_s"wputenv_s//! Windows CRT definitions// DIFF(main): removed in 458c58f409// FIXME(msrv): done by `std` starting in 1.79.0// inline comment below appeases style checkerEOTHER// This particular error code is only currently available in msvc toolchain"_stricmp"stricmp"_strnicmp"strnicmp"_memccpy"//! Xous C type definitions// Allowed globally, the warning is enabled in individual modules as we work through them// needed while the module is empty on some platformsalign_of_valCEnumRepr// Prepare for a future upgrade// Things missing for 2024 that are blocked on MSRV or breakage/// Implement `Clone`, `Copy`, and `Debug` since those can be derived, but exclude `PartialEq`,/// `Eq`, and `Hash`.// FIXME(#4419): Replace all uses of `e!` with `c_enum!`c_enum// Matcher for a single variant// Use a specific type if provided, otherwise default to `CEnumRepr`/// Represent a C enum as Rust constants and a type./// C enums can't soundly be mapped to Rust enums since C enums are allowed to have duplicates or/// unlisted values, but this is UB in Rust. This enum doesn't implement any traits, its main/// purpose is to calculate the correct enum values./// See <https://github.com/rust-lang/libc/issues/4419> for more./// Define a `unsafe` function./// Define a safe function.//! Header: `bionic/libc/include/sys/socket.h`can//! `linux/can/j1939.h`// FIXME(cleanup): these could use c_enum if it can accept anonymous enums.// FIXME(cleanup): use `c_enum!`, which needs to be adapted to allow omitting a type.//! `linux/can/raw.h`//! Header: `uapi/linux/can.h`//! The `linux` directory within `include/uapi` in the Linux source tree.//! This directory maps to `include/uapi` in the Linux source tree.linux_uapi//! This module contains the future directory structure. If possible, new definitions should//! get added here.//! Eventually everything should be moved over, and we will move this directory to the top//! level in `src`./// A transparent wrapper over `MaybeUninit<T>` to represent uninitialized padding/// while providing `Default`.// This is restricted to `Copy` types since that's a loose indicator that zeros is actually// a valid bitpattern. There is no technical reason this is required, though, so it could be// lifted in the future if it becomes a problem.//! Platform-agnostic support types.offset_tIPV6_FLOWINFO_PRIFLOWIPV6_FLOWINFO_SRFLAGIPV6_FLOWINFO_VERSIONNFSMNT_HOSTNAMEENOTREADYEWRPROTECTEFORMATENOCONNECTEDISTECORRUPTESYSERROR// errnos 96-108 reserved for future use compatible with AIX PS/2EMEDIAESOFTL_GETMESSAGESL_GETKERNINFOL_GETLIB32INFOL_GETLIB64INFOL_GETPROCINFOpthread_cleanup_poppthread_cleanup_pushpthread_getconcurrencypthread_mutexattr_getprioceilingpthread_mutexattr_gettypepthread_mutexattr_setprioceilingpthread_mutex_getprioceilingpthread_mutex_setprioceilingpthread_setcancelstatepthread_setcanceltypepthread_setconcurrencypthread_testcancel"_posix_aio_cancel""_posix_aio_error""_posix_aio_read""_posix_aio_return""_posix_aio_suspend""_posix_aio_write""_posix_getgrgid_r""_posix_getgrnam_r""_posix_getpwnam_r""_posix_getpwuid_r""_posix_lio_listio""nrecvfrom"// AIX header socket.h maps recvfrom() to nrecvfrom()"nrecvmsg"// AIX header socket.h maps recvmsg() to nrecvmsg()."nsendmsg"// AIX header socket.h maps sendmsg() to nsendmsg().// Define lock_data_instrumented as an empty enumpthread_cond_timedwait_relative_np_CMSG_ALIGN"qsort_r@FBSD_1.0"// Argument order of the function pointer changed in FreeBSD 14. From 14 onwards the signature// matches the POSIX specification by having the third argument be a mutable pointer, on// earlier versions the first argument is the mutable pointer.ksize_tinp_gen_tso_gen_tTCP_BBR_PACE_PER_SECTCP_BBR_PACE_DEL_TARTCP_BBR_PACE_SEG_MAXTCP_BBR_PACE_SEG_MINTCP_BBR_PACE_CROSSTCP_BBR_TMR_PACE_OHTCP_BBR_RACK_RTT_USETCP_BBR_RETRAN_WTSOTCP_BBR_PROBE_RTT_GAINTCP_BBR_PROBE_RTT_LENTCP_BBR_SEND_IWND_IN_TSOTCP_BBR_USE_RACK_RRTCP_BBR_HDWR_PACETCP_BBR_UTTER_MAX_TSOTCP_BBR_EXTRA_STATETCP_BBR_FLOOR_MIN_TSOTCP_BBR_MIN_TOPACEOUTTCP_BBR_TSTMP_RAISESTCP_BBR_POLICER_DETECTTCP_BBR_RACK_INIT_RATEP_IDLEPROCINC_ISIPV6// netinet/in_pcb.hINC_IPV6MINMTU_ALIGNdlvsym// sys/ioccom.h in NetBSD and OpenBSDIOC_DIRMASK// sys/ioccom.hIOCGROUP_SHIFTIOCPARM_LENIOCBASECMDIOCGROUP// Added in `NetBSD` 10.0IPTOS_LOWCOST// stringlist.h (utility library)// Note: this is kept because it was previously introduced// sys/event.h// pty.h// sys/link_elf.h// sys/uov.h//! This file contains the BSD APIs available in Haiku. It corresponds to the//! header files in `headers/compatibility/bsd`.//! Note that Haiku's BSD compatibility is a combination of system APIs and//! utility libraries. There should only be system APIs in `libc`. When you are//! trying to determine whether something should be included in this file, the//! best indicator is whether it also exists in the BSD-specific definitions in//! this libc crate.// linked to any binary by default. Additionally, Haiku supports several// non-POSIX APIs from BSD and GNU, which live in libbsd.so and libgnu.so. These// modules are also supported.// The module is comprised of the following files:// - `mod.rs` (this file) implements the C11 and POSIX API found in//     `headers/posix`// - `b32.rs`, `b64.rs` and `x86_64.rs` contain platform-specific definitions//      of the C11 and POSIX APIs// - `native.rs` defines the native Haiku API that is implemented in//     `libroot.so` and that are found in `headers/os`.// - `bsd.rs` defines the BSD customizations available on Haiku found in//     `headers/compatibility/bsd`// This file follows the Haiku API for Haiku R1 beta 5. It is organized by the/* UDP socket options */NLM_F_NONRECNLM_F_BULKNLM_F_CAPPEDNLM_F_ACK_TLVSPR_SVE_SET_VLPR_SVE_SET_VL_ONEXECPR_SVE_GET_VLPR_SVE_VL_LEN_MASKPR_SVE_VL_INHERITPR_SPEC_L1D_FLUSHPR_MTE_TCF_NONEPR_MTE_TCF_SYNCPR_MTE_TCF_ASYNCPR_MTE_TCF_MASKPR_MTE_TAG_SHIFTPR_MTE_TAG_MASKPR_MTE_TCF_SHIFTPR_SET_IO_FLUSHERPR_GET_IO_FLUSHERPR_SET_SYSCALL_USER_DISPATCHPR_SYS_DISPATCH_OFFPR_SYS_DISPATCH_ONSYSCALL_DISPATCH_FILTER_ALLOWSYSCALL_DISPATCH_FILTER_BLOCKPR_SME_SET_VL_ONEXECPR_SME_VL_LEN_MASKPR_SME_VL_INHERITPR_SET_MDWEPR_MDWE_REFUSE_EXEC_GAINPR_MDWE_NO_INHERITPR_GET_MDWEPR_GET_AUXVPR_SET_MEMORY_MERGEPR_GET_MEMORY_MERGEPR_RISCV_V_SET_CONTROLPR_RISCV_V_GET_CONTROLPR_RISCV_V_VSTATE_CTRL_DEFAULTPR_RISCV_V_VSTATE_CTRL_OFFPR_RISCV_V_VSTATE_CTRL_ONPR_RISCV_V_VSTATE_CTRL_INHERITPR_RISCV_V_VSTATE_CTRL_CUR_MASKPR_RISCV_V_VSTATE_CTRL_NEXT_MASKPR_RISCV_V_VSTATE_CTRL_MASKselectorptrace_sud_config__wchb__pos__statePTRACE_SET_SYSCALL_USER_DISPATCH_CONFIGPTRACE_GET_SYSCALL_USER_DISPATCH_CONFIGpid_typePIDTYPE_PIDPIDTYPE_TGIDPIDTYPE_PGIDPIDTYPE_SIDPIDTYPE_MAXTLS_CIPHER_AES_CCM_128_IV_SIZETLS_CIPHER_AES_CCM_128_KEY_SIZETLS_CIPHER_AES_CCM_128_SALT_SIZETLS_CIPHER_AES_CCM_128_REC_SEQ_SIZEtls12_crypto_info_aes_ccm_128TLS_CIPHER_SM4_GCM_IV_SIZETLS_CIPHER_SM4_GCM_KEY_SIZETLS_CIPHER_SM4_GCM_SALT_SIZETLS_CIPHER_SM4_GCM_REC_SEQ_SIZEtls12_crypto_info_sm4_gcmTLS_CIPHER_SM4_CCM_IV_SIZETLS_CIPHER_SM4_CCM_KEY_SIZETLS_CIPHER_SM4_CCM_SALT_SIZETLS_CIPHER_SM4_CCM_REC_SEQ_SIZEtls12_crypto_info_sm4_ccmTLS_CIPHER_ARIA_GCM_128_IV_SIZETLS_CIPHER_ARIA_GCM_128_KEY_SIZETLS_CIPHER_ARIA_GCM_128_SALT_SIZETLS_CIPHER_ARIA_GCM_128_REC_SEQ_SIZEtls12_crypto_info_aria_gcm_128TLS_CIPHER_ARIA_GCM_256_IV_SIZETLS_CIPHER_ARIA_GCM_256_KEY_SIZETLS_CIPHER_ARIA_GCM_256_SALT_SIZETLS_CIPHER_ARIA_GCM_256_REC_SEQ_SIZEtls12_crypto_info_aria_gcm_256nr_mountsmnt_ns_idmnt_ns_infocgroupidtgidppidruidrgideuidegidsuidsgidfsuidfsgidpidfd_infoEM_RISCVRWF_NOAPPENDRWF_ATOMICRWF_DONTCACHENSIO// linux/nsfs.hNS_GET_USERNSNS_GET_PARENTNS_GET_NSTYPENS_GET_OWNER_UIDNS_GET_MNTNS_IDNS_GET_PID_FROM_PIDNSNS_GET_TGID_FROM_PIDNSNS_GET_PID_IN_PIDNSNS_GET_TGID_IN_PIDNSMNT_NS_INFO_SIZE_VER0NS_MNT_GET_INFONS_MNT_GET_NEXTNS_MNT_GET_PREV// linux/pidfd.hPIDFD_THREADPIDFD_SIGNAL_THREADPIDFD_SIGNAL_THREAD_GROUPPIDFD_SIGNAL_PROCESS_GROUPPIDFD_INFO_PIDPIDFD_INFO_CREDSPIDFD_INFO_CGROUPIDPIDFD_INFO_EXITPIDFD_INFO_SIZE_VER0PIDFS_IOCTL_MAGICPIDFD_GET_CGROUP_NAMESPACEPIDFD_GET_IPC_NAMESPACEPIDFD_GET_MNT_NAMESPACEPIDFD_GET_NET_NAMESPACEPIDFD_GET_PID_NAMESPACEPIDFD_GET_PID_FOR_CHILDREN_NAMESPACEPIDFD_GET_TIME_NAMESPACEPIDFD_GET_TIME_FOR_CHILDREN_NAMESPACEPIDFD_GET_USER_NAMESPACEPIDFD_GET_UTS_NAMESPACEPIDFD_GET_INFOBPF_ABPF_TAXBPF_TXAPACKET_RECV_OUTPUTPACKET_COPY_THRESHPACKET_ORIGDEVPACKET_HDRLENPACKET_VNET_HDRPACKET_TX_TIMESTAMPPACKET_TX_HAS_OFFPACKET_ROLLOVER_STATSPACKET_FANOUT_DATAPACKET_IGNORE_OUTGOINGPACKET_VNET_HDR_SZPACKET_FANOUT_FLAG_IGNORE_OUTGOINGproc_cn_mcast_opPROC_CN_MCAST_LISTENPROC_CN_MCAST_IGNOREproc_cn_eventPROC_EVENT_NONEPROC_EVENT_FORKPROC_EVENT_EXECPROC_EVENT_UIDPROC_EVENT_GIDPROC_EVENT_SIDPROC_EVENT_PTRACEPROC_EVENT_COMMPROC_EVENT_NONZERO_EXITPROC_EVENT_COREDUMPPROC_EVENT_EXIT// linux/cn_proc.hCN_IDX_PROC// linux/connector.hCN_VAL_PROCCN_IDX_CIFSCN_VAL_CIFSCN_W1_IDXCN_W1_VALCN_IDX_V86DCN_VAL_V86D_UVESAFBCN_IDX_BBCN_DST_IDXCN_DST_VALCN_IDX_DMCN_VAL_DM_USERSPACE_LOGCN_IDX_DRBDCN_VAL_DRBDCN_KVP_IDXCN_KVP_VALCN_VSS_IDXCN_VSS_VALTLS_TX_ZEROCOPY_ROTLS_RX_EXPECT_NO_PADTLS_CIPHER_AES_CCM_128TLS_CIPHER_AES_CCM_128_TAG_SIZETLS_CIPHER_SM4_GCMTLS_CIPHER_SM4_GCM_TAG_SIZETLS_CIPHER_SM4_CCMTLS_CIPHER_SM4_CCM_TAG_SIZETLS_CIPHER_ARIA_GCM_128TLS_CIPHER_ARIA_GCM_128_TAG_SIZETLS_CIPHER_ARIA_GCM_256TLS_CIPHER_ARIA_GCM_256_TAG_SIZETLS_INFO_UNSPEC// enumTLS_INFO_VERSIONTLS_INFO_CIPHERTLS_INFO_TXCONFTLS_INFO_RXCONFTLS_INFO_ZC_RO_TXTLS_INFO_RX_NO_PADTLS_CONF_BASETLS_CONF_SWTLS_CONF_HWTLS_CONF_HW_RECORDSECURE_NOROOT// uapi/linux/securebits.hSECURE_NOROOT_LOCKEDSECBIT_NOROOTSECBIT_NOROOT_LOCKEDSECURE_NO_SETUID_FIXUPSECURE_NO_SETUID_FIXUP_LOCKEDSECBIT_NO_SETUID_FIXUPSECBIT_NO_SETUID_FIXUP_LOCKEDSECURE_KEEP_CAPSSECURE_KEEP_CAPS_LOCKEDSECBIT_KEEP_CAPSSECBIT_KEEP_CAPS_LOCKEDSECURE_NO_CAP_AMBIENT_RAISESECURE_NO_CAP_AMBIENT_RAISE_LOCKEDSECBIT_NO_CAP_AMBIENT_RAISESECBIT_NO_CAP_AMBIENT_RAISE_LOCKEDSECURE_EXEC_RESTRICT_FILESECURE_EXEC_RESTRICT_FILE_LOCKEDSECBIT_EXEC_RESTRICT_FILESECBIT_EXEC_RESTRICT_FILE_LOCKEDSECURE_EXEC_DENY_INTERACTIVESECURE_EXEC_DENY_INTERACTIVE_LOCKEDSECBIT_EXEC_DENY_INTERACTIVESECBIT_EXEC_DENY_INTERACTIVE_LOCKEDSECUREBITS_DEFAULTSECURE_ALL_BITSSECURE_ALL_LOCKSSECURE_ALL_UNPRIVILEGEDissecure_maskINPUT_PROP_POINTERINPUT_PROP_DIRECTINPUT_PROP_BUTTONPADINPUT_PROP_SEMI_MTINPUT_PROP_TOPBUTTONPADINPUT_PROP_POINTING_STICKINPUT_PROP_ACCELEROMETERBPF_CLASSBPF_SIZEBPF_MODEBPF_OPBPF_SRC// RISC-V don't have SYS_fstat, use statx instead.// RISC-V don't have wait4, use waitid instead.// RISC-V don't have gettimeofday, use clock_gettime64 instead.// RISC-V don't have getrlimit, use prlimit64 instead.SYS_rt_sigtimedwait_time64SYS_sched_rr_get_interval_time64// RISC-V don't have setrlimit, use prlimit64 instead.// RISC-V don't have settimeofday, use clock_settime64 instead.SYS_futex_time64SYS_io_pgetevents_time64SYS_semtimedop_time64SYS_timer_settime64SYS_timer_gettime64SYS_clock_settime64SYS_clock_gettime64SYS_clock_getres_time64SYS_clock_nanosleep_time64SYS_mq_timedsend_time64SYS_mq_timedreceive_time64// RISC-V don't have newfstatat, use statx instead.SYS_pselect6_time64SYS_ppoll_time64SYS_utimensat_time64SYS_timerfd_settime64SYS_timerfd_gettime64SYS_recvmmsg_time64SYS_clock_adjtime64// Plain syscalls aliased to their time64 variants// FIXME(musl): Value is 1024 for all architectures since 1.2.4// FIXME(ulibc): this module has definitions that are redundant with the parentMS_NOSYMFOLLOWT_TYPEr" Build an ioctl number, analogous to the C macro of the same name."r" Build an ioctl number for an argumentless ioctl."r" Build an ioctl number for an read-only ioctl."r" Build an ioctl number for an write-only ioctl."r" Build an ioctl number for a read-write ioctl."// FIXME(redox): remove after relibc removes itRUSAGE_BOTH// confstr_CMSG_HDR_ALIGN_CMSG_DATA_ALIGNsecure_getenv// FIXME(solaris): O_DIRECT and SIGINFO are NOT available on Solaris.// But in past they were defined here and thus other crates expected them.// Latest version v0.29.0 of Nix crate still expects this. Since last// version of Nix crate is almost one year ago let's define these two// temporarily before new Nix version is released.EDOOMVX_TASK_RENAME_LENGTH// FIXME(msrv): `addr_of!(EXTERN_STATIC)` is now safe; remove `unsafe` when MSRV >= 1.82qsort_swcsnlen"_get_daylight"get_daylight"_get_dstbias"get_dstbias"_get_timezone""_get_tzname"get_tzname"_tzset"tzsetbuild_vendoredDBUS_VERSION// Version of vendored libdbusDBUS_VERSION_MAJORDBUS_VERSION_MINORDBUS_VERSION_MICRODBUS_SYSTEM_BUS_DEFAULT_ADDRESS// Location of dbus-daemon socket.// Systemd Default: https://github.com/systemd/systemd/blob/main/src/libsystemd/sd-bus/bus-internal.h#L20DBUS_SESSION_SOCKET_DIRDBUS_MACHINE_UUID_FILESOURCE_FILES/// Source Files Required/// Reference: https://github.com/freedesktop/dbus/blob/master/dbus/meson.build#L31/// Meson variable name: dbus_lib_sourcesINTERNAL_FILES/// Internal files/// Reference: https://github.com/freedesktop/dbus/blob/master/dbus/meson.build#L67/// Meson variable name: dbus_shared_sourcesUNIX_SOURCES/// Unix platform files/// References:/// - https://github.com/freedesktop/dbus/blob/master/dbus/meson.build#L139/// - https://github.com/freedesktop/dbus/blob/master/dbus/meson.build#L144/// Meson variable names: dbus_lib_sources + dbus_shared_sourcesCWARNINGS/// Taken directly from the libdbus meson config/// Reference: https://github.com/freedesktop/dbus/blob/master/meson.build#L1026/// Meson variable: compile_warningsdefsundefs/// Wrapper type for the libdbus config./// Boils down to a set of C defs/undefs./// Iterator over all C defines, set with -Dopt=val/// Iterator over all undefs, that must be set with -Uoptgenerate_stubs/// Config.h and dbus-arch-deps.h stubs (we generate config programatically/// instead to be passed directly to cc)generate_config/// Generate configuration based on target platform + architecturebuild_libdbus/// Vendored build entrypoint./// Instead of relying on cmake or meson. The build configuration was simple/// enough to port to cc directly. Allowing downstream crates to rely on the/// dbus crate without additional host dependencies.//! Vendored Libdbus build.//! Configures + Compiles + Statically Links a pinned libdbus release.DBusPendingCallDBusTimeout/// System or Session busDBUS_TIMEOUT_USE_DEFAULTDBUS_TIMEOUT_INFINITENotYetHandledNeedMemory/// This is not a valid message type (rarely used)/// This is a method return with error D-Bus message, used when the method call message could not be handled /// One of the four different D-Bus message types.DBusDispatchStatusDataRemainspadding1pad2_added_by_rust// Here would have been padding; because pad3 is a 8 byte aligned pointer (on amd64).// Rust reserves the right not to copy the padding when cloning a struct,// but the D-Bus library uses this part of the struct too.// Hence, add a field as big as the padding to ensure Rust copies all data.DBusHandleMessageFunctionDBusAddWatchFunctionDBusRemoveWatchFunctionDBusWatchToggledFunctionDBusAddTimeoutFunctionDBusTimeoutToggledFunctionDBusRemoveTimeoutFunctionDBusDispatchStatusFunctionDBusWakeupMainFunctionDBusPendingCallNotifyFunctionDBusFreeFunctionunregister_functionmessage_functiondbus_internal_pad1dbus_internal_pad2dbus_internal_pad3dbus_internal_pad4DBusObjectPathVTabledbus_bus_get_privatedbus_bus_get_unique_namedbus_bus_request_namedbus_bus_release_namedbus_bus_add_matchdbus_bus_remove_matchdbus_bus_registerdbus_connection_closedbus_connection_dispatchdbus_connection_flushdbus_connection_open_privatedbus_connection_unrefdbus_connection_get_is_connecteddbus_connection_set_exit_on_disconnectdbus_connection_send_with_reply_and_blockdbus_connection_send_with_replydbus_connection_senddbus_connection_read_write_dispatchdbus_connection_read_writedbus_connection_try_register_object_pathdbus_connection_unregister_object_pathdbus_connection_list_registereddbus_connection_add_filterdbus_connection_remove_filterdbus_connection_set_watch_functionsdbus_connection_set_timeout_functionsdbus_connection_set_dispatch_status_functiondbus_connection_set_wakeup_main_functiondbus_connection_pop_messagedbus_connection_get_dispatch_statusdbus_error_initdbus_error_freedbus_set_errordbus_set_error_from_messagedbus_message_new_method_calldbus_message_new_method_returndbus_message_new_errordbus_message_new_signaldbus_message_refdbus_message_unrefdbus_message_get_typedbus_message_is_method_calldbus_message_is_signaldbus_message_get_reply_serialdbus_message_get_serialdbus_message_get_pathdbus_message_get_interfacedbus_message_get_destinationdbus_message_get_memberdbus_message_get_senderdbus_message_set_serialdbus_message_set_senderdbus_message_set_destinationdbus_message_get_no_replydbus_message_set_no_replydbus_message_get_auto_startdbus_message_set_auto_startdbus_message_copydbus_message_iter_append_basicdbus_message_iter_append_fixed_arraydbus_message_iter_initdbus_message_iter_init_appenddbus_message_iter_get_arg_typedbus_message_iter_get_basicdbus_message_iter_get_element_typedbus_message_iter_get_fixed_arraydbus_message_iter_get_signaturedbus_message_iter_nextdbus_message_iter_recursedbus_message_iter_open_containerdbus_message_iter_close_containerdbus_freedbus_free_string_arraydbus_signature_validate_singledbus_threads_init_defaultdbus_validate_bus_namedbus_validate_error_namedbus_validate_interfacedbus_validate_memberdbus_validate_pathdbus_watch_get_enableddbus_watch_get_flagsdbus_watch_get_unix_fddbus_watch_get_socketdbus_watch_handledbus_watch_get_datadbus_watch_set_datadbus_timeout_get_enableddbus_timeout_get_intervaldbus_timeout_handledbus_timeout_get_datadbus_timeout_set_datadbus_pending_call_refdbus_pending_call_unrefdbus_pending_call_set_notifydbus_pending_call_steal_replydbus_message_marshaldbus_message_demarshaldbus_message_demarshal_bytes_neededdbus_connection_set_max_message_sizedbus_connection_get_max_message_sizedbus_connection_set_max_message_unix_fdsdbus_connection_get_max_message_unix_fdsdbus_connection_set_max_received_sizedbus_connection_get_max_received_sizedbus_connection_set_max_received_unix_fdsdbus_connection_get_max_received_unix_fdsdbus_connection_get_outgoing_sizedbus_connection_get_outgoing_unix_fdsdbus_connection_has_messages_to_senddbus_try_get_local_machine_iddbus_get_local_machine_idcp_radd_c_filesrerun_if// This is required to link libz when libssh2-sys is not included.GIT_OID_RAWSZGIT_OID_HEXSZGIT_CLONE_OPTIONS_VERSIONGIT_STASH_APPLY_OPTIONS_VERSIONGIT_CHECKOUT_OPTIONS_VERSIONGIT_MERGE_OPTIONS_VERSIONGIT_REMOTE_CALLBACKS_VERSIONGIT_STATUS_OPTIONS_VERSIONGIT_BLAME_OPTIONS_VERSIONGIT_PROXY_OPTIONS_VERSIONGIT_SUBMODULE_UPDATE_OPTIONS_VERSIONGIT_ODB_BACKEND_VERSIONGIT_REFDB_BACKEND_VERSIONGIT_CHERRYPICK_OPTIONS_VERSIONGIT_APPLY_OPTIONS_VERSIONGIT_REVERT_OPTIONS_VERSIONgit_enumgit_refdbgit_pushgit_revspecgit_time_tgit_off_tgit_object_size_tgit_revparse_mode_tGIT_REVPARSE_SINGLEGIT_REVPARSE_RANGEGIT_REVPARSE_MERGE_BASEGIT_OKGIT_ERRORGIT_ENOTFOUNDGIT_EEXISTSGIT_EAMBIGUOUSGIT_EBUFSGIT_EBAREREPOGIT_EUNBORNBRANCHGIT_EUNMERGEDGIT_ENONFASTFORWARDGIT_EINVALIDSPECGIT_ECONFLICTGIT_ELOCKEDGIT_EMODIFIEDGIT_EAUTHGIT_ECERTIFICATEGIT_EAPPLIEDGIT_EPEELGIT_EEOFGIT_EINVALIDGIT_EUNCOMMITTEDGIT_EDIRECTORYGIT_EMERGECONFLICTGIT_PASSTHROUGHGIT_ITEROVERGIT_RETRYGIT_EMISMATCHGIT_EINDEXDIRTYGIT_EAPPLYFAILGIT_EOWNERGIT_ERROR_NONEGIT_ERROR_NOMEMORYGIT_ERROR_OSGIT_ERROR_INVALIDGIT_ERROR_REFERENCEGIT_ERROR_ZLIBGIT_ERROR_REPOSITORYGIT_ERROR_CONFIGGIT_ERROR_REGEXGIT_ERROR_ODBGIT_ERROR_INDEXGIT_ERROR_OBJECTGIT_ERROR_NETGIT_ERROR_TAGGIT_ERROR_TREEGIT_ERROR_INDEXERGIT_ERROR_SSLGIT_ERROR_SUBMODULEGIT_ERROR_THREADGIT_ERROR_STASHGIT_ERROR_CHECKOUTGIT_ERROR_FETCHHEADGIT_ERROR_MERGEGIT_ERROR_SSHGIT_ERROR_FILTERGIT_ERROR_REVERTGIT_ERROR_CALLBACKGIT_ERROR_CHERRYPICKGIT_ERROR_DESCRIBEGIT_ERROR_REBASEGIT_ERROR_FILESYSTEMGIT_ERROR_PATCHGIT_ERROR_WORKTREEGIT_ERROR_SHA1GIT_ERROR_HTTPgit_repository_state_tGIT_REPOSITORY_STATE_NONEGIT_REPOSITORY_STATE_MERGEGIT_REPOSITORY_STATE_REVERTGIT_REPOSITORY_STATE_REVERT_SEQUENCEGIT_REPOSITORY_STATE_CHERRYPICKGIT_REPOSITORY_STATE_CHERRYPICK_SEQUENCEGIT_REPOSITORY_STATE_BISECTGIT_REPOSITORY_STATE_REBASEGIT_REPOSITORY_STATE_REBASE_INTERACTIVEGIT_REPOSITORY_STATE_REBASE_MERGEGIT_REPOSITORY_STATE_APPLY_MAILBOXGIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASEGIT_DIRECTION_FETCHGIT_DIRECTION_PUSHgit_clone_local_tcheckout_branchrepository_cbgit_repository_create_cbrepository_cb_payloadremote_cbgit_remote_create_cbremote_cb_payloadgit_clone_optionscheckout_strategydir_modefile_modefile_open_flagsgit_checkout_notify_cbnotify_payloadgit_checkout_progress_cbprogress_payloadbaseline_indextarget_directoryperfdata_cbgit_checkout_perfdata_cbperfdata_payloadgit_checkout_perfdatamkdir_callsstat_callschmod_callsgit_indexer_progress_cbgit_transfer_progressgit_remote_ready_cbgit_transport_message_cbgit_remote_completion_typegit_cred_acquire_cbgit_transport_certificate_check_cbgit_packbuilder_progressgit_push_transfer_progressgit_push_update_reference_cbpush_negotiationgit_push_negotiationgit_transport_cbremote_readyresolve_urlgit_url_resolve_cbproxy_optsGIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIEDGIT_REMOTE_DOWNLOAD_TAGS_AUTOGIT_REMOTE_DOWNLOAD_TAGS_NONEGIT_REMOTE_DOWNLOAD_TAGS_ALLGIT_FETCH_PRUNE_UNSPECIFIEDGIT_FETCH_PRUNEGIT_FETCH_NO_PRUNEGIT_REMOTE_COMPLETION_DOWNLOADGIT_REMOTE_COMPLETION_INDEXINGGIT_REMOTE_COMPLETION_ERRORgit_transfer_progress_cbgit_push_updatesrc_refnamedst_refnameGIT_CERT_NONEGIT_CERT_X509GIT_CERT_HOSTKEY_LIBSSH2GIT_CERT_STRARRAYcert_typegit_cert_ssh_tgit_cert_ssh_raw_type_thostkey_lenGIT_CERT_SSH_MD5GIT_CERT_SSH_SHA1GIT_CERT_SSH_SHA256GIT_CERT_SSH_RAWgit_diff_flag_tGIT_DIFF_FLAG_BINARYGIT_DIFF_FLAG_NOT_BINARYGIT_DIFF_FLAG_VALID_IDGIT_DIFF_FLAG_EXISTSGIT_CHECKOUT_NOTIFY_NONEGIT_CHECKOUT_NOTIFY_CONFLICTGIT_CHECKOUT_NOTIFY_DIRTYGIT_CHECKOUT_NOTIFY_UPDATEDGIT_CHECKOUT_NOTIFY_UNTRACKEDGIT_CHECKOUT_NOTIFY_IGNOREDGIT_CHECKOUT_NOTIFY_ALLgit_status_tGIT_STATUS_CURRENTGIT_STATUS_INDEX_NEWGIT_STATUS_INDEX_MODIFIEDGIT_STATUS_INDEX_DELETEDGIT_STATUS_INDEX_RENAMEDGIT_STATUS_INDEX_TYPECHANGEGIT_STATUS_WT_NEWGIT_STATUS_WT_MODIFIEDGIT_STATUS_WT_DELETEDGIT_STATUS_WT_TYPECHANGEGIT_STATUS_WT_RENAMEDGIT_STATUS_WT_UNREADABLEGIT_STATUS_IGNOREDGIT_STATUS_CONFLICTEDGIT_STATUS_OPT_INCLUDE_UNTRACKEDGIT_STATUS_OPT_INCLUDE_IGNOREDGIT_STATUS_OPT_INCLUDE_UNMODIFIEDGIT_STATUS_OPT_EXCLUDE_SUBMODULESGIT_STATUS_OPT_RECURSE_UNTRACKED_DIRSGIT_STATUS_OPT_DISABLE_PATHSPEC_MATCHGIT_STATUS_OPT_RECURSE_IGNORED_DIRSGIT_STATUS_OPT_RENAMES_HEAD_TO_INDEXGIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIRGIT_STATUS_OPT_SORT_CASE_SENSITIVELYGIT_STATUS_OPT_SORT_CASE_INSENSITIVELYGIT_STATUS_OPT_RENAMES_FROM_REWRITESGIT_STATUS_OPT_NO_REFRESHGIT_STATUS_OPT_UPDATE_INDEXGIT_STATUS_OPT_INCLUDE_UNREADABLEGIT_STATUS_OPT_INCLUDE_UNREADABLE_AS_UNTRACKEDgit_status_show_tGIT_STATUS_SHOW_INDEX_AND_WORKDIRGIT_STATUS_SHOW_INDEX_ONLYGIT_STATUS_SHOW_WORKDIR_ONLYgit_delta_tGIT_DELTA_UNMODIFIEDGIT_DELTA_ADDEDGIT_DELTA_DELETEDGIT_DELTA_MODIFIEDGIT_DELTA_RENAMEDGIT_DELTA_COPIEDGIT_DELTA_IGNOREDGIT_DELTA_UNTRACKEDGIT_DELTA_TYPECHANGEGIT_DELTA_UNREADABLEGIT_DELTA_CONFLICTEDsimilarityGIT_CHECKOUT_NONEGIT_CHECKOUT_SAFEGIT_CHECKOUT_FORCEGIT_CHECKOUT_RECREATE_MISSINGGIT_CHECKOUT_ALLOW_CONFLICTSGIT_CHECKOUT_REMOVE_UNTRACKEDGIT_CHECKOUT_REMOVE_IGNOREDGIT_CHECKOUT_UPDATE_ONLYGIT_CHECKOUT_DONT_UPDATE_INDEXGIT_CHECKOUT_NO_REFRESHGIT_CHECKOUT_SKIP_UNMERGEDGIT_CHECKOUT_USE_OURSGIT_CHECKOUT_USE_THEIRSGIT_CHECKOUT_DISABLE_PATHSPEC_MATCHGIT_CHECKOUT_SKIP_LOCKED_DIRECTORIESGIT_CHECKOUT_DONT_OVERWRITE_IGNOREDGIT_CHECKOUT_CONFLICT_STYLE_MERGEGIT_CHECKOUT_CONFLICT_STYLE_DIFF3GIT_CHECKOUT_UPDATE_SUBMODULESGIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGEDGIT_RESET_SOFTGIT_RESET_MIXEDGIT_RESET_HARDGIT_OBJECT_ANYGIT_OBJECT_INVALIDGIT_OBJECT_COMMITGIT_OBJECT_TREEGIT_OBJECT_BLOBGIT_OBJECT_TAGGIT_OBJECT_OFS_DELTAGIT_OBJECT_REF_DELTAGIT_REFERENCE_INVALIDGIT_REFERENCE_DIRECTGIT_REFERENCE_SYMBOLICGIT_REFERENCE_ALLgit_filemode_tGIT_FILEMODE_UNREADABLEGIT_FILEMODE_TREEGIT_FILEMODE_BLOBGIT_FILEMODE_BLOB_EXECUTABLEGIT_FILEMODE_LINKGIT_FILEMODE_COMMITGIT_TREEWALK_PREGIT_TREEWALK_POSTgit_treewalk_cbgit_treebuilder_filter_cbgit_revwalk_hide_cbgit_tree_update_tGIT_TREE_UPDATE_UPSERTGIT_TREE_UPDATE_REMOVEGIT_BRANCH_LOCALGIT_BRANCH_REMOTEGIT_BRANCH_ALLGIT_BLAME_NORMALGIT_BLAME_TRACK_COPIES_SAME_FILEGIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVESGIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIESGIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIESGIT_BLAME_FIRST_PARENTGIT_BLAME_USE_MAILMAPGIT_BLAME_IGNORE_WHITESPACEmin_match_charactersfinal_start_line_numberorig_pathorig_start_line_numberboundarygit_index_matched_path_cbgit_index_entry_extended_flag_tGIT_INDEX_ENTRY_INTENT_TO_ADDGIT_INDEX_ENTRY_SKIP_WORKTREEGIT_INDEX_ENTRY_UPTODATEgit_index_entry_flag_tGIT_INDEX_ENTRY_EXTENDEDGIT_INDEX_ENTRY_VALIDGIT_INDEX_ENTRY_NAMEMASKGIT_INDEX_ENTRY_STAGEMASKGIT_INDEX_ENTRY_STAGESHIFTGIT_CONFIG_LEVEL_PROGRAMDATAGIT_CONFIG_LEVEL_SYSTEMGIT_CONFIG_LEVEL_XDGGIT_CONFIG_LEVEL_GLOBALGIT_CONFIG_LEVEL_LOCALGIT_CONFIG_LEVEL_APPGIT_CONFIG_HIGHEST_LEVELGIT_SUBMODULE_UPDATE_CHECKOUTGIT_SUBMODULE_UPDATE_REBASEGIT_SUBMODULE_UPDATE_MERGEGIT_SUBMODULE_UPDATE_NONEGIT_SUBMODULE_UPDATE_DEFAULTGIT_SUBMODULE_IGNORE_UNSPECIFIEDGIT_SUBMODULE_IGNORE_NONEGIT_SUBMODULE_IGNORE_UNTRACKEDGIT_SUBMODULE_IGNORE_DIRTYGIT_SUBMODULE_IGNORE_ALLgit_submodule_cbgit_attr_value_tGIT_ATTR_VALUE_UNSPECIFIEDGIT_ATTR_VALUE_TRUEGIT_ATTR_VALUE_FALSEGIT_ATTR_VALUE_STRINGGIT_ATTR_CHECK_FILE_THEN_INDEXGIT_ATTR_CHECK_INDEX_THEN_FILEGIT_ATTR_CHECK_INDEX_ONLYGIT_ATTR_CHECK_NO_SYSTEMGIT_ATTR_CHECK_INCLUDE_HEADGIT_CREDTYPE_USERPASS_PLAINTEXTGIT_CREDTYPE_SSH_KEYGIT_CREDTYPE_SSH_CUSTOMGIT_CREDTYPE_DEFAULTGIT_CREDTYPE_SSH_INTERACTIVEGIT_CREDTYPE_USERNAMEGIT_CREDTYPE_SSH_MEMORYgit_cred_ssh_interactive_callbackLIBSSH2_USERAUTH_KBDINT_PROMPTLIBSSH2_USERAUTH_KBDINT_RESPONSEgit_cred_sign_callbackLIBSSH2_SESSIONgit_tag_foreach_cbgit_index_add_option_tGIT_INDEX_ADD_DEFAULTGIT_INDEX_ADD_FORCEGIT_INDEX_ADD_DISABLE_PATHSPEC_MATCHGIT_INDEX_ADD_CHECK_PATHSPECgit_repository_open_flag_tGIT_REPOSITORY_OPEN_NO_SEARCHGIT_REPOSITORY_OPEN_CROSS_FSGIT_REPOSITORY_OPEN_BAREGIT_REPOSITORY_OPEN_NO_DOTGITGIT_REPOSITORY_OPEN_FROM_ENVGIT_REPOSITORY_INIT_OPTIONS_VERSIONGIT_REPOSITORY_INIT_BAREGIT_REPOSITORY_INIT_NO_REINITGIT_REPOSITORY_INIT_NO_DOTGIT_DIRGIT_REPOSITORY_INIT_MKDIRGIT_REPOSITORY_INIT_MKPATHGIT_REPOSITORY_INIT_EXTERNAL_TEMPLATEgit_repository_init_mode_tGIT_REPOSITORY_INIT_SHARED_UMASKGIT_REPOSITORY_INIT_SHARED_GROUPGIT_REPOSITORY_INIT_SHARED_ALLgit_sort_tGIT_SORT_NONEGIT_SORT_TOPOLOGICALGIT_SORT_TIMEGIT_SORT_REVERSEgit_submodule_status_tGIT_SUBMODULE_STATUS_IN_HEADGIT_SUBMODULE_STATUS_IN_INDEXGIT_SUBMODULE_STATUS_IN_CONFIGGIT_SUBMODULE_STATUS_IN_WDGIT_SUBMODULE_STATUS_INDEX_ADDEDGIT_SUBMODULE_STATUS_INDEX_DELETEDGIT_SUBMODULE_STATUS_INDEX_MODIFIEDGIT_SUBMODULE_STATUS_WD_UNINITIALIZEDGIT_SUBMODULE_STATUS_WD_ADDEDGIT_SUBMODULE_STATUS_WD_DELETEDGIT_SUBMODULE_STATUS_WD_MODIFIEDGIT_SUBMODULE_STATUS_WD_INDEX_MODIFIEDGIT_SUBMODULE_STATUS_WD_WD_MODIFIEDGIT_SUBMODULE_STATUS_WD_UNTRACKEDgit_pathspec_flag_tGIT_PATHSPEC_DEFAULTGIT_PATHSPEC_IGNORE_CASEGIT_PATHSPEC_USE_CASEGIT_PATHSPEC_NO_GLOBGIT_PATHSPEC_NO_MATCH_ERRORGIT_PATHSPEC_FIND_FAILURESGIT_PATHSPEC_FAILURES_ONLYgit_diff_file_cbgit_diff_hunk_cbgit_diff_line_cbgit_diff_binary_cbheader_lenGIT_DIFF_LINE_CONTEXTGIT_DIFF_LINE_ADDITIONGIT_DIFF_LINE_DELETIONGIT_DIFF_LINE_CONTEXT_EOFNLGIT_DIFF_LINE_ADD_EOFNLGIT_DIFF_LINE_DEL_EOFNLGIT_DIFF_LINE_FILE_HDRGIT_DIFF_LINE_HUNK_HDRGIT_DIFF_LINE_BINARYgit_diff_notify_cbgit_diff_progress_cbGIT_DIFF_FORMAT_PATCHGIT_DIFF_FORMAT_PATCH_HEADERGIT_DIFF_FORMAT_RAWGIT_DIFF_FORMAT_NAME_ONLYGIT_DIFF_FORMAT_NAME_STATUSGIT_DIFF_FORMAT_PATCH_IDGIT_DIFF_STATS_NONEGIT_DIFF_STATS_FULLGIT_DIFF_STATS_SHORTGIT_DIFF_STATS_NUMBERGIT_DIFF_STATS_INCLUDE_SUMMARYgit_diff_option_tGIT_DIFF_NORMALGIT_DIFF_REVERSEGIT_DIFF_INCLUDE_IGNOREDGIT_DIFF_RECURSE_IGNORED_DIRSGIT_DIFF_INCLUDE_UNTRACKEDGIT_DIFF_RECURSE_UNTRACKED_DIRSGIT_DIFF_INCLUDE_UNMODIFIEDGIT_DIFF_INCLUDE_TYPECHANGEGIT_DIFF_INCLUDE_TYPECHANGE_TREESGIT_DIFF_IGNORE_FILEMODEGIT_DIFF_IGNORE_SUBMODULESGIT_DIFF_IGNORE_CASEGIT_DIFF_DISABLE_PATHSPEC_MATCHGIT_DIFF_SKIP_BINARY_CHECKGIT_DIFF_ENABLE_FAST_UNTRACKED_DIRSGIT_DIFF_UPDATE_INDEXGIT_DIFF_INCLUDE_UNREADABLEGIT_DIFF_INCLUDE_UNREADABLE_AS_UNTRACKEDGIT_DIFF_INDENT_HEURISTICGIT_DIFF_IGNORE_BLANK_LINESGIT_DIFF_FORCE_TEXTGIT_DIFF_FORCE_BINARYGIT_DIFF_IGNORE_WHITESPACEGIT_DIFF_IGNORE_WHITESPACE_CHANGEGIT_DIFF_IGNORE_WHITESPACE_EOLGIT_DIFF_SHOW_UNTRACKED_CONTENTGIT_DIFF_SHOW_UNMODIFIEDGIT_DIFF_PATIENCEGIT_DIFF_MINIMALGIT_DIFF_SHOW_BINARYmetricgit_diff_similarity_metricfile_signaturebuffer_signaturefree_signatureGIT_DIFF_FIND_OPTIONS_VERSIONGIT_DIFF_FIND_BY_CONFIGGIT_DIFF_FIND_RENAMESGIT_DIFF_FIND_RENAMES_FROM_REWRITESGIT_DIFF_FIND_COPIESGIT_DIFF_FIND_COPIES_FROM_UNMODIFIEDGIT_DIFF_FIND_REWRITESGIT_DIFF_BREAK_REWRITESGIT_DIFF_FIND_AND_BREAK_REWRITESGIT_DIFF_FIND_FOR_UNTRACKEDGIT_DIFF_FIND_ALLGIT_DIFF_FIND_IGNORE_LEADING_WHITESPACEGIT_DIFF_FIND_IGNORE_WHITESPACEGIT_DIFF_FIND_DONT_IGNORE_WHITESPACEGIT_DIFF_FIND_EXACT_MATCH_ONLYGIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLYGIT_DIFF_FIND_REMOVE_UNMODIFIEDpatch_nototal_patchesGIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSIONGIT_DIFF_FORMAT_EMAIL_NONEGIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKERGIT_DIFF_PATCHID_OPTIONS_VERSIONdataleninflatedlenGIT_DIFF_BINARY_NONEGIT_DIFF_BINARY_LITERALGIT_DIFF_BINARY_DELTAdefault_driverfile_flagsgit_merge_flag_tGIT_MERGE_FIND_RENAMESGIT_MERGE_FAIL_ON_CONFLICTGIT_MERGE_SKIP_REUCGIT_MERGE_NO_RECURSIVEGIT_MERGE_FILE_FAVOR_NORMALGIT_MERGE_FILE_FAVOR_OURSGIT_MERGE_FILE_FAVOR_THEIRSGIT_MERGE_FILE_FAVOR_UNIONgit_merge_file_flag_tGIT_MERGE_FILE_DEFAULTGIT_MERGE_FILE_STYLE_MERGEGIT_MERGE_FILE_STYLE_DIFF3GIT_MERGE_FILE_SIMPLIFY_ALNUMGIT_MERGE_FILE_IGNORE_WHITESPACEGIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGEGIT_MERGE_FILE_IGNORE_WHITESPACE_EOLGIT_MERGE_FILE_DIFF_PATIENCEGIT_MERGE_FILE_DIFF_MINIMALgit_merge_analysis_tGIT_MERGE_ANALYSIS_NONEGIT_MERGE_ANALYSIS_NORMALGIT_MERGE_ANALYSIS_UP_TO_DATEGIT_MERGE_ANALYSIS_FASTFORWARDGIT_MERGE_ANALYSIS_UNBORNgit_merge_preference_tGIT_MERGE_PREFERENCE_NONEGIT_MERGE_PREFERENCE_NO_FASTFORWARDGIT_MERGE_PREFERENCE_FASTFORWARD_ONLYgit_remote_connect_optionsset_connect_optslsnegotiate_fetchdownload_packGIT_REMOTE_REDIRECT_NONEGIT_REMOTE_REDIRECT_INITIALGIT_REMOTE_REDIRECT_ALLread_prefixwritestreamreadstreamgit_odb_foreach_cbwritepackwritemidxfreshengit_odb_lookup_flags_tGIT_ODB_LOOKUP_NO_REFRESHgit_refdb_backenddelhas_logensure_logreflog_readreflog_writeGIT_PROXY_NONEGIT_PROXY_AUTOGIT_PROXY_SPECIFIEDGIT_SERVICE_UPLOADPACK_LSGIT_SERVICE_UPLOADPACKGIT_SERVICE_RECEIVEPACK_LSGIT_SERVICE_RECEIVEPACKsubtransportgit_smart_subtransport_cbgit_smart_subtransport_definitiondescribe_strategygit_describe_strategy_tGIT_DESCRIBE_DEFAULTGIT_DESCRIBE_TAGSGIT_DESCRIBE_ALLGIT_PACKBUILDER_ADDING_OBJECTSGIT_PACKBUILDER_DELTAFICATIONgit_stash_flagsGIT_STASH_DEFAULTGIT_STASH_KEEP_INDEXGIT_STASH_INCLUDE_UNTRACKEDGIT_STASH_INCLUDE_IGNOREDgit_stash_apply_flagsGIT_STASH_APPLY_DEFAULTGIT_STASH_APPLY_REINSTATE_INDEXGIT_STASH_APPLY_PROGRESS_NONEGIT_STASH_APPLY_PROGRESS_LOADING_STASHGIT_STASH_APPLY_PROGRESS_ANALYZE_INDEXGIT_STASH_APPLY_PROGRESS_ANALYZE_MODIFIEDGIT_STASH_APPLY_PROGRESS_ANALYZE_UNTRACKEDGIT_STASH_APPLY_PROGRESS_CHECKOUT_UNTRACKEDGIT_STASH_APPLY_PROGRESS_CHECKOUT_MODIFIEDGIT_STASH_APPLY_PROGRESS_DONEgit_stash_apply_progress_cbgit_stash_cbgit_packbuilder_foreach_cbgit_commit_signing_cbgit_commit_create_cbGIT_REBASE_NO_OPERATIONcommit_create_cbsigning_cbGIT_REBASE_OPERATION_PICKGIT_REBASE_OPERATION_REWORDGIT_REBASE_OPERATION_EDITGIT_REBASE_OPERATION_SQUASHGIT_REBASE_OPERATION_FIXUPGIT_REBASE_OPERATION_EXECgit_apply_delta_cbgit_apply_hunk_cbGIT_APPLY_CHECKGIT_APPLY_LOCATION_WORKDIRGIT_APPLY_LOCATION_INDEXGIT_APPLY_LOCATION_BOTHgit_libgit2_opt_tGIT_OPT_GET_MWINDOW_SIZEGIT_OPT_SET_MWINDOW_SIZEGIT_OPT_GET_MWINDOW_MAPPED_LIMITGIT_OPT_SET_MWINDOW_MAPPED_LIMITGIT_OPT_GET_SEARCH_PATHGIT_OPT_SET_SEARCH_PATHGIT_OPT_SET_CACHE_OBJECT_LIMITGIT_OPT_SET_CACHE_MAX_SIZEGIT_OPT_ENABLE_CACHINGGIT_OPT_GET_CACHED_MEMORYGIT_OPT_GET_TEMPLATE_PATHGIT_OPT_SET_TEMPLATE_PATHGIT_OPT_SET_SSL_CERT_LOCATIONSGIT_OPT_SET_USER_AGENTGIT_OPT_ENABLE_STRICT_OBJECT_CREATIONGIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATIONGIT_OPT_SET_SSL_CIPHERSGIT_OPT_GET_USER_AGENTGIT_OPT_ENABLE_OFS_DELTAGIT_OPT_ENABLE_FSYNC_GITDIRGIT_OPT_GET_WINDOWS_SHAREMODEGIT_OPT_SET_WINDOWS_SHAREMODEGIT_OPT_ENABLE_STRICT_HASH_VERIFICATIONGIT_OPT_SET_ALLOCATORGIT_OPT_ENABLE_UNSAVED_INDEX_SAFETYGIT_OPT_GET_PACK_MAX_OBJECTSGIT_OPT_SET_PACK_MAX_OBJECTSGIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKSGIT_OPT_ENABLE_HTTP_EXPECT_CONTINUEGIT_OPT_GET_MWINDOW_FILE_LIMITGIT_OPT_SET_MWINDOW_FILE_LIMITGIT_OPT_SET_ODB_PACKED_PRIORITYGIT_OPT_SET_ODB_LOOSE_PRIORITYGIT_OPT_GET_EXTENSIONSGIT_OPT_SET_EXTENSIONSGIT_OPT_GET_OWNER_VALIDATIONGIT_OPT_SET_OWNER_VALIDATIONgit_reference_format_tGIT_REFERENCE_FORMAT_NORMALGIT_REFERENCE_FORMAT_ALLOW_ONELEVELGIT_REFERENCE_FORMAT_REFSPEC_PATTERNGIT_REFERENCE_FORMAT_REFSPEC_SHORTHANDGIT_WORKTREE_ADD_OPTIONS_VERSIONGIT_WORKTREE_PRUNE_VALIDGIT_WORKTREE_PRUNE_LOCKEDGIT_WORKTREE_PRUNE_WORKING_TREEGIT_WORKTREE_PRUNE_OPTIONS_VERSIONgit_repository_mergehead_foreach_cbgit_repository_fetchhead_foreach_cbGIT_TRACE_NONEGIT_TRACE_FATALGIT_TRACE_ERRORGIT_TRACE_WARNGIT_TRACE_INFOGIT_TRACE_DEBUGGIT_TRACE_TRACEgit_trace_cbgit_feature_tGIT_FEATURE_THREADSGIT_FEATURE_HTTPSGIT_FEATURE_SSHGIT_FEATURE_NSECgit_message_trailer_trailer_blockdiff_optsdiff_find_optsGIT_EMAIL_CREATE_OPTIONS_VERSIONGIT_EMAIL_CREATE_DEFAULTGIT_EMAIL_CREATE_OMIT_NUMBERSGIT_EMAIL_CREATE_ALWAYS_NUMBERGIT_EMAIL_CREATE_NO_RENAMESgit_libgit2_init// threadsgit_libgit2_shutdowngit_repository_new// repositorygit_repository_freegit_repository_opengit_repository_open_baregit_repository_open_extgit_repository_open_from_worktreegit_repository_wrap_odbgit_repository_initgit_repository_init_extgit_repository_init_init_optionsgit_repository_get_namespacegit_repository_set_namespacegit_repository_headgit_repository_set_headgit_repository_head_detachedgit_repository_set_head_detachedgit_repository_set_head_detached_from_annotatedgit_repository_set_baregit_repository_is_worktreegit_repository_is_baregit_repository_is_emptygit_repository_is_shallowgit_repository_pathgit_repository_stategit_repository_workdirgit_repository_set_workdirgit_repository_indexgit_repository_set_indexgit_repository_messagegit_repository_message_removegit_repository_configgit_repository_set_configgit_repository_config_snapshotgit_repository_discovergit_repository_set_odbgit_repository_refdbgit_repository_set_refdbgit_repository_reinit_filesystemgit_repository_mergehead_foreachgit_repository_fetchhead_foreachgit_ignore_add_rulegit_ignore_clear_internal_rulesgit_ignore_path_is_ignoredgit_revparse// revparsegit_revparse_singlegit_revparse_extgit_object_dup// objectgit_object_idgit_object_freegit_object_lookupgit_object_typegit_object_peelgit_object_short_idgit_object_type2stringgit_object_string2typegit_object_typeisloosegit_oid_fromraw// oidgit_oid_fromstrngit_oid_tostrgit_oid_cmpgit_oid_equalgit_oid_streqgit_oid_iszerogit_error_last// errorgit_error_cleargit_error_set_strgit_remote_create// remotegit_remote_create_with_fetchspecgit_remote_lookupgit_remote_create_anonymousgit_remote_create_detachedgit_remote_deletegit_remote_freegit_remote_namegit_remote_pushurlgit_remote_refspec_countgit_remote_urlgit_remote_connectgit_remote_connectedgit_remote_disconnectgit_remote_add_fetchgit_remote_add_pushgit_remote_downloadgit_remote_stopgit_remote_dupgit_remote_get_fetch_refspecsgit_remote_get_push_refspecsgit_remote_get_refspecgit_remote_is_valid_namegit_remote_listgit_remote_renamegit_remote_fetchgit_remote_pushgit_remote_update_tipsgit_remote_set_urlgit_remote_set_pushurlgit_remote_init_callbacksgit_fetch_init_optionsgit_remote_statsgit_remote_lsgit_remote_set_autotaggit_remote_prunegit_remote_default_branchgit_refspec_direction// refspecgit_refspec_dstgit_refspec_dst_matchesgit_refspec_srcgit_refspec_src_matchesgit_refspec_forcegit_refspec_stringgit_refspec_transformgit_refspec_rtransformgit_strarray_free// strarraygit_oidarray_free// oidarraygit_signature_default// signaturegit_signature_freegit_signature_newgit_signature_nowgit_signature_dupgit_status_list_new// statusgit_status_list_entrycountgit_status_byindexgit_status_list_freegit_status_init_optionsgit_status_filegit_status_should_ignoregit_clone// clonegit_clone_init_optionsgit_reset// resetgit_reset_defaultgit_reference_cmp// referencegit_reference_deletegit_reference_freegit_reference_is_branchgit_reference_is_notegit_reference_is_remotegit_reference_is_taggit_reference_is_valid_namegit_reference_lookupgit_reference_dwimgit_reference_namegit_reference_name_to_idgit_reference_peelgit_reference_renamegit_reference_resolvegit_reference_shorthandgit_reference_symbolic_targetgit_reference_targetgit_reference_target_peelgit_reference_set_targetgit_reference_typegit_reference_iterator_newgit_reference_iterator_glob_newgit_reference_iterator_freegit_reference_nextgit_reference_next_namegit_reference_creategit_reference_symbolic_creategit_reference_create_matchinggit_reference_symbolic_create_matchinggit_reference_has_loggit_reference_ensure_loggit_reference_normalize_namegit_stash_save// stashgit_stash_apply_init_optionsgit_stash_applygit_stash_foreachgit_stash_dropgit_stash_popgit_submodule_add_finalize// submodulesgit_submodule_add_setupgit_submodule_add_to_indexgit_submodule_branchgit_submodule_clonegit_submodule_foreachgit_submodule_freegit_submodule_head_idgit_submodule_ignoregit_submodule_index_idgit_submodule_initgit_submodule_locationgit_submodule_lookupgit_submodule_namegit_submodule_opengit_submodule_pathgit_submodule_reloadgit_submodule_set_ignoregit_submodule_set_updategit_submodule_set_urlgit_submodule_syncgit_submodule_update_strategygit_submodule_updategit_submodule_update_init_optionsgit_submodule_urlgit_submodule_wd_idgit_submodule_statusgit_submodule_set_branchgit_blob_free// blobgit_blob_idgit_blob_is_binarygit_blob_lookupgit_blob_lookup_prefixgit_blob_rawcontentgit_blob_rawsizegit_blob_create_frombuffergit_blob_create_fromdiskgit_blob_create_fromworkdirgit_blob_create_fromstreamgit_blob_create_fromstream_commitgit_tree_entry_byid// treegit_tree_entry_byindexgit_tree_entry_bynamegit_tree_entry_bypathgit_tree_entry_cmpgit_tree_entry_dupgit_tree_entry_filemodegit_tree_entry_filemode_rawgit_tree_entry_freegit_tree_entry_idgit_tree_entry_namegit_tree_entry_to_objectgit_tree_entry_typegit_tree_entrycountgit_tree_freegit_tree_idgit_tree_lookupgit_tree_walkgit_tree_create_updatedgit_treebuilder_new// treebuildergit_treebuilder_cleargit_treebuilder_entrycountgit_treebuilder_freegit_treebuilder_getgit_treebuilder_insertgit_treebuilder_removegit_treebuilder_filtergit_treebuilder_writegit_buf_dispose// bufgit_buf_growgit_buf_setgit_commit_author// commitgit_commit_author_with_mailmapgit_commit_committergit_commit_committer_with_mailmapgit_commit_freegit_commit_idgit_commit_lookupgit_commit_messagegit_commit_message_encodinggit_commit_message_rawgit_commit_nth_gen_ancestorgit_commit_parentgit_commit_parent_idgit_commit_parentcountgit_commit_raw_headergit_commit_summarygit_commit_bodygit_commit_timegit_commit_time_offsetgit_commit_treegit_commit_tree_idgit_commit_amendgit_commit_creategit_commit_create_buffergit_commit_header_fieldgit_annotated_commit_lookupgit_commit_create_with_signaturegit_commit_extract_signaturegit_branch_create// branchgit_branch_create_from_annotatedgit_branch_deletegit_branch_is_headgit_branch_iterator_freegit_branch_iterator_newgit_branch_lookupgit_branch_movegit_branch_namegit_branch_name_is_validgit_branch_remote_namegit_branch_nextgit_branch_set_upstreamgit_branch_upstreamgit_branch_upstream_namegit_branch_upstream_remotegit_index_version// indexgit_index_set_versiongit_index_addgit_index_add_allgit_index_add_bypathgit_index_add_frombuffergit_index_conflict_addgit_index_conflict_removegit_index_conflict_getgit_index_conflict_iterator_newgit_index_conflict_nextgit_index_conflict_iterator_freegit_index_cleargit_index_entry_stagegit_index_entrycountgit_index_findgit_index_freegit_index_get_byindexgit_index_get_bypathgit_index_has_conflictsgit_index_newgit_index_opengit_index_pathgit_index_readgit_index_read_treegit_index_removegit_index_remove_allgit_index_remove_bypathgit_index_remove_directorygit_index_update_allgit_index_writegit_index_write_treegit_index_write_tree_togit_config_add_file_ondisk// configgit_config_delete_entrygit_config_delete_multivargit_config_find_programdatagit_config_find_globalgit_config_find_systemgit_config_find_xdggit_config_freegit_config_get_boolgit_config_get_entrygit_config_get_int32git_config_get_int64git_config_get_stringgit_config_get_string_bufgit_config_get_pathgit_config_iterator_freegit_config_iterator_glob_newgit_config_iterator_newgit_config_newgit_config_nextgit_config_open_defaultgit_config_open_globalgit_config_open_levelgit_config_open_ondiskgit_config_parse_boolgit_config_parse_int32git_config_parse_int64git_config_set_boolgit_config_set_int32git_config_set_int64git_config_set_multivargit_config_set_stringgit_config_snapshotgit_config_entry_freegit_config_multivar_iterator_newgit_attr_get// attrgit_attr_valuegit_cred_default_new// credgit_cred_has_usernamegit_cred_ssh_custom_newgit_cred_ssh_interactive_newgit_cred_ssh_key_from_agentgit_cred_ssh_key_newgit_cred_ssh_key_memory_newgit_cred_userpassgit_cred_userpass_plaintext_newgit_cred_username_newgit_tag_annotation_create// tagsgit_tag_creategit_tag_create_frombuffergit_tag_create_lightweightgit_tag_deletegit_tag_foreachgit_tag_freegit_tag_idgit_tag_listgit_tag_list_matchgit_tag_lookupgit_tag_lookup_prefixgit_tag_messagegit_tag_namegit_tag_peelgit_tag_taggergit_tag_targetgit_tag_target_idgit_tag_target_typegit_checkout_head// checkoutgit_checkout_indexgit_checkout_treegit_checkout_init_optionsgit_annotated_commit_id// mergegit_annotated_commit_refgit_annotated_commit_from_refgit_annotated_commit_from_fetchheadgit_annotated_commit_freegit_merge_init_optionsgit_mergegit_merge_commitsgit_merge_treesgit_repository_state_cleanupgit_merge_analysisgit_merge_analysis_for_refgit_note_author// notesgit_note_committergit_note_creategit_note_default_refgit_note_freegit_note_idgit_note_iterator_freegit_note_iterator_newgit_note_messagegit_note_nextgit_note_readgit_note_removegit_blame_file// blamegit_blame_freegit_blame_init_optionsgit_blame_get_hunk_countgit_blame_get_hunk_bylinegit_blame_get_hunk_byindexgit_revwalk_new// revwalkgit_revwalk_freegit_revwalk_resetgit_revwalk_sortinggit_revwalk_push_headgit_revwalk_pushgit_revwalk_push_refgit_revwalk_push_globgit_revwalk_push_rangegit_revwalk_simplify_first_parentgit_revwalk_hide_headgit_revwalk_hidegit_revwalk_hide_refgit_revwalk_hide_globgit_revwalk_add_hide_cbgit_revwalk_nextgit_merge_basegit_merge_base_manygit_merge_basesgit_merge_bases_manygit_pathspec_free// pathspecgit_pathspec_match_diffgit_pathspec_match_indexgit_pathspec_match_list_diff_entrygit_pathspec_match_list_entrygit_pathspec_match_list_entrycountgit_pathspec_match_list_failed_entrygit_pathspec_match_list_failed_entrycountgit_pathspec_match_list_freegit_pathspec_match_treegit_pathspec_match_workdirgit_pathspec_matches_pathgit_pathspec_newgit_diff_blob_to_buffer// diffgit_diff_blobsgit_diff_buffersgit_diff_from_buffergit_diff_find_similargit_diff_find_init_optionsgit_diff_foreachgit_diff_freegit_diff_get_deltagit_diff_get_statsgit_diff_index_to_indexgit_diff_index_to_workdirgit_diff_init_optionsgit_diff_is_sorted_icasegit_diff_mergegit_diff_num_deltasgit_diff_num_deltas_of_typegit_diff_printgit_diff_stats_deletionsgit_diff_stats_files_changedgit_diff_stats_freegit_diff_stats_insertionsgit_diff_stats_to_bufgit_diff_status_chargit_diff_tree_to_indexgit_diff_tree_to_treegit_diff_tree_to_workdirgit_diff_tree_to_workdir_with_indexgit_graph_ahead_behindgit_graph_descendant_ofgit_diff_format_emailgit_diff_format_email_options_initgit_diff_patchidgit_diff_patchid_options_initgit_patch_from_diff// patchgit_patch_from_blobsgit_patch_from_blob_and_buffergit_patch_from_buffersgit_patch_freegit_patch_get_deltagit_patch_num_hunksgit_patch_line_statsgit_patch_get_hunkgit_patch_num_lines_in_hunkgit_patch_get_line_in_hunkgit_patch_sizegit_patch_printgit_patch_to_bufgit_reflog_append// refloggit_reflog_deletegit_reflog_dropgit_reflog_entry_byindexgit_reflog_entry_committergit_reflog_entry_id_newgit_reflog_entry_id_oldgit_reflog_entry_messagegit_reflog_entrycountgit_reflog_freegit_reflog_readgit_reflog_renamegit_reflog_writegit_transport_register// transportgit_transport_unregistergit_transport_smartgit_describe_commit// describegit_describe_formatgit_describe_result_freegit_describe_workdirgit_message_prettify// messagegit_message_trailersgit_message_trailer_array_freegit_packbuilder_new// packbuildergit_packbuilder_set_threadsgit_packbuilder_insertgit_packbuilder_insert_treegit_packbuilder_insert_commitgit_packbuilder_insert_walkgit_packbuilder_insert_recurgit_packbuilder_write_bufgit_packbuilder_write"use `git_packbuilder_name` to retrieve the filename"git_packbuilder_hashgit_packbuilder_namegit_packbuilder_foreachgit_packbuilder_object_countgit_packbuilder_writtengit_packbuilder_set_callbacksgit_packbuilder_freegit_repository_odb// odbgit_odb_newgit_odb_freegit_odb_open_rstreamgit_odb_stream_readgit_odb_open_wstreamgit_odb_stream_writegit_odb_stream_finalize_writegit_odb_stream_freegit_odb_foreachgit_odb_readgit_odb_read_headergit_odb_writegit_odb_write_packgit_odb_hashgit_odb_hashfilegit_odb_exists_prefixgit_odb_existsgit_odb_exists_extgit_odb_refreshgit_odb_object_idgit_odb_object_sizegit_odb_object_typegit_odb_object_datagit_odb_object_dupgit_odb_object_freegit_odb_init_backendgit_odb_add_backendgit_odb_backend_packgit_odb_backend_one_packgit_odb_add_disk_alternategit_odb_backend_loosegit_odb_add_alternategit_odb_backend_mallocgit_odb_num_backendsgit_odb_get_backendgit_mempack_new// mempackgit_mempack_resetgit_mempack_dumpgit_refdb_new// refdbgit_refdb_opengit_refdb_backend_fsgit_refdb_init_backendgit_refdb_set_backendgit_refdb_compressgit_refdb_freegit_rebase_init_options// rebasegit_rebase_initgit_rebase_opengit_rebase_operation_entrycountgit_rebase_operation_currentgit_rebase_operation_byindexgit_rebase_orig_head_idgit_rebase_orig_head_namegit_rebase_nextgit_rebase_inmemory_indexgit_rebase_commitgit_rebase_abortgit_rebase_finishgit_rebase_freegit_cherrypick_init_options// cherrypickgit_cherrypickgit_cherrypick_commitgit_apply_options_init// applygit_apply_to_treegit_applygit_revert_options_init// revertgit_revert_commitgit_revertgit_libgit2_version// Commongit_libgit2_featuresgit_libgit2_optsgit_worktree_list// Worktreesgit_worktree_lookupgit_worktree_open_from_repositorygit_worktree_freegit_worktree_validategit_worktree_add_options_initgit_worktree_addgit_worktree_lockgit_worktree_unlockgit_worktree_is_lockedgit_worktree_namegit_worktree_pathgit_worktree_prune_options_initgit_worktree_is_prunablegit_worktree_prunegit_transaction_new// Ref transactionsgit_transaction_lock_refgit_transaction_set_targetgit_transaction_set_symbolic_targetgit_transaction_set_refloggit_transaction_removegit_transaction_commitgit_transaction_freegit_mailmap_new// Mailmapgit_mailmap_from_buffergit_mailmap_from_repositorygit_mailmap_freegit_mailmap_resolve_signaturegit_mailmap_add_entrygit_email_create_from_diff// emailgit_email_create_from_commitgit_trace_set// merge analysisopenssl_initssh_initr0_7_4/// Release 0.7.4 (2022-11-07)/// This release has no functional changes./// `RTLD_LAZY`, `RTLD_GLOBAL` and `RTLD_LOCAL` constants have been implemented for AIX platforms.r0_7_3/// Release 0.7.3 (2022-01-15)/// In this release the `docsrs` `cfg` has been renamed to `libloading_docs` to better reflect that/// this `cfg` is intended to be only used by `libloading` and only specifically for the invocation/// of `rustdoc` when documenting `libloading`. Setting this `cfg` in any other situation is/// unsupported and will not work.r0_7_2/// Release 0.7.2 (2021-11-14)/// Cargo.toml now specifies the MSRV bounds, which enables tooling to report an early failure when/// the version of the toolchain is insufficient. Refer to the [min-rust-version RFC] and its/// [tracking issue]./// [min-rust-version RFC]: https://rust-lang.github.io/rfcs/2495-min-rust-version.html/// [tracking issue]: https://github.com/rust-lang/rust/issues/65262/// Additionally, on platforms `libloading` has no support (today: `not(any(unix, windows))`), we/// will no longer attempt to implement the cross-platform `Library` and `Symbol` types. This makes/// `libloading` compile on targets such as `wasm32-unknown-unknown` and gives ability to the/// downstream consumers of this library to decide how they want to handle the absence of the/// library loading implementation in their code. One of such approaches could be depending on/// `libloading` itself optionally as such:/// [target.'cfg(any(unix, windows))'.dependencies.libloading]/// version = "0.7"r0_7_1/// Release 0.7.1 (2021-10-09)/// Significantly improved the consistency and style of the documentation.r0_7_0/// Release 0.7.0 (2021-02-06)/// ## Breaking changes/// ### Loading functions are now `unsafe`/// A number of associated methods involved in loading a library were changed to/// be `unsafe`. The affected functions are: [`Library::new`], [`os::unix::Library::new`],/// [`os::unix::Library::open`], [`os::windows::Library::new`],/// [`os::windows::Library::load_with_flags`]. This is the most prominent breaking change in this/// release and affects majority of the users of `libloading`./// In order to see why it was necessary, consider the following snippet of C++ code:/// #include <vector>/// #include <iostream>/// static std::vector<unsigned int> UNSHUU = { 1, 2, 3 };/// int main() {///     std::cout << UNSHUU[0] << UNSHUU[1] << UNSHUU[2] << std::endl; // Prints 123///     return 0;/// The `std::vector` type, much like in Rust's `Vec`, stores its contents in a buffer allocated on/// the heap. In this example the vector object itself is stored and initialized as a static/// variable – a compile time construct. The heap, on the other hand, is a runtime construct. And/// yet the code works exactly as you'd expect – the vector contains numbers 1, 2 and 3 stored in/// a buffer on heap. So, _what_ makes it work out, exactly?/// Various executable and shared library formats define conventions and machinery to execute/// arbitrary code when a program or a shared library is loaded. On systems using the PE format/// (e.g. Windows) this is available via the optional `DllMain` initializer. Various systems/// utilizing the ELF format take a sightly different approach of maintaining an array of function/// pointers in the `.init_array` section. A very similar mechanism exists on systems that utilize/// the Mach-O format./// For the C++ program above, the object stored in the `UNSHUU` global variable is constructed/// by code run as part of such an initializer routine. This initializer is run before the entry/// point (the `main` function) is executed, allowing for this magical behaviour to be possible./// Were the C++ code built as a shared library instead, the initialization routines would run as/// the resulting shared library is loaded. In case of `libloading` – during the call to/// `Library::new` and other methods affected by this change./// These initialization (and very closely related termination) routines can be utilized outside of/// C++ too. Anybody can build a shared library in variety of different programming languages and/// set up the initializers to execute arbitrary code. Potentially code that does all sorts of/// wildly unsound stuff./// The routines are executed by components that are an integral part of the operating system./// Changing or controlling the operation of these components is infeasible. With that in/// mind, the initializer and termination routines are something anybody loading a library must/// carefully evaluate the libraries loaded for soundness./// In practice, a vast majority of the libraries can be considered a good citizen and their/// initialization and termination routines, if they have any at all, can be trusted to be sound./// Also see: [issue #86]./// ### Better & more consistent default behaviour on UNIX systems/// On UNIX systems the [`Library::new`], [`os::unix::Library::new`] and/// [`os::unix::Library::this`] methods have been changed to use/// <code>[RTLD_LAZY] | [RTLD_LOCAL]</code> as the default set of loader options (previously:/// [`RTLD_NOW`]). This has a couple benefits. Namely:/// * Lazy binding is generally quicker to execute when only a subset of symbols from a library are///   used and is typically the default when neither `RTLD_LAZY` nor `RTLD_NOW` are specified when///   calling the underlying `dlopen` API;/// * On most UNIX systems (macOS being a notable exception) `RTLD_LOCAL` is the default when///   neither `RTLD_LOCAL` nor [`RTLD_GLOBAL`] are specified. The explicit setting of the///   `RTLD_LOCAL` flag makes this behaviour consistent across platforms./// ### Dropped support for Windows XP/Vista/// The (broken) support for Windows XP and Windows Vista environments was removed. This was/// prompted primarily by a similar policy change in the [Rust/// project](https://github.com/rust-lang/compiler-team/issues/378) but also as an acknowledgement/// to the fact that `libloading` never worked in these environments anyway./// ### More accurate error variant names/// Finally, the `Error::LoadLibraryW` renamed to [`Error::LoadLibraryExW`] to more accurately/// represent the underlying API that's failing. No functional changes as part of this rename/// [issue #86]: https://github.com/nagisa/rust_libloading/issues/86/// [`Library::new`]: crate::Library::new/// [`Error::LoadLibraryExW`]: crate::Error::LoadLibraryExW/// [`os::unix::Library::this`]: crate::os::unix::Library::this/// [`os::unix::Library::new`]: crate::os::unix::Library::new/// [`os::unix::Library::open`]: crate::os::unix::Library::new/// [`os::windows::Library::new`]: crate::os::windows::Library::new/// [`os::windows::Library::load_with_flags`]: crate::os::windows::Library::load_with_flags/// [`RTLD_NOW`]: crate::os::unix::RTLD_NOW/// [RTLD_LAZY]: crate::os::unix::RTLD_LAZY/// [RTLD_LOCAL]: crate::os::unix::RTLD_LOCAL/// [`RTLD_GLOBAL`]: crate::os::unix::RTLD_GLOBALr0_6_7/// Release 0.6.7 (2021-01-14)/// * Added a [`os::windows::Library::open_already_loaded`] to obtain a handle to a library that/// must already be loaded. There is no portable equivalent for all UNIX targets. Users who do not/// care about portability across UNIX platforms may use [`os::unix::Library::open`] with/// `libc::RTLD_NOLOAD`;/// [`os::windows::Library::open_already_loaded`]: crate::os::windows::Library::open_already_loaded/// [`os::unix::Library::open`]: crate::os::unix::Library::openr0_6_6/// Release 0.6.6 (2020-12-03)/// * Fix a double-release of resources when [`Library::close`] or [`os::windows::Library::close`]///   is used on Windows./// [`Library::close`]: crate::Library::close/// [`os::windows::Library::close`]: crate::os::windows::Library::closer0_6_5/// Release 0.6.5 (2020-10-23)/// * Upgrade cfg-if 0.1 to 1.0r0_6_4/// Release 0.6.4 (2020-10-10)/// * Remove use of `build.rs` making it easier to build `libloading` without cargo. It also///   almost halves the build time of this crate.r0_6_3/// Release 0.6.3 (2020-08-22)/// * Improve documentation, allowing to view all of the os-specific functionality from/// documentation generated for any target;/// * Add [`os::windows::Library::this`];/// * Added constants to use with OS-specific `Library::open`;/// * Add [`library_filename`]./// [`os::windows::Library::this`]: crate::os::windows::Library::this/// [`library_filename`]: crate::library_filenamer0_6_2/// Release 0.6.2 (2020-05-06)/// * Fixed building of this library on Illumos.r0_6_1/// Release 0.6.1 (2020-04-15)/// * Introduced a new method [`os::windows::Library::load_with_flags`];/// * Added support for the Illumos triple.r0_6_0/// Release 0.6.0 (2020-04-05)/// * Introduced a new method [`os::unix::Library::get_singlethreaded`];/// * Added (untested) support for building when targeting Redox and Fuchsia;/// * The APIs exposed by this library no longer panic and instead return an `Err` when it used///   to panic./// * Minimum required (stable) version of Rust to build this library is now 1.40.0;/// * This crate now implements a custom [`Error`] type and all APIs now return this type rather///   than returning the `std::io::Error`;/// * `libloading::Result` has been removed;/// * Removed the dependency on the C compiler to build this library on UNIX-like platforms.///   `libloading` used to utilize a snippet written in C to work-around the unlikely possibility///   of the target having a thread-unsafe implementation of the `dlerror` function. The effect of///   the work-around was very opportunistic: it would not work if the function was called by///   forgoing `libloading`.///   Starting with 0.6.0, [`Library::get`] on platforms where `dlerror` is not MT-safe (such as///   FreeBSD, DragonflyBSD or NetBSD) will unconditionally return an error when the underlying///   `dlsym` returns a null pointer. For the use-cases where loading null pointers is necessary///   consider using [`os::unix::Library::get_singlethreaded`] instead./// [`Library::get`]: crate::Library::get/// [`os::unix::Library::get_singlethreaded`]: crate::os::unix::Library::get_singlethreaded/// [`Error`]: crate::Errorr0_5_2/// Release 0.5.2 (2019-07-07)/// * Added API to convert OS-specific `Library` and `Symbol` conversion to underlying resources.r0_5_1/// Release 0.5.1 (2019-06-01)/// * Build on Haiku targets.r0_5_0/// Release 0.5.0 (2018-01-11)/// * Update to `winapi = ^0.3`;/// * libloading now requires a C compiler to build on UNIX;///   * This is a temporary measure until the [`linkage`] attribute is stabilised;///   * Necessary to resolve [#32]./// [`linkage`]: https://github.com/rust-lang/rust/issues/29603/// [#32]: https://github.com/nagisa/rust_libloading/issues/32r0_4_3/// Release 0.4.3 (2017-12-07)/// * Bump lazy-static dependency to `^1.0`;/// * `cargo test --release` now works when testing libloading.r0_4_2/// Release 0.4.2 (2017-09-24)/// * Improved error and race-condition handling on Windows;/// * Improved documentation about thread-safety of Library;/// * Added `Symbol::<Option<T>::lift_option() -> Option<Symbol<T>>` convenience method.r0_4_1/// Release 0.4.1 (2017-08-29)/// * Solaris supportr0_4_0/// Release 0.4.0 (2017-05-01)/// * Remove build-time dependency on target_build_utils (and by extension serde/phf);/// * Require at least version 1.14.0 of rustc to build;///   * Actually, it is cargo which has to be more recent here. The one shipped with rustc 1.14.0///     is what’s being required from now on.r0_3_4/// Release 0.3.4 (2017-03-25)/// * Remove rogue println!r0_3_3/// Release 0.3.3 (2017-03-25)/// * Panics when `Library::get` is called for incompatibly sized type such as named function///   types (which are zero-sized).r0_3_2/// Release 0.3.2 (2017-02-10)/// * Minimum version required is now rustc 1.12.0;/// * Updated dependency versions (most notably target_build_utils to 0.3.0)r0_3_1/// Release 0.3.1 (2016-10-01)/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Send` where `T: Send`;/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Sync` where `T: Sync`;/// * `Library` and `os::*::Library` now implement `Sync` (they were `Send` in 0.3.0 already).r0_3_0/// Release 0.3.0 (2016-07-27)/// * Greatly improved documentation, especially around platform-specific behaviours;/// * Improved test suite by building our own library to test against;/// * All `Library`-ies now implement `Send`./// * Added `impl From<os::platform::Library> for Library` and `impl From<Library> for/// os::platform::Library` allowing wrapping and extracting the platform-specific library handle;/// * Added methods to wrap (`Symbol::from_raw`) and unwrap (`Symbol::into_raw`) the safe `Symbol`/// wrapper into unsafe `os::platform::Symbol`./// The last two additions focus on not restricting potential usecases of this library, allowing/// users of the library to circumvent safety checks if need be./// ## Breaking Changes/// `Library::new` defaults to `RTLD_NOW` instead of `RTLD_LAZY` on UNIX for more consistent/// cross-platform behaviour. If a library loaded with `Library::new` had any linking errors, but/// unresolved references weren’t forced to be resolved, the library would’ve “just worked”,/// whereas now the call to `Library::new` will return an error signifying presence of such error./// ## os::platform/// * Added `os::unix::Library::open` which allows specifying arbitrary flags (e.g. `RTLD_LAZY`);/// * Added `os::windows::Library::get_ordinal` which allows finding a function or variable by its/// ordinal number;//! The change log.DlDescription/// A `dlerror` error./// A Windows API error./// The source error.DlOpen/// The `dlopen` call failed.DlOpenUnknown/// The `dlopen` call failed and system did not report an error.DlSym/// The `dlsym` call failed.DlSymUnknown/// The `dlsym` call failed and system did not report an error.DlClose/// The `dlclose` call failed.DlCloseUnknown/// The `dlclose` call failed and system did not report an error.LoadLibraryExW/// The `LoadLibraryW` call failed.LoadLibraryExWUnknown/// The `LoadLibraryW` call failed and system did not report an error./// The `GetModuleHandleExW` call failed.GetModuleHandleExWUnknown/// The `GetModuleHandleExW` call failed and system did not report an error./// The `GetProcAddress` call failed.GetProcAddressUnknown/// The `GetProcAddressUnknown` call failed and system did not report an error./// The `FreeLibrary` call failed.FreeLibraryUnknown/// The `FreeLibrary` call failed and system did not report an error.IncompatibleSize/// The requested type cannot possibly work.CreateCString/// Could not create a new CString.FromBytesWithNulErrorCreateCStringWithTrailing/// Could not create a new CString from bytes with trailing null./// Errors.changelogDLL_PREFIXDLL_SUFFIXlibrary_filename/// Converts a library name to a filename generally appropriate for use on the system./// This function will prepend prefixes (such as `lib`) and suffixes (such as `.so`) to the library/// `name` to construct the filename./// It can be used to load global libraries in a platform independent manner:/// use libloading::{Library, library_filename};/// // Will attempt to load `libLLVM.so` on Linux, `libLLVM.dylib` on macOS and `LLVM.dll` on/// // Windows./// let library = unsafe {///     Library::new(library_filename("LLVM"))//! Bindings around the platform's dynamic library loading primitives with greatly improved memory safety.//! Using this library allows the loading of [dynamic libraries](struct.Library.html), also known as//! shared libraries, and the use of the functions and static variables they contain.//! The `libloading` crate exposes a cross-platform interface to load a library and make use of its//! contents, but little is done to hide the differences in behaviour between platforms.//! The API documentation strives to document such differences as much as possible.//! Platform-specific APIs are also available in the [`os`](crate::os) module. These APIs are more//! flexible, but less safe.//! Add the `libloading` library to your dependencies in `Cargo.toml`://! libloading = "0.7"//! In your code, run the following://! fn call_dynamic() -> Result<u32, Box<dyn std::error::Error>> {//!         let lib = libloading::Library::new("/path/to/liblibrary.so")?;//!         let func: libloading::Symbol<unsafe extern fn() -> u32> = lib.get(b"my_func")?;//!         Ok(func())//! The compiler will ensure that the loaded function will not outlive the `Library` from which it comes,//! preventing the most common memory-safety issues./// UNIX implementation of dynamic library loading.//! Unsafe but flexible platform-specific bindings to dynamic library loading facilities.//! These modules expose more extensive and powerful bindings to the dynamic//! library loading facilities. Use of these bindings come at the cost of less (in most cases,//! none at all) safety guarantees, which are provided by the top-level bindings.//! Using these modules will likely involve conditional compilation://! # extern crate libloading;//! #[cfg(unix)]//! use libloading::os::unix::*;//! #[cfg(windows)]//! use libloading::os::windows::*;/// Perform lazy binding./// Relocations shall be performed at an implementation-defined time, ranging from the time/// of the [`Library::open`] call until the first reference to a given symbol occurs./// Specifying `RTLD_LAZY` should improve performance on implementations supporting dynamic/// symbol binding since a process might not reference all of the symbols in an executable/// object file. And, for systems supporting dynamic symbol resolution for normal process/// execution, this behaviour mimics the normal handling of process execution./// Conflicts with [`RTLD_NOW`]./// [`Library::open`]: crate::os::unix::Library::open/// Perform eager binding./// All necessary relocations shall be performed when the executable object file is first/// loaded. This may waste some processing if relocations are performed for symbols/// that are never referenced. This behaviour may be useful for applications that need to/// know that all symbols referenced during execution will be available before/// [`Library::open`] returns./// Conflicts with [`RTLD_LAZY`]./// Make loaded symbols available for resolution globally./// The executable object file's symbols shall be made available for relocation processing of any/// other executable object file. In addition, calls to [`Library::get`] on `Library` obtained from/// [`Library::this`] allows executable object files loaded with this mode to be searched./// [`Library::this`]: crate::os::unix::Library::this/// [`Library::get`]: crate::os::unix::Library::get/// Load symbols into an isolated namespace./// The executable object file's symbols shall not be made available for relocation processing of/// any other executable object file. This mode of operation is most appropriate for e.g. plugins.posix// Other constants that exist but are not bound because they are platform-specific (non-posix)// extensions. Some of these constants are only relevant to `dlsym` or `dlmopen` calls.// RTLD_CONFGEN// RTLD_DEFAULT// RTLD_DI_CONFIGADDR// RTLD_DI_LINKMAP// RTLD_DI_LMID// RTLD_DI_ORIGIN// RTLD_DI_PROFILENAME// RTLD_DI_PROFILEOUT// RTLD_DI_SERINFO// RTLD_DI_SERINFOSIZE// RTLD_DI_TLS_DATA// RTLD_DI_TLS_MODID// RTLD_FIRST// RTLD_GROUP// RTLD_NEXT// RTLD_PARENT// RTLD_PROBE// RTLD_SELF// RTLD_WORLD// RTLD_NODELETE// RTLD_NOLOAD// RTLD_DEEPBINDunix_importscstr_cow_from_bytesensure_compatible_typeswith_dlerror// dl* family of functions did not have enough thought put into it.// Whole error handling scheme is done via setting and querying some global state, therefore it is// not safe to use dynamic library loading in MT-capable environment at all. Only in POSIX 2008+TC1// a thread-local state was allowed for `dlerror`, making the dl* family of functions MT-safe.// In practice (as of 2020-04-01) most of the widely used targets use a thread-local for error// state and have been doing so for a long time. Regardless the comments in this function shall// remain as a documentation for the future generations./// A platform-specific counterpart of the cross-platform [`Library`](crate::Library).// That being said... this section in the volume 2 of POSIX.1-2008 states:// > All functions defined by this volume of POSIX.1-2008 shall be thread-safe, except that the// > following functions need not be thread-safe.// With notable absence of any dl* function other than dlerror in the list. By “this volume”// I suppose they refer precisely to the “volume 2”. dl* family of functions are specified// by this same volume, so the conclusion is indeed that dl* functions are required by POSIX// to be thread-safe. Great!// See for more details://  * https://github.com/nagisa/rust_libloading/pull/17//  * http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_09_01/// Find and eagerly load a shared library (module)./// If the `filename` contains a [path separator], the `filename` is interpreted as a `path` to/// a file. Otherwise, platform-specific algorithms are employed to find a library with a/// matching file name./// This is equivalent to <code>[Library::open](filename, [RTLD_LAZY] | [RTLD_LOCAL])</code>./// [path separator]: std::path::MAIN_SEPARATOR/// When a library is loaded, initialisation routines contained within the library are executed./// For the purposes of safety, the execution of these routines is conceptually the same calling an/// unknown foreign function and may impose arbitrary requirements on the caller for the call/// to be sound./// Additionally, the callers of this function must also ensure that execution of the/// termination routines contained within the library is safe as well. These routines may be/// executed when the library is unloaded./// Load the `Library` representing the current executable./// [`Library::get`] calls of the returned `Library` will look for symbols in following/// locations in order:/// 1. The original program image;/// 2. Any executable object files (e.g. shared libraries) loaded at program startup;/// 3. Any executable object files loaded at runtime (e.g. via other `Library::new` calls or via///    calls to the `dlopen` function)./// Note that the behaviour of a `Library` loaded with this method is different from that of/// Libraries loaded with [`os::windows::Library::this`]./// This is equivalent to <code>[Library::open](None, [RTLD_LAZY] | [RTLD_LOCAL])</code>./// Find and load an executable object file (shared library)./// See documentation for [`Library::this`] for further description of the behaviour/// when the `filename` is `None`. Otherwise see [`Library::new`]./// Corresponds to `dlopen(filename, flags)`./// Get a pointer to a function or static variable by symbol name./// The `symbol` may not contain any null bytes, with the exception of the last byte. Providing a/// null terminated `symbol` may help to avoid an allocation./// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are/// most likely invalid./// Users of this API must specify the correct type of the function or variable loaded. Using a/// `Symbol` with a wrong type is undefined./// # Platform-specific behaviour/// Implementation of thread local variables is extremely platform specific and uses of such/// variables that work on e.g. Linux may have unintended behaviour on other targets./// On POSIX implementations where the `dlerror` function is not confirmed to be MT-safe (such/// as FreeBSD), this function will unconditionally return an error when the underlying `dlsym`/// call returns a null pointer. There are rare situations where `dlsym` returns a genuine null/// pointer without it being an error. If loading a null pointer is something you care about,/// consider using the [`Library::get_singlethreaded`] call.get_singlethreaded/// Get a pointer to function or static variable by symbol name./// Users of this API must specify the correct type of the function or variable loaded./// It is up to the user of this library to ensure that no other calls to an MT-unsafe/// implementation of `dlerror` occur during the execution of this function. Failing that, the/// behaviour of this function is not defined./// The implementation of thread-local variables is extremely platform specific and uses of such/// Convert the `Library` to a raw handle./// The handle returned by this function shall be usable with APIs which accept handles/// as returned by `dlopen`./// Convert a raw handle returned by `dlopen`-family of calls to a `Library`./// The pointer shall be a result of a successful call of the `dlopen`-family of functions or a/// pointer previously returned by `Library::into_raw` call. It must be valid to call `dlclose`/// with this pointer as an argument./// Unload the library./// This method might be a no-op, depending on the flags with which the `Library` was opened,/// what library was opened or other platform specifics./// You only need to call this if you are interested in handling any errors that may arise when/// library is unloaded. Otherwise the implementation of `Drop` for `Library` will close the/// library and ignore the errors were they arise./// The underlying data structures may still get leaked if an error does occur./// Symbol from a library./// A major difference compared to the cross-platform `Symbol` is that this does not ensure that the/// `Symbol` does not outlive the `Library` it comes from./// Convert the loaded `Symbol` into a raw pointer.lift_option/// Lift Option out of the symbol.DlInfo// Platform specific thingsLOAD_IGNORE_CODE_AUTHZ_LEVELLOAD_LIBRARY_AS_DATAFILELOAD_LIBRARY_AS_DATAFILE_EXCLUSIVELOAD_LIBRARY_AS_IMAGE_RESOURCELOAD_LIBRARY_SEARCH_APPLICATION_DIRLOAD_LIBRARY_SEARCH_DEFAULT_DIRSLOAD_LIBRARY_SEARCH_DLL_LOAD_DIRLOAD_LIBRARY_SEARCH_SYSTEM32LOAD_LIBRARY_SEARCH_USER_DIRSLOAD_WITH_ALTERED_SEARCH_PATHLOAD_LIBRARY_REQUIRE_SIGNED_TARGETLOAD_LIBRARY_SAFE_CURRENT_DIRSwindows_imports// A hack for docs.rs to build documentation that has both windows and linux documentation in the// same rustdoc build visible.SEM_FAILCE/// The platform-specific counterpart of the cross-platform [`Library`](crate::Library).// Now, this is sort-of-tricky. MSDN documentation does not really make any claims as to safety of// the Win32 APIs. Sadly, whomever I asked, even current and former Microsoft employees, couldn’t// say for sure whether the Win32 APIs used to implement `Library` are thread-safe or not.// My investigation ended up with a question about thread-safety properties of the API involved// being sent to an internal (to MS) general question mailing-list. The conclusion of the mail is// as such:// * Nobody inside MS (at least out of all of the people who have seen the question) knows for//   sure either;// * However, the general consensus between MS developers is that one can rely on the API being//   thread-safe. In case it is not thread-safe it should be considered a bug on the Windows//   part. (NB: bugs filed at https://connect.microsoft.com/ against Windows Server)/// Find and load a module./// If the `filename` specifies a full path, the function only searches that path for the/// module. Otherwise, if the `filename` specifies a relative path or a module name without a/// path, the function uses a Windows-specific search strategy to find the module. For more/// information, see the [Remarks on MSDN][msdn]./// If the `filename` specifies a library filename without a path and with the extension omitted,/// the `.dll` extension is implicitly added. This behaviour may be suppressed by appending a/// trailing `.` to the `filename`./// This is equivalent to <code>[Library::load_with_flags](filename, 0)</code>./// [msdn]: https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryw#remarks/// Get the `Library` representing the original program executable./// Note that the behaviour of the `Library` loaded with this method is different from/// Libraries loaded with [`os::unix::Library::this`]. For more information refer to [MSDN]./// Corresponds to `GetModuleHandleExW(0, NULL, _)`./// [MSDN]: https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulehandleexwopen_already_loaded/// Get a module that is already loaded by the program./// This function returns a `Library` corresponding to a module with the given name that is/// already mapped into the address space of the process. If the module isn't found, an error is/// If the `filename` does not include a full path and there are multiple different loaded/// modules corresponding to the `filename`, it is impossible to predict which module handle/// will be returned. For more information refer to [MSDN]./// This is equivalent to `GetModuleHandleExW(0, filename, _)`.load_with_flags/// Find and load a module, additionally adjusting behaviour with flags./// See [`Library::new`] for documentation on the handling of the `filename` argument. See the/// [flag table on MSDN][flags] for information on applicable values for the `flags` argument./// Corresponds to `LoadLibraryExW(filename, reserved: NULL, flags)`./// [flags]: https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryexw#parameters/// The `symbol` may not contain any null bytes, with the exception of the last byte. A null/// terminated `symbol` may avoid a string allocation in some cases.get_ordinal/// Get a pointer to a function or static variable by ordinal number./// Convert a raw handle to a `Library`./// The handle must be the result of a successful call of `LoadLibraryA`, `LoadLibraryW`,/// `LoadLibraryExW`, or `LoadLibraryExA`, or a handle previously returned by the/// `Library::into_raw` call./// library is unloaded. Otherwise this will be done when `Library` is dropped./// A symbol from a library./// `Symbol` does not outlive the `Library` that it comes from./// Convert the loaded `Symbol` into a handle.with_get_last_error/// Do not check AppLocker rules or apply Software Restriction Policies for the DLL./// This action applies only to the DLL being loaded and not to its dependencies. This value is/// recommended for use in setup programs that must run extracted DLLs during installation./// See [flag documentation on MSDN](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryexw#parameters)./// Map the file into the calling process’ virtual address space as if it were a data file./// Nothing is done to execute or prepare to execute the mapped file. Therefore, you cannot call/// functions like [`Library::get`] with this DLL. Using this value causes writes to read-only/// memory to raise an access violation. Use this flag when you want to load a DLL only to extract/// messages or resources from it./// Similar to [`LOAD_LIBRARY_AS_DATAFILE`], except that the DLL file is opened with exclusive/// write access for the calling process. Other processes cannot open the DLL file for write access/// while it is in use. However, the DLL can still be opened by other processes./// Map the file into the process’ virtual address space as an image file./// The loader does not load the static imports or perform the other usual initialisation steps./// Use this flag when you want to load a DLL only to extract messages or resources from it./// Unless the application depends on the file having the in-memory layout of an image, this value/// should be used with either [`LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE`] or/// [`LOAD_LIBRARY_AS_DATAFILE`]./// Search the application's installation directory for the DLL and its dependencies./// Directories in the standard search path are not searched. This value cannot be combined with/// [`LOAD_WITH_ALTERED_SEARCH_PATH`]./// Search default directories when looking for the DLL and its dependencies./// This value is a combination of [`LOAD_LIBRARY_SEARCH_APPLICATION_DIR`],/// [`LOAD_LIBRARY_SEARCH_SYSTEM32`], and [`LOAD_LIBRARY_SEARCH_USER_DIRS`]. Directories in the/// standard search path are not searched. This value cannot be combined with/// Directory that contains the DLL is temporarily added to the beginning of the list of/// directories that are searched for the DLL’s dependencies./// Directories in the standard search path are not searched./// The `filename` parameter must specify a fully qualified path. This value cannot be combined/// with [`LOAD_WITH_ALTERED_SEARCH_PATH`]./// Search `%windows%\system32` for the DLL and its dependencies.///  Directories added using the `AddDllDirectory` or the `SetDllDirectory` function are searched///  for the DLL and its dependencies.///  If more than one directory has been added, the order in which the directories are searched is///  unspecified. Directories in the standard search path are not searched. This value cannot be///  combined with [`LOAD_WITH_ALTERED_SEARCH_PATH`]./// If `filename` specifies an absolute path, the system uses the alternate file search strategy/// discussed in the [Remarks section] to find associated executable modules that the specified/// module causes to be loaded./// If this value is used and `filename` specifies a relative path, the behaviour is undefined./// If this value is not used, or if `filename` does not specify a path, the system uses the/// standard search strategy discussed in the [Remarks section] to find associated executable/// modules that the specified module causes to be loaded./// [Remarks]: https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryexw#remarks/// Specifies that the digital signature of the binary image must be checked at load time./// Allow loading a DLL for execution from the current directory only if it is under a directory in/// the Safe load list.// the implementation used here doesn't matter particularly much.../// A loaded dynamic library./// Find and load a dynamic library./// The `filename` argument may be either:/// * A library filename;/// * The absolute path to the library;/// * A relative (to the current working directory) path to the library./// When a library is loaded, initialisation routines contained within it are executed./// # Thread-safety/// The implementation strives to be as MT-safe as sanely possible, however on certain/// platforms the underlying error-handling related APIs not always MT-safe. This library/// shares these limitations on those platforms. In particular, on certain UNIX targets/// `dlerror` is not MT-safe, resulting in garbage error messages in certain MT-scenarios./// Calling this function from multiple threads is not MT-safe if used in conjunction with/// library filenames and the library search path is modified (`SetDllDirectory` function on/// Windows, `{DY,}LD_LIBRARY_PATH` environment variable on UNIX)./// When a plain library filename is supplied, the locations in which the library is searched are/// platform specific and cannot be adjusted in a portable manner. See the documentation for/// the platform specific [`os::unix::Library::new`] and [`os::windows::Library::new`] methods/// for further information on library lookup behaviour./// the `.dll` extension is implicitly added on Windows./// # Tips/// Distributing your dynamic libraries under a filename common to all platforms (e.g./// `awesome.module`) allows you to avoid code which has to account for platform’s conventional/// library filenames./// Strive to specify an absolute or at least a relative path to your library, unless/// system-wide libraries are being loaded. Platform-dependent library search locations/// combined with various quirks related to path-less filenames may cause flakiness in/// programs./// # use ::libloading::Library;/// // Any of the following are valid.///     let _ = Library::new("/path/to/awesome.module").unwrap();///     let _ = Library::new("../awesome.module").unwrap();///     let _ = Library::new("libsomelib.so.1").unwrap();/// null-terminated `symbol` may help to avoid an allocation./// The symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are/// consider using the [`os::unix::Library::get_singlethreaded`] call./// Given a loaded library:/// let lib = unsafe {///     Library::new("/path/to/awesome.module").unwrap()/// Loading and using a function looks like this:/// # use ::libloading::{Library, Symbol};/// # let lib = unsafe {/// #     Library::new("/path/to/awesome.module").unwrap()///     let awesome_function: Symbol<unsafe extern fn(f64) -> f64> =///         lib.get(b"awesome_function\0").unwrap();///     awesome_function(0.42);/// A static variable may also be loaded and inspected:/// # let lib = unsafe { Library::new("/path/to/awesome.module").unwrap() };///     let awesome_variable: Symbol<*mut f64> = lib.get(b"awesome_variable\0").unwrap();///     **awesome_variable = 42.0;/// This type is a safeguard against using dynamically loaded symbols after a `Library` is/// unloaded. The primary method to create an instance of a `Symbol` is via [`Library::get`]./// The `Deref` trait implementation allows the use of `Symbol` as if it was a function or variable/// itself, without taking care to “extract” the function or variable manually most of the time./// [`Library::get`]: Library::get/// Extract the wrapped `os::platform::Symbol`./// Using this function relinquishes all the lifetime guarantees. It is up to the developer to/// ensure the resulting `Symbol` is not used past the lifetime of the `Library` this symbol/// was loaded from.///     let lib = Library::new("/path/to/awesome.module").unwrap();///     let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();///     let symbol = symbol.into_raw();/// Wrap the `os::platform::Symbol` into this safe wrapper./// Note that, in order to create association between the symbol and the library this symbol/// came from, this function requires a reference to the library./// The `library` reference must be exactly the library `sym` was loaded from.///     let symbol = Symbol::from_raw(symbol, &lib);///     let symbol: Symbol<Option<*mut u32>> = lib.get(b"symbol\0").unwrap();///     let symbol: Symbol<*mut u32> = symbol.lift_option().expect("static is not null");// FIXME: implement FnOnce for callable stuff instead."cdylib"TEST_STATIC_U32TEST_STATIC_PTRtest_identity_u32test_identity_structtest_get_static_u32test_check_static_ptr//! This is a separate file containing helpers for tests of this library. It is built into a//! dynamic library by the build.rs script./// Checks for the last byte and avoids allocating if it is zero./// Non-last null bytes still result in an error.r0_8_4/// Release 0.8.4 (2024-06-23)/// ## Non-breaking changes/// Compilation when targetting Apple's visionos, watchos and tvos targets has been fixed.r0_8_3/// Release 0.8.3 (2024-03-05)/// A `dev-dependency` on `windows-sys` that was unconditionally introduced in/// [0.8.2](r0_8_2) has been made conditional.r0_8_2/// Release 0.8.2 (2024-03-01)/// ## (Potentially) breaking changes/// MSRV has been increased to 1.56.0. Since both rustc versions are ancient, this has been deemed/// to not be breaking enough to warrant a semver-breaking release of libloading. If you're stick/// with a version of rustc older than 1.56.0, lock `libloading` dependency to `0.8.1`./// * The crate switches the dependency on `windows-sys` to a `windows-target` one for Windows///   bindings. In order to enable this `libloading` defines any bindings necessary for its operation///   internally, just like has been done for `unix` targets. This should result in leaner dependency///   trees./// * `os::unix::with_dlerror` has been exposed for the users who need to invoke `dl*` family of///   functions manually.r0_8_1/// Release 0.8.1 (2023-09-30)/// * Support for GNU Hurd.r0_8_0/// Release 0.8.0 (2023-04-11)/// * `winapi` dependency has been replaced with `windows-sys`./// * As a result the MSRV has been increased to 1.48./// * Support for the QNX Neutrino target has been added.///   must already be loaded. There is no portable equivalent for all UNIX targets. Users who do///   not care about portability across UNIX platforms may use [`os::unix::Library::open`] with///   `libc::RTLD_NOLOAD`;///   documentation generated for any target;///   os::platform::Library` allowing wrapping and extracting the platform-specific library handle;///   wrapper into unsafe `os::platform::Symbol`.///   ordinal number;//! libloading = "0.8"/// Run code and handle errors reported by `dlerror`./// This function first executes the `closure` function containing calls to the functions that/// report their errors via `dlerror`. This closure may return either `None` or `Some(*)` to/// further affect operation of this function./// In case the `closure` returns `None`, `with_dlerror` inspects the `dlerror`. `dlerror` may/// decide to not provide any error description, in which case `Err(None)` is returned to the/// caller. Otherwise the `error` callback is invoked to allow inspection and conversion of the/// error message. The conversion result is returned as `Err(Some(Error))`./// If the operations that report their errors via `dlerror` were all successful, `closure` should/// return `Some(T)` instead. In this case `dlerror` is not inspected at all./// The whole `dlerror` handling scheme is done via setting and querying some global state. For/// that reason it is not safe to use dynamic library loading in MT-capable environment at all./// Only in POSIX 2008+TC1 a thread-local state was allowed for `dlerror`, making the dl* family of/// functions possibly MT-safe, depending on the implementation of `dlerror`./// In practice (as of 2020-04-01) most of the widely used targets use a thread-local for error/// state and have been doing so for a long time.LOAD_LIBRARY_FLAGSSEM_FAILCRITICALERRORSNTESTS// Number of tests to generate for each functionIGNORED_FILES// These files are all internal functions or otherwise miscellaneous, not// defining a function we want to test.inputs/// A "poor man's" parser for the signature of a functiongenerate_random_testsgen_i64libc_tylibc_ptygenerate_test_outputsgenerate_unit_tests/// Codegens a file which has a ton of `#[test]` annotations for all the/// tests that we generated above.musl_reference_testslibm_helper_eqf/// Approximate equality with 1 ULP of tolerance_eq//! libm in pure Rust/// Generic helper for libm functions, abstracting over f32 and f64. <br/>/// # Type Parameter:/// - `T`: Either `f32` or `f64`/// use libm::{self, Libm};/// const PI_F32: f32 = 3.1415927410e+00;/// const PI_F64: f64 = 3.1415926535897931160e+00;/// assert!(Libm::<f32>::cos(0.0f32) == libm::cosf(0.0));/// assert!(Libm::<f32>::sin(PI_F32) == libm::sinf(PI_F32));/// assert!(Libm::<f64>::cos(0.0f64) == libm::cos(0.0));/// assert!(Libm::<f64>::sin(PI_F64) == libm::sin(PI_F64));erferfcexp10expm1fdimfmafmaxfmodilogbj0j1jnldexplgamma_rlgammalog1pmodfnextafterremquorintsincostgammaynPIO2_HIPIO2_LO/* 0x3FF921FB, 0x54442D18 */PS0/* 0x3C91A626, 0x33145C07 */PS1/* 0x3FC55555, 0x55555555 */PS2/* 0xBFD4D612, 0x03EB6F7D */PS3/* 0x3FC9C155, 0x0E884455 */PS4/* 0xBFA48228, 0xB5688F3B */PS5/* 0x3F49EFE0, 0x7501B288 */QS1/* 0x3F023DE1, 0x0DFDF709 */QS2/* 0xC0033A27, 0x1C8A2D4B */QS3/* 0x40002AE5, 0x9C598AC8 */QS4/* 0xBFE6066C, 0x1B8D0159 *//// Arccosine (f64)/// Computes the inverse cosine (arc cosine) of the input value./// Arguments must be in the range -1 to 1./// Returns values in radians, in the range of 0 to pi./* origin: FreeBSD /usr/src/lib/msun/src/e_acos.c *//*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunSoft, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 *//* acos(x)
 * Method :
 *      acos(x)  = pi/2 - asin(x)
 *      acos(-x) = pi/2 + asin(x)
 * For |x|<=0.5
 *      acos(x) = pi/2 - (x + x*x^2*R(x^2))     (see asin.c)
 * For x>0.5
 *      acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2)))
 *              = 2asin(sqrt((1-x)/2))
 *              = 2s + 2s*z*R(z)        ...z=(1-x)/2, s=sqrt(z)
 *              = 2f + (2c + 2s*z*R(z))
 *     where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term
 *     for f so that f+c ~ sqrt(z).
 * For x<-0.5
 *      acos(x) = pi - 2asin(sqrt((1-|x|)/2))
 *              = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z)
 *
 * Special cases:
 *      if x is NaN, return x itself;
 *      if |x|>1, return NaN with invalid signal.
 *
 * Function needed: sqrt
 *//* 0x3FB3B8C5, 0xB12E9282 */sqrtf/* 0x3fc90fda */P_S0/* 0x33a22168 */P_S1P_S2Q_S1acosf/// Arccosine (f32)/* origin: FreeBSD /usr/src/lib/msun/src/e_acosf.c *//*
 * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
 *//*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunPro, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 */LN2/// Inverse hyperbolic cosine (f64)/// Calculates the inverse hyperbolic cosine of `x`./// Is defined as `log(x + sqrt(x*x-1))`./// `x` must be a number greater than or equal to 1./* 0x3fe62e42,  0xfefa39ef*/log1pflogfacoshf/// Inverse hyperbolic cosine (f32)get_high_wordget_low_wordwith_set_low_word/* coefficients for R(x^2) */P_S3P_S4P_S5Q_S2Q_S3Q_S4comp_r/// Arcsine (f64)/// Computes the inverse sine (arc sine) of the argument `x`./// Arguments to asin must be in the range -1 to 1./// Returns values in radians, in the range of -pi/2 to pi/2./* origin: FreeBSD /usr/src/lib/msun/src/e_asin.c *//* asin(x)
 * Method :
 *      Since  asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...
 *      we approximate asin(x) on [0,0.5] by
 *              asin(x) = x + x*x^2*R(x^2)
 *      where
 *              R(x^2) is a rational approximation of (asin(x)-x)/x^3
 *      and its remez error is bounded by
 *              |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75)
 *
 *      For x in [0.5,1]
 *              asin(x) = pi/2-2*asin(sqrt((1-x)/2))
 *      Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2;
 *      then for x>0.98
 *              asin(x) = pi/2 - 2*(s+s*z*R(z))
 *                      = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo)
 *      For x<=0.98, let pio4_hi = pio2_hi/2, then
 *              f = hi part of s;
 *              c = sqrt(z) - f = (z-f*f)/(s+f)         ...f+c=sqrt(z)
 *      and
 *              asin(x) = pi/2 - 2*(s+s*z*R(z))
 *                      = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo)
 *                      = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c))
 *
 * Special cases:
 *      if x is NaN, return x itself;
 *      if |x|>1, return NaN with invalid signal.
 *
 */fabsfPIO2asinf/// Arcsine (f32)/* origin: FreeBSD /usr/src/lib/msun/src/e_asinf.c *//* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) *//// Inverse hyperbolic sine (f64)/// Calculates the inverse hyperbolic sine of `x`./// Is defined as `sgn(x)*log(|x|+sqrt(x*x+1))`.asinhf/// Inverse hyperbolic sine (f32)ATANHIATANLO/// Arctangent (f64)/// Computes the inverse tangent (arc tangent) of the input value./// Returns a value in radians, in the range of -pi/2 to pi/2.sanity_checkminus_infinity/* origin: FreeBSD /usr/src/lib/msun/src/s_atan.c *//* atan(x)
 * Method
 *   1. Reduce x to positive by atan(x) = -atan(-x).
 *   2. According to the integer k=4t+0.25 chopped, t=x, the argument
 *      is further reduced to one of the following intervals and the
 *      arctangent of t is evaluated by the corresponding formula:
 *
 *      [0,7/16]      atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...)
 *      [7/16,11/16]  atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) )
 *      [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) )
 *      [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) )
 *      [39/16,INF]   atan(x) = atan(INF) + atan( -1/t )
 *
 * Constants:
 * The hexadecimal values are the intended ones for the following
 * constants. The decimal values may be used, provided that the
 * compiler will convert from decimal to binary accurately enough
 * to produce the hexadecimal values shown.
 */PI_LO/* 0x400921FB, 0x54442D18 *//// Arctangent of y/x (f64)/// Computes the inverse tangent (arc tangent) of `y/x`./// Produces the correct result even for angles near pi/2 or -pi/2 (that is, when `x` is near 0)./// Returns a value in radians, in the range of -pi to pi./* origin: FreeBSD /usr/src/lib/msun/src/e_atan2.c *//*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunSoft, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 *
 *//* atan2(y,x)
 * Method :
 *      1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).
 *      2. Reduce x to positive by (if x and y are unexceptional):
 *              ARG (x+iy) = arctan(y/x)           ... if x > 0,
 *              ARG (x+iy) = pi - arctan[y/(-x)]   ... if x < 0,
 *
 * Special cases:
 *
 *      ATAN2((anything), NaN ) is NaN;
 *      ATAN2(NAN , (anything) ) is NaN;
 *      ATAN2(+-0, +(anything but NaN)) is +-0  ;
 *      ATAN2(+-0, -(anything but NaN)) is +-pi ;
 *      ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;
 *      ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;
 *      ATAN2(+-(anything but INF and NaN), -INF) is +-pi;
 *      ATAN2(+-INF,+INF ) is +-pi/4 ;
 *      ATAN2(+-INF,-INF ) is +-3pi/4;
 *      ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;
 *
 * Constants:
 * The hexadecimal values are the intended ones for the following
 * constants. The decimal values may be used, provided that the
 * compiler will convert from decimal to binary accurately enough
 * to produce the hexadecimal values shown.
 *//* 0x3CA1A626, 0x33145C07 */atanf/* 0x40490fdb */atan2f/// Arctangent of y/x (f32)/* origin: FreeBSD /usr/src/lib/msun/src/e_atan2f.c *//* 0xb3bbbd2e */ATAN_HIATAN_LOA_T/// Arctangent (f32)/* origin: FreeBSD /usr/src/lib/msun/src/s_atanf.c *//* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) *//// Inverse hyperbolic tangent (f64)/// Calculates the inverse hyperbolic tangent of `x`./// Is defined as `log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2`.atanhf/// Inverse hyperbolic tangent (f32)/* B1 = (1023-1023/3-0.03306235651)*2**20 *//* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). *//* 0x3ffe03e6, 0x0f61e692 *//* 0xbffe28e0, 0x92f02420 *//* 0x3ff9f160, 0x4a49d6c2 *//* 0xbfe844cb, 0xbee751d9 */// Cube root (f64)/// Computes the cube root of the argument./* origin: FreeBSD /usr/src/lib/msun/src/s_cbrt.c *//*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunPro, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 *
 * Optimized by Bruce D. Evans.
 *//* cbrt(x)
 * Return cube root of x
 *//* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 *//* 0x3fc2b000, 0xd4e4edd7 *//* B1 = (127-127.0/3-0.03306235651)*2**23 */cbrtf/// Cube root (f32)/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrtf.c *//*
 * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
 * Debugged and optimized by Bruce D. Evans.
 *//* cbrtf(x)
 * Return cube root of x
 *//* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */TOINT/// Ceil (f64)/// Finds the nearest integer greater than or equal to `x`.spec_tests/// The spec: https://en.cppreference.com/w/cpp/numeric/math/ceil/// Ceil (f32)// PowerPC tests are failing on LLVM 13: https://github.com/rust-lang/rust/issues/88520/// Sign of Y, magnitude of X (f64)/// Constructs a number with the magnitude (absolute value) of its/// first argument, `x`, and the sign of its second argument, `y`.copysignf/// Sign of Y, magnitude of X (f32)k_cosk_sinrem_pio2// cos(x)// Return cosine function of x.// kernel function://      k_sin           ... sine function on [-pi/4,pi/4]//      k_cos           ... cosine function on [-pi/4,pi/4]//      rem_pio2        ... argument reduction routine// Method.//      Let S,C and T denote the sin, cos and tan respectively on//      [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2//      in [-pi/4 , +pi/4], and let n = k mod 4.//      We have//          n        sin(x)      cos(x)        tan(x)//     ----------------------------------------------------------//          0          S           C             T//          1          C          -S            -1/T//          2         -S          -C             T//          3         -C           S            -1/T// Special cases://      Let trig be any of sin, cos, or tan.//      trig(+-INF)  is NaN, with signals;//      trig(NaN)    is that NaN;// Accuracy://      TRIG(x) returns trig(x) nearly rounded// origin: FreeBSD /usr/src/lib/msun/src/s_cos.c */// ====================================================// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.// Developed at SunPro, a Sun Microsystems, Inc. business.// Permission to use, copy, modify, and distribute this// software is freely granted, provided that this notice// is preserved.k_cosfk_sinfrem_pio2fC1_PIO2/* Small multiples of pi/2 rounded to double precision. */C2_PIO2C3_PIO2C4_PIO2/* 0x4012D97C, 0x7F3321D2 */cosf/* origin: FreeBSD /usr/src/lib/msun/src/s_cosf.c *//*
 * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
 * Optimized by Bruce D. Evans.
 *//* 0x401921FB, 0x54442D18 */k_expo2/// Hyperbolic cosine (f64)/// Computes the hyperbolic cosine of the argument x./// Is defined as `(exp(x) + exp(-x))/2`/// Angles are specified in radians.expfexpm1fk_expo2fcoshfERXEFX8/* 0x3FEB0AC1, 0x60000000 *//*
 * Coefficients for approximation to  erf on [0,0.84375]
 */PP0/* 0x3FF06EBA, 0x8214DB69 */PP1/* 0x3FC06EBA, 0x8214DB68 */PP2/* 0xBFD4CD7D, 0x691CB913 */PP3/* 0xBF9D2A51, 0xDBD7194F */PP4/* 0xBF77A291, 0x236668E4 */QQ1/* 0xBEF8EAD6, 0x120016AC */QQ2/* 0x3FD97779, 0xCDDADC09 */QQ3/* 0x3FB0A54C, 0x5536CEBA */QQ4/* 0x3F74D022, 0xC4D36B0F */QQ5/* 0x3F215DC9, 0x221C1A10 */PA0/* 0xBED09C43, 0x42A26120 *//*
 * Coefficients for approximation to  erf  in [0.84375,1.25]
 */PA1/* 0xBF6359B8, 0xBEF77538 */PA2/* 0x3FDA8D00, 0xAD92B34D */PA3/* 0xBFD7D240, 0xFBB8C3F1 */PA4/* 0x3FD45FCA, 0x805120E4 */PA5/* 0xBFBC6398, 0x3D3E28EC */PA6/* 0x3FA22A36, 0x599795EB */QA1/* 0xBF61BF38, 0x0A96073F */QA2/* 0x3FBB3E66, 0x18EEE323 */QA3/* 0x3FE14AF0, 0x92EB6F33 */QA4/* 0x3FB2635C, 0xD99FE9A7 */QA5/* 0x3FC02660, 0xE763351F */QA6/* 0x3F8BEDC2, 0x6B51DD1C */RA0/* 0x3F888B54, 0x5735151D *//*
 * Coefficients for approximation to  erfc in [1.25,1/0.35]
 */RA1/* 0xBF843412, 0x600D6435 */RA2/* 0xBFE63416, 0xE4BA7360 */RA3/* 0xC0251E04, 0x41B0E726 */RA4/* 0xC04F300A, 0xE4CBA38D */RA5/* 0xC0644CB1, 0x84282266 */RA6/* 0xC067135C, 0xEBCCABB2 */RA7/* 0xC0545265, 0x57E4D2F2 */SA1/* 0xC023A0EF, 0xC69AC25C */SA2/* 0x4033A6B9, 0xBD707687 */SA3/* 0x4061350C, 0x526AE721 */SA4/* 0x407B290D, 0xD58A1A71 */SA5/* 0x40842B19, 0x21EC2868 */SA6/* 0x407AD021, 0x57700314 */SA7/* 0x405B28A3, 0xEE48AE2C */SA8/* 0x401A47EF, 0x8E484A93 */RB0/* 0xBFAEEFF2, 0xEE749A62 *//*
 * Coefficients for approximation to  erfc in [1/.35,28]
 */RB1/* 0xBF843412, 0x39E86F4A */RB2/* 0xBFE993BA, 0x70C285DE */RB3/* 0xC031C209, 0x555F995A */RB4/* 0xC064145D, 0x43C5ED98 */RB5/* 0xC083EC88, 0x1375F228 */RB6/* 0xC0900461, 0x6A2E5992 */SB1/* 0xC07E384E, 0x9BDC383F */SB2/* 0x403E568B, 0x261D5190 */SB3/* 0x40745CAE, 0x221B9F0A */SB4/* 0x409802EB, 0x189D5118 */SB5/* 0x40A8FFB7, 0x688C246A */SB6/* 0x40A3F219, 0xCEDF3BE6 */SB7/* 0x407DA874, 0xE79FE763 */erfc1erfc2/// Error function (f64)/// Calculates an approximation to the “error function”, which estimates/// the probability that an observation will fall within x standard/// deviations of the mean (assuming a normal distribution)./// Complementary error function (f64)/// Calculates the complementary probability./// Is `1 - erf(x)`. Is computed directly, so that you can use it to avoid/// the loss of precision that would result from subtracting/// large probabilities (on large `x`) from 1./* origin: FreeBSD /usr/src/lib/msun/src/s_erf.c *//* double erf(double x)
 * double erfc(double x)
 *                           x
 *                    2      |\
 *     erf(x)  =  ---------  | exp(-t*t)dt
 *                 sqrt(pi) \|
 *                           0
 *
 *     erfc(x) =  1-erf(x)
 *  Note that
 *              erf(-x) = -erf(x)
 *              erfc(-x) = 2 - erfc(x)
 *
 * Method:
 *      1. For |x| in [0, 0.84375]
 *          erf(x)  = x + x*R(x^2)
 *          erfc(x) = 1 - erf(x)           if x in [-.84375,0.25]
 *                  = 0.5 + ((0.5-x)-x*R)  if x in [0.25,0.84375]
 *         where R = P/Q where P is an odd poly of degree 8 and
 *         Q is an odd poly of degree 10.
 *                                               -57.90
 *                      | R - (erf(x)-x)/x | <= 2
 *
 *
 *         Remark. The formula is derived by noting
 *          erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....)
 *         and that
 *          2/sqrt(pi) = 1.128379167095512573896158903121545171688
 *         is close to one. The interval is chosen because the fix
 *         point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is
 *         near 0.6174), and by some experiment, 0.84375 is chosen to
 *         guarantee the error is less than one ulp for erf.
 *
 *      2. For |x| in [0.84375,1.25], let s = |x| - 1, and
 *         c = 0.84506291151 rounded to single (24 bits)
 *              erf(x)  = sign(x) * (c  + P1(s)/Q1(s))
 *              erfc(x) = (1-c)  - P1(s)/Q1(s) if x > 0
 *                        1+(c+P1(s)/Q1(s))    if x < 0
 *              |P1/Q1 - (erf(|x|)-c)| <= 2**-59.06
 *         Remark: here we use the taylor series expansion at x=1.
 *              erf(1+s) = erf(1) + s*Poly(s)
 *                       = 0.845.. + P1(s)/Q1(s)
 *         That is, we use rational approximation to approximate
 *                      erf(1+s) - (c = (single)0.84506291151)
 *         Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
 *         where
 *              P1(s) = degree 6 poly in s
 *              Q1(s) = degree 6 poly in s
 *
 *      3. For x in [1.25,1/0.35(~2.857143)],
 *              erfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1)
 *              erf(x)  = 1 - erfc(x)
 *         where
 *              R1(z) = degree 7 poly in z, (z=1/x^2)
 *              S1(z) = degree 8 poly in z
 *
 *      4. For x in [1/0.35,28]
 *              erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0
 *                      = 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0
 *                      = 2.0 - tiny            (if x <= -6)
 *              erf(x)  = sign(x)*(1.0 - erfc(x)) if x < 6, else
 *              erf(x)  = sign(x)*(1.0 - tiny)
 *         where
 *              R2(z) = degree 6 poly in z, (z=1/x^2)
 *              S2(z) = degree 7 poly in z
 *
 *      Note1:
 *         To compute exp(-x*x-0.5625+R/S), let s be a single
 *         precision number and s := x; then
 *              -x*x = -s*s + (s-x)*(s+x)
 *              exp(-x*x-0.5626+R/S) =
 *                      exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S);
 *      Note2:
 *         Here 4 and 5 make use of the asymptotic series
 *                        exp(-x*x)
 *              erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) )
 *                        x*sqrt(pi)
 *         We use rational approximation to approximate
 *              g(s)=f(1/x^2) = log(erfc(x)*x) - x*x + 0.5625
 *         Here is the error bound for R1/S1 and R2/S2
 *              |R1/S1 - f(x)|  < 2**(-62.57)
 *              |R2/S2 - f(x)|  < 2**(-61.52)
 *
 *      5. For inf > x >= 28
 *              erf(x)  = sign(x) *(1 - tiny)  (raise inexact)
 *              erfc(x) = tiny*tiny (raise underflow) if x > 0
 *                      = 2 - tiny if x<0
 *
 *      7. Special case:
 *              erf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,
 *              erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,
 *              erfc/erf(NaN) is NaN
 *//* 0xC03670E2, 0x42712D62 *//* 0x3f58560b *//* 0x3f8375d4 *//* 0x3e0375d4 *//* 0xbea66beb *//* 0xbce9528f *//* 0xbbbd1489 *//* 0xb7c756b1 *//* 0x3ecbbbce *//* 0x3d852a63 *//* 0x3ba68116 *//* 0x390aee49 *//* 0xb684e21a *//* 0xbb1acdc6 *//* 0x3ed46805 *//* 0xbebe9208 *//* 0x3ea2fe54 *//* 0xbde31cc2 *//* 0x3d1151b3 *//* 0xbb0df9c0 *//* 0x3dd9f331 *//* 0x3f0a5785 *//* 0x3d931ae7 *//* 0x3e013307 *//* 0x3c5f6e13 *//* 0x3c445aa3 *//* 0xbc21a093 *//* 0xbf31a0b7 *//* 0xc128f022 *//* 0xc2798057 *//* 0xc322658c *//* 0xc3389ae7 *//* 0xc2a2932b *//* 0xc11d077e *//* 0x419d35ce *//* 0x4309a863 *//* 0x43d9486f *//* 0x442158c9 *//* 0x43d6810b *//* 0x42d9451f *//* 0x40d23f7c *//* 0xbd777f97 *//* 0xbc21a092 *//* 0xbf4c9dd4 *//* 0xc18e104b *//* 0xc320a2ea *//* 0xc41f6441 *//* 0xc480230b *//* 0xc3f1c275 *//* 0x41f2b459 *//* 0x43a2e571 *//* 0x44c01759 *//* 0x4547fdbb *//* 0x451f90ce *//* 0x43ed43a7 */erff/// Error function (f32)erfcf/// Complementary error function (f32)/* origin: FreeBSD /usr/src/lib/msun/src/s_erff.c *//* 0xc1b38712 */LN2HILN2LO/* 0x3fe62e42, 0xfee00000 */INVLN2/* 0x3dea39ef, 0x35793c76 *//* 0x3ff71547, 0x652b82fe *//* 0x3FC55555, 0x5555553E *//* 0xBF66C16C, 0x16BEBD93 *//* 0x3F11566A, 0xAF25DE2C *//* 0xBEBBBD41, 0xC5D26BF1 *//// Exponential, base *e* (f64)/// Calculate the exponential of `x`, that is, *e* raised to the power `x`/// (where *e* is the base of the natural system of logarithms, approximately 2.71828)./* origin: FreeBSD /usr/src/lib/msun/src/e_exp.c *//*
 * ====================================================
 * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 *//* exp(x)
 * Returns the exponential of x.
 *
 * Method
 *   1. Argument reduction:
 *      Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658.
 *      Given x, find r and integer k such that
 *
 *               x = k*ln2 + r,  |r| <= 0.5*ln2.
 *
 *      Here r will be represented as r = hi-lo for better
 *      accuracy.
 *
 *   2. Approximation of exp(r) by a special rational function on
 *      the interval [0,0.34658]:
 *      Write
 *          R(r**2) = r*(exp(r)+1)/(exp(r)-1) = 2 + r*r/6 - r**4/360 + ...
 *      We use a special Remez algorithm on [0,0.34658] to generate
 *      a polynomial of degree 5 to approximate R. The maximum error
 *      of this polynomial approximation is bounded by 2**-59. In
 *      other words,
 *          R(z) ~ 2.0 + P1*z + P2*z**2 + P3*z**3 + P4*z**4 + P5*z**5
 *      (where z=r*r, and the values of P1 to P5 are listed below)
 *      and
 *          |                  5          |     -59
 *          | 2.0+P1*z+...+P5*z   -  R(z) | <= 2
 *          |                             |
 *      The computation of exp(r) thus becomes
 *                              2*r
 *              exp(r) = 1 + ----------
 *                            R(r) - r
 *                                 r*c(r)
 *                     = 1 + r + ----------- (for better accuracy)
 *                                2 - c(r)
 *      where
 *                              2       4             10
 *              c(r) = r - (P1*r  + P2*r  + ... + P5*r   ).
 *
 *   3. Scale back to obtain exp(x):
 *      From step 1, we have
 *         exp(x) = 2^k * exp(r)
 *
 * Special cases:
 *      exp(INF) is INF, exp(NaN) is NaN;
 *      exp(-INF) is 0, and
 *      for finite argument, only exp(0)=1 is exact.
 *
 * Accuracy:
 *      according to an error analysis, the error is always less than
 *      1 ulp (unit in the last place).
 *
 * Misc. info.
 *      For IEEE double
 *          if x >  709.782712893383973096 then exp(x) overflows
 *          if x < -745.133219101941108420 then exp(x) underflows
 *//* 0x3E663769, 0x72BEA4D0 */LN10exp2fmodffLN10_F32LN10_F64exp10fTBLSIZETBL/// Exponential, base 2 (f64)/// Calculate `2^x`, that is, 2 raised to the power `x`.i0_wrap_test// origin: FreeBSD /usr/src/lib/msun/src/s_exp2.c *///-// Copyright (c) 2005 David Schultz <das@FreeBSD.ORG>// All rights reserved.// Redistribution and use in source and binary forms, with or without// modification, are permitted provided that the following conditions// are met:// 1. Redistributions of source code must retain the above copyright//    notice, this list of conditions and the following disclaimer.// 2. Redistributions in binary form must reproduce the above copyright//    notice, this list of conditions and the following disclaimer in the//    documentation and/or other materials provided with the distribution.// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF// SUCH DAMAGE.// exp2(x): compute the base 2 exponential of x// Accuracy: Peak error < 0.503 ulp for normalized results.// Method: (accurate tables)//   Reduce x://     x = k + y, for integer k and |y| <= 1/2.//     Thus we have exp2(x) = 2**k * exp2(y).//   Reduce y://     y = i/TBLSIZE + z - eps[i] for integer i near y * TBLSIZE.//     Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z - eps[i]),//     with |z - eps[i]| <= 2**-9 + 2**-39 for the table used.//   We compute exp2(i/TBLSIZE) via table lookup and exp2(z - eps[i]) via//   a degree-5 minimax polynomial with maximum error under 1.3 * 2**-61.//   The values in exp2t[] and eps[] are chosen such that//   exp2t[i] = exp2(i/TBLSIZE + eps[i]), and eps[i] is a small offset such//   that exp2t[i] is accurate to 2**-64.//   Note that the range of i is +-TBLSIZE/2, so we actually index the tables//   by i0 = i + TBLSIZE/2.  For cache efficiency, exp2t[] and eps[] are//   virtual tables, interleaved in the real table tbl[].//   This method is due to Gal, with many details due to Gal and Bachelis://      Gal, S. and Bachelis, B.  An Accurate Elementary Mathematical Library//      for the IEEE Floating Point Standard.  TOMS 17(1), 26-46 (1991).EXP2FT/// Exponential, base 2 (f32)// origin: FreeBSD /usr/src/lib/msun/src/s_exp2f.c// exp2f(x): compute the base 2 exponential of x// Accuracy: Peak error < 0.501 ulp; location of peak: -0.030110927.// Method: (equally-spaced tables)//     Thus we have exp2f(x) = 2**k * exp2(y).//     y = i/TBLSIZE + z for integer i near y * TBLSIZE.//     Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z),//     with |z| <= 2**-(TBLSIZE+1).//   We compute exp2(i/TBLSIZE) via table lookup and exp2(z) via a//   degree-4 minimax polynomial with maximum error under 1.4 * 2**-33.//   Using double precision for everything except the reduction makes//   roundoff error insignificant and simplifies the scaling step.//   This method is due to Tang, but I do not use his suggested parameters://      Tang, P.  Table-driven Implementation of the Exponential Function//      in IEEE Floating-Point Arithmetic.  TOMS 15(2), 144-157 (1989).scalbnfLN2_HILN2_LO/* 0x3f317200 */INV_LN2/* 0x35bfbe8e *//* 0x3fb8aa3b *//*
 * Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:
 * |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74
 *//*  0xaaaa8f.0p-26 *//// Exponential, base *e* (f32)/* origin: FreeBSD /usr/src/lib/msun/src/e_expf.c *//* -0xb55215.0p-32 */O_THRESHOLD/* 0x40862E42, 0xFEFA39EF */Q1/* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = x*x/2: */Q2/* BFA11111 111110F4 */Q3/* 3F5A01A0 19FE5585 */Q4/* BF14CE19 9EAADBB7 */Q5/* 3ED0CFCA 86E65239 *//// Exponential, base *e*, of x-1 (f64)/// Calculates the exponential of `x` and subtract 1, that is, *e* raised/// to the power `x` minus 1 (where *e* is the base of the natural/// system of logarithms, approximately 2.71828)./// The result is accurate even for small values of `x`,/// where using `exp(x)-1` would lose many significant digits./* origin: FreeBSD /usr/src/lib/msun/src/s_expm1.c *//* BE8AFDB7 6E09C32D *//* 0x42b17180 *//* 0x3f317180 *//* 0x3717f7d1 *//*
 * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]:
 * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04
 * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c):
 *//* -0x888868.0p-28 *//// Exponential, base *e*, of x-1 (f32)/* origin: FreeBSD /usr/src/lib/msun/src/s_expm1f.c *//*  0xcf3010.0p-33 */combine_wordsexpo2/* exp(x)/2 for x >= log(DBL_MAX), slightly better than 0.5*exp(x/2)*exp(x/2) *//// Absolute value (magnitude) (f64)/// Calculates the absolute value (magnitude) of the argument `x`,/// by direct manipulation of the bit representation of `x`./// The spec: https://en.cppreference.com/w/cpp/numeric/math/fabs/// Absolute value (magnitude) (f32)/// Positive difference (f64)/// Determines the positive difference between arguments, returning:/// * x - y	if x > y, or/// * +0	if x <= y, or/// * NAN	if either argument is NAN./// A range error may occur.fdimf/// Positive difference (f32)FE_UNDERFLOWFE_INEXACTFE_TONEARESTfeclearexceptferaiseexceptfetestexceptfegetround// src: musl/src/fenv/fenv.c/* Dummy functions for archs lacking fenv implementation *//// Floor (f64)/// Finds the nearest integer less than or equal to `x`./// The spec: https://en.cppreference.com/w/cpp/numeric/math/floorfloorf/// Floor (f32)ZEROINFNAN/// Floating multiply add (f64)/// Computes `(x*y)+z`, rounded as one ternary operation:/// Computes the value (as if) to infinite precision and rounds once to the result format,/// according to the rounding mode characterized by the value of FLT_ROUNDS.fma_segfaultfma_sbbfma_underflowfenvfmaf/// Floating multiply add (f32)issue_263/* origin: FreeBSD /usr/src/lib/msun/src/s_fmaf.c *//*-
 * Copyright (c) 2005-2011 David Schultz <das@FreeBSD.ORG>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *//*
 * Fused multiply-add: Compute x * y + z with a single rounding error.
 *
 * A double has more than twice as much precision than a float, so
 * direct double-precision arithmetic suffices, except where double
 * rounding occurs.
 */fmaxffminffmodffrexpfSPLITsq// 0x1p27 + 1 === (2 ^ 27) + 1hypotfFP_ILOGBNANFP_ILOGB0ilogbfINVSQRTPITPI/* 0x3FE20DD7, 0x50429B6D *//* common method when |x|>=2 */R02/* R0/S0 on [0, 2.00] */R03/* 0x3F8FFFFF, 0xFFFFFFFD */R04/* 0xBF28E6A5, 0xB61AC6E9 */R05/* 0x3EBEB1D1, 0x0C503919 */S01/* 0xBE33D5E7, 0x73D63FCE */S02/* 0x3F8FFCE8, 0x82C8C2A4 */S03/* 0x3F1EA6D2, 0xDD57DBF4 */S04/* 0x3EA13B54, 0xCE84D5A9 */U00U01/* 0xBFB2E4D6, 0x99CBD01F */U02/* 0x3FC69D01, 0x9DE9E3FC */U03/* 0xBF8C4CE8, 0xB16CFA97 */U04/* 0x3F36C54D, 0x20B29B6B */U05/* 0xBECFFEA7, 0x73D25CAD */U06/* 0x3E550057, 0x3B4EABD4 */V01/* 0xBDC5E43D, 0x693FB3C8 */V02/* 0x3F8A1270, 0x91C9C71A */V03/* 0x3F13ECBB, 0xF578C6C1 */V04/* 0x3E91642D, 0x7FF202FD */PR8/* The asymptotic expansions of pzero is
 *      1 - 9/128 s^2 + 11025/98304 s^4 - ...,  where s = 1/x.
 * For x >= 2, We approximate pzero by
 *      pzero(x) = 1 + (R/S)
 * where  R = pR0 + pR1*s^2 + pR2*s^4 + ... + pR5*s^10
 *        S = 1 + pS0*s^2 + ... + pS4*s^10
 * and
 *      | pzero(x)-1-R/S | <= 2  ** ( -60.26)
 */PS8PR5PR3PR2pzeroQR8/* For x >= 8, the asymptotic expansions of qzero is
 *      -1/8 s + 75/1024 s^3 - ..., where s = 1/x.
 * We approximate pzero by
 *      qzero(x) = s*(-1.25 + (R/S))
 * where  R = qR0 + qR1*s^2 + qR2*s^4 + ... + qR5*s^10
 *        S = 1 + qS0*s^2 + ... + qS5*s^12
 * and
 *      | qzero(x)/s +1.25-R/S | <= 2  ** ( -61.22)
 */QS8QR5QS5QR3QR2qzero/* origin: FreeBSD /usr/src/lib/msun/src/e_j0.c *//* j0(x), y0(x)
 * Bessel function of the first and second kinds of order zero.
 * Method -- j0(x):
 *      1. For tiny x, we use j0(x) = 1 - x^2/4 + x^4/64 - ...
 *      2. Reduce x to |x| since j0(x)=j0(-x),  and
 *         for x in (0,2)
 *              j0(x) = 1-z/4+ z^2*R0/S0,  where z = x*x;
 *         (precision:  |j0-1+z/4-z^2R0/S0 |<2**-63.67 )
 *         for x in (2,inf)
 *              j0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x0)-q0(x)*sin(x0))
 *         where x0 = x-pi/4. It is better to compute sin(x0),cos(x0)
 *         as follow:
 *              cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4)
 *                      = 1/sqrt(2) * (cos(x) + sin(x))
 *              sin(x0) = sin(x)cos(pi/4)-cos(x)sin(pi/4)
 *                      = 1/sqrt(2) * (sin(x) - cos(x))
 *         (To avoid cancellation, use
 *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
 *          to compute the worse one.)
 *
 *      3 Special cases
 *              j0(nan)= nan
 *              j0(0) = 1
 *              j0(inf) = 0
 *
 * Method -- y0(x):
 *      1. For x<2.
 *         Since
 *              y0(x) = 2/pi*(j0(x)*(ln(x/2)+Euler) + x^2/4 - ...)
 *         therefore y0(x)-2/pi*j0(x)*ln(x) is an even function.
 *         We use the following function to approximate y0,
 *              y0(x) = U(z)/V(z) + (2/pi)*(j0(x)*ln(x)), z= x^2
 *         where
 *              U(z) = u00 + u01*z + ... + u06*z^6
 *              V(z) = 1  + v01*z + ... + v04*z^4
 *         with absolute approximation error bounded by 2**-72.
 *         Note: For tiny x, U/V = u0 and j0(x)~1, hence
 *              y0(tiny) = u0 + (2/pi)*ln(tiny), (choose tiny<2**-27)
 *      2. For x>=2.
 *              y0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x0)+q0(x)*sin(x0))
 *         where x0 = x-pi/4. It is better to compute sin(x0),cos(x0)
 *         by the method mentioned above.
 *      3. Special cases: y0(0)=-inf, y0(x<0)=NaN, y0(inf)=0.
 *//* 0x3FE45F30, 0x6DC9C883 *//* 0x3E1408BC, 0xF4745D8F *//* 0x3DFE5018, 0x3BD6D9EF */sinf/* 0x3f106ebb *//* 0x3c800000 *//* 0xb947352e *//* 0x35f58e88 *//* 0xb19eaf3c *//* 0x3c7fe744 *//* 0x38f53697 *//* 0x3509daa6 */j0f/* 0xbd9726b5 *//* 0x3e34e80d *//* 0xbc626746 *//* 0x39b62a69 *//* 0xb67ff53c *//* 0x32a802ba *//* 0xae2f21eb *//* 0x3c509385 *//* 0x389f65e0 *//* 0x348b216c */y0fpzerofqzerof/* origin: FreeBSD /usr/src/lib/msun/src/e_j0f.c *//* 0x3f22f983 *//* 0x30a045e8 *//* 0x2ff280c2 */R00/* R0/S0 on [0,2] */R01/* 0xBFB00000, 0x00000000 *//* 0x3F570D9F, 0x98472C61 *//* 0xBEF0C5C6, 0xBA169668 *//* 0x3E6AAAFA, 0x46CA0BD9 *//* 0x3F939D0B, 0x12637E53 *//* 0x3F285F56, 0xB9CDF664 *//* 0x3EB3BFF8, 0x333F8498 */S05/* 0x3E35AC88, 0xC97DFF2C */poneqone/* origin: FreeBSD /usr/src/lib/msun/src/e_j1.c *//* j1(x), y1(x)
 * Bessel function of the first and second kinds of order zero.
 * Method -- j1(x):
 *      1. For tiny x, we use j1(x) = x/2 - x^3/16 + x^5/384 - ...
 *      2. Reduce x to |x| since j1(x)=-j1(-x),  and
 *         for x in (0,2)
 *              j1(x) = x/2 + x*z*R0/S0,  where z = x*x;
 *         (precision:  |j1/x - 1/2 - R0/S0 |<2**-61.51 )
 *         for x in (2,inf)
 *              j1(x) = sqrt(2/(pi*x))*(p1(x)*cos(x1)-q1(x)*sin(x1))
 *              y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x1)+q1(x)*cos(x1))
 *         where x1 = x-3*pi/4. It is better to compute sin(x1),cos(x1)
 *         as follow:
 *              cos(x1) =  cos(x)cos(3pi/4)+sin(x)sin(3pi/4)
 *                      =  1/sqrt(2) * (sin(x) - cos(x))
 *              sin(x1) =  sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
 *                      = -1/sqrt(2) * (sin(x) + cos(x))
 *         (To avoid cancellation, use
 *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
 *          to compute the worse one.)
 *
 *      3 Special cases
 *              j1(nan)= nan
 *              j1(0) = 0
 *              j1(inf) = 0
 *
 * Method -- y1(x):
 *      1. screen out x<=0 cases: y1(0)=-inf, y1(x<0)=NaN
 *      2. For x<2.
 *         Since
 *              y1(x) = 2/pi*(j1(x)*(ln(x/2)+Euler)-1/x-x/2+5/64*x^3-...)
 *         therefore y1(x)-2/pi*j1(x)*ln(x)-1/x is an odd function.
 *         We use the following function to approximate y1,
 *              y1(x) = x*U(z)/V(z) + (2/pi)*(j1(x)*ln(x)-1/x), z= x^2
 *         where for x in [0,2] (abs err less than 2**-65.89)
 *              U(z) = U0[0] + U0[1]*z + ... + U0[4]*z^4
 *              V(z) = 1  + v0[0]*z + ... + v0[4]*z^5
 *         Note: For tiny x, 1/x dominate y1 and hence
 *              y1(tiny) = -2/pi/tiny, (choose tiny<2**-54)
 *      3. For x>=2.
 *              y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x1)+q1(x)*cos(x1))
 *         where x1 = x-3*pi/4. It is better to compute sin(x1),cos(x1)
 *         by method mentioned above.
 *//* 0x3DAB2ACF, 0xCFB97ED8 *//* For x >= 8, the asymptotic expansions of pone is
 *      1 + 15/128 s^2 - 4725/2^15 s^4 - ...,   where s = 1/x.
 * We approximate pone by
 *      pone(x) = 1 + (R/S)
 * where  R = pr0 + pr1*s^2 + pr2*s^4 + ... + pr5*s^10
 *        S = 1 + ps0*s^2 + ... + ps4*s^10
 * and
 *      | pone(x)-1-R/S | <= 2  ** ( -60.06)
 *//* For x >= 8, the asymptotic expansions of qone is
 *      3/8 s - 105/1024 s^3 - ..., where s = 1/x.
 * We approximate pone by
 *      qone(x) = s*(0.375 + (R/S))
 * where  R = qr1*s^2 + qr2*s^4 + ... + qr5*s^10
 *        S = 1 + qs1*s^2 + ... + qs6*s^12
 * and
 *      | qone(x)/s -0.375-R/S | <= 2  ** ( -61.13)
 *//* 0xbd800000 *//* 0x3ab86cfd *//* 0xb7862e36 *//* 0x335557d2 *//* 0x3c9ce859 *//* 0x3942fab6 *//* 0x359dffc2 *//* 0x31ad6446 */j1fy1fponefqoneftest_j1f_2488test_y1f_2002/* origin: FreeBSD /usr/src/lib/msun/src/e_j1f.c *//* 0x2d59567e *//* origin: FreeBSD /usr/src/lib/msun/src/e_jn.c *//*
 * jn(n, x), yn(n, x)
 * floating point Bessel's function of the 1st and 2nd kind
 * of order n
 *
 * Special cases:
 *      y0(0)=y1(0)=yn(n,0) = -inf with division by zero signal;
 *      y0(-ve)=y1(-ve)=yn(n,-ve) are NaN with invalid signal.
 * Note 2. About jn(n,x), yn(n,x)
 *      For n=0, j0(x) is called,
 *      for n=1, j1(x) is called,
 *      for n<=x, forward recursion is used starting
 *      from values of j0(x) and j1(x).
 *      for n>x, a continued fraction approximation to
 *      j(n,x)/j(n-1,x) is evaluated and then backward
 *      recursion is used starting from a supposed value
 *      for j(n,x). The resulting value of j(0,x) is
 *      compared with the actual value to correct the
 *      supposed value of j(n,x).
 *
 *      yn(n,x) is similar in all respects, except
 *      that forward recursion is used for all
 *      values of n>1.
 */jnfynf/* origin: FreeBSD /usr/src/lib/msun/src/e_jnf.c */C2/* 0x3FA55555, 0x5555554C */C3/* 0xBF56C16C, 0x16C15177 */C4/* 0x3EFA01A0, 0x19CB1590 */C5/* 0xBE927E4F, 0x809C52AD */C6/* 0x3E21EE9E, 0xBDB4B1C4 */// kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164// Input x is assumed to be bounded by ~pi/4 in magnitude.// Input y is the tail of x.// Algorithm//      1. Since cos(-x) = cos(x), we need only to consider positive x.//      2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0.//      3. cos(x) is approximated by a polynomial of degree 14 on//         [0,pi/4]//                                       4            14//              cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x//         where the remez error is//      |              2     4     6     8     10    12     14 |     -58//      |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x  +C6*x  )| <= 2//      |                                                      |//                     4     6     8     10    12     14//      4. let r = C1*x +C2*x +C3*x +C4*x +C5*x  +C6*x  , then//             cos(x) ~ 1 - x*x/2 + r//         since cos(x+y) ~ cos(x) - sin(x)*y//                        ~ cos(x) - x*y,//         a correction term is necessary in cos(x) and hence//              cos(x+y) = 1 - (x*x/2 - (r - x*y))//         For better accuracy, rearrange to//              cos(x+y) ~ w + (tmp + (r-x*y))//         where w = 1 - x*x/2 and tmp is a tiny correction term//         (1 - x*x/2 == w + tmp exactly in infinite precision).//         The exactness of w + tmp in infinite precision depends on w//         and tmp having the same precision as x.  If they have extra//         precision due to compiler bugs, then the extra precision is//         only good provided it is retained in all terms of the final//         expression for cos().  Retention happens in all cases tested//         under FreeBSD, so don't pessimize things by forcibly clipping//         any extra precision in w.// origin: FreeBSD /usr/src/lib/msun/src/k_cos.c// Developed at SunSoft, a Sun Microsystems, Inc. business./* 0xBDA8FAE9, 0xBE8838D4 */C0/* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). *//* -0x1ffffffd0c5e81.0p-54 *//*  0x155553e1053a42.0p-57 *//* -0x16c087e80f1e27.0p-62 *//* origin: FreeBSD /usr/src/lib/msun/src/k_cosf.c *//*  0x199342e0ee5069.0p-68 *//* k is such that k*ln2 has minimal relative error and x - kln2 > log(FLT_MIN) *//* expf(x)/2 for x >= log(FLT_MAX), slightly better than 0.5f*expf(x/2)*expf(x/2) *//* 0xBFC55555, 0x55555549 *//* 0x3F811111, 0x1110F8A6 *//* 0xBF2A01A0, 0x19C161D5 *//* 0x3EC71DE3, 0x57B1FE7D *//* 0xBE5AE5E6, 0x8A2B9CEB */// kernel sin function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854// Input iy indicates whether y is 0. (if iy=0, y assume to be 0).//      1. Since sin(-x) = -sin(x), we need only to consider positive x.//      2. Callers must return sin(-0) = -0 without calling here since our//         odd polynomial is not evaluated in a way that preserves -0.//         Callers may do the optimization sin(x) ~ x for tiny x.//      3. sin(x) is approximated by a polynomial of degree 13 on//                               3            13//              sin(x) ~ x + S1*x + ... + S6*x//         where//      |sin(x)         2     4     6     8     10     12  |     -58//      |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x  +S6*x   )| <= 2//      |  x                                               |//      4. sin(x+y) = sin(x) + sin'(x')*y//                  ~ sin(x) + (1-x*x/2)*y//         For better accuracy, let//                   3      2      2      2      2//              r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6))))//         then                   3    2//              sin(x) = x + (S1*x + (x *(r-y/2)+y))// origin: FreeBSD /usr/src/lib/msun/src/k_sin.c/* 0x3DE5D93A, 0x5ACFD57C *//* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). *//* -0x15555554cbac77.0p-55 *//*  0x111110896efbb2.0p-59 *//* -0x1a00f9e2cae774.0p-65 *//* origin: FreeBSD /usr/src/lib/msun/src/k_sinf.c *//*  0x16cd878c3b46a7.0p-71 */// kernel tan function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854// Input odd indicates whether tan (if odd = 0) or -1/tan (if odd = 1) is returned.//      1. Since tan(-x) = -tan(x), we need only to consider positive x.//      2. Callers must return tan(-0) = -0 without calling here since our//         Callers may do the optimization tan(x) ~ x for tiny x.//      3. tan(x) is approximated by a odd polynomial of degree 27 on//         [0,0.67434]//                               3             27//              tan(x) ~ x + T1*x + ... + T13*x//              |tan(x)         2     4            26   |     -59.2//              |----- - (1+T1*x +T2*x +.... +T13*x    )| <= 2//              |  x                                    |//         Note: tan(x+y) = tan(x) + tan'(x)*y//                        ~ tan(x) + (1+x*x)*y//         Therefore, for better accuracy in computing tan(x+y), let//                   3      2      2       2       2//              r = x *(T2+x *(T3+x *(...+x *(T12+x *T13))))//         then//                                  3    2//              tan(x+y) = x + (T1*x + (x *(r+y)+y))//      4. For x in [0.67434,pi/4],  let y = pi/4 - x, then//              tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y))//                     = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y)))PIO4PIO4_LO/* 3FE921FB, 54442D18 */k_tanzero_low_word// origin: FreeBSD /usr/src/lib/msun/src/k_tan.c */// Copyright 2004 Sun Microsystems, Inc.  All Rights Reserved./* 3C81A626, 33145C07 *//* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */k_tanf/* origin: FreeBSD /usr/src/lib/msun/src/k_tan.c *//*
 * ====================================================
 * Copyright 2004 Sun Microsystems, Inc.  All Rights Reserved.
 *
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 */ldexpf/* 0x3FB3C467, 0xE37DB0C8 *//* 0x3FD4A34C, 0xC4A60FAD *//* 0x3FB13E00, 0x1A5562A7 *//* 0x3F951322, 0xAC92547B *//* 0x3F7E404F, 0xB68FEFE8 *//* 0x3F67ADD8, 0xCCB7926B *//* 0x3F538A94, 0x116F3F5D *//* 0x3F40B6C6, 0x89B99C00 */A9/* 0x3F2CF2EC, 0xED10E54D */A10/* 0x3F1C5088, 0x987DFB07 */A11/* 0x3EFA7074, 0x428CFA52 */TC/* 0x3F07858E, 0x90A45837 */TF/* 0x3FF762D8, 0x6356BE3F */TT/* 0xBFBF19B9, 0xBCC38A42 *//* tt = -(tail of TF) *//* 0xBC50C7CA, 0xA48A971F *//* 0x3FDEF72B, 0xC8EE38A2 *//* 0xBFC2E427, 0x8DC6C509 *//* 0x3FB08B42, 0x94D5419B *//* 0xBFA0C9A8, 0xDF35B713 *//* 0x3F9266E7, 0x970AF9EC *//* 0xBF851F9F, 0xBA91EC6A *//* 0x3F78FCE0, 0xE370E344 *//* 0xBF6E2EFF, 0xB3E914D7 *//* 0x3F6282D3, 0x2E15C915 *//* 0xBF56FE8E, 0xBF2D1AF1 *//* 0x3F4CDF0C, 0xEF61A8E9 *//* 0xBF41A610, 0x9C73E0EC *//* 0x3F34AF6D, 0x6C0EBBF7 *//* 0xBF347F24, 0xECC38C38 *//* 0x3F35FD3E, 0xE8C2D3F4 *//* 0xBFB3C467, 0xE37DB0C8 *//* 0x3FE4401E, 0x8B005DFF *//* 0x3FF7475C, 0xD119BD6F *//* 0x3FEF4976, 0x44EA8450 *//* 0x3FCD4EAE, 0xF6010924 *//* 0x3F8B678B, 0xBF2BAB09 *//* 0x4003A5D7, 0xC2BD619C *//* 0x40010725, 0xA42B18F5 *//* 0x3FE89DFB, 0xE45050AF *//* 0x3FBAAE55, 0xD6537C88 *//* 0x3F6A5ABB, 0x57D0CF61 *//* 0x3FCB848B, 0x36E20878 *//* 0x3FD4D98F, 0x4F139F59 *//* 0x3FC2BB9C, 0xBEE5F2F7 *//* 0x3F9B481C, 0x7E939961 *//* 0x3F5E26B6, 0x7368F239 *//* 0x3F00BFEC, 0xDD17E945 *//* 0x3FF645A7, 0x62C4AB74 *//* 0x3FE71A18, 0x93D3DCDC *//* 0x3FC601ED, 0xCCFBDF27 *//* 0x3F9317EA, 0x742ED475 *//* 0x3F497DDA, 0xCA41A95B */W0/* 0x3EDEBAF7, 0xA5B38140 */W1/* 0x3FDACFE3, 0x90C97D69 */W2/* 0x3FB55555, 0x5555553B */W3/* 0xBF66C16C, 0x16B02E5C */W4/* 0x3F4A019F, 0x98CF38B6 */W5/* 0xBF4380CB, 0x8C0FE741 */W6/* 0x3F4B67BA, 0x4CDAD5D1 */sin_pi/* sin(PI*x) assuming x > 2^-100, if sin(PI*x)==0 the sign is arbitrary *//* origin: FreeBSD /usr/src/lib/msun/src/e_lgamma_r.c *//* lgamma_r(x, signgamp)
 * Reentrant version of the logarithm of the Gamma function
 * with user provide pointer for the sign of Gamma(x).
 *
 * Method:
 *   1. Argument Reduction for 0 < x <= 8
 *      Since gamma(1+s)=s*gamma(s), for x in [0,8], we may
 *      reduce x to a number in [1.5,2.5] by
 *              lgamma(1+s) = log(s) + lgamma(s)
 *      for example,
 *              lgamma(7.3) = log(6.3) + lgamma(6.3)
 *                          = log(6.3*5.3) + lgamma(5.3)
 *                          = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
 *   2. Polynomial approximation of lgamma around its
 *      minimun ymin=1.461632144968362245 to maintain monotonicity.
 *      On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
 *              Let z = x-ymin;
 *              lgamma(x) = -1.214862905358496078218 + z^2*poly(z)
 *      where
 *              poly(z) is a 14 degree polynomial.
 *   2. Rational approximation in the primary interval [2,3]
 *      We use the following approximation:
 *              s = x-2.0;
 *              lgamma(x) = 0.5*s + s*P(s)/Q(s)
 *      with accuracy
 *              |P/Q - (lgamma(x)-0.5s)| < 2**-61.71
 *      Our algorithms are based on the following observation
 *
 *                             zeta(2)-1    2    zeta(3)-1    3
 * lgamma(2+s) = s*(1-Euler) + --------- * s  -  --------- * s  + ...
 *                                 2                 3
 *
 *      where Euler = 0.5771... is the Euler constant, which is very
 *      close to 0.5.
 *
 *   3. For x>=8, we have
 *      lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+....
 *      (better formula:
 *         lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...)
 *      Let z = 1/x, then we approximation
 *              f(z) = lgamma(x) - (x-0.5)(log(x)-1)
 *      by
 *                                  3       5             11
 *              w = w0 + w1*z + w2*z  + w3*z  + ... + w6*z
 *      where
 *              |w - f(z)| < 2**-58.74
 *
 *   4. For negative x, since (G is gamma function)
 *              -x*G(-x)*G(x) = PI/sin(PI*x),
 *      we have
 *              G(x) = PI/(sin(PI*x)*(-x)*G(-x))
 *      since G(-x) is positive, sign(G(x)) = sign(sin(PI*x)) for x<0
 *      Hence, for x<0, signgam = sign(sin(PI*x)) and
 *              lgamma(x) = log(|Gamma(x)|)
 *                        = log(PI/(|x*sin(PI*x)|)) - lgamma(-x);
 *      Note: one should avoid compute PI*(-x) directly in the
 *            computation of sin(PI*(-x)).
 *
 *   5. Special Cases
 *              lgamma(2+s) ~ s*(1-Euler) for tiny s
 *              lgamma(1) = lgamma(2) = 0
 *              lgamma(x) ~ -log(|x|) for tiny x
 *              lgamma(0) = lgamma(neg.integer) = inf and raise divide-by-zero
 *              lgamma(inf) = inf
 *              lgamma(-inf) = inf (bug for bug compatible with C99!?)
 *
 *//* 0xBF5AB89D, 0x0B9E43E4 */lgammaf_rlgammaf/* 0x3d9e233f *//* 0x3ea51a66 *//* 0x3d89f001 *//* 0x3ca89915 *//* 0x3bf2027e *//* 0x3b3d6ec6 *//* 0x3a9c54a1 *//* 0x3a05b634 *//* 0x39679767 *//* 0x38e28445 *//* 0x37d383a2 *//* 0x383c2c75 *//* 0x3fbb16c3 *//* 0xbdf8cdcd *//* TT = -(tail of TF) *//* 0x31e61c52 *//* 0x3ef7b95e *//* 0xbe17213c *//* 0x3d845a15 *//* 0xbd064d47 *//* 0x3c93373d *//* 0xbc28fcfe *//* 0x3bc7e707 *//* 0xbb7177fe *//* 0x3b141699 *//* 0xbab7f476 *//* 0x3a66f867 *//* 0xba0d3085 *//* 0x39a57b6b *//* 0xb9a3f927 *//* 0x39afe9f7 *//* 0xbd9e233f *//* 0x3f2200f4 *//* 0x3fba3ae7 *//* 0x3f7a4bb2 *//* 0x3e6a7578 *//* 0x3c5b3c5e *//* 0x401d2ebe *//* 0x4008392d *//* 0x3f44efdf *//* 0x3dd572af *//* 0x3b52d5db *//* 0x3e5c245a *//* 0x3ea6cc7a *//* 0x3e15dce6 *//* 0x3cda40e4 *//* 0x3af135b4 *//* 0x3805ff67 *//* 0x3fb22d3b *//* 0x3f38d0c5 *//* 0x3e300f6e *//* 0x3c98bf54 *//* 0x3a4beed6 *//* 0x36f5d7bd *//* 0x3ed67f1d *//* 0x3daaaaab *//* 0xbb360b61 *//* 0x3a500cfd *//* 0xba1c065c *//* 0x3a5b3dd2 *//* origin: FreeBSD /usr/src/lib/msun/src/e_lgammaf_r.c *//* 0xbad5c4e8 *//* 3fe62e42 fee00000 */LG1/* 3dea39ef 35793c76 */LG2/* 3FE55555 55555593 */LG3/* 3FD99999 9997FA04 */LG4/* 3FD24924 94229359 */LG5/* 3FCC71C5 1D8E78AF */LG6/* 3FC74664 96CB03DE */LG7/* 3FC39A09 D078C69F *//* origin: FreeBSD /usr/src/lib/msun/src/e_log.c *//* log(x)
 * Return the logarithm of x
 *
 * Method :
 *   1. Argument Reduction: find k and f such that
 *                      x = 2^k * (1+f),
 *         where  sqrt(2)/2 < 1+f < sqrt(2) .
 *
 *   2. Approximation of log(1+f).
 *      Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
 *               = 2s + 2/3 s**3 + 2/5 s**5 + .....,
 *               = 2s + s*R
 *      We use a special Remez algorithm on [0,0.1716] to generate
 *      a polynomial of degree 14 to approximate R The maximum error
 *      of this polynomial approximation is bounded by 2**-58.45. In
 *      other words,
 *                      2      4      6      8      10      12      14
 *          R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s  +Lg6*s  +Lg7*s
 *      (the values of Lg1 to Lg7 are listed in the program)
 *      and
 *          |      2          14          |     -58.45
 *          | Lg1*s +...+Lg7*s    -  R(z) | <= 2
 *          |                             |
 *      Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
 *      In order to guarantee error in log below 1ulp, we compute log
 *      by
 *              log(1+f) = f - s*(f - R)        (if f is not too large)
 *              log(1+f) = f - (hfsq - s*(hfsq+R)).     (better accuracy)
 *
 *      3. Finally,  log(x) = k*ln2 + log(1+f).
 *                          = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
 *         Here ln2 is split into two floating point number:
 *                      ln2_hi + ln2_lo,
 *         where n*ln2_hi is always exact for |n| < 2000.
 *
 * Special cases:
 *      log(x) is NaN with signal if x < 0 (including -INF) ;
 *      log(+INF) is +INF; log(0) is -INF with signal;
 *      log(NaN) is that NaN with no signal.
 *
 * Accuracy:
 *      according to an error analysis, the error is always less than
 *      1 ulp (unit in the last place).
 *
 * Constants:
 * The hexadecimal values are the intended ones for the following
 * constants. The decimal values may be used, provided that the
 * compiler will convert from decimal to binary accurately enough
 * to produce the hexadecimal values shown.
 *//* 3FC2F112 DF3E5244 */IVLN10HIIVLN10LO/* 0x3fdbcb7b, 0x15200000 */LOG10_2HI/* 0x3dbb9438, 0xca9aadd5 */LOG10_2LO/* 0x3FD34413, 0x509F6000 *//* 0x3D59FEF3, 0x11F12B36 *//* origin: FreeBSD /usr/src/lib/msun/src/e_log10.c *//*
 * Return the base 10 logarithm of x.  See log.c for most comments.
 *
 * Reduce x to 2^k (1+f) and calculate r = log(1+f) - f + f*f/2
 * as in log.c, then combine and scale in extra precision:
 *    log10(x) = (f - f*f/2 + r)/log(10) + k*log10(2)
 *//* 0x3ede6000 *//* 0xb804ead9 *//* 0x3e9a2080 *//* 0x355427db *//* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). *//* 0xaaaaaa.0p-24 *//* 0xccce13.0p-25 *//* 0x91e9ee.0p-25 */log10f/* origin: FreeBSD /usr/src/lib/msun/src/e_log10f.c *//*
 * See comments in log10.c.
 *//* 0xf89e26.0p-26 *//* origin: FreeBSD /usr/src/lib/msun/src/s_log1p.c *//* double log1p(double x)
 * Return the natural logarithm of 1+x.
 *
 * Method :
 *   1. Argument Reduction: find k and f such that
 *                      1+x = 2^k * (1+f),
 *         where  sqrt(2)/2 < 1+f < sqrt(2) .
 *
 *      Note. If k=0, then f=x is exact. However, if k!=0, then f
 *      may not be representable exactly. In that case, a correction
 *      term is need. Let u=1+x rounded. Let c = (1+x)-u, then
 *      log(1+x) - log(u) ~ c/u. Thus, we proceed to compute log(u),
 *      and add back the correction term c/u.
 *      (Note: when x > 2**53, one can simply return log(x))
 *
 *   2. Approximation of log(1+f): See log.c
 *
 *   3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
 *
 * Special cases:
 *      log1p(x) is NaN with signal if x < -1 (including -INF) ;
 *      log1p(+INF) is +INF; log1p(-1) is -INF with signal;
 *      log1p(NaN) is that NaN with no signal.
 *
 * Accuracy:
 *      according to an error analysis, the error is always less than
 *      1 ulp (unit in the last place).
 *
 * Constants:
 * The hexadecimal values are the intended ones for the following
 * constants. The decimal values may be used, provided that the
 * compiler will convert from decimal to binary accurately enough
 * to produce the hexadecimal values shown.
 *
 * Note: Assuming log() return accurate answer, the following
 *       algorithm can be used to compute log1p(x) to within a few ULP:
 *
 *              u = 1+x;
 *              if(u==1.0) return x ; else
 *                         return log(u)*(x/(u-1.0));
 *
 *       See HP-15C Advanced Functions Handbook, p.193.
 *//* origin: FreeBSD /usr/src/lib/msun/src/s_log1pf.c */IVLN2HIIVLN2LO/* 0x3ff71547, 0x65200000 *//* 0x3de705fc, 0x2eefa200 *//* origin: FreeBSD /usr/src/lib/msun/src/e_log2.c *//*
 * Return the base 2 logarithm of x.  See log.c for most comments.
 *
 * Reduce x to 2^k (1+f) and calculate r = log(1+f) - f + f*f/2
 * as in log.c, then combine and scale in extra precision:
 *    log2(x) = (f - f*f/2 + r)/log(2) + k
 *//* 0x3fb8b000 *//* 0xb9389ad4 */log2f/* origin: FreeBSD /usr/src/lib/msun/src/e_log2f.c *//*
 * See comments in log2.c.
 *//*  0xaaaaaa.0p-24*//*  0xccce13.0p-25 *//*  0x91e9ee.0p-25 *//* origin: FreeBSD /usr/src/lib/msun/src/e_logf.c *//*  0xf89e26.0p-26 */force_eval// Temporary macro to avoid panic codegen for division (in debug mode too). At// the time of this writing this is only used in a few places, and once// rust-lang/rust#72751 is fixed then this macro will no longer be necessary and// the native `/` operator can be used and panics won't be codegen'd.llvm_intrinsically_optimized// Public modulesnextafterfremainderfremquofrintfsincosfsinhftanftanhftgammaftruncf// Use separated imports instead of {}-grouped imports for easier merging.// Private modulesrem_pio2_large// Private re-importswith_set_high_word// pow(x,y) return x**y//                    n// Method:  Let x =  2   * (1+f)//      1. Compute and return log2(x) in two pieces://              log2(x) = w1 + w2,//         where w1 has 53-24 = 29 bit trailing zeros.//      2. Perform y*log2(x) = n+y' by simulating muti-precision//         arithmetic, where |y'|<=0.5.//      3. Return x**y = 2**n*exp(y'*log2)//      1.  (anything) ** 0  is 1//      2.  1 ** (anything)  is 1//      3.  (anything except 1) ** NAN is NAN//      4.  NAN ** (anything except 0) is NAN//      5.  +-(|x| > 1) **  +INF is +INF//      6.  +-(|x| > 1) **  -INF is +0//      7.  +-(|x| < 1) **  +INF is +0//      8.  +-(|x| < 1) **  -INF is +INF//      9.  -1          ** +-INF is 1//      10. +0 ** (+anything except 0, NAN)               is +0//      11. -0 ** (+anything except 0, NAN, odd integer)  is +0//      12. +0 ** (-anything except 0, NAN)               is +INF, raise divbyzero//      13. -0 ** (-anything except 0, NAN, odd integer)  is +INF, raise divbyzero//      14. -0 ** (+odd integer) is -0//      15. -0 ** (-odd integer) is -INF, raise divbyzero//      16. +INF ** (+anything except 0,NAN) is +INF//      17. +INF ** (-anything except 0,NAN) is +0//      18. -INF ** (+odd integer) is -INF//      19. -INF ** (anything) = -0 ** (-anything), (anything except odd integer)//      20. (anything) ** 1 is (anything)//      21. (anything) ** -1 is 1/(anything)//      22. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)//      23. (-anything except 0 and inf) ** (non-integer) is NAN//      pow(x,y) returns x**y nearly rounded. In particular//                      pow(integer,integer)//      always returns the correct integer provided it is//      representable.// Constants :// The hexadecimal values are the intended ones for the following// constants. The decimal values may be used, provided that the// compiler will convert from decimal to binary accurately enough// to produce the hexadecimal values shown.BPDP_HDP_L/* 0x3fe2b803_40000000 */TWO53/* 0x3E4CFDEB, 0x43CFD006 */HUGE/* 0x43400000_00000000 */TINY// poly coefs for (3/2)*(log(x)-2s-2/3*s**3:/* 0x3fe33333_33333303 *//* 0x3fdb6db6_db6fabff *//* 0x3fd55555_518f264d *//* 0x3fd17460_a91d4101 *//* 0x3fcd864a_93c9db65 *//* 0x3fca7e28_4a454eef *//* 0x3fc55555_5555553e *//* 0xbf66c16c_16bebd93 *//* 0x3f11566a_af25de2c *//* 0xbebbbd41_c5d26bf1 *//* 0x3e663769_72bea4d0 */LG2_H/* 0x3fe62e42_fefa39ef */LG2_L/* 0x3fe62e43_00000000 */OVT/* 0xbe205c61_0ca86c39 */CP/* -(1024-log2(ovfl+.5ulp)) */CP_H/* 0x3feec709_dc3a03fd =2/(3ln2) */CP_L/* 0x3feec709_e0000000 =(float)cp */IVLN2/* 0xbe3e2fe0_145b01f5 =tail of cp_h*/IVLN2_H/* 0x3ff71547_652b82fe =1/ln2 */IVLN2_L/* 0x3ff71547_60000000 =24b 1/ln2*/POS_ZEROPOS_ONEPOS_FLOATSNEG_FLOATSPOS_SMALL_FLOATSNEG_SMALL_FLOATSPOS_EVENSNEG_EVENSPOS_ODDSNEG_ODDSNANSPOS_INFNEG_INFNEGpow_testtest_sets_as_basetest_sets_as_exponenttest_setszero_as_exponentone_as_basenan_inputsinfinity_as_baseinfinity_as_exponentzero_as_basespecial_casesnormal_cases/* origin: FreeBSD /usr/src/lib/msun/src/e_pow.c *//* 0x3e54ae0b_f85ddf44 =1/ln2 tail*//* 0x3f15c000 */TWO24/* 0x35d1cfdc *//* 0x4b800000 *//* 0x3f19999a *//* 0x3edb6db7 *//* 0x3eaaaaab *//* 0x3e8ba305 *//* 0x3e6c3255 *//* 0x3e53f142 *//* 0x3e2aaaab *//* 0x388ab355 *//* 0xb5ddea0e *//* 0x3331bb4c *//* 0x3f317218 *//* 0x35bfbe8c *//* -(128-log2(ovfl+.5ulp)) *//* 0x3f76384f =2/(3ln2) *//* 0x3f764000 =12b cp *//* 0xb8f623c6 =tail of cp_h *//* origin: FreeBSD /usr/src/lib/msun/src/e_powf.c */// origin: FreeBSD /usr/src/lib/msun/src/e_rem_pio2.c// Optimized by Bruce D. Evans. */EPS// #if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1// #define EPS DBL_EPSILONTO_INTINV_PIO2/// 53 bits of 2/piPIO2_1/// first 33 bits of pi/2PIO2_1T/* 0x3FF921FB, 0x54400000 *//// pi/2 - PIO2_1PIO2_2/* 0x3DD0B461, 0x1A626331 *//// second 33 bits of pi/2PIO2_2T/* 0x3DD0B461, 0x1A600000 *//// pi/2 - (PIO2_1+PIO2_2)PIO2_3/* 0x3BA3198A, 0x2E037073 *//// third 33 bits of pi/2PIO2_3T/* 0x3BA3198A, 0x2E000000 *//// pi/2 - (PIO2_1+PIO2_2+PIO2_3)// return the remainder of x rem pi/2 in y[0]+y[1]// use rem_pio2_large() for large x// caller must handle the case when reduction is not needed: |x| ~<= pi/4 */test_near_pitest_overflow_b9b847test_overflow_4747b9// #elif FLT_EVAL_METHOD==2// #define EPS LDBL_EPSILON// TODO: Support FLT_EVAL_METHOD?/* 0x397B839A, 0x252049C1 */INIT_JK// initial value for jkIPIO2690/// Return the last three digits of N with y = x - N*pi/2/// so that |y| < pi/2./// The method is to compute the integer (mod 8) and fraction parts of/// (2/pi)*x without doing the full multiplication. In general we/// skip the part of the product that are known to be a huge integer (/// more accurately, = 0 mod 8 ). Thus the number of operations are/// independent of the exponent of the input./* origin: FreeBSD /usr/src/lib/msun/src/k_rem_pio2.c */// fn rem_pio2_large(x : &[f64], y : &mut [f64], e0 : i32, prec : usize) -> i32// Input parameters://      x[]     The input value (must be positive) is broken into nx//              pieces of 24-bit integers in double precision format.//              x[i] will be the i-th 24 bit of x. The scaled exponent//              of x[0] is given in input parameter e0 (i.e., x[0]*2^e0//              match x's up to 24 bits.//              Example of breaking a double positive z into x[0]+x[1]+x[2]://                      e0 = ilogb(z)-23//                      z  = scalbn(z,-e0)//              for i = 0,1,2//                      x[i] = floor(z)//                      z    = (z-x[i])*2**24//      y[]     ouput result in an array of double precision numbers.//              The dimension of y[] is://                      24-bit  precision       1//                      53-bit  precision       2//                      64-bit  precision       2//                      113-bit precision       3//              The actual value is the sum of them. Thus for 113-bit//              precison, one may have to do something like://              long double t,w,r_head, r_tail;//              t = (long double)y[2] + (long double)y[1];//              w = (long double)y[0];//              r_head = t+w;//              r_tail = w - (r_head - t);//      e0      The exponent of x[0]. Must be <= 16360 or you need to//              expand the ipio2 table.//      prec    an integer indicating the precision://                      0       24  bits (single)//                      1       53  bits (double)//                      2       64  bits (extended)//                      3       113 bits (quad)// Here is the description of some local variables://      jk      jk+1 is the initial number of terms of ipio2[] needed//              in the computation. The minimum and recommended value//              for jk is 3,4,4,6 for single, double, extended, and quad.//              jk+1 must be 2 larger than you might expect so that our//              recomputation test works. (Up to 24 bits in the integer//              part (the 24 bits of it that we compute) and 23 bits in//              the fraction part may be lost to cancelation before we//              recompute.)//      jz      local integer variable indicating the number of//              terms of ipio2[] used.//      jx      nx - 1//      jv      index for pointing to the suitable ipio2[] for the//              computation. In general, we want//                      ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8//              is an integer. Thus//                      e0-3-24*jv >= 0 or (e0-3)/24 >= jv//              Hence jv = max(0,(e0-3)/24).//      jp      jp+1 is the number of terms in PIo2[] needed, jp = jk.//      q[]     double array with integral value, representing the//              24-bits chunk of the product of x and 2/pi.//      q0      the corresponding exponent of q[0]. Note that the//              exponent for q[i] would be q0-24*i.//      PIo2[]  double precision array, obtained by cutting pi/2//              into 24 bits chunks.//      f[]     ipio2[] in floating point//      iq[]    integer array by breaking up q[] in 24-bits chunk.//      fq[]    final product of x*(2/pi) in fq[0],..,fq[jk]//      ih      integer. If >0 it indicates q[] is >= 0.5, hence//              it also indicates the *sign* of the result./// first 25 bits of pi/2/* 0x3FF921FB, 0x50000000 *//// pi/2 - pio2_1/// Return the remainder of x rem pi/2 in *y/// use double precision for everything except passing x/// use __rem_pio2_large() for large x/* origin: FreeBSD /usr/src/lib/msun/src/e_rem_pio2f.c *//* 0x3E5110b4, 0x611A6263 */test_q_overflownegative_zero// sin(x)// Return sine function of x.//      k_sin            ... sine function on [-pi/4,pi/4]//      k_cos            ... cose function on [-pi/4,pi/4]//      rem_pio2         ... argument reduction routine// origin: FreeBSD /usr/src/lib/msun/src/s_sin.c */TOLERANCEwith_pirotational_symmetry// These tests are based on those from sincosf.rs/* origin: FreeBSD /usr/src/lib/msun/src/s_sin.c */PI_2S1PIO2S2PIO2S3PIO2S4PIO2/* origin: FreeBSD /usr/src/lib/msun/src/s_sinf.c */S1_PIO2S2_PIO2S3_PIO2S4_PIO2// sinh(x) = (exp(x) - 1/exp(x))/2//         = (exp(x)-1 + (exp(x)-1)/exp(x))/2//         = x + x^3/6 + o(x^5)/// The spec: https://en.cppreference.com/w/cpp/numeric/math/sqrtconformance_tests/* origin: FreeBSD /usr/src/lib/msun/src/e_sqrt.c *//* sqrt(x)
 * Return correctly rounded sqrt.
 *           ------------------------------------------
 *           |  Use the hardware sqrt if you have one |
 *           ------------------------------------------
 * Method:
 *   Bit by bit method using integer arithmetic. (Slow, but portable)
 *   1. Normalization
 *      Scale x to y in [1,4) with even powers of 2:
 *      find an integer k such that  1 <= (y=x*2^(2k)) < 4, then
 *              sqrt(x) = 2^k * sqrt(y)
 *   2. Bit by bit computation
 *      Let q  = sqrt(y) truncated to i bit after binary point (q = 1),
 *           i                                                   0
 *                                     i+1         2
 *          s  = 2*q , and      y  =  2   * ( y - q  ).         (1)
 *           i      i            i                 i
 *
 *      To compute q    from q , one checks whether
 *                  i+1       i
 *
 *                            -(i+1) 2
 *                      (q + 2      ) <= y.                     (2)
 *                        i
 *                                                            -(i+1)
 *      If (2) is false, then q   = q ; otherwise q   = q  + 2      .
 *                             i+1   i             i+1   i
 *
 *      With some algebraic manipulation, it is not difficult to see
 *      that (2) is equivalent to
 *                             -(i+1)
 *                      s  +  2       <= y                      (3)
 *                       i                i
 *
 *      The advantage of (3) is that s  and y  can be computed by
 *                                    i      i
 *      the following recurrence formula:
 *          if (3) is false
 *
 *          s     =  s  ,       y    = y   ;                    (4)
 *           i+1      i          i+1    i
 *
 *          otherwise,
 *                         -i                     -(i+1)
 *          s     =  s  + 2  ,  y    = y  -  s  - 2             (5)
 *           i+1      i          i+1    i     i
 *
 *      One may easily use induction to prove (4) and (5).
 *      Note. Since the left hand side of (3) contain only i+2 bits,
 *            it does not necessary to do a full (53-bit) comparison
 *            in (3).
 *   3. Final rounding
 *      After generating the 53 bits result, we compute one more bit.
 *      Together with the remainder, we can decide whether the
 *      result is exact, bigger than 1/2ulp, or less than 1/2ulp
 *      (it will never equal to 1/2ulp).
 *      The rounding mode can be detected by checking whether
 *      huge + tiny is equal to huge, and whether huge - tiny is
 *      equal to huge for some floating point number "huge" and "tiny".
 *
 * Special cases:
 *      sqrt(+-0) = +-0         ... exact
 *      sqrt(inf) = inf
 *      sqrt(-ve) = NaN         ... with invalid signal
 *      sqrt(NaN) = NaN         ... with invalid signal for signaling NaN
 *//* origin: FreeBSD /usr/src/lib/msun/src/e_sqrtf.c */// tan(x)// Return tangent function of x.//      k_tan           ... tangent function on [-pi/4,pi/4]// origin: FreeBSD /usr/src/lib/msun/src/s_tan.c */T1_PIO2T2_PIO2T3_PIO2T4_PIO2/* origin: FreeBSD /usr/src/lib/msun/src/s_tanf.c *//* tanh(x) = (exp(x) - exp(-x))/(exp(x) + exp(-x))
 *         = (exp(2*x) - 1)/(exp(2*x) - 1 + 2)
 *         = (1 - exp(-2*x))/(exp(-2*x) - 1 + 2)
 *//*
"A Precision Approximation of the Gamma Function" - Cornelius Lanczos (1964)
"Lanczos Implementation of the Gamma Function" - Paul Godfrey (2001)
"An Analysis of the Lanczos Gamma Approximation" - Glendon Ralph Pugh (2004)

approximation method:

                        (x - 0.5)         S(x)
Gamma(x) = (x + g - 0.5)         *  ----------------
                                    exp(x + g - 0.5)

with
                 a1      a2      a3            aN
S(x) ~= [ a0 + ----- + ----- + ----- + ... + ----- ]
               x + 1   x + 2   x + 3         x + N

with a0, a1, a2, a3,.. aN constants which depend on g.

for x < 0 the following reflection formula is used:

Gamma(x)*Gamma(-x) = -pi/(x sin(pi x))

most ideas and constants are from boost and python
*/sinpi/* sin(pi x) with x > 0x1p-100, if sin(pi*x)==0 the sign is arbitrary */GMHALF//static const double g = 6.024680040776729583740234375;SNUMSDENFACT/* n! for small integer n *//* S(x) rational function for positive x *//// List item/// End of list reached/// Failure, an error occurred/// List result instance./// Fetching a list can result in a callback being fired for each list item, and then once more to/// signal the end of the list having been reached. This type is used to distinguish such state to a/// closure callback.savedClosureProtoProxyProtoMultiUseCallback/// A saved multi-use callback./// Closures of multi-use callbacks (those that may be called multiple times) need saving, and/// releasing later at an appropriate time (on change of registered callback, or on destruction of/// associated object). This is used for saving the pointer to it for such deferred destruction./// **Note**, an existing instance should always be overwritten with a new one, to ensure the/// old one is correctly freed.get_capi_params/// Returns callback params to give to the C API (a tuple of function pointer and data pointer).get_callback/// Converts void closure pointer back to real type./// For use in callback proxies./// Only a reference is returned, in order to deliberately avoid reclaiming ownership and thus/// triggering of destruction./// Panics if `ptr` is null.box_closure_get_capi_ptr/// Converts single-use-callback closure to pointer for C API./// It can be restored in an `extern "C"` callback proxy with `get_su_callback`./// Note: The closure itself needs to exist on the heap, and here we take it as such (wrapped in a/// `Box`); from this you may assume that a pointer is already available. However, this is a pointer/// to a trait object, and these are special in Rust, they are twice the size of a normal pointer/// because in actual fact it is implemented as a pair of pointers (one to a type instance and one/// to a ‘vtable’). We can only pass a normal sized pointer through the C API, so we must further/// box it, producing `Box<Box<Closure>>` which we convert to `*mut Box<Closure>` and then further/// to simply `*mut c_void`.get_su_capi_params/// Gets the C API callback params (function pointer and data pointer pair), for an optional/// single-use callback closure./// The proxy function must be specified. If `callback` is `None` then a pair of null pointers will/// be returned. Otherwise, a pair consisting of the given proxy and a pointer for the given closure/// will be returned. The data pointer can be restored to the actual (boxed) closure in the/// `extern "C"` callback proxy with `get_su_callback`.get_su_callback/// Converts void single-use-callback closure pointer back to real type./// Returns ownership of the closure, thus it can be destroyed after use.ItemRawcallback_for_list_instance/// Used by list-iteration style callback proxies, which are single use, but make multiple/// executions of the callback, once per item and once to signal end-of-list.// Converter, from raw item pointer to item wrapper// Copyright 2018 Lyndon Brown// This file is part of the PulseAudio Rust language binding.// Licensed under the MIT license or the Apache license (version 2.0), at your option. You may not// copy, modify, or distribute this file except in compliance with said license. You can find copies// of these licenses either in the LICENSE-MIT and LICENSE-APACHE files, or alternatively at// <http://opensource.org/licenses/MIT> and <http://www.apache.org/licenses/LICENSE-2.0>// respectively.// Portions of documentation are copied from the LGPL 2.1+ licensed PulseAudio C headers on a// fair-use basis, as discussed in the overall project readme (available in the git repository).//! Callback handling.pa_channel_map_def_tMapDefPositionMaskpa_channel_position_mask_t/// A mask of channel positions.POSITION_MASK_ALL/// Position mask covering all positions./// Invalid./// Mono.FrontLeft/// Apple, Dolby call this ‘Left’.FrontRight/// Apple, Dolby call this ‘Right’.FrontCenter/// Apple, Dolby call this ‘Center’.RearCenter/// Microsoft calls this ‘Back Center’, Apple calls this ‘Center Surround’,/// Dolby calls this ‘Surround Rear Center’.RearLeft/// Microsoft calls this ‘Back Left’, Apple calls this ‘Left Surround’,/// Dolby calls this ‘Surround Rear Left’.RearRight/// Microsoft calls this ‘Back Right’, Apple calls this ‘Right Surround’,/// Dolby calls this ‘Surround Rear Right’./// Aka subwoofer. Microsoft calls this ‘Low Frequency’,/// Apple calls this ‘LFEScreen’.FrontLeftOfCenter/// Apple, Dolby call this ‘Left Center’.FrontRightOfCenter/// Apple, Dolby call this ‘Right Center’.SideLeft/// Apple calls this ‘Left Surround Direct’,/// Dolby calls this ‘Surround Left’.SideRight/// Apple calls this ‘Right Surround Direct’,/// Dolby calls this ‘Surround Right’.Aux0/// Auxillary 0.Aux1/// Auxillary 1.Aux2/// Auxillary 2.Aux3/// Auxillary 3.Aux4/// Auxillary 4.Aux5/// Auxillary 5.Aux6/// Auxillary 6.Aux7/// Auxillary 7.Aux8/// Auxillary 8.Aux9/// Auxillary 9.Aux10/// Auxillary 10.Aux11/// Auxillary 11.Aux12/// Auxillary 12.Aux13/// Auxillary 13.Aux14/// Auxillary 14.Aux15/// Auxillary 15.Aux16/// Auxillary 16.Aux17/// Auxillary 17.Aux18/// Auxillary 18.Aux19/// Auxillary 19.Aux20/// Auxillary 20.Aux21/// Auxillary 21.Aux22/// Auxillary 22.Aux23/// Auxillary 23.Aux24/// Auxillary 24.Aux25/// Auxillary 25.Aux26/// Auxillary 26.Aux27/// Auxillary 27.Aux28/// Auxillary 28.Aux29/// Auxillary 29.Aux30/// Auxillary 30.Aux31/// Auxillary 31.TopCenter/// Apple calls this ‘Top Center Surround’.TopFrontLeft/// Apple calls this ‘Vertical Height Left’.TopFrontRight/// Apple calls this ‘Vertical Height Right’.TopFrontCenter/// Apple calls this ‘Vertical Height Center’.TopRearLeft/// Microsoft and Apple call this ‘Top Back Left’.TopRearRight/// Microsoft and Apple call this ‘Top Back Right’.TopRearCenter/// Microsoft and Apple call this ‘Top Back Center’./* NOTE: This enum’s variants and variant values **must** remain identical to the `sys` crate
       (C API) equivalent */_IMPL_NUM_FromPrimitive_FOR_Position_IMPL_NUM_ToPrimitive_FOR_Position/// A list of channel labels./// Note, certain aliases, specifically `Left`, `Right`, `Center` and `Subwoofer`, available in the/// equivalent C enum are not provided here, since Rust does not allow aliases.pos_compare_capi/// Check is equal to `sys` equivalentpa_channel_position_t/* NOTE: This struct must be directly usable by the C API, thus same attributes/layout/etc *//// Number of channels mapped.CHANNELS_MAX/// Channel labels./// A channel map which can be used to attach labels to specific channels of a stream./// These values are relevant for conversion and mixing of streams.map_compare_capi/// Test size is equal to `sys` equivalentpa_channel_mapto_mask/// Makes a bit mask from a channel position./// Gets a text label for the specified channel position.to_pretty_string/// Gets a human readable text label for the specified channel position./// Creates a new instance from a string representation, as given by/// [`to_string()`](Self::to_string)./// Maximum number of allowed channels.new_from_string/// Parses a channel position list or well-known mapping name into a channel map structure./// This turns the output of [`print()`](Self::print) and [`to_name()`](Self::to_name) back into/// a `Map`./// Initializes the specified channel map and returns a pointer to it./// The map will have a defined state but [`is_valid()`](Self::is_valid) will fail for it.init_mono/// Initializes the specified channel map for monaural audio and returns a pointer to it.init_stereo/// Initializes the specified channel map for stereophonic audio and returns a pointer to it.init_auto/// Initializes the specified channel map for the specified number of channels using default/// labels and returns a pointer to it./// This call will fail (return `None`) if there is no default channel map known for this/// specific number of channels and mapping.init_extend/// Similar to [`init_auto()`](Self::init_auto) but instead of failing if no default mapping is/// known with the specified parameters it will synthesize a mapping based on a known mapping/// with fewer channels and fill up the rest with AUX0...AUX31 channels./// Checks whether or not the map is considered valid./// Gets the number of active channels./// Sets the number of active channels./// Positions for up to [`Self::CHANNELS_MAX`] channels can be held. This sets the portion of/// the internal array considered “active” and thus available for reading/writing (i.e. when/// borrowing `self` as a slice)./// **Panics** if the number of channels specified is greater than [`Self::CHANNELS_MAX`]./// Gets an immutable slice of the set of “active” channels./// Gets a mutable slice of the set of “active” channels./// Makes a human readable string from the map.is_compatible_with_sample_spec/// Checks whether or not the specified map is compatible with the specified sample spec.is_superset_of/// Checks whether every channel defined in `of` is also defined in self.can_balance/// Checks whether or not it makes sense to apply a volume “balance” with this mapping, i.e. if/// there are left/right channels available.can_fade/// Checks whether or not it makes sense to apply a volume “fade” (i.e. “balance” between front/// and rear) with this mapping, i.e. if there are front/rear channels available.can_lfe_balance/// Checks whether or not it makes sense to apply a volume “LFE balance” (i.e. “balance” between/// LFE and non-LFE channels) with this mapping, i.e. if there are LFE and non-LFE channelsto_name/// Tries to find a well-known channel mapping name for this channel mapping, i.e. “stereo”,/// “surround-71” and so on. This name can be parsed with/// [`new_from_string()`](Self::new_from_string).to_pretty_name/// Similar to [`to_name()`](Self::to_name), but returning prettier, human readable text labels,/// i.e. “Stereo”, “Surround 7.1” and so on.has_position/// Checks whether or not the specified channel position is available at least once in the map./// Generates a bit mask from a map.// Copyright 2017 Lyndon Brown//! Constants and routines for handing channel mapping.//! Channel maps provide a way to associate channels in a stream with a specific speaker position.//! This relieves applications of having to make sure their channel order is identical to the final//! # Initialisation//! A channel map consists of an array of [`Position`] values, one for each channel. This array is//! stored together with a channel count in a [`Map`] structure.//! Before filling the structure, the application must initialise it using [`Map::init()`]. There//! are also a number of convenience functions for standard channel mappings://! * [`Map::init_mono()`]: Create a channel map with only mono audio.//! * [`Map::init_stereo()`]: Create a standard stereo mapping.//! * [`Map::init_auto()`]: Create a standard channel map for a specific number of channels.//! * [`Map::init_extend()`]: Similar to [`Map::init_auto()`] but synthesize a channel map if no//!   predefined one is known for the specified number of channels.pa_ext_device_manager_infoInfoInternalpa_ext_device_manager_role_priority_infoRolePriorityInfoInternalContextInternal/// Role name/// PriorityRolePriorityInfo/// Role priority information.new_from_raw/// Identifier string of the device. A string like “sink:” or similar followed by the name of/// the device./// The description of the device when it was last seen, if applicable and saved./// The icon given to the device./// The device index if it is currently available or `None` if invalid.role_priorities/// A set of role priority structures./// Stores information about one device in the device database that is maintained by/// module-device-manager.cb_ptrsCallbackPointers/// Multi-use callback closure pointers/// A wrapper object providing device manager routines to a context./// Note: Saves a copy of active multi-use closure callbacks, which it frees on drop.ExtSubscribeCb/// Holds copies of callback closure pointers, for those that are “multi-use” (may be fired multiple/// times), for freeing at the appropriate time./// Gets a device manager object linked to the current context, giving access to device manager/// routines./// See [`context::ext_device_manager`](mod@crate::context::ext_device_manager)./// Creates a new `DeviceManager` from an existing [`ContextInternal`] pointer./// Tests if this extension module is available in the server./// Panics if the underlying C function returns a null pointer./// Reads all entries from the device database.set_device_description/// Sets the description for a device./// The callback must accept a `bool`, which indicates success./// Deletes entries from the device database.enable_role_device_priority_routing/// Enables the role-based device-priority routing mode.reorder_devices_for_role/// Reorders the position of a given device in the priority list to give preference to it./// Subscribes to changes in the device database.set_subscribe_cb/// Sets the subscription callback that is called when [`subscribe()`](Self::subscribe) was/// called.read_list_cb_proxy/// Proxy for read list callbacks./// Warning: This is for list cases only! On EOL it destroys the actual closure callback.//! Routines for controlling module-device-manager.pa_ext_device_restore_infodtype/// Device type sink or source?/// The device index./// A set of formats.DeviceRestore/// A wrapper object providing device restore routines to a context.SubscribeCbdevice_restore/// Gets a device restore object linked to the current context, giving access to device restore/// See [`context::ext_device_restore`](mod@crate::context::ext_device_restore)./// Creates a new `DeviceRestore` from an existing [`ContextInternal`] pointer./// The callback must accept an integer, which indicates version./// The callback must accept two parameters, firstly a [`Device`] variant, and secondly an/// integer index./// [`Device`]: crate::def::Deviceread_formats_all/// Reads the formats for all present devices from the device database.read_formats/// Reads an entry from the device database.save_formatsext_subscribe_cb_proxy/// Proxy for the extension subscribe callback./// Warning: This is for multi-use cases! It does **not** destroy the actual closure callback, which/// must be accomplished separately to avoid a memory leak./// Warning: This is for list cases only! On EOL or error it destroys the actual closure callback.//! Routines for controlling module-device-restore.pa_ext_stream_restore_info/// Identifier string of the stream. A string like “sink-input-by-role:” or similar followed by/// some arbitrary property value./// The channel map for the volume field, if applicable./// The volume of the stream when it was seen last, if applicable and saved./// The sink/source of the stream when it was last seen, if applicable and saved./// The boolean mute state of the stream when it was last seen, if applicable and saved./// Stores information about one entry in the stream database that is maintained by/// module-stream-restore.StreamRestore/// A wrapper object providing stream restore routines to a context.stream_restore/// Gets a stream restore object linked to the current context, giving access to stream restore/// See [`context::ext_stream_restore`](mod@crate::context::ext_stream_restore)./// Creates a new `StreamRestore` from an existing [`ContextInternal`] pointer./// Reads all entries from the stream database.UpdateMode/// Stores entries in the stream database./// Deletes entries from the stream database./// Subscribes to changes in the stream database.//! Routines for controlling module-stream-restore.pa_sink_port_infoSinkPortInfoInternalpa_sink_infoSinkInfoInternalpa_source_port_infoSourcePortInfoInternalpa_source_infoSourceInfoInternalpa_server_infoServerInfoInternalpa_module_infoModuleInfoInternalpa_client_infoClientInfoInternalpa_card_profile_info2CardProfileInfoInternalpa_card_port_infoCardPortInfoInternalpa_card_infoCardInfoInternalpa_sink_input_infoSinkInputInfoInternalpa_source_output_infoSourceOutputInfoInternalpa_sample_infoSampleInfoInternalpa_stat_infoStatInfo/// A wrapper object providing introspection routines to a context./// Gets an introspection object linked to the current context, giving access to introspection/// See [`context::introspect`](mod@crate::context::introspect)./// Creates a new `Introspector` from an existing [`ContextInternal`] pointer./// Name of this port./// Description of this port./// Stores information about a specific port of a sink./// Please note that this structure can be extended as part of evolutionary API updates at any time/// in any new release.monitor_sourcemonitor_source_name/// Pointer to active port in the set, or `None`./// Stores information about sinks.get_sink_info_by_name/// Gets information about a sink by its name./// Panics on error, i.e. invalid arguments or state.get_sink_info_by_index/// Gets information about a sink by its index.get_sink_info_list/// Gets the complete sink list.set_sink_volume_by_index/// Sets the volume of a sink device specified by its index./// The optional callback must accept a `bool`, which indicates success.set_sink_volume_by_name/// Sets the volume of a sink device specified by its name.set_sink_mute_by_index/// Sets the mute switch of a sink device specified by its index.set_sink_mute_by_name/// Sets the mute switch of a sink device specified by its name.suspend_sink_by_name/// Suspends/Resumes a sink.suspend_sink_by_index/// If `index` is [`def::INVALID_INDEX`] all sinks will be suspended.set_sink_port_by_index/// Changes the profile of a sink.set_sink_port_by_nameget_sink_info_list_cb_proxy/// Proxy for get sink info list callbacks./// Stores information about a specific port of a source./// Name of the source./// Index of the source./// Description of this source./// Sample spec of this source./// Owning module index, or `None`./// Volume of the source.monitor_of_sink/// If this is a monitor source, the index of the owning sink, otherwise `None`.monitor_of_sink_name/// Name of the owning sink, or `None`./// Length of filled record buffer of this source./// the input device./// Number of volume steps for sources which do not support arbitrary volumes./// Card index, or `None`./// Stores information about sources.get_source_info_by_name/// Gets information about a source by its name.get_source_info_by_index/// Gets information about a source by its index.get_source_info_list/// Gets the complete source list.set_source_volume_by_index/// Sets the volume of a source device specified by its index.set_source_volume_by_name/// Sets the volume of a source device specified by its name.set_source_mute_by_index/// Sets the mute switch of a source device specified by its index.set_source_mute_by_name/// Sets the mute switch of a source device specified by its name.suspend_source_by_name/// Suspends/Resumes a source.suspend_source_by_index/// If `index` is [`def::INVALID_INDEX`], all sources will be suspended.set_source_port_by_index/// Changes the profile of a source.set_source_port_by_nameget_source_info_list_cb_proxy/// Proxy for get source info list callbacks./// Server information./// Gets some information about the server.get_server_info_cb_proxy/// Proxy for get server info callbacks./// Warning: This is for single-use cases only! It destroys the actual closure callback./// Index of the module./// Name of the module./// Argument string of the module.n_used/// Usage counter or `None` if invalid.ModuleInfo/// Stores information about modules.get_module_info/// Gets some information about a module by its index.get_module_info_list/// Gets the complete list of currently loaded modules.load_module/// Loads a module./// Panics on error, i.e. invalid arguments or state. The callback is provided with theunload_module/// Unloads a module.mod_info_list_cb_proxy/// Proxy for get module info list callbacks.context_index_cb_proxy/// Proxy for context index callbacks./// Index of this client./// Name of this client./// Index of the owning module, or `None`.ClientInfo/// Stores information about clients.get_client_info/// Gets information about a client by its index.get_client_info_list/// Gets the complete client list.kill_client/// Kills a client.get_client_info_list_cb_proxyCardProfileInfo2CardProfileInfo/// Backwards compatable alias/// Name of this profile./// Description of this profile.n_sinks/// Number of sinks this profile would create.n_sources/// Number of sources this profile would create./// The higher this value is, the more useful this profile is as a default./// Is this profile available? If this is `false`, meaning “unavailable”, then it makes no sense/// to try to activate this profile. If this is `true`, it’s still not a guarantee that/// activating the profile will result in anything useful, it just means that the server isn’t/// aware of any reason why the profile would definitely be useless./// Stores information about a specific profile of a card./// Availability status of this port.FlagSet/// The direction of this port.latency_offset/// Latency offset of the port that gets added to the sink/source latency when the port isprofiles/// Set of available profiles.CardPortInfo/// Stores information about a specific port of a card./// Index of this card./// Name of this card./// Set of ports.active_profile/// Pointer to active profile in the set, or `None`.CardInfo/// Stores information about cards.get_card_info_by_index/// Gets information about a card by its index.get_card_info_by_name/// Gets information about a card by its name.get_card_info_list/// Gets the complete card list.set_card_profile_by_index/// Changes the profile of a card.set_card_profile_by_nameset_port_latency_offset/// Sets the latency offset of a port.get_card_info_list_cb_proxy/// Proxy for get card info list callbacks./// Index of the connected sink./// Latency due to buffering in sink input, see [`TimingInfo`](crate::def::TimingInfo) forsink_usec/// Latency of the sink device, see [`TimingInfo`](crate::def::TimingInfo) for details./// Stream has volume. If not set, then the meaning of this struct’s volume member is/// unspecified./// Stores information about sink inputs.get_sink_input_info/// Gets some information about a sink input by its index.get_sink_input_info_list/// Gets the complete sink input list.move_sink_input_by_name/// Moves the specified sink input to a different sink.move_sink_input_by_indexset_sink_input_volume/// Sets the volume of a sink input stream.set_sink_input_mute/// Sets the mute switch of a sink input stream.kill_sink_input/// Kills a sink input.get_sink_input_info_list_cb_proxy/// Proxy for get sink input info list callbacks./// Index of the source output./// Name of the source output./// Index of the module this source output belongs to, or `None` when it does not belong to any/// Index of the client this source output belongs to, or `None` when it does not belong to any/// Index of the connected source./// The sample specification of the source output./// Latency due to buffering in the source output, see [`TimingInfo`](crate::def::TimingInfo)source_usec/// Latency of the source device, see [`TimingInfo`](crate::def::TimingInfo) for details./// The resampling method used by this source output./// The volume of this source output./// Stores information about source outputs.get_source_output_info/// Gets information about a source output by its index.get_source_output_info_list/// Gets the complete list of source outputs.move_source_output_by_name/// Moves the specified source output to a different source.move_source_output_by_indexset_source_output_volume/// Sets the volume of a source output stream.set_source_output_mute/// Sets the mute switch of a source output stream.kill_source_output/// Kills a source output.get_source_output_info_list_cb_proxy/// Proxy for get source output info list callbacks./// Gets daemon memory block statistics.get_stat_info_cb_proxy/// Proxy for get stat info callbacks./// Index of this entry./// Name of this entry./// Default volume of this entry./// Sample specification of the sample./// The channel map./// Duration of this entry./// Length of this sample in bytes./// Non-zero when this is a lazy cache entry./// In case this is a lazy cache entry, the filename for the sound file to be loaded on demand./// Property list for this sample.SampleInfo/// Stores information about sample cache entries.get_sample_info_by_name/// Gets information about a sample by its name.get_sample_info_by_index/// Gets information about a sample by its index.get_sample_info_list/// Gets the complete list of samples stored in the daemon.get_sample_info_list_cb_proxy/// Proxy for get sample info list callbacks.//! Routines for daemon introspection.//! Sometimes it is necessary to query and modify global settings in the server. For this,//! PulseAudio has the introspection API. It can list sinks, sources, samples and other aspects of//! the server. It can also modify the attributes of the server that will affect operations on a//! global level, and not just the application’s context.//! The introspection routines are exposed as methods on an [`Introspector`] object held by the//! [`Context`] object, and can be accessed via the [`Context::introspect()`] method.//! # Querying//! All querying is done through callbacks. This approach is necessary to maintain an asynchronous//! design. The client will request the information and some time later, the server will respond//! with the desired data.//! Some objects can have multiple instances on the server. When requesting all of these at once,//! the callback will be called multiple times, each time with an [`ListResult`] variant. It will be//! called once for each item in turn, using the `Item` variant, and then once more time with the//! `End` variant to signal that the end of the list has been reached. If an error occurs, then//! the `Error` variant will be given.//! Note that even if a single object is requested, and not the entire list, the terminating call//! will still be made.//! Data members in the information structures are only valid during the duration of the callback.//! If they are required after the callback is finished, a deep copy of the information structure//! must be performed.//! # Server Information//! The server can be queried about its name, the environment it’s running on and the currently//! active global defaults. Calling [`Introspector::get_server_info()`] provides access to a//! [`ServerInfo`] structure containing all of these.//! # Memory Usage//! Statistics about memory usage can be fetched using [`Introspector::stat()`], giving a//! [`StatInfo`] structure.//! # Sinks and Sources//! The server can have an arbitrary number of sinks and sources. Each sink and source have both an//! index and a name associated with it. As such, there are three ways to get access to them://! * By index: [`Introspector::get_sink_info_by_index()`],//!   [`Introspector::get_source_info_by_index()`]//! * By name: [`Introspector::get_sink_info_by_name()`],//!   [`Introspector::get_source_info_by_name()`]//! * All: [`Introspector::get_sink_info_list()`], [`Introspector::get_source_info_list()`]//! All three methods use the same callback and will provide a [`SinkInfo`] or [`SourceInfo`]//! structure.//! # Sink Inputs and Source Outputs//! Sink inputs and source outputs are the representations of the client ends of streams inside the//! server. I.e. they connect a client stream to one of the global sinks or sources.//! Sink inputs and source outputs only have an index to identify them. As such, there are only two//! ways to get information about them://! * By index: [`Introspector::get_sink_input_info()`], [`Introspector::get_source_output_info()`]//! * All: [`Introspector::get_sink_input_info_list()`],//!   [`Introspector::get_source_output_info_list()`]//! The structure returned is the [`SinkInputInfo`] or [`SourceOutputInfo`] structure.//! # Samples//! The list of cached samples can be retrieved from the server. Three methods exist for querying//! the sample cache list://! * By index: [`Introspector::get_sample_info_by_index()`]//! * By name: [`Introspector::get_sample_info_by_name()`]//! * All: [`Introspector::get_sample_info_list()`]//! Note that this only retrieves information about the sample, not the sample data itself.//! # Driver Modules//! PulseAudio driver modules are identified by index and are retrieved using either//! [`Introspector::get_module_info()`] or [`Introspector::get_module_info_list()`]. The information//! structure is called [`ModuleInfo`].//! # Clients//! PulseAudio clients are also identified by index and are retrieved using either//! [`Introspector::get_client_info()`] or [`Introspector::get_client_info_list()`]. The information//! structure is called [`ClientInfo`].//! # Control//! Some parts of the server are only possible to read, but most can also be modified in different//! ways. Note that these changes will affect all connected clients and not just the one issuing the//! request.//! The most common change one would want to apply to sinks and sources is to modify the volume of//! the audio. Identically to how sinks and sources can be queried, there are two ways of//! identifying them://! * By index: [`Introspector::set_sink_volume_by_index()`],//!   [`Introspector::set_source_volume_by_index()`]//! * By name: [`Introspector::set_sink_volume_by_name()`],//!   [`Introspector::set_source_volume_by_name()`]//! It is also possible to mute a sink or source://! * By index: [`Introspector::set_sink_mute_by_index()`],//!   [`Introspector::set_source_mute_by_index()`]//! * By name: [`Introspector::set_sink_mute_by_name()`],//!   [`Introspector::set_source_mute_by_name()`]//! If an application desires to modify the volume of just a single stream (commonly one of its own//! streams), this can be done by setting the volume of its associated sink input or source output,//! using [`Introspector::set_sink_input_volume()`] or [`Introspector::set_source_output_volume()`].//! It is also possible to remove sink inputs and source outputs, terminating the streams associated//! with them://! * Sink input: [`Introspector::kill_sink_input()`]//! * Source output: [`Introspector::kill_source_output()`]//! It is strongly recommended that all volume changes are done as a direct result of user input.//! With automated requests, such as those resulting from misguided attempts of crossfading,//! PulseAudio can store the stream volume at an inappropriate moment and restore it later. Besides,//! such attempts lead to OSD popups in some desktop environments.//! As a special case of the general rule above, it is recommended that your application leaves the//! task of saving and restoring the volume of its streams to PulseAudio and does not attempt to do//! it by itself. PulseAudio really knows better about events such as stream moving or headphone//! plugging that would make the volume stored by the application inapplicable to the new//! configuration.//! Another important case where setting a sink input volume may be a bad idea is related to//! interpreters that interpret potentially untrusted scripts. PulseAudio relies on your application//! not making malicious requests (such as repeatedly setting the volume to 100%). Thus, script//! interpreters that represent a security boundary must sandbox volume-changing requests coming//! from their scripts. In the worst case, it may be necessary to apply the script-requested volume//! to the script-produced sounds by altering the samples in the script interpreter and not touching//! the sink or sink input volume as seen by PulseAudio.//! If an application changes any volume, it should also listen to changes of the same volume//! originating from outside the application (e.g., from the system mixer application) and update//! its user interface accordingly. Use [`Context::subscribe()`] to get such notifications.//! # Modules//! Server modules can be remotely loaded and unloaded using [`Introspector::load_module()`] and//! [`Introspector::unload_module()`].//! # Messages//! Server objects like sinks, sink inputs or modules can register a message handler to communicate//! with clients. A message can be sent to a named message handler using//! [`Introspector::send_message_to_object()`].//! The only operation supported on clients is the possibility of kicking them off the server using//! [`Introspector::kill_client()`].////////////////////////////////////////////////////////////////////////////////////////////////////// Sink info// Source info// Server info// Module info// Messages// Client info// Card info// Sink input info// Source output info// Stat info// Sample infoext_device_managerext_device_restoreext_stream_restorescacheMainloopInnerTypeTimeEventTimeEventRefMonotonicTsProplistInternalpa_context/// The actual C object.weak/// Used to avoid freeing the internal object when used as a weak wrapper in callbacks./// Multi-use callback closure pointers./// An opaque connection context to a daemon.NotifyCbEventCbUnconnected/// The context hasn’t been connected yet./// A connection is being established.Authorizing/// The client is authorizing itself to the daemon.SettingName/// The client is passing its application name to the daemon./// The connection is established, the context is ready to execute operations./// The connection failed or was disconnected./// The connection was terminated cleanly._IMPL_NUM_FromPrimitive_FOR_State_IMPL_NUM_ToPrimitive_FOR_State/// The state of a connection context.state_compare_capipa_context_state_tis_good/// Checks if the passed state is one of the connected states (returns `true` if so).r" Context flag set."r" No flags set."NOFLAGSr" Disable autospawning of the PulseAudio daemon if required."NOAUTOSPAWNr" Don’t fail if the daemon is not available when [`Context::connect()`] is called, instead"r" enter [`State::Connecting`] state and wait for the daemon to appear."NOFAIL/// No flags set./// Disable autospawning of the PulseAudio daemon if required./// Don’t fail if the daemon is not available when [`Context::connect()`] is called, instead/// enter [`State::Connecting`] state and wait for the daemon to appear./// [`Context::connect()`]: super::Context::connect/// [`State::Connecting`]: super::State::Connecting/// Some special flags for contexts./// Instantiates a new connection context with an abstract mainloop API and an application name./// It is recommended to use [`new_with_proplist()`](Self::new_with_proplist) instead and/// specify some initial properties./// Note, this will fail either should the underlying C API call return a null pointer for some/// reason, or if the version of the PulseAudio client system library at runtime is found to be/// older than the minimum version set via this crate’s feature flags (as a means to help/// prevent “forward” compatibility problems, as discussed in the project `COMPATIBILITY.md`/// documentation).new_with_proplist/// Instantiates a new connection context with an abstract mainloop API and an application name,/// and specify the initial client property list./// Internal common creation function/// Creates a new `Context` from an existing [`ContextInternal`] pointer.set_state_callback/// Sets a callback function that is called whenever the context status changes.set_event_callback/// Sets a callback function that is called whenever a meta/policy control event is received./// The callback is given a name which represents what event occurred. The set of defined events/// can be extended at any time. Also, server modules may introduce additional message types so/// make sure that your callback function ignores messages it doesn’t know. It is also given an/// (owned) property list./// Gets the error number of the last failed operation.is_pending/// Checks if some data is pending to be written to the connection (returns `true` if so)./// Gets the current context status.SpawnApi/// Connects the context to the specified server./// If server is `None`, connect to the default server. This routine may but will not always/// return synchronously on error. Use [`set_state_callback()`] to be notified when the/// connection is established. If `flags` doesn’t have [`FlagSet::NOAUTOSPAWN`] set and no/// specific server is specified or accessible, a new daemon is spawned. If `api` is not `None`,/// the functions specified in the structure are used when forking a new child process./// [`set_state_callback()`]: Self::set_state_callback/// Terminates the context connection immediately./// Drains the context./// If there is nothing to drain, the function returns `None`./// Note that it can also return `None` under other conditions. Many functions in the C API/// perform internal state validation checks and return a null pointer if they detect a problem,/// just as they return a null pointer on invalid input. Other functions panic on getting a null/// pointer return, however this function is unique in a null pointer also signalling something/// useful, and it is not possible to tell the difference. However, while I feel the need to be/// clear about the possibility, I believe that such invalid state conditions should only occur/// if there were a serious bug within PA, thus you are probably safe to just ignore this and/// always take a `None` return to indicate only that there is nothing to drain.exit_daemon/// Tells the daemon to exit./// The returned operation is unlikely to complete successfully, since the daemon probably died/// before returning a success notification.set_default_sink/// Sets the name of the default sink./// Sets the name of the default source./// Checks if this is a connection to a local daemon./// Returns `true` when the connection is to a local daemon. Returns `None` on error, for/// instance when no connection has been made yet./// Sets a different application name for context on the server.get_server/// Gets the server name this context is connected to.get_protocol_version/// Gets the protocol version of the library.get_server_protocol_version/// Gets the protocol version of the connected server./// Returns `None` on error.proplist_update/// Updates the property list of the client, adding new entries./// Please note that it is highly recommended to set as many properties initially via/// [`new_with_proplist()`](Self::new_with_proplist) as possible instead a posteriori with this/// function, since that information may then be used to route streams of the client to the/// right device.proplist_remove/// Updates the property list of the client, remove entries./// Gets the client index this context is identified in the server with./// This is useful for usage with the introspection functions, such as/// [`Introspector::get_client_info()`](self::introspect::Introspector::get_client_info).rttime_newMI/// Creates a new timer event source for the specified time./// This is an alternative to the mainloop `new_timer_event_rt` method./// A reference to the mainloop object is needed, in order to associate the event object with/// it. The association is done to ensure the event does not outlive the mainloop./// If pointer returned by underlying C function is `NULL`, `None` will be returned, otherwise a/// [`TimeEvent`](crate::mainloop::events::timer::TimeEvent) object will be returned./// Example event set to fire in five seconds time:/// use libpulse_binding::time::{MonotonicTs, MicroSeconds};/// let _t_event = context.rttime_new::<Mainloop, _>(&mainloop,///     MonotonicTs::now() + MicroSeconds::from_secs(5).unwrap(),///     |_| { println!("Timer event fired!"); });/// **Note**: You must ensure that the returned event object lives for as long as you want its/// event(s) to fire, as its `Drop` implementation destroys the event source. I.e. if you create/// a new event, but then immediately drop the object returned here, no event will fire!get_tile_size/// Gets the optimal block size for passing around audio buffers./// It is recommended to allocate buffers of the size returned here when writing audio data to/// playback streams, if the latency constraints permit this. It is not recommended writing/// larger blocks than this because usually they will then be split up internally into chunks of/// this size. It is not recommended writing smaller blocks than this (unless required due to/// latency demands) because this increases CPU usage./// If `ss` is `None` you will be returned the byte-exact tile size./// If `ss` is invalid, returns `None`, else returns tile size rounded down to multiple of the/// frame size./// This is supposed to be used in a construct such as:/// let ss = stream.get_sample_spec().unwrap();/// let size = context.get_tile_size(Some(ss)).unwrap();load_cookie_from_file/// Loads the authentication cookie from a file./// This function is primarily meant for PulseAudio’s own tunnel modules, which need to load the/// cookie from a custom location. Applications don’t usually need to care about the cookie at/// all, but if it happens that you know what the authentication cookie is and your application/// needs to load it from a non-standard location, feel free to use this function.success_cb_proxy/// Proxy for completion success callbacks.notify_cb_proxy_single/// Proxy for notification callbacks (single use).notify_cb_proxy_multi/// Proxy for notification callbacks (multi use).event_cb_proxy/// Proxy for event callbacks.ext_test_cb_proxy/// Proxy for extension test callbacks./// Proxy for extension subscribe callbacks.//! Connection contexts for asynchronous communication with a server.//! A `Context` object wraps a connection to a PulseAudio server using its native protocol.//! A context is the basic object for a connection to a PulseAudio server. It multiplexes commands,//! data streams and events through a single channel.//! There is no need for more than one context per application, unless connections to multiple//! servers are needed.//! # Operations//! All operations on the context are performed asynchronously. I.e. the client will not wait for//! the server to complete the request. To keep track of all these in-flight operations, the//! application is given an [`Operation`] object for each asynchronous operation.//! There are only two actions (besides reference counting) that can be performed on an//! [`Operation`]: querying its state with [`Operation::get_state()`] and aborting it with//! [`Operation::cancel()`].//! An [`Operation`] object is reference counted, so an application must make sure to unreference//! it, even if it has no intention of using it. This however is taken care of automatically in this//! Rust binding via the implementation of the `Drop` trait on the object.//! # Connecting//! A context must be connected to a server before any operation can be issued. Calling//! [`Context::connect()`] will initiate the connection procedure. Unlike most asynchronous//! operations, connecting does not result in an [`Operation`] object. Instead, the application//! should register a callback using [`Context::set_state_callback()`].//! # Disconnecting//! When the sound support is no longer needed, the connection needs to be closed using//! [`Context::disconnect()`]. This is an immediate function that works synchronously.//! Since the context object has references to other objects it must be disconnected after use or//! there is a high risk of memory leaks. If the connection has terminated by itself, then there is//! no need to explicitly disconnect the context using [`Context::disconnect()`].//! # Functions//! The sound server’s functionality can be divided into a number of subsections://! * [`stream`](mod@crate::stream)//! * [`context::scache`](mod@crate::context::scache)//! * [`context::introspect`](mod@crate::context::introspect)//! * [`context::subscribe`](mod@crate::context::subscribe)remove_sample/// Removes a sample from the sample cache./// Returns an operation object which may be used to cancel the operation while it is running.play_sample/// Plays a sample from the sample cache to the specified device./// If the specified device is `None` use the default sink./// # Params/// * `name`: Name of the sample to play./// * `dev`: Sink to play this sample on, or `None` for default./// * `volume`: Volume to play this sample with, or `None` to leave the decision about the///   volume to the server side which is a good idea. [`Volume::INVALID`] has the same meaning///   as `None./// * `callback`: Optional success callback. It must accept a `bool`, which indicates success.play_sample_with_proplist/// Plays a sample from the sample cache to the specified device, allowing specification of a/// property list for the playback stream./// If the device is `None` use the default sink./// * `proplist`: Property list for this sound. The property list of the cached entry will have///   this merged into it./// * `callback`: Optional success callback. It must accept an `u32` index value wrapper in a///   `Result`. The index is the index of the sink input object. `Err` is given instead on///   failure.play_sample_success_cb_proxy//! Sample cache mechanism.//! The sample cache provides a simple way of overcoming high network latencies and reducing//! bandwidth. Instead of streaming a sound precisely when it should be played, it is stored on the//! server and only the command to start playing it needs to be sent.//! # Creation//! To create a sample, the normal stream API is used (see [`stream`]). The function//! [`Stream::connect_upload()`] will make sure the stream is stored as a sample on the server.//! To complete the upload, [`Stream::finish_upload()`] is called and the sample will receive the//! same name as the stream. If the upload should be aborted, simply call [`Stream::disconnect()`].//! # Playing samples//! To play back a sample, simply call [`Context::play_sample()`]://! extern crate libpulse_binding as pulse;//! use pulse::volume;//! //...//! let o = my_context.play_sample(//!     "sample2",            // Name of my sample//!     None,                 // Use default sink//!     volume::VOLUME_NORM,  // Full volume//!     None                  // Don’t need a callback//! # Removing samples//! When a sample is no longer needed, it should be removed on the server to save resources. The//! sample is deleted using [`Context::remove_sample()`].//! [`stream`]: mod@crate::stream//! [`Stream::connect_upload()`]: crate::stream::Stream::connect_upload//! [`Stream::finish_upload()`]: crate::stream::Stream::finish_upload//! [`Stream::disconnect()`]: crate::stream::Stream::disconnectpa_subscription_event_type_tFACILITY_MASK/// Mask to extract facility value from the event type passed to the user callback.OPERATION_MASK/// Mask to extract operation value from the event type passed to the user callback.r" A set of facility masks, to be passed to [`Context::subscribe()`]."r" Note that you can convert a [`Facility`] to a mask with [`Facility::to_interest_mask()`]."InterestMaskSetr" No facility (null selection; zero)."r" Sink facility."r" Source facility."r" Sink input facility."SINK_INPUTr" Source output facility."SOURCE_OUTPUTr" Module facility."MODULEr" Client facility."CLIENTr" Sample cache facility."SAMPLE_CACHEr" Server facility."r" Card facility."CARDr" All facilities."/// No facility (null selection; zero)./// Sink facility./// Source facility./// Sink input facility./// Source output facility./// Module facility./// Client facility./// Sample cache facility./// Server facility.MASK_CARD/// Card facility./// All facilities.subscription_masks/// A set of masks used for expressing which facilities you are interested in when subscribing.Facility/// Sink./// Source.SinkInput/// Sink-input.SourceOutput/// Source-output./// Module./// Client.SampleCache/// Sample-cache./// Global server change, only occurring with [`Operation::Changed`].Card/* NOTE: value `8` previously assigned, obsoleted *//// Card._IMPL_NUM_FromPrimitive_FOR_Facility_IMPL_NUM_ToPrimitive_FOR_Facility/// Facility component of an event./// A new object was created/// A property of the object was modified/// An object was removed_IMPL_NUM_FromPrimitive_FOR_Operation_IMPL_NUM_ToPrimitive_FOR_Operation/// Operation component of an event.to_interest_mask/// Converts to an interest mask./// Enables event notification./// The `mask` parameter is used to specify which facilities you are interested in being/// modified about. Use [`set_subscribe_callback()`] to set the actual callback that will be/// called when an event occurs./// [`set_subscribe_callback()`]: Self::set_subscribe_callbackset_subscribe_callback/// Sets the context specific call back function that is called whenever a subscribed-to event/// occurs./// Use [`subscribe()`] to set the facilities you are interested in receiving notifications for,/// and thus to start receiving notifications with the callback set here./// The callback must take three parameters. The first two are the facility and operation/// components of the event type respectively (the underlying C API provides this information/// combined into a single integer, here we extract the two component parts for you); these are/// wrapped in `Option` wrappers should the given values ever not map to the enum variants, but/// it’s probably safe to always just `unwrap()` them). The third parameter is an associated/// index value./// [`subscribe()`]: Self::subscribecb_proxy/// Proxy for callbacks.//! Daemon introspection event subscription subsystem.//! The application can be notified, asynchronously, whenever the internal layout of the server//! changes. The set of facilities and operations for which notifications are generated are//! enumerated in [`Facility`] and [`Operation`].//! The application sets the notification mask using [`Context::subscribe()`] and the callback//! function that will be called whenever a notification occurs using//! [`Context::set_subscribe_callback()`].//! The mask provided to [`Context::subscribe()`] can be created by binary ORing a set of values,//! either produced with [`Facility::to_interest_mask()`], or more simply with the provided//! constants in the [`subscription_masks`](mod@subscription_masks) submodule.//! The callback will be called with event type information representing the event that caused the//! callback, detailing *facility* and *operation*, where for instance [`Facility::Source`] with//! [`Operation::New`] indicates that a new source was added.//! Subscribe (declare interest)://! use libpulse_binding::context::subscribe::subscription_masks;//! let interest = subscription_masks::SINK |//!     subscription_masks::SOURCE;//! let op = my_context.subscribe(//!     interest,   // Our interest mask//!     |_| {}      // We won’t bother doing anything in the success callback in this exampleUnixTsPA_INVALID_INDEXINVALID_INDEXpa_device_type_tpa_port_available_tpa_device_port_type_tDevicePortTypeFreeCb/// A callback type for releasing allocations.RetvalActual/// PulseAudio 'quit return value' type.Retval/// A wrapper around integer ‘quit return values’ returned by PulseAudio.maxlength/// Maximum length of the buffer in bytes./// Setting this to [`std::u32::MAX`] will initialize this to the maximum value supported by the/// server, which is recommended. In strict low-latency playback scenarios you might want to set/// this to a lower value, likely together with the [`stream::FlagSet::ADJUST_LATENCY`] flag. If/// you do so, you ensure that the latency doesn’t grow beyond what is acceptable for the use/// case, at the cost of getting more underruns if the latency is lower than what the server can/// reliably handle./// [`stream::FlagSet::ADJUST_LATENCY`]: crate::stream::FlagSet::ADJUST_LATENCYtlength/// Target length of the buffer (playback only). The server tries to assure that at least/// `tlength` bytes are always available in the per-stream server-side playback buffer. The/// server will only send requests for more data as long as the buffer has less than this number/// of bytes of data./// It is recommended to set this to [`std::u32::MAX`], which will initialize this to a value/// that is deemed sensible by the server. However, this value will default to something like/// 2s; for applications that have specific latency requirements this value should be set to/// the maximum latency that the application can deal with./// When [`stream::FlagSet::ADJUST_LATENCY`] is not set this value will influence only the/// per-stream playback buffer size. When [`stream::FlagSet::ADJUST_LATENCY`] is set, the/// overall latency of the sink plus the playback buffer size is configured to this value. Set/// [`stream::FlagSet::ADJUST_LATENCY`] if you are interested in adjusting the overall latency./// Don’t set it if you are interested in configuring the server-side per-stream playback buffer/// size.prebuf/// Pre-buffering (playback only). The server does not start with playback before at least/// `prebuf` bytes are available in the buffer. It is recommended to set this to/// [`std::u32::MAX`], which will initialize this to the same value as `tlength`, whatever that/// may be./// Initialize to `0` to enable manual start/stop control of the stream. This means that/// playback will not stop on underrun and playback will not start automatically, instead/// [`Stream::cork()`] needs to be called explicitly. If you set this value to `0` you should/// also set [`stream::FlagSet::START_CORKED`]. Should underrun occur, the read index of the/// output buffer overtakes the write index, and hence the fill level of the buffer is negative./// Start of playback can be forced using [`Stream::trigger()`] even though the prebuffer size/// hasn’t been reached. If a buffer underrun occurs, this prebuffering will be again enabled./// [`Stream::cork()`]: crate::stream::Stream::cork/// [`Stream::trigger()`]: crate::stream::Stream::trigger/// [`stream::FlagSet::START_CORKED`]: crate::stream::FlagSet::START_CORKEDminreq/// Minimum request (playback only). The server does not request less than `minreq` bytes from/// the client, instead it waits until the buffer is free enough to request more bytes at once./// that is deemed sensible by the server. This should be set to a value that gives PulseAudio/// enough time to move the data from the per-stream playback buffer into the hardware playbackfragsize/// Fragment size (recording only). The server sends data in blocks of `fragsize` bytes size./// Large values diminish interactivity with other operations on the connection context but/// decrease control overhead. It is recommended to set this to `std::u32::MAX`, which will/// initialize this to a value that is deemed sensible by the server. However, this value will/// default to something like 2s; For applications that have specific latency requirements this/// value should be set to the maximum latency that the application can deal with./// If [`stream::FlagSet::ADJUST_LATENCY`] is set the overall source latency will be adjusted/// according to this value. If it is not set the source latency is left unmodified.BufferAttr/// Playback and record buffer metrics.bufferattr_compare_capi/// Test size is equal to `sys` equivalent (duplicated here for different documentation)pa_buffer_attr/// The system clock time when this timing info structure was current.synchronized_clocks/// Non-zero if the local and the remote machine have synchronized clocks. If synchronized/// clocks are detected `transport_usec` becomes much more reliable. However, the code that/// detects synchronized clocks is very limited and unreliable itself./// Time in usecs a sample takes to be played on the sink. For playback streams and record/// streams connected to a monitor source./// Time in usecs a sample takes from being recorded to being delivered to the application. Only/// for record streams.transport_usec/// Estimated time in usecs a sample takes to be transferred to/from the daemon. For both/// playback and record streams.playing/// Non-zero when the stream is currently not underrun and data is being passed on to the/// device. Only for playback streams. This field does not say whether the data is actually/// already being played. To determine this check whether `since_underrun` (converted to usec)/// is larger than `sink_usec`.write_index_corrupt/// Non-zero if `write_index` is not up-to-date because a local write command that corrupted it/// has been issued in the time since this latency info was current. Only write commands with/// [`SeekMode::RelativeOnRead`] and [`SeekMode::RelativeEnd`] can corrupt `write_index`./// [`SeekMode::RelativeOnRead`]: crate::stream::SeekMode::RelativeOnRead/// [`SeekMode::RelativeEnd`]: crate::stream::SeekMode::RelativeEndwrite_index/// Current write index into the playback buffer in bytes./// Think twice before using this for seeking purposes: it might be out of date at the time you/// want to use it. Consider using [`SeekMode::Relative`] instead./// [`SeekMode::Relative`]: crate::stream::SeekMode::Relativeread_index_corrupt/// Non-zero if `read_index` is not up-to-date because a local pause or flush request that/// corrupted it has been issued in the time since this latency info was current.read_index/// Current read index into the playback buffer in bytes./// want to use it. Consider using [`SeekMode::RelativeOnRead`] instead.configured_sink_usec/// The configured latency for the sink.configured_source_usec/// The configured latency for the source.since_underrun/// Bytes that were handed to the sink since the last underrun happened, or since playback/// started again after the last underrun. `playing` will tell you which case it is.TimingInfo/// A structure for all kinds of timing information of a stream./// See [`Stream::update_timing_info()`] and [`Stream::get_timing_info()`]./// The total output latency a sample that is written with [`Stream::write()`] takes to be played/// may be estimated by:/// ``/// sink_usec + buffer_usec + transport_usec/// (Where `buffer_usec` is defined as the result of passing ``write_index - read_index`` to/// [`Spec::bytes_to_usec()`]). The output buffer which `buffer_usec` relates to may be manipulated/// freely (with [`Stream::write()`]’s `seek` argument, [`Stream::flush()`] and friends), the/// buffers `sink_usec` and `source_usec` relate to are first-in first-out (FIFO) buffers which/// cannot be flushed or manipulated in any way. The total input latency a sample that is recorded/// takes to be delivered to the application is:/// source_usec + buffer_usec + transport_usec - sink_usec/// (Take care of sign issues!). When connected to a monitor source `sink_usec` contains the latency/// of the owning sink. The two latency estimations described here are implemented in/// [`Stream::get_latency()`]./// All time values are in the sound card clock domain, unless noted otherwise. The sound card clock/// usually runs at a slightly different rate than the system clock./// [`Spec::bytes_to_usec()`]: crate::sample::Spec::bytes_to_usec/// [`Stream::update_timing_info()`]: crate::stream::Stream::update_timing_info/// [`Stream::get_timing_info()`]: crate::stream::Stream::get_timing_info/// [`Stream::write()`]: crate::stream::Stream::write/// [`Stream::flush()`]: crate::stream::Stream::flush/// [`Stream::get_latency()`]: crate::stream::Stream::get_latencytiminginfo_compare_capipa_timing_infoprefork/// Is called just before the fork in the parent process.postfork/// Is called immediately after the fork in the parent process.atfork/// Is called immediately after the fork in the child process./// It is not safe to close all file descriptors in this function unconditionally, since a UNIX/// socket (created using socketpair()) is passed to the new process./// A structure for the spawn API./// This may be used to integrate auto spawned daemons into your application. For more information/// see [`Context::connect()`]. When spawning a new child process the `waitpid()` is used on the/// child’s PID. The spawn routine will not block or ignore SIGCHLD signals, since this cannot be/// done in a thread compatible way. You might have to do this in prefork/postfork./// [`Context::connect()`]: crate::context::Context::connectspawnapi_compare_capipa_spawn_apir" Set of sink flags."r" Flag to pass when no specific options are needed."r" Supports hardware volume control. This is a dynamic flag and may change at runtime after"r" the sink has initialized."HW_VOLUME_CTRLr" Supports latency querying."LATENCYr" Is a hardware sink of some kind, in contrast to “virtual”/software sinks."HARDWAREr" Is a networked sink of some kind."NETWORKr" Supports hardware mute control. This is a dynamic flag and may change at runtime after"HW_MUTE_CTRLr" Volume can be translated to dB with the `From` based conversions between [`Volume`],"r" [`VolumeLinear`] and [`VolumeDB`] types. This is a dynamic flag and may change at"r" runtime after the sink has initialized."r" [`Volume`]: crate::volume::Volume"r" [`VolumeDB`]: crate::volume::VolumeDB"r" [`VolumeLinear`]: crate::volume::VolumeLinear"DECIBEL_VOLUMEr" This sink is in flat volume mode, i.e. always the maximum of the volume  of all"r" connected inputs."FLAT_VOLUMEr" The latency can be adjusted dynamically depending on the needs of the connected streams."DYNAMIC_LATENCYr" The sink allows setting what formats are supported by the connected hardware. The actual"r" functionality to do this might be provided by an extension."SET_FORMATS/// Flag to pass when no specific options are needed./// Supports hardware volume control. This is a dynamic flag and may change at runtime after the/// sink has initialized./// Supports latency querying./// Is a hardware sink of some kind, in contrast to “virtual”/software sinks./// Is a networked sink of some kind./// Supports hardware mute control. This is a dynamic flag and may change at runtime after the/// Volume can be translated to dB with the `From` based conversions between [`Volume`],/// [`VolumeLinear`] and [`VolumeDB`] types. This is a dynamic flag and may change at runtime/// after the sink has initialized./// [`Volume`]: crate::volume::Volume/// [`VolumeDB`]: crate::volume::VolumeDB/// [`VolumeLinear`]: crate::volume::VolumeLinear/// This sink is in flat volume mode, i.e. always the maximum of the volume  of all connected/// The latency can be adjusted dynamically depending on the needs of the connected streams./// The sink allows setting what formats are supported by the connected hardware. The actual/// functionality to do this might be provided by an extension.sink_flags/// Special sink flags._IMPL_NUM_FromPrimitive_FOR_SinkState_IMPL_NUM_ToPrimitive_FOR_SinkState/// Sink state.sink_state_compare_capipa_sink_state_tis_opened/// Checks if sink is playing: running or idle./// Checks if sink is running.r" Set of source flags."r" the source has initialized."r" Is a hardware source of some kind, in contrast to “virtual”/software source."r" Is a networked source of some kind."r" runtime after the source has initialized."r" This source is in flat volume mode, i.e. always the maximum of the volume of all"r" connected outputs."/// source has initialized./// Is a hardware source of some kind, in contrast to “virtual”/software source./// Is a networked source of some kind./// after the source has initialized./// This source is in flat volume mode, i.e. always the maximum of the volume of all connected/// outputs.source_flags/// Special source flags./// This state is used when the server does not support source state introspection./// Running, source is recording and used by at least one non-corked source-output./// When idle, the source is still recording but there is no non-corked source-output./// When suspended, actual source access can be closed, for instance._IMPL_NUM_FromPrimitive_FOR_SourceState_IMPL_NUM_ToPrimitive_FOR_SourceState/// Source state.source_state_compare_capipa_source_state_t/// Checks if source is recording: running or idle./// Checks if source is running.//! Global definitions.r" Flag set."r" Output flag."OUTPUTr" Input flag."/// Output flag./// Input flag./// Available flags for [`FlagSet`]./// Checks whether direction is valid (either input, output or bidirectional)./// Gets a textual representation of the direction.//! Utilities for direction.FromPrimitiveTrait/// A wrapper around integer errors returned by PulseAudio. Can be converted to a [`Code`] variant/// for comparison purposes if desired./// No error./// Access failure./// Unknown command./// Invalid argument./// Entity exists.NoEntity/// No such entity./// Connection refused./// Protocol error./// Timeout.AuthKey/// No authentication key./// Internal.ConnectionTerminated/// Connection terminated.Killed/// Entity killed.InvalidServer/// Invalid server.ModInitFailed/// Module init failed./// Bad state.NoData/// No data./// Incompatible protocol version./// Data too large./// Operation not supported./// The error code was unknown to the client.NoExtension/// Extension does not exist.Obsolete/// Obsolete functionality./// Missing implementation.Forked/// The caller forked without calling execve() and tried to reuse the context./// An IO error happened./// Device or resource busy._IMPL_NUM_FromPrimitive_FOR_Code_IMPL_NUM_ToPrimitive_FOR_Code/// These represent errors returned by many of the underlying PulseAudio C functions.code_compare_capipa_error_code_t/// Converts an integer error value, as returned by many PA C API functions, to a human readable/// Converts a `Code` to a human readable string./// Attempts to convert the wrapped integer error value to a `Code` variant./// Returns `Err(())` if the value cannot be mapped.check_code_paerr_conversions/// Check `PAErr` <=> `Code` conversions//! Error management.pa_prop_type_t/// Any encoding format, PCM or compressed.PCM/// Any PCM format.AC3_IEC61937/// AC3 data encapsulated in IEC 61937 header/padding.EAC3_IEC61937/// EAC3 data encapsulated in IEC 61937 header/padding.MPEG_IEC61937/// MPEG-1 or MPEG-2 (Part 3, not AAC) data encapsulated in IEC 61937 header/padding.DTS_IEC61937/// DTS data encapsulated in IEC 61937 header/padding.MPEG2_AAC_IEC61937/// MPEG-2 AAC data encapsulated in IEC 61937 header/padding./// Represents an invalid encoding._IMPL_NUM_FromPrimitive_FOR_Encoding_IMPL_NUM_ToPrimitive_FOR_Encoding/// Represents the type of encoding used in a stream or accepted by a sink.enc_compare_capipa_encoding_t/// Wrapped property list pointer./// Represents the format of data provided in a stream or processed by a sink./// The encoding used for the format./// Additional encoding-specific properties such as sample rate, bitrate, etc./// The raw C structure (with documentation).info_compare_capi/// Returns a printable string representing the given encoding type./// Allocates a new `Info` structure./// Clients must initialise at least the encoding field themselves. Returns `None` on failure./// Parses a human-readable string of the form generated by [`print()`](Self::print) into an/// `Info` structure./// Returns `None` on failure.new_from_sample_spec/// Utility function to take a [`Spec`] and generate the corresponding `Info`./// Note that if you want the server to choose some of the stream parameters, for example the/// sample rate, so that they match the device parameters, then you shouldn’t use this function./// In order to allow the server to choose a parameter value, that parameter must be left/// unspecified in the `Info` object, and this function always specifies all parameters. An/// exception is the channel map: if you pass `None` for the channel map, then the channel map/// will be left unspecified, allowing the server to choose it./// [`Spec`]: crate::sample::Spec/// Creates a new `Info` from an existing [`InfoInternal`] pointer.from_raw_weak/// This is the ‘weak’ version, which avoids destroying the internal object when dropped./// Checks whether the `Info` structure is valid.is_pcm/// Checks whether the `Info` structure represents a PCM (i.e. uncompressed data) format.is_compatible_with/// Checks whether the format represented by self is a subset of the format represented by/// `with`./// This means that `with` must have all the fields that self does, but the reverse need not be/// true. This is typically expected to be used to check if a stream’s format is compatible with/// a given sink. In such a case, self would be the sink’s format and `with` would be the/// Gets a human-readable string representing the given format.to_sample_spec/// Utility function to generate a [`Spec`] and [`Map`] corresponding to a given `Info`./// The conversion for PCM formats is straight-forward. For non-PCM formats, if there is a fixed/// size-time conversion (i.e. all IEC61937-encapsulated formats), a “fake” sample spec whose/// size-time conversion corresponds to this format is provided and the channel map argument is/// ignored. For formats with variable size-time conversion, this function will fail./// [`Map`]: crate::channelmap::Mapget_encoding/// Gets the encoding.set_encoding/// Sets the encoding attribute./// Gets an immutable reference to the property list.get_properties_mut/// Gets a mutable reference to the property list.get_prop_type/// Gets the type of property key.get_prop_int/// Gets an integer property.get_prop_int_range/// Gets an integer range property. On success, returns min-max tuple.get_prop_int_array/// Gets an integer array property.get_prop_string/// Gets a string property.get_prop_string_array/// Gets a string array property.set_prop_int/// Sets an integer property.set_prop_int_array/// Sets a property with a list of integer values.set_prop_int_range/// Sets a property which can have any value in a given integer range.set_prop_string/// Sets a string property.set_prop_string_array/// Sets a property with a list of string values.set_sample_format/// Convenience method to set the sample format as a property./// Note for PCM: If the sample format is left unspecified in the `Info` object, then the server/// will select the stream sample format. In that case the stream sample format will most likely/// match the device sample format, meaning that sample format conversion will be avoided./// Convenience method to set the sampling rate as a property./// Note for PCM: If the sample rate is left unspecified in the `Info` object, then the server/// will select the stream sample rate. In that case the stream sample rate will most likely/// match the device sample rate, meaning that sample rate conversion will be avoided.set_channels/// Convenience method to set the number of channels as a property./// Note for PCM: If the channel count is left unspecified in the `Info` object, then the server/// will select the stream channel count. In that case the stream channel count will most likely/// match the device channel count, meaning that up/downmixing will be avoided.set_channel_map/// Convenience method to set the channel map as a property./// Note for PCM: If the channel map is left unspecified in the `Info` object, then the server/// will select the stream channel map. In that case the stream channel map will most likely/// match the device channel map, meaning that remixing will be avoided./// Returns a new `Info` struct and representing the same format. If this is called on a ‘weak’/// instance, a non-weak object is returned.//! Utility functions for handling a stream or sink format.//! # Note//! Clients using an [`Info`] structure must remember to at least set the encoding attribute, which//! can be done through the [`Info::set_encoding()`] method.//! A binding for the PulseAudio system library (`libpulse`).//! This binding enables Rust projects to make use of the [PulseAudio] client system library. It//! builds upon the [separate raw FFI crate][sys] to provide a more “Rusty” interface.//! The documentation below and throughout this crate has been largely copied (under fair-use terms)//! from those in the PulseAudio C API header files, and adjusted where appropriate to fit any//! differences, thus it should not be too unfamiliar to those of you already familiar with the C//! <div style="border-left:#bda000aa 5px solid; padding:0.5em 1em; margin:1em 0 0.6em 0; background-color:#aaa2">//! <h3 style="color:#bfa800; margin-top:0.2em">//! <span aria-hidden="true">//! <svg style="width:1em; height:1em; margin-bottom:-0.15em; fill:currentColor" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path d="M569.517 440.013C587.975 472.007 564.806 512 527.94 512H48.054c-36.937 0-59.999-40.055-41.577-71.987L246.423 23.985c18.467-32.009 64.72-31.951 83.154 0l239.94 416.028zM288 354c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"></path></svg>//! </span>//! Warning//! </h3>//! <p>//! The PulseAudio API, even in this Rust-ified form, is not the easiest thing to understand how to//! make use of. Furthermore, the somewhat complex underlying C API imposes certain limitations upon//! just how safe and simple an interface this binding can reasonably offer. One particularly//! notable example is the threaded mainloop locking mechanism, which uses a perfectly legitimate//! design, but one that happens to conflict with what is typically used in Rust code; it does not//! fit perfectly with the Rust borrow checking mechanism and thus you cannot rely upon the borrow//! checker to prevent unsafe use as much as is typical.//! </p>//! # Introduction//! The PulseAudio API comes in two flavours to accommodate different styles of applications and//! different needs in complexity://! * The complete but somewhat complicated to use asynchronous API.//! * The simplified, easy to use, but limited synchronous API.//! ## Simple API//! Use this if you develop your program in synchronous style and just need a way to play or record//! data on the sound server. This functionality is kept in the separate [`libpulse-simple-binding`]//! crate. See that for details.//! ## Asynchronous API//! Use this if you develop your programs in asynchronous, event loop based style or if you want to//! use the advanced features of the PulseAudio API. A guide can be found in the//! [`mainloop`](mod@mainloop) module.//! By using the built-in threaded main loop, it is possible to achieve a pseudo-synchronous API,//! which can be useful in synchronous applications where the simple API is insufficient.//! ## Threads//! The PulseAudio client libraries are not designed to be directly thread-safe. They are however//! designed to be re-entrant and thread-aware.//! To use the libraries in a threaded environment, you must assure that all objects are only used//! in one thread at a time. Normally, this means that all objects belonging to a single context//! must be accessed from the same thread.//! The included main loop implementation is also not thread safe. Take care to make sure event//! objects are not manipulated when any other code is using the main loop.//! Note that some objects implement the `Sync` trait, despite not truly being thread-safe. The//! reason for this is that when the threaded mainloop is used (the most common one), its lock//! provides the thread safety, and when such types are used behind that lock, they are then `Sync`//! safe. If you use the standard mainloop though, then you would have to add an `Arc` wrapper to//! make them safe. Not having `Sync` would force the threaded mainloop case to require unnecessary//! and undesirable `Arc` wrappers. This is an unfortunate compromise resulting from the//! complication of needing to support multiple mainloop designs, and the threaded mainloop design//! being built upon a non-wrapper lock that is not typical of Rust code.//! ## Logging//! You can configure different logging parameters for the PulseAudio client libraries. The//! following environment variables are recognized://! * `PULSE_LOG`: Maximum log level required. Bigger values result in a more verbose logging//!   output. The following values are recognized://!   * `0`: Error messages//!   * `1`: Warning messages//!   * `2`: Notice messages//!   * `3`: Info messages//!   * `4`: Debug messages//! * `PULSE_LOG_SYSLOG`: If defined, force all client libraries to log their output using the//!   `syslog(3)` mechanism. Default behavior is to log all output to `stderr`.//! * `PULSE_LOG_JOURNAL`: If defined, force all client libraries to log their output using the//!   systemd journal. If both `PULSE_LOG_JOURNAL` and `PULSE_LOG_SYSLOG` are defined, logging to//!   the systemd journal takes a higher precedence. Each message originating library file name and//!   function are included by default through the journal fields `CODE_FILE`, `CODE_FUNC`, and//!   `CODE_LINE`. Any backtrace attached to the logging message is sent through the//!   PulseAudio-specific journal field `PULSE_BACKTRACE`. This environment variable has no effect//!   if PulseAudio was compiled without systemd journal support.//! * `PULSE_LOG_COLORS`: If defined, enables colored logging output.//! * `PULSE_LOG_TIME`: If defined, include timestamps with each message.//! * `PULSE_LOG_FILE`: If defined, include each message originating file name.//! * `PULSE_LOG_META`: If defined, include each message originating file name and path relative to//!   the PulseAudio source tree root.//! * `PULSE_LOG_LEVEL`: If defined, include a log level prefix with each message. Respectively, the//!   prefixes "E", "W", "N", "I", "D" stands for Error, Warning, Notice, Info, and Debugging.//! * `PULSE_LOG_BACKTRACE`: Number of functions to display in the backtrace. If this variable is//!   not defined, or has a value of zero, no backtrace is shown.//! * `PULSE_LOG_BACKTRACE_SKIP`: Number of backtrace levels to skip, from the function printing the//!   log message downwards.//! * `PULSE_LOG_NO_RATE_LIMIT`: If defined, do not rate limit the logging output. Rate limiting//!   skips certain log messages when their frequency is considered too high.//! Start by adding a dependency on the crate in your program’s `Cargo.toml` file. Note that it is//! recommended that you rename the crate such that you can refer to it by a shorter name within//! your code (such as `pulse`, as used within examples within this crate’s documentation). Such//! renaming can be done [within your `Cargo.toml` file][rename] with cargo version 1.31 or newer,//! or otherwise with `extern crate` statements.//! See sub-modules for further information.//! It is important that you read the <code>COMPATIBILITY.md</code> guide available in the//! <a href="https://github.com/jnqnfe/pulse-binding-rust">code repository</a> to understand the//! topic of compatibility with different versions of PulseAudio.//! [sys]: https://docs.rs/libpulse-sys//! [`libpulse-simple-binding`]: https://docs.rs/libpulse-simple-binding//! [PulseAudio]: https://en.wikipedia.org/wiki/PulseAudio//! [rename]: https://doc.rust-lang.org/1.31.0/cargo/reference/specifying-dependencies.html#renaming-dependencies-in-cargotoml//! [code repository]: https://github.com/jnqnfe/pulse-binding-rustIoEventIoEventRefIoEventInternalIoEventFlagSetTimeEventInternalDeferEventDeferEventRefDeferEventInternalTimevalpa_mainloop_apiApiInternalMainloopInternalType/// This enables generic type enforcement with the opaque C objects./// Internal mainloop type.MainloopApiMainloopInner/// Create a new instanceget_ptr/// Return opaque main loop object pointer./// **Warning**: The pointer is only valid for the lifetime of this object.get_api_ptr/// Return raw API object pointer./// Return main loop API object pointer.supports_rtclock/// Returns `true` if the mainloop implementation supports monotonic based time events./// This enables generic type enforcement with MainloopInner objects, and describes mandatory/// accessors for the internal pointers, allowing access to these pointers across the generic/// implementations to work./// An opaque main loop object./// The abstract main loop API vtable for the GLIB main loop object. No need to free this API as/// it is owned by the loop and is destroyed when the loop is freed./// All implementations must provide a drop method, to be called from an actual drop call, which/// should free the mainloop object./// Whether or not the implementation supports monotonic based time events. (`true` if so)./// Mainloop inner wrapper./// This contains the actual main loop object pointers, holding both the pointer to the actual/// opaque main loop C object, and the pointer to the associated API vtable./// An instance of this type will be held, in an `Rc` ref counted wrapper both in an outer Mainloop/// wrapper, and by all event objects. With event objects holding a ref-counted copy, this both/// gives event objects access to the API pointer, which they need, and also it allows us to ensure/// that event objects do not outlive the main loop object (which internally owns the API object),/// and thus ensures correct destruction order of event and main loop objects./// Gets opaque main loop object pointer./// Gets raw API object pointer./// Gets main loop API object pointer./// This is the actual implementation of the ‘inner type’ trait./// It is not possible to replace this with ‘default’ method implementations within the trait itself/// since the trait does not know about the existence of the struct attributes being accessed./// Inner mainloop type./// Get inner mainloop.new_io_event/// Creates a new IO event./// The given callback must accept three parameters, an [`IoEventRef`] object, a copy of the/// given file descriptor, and an event flag set, indicating the event(s) that occurred. The/// [`DeferEventRef`] object gives you some opportunity to manage the event source from within/// it’s callback execution.new_timer_event/// Creates a new timer event./// The callback must take a [`TimeEventRef`] object, which gives you some opportunity to/// manage the event source from within it’s callback execution./// use libpulse_binding::time::{UnixTs, MicroSeconds};/// let _t_event = mainloop.new_timer_event(///     &(UnixTs::now() + MicroSeconds::from_secs(5).unwrap()),///     Box::new(|_| { println!("Timer event fired!"); }));new_timer_event_rt/// Creates a new monotonic-based timer event./// Asserts that `t` is not `MicroSeconds::INVALID`./// This is an alternative to the `new_timer_event` method, taking a monotonic based time value./// let _t_event = mainloop.new_timer_event_rt(new_deferred_event/// Creates a new deferred event./// The callback must take a [`DeferEventRef`] object, which gives you some opportunity toonce_event/// Runs the specified callback once from the main loop using an anonymous defer event./// If the mainloop runs in a different thread, you need to follow the mainloop implementation’s/// rules regarding how to safely create defer events. In particular, if you’re using/// [`mainloop::threaded`](mod@crate::mainloop::threaded), you must lock the mainloop before/// calling this function./// Calls quit/// Mainloop trait, to be implemented by the different types of mainloops.IoEventCb/// An IO event callback prototype.IoEventDestroyCb/// A IO event destroy callback prototype.TimeEventCb/// A time event callback prototype.TimeEventDestroyCb/// A time event destroy callback prototype.DeferEventCb/// A defer event callback prototype.DeferEventDestroyCb/// A defer event destroy callback prototype./// A pointer to some private, arbitrary data of the main loop implementation.io_new/// Creates a new IO event source object.io_enable/// Enables or disables IO events on this object./// Frees a IO event source object.io_set_destroy/// Sets a function that is called when the IO event source is destroyed. Use this to free the/// `userdata` argument if required.time_new/// Creates a new timer event source object for the specified Unix time.time_restart/// Restarts a running or expired timer event source with a new Unix time.time_free/// Frees a deferred timer event source object.time_set_destroy/// Sets a function that is called when the timer event source is destroyed. Use this to free/// the `userdata` argument if required.defer_new/// Creates a new deferred event source object.defer_enable/// Enables or disables a deferred event source temporarily.defer_free/// Frees a deferred event source object.defer_set_destroy/// Sets a function that is called when the deferred event source is/// destroyed. Use this to free the `userdata` argument if required./// Exits the main loop and return the specified retval./// An abstract mainloop API vtableapi_compare_capionce_cb_proxy/// Proxy for anonymous ‘once’ deferred event callbacks.//! Main loop abstraction layer API.pa_defer_event/// Internal object pointer/// Source mainloop._saved_cb/// Saved callback closure, for later destruction./// A deferred event source./// A reference to a deferred event source, provided to the callback, allowing modification within/// the callback itself./// Enables this event source temporarily./// Disables this event source temporarily./// Proxy for the event callback.//! Main loop deferred events.pa_io_eventr" IO event flag set."r" No event."r" Input event."r" Output event."r" Hangup event."HANGUPr" Error event."/// No event./// Input event./// Output event./// Hangup event./// Error event./// Flags for [`FlagSet`]./// An IO event source/// A reference to an IO event source, provided to the callback, allowing modification within the/// callback itself.//! Main loop IO events.//! Main loop events.pa_time_event/// Source mainloop/// A reference to a timer event source, provided to the callback, allowing modification within the/// Restarts this timer event source (whether still running or already expired) with a new Unixrestart_rt/// Restarts this timer event source (whether still running or already expired) with a new/// monotonic time.//! Main loop timer events.//! Time events may be created (or reset) with either Unix time values or real-time (monotonic)//! based values (though if the mainloop does not support monotonic time value, they may be silently//! converted to unix time).//! Note that time events created with one form of time value can be freely restarted with the other//! form of time value.threaded//! Main loop abstraction layer.//! # Main Loop Abstraction//! Both the PulseAudio core and the PulseAudio client library use a main loop abstraction layer.//! Due to this it is possible to embed PulseAudio into other applications easily.//! This abstraction contains three basic elements://! * Deferred events: Events that will trigger as soon as possible. Note that some implementations//!   may block all other events when a deferred event is active.//! * I/O events: Events that trigger on file descriptor activities.//! * Timer events: Events that trigger after a fixed amount of time.//! The abstraction is represented as a number of function pointers in the//! [`MainloopApi`](self::api::MainloopApi) structure.//! To actually be able to use these functions, an implementation needs to be coupled to the//! abstraction. There are three of these shipped with PulseAudio, but any other can be used with a//! minimal amount of work, provided it supports the three basic events listed above.//! The implementations shipped with PulseAudio are://! * [Standard](mod@standard): A minimal but fast implementation based on the C library’s poll()//!   function.//! * [Threaded](mod@threaded): A special version of the previous implementation where all of//!   PulseAudio’s internal handling runs in a separate thread.//! * ‘Glib’: A wrapper around GLib’s main loop. This is provided in the separate//!   `libpulse_glib_binding` crate.//! UNIX signals may be hooked to a main loop using the functionality from the//! [`signal`](mod@signal) mod. This relies only on the main loop abstraction and can therefore be//! used with any of the implementations.//! # Callback Notes//! ## Execution//! As described in the [standard mainloop] documentation], there are three phases to mainloop//! execution, and the third - ‘dispatch’ - is when user callbacks get executed.//! It is important to understand that while it is *typical* that user callbacks are executed//! by the mainloop’s dispatcher, callback execution is not exclusively done there; in some cases//! callbacks get executed directly in synchronous function execution. For instance, if you set up//! a context state change callback, then try to connect the context object, execution of the//! ‘connect’ function call involves (internally within the PulseAudio client library) direct//! execution of this callback in setting the initial connection state. After returning, the//! callback is then on only executed asynchronously from the mainloop’s dispatcher.//! While execution using the [standard mainloop] is entirely synchronous, the [threaded mainloop]//! implementation runs the standard mainloop in a separate thread and callback execution occurs//! asynchronously, requiring careful use of the mainloop’s [`lock()`] method. When writing//! callbacks with the threaded mainloop, users must beware the potential that in a few cases the//! callback may be executed in two different scenarios, and with different threads. Note that the//! threaded mainloop has an [`in_thread()`] method for determining whether or not the thread it is//! executed from is the special event loop thread.//! ## Queued Events and Changing Callbacks//! It is also worth understanding that any events that get queued for dispatch do **not** hold//! cached copies of user callback parameters. Where applicable, you can thus freely and safely//! change the set callback, with that change taking effect immediately to all future event//! dispatching.//! ## Threading and `Rc`//! Normally when holding multiple references to objects across threads in Rust you would use an//! [`Arc`] wrapper. However, with the [threaded mainloop], you may be able to get away with using//! just an `Rc` wrapper. Remember that with the [threaded mainloop] you **must** use its//! [`lock()`] method to synchronise access to objects, and so you know that at any one moment//! either your thread (when you take the lock) **or** the event loop thread hold the lock, never//! both, and thus only one thread is ever working with objects at any one time, and since Rust//! actually has no idea that more than one thread is involved (hidden in the C library’s//! implementation), you can safely get away with using `Rc`.//! [standard mainloop]: mod@standard//! [threaded mainloop]: mod@self::threaded//! [`lock()`]: self::threaded::Mainloop::lock//! [`in_thread()`]: self::threaded::Mainloop::in_threadpa_signal_eventEventInternalMainloopTrait_signal_cbSignalCb/// Saved multi-use state callback closure, for later destruction./// An opaque UNIX signal event source object./// Note: Saves a copy of the closure callbacks, which it frees on drop.init_signals/// Initializes the UNIX signal subsystem and bind it to the specified main loop.signals_done/// Cleans up the signal subsystem.MainloopSignals/// Trait with signal handling, for mainloops./// Creates a new UNIX signal event source object./// The callback must accept an integer which represents the signal.signal_cb_proxy/// Proxy for signal callbacks.//! UNIX signal support for main loops.//! In contrast to other main loop event sources such as timer and IO events, UNIX signal support//! requires modification of the global process environment. Due to this the generic main loop//! abstraction layer as defined in [`mainloop::api`](mod@crate::mainloop::api) doesn’t have direct//! support for UNIX signals. However, you may hook signal support into an abstract main loop via//! the routines defined herein.ErrCodepa_mainloopMainloopInternal/// Generic prototype of a poll() like function./// Success, with number of sources dispatched./// Quit was called, with quit’s retval./// An error occurred, with error value./// Return type for [`Mainloop::iterate()`]./// Checks if the result is a `Success` value (returns `true` if so).is_quit/// Checks if the result is a `Quit` value (returns `true` if so)./// Checks` if the result is an `Error` value (returns `true` if so)./// The ref-counted inner data./// This acts as a safe interface to the internal PA Mainloop./// The mainloop object pointers are further enclosed here in a ref counted wrapper, allowing this/// outer wrapper to have clean methods for creating event objects, which can cleanly pass a copy of/// the inner ref counted mainloop object to them. Giving this to events serves two purposes,/// firstly because they need the API pointer, secondly, it ensures that event objects do not/// outlive the mainloop object.drop_actual/// Allocates a new main loop object./// Prepares for a single iteration of the main loop./// Returns `Err` on error or exit request./// `timeout` specifies a maximum timeout for the subsequent poll. `None` requests blocking/// Note, should the microseconds timeout value provided be too large to pass to the underlying/// C API (larger than [`std::i32::MAX`]), then the [`PAErr`] form of the [`Code::TooLarge`]/// error will be returned (within [`Result::Err`])./// [`Code::TooLarge`]: crate::error::Code::TooLarge/// Executes the previously prepared poll./// Dispatchs timeout, IO and deferred events from the previously executed poll./// On success returns the number of source dispatched.get_retval/// Gets the return value as specified with the main loop’s [`quit()`](Self::quit) routine./// Runs a single iteration of the main loop./// This is a convenience function for [`prepare()`], [`poll()`] and [`dispatch()`]./// If `block` is `true`, block for events if none are queued./// Returns an [`IterateResult`] variant:/// * On success, returns `IterateResult::Success` containing the number of sources dispatched///   in this iteration./// * If exit was requested, returns `IterateResult::Quit` containing quit’s retval./// * On error, returns `IterateResult::Err` containing error value./// [`prepare()`]: Self::prepare/// [`poll()`]: Self::poll/// [`dispatch()`]: Self::dispatch/// Runs unlimited iterations of the main loop object until the main loop’s/// [`quit()`](Self::quit) routine is called./// On success, returns `Ok` containing quit’s return value. On error returns `Err` containing a/// tuple of the error value and quit’s return value./// Gets the abstract main loop abstraction layer vtable for this main loop./// No need to free the API as it is owned by the loop and is destroyed when the loop is freed./// Talking to PA directly with C requires fetching this pointer explicitly via this function./// This is actually unnecessary through this binding. The pointer is retrieved automatically/// upon Mainloop creation, stored internally, and automatically obtained from it by functions/// that need it./// Shuts down the main loop with the specified return value./// Interrupts a running poll (for threaded systems).set_poll_func/// Changes the poll() implementation.//! Standard/minimal main loop implementation based on poll().//! This ‘standard’ (minimal) main loop implementation is based on the poll() system call. It//! supports the functions defined in the main loop abstraction//! ([`mainloop::api`](mod@crate::mainloop::api)) and very little else.//! This implementation is thread safe as long as you access the main loop object from a single//! thread only.//! A [`Mainloop`] is created using [`Mainloop::new()`]. To get access to the main loop abstraction,//! [`Mainloop::get_api()`] is used.//! Destruction of the [`Mainloop`] object is done automatically when the object falls out of scope.//! (Rust’s `Drop` trait has been implemented and takes care of it).//! The main loop is designed around the concept of iterations. Each iteration consists of three//! steps that repeat during the application’s entire lifetime://! * Prepare - Build a list of file descriptors that need to be monitored and calculate the next//!   timeout.//! * Poll - Execute the actual poll() system call.//! * Dispatch - Dispatch any events that have fired.//! When using the main loop, the application can either execute each iteration, one at a time,//! using [`Mainloop::iterate()`], or let the library iterate automatically using//! [`Mainloop::run()`].//! # Threads//! The main loop functions are designed to be thread safe, but the objects are not. What this means//! is that multiple main loops can be used, but only one object per thread.//! An example program using the standard mainloop://! use std::sync::atomic;//! use std::cell::RefCell;//! use std::ops::Deref;//! use pulse::mainloop::standard::Mainloop;//! use pulse::context::{Context, FlagSet as ContextFlagSet};//! use pulse::stream::{Stream, FlagSet as StreamFlagSet};//! use pulse::sample::{Spec, Format};//! use pulse::proplist::Proplist;//! use pulse::mainloop::standard::IterateResult;//! use pulse::def::Retval;//!     let spec = Spec {//!         format: Format::S16NE,//!         channels: 2,//!         rate: 44100,//!     assert!(spec.is_valid());//!     let mut proplist = Proplist::new().unwrap();//!     proplist.set_str(pulse::proplist::properties::APPLICATION_NAME, "FooApp")//!         .unwrap();//!     let mut mainloop = Rc::new(RefCell::new(Mainloop::new()//!         .expect("Failed to create mainloop")));//!     let mut context = Rc::new(RefCell::new(Context::new_with_proplist(//!         mainloop.borrow().deref(),//!         "FooAppContext",//!         &proplist//!         ).expect("Failed to create new context")));//!     context.borrow_mut().connect(None, ContextFlagSet::NOFLAGS, None)//!         .expect("Failed to connect context");//!     // Wait for context to be ready//!     loop {//!         match mainloop.borrow_mut().iterate(false) {//!             IterateResult::Quit(_) |//!             IterateResult::Err(_) => {//!                 eprintln!("Iterate state was not success, quitting...");//!                 return;//!             IterateResult::Success(_) => {},//!         match context.borrow().get_state() {//!             pulse::context::State::Ready => { break; },//!             pulse::context::State::Failed |//!             pulse::context::State::Terminated => {//!                 eprintln!("Context state failed/terminated, quitting...");//!             _ => {},//!     let mut stream = Rc::new(RefCell::new(Stream::new(//!         &mut context.borrow_mut(),//!         "Music",//!         &spec,//!         None//!         ).expect("Failed to create new stream")));//!     stream.borrow_mut().connect_playback(None, None, StreamFlagSet::START_CORKED,//!         None, None).expect("Failed to connect playback");//!     // Wait for stream to be ready//!         match stream.borrow().get_state() {//!             pulse::stream::State::Ready => { break; },//!             pulse::stream::State::Failed |//!             pulse::stream::State::Terminated => {//!                 eprintln!("Stream state failed/terminated, quitting...");//!     // Our main logic (to output a stream of audio data)//! #   let mut count = 0; // For automatic unit tests, we’ll spin a few times//!     let drained = Rc::new(RefCell::new(false));//!         // Write some data with stream.write()//!         if stream.borrow().is_corked().unwrap() {//!             stream.borrow_mut().uncork(None);//!         // Wait for our data to be played//!         let _o = {//!             let drain_state_ref = Rc::clone(&drained);//!             stream.borrow_mut().drain(Some(Box::new(move |_success: bool| {//!                 *drain_state_ref.borrow_mut() = true;//!             })))//!         while *drained.borrow_mut() == false {//!             match mainloop.borrow_mut().iterate(false) {//!                 IterateResult::Quit(_) |//!                 IterateResult::Err(_) => {//!                     eprintln!("Iterate state was not success, quitting...");//!                 IterateResult::Success(_) => {},//!         *drained.borrow_mut() = false;//!         // Remember to break out of the loop once done writing all data (or whatever).//! #       // Hack: Stop test getting stuck in infinite loop!//! #       count += 1;//! #       if count == 3 {//! #           break;//! #       }//!     // Clean shutdown//!     mainloop.borrow_mut().quit(Retval(0)); // uncertain whether this is necessary//!     stream.borrow_mut().disconnect().unwrap();pa_threaded_mainloop/// Allocates a new threaded main loop object./// You have to call [`start()`](Self::start) before the event loop thread starts running./// Starts the event loop thread./// Terminates the event loop thread cleanly./// Make sure to unlock the mainloop object before calling this function./// Locks the event loop object, effectively blocking the event loop thread from processing/// You can use this to enforce exclusive access to all objects attached to the event loop. This/// lock is recursive. This function may not be called inside the event loop thread. Events that/// are dispatched from the event loop thread are executed with this lock held./// Unlocks the event loop object, inverse of [`lock()`](Self::lock)./// Waits for an event to be signalled by the event loop thread./// You can use this to pass data from the event loop thread to the main thread in a/// synchronized fashion. This function may not be called inside the event loop thread. Prior to/// this call the event loop object needs to be locked using [`lock()`]. While waiting the lock/// will be released. Immediately before returning it will be acquired again. This function may/// spuriously wake up even without [`signal()`] being called. You need to make sure to handle/// that!/// [`lock()`]: Self::lock/// [`signal()`]: Self::signal/// Signals all threads waiting for a signalling event in [`wait()`]./// If `wait_for_accept` is `true`, do not return before the signal was accepted by an/// [`accept()`] call. While waiting for that condition the event loop object is unlocked./// [`wait()`]: Self::wait/// [`accept()`]: Self::accept/// Accepts a signal from the event thread issued with [`signal()`]./// This call should only be used in conjunction with [`signal()`] with `wait_for_accept` as/// Gets the return value as specified with the main loop’s `quit` routine (used internally by/// threaded mainloop)./// Gets the main loop abstraction layer vtable for this main loop./// There is no need to free this object as it is owned by the loop and is destroyed when the/// loop is freed.in_thread/// Checks whether or not we are in the event loop thread (returns `true` if so)./// Sets the name of the thread.//! A variation of the standard main loop implementation, using a background thread.//! The threaded main loop implementation is a special version of the standard main loop//! implementation. For the basic design, see the standard main loop documentation//! ([`mainloop::standard`](mod@crate::mainloop::standard)).//! The added feature in the threaded main loop is that it spawns a new thread that runs the real//! main loop in the background. This allows a synchronous application to use the asynchronous API//! without risking stalling the PulseAudio library. A few synchronization primitives are available//! to access the objects attached to the event loop safely.//! A [`Mainloop`] object is created using [`Mainloop::new()`]. This will only allocate the required//! structures though, so to use it the thread must also be started. This is done through//! [`Mainloop::start()`], after which you can start using the main loop.//! # Destruction//! When the PulseAudio connection has been terminated, the thread must be stopped and the//! resources freed. Stopping the thread is done using [`Mainloop::stop()`], which must be called//! without the lock (see below) held. When that function returns, the thread is stopped and the//! [`Mainloop`] object can be destroyed.//! # Locking//! Since the PulseAudio API doesn’t allow concurrent accesses to objects, a locking scheme must be//! used to guarantee safe usage. The threaded main loop API provides such a scheme through the//! functions [`Mainloop::lock()`] and [`Mainloop::unlock()`].//! The lock is recursive, so it’s safe to use it multiple times from the same thread. Just make//! sure you call [`Mainloop::unlock()`] the same number of times you called [`Mainloop::lock()`].//! The lock needs to be held whenever you call any PulseAudio function that uses an object//! associated with this main loop. Those objects include the mainloop, context, stream and//! operation objects, and the various event objects (io, time, defer). Make sure you do not hold on//! to the lock more than necessary though, as the threaded main loop stops while the lock is held.//! use pulse::mainloop::threaded::Mainloop;//! use pulse::stream::{Stream, State};//! fn check_stream(m: Rc<RefCell<Mainloop>>, s: Rc<RefCell<Stream>>) {//!     m.borrow_mut().lock();//!     let state = s.borrow().get_state();//!     m.borrow_mut().unlock();//!     match state {//!         State::Ready => { println!("Stream is ready!"); },//!         _ => { println!("Stream is not ready!"); },//! # Callbacks//! Callbacks in PulseAudio are asynchronous, so they require extra care when using them together//! with a threaded main loop.//! The easiest way to turn the callback based operations into synchronous ones, is to simply wait//! for the callback to be called and continue from there. This is the approach chosen in//! PulseAudio’s threaded API.//! ## Basic callbacks//! For the basic case, where all that is required is to wait for the callback to be invoked, the//! code should look something like this://! use pulse::operation::State;//! use pulse::stream::Stream;//! fn drain_stream(m: Rc<RefCell<Mainloop>>, s: Rc<RefCell<Stream>>) {//!     // Drain//!     let o = {//!         let ml_ref = Rc::clone(&m);//!         s.borrow_mut().drain(Some(Box::new(move |_success: bool| {//!             unsafe { (*ml_ref.as_ptr()).signal(false); }//!         })))//!     while o.get_state() != pulse::operation::State::Done {//!         m.borrow_mut().wait();//! The function `drain_stream` will wait for the callback to be called using [`Mainloop::wait()`].//! If your application is multi-threaded, then this waiting must be done inside a while loop. The//! reason for this is that multiple threads might be using [`Mainloop::wait()`] at the same time.//! Each thread must therefore verify that it was its callback that was invoked. Also the underlying//! OS synchronization primitives are usually not free of spurious wake-ups, so a//! [`Mainloop::wait()`] must be called within a loop even if you have only one thread waiting.//! The callback `my_drain_callback` indicates to the main function that it has been called using//! [`Mainloop::signal()`].//! As you can see, [`Mainloop::wait()`] may only be called with the lock held. The same thing is//! true for [`Mainloop::signal()`], but as the lock is held before the callback is invoked, you do//! not have to deal with that.//! The functions will not dead lock because the wait function will release the lock before waiting//! and then regrab it once it has been signalled. For those of you familiar with threads, the//! behaviour is that of a condition variable.//! ## Data callbacks//! For many callbacks, simply knowing that they have been called is insufficient. The callback also//! receives some data that is desired. To access this data safely, we must extend our example a//! bit://! // A data structure to capture all our data in (currently just a pointer to a bool)//! struct DrainCbData(*mut bool);//!     // For guarding against spurious wakeups//!     // Possibly also needed for memory flushing and ordering control//!     let mut guard = Rc::new(RefCell::new(AtomicBool::new(true)));//!     let mut data: Rc<RefCell<Option<DrainCbData>>> = Rc::new(RefCell::new(None));//!         let guard_ref = Rc::clone(&guard);//!         let data_ref = Rc::clone(&data);//!         s.borrow_mut().drain(Some(Box::new(move |mut success: bool| {//!             unsafe {//!                 *data_ref.as_ptr() = Some(DrainCbData(&mut success));//!                 (*guard_ref.as_ptr()).store(false, Ordering::Release);//!                 (*ml_ref.as_ptr()).signal(true);//!     while guard.borrow().load(Ordering::Acquire) {//!     assert!(!data.borrow().is_none());//!     let success = unsafe { *(data.borrow_mut().take().unwrap().0) };//!     // Allow callback to continue now//!     m.borrow_mut().accept();//!     match success {//!         false => { println!("Bitter defeat..."); },//!         true => { println!("Success!"); },//! The example is a bit silly as it would have been more simple to just copy the contents of//! `success`, but for larger data structures this can be wasteful.//! The difference here compared to the basic callback is the value `true` passed to//! [`Mainloop::signal()`] and the call to [`Mainloop::accept()`]. What will happen is that//! [`Mainloop::signal()`] will signal the main function and then wait. The main function is then//! free to use the data in the callback until [`Mainloop::accept()`] is called, which will allow//! the callback to continue.//! Note that [`Mainloop::accept()`] must be called some time between exiting the while loop and//! unlocking the main loop! Failure to do so will result in a race condition. I.e. it is not okay//! to release the lock and regrab it before calling [`Mainloop::accept()`].//! ## Asynchronous callbacks//! PulseAudio also has callbacks that are completely asynchronous, meaning that they can be called//! at any time. The threaded main loop API provides the locking mechanism to handle concurrent//! accesses, but nothing else. Applications will have to handle communication from the callback to//! the main program through their own mechanisms.//! The callbacks that are completely asynchronous are://! * State callbacks for contexts, streams, etc.//! * Subscription notifications.//! An example program using the threaded mainloop://! use pulse::mainloop::api::Mainloop as MainloopTrait; //Needs to be in scope//!     // Context state change callback//!         let ml_ref = Rc::clone(&mainloop);//!         let context_ref = Rc::clone(&context);//!         context.borrow_mut().set_state_callback(Some(Box::new(move || {//!             let state = unsafe { (*context_ref.as_ptr()).get_state() };//!             match state {//!                 pulse::context::State::Ready |//!                 pulse::context::State::Failed |//!                 pulse::context::State::Terminated => {//!                     unsafe { (*ml_ref.as_ptr()).signal(false); }//!                 _ => {},//!         })));//!     mainloop.borrow_mut().lock();//!     mainloop.borrow_mut().start().expect("Failed to start mainloop");//!                 mainloop.borrow_mut().unlock();//!                 mainloop.borrow_mut().stop();//!             _ => { mainloop.borrow_mut().wait(); },//!     context.borrow_mut().set_state_callback(None);//!     // Stream state change callback//!         let stream_ref = Rc::clone(&stream);//!         stream.borrow_mut().set_state_callback(Some(Box::new(move || {//!             let state = unsafe { (*stream_ref.as_ptr()).get_state() };//!                 pulse::stream::State::Ready |//!                 pulse::stream::State::Failed |//!                 pulse::stream::State::Terminated => {//!     stream.borrow_mut().set_state_callback(None);//!     mainloop.borrow_mut().unlock();//!         mainloop.borrow_mut().lock();//!         // Drain//!         let o = {//!             let ml_ref = Rc::clone(&mainloop);//!                 unsafe { (*ml_ref.as_ptr()).signal(false); }//!         while o.get_state() != pulse::operation::State::Done {//!             mainloop.borrow_mut().wait();//!         mainloop.borrow_mut().unlock();//!         // If done writing data, call `mainloop.borrow_mut().stop()` (with lock released), then//!         // break!//! #           mainloop.borrow_mut().stop();pa_operationOperationInternalpa_operation_state_tsaved_cb/// The operation’s associated closure callback./// This is a copy of the callback userdata pointer given in the C API function call that/// generated the operation instance (except not cast to void). It is saved here in case the/// user tries to cancel execution of the callback (with the `cancel` method), in which case we/// need this in order to release the memory.state_cb/// An asynchronous operation object./// Creates a new `Operation` from an existing [`OperationInternal`] pointer./// We also take a copy of the closure callback pointer, in order to free the memory on/// cancellation./// Cancels the operation./// Beware! This will not necessarily cancel the execution of the operation on the server side./// However it will make sure that the callback associated with this operation will not be/// called any more, effectively disabling the operation from the client side’s view./// **Warning**, you should **never** attempt to use this to cancel a callback from within the/// execution of that callback itself. This should go without saying, since it makes absolutely/// no sense to try and do this, but be aware that this is not supported by the C API and/// **will** break things./// Gets the current status of the operation./// Sets the callback function that is called when the operation state changes./// Usually this is not necessary, since the functions that create `Operation` objects already/// take a callback that is called when the operation finishes. Registering a state change/// callback is mainly useful, if you want to get called back also if the operation gets/// cancelled.notify_cb_proxy/// Proxy for notification callbacks.//! Asynchronous operations.pa_proplistpa_update_mode_tPA_PROP_MEDIA_NAMEMEDIA_NAMEPA_PROP_MEDIA_TITLEMEDIA_TITLEPA_PROP_MEDIA_ARTISTMEDIA_ARTISTPA_PROP_MEDIA_COPYRIGHTMEDIA_COPYRIGHTPA_PROP_MEDIA_SOFTWAREMEDIA_SOFTWAREPA_PROP_MEDIA_LANGUAGEMEDIA_LANGUAGEPA_PROP_MEDIA_FILENAMEMEDIA_FILENAMEPA_PROP_MEDIA_ICONMEDIA_ICONPA_PROP_MEDIA_ICON_NAMEMEDIA_ICON_NAMEPA_PROP_MEDIA_ROLEMEDIA_ROLEPA_PROP_FILTER_WANTFILTER_WANTPA_PROP_EVENT_IDEVENT_IDPA_PROP_EVENT_DESCRIPTIONEVENT_DESCRIPTIONPA_PROP_EVENT_MOUSE_XEVENT_MOUSE_XPA_PROP_EVENT_MOUSE_YEVENT_MOUSE_YPA_PROP_EVENT_MOUSE_HPOSEVENT_MOUSE_HPOSPA_PROP_EVENT_MOUSE_VPOSEVENT_MOUSE_VPOSPA_PROP_EVENT_MOUSE_BUTTONEVENT_MOUSE_BUTTONPA_PROP_WINDOW_NAMEWINDOW_NAMEPA_PROP_WINDOW_IDWINDOW_IDPA_PROP_WINDOW_ICONWINDOW_ICONPA_PROP_WINDOW_ICON_NAMEWINDOW_ICON_NAMEPA_PROP_WINDOW_XWINDOW_XPA_PROP_WINDOW_YWINDOW_YPA_PROP_WINDOW_WIDTHPA_PROP_WINDOW_HEIGHTWINDOW_HEIGHTPA_PROP_WINDOW_HPOSWINDOW_HPOSPA_PROP_WINDOW_VPOSWINDOW_VPOSPA_PROP_WINDOW_DESKTOPWINDOW_DESKTOPPA_PROP_WINDOW_X11_DISPLAYWINDOW_X11_DISPLAYPA_PROP_WINDOW_X11_SCREENWINDOW_X11_SCREENPA_PROP_WINDOW_X11_MONITORWINDOW_X11_MONITORPA_PROP_WINDOW_X11_XIDWINDOW_X11_XIDPA_PROP_APPLICATION_NAMEAPPLICATION_NAMEPA_PROP_APPLICATION_IDAPPLICATION_IDPA_PROP_APPLICATION_VERSIONAPPLICATION_VERSIONPA_PROP_APPLICATION_ICONAPPLICATION_ICONPA_PROP_APPLICATION_ICON_NAMEAPPLICATION_ICON_NAMEPA_PROP_APPLICATION_LANGUAGEAPPLICATION_LANGUAGEPA_PROP_APPLICATION_PROCESS_IDAPPLICATION_PROCESS_IDPA_PROP_APPLICATION_PROCESS_BINARYAPPLICATION_PROCESS_BINARYPA_PROP_APPLICATION_PROCESS_USERAPPLICATION_PROCESS_USERPA_PROP_APPLICATION_PROCESS_HOSTAPPLICATION_PROCESS_HOSTPA_PROP_APPLICATION_PROCESS_MACHINE_IDAPPLICATION_PROCESS_MACHINE_IDPA_PROP_APPLICATION_PROCESS_SESSION_IDAPPLICATION_PROCESS_SESSION_IDPA_PROP_DEVICE_STRINGDEVICE_STRINGPA_PROP_DEVICE_APIDEVICE_APIPA_PROP_DEVICE_DESCRIPTIONDEVICE_DESCRIPTIONPA_PROP_DEVICE_BUS_PATHDEVICE_BUS_PATHPA_PROP_DEVICE_SERIALDEVICE_SERIALPA_PROP_DEVICE_VENDOR_IDDEVICE_VENDOR_IDPA_PROP_DEVICE_VENDOR_NAMEDEVICE_VENDOR_NAMEPA_PROP_DEVICE_PRODUCT_IDDEVICE_PRODUCT_IDPA_PROP_DEVICE_PRODUCT_NAMEDEVICE_PRODUCT_NAMEPA_PROP_DEVICE_CLASSDEVICE_CLASSPA_PROP_DEVICE_FORM_FACTORDEVICE_FORM_FACTORPA_PROP_DEVICE_BUSDEVICE_BUSPA_PROP_DEVICE_ICONDEVICE_ICONPA_PROP_DEVICE_ICON_NAMEDEVICE_ICON_NAMEPA_PROP_DEVICE_ACCESS_MODEDEVICE_ACCESS_MODEPA_PROP_DEVICE_MASTER_DEVICEDEVICE_MASTER_DEVICEPA_PROP_DEVICE_BUFFERING_BUFFER_SIZEDEVICE_BUFFERING_BUFFER_SIZEPA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZEDEVICE_BUFFERING_FRAGMENT_SIZEPA_PROP_DEVICE_PROFILE_NAMEDEVICE_PROFILE_NAMEPA_PROP_DEVICE_PROFILE_DESCRIPTIONDEVICE_PROFILE_DESCRIPTIONPA_PROP_MODULE_AUTHORMODULE_AUTHORPA_PROP_MODULE_DESCRIPTIONMODULE_DESCRIPTIONPA_PROP_MODULE_USAGEMODULE_USAGEPA_PROP_MODULE_VERSIONMODULE_VERSIONPA_PROP_FORMAT_RATEFORMAT_RATEPA_PROP_FORMAT_CHANNELSFORMAT_CHANNELSFILTER_APPLY/// For streams: the name of a filter that is desired, e.g. “echo-cancel” or “equalizer-sink”./// Differs from [`FILTER_WANT`] in that it forces PulseAudio to apply the filter, regardless of/// whether PulseAudio thinks it makes sense to do so or not. If this is set, [`FILTER_WANT`] is/// ignored. In other words, you almost certainly do not want to use this.FILTER_SUPPRESS/// For streams: the name of a filter that should specifically be suppressed (i.e. overrides/// [`FILTER_WANT`]). Useful for the times that [`FILTER_WANT`] is automatically added (e.g./// echo-cancellation for phone streams when $VOIP_APP does its own, internal AEC).DEVICE_INTENDED_ROLES/// For devices: intended use. A space separated list of roles (see [`MEDIA_ROLE`]) this device/// is particularly well suited for, due to latency, quality or form factor.FORMAT_SAMPLE_FORMAT/// For PCM formats: the sample format used as returned by/// [`Format::to_string()`](crate::sample::Format::to_string).FORMAT_CHANNEL_MAP/// For PCM formats: the channel map of the stream as returned by/// [`Map::print()`](crate::channelmap::Map::print)./* These need defining here, rather than `pub use`, in order to correctly link to other things
     * in their doc comments *//// Common properties.ProplistInner/// A property list object. Basically a dictionary with ASCII strings as keys and arbitrary data as/// Inner type holding ownership over actual C object, necessary to guard against use-after-free/// issues with respect to the related `Iterator` object.pl_ref/// The actual C proplist object./// State tracker, used by underlying C function./// Use lifetime `'a`./// Proplist iterator, used for iterating over the list’s keys. Returned by the/// [`Proplist::iter()`] method./// Note, lifetime `'a` is used to tie an instance of this struct to the associated `Proplist`, and/// thus prevent a use-after-free issue that would otherwise occur should the `Proplist` be/// destroyed first. Conversion from a `Proplist` via `into_iter` is okay though as responsibility/// for destruction is transfered to it.//XXX: Do **NOT** derive `Clone` for this, it will introduce a use-afer-free. To implement `Clone` properly would require an `Rc` wrapper around `ProplistInner`, but then if that would apply to `Proplist` also, that affects the `Send`+`Sync` properties of `Proplist` and anything using it./// Allocates a property list./// Allocates a new property list and assigns key/value from a human readable string./// Creates a new `Proplist` from an existing [`ProplistInternal`] pointer.key_is_valid/// Checks if the key is valid./// Appends a new string entry to the property list, possibly overwriting an already existing/// entry with the same key./// An internal copy is made of the provided string.set_pl/// This is similar to [`set_str()`](Self::set_str), however here the provided key and value/// are combined into a single string, separated by an `=`. An internal copy is made of the/// provided string./// Appends a new arbitrary data entry to the property list, possibly overwriting an already/// existing entry with the same key./// An internal copy of the provided data is made./// Gets a string entry for the specified key./// Will return `None` if the key does not exist or if data is not valid UTF-8./// Gets the value for the specified key./// For string entries, the value store will be NUL-terminated./// The caller should make a copy of the data before any subsequent modification or destruction/// of the property list./// Returns a slice formed from the data pointer and the length of the data./// Returns `None` if key does not exist./// Merges property list “other” into self, adhering to the merge mode specified./// Removes a single entry from the property list, identified by the specified key name.unset_many/// Similar to [`unset()`](Self::unset) but takes an array of keys to remove./// Returns `None` on failure, otherwise the number of entries actually removed (which might/// even be 0, if there were no matching entries to remove)./// Gets an immutable iterator over the list’s keys./// The property list should not be modified during iteration through the list, with the/// exception of deleting the current entry. The keys in the property list do not have any/// particular order./// # extern crate libpulse_binding as pulse;/// # use pulse::proplist::Proplist;/// #     let mut my_props = Proplist::new().unwrap();/// #     my_props.set_str(pulse::proplist::properties::APPLICATION_NAME, "FooApp").unwrap();/// for key in my_props.iter() {///     //do something with it///     println!("key: {}", key);/// Formats the property list nicely as a human readable string./// This works very much like [`to_string_sep()`](Self::to_string_sep) and uses a newline as/// separator and appends one final one.to_string_sep/// Formats the property list nicely as a human readable string, choosing the separator used./// Checks if this contains an entry with the given key./// Returns `true` if an entry for the specified key exists in the property list. Returns `None`/// on error./// Removes all entries from the property list object./// Gets the number of entries in the property list./// Checks if the proplist is empty./// Allocates a new property list and copy over every single entry from the specified list./// If this is called on a ‘weak’ instance, a non-weak object is returned.proplist_iter_lifetime_conv/// Test that you can however return an iterator if you convert the `Proplist` into one//! Property list constants and functions.RATE_MAX/// Maximum allowed sample rate./// Unsigned 8 Bit PCM.ALaw/// 8 Bit a-Law.ULaw/// 8 Bit mu-Law.S16le/// Signed 16 Bit PCM, little endian (PC).S16be/// Signed 16 Bit PCM, big endian.F32le/// 32 Bit IEEE floating point, little endian (PC), range -1.0 to 1.0.F32be/// 32 Bit IEEE floating point, big endian, range -1.0 to 1.0.S32le/// Signed 32 Bit PCM, little endian (PC).S32be/// Signed 32 Bit PCM, big endian.S24le/// Signed 24 Bit PCM packed, little endian (PC).S24be/// Signed 24 Bit PCM packed, big endian.S24_32le/// Signed 24 Bit PCM in LSB of 32 Bit words, little endian (PC).S24_32be/// Signed 24 Bit PCM in LSB of 32 Bit words, big endian./// An invalid value._IMPL_NUM_FromPrimitive_FOR_Format_IMPL_NUM_ToPrimitive_FOR_Format/// Sample format./// Note, native-endian (endian-independent) associated constants are available on this type which/// should be preferred over direct use of the endian-specific variants, for improved flexibility/// and avoidance of mistakes.format_compare_capipa_sample_format_tSAMPLE_FLOAT32/// A shortcut for [`SAMPLE_FLOAT32NE`].SAMPLE_S16NE/// Signed 16-bit PCM, native endian.SAMPLE_FLOAT32NE/// 32-bit IEEE floating point, native endian.SAMPLE_S32NE/// Signed 32-bit PCM, native endian.SAMPLE_S24NE/// Signed 24-bit PCM packed, native endian.SAMPLE_S24_32NE/// Signed 24-bit PCM in LSB of 32-bit words, native endian.SAMPLE_S16RE/// Signed 16-bit PCM reverse endian.SAMPLE_FLOAT32RE/// 32-bit IEEE floating point, reverse endian.SAMPLE_S32RE/// Signed 32-bit PCM, reverse endian.SAMPLE_S24RE/// Signed 24-bit PCM, packed reverse endian.SAMPLE_S24_32RE/// Signed 24-bit PCM, in LSB of 32-bit words, reverse endian.ei_formats/// Endian-independent format identifiers, for little-endian systems./// The sample format./// The sample rate. (e.g. 44100)./// Audio channels. (1 for mono, 2 for stereo, ...)./// A sample format and attribute specification.spec_compare_capipa_sample_spec/// Initializes the specified sample spec./// The sample spec will have a defined state but [`is_valid()`](Self::is_valid) will fail for/// Checks if the whole sample type specification is valid.format_is_valid/// Checks only if the format attribute is valid./// Or in other words that the client library running on the end user system accepts it.rate_is_valid/// Checks only if the rate is within the supported range.channels_are_valid/// Checks only if the channel count is within the supported range.bytes_per_second/// Gets the amount of bytes that constitute playback of one second of audio, with the specified/// sample type.frame_size/// Gets the size of a frame./// Gets the size of a sample.bytes_to_usec/// Calculates the time it would take to play a buffer of the specified size./// The return value will always be rounded down for non-integral return values./// Note, the underlying calculation may overflow for very large values.usec_to_bytes/// Calculates the size of a buffer required, for playback duration of the time specified./// Pretty prints a sample type specification to a string.bytes_print/// Pretty print a byte size value (i.e. “2.5 MiB”).S16NEFLOAT32NES32NES24NES24_32NES16REFLOAT32RES32RES24RES24_32RE/// Similar to [`Spec::sample_size()`] but take a sample format instead of full sample spec./// Gets a descriptive string for the specified sample format./// Parses a sample format text. Inverse of [`to_string()`](Self::to_string)./// Checks if format is little endian./// Returns `true` when the specified format is little endian, `false` if big endian. Returns/// `None` when endianness does not apply to this format, or if unknown.is_be/// Checks if format is big endian./// Returns `true` when the specified format is big endian, `false` if little endian. Returnsis_ne/// Checks if format is native endian./// Returns `true` when the specified format is native endian, `false` when not. Returns `None`/// when endianness does not apply to the specified format, or endianness is unknown.is_re/// Checks if format is reverse of native endian./// Returns `true` when the specified format is reverse endian, `false` when not. Returns `None`//! Constants and routines for sample type handling.//! PulseAudio is capable of handling a multitude of sample formats, rates and channels,//! transparently converting and mixing them as needed.//! # Sample Formats//! PulseAudio supports the following sample formats://! * `U8` - Unsigned 8 bit integer PCM.//! * `S16LE` - Signed 16 integer bit PCM, little endian.//! * `S16BE` - Signed 16 integer bit PCM, big endian.//! * `FLOAT32LE` - 32 bit IEEE floating point PCM, little endian.//! * `FLOAT32BE` - 32 bit IEEE floating point PCM, big endian.//! * `ALAW` - 8 bit a-Law.//! * `ULAW` - 8 bit mu-Law.//! * `S32LE` - Signed 32 bit integer PCM, little endian.//! * `S32BE` - Signed 32 bit integer PCM, big endian.//! * `S24LE` - Signed 24 bit integer PCM packed, little endian.//! * `S24BE` - Signed 24 bit integer PCM packed, big endian.//! * `S24_32LE` - Signed 24 bit integer PCM in LSB of 32 bit words, little endian.//! * `S24_32BE` - Signed 24 bit integer PCM in LSB of 32 bit words, big endian.//! The floating point sample formats have the range from `-1.0` to `1.0`.//! # Sample Rates//! PulseAudio supports any sample rate between 1 Hz and 192000 Hz. There is no point trying to//! exceed the sample rate of the output device though as the signal will only get downsampled,//! consuming CPU on the machine running the server.//! # Channels//! PulseAudio supports up to 32 individual channels. The order of the channels is up to the//! application, but they must be continuous. To map channels to speakers, see//! [`channelmap`](mod@crate::channelmap).//! # Calculations//! The PulseAudio library contains a number of convenience functions to do calculations on sample//! formats://! * [`Spec::bytes_per_second()`]: The number of bytes one second of audio will take given a sample//!   format.//! * [`Spec::frame_size()`]: The size, in bytes, of one frame (i.e. one set of samples, one for//!   each channel).//! * [`Spec::sample_size()`]: The size, in bytes, of one sample.//! * [`Spec::bytes_to_usec()`]: Calculate the time it would take to play a buffer of a certain//!   size.// The following are endian-independant format references.pa_streamStreamInternalpa_seek_mode_tSeekModepa_stream_direction_t/// An opaque stream for playback or recording.RequestCbunderflowlatency_updatemovedsuspendedbuffer_attr/// The stream is not yet connected to any sink or source.Creating/// The stream is being created./// The stream is established, you may pass audio data to it now./// An error occurred that made the stream invalid./// The stream has been terminated cleanly./// Stream state.pa_stream_state_t/// Checks if the passed state is one of the connected states.r" Create the stream corked, requiring an explicit [`Stream::uncork()`] call to uncork it."START_CORKEDr" Interpolate the latency for this stream. When enabled, [`Stream::get_latency()`] and"r" [`Stream::get_time()`] will try to estimate the current record/playback time based on"r" the local time that passed since the last timing info update. Using this option has the"r" advantage of not requiring a whole round trip when the current playback/recording time"r" is needed. Consider using this option when requesting latency information frequently."r" This is especially useful on long latency network connections. It makes a lot of sense"r" to combine this option with [`AUTO_TIMING_UPDATE`]."r" [`AUTO_TIMING_UPDATE`]: Self::AUTO_TIMING_UPDATE"INTERPOLATE_TIMINGr" Don’t force the time to increase monotonically. If this option is enabled,"r" [`Stream::get_time()`] will not necessarily return always monotonically increasing time"r" values on each call. This may confuse applications which cannot deal with time going"r" ‘backwards’, but has the advantage that bad transport latency estimations that caused"r" the time to jump ahead can be corrected quickly, without the need to wait."NOT_MONOTONICr" If set timing update requests are issued periodically automatically. Combined with"r" [`INTERPOLATE_TIMING`] you will be able to query the current time and latency with"r" [`Stream::get_time()`] and [`Stream::get_latency()`] at all times without a packet round"r" trip."r" [`INTERPOLATE_TIMING`]: Self::INTERPOLATE_TIMING"AUTO_TIMING_UPDATEr" Don’t remap channels by their name, instead map them simply by their index. Implies"r" [`NO_REMIX_CHANNELS`](Self::NO_REMIX_CHANNELS)."NO_REMAP_CHANNELSr" When remapping channels by name, don’t upmix or downmix them to related channels. Copy"r" them into matching channels of the device 1:1."NO_REMIX_CHANNELSr" Use the sample format of the sink/device this stream is being connected to, and possibly"r" ignore the format the sample spec contains -- but you still have to pass a valid value"r" in it as a hint to PulseAudio what would suit your stream best. If this is used you"r" should query the used sample format after creating the stream by using"r" [`Stream::get_sample_spec()`]. Also, if you specified manual buffer metrics it is"r" recommended to update them with [`Stream::set_buffer_attr()`] to compensate for the"r" changed frame sizes."r" When creating streams with [`Stream::new_extended()`], this flag has no effect. If you"r" specify a format with PCM encoding, and you want the server to choose the sample format,"r" then you should leave the sample format unspecified in the [`Info`] object. This also"r" means that you can’t use [`Info::new_from_sample_spec()`], because that function always"r" sets the sample format."r" [`Info`]: crate::format::Info"r" [`Info::new_from_sample_spec()`]: crate::format::Info::new_from_sample_spec"FIX_FORMATr" Use the sample rate of the sink, and possibly ignore the rate the sample spec contains."r" Usage similar to [`FIX_FORMAT`]."r" specify a format with PCM encoding, and you want the server to choose the sample rate,"r" then you should leave the rate unspecified in the [`Info`] object. This also means that"r" you can’t use [`Info::new_from_sample_spec()`], because that function always sets the"r" sample rate."r" [`FIX_FORMAT`]: Self::FIX_FORMAT"FIX_RATEr" Use the number of channels and the channel map of the sink, and possibly ignore the number"r" of channels and the map the sample spec and the passed channel map contains. Usage similar"r" to [`FIX_FORMAT`]."r" specify a format with PCM encoding, and you want the server to choose the channel count"r" and/or channel map, then you should leave the channels and/or the channel map"r" unspecified in the [`Info`] object. This also means that you can’t use"r" [`Info::new_from_sample_spec()`], because that function always sets the channel count"r" (but if you only want to leave the channel map unspecified, then"r" [`Info::new_from_sample_spec()`] works, because the channel map parameter is optional)."FIX_CHANNELSr" Don’t allow moving of this stream to another sink/device. Useful if you use any of the"r" `Fix*` flags and want to make sure that resampling never takes place -- which might"r" happen if the stream is moved to another sink/source with a different sample"r" spec/channel map."DONT_MOVEr" Allow dynamic changing of the sampling rate during playback with"r" [`Stream::update_sample_rate()`]."VARIABLE_RATEr" Find peaks instead of resampling."PEAK_DETECTr" Create in muted state. If neither [`START_UNMUTED`] nor this is specified, it is left to"r" the server to decide whether to create the stream in muted or in un-muted state."r" [`START_UNMUTED`]: Self::START_UNMUTED"START_MUTEDr" Try to adjust the latency of the sink/source based on the requested buffer metrics and"r" adjust buffer metrics accordingly. Also see [`BufferAttr`]. This option may not be"r" specified at the same time as [`EARLY_REQUESTS`]."r" [`EARLY_REQUESTS`]: Self::EARLY_REQUESTS"r" [`BufferAttr`]: crate::def::BufferAttr"ADJUST_LATENCYr" Enable compatibility mode for legacy clients that rely on a “classic” hardware device"r" fragment-style playback model. If this option is set, the `minreq` value of the buffer"r" metrics gets a new meaning: instead of just specifying that no requests asking for less"r" new data than this value will be made to the client it will also guarantee that requests"r" are generated as early as this limit is reached. This flag should only be set in very"r" few situations where compatibility with a fragment-based playback model needs to be kept"r" and the client applications cannot deal with data requests that are delayed to the"r" latest moment possible. (Usually these are programs that use usleep() or a similar call"r" in their playback loops instead of sleeping on the device itself.) Also see"r" [`BufferAttr`]. This option may not be specified at the same time as [`ADJUST_LATENCY`]."r" [`ADJUST_LATENCY`]: Self::ADJUST_LATENCY"EARLY_REQUESTSr" If set this stream won’t be taken into account when it is checked whether the device"r" this stream is connected to should auto-suspend."DONT_INHIBIT_AUTO_SUSPENDr" Create in unmuted state. If neither [`START_MUTED`] nor this is specified, it is left to"r" the server to decide whether to create the stream in muted or in unmuted state."r" [`START_MUTED`]: Self::START_MUTED"START_UNMUTEDr" If the sink/source this stream is connected to is suspended during the creation of this"r" stream, cause it to fail. If the sink/source is being suspended during creation of this"r" stream, make sure this stream is terminated."FAIL_ON_SUSPENDr" If a volume is passed when this stream is created, consider it relative to the sink’s"r" current volume, never as absolute device volume. If this is not specified the volume"r" will be consider absolute when the sink is in flat volume mode, relative otherwise."RELATIVE_VOLUMEr" Used to tag content that will be rendered by passthrough sinks. The data will be left as"r" is and not reformatted, resampled."PASSTHROUGH/// Create the stream corked, requiring an explicit [`Stream::uncork()`] call to uncork it./// [`Stream::uncork()`]: ../struct.Stream.html#method.uncork/// Interpolate the latency for this stream. When enabled, [`Stream::get_latency()`] and/// [`Stream::get_time()`] will try to estimate the current record/playback time based on the/// local time that passed since the last timing info update. Using this option has the/// advantage of not requiring a whole round trip when the current playback/recording time is/// needed. Consider using this option when requesting latency information frequently. This is/// especially useful on long latency network connections. It makes a lot of sense to combine/// this option with [`AUTO_TIMING_UPDATE`]./// [`Stream::get_latency()`]: ../struct.Stream.html#method.get_latency/// [`Stream::get_time()`]: ../struct.Stream.html#method.get_time/// Don’t force the time to increase monotonically. If this option is enabled,/// [`Stream::get_time()`] will not necessarily return always monotonically increasing time/// values on each call. This may confuse applications which cannot deal with time going/// ‘backwards’, but has the advantage that bad transport latency estimations that caused the/// time to jump ahead can be corrected quickly, without the need to wait./// [`Stream::get_time()`]: super::Stream::get_time/// If set timing update requests are issued periodically automatically. Combined with/// [`INTERPOLATE_TIMING`] you will be able to query the current time and latency with/// [`Stream::get_time()`] and [`Stream::get_latency()`] at all times without a packet round/// trip./// [`Stream::get_latency()`]: super::Stream::get_latency/// Don’t remap channels by their name, instead map them simply by their index. Implies/// [`NO_REMIX_CHANNELS`](constant.NO_REMIX_CHANNELS.html)./// When remapping channels by name, don’t upmix or downmix them to related channels. Copy them/// into matching channels of the device 1:1./// Use the sample format of the sink/device this stream is being connected to, and possibly/// ignore the format the sample spec contains -- but you still have to pass a valid value in it/// as a hint to PulseAudio what would suit your stream best. If this is used you should query/// the used sample format after creating the stream by using [`Stream::get_sample_spec()`]./// Also, if you specified manual buffer metrics it is recommended to update them with/// [`Stream::set_buffer_attr()`] to compensate for the changed frame sizes./// When creating streams with [`Stream::new_extended()`], this flag has no effect. If you/// specify a format with PCM encoding, and you want the server to choose the sample format,/// then you should leave the sample format unspecified in the [`Info`] object. This also means/// that you can’t use [`Info::new_from_sample_spec()`], because that function always sets the/// sample format./// [`Stream::get_sample_spec()`]: super::Stream::get_sample_spec/// [`Stream::set_buffer_attr()`]: super::Stream::set_buffer_attr/// [`Stream::new_extended()`]: super::Stream::new_extended/// [`Info`]: crate::format::Info/// [`Info::new_from_sample_spec()`]: crate::format::Info::new_from_sample_spec/// Use the sample rate of the sink, and possibly ignore the rate the sample spec contains./// Usage similar to [`FIX_FORMAT`]./// specify a format with PCM encoding, and you want the server to choose the sample rate, then/// you should leave the rate unspecified in the [`Info`] object. This also means that you can’t/// use [`Info::new_from_sample_spec()`], because that function always sets the sample rate./// [`FIX_FORMAT`]: constant.FIX_FORMAT.html/// Use the number of channels and the channel map of the sink, and possibly ignore the number/// of channels and the map the sample spec and the passed channel map contains. Usage similar/// to [`FIX_FORMAT`]./// specify a format with PCM encoding, and you want the server to choose the channel count/// and/or channel map, then you should leave the channels and/or the channel map unspecified in/// the [`Info`] object. This also means that you can’t use [`Info::new_from_sample_spec()`],/// because that function always sets the channel count (but if you only want to leave the/// channel map unspecified, then [`Info::new_from_sample_spec()`] works, because the channel/// map parameter is optional)./// Don’t allow moving of this stream to another sink/device. Useful if you use any of the/// `Fix*` flags and want to make sure that resampling never takes place -- which might happen/// if the stream is moved to another sink/source with a different sample spec/channel map./// Allow dynamic changing of the sampling rate during playback with/// [`Stream::update_sample_rate()`]./// [`Stream::update_sample_rate()`]: super::Stream::update_sample_rate/// Find peaks instead of resampling./// Create in muted state. If neither [`START_UNMUTED`] nor this is specified, it is left to the/// server to decide whether to create the stream in muted or in un-muted state./// Try to adjust the latency of the sink/source based on the requested buffer metrics and/// adjust buffer metrics accordingly. Also see [`BufferAttr`]. This option may not be/// specified at the same time as [`EARLY_REQUESTS`]./// [`BufferAttr`]: crate::def::BufferAttr/// Enable compatibility mode for legacy clients that rely on a “classic” hardware device/// fragment-style playback model. If this option is set, the `minreq` value of the buffer/// metrics gets a new meaning: instead of just specifying that no requests asking for less new/// data than this value will be made to the client it will also guarantee that requests are/// generated as early as this limit is reached. This flag should only be set in very few/// situations where compatibility with a fragment-based playback model needs to be kept and the/// client applications cannot deal with data requests that are delayed to the latest moment/// possible. (Usually these are programs that use usleep() or a similar call in their playback/// loops instead of sleeping on the device itself.) Also see [`BufferAttr`]. This option may/// not be specified at the same time as [`ADJUST_LATENCY`]./// If set this stream won’t be taken into account when it is checked whether the device this/// stream is connected to should auto-suspend./// Create in unmuted state. If neither [`START_MUTED`] nor this is specified, it is left to the/// server to decide whether to create the stream in muted or in unmuted state./// If the sink/source this stream is connected to is suspended during the creation of this/// stream, cause it to fail. If the sink/source is being suspended during creation of this/// stream, make sure this stream is terminated./// If a volume is passed when this stream is created, consider it relative to the sink’s/// current volume, never as absolute device volume. If this is not specified the volume will be/// consider absolute when the sink is in flat volume mode, relative otherwise./// Used to tag content that will be rendered by passthrough sinks. The data will be left as is/// and not reformatted, resampled./// Some special flags for stream connections.EVENT_REQUEST_CORK/// A stream policy/meta event requesting that an application should cork a specific stream.EVENT_REQUEST_UNCORKEVENT_FORMAT_LOST/// A stream event notifying that the stream is going to be disconnected because the underlying/// sink changed and no longer supports the format that was originally negotiated. Clients need/// to connect a new stream to renegotiate a format and continue playback.event_names/// Common event names supplied to the [`Stream::set_event_callback()`] callback.PeekResult/// No data (Null data pointer and size of 0 returned by PA).Hole/// Data hole with given size (Null pointer with non-zero size returned by PA)./// Data available, with slice into memory returned by PA./// Result type for the [`Stream::peek()`] method. See documentation of the method itself for more/// No latency.Positive/// A positive (greater than zero) amount of latency.Negative/// A negative (less than zero) amount of latency./// Result type for [`Stream::get_latency()`]./// Creates a new, unconnected stream with the specified name and sample type./// It is recommended to use [`new_with_proplist()`] instead and specify some initial/// properties./// * `ctx`: The context to create this stream in/// * `name`: A name for this stream/// * `ss`: The desired sample format/// * `map`: The desired channel map, or `None` for default/// [`new_with_proplist()`]: Self::new_with_proplist/// Creates a new, unconnected stream with the specified name and sample type, and specify the/// initial stream property list./// * `proplist`: The initial property listnew_extended/// Creates a new, unconnected stream with the specified name, the set of formats this client/// can provide, and an initial list of properties./// While connecting, the server will select the most appropriate format which the client must/// then provide./// * `formats`: The list of formats that can be provided/// Creates a new `Stream` from an existing [`StreamInternal`] pointer./// Gets the current state of the stream./// Gets the sink input resp. source output index this stream is identified in the server with./// This is useful with the introspection functions such as/// [`Introspector::get_sink_input_info()`] or [`Introspector::get_source_output_info()`]./// [`Introspector::get_sink_input_info()`]: crate::context::introspect::Introspector::get_sink_input_info/// [`Introspector::get_source_output_info()`]: crate::context::introspect::Introspector::get_source_output_infoget_device_index/// Gets the index of the sink or source this stream is connected to in the server./// [`Introspector::get_sink_info_by_index()`] or [`Introspector::get_source_info_by_index()`]./// Please note that streams may be moved between sinks/sources and thus it is recommended to/// use [`set_moved_callback()`] to be notified about this./// [`set_moved_callback()`]: Self::set_moved_callback/// [`Introspector::get_sink_info_by_index()`]: crate::context::introspect::Introspector::get_sink_info_by_index/// [`Introspector::get_source_info_by_index()`]: crate::context::introspect::Introspector::get_source_info_by_indexget_device_name/// Gets the name of the sink or source this stream is connected to in the server./// [`Introspector::get_sink_info_by_name()`] or [`Introspector::get_source_info_by_name()`]./// [`Introspector::get_sink_info_by_name()`]: crate::context::introspect::Introspector::get_sink_info_by_name/// [`Introspector::get_source_info_by_name()`]: crate::context::introspect::Introspector::get_source_info_by_name/// Checks whether or not the sink or source this stream is connected to has been suspended.is_corked/// Checks whether or not this stream has been corked.connect_playback/// Connects the stream to a sink./// It is strongly recommended to pass `None` in both `dev` and `volume` and to set neither/// [`FlagSet::START_MUTED`] nor [`FlagSet::START_UNMUTED`] -- unless these options are directly/// dependent on user input or configuration./// If you follow this rule then the sound server will have the full flexibility to choose the/// device, volume and mute status automatically, based on server-side policies, heuristics and/// stored information from previous uses. Also the server may choose to reconfigure audio/// devices to make other sinks/sources or capabilities available to be able to accept the/// Before PA 0.9.20 it was not defined whether the ‘volume’ parameter was interpreted relative/// to the sink’s current volume or treated as an absolute device volume. Since PA 0.9.20 it is/// an absolute volume when the sink is in flat volume mode, and relative otherwise, thus making/// sure the volume passed here has always the same semantics as the volume passed to/// [`Introspector::set_sink_input_volume()`]. It is possible to figure out whether flat volume/// mode is in effect for a given sink by calling [`Introspector::get_sink_info_by_name()`]./// Since PA 5.0, it’s possible to specify a single-channel volume even if the stream has/// multiple channels. In that case the same volume is applied to all channels./// * `dev`: Name of the sink to connect to, or `None` to let the server decide/// * `attr`: Buffering attributes, or `None` for default/// * `flags`: Additional flags, or `0` for default/// * `volume`: Initial volume, or `None` for default/// * `sync_stream`: Synchronize this stream with the specified one, or `None` for a standalone///   stream./// [`Introspector::set_sink_input_volume()`]: crate::context::introspect::Introspector::set_sink_input_volumeconnect_record/// Connects the stream to a source./// * `dev`: Name of the source to connect to, or `None` to let the server decideconnect_upload/// Makes this stream a sample upload stream./// (See [`scache`](mod@crate::context::scache)).finish_upload/// Finishes the sample upload, the stream name will become the sample name./// You cancel a sample upload by issuing [`disconnect()`](Self::disconnect)./// Disconnects a stream from a source/sink.begin_write/// Prepares writing data to the server (for playback streams)./// This function may be used to optimize the number of memory copies when doing playback/// (“zero-copy”). It is recommended to call this function before each call to [`write()`]. It/// is used to obtain a chunk of PA internally allocated memory, into which you can directly/// write your data before calling [`write()`] to actually execute the write./// This function should be called with `nbytes` set to the number of bytes you want to write,/// or `None`, in which case the size will be chosen automatically (which is recommended)./// The return value is a `Result` type, with the `Ok` variant wrapping an `Option`. `Err` will/// be returned if PA encountered an error; `Ok(None)` will be  returned if it appeared to be/// successful, but the pointer returned was `NULL`, otherwise the buffer will be returned as/// `Ok(Some(_))`./// After placing your data in the memory area returned, call [`write()`] with a sub-slice of/// it, to actually execute the write. **Note**, the buffer may only be used once, i.e. if you/// were thinking of getting a large buffer, placing a large chunk of data into it, then perform/// multiple small writes from it, you **cannot** do this. Any attempt at accessing the memory/// returned after the following [`write()`] or [`cancel_write()`] is invalid./// If you want to cancel a previously called `begin_write()` without calling [`write()`] use/// [`cancel_write()`]./// The memory should **not** be explicitly freed by the caller./// An invocation of [`write()`] should “quickly” follow a `begin_write()`. It is not/// recommended letting an unbounded amount of time pass after calling `begin_write()` and/// before calling [`write()`]. Calling `begin_write()` twice without calling [`write()`] or/// [`cancel_write()`] in between will return exactly the same `data` pointer and `nbytes`/// [`write()`]: Self::write/// [`cancel_write()`]: Self::cancel_writecancel_write/// Reverses the effect of [`begin_write()`] dropping any data that has already been placed in/// the memory area returned by [`begin_write()`]./// Only valid to call after a call to [`begin_write()`] has been made, and neither/// `cancel_write()` nor [`write()`] have been called yet. Accessing the memory previously/// returned by [`begin_write()`] after calling this function is invalid./// [`begin_write()`]: Self::begin_write/// Writes some data to the server (for playback streams)./// If `free_cb` is provided, this routine is called when all data has been written out. An/// internal reference to the specified data is kept, the data is not copied. If `None`, the/// data is copied into an internal buffer./// The client may freely seek around in the output buffer. For most applications it is typical/// to pass `0` and [`SeekMode::Relative`] as values for the arguments `offset` and `seek`/// respectively. After a successful write call the write index will be at the position after/// where this chunk of data has been written to./// As an optimization for avoiding needless memory copies you may call [`begin_write()`] before/// this call and then place your audio data directly in the memory area returned by that call./// Then, pass a pointer to that memory area to `write()`. After the invocation of `write()` the/// memory area may no longer be accessed. Any further explicit freeing of the memory area is/// not necessary. It is OK to write to the memory area returned by [`begin_write()`] only/// partially with this call, skipping bytes both at the end and at the beginning of the/// reserved memory area./// * `data`: The data to write. The length must be in multiples of the stream’s sample spec///   frame size./// * `free_cb`: A cleanup routine for the data or `None` to request an internal copy of the///   data./// * `offset`: Offset for seeking. Must be `0` for upload streams. Must be in multiples of the///   stream’s sample spec frame size./// * `seek`: Seek mode. Must be [`SeekMode::Relative`] for upload streams.write_copy/// This function does exactly the same as [`write()`] as though `None` had been specified for/// the `free_cb` param. I.e. an internal copy will be made of the provided data.write_ext_free/// This function does exactly the same as [`write()`] with the only difference being that a/// void pointer is provided along with the `free_cb` callback pointer, and this void pointer/// will be passed to the callback instead of the `data` pointer.///   data. If provided, the accompanying data pointer will be supplied to the callback./// * `offset`: Offset for seeking. Must be `0` for upload streams./// * `seek`: Seek mode, must be [`SeekMode::Relative`] for upload streams./// Reads the next fragment from the buffer (for recording streams)./// This function returns one of the [`PeekResult`] variants - either [`Empty`], [`Hole`] or/// [`Data`]:///  * If there is data at the current read index, the [`Data`] variant will be returned, which///    contains a slice giving a view of the data. (The length of this slice can be less or more///    than a complete fragment). This is pointing into an internal buffer, so obviously you///    must make a copy of it if you want to keep it.///  * If there is no data at the current read index, it means that either the buffer is empty///    or it contains a hole (that is, the write index is ahead of the read index but there’s no///    data where the read index points at). If the buffer is empty, the [`Empty`] result///    variant will be returned. If there is a hole, the [`Hole`] variant will be returned,///    containing the length of the hole in bytes./// Use [`discard()`] to actually remove the data from the buffer and move the read index/// forward. [`discard()`] should not be called if the buffer is empty, but it should be called/// if there is a hole./// [`Empty`]: PeekResult::Empty/// [`Hole`]: PeekResult::Hole/// [`Data`]: PeekResult::Data/// [`discard()`]: Self::discard/// Removes the current fragment on record streams./// It is invalid to do this without first calling [`peek()`](Self::peek)./// Note: The original C function name used the term `drop`; We instead use `discard` here to/// avoid conflict with the Rust `Drop` trait!writable_size/// Gets the number of bytes requested by the server that have not yet been written./// It is possible to write more than this amount, up to the stream’s [`buffer_attr.maxlength`]/// bytes. This is usually not desirable, though, as it would increase stream latency to be/// higher than requested ([`buffer_attr.tlength`])./// [`buffer_attr.maxlength`]: crate::def::BufferAttr.maxlength/// [`buffer_attr.tlength`]: crate::def::BufferAttr.tlengthreadable_size/// Gets the number of bytes that may be read using [`peek()`](Self::peek)./// Drains a playback stream./// Use this for notification when the playback buffer is empty after playing all the audio in/// the buffer. Please note that only one drain operation per stream may be issued at a time.update_timing_info/// Requests a timing info structure update for a stream./// Use [`get_timing_info()`] to get access to the raw timing data, or [`get_time()`] or/// [`get_latency()`] to get cleaned up values./// [`get_timing_info()`]: Self::get_timing_info/// [`get_time()`]: Self::get_time/// [`get_latency()`]: Self::get_latency/// Sets the callback function that is called whenever the state of the stream changes.set_write_callback/// Sets the callback function that is called when new data may be written to the stream./// The callback accepts an argument giving the number of bytes.set_read_callback/// Sets the callback function that is called when new data is available from the stream.set_overflow_callback/// Sets the callback function that is called when a buffer overflow happens. (Only for playback/// streams).get_underflow_index/// Gets at what position the latest underflow occurred./// `None` is returned if this information is not known (e.g. if no underflow has occurred)./// This can be used inside the underflow callback to get information about the current/// underflow. (Only for playback streams).set_underflow_callback/// Sets the callback function that is called when a buffer underflow happens./// (Only for playback streams).set_started_callback/// Sets the callback function that is called when the server starts playback after an underrun/// or on initial startup./// This only informs that audio is flowing again, it is no indication that audio started to/// reach the speakers already. (Only for playback streams).set_latency_update_callback/// Sets the callback function that is called whenever a latency information update happens./// Useful on [`FlagSet::AUTO_TIMING_UPDATE`] streams only.set_moved_callback/// Sets the callback function that is called whenever the stream is moved to a different/// sink/source./// Use [`get_device_name()`] or [`get_device_index()`] to query the new sink/source./// [`get_device_name()`]: Self::get_device_name/// [`get_device_index()`]: Self::get_device_indexset_suspended_callback/// Sets the callback function that is called whenever the sink/source this stream is connected/// to is suspended or resumed./// Use [`is_suspended()`] to query the new suspend status. Please note that the suspend status/// might also change when the stream is moved between devices. Thus if you call this function/// you very likely want to call [`set_moved_callback()`] too./// [`is_suspended()`]: Self::is_suspended/// Sets the callback function that is called whenever a meta/policy control event is received./// make sure that your callback function ignores messages it doesn’t know. Some well known/// event names can be found in the [`event_names`](mod@self::event_names) submodule. It is also/// given an (owned) property list.set_buffer_attr_callback/// Sets the callback function that is called whenever the buffer attributes on the server side/// Please note that the buffer attributes can change when moving a stream to a different/// sink/source too, hence if you use this callback you should use [`set_moved_callback()`] as/// well.cork/// Pauses playback of this stream temporarily./// Available on both playback and recording streams./// The pause operation is executed as quickly as possible. If a cork is very quickly followed/// by an uncork, this might not actually have any effect on the stream that is output. You can/// use [`is_corked()`] to find out whether the stream is currently paused or not. Normally a/// stream will be created in uncorked state. If you pass [`FlagSet::START_CORKED`] as a flag/// when connecting the stream, it will be created in corked state./// [`is_corked()`]: Self::is_corkeduncork/// Resumes playback of this stream./// The un-pause operation is executed as quickly as possible. If an uncork is very quickly/// followed by a cork, this might not actually have any effect on the stream that is output./// You can use [`is_corked()`] to find out whether the stream is currently paused or not./// Normally a stream will be created in uncorked state. If you pass [`FlagSet::START_CORKED`]/// as a flag when connecting the stream, it will be created in corked state./// Flushes the playback or record buffer of this stream./// This discards any audio data in the buffer. Most of the time you’re better off using the/// parameter `seek` of [`write()`](Self::write) instead of this function./// Re-enables prebuffering if specified in the [`BufferAttr`] structure./// Available for playback streams only./// Requests immediate start of playback on this stream./// This disables prebuffering temporarily if specified in the [`BufferAttr`] structure./// Renames the stream./// Gets the current playback/recording time./// This is based on the data in the timing info structure returned by [`get_timing_info()`]./// The returned time is in the sound card clock domain, which usually runs at a slightly/// different rate than the system clock./// This function will usually only return new data if a timing info update has been received./// Only if timing interpolation has been requested ([`FlagSet::INTERPOLATE_TIMING`]) the data/// from the last timing update is used for an estimation of the current playback/recording time/// based on the local time that passed since the timing info structure has been acquired./// The time value returned by this function is guaranteed to increase monotonically (the/// returned value is always greater or equal to the value returned by the last call). This/// behaviour can be disabled by using [`FlagSet::NOT_MONOTONIC`]. This may be desirable to/// better deal with bad estimations of transport latencies, but may have strange effects if the/// application is not able to deal with time going ‘backwards’./// The time interpolator activated by [`FlagSet::INTERPOLATE_TIMING`] favours ‘smooth’ time/// graphs over accurate ones to improve the smoothness of UI operations that are tied to the/// audio clock. If accuracy is more important to you, you might need to estimate your timing/// based on the data from [`get_timing_info()`] yourself or not work with interpolated timing/// at all and instead always query the server side for the most up to date timing with/// [`update_timing_info()`]./// If no timing information has been received yet this call will return `Ok(None)`. For more/// details see [`get_timing_info()`]./// [`update_timing_info()`]: Self::update_timing_info/// Determines the total stream latency./// This function is based on [`get_time()`]. The returned time is in the sound card clock/// domain, which usually runs at a slightly different rate than the system clock./// In case the stream is a monitoring stream the result can be negative, i.e. the captured/// samples are not yet played, in which case `Ok(Latency::Negative(usecs))` will be returned/// instead of `Ok(Latency::Positive(usecs))`/// If no timing information has been received yet, this call will return `Ok(Latency::None)`./// For more details see [`get_timing_info()`] and [`get_time()`].get_timing_info/// Gets the latest raw timing data structure./// The returned pointer refers to an internal read-only instance of the timing structure. The/// user should make a copy of this structure if wanting to modify it. An in-place update to/// this data structure may be requested using [`update_timing_info()`]./// If no timing information has been received before (i.e. by requesting/// [`update_timing_info()`] or by using [`FlagSet::AUTO_TIMING_UPDATE`]), this function will/// return `None` (as it will also if an error occurs)./// Please note that the `write_index` member field (and only this field) is updated on each/// [`write()`] call, not just when a timing update has been received.get_sample_spec/// Gets a pointer to the stream’s sample specification.get_channel_map/// Gets a pointer to the stream’s channel map.get_format_info/// Gets a pointer to the stream’s format.get_buffer_attr/// Gets the per-stream server-side buffer metrics of the stream./// Only valid after the stream has been connected successfully. This will return the actual/// configured buffering metrics, which may differ from what was requested during/// [`connect_record()`] or [`connect_playback()`]. This call will always return the actual/// per-stream server-side buffer metrics, regardless whether [`FlagSet::ADJUST_LATENCY`] is set/// [`connect_record()`]: Self::connect_record/// [`connect_playback()`]: Self::connect_playbackset_buffer_attr/// Changes the buffer metrics of the stream during playback./// The server might have chosen different buffer metrics then requested. The selected metrics/// may be queried with [`get_buffer_attr()`] as soon as the callback is called. Only valid/// after the stream has been connected successfully. Please be aware of the slightly different/// semantics of the call depending whether [`FlagSet::ADJUST_LATENCY`] is set or not./// [`get_buffer_attr()`]: Self::get_buffer_attrupdate_sample_rate/// Changes the stream sampling rate during playback./// You need to pass [`FlagSet::VARIABLE_RATE`] in the flags parameter of [`connect_playback()`]/// if you plan to use this function. Only valid after the stream has been connectedupdate_proplist/// Updates the property list of the sink input/source output of this stream, adding new/// entries./// [`new_with_proplist()`] as possible instead a posteriori with this function, since that/// information may be used to route this stream to the right device.remove_proplist/// Updates the property list of the sink input/source output of this stream, removing entries.set_monitor_stream/// For record streams connected to a monitor source: monitors only a very specific sink input/// of the sink./// This function needs to be called before [`connect_record()`](Self::connect_record) isget_monitor_stream/// Gets the sink input index previously set with [`set_monitor_stream()`]./// [`set_monitor_stream()`]: Self::set_monitor_streamrequest_cb_proxy/// Proxy for request callbacks./// Proxy for notify callbacks.//! Audio streams for input, output and sample upload.//! Audio streams form the central functionality of the sound server. Data is routed, converted and//! mixed from several sources before it is passed along to a final output. Currently, there are//! three forms of audio streams://! * Playback streams: Data flows from the client to the server.//! * Record streams: Data flows from the server to the client.//! * Upload streams: Similar to playback streams, but the data is stored in the sample cache. See//!   [`context::scache`] for more information about controlling the sample cache.//! # Creating//! To access a stream, a [`Stream`] object must be created using [`Stream::new()`] or//! [`Stream::new_extended()`]. `new` is for PCM streams only, while `new_extended` can be used for//! both PCM and compressed audio streams. At this point the application must specify what stream//! format(s) it supports. See [`sample`] and [`channelmap`] for more information on the stream//! format parameters.//! **FIXME**: Those references only talk about PCM parameters, we should also have an overview//! page for how the [`Info`] based stream format configuration works.//! [Bug filed](https://bugs.freedesktop.org/show_bug.cgi?id=72265).//! This first step will only create a client-side object, representing the stream. To use the//! stream, a server-side object must be created and associated with the local object. Depending on//! which type of stream is desired, a different function is needed://! * Playback stream: [`Stream::connect_playback()`]//! * Record stream: [`Stream::connect_record()`]//! * Upload stream: [`Stream::connect_upload()`] \(see [`context::scache`])//! Similar to how connections are done in contexts, connecting a stream will not generate an//! [`Operation`] object. Also like contexts, the application should register a state change//! callback, using [`Stream::set_state_callback()`], and wait for the stream to enter an active//! state.//! Note: there is a user-controllable slider in mixer applications such as pavucontrol//! corresponding to each of the created streams. Multiple (especially identically named) volume//! sliders for the same application might confuse the user. Also, the server supports only a//! limited number of simultaneous streams. Because of this, it is not always appropriate to create//! multiple streams in one application that needs to output multiple sounds. The rough guideline//! is: if there is no use case that would require separate user-initiated volume changes for each//! stream, perform the mixing inside the application.//! # Buffer Attributes//! Playback and record streams always have a server-side buffer as part of the data flow. The size//! of this buffer needs to be chosen in a compromise between low latency and sensitivity for buffer//! overflows/underruns.//! The buffer metrics may be controlled by the application. They are described with a//! [`BufferAttr`] structure.//! If [`FlagSet::ADJUST_LATENCY`] is set, then the `tlength`/`fragsize` parameters of this//! structure will be interpreted slightly differently than otherwise when passed to//! [`Stream::connect_record()`] and [`Stream::connect_playback()`]: the overall latency that is//! comprised of both the server side playback buffer length, the hardware playback buffer length//! and additional latencies will be adjusted in a way that it matches `tlength` resp. `fragsize`.//! Set [`FlagSet::ADJUST_LATENCY`] if you want to control the overall playback latency for your//! stream. Unset it if you want to control only the latency induced by the server-side, rewritable//! playback buffer. The server will try to fulfill the client’s latency requests as good as//! possible. However if the underlying hardware cannot change the hardware buffer length or only in//! a limited range, the actually resulting latency might be different from what the client//! requested. Thus, for synchronization clients always need to check the actual measured latency//! via [`Stream::get_latency()`] or a similar call, and not make any assumptions about the latency//! available. The function [`Stream::get_buffer_attr()`] will always return the actual size of the//! server-side per-stream buffer in `tlength`/`fragsize`, regardless whether//! [`FlagSet::ADJUST_LATENCY`] is set or not.//! The server-side per-stream playback buffers are indexed by a write and a read index. The//! application writes to the write index and the sound device reads from the read index. The read//! index is increased monotonically, while the write index may be freely controlled by the//! application. Subtracting the read index from the write index will give you the current fill//! level of the buffer. The read/write indexes are 64bit values and measured in bytes, they will//! never wrap. The current read/write index may be queried using [`Stream::get_timing_info()`]//! \(see below for more information). In case of a buffer underrun the read index is equal or//! larger than the write index. Unless the `prebuf` value is `0`, PulseAudio will temporarily pause//! playback in such a case, and wait until the buffer is filled up to `prebuf` bytes again. If//! `prebuf` is `0`, the read index may be larger than the write index, in which case silence is//! played. If the application writes data to indexes lower than the read index, the data is//! immediately lost.//! # Transferring Data//! Once the stream is up, data can start flowing between the client and the server. Two different//! access models can be used to transfer the data://! * Asynchronous: The application registers a callback using [`Stream::set_write_callback()`] and//!   [`Stream::set_read_callback()`] to receive notifications that data can either be written or//!   read.//! * Polled: Query the library for available data/space using [`Stream::writable_size()`] and//!   [`Stream::readable_size()`] and transfer data as needed. The sizes are stored locally, in the//!   client end, so there is no delay when reading them.//! It is also possible to mix the two models freely.//! Once there is data/space available, it can be transferred using either [`Stream::write()`] for//! playback, or [`Stream::peek()`] / [`Stream::discard()`] for record. Make sure you do not//! overflow the playback buffers as data will be dropped.//! # Buffer Control//! The transfer buffers can be controlled through a number of operations://! * [`Stream::cork()`]: Stop the playback or recording.//! * [`Stream::uncork()`]: Start the playback or recording.//! * [`Stream::trigger()`]: Start playback immediately and do not wait for the buffer to fill up to//!   the set trigger level.//! * [`Stream::prebuf()`]: Re-enable the playback trigger level.//! * [`Stream::drain()`]: Wait for the playback buffer to go empty. Will return an [`Operation`]//!   object that will indicate when the buffer is completely drained.//! * [`Stream::flush()`]: Drop all data from the playback or record buffer. Do not wait for it to//!   finish playing.//! # Seeking in the Playback Buffer//! A client application may freely seek in the playback buffer. To accomplish that the//! [`Stream::write()`] function takes a seek mode and an offset argument. The seek mode is one of://! * [`SeekMode::Relative`]: seek relative to the current write index.//! * [`SeekMode::Absolute`]: seek relative to the beginning of the playback buffer, (i.e. the first//!   that was ever played in the stream).//! * [`SeekMode::RelativeOnRead`]: seek relative to the current read index. Use this to write data//!   to the output buffer that should be played as soon as possible.//! * [`SeekMode::RelativeEnd`]: seek relative to the last byte ever written.//! If an application just wants to append some data to the output buffer, [`SeekMode::Relative`]//! and an offset of `0` should be used.//! After a call to [`Stream::write()`] the write index will be left at the position right after the//! last byte of the written data.//! # Latency//! A major problem with networked audio is the increased latency caused by the network. To remedy//! this, PulseAudio supports an advanced system of monitoring the current latency.//! To get the raw data needed to calculate latencies, call [`Stream::get_timing_info()`]. This will//! give you a [`TimingInfo`] structure that contains everything that is known about the server side//! buffer transport delays and the backend active in the server. (Besides other things it contains//! the write and read index values mentioned above.)//! This structure is updated every time a [`Stream::update_timing_info()`] operation is executed.//! (i.e. before the first call to this function the timing information structure is not available!)//! Since it is a lot of work to keep this structure up-to-date manually, PulseAudio can do that//! automatically for you: if [`FlagSet::AUTO_TIMING_UPDATE`] is passed when connecting the stream//! PulseAudio will automatically update the structure every 100ms and every time a function is//! called that might invalidate the previously known timing data (such as [`Stream::write()`] or//! [`Stream::flush()`]). Please note however, that there always is a short time window when the//! data in the timing information structure is out-of-date. PulseAudio tries to mark these//! situations by setting the `write_index_corrupt` and `read_index_corrupt` fields accordingly.//! The raw timing data in the [`TimingInfo`] structure is usually hard to deal with. Therefore a//! simpler interface is available: you can call [`Stream::get_time()`] or//! [`Stream::get_latency()`]. The former will return the current playback time of the hardware//! since the stream has been started. The latter returns the overall time a sample that you write//! now takes to be played by the hardware. These two functions base their calculations on the same//! data that is returned by [`Stream::get_timing_info()`]. Hence the same rules for keeping the//! timing data up-to-date apply here. In case the write or read index is corrupted, these two//! functions will fail.//! Since updating the timing info structure usually requires a full network round trip and some//! applications monitor the timing very often PulseAudio offers a timing interpolation system. If//! [`FlagSet::INTERPOLATE_TIMING`] is passed when connecting the stream, [`Stream::get_time()`] and//! [`Stream::get_latency()`] will try to interpolate the current playback time/latency by//! estimating the number of samples that have been played back by the hardware since the last//! regular timing update. It is especially useful to combine this option with//! [`FlagSet::AUTO_TIMING_UPDATE`], which will enable you to monitor the current playback//! time/latency very precisely and very frequently without requiring a network round trip every//! time.//! # Overflow and underflow//! Even with the best precautions, buffers will sometime over - or underflow. To handle this//! gracefully, the application can be notified when this happens. Callbacks are registered using//! [`Stream::set_overflow_callback()`] and [`Stream::set_underflow_callback()`].//! # Synchronizing Multiple Playback Streams//! PulseAudio allows applications to fully synchronize multiple playback streams that are connected//! to the same output device. That means the streams will always be played back sample-by-sample//! synchronously. If stream operations like [`Stream::cork()`] are issued on one of the//! synchronized streams, they are simultaneously issued on the others.//! To synchronize a stream to another, just pass the “master” stream as the last argument to//! [`Stream::connect_playback()`]. To make sure that the freshly created stream doesn’t start//! playback right-away, make sure to pass [`FlagSet::START_CORKED`] and, after all streams have//! been created, uncork them all with a single call to [`Stream::uncork()`] for the master stream.//! To make sure that a particular stream doesn’t stop to play when a server side buffer underrun//! happens on it while the other synchronized streams continue playing and hence deviate, you need//! to pass a [`BufferAttr`] with `prebuf` set to `0` when connecting.//! When a stream has served is purpose it must be disconnected with [`Stream::disconnect()`]. If//! you only unreference it, then it will live on and eat resources both locally and on the server//! until you disconnect the context. This is done automatically upon drop of the stream object.//! [`context::scache`]: mod@crate::context::scache//! [`sample`]: mod@crate::sample//! [`channelmap`]: mod@crate::channelmap//! [`Info`]: crate::format::Info//! [`BufferAttr`]: crate::def::BufferAttr//! [`TimingInfo`]: crate::def::TimingInfo//! Implementation of conversions between the types.// To `MicroSeconds`// To `Duration`// To `Timeval`op_err/// Microseconds. Represents a span of time like [`std::time::Duration`]./// This is an unsigned 64-bit type, and thus represents absolute values only./// `MicroSeconds` value representing an ‘invalid’ time./// # use libpulse_binding::time::MicroSeconds;/// assert_eq!(MicroSeconds::INVALID, MicroSeconds(std::u64::MAX));/// One second in microseconds./// assert_eq!(MicroSeconds::SECOND, MicroSeconds(1_000_000));MILLISECOND/// One millisecond in microseconds./// assert_eq!(MicroSeconds::MILLISECOND, MicroSeconds(1_000));/// Zero value./// assert_eq!(MicroSeconds::ZERO, MicroSeconds(0));/// Smallest _valid_ time value (zero)./// assert_eq!(MicroSeconds::MIN, MicroSeconds(0));/// Largest _valid_ time value (largest integer value is reserved for representing ‘invalid’)./// Roughly equal to 5,124,095,576 hours, 213,503,982 days, or 584,542 years./// assert_eq!(MicroSeconds::MAX, MicroSeconds(std::u64::MAX - 1));/// Get the inner `u64` value./// assert_eq!(MicroSeconds(100).inner(), 100);/// Returns `true` so long as inner value is not [`Self::INVALID`]./// # use libpulse_binding::time::{MicroSeconds, MICROS_PER_SEC};/// assert_eq!(MicroSeconds::MIN.is_valid(), true);/// assert_eq!(MicroSeconds::MAX.is_valid(), true);/// assert_eq!(MicroSeconds::INVALID.is_valid(), false);/// assert_eq!(MicroSeconds::ZERO.is_valid(), true);/// assert_eq!(MicroSeconds(60 * MICROS_PER_SEC).is_valid(), true);/// Returns `true` so long as inner value is zero./// assert_eq!(MicroSeconds::ZERO.is_zero(), true);/// assert_eq!(MicroSeconds(0).is_zero(), true);/// assert_eq!(MicroSeconds(1).is_zero(), false);from_secs/// Creates a new `MicroSeconds` from the specified number of whole seconds. Returns `None` on/// assert_eq!(MicroSeconds::from_secs(2), Some(MicroSeconds(2_000_000)));/// assert_eq!(MicroSeconds::from_secs(0xffff_ffff_0000_0000), None);from_millis/// Creates a new `MicroSeconds` from the specified number of whole milliseconds. Returns `None`/// on overflow./// assert_eq!(MicroSeconds::from_millis(23), Some(MicroSeconds(23_000)));/// assert_eq!(MicroSeconds::from_millis(0xffff_ffff_0000_0000), None);/// Returns the absolute difference with `other`./// assert_eq!(MicroSeconds(0).diff(MicroSeconds(0)), MicroSeconds(0));/// assert_eq!(MicroSeconds(100).diff(MicroSeconds(100)), MicroSeconds(0));/// assert_eq!(MicroSeconds(200).diff(MicroSeconds(150)), MicroSeconds(50));/// assert_eq!(MicroSeconds(150).diff(MicroSeconds(200)), MicroSeconds(50));as_secs/// Returns the total number of whole seconds./// assert_eq!(MicroSeconds(2_300_000).as_secs(), 2);/// assert_eq!(MicroSeconds(2_800_000).as_secs(), 2);as_millis/// Returns the total number of whole milliseconds./// assert_eq!(MicroSeconds(23_000_300).as_millis(), 23_000);/// assert_eq!(MicroSeconds(23_000_800).as_millis(), 23_000);from_secs_f64/// Creates a new `MicroSeconds` from the specified number of seconds represented as `f64`./// **Panics** if `secs` is not finite, is negative, or the value overflows./// assert_eq!(MicroSeconds::from_secs_f64(0.5), MicroSeconds(500_000));/// assert_eq!(MicroSeconds::from_secs_f64(2.3), MicroSeconds(2_300_000));/// These should panic./// MicroSeconds::from_secs_f64(std::f64::INFINITY);/// MicroSeconds::from_secs_f64(-0.5);/// MicroSeconds::from_secs_f64(std::f64::MAX);/// MicroSeconds::from_secs_f64(std::f64::NAN);from_secs_f32/// Creates a new `MicroSeconds` from the specified number of seconds represented as `f32`./// assert_eq!(MicroSeconds::from_secs_f32(0.5), MicroSeconds(500_000));/// assert_eq!(MicroSeconds::from_secs_f32(2.3), MicroSeconds(2_299_999));/// MicroSeconds::from_secs_f32(std::f32::INFINITY);/// MicroSeconds::from_secs_f32(-0.5);/// MicroSeconds::from_secs_f32(std::f32::MAX);/// MicroSeconds::from_secs_f32(std::f32::NAN);as_secs_f64/// Returns the number of seconds as `f64`./// assert_eq!(MicroSeconds(2_300_000).as_secs_f64(), 2.3);/// assert_eq!(MicroSeconds(500_000).as_secs_f64(), 0.5);as_secs_f32/// Returns the number of seconds as `f32`./// assert_eq!(MicroSeconds(2_300_000).as_secs_f32(), 2.3);/// assert_eq!(MicroSeconds(500_000).as_secs_f32(), 0.5);/// Checked integer addition. Computes `self + rhs`, returning `None` if overflow occurred,/// using the inner integer’s [`checked_add()`](u64::checked_add) method./// let quater_minute = MicroSeconds(15 * MICROS_PER_SEC);/// let half_minute = MicroSeconds(30 * MICROS_PER_SEC);/// let three_quater_minute = MicroSeconds(45 * MICROS_PER_SEC);/// assert_eq!(half_minute.checked_add(quater_minute), Some(three_quater_minute));/// assert_eq!(MicroSeconds::MAX.checked_add(half_minute), None);checked_add_duration/// # use libpulse_binding::time::{MicroSeconds, MICROS_PER_SEC, NANOS_PER_MICRO};/// let duration1 = Duration::new(2, 5 * NANOS_PER_MICRO + 20); // 2s + 5us + 20ns/// let duration2 = Duration::new(MicroSeconds::MAX.inner() / MICROS_PER_SEC, 0);/// assert_eq!(half_minute.checked_add_duration(duration1), Some(MicroSeconds(32_000_005)));/// assert_eq!(half_minute.checked_add_duration(duration2), None);/// Checked integer subtraction. Computes `self - rhs`, returning `None` if overflow occurred,/// using the inner integer’s [`checked_sub()`](u64::checked_sub) method./// let whole_minute = MicroSeconds(60 * MICROS_PER_SEC);/// assert_eq!(whole_minute.checked_sub(quater_minute), Some(three_quater_minute));/// assert_eq!(quater_minute.checked_sub(whole_minute), None);checked_sub_duration/// let duration2 = Duration::new(45, 0);/// assert_eq!(half_minute.checked_sub_duration(duration1), Some(MicroSeconds(27_999_995)));/// assert_eq!(half_minute.checked_sub_duration(duration2), None);/// Checked integer multiplication. Computes `self * rhs`, returning `None` if overflow/// occurred, using the inner integer’s [`checked_mul()`](u64::checked_mul) method./// assert_eq!(quater_minute.checked_mul(4), Some(whole_minute));/// assert_eq!(MicroSeconds::MAX.checked_mul(2), None);/// Checked integer division. Computes `self / rhs`, returning `None` if `rhs == 0`, using the/// inner integer’s [`checked_div()`](u64::checked_div) method./// assert_eq!(whole_minute.checked_div(4), Some(quater_minute));/// assert_eq!(whole_minute.checked_div(0), None);/// Checked integer remainder. Computes `self % rhs`, returning `None` if `rhs == 0`, using the/// inner integer’s [`checked_rem()`](u64::checked_rem) method./// assert_eq!(whole_minute.checked_rem(4), Some(MicroSeconds::ZERO));/// assert_eq!(whole_minute.checked_rem(7), Some(MicroSeconds(4)));/// assert_eq!(whole_minute.checked_rem(0), None);mul_f64/// Multiplies `MicroSeconds` by `f64`./// Converts to an `f64` representing seconds, multiplies by the given factor, then converts/// back to microseconds./// **Panics** if `rhs` is not finite, is negative, or the value overflows./// let micros = MicroSeconds(2_700_000_000);/// assert_eq!(micros.mul_f64(3.14), MicroSeconds(8_478_000_000));/// assert_eq!(micros.mul_f64(3.14e5), MicroSeconds(847_800_000_000_000));/// MicroSeconds::SECOND.mul_f64(std::f64::INFINITY);/// MicroSeconds::SECOND.mul_f64(-0.5);/// MicroSeconds(2 * MICROS_PER_SEC).mul_f64(std::f64::MAX / 10.0);/// MicroSeconds::SECOND.mul_f64(std::f64::NAN);mul_f32/// Multiplies `MicroSeconds` by `f32`./// Converts to an `f32` representing seconds, multiplies by the given factor, then converts/// // Note the rounding errors that are clear here./// assert_eq!(micros.mul_f32(3.14), MicroSeconds(8_478_000_000));/// assert_eq!(micros.mul_f32(3.14e5), MicroSeconds(847_800_000_000_000));/// MicroSeconds::SECOND.mul_f32(std::f32::INFINITY);/// MicroSeconds::SECOND.mul_f32(-0.5);/// MicroSeconds(2 * MICROS_PER_SEC).mul_f32(std::f32::MAX / 10.0);/// MicroSeconds::SECOND.mul_f32(std::f32::NAN);div_f64/// Divides `MicroSeconds` by `f64`./// Converts to an `f64` representing seconds, divides by the given factor, then converts back/// to microseconds./// assert_eq!(micros.div_f64(3.14), MicroSeconds(859_872_611));/// assert_eq!(micros.div_f64(3.14e5), MicroSeconds(8_598));/// MicroSeconds::SECOND.div_f64(-2.0);/// MicroSeconds::MAX.div_f64(0.5);/// MicroSeconds::SECOND.div_f64(std::f64::NAN);div_f32/// Divides `MicroSeconds` by `f32`./// Converts to an `f32` representing seconds, divides by the given factor, then converts back/// assert_eq!(micros.div_f32(3.14), MicroSeconds(859_872_558));/// assert_eq!(micros.div_f32(3.14e5), MicroSeconds(8_598));/// MicroSeconds::SECOND.div_f32(-2.0);/// MicroSeconds::MAX.div_f32(0.5);/// MicroSeconds::SECOND.div_f32(std::f32::NAN);//! MicroSeconds.// Operations with `Duration`// Operations with primitives// NOTE 1: We only implement `u32` here because://  - We do not expect operations will be needed for the larger `u64` range, otherwise we should//    switch to that.//  - Although implementing for the set of { `u8`, `u16`, `u32`, `u64 } is very easy with a macro,//    and may avoid possible need for `as u32` for non-`u32` variables, it introduces ambiguity such//    that the compiler does not know which type the `2` should be in the example use case of `2 *//    MicroSeconds::SECOND` and so it goes with `i32`, and since we don't implement the ops for//    `i32`, the user thus gets an error, forcing them to write instead `2u32 *//    MicroSeconds::SECOND`.// NOTE 2: Addition and subtraction deliberately not implemented, since allowing arbitrary such// operations would allow mistakes to be made that the `MicroSeconds` type exists to prevent. I.e.// allowing the following:// let a = 10u32;// let b = MicroSeconds(1) + a;// ...would allow mistakes to be made around the form of `a`. We must force `a` to be wrapped in// `MicroSeconds`.// NOTE 3: We support an integer being the Lhs of the operation for multiplicaton (for example// `2 * MicroSeconds`), but not for division/remainder, because dividing a generic integer by an// amount of microseconds makes no sense.//private!monotonic// (Copied constants from rust’s std/time/duration.rs)/// Nanoseconds per second./// Nanoseconds per millisecond./// Nanoseconds per microsecond./// Microseconds per second.MICROS_PER_MILLI/// Microseconds per millisecond./// Milliseconds per second.USEC_INVALID/// Invalid time. Microseconds value representing ‘invalid’.USEC_MAX/// Largest valid time value in microseconds (largest integer value is reserved for representing/// ‘invalid’).ADDSUBMULDIVREM/// Basic math operation errors.//! Time handling functionality./// A monotonic timestamp./// Gets the current monotonic system time in microseconds./// Note, if such a clock is not available then this will actually fall back to the wallclock/// time instead. No indication is available for whether or not this is the case, and the/// return value is still a `MonotonicTs` type./// Returns `true` so long as inner value is not [`MicroSeconds::INVALID`]./// using the inner [`MicroSeconds`]’s [`checked_add()`](MicroSeconds::checked_add) method./// using the inner integer’s `checked_add()` method./// using the inner [`MicroSeconds`]’s [`checked_sub()`](MicroSeconds::checked_sub) method./// using the inner integer’s `checked_sub()` method.//! Monotonic timestamps.TvSecsTvUsecs/// Wrapper for [`libc::timeval`], attaching various methods and trait implementations.RTCLOCK_BIT/// Bit to set in `tv_usec` attribute to mark that the `timeval` is in monotonic time./// Creates a new instance, with values provided.new_zero/// Creates a new instance, with value of zero./// Calculates the difference between the two specified timeval structs./// Gets the time difference between now and self.set_rt/// Sets to the specified (monotonic) value./// The `rtclock` boolean is used for indicating support of the rtclock (monotonic time). If/// `true` then the conversion from `MicroSeconds` to `Timeval` is done, and a special ‘rt’ flag/// bit is set in `Timeval`’s inner `tv_usec` attribute. If `false`, then instead the timestamp/// is converted to a Unix wallclock timestamp./// Asserts that `v` is not `MicroSeconds::INVALID`.wallclock_from_rtclockchecked_add_uschecked_sub_us/// occurred, using the inner integer’s `checked_mul()` method./// inner integer’s `checked_div()` method./// inner integer’s `checked_rem()` method.//! Timeval.// Warning, this must remain directly transmutable with the inner libc::timeval// Operations with `MicroSeconds`/// A Unix timestamp./// Gets the current ‘time of day’./// Calculates the difference between the two specified timestamps./// using the inner integer’s [`checked_add()`](Timeval::checked_add) method./// using the inner integer’s [`checked_sub()`](Timeval::checked_sub) method.//! Unix timestamps.utf8_to_locale/// Converts a UTF-8 string to the current locale.//! UTF-8 validation functions.//! Bindings are not provided here for most of the PulseAudio UTF-8 functions since Rust has built//! in UTF-8 handling and thus they should be entirely unnecessary.fn_string_with_buffer/// Gets the current username./// Gets the current hostname.get_fqdn/// Gets the fully qualified domain name./// Gets the home directory of the current user.get_binary_name/// Gets the binary file name of the current process./// This is not supported on all architectures (in which case `NULL` is returned).//! Assorted utility functions.get_compatibility// Re-export from sysTARGET_VERSION_STRINGTARGET_VERSIONPA_API_VERSIONAPI_VERSIONPA_PROTOCOL_VERSIONPROTOCOL_VERSION/// Error parsing part as integer.MissingPart/// Missing version part.ExtraParts/// Too many parts found in the string (unexpected; something is wrong)./// Kinds of errors from trying to parse the runtime PulseAudio system library version string.ver_str/// The problematic version sring which could not be parsed./// Error from trying to parse the runtime PulseAudio system library version string.library_version_is_too_old/// Checks whether the version of the running system library is older than the version corresponding/// to the compatibility level selected via the available feature flags./// Returns `Ok(true)` if the library version is older, `Ok(false)` if equal or newer, or `Err` if a/// problem occurred processing the version string.compare_with_library_version/// Compares the supplied version with that of the runtime system library./// Returns the comparison, or `Err` if a problem occurred parsing the library version string. The/// comparison will represent `supplied.cmp(&library)`.get_library_version_numbers/// Tries to convert the runtime system library version to numeric major, minor and micro form, for/// comparison purposes./// Note, currently micro is always zero. This is the case even in beta/rc versions (like 13.99.1)/// due to the fact that the version string returned by PA always has micro fixed to zero./// Returns `Err` if parsing the version number string fails.pa_version_str_to_num/// Convert PulseAudio version string to major, minor and micro numbers./// The version number string should come from `pa_get_library_version()` and thus currently will/// always consist of exactly `$MAJOR.$MINOR.0` per the compiled version.h header. Note that the/// micro number is fixed to zero.get_library_version/// Gets the version string of the (PulseAudio client system) library actually in use at runtime./// Just compares given version with that defined in `TARGET_VERSION` and returns `true` if the/// `TARGET_VERSION` version is greater. This does **not** involve talking to the PulseAudio client/// library at runtime. This is not very useful!test_ver_str_to_numtest_getting_pa_versiontest_comparing_pa_versiontest_lib_ver_not_too_old//! Version related constants and functions.//! This module contains functions and constants relating to the version of the PulseAudio (PA)//! client system library.//! # Dynamic compatibility//! As discussed in the project `COMPATIBILITY.md` file, compatibility is offered for multiple//! versions of the PA client system library, with feature flags adapting the crate to changes made//! in the API of newer PA versions.//! Note that the minimum supported version of PA is v5.0.//! # Runtime checking//! The following functions are provided to retrieve and compare the version of the actual PA client//! system library in use at runtime://!  - The [`get_library_version()`] function obtains the version string the system library//!    provides.//!  - The [`get_library_version_numbers()`] function uses the previous function and attempts to//!    parse the version string it returns into numeric form for comparison purposes.//!  - The [`compare_with_library_version()`] function uses the previous function and allows//!    comparing a provided major and minor version number with what it returned.//!  - The [`library_version_is_too_old()`] function uses the previous function to compare against//!    the [`TARGET_VERSION`] constant version numbers. This constant varies depending upon PA//!    version feature flags, and thus this can be used to check that a program is not being run on//!    a system with too old of a version of PA, helping combat the “forward” compatibility problem//!    discussed in the project `COMPATIBILITY.md` documentation.//! # Dynamic constants//! The version constants defined here mostly relate to those provided in the PA C headers, and are//! likely of little use to most projects. They are set dynamically, depending upon the feature//! flags used, or in other words the level of minimum compatibility support selected. Note that PA//! version feature flags are only introduced when new versions of PA introduce changes to its API//! that would require one. The version numbers associated with each PA version feature flag are//! those from the PA version that required introduction of that feature flag.//! As an example to clarify, if the “newest” PA version feature flag enabled is `pa_v8` (which//! obviously corresponds to a minimum compatibility level of PA version 8.0), then the//! [`TARGET_VERSION`] constant is set to `(8, 0)`. The “next-newest” feature flag is `pa_v11`,//! which if enabled would bump it up to `(11, 0)`.VOLUME_NORM/// A “normal” volume level.VOLUME_MUTED/// A muted volume level.VOLUME_MAX/// A maximum volume level.VOLUME_INVALID/// An invalid volume level.DECIBEL_MINUS_INFINITYVolumeDB/// Minus Infinity./// This floor value is used / can be used, when using converting between integer software volume/// and decibel (dB, floating point) software volume.pa_volume_t/// Software volume expressed as an integer./// Software volume expressed in decibels (dBs).VolumeLinear/// Software volume expressed as linear factor./// Number of channels./// Per-channel volume./// A structure encapsulating a per-channel volumeset_compare_capipa_cvolume/// Returns `true` if the volume of all channels are equal to the specified value./// Converts a decibel value to a volume (amplitude, not power)./// This is only valid for software volumes!/// Converts a volume to a decibel value (amplitude, not power)./// Converts a linear factor to a volume./// `0.0` and less is muted while `1.0` is [`Volume::NORMAL`]./// [`Volume::NORMAL`]: struct.Volume.html#associatedconstant.NORMAL/// Converts a volume to a linear factor./// Converts a linear factor to a decibel value (amplitude, not power)./// Converts a decibel value (amplitude, not power) to a linear factor.is_muted/// Is a muted volume level./// Is a “normal” volume level.MUTEDis_max/// Is a maximum volume level.ui_max/// Get the recommended maximum volume to show in user facing UIs./// Note: UIs should deal gracefully with volumes greater than this value and not cause feedback/// loops etc. - i.e. if the volume is more than this, the UI should not limit it and push the/// limited value back to the server./// Checks if volume is valid./// Clamps volume to the permitted range./// Multiplies two software volumes, returning the result./// This uses [`Volume::NORMAL`] as neutral element of multiplication./// Divides two software volumes, returning the result./// This uses [`Volume::NORMAL`] as neutral element of division. If a division by zero is tried/// the result will be `0`./// Pretty prints a volume.print_db/// Pretty prints a volume but showing dB values.print_verbose/// Pretty prints a volume in a verbose way./// The volume is printed in several formats: the raw volume value, percentage, and if/// `print_db` is true, also the dB value.MINUS_INFINITY/// This floor value is used / can be used, when using converting between integer software/// volume and decibel (dB, floating point) software volume./// Initializes the specified volume and return a pointer to it./// Checks if the `ChannelVolumes` structure is valid./// Volumes for up to [`Self::CHANNELS_MAX`] channels can be held. This sets the portion of/// Sets the volume of the specified number of channels to the supplied volume./// Sets the volume of the first n channels to [`Volume::NORMAL`]./// Sets the volume of the first n channels to [`Volume::MUTED`]./// Checks if all channels are muted.is_norm/// Checks if all channels are at normal volume level.avg/// Gets the average volume of all channels.avg_mask/// Returns the average volume of all channels that are included in the specified channel map/// with the specified channel position mask./// If no channel is selected the returned value will be [`Volume::MUTED`]. If `mask` is `None`,/// has the same effect as passing [`POSITION_MASK_ALL`]./// Gets the maximum volume of all channels.max_mask/// Gets the maximum volume of all channels that are included in the specified channel map/// Gets the minimum volume of all channels.min_mask/// Gets the minimum volume of all channels that are included in the specified channel mapsw_multiply/// Multiplies two per-channel volumes./// If `with` is `None`, multiplies with itself. This is only valid for software volumes!/// Returns pointer to self.sw_multiply_scalar/// Multiplies a per-channel volume with a scalar volume./// This is only valid for software volumes! Returns pointer to self.sw_divide/// Divides two per-channel volumes./// If `with` is `None`, divides with itself. This is only valid for software volumes! Returns/// pointer to self.sw_divide_scalar/// Divides a per-channel volume by a scalar volume./// Remaps a volume from one channel mapping to a different channel mapping.is_compatible_with_ss/// Checks if the specified volume is compatible with the specified sample spec.is_compatible_with_cm/// Checks if the specified volume is compatible with the specified channel map./// Calculates a ‘balance’ value for the specified volume with the specified channel map./// The return value will range from `-1.0` (left) to `+1.0` (right). If no balance value is/// applicable to this channel map the return value will always be `0.0`. See/// [`Map::can_balance()`]./// Adjusts the ‘balance’ value for the specified volume with the specified channel map./// The balance is a value between `-1.0` and `+1.0`. This operation might not be reversible!/// Also, after this call [`get_balance()`](Self::get_balance) is not guaranteed to actually/// return the requested balance value (e.g. when the input volume was zero anyway for all/// channels). If no balance value is applicable to this channel map the volume will not be/// modified. See [`Map::can_balance()`]./// Returns pointer to self, or `None` on error.get_fade/// Calculates a ‘fade’ value (i.e. ‘balance’ between front and rear) for the specified volume/// with the specified channel map./// The return value will range from -1.0f (rear) to +1.0f (left). If no fade value is/// [`Map::can_fade()`].set_fade/// Adjusts the ‘fade’ value (i.e. ‘balance’ between front and rear) for the specified volume/// Also, after this call [`get_fade()`](Self::get_fade) is not guaranteed to actually return/// the requested fade value (e.g. when the input volume was zero anyway for all channels). If/// no fade value is applicable to this channel map the volume will not be modified. Seeget_lfe_balance/// Calculates a ‘lfe balance’ value for the specified volume with the specified channel map./// The return value will range from `-1.0` (no lfe) to `+1.0` (only lfe), where `0.0` is/// balanced. If no value is applicable to this channel map the return value will always be/// `0.0`. See [`Map::can_lfe_balance()`].set_lfe_balance/// Adjusts the ‘LFE balance’ value for the specified volume with the specified channel map./// The balance is a value between `-1.0` (no lfe) and `+1.0` (only lfe). This operation might/// not be reversible! Also, after this call [`get_lfe_balance()`] is not guaranteed to actually/// return the requested value (e.g. when the input volume was zero anyway for all channels). If/// no lfe balance value is applicable to this channel map the volume will not be modified. See/// [`Map::can_lfe_balance()`]./// [`get_lfe_balance()`]: Self::get_lfe_balance/// Scales so that the maximum volume of all channels equals `max`./// The proportions between the channel volumes are kept.scale_mask/// Scales so that the maximum volume of all channels selected via `cm`/`mask` equals `max`./// This also modifies the volume of those channels that are unmasked. The proportions between/// the channel volumes are kept./// If `mask` is `None`, has the same effect as passing [`POSITION_MASK_ALL`]./// Sets the passed volume to all channels at the specified channel position./// Returns `None` if either invalid data was provided, or if there is no channel at the/// position specified. You can check if a channel map includes a specific position by calling/// [`Map::has_position()`]. On success, returns pointer to self./// Gets the maximum volume of all channels at the specified channel position./// Will return `0` if there is no channel at the position specified. You can check if a channel/// map includes a specific position by calling [`Map::has_position()`]./// Merges one set of channel volumes with another./// The channel count is set to the minimum between that of self and that of `with`. Only this/// number of channels are processed. For each channel processed, volume is set to the greatest/// of the values from self and from `with`. I.e if one set has three channels and the other has/// two, the number of channels will be set to two, and only the first two channels will be/// compared, with the greatest values of these two channels being stored. The third channel in/// the one set will be ignored.inc_clamp/// Increases the volume passed in by `inc`, but not exceeding `limit`./// The proportions between the channels are kept.increase/// Increases the volume passed in by `inc`.decrease/// Decreases the volume passed in by `dec`./// Pretty prints a volume structure./// Pretty prints a volume structure but show dB values./// Pretty prints a volume structure in a verbose way./// The volume for each channel is printed in several formats: the raw volume value,/// percentage, and if `print_db` is non-zero, also the dB value. If `map` is provided, the/// channel names will be printed.//! Constants and routines for volume handling.//! Sinks, sources, sink inputs, source outputs and samples can all have their own volumes. To deal//! with these, The PulseAudio library contains a number of functions that ease handling.//! The basic volume type in PulseAudio is the [`Volume`] type. Most of the time, applications will//! use the aggregated [`ChannelVolumes`] structure that can store the volume of all channels at//! once.//! Volumes commonly span between muted (0%), and normal (100%). It is possible to set volumes to//! higher than 100%, but clipping might occur.//! There is no single well-defined meaning attached to the 100% volume for a sink input. In fact,//! it depends on the server configuration. With flat volumes enabled, it means the maximum volume//! that the sound hardware is capable of, which is usually so high that you absolutely must not set//! sink input volume to 100% unless the user explicitly requests that (note that usually you//! shouldn’t set the volume anyway if the user doesn’t explicitly request it, instead, let//! PulseAudio decide the volume for the sink input). With flat volumes disabled the sink input//! volume is relative to the sink volume, so 100% sink input volume means that the sink input is//! played at the current sink volume level. In this case 100% is often a good default volume for a//! sink input, although you still should let PulseAudio decide the default volume. It is possible//! to figure out whether flat volume mode is in effect for a given sink by calling//! [`Introspector::get_sink_info_by_name()`].//! The [`Volume`]s in PulseAudio are cubic in nature and applications should not perform//! calculations with them directly. Instead, they should be converted to and from either dB or a//! linear scale.//! The [`VolumeDB`] type represents decibel (dB) converted values, and [`VolumeLinear`], linear.//! The `From` trait has been implemented for your convenience, allowing such conversions.//! For simple multiplication, [`Volume::multiply()`] and [`ChannelVolumes::sw_multiply()`] can be//! used.//! It’s often unknown what scale hardware volumes relate to. Don’t use the above functions on sink//! and source volumes, unless the sink or source in question has the//! [`SinkFlagSet::DECIBEL_VOLUME`] or [`SourceFlagSet::DECIBEL_VOLUME`] flag set. The conversion//! functions are rarely needed anyway, most of the time it’s sufficient to treat all volumes as//! opaque with a range from [`Volume::MUTED`] \(0%) to [`Volume::NORMAL`] \(100%).//! [`Introspector::get_sink_info_by_name()`]: crate::context::introspect::Introspector::get_sink_info_by_name//! [`SinkFlagSet::DECIBEL_VOLUME`]: crate::def::SinkFlagSet::DECIBEL_VOLUME//! [`SourceFlagSet::DECIBEL_VOLUME`]: crate::def::SourceFlagSet::DECIBEL_VOLUMEpcapipa_simpleSimpleInternal/// An opaque simple connection object./// Creates a new connection to the server./// * `server`: Server name, or `None` for default./// * `name`: A descriptive name for this client (application name, ...)./// * `dir`: Open this stream for recording or playback?/// * `dev`: Sink (resp. source) name, or `None` for default./// * `stream_name`: A descriptive name for this stream (application name, song title, ...)./// * `ss`: The sample type to use./// * `map`: The channel map to use, or `None` for default./// * `attr`: Buffering attributes, or `None` for default./// Creates a new `Simple` from an existing [`SimpleInternal`] pointer./// Writes some data to the server./// Waits until all data already written is played by the daemon./// Reads some data from the server./// This function blocks until `data.len()` amount of data has been received from the server,/// or until an error occurs./// Gets the playback or record latency./// Flushes the playback or record buffer./// This discards any audio in the buffer.//! A binding for the PulseAudio binding ‘simple’ interface (`libpulse-simple` system library).//! This binding enables Rust projects to make use of the ‘simple’ interface of the [PulseAudio]//! client system library. It builds upon the [separate raw FFI crate][sys] to provide a more//! “Rusty” interface.//! The ‘simple’ interface provides a simple but limited synchronous playback and recording API. It//! is a synchronous, simplified wrapper around the standard asynchronous API.//! Note that you will need components of the primary [`libpulse-binding`] crate to make use of//! The simple API is designed for applications with very basic sound playback or capture needs. It//! can only support a single stream per connection and has no support for handling of complex//! features like events, channel mappings and volume control. It is, however, very simple to use//! and quite sufficient for many programs.//! Start by adding a dependency on the crate, along with the main binding crate, in your program’s//! `Cargo.toml` file. Note that it is recommended that you rename the crates such that you can//! refer to them by shorter names within your code (such as `pulse` and `psimple` as used below).//! Such renaming can be done [within your `Cargo.toml` file][rename] with cargo version 1.31 or//! newer, or otherwise with `extern crate` statements.//! Finally, establish a connection, as below.//! The first step before using the sound system is to connect to the server. This is normally done//! this way://! # extern crate libpulse_binding as pulse;//! # extern crate libpulse_simple_binding as psimple;//! use psimple::Simple;//! use pulse::stream::Direction;//! let spec = Spec {//!     format: Format::S16NE,//!     channels: 2,//!     rate: 44100,//! assert!(spec.is_valid());//! let s = Simple::new(//!     None,                // Use the default server//!     "FooApp",            // Our application’s name//!     Direction::Playback, // We want a playback stream//!     None,                // Use the default device//!     "Music",             // Description of our stream//!     &spec,               // Our sample format//!     None,                // Use default channel map//!     None                 // Use default buffering attributes//! # Transferring data//! Once the connection is established to the server, data can start flowing. Using the connection//! is very similar to the normal read() and write() system calls using [`Simple::read()`] and//! [`Simple::write()`] methods of the [`Simple`] object. Note that these operations always block.//! # Buffer control//! * [`Simple::get_latency()`]: Will return the total latency of the playback or record pipeline,//!   respectively.//! * [`Simple::flush()`]: Will throw away all data currently in buffers.//! If a playback stream is used then the following operation is available://! * [`Simple::drain()`]: Will wait for all sent data to finish playing.//! # Cleanup//! Once playback or capture is complete, the connection should be closed and resources freed. This//! is done automatically once the [`Simple`] object is dropped.//! [sys]: https://docs.rs/libpulse-simple-sys//! [`libpulse-binding`]: https://docs.rs/libpulse-bindingpa_simple_newpa_simple_freepa_simple_writepa_simple_drainpa_simple_readpa_simple_get_latencypa_usec_tpa_simple_flush// This file is part of the PulseAudio Rust language linking library.//! PulseAudio FFI binding for the `libpulse-simple` system library.//! This crate does nothing more than offer a simple FFI binding to the C API of the [PulseAudio]//! client system library, specifically the “simple” interface component only. Please note that//! there is a “higher-level” binding available (the [`libpulse-simple-binding`] crate), built on//! top of this, which offers a more Rust-oriented interface.//! Unlike the “higher-level” binding just mentioned, virtually no documentation is provided here.//! Things that *are* documented here are typically only those directly re-exported by the//! “higher-level” binding. Please see either the equivalent documentation in that, or the//! documentation of the actual PulseAudio C header files, if you need documentation.pa_channel_position_mask_IMPL_NUM_FromPrimitive_FOR_pa_channel_position_t_IMPL_NUM_ToPrimitive_FOR_pa_channel_position_tPA_CHANNEL_POSITION_MAXPA_CHANNEL_POSITION_INVALIDPA_CHANNEL_POSITION_MONOPA_CHANNEL_POSITION_LEFTPA_CHANNEL_POSITION_RIGHTPA_CHANNEL_POSITION_CENTERPA_CHANNEL_POSITION_FRONT_LEFTPA_CHANNEL_POSITION_FRONT_RIGHTPA_CHANNEL_POSITION_FRONT_CENTERPA_CHANNEL_POSITION_REAR_CENTERPA_CHANNEL_POSITION_REAR_LEFTPA_CHANNEL_POSITION_REAR_RIGHTPA_CHANNEL_POSITION_LFEPA_CHANNEL_POSITION_SUBWOOFERPA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTERPA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTERPA_CHANNEL_POSITION_SIDE_LEFTPA_CHANNEL_POSITION_SIDE_RIGHTPA_CHANNEL_POSITION_AUX0PA_CHANNEL_POSITION_AUX1PA_CHANNEL_POSITION_AUX2PA_CHANNEL_POSITION_AUX3PA_CHANNEL_POSITION_AUX4PA_CHANNEL_POSITION_AUX5PA_CHANNEL_POSITION_AUX6PA_CHANNEL_POSITION_AUX7PA_CHANNEL_POSITION_AUX8PA_CHANNEL_POSITION_AUX9PA_CHANNEL_POSITION_AUX10PA_CHANNEL_POSITION_AUX11PA_CHANNEL_POSITION_AUX12PA_CHANNEL_POSITION_AUX13PA_CHANNEL_POSITION_AUX14PA_CHANNEL_POSITION_AUX15PA_CHANNEL_POSITION_AUX16PA_CHANNEL_POSITION_AUX17PA_CHANNEL_POSITION_AUX18PA_CHANNEL_POSITION_AUX19PA_CHANNEL_POSITION_AUX20PA_CHANNEL_POSITION_AUX21PA_CHANNEL_POSITION_AUX22PA_CHANNEL_POSITION_AUX23PA_CHANNEL_POSITION_AUX24PA_CHANNEL_POSITION_AUX25PA_CHANNEL_POSITION_AUX26PA_CHANNEL_POSITION_AUX27PA_CHANNEL_POSITION_AUX28PA_CHANNEL_POSITION_AUX29PA_CHANNEL_POSITION_AUX30PA_CHANNEL_POSITION_AUX31PA_CHANNEL_POSITION_TOP_CENTERPA_CHANNEL_POSITION_TOP_FRONT_LEFTPA_CHANNEL_POSITION_TOP_FRONT_RIGHTPA_CHANNEL_POSITION_TOP_FRONT_CENTERPA_CHANNEL_POSITION_TOP_REAR_LEFTPA_CHANNEL_POSITION_TOP_REAR_RIGHTPA_CHANNEL_POSITION_TOP_REAR_CENTERAIFF/// The mapping from RFC3551, which is based on AIFF-C.ALSA/// The default mapping used by ALSA. This mapping is probably not too useful since ALSA’s/// default channel mapping depends on the device string used.Aux/// Only aux channels.WAVEEx/// Microsoft’s WAVEFORMATEXTENSIBLE mapping. This mapping works as if all LSBs of dwChannelMask/// are set.OSS/// The default channel mapping used by OSS as defined in the OSS 4.0 API specs. This mapping is/// probably not too useful since the OSS API has changed in this respect and no longer knows a/// default channel mapping based on the number of channels._IMPL_NUM_FromPrimitive_FOR_pa_channel_map_def_t_IMPL_NUM_ToPrimitive_FOR_pa_channel_map_def_t/// Channel map definition standards./// Used in having a channel map automatically setup per number of channels and a specific standard.PA_CHANNEL_MAP_DEF_MAXPA_CHANNEL_MAP_AIFFPA_CHANNEL_MAP_ALSAPA_CHANNEL_MAP_AUXPA_CHANNEL_MAP_WAVEEXPA_CHANNEL_MAP_OSSPA_CHANNEL_MAP_DEFAULTPA_CHANNELS_MAXPA_CHANNEL_MAP_SNPRINT_MAXpa_channel_map_initpa_channel_map_init_monopa_channel_map_init_stereopa_channel_map_init_autopa_channel_map_init_extendpa_channel_position_to_stringpa_channel_position_from_stringpa_channel_position_to_pretty_stringpa_channel_map_snprintpa_channel_map_parsepa_channel_map_equalpa_channel_map_validpa_channel_map_compatiblepa_channel_map_supersetpa_channel_map_can_balancepa_channel_map_can_fadepa_channel_map_can_lfe_balancepa_channel_map_to_namepa_channel_map_to_pretty_namepa_channel_map_has_positionpa_channel_map_maskpa_context_success_cb_tn_role_prioritiespa_ext_device_manager_test_cb_tpa_ext_device_manager_read_cb_tpa_ext_device_manager_subscribe_cb_tpa_ext_device_manager_testpa_ext_device_manager_readpa_ext_device_manager_set_device_descriptionpa_ext_device_manager_deletepa_ext_device_manager_enable_role_device_priority_routingpa_ext_device_manager_reorder_devices_for_rolepa_ext_device_manager_subscribepa_ext_device_manager_set_subscribe_cbpa_format_infon_formatspa_ext_device_restore_test_cb_tpa_ext_device_restore_subscribe_cb_tpa_ext_device_restore_read_device_formats_cb_tpa_ext_device_restore_testpa_ext_device_restore_subscribepa_ext_device_restore_set_subscribe_cbpa_ext_device_restore_read_formats_allpa_ext_device_restore_read_formatspa_ext_device_restore_save_formatspa_ext_stream_restore_test_cb_tpa_ext_stream_restore_read_cb_tpa_ext_stream_restore_subscribe_cb_tpa_ext_stream_restore_testpa_ext_stream_restore_readpa_ext_stream_restore_writepa_ext_stream_restore_deletepa_ext_stream_restore_subscribepa_ext_stream_restore_set_subscribe_cbpa_sink_flags_tpa_source_flags_tn_portspa_sink_info_cb_tpa_source_info_cb_tpa_server_info_cb_tauto_unloadpa_module_info_cb_tpa_context_index_cb_t/// Index of the owning module, or [`PA_INVALID_INDEX`](crate::def::PA_INVALID_INDEX).pa_client_info_cb_tpa_card_profile_info/// Please note that this structure is obsolete, replaced by [`pa_card_profile_info2`] in PA v5./// Is this profile available? If this is zero, meaning “unavailable”, then it makes no sense to/// try to activate this profile. If this is non-zero, it’s still not a guarantee thatn_profilesprofiles2active_profile2pa_card_info_cb_tpa_sink_input_info_cb_tpa_source_output_info_cb_tmemblock_total/// Currently allocated memory blocks.memblock_total_size/// Current total size of allocated memory blocks.memblock_allocated/// Allocated memory blocks during the whole lifetime of the daemon.memblock_allocated_size/// Total size of all memory blocks allocated during the whole lifetime of the daemon.scache_size/// Total size of all sample cache entries./// Memory block statistics.pa_stat_info_cb_tpa_sample_info_cb_tpa_context_get_sink_info_by_namepa_context_get_sink_info_by_indexpa_context_get_sink_info_listpa_context_set_sink_volume_by_indexpa_context_set_sink_volume_by_namepa_context_set_sink_mute_by_indexpa_context_set_sink_mute_by_namepa_context_suspend_sink_by_namepa_context_suspend_sink_by_indexpa_context_set_sink_port_by_indexpa_context_set_sink_port_by_namepa_context_get_source_info_by_namepa_context_get_source_info_by_indexpa_context_get_source_info_listpa_context_set_source_volume_by_indexpa_context_set_source_volume_by_namepa_context_set_source_mute_by_indexpa_context_set_source_mute_by_namepa_context_suspend_source_by_namepa_context_suspend_source_by_indexpa_context_set_source_port_by_indexpa_context_set_source_port_by_namepa_context_get_server_infopa_context_get_module_infopa_context_get_module_info_listpa_context_load_modulepa_context_unload_modulepa_context_get_client_infopa_context_get_client_info_listpa_context_kill_clientpa_context_get_card_info_by_indexpa_context_get_card_info_by_namepa_context_get_card_info_listpa_context_set_card_profile_by_indexpa_context_set_card_profile_by_namepa_context_set_port_latency_offsetpa_context_get_sink_input_infopa_context_get_sink_input_info_listpa_context_move_sink_input_by_namepa_context_move_sink_input_by_indexpa_context_set_sink_input_volumepa_context_set_sink_input_mutepa_context_kill_sink_inputpa_context_get_source_output_infopa_context_get_source_output_info_listpa_context_move_source_output_by_namepa_context_move_source_output_by_indexpa_context_set_source_output_volumepa_context_set_source_output_mutepa_context_kill_source_outputpa_context_statpa_context_get_sample_info_by_namepa_context_get_sample_info_by_indexpa_context_get_sample_info_list// Re-exportpa_time_event_cb_t_IMPL_NUM_FromPrimitive_FOR_pa_context_state_t_IMPL_NUM_ToPrimitive_FOR_pa_context_state_tPA_CONTEXT_UNCONNECTEDPA_CONTEXT_CONNECTINGPA_CONTEXT_AUTHORIZINGPA_CONTEXT_SETTING_NAMEPA_CONTEXT_READYPA_CONTEXT_FAILEDPA_CONTEXT_TERMINATEDpa_context_is_goodpa_context_flags_tPA_CONTEXT_NOFLAGSPA_CONTEXT_NOAUTOSPAWNPA_CONTEXT_NOFAILpa_context_notify_cb_tpa_context_event_cb_tpa_context_newpa_context_new_with_proplistpa_context_unrefpa_context_refpa_context_set_state_callbackpa_context_set_event_callbackpa_context_errnopa_context_is_pendingpa_context_get_statepa_context_connectpa_context_disconnectpa_context_drainpa_context_exit_daemonpa_context_set_default_sinkpa_context_set_default_sourcepa_context_is_localpa_context_set_namepa_context_get_serverpa_context_get_protocol_versionpa_context_get_server_protocol_versionpa_context_proplist_updatepa_context_proplist_removepa_context_get_indexpa_context_rttime_newpa_context_rttime_restartpa_context_get_tile_sizepa_context_load_cookie_from_file//! A [`pa_context`] object wraps a connection to a PulseAudio server using its native protocol.pa_context_play_sample_cb_tpa_context_remove_samplepa_context_play_samplepa_context_play_sample_with_proplist/// The base integer type passed to the callback, from which the facility and operation components/// can be extracted.pa_subscription_mask_t/// Used to express what facilities you are interested in when subscribing.PA_SUBSCRIPTION_EVENT_FACILITY_MASKPA_SUBSCRIPTION_EVENT_TYPE_MASKPA_SUBSCRIPTION_MASK_NULLPA_SUBSCRIPTION_MASK_SINKPA_SUBSCRIPTION_MASK_SOURCEPA_SUBSCRIPTION_MASK_SINK_INPUTPA_SUBSCRIPTION_MASK_SOURCE_OUTPUTPA_SUBSCRIPTION_MASK_MODULEPA_SUBSCRIPTION_MASK_CLIENTPA_SUBSCRIPTION_MASK_SAMPLE_CACHEPA_SUBSCRIPTION_MASK_SERVERPA_SUBSCRIPTION_MASK_CARD/* NOTE: value `0x100` previously assigned, obsoleted */PA_SUBSCRIPTION_MASK_ALLevent_facilitiesPA_SUBSCRIPTION_EVENT_SINKPA_SUBSCRIPTION_EVENT_SOURCEPA_SUBSCRIPTION_EVENT_SINK_INPUTPA_SUBSCRIPTION_EVENT_SOURCE_OUTPUTPA_SUBSCRIPTION_EVENT_MODULEPA_SUBSCRIPTION_EVENT_CLIENTPA_SUBSCRIPTION_EVENT_SAMPLE_CACHEPA_SUBSCRIPTION_EVENT_SERVER/// Global server change, only occurring with a change operation.PA_SUBSCRIPTION_EVENT_CARD/// Possible facility variants that could be extracted from an event type.event_operationsPA_SUBSCRIPTION_EVENT_NEWPA_SUBSCRIPTION_EVENT_CHANGEPA_SUBSCRIPTION_EVENT_REMOVE/// Possible operation variants that could be extracted from an event type.pa_subscription_match_flags/// Checks if event type `t` matches an event mask bitfield (returns `true` if so).pa_context_subscribe_cb_tpa_context_subscribepa_context_set_subscribe_callback/// An invalid index.pa_free_cb_t/// A sink./// A source._IMPL_NUM_FromPrimitive_FOR_pa_device_type_t_IMPL_NUM_ToPrimitive_FOR_pa_device_type_t/// Device type, source or sink.PA_DEVICE_TYPE_SINKPA_DEVICE_TYPE_SOURCEPA_SINK_NOFLAGSPA_SINK_HW_VOLUME_CTRLPA_SINK_LATENCYPA_SINK_HARDWAREPA_SINK_NETWORKPA_SINK_HW_MUTE_CTRLPA_SINK_DECIBEL_VOLUMEPA_SINK_FLAT_VOLUMEPA_SINK_DYNAMIC_LATENCYPA_SINK_SET_FORMATS_IMPL_NUM_FromPrimitive_FOR_pa_sink_state_t_IMPL_NUM_ToPrimitive_FOR_pa_sink_state_tPA_SINK_INVALID_STATEPA_SINK_RUNNINGPA_SINK_IDLEPA_SINK_SUSPENDEDpa_sink_is_opened/// Checks if state is playing, i.e. running or idle (returns `true` if so).pa_sink_is_running/// Checks if state is running (returns `true` if so).PA_SOURCE_NOFLAGSPA_SOURCE_HW_VOLUME_CTRLPA_SOURCE_LATENCYPA_SOURCE_HARDWAREPA_SOURCE_NETWORKPA_SOURCE_HW_MUTE_CTRLPA_SOURCE_DECIBEL_VOLUMEPA_SOURCE_DYNAMIC_LATENCYPA_SOURCE_FLAT_VOLUME_IMPL_NUM_FromPrimitive_FOR_pa_source_state_t_IMPL_NUM_ToPrimitive_FOR_pa_source_state_tPA_SOURCE_INVALID_STATEPA_SOURCE_RUNNINGPA_SOURCE_IDLEPA_SOURCE_SUSPENDEDpa_source_is_openedpa_source_is_running/// This port does not support jack detection./// This port is not available, likely because the jack is not plugged in./// This port is available, likely because the jack is plugged in._IMPL_NUM_FromPrimitive_FOR_pa_port_available_t_IMPL_NUM_ToPrimitive_FOR_pa_port_available_t/// Port availability.PA_PORT_AVAILABLE_UNKNOWNPA_PORT_AVAILABLE_NOPA_PORT_AVAILABLE_YES/// Auxillary.Speaker/// Speaker.Headphones/// Headphones./// Line.Mic/// Mic.Headset/// Headset.Handset/// Handset.Earpiece/// Earpiece.SPDIF/// SPDIF.HDMI/// HDMI./// TV./// Radio./// Video./// USB./// Bluetooth.Portable/// Portable.Handsfree/// Handsfree.Car/// Car.HiFi/// HiFi./// Phone./// Network.Analog/// Analog._IMPL_NUM_FromPrimitive_FOR_pa_device_port_type_t_IMPL_NUM_ToPrimitive_FOR_pa_device_port_type_t/// Port type.PA_DEVICE_PORT_TYPE_UNKNOWNPA_DEVICE_PORT_TYPE_AUXPA_DEVICE_PORT_TYPE_SPEAKERPA_DEVICE_PORT_TYPE_HEADPHONESPA_DEVICE_PORT_TYPE_LINEPA_DEVICE_PORT_TYPE_MICPA_DEVICE_PORT_TYPE_HEADSETPA_DEVICE_PORT_TYPE_HANDSETPA_DEVICE_PORT_TYPE_EARPIECEPA_DEVICE_PORT_TYPE_SPDIFPA_DEVICE_PORT_TYPE_HDMIPA_DEVICE_PORT_TYPE_TVPA_DEVICE_PORT_TYPE_RADIOPA_DEVICE_PORT_TYPE_VIDEOPA_DEVICE_PORT_TYPE_USBPA_DEVICE_PORT_TYPE_BLUETOOTHPA_DEVICE_PORT_TYPE_PORTABLEPA_DEVICE_PORT_TYPE_HANDSFREEPA_DEVICE_PORT_TYPE_CARPA_DEVICE_PORT_TYPE_HIFIPA_DEVICE_PORT_TYPE_PHONEPA_DEVICE_PORT_TYPE_NETWORKPA_DEVICE_PORT_TYPE_ANALOGpa_direction_t/// Direction bitfield./// While we currently do not expose anything bidirectional, one should test against the bit instead/// of the value because we might add bidirectional stuff in the future.PA_DIRECTION_OUTPUTPA_DIRECTION_INPUTpa_direction_validpa_direction_to_string//! Utility functions for direction._IMPL_NUM_FromPrimitive_FOR_pa_error_code_t_IMPL_NUM_ToPrimitive_FOR_pa_error_code_t/// Error code./// These represent the i32 error codes returned by many of the underlying PulseAudio C functions./// Beware, these enum values are positive values, whilst PA functions return them in negative form,/// i.e. the `Invalid` variant here has a value of `3`, while functions returning this error code/// return `-3`. (This is identical to the enum provided in the PA C API).PA_ERR_MAXPA_OKPA_ERR_ACCESSPA_ERR_COMMANDPA_ERR_INVALIDPA_ERR_EXISTPA_ERR_NOENTITYPA_ERR_CONNECTIONREFUSEDPA_ERR_PROTOCOLPA_ERR_TIMEOUTPA_ERR_AUTHKEYPA_ERR_INTERNALPA_ERR_CONNECTIONTERMINATEDPA_ERR_KILLEDPA_ERR_INVALIDSERVERPA_ERR_MODINITFAILEDPA_ERR_BADSTATEPA_ERR_NODATAPA_ERR_VERSIONPA_ERR_TOOLARGEPA_ERR_NOTSUPPORTEDPA_ERR_UNKNOWNPA_ERR_NOEXTENSIONPA_ERR_OBSOLETEPA_ERR_NOTIMPLEMENTEDPA_ERR_FORKEDPA_ERR_IOPA_ERR_BUSYpa_strerror_IMPL_NUM_FromPrimitive_FOR_pa_encoding_t_IMPL_NUM_ToPrimitive_FOR_pa_encoding_tPA_ENCODING_MAXPA_ENCODING_ANYPA_ENCODING_PCMPA_ENCODING_AC3_IEC61937PA_ENCODING_EAC3_IEC61937PA_ENCODING_MPEG_IEC61937PA_ENCODING_DTS_IEC61937PA_ENCODING_MPEG2_AAC_IEC61937PA_ENCODING_INVALIDplistPA_FORMAT_INFO_SNPRINT_MAX/// The maximum length of strings returned by [`pa_format_info_snprint()`]./// Please note that this value can change with any release without warning and without being/// considered API or ABI breakage. You should not use this definition anywhere where it might/// become part of an ABI./// Integer./// Integer range.IntArray/// Integer array./// String./// String array._IMPL_NUM_FromPrimitive_FOR_pa_prop_type_t_IMPL_NUM_ToPrimitive_FOR_pa_prop_type_t/// Represents the type of value of a property.PA_PROP_TYPE_INTPA_PROP_TYPE_INT_RANGEPA_PROP_TYPE_INT_ARRAYPA_PROP_TYPE_STRINGPA_PROP_TYPE_STRING_ARRAYPA_PROP_TYPE_INVALIDpa_encoding_to_stringpa_format_info_newpa_format_info_copypa_format_info_freepa_format_info_validpa_format_info_is_pcmpa_format_info_is_compatiblepa_format_info_snprintpa_format_info_from_stringpa_format_info_from_sample_specpa_format_info_to_sample_specpa_format_info_get_prop_typepa_format_info_get_prop_intpa_format_info_get_prop_int_rangepa_format_info_get_prop_int_arraypa_format_info_get_prop_stringpa_format_info_get_prop_string_arraypa_format_info_free_string_arraypa_format_info_set_prop_intpa_format_info_set_prop_int_arraypa_format_info_set_prop_int_rangepa_format_info_set_prop_stringpa_format_info_set_prop_string_arraypa_format_info_set_sample_formatpa_format_info_set_ratepa_format_info_set_channelspa_format_info_set_channel_maprtclockxmalloc//! PulseAudio FFI bindings for the main `libpulse` system library.//! client system library. Please note that there is a “higher-level” binding available (the//! [`libpulse-binding`] crate), built on top of this, which offers a more Rust-oriented interface.pa_io_event_flags_tio_event_flagsPA_IO_EVENT_NULLPA_IO_EVENT_INPUTPA_IO_EVENT_OUTPUTPA_IO_EVENT_HANGUPPA_IO_EVENT_ERROR/// An opaque IO event source object.pa_io_event_cb_tpa_io_event_destroy_cb_t/// An opaque timer event source object.pa_time_event_destroy_cb_t/// An opaque deferred event source object./// Events of this type are triggered once in every main loop iteration.pa_defer_event_cb_tpa_defer_event_destroy_cb_tpa_mainloop_api_once_cbpa_mainloop_api_oncepa_signal_cb_tpa_signal_destroy_cb_tpa_signal_initpa_signal_donepa_signal_newpa_signal_freepa_signal_set_destroypa_poll_funcpa_mainloop_newpa_mainloop_freepa_mainloop_preparepa_mainloop_pollpa_mainloop_dispatchpa_mainloop_get_retvalpa_mainloop_iteratepa_mainloop_runpa_mainloop_get_apipa_mainloop_quitpa_mainloop_wakeuppa_mainloop_set_poll_func/// An opaque threaded main loop object.pa_threaded_mainloop_newpa_threaded_mainloop_freepa_threaded_mainloop_startpa_threaded_mainloop_stoppa_threaded_mainloop_lockpa_threaded_mainloop_unlockpa_threaded_mainloop_waitpa_threaded_mainloop_signalpa_threaded_mainloop_acceptpa_threaded_mainloop_get_retvalpa_threaded_mainloop_get_apipa_threaded_mainloop_in_threadpa_threaded_mainloop_set_name/// The operation is still running./// The operation has completed./// The operation has been cancelled. Operations may get cancelled by the application, or as a/// result of the context getting disconnected while the operation is pending._IMPL_NUM_FromPrimitive_FOR_pa_operation_state_t_IMPL_NUM_ToPrimitive_FOR_pa_operation_state_t/// Operation state.PA_OPERATION_RUNNINGPA_OPERATION_DONEPA_OPERATION_CANCELEDPA_OPERATION_CANCELLEDpa_operation_notify_cb_t/// A callback for operation state changes.pa_operation_refpa_operation_unrefpa_operation_cancelpa_operation_get_statepa_operation_set_state_callback/// For streams: localized media name, formatted as UTF-8. E.g. "Guns'N'Roses: Civil War"./// For streams: localized media title if applicable, formatted as UTF-8. E.g. "Civil War"./// For streams: localized media artist if applicable, formatted as UTF-8. E.g. "Guns'N'Roses"./// For streams: localized media copyright string if applicable, formatted as UTF-8./// E.g. "Evil Record Corp."./// For streams: localized media generator software string if applicable, formatted as UTF-8./// E.g. "Foocrop AudioFrobnicator"./// For streams: media language if applicable, in standard POSIX format. E.g. "de_DE"./// For streams: source filename if applicable, in URI format or local path./// E.g. "/home/lennart/music/foobar.ogg"./// For streams: icon for the media. A binary blob containing PNG image data./// For streams: an XDG icon name for the media. E.g. "audio-x-mp3"./// For streams: logic role of this media./// One of the strings "video", "music", "game", "event", "phone", "animation", "production",/// "a11y", "test"./// For streams: the name of a filter that is desired, e.g. "echo-cancel" or "equalizer-sink"./// PulseAudio may choose to not apply the filter if it does not make sense (for example, applying/// echo-cancellation on a Bluetooth headset probably does not make sense.PA_PROP_FILTER_APPLY/// Differs from PA_PROP_FILTER_WANT in that it forces PulseAudio to apply the filter, regardless of/// whether PulseAudio thinks it makes sense to do so or not. If this is set, PA_PROP_FILTER_WANT/// is ignored. In other words, you almost certainly do not want to use this.PA_PROP_FILTER_SUPPRESS/// PA_PROP_FILTER_WANT). Useful for the times that PA_PROP_FILTER_WANT is automatically added (e.g./// For event sound streams: XDG event sound name. e.g. "message-new-email" (Event sound streams are/// those with media.role set to "event")./// For event sound streams: localized human readable one-line description of the event, formatted/// as UTF-8. E.g. "Email from lennart\@example.com received."/// For event sound streams: absolute horizontal mouse position on the screen if the event sound was/// triggered by a mouse click, integer formatted as text string. E.g. "865"./// For event sound streams: absolute vertical mouse position on the screen if the event sound was/// triggered by a mouse click, integer formatted as text string. E.g. "432"./// For event sound streams: relative horizontal mouse position on the screen if the event sound was/// triggered by a mouse click, float formatted as text string, ranging from 0.0 (left side of the/// screen) to 1.0 (right side of the screen). E.g. "0.65"./// For event sound streams: relative vertical mouse position on the screen if the event sound was/// triggered by a mouse click, float formatted as text string, ranging from 0.0 (top of the screen)/// to 1.0 (bottom of the screen). E.g. "0.43"./// For event sound streams: mouse button that triggered the event if applicable, integer formatted/// as string with 0=left, 1=middle, 2=right. E.g. "0"./// For streams that belong to a window on the screen: localized window title./// E.g. "Totem Music Player"./// For streams that belong to a window on the screen: a textual id for identifying a window/// logically. E.g. "org.gnome.Totem.MainWindow"./// For streams that belong to a window on the screen: window icon. A binary blob containing PNG/// image data./// For streams that belong to a window on the screen: an XDG icon name for the window. E.g./// "totem"./// For streams that belong to a window on the screen: absolute horizontal window position on the/// screen, integer formatted as text string. E.g. "865"./// For streams that belong to a window on the screen: absolute vertical window position on the/// screen, integer formatted as text string. E.g. "343"./// For streams that belong to a window on the screen: window width on the screen, integer/// formatted as text string. e.g. "365"./// For streams that belong to a window on the screen: window height on the screen, integer/// formatted as text string. E.g. "643"./// For streams that belong to a window on the screen: relative position of the window center on the/// screen, float formatted as text string, ranging from 0.0 (left side of the screen) to 1.0 (right/// side of the screen). E.g. "0.65"./// screen, float formatted as text string, ranging from 0.0 (top of the screen) to 1.0 (bottom of/// the screen). E.g. "0.43"./// For streams that belong to a window on the screen: if the windowing system supports multiple/// desktops, a comma separated list of indexes of the desktops this window is visible on. If this/// property is an empty string, it is visible on all desktops (i.e. ‘sticky’). The first desktop is/// zero. E.g. "0,2,3"./// For streams that belong to an X11 window on the screen: the X11 display string. E.g. ":0.0"./// For streams that belong to an X11 window on the screen: the X11 screen the window is on, an/// integer formatted as string. E.g. "0"./// For streams that belong to an X11 window on the screen: the X11 monitor the window is on, an/// For streams that belong to an X11 window on the screen: the window XID, an integer formatted as/// string. E.g. "25632"./// For clients/streams: localized human readable application name. E.g. "Totem Music Player"./// For clients/streams: a textual id for identifying an application logically./// E.g. "org.gnome.Totem"./// For clients/streams: a version string, e.g. "0.6.88"./// For clients/streams: application icon. A binary blob containing PNG image data./// For clients/streams: an XDG icon name for the application. E.g. "totem"./// For clients/streams: application language if applicable, in standard POSIX format. E.g. "de_DE"./// For clients/streams on UNIX: application process PID, an integer formatted as string. E.g./// "4711"./// For clients/streams: application process name. E.g. "totem"./// For clients/streams: application user name. E.g. "lennart"./// For clients/streams: host name the application runs on. E.g. "omega"./// For clients/streams: the D-Bus host id the application runs on./// E.g. "543679e7b01393ed3e3e650047d78f6e"./// For clients/streams: an id for the login session the application runs in. On Unix the value of/// $XDG_SESSION_ID. E.g. "5"./// For devices: device string in the underlying audio layer’s format. E.g. "surround51:0"./// For devices: API this device is accessed with. E.g. "alsa"./// For devices: localized human readable device one-line description./// E.g. "Foobar Industries USB Headset 2000+ Ultra"./// For devices: bus path to the device in the OS’ format./// E.g. "/sys/bus/pci/devices/0000:00:1f.2"./// For devices: serial number if applicable. E.g. "4711-0815-1234"./// For devices: vendor ID if applicable. E.g. 1274./// For devices: vendor name if applicable. E.g. "Foocorp Heavy Industries"./// For devices: product ID if applicable. E.g. 4565./// For devices: product name if applicable. E.g. "SuperSpeakers 2000 Pro"./// For devices: device class. One of "sound", "modem", "monitor", "filter"./// For devices: form factor if applicable. One of "internal", "speaker", "handset", "tv", "webcam",/// "microphone", "headset", "headphone", "hands-free", "car", "hifi", "computer", "portable"./// For devices: bus of the device if applicable. One of "isa", "pci", "usb", "firewire",/// "bluetooth"./// For devices: icon for the device. A binary blob containing PNG image data./// For devices: an XDG icon name for the device. E.g. "sound-card-speakers-usb"./// For devices: access mode of the device if applicable. One of "mmap", "mmap_rewrite", "serial"./// For filter devices: master device id if applicable./// For devices: buffer size in bytes, integer formatted as string./// For devices: fragment size in bytes, integer formatted as string./// For devices: profile identifier for the profile this devices is in./// E.g. "analog-stereo", "analog-surround-40", "iec958-stereo", ...PA_PROP_DEVICE_INTENDED_ROLES/// For devices: intended use. A space separated list of roles (see PA_PROP_MEDIA_ROLE) this device/// For devices: human readable one-line description of the profile this device is in. E.g./// "Analog Stereo", .../// For modules: the author’s name, formatted as UTF-8 string. E.g. "Lennart Poettering"./// For modules: a human readable one-line description of the module’s purpose formatted as UTF-8./// E.g. "Frobnicate sounds with a flux compensator"./// For modules: a human readable usage description of the module’s arguments formatted as UTF-8./// For modules: a version string for the module. E.g. "0.9.15".PA_PROP_FORMAT_SAMPLE_FORMAT/// For PCM formats: the sample format used as returned by `pa_sample_format_to_string`./// For all formats: the sample rate (unsigned integer)./// For all formats: the number of channels (unsigned integer).PA_PROP_FORMAT_CHANNEL_MAP/// For PCM formats: the channel map of the stream as returned by `pa_channel_map_snprint`.PA_PROP_CONTEXT_FORCE_DISABLE_SHM/// For context: whether to forcefully disable data transfer via POSIX or memfd shared memory./// This property overrides any other client configuration which would otherwise enable SHM/// communication channels.//TODO: enable this feature gate once the passing of `--cfg doc` to dependencies is fixed (https://github.com/rust-lang/cargo/issues/8811)//#[cfg(any(doc, feature = "pa_v15"))]PA_PROP_BLUETOOTH_CODEC/// For a bluez device: the currently selected codec name./// Replace the entire property list with the new one. Don’t keep any of the old data around./// Merge new property list into the existing one, not replacing any old entries if they share a/// common key with the new property list./// Merge new property list into the existing one, replacing all old entries that share a common/// key with the new property list._IMPL_NUM_FromPrimitive_FOR_pa_update_mode_t_IMPL_NUM_ToPrimitive_FOR_pa_update_mode_t/// Update mode.PA_UPDATE_SETPA_UPDATE_MERGEPA_UPDATE_REPLACEpa_proplist_newpa_proplist_freepa_proplist_key_validpa_proplist_setspa_proplist_setppa_proplist_setfpa_proplist_setpa_proplist_getspa_proplist_getpa_proplist_updatepa_proplist_unsetpa_proplist_unset_manypa_proplist_iteratepa_proplist_to_stringpa_proplist_to_string_seppa_proplist_from_stringpa_proplist_containspa_proplist_clearpa_proplist_copypa_proplist_sizepa_proplist_isemptypa_proplist_equalpa_rtclock_now//! Monotonic clock utilities.PA_RATE_MAX_IMPL_NUM_FromPrimitive_FOR_pa_sample_format_t_IMPL_NUM_ToPrimitive_FOR_pa_sample_format_tPA_SAMPLE_MAXPA_SAMPLE_U8PA_SAMPLE_ALAWPA_SAMPLE_ULAWPA_SAMPLE_S16LEPA_SAMPLE_S16BEPA_SAMPLE_FLOAT32LEPA_SAMPLE_FLOAT32BEPA_SAMPLE_S32LEPA_SAMPLE_S32BEPA_SAMPLE_S24LEPA_SAMPLE_S24BEPA_SAMPLE_S24_32LEPA_SAMPLE_S24_32BEPA_SAMPLE_INVALIDPA_SAMPLE_S16NEPA_SAMPLE_FLOAT32NEPA_SAMPLE_S32NEPA_SAMPLE_S24NEPA_SAMPLE_S24_32NEPA_SAMPLE_S16REPA_SAMPLE_FLOAT32REPA_SAMPLE_S32REPA_SAMPLE_S24REPA_SAMPLE_S24_32RE/// Endian-independent format identifiers.PA_SAMPLE_FLOAT32/// A shortcut for [`PA_SAMPLE_FLOAT32NE`]./// Type for usec specifications (unsigned). Always 64 bit.PA_SAMPLE_SPEC_SNPRINT_MAX/// The maximum length of strings returned by [`pa_sample_spec_snprint()`].PA_BYTES_SNPRINT_MAX/// The maximum length of strings returned by [`pa_bytes_snprint()`].pa_bytes_per_secondpa_frame_sizepa_sample_sizepa_sample_size_of_formatpa_bytes_to_usecpa_usec_to_bytespa_sample_spec_initpa_sample_format_validpa_sample_rate_validpa_channels_validpa_sample_spec_validpa_sample_spec_equalpa_sample_format_to_stringpa_parse_sample_formatpa_sample_spec_snprintpa_bytes_snprintpa_sample_format_is_lepa_sample_format_is_be_IMPL_NUM_FromPrimitive_FOR_pa_stream_state_t_IMPL_NUM_ToPrimitive_FOR_pa_stream_state_tPA_STREAM_UNCONNECTEDPA_STREAM_CREATINGPA_STREAM_READYPA_STREAM_FAILEDPA_STREAM_TERMINATEDpa_stream_is_goodPlayback/// Playback./// Record.Upload/// Upload._IMPL_NUM_FromPrimitive_FOR_pa_stream_direction_t_IMPL_NUM_ToPrimitive_FOR_pa_stream_direction_t/// Stream direction.PA_STREAM_NODIRECTIONPA_STREAM_PLAYBACKPA_STREAM_RECORDPA_STREAM_UPLOADpa_stream_flags_tPA_STREAM_NOFLAGSPA_STREAM_START_CORKEDPA_STREAM_INTERPOLATE_TIMINGPA_STREAM_NOT_MONOTONICPA_STREAM_AUTO_TIMING_UPDATEPA_STREAM_NO_REMAP_CHANNELSPA_STREAM_NO_REMIX_CHANNELSPA_STREAM_FIX_FORMATPA_STREAM_FIX_RATEPA_STREAM_FIX_CHANNELSPA_STREAM_DONT_MOVEPA_STREAM_VARIABLE_RATEPA_STREAM_PEAK_DETECTPA_STREAM_START_MUTEDPA_STREAM_ADJUST_LATENCYPA_STREAM_EARLY_REQUESTSPA_STREAM_DONT_INHIBIT_AUTO_SUSPENDPA_STREAM_START_UNMUTEDPA_STREAM_FAIL_ON_SUSPENDPA_STREAM_RELATIVE_VOLUMEPA_STREAM_PASSTHROUGH/// Seek relatively to the write index./// Seek relatively to the start of the buffer queue.RelativeOnRead/// Seek relatively to the read index.RelativeEnd/// Seek relatively to the current end of the buffer queue._IMPL_NUM_FromPrimitive_FOR_pa_seek_mode_t_IMPL_NUM_ToPrimitive_FOR_pa_seek_mode_t/// Seek mode.PA_SEEK_RELATIVEPA_SEEK_ABSOLUTEPA_SEEK_RELATIVE_ON_READPA_SEEK_RELATIVE_ENDPA_STREAM_EVENT_REQUEST_CORKPA_STREAM_EVENT_REQUEST_UNCORKPA_STREAM_EVENT_FORMAT_LOSTpa_stream_success_cb_tpa_stream_request_cb_tpa_stream_notify_cb_tpa_stream_event_cb_tpa_stream_connect_uploadpa_stream_finish_uploadpa_stream_newpa_stream_new_with_proplistpa_stream_new_extendedpa_stream_unrefpa_stream_refpa_stream_get_statepa_stream_get_contextpa_stream_get_indexpa_stream_get_device_indexpa_stream_get_device_namepa_stream_is_suspendedpa_stream_is_corkedpa_stream_connect_playbackpa_stream_connect_recordpa_stream_disconnectpa_stream_begin_writepa_stream_cancel_writepa_stream_writepa_stream_write_ext_freepa_stream_peekpa_stream_droppa_stream_writable_sizepa_stream_readable_sizepa_stream_drainpa_stream_update_timing_infopa_stream_set_state_callbackpa_stream_set_write_callbackpa_stream_set_read_callbackpa_stream_set_overflow_callbackpa_stream_get_underflow_indexpa_stream_set_underflow_callbackpa_stream_set_started_callbackpa_stream_set_latency_update_callbackpa_stream_set_moved_callbackpa_stream_set_suspended_callbackpa_stream_set_event_callbackpa_stream_set_buffer_attr_callbackpa_stream_corkpa_stream_flushpa_stream_prebufpa_stream_triggerpa_stream_set_namepa_stream_get_timepa_stream_get_latencypa_stream_get_timing_infopa_stream_get_sample_specpa_stream_get_channel_mappa_stream_get_format_infopa_stream_get_buffer_attrpa_stream_set_buffer_attrpa_stream_update_sample_ratepa_stream_proplist_updatepa_stream_proplist_removepa_stream_set_monitor_streampa_stream_get_monitor_streamPA_MSEC_PER_SECPA_USEC_PER_SECPA_NSEC_PER_SECPA_USEC_PER_MSECPA_NSEC_PER_MSECPA_NSEC_PER_USECPA_USEC_INVALIDPA_USEC_MAXpa_gettimeofdaypa_timeval_diffpa_timeval_cmppa_timeval_agepa_timeval_addpa_timeval_subpa_timeval_storepa_timeval_load//! Utility functions for handling timeval calculations.pa_utf8_validpa_ascii_validpa_utf8_filterpa_ascii_filterpa_utf8_to_localepa_locale_to_utf8pa_get_user_namepa_get_host_namepa_get_fqdnpa_get_home_dirpa_get_binary_namepa_path_get_filenamepa_msleepV5Plus/// Support for PA version 5+ selected.V6Plus/// Support for PA version 6+ selected.V8Plus/// Support for PA version 8+ selected.V12Plus/// Support for PA version 12+ selected.V13Plus/// Support for PA version 13+ selected.V14Plus/// Support for PA version 14+ selected.V15Plus/// Support for PA version 15+ selected./// PulseAudio version compatibility./// Used for indicating what level of PA version compatibility was selected at compile time via/// Cargo feature flags./// Note that PA v4 is the oldest supported.COMPATIBILITY// Pre-v12/// Version string of targetted version./// See the module level documentation for an explanation./// Version number of targetted version./// Protocol version of targetted version./// The current API version./// Note, this has not been updated since PA v0.9.11. It is presumed that it would only ever be/// updated for backwards-breaking API changes./// Get selected compatibility level./// Returns indication of the level of PulseAudio version compatibility selected at compile time viapa_check_versionpa_get_library_version//! Version constants and functions.//! This module contains functions and constants relating to PulseAudio (PA) client API version//! compatibility.//! As discussed in the project `COMPATIBILITY.md` file, support is offered for multiple versions of//! the PA client library, with changes made in newer versions being guarded with Cargo feature//! flags.//! The version constants defined here mostly relate to those provided in the PA C headers. They are//! typically only updated following a new **major** release of PA. They are also dynamic, depending//! upon the level of compatibility support selected at compile time via the available Cargo feature//! Note that there is **not** a one-to-one mapping of major PA version to compatibility feature. A//! new such feature is only introduced where actual changes in the PA client API require one//! because they introduce changes such as the addition of new functions.//! It is not obvious how the constants relate to version compatibility levels without reading the//! code, so this needs explaining. Simply put, version numbers are updated typically only on//! release of a new major version of PA, and update the existing version number associated with the//! current latest compatibility level selector when there are no changes requiring a new//! compatibility feature.//! Thus, for instance, PA versions 8 and 12 introduced additions to the API and have corresponding//! compatibility features to control the inclusion of those additions on top of the minimum level//! of support offered. If you have v8 compatibility enabled but not v12, then the version number//! indicated will be v11./// The basic volume type.PA_VOLUME_NORM/// Normal volume (100%, 0 dB).PA_VOLUME_MUTED/// Muted (minimal valid) volume (0%, -inf dB).PA_VOLUME_MAX/// Maximum valid volume we can store.pa_volume_ui_maxPA_VOLUME_INVALID/// Special ‘invalid’ volume.PA_DECIBEL_MININFTY/// This floor value is used as minus infinity when using [`pa_sw_volume_to_dB()`] or/// [`pa_sw_volume_from_dB()`].PA_CVOLUME_SNPRINT_MAX/// The maximum length of strings returned by [`pa_cvolume_snprint()`].PA_SW_CVOLUME_SNPRINT_DB_MAX/// The maximum length of strings returned by [`pa_sw_cvolume_snprint_dB()`].PA_CVOLUME_SNPRINT_VERBOSE_MAX/// The maximum length of strings returned by [`pa_cvolume_snprint_verbose()`].PA_VOLUME_SNPRINT_MAX/// The maximum length of strings returned by [`pa_volume_snprint()`].PA_SW_VOLUME_SNPRINT_DB_MAX/// The maximum length of strings returned by [`pa_sw_volume_snprint_dB()`].PA_VOLUME_SNPRINT_VERBOSE_MAX/// The maximum length of strings returned by [`pa_volume_snprint_verbose()`].pa_volume_is_validpa_clamp_volumepa_cvolume_reset/// Sets the volume of the first n channels to [`PA_VOLUME_NORM`].pa_cvolume_mute/// Sets the volume of the first n channels to [`PA_VOLUME_MUTED`].pa_cvolume_equalpa_cvolume_initpa_cvolume_setpa_cvolume_snprintpa_sw_cvolume_snprint_dBpa_cvolume_snprint_verbosepa_volume_snprintpa_sw_volume_snprint_dBpa_volume_snprint_verbosepa_cvolume_avgpa_cvolume_avg_maskpa_cvolume_maxpa_cvolume_max_maskpa_cvolume_minpa_cvolume_min_maskpa_cvolume_validpa_cvolume_channels_equal_topa_sw_volume_multiplypa_sw_cvolume_multiplypa_sw_cvolume_multiply_scalarpa_sw_volume_dividepa_sw_cvolume_dividepa_sw_cvolume_divide_scalarpa_sw_volume_from_dBpa_sw_volume_to_dBpa_sw_volume_from_linearpa_sw_volume_to_linearpa_cvolume_remappa_cvolume_compatiblepa_cvolume_compatible_with_channel_mappa_cvolume_get_balancepa_cvolume_set_balancepa_cvolume_get_fadepa_cvolume_set_fadepa_cvolume_get_lfe_balancepa_cvolume_set_lfe_balancepa_cvolume_scalepa_cvolume_scale_maskpa_cvolume_set_positionpa_cvolume_get_positionpa_cvolume_mergepa_cvolume_inc_clamppa_cvolume_incpa_cvolume_decpa_xnew/// Allocates `n` new structures of the specified type.pa_xnew0/// Same as [`pa_xnew()`] but sets the memory to zero.pa_xnewdup/// Same as [`pa_xnew()`] but duplicates the specified data.pa_xrenew/// Reallocates `n` new structures of the specified type.pa_xmalloc/// Allocates the specified number of bytes, just like `malloc()` does./// However, in case of OOM, terminate.pa_xmalloc0/// Same as [`pa_xmalloc()`] , but initializes allocated memory to 0.pa_xrealloc///  The combination of [`pa_xmalloc()`] and `realloc()`.pa_xfree/// Frees allocated memory.pa_xstrdup/// Duplicates the specified string, allocating memory with [`pa_xmalloc()`].pa_xstrndup/// Duplicates the specified string, but truncate after `l` characters.pa_xmemdup/// Duplicates the specified memory block.//! Memory allocation functions.SRC_STATE_tagSRC_STATEdata_ininput_framesoutput_framesinput_frames_usedoutput_frames_genend_of_inputsrc_ratioSRC_DATAsrc_callback_tsrc_newsrc_clonesrc_callback_newsrc_deletesrc_processsrc_callback_readsrc_simplesrc_get_namesrc_get_descriptionsrc_get_versionsrc_set_ratiosrc_get_channelssrc_resetsrc_is_valid_ratiosrc_errorsrc_strerrorSRC_SINC_BEST_QUALITYSRC_SINC_MEDIUM_QUALITYSRC_SINC_FASTESTSRC_ZERO_ORDER_HOLDSRC_LINEARsrc_short_to_float_arraysrc_float_to_short_arraysrc_int_to_float_arraysrc_float_to_int_array/* automatically generated by rust-bindgen 0.55.1 */all_assertssimple_sample_rate_conversioncomplex_sample_rate_conversionfind_libsodium_env/* Must be called when SODIUM_LIB_DIR is set to any value
This function will set `cargo` flags.
*/find_libsodium_pkg/* Must be called when no SODIUM_USE_PKG_CONFIG env var is set
This function will set `cargo` flags.
*//* Must be called when SODIUM_USE_PKG_CONFIG env var is set
This function will set `cargo` flags.
*/make_libsodiumget_crate_diris_release_profileget_lib_dirbuild_libsodiumsodium_bindings// we can't control bindgen output to make clippy happySODIUM_VERSION_STRING7usizeSODIUM_LIBRARY_VERSION_MAJORSODIUM_LIBRARY_VERSION_MINORcrypto_aead_aes256gcm_KEYBYTEScrypto_aead_aes256gcm_NSECBYTEScrypto_aead_aes256gcm_NPUBBYTEScrypto_aead_aes256gcm_ABYTEScrypto_aead_chacha20poly1305_ietf_KEYBYTEScrypto_aead_chacha20poly1305_ietf_NSECBYTEScrypto_aead_chacha20poly1305_ietf_NPUBBYTEScrypto_aead_chacha20poly1305_ietf_ABYTEScrypto_aead_chacha20poly1305_KEYBYTEScrypto_aead_chacha20poly1305_NSECBYTEScrypto_aead_chacha20poly1305_NPUBBYTEScrypto_aead_chacha20poly1305_ABYTEScrypto_aead_chacha20poly1305_IETF_KEYBYTEScrypto_aead_chacha20poly1305_IETF_NSECBYTEScrypto_aead_chacha20poly1305_IETF_NPUBBYTEScrypto_aead_chacha20poly1305_IETF_ABYTEScrypto_aead_xchacha20poly1305_ietf_KEYBYTEScrypto_aead_xchacha20poly1305_ietf_NSECBYTEScrypto_aead_xchacha20poly1305_ietf_NPUBBYTEScrypto_aead_xchacha20poly1305_ietf_ABYTEScrypto_aead_xchacha20poly1305_IETF_KEYBYTEScrypto_aead_xchacha20poly1305_IETF_NSECBYTEScrypto_aead_xchacha20poly1305_IETF_NPUBBYTEScrypto_aead_xchacha20poly1305_IETF_ABYTEScrypto_hash_sha512_BYTEScrypto_auth_hmacsha512_BYTEScrypto_auth_hmacsha512_KEYBYTEScrypto_auth_hmacsha512256_BYTEScrypto_auth_hmacsha512256_KEYBYTEScrypto_auth_BYTEScrypto_auth_KEYBYTEScrypto_auth_PRIMITIVEcrypto_hash_sha256_BYTEScrypto_auth_hmacsha256_BYTEScrypto_auth_hmacsha256_KEYBYTEScrypto_stream_xsalsa20_KEYBYTEScrypto_stream_xsalsa20_NONCEBYTEScrypto_box_curve25519xsalsa20poly1305_SEEDBYTEScrypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTEScrypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTEScrypto_box_curve25519xsalsa20poly1305_BEFORENMBYTEScrypto_box_curve25519xsalsa20poly1305_NONCEBYTEScrypto_box_curve25519xsalsa20poly1305_MACBYTEScrypto_box_curve25519xsalsa20poly1305_BOXZEROBYTEScrypto_box_curve25519xsalsa20poly1305_ZEROBYTEScrypto_box_SEEDBYTEScrypto_box_PUBLICKEYBYTEScrypto_box_SECRETKEYBYTEScrypto_box_NONCEBYTEScrypto_box_MACBYTEScrypto_box_PRIMITIVE27usizecrypto_box_BEFORENMBYTEScrypto_box_SEALBYTEScrypto_box_ZEROBYTEScrypto_box_BOXZEROBYTEScrypto_core_hsalsa20_OUTPUTBYTEScrypto_core_hsalsa20_INPUTBYTEScrypto_core_hsalsa20_KEYBYTEScrypto_core_hsalsa20_CONSTBYTEScrypto_core_hchacha20_OUTPUTBYTEScrypto_core_hchacha20_INPUTBYTEScrypto_core_hchacha20_KEYBYTEScrypto_core_hchacha20_CONSTBYTEScrypto_core_salsa20_OUTPUTBYTEScrypto_core_salsa20_INPUTBYTEScrypto_core_salsa20_KEYBYTEScrypto_core_salsa20_CONSTBYTEScrypto_core_salsa2012_OUTPUTBYTEScrypto_core_salsa2012_INPUTBYTEScrypto_core_salsa2012_KEYBYTEScrypto_core_salsa2012_CONSTBYTEScrypto_core_salsa208_OUTPUTBYTEScrypto_core_salsa208_INPUTBYTEScrypto_core_salsa208_KEYBYTEScrypto_core_salsa208_CONSTBYTEScrypto_generichash_blake2b_BYTES_MINcrypto_generichash_blake2b_BYTES_MAXcrypto_generichash_blake2b_BYTEScrypto_generichash_blake2b_KEYBYTES_MINcrypto_generichash_blake2b_KEYBYTES_MAXcrypto_generichash_blake2b_KEYBYTEScrypto_generichash_blake2b_SALTBYTEScrypto_generichash_blake2b_PERSONALBYTEScrypto_generichash_BYTES_MINcrypto_generichash_BYTES_MAXcrypto_generichash_BYTEScrypto_generichash_KEYBYTES_MINcrypto_generichash_KEYBYTES_MAXcrypto_generichash_KEYBYTEScrypto_generichash_PRIMITIVE8usizecrypto_hash_BYTEScrypto_hash_PRIMITIVEcrypto_kdf_blake2b_BYTES_MINcrypto_kdf_blake2b_BYTES_MAXcrypto_kdf_blake2b_CONTEXTBYTEScrypto_kdf_blake2b_KEYBYTEScrypto_kdf_BYTES_MINcrypto_kdf_BYTES_MAXcrypto_kdf_CONTEXTBYTEScrypto_kdf_KEYBYTEScrypto_kdf_PRIMITIVEcrypto_kx_PUBLICKEYBYTEScrypto_kx_SECRETKEYBYTEScrypto_kx_SEEDBYTEScrypto_kx_SESSIONKEYBYTEScrypto_kx_PRIMITIVEcrypto_onetimeauth_poly1305_BYTEScrypto_onetimeauth_poly1305_KEYBYTEScrypto_onetimeauth_BYTEScrypto_onetimeauth_KEYBYTEScrypto_onetimeauth_PRIMITIVEcrypto_pwhash_argon2i_ALG_ARGON2I13crypto_pwhash_argon2i_BYTES_MINcrypto_pwhash_argon2i_PASSWD_MINcrypto_pwhash_argon2i_PASSWD_MAXcrypto_pwhash_argon2i_SALTBYTEScrypto_pwhash_argon2i_STRBYTEScrypto_pwhash_argon2i_STRPREFIX10usizecrypto_pwhash_argon2i_OPSLIMIT_MINcrypto_pwhash_argon2i_OPSLIMIT_MAXcrypto_pwhash_argon2i_MEMLIMIT_MINcrypto_pwhash_argon2i_OPSLIMIT_INTERACTIVEcrypto_pwhash_argon2i_MEMLIMIT_INTERACTIVEcrypto_pwhash_argon2i_OPSLIMIT_MODERATEcrypto_pwhash_argon2i_MEMLIMIT_MODERATEcrypto_pwhash_argon2i_OPSLIMIT_SENSITIVEcrypto_pwhash_argon2i_MEMLIMIT_SENSITIVEcrypto_pwhash_argon2id_ALG_ARGON2ID13crypto_pwhash_argon2id_BYTES_MINcrypto_pwhash_argon2id_PASSWD_MINcrypto_pwhash_argon2id_PASSWD_MAXcrypto_pwhash_argon2id_SALTBYTEScrypto_pwhash_argon2id_STRBYTEScrypto_pwhash_argon2id_STRPREFIXcrypto_pwhash_argon2id_OPSLIMIT_MINcrypto_pwhash_argon2id_OPSLIMIT_MAXcrypto_pwhash_argon2id_MEMLIMIT_MINcrypto_pwhash_argon2id_OPSLIMIT_INTERACTIVEcrypto_pwhash_argon2id_MEMLIMIT_INTERACTIVEcrypto_pwhash_argon2id_OPSLIMIT_MODERATEcrypto_pwhash_argon2id_MEMLIMIT_MODERATEcrypto_pwhash_argon2id_OPSLIMIT_SENSITIVEcrypto_pwhash_argon2id_MEMLIMIT_SENSITIVEcrypto_pwhash_ALG_ARGON2I13crypto_pwhash_ALG_ARGON2ID13crypto_pwhash_ALG_DEFAULTcrypto_pwhash_BYTES_MINcrypto_pwhash_PASSWD_MINcrypto_pwhash_PASSWD_MAXcrypto_pwhash_SALTBYTEScrypto_pwhash_STRBYTEScrypto_pwhash_STRPREFIXcrypto_pwhash_OPSLIMIT_MINcrypto_pwhash_OPSLIMIT_MAXcrypto_pwhash_MEMLIMIT_MINcrypto_pwhash_OPSLIMIT_INTERACTIVEcrypto_pwhash_MEMLIMIT_INTERACTIVEcrypto_pwhash_OPSLIMIT_MODERATEcrypto_pwhash_MEMLIMIT_MODERATEcrypto_pwhash_OPSLIMIT_SENSITIVEcrypto_pwhash_MEMLIMIT_SENSITIVEcrypto_pwhash_PRIMITIVEcrypto_scalarmult_curve25519_BYTEScrypto_scalarmult_curve25519_SCALARBYTEScrypto_scalarmult_BYTEScrypto_scalarmult_SCALARBYTEScrypto_scalarmult_PRIMITIVEcrypto_secretbox_xsalsa20poly1305_KEYBYTEScrypto_secretbox_xsalsa20poly1305_NONCEBYTEScrypto_secretbox_xsalsa20poly1305_MACBYTEScrypto_secretbox_xsalsa20poly1305_BOXZEROBYTEScrypto_secretbox_xsalsa20poly1305_ZEROBYTEScrypto_secretbox_KEYBYTEScrypto_secretbox_NONCEBYTEScrypto_secretbox_MACBYTEScrypto_secretbox_PRIMITIVEcrypto_secretbox_ZEROBYTEScrypto_secretbox_BOXZEROBYTEScrypto_stream_chacha20_KEYBYTEScrypto_stream_chacha20_NONCEBYTEScrypto_stream_chacha20_ietf_KEYBYTEScrypto_stream_chacha20_ietf_NONCEBYTEScrypto_stream_chacha20_IETF_KEYBYTEScrypto_stream_chacha20_IETF_NONCEBYTEScrypto_secretstream_xchacha20poly1305_ABYTEScrypto_secretstream_xchacha20poly1305_HEADERBYTEScrypto_secretstream_xchacha20poly1305_KEYBYTEScrypto_secretstream_xchacha20poly1305_TAG_MESSAGEcrypto_secretstream_xchacha20poly1305_TAG_PUSHcrypto_secretstream_xchacha20poly1305_TAG_REKEYcrypto_secretstream_xchacha20poly1305_TAG_FINALcrypto_shorthash_siphash24_BYTEScrypto_shorthash_siphash24_KEYBYTEScrypto_shorthash_siphashx24_BYTEScrypto_shorthash_siphashx24_KEYBYTEScrypto_shorthash_BYTEScrypto_shorthash_KEYBYTEScrypto_shorthash_PRIMITIVEcrypto_sign_ed25519_BYTEScrypto_sign_ed25519_SEEDBYTEScrypto_sign_ed25519_PUBLICKEYBYTEScrypto_sign_ed25519_SECRETKEYBYTEScrypto_sign_BYTEScrypto_sign_SEEDBYTEScrypto_sign_PUBLICKEYBYTEScrypto_sign_SECRETKEYBYTEScrypto_sign_PRIMITIVEcrypto_stream_KEYBYTEScrypto_stream_NONCEBYTEScrypto_stream_PRIMITIVEcrypto_stream_salsa20_KEYBYTEScrypto_stream_salsa20_NONCEBYTEScrypto_verify_16_BYTEScrypto_verify_32_BYTEScrypto_verify_64_BYTESrandombytes_SEEDBYTESsodium_base64_VARIANT_ORIGINALsodium_base64_VARIANT_ORIGINAL_NO_PADDINGsodium_base64_VARIANT_URLSAFEsodium_base64_VARIANT_URLSAFE_NO_PADDINGcrypto_stream_xchacha20_KEYBYTEScrypto_stream_xchacha20_NONCEBYTEScrypto_box_curve25519xchacha20poly1305_SEEDBYTEScrypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTEScrypto_box_curve25519xchacha20poly1305_SECRETKEYBYTEScrypto_box_curve25519xchacha20poly1305_BEFORENMBYTEScrypto_box_curve25519xchacha20poly1305_NONCEBYTEScrypto_box_curve25519xchacha20poly1305_MACBYTEScrypto_box_curve25519xchacha20poly1305_SEALBYTEScrypto_core_ed25519_BYTEScrypto_core_ed25519_UNIFORMBYTEScrypto_core_ed25519_HASHBYTEScrypto_core_ed25519_SCALARBYTEScrypto_core_ed25519_NONREDUCEDSCALARBYTEScrypto_core_ristretto255_BYTEScrypto_core_ristretto255_HASHBYTEScrypto_core_ristretto255_SCALARBYTEScrypto_core_ristretto255_NONREDUCEDSCALARBYTEScrypto_scalarmult_ed25519_BYTEScrypto_scalarmult_ed25519_SCALARBYTEScrypto_scalarmult_ristretto255_BYTEScrypto_scalarmult_ristretto255_SCALARBYTEScrypto_secretbox_xchacha20poly1305_KEYBYTEScrypto_secretbox_xchacha20poly1305_NONCEBYTEScrypto_secretbox_xchacha20poly1305_MACBYTEScrypto_pwhash_scryptsalsa208sha256_BYTES_MINcrypto_pwhash_scryptsalsa208sha256_PASSWD_MINcrypto_pwhash_scryptsalsa208sha256_SALTBYTEScrypto_pwhash_scryptsalsa208sha256_STRBYTEScrypto_pwhash_scryptsalsa208sha256_STRPREFIXcrypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MINcrypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAXcrypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MINcrypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVEcrypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVEcrypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVEcrypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVEcrypto_stream_salsa2012_KEYBYTEScrypto_stream_salsa2012_NONCEBYTEScrypto_stream_salsa208_KEYBYTEScrypto_stream_salsa208_NONCEBYTESsodium_version_stringsodium_library_version_majorsodium_library_version_minorsodium_library_minimalsodium_initsodium_set_misuse_handlersodium_misusecrypto_aead_aes256gcm_is_availablecrypto_aead_aes256gcm_keybytescrypto_aead_aes256gcm_nsecbytescrypto_aead_aes256gcm_npubbytescrypto_aead_aes256gcm_abytescrypto_aead_aes256gcm_messagebytes_max512usizecrypto_aead_aes256gcm_state_crypto_aead_aes256gcm_statecrypto_aead_aes256gcm_statebytescrypto_aead_aes256gcm_encryptcrypto_aead_aes256gcm_decryptcrypto_aead_aes256gcm_encrypt_detachedcrypto_aead_aes256gcm_decrypt_detachedcrypto_aead_aes256gcm_beforenmcrypto_aead_aes256gcm_encrypt_afternmcrypto_aead_aes256gcm_decrypt_afternmcrypto_aead_aes256gcm_encrypt_detached_afternmcrypto_aead_aes256gcm_decrypt_detached_afternmcrypto_aead_aes256gcm_keygencrypto_aead_chacha20poly1305_ietf_keybytescrypto_aead_chacha20poly1305_ietf_nsecbytescrypto_aead_chacha20poly1305_ietf_npubbytescrypto_aead_chacha20poly1305_ietf_abytescrypto_aead_chacha20poly1305_ietf_messagebytes_maxcrypto_aead_chacha20poly1305_ietf_encryptcrypto_aead_chacha20poly1305_ietf_decryptcrypto_aead_chacha20poly1305_ietf_encrypt_detachedcrypto_aead_chacha20poly1305_ietf_decrypt_detachedcrypto_aead_chacha20poly1305_ietf_keygencrypto_aead_chacha20poly1305_keybytescrypto_aead_chacha20poly1305_nsecbytescrypto_aead_chacha20poly1305_npubbytescrypto_aead_chacha20poly1305_abytescrypto_aead_chacha20poly1305_messagebytes_maxcrypto_aead_chacha20poly1305_encryptcrypto_aead_chacha20poly1305_decryptcrypto_aead_chacha20poly1305_encrypt_detachedcrypto_aead_chacha20poly1305_decrypt_detachedcrypto_aead_chacha20poly1305_keygencrypto_aead_xchacha20poly1305_ietf_keybytescrypto_aead_xchacha20poly1305_ietf_nsecbytescrypto_aead_xchacha20poly1305_ietf_npubbytescrypto_aead_xchacha20poly1305_ietf_abytescrypto_aead_xchacha20poly1305_ietf_messagebytes_maxcrypto_aead_xchacha20poly1305_ietf_encryptcrypto_aead_xchacha20poly1305_ietf_decryptcrypto_aead_xchacha20poly1305_ietf_encrypt_detachedcrypto_aead_xchacha20poly1305_ietf_decrypt_detachedcrypto_aead_xchacha20poly1305_ietf_keygen128usizecrypto_hash_sha512_statecrypto_hash_sha512_statebytescrypto_hash_sha512_bytescrypto_hash_sha512crypto_hash_sha512_initcrypto_hash_sha512_updatecrypto_hash_sha512_finalcrypto_auth_hmacsha512_bytescrypto_auth_hmacsha512_keybytescrypto_auth_hmacsha512crypto_auth_hmacsha512_verifyictxoctxcrypto_auth_hmacsha512_statecrypto_auth_hmacsha512_statebytescrypto_auth_hmacsha512_initcrypto_auth_hmacsha512_updatecrypto_auth_hmacsha512_finalcrypto_auth_hmacsha512_keygencrypto_auth_hmacsha512256_bytescrypto_auth_hmacsha512256_keybytescrypto_auth_hmacsha512256crypto_auth_hmacsha512256_verifycrypto_auth_hmacsha512256_statecrypto_auth_hmacsha512256_statebytescrypto_auth_hmacsha512256_initcrypto_auth_hmacsha512256_updatecrypto_auth_hmacsha512256_finalcrypto_auth_hmacsha512256_keygencrypto_auth_bytescrypto_auth_keybytescrypto_auth_primitivecrypto_authcrypto_auth_verifycrypto_auth_keygen64usizecrypto_hash_sha256_statecrypto_hash_sha256_statebytescrypto_hash_sha256_bytescrypto_hash_sha256crypto_hash_sha256_initcrypto_hash_sha256_updatecrypto_hash_sha256_finalcrypto_auth_hmacsha256_bytescrypto_auth_hmacsha256_keybytescrypto_auth_hmacsha256crypto_auth_hmacsha256_verifycrypto_auth_hmacsha256_statecrypto_auth_hmacsha256_statebytescrypto_auth_hmacsha256_initcrypto_auth_hmacsha256_updatecrypto_auth_hmacsha256_finalcrypto_auth_hmacsha256_keygencrypto_stream_xsalsa20_keybytescrypto_stream_xsalsa20_noncebytescrypto_stream_xsalsa20_messagebytes_maxcrypto_stream_xsalsa20crypto_stream_xsalsa20_xorcrypto_stream_xsalsa20_xor_iccrypto_stream_xsalsa20_keygencrypto_box_curve25519xsalsa20poly1305_seedbytescrypto_box_curve25519xsalsa20poly1305_publickeybytescrypto_box_curve25519xsalsa20poly1305_secretkeybytescrypto_box_curve25519xsalsa20poly1305_beforenmbytescrypto_box_curve25519xsalsa20poly1305_noncebytescrypto_box_curve25519xsalsa20poly1305_macbytescrypto_box_curve25519xsalsa20poly1305_messagebytes_maxcrypto_box_curve25519xsalsa20poly1305_seed_keypaircrypto_box_curve25519xsalsa20poly1305_keypaircrypto_box_curve25519xsalsa20poly1305_beforenmcrypto_box_curve25519xsalsa20poly1305_boxzerobytescrypto_box_curve25519xsalsa20poly1305_zerobytescrypto_box_curve25519xsalsa20poly1305crypto_box_curve25519xsalsa20poly1305_opencrypto_box_curve25519xsalsa20poly1305_afternmcrypto_box_curve25519xsalsa20poly1305_open_afternmcrypto_box_seedbytescrypto_box_publickeybytescrypto_box_secretkeybytescrypto_box_noncebytescrypto_box_macbytescrypto_box_messagebytes_maxcrypto_box_primitivecrypto_box_seed_keypaircrypto_box_keypaircrypto_box_easycrypto_box_open_easycrypto_box_detachedcrypto_box_open_detachedcrypto_box_beforenmbytescrypto_box_beforenmcrypto_box_easy_afternmcrypto_box_open_easy_afternmcrypto_box_detached_afternmcrypto_box_open_detached_afternmcrypto_box_sealbytescrypto_box_sealcrypto_box_seal_opencrypto_box_zerobytescrypto_box_boxzerobytescrypto_boxcrypto_box_opencrypto_box_afternmcrypto_box_open_afternmcrypto_core_hsalsa20_outputbytescrypto_core_hsalsa20_inputbytescrypto_core_hsalsa20_keybytescrypto_core_hsalsa20_constbytescrypto_core_hsalsa20crypto_core_hchacha20_outputbytescrypto_core_hchacha20_inputbytescrypto_core_hchacha20_keybytescrypto_core_hchacha20_constbytescrypto_core_hchacha20crypto_core_salsa20_outputbytescrypto_core_salsa20_inputbytescrypto_core_salsa20_keybytescrypto_core_salsa20_constbytescrypto_core_salsa20crypto_core_salsa2012_outputbytescrypto_core_salsa2012_inputbytescrypto_core_salsa2012_keybytescrypto_core_salsa2012_constbytescrypto_core_salsa2012crypto_core_salsa208_outputbytescrypto_core_salsa208_inputbytescrypto_core_salsa208_keybytescrypto_core_salsa208_constbytescrypto_core_salsa208384usizecrypto_generichash_blake2b_statecrypto_generichash_blake2b_bytes_mincrypto_generichash_blake2b_bytes_maxcrypto_generichash_blake2b_bytescrypto_generichash_blake2b_keybytes_mincrypto_generichash_blake2b_keybytes_maxcrypto_generichash_blake2b_keybytescrypto_generichash_blake2b_saltbytescrypto_generichash_blake2b_personalbytescrypto_generichash_blake2b_statebytescrypto_generichash_blake2bcrypto_generichash_blake2b_salt_personalcrypto_generichash_blake2b_initcrypto_generichash_blake2b_init_salt_personalcrypto_generichash_blake2b_updatecrypto_generichash_blake2b_finalcrypto_generichash_blake2b_keygencrypto_generichash_bytes_mincrypto_generichash_bytes_maxcrypto_generichash_bytescrypto_generichash_keybytes_mincrypto_generichash_keybytes_maxcrypto_generichash_keybytescrypto_generichash_primitivecrypto_generichash_statecrypto_generichash_statebytescrypto_generichashcrypto_generichash_initcrypto_generichash_updatecrypto_generichash_finalcrypto_generichash_keygencrypto_hash_bytescrypto_hashcrypto_hash_primitivecrypto_kdf_blake2b_bytes_mincrypto_kdf_blake2b_bytes_maxcrypto_kdf_blake2b_contextbytescrypto_kdf_blake2b_keybytescrypto_kdf_blake2b_derive_from_keycrypto_kdf_bytes_mincrypto_kdf_bytes_maxcrypto_kdf_contextbytescrypto_kdf_keybytescrypto_kdf_primitivecrypto_kdf_derive_from_keycrypto_kdf_keygencrypto_kx_publickeybytescrypto_kx_secretkeybytescrypto_kx_seedbytescrypto_kx_sessionkeybytescrypto_kx_primitivecrypto_kx_seed_keypaircrypto_kx_keypaircrypto_kx_client_session_keyscrypto_kx_server_session_keys256usizecrypto_onetimeauth_poly1305_statecrypto_onetimeauth_poly1305_statebytescrypto_onetimeauth_poly1305_bytescrypto_onetimeauth_poly1305_keybytescrypto_onetimeauth_poly1305crypto_onetimeauth_poly1305_verifycrypto_onetimeauth_poly1305_initcrypto_onetimeauth_poly1305_updatecrypto_onetimeauth_poly1305_finalcrypto_onetimeauth_poly1305_keygencrypto_onetimeauth_statecrypto_onetimeauth_statebytescrypto_onetimeauth_bytescrypto_onetimeauth_keybytescrypto_onetimeauth_primitivecrypto_onetimeauthcrypto_onetimeauth_verifycrypto_onetimeauth_initcrypto_onetimeauth_updatecrypto_onetimeauth_finalcrypto_onetimeauth_keygencrypto_pwhash_argon2i_alg_argon2i13crypto_pwhash_argon2i_bytes_mincrypto_pwhash_argon2i_bytes_maxcrypto_pwhash_argon2i_passwd_mincrypto_pwhash_argon2i_passwd_maxcrypto_pwhash_argon2i_saltbytescrypto_pwhash_argon2i_strbytescrypto_pwhash_argon2i_strprefixcrypto_pwhash_argon2i_opslimit_mincrypto_pwhash_argon2i_opslimit_maxcrypto_pwhash_argon2i_memlimit_mincrypto_pwhash_argon2i_memlimit_maxcrypto_pwhash_argon2i_opslimit_interactivecrypto_pwhash_argon2i_memlimit_interactivecrypto_pwhash_argon2i_opslimit_moderatecrypto_pwhash_argon2i_memlimit_moderatecrypto_pwhash_argon2i_opslimit_sensitivecrypto_pwhash_argon2i_memlimit_sensitivecrypto_pwhash_argon2icrypto_pwhash_argon2i_strcrypto_pwhash_argon2i_str_verifycrypto_pwhash_argon2i_str_needs_rehashcrypto_pwhash_argon2id_alg_argon2id13crypto_pwhash_argon2id_bytes_mincrypto_pwhash_argon2id_bytes_maxcrypto_pwhash_argon2id_passwd_mincrypto_pwhash_argon2id_passwd_maxcrypto_pwhash_argon2id_saltbytescrypto_pwhash_argon2id_strbytescrypto_pwhash_argon2id_strprefixcrypto_pwhash_argon2id_opslimit_mincrypto_pwhash_argon2id_opslimit_maxcrypto_pwhash_argon2id_memlimit_mincrypto_pwhash_argon2id_memlimit_maxcrypto_pwhash_argon2id_opslimit_interactivecrypto_pwhash_argon2id_memlimit_interactivecrypto_pwhash_argon2id_opslimit_moderatecrypto_pwhash_argon2id_memlimit_moderatecrypto_pwhash_argon2id_opslimit_sensitivecrypto_pwhash_argon2id_memlimit_sensitivecrypto_pwhash_argon2idcrypto_pwhash_argon2id_strcrypto_pwhash_argon2id_str_verifycrypto_pwhash_argon2id_str_needs_rehashcrypto_pwhash_alg_argon2i13crypto_pwhash_alg_argon2id13crypto_pwhash_alg_defaultcrypto_pwhash_bytes_mincrypto_pwhash_bytes_maxcrypto_pwhash_passwd_mincrypto_pwhash_passwd_maxcrypto_pwhash_saltbytescrypto_pwhash_strbytescrypto_pwhash_strprefixcrypto_pwhash_opslimit_mincrypto_pwhash_opslimit_maxcrypto_pwhash_memlimit_mincrypto_pwhash_memlimit_maxcrypto_pwhash_opslimit_interactivecrypto_pwhash_memlimit_interactivecrypto_pwhash_opslimit_moderatecrypto_pwhash_memlimit_moderatecrypto_pwhash_opslimit_sensitivecrypto_pwhash_memlimit_sensitivecrypto_pwhashcrypto_pwhash_strcrypto_pwhash_str_algcrypto_pwhash_str_verifycrypto_pwhash_str_needs_rehashcrypto_pwhash_primitivecrypto_scalarmult_curve25519_bytescrypto_scalarmult_curve25519_scalarbytescrypto_scalarmult_curve25519crypto_scalarmult_curve25519_basecrypto_scalarmult_bytescrypto_scalarmult_scalarbytescrypto_scalarmult_primitivecrypto_scalarmult_basecrypto_scalarmultcrypto_secretbox_xsalsa20poly1305_keybytescrypto_secretbox_xsalsa20poly1305_noncebytescrypto_secretbox_xsalsa20poly1305_macbytescrypto_secretbox_xsalsa20poly1305_messagebytes_maxcrypto_secretbox_xsalsa20poly1305crypto_secretbox_xsalsa20poly1305_opencrypto_secretbox_xsalsa20poly1305_keygencrypto_secretbox_xsalsa20poly1305_boxzerobytescrypto_secretbox_xsalsa20poly1305_zerobytescrypto_secretbox_keybytescrypto_secretbox_noncebytescrypto_secretbox_macbytescrypto_secretbox_primitivecrypto_secretbox_messagebytes_maxcrypto_secretbox_easycrypto_secretbox_open_easycrypto_secretbox_detachedcrypto_secretbox_open_detachedcrypto_secretbox_keygencrypto_secretbox_zerobytescrypto_secretbox_boxzerobytescrypto_secretboxcrypto_secretbox_opencrypto_stream_chacha20_keybytescrypto_stream_chacha20_noncebytescrypto_stream_chacha20_messagebytes_maxcrypto_stream_chacha20crypto_stream_chacha20_xorcrypto_stream_chacha20_xor_iccrypto_stream_chacha20_keygencrypto_stream_chacha20_ietf_keybytescrypto_stream_chacha20_ietf_noncebytescrypto_stream_chacha20_ietf_messagebytes_maxcrypto_stream_chacha20_ietfcrypto_stream_chacha20_ietf_xorcrypto_stream_chacha20_ietf_xor_iccrypto_stream_chacha20_ietf_keygencrypto_secretstream_xchacha20poly1305_abytescrypto_secretstream_xchacha20poly1305_headerbytescrypto_secretstream_xchacha20poly1305_keybytescrypto_secretstream_xchacha20poly1305_messagebytes_maxcrypto_secretstream_xchacha20poly1305_tag_messagecrypto_secretstream_xchacha20poly1305_tag_pushcrypto_secretstream_xchacha20poly1305_tag_rekeycrypto_secretstream_xchacha20poly1305_tag_finalcrypto_secretstream_xchacha20poly1305_statecrypto_secretstream_xchacha20poly1305_statebytescrypto_secretstream_xchacha20poly1305_keygencrypto_secretstream_xchacha20poly1305_init_pushcrypto_secretstream_xchacha20poly1305_pushcrypto_secretstream_xchacha20poly1305_init_pullcrypto_secretstream_xchacha20poly1305_pullcrypto_secretstream_xchacha20poly1305_rekeycrypto_shorthash_siphash24_bytescrypto_shorthash_siphash24_keybytescrypto_shorthash_siphash24crypto_shorthash_siphashx24_bytescrypto_shorthash_siphashx24_keybytescrypto_shorthash_siphashx24crypto_shorthash_bytescrypto_shorthash_keybytescrypto_shorthash_primitivecrypto_shorthashcrypto_shorthash_keygencrypto_sign_ed25519ph_statecrypto_sign_ed25519ph_statebytescrypto_sign_ed25519_bytescrypto_sign_ed25519_seedbytescrypto_sign_ed25519_publickeybytescrypto_sign_ed25519_secretkeybytescrypto_sign_ed25519_messagebytes_maxcrypto_sign_ed25519crypto_sign_ed25519_opencrypto_sign_ed25519_detachedcrypto_sign_ed25519_verify_detachedcrypto_sign_ed25519_keypaircrypto_sign_ed25519_seed_keypaircrypto_sign_ed25519_pk_to_curve25519crypto_sign_ed25519_sk_to_curve25519crypto_sign_ed25519_sk_to_seedcrypto_sign_ed25519_sk_to_pkcrypto_sign_ed25519ph_initcrypto_sign_ed25519ph_updatecrypto_sign_ed25519ph_final_createcrypto_sign_ed25519ph_final_verifycrypto_sign_statecrypto_sign_statebytescrypto_sign_bytescrypto_sign_seedbytescrypto_sign_publickeybytescrypto_sign_secretkeybytescrypto_sign_messagebytes_maxcrypto_sign_primitivecrypto_sign_seed_keypaircrypto_sign_keypaircrypto_signcrypto_sign_opencrypto_sign_detachedcrypto_sign_verify_detachedcrypto_sign_initcrypto_sign_updatecrypto_sign_final_createcrypto_sign_final_verifycrypto_stream_keybytescrypto_stream_noncebytescrypto_stream_messagebytes_maxcrypto_stream_primitivecrypto_streamcrypto_stream_xorcrypto_stream_keygencrypto_stream_salsa20_keybytescrypto_stream_salsa20_noncebytescrypto_stream_salsa20_messagebytes_maxcrypto_stream_salsa20crypto_stream_salsa20_xorcrypto_stream_salsa20_xor_iccrypto_stream_salsa20_keygencrypto_verify_16_bytescrypto_verify_16crypto_verify_32_bytescrypto_verify_32crypto_verify_64_bytescrypto_verify_64implementation_namestirrandombytes_implementationrandombytes_seedbytesrandombytes_bufrandombytes_buf_deterministicrandombytes_randomrandombytes_uniformrandombytes_stirrandombytes_closerandombytes_set_implementationrandombytes_implementation_namerandombytes_internal_implementationrandombytes_sysrandom_implementationsodium_runtime_has_neonsodium_runtime_has_sse2sodium_runtime_has_sse3sodium_runtime_has_ssse3sodium_runtime_has_sse41sodium_runtime_has_avxsodium_runtime_has_avx2sodium_runtime_has_avx512fsodium_runtime_has_pclmulsodium_runtime_has_aesnisodium_runtime_has_rdrandsodium_memzerosodium_stackzerosodium_memcmpsodium_comparesodium_is_zerosodium_incrementsodium_addsodium_subsodium_bin2hexsodium_hex2binsodium_base64_encoded_lensodium_bin2base64sodium_base642binsodium_mlocksodium_munlocksodium_mallocsodium_allocarraysodium_freesodium_mprotect_noaccesssodium_mprotect_readonlysodium_mprotect_readwritesodium_padsodium_unpadcrypto_stream_xchacha20_keybytescrypto_stream_xchacha20_noncebytescrypto_stream_xchacha20_messagebytes_maxcrypto_stream_xchacha20crypto_stream_xchacha20_xorcrypto_stream_xchacha20_xor_iccrypto_stream_xchacha20_keygencrypto_box_curve25519xchacha20poly1305_seedbytescrypto_box_curve25519xchacha20poly1305_publickeybytescrypto_box_curve25519xchacha20poly1305_secretkeybytescrypto_box_curve25519xchacha20poly1305_beforenmbytescrypto_box_curve25519xchacha20poly1305_noncebytescrypto_box_curve25519xchacha20poly1305_macbytescrypto_box_curve25519xchacha20poly1305_messagebytes_maxcrypto_box_curve25519xchacha20poly1305_seed_keypaircrypto_box_curve25519xchacha20poly1305_keypaircrypto_box_curve25519xchacha20poly1305_easycrypto_box_curve25519xchacha20poly1305_open_easycrypto_box_curve25519xchacha20poly1305_detachedcrypto_box_curve25519xchacha20poly1305_open_detachedcrypto_box_curve25519xchacha20poly1305_beforenmcrypto_box_curve25519xchacha20poly1305_easy_afternmcrypto_box_curve25519xchacha20poly1305_open_easy_afternmcrypto_box_curve25519xchacha20poly1305_detached_afternmcrypto_box_curve25519xchacha20poly1305_open_detached_afternmcrypto_box_curve25519xchacha20poly1305_sealbytescrypto_box_curve25519xchacha20poly1305_sealcrypto_box_curve25519xchacha20poly1305_seal_opencrypto_core_ed25519_bytescrypto_core_ed25519_uniformbytescrypto_core_ed25519_hashbytescrypto_core_ed25519_scalarbytescrypto_core_ed25519_nonreducedscalarbytescrypto_core_ed25519_is_valid_pointcrypto_core_ed25519_addcrypto_core_ed25519_subcrypto_core_ed25519_from_uniformcrypto_core_ed25519_from_hashcrypto_core_ed25519_randomcrypto_core_ed25519_scalar_randomcrypto_core_ed25519_scalar_invertcrypto_core_ed25519_scalar_negatecrypto_core_ed25519_scalar_complementcrypto_core_ed25519_scalar_addcrypto_core_ed25519_scalar_subcrypto_core_ed25519_scalar_mulcrypto_core_ed25519_scalar_reducecrypto_core_ristretto255_bytescrypto_core_ristretto255_hashbytescrypto_core_ristretto255_scalarbytescrypto_core_ristretto255_nonreducedscalarbytescrypto_core_ristretto255_is_valid_pointcrypto_core_ristretto255_addcrypto_core_ristretto255_subcrypto_core_ristretto255_from_hashcrypto_core_ristretto255_randomcrypto_core_ristretto255_scalar_randomcrypto_core_ristretto255_scalar_invertcrypto_core_ristretto255_scalar_negatecrypto_core_ristretto255_scalar_complementcrypto_core_ristretto255_scalar_addcrypto_core_ristretto255_scalar_subcrypto_core_ristretto255_scalar_mulcrypto_core_ristretto255_scalar_reducecrypto_scalarmult_ed25519_bytescrypto_scalarmult_ed25519_scalarbytescrypto_scalarmult_ed25519crypto_scalarmult_ed25519_noclampcrypto_scalarmult_ed25519_basecrypto_scalarmult_ed25519_base_noclampcrypto_scalarmult_ristretto255_bytescrypto_scalarmult_ristretto255_scalarbytescrypto_scalarmult_ristretto255crypto_scalarmult_ristretto255_basecrypto_secretbox_xchacha20poly1305_keybytescrypto_secretbox_xchacha20poly1305_noncebytescrypto_secretbox_xchacha20poly1305_macbytescrypto_secretbox_xchacha20poly1305_messagebytes_maxcrypto_secretbox_xchacha20poly1305_easycrypto_secretbox_xchacha20poly1305_open_easycrypto_secretbox_xchacha20poly1305_detachedcrypto_secretbox_xchacha20poly1305_open_detachedcrypto_pwhash_scryptsalsa208sha256_bytes_mincrypto_pwhash_scryptsalsa208sha256_bytes_maxcrypto_pwhash_scryptsalsa208sha256_passwd_mincrypto_pwhash_scryptsalsa208sha256_passwd_maxcrypto_pwhash_scryptsalsa208sha256_saltbytescrypto_pwhash_scryptsalsa208sha256_strbytescrypto_pwhash_scryptsalsa208sha256_strprefixcrypto_pwhash_scryptsalsa208sha256_opslimit_mincrypto_pwhash_scryptsalsa208sha256_opslimit_maxcrypto_pwhash_scryptsalsa208sha256_memlimit_mincrypto_pwhash_scryptsalsa208sha256_memlimit_maxcrypto_pwhash_scryptsalsa208sha256_opslimit_interactivecrypto_pwhash_scryptsalsa208sha256_memlimit_interactivecrypto_pwhash_scryptsalsa208sha256_opslimit_sensitivecrypto_pwhash_scryptsalsa208sha256_memlimit_sensitivecrypto_pwhash_scryptsalsa208sha256crypto_pwhash_scryptsalsa208sha256_strcrypto_pwhash_scryptsalsa208sha256_str_verifycrypto_pwhash_scryptsalsa208sha256_llcrypto_pwhash_scryptsalsa208sha256_str_needs_rehashcrypto_stream_salsa2012_keybytescrypto_stream_salsa2012_noncebytescrypto_stream_salsa2012_messagebytes_maxcrypto_stream_salsa2012crypto_stream_salsa2012_xorcrypto_stream_salsa2012_keygencrypto_stream_salsa208_keybytescrypto_stream_salsa208_noncebytescrypto_stream_salsa208_messagebytes_maxcrypto_stream_salsa208crypto_stream_salsa208_xorcrypto_stream_salsa208_keygen/* automatically generated by rust-bindgen */xdo_tXDo/// The main handle type which provides access to the various operations.Nul/// The provided string parameter had an interior null byte in it.Ffi/// Libxdo failed to create an instance. No further information available./// An error that can happen when trying to create an `XDo` instance.OpError/// Libxdo failed, returning an error code./// An error that can happen while executing an operation.OpResult/// Result of an `XDo` operation.xdo/// Creates a new `XDo` instance./// display - An optional string display name, such as `":0"`. If `None`, uses `$DISPLAY`./// Returns a new `XDo` instance, or a `CreationError` on error.move_mouse/// Moves the mouse to the specified position.move_mouse_relative/// Moves the mouse relative to the current position./// Does a mouse click./// Holds a mouse button down./// Releases a mouse button.enter_text/// Types the specified text.send_keysequence/// Does the specified key sequence.send_keysequence_up/// Releases the specified key sequence.send_keysequence_down/// Presses the specified key sequence down.//! High level bindings to [libxdo](http://www.semicomplete.com/files/xdotool/docs/html/)build_zlibbuild_zngbuild_zlib_ngzngtry_vcpkgzlib_installedif_zng// Macro for variances between zlib-ng in native mode and either zlib or zlib-ng in zlib compat// mode. Note in particular that zlib-ng in compat mode does *not* use the zng case.z_size// zlib uses unsigned long for various sizes; zlib-ng uses size_t.z_checksum// zlib stores Adler-32 and CRC-32 checksums in unsigned long; zlib-ng uses uint32_t.voidpfBytefgzFilegzFile_sin_funcout_funcuLonguLongfvoidpvoidpcz_off_txflagsextra_lenextra_maxname_maxcomm_maxhcrcgz_headergz_headerpz_streampzng_prefix// Ideally, this should instead use a macro that parses the whole block of externs, and generates// the appropriate link_name attributes, without duplicating the function names. However, ctest2// can't parse that.adler32deflateBounddeflateCopydeflateParamsdeflatePrimedeflateSetDictionarydeflateSetHeaderdeflateTuneinflateBackinflateBackEndinflateCopyinflateGetHeaderinflateMarkinflatePrimeinflateResetinflateReset2inflateSetDictionaryinflateSynczlibCompileFlags// The above set of functions currently target 1.2.3.4 (what's present on Ubuntu// 12.04, but there's some other APIs that were added later. Should figure out// how to expose them...// Added in 1.2.5.1//     pub fn deflatePending(strm: z_streamp,//                           pending: *mut c_uint,//                           bits: *mut c_int) -> c_int;// Addedin 1.2.7.1//     pub fn inflateGetDictionary(strm: z_streamp,//                                 dictionary: *mut Bytef,//                                 dictLength: *mut uInt) -> c_int;// Added in 1.2.3.5//     pub fn gzbuffer(file: gzFile, size: c_uint) -> c_int;//     pub fn gzclose_r(file: gzFile) -> c_int;//     pub fn gzclose_w(file: gzFile) -> c_int;//     pub fn gzoffset(file: gzFile) -> z_off_t;zlibVersiondeflateInit_deflateInit2_inflateBackInit_inflateInit_inflateInit2_adler32_combinecompress2compressBoundcrc32_combinegzdirectgzdopengzclearerrgzclosegzeofgzerrorgzflushgzgetcgzgetsgzopengzputcgzputsgzreadgzrewindgzseekgzsetparamsgztellgzungetcgzwriteuncompressZ_TREESZ_ERRNOZ_MEM_ERRORZ_VERSION_ERRORZ_NO_COMPRESSIONZ_BEST_SPEEDZ_BEST_COMPRESSIONZ_DEFAULT_COMPRESSIONZ_FILTEREDZ_HUFFMAN_ONLYZ_RLEZ_FIXEDZ_BINARYZ_TEXTZ_ASCIIZ_UNKNOWNis_msvcmflagstrip_symbol_prefix/// Replicate the behavior of cmake/make/configure of stripping out the/// @ZLIB_SYMBOL_PREFIX@ since we don't want or need itAT_HWCAP3AT_HWCAP4/* automatically generated by rust-bindgen 0.72.1 */__s8__kernel_key_t__kernel_mqd_t__kernel_old_uid_t__kernel_old_gid_t__kernel_long_t__kernel_ulong_t__kernel_ino_t__kernel_mode_t__kernel_ipc_pid_t__kernel_uid_t__kernel_gid_t__kernel_suseconds_t__kernel_daddr_t__kernel_uid32_t__kernel_gid32_t__kernel_old_dev_t__kernel_ssize_t__kernel_ptrdiff_t__kernel_off_t__kernel_old_time_t__kernel_time_t__kernel_time64_t__kernel_clock_t__kernel_timer_t__kernel_caddr_t__kernel_uid16_t__kernel_gid16_t__s128__u128__le16__be16__le32__be32__le64__be64__sum16__wsum__poll_t__IncompleteArrayFieldcontents_encryption_modefilenames_encryption_modemaster_key_descriptorfscrypt_policy_v1fscrypt_keylog2_data_unit_sizemaster_key_identifier16usizefscrypt_policy_v2policy_sizefscrypt_get_policy_ex_arg__bindgen_ty_1fscrypt_get_policy_ex_argfscrypt_key_specifier__bindgen_ty_1fscrypt_key_specifierfscrypt_provisioning_key_payloadkey_specraw_sizekey_idfscrypt_add_key_argremoval_status_flagsfscrypt_remove_key_arg6usizestatus_flagsuser_count__out_reserved13usizefscrypt_get_key_status_argsb_dev_majorsb_dev_minorsb_magicsb_flagsmnt_idmnt_parent_idmnt_id_oldmnt_parent_id_oldmnt_attrmnt_propagationmnt_peer_groupmnt_masterpropagate_frommnt_rootmnt_pointfs_subtypesb_sourceopt_numopt_arrayopt_sec_numopt_sec_arraysupported_maskmnt_uidmap_nummnt_uidmapmnt_gidmap_nummnt_gidmap__spare243usizestr_statmountmnt_id_reqminlenfstrim_rangefsuuid2fs_sysfs_pathbytes_dedupedfile_dedupe_range_infodest_countfile_dedupe_rangenr_filesnr_free_filesmax_filesfiles_stat_structnr_inodesnr_unusedinodes_stat_tfsx_xflagsfsx_extsizefsx_nextentsfsx_projidfsx_cowextsizefsx_padfsxattrpage_regionwalk_endvec_lenmax_pagescategory_invertedcategory_maskcategory_anyof_maskreturn_maskpm_scan_argquery_flagsquery_addrvma_startvma_endvma_flagsvma_page_sizevma_offsetdev_majordev_minorvma_name_sizebuild_id_sizevma_name_addrbuild_id_addrprocmap_query4088usizebtrfs_ioctl_vol_argsmax_rfermax_exclrsv_rferrsv_exclbtrfs_qgroup_limitnum_qgroupsnum_ref_copiesnum_excl_copieslimqgroupsbtrfs_qgroup_inheritqgroupidbtrfs_ioctl_qgroup_limit_argstransidbtrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_anon_2btrfs_ioctl_vol_args_v2__bindgen_ty_2btrfs_ioctl_vol_args_v2qgroup_inheritbtrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1data_extents_scrubbedtree_extents_scrubbeddata_bytes_scrubbedtree_bytes_scrubbedread_errorscsum_errorsverify_errorsno_csumcsum_discardssuper_errorsmalloc_errorsuncorrectable_errorscorrected_errorslast_physicalunverified_errorsbtrfs_scrub_progressdevid109usizebtrfs_ioctl_scrub_argssrcdevidcont_reading_from_srcdev_modesrcdev_name1025usizetgtdev_namebtrfs_ioctl_dev_replace_start_paramsprogress_1000time_startedtime_stoppednum_write_errorsnum_uncorrectable_read_errorsbtrfs_ioctl_dev_replace_status_paramsbtrfs_ioctl_dev_replace_args__bindgen_ty_1btrfs_ioctl_dev_replace_args377usize1024usizebtrfs_ioctl_dev_info_argsmax_idnum_devicesnodesizesectorsizeclone_alignmentcsum_typecsum_sizemetadata_uuid944usizebtrfs_ioctl_fs_info_argscompat_flagscompat_ro_flagsincompat_flagsbtrfs_ioctl_feature_flagsbtrfs_balance_args__bindgen_ty_1pstartpendvstartvendbtrfs_balance_args__bindgen_ty_2stripes_minstripes_maxbtrfs_balance_argsusage_minusage_maxbtrfs_balance_args__bindgen_ty_1__bindgen_ty_1limit_minlimit_maxbtrfs_balance_args__bindgen_ty_2__bindgen_ty_1consideredcompletedbtrfs_balance_progress72usizebtrfs_ioctl_balance_argstreeidobjectid4080usizebtrfs_ioctl_ino_lookup_argsdirid3824usizebtrfs_ioctl_ino_lookup_user_argsmin_objectidmax_objectidmin_offsetmax_offsetmin_transidmax_transidmin_typemax_typenr_itemsbtrfs_ioctl_search_keybtrfs_ioctl_search_header3992usizebtrfs_ioctl_search_argsbtrfs_ioctl_search_args_v2btrfs_ioctl_clone_range_argsextent_threshbtrfs_ioctl_defrag_range_args__bindgen_ty_1btrfs_ioctl_defrag_range_argsbtrfs_ioctl_defrag_range_args__bindgen_ty_1__bindgen_ty_1logical_offsetbtrfs_ioctl_same_extent_infobtrfs_ioctl_same_argsused_bytesbtrfs_ioctl_space_infospace_slotstotal_spacesspacesbtrfs_ioctl_space_argsbytes_leftbytes_missingelem_cntelem_missedbtrfs_data_containerinumfspathbtrfs_ioctl_ino_path_argslogicalinodesbtrfs_ioctl_logical_ino_args121usizebtrfs_ioctl_get_dev_statsbtrfs_ioctl_quota_ctl_argsbtrfs_ioctl_quota_rescan_argsbtrfs_ioctl_qgroup_assign_argsbtrfs_ioctl_qgroup_create_argsbtrfs_ioctl_timespecstransidrtransidrtimebtrfs_ioctl_received_subvol_argssend_fdclone_sources_countclone_sourcesparent_root28usizebtrfs_ioctl_send_argsparent_uuidreceived_uuidctransidotransidotimebtrfs_ioctl_get_subvol_info_argsmin_treeidrootref255usizebtrfs_ioctl_get_subvol_rootref_args__bindgen_ty_1btrfs_ioctl_get_subvol_rootref_argsioviovcntunencoded_lenunencoded_offsetencryptionbtrfs_ioctl_encoded_io_argssubvolidbtrfs_ioctl_subvol_waitbtrfs_disk_keybtrfs_keycsumbytenrchunk_tree_uuidnritemsbtrfs_headertree_roottree_root_genchunk_rootchunk_root_genextent_rootextent_root_genfs_rootfs_root_gendev_rootdev_root_gencsum_rootcsum_root_genunused_64tree_root_levelchunk_root_levelextent_root_levelfs_root_leveldev_root_levelcsum_root_levelunused_8btrfs_root_backupbtrfs_itembtrfs_leafblockptrbtrfs_key_ptrbtrfs_nodeio_alignio_widthsector_sizedev_groupseek_speedbandwidthbtrfs_dev_itemdev_uuidbtrfs_stripestripe_lennum_stripessub_stripesstripebtrfs_chunklog_root__unused_log_root_transidroot_dir_objectid__unused_leafsizestripesizesys_chunk_array_sizechunk_root_generationroot_levellog_root_leveldev_itemcache_generationuuid_tree_generationnr_global_rootssys_chunk_array2048usizesuper_roots565usizebtrfs_super_blockbtrfs_free_space_entrynum_entriesnum_bitmapsbtrfs_free_space_headerbtrfs_raid_stridebtrfs_stripe_extent__bindgen_ty_1btrfs_stripe_extent__empty_stridesbtrfs_stripe_extent__bindgen_ty_1__bindgen_ty_1stridesbtrfs_extent_itembtrfs_extent_item_v0btrfs_tree_block_infobtrfs_extent_data_refbtrfs_shared_data_refroot_idbtrfs_extent_owner_refbtrfs_extent_inline_refchunk_treechunk_objectidchunk_offsetbtrfs_dev_extentbtrfs_inode_refparent_objectidbtrfs_inode_extrefbtrfs_timespecnbytesblock_groupbtrfs_inode_itembtrfs_dir_log_itembtrfs_dir_itemroot_diridbyte_limitlast_snapshotdrop_progressdrop_levelgeneration_v2btrfs_root_itembtrfs_root_refbtrfs_disk_balance_args__bindgen_ty_1btrfs_disk_balance_args__bindgen_ty_2btrfs_disk_balance_argsbtrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1btrfs_balance_itemram_bytesother_encodingdisk_bytenrdisk_num_bytesbtrfs_file_extent_itembtrfs_csum_itembtrfs_dev_stats_itemsrc_devidcursor_leftcursor_rightbtrfs_dev_replace_itembtrfs_block_group_itemextent_countbtrfs_free_space_inforescanenable_genbtrfs_qgroup_status_itemrferrfer_cmprexclexcl_cmprbtrfs_qgroup_info_itembtrfs_qgroup_limit_itembtrfs_verity_descriptor_item__BITS_PER_LONG_LONGIOCSIZE_MASKIOCSIZE_SHIFTNR_OPENLINK_MAXXATTR_NAME_MAXXATTR_SIZE_MAXXATTR_LIST_MAXRTSIG_MAXFSCRYPT_POLICY_FLAGS_PAD_4FSCRYPT_POLICY_FLAGS_PAD_8FSCRYPT_POLICY_FLAGS_PAD_16FSCRYPT_POLICY_FLAGS_PAD_32FSCRYPT_POLICY_FLAGS_PAD_MASKFSCRYPT_POLICY_FLAG_DIRECT_KEYFSCRYPT_POLICY_FLAG_IV_INO_LBLK_64FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32FSCRYPT_MODE_AES_256_XTSFSCRYPT_MODE_AES_256_CTSFSCRYPT_MODE_AES_128_CBCFSCRYPT_MODE_AES_128_CTSFSCRYPT_MODE_SM4_XTSFSCRYPT_MODE_SM4_CTSFSCRYPT_MODE_ADIANTUMFSCRYPT_MODE_AES_256_HCTR2FSCRYPT_POLICY_V1FSCRYPT_KEY_DESCRIPTOR_SIZEFSCRYPT_KEY_DESC_PREFIXFSCRYPT_KEY_DESC_PREFIX_SIZEFSCRYPT_MAX_KEY_SIZEFSCRYPT_POLICY_V2FSCRYPT_KEY_IDENTIFIER_SIZEFSCRYPT_KEY_SPEC_TYPE_DESCRIPTORFSCRYPT_KEY_SPEC_TYPE_IDENTIFIERFSCRYPT_ADD_KEY_FLAG_HW_WRAPPEDFSCRYPT_KEY_REMOVAL_STATUS_FLAG_FILES_BUSYFSCRYPT_KEY_REMOVAL_STATUS_FLAG_OTHER_USERSFSCRYPT_KEY_STATUS_ABSENTFSCRYPT_KEY_STATUS_PRESENTFSCRYPT_KEY_STATUS_INCOMPLETELY_REMOVEDFSCRYPT_KEY_STATUS_FLAG_ADDED_BY_SELFFS_KEY_DESCRIPTOR_SIZEFS_POLICY_FLAGS_PAD_4FS_POLICY_FLAGS_PAD_8FS_POLICY_FLAGS_PAD_16FS_POLICY_FLAGS_PAD_32FS_POLICY_FLAGS_PAD_MASKFS_POLICY_FLAG_DIRECT_KEYFS_POLICY_FLAGS_VALIDFS_ENCRYPTION_MODE_INVALIDFS_ENCRYPTION_MODE_AES_256_XTSFS_ENCRYPTION_MODE_AES_256_GCMFS_ENCRYPTION_MODE_AES_256_CBCFS_ENCRYPTION_MODE_AES_256_CTSFS_ENCRYPTION_MODE_AES_128_CBCFS_ENCRYPTION_MODE_AES_128_CTSFS_ENCRYPTION_MODE_ADIANTUMFS_KEY_DESC_PREFIXFS_KEY_DESC_PREFIX_SIZEFS_MAX_KEY_SIZEMS_VERBOSEMS_SUBMOUNTMS_NOREMOTELOCKMS_NOSECMS_BORNMOVE_MOUNT__MASKFSOPEN_CLOEXECFSPICK_CLOEXECFSPICK_SYMLINK_NOFOLLOWFSPICK_NO_AUTOMOUNTFSPICK_EMPTY_PATHFSMOUNT_CLOEXECMNT_ID_REQ_SIZE_VER0MNT_ID_REQ_SIZE_VER1STATMOUNT_SB_BASICSTATMOUNT_MNT_BASICSTATMOUNT_PROPAGATE_FROMSTATMOUNT_MNT_ROOTSTATMOUNT_MNT_POINTSTATMOUNT_FS_TYPESTATMOUNT_MNT_NS_IDSTATMOUNT_MNT_OPTSSTATMOUNT_FS_SUBTYPESTATMOUNT_SB_SOURCESTATMOUNT_OPT_ARRAYSTATMOUNT_OPT_SEC_ARRAYSTATMOUNT_SUPPORTED_MASKSTATMOUNT_MNT_UIDMAPSTATMOUNT_MNT_GIDMAPLSMT_ROOTLISTMOUNT_REVERSEINR_OPEN_CURINR_OPEN_MAXBLOCK_SIZE_BITSIO_INTEGRITY_CHK_GUARDIO_INTEGRITY_CHK_REFTAGIO_INTEGRITY_CHK_APPTAGIO_INTEGRITY_VALID_FLAGSSEEK_MAXFILE_DEDUPE_RANGE_SAMEFILE_DEDUPE_RANGE_DIFFERSNR_FILEFS_XFLAG_REALTIMEFS_XFLAG_PREALLOCFS_XFLAG_IMMUTABLEFS_XFLAG_APPENDFS_XFLAG_SYNCFS_XFLAG_NOATIMEFS_XFLAG_NODUMPFS_XFLAG_RTINHERITFS_XFLAG_PROJINHERITFS_XFLAG_NOSYMLINKSFS_XFLAG_EXTSIZEFS_XFLAG_EXTSZINHERITFS_XFLAG_NODEFRAGFS_XFLAG_FILESTREAMFS_XFLAG_DAXFS_XFLAG_COWEXTSIZEFS_XFLAG_HASATTRBMAP_IOCTLFSLABEL_MAXFS_SECRM_FLFS_UNRM_FLFS_COMPR_FLFS_SYNC_FLFS_IMMUTABLE_FLFS_APPEND_FLFS_NODUMP_FLFS_NOATIME_FLFS_DIRTY_FLFS_COMPRBLK_FLFS_NOCOMP_FLFS_ENCRYPT_FLFS_BTREE_FLFS_INDEX_FLFS_IMAGIC_FLFS_JOURNAL_DATA_FLFS_NOTAIL_FLFS_DIRSYNC_FLFS_TOPDIR_FLFS_HUGE_FILE_FLFS_EXTENT_FLFS_VERITY_FLFS_EA_INODE_FLFS_EOFBLOCKS_FLFS_NOCOW_FLFS_DAX_FLFS_INLINE_DATA_FLFS_PROJINHERIT_FLFS_CASEFOLD_FLFS_RESERVED_FLFS_FL_USER_VISIBLEFS_FL_USER_MODIFIABLESYNC_FILE_RANGE_WRITE_AND_WAITPROCFS_IOCTL_MAGICPAGE_IS_WPALLOWEDPAGE_IS_WRITTENPAGE_IS_FILEPAGE_IS_PRESENTPAGE_IS_SWAPPEDPAGE_IS_PFNZEROPAGE_IS_HUGEPAGE_IS_SOFT_DIRTYPAGE_IS_GUARDPM_SCAN_WP_MATCHINGPM_SCAN_CHECK_WPASYNCBTRFS_IOCTL_MAGICBTRFS_VOL_NAME_MAXBTRFS_LABEL_SIZEBTRFS_PATH_NAME_MAXBTRFS_DEVICE_PATH_NAME_MAXBTRFS_SUBVOL_NAME_MAXBTRFS_SUBVOL_CREATE_ASYNCBTRFS_SUBVOL_RDONLYBTRFS_SUBVOL_QGROUP_INHERITBTRFS_DEVICE_SPEC_BY_IDBTRFS_SUBVOL_SPEC_BY_IDBTRFS_VOL_ARG_V2_FLAGS_SUPPORTEDBTRFS_FSID_SIZEBTRFS_UUID_SIZEBTRFS_UUID_UNPARSED_SIZEBTRFS_QGROUP_LIMIT_MAX_RFERBTRFS_QGROUP_LIMIT_MAX_EXCLBTRFS_QGROUP_LIMIT_RSV_RFERBTRFS_QGROUP_LIMIT_RSV_EXCLBTRFS_QGROUP_LIMIT_RFER_CMPRBTRFS_QGROUP_LIMIT_EXCL_CMPRBTRFS_QGROUP_INHERIT_SET_LIMITSBTRFS_QGROUP_INHERIT_FLAGS_SUPPBTRFS_DEVICE_REMOVE_ARGS_MASKBTRFS_SUBVOL_CREATE_ARGS_MASKBTRFS_SUBVOL_DELETE_ARGS_MASKBTRFS_SCRUB_READONLYBTRFS_SCRUB_SUPPORTED_FLAGSBTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYSBTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOIDBTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTEDBTRFS_IOCTL_DEV_REPLACE_STATE_STARTEDBTRFS_IOCTL_DEV_REPLACE_STATE_FINISHEDBTRFS_IOCTL_DEV_REPLACE_STATE_CANCELEDBTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDEDBTRFS_IOCTL_DEV_REPLACE_CMD_STARTBTRFS_IOCTL_DEV_REPLACE_CMD_STATUSBTRFS_IOCTL_DEV_REPLACE_CMD_CANCELBTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERRORBTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTEDBTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTEDBTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESSBTRFS_FS_INFO_FLAG_CSUM_INFOBTRFS_FS_INFO_FLAG_GENERATIONBTRFS_FS_INFO_FLAG_METADATA_UUIDBTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREEBTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALIDBTRFS_FEATURE_COMPAT_RO_VERITYBTRFS_FEATURE_COMPAT_RO_BLOCK_GROUP_TREEBTRFS_FEATURE_INCOMPAT_MIXED_BACKREFBTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOLBTRFS_FEATURE_INCOMPAT_MIXED_GROUPSBTRFS_FEATURE_INCOMPAT_COMPRESS_LZOBTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTDBTRFS_FEATURE_INCOMPAT_BIG_METADATABTRFS_FEATURE_INCOMPAT_EXTENDED_IREFBTRFS_FEATURE_INCOMPAT_RAID56BTRFS_FEATURE_INCOMPAT_SKINNY_METADATABTRFS_FEATURE_INCOMPAT_NO_HOLESBTRFS_FEATURE_INCOMPAT_METADATA_UUIDBTRFS_FEATURE_INCOMPAT_RAID1C34BTRFS_FEATURE_INCOMPAT_ZONEDBTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREEBTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTABTRFS_BALANCE_CTL_PAUSEBTRFS_BALANCE_CTL_CANCELBTRFS_BALANCE_DATABTRFS_BALANCE_SYSTEMBTRFS_BALANCE_METADATABTRFS_BALANCE_TYPE_MASKBTRFS_BALANCE_FORCEBTRFS_BALANCE_RESUMEBTRFS_BALANCE_ARGS_PROFILESBTRFS_BALANCE_ARGS_USAGEBTRFS_BALANCE_ARGS_DEVIDBTRFS_BALANCE_ARGS_DRANGEBTRFS_BALANCE_ARGS_VRANGEBTRFS_BALANCE_ARGS_LIMITBTRFS_BALANCE_ARGS_LIMIT_RANGEBTRFS_BALANCE_ARGS_STRIPES_RANGEBTRFS_BALANCE_ARGS_USAGE_RANGEBTRFS_BALANCE_ARGS_MASKBTRFS_BALANCE_ARGS_CONVERTBTRFS_BALANCE_ARGS_SOFTBTRFS_BALANCE_STATE_RUNNINGBTRFS_BALANCE_STATE_PAUSE_REQBTRFS_BALANCE_STATE_CANCEL_REQBTRFS_INO_LOOKUP_PATH_MAXBTRFS_INO_LOOKUP_USER_PATH_MAXBTRFS_DEFRAG_RANGE_COMPRESSBTRFS_DEFRAG_RANGE_START_IOBTRFS_DEFRAG_RANGE_COMPRESS_LEVELBTRFS_DEFRAG_RANGE_FLAGS_SUPPBTRFS_SAME_DATA_DIFFERSBTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSETBTRFS_DEV_STATS_RESETBTRFS_QUOTA_CTL_ENABLEBTRFS_QUOTA_CTL_DISABLEBTRFS_QUOTA_CTL_RESCAN__NOTUSEDBTRFS_QUOTA_CTL_ENABLE_SIMPLE_QUOTABTRFS_SEND_FLAG_NO_FILE_DATABTRFS_SEND_FLAG_OMIT_STREAM_HEADERBTRFS_SEND_FLAG_OMIT_END_CMDBTRFS_SEND_FLAG_VERSIONBTRFS_SEND_FLAG_COMPRESSEDBTRFS_SEND_FLAG_MASKBTRFS_MAX_ROOTREF_BUFFER_NUMBTRFS_ENCODED_IO_COMPRESSION_NONEBTRFS_ENCODED_IO_COMPRESSION_ZLIBBTRFS_ENCODED_IO_COMPRESSION_ZSTDBTRFS_ENCODED_IO_COMPRESSION_LZO_4KBTRFS_ENCODED_IO_COMPRESSION_LZO_8KBTRFS_ENCODED_IO_COMPRESSION_LZO_16KBTRFS_ENCODED_IO_COMPRESSION_LZO_32KBTRFS_ENCODED_IO_COMPRESSION_LZO_64KBTRFS_ENCODED_IO_COMPRESSION_TYPESBTRFS_ENCODED_IO_ENCRYPTION_NONEBTRFS_ENCODED_IO_ENCRYPTION_TYPESBTRFS_SUBVOL_SYNC_WAIT_FOR_ONEBTRFS_SUBVOL_SYNC_WAIT_FOR_QUEUEDBTRFS_SUBVOL_SYNC_COUNTBTRFS_SUBVOL_SYNC_PEEK_FIRSTBTRFS_SUBVOL_SYNC_PEEK_LASTBTRFS_MAGICBTRFS_MAX_LEVELBTRFS_NAME_LENBTRFS_LINK_MAXBTRFS_ROOT_TREE_OBJECTIDBTRFS_EXTENT_TREE_OBJECTIDBTRFS_CHUNK_TREE_OBJECTIDBTRFS_DEV_TREE_OBJECTIDBTRFS_FS_TREE_OBJECTIDBTRFS_ROOT_TREE_DIR_OBJECTIDBTRFS_CSUM_TREE_OBJECTIDBTRFS_QUOTA_TREE_OBJECTIDBTRFS_UUID_TREE_OBJECTIDBTRFS_FREE_SPACE_TREE_OBJECTIDBTRFS_BLOCK_GROUP_TREE_OBJECTIDBTRFS_RAID_STRIPE_TREE_OBJECTIDBTRFS_DEV_STATS_OBJECTIDBTRFS_BALANCE_OBJECTIDBTRFS_ORPHAN_OBJECTIDBTRFS_TREE_LOG_OBJECTIDBTRFS_TREE_LOG_FIXUP_OBJECTIDBTRFS_TREE_RELOC_OBJECTIDBTRFS_DATA_RELOC_TREE_OBJECTIDBTRFS_EXTENT_CSUM_OBJECTIDBTRFS_FREE_SPACE_OBJECTIDBTRFS_FREE_INO_OBJECTIDBTRFS_MULTIPLE_OBJECTIDSBTRFS_FIRST_FREE_OBJECTIDBTRFS_LAST_FREE_OBJECTIDBTRFS_FIRST_CHUNK_TREE_OBJECTIDBTRFS_DEV_ITEMS_OBJECTIDBTRFS_BTREE_INODE_OBJECTIDBTRFS_EMPTY_SUBVOL_DIR_OBJECTIDBTRFS_DEV_REPLACE_DEVIDBTRFS_INODE_ITEM_KEYBTRFS_INODE_REF_KEYBTRFS_INODE_EXTREF_KEYBTRFS_XATTR_ITEM_KEYBTRFS_VERITY_DESC_ITEM_KEYBTRFS_VERITY_MERKLE_ITEM_KEYBTRFS_ORPHAN_ITEM_KEYBTRFS_DIR_LOG_ITEM_KEYBTRFS_DIR_LOG_INDEX_KEYBTRFS_DIR_ITEM_KEYBTRFS_DIR_INDEX_KEYBTRFS_EXTENT_DATA_KEYBTRFS_EXTENT_CSUM_KEYBTRFS_ROOT_ITEM_KEYBTRFS_ROOT_BACKREF_KEYBTRFS_ROOT_REF_KEYBTRFS_EXTENT_ITEM_KEYBTRFS_METADATA_ITEM_KEYBTRFS_EXTENT_OWNER_REF_KEYBTRFS_TREE_BLOCK_REF_KEYBTRFS_EXTENT_DATA_REF_KEYBTRFS_SHARED_BLOCK_REF_KEYBTRFS_SHARED_DATA_REF_KEYBTRFS_BLOCK_GROUP_ITEM_KEYBTRFS_FREE_SPACE_INFO_KEYBTRFS_FREE_SPACE_EXTENT_KEYBTRFS_FREE_SPACE_BITMAP_KEYBTRFS_DEV_EXTENT_KEYBTRFS_DEV_ITEM_KEYBTRFS_CHUNK_ITEM_KEYBTRFS_RAID_STRIPE_KEYBTRFS_QGROUP_STATUS_KEYBTRFS_QGROUP_INFO_KEYBTRFS_QGROUP_LIMIT_KEYBTRFS_QGROUP_RELATION_KEYBTRFS_BALANCE_ITEM_KEYBTRFS_TEMPORARY_ITEM_KEYBTRFS_DEV_STATS_KEYBTRFS_PERSISTENT_ITEM_KEYBTRFS_DEV_REPLACE_KEYBTRFS_UUID_KEY_SUBVOLBTRFS_UUID_KEY_RECEIVED_SUBVOLBTRFS_STRING_ITEM_KEYBTRFS_MAX_METADATA_BLOCKSIZEBTRFS_CSUM_SIZEBTRFS_FT_UNKNOWNBTRFS_FT_REG_FILEBTRFS_FT_DIRBTRFS_FT_CHRDEVBTRFS_FT_BLKDEVBTRFS_FT_FIFOBTRFS_FT_SOCKBTRFS_FT_SYMLINKBTRFS_FT_XATTRBTRFS_FT_MAXBTRFS_FT_ENCRYPTEDBTRFS_INODE_NODATASUMBTRFS_INODE_NODATACOWBTRFS_INODE_READONLYBTRFS_INODE_NOCOMPRESSBTRFS_INODE_PREALLOCBTRFS_INODE_SYNCBTRFS_INODE_IMMUTABLEBTRFS_INODE_APPENDBTRFS_INODE_NODUMPBTRFS_INODE_NOATIMEBTRFS_INODE_DIRSYNCBTRFS_INODE_COMPRESSBTRFS_INODE_ROOT_ITEM_INITBTRFS_INODE_FLAG_MASKBTRFS_INODE_RO_VERITYBTRFS_INODE_RO_FLAG_MASKBTRFS_SYSTEM_CHUNK_ARRAY_SIZEBTRFS_NUM_BACKUP_ROOTSBTRFS_FREE_SPACE_EXTENTBTRFS_FREE_SPACE_BITMAPBTRFS_HEADER_FLAG_WRITTENBTRFS_HEADER_FLAG_RELOCBTRFS_SUPER_FLAG_ERRORBTRFS_SUPER_FLAG_SEEDINGBTRFS_SUPER_FLAG_METADUMPBTRFS_SUPER_FLAG_METADUMP_V2BTRFS_SUPER_FLAG_CHANGING_FSIDBTRFS_SUPER_FLAG_CHANGING_FSID_V2BTRFS_SUPER_FLAG_CHANGING_BG_TREEBTRFS_SUPER_FLAG_CHANGING_DATA_CSUMBTRFS_SUPER_FLAG_CHANGING_META_CSUMBTRFS_EXTENT_FLAG_DATABTRFS_EXTENT_FLAG_TREE_BLOCKBTRFS_BLOCK_FLAG_FULL_BACKREFBTRFS_BACKREF_REV_MAXBTRFS_BACKREF_REV_SHIFTBTRFS_OLD_BACKREF_REVBTRFS_MIXED_BACKREF_REVBTRFS_EXTENT_FLAG_SUPERBTRFS_ROOT_SUBVOL_RDONLYBTRFS_ROOT_SUBVOL_DEADBTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYSBTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOIDBTRFS_BLOCK_GROUP_DATABTRFS_BLOCK_GROUP_SYSTEMBTRFS_BLOCK_GROUP_METADATABTRFS_BLOCK_GROUP_RAID0BTRFS_BLOCK_GROUP_RAID1BTRFS_BLOCK_GROUP_DUPBTRFS_BLOCK_GROUP_RAID10BTRFS_BLOCK_GROUP_RAID5BTRFS_BLOCK_GROUP_RAID6BTRFS_BLOCK_GROUP_RAID1C3BTRFS_BLOCK_GROUP_RAID1C4BTRFS_BLOCK_GROUP_TYPE_MASKBTRFS_BLOCK_GROUP_PROFILE_MASKBTRFS_BLOCK_GROUP_RAID56_MASKBTRFS_BLOCK_GROUP_RAID1_MASKBTRFS_AVAIL_ALLOC_BIT_SINGLEBTRFS_SPACE_INFO_GLOBAL_RSVBTRFS_EXTENDED_PROFILE_MASKBTRFS_FREE_SPACE_USING_BITMAPSBTRFS_QGROUP_LEVEL_SHIFTBTRFS_QGROUP_STATUS_FLAG_ONBTRFS_QGROUP_STATUS_FLAG_RESCANBTRFS_QGROUP_STATUS_FLAG_INCONSISTENTBTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODEBTRFS_QGROUP_STATUS_FLAGS_MASKBTRFS_QGROUP_STATUS_VERSIONBTRFS_FILE_EXTENT_INLINEBTRFS_FILE_EXTENT_REGBTRFS_FILE_EXTENT_PREALLOCBTRFS_NR_FILE_EXTENT_TYPESfsconfig_commandFSCONFIG_SET_FLAGFSCONFIG_SET_STRINGFSCONFIG_SET_BINARYFSCONFIG_SET_PATHFSCONFIG_SET_PATH_EMPTYFSCONFIG_SET_FDFSCONFIG_CMD_CREATEFSCONFIG_CMD_RECONFIGUREFSCONFIG_CMD_CREATE_EXCLprocmap_query_flagsPROCMAP_QUERY_VMA_READABLEPROCMAP_QUERY_VMA_WRITABLEPROCMAP_QUERY_VMA_EXECUTABLEPROCMAP_QUERY_VMA_SHAREDPROCMAP_QUERY_COVERING_OR_NEXT_VMAPROCMAP_QUERY_FILE_BACKED_VMAbtrfs_dev_stat_valuesBTRFS_DEV_STAT_WRITE_ERRSBTRFS_DEV_STAT_READ_ERRSBTRFS_DEV_STAT_FLUSH_ERRSBTRFS_DEV_STAT_CORRUPTION_ERRSBTRFS_DEV_STAT_GENERATION_ERRSBTRFS_DEV_STAT_VALUES_MAXbtrfs_err_codeBTRFS_ERROR_DEV_RAID1_MIN_NOT_METBTRFS_ERROR_DEV_RAID10_MIN_NOT_METBTRFS_ERROR_DEV_RAID5_MIN_NOT_METBTRFS_ERROR_DEV_RAID6_MIN_NOT_METBTRFS_ERROR_DEV_TGT_REPLACEBTRFS_ERROR_DEV_MISSING_NOT_FOUNDBTRFS_ERROR_DEV_ONLY_WRITABLEBTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESSBTRFS_ERROR_DEV_RAID1C3_MIN_NOT_METBTRFS_ERROR_DEV_RAID1C4_MIN_NOT_METbtrfs_csum_typeBTRFS_CSUM_TYPE_CRC32BTRFS_CSUM_TYPE_XXHASHBTRFS_CSUM_TYPE_SHA256BTRFS_CSUM_TYPE_BLAKE24040usizecompress_typeElf32_VersymElf64_SHalfElf64_Versymelf32_relelf64_relelf32_relaelf64_relaelf32_symelf64_symelf32_hdrelf64_hdrelf32_phdrelf64_phdrelf32_shdrelf64_shdrElf32_Nhdrelf32_noteElf64_Nhdrelf64_noted_tagd_unElf32_Dyn__bindgen_ty_1Elf32_DynElf64_Dyn__bindgen_ty_1Elf64_Dynvd_versionvd_flagsvd_ndxvd_cntvd_hashvd_auxvd_nextElf32_VerdefElf64_Verdefvda_namevda_nextElf32_VerdauxElf64_VerdauxEM_486EM_MIPS_RS4_BEEM_SPUEM_ARCOMPACTEM_BLACKFINEM_UNICOREEM_ALTERA_NIOS2EM_TI_C6000EM_HEXAGONEM_NDS32EM_MICROBLAZEEM_ARCV2EM_BPFEM_CSKYEM_LOONGARCHEM_FRVEM_CYGNUS_M32REM_S390_OLDEM_CYGNUS_MN10300PT_GNU_PROPERTYPT_AARCH64_MEMTAG_MTEPN_XNUMDT_NULLDT_NEEDEDDT_PLTRELSZDT_PLTGOTDT_HASHDT_STRTABDT_SYMTABDT_RELADT_RELASZDT_RELAENTDT_STRSZDT_SYMENTDT_INITDT_FINIDT_SONAMEDT_RPATHDT_SYMBOLICDT_RELDT_RELSZDT_RELENTDT_PLTRELDT_DEBUGDT_TEXTRELDT_JMPRELDT_ENCODINGOLD_DT_LOOSDT_LOOSDT_HIOSDT_VALRNGLODT_VALRNGHIDT_ADDRRNGLODT_GNU_HASHDT_ADDRRNGHIDT_VERSYMDT_RELACOUNTDT_RELCOUNTDT_FLAGS_1DT_VERDEFDT_VERDEFNUMDT_VERNEEDDT_VERNEEDNUMOLD_DT_HIOSDT_LOPROCDT_HIPROCSTB_LOCALSTB_GLOBALSTB_WEAKSTN_UNDEFSTT_NOTYPESTT_OBJECTSTT_FUNCSTT_SECTIONSTT_FILESTT_COMMONSTT_TLSVER_FLG_BASEVER_FLG_WEAKSHT_NULLSHT_PROGBITSSHT_SYMTABSHT_STRTABSHT_RELASHT_HASHSHT_DYNAMICSHT_NOTESHT_NOBITSSHT_RELSHT_SHLIBSHT_DYNSYMSHT_NUMSHT_LOPROCSHT_HIPROCSHT_LOUSERSHT_HIUSERSHF_WRITESHF_ALLOCSHF_EXECINSTRSHF_MERGESHF_STRINGSSHF_INFO_LINKSHF_LINK_ORDERSHF_OS_NONCONFORMINGSHF_GROUPSHF_TLSSHF_RELA_LIVEPATCHSHF_RO_AFTER_INITSHF_ORDEREDSHF_EXCLUDESHF_MASKOSSHF_MASKPROCSHN_UNDEFSHN_LORESERVESHN_LOPROCSHN_HIPROCSHN_LIVEPATCHSHN_ABSSHN_COMMONSHN_HIRESERVEELFMAGELF_OSABINN_GNU_PROPERTY_TYPE_0NT_GNU_PROPERTY_TYPE_0NN_PRSTATUSNN_PRFPREGNN_PRPSINFONN_TASKSTRUCTNN_AUXVNN_SIGINFONT_SIGINFONN_FILENT_FILENN_PRXFPREGNT_PRXFPREGNN_PPC_VMXNT_PPC_VMXNN_PPC_SPENT_PPC_SPENN_PPC_VSXNT_PPC_VSXNN_PPC_TARNT_PPC_TARNN_PPC_PPRNT_PPC_PPRNN_PPC_DSCRNT_PPC_DSCRNN_PPC_EBBNT_PPC_EBBNN_PPC_PMUNT_PPC_PMUNN_PPC_TM_CGPRNT_PPC_TM_CGPRNN_PPC_TM_CFPRNT_PPC_TM_CFPRNN_PPC_TM_CVMXNT_PPC_TM_CVMXNN_PPC_TM_CVSXNT_PPC_TM_CVSXNN_PPC_TM_SPRNT_PPC_TM_SPRNN_PPC_TM_CTARNT_PPC_TM_CTARNN_PPC_TM_CPPRNT_PPC_TM_CPPRNN_PPC_TM_CDSCRNT_PPC_TM_CDSCRNN_PPC_PKEYNT_PPC_PKEYNN_PPC_DEXCRNT_PPC_DEXCRNN_PPC_HASHKEYRNT_PPC_HASHKEYRNN_386_TLSNT_386_TLSNN_386_IOPERMNT_386_IOPERMNN_X86_XSTATENT_X86_XSTATENN_X86_SHSTKNT_X86_SHSTKNN_X86_XSAVE_LAYOUTNT_X86_XSAVE_LAYOUTNN_S390_HIGH_GPRSNT_S390_HIGH_GPRSNN_S390_TIMERNT_S390_TIMERNN_S390_TODCMPNT_S390_TODCMPNN_S390_TODPREGNT_S390_TODPREGNN_S390_CTRSNT_S390_CTRSNN_S390_PREFIXNT_S390_PREFIXNN_S390_LAST_BREAKNT_S390_LAST_BREAKNN_S390_SYSTEM_CALLNT_S390_SYSTEM_CALLNN_S390_TDBNT_S390_TDBNN_S390_VXRS_LOWNT_S390_VXRS_LOWNN_S390_VXRS_HIGHNT_S390_VXRS_HIGHNN_S390_GS_CBNT_S390_GS_CBNN_S390_GS_BCNT_S390_GS_BCNN_S390_RI_CBNT_S390_RI_CBNN_S390_PV_CPU_DATANT_S390_PV_CPU_DATANN_ARM_VFPNT_ARM_VFPNN_ARM_TLSNT_ARM_TLSNN_ARM_HW_BREAKNT_ARM_HW_BREAKNN_ARM_HW_WATCHNT_ARM_HW_WATCHNN_ARM_SYSTEM_CALLNT_ARM_SYSTEM_CALLNN_ARM_SVENT_ARM_SVENN_ARM_PAC_MASKNT_ARM_PAC_MASKNN_ARM_PACA_KEYSNT_ARM_PACA_KEYSNN_ARM_PACG_KEYSNT_ARM_PACG_KEYSNN_ARM_TAGGED_ADDR_CTRLNT_ARM_TAGGED_ADDR_CTRLNN_ARM_PAC_ENABLED_KEYSNT_ARM_PAC_ENABLED_KEYSNN_ARM_SSVENT_ARM_SSVENN_ARM_ZANT_ARM_ZANN_ARM_ZTNT_ARM_ZTNN_ARM_FPMRNT_ARM_FPMRNN_ARM_POENT_ARM_POENN_ARM_GCSNT_ARM_GCSNN_ARC_V2NT_ARC_V2NN_VMCOREDDNT_VMCOREDDNN_MIPS_DSPNT_MIPS_DSPNN_MIPS_FP_MODENT_MIPS_FP_MODENN_MIPS_MSANT_MIPS_MSANN_RISCV_CSRNT_RISCV_CSRNN_RISCV_VECTORNT_RISCV_VECTORNN_RISCV_TAGGED_ADDR_CTRLNT_RISCV_TAGGED_ADDR_CTRLNN_LOONGARCH_CPUCFGNT_LOONGARCH_CPUCFGNN_LOONGARCH_CSRNT_LOONGARCH_CSRNN_LOONGARCH_LSXNT_LOONGARCH_LSXNN_LOONGARCH_LASXNT_LOONGARCH_LASXNN_LOONGARCH_LBTNT_LOONGARCH_LBTNN_LOONGARCH_HW_BREAKNT_LOONGARCH_HW_BREAKNN_LOONGARCH_HW_WATCHNT_LOONGARCH_HW_WATCHGNU_PROPERTY_AARCH64_FEATURE_1_ANDGNU_PROPERTY_AARCH64_FEATURE_1_BTId_vald_ptr__kernel_sighandler_tcap_user_header_t__user_cap_header_structcap_user_data_t__user_cap_data_structold_sigset_t__signalfn_t__sighandler_t__restorefn_t__sigrestore_t__kernel_fd_setpermittedinheritablemagic_etcvfs_cap_data__bindgen_ty_1vfs_cap_datavfs_ns_cap_data__bindgen_ty_1rootidvfs_ns_cap_dataf_owner_exuaddrfutex_waitvrobust_listfutex_offsetlist_op_pendingrobust_list_headcachestat_rangenr_cachenr_dirtynr_writebacknr_evictednr_recently_evictedcachestatentropy_countrand_pool_infosize_of_opaque_statemmap_protmmap_flagsvgetrandom_opaque_params__kernel_timespec__kernel_itimerspec__kernel_old_timeval__kernel_old_timespec__kernel_old_itimerval__kernel_sock_timeval1usizesa_handler_pid_uid__sifields__bindgen_ty_1_tid_overrun_sigval_sys_private__sifields__bindgen_ty_2__sifields__bindgen_ty_3_status_utime_stime__sifields__bindgen_ty_4_addr__sifields__bindgen_ty_5__bindgen_ty_1__sifields__bindgen_ty_5_dummy_bnd_lower_upper__sifields__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1_dummy_pkey_pkey__sifields__bindgen_ty_5__bindgen_ty_1__bindgen_ty_2__sifields__bindgen_ty_5__bindgen_ty_1__bindgen_ty_3_band_fd__sifields__bindgen_ty_6_call_addr_syscall_arch__sifields__bindgen_ty_7siginfo__bindgen_ty_1_sifields__sifieldssiginfo__bindgen_ty_1__bindgen_ty_1_sigev_unsigevent__bindgen_ty_1_function_attributesigevent__bindgen_ty_1__bindgen_ty_1__spare0stx_subvolstx_atomic_write_unit_minstx_atomic_write_unit_maxstx_atomic_write_segments_maxstx_dio_read_offset_alignstx_atomic_write_unit_max_opt__spare3ktermiostermiotz_minuteswesttz_dsttimexattr_argsuffd_msg__bindgen_ty_1uffd_msgfeatuffd_msg__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1uffd_msg__bindgen_ty_1__bindgen_ty_1ufduffd_msg__bindgen_ty_1__bindgen_ty_2uffd_msg__bindgen_ty_1__bindgen_ty_3uffd_msg__bindgen_ty_1__bindgen_ty_4uffd_msg__bindgen_ty_1__bindgen_ty_5ioctlsuffdio_apiuffdio_rangeuffdio_registeruffdio_copyzeropageuffdio_zeropageuffdio_writeprotectmappeduffdio_continueuffdio_poisonuffdio_movelinux_dirent64compat_statfs64entry_number_bitfield_align_1_bitfield_1__bindgen_padding_0user_desckernel_sigset_tsa_handler_kernelkernel_sigactionLINUX_VERSION_CODELINUX_VERSION_MAJORLINUX_VERSION_PATCHLEVELLINUX_VERSION_SUBLEVEL_LINUX_CAPABILITY_VERSION_1_LINUX_CAPABILITY_U32S_1_LINUX_CAPABILITY_VERSION_2_LINUX_CAPABILITY_U32S_2_LINUX_CAPABILITY_VERSION_3_LINUX_CAPABILITY_U32S_3VFS_CAP_REVISION_MASKVFS_CAP_REVISION_SHIFTVFS_CAP_FLAGS_MASKVFS_CAP_FLAGS_EFFECTIVEVFS_CAP_REVISION_1VFS_CAP_U32_1VFS_CAP_REVISION_2VFS_CAP_U32_2VFS_CAP_REVISION_3VFS_CAP_U32_3VFS_CAP_U32VFS_CAP_REVISION_LINUX_CAPABILITY_VERSION_LINUX_CAPABILITY_U32SCAP_CHOWNCAP_DAC_OVERRIDECAP_DAC_READ_SEARCHCAP_FOWNERCAP_FSETIDCAP_KILLCAP_SETGIDCAP_SETUIDCAP_SETPCAPCAP_LINUX_IMMUTABLECAP_NET_BIND_SERVICECAP_NET_BROADCASTCAP_NET_ADMINCAP_NET_RAWCAP_IPC_LOCKCAP_IPC_OWNERCAP_SYS_MODULECAP_SYS_RAWIOCAP_SYS_CHROOTCAP_SYS_PTRACECAP_SYS_PACCTCAP_SYS_ADMINCAP_SYS_BOOTCAP_SYS_NICECAP_SYS_RESOURCECAP_SYS_TIMECAP_SYS_TTY_CONFIGCAP_MKNODCAP_LEASECAP_AUDIT_WRITECAP_AUDIT_CONTROLCAP_SETFCAPCAP_MAC_OVERRIDECAP_MAC_ADMINCAP_SYSLOGCAP_WAKE_ALARMCAP_BLOCK_SUSPENDCAP_AUDIT_READCAP_PERFMONCAP_BPFCAP_CHECKPOINT_RESTORECAP_LAST_CAP__O_SYNC__O_TMPFILELOCK_MANDLOCK_READLOCK_WRITELOCK_RWF_DUPFD_QUERYF_CREATED_QUERYF_GET_RW_HINTF_SET_RW_HINTF_GET_FILE_RW_HINTF_SET_FILE_RW_HINTRWH_WRITE_LIFE_NOT_SETRWH_WRITE_LIFE_NONERWH_WRITE_LIFE_SHORTRWH_WRITE_LIFE_MEDIUMRWH_WRITE_LIFE_LONGRWH_WRITE_LIFE_EXTREMERWF_WRITE_LIFE_NOT_SETDN_ACCESSDN_MODIFYDN_CREATEDN_DELETEDN_RENAMEDN_ATTRIBDN_MULTISHOTAT_RENAME_NOREPLACEAT_RENAME_EXCHANGEAT_RENAME_WHITEOUTAT_HANDLE_FIDAT_HANDLE_MNT_ID_UNIQUEAT_HANDLE_CONNECTABLEAT_EXECVE_CHECKEPOLL_IOC_TYPEFALLOC_FL_ALLOCATE_RANGEFUTEX_WAIT_PRIVATEFUTEX_WAKE_PRIVATEFUTEX_REQUEUE_PRIVATEFUTEX_CMP_REQUEUE_PRIVATEFUTEX_WAKE_OP_PRIVATEFUTEX_LOCK_PI_PRIVATEFUTEX_LOCK_PI2_PRIVATEFUTEX_UNLOCK_PI_PRIVATEFUTEX_TRYLOCK_PI_PRIVATEFUTEX_WAIT_BITSET_PRIVATEFUTEX_WAKE_BITSET_PRIVATEFUTEX_WAIT_REQUEUE_PI_PRIVATEFUTEX_CMP_REQUEUE_PI_PRIVATEFUTEX2_SIZE_U8FUTEX2_SIZE_U16FUTEX2_SIZE_U32FUTEX2_SIZE_U64FUTEX2_NUMAFUTEX2_MPOLFUTEX2_PRIVATEFUTEX2_SIZE_MASKFUTEX_32FUTEX_NO_NODEFUTEX_WAITV_MAXROBUST_LIST_LIMITCEPH_SUPER_MAGICCRAMFS_MAGIC_WENDRAMFS_MAGICSQUASHFS_MAGICEROFS_SUPER_MAGIC_V1PSTOREFS_MAGICEFIVARFS_MAGICBCACHEFS_SUPER_MAGICEXFAT_SUPER_MAGICAFS_FS_MAGICREISERFS_SUPER_MAGIC_STRINGREISER2FS_SUPER_MAGIC_STRINGREISER2FS_JR_SUPER_MAGIC_STRINGCIFS_SUPER_MAGICSMB2_SUPER_MAGICSTACK_END_MAGICV9FS_MAGICBDEVFS_MAGICDAXFS_MAGICBINFMTFS_MAGICPIPEFS_MAGICSOCKFS_MAGICMTD_INODE_FS_MAGICANON_INODE_FS_MAGICBTRFS_TEST_MAGICAAFS_MAGICZONEFS_MAGICDMA_BUF_MAGICDEVMEM_MAGICSECRETMEM_MAGICPID_FS_MAGICPROT_SEMMADV_GUARD_INSTALLMADV_GUARD_REMOVEPKEY_UNRESTRICTEDPKEY_DISABLE_ACCESSPKEY_DISABLE_WRITEPKEY_ACCESS_MASKSHADOW_STACK_SET_TOKENSHADOW_STACK_SET_MARKERPKEY_DISABLE_EXECUTEPKEY_DISABLE_READHUGETLB_FLAG_ENCODE_16KBOVERCOMMIT_GUESSOVERCOMMIT_ALWAYSOVERCOMMIT_NEVERPOLLREMOVE_STK_LIMMLOCK_LIMITCLONE_ARGS_SIZE_VER0CLONE_ARGS_SIZE_VER1CLONE_ARGS_SIZE_VER2SCHED_EXT_NSIG_BPW_NSIG_WORDSSA_UNSUPPORTEDSA_EXPOSE_TAGBITSSI_MAX_SIZEILL_BADIADDR__ILL_BREAK__ILL_BNDMODNSIGILL__FPE_DECOVF__FPE_DECDIV__FPE_DECERR__FPE_INVASC__FPE_INVDECFPE_FLTUNKFPE_CONDTRAPNSIGFPESEGV_BNDERRSEGV_PKUERRSEGV_ACCADISEGV_ADIDERRSEGV_ADIPERRSEGV_MTEAERRSEGV_MTESERRSEGV_CPERRNSIGSEGVNSIGBUSNSIGTRAPTRAP_PERF_FLAG_ASYNCNSIGCHLDNSIGPOLLSYS_SECCOMPSYS_USER_DISPATCHNSIGSYSEMT_TAGOVFNSIGEMTSIGEV_MAX_SIZESS_AUTODISARMSS_FLAG_BITSSTATX_MNT_ID_UNIQUESTATX_SUBVOLSTATX_WRITE_ATOMICSTATX_DIO_READ_ALIGNSTATX_ATTR_WRITE_ATOMICADDRBNCCMAX_CLOCKSCLOCKS_MASKCLOCKS_MONOUIO_FASTIOV__NR_io_setup__NR_io_destroy__NR_io_submit__NR_io_cancel__NR_io_getevents__NR_setxattr__NR_lsetxattr__NR_fsetxattr__NR_getxattr__NR_lgetxattr__NR_fgetxattr__NR_listxattr__NR_llistxattr__NR_flistxattr__NR_removexattr__NR_lremovexattr__NR_fremovexattr__NR_getcwd__NR_lookup_dcookie__NR_eventfd2__NR_epoll_create1__NR_epoll_ctl__NR_epoll_pwait__NR_dup__NR_dup3__NR_fcntl__NR_inotify_init1__NR_inotify_add_watch__NR_inotify_rm_watch__NR_ioctl__NR_ioprio_set__NR_ioprio_get__NR_flock__NR_mknodat__NR_mkdirat__NR_unlinkat__NR_symlinkat__NR_linkat__NR_renameat__NR_umount2__NR_mount__NR_pivot_root__NR_nfsservctl__NR_statfs__NR_fstatfs__NR_truncate__NR_ftruncate__NR_fallocate__NR_faccessat__NR_chdir__NR_fchdir__NR_chroot__NR_fchmod__NR_fchmodat__NR_fchownat__NR_fchown__NR_openat__NR_close__NR_vhangup__NR_pipe2__NR_quotactl__NR_getdents64__NR_lseek__NR_read__NR_write__NR_readv__NR_writev__NR_pread64__NR_pwrite64__NR_preadv__NR_pwritev__NR_sendfile__NR_pselect6__NR_ppoll__NR_signalfd4__NR_vmsplice__NR_splice__NR_tee__NR_readlinkat__NR_newfstatat__NR_fstat__NR_sync__NR_fsync__NR_fdatasync__NR_sync_file_range__NR_timerfd_create__NR_timerfd_settime__NR_timerfd_gettime__NR_utimensat__NR_acct__NR_capget__NR_capset__NR_personality__NR_exit__NR_exit_group__NR_waitid__NR_set_tid_address__NR_unshare__NR_futex__NR_set_robust_list__NR_get_robust_list__NR_nanosleep__NR_getitimer__NR_setitimer__NR_kexec_load__NR_init_module__NR_delete_module__NR_timer_create__NR_timer_gettime__NR_timer_getoverrun__NR_timer_settime__NR_timer_delete__NR_clock_settime__NR_clock_gettime__NR_clock_getres__NR_clock_nanosleep__NR_syslog__NR_ptrace__NR_sched_setparam__NR_sched_setscheduler__NR_sched_getscheduler__NR_sched_getparam__NR_sched_setaffinity__NR_sched_getaffinity__NR_sched_yield__NR_sched_get_priority_max__NR_sched_get_priority_min__NR_sched_rr_get_interval__NR_restart_syscall__NR_kill__NR_tkill__NR_tgkill__NR_sigaltstack__NR_rt_sigsuspend__NR_rt_sigaction__NR_rt_sigprocmask__NR_rt_sigpending__NR_rt_sigtimedwait__NR_rt_sigqueueinfo__NR_rt_sigreturn__NR_setpriority__NR_getpriority__NR_reboot__NR_setregid__NR_setgid__NR_setreuid__NR_setuid__NR_setresuid__NR_getresuid__NR_setresgid__NR_getresgid__NR_setfsuid__NR_setfsgid__NR_times__NR_setpgid__NR_getpgid__NR_getsid__NR_setsid__NR_getgroups__NR_setgroups__NR_uname__NR_sethostname__NR_setdomainname__NR_getrlimit__NR_setrlimit__NR_getrusage__NR_umask__NR_prctl__NR_getcpu__NR_gettimeofday__NR_settimeofday__NR_adjtimex__NR_getpid__NR_getppid__NR_getuid__NR_geteuid__NR_getgid__NR_getegid__NR_gettid__NR_sysinfo__NR_mq_open__NR_mq_unlink__NR_mq_timedsend__NR_mq_timedreceive__NR_mq_notify__NR_mq_getsetattr__NR_msgget__NR_msgctl__NR_msgrcv__NR_msgsnd__NR_semget__NR_semctl__NR_semtimedop__NR_semop__NR_shmget__NR_shmctl__NR_shmat__NR_shmdt__NR_socket__NR_socketpair__NR_bind__NR_listen__NR_accept__NR_connect__NR_getsockname__NR_getpeername__NR_sendto__NR_recvfrom__NR_setsockopt__NR_getsockopt__NR_shutdown__NR_sendmsg__NR_recvmsg__NR_readahead__NR_brk__NR_munmap__NR_mremap__NR_add_key__NR_request_key__NR_keyctl__NR_clone__NR_execve__NR_mmap__NR_fadvise64__NR_swapon__NR_swapoff__NR_mprotect__NR_msync__NR_mlock__NR_munlock__NR_mlockall__NR_munlockall__NR_mincore__NR_madvise__NR_remap_file_pages__NR_mbind__NR_get_mempolicy__NR_set_mempolicy__NR_migrate_pages__NR_move_pages__NR_rt_tgsigqueueinfo__NR_perf_event_open__NR_accept4__NR_recvmmsg__NR_wait4__NR_prlimit64__NR_fanotify_init__NR_fanotify_mark__NR_name_to_handle_at__NR_open_by_handle_at__NR_clock_adjtime__NR_syncfs__NR_setns__NR_sendmmsg__NR_process_vm_readv__NR_process_vm_writev__NR_kcmp__NR_finit_module__NR_sched_setattr__NR_sched_getattr__NR_renameat2__NR_seccomp__NR_getrandom__NR_memfd_create__NR_bpf__NR_execveat__NR_userfaultfd__NR_membarrier__NR_mlock2__NR_copy_file_range__NR_preadv2__NR_pwritev2__NR_pkey_mprotect__NR_pkey_alloc__NR_pkey_free__NR_statx__NR_io_pgetevents__NR_rseq__NR_kexec_file_load__NR_pidfd_send_signal__NR_io_uring_setup__NR_io_uring_enter__NR_io_uring_register__NR_open_tree__NR_move_mount__NR_fsopen__NR_fsconfig__NR_fsmount__NR_fspick__NR_pidfd_open__NR_clone3__NR_close_range__NR_openat2__NR_pidfd_getfd__NR_faccessat2__NR_process_madvise__NR_epoll_pwait2__NR_mount_setattr__NR_quotactl_fd__NR_landlock_create_ruleset__NR_landlock_add_rule__NR_landlock_restrict_self__NR_memfd_secret__NR_process_mrelease__NR_futex_waitv__NR_set_mempolicy_home_node__NR_cachestat__NR_fchmodat2__NR_map_shadow_stack__NR_futex_wake__NR_futex_wait__NR_futex_requeue__NR_statmount__NR_listmount__NR_lsm_get_self_attr__NR_lsm_set_self_attr__NR_lsm_list_modules__NR_mseal__NR_setxattrat__NR_getxattrat__NR_listxattrat__NR_removexattrat__NR_open_tree_attrXATTR_OS2_PREFIXXATTR_MAC_OSX_PREFIXXATTR_BTRFS_PREFIXXATTR_HURD_PREFIXXATTR_SECURITY_PREFIXXATTR_SYSTEM_PREFIXXATTR_TRUSTED_PREFIXXATTR_USER_PREFIXXATTR_EVM_SUFFIXXATTR_NAME_EVMXATTR_IMA_SUFFIXXATTR_NAME_IMAXATTR_SELINUX_SUFFIXXATTR_NAME_SELINUXXATTR_SMACK_SUFFIXXATTR_SMACK_IPINXATTR_SMACK_IPOUTXATTR_SMACK_EXECXATTR_SMACK_TRANSMUTEXATTR_SMACK_MMAPXATTR_NAME_SMACKXATTR_NAME_SMACKIPINXATTR_NAME_SMACKIPOUTXATTR_NAME_SMACKEXECXATTR_NAME_SMACKTRANSMUTEXATTR_NAME_SMACKMMAPXATTR_APPARMOR_SUFFIXXATTR_NAME_APPARMORXATTR_CAPS_SUFFIXXATTR_NAME_CAPSXATTR_BPF_LSM_SUFFIXXATTR_NAME_BPF_LSMXATTR_POSIX_ACL_ACCESSXATTR_NAME_POSIX_ACL_ACCESSXATTR_POSIX_ACL_DEFAULTXATTR_NAME_POSIX_ACL_DEFAULTUSERFAULTFD_IOC_UFFDIO_REGISTER_UFFDIO_UNREGISTER_UFFDIO_WAKE_UFFDIO_COPY_UFFDIO_ZEROPAGE_UFFDIO_MOVE_UFFDIO_WRITEPROTECT_UFFDIO_CONTINUE_UFFDIO_POISON_UFFDIO_APIUFFDIOUFFD_EVENT_PAGEFAULTUFFD_EVENT_FORKUFFD_EVENT_REMAPUFFD_EVENT_REMOVEUFFD_EVENT_UNMAPUFFD_PAGEFAULT_FLAG_WRITEUFFD_PAGEFAULT_FLAG_WPUFFD_PAGEFAULT_FLAG_MINORUFFD_FEATURE_PAGEFAULT_FLAG_WPUFFD_FEATURE_EVENT_FORKUFFD_FEATURE_EVENT_REMAPUFFD_FEATURE_EVENT_REMOVEUFFD_FEATURE_MISSING_HUGETLBFSUFFD_FEATURE_MISSING_SHMEMUFFD_FEATURE_EVENT_UNMAPUFFD_FEATURE_SIGBUSUFFD_FEATURE_THREAD_IDUFFD_FEATURE_MINOR_HUGETLBFSUFFD_FEATURE_MINOR_SHMEMUFFD_FEATURE_EXACT_ADDRESSUFFD_FEATURE_WP_HUGETLBFS_SHMEMUFFD_FEATURE_WP_UNPOPULATEDUFFD_FEATURE_POISONUFFD_FEATURE_WP_ASYNCUFFD_FEATURE_MOVEUFFD_USER_MODE_ONLYSTAT_HAVE_NSECUMOUNT_UNUSEDTFD_SHARED_FCNTL_FLAGSTFD_CREATE_FLAGSTFD_SETTIME_FLAGSUFFD_APIUFFDIO_REGISTER_MODE_MISSINGUFFDIO_REGISTER_MODE_WPUFFDIO_REGISTER_MODE_MINORUFFDIO_COPY_MODE_DONTWAKEUFFDIO_COPY_MODE_WPUFFDIO_ZEROPAGE_MODE_DONTWAKEmembarrier_cmdMEMBARRIER_CMD_GET_REGISTRATIONSmembarrier_cmd_flagMEMBARRIER_CMD_FLAG_CPUsival_int_kill_timer_rt_sigchld_sigfault_sigpoll_sigsys_trapno_addr_lsb_addr_bnd_addr_pkey_perf_si_pad_sigev_threadpagefaultptidMEMBARRIER_CMD_SHAREDseg_32bitset_seg_32bitseg_32bit_rawset_seg_32bit_rawset_contentscontents_rawset_contents_rawread_exec_onlyset_read_exec_onlyread_exec_only_rawset_read_exec_only_rawlimit_in_pagesset_limit_in_pageslimit_in_pages_rawset_limit_in_pages_rawseg_not_presentset_seg_not_presentseg_not_present_rawset_seg_not_present_rawuseableset_useableuseable_rawset_useable_rawnew_bitfield_1__kernel_sa_family_t__kernel_sockaddr_storage__bindgen_ty_1__kernel_sockaddr_storage__data126usize__kernel_sockaddr_storage__bindgen_ty_1__bindgen_ty_1__storageclock_typesync_serial_settingsslot_mapte1_settingsraw_hdlc_protot391t392n391n392n393lmidcefr_protodlcifr_proto_pvcfr_proto_pvc_infocisco_protomodulot2n2x25_hdlc_protoifmapifs_ifsuif_settings__bindgen_ty_1if_settingsifreq__bindgen_ty_1ifreq__bindgen_ty_2ifconf__bindgen_ty_1h_desth_sourceh_protoethhdrtpacket3_hdr__bindgen_ty_1tpacket_bd_ts__bindgen_ty_1nla_bitfield32tx_droppedmulticastcollisionsrx_length_errorsrx_over_errorsrx_crc_errorsrx_frame_errorsrx_fifo_errorsrx_missed_errorstx_aborted_errorstx_carrier_errorstx_fifo_errorstx_heartbeat_errorstx_window_errorsrx_compressedtx_compressedrx_nohandlerrtnl_link_statsrx_otherhost_droppedrtnl_link_stats64rtnl_hw_stats64rtnl_link_ifmapifla_bridge_idmax_reasm_lentstampreachable_timeretrans_timeifla_cacheinfoifla_vlan_flagsifla_vlan_qos_mappingifindextunnel_msgifla_vxlan_port_rangeifla_geneve_port_rangevfifla_vf_macifla_vf_broadcastvlanqosifla_vf_vlanvlan_protoifla_vf_vlan_infoifla_vf_tx_ratemin_tx_ratemax_tx_rateifla_vf_rateifla_vf_spoofchkifla_vf_guidifla_vf_link_stateifla_vf_rss_query_enifla_vf_trustvsi_mgr_idvsi_type_idvsi_type_versionifla_port_vsifilter_maskif_stats_msgifla_rmnet_flags_K_SS_MAXSIZESOCK_SNDBUF_LOCKSOCK_RCVBUF_LOCKSOCK_BUF_LOCK_MASKSOCK_TXREHASH_DEFAULTSOCK_TXREHASH_DISABLEDSOCK_TXREHASH_ENABLEDIFALIASZALTIFNAMSIZGENERIC_HDLC_VERSIONCLOCK_DEFAULTCLOCK_EXTCLOCK_INTCLOCK_TXINTCLOCK_TXFROMRXENCODING_DEFAULTENCODING_NRZENCODING_NRZIENCODING_FM_MARKENCODING_FM_SPACEENCODING_MANCHESTERPARITY_DEFAULTPARITY_NONEPARITY_CRC16_PR0PARITY_CRC16_PR1PARITY_CRC16_PR0_CCITTPARITY_CRC16_PR1_CCITTPARITY_CRC32_PR0_CCITTPARITY_CRC32_PR1_CCITTLMI_DEFAULTLMI_NONELMI_ANSILMI_CCITTLMI_CISCOIF_GET_IFACEIF_GET_PROTOIF_IFACE_V35IF_IFACE_V24IF_IFACE_X21IF_IFACE_T1IF_IFACE_E1IF_IFACE_SYNC_SERIALIF_IFACE_X21DIF_PROTO_HDLCIF_PROTO_PPPIF_PROTO_CISCOIF_PROTO_FRIF_PROTO_FR_ADD_PVCIF_PROTO_FR_DEL_PVCIF_PROTO_X25IF_PROTO_HDLC_ETHIF_PROTO_FR_ADD_ETH_PVCIF_PROTO_FR_DEL_ETH_PVCIF_PROTO_FR_PVCIF_PROTO_FR_ETH_PVCIF_PROTO_RAWIFHWADDRLENETH_TLENETH_P_ERSPAN2ETH_P_ERSPANETH_P_PROFINETETH_P_REALTEKETH_P_ETHERCATETH_P_PREAUTHETH_P_LLDPETH_P_MRPETH_P_CFMETH_P_IBOEETH_P_NSHETH_P_DSA_8021QETH_P_DSA_A5PSWETH_P_IFEETH_P_CANXLETH_P_MAPETH_P_MCTPPACKET_FASTROUTETP_STATUS_GSO_TCPNETLINK_SMCNLMSG_ALIGNTONL_MMAP_MSG_ALIGNMENTNET_MAJORMACVLAN_FLAG_NOPROMISCMACVLAN_FLAG_NODSTIPVLAN_F_PRIVATEIPVLAN_F_VEPATUNNEL_MSG_FLAG_STATSTUNNEL_MSG_VALID_USER_FLAGSMAX_VLAN_LIST_LENPORT_PROFILE_MAXPORT_UUID_MAXPORT_SELF_VFXDP_FLAGS_UPDATE_IF_NOEXISTXDP_FLAGS_SKB_MODEXDP_FLAGS_DRV_MODEXDP_FLAGS_HW_MODEXDP_FLAGS_REPLACEXDP_FLAGS_MODESXDP_FLAGS_MASKRMNET_FLAGS_INGRESS_DEAGGREGATIONRMNET_FLAGS_INGRESS_MAP_COMMANDSRMNET_FLAGS_INGRESS_MAP_CKSUMV4RMNET_FLAGS_EGRESS_MAP_CKSUMV4RMNET_FLAGS_INGRESS_MAP_CKSUMV5RMNET_FLAGS_EGRESS_MAP_CKSUMV5INIT_NETDEV_GROUPNET_NAME_UNKNOWNNET_NAME_ENUMNET_NAME_PREDICTABLENET_NAME_USERNET_NAME_RENAMEDNET_ADDR_PERMNET_ADDR_RANDOMNET_ADDR_STOLENNET_ADDR_SETARPHRD_MCTPARPHRD_RAWIPARPHRD_IEEE802154_MONITORARPHRD_PHONETARPHRD_PHONET_PIPEARPHRD_CAIFARPHRD_IP6GREARPHRD_NETLINKARPHRD_6LOWPANARPHRD_VSOCKMON_bindgen_ty_2NETLINK_UNCONNECTED_bindgen_ty_3NETLINK_CONNECTED_bindgen_ty_4IFLA_DPLL_PINIFLA_MAX_PACING_OFFLOAD_HORIZONIFLA_NETNS_IMMUTABLE__IFLA_MAXIFLA_PROTO_DOWN_REASON_UNSPEC_bindgen_ty_5IFLA_PROTO_DOWN_REASON_MASKIFLA_PROTO_DOWN_REASON_VALUE__IFLA_PROTO_DOWN_REASON_CNTIFLA_PROTO_DOWN_REASON_MAXIFLA_INET_UNSPEC_bindgen_ty_6IFLA_INET_CONF__IFLA_INET_MAXIFLA_INET6_UNSPEC_bindgen_ty_7IFLA_INET6_FLAGSIFLA_INET6_CONFIFLA_INET6_STATSIFLA_INET6_MCASTIFLA_INET6_CACHEINFOIFLA_INET6_ICMP6STATSIFLA_INET6_TOKENIFLA_INET6_ADDR_GEN_MODEIFLA_INET6_RA_MTU__IFLA_INET6_MAXIFLA_BR_UNSPEC_bindgen_ty_8IFLA_BR_FORWARD_DELAYIFLA_BR_HELLO_TIMEIFLA_BR_MAX_AGEIFLA_BR_AGEING_TIMEIFLA_BR_STP_STATEIFLA_BR_PRIORITYIFLA_BR_VLAN_FILTERINGIFLA_BR_VLAN_PROTOCOLIFLA_BR_GROUP_FWD_MASKIFLA_BR_ROOT_IDIFLA_BR_BRIDGE_IDIFLA_BR_ROOT_PORTIFLA_BR_ROOT_PATH_COSTIFLA_BR_TOPOLOGY_CHANGEIFLA_BR_TOPOLOGY_CHANGE_DETECTEDIFLA_BR_HELLO_TIMERIFLA_BR_TCN_TIMERIFLA_BR_TOPOLOGY_CHANGE_TIMERIFLA_BR_GC_TIMERIFLA_BR_GROUP_ADDRIFLA_BR_FDB_FLUSHIFLA_BR_MCAST_ROUTERIFLA_BR_MCAST_SNOOPINGIFLA_BR_MCAST_QUERY_USE_IFADDRIFLA_BR_MCAST_QUERIERIFLA_BR_MCAST_HASH_ELASTICITYIFLA_BR_MCAST_HASH_MAXIFLA_BR_MCAST_LAST_MEMBER_CNTIFLA_BR_MCAST_STARTUP_QUERY_CNTIFLA_BR_MCAST_LAST_MEMBER_INTVLIFLA_BR_MCAST_MEMBERSHIP_INTVLIFLA_BR_MCAST_QUERIER_INTVLIFLA_BR_MCAST_QUERY_INTVLIFLA_BR_MCAST_QUERY_RESPONSE_INTVLIFLA_BR_MCAST_STARTUP_QUERY_INTVLIFLA_BR_NF_CALL_IPTABLESIFLA_BR_NF_CALL_IP6TABLESIFLA_BR_NF_CALL_ARPTABLESIFLA_BR_VLAN_DEFAULT_PVIDIFLA_BR_PADIFLA_BR_VLAN_STATS_ENABLEDIFLA_BR_MCAST_STATS_ENABLEDIFLA_BR_MCAST_IGMP_VERSIONIFLA_BR_MCAST_MLD_VERSIONIFLA_BR_VLAN_STATS_PER_PORTIFLA_BR_MULTI_BOOLOPTIFLA_BR_MCAST_QUERIER_STATEIFLA_BR_FDB_N_LEARNEDIFLA_BR_FDB_MAX_LEARNED__IFLA_BR_MAXBRIDGE_MODE_UNSPEC_bindgen_ty_9BRIDGE_MODE_HAIRPINIFLA_BRPORT_UNSPEC_bindgen_ty_10IFLA_BRPORT_STATEIFLA_BRPORT_PRIORITYIFLA_BRPORT_COSTIFLA_BRPORT_MODEIFLA_BRPORT_GUARDIFLA_BRPORT_PROTECTIFLA_BRPORT_FAST_LEAVEIFLA_BRPORT_LEARNINGIFLA_BRPORT_UNICAST_FLOODIFLA_BRPORT_PROXYARPIFLA_BRPORT_LEARNING_SYNCIFLA_BRPORT_PROXYARP_WIFIIFLA_BRPORT_ROOT_IDIFLA_BRPORT_BRIDGE_IDIFLA_BRPORT_DESIGNATED_PORTIFLA_BRPORT_DESIGNATED_COSTIFLA_BRPORT_IDIFLA_BRPORT_NOIFLA_BRPORT_TOPOLOGY_CHANGE_ACKIFLA_BRPORT_CONFIG_PENDINGIFLA_BRPORT_MESSAGE_AGE_TIMERIFLA_BRPORT_FORWARD_DELAY_TIMERIFLA_BRPORT_HOLD_TIMERIFLA_BRPORT_FLUSHIFLA_BRPORT_MULTICAST_ROUTERIFLA_BRPORT_PADIFLA_BRPORT_MCAST_FLOODIFLA_BRPORT_MCAST_TO_UCASTIFLA_BRPORT_VLAN_TUNNELIFLA_BRPORT_BCAST_FLOODIFLA_BRPORT_GROUP_FWD_MASKIFLA_BRPORT_NEIGH_SUPPRESSIFLA_BRPORT_ISOLATEDIFLA_BRPORT_BACKUP_PORTIFLA_BRPORT_MRP_RING_OPENIFLA_BRPORT_MRP_IN_OPENIFLA_BRPORT_MCAST_EHT_HOSTS_LIMITIFLA_BRPORT_MCAST_EHT_HOSTS_CNTIFLA_BRPORT_LOCKEDIFLA_BRPORT_MABIFLA_BRPORT_MCAST_N_GROUPSIFLA_BRPORT_MCAST_MAX_GROUPSIFLA_BRPORT_NEIGH_VLAN_SUPPRESSIFLA_BRPORT_BACKUP_NHID__IFLA_BRPORT_MAX_bindgen_ty_11__IFLA_INFO_MAXIFLA_VLAN_UNSPEC_bindgen_ty_12IFLA_VLAN_IDIFLA_VLAN_FLAGSIFLA_VLAN_EGRESS_QOSIFLA_VLAN_INGRESS_QOSIFLA_VLAN_PROTOCOL__IFLA_VLAN_MAXIFLA_VLAN_QOS_UNSPEC_bindgen_ty_13IFLA_VLAN_QOS_MAPPING__IFLA_VLAN_QOS_MAXIFLA_MACVLAN_UNSPEC_bindgen_ty_14IFLA_MACVLAN_MODEIFLA_MACVLAN_FLAGSIFLA_MACVLAN_MACADDR_MODEIFLA_MACVLAN_MACADDRIFLA_MACVLAN_MACADDR_DATAIFLA_MACVLAN_MACADDR_COUNTIFLA_MACVLAN_BC_QUEUE_LENIFLA_MACVLAN_BC_QUEUE_LEN_USEDIFLA_MACVLAN_BC_CUTOFF__IFLA_MACVLAN_MAXIFLA_VRF_UNSPEC_bindgen_ty_15IFLA_VRF_TABLE__IFLA_VRF_MAXIFLA_VRF_PORT_UNSPEC_bindgen_ty_16IFLA_VRF_PORT_TABLE__IFLA_VRF_PORT_MAXIFLA_MACSEC_UNSPEC_bindgen_ty_17IFLA_MACSEC_SCIIFLA_MACSEC_PORTIFLA_MACSEC_ICV_LENIFLA_MACSEC_CIPHER_SUITEIFLA_MACSEC_WINDOWIFLA_MACSEC_ENCODING_SAIFLA_MACSEC_ENCRYPTIFLA_MACSEC_PROTECTIFLA_MACSEC_INC_SCIIFLA_MACSEC_ESIFLA_MACSEC_SCBIFLA_MACSEC_REPLAY_PROTECTIFLA_MACSEC_VALIDATIONIFLA_MACSEC_PADIFLA_MACSEC_OFFLOAD__IFLA_MACSEC_MAXIFLA_XFRM_UNSPEC_bindgen_ty_18IFLA_XFRM_LINKIFLA_XFRM_IF_IDIFLA_XFRM_COLLECT_METADATA__IFLA_XFRM_MAXIFLA_IPVLAN_UNSPEC_bindgen_ty_19IFLA_IPVLAN_MODEIFLA_IPVLAN_FLAGS__IFLA_IPVLAN_MAXIFLA_NETKIT_UNSPEC_bindgen_ty_20IFLA_NETKIT_PEER_INFOIFLA_NETKIT_PRIMARYIFLA_NETKIT_POLICYIFLA_NETKIT_PEER_POLICYIFLA_NETKIT_MODEIFLA_NETKIT_SCRUBIFLA_NETKIT_PEER_SCRUBIFLA_NETKIT_HEADROOMIFLA_NETKIT_TAILROOM__IFLA_NETKIT_MAXVNIFILTER_ENTRY_STATS_UNSPEC_bindgen_ty_21VNIFILTER_ENTRY_STATS_RX_BYTESVNIFILTER_ENTRY_STATS_RX_PKTSVNIFILTER_ENTRY_STATS_RX_DROPSVNIFILTER_ENTRY_STATS_RX_ERRORSVNIFILTER_ENTRY_STATS_TX_BYTESVNIFILTER_ENTRY_STATS_TX_PKTSVNIFILTER_ENTRY_STATS_TX_DROPSVNIFILTER_ENTRY_STATS_TX_ERRORSVNIFILTER_ENTRY_STATS_PAD__VNIFILTER_ENTRY_STATS_MAXVXLAN_VNIFILTER_ENTRY_UNSPEC_bindgen_ty_22VXLAN_VNIFILTER_ENTRY_STARTVXLAN_VNIFILTER_ENTRY_ENDVXLAN_VNIFILTER_ENTRY_GROUPVXLAN_VNIFILTER_ENTRY_GROUP6VXLAN_VNIFILTER_ENTRY_STATS__VXLAN_VNIFILTER_ENTRY_MAXVXLAN_VNIFILTER_UNSPEC_bindgen_ty_23VXLAN_VNIFILTER_ENTRY__VXLAN_VNIFILTER_MAXIFLA_VXLAN_UNSPEC_bindgen_ty_24IFLA_VXLAN_IDIFLA_VXLAN_GROUPIFLA_VXLAN_LINKIFLA_VXLAN_LOCALIFLA_VXLAN_TTLIFLA_VXLAN_TOSIFLA_VXLAN_LEARNINGIFLA_VXLAN_AGEINGIFLA_VXLAN_LIMITIFLA_VXLAN_PORT_RANGEIFLA_VXLAN_PROXYIFLA_VXLAN_RSCIFLA_VXLAN_L2MISSIFLA_VXLAN_L3MISSIFLA_VXLAN_PORTIFLA_VXLAN_GROUP6IFLA_VXLAN_LOCAL6IFLA_VXLAN_UDP_CSUMIFLA_VXLAN_UDP_ZERO_CSUM6_TXIFLA_VXLAN_UDP_ZERO_CSUM6_RXIFLA_VXLAN_REMCSUM_TXIFLA_VXLAN_REMCSUM_RXIFLA_VXLAN_GBPIFLA_VXLAN_REMCSUM_NOPARTIALIFLA_VXLAN_COLLECT_METADATAIFLA_VXLAN_LABELIFLA_VXLAN_GPEIFLA_VXLAN_TTL_INHERITIFLA_VXLAN_DFIFLA_VXLAN_VNIFILTERIFLA_VXLAN_LOCALBYPASSIFLA_VXLAN_LABEL_POLICYIFLA_VXLAN_RESERVED_BITS__IFLA_VXLAN_MAXIFLA_GENEVE_UNSPEC_bindgen_ty_25IFLA_GENEVE_IDIFLA_GENEVE_REMOTEIFLA_GENEVE_TTLIFLA_GENEVE_TOSIFLA_GENEVE_PORTIFLA_GENEVE_COLLECT_METADATAIFLA_GENEVE_REMOTE6IFLA_GENEVE_UDP_CSUMIFLA_GENEVE_UDP_ZERO_CSUM6_TXIFLA_GENEVE_UDP_ZERO_CSUM6_RXIFLA_GENEVE_LABELIFLA_GENEVE_TTL_INHERITIFLA_GENEVE_DFIFLA_GENEVE_INNER_PROTO_INHERITIFLA_GENEVE_PORT_RANGE__IFLA_GENEVE_MAXIFLA_BAREUDP_UNSPEC_bindgen_ty_26IFLA_BAREUDP_PORTIFLA_BAREUDP_ETHERTYPEIFLA_BAREUDP_SRCPORT_MINIFLA_BAREUDP_MULTIPROTO_MODE__IFLA_BAREUDP_MAXIFLA_PPP_UNSPEC_bindgen_ty_27IFLA_PPP_DEV_FD__IFLA_PPP_MAXIFLA_GTP_UNSPEC_bindgen_ty_28IFLA_GTP_FD0IFLA_GTP_FD1IFLA_GTP_PDP_HASHSIZEIFLA_GTP_ROLEIFLA_GTP_CREATE_SOCKETSIFLA_GTP_RESTART_COUNTIFLA_GTP_LOCALIFLA_GTP_LOCAL6__IFLA_GTP_MAXIFLA_BOND_UNSPEC_bindgen_ty_29IFLA_BOND_MODEIFLA_BOND_ACTIVE_SLAVEIFLA_BOND_MIIMONIFLA_BOND_UPDELAYIFLA_BOND_DOWNDELAYIFLA_BOND_USE_CARRIERIFLA_BOND_ARP_INTERVALIFLA_BOND_ARP_IP_TARGETIFLA_BOND_ARP_VALIDATEIFLA_BOND_ARP_ALL_TARGETSIFLA_BOND_PRIMARYIFLA_BOND_PRIMARY_RESELECTIFLA_BOND_FAIL_OVER_MACIFLA_BOND_XMIT_HASH_POLICYIFLA_BOND_RESEND_IGMPIFLA_BOND_NUM_PEER_NOTIFIFLA_BOND_ALL_SLAVES_ACTIVEIFLA_BOND_MIN_LINKSIFLA_BOND_LP_INTERVALIFLA_BOND_PACKETS_PER_SLAVEIFLA_BOND_AD_LACP_RATEIFLA_BOND_AD_SELECTIFLA_BOND_AD_INFOIFLA_BOND_AD_ACTOR_SYS_PRIOIFLA_BOND_AD_USER_PORT_KEYIFLA_BOND_AD_ACTOR_SYSTEMIFLA_BOND_TLB_DYNAMIC_LBIFLA_BOND_PEER_NOTIF_DELAYIFLA_BOND_AD_LACP_ACTIVEIFLA_BOND_MISSED_MAXIFLA_BOND_NS_IP6_TARGETIFLA_BOND_COUPLED_CONTROL__IFLA_BOND_MAXIFLA_BOND_AD_INFO_UNSPEC_bindgen_ty_30IFLA_BOND_AD_INFO_AGGREGATORIFLA_BOND_AD_INFO_NUM_PORTSIFLA_BOND_AD_INFO_ACTOR_KEYIFLA_BOND_AD_INFO_PARTNER_KEYIFLA_BOND_AD_INFO_PARTNER_MAC__IFLA_BOND_AD_INFO_MAXIFLA_BOND_SLAVE_UNSPEC_bindgen_ty_31IFLA_BOND_SLAVE_STATEIFLA_BOND_SLAVE_MII_STATUSIFLA_BOND_SLAVE_LINK_FAILURE_COUNTIFLA_BOND_SLAVE_PERM_HWADDRIFLA_BOND_SLAVE_QUEUE_IDIFLA_BOND_SLAVE_AD_AGGREGATOR_IDIFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATEIFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATEIFLA_BOND_SLAVE_PRIO__IFLA_BOND_SLAVE_MAXIFLA_VF_INFO_UNSPEC_bindgen_ty_32IFLA_VF_INFO__IFLA_VF_INFO_MAXIFLA_VF_UNSPEC_bindgen_ty_33IFLA_VF_MACIFLA_VF_VLANIFLA_VF_TX_RATEIFLA_VF_SPOOFCHKIFLA_VF_LINK_STATEIFLA_VF_RATEIFLA_VF_RSS_QUERY_ENIFLA_VF_STATSIFLA_VF_TRUSTIFLA_VF_IB_NODE_GUIDIFLA_VF_IB_PORT_GUIDIFLA_VF_VLAN_LISTIFLA_VF_BROADCAST__IFLA_VF_MAXIFLA_VF_VLAN_INFO_UNSPEC_bindgen_ty_34IFLA_VF_VLAN_INFO__IFLA_VF_VLAN_INFO_MAXIFLA_VF_LINK_STATE_AUTO_bindgen_ty_35IFLA_VF_LINK_STATE_ENABLEIFLA_VF_LINK_STATE_DISABLE__IFLA_VF_LINK_STATE_MAXIFLA_VF_STATS_RX_PACKETS_bindgen_ty_36IFLA_VF_STATS_TX_PACKETSIFLA_VF_STATS_RX_BYTESIFLA_VF_STATS_TX_BYTESIFLA_VF_STATS_BROADCASTIFLA_VF_STATS_MULTICASTIFLA_VF_STATS_PADIFLA_VF_STATS_RX_DROPPEDIFLA_VF_STATS_TX_DROPPED__IFLA_VF_STATS_MAXIFLA_VF_PORT_UNSPEC_bindgen_ty_37IFLA_VF_PORT__IFLA_VF_PORT_MAXIFLA_PORT_UNSPEC_bindgen_ty_38IFLA_PORT_VFIFLA_PORT_PROFILEIFLA_PORT_VSI_TYPEIFLA_PORT_INSTANCE_UUIDIFLA_PORT_HOST_UUIDIFLA_PORT_REQUESTIFLA_PORT_RESPONSE__IFLA_PORT_MAXPORT_REQUEST_PREASSOCIATE_bindgen_ty_39PORT_REQUEST_PREASSOCIATE_RRPORT_REQUEST_ASSOCIATEPORT_REQUEST_DISASSOCIATEPORT_VDP_RESPONSE_SUCCESS_bindgen_ty_40PORT_VDP_RESPONSE_INVALID_FORMATPORT_VDP_RESPONSE_INSUFFICIENT_RESOURCESPORT_VDP_RESPONSE_UNUSED_VTIDPORT_VDP_RESPONSE_VTID_VIOLATIONPORT_VDP_RESPONSE_VTID_VERSION_VIOALTIONPORT_VDP_RESPONSE_OUT_OF_SYNCPORT_PROFILE_RESPONSE_SUCCESSPORT_PROFILE_RESPONSE_INPROGRESSPORT_PROFILE_RESPONSE_INVALIDPORT_PROFILE_RESPONSE_BADSTATEPORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCESPORT_PROFILE_RESPONSE_ERRORIFLA_IPOIB_UNSPEC_bindgen_ty_41IFLA_IPOIB_PKEYIFLA_IPOIB_MODEIFLA_IPOIB_UMCAST__IFLA_IPOIB_MAXIPOIB_MODE_DATAGRAM_bindgen_ty_42IPOIB_MODE_CONNECTEDHSR_PROTOCOL_HSR_bindgen_ty_43HSR_PROTOCOL_PRPHSR_PROTOCOL_MAXIFLA_HSR_UNSPEC_bindgen_ty_44IFLA_HSR_SLAVE1IFLA_HSR_SLAVE2IFLA_HSR_MULTICAST_SPECIFLA_HSR_SUPERVISION_ADDRIFLA_HSR_SEQ_NRIFLA_HSR_VERSIONIFLA_HSR_PROTOCOLIFLA_HSR_INTERLINK__IFLA_HSR_MAXIFLA_STATS_UNSPEC_bindgen_ty_45IFLA_STATS_LINK_64IFLA_STATS_LINK_XSTATSIFLA_STATS_LINK_XSTATS_SLAVEIFLA_STATS_LINK_OFFLOAD_XSTATSIFLA_STATS_AF_SPEC__IFLA_STATS_MAXIFLA_STATS_GETSET_UNSPEC_bindgen_ty_46IFLA_STATS_GET_FILTERSIFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS__IFLA_STATS_GETSET_MAXLINK_XSTATS_TYPE_UNSPEC_bindgen_ty_47LINK_XSTATS_TYPE_BRIDGELINK_XSTATS_TYPE_BOND__LINK_XSTATS_TYPE_MAXIFLA_OFFLOAD_XSTATS_UNSPEC_bindgen_ty_48IFLA_OFFLOAD_XSTATS_CPU_HITIFLA_OFFLOAD_XSTATS_HW_S_INFOIFLA_OFFLOAD_XSTATS_L3_STATS__IFLA_OFFLOAD_XSTATS_MAXIFLA_OFFLOAD_XSTATS_HW_S_INFO_UNSPEC_bindgen_ty_49IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUESTIFLA_OFFLOAD_XSTATS_HW_S_INFO_USED__IFLA_OFFLOAD_XSTATS_HW_S_INFO_MAXXDP_ATTACHED_NONE_bindgen_ty_50XDP_ATTACHED_DRVXDP_ATTACHED_SKBXDP_ATTACHED_HWXDP_ATTACHED_MULTIIFLA_XDP_UNSPEC_bindgen_ty_51IFLA_XDP_FDIFLA_XDP_ATTACHEDIFLA_XDP_FLAGSIFLA_XDP_PROG_IDIFLA_XDP_DRV_PROG_IDIFLA_XDP_SKB_PROG_IDIFLA_XDP_HW_PROG_IDIFLA_XDP_EXPECTED_FD__IFLA_XDP_MAXIFLA_EVENT_NONE_bindgen_ty_52IFLA_EVENT_REBOOTIFLA_EVENT_FEATURESIFLA_EVENT_BONDING_FAILOVERIFLA_EVENT_NOTIFY_PEERSIFLA_EVENT_IGMP_RESENDIFLA_EVENT_BONDING_OPTIONSIFLA_TUN_UNSPEC_bindgen_ty_53IFLA_TUN_OWNERIFLA_TUN_GROUPIFLA_TUN_TYPEIFLA_TUN_PIIFLA_TUN_VNET_HDRIFLA_TUN_PERSISTIFLA_TUN_MULTI_QUEUEIFLA_TUN_NUM_QUEUESIFLA_TUN_NUM_DISABLED_QUEUES__IFLA_TUN_MAXIFLA_RMNET_UNSPEC_bindgen_ty_54IFLA_RMNET_MUX_IDIFLA_RMNET_FLAGS__IFLA_RMNET_MAXIFLA_MCTP_UNSPEC_bindgen_ty_55IFLA_MCTP_NETIFLA_MCTP_PHYS_BINDING__IFLA_MCTP_MAXIFLA_DSA_UNSPEC_bindgen_ty_56IFLA_DSA_CONDUITIFLA_DSA_MASTER__IFLA_DSA_MAXIFLA_OVPN_UNSPEC_bindgen_ty_57IFLA_OVPN_MODE__IFLA_OVPN_MAXIF_PORT_UNKNOWN_bindgen_ty_58IF_PORT_10BASE2IF_PORT_10BASETIF_PORT_AUIIF_PORT_100BASETIF_PORT_100BASETXIF_PORT_100BASEFXnet_device_flagsnlmsgerr_attrsNLMSGERR_ATTR_UNUSEDNLMSGERR_ATTR_MSGNLMSGERR_ATTR_OFFSNLMSGERR_ATTR_COOKIENLMSGERR_ATTR_POLICYNLMSGERR_ATTR_MISS_TYPENLMSGERR_ATTR_MISS_NEST__NLMSGERR_ATTR_MAXnl_mmap_statusNL_MMAP_STATUS_UNUSEDNL_MMAP_STATUS_RESERVEDNL_MMAP_STATUS_VALIDNL_MMAP_STATUS_COPYNL_MMAP_STATUS_SKIPnetlink_attribute_typeNL_ATTR_TYPE_INVALIDNL_ATTR_TYPE_FLAGNL_ATTR_TYPE_U8NL_ATTR_TYPE_U16NL_ATTR_TYPE_U32NL_ATTR_TYPE_U64NL_ATTR_TYPE_S8NL_ATTR_TYPE_S16NL_ATTR_TYPE_S32NL_ATTR_TYPE_S64NL_ATTR_TYPE_BINARYNL_ATTR_TYPE_STRINGNL_ATTR_TYPE_NUL_STRINGNL_ATTR_TYPE_NESTEDNL_ATTR_TYPE_NESTED_ARRAYNL_ATTR_TYPE_BITFIELD32NL_ATTR_TYPE_SINTNL_ATTR_TYPE_UINTnetlink_policy_type_attrNL_POLICY_TYPE_ATTR_UNSPECNL_POLICY_TYPE_ATTR_TYPENL_POLICY_TYPE_ATTR_MIN_VALUE_SNL_POLICY_TYPE_ATTR_MAX_VALUE_SNL_POLICY_TYPE_ATTR_MIN_VALUE_UNL_POLICY_TYPE_ATTR_MAX_VALUE_UNL_POLICY_TYPE_ATTR_MIN_LENGTHNL_POLICY_TYPE_ATTR_MAX_LENGTHNL_POLICY_TYPE_ATTR_POLICY_IDXNL_POLICY_TYPE_ATTR_POLICY_MAXTYPENL_POLICY_TYPE_ATTR_BITFIELD32_MASKNL_POLICY_TYPE_ATTR_PADNL_POLICY_TYPE_ATTR_MASK__NL_POLICY_TYPE_ATTR_MAXin6_addr_gen_modeIN6_ADDR_GEN_MODE_EUI64IN6_ADDR_GEN_MODE_NONEIN6_ADDR_GEN_MODE_STABLE_PRIVACYIN6_ADDR_GEN_MODE_RANDOMmacvlan_modeMACVLAN_MODE_PRIVATEMACVLAN_MODE_VEPAMACVLAN_MODE_BRIDGEMACVLAN_MODE_PASSTHRUMACVLAN_MODE_SOURCEmacvlan_macaddr_modeMACVLAN_MACADDR_ADDMACVLAN_MACADDR_DELMACVLAN_MACADDR_FLUSHMACVLAN_MACADDR_SETmacsec_validation_typeMACSEC_VALIDATE_DISABLEDMACSEC_VALIDATE_CHECKMACSEC_VALIDATE_STRICT__MACSEC_VALIDATE_ENDmacsec_offloadMACSEC_OFFLOAD_OFFMACSEC_OFFLOAD_PHYMACSEC_OFFLOAD_MAC__MACSEC_OFFLOAD_ENDipvlan_modeIPVLAN_MODE_L2IPVLAN_MODE_L3IPVLAN_MODE_L3SIPVLAN_MODE_MAXnetkit_actionNETKIT_NEXTNETKIT_PASSNETKIT_DROPNETKIT_REDIRECTnetkit_modeNETKIT_L2NETKIT_L3netkit_scrubNETKIT_SCRUB_NONENETKIT_SCRUB_DEFAULTifla_vxlan_dfVXLAN_DF_UNSETVXLAN_DF_SETVXLAN_DF_INHERIT__VXLAN_DF_ENDifla_vxlan_label_policyVXLAN_LABEL_FIXEDVXLAN_LABEL_INHERIT__VXLAN_LABEL_ENDifla_geneve_dfGENEVE_DF_UNSETGENEVE_DF_SETGENEVE_DF_INHERIT__GENEVE_DF_ENDifla_gtp_roleGTP_ROLE_GGSNGTP_ROLE_SGSNovpn_modeOVPN_MODE_P2POVPN_MODE_MP__alignraw_hdlcciscofr_pvcfr_pvc_infox25te1ifru_ivalueifru_settingstpacket_stats_ustats1stats3ts_nsecNLMSGERR_ATTR_MAXNL_POLICY_TYPE_ATTR_MAXMACSEC_VALIDATE_MAXMACSEC_OFFLOAD_MAXVXLAN_DF_MAXVXLAN_LABEL_MAXGENEVE_DF_MAXcode0code1text_offsetres2res3res4res5arm64_image_headerARM64_IMAGE_MAGICARM64_IMAGE_FLAG_BE_SHIFTARM64_IMAGE_FLAG_PAGE_SIZE_SHIFTARM64_IMAGE_FLAG_PHYS_BASE_SHIFTARM64_IMAGE_FLAG_BE_MASKARM64_IMAGE_FLAG_PAGE_SIZE_MASKARM64_IMAGE_FLAG_PHYS_BASE_MASKARM64_IMAGE_FLAG_LEARM64_IMAGE_FLAG_BEARM64_IMAGE_FLAG_PAGE_SIZE_4KARM64_IMAGE_FLAG_PAGE_SIZE_16KARM64_IMAGE_FLAG_PAGE_SIZE_64KARM64_IMAGE_FLAG_PHYS_BASE__BindgenUnionFieldioprioio_uring_sqe__bindgen_ty_1io_uring_sqe__bindgen_ty_2__bindgen_anon_3io_uring_sqe__bindgen_ty_3__bindgen_anon_4io_uring_sqe__bindgen_ty_4__bindgen_anon_5io_uring_sqe__bindgen_ty_5__bindgen_anon_6io_uring_sqe__bindgen_ty_6io_uring_sqecmd_opio_uring_sqe__bindgen_ty_1__bindgen_ty_1optnameio_uring_sqe__bindgen_ty_2__bindgen_ty_1addr_len__pad3io_uring_sqe__bindgen_ty_5__bindgen_ty_1write_stream__pad4io_uring_sqe__bindgen_ty_5__bindgen_ty_2io_uring_sqe__bindgen_ty_6__bindgen_ty_1io_uring_sqe__bindgen_ty_6__bindgen_ty_2optval0usizebindgen_union_fieldaddr3attr_ptrattr_type_maskapp_tagrsvdio_uring_attr_pibig_cqeio_uring_cqering_maskring_entriesresv1user_addrio_sqring_offsetscqesio_cqring_offsetssq_entriescq_entriessq_thread_cpusq_thread_idlewq_fdresvsq_offcq_offio_uring_paramsfdsio_uring_files_updatemmap_offset__resvio_uring_region_descregion_uptrio_uring_mem_region_regresv2io_uring_rsrc_registerio_uring_rsrc_updateio_uring_rsrc_update2io_uring_probe_oplast_opops_lenio_uring_probeio_uring_restriction__bindgen_ty_1io_uring_restrictionio_uring_clock_registersrc_offdst_offio_uring_clone_buffersbidio_uring_bufio_uring_buf_ring__bindgen_ty_1io_uring_buf_ringio_uring_buf_ring__bindgen_ty_1__bindgen_ty_1io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2resv3__empty_bufsio_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1ring_addrbgidio_uring_buf_regbuf_groupio_uring_buf_statusbusy_poll_toop_paramio_uring_napimin_wait_usecsigmasksigmask_szio_uring_reg_waitio_uring_getevents_argio_uring_sync_cancel_regio_uring_file_index_rangecontrollenpayloadlenio_uring_recvmsg_outio_uring_zcrx_rqeio_uring_zcrx_cqerqes__resv2io_uring_zcrx_offsetsrq_area_tokendmabuf_fdio_uring_zcrx_area_regif_idxif_rxqrq_entriesarea_ptrregion_ptrzcrx_idio_uring_zcrx_ifq_regIORING_RW_ATTR_FLAG_PIIORING_FILE_INDEX_ALLOCIORING_SETUP_IOPOLLIORING_SETUP_SQPOLLIORING_SETUP_SQ_AFFIORING_SETUP_CQSIZEIORING_SETUP_CLAMPIORING_SETUP_ATTACH_WQIORING_SETUP_R_DISABLEDIORING_SETUP_SUBMIT_ALLIORING_SETUP_COOP_TASKRUNIORING_SETUP_TASKRUN_FLAGIORING_SETUP_SQE128IORING_SETUP_CQE32IORING_SETUP_SINGLE_ISSUERIORING_SETUP_DEFER_TASKRUNIORING_SETUP_NO_MMAPIORING_SETUP_REGISTERED_FD_ONLYIORING_SETUP_NO_SQARRAYIORING_SETUP_HYBRID_IOPOLLIORING_URING_CMD_FIXEDIORING_URING_CMD_MASKIORING_FSYNC_DATASYNCIORING_TIMEOUT_ABSIORING_TIMEOUT_UPDATEIORING_TIMEOUT_BOOTTIMEIORING_TIMEOUT_REALTIMEIORING_LINK_TIMEOUT_UPDATEIORING_TIMEOUT_ETIME_SUCCESSIORING_TIMEOUT_MULTISHOTIORING_TIMEOUT_CLOCK_MASKIORING_TIMEOUT_UPDATE_MASKSPLICE_F_FD_IN_FIXEDIORING_POLL_ADD_MULTIIORING_POLL_UPDATE_EVENTSIORING_POLL_UPDATE_USER_DATAIORING_POLL_ADD_LEVELIORING_ASYNC_CANCEL_ALLIORING_ASYNC_CANCEL_FDIORING_ASYNC_CANCEL_ANYIORING_ASYNC_CANCEL_FD_FIXEDIORING_ASYNC_CANCEL_USERDATAIORING_ASYNC_CANCEL_OPIORING_RECVSEND_POLL_FIRSTIORING_RECV_MULTISHOTIORING_RECVSEND_FIXED_BUFIORING_SEND_ZC_REPORT_USAGEIORING_RECVSEND_BUNDLEIORING_NOTIF_USAGE_ZC_COPIEDIORING_ACCEPT_MULTISHOTIORING_ACCEPT_DONTWAITIORING_ACCEPT_POLL_FIRSTIORING_MSG_RING_CQE_SKIPIORING_MSG_RING_FLAGS_PASSIORING_FIXED_FD_NO_CLOEXECIORING_NOP_INJECT_RESULTIORING_NOP_FILEIORING_NOP_FIXED_FILEIORING_NOP_FIXED_BUFFERIORING_CQE_F_BUFFERIORING_CQE_F_MOREIORING_CQE_F_SOCK_NONEMPTYIORING_CQE_F_NOTIFIORING_CQE_F_BUF_MOREIORING_CQE_BUFFER_SHIFTIORING_OFF_SQ_RINGIORING_OFF_CQ_RINGIORING_OFF_SQESIORING_OFF_PBUF_RINGIORING_OFF_PBUF_SHIFTIORING_OFF_MMAP_MASKIORING_SQ_NEED_WAKEUPIORING_SQ_CQ_OVERFLOWIORING_SQ_TASKRUNIORING_CQ_EVENTFD_DISABLEDIORING_ENTER_GETEVENTSIORING_ENTER_SQ_WAKEUPIORING_ENTER_SQ_WAITIORING_ENTER_EXT_ARGIORING_ENTER_REGISTERED_RINGIORING_ENTER_ABS_TIMERIORING_ENTER_EXT_ARG_REGIORING_ENTER_NO_IOWAITIORING_FEAT_SINGLE_MMAPIORING_FEAT_NODROPIORING_FEAT_SUBMIT_STABLEIORING_FEAT_RW_CUR_POSIORING_FEAT_CUR_PERSONALITYIORING_FEAT_FAST_POLLIORING_FEAT_POLL_32BITSIORING_FEAT_SQPOLL_NONFIXEDIORING_FEAT_EXT_ARGIORING_FEAT_NATIVE_WORKERSIORING_FEAT_RSRC_TAGSIORING_FEAT_CQE_SKIPIORING_FEAT_LINKED_FILEIORING_FEAT_REG_REG_RINGIORING_FEAT_RECVSEND_BUNDLEIORING_FEAT_MIN_TIMEOUTIORING_FEAT_RW_ATTRIORING_FEAT_NO_IOWAITIORING_RSRC_REGISTER_SPARSEIORING_REGISTER_FILES_SKIPIO_URING_OP_SUPPORTEDIORING_ZCRX_AREA_SHIFTIORING_MEM_REGION_TYPE_USERIORING_MEM_REGION_REG_WAIT_ARGIORING_REGISTER_SRC_REGISTEREDIORING_REGISTER_DST_REPLACEIORING_REG_WAIT_TSio_uring_sqe_flags_bitIOSQE_FIXED_FILE_BITIOSQE_IO_DRAIN_BITIOSQE_IO_LINK_BITIOSQE_IO_HARDLINK_BITIOSQE_ASYNC_BITIOSQE_BUFFER_SELECT_BITIOSQE_CQE_SKIP_SUCCESS_BITio_uring_opIORING_OP_NOPIORING_OP_READVIORING_OP_WRITEVIORING_OP_FSYNCIORING_OP_READ_FIXEDIORING_OP_WRITE_FIXEDIORING_OP_POLL_ADDIORING_OP_POLL_REMOVEIORING_OP_SYNC_FILE_RANGEIORING_OP_SENDMSGIORING_OP_RECVMSGIORING_OP_TIMEOUTIORING_OP_TIMEOUT_REMOVEIORING_OP_ACCEPTIORING_OP_ASYNC_CANCELIORING_OP_LINK_TIMEOUTIORING_OP_CONNECTIORING_OP_FALLOCATEIORING_OP_OPENATIORING_OP_CLOSEIORING_OP_FILES_UPDATEIORING_OP_STATXIORING_OP_READIORING_OP_WRITEIORING_OP_FADVISEIORING_OP_MADVISEIORING_OP_SENDIORING_OP_RECVIORING_OP_OPENAT2IORING_OP_EPOLL_CTLIORING_OP_SPLICEIORING_OP_PROVIDE_BUFFERSIORING_OP_REMOVE_BUFFERSIORING_OP_TEEIORING_OP_SHUTDOWNIORING_OP_RENAMEATIORING_OP_UNLINKATIORING_OP_MKDIRATIORING_OP_SYMLINKATIORING_OP_LINKATIORING_OP_MSG_RINGIORING_OP_FSETXATTRIORING_OP_SETXATTRIORING_OP_FGETXATTRIORING_OP_GETXATTRIORING_OP_SOCKETIORING_OP_URING_CMDIORING_OP_SEND_ZCIORING_OP_SENDMSG_ZCIORING_OP_READ_MULTISHOTIORING_OP_WAITIDIORING_OP_FUTEX_WAITIORING_OP_FUTEX_WAKEIORING_OP_FUTEX_WAITVIORING_OP_FIXED_FD_INSTALLIORING_OP_FTRUNCATEIORING_OP_BINDIORING_OP_LISTENIORING_OP_RECV_ZCIORING_OP_EPOLL_WAITIORING_OP_READV_FIXEDIORING_OP_WRITEV_FIXEDIORING_OP_PIPEIORING_OP_LASTio_uring_msg_ring_flagsIORING_MSG_DATAIORING_MSG_SEND_FDio_uring_register_opIORING_REGISTER_BUFFERSIORING_UNREGISTER_BUFFERSIORING_REGISTER_FILESIORING_UNREGISTER_FILESIORING_REGISTER_EVENTFDIORING_UNREGISTER_EVENTFDIORING_REGISTER_FILES_UPDATEIORING_REGISTER_EVENTFD_ASYNCIORING_REGISTER_PROBEIORING_REGISTER_PERSONALITYIORING_UNREGISTER_PERSONALITYIORING_REGISTER_RESTRICTIONSIORING_REGISTER_ENABLE_RINGSIORING_REGISTER_FILES2IORING_REGISTER_FILES_UPDATE2IORING_REGISTER_BUFFERS2IORING_REGISTER_BUFFERS_UPDATEIORING_REGISTER_IOWQ_AFFIORING_UNREGISTER_IOWQ_AFFIORING_REGISTER_IOWQ_MAX_WORKERSIORING_REGISTER_RING_FDSIORING_UNREGISTER_RING_FDSIORING_REGISTER_PBUF_RINGIORING_UNREGISTER_PBUF_RINGIORING_REGISTER_SYNC_CANCELIORING_REGISTER_FILE_ALLOC_RANGEIORING_REGISTER_PBUF_STATUSIORING_REGISTER_NAPIIORING_UNREGISTER_NAPIIORING_REGISTER_CLOCKIORING_REGISTER_CLONE_BUFFERSIORING_REGISTER_SEND_MSG_RINGIORING_REGISTER_ZCRX_IFQIORING_REGISTER_RESIZE_RINGSIORING_REGISTER_MEM_REGIONIORING_REGISTER_LASTIORING_REGISTER_USE_REGISTERED_RINGio_wq_typeIO_WQ_BOUNDIO_WQ_UNBOUNDio_uring_register_pbuf_ring_flagsIOU_PBUF_RING_MMAPIOU_PBUF_RING_INCio_uring_napi_opIO_URING_NAPI_REGISTER_OPIO_URING_NAPI_STATIC_ADD_IDIO_URING_NAPI_STATIC_DEL_IDio_uring_napi_tracking_strategyIO_URING_NAPI_TRACKING_DYNAMICIO_URING_NAPI_TRACKING_STATICIO_URING_NAPI_TRACKING_INACTIVEio_uring_register_restriction_opIORING_RESTRICTION_REGISTER_OPIORING_RESTRICTION_SQE_OPIORING_RESTRICTION_SQE_FLAGS_ALLOWEDIORING_RESTRICTION_SQE_FLAGS_REQUIREDIORING_RESTRICTION_LASTio_uring_socket_opSOCKET_URING_OP_SIOCINQSOCKET_URING_OP_SIOCOUTQSOCKET_URING_OP_GETSOCKOPTSOCKET_URING_OP_SETSOCKOPTio_uring_zcrx_area_flagsIORING_ZCRX_AREA_DMABUFaddr2splice_off_inrw_flagspoll32_eventssync_range_flagstimeout_flagsaccept_flagscancel_flagsstatx_flagsfadvise_advicesplice_flagsrename_flagsunlink_flagshardlink_flagsxattr_flagsmsg_ring_flagsuring_cmd_flagswaitid_flagsfutex_flagsinstall_fd_flagsnop_flagspipe_flagsbuf_indexsplice_fd_inzcrx_ifq_idxoptlenregister_opsqe_opsqe_flagsMTIOCGETBLKROSETBLKROGETBLKRRPARTBLKGETSIZEBLKFLSBUFBLKRASETBLKRAGETBLKFRASETBLKFRAGETBLKSECTSETBLKSECTGETBLKPGBLKBSZGETBLKBSZSETBLKGETSIZE64BLKTRACESETUPBLKTRACESTARTBLKTRACESTOPBLKTRACETEARDOWNBLKDISCARDBLKALIGNOFFBLKDISCARDZEROESBLKSECDISCARDBLKROTATIONALBLKZEROOUTFIEMAP_MAX_OFFSETFIEMAP_FLAG_SYNCFIEMAP_FLAG_XATTRFIEMAP_FLAG_CACHEFIEMAP_FLAGS_COMPATFIEMAP_EXTENT_LASTFIEMAP_EXTENT_UNKNOWNFIEMAP_EXTENT_DELALLOCFIEMAP_EXTENT_ENCODEDFIEMAP_EXTENT_DATA_ENCRYPTEDFIEMAP_EXTENT_NOT_ALIGNEDFIEMAP_EXTENT_DATA_INLINEFIEMAP_EXTENT_DATA_TAILFIEMAP_EXTENT_UNWRITTENFIEMAP_EXTENT_MERGEDFIEMAP_EXTENT_SHAREDUFFDIO_REGISTERUFFDIO_UNREGISTERUFFDIO_WAKEUFFDIO_COPYUFFDIO_ZEROPAGEUFFDIO_WRITEPROTECTUFFDIO_APIKDGETLEDKDSETLEDKDGKBLEDKDSKBLEDKDGKBTYPEKDADDIOKDDELIOKDENABIOKDDISABIOKDSETMODEKDGETMODEKDMKTONEKIOCSOUNDGIO_CMAPPIO_CMAPGIO_FONTGIO_FONTXPIO_FONTPIO_FONTXPIO_FONTRESETGIO_SCRNMAPGIO_UNISCRNMAPPIO_SCRNMAPPIO_UNISCRNMAPGIO_UNIMAPPIO_UNIMAPPIO_UNIMAPCLRKDGKBMODEKDSKBMODEKDGKBMETAKDSKBMETAKDGKBENTKDSKBENTKDGKBSENTKDSKBSENTKDGKBDIACRKDGETKEYCODEKDSETKEYCODEKDSIGACCEPTVT_OPENQRYVT_GETMODEVT_SETMODEVT_GETSTATEVT_RELDISPVT_ACTIVATEVT_WAITACTIVEVT_DISALLOCATEVT_RESIZEVT_RESIZEXSIOCATMARKFIGETBSZFIFREEZEFITHAWFITRIMFIDEDUPERANGEFS_IOC_FIEMAPFS_IOC_FSGETXATTRFS_IOC_FSSETXATTRFS_IOC_GETFSLABELFS_IOC_SETFSLABELEXT4_IOC_GETVERSIONEXT4_IOC_SETVERSIONEXT4_IOC_GETVERSION_OLDEXT4_IOC_SETVERSION_OLDEXT4_IOC_GETRSVSZEXT4_IOC_SETRSVSZEXT4_IOC_GROUP_EXTENDEXT4_IOC_MIGRATEEXT4_IOC_ALLOC_DA_BLKSEXT4_IOC_RESIZE_FSEXT4_IOC_SWAP_BOOTEXT4_IOC_PRECACHE_EXTENTSEXT4_IOC_CLEAR_ES_CACHEEXT4_IOC_GETSTATEEXT4_IOC_GET_ES_CACHEEXT4_IOC_CHECKPOINTEXT4_IOC_SHUTDOWNEXT4_IOC32_GETVERSIONEXT4_IOC32_SETVERSIONEXT4_IOC32_GETRSVSZEXT4_IOC32_SETRSVSZEXT4_IOC32_GROUP_EXTENDEXT4_IOC32_GETVERSION_OLDEXT4_IOC32_SETVERSION_OLDVIDIOC_SUBDEV_QUERYSTDAUTOFS_DEV_IOCTL_CLOSEMOUNTLIRC_SET_SEND_CARRIERAUTOFS_IOC_PROTOSUBVERFSI_SCOM_WRITEATM_GETCIRANGEDMA_BUF_SET_NAME_BRIO_CM_EP_GET_LIST_SIZEFS_IOC_GET_ENCRYPTION_POLICYCEC_RECEIVEMGSL_IOCGPARAMSENI_SETMULTRIO_GET_EVENT_MASKLIRC_GET_MAX_TIMEOUTUSBDEVFS_CLAIMINTERFACECHIOMOVESONYPI_IOCGBATFLAGSBTRFS_IOC_SYNCVIDIOC_TRY_FMTLIRC_SET_REC_MODEVIDIOC_DQEVENTRPMSG_DESTROY_EPT_IOCTLUVCIOC_CTRL_MAPVHOST_SET_BACKEND_FEATURESVHOST_VSOCK_SET_GUEST_CIDLIRC_SET_REC_TIMEOUTFS_IOC_GET_ENCRYPTION_KEY_STATUSBTRFS_IOC_TREE_SEARCH_V2VHOST_SET_VRING_BASERIO_ENABLE_DOORBELL_RANGEVIDIOC_TRY_EXT_CTRLSLIRC_GET_REC_MODEPPGETTIMEBTRFS_IOC_RM_DEVATM_SETBACKENDFSL_HV_IOCTL_PARTITION_STARTFBIO_WAITEVENTSWITCHTEC_IOCTL_PORT_TO_PFFNVME_IOCTL_IO_CMDIPMICTL_RECEIVE_MSG_TRUNCFDTWADDLENVME_IOCTL_SUBMIT_IONILFS_IOCTL_SYNCVIDIOC_SUBDEV_S_DV_TIMINGSASPEED_LPC_CTRL_IOCTL_GET_SIZEDM_DEV_STATUSTEE_IOC_CLOSE_SESSIONNS_GETPSTATUI_SET_PROPBITRIO_MPORT_MAINT_COMPTAG_SETAUTOFS_DEV_IOCTL_VERSIONWDIOC_SETOPTIONSVHOST_SCSI_SET_ENDPOINTMGSL_IOCGTXIDLEATM_ADDLECSADDRFSL_HV_IOCTL_GETPROPFDGETPRMHIDIOCAPPLICATIONENI_MEMDUMPVIDIOC_SUBDEV_G_DV_TIMINGSDMA_BUF_SET_NAME_ADFL_FPGA_PORT_UINT_SET_IRQRTC_EPOCH_READVIDIOC_SUBDEV_S_SELECTIONVIDIOC_QUERY_EXT_CTRLATM_GETLECSADDRFSL_HV_IOCTL_PARTITION_STOPSONET_GETDIAGATMMPC_DATAIPMICTL_UNREGISTER_FOR_CMD_CHANSHIDIOCGCOLLECTIONINDEXRPMSG_CREATE_EPT_IOCTLGPIOHANDLE_GET_LINE_VALUES_IOCTLISST_IF_IO_CMDRIO_MPORT_MAINT_READ_REMOTEVIDIOC_OMAP3ISP_HIST_CFGBLKGETNRZONESVIDIOC_G_MODULATORVBG_IOCTL_WRITE_CORE_DUMPUSBDEVFS_SETINTERFACEPPPIOCGCHANEVIOCGVERSIONVHOST_NET_SET_BACKENDUSBDEVFS_REAPURBNDELAYRNDZAPENTCNTVIDIOC_G_PARMLIRC_SET_MEASURE_CARRIER_MODEVHOST_SET_VRING_ERRVDUSE_VQ_SETUPAUTOFS_IOC_SETTIMEOUTVIDIOC_S_FREQUENCYF2FS_IOC_SEC_TRIM_FILEFS_IOC_REMOVE_ENCRYPTION_KEYWDIOC_GETPRETIMEOUTUSBDEVFS_DROP_PRIVILEGESBTRFS_IOC_SNAP_CREATE_V2VHOST_VSOCK_SET_RUNNINGSTP_SET_OPTIONSFBIO_RADEON_GET_MIRRORIVTVFB_IOC_DMA_FRAMEIPMICTL_SEND_COMMANDVIDIOC_G_ENC_INDEXDFL_FPGA_FME_PORT_PRCHIOSVOLTAGATM_SETESIFFW_CDEV_IOC_SEND_RESPONSEPMU_IOC_GET_MODELJSIOCGBTNMAPUSBDEVFS_HUB_PORTINFOVBG_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTSFDCLRPRMBTRFS_IOC_SCRUBUSBDEVFS_DISCONNECTATMTCP_REMOVEVHOST_VDPA_GET_CONFIGPPPIOCGNPMODEFDGETDRVPRMPHN_SETREGPPPIOCDETACHMMTIMER_GETRESVIDIOC_SUBDEV_ENUMSTDPPGETFLAGSVDUSE_DEV_GET_FEATURESCAPI_MANUFACTURER_CMDVIDIOC_G_TUNERDM_TABLE_STATUSDM_DEV_ARM_POLLNE_CREATE_VMMEDIA_IOC_ENUM_LINKSF2FS_IOC_PRECACHE_EXTENTSDFL_FPGA_PORT_DMA_MAPMGSL_IOCGXCTRLFW_CDEV_IOC_SEND_REQUESTSONYPI_IOCGBLUEF2FS_IOC_DECOMPRESS_FILEI2OHTMLVFIO_GET_API_VERSIONIDT77105_GETSTATZI2OPARMSETTEE_IOC_CANCELDFL_FPGA_PORT_RESETPPPIOCGASYNCMAPEVIOCGKEYCODE_V2DM_DEV_SET_GEOMETRYHIDIOCSUSAGEFW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE_ONCESWITCHTEC_IOCTL_EVENT_CTLWDIOC_SETPRETIMEOUTVHOST_SCSI_CLEAR_ENDPOINTJSIOCGAXESHIDIOCSFLAGPPWDATAFDGETMAXERRSSIOCSIFATMTCPCEC_ADAP_G_LOG_ADDRSND_IOCTL_ARS_CAPNBD_SET_BLKSIZENBD_SET_TIMEOUTVHOST_SCSI_GET_ABI_VERSIONRIO_UNMAP_INBOUNDATM_QUERYLOOPDFL_FPGA_GET_API_VERSIONUSBDEVFS_WAIT_FOR_RESUMEFBIO_CURSORRNDCLEARPOOLVIDIOC_QUERYSTDDMA_BUF_IOCTL_SYNCSCIF_RECVFW_CDEV_IOC_ALLOCATECEC_ADAP_G_CAPSVIDIOC_G_FBUFPCITEST_CLEAR_IRQIPMICTL_SET_GETS_EVENTS_CMDBTRFS_IOC_DEVICES_READYJSIOCGAXMAPFW_CDEV_IOC_GET_CYCLE_TIMERFW_CDEV_IOC_SET_ISO_CHANNELSRTC_WIE_OFFPPGETMODEVIDIOC_DBG_G_REGISTERBTRFS_IOC_SPACE_INFOVIDIOC_SUBDEV_ENUM_FRAME_SIZEND_IOCTL_VENDORSCIF_VREADFROMBTRFS_IOC_TRANS_STARTINOTIFY_IOC_SETNEXTWDSNAPSHOT_GET_IMAGE_SIZEND_IOCTL_CLEAR_ERRORIOC_PR_CLEARSCIF_READFROMPPPIOCGDEBUGBLKGETZONESZHIDIOCGUSAGESSONYPI_IOCGTEMPUI_SET_MSCBITAPM_IOC_SUSPENDBTRFS_IOC_TREE_SEARCHRTC_PLL_GETRIO_CM_EP_GET_LISTUSBDEVFS_DISCSIGNALLIRC_GET_MIN_TIMEOUTSWITCHTEC_IOCTL_EVENT_SUMMARY_LEGACYDM_TARGET_MSGSONYPI_IOCGBAT1REMEVIOCSFFEVIOCGKEYCODEKCOV_REMOTE_ENABLEND_IOCTL_GET_CONFIG_SIZEFDEJECTPPPIOCCONNECTATM_ADDADDRVDUSE_DEV_INJECT_CONFIG_IRQAUTOFS_DEV_IOCTL_ASKUMOUNTVHOST_VDPA_GET_STATUSCCISS_PASSTHRUMGSL_IOCCLRMODCOUNTTEE_IOC_SUPPL_SENDATMARPD_CTRLUI_ABS_SETUPBTRFS_IOC_QUOTA_CTLRTC_AIE_ONAUTOFS_IOC_EXPIREPPPIOCSDEBUGGPIO_V2_LINE_SET_VALUES_IOCTLPPPIOCSMRUCCISS_DEREGDISKFUSE_DEV_IOC_CLONEBTRFS_IOC_START_SYNCNILFS_IOCTL_DELETE_CHECKPOINTSNAPSHOT_AVAIL_SWAP_SIZEDM_TABLE_CLEARCCISS_GETINTINFOPPPIOCSASYNCMAPI2OEVTGETNVME_IOCTL_RESETPPYIELDNVME_IOCTL_IO64_CMDDM_DEV_WAITRTC_WIE_ONMEDIA_IOC_DEVICE_INFORIO_CM_CHAN_CREATEMGSL_IOCSPARAMSRTC_SET_TIMEVHOST_RESET_OWNERIOC_OPAL_PSID_REVERT_TPRAUTOFS_DEV_IOCTL_OPENMOUNTUDF_GETEABLOCKVFIO_IOMMU_MAP_DMAVIDIOC_SUBSCRIBE_EVENTHIDIOCGFLAGHIDIOCGUCODEVIDIOC_OMAP3ISP_AF_CFGDM_REMOVE_ALLASPEED_LPC_CTRL_IOCTL_MAPCCISS_GETFIRMVERND_IOCTL_ARS_STARTPPPIOCSMRRUCEC_ADAP_S_LOG_ADDRSRPROC_GET_SHUTDOWN_ON_RELEASEDMA_HEAP_IOCTL_ALLOCPPSETTIMERTC_ALM_READVDUSE_SET_API_VERSIONRIO_MPORT_MAINT_WRITE_REMOTEVIDIOC_SUBDEV_S_CROPUSBDEVFS_CONNECTSYNC_IOC_FILE_INFOATMARP_MKIPVFIO_IOMMU_SPAPR_TCE_GET_INFOCCISS_GETHEARTBEATATM_RSTADDRNBD_SET_SIZEUDF_GETVOLIDENTGPIO_V2_LINE_GET_VALUES_IOCTLMGSL_IOCSTXIDLEFSL_HV_IOCTL_SETPROPBTRFS_IOC_GET_DEV_STATSPPRSTATUSMGSL_IOCTXENABLEUDF_GETEASIZENVME_IOCTL_ADMIN64_CMDVHOST_SET_OWNERRIO_ALLOC_DMARIO_CM_CHAN_ACCEPTI2OHRTGETATM_SETCIRANGEHPET_IE_ONPERF_EVENT_IOC_IDPPPIOCDISCONNVIDIOC_QUERYCTRLPPEXCLPCITEST_MSIFDWERRORCLRAUTOFS_IOC_FAILUSBDEVFS_IOCTLVIDIOC_S_STDF2FS_IOC_RESIZE_FSSONET_SETDIAGBTRFS_IOC_DEFRAGCCISS_GETDRIVVERIPMICTL_GET_TIMING_PARMS_CMDHPET_IRQFREQATM_GETESICCISS_GETLUNINFOAUTOFS_DEV_IOCTL_ISMOUNTPOINTTEE_IOC_SHM_ALLOCPERF_EVENT_IOC_SET_BPFUDMABUF_CREATE_LISTVHOST_SET_LOG_BASEZATM_GETPOOLBR2684_SETFILTRNDGETPOOLPPS_GETPARAMSIOC_PR_RESERVEVIDIOC_TRY_DECODER_CMDRIO_CM_CHAN_CLOSEVIDIOC_DV_TIMINGS_CAPIOCTL_MEI_CONNECT_CLIENT_VTAGPMU_IOC_GET_BACKLIGHTUSBDEVFS_GET_CAPABILITIESSCIF_WRITETOUDF_RELOCATE_BLOCKSFSL_HV_IOCTL_PARTITION_RESTARTCCISS_REGNEWDFAT_IOCTL_SET_ATTRIBUTESVIDIOC_CREATE_BUFSCAPI_GET_VERSIONSWITCHTEC_IOCTL_EVENT_SUMMARYVFIO_EEH_PE_OPFW_CDEV_IOC_CREATE_ISO_CONTEXTF2FS_IOC_RELEASE_COMPRESS_BLOCKSNBD_SET_SIZE_BLOCKSIPMI_BMC_IOCTL_SET_SMS_ATNASPEED_P2A_CTRL_IOCTL_GET_MEMORY_CONFIGVIDIOC_S_AUDOUTVIDIOC_S_FMTPPPIOCATTACHVHOST_GET_VRING_BUSYLOOP_TIMEOUTFS_IOC_MEASURE_VERITYCCISS_BIG_PASSTHRUIPMICTL_SET_MY_LUN_CMDPCITEST_LEGACY_IRQUSBDEVFS_SUBMITURBAUTOFS_IOC_READYBTRFS_IOC_SENDVIDIOC_G_EXT_CTRLSJSIOCSBTNMAPPPPIOCSFLAGSNVRAM_INITRFKILL_IOCTL_NOINPUTBTRFS_IOC_BALANCEFS_IOC_GETFSMAPIPMICTL_GET_MY_CHANNEL_LUN_CMDSTP_POLICY_ID_GETPPSETFLAGSCEC_ADAP_S_PHYS_ADDRATMTCP_CREATEIPMI_BMC_IOCTL_FORCE_ABORTPPPIOCGXASYNCMAPVHOST_SET_VRING_CALLLIRC_GET_FEATURESGSMIOC_DISABLE_NETAUTOFS_IOC_CATATONICNBD_DO_ITLIRC_SET_REC_CARRIER_RANGEIPMICTL_GET_MY_CHANNEL_ADDRESS_CMDEVIOCSCLOCKIDUSBDEVFS_FREE_STREAMSFSI_SCOM_RESETPMU_IOC_GRAB_BACKLIGHTVIDIOC_SUBDEV_S_FMTFDDEFPRMTEE_IOC_INVOKEUSBDEVFS_BULKSCIF_VWRITETOSONYPI_IOCSBRTBTRFS_IOC_FILE_EXTENT_SAMERTC_PIE_ONBTRFS_IOC_SCAN_DEVPPPIOCXFERUNITWDIOC_GETTIMEOUTBTRFS_IOC_SET_RECEIVED_SUBVOLDFL_FPGA_PORT_ERR_SET_IRQFBIO_WAITFORVSYNCRTC_PIE_OFFEVIOCGRABPMU_IOC_SET_BACKLIGHTEVIOCGREPPERF_EVENT_IOC_MODIFY_ATTRIBUTESUFFDIO_CONTINUEVDUSE_GET_API_VERSIONRTC_RD_TIMEFDMSGOFFIPMICTL_REGISTER_FOR_CMD_CHANSCAPI_GET_ERRCODEPCITEST_SET_IRQTYPEVIDIOC_SUBDEV_S_EDIDMATROXFB_SET_OUTPUT_MODERIO_DEV_ADDVIDIOC_ENUM_FREQ_BANDSFBIO_RADEON_SET_MIRRORPCITEST_GET_IRQTYPEJSIOCGVERSIONSONYPI_IOCSBLUESNAPSHOT_PREF_IMAGE_SIZEF2FS_IOC_GET_FEATURESSCIF_REGNILFS_IOCTL_CLEAN_SEGMENTSFW_CDEV_IOC_INITIATE_BUS_RESETRIO_WAIT_FOR_ASYNCVHOST_SET_VRING_NUMAUTOFS_DEV_IOCTL_PROTOVERRIO_FREE_DMAMGSL_IOCRXENABLEIOCTL_VM_SOCKETS_GET_LOCAL_CIDIPMICTL_SET_TIMING_PARMS_CMDPPPIOCGL2TPSTATSPERF_EVENT_IOC_PERIODCHIOEXCHANGENILFS_IOCTL_GET_SUINFOCEC_DQEVENTUI_SET_SWBITVHOST_VDPA_SET_CONFIGCHIOPOSITIONIPMICTL_SET_MAINTENANCE_MODE_CMDBTRFS_IOC_DEFAULT_SUBVOLRIO_UNMAP_OUTBOUNDCAPI_CLR_FLAGSFW_CDEV_IOC_ALLOCATE_ISO_RESOURCE_ONCEMATROXFB_GET_OUTPUT_CONNECTIONEVIOCSMASKBTRFS_IOC_FORGET_DEVCXL_MEM_QUERY_COMMANDSCEC_S_MODEMGSL_IOCSIFSWITCHTEC_IOCTL_PFF_TO_PORTPPSETMODEVFIO_DEVICE_SET_IRQSVIDIOC_PREPARE_BUFCEC_ADAP_G_CONNECTOR_INFOIOC_OPAL_WRITE_SHADOW_MBRVIDIOC_SUBDEV_ENUM_FRAME_INTERVALUDMABUF_CREATESONET_CLRDIAGPHN_SET_REGRNDADDTOENTCNTVBG_IOCTL_CHECK_BALLOONVIDIOC_OMAP3ISP_STAT_REQPPS_FETCHRTC_AIE_OFFVFIO_GROUP_SET_CONTAINERFW_CDEV_IOC_RECEIVE_PHY_PACKETSVFIO_IOMMU_SPAPR_TCE_REMOVEVFIO_IOMMU_GET_INFODM_DEV_SUSPENDF2FS_IOC_GET_COMPRESS_OPTIONFW_CDEV_IOC_STOP_ISOGPIO_V2_GET_LINEINFO_IOCTLATMMPC_CTRLPPPIOCSXASYNCMAPCHIOGSTATUSFW_CDEV_IOC_ALLOCATE_ISO_RESOURCERIO_MPORT_MAINT_PORT_IDX_GETCAPI_SET_FLAGSVFIO_GROUP_GET_DEVICE_FDVHOST_SET_MEM_TABLEMATROXFB_SET_OUTPUT_CONNECTIONDFL_FPGA_PORT_GET_REGION_INFOVHOST_GET_FEATURESLIRC_GET_REC_RESOLUTIONPACKET_CTRL_CMDLIRC_SET_TRANSMITTER_MASKBTRFS_IOC_ADD_DEVJSIOCGCORRVIDIOC_G_FMTRTC_EPOCH_SETCAPI_GET_PROFILEATM_GETLOOPSCIF_LISTENNBD_CLEAR_QUEF2FS_IOC_MOVE_RANGELIRC_GET_LENGTHI8K_SET_FANFDSETMAXERRSVIDIOC_SUBDEV_QUERYCAPSNAPSHOT_SET_SWAP_AREALIRC_GET_REC_TIMEOUTEVIOCRMFFGPIO_GET_LINEEVENT_IOCTLPPRDATARIO_MPORT_GET_PROPERTIESGPIO_GET_LINEINFO_IOCTLGSMIOC_GETCONFLIRC_GET_SEND_MODEPPPIOCSACTIVESIOCGSTAMPNS_NEWIPMICTL_RECEIVE_MSGLIRC_SET_SEND_DUTY_CYCLEUI_END_FF_ERASESWITCHTEC_IOCTL_FLASH_PART_INFOFW_CDEV_IOC_SEND_PHY_PACKETNBD_SET_FLAGSVFIO_DEVICE_GET_REGION_INFOREISERFS_IOC_UNPACKFW_CDEV_IOC_REMOVE_DESCRIPTORRIO_SET_EVENT_MASKSNAPSHOT_ALLOC_SWAP_PAGEVDUSE_VQ_INJECT_IRQI2OPASSTHRUIOC_OPAL_SET_PWFSI_SCOM_READVHOST_VDPA_GET_DEVICE_IDVIDIOC_QBUFVIDIOC_S_TUNERCAPI_NCCI_GETUNITDFL_FPGA_PORT_UINT_GET_IRQ_NUMVIDIOC_OMAP3ISP_STAT_ENGPIO_V2_LINE_SET_CONFIG_IOCTLTEE_IOC_VERSIONVIDIOC_LOG_STATUSIPMICTL_SEND_COMMAND_SETTIMEVHOST_SET_LOG_FDSCIF_SENDVIDIOC_SUBDEV_G_FMTNS_ADJBUFLEVVIDIOC_DBG_S_REGISTERNILFS_IOCTL_RESIZEPHN_GETREGI2OSWDLVBG_IOCTL_VMMDEV_REQUEST_BIGJSIOCGBUTTONSVFIO_IOMMU_ENABLEDM_DEV_RENAMEMEDIA_IOC_SETUP_LINKVIDIOC_ENUMOUTPUTSTP_POLICY_ID_SETVHOST_VDPA_SET_CONFIG_CALLVIDIOC_SUBDEV_G_CROPVIDIOC_S_CROPWDIOC_GETTEMPIOC_OPAL_ADD_USR_TO_LRUI_SET_LEDBITNBD_SET_SOCKBTRFS_IOC_SNAP_DESTROY_V2HIDIOCGCOLLECTIONINFOI2OSWULIOCTL_MEI_NOTIFY_GETFDFMTTRKMMTIMER_GETBITSVIDIOC_ENUMSTDVHOST_GET_VRING_BASEVFIO_DEVICE_IOEVENTFDATMARP_SETENTRYCCISS_REVALIDVOLSMGSL_IOCLOOPTXDONERTC_VL_READND_IOCTL_ARS_STATUSRIO_DEV_DELVBG_IOCTL_ACQUIRE_GUEST_CAPABILITIESVIDIOC_SUBDEV_DV_TIMINGS_CAPSONYPI_IOCSFANSPIOCSTYPEIPMICTL_REGISTER_FOR_CMDI8K_GET_FANAUTOFS_DEV_IOCTL_FAILUI_END_FF_UPLOADTOSH_SMMSONYPI_IOCGBAT2REMF2FS_IOC_GET_COMPRESS_BLOCKSPPPIOCSNPMODEUSBDEVFS_CONTROLHIDIOCGUSAGEVIDIOC_ENUM_DV_TIMINGSBTRFS_IOC_INO_PATHSMGSL_IOCGXSYNCHIDIOCGFIELDINFOVIDIOC_SUBDEV_G_STDI2OVALIDATEVIDIOC_TRY_ENCODER_CMDNILFS_IOCTL_GET_CPINFOVIDIOC_G_FREQUENCYVFAT_IOCTL_READDIR_SHORTND_IOCTL_GET_CONFIG_DATAF2FS_IOC_RESERVE_COMPRESS_BLOCKSFDGETDRVSTATSYNC_IOC_MERGEVIDIOC_S_DV_TIMINGSPPPIOCBRIDGECHANLIRC_SET_SEND_MODERIO_ENABLE_PORTWRITE_RANGEATM_GETTYPEPHN_GETREGSFDSETEMSGTRESHNILFS_IOCTL_GET_VINFOMGSL_IOCWAITEVENTCAPI_INSTALLEDEVIOCGMASKBTRFS_IOC_SUBVOL_GETFLAGSFSL_HV_IOCTL_PARTITION_GET_STATUSMEDIA_IOC_ENUM_ENTITIESGSMIOC_GETFIRSTFW_CDEV_IOC_FLUSH_ISOVIDIOC_DBG_G_CHIP_INFOF2FS_IOC_RELEASE_VOLATILE_WRITECAPI_GET_SERIALFDSETDRVPRMIOC_OPAL_SAVEVIDIOC_G_DV_TIMINGSCCISS_SETINTINFORTC_VL_CLRVIDIOC_REQBUFSUSBDEVFS_REAPURBNDELAY32TEE_IOC_SHM_REGISTERUSBDEVFS_SETCONFIGURATIONCCISS_GETNODENAMEVIDIOC_SUBDEV_S_FRAME_INTERVALVIDIOC_ENUM_FRAMESIZESVFIO_DEVICE_PCI_HOT_RESETFW_CDEV_IOC_SEND_BROADCAST_REQUESTLPSETTIMEOUT_NEWRIO_CM_MPORT_GET_LISTFW_CDEV_IOC_QUEUE_ISOFDRAWCMDSCIF_UNREGPPPIOCGIDLE64USBDEVFS_RELEASEINTERFACEVIDIOC_CROPCAPDFL_FPGA_PORT_GET_INFOPHN_SET_REGSATMLEC_DATAPPPOEIOCDFWDVIDIOC_S_SELECTIONSNAPSHOT_FREE_SWAP_PAGESBTRFS_IOC_LOGICAL_INOVIDIOC_S_CTRLZATM_SETPOOLMTIOCPOSPMU_IOC_SLEEPAUTOFS_DEV_IOCTL_PROTOSUBVERVBG_IOCTL_CHANGE_FILTER_MASKNILFS_IOCTL_GET_SUSTATVIDIOC_QUERYCAPHPET_INFOVIDIOC_AM437X_CCDC_CFGDM_LIST_DEVICESVBG_IOCTL_CHANGE_GUEST_CAPABILITIESRNDADDENTROPYUSBDEVFS_RESETBTRFS_IOC_SUBVOL_CREATEUSBDEVFS_FORBID_SUSPENDFDGETDRVTYPPPWCONTROLVIDIOC_ENUM_FRAMEINTERVALSKCOV_DISABLEIOC_OPAL_ACTIVATE_LSPVHOST_VDPA_GET_IOVA_RANGEPPPIOCSPASSRIO_CM_CHAN_CONNECTI2OSWDELFS_IOC_SET_ENCRYPTION_POLICYIOC_OPAL_MBR_DONEPPPIOCSMAXCIDPPSETPHASEVHOST_VDPA_SET_VRING_ENABLEUSBDEVFS_GET_SPEEDSONET_GETFRAMINGVIDIOC_QUERYBUFVIDIOC_S_EDIDBTRFS_IOC_QGROUP_ASSIGNPPS_GETCAPSNAPSHOT_PLATFORM_SUPPORTLIRC_SET_REC_TIMEOUT_REPORTSSCIF_GET_NODEIDSNBD_DISCONNECTVIDIOC_SUBDEV_G_FRAME_INTERVALVFIO_IOMMU_DISABLESNAPSHOT_CREATE_IMAGESNAPSHOT_POWER_OFFAPM_IOC_STANDBYPPPIOCGUNITAUTOFS_IOC_EXPIRE_MULTISCIF_BINDIOC_WATCH_QUEUE_SET_SIZENILFS_IOCTL_CHANGE_CPMODEIOC_OPAL_LOCK_UNLOCKF2FS_IOC_SET_PIN_FILEPPPIOCGRASYNCMAPMMTIMER_MMAPAVAILI2OPASSTHRU32DFL_FPGA_FME_PORT_RELEASEVIDIOC_SUBDEV_QUERY_DV_TIMINGSUI_SET_SNDBITVIDIOC_G_AUDOUTRTC_PLL_SETVIDIOC_ENUMAUDIOAUTOFS_DEV_IOCTL_TIMEOUTVBG_IOCTL_DRIVER_VERSION_INFOVHOST_SCSI_GET_EVENTS_MISSEDVHOST_SET_VRING_ADDRVDUSE_CREATE_DEVFDFLUSHVBG_IOCTL_WAIT_FOR_EVENTSDFL_FPGA_FME_ERR_SET_IRQF2FS_IOC_GET_PIN_FILESCIF_CONNECTBLKREPORTZONEAUTOFS_IOC_ASKUMOUNTATM_ADDPARTYFDSETPRMATM_GETSTATZISST_IF_MSR_COMMANDBTRFS_IOC_GET_SUBVOL_INFOVIDIOC_UNSUBSCRIBE_EVENTSEV_ISSUE_CMDGPIOHANDLE_SET_LINE_VALUES_IOCTLPCITEST_COPYIPMICTL_GET_MY_ADDRESS_CMDCHIOGPICKERCAPI_NCCI_OPENCOUNTCXL_MEM_SEND_COMMANDPERF_EVENT_IOC_SET_FILTERIOC_OPAL_REVERT_TPRCHIOGVPARAMSFSI_SCOM_CHECKRTC_IRQP_READRIO_MPORT_MAINT_READ_LOCALHIDIOCGRDESCSIZEUI_GET_VERSIONNILFS_IOCTL_GET_CPSTATCCISS_GETBUSTYPESVFIO_IOMMU_SPAPR_TCE_CREATEVIDIOC_EXPBUFVFIO_SET_IOMMUVIDIOC_S_MODULATORCCISS_SETNODENAMEFBIO_GETCONTROL2DM_DEV_REMOVEHIDIOCSUSAGESFS_IOC_ADD_ENCRYPTION_KEYFBIOGET_VBLANKATM_GETSTATVIDIOC_G_JPEGCOMPDFL_FPGA_PORT_ERR_GET_IRQ_NUMUSBDEVFS_REAPURB32BTRFS_IOC_TRANS_ENDCAPI_REGISTERF2FS_IOC_COMPRESS_FILEUSBDEVFS_DISCARDURBHE_GET_REGATM_SETLOOPATMSIGD_CTRLCIOC_KERNEL_VERSIONBTRFS_IOC_CLONE_RANGESNAPSHOT_UNFREEZEF2FS_IOC_START_VOLATILE_WRITEPMU_IOC_HAS_ADBI2OGETIOPSVIDIOC_S_FBUFPPRCONTROLCHIOSPICKERVFIO_IOMMU_SPAPR_REGISTER_MEMORYGSMIOC_SETCONFIOC_PR_PREEMPTKCOV_INIT_TRACESONYPI_IOCGBAT1CAPSWITCHTEC_IOCTL_FLASH_INFOMTIOCTOPVHOST_VDPA_SET_STATUSVHOST_SCSI_SET_EVENTS_MISSEDVFIO_IOMMU_DIRTY_PAGESBTRFS_IOC_SCRUB_PROGRESSPPPIOCGMRUBTRFS_IOC_DEV_REPLACEPPPIOCGFLAGSNILFS_IOCTL_SET_SUINFOFW_CDEV_IOC_GET_CYCLE_TIMER2ATM_DELLECSADDRFW_CDEV_IOC_GET_SPEEDPPPIOCGIDLE32VFIO_DEVICE_RESETGPIO_GET_LINEINFO_UNWATCH_IOCTLWDIOC_GETSTATUSBTRFS_IOC_SET_FEATURESIOCTL_MEI_CONNECT_CLIENTVIDIOC_OMAP3ISP_AEWB_CFGPCITEST_READVFIO_GROUP_GET_STATUSMATROXFB_GET_ALL_OUTPUTSUSBDEVFS_CLEAR_HALTVIDIOC_DECODER_CMDVIDIOC_G_AUDIOCCISS_RESCANDISKRIO_DISABLE_PORTWRITE_RANGEIOC_OPAL_SECURE_ERASE_LRUSBDEVFS_REAPURBDFL_FPGA_CHECK_EXTENSIONAUTOFS_IOC_PROTOVERFSL_HV_IOCTL_MEMCPYBTRFS_IOC_GET_FEATURESPCITEST_MSIXBTRFS_IOC_DEFRAG_RANGEUI_BEGIN_FF_ERASEDM_GET_TARGET_VERSIONPPPIOCGIDLENVRAM_SETCKSWDIOC_GETSUPPORTGSMIOC_ENABLE_NETGPIO_GET_CHIPINFO_IOCTLNE_ADD_VCPUEVIOCSKEYCODE_V2SCIF_FENCE_WAITRIO_TRANSFERFSL_HV_IOCTL_DOORBELLRIO_MPORT_MAINT_WRITE_LOCALI2OEVTREGI2OPARMGETEVIOCGIDBTRFS_IOC_QGROUP_CREATEAUTOFS_DEV_IOCTL_SETPIPEFDVIDIOC_S_PARMATM_GETNAMESVIDIOC_QUERYMENUDFL_FPGA_PORT_DMA_UNMAPI2OLCTGETFS_IOC_GET_ENCRYPTION_PWSALTNS_SETBUFLEVBLKCLOSEZONESONET_GETFRSENSEDM_LIST_VERSIONSHIDIOCGSTRINGPPPIOCATTCHANVDUSE_DEV_SET_CONFIGVFIO_GROUP_UNSET_CONTAINERIPMICTL_SET_MY_ADDRESS_CMDCCISS_REGNEWDISKVIDIOC_QUERY_DV_TIMINGSPHN_SETREGSFAT_IOCTL_GET_ATTRIBUTESFSL_MC_SEND_MC_COMMANDBTRFS_IOC_RESIZEVHOST_SET_VRING_ENDIANPPS_KC_BINDF2FS_IOC_WRITE_CHECKPOINTUI_SET_FFBITIPMICTL_GET_MY_LUN_CMDCEC_ADAP_G_PHYS_ADDRCEC_G_MODEUSBDEVFS_RESETEPMEDIA_REQUEST_IOC_QUEUEUSBDEVFS_ALLOC_STREAMSMGSL_IOCSXCTRLMEDIA_IOC_G_TOPOLOGYPPPIOCUNBRIDGECHANF2FS_IOC_COMMIT_ATOMIC_WRITEISST_IF_GET_PLATFORM_INFOSCIF_FENCE_MARKUSBDEVFS_RELEASE_PORTVFIO_CHECK_EXTENSIONBTRFS_IOC_QGROUP_LIMITFAT_IOCTL_GET_VOLUME_IDUI_SET_PHYSFDWERRORGETVIDIOC_SUBDEV_G_EDIDMGSL_IOCGSTATSRPROC_SET_SHUTDOWN_ON_RELEASESIOCGSTAMP_NEWRTC_WKALM_RDPHN_GET_REGDELL_WMI_SMBIOS_CMDPHN_NOT_OHPPGETMODESCHIOGPARAMSVFIO_DEVICE_GET_GFX_DMABUFVHOST_SET_VRING_BUSYLOOP_TIMEOUTVIDIOC_SUBDEV_G_SELECTIONBTRFS_IOC_RM_DEV_V2MGSL_IOCWAITGPIOPMU_IOC_CAN_SLEEPKCOV_ENABLEBTRFS_IOC_CLONEF2FS_IOC_DEFRAGMENTFW_CDEV_IOC_DEALLOCATE_ISO_RESOURCEAGPIOC_ALLOCATENE_SET_USER_MEMORY_REGIONMGSL_IOCTXABORTMGSL_IOCSGPIOLIRC_SET_REC_CARRIERF2FS_IOC_FLUSH_DEVICESNAPSHOT_ATOMIC_RESTORERTC_UIE_OFFBT_BMC_IOCTL_SMS_ATNNVME_IOCTL_IDNE_START_ENCLAVEVIDIOC_STREAMONFDPOLLDRVSTATAUTOFS_DEV_IOCTL_READYVIDIOC_ENUMAUDOUTVIDIOC_SUBDEV_S_STDWDIOC_GETTIMELEFTATM_GETLINKRATERTC_WKALM_SETVHOST_GET_BACKEND_FEATURESATMARP_ENCAPCAPI_GET_FLAGSIPMICTL_SET_MY_CHANNEL_ADDRESS_CMDDFL_FPGA_FME_PORT_ASSIGNVIDIOC_OVERLAYBTRFS_IOC_WAIT_SYNCGPIOHANDLE_SET_CONFIG_IOCTLVHOST_GET_VRING_ENDIANATM_GETADDRPHN_GET_REGSAUTOFS_DEV_IOCTL_REQUESTERAUTOFS_DEV_IOCTL_EXPIRESNAPSHOT_S2RAMJSIOCSAXMAPF2FS_IOC_SET_COMPRESS_OPTIONVBG_IOCTL_HGCM_DISCONNECTSCIF_FENCE_SIGNALVFIO_DEVICE_GET_PCI_HOT_RESET_INFOVIDIOC_SUBDEV_ENUM_MBUS_CODEMMTIMER_GETOFFSETRIO_CM_CHAN_LISTENATM_SETSCF2FS_IOC_SHUTDOWNNVME_IOCTL_RESCANBLKOPENZONEDM_VERSIONCEC_TRANSMITFS_IOC_GET_ENCRYPTION_POLICY_EXSIOCMKCLIPIPMI_BMC_IOCTL_CLEAR_SMS_ATNHIDIOCGVERSIONVIDIOC_S_INPUTVIDIOC_G_CROPLIRC_SET_WIDEBAND_RECEIVEREVIOCGEFFECTSUVCIOC_CTRL_QUERYIOC_OPAL_GENERIC_TABLE_RWFS_IOC_READ_VERITY_METADATAND_IOCTL_SET_CONFIG_DATAUSBDEVFS_GETDRIVERIDT77105_GETSTATHIDIOCINITREPORTVFIO_DEVICE_GET_INFORIO_CM_CHAN_RECEIVERNDGETENTCNTPPPIOCNEWUNITBTRFS_IOC_INO_LOOKUPFDRESETIOC_PR_REGISTERHIDIOCSREPORTTEE_IOC_OPEN_SESSIONTEE_IOC_SUPPL_RECVBTRFS_IOC_BALANCE_CTLGPIO_GET_LINEINFO_WATCH_IOCTLHIDIOCGRAWINFOPPPIOCSCOMPRESSUSBDEVFS_CONNECTINFOBLKRESETZONECHIOINITELEMNILFS_IOCTL_SET_ALLOC_RANGEAUTOFS_DEV_IOCTL_CATATONICRIO_MPORT_MAINT_HDID_SETPPGETPHASEUSBDEVFS_DISCONNECT_CLAIMFDMSGONVIDIOC_G_SLICED_VBI_CAPBTRFS_IOC_BALANCE_V2MEDIA_REQUEST_IOC_REINITIOC_OPAL_ERASE_LRFDFMTBEGRNDRESEEDCRNGISST_IF_GET_PHY_IDSONET_GETSTATTFD_IOC_SET_TICKSPPDATADIRIOC_OPAL_ENABLE_DISABLE_MBRGPIO_V2_GET_LINE_IOCTLRIO_CM_CHAN_SENDPPWCTLONIRQSONYPI_IOCGBRTIOC_PR_RELEASEPPCLRIRQIPMICTL_SET_MY_CHANNEL_LUN_CMDMGSL_IOCSXSYNCHPET_IE_OFFIOC_OPAL_ACTIVATE_USRSONET_SETFRAMINGPERF_EVENT_IOC_PAUSE_OUTPUTBTRFS_IOC_LOGICAL_INO_V2VBG_IOCTL_HGCM_CONNECTBLKFINISHZONEEVIOCREVOKEVFIO_DEVICE_FEATURECCISS_GETPCIINFOISST_IF_MBOX_COMMANDSCIF_ACCEPTREQPERF_EVENT_IOC_QUERY_BPFVIDIOC_STREAMOFFVDUSE_DESTROY_DEVFDGETFDCSTATVIDIOC_S_PRIORITYSNAPSHOT_FREEZEVIDIOC_ENUMINPUTZATM_GETPOOLZRIO_DISABLE_DOORBELL_RANGEGPIO_V2_GET_LINEINFO_WATCH_IOCTLVIDIOC_G_STDUSBDEVFS_ALLOW_SUSPENDSONET_GETSTATZSCIF_ACCEPTREGVIDIOC_ENCODER_CMDPPPIOCSRASYNCMAPIOCTL_MEI_NOTIFY_SETBTRFS_IOC_QUOTA_RESCAN_STATUSF2FS_IOC_GARBAGE_COLLECTATMLEC_CTRLMATROXFB_GET_AVAILABLE_OUTPUTSDM_DEV_CREATEVHOST_VDPA_GET_VRING_NUMVIDIOC_G_CTRLNBD_CLEAR_SOCKVFIO_DEVICE_QUERY_GFX_PLANEWDIOC_KEEPALIVENVME_IOCTL_SUBSYS_RESETPCITEST_BARMGSL_IOCGGPIOEVIOCSREPVFIO_DEVICE_GET_IRQ_INFOHPET_DPIVDUSE_VQ_SETUP_KICKFDND_IOCTL_CALLHIDIOCGDEVINFODM_TABLE_DEPSBTRFS_IOC_DEV_INFOVDUSE_IOTLB_GET_FDFW_CDEV_IOC_GET_INFOVIDIOC_G_PRIORITYATM_NEWBACKENDIFVIDIOC_S_EXT_CTRLSVIDIOC_SUBDEV_ENUM_DV_TIMINGSVIDIOC_OMAP3ISP_CCDC_CFGVIDIOC_S_HW_FREQ_SEEKDM_TABLE_LOADF2FS_IOC_START_ATOMIC_WRITEVIDIOC_G_OUTPUTATM_DROPPARTYCHIOGELEMBTRFS_IOC_GET_SUPPORTED_FEATURESEVIOCSKEYCODENE_GET_IMAGE_LOAD_INFOFW_CDEV_IOC_ADD_DESCRIPTORBTRFS_IOC_SCRUB_CANCELPPS_SETPARAMSIOC_OPAL_LR_SETUPFW_CDEV_IOC_DEALLOCATEWDIOC_SETTIMEOUTIOC_WATCH_QUEUE_SET_FILTERCAPI_GET_MANUFACTURERVFIO_IOMMU_SPAPR_UNREGISTER_MEMORYASPEED_P2A_CTRL_IOCTL_SET_WINDOWVIDIOC_G_EDIDF2FS_IOC_GARBAGE_COLLECT_RANGERIO_MAP_INBOUNDIOC_OPAL_TAKE_OWNERSHIPUSBDEVFS_CLAIM_PORTVIDIOC_S_AUDIOFS_IOC_GET_ENCRYPTION_NONCEFW_CDEV_IOC_SEND_STREAM_PACKETBTRFS_IOC_SNAP_DESTROYSNAPSHOT_FREEI8K_GET_SPEEDHIDIOCGREPORTHPET_EPIJSIOCSCORRIOC_PR_PREEMPT_ABORTRIO_MAP_OUTBOUNDATM_SETESIFW_CDEV_IOC_START_ISOATM_DELADDRPPFCONTROLSONYPI_IOCGFANRTC_IRQP_SETPCITEST_WRITEPPCLAIMVIDIOC_S_JPEGCOMPIPMICTL_UNREGISTER_FOR_CMDVHOST_SET_FEATURESTOSHIBA_ACPI_SCIVIDIOC_DQBUFBTRFS_IOC_BALANCE_PROGRESSBTRFS_IOC_SUBVOL_SETFLAGSATMLEC_MCASTMMTIMER_GETFREQVIDIOC_G_SELECTIONRTC_ALM_SETPPPOEIOCSFWDIPMICTL_GET_MAINTENANCE_MODE_CMDFS_IOC_ENABLE_VERITYNILFS_IOCTL_GET_BDESCSFDFMTENDDMA_BUF_SET_NAMEUI_BEGIN_FF_UPLOADRTC_UIE_ONPPRELEASEVFIO_IOMMU_UNMAP_DMAVIDIOC_OMAP3ISP_PRV_CFGGPIO_GET_LINEHANDLE_IOCTLVFAT_IOCTL_READDIR_BOTHNVME_IOCTL_ADMIN_CMDVHOST_SET_VRING_KICKBTRFS_IOC_SUBVOL_CREATE_V2BTRFS_IOC_SNAP_CREATESONYPI_IOCGBAT2CAPPPNEGOTNBD_PRINT_DEBUGBTRFS_IOC_INO_LOOKUP_USERBTRFS_IOC_GET_SUBVOL_ROOTREFFS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERSBTRFS_IOC_FS_INFOVIDIOC_ENUM_FMTVIDIOC_G_INPUTVTPM_PROXY_IOC_NEW_DEVDFL_FPGA_FME_ERR_GET_IRQ_NUMND_IOCTL_DIMM_FLAGSBTRFS_IOC_QUOTA_RESCANMMTIMER_GETCOUNTERMATROXFB_GET_OUTPUT_MODEBTRFS_IOC_QUOTA_RESCAN_WAITRIO_CM_CHAN_BINDHIDIOCGRDESCMGSL_IOCGIFVIDIOC_S_OUTPUTHIDIOCGREPORTINFOWDIOC_GETBOOTSTATUSVDUSE_VQ_GET_INFOACRN_IOCTL_ASSIGN_PCIDEVBLKGETDISKSEQACRN_IOCTL_PM_GET_CPU_STATEACRN_IOCTL_DESTROY_VMACRN_IOCTL_SET_PTDEV_INTRACRN_IOCTL_CREATE_IOREQ_CLIENTACRN_IOCTL_IRQFDACRN_IOCTL_CREATE_VMACRN_IOCTL_INJECT_MSIACRN_IOCTL_ATTACH_IOREQ_CLIENTACRN_IOCTL_RESET_PTDEV_INTRACRN_IOCTL_NOTIFY_REQUEST_FINISHACRN_IOCTL_SET_IRQLINEACRN_IOCTL_START_VMACRN_IOCTL_SET_VCPU_REGSACRN_IOCTL_SET_MEMSEGACRN_IOCTL_PAUSE_VMACRN_IOCTL_CLEAR_VM_IOREQACRN_IOCTL_UNSET_MEMSEGACRN_IOCTL_IOEVENTFDACRN_IOCTL_DEASSIGN_PCIDEVACRN_IOCTL_RESET_VMACRN_IOCTL_DESTROY_IOREQ_CLIENTACRN_IOCTL_VM_INTR_MONITORhandled_access_fshandled_access_netscopedlandlock_ruleset_attrallowed_accessparent_fdlandlock_path_beneath_attrlandlock_net_port_attrLANDLOCK_CREATE_RULESET_VERSIONLANDLOCK_CREATE_RULESET_ERRATALANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFFLANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ONLANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFFLANDLOCK_ACCESS_FS_EXECUTELANDLOCK_ACCESS_FS_WRITE_FILELANDLOCK_ACCESS_FS_READ_FILELANDLOCK_ACCESS_FS_READ_DIRLANDLOCK_ACCESS_FS_REMOVE_DIRLANDLOCK_ACCESS_FS_REMOVE_FILELANDLOCK_ACCESS_FS_MAKE_CHARLANDLOCK_ACCESS_FS_MAKE_DIRLANDLOCK_ACCESS_FS_MAKE_REGLANDLOCK_ACCESS_FS_MAKE_SOCKLANDLOCK_ACCESS_FS_MAKE_FIFOLANDLOCK_ACCESS_FS_MAKE_BLOCKLANDLOCK_ACCESS_FS_MAKE_SYMLANDLOCK_ACCESS_FS_REFERLANDLOCK_ACCESS_FS_TRUNCATELANDLOCK_ACCESS_FS_IOCTL_DEVLANDLOCK_ACCESS_NET_BIND_TCPLANDLOCK_ACCESS_NET_CONNECT_TCPLANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKETLANDLOCK_SCOPE_SIGNALlandlock_rule_typeLANDLOCK_RULE_PATH_BENEATHLANDLOCK_RULE_NET_PORTlo_numberlo_devicelo_inodelo_rdevicelo_offsetlo_encrypt_typelo_encrypt_key_sizelo_flagslo_namelo_encrypt_keylo_initloop_infolo_sizelimitlo_file_namelo_crypt_nameloop_info64loop_configLO_NAME_SIZELO_KEY_SIZELO_CRYPT_NONELO_CRYPT_XORLO_CRYPT_DESLO_CRYPT_FISH2LO_CRYPT_BLOWLO_CRYPT_CAST128LO_CRYPT_IDEALO_CRYPT_DUMMYLO_CRYPT_SKIPJACKLO_CRYPT_CRYPTOAPIMAX_LO_CRYPTLOOP_SET_FDLOOP_CLR_FDLOOP_SET_STATUSLOOP_GET_STATUSLOOP_SET_STATUS64LOOP_GET_STATUS64LOOP_CHANGE_FDLOOP_SET_CAPACITYLOOP_SET_DIRECT_IOLOOP_SET_BLOCK_SIZELOOP_CONFIGURELOOP_CTL_ADDLOOP_CTL_REMOVELOOP_CTL_GET_FREELO_FLAGS_READ_ONLYLO_FLAGS_AUTOCLEARLO_FLAGS_PARTSCANLO_FLAGS_DIRECT_IOMPOL_MODE_FLAGSMPOL_F_NODEMPOL_F_ADDRMPOL_F_MEMS_ALLOWEDMPOL_MF_STRICTMPOL_MF_MOVEMPOL_MF_MOVE_ALLMPOL_MF_LAZYMPOL_MF_INTERNALMPOL_MF_VALIDMPOL_F_SHAREDMPOL_F_MOFMPOL_F_MORONRECLAIM_ZONERECLAIM_WRITERECLAIM_UNMAPMPOL_PREFERRED_MANYMPOL_WEIGHTED_INTERLEAVEMPOL_MAXimsf_multiaddrimsf_interfaceimsf_fmodeimsf_numsrcip_msfilter__bindgen_ty_1ip_msfilterimsf_slistip_msfilter__bindgen_ty_1__bindgen_ty_1__empty_imsf_slist_flexip_msfilter__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1imsf_slist_flexgr_interfacegr_groupgroup_reqgsr_interfacegsr_groupgsr_sourcegroup_source_reqgroup_filter__bindgen_ty_1group_filtergroup_filter__bindgen_ty_1__bindgen_ty_1group_filter__bindgen_ty_1__bindgen_ty_234usizegf_interface_auxgf_group_auxgf_fmode_auxgf_numsrc_auxgf_slistgf_interfacegf_groupgf_fmodegf_numsrcgf_slist_flextostot_lenfrag_offiphdr__bindgen_ty_1iphdrsaddrdaddriphdr__bindgen_ty_1__bindgen_ty_1iphdr__bindgen_ty_1__bindgen_ty_2nexthdrhdrlenspiauth_dataip_auth_hdrenc_dataip_esp_hdrcpiip_comp_hdrpadlenip_beet_phdrblock_offsetip_iptfs_hdrloss_ratertt_adelay_xdelaytvaltechoip_iptfs_cc_hdrin6_uin6_addr__bindgen_ty_1ipv6mr_ifindexflr_dstflr_labelflr_actionflr_shareflr_flagsflr_expiresflr_linger__flr_padin6_flowlabel_reqip6m_addrip6m_mtuip6_mtuinfosegments_leftipv6_rt_hdripv6_opt_hdrrt_hdrrt0_hdrrt2_hdripv6_destopt_haoflow_lblpayload_lenhop_limitipv6hdr__bindgen_ty_1ipv6hdripv6hdr__bindgen_ty_1__bindgen_ty_1ipv6hdr__bindgen_ty_1__bindgen_ty_2ack_sequrg_ptrtcphdropt_codetcp_repair_optsnd_wl1max_windowrcv_wuptcp_repair_windowtcpi_pacing_ratetcpi_max_pacing_ratetcpi_bytes_ackedtcpi_bytes_receivedtcpi_segs_outtcpi_segs_intcpi_notsent_bytestcpi_min_rtttcpi_data_segs_intcpi_data_segs_outtcpi_delivery_ratetcpi_busy_timetcpi_rwnd_limitedtcpi_sndbuf_limitedtcpi_deliveredtcpi_delivered_cetcpi_bytes_senttcpi_bytes_retranstcpi_dsack_dupstcpi_reord_seentcpi_rcv_ooopacktcpi_snd_wndtcpi_rcv_wndtcpi_rehashtcpi_total_rtotcpi_total_rto_recoveriestcpi_total_rto_timetcpm_addrtcpm_flagstcpm_prefixlentcpm_keylentcpm_ifindextcpm_key80usizetcp_md5sigtcpm_familytcp_diag_md5sigalg_namesndidrcvidmaclenkeyflagskeylentcp_ao_addrnexttcp_ao_delpkt_goodpkt_badpkt_key_not_foundpkt_ao_requiredpkt_dropped_icmptcp_ao_info_optnkeystcp_ao_getsockoptsnt_isnrcv_isnsnd_snercv_snetcp_ao_repairrecv_skip_hintinqcopybuf_addresscopybuf_lentcp_zerocopy_receive108usizext_entry_match__bindgen_ty_1xt_entry_matchmatch_size29usizerevisionxt_entry_match__bindgen_ty_1__bindgen_ty_1xt_matchxt_entry_match__bindgen_ty_1__bindgen_ty_2xt_entry_target__bindgen_ty_1xt_entry_targettarget_sizext_entry_target__bindgen_ty_1__bindgen_ty_1xt_targetxt_entry_target__bindgen_ty_1__bindgen_ty_2verdictxt_standard_target30usizext_error_targetxt_get_revisionu8_u16_u32_u64__xt_alignpcntbcntxt_countersnum_countersxt_counters_infosptsdptsflg_maskflg_cmpinvflagsxt_tcpxt_udpsmskdmskinifaceoutifaceiniface_maskoutiface_maskip6t_ip6nfcachetarget_offsetcomefromip6t_entryip6t_standardip6t_errorip6t_icmpvalid_hookshook_entryip6t_getinfoip6t_replaceentrytableip6t_get_entriesbind_phcso_timestampingpkt_lengthscm_ts_pktinfoIP_RECVERR_RFC4884IP_LOCAL_PORT_RANGEIP_PROTOCOL__SOCK_SIZE__IN_MULTICAST_NETIN_CLASSE_NETIN_CLASSE_NSHIFTINADDR_UNSPEC_GROUPINADDR_ALLHOSTS_GROUPINADDR_ALLRTRS_GROUPINADDR_ALLSNOOPERS_GROUPINADDR_MAX_LOCAL_GROUPIPOPT_CIPSOIPV4_BEET_PHMAXLENIPV6_FL_A_GETIPV6_FL_A_PUTIPV6_FL_A_RENEWIPV6_FL_F_CREATEIPV6_FL_F_EXCLIPV6_FL_F_REFLECTIPV6_FL_F_REMOTEIPV6_FL_S_NONEIPV6_FL_S_EXCLIPV6_FL_S_PROCESSIPV6_FL_S_USERIPV6_FL_S_ANYIPV6_PRIORITY_UNCHARACTERIZEDIPV6_PRIORITY_FILLERIPV6_PRIORITY_UNATTENDEDIPV6_PRIORITY_RESERVED1IPV6_PRIORITY_BULKIPV6_PRIORITY_RESERVED2IPV6_PRIORITY_INTERACTIVEIPV6_PRIORITY_CONTROLIPV6_PRIORITY_8IPV6_PRIORITY_9IPV6_PRIORITY_10IPV6_PRIORITY_11IPV6_PRIORITY_12IPV6_PRIORITY_13IPV6_PRIORITY_14IPV6_PRIORITY_15IPV6_TLV_PAD1IPV6_TLV_PADNIPV6_TLV_ROUTERALERTIPV6_TLV_CALIPSOIPV6_TLV_IOAMIPV6_TLV_JUMBOIPV6_TLV_HAOIPV6_RECVERR_RFC4884IPV6_MIN_MTUIPV6_SRCRT_STRICTIPV6_SRCRT_TYPE_0IPV6_SRCRT_TYPE_2IPV6_SRCRT_TYPE_3IPV6_SRCRT_TYPE_4IPV6_OPT_ROUTERALERT_MLDSIOCGSTAMP_OLDSIOCGSTAMPNS_OLDSCM_TS_OPT_IDSO_RCVPRIORITYSO_PASSRIGHTSSYS_SOCKETSYS_BINDSYS_CONNECTSYS_LISTENSYS_ACCEPTSYS_GETSOCKNAMESYS_GETPEERNAMESYS_SOCKETPAIRSYS_SENDSYS_RECVSYS_SENDTOSYS_RECVFROMSYS_SHUTDOWNSYS_SETSOCKOPTSYS_GETSOCKOPTSYS_SENDMSGSYS_RECVMSGSYS_RECVMMSGSYS_SENDMMSG__SO_ACCEPTCONTCP_AO_ADD_KEYTCP_AO_DEL_KEYTCP_AO_INFOTCP_AO_GET_KEYSTCP_AO_REPAIRTCP_IS_MPTCPTCP_RTO_MAX_MSTCP_RTO_MIN_USTCP_DELACK_MAX_USTCPI_OPT_USEC_TSTCPI_OPT_TFO_CHILDTCP_MD5SIG_FLAG_IFINDEXTCP_AO_MAXKEYLENTCP_AO_KEYF_IFINDEXTCP_AO_KEYF_EXCLUDE_OPTTCP_RECEIVE_ZEROCOPY_FLAG_TLB_CLEAN_HINTUNIX_PATH_MAXXT_FUNCTION_MAXNAMELENXT_EXTENSION_MAXNAMELENXT_TABLE_MAXNAMELENXT_CONTINUEXT_RETURNXT_STANDARD_TARGETXT_ERROR_TARGETXT_INV_PROTOIP6T_FUNCTION_MAXNAMELENIP6T_TABLE_MAXNAMELENIP6T_CONTINUEIP6T_RETURNXT_TCP_INV_SRCPTXT_TCP_INV_DSTPTXT_TCP_INV_FLAGSXT_TCP_INV_OPTIONXT_TCP_INV_MASKXT_UDP_INV_SRCPTXT_UDP_INV_DSTPTXT_UDP_INV_MASKIP6T_TCP_INV_SRCPTIP6T_TCP_INV_DSTPTIP6T_TCP_INV_FLAGSIP6T_TCP_INV_OPTIONIP6T_TCP_INV_MASKIP6T_UDP_INV_SRCPTIP6T_UDP_INV_DSTPTIP6T_UDP_INV_MASKIP6T_STANDARD_TARGETIP6T_ERROR_TARGETIP6T_F_PROTOIP6T_F_TOSIP6T_F_GOTOIP6T_F_MASKIP6T_INV_VIA_INIP6T_INV_VIA_OUTIP6T_INV_TOSIP6T_INV_SRCIPIP6T_INV_DSTIPIP6T_INV_FRAGIP6T_INV_PROTOIP6T_INV_MASKIP6T_BASE_CTLIP6T_SO_SET_REPLACEIP6T_SO_SET_ADD_COUNTERSIP6T_SO_SET_MAXIP6T_SO_GET_INFOIP6T_SO_GET_ENTRIESIP6T_SO_GET_REVISION_MATCHIP6T_SO_GET_REVISION_TARGETIP6T_SO_GET_MAXIP6T_ICMP_INVAF_SMCAF_MCTPMSG_PROBESCM_SECURITYSOL_UDPLITESOL_MPTCPSOL_MCTPSOL_SMCIPPROTO_AGGFRAGIPPROTO_SMCIPV4_DEVCONF_FORWARDINGIPV4_DEVCONF_MC_FORWARDINGIPV4_DEVCONF_PROXY_ARPIPV4_DEVCONF_ACCEPT_REDIRECTSIPV4_DEVCONF_SECURE_REDIRECTSIPV4_DEVCONF_SEND_REDIRECTSIPV4_DEVCONF_SHARED_MEDIAIPV4_DEVCONF_RP_FILTERIPV4_DEVCONF_ACCEPT_SOURCE_ROUTEIPV4_DEVCONF_BOOTP_RELAYIPV4_DEVCONF_LOG_MARTIANSIPV4_DEVCONF_TAGIPV4_DEVCONF_ARPFILTERIPV4_DEVCONF_MEDIUM_IDIPV4_DEVCONF_NOXFRMIPV4_DEVCONF_NOPOLICYIPV4_DEVCONF_FORCE_IGMP_VERSIONIPV4_DEVCONF_ARP_ANNOUNCEIPV4_DEVCONF_ARP_IGNOREIPV4_DEVCONF_PROMOTE_SECONDARIESIPV4_DEVCONF_ARP_ACCEPTIPV4_DEVCONF_ARP_NOTIFYIPV4_DEVCONF_ACCEPT_LOCALIPV4_DEVCONF_SRC_VMARKIPV4_DEVCONF_PROXY_ARP_PVLANIPV4_DEVCONF_ROUTE_LOCALNETIPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVALIPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVALIPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWNIPV4_DEVCONF_DROP_UNICAST_IN_L2_MULTICASTIPV4_DEVCONF_DROP_GRATUITOUS_ARPIPV4_DEVCONF_BC_FORWARDINGIPV4_DEVCONF_ARP_EVICT_NOCARRIER__IPV4_DEVCONF_MAXDEVCONF_FORWARDINGDEVCONF_HOPLIMITDEVCONF_MTU6DEVCONF_ACCEPT_RADEVCONF_ACCEPT_REDIRECTSDEVCONF_AUTOCONFDEVCONF_DAD_TRANSMITSDEVCONF_RTR_SOLICITSDEVCONF_RTR_SOLICIT_INTERVALDEVCONF_RTR_SOLICIT_DELAYDEVCONF_USE_TEMPADDRDEVCONF_TEMP_VALID_LFTDEVCONF_TEMP_PREFERED_LFTDEVCONF_REGEN_MAX_RETRYDEVCONF_MAX_DESYNC_FACTORDEVCONF_MAX_ADDRESSESDEVCONF_FORCE_MLD_VERSIONDEVCONF_ACCEPT_RA_DEFRTRDEVCONF_ACCEPT_RA_PINFODEVCONF_ACCEPT_RA_RTR_PREFDEVCONF_RTR_PROBE_INTERVALDEVCONF_ACCEPT_RA_RT_INFO_MAX_PLENDEVCONF_PROXY_NDPDEVCONF_OPTIMISTIC_DADDEVCONF_ACCEPT_SOURCE_ROUTEDEVCONF_MC_FORWARDINGDEVCONF_DISABLE_IPV6DEVCONF_ACCEPT_DADDEVCONF_FORCE_TLLAODEVCONF_NDISC_NOTIFYDEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVALDEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVALDEVCONF_SUPPRESS_FRAG_NDISCDEVCONF_ACCEPT_RA_FROM_LOCALDEVCONF_USE_OPTIMISTICDEVCONF_ACCEPT_RA_MTUDEVCONF_STABLE_SECRETDEVCONF_USE_OIF_ADDRS_ONLYDEVCONF_ACCEPT_RA_MIN_HOP_LIMITDEVCONF_IGNORE_ROUTES_WITH_LINKDOWNDEVCONF_DROP_UNICAST_IN_L2_MULTICASTDEVCONF_DROP_UNSOLICITED_NADEVCONF_KEEP_ADDR_ON_DOWNDEVCONF_RTR_SOLICIT_MAX_INTERVALDEVCONF_SEG6_ENABLEDDEVCONF_SEG6_REQUIRE_HMACDEVCONF_ENHANCED_DADDEVCONF_ADDR_GEN_MODEDEVCONF_DISABLE_POLICYDEVCONF_ACCEPT_RA_RT_INFO_MIN_PLENDEVCONF_NDISC_TCLASSDEVCONF_RPL_SEG_ENABLEDDEVCONF_RA_DEFRTR_METRICDEVCONF_IOAM6_ENABLEDDEVCONF_IOAM6_IDDEVCONF_IOAM6_ID_WIDEDEVCONF_NDISC_EVICT_NOCARRIERDEVCONF_ACCEPT_UNTRACKED_NADEVCONF_ACCEPT_RA_MIN_LFTDEVCONF_MAXTCP_FLAG_AETCP_FLAG_CWRTCP_FLAG_ECETCP_FLAG_URGTCP_FLAG_ACKTCP_FLAG_PSHTCP_FLAG_RSTTCP_FLAG_SYNTCP_FLAG_FINTCP_RESERVED_BITSTCP_DATA_OFFSETTCP_NLA_PADTCP_NLA_BUSYTCP_NLA_RWND_LIMITEDTCP_NLA_SNDBUF_LIMITEDTCP_NLA_DATA_SEGS_OUTTCP_NLA_TOTAL_RETRANSTCP_NLA_PACING_RATETCP_NLA_DELIVERY_RATETCP_NLA_SND_CWNDTCP_NLA_REORDERINGTCP_NLA_MIN_RTTTCP_NLA_RECUR_RETRANSTCP_NLA_DELIVERY_RATE_APP_LMTTCP_NLA_SNDQ_SIZETCP_NLA_CA_STATETCP_NLA_SND_SSTHRESHTCP_NLA_DELIVEREDTCP_NLA_DELIVERED_CETCP_NLA_BYTES_SENTTCP_NLA_BYTES_RETRANSTCP_NLA_DSACK_DUPSTCP_NLA_REORD_SEENTCP_NLA_SRTTTCP_NLA_TIMEOUT_REHASHTCP_NLA_BYTES_NOTSENTTCP_NLA_EDTTCP_NLA_TTLTCP_NLA_REHASHSOF_TIMESTAMPING_TX_COMPLETIONSOF_TIMESTAMPING_LASTSOF_TIMESTAMPING_MASKsocket_stateSS_FREESS_UNCONNECTEDSS_CONNECTINGSS_CONNECTEDSS_DISCONNECTINGtcp_fastopen_client_failTFO_STATUS_UNSPECTFO_COOKIE_UNAVAILABLETFO_DATA_NOT_ACKEDTFO_SYN_RETRANSMITTEDnf_inet_hooksnf_dev_hooksnf_ip6_hook_priorities4502147483647nf_ip_hook_prioritieshwtstamp_provider_qualifierHWTSTAMP_PROVIDER_QUALIFIER_PRECISEHWTSTAMP_PROVIDER_QUALIFIER_APPROXHWTSTAMP_PROVIDER_QUALIFIER_CNT524287hwtstamp_flagsHWTSTAMP_FLAG_BONDED_PHC_INDEXhwtstamp_tx_types__HWTSTAMP_TX_CNThwtstamp_rx_filters__HWTSTAMP_FILTER_CNTtxtime_flagsSOF_TXTIME_FLAGS_MASKu6_addr8u6_addr16u6_addr32tcp_word_hdrnf_inet_addrip6in6ihlset_ihlihl_rawset_ihl_rawversion_rawset_version_rawpriority_rawset_priority_rawset_aeae_rawset_ae_rawres1set_res1res1_rawset_res1_rawdoffset_doffdoff_rawset_doff_rawfinfin_rawset_fin_rawsyn_rawset_syn_rawrstrst_rawset_rst_rawpshset_pshpsh_rawset_psh_rawackack_rawset_ack_rawurgset_urgurg_rawset_urg_raweceset_eceece_rawset_ece_rawcwrset_cwrcwr_rawset_cwr_rawtcpi_snd_wscaleset_tcpi_snd_wscaletcpi_snd_wscale_rawset_tcpi_snd_wscale_rawtcpi_rcv_wscaleset_tcpi_rcv_wscaletcpi_rcv_wscale_rawset_tcpi_rcv_wscale_rawtcpi_delivery_rate_app_limitedset_tcpi_delivery_rate_app_limitedtcpi_delivery_rate_app_limited_rawset_tcpi_delivery_rate_app_limited_rawtcpi_fastopen_client_failset_tcpi_fastopen_client_failtcpi_fastopen_client_fail_rawset_tcpi_fastopen_client_fail_rawset_currentset_set_currentset_current_rawset_set_current_rawset_rnextset_set_rnextset_rnext_rawset_set_rnext_rawset_reservedreserved_rawset_reserved_rawdel_asyncset_del_asyncdel_async_rawset_del_async_rawao_requiredset_ao_requiredao_required_rawset_ao_required_rawset_countersset_set_countersset_counters_rawset_set_counters_rawaccept_icmpsset_accept_icmpsaccept_icmps_rawset_accept_icmps_rawis_currentset_is_currentis_current_rawset_is_current_rawis_rnextset_is_rnextis_rnext_rawset_is_rnext_rawset_get_allget_all_rawset_get_all_rawHWTSTAMP_FLAG_LASTHWTSTAMP_FLAG_MASKSOF_TXTIME_FLAGS_LASTnl80211_sta_flag_updatemcsnl80211_txrate_vhtnl80211_txrate_hemax_patternsmax_pkt_offsetnl80211_pattern_supportnl80211_wowlan_tcp_data_seqnl80211_wowlan_tcp_data_tokenmin_lenbufsizenl80211_wowlan_tcp_data_token_featuremax_rulespatmax_delaynl80211_coalesce_rule_supportnl80211_vendor_cmd_infobandnl80211_bss_select_rssi_adjustifa_familyifa_prefixlenifa_scopeifa_indexifaddrmsgifa_preferedifa_validcstampifa_cacheinfondm_familyndm_pad1ndm_pad2ndm_ifindexndm_statendm_flagsndm_typendmsgndm_confirmedndm_usedndm_updatedndm_refcntnda_cacheinfondts_allocsndts_destroysndts_hash_growsndts_res_failedndts_lookupsndts_hitsndts_rcv_probes_mcastndts_rcv_probes_ucastndts_periodic_gc_runsndts_forced_gc_runsndts_table_fullsndt_statsndtm_familyndtm_pad1ndtm_pad2ndtmsgndtc_key_lenndtc_entry_sizendtc_entriesndtc_last_flushndtc_last_randndtc_hash_rndndtc_hash_maskndtc_hash_chain_gcndtc_proxy_qlenndt_configrta_lenrta_typertattrrtm_familyrtm_dst_lenrtm_src_lenrtm_tosrtm_tablertm_protocolrtm_scopertm_typertm_flagsrtmsgrtnh_lenrtnh_flagsrtnh_hopsrtnh_ifindexrtnexthoprtvia_familyrtvia_addrrtviarta_clntrefrta_lastuserta_expiresrta_errorrta_usedrta_idrta_tsrta_tsagerta_cacheinforta_session__bindgen_ty_1rta_sessionsportdportrta_session__bindgen_ty_1__bindgen_ty_1rta_session__bindgen_ty_1__bindgen_ty_2mfcs_packetsmfcs_bytesmfcs_wrong_ifrta_mfc_statsrtgen_familyrtgenmsgifi_family__ifi_padifi_typeifi_indexifi_flagsifi_changeifinfomsgprefix_familyprefix_pad1prefix_pad2prefix_ifindexprefix_typeprefix_flagsprefix_pad3prefixmsgpreferred_timevalid_timeprefix_cacheinfotcm_familytcm__pad1tcm__pad2tcm_ifindextcm_handletcm_parenttcm_infotcmsgnduseropt_familynduseropt_pad1nduseropt_opts_lennduseropt_ifindexnduseropt_icmp_typenduseropt_icmp_codenduseropt_pad2nduseropt_pad3nduseroptmsgtca_familytca__pad1tca__pad2tcamsgNL80211_GENL_NAMENL80211_MULTICAST_GROUP_CONFIGNL80211_MULTICAST_GROUP_SCANNL80211_MULTICAST_GROUP_REGNL80211_MULTICAST_GROUP_MLMENL80211_MULTICAST_GROUP_VENDORNL80211_MULTICAST_GROUP_NANNL80211_MULTICAST_GROUP_TESTMODENL80211_EDMG_BW_CONFIG_MINNL80211_EDMG_BW_CONFIG_MAXNL80211_EDMG_CHANNELS_MINNL80211_EDMG_CHANNELS_MAXNL80211_WIPHY_NAME_MAXLENNL80211_MAX_SUPP_RATESNL80211_MAX_SUPP_SELECTORSNL80211_MAX_SUPP_HT_RATESNL80211_MAX_SUPP_REG_RULESNL80211_TKIP_DATA_OFFSET_ENCR_KEYNL80211_TKIP_DATA_OFFSET_TX_MIC_KEYNL80211_TKIP_DATA_OFFSET_RX_MIC_KEYNL80211_HT_CAPABILITY_LENNL80211_VHT_CAPABILITY_LENNL80211_HE_MIN_CAPABILITY_LENNL80211_HE_MAX_CAPABILITY_LENNL80211_MAX_NR_CIPHER_SUITESNL80211_MAX_NR_AKM_SUITESNL80211_EHT_MIN_CAPABILITY_LENNL80211_EHT_MAX_CAPABILITY_LENNL80211_MIN_REMAIN_ON_CHANNEL_TIMENL80211_SCAN_RSSI_THOLD_OFFNL80211_CQM_TXE_MAX_INTVLNL80211_VHT_NSS_MAXNL80211_HE_NSS_MAXNL80211_KCK_LENNL80211_KEK_LENNL80211_KCK_EXT_LENNL80211_KEK_EXT_LENNL80211_KCK_EXT_LEN_32NL80211_REPLAY_CTR_LENNL80211_CRIT_PROTO_MAX_DURATIONNL80211_VENDOR_ID_IS_LINUXNL80211_NAN_FUNC_SERVICE_ID_LENNL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LENNL80211_NAN_FUNC_SRF_MAX_LENNL80211_FILS_DISCOVERY_TMPL_MIN_LENIFAPROT_UNSPECIFAPROT_KERNEL_LOIFAPROT_KERNEL_RAIFAPROT_KERNEL_LLRTNL_FAMILY_IPMRRTNL_FAMILY_IP6MRRTNL_FAMILY_MAXRTA_ALIGNTORTPROT_GATEDRTPROT_RARTPROT_MRTRTPROT_ZEBRARTPROT_BIRDRTPROT_DNROUTEDRTPROT_XORPRTPROT_NTKRTPROT_DHCPRTPROT_MROUTEDRTPROT_KEEPALIVEDRTPROT_BABELRTPROT_OVNRTPROT_OPENRRTPROT_BGPRTPROT_ISISRTPROT_OSPFRTPROT_RIPRTPROT_EIGRPRTM_F_OFFLOADRTM_F_TRAPRTM_F_OFFLOAD_FAILEDRTNH_F_DEADRTNH_F_PERVASIVERTNH_F_ONLINKRTNH_F_OFFLOADRTNH_F_LINKDOWNRTNH_F_UNRESOLVEDRTNH_F_TRAPRTNH_COMPARE_MASKRTNH_ALIGNTORTNETLINK_HAVE_PEERINFORTAX_FEATURE_ECNRTAX_FEATURE_SACKRTAX_FEATURE_TIMESTAMPRTAX_FEATURE_ALLFRAGRTAX_FEATURE_TCP_USEC_TSRTAX_FEATURE_MASKTCM_IFINDEX_MAGIC_BLOCKTCA_DUMP_FLAGS_TERSETCA_FLAG_LARGE_DUMP_ONTCA_ACT_FLAG_LARGE_DUMP_ONTCA_ACT_FLAG_TERSE_DUMPRTEXT_FILTER_MSTIFA_RT_PRIORITYIFA_TARGET_NETNSIDIFA_PROTO__IFA_MAX__NDA_MAX__NDTPA_MAX_bindgen_ty_59__NDTA_MAX_bindgen_ty_60_bindgen_ty_61__NFEA_MAXRTM_BASE_bindgen_ty_62RTM_NEWMULTICASTRTM_DELMULTICASTRTM_NEWANYCASTRTM_DELANYCASTRTM_SETSTATSRTM_NEWCHAINRTM_DELCHAINRTM_GETCHAINRTM_NEWNEXTHOPRTM_DELNEXTHOPRTM_GETNEXTHOPRTM_NEWLINKPROPRTM_DELLINKPROPRTM_GETLINKPROPRTM_NEWVLANRTM_DELVLANRTM_GETVLANRTM_NEWNEXTHOPBUCKETRTM_DELNEXTHOPBUCKETRTM_GETNEXTHOPBUCKETRTM_NEWTUNNELRTM_DELTUNNELRTM_GETTUNNEL__RTM_MAX_bindgen_ty_63__RTN_MAXRTAX_UNSPEC_bindgen_ty_64RTAX_LOCKRTAX_MTURTAX_WINDOWRTAX_RTTRTAX_RTTVARRTAX_SSTHRESHRTAX_CWNDRTAX_ADVMSSRTAX_REORDERINGRTAX_HOPLIMITRTAX_INITCWNDRTAX_FEATURESRTAX_RTO_MINRTAX_INITRWNDRTAX_QUICKACKRTAX_CC_ALGORTAX_FASTOPEN_NO_COOKIE__RTAX_MAXPREFIX_UNSPEC_bindgen_ty_65PREFIX_ADDRESSPREFIX_CACHEINFO__PREFIX_MAX_bindgen_ty_66TCA_INGRESS_BLOCKTCA_EGRESS_BLOCKTCA_DUMP_FLAGSTCA_EXT_WARN_MSG__TCA_MAXNDUSEROPT_UNSPEC_bindgen_ty_67NDUSEROPT_SRCADDR__NDUSEROPT_MAXTCA_ROOT_UNSPEC_bindgen_ty_68TCA_ROOT_TABTCA_ROOT_FLAGSTCA_ROOT_COUNTTCA_ROOT_TIME_DELTATCA_ROOT_EXT_WARN_MSG__TCA_ROOT_MAXnl80211_commandsNL80211_CMD_UNSPECNL80211_CMD_GET_WIPHYNL80211_CMD_SET_WIPHYNL80211_CMD_NEW_WIPHYNL80211_CMD_DEL_WIPHYNL80211_CMD_GET_INTERFACENL80211_CMD_SET_INTERFACENL80211_CMD_NEW_INTERFACENL80211_CMD_DEL_INTERFACENL80211_CMD_GET_KEYNL80211_CMD_SET_KEYNL80211_CMD_NEW_KEYNL80211_CMD_DEL_KEYNL80211_CMD_GET_BEACONNL80211_CMD_SET_BEACONNL80211_CMD_START_APNL80211_CMD_STOP_APNL80211_CMD_GET_STATIONNL80211_CMD_SET_STATIONNL80211_CMD_NEW_STATIONNL80211_CMD_DEL_STATIONNL80211_CMD_GET_MPATHNL80211_CMD_SET_MPATHNL80211_CMD_NEW_MPATHNL80211_CMD_DEL_MPATHNL80211_CMD_SET_BSSNL80211_CMD_SET_REGNL80211_CMD_REQ_SET_REGNL80211_CMD_GET_MESH_CONFIGNL80211_CMD_SET_MESH_CONFIGNL80211_CMD_SET_MGMT_EXTRA_IENL80211_CMD_GET_REGNL80211_CMD_GET_SCANNL80211_CMD_TRIGGER_SCANNL80211_CMD_NEW_SCAN_RESULTSNL80211_CMD_SCAN_ABORTEDNL80211_CMD_REG_CHANGENL80211_CMD_AUTHENTICATENL80211_CMD_ASSOCIATENL80211_CMD_DEAUTHENTICATENL80211_CMD_DISASSOCIATENL80211_CMD_MICHAEL_MIC_FAILURENL80211_CMD_REG_BEACON_HINTNL80211_CMD_JOIN_IBSSNL80211_CMD_LEAVE_IBSSNL80211_CMD_TESTMODENL80211_CMD_CONNECTNL80211_CMD_ROAMNL80211_CMD_DISCONNECTNL80211_CMD_SET_WIPHY_NETNSNL80211_CMD_GET_SURVEYNL80211_CMD_NEW_SURVEY_RESULTSNL80211_CMD_SET_PMKSANL80211_CMD_DEL_PMKSANL80211_CMD_FLUSH_PMKSANL80211_CMD_REMAIN_ON_CHANNELNL80211_CMD_CANCEL_REMAIN_ON_CHANNELNL80211_CMD_SET_TX_BITRATE_MASKNL80211_CMD_REGISTER_FRAMENL80211_CMD_FRAMENL80211_CMD_FRAME_TX_STATUSNL80211_CMD_SET_POWER_SAVENL80211_CMD_GET_POWER_SAVENL80211_CMD_SET_CQMNL80211_CMD_NOTIFY_CQMNL80211_CMD_SET_CHANNELNL80211_CMD_SET_WDS_PEERNL80211_CMD_FRAME_WAIT_CANCELNL80211_CMD_JOIN_MESHNL80211_CMD_LEAVE_MESHNL80211_CMD_UNPROT_DEAUTHENTICATENL80211_CMD_UNPROT_DISASSOCIATENL80211_CMD_NEW_PEER_CANDIDATENL80211_CMD_GET_WOWLANNL80211_CMD_SET_WOWLANNL80211_CMD_START_SCHED_SCANNL80211_CMD_STOP_SCHED_SCANNL80211_CMD_SCHED_SCAN_RESULTSNL80211_CMD_SCHED_SCAN_STOPPEDNL80211_CMD_SET_REKEY_OFFLOADNL80211_CMD_PMKSA_CANDIDATENL80211_CMD_TDLS_OPERNL80211_CMD_TDLS_MGMTNL80211_CMD_UNEXPECTED_FRAMENL80211_CMD_PROBE_CLIENTNL80211_CMD_REGISTER_BEACONSNL80211_CMD_UNEXPECTED_4ADDR_FRAMENL80211_CMD_SET_NOACK_MAPNL80211_CMD_CH_SWITCH_NOTIFYNL80211_CMD_START_P2P_DEVICENL80211_CMD_STOP_P2P_DEVICENL80211_CMD_CONN_FAILEDNL80211_CMD_SET_MCAST_RATENL80211_CMD_SET_MAC_ACLNL80211_CMD_RADAR_DETECTNL80211_CMD_GET_PROTOCOL_FEATURESNL80211_CMD_UPDATE_FT_IESNL80211_CMD_FT_EVENTNL80211_CMD_CRIT_PROTOCOL_STARTNL80211_CMD_CRIT_PROTOCOL_STOPNL80211_CMD_GET_COALESCENL80211_CMD_SET_COALESCENL80211_CMD_CHANNEL_SWITCHNL80211_CMD_VENDORNL80211_CMD_SET_QOS_MAPNL80211_CMD_ADD_TX_TSNL80211_CMD_DEL_TX_TSNL80211_CMD_GET_MPPNL80211_CMD_JOIN_OCBNL80211_CMD_LEAVE_OCBNL80211_CMD_CH_SWITCH_STARTED_NOTIFYNL80211_CMD_TDLS_CHANNEL_SWITCHNL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCHNL80211_CMD_WIPHY_REG_CHANGENL80211_CMD_ABORT_SCANNL80211_CMD_START_NANNL80211_CMD_STOP_NANNL80211_CMD_ADD_NAN_FUNCTIONNL80211_CMD_DEL_NAN_FUNCTIONNL80211_CMD_CHANGE_NAN_CONFIGNL80211_CMD_NAN_MATCHNL80211_CMD_SET_MULTICAST_TO_UNICASTNL80211_CMD_UPDATE_CONNECT_PARAMSNL80211_CMD_SET_PMKNL80211_CMD_DEL_PMKNL80211_CMD_PORT_AUTHORIZEDNL80211_CMD_RELOAD_REGDBNL80211_CMD_EXTERNAL_AUTHNL80211_CMD_STA_OPMODE_CHANGEDNL80211_CMD_CONTROL_PORT_FRAMENL80211_CMD_GET_FTM_RESPONDER_STATSNL80211_CMD_PEER_MEASUREMENT_STARTNL80211_CMD_PEER_MEASUREMENT_RESULTNL80211_CMD_PEER_MEASUREMENT_COMPLETENL80211_CMD_NOTIFY_RADARNL80211_CMD_UPDATE_OWE_INFONL80211_CMD_PROBE_MESH_LINKNL80211_CMD_SET_TID_CONFIGNL80211_CMD_UNPROT_BEACONNL80211_CMD_CONTROL_PORT_FRAME_TX_STATUSNL80211_CMD_SET_SAR_SPECSNL80211_CMD_OBSS_COLOR_COLLISIONNL80211_CMD_COLOR_CHANGE_REQUESTNL80211_CMD_COLOR_CHANGE_STARTEDNL80211_CMD_COLOR_CHANGE_ABORTEDNL80211_CMD_COLOR_CHANGE_COMPLETEDNL80211_CMD_SET_FILS_AADNL80211_CMD_ASSOC_COMEBACKNL80211_CMD_ADD_LINKNL80211_CMD_REMOVE_LINKNL80211_CMD_ADD_LINK_STANL80211_CMD_MODIFY_LINK_STANL80211_CMD_REMOVE_LINK_STANL80211_CMD_SET_HW_TIMESTAMPNL80211_CMD_LINKS_REMOVEDNL80211_CMD_SET_TID_TO_LINK_MAPPINGNL80211_CMD_ASSOC_MLO_RECONFNL80211_CMD_EPCS_CFG__NL80211_CMD_AFTER_LASTnl80211_attrsNL80211_ATTR_UNSPECNL80211_ATTR_WIPHYNL80211_ATTR_WIPHY_NAMENL80211_ATTR_IFINDEXNL80211_ATTR_IFNAMENL80211_ATTR_IFTYPENL80211_ATTR_MACNL80211_ATTR_KEY_DATANL80211_ATTR_KEY_IDXNL80211_ATTR_KEY_CIPHERNL80211_ATTR_KEY_SEQNL80211_ATTR_KEY_DEFAULTNL80211_ATTR_BEACON_INTERVALNL80211_ATTR_DTIM_PERIODNL80211_ATTR_BEACON_HEADNL80211_ATTR_BEACON_TAILNL80211_ATTR_STA_AIDNL80211_ATTR_STA_FLAGSNL80211_ATTR_STA_LISTEN_INTERVALNL80211_ATTR_STA_SUPPORTED_RATESNL80211_ATTR_STA_VLANNL80211_ATTR_STA_INFONL80211_ATTR_WIPHY_BANDSNL80211_ATTR_MNTR_FLAGSNL80211_ATTR_MESH_IDNL80211_ATTR_STA_PLINK_ACTIONNL80211_ATTR_MPATH_NEXT_HOPNL80211_ATTR_MPATH_INFONL80211_ATTR_BSS_CTS_PROTNL80211_ATTR_BSS_SHORT_PREAMBLENL80211_ATTR_BSS_SHORT_SLOT_TIMENL80211_ATTR_HT_CAPABILITYNL80211_ATTR_SUPPORTED_IFTYPESNL80211_ATTR_REG_ALPHA2NL80211_ATTR_REG_RULESNL80211_ATTR_MESH_CONFIGNL80211_ATTR_BSS_BASIC_RATESNL80211_ATTR_WIPHY_TXQ_PARAMSNL80211_ATTR_WIPHY_FREQNL80211_ATTR_WIPHY_CHANNEL_TYPENL80211_ATTR_KEY_DEFAULT_MGMTNL80211_ATTR_MGMT_SUBTYPENL80211_ATTR_IENL80211_ATTR_MAX_NUM_SCAN_SSIDSNL80211_ATTR_SCAN_FREQUENCIESNL80211_ATTR_SCAN_SSIDSNL80211_ATTR_GENERATIONNL80211_ATTR_BSSNL80211_ATTR_REG_INITIATORNL80211_ATTR_REG_TYPENL80211_ATTR_SUPPORTED_COMMANDSNL80211_ATTR_FRAMENL80211_ATTR_SSIDNL80211_ATTR_AUTH_TYPENL80211_ATTR_REASON_CODENL80211_ATTR_KEY_TYPENL80211_ATTR_MAX_SCAN_IE_LENNL80211_ATTR_CIPHER_SUITESNL80211_ATTR_FREQ_BEFORENL80211_ATTR_FREQ_AFTERNL80211_ATTR_FREQ_FIXEDNL80211_ATTR_WIPHY_RETRY_SHORTNL80211_ATTR_WIPHY_RETRY_LONGNL80211_ATTR_WIPHY_FRAG_THRESHOLDNL80211_ATTR_WIPHY_RTS_THRESHOLDNL80211_ATTR_TIMED_OUTNL80211_ATTR_USE_MFPNL80211_ATTR_STA_FLAGS2NL80211_ATTR_CONTROL_PORTNL80211_ATTR_TESTDATANL80211_ATTR_PRIVACYNL80211_ATTR_DISCONNECTED_BY_APNL80211_ATTR_STATUS_CODENL80211_ATTR_CIPHER_SUITES_PAIRWISENL80211_ATTR_CIPHER_SUITE_GROUPNL80211_ATTR_WPA_VERSIONSNL80211_ATTR_AKM_SUITESNL80211_ATTR_REQ_IENL80211_ATTR_RESP_IENL80211_ATTR_PREV_BSSIDNL80211_ATTR_KEYNL80211_ATTR_KEYSNL80211_ATTR_PIDNL80211_ATTR_4ADDRNL80211_ATTR_SURVEY_INFONL80211_ATTR_PMKIDNL80211_ATTR_MAX_NUM_PMKIDSNL80211_ATTR_DURATIONNL80211_ATTR_COOKIENL80211_ATTR_WIPHY_COVERAGE_CLASSNL80211_ATTR_TX_RATESNL80211_ATTR_FRAME_MATCHNL80211_ATTR_ACKNL80211_ATTR_PS_STATENL80211_ATTR_CQMNL80211_ATTR_LOCAL_STATE_CHANGENL80211_ATTR_AP_ISOLATENL80211_ATTR_WIPHY_TX_POWER_SETTINGNL80211_ATTR_WIPHY_TX_POWER_LEVELNL80211_ATTR_TX_FRAME_TYPESNL80211_ATTR_RX_FRAME_TYPESNL80211_ATTR_FRAME_TYPENL80211_ATTR_CONTROL_PORT_ETHERTYPENL80211_ATTR_CONTROL_PORT_NO_ENCRYPTNL80211_ATTR_SUPPORT_IBSS_RSNNL80211_ATTR_WIPHY_ANTENNA_TXNL80211_ATTR_WIPHY_ANTENNA_RXNL80211_ATTR_MCAST_RATENL80211_ATTR_OFFCHANNEL_TX_OKNL80211_ATTR_BSS_HT_OPMODENL80211_ATTR_KEY_DEFAULT_TYPESNL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATIONNL80211_ATTR_MESH_SETUPNL80211_ATTR_WIPHY_ANTENNA_AVAIL_TXNL80211_ATTR_WIPHY_ANTENNA_AVAIL_RXNL80211_ATTR_SUPPORT_MESH_AUTHNL80211_ATTR_STA_PLINK_STATENL80211_ATTR_WOWLAN_TRIGGERSNL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTEDNL80211_ATTR_SCHED_SCAN_INTERVALNL80211_ATTR_INTERFACE_COMBINATIONSNL80211_ATTR_SOFTWARE_IFTYPESNL80211_ATTR_REKEY_DATANL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDSNL80211_ATTR_MAX_SCHED_SCAN_IE_LENNL80211_ATTR_SCAN_SUPP_RATESNL80211_ATTR_HIDDEN_SSIDNL80211_ATTR_IE_PROBE_RESPNL80211_ATTR_IE_ASSOC_RESPNL80211_ATTR_STA_WMENL80211_ATTR_SUPPORT_AP_UAPSDNL80211_ATTR_ROAM_SUPPORTNL80211_ATTR_SCHED_SCAN_MATCHNL80211_ATTR_MAX_MATCH_SETSNL80211_ATTR_PMKSA_CANDIDATENL80211_ATTR_TX_NO_CCK_RATENL80211_ATTR_TDLS_ACTIONNL80211_ATTR_TDLS_DIALOG_TOKENNL80211_ATTR_TDLS_OPERATIONNL80211_ATTR_TDLS_SUPPORTNL80211_ATTR_TDLS_EXTERNAL_SETUPNL80211_ATTR_DEVICE_AP_SMENL80211_ATTR_DONT_WAIT_FOR_ACKNL80211_ATTR_FEATURE_FLAGSNL80211_ATTR_PROBE_RESP_OFFLOADNL80211_ATTR_PROBE_RESPNL80211_ATTR_DFS_REGIONNL80211_ATTR_DISABLE_HTNL80211_ATTR_HT_CAPABILITY_MASKNL80211_ATTR_NOACK_MAPNL80211_ATTR_INACTIVITY_TIMEOUTNL80211_ATTR_RX_SIGNAL_DBMNL80211_ATTR_BG_SCAN_PERIODNL80211_ATTR_WDEVNL80211_ATTR_USER_REG_HINT_TYPENL80211_ATTR_CONN_FAILED_REASONNL80211_ATTR_AUTH_DATANL80211_ATTR_VHT_CAPABILITYNL80211_ATTR_SCAN_FLAGSNL80211_ATTR_CHANNEL_WIDTHNL80211_ATTR_CENTER_FREQ1NL80211_ATTR_CENTER_FREQ2NL80211_ATTR_P2P_CTWINDOW163NL80211_ATTR_P2P_OPPPSNL80211_ATTR_LOCAL_MESH_POWER_MODENL80211_ATTR_ACL_POLICYNL80211_ATTR_MAC_ADDRSNL80211_ATTR_MAC_ACL_MAXNL80211_ATTR_RADAR_EVENTNL80211_ATTR_EXT_CAPANL80211_ATTR_EXT_CAPA_MASKNL80211_ATTR_STA_CAPABILITYNL80211_ATTR_STA_EXT_CAPABILITYNL80211_ATTR_PROTOCOL_FEATURESNL80211_ATTR_SPLIT_WIPHY_DUMPNL80211_ATTR_DISABLE_VHTNL80211_ATTR_VHT_CAPABILITY_MASKNL80211_ATTR_MDIDNL80211_ATTR_IE_RICNL80211_ATTR_CRIT_PROT_IDNL80211_ATTR_MAX_CRIT_PROT_DURATIONNL80211_ATTR_PEER_AIDNL80211_ATTR_COALESCE_RULENL80211_ATTR_CH_SWITCH_COUNTNL80211_ATTR_CH_SWITCH_BLOCK_TXNL80211_ATTR_CSA_IESNL80211_ATTR_CNTDWN_OFFS_BEACONNL80211_ATTR_CNTDWN_OFFS_PRESPNL80211_ATTR_RXMGMT_FLAGSNL80211_ATTR_STA_SUPPORTED_CHANNELSNL80211_ATTR_STA_SUPPORTED_OPER_CLASSESNL80211_ATTR_HANDLE_DFSNL80211_ATTR_SUPPORT_5_MHZNL80211_ATTR_SUPPORT_10_MHZNL80211_ATTR_OPMODE_NOTIFNL80211_ATTR_VENDOR_IDNL80211_ATTR_VENDOR_SUBCMDNL80211_ATTR_VENDOR_DATANL80211_ATTR_VENDOR_EVENTSNL80211_ATTR_QOS_MAPNL80211_ATTR_MAC_HINTNL80211_ATTR_WIPHY_FREQ_HINTNL80211_ATTR_MAX_AP_ASSOC_STANL80211_ATTR_TDLS_PEER_CAPABILITYNL80211_ATTR_SOCKET_OWNERNL80211_ATTR_CSA_C_OFFSETS_TXNL80211_ATTR_MAX_CSA_COUNTERSNL80211_ATTR_TDLS_INITIATORNL80211_ATTR_USE_RRMNL80211_ATTR_WIPHY_DYN_ACKNL80211_ATTR_TSIDNL80211_ATTR_USER_PRIONL80211_ATTR_ADMITTED_TIMENL80211_ATTR_SMPS_MODENL80211_ATTR_OPER_CLASSNL80211_ATTR_MAC_MASKNL80211_ATTR_WIPHY_SELF_MANAGED_REGNL80211_ATTR_EXT_FEATURESNL80211_ATTR_SURVEY_RADIO_STATSNL80211_ATTR_NETNS_FDNL80211_ATTR_SCHED_SCAN_DELAYNL80211_ATTR_REG_INDOORNL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANSNL80211_ATTR_MAX_SCAN_PLAN_INTERVALNL80211_ATTR_MAX_SCAN_PLAN_ITERATIONSNL80211_ATTR_SCHED_SCAN_PLANSNL80211_ATTR_PBSSNL80211_ATTR_BSS_SELECTNL80211_ATTR_STA_SUPPORT_P2P_PSNL80211_ATTR_PADNL80211_ATTR_IFTYPE_EXT_CAPANL80211_ATTR_MU_MIMO_GROUP_DATANL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDRNL80211_ATTR_SCAN_START_TIME_TSFNL80211_ATTR_SCAN_START_TIME_TSF_BSSIDNL80211_ATTR_MEASUREMENT_DURATIONNL80211_ATTR_MEASUREMENT_DURATION_MANDATORYNL80211_ATTR_MESH_PEER_AIDNL80211_ATTR_NAN_MASTER_PREFNL80211_ATTR_BANDSNL80211_ATTR_NAN_FUNCNL80211_ATTR_NAN_MATCHNL80211_ATTR_FILS_KEKNL80211_ATTR_FILS_NONCESNL80211_ATTR_MULTICAST_TO_UNICAST_ENABLEDNL80211_ATTR_BSSIDNL80211_ATTR_SCHED_SCAN_RELATIVE_RSSINL80211_ATTR_SCHED_SCAN_RSSI_ADJUSTNL80211_ATTR_TIMEOUT_REASONNL80211_ATTR_FILS_ERP_USERNAMENL80211_ATTR_FILS_ERP_REALMNL80211_ATTR_FILS_ERP_NEXT_SEQ_NUMNL80211_ATTR_FILS_ERP_RRKNL80211_ATTR_FILS_CACHE_IDNL80211_ATTR_PMKNL80211_ATTR_SCHED_SCAN_MULTINL80211_ATTR_SCHED_SCAN_MAX_REQSNL80211_ATTR_WANT_1X_4WAY_HSNL80211_ATTR_PMKR0_NAMENL80211_ATTR_PORT_AUTHORIZEDNL80211_ATTR_EXTERNAL_AUTH_ACTIONNL80211_ATTR_EXTERNAL_AUTH_SUPPORTNL80211_ATTR_NSSNL80211_ATTR_ACK_SIGNALNL80211_ATTR_CONTROL_PORT_OVER_NL80211NL80211_ATTR_TXQ_STATSNL80211_ATTR_TXQ_LIMITNL80211_ATTR_TXQ_MEMORY_LIMITNL80211_ATTR_TXQ_QUANTUMNL80211_ATTR_HE_CAPABILITY270NL80211_ATTR_FTM_RESPONDER271NL80211_ATTR_FTM_RESPONDER_STATS272NL80211_ATTR_TIMEOUT273NL80211_ATTR_PEER_MEASUREMENTS274NL80211_ATTR_AIRTIME_WEIGHT275NL80211_ATTR_STA_TX_POWER_SETTING276NL80211_ATTR_STA_TX_POWER277NL80211_ATTR_SAE_PASSWORD278NL80211_ATTR_TWT_RESPONDER279NL80211_ATTR_HE_OBSS_PDNL80211_ATTR_WIPHY_EDMG_CHANNELSNL80211_ATTR_WIPHY_EDMG_BW_CONFIGNL80211_ATTR_VLAN_IDNL80211_ATTR_HE_BSS_COLORNL80211_ATTR_IFTYPE_AKM_SUITES285NL80211_ATTR_TID_CONFIGNL80211_ATTR_CONTROL_PORT_NO_PREAUTH287NL80211_ATTR_PMK_LIFETIME288NL80211_ATTR_PMK_REAUTH_THRESHOLD289NL80211_ATTR_RECEIVE_MULTICASTNL80211_ATTR_WIPHY_FREQ_OFFSETNL80211_ATTR_CENTER_FREQ1_OFFSETNL80211_ATTR_SCAN_FREQ_KHZNL80211_ATTR_HE_6GHZ_CAPABILITYNL80211_ATTR_FILS_DISCOVERYNL80211_ATTR_UNSOL_BCAST_PROBE_RESPNL80211_ATTR_S1G_CAPABILITYNL80211_ATTR_S1G_CAPABILITY_MASKNL80211_ATTR_SAE_PWENL80211_ATTR_RECONNECT_REQUESTEDNL80211_ATTR_SAR_SPECNL80211_ATTR_DISABLE_HENL80211_ATTR_OBSS_COLOR_BITMAPNL80211_ATTR_COLOR_CHANGE_COUNTNL80211_ATTR_COLOR_CHANGE_COLORNL80211_ATTR_COLOR_CHANGE_ELEMSNL80211_ATTR_MBSSID_CONFIGNL80211_ATTR_MBSSID_ELEMSNL80211_ATTR_RADAR_BACKGROUNDNL80211_ATTR_AP_SETTINGS_FLAGSNL80211_ATTR_EHT_CAPABILITYNL80211_ATTR_DISABLE_EHTNL80211_ATTR_MLO_LINKSNL80211_ATTR_MLO_LINK_IDNL80211_ATTR_MLD_ADDR315NL80211_ATTR_MLO_SUPPORT316NL80211_ATTR_MAX_NUM_AKM_SUITES317NL80211_ATTR_EML_CAPABILITY318NL80211_ATTR_MLD_CAPA_AND_OPS319NL80211_ATTR_TX_HW_TIMESTAMPNL80211_ATTR_RX_HW_TIMESTAMPNL80211_ATTR_TD_BITMAPNL80211_ATTR_PUNCT_BITMAPNL80211_ATTR_MAX_HW_TIMESTAMP_PEERSNL80211_ATTR_HW_TIMESTAMP_ENABLEDNL80211_ATTR_EMA_RNR_ELEMSNL80211_ATTR_MLO_LINK_DISABLEDNL80211_ATTR_BSS_DUMP_INCLUDE_USE_DATANL80211_ATTR_MLO_TTLM_DLINKNL80211_ATTR_MLO_TTLM_ULINKNL80211_ATTR_ASSOC_SPP_AMSDUNL80211_ATTR_WIPHY_RADIOSNL80211_ATTR_WIPHY_INTERFACE_COMBINATIONSNL80211_ATTR_VIF_RADIO_MASKNL80211_ATTR_SUPPORTED_SELECTORSNL80211_ATTR_MLO_RECONF_REM_LINKSNL80211_ATTR_EPCS337NL80211_ATTR_ASSOC_MLD_EXT_CAPA_OPS338__NL80211_ATTR_AFTER_LASTnl80211_iftypeNL80211_IFTYPE_UNSPECIFIEDNL80211_IFTYPE_ADHOCNL80211_IFTYPE_STATIONNL80211_IFTYPE_APNL80211_IFTYPE_AP_VLANNL80211_IFTYPE_WDSNL80211_IFTYPE_MONITORNL80211_IFTYPE_MESH_POINTNL80211_IFTYPE_P2P_CLIENTNL80211_IFTYPE_P2P_GONL80211_IFTYPE_P2P_DEVICENL80211_IFTYPE_OCBNL80211_IFTYPE_NANNUM_NL80211_IFTYPESnl80211_sta_flags__NL80211_STA_FLAG_INVALIDNL80211_STA_FLAG_AUTHORIZEDNL80211_STA_FLAG_SHORT_PREAMBLENL80211_STA_FLAG_WMENL80211_STA_FLAG_MFPNL80211_STA_FLAG_AUTHENTICATEDNL80211_STA_FLAG_TDLS_PEERNL80211_STA_FLAG_ASSOCIATEDNL80211_STA_FLAG_SPP_AMSDU__NL80211_STA_FLAG_AFTER_LASTnl80211_sta_p2p_ps_statusNL80211_P2P_PS_UNSUPPORTEDNL80211_P2P_PS_SUPPORTEDNUM_NL80211_P2P_PS_STATUSnl80211_he_giNL80211_RATE_INFO_HE_GI_0_8NL80211_RATE_INFO_HE_GI_1_6NL80211_RATE_INFO_HE_GI_3_2nl80211_he_ltfNL80211_RATE_INFO_HE_1XLTFNL80211_RATE_INFO_HE_2XLTFNL80211_RATE_INFO_HE_4XLTFnl80211_he_ru_allocNL80211_RATE_INFO_HE_RU_ALLOC_26NL80211_RATE_INFO_HE_RU_ALLOC_52NL80211_RATE_INFO_HE_RU_ALLOC_106NL80211_RATE_INFO_HE_RU_ALLOC_242NL80211_RATE_INFO_HE_RU_ALLOC_484NL80211_RATE_INFO_HE_RU_ALLOC_996NL80211_RATE_INFO_HE_RU_ALLOC_2x996nl80211_eht_giNL80211_RATE_INFO_EHT_GI_0_8NL80211_RATE_INFO_EHT_GI_1_6NL80211_RATE_INFO_EHT_GI_3_2nl80211_eht_ru_allocNL80211_RATE_INFO_EHT_RU_ALLOC_26NL80211_RATE_INFO_EHT_RU_ALLOC_52NL80211_RATE_INFO_EHT_RU_ALLOC_52P26NL80211_RATE_INFO_EHT_RU_ALLOC_106NL80211_RATE_INFO_EHT_RU_ALLOC_106P26NL80211_RATE_INFO_EHT_RU_ALLOC_242NL80211_RATE_INFO_EHT_RU_ALLOC_484NL80211_RATE_INFO_EHT_RU_ALLOC_484P242NL80211_RATE_INFO_EHT_RU_ALLOC_996NL80211_RATE_INFO_EHT_RU_ALLOC_996P484NL80211_RATE_INFO_EHT_RU_ALLOC_996P484P242NL80211_RATE_INFO_EHT_RU_ALLOC_2x996NL80211_RATE_INFO_EHT_RU_ALLOC_2x996P484NL80211_RATE_INFO_EHT_RU_ALLOC_3x996NL80211_RATE_INFO_EHT_RU_ALLOC_3x996P484NL80211_RATE_INFO_EHT_RU_ALLOC_4x996nl80211_rate_info__NL80211_RATE_INFO_INVALIDNL80211_RATE_INFO_BITRATENL80211_RATE_INFO_MCSNL80211_RATE_INFO_40_MHZ_WIDTHNL80211_RATE_INFO_SHORT_GINL80211_RATE_INFO_BITRATE32NL80211_RATE_INFO_VHT_MCSNL80211_RATE_INFO_VHT_NSSNL80211_RATE_INFO_80_MHZ_WIDTHNL80211_RATE_INFO_80P80_MHZ_WIDTHNL80211_RATE_INFO_160_MHZ_WIDTHNL80211_RATE_INFO_10_MHZ_WIDTHNL80211_RATE_INFO_5_MHZ_WIDTHNL80211_RATE_INFO_HE_MCSNL80211_RATE_INFO_HE_NSSNL80211_RATE_INFO_HE_GINL80211_RATE_INFO_HE_DCMNL80211_RATE_INFO_HE_RU_ALLOCNL80211_RATE_INFO_320_MHZ_WIDTHNL80211_RATE_INFO_EHT_MCSNL80211_RATE_INFO_EHT_NSSNL80211_RATE_INFO_EHT_GINL80211_RATE_INFO_EHT_RU_ALLOCNL80211_RATE_INFO_S1G_MCSNL80211_RATE_INFO_S1G_NSSNL80211_RATE_INFO_1_MHZ_WIDTHNL80211_RATE_INFO_2_MHZ_WIDTHNL80211_RATE_INFO_4_MHZ_WIDTHNL80211_RATE_INFO_8_MHZ_WIDTHNL80211_RATE_INFO_16_MHZ_WIDTH__NL80211_RATE_INFO_AFTER_LASTnl80211_sta_bss_param__NL80211_STA_BSS_PARAM_INVALIDNL80211_STA_BSS_PARAM_CTS_PROTNL80211_STA_BSS_PARAM_SHORT_PREAMBLENL80211_STA_BSS_PARAM_SHORT_SLOT_TIMENL80211_STA_BSS_PARAM_DTIM_PERIODNL80211_STA_BSS_PARAM_BEACON_INTERVAL__NL80211_STA_BSS_PARAM_AFTER_LASTnl80211_sta_info__NL80211_STA_INFO_INVALIDNL80211_STA_INFO_INACTIVE_TIMENL80211_STA_INFO_RX_BYTESNL80211_STA_INFO_TX_BYTESNL80211_STA_INFO_LLIDNL80211_STA_INFO_PLIDNL80211_STA_INFO_PLINK_STATENL80211_STA_INFO_SIGNALNL80211_STA_INFO_TX_BITRATENL80211_STA_INFO_RX_PACKETSNL80211_STA_INFO_TX_PACKETSNL80211_STA_INFO_TX_RETRIESNL80211_STA_INFO_TX_FAILEDNL80211_STA_INFO_SIGNAL_AVGNL80211_STA_INFO_RX_BITRATENL80211_STA_INFO_BSS_PARAMNL80211_STA_INFO_CONNECTED_TIMENL80211_STA_INFO_STA_FLAGSNL80211_STA_INFO_BEACON_LOSSNL80211_STA_INFO_T_OFFSETNL80211_STA_INFO_LOCAL_PMNL80211_STA_INFO_PEER_PMNL80211_STA_INFO_NONPEER_PMNL80211_STA_INFO_RX_BYTES64NL80211_STA_INFO_TX_BYTES64NL80211_STA_INFO_CHAIN_SIGNALNL80211_STA_INFO_CHAIN_SIGNAL_AVGNL80211_STA_INFO_EXPECTED_THROUGHPUTNL80211_STA_INFO_RX_DROP_MISCNL80211_STA_INFO_BEACON_RXNL80211_STA_INFO_BEACON_SIGNAL_AVGNL80211_STA_INFO_TID_STATSNL80211_STA_INFO_RX_DURATIONNL80211_STA_INFO_PADNL80211_STA_INFO_ACK_SIGNALNL80211_STA_INFO_ACK_SIGNAL_AVGNL80211_STA_INFO_RX_MPDUSNL80211_STA_INFO_FCS_ERROR_COUNTNL80211_STA_INFO_CONNECTED_TO_GATENL80211_STA_INFO_TX_DURATIONNL80211_STA_INFO_AIRTIME_WEIGHTNL80211_STA_INFO_AIRTIME_LINK_METRICNL80211_STA_INFO_ASSOC_AT_BOOTTIMENL80211_STA_INFO_CONNECTED_TO_AS__NL80211_STA_INFO_AFTER_LASTnl80211_tid_stats__NL80211_TID_STATS_INVALIDNL80211_TID_STATS_RX_MSDUNL80211_TID_STATS_TX_MSDUNL80211_TID_STATS_TX_MSDU_RETRIESNL80211_TID_STATS_TX_MSDU_FAILEDNL80211_TID_STATS_PADNL80211_TID_STATS_TXQ_STATSNUM_NL80211_TID_STATSnl80211_txq_stats__NL80211_TXQ_STATS_INVALIDNL80211_TXQ_STATS_BACKLOG_BYTESNL80211_TXQ_STATS_BACKLOG_PACKETSNL80211_TXQ_STATS_FLOWSNL80211_TXQ_STATS_DROPSNL80211_TXQ_STATS_ECN_MARKSNL80211_TXQ_STATS_OVERLIMITNL80211_TXQ_STATS_OVERMEMORYNL80211_TXQ_STATS_COLLISIONSNL80211_TXQ_STATS_TX_BYTESNL80211_TXQ_STATS_TX_PACKETSNL80211_TXQ_STATS_MAX_FLOWSNUM_NL80211_TXQ_STATSnl80211_mpath_flagsNL80211_MPATH_FLAG_ACTIVENL80211_MPATH_FLAG_RESOLVINGNL80211_MPATH_FLAG_SN_VALIDNL80211_MPATH_FLAG_FIXEDNL80211_MPATH_FLAG_RESOLVEDnl80211_mpath_info__NL80211_MPATH_INFO_INVALIDNL80211_MPATH_INFO_FRAME_QLENNL80211_MPATH_INFO_SNNL80211_MPATH_INFO_METRICNL80211_MPATH_INFO_EXPTIMENL80211_MPATH_INFO_FLAGSNL80211_MPATH_INFO_DISCOVERY_TIMEOUTNL80211_MPATH_INFO_DISCOVERY_RETRIESNL80211_MPATH_INFO_HOP_COUNTNL80211_MPATH_INFO_PATH_CHANGE__NL80211_MPATH_INFO_AFTER_LASTnl80211_band_iftype_attr__NL80211_BAND_IFTYPE_ATTR_INVALIDNL80211_BAND_IFTYPE_ATTR_IFTYPESNL80211_BAND_IFTYPE_ATTR_HE_CAP_MACNL80211_BAND_IFTYPE_ATTR_HE_CAP_PHYNL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SETNL80211_BAND_IFTYPE_ATTR_HE_CAP_PPENL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPANL80211_BAND_IFTYPE_ATTR_VENDOR_ELEMSNL80211_BAND_IFTYPE_ATTR_EHT_CAP_MACNL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHYNL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SETNL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE__NL80211_BAND_IFTYPE_ATTR_AFTER_LASTnl80211_band_attr__NL80211_BAND_ATTR_INVALIDNL80211_BAND_ATTR_FREQSNL80211_BAND_ATTR_RATESNL80211_BAND_ATTR_HT_MCS_SETNL80211_BAND_ATTR_HT_CAPANL80211_BAND_ATTR_HT_AMPDU_FACTORNL80211_BAND_ATTR_HT_AMPDU_DENSITYNL80211_BAND_ATTR_VHT_MCS_SETNL80211_BAND_ATTR_VHT_CAPANL80211_BAND_ATTR_IFTYPE_DATANL80211_BAND_ATTR_EDMG_CHANNELSNL80211_BAND_ATTR_EDMG_BW_CONFIGNL80211_BAND_ATTR_S1G_MCS_NSS_SETNL80211_BAND_ATTR_S1G_CAPA__NL80211_BAND_ATTR_AFTER_LASTnl80211_wmm_rule__NL80211_WMMR_INVALIDNL80211_WMMR_CW_MINNL80211_WMMR_CW_MAXNL80211_WMMR_AIFSNNL80211_WMMR_TXOP__NL80211_WMMR_LASTnl80211_frequency_attr__NL80211_FREQUENCY_ATTR_INVALIDNL80211_FREQUENCY_ATTR_FREQNL80211_FREQUENCY_ATTR_DISABLEDNL80211_FREQUENCY_ATTR_NO_IR__NL80211_FREQUENCY_ATTR_NO_IBSSNL80211_FREQUENCY_ATTR_RADARNL80211_FREQUENCY_ATTR_MAX_TX_POWERNL80211_FREQUENCY_ATTR_DFS_STATENL80211_FREQUENCY_ATTR_DFS_TIMENL80211_FREQUENCY_ATTR_NO_HT40_MINUSNL80211_FREQUENCY_ATTR_NO_HT40_PLUSNL80211_FREQUENCY_ATTR_NO_80MHZNL80211_FREQUENCY_ATTR_NO_160MHZNL80211_FREQUENCY_ATTR_DFS_CAC_TIMENL80211_FREQUENCY_ATTR_INDOOR_ONLYNL80211_FREQUENCY_ATTR_IR_CONCURRENTNL80211_FREQUENCY_ATTR_NO_20MHZNL80211_FREQUENCY_ATTR_NO_10MHZNL80211_FREQUENCY_ATTR_WMMNL80211_FREQUENCY_ATTR_NO_HENL80211_FREQUENCY_ATTR_OFFSETNL80211_FREQUENCY_ATTR_1MHZNL80211_FREQUENCY_ATTR_2MHZNL80211_FREQUENCY_ATTR_4MHZNL80211_FREQUENCY_ATTR_8MHZNL80211_FREQUENCY_ATTR_16MHZNL80211_FREQUENCY_ATTR_NO_320MHZNL80211_FREQUENCY_ATTR_NO_EHTNL80211_FREQUENCY_ATTR_PSDNL80211_FREQUENCY_ATTR_DFS_CONCURRENTNL80211_FREQUENCY_ATTR_NO_6GHZ_VLP_CLIENTNL80211_FREQUENCY_ATTR_NO_6GHZ_AFC_CLIENTNL80211_FREQUENCY_ATTR_CAN_MONITORNL80211_FREQUENCY_ATTR_ALLOW_6GHZ_VLP_APNL80211_FREQUENCY_ATTR_ALLOW_20MHZ_ACTIVITY__NL80211_FREQUENCY_ATTR_AFTER_LASTnl80211_bitrate_attr__NL80211_BITRATE_ATTR_INVALIDNL80211_BITRATE_ATTR_RATENL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE__NL80211_BITRATE_ATTR_AFTER_LASTnl80211_reg_initiatorNL80211_REGDOM_SET_BY_CORENL80211_REGDOM_SET_BY_USERNL80211_REGDOM_SET_BY_DRIVERNL80211_REGDOM_SET_BY_COUNTRY_IEnl80211_reg_typeNL80211_REGDOM_TYPE_COUNTRYNL80211_REGDOM_TYPE_WORLDNL80211_REGDOM_TYPE_CUSTOM_WORLDNL80211_REGDOM_TYPE_INTERSECTIONnl80211_reg_rule_attr__NL80211_REG_RULE_ATTR_INVALIDNL80211_ATTR_REG_RULE_FLAGSNL80211_ATTR_FREQ_RANGE_STARTNL80211_ATTR_FREQ_RANGE_ENDNL80211_ATTR_FREQ_RANGE_MAX_BWNL80211_ATTR_POWER_RULE_MAX_ANT_GAINNL80211_ATTR_POWER_RULE_MAX_EIRPNL80211_ATTR_DFS_CAC_TIMENL80211_ATTR_POWER_RULE_PSD__NL80211_REG_RULE_ATTR_AFTER_LASTnl80211_sched_scan_match_attr__NL80211_SCHED_SCAN_MATCH_ATTR_INVALIDNL80211_SCHED_SCAN_MATCH_ATTR_SSIDNL80211_SCHED_SCAN_MATCH_ATTR_RSSINL80211_SCHED_SCAN_MATCH_ATTR_RELATIVE_RSSINL80211_SCHED_SCAN_MATCH_ATTR_RSSI_ADJUSTNL80211_SCHED_SCAN_MATCH_ATTR_BSSIDNL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI__NL80211_SCHED_SCAN_MATCH_ATTR_AFTER_LASTnl80211_reg_rule_flagsNL80211_RRF_NO_OFDMNL80211_RRF_NO_CCKNL80211_RRF_NO_INDOORNL80211_RRF_NO_OUTDOORNL80211_RRF_DFSNL80211_RRF_PTP_ONLYNL80211_RRF_PTMP_ONLYNL80211_RRF_NO_IR__NL80211_RRF_NO_IBSSNL80211_RRF_AUTO_BWNL80211_RRF_IR_CONCURRENTNL80211_RRF_NO_HT40MINUSNL80211_RRF_NO_HT40PLUSNL80211_RRF_NO_80MHZNL80211_RRF_NO_160MHZNL80211_RRF_NO_HENL80211_RRF_NO_320MHZNL80211_RRF_NO_EHTNL80211_RRF_PSDNL80211_RRF_DFS_CONCURRENTNL80211_RRF_NO_6GHZ_VLP_CLIENTNL80211_RRF_NO_6GHZ_AFC_CLIENTNL80211_RRF_ALLOW_6GHZ_VLP_APNL80211_RRF_ALLOW_20MHZ_ACTIVITYnl80211_dfs_regionsNL80211_DFS_UNSETNL80211_DFS_FCCNL80211_DFS_ETSINL80211_DFS_JPnl80211_user_reg_hint_typeNL80211_USER_REG_HINT_USERNL80211_USER_REG_HINT_CELL_BASENL80211_USER_REG_HINT_INDOORnl80211_survey_info__NL80211_SURVEY_INFO_INVALIDNL80211_SURVEY_INFO_FREQUENCYNL80211_SURVEY_INFO_NOISENL80211_SURVEY_INFO_IN_USENL80211_SURVEY_INFO_TIMENL80211_SURVEY_INFO_TIME_BUSYNL80211_SURVEY_INFO_TIME_EXT_BUSYNL80211_SURVEY_INFO_TIME_RXNL80211_SURVEY_INFO_TIME_TXNL80211_SURVEY_INFO_TIME_SCANNL80211_SURVEY_INFO_PADNL80211_SURVEY_INFO_TIME_BSS_RXNL80211_SURVEY_INFO_FREQUENCY_OFFSET__NL80211_SURVEY_INFO_AFTER_LASTnl80211_mntr_flags__NL80211_MNTR_FLAG_INVALIDNL80211_MNTR_FLAG_FCSFAILNL80211_MNTR_FLAG_PLCPFAILNL80211_MNTR_FLAG_CONTROLNL80211_MNTR_FLAG_OTHER_BSSNL80211_MNTR_FLAG_COOK_FRAMESNL80211_MNTR_FLAG_ACTIVENL80211_MNTR_FLAG_SKIP_TX__NL80211_MNTR_FLAG_AFTER_LASTnl80211_mesh_power_modeNL80211_MESH_POWER_UNKNOWNNL80211_MESH_POWER_ACTIVENL80211_MESH_POWER_LIGHT_SLEEPNL80211_MESH_POWER_DEEP_SLEEP__NL80211_MESH_POWER_AFTER_LASTnl80211_meshconf_params__NL80211_MESHCONF_INVALIDNL80211_MESHCONF_RETRY_TIMEOUTNL80211_MESHCONF_CONFIRM_TIMEOUTNL80211_MESHCONF_HOLDING_TIMEOUTNL80211_MESHCONF_MAX_PEER_LINKSNL80211_MESHCONF_MAX_RETRIESNL80211_MESHCONF_TTLNL80211_MESHCONF_AUTO_OPEN_PLINKSNL80211_MESHCONF_HWMP_MAX_PREQ_RETRIESNL80211_MESHCONF_PATH_REFRESH_TIMENL80211_MESHCONF_MIN_DISCOVERY_TIMEOUTNL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUTNL80211_MESHCONF_HWMP_PREQ_MIN_INTERVALNL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIMENL80211_MESHCONF_HWMP_ROOTMODENL80211_MESHCONF_ELEMENT_TTLNL80211_MESHCONF_HWMP_RANN_INTERVALNL80211_MESHCONF_GATE_ANNOUNCEMENTSNL80211_MESHCONF_HWMP_PERR_MIN_INTERVALNL80211_MESHCONF_FORWARDINGNL80211_MESHCONF_RSSI_THRESHOLDNL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBORNL80211_MESHCONF_HT_OPMODENL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUTNL80211_MESHCONF_HWMP_ROOT_INTERVALNL80211_MESHCONF_HWMP_CONFIRMATION_INTERVALNL80211_MESHCONF_POWER_MODENL80211_MESHCONF_AWAKE_WINDOWNL80211_MESHCONF_PLINK_TIMEOUTNL80211_MESHCONF_CONNECTED_TO_GATENL80211_MESHCONF_NOLEARNNL80211_MESHCONF_CONNECTED_TO_AS__NL80211_MESHCONF_ATTR_AFTER_LASTnl80211_mesh_setup_params__NL80211_MESH_SETUP_INVALIDNL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SELNL80211_MESH_SETUP_ENABLE_VENDOR_METRICNL80211_MESH_SETUP_IENL80211_MESH_SETUP_USERSPACE_AUTHNL80211_MESH_SETUP_USERSPACE_AMPENL80211_MESH_SETUP_ENABLE_VENDOR_SYNCNL80211_MESH_SETUP_USERSPACE_MPMNL80211_MESH_SETUP_AUTH_PROTOCOL__NL80211_MESH_SETUP_ATTR_AFTER_LASTnl80211_txq_attr__NL80211_TXQ_ATTR_INVALIDNL80211_TXQ_ATTR_ACNL80211_TXQ_ATTR_TXOPNL80211_TXQ_ATTR_CWMINNL80211_TXQ_ATTR_CWMAXNL80211_TXQ_ATTR_AIFS__NL80211_TXQ_ATTR_AFTER_LASTnl80211_acNL80211_AC_VONL80211_AC_VINL80211_AC_BENL80211_AC_BKNL80211_NUM_ACSnl80211_channel_typeNL80211_CHAN_NO_HTNL80211_CHAN_HT20NL80211_CHAN_HT40MINUSNL80211_CHAN_HT40PLUSnl80211_key_modeNL80211_KEY_RX_TXNL80211_KEY_NO_TXNL80211_KEY_SET_TXnl80211_chan_widthNL80211_CHAN_WIDTH_20_NOHTNL80211_CHAN_WIDTH_20NL80211_CHAN_WIDTH_40NL80211_CHAN_WIDTH_80NL80211_CHAN_WIDTH_80P80NL80211_CHAN_WIDTH_160NL80211_CHAN_WIDTH_5NL80211_CHAN_WIDTH_10NL80211_CHAN_WIDTH_1NL80211_CHAN_WIDTH_2NL80211_CHAN_WIDTH_4NL80211_CHAN_WIDTH_8NL80211_CHAN_WIDTH_16NL80211_CHAN_WIDTH_320nl80211_bss_scan_widthNL80211_BSS_CHAN_WIDTH_20NL80211_BSS_CHAN_WIDTH_10NL80211_BSS_CHAN_WIDTH_5NL80211_BSS_CHAN_WIDTH_1NL80211_BSS_CHAN_WIDTH_2nl80211_bss_use_forNL80211_BSS_USE_FOR_NORMALNL80211_BSS_USE_FOR_MLD_LINKnl80211_bss_cannot_use_reasonsNL80211_BSS_CANNOT_USE_NSTR_NONPRIMARYNL80211_BSS_CANNOT_USE_6GHZ_PWR_MISMATCHnl80211_bss__NL80211_BSS_INVALIDNL80211_BSS_BSSIDNL80211_BSS_FREQUENCYNL80211_BSS_TSFNL80211_BSS_BEACON_INTERVALNL80211_BSS_CAPABILITYNL80211_BSS_INFORMATION_ELEMENTSNL80211_BSS_SIGNAL_MBMNL80211_BSS_SIGNAL_UNSPECNL80211_BSS_STATUSNL80211_BSS_SEEN_MS_AGONL80211_BSS_BEACON_IESNL80211_BSS_CHAN_WIDTHNL80211_BSS_BEACON_TSFNL80211_BSS_PRESP_DATANL80211_BSS_LAST_SEEN_BOOTTIMENL80211_BSS_PADNL80211_BSS_PARENT_TSFNL80211_BSS_PARENT_BSSIDNL80211_BSS_CHAIN_SIGNALNL80211_BSS_FREQUENCY_OFFSETNL80211_BSS_MLO_LINK_IDNL80211_BSS_MLD_ADDRNL80211_BSS_USE_FORNL80211_BSS_CANNOT_USE_REASONS__NL80211_BSS_AFTER_LASTnl80211_bss_statusNL80211_BSS_STATUS_AUTHENTICATEDNL80211_BSS_STATUS_ASSOCIATEDNL80211_BSS_STATUS_IBSS_JOINEDnl80211_auth_typeNL80211_AUTHTYPE_OPEN_SYSTEMNL80211_AUTHTYPE_SHARED_KEYNL80211_AUTHTYPE_FTNL80211_AUTHTYPE_NETWORK_EAPNL80211_AUTHTYPE_SAENL80211_AUTHTYPE_FILS_SKNL80211_AUTHTYPE_FILS_SK_PFSNL80211_AUTHTYPE_FILS_PK__NL80211_AUTHTYPE_NUMnl80211_key_typeNL80211_KEYTYPE_GROUPNL80211_KEYTYPE_PAIRWISENL80211_KEYTYPE_PEERKEYNUM_NL80211_KEYTYPESnl80211_mfpNL80211_MFP_NONL80211_MFP_REQUIREDNL80211_MFP_OPTIONALnl80211_wpa_versionsNL80211_WPA_VERSION_1NL80211_WPA_VERSION_2NL80211_WPA_VERSION_3nl80211_key_default_types__NL80211_KEY_DEFAULT_TYPE_INVALIDNL80211_KEY_DEFAULT_TYPE_UNICASTNL80211_KEY_DEFAULT_TYPE_MULTICASTNUM_NL80211_KEY_DEFAULT_TYPESnl80211_key_attributes__NL80211_KEY_INVALIDNL80211_KEY_DATANL80211_KEY_IDXNL80211_KEY_CIPHERNL80211_KEY_SEQNL80211_KEY_DEFAULTNL80211_KEY_DEFAULT_MGMTNL80211_KEY_TYPENL80211_KEY_DEFAULT_TYPESNL80211_KEY_MODENL80211_KEY_DEFAULT_BEACON__NL80211_KEY_AFTER_LASTnl80211_tx_rate_attributes__NL80211_TXRATE_INVALIDNL80211_TXRATE_LEGACYNL80211_TXRATE_HTNL80211_TXRATE_VHTNL80211_TXRATE_GINL80211_TXRATE_HENL80211_TXRATE_HE_GINL80211_TXRATE_HE_LTF__NL80211_TXRATE_AFTER_LASTnl80211_txrate_giNL80211_TXRATE_DEFAULT_GINL80211_TXRATE_FORCE_SGINL80211_TXRATE_FORCE_LGInl80211_bandNL80211_BAND_2GHZNL80211_BAND_5GHZNL80211_BAND_60GHZNL80211_BAND_6GHZNL80211_BAND_S1GHZNL80211_BAND_LCNUM_NL80211_BANDSnl80211_ps_stateNL80211_PS_DISABLEDNL80211_PS_ENABLEDnl80211_attr_cqm__NL80211_ATTR_CQM_INVALIDNL80211_ATTR_CQM_RSSI_THOLDNL80211_ATTR_CQM_RSSI_HYSTNL80211_ATTR_CQM_RSSI_THRESHOLD_EVENTNL80211_ATTR_CQM_PKT_LOSS_EVENTNL80211_ATTR_CQM_TXE_RATENL80211_ATTR_CQM_TXE_PKTSNL80211_ATTR_CQM_TXE_INTVLNL80211_ATTR_CQM_BEACON_LOSS_EVENTNL80211_ATTR_CQM_RSSI_LEVEL__NL80211_ATTR_CQM_AFTER_LASTnl80211_cqm_rssi_threshold_eventNL80211_CQM_RSSI_THRESHOLD_EVENT_LOWNL80211_CQM_RSSI_THRESHOLD_EVENT_HIGHNL80211_CQM_RSSI_BEACON_LOSS_EVENTnl80211_tx_power_settingNL80211_TX_POWER_AUTOMATICNL80211_TX_POWER_LIMITEDNL80211_TX_POWER_FIXEDnl80211_tid_configNL80211_TID_CONFIG_ENABLENL80211_TID_CONFIG_DISABLEnl80211_tx_rate_settingNL80211_TX_RATE_AUTOMATICNL80211_TX_RATE_LIMITEDNL80211_TX_RATE_FIXEDnl80211_tid_config_attr__NL80211_TID_CONFIG_ATTR_INVALIDNL80211_TID_CONFIG_ATTR_PADNL80211_TID_CONFIG_ATTR_VIF_SUPPNL80211_TID_CONFIG_ATTR_PEER_SUPPNL80211_TID_CONFIG_ATTR_OVERRIDENL80211_TID_CONFIG_ATTR_TIDSNL80211_TID_CONFIG_ATTR_NOACKNL80211_TID_CONFIG_ATTR_RETRY_SHORTNL80211_TID_CONFIG_ATTR_RETRY_LONGNL80211_TID_CONFIG_ATTR_AMPDU_CTRLNL80211_TID_CONFIG_ATTR_RTSCTS_CTRLNL80211_TID_CONFIG_ATTR_AMSDU_CTRLNL80211_TID_CONFIG_ATTR_TX_RATE_TYPENL80211_TID_CONFIG_ATTR_TX_RATE__NL80211_TID_CONFIG_ATTR_AFTER_LASTnl80211_packet_pattern_attr__NL80211_PKTPAT_INVALIDNL80211_PKTPAT_MASKNL80211_PKTPAT_PATTERNNL80211_PKTPAT_OFFSETNUM_NL80211_PKTPATnl80211_wowlan_triggers__NL80211_WOWLAN_TRIG_INVALIDNL80211_WOWLAN_TRIG_ANYNL80211_WOWLAN_TRIG_DISCONNECTNL80211_WOWLAN_TRIG_MAGIC_PKTNL80211_WOWLAN_TRIG_PKT_PATTERNNL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTEDNL80211_WOWLAN_TRIG_GTK_REKEY_FAILURENL80211_WOWLAN_TRIG_EAP_IDENT_REQUESTNL80211_WOWLAN_TRIG_4WAY_HANDSHAKENL80211_WOWLAN_TRIG_RFKILL_RELEASENL80211_WOWLAN_TRIG_WAKEUP_PKT_80211NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LENNL80211_WOWLAN_TRIG_WAKEUP_PKT_8023NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LENNL80211_WOWLAN_TRIG_TCP_CONNECTIONNL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCHNL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOSTNL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENSNL80211_WOWLAN_TRIG_NET_DETECTNL80211_WOWLAN_TRIG_NET_DETECT_RESULTSNL80211_WOWLAN_TRIG_UNPROTECTED_DEAUTH_DISASSOCNUM_NL80211_WOWLAN_TRIGnl80211_wowlan_tcp_attrs__NL80211_WOWLAN_TCP_INVALIDNL80211_WOWLAN_TCP_SRC_IPV4NL80211_WOWLAN_TCP_DST_IPV4NL80211_WOWLAN_TCP_DST_MACNL80211_WOWLAN_TCP_SRC_PORTNL80211_WOWLAN_TCP_DST_PORTNL80211_WOWLAN_TCP_DATA_PAYLOADNL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQNL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKENNL80211_WOWLAN_TCP_DATA_INTERVALNL80211_WOWLAN_TCP_WAKE_PAYLOADNL80211_WOWLAN_TCP_WAKE_MASKNUM_NL80211_WOWLAN_TCPnl80211_attr_coalesce_rule__NL80211_COALESCE_RULE_INVALIDNL80211_ATTR_COALESCE_RULE_DELAYNL80211_ATTR_COALESCE_RULE_CONDITIONNL80211_ATTR_COALESCE_RULE_PKT_PATTERNNUM_NL80211_ATTR_COALESCE_RULEnl80211_coalesce_conditionNL80211_COALESCE_CONDITION_MATCHNL80211_COALESCE_CONDITION_NO_MATCHnl80211_iface_limit_attrsNL80211_IFACE_LIMIT_UNSPECNL80211_IFACE_LIMIT_MAXNL80211_IFACE_LIMIT_TYPESNUM_NL80211_IFACE_LIMITnl80211_if_combination_attrsNL80211_IFACE_COMB_UNSPECNL80211_IFACE_COMB_LIMITSNL80211_IFACE_COMB_MAXNUMNL80211_IFACE_COMB_STA_AP_BI_MATCHNL80211_IFACE_COMB_NUM_CHANNELSNL80211_IFACE_COMB_RADAR_DETECT_WIDTHSNL80211_IFACE_COMB_RADAR_DETECT_REGIONSNL80211_IFACE_COMB_BI_MIN_GCDNUM_NL80211_IFACE_COMBnl80211_plink_stateNL80211_PLINK_LISTENNL80211_PLINK_OPN_SNTNL80211_PLINK_OPN_RCVDNL80211_PLINK_CNF_RCVDNL80211_PLINK_ESTABNL80211_PLINK_HOLDINGNL80211_PLINK_BLOCKEDNUM_NL80211_PLINK_STATESnl80211_plink_actionNL80211_PLINK_ACTION_NO_ACTIONNL80211_PLINK_ACTION_OPENNL80211_PLINK_ACTION_BLOCKNUM_NL80211_PLINK_ACTIONSnl80211_rekey_data__NL80211_REKEY_DATA_INVALIDNL80211_REKEY_DATA_KEKNL80211_REKEY_DATA_KCKNL80211_REKEY_DATA_REPLAY_CTRNL80211_REKEY_DATA_AKMNUM_NL80211_REKEY_DATAnl80211_hidden_ssidNL80211_HIDDEN_SSID_NOT_IN_USENL80211_HIDDEN_SSID_ZERO_LENNL80211_HIDDEN_SSID_ZERO_CONTENTSnl80211_sta_wme_attr__NL80211_STA_WME_INVALIDNL80211_STA_WME_UAPSD_QUEUESNL80211_STA_WME_MAX_SP__NL80211_STA_WME_AFTER_LASTnl80211_pmksa_candidate_attr__NL80211_PMKSA_CANDIDATE_INVALIDNL80211_PMKSA_CANDIDATE_INDEXNL80211_PMKSA_CANDIDATE_BSSIDNL80211_PMKSA_CANDIDATE_PREAUTHNUM_NL80211_PMKSA_CANDIDATEnl80211_tdls_operationNL80211_TDLS_DISCOVERY_REQNL80211_TDLS_SETUPNL80211_TDLS_TEARDOWNNL80211_TDLS_ENABLE_LINKNL80211_TDLS_DISABLE_LINKnl80211_ap_sme_featuresNL80211_AP_SME_SA_QUERY_OFFLOADnl80211_feature_flagsNL80211_FEATURE_SK_TX_STATUSNL80211_FEATURE_HT_IBSSNL80211_FEATURE_INACTIVITY_TIMERNL80211_FEATURE_CELL_BASE_REG_HINTSNL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNELNL80211_FEATURE_SAENL80211_FEATURE_LOW_PRIORITY_SCANNL80211_FEATURE_SCAN_FLUSHNL80211_FEATURE_AP_SCANNL80211_FEATURE_VIF_TXPOWERNL80211_FEATURE_NEED_OBSS_SCANNL80211_FEATURE_P2P_GO_CTWINNL80211_FEATURE_P2P_GO_OPPPSNL80211_FEATURE_ADVERTISE_CHAN_LIMITSNL80211_FEATURE_FULL_AP_CLIENT_STATENL80211_FEATURE_USERSPACE_MPMNL80211_FEATURE_ACTIVE_MONITORNL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGENL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBESNL80211_FEATURE_WFA_TPC_IE_IN_PROBESNL80211_FEATURE_QUIETNL80211_FEATURE_TX_POWER_INSERTIONNL80211_FEATURE_ACKTO_ESTIMATIONNL80211_FEATURE_STATIC_SMPSNL80211_FEATURE_DYNAMIC_SMPSNL80211_FEATURE_SUPPORTS_WMM_ADMISSIONNL80211_FEATURE_MAC_ON_CREATENL80211_FEATURE_TDLS_CHANNEL_SWITCHNL80211_FEATURE_SCAN_RANDOM_MAC_ADDRNL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDRNL80211_FEATURE_ND_RANDOM_MAC_ADDRnl80211_ext_feature_indexNL80211_EXT_FEATURE_VHT_IBSSNL80211_EXT_FEATURE_RRMNL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFERNL80211_EXT_FEATURE_SCAN_START_TIMENL80211_EXT_FEATURE_BSS_PARENT_TSFNL80211_EXT_FEATURE_SET_SCAN_DWELLNL80211_EXT_FEATURE_BEACON_RATE_LEGACYNL80211_EXT_FEATURE_BEACON_RATE_HTNL80211_EXT_FEATURE_BEACON_RATE_VHTNL80211_EXT_FEATURE_FILS_STANL80211_EXT_FEATURE_MGMT_TX_RANDOM_TANL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTEDNL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSINL80211_EXT_FEATURE_CQM_RSSI_LISTNL80211_EXT_FEATURE_FILS_SK_OFFLOADNL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSKNL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1XNL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIMENL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESPNL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATENL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSIONNL80211_EXT_FEATURE_MFP_OPTIONALNL80211_EXT_FEATURE_LOW_SPAN_SCANNL80211_EXT_FEATURE_LOW_POWER_SCANNL80211_EXT_FEATURE_HIGH_ACCURACY_SCANNL80211_EXT_FEATURE_DFS_OFFLOADNL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORTNL80211_EXT_FEATURE_TXQSNL80211_EXT_FEATURE_SCAN_RANDOM_SNNL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENTNL80211_EXT_FEATURE_CAN_REPLACE_PTK0NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDERNL80211_EXT_FEATURE_AIRTIME_FAIRNESSNL80211_EXT_FEATURE_AP_PMKSA_CACHINGNL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLDNL80211_EXT_FEATURE_EXT_KEY_IDNL80211_EXT_FEATURE_STA_TX_PWRNL80211_EXT_FEATURE_SAE_OFFLOADNL80211_EXT_FEATURE_VLAN_OFFLOADNL80211_EXT_FEATURE_AQLNL80211_EXT_FEATURE_BEACON_PROTECTIONNL80211_EXT_FEATURE_CONTROL_PORT_NO_PREAUTHNL80211_EXT_FEATURE_PROTECTED_TWTNL80211_EXT_FEATURE_DEL_IBSS_STANL80211_EXT_FEATURE_MULTICAST_REGISTRATIONSNL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENTNL80211_EXT_FEATURE_SCAN_FREQ_KHZNL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211_TX_STATUSNL80211_EXT_FEATURE_OPERATING_CHANNEL_VALIDATIONNL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSKNL80211_EXT_FEATURE_SAE_OFFLOAD_APNL80211_EXT_FEATURE_FILS_DISCOVERYNL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESPNL80211_EXT_FEATURE_BEACON_RATE_HENL80211_EXT_FEATURE_SECURE_LTFNL80211_EXT_FEATURE_SECURE_RTTNL80211_EXT_FEATURE_PROT_RANGE_NEGO_AND_MEASURENL80211_EXT_FEATURE_BSS_COLORNL80211_EXT_FEATURE_FILS_CRYPTO_OFFLOADNL80211_EXT_FEATURE_RADAR_BACKGROUNDNL80211_EXT_FEATURE_POWERED_ADDR_CHANGENL80211_EXT_FEATURE_PUNCTNL80211_EXT_FEATURE_SECURE_NANNL80211_EXT_FEATURE_AUTH_AND_DEAUTH_RANDOM_TANL80211_EXT_FEATURE_OWE_OFFLOADNL80211_EXT_FEATURE_OWE_OFFLOAD_APNL80211_EXT_FEATURE_DFS_CONCURRENTNL80211_EXT_FEATURE_SPP_AMSDU_SUPPORTNUM_NL80211_EXT_FEATURESnl80211_probe_resp_offload_support_attrNL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPSNL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2PNL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211Unl80211_connect_failed_reasonNL80211_CONN_FAIL_MAX_CLIENTSNL80211_CONN_FAIL_BLOCKED_CLIENTnl80211_timeout_reasonNL80211_TIMEOUT_UNSPECIFIEDNL80211_TIMEOUT_SCANNL80211_TIMEOUT_AUTHNL80211_TIMEOUT_ASSOCnl80211_scan_flagsNL80211_SCAN_FLAG_LOW_PRIORITYNL80211_SCAN_FLAG_FLUSHNL80211_SCAN_FLAG_APNL80211_SCAN_FLAG_RANDOM_ADDRNL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIMENL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESPNL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATENL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSIONNL80211_SCAN_FLAG_LOW_SPANNL80211_SCAN_FLAG_LOW_POWERNL80211_SCAN_FLAG_HIGH_ACCURACYNL80211_SCAN_FLAG_RANDOM_SNNL80211_SCAN_FLAG_MIN_PREQ_CONTENTNL80211_SCAN_FLAG_FREQ_KHZNL80211_SCAN_FLAG_COLOCATED_6GHZnl80211_acl_policyNL80211_ACL_POLICY_ACCEPT_UNLESS_LISTEDNL80211_ACL_POLICY_DENY_UNLESS_LISTEDnl80211_smps_modeNL80211_SMPS_OFFNL80211_SMPS_STATICNL80211_SMPS_DYNAMIC__NL80211_SMPS_AFTER_LASTnl80211_radar_eventNL80211_RADAR_DETECTEDNL80211_RADAR_CAC_FINISHEDNL80211_RADAR_CAC_ABORTEDNL80211_RADAR_NOP_FINISHEDNL80211_RADAR_PRE_CAC_EXPIREDNL80211_RADAR_CAC_STARTEDnl80211_dfs_stateNL80211_DFS_USABLENL80211_DFS_UNAVAILABLENL80211_DFS_AVAILABLEnl80211_protocol_featuresNL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMPnl80211_crit_proto_idNL80211_CRIT_PROTO_UNSPECNL80211_CRIT_PROTO_DHCPNL80211_CRIT_PROTO_EAPOLNL80211_CRIT_PROTO_APIPANUM_NL80211_CRIT_PROTOnl80211_rxmgmt_flagsNL80211_RXMGMT_FLAG_ANSWEREDNL80211_RXMGMT_FLAG_EXTERNAL_AUTHnl80211_tdls_peer_capabilityNL80211_TDLS_PEER_HTNL80211_TDLS_PEER_VHTNL80211_TDLS_PEER_WMMNL80211_TDLS_PEER_HEnl80211_sched_scan_plan__NL80211_SCHED_SCAN_PLAN_INVALIDNL80211_SCHED_SCAN_PLAN_INTERVALNL80211_SCHED_SCAN_PLAN_ITERATIONS__NL80211_SCHED_SCAN_PLAN_AFTER_LASTnl80211_bss_select_attr__NL80211_BSS_SELECT_ATTR_INVALIDNL80211_BSS_SELECT_ATTR_RSSINL80211_BSS_SELECT_ATTR_BAND_PREFNL80211_BSS_SELECT_ATTR_RSSI_ADJUST__NL80211_BSS_SELECT_ATTR_AFTER_LASTnl80211_nan_function_typeNL80211_NAN_FUNC_PUBLISHNL80211_NAN_FUNC_SUBSCRIBENL80211_NAN_FUNC_FOLLOW_UP__NL80211_NAN_FUNC_TYPE_AFTER_LASTnl80211_nan_publish_typeNL80211_NAN_SOLICITED_PUBLISHNL80211_NAN_UNSOLICITED_PUBLISHnl80211_nan_func_term_reasonNL80211_NAN_FUNC_TERM_REASON_USER_REQUESTNL80211_NAN_FUNC_TERM_REASON_TTL_EXPIREDNL80211_NAN_FUNC_TERM_REASON_ERRORnl80211_nan_func_attributes__NL80211_NAN_FUNC_INVALIDNL80211_NAN_FUNC_TYPENL80211_NAN_FUNC_SERVICE_IDNL80211_NAN_FUNC_PUBLISH_TYPENL80211_NAN_FUNC_PUBLISH_BCASTNL80211_NAN_FUNC_SUBSCRIBE_ACTIVENL80211_NAN_FUNC_FOLLOW_UP_IDNL80211_NAN_FUNC_FOLLOW_UP_REQ_IDNL80211_NAN_FUNC_FOLLOW_UP_DESTNL80211_NAN_FUNC_CLOSE_RANGENL80211_NAN_FUNC_TTLNL80211_NAN_FUNC_SERVICE_INFONL80211_NAN_FUNC_SRFNL80211_NAN_FUNC_RX_MATCH_FILTERNL80211_NAN_FUNC_TX_MATCH_FILTERNL80211_NAN_FUNC_INSTANCE_IDNL80211_NAN_FUNC_TERM_REASONNUM_NL80211_NAN_FUNC_ATTRnl80211_nan_srf_attributes__NL80211_NAN_SRF_INVALIDNL80211_NAN_SRF_INCLUDENL80211_NAN_SRF_BFNL80211_NAN_SRF_BF_IDXNL80211_NAN_SRF_MAC_ADDRSNUM_NL80211_NAN_SRF_ATTRnl80211_nan_match_attributes__NL80211_NAN_MATCH_INVALIDNL80211_NAN_MATCH_FUNC_LOCALNL80211_NAN_MATCH_FUNC_PEERNUM_NL80211_NAN_MATCH_ATTRnl80211_external_auth_actionNL80211_EXTERNAL_AUTH_STARTNL80211_EXTERNAL_AUTH_ABORTnl80211_ftm_responder_attributes__NL80211_FTM_RESP_ATTR_INVALIDNL80211_FTM_RESP_ATTR_ENABLEDNL80211_FTM_RESP_ATTR_LCINL80211_FTM_RESP_ATTR_CIVICLOC__NL80211_FTM_RESP_ATTR_LASTnl80211_ftm_responder_stats__NL80211_FTM_STATS_INVALIDNL80211_FTM_STATS_SUCCESS_NUMNL80211_FTM_STATS_PARTIAL_NUMNL80211_FTM_STATS_FAILED_NUMNL80211_FTM_STATS_ASAP_NUMNL80211_FTM_STATS_NON_ASAP_NUMNL80211_FTM_STATS_TOTAL_DURATION_MSECNL80211_FTM_STATS_UNKNOWN_TRIGGERS_NUMNL80211_FTM_STATS_RESCHEDULE_REQUESTS_NUMNL80211_FTM_STATS_OUT_OF_WINDOW_TRIGGERS_NUMNL80211_FTM_STATS_PAD__NL80211_FTM_STATS_AFTER_LASTnl80211_preambleNL80211_PREAMBLE_LEGACYNL80211_PREAMBLE_HTNL80211_PREAMBLE_VHTNL80211_PREAMBLE_DMGNL80211_PREAMBLE_HEnl80211_peer_measurement_typeNL80211_PMSR_TYPE_INVALIDNL80211_PMSR_TYPE_FTMNUM_NL80211_PMSR_TYPESnl80211_peer_measurement_statusNL80211_PMSR_STATUS_SUCCESSNL80211_PMSR_STATUS_REFUSEDNL80211_PMSR_STATUS_TIMEOUTNL80211_PMSR_STATUS_FAILUREnl80211_peer_measurement_req__NL80211_PMSR_REQ_ATTR_INVALIDNL80211_PMSR_REQ_ATTR_DATANL80211_PMSR_REQ_ATTR_GET_AP_TSFNUM_NL80211_PMSR_REQ_ATTRSnl80211_peer_measurement_resp__NL80211_PMSR_RESP_ATTR_INVALIDNL80211_PMSR_RESP_ATTR_DATANL80211_PMSR_RESP_ATTR_STATUSNL80211_PMSR_RESP_ATTR_HOST_TIMENL80211_PMSR_RESP_ATTR_AP_TSFNL80211_PMSR_RESP_ATTR_FINALNL80211_PMSR_RESP_ATTR_PADNUM_NL80211_PMSR_RESP_ATTRSnl80211_peer_measurement_peer_attrs__NL80211_PMSR_PEER_ATTR_INVALIDNL80211_PMSR_PEER_ATTR_ADDRNL80211_PMSR_PEER_ATTR_CHANNL80211_PMSR_PEER_ATTR_REQNL80211_PMSR_PEER_ATTR_RESPNUM_NL80211_PMSR_PEER_ATTRSnl80211_peer_measurement_attrs__NL80211_PMSR_ATTR_INVALIDNL80211_PMSR_ATTR_MAX_PEERSNL80211_PMSR_ATTR_REPORT_AP_TSFNL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDRNL80211_PMSR_ATTR_TYPE_CAPANL80211_PMSR_ATTR_PEERSNUM_NL80211_PMSR_ATTRnl80211_peer_measurement_ftm_capa__NL80211_PMSR_FTM_CAPA_ATTR_INVALIDNL80211_PMSR_FTM_CAPA_ATTR_ASAPNL80211_PMSR_FTM_CAPA_ATTR_NON_ASAPNL80211_PMSR_FTM_CAPA_ATTR_REQ_LCINL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOCNL80211_PMSR_FTM_CAPA_ATTR_PREAMBLESNL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHSNL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENTNL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURSTNL80211_PMSR_FTM_CAPA_ATTR_TRIGGER_BASEDNL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASEDNUM_NL80211_PMSR_FTM_CAPA_ATTRnl80211_peer_measurement_ftm_req__NL80211_PMSR_FTM_REQ_ATTR_INVALIDNL80211_PMSR_FTM_REQ_ATTR_ASAPNL80211_PMSR_FTM_REQ_ATTR_PREAMBLENL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXPNL80211_PMSR_FTM_REQ_ATTR_BURST_PERIODNL80211_PMSR_FTM_REQ_ATTR_BURST_DURATIONNL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURSTNL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIESNL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCINL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOCNL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASEDNL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASEDNL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACKNL80211_PMSR_FTM_REQ_ATTR_BSS_COLORNUM_NL80211_PMSR_FTM_REQ_ATTRnl80211_peer_measurement_ftm_failure_reasonsNL80211_PMSR_FTM_FAILURE_UNSPECIFIEDNL80211_PMSR_FTM_FAILURE_NO_RESPONSENL80211_PMSR_FTM_FAILURE_REJECTEDNL80211_PMSR_FTM_FAILURE_WRONG_CHANNELNL80211_PMSR_FTM_FAILURE_PEER_NOT_CAPABLENL80211_PMSR_FTM_FAILURE_INVALID_TIMESTAMPNL80211_PMSR_FTM_FAILURE_PEER_BUSYNL80211_PMSR_FTM_FAILURE_BAD_CHANGED_PARAMSnl80211_peer_measurement_ftm_resp__NL80211_PMSR_FTM_RESP_ATTR_INVALIDNL80211_PMSR_FTM_RESP_ATTR_FAIL_REASONNL80211_PMSR_FTM_RESP_ATTR_BURST_INDEXNL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_ATTEMPTSNL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_SUCCESSESNL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIMENL80211_PMSR_FTM_RESP_ATTR_NUM_BURSTS_EXPNL80211_PMSR_FTM_RESP_ATTR_BURST_DURATIONNL80211_PMSR_FTM_RESP_ATTR_FTMS_PER_BURSTNL80211_PMSR_FTM_RESP_ATTR_RSSI_AVGNL80211_PMSR_FTM_RESP_ATTR_RSSI_SPREADNL80211_PMSR_FTM_RESP_ATTR_TX_RATENL80211_PMSR_FTM_RESP_ATTR_RX_RATENL80211_PMSR_FTM_RESP_ATTR_RTT_AVGNL80211_PMSR_FTM_RESP_ATTR_RTT_VARIANCENL80211_PMSR_FTM_RESP_ATTR_RTT_SPREADNL80211_PMSR_FTM_RESP_ATTR_DIST_AVGNL80211_PMSR_FTM_RESP_ATTR_DIST_VARIANCENL80211_PMSR_FTM_RESP_ATTR_DIST_SPREADNL80211_PMSR_FTM_RESP_ATTR_LCINL80211_PMSR_FTM_RESP_ATTR_CIVICLOCNL80211_PMSR_FTM_RESP_ATTR_PADNUM_NL80211_PMSR_FTM_RESP_ATTRnl80211_obss_pd_attributes__NL80211_HE_OBSS_PD_ATTR_INVALIDNL80211_HE_OBSS_PD_ATTR_MIN_OFFSETNL80211_HE_OBSS_PD_ATTR_MAX_OFFSETNL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSETNL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAPNL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAPNL80211_HE_OBSS_PD_ATTR_SR_CTRL__NL80211_HE_OBSS_PD_ATTR_LASTnl80211_bss_color_attributes__NL80211_HE_BSS_COLOR_ATTR_INVALIDNL80211_HE_BSS_COLOR_ATTR_COLORNL80211_HE_BSS_COLOR_ATTR_DISABLEDNL80211_HE_BSS_COLOR_ATTR_PARTIAL__NL80211_HE_BSS_COLOR_ATTR_LASTnl80211_iftype_akm_attributes__NL80211_IFTYPE_AKM_ATTR_INVALIDNL80211_IFTYPE_AKM_ATTR_IFTYPESNL80211_IFTYPE_AKM_ATTR_SUITES__NL80211_IFTYPE_AKM_ATTR_LASTnl80211_fils_discovery_attributes__NL80211_FILS_DISCOVERY_ATTR_INVALIDNL80211_FILS_DISCOVERY_ATTR_INT_MINNL80211_FILS_DISCOVERY_ATTR_INT_MAXNL80211_FILS_DISCOVERY_ATTR_TMPL__NL80211_FILS_DISCOVERY_ATTR_LASTnl80211_unsol_bcast_probe_resp_attributes__NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INVALIDNL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INTNL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL__NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_LASTnl80211_sae_pwe_mechanismNL80211_SAE_PWE_UNSPECIFIEDNL80211_SAE_PWE_HUNT_AND_PECKNL80211_SAE_PWE_HASH_TO_ELEMENTNL80211_SAE_PWE_BOTHnl80211_sar_typeNL80211_SAR_TYPE_POWERNUM_NL80211_SAR_TYPEnl80211_sar_attrs__NL80211_SAR_ATTR_INVALIDNL80211_SAR_ATTR_TYPENL80211_SAR_ATTR_SPECS__NL80211_SAR_ATTR_LASTnl80211_sar_specs_attrs__NL80211_SAR_ATTR_SPECS_INVALIDNL80211_SAR_ATTR_SPECS_POWERNL80211_SAR_ATTR_SPECS_RANGE_INDEXNL80211_SAR_ATTR_SPECS_START_FREQNL80211_SAR_ATTR_SPECS_END_FREQ__NL80211_SAR_ATTR_SPECS_LASTnl80211_mbssid_config_attributes__NL80211_MBSSID_CONFIG_ATTR_INVALIDNL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACESNL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITYNL80211_MBSSID_CONFIG_ATTR_INDEXNL80211_MBSSID_CONFIG_ATTR_TX_IFINDEXNL80211_MBSSID_CONFIG_ATTR_EMANL80211_MBSSID_CONFIG_ATTR_TX_LINK_ID__NL80211_MBSSID_CONFIG_ATTR_LASTnl80211_ap_settings_flagsNL80211_AP_SETTINGS_EXTERNAL_AUTH_SUPPORTNL80211_AP_SETTINGS_SA_QUERY_OFFLOAD_SUPPORTnl80211_wiphy_radio_attrs__NL80211_WIPHY_RADIO_ATTR_INVALIDNL80211_WIPHY_RADIO_ATTR_INDEXNL80211_WIPHY_RADIO_ATTR_FREQ_RANGENL80211_WIPHY_RADIO_ATTR_INTERFACE_COMBINATIONNL80211_WIPHY_RADIO_ATTR_ANTENNA_MASK__NL80211_WIPHY_RADIO_ATTR_LASTnl80211_wiphy_radio_freq_range__NL80211_WIPHY_RADIO_FREQ_ATTR_INVALIDNL80211_WIPHY_RADIO_FREQ_ATTR_STARTNL80211_WIPHY_RADIO_FREQ_ATTR_END__NL80211_WIPHY_RADIO_FREQ_ATTR_LASTrt_scope_trt_class_t4294967295RT_TABLE_MAXrtattr_type_tRTA_IP_PROTORTA_SPORTRTA_DPORTRTA_NH_IDRTA_FLOWLABEL__RTA_MAXrtnetlink_groupsRTNLGRP_IPV4_MCADDRRTNLGRP_IPV6_MCADDRRTNLGRP_IPV6_ACADDR__RTNLGRP_MAXicmptNL80211_CMD_NEW_BEACONNL80211_CMD_DEL_BEACONNL80211_CMD_REGISTER_ACTIONNL80211_CMD_ACTIONNL80211_CMD_ACTION_TX_STATUSNL80211_CMD_MAXNUM_NL80211_ATTRNL80211_ATTR_MAXNL80211_IFTYPE_MAXNL80211_STA_FLAG_MAXNL80211_RATE_INFO_MAXNL80211_STA_BSS_PARAM_MAXNL80211_STA_INFO_MAXNL80211_TID_STATS_MAXNL80211_TXQ_STATS_MAXNL80211_MPATH_INFO_MAXNL80211_BAND_IFTYPE_ATTR_MAXNL80211_BAND_ATTR_MAXNL80211_WMMR_MAXNL80211_FREQUENCY_ATTR_MAXNL80211_BITRATE_ATTR_MAXNL80211_REG_RULE_ATTR_MAXNL80211_SCHED_SCAN_MATCH_ATTR_MAXNL80211_SURVEY_INFO_MAXNL80211_MNTR_FLAG_MAXNL80211_MESH_POWER_MAXNL80211_MESHCONF_ATTR_MAXNL80211_MESH_SETUP_ATTR_MAXNL80211_TXQ_ATTR_MAXNL80211_BSS_MAXNL80211_AUTHTYPE_MAXNL80211_AUTHTYPE_AUTOMATICNL80211_KEY_MAXNL80211_TXRATE_MAXNL80211_ATTR_CQM_MAXNL80211_TID_CONFIG_ATTR_MAXMAX_NL80211_PKTPATMAX_NL80211_WOWLAN_TRIGMAX_NL80211_WOWLAN_TCPNL80211_ATTR_COALESCE_RULE_MAXMAX_NL80211_IFACE_LIMITMAX_NL80211_IFACE_COMBMAX_NL80211_PLINK_STATESMAX_NL80211_REKEY_DATANL80211_STA_WME_MAXMAX_NL80211_PMKSA_CANDIDATENL80211_EXT_FEATURE_DATA_ACK_SIGNAL_SUPPORTMAX_NL80211_EXT_FEATURESNL80211_SMPS_MAXNL80211_SCHED_SCAN_PLAN_MAXNL80211_BSS_SELECT_ATTR_MAXNL80211_NAN_FUNC_MAX_TYPENL80211_NAN_FUNC_ATTR_MAXNL80211_NAN_SRF_ATTR_MAXNL80211_NAN_MATCH_ATTR_MAXNL80211_FTM_RESP_ATTR_MAXNL80211_FTM_STATS_MAXNL80211_PMSR_TYPE_MAXNL80211_PMSR_REQ_ATTR_MAXNL80211_PMSR_RESP_ATTR_MAXNL80211_PMSR_PEER_ATTR_MAXNL80211_PMSR_ATTR_MAXNL80211_PMSR_FTM_CAPA_ATTR_MAXNL80211_PMSR_FTM_REQ_ATTR_MAXNL80211_PMSR_FTM_RESP_ATTR_MAXNL80211_HE_OBSS_PD_ATTR_MAXNL80211_HE_BSS_COLOR_ATTR_MAXNL80211_IFTYPE_AKM_ATTR_MAXNL80211_FILS_DISCOVERY_ATTR_MAXNL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAXNL80211_SAR_ATTR_MAXNL80211_SAR_ATTR_SPECS_MAXNL80211_MBSSID_CONFIG_ATTR_MAXNL80211_WIPHY_RADIO_ATTR_MAXNL80211_WIPHY_RADIO_FREQ_ATTR_MAXend_codestart_dataend_datastart_brkarg_startarg_endenv_startenv_endauxvauxv_sizeexe_fdprctl_mm_mapPR_PMLEN_SHIFTPR_PMLEN_MASKPR_RISCV_SET_ICACHE_FLUSH_CTXPR_RISCV_CTX_SW_FENCEI_ONPR_RISCV_CTX_SW_FENCEI_OFFPR_RISCV_SCOPE_PER_PROCESSPR_RISCV_SCOPE_PER_THREADPR_PPC_GET_DEXCRPR_PPC_SET_DEXCRPR_PPC_DEXCR_SBHEPR_PPC_DEXCR_IBRTPDPR_PPC_DEXCR_SRAPDPR_PPC_DEXCR_NPHIEPR_PPC_DEXCR_CTRL_EDITABLEPR_PPC_DEXCR_CTRL_SETPR_PPC_DEXCR_CTRL_CLEARPR_PPC_DEXCR_CTRL_SET_ONEXECPR_PPC_DEXCR_CTRL_CLEAR_ONEXECPR_PPC_DEXCR_CTRL_MASKPR_GET_SHADOW_STACK_STATUSPR_SET_SHADOW_STACK_STATUSPR_SHADOW_STACK_ENABLEPR_SHADOW_STACK_WRITEPR_SHADOW_STACK_PUSHPR_LOCK_SHADOW_STACK_STATUSPR_TIMER_CREATE_RESTORE_IDSPR_TIMER_CREATE_RESTORE_IDS_OFFPR_TIMER_CREATE_RESTORE_IDS_ONPR_TIMER_CREATE_RESTORE_IDS_GETPR_FUTEX_HASHPR_FUTEX_HASH_SET_SLOTSFH_FLAG_IMMUTABLEPR_FUTEX_HASH_GET_SLOTSPR_FUTEX_HASH_GET_IMMUTABLE__uint128_tbacklog_limitlostaudit_status__bindgen_ty_1backlog_wait_timebacklog_wait_time_actualaudit_statusaudit_featureslog_passwdaudit_tty_statusfieldflagsbuflenaudit_rule_datafilter_offseccomp_metadataptrace_syscall_info__bindgen_ty_1ptrace_syscall_info__bindgen_ty_1__bindgen_ty_1rvalptrace_syscall_info__bindgen_ty_1__bindgen_ty_2ptrace_syscall_info__bindgen_ty_1__bindgen_ty_331usizepstateuser_pt_regsvregsfpsrfpcruser_fpsimd_statedbg_infodbg_regsuser_hwdebug_state__bindgen_ty_1user_hwdebug_statevlmax_vluser_sve_headerdata_maskinsn_maskuser_pac_maskapiakeyapibkeyapdakeyapdbkeyuser_pac_address_keysapgakeyuser_pac_generic_keysuser_za_headerfeatures_enabledfeatures_lockedgcspr_el0user_gcsAUDIT_GETAUDIT_SETAUDIT_LISTAUDIT_ADDAUDIT_DELAUDIT_USERAUDIT_LOGINAUDIT_WATCH_INSAUDIT_WATCH_REMAUDIT_WATCH_LISTAUDIT_SIGNAL_INFOAUDIT_ADD_RULEAUDIT_DEL_RULEAUDIT_LIST_RULESAUDIT_TRIMAUDIT_MAKE_EQUIVAUDIT_TTY_GETAUDIT_TTY_SETAUDIT_SET_FEATUREAUDIT_GET_FEATUREAUDIT_FIRST_USER_MSGAUDIT_USER_AVCAUDIT_USER_TTYAUDIT_LAST_USER_MSGAUDIT_FIRST_USER_MSG2AUDIT_LAST_USER_MSG2AUDIT_DAEMON_STARTAUDIT_DAEMON_ENDAUDIT_DAEMON_ABORTAUDIT_DAEMON_CONFIGAUDIT_SYSCALLAUDIT_PATHAUDIT_IPCAUDIT_SOCKETCALLAUDIT_CONFIG_CHANGEAUDIT_SOCKADDRAUDIT_CWDAUDIT_EXECVEAUDIT_IPC_SET_PERMAUDIT_MQ_OPENAUDIT_MQ_SENDRECVAUDIT_MQ_NOTIFYAUDIT_MQ_GETSETATTRAUDIT_KERNEL_OTHERAUDIT_FD_PAIRAUDIT_OBJ_PIDAUDIT_TTYAUDIT_EOEAUDIT_BPRM_FCAPSAUDIT_CAPSETAUDIT_MMAPAUDIT_NETFILTER_PKTAUDIT_NETFILTER_CFGAUDIT_SECCOMPAUDIT_PROCTITLEAUDIT_FEATURE_CHANGEAUDIT_REPLACEAUDIT_KERN_MODULEAUDIT_FANOTIFYAUDIT_TIME_INJOFFSETAUDIT_TIME_ADJNTPVALAUDIT_BPFAUDIT_EVENT_LISTENERAUDIT_URINGOPAUDIT_OPENAT2AUDIT_DM_CTRLAUDIT_DM_EVENTAUDIT_AVCAUDIT_SELINUX_ERRAUDIT_AVC_PATHAUDIT_MAC_POLICY_LOADAUDIT_MAC_STATUSAUDIT_MAC_CONFIG_CHANGEAUDIT_MAC_UNLBL_ALLOWAUDIT_MAC_CIPSOV4_ADDAUDIT_MAC_CIPSOV4_DELAUDIT_MAC_MAP_ADDAUDIT_MAC_MAP_DELAUDIT_MAC_IPSEC_ADDSAAUDIT_MAC_IPSEC_DELSAAUDIT_MAC_IPSEC_ADDSPDAUDIT_MAC_IPSEC_DELSPDAUDIT_MAC_IPSEC_EVENTAUDIT_MAC_UNLBL_STCADDAUDIT_MAC_UNLBL_STCDELAUDIT_MAC_CALIPSO_ADDAUDIT_MAC_CALIPSO_DELAUDIT_IPE_ACCESSAUDIT_IPE_CONFIG_CHANGEAUDIT_IPE_POLICY_LOADAUDIT_LANDLOCK_ACCESSAUDIT_LANDLOCK_DOMAINAUDIT_FIRST_KERN_ANOM_MSGAUDIT_LAST_KERN_ANOM_MSGAUDIT_ANOM_PROMISCUOUSAUDIT_ANOM_ABENDAUDIT_ANOM_LINKAUDIT_ANOM_CREATAUDIT_INTEGRITY_DATAAUDIT_INTEGRITY_METADATAAUDIT_INTEGRITY_STATUSAUDIT_INTEGRITY_HASHAUDIT_INTEGRITY_PCRAUDIT_INTEGRITY_RULEAUDIT_INTEGRITY_EVM_XATTRAUDIT_INTEGRITY_POLICY_RULEAUDIT_INTEGRITY_USERSPACEAUDIT_KERNELAUDIT_FILTER_USERAUDIT_FILTER_TASKAUDIT_FILTER_ENTRYAUDIT_FILTER_WATCHAUDIT_FILTER_EXITAUDIT_FILTER_EXCLUDEAUDIT_FILTER_TYPEAUDIT_FILTER_FSAUDIT_FILTER_URING_EXITAUDIT_NR_FILTERSAUDIT_FILTER_PREPENDAUDIT_NEVERAUDIT_POSSIBLEAUDIT_ALWAYSAUDIT_MAX_FIELDSAUDIT_MAX_KEY_LENAUDIT_BITMASK_SIZEAUDIT_SYSCALL_CLASSESAUDIT_CLASS_DIR_WRITEAUDIT_CLASS_DIR_WRITE_32AUDIT_CLASS_CHATTRAUDIT_CLASS_CHATTR_32AUDIT_CLASS_READAUDIT_CLASS_READ_32AUDIT_CLASS_WRITEAUDIT_CLASS_WRITE_32AUDIT_CLASS_SIGNALAUDIT_CLASS_SIGNAL_32AUDIT_UNUSED_BITSAUDIT_COMPARE_UID_TO_OBJ_UIDAUDIT_COMPARE_GID_TO_OBJ_GIDAUDIT_COMPARE_EUID_TO_OBJ_UIDAUDIT_COMPARE_EGID_TO_OBJ_GIDAUDIT_COMPARE_AUID_TO_OBJ_UIDAUDIT_COMPARE_SUID_TO_OBJ_UIDAUDIT_COMPARE_SGID_TO_OBJ_GIDAUDIT_COMPARE_FSUID_TO_OBJ_UIDAUDIT_COMPARE_FSGID_TO_OBJ_GIDAUDIT_COMPARE_UID_TO_AUIDAUDIT_COMPARE_UID_TO_EUIDAUDIT_COMPARE_UID_TO_FSUIDAUDIT_COMPARE_UID_TO_SUIDAUDIT_COMPARE_AUID_TO_FSUIDAUDIT_COMPARE_AUID_TO_SUIDAUDIT_COMPARE_AUID_TO_EUIDAUDIT_COMPARE_EUID_TO_SUIDAUDIT_COMPARE_EUID_TO_FSUIDAUDIT_COMPARE_SUID_TO_FSUIDAUDIT_COMPARE_GID_TO_EGIDAUDIT_COMPARE_GID_TO_FSGIDAUDIT_COMPARE_GID_TO_SGIDAUDIT_COMPARE_EGID_TO_FSGIDAUDIT_COMPARE_EGID_TO_SGIDAUDIT_COMPARE_SGID_TO_FSGIDAUDIT_MAX_FIELD_COMPAREAUDIT_PIDAUDIT_UIDAUDIT_EUIDAUDIT_SUIDAUDIT_FSUIDAUDIT_GIDAUDIT_EGIDAUDIT_SGIDAUDIT_FSGIDAUDIT_LOGINUIDAUDIT_PERSAUDIT_ARCHAUDIT_MSGTYPEAUDIT_SUBJ_USERAUDIT_SUBJ_ROLEAUDIT_SUBJ_TYPEAUDIT_SUBJ_SENAUDIT_SUBJ_CLRAUDIT_PPIDAUDIT_OBJ_USERAUDIT_OBJ_ROLEAUDIT_OBJ_TYPEAUDIT_OBJ_LEV_LOWAUDIT_OBJ_LEV_HIGHAUDIT_LOGINUID_SETAUDIT_SESSIONIDAUDIT_FSTYPEAUDIT_DEVMAJORAUDIT_DEVMINORAUDIT_INODEAUDIT_EXITAUDIT_SUCCESSAUDIT_WATCHAUDIT_PERMAUDIT_DIRAUDIT_FILETYPEAUDIT_OBJ_UIDAUDIT_OBJ_GIDAUDIT_FIELD_COMPAREAUDIT_EXEAUDIT_SADDR_FAMAUDIT_ARG0AUDIT_ARG1AUDIT_ARG2AUDIT_ARG3AUDIT_FILTERKEYAUDIT_NEGATEAUDIT_BIT_MASKAUDIT_LESS_THANAUDIT_GREATER_THANAUDIT_NOT_EQUALAUDIT_EQUALAUDIT_BIT_TESTAUDIT_LESS_THAN_OR_EQUALAUDIT_GREATER_THAN_OR_EQUALAUDIT_OPERATORSAUDIT_STATUS_ENABLEDAUDIT_STATUS_FAILUREAUDIT_STATUS_PIDAUDIT_STATUS_RATE_LIMITAUDIT_STATUS_BACKLOG_LIMITAUDIT_STATUS_BACKLOG_WAIT_TIMEAUDIT_STATUS_LOSTAUDIT_STATUS_BACKLOG_WAIT_TIME_ACTUALAUDIT_FEATURE_BITMAP_BACKLOG_LIMITAUDIT_FEATURE_BITMAP_BACKLOG_WAIT_TIMEAUDIT_FEATURE_BITMAP_EXECUTABLE_PATHAUDIT_FEATURE_BITMAP_EXCLUDE_EXTENDAUDIT_FEATURE_BITMAP_SESSIONID_FILTERAUDIT_FEATURE_BITMAP_LOST_RESETAUDIT_FEATURE_BITMAP_FILTER_FSAUDIT_FEATURE_BITMAP_ALLAUDIT_VERSION_LATESTAUDIT_VERSION_BACKLOG_LIMITAUDIT_VERSION_BACKLOG_WAIT_TIMEAUDIT_FAIL_SILENTAUDIT_FAIL_PRINTKAUDIT_FAIL_PANIC__AUDIT_ARCH_CONVENTION_MASK__AUDIT_ARCH_CONVENTION_MIPS64_N32__AUDIT_ARCH_64BIT__AUDIT_ARCH_LEAUDIT_ARCH_AARCH64AUDIT_ARCH_ALPHAAUDIT_ARCH_ARCOMPACTAUDIT_ARCH_ARCOMPACTBEAUDIT_ARCH_ARCV2AUDIT_ARCH_ARCV2BEAUDIT_ARCH_ARMAUDIT_ARCH_ARMEBAUDIT_ARCH_C6XAUDIT_ARCH_C6XBEAUDIT_ARCH_CRISAUDIT_ARCH_CSKYAUDIT_ARCH_FRVAUDIT_ARCH_H8300AUDIT_ARCH_HEXAGONAUDIT_ARCH_I386AUDIT_ARCH_IA64AUDIT_ARCH_M32RAUDIT_ARCH_M68KAUDIT_ARCH_MICROBLAZEAUDIT_ARCH_MIPSAUDIT_ARCH_MIPSELAUDIT_ARCH_MIPS64AUDIT_ARCH_MIPS64N32AUDIT_ARCH_MIPSEL64AUDIT_ARCH_MIPSEL64N32AUDIT_ARCH_NDS32AUDIT_ARCH_NDS32BEAUDIT_ARCH_NIOS2AUDIT_ARCH_OPENRISCAUDIT_ARCH_PARISCAUDIT_ARCH_PARISC64AUDIT_ARCH_PPCAUDIT_ARCH_PPC64AUDIT_ARCH_PPC64LEAUDIT_ARCH_RISCV32AUDIT_ARCH_RISCV64AUDIT_ARCH_S390AUDIT_ARCH_S390XAUDIT_ARCH_SHAUDIT_ARCH_SHELAUDIT_ARCH_SH64AUDIT_ARCH_SHEL64AUDIT_ARCH_SPARCAUDIT_ARCH_SPARC64AUDIT_ARCH_TILEGXAUDIT_ARCH_TILEGX32AUDIT_ARCH_TILEPROAUDIT_ARCH_UNICOREAUDIT_ARCH_X86_64AUDIT_ARCH_XTENSAAUDIT_ARCH_LOONGARCH32AUDIT_ARCH_LOONGARCH64AUDIT_PERM_EXECAUDIT_PERM_WRITEAUDIT_PERM_READAUDIT_PERM_ATTRAUDIT_MESSAGE_TEXT_MAXAUDIT_FEATURE_VERSIONAUDIT_FEATURE_ONLY_UNSET_LOGINUIDAUDIT_FEATURE_LOGINUID_IMMUTABLEAUDIT_LAST_FEATUREBPF_MAJOR_VERSIONBPF_MINOR_VERSIONPTRACE_PEEKUSRPTRACE_POKEUSRPTRACE_SECCOMP_GET_FILTERPTRACE_SET_SYSCALL_INFOPTRACE_EVENTMSG_SYSCALL_ENTRYPTRACE_EVENTMSG_SYSCALL_EXITHWCAP_GCSHWCAP_CMPBRHWCAP_FPRCVTHWCAP_F8MM8HWCAP_F8MM4HWCAP_SVE_F16MMHWCAP_SVE_ELTPERMHWCAP_SVE_AES2HWCAP_SVE_BFSCALEHWCAP_SVE2P2HWCAP_SME2P2HWCAP_SME_SBITPERMHWCAP_SME_AESHWCAP_SME_SFEXPAHWCAP_SME_STMOPHWCAP_SME_SMOP4HWCAP2_CSSCHWCAP2_RPRFMHWCAP2_SVE2P1HWCAP2_SME2HWCAP2_SME2P1HWCAP2_SME_I16I32HWCAP2_SME_BI32I32HWCAP2_SME_B16B16HWCAP2_SME_F16F16HWCAP2_MOPSHWCAP2_HBCHWCAP2_SVE_B16B16HWCAP2_LRCPC3HWCAP2_LSE128HWCAP2_FPMRHWCAP2_LUTHWCAP2_FAMINMAXHWCAP2_F8CVTHWCAP2_F8FMAHWCAP2_F8DP4HWCAP2_F8DP2HWCAP2_F8E4M3HWCAP2_F8E5M2HWCAP2_SME_LUTV2HWCAP2_SME_F8F16HWCAP2_SME_F8F32HWCAP2_SME_SF8FMAHWCAP2_SME_SF8DP4HWCAP2_SME_SF8DP2HWCAP2_POE__SVE_VQ_BYTES__SVE_VQ_MIN__SVE_VQ_MAX__SVE_VL_MIN__SVE_VL_MAX__SVE_NUM_ZREGS__SVE_NUM_PREGS__SVE_ZREGS_OFFSETPSR_MODE_EL0tPSR_MODE_EL1tPSR_MODE_EL1hPSR_MODE_EL2tPSR_MODE_EL2hPSR_MODE_EL3tPSR_MODE_EL3hPSR_MODE_MASKPSR_MODE32_BITPSR_F_BITPSR_I_BITPSR_A_BITPSR_D_BITPSR_BTYPE_MASKPSR_SSBS_BITPSR_PAN_BITPSR_UAO_BITPSR_DIT_BITPSR_TCO_BITPSR_V_BITPSR_C_BITPSR_Z_BITPSR_N_BITPSR_BTYPE_SHIFTPSR_fPSR_sPSR_xPSR_cPSR_BTYPE_NONEPSR_BTYPE_JCPSR_BTYPE_CPSR_BTYPE_JPTRACE_PEEKMTETAGSPTRACE_POKEMTETAGSSVE_PT_REGS_MASKSVE_PT_REGS_FPSIMDSVE_PT_REGS_SVESVE_PT_VL_INHERITSVE_PT_VL_ONEXECZA_PT_VL_INHERITZA_PT_VL_ONEXECSECCOMP_USER_NOTIF_FD_SYNC_WAKE_UPSECCOMP_IOC_MAGICAudit_equalAudit_not_equalAudit_bitmaskAudit_bittestAudit_ltAudit_gtAudit_leAudit_geAudit_badaudit_nlgrpsAUDIT_NLGRP_NONEAUDIT_NLGRP_READLOG__AUDIT_NLGRP_MAXfeature_bitmapoldold_utsname65usizeold_utsnamenew_utsname__OLD_UTS_LEN__NEW_UTS_LENxsk_tx_metadata__bindgen_ty_1launch_timexsk_tx_metadata__bindgen_ty_1__bindgen_ty_1xsk_tx_metadata__bindgen_ty_1__bindgen_ty_2XDP_TXMD_FLAGS_LAUNCH_TIME_usigaction__bindgen_ty_1__old_kernel_stat__st_inoSIGSWISA_THIRTYTWO__NR_OABI_SYSCALL_BASE__NR_SYSCALL_MASK__NR_SYSCALL_BASE__NR_fork__NR_open__NR_creat__NR_link__NR_unlink__NR_mknod__NR_chmod__NR_lchown__NR_pause__NR_access__NR_nice__NR_rename__NR_mkdir__NR_rmdir__NR_pipe__NR_ustat__NR_dup2__NR_getpgrp__NR_sigaction__NR_sigsuspend__NR_sigpending__NR_symlink__NR_readlink__NR_uselib__NR_stat__NR_lstat__NR_sigreturn__NR_sigprocmask__NR_bdflush__NR_sysfs__NR__llseek__NR_getdents__NR__newselect__NR__sysctl__NR_poll__NR_chown__NR_vfork__NR_ugetrlimit__NR_mmap2__NR_truncate64__NR_ftruncate64__NR_stat64__NR_lstat64__NR_fstat64__NR_lchown32__NR_getuid32__NR_getgid32__NR_geteuid32__NR_getegid32__NR_setreuid32__NR_setregid32__NR_getgroups32__NR_setgroups32__NR_fchown32__NR_setresuid32__NR_getresuid32__NR_setresgid32__NR_getresgid32__NR_chown32__NR_setuid32__NR_setgid32__NR_setfsuid32__NR_setfsgid32__NR_fcntl64__NR_sendfile64__NR_epoll_create__NR_epoll_wait__NR_statfs64__NR_fstatfs64__NR_utimes__NR_arm_fadvise64_64__NR_pciconfig_iobase__NR_pciconfig_read__NR_pciconfig_write__NR_send__NR_recv__NR_vserver__NR_inotify_init__NR_futimesat__NR_fstatat64__NR_arm_sync_file_range__NR_signalfd__NR_eventfd__NR_clock_gettime64__NR_clock_settime64__NR_clock_adjtime64__NR_clock_getres_time64__NR_clock_nanosleep_time64__NR_timer_gettime64__NR_timer_settime64__NR_timerfd_gettime64__NR_timerfd_settime64__NR_utimensat_time64__NR_pselect6_time64__NR_ppoll_time64__NR_io_pgetevents_time64__NR_recvmmsg_time64__NR_mq_timedsend_time64__NR_mq_timedreceive_time64__NR_semtimedop_time64__NR_rt_sigtimedwait_time64__NR_futex_time64__NR_sched_rr_get_interval_time64__NR_sync_file_range2__ARM_NR_BASE__ARM_NR_breakpoint__ARM_NR_cacheflush__ARM_NR_usr26__ARM_NR_usr32__ARM_NR_set_tls__ARM_NR_get_tlsSTAT64_HAS_BROKEN_ST_INO_sa_handler_sa_sigaction67usizeuregs18usizept_regsHWCAP_SWPHWCAP_HALFHWCAP_THUMBHWCAP_26BITHWCAP_FAST_MULTHWCAP_FPAHWCAP_VFPHWCAP_EDSPHWCAP_JAVAHWCAP_IWMMXTHWCAP_CRUNCHHWCAP_THUMBEEHWCAP_NEONHWCAP_VFPv3HWCAP_VFPv3D16HWCAP_TLSHWCAP_VFPv4HWCAP_IDIVAHWCAP_IDIVTHWCAP_VFPD32HWCAP_IDIVHWCAP_LPAEHWCAP_ASIMDBF16HWCAP_I8MMHWCAP2_AESHWCAP2_PMULLHWCAP2_SHA1HWCAP2_SHA2HWCAP2_CRC32HWCAP2_SBHWCAP2_SSBSPTRACE_GETWMMXREGSPTRACE_SETWMMXREGSPTRACE_OLDSETOPTIONSPTRACE_GET_THREAD_AREAPTRACE_SET_SYSCALLPTRACE_GETCRUNCHREGSPTRACE_SETCRUNCHREGSPTRACE_GETVFPREGSPTRACE_SETVFPREGSPTRACE_GETHBPREGSPTRACE_SETHBPREGSPTRACE_GETFDPICPTRACE_GETFDPIC_EXECPTRACE_GETFDPIC_INTERPUSR26_MODEFIQ26_MODEIRQ26_MODESVC26_MODEUSR_MODESVC_MODEFIQ_MODEIRQ_MODEMON_MODEABT_MODEHYP_MODEUND_MODESYSTEM_MODEMODE32_BITMODE_MASKV4_PSR_T_BITV7M_PSR_T_BITPSR_T_BITPSR_E_BITPSR_J_BITPSR_Q_BITAPSR_MASKPSR_ISET_MASKPSR_IT_MASKPSR_ENDIAN_MASKPSR_ENDSTATEPT_TEXT_ADDRPT_DATA_ADDRPT_TEXT_END_ADDRARM_VFPREGS_SIZE__NR_llseek__NR_fadvise64_64__NR_set_thread_area__NR_cacheflushlrsrusporig_a0a0a1a2a3vr96usizefcrfesruser_fpELFCLASS// ELFCLASS32ELFDATA// ELFCLASS64// ELFDATA2MSBELFABIVERSION// At present all of our supported platforms use 0.VER_DEF_CURRENTSTV_DEFAULTEM_CURRENT// EM_MIPSELF_ST_VISIBILITYELF_ST_BINDELF_ST_TYPEElf_Verdef_vda_nextElf_VerdauxElf_Dyn_UnionElf_DynElf_RelaElf_RelR_RELATIVEa_typea_val// Some of the values in the auxv array are pointers, so we make `a_val` a// pointer, in order to preserve their provenance. For the values which are// integers, we cast this to `usize`.Elf_auxv_t//! The ELF ABI. 🧝//! This module is not as comprehensive as bindgened [`elf_uapi`] and provides only types for target//! pointer width: instead of [`elf32_phdr`] and [`elf64_phdr`] there's only [`Elf_Phdr`].//! [`elf_uapi`]: super::elf_uapi//! [`elf32_phdr`]: super::elf_uapi::elf32_phdr//! [`elf64_phdr`]: super::elf_uapi::elf64_phdr// EM_RISCV// `R_ARM_RELATIVE`// The following assumes that Linux is always either ILP32 or LP64,// and char is always 8-bit.// In theory, `c_long` and `c_ulong` could be `isize` and `usize`// respectively, however in practice Linux doesn't use them in that way// consistently. So stick with the convention followed by `libc` and// others and use the fixed-width types.assert_eq_sizeassert_type_eq_all// Confirm that our type definitions above match the actual type definitions.// We don't enable `derive_eq` in bindgen because adding `PartialEq`/`Eq` to// *all* structs noticeably increases compile times. But we can add a few// manual impls where they're especially useful.cmsg_macrosselect_macrossig_ign/// Rust doesn't currently permit us to use `transmute` to convert the/// `SIG_IGN` value into a function pointer in a `const` initializer, so/// we make it a function instead.signal_macros"x86_64/auxvec.rs"auxvec"x86_64/errno.rs""x86_64/general.rs""x86_64/if_ether.rs"if_ether"x86_64/ioctl.rs""x86_64/net.rs""x86_64/netlink.rs""x86_64/prctl.rs""x86_64/xdp.rs"xdp/*
Unsafe functions no longer implicitly create unsafe blocks (RFC 2585).
While newer bindgen versions follow this convention, we support Rust 1.63 which warns about
this behavior. We can simply silence these warnings.
*/CM_IOSDBGLVLMEYEIOC_SYNCCM_IOCGATRcsr_eracsr_badvfprfccfcsruser_fp_stateuser_lsx_stateuser_lasx_statescrftopuser_lbt_stateuser_watch_state__bindgen_ty_1user_watch_stateuser_watch_state_v2__bindgen_ty_1user_watch_state_v2GPR_BASEGPR_NUMGPR_ENDARG0BADVADDRNUM_FPU_REGS_MIPS_ISA_MIPS1_MIPS_ISA_MIPS2_MIPS_ISA_MIPS3_MIPS_ISA_MIPS4_MIPS_ISA_MIPS5_MIPS_ISA_MIPS32_MIPS_ISA_MIPS64_MIPS_SIM_ABI32_MIPS_SIM_NABI32_MIPS_SIM_ABI64EINITEREMDEVl_sysid23usizesg_ispeedsg_ospeedsg_erasesg_killsg_flagssgttybt_intrct_quitct_startct_stopct_eofct_brkctcharst_suspct_dsuspct_rprntct_flushct_werasct_lnextcltcharsst_pad1st_pad2st_pad3st_pad4st_pad0MAP_AUTOGROWMAP_LOCALMAP_AUTORSRVITOSTOP__NR_Linux__NR_syscall__NR_waitpid__NR_time__NR_break__NR_unused18__NR_umount__NR_stime__NR_alarm__NR_unused28__NR_utime__NR_stty__NR_gtty__NR_ftime__NR_prof__NR_signal__NR_lock__NR_mpx__NR_ulimit__NR_unused59__NR_sgetmask__NR_ssetmask__NR_reserved82__NR_unused84__NR_readdir__NR_profil__NR_ioperm__NR_socketcall__NR_unused109__NR_iopl__NR_idle__NR_vm86__NR_ipc__NR_modify_ldt__NR_create_module__NR_get_kernel_syms__NR_afs_syscall__NR_cachectl__NR_sysmips__NR_unused150__NR_query_module__NR_getpmsg__NR_putpmsg__NR_reserved221__NR_timerfd2348810244026531840cp0_epccp0_badvaddrcp0_statuscp0_causewatchlowatchhiwatch_masksnum_validmips32_watch_regsmips64_watch_regspt_watch_stylept_watch_regs__bindgen_ty_1pt_watch_regsFPR_BASECAUSEMMHIMMLOFPC_CSRFPC_EIRDSP_BASEDSP_CONTROLACXPTRACE_SET_THREAD_AREAPTRACE_PEEKTEXT_3264PTRACE_PEEKDATA_3264PTRACE_POKETEXT_3264PTRACE_POKEDATA_3264PTRACE_GET_THREAD_AREA_3264PTRACE_GET_WATCH_REGSPTRACE_SET_WATCH_REGSpt_watch_style_mips32pt_watch_style_mips64mips32__NR_reserved177__NR_reserved193AT_IGNOREPPC__vector128old_sigactiondbg_typedbg_valuesig_dbg_opPROT_SAOSIG_DBG_SINGLE_STEPPINGSIG_DBG_BRANCH_TRACING_VINTR_VQUIT_VERASE_VKILL_VEOF_VMIN_VEOL_VTIME_VEOL2_VSWTC__NR_oldstat__NR_oldfstat__NR_oldolduname__NR_select__NR_oldlstat__NR_olduname__NR_multiplexer__NR_tuxcall__NR_swapcontext__NR_rtas__NR_sys_debug_setcontext__NR_spu_run__NR_spu_create__NR_subpage_prot__NR_switch_endiangprnipmsrorig_gpr3xerccrmqtrapdardsisrnum_instruction_bpsnum_data_bpsnum_condition_regsdata_bp_alignmentsizeof_conditionppc_debug_infotrigger_typeaddr_modecondition_modecondition_valueppc_hw_breakpointPT_R0PT_R1PT_R2PT_R3PT_R4PT_R5PT_R6PT_R7PT_R8PT_R9PT_R10PT_R11PT_R12PT_R13PT_R14PT_R15PT_R16PT_R17PT_R18PT_R19PT_R20PT_R21PT_R22PT_R23PT_R24PT_R25PT_R26PT_R27PT_R28PT_R29PT_R30PT_R31PT_NIPPT_MSRPT_ORIG_R3PT_CTRPT_LNKPT_XERPT_CCRPT_MQPT_TRAPPT_DARPT_DSISRPT_RESULTPT_DSCRPT_REGS_COUNTPT_FPR0PT_FPR31PT_FPSCRPTRACE_GETVRREGSPTRACE_SETVRREGSPTRACE_GETEVRREGSPTRACE_SETEVRREGSPTRACE_GETVSRREGSPTRACE_SETVSRREGSPTRACE_GET_DEBUGREGPTRACE_SET_DEBUGREGPTRACE_GETREGS64PTRACE_SETREGS64PPC_PTRACE_PEEKTEXT_3264PPC_PTRACE_PEEKDATA_3264PPC_PTRACE_POKETEXT_3264PPC_PTRACE_POKEDATA_3264PPC_PTRACE_PEEKUSR_3264PPC_PTRACE_POKEUSR_3264PTRACE_SINGLEBLOCKPPC_PTRACE_GETHWDBGINFOPPC_PTRACE_SETHWDEBUGPPC_PTRACE_DELHWDEBUGPPC_DEBUG_FEATURE_INSN_BP_RANGEPPC_DEBUG_FEATURE_INSN_BP_MASKPPC_DEBUG_FEATURE_DATA_BP_RANGEPPC_DEBUG_FEATURE_DATA_BP_MASKPPC_DEBUG_FEATURE_DATA_BP_DAWRPPC_DEBUG_FEATURE_DATA_BP_ARCH_31PPC_BREAKPOINT_TRIGGER_EXECUTEPPC_BREAKPOINT_TRIGGER_READPPC_BREAKPOINT_TRIGGER_WRITEPPC_BREAKPOINT_TRIGGER_RWPPC_BREAKPOINT_MODE_EXACTPPC_BREAKPOINT_MODE_RANGE_INCLUSIVEPPC_BREAKPOINT_MODE_RANGE_EXCLUSIVEPPC_BREAKPOINT_MODE_MASKPPC_BREAKPOINT_CONDITION_MODEPPC_BREAKPOINT_CONDITION_NONEPPC_BREAKPOINT_CONDITION_ANDPPC_BREAKPOINT_CONDITION_EXACTPPC_BREAKPOINT_CONDITION_ORPPC_BREAKPOINT_CONDITION_AND_ORPPC_BREAKPOINT_CONDITION_BE_ALLPPC_BREAKPOINT_CONDITION_BE_SHIFTsoftePT_SOFTEPT_VR0PT_VSCRPT_VRSAVEPT_VSR0PT_VSR31__NR_riscv_hwprobe__NR_riscv_flush_icacheragpt0s0s1a4a5a6a7s2s3s4s5s6s7s9s10s11t3t4t5t6__riscv_f_ext_state__riscv_d_ext_state__riscv_q_ext_state__riscv_ctx_hdr__padding129usize__riscv_extra_ext_headervtypevcsrvlenbdatap__riscv_v_ext_statevreg__riscv_v_regset_stateRISCV_MAX_VLENB__riscv_fp_stateaddr_tsaddr_t__kernel_sigset_t__vector128__bindgen_ty_1__vector128__bindgen_ty_1__bindgen_ty_1__NR_s390_runtime_instr__NR_s390_pci_mmio_write__NR_s390_pci_mmio_read__NR_s390_guarded_storage__NR_s390_sthyifreg_t__bindgen_ty_1fpcfprsfreg_ts390_fp_regspsw_tpswgprsacrsorig_gpr2s390_regsper_cr_wordsstarting_addrending_addrper_cr_bitsperc_atmidaccess_idper_lowcore_words_bitfield_align_2_bitfield_2per_lowcore_bitscontrol_regsper_struct__bindgen_ty_1lowcoreper_struct__bindgen_ty_2per_structkernel_addrprocess_addrptrace_arealowaddrhiaddrprotptprot_flagsptprot_areafp_regsper_infoieee_instruction_pointerPT_PSWMASKPT_PSWADDRPT_GPR0PT_GPR1PT_GPR2PT_GPR3PT_GPR4PT_GPR5PT_GPR6PT_GPR7PT_GPR8PT_GPR9PT_GPR10PT_GPR11PT_GPR12PT_GPR13PT_GPR14PT_GPR15PT_ACR0PT_ACR1PT_ACR2PT_ACR3PT_ACR4PT_ACR5PT_ACR6PT_ACR7PT_ACR8PT_ACR9PT_ACR10PT_ACR11PT_ACR12PT_ACR13PT_ACR14PT_ACR15PT_ORIGGPR2PT_FPCPT_FPR1PT_FPR2PT_FPR3PT_FPR4PT_FPR5PT_FPR6PT_FPR7PT_FPR8PT_FPR9PT_FPR10PT_FPR11PT_FPR12PT_FPR13PT_FPR14PT_FPR15PT_CR_9PT_CR_10PT_CR_11PT_IEEE_IPPT_LASTOFFPT_ENDREGSGPR_SIZECR_SIZESTACK_FRAME_OVERHEADNUM_GPRSNUM_FPRSNUM_CRSNUM_ACRSNUM_CR_WORDSFPR_SIZEFPC_SIZEFPC_PAD_SIZEACR_SIZEFPC_EXCEPTION_MASKFPC_FLAGS_MASKFPC_DXC_MASKFPC_RM_MASKPER_EM_MASKPTRACE_PEEKUSR_AREAPTRACE_POKEUSR_AREAPTRACE_PEEKTEXT_AREAPTRACE_PEEKDATA_AREAPTRACE_POKETEXT_AREAPTRACE_POKEDATA_AREAPTRACE_GET_LAST_BREAKPTRACE_PEEK_SYSTEM_CALLPTRACE_POKE_SYSTEM_CALLPTRACE_ENABLE_TEPTRACE_DISABLE_TEPTRACE_TE_ABORT_RANDPTRACE_PROTS390_SYSCALL_SIZEptprot_set_access_watchpointptprot_set_write_watchpointptprot_disable_watchpointuifpem_branchingset_em_branchingem_branching_rawset_em_branching_rawem_instruction_fetchset_em_instruction_fetchem_instruction_fetch_rawset_em_instruction_fetch_rawem_storage_alterationset_em_storage_alterationem_storage_alteration_rawset_em_storage_alteration_rawem_gpr_alt_unusedset_em_gpr_alt_unusedem_gpr_alt_unused_rawset_em_gpr_alt_unused_rawem_store_real_addressset_em_store_real_addressem_store_real_address_rawset_em_store_real_address_rawbranch_addr_ctlset_branch_addr_ctlbranch_addr_ctl_rawset_branch_addr_ctl_rawstorage_alt_space_ctlset_storage_alt_space_ctlstorage_alt_space_ctl_rawset_storage_alt_space_ctl_rawperc_branchingset_perc_branchingperc_branching_rawset_perc_branching_rawperc_instruction_fetchset_perc_instruction_fetchperc_instruction_fetch_rawset_perc_instruction_fetch_rawperc_storage_alterationset_perc_storage_alterationperc_storage_alteration_rawset_perc_storage_alteration_rawperc_gpr_alt_unusedset_perc_gpr_alt_unusedperc_gpr_alt_unused_rawset_perc_gpr_alt_unused_rawperc_store_real_addressset_perc_store_real_addressperc_store_real_address_rawset_perc_store_real_address_rawatmid_psw_bit_31set_atmid_psw_bit_31atmid_psw_bit_31_rawset_atmid_psw_bit_31_rawatmid_validity_bitset_atmid_validity_bitatmid_validity_bit_rawset_atmid_validity_bit_rawatmid_psw_bit_32set_atmid_psw_bit_32atmid_psw_bit_32_rawset_atmid_psw_bit_32_rawatmid_psw_bit_5set_atmid_psw_bit_5atmid_psw_bit_5_rawset_atmid_psw_bit_5_rawatmid_psw_bit_16set_atmid_psw_bit_16atmid_psw_bit_16_rawset_atmid_psw_bit_16_rawatmid_psw_bit_17set_atmid_psw_bit_17atmid_psw_bit_17_rawset_atmid_psw_bit_17_rawsiset_sisi_rawset_si_rawset_access_idaccess_id_rawset_access_id_rawnew_bitfield_2single_stepset_single_stepsingle_step_rawset_single_step_rawinstruction_fetchset_instruction_fetchinstruction_fetch_rawset_instruction_fetch_rawAT_ADI_BLKSZAT_ADI_NBITSAT_ADI_UEONADI_IOC_XSIZEMASKERREMOTEthe_stackcur_statussigstackPROT_ADI_MAP_NEWSUBSIG_STACKSUBSIG_ILLINSTSUBSIG_PRIVINSTSUBSIG_TAGSUBSIG_FPDISABLEDSUBSIG_FPERRORSUBSIG_FPINTOVFLSUBSIG_FPSTSIGSUBSIG_IDIVZEROSUBSIG_FPINEXACTSUBSIG_FPDIVZEROSUBSIG_FPUNFLOWSUBSIG_FPOPERRORSUBSIG_FPOVFLOWSUBSIG_BUSTIMEOUTSUBSIG_ALIGNMENTSUBSIG_MISCERRORSUBSIG_NOMAPPINGSUBSIG_PROTECTIONSUBSIG_SEGERROR__OLD_NSIG__NEW_NSIG_SV_SSTACK_SV_INTR_SV_RESET_SV_IGNCHILDSI_NOINFOPAGEOUTWRAPDEFECHO__NR_execv__NR_perfctr__NR_getpagesize__NR_sched_set_affinity__NR_sched_get_affinity__NR_getdomainname__NR_kern_featuresKERN_FEATURE_MIXED_MODE_STACKASI_NULL1ASI_NULL2ASI_CONTROLASI_SEGMAPASI_PTEASI_HWFLUSHSEGASI_HWFLUSHPAGEASI_REGMAPASI_HWFLUSHCONTEXTASI_USERTXTASI_KERNELTXTASI_USERDATAASI_KERNELDATAASI_FLUSHSEGASI_FLUSHPGASI_FLUSHCTXASI_M_RES00ASI_M_UNA01ASI_M_MXCCASI_M_FLUSH_PROBEASI_M_MMUREGSASI_M_TLBDIAGASI_M_DIAGSASI_M_IODIAGASI_M_USERTXTASI_M_KERNELTXTASI_M_USERDATAASI_M_KERNELDATAASI_M_TXTC_TAGASI_M_TXTC_DATAASI_M_DATAC_TAGASI_M_DATAC_DATAASI_M_FLUSH_PAGEASI_M_FLUSH_SEGASI_M_FLUSH_REGIONASI_M_FLUSH_CTXASI_M_FLUSH_USERASI_M_BCOPYASI_M_IFLUSH_PAGEASI_M_IFLUSH_SEGASI_M_IFLUSH_REGIONASI_M_IFLUSH_CTXASI_M_IFLUSH_USERASI_M_BFILLASI_M_BYPASSASI_M_FBMEMASI_M_VMEUSASI_M_VMEPSASI_M_VMEUTASI_M_VMEPTASI_M_SBUSASI_M_CTLASI_M_FLUSH_IWHOLEASI_M_IC_FLCLEARASI_M_DC_FLCLEARASI_M_DCDRASI_M_VIKING_TMP1ASI_M_ACTIONASI_LEON_NOCACHEASI_LEON_DCACHE_MISSASI_LEON_CACHEREGSASI_LEON_IFLUSHASI_LEON_DFLUSHASI_LEON_MMUFLUSHASI_LEON_MMUREGSASI_LEON_BYPASSASI_LEON_FLUSH_PAGEASI_NASI_NLASI_AIUPASI_AIUSASI_AIUPLASI_AIUSLASI_PASI_SASI_PNFASI_SNFASI_PLASI_SLASI_PNFLASI_SNFLASI_MCD_PRIV_PRIMARYASI_MCD_REALASI_PHYS_USE_ECASI_PHYS_BYPASS_EC_EASI_BLK_AIUP_4VASI_BLK_AIUS_4VASI_PHYS_USE_EC_LASI_PHYS_BYPASS_EC_E_LASI_BLK_AIUP_L_4VASI_BLK_AIUS_L_4VASI_SCRATCHPADASI_MMUASI_BLK_INIT_QUAD_LDD_AIUSASI_NUCLEUS_QUAD_LDDASI_QUEUEASI_QUAD_LDD_PHYS_4VASI_NUCLEUS_QUAD_LDD_LASI_QUAD_LDD_PHYS_L_4VASI_PCACHE_DATA_STATUSASI_PCACHE_DATAASI_PCACHE_TAGASI_PCACHE_SNOOP_TAGASI_QUAD_LDD_PHYSASI_WCACHE_VALID_BITSASI_WCACHE_DATAASI_WCACHE_TAGASI_WCACHE_SNOOP_TAGASI_QUAD_LDD_PHYS_LASI_SRAM_FAST_INITASI_CORE_AVAILABLEASI_CORE_ENABLE_STATASI_CORE_ENABLEASI_XIR_STEERINGASI_CORE_RUNNING_RWASI_CORE_RUNNING_W1SASI_CORE_RUNNING_W1CASI_CORE_RUNNING_STATASI_CMT_ERROR_STEERINGASI_DCACHE_INVALIDATEASI_DCACHE_UTAGASI_DCACHE_SNOOP_TAGASI_LSU_CONTROLASI_DCU_CONTROL_REGASI_DCACHE_DATAASI_DCACHE_TAGASI_INTR_DISPATCH_STATASI_INTR_RECEIVEASI_UPA_CONFIGASI_JBUS_CONFIGASI_SAFARI_CONFIGASI_SAFARI_ADDRESSASI_ESTATE_ERROR_ENASI_AFSRASI_AFARASI_EC_TAG_DATAASI_IMMUASI_IMMU_TSB_8KB_PTRASI_IMMU_TSB_64KB_PTRASI_ITLB_DATA_INASI_ITLB_DATA_ACCESSASI_ITLB_TAG_READASI_IMMU_DEMAPASI_DMMUASI_DMMU_TSB_8KB_PTRASI_DMMU_TSB_64KB_PTRASI_DMMU_TSB_DIRECT_PTRASI_DTLB_DATA_INASI_DTLB_DATA_ACCESSASI_DTLB_TAG_READASI_DMMU_DEMAPASI_IIU_INST_TRAPASI_INTR_IDASI_CORE_IDASI_CESR_IDASI_IC_INSTRASI_IC_TAGASI_IC_STAGASI_IC_PRE_DECODEASI_IC_NEXT_FIELDASI_BRPRED_ARRAYASI_BLK_AIUPASI_BLK_AIUSASI_MCU_CTRL_REGASI_EC_DATAASI_EC_CTRLASI_EC_WASI_UDB_ERROR_WASI_UDB_CONTROL_WASI_INTR_WASI_INTR_DATAN_WASI_INTR_DISPATCH_WASI_BLK_AIUPLASI_BLK_AIUSLASI_EC_RASI_UDBH_ERROR_RASI_UDBL_ERROR_RASI_UDBH_CONTROL_RASI_UDBL_CONTROL_RASI_INTR_RASI_INTR_DATAN_RASI_MCD_PRIMARYASI_MCD_ST_BLKINIT_PRIMARYASI_PICASI_PST8_PASI_PST8_SASI_PST16_PASI_PST16_SASI_PST32_PASI_PST32_SASI_PST8_PLASI_PST8_SLASI_PST16_PLASI_PST16_SLASI_PST32_PLASI_PST32_SLASI_FL8_PASI_FL8_SASI_FL16_PASI_FL16_SASI_FL8_PLASI_FL8_SLASI_FL16_PLASI_FL16_SLASI_BLK_COMMIT_PASI_BLK_COMMIT_SASI_BLK_INIT_QUAD_LDD_PASI_BLK_INIT_QUAD_LDD_SASI_BLK_PASI_BLK_SASI_ST_BLKINIT_MRU_PASI_ST_BLKINIT_MRU_SASI_BLK_PLASI_BLK_SLASI_ST_BLKINIT_MRU_PLASI_ST_BLKINIT_MRU_SLpsrnpcu_regsinsreg_window32sparc_stackfcallers_pcstructptrxargsxxargsPSR_CWPPSR_ETPSR_PSPSR_SPSR_PILPSR_EFPSR_ECPSR_SYSCALLPSR_LEPSR_ICCPSR_CPSR_VPSR_ZPSR_NPSR_VERSPSR_IMPLPSR_VERS_SHIFTPSR_IMPL_SHIFTPSR_VERS_SHIFTED_MASKPSR_IMPL_SHIFTED_MASKPSR_IMPL_TIPSR_IMPL_LEONUREG_G0UREG_G1UREG_G2UREG_G3UREG_G4UREG_G5UREG_G6UREG_G7UREG_I0UREG_I1UREG_I2UREG_I3UREG_I4UREG_I5UREG_I6UREG_I7UREG_FPUREG_RETPCPT_V9_G0PT_V9_G1PT_V9_G2PT_V9_G3PT_V9_G4PT_V9_G5PT_V9_G6PT_V9_G7PT_V9_I0PT_V9_I1PT_V9_I2PT_V9_I3PT_V9_I4PT_V9_I5PT_V9_I6PT_V9_FPPT_V9_I7PT_V9_TSTATEPT_V9_TPCPT_V9_TNPCPT_V9_YPT_V9_MAGICPT_TSTATEPT_TPCPT_TNPCPT_PSRPT_PCPT_NPCPT_YPT_G0PT_WIMPT_G1PT_G2PT_G3PT_G4PT_G5PT_G6PT_G7PT_I0PT_I1PT_I2PT_I3PT_I4PT_I5PT_I6PT_FPPT_I7RW_V9_L0RW_V9_L1RW_V9_L2RW_V9_L3RW_V9_L4RW_V9_L5RW_V9_L6RW_V9_L7RW_V9_I0RW_V9_I1RW_V9_I2RW_V9_I3RW_V9_I4RW_V9_I5RW_V9_I6RW_V9_I7RW_L0RW_L1RW_L2RW_L3RW_L4RW_L5RW_L6RW_L7RW_I0RW_I1RW_I2RW_I3RW_I4RW_I5RW_I6RW_I7SF_V9_L0SF_V9_L1SF_V9_L2SF_V9_L3SF_V9_L4SF_V9_L5SF_V9_L6SF_V9_L7SF_V9_I0SF_V9_I1SF_V9_I2SF_V9_I3SF_V9_I4SF_V9_I5SF_V9_FPSF_V9_PCSF_V9_RETPSF_V9_XARG0SF_V9_XARG1SF_V9_XARG2SF_V9_XARG3SF_V9_XARG4SF_V9_XARG5SF_V9_XXARGSF_L0SF_L1SF_L2SF_L3SF_L4SF_L5SF_L6SF_L7SF_I0SF_I1SF_I2SF_I3SF_I4SF_I5SF_FPSF_PCSF_RETPSF_XARG0SF_XARG1SF_XARG2SF_XARG3SF_XARG4SF_XARG5SF_XXARGPTRACE_SPARC_DETACHPTRACE_READDATAPTRACE_WRITEDATAPTRACE_READTEXTPTRACE_WRITETEXTPTRACE_GETFPAREGSPTRACE_SETFPAREGSPTRACE_GETFPREGS64PTRACE_SETFPREGS64__NR_memory_ordering__NR_utrap_installtstatetpctnpcpt_regs32reg_windowsparc_stackf32sparc_trapfPT_REGS_MAGICapm_event_tapm_eventinfo_tsetup_datasetup_indirectboot_e820_entryjailhouse_setup_data__bindgen_ty_1jailhouse_setup_data__bindgen_ty_2jailhouse_setup_data__bindgen_ty_3jailhouse_setup_datacompatible_versionpm_timer_addresspci_mmconfig_basetsc_khzapic_khzstandard_ioapiccpu_idsima_setup_datafdt_addrfdt_sizescratch_addrscratch_sizekho_dataorig_xorig_yext_mem_korig_video_pageorig_video_modeorig_video_colsorig_video_ega_bxorig_video_linesorig_video_isVGAorig_video_pointslfb_widthlfb_heightlfb_depthlfb_baselfb_sizecl_magiccl_offsetlfb_linelengthred_sizered_posgreen_sizegreen_posblue_sizeblue_posrsvd_sizersvd_posvesapm_segvesapm_offpagesvesa_attributesext_lfb_base_reservedscreen_infocsegcseg_16dsegcseg_lencseg_16_lendseg_lenapm_bios_infoinfo_flagsnum_default_cylindersnum_default_headssectors_per_tracknumber_of_sectorsbytes_per_sectordpte_ptrdevice_path_info_lengthhost_bus_typeinterface_typeinterface_pathedd_device_params__bindgen_ty_1edd_device_params__bindgen_ty_2edd_device_paramsedd_device_params__bindgen_ty_1__bindgen_ty_1edd_device_params__bindgen_ty_1__bindgen_ty_2edd_device_params__bindgen_ty_1__bindgen_ty_3edd_device_params__bindgen_ty_1__bindgen_ty_4edd_device_params__bindgen_ty_1__bindgen_ty_5edd_device_params__bindgen_ty_1__bindgen_ty_6edd_device_params__bindgen_ty_2__bindgen_ty_1lunedd_device_params__bindgen_ty_2__bindgen_ty_2edd_device_params__bindgen_ty_2__bindgen_ty_3serial_numberedd_device_params__bindgen_ty_2__bindgen_ty_4euiedd_device_params__bindgen_ty_2__bindgen_ty_5wwidedd_device_params__bindgen_ty_2__bindgen_ty_6identity_tagedd_device_params__bindgen_ty_2__bindgen_ty_7array_numberedd_device_params__bindgen_ty_2__bindgen_ty_8edd_device_params__bindgen_ty_2__bindgen_ty_9edd_device_params__bindgen_ty_2__bindgen_ty_10interface_supportlegacy_max_cylinderlegacy_max_headlegacy_sectors_per_trackedd_infombr_signaturembr_signature_nredd_info_nreddperf_levelist_infoedid_infosetup_sectsroot_flagssyssizeram_sizevid_moderoot_devboot_flagjumprealmode_swtchstart_sys_segtype_of_loaderloadflagssetup_move_sizecode32_startramdisk_imageramdisk_sizebootsect_kludgeheap_end_ptrext_loader_verext_loader_typecmd_line_ptrinitrd_addr_maxkernel_alignmentrelocatable_kernelmin_alignmentxloadflagscmdline_sizehardware_subarchhardware_subarch_datapayload_lengthpref_addressinit_sizehandover_offsetkernel_info_offsetsetup_headersys_desc_tableofw_magicofw_versioncif_handlerirq_desc_tableolpc_ofw_headerefi_loader_signatureefi_systabefi_memdesc_sizeefi_memdesc_versionefi_memmapefi_memmap_sizeefi_systab_hiefi_memmap_hiefi_infotboot_addracpi_rsdp_addr_pad3hd0_infohd1_infoext_ramdisk_imageext_ramdisk_sizeext_cmd_line_ptr_pad4112usizecc_blob_addressalt_mem_kscratche820_entrieseddbuf_entriesedd_mbr_sig_buf_entrieskbd_statussecure_boot_pad5sentinel_pad6_pad736usizeedd_mbr_sig_buffere820_table_pad848usizeeddbuf_pad9276usizeboot_paramsSETUP_NONESETUP_E820_EXTSETUP_DTBSETUP_PCISETUP_EFISETUP_APPLE_PROPERTIESSETUP_JAILHOUSESETUP_CC_BLOBSETUP_IMASETUP_RNG_SEEDSETUP_KEXEC_KHOSETUP_ENUM_MAXSETUP_INDIRECTSETUP_TYPE_MAXRAMDISK_IMAGE_START_MASKRAMDISK_PROMPT_FLAGRAMDISK_LOAD_FLAGLOADED_HIGHKASLR_FLAGQUIET_FLAGKEEP_SEGMENTSCAN_USE_HEAPXLF_KERNEL_64XLF_CAN_BE_LOADED_ABOVE_4GXLF_EFI_HANDOVER_32XLF_EFI_HANDOVER_64XLF_EFI_KEXECXLF_5LEVELXLF_5LEVEL_ENABLEDXLF_MEM_ENCRYPTIONVIDEO_TYPE_MDAVIDEO_TYPE_CGAVIDEO_TYPE_EGAMVIDEO_TYPE_EGACVIDEO_TYPE_VGACVIDEO_TYPE_VLFBVIDEO_TYPE_PICA_S3VIDEO_TYPE_MIPS_G364VIDEO_TYPE_SGIVIDEO_TYPE_TGACVIDEO_TYPE_SUNVIDEO_TYPE_SUNPCIVIDEO_TYPE_PMACVIDEO_TYPE_EFIVIDEO_FLAGS_NOCURSORVIDEO_CAPABILITY_SKIP_QUIRKSVIDEO_CAPABILITY_64BIT_BASEAPM_STATE_READYAPM_STATE_STANDBYAPM_STATE_SUSPENDAPM_STATE_OFFAPM_STATE_BUSYAPM_STATE_REJECTAPM_STATE_OEM_SYSAPM_STATE_OEM_DEVAPM_STATE_DISABLEAPM_STATE_ENABLEAPM_STATE_DISENGAGEAPM_STATE_ENGAGEAPM_SYS_STANDBYAPM_SYS_SUSPENDAPM_NORMAL_RESUMEAPM_CRITICAL_RESUMEAPM_LOW_BATTERYAPM_POWER_STATUS_CHANGEAPM_UPDATE_TIMEAPM_CRITICAL_SUSPENDAPM_USER_STANDBYAPM_USER_SUSPENDAPM_STANDBY_RESUMEAPM_CAPABILITY_CHANGEAPM_USER_HIBERNATIONAPM_HIBERNATION_RESUMEAPM_SUCCESSAPM_DISABLEDAPM_CONNECTEDAPM_NOT_CONNECTEDAPM_16_CONNECTEDAPM_16_UNSUPPORTEDAPM_32_CONNECTEDAPM_32_UNSUPPORTEDAPM_BAD_DEVICEAPM_BAD_PARAMAPM_NOT_ENGAGEDAPM_BAD_FUNCTIONAPM_RESUME_DISABLEDAPM_NO_ERRORAPM_BAD_STATEAPM_NO_EVENTSAPM_NOT_PRESENTAPM_DEVICE_BIOSAPM_DEVICE_ALLAPM_DEVICE_DISPLAYAPM_DEVICE_STORAGEAPM_DEVICE_PARALLELAPM_DEVICE_SERIALAPM_DEVICE_NETWORKAPM_DEVICE_PCMCIAAPM_DEVICE_BATTERYAPM_DEVICE_OEMAPM_DEVICE_OLD_ALLAPM_DEVICE_CLASSAPM_DEVICE_MASKAPM_MAX_BATTERIESAPM_CAP_GLOBAL_STANDBYAPM_CAP_GLOBAL_SUSPENDAPM_CAP_RESUME_STANDBY_TIMERAPM_CAP_RESUME_SUSPEND_TIMERAPM_CAP_RESUME_STANDBY_RINGAPM_CAP_RESUME_SUSPEND_RINGAPM_CAP_RESUME_STANDBY_PCMCIAAPM_CAP_RESUME_SUSPEND_PCMCIAEDDNREDDBUFEDDMAXNREDDEXTSIZEEDDPARMSIZECHECKEXTENSIONSPRESENTGETDEVICEPARAMETERSLEGACYGETDEVICEPARAMETERSEDDMAGIC1EDDMAGIC2READ_SECTORSEDD_MBR_SIG_OFFSETEDD_MBR_SIG_BUFEDD_MBR_SIG_MAXEDD_MBR_SIG_NR_BUFEDD_EXT_FIXED_DISK_ACCESSEDD_EXT_DEVICE_LOCKING_AND_EJECTINGEDD_EXT_ENHANCED_DISK_DRIVE_SUPPORTEDD_EXT_64BIT_EXTENSIONSEDD_INFO_DMA_BOUNDARY_ERROR_TRANSPARENTEDD_INFO_GEOMETRY_VALIDEDD_INFO_REMOVABLEEDD_INFO_WRITE_VERIFYEDD_INFO_MEDIA_CHANGE_NOTIFICATIONEDD_INFO_LOCKABLEEDD_INFO_NO_MEDIA_PRESENTEDD_INFO_USE_INT13_FN50E820_MAX_ENTRIES_ZEROPAGEJAILHOUSE_SETUP_REQUIRED_VERSIONx86_hardware_subarchX86_SUBARCH_PCX86_SUBARCH_LGUESTX86_SUBARCH_XENX86_SUBARCH_INTEL_MIDX86_SUBARCH_CE4100X86_NR_SUBARCHSpciibndxprshtptataatapiscsiusbi1394fibrei2oraidsata__kernel_si_clock_tMAP_ABOVE4G__NR_arch_prctl__NR_security__NR_uretprobeARCH_SET_FSlmset_lmlm_rawset_lm_rawFRAME_SIZEPTRACE_ARCH_PRCTLX86_EFLAGS_CF_BITX86_EFLAGS_FIXED_BITX86_EFLAGS_PF_BITX86_EFLAGS_AF_BITX86_EFLAGS_ZF_BITX86_EFLAGS_SF_BITX86_EFLAGS_TF_BITX86_EFLAGS_IF_BITX86_EFLAGS_DF_BITX86_EFLAGS_OF_BITX86_EFLAGS_IOPL_BITX86_EFLAGS_NT_BITX86_EFLAGS_RF_BITX86_EFLAGS_VM_BITX86_EFLAGS_AC_BITX86_EFLAGS_VIF_BITX86_EFLAGS_VIP_BITX86_EFLAGS_ID_BITX86_CR0_PE_BITX86_CR0_MP_BITX86_CR0_EM_BITX86_CR0_TS_BITX86_CR0_ET_BITX86_CR0_NE_BITX86_CR0_WP_BITX86_CR0_AM_BITX86_CR0_NW_BITX86_CR0_CD_BITX86_CR0_PG_BITX86_CR3_PWT_BITX86_CR3_PCD_BITX86_CR3_PCID_BITSX86_CR3_LAM_U57_BITX86_CR3_LAM_U48_BITX86_CR3_PCID_NOFLUSH_BITX86_CR4_VME_BITX86_CR4_PVI_BITX86_CR4_TSD_BITX86_CR4_DE_BITX86_CR4_PSE_BITX86_CR4_PAE_BITX86_CR4_MCE_BITX86_CR4_PGE_BITX86_CR4_PCE_BITX86_CR4_OSFXSR_BITX86_CR4_OSXMMEXCPT_BITX86_CR4_UMIP_BITX86_CR4_LA57_BITX86_CR4_VMXE_BITX86_CR4_SMXE_BITX86_CR4_FSGSBASE_BITX86_CR4_PCIDE_BITX86_CR4_OSXSAVE_BITX86_CR4_SMEP_BITX86_CR4_SMAP_BITX86_CR4_PKE_BITX86_CR4_CET_BITX86_CR4_LAM_SUP_BITX86_CR4_FRED_BITCX86_PCR0CX86_GCRCX86_CCR0CX86_CCR1CX86_CCR2CX86_CCR3CX86_CCR4CX86_CCR5CX86_CCR6CX86_CCR7CX86_PCR1CX86_DIR0CX86_DIR1CX86_ARR_BASECX86_RCR_BASE__NR_vm86old__NR_get_thread_areaebxecxedxesiediebpeaxxdsxesxfsxgsorig_eaxeipxcsespX86_CR4_FRED__NR_epoll_ctl_old__NR_epoll_wait_old/* automatically generated by rust-bindgen 0.59.2 */__BITS_PER_LONGO_TMPFILE_MASK__UAPI_DEF_IF_IFCONF__UAPI_DEF_IF_IFMAP__UAPI_DEF_IF_IFNAMSIZ__UAPI_DEF_IF_IFREQ__UAPI_DEF_IF_NET_DEVICE_FLAGS__UAPI_DEF_IF_NET_DEVICE_FLAGS_LOWER_UP_DORMANT_ECHO__UAPI_DEF_IN_ADDR__UAPI_DEF_IN_IPPROTO__UAPI_DEF_IN_PKTINFO__UAPI_DEF_IP_MREQ__UAPI_DEF_SOCKADDR_IN__UAPI_DEF_IN_CLASS__UAPI_DEF_IN6_ADDR__UAPI_DEF_IN6_ADDR_ALT__UAPI_DEF_SOCKADDR_IN6__UAPI_DEF_IPV6_MREQ__UAPI_DEF_IPPROTO_V6__UAPI_DEF_IPV6_OPTIONS__UAPI_DEF_IN6_PKTINFO__UAPI_DEF_IP6_MTUINFO__UAPI_DEF_SOCKADDR_IPX__UAPI_DEF_IPX_ROUTE_DEFINITION__UAPI_DEF_IPX_INTERFACE_DEFINITION__UAPI_DEF_IPX_CONFIG_DATA__UAPI_DEF_IPX_ROUTE_DEF__UAPI_DEF_XATTR__NR3264_fcntl__NR3264_statfs__NR3264_fstatfs__NR3264_truncate__NR3264_ftruncate__NR3264_lseek__NR3264_sendfile__NR3264_fstatat__NR3264_fstat__NR3264_mmap__NR3264_fadvise64__NR_arch_specific_syscall__NR_syscalls21usize22usize26usize20usize24usize25usizeio_uring_notification_slotnr_slotsio_uring_notification_registerKVM_SET_BOOT_CPU_IDKVM_SET_MP_STATEKVM_GET_MP_STATEKVM_GET_API_VERSIONKVM_S390_GET_SKEYSKVM_SET_ONE_REGKVM_IRQ_LINE_STATUSKVM_SET_USER_MEMORY_REGIONKVM_S390_INTERRUPTKVM_TPR_ACCESS_REPORTINGKVM_GET_FPUKVM_ASSIGN_SET_MSIX_ENTRYKVM_MEMORY_ENCRYPT_REG_REGIONKVM_S390_UCAS_MAPKVM_ASSIGN_SET_INTX_MASKKVM_MEMORY_ENCRYPT_OPKVM_CREATE_PIT2KVM_S390_VCPU_FAULTKVM_REGISTER_COALESCED_MMIOKVM_SET_VAPIC_ADDRKVM_CREATE_DEVICEKVM_GET_IRQCHIPKVM_TRANSLATEKVM_S390_SET_INITIAL_PSWKVM_X86_SETUP_MCEKVM_DEASSIGN_PCI_DEVICEKVM_XEN_HVM_SET_ATTRKVM_GET_CLOCKKVM_SET_FPUKVM_KVMCLOCK_CTRLKVM_PPC_GET_PVINFOKVM_X86_GET_MCE_CAP_SUPPORTEDKVM_S390_GET_IRQ_STATEKVM_GET_DEVICE_ATTRKVM_S390_INITIAL_RESETKVM_SET_REGSKVM_GET_TSC_KHZKVM_CHECK_EXTENSIONKVM_PPC_RESIZE_HPT_COMMITKVM_GET_DIRTY_LOGKVM_S390_SET_IRQ_STATEKVM_S390_NORMAL_RESETKVM_SET_SIGNAL_MASKKVM_XEN_VCPU_SET_ATTRKVM_SET_GSI_ROUTINGKVM_CREATE_VCPUKVM_S390_UCAS_UNMAPKVM_S390_STORE_STATUSKVM_UNREGISTER_COALESCED_MMIOKVM_ASSIGN_DEV_IRQKVM_S390_PV_COMMANDKVM_S390_ENABLE_SIEKVM_CLEAR_DIRTY_LOGKVM_GET_ONE_REGKVM_ARM_SET_DEVICE_ADDRKVM_DIRTY_TLBKVM_NMIKVM_HYPERV_EVENTFDKVM_S390_MEM_OPKVM_PPC_SVM_OFFKVM_PPC_RESIZE_HPT_PREPAREKVM_INTERRUPTKVM_XEN_HVM_GET_ATTRKVM_GET_SREGSKVM_SET_IDENTITY_MAP_ADDRKVM_GET_REGSKVM_S390_GET_CMMA_BITSKVM_CREATE_IRQCHIPKVM_ASSIGN_PCI_DEVICEKVM_SET_NR_MMU_PAGESKVM_IOEVENTFDKVM_RUNKVM_S390_SET_SKEYSKVM_SET_DEVICE_ATTRKVM_DEASSIGN_DEV_IRQKVM_SMIKVM_SET_TSS_ADDRKVM_GET_NR_MMU_PAGESKVM_XEN_VCPU_GET_ATTRKVM_REINJECT_CONTROLKVM_HAS_DEVICE_ATTRKVM_IRQFDKVM_S390_SET_CMMA_BITSKVM_SET_IRQCHIPKVM_SIGNAL_MSIKVM_GET_VCPU_MMAP_SIZEKVM_CREATE_VMKVM_S390_CLEAR_RESETKVM_RESET_DIRTY_RINGSKVM_ASSIGN_SET_MSIX_NRKVM_CREATE_PITKVM_SET_GUEST_DEBUGKVM_GET_REG_LISTKVM_ARM_VCPU_FINALIZEKVM_SET_CLOCKKVM_PPC_ALLOCATE_HTABKVM_PPC_GET_SMMU_INFOKVM_SET_TSC_KHZKVM_S390_IRQKVM_ENABLE_CAPKVM_IRQ_LINEKVM_SET_SREGSKVM_MEMORY_ENCRYPT_UNREG_REGIONKVM_GET_STATS_FD// The signedness of `char` is platform-specific, however a consequence// of it being platform-specific is that any code which depends on the// signedness of `char` is already non-portable. So we can just use `u8`// here and no portable code will notice.// TODO: In Rust 1.63 we can make this a `const fn`.// TODO: In Rust 1.56 we can make this a `const fn`.251658240__new_sigset_t__new_sigaction/* automatically generated by rust-bindgen 0.66.1 */"x86_64/system.rs"__spare150usize// ELFDATA2LSB// EM_ARM// EM_386// EM_PPC64// EM_X86_64// EM_AARCH64// `R_X86_64_RELATIVE`// `R_386_RELATIVE`// `R_AARCH64_RELATIVE`// `R_RISCV_RELATIVE`GuardSend/// Marker type which indicates that the Guard type for a lock is `Send`./// Marker type which indicates that the Guard type for a lock is not `Send`.remutex// Copyright 2018 Amanieu d'Antras//! This library provides type-safe and fully-featured [`Mutex`] and [`RwLock`]//! types which wrap a simple raw mutex or rwlock type. This has several//! benefits: not only does it eliminate a large portion of the work in//! implementing custom lock types, it also allows users to write code which is//! generic with regards to different lock implementations.//! Basic usage of this crate is very straightforward://! 1. Create a raw lock type. This should only contain the lock state, not any//!    data protected by the lock.//! 2. Implement the `RawMutex` trait for your custom lock type.//! 3. Export your mutex as a type alias for `lock_api::Mutex`, and//!    your mutex guard as a type alias for `lock_api::MutexGuard`.//!    See the [example](#example) below for details.//! This process is similar for [`RwLock`]s, except that two guards need to be//! exported instead of one. (Or 3 guards if your type supports upgradable read//! locks, see [extension traits](#extension-traits) below for details)//! use lock_api::{RawMutex, Mutex, GuardSend};//! // 1. Define our raw lock type//! pub struct RawSpinlock(AtomicBool);//! // 2. Implement RawMutex for this type//! unsafe impl RawMutex for RawSpinlock {//!     const INIT: RawSpinlock = RawSpinlock(AtomicBool::new(false));//!     // A spinlock guard can be sent to another thread and unlocked there//!     type GuardMarker = GuardSend;//!     fn lock(&self) {//!         // Note: This isn't the best way of implementing a spinlock, but it//!         // suffices for the sake of this example.//!         while !self.try_lock() {}//!     fn try_lock(&self) -> bool {//!             .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)//!             .is_ok()//!     unsafe fn unlock(&self) {//!         self.0.store(false, Ordering::Release);//! // 3. Export the wrappers. This are the types that your users will actually use.//! pub type Spinlock<T> = lock_api::Mutex<RawSpinlock, T>;//! pub type SpinlockGuard<'a, T> = lock_api::MutexGuard<'a, RawSpinlock, T>;//! # Extension traits//! In addition to basic locking & unlocking functionality, you have the option//! of exposing additional functionality in your lock types by implementing//! additional traits for it. Examples of extension features include://! - Fair unlocking (`RawMutexFair`, `RawRwLockFair`)//! - Lock timeouts (`RawMutexTimed`, `RawRwLockTimed`)//! - Downgradable write locks (`RawRwLockDowngradable`)//! - Recursive read locks (`RawRwLockRecursive`)//! - Upgradable read locks (`RawRwLockUpgrade`)//! The `Mutex` and `RwLock` wrappers will automatically expose this additional//! functionality if the raw lock type implements these extension traits.//! This crate supports three cargo features://! - `owning_ref`: Allows your lock types to be used with the `owning_ref` crate.//! - `arc_lock`: Enables locking from an `Arc`. This enables types such as `ArcMutexGuard`. Note that this//!   requires the `alloc` crate to be present./// Initial value for an unlocked mutex.// A “non-constant” const item is a legacy way to supply an initialized value to downstream// static items. Can hopefully be replaced with `const fn new() -> Self` at some point./// Marker type which determines whether a lock guard should be `Send`. Use/// one of the `GuardSend` or `GuardNoSend` helper types here./// Acquires this mutex, blocking the current thread until it is able to do so./// Attempts to acquire this mutex without blocking. Returns `true`/// if the lock was successfully acquired and `false` otherwise./// Unlocks this mutex./// This method may only be called if the mutex is held in the current context, i.e. it must/// be paired with a successful call to [`lock`], [`try_lock`], [`try_lock_for`] or [`try_lock_until`]./// [`lock`]: RawMutex::lock/// [`try_lock`]: RawMutex::try_lock/// [`try_lock_for`]: RawMutexTimed::try_lock_for/// [`try_lock_until`]: RawMutexTimed::try_lock_until/// Checks whether the mutex is currently locked.RawMutex/// Basic operations for a mutex./// Types implementing this trait can be used by `Mutex` to form a safe and/// fully-functioning mutex type./// Implementations of this trait must ensure that the mutex is actually/// exclusive: a lock can't be acquired while the mutex is already locked.unlock_fair/// Unlocks this mutex using a fair unlock protocol./// This method may only be called if the mutex is held in the current context, see/// the documentation of [`unlock`](RawMutex::unlock)./// Temporarily yields the mutex to a waiting thread if there is one./// This method is functionally equivalent to calling `unlock_fair` followed/// by `lock`, however it can be much more efficient in the case where there/// are no waiting threads.RawMutexFair/// Additional methods for mutexes which support fair unlocking./// Fair unlocking means that a lock is handed directly over to the next waiting/// thread if there is one, without giving other threads the opportunity to/// "steal" the lock in the meantime. This is typically slower than unfair/// unlocking, but may be necessary in certain circumstances./// Duration type used for `try_lock_for`./// Instant type used for `try_lock_until`.try_lock_for/// Attempts to acquire this lock until a timeout is reached.try_lock_untilRawMutexTimed/// Additional methods for mutexes which support locking with timeouts./// The `Duration` and `Instant` types are specified as associated types so that/// this trait is usable even in `no_std` environments./// A mutual exclusion primitive useful for protecting shared data/// This mutex will block threads waiting for the lock to become available. The/// mutex can also be statically initialized or created via a `new`/// constructor. Each mutex has a type parameter which represents the data that/// it is protecting. The data can only be accessed through the RAII guards/// returned from `lock` and `try_lock`, which guarantees that the data is only/// ever accessed when the mutex is locked./// Creates a new mutex in an unlocked state ready for use./// Creates a new mutex based on a pre-existing raw mutex./// This allows creating a mutex in a constant context on stable Rust./// This method is a legacy alias for [`from_raw`](Self::from_raw).make_guard_unchecked/// Creates a new `MutexGuard` without checking if the mutex is locked./// This method must only be called if the thread logically holds the lock./// Calling this function when a guard has already been produced is undefined behaviour unless/// the guard was forgotten with `mem::forget`./// Acquires a mutex, blocking the current thread until it is able to do so./// This function will block the local thread until it is available to acquire/// the mutex. Upon returning, the thread is the only thread with the mutex/// held. An RAII guard is returned to allow scoped unlock of the lock. When/// the guard goes out of scope, the mutex will be unlocked./// Attempts to lock a mutex in the thread which already holds the lock will/// Attempts to acquire this lock./// If the lock could not be acquired at this time, then `None` is returned./// Otherwise, an RAII guard is returned. The lock will be unlocked when the/// guard is dropped./// This function does not block./// take place---the mutable borrow statically guarantees no locks exist.force_unlock/// Forcibly unlocks the mutex./// This is useful when combined with `mem::forget` to hold a lock without/// the need to maintain a `MutexGuard` object alive, for example when/// dealing with FFI./// This method must only be called if the current thread logically owns a/// `MutexGuard` but that guard has been discarded using `mem::forget`./// Behavior is undefined if a mutex is unlocked when not locked./// Returns the underlying raw mutex object./// Note that you will most likely need to import the `RawMutex` trait from/// `lock_api` to be able to call functions on the raw mutex./// This method is unsafe because it allows unlocking a mutex while/// still holding a reference to a `MutexGuard`.data_ptr/// Returns a raw pointer to the underlying data./// You must ensure that there are no data races when dereferencing the/// returned pointer, for example if the current thread logically owns/// a `MutexGuard` but that guard has been discarded using `mem::forget`.force_unlock_fair/// Forcibly unlocks the mutex using a fair unlock protocol./// If the lock could not be acquired before the timeout expired, then/// `None` is returned. Otherwise, an RAII guard is returned. The lock will/// be unlocked when the guard is dropped./// An RAII implementation of a "scoped lock" of a mutex. When this structure is/// dropped (falls out of scope), the lock will be unlocked./// The data protected by the mutex can be accessed through this guard via its/// `Deref` and `DerefMut` implementations./// Returns a reference to the original `Mutex` object./// Makes a new `MappedMutexGuard` for a component of the locked data./// This operation cannot fail as the `MutexGuard` passed/// in already locked the mutex./// This is an associated function that needs to be/// used as `MutexGuard::map(...)`. A method would interfere with methods of/// the same name on the contents of the locked data./// Attempts to make a new `MappedMutexGuard` for a component of the/// locked data. The original guard is returned if the closure returns `None`./// used as `MutexGuard::try_map(...)`. A method would interfere with methods ofunlocked/// Temporarily unlocks the mutex to execute the given function./// This is safe because `&mut` guarantees that there exist no other/// references to the data protected by the mutex./// Leaks the mutex guard and returns a mutable reference to the data/// protected by the mutex./// This will leave the `Mutex` in a locked state./// Unlocks the mutex using a fair unlock protocol./// By default, mutexes are unfair and allow the current thread to re-lock/// the mutex before another has the chance to acquire the lock, even if/// that thread has been blocked on the mutex for a long time. This is the/// default because it allows much higher throughput as it avoids forcing a/// context switch on every mutex unlock. This can result in one thread/// acquiring a mutex many more times than other threads./// However in some cases it can be beneficial to ensure fairness by forcing/// the lock to pass on to a waiting thread if there is one. This is done by/// using this method instead of dropping the `MutexGuard` normally.unlocked_fair/// The mutex is unlocked using a fair unlock protocol./// An RAII mutex guard returned by `MutexGuard::map`, which can point to a/// subfield of the protected data./// The main difference between `MappedMutexGuard` and `MutexGuard` is that the/// former doesn't support temporarily unlocking and re-locking, since that/// could introduce soundness issues if the locked object is modified by another/// This operation cannot fail as the `MappedMutexGuard` passed/// used as `MappedMutexGuard::map(...)`. A method would interfere with methods of/// used as `MappedMutexGuard::try_map(...)`. A method would interfere with methods of/// Initial value.nonzero_thread_id/// Returns a non-zero thread ID which identifies the current thread ofGetThreadId/// Helper trait which returns a non-zero thread ID./// The simplest way to implement this trait is to return the address of a/// thread-local variable./// Implementations of this trait must ensure that no two active threads share/// the same thread ID. However the ID of a thread that has exited can be/// re-used since that thread is no longer active.lock_countRawReentrantMutex/// A raw mutex type that wraps another raw mutex to provide reentrancy./// Although this has the same methods as the [`RawMutex`] trait, it does/// not implement it, and should not be used in the same way, since this/// mutex can successfully acquire a lock multiple times in the same thread./// Only use this when you know you want a raw mutex that can be locked/// reentrantly; you probably want [`ReentrantMutex`] instead.lock_internal/// Acquires this mutex, blocking if it's held by another thread./// Unlocks this mutex. The inner mutex may not be unlocked if/// this mutex was acquired previously in the current thread./// This method may only be called if the mutex is held by the current thread.is_owned_by_current_thread/// Checks whether the mutex is currently held by the current thread./// Unlocks this mutex using a fair unlock protocol. The inner mutex/// may not be unlocked if this mutex was acquired previously in theReentrantMutex/// A mutex which can be recursively locked by a single thread./// This type is identical to `Mutex` except for the following points:/// - Locking multiple times from the same thread will work correctly instead of///   deadlocking./// - `ReentrantMutexGuard` does not give mutable references to the locked data.///   Use a `RefCell` if you need this./// See [`Mutex`](crate::Mutex) for more details about the underlying mutex/// primitive./// Creates a new reentrant mutex in an unlocked state ready for use./// Creates a new reentrant mutex based on a pre-existing raw mutex and a/// helper to get the thread ID./// This allows creating a reentrant mutex in a constant context on stable/// Rust.ReentrantMutexGuard/// Creates a new `ReentrantMutexGuard` without checking if the lock is held./// Acquires a reentrant mutex, blocking the current thread until it is able/// to do so./// If the mutex is held by another thread then this function will block the/// local thread until it is available to acquire the mutex. If the mutex is/// already held by the current thread then this function will increment the/// lock reference count and return immediately. Upon returning,/// the thread is the only thread with the mutex held. An RAII guard is/// returned to allow scoped unlock of the lock. When the guard goes out of/// scope, the mutex will be unlocked./// Since this call borrows the `ReentrantMutex` mutably, no actual locking needs to/// the need to maintain a `ReentrantMutexGuard` object alive, for example when/// `ReentrantMutexGuard` but that guard has be discarded using `mem::forget`./// still holding a reference to a `ReentrantMutexGuard`./// the need to maintain a `ReentrantMutexGuard` object alive, for example/// when dealing with FFI./// returned pointer, for example if the current thread logically owns a/// `ReentrantMutexGuard` but that guard has been discarded using/// `mem::forget`."if unused the ReentrantMutex will immediately unlock"/// An RAII implementation of a "scoped lock" of a reentrant mutex. When this structure/// is dropped (falls out of scope), the lock will be unlocked./// `Deref` implementation./// Returns a reference to the original `ReentrantMutex` object.MappedReentrantMutexGuard/// Makes a new `MappedReentrantMutexGuard` for a component of the locked data./// This operation cannot fail as the `ReentrantMutexGuard` passed/// used as `ReentrantMutexGuard::map(...)`. A method would interfere with methods of/// Attempts to make  a new `MappedReentrantMutexGuard` for a component of the/// locked data. The original guard is return if the closure returns `None`./// used as `ReentrantMutexGuard::try_map(...)`. A method would interfere with methods of/// using this method instead of dropping the `ReentrantMutexGuard` normally./// The mutex is unlocked a fair unlock protocol./// An RAII mutex guard returned by `ReentrantMutexGuard::map`, which can point to a/// The main difference between `MappedReentrantMutexGuard` and `ReentrantMutexGuard` is that the/// This operation cannot fail as the `MappedReentrantMutexGuard` passed/// used as `MappedReentrantMutexGuard::map(...)`. A method would interfere with methods of/// used as `MappedReentrantMutexGuard::try_map(...)`. A method would interfere with methods of/// Initial value for an unlocked `RwLock`./// Acquires a shared lock, blocking the current thread until it is able to do so./// Attempts to acquire a shared lock without blocking./// Releases a shared lock./// This method may only be called if a shared lock is held in the current context./// Acquires an exclusive lock, blocking the current thread until it is able to do so./// Attempts to acquire an exclusive lock without blocking./// Releases an exclusive lock./// This method may only be called if an exclusive lock is held in the current context./// Checks if this `RwLock` is currently locked in any way.is_locked_exclusive/// Check if this `RwLock` is currently exclusively locked./// Basic operations for a reader-writer lock./// Types implementing this trait can be used by `RwLock` to form a safe and/// fully-functioning `RwLock` type./// Implementations of this trait must ensure that the `RwLock` is actually/// exclusive: an exclusive lock can't be acquired while an exclusive or shared/// lock exists, and a shared lock can't be acquire while an exclusive lockunlock_shared_fair/// Releases a shared lock using a fair unlock protocol.unlock_exclusive_fair/// Releases an exclusive lock using a fair unlock protocol.bump_shared/// Temporarily yields a shared lock to a waiting thread if there is one./// This method is functionally equivalent to calling `unlock_shared_fair` followed/// by `lock_shared`, however it can be much more efficient in the case where therebump_exclusive/// Temporarily yields an exclusive lock to a waiting thread if there is one./// This method is functionally equivalent to calling `unlock_exclusive_fair` followed/// by `lock_exclusive`, however it can be much more efficient in the case where thereRawRwLockFair/// Additional methods for `RwLock`s which support fair unlocking./// Atomically downgrades an exclusive lock into a shared lock without/// allowing any thread to take an exclusive lock in the meantime./// Additional methods for `RwLock`s which support atomically downgrading an/// exclusive lock to a shared lock.try_lock_shared_for/// Attempts to acquire a shared lock until a timeout is reached.try_lock_shared_untiltry_lock_exclusive_for/// Attempts to acquire an exclusive lock until a timeout is reached.try_lock_exclusive_untilRawRwLockTimed/// Additional methods for `RwLock`s which support locking with timeouts.lock_shared_recursive/// Acquires a shared lock without deadlocking in case of a recursive lock.try_lock_shared_recursive/// Attempts to acquire a shared lock without deadlocking in case of a recursive lock.RawRwLockRecursive/// Additional methods for `RwLock`s which support recursive read locks./// These are guaranteed to succeed without blocking if/// another read lock is held at the time of the call. This allows a thread/// to recursively lock a `RwLock`. However using this method can cause/// writers to starve since readers no longer block if a writer is waiting/// for the lock.try_lock_shared_recursive_for/// Attempts to acquire a shared lock until a timeout is reached, without/// deadlocking in case of a recursive lock.try_lock_shared_recursive_untilRawRwLockRecursiveTimed/// Additional methods for `RwLock`s which support recursive read locks and timeouts.lock_upgradable/// Acquires an upgradable lock, blocking the current thread until it is able to do so.try_lock_upgradable/// Attempts to acquire an upgradable lock without blocking.unlock_upgradable/// Releases an upgradable lock./// This method may only be called if an upgradable lock is held in the current context./// Upgrades an upgradable lock to an exclusive lock./// Attempts to upgrade an upgradable lock to an exclusive lock without/// blocking.RawRwLockUpgrade/// Additional methods for `RwLock`s which support atomically upgrading a shared/// lock to an exclusive lock./// This requires acquiring a special "upgradable read lock" instead of a/// normal shared lock. There may only be one upgradable lock at any time,/// otherwise deadlocks could occur when upgrading.unlock_upgradable_fair/// Releases an upgradable lock using a fair unlock protocol.bump_upgradable/// Temporarily yields an upgradable lock to a waiting thread if there is one./// This method is functionally equivalent to calling `unlock_upgradable_fair` followed/// by `lock_upgradable`, however it can be much more efficient in the case where thereRawRwLockUpgradeFair/// Additional methods for `RwLock`s which support upgradable locks and fair/// unlocking.downgrade_upgradable/// Downgrades an upgradable lock to a shared lock./// Downgrades an exclusive lock to an upgradable lock.RawRwLockUpgradeDowngrade/// Additional methods for `RwLock`s which support upgradable locks and lock/// downgrading.try_lock_upgradable_for/// Attempts to acquire an upgradable lock until a timeout is reached.try_lock_upgradable_untiltry_upgrade_for/// Attempts to upgrade an upgradable lock to an exclusive lock until a/// timeout is reached.try_upgrade_untilRawRwLockUpgradeTimed/// Additional methods for `RwLock`s which support upgradable locks and locking/// with timeouts./// A reader-writer lock/// This type of lock allows a number of readers or at most one writer at any/// point in time. The write portion of this lock typically allows modification/// of the underlying data (exclusive access) and the read portion of this lock/// typically allows for read-only access (shared access)./// The type parameter `T` represents the data that this lock protects. It is/// required that `T` satisfies `Send` to be shared across threads and `Sync` to/// allow concurrent access through readers. The RAII guards returned from the/// locking methods implement `Deref` (and `DerefMut` for the `write` methods)/// to allow access to the contained of the lock./// Creates a new instance of an `RwLock<T>` which is unlocked./// Consumes this `RwLock`, returning the underlying data./// Creates a new new instance of an `RwLock<T>` based on a pre-existing/// `RawRwLock<T>`./// This allows creating a `RwLock<T>` in a constant context on stablemake_read_guard_unchecked/// Creates a new `RwLockReadGuard` without checking if the lock is held./// This method must only be called if the thread logically holds a read lock./// This function does not increment the read count of the lock. Calling this function when a/// guard has already been produced is undefined behaviour unless the guard was forgotten/// with `mem::forget`.make_write_guard_unchecked/// This method must only be called if the thread logically holds a write lock./// Locks this `RwLock` with shared read access, blocking the current thread/// until it can be acquired./// The calling thread will be blocked until there are no more writers which/// hold the lock. There may be other readers currently inside the lock when/// this method returns./// Note that attempts to recursively acquire a read lock on a `RwLock` when/// the current thread already holds one may result in a deadlock./// Returns an RAII guard which will release this thread's shared access/// once it is dropped./// Attempts to acquire this `RwLock` with shared read access./// If the access could not be granted at this time, then `None` is returned./// Otherwise, an RAII guard is returned which will release the shared access/// Locks this `RwLock` with exclusive write access, blocking the current/// thread until it can be acquired./// This function will not return while other writers or other readers/// currently have access to the lock./// Returns an RAII guard which will drop the write access of this `RwLock`/// when dropped./// Attempts to lock this `RwLock` with exclusive write access./// Otherwise, an RAII guard is returned which will release the lock when/// it is dropped./// Since this call borrows the `RwLock` mutably, no actual locking needs to/// Checks whether this `RwLock` is currently locked in any way.force_unlock_read/// Forcibly unlocks a read lock./// the need to maintain a `RwLockReadGuard` object alive, for example when/// `RwLockReadGuard` but that guard has be discarded using `mem::forget`./// Behavior is undefined if a rwlock is read-unlocked when not read-locked.force_unlock_write/// Forcibly unlocks a write lock./// the need to maintain a `RwLockWriteGuard` object alive, for example when/// `RwLockWriteGuard` but that guard has be discarded using `mem::forget`./// Behavior is undefined if a rwlock is write-unlocked when not write-locked./// Returns the underlying raw reader-writer lock object./// Note that you will most likely need to import the `RawRwLock` trait from/// `lock_api` to be able to call functions on the raw/// reader-writer lock./// still holding a reference to a lock guard./// the need to maintain a `RwLockReadGuard` or `RwLockWriteGuard` object/// alive, for example when dealing with FFI./// `RwLockReadGuard` or `RwLockWriteGuard` but that guard has been discarded/// using `mem::forget`.force_unlock_read_fair/// Forcibly unlocks a read lock using a fair unlock protocol.force_unlock_write_fair/// Forcibly unlocks a write lock using a fair unlock protocol.try_read_for/// Attempts to acquire this `RwLock` with shared read access until a timeout/// is reached./// If the access could not be granted before the timeout expires, then/// `None` is returned. Otherwise, an RAII guard is returned which will/// release the shared access when it is dropped.try_read_untiltry_write_for/// Attempts to acquire this `RwLock` with exclusive write access until a/// release the exclusive access when it is dropped.try_write_untilread_recursive/// Unlike `read`, this method is guaranteed to succeed without blocking iftry_read_recursive/// This method is guaranteed to succeed if another read lock is held at the/// time of the call. See the documentation for `read_recursive` for details.try_read_recursive_for/// This method is guaranteed to succeed without blocking if another read/// lock is held at the time of the call. See the documentation for/// `read_recursive` for details.try_read_recursive_untilmake_upgradable_guard_unchecked/// Creates a new `RwLockUpgradableReadGuard` without checking if the lock is held./// This method must only be called if the thread logically holds an upgradable read lock./// Locks this `RwLock` with upgradable read access, blocking the current thread/// The calling thread will be blocked until there are no more writers or other/// upgradable reads which hold the lock. There may be other readers currently/// inside the lock when this method returns./// Attempts to acquire this `RwLock` with upgradable read access.try_upgradable_read_for/// Attempts to acquire this `RwLock` with upgradable read access until a timeouttry_upgradable_read_until"if unused the RwLock will immediately unlock"/// RAII structure used to release the shared read access of a lock when/// Returns a reference to the original reader-writer lock object.MappedRwLockReadGuard/// Make a new `MappedRwLockReadGuard` for a component of the locked data./// This operation cannot fail as the `RwLockReadGuard` passed/// in already locked the data./// used as `RwLockReadGuard::map(...)`. A method would interfere with methods of/// Attempts to make  a new `MappedRwLockReadGuard` for a component of the/// locked data. Returns the original guard if the closure returns `None`./// used as `RwLockReadGuard::try_map(...)`. A method would interfere with methods of/// Temporarily unlocks the `RwLock` to execute the given function./// references to the data protected by the `RwLock`./// Unlocks the `RwLock` using a fair unlock protocol./// By default, `RwLock` is unfair and allow the current thread to re-lock/// the `RwLock` before another has the chance to acquire the lock, even if/// that thread has been blocked on the `RwLock` for a long time. This is/// the default because it allows much higher throughput as it avoids/// forcing a context switch on every `RwLock` unlock. This can result in one/// thread acquiring a `RwLock` many more times than other threads./// using this method instead of dropping the `RwLockReadGuard` normally./// The `RwLock` is unlocked a fair unlock protocol./// Temporarily yields the `RwLock` to a waiting thread if there is one./// by `read`, however it can be much more efficient in the case where there/// RAII structure used to release the exclusive write access of a lock whenMappedRwLockWriteGuard/// Make a new `MappedRwLockWriteGuard` for a component of the locked data./// This operation cannot fail as the `RwLockWriteGuard` passed/// used as `RwLockWriteGuard::map(...)`. A method would interfere with methods of/// Attempts to make  a new `MappedRwLockWriteGuard` for a component of the/// used as `RwLockWriteGuard::try_map(...)`. A method would interfere with methods of/// Atomically downgrades a write lock into a read lock without allowing any/// writers to take exclusive access of the lock in the meantime./// Note that if there are any writers currently waiting to take the lock/// then other readers may not be able to acquire the lock even if it was/// downgraded./// Atomically downgrades a write lock into an upgradable read lock without allowing any/// using this method instead of dropping the `RwLockWriteGuard` normally./// by `write`, however it can be much more efficient in the case where there/// RAII structure used to release the upgradable read access of a lock when/// Atomically upgrades an upgradable read lock lock into an exclusive write lock,/// blocking the current thread until it can be acquired./// Tries to atomically upgrade an upgradable read lock into an exclusive write lock./// If the access could not be granted at this time, then the current guard is returned./// using this method instead of dropping the `RwLockUpgradableReadGuard` normally./// by `upgradable_read`, however it can be much more efficient in the case where there/// Atomically downgrades an upgradable read lock lock into a shared read lock/// without allowing any writers to take exclusive access of the lock in the/// meantime.with_upgraded/// First, atomically upgrades an upgradable read lock lock into an exclusive write lock,/// Then, calls the provided closure with an exclusive reference to the lock's data./// Finally, atomically downgrades the lock back to an upgradable read lock./// The closure's return value is wrapped in `Some` and returned./// This function only requires a mutable reference to the guard, unlike/// `upgrade` which takes the guard by value.try_with_upgraded/// First, tries to atomically upgrade an upgradable read lock into an exclusive write lock./// Otherwise, calls the provided closure with an exclusive reference to the lock's data,/// and finally downgrades the lock back to an upgradable read lock./// `try_upgrade` which takes the guard by value./// Tries to atomically upgrade an upgradable read lock into an exclusive/// write lock, until a timeout is reached./// the current guard is returned.try_with_upgraded_for/// `try_upgrade_for` which takes the guard by value.try_with_upgraded_until/// `try_upgrade_until` which takes the guard by value./// An RAII read lock guard returned by `RwLockReadGuard::map`, which can point to a/// The main difference between `MappedRwLockReadGuard` and `RwLockReadGuard` is that the/// This operation cannot fail as the `MappedRwLockReadGuard` passed/// used as `MappedRwLockReadGuard::map(...)`. A method would interfere with methods of/// used as `MappedRwLockReadGuard::try_map(...)`. A method would interfere with methods of/// using this method instead of dropping the `MappedRwLockReadGuard` normally./// An RAII write lock guard returned by `RwLockWriteGuard::map`, which can point to a/// The main difference between `MappedRwLockWriteGuard` and `RwLockWriteGuard` is that the/// This operation cannot fail as the `MappedRwLockWriteGuard` passed/// used as `MappedRwLockWriteGuard::map(...)`. A method would interfere with methods of/// used as `MappedRwLockWriteGuard::try_map(...)`. A method would interfere with methods of/// using this method instead of dropping the `MappedRwLockWriteGuard` normally.KVsinto_kvs/// Types for the `kv` argument.log_impl//! WARNING: this is not part of the crate's public API and is subject to change at any time// Types for the `kv` argument.// Log implementation./// An error encountered while working with structured data.std_support/// Create an error from a message.// Not public so we don't leak the `crate::kv::value::inner` API/// Create an error from a standard error type.to_key/// Perform the conversion.ToKey/// A type that can be converted into a [`Key`](struct.Key.html)./// A key in a key-value.// These impls must only be based on the as_str() representation of the key// If a new field (such as an optional index) is added to the key they must not affect comparison/// Get a key from a borrowed string./// Get a borrowed string from this key.sval_refValueRef'svalsval_supportserde_supportkey_from_string//! Structured keys.VisitValue//! Structured logging.//! Add the `kv` feature to your `Cargo.toml` to enable//! this module://! [dependencies.log]//! features = ["kv"]//! # Structured logging in `log`//! Structured logging enhances traditional text-based log records with user-defined//! attributes. Structured logs can be analyzed using a variety of data processing//! techniques, without needing to find and parse attributes from unstructured text first.//! In `log`, user-defined attributes are part of a [`Source`] on the log record.//! Each attribute is a key-value; a pair of [`Key`] and [`Value`]. Keys are strings//! and values are a datum of any type that can be formatted or serialized. Simple types//! like strings, booleans, and numbers are supported, as well as arbitrarily complex//! structures involving nested objects and sequences.//! ## Adding key-values to log records//! Key-values appear before the message format in the `log!` macros://! # use log::info;//! info!(a = 1; "Something of interest");//! Key-values support the same shorthand identifer syntax as `format_args`://! let a = 1;//! info!(a; "Something of interest");//! Values are capturing using the [`ToValue`] trait by default. To capture a value//! using a different trait implementation, use a modifier after its key. Here's how//! the same example can capture `a` using its `Debug` implementation instead://! info!(a:? = 1; "Something of interest");//! The following capturing modifiers are supported://! - `:?` will capture the value using `Debug`.//! - `:debug` will capture the value using `Debug`.//! - `:%` will capture the value using `Display`.//! - `:display` will capture the value using `Display`.//! - `:err` will capture the value using `std::error::Error` (requires the `kv_std` feature).//! - `:sval` will capture the value using `sval::Value` (requires the `kv_sval` feature).//! - `:serde` will capture the value using `serde::Serialize` (requires the `kv_serde` feature).//! ## Working with key-values on log records//! Use the [`Record::key_values`](../struct.Record.html#method.key_values) method to access key-values.//! Individual values can be pulled from the source by their key://! # fn main() -> Result<(), log::kv::Error> {//! use log::kv::{Source, Key, Value};//! # let record = log::Record::builder().key_values(&[("a", 1)]).build();//! // info!(a = 1; "Something of interest");//! let a: Value = record.key_values().get(Key::from("a")).unwrap();//! assert_eq!(1, a.to_i64().unwrap());//! All key-values can also be enumerated using a [`VisitSource`]://! use std::collections::BTreeMap;//! use log::kv::{self, Source, Key, Value, VisitSource};//! struct Collect<'kvs>(BTreeMap<Key<'kvs>, Value<'kvs>>);//! impl<'kvs> VisitSource<'kvs> for Collect<'kvs> {//!     fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), kv::Error> {//!         self.0.insert(key, value);//! let mut visitor = Collect(BTreeMap::new());//! # let record = log::Record::builder().key_values(&[("a", 1), ("b", 2), ("c", 3)]).build();//! // info!(a = 1, b = 2, c = 3; "Something of interest");//! record.key_values().visit(&mut visitor)?;//! let collected = visitor.0;//!     vec!["a", "b", "c"],//!     collected//!         .keys()//!         .map(|k| k.as_str())//!         .collect::<Vec<_>>(),//! [`Value`]s have methods for conversions to common types://! use log::kv::{Source, Key};//! let a = record.key_values().get(Key::from("a")).unwrap();//! Values also have their own [`VisitValue`] type. Value visitors are a lightweight//! API for working with primitives types://! use log::kv::{self, Source, Key, VisitValue};//! struct IsNumeric(bool);//! impl<'kvs> VisitValue<'kvs> for IsNumeric {//!     fn visit_any(&mut self, _value: kv::Value) -> Result<(), kv::Error> {//!         self.0 = false;//!     fn visit_u64(&mut self, _value: u64) -> Result<(), kv::Error> {//!         self.0 = true;//!     fn visit_i64(&mut self, _value: i64) -> Result<(), kv::Error> {//!     fn visit_u128(&mut self, _value: u128) -> Result<(), kv::Error> {//!     fn visit_i128(&mut self, _value: i128) -> Result<(), kv::Error> {//!     fn visit_f64(&mut self, _value: f64) -> Result<(), kv::Error> {//! let mut visitor = IsNumeric(false);//! a.visit(&mut visitor)?;//! let is_numeric = visitor.0;//! assert!(is_numeric);//! To serialize a value to a format like JSON, you can also use either `serde` or `sval`://! # #[cfg(feature = "serde")]//! # use log::kv::Key;//! #[derive(serde::Serialize)]//!     a: i32, b: bool,//!     c: &'static str,//! let data = Data { a: 1, b: true, c: "Some data" };//! # let source = [("a", log::kv::Value::from_serde(&data))];//! # let record = log::Record::builder().key_values(&source).build();//! // info!(a = data; "Something of interest");//! assert_eq!("{\"a\":1,\"b\":true,\"c\":\"Some data\"}", serde_json::to_string(&a)?);//! The choice of serialization framework depends on the needs of the consumer.//! If you're in a no-std environment, you can use `sval`. In other cases, you can use `serde`.//! Log producers and log consumers don't need to agree on the serialization framework.//! A value can be captured using its `serde::Serialize` implementation and still be serialized//! through `sval` without losing any structure or data.//! Values can also always be formatted using the standard `Debug` and `Display`//! traits://! # #[derive(Debug)]//!     a: i32,//!     b: bool,//! # let source = [("a", log::kv::Value::from_debug(&data))];//! assert_eq!("Data { a: 1, b: true, c: \"Some data\" }", format!("{a:?}"));/// Visit key-values./// A source doesn't have to guarantee any ordering or uniqueness of key-values./// If the given visitor returns an error then the source may early-return with it,/// even if there are more key-values./// A source should yield the same key-values to a subsequent visitor unless/// that visitor itself fails./// Get the value for a given key./// If the key appears multiple times in the source then which key is returned/// is implementation specific./// A source that can provide a more efficient implementation of this method/// should override it./// Count the number of key-values that can be visited./// A source that knows the number of key-values upfront may provide a more/// efficient implementation./// A subsequent call to `visit` should yield the same number of key-values./// A source of key-values./// The source may be a single pair, a set of pairs, or a filter over a set of pairs./// Use the [`VisitSource`](trait.VisitSource.html) trait to inspect the structured data/// in a source./// A source is like an iterator over its key-values, except with a push-based API/// instead of a pull-based one./// Enumerating the key-values in a source:/// # fn main() -> Result<(), log::kv::Error> {/// use log::kv::{self, Source, Key, Value, VisitSource};/// // A `VisitSource` that prints all key-values/// // VisitSources are fed the key-value pairs of each key-values/// struct Printer;/// impl<'kvs> VisitSource<'kvs> for Printer {///     fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), kv::Error> {///         println!("{key}: {value}");/// // A source with 3 key-values/// // Common collection types implement the `Source` trait/// let source = &[/// // Pass an instance of the `VisitSource` to a `Source` to visit it/// source.visit(&mut Printer)?;/// The default implementation of `Source::get`count_default/// The default implementation of `Source::count`./// Visit a key-value pair./// A visitor for the key-value pairs in a [`Source`](trait.Source.html).DebugMap// NOTE: Deprecated; but aliases can't carry this attributesource_is_object_safevisitor_is_object_safe//! Sources for key-values.//! This module defines the [`Source`] type and supporting APIs for//! working with collections of key-values./// A type that can be converted into a [`Value`](struct.Value.html)./// A value in a key-value./// Values are an anonymous bag containing some structured datum./// # Capturing values/// There are a few ways to capture a value:/// - Using the `Value::from_*` methods./// - Using the `ToValue` trait./// - Using the standard `From` trait./// ## Using the `Value::from_*` methods/// `Value` offers a few constructor methods that capture values of different kinds./// use log::kv::Value;/// let value = Value::from_debug(&42i32);/// assert_eq!(None, value.to_i64());/// ## Using the `ToValue` trait/// The `ToValue` trait can be used to capture values generically./// It's the bound used by `Source`./// # use log::kv::ToValue;/// let value = 42i32.to_value();/// assert_eq!(Some(42), value.to_i64());/// ## Using the standard `From` trait/// Standard types that implement `ToValue` also implement `From`./// let value = Value::from(42i32);/// # Data model/// Values can hold one of a number of types:/// - **Null:** The absence of any other meaningful value. Note that///   `Some(Value::null())` is not the same as `None`. The former is///   `null` while the latter is `undefined`. This is important to be///   able to tell the difference between a key-value that was logged,///   but its value was empty (`Some(Value::null())`) and a key-value///   that was never logged at all (`None`)./// - **Strings:** `str`, `char`./// - **Booleans:** `bool`./// - **Integers:** `u8`-`u128`, `i8`-`i128`, `NonZero*`./// - **Floating point numbers:** `f32`-`f64`./// - **Errors:** `dyn (Error + 'static)`./// - **`serde`:** Any type in `serde`'s data model./// - **`sval`:** Any type in `sval`'s data model./// # Serialization/// Values provide a number of ways to be serialized./// For basic types the [`Value::visit`] method can be used to extract the/// underlying typed value. However this is limited in the amount of types/// supported (see the [`VisitValue`] trait methods)./// For more complex types one of the following traits can be used:///  * `sval::Value`, requires the `kv_sval` feature.///  * `serde::Serialize`, requires the `kv_serde` feature./// You don't need a visitor to serialize values through `serde` or `sval`./// A value can always be serialized using any supported framework, regardless/// of how it was captured. If, for example, a value was captured using its/// `Display` implementation, it will serialize through `serde` as a string. If it was/// captured as a struct using `serde`, it will also serialize as a struct/// through `sval`, or can be formatted using a `Debug`-compatible representation.from_any/// Get a value from a type implementing `ToValue`.from_debug/// Get a value from a type implementing `std::fmt::Debug`.from_display/// Get a value from a type implementing `std::fmt::Display`.from_serde/// Get a value from a type implementing `serde::Serialize`.from_sval/// Get a value from a type implementing `sval::Value`.from_dyn_debug/// Get a value from a dynamic `std::fmt::Debug`.from_dyn_display/// Get a value from a dynamic `std::fmt::Display`.from_dyn_error/// Get a value from a dynamic error./// Get a `null` value./// Get a value from an internal primitive./// Inspect this value using a simple visitor./// When the `kv_serde` or `kv_sval` features are enabled, you can also/// serialize a value using its `Serialize` or `Value` implementation.impl_to_value_primitiveimpl_to_value_nonzero_primitiveimpl_value_to_primitiveto_borrowed_error/// Try convert this value into an error.to_borrowed_str/// Try convert this value into a borrowed string.to_cow_str/// Try convert this value into a string.visit_any/// Visit a `Value`./// This is the only required method on `VisitValue` and acts as a fallback for any/// more specific methods that aren't overridden./// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,/// or serialized using its `sval::Value` or `serde::Serialize` implementation.visit_null/// Visit an empty value./// Visit an unsigned integer./// Visit a signed integer.visit_u128/// Visit a big unsigned integer.visit_i128/// Visit a big signed integer.visit_f64/// Visit a floating point.visit_bool/// Visit a boolean./// Visit a string.visit_borrowed_strvisit_char/// Visit a Unicode character.visit_error/// Visit an error.visit_borrowed_error/// A visitor for a [`Value`]./// Also see [`Value`'s documentation on seralization]. Value visitors are a simple alternative/// to a more fully-featured serialization framework like `serde` or `sval`. A value visitor/// can differentiate primitive types through methods like [`VisitValue::visit_bool`] and/// [`VisitValue::visit_str`], but more complex types like maps and sequences/// will fallthrough to [`VisitValue::visit_any`]./// If you're trying to serialize a value to a format like JSON, you can use either `serde`/// or `sval` directly with the value. You don't need a visitor./// [`Value`'s documentation on seralization]: Value#serialization/**
    An implementation of `Value` based on a library called `value_bag`.

    `value_bag` was written specifically for use in `log`'s value, but was split out when it outgrew
    the codebase here. It's a general-purpose type-erasure library that handles mapping between
    more fully-featured serialization frameworks.
    */value_bagValueBagTestToken/**
    This is a dependency-free implementation of `Value` when there's no serialization frameworks involved.
    In these simple cases a more fully featured solution like `value_bag` isn't needed, so we avoid pulling it in.

    There are a few things here that need to remain consistent with the `value_bag`-based implementation:

    1. Conversions should always produce the same results. If a conversion here returns `Some`, then
       the same `value_bag`-based conversion must also. Of particular note here are floats to ints; they're
       based on the standard library's `TryInto` conversions, which need to be convert to `i32` or `u32`,
       and then to `f64`.
    2. VisitValues should always be called in the same way. If a particular type of value calls `visit_i64`,
       then the same `value_bag`-based visitor must also.
    */to_charto_u128to_i128to_test_tokencapture_debugcapture_displaycapture_error/// Get a value from an error.capture_serdecapture_sval/// Check whether this value can be downcast to `T`./// Try downcast this value to `T`.as_debugas_displayas_erroras_serdeas_svalto_tokentest_to_value_displaytest_to_value_structuredtest_to_numbertest_to_floattest_to_cow_strtest_to_booltest_to_chartest_visit_integertest_visit_borrowed_str//! Structured values.//! This module defines the [`Value`] type and supporting APIs for//! capturing and serializing them.LOGGER// The LOGGER static holds a pointer to the global logger. It is protected by// the STATE static which determines whether LOGGER has been initialized yet.STATEUNINITIALIZED// There are three different states that we care about: the logger's// uninitialized, the logger's initializing (set_logger's been called but// LOGGER hasn't actually been set yet), or the logger's active.INITIALIZINGMAX_LOG_LEVEL_FILTERLOG_LEVEL_NAMESSET_LOGGER_ERRORLEVEL_PARSE_ERROR/// The "error" level./// Designates very serious errors.// This way these line up with the discriminants for LevelFilter below// This works because Rust treats field-less enums the same way as C does:// https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-field-less-enumerations/// The "warn" level./// Designates hazardous situations./// The "info" level./// Designates useful information./// The "debug" level./// Designates lower priority information./// The "trace" level./// Designates very low priority, often extremely verbose, information./// An enum representing the available verbosity levels of the logger./// Typical usage includes: checking if a certain `Level` is enabled with/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of/// [`log!`](macro.log.html), and comparing a `Level` directly to a/// [`LevelFilter`](enum.LevelFilter.html).ParseLevelError/// Returns the most verbose logging level.to_level_filter/// Converts the `Level` to the equivalent `LevelFilter`./// Returns the string representation of the `Level`./// This returns the same string as the `fmt::Display` implementation./// Iterate through all supported logging levels./// The order of iteration is from more severe to less severe log messages./// use log::Level;/// let mut levels = Level::iter();/// assert_eq!(Some(Level::Error), levels.next());/// assert_eq!(Some(Level::Trace), levels.last());/// A level lower than all log levels./// Corresponds to the `Error` log level./// Corresponds to the `Warn` log level./// Corresponds to the `Info` log level./// Corresponds to the `Debug` log level./// Corresponds to the `Trace` log level./// An enum representing the available verbosity level filters of the logger./// A `LevelFilter` may be compared directly to a [`Level`]. Use this type/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`]./// [`Level`]: enum.Level.html/// [`max_level()`]: fn.max_level.html/// [`set_max_level`]: fn.set_max_level.html/// Returns the most verbose logging level filter.to_level/// Converts `self` to the equivalent `Level`./// Returns `None` if `self` is `LevelFilter::Off`./// Returns the string representation of the `LevelFilter`./// Iterate through all supported filtering levels./// The order of iteration is from less to more verbose filtering./// let mut levels = LevelFilter::iter();/// assert_eq!(Some(LevelFilter::Off), levels.next());/// assert_eq!(Some(LevelFilter::Trace), levels.last());MaybeStaticStr/// The "payload" of a log message./// # Use/// `Record` structures are passed as parameters to the [`log`][method.log]/// method of the [`Log`] trait. Logger implementors manipulate these/// structures in order to display log messages. `Record`s are automatically/// created by the [`log!`] macro and so are not seen by log users./// Note that the [`level()`] and [`target()`] accessors are equivalent to/// `self.metadata().level()` and `self.metadata().target()` respectively./// These methods are provided as a convenience for users of this structure./// The following example shows a simple logger that displays the level,/// module path, and message of any `Record` that is passed to it./// struct SimpleLogger;/// impl log::Log for SimpleLogger {///    fn enabled(&self, _metadata: &log::Metadata) -> bool {///        true///    fn log(&self, record: &log::Record) {///        if !self.enabled(record.metadata()) {///            return;///        println!("{}:{} -- {}",///                 record.level(),///                 record.target(),///                 record.args());///    fn flush(&self) {}/// [method.log]: trait.Log.html#tymethod.log/// [`Log`]: trait.Log.html/// [`log!`]: macro.log.html/// [`level()`]: struct.Record.html#method.level/// [`target()`]: struct.Record.html#method.targetRecordBuilder/// Returns a new builder./// The message body./// Metadata about the log directive./// The verbosity level of the message./// The name of the target of the directive./// The module path of the message.module_path_static/// The module path of the message, if it is a `'static` string./// The source file containing the message.file_static/// The source file containing the message, if it is a `'static` string./// The line containing the message./// Builder for [`Record`](struct.Record.html)./// Typically should only be used by log library creators or for testing and "shim loggers"./// The `RecordBuilder` can set the different parameters of `Record` object, and returns/// the created object when `build` is called./// use log::{Level, Record};/// let record = Record::builder()///                 .args(format_args!("Error!"))///                 .level(Level::Error)///                 .target("myApp")///                 .file(Some("server.rs"))///                 .line(Some(144))///                 .module_path(Some("server"))///                 .build();/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):/// use log::{Record, Level, MetadataBuilder};/// let error_metadata = MetadataBuilder::new()///                         .target("myApp")///                         .level(Level::Error)///                         .build();///                 .metadata(error_metadata)///                 .line(Some(433))///                 .file(Some("app.rs"))/// Construct new `RecordBuilder`./// The default options are:/// - `args`: [`format_args!("")`]/// - `metadata`: [`Metadata::builder().build()`]/// - `module_path`: `None`/// - `file`: `None`/// - `line`: `None`/// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html/// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build/// Set [`args`](struct.Record.html#method.args)./// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html)./// Set [`Metadata::level`](struct.Metadata.html#method.level)./// Set [`Metadata::target`](struct.Metadata.html#method.target)/// Set [`module_path`](struct.Record.html#method.module_path)/// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string/// Set [`file`](struct.Record.html#method.file)/// Set [`file`](struct.Record.html#method.file) to a `'static` string./// Set [`line`](struct.Record.html#method.line)/// Invoke the builder and return a `Record`/// Metadata about a log message./// `Metadata` structs are created when users of the library use/// logging macros./// They are consumed by implementations of the `Log` trait in the/// `enabled` method./// `Record`s use `Metadata` to determine the log message's severity/// and target./// Users should use the `log_enabled!` macro in their code to avoid/// constructing expensive log messages./// use log::{Record, Level, Metadata};/// struct MyLogger;/// impl log::Log for MyLogger {///     fn enabled(&self, metadata: &Metadata) -> bool {///         metadata.level() <= Level::Info///     fn log(&self, record: &Record) {///         if self.enabled(record.metadata()) {///             println!("{} - {}", record.level(), record.args());///     fn flush(&self) {}/// # fn main(){}MetadataBuilder/// Builder for [`Metadata`](struct.Metadata.html)./// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns/// let target = "myApp";/// use log::{Level, MetadataBuilder};/// let metadata = MetadataBuilder::new()///                     .level(Level::Debug)///                     .target(target)///                     .build();/// Construct a new `MetadataBuilder`./// - `level`: `Level::Info`/// - `target`: `""`/// Setter for [`level`](struct.Metadata.html#method.level)./// Setter for [`target`](struct.Metadata.html#method.target)./// Returns a `Metadata` object./// Determines if a log message with the specified metadata would be/// logged./// This is used by the `log_enabled!` macro to allow callers to avoid/// expensive computation of log message arguments if the message would be/// discarded anyway./// # For implementors/// This method isn't called automatically by the `log!` macros./// It's up to an implementation of the `Log` trait to call `enabled` in its own/// `log` method implementation to guarantee that filtering is applied./// Logs the `Record`./// Note that `enabled` is *not* necessarily called before this method./// Implementations of `log` should perform all necessary filtering/// internally./// It can be called manually on shut-down to ensure any in-flight records are flushed./// A trait encapsulating the operations required of a logger.NopLogger// Just used as a dummy initial value for LOGGERset_max_level/// Sets the global maximum log level./// Generally, this should only be called by the active logging implementation./// Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.set_max_level_racy/// A thread-unsafe version of [`set_max_level`]./// This function is available on all platforms, even those that do not have/// support for atomics that is needed by [`set_max_level`]./// In almost all cases, [`set_max_level`] should be preferred./// This function is only safe to call when it cannot race with any other/// calls to `set_max_level` or `set_max_level_racy`./// This can be upheld by (for example) making sure that **there are no other/// threads**, and (on embedded) that **interrupts are disabled**./// It is safe to use all other logging functions while this function runs/// (including all logging macros)./// Returns the current maximum log level./// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check/// this value and discard any message logged at a higher level. The maximum/// log level is set by the [`set_max_level`] function./// [`error!`]: macro.error.html/// [`warn!`]: macro.warn.html/// [`info!`]: macro.info.html/// [`debug!`]: macro.debug.html/// [`trace!`]: macro.trace.htmlset_boxed_logger/// Sets the global logger to a `Box<Log>`./// This is a simple convenience wrapper over `set_logger`, which takes a/// `Box<Log>` rather than a `&'static Log`. See the documentation for/// [`set_logger`] for more details./// Requires the `std` feature./// An error is returned if a logger has already been set./// [`set_logger`]: fn.set_logger.htmlset_logger/// Sets the global logger to a `&'static Log`./// This function may only be called once in the lifetime of a program. Any log/// events that occur before the call to `set_logger` completes will be ignored./// This function does not typically need to be called manually. Logger/// implementations should provide an initialization method that installs the/// logger internally./// # Availability/// This method is available even when the `std` feature is disabled. However,/// it is currently unavailable on `thumbv6` targets, which lack support for/// some atomic operations which are used by this function. Even on those/// targets, [`set_logger_racy`] will be available./// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};/// static MY_LOGGER: MyLogger = MyLogger;/// # fn main(){/// log::set_logger(&MY_LOGGER).unwrap();/// log::set_max_level(LevelFilter::Info);/// info!("hello log");/// warn!("warning");/// error!("oops");/// [`set_logger_racy`]: fn.set_logger_racy.htmlset_logger_innerset_logger_racy/// A thread-unsafe version of [`set_logger`]./// support for atomics that is needed by [`set_logger`]./// In almost all cases, [`set_logger`] should be preferred./// calls to `set_logger` or `set_logger_racy`./// It is safe to use other logging functions while this function runs/// The type returned by [`set_logger`] if [`set_logger`] has already been called.// The Error trait is not available in libcore/// The type returned by [`from_str`] when the string doesn't match any of the log levels./// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str/// Returns a reference to the logger./// If a logger has not been set, a no-op implementation is returned.__private_api// WARNING: this is not part of the crate's public API and is subject to change at any timeSTATIC_MAX_LEVEL/// The statically resolved maximum log level./// See the crate level documentation for information on how to configure this./// This value is checked by the log macros, but not by the `Log`ger returned by/// the [`logger`] function. Code that manually calls functions on that value/// should compare the level against this value./// [`logger`]: fn.logger.htmltest_levelfilter_from_strtest_level_from_strtest_level_as_strtest_level_showtest_levelfilter_showtest_cross_cmptest_cross_eqtest_to_leveltest_to_level_filtertest_level_filter_as_strtest_static_max_level_debugtest_static_max_level_releasetest_error_traittest_metadata_buildertest_metadata_convenience_buildertest_record_buildertest_record_convenience_buildertest_record_complete_buildertest_foreign_impl// Test that the `impl Log for Foo` blocks work// This test mostly operates on a type level, so failures will be compile errors//! A lightweight logging facade.//! The `log` crate provides a single logging API that abstracts over the//! actual logging implementation. Libraries can use the logging API provided//! by this crate, and the consumer of those libraries can choose the logging//! implementation that is most suitable for its use case.//! If no logging implementation is selected, the facade falls back to a "noop"//! implementation that ignores all log messages. The overhead in this case//! is very small - just an integer load, comparison and jump.//! A log request consists of a _target_, a _level_, and a _body_. A target is a//! string which defaults to the module path of the location of the log request,//! though that default may be overridden. Logger implementations typically use//! the target to filter requests based on some user configuration.//! The basic use of the log crate is through the five logging macros: [`error!`],//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]//! where `error!` represents the highest-priority log messages//! and `trace!` the lowest. The log messages are filtered by configuring//! the log level to exclude messages with a lower priority.//! Each of these macros accept format strings similarly to [`println!`].//! [`error!`]: ./macro.error.html//! [`warn!`]: ./macro.warn.html//! [`info!`]: ./macro.info.html//! [`debug!`]: ./macro.debug.html//! [`trace!`]: ./macro.trace.html//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html//! Avoid writing expressions with side-effects in log statements. They may not be evaluated.//! ## In libraries//! Libraries should link only to the `log` crate, and use the provided//! macros to log whatever information will be useful to downstream consumers.//! # #[derive(Debug)] pub struct Yak(String);//! # impl Yak { fn shave(&mut self, _: u32) {} }//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }//! use log::{info, warn};//! pub fn shave_the_yak(yak: &mut Yak) {//!     info!(target: "yak_events", "Commencing yak shaving for {yak:?}");//!         match find_a_razor() {//!             Ok(razor) => {//!                 info!("Razor located: {razor}");//!                 yak.shave(razor);//!                 break;//!             Err(err) => {//!                 warn!("Unable to locate a razor: {err}, retrying");//! ## In executables//! Executables should choose a logging implementation and initialize it early in the//! runtime of the program. Logging implementations will typically include a//! function to do this. Any log messages generated before//! the implementation is initialized will be ignored.//! The executable itself may use the `log` crate to log as well.//! ### Warning//! The logging system may only be initialized once.//! ## Structured logging//! If you enable the `kv` feature you can associate structured values//! with your log records. If we take the example from before, we can include//! some additional context besides what's in the formatted message://! # use serde::Serialize;//! # #[derive(Debug, Serialize)] pub struct Yak(String);//! # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }//! # #[cfg(feature = "kv_serde")]//!     info!(target: "yak_events", yak:serde; "Commencing yak shaving");//!                 info!(razor; "Razor located");//!             Err(e) => {//!                 warn!(e:err; "Unable to locate a razor, retrying");//! # #[cfg(not(feature = "kv_serde"))]//! See the [`kv`] module documentation for more details.//! # Available logging implementations//! In order to produce log output executables have to use//! a logger implementation compatible with the facade.//! There are many available implementations to choose from,//! here are some of the most popular ones://! * Simple minimal loggers://!     * [env_logger]//!     * [colog]//!     * [simple_logger]//!     * [simplelog]//!     * [pretty_env_logger]//!     * [stderrlog]//!     * [flexi_logger]//!     * [call_logger]//!     * [structured-logger]//! * Complex configurable frameworks://!     * [log4rs]//!     * [fern]//! * Adaptors for other facilities://!     * [syslog]//!     * [slog-stdlog]//!     * [systemd-journal-logger]//!     * [android_log]//!     * [win_dbg_logger]//!     * [db_logger]//!     * [log-to-defmt]//!     * [logcontrol-log]//! * For WebAssembly binaries://!     * [console_log]//! * For dynamic libraries://!     * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries//! * Utilities://!     * [log_err]//!     * [log-reload]//! # Implementing a Logger//! Loggers implement the [`Log`] trait. Here's a very basic example that simply//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or//! [`Info`][level_link] levels to stdout://! use log::{Record, Level, Metadata};//! struct SimpleLogger;//! impl log::Log for SimpleLogger {//!         metadata.level() <= Level::Info//!         if self.enabled(record.metadata()) {//!             println!("{} - {}", record.level(), record.args());//! Loggers are installed by calling the [`set_logger`] function. The maximum//! log level also needs to be adjusted via the [`set_max_level`] function. The//! logging facade uses this as an optimization to improve performance of log//! messages at levels that are disabled. It's important to set it, as it//! defaults to [`Off`][filter_link], so no log messages will ever be captured!//! In the case of our example logger, we'll want to set the maximum log level//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or//! [`Trace`][level_link] level log messages. A logging implementation should//! provide a function that wraps a call to [`set_logger`] and//! [`set_max_level`], handling initialization of the logger://! # use log::{Level, Metadata};//! # struct SimpleLogger;//! # impl log::Log for SimpleLogger {//! #   fn enabled(&self, _: &Metadata) -> bool { false }//! #   fn log(&self, _: &log::Record) {}//! #   fn flush(&self) {}//! use log::{SetLoggerError, LevelFilter};//! static LOGGER: SimpleLogger = SimpleLogger;//! pub fn init() -> Result<(), SetLoggerError> {//!     log::set_logger(&LOGGER)//!         .map(|()| log::set_max_level(LevelFilter::Info))//! Implementations that adjust their configurations at runtime should take care//! to adjust the maximum log level as well.//! # Use with `std`//! `set_logger` requires you to provide a `&'static Log`, which can be hard to//! obtain if your logger depends on some runtime configuration. The//! `set_boxed_logger` function is available with the `std` Cargo feature. It is//! identical to `set_logger` except that it takes a `Box<Log>` rather than a//! `&'static Log`://! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};//! # #[cfg(feature = "std")]//!     log::set_boxed_logger(Box::new(SimpleLogger))//! # Compile time filters//! Log levels can be statically disabled at compile time by enabling one of these Cargo features://! * `max_level_off`//! * `max_level_error`//! * `max_level_warn`//! * `max_level_info`//! * `max_level_debug`//! * `max_level_trace`//! Log invocations at disabled levels will be skipped and will not even be present in the//! resulting binary. These features control the value of the `STATIC_MAX_LEVEL` constant. The//! logging macros check this value before logging a message. By default, no levels are disabled.//! It is possible to override this level for release builds only with the following features://! * `release_max_level_off`//! * `release_max_level_error`//! * `release_max_level_warn`//! * `release_max_level_info`//! * `release_max_level_debug`//! * `release_max_level_trace`//! Libraries should avoid using the max level features because they're global and can't be changed//! once they're set.//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info//! level logs in release builds with the following configuration://! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }//! # Crate Feature Flags//! The following crate feature flags are available in addition to the filters. They are//! configured in your `Cargo.toml`.//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and//! `set_boxed_logger` functionality.//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.//! log = { version = "0.4", features = ["std", "serde"] }//! # Version compatibility//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the//! module path and file name information associated with the message will unfortunately be lost.//! [`Log`]: trait.Log.html//! [level_link]: enum.Level.html//! [filter_link]: enum.LevelFilter.html//! [`set_logger`]: fn.set_logger.html//! [`set_max_level`]: fn.set_max_level.html//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html//! [env_logger]: https://docs.rs/env_logger/*/env_logger///! [colog]: https://docs.rs/colog/*/colog///! [simple_logger]: https://github.com/borntyping/rust-simple_logger//! [simplelog]: https://github.com/drakulix/simplelog.rs//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger///! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog///! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger///! [call_logger]: https://docs.rs/call_logger/*/call_logger///! [syslog]: https://docs.rs/syslog/*/syslog///! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog///! [log4rs]: https://docs.rs/log4rs/*/log4rs///! [fern]: https://docs.rs/fern/*/fern///! [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger///! [android_log]: https://docs.rs/android_log/*/android_log///! [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger///! [db_logger]: https://docs.rs/db_logger/*/db_logger///! [log-to-defmt]: https://docs.rs/log-to-defmt/*/log_to_defmt///! [console_log]: https://docs.rs/console_log/*/console_log///! [structured-logger]: https://docs.rs/structured-logger/latest/structured_logger///! [logcontrol-log]: https://docs.rs/logcontrol-log/*/logcontrol_log///! [log_err]: https://docs.rs/log_err/*/log_err///! [log-reload]: https://docs.rs/log-reload/*/log_reload/// log!(target: "my_target", Level::Info, key1:? = 42, key2 = true; "a {} event", "log");// log!(target: "my_target", Level::Info, "a {} event", "log");// log!(Level::Info, "a log event")/// The standard logging macro./// This macro will generically log with the specified `Level` and `format!`/// based argument list./// use log::{log, Level};/// let data = (42, "Forty-two");/// let private_data = "private";/// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);/// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",///     data.0, data.1, private_data);// error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")// error!(target: "my_target", "a {} event", "log")// error!("a {} event", "log")/// Logs a message at the error level./// use log::error;/// let (err_info, port) = ("No connection", 22);/// error!("Error: {err_info} on port {port}");/// error!(target: "app_events", "App Error: {err_info}, Port: {port}");// warn!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")// warn!(target: "my_target", "a {} event", "log")// warn!("a {} event", "log")/// Logs a message at the warn level./// use log::warn;/// let warn_description = "Invalid Input";/// warn!("Warning! {warn_description}!");/// warn!(target: "input_events", "App received warning: {warn_description}");// info!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")// info!(target: "my_target", "a {} event", "log")// info!("a {} event", "log")/// Logs a message at the info level./// use log::info;/// # struct Connection { port: u32, speed: f32 }/// let conn_info = Connection { port: 40, speed: 3.20 };/// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);/// info!(target: "connection_events", "Successful connection, port: {}, speed: {}",///       conn_info.port, conn_info.speed);// debug!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")// debug!(target: "my_target", "a {} event", "log")// debug!("a {} event", "log")/// Logs a message at the debug level./// use log::debug;/// # struct Position { x: f32, y: f32 }/// let pos = Position { x: 3.234, y: -1.223 };/// debug!("New position: x: {}, y: {}", pos.x, pos.y);/// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);// trace!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")// trace!(target: "my_target", "a {} event", "log")// trace!("a {} event", "log")/// Logs a message at the trace level./// use log::trace;/// trace!("Position is: x: {}, y: {}", pos.x, pos.y);/// trace!(target: "app_events", "x is {} and y is {}",///        if pos.x >= 0.0 { "positive" } else { "negative" },///        if pos.y >= 0.0 { "positive" } else { "negative" });log_enabled/// Determines if a message logged at the specified level in that module will/// be logged./// This can be used to avoid expensive computation of log message arguments if/// the message would be ignored anyway./// use log::Level::Debug;/// use log::{debug, log_enabled};/// if log_enabled!(Debug) {///     let data = expensive_call();///     debug!("expensive debug data: {} {}", data.x, data.y);/// if log_enabled!(target: "Global", Debug) {///    let data = expensive_call();///    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);/// # struct Data { x: u32, y: u32 }/// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }__log_key__log_value__log_value_sval__log_value_serde__log_value_error// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT// These macros use a pattern of #[cfg]s to produce nicer error// messages when log features aren't availablelevel_tokenlevel_bytes_tokenslevel_variant_tokenslevel_filter_tokenlevel_filter_bytes_tokenslevel_filter_variant_tokenstest_level_ser_detest_level_case_insensitivetest_level_de_bytestest_level_de_variant_indextest_level_de_errortest_level_filter_ser_detest_level_filter_case_insensitivetest_level_filter_de_bytestest_level_filter_de_variant_indextest_level_filter_de_error// The Deserialize impls are handwritten to be case insensitive using FromStr./// Most recently used/// Least recently used/// First unused/// Number of occupied slotsLruSlab/// A random-access table that maintains an LRU list in constant time/// Create an empty [`LruSlab`]/// Create an [`LruSlab`] that can store at least `capacity` elements without reallocating/// Whether no elements are stored/// Number of elements stored/// Number of elements that can be stored without reallocatingvacant_key/// The slot that will be returned by the next call to `insert`, unless `remove` is called first/// Insert a value, returning the slot it was stored in/// The returned slot is marked as the most recently used.lru/// Get the least recently used slot, if any/// Remove the element stored in `slot`, returning it/// Mark `slot` as the most recently used and access it uniquely/// Access `slot` without marking it as most recently used/// Access `slot` uniquely without marking it as most recently used/// Walk the container from most to least recently used/// Remove a slot from the freelist/// Mark `slot` as the most recently usedlink_at_head/// Add a link to the head of the list/// Remove a link from anywhere in the list/// Next slot in the LRU or free list/// Previous slot in the LRU list; NONE when freeIterState/// Iterator over elements of an [`LruSlab`], from most to least recently used/// Iterator over mutable elements of an [`LruSlab`], from most to least recently usedlru_orderslot_reuseiter_reverse//! Pre-allocated storage with constant-time LRU trackingMacAddressMacAddressErrorInterfaceAddressMacAddressIterator/// An iterator over all available MAC addresses on the system./// Creates a new `MacAddressIterator`.filter_macsPIP_ADAPTER_ADDRESSES_buffer// So we don't UAF during iteration./// Signifies an internal API error has occurred./// Possible errors when attempting to retrieve a MAC address./// Eventually will expose more detailed error information.MacParseError/// Parsing of the MAC address contained an invalid digit./// The MAC address did not have the correct length./// An error that may occur when parsing a MAC address string./// Contains the individual bytes of the MAC address./// Creates a new `MacAddress` struct from the given bytes.get_mac_address/// Calls the OS-specific function for retrieving the MAC address of the first/// network device containing one, ignoring local-loopback.mac_address_by_name/// Attempts to look up the MAC address of an interface via the specified name./// **NOTE**: On Windows, this uses the `FriendlyName` field of the adapter, which/// is the same name shown in the "Network Connections" Control Panel screen.name_by_mac_address/// Attempts to look up the interface name via MAC address./// Returns the array of MAC address bytes.parse_str_colonparse_str_hyphenparse_str_no_sepparse_invalid_lengthparse_invalid_digitparse_invalid_separator//! `mac_address` provides a cross platform way to retrieve the MAC address of//! network hardware. See [the Wikipedia//! entry](https://en.wikipedia.org/wiki/MAC_address) for more information.//! Supported platforms: Linux, Windows, MacOS, FreeBSD/// Uses the `getifaddrs` call to retrieve a list of network interfaces on the/// host device and returns the first MAC address listed that isn't/// local-loopback or if a name was specified, that name.get_ifname/// Uses bindings to the `Iphlpapi.h` Windows header to fetch the interface/// devices list with/// [GetAdaptersAddresses][https://msdn.microsoft.com/en-us/library/windows/desktop/aa365915(v=vs.85).aspx]/// then loops over the returned list until it finds a network device with a MAC/// address, and returns it./// If it fails to find a device, it returns a `NoDevicesFound` error./// Copy over the 6 MAC address bytes to the buffer.round0round1round2round3roundtail//! LoongArch64 assembly backendRCop_fop_gop_hop_iSTATE_INIT// TODO: remove `allow` on deprecation of `md5-asm`Md5Core/// Core MD5 hasher state./// MD5 hasher state.//! An implementation of the [MD5][1] cryptographic hash algorithm.//! use md5::{Md5, Digest};//! // create a Md5 hasher instance//! let mut hasher = Md5::new();//! // process input message//! hasher.update(b"hello world");//! // acquire hash digest in the form of GenericArray,//! // which in this case is equivalent to [u8; 16]//! let result = hasher.finalize();//! assert_eq!(result[..], hex!("5eb63bbbe01eeed093cb22bb8f5acdc3"));//! Also see [RustCrypto/hashes][2] readme.//! [1]: https://en.wikipedia.org/wiki/MD5//! [2]: https://github.com/RustCrypto/hashes/// A digest./// A context./// Create a context for computing a digest./// Consume data./// Finalize and return the digest./// Compute the digest of data.overflow_countoverflow_length//! The [MD5] hash function.//! let digest = md5::compute(b"abcdefghijklmnopqrstuvwxyz");//! assert_eq!(format!("{:x}", digest), "c3fcd3d76192e4007dfb496cca67e13b");//! ## Security Warning//! The package is provided for the purposes of interoperability with protocols//! and systems that mandate the use of MD5. However, MD5 should be considered//! [cryptographically broken and unsuitable for further use][VU836068].//! Collision attacks against MD5 are both practical and trivial, and//! [theoretical attacks against MD5 have been found][ACM1724151].//! [RFC6151] advises no new protocols to be designed with any MD5-based//! constructions, including HMAC-MD5.//! [MD5]: https://en.wikipedia.org/wiki/MD5//! [ACM1724151]: https://dl.acm.org/citation.cfm?id=1724151//! [RFC6151]: https://tools.ietf.org/html/rfc6151//! [VU836068]: https://www.kb.cert.org/vuls/id/836068// The implementation is based on:// https://people.csail.mit.edu/rivest/Md5.c// https://tools.ietf.org/html/rfc1321defrawmemchr_raw/// memchr, but using raw pointers to represent the haystack./// Pointers must be valid. See `One::find_raw`.memrchr_raw/// memrchr, but using raw pointers to represent the haystack./// Pointers must be valid. See `One::rfind_raw`.memchr2_raw/// memchr2, but using raw pointers to represent the haystack./// Pointers must be valid. See `Two::find_raw`.memrchr2_raw/// memrchr2, but using raw pointers to represent the haystack./// Pointers must be valid. See `Two::rfind_raw`.memchr3_raw/// memchr3, but using raw pointers to represent the haystack./// Pointers must be valid. See `Three::find_raw`.memrchr3_raw/// memrchr3, but using raw pointers to represent the haystack./// Pointers must be valid. See `Three::rfind_raw`.count_raw/// Count all matching bytes, but using raw pointers to represent the haystack./// Pointers must be valid. See `One::count_raw`./*!
Wrapper routines for `memchr` and friends.

These routines choose the best implementation at compile time. (This is
different from `x86_64` because it is expected that `neon` is almost always
available for `aarch64` targets.)
*//*!
Vector algorithms for the `aarch64` target.
*//// Finds all occurrences of a single byte in a haystack./// Create a new searcher that finds occurrences of the needle byte given./// This particular searcher is specialized to use neon vector instructions/// that typically make it quite fast./// If neon is unavailable in the current environment, then `None` is/// Create a new finder specific to neon vectors and routines without/// checking that neon is available./// Callers must guarantee that it is safe to execute `neon` instructions/// in the current environment./// Note that it is a common misconception that if one compiles for an/// `x86_64` target, then they therefore automatically have access to neon/// instructions. While this is almost always the case, it isn't true in/// 100% of cases./// Returns true when this implementation is available in the current/// When this is true, it is guaranteed that [`One::new`] will return/// a `Some` value. Similarly, when it is false, it is guaranteed that/// `One::new` will return a `None` value./// Note also that for the lifetime of a single program, if this returns/// true then it will always return true./// Return the first occurrence of one of the needle bytes in the given/// haystack. If no such occurrence exists, then `None` is returned./// The occurrence is reported as an offset into `haystack`. Its maximum/// value is `haystack.len() - 1`./// Return the last occurrence of one of the needle bytes in the given/// Counts all occurrences of this byte in the given haystack.find_raw/// Like `find`, but accepts and returns raw pointers./// When a match is found, the pointer returned is guaranteed to be/// `>= start` and `< end`./// This routine is useful if you're already using raw pointers and would/// like to avoid converting back to a slice before executing a search./// Note that callers may pass a pair of pointers such that `start >= end`./// In that case, `None` will always be returned.rfind_raw/// Like `rfind`, but accepts and returns raw pointers./// Like `count`, but accepts and returns raw pointers.find_raw_impl/// Execute a search using neon vectors and routines./// Same as [`One::find_raw`], except the distance between `start` and/// `end` must be at least the size of a neon vector (in bytes)./// (The target feature safety obligation is automatically fulfilled by/// virtue of being a method on `One`, which can only be constructed/// when it is safe to call `neon` routines.)rfind_raw_impl/// Same as [`One::rfind_raw`], except the distance between `start` andcount_raw_impl/// Execute a count using neon vectors and routines./// Same as [`One::count_raw`], except the distance between `start` andOneIter/// Returns an iterator over all occurrences of the needle byte in the/// given haystack./// The iterator returned implements `DoubleEndedIterator`. This means it/// can also be used to find occurrences in reverse order./// An iterator over all occurrences of a single byte in a haystack./// This iterator implements `DoubleEndedIterator`, which means it can also be/// used to find occurrences in reverse order./// This iterator is created by the [`One::iter`] method./// The lifetime parameters are as follows:/// * `'a` refers to the lifetime of the underlying [`One`] searcher./// * `'h` refers to the lifetime of the haystack being searched.Two/// Finds all occurrences of two bytes in a haystack./// That is, this reports matches of one of two possible bytes. For example,/// searching for `a` or `b` in `afoobar` would report matches at offsets `0`,/// `4` and `5`./// Create a new searcher that finds occurrences of the needle bytes given./// When this is true, it is guaranteed that [`Two::new`] will return/// `Two::new` will return a `None` value./// Same as [`Two::find_raw`], except the distance between `start` and/// virtue of being a method on `Two`, which can only be constructed/// Same as [`Two::rfind_raw`], except the distance between `start` andTwoIter/// Returns an iterator over all occurrences of the needle bytes in the/// An iterator over all occurrences of two possible bytes in a haystack./// This iterator is created by the [`Two::iter`] method./// * `'a` refers to the lifetime of the underlying [`Two`] searcher.Three/// Finds all occurrences of three bytes in a haystack./// That is, this reports matches of one of three possible bytes. For example,/// searching for `a`, `b` or `o` in `afoobar` would report matches at offsets/// `0`, `2`, `3`, `4` and `5`./// When this is true, it is guaranteed that [`Three::new`] will return/// `Three::new` will return a `None` value./// Same as [`Three::find_raw`], except the distance between `start` and/// virtue of being a method on `Three`, which can only be constructed/// Same as [`Three::rfind_raw`], except the distance between `start` andThreeIter/// An iterator over all occurrences of three possible bytes in a haystack./// This iterator is created by the [`Three::iter`] method./// * `'a` refers to the lifetime of the underlying [`Three`] searcher.define_memchr_quickcheckforward_onereverse_onecount_oneforward_tworeverse_twoforward_threereverse_three/*!
This module defines 128-bit vector implementations of `memchr` and friends.

The main types in this module are [`One`], [`Two`] and [`Three`]. They are for
searching for one, two or three distinct bytes, respectively, in a haystack.
Each type also has corresponding double ended iterators. These searchers are
typically much faster than scalar routines accomplishing the same task.

The `One` searcher also provides a [`One::count`] routine for efficiently
counting the number of times a single byte occurs in a haystack. This is
useful, for example, for counting the number of lines in a haystack. This
routine exists because it is usually faster, especially with a high match
count, then using [`One::find`] repeatedly. ([`OneIter`] specializes its
`Iterator::count` implementation to use this routine.)

Only one, two and three bytes are supported because three bytes is about
the point where one sees diminishing returns. Beyond this point and it's
probably (but not necessarily) better to just use a simple `[bool; 256]` array
or similar. However, it depends mightily on the specific work-load and the
expected match frequency.
*/packedpair/*!
Algorithms for the `aarch64` target using 128-bit vectors via NEON.
*//// A "packed pair" finder that uses 128-bit vector operations./// This finder picks two bytes that it believes have high predictive power/// for indicating an overall match of a needle. Depending on whether/// `Finder::find` or `Finder::find_prefilter` is used, it reports offsets/// where the needle matches or could match. In the prefilter case, candidates/// are reported whenever the [`Pair`] of bytes given matches./// Create a new pair searcher. The searcher returned can either report/// exact matches of `needle` or act as a prefilter and report candidate/// positions of `needle`./// If neon is unavailable in the current environment or if a [`Pair`]/// could not be constructed from the needle given, then `None` iswith_pair/// Create a new "packed pair" finder using the pair of bytes given./// This constructor permits callers to control precisely which pair of/// bytes is used as a predicate.with_pair_impl/// Create a new `Finder` specific to neon vectors and routines./// Same as the safety for `packedpair::Finder::new`, and callers must also/// ensure that neon is available./// When this is true, it is guaranteed that [`Finder::with_pair`] will/// return a `Some` value. Similarly, when it is false, it is guaranteed/// that `Finder::with_pair` will return a `None` value. Notice that this/// does not guarantee that [`Finder::new`] will return a `Finder`. Namely,/// even when `Finder::is_available` is true, it is not guaranteed that a/// valid [`Pair`] can be found from the needle given./// When `haystack.len()` is less than [`Finder::min_haystack_len`].find_prefilterfind_impl/// virtue of being a method on `Finder`, which can only be constructedfind_prefilter_impl/// Execute a prefilter search using neon vectors and routines./// Returns the pair of offsets (into the needle) used to check as a/// predicate before confirming whether a needle exists at a particularmin_haystack_len/// Returns the minimum haystack length that this `Finder` can search./// Using a haystack with length smaller than this in a search will result/// in a panic. The reason for this restriction is that this finder is/// meant to be a low-level component that is part of a larger substring/// strategy. In that sense, it avoids trying to handle all cases and/// instead only handles the cases that it can handle very well.define_substring_forward_quickcheckforward_substringforward_packedpairforward_packedpair_prefilter/*!
A 128-bit vector implementation of the "packed pair" SIMD algorithm.

The "packed pair" algorithm is based on the [generic SIMD] algorithm. The main
difference is that it (by default) uses a background distribution of byte
frequencies to heuristically select the pair of bytes to search for.

[generic SIMD]: http://0x80.pl/articles/simd-strfind.html#first-and-last
*//// The number of bytes in a single `usize` value.USIZE_ALIGN/// The bits that must be zero for a `*const usize` to be properly aligned.LOOP_BYTES/// The number of bytes we examine per each iteration of our search loop./// Create a new searcher that finds occurrences of the byte given./// A test-only routine so that we can bundle a bunch of quickcheck/// properties into a single macro. Basically, this provides a constructor/// that makes it identical to most other memchr implementations, which/// have fallible constructors./// Return the first occurrence of the needle in the given haystack. If no/// such occurrence exists, then `None` is returned./// value for a non-empty haystack is `haystack.len() - 1`./// Return the last occurrence of the needle in the given haystack. If no/// Counts all occurrences of this byte in the given haystack represented/// by raw pointers./// In that case, `0` will always be returned.has_needle/// The underlying memchr searcher./// Generic iterator implementation./// Create a new searcher that finds occurrences of the two needle bytes/// Returns an iterator over all occurrences of one of the needle bytes in/// the given haystack.v3/// Create a new searcher that finds occurrences of the three needle byteshas_zero_byte/// Return `true` if `x` contains any zero byte./// That is, this routine treats `x` as a register of 8-bit lanes and returns/// true when any of those lanes is `0`./// From "Matters Computational" by J. Arndt./// Repeat the given byte into a word size number. That is, every 8 bits/// is equivalent to the given byte. For example, if `b` is `\x4E` or/// `01001110` in binary, then the returned value on a 32-bit system would be:/// `01001110_01001110_01001110_01001110`.TestResultpropdouble_ended_takenaive1_iternaive2_iternaive3_iterregression_double_ended_iterator// This was found by quickcheck in the course of refactoring this crate// after memchr 2.5.0.regression_count_new_lines// This regression test was caught by ripgrep's test suite on i686 when// upgrading to memchr 2.6. Namely, something about the \x0B bytes here// screws with the SWAR counting approach I was using. This regression test// prompted me to remove the SWAR counting approach and just replace it// with a byte-at-a-time loop.regression_big_endian1// A test[1] that failed on some big endian targets after a perf// improvement was merged[2].// At first it seemed like the test suite somehow missed the regression,// but in actuality, CI was not running tests with `cross` but instead with// `cargo` specifically. This is because those steps were using `cargo`// instead of `${{ env.CARGO }}`. So adding this regression test doesn't// really help catch that class of failure, but we add it anyway for good// measure.// [1]: https://github.com/BurntSushi/memchr/issues/152// [2]: https://github.com/BurntSushi/memchr/pull/151regression_big_endian2// Interestingly, I couldn't get `regression_big_endian1` to fail for me// on the `powerpc64-unknown-linux-gnu` target. But I found another case// through quickcheck that does./*!
Provides architecture independent implementations of `memchr` and friends.

The main types in this module are [`One`], [`Two`] and [`Three`]. They are for
searching for one, two or three distinct bytes, respectively, in a haystack.
Each type also has corresponding double ended iterators. These searchers
are typically slower than hand-coded vector routines accomplishing the same
task, but are also typically faster than naive scalar code. These routines
effectively work by treating a `usize` as a vector of 8-bit lanes, and thus
achieves some level of data parallelism even without explicit vector support.

The `One` searcher also provides a [`One::count`] routine for efficiently
counting the number of times a single byte occurs in a haystack. This is
useful, for example, for counting the number of lines in a haystack. This
routine exists because it is usually faster, especially with a high match
count, then using [`One::find`] repeatedly. ([`OneIter`] specializes its
`Iterator::count` implementation to use this routine.)

Only one, two and three bytes are supported because three bytes is about
the point where one sees diminishing returns. Beyond this point and it's
probably (but not necessarily) better to just use a simple `[bool; 256]` array
or similar. However, it depends mightily on the specific work-load and the
expected match frequency.
*/shiftortwowayis_suffix/// Returns true if and only if `needle` is a suffix of `haystack`./*!
Contains architecture independent routines.

These routines are often used as a "fallback" implementation when the more
specialized architecture dependent routines are unavailable.
*/RANKdefault_rank/// An architecture independent "packed pair" finder./// This finder picks two bytes that it believes have high predictive power for/// indicating an overall match of a needle. At search time, it reports offsets/// where the needle could match based on whether the pair of bytes it chose/// This is architecture independent because it utilizes `memchr` to find the/// occurrence of one of the bytes in the pair, and then checks whether the/// second byte matches. If it does, in the case of [`Finder::find_prefilter`],/// the location at which the needle could match is returned./// It is generally preferred to use architecture specific routines for a/// "packed pair" prefilter, but this can be a useful fallback when the/// architecture independent routines are unavailable./// Create a new prefilter that reports possible locations where the given/// needle matches./// Create a new prefilter using the pair given./// If the prefilter could not be constructed, then `None` is returned./// Run this finder on the given haystack as a prefilter./// If a candidate match is found, then an offset where the needle *could*/// begin in the haystack is returned.index1index2/// A pair of byte offsets into a needle to use as a predicate./// This pair is used as a predicate to quickly filter out positions in a/// haystack in which a needle cannot match. In some cases, this pair can even/// be used in vector algorithms such that the vector algorithm only switches/// over to scalar code once this pair has been found./// A pair of offsets can be used in both substring search implementations and/// in prefilters. The former will report matches of a needle in a haystack/// where as the latter will only report possible matches of a needle./// The offsets are limited each to a maximum of 255 to keep memory usage low./// Moreover, it's rarely advantageous to create a predicate using offsets/// greater than 255 anyway./// The only guarantee enforced on the pair of offsets is that they are not/// equivalent. It is not necessarily the case that `index1 < index2` for/// example. By convention, `index1` corresponds to the byte in the needle/// that is believed to be most the predictive. Note also that because of the/// requirement that the indices be both valid for the needle used to build/// the pair and not equal, it follows that a pair can only be constructed for/// needles with length at least 2./// Create a new pair of offsets from the given needle./// If a pair could not be created (for example, if the needle is too/// short), then `None` is returned./// This chooses the pair in the needle that is believed to be as/// predictive of an overall match of the needle as possible.HeuristicFrequencyRankwith_ranker/// Create a new pair of offsets from the given needle and ranker./// This permits the caller to choose a background frequency distribution/// with which bytes are selected. The idea is to select a pair of bytes/// that is believed to strongly predict a match in the haystack. This/// usually means selecting bytes that occur rarely in a haystack.with_indices/// Create a new pair using the offsets given for the needle given./// This bypasses any sort of heuristic process for choosing the offsets/// and permits the caller to choose the offsets themselves./// Indices are limited to valid `u8` values so that a `Pair` uses less/// memory. It is not possible to create a `Pair` with offsets bigger than/// `u8::MAX`. It's likely that such a thing is not needed, but if it is,/// it's suggested to build your own bespoke algorithm because you're/// likely working on a very niche case. (File an issue if this suggestion/// does not make sense to you.)/// Returns the first offset of the pair./// Returns the second offset of the pair.rank/// Return the heuristic frequency rank of the given byte. A lower rank/// means the byte is believed to occur less frequently in the haystack./// Some uses of this heuristic may treat arbitrary absolute rank values as/// significant. For example, an implementation detail in this crate may/// determine that heuristic prefilters are inappropriate if every byte in/// the needle has a "high" rank./// This trait allows the user to customize the heuristic used to determine the/// relative frequency of a given byte in the dataset being searched./// The use of this trait can have a dramatic impact on performance depending/// on the type of data being searched. The details of why are explained in the/// docs of [`crate::memmem::Prefilter`]. To summarize, the core algorithm uses/// a prefilter to quickly identify candidate matches that are later verified/// more slowly. This prefilter is implemented in terms of trying to find/// `rare` bytes at specific offsets that will occur less frequently in the/// dataset. While the concept of a `rare` byte is similar for most datasets,/// there are some specific datasets (like binary executables) that have/// dramatically different byte distributions. For these datasets customizing/// the byte frequency heuristic can have a massive impact on performance, and/// might even need to be done at runtime./// The default implementation of `HeuristicFrequencyRank` reads from the/// static frequency table defined in `src/memmem/byte_frequencies.rs`. This/// is optimal for most inputs, so if you are unsure of the impact of using a/// custom `HeuristicFrequencyRank` you should probably just use the default./// use memchr::{///     arch::all::packedpair::HeuristicFrequencyRank,///     memmem::FinderBuilder,/// /// A byte-frequency table that is good for scanning binary executables./// struct Binary;/// impl HeuristicFrequencyRank for Binary {///     fn rank(&self, byte: u8) -> u8 {///         const TABLE: [u8; 256] = [///             255, 128, 61, 43, 50, 41, 27, 28, 57, 15, 21, 13, 24, 17, 17,///             89, 58, 16, 11, 7, 14, 23, 7, 6, 24, 9, 6, 5, 9, 4, 7, 16,///             68, 11, 9, 6, 88, 7, 4, 4, 23, 9, 4, 8, 8, 5, 10, 4, 30, 11,///             9, 24, 11, 5, 5, 5, 19, 11, 6, 17, 9, 9, 6, 8,///             48, 58, 11, 14, 53, 40, 9, 9, 254, 35, 3, 6, 52, 23, 6, 6, 27,///             4, 7, 11, 14, 13, 10, 11, 11, 5, 2, 10, 16, 12, 6, 19,///             19, 20, 5, 14, 16, 31, 19, 7, 14, 20, 4, 4, 19, 8, 18, 20, 24,///             1, 25, 19, 58, 29, 10, 5, 15, 20, 2, 2, 9, 4, 3, 5,///             51, 11, 4, 53, 23, 39, 6, 4, 13, 81, 4, 186, 5, 67, 3, 2, 15,///             0, 0, 1, 3, 2, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0,///             12, 2, 1, 1, 3, 1, 1, 1, 6, 1, 2, 1, 3, 1, 1, 2, 9, 1, 1, 0,///             2, 2, 4, 4, 11, 6, 7, 3, 6, 9, 4, 5,///             46, 18, 8, 18, 17, 3, 8, 20, 16, 10, 3, 7, 175, 4, 6, 7, 13,///             3, 7, 3, 3, 1, 3, 3, 10, 3, 1, 5, 2, 0, 1, 2,///             16, 3, 5, 1, 6, 1, 1, 2, 58, 20, 3, 14, 12, 2, 1, 3, 16, 3, 5,///             8, 3, 1, 8, 6, 17, 6, 5, 3, 8, 6, 13, 175,///         ];///         TABLE[byte as usize]/// // Create a new finder with the custom heuristic./// let finder = FinderBuilder::new()///     .build_forward_with_ranker(Binary, b"\x00\x00\xdd\xdd");/// // Find needle with custom heuristic./// assert!(finder.find(b"\x00\x00\x00\xdd\xdd").is_some());DefaultFrequencyRank/// The default byte frequency heuristic that is good for most haystacks./// This permits passing any implementation of `HeuristicFrequencyRank` as a/// borrowed version of itself./*!
Provides an architecture independent implementation of the "packed pair"
algorithm.

The "packed pair" algorithm is based on the [generic SIMD] algorithm. The main
difference is that it (by default) uses a background distribution of byte
frequencies to heuristically select the pair of bytes to search for. Note that
this module provides an architecture independent version that doesn't do as
good of a job keeping the search for candidates inside a SIMD hot path. It
however can be good enough in many circumstances.

[generic SIMD]: http://0x80.pl/articles/simd-strfind.html#first-and-last
*//// The actual hash./// The factor needed to multiply a byte by in order to subtract it from/// the hash. It is defined to be 2^(n-1) (using wrapping exponentiation),/// where n is the length of the needle. This is how we "remove" a byte/// from the hash once the hash window rolls past it./// A forward substring searcher using the Rabin-Karp algorithm./// Note that, as a lower level API, a `Finder` does not have access to the/// needle it was constructed with. For this reason, executing a search/// with a `Finder` requires passing both the needle and the haystack,/// where the needle is exactly equivalent to the one given to the `Finder`/// at construction time. This design was chosen so that callers can have/// more precise control over where and how many times a needle is stored./// For example, in cases where Rabin-Karp is just one of several possible/// substring search algorithms./// Create a new Rabin-Karp forward searcher for the given `needle`./// The needle may be empty. The empty needle matches at every byte offset./// Note that callers must pass the same needle to all search calls using/// this `Finder`./// Return the first occurrence of the `needle` in the `haystack`/// given. If no such occurrence exists, then `None` is returned./// The `needle` provided must match the needle given to this finder at/// construction time./// The maximum value this can return is `haystack.len()`, which can only/// occur when the needle and haystack both have length zero. Otherwise,/// for non-empty haystacks, the maximum value is `haystack.len() - 1`./// `>= start` and `<= end`. The pointer returned is only ever equivalent/// to `end` when both the needle and haystack are empty. (That is, the/// empty string matches the empty string.)/// Note that `start` and `end` below refer to both pairs of pointers given/// to this routine. That is, the conditions apply to both `hstart`/`hend`/// and `nstart`/`nend`.FinderRev/// A reverse substring searcher using the Rabin-Karp algorithm./// Create a new Rabin-Karp reverse searcher for the given `needle`./// Return the last occurrence of the `needle` in the `haystack`is_fast/// Whether RK is believed to be very fast for the given needle/haystack./// A Rabin-Karp hash. This might represent the hash of a needle, or the hash/// of a rolling window in the haystack./// Create a new hash that represents the empty string./// Create a new hash from the bytes given for use in forward searches./// The given pointers must be valid to read from within their range./// Create a new hash from the bytes given for use in reverse searches./// Add 'new' and remove 'old' from this hash. The given needle hash should/// correspond to the hash computed for the needle being searched for./// This is meant to be used when the rolling window of the haystack is/// advanced./// Add a byte to this hash./// Remove a byte from this hash. The given needle hash should correspond/// to the hash computed for the needle being searched for./// Returns true when `x[i] == y[i]` for all `0 <= i < n`./// We forcefully don't inline this to hint at the compiler that it is unlikely/// to be called. This causes the inner rabinkarp loop above to be a bit/// tighter and leads to some performance improvement. See the/// memmem/krate/prebuilt/sliceslice-words/words benchmark./// Same as `crate::arch::all::is_equal_raw`.define_substring_reverse_quickcheck/*!
An implementation of the [Rabin-Karp substring search algorithm][rabinkarp].

Rabin-Karp works by creating a hash of the needle provided and then computing
a rolling hash for each needle sized window in the haystack. When the rolling
hash matches the hash of the needle, a byte-wise comparison is done to check
if a match exists. The worst case time complexity of Rabin-Karp is `O(m *
n)` where `m ~ len(needle)` and `n ~ len(haystack)`. Its worst case space
complexity is constant.

The main utility of Rabin-Karp is that the searcher can be constructed very
quickly with very little memory. This makes it especially useful when searching
for small needles in small haystacks, as it might finish its search before a
beefier algorithm (like Two-Way) even starts.

[rabinkarp]: https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm
*//*
(This was the comment I wrote for this module originally when it was not
exposed. The comment still looks useful, but it's a bit in the weeds, so it's
not public itself.)

This module implements the classical Rabin-Karp substring search algorithm,
with no extra frills. While its use would seem to break our time complexity
guarantee of O(m+n) (RK's time complexity is O(mn)), we are careful to only
ever use RK on a constant subset of haystacks. The main point here is that
RK has good latency properties for small needles/haystacks. It's very quick
to compute a needle hash and zip through the haystack when compared to
initializing Two-Way, for example. And this is especially useful for cases
where the haystack is just too short for vector instructions to do much good.

The hashing function used here is the same one recommended by ESMAJ.

Another choice instead of Rabin-Karp would be Shift-Or. But its latency
isn't quite as good since its preprocessing time is a bit more expensive
(both in practice and in theory). However, perhaps Shift-Or has a place
somewhere else for short patterns. I think the main problem is that it
requires space proportional to the alphabet and the needle. If we, for
example, supported needles up to length 16, then the total table size would be
len(alphabet)*size_of::<u16>()==512 bytes. Which isn't exactly small, and it's
probably bad to put that on the stack. So ideally, we'd throw it on the heap,
but we'd really like to write as much code without using alloc/std as possible.
But maybe it's worth the special casing. It's a TODO to benchmark.

Wikipedia has a decent explanation, if a bit heavy on the theory:
https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm

But ESMAJ provides something a bit more concrete:
http://www-igm.univ-mlv.fr/~lecroq/string/node5.html

Finally, aho-corasick uses Rabin-Karp for multiple pattern match in some cases:
https://github.com/BurntSushi/aho-corasick/blob/3852632f10587db0ff72ef29e88d58bf305a0946/src/packed/rabinkarp.rs
*//// The type of our mask./// While we don't expose anyway to configure this in the public API, if one/// really needs less memory usage or support for longer needles, then it is/// suggested to copy the code from this module and modify it to fit your/// needs. The code below is written to be correct regardless of whether Mask/// is a u8, u16, u32, u64 or u128.needle_len/// A forward substring searcher using the Shift-Or algorithm.MAX_NEEDLE_LEN/// Create a new Shift-Or forward searcher for the given `needle`./// Return the first occurrence of the needle given to `Finder::new` in/// the `haystack` given. If no such occurrence exists, then `None` is/// Unlike most other substring search implementations in this crate, this/// finder does not require passing the needle at search time. A match can/// be determined without the needle at all since the required information/// is already encoded into this finder at construction time./*!
An implementation of the [Shift-Or substring search algorithm][shiftor].

[shiftor]: https://en.wikipedia.org/wiki/Bitap_algorithm
*/PreTwoWay/// A forward substring searcher that uses the Two-Way algorithm./// A reverse substring searcher that uses the Two-Way algorithm.ApproximateByteSet/// A small bitset used as a quick prefilter (in addition to any prefilter/// given by the caller). Namely, a bit `i` is set if and only if `b%64==i`/// for any `b == needle[i]`./// When used as a prefilter, if the last byte at the current candidate/// position is NOT in this set, then we can skip that entire candidate/// position (the length of the needle). This is essentially the shift/// trick found in Boyer-Moore, but only applied to bytes that don't appear/// in the needle./// N.B. This trick was inspired by something similar in std's/// implementation of Two-Way.critical_pos/// A critical position in needle. Specifically, this position corresponds/// to beginning of either the minimal or maximal suffix in needle. (N.B./// See SuffixType below for why "minimal" isn't quite the correct word/// here.)/// This is the position at which every search begins. Namely, search/// starts by scanning text to the right of this position, and only if/// there's a match does the text to the left of this position get scanned./// The amount we shift by in the Two-Way search algorithm. This/// corresponds to the "small period" and "large period" cases./// An implementation of the TwoWay substring search algorithm./// This searcher supports forward and reverse search, although not/// simultaneously. It runs in `O(n + m)` time and `O(1)` space, where/// `n ~ len(needle)` and `m ~ len(haystack)`./// The implementation here roughly matches that which was developed by/// Crochemore and Perrin in their 1991 paper "Two-way string-matching." The/// changes in this implementation are 1) the use of zero-based indices, 2) a/// heuristic skip table based on the last byte (borrowed from Rust's standard/// library) and 3) the addition of heuristics for a fast skip loop. For (3),/// callers can pass any kind of prefilter they want, but usually it's one/// based on a heuristic that uses an approximate background frequency of bytes/// to choose rare bytes to quickly look for candidate match positions. Note/// though that currently, this prefilter functionality is not exposed directly/// in the public API. (File an issue if you want it and provide a use case/// please.)/// The heuristic for fast skipping is automatically shut off if it's/// detected to be ineffective at search time. Generally, this only occurs in/// pathological cases. But this is generally necessary in order to preserve/// a `O(n + m)` time bound./// The code below is fairly complex and not obviously correct at all. It's/// likely necessary to read the Two-Way paper cited above in order to fully/// grok this code. The essence of it is:/// 1. Do something to detect a "critical" position in the needle./// 2. For the current position in the haystack, look if `needle[critical..]`/// matches at that position./// 3. If so, look if `needle[..critical]` matches./// 4. If a mismatch occurs, shift the search by some amount based on the/// critical position and a pre-computed shift./// This type is wrapped in the forward and reverse finders that expose/// consistent forward or reverse APIs./// Create a searcher that finds occurrences of the given `needle`./// An empty `needle` results in a match at every position in a haystack,/// including at `haystack.len()`./// Returns the first occurrence of `needle` in the given `haystack`, or/// `None` if no such occurrence could be found./// The `needle` given must be the same as the `needle` provided to/// [`Finder::new`].find_with_prefilter/// This is like [`Finder::find`], but it accepts a prefilter for/// accelerating searches./// Currently this is not exposed in the public API because, at the time/// of writing, I didn't want to spend time thinking about how to expose/// the prefilter infrastructure (if at all). If you have a compelling use/// case for exposing this routine, please create an issue. Do *not* open/// a PR that just exposes `Pre` and friends. Exporting this routine will/// require API design.find_small_impfind_large_imp// Each of the two search implementations below can be accelerated by a// prefilter, but it is not always enabled. To avoid its overhead when// its disabled, we explicitly inline each search implementation based on// whether a prefilter will be used or not. The decision on which to use// is made in the parent meta searcher./// Returns the last occurrence of `needle` in the given `haystack`, or/// [`FinderRev::new`].rfind_small_imprfind_large_impLarge/// A representation of the amount we're allowed to shift by during Two-Way/// When computing a critical factorization of the needle, we find the position/// of the critical factorization by finding the needle's maximal (or minimal)/// suffix, along with the period of that suffix. It turns out that the period/// of that suffix is a lower bound on the period of the needle itself./// This lower bound is equivalent to the actual period of the needle in/// some cases. To describe that case, we denote the needle as `x` where/// `x = uv` and `v` is the lexicographic maximal suffix of `v`. The lower/// bound given here is always the period of `v`, which is `<= period(x)`. The/// case where `period(v) == period(x)` occurs when `len(u) < (len(x) / 2)` and/// where `u` is a suffix of `v[0..period(v)]`./// This case is important because the search algorithm for when the/// periods are equivalent is slightly different than the search algorithm/// for when the periods are not equivalent. In particular, when they aren't/// equivalent, we know that the period of the needle is no less than half its/// length. In this case, we shift by an amount less than or equal to the/// period of the needle (determined by the maximum length of the components/// of the critical factorization of `x`, i.e., `max(len(u), len(v))`)../// The above two cases are represented by the variants below. Each entails/// a different instantiation of the Two-Way search algorithm./// N.B. If we could find a way to compute the exact period in all cases,/// then we could collapse this case analysis and simplify the algorithm. The/// Two-Way paper suggests this is possible, but more reading is required to/// grok why the authors didn't pursue that path./// Compute the shift for a given needle in the forward direction./// This requires a lower bound on the period and a critical position./// These can be computed by extracting both the minimal and maximal/// lexicographic suffixes, and choosing the right-most starting position./// The lower bound on the period is then the period of the chosen suffix./// Compute the shift for a given needle in the reverse direction./// lexicographic suffixes, and choosing the left-most starting position./// The starting position of this suffix./// If this is a forward suffix, then `&bytes[pos..]` can be used. If this/// is a reverse suffix, then `&bytes[..pos]` can be used. That is, for/// forward suffixes, this is an inclusive starting position, where as for/// reverse suffixes, this is an exclusive ending position./// The period of this suffix./// Note that this is NOT necessarily the period of the string from which/// this suffix comes from. (It is always less than or equal to the period/// of the original string.)/// A suffix extracted from a needle along with its period.SuffixKindMinimal/// Extract the smallest lexicographic suffix from a string./// Technically, this doesn't actually pick the smallest lexicographic/// suffix. e.g., Given the choice between `a` and `aa`, this will choose/// the latter over the former, even though `a < aa`. The reasoning for/// this isn't clear from the paper, but it still smells like a minimal/// suffix.Maximal/// Extract the largest lexicographic suffix from a string./// Unlike `Minimal`, this really does pick the maximum suffix. e.g., Given/// the choice between `z` and `zz`, this will choose the latter over the/// former./// The kind of suffix to extract.SuffixOrdering/// This occurs when the given candidate byte indicates that the candidate/// suffix is better than the current maximal (or minimal) suffix. That is,/// the current candidate suffix should supplant the current maximal (or/// minimal) suffix./// This occurs when the given candidate byte excludes the candidate suffix/// from being better than the current maximal (or minimal) suffix. That/// is, the current candidate suffix should be dropped and the next one/// should be considered./// This occurs when no decision to accept or skip the candidate suffix/// can be made, e.g., when corresponding bytes are equivalent. In this/// case, the next corresponding bytes should be compared./// The result of comparing corresponding bytes between two suffixes./// Returns true if and only if the given candidate byte indicates that/// it should replace the current suffix as the maximal (or minimal)/// A bitset used to track whether a particular byte exists in a needle or not./// Namely, bit 'i' is set if and only if byte%64==i for any byte in the/// needle. If a particular byte in the haystack is NOT in this set, then one/// can conclude that it is also not in the needle, and thus, one can advance/// in the haystack by needle.len() bytes./// Create a new set from the given needle./// Return true if and only if the given byte might be in this set. This/// may return a false positive, but will never return a false negative.get_suffix_forward/// Convenience wrapper for computing the suffix as a byte string.get_suffix_reverse/// Convenience wrapper for computing the reverse suffix as a byte string.suffixes/// Return all of the non-empty suffixes in the given byte string.naive_maximal_suffix_forward/// Return the lexicographically maximal suffix of the given byte string.naive_maximal_suffix_reverse/// Return the lexicographically maximal suffix of the reverse of the givensuffix_forwardsuffix_reverseregression_rev_small_period// This is a regression test caught by quickcheck that exercised a bug in// the reverse small period handling. The bug was that we were using 'if j// == shift' to determine if a match occurred, but the correct guard is 'if// j >= shift', which matches the corresponding guard in the forward impl./*!
An implementation of the [Two-Way substring search algorithm][two-way].

[`Finder`] can be built for forward searches, while [`FinderRev`] can be built
for reverse searches.

Two-Way makes for a nice general purpose substring search algorithm because of
its time and space complexity properties. It also performs well in practice.
Namely, with `m = len(needle)` and `n = len(haystack)`, Two-Way takes `O(m)`
time to create a finder, `O(1)` space and `O(n)` search time. In other words,
the preprocessing step is quick, doesn't require any heap memory and the worst
case search time is guaranteed to be linear in the haystack regardless of the
size of the needle.

While vector algorithms will usually beat Two-Way handedly, vector algorithms
also usually have pathological or edge cases that are better handled by Two-Way.
Moreover, not all targets support vector algorithms or implementations for them
simply may not exist yet.

Two-Way can be found in the `memmem` implementations in at least [GNU libc] and
[musl].

[two-way]: https://en.wikipedia.org/wiki/Two-way_string-matching_algorithm
[GNU libc]: https://www.gnu.org/software/libc/
[musl]: https://www.musl-libc.org/
*/MoveMaskLOOP_SIZEneedle1/// Returns the needle given to `One::new`./// Return a pointer to the first occurrence of the needle in the given/// Return a pointer to the last occurrence of the needle in the given/// Return a count of all matching bytes in the given haystack.search_chunk/// Search `V::BYTES` starting at `cur` via an unaligned load./// `mask_to_offset` should be a function that converts a `movemask` to/// an offset such that `cur.add(offset)` corresponds to a pointer to the/// match location if one is found. Generally it is expected to use either/// `mask_to_first_offset` or `mask_to_last_offset`, depending on whether/// one is implementing a forward or reverse search, respectively./// `cur` must be a valid pointer and it must be valid to do an unaligned/// load of size `V::BYTES` at `cur`./// Returns the first needle given to `Two::new`.needle2/// Returns the second needle given to `Two::new`./// Return a pointer to the first occurrence of one of the needles in the/// given haystack. If no such occurrence exists, then `None` is returned./// Returns the first needle given to `Three::new`./// Returns the second needle given to `Three::new`.needle3/// Returns the third needle given to `Three::new`.original_start/// The original starting point into the haystack. We use this to convert/// pointers to offsets./// The current starting point into the haystack. That is, where the next/// search will begin./// The current ending point into the haystack. That is, where the next/// reverse search will begin./// A marker for tracking the lifetime of the start/cur_start/cur_end/// pointers above, which all point into the haystack./// An iterator over all occurrences of a set of bytes in a haystack./// This iterator implements the routines necessary to provide a/// `DoubleEndedIterator` impl, which means it can also be used to find/// occurrences in reverse order./// This type is intended to be used to implement all iterators for the/// `memchr` family of functions. It handles a tiny bit of marginally tricky/// raw pointer math, but otherwise expects the caller to provide `find_raw`/// and `rfind_raw` routines for each call of `next` and `next_back`,// SAFETY: Iter contains no shared references to anything that performs any// interior mutations. Also, the lifetime guarantees that Iter will not outlive// the haystack.// SAFETY: Iter perform no interior mutations, therefore no explicit// synchronization is necessary. Also, the lifetime guarantees that Iter will// not outlive the haystack./// Create a new generic memchr iterator./// Returns the next occurrence in the forward direction./// Callers must ensure that if a pointer is returned from the closure/// provided, then it must be greater than or equal to the start pointer/// and less than the end pointer./// Returns the number of remaining elements in this iterator./// Returns the next occurrence in reverse./// Provides an implementation of `Iterator::size_hint`.search_slice_with_raw/// Search a slice using a function that operates on raw pointers./// Given a function to search a contiguous sequence of memory for the location/// of a non-empty set of bytes, this will execute that search on a slice of/// bytes. The pointer returned by the given function will be converted to an/// offset relative to the starting point of the given slice. That is, if a/// match is found, the offset returned by this routine is guaranteed to be a/// valid index into `haystack`./// Callers may use this for a forward or reverse search./// Callers must ensure that if a pointer is returned by `find_raw`, then the/// pointer must be greater than or equal to the starting pointer and less than/// the end pointer.fwd_byte_by_byte/// Performs a forward byte-at-a-time loop until either `ptr >= end_ptr` or/// until `confirm(*ptr)` returns `true`. If the former occurs, then `None` is/// returned. If the latter occurs, then the pointer at which `confirm` returns/// `true` is returned./// Callers must provide valid pointers and they must satisfy `start_ptr <=/// ptr` and `ptr <= end_ptr`.rev_byte_by_byte/// Performs a reverse byte-at-a-time loop until either `ptr < start_ptr` orcount_byte_by_byte/// Performs a forward byte-at-a-time loop until `ptr >= end_ptr` and returns/// the number of times `confirm(*ptr)` returns `true`./*!
Generic crate-internal routines for the `memchr` family of functions.
*/// What follows is a vector algorithm generic over the specific vector// type to detect the position of one, two or three needles in a haystack.// From what I know, this is a "classic" algorithm, although I don't// believe it has been published in any peer reviewed journal. I believe// it can be found in places like glibc and Go's standard library. It// appears to be well known and is elaborated on in more detail here:// https://gms.tf/stdfind-and-memchr-optimizations.html// While the routine below is fairly long and perhaps intimidating, the basic// idea is actually very simple and can be expressed straight-forwardly in// pseudo code. The psuedo code below is written for 128 bit vectors, but the// actual code below works for anything that implements the Vector trait.//     needle = (n1 << 15) | (n1 << 14) | ... | (n1 << 1) | n1//     // Note: shift amount is in bytes//     while i <= haystack.len() - 16://       // A 16 byte vector. Each byte in chunk corresponds to a byte in//       // the haystack.//       chunk = haystack[i:i+16]//       // Compare bytes in needle with bytes in chunk. The result is a 16//       // byte chunk where each byte is 0xFF if the corresponding bytes//       // in needle and chunk were equal, or 0x00 otherwise.//       eqs = cmpeq(needle, chunk)//       // Return a 32 bit integer where the most significant 16 bits//       // are always 0 and the lower 16 bits correspond to whether the//       // most significant bit in the correspond byte in `eqs` is set.//       // In other words, `mask as u16` has bit i set if and only if//       // needle[i] == chunk[i].//       mask = movemask(eqs)//       // Mask is 0 if there is no match, and non-zero otherwise.//       if mask != 0://         // trailing_zeros tells us the position of the least significant//         // bit that is set.//         return i + trailing_zeros(mask)//     // haystack length may not be a multiple of 16, so search the rest.//     while i < haystack.len()://       if haystack[i] == n1://         return i//     // No match found.//     return NULL// In fact, we could loosely translate the above code to Rust line-for-line// and it would be a pretty fast algorithm. But, we pull out all the stops// to go as fast as possible:// 1. We use aligned loads. That is, we do some finagling to make sure our//    primary loop not only proceeds in increments of 16 bytes, but that//    the address of haystack's pointer that we dereference is aligned to//    16 bytes. 16 is a magic number here because it is the size of SSE2//    128-bit vector. (For the AVX2 algorithm, 32 is the magic number.)//    Therefore, to get aligned loads, our pointer's address must be evenly//    divisible by 16.// 2. Our primary loop proceeds 64 bytes at a time instead of 16. It's//    kind of like loop unrolling, but we combine the equality comparisons//    using a vector OR such that we only need to extract a single mask to//    determine whether a match exists or not. If so, then we do some//    book-keeping to determine the precise location but otherwise mush on.// 3. We use our "chunk" comparison routine in as many places as possible,//    even if it means using unaligned loads. In particular, if haystack//    starts with an unaligned address, then we do an unaligned load to//    search the first 16 bytes. We then start our primary loop at the//    smallest subsequent aligned address, which will actually overlap with//    previously searched bytes. But we're OK with that. We do a similar//    dance at the end of our primary loop. Finally, to avoid a//    byte-at-a-time loop at the end, we do a final 16 byte unaligned load//    that may overlap with a previous load. This is OK because it converts//    a loop into a small number of very fast vector instructions. The overlap//    is OK because we know the place where the overlap occurs does not//    contain a match.// And that's pretty all there is to it. Note that since the below is// generic and since it's meant to be inlined into routines with a// `#[target_feature(enable = "...")]` annotation, we must mark all routines as// both unsafe and `#[inline(always)]`.// The fact that the code below is generic does somewhat inhibit us. For// example, I've noticed that introducing an unlineable `#[cold]` function to// handle the match case in the loop generates tighter assembly, but there is// no way to do this in the generic code below because the generic code doesn't// know what `target_feature` annotation to apply to the unlineable function.// We could make such functions part of the `Vector` trait, but we instead live// with the slightly sub-optimal codegen for now since it doesn't seem to have// a noticeable perf difference./*!
This module defines "generic" routines that can be specialized to specific
architectures.

We don't expose this module primarily because it would require exposing all
of the internal infrastructure required to write these generic routines.
That infrastructure should be treated as an implementation detail so that
it is allowed to evolve. Instead, what we expose are architecture specific
instantiations of these generic implementations. The generic code just lets us
write the code once (usually).
*//// A generic architecture dependent "packed pair" finder./// This is architecture dependent because it uses specific vector operations/// to look for occurrences of the pair of bytes./// This type is not meant to be exported and is instead meant to be used as/// the implementation for architecture specific facades. Why? Because it's a/// bit of a quirky API that requires `inline(always)` annotations. And pretty/// much everything has safety obligations due (at least) to the caller needing/// to inline calls into routines marked with/// `#[target_feature(enable = "...")]`./// Callers must ensure that whatever vector type this routine is called/// with is supported by the current environment./// Callers must also ensure that `needle.len() >= 2`./// Searches the given haystack for the given needle. The needle given/// should be the same as the needle that this finder was initialized/// with./// Since this is meant to be used with vector functions, callers need to/// specialize this inside of a function with a `target_feature` attribute./// Therefore, callers must ensure that whatever target feature is being/// used supports the vector functions that this function is specialized/// for. (For the specific vector functions used, see the Vector trait/// implementations.)/// Searches the given haystack for offsets that represent candidate/// matches of the `needle` given to this finder's constructor. The offsets/// returned, if they are a match, correspond to the starting offset of/// `needle` in the given `haystack`.find_in_chunk/// Search for an occurrence of our byte pair from the needle in the chunk/// pointed to by cur, with the end of the haystack pointed to by end./// When an occurrence is found, memcmp is run to check if a match occurs/// at the corresponding position./// `mask` should have bits set corresponding the positions in the chunk/// in which matches are considered. This is only used for the last vector/// load where the beginning of the vector might have overlapped with the/// last load in the main loop. The mask lets us avoid visiting positions/// that have already been discarded as matches./// It must be safe to do an unaligned read of size(V) bytes starting at/// both (cur + self.index1) and (cur + self.index2). It must also be safe/// to do unaligned loads on cur up to (end - needle.len()).find_prefilter_in_chunk/// to do unaligned reads on cur up to (end - needle.len())./// Providing a haystack to this `Finder` shorter than this length is/// guaranteed to result in a panic./// Accepts a chunk-relative offset and returns a haystack relative offset./// This used to be marked `#[cold]` and `#[inline(never)]`, but I couldn't/// observe a consistent measureable difference between that and just inlining/// it. So we go with inlining it./// Same at `ptr::offset_from` in addition to `cur >= start`./*!
Generic crate-internal routines for the "packed pair" SIMD algorithm.

The "packed pair" algorithm is based on the [generic SIMD] algorithm. The main
difference is that it (by default) uses a background distribution of byte
frequencies to heuristically select the pair of bytes to search for.

[generic SIMD]: http://0x80.pl/articles/simd-strfind.html#first-and-last
*/// If you're looking for tests, those are run for each instantiation of the// above code. So for example, see arch::x86_64::sse2::packedpair./*!
A module with low-level architecture dependent routines.

These routines are useful as primitives for tasks not covered by the higher
level crate API.
*//*!
Wrapper routines for `memchr` and friends.

These routines choose the best implementation at compile time. (This is
different from `x86_64` because it is expected that `simd128` is almost always
available for `wasm32` targets.)
*/simd128/*!
Vector algorithms for the `wasm32` target.
*/v128/// This particular searcher is specialized to use simd128 vector/// instructions that typically make it quite fast./// If simd128 is unavailable in the current environment, then `None` is/// Create a new finder specific to simd128 vectors and routines without/// checking that simd128 is available./// Callers must guarantee that it is safe to execute `simd128`/// instructions in the current environment./// Execute a search using simd128 vectors and routines./// `end` must be at least the size of a simd128 vector (in bytes)./// when it is safe to call `simd128` routines.)/// Execute a count using simd128 vectors and routines./*!
Algorithms for the `wasm32` target using 128-bit vectors via simd128.
*//// If simd128 is unavailable in the current environment or if a [`Pair`]/// Create a new `Finder` specific to simd128 vectors and routines./// ensure that simd128 is available./// Execute a search using wasm32 v128 vectors and routines./// Execute a prefilter search using wasm32 v128 vectors and routines./// Used for haystacks less than 32 bytes./// Used for haystacks bigger than 32 bytes./// This particular searcher is specialized to use AVX2 vector instructions/// that typically make it quite fast. (SSE2 is used for haystacks that/// are too short to accommodate an AVX2 vector.)/// If either SSE2 or AVX2 is unavailable in the current environment, then/// Create a new finder specific to AVX2 vectors and routines without/// checking that either SSE2 or AVX2 is available./// Callers must guarantee that it is safe to execute both `sse2` and/// `avx2` instructions in the current environment./// `x86_64` target, then they therefore automatically have access to SSE2find_raw_sse2/// Execute a search using SSE2 vectors and routines./// `end` must be at least the size of an SSE2 vector (in bytes)./// when it is safe to call `sse2`/`avx2` routines.)rfind_raw_sse2count_raw_sse2/// Execute a count using SSE2 vectors and routines.find_raw_avx2/// Execute a search using AVX2 vectors and routines./// `end` must be at least the size of an AVX2 vector (in bytes).rfind_raw_avx2count_raw_avx2/// Execute a count using AVX2 vectors and routines./*!
This module defines 256-bit vector implementations of `memchr` and friends.

The main types in this module are [`One`], [`Two`] and [`Three`]. They are for
searching for one, two or three distinct bytes, respectively, in a haystack.
Each type also has corresponding double ended iterators. These searchers are
typically much faster than scalar routines accomplishing the same task.

The `One` searcher also provides a [`One::count`] routine for efficiently
counting the number of times a single byte occurs in a haystack. This is
useful, for example, for counting the number of lines in a haystack. This
routine exists because it is usually faster, especially with a high match
count, then using [`One::find`] repeatedly. ([`OneIter`] specializes its
`Iterator::count` implementation to use this routine.)

Only one, two and three bytes are supported because three bytes is about
the point where one sees diminishing returns. Beyond this point and it's
probably (but not necessarily) better to just use a simple `[bool; 256]` array
or similar. However, it depends mightily on the specific work-load and the
expected match frequency.
*//*!
Algorithms for the `x86_64` target using 256-bit vectors via AVX2.
*//// A "packed pair" finder that uses 256-bit vector operations./// If AVX2 is unavailable in the current environment or if a [`Pair`]/// If AVX2 is unavailable in the current environment, then `None` is/// Create a new `Finder` specific to SSE2 vectors and routines./// ensure that both SSE2 and AVX2 are available./// when it is safe to call `sse2` and `avx2` routines.)/// Execute a prefilter search using AVX2 vectors and routines./*!
A 256-bit vector implementation of the "packed pair" SIMD algorithm.

The "packed pair" algorithm is based on the [generic SIMD] algorithm. The main
difference is that it (by default) uses a background distribution of byte
frequencies to heuristically select the pair of bytes to search for.

[generic SIMD]: http://0x80.pl/articles/simd-strfind.html#first-and-last
*/unsafe_ifunc/// Provides a way to run a memchr-like function while amortizing the cost of/// runtime CPU feature detection./// This works by loading a function pointer from an atomic global. Initially,/// this global is set to a function that does CPU feature detection. For/// example, if AVX2 is enabled, then the AVX2 implementation is used./// Otherwise, at least on x86_64, the SSE2 implementation is used. (And/// in some niche cases, if SSE2 isn't available, then the architecture/// independent fallback implementation is used.)/// After the first call to this function, the atomic global is replaced with/// the specific AVX2, SSE2 or fallback routine chosen. Subsequent calls then/// will directly call the chosen routine instead of needing to go through the/// CPU feature detection branching again./// This particular macro is specifically written to provide the implementation/// of functions with the following signature:/// fn memchr(needle1: u8, start: *const u8, end: *const u8) -> Option<usize>;/// Where you can also have `memchr2` and `memchr3`, but with `needle2` and/// `needle3`, respectively. The `start` and `end` parameters correspond to the/// start and end of the haystack, respectively./// We use raw pointers here instead of the more obvious `haystack: &[u8]` so/// that the function is compatible with our lower level iterator logic that/// operates on raw pointers. We use this macro to implement "raw" memchr/// routines with the signature above, and then define memchr routines using/// regular slices on top of them./// Note that we use `#[cfg(target_feature = "sse2")]` below even though/// it shouldn't be strictly necessary because without it, it seems to/// cause the compiler to blow up. I guess it can't handle a function/// pointer being created with a sse target feature? Dunno. See the/// `build-for-x86-64-but-non-sse-target` CI job if you want to experiment with/// Primarily callers must that `$fnty` is a correct function pointer type and/// not something else./// Callers must also ensure that `$memchrty::$memchrfind` corresponds to a/// routine that returns a valid function pointer when a match is found. That/// is, a pointer that is `>= start` and `< end`./// Callers must also ensure that the `$hay_start` and `$hay_end` identifiers/// correspond to valid pointers./*!
Wrapper routines for `memchr` and friends.

These routines efficiently dispatch to the best implementation based on what
the CPU supports.
*/// The routines below dispatch to AVX2, SSE2 or a fallback routine based on// what's available in the current environment. The secret sauce here is that// we only check for which one to use approximately once, and then "cache" that// choice into a global function pointer. Subsequent invocations then just call// the appropriate function directly./*!
Vector algorithms for the `x86_64` target.
*//// This particular searcher is specialized to use SSE2 vector instructions/// If SSE2 is unavailable in the current environment, then `None` is/// Create a new finder specific to SSE2 vectors and routines without/// checking that SSE2 is available./// Callers must guarantee that it is safe to execute `sse2` instructions/// when it is safe to call `sse2` routines.)/*!
Algorithms for the `x86_64` target using 128-bit vectors via SSE2.
*//// If SSE2 is unavailable in the current environment or if a [`Pair`]/// ensure that SSE2 is available./// Execute a prefilter search using SSE2 vectors and routines.ImpCowBytes/// A specialized copy-on-write byte string./// The purpose of this type is to permit usage of a "borrowed or owned/// byte string" in a way that keeps std/no-std compatibility. That is, in/// no-std/alloc mode, this type devolves into a simple &[u8] with no owned/// variant available. We can't just use a plain Cow because Cow is not in/// core.// N.B. We don't use alloc::borrow::Cow here since we can get away with a// Box<[u8]> for our use case, which is 1/3 smaller than the Vec<u8> that// a Cow<[u8]> would use./// Create a new borrowed CowBytes.new_owned/// Create a new owned CowBytes./// Return a borrowed byte string, regardless of whether this is an owned/// or borrowed byte string internally./// Return an owned version of this copy-on-write byte string./// If this is already an owned byte string internally, then this is a/// no-op. Otherwise, the internal byte string is copied./// Converts this byte to a `char` if it's ASCII. Otherwise panics./// A trait for adding some helper routines to raw bytes.memchr2memchr2_itermemchr3memchr3_itermemchr_itermemrchr2memrchr2_itermemrchr3memrchr3_itermemrchr_iterMemchrMemchr2Memchr3cow/*!
This library provides heavily optimized routines for string search primitives.

# Overview

This section gives a brief high level overview of what this crate offers.

* The top-level module provides routines for searching for 1, 2 or 3 bytes
  in the forward or reverse direction. When searching for more than one byte,
  positions are considered a match if the byte at that position matches any
  of the bytes.
* The [`memmem`] sub-module provides forward and reverse substring search
  routines.

In all such cases, routines operate on `&[u8]` without regard to encoding. This
is exactly what you want when searching either UTF-8 or arbitrary bytes.

# Example: using `memchr`

This example shows how to use `memchr` to find the first occurrence of `z` in
a haystack:

```
use memchr::memchr;

let haystack = b"foo bar baz quuz";
assert_eq!(Some(10), memchr(b'z', haystack));
```

# Example: matching one of three possible bytes

This examples shows how to use `memrchr3` to find occurrences of `a`, `b` or
`c`, starting at the end of the haystack.

```
use memchr::memchr3_iter;

let haystack = b"xyzaxyzbxyzc";

let mut it = memchr3_iter(b'a', b'b', b'c', haystack).rev();
assert_eq!(Some(11), it.next());
assert_eq!(Some(7), it.next());
assert_eq!(Some(3), it.next());
assert_eq!(None, it.next());
```

# Example: iterating over substring matches

This example shows how to use the [`memmem`] sub-module to find occurrences of
a substring in a haystack.

```
use memchr::memmem;

let haystack = b"foo bar foo baz foo";

let mut it = memmem::find_iter(haystack, "foo");
assert_eq!(Some(0), it.next());
assert_eq!(Some(8), it.next());
assert_eq!(Some(16), it.next());
assert_eq!(None, it.next());
```

# Example: repeating a search for the same needle

It may be possible for the overhead of constructing a substring searcher to be
measurable in some workloads. In cases where the same needle is used to search
many haystacks, it is possible to do construction once and thus to avoid it for
subsequent searches. This can be done with a [`memmem::Finder`]:

```
use memchr::memmem;

let finder = memmem::Finder::new("foo");

assert_eq!(Some(4), finder.find(b"baz foo quux"));
assert_eq!(None, finder.find(b"quux baz bar"));
```

# Why use this crate?

At first glance, the APIs provided by this crate might seem weird. Why provide
a dedicated routine like `memchr` for something that could be implemented
clearly and trivially in one line:

```
fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
    haystack.iter().position(|&b| b == needle)
}
```

Or similarly, why does this crate provide substring search routines when Rust's
core library already provides them?

```
fn search(haystack: &str, needle: &str) -> Option<usize> {
    haystack.find(needle)
}
```

The primary reason for both of them to exist is performance. When it comes to
performance, at a high level at least, there are two primary ways to look at
it:

* **Throughput**: For this, think about it as, "given some very large haystack
  and a byte that never occurs in that haystack, how long does it take to
  search through it and determine that it, in fact, does not occur?"
* **Latency**: For this, think about it as, "given a tiny haystack---just a
  few bytes---how long does it take to determine if a byte is in it?"

The `memchr` routine in this crate has _slightly_ worse latency than the
solution presented above, however, its throughput can easily be over an
order of magnitude faster. This is a good general purpose trade off to make.
You rarely lose, but often gain big.

**NOTE:** The name `memchr` comes from the corresponding routine in `libc`. A
key advantage of using this library is that its performance is not tied to its
quality of implementation in the `libc` you happen to be using, which can vary
greatly from platform to platform.

But what about substring search? This one is a bit more complicated. The
primary reason for its existence is still indeed performance, but it's also
useful because Rust's core library doesn't actually expose any substring
search routine on arbitrary bytes. The only substring search routine that
exists works exclusively on valid UTF-8.

So if you have valid UTF-8, is there a reason to use this over the standard
library substring search routine? Yes. This routine is faster on almost every
metric, including latency. The natural question then, is why isn't this
implementation in the standard library, even if only for searching on UTF-8?
The reason is that the implementation details for using SIMD in the standard
library haven't quite been worked out yet.

**NOTE:** Currently, only `x86_64`, `wasm32` and `aarch64` targets have vector
accelerated implementations of `memchr` (and friends) and `memmem`.

# Crate features

* **std** - When enabled (the default), this will permit features specific to
the standard library. Currently, the only thing used from the standard library
is runtime SIMD CPU feature detection. This means that this feature must be
enabled to get AVX2 accelerated routines on `x86_64` targets without enabling
the `avx2` feature at compile time, for example. When `std` is not enabled,
this crate will still attempt to use SSE2 accelerated routines on `x86_64`. It
will also use AVX2 accelerated routines when the `avx2` feature is enabled at
compile time. In general, enable this feature if you can.
* **alloc** - When enabled (the default), APIs in this crate requiring some
kind of allocation will become available. For example, the
[`memmem::Finder::into_owned`](crate::memmem::Finder::into_owned) API and the
[`arch::all::shiftor`](crate::arch::all::shiftor) substring search
implementation. Otherwise, this crate is designed from the ground up to be
usable in core-only contexts, so the `alloc` feature doesn't add much
currently. Notably, disabling `std` but enabling `alloc` will **not** result
in the use of AVX2 on `x86_64` targets unless the `avx2` feature is enabled
at compile time. (With `std` enabled, AVX2 can be used even without the `avx2`
feature enabled at compile time by way of runtime CPU feature detection.)
* **logging** - When enabled (disabled by default), the `log` crate is used
to emit log messages about what kinds of `memchr` and `memmem` algorithms
are used. Namely, both `memchr` and `memmem` have a number of different
implementation choices depending on the target and CPU, and the log messages
can help show what specific implementations are being used. Generally, this is
useful for debugging performance issues.
* **libc** - **DEPRECATED**. Previously, this enabled the use of the target's
`memchr` function from whatever `libc` was linked into the program. This
feature is now a no-op because this crate's implementation of `memchr` should
now be sufficiently fast on a number of platforms that `libc` should no longer
be needed. (This feature is somewhat of a holdover from this crate's origins.
Originally, this crate was literally just a safe wrapper function around the
`memchr` function from `libc`.)
*/// It's just not worth trying to squash all dead code warnings. Pretty// unfortunate IMO. Not really sure how to fix this other than to either// live with it or sprinkle a whole mess of `cfg` annotations everywhere.// Same deal for miri.// Some feature combinations result in some of these macros never being used.// Which is fine. Just squash the warnings./// Search for the first occurrence of a byte in a slice./// This returns the index corresponding to the first occurrence of `needle` in/// `haystack`, or `None` if one is not found. If an index is returned, it is/// guaranteed to be less than `haystack.len()`./// While this is semantically the same as something like/// `haystack.iter().position(|&b| b == needle)`, this routine will attempt to/// use highly optimized vector operations that can be an order of magnitude/// faster (or more)./// This shows how to find the first position of a byte in a byte string./// use memchr::memchr;/// let haystack = b"the quick brown fox";/// assert_eq!(memchr(b'k', haystack), Some(8));/// Search for the last occurrence of a byte in a slice./// This returns the index corresponding to the last occurrence of `needle` in/// `haystack.iter().rposition(|&b| b == needle)`, this routine will attempt to/// This shows how to find the last position of a byte in a byte string./// use memchr::memrchr;/// assert_eq!(memrchr(b'o', haystack), Some(17));/// Search for the first occurrence of two possible bytes in a haystack./// This returns the index corresponding to the first occurrence of one of the/// needle bytes in `haystack`, or `None` if one is not found. If an index is/// returned, it is guaranteed to be less than `haystack.len()`./// `haystack.iter().position(|&b| b == needle1 || b == needle2)`, this routine/// will attempt to use highly optimized vector operations that can be an order/// of magnitude faster (or more)./// This shows how to find the first position of one of two possible bytes in a/// use memchr::memchr2;/// assert_eq!(memchr2(b'k', b'q', haystack), Some(4));/// Search for the last occurrence of two possible bytes in a haystack./// This returns the index corresponding to the last occurrence of one of the/// `haystack.iter().rposition(|&b| b == needle1 || b == needle2)`, this/// routine will attempt to use highly optimized vector operations that can be/// an order of magnitude faster (or more)./// This shows how to find the last position of one of two possible bytes in a/// use memchr::memrchr2;/// assert_eq!(memrchr2(b'k', b'o', haystack), Some(17));/// Search for the first occurrence of three possible bytes in a haystack./// `haystack.iter().position(|&b| b == needle1 || b == needle2 || b == needle3)`,/// this routine will attempt to use highly optimized vector operations that/// can be an order of magnitude faster (or more)./// This shows how to find the first position of one of three possible bytes in/// a haystack./// use memchr::memchr3;/// assert_eq!(memchr3(b'k', b'q', b'u', haystack), Some(4));/// Search for the last occurrence of three possible bytes in a haystack./// `haystack.iter().rposition(|&b| b == needle1 || b == needle2 || b == needle3)`,/// This shows how to find the last position of one of three possible bytes in/// use memchr::memrchr3;/// assert_eq!(memrchr3(b'k', b'o', b'n', haystack), Some(17));/// Returns an iterator over all occurrences of the needle in a haystack./// Returns an iterator over all occurrences of the needle in a haystack, in/// reverse./// Returns an iterator over all occurrences of the needles in a haystack./// Returns an iterator over all occurrences of the needles in a haystack, in/// This iterator is created by the [`memchr_iter`] or `[memrchr_iter`]/// functions. It can also be created with the [`Memchr::new`] method./// The lifetime parameter `'h` refers to the lifetime of the haystack being/// This iterator is created by the [`memchr2_iter`] or `[memrchr2_iter`]/// functions. It can also be created with the [`Memchr2::new`] method./// functions. It can also be created with the [`Memchr3::new`] method.forward1_iterforward1_oneshotreverse1_iterreverse1_oneshotcount1_iterforward2_iterforward2_oneshotreverse2_iterreverse2_oneshotforward3_iterforward3_oneshotreverse3_iterreverse3_oneshotsync_regression// Prior to memchr 2.6, the memchr iterators both implemented Send and// Sync. But in memchr 2.6, the iterator changed to use raw pointers// internally and I didn't add explicit Send/Sync impls. This ended up// regressing the API. This test ensures we don't do that again.// See: https://github.com/BurntSushi/memchr/issues/133PrefilterConfig// This is exported here for use in the crate::arch::all::twoway// implementation. This is essentially an abstraction breaker. Namely, the// public API of twoway doesn't support providing a prefilter, but its crate// internal API does. The main reason for this is that I didn't want to do the// API design required to support it without a concrete use case.PrefilterStateSearcherRev/// Returns an iterator over all non-overlapping occurrences of a substring in/// This routine is guaranteed to have worst case linear time complexity/// with respect to both the needle and the haystack. That is, this runs/// in `O(needle.len() + haystack.len())` time./// This routine is also guaranteed to have worst case constant space/// complexity./// use memchr::memmem;/// let haystack = b"foo bar foo baz foo";/// let mut it = memmem::find_iter(haystack, b"foo");/// assert_eq!(Some(0), it.next());/// assert_eq!(Some(8), it.next());/// assert_eq!(Some(16), it.next());rfind_iterFindRevIter/// Returns a reverse iterator over all non-overlapping occurrences of a/// substring in a haystack./// let mut it = memmem::rfind_iter(haystack, b"foo");/// Returns the index of the first occurrence of the given needle./// Note that if you're are searching for the same needle in many different/// small haystacks, it may be faster to initialize a [`Finder`] once,/// and reuse it for each search./// let haystack = b"foo bar baz";/// assert_eq!(Some(0), memmem::find(haystack, b"foo"));/// assert_eq!(Some(4), memmem::find(haystack, b"bar"));/// assert_eq!(None, memmem::find(haystack, b"quux"));/// Returns the index of the last occurrence of the given needle./// small haystacks, it may be faster to initialize a [`FinderRev`] once,/// assert_eq!(Some(0), memmem::rfind(haystack, b"foo"));/// assert_eq!(Some(4), memmem::rfind(haystack, b"bar"));/// assert_eq!(Some(8), memmem::rfind(haystack, b"ba"));/// assert_eq!(None, memmem::rfind(haystack, b"quux"));prestate/// An iterator over non-overlapping substring matches./// Matches are reported by the byte offset at which they begin./// `'h` is the lifetime of the haystack while `'n` is the lifetime of the/// needle./// Convert this iterator into its owned variant, such that it no longer/// borrows the finder and needle./// If this is already an owned iterator, then this is a no-op. Otherwise,/// this copies the needle./// This is only available when the `alloc` feature is enabled./// When searching with an empty needle, this gets set to `None` after/// we've yielded the last element at `0`./// An iterator over non-overlapping substring matches in reverse./// This is only available when the `std` feature is enabled./// A single substring searcher fixed to a particular needle./// The purpose of this type is to permit callers to construct a substring/// searcher that can be used to search haystacks without the overhead of/// constructing the searcher in the first place. This is a somewhat niche/// concern when it's necessary to re-use the same needle to search multiple/// different haystacks with as little overhead as possible. In general, using/// [`find`] is good enough, but `Finder` is useful when you can meaningfully/// observe searcher construction time in a profile./// When the `std` feature is enabled, then this type has an `into_owned`/// version which permits building a `Finder` that is not connected to/// the lifetime of its needle./// Create a new finder for the given needle./// Returns the index of the first occurrence of this needle in the given/// use memchr::memmem::Finder;/// assert_eq!(Some(0), Finder::new("foo").find(haystack));/// assert_eq!(Some(4), Finder::new("bar").find(haystack));/// assert_eq!(None, Finder::new("quux").find(haystack));/// Returns an iterator over all occurrences of a substring in a haystack./// let finder = Finder::new(b"foo");/// let mut it = finder.find_iter(haystack);/// Convert this finder into its owned variant, such that it no longer/// borrows the needle./// If this is already an owned finder, then this is a no-op. Otherwise,/// Convert this finder into its borrowed variant./// This is primarily useful if your finder is owned and you'd like to/// store its borrowed variant in some intermediate data structure./// Note that the lifetime parameter of the returned finder is tied to the/// lifetime of `self`, and may be shorter than the `'n` lifetime of the/// needle itself. Namely, a finder's needle can be either borrowed or/// owned, so the lifetime of the needle returned must necessarily be the/// shorter of the two./// Returns the needle that this finder searches for./// Note that the lifetime of the needle returned is tied to the lifetime/// of the finder, and may be shorter than the `'n` lifetime. Namely, a/// finder's needle can be either borrowed or owned, so the lifetime of the/// needle returned must necessarily be the shorter of the two./// A single substring reverse searcher fixed to a particular needle./// different haystacks with as little overhead as possible. In general,/// using [`rfind`] is good enough, but `FinderRev` is useful when you can/// meaningfully observe searcher construction time in a profile./// version which permits building a `FinderRev` that is not connected to/// Create a new reverse finder for the given needle./// Returns the index of the last occurrence of this needle in the given/// The haystack may be any type that can be cheaply converted into a/// `&[u8]`. This includes, but is not limited to, `&str` and `&[u8]`./// use memchr::memmem::FinderRev;/// assert_eq!(Some(0), FinderRev::new("foo").rfind(haystack));/// assert_eq!(Some(4), FinderRev::new("bar").rfind(haystack));/// assert_eq!(None, FinderRev::new("quux").rfind(haystack));/// Returns a reverse iterator over all occurrences of a substring in a/// let finder = FinderRev::new(b"foo");/// let mut it = finder.rfind_iter(haystack);FinderBuilder/// A builder for constructing non-default forward or reverse memmem finders./// A builder is primarily useful for configuring a substring searcher./// Currently, the only configuration exposed is the ability to disable/// heuristic prefilters used to speed up certain searches./// Create a new finder builder with default settings.build_forward/// Build a forward finder using the given needle from the current/// settings.build_forward_with_ranker/// Build a forward finder using the given needle and a custom heuristic for/// determining the frequency of a given byte in the dataset./// See [`HeuristicFrequencyRank`] for more details.build_reverse/// Build a reverse finder using the given needle from the current/// Configure the prefilter setting for the finder./// See the documentation for [`Prefilter`] for more discussion on why/// you might want to configure this./*!
This module provides forward and reverse substring search routines.

Unlike the standard library's substring search routines, these work on
arbitrary bytes. For all non-empty needles, these routines will report exactly
the same values as the corresponding routines in the standard library. For
the empty needle, the standard library reports matches only at valid UTF-8
boundaries, where as these routines will report matches at every position.

Other than being able to work on arbitrary bytes, the primary reason to prefer
these routines over the standard library routines is that these will generally
be faster. In some cases, significantly so.

# Example: iterating over substring matches

This example shows how to use [`find_iter`] to find occurrences of a substring
in a haystack.

```
use memchr::memmem;

let haystack = b"foo bar foo baz foo";

let mut it = memmem::find_iter(haystack, "foo");
assert_eq!(Some(0), it.next());
assert_eq!(Some(8), it.next());
assert_eq!(Some(16), it.next());
assert_eq!(None, it.next());
```

# Example: iterating over substring matches in reverse

This example shows how to use [`rfind_iter`] to find occurrences of a substring
in a haystack starting from the end of the haystack.

**NOTE:** This module does not implement double ended iterators, so reverse
searches aren't done by calling `rev` on a forward iterator.

```
use memchr::memmem;

let haystack = b"foo bar foo baz foo";

let mut it = memmem::rfind_iter(haystack, "foo");
assert_eq!(Some(16), it.next());
assert_eq!(Some(8), it.next());
assert_eq!(Some(0), it.next());
assert_eq!(None, it.next());
```

# Example: repeating a search for the same needle

It may be possible for the overhead of constructing a substring searcher to be
measurable in some workloads. In cases where the same needle is used to search
many haystacks, it is possible to do construction once and thus to avoid it for
subsequent searches. This can be done with a [`Finder`] (or a [`FinderRev`] for
reverse searches).

```
use memchr::memmem;

let finder = memmem::Finder::new("foo");

assert_eq!(Some(4), finder.find(b"baz foo quux"));
assert_eq!(None, finder.find(b"quux baz bar"));
```
*/SearcherKindFnSearcherKind/// A "meta" substring searcher./// To a first approximation, this chooses what it believes to be the "best"/// substring search implemnetation based on the needle at construction time./// Then, every call to `find` will execute that particular implementation. To/// a second approximation, multiple substring search algorithms may be used,/// depending on the haystack. For example, for supremely short haystacks,/// Rabin-Karp is typically used./// See the documentation on `Prefilter` for an explanation of the dispatching/// mechanism. The quick summary is that an enum has too much overhead and/// we can't use dynamic dispatch via traits because we need to work in a/// core-only environment. (Dynamic dispatch works in core-only, but you/// need `&dyn Trait` and we really need a `Box<dyn Trait>` here. The latter/// requires `alloc`.) So instead, we use a union and an appropriately paired/// free function to read from the correct field on the union and execute the/// chosen substring search implementation./// Creates a new "meta" substring searcher that attempts to choose the/// best algorithm based on the needle, heuristics and what the current/// target supports./// Creates a new searcher that always uses the Two-Way algorithm. This is/// typically used when vector algorithms are unavailable or inappropriate./// (For example, when the needle is "too long.")/// If a prefilter is given, then the searcher returned will be accelerated/// by the prefilter./// Inlining this can lead to big wins for latency, and #[inline] doesn't/// seem to be enough in some cases.one_bytetwo_waytwo_way_with_prefilterTwoWayWithPrefilter/// A union indicating one of several possible substring search implementations/// that are in active use./// This union should only be read by one of the functions prefixed with/// `searcher_kind_`. Namely, the correct function is meant to be paired with/// the union by the caller, such that the function always reads from the/// designated union field.prestrat/// A two-way substring searcher with a prefilter./// The type of a substring search function./// When using a function of this type, callers must ensure that the correct/// function is paired with the value populated in `SearcherKind` union.searcher_kind_empty/// Reads from the `empty` field of `SearcherKind` to handle the case of/// searching for the empty needle. Works on all platforms./// Callers must ensure that the `searcher.kind.empty` union field is set.searcher_kind_one_byte/// Reads from the `one_byte` field of `SearcherKind` to handle the case of/// searching for a single byte needle. Works on all platforms./// Callers must ensure that the `searcher.kind.one_byte` union field is set.searcher_kind_two_way/// Reads from the `two_way` field of `SearcherKind` to handle the case of/// searching for an arbitrary needle without prefilter acceleration. Works on/// all platforms./// Callers must ensure that the `searcher.kind.two_way` union field is set.searcher_kind_two_way_with_prefilter/// Reads from the `two_way_with_prefilter` field of `SearcherKind` to handle/// the case of searching for an arbitrary needle with prefilter acceleration./// Works on all platforms./// Callers must ensure that the `searcher.kind.two_way_with_prefilter` union/// field is set.searcher_kind_sse2/// Reads from the `sse2` field of `SearcherKind` to execute the x86_64 SSE2/// vectorized substring search implementation./// Callers must ensure that the `searcher.kind.sse2` union field is set.searcher_kind_avx2/// Reads from the `avx2` field of `SearcherKind` to execute the x86_64 AVX2/// Callers must ensure that the `searcher.kind.avx2` union field is set.SearcherRevKind/// A reverse substring searcher.OneByte/// The kind of the reverse searcher./// For the reverse case, we don't do any SIMD acceleration or prefilters./// There is no specific technical reason why we don't, but rather don't do it/// because it's not clear it's worth the extra code to do so. If you have a/// use case for it, please file an issue./// We also don't do the union trick as we do with the forward case and/// prefilters. Basically for the same reason we don't have prefilters or/// vector algorithms for reverse searching: it's not clear it's worth doing./// Please file an issue if you have a compelling use case for fast reverse/// substring search./// Creates a new searcher for finding occurrences of the given needle in/// reverse. That is, it reports the last (instead of the first) occurrence/// of a needle in a haystack./// Searches the given haystack for the last occurrence of the given/// needle. The needle given should be the same as the needle that this/// finder was initialized with./// Never used a prefilter in substring search./// Automatically detect whether a heuristic prefilter should be used. If/// it is used, then heuristics will be used to dynamically disable the/// prefilter if it is believed to not be carrying its weight./// Prefilter controls whether heuristics are used to accelerate searching./// A prefilter refers to the idea of detecting candidate matches very quickly,/// and then confirming whether those candidates are full matches. This/// idea can be quite effective since it's often the case that looking for/// candidates can be a lot faster than running a complete substring search/// over the entire input. Namely, looking for candidates can be done with/// extremely fast vectorized code./// The downside of a prefilter is that it assumes false positives (which are/// candidates generated by a prefilter that aren't matches) are somewhat rare/// relative to the frequency of full matches. That is, if a lot of false/// positives are generated, then it's possible for search time to be worse/// than if the prefilter wasn't enabled in the first place./// Another downside of a prefilter is that it can result in highly variable/// performance, where some cases are extraordinarily fast and others aren't./// Typically, variable performance isn't a problem, but it may be for your use/// case./// The use of prefilters in this implementation does use a heuristic to detect/// when a prefilter might not be carrying its weight, and will dynamically/// disable its use. Nevertheless, this configuration option gives callers/// the ability to disable prefilters if you have knowledge that they won't be/// useful./// Returns true when this prefilter is set to the `None` variant.PrefilterKindFnPrefilterKindrarest_byterarest_offset/// The implementation of a prefilter./// This type encapsulates dispatch to one of several possible choices for a/// prefilter. Generally speaking, all prefilters have the same approximate/// algorithm: they choose a couple of bytes from the needle that are believed/// to be rare, use a fast vector algorithm to look for those bytes and return/// positions as candidates for some substring search algorithm (currently only/// Two-Way) to confirm as a match or not./// The differences between the algorithms are actually at the vector/// implementation level. Namely, we need different routines based on both/// which target architecture we're on and what CPU features are supported./// The straight-forwardly obvious approach here is to use an enum, and make/// `Prefilter::find` do case analysis to determine which algorithm was/// selected and invoke it. However, I've observed that this leads to poor/// codegen in some cases, especially in latency sensitive benchmarks. That is,/// this approach comes with overhead that I wasn't able to eliminate./// The second obvious approach is to use dynamic dispatch with traits. Doing/// that in this context where `Prefilter` owns the selection generally/// requires heap allocation, and this code is designed to run in core-only/// So we settle on using a union (that's `PrefilterKind`) and a function/// pointer (that's `PrefilterKindFn`). We select the right function pointer/// based on which field in the union we set, and that function in turn/// knows which field of the union to access. The downside of this approach/// is that it forces us to think about safety, but the upside is that/// there are some nice latency improvements to benchmarks. (Especially the/// `memmem/sliceslice/short` benchmark.)/// In cases where we've selected a vector algorithm and the haystack given/// is too short, we fallback to the scalar version of `memchr` on the/// `rarest_byte`. (The scalar version of `memchr` is still better than a naive/// byte-at-a-time loop because it will read in `usize`-sized chunks at a/// time.)/// Return a "fallback" prefilter, but only if it is believed to be/// effective./// Return a prefilter using a x86_64 SSE2 vector algorithm./// Return a prefilter using a x86_64 AVX2 vector algorithm./// Return a *candidate* position for a match./// When this returns an offset, it implies that a match could begin at/// that offset, but it may not. That is, it is possible for a false/// positive to be returned./// When `None` is returned, then it is guaranteed that there are no/// matches for the needle in the given haystack. That is, it is impossible/// for a false negative to be returned./// The purpose of this routine is to look for candidate matching positions/// as quickly as possible before running a (likely) slower confirmationfind_simple/// A "simple" prefilter that just looks for the occurrence of the rarest/// byte from the needle. This is generally only used for very small/// haystacks./// A union indicating one of several possible prefilters that are in active/// `prefilter_kind_`. Namely, the correct function is meant to be paired with/// The type of a prefilter function./// function is paired with the value populated in `PrefilterKind` union.prefilter_kind_fallback/// Reads from the `fallback` field of `PrefilterKind` to execute the fallback/// prefilter. Works on all platforms./// Callers must ensure that the `strat.kind.fallback` union field is set.prefilter_kind_sse2/// Reads from the `sse2` field of `PrefilterKind` to execute the x86_64 SSE2/// prefilter./// Callers must ensure that the `strat.kind.sse2` union field is set.prefilter_kind_avx2/// Reads from the `avx2` field of `PrefilterKind` to execute the x86_64 AVX2/// Callers must ensure that the `strat.kind.avx2` union field is set.skips/// The number of skips that has been executed. This is always 1 greater/// than the actual number of skips. The special sentinel value of 0/// indicates that the prefilter is inert. This is useful to avoid/// additional checks to determine whether the prefilter is still/// "effective." Once a prefilter becomes inert, it should no longer be/// used (according to our heuristics).skipped/// The total number of bytes that have been skipped./// PrefilterState tracks state associated with the effectiveness of a/// prefilter. It is used to track how many bytes, on average, are skipped by/// the prefilter. If this average dips below a certain threshold over time,/// then the state renders the prefilter inert and stops using it./// A prefilter state should be created for each search. (Where creating an/// iterator is treated as a single search.) A prefilter state should only be/// created from a `Freqy`. e.g., An inert `Freqy` will produce an inert/// `PrefilterState`.MIN_SKIPS/// The minimum number of skip attempts to try before considering whether/// a prefilter is effective or not.MIN_SKIP_BYTES/// The minimum amount of bytes that skipping must average./// This value was chosen based on varying it and checking/// the microbenchmarks. In particular, this can impact the/// pathological/repeated-{huge,small} benchmarks quite a bit if it's set/// too low./// Create a fresh prefilter state./// Update this state with the number of bytes skipped on the last/// invocation of the prefilter.is_effective/// Return true if and only if this state indicates that a prefilter is/// still effective.is_inert/// Returns true if the prefilter this state represents should no longer/// be used./// Returns the total number of times the prefilter has been used./// State that tracks the effectiveness of a prefilter./// The actual prefilter./// A combination of prefilter effectiveness state and the prefilter itself./// Call this prefilter on the given haystack with the given needle./// Return true if and only if this prefilter should be used.do_packed_search/// Returns true if the needle has the right characteristics for a vector/// algorithm to handle the entirety of substring search./// Vector algorithms can be used for prefilters for other substring search/// algorithms (like Two-Way), but they can also be used for substring search/// on their own. When used for substring search, vector algorithms will/// quickly identify candidate match positions (just like in the prefilter/// case), but instead of returning the candidate position they will try to/// confirm the match themselves. Confirmation happens via `memcmp`. This/// works well for short needles, but can break down when many false candidate/// positions are generated for large needles. Thus, we only permit vector/// algorithms to own substring search when the needle is of a certain length.SEEDSSeed/// Runs a host of substring search tests./// This has support for "partial" substring search implementations only work/// for a subset of needles/haystacks. For example, the "packed pair" substring/// search implementation only works for haystacks of some minimum length based/// of the pair of bytes selected and the size of the vector used./// Create a new test runner for forward and reverse byte search/// The `needle_len` given must be at most `3` and at least `1`. It/// corresponds to the number of needle bytes to search for.forward_iter/// Run all tests. This panics on the first failure./// If the implementation being tested returns `None` for a particular/// haystack/needle combination, then that test is skipped.reverse_iter/// Run all tests in the reverse direction. This panics on the firstcount_iter/// Run all tests as counting tests. This panics on the first failure./// That is, this only checks that the number of matches is correct and/// not whether the offsets of each match are.forward_oneshot/// Like `Runner::forward`, but for a function that returns only the next/// match and not all matches./// If the function returns `None`, then it is skipped.reverse_oneshot/// Like `Runner::reverse`, but for a function that returns only the last/// The string to search in.needles/// The needles to look for./// The offsets that are expected to be found for all needles in the/// forward direction./// A single test for memr?chr{,2,3}./// The thing to search. We use `&str` instead of `&[u8]` because they/// are nicer to write in tests, and we don't miss much since memchr/// doesn't care about UTF-8./// Corpora cannot contain either '%' or '#'. We use these bytes when/// expanding test cases into many test cases, and we assume they are not/// used. If they are used, `memchr_tests` will panic./// The needles to search for. This is intended to be an alternation of/// needles. The number of needles may cause this test to be skipped for/// some memchr variants. For example, a test with 2 needles cannot be used/// to test `memchr`, but can be used to test `memchr2` and `memchr3`./// However, a test with only 1 needle can be used to test all of `memchr`,/// `memchr2` and `memchr3`. We achieve this by filling in the needles with/// bytes that we never used in the corpus (such as '#')./// The positions expected to match for all of the needles./// Data that can be expanded into many memchr tests by padding out the corpus.EXPAND_LEN/// Controls how much we expand the haystack on either side for each test./// We lower this on Miri because otherwise running the tests would take/// forever./// Expand this test into many variations of the same test./// In particular, this will generate more tests with larger corpus sizes./// The expected positions are updated to maintain the integrity of the/// This is important in testing a memchr implementation, because there are/// often different cases depending on the length of the corpus./// Note that we extend the corpus by adding `%` bytes, which we/// don't otherwise use as a needle.// take items from a DEI, taking front for each true and back for each false.// Return a vector with the concatenation of the fronts and the reverse of the// backs.// return an iterator of the 0-based indices of haystack that match the needle// For debugging, particularly in CI, print out the byte order of the current// target./// A set of "packed pair" test seeds. Each seed serves as the base for the/// generation of many other tests. In essence, the seed captures the pair of/// bytes we used for a predicate and first byte among our needle. The tests/// generated from each seed essentially vary the length of the needle and/// haystack, while using the rare/first byte configuration from the seed./// The purpose of this is to test many different needle/haystack lengths./// In particular, some of the vector optimizations might only have bugs/// in haystacks of a certain size.fwd/// Runs a host of "packed pair" search tests./// These tests specifically look for the occurrence of a possible substring/// match based on a pair of bytes matching at the right offsets./// Create a new test runner for "packed pair" substring search./// This runs tests on both the forward and reverse implementations given./// If either (or both) are missing, then tests for that implementation are/// skipped./// Set the implementation for forward "packed pair" substring search./// If the closure returns `None`, then it is assumed that the given/// test cannot be applied to the particular implementation and it is/// skipped. For example, if a particular implementation only supports/// needles or haystacks for some minimum length./// If this is not set, then forward "packed pair" search is not tested./// A test that represents the input and expected output to a "packed pair"/// search function. The test should be able to run with any "packed pair"/// implementation and get the expected output./// Create a new "packed pair" test from a seed and some given offsets to/// the pair of bytes to use as a predicate in the seed's needle./// If a valid test could not be constructed, then None is returned./// (Currently, we take the approach of massaging tests to be valid/// instead of rejecting them outright.)/// Data that describes a single prefilter test seed.NEEDLE_LENGTH_LIMITHAYSTACK_LENGTH_LIMIT/// Generate a series of prefilter tests from this seed./// Create a new test runner for forward and reverse substring search/// Set the implementation for forward substring search./// If this is not set, then forward substring search is not tested./// Set the implementation for reverse substring search./// If this is not set, then reverse substring search is not tested./// A single substring test for forward and reverse searches./// Each seed is valid on its own, but it also serves as a starting point/// to generate more tests. Namely, we pad out the haystacks with other/// characters so that we get more complete coverage. This is especially useful/// for testing vector algorithms that tend to have weird special cases for/// alignment and loop unrolling./// Padding works by assuming certain characters never otherwise appear in a/// needle or a haystack. Neither should contain a `#` character.MAX_PAD/*!
This module defines tests and test helpers for substring implementations.
*//// Naively search forwards for the given needle in the given haystack./// Naively search in reverse for the given needle in the given haystack./*!
This module defines "naive" implementations of substring search.

These are sometimes useful to compare with "real" substring implementations.
The idea is that they are so simple that they are unlikely to be incorrect.
*//// $fwd is a `impl FnMut(haystack, needle) -> Option<Option<usize>>`. When the/// routine returns `None`, then it's skipped, which is useful for substring/// implementations that don't work for all inputs./// $rev is a `impl FnMut(haystack, needle) -> Option<Option<usize>>`. When theprefix_is_substring/// Check that every prefix of the given byte string is a substring.suffix_is_substring/// Check that every suffix of the given byte string is a substring.same_as_naive/// Check that naive substring search matches the result of the given search/// algorithm./*!
This module defines a few quickcheck properties for substring search.

It also provides a forward and reverse macro for conveniently defining
quickcheck tests that run these properties over any substring search
implementation.
*//// The bits that must be zero in order for a `*const u8` pointer to be/// correctly aligned to read vector values./// The type of the value returned by `Vector::movemask`./// This supports abstracting over the specific representation used in/// order to accommodate different representations in different ISAs./// must be aligned to the size of the vector./// `data` and that `data` is aligned to a `BYTES` boundary.movemask/// _mm_movemask_epi8 or _mm256_movemask_epi8/// _mm_cmpeq_epi8 or _mm256_cmpeq_epi8/// _mm_and_si128 or _mm256_and_si256/// _mm_or or _mm256_or_si256movemask_will_have_non_zero/// Returns true if and only if `Self::movemask` would return a mask that/// contains at least one non-zero bit./// The trait is highly constrained to low level vector operations needed./// In general, it was invented mostly to be generic over x86's __m128i and/// __m256i types. At time of writing, it also supports wasm and aarch64/// 128-bit vector types as well./// vendor intrinsics, which are also not safe. Callers must ensure that the/// appropriate target features are enabled in the calling function, and that/// the current CPU supports them. All implementations should avoid marking the/// routines with #[target_feature] and instead mark them as #[inline(always)]/// to ensure they get appropriately inlined. (inline(always) cannot be used/// with target_feature.)all_zeros_except_least_significant/// Return a mask that is all zeros except for the least significant `n`/// lanes in a corresponding vector.has_non_zero/// Returns true if and only if this mask has a a non-zero bit anywhere./// Returns the number of bits set to 1 in this mask./// Does a bitwise `and` operation between `self` and `other`./// Does a bitwise `or` operation between `self` and `other`.clear_least_significant_bit/// Returns a mask that is equivalent to `self` but with the least/// significant 1-bit set to 0.first_offset/// Returns the offset of the first non-zero lane this mask represents.last_offset/// Returns the offset of the last non-zero lane this mask represents./// A trait that abstracts over a vector-to-scalar operation called/// "move mask."/// On x86-64, this is `_mm_movemask_epi8` for SSE2 and `_mm256_movemask_epi8`/// for AVX2. It takes a vector of `u8` lanes and returns a scalar where the/// `i`th bit is set if and only if the most significant bit in the `i`th lane/// of the vector is set. The simd128 ISA for wasm32 also supports this/// exact same operation natively./// ... But aarch64 doesn't. So we have to fake it with more instructions and/// a slightly different representation. We could do extra work to unify the/// representations, but then would require additional costs in the hot path/// for `memchr` and `packedpair`. So instead, we abstraction over the specific/// representation with this trait an ddefine the operations we actually need.SensibleMoveMask/// This is a "sensible" movemask implementation where each bit represents/// whether the most significant bit is set in each corresponding lane of a/// vector. This is used on x86-64 and wasm, but such a mask is more expensive/// to get on aarch64 so we use something a little different./// We call this "sensible" because this is what we get using native sse/avx/// movemask instructions. But neon has no such native equivalent.get_for_offset/// Get the mask in a form suitable for computing offsets./// Basically, this normalizes to little endian. On big endian, this swaps/// the bytes.x86sse2x86avx2Advice/// **MADV_NORMAL**/// No special treatment.  This is the default./// **MADV_RANDOM**/// Expect page references in random order.  (Hence, read/// ahead may be less useful than normally.)Sequential/// **MADV_SEQUENTIAL**/// Expect page references in sequential order.  (Hence, pages/// in the given range can be aggressively read ahead, and may/// be freed soon after they are accessed.)WillNeed/// **MADV_WILLNEED**/// Expect access in the near future.  (Hence, it might be a/// good idea to read some pages ahead.)DontFork/// **MADV_DONTFORK** - Linux only (since Linux 2.6.16)/// Do not make the pages in this range available to the child/// after a fork(2).  This is useful to prevent copy-on-write/// semantics from changing the physical location of a page if/// the parent writes to it after a fork(2).  (Such page/// relocations cause problems for hardware that DMAs into the/// page.)DoFork/// **MADV_DOFORK** - Linux only (since Linux 2.6.16)/// Undo the effect of MADV_DONTFORK, restoring the default/// behavior, whereby a mapping is inherited across fork(2).Mergeable/// **MADV_MERGEABLE** - Linux only (since Linux 2.6.32)/// Enable Kernel Samepage Merging (KSM) for the pages in the/// range specified by addr and length.  The kernel regularly/// scans those areas of user memory that have been marked as/// mergeable, looking for pages with identical content./// These are replaced by a single write-protected page (which/// is automatically copied if a process later wants to update/// the content of the page).  KSM merges only private/// anonymous pages (see mmap(2))./// The KSM feature is intended for applications that generate/// many instances of the same data (e.g., virtualization/// systems such as KVM).  It can consume a lot of processing/// power; use with care.  See the Linux kernel source file/// Documentation/admin-guide/mm/ksm.rst for more details./// The MADV_MERGEABLE and MADV_UNMERGEABLE operations are/// available only if the kernel was configured with/// CONFIG_KSM.Unmergeable/// **MADV_UNMERGEABLE** - Linux only (since Linux 2.6.32)/// Undo the effect of an earlier MADV_MERGEABLE operation on/// the specified address range; KSM unmerges whatever pages/// it had merged in the address range specified by addr andHugePage/// **MADV_HUGEPAGE** - Linux only (since Linux 2.6.38)/// Enable Transparent Huge Pages (THP) for pages in the range/// specified by addr and length.  Currently, Transparent Huge/// Pages work only with private anonymous pages (see/// mmap(2)).  The kernel will regularly scan the areas marked/// as huge page candidates to replace them with huge pages./// The kernel will also allocate huge pages directly when the/// region is naturally aligned to the huge page size (see/// posix_memalign(2))./// This feature is primarily aimed at applications that use/// large mappings of data and access large regions of that/// memory at a time (e.g., virtualization systems such as/// QEMU).  It can very easily waste memory (e.g., a 2 MB/// mapping that only ever accesses 1 byte will result in 2 MB/// of wired memory instead of one 4 KB page).  See the Linux/// kernel source file/// Documentation/admin-guide/mm/transhuge.rst for more/// Most common kernels configurations provide MADV_HUGEPAGE-/// style behavior by default, and thus MADV_HUGEPAGE is/// normally not necessary.  It is mostly intended for/// embedded systems, where MADV_HUGEPAGE-style behavior may/// not be enabled by default in the kernel.  On such systems,/// this flag can be used in order to selectively enable THP./// Whenever MADV_HUGEPAGE is used, it should always be in/// regions of memory with an access pattern that the/// developer knows in advance won't risk to increase the/// memory footprint of the application when transparent/// hugepages are enabled./// The MADV_HUGEPAGE and MADV_NOHUGEPAGE operations are/// CONFIG_TRANSPARENT_HUGEPAGE.NoHugePage/// **MADV_NOHUGEPAGE** - Linux only (since Linux 2.6.38)/// Ensures that memory in the address range specified by addr/// and length will not be backed by transparent hugepages.DontDump/// **MADV_DONTDUMP** - Linux only (since Linux 3.4)/// Exclude from a core dump those pages in the range/// specified by addr and length.  This is useful in/// applications that have large areas of memory that are/// known not to be useful in a core dump.  The effect of/// **MADV_DONTDUMP** takes precedence over the bit mask that is/// set via the `/proc/[pid]/coredump_filter` file (see/// core(5)).DoDump/// **MADV_DODUMP** - Linux only (since Linux 3.4)/// Undo the effect of an earlier MADV_DONTDUMP.HwPoison/// **MADV_HWPOISON** - Linux only (since Linux 2.6.32)/// Poison the pages in the range specified by addr and length/// and handle subsequent references to those pages like a/// hardware memory corruption.  This operation is available/// only for privileged (CAP_SYS_ADMIN) processes.  This/// operation may result in the calling process receiving a/// SIGBUS and the page being unmapped./// This feature is intended for testing of memory error-/// handling code; it is available only if the kernel was/// configured with CONFIG_MEMORY_FAILURE.PopulateRead/// **MADV_POPULATE_READ** - Linux only (since Linux 5.14)/// Populate  (prefault)  page  tables readable, faulting in all/// pages in the range just as  if  manually  reading  from  each/// page; however, avoid the actual memory access that would have/// been performed after handling the fault./// In contrast to MAP_POPULATE, MADV_POPULATE_READ does not hide/// errors,  can  be  applied to (parts of) existing mappings and/// will always populate (prefault) page  tables  readable.   One/// example  use  case is prefaulting a file mapping, reading all/// file content from disk; however, pages won't be  dirtied  and/// consequently  won't  have  to  be  written  back to disk when/// evicting the pages from memory./// Depending on the underlying mapping, map the shared zeropage,/// preallocate  memory  or  read the underlying file; files with/// holes might or might not preallocate blocks.   If  populating/// fails, a SIGBUS signal is not generated; instead, an error is/// If MADV_POPULATE_READ succeeds, all  page  tables  have  been/// populated  (prefaulted) readable once.  If MADV_POPULATE_READ/// fails, some page tables might have been populated./// MADV_POPULATE_READ cannot be applied to mappings without read/// permissions  and  special  mappings,  for  example,  mappings/// marked with kernel-internal flags such as VM_PFNMAP or VM_IO,/// or secret memory regions created using memfd_secret(2)./// Note  that with MADV_POPULATE_READ, the process can be killed/// at any moment when the system runs out of memory.PopulateWrite/// **MADV_POPULATE_WRITE** - Linux only (since Linux 5.14)/// Populate (prefault) page tables  writable,  faulting  in  all/// pages  in  the range just as if manually writing to each each/// In  contrast  to  MAP_POPULATE,  MADV_POPULATE_WRITE does not/// hide errors, can be applied to (parts of)  existing  mappings/// and  will  always  populate  (prefault) page tables writable./// One example use case is preallocating  memory,  breaking  any/// CoW (Copy on Write)./// Depending  on  the  underlying mapping, preallocate memory or/// read the underlying file; files with holes  will  preallocate/// blocks.   If  populating fails, a SIGBUS signal is not gener‐/// ated; instead, an error is returned./// If MADV_POPULATE_WRITE succeeds, all page  tables  have  been/// populated (prefaulted) writable once.  If MADV_POPULATE_WRITE/// MADV_POPULATE_WRITE cannot be  applied  to  mappings  without/// write permissions and special mappings, for example, mappings/// Note that with MADV_POPULATE_WRITE, the process can be killed/// Values supported by [`Mmap::advise`][crate::Mmap::advise] and [`MmapMut::advise`][crate::MmapMut::advise] functions./// See [madvise()](https://man7.org/linux/man-pages/man2/madvise.2.html) map page.UncheckedAdviceDontNeed/// **MADV_DONTNEED**/// Do not expect access in the near future.  (For the time/// being, the application is finished with the given range,/// so the kernel can free resources associated with it.)/// After a successful MADV_DONTNEED operation, the semantics/// of memory access in the specified region are changed:/// subsequent accesses of pages in the range will succeed,/// but will result in either repopulating the memory contents/// from the up-to-date contents of the underlying mapped file/// (for shared file mappings, shared anonymous mappings, and/// shmem-based techniques such as System V shared memory/// segments) or zero-fill-on-demand pages for anonymous/// private mappings./// Note that, when applied to shared mappings, MADV_DONTNEED/// might not lead to immediate freeing of the pages in the/// range.  The kernel is free to delay freeing the pages/// until an appropriate moment.  The resident set size (RSS)/// of the calling process will be immediately reduced/// **MADV_DONTNEED** cannot be applied to locked pages, Huge TLB/// pages, or VM_PFNMAP pages.  (Pages marked with the kernel-/// internal VM_PFNMAP flag are special memory areas that are/// not managed by the virtual memory subsystem.  Such pages/// are typically created by device drivers that map the pages/// into user space.)/// Using the returned value with conceptually write to the/// mapped pages, i.e. borrowing the mapping when the pages/// are freed results in undefined behaviour.Free// The rest are Linux-specific/// **MADV_FREE** - Linux (since Linux 4.5) and Darwin/// The application no longer requires the pages in the range/// specified by addr and len.  The kernel can thus free these/// pages, but the freeing could be delayed until memory/// pressure occurs.  For each of the pages that has been/// marked to be freed but has not yet been freed, the free/// operation will be canceled if the caller writes into the/// page.  After a successful MADV_FREE operation, any stale/// data (i.e., dirty, unwritten pages) will be lost when the/// kernel frees the pages.  However, subsequent writes to/// pages in the range will succeed and then kernel cannot/// free those dirtied pages, so that the caller can always/// see just written data.  If there is no subsequent write,/// the kernel can free the pages at any time.  Once pages in/// the range have been freed, the caller will see zero-fill-/// on-demand pages upon subsequent page references./// The MADV_FREE operation can be applied only to private/// anonymous pages (see mmap(2)).  In Linux before version/// 4.12, when freeing pages on a swapless system, the pages/// in the given range are freed instantly, regardless of/// memory pressure./// mapped pages, i.e. borrowing the mapping while the pages/// are still being freed results in undefined behaviour./// **MADV_REMOVE** - Linux only (since Linux 2.6.16)/// Free up a given range of pages and its associated backing/// store.  This is equivalent to punching a hole in the/// corresponding byte range of the backing store (see/// fallocate(2)).  Subsequent accesses in the specified/// address range will see bytes containing zero./// The specified address range must be mapped shared and/// writable.  This flag cannot be applied to locked pages,/// Huge TLB pages, or VM_PFNMAP pages./// In the initial implementation, only tmpfs(5) was supported/// **MADV_REMOVE**; but since Linux 3.5, any filesystem which/// supports the fallocate(2) FALLOC_FL_PUNCH_HOLE mode also/// supports MADV_REMOVE.  Hugetlbfs fails with the error/// EINVAL and other filesystems fail with the error/// EOPNOTSUPP./// Values supported by [`Mmap::unchecked_advise`][crate::Mmap::unchecked_advise] and [`MmapMut::unchecked_advise`][crate::MmapMut::unchecked_advise] functions./// These flags can be passed to the [madvise (2)][man_page] system call/// and effects on the mapped pages which are conceptually writes,/// i.e. the change the observable contents of these pages which/// implies undefined behaviour if the mapping is still borrowed./// Hence, these potentially unsafe flags must be used with the unsafe/// methods and the programmer has to justify that the code/// does not keep any borrows of the mapping active while the mapped pages/// are updated by the kernel's memory management subsystem./// [man_page]: https://man7.org/linux/man-pages/man2/madvise.2.html/// Performs a runtime check if this advice is supported by the kernel./// Only supported on Linux. See the [`madvise(2)`] man page./// [`madvise(2)`]: https://man7.org/linux/man-pages/man2/madvise.2.html#VERSIONStest_is_supported// Future expansion:// MADV_SOFT_OFFLINE  (since Linux 2.6.33)// MADV_WIPEONFORK  (since Linux 4.14)// MADV_KEEPONFORK  (since Linux 4.14)// MADV_COLD  (since Linux 5.4)// MADV_PAGEOUT  (since Linux 5.4)// pedantic exceptionsfile_lenMmapInneradviceMmapRawDescriptoras_raw_descMmapAsRawDeschugeno_reserve_swapMmapOptions/// A memory map builder, providing advanced options and flags for specifying memory map behavior./// `MmapOptions` can be used to create an anonymous memory map using [`map_anon()`], or a/// file-backed memory map using one of [`map()`], [`map_mut()`], [`map_exec()`],/// [`map_copy()`], or [`map_copy_read_only()`]./// All file-backed memory map constructors are marked `unsafe` because of the potential for/// *Undefined Behavior* (UB) using the map if the underlying file is subsequently modified, in or/// out of process. Applications must consider the risk and take appropriate precautions when/// using file-backed maps. Solutions such as file permissions, locks or process-private (e.g./// unlinked) files exist but are platform specific and limited./// [`map_anon()`]: MmapOptions::map_anon()/// [`map()`]: MmapOptions::map()/// [`map_mut()`]: MmapOptions::map_mut()/// [`map_exec()`]: MmapOptions::map_exec()/// [`map_copy()`]: MmapOptions::map_copy()/// [`map_copy_read_only()`]: MmapOptions::map_copy_read_only()/// Creates a new set of options for configuring and creating a memory map./// use memmap2::{MmapMut, MmapOptions};/// # use std::io::Result;/// // Create a new memory map builder./// let mut mmap_options = MmapOptions::new();/// // Configure the memory map builder using option setters, then create/// // a memory map using one of `mmap_options.map_anon`, `mmap_options.map`,/// // `mmap_options.map_mut`, `mmap_options.map_exec`, or `mmap_options.map_copy`:/// let mut mmap: MmapMut = mmap_options.len(36).map_anon()?;/// // Use the memory map:/// mmap.copy_from_slice(b"...data to copy to the memory map...");/// Configures the memory map to start at byte `offset` from the beginning of the file./// This option has no effect on anonymous memory maps./// By default, the offset is 0./// use memmap2::MmapOptions;/// # fn main() -> std::io::Result<()> {/// let mmap = unsafe {///     MmapOptions::new()///                 .offset(30)///                 .map(&File::open("LICENSE-APACHE")?)?/// assert_eq!(&b"Apache License"[..],///            &mmap[..14]);/// Configures the created memory mapped buffer to be `len` bytes long./// This option is mandatory for anonymous memory maps./// For file-backed memory maps, the length will default to the file length.///                 .len(9)///                 .map(&File::open("README.md")?)?/// assert_eq!(&b"# memmap2"[..], &mmap[..]);validate_lenget_len/// Returns the configured length, or the length of the provided file./// Configures the anonymous memory map to be suitable for a process or thread stack./// This option corresponds to the `MAP_STACK` flag on Linux. It has no effect on Windows./// This option has no effect on file-backed memory maps./// let stack = MmapOptions::new().stack().len(4096).map_anon();/// Configures the anonymous memory map to be allocated using huge pages./// This option corresponds to the `MAP_HUGETLB` flag on Linux. It has no effect on Windows./// The size of the requested page can be specified in page bits. If not provided, the system/// default is requested. The requested length should be a multiple of this, or the mapping/// let stack = MmapOptions::new().huge(Some(21)).len(2*1024*1024).map_anon();/// The number 21 corresponds to `MAP_HUGE_2MB`. See mmap(2) for more details./// Populate (prefault) page tables for a mapping./// For a file mapping, this causes read-ahead on the file. This will help to reduce blocking on page faults later./// This option corresponds to the `MAP_POPULATE` flag on Linux. It has no effect on Windows./// let file = File::open("LICENSE-MIT")?;///     MmapOptions::new().populate().map(&file)?/// assert_eq!(&b"Copyright"[..], &mmap[..9]);/// Do not reserve swap space for the memory map./// By default, platforms may reserve swap space for memory maps./// This guarantees that a write to the mapped memory will succeed, even if physical memory is exhausted./// Otherwise, the write to memory could fail (on Linux with a segfault)./// This option requests that no swap space will be allocated for the memory map,/// which can be useful for extremely large maps that are only written to sparsely./// This option is currently supported on Linux, Android, macOS, iOS, NetBSD, Solaris and Illumos./// On those platforms, this option corresponds to the `MAP_NORESERVE` flag./// On Linux, this option is ignored if [`vm.overcommit_memory`](https://www.kernel.org/doc/Documentation/vm/overcommit-accounting) is set to 2.///     MmapOptions::new().no_reserve_swap().map_copy(&file)?/// Creates a read-only memory map backed by a file./// See the [type-level][MmapOptions] docs for why this function is unsafe./// This method returns an error when the underlying system call fails, which can happen for a/// variety of reasons, such as when the file is not open with read permissions./// let mut file = File::open("LICENSE-APACHE")?;/// file.read_to_end(&mut contents)?;///     MmapOptions::new().map(&file)?/// assert_eq!(&contents[..], &mmap[..]);map_exec/// Creates a readable and executable memory map backed by a file.MmapMut/// Creates a writeable memory map backed by a file./// variety of reasons, such as when the file is not open with read and write permissions./// # let tempdir = tempfile::tempdir()?;/// let path: PathBuf = /* path to file *//// #   tempdir.path().join("map_mut");/// let file = OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&path)?;/// file.set_len(13)?;/// let mut mmap = unsafe {///     MmapOptions::new().map_mut(&file)?/// mmap.copy_from_slice(b"Hello, world!");map_copy/// Creates a copy-on-write memory map backed by a file./// Data written to the memory map will not be visible by other processes,/// and will not be carried through to the underlying file./// variety of reasons, such as when the file is not open with writable permissions./// let file = File::open("LICENSE-APACHE")?;/// let mut mmap = unsafe { MmapOptions::new().map_copy(&file)? };/// (&mut mmap[..]).write_all(b"Hello, world!")?;map_copy_read_only/// Creates a copy-on-write read-only memory map backed by a file./// let mut file = File::open("README.md")?;///     MmapOptions::new().map_copy_read_only(&file)?map_anon/// Creates an anonymous memory map./// The memory map length should be configured using [`MmapOptions::len()`]/// before creating an anonymous memory map, otherwise a zero-length mapping/// will be crated./// This method returns an error when the underlying system call fails or/// when `len > isize::MAX`.map_rawMmapRaw/// Creates a raw memory map.map_raw_read_only/// Creates a read-only raw memory map/// This is primarily useful to avoid intermediate `Mmap` instances when/// read-only access to files modified elsewhere are required./// This method returns an error when the underlying system call fails/// A handle to an immutable memory mapped buffer./// A `Mmap` may be backed by a file, or it can be anonymous map, backed by volatile memory. Use/// [`MmapOptions`] or [`map()`] to create a file-backed memory map. To create an immutable/// anonymous memory map, first create a mutable anonymous memory map, and then make it immutable/// with [`MmapMut::make_read_only()`]./// A file backed `Mmap` is created by `&File` reference, and will remain valid even after the/// `File` is dropped. In other words, the `Mmap` handle is completely independent of the `File`/// used to create it. For consistency, on some platforms this is achieved by duplicating the/// underlying file handle. The memory will be unmapped when the `Mmap` handle is dropped./// Dereferencing and accessing the bytes of the buffer may result in page faults (e.g. swapping/// the mapped pages into physical memory) though the details of this are platform specific./// `Mmap` is [`Sync`] and [`Send`]./// See [`MmapMut`] for the mutable version./// out of process. Applications must consider the risk and take appropriate precautions when using/// file-backed maps. Solutions such as file permissions, locks or process-private (e.g. unlinked)/// files exist but are platform specific and limited./// let file = File::open("README.md")?;/// let mmap = unsafe { MmapOptions::new().map(&file)? };/// assert_eq!(b"# memmap2", &mmap[0..9]);/// [`map()`]: Mmap::map()/// This is equivalent to calling `MmapOptions::new().map(file)`./// See the [type-level][Mmap] docs for why this function is unsafe./// let mmap = unsafe { Mmap::map(&file)?  };/// Transition the memory map to be writable./// If the memory map is file-backed, the file must have been opened with write permissions./// use std::ops::DerefMut;/// # use std::fs::OpenOptions;/// let file = /* file opened with write permissions *//// #          OpenOptions::new()/// #                      .read(true)/// #                      .write(true)/// #                      .create(true)/// #                      .truncate(true)/// #                      .open(tempdir.path()/// #                      .join("make_mut"))?;/// # file.set_len(128)?;/// let mmap = unsafe { Mmap::map(&file)? };/// // ... use the read-only memory map .../// let mut mut_mmap = mmap.make_mut()?;/// mut_mmap.deref_mut().write_all(b"hello, world!")?;advise/// Advise OS how this memory map will be accessed./// Only supported on Unix.unchecked_advise/// Used with the [unchecked flags][UncheckedAdvice]. Only supported on Unix.advise_range/// Advise OS how this range of memory map will be accessed./// The offset and length must be in the bounds of the memory map.unchecked_advise_range/// Lock the whole memory map into RAM. Only supported on Unix./// See [mlock()](https://man7.org/linux/man-pages/man2/mlock.2.html) map page./// Unlock the whole memory map. Only supported on Unix./// See [munlock()](https://man7.org/linux/man-pages/man2/munlock.2.html) map page.RemapOptions/// Adjust the size of the memory mapping./// This will try to resize the memory mapping in place. If/// [`RemapOptions::may_move`] is specified it will move the mapping if it/// could not resize in place, otherwise it will error./// Only supported on Linux./// See the [`mremap(2)`] man page./// Resizing the memory mapping beyond the end of the mapped file will/// result in UB should you happen to access memory beyond the end of the/// [`mremap(2)`]: https://man7.org/linux/man-pages/man2/mremap.2.html/// A handle to a raw memory mapped buffer./// This struct never hands out references to its interior, only raw pointers./// This can be helpful when creating shared memory maps between untrusted processes./// For the safety concerns that arise when converting these raw pointers to references,/// see the [`Mmap`] safety documentation./// This is equivalent to calling `MmapOptions::new().map_raw(file)`./// Returns a raw pointer to the memory mapped file./// Before dereferencing this pointer, you have to make sure that the file has not been/// truncated since the memory map was created./// Avoiding this will not introduce memory safety issues in Rust terms,/// but will cause SIGBUS (or equivalent) signal./// Returns an unsafe mutable pointer to the memory mapped file./// Returns the length in bytes of the memory map./// Note that truncating the file can cause the length to change (and render this value unusable)./// Flushes outstanding memory map modifications to disk./// When this method returns with a non-error result, all outstanding changes to a file-backed/// memory map are guaranteed to be durably stored. The file's metadata (including last/// modification timestamp) may not be updated./// use memmap2::MmapRaw;/// let tempdir = tempfile::tempdir()?;/// #   tempdir.path().join("flush");/// file.set_len(128)?;/// let mut mmap = unsafe { MmapRaw::map_raw(&file)? };/// let mut memory = unsafe { slice::from_raw_parts_mut(mmap.as_mut_ptr(), 128) };/// memory.write_all(b"Hello, world!")?;/// mmap.flush()?;/// Asynchronously flushes outstanding memory map modifications to disk./// This method initiates flushing modified pages to durable storage, but it will not wait for/// the operation to complete before returning. The file's metadata (including lastflush_range/// Flushes outstanding memory map modifications in the range to disk./// memory in the range are guaranteed to be durable stored. The file's metadata (including/// last modification timestamp) may not be updated. It is not guaranteed the only the changes/// in the specified range are flushed; other outstanding changes to the memory map may be/// flushed as well.flush_async_range/// Asynchronously flushes outstanding memory map modifications in the range to disk./// modification timestamp) may not be updated. It is not guaranteed that the only changes/// flushed are those in the specified range; other outstanding changes to the memory map may/// be flushed as well./// A handle to a mutable memory mapped buffer./// A file-backed `MmapMut` buffer may be used to read from or write to a file. An anonymous/// `MmapMut` buffer may be used any place that an in-memory byte buffer is needed. Use/// [`MmapMut::map_mut()`] and [`MmapMut::map_anon()`] to create a mutable memory map of the/// respective types, or [`MmapOptions::map_mut()`] and [`MmapOptions::map_anon()`] if non-default/// options are required./// A file backed `MmapMut` is created by `&File` reference, and will remain valid even after the/// `File` is dropped. In other words, the `MmapMut` handle is completely independent of the `File`/// underlying file handle. The memory will be unmapped when the `MmapMut` handle is dropped./// `MmapMut` is [`Sync`] and [`Send`]./// See [`Mmap`] for the immutable version./// This is equivalent to calling `MmapOptions::new().map_mut(file)`./// See the [type-level][MmapMut] docs for why this function is unsafe./// use memmap2::MmapMut;///                        .read(true)///                        .write(true)///                        .create(true)///                        .truncate(true)///                        .open(&path)?;/// let mut mmap = unsafe { MmapMut::map_mut(&file)? };/// This is equivalent to calling `MmapOptions::new().len(length).map_anon()`.make_read_only/// Returns an immutable version of this memory mapped buffer./// If the memory map is file-backed, the file must have been opened with read permissions./// variety of reasons, such as when the file has not been opened with read permissions./// use memmap2::{Mmap, MmapMut};/// let mut mmap = MmapMut::map_anon(128)?;/// (&mut mmap[..]).write(b"Hello, world!")?;/// let mmap: Mmap = mmap.make_read_only()?;make_exec/// Transition the memory map to be readable and executable./// If the memory map is file-backed, the file must have been opened with execute permissions./// On systems with separate instructions and data caches (a category that includes many ARM/// chips), a platform-specific call may be needed to ensure that the changes are visible to the/// execution unit (e.g. when using this function to implement a JIT compiler).  For more/// details, see [this ARM write-up](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/caches-and-self-modifying-code)/// or the `man` page for [`sys_icache_invalidate`](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/sys_icache_invalidate.3.html)./// variety of reasons, such as when the file has not been opened with execute permissions.may_move/// Options for [`Mmap::remap`] and [`MmapMut::remap`]./// Creates a mew set of options for resizing a memory map./// Controls whether the memory map can be moved if it is not possible to/// resize it in place./// If false then the memory map is guaranteed to remain at the same/// address when being resized but attempting to resize will return an/// error if the new memory map would overlap with something else in the/// current process' memory./// By default this is false./// # `may_move` and `StableDeref`/// If the `stable_deref_trait` feature is enabled then [`Mmap`] and/// [`MmapMut`] implement `StableDeref`. `StableDeref` promises that the/// memory map dereferences to a fixed address, however, calling `remap`/// with `may_move` set may result in the backing memory of the mapping/// being moved to a new address. This may cause UB in other code/// depending on the `StableDeref` guarantees.into_flagsmap_filemap_fdmap_empty_file/// Checks that "mapping" a 0-length file derefs to an empty slice.map_anon_zero_lenmap_offsetsync_sendjit_x86jit_x86_anonjit_x86_filemprotect_filemprotect_copymprotect_anonraw_read_onlyadvise_writes_unsafelyadvise_writes_unsafely_to_part_of_map/// Returns true if a non-zero amount of memory is locked.remap_growremap_shrinkremap_with_offset//! A cross-platform Rust API for memory mapped buffers.//! The core functionality is provided by either [`Mmap`] or [`MmapMut`],//! which correspond to mapping a [`File`] to a [`&[u8]`](https://doc.rust-lang.org/std/primitive.slice.html)//! or [`&mut [u8]`](https://doc.rust-lang.org/std/primitive.slice.html)//! respectively. Both function by dereferencing to a slice, allowing the//! [`Mmap`]/[`MmapMut`] to be used in the same way you would the equivalent slice//! [`File`]: std::fs::File//! For simple cases [`Mmap`] can be used directly://! use std::io::Read;//! use memmap2::Mmap;//! let mut file = File::open("LICENSE-APACHE")?;//! let mut contents = Vec::new();//! file.read_to_end(&mut contents)?;//! let mmap = unsafe { Mmap::map(&file)?  };//! assert_eq!(&contents[..], &mmap[..]);//! However for cases which require configuration of the mapping, then//! you can use [`MmapOptions`] in order to further configure a mapping//! before you create it.// A stable alternative to https://doc.rust-lang.org/stable/std/primitive.never.html/// Creates a new `MmapInner`./// This is a thin wrapper around the `mmap` system call.adjust_mmap_paramsas_mmap_params/// Get the current memory mapping as a `(ptr, map_len, offset)` tuple./// Note that `map_len` is the length of the memory mapping itself and/// _not_ the one that would be passed to `from_raw_parts`./// Construct this `MmapInner` from its raw components/// - `ptr` must point to the start of memory mapping that can be freed///   using `munmap(2)` (i.e. returned by `mmap(2)` or `mremap(2)`)/// - The memory mapping at `ptr` must have a length of `len + offset`./// - If `len + offset == 0` then the memory mapping must be of length 1./// - `offset` must be less than the current page size./// Open an anonymous memory map.LPHANDLESIZE_TDWORD_PTRLPSECURITY_ATTRIBUTESLPSYSTEM_INFOSTANDARD_RIGHTS_REQUIREDSECTION_QUERYSECTION_MAP_WRITESECTION_MAP_READSECTION_MAP_EXECUTESECTION_EXTEND_SIZESECTION_MAP_EXECUTE_EXPLICITSECTION_ALL_ACCESSPAGE_READONLYPAGE_READWRITEPAGE_WRITECOPYPAGE_EXECUTE_READPAGE_EXECUTE_READWRITEPAGE_EXECUTE_WRITECOPYFILE_MAP_WRITEFILE_MAP_READFILE_MAP_ALL_ACCESSFILE_MAP_EXECUTEFILE_MAP_COPYnLengthlpSecurityDescriptorbInheritHandlewProcessorArchitecturewReserveddwPageSizelpMinimumApplicationAddresslpMaximumApplicationAddressdwActiveProcessorMaskdwNumberOfProcessorsdwProcessorTypedwAllocationGranularitywProcessorLevelwProcessorRevisionCreateFileMappingWFlushFileBuffersFlushViewOfFileUnmapViewOfFileMapViewOfFileVirtualProtectempty_slice_ptr/// Returns a fixed aligned pointer that is valid for `slice::from_raw_parts::<u8>` with `len == 0`./// This aligns the pointer to `allocation_granularity()` or 1 if unknown./// This is a thin wrapper around the `CreateFileMappingW` and `MapViewOfFile` system calls.virtual_protectprotection_supportedallocation_granularitysize_of_pointee/// Use type inference to obtain the size of the pointee (without actually using the pointer).__priv/// Hidden module for things the macros need to access.raw_fieldspan_of// Copyright (c) 2017 Gilad Naaman// Permission is hereby granted, free of charge, to any person obtaining a copy// of this software and associated documentation files (the "Software"), to deal// in the Software without restriction, including without limitation the rights// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell// copies of the Software, and to permit persons to whom the Software is// furnished to do so, subject to the following conditions:// The above copyright notice and this permission notice shall be included in all// copies or substantial portions of the Software.// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE// SOFTWARE.//! A crate used for calculating offsets of struct members and their spans.//! This functionality currently can not be used in compile time code such as `const` or `const fn` definitions.//! use memoffset::{offset_of, span_of};//! #[repr(C, packed)]//! struct HelpMeIAmTrappedInAStructFactory {//!     help_me_before_they_: [u8; 15],//!     a: u32//!     assert_eq!(offset_of!(HelpMeIAmTrappedInAStructFactory, a), 15);//!     assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, a), 15..19);//!     assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, help_me_before_they_ .. a), 0..15);//! This functionality can be useful, for example, for checksum calculations://! struct Message {//!     header: MessageHeader,//!     fragment_index: u32,//!     fragment_count: u32,//!     payload: [u8; 1024],//!     checksum: u16//! let checksum_range = &raw[span_of!(Message, header..checksum)];//! let checksum = crc16(checksum_range);_memoffset__let_base_ptr/// Macro to create a local `base_ptr` raw pointer of the given type, avoiding UB as/// much as is possible currently._memoffset_offset_from_unsafe/// Calculates the offset of the specified field from the start of the named struct./// use memoffset::offset_of;///     b: u64,///     c: [u8; 5]///     assert_eq!(offset_of!(Foo, a), 0);///     assert_eq!(offset_of!(Foo, b), 4);offset_of_tuple/// Calculates the offset of the specified field from the start of the tuple./// use memoffset::offset_of_tuple;///     assert!(offset_of_tuple!((u8, u32), 1) >= 0, "Tuples do not have a defined layout");offset_simpleoffset_simple_packed// this creates unaligned referencestuple_structinside_generic_methodtest_tuple_offsettest_raw_fieldtest_raw_field_tuple_memoffset__addr_of/// `addr_of!`, or just ref-then-cast when that is not available._memoffset__field_check/// Deref-coercion protection macro._memoffset__field_check_tuple/// Computes a const raw pointer to the given field of the given base pointer/// to the given parent type./// The `base` pointer *must not* be dangling, but it *may* point to/// uninitialized memory.raw_field_tuple/// to the given parent tuple typle.// Copyright (c) 2020 Gilad Naaman, Ralf Jung_memoffset__compile_error/// Reexport for `local_inner_macros`; see/// <https://doc.rust-lang.org/edition-guide/rust-2018/macros/macro-changes.html#macros-using-local_inner_macros>.// No explicit begin for range.// Explicit begin and end for range.// No explicit end for range.// Just one field.// Parsing.// Entry point./// Produces a range instance representing the sub-slice containing the specified member./// This macro provides 2 forms of differing functionalities./// The first form is identical to the appearance of the `offset_of!` macro./// span_of!(Struct, member)/// The second form of `span_of!` returns a sub-slice which starts at one field, and ends at another./// The general pattern of this form is:/// // Exclusive/// span_of!(Struct, member_a .. member_b)/// // Inclusive/// span_of!(Struct, member_a ..= member_b)/// // Open-ended ranges/// span_of!(Struct, .. end)/// span_of!(Struct, start ..)/// *Note*:/// This macro uses recursion in order to resolve the range expressions, so there is a limit to/// the complexity of the expression./// In order to raise the limit, the compiler's recursion limit should be lifted./// use memoffset::span_of;/// struct Florp {///     a: u32/// struct Blarg {///     x: [u32; 2],///     y: [u8; 56],///     z: Florp,///     egg: [[u8; 4]; 4]///     assert_eq!(0..84,  span_of!(Blarg, ..));///     assert_eq!(0..8,   span_of!(Blarg, .. y));///     assert_eq!(0..64,  span_of!(Blarg, ..= y));///     assert_eq!(0..8,   span_of!(Blarg, x));///     assert_eq!(8..84,  span_of!(Blarg, y ..));///     assert_eq!(0..8,   span_of!(Blarg, x .. y));///     assert_eq!(0..64,  span_of!(Blarg, x ..= y));span_simplespan_simple_packedspan_formsig_test/// Rust's ABI is unstable, and [type layout can be changed with each/// compilation](https://doc.rust-lang.org/reference/type-layout.html)./// Using `offset_of!` with a `repr(Rust)` struct will return the correct offset of the/// specified `field` for a particular compilation, but the exact value may change/// based on the compiler version, concrete struct type, time of day, or rustc's mood./// As a result, the value should not be retained and used between different compilations.offset_of_union/// Calculates the offset of the specified union member from the start of the union./// use memoffset::offset_of_union;/// union Foo {///     foo32: i32,///     foo64: i64,///     assert!(offset_of_union!(Foo, foo64) == 0);/// Due to macro_rules limitations, this macro will accept structs with a single field as well as unions./// This is not a stable guarantee, and future versions of this crate might fail/// on any use of this macro with a struct, without a semver bump.offset_uniontest_raw_field_union/// Prevents complilation if the specified field name is not a part of the/// struct definition./// use memoffset::_memoffset__field_check;///     foo: i32,/// type BoxedFoo = Box<Foo>;/// _memoffset__field_check!(BoxedFoo, foo);/// Prevents complilation if the specified type is not a tuple./// use memoffset::_memoffset__field_check_tuple;/// _memoffset__field_check_tuple!(i32, 0);_memoffset__field_check_union/// Deref-coercion protection macro for unions./// Unfortunately accepts single-field structs as well, which is not ideal,/// but ultimately pretty harmless./// use memoffset::_memoffset__field_check_union;///     variant_a: i32,/// _memoffset__field_check_union!(BoxedFoo, variant_a);raw_field_union/// This macro is the same as `raw_field`, except for a different Deref-coercion check that/// supports unions./// Due to macro_rules limitations, this check will accept structs with a single field as well as unions./// ### Note/// ### Safety/// The inter-field form mentioned above assumes that the first field is positioned before the/// second./// This is only guarenteed for `repr(C)` structs./// Usage with `repr(Rust)` structs may yield unexpected results, like downward-going ranges,/// spans that include unexpected fields, empty spans, or spans that include *unexpected* padding bytes.//! assert_eq!(offset_of!(HelpMeIAmTrappedInAStructFactory, a), 15);//! assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, a), 15..19);//! assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, help_me_before_they_ .. a), 0..15);/// Macro to compute the distance between two pointers._memoffset__offset_of_impl/// assert_eq!(offset_of!(Foo, a), 0);/// assert_eq!(offset_of!(Foo, b), 4);_memoffset__offset_of_tuple_impl/// assert!(offset_of_tuple!((u8, u32), 1) >= 0, "Tuples do not have a defined layout");_memoffset__offset_of_union_impl/// assert!(offset_of_union!(Foo, foo64) == 0);/// Due to `macro_rules!` limitations, this macro will accept structs with a single field as well as unions.const_offsetconst_offset_interior_mutableconst_fn_offset// For `... + 0` constructs below./// Prevents compilation if the specified field name is not a part of the/// Prevents compilation if the specified type is not a tuple./// to the given parent tuple type./// Due to `macro_rules!` limitations, this check will accept structs with a single field as well as unions./// This is only guaranteed for `repr(C)` structs./// assert_eq!(0..84,  span_of!(Blarg, ..));/// assert_eq!(0..8,   span_of!(Blarg, .. y));/// assert_eq!(0..64,  span_of!(Blarg, ..= y));/// assert_eq!(0..8,   span_of!(Blarg, x));/// assert_eq!(8..84,  span_of!(Blarg, y ..));/// assert_eq!(0..8,   span_of!(Blarg, x .. y));/// assert_eq!(0..64,  span_of!(Blarg, x ..= y));extended_floatExtendedFloatlower_n_halfwaylower_n_maskroundinground_nearest_tie_evenBASE10_POWERSbellerophon/// Core implementation of the Bellerophon algorithm./// Create an extended-precision float, scale it to the proper radix power,/// calculate the bits of slop, and return the representation. The value/// will always be guaranteed to be within 1 bit, rounded-down, of the real/// value. If a negative exponent is returned, this represents we were/// unable to unambiguously round the significant digits./// This has been modified to return a biased, rather than unbiased exponent.error_scale/// Get the full error scale.error_halfscale/// Get the half error scale.error_is_accurate/// Determine if the number of errors is tolerable for float precision./// Normalize float-point number./// Shift the mantissa so the number of leading zeros is 0, or the value/// itself is 0./// Get the number of bytes shifted./// Multiply two normalized extended-precision floats, as if by `a*b`./// The precision is maximal when the numbers are normalized, however,/// decent precision will occur as long as both values have high bits/// set. The result is not normalized./// Algorithm:///     1. Non-signed multiplication of mantissas (requires 2x as many bits as input).///     2. Normalization of the result (not done here).///     3. Addition of exponents.// Pre-calculated small powers.large// Pre-calculated large powers.small_int/// Pre-calculated small powers as 64-bit integers// Step between large powers and number of small powers.// Exponent bias for the large powers./// ceil(log2(radix)) scaled as a multiplier.log2_shift/// Bitshift for the log2 multiplier.BellerophonPowers/// Precalculated powers of base N for the Bellerophon algorithm.get_smallget_largeget_small_int/// Allow indexing of values without bounds checking//! An implementation of Clinger's Bellerophon algorithm.//! This is a moderate path algorithm that uses an extended-precision//! float, represented in 80 bits, by calculating the bits of slop//! and determining if those bits could prevent unambiguous rounding.//! This algorithm requires less static storage than the Lemire algorithm,//! and has decent performance, and is therefore used when non-decimal,//! non-power-of-two strings need to be parsed. Clinger's algorithm//! is described in depth in "How to Read Floating Point Numbers Accurately.",//! available online [here](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.45.4152&rep=rep1&type=pdf).//! This implementation is loosely based off the Golang implementation,//! found [here](https://github.com/golang/go/blob/b10849fbb97a2244c086991b4623ae9f32c212d0/src/strconv/extfloat.go).//! This code is therefore subject to a 3-clause BSD license.// ALGORITHM// ---------// ERRORS// ------// Calculate if the errors in calculating the extended-precision float.// Specifically, we want to know if we are close to a halfway representation,// or halfway between `b` and `b+1`, or `b+h`. The halfway representation// has the form://     SEEEEEEEHMMMMMMMMMMMMMMMMMMMMMMM100...// where://     S = Sign Bit//     E = Exponent Bits//     H = Hidden Bit//     M = Mantissa Bits// The halfway representation has a bit set 1-after the mantissa digits,// and no bits set immediately afterward, making it impossible to// round between `b` and `b+1` with this representation.// MATH// ----// POWERSstackvecStackVecLARGE_POW5LARGE_POW5_STEPBIGINT_BITS/// Number of bits in a Bigint./// This needs to be at least the number of bits required to store/// a Bigint, which is `log2(radix**digits)`./// ≅ 3600 for base-10, rounded-up.BIGINT_LIMBS/// The number of limbs for the bigint.VecType/// Significant digits for the float, stored in a big integer in LE order./// This is pretty much the same number of digits for any radix, since the///  significant digits balances out the zeros from the exponent:///     1. Decimal is 1091 digits, 767 mantissa digits + 324 exponent zeros.///     2. Base 6 is 1097 digits, or 680 mantissa digits + 417 exponent zeros.///     3. Base 36 is 1086 digits, or 877 mantissa digits + 209 exponent zeros./// However, the number of bytes required is larger for large radixes:/// for decimal, we need `log2(10**1091) ≅ 3600`, while for base 36/// we need `log2(36**1086) ≅ 5600`. Since we use uninitialized data,/// we avoid a major performance hit from the large buffer size.Bigint/// Storage for a big integer type./// This is used for algorithms when we have a finite number of digits./// Specifically, it stores all the significant digits scaled to the/// proper exponent, as an integral type, and then directly compares/// these digits./// This requires us to store the number of significant bits, plus the/// number of exponent bits (required) since we scale everything/// to the same exponent./// Construct a bigint representing 0./// Construct a bigint from an integer.hi64/// Multiply and assign as if by exponentiation by a power./// Calculate the bit-length of the big-integer.ReverseView/// REVERSE VIEW/// Reverse, immutable view of a sequence.rview/// Create a reverse view of the vector for indexing./// Compare `x` to `y`, in little-endian order./// Normalize the integer, so any leading zero values are removed./// Get if the big integer is normalized./// Create StackVec from u64 value./// Check if any of the remaining bits are non-zero./// Safe as long as `rindex <= x.len()`.u32_to_hi64_1/// Shift 32-bit integer to high 64-bits.u32_to_hi64_2/// Shift 2 32-bit integers to high 64-bits.u32_to_hi64_3/// Shift 3 32-bit integers to high 64-bits.u64_to_hi64_1/// Shift 64-bit integer to high 64-bits.u64_to_hi64_2/// Shift 2 64-bit integers to high 64-bits.// # Safety// Safe as long as the `stackvec.len() >= 1`.// Safe as long as the `stackvec.len() >= 2`.// Safe as long as the `stackvec.len() >= 3`./// Extract the hi bits from the buffer./// Get the high 64 bits from the vector./// MulAssign by a power of 5./// Theoretically.../// Use an exponentiation by squaring method, since it reduces the time/// complexity of the multiplication to ~`O(log(n))` for the squaring,/// and `O(n*m)` for the result. Since `m` is typically a lower-order/// factor, this significantly reduces the number of multiplications/// we need to do. Iteratively multiplying by small powers follows/// the nth triangular number series, which scales as `O(p^2)`, but/// where `p` is `n+m`. In short, it scales very poorly./// Practically..../// Exponentiation by Squaring:///     running 2 tests///     test bigcomp_f32_lexical ... bench:       1,018 ns/iter (+/- 78)///     test bigcomp_f64_lexical ... bench:       3,639 ns/iter (+/- 1,007)/// Exponentiation by Iterative Small Powers:///     test bigcomp_f32_lexical ... bench:         518 ns/iter (+/- 31)///     test bigcomp_f64_lexical ... bench:         583 ns/iter (+/- 47)/// Exponentiation by Iterative Large Powers (of 2):///     test bigcomp_f32_lexical ... bench:         671 ns/iter (+/- 31)///     test bigcomp_f64_lexical ... bench:       1,394 ns/iter (+/- 47)/// The following benchmarks were run on `1 * 5^300`, using native `pow`,/// a version with only small powers, and one with pre-computed powers/// of `5^(3 * max_exp)`, rather than `5^(5 * max_exp)`./// However, using large powers is crucial for good performance for higher/// powers.///     pow/default             time:   [426.20 ns 427.96 ns 429.89 ns]///     pow/small               time:   [2.9270 us 2.9411 us 2.9565 us]///     pow/large:3             time:   [838.51 ns 842.21 ns 846.27 ns]/// Even using worst-case scenarios, exponentiation by squaring is/// significantly slower for our workloads. Just multiply by small powers,/// in simple cases, and use precalculated large powers in other cases./// Furthermore, using sufficiently big large powers is also crucial for/// performance. This is a tradeoff of binary size and performance, and/// using a single value at ~`5^(5 * max_exp)` seems optimal.scalar_add/// Add two small integers and return the resulting value and if overflow happens./// Multiply two small integers (with carry) (and return the overflow contribution)./// Returns the (low, high) components.small_add_from/// Add small integer to bigint starting from offset.small_add/// Add small integer to bigint.small_mul/// Multiply bigint by small integer.large_add_from/// Add bigint to bigint starting from offset.large_add/// Add bigint to bigint.long_mul/// Grade-school multiplication algorithm./// Slow, naive algorithm, using limb-bit bases and just shifting left for/// each iteration. This could be optimized with numerous other algorithms,/// but it's extremely simple, and works in O(n*m) time, which is fine/// by me. Each iteration, of which there are `m` iterations, requires/// `n` multiplications, and `n` additions, or grade-school multiplication./// Don't use Karatsuba multiplication, since out implementation seems to/// be slower asymptotically, which is likely just due to the small sizes/// we deal with here. For example, running on the following data:/// const SMALL_X: &[u32] = &[///     766857581, 3588187092, 1583923090, 2204542082, 1564708913, 2695310100, 3676050286,///     1022770393, 468044626, 446028186/// const SMALL_Y: &[u32] = &[///     3945492125, 3250752032, 1282554898, 1708742809, 1131807209, 3171663979, 1353276095,///     1678845844, 2373924447, 3640713171/// const LARGE_X: &[u32] = &[///     3647536243, 2836434412, 2154401029, 1297917894, 137240595, 790694805, 2260404854,///     3872698172, 690585094, 99641546, 3510774932, 1672049983, 2313458559, 2017623719,///     638180197, 1140936565, 1787190494, 1797420655, 14113450, 2350476485, 3052941684,///     1993594787, 2901001571, 4156930025, 1248016552, 848099908, 2660577483, 4030871206,///     692169593, 2835966319, 1781364505, 4266390061, 1813581655, 4210899844, 2137005290,///     2346701569, 3715571980, 3386325356, 1251725092, 2267270902, 474686922, 2712200426,///     197581715, 3087636290, 1379224439, 1258285015, 3230794403, 2759309199, 1494932094,///     326310242/// const LARGE_Y: &[u32] = &[///     1574249566, 868970575, 76716509, 3198027972, 1541766986, 1095120699, 3891610505,///     2322545818, 1677345138, 865101357, 2650232883, 2831881215, 3985005565, 2294283760,///     3468161605, 393539559, 3665153349, 1494067812, 106699483, 2596454134, 797235106,///     705031740, 1209732933, 2732145769, 4122429072, 141002534, 790195010, 4014829800,///     1303930792, 3649568494, 308065964, 1233648836, 2807326116, 79326486, 1262500691,///     621809229, 2258109428, 3819258501, 171115668, 1139491184, 2979680603, 1333372297,///     1657496603, 2790845317, 4090236532, 4220374789, 601876604, 1828177209, 2372228171,///     2247372529/// We get the following results:/// mul/small:long          time:   [220.23 ns 221.47 ns 222.81 ns]/// Found 4 outliers among 100 measurements (4.00%)///   2 (2.00%) high mild///   2 (2.00%) high severe/// mul/small:karatsuba     time:   [233.88 ns 234.63 ns 235.44 ns]/// Found 11 outliers among 100 measurements (11.00%)///   8 (8.00%) high mild///   3 (3.00%) high severe/// mul/large:long          time:   [1.9365 us 1.9455 us 1.9558 us]/// Found 12 outliers among 100 measurements (12.00%)///   7 (7.00%) high mild///   5 (5.00%) high severe/// mul/large:karatsuba     time:   [4.4250 us 4.4515 us 4.4812 us]/// In short, Karatsuba multiplication is never worthwhile for out use-case.large_mul/// Multiply bigint by bigint using grade-school multiplication algorithm.shl_bits/// Shift-left `n` bits inside a buffer.shl_limbs/// Shift-left `n` limbs inside a buffer./// Shift-left buffer by n bits./// Get number of leading zero bits in the storage.LIMB_BITS//! A simple big-integer type for slow path algorithms.//! This includes minimal stackvector for use in big-integer arithmetic.// COMPARE// -------// NORMALIZE// FROM// HI// --// These return the high X bits and if the bits were truncated.// SCALAR// SMALL// -----// LARGE// SHIFT// LIMB//  Type for a single limb of the big integer.//  A limb is analogous to a digit in base10, except, it stores 32-bit//  or 64-bit numbers instead. We want types where 64-bit multiplication//  is well-supported by the architecture, rather than emulated in 3//  instructions. The quickest way to check this support is using a//  cross-compiler for numerous architectures, along with the following//  source file and command://  Compile with `gcc main.c -c -S -O3 -masm=intel`//  And the source code is://  ```text//  #include <stdint.h>//  struct i128 {//      uint64_t hi;//      uint64_t lo;//  };//  // Type your code here, or load an example.//  struct i128 square(uint64_t x, uint64_t y) {//      __int128 prod = (__int128)x * (__int128)y;//      struct i128 z;//      z.hi = (uint64_t)(prod >> 64);//      z.lo = (uint64_t)prod;//      return z;//  }//  ```//  If the result contains `call __multi3`, then the multiplication//  is emulated by the compiler. Otherwise, it's natively supported.//  This should be all-known 64-bit platforms supported by Rust.//      https://forge.rust-lang.org/platform-support.html//  # Supported//  Platforms where native 128-bit multiplication is explicitly supported://      - x86_64 (Supported via `MUL`).//      - mips64 (Supported via `DMULTU`, which `HI` and `LO` can be read-from).//      - s390x (Supported via `MLGR`).//  # Efficient//  Platforms where native 64-bit multiplication is supported and//  you can extract hi-lo for 64-bit multiplications.//      - aarch64 (Requires `UMULH` and `MUL` to capture high and low bits).//      - powerpc64 (Requires `MULHDU` and `MULLD` to capture high and low bits).//      - riscv64 (Requires `MUL` and `MULH` to capture high and low bits).//  # Unsupported//  Platforms where native 128-bit multiplication is not supported,//  requiring software emulation.//      sparc64 (`UMUL` only supports double-word arguments).//      sparcv9 (Same as sparc64).//  These tests are run via `xcross`, my own library for C cross-compiling,//  which supports numerous targets (far in excess of Rust's tier 1 support,//  or rust-embedded/cross's list). xcross may be found here://      https://github.com/Alexhuszagh/xcross//  To compile for the given target, run://      `xcross gcc main.c -c -S -O3 --target $target`//  All 32-bit architectures inherently do not have support. That means//  we can essentially look for 64-bit architectures that are not SPARC.mant/// Mantissa for the extended-precision float./// Binary exponent for the extended-precision float./// Extended precision floating-point type./// Private implementation, exposed only for testing purposes.extended_to_float/// Converts an `ExtendedFloat` to the closest machine float type.// FLOAT TYPEfpu_precisionset_precisionFPUControlWord/// A structure used to preserve the original value of the FPU control word, so that it can be/// restored when the structure is dropped./// The x87 FPU is a 16-bits register whose fields are as follows:/// | 12-15 | 10-11 | 8-9 | 6-7 |  5 |  4 |  3 |  2 |  1 |  0 |/// |------:|------:|----:|----:|---:|---:|---:|---:|---:|---:|/// |       | RC    | PC  |     | PM | UM | OM | ZM | DM | IM |/// The documentation for all of the fields is available in the IA-32 Architectures Software/// Developer's Manual (Volume 1)./// The only field which is relevant for the following code is PC, Precision Control. This/// field determines the precision of the operations performed by the  FPU. It can be set to:///  - 0b00, single precision i.e., 32-bits///  - 0b10, double precision i.e., 64-bits///  - 0b11, double extended precision i.e., 80-bits (default state)/// The 0b01 value is reserved and should not be used.set_cw/// Sets the precision field of the FPU to `T` and returns a `FPUControlWord`.// On x86, the x87 FPU is used for float operations if the SSE/SSE2 extensions are not available.// The x87 FPU operates with 80 bits of precision by default, which means that operations will// round to 80 bits causing double rounding to happen when values are eventually represented as// 32/64 bit float values. To overcome this, the FPU control word can be set so that the// computations are performed in the desired precision.// In most architectures, floating point operations have an explicit bit size, therefore the// precision of the computation is determined on a per-operation basis.//! Platform-specific, assembly instructions to avoid//! intermediate rounding on architectures with FPUs.//! This is adapted from the implementation in the Rust core library,//! the original implementation can be [here](https://github.com/rust-lang/rust/blob/master/library/core/src/num/dec2flt/fpu.rs).//! It is therefore also subject to a Apache2.0/MIT license./// The heap-allocated buffer for the elements.HeapVec/// Simple heap vector implementation./// Construct an empty vector./// Construct a vector from an existing slice./// Sets the length of a vector./// This will explicitly set the size of the vector, without actually/// modifying its buffers, so it is up to the caller to ensure that the/// vector is actually the specified size./// Safe as long as `len` is less than `self.capacity()` and has been initialized./// The number of elements stored in the vector./// If the vector is empty./// The number of items the vector can hold./// Append an item to the vector./// Remove an item from the end of the vector and return it, or None if empty.try_extend/// Copy elements from a slice and append them to the vector.try_resize/// Try to resize the buffer./// If the new length is smaller than the current length, truncate/// the input. If it's larger, then append elements to the buffer.add_small/// AddAssign small integer.mul_small/// MulAssign small integer.//! Simple heap-allocated vector.LARGEST_POWER_OF_FIVEPOWER_OF_FIVE_128SMALLEST_POWER_OF_FIVElemire/// Ensure truncation of digits doesn't affect our computation, by doing 2 passes.compute_float/// Compute a float using an extended-precision representation./// Fast conversion of a the significant digits and decimal exponent/// a float to a extended representation with a binary float. This/// algorithm will accurately parse the vast majority of cases,/// and uses a 128-bit representation (with a fallback 192-bit/// representation)./// This algorithm scales the exponent by the decimal exponent/// using pre-computed powers-of-5, and calculates if the/// representation can be unambiguously rounded to the nearest/// machine float. Near-halfway cases are not handled here,/// and are represented by a negative, biased binary exponent./// The algorithm is described in detail in "Daniel Lemire, Number Parsing/// at a Gigabyte per Second" in section 5, "Fast Algorithm", and/// section 6, "Exact Numbers And Ties", available online:/// <https://arxiv.org/abs/2101.11408.pdf>.compute_error/// Fallback algorithm to calculate the non-rounded representation./// This calculates the extended representation, and then normalizes/// the resulting representation, so the high bit is set.compute_error_scaled/// Compute the error from a mantissa scaled to the exponent./// Calculate a base 2 exponent from a decimal exponent./// This uses a pre-computed integer approximation for/// log2(10), where 217706 / 2^16 is accurate for the/// entire range of non-finite decimal exponents.full_multiplicationcompute_product_approx// This will compute or rather approximate w * 5**q and return a pair of 64-bit words// approximating the result, with the "high" part corresponding to the most significant// bits and the low part corresponding to the least significant bits.//! Implementation of the Eisel-Lemire algorithm.//! This is adapted from [fast-float-rust](https://github.com/aldanor/fast-float-rust),//! a port of [fast_float](https://github.com/fastfloat/fast_float) to Rust.fpuheapvectable_bellerophontable_lemiretable_small// APIparse_float//! Fast, minimal float-parsing algorithm.//! minimal-lexical has a simple, high-level API with a single//! exported function: [`parse_float`].//! [`parse_float`] expects a forward iterator for the integer//! and fraction digits, as well as a parsed exponent as an [`i32`].//! For more examples, please see [simple-example](https://github.com/Alexhuszagh/minimal-lexical/blob/master/examples/simple.rs).//! EXAMPLES//! --------//! extern crate minimal_lexical;//! // Let's say we want to parse "1.2345".//! // First, we need an external parser to extract the integer digits ("1"),//! // the fraction digits ("2345"), and then parse the exponent to a 32-bit//! // integer (0).//! // Warning://! // --------//! //  Please note that leading zeros must be trimmed from the integer,//! //  and trailing zeros must be trimmed from the fraction. This cannot//! //  be handled by minimal-lexical, since we accept iterators.//! let integer = b"1";//! let fraction = b"2345";//! let float: f64 = minimal_lexical::parse_float(integer.iter(), fraction.iter(), 0);//! println!("float={:?}", float);    // 1.235//! [`parse_float`]: fn.parse_float.html//! [`i32`]: https://doc.rust-lang.org/stable/std/primitive.i32.html// FEATURES// We want to have the same safety guarantees as Rust core,// so we allow unused unsafe to clearly document safety guarantees./// Safe if `index < array.len()`.powdfabsdscalbndsqrtd//! A small number of math routines for floats and doubles.//! These are adapted from libm, a port of musl libc's libm to Rust.//! libm can be found online [here](https://github.com/rust-lang/libm),//! and is similarly licensed under an Apache2.0/MIT license/// Generate a bitwise mask for the lower `n` bits./// # use minimal_lexical::mask::lower_n_mask;/// # pub fn main() {/// assert_eq!(lower_n_mask(2), 0b11);/// Calculate the halfway point for the lower `n` bits./// # use minimal_lexical::mask::lower_n_halfway;/// assert_eq!(lower_n_halfway(2), 0b10);nth_bit/// Calculate a scalar factor of 2 above the halfway point./// # use minimal_lexical::mask::nth_bit;/// assert_eq!(nth_bit(2), 0b100);//! Utilities to generate bitmasks.SMALL_F32_POW10SMALL_F64_POW10SMALL_INT_POW10SMALL_INT_POW5MAX_DIGITS/// Maximum number of digits that can contribute in the mantissa./// We can exactly represent a float in radix `b` from radix 2 if/// `b` is divisible by 2. This function calculates the exact number of/// digits required to exactly represent that float./// According to the "Handbook of Floating Point Arithmetic",/// for IEEE754, with emin being the min exponent, p2 being the/// precision, and b being the radix, the number of digits follows as:/// `−emin + p2 + ⌊(emin + 1) log(2, b) − log(1 − 2^(−p2), b)⌋`/// For f32, this follows as:///     emin = -126///     p2 = 24/// For f64, this follows as:///     emin = -1022///     p2 = 53/// In Python:///     `-emin + p2 + math.floor((emin+1)*math.log(2, b) - math.log(1-2**(-p2), b))`/// This was used to calculate the maximum number of digits for [2, 36].SIGN_MASK/// Bitmask for the sign bit.EXPONENT_MASK/// Bitmask for the exponent, including the hidden bit.HIDDEN_BIT_MASK/// Bitmask for the hidden bit in exponent, which is an implicit 1 in the fraction.MANTISSA_MASK/// Bitmask for the mantissa (fraction), excluding the hidden bit.MANTISSA_SIZE/// Size of the significand (mantissa) without hidden bit.EXPONENT_BIAS/// Bias of the exponetDENORMAL_EXPONENT/// Exponent portion of a denormal float.MAX_EXPONENT/// Maximum exponent value in float.CARRY_MASK/// Mask to determine if a full-carry occurred (1 in bit above hidden bit).INVALID_FP/// Bias for marking an invalid extended float.// Value is `i16::MIN`, using hard-coded constants for older Rustc versions.MAX_MANTISSA_FAST_PATH// Maximum mantissa for the fast-path (`1 << 53` for f64).INFINITE_POWER// Largest exponent value `(1 << EXP_BITS) - 1`.MIN_EXPONENT_ROUND_TO_EVEN// Round-to-even only happens for negative values of q// when q ≥ −4 in the 64-bit case and when q ≥ −17 in// the 32-bitcase.// When q ≥ 0,we have that 5^q ≤ 2m+1. In the 64-bit case,we// have 5^q ≤ 2m+1 ≤ 2^54 or q ≤ 23. In the 32-bit case,we have// 5^q ≤ 2m+1 ≤ 2^25 or q ≤ 10.// When q < 0, we have w ≥ (2m+1)×5^−q. We must have that w < 2^64// so (2m+1)×5^−q < 2^64. We have that 2m+1 > 2^53 (64-bit case)// or 2m+1 > 2^24 (32-bit case). Hence,we must have 2^53×5^−q < 2^64// (64-bit) and 2^24×5^−q < 2^64 (32-bit). Hence we have 5^−q < 2^11// or q ≥ −4 (64-bit case) and 5^−q < 2^40 or q ≥ −17 (32-bitcase).// Thus we have that we only need to round ties to even when// we have that q ∈ [−4,23](in the 64-bit case) or q∈[−17,10]// (in the 32-bit case). In both cases,the power of five(5^|q|)// fits in a 64-bit word.MAX_EXPONENT_ROUND_TO_EVENMINIMUM_EXPONENT/// Minimum normal exponent value `-(1 << (EXPONENT_SIZE - 1)) + 1`.SMALLEST_POWER_OF_TEN/// Smallest decimal exponent for a non-zero value.LARGEST_POWER_OF_TEN/// Largest decimal exponent for a non-infinite value.MIN_EXPONENT_FAST_PATH/// Minimum exponent that for a fast path case, or `-⌊(MANTISSA_SIZE+1)/log2(10)⌋`MAX_EXPONENT_FAST_PATH/// Maximum exponent that for a fast path case, or `⌊(MANTISSA_SIZE+1)/log2(5)⌋`MAX_EXPONENT_DISGUISED_FAST_PATH/// Maximum exponent that can be represented for a disguised-fast path case./// This is `MAX_EXPONENT_FAST_PATH + ⌊(MANTISSA_SIZE+1)/log2(10)⌋`/// Convert 64-bit integer to float.// Re-exported methods from std.pow_fast_path/// Get a small power-of-radix for fast-path multiplication./// Safe as long as the exponent is smaller than the table size.int_pow_fast_path/// Get a small, integral power-of-radix for fast-path multiplication.is_denormal/// Returns true if the float is a denormal./// Get exponent component from the float./// Get mantissa (significand) component from float.// MASKS// PROPERTIES// ROUNDING/// Generic floating-point type, to be used in generic code for parsing./// Although the trait is part of the public API, the trait provides methods/// and constants that are effectively non-public: they may be removed/// at any time without any breaking changes.//! Utilities for Rust numbers./// The exponent of the float, scaled to the mantissa./// The significant digits of the float.many_digits/// If the significant digits were truncated./// Representation of a number as the significant digits and exponent./// This is only used if the exponent base and the significant digit/// radix are the same, since we need to be able to move powers in and/// out of the exponent.is_fast_path/// Detect if the float can be accurately reconstructed from native floats.try_fast_path/// The fast path algorithmn using machine-sized integers and floats./// This is extracted into a separate function so that it can be attempted before constructing/// a Decimal. This only works if both the mantissa and the exponent/// can be exactly represented as a machine float, since IEE-754 guarantees/// no rounding will occur./// There is an exception: disguised fast-path cases, where we can shift/// powers-of-10 from the exponent to the significant digits.//! Representation of a float as the significant digits and exponent.Iter1Iter2parse_number_fast/// Try to parse the significant digits quickly./// This attempts a very quick parse, to deal with common cases./// * `integer`     - Slice containing the integer digits./// * `fraction`    - Slice containing the fraction digits.parse_number/// Parse the significant digits of the float and adjust the exponent./// Parse float from extracted float components./// * `integer`     - Cloneable, forward iterator over integer digits./// * `fraction`    - Cloneable, forward iterator over integer digits./// * `exponent`    - Parsed, 32-bit exponent./// 1. The integer should not have leading zeros./// 2. The fraction should not have trailing zeros./// 3. All bytes in `integer` and `fraction` should be valid digits,///     in the range [`b'0', b'9']./// Although passing garbage input will not cause memory safety issues,/// it is very likely to cause a panic with a large number of digits, or/// in debug mode. The big-integer arithmetic without the `alloc` feature/// assumes a maximum, fixed-width input, which assumes at maximum a/// value of `10^(769 + 342)`, or ~4000 bits of storage. Passing in/// nonsensical digits may require up to ~6000 bits of storage, which will/// panic when attempting to add it to the big integer. It is therefore/// up to the caller to validate this input./// We cannot efficiently remove trailing zeros while only accepting a/// forward iterator.moderate_path/// Wrapper for different moderate-path algorithms./// A return exponent of `-1` indicates an invalid value.into_i32/// Convert usize into i32 without overflow./// This is needed to ensure when adjusting the exponent relative to/// the mantissa we do not overflow for comically-long exponents.add_digit// Add digit to mantissa.//! Parse byte iterators to float./// Round an extended-precision float to the nearest machine float./// Shifts the significant digits into place, adjusts the exponent,/// so it can be easily converted to a native float.// is_odd, is_halfway, is_above/// Shift right N-bytes and round towards a direction./// Callback should take the following parameters:///     1. is_odd///     1. is_halfway///     1. is_aboveround_down/// Round our significant digits into place, truncating them.//! Defines rounding schemes for floating-point numbers.// --------/// Parse the significant digits and biased, binary exponent of a float./// This is a fallback algorithm that uses a big-integer representation/// of the float, and therefore is considerably slower than faster/// approximations. However, it will always determine how to round/// the significant digits to the nearest machine float, allowing/// use to handle near half-way cases./// Near half-way cases are halfway between two consecutive machine floats./// For example, the float `16777217.0` has a bitwise representation of/// `100000000000000000000000 1`. Rounding to a single-precision float,/// the trailing `1` is truncated. Using round-nearest, tie-even, any/// value above `16777217.0` must be rounded up to `16777218.0`, while/// any value before or equal to `16777217.0` must be rounded down/// to `16777216.0`. These near-halfway conversions therefore may require/// a large number of digits to unambiguously determine how to round.positive_digit_comp/// Generate the significant digits with a positive exponent relative to mantissa.negative_digit_comp/// Generate the significant digits with a negative exponent relative to mantissa./// This algorithm is quite simple: we have the significant digits `m1 * b^N1`,/// where `m1` is the bigint mantissa, `b` is the radix, and `N1` is the radix/// exponent. We then calculate the theoretical representation of `b+h`, which/// is `m2 * 2^N2`, where `m2` is the bigint mantissa and `N2` is the binary/// exponent. If we had infinite, efficient floating precision, this would be/// equal to `m1 / b^-N1` and then compare it to `m2 * 2^N2`./// Since we cannot divide and keep precision, we must multiply the other:/// if we want to do `m1 / b^-N1 >= m2 * 2^N2`, we can do/// `m1 >= m2 * b^-N1 * 2^N2` Going to the decimal case, we can show and example/// and simplify this further: `m1 >= m2 * 2^N2 * 10^-N1`. Since we can remove/// a power-of-two, this is `m1 >= m2 * 2^(N2 - N1) * 5^-N1`. Therefore, if/// `N2 - N1 > 0`, we need have `m1 >= m2 * 2^(N2 - N1) * 5^-N1`, otherwise,/// we have `m1 * 2^(N1 - N2) >= m2 * 5^-N1`, where the resulting exponents/// are all positive./// This allows us to compare both floats using integers efficiently/// without any loss of precision./// Add a digit to the temporary value.add_temporary// Multiply by the small power and add the native value.// Safe is `counter <= step`, or smaller than the table size.// Add a temporary where we won't read the counter results internally.// Add the maximum native value./// Add a temporary value to our mantissa.round_up_truncated/// Round-up a truncated value.round_up_nonzero/// Check and round-up the fraction if any non-zero digits exist.parse_mantissa/// Parse the full mantissa into a big integer./// Returns the parsed mantissa and the number of digits in the mantissa./// The max digits is the maximum number of digits plus one.scientific_exponent/// Calculate the scientific exponent from a `Number` value./// Any other attempts would require slowdowns for faster algorithms./// Calculate `b` from a a representation of `b` as a float.bh/// Calculate `b+h` from a a representation of `b` as a float.//! Slow, fallback cases where we cannot unambiguously round a float.//! This occurs when we cannot determine the exact representation using//! both the fast path (native) cases nor the Lemire/Bellerophon algorithms,//! and therefore must fallback to a slow, arbitrary-precision representation.// SCALING/// The raw buffer for the elements./// The number of elements in the array (we never need more than u16::MAX)./// Simple stack vector implementation./// Safe as long as `len` is less than `BIGINT_LIMBS`./// Append an item to the vector, without bounds checking./// Safe if `self.len() < self.capacity()`.pop_unchecked/// Remove an item from the end of a vector, without bounds checking./// Safe if `self.len() > 0`./// Add items from a slice to the vector, without bounds checking./// Safe if `self.len() + slc.len() <= self.capacity()`.truncate_unchecked/// Truncate vector to new length, dropping any items after `len`./// Safe as long as `len <= self.capacity()`.resize_unchecked/// Resize the buffer, without bounds checking.//! Simple stack-allocated vector.//! Pre-computed tables for parsing float strings.BASE10_SMALL_MANTISSABASE10_LARGE_MANTISSABASE10_SMALL_INT_POWERSBASE10_STEPBASE10_BIASBASE10_LOG2_MULTBASE10_LOG2_SHIFT//! Cached exponents for basen values with 80-bit extended floats.//! Exact versions of base**n as an extended-precision float, with both//! large and small powers. Use the large powers to minimize the amount//! of compounded error. This is used in the Bellerophon algorithm.//! These values were calculated using Python, using the arbitrary-precision//! integer to calculate exact extended-representation of each value.//! These values are all normalized.//! DO NOT MODIFY: Generated by `etc/bellerophon_table.py`// HIGH LEVEL// ----------// LOW-LEVELN_POWERS_OF_FIVE// Use static to avoid long compile times: Rust compiler errors// can have the entire table compiled multiple times, and then// emit code multiple times, even if it's stripped out in// the final binary.//! Pre-computed tables powers-of-5 for extended-precision representations.//! These tables enable fast scaling of the significant digits//! of a float to the decimal exponent, with minimal rounding//! errors, in a 128 or 192-bit representation.//! DO NOT MODIFY: Generated by `etc/lemire_table.py`//! This adapted from the Rust implementation, based on the fast-float-rust//! implementation, and is similarly subject to an Apache2.0/MIT license./// Pre-computed, small powers-of-5./// Pre-computed, small powers-of-10./// Pre-computed large power-of-5 for 64-bit limbs./// Step for large power-of-5 for 32-bit limbs.//! Pre-computed small tables for parsing decimal strings.LZ_DICT_SIZEMAX_MATCH_LENLZ_CODE_BUF_SIZE/// Size of the buffer of lz77 encoded data.OUT_BUF_SIZE/// Size of the output buffer.LZ_DICT_FULL_SIZELZ_HASH_BITS/// Size of hash values in the hash chains.LZ_HASH_SHIFT/// How many bits to shift when updating the current hash value.LZ_HASH_SIZE/// Size of the chained hash tables.dictHashBuffersLocalBuf//! Buffer wrappers implementing default so we can allocate the buffers with `Box::default()`//! to avoid stack copies. Box::new() doesn't at the moment, and using a vec means we would lose//! static length info.deflate_flagsCompressionLevelupdate_adler32HUFFMAN_LENGTH_ORDERMZ_ADLER32_INIT// Currently not bubbled up outside this module, so can fill in with more// context eventually if needed.MAX_PROBES_MASKMAX_SUPPORTED_HUFF_CODESIZELEN_SYM/// Length code for length values.LEN_EXTRA/// Number of extra bits for length values.SMALL_DIST_SYM/// Distance codes for distances smaller than 512.SMALL_DIST_EXTRA/// Number of extra bits for distances smaller than 512.LARGE_DIST_SYM/// Base values to calculate distances above 512.LARGE_DIST_EXTRA/// Number of extra bits distances above 512.NUM_PROBES/// The maximum number of checks for matches in the hash table the compressor will make for each/// compression level.sym_indexSymFreqTDEFL_WRITE_ZLIB_HEADER/// Whether to use a zlib wrapper.TDEFL_COMPUTE_ADLER32/// Should we compute the adler32 checksum.TDEFL_GREEDY_PARSING_FLAG/// Should we use greedy parsing (as opposed to lazy parsing where look ahead one or more/// bytes to check for better matches.)TDEFL_NONDETERMINISTIC_PARSING_FLAG/// Used in miniz to skip zero-initializing hash and dict. We don't do this here, so/// this flag is ignored.TDEFL_RLE_MATCHES/// Only look for matches with a distance of 0.TDEFL_FILTER_MATCHES/// Only use matches that are at least 6 bytes long.TDEFL_FORCE_ALL_STATIC_BLOCKS/// Force the compressor to only output static blocks. (Blocks using the default huffman codes/// specified in the deflate specification.)TDEFL_FORCE_ALL_RAW_BLOCKS/// Force the compressor to only output raw/uncompressed blocks.CompressionStrategy/// Don't use any of the special strategies.Filtered/// Only use matches that are at least 5 bytes long.HuffmanOnly/// Don't look for matches, only huffman encode the literals./// Only look for matches with a distance of 1, i.e do run-length encoding only./// Only use static/fixed blocks. (Blocks using the default huffman codes/// Strategy setting for compression./// The non-default settings offer some special-case compression variants.TDEFLFlush/// Normal operation./// Compress as much as there is space for, and then return waiting for more input./// Try to flush all the current data and output an empty raw block./// Same as [`Sync`][Self::Sync], but reset the dictionary so that the following data does not/// depend on previous data./// Try to flush everything and end the deflate stream./// On success this will yield a [`TDEFLStatus::Done`] return status./// A list of deflate flush types.MZFlushMZErrorTDEFLStatusBadParam/// Usage error./// This indicates that either the [`CompressorOxide`] experienced a previous error, or the/// stream has already been [`TDEFLFlush::Finish`]'d.PutBufFailed/// Error putting data into output buffer./// This usually indicates a too-small buffer.Okay/// Compression succeeded normally./// Compression succeeded and the deflate stream was ended./// This is the result of calling compression with [`TDEFLFlush::Finish`]./// Return status of compression.MAX_HUFF_SYMBOLSLEVEL1_HASH_SIZE_MASK/// Size of hash chain for fast compression mode.MAX_HUFF_TABLES/// The number of huffman tables used by the compressor./// Literal/length, Distances and Length of the huffman codes for the other two tables.MAX_HUFF_SYMBOLS_0/// Literal/length codesMAX_HUFF_SYMBOLS_1/// Distance codes.MAX_HUFF_SYMBOLS_2/// Huffman length values./// Size of the chained hash table.LZ_DICT_SIZE_MASK/// Mask used when stepping through the hash chains.MIN_MATCH_LEN/// The minimum length of a match./// The maximum length of a match.DEFAULT_CMDEFAULT_CINFO_DEFAULT_FDICTDEFAULT_CMFFCHECK_DIVISOR/// The 16-bit value consisting of CMF and FLG must be divisible by this to be valid.add_fcheck/// Generate FCHECK from CMF and FLG (without FCKECH )so that they are correct according to the/// specification, i.e (CMF*256 + FCHK) % 31 = 0./// Returns flg with the FCHKECK bits added (any existing FCHECK bits are ignored).zlib_level_from_flagsheader_from_level/// Get the zlib header for the level using the default window size and no/// dictionary.header_from_flags/// Create a zlib header from the given compression flags./// Only level is considered.test_headerwrite_u16_leread_u16_le// Read the two bytes starting at pos and interpret them as an u16.lzLZOxideParamsOxidehuffHuffmanOxide/// Put HuffmanOxide on the heap with default trick to avoid/// excessive stack copies.DictOxide/// Main compression struct./// Create a new `CompressorOxide` with the given flags./// This function may be changed to take different parameters in the future./// Get the adler32 checksum of the currently encoded data.prev_return_status/// Get the return status of the previous [`compress`](fn.compress.html)/// call with this compressor./// Get the raw compressor flags./// This function may be deprecated or changed in the future to use more rust-style flags./// Returns whether the compressor is wrapping the data in a zlib format or not./// Reset the state of the compressor, keeping the same parameters./// This avoids re-allocating data.set_compression_level/// Set the compression level of the compressor./// Using this to change level after compression has started is supported./// The compression strategy will be reset to the default one when this is called.set_compression_level_raw/// Set the compression level of the compressor using an integer value.set_format_and_level/// Update the compression settings of the compressor./// Changing the `DataFormat` after compression has started will result in/// a corrupted stream./// This function mainly intended for setting the initial settings after e.g creating with/// `default` or after calling `CompressorOxide::reset()`, and behaviour may be changed/// to disallow calling it after starting compression in the future./// Initialize the compressor with a level of 4, zlib wrapper and/// the default strategy.put_buf_funcCallbackFunc/// Callback function and user used in `compress_to_output`.flush_outputSavedOutputBufferOxideout_bufCallbackBufCallbackOutnew_output_bufferOutputBufferOxidein_bufin_buf_sizeout_buf_sizeCallbackOxidenew_callback_bufnew_callback_funcupdate_sizeinner_posbit_bufferbits_input_bitspad_to_bytesBitBufferput_fast/// Number of occurrences of each symbol./// The bits of the huffman code assigned to the symbolcode_sizes/// The length of the huffman code assigned to the symbol./// A struct containing data about huffman codes and symbol frequencies./// NOTE: Only the literal/lengths have enough symbols to actually use/// the full array. It's unclear why it's defined like this in miniz,/// it could be for cache/alignment reasons.LITLEN_TABLE/// Tables used for literal/lengths in `HuffmanOxide`.DIST_TABLE/// Tables for distances.HUFF_CODES_TABLE/// Tables for the run-length encoded huffman lengths for literals/lengths/distances.z_countrepeat_countprev_code_size/// Status of RLE encoding of huffman code lengths.zero_code_sizeradix_sort_symbolscalculate_minimum_redundancyenforce_max_code_sizeoptimize_tablestart_static_blockstart_dynamic_blockmax_probes/// The maximum number of checks in the hash chain, for the initial,/// and the lazy match respectively./// Buffer of input data./// Padded with 1 byte to simplify matching code in `compress_fast`.code_buf_dict_poslookahead_sizelookahead_posprobes_from_flagsupdate_flagsread_unaligned_u32/// Do an unaligned read of the data at `pos` in the dictionary and treat it as if it was of/// type T.read_unaligned_u64read_as_u16find_match/// Try to find a match for the data at lookahead_pos in the dictionary that is/// longer than `match_len`./// Returns a tuple containing (match_distance, match_length). Will be equal to the input/// values if no better matches were found.greedy_parsingblock_indexsaved_match_distsaved_match_lensaved_litflush_ofsflush_remainingsrc_posout_buf_ofssaved_bit_buffersaved_bits_inlocal_buf/// Reset state, saving settings.code_positionflag_position// The total number of bytes in the current block.num_flags_leftinit_flagplant_flagconsume_flagcompress_lz_codesflush_blockrecord_literalrecord_matchcompress_normalCOMP_FAST_LOOKAHEAD_SIZEcompress_fastflush_output_buffer/// Main compression function. Tries to compress as much as possible from `in_buf` and/// puts compressed output into `out_buf`./// The value of `flush` determines if the compressor should attempt to flush all output/// and alternatively try to finish the stream./// Use [`TDEFLFlush::Finish`] on the final call to signal that the stream is finishing./// Note that this function does not keep track of whether a flush marker has been output, so/// if called using [`TDEFLFlush::Sync`], the caller needs to ensure there is enough space in the/// output buffer if they want to avoid repeated flush markers./// See #105 for details./// Returns a tuple containing the current status of the compressor, the current position/// in the input buffer and the current position in the output buffer.compress_to_output/// Main compression function. Callbacks output./// in the input buffer./// The caller is responsible for ensuring the `CallbackFunc` struct will not cause undefinedcompress_innercreate_comp_flags_from_zip_params/// Create a set of compression flags using parameters used by zlib and other compressors./// Mainly intended for use with transition from c libraries as it deals with raw integers./// `level` determines compression level. Clamped to maximum of 10. Negative values result in/// `CompressionLevel::DefaultLevel`./// `window_bits`: Above 0, wraps the stream in a zlib wrapper, 0 or negative for a raw deflate/// `strategy`: Sets the strategy if this conforms to any of the values in `CompressionStrategy`./// This function may be removed or moved to the `miniz_oxide_c_api` in the future.u16_to_sliceu16_from_slicecompress_output/// Check fast compress mode//! Streaming compression functionality.NoCompression/// Don't do any compression, only output uncompressed blocks.BestSpeed/// Fast compression. Uses a special compression routine that is optimized for speed.BestCompression/// Slow/high compression. Do a lot of checks to try to find good matches.UberCompression/// Even more checks, can be very slow.DefaultLevel/// Default compromise between speed and compression.DefaultCompression/// Use the default compression level./// How much processing the compressor should do to compress the data./// `NoCompression` and `Bestspeed` have special meanings, the other levels determine the number/// of checks for matches in the hash chains and whether to use lazy or greedy parsing./// Compress the input data to a vector, using the specified compression level (0-10).compress_to_vec_zlib/// Compress the input data to a vector, using the specified compression level (0-10), and with a/// zlib wrapper.compress_to_vec_inner/// Simple function to compress data to a vec.compress_small/// Test deflate example./// Check if the encoder produces the same code as the example given by Mark Adler here:/// https://stackoverflow.com/questions/17398931/deflate-encoding-with-static-huffman-codes/17415203compress_huff_onlycompress_raw/// Test that a raw block compresses fine.//! This module contains functionality for compression.// Missing safe rust analogue (this and mem-to-mem are quite similar)/*
fn tdefl_compress(
    d: Option<&mut CompressorOxide>,
    in_buf: *const c_void,
    in_size: Option<&mut usize>,
    out_buf: *mut c_void,
    out_size: Option<&mut usize>,
    flush: TDEFLFlush,
) -> TDEFLStatus {
    let res = match d {
        None => {
            in_size.map(|size| *size = 0);
            out_size.map(|size| *size = 0);
            (TDEFLStatus::BadParam, 0, 0)
        },
        Some(compressor) => {
            let callback_res = CallbackOxide::new(
                compressor.callback_func.clone(),
                in_buf,
                in_size,
                out_buf,
                out_size,
            );

            if let Ok(mut callback) = callback_res {
                let res = compress(compressor, &mut callback, flush);
                callback.update_size(Some(res.1), Some(res.2));
                res
            } else {
                (TDEFLStatus::BadParam, 0, 0)
            }
        }
    };
    res.0
}*/// Missing safe rust analogue/*
fn tdefl_init(
    d: Option<&mut CompressorOxide>,
    put_buf_func: PutBufFuncPtr,
    put_buf_user: *mut c_void,
    flags: c_int,
) -> TDEFLStatus {
    if let Some(d) = d {
        *d = CompressorOxide::new(
            put_buf_func.map(|func|
                CallbackFunc { put_buf_func: func, put_buf_user: put_buf_user }
            ),
            flags as u32,
        );
        TDEFLStatus::Okay
    } else {
        TDEFLStatus::BadParam
    }
}*/// Missing safe rust analogue (though maybe best served by flate2 front-end instead)/*
fn tdefl_compress_mem_to_output(
    buf: *const c_void,
    buf_len: usize,
    put_buf_func: PutBufFuncPtr,
    put_buf_user: *mut c_void,
    flags: c_int,
) -> bool*/// Missing safe Rust analogue/*
fn tdefl_compress_mem_to_mem(
    out_buf: *mut c_void,
    out_buf_len: usize,
    src_buf: *const c_void,
    src_buf_len: usize,
    flags: c_int,
) -> usize*/MZStatusStreamResult/// Try to compress from input to output with the given [`CompressorOxide`]./// Returns [`MZError::Buf`] If the size of the `output` slice is empty or no progress was made due/// to lack of expected input data, or if called without [`MZFlush::Finish`] after the compression/// was already finished./// Returns [`MZError::Param`] if the compressor parameters are set wrong./// Returns [`MZError::Stream`] when lower-level decompressor returns a/// [`TDEFLStatus::PutBufFailed`]; may not actually be possible.decompress_to_vec_zlibtest_state//! Extra streaming compression functionality.//! As of now this is mainly intended for use to build a higher-level wrapper.//! There is no DeflateState as the needed state is contained in the compressor struct itself.TINFL_LZ_DICT_SIZEcode_size/// Length of the code at each index.look_upFAST_LOOKUP_SIZE/// Fast lookup table for shorter huffman codes./// See `HuffmanTable::fast_lookup`.MAX_HUFF_TREE_SIZE/// Full huffman tree./// Positive values are edge nodes/symbols, negative values are/// parent nodes/references to other nodes./// A struct containing huffman code lengths and the huffman code tree used by the decompressor.fast_lookup/// Look for a symbol in the fast lookup table./// The symbol is stored in the lower 9 bits, the length in the next 6./// If the returned value is negative, the code wasn't found in the/// fast lookup table and the full tree has to be traversed to find the code.tree_lookup/// Get the symbol and the code length from the huffman tree./// Look up a symbol and code length from the bits in the provided bit buffer./// Returns Some(symbol, length) on success,/// None if the length is 0./// It's possible we could avoid checking for 0 if we can guarantee a sane table./// TODO: Check if a smaller type for code_len helps performance./// The number of huffman tables used./// The length of the first (literal/length) huffman table./// The length of the second (distance) huffman table._MAX_HUFF_SYMBOLS_2/// The length of the last (huffman code length) huffman table.FAST_LOOKUP_BITS/// The maximum length of a code that can be looked up in the fast lookup table./// The size of the fast lookup table.HUFFLEN_TABLETINFL_FLAG_PARSE_ZLIB_HEADER/// Should we try to parse a zlib header?/// If unset, the function will expect an RFC1951 deflate stream.  If set, it will expect a/// RFC1950 zlib wrapper around the deflate stream.TINFL_FLAG_HAS_MORE_INPUT/// There will be more input that hasn't been given to the decompressor yet./// This is useful when you want to decompress what you have so far,/// even if you know there is probably more input that hasn't gotten here yet (_e.g._, over a/// network connection).  When [`decompress()`][super::decompress] reaches the end of the input/// without finding the end of the compressed stream, it will return/// [`TINFLStatus::NeedsMoreInput`][super::TINFLStatus::NeedsMoreInput] if this is set,/// indicating that you should get more data before calling again.  If not set, it will return/// [`TINFLStatus::FailedCannotMakeProgress`][super::TINFLStatus::FailedCannotMakeProgress]/// suggesting the stream is corrupt, since you claimed it was all there.TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF/// The output buffer should not wrap around.TINFL_FLAG_COMPUTE_ADLER32/// Calculate the adler32 checksum of the output data even if we're not inflating a zlib stream./// If [`TINFL_FLAG_IGNORE_ADLER32`] is specified, it will override this./// NOTE: Enabling/disabling this between calls to decompress will result in an incorrect/// checksum.TINFL_FLAG_IGNORE_ADLER32/// Ignore adler32 checksum even if we are inflating a zlib stream./// Overrides [`TINFL_FLAG_COMPUTE_ADLER32`] if both are enabled./// NOTE: This flag does not exist in miniz as it does not support this and is a/// custom addition for miniz_oxide./// NOTE: Should not be changed from enabled to disabled after decompression has started,/// this will result in checksum failure (outside the unlikely event where the checksum happens/// to match anyway).inflate_flags/// Flags to [`decompress()`] to control how inflation works./// These define bits for a bitmask argument.MIN_TABLE_SIZES/// Current state of the decompressor./// Number of bits in the bit buffer.z_header0/// Zlib CMFz_header1/// Zlib FLGz_adler32/// Adler32 checksum from the zlib header./// 1 if the current block is the last block, 0 otherwise./// The type of the current block.check_adler32/// 1 if the adler32 value should be checked./// Last match distance./// Variable used for match length, symbols, and a number of other things.num_extra/// Number of extra bits for the last length or distance code.table_sizes/// Number of entries in each huffman table.bit_buf/// Huffman tables./// Raw block header.len_codes/// Huffman length codes.DecompressorOxide/// Main decompression struct./// Create a new tinfl_decompressor with all fields set to 0./// Set the current state to `Start`./// Returns the adler32 checksum of the currently decompressed data./// Note: Will return Some(1) if decompressing zlib but ignoring adler32.adler32_header/// Returns the adler32 that was read from the zlib header if it exists.ReadZlibCmfReadZlibFlgReadBlockHeaderBlockTypeNoCompressionRawHeaderRawMemcpy1RawMemcpy2ReadTableSizesReadHufflenTableCodeSizeReadLitlenDistTablesCodeSizeReadExtraBitsCodeSizeDecodeLitlenWriteSymbolReadExtraBitsLitlenDecodeDistanceReadExtraBitsDistanceRawReadFirstByteRawStoreFirstByteWriteLenBytesToEndBlockDoneHuffDecodeOuterLoop1HuffDecodeOuterLoop2ReadAdler32DoneForeverBlockTypeUnexpected// Failure states.BadCodeSizeSumBadDistOrLiteralTableLengthBadTotalSymbolsDistanceOutOfBoundsBadRawLengthBadCodeSizeDistPrevLookupInvalidLitlenInvalidDistInvalidCodeLenis_failureLENGTH_BASE// Not sure why miniz uses 32-bit values for these, maybe alignment/cache again?// # Optimization// We add a extra value at the end and make the tables 32 elements long// so we can use a mask to avoid bounds checks.// The invalid values are set to something high enough to avoid underflowing// the match length./// Base length for each length code./// The base is used together with the value of the extra bits to decode the actual/// length/distance values in a match.LENGTH_EXTRA/// Number of extra bits for each length code.DIST_BASE/// Base length for each distance code.DIST_EXTRA/// Number of extra bits for each distance code.BASE_EXTRA_MASK/// The mask used when indexing the base/extra arrays./// Sets the value of all the elements of the slice to `val`./// Read an le u16 value from the slice iterator./// Panics if there are less than two bytes left.read_u32_le/// Read an le u32 value from the slice iterator./// Panics if there are less than four bytes left.fill_bit_bufferLocalVars/// Ensure that there is data in the bit buffer./// On 64-bit platform, we use a 64-bit value so this will/// result in there being at least 32 bits in the bit buffer./// This function assumes that there is at least 4 bytes left in the input buffer.validate_zlib_header/// Check that the zlib header is correct and that there is enough space in the buffer/// for the window size specified in the header./// See https://tools.ietf.org/html/rfc1950TINFLStatusdecode_huffman_code/// Try to decode the next huffman code, and puts it in the counter field of the decompressor/// if successful./// The specified action returned from `f` on success,/// `Action::End` if there are not enough data left to decode a symbol./// Try to read one byte from `in_iter` and call `f` with the read byte as an argument,/// returning the result./// If reading fails, `Action::End is returned`// TODO: `l: &mut LocalVars` may be slow similar to decompress_fast (even with inline(always))/// Try to read `amount` number of bits from `in_iter` and call the function `f` with the bits as an/// an argument after reading, returning the result of that function, or `Action::End` if there are/// not enough bytes left.undo_bytesstart_static_tableinit_treegenerate_state// A helper macro for generating the state machine.// As Rust doesn't have fallthrough on matches, we have to return to the match statement// and jump for each state change. (Which would ideally be optimized away, but often isn't.)apply_match/// Presumes that there is at least match_len bytes in output left.decompress_fast/// Fast inner decompression loop which is run  while there is at least/// 259 bytes left in the output buffer, and at least 6 bytes left in the input buffer/// (The maximum one match would need + 1)./// This was inspired by a similar optimization in zlib, which uses this info to do/// faster unchecked copies of multiple bytes at a time./// Currently we don't do this here, but this function does avoid having to jump through the/// big match loop on each state change(as rust does not have fallthrough or gotos at the moment),/// and already improves decompression speed a fair bit./// Main decompression function. Keeps decompressing data from `in_buf` until the `in_buf` is/// empty, `out` is full, the end of the deflate stream is hit, or there is an error in the/// deflate stream./// `r` is a [`DecompressorOxide`] struct with the state of this stream./// `in_buf` is a reference to the compressed data that is to be decompressed. The decompressor will/// start at the first byte of this buffer./// `out` is a reference to the buffer that will store the decompressed data, and that/// stores previously decompressed data if any./// * The offset given by `out_pos` indicates where in the output buffer slice writing should start./// * If [`TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF`] is not set, the output buffer is used in a/// wrapping manner, and it's size is required to be a power of 2./// * The decompression function normally needs access to 32KiB of the previously decompressed data///(or to the beginning of the decompressed data if less than 32KiB has been decompressed.)///     - If this data is not available, decompression may fail.///     - Some deflate compressors allow specifying a window size which limits match distances to/// less than this, or alternatively an RLE mode where matches will only refer to the previous byte/// and thus allows a smaller output buffer. The window size can be specified in the zlib/// header structure, however, the header data should not be relied on to be correct./// `flags` indicates settings and status to the decompression function./// * The [`TINFL_FLAG_HAS_MORE_INPUT`] has to be specified if more compressed data is to be provided/// in a subsequent call to this function./// * See the the [`inflate_flags`] module for details on other flags./// Returns a tuple containing the status of the compressor, the number of input bytes read, and the/// number of bytes output to `out`./// This function shouldn't panic pending any bugs.tinfl_decompress_oxideraw_blockmasked_lookupfixed_table_lookupcheck_result// Only run this test with alloc enabled as it uses a larger buffer.bogus_inputempty_output_buffer_non_wrappingempty_output_buffer_wrapping//TODO: Fix these.//! Streaming decompression functionality.TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESSTINFL_STATUS_BAD_PARAMTINFL_STATUS_ADLER32_MISMATCHTINFL_STATUS_FAILEDTINFL_STATUS_DONETINFL_STATUS_NEEDS_MORE_INPUTTINFL_STATUS_HAS_MORE_OUTPUTFailedCannotMakeProgress/// More input data was expected, but the caller indicated that there was no more data, so the/// input stream is likely truncated./// This can't happen if you have provided the/// [`TINFL_FLAG_HAS_MORE_INPUT`][core::inflate_flags::TINFL_FLAG_HAS_MORE_INPUT] flag to the/// decompression.  By setting that flag, you indicate more input exists but is not provided,/// and so reaching the end of the input data without finding the end of the compressed stream/// would instead return a [`NeedsMoreInput`][Self::NeedsMoreInput] status./// The output buffer is an invalid size; consider the `flags` parameter.Adler32Mismatch/// The decompression went fine, but the adler32 checksum did not match the one/// provided in the header./// Failed to decompress due to invalid data./// Finished decompression without issues./// This indicates the end of the compressed stream has been reached./// The decompressor needs more input data to continue decompressing./// This occurs when there's no more consumable input, but the end of the stream hasn't been/// reached, and you have supplied the/// decompressor.  Had you not supplied that flag (which would mean you were asserting that you/// believed all the data was available) you would have gotten a/// [`FailedCannotMakeProcess`][Self::FailedCannotMakeProgress] instead.HasMoreOutput/// There is still pending data that didn't fit in the output buffer./// Return status codes./// Decompressor status on failure. See [TINFLStatus] for details./// The currently decompressed data if any./// Struct return when decompress_to_vec functions fail.decompress_error/// Decompress the deflate-encoded data in `input` to a vector./// NOTE: This function will not bound the output, so if the output is large enough it can result in an out of memory error./// It is therefore suggested to not use this for anything other than test programs, use the functions with a specified limit, or/// ideally streaming decompression via the [flate2](https://github.com/alexcrichton/flate2-rs) library instead./// Returns a [`Result`] containing the [`Vec`] of decompressed data on success, and a [struct][DecompressError] containing the status and so far decompressed data if any on failure./// Decompress the deflate-encoded data (with a zlib wrapper) in `input` to a vector.decompress_to_vec_with_limit/// The vector is grown to at most `max_size` bytes; if the data does not fit in that size,/// the error [struct][DecompressError] will contain the status [`TINFLStatus::HasMoreOutput`] and the data that was decompressed on failure./// As this function tries to decompress everything in one go, it's not ideal for general use outside of tests or where the output size is expected to be small./// It is suggested to use streaming decompression via the [flate2](https://github.com/alexcrichton/flate2-rs) library instead./// Returns a [`Result`] containing the [`Vec`] of decompressed data on success, and a [struct][DecompressError] on failure.decompress_to_vec_zlib_with_limitdecompress_to_vec_inner/// Backend of various to-[`Vec`] decompressions./// Returns [`Vec`] of decompressed data on success and the [error struct][DecompressError] with details on failure.decompress_slice_iter_to_slice/// Decompress one or more source slices from an iterator into the output slice./// * On success, returns the number of bytes that were written./// * On failure, returns the failure status code./// This will fail if the output buffer is not large enough, but in that case/// the output buffer will still contain the partial decompression./// * `out` the output buffer./// * `it` the iterator of input slices./// * `zlib_header` if the first slice out of the iterator is expected to have a///   Zlib header. Otherwise the slices are assumed to be the deflate data only./// * `ignore_adler32` if the adler32 checksum should be calculated or not.decompress_vec_with_high_limitfail_to_decompress_with_limittest_decompress_slice_iter_to_slice//! This module contains functionality for decompression./// A wrapper for the output slice used when decompressing./// Using this rather than `Cursor` lets us implement the writing methods directly on/// the buffer and lets us use a usize rather than u64 for the position which helps with/// performance on 32-bit systems.from_slice_and_pos/// Write a byte to the current position and increment/// Assumes that there is space./// Write a slice to the current position and incrementMZResult/// Performs resetResetPolicy/// Tag that determines reset policy of [InflateState](struct.InflateState.html)MinReset/// Resets state, without performing expensive ops (e.g. zeroing buffer)/// Note that not zeroing buffer can lead to security issues when dealing with untrusted input.ZeroReset/// Resets state and zero memory, continuing to use the same data format.FullReset/// Full reset of the state, including zeroing memory./// Requires to provide new data format.decomp/// Inner decompressor struct/// Buffer of input bytes for matches./// TODO: Could probably do this a bit cleaner with some/// Cursor-like class./// We may also look into whether we need to keep a buffer here, or just one in the/// decompressor struct.dict_ofs/// Where in the buffer are we currently at?dict_avail/// How many bytes of data to be flushed is there currently in the buffer?first_callhas_flushed/// Whether the input data is wrapped in a zlib header and checksum./// TODO: This should be stored in the decompressor.last_status/// A struct that compbines a decompressor with extra data for streaming decompression./// Create a new state./// Note that this struct is quite large due to internal buffers, and as such storing it on/// the stack is not recommended./// `data_format`: Determines whether the compressed data is assumed to wrapped with zlibnew_boxed/// Create a new state on the heap./// Access the innner decompressor./// Return the status of the last call to `inflate` with this `InflateState`.new_boxed_with_window_bits/// Create a new state using miniz/zlib style window bits parameter./// The decompressor does not support different window sizes. As such,/// any positive (>0) value will set the zlib header flag, while a negative one/// will not./// Reset the decompressor without re-allocating memory, using the given/// data format.reset_as/// Resets the state according to specified policy./// Try to decompress from `input` to `output` with the given [`InflateState`]/// # `flush`/// Generally, the various [`MZFlush`] flags have meaning only on the compression side.  They can be/// supplied here, but the only one that has any semantic meaning is [`MZFlush::Finish`], which is a/// signal that the stream is expected to finish, and failing to do so is an error.  It isn't/// necessary to specify it when the stream ends; you'll still get returned a/// [`MZStatus::StreamEnd`] anyway.  Other values either have no effect or cause errors.  It's/// likely that you'll almost always just want to use [`MZFlush::None`]./// Returns [`MZError::Buf`] if the size of the `output` slice is empty or no progress was made due/// to lack of expected input data, or if called with [`MZFlush::Finish`] and input wasn't all/// consumed./// Returns [`MZError::Data`] if this or a a previous call failed with an error return from/// [`TINFLStatus`]; probably indicates corrupted data./// Returns [`MZError::Stream`] when called with [`MZFlush::Full`] (meaningless on/// decompression), or when called without [`MZFlush::Finish`] after an earlier call with/// [`MZFlush::Finish`] has been made.inflate_looppush_dict_out//! Extra streaming decompression functionality.mz_adler32_oxide/// Don't force any flushing./// Used when more input data is expected./// Zlib partial flush./// Currently treated as [`Sync`]./// Finish compressing the currently buffered data, and output an empty raw block./// Has no use in decompression./// Same as [`Sync`], but resets the compression dictionary so that further compressed/// data does not depend on data compressed before the flush./// Has no use in decompression, and is an error to supply in that case./// Attempt to flush the remaining data and end the stream./// Not implemented./// A list of flush types./// See <http://www.bolet.org/~pornin/deflate-flush.html> for more in-depth info./// Create an MZFlush value from an integer value./// Returns `MZError::Param` on invalid values./// Operation succeeded./// Some data was decompressed or compressed; see the byte counters in the [`StreamResult`] for/// Operation succeeded and end of deflate stream was found./// X-ref [`TINFLStatus::Done`][inflate::TINFLStatus::Done] or/// [`TDEFLStatus::Done`][deflate::core::TDEFLStatus::Done] for `inflate` or `deflate`NeedDict/// Unused/// A list of miniz successful status codes./// These are emitted as the [`Ok`] side of a [`MZResult`] in the [`StreamResult`] returned from/// [`deflate::stream::deflate()`] or [`inflate::stream::inflate()`].ErrNo/// General stream error./// See [`inflate::stream::inflate()`] docs for details of how it can occur there./// See [`deflate::stream::deflate()`] docs for how it can in principle occur there, though it's/// believed impossible in practice./// Error in inflation; see [`inflate::stream::inflate()`] for details./// Not returned from [`deflate::stream::deflate()`]./// Buffer-related error./// See the docs of [`deflate::stream::deflate()`] or [`inflate::stream::inflate()`] for details/// of when it would trigger in the one you're using.10_000/// Bad parameters./// This can be returned from [`deflate::stream::deflate()`] in the case of bad parameters.  See/// [`TDEFLStatus::BadParam`][deflate::core::TDEFLStatus::BadParam]./// A list of miniz failed status codes./// These are emitted as the [`Err`] side of a [`MZResult`] in the [`StreamResult`] returned from/// Wrapped using the [zlib](http://www.zlib.org/rfc-zlib.html) format.ZLibIgnoreChecksum/// Zlib wrapped but ignore and don't compute the adler32 checksum./// Currently only used for inflate, behaves the same as Zlib for compression./// Raw DEFLATE./// How compressed data is wrapped.from_window_bitsto_window_bits/// `Result` alias for all miniz status codes both successful and failed.bytes_consumed/// The number of bytes consumed from the input slice.bytes_written/// The number of bytes written to the output slice./// The return status of the call./// A structure containing the result of a call to the inflate or deflate streaming functions.//! A pure rust replacement for the [miniz](https://github.com/richgel999/miniz)//! DEFLATE/zlib encoder/decoder.//! Used a rust back-end for the//! [flate2](https://github.com/alexcrichton/flate2-rs) crate./// A readiness event./// `Event` is a readiness state paired with a [`Token`]. It is returned by/// [`Poll::poll`]./// For more documentation on polling and events, see [`Poll`]./// [`Poll::poll`]: ../struct.Poll.html#method.poll/// [`Poll`]: ../struct.Poll.html/// [`Token`]: ../struct.Token.html/// Returns the event's token./// Returns true if the event contains readable readiness./// Out-of-band (OOB) data also triggers readable events. But must/// application don't actually read OOB data, this could leave an/// application open to a Denial-of-Service (Dos) attack, see/// <https://github.com/sandstorm-io/sandstorm-website/blob/58f93346028c0576e8147627667328eaaf4be9fa/_posts/2015-04-08-osx-security-bug.md>./// However because Mio uses edge-triggers it will not result in an infinite/// loop as described in the article above./// Returns true if the event contains writable readiness./// Returns true if the event contains error readiness./// Error events occur when the socket enters an error state. In this case,/// the socket will also receive a readable or writable event. Reading or/// writing to the socket will result in an error./// Method is available on all platforms, but not all platforms trigger the/// error event./// The table below shows what flags are checked on what OS./// | [OS selector] | Flag(s) checked |/// |---------------|-----------------|/// | [epoll]       | `EPOLLERR`      |/// | [kqueue]      | `EV_ERROR` and `EV_EOF` with `fflags` set to `0`. |/// [OS selector]: ../struct.Poll.html#implementation-notes/// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html/// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2/// Returns true if the event contains read closed readiness./// Read closed readiness can be expected after any of the following have/// occurred:/// * The local stream has shutdown the read half of its socket/// * The local stream has shutdown both the read half and the write half///   of its socket/// * The peer stream has shutdown the write half its socket; this sends a///   `FIN` packet that has been received by the local stream/// Method is a best effort implementation. While some platforms may not/// return readiness when read half is closed, it is guaranteed that/// false-positives will not occur./// | [epoll]       | `EPOLLHUP`, or  |/// |               | `EPOLLIN` and `EPOLLRDHUP` |/// | [kqueue]      | `EV_EOF`        |/// Returns true if the event contains write closed readiness./// On [epoll] this is essentially a check for `EPOLLHUP` flag as the/// local stream shutting down its write half does not trigger this event./// On [kqueue] the local stream shutting down the write half of its/// socket will trigger this event./// return readiness when write half is closed, it is guaranteed that/// |               | only `EPOLLERR`, or |/// |               | `EPOLLOUT` and `EPOLLERR` |is_priority/// Returns true if the event contains priority readiness./// priority event./// | [epoll]       | `EPOLLPRI`      |/// | [kqueue]      | *Not supported* |is_aio/// Returns true if the event contains AIO readiness./// Method is available on all platforms, but not all platforms support AIO./// | [epoll]       | *Not supported* |/// | [kqueue]<sup>1</sup> | `EVFILT_AIO` |/// 1: Only supported on DragonFly BSD, FreeBSD, iOS and macOS.is_lio/// Returns true if the event contains LIO readiness./// Method is available on all platforms, but only FreeBSD supports LIO. On/// FreeBSD this method checks the `EVFILT_LIO` flag.from_sys_event_ref/// Create a reference to an `Event` from a platform specific event./// When the [alternate] flag is enabled this will print platform specific/// details, for example the fields of the `kevent` structure on platforms that/// use `kqueue(2)`. Note however that the output of this implementation is/// **not** consider a part of the stable API./// [alternate]: fmt::Formatter::alternate/// A collection of readiness events./// `Events` is passed as an argument to [`Poll::poll`] and will be used to/// receive any new readiness events received since the last poll. Usually, a/// single `Events` instance is created at the same time as a [`Poll`] and/// reused on each call to [`Poll::poll`]./// See [`Poll`] for more documentation on polling./// use mio::{Events, Poll};/// let mut events = Events::with_capacity(1024);/// let mut poll = Poll::new()?;/// # assert!(events.is_empty());/// // Register `event::Source`s with `poll`./// poll.poll(&mut events, Some(Duration::from_millis(100)))?;/// for event in events.iter() {///     println!("Got an event for {:?}", event.token());/// [`Events`] iterator./// This struct is created by the [`iter`] method on [`Events`]./// [`Events`]: struct.Events.html/// [`iter`]: struct.Events.html#method.iter/// // Register handles with `poll`./// Return a new `Events` capable of holding up to `capacity` events./// use mio::Events;/// let events = Events::with_capacity(1024);/// assert_eq!(1024, events.capacity());/// Returns the number of `Event` values that `self` can hold./// Returns `true` if `self` contains no `Event` values./// assert!(events.is_empty());/// Returns an iterator over the `Event` values./// Clearing all `Event` values from container explicitly./// Events are cleared before every `poll`, so it is not required to call/// this manually./// // Clear all events./// events.clear();/// Returns the inner `sys::Events`.//! Readiness event types and utilities./// Register `self` with the given `Registry` instance./// This function should not be called directly. Use [`Registry::register`]/// instead. Implementors should handle registration by delegating the call/// to another `Source` type./// [`Registry::register`]: ../struct.Registry.html#method.register/// Re-register `self` with the given `Registry` instance./// This function should not be called directly. Use/// [`Registry::reregister`] instead. Implementors should handle/// re-registration by either delegating the call to another `Source` type./// [`Registry::reregister`]: ../struct.Registry.html#method.reregisterderegister/// Deregister `self` from the given `Registry` instance./// [`Registry::deregister`] instead. Implementors should handle/// deregistration by delegating the call to another `Source` type./// [`Registry::deregister`]: ../struct.Registry.html#method.deregister/// An event source that may be registered with [`Registry`]./// Types that implement `event::Source` can be registered with/// `Registry`. Users of Mio **should not** use the `event::Source` trait/// functions directly. Instead, the equivalent functions on `Registry` should/// See [`Registry`] for more details./// [`Registry`]: ../struct.Registry.html/// # Implementing `event::Source`/// Event sources are always backed by system handles, such as sockets or other/// system handles. These `event::Source`s will be monitored by the system/// selector. An implementation of `Source` will almost always delegates to a/// lower level handle. Examples of this are [`TcpStream`]s, or the *unix only*/// [`SourceFd`]./// [`TcpStream`]: ../net/struct.TcpStream.html/// [`SourceFd`]: ../unix/struct.SourceFd.html/// # Dropping `event::Source`s/// All `event::Source`s, unless otherwise specified, need to be [deregistered]/// before being dropped for them to not leak resources. This goes against the/// normal drop behaviour of types in Rust which cleanup after themselves, e.g./// a `File` will close itself. However since deregistering needs access to/// [`Registry`] this cannot be done while being dropped./// [deregistered]: ../struct.Registry.html#method.deregister/// Implementing `Source` on a struct containing a socket:/// use mio::{Interest, Registry, Token};/// use mio::event::Source;/// use mio::net::TcpStream;/// # #[allow(dead_code)]/// pub struct MySource {///     socket: TcpStream,/// impl Source for MySource {///     fn register(&mut self, registry: &Registry, token: Token, interests: Interest)///         -> io::Result<()>///         // Delegate the `register` call to `socket`///         self.socket.register(registry, token, interests)///     fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest)///         // Delegate the `reregister` call to `socket`///         self.socket.reregister(registry, token, interests)///     fn deregister(&mut self, registry: &Registry) -> io::Result<()> {///         // Delegate the `deregister` call to `socket`///         self.socket.deregister(registry)/// Interest used in registering./// Interest are used in [registering] [`event::Source`]s with [`Poll`], they/// indicate what readiness should be monitored for. For example if a socket is/// registered with [readable] interests and the socket becomes writable, no/// event will be returned from a call to [`poll`]./// [registering]: struct.Registry.html#method.register/// [`event::Source`]: ./event/trait.Source.html/// [`Poll`]: struct.Poll.html/// [readable]: struct.Interest.html#associatedconstant.READABLE/// [`poll`]: struct.Poll.html#method.poll// These must be unique.AIO// The following are not available on all platforms.LIOPRIORITY/// Returns a `Interest` set representing readable interests./// Returns a `Interest` set representing writable interests./// Returns a `Interest` set representing priority completion interests./// Add together two `Interest`./// This does the same thing as the `BitOr` implementation, but is a/// constant function./// use mio::Interest;/// const INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE);/// # fn silent_dead_code_warning(_: Interest) { }/// # silent_dead_code_warning(INTERESTS)/// Removes `other` `Interest` from `self`./// Returns `None` if the set would be empty after removing `other`./// const RW_INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE);/// // As long a one interest remain this will return `Some`./// let w_interest = RW_INTERESTS.remove(Interest::READABLE).unwrap();/// assert!(!w_interest.is_readable());/// assert!(w_interest.is_writable());/// // Removing all interests from the set will return `None`./// assert_eq!(w_interest.remove(Interest::WRITABLE), None);/// // Its also possible to remove multiple interests at once./// assert_eq!(RW_INTERESTS.remove(RW_INTERESTS), None);/// Returns true if the value includes readable readiness./// Returns true if the value includes writable readiness./// Returns true if `Interest` contains AIO readiness./// Returns true if `Interest` contains LIO readiness./// Returns true if `Interest` contains priority readiness.IoSourceStateIoSource/// Adapter for a [`RawFd`] or [`RawSocket`] providing an [`event::Source`]/// `IoSource` enables registering any FD or socket wrapper with [`Poll`]./// While only implementations for TCP, UDP, and UDS (Unix only) are provided,/// Mio supports registering any FD or socket that can be registered with the/// underlying OS selector. `IoSource` provides the necessary bridge./// [`RawFd`]: std::os::unix::io::RawFd/// [`RawSocket`]: std::os::windows::io::RawSocket/// To handle the registrations and events properly **all** I/O operations (such/// as `read`, `write`, etc.) must go through the [`do_io`] method to ensure the/// internal state is updated accordingly./// [`Poll`]: crate::Poll/// [`do_io`]: IoSource::do_io/*
///
/// # Examples
///
/// Basic usage.
///
/// ```
/// # use std::error::Error;
/// # fn main() -> Result<(), Box<dyn Error>> {
/// use mio::{Interest, Poll, Token};
/// use mio::IoSource;
///
/// use std::net;
///
/// let poll = Poll::new()?;
///
/// // Bind a std TCP listener.
/// let listener = net::TcpListener::bind("127.0.0.1:0")?;
/// // Wrap it in the `IoSource` type.
/// let mut listener = IoSource::new(listener);
///
/// // Register the listener.
/// poll.registry().register(&mut listener, Token(0), Interest::READABLE)?;
/// #     Ok(())
/// # }
/// ```
*//// Create a new `IoSource`.do_io/// Execute an I/O operations ensuring that the socket receives more events/// if it hits a [`WouldBlock`] error./// This method is required to be called for **all** I/O operations to/// ensure the user will receive events once the socket is ready again after/// returning a [`WouldBlock`] error./// [`WouldBlock`]: io::ErrorKind::WouldBlock/// Returns the I/O source, dropping the state./// To ensure no more events are to be received for this I/O source first/// [`deregister`] it./// [`deregister`]: Registry::deregister/// Be careful when using this method. All I/O operations that may block must go/// through the [`do_io`] method.// macros used internallycfg_io_sourceio_sourcecfg_net//! Unix pipe.//! See the [`new`] function for documentation.//! Unix only extensions.//! # Mio's optional features.//! This document describes the available features in Mio.//! Mio by default provides only a shell implementation that `panic!`s the//! moment it is actually run. To run it requires OS support, this is//! enabled by activating the `os-poll` feature.//! This makes `Poll`, `Registry` and `Waker` functional.//! `os-ext` enables additional OS specific facilities. These facilities can//! be found in the `unix` and `windows` module.//! The `net` feature enables networking primitives in the `net` module.//! # Getting started guide.//! In this guide we'll do the following://! 1. Create a [`Poll`] instance (and learn what it is).//! 2. Register an [event source].//! 3. Create an event loop.//! At the end you'll have a very small (but quick) TCP server that accepts//! connections and then drops (disconnects) them.//! ## 1. Creating a `Poll` instance//! Using Mio starts by creating a [`Poll`] instance, which monitors events//! from the OS and puts them into [`Events`]. This allows us to execute I/O//! operations based on what operations are ready.//! [`Poll`]: ../struct.Poll.html//! [`Events`]: ../event/struct.Events.html//! # use mio::{Poll, Events};//! // `Poll` allows for polling of readiness events.//! let poll = Poll::new()?;//! // `Events` is collection of readiness `Event`s and can be filled by//! // calling `Poll::poll`.//! let events = Events::with_capacity(128);//! # drop((poll, events));//! For example if we're using a [`TcpListener`],  we'll only want to//! attempt to accept an incoming connection *iff* any connections are//! queued and ready to be accepted. We don't want to waste our time if no//! connections are ready.//! [`TcpListener`]: ../net/struct.TcpListener.html//! ## 2. Registering event source//! After we've created a [`Poll`] instance that monitors events from the OS//! for us, we need to provide it with a source of events. This is done by//! registering an [event source]. As the name “event source” suggests it is//! a source of events which can be polled using a `Poll` instance. On Unix//! systems this is usually a file descriptor, or a socket/handle on//! Windows.//! In the example below we'll use a [`TcpListener`] for which we'll receive//! an event (from [`Poll`]) once a connection is ready to be accepted.//! [event source]: ../event/trait.Source.html//! # use mio::net::TcpListener;//! # use mio::{Poll, Token, Interest};//! # let poll = Poll::new()?;//! # let address = "127.0.0.1:0".parse().unwrap();//! // Create a `TcpListener`, binding it to `address`.//! let mut listener = TcpListener::bind(address)?;//! // Next we register it with `Poll` to receive events for it. The `SERVER`//! // `Token` is used to determine that we received an event for the listener//! // later on.//! const SERVER: Token = Token(0);//! poll.registry().register(&mut listener, SERVER, Interest::READABLE)?;//! Multiple event sources can be [registered] (concurrently), so we can//! monitor multiple sources at a time.//! [registered]: ../struct.Registry.html#method.register//! ## 3. Creating the event loop//! After we've created a [`Poll`] instance and registered one or more//! [event sources] with it, we can [poll] it for events. Polling for events//! is simple, we need a container to store the events: [`Events`] and need//! to do something based on the polled events (this part is up to you, we//! can't do it all!). If we do this in a loop we've got ourselves an event//! loop.//! The example below shows the event loop in action, completing our small//! TCP server.//! [poll]: ../struct.Poll.html#method.poll//! [event sources]: ../event/trait.Source.html//! # use mio::{Poll, Token, Interest, Events};//! # fn main() -> io::Result<()> {//! # let mut poll = Poll::new()?;//! # let mut events = Events::with_capacity(128);//! # let mut listener = TcpListener::bind(address)?;//! # const SERVER: Token = Token(0);//! # poll.registry().register(&mut listener, SERVER, Interest::READABLE)?;//! // Start our event loop.//!     // Poll the OS for events, waiting at most 100 milliseconds.//!     poll.poll(&mut events, Some(Duration::from_millis(100)))?;//!     // Process each event.//!     for event in events.iter() {//!         // We can use the token we previously provided to `register` to//!         // determine for which type the event is.//!         match event.token() {//!             SERVER => loop {//!                 // One or more connections are ready, so we'll attempt to//!                 // accept them (in a loop).//!                 match listener.accept() {//!                     Ok((connection, address)) => {//!                         println!("Got a connection from: {}", address);//! #                       drop(connection);//!                     },//!                     // A "would block error" is returned if the operation//!                     // is not ready, so we'll stop trying to accept//!                     // connections.//!                     Err(ref err) if would_block(err) => break,//!                     Err(err) => return Err(err),//! #           _ => unreachable!(),//! #   return Ok(());//! fn would_block(err: &io::Error) -> bool {//!     err.kind() == io::ErrorKind::WouldBlockguide// Disallow warnings when running tests.// Disallow warnings in examples.//! Mio is a fast, low-level I/O library for Rust focusing on non-blocking APIs//! and event notification for building high performance I/O apps with as little//! overhead as possible over the OS abstractions.//! Using Mio starts by creating a [`Poll`], which reads events from the OS and//! puts them into [`Events`]. You can handle I/O events from the OS with it.//! For more detail, see [`Poll`].//! [`Poll`]: ../mio/struct.Poll.html//! [`Events`]: ../mio/event/struct.Events.html//! Examples can found in the `examples` directory of the source code, or [on//! GitHub].//! [on GitHub]: https://github.com/tokio-rs/mio/tree/master/examples//! ## Guide//! A getting started guide is available in the [`guide`] module.//! ## Available features//! The available features are described in the [`features`] module.cfg_os_poll/// The `os-poll` feature is enabled.cfg_not_os_poll/// The `os-poll` feature is disabled.cfg_os_ext/// The `os-ext` feature is enabled./// The `net` feature is enabled./// One of the features enabled that needs `IoSource`. That is `net` or `os-ext`/// on Unix (for `pipe`).cfg_any_os_ext/// The `os-ext` feature is enabled, or one of the features that need `os-ext`.//! Macros to ease conditional code based on enabled features.// Depending on the features not all macros are used.uds//! Networking primitives.//! The types provided in this module are non-blocking by default and are//! designed to be portable across all supported Mio platforms. As long as the//! [portability guidelines] are followed, the behavior should be identical no//! matter the target platform.//! [portability guidelines]: ../struct.Poll.html#portability//! When using a datagram based socket, i.e. [`UdpSocket`] or [`UnixDatagram`],//! its only possible to receive a packet once. This means that if you provide a//! buffer that is too small you won't be able to receive the data anymore. How//! OSs deal with this situation is different for each OS://!  * Unixes, such as Linux, FreeBSD and macOS, will simply fill the buffer and//!    return the amount of bytes written. This means that if the returned value//!    is equal to the size of the buffer it may have only written a part of the//!    packet (or the packet has the same size as the buffer).//!  * Windows returns an `WSAEMSGSIZE` error.//! Mio does not change the value (either ok or error) returned by the OS, it's//! up to the user handle this. How to deal with these difference is still up//! for debate, specifically in//! <https://github.com/rust-lang/rust/issues/55794>. The best advice we can//! give is to always call receive with a large enough buffer.set_reuseaddrnew_for_addr/// A structure representing a socket server/// use mio::{Events, Interest, Poll, Token};/// use mio::net::TcpListener;/// let mut listener = TcpListener::bind("127.0.0.1:34255".parse()?)?;/// let mut events = Events::with_capacity(128);/// // Register the socket with `Poll`/// poll.registry().register(&mut listener, Token(0), Interest::READABLE)?;/// // There may be a socket ready to be accepted/// Convenience method to bind a new TCP listener to the specified address/// to receive new connections./// This function will take the following steps:/// 1. Create a new TCP socket./// 2. Set the `SO_REUSEADDR` option on the socket on Unix./// 3. Bind the socket to the specified address./// 4. Calls `listen` on the socket to prepare it to receive new connections./// Creates a new `TcpListener` from a standard `net::TcpListener`./// This function is intended to be used to wrap a TCP listener from the/// standard library in the Mio equivalent. The conversion assumes nothing/// about the underlying listener; ; it is left up to the user to set it/// in non-blocking mode./// Accepts a new `TcpStream`./// This may return an `Err(e)` where `e.kind()` is/// `io::ErrorKind::WouldBlock`. This means a stream may be ready at a later/// point and one should wait for an event before calling `accept` again./// If an accepted stream is returned, the remote address of the peer is/// returned along with it./// Returns the local socket address of this listener./// Sets the value for the `IP_TTL` option on this socket./// This value sets the time-to-live field that is used in every packet sent/// from this socket./// Gets the value of the `IP_TTL` option for this socket./// For more information about this option, see [`set_ttl`][link]./// [link]: #method.set_ttl/// Get the value of the `SO_ERROR` option on this socket./// This will retrieve the stored error in the underlying socket, clearing/// the field in the process. This can be useful for checking errors between/// Converts a `RawFd` to a `TcpListener`./// The caller is responsible for ensuring that the socket is in/// non-blocking mode./// Converts a `RawSocket` to a `TcpListener`./// A non-blocking TCP stream between a local socket and a remote socket./// The socket will be closed when the value is dropped./// # use std::net::{TcpListener, SocketAddr};/// let address: SocketAddr = "127.0.0.1:0".parse()?;/// let listener = TcpListener::bind(address)?;/// let mut stream = TcpStream::connect(listener.local_addr()?)?;/// poll.registry().register(&mut stream, Token(0), Interest::WRITABLE)?;/// // The socket might be ready at this point/// Create a new TCP stream and issue a non-blocking connect to the/// specified address./// The returned `TcpStream` may not be connected (and thus usable), unlike/// the API found in `std::net::TcpStream`. Because Mio issues a/// *non-blocking* connect it will not block the thread and instead return/// an unconnected `TcpStream`./// Ensuring the returned stream is connected is surprisingly complex when/// considering cross-platform support. Doing this properly should follow/// the steps below, an example implementation can be found/// [here](https://github.com/Thomasdezeeuw/heph/blob/0c4f1ab3eaf08bea1d65776528bfd6114c9f8374/src/net/tcp/stream.rs#L560-L622).///  1. Call `TcpStream::connect`///  2. Register the returned stream with at least [write interest].///  3. Wait for a (writable) event.///  4. Check `TcpStream::peer_addr`. If it returns `libc::EINPROGRESS` or///     `ErrorKind::NotConnected` it means the stream is not yet connected,///     go back to step 3. If it returns an address it means the stream is///     connected, go to step 5. If another error is returned something///     went wrong.///  5. Now the stream can be used./// This may return a `WouldBlock` in which case the socket connection/// cannot be completed immediately, it usually means there are insufficient/// entries in the routing cache./// [write interest]: Interest::WRITABLE/// Creates a new `TcpStream` from a standard `net::TcpStream`./// This function is intended to be used to wrap a TCP stream from the/// about the underlying stream; it is left up to the user to set it in/// The TCP stream here will not have `connect` called on it, so it/// should already be connected via some other means (be it manually, or/// the standard library).peer_addr/// Returns the socket address of the remote peer of this TCP connection./// Returns the socket address of the local half of this TCP connection./// Shuts down the read, write, or both halves of this connection./// This function will cause all pending and future I/O on the specified/// portions to return immediately with an appropriate value (see the/// documentation of `Shutdown`)./// Sets the value of the `TCP_NODELAY` option on this socket./// If set, this option disables the Nagle algorithm. This means that/// segments are always sent as soon as possible, even if there is only a/// small amount of data. When not set, data is buffered until there is a/// sufficient amount to send out, thereby avoiding the frequent sending of/// small packets./// On Windows make sure the stream is connected before calling this method,/// by receiving an (writable) event. Trying to set `nodelay` on an/// unconnected `TcpStream` is unspecified behavior./// Gets the value of the `TCP_NODELAY` option on this socket./// For more information about this option, see [`set_nodelay`][link]./// [link]: #method.set_nodelay/// by receiving an (writable) event. Trying to get `nodelay` on an/// by receiving an (writable) event. Trying to set `ttl` on an/// by receiving an (writable) event. Trying to get `ttl` on an/// Receives data on the socket from the remote address to which it is/// connected, without removing that data from the queue. On success,/// returns the number of bytes peeked./// Successive calls return the same data. This is accomplished by passing/// `MSG_PEEK` as a flag to the underlying recv system call.try_io/// Execute an I/O operation ensuring that the socket receives more events/// #[cfg(unix)]/// use std::os::unix::io::AsRawFd;/// #[cfg(windows)]/// use std::os::windows::io::AsRawSocket;/// let address = "127.0.0.1:8080".parse().unwrap();/// let stream = TcpStream::connect(address)?;/// // Wait until the stream is readable.../// // Read from the stream using a direct libc call, of course the/// // `io::Read` implementation would be easier to use./// let mut buf = [0; 512];/// let n = stream.try_io(|| {///     let buf_ptr = &mut buf as *mut _ as *mut _;///     #[cfg(unix)]///     let res = unsafe { libc::recv(stream.as_raw_fd(), buf_ptr, buf.len(), 0) };///     #[cfg(windows)]///     let res = unsafe { libc::recvfrom(stream.as_raw_socket() as usize, buf_ptr, buf.len() as i32, 0, std::ptr::null_mut(), std::ptr::null_mut()) };///     if res != -1 {///         Ok(res as usize)///         // If EAGAIN or EWOULDBLOCK is set by libc::recv, the closure///         // should return `WouldBlock` error.///         Err(io::Error::last_os_error())/// eprintln!("read {} bytes", n);/// Converts a `RawFd` to a `TcpStream`./// Converts a `RawSocket` to a `TcpStream`./// A User Datagram Protocol socket./// This is an implementation of a bound UDP socket. This supports both IPv4 and/// IPv6 addresses, and there is no corresponding notion of a server because UDP/// is a datagram protocol./// // An Echo program:/// // SENDER -> sends a message./// // ECHOER -> listens and prints the message received./// use mio::net::UdpSocket;/// const SENDER: Token = Token(0);/// const ECHOER: Token = Token(1);/// // This operation will fail if the address is in use, so we select different ports for each/// // socket./// let mut sender_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?;/// let mut echoer_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?;/// // If we do not use connect here, SENDER and ECHOER would need to call send_to and recv_from/// // respectively./// sender_socket.connect(echoer_socket.local_addr()?)?;/// // We need a Poll to check if SENDER is ready to be written into, and if ECHOER is ready to be/// // read from./// // We register our sockets here so that we can check if they are ready to be written/read./// poll.registry().register(&mut sender_socket, SENDER, Interest::WRITABLE)?;/// poll.registry().register(&mut echoer_socket, ECHOER, Interest::READABLE)?;/// let msg_to_send = [9; 9];/// let mut buffer = [0; 9];///     poll.poll(&mut events, Some(Duration::from_millis(100)))?;///     for event in events.iter() {///         match event.token() {///             // Our SENDER is ready to be written into.///             SENDER => {///                 let bytes_sent = sender_socket.send(&msg_to_send)?;///                 assert_eq!(bytes_sent, 9);///                 println!("sent {:?} -> {:?} bytes", msg_to_send, bytes_sent);///             },///             // Our ECHOER is ready to be read from.///             ECHOER => {///                 let num_recv = echoer_socket.recv(&mut buffer)?;///                 println!("echo {:?} -> {:?}", buffer, num_recv);///                 buffer = [0; 9];///                 # _ = buffer; // Silence unused assignment warning.///                 # return Ok(());///             _ => unreachable!()/// Creates a UDP socket from the given address./// // We must bind it to an open address./// let socket = match UdpSocket::bind("127.0.0.1:0".parse()?) {///     Ok(new_socket) => new_socket,///     Err(fail) => {///         // We panic! here, but you could try to bind it again on another address.///         panic!("Failed to bind socket. {:?}", fail);/// // Our socket was created, but we should not use it before checking it's readiness./// #    drop(socket); // Silence unused variable warning./// #    Ok(())/// Creates a new `UdpSocket` from a standard `net::UdpSocket`./// This function is intended to be used to wrap a UDP socket from the/// about the underlying socket; it is left up to the user to set it in/// Returns the socket address that this socket was created from.// This assertion is almost, but not quite, universal.  It fails on// shared-IP FreeBSD jails.  It's hard for mio to know whether we're jailed,// so simply disable the test on FreeBSD./// let addr = "127.0.0.1:0".parse()?;/// let socket = UdpSocket::bind(addr)?;/// assert_eq!(socket.local_addr()?.ip(), addr.ip());/// Returns the socket address of the remote peer this socket was connected to./// let peer_addr = "127.0.0.1:11100".parse()?;/// socket.connect(peer_addr)?;/// assert_eq!(socket.peer_addr()?.ip(), peer_addr.ip());/// Sends data on the socket to the given address. On success, returns the/// Address type can be any implementor of `ToSocketAddrs` trait. See its/// documentation for concrete examples./// let socket = UdpSocket::bind("127.0.0.1:0".parse()?)?;/// // We must check if the socket is writable before calling send_to,/// // or we could run into a WouldBlock error./// let bytes_sent = socket.send_to(&[9; 9], "127.0.0.1:11100".parse()?)?;/// assert_eq!(bytes_sent, 9);/// Receives data from the socket. On success, returns the number of bytes/// read and the address from whence the data came./// On Windows, if the data is larger than the buffer specified, the buffer/// is filled with the first part of the data, and recv_from returns the error/// WSAEMSGSIZE(10040). The excess data is lost./// Make sure to always use a sufficiently large buffer to hold the/// maximum UDP packet size, which can be up to 65536 bytes in size./// // We must check if the socket is readable before calling recv_from,/// let mut buf = [0; 9];/// let (num_recv, from_addr) = socket.recv_from(&mut buf)?;/// println!("Received {:?} -> {:?} bytes from {:?}", buf, num_recv, from_addr);/// Receives data from the socket, without removing it from the input queue./// On success, returns the number of bytes read and the address from whence/// the data came./// is filled with the first part of the data, and peek_from returns the error/// let (num_recv, from_addr) = socket.peek_from(&mut buf)?;/// Sends data on the socket to the address previously bound via connect(). On success,/// returns the number of bytes written./// Receives data from the socket previously bound with connect(). On success, returns/// the number of bytes read./// is filled with the first part of the data, and recv returns the error/// On success, returns the number of bytes read./// is filled with the first part of the data, and peek returns the error/// Connects the UDP socket setting the default destination for `send()`/// and limiting packets that are read via `recv` from the address specified/// in `addr`./// Sets the value of the `SO_BROADCAST` option for this socket./// When enabled, this socket is allowed to send packets to a broadcast/// let broadcast_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?;/// if broadcast_socket.broadcast()? == false {///     broadcast_socket.set_broadcast(true)?;/// assert_eq!(broadcast_socket.broadcast()?, true);/// Gets the value of the `SO_BROADCAST` option for this socket./// For more information about this option, see/// [`set_broadcast`][link]./// [link]: #method.set_broadcast/// assert_eq!(broadcast_socket.broadcast()?, false);set_multicast_loop_v4/// Sets the value of the `IP_MULTICAST_LOOP` option for this socket./// If enabled, multicast packets will be looped back to the local socket./// Note that this may not have any affect on IPv6 sockets.multicast_loop_v4/// Gets the value of the `IP_MULTICAST_LOOP` option for this socket./// [`set_multicast_loop_v4`][link]./// [link]: #method.set_multicast_loop_v4set_multicast_ttl_v4/// Sets the value of the `IP_MULTICAST_TTL` option for this socket./// Indicates the time-to-live value of outgoing multicast packets for/// this socket. The default value is 1 which means that multicast packets/// don't leave the local network unless explicitly requested.multicast_ttl_v4/// Gets the value of the `IP_MULTICAST_TTL` option for this socket./// [`set_multicast_ttl_v4`][link]./// [link]: #method.set_multicast_ttl_v4set_multicast_loop_v6/// Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket./// Controls whether this socket sees the multicast packets it sends itself./// Note that this may not have any affect on IPv4 sockets.multicast_loop_v6/// Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket./// [`set_multicast_loop_v6`][link]./// [link]: #method.set_multicast_loop_v6/// if socket.ttl()? < 255 {///     socket.set_ttl(255)?;/// assert_eq!(socket.ttl()?, 255);/// socket.set_ttl(255)?;join_multicast_v4/// Executes an operation of the `IP_ADD_MEMBERSHIP` type./// This function specifies a new multicast group for this socket to join./// The address must be a valid multicast address, and `interface` is the/// address of the local interface with which the system should join the/// multicast group. If it's equal to `INADDR_ANY` then an appropriate/// interface is chosen by the system.join_multicast_v6/// Executes an operation of the `IPV6_ADD_MEMBERSHIP` type./// index of the interface to join/leave (or 0 to indicate any interface).leave_multicast_v4/// Executes an operation of the `IP_DROP_MEMBERSHIP` type./// [`join_multicast_v4`][link]./// [link]: #method.join_multicast_v4leave_multicast_v6/// Executes an operation of the `IPV6_DROP_MEMBERSHIP` type./// [`join_multicast_v6`][link]./// [link]: #method.join_multicast_v6only_v6/// Get the value of the `IPV6_V6ONLY` option on this socket./// let dgram = UdpSocket::bind(address)?;/// // Wait until the dgram is readable.../// // Read from the dgram using a direct libc call, of course the/// let n = dgram.try_io(|| {///     let res = unsafe { libc::recv(dgram.as_raw_fd(), buf_ptr, buf.len(), 0) };///     let res = unsafe { libc::recvfrom(dgram.as_raw_socket() as usize, buf_ptr, buf.len() as i32, 0, std::ptr::null_mut(), std::ptr::null_mut()) };/// Converts a `RawFd` to a `UdpSocket`./// Converts a `RawSocket` to a `UdpSocket`.//! Primitives for working with UDP./// A Unix datagram socket./// Creates a Unix datagram socket bound to the given path./// Creates a new `UnixDatagram` from a standard `net::UnixDatagram`./// This function is intended to be used to wrap a Unix datagram from the/// about the underlying datagram; it is left up to the user to set it in/// Connects the socket to the specified address./// cannot be completed immediately./// Creates a Unix Datagram socket which is not bound to any address./// Create an unnamed pair of connected sockets./// Returns the address of this socket./// Returns the address of this socket's peer./// The `connect` method will connect the socket to a peer./// On success, returns the number of bytes read and the address from/// whence the data came./// Sends data on the socket to the specified address./// On success, returns the number of bytes written./// Sends data on the socket to the socket's peer./// The peer address may be set by the `connect` method, and this method/// will return an error if the socket has not already been connected./// Returns the value of the `SO_ERROR` option./// Shut down the read, write, or both halves of this connection./// This function will cause all pending and future I/O calls on the/// specified portions to immediately return with an appropriate value/// (see the documentation of `Shutdown`)./// use mio::net::UnixDatagram;/// let (dgram1, dgram2) = UnixDatagram::pair()?;/// // Wait until the dgram is writable.../// // Write to the dgram using a direct libc call, of course the/// // `io::Write` implementation would be easier to use./// let buf = b"hello";/// let n = dgram1.try_io(|| {///     let buf_ptr = &buf as *const _ as *const _;///     let res = unsafe { libc::send(dgram1.as_raw_fd(), buf_ptr, buf.len(), 0) };///         // If EAGAIN or EWOULDBLOCK is set by libc::send, the closure/// eprintln!("write {} bytes", n);/// let n = dgram2.try_io(|| {///     let res = unsafe { libc::recv(dgram2.as_raw_fd(), buf_ptr, buf.len(), 0) };/// Converts a `RawFd` to a `UnixDatagram`./// A non-blocking Unix domain socket server./// Creates a new `UnixListener` bound to the specified socket `path`./// Creates a new `UnixListener` bound to the specified socket `address`./// Creates a new `UnixListener` from a standard `net::UnixListener`./// This function is intended to be used to wrap a Unix listener from the/// about the underlying listener; it is left up to the user to set it in/// Accepts a new incoming connection to this listener./// The call is responsible for ensuring that the listening socket is in/// Converts a `RawFd` to a `UnixListener`.datagram/// A non-blocking Unix stream socket./// Connects to the socket named by `path`./// cannot be completed immediately. Usually it means the backlog is full.connect_addr/// Connects to the socket named by `address`./// Creates a new `UnixStream` from a standard `net::UnixStream`./// This function is intended to be used to wrap a Unix stream from the/// The Unix stream here will not have `connect` called on it, so it/// Creates an unnamed pair of connected sockets./// Returns two `UnixStream`s which are connected to each other./// Returns the socket address of the local half of this connection./// Returns the socket address of the remote half of this connection./// use mio::net::UnixStream;/// let (stream1, stream2) = UnixStream::pair()?;/// // Wait until the stream is writable.../// // Write to the stream using a direct libc call, of course the/// let n = stream1.try_io(|| {///     let res = unsafe { libc::send(stream1.as_raw_fd(), buf_ptr, buf.len(), 0) };/// let n = stream2.try_io(|| {///     let res = unsafe { libc::recv(stream2.as_raw_fd(), buf_ptr, buf.len(), 0) };/// Converts a `RawFd` to a `UnixStream`./// Polls for readiness events on all registered values./// `Poll` allows a program to monitor a large number of [`event::Source`]s,/// waiting until one or more become "ready" for some class of operations; e.g./// reading and writing. An event source is considered ready if it is possible/// to immediately perform a corresponding operation; e.g. [`read`] or/// [`write`]./// To use `Poll`, an `event::Source` must first be registered with the `Poll`/// instance using the [`register`] method on its associated `Register`,/// supplying readiness interest. The readiness interest tells `Poll` which/// specific operations on the handle to monitor for readiness. A `Token` is/// also passed to the [`register`] function. When `Poll` returns a readiness/// event, it will include this token.  This associates the event with the/// event source that generated the event./// [`read`]: ./net/struct.TcpStream.html#method.read/// [`write`]: ./net/struct.TcpStream.html#method.write/// [`register`]: struct.Registry.html#method.register/// A basic example -- establishing a `TcpStream` connection./// use mio::{Events, Poll, Interest, Token};/// use std::net::{self, SocketAddr};/// // Bind a server socket to connect to./// let addr: SocketAddr = "127.0.0.1:0".parse()?;/// let server = net::TcpListener::bind(addr)?;/// // Construct a new `Poll` handle as well as the `Events` we'll store into/// // Connect the stream/// let mut stream = TcpStream::connect(server.local_addr()?)?;/// // Register the stream with `Poll`/// poll.registry().register(&mut stream, Token(0), Interest::READABLE | Interest::WRITABLE)?;/// // Wait for the socket to become ready. This has to happens in a loop to/// // handle spurious wakeups.///     poll.poll(&mut events, None)?;///     for event in &events {///         if event.token() == Token(0) && event.is_writable() {///             // The socket connected (probably, it could still be a spurious///             // wakeup)///             return Ok(());/// # Portability/// Using `Poll` provides a portable interface across supported platforms as/// long as the caller takes the following into consideration:/// ### Spurious events/// [`Poll::poll`] may return readiness events even if the associated/// event source is not actually ready. Given the same code, this may/// happen more on some platforms than others. It is important to never assume/// that, just because a readiness event was received, that the associated/// operation will succeed as well./// If operation fails with [`WouldBlock`], then the caller should not treat/// this as an error, but instead should wait until another readiness event is/// ### Draining readiness/// Once a readiness event is received, the corresponding operation must be/// performed repeatedly until it returns [`WouldBlock`]. Unless this is done,/// there is no guarantee that another readiness event will be delivered, even/// if further data is received for the event source./// [`WouldBlock`]: std::io::ErrorKind::WouldBlock/// ### Readiness operations/// The only readiness operations that are guaranteed to be present on all/// supported platforms are [`readable`] and [`writable`]. All other readiness/// operations may have false negatives and as such should be considered/// **hints**. This means that if a socket is registered with [`readable`]/// interest and either an error or close is received, a readiness event will/// be generated for the socket, but it **may** only include `readable`/// readiness. Also note that, given the potential for spurious events,/// receiving a readiness event with `read_closed`, `write_closed`, or `error`/// doesn't actually mean that a `read` on the socket will return a result/// matching the readiness event./// In other words, portable programs that explicitly check for [`read_closed`],/// [`write_closed`], or [`error`] readiness should be doing so as an/// **optimization** and always be able to handle an error or close situation/// when performing the actual read operation./// [`readable`]: ./event/struct.Event.html#method.is_readable/// [`writable`]: ./event/struct.Event.html#method.is_writable/// [`error`]: ./event/struct.Event.html#method.is_error/// [`read_closed`]: ./event/struct.Event.html#method.is_read_closed/// [`write_closed`]: ./event/struct.Event.html#method.is_write_closed/// ### Registering handles/// Unless otherwise noted, it should be assumed that types implementing/// [`event::Source`] will never become ready unless they are registered with/// `Poll`./// # use std::net;/// use mio::{Poll, Interest, Token};/// use std::net::SocketAddr;/// let listener = net::TcpListener::bind(address)?;/// let mut sock = TcpStream::connect(listener.local_addr()?)?;/// let poll = Poll::new()?;/// // The connect is not guaranteed to have started until it is registered at/// // this point/// poll.registry().register(&mut sock, Token(0), Interest::READABLE | Interest::WRITABLE)?;/// ### Dropping `Poll`/// When the `Poll` instance is dropped it may cancel in-flight operations for/// the registered [event sources], meaning that no further events for them may/// be received. It also means operations on the registered event sources may no/// longer work. It is up to the user to keep the `Poll` instance alive while/// registered event sources are being used./// [event sources]: ./event/trait.Source.html/// ### Accessing raw fd/socket/handle/// Mio makes it possible for many types to be converted into a raw file/// descriptor (fd, Unix), socket (Windows) or handle (Windows). This makes it/// possible to support more operations on the type than Mio supports, for/// example it makes [mio-aio] possible. However accessing the raw fd is not/// without it's pitfalls./// Specifically performing I/O operations outside of Mio on these types (via/// the raw fd) has unspecified behaviour. It could cause no more events to be/// generated for the type even though it returned `WouldBlock` (in an operation/// directly accessing the fd). The behaviour is OS specific and Mio can only/// guarantee cross-platform behaviour if it can control the I/O./// [mio-aio]: https://github.com/asomers/mio-aio/// *The following is **not** guaranteed, just a description of the current/// situation!* Mio is allowed to change the following without it being considered/// a breaking change, don't depend on this, it's just here to inform the user./// Currently the kqueue and epoll implementation support direct I/O operations/// on the fd without Mio's knowledge. Windows however needs **all** I/O/// operations to go through Mio otherwise it is not able to update it's/// internal state properly and won't generate events./// ### Polling without registering event sources/// situation!* Mio is allowed to change the following without it being/// considered a breaking change, don't depend on this, it's just here to inform/// the user. On platforms that use epoll, kqueue or IOCP (see implementation/// notes below) polling without previously registering [event sources] will/// result in sleeping forever, only a process signal will be able to wake up/// the thread./// On WASM/WASI this is different as it doesn't support process signals,/// furthermore the WASI specification doesn't specify a behaviour in this/// situation, thus it's up to the implementation what to do here. As an/// example, the wasmtime runtime will return `EINVAL` in this situation, but/// different runtimes may return different results. If you have further/// insights or thoughts about this situation (and/or how Mio should handle it)/// please add you comment to [pull request#1580]./// [event sources]: crate::event::Source/// [pull request#1580]: https://github.com/tokio-rs/mio/pull/1580/// `Poll` is backed by the selector provided by the operating system./// |      OS       |  Selector |/// |---------------|-----------|/// | Android       | [epoll]   |/// | DragonFly BSD | [kqueue]  |/// | FreeBSD       | [kqueue]  |/// | iOS           | [kqueue]  |/// | illumos       | [epoll]   |/// | Linux         | [epoll]   |/// | NetBSD        | [kqueue]  |/// | OpenBSD       | [kqueue]  |/// | Windows       | [IOCP]    |/// | macOS         | [kqueue]  |/// On all supported platforms, socket operations are handled by using the/// system selector. Platform specific extensions (e.g. [`SourceFd`]) allow/// accessing other features provided by individual system selectors. For/// example, Linux's [`signalfd`] feature can be used by registering the FD with/// `Poll` via [`SourceFd`]./// On all platforms except windows, a call to [`Poll::poll`] is mostly just a/// direct call to the system selector. However, [IOCP] uses a completion model/// instead of a readiness model. In this case, `Poll` must adapt the completion/// model Mio's API. While non-trivial, the bridge layer is still quite/// efficient. The most expensive part being calls to `read` and `write` require/// data to be copied into an intermediate buffer before it is passed to the/// kernel./// [IOCP]: https://docs.microsoft.com/en-us/windows/win32/fileio/i-o-completion-ports/// [`signalfd`]: https://man7.org/linux/man-pages/man2/signalfd.2.html/// [`SourceFd`]: unix/struct.SourceFd.html/// [`Poll::poll`]: struct.Poll.html#method.poll/// Registers I/O resources.r" Return a new `Poll` handle."r" This function will make a syscall to the operating system to create"r" the system selector. If this syscall fails, `Poll::new` will return"r" with the error."r" close-on-exec flag is set on the file descriptors used by the selector to prevent"r" leaking it to executed processes. However, on some systems such as"r" old Linux systems that don't support `epoll_create1` syscall it is done"r" non-atomically, so a separate thread executing in parallel to this"r" function may accidentally leak the file descriptor if it executes a"r" new process before this function returns."r" See [struct] level docs for more details."r" [struct]: struct.Poll.html"r" # use std::error::Error;"r" # fn main() -> Result<(), Box<dyn Error>> {"r" use mio::{Poll, Events};"r" let mut poll = match Poll::new() {"r"     Ok(poll) => poll,"r#"     Err(e) => panic!("failed to create Poll instance; err={:?}", e),"#r" // Create a structure to receive polled events"r" let mut events = Events::with_capacity(1024);"r" // Wait for events, but none will be received because no"r" // `event::Source`s have been registered with this `Poll` instance."r" poll.poll(&mut events, Some(Duration::from_millis(500)))?;"r" assert!(events.is_empty());"/// Create a separate `Registry` which can be used to register/// `event::Source`s./// Wait for readiness events/// Blocks the current thread and waits for readiness events for any of the/// [`event::Source`]s that have been registered with this `Poll` instance./// The function will block until either at least one readiness event has/// been received or `timeout` has elapsed. A `timeout` of `None` means that/// `poll` will block until a readiness event has been received./// The supplied `events` will be cleared and newly received readiness events/// will be pushed onto the end. At most `events.capacity()` events will be/// returned. If there are further pending readiness events, they will be/// returned on the next call to `poll`./// A single call to `poll` may result in multiple readiness events being/// returned for a single event source. For example, if a TCP socket becomes/// both readable and writable, it may be possible for a single readiness/// event to be returned with both [`readable`] and [`writable`] readiness/// **OR** two separate events may be returned, one with [`readable`] set/// and one with [`writable`] set./// Note that the `timeout` will be rounded up to the system clock/// granularity (usually 1ms), and kernel scheduling delays mean that/// the blocking interval may be overrun by a small amount./// See the [struct] level documentation for a higher level discussion of/// polling./// [`readable`]: struct.Interest.html#associatedconstant.READABLE/// [`writable`]: struct.Interest.html#associatedconstant.WRITABLE/// [struct]: struct.Poll.html/// [`iter`]: ./event/struct.Events.html#method.iter/// This returns any errors without attempting to retry, previous versions/// of Mio would automatically retry the poll call if it was interrupted/// (if `EINTR` was returned)./// Currently if the `timeout` elapses without any readiness events/// triggering this will return `Ok(())`. However we're not guaranteeing/// this behaviour as this depends on the OS./// use std::net::{TcpListener, SocketAddr};/// let server = TcpListener::bind(addr)?;/// let addr = server.local_addr()?.clone();/// // Spawn a thread to accept the socket///     let _ = server.accept();/// let mut stream = TcpStream::connect(addr)?;/// poll.registry().register(///     &mut stream,///     Token(0),///     Interest::READABLE | Interest::WRITABLE)?;/// [struct]: #/// Register an [`event::Source`] with the `Poll` instance./// Once registered, the `Poll` instance will monitor the event source for/// readiness state changes. When it notices a state change, it will return/// a readiness event for the handle the next time [`poll`] is called./// See [`Poll`] docs for a high level overview./// `source: &mut S: event::Source`: This is the source of events that the/// `Poll` instance should monitor for readiness state changes./// `token: Token`: The caller picks a token to associate with the socket./// When [`poll`] returns an event for the handle, this token is included./// This allows the caller to map the event to its source. The token/// associated with the `event::Source` can be changed at any time by/// calling [`reregister`]./// See documentation on [`Token`] for an example showing how to pick/// [`Token`] values./// `interest: Interest`: Specifies which operations `Poll` should monitor/// for readiness. `Poll` will only return readiness events for operations/// specified by this argument./// If a socket is registered with readable interest and the socket becomes/// writable, no event will be returned from [`poll`]./// The readiness interest for an `event::Source` can be changed at any time/// by calling [`reregister`]./// Callers must ensure that if a source being registered with a `Poll`/// instance was previously registered with that `Poll` instance, then a/// call to [`deregister`] has already occurred. Consecutive calls to/// `register` is unspecified behavior./// Unless otherwise specified, the caller should assume that once an event/// source is registered with a `Poll` instance, it is bound to that `Poll`/// instance for the lifetime of the event source. This remains true even/// if the event source is deregistered from the poll instance using/// [`deregister`]./// [`reregister`]: struct.Registry.html#method.reregister/// [`deregister`]: struct.Registry.html#method.deregister/// [`Token`]: struct.Token.html/// let mut socket = TcpStream::connect(listener.local_addr()?)?;/// // Register the socket with `poll`///     &mut socket,/// let timeout = Duration::from_millis(500);///     let elapsed = start.elapsed();///     if elapsed >= timeout {///         // Connection timed out///         return Ok(());///     let remaining = timeout - elapsed;///     poll.poll(&mut events, Some(remaining))?;///         if event.token() == Token(0) {///             // Something (probably) happened on the socket./// Re-register an [`event::Source`] with the `Poll` instance./// Re-registering an event source allows changing the details of the/// registration. Specifically, it allows updating the associated `token`/// and `interests` specified in previous `register` and `reregister` calls./// The `reregister` arguments fully override the previous values. In other/// words, if a socket is registered with [`readable`] interest and the call/// to `reregister` specifies [`writable`], then read interest is no longer/// requested for the handle./// The event source must have previously been registered with this instance/// of `Poll`, otherwise the behavior is unspecified./// See the [`register`] documentation for details about the function/// arguments and see the [`struct`] docs for a high level overview of/// // Register the socket with `poll`, requesting readable///     Interest::READABLE)?;/// // Reregister the socket specifying write interest instead. Even though/// // the token is the same it must be specified./// poll.registry().reregister(///     Interest::WRITABLE)?;/// [`struct`]: struct.Poll.html/// [`readable`]: ./event/struct.Event.html#is_readable/// [`writable`]: ./event/struct.Event.html#is_writable/// Deregister an [`event::Source`] with the `Poll` instance./// When an event source is deregistered, the `Poll` instance will no longer/// monitor it for readiness state changes. Deregistering clears up any/// internal resources needed to track the handle.  After an explicit call/// to this method completes, it is guaranteed that the token previously/// registered to this handle will not be returned by a future poll, so long/// as a happens-before relationship is established between this call and/// the poll./// A handle can be passed back to `register` after it has been/// deregistered; however, it must be passed back to the **same** `Poll`/// instance, otherwise the behavior is unspecified./// poll.registry().deregister(&mut socket)?;/// // Set a timeout because this poll should never receive any events./// poll.poll(&mut events, Some(Duration::from_secs(1)))?;/// Creates a new independently owned `Registry`./// Event sources registered with this `Registry` will be registered with/// the original `Registry` and `Poll` instance./// Get access to the `sys::Selector`.debug_detail//! Module with system specific types.//! Required types://! * `Event`: a type alias for the system specific event, e.g. `kevent` or//!            `epoll_event`.//! * `event`: a module with various helper functions for `Event`, see//!            [`crate::event::Event`] for the required functions.//! * `Events`: collection of `Event`s, see [`crate::Events`].//! * `IoSourceState`: state for the `IoSource` type.//! * `Selector`: selector used to register event sources and poll for events,//!               see [`crate::Poll`] and [`crate::Registry`] for required//!               methods.//! * `tcp` and `udp` modules: see the [`crate::net`] module.//! * `Waker`: see [`crate::Waker`].os_requireddebug_details/// Helper macro to execute a system call that returns an `io::Result`.// Macro must be defined before any modules that uses them.sourcefdstateless_io_sourcenew_ip_socketnew_socket/// Create a new non-blocking socket.SocketAddrCRepr/// A type with the same memory layout as `libc::sockaddr`. Used in converting Rust level/// SocketAddr* types into their system representation. The benefit of this specific/// type over using `libc::sockaddr_storage` is that this type is exactly as large as it/// needs to be and not a lot larger. And it can be initialized cleaner from Rust.socket_addr/// Converts a Rust `SocketAddr` into the system representation.to_socket_addr/// Converts a `libc::sockaddr` compatible struct into a native Rust `SocketAddr`./// `storage` must have the `ss_family` field correctly initialized./// `storage` must be initialised to a `sockaddr_in` or `sockaddr_in6`.r" Create a new non-blocking Unix pipe."r" This is a wrapper around Unix's [`pipe(2)`] system call and can be used as"r" inter-process or thread communication channel."r" This channel may be created before forking the process and then one end used"r" in each process, e.g. the parent process has the sending end to send command"r" to the child process."r" [`pipe(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.html"r" # Events"r" The [`Sender`] can be registered with [`WRITABLE`] interest to receive"r" [writable events], the [`Receiver`] with [`READABLE`] interest. Once data is"r" written to the `Sender` the `Receiver` will receive an [readable event]."r" In addition to those events, events will also be generated if the other side"r" is dropped. To check if the `Sender` is dropped you'll need to check"r" [`is_read_closed`] on events for the `Receiver`, if it returns true the"r" `Sender` is dropped. On the `Sender` end check [`is_write_closed`], if it"r" returns true the `Receiver` was dropped. Also see the second example below."r" [`WRITABLE`]: Interest::WRITABLE"r" [writable events]: event::Event::is_writable"r" [`READABLE`]: Interest::READABLE"r" [readable event]: event::Event::is_readable"r" [`is_read_closed`]: event::Event::is_read_closed"r" [`is_write_closed`]: event::Event::is_write_closed"r" # Deregistering"r" Both `Sender` and `Receiver` will deregister themselves when dropped,"r" **iff** the file descriptors are not duplicated (via [`dup(2)`])."r" [`dup(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html"r" Simple example that writes data into the sending end and read it from the"r" receiving end."r" use std::io::{self, Read, Write};"r" use mio::{Poll, Events, Interest, Token};"r" use mio::unix::pipe;"r" // Unique tokens for the two ends of the channel."r" const PIPE_RECV: Token = Token(0);"r" const PIPE_SEND: Token = Token(1);"r" # fn main() -> io::Result<()> {"r" // Create our `Poll` instance and the `Events` container."r" let mut poll = Poll::new()?;"r" let mut events = Events::with_capacity(8);"r" // Create a new pipe."r" let (mut sender, mut receiver) = pipe::new()?;"r" // Register both ends of the channel."r" poll.registry().register(&mut receiver, PIPE_RECV, Interest::READABLE)?;"r" poll.registry().register(&mut sender, PIPE_SEND, Interest::WRITABLE)?;"r#" const MSG: &[u8; 11] = b"Hello world";"#r"     poll.poll(&mut events, None)?;"r"     for event in events.iter() {"r"         match event.token() {"r"             PIPE_SEND => sender.write(MSG)"r"                 .and_then(|n| if n != MSG.len() {"r"                         // We'll consider a short write an error in this"r"                         // example. NOTE: we can't use `write_all` with"r"                         // non-blocking I/O."r"                         Err(io::ErrorKind::WriteZero.into())"r"                     } else {"r"                         Ok(())"r"                     })?,"r"             PIPE_RECV => {"r"                 let mut buf = [0; 11];"r"                 let n = receiver.read(&mut buf)?;"r#"                 println!("received: {:?}", &buf[0..n]);"#r"                 assert_eq!(n, MSG.len());"r"                 assert_eq!(&buf, &*MSG);"r"                 return Ok(());"r"             },"r"             _ => unreachable!(),"r"         }"r" Example that receives an event once the `Sender` is dropped."r" # use std::io;"r" # use mio::{Poll, Events, Interest, Token};"r" # use mio::unix::pipe;"r" # const PIPE_RECV: Token = Token(0);"r" # const PIPE_SEND: Token = Token(1);"r" // Same setup as in the example above."r" // Drop the sender."r" drop(sender);"r" poll.poll(&mut events, None)?;"r" for event in events.iter() {"r"     match event.token() {"r"         PIPE_RECV if event.is_read_closed() => {"r"             // Detected that the sender was dropped."r#"             println!("Sender dropped!");"#r"             return Ok(());"r"         },"r"         _ => unreachable!(),"r" # unreachable!();"r" Sending end of an Unix pipe."r" See [`new`] for documentation, including examples."r" Set the `Sender` into or out of non-blocking mode."r" Execute an I/O operation ensuring that the socket receives more events"r" if it hits a [`WouldBlock`] error."r" # Notes"r" This method is required to be called for **all** I/O operations to"r" ensure the user will receive events once the socket is ready again after"r" returning a [`WouldBlock`] error."r" [`WouldBlock`]: io::ErrorKind::WouldBlock"r" use std::io;"r" use std::os::unix::io::AsRawFd;"r" let (sender, receiver) = pipe::new()?;"r" // Wait until the sender is writable..."r" // Write to the sender using a direct libc call, of course the"r" // `io::Write` implementation would be easier to use."r#" let buf = b"hello";"#r" let n = sender.try_io(|| {"r"     let buf_ptr = &buf as *const _ as *const _;"r"     let res = unsafe { libc::write(sender.as_raw_fd(), buf_ptr, buf.len()) };"r"     if res != -1 {"r"         Ok(res as usize)"r"         // If EAGAIN or EWOULDBLOCK is set by libc::write, the closure"r"         // should return `WouldBlock` error."r"         Err(io::Error::last_os_error())"r" })?;"r#" eprintln!("write {} bytes", n);"#r" // Wait until the receiver is readable..."r" // Read from the receiver using a direct libc call, of course the"r" // `io::Read` implementation would be easier to use."r" let mut buf = [0; 512];"r" let n = receiver.try_io(|| {"r"     let buf_ptr = &mut buf as *mut _ as *mut _;"r"     let res = unsafe { libc::read(receiver.as_raw_fd(), buf_ptr, buf.len()) };"r"         // If EAGAIN or EWOULDBLOCK is set by libc::read, the closure"r#" eprintln!("read {} bytes", n);"#r" # Ok(())"r" The underlying pipe is **not** set to non-blocking."r" Receiving end of an Unix pipe."r" Set the `Receiver` into or out of non-blocking mode."// `cfg_os_ext!`.epinterests_to_epollNEXT_ID/// Unique id for use as `SelectorId`.// Type of the `nchanges` and `nevents` parameters in the `kevent` function.// Type of the `filter` field in the `kevent` structure.// Type of the `flags` field in the `kevent` structure.UData// Type of the `udata` field in the `kevent` structure.kqsetup_waker// Used by `Waker`.kevent_register/// Register `changes` with `kq`ueue./// Check all events for possible errors, it returns the first error found.// `Events` cannot derive `Send` or `Sync` because of the// `udata: *mut ::c_void` field in `libc::kevent`. However, `Events`'s public// API treats the `udata` field as a `uintptr_t` which is `Send`. `Sync` is// safe because with a `events: &Events` value, the only access to the `udata`// field is through `fn token(event: &Event)` which cannot mutate the field.// `event` is not used on some platforms.// `event` is only used on FreeBSD.does_not_register_rwLOWEST_FD/// Lowest file descriptor used in `Selector::try_clone`./// Usually fds 0, 1 and 2 are standard in, out and error. Some application/// blindly assume this to be true, which means using any one of those a select/// could result in some interesting and unexpected errors. Avoid that by using/// an fd that doesn't have a pre-determined usage.WakerInternalSelectorStateregister_internalRegistrationRecordFds/// File descriptors to poll.pending_removal/// File descriptors which will be removed before the next poll call./// When a file descriptor is deregistered while a poll is running, we need to filter/// out all removed descriptors after that poll is finished running.pending_wake_token/// Token associated with Waker that have recently asked to wake.  This will/// cause a synthetic behaviour where on any wakeup we add all pending tokens/// to the list of emitted events.notify_waker/// Data is written to this to wake up the current instance of `wait`, which can occur when the/// user notifies it (in which case `notified` would have been set) or when an operation needs/// to occur (in which case `waiting_operations` would have been incremented).waiting_operations/// The number of operations (`add`, `modify` or `delete`) that are currently waiting on the/// mutex to become free. When this is nonzero, `wait` must be suspended until it reaches zerooperations_complete/// The condition variable that gets notified when `waiting_operations` reaches zero or/// `notified` becomes true./// This is used with the `fds` mutex./// This selectors id./// Interface to poll.PollFd/// The list of `pollfds` taken by poll./// The first file descriptor is always present and is used to notify the poller.fd_dataFdData/// The map of each file descriptor to data associated with it. This does not include the file/// descriptors created by the internal notify waker./// The file descriptors to poll in a `Poller`./// Transparent wrapper around `libc::pollfd`, used to support `Debug` derives without adding the/// `extra_traits` feature of `libc`.poll_fds_index/// The index into `poll_fds` this file descriptor is./// The key of the `Event` associated with this file descriptor.shared_record/// Used to communicate with IoSourceState when we need to internally deregister/// based on a closed fd./// Data associated with a file descriptor in a poller.modify_fds/// Perform a modification on `fds`, interrupting the current caller of `wait` if it's running.deregister_all/// Special optimized version of [Self::deregister] which handles multiple removals/// at once.  Ok result if all removals were performed, Err if any entries/// were not found.is_unregistered/// Shared record between IoSourceState and SelectorState that allows us to internally/// deregister partially or fully closed fds (i.e. when we get POLLHUP or PULLERR) without/// confusing IoSourceState and trying to deregister twice.  This isn't strictly/// required as technically deregister is idempotent but it is confusing/// when trying to debug behaviour as we get imbalanced calls to register/deregister and/// superfluous NotFound errors.mark_unregisteredREAD_EVENTSWRITE_EVENTSPRIORITY_EVENTSinterests_to_poll/// Get the input poll events for the given event./// Helper function to call poll.// This implementation is based on the one in the `polling` crate.// Thanks to https://github.com/Kestrer for the original implementation!// Permission to use this code has been granted by original author:// https://github.com/tokio-rs/mio/pull/1602#issuecomment-1218441031/// Adapter for [`RawFd`] providing an [`event::Source`] implementation./// `SourceFd` enables registering any type with an FD with [`Poll`]./// While only implementations for TCP and UDP are provided, Mio supports/// registering any FD that can be registered with the underlying OS selector./// `SourceFd` provides the necessary bridge./// Note that `SourceFd` takes a `&RawFd`. This is because `SourceFd` **does/// not** take ownership of the FD. Specifically, it will not manage any/// lifecycle related operations, such as closing the FD on drop. It is expected/// that the `SourceFd` is constructed right before a call to/// [`Registry::register`]. See the examples for more detail./// [`event::Source`]: ../event/trait.Source.html/// use mio::{Interest, Poll, Token};/// use mio::unix::SourceFd;/// // Bind a std listener/// let listener = TcpListener::bind("127.0.0.1:0")?;/// // Register the listener///     &mut SourceFd(&listener.as_raw_fd()),/// Implementing [`event::Source`] for a custom type backed by a [`RawFd`]./// use mio::{event, Interest, Registry, Token};/// use std::os::unix::io::RawFd;/// pub struct MyIo {///     fd: RawFd,/// impl event::Source for MyIo {///         SourceFd(&self.fd).register(registry, token, interests)///         SourceFd(&self.fd).reregister(registry, token, interests)///         SourceFd(&self.fd).deregister(registry)socketaddrpath_offset/// Get the `sun_path` field offset of `sockaddr_un` for the target OS./// On Linux, this function equates to the same value as/// `size_of::<sa_family_t>()`, but some other implementations include/// other fields before `sun_path`, so the expression more portably/// describes the size of the address structure.socklen/// An address associated with a `mio` specific Unix socket./// This is implemented instead of imported from [`net::SocketAddr`] because/// there is no way to create a [`net::SocketAddr`]. One must be returned by/// [`accept`], so this is returned instead./// [`net::SocketAddr`]: std::os::unix::net::SocketAddr/// [`accept`]: #method.acceptAsciiEscapedAddressKindUnnamedPathnamefdbased/// Waker backed by `eventfd`./// `eventfd` is effectively an 64 bit counter. All writes must be of 8/// bytes (64 bits) and are converted (native endian) into an 64 bit/// unsigned integer and added to the count. Reads must also be 8 bytes and/// reset the count to 0, returning the count./// Reset the eventfd object, only need to call this if `wake` fails.subscriptionsSubscription/// Subscriptions (reads events) we're interested in.TIMEOUT_TOKENUserdata/// Token used to a add a timeout subscription, also used in removing it again.timeout_subscription/// Returns a `wasi::Subscription` for `timeout`.is_timeout_event/// Convert `wasi::Errno` into an `io::Error`.//! The current implementation is somewhat limited. The `Waker` is not//! implemented, as at the time of writing there is no way to support to wake-up//! a thread from calling `poll_oneoff`.//! Furthermore the (re/de)register functions also don't work while concurrently//! polling as both registering and polling requires a lock on the//! `subscriptions`.//! Finally `Selector::try_clone`, required by `Registry::try_clone`, doesn't//! work. However this could be implemented by use of an `Arc`.//! In summary, this only (barely) works using a single thread.RtlNtStatusToDosErrorNTSTATUSSTATUS_NOT_FOUNDSTATUS_PENDINGNtDeviceIoControlFileIO_STATUS_BLOCKIO_STATUS_BLOCK_0IOCTL_AFD_POLLNtCancelIoFileEx/// See <https://processhacker.sourceforge.io/doc/ntioapi_8h.html#a0d4d550cad4d62d75b76961e25f6550c>/// This is an undocumented API and as such not part of <https://github.com/microsoft/win32metadata>/// from which `windows-sys` is generated, and also unlikely to be added, so/// we manually declare it hereAfd/// Winsock2 AFD driver instance./// All operations are unsafe due to IO_STATUS_BLOCK parameter are being used by Afd driver during STATUS_PENDING before I/O Completion Port returns its result.AfdPollHandleInfonumber_of_handles// Can have only value 1.AfdPollInfo/// Poll `Afd` instance with `AfdPollInfo`./// # Unsafety/// This function is unsafe due to memory of `IO_STATUS_BLOCK` still being used by `Afd` instance while `Ok(false)` (`STATUS_PENDING`)./// `iosb` needs to be untouched after the call while operation is in effective at ALL TIME except for `cancel` method./// So be careful not to `poll` twice while polling./// User should deallocate there overlapped value when error to prevent memory leak./// Cancel previous polled request of `Afd`./// iosb needs to be used by `poll` first for valid `cancel`./// Use it only with request is still being polled so that you have valid `IO_STATUS_BLOCK` to use./// User should NOT deallocate there overlapped value after the `cancel` to prevent double free.POLL_RECEIVEPOLL_RECEIVE_EXPEDITEDPOLL_SENDPOLL_DISCONNECTPOLL_ABORTPOLL_LOCAL_CLOSEPOLL_CONNECT// Not used as it indicated in each event where a connection is connected, not// just the first time a connection is established.// Also see https://github.com/piscisaureus/wepoll/commit/8b7b340610f88af3d83f40fb728e7b850b090ece.POLL_ACCEPTPOLL_CONNECT_FAILKNOWN_EVENTSCompletionStatusset_readableset_writablefrom_completion_statusto_completion_statusto_completion_status_with_overlappedOverlappedREADABLE_FLAGSWRITABLE_FLAGSERROR_FLAGSREAD_CLOSED_FLAGSWRITE_CLOSED_FLAGS/// Raw I/O event completions are filled in here by the call to `get_many`/// on the completion port above. These are then processed to run callbacks/// which figure out what to do after the event is done./// Literal events returned by `get` to the upwards `EventLoop`. This file/// doesn't really modify this (except for the waker), instead almost all/// events are filled in by the `ReadinessQueue` from the `poll` module./// Wrapper around a Windows HANDLE so that we close it upon drop in all scenariosIoStatusBlockCreateIoCompletionPortGetQueuedCompletionStatusExPostQueuedCompletionStatusOVERLAPPEDOVERLAPPED_ENTRYCompletionPort/// A handle to an Windows I/O Completion Port./// A status message received from an I/O completion port./// These statuses can be created via the `new` or `empty` constructors and then/// provided to a completion port, or they are read out of a completion port./// The fields of each status are read through its accessor methods./// Creates a new I/O completion port with the specified concurrency value./// The number of threads given corresponds to the level of concurrency/// allowed for threads associated with this port. Consult the Windows/// documentation for more information about this value.add_handle/// Associates a new `HANDLE` to this I/O completion port./// This function will associate the given handle to this port with the/// given `token` to be returned in status messages whenever it receives a/// notification./// Any object which is convertible to a `HANDLE` via the `AsRawHandle`/// trait can be provided to this function, such as `std::fs::File` and/// friends./// Dequeues a number of completion statuses from this I/O completion port./// This function is the same as `get` except that it may return more than/// one status. A buffer of "zero" statuses is provided (the contents are/// not read) and then on success this function will return a sub-slice of/// statuses which represent those which were dequeued from this port. This/// function does not wait to fill up the entire list of statuses provided./// Like with `get`, a timeout may be specified for this operation./// Posts a new completion status onto this I/O completion port./// This function will post the given status, with custom parameters, to the/// port. Threads blocked in `get` or `get_many` will eventually receive/// this status./// Creates a new completion status with the provided parameters./// This function is useful when creating a status to send to a port with/// the `post` method. The parameters are opaquely passed through and not/// interpreted by the system at all./// Creates a new borrowed completion status from the borrowed/// `OVERLAPPED_ENTRY` argument provided./// This method will wrap the `OVERLAPPED_ENTRY` in a `CompletionStatus`,/// returning the wrapped structure./// Creates a new "zero" completion status./// This function is useful when creating a stack buffer or vector of/// completion statuses to be passed to the `get_many` function.bytes_transferred/// Returns the number of bytes that were transferred for the I/O operation/// associated with this completion status./// Returns the completion key value associated with the file handle whose/// I/O operation has completed./// A completion key is a per-handle key that is specified when it is added/// to an I/O completion port via `add_handle` or `add_socket`.overlapped/// Returns a pointer to the `Overlapped` structure that was specified when/// the I/O operation was started./// Returns a pointer to the internal `OVERLAPPED_ENTRY` object.duration_millisis_send_sync//! Bindings to IOCP, I/O Completion Portsio_status_block// Macros must be defined before the modules that use themERROR_BROKEN_PIPEERROR_IO_PENDINGERROR_NO_DATAERROR_PIPE_CONNECTEDERROR_PIPE_LISTENINGReadFileWriteFileFILE_FLAG_FIRST_PIPE_INSTANCEFILE_FLAG_OVERLAPPEDPIPE_ACCESS_DUPLEXPipesConnectNamedPipeCreateNamedPipeWDisconnectNamedPipePIPE_TYPE_BYTEPIPE_UNLIMITED_INSTANCESCancelIoExGetOverlappedResult/// Non-blocking windows named pipe./// This structure internally contains a `HANDLE` which represents the named/// pipe, and also maintains state associated with the mio event loop and active/// I/O operations that have been scheduled to translate IOCP to a readiness/// model./// Note, IOCP is a *completion* based model whereas mio is a *readiness* based/// model. To bridge this, `NamedPipe` performs internal buffering. Writes are/// written to an internal buffer and the buffer is submitted to IOCP. IOCP/// reads are submitted using internal buffers and `NamedPipe::read` reads from/// this internal buffer./// # Trait implementations/// The `Read` and `Write` traits are implemented for `NamedPipe` and for/// `&NamedPipe`. This represents that a named pipe can be concurrently read and/// written to and also can be read and written to at all. Typically a named/// pipe needs to be connected to a client before it can be read or written,/// Note that for I/O operations on a named pipe to succeed then the named pipe/// needs to be associated with an event loop. Until this happens all I/O/// operations will return a "would block" error./// # Managing connections/// The `NamedPipe` type supports a `connect` method to connect to a client and/// a `disconnect` method to disconnect from that client. These two methods only/// work once a named pipe is associated with an event loop./// The `connect` method will succeed asynchronously and a completion can be/// detected once the object receives a writable notification./// # Named pipe clients/// Currently to create a client of a named pipe server then you can use the/// `OpenOptions` type in the standard library to create a `File` that connects/// to a named pipe. Afterwards you can use the `into_raw_handle` method coupled/// with the `NamedPipe::from_raw_handle` method to convert that to a named pipe/// that can operate asynchronously. Don't forget to pass the/// `FILE_FLAG_OVERLAPPED` flag when opening the `File`.// NOTE: careful modifying the order of these three fields, the `ptr_from_*`// methods depend on the layout!// END NOTE./// The memory layout of this structure must be fixed as the/// `ptr_from_*_overlapped` methods depend on it, see the `ptr_from` test.ptr_from_conn_overlapped/// Converts a pointer to `Inner.connect` to a pointer to `Inner`./// Caller must ensure `ptr` is pointing to `Inner.connect`.ptr_from_read_overlapped/// Same as [`ptr_from_conn_overlapped`] but for `Inner.read`.ptr_from_write_overlapped/// Same as [`ptr_from_conn_overlapped`] but for `Inner.write`.ptr_from_event_overlapped/// Same as [`ptr_from_conn_overlapped`] but for `Inner.event`.connect_overlapped/// Issue a connection request with the specified overlapped operation./// This function will issue a request to connect a client to this server,/// returning immediately after starting the overlapped operation./// If this function immediately succeeds then `Ok(true)` is returned. If/// the overlapped operation is enqueued and pending, then `Ok(false)` is/// returned. Otherwise an error is returned indicating what went wrong./// This function is unsafe because the kernel requires that the/// `overlapped` pointer is valid until the end of the I/O operation. The/// kernel also requires that `overlapped` is unique for this I/O operation/// and is not in use for any other I/O./// To safely use this function callers must ensure that this pointer is/// valid until the I/O operation is completed, typically via completion/// ports and waiting to receive the completion notification on the port./// Disconnects this named pipe from any connected client.read_overlapped/// Issues an overlapped read operation to occur on this pipe./// This function will issue an asynchronous read to occur in an overlapped/// fashion, returning immediately. The `buf` provided will be filled in/// with data and the request is tracked by the `overlapped` function/// If the operation succeeds immediately, `Ok(Some(n))` is returned where/// `n` is the number of bytes read. If an asynchronous operation is/// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred/// it is returned./// When this operation completes (or if it completes immediately), another/// mechanism must be used to learn how many bytes were transferred (such as/// looking at the filed in the IOCP status message)./// This function is unsafe because the kernel requires that the `buf` and/// `overlapped` pointers to be valid until the end of the I/O operation./// The kernel also requires that `overlapped` is unique for this I/O/// operation and is not in use for any other I/O./// To safely use this function callers must ensure that the pointers arewrite_overlapped/// Issues an overlapped write operation to occur on this pipe./// This function will issue an asynchronous write to occur in an overlapped/// `n` is the number of bytes written. If an asynchronous operation is/// Calls the `GetOverlappedResult` function to get the result of an/// overlapped operation for this handle./// This function takes the `OVERLAPPED` argument which must have been used/// to initiate an overlapped I/O operation, and returns either the/// successful number of bytes transferred during the operation or an error/// if one occurred./// This function is unsafe as `overlapped` must have previously been used/// to execute an operation for this handle, and it must also be a valid/// pointer to an `Overlapped` instance.ptr_fromcp// Uniquely identifies the selector associated with this named pipe// Token used to identify eventsNEXT_TOKEN// Odd tokens are for named pipes/// Creates a new named pipe at the specified `addr` given a "reasonable/// set" of initial configuration options./// Attempts to call `ConnectNamedPipe`, if possible./// This function will attempt to connect this pipe to a client in an/// asynchronous fashion. If the function immediately establishes a/// connection to a client then `Ok(())` is returned. Otherwise if a/// connection attempt was issued and is now in progress then a "would/// block" error is returned./// When the connection is finished then this object will be flagged as/// being ready for a write, or otherwise in the writable state./// This function will return a "would block" error if the pipe has not yet/// been registered with an event loop, if the connection operation has/// previously been issued but has not yet completed, or if the connect/// itself was issued and didn't finish immediately./// Normal I/O errors from the call to `ConnectNamedPipe` are returned/// Takes any internal error that has happened after the last I/O operation/// which hasn't been retrieved yet./// This is particularly useful when detecting failed attempts to `connect`./// After a completed `connect` flags this pipe as writable then callers/// must invoke this method to determine whether the connection actually/// succeeded. If this function returns `None` then a client is connected,/// otherwise it returns an error of what happened and a client shouldn't be/// connected./// Disconnects this named pipe from a connected client./// This function will disconnect the pipe from a connected client, if any,/// transitively calling the `DisconnectNamedPipe` function./// After a `disconnect` is issued, then a `connect` may be called again to/// connect to another client.schedule_read/// Schedules a read to happen in the background, executing an overlapped/// This function returns `true` if a normal error happens or if the read/// is scheduled in the background. If the pipe is no longer connected/// (ERROR_PIPE_LISTENING) then `false` is returned and no read is/// scheduled.maybe_schedule_write/// Maybe schedules overlapped write operation./// * `None` means that overlapped operation was enqueued/// * `Some(n)` means that `n` bytes was immediately written.///   Note, that `write_done` will fire anyway to clean up the state.schedule_writepost_registerput_bufferread_donewrite_doneevent_donecheck_associationnotify_readablenotify_writableschedule_eventIN6_ADDRIN6_ADDR_0IN_ADDR_0SOCKADDRSOCKADDR_IN6_0/// Initialise the network stack for Windows./// A type with the same memory layout as `SOCKADDR`. Used in converting Rust level/// type over using `SOCKADDR_STORAGE` is that this type is exactly as large as itERROR_INVALID_HANDLESTATUS_CANCELLEDafd_groupAfdGrouprelease_unused_afdSockPollStatusiosbpoll_infobase_socketuser_evtspending_evtspoll_statusdelete_pending// last raw os error_pinnedSockStatefeed_event// This is the function called from the overlapped using as Arc<Mutex<SockState>>. Watch out for reference counting.is_pending_deletionmark_deleteinto_overlapped/// Converts the pointer to a `SockState` into a raw pointer./// To revert see `from_overlapped`.from_overlapped/// Convert a raw overlapped pointer into a reference to `SockState`./// Reverts `into_overlapped`./// Each Selector has a globally unique(ish) ID associated with it. This ID/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first/// registered with the `Selector`. If a type that is previously associated with/// a `Selector` attempts to register itself with a different `Selector`, the/// operation will return with an error. This matches windows behavior.SelectorInner/// Windows implementation of `sys::Selector`/// Edge-triggered event notification is simulated by resetting internal event flag of each socket state `SockState`/// and setting all events back by intercepting all requests that could cause `io::ErrorKind::WouldBlock` happening./// This selector is currently only support socket due to `Afd` driver is winsock2 specific./// This requires a mutable reference to self because only a single thread/// can poll IOCP at a time.clone_portsame_portupdate_queueis_polling// We have ensured thread safety by introducing lock manually./// May only be calling via `Selector::select`.update_sockets_eventsfeed_events// It returns processed count of iocp_events rather than the events itself.StdSocketwin_bind// windows-sys uses usize, stdlib uses u32/u64./// Associates readiness events with [`event::Source`]s./// `Token` is a wrapper around `usize` and is used as an argument to/// [`Registry::register`] and [`Registry::reregister`]./// [`Registry::register`]: struct.Registry.html#method.register/// [`Registry::reregister`]: struct.Registry.html#method.reregister/// Using `Token` to track which socket generated the event. In this example,/// `HashMap` is used, but usually something like [`slab`] is better./// [`slab`]: https://crates.io/crates/slab/// use std::io::{self, Read};/// // After this number of sockets is accepted, the server will shutdown./// const MAX_SOCKETS: usize = 32;/// // Pick a token that will not be used by any other socket and use that one/// // for the listener./// const LISTENER: Token = Token(1024);/// // Used to store the sockets./// let mut sockets = HashMap::new();/// // This is used to generate a unique token for a socket/// let mut next_socket_index = 0;/// // The `Poll` instance/// // Tcp listener/// let mut listener = TcpListener::bind("127.0.0.1:0".parse()?)?;/// poll.registry().register(&mut listener, LISTENER, Interest::READABLE)?;/// // Spawn a thread that will connect a bunch of sockets then close them/// let addr = listener.local_addr()?;///     use std::net::TcpStream;///     // +1 here is to connect an extra socket to signal the socket to close///     for _ in 0..(MAX_SOCKETS+1) {///         // Connect then drop the socket///         let _ = TcpStream::connect(addr).unwrap();/// // Event storage/// // Read buffer, this will never actually get filled/// let mut buf = [0; 256];/// // The main event loop///     // Wait for events///             LISTENER => {///                 // Perform operations in a loop until `WouldBlock` is///                 // encountered.///                 loop {///                     match listener.accept() {///                         Ok((mut socket, _)) => {///                             // Shutdown the server///                             if next_socket_index == MAX_SOCKETS {///                                 return Ok(());///                             }///                             // Get the token for the socket///                             let token = Token(next_socket_index);///                             next_socket_index += 1;///                             // Register the new socket w/ poll///                             poll.registry().register(&mut socket, token, Interest::READABLE)?;///                             // Store the socket///                             sockets.insert(token, socket);///                         }///                         Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {///                             // Socket is not ready anymore, stop accepting///                             break;///                         e => panic!("err={:?}", e), // Unexpected error///                     }///             token => {///                 // Always operate in a loop///                     match sockets.get_mut(&token).unwrap().read(&mut buf) {///                         Ok(0) => {///                             // Socket is closed, remove it from the map///                             sockets.remove(&token);///                         // Data is not actually sent in this example///                         Ok(_) => unreachable!(),///                             // Socket is not ready anymore, stop reading/// Waker allows cross-thread waking of [`Poll`]./// When created it will cause events with [`readable`] readiness and the/// provided `token` if [`wake`] is called, possibly from another thread./// [`wake`]: struct.Waker.html#method.wake/// `Waker` events are only guaranteed to be delivered while the `Waker` value/// is alive./// Only a single `Waker` can be active per [`Poll`], if multiple threads need/// access to the `Waker` it can be shared via for example an `Arc`. What/// happens if multiple `Waker`s are registered with the same `Poll` is/// On platforms that support kqueue this will use the `EVFILT_USER` event/// filter, see [implementation notes of `Poll`] to see what platforms support/// kqueue. On Linux it uses [eventfd]./// [implementation notes of `Poll`]: struct.Poll.html#implementation-notes/// [eventfd]: https://man7.org/linux/man-pages/man2/eventfd.2.html/// Wake a [`Poll`] instance from another thread./// use mio::{Events, Token, Poll, Waker};/// const WAKE_TOKEN: Token = Token(10);/// let mut events = Events::with_capacity(2);/// let waker = Arc::new(Waker::new(poll.registry(), WAKE_TOKEN)?);/// // We need to keep the Waker alive, so we'll create a clone for the/// // thread we create below./// let waker1 = waker.clone();/// let handle = thread::spawn(move || {///     // Working hard, or hardly working?///     // Now we'll wake the queue on the other thread.///     waker1.wake().expect("unable to wake");/// // On our current thread we'll poll for events, without a timeout./// poll.poll(&mut events, None)?;/// // After about 500 milliseconds we should be awoken by the other thread and/// // get a single event./// assert!(!events.is_empty());/// let waker_event = events.iter().next().unwrap();/// assert!(waker_event.is_readable());/// assert_eq!(waker_event.token(), WAKE_TOKEN);/// # handle.join().unwrap();/// Create a new `Waker`./// Wake up the [`Poll`] associated with this `Waker`./// Out-of-band (OOB) data also triggers readable events. But most/// applications don't actually read OOB data, this could leave an/// [`RawFd`]: std::os::fd::RawFd///  4. Check `TcpStream::take_error`. If it returns an error, then///     something went wrong. If it returns `Ok(None)`, then proceed to///     step 5.///  5. Check `TcpStream::peer_addr`. If it returns `libc::EINPROGRESS` or///     connected, go to step 6. If another error is returned something///  6. Now the stream can be used./// #[cfg(any(unix, target_os = "wasi"))]/// use std::os::fd::AsRawFd;/// Creates a new `UnixDatagram` bound to the specified socket `address`.r" use std::os::fd::AsRawFd;"// No special requirement from the implementation around waking.// TODO: once <https://github.com/rust-lang/rust/issues/126198> is fixed this// can use `std::os::fd` and be merged with the above.//! Both `kqueue(2)` and `epoll(2)` don't need to hold any user space state./// use std::os::fd::RawFd;unix_addrSocketAddrExtUNNAMED_ADDRESSpathname_addressabstract_address// Not used by the `poll(2)` implementation.new_unregistered// Don't care about partial writes.ack_and_reset// Only used by the `poll(2)` implementation.// Don't care about partial reads./// Waker backed by kqueue user space notifications (`EVFILT_USER`)./// The implementation is fairly simple, first the kqueue must be setup to/// receive waker events this done by calling `Selector.setup_waker`. Next/// we need access to kqueue, thus we need to duplicate the file descriptor./// Now waking is as simple as adding an event to the kqueue./// Waker backed by a unix pipe./// Waker controls both the sending and receiving ends and empties the pipe/// if writing to it (waking) fails./// Empty the pipe's buffer, only need to call this if `wake` fails./// This ignores any errors.J_COLOR_SPACEnum_components/// Number of channels (including unused alpha) in this color spaceColorSpaceExtjpeg_component_infoDCTSIZEqtableQTable/// Number of pixels per row, including padding to MCUcol_stride/// Total height, including padding to MCU/// h,v samplinig (1..4). Number of pixels per sample (may be opposite of what you expect!)// Quantization table, if availablewidth_in_blocks// Number of blocks per rowheight_in_blocks// Number of block rowsCompInfoExterrormgrunwinding_error_mgrErrorMgrjpeg_compress_structJDIMENSIONJPEG_LIB_VERSIONJ_BOOLEAN_PARAMJ_INT_PARAMwritedstDestinationMgrMAX_MCU_HEIGHT/// Max sampling factor is 2/// Codec doesn't allow more channels than thiscinfoown_err/// It's `Box<ErrorMgr>`, but `cinfo` references `own_err`,/// so I need talismans to ward off nasal demons haunting self-referential structs_it_is_self_referential/// Create a new JPEG file from pixels/// Wrapper for `jpeg_compress_struct`ScanModeAllComponentsTogetherScanPerComponent/// Can flash grayscale or green-tinted imagesdest_mgr/// Safety: sensitive to drop order. Needs to be dropped after `Compress`CompressStarted/// Compress image using input in this colorspace./// You need to wrap all use of this library in `std::panic::catch_unwind()`/// By default errors cause unwind (panic) and unwind through the C code,/// which strictly speaking is not guaranteed to work in Rust (but seems to work fine, at least on x86-64 and ARM)./// Use a specific error handler instead of the default unwinding one./// Note that the error handler must either abort the process or unwind,/// it can't gracefully return due to the design of libjpeg./// `color_space` refers to input color spaceset_mem_deststart_compress/// Settings can't be changed after this call. Returns a `CompressStarted` struct that will handle the rest of the writing./// It may panic, like all functions of this library./// Add a marker to compressed file/// Data is max 64KBwrite_icc_profile/// Add ICC profile to compressed file/// Read-only view of component informationcan_write_more_linescomponents_mut/// Expose components for modification, e.g. to set chroma subsamplingwrite_scanlines/// Returns Ok(()) if all lines in `image_src` (not necessarily all lines of the image) were writtenwrite_raw_data/// Advanced. Only possible after `set_raw_data_in()`./// Write YCbCr blocks pixels instead of usual color space/// See `raw_data_in` in libjpeg docs/// ## Panic/// Panics if raw write wasn't enabledset_color_space/// Set color space of JPEG being written, different from input color space/// See `jpeg_set_colorspace` in libjpeg docs/// Image size of the input/// libjpeg's `input_gamma` = image gamma of input image/// Sets pixel density of an image in the JFIF APP0 segment[^note]./// If this method is not called, the resulting JPEG will have a default/// pixel aspect ratio of 1x1./// [^note]: This method is not related to EXIF-based intrinsic image sizing,/// and does not affect rendering in browsers.set_optimize_scans/// If true, it will use MozJPEG's scan optimization. Makes progressive image files smaller.set_smoothing_factor/// If 1-100 (non-zero), it will use MozJPEG's smoothing.set_optimize_coding/// Set to `false` to make files larger for no reasonset_use_scans_in_trellis/// Specifies whether multiple scans should be considered during trellis/// quantization.set_progressive_mode/// You can only turn it onset_scan_optimization_mode/// One scan for all components looks best. Other options may flash grayscale or green images.set_fastest_defaults/// Reset to libjpeg v6 settings/// It gives files identical with libjpeg-turboset_raw_data_in/// Advanced. See `raw_data_in` in libjpeg docs./// Set image quality. Values 60-80 are recommended.set_luma_qtable/// Instead of quality setting, use a specific quantization table.set_chroma_qtable/// Instead of quality setting, use a specific quantization table for color.set_chroma_sampling_pixel_sizes/// Sets chroma subsampling, separately for Cb and Cr channels./// Instead of setting samples per pixel, like in `cinfo`'s `x_samp_factor`,/// it sets size of chroma "pixels" per luma pixel./// * `(1,1), (1,1)` == 4:4:4/// * `(2,1), (2,1)` == 4:2:2/// * `(2,2), (2,2)` == 4:2:0/// Finalize compression./// In case of progressive files, this may actually start processing.finish_compress/// Give up writing, return incomplete resultwrite_memconvert_colorspacejpeg_decompress_structreadsrcSourceMgrNO_MARKERS/// Empty list of markers/// By default markers are not read from JPEG files.ALL_MARKERS/// App 0-14 and comment markers/// # use mozjpeg::*;/// Decompress::with_markers(ALL_MARKERS);DctMethodIntegerSlow/// slow but accurate integer algorithmIntegerFast/// faster, less accurate integer method/// floating-point method/// Algorithm for the DCT step.save_markers'markerserr_mgrDecompressBuilder/// Use `Decompress` static methods instead of creating this directlyDecompressConfigwith_errwith_markers/// Reads from an already-open `File`./// Use `from_reader` if you want to customize buffer size.from_mem/// Reads from a `Vec` or a slice./// Takes `BufReader`. If you have `io::Read`, wrap it in `io::BufReader::new(read)`.src_mgr/// Get pixels out of a JPEG file/// High-level wrapper for `jpeg_decompress_struct`/// # fn t() -> std::io::Result<()> {/// let d = Decompress::new_path("image.jpg")?;MarkerData/// Marker type and data slice returned by `MarkerIter`marker_listjpeg_marker_struct_referencesMarkerIter/// See `Decompress.markers()`/// Short for builder().with_err()/// Short for builder().with_markers()/// Use builder()/// This is `DecompressBuilder::new()`/// Decode file at path/// Decode an already-opened filenew_mem'mem/// Decode from a JPEG file already in memorynew_reader/// Decode from an `io::BufRead`, which is `BufReader` wrapping any `io::Read`.from_builder_and_reader/// Result here is mostly useless, because it will panic if the file is invalidcolor_spacegamma/// It's generally bogus in libjpeg/// Get pixel density of an image from the JFIF APP0 segment./// Returns None in case of an invalid density unit.markers/// Markers are available only if you enable them via `with_markers()`save_marker/// width,heightDecompressStarted/// Start decompression with conversion to RGBto_colorspace/// Start decompression with conversion to `colorspace`/// Start decompression with conversion to RGBA/// Start decompression with conversion to grayscale.dct_method/// Selects the algorithm used for the DCT step.do_fancy_upsampling// If `true`, do careful upsampling of chroma components.  If `false`,// a faster but sloppier method is used.  Default is `true`.  The visual// impact of the sloppier method is often very small.do_block_smoothing/// If `true`, interblock smoothing is applied in early stages of decoding/// progressive JPEG files; if `false`, not.  Default is `true`.  Early/// progression stages look "fuzzy" with smoothing, "blocky" without./// In any case, block smoothing ceases to be applied after the first few/// AC coefficients are known to full accuracy, so it is relevant only/// when using buffered-image mode for progressive images.out_color_space/// Start decompression without colorspace conversion/// Rescales the output image by `numerator / 8` during decompression./// `numerator` must be between 1 and 16./// Thus setting a value of `8` will result in an unscaled image./// See `Decompress.image()`/// See methods on `Decompress`start_decompressmin_flat_buffer_size/// Gets the minimal buffer size for using `DecompressStarted::read_scanlines_flat_into`can_read_more_scanlinesread_raw_dataJSAMPLE/// Append dataread_raw_data_chunkread_scanlines/// Supports any pixel type that is marked as "plain old data", see bytemuck crate./// Pixels can either have number of bytes matching number of channels, e.g. RGB as/// `[u8; 3]` or `rgb::RGB8`, or be an amorphous blob of `u8`s.'destread_scanlines_into/// `[u8; 3]` and `rgb::RGB8` are fine, for example. `[u8]` is allowed for any pixel type./// Allocation-less version of `read_scanlines`read_scanlines_into_uninit/// Returns written-to sliceread_scanlines_flatread_scanlines_flat_intofinish_decompressfinish_into_inner/// Finish decompress and return the readerfinish_internalio_suspend_errread_incomplete_filemem_no_trailerfile_no_trailermem_trailerfile_trailerfile_trailer_bytes_leftno_markersbuffer_into_innerread_file_rgbdrops_reader//! See the `Decompress` struct instead. You don't need to use this module directly./// No units/// Pixels per inchjpeg_common_structjpeg_error_mgrformatted_messagepush_str_in_cap"C-unwind"silence_messageunwind_error_exit/// Quantization table presets from MozJPEGrecompress/// Marker number identifier (APP0-APP14 and comment markers)/// For actual contents of markers, see `MarkerData`Coefcoeffslow_weightsscaledquality_scaling// Similar to libjpeg, but result is 100x smallerAnnexK_LumaAnnexK_ChromaFlatMSSSIM_LumaMSSSIM_ChromaNRobidouxPSNRHVS_LumaPSNRHVS_ChromaKleinSilversteinCarneyWatsonTaylorBorthwickAhumadaWatsonPetersonPetersonAhumadaWatsonALL_TABLESscalingJERR_BAD_LENGTHjpeg_resync_to_restartjpeg_source_mgrJERR_FILE_READJERR_VIRTUAL_BUGJPOOL_IMAGEJPOOL_PERMANENTJWRN_JPEG_EOFinner_sharedSourceMgrInner/// The `jpeg_source_mgr` has requirements that are tricky for Rust:/// * it must have a stable address,/// * it is mutated via `cinfo.src` raw pointer via C, while the `SourceMgr` stored elsewhere owns it.///   This requires interior mutability and a non-exclusive ownership (`Box<UnsafeCell>` would be useless).to_consume// jpeg_source_mgr callbacks get a pointer to the struct/// This will have the buffer in valid state only if libjpeg stopped decoding/// at an end of a marker, or `jpeg_consume_input` has been called.iface_c_ptr/// Safety: `SourceMgr` can only be dropped after `cinfo.src` is set to NULL,/// or otherwise guaranteed not to be used any more via libjpeg.init_sourceset_buffer_to_eoifill_input_buffer_implfill_input_buffer/// In typical applications, it should read fresh data///    into the buffer (ignoring the current state of `next_input_byte` and///    `bytes_in_buffer`)skip_input_data/// libjpeg makes `bytes_in_buffer` up to date before calling thisreturn_unconsumed_dataterm_source/// `jpeg_finish_decompress` consumes data up to EOI before calling thisjpeg_destination_mgrJERR_BUFFER_SIZEJERR_FILE_WRITEJERR_INPUT_EOFJ_MESSAGE_CODEDestinationMgrInner/// The `jpeg_destination_mgr` has requirements that are tricky for Rust:/// * it is mutated via `cinfo.dest` raw pointer via C, while the `DestinationMgr` stored elsewhere owns it./// The `iface` is mutably aliased by C code. Must be the first field.// jpeg_destination_mgr callbacks get a pointer to the struct/// Must be called after `term_destination`/// Safety: `DestinationMgr` can only be dropped after `cinfo.dest` is set to NULLempty_output_buffer/// This is called by `jcphuff`'s `dump_buffer()`, which does NOT keep/// the position up to date, and expects full buffer write every time.init_destinationterm_destinationgas_supportednasm_supportedbuild_gasbuild_nasmJMSG_NOMESSAGEJERR_ARITH_NOTIMPLJERR_BAD_ALIGN_TYPEJERR_BAD_ALLOC_CHUNKJERR_BAD_BUFFER_MODEJERR_BAD_COMPONENT_IDJERR_BAD_DCT_COEFJERR_BAD_DCTSIZEJERR_BAD_HUFF_TABLEJERR_BAD_IN_COLORSPACEJERR_BAD_J_COLORSPACEJERR_BAD_LIB_VERSIONJERR_BAD_MCU_SIZEJERR_BAD_POOL_IDJERR_BAD_PRECISIONJERR_BAD_PROGRESSIONJERR_BAD_PROG_SCRIPTJERR_BAD_SAMPLINGJERR_BAD_SCAN_SCRIPTJERR_BAD_STATEJERR_BAD_STRUCT_SIZEJERR_BAD_VIRTUAL_ACCESSJERR_CANT_SUSPENDJERR_CCIR601_NOTIMPLJERR_COMPONENT_COUNTJERR_CONVERSION_NOTIMPLJERR_DAC_INDEXJERR_DAC_VALUEJERR_DHT_INDEXJERR_DQT_INDEXJERR_EMPTY_IMAGEJERR_EMS_READJERR_EMS_WRITEJERR_EOI_EXPECTEDJERR_FRACT_SAMPLE_NOTIMPLJERR_HUFF_CLEN_OVERFLOWJERR_HUFF_MISSING_CODEJERR_IMAGE_TOO_BIGJERR_INPUT_EMPTYJERR_MISMATCHED_QUANT_TABLEJERR_MISSING_DATAJERR_MODE_CHANGEJERR_NOTIMPLJERR_NOT_COMPILEDJERR_NO_BACKING_STOREJERR_NO_HUFF_TABLEJERR_NO_IMAGEJERR_NO_QUANT_TABLEJERR_NO_SOIJERR_OUT_OF_MEMORYJERR_QUANT_COMPONENTSJERR_QUANT_FEW_COLORSJERR_QUANT_MANY_COLORSJERR_SOF_DUPLICATEJERR_SOF_NO_SOSJERR_SOF_UNSUPPORTEDJERR_SOI_DUPLICATEJERR_SOS_NO_SOFJERR_TFILE_CREATEJERR_TFILE_READJERR_TFILE_SEEKJERR_TFILE_WRITEJERR_TOO_LITTLE_DATAJERR_UNKNOWN_MARKERJERR_WIDTH_OVERFLOWJERR_XMS_READJERR_XMS_WRITEJMSG_COPYRIGHTJMSG_VERSIONJTRC_16BIT_TABLESJTRC_ADOBEJTRC_APP0JTRC_APP14JTRC_DACJTRC_DHTJTRC_DQTJTRC_DRIJTRC_EMS_CLOSEJTRC_EMS_OPENJTRC_EOIJTRC_HUFFBITSJTRC_JFIFJTRC_JFIF_BADTHUMBNAILSIZEJTRC_JFIF_EXTENSIONJTRC_JFIF_THUMBNAILJTRC_MISC_MARKERJTRC_PARMLESS_MARKERJTRC_QUANTVALSJTRC_QUANT_3_NCOLORSJTRC_QUANT_NCOLORSJTRC_QUANT_SELECTEDJTRC_RECOVERY_ACTIONJTRC_RSTJTRC_SMOOTH_NOTIMPLJTRC_SOFJTRC_SOF_COMPONENTJTRC_SOIJTRC_SOSJTRC_SOS_COMPONENTJTRC_SOS_PARAMSJTRC_TFILE_CLOSEJTRC_TFILE_OPENJTRC_THUMB_JPEGJTRC_THUMB_PALETTEJTRC_THUMB_RGBJTRC_UNKNOWN_IDSJTRC_XMS_CLOSEJTRC_XMS_OPENJWRN_ADOBE_XFORMJWRN_BOGUS_PROGRESSIONJWRN_EXTRANEOUS_DATAJWRN_HIT_MARKERJWRN_HUFF_BAD_CODEJWRN_JFIF_MAJORJWRN_MUST_RESYNCJWRN_NOT_SEQUENTIALJWRN_TOO_MUCH_DATAJERR_BAD_CROP_SPECJERR_BAD_PARAMJERR_BAD_PARAM_VALUEJERR_UNSUPPORTED_SUSPENDJWRN_BOGUS_ICCJERR_BAD_DROP_SAMPLINGJMSG_LASTMSGCODE// bindgen vendor/jerror.h --constified-enum='.*' --no-prepend-enum-name > src/jerror.rs & fix uint/* automatically generated by rust-bindgen 0.65.1 */jerrorJINT_COMPRESS_PROFILE_VALUEJ_DCT_METHODJDCT_IFASTJDCT_FASTESTJDCT_ISLOWJDCT_DEFAULTJ_FLOAT_PARAM// ABI 80 implies ABI 70/// The basic DCT block is 8x8 samplesDCTSIZE2/// DCTSIZE²/// lasts until master record is destroyed/// lasts until done with image/datastreamNUM_QUANT_TBLS/// Quantization tables are numbered 0..3JCOEFJSAMPROW/// ptr to one image row of pixel samples.JSAMPROW_MUTJSAMPARRAY/// ptr to some rows (a 2-D sample array)JSAMPARRAY_MUTJSAMPIMAGE/// a 3-D sample array: top index is colorJSAMPIMAGE_MUTJBLOCK/// one block of coefficientsJBLOCKROW/// pointer to one row of coefficient blocksJBLOCKARRAYDCTELEM// must match dct.h; assumes bits in sample == 8/// type for individual integer DCT coefficientquantval/// This array gives the coefficient quantizers in natural array order/// (not the zigzag order in which they are stored in a JPEG DQT marker)./// CAUTION: IJG versions prior to v6a kept this array in zigzag order.sent_tableJQUANT_TBLhuffvalJHUFF_TBLcomponent_id/// identifier for this component (0..255)component_index/// its index in SOF or cinfo->comp_info[]h_samp_factor/// horizontal sampling factor (1..4)v_samp_factor/// vertical sampling factor (1..4)quant_tbl_no/// quantization table selector (0..3)dc_tbl_no/// DC entropy table selector (0..3)/// These values may vary between scans./// For compression, they must be supplied by parameter setup;/// for decompression, they are read from the SOS marker./// The decompressor output side may not use these variables.ac_tbl_no/// AC entropy table selector (0..3)DCT_scaled_sizedownsampled_widthdownsampled_heightcomponent_neededMCU_widthMCU_heightMCU_blocksMCU_sample_widthlast_col_widthlast_row_heightquant_tabledct_tablecomps_in_scanSsAhAljpeg_scan_infooriginal_lengthdata_lengthjpeg_marker/* APP0 marker code *//* COM marker code */JCS_UNKNOWN/// error/unspecifiedJCS_GRAYSCALE/// monochromeJCS_RGB/// red/green/blue as specified by the `RGB_RED`, `RGB_GREEN`, `RGB_BLUE`, and `RGB_PIXELSIZE` macrosJCS_YCbCr/// Y/Cb/Cr (also known as YUV)JCS_CMYK/// C/M/Y/KJCS_YCCK/// Y/Cb/Cr/KJCS_EXT_RGB/// red/green/blueJCS_EXT_RGBX/// red/green/blue/x/// When `out_color_space` it set to `JCS_EXT_RGBX`, `JCS_EXT_BGRX`, `JCS_EXT_XBGR`,/// or `JCS_EXT_XRGB` during decompression, the X byte is undefined, and in/// order to ensure the best performance, libjpeg-turbo can set that byte to/// whatever value it wishes.JCS_EXT_BGR/// blue/green/redJCS_EXT_BGRX/// blue/green/red/xJCS_EXT_XBGR/// x/blue/green/redJCS_EXT_XRGB/// x/red/green/blueJCS_EXT_RGBA/// Use the following colorspace constants to/// ensure that the X byte is set to 0xFF, so that it can be interpreted as an/// opaque alpha channel./// red/green/blue/alphaJCS_EXT_BGRA/// blue/green/red/alphaJCS_EXT_ABGR/// alpha/blue/green/redJCS_EXT_ARGB/// alpha/red/green/blueJCS_RGB565/// 5-bit red/6-bit green/5-bit blueJDCT_FLOATJ_DITHER_MODEJDITHER_NONEJDITHER_ORDEREDJDITHER_FS// #[deprecated]0x680C061EJBOOLEAN_OPTIMIZE_SCANS/// TRUE=optimize progressive coding scans0xC5122033JBOOLEAN_TRELLIS_QUANT/// TRUE=use trellis quantization0x339D4C0CJBOOLEAN_TRELLIS_QUANT_DC/// TRUE=use trellis quant for DC coefficient0xD7F73780JBOOLEAN_TRELLIS_EOB_OPT/// TRUE=optimize for sequences of EOB0x339DB65FJBOOLEAN_USE_LAMBDA_WEIGHT_TBL/// TRUE=use lambda weighting table0xFD841435JBOOLEAN_USE_SCANS_IN_TRELLIS/// TRUE=use scans in trellis optimization0xE12AE269JBOOLEAN_TRELLIS_Q_OPT/// TRUE=optimize quant table in trellis loop0x3F4BBBF9JBOOLEAN_OVERSHOOT_DERINGING/// TRUE=preprocess input to reduce ringing of edges on white background/// These 32-bit GUIDs and the corresponding `jpeg_*_get_*_param()`/// `jpeg_*_set_*_param()` functions allow for extending the libjpeg API without/// breaking backward ABI compatibility.  The actual parameters are stored in/// the opaque `jpeg_comp_master` and `jpeg_decomp_master` structs.0x5B61A599JFLOAT_LAMBDA_LOG_SCALE10xB9BBAE03JFLOAT_LAMBDA_LOG_SCALE20x13775453JFLOAT_TRELLIS_DELTA_DC_WEIGHT0xE9918625JINT_COMPRESS_PROFILE/// compression profile0x6FAFF127JINT_TRELLIS_FREQ_SPLIT/// splitting point for frequency in trellis quantization0xB63EBF39JINT_TRELLIS_NUM_LOOPS/// number of trellis loops0x44492AB1JINT_BASE_QUANT_TBL_IDX/// base quantization table index0x0BE7AD3CJINT_DC_SCAN_OPT_MODE/// DC scan optimization mode0x5D083AADJCP_MAX_COMPRESSION0x2AEA5CB4JCP_FASTEST/* best compression ratio (progressive, all mozjpeg extensions) *//* libjpeg[-turbo] defaults (baseline, no mozjpeg extensions) */jpeg_memory_mgrjpeg_progress_mgr/// Progress monitor, or NULL if none/// Available for use by applicationis_decompressor/// So common code can tell which is whichglobal_state/// For checking call sequence validity/// Routines that are to be used by both halves of the library are declared/// to receive a pointer to this structure.  There are no actual instances of/// `jpeg_common_struct`, only of `jpeg_compress_struct` and `jpeg_decompress_struct`.jpeg_comp_masterjpeg_c_main_controllerjpeg_c_prep_controllerjpeg_c_coef_controllerjpeg_marker_writerjpeg_color_converterjpeg_downsamplerjpeg_forward_dctjpeg_entropy_encoder/// Description of source image --- these fields must be filled in by/// outer application before starting compression.input_componentsin_color_space/// `in_color_space` must be correct before you can even call `jpeg_set_defaults()`.input_gamma/// image gamma of input imagedata_precision/// bits of precision in image datajpeg_color_space/// `comp_info[i]` describes component that appears i'th in SOFquant_tbl_ptrsdc_huff_tbl_ptrs/// ptrs to coefficient quantization tables, or NULL if not defined,/// and corresponding scale factors (percentage, initialized 100).ac_huff_tbl_ptrsarith_dc_Larith_dc_Uarith_ac_Knum_scansscan_inforaw_data_in/// TRUE=caller supplies downsampled dataarith_codeoptimize_coding/// TRUE=optimize entropy encoding parmsCCIR601_samplingsmoothing_factor/// MCUs per restart, or 0 for no restartrestart_in_rowswrite_JFIF_headerJFIF_major_versionJFIF_minor_versiondensity_unitX_densityY_densitywrite_Adobe_markernext_scanlineprogressive_mode/// Remaining fields are known throughout compressor, but generally/// should not be touched by a surrounding application./// These fields are computed during compression startupmax_h_samp_factormax_v_samp_factortotal_iMCU_rowscur_comp_infoMCUs_per_rowMCU_rows_in_scanblocks_in_MCUMCU_membershipprepcoefcconvertdownsamplescript_spacescript_space_sizejpeg_decomp_masterjpeg_d_main_controllerjpeg_d_coef_controllerjpeg_d_post_controllerjpeg_input_controllerjpeg_marker_readerjpeg_entropy_decoderjpeg_inverse_dctjpeg_upsamplerjpeg_color_deconverterjpeg_color_quantizer/// Basic description of image --- filled in by `jpeg_read_header()`/// Decompression processing parameters --- these fields must be set before/// calling `jpeg_start_decompress()`.  Note that `jpeg_read_header()` initializes/// them to default values.scale_numscale_denomoutput_gamma/// image gamma wanted in outputbuffered_imageraw_data_out/// TRUE=downsampled data wantedquantize_colorsdither_modetwo_pass_quantizedesired_number_of_colorsenable_1pass_quantenable_external_quantenable_2pass_quantoutput_width/// Description of actual output image that will be returned to application./// These fields are computed by `jpeg_start_decompress()`./// You can also use `jpeg_calc_output_dimensions()` to determine these values/// in advance of calling `jpeg_start_decompress()`.output_heightout_color_componentsoutput_componentsrec_outbuf_height/// min recommended height of scanline buffer/// If the buffer passed to `jpeg_read_scanlines()` is less than this many rows/// high, space and time will be wasted due to unnecessary data copying./// Usually `rec_outbuf_height` will be 1 or 2, at most 4.actual_number_of_colorsoutput_scanline/// Row index of next scanline to be read from `jpeg_read_scanlines()`./// Application may use this to control its processing loop, e.g.,/// "while (`output_scanline` < `output_height`)".input_scan_number/// Current input scan number and number of iMCU rows completed in scan./// These indicate the progress of the decompressor input side.input_iMCU_rowoutput_scan_numberoutput_iMCU_rowcoef_bits/// Current progression status.  `coef_bits[c][i]` indicates the precision/// with which component c's DCT coefficient i (in zigzag order) is known./// It is -1 when no data has yet been received, otherwise it is the point/// transform (shift) value for the most recent scan of the coefficient/// (thus, 0 at completion of the progression)./// This pointer is NULL when reading a non-progressive file./// Internal JPEG parameters --- the application usually need not look at/// these fields.  Note that the decompressor output side may not use/// any parameters that can change between scans.saw_JFIF_markersaw_Adobe_markerAdobe_transform/// These fields are computed during decompression startupmin_DCT_scaled_size/// smallest `DCT_scaled_size` of any componentsample_range_limitunread_markerinputctlupsamplecquantizeerror_exit/// Error exit handler: does not return to calleremit_messageoutput_messageformat_messagereset_error_mgrmsg_codemsg_parmmsg_parm_uniontrace_levelnum_warningsjpeg_message_tablelast_jpeg_messageaddon_message_tablefirst_addon_messagelast_addon_message/// Error handler objectprogress_monitorpass_counterpass_limitcompleted_passestotal_passesnext_output_bytefree_in_buffernext_input_bytebytes_in_bufferresync_to_restartjvirt_sarray_control/// This is an opaque type. Don't assume size or alignment of this struct.jvirt_barray_controlalloc_smallalloc_largealloc_sarrayalloc_barrayrequest_virt_sarrayrequest_virt_barrayrealize_virt_arraysaccess_virt_sarrayaccess_virt_barrayfree_poolself_destructmax_memory_to_usemax_alloc_chunkjpeg_marker_parser_methodjpeg_create_decompressjpeg_create_compressjpeg_std_errorjpeg_CreateCompressjpeg_CreateDecompressjpeg_destroy_compressjpeg_destroy_decompressjpeg_stdio_destjpeg_stdio_srcjpeg_mem_destjpeg_mem_srcjpeg_set_defaultsjpeg_set_colorspacejpeg_default_colorspacejpeg_set_qualityjpeg_set_linear_qualityjpeg_add_quant_tablejpeg_quality_scalingjpeg_float_quality_scalingjpeg_simple_progressionjpeg_suppress_tablesjpeg_alloc_quant_tablejpeg_alloc_huff_tablejpeg_start_compressjpeg_write_scanlinesjpeg_finish_compressjpeg_write_raw_datajpeg_write_markerjpeg_write_m_headerjpeg_write_m_bytejpeg_write_tablesjpeg_read_headerjpeg_start_decompressjpeg_read_scanlinesjpeg_finish_decompressjpeg_read_raw_datajpeg_skip_scanlines/// This function provides application programmers with the ability to skip over/// multiple rows in the JPEG image./// Suspending data sources are not supported by this function.  Calling/// jpeg_skip_scanlines() with a suspending data source will result in undefinedjpeg_crop_scanline/// This function provides application programmers with the ability to decompress/// only a portion of each row in the JPEG image.  It must be called after/// jpeg_start_decompress() and before any calls to jpeg_read_scanlines() or/// jpeg_skip_scanlines()./// If the output image is scaled, then xoffset and width are relative to the scaled image dimensions./// xoffset and width are passed by reference because xoffset must fall on an iMCU/// boundary.  If it doesn't, then it will be moved left to the nearest iMCU/// boundary, and width will be increased accordingly.jpeg_has_multiple_scansjpeg_start_outputjpeg_finish_outputjpeg_input_completejpeg_new_colormapjpeg_consume_inputjpeg_calc_output_dimensionsjpeg_save_markersjpeg_set_marker_processorjpeg_read_coefficientsjpeg_write_coefficientsjpeg_copy_critical_parametersjpeg_abort_compressjpeg_abort_decompressjpeg_c_bool_param_supportedjpeg_c_set_bool_paramjpeg_c_get_bool_paramjpeg_c_float_param_supportedjpeg_abortjpeg_destroyjpeg_c_set_float_paramjpeg_c_get_float_paramjpeg_c_int_param_supportedjpeg_c_set_int_paramjpeg_c_get_int_paramjpeg_set_idct_method_selectorjsimd_can_rgb_yccjsimd_can_fdct_ifastjsimd_fdct_ifastenum_32bitsimd_is_detectablesimd_works_sse2try_decompresstry_compressall_links//! Please **[read libjpeg manual](https://github.com/mozilla/mozjpeg/blob/master/libjpeg.txt)** for description of functions in this crate.j_common_ptrj_compress_ptrj_decompress_ptrjvirt_barray_ptrJXFORM_CODE_JXFORM_NONEJXFORM_CODEJXFORM_CODE_JXFORM_FLIP_HJXFORM_CODE_JXFORM_FLIP_VJXFORM_CODE_JXFORM_TRANSPOSEJXFORM_CODE_JXFORM_TRANSVERSEJXFORM_CODE_JXFORM_ROT_90JXFORM_CODE_JXFORM_ROT_180JXFORM_CODE_JXFORM_ROT_270JCROP_CODE_JCROP_UNSETJCROP_CODEJCROP_CODE_JCROP_POSJCROP_CODE_JCROP_NEGJCROP_CODE_JCROP_FORCEJCOPY_OPTION_JCOPYOPT_NONEJCOPY_OPTIONJCOPY_OPTION_JCOPYOPT_COMMENTSJCOPY_OPTION_JCOPYOPT_ALLJCOPY_OPTION_JCOPYOPT_ALL_EXCEPT_ICCJCOPY_OPTION_JCOPYOPT_ICCperfecttrimforce_grayscaleslow_hflipcrop_widthcrop_width_setcrop_heightcrop_height_setcrop_xoffsetcrop_xoffset_setcrop_yoffsetcrop_yoffset_setworkspace_coef_arraysx_crop_offsety_crop_offsetiMCU_sample_widthiMCU_sample_heightjpeg_transform_infojtransform_execute_transformationjtransform_adjust_parametersjtransform_execute_transformjtransform_request_workspacejcopy_markers_setupjcopy_markers_execute/// Sets the application name./// The application version.short_version/// The short version, e.g. "1.0"./// - **Windows / Linux:** Appended to the end of `version` in parentheses./// The authors of the application./// - **macOS:** Unsupported./// Application comments./// The copyright of the application./// The license of the application./// The application website./// The website label.credits/// The credits./// - **Windows / Linux:** Unsupported./// The application icon.AboutMetadata/// Application metadata for the [`PredefinedMenuItem::about`](crate::PredefinedMenuItem::about).full_versionfrom_cargo_metadata/// Creates [`AboutMetadata`] from [Cargo metadata][cargo]. The following fields are set by this function./// - [`AboutMetadata::name`] (from `CARGO_PKG_NAME`)/// - [`AboutMetadata::version`] (from `CARGO_PKG_VERSION`)/// - [`AboutMetadata::short_version`] (from `CARGO_PKG_VERSION_MAJOR` and `CARGO_PKG_VERSION_MINOR`)/// - [`AboutMetadata::authors`] (from `CARGO_PKG_AUTHORS`)/// - [`AboutMetadata::comments`] (from `CARGO_PKG_DESCRIPTION`)/// - [`AboutMetadata::license`] (from `CARGO_PKG_LICENSE`)/// - [`AboutMetadata::website`] (from `CARGO_PKG_HOMEPAGE`)/// [cargo]: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-cratesAboutMetadataBuilder/// A builder type for [`AboutMetadata`].with_cargo_metadata/// Creates [`AboutMetadataBuilder`] with Cargo metadata./// See [`AboutMetadata::from_cargo_metadata`] for more details./// Sets the application version./// Sets the short version, e.g. "1.0"./// Sets the authors of the application./// Sets the copyright of the application./// Sets the license of the application./// Sets the application website./// Sets the website label./// Sets the credits./// Sets the application icon./// Construct the final [`AboutMetadata`]test_build_from_metadataCMD_OR_CTRLAcceleratorParseErrorUnsupportedKeyEmptyToken/// A keyboard shortcut that consists of an optional combination/// of modifier keys (provided by [`Modifiers`](crate::accelerator::Modifiers)) and/// one key ([`Code`](crate::accelerator::Code))./// Creates a new accelerator to define keyboard shortcuts throughout your application./// Only [`Modifiers::ALT`], [`Modifiers::SHIFT`], [`Modifiers::CONTROL`], and [`Modifiers::SUPER`]generate_hash/// Returns the id associated with this accelerator/// which is a hash of the string representation of modifiers and key within this accelerator./// Returns `true` if this [`Code`] and [`Modifiers`] matches this `Accelerator`.parse_acceleratortest_parse_acceleratortest_equality//! Accelerators describe keyboard shortcuts for menu items.//! [`Accelerator`s](crate::accelerator::Accelerator) are used to define a keyboard shortcut consisting//! of an optional combination of modifier keys (provided by [`Modifiers`](crate::accelerator::Modifiers)) and//! one key ([`Code`](crate::accelerator::Code)).//! They can be created directly//! # use muda::accelerator::{Accelerator, Modifiers, Code};//! let accelerator = Accelerator::new(Some(Modifiers::SHIFT), Code::KeyQ);//! let accelerator_without_mods = Accelerator::new(None, Code::KeyQ);//! or from `&str`, note that all modifiers//! have to be listed before the non-modifier key, `shift+alt+KeyQ` is legal,//! whereas `shift+q+alt` is not.//! # use muda::accelerator::{Accelerator};//! let accelerator: Accelerator = "shift+alt+KeyQ".parse().unwrap();//! # // This assert exists to ensure a test breaks once the//! # // statement above about ordering is no longer valid.//! # assert!("shift+KeyQ+alt".parse::<Accelerator>().is_err());MenuIdacccelerator/// A builder type for [`CheckMenuItem`]/// Set the id this check menu item./// Set the text for this check menu item./// See [`CheckMenuItem::set_text`] for more info./// Enable or disable this menu item./// Check or uncheck this menu item./// Set this check menu item accelerator./// Build this check menu item.NativeIconIconMenuItemnative_iconIconMenuItemBuilder/// A builder type for [`IconMenuItem`]/// Set the id this icon menu item./// Set the text for this icon menu item./// See [`IconMenuItem::set_text`] for more info./// Set this icon menu item icon./// Set this icon menu item native icon./// Set this icon menu item accelerator./// Build this icon menu item.about_metadata//! A module containting builder types/// A builder type for [`MenuItem`]/// Set the id this menu item./// Set the text for this menu item./// See [`MenuItem::set_text`] for more info./// Set this menu item accelerator./// Build this menu item.IsMenuItemSubmenuSubmenuBuilder/// A builder type for [`Submenu`]/// Set the id this submenu./// Set the text for this submenu./// See [`Submenu::set_text`] for more info./// Enable or disable this submenu./// Add an item to this submenu./// Add these items to this submenu.NotAChildOfThisMenuAlreadyInitialized/// Errors returned by muda./// Convenient type alias of Result type for muda./// An add item template image.Advanced/// Advanced preferences toolbar icon for the preferences window./// A Bluetooth template image.Bookmarks/// Bookmarks image suitable for a template.Caution/// A caution image.ColorPanel/// A color panel toolbar icon.ColumnView/// A column view mode template image.Computer/// A computer icon.EnterFullScreen/// An enter full-screen mode template image.Everyone/// Permissions for all users.ExitFullScreen/// An exit full-screen mode template image.FlowView/// A cover flow view mode template image./// A folder image.FolderBurnable/// A burnable folder icon.FolderSmart/// A smart folder icon.FollowLinkFreestanding/// A link template image.FontPanel/// A font panel toolbar icon.GoLeft/// A `go back` template image.GoRight/// A `go forward` template image./// Home image suitable for a template.IChatTheater/// An iChat Theater template image./// An icon view mode template image./// An information toolbar icon.InvalidDataFreestanding/// A template image used to denote invalid data.LeftFacingTriangle/// A generic left-facing triangle template image.ListView/// A list view mode template image.LockLocked/// A locked padlock template image.LockUnlocked/// An unlocked padlock template image.MenuMixedState/// A horizontal dash, for use in menus.MenuOnState/// A check mark template image, for use in menus.MobileMe/// A MobileMe icon.MultipleDocuments/// A drag image for multiple items./// A network icon./// A path button template image.PreferencesGeneral/// General preferences toolbar icon for the preferences window.QuickLook/// A Quick Look template image.RefreshFreestanding/// A refresh template image./// A remove item template image.RevealFreestanding/// A reveal contents template image.RightFacingTriangle/// A generic right-facing triangle template image.Share/// A share view template image.Slideshow/// A slideshow template image.SmartBadge/// A badge for a `smart` item.StatusAvailable/// Small green indicator, similar to iChat’s available image.StatusNone/// Small clear indicator.StatusPartiallyAvailable/// Small yellow indicator, similar to iChat’s idle image.StatusUnavailable/// Small red indicator, similar to iChat’s unavailable image.StopProgressFreestanding/// A stop progress template image.StopProgress/// A stop progress button template image.TrashEmpty/// An image of the empty trash can.TrashFull/// An image of the full trash can./// Permissions for a single user.UserAccounts/// User account toolbar icon for the preferences window.UserGroup/// Permissions for a group of users.UserGuest/// Permissions for guests./// A native Icon to be used for the menu item/// - **Windows / Linux**: Unsupported.IsMenuItemBaseMenuItemKindMenuChild/// A check menu item inside a [`Menu`] or [`Submenu`]/// and usually contains a text and a check mark or a similar toggle/// that corresponds to a checked and unchecked states./// [`Menu`]: crate::Menu/// [`Submenu`]: crate::Submenuinto_id/// Create a new check menu item./// - `text` could optionally contain an `&` before a character to assign this character as the mnemonic/// for this check menu item. To display a `&` without assigning a mnemenonic, use `&&`./// Create a new check menu item with the specified id./// Returns a unique identifier associated with this submenu./// Get the text for this check menu item./// Set the text for this check menu item. `text` could optionally contain/// an `&` before a character to assign this character as the mnemonic/// Get whether this check menu item is enabled or not./// Enable or disable this check menu item.is_checked/// Get whether this check menu item is checked or not.set_checked/// Check or Uncheck this check menu item./// Convert this menu item into its menu ID.// SPDX-License-Identifier: Apache-2.inner/// An icon menu item inside a [`Menu`] or [`Submenu`]/// and usually contains an icon and a text./// Create a new icon menu item./// for this icon menu item. To display a `&` without assigning a mnemenonic, use `&&`./// Create a new icon menu item with the specified id.with_native_icon/// Create a new icon menu item but with a native icon./// See [`IconMenuItem::new`] for more info.with_id_and_native_icon/// Create a new icon menu item but with the specified id and a native icon./// Change this menu item icon or remove it.set_native_icon/// Change this menu item icon to a native image or remove it.predefinedPredefinedMenuItemit_returns_same_idtest_convert_from_id_and_into_id/// A menu item inside a [`Menu`] or [`Submenu`] and contains only text./// Create a new menu item./// for this menu item. To display a `&` without assigning a mnemenonic, use `&&`./// Create a new menu item with the specified id./// Returns a unique identifier associated with this menu item./// Set the text for this menu item. `text` could optionally contain/// Get whether this menu item is enabled or not./// A predefined (native) menu item which has a predfined behavior by the OS or by this crate./// Separator menu item/// Copy menu item/// Cut menu item/// Paste menu item/// SelectAll menu itemundo/// Undo menu itemredo/// Redo menu itemminimize/// Minimize window menu item/// Maximize window menu item/// Fullscreen menu item/// Hide window menu itemhide_others/// Hide other windows menu item/// Show all app windows menu itemclose_window/// Close window menu item/// Quit app menu item/// About app menu itemservices/// Services menu itembring_all_to_front/// 'Bring all to front' menu itemPredefinedMenuItemType/// Returns a unique identifier associated with this predefined menu item./// Get the text for this predefined menu item./// Set the text for this predefined menu item.test_about_metadataMinimizeMaximizeHideOthersShowAllCloseWindowAboutServicesBringAllToFrontAddOp/// A menu that can be added to a [`Menu`] or another [`Submenu`]./// Create a new submenu./// for this submenu. To display a `&` without assigning a mnemenonic, use `&&`./// Create a new submenu with the specified id.with_items/// Creates a new submenu with given `items`. It calls [`Submenu::new`] and [`Submenu::append_items`] internally.with_id_and_items/// Creates a new submenu with the specified id and given `items`. It calls [`Submenu::new`] and [`Submenu::append_items`] internally./// Add a menu item to the end of this menu./// Add menu items to the end of this submenu. It calls [`Submenu::append`] in a loop./// Add a menu item to the beginning of this submenu.prepend_items/// Add menu items to the beginning of this submenu./// It calls [`Menu::prepend`](crate::Menu::prepend) on the first element and/// passes the rest to [`Menu::insert_items`](crate::Menu::insert_items) with position of `1`./// Insert a menu item at the specified `postion` in the submenu.insert_items/// Insert menu items at the specified `postion` in the submenu./// Remove a menu item from this submenu.remove_at/// Remove the menu item at the specified position from this submenu and returns it./// Returns a list of menu items that has been added to this submenu./// Get the text for this submenu./// Set the text for this submenu. `text` could optionally contain/// Get whether this submenu is enabled or not./// Convert this submenu into its menu ID.show_context_menu_for_gtk_windowgtk_context_menumenu_idPredefined/// An enumeration of all available menu types, useful to match against/// the items returned from [`Menu::items`] or [`Submenu::items`]as_menuitem/// Casts this item to a [`MenuItem`], and returns `None` if it wasn't.as_menuitem_unchecked/// Casts this item to a [`MenuItem`], and panics if it wasn't.as_submenu/// Casts this item to a [`Submenu`], and returns `None` if it wasn't.as_submenu_unchecked/// Casts this item to a [`Submenu`], and panics if it wasn't.as_predefined_menuitem/// Casts this item to a [`PredefinedMenuItem`], and returns `None` if it wasn't.as_predefined_menuitem_unchecked/// Casts this item to a [`PredefinedMenuItem`], and panics if it wasn't.as_check_menuitem/// Casts this item to a [`CheckMenuItem`], and returns `None` if it wasn't.as_check_menuitem_unchecked/// Casts this item to a [`CheckMenuItem`], and panics if it wasn't.as_icon_menuitem/// Casts this item to a [`IconMenuItem`], and returns `None` if it wasn't.as_icon_menuitem_unchecked/// Casts this item to a [`IconMenuItem`], and panics if it wasn't./// Convert this item into its menu ID./// Returns a [`MenuItemKind`] associated with this item./// A trait that defines a generic item in a menu, which may be one of [`MenuItemKind`]MenuItemType/// Shows this menu as a context menu inside a [`gtk::Window`]/// - `position` is relative to the window top-left corner, if `None`, the cursor position is used./// Get the underlying gtk menu reserved for context menus./// A helper trait with methods to help creating a context menu./// Id of the menu item which triggered this eventMenuEvent/// Describes a menu event emitted when a menu item is activatedMenuEventReceiver/// A reciever that could be used to listen to menu events.MenuEventHandlerMENU_CHANNELMENU_EVENT_HANDLER/// Returns the id of the menu item which triggered this event/// Gets a reference to the event channel's [`MenuEventReceiver`]/// which can be used to listen for menu events./// This will not receive any events if [`MenuEvent::set_event_handler`] has been called with a `Some` value./// will not send new events to the channel associated with [`MenuEvent::receiver`]//! muda is a Menu Utilities library for Desktop Applications.//! - On Windows, accelerators don't work unless the win32 message loop calls//!   [`TranslateAcceleratorW`](https://docs.rs/windows-sys/latest/windows_sys/Win32/UI/WindowsAndMessaging/fn.TranslateAcceleratorW.html).//!   See [`Menu::init_for_hwnd`](https://docs.rs/muda/latest/x86_64-pc-windows-msvc/muda/struct.Menu.html#method.init_for_hwnd) for more details//! `gtk` is used for menus and `libxdo` is used to make the predfined `Copy`, `Cut`, `Paste` and `SelectAll` menu items work. Be sure to install following packages before building://! pacman -S gtk3 xdotool//! sudo apt install libgtk-3-dev libxdo-dev//! Create the menu and add your items//! # use muda::{Menu, Submenu, MenuItem, accelerator::{Code, Modifiers, Accelerator}, PredefinedMenuItem};//! let menu = Menu::new();//! let menu_item2 = MenuItem::new("Menu item #2", false, None);//! let submenu = Submenu::with_items(//!     "Submenu Outer",//!     true,//!     &[//!         &MenuItem::new(//!             "Menu item #1",//!             true,//!             Some(Accelerator::new(Some(Modifiers::ALT), Code::KeyD)),//!         ),//!         &PredefinedMenuItem::separator(),//!         &menu_item2,//!         &MenuItem::new("Menu item #3", true, None),//!         &Submenu::with_items(//!             "Submenu Inner",//!             &[//!                 &MenuItem::new("Submenu item #1", true, None),//!                 &PredefinedMenuItem::separator(),//!                 &menu_item2,//!             ],//!         ).unwrap(),//! Then add your root menu to a Window on Windows and Linux//! or use it as your global app menu on macOS//! # let menu = muda::Menu::new();//! # let window_hwnd = 0;//! # #[cfg(target_os = "linux")]//! # let gtk_window = gtk::Window::builder().build();//! # let vertical_gtk_box = gtk::Box::new(gtk::Orientation::Vertical, 0);//! // --snip--//! #[cfg(target_os = "windows")]//! menu.init_for_hwnd(window_hwnd);//! #[cfg(target_os = "linux")]//! menu.init_for_gtk_window(&gtk_window, Some(&vertical_gtk_box));//! #[cfg(target_os = "macos")]//! menu.init_for_nsapp();//! # Context menus (Popup menus)//! You can also use a [`Menu`] or a [`Submenu`] show a context menu.//! use muda::ContextMenu;//! # #[cfg(target_os = "macos")]//! # let nsview = 0 as *mut objc::runtime::Object;//! let position = muda::dpi::PhysicalPosition { x: 100., y: 120. };//! menu.show_context_menu_for_hwnd(window_hwnd, Some(position.into()));//! menu.show_context_menu_for_gtk_window(&gtk_window, Some(position.into()));//! menu.show_context_menu_for_nsview(nsview, Some(position.into()));//! # Processing menu events//! You can use [`MenuEvent::receiver`] to get a reference to the [`MenuEventReceiver`]//! which you can use to listen to events when a menu item is activated//! # use muda::MenuEvent;//! # let save_item: muda::MenuItem = unsafe { std::mem::zeroed() };//!     match event.id {//!         id if id == save_item.id() => {//!             println!("Save menu item activated");//!         _ => {}/// A root menu that can be added to a Window on Windows and Linux/// and used as the app global menu on macOS./// Creates a new menu./// Creates a new menu with the specified id./// Creates a new menu with given `items`. It calls [`Menu::new`] and [`Menu::append_items`] internally./// Creates a new menu with the specified id and given `items`. It calls [`Menu::new`] and [`Menu::append_items`] internally./// Returns a unique identifier associated with this menu./// ## Platform-spcific:/// - **macOS:** Only [`Submenu`] can be added to the menu/// Add menu items to the end of this menu. It calls [`Menu::append`] in a loop internally./// Add a menu item to the beginning of this menu./// Add menu items to the beginning of this menu. It calls [`Menu::insert_items`] with position of `0` internally./// Insert a menu item at the specified `postion` in the menu./// Insert menu items at the specified `postion` in the menu./// Remove a menu item from this menu./// Remove the menu item at the specified position from this menu and returns it./// Returns a list of menu items that has been added to this menu.init_for_gtk_window/// Adds this menu to a [`gtk::Window`]/// - `container`: this is an optional paramter to specify a container for the [`gtk::MenuBar`],/// it is highly recommended to pass a container, otherwise the menubar will be added directly to the window,/// which is usually not the desired behavior./// If using a [`gtk::Box`] as a container, it is added using [`Box::pack_start(menubar, false, false, 0)`](gtk::prelude::BoxExt::pack_start) then/// reordered to be the first child of [`gtk::Box`] using [`Box::reorder_child(menubar, 0)`](gtk::prelude::BoxExt::reorder_child)./// let window = gtk::Window::builder().build();/// let vbox = gtk::Box::new(gtk::Orientation::Vertical, 0);/// let menu = muda::Menu::new();/// // -- snip, add your menu items --/// menu.init_for_gtk_window(&window, Some(&vbox));/// // then proceed to add your widgets to the `vbox`/// ## Panics:/// Panics if the gtk event loop hasn't been initialized on the thread.remove_for_gtk_window/// Removes this menu from a [`gtk::Window`]hide_for_gtk_window/// Hides this menu from a [`gtk::Window`]show_for_gtk_window/// Shows this menu on a [`gtk::Window`]is_visible_on_gtk_window/// Returns whether this menu visible on a [`gtk::Window`]gtk_menubar_for_gtk_window/// Returns the [`gtk::MenuBar`] that is associated with this window if it exists./// This is useful to get information about the menubar for example its height./// An unique id that is associated with a menu or a menu item./// Create a new menu id.to_gtk_mnemonicfrom_gtk_mnemonicmodifiers_to_gdk_modifier_typekey_to_raw_keyto_pixbufto_pixbuf_scale// Copyright 2021-2022 Tauri Programme within The Commons Conservancyis_item_supportedreturn_if_item_not_supportedgtk_menubars// TODO: maybe save a reference to the window?gtk_menu// dedicated menu for tray or context menusadd_menu_itemadd_menu_item_with_idadd_menu_item_to_context_menuremove_inner// shared fields between submenus and menu itemsgtk_menu_items// menu item fieldsgtk_acceleratorpredefined_item_type// predefined menu item fields// check menu item fieldsis_syncing_checked_state// icon menu item fields// submenu fieldsgtk_menus/// A generic child in a menudrop_children_from_menu_and_destroynew_predefinednew_checknew_iconnew_native_icon/// Constructors/// Shared methods/// CheckMenuItem methods/// IconMenuItem methods/// Submenu methodsregister_accelcreate_gtk_item_for_submenucreate_gtk_item_for_menu_itemcreate_gtk_item_for_predefined_menu_itemcreate_gtk_item_for_check_menu_itemcreate_gtk_item_for_icon_menu_item/// Gtk menu item creation methodsmake_gtk_menu_itemshow_context_menuxdo_keyskey_equivalent/// Return the string value of this hotkey, without modifiers./// Returns the empty string if no key equivalent is known.key_modifier_mask/// Return the modifiers of this hotkey, as an NSEventModifierFlags bitflag.to_nsimageNSMenuItemapp_name_stringstrip_mnemonicBLOCK_PTRNSAboutPanelOptionApplicationNameNSAboutPanelOptionApplicationIconNSAboutPanelOptionApplicationVersionNSAboutPanelOptionCreditsNSAboutPanelOptionVersionNSAboutPanelOptionCopyright/// https://developer.apple.com/documentation/appkit/nsapplication/1428479-orderfrontstandardaboutpanelwith#discussionNsMenuRefNsMenuItemRefns_menuinit_for_nsappremove_for_nsappshow_context_menu_for_nsviewns_menu_itemsns_menusset_as_windows_menu_for_nsappset_as_help_menu_for_nsappcreate_ns_item_for_submenucreate_ns_item_for_menu_itemcreate_ns_item_for_predefined_menu_itemcreate_ns_item_for_check_menu_itemcreate_ns_item_for_icon_menu_itemmake_ns_item_for_menu/// NSMenuItem item creation methodsmake_menu_item_classdealloc_custom_menuitemfire_menu_item_clickcreate_ns_menu_itemmenuitem_set_iconmenuitem_set_native_iconnamed_img/// Strips single `&` characters from the string./// `&` can be escaped as `&&` to prevent stripping, in which case a single `&` will be output./// Copies the contents of the NSString into a `String` which gets returned./// Gets the app's name from the `localizedName` property of `NSRunningApplication`./// Gets the app's name as a `String` from the `localizedName` property of `NSRunningApplication`./// Internal utilitieschild_mutFALTFCONTROLFSHIFTFVIRTKEYto_accel// Convert a hotkey to an accelerator.key_to_vk// used to build accelerators table from KeyHIGHCONTRASTAGetClientRectGetMenuBarInfoGetMenuItemInfoWGetWindowRectSystemParametersInfoAMENUBARINFOMENUITEMINFOWMIIM_STRINGOBJID_MENUSPI_GETHIGHCONTRASTWM_NCACTIVATEWM_NCPAINTWM_UAHDRAWMENUWM_UAHDRAWMENUITEMUAHMENUITEMMETRICS0rgsizeBarrgsizePopupUAHMENUITEMMETRICSrgcxfUpdateMaxWidthsUAHMENUPOPUPMETRICShmenuhdcUAHMENUiPositionumimumpmUAHMENUITEMdisDRAWITEMSTRUCTumiUAHDRAWMENUITEMHBRUSHHBrushbackground_brushselected_background_brush/// Draws a dark menu bar if needed and returns whether it draws it or notis_dark_mode_allowed_for_window// this is a port of combination of https://github.com/hrydgard/ppsspp/blob/master/Windows/W32Util/UAHMenuBar.cpp and https://github.com/ysc3839/win32-darkmode/blob/master/win32-darkmode/DarkMode.hCreateCompatibleDCCreateDIBSectionDeleteDCReleaseDCSelectObjectDrawIconExDI_NORMALto_hbitmapdark_menu_barMenuThemedecode_wideAppendMenuWCreateAcceleratorTableWCreateMenuCreatePopupMenuDestroyAcceleratorTableDestroyMenuDrawMenuBarEnableMenuItemGetMenuInsertMenuWPostQuitMessageRemoveMenuSetMenuSetMenuItemInfoWShowWindowHACCELMFS_CHECKEDMFS_DISABLEDMF_BYCOMMANDMF_BYPOSITIONMF_CHECKEDMF_DISABLEDMF_ENABLEDMF_GRAYEDMF_POPUPMF_SEPARATORMF_STRINGMF_UNCHECKEDMIIM_BITMAPMIIM_STATESW_HIDESW_MAXIMIZESW_MINIMIZEWM_CLOSEWM_COMMANDinner_menu_child_and_flagsAccelWrapperhwndshaccel_storefind_by_idhaccelinit_for_hwnd_with_themeinit_for_hwndremove_for_hwndattach_menu_subclass_for_hwnddetach_menu_subclass_from_hwndhide_for_hwndshow_for_hwndis_visible_on_hwndshow_context_menu_for_hwndset_theme_for_hwndparents_hemnuroot_menu_haccel_stores/// Internal UtilitlesAccelActionupdate_storecreate_icon_item_infoMENU_SUBCLASS_IDMENU_UPDATE_THEMESUBMENU_SUBCLASS_IDCONTEXT_MENU_SUBCLASS_IDCONTEXT_SUBMENU_SUBCLASS_IDmenu_subclass_procshould_use_darkEditCommandexecute_edit_commandshow_about_dialogGetDeviceCapsMonitorFromWindowLOGPIXELSXMONITOR_DEFAULTTONEARESTMDT_EFFECTIVE_DPIIsProcessDPIAwarenew_with_start/// Output type for the methods of this trait./// Calculates `floor(val * num / denom)`, i.e. the largest integer less than or equal to the/// result of the division./// extern crate muldiv;/// use muldiv::MulDiv;/// let x = 3i8.mul_div_floor(4, 2);/// assert_eq!(x, Some(6));/// let x = 5i8.mul_div_floor(2, 3);/// assert_eq!(x, Some(3));/// let x = (-5i8).mul_div_floor(2, 3);/// assert_eq!(x, Some(-4));/// let x = 3i8.mul_div_floor(3, 2);/// assert_eq!(x, Some(4));/// let x = (-3i8).mul_div_floor(3, 2);/// assert_eq!(x, Some(-5));/// let x = 127i8.mul_div_floor(4, 3);/// assert_eq!(x, None);/// Calculates `round(val * num / denom)`, i.e. the closest integer to the result of the/// division. If both surrounding integers are the same distance (`x.5`), the one with the bigger/// absolute value is returned (round away from 0.0)./// let x = 3i8.mul_div_round(4, 2);/// let x = 5i8.mul_div_round(2, 3);/// let x = (-5i8).mul_div_round(2, 3);/// assert_eq!(x, Some(-3));/// let x = 3i8.mul_div_round(3, 2);/// assert_eq!(x, Some(5));/// let x = (-3i8).mul_div_round(3, 2);/// let x = 127i8.mul_div_round(4, 3);/// Calculates `ceil(val * num / denom)`, i.e. the the smallest integer greater than or equal to/// the result of the division./// let x = 3i8.mul_div_ceil(4, 2);/// let x = 5i8.mul_div_ceil(2, 3);/// let x = (-5i8).mul_div_ceil(2, 3);/// let x = 3i8.mul_div_ceil(3, 2);/// let x = (-3i8).mul_div_ceil(3, 2);/// let x = (127i8).mul_div_ceil(4, 3);/// Trait for calculating `val * num / denom` with different rounding modes and overflow/// protection./// Implementations of this trait have to ensure that even if the result of the multiplication does/// not fit into the type, as long as it would fit after the division the correct result has to be/// returned instead of `None`. `None` only should be returned if the overall result does not fit/// into the type./// This specifically means that e.g. the `u64` implementation must, depending on the arguments, be/// able to do 128 bit integer multiplication.mul_div_impl_unsignedmul_div_impl_unsigned_testsmuldiv_u64_tests// FIXME: https://github.com/rust-lang/rust/issues/12249muldiv_u32_testsmuldiv_u16_testsmuldiv_u8_testsmul_div_impl_signedmul_div_impl_signed_testsmuldiv_i64_testsmuldiv_i32_testsmuldiv_i16_testsmuldiv_i8_tests// Copyright (C) 2016,2017 Sebastian Dröge <sebastian@centricular.com>//! Provides a trait for numeric types to perform combined multiplication and division with//! overflow protection.//! The [`MulDiv`] trait provides functions for performing combined multiplication and division for//! numeric types and comes with implementations for all the primitive integer types. Three//! variants with different rounding characteristics are provided: [`mul_div_floor()`],//! [`mul_div_round()`] and [`mul_div_ceil()`].//! extern crate muldiv;//! use muldiv::MulDiv;//! // Calculates 127 * 23 / 42 rounded down//! let x = 127u8.mul_div_floor(23, 42);//! assert_eq!(x, Some(69));//! [`MulDiv`]: trait.MulDiv.html//! [`mul_div_floor()`]: trait.MulDiv.html#tymethod.mul_div_floor//! [`mul_div_round()`]: trait.MulDiv.html#tymethod.mul_div_round//! [`mul_div_ceil()`]: trait.MulDiv.html#tymethod.mul_div_ceilInternalGeneratorBufferedRng/// A buffered wrapper for any [Rng] implementation.
/// It will keep unused bytes from the last call to [`Rng::rand`], and use them
/// for subsequent randomness if needed, rather than throwing them away.
/// use nanorand::{Rng, BufferedRng, WyRand};
/// let mut thingy = [0u8; 5];
/// let mut rng = BufferedRng::new(WyRand::new());
/// rng.fill(&mut thingy);
/// // As WyRand generates 8 bytes of output, and our target is only 5 bytes,
/// // 3 bytes will remain in the buffer.
/// assert_eq!(rng.buffered(), 3);
/// Wraps a [`Rng`] InternalGenerator in a [`BufferedRng`] instance.
/// Returns the internal RNG, dropping the buffer.
/// Returns how many unused bytes are currently buffered.
reseedSEED_SIZECHACHA_TAUchacha_quarter_roundchacha_packROUNDSchacha_block/// Do one ChaCha round on the input data.chacha_init/// Initialize the ChaCha internal state, with a 256-bit key and 64-bit nonce.chacha_increment_counter/// Increment the 64-bit counter of the internal ChaCha20 state by 1./// Returns `false` if it overflows, `true` otherwise.ietf_test_vectortest_ietf_chacha20_test_vectorschacha/// Implementation of the ChaCha cryptographic primitives.  /// More details can be seen at https://en.wikipedia.org/wiki/Salsa20SecRandomCopyBytes/// Obtain a series of random bytes./// Obtain a random 64-bit number using WinAPI's `RtlGenRandom` function.backup_entropy/// Obtain a random 64-bit number using WinAPI's `BCryptGenRandom` function./// Pull in system entropy using the [`getrandom`](https://crates.io/crates/getrandom) crate./// Uses backup entropy (rdseed and system time) if it fails.rdseed/// A wrapper function for non-x86(64) platforms that do not have rdseed.backup/// A backup entropy source, trying rdseed first,/// and if it fails or does not complete, combining it with or/// using system time-based entropy generation./// This function panics if sufficient entropy could not be obtained./// Return a random instance of the implementing type, from the specified RNG instance.RandomGen/// A trait used for generating a random object with an RNG,Boundsrandom_range/// Return a ranged number of the implementing type, from the specified RNG instance./// This function will panic if the lower bound of the range is greater than the upper bound.RandomRange/// A trait used for generating a random number within a range, with an RNG,ensure_unsigned_in_rangeensure_signed_in_rangeensure_floats_generate_properlyensure_invalid_range_panicstls_rng/// Provides a buffered wrapper for RNGs, preventing bits from being wasted./// Implementation of cryptography, for CSPRNGs./// Sources for obtaining entropy./// Traits for generating types from an RNG./// RNG algorithms./// Provides a thread-local [`WyRand`] RNG.//! A library meant for fast, random number generation with quick compile time, and minimal dependencies.//! ## Generating a number with an initialized RNG//! use nanorand::{Rng, WyRand};//! let mut rng = WyRand::new();//! println!("Random number: {}", rng.generate::<u64>());//! ## Generating a number with a thread-local RNG//! use nanorand::Rng;//! let mut rng = nanorand::tls_rng();//! ## Generating a number in a range//! println!("Random number between 1 and 100: {}", rng.generate_range(1_u64..=100));//! println!("Random number between -100 and 50: {}", rng.generate_range(-100_i64..=50));//! ### Buffering random bytes//! use nanorand::{Rng, BufferedRng, WyRand};//! let mut thingy = [0u8; 5];//! let mut rng = BufferedRng::new(WyRand::new());//! rng.fill(&mut thingy);//! // As WyRand generates 8 bytes of output, and our target is only 5 bytes,//! // 3 bytes will remain in the buffer.//! assert_eq!(rng.buffered(), 3);//! ## Shuffling a Vec//! let mut items = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];//! rng.shuffle(&mut items);//! ## Why should I use this over...//! * `rand` - The standard rand crate is a complex beast. It contains unsafe code in the core implementations, and while it has much more options than we do, that's kind of the point. We're straight to the point, while rand is everything and the kitchen sink.//! * `fastrand`, `oorandom`, `random-fast-rng`, or `randomize` - These are all minimal, zero-dep implementations of the PCG family of RNGs (Pcg32 and Pcg64). While these are decent, they are _much_ slower than wyrand (which beats the speed of these Pcg32 implementations while providing 64 random bits), and do not provide CSPRNGs.//! * `getrandom` - The getrandom crate just provides OS entropy sources. It is not meant for random number generation. In fact, we provide it as an optional entropy source.//! ## RNG Implementations//! **RNG**|**nanorand type**|**Output Size**|**Cryptographically Secure**|**Speed**<sup>1</sup>|**Notes**|**Original Implementation**//! :-----:|:-----:|:-----:|:-----:|:-----:|:-----:|:-----://! wyrand|[`nanorand::WyRand`](rand/wyrand/struct.WyRand.html), [`nanorand::tls::TlsWyRand`](tls/fn.tls_rng.html)|64 bits (`u64`)|🚫|16.4 GB/s||[https://github.com/lemire/testingRNG/blob/master/source/wyrand.h](https://github.com/lemire/testingRNG/blob/master/source/wyrand.h)//! Pcg64|[`nanorand::Pcg64`](rand/pcg64/struct.Pcg64.html)|64 bits (`u64`)|🚫|1.6 GB/s||[https://github.com/rkern/pcg64](https://github.com/rkern/pcg64)//! ChaCha|[`nanorand::ChaCha`](rand/chacha/struct.ChaCha.html)|512 bits (`[u32; 16]`)|✅|204 MB/s (ChaCha8), 79 MB/s (ChaCha20)|Only works in Rust 1.47 or above|[https://cr.yp.to/chacha.html](https://cr.yp.to/chacha.html)//! <sup>1. Speed benchmarked on an M1 Macbook Air</sup>//! ## Entropy Sources//! _Listed in order of priority_//! * If the `getrandom` feature is enabled, then [`getrandom::getrandom`](https://docs.rs/getrandom/*/getrandom/fn.getrandom.html) will be called, and no other entropy sources will be used.//! * If the `rdseed` feature is enabled, and is running on an x86(-64) system with the [RDSEED](https://en.wikipedia.org/wiki/RDRAND) instruction, then//!   we will attempt to source as much entropy as possible via our [`rdseed_entropy`](entropy::rdseed_entropy) function//! * Linux and Android will attempt to use the [`getrandom`](https://man7.org/linux/man-pages/man2/getrandom.2.html) syscall.//! * macOS and iOS (Darwin-based systems) will use Security.framework's [`SecRandomCopyBytes`](https://developer.apple.com/documentation/security/1399291-secrandomcopybytes).//!   * If we're targeting UWP, then the [`BCryptGenRandom`](https://docs.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptgenrandom) is used with system-preferred RNG (`BCRYPT_USE_SYSTEM_PREFERRED_RNG`).//!   * Otherwise, we'll use [`RtlGenRandom`](https://docs.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom).//! ## Feature Flags//! * `alloc` (default) - Enables Rust `alloc` lib features, such as a buffering Rng wrapper.//! * `std` (default) - Enables Rust `std` lib features, such as seeding from OS entropy sources. Requires `alloc` to be enabled.//! * `tls` (default) - Enables a thread-local [`WyRand`](rand/wyrand/struct.WyRand.html) RNG (see below). Requires `std` to be enabled.//! * `wyrand` (default) - Enable the [`WyRand`](rand/wyrand/struct.WyRand.html) RNG.//! * `pcg64` (default) - Enable the [`Pcg64`](rand/pcg64/struct.Pcg64.html)  RNG.//! * `chacha` - Enable the [`ChaCha`](rand/chacha/struct.ChaCha.html) RNG. Requires Rust 1.47 or later.//! * `rdseed` - On x86 and x86-64 platforms, the `rdseed` intrinsic will be used when OS entropy isn't available.//! * `zeroize` - Implement the [Zeroize](https://crates.io/crates/zeroize) trait for all RNGs.//! * `getrandom` - Use the [`getrandom`](https://crates.io/crates/getrandom) crate as an entropy source. Works on most systems, optional due to the fact that it brings in more dependencies.//! ## MSRV//! The minimum supported Rust version for the latest version of nanorand is **Rust 1.56.0**, released October 21st, 2021.ChaCha/// The ChaCha CSPRNG, with 8 rounds./// The ChaCha CSPRNG, with 12 rounds./// The ChaCha CSPRNG, with 20 rounds./// An instance of the ChaCha random number generator./// Seeded from the system entropy generator when available./// **This generator _is theoretically_ cryptographically secure.**/// Create a new [`ChaCha`] instance, seeding from the system's default source of entropy.new_key/// Create a new [`ChaCha`] instance, using the provided key and nonce.PCG_DEFAULT_MULTIPLIER_128Pcg64/// An instance of the Pcg64 random number generator./// **This generator is _NOT_ cryptographically secure.**/// Create a new [`Pcg64`] instance, seeding from the system's default source of entropy.new_seed/// Create a new [`Pcg64`] instance, using a provided seed.rand128// Based off Robert Kern's C implementation at https://github.com/rkern/pcg64/blob/master/pcg64.c/// An instance of the WyRand random number generator./// Create a new [`WyRand`] instance, seeding from the system's default source of entropy./// Create a new [`WyRand`] instance, using a provided seed.// Based off lemire's wyrand C++ code at https://github.com/lemire/testingRNG/blob/master/source/wyrand.hpcg64wyrand/// Implementation of the wyrand PRNG algorithm./// More details can be seen at <https://github.com/wangyi-fudan/wyhash>/// Implementation of the Pcg64 PRNG algorithm./// More details can be seen at <https://www.pcg-random.org/index.html>/// Implementation of the ChaCha CSPRNG algorithm./// More details can be seen at <https://en.wikipedia.org/wiki/Salsa20>/// Generates a random sequence of bytes, seeding from the internal state.Generated/// Generates a random of the specified type, seeding from the internal state./// Fill an array of bytes with randomness./// Fill an array with the specified type.generate_range/// Shuffle a slice, using the RNG./// A trait that represents a random number generator./// Re-seed the RNG with the specified bytes./// A trait that represents an RNG that can be reseeded from arbitrary bytes.WYRANDTlsWyRand/// Fetch a thread-local [`WyRand`]/// use nanorand::Rng;/// let mut rng = nanorand::tls_rng();/// println!("Random number: {}", rng.generate::<u64>());/// This cannot be passed to another thread, as something like this will fail to compile:///     println!("Random number: {}", rng.generate::<u64>());JOBSERVERx86_triplex86_64_tripleparse_triplecompile_library/// nasm_rs::compile_library("libfoo.a", &["foo.s", "bar.s"]).unwrap();compile_library_args/// nasm_rs::compile_library_args("libfoo.a", &["foo.s", "bar.s"], &["-Fdwarf"]).unwrap();archiver_is_msvcnasmmin_version/// e.g. `"foo.s"`/// Set multiple files/// Add a directory to the `-I` include path/// Pre-define a macro with an optional value/// Configures whether the assembler will generate debug information./// variable by build scripts (only enabled when the profile is "debug"), so/// it's not required to call this function./// Add an arbitrary flag to the invocation of the assembler/// e.g. `"-Fdwarf"`/// Configures the output directory where all object files and static libraries will be located./// This option is automatically scraped from the OUT_DIR environment variable by build scripts,/// so it's not required to call this function./// Configures the default archiver tool as well as the command syntax./// This option is automatically determined from `cfg!(target_env = "msvc")`,/// Configures path to `nasm` command/// Set the minimum version required/// Run the compiler, generating the file output/// The name output should be the base name of the library,/// without file extension, and without "lib" prefix./// The output file will have target-specific name,/// such as `lib*.a` (non-MSVC) or `*.lib` (MSVC)./// Run the compiler, generating .o files/// The files can be linked in a separate step, e.g. passed to `cc`compile_objects_innercompile_fileis_nasm_found_and_new_enough/// Returns version string if nasm is too old,/// or error message string if it's unusable.find_nasmparse_nasm_versiontest_buildtest_parse_nasm_versiontest_parse_tripleErrorStackMessageDigestnidNidpkcs12Pkcs12pkeyPKeysslMidHandshakeSslStreamSslAcceptorSslConnectorSslContextBuilderSslMethodSslVerifyModex509X509StoreBuilderX509VerifyResultX509TlsAcceptorBuilderTlsConnectorBuildersupported_protocolsinit_trustEmptyChainNotPkcs8from_pkcs12from_pkcs8MidHandshakeTlsStreamHandshakeErroruse_sniaccept_invalid_hostnamesaccept_invalid_certsTlsAcceptorSslStreambuffered_read_sizetls_server_end_pointschannelcert_contextCertContextKeySpeccert_storeCertAddCertStorePfxImportOptionscrypt_provAcquireOptionsProviderTypeschannel_credSchannelCredtls_streamSEC_E_NO_CREDENTIALSPROTOCOLSconvert_protocolsgen_container_name// The name of the container must be unique to have multiple active keys.rootsmin_protocolmax_protocoldisable_built_in_rootsnegotiated_alpnpem_blockcur_endPemBlock/// Split data by PEM guard linestest_splitsecurity_frameworksecurity_framework_sysSecCertificateSecIdentityimport_exportImportedIdentityPkcs12ImportOptionsSecRandomsecure_transportClientBuilderSslConnectionTypeSslContextSslProtocolSslProtocolSideerrSecIOerrSecParamPropertyTypeSecCertificateExtcertificate_oidsCertificateOidSecIdentityExtImportOptionsPkcs12ImportOptionsExtSecItemskeychainKeychainSettingsSecKeychainSET_AT_EXITTEMP_KEYCHAINconvert_protocolimport_optionsrandom_passwordClientHandshakeErrorMidHandshakeClientBuilderdanger_accept_invalid_hostnamesdanger_accept_invalid_certsCC_SHA224_DIGEST_LENGTH// FIXME ideally we'd pull these in from elsewhereCC_SHA256_DIGEST_LENGTHCC_SHA384_DIGEST_LENGTHCC_SHA512_DIGEST_LENGTHCC_LONGCC_SHA224CC_SHA256CC_SHA384CC_SHA512"imp/openssl.rs"/// A typedef of the result-type returned by many methods./// An error returned from the TLS implementation./// A cryptographic identity./// An identity is an X509 certificate along with its corresponding private key and chain of certificates to a trusted/// root./// Parses a DER-formatted PKCS #12 archive, using the specified password to decrypt the key./// The archive should contain a leaf certificate and its private key, as well any intermediate/// certificates that should be sent to clients to allow them to build a chain to a trusted/// root. The chain certificates should be in order from the leaf certificate towards the root./// PKCS #12 archives typically have the file extension `.p12` or `.pfx`, and can be created/// with the OpenSSL `pkcs12` tool:/// openssl pkcs12 -export -out identity.pfx -inkey key.pem -in cert.pem -certfile chain_certs.pem/// Parses a chain of PEM encoded X509 certificates, with the leaf certificate first./// `key` is a PEM encoded PKCS #8 formatted private key for the leaf certificate./// The certificate chain should contain any intermediate cerficates that should be sent to/// clients to allow them to build a chain to a trusted root./// A certificate chain here means a series of PEM encoded certificates concatenated together./// An X509 certificate./// Parses a DER-formatted X509 certificate./// Parses a PEM-formatted X509 certificate./// Returns the DER-encoded representation of this certificate./// A TLS stream which has been interrupted midway through the handshake process./// Returns a shared reference to the inner stream./// Returns a mutable reference to the inner stream./// Restarts the handshake process./// If the handshake completes successfully then the negotiated stream is/// returned. If there is a problem, however, then an error is returned./// Note that the error may not be fatal. For example if the underlying/// stream is an asynchronous one then `HandshakeError::WouldBlock` may/// just mean to wait for more I/O to happen later./// A fatal error./// A stream interrupted midway through the handshake process due to a/// `WouldBlock` error./// Note that this is not a fatal error and it should be safe to call/// `handshake` at a later time once the stream is ready to perform I/O/// An error returned from `ClientBuilder::handshake`.Sslv3/// The SSL 3.0 protocol./// SSL 3.0 has severe security flaws, and should not be used unless absolutely necessary. If/// you are not sure if you need to enable this protocol, you should not.Tlsv10/// The TLS 1.0 protocol.Tlsv11/// The TLS 1.1 protocol.Tlsv12/// The TLS 1.2 protocol./// SSL/TLS protocol versions.root_certificates/// A builder for `TlsConnector`s./// You can get one from [`TlsConnector::builder()`](TlsConnector::builder)/// Sets the identity to be used for client certificate authentication.min_protocol_version/// Sets the minimum supported protocol version./// A value of `None` enables support for the oldest protocols supported by the implementation./// Defaults to `Some(Protocol::Tlsv10)`.max_protocol_version/// Sets the maximum supported protocol version./// A value of `None` enables support for the newest protocols supported by the implementation./// Defaults to `None`.add_root_certificate/// Adds a certificate to the set of roots that the connector will trust./// The connector will use the system's trust root by default. This method can be used to add/// to that set when communicating with servers not trusted by the system./// Defaults to an empty set./// Controls the use of built-in system certificates during certificate validation./// Defaults to `false` -- built-in system certs will be used./// Controls the use of certificate validation./// Defaults to `false`./// You should think very carefully before using this method. If invalid certificates are trusted, *any*/// certificate for *any* site will be trusted for use. This includes expired certificates. This introduces/// significant vulnerabilities, and should only be used as a last resort./// Controls the use of Server Name Indication (SNI)./// Controls the use of hostname verification./// You should think very carefully before using this method. If invalid hostnames are trusted, *any* valid/// certificate for *any* site will be trusted for use. This introduces significant vulnerabilities, and should/// only be used as a last resort./// Creates a new `TlsConnector`./// A builder for client-side TLS connections./// use native_tls::TlsConnector;/// use std::io::{Read, Write};/// let connector = TlsConnector::new().unwrap();/// let stream = TcpStream::connect("google.com:443").unwrap();/// let mut stream = connector.connect("google.com", stream).unwrap();/// stream.write_all(b"GET / HTTP/1.0\r\n\r\n").unwrap();/// let mut res = vec![];/// stream.read_to_end(&mut res).unwrap();/// println!("{}", String::from_utf8_lossy(&res));/// Returns a new connector with default settings./// Returns a new builder for a `TlsConnector`./// Initiates a TLS handshake./// The provided domain will be used for both SNI and certificate hostname/// validation./// If the socket is nonblocking and a `WouldBlock` error is returned during/// the handshake, a `HandshakeError::WouldBlock` error will be returned/// which can be used to restart the handshake when the socket is ready/// The domain is ignored if both SNI and hostname verification are/// A builder for `TlsAcceptor`s./// You can get one from [`TlsAcceptor::builder()`](TlsAcceptor::builder)/// Creates a new `TlsAcceptor`./// A builder for server-side TLS connections./// use native_tls::{Identity, TlsAcceptor, TlsStream};/// use std::io::{Read};/// use std::net::{TcpListener, TcpStream};/// let mut file = File::open("identity.pfx").unwrap();/// let mut identity = vec![];/// file.read_to_end(&mut identity).unwrap();/// let identity = Identity::from_pkcs12(&identity, "hunter2").unwrap();/// let listener = TcpListener::bind("0.0.0.0:8443").unwrap();/// let acceptor = TlsAcceptor::new(identity).unwrap();/// let acceptor = Arc::new(acceptor);/// fn handle_client(stream: TlsStream<TcpStream>) {/// for stream in listener.incoming() {///     match stream {///         Ok(stream) => {///             let acceptor = acceptor.clone();///             thread::spawn(move || {///                 let stream = acceptor.accept(stream).unwrap();///                 handle_client(stream);///             });///         Err(e) => { /* connection failed */ }/// Creates a acceptor with default settings./// The identity acts as the server's private key/certificate chain./// Returns a new builder for a `TlsAcceptor`./// A stream managing a TLS session./// Returns the number of bytes that can be read without resulting in any/// network calls./// Returns the peer's leaf certificate, if available./// Returns the tls-server-end-point channel binding data as defined in [RFC 5929]./// [RFC 5929]: https://tools.ietf.org/html/rfc5929/// Shuts down the TLS session._check_kinds//! An abstraction over platform-specific TLS implementations.//! Many applications require TLS/SSL communication in one form or another as//! part of their implementation, but finding a library for this isn't always//! trivial! The purpose of this crate is to provide a seamless integration//! experience on all platforms with a cross-platform API that deals with all//! the underlying details for you.//! # How is this implemented?//! This crate uses SChannel on Windows (via the `schannel` crate), Secure//! Transport on OSX (via the `security-framework` crate), and OpenSSL (via the//! `openssl` crate) on all other platforms. Future features may also enable//! other TLS frameworks as well, but these initial libraries are likely to//! remain as the defaults.//! Note that this crate also strives to be secure-by-default. For example when//! using OpenSSL it will configure validation callbacks to ensure that//! hostnames match certificates, use strong ciphers, etc. This implies that//! this crate is *not* just a thin abstraction around the underlying libraries,//! but also an implementation that strives to strike reasonable defaults.//! This crate supports the following features out of the box://! * TLS/SSL client communication//! * TLS/SSL server communication//! * PKCS#12 encoded identities//! * X.509/PKCS#8 encoded identities//! * Secure-by-default for client and server//!     * Includes hostname verification for clients//! * Supports asynchronous I/O for both the server and the client//! * `vendored` - If enabled, the crate will compile and statically link to a//!     vendored copy of OpenSSL. This feature has no effect on Windows and//!     macOS, where OpenSSL is not used.//! To connect as a client to a remote server://! use native_tls::TlsConnector;//! use std::net::TcpStream;//! let connector = TlsConnector::new().unwrap();//! let stream = TcpStream::connect("google.com:443").unwrap();//! let mut stream = connector.connect("google.com", stream).unwrap();//! stream.write_all(b"GET / HTTP/1.0\r\n\r\n").unwrap();//! let mut res = vec![];//! stream.read_to_end(&mut res).unwrap();//! println!("{}", String::from_utf8_lossy(&res));//! To accept connections as a server from remote clients://! use native_tls::{Identity, TlsAcceptor, TlsStream};//! use std::io::{Read};//! use std::net::{TcpListener, TcpStream};//! let mut file = File::open("identity.pfx").unwrap();//! let mut identity = vec![];//! file.read_to_end(&mut identity).unwrap();//! let identity = Identity::from_pkcs12(&identity, "hunter2").unwrap();//! let listener = TcpListener::bind("0.0.0.0:8443").unwrap();//! let acceptor = TlsAcceptor::new(identity).unwrap();//! let acceptor = Arc::new(acceptor);//! fn handle_client(stream: TlsStream<TcpStream>) {//! for stream in listener.incoming() {//!     match stream {//!         Ok(stream) => {//!             let acceptor = acceptor.clone();//!             thread::spawn(move || {//!                 let stream = acceptor.accept(stream).unwrap();//!                 handle_client(stream);//!         Err(e) => { /* connection failed */ }connect_googleconnect_bad_hostnameconnect_bad_hostname_ignoredconnect_no_root_certsserver_no_root_certscertificate_from_pemserver_tls11_onlyserver_no_shared_protocolserver_untrustedserver_untrusted_unverifiedimport_same_identity_multiple_timesfrom_pkcs8_rejects_rsa_keyserver_pkcs8two_serversrsa_to_pkcs8NixPath/// An open directory./// This is a lower-level interface than `std::fs::ReadDir`. Notable differences:///    * can be opened from a file descriptor (as returned by `openat`, perhaps before knowing///      if the path represents a file or directory).///    * implements `AsRawFd`, so it can be passed to `fstat`, `openat`, etc.///      The file descriptor continues to be owned by the `Dir`, so callers must not keep a `RawFd`///      after the `Dir` is dropped.///    * can be iterated through multiple times without closing and reopening the file///      descriptor. Each iteration rewinds when finished.///    * returns entries for `.` (current directory) and `..` (parent directory).///    * returns entries' names as a `CStr` (no allocation or conversion beyond whatever libc///      does)./// Opens the given path as with `fcntl::open`./// Opens the given path as with `fcntl::openat`./// Converts from a descriptor-based object, closing the descriptor on success or failure./// Converts from a file descriptor, closing it on success or failure./// Returns an iterator of `Result<Entry>` which rewinds when finished.// `Dir` is not `Sync`. With the current implementation, it could be, but according to// https://www.gnu.org/software/libc/manual/html_node/Reading_002fClosing-Directory.html,// future versions of POSIX are likely to obsolete `readdir_r` and specify that it's unsafe to// call `readdir` simultaneously from multiple threads.// `Dir` is safe to pass from one thread to another, as it's not reference-counted./// The return type of [Dir::into_iter]/// Creates a owning iterator, that is, one that takes ownership of the/// `Dir`. The `Dir` cannot be used after calling this.  This can be useful/// when you have a function that both creates a `Dir` instance and returns/// an `Iterator`./// use nix::{dir::Dir, fcntl::OFlag, sys::stat::Mode};/// use std::{iter::Iterator, string::String};/// fn ls_upper(dirname: &str) -> impl Iterator<Item=String> {///     let d = Dir::open(dirname, OFlag::O_DIRECTORY, Mode::S_IXUSR).unwrap();///     d.into_iter().map(|x| x.unwrap().file_name().as_ref().to_string_lossy().to_ascii_uppercase())/// A directory entry, similar to `std::fs::DirEntry`./// Note that unlike the std version, this may represent the `.` or `..` entries.CharacterDevice/// Returns the inode number (`d_ino`) of the underlying `dirent`.// The cast is not unnecessary on all platforms./// Returns the bare file name of this directory entry without any other leading path component./// Returns the type of this directory entry, if known./// See platform `readdir(3)` or `dirent(5)` manpage for when the file type is known;/// notably, some Linux filesystems don't implement this. The caller should use `stat` or/// `fstat` if this returns `None`.ClearEnvError/// Indicates that [`clearenv`] failed for some unknown reason/// Clear the environment of all name-value pairs./// On platforms where libc provides `clearenv()`, it will be used. libc's/// `clearenv()` is documented to return an error code but not set errno; if the/// return value indicates a failure, this function will return/// [`ClearEnvError`]./// On platforms where libc does not provide `clearenv()`, a fallback/// implementation will be used that iterates over all environment variables and/// removes them one-by-one./// This function is not threadsafe and can cause undefined behavior in/// combination with `std::env` or other program components that access the/// environment. See, for example, the discussion on `std::env::remove_var`; this/// function is a case of an "inherently unsafe non-threadsafe API" dealing with/// the environment.///  The caller must ensure no other threads access the process environment while///  this function executes and that no raw pointers to an element of libc's///  `environ` is currently held. The latter is not an issue if the only other///  environment access in the program is via `std::env`, but the requirement on///  thread safety must still be upheld.//! Environment variables/// Sets the platform-specific errno to no-error/// Returns the platform-specific value of errnoas_errno/// Convert this `Error` to an [`Errno`](enum.Errno.html)./// # use nix::Error;/// # use nix::errno::Errno;/// let e = Error::from(Errno::EPERM);/// assert_eq!(Some(Errno::EPERM), e.as_errno());from_errno/// Create a nix Error from a given errnoinvalid_argument/// Create a new invalid argument error (`EINVAL`)ErrnoSentinel/// Returns `Ok(value)` if it does not contain the sentinel value. This/// should not be used when `-1` is not the errno sentinel value./// Backwards compatibility hack for Nix <= 0.21.0 users/// In older versions of Nix, `Error::Sys` was an enum variant.  Now it's a/// function, which is compatible with most of the former use cases of the/// enum variant.  But you should use `Error(Errno::...)` instead./// The sentinel value indicates that a function failed and more detailed/// information about the error can be found in `errno`UnknownErrnouioIoVec// For splice and copy_file_rangelibc_bitflagsAtFlagsr" Configuration options for opened files."r" Mask for the access mode of the file."r" Open the file in append-only mode."r" Generate a signal when input or output becomes possible."r" Closes the file descriptor once an `execve` call is made."r" Also sets the file offset to the beginning of the file."r" Create the file if it does not exist."r" Try to minimize cache effects of the I/O for this file."r" If the specified path isn't a directory, fail."r" Implicitly follow each `write()` with an `fdatasync()`."r" Error out if a file was not created."r" Same as `O_SYNC`."r" Allow files whose sizes can't be represented in an `off_t` to be opened."r" Do not update the file last access time during `read(2)`s."r" Don't attach the device as the process' controlling terminal."r" Same as `O_NONBLOCK`."r" `open()` will fail if the given path is a symbolic link."r" When possible, open the file in nonblocking mode."r" Obtain a file descriptor for low-level access."r" The file itself is not opened and other file operations will fail."r" Only allow reading."r" This should not be combined with `O_WRONLY` or `O_RDWR`."r" Allow both reading and writing."r" This should not be combined with `O_WRONLY` or `O_RDONLY`."r" Similar to `O_DSYNC` but applies to `read`s instead."r" Implicitly follow each `write()` with an `fsync()`."r" Create an unnamed temporary file."r" Truncate an existing regular file to 0 length if it allows writing."r" Only allow writing."r" This should not be combined with `O_RDONLY` or `O_RDWR`."// The conversion is not identical on all operating systems.RenameFlagswrap_readlink_resultreadlink_maybe_atinner_readlinkat_rawfd/// Computes the raw fd consumed by a function of the form `*at`.r" Additional flags for file sealing, which allows for limiting operations on a file."SealFlagr" Prevents further calls to `fcntl()` with `F_ADD_SEALS`."r" The file cannot be reduced in size."r" The size of the file cannot be increased."r" The file contents cannot be modified."r" Additional configuration flags for `fcntl`'s `F_SETFD`."FdFlagr" The file descriptor will automatically be closed during a successful `execve(2)`."FcntlArg// FD_FLAGS// O_NONBLOCK// TODO: Rest of flags// TODO: Figure out how to handle value fcntl returnsFlockArgLockSharedLockExclusiveUnlockLockSharedNonblockLockExclusiveNonblockUnlockNonblockr" Additional flags to `splice` and friends."SpliceFFlagsr" Request that pages be moved instead of copied."r" Not applicable to `vmsplice`."r" Do not block on I/O."r" Hint that more data will be coming in a subsequent splice."r" Gift the user pages to the kernel."r" Not applicable to `splice`."/// Copy a range of data from one file to another/// The `copy_file_range` system call performs an in-kernel copy between/// file descriptors `fd_in` and `fd_out` without the additional cost of/// transferring data from the kernel to user space and then back into the/// kernel. It copies up to `len` bytes of data from file descriptor `fd_in` to/// file descriptor `fd_out`, overwriting any data that exists within the/// requested range of the target file./// If the `off_in` and/or `off_out` arguments are used, the values/// will be mutated to reflect the new position within the file after/// copying. If they are not used, the relevant filedescriptors will be seeked/// to the new position./// On successful completion the number of bytes actually copied will ber" Mode argument flags for fallocate determining operation performed on a given range."FallocateFlagsr" File size is not changed."r" offset + len can be greater than file size."r" Deallocates space by creating a hole."r" Must be ORed with FALLOC_FL_KEEP_SIZE. Byte range starts at offset and continues for len bytes."r" Removes byte range from a file without leaving a hole."r" Byte range to collapse starts at offset and continues for len bytes."r" Zeroes space in specified byte range."r" Byte range starts at offset and continues for len bytes."r" Increases file space by inserting a hole within the file size."r" Does not overwrite existing data. Hole starts at offset and continues for len bytes."r" Shared file data extants are made private to the file."r" Gaurantees that a subsequent write will not fail due to lack of space."/// Manipulates file space./// Allows the caller to directly manipulate the allocated disk space for the/// file referred to by fd.libc_enumPosixFadviseAdvice// For vmspliceVERS_UNKNOWNVERS_2_6_18VERS_2_6_27VERS_2_6_28VERS_3parse_kernel_versionsocket_atomic_cloexec/// Check if the OS supports atomic close-on-exec for socketstest_parsing_kernel_version// Features:// * atomic cloexec on socket: 2.6.27// * pipe2: 2.6.27// * accept4: 2.6.28//! Feature tests for OS functionalityif_/// Name of the network interfaceInterfaceFlags/// Flags as from `SIOCGIFFLAGS` ioctl/// Network address of this interface/// Netmask of this interface/// Broadcast address of this interface, if applicable/// Point-to-point destination address/// Describes a single address for an interface as returned by `getifaddrs`.get_ifu_from_sockaddrfrom_libc_ifaddrs/// Create an `InterfaceAddress` from the libc struct./// Holds the results of `getifaddrs`./// Use the function `getifaddrs` to create this Iterator. Note that the/// actual list of interfaces can be iterated once and will be freed as/// soon as the Iterator goes out of scope./// Get interface addresses using libc's `getifaddrs`/// Note that the underlying implementation differs between OSes. Only the/// most common address families are supported by the nix crate (due to/// lack of time and complexity of testing). The address family is encoded/// in the specific variant of `SockAddr` returned for the fields `address`,/// `netmask`, `broadcast`, and `destination`. For any entry not supported,/// the returned list will contain a `None` entry./// let addrs = nix::ifaddrs::getifaddrs().unwrap();/// for ifaddr in addrs {///   match ifaddr.address {///     Some(address) => {///       println!("interface {} address {}",///                ifaddr.interface_name, address);///       println!("interface {} with unsupported address family",///                ifaddr.interface_name);///   }test_getifaddrs// Only checks if `getifaddrs` can be invoked without panicking.//! Query network interface addresses//! Uses the Linux and/or BSD specific function `getifaddrs` to query the list//! of interfaces and their associated addresses.init_module/// Loads a kernel module from a buffer./// It loads an ELF image into kernel space,/// performs any necessary symbol relocations,/// initializes module parameters to values provided by the caller,/// and then runs the module's init function./// This function requires `CAP_SYS_MODULE` privilege./// The `module_image` argument points to a buffer containing the binary image/// to be loaded. The buffer should contain a valid ELF image/// built for the running kernel./// The `param_values` argument is a string containing space-delimited specifications/// of the values for module parameters./// Each of the parameter specifications has the form:/// `name[=value[,value...]]`/// use nix::kmod::init_module;/// let mut f = File::open("mykernel.ko").unwrap();/// let mut contents: Vec<u8> = Vec::new();/// f.read_to_end(&mut contents).unwrap();/// init_module(&mut contents, &CString::new("who=Rust when=Now,12").unwrap()).unwrap();/// See [`man init_module(2)`](https://man7.org/linux/man-pages/man2/init_module.2.html) for more information.r" Flags used by the `finit_module` function."ModuleInitFlagsr" Ignore symbol version hashes."r" Ignore kernel version magic."finit_module/// Loads a kernel module from a given file descriptor./// use nix::kmod::{finit_module, ModuleInitFlags};/// let f = File::open("mymod.ko").unwrap();/// finit_module(&f, &CString::new("").unwrap(), ModuleInitFlags::empty()).unwrap();r" Flags used by `delete_module`."r" See [`man delete_module(2)`](https://man7.org/linux/man-pages/man2/delete_module.2.html)"r" for a detailed description how these flags work."DeleteModuleFlagsdelete_module/// Unloads the kernel module with the given name./// use nix::kmod::{delete_module, DeleteModuleFlags};/// delete_module(&CString::new("mymod").unwrap(), DeleteModuleFlags::O_NONBLOCK).unwrap();/// See [`man delete_module(2)`](https://man7.org/linux/man-pages/man2/delete_module.2.html) for more information.//! Load and unload kernel modules.//! For more details see"nix""500"// Re-exported external crates// Private internal modules// Public crateskmodmqueueptyscheducontext// This can be implemented for other platforms as soon as libc// provides bindings for them./// Nix Result Type/// Nix's main error type./// It's a wrapper around Errno.  As such, it's very interoperable with/// [`std::io::Error`], but it has the advantages of:/// * `Clone`/// * `Copy`/// * `Eq`/// * Small size/// * Represents all of the system's errnos, instead of just the most common/// ones./// Is the path empty?/// Length of the path in byteswith_nix_path/// Execute a function with this path as a `CStr`./// Mostly used internally by Nix./// Common trait used to represent file system paths by many Nix functions.//! Rust friendly bindings to the various *nix system functions.//! Modules are structured according to the C header file that they would be//! defined in./*
 *
 * ===== Result / Error =====
 *
 *//// The `libc_bitflags!` macro helps with a common use case of defining a public bitflags type/// with values from the libc crate. It is used the same way as the `bitflags!` macro, except/// that only the name of the flag value has to be given./// The `libc` crate must be in scope with the name `libc`./// libc_bitflags!{///     pub struct ProtFlags: libc::c_int {///         PROT_NONE;///         PROT_READ;///         /// PROT_WRITE enables write protect///         PROT_WRITE;///         PROT_EXEC;///         #[cfg(any(target_os = "linux", target_os = "android"))]///         PROT_GROWSDOWN;///         PROT_GROWSUP;/// Example with casting, due to a mistake in libc. In this example, the/// various flags have different types, so we cast the broken ones to the right///     pub struct SaFlags: libc::c_ulong {///         SA_NOCLDSTOP as libc::c_ulong;///         SA_NOCLDWAIT;///         SA_NODEFER as libc::c_ulong;///         SA_ONSTACK;///         SA_RESETHAND as libc::c_ulong;///         SA_RESTART as libc::c_ulong;///         SA_SIGINFO;// Exit rule.// Exit rule including TryFrom// Done accumulating.// Done accumulating and want TryFrom// Munch an attr.// Munch last ident if not followed by a comma.// Munch an ident; covers terminating comma case.// Munch an ident and cast it to the given type; covers terminating comma.// Entry rule.// Entry rule including TryFrom/// The `libc_enum!` macro helps with a common use case of defining an enum exclusively using/// values from the `libc` crate. This macro supports both `pub` and private `enum`s./// libc_enum!{///     pub enum ProtFlags {///         PROT_NONE,///         PROT_READ,///         PROT_WRITE,///         PROT_EXEC,///         PROT_GROWSDOWN,///         PROT_GROWSUP,// Some targets don't use all rules.errmsgNmountError/// The Error type of [`Nmount::nmount`]./// It wraps an [`Errno`], but also may contain an additional message returned/// by `nmount(2)`./// Returns the additional error string sometimes generated by `nmount(2)`./// Returns the inner [`Error`]NmountResult/// Result type of [`Nmount::nmount`].is_ownedNmount/// Mount a FreeBSD file system./// The `nmount(2)` system call works similarly to the `mount(8)` program; it/// takes its options as a series of name-value pairs.  Most of the values are/// strings, as are all of the names.  The `Nmount` structure builds up an/// argument list and then executes the syscall./// To mount `target` onto `mountpoint` with `nullfs`:/// # use nix::unistd::Uid;/// # use ::sysctl::CtlValue;/// # if !Uid::current().is_root() && CtlValue::Int(0) == ::sysctl::value("vfs.usermount").unwrap() {/// #     return;/// use nix::mount::{MntFlags, Nmount, unmount};/// use tempfile::tempdir;/// let mountpoint = tempdir().unwrap();/// let target = tempdir().unwrap();/// let fstype = CString::new("fstype").unwrap();/// let nullfs = CString::new("nullfs").unwrap();/// Nmount::new()///     .str_opt(&fstype, &nullfs)///     .str_opt_owned("fspath", mountpoint.path().to_str().unwrap())///     .str_opt_owned("target", target.path().to_str().unwrap())///     .nmount(MntFlags::empty()).unwrap();/// unmount(mountpoint.path(), MntFlags::empty()).unwrap();/// * [`nmount(2)`](https://www.freebsd.org/cgi/man.cgi?query=nmount)/// * [`nullfs(5)`](https://www.freebsd.org/cgi/man.cgi?query=nullfs)mut_ptr_opt/// Add an opaque mount option./// Some file systems take binary-valued mount options.  They can be set/// with this method./// Unsafe because it will cause `Nmount::nmount` to dereference a raw/// pointer.  The user is responsible for ensuring that `val` is valid and/// its lifetime outlives `self`!  An easy way to do that is to give the/// value a larger scope than `name`/// use libc::c_void;/// use nix::mount::Nmount;/// use std::mem;/// // Note that flags outlives name/// let mut flags: u32 = 0xdeadbeef;/// let name = CString::new("flags").unwrap();/// let p = &mut flags as *mut u32 as *mut c_void;/// let len = mem::size_of_val(&flags);/// let mut nmount = Nmount::new();/// unsafe { nmount.mut_ptr_opt(&name, p, len) };null_opt/// Add a mount option that does not take a value./// let read_only = CString::new("ro").unwrap();///     .null_opt(&read_only);null_opt_owned/// Add a mount option that does not take a value, but whose name must be/// owned./// This has higher runtime cost than [`Nmount::null_opt`], but is useful/// when the name's lifetime doesn't outlive the `Nmount`, or it's a/// different string type than `CStr`./// let read_only = "ro";/// let mut nmount: Nmount<'static> = Nmount::new();/// nmount.null_opt_owned(read_only);str_opt/// Add a mount option as a [`CStr`].///     .str_opt(&fstype, &nullfs);str_opt_owned/// Add a mount option as an owned string./// This has higher runtime cost than [`Nmount::str_opt`], but is useful/// when the value's lifetime doesn't outlive the `Nmount`, or it's a/// let mountpoint = Path::new("/mnt");///     .str_opt_owned("fspath", mountpoint.to_str().unwrap());/// Create a new `Nmount` struct with no optionsMntFlags/// Actually mount the file system./// Unmount the file system mounted at `mountpoint`./// Useful flags include/// * `MNT_FORCE` -     Unmount even if still in use./// * `MNT_BYFSID` -    `mountpoint` is not a path, but a file system ID///                     encoded as `FSID:val0:val1`, where `val0` and `val1`///                     are the contents of the `fsid_t val[]` array in decimal.///                     The file system that has the specified file system ID///                     will be unmounted.  See///                     [`statfs`](crate::sys::statfs::statfs) to determine the///                     `fsid`.MsFlagsr" Mount read-only"r" Ignore suid and sgid bits"r" Disallow access to device special files"r" Disallow program execution"r" Writes are synced at once"r" Alter flags of a mounted FS"r" Allow mandatory locks on a FS"r" Directory modifications are synchronous"r" Do not update access times"r" Do not update directory access times"r" Linux 2.4.0 - Bind directory at different place"//! Mount file systemsMQ_OFlagMqAttrmq_attr_member_t/// Open a message queue/// See also [`mq_open(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_open.html)// The mode.bits cast is only lossless on some OSes/// Remove a message queue/// See also [`mq_unlink(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_unlink.html)/// Close a message queue/// See also [`mq_close(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_close.html)/// Receive a message from a message queue/// See also [`mq_receive(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_receive.html)/// Send a message to a message queue/// See also [`mq_send(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_send.html)/// Get message queue attributes/// See also [`mq_getattr(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_getattr.html)/// Set the attributes of the message queue. Only `O_NONBLOCK` can be set, everything else will be ignored/// Returns the old attributes/// It is recommend to use the `mq_set_nonblock()` and `mq_remove_nonblock()` convenience functions as they are easier to use/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_setattr.html)mq_set_nonblock/// Convenience function./// Sets the `O_NONBLOCK` attribute for a given message queue descriptor// Not useless on all OSesmq_remove_nonblock/// Removes `O_NONBLOCK` attribute for a given message queue descriptor//! Posix Message Queue functions//! [Further reading and details on the C API](https://man7.org/linux/man-pages/man7/mq_overview.7.html)/// Resolve an interface into a interface number.r" Standard interface flags, used by `getifaddrs`"r" Interface is running. (see"r" [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))"r" Valid broadcast address set. (see"r" Internal debugging flag. (see"r" Interface is a loopback interface. (see"r" Interface is a point-to-point link. (see"r" Avoid use of trailers. (see"r" Resources allocated. (see"r" No arp protocol, L2 destination address not set. (see"r" Interface is in promiscuous mode. (see"r" Receive all multicast packets. (see"r" Master of a load balancing bundle. (see"r" Slave of a load balancing bundle. (see"r" Supports multicast. (see"r" Is able to select media type via ifmap. (see"r" Auto media selection active. (see"r" The addresses are lost when the interface goes down. (see"r" Driver signals L1 up. Volatile."r" Driver signals dormant. Volatile."r" Echo sent packets. Volatile."r" Do not provide packet information"r" TUN device (no Ethernet headers)"r" TAP device"/// A network interface. Has a name like "eth0" or "wlp4s0" or "wlan0", as well as an index/// (1, 2, 3, etc) that identifies it in the OS's networking stack./// Obtain the index of this interface./// Obtain the name of this interface./// A list of the network interfaces available on this system. Obtained from [`if_nameindex()`].InterfacesIter/// Iterate over the interfaces in this list./// Convert this to a slice of interfaces. Note that the underlying interfaces list is/// null-terminated, so calling this calculates the length. If random access isn't needed,/// [`Interfaces::iter()`] should be used instead./// An iterator over the interfaces in an [`Interfaces`]./// Retrieve a list of the network interfaces available on the local system./// let interfaces = nix::net::if_::if_nameindex().unwrap();/// for iface in &interfaces {///     println!("Interface #{} is called {}", iface.index(), iface.name().to_string_lossy());//! Network interface name resolution.//! Uses Linux and/or POSIX functions to resolve interface names like "eth0"//! or "socan1" into device numbers.// To avoid clashing with the keyword "if", we use "if_" as the module name.// The original header is called "net/if.h".//! Functionality involving network interfacesTimeSpec/// This is a wrapper around `libc::pollfd`./// It's meant to be used as an argument to the [`poll`](fn.poll.html) and/// [`ppoll`](fn.ppoll.html) functions to specify the events of interest/// for a specific file descriptor./// After a call to `poll` or `ppoll`, the events that occured can be/// retrieved by calling [`revents()`](#method.revents) on the `PollFd`.PollFlags/// Creates a new `PollFd` specifying the events of interest/// for a given file descriptor./// Returns the events that occured in the last call to `poll` or `ppoll`.  Will only return/// `None` if the kernel provides status flags that Nix does not know about./// The events of interest for this `PollFd`./// Modify the events of interest for this `PollFd`.r" These flags define the different events that can be monitored by `poll` and `ppoll`"r" There is data to read."r" There is some exceptional condition on the file descriptor."r" Possibilities include:"r" *  There is out-of-band data on a TCP socket (see"r"    [tcp(7)](https://man7.org/linux/man-pages/man7/tcp.7.html))."r" *  A pseudoterminal master in packet mode has seen a state"r"    change on the slave (see"r"    [ioctl_tty(2)](https://man7.org/linux/man-pages/man2/ioctl_tty.2.html))."r" *  A cgroup.events file has been modified (see"r"    [cgroups(7)](https://man7.org/linux/man-pages/man7/cgroups.7.html))."r" Writing is now possible, though a write larger that the"r" available space in a socket or pipe will still block (unless"r" `O_NONBLOCK` is set)."r" Equivalent to [`POLLIN`](constant.POLLIN.html)"r" Equivalent to [`POLLOUT`](constant.POLLOUT.html)"r" Priority band data can be read (generally unused on Linux)."r" Priority data may be written."r" Error condition (only returned in"r" [`PollFd::revents`](struct.PollFd.html#method.revents);"r" ignored in [`PollFd::new`](struct.PollFd.html#method.new))."r" This bit is also set for a file descriptor referring to the"r" write end of a pipe when the read end has been closed."r" Hang up (only returned in [`PollFd::revents`](struct.PollFd.html#method.revents);"r" Note that when reading from a channel such as a pipe or a stream"r" socket, this event merely indicates that the peer closed its"r" end of the channel.  Subsequent reads from the channel will"r" return 0 (end of file) only after all outstanding data in the"r" Invalid request: `fd` not open (only returned in"/// `poll` waits for one of a set of file descriptors to become ready to perform I/O./// ([`poll(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/poll.html))/// `fds` contains all [`PollFd`](struct.PollFd.html) to poll./// The function will return as soon as any event occur for any of these `PollFd`s./// The `timeout` argument specifies the number of milliseconds that `poll()`/// should block waiting for a file descriptor to become ready.  The call/// will block until either:/// *  a file descriptor becomes ready;/// *  the call is interrupted by a signal handler; or/// *  the timeout expires./// Note that the timeout interval will be rounded up to the system clock/// granularity, and kernel scheduling delays mean that the blocking/// interval may overrun by a small amount.  Specifying a negative value/// in timeout means an infinite timeout.  Specifying a timeout of zero/// causes `poll()` to return immediately, even if no file descriptors are/// `ppoll()` allows an application to safely wait until either a file/// descriptor becomes ready or until a signal is caught./// ([`poll(2)`](https://man7.org/linux/man-pages/man2/poll.2.html))/// `ppoll` behaves like `poll`, but let you specify what signals may interrupt it/// with the `sigmask` argument. If you want `ppoll` to block indefinitely,/// specify `None` as `timeout` (it is like `timeout = -1` for `poll`).//! Wait for events to trigger on specific file descriptorsSessionIdWinsizeForkResult/// The master port in a virtual pty pair/// The slave port in a virtual pty pairOpenptyResult/// Representation of a master/slave pty pair/// This is returned by `openpty`.  Note that this type does *not* implement `Drop`, so the user/// must manually close the file descriptors.fork_result/// Metadata about forked processForkptyResult/// Representation of a master with a forked pty/// This is returned by `forkpty`. Note that this type does *not* implement `Drop`, so the userPtyMaster/// Representation of the Master device in a master/slave pty pair/// While this datatype is a thin wrapper around `RawFd`, it enforces that the available PTY/// functions are given the correct file descriptor. Additionally this type implements `Drop`,/// so that when it's consumed or goes out of scope, it's automatically cleaned-up./// Grant access to a slave pseudoterminal (see/// [`grantpt(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/grantpt.html))/// `grantpt()` changes the mode and owner of the slave pseudoterminal device corresponding to the/// master pseudoterminal referred to by `fd`. This is a necessary step towards opening the slave./// Open a pseudoterminal device (see/// [`posix_openpt(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_openpt.html))/// `posix_openpt()` returns a file descriptor to an existing unused pseuterminal master device./// A common use case with this function is to open both a master and slave PTY pair. This can be/// done as follows:/// use nix::fcntl::{OFlag, open};/// use nix::pty::{grantpt, posix_openpt, ptsname, unlockpt};/// use nix::sys::stat::Mode;/// # fn run() -> nix::Result<()> {/// // Open a new PTY master/// let master_fd = posix_openpt(OFlag::O_RDWR)?;/// // Allow a slave to be generated for it/// grantpt(&master_fd)?;/// unlockpt(&master_fd)?;/// // Get the name of the slave/// let slave_name = unsafe { ptsname(&master_fd) }?;/// // Try to open the slave/// let _slave_fd = open(Path::new(&slave_name), OFlag::O_RDWR, Mode::empty())?;/// Get the name of the slave pseudoterminal (see/// [`ptsname(3)`](https://man7.org/linux/man-pages/man3/ptsname.3.html))/// `ptsname()` returns the name of the slave pseudoterminal device corresponding to the master/// referred to by `fd`./// This value is useful for opening the slave pty once the master has already been opened with/// `posix_openpt()`./// `ptsname()` mutates global variables and is *not* threadsafe./// Mutating global variables is always considered `unsafe` by Rust and this/// function is marked as `unsafe` to reflect that./// For a threadsafe and non-`unsafe` alternative on Linux, see `ptsname_r()`./// `ptsname_r()` returns the name of the slave pseudoterminal device corresponding to the master/// referred to by `fd`. This is the threadsafe version of `ptsname()`, but it is not part of the/// POSIX standard and is instead a Linux-specific extension./// This value is useful for opening the slave ptty once the master has already been opened with/// Unlock a pseudoterminal master/slave pseudoterminal pair (see/// [`unlockpt(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlockpt.html))/// `unlockpt()` unlocks the slave pseudoterminal device corresponding to the master pseudoterminal/// referred to by `fd`. This must be called before trying to open the slave side of a/// pseuoterminal./// Create a new pseudoterminal, returning the slave and master file descriptors/// in `OpenptyResult`/// (see [`openpty`](https://man7.org/linux/man-pages/man3/openpty.3.html))./// If `winsize` is not `None`, the window size of the slave will be set to/// the values in `winsize`. If `termios` is not `None`, the pseudoterminal's/// terminal settings of the slave will be set to the values in `termios`./// Create a new pseudoterminal, returning the master file descriptor and forked pid./// in `ForkptyResult`/// (see [`forkpty`](https://man7.org/linux/man-pages/man3/forkpty.3.html))./// In a multithreaded program, only [async-signal-safe] functions like `pause`/// and `_exit` may be called by the child (the parent isn't restricted). Note/// that memory allocation may **not** be async-signal-safe and thus must be/// prevented./// Those functions are only a small subset of your operating system's API, so/// special care must be taken to only invoke code you can control and audit./// [async-signal-safe]: https://man7.org/linux/man-pages/man7/signal-safety.7.html//! Create master and slave virtual pseudo-terminals (PTYs)sched_linux_liker" Options for use with [`clone`]"CloneFlagsr" The calling process and the child process run in the same"r" memory space."r" The caller and the child process share the same  filesystem"r" The calling process and the child process share the same file"r" descriptor table."r" The calling process and the child process share the same table"r" of signal handlers."r" If the calling process is being traced, then trace the child"r" also."r" The execution of the calling process is suspended until the"r" child releases its virtual memory resources via a call to"r" execve(2) or _exit(2) (as with vfork(2))."r" The parent of the new child  (as returned by getppid(2))"r" will be the same as that of the calling process."r" The child is placed in the same thread group as the calling"r" process."r" The cloned child is started in a new mount namespace."r" The child and the calling process share a single list of System"r" V semaphore adjustment values"r" Unused since Linux 2.6.2"r" A tracing process cannot force `CLONE_PTRACE` on this child"r" Create the process in a new cgroup namespace."r" Create the process in a new UTS namespace."r" Create the process in a new IPC namespace."r" Create the process in a new user namespace."r" Create the process in a new PID namespace."r" Create the process in a new network namespace."r" The new process shares an I/O context with the calling process."// For some functions taking with a parameter of type CloneFlags,// only a subset of these flags have an effect.CloneCb/// Type for the function executed by [`clone`].cpu_setCpuSet/// CpuSet represent a bit-mask of CPUs./// CpuSets are used by sched_setaffinity and/// sched_getaffinity for example./// This is a wrapper around `libc::cpu_set_t`./// Create a new and empty CpuSet./// Test to see if a CPU is in the CpuSet./// `field` is the CPU id to test/// Add a CPU to CpuSet./// `field` is the CPU id to add/// Remove a CPU from CpuSet./// `field` is the CPU id to remove/// Return the maximum number of CPU in CpuSet/// `sched_setaffinity` set a thread's CPU affinity mask/// ([`sched_setaffinity(2)`](https://man7.org/linux/man-pages/man2/sched_setaffinity.2.html))/// `pid` is the thread ID to update./// If pid is zero, then the calling thread is updated./// The `cpuset` argument specifies the set of CPUs on which the thread/// will be eligible to run./// Binding the current thread to CPU 0 can be done as follows:/// use nix::sched::{CpuSet, sched_setaffinity};/// use nix::unistd::Pid;/// let mut cpu_set = CpuSet::new();/// cpu_set.set(0);/// sched_setaffinity(Pid::from_raw(0), &cpu_set);/// `sched_getaffinity` get a thread's CPU affinity mask/// ([`sched_getaffinity(2)`](https://man7.org/linux/man-pages/man2/sched_getaffinity.2.html))/// `pid` is the thread ID to check./// If pid is zero, then the calling thread is checked./// Returned `cpuset` is the set of CPUs on which the thread/// is eligible to run./// Checking if the current thread can run on CPU 0 can be done as follows:/// use nix::sched::sched_getaffinity;/// let cpu_set = sched_getaffinity(Pid::from_raw(0)).unwrap();/// if cpu_set.is_set(0).unwrap() {///     println!("Current thread can run on CPU 0");/// `clone` create a child process/// ([`clone(2)`](https://man7.org/linux/man-pages/man2/clone.2.html))/// `stack` is a reference to an array which will hold the stack of the new/// process.  Unlike when calling `clone(2)` from C, the provided stack/// address need not be the highest address of the region.  Nix will take/// care of that requirement.  The user only needs to provide a reference to/// a normally allocated buffer./// disassociate parts of the process execution context/// See also [unshare(2)](https://man7.org/linux/man-pages/man2/unshare.2.html)/// reassociate thread with a namespace/// See also [setns(2)](https://man7.org/linux/man-pages/man2/setns.2.html)/// Explicitly yield the processor to other threads./// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_yield.html)//! Execution scheduling//! See Also//! [sched.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sched.h.html)r" Mode for `AioCb::fsync`.  Controls whether only data or both data and"r" metadata are synced."AioFsyncModer" do it like `fsync`"r" on supported operating systems only, do it like `fdatasync`"r" When used with [`lio_listio`](fn.lio_listio.html), determines whether a"r" given `aiocb` should be used for a read operation, a write operation, or"r" ignored.  Has no effect for any other aio functions."LioOpcoder" No operation"r" Write data as if by a call to [`AioCb::write`]"r" Write data as if by a call to [`AioCb::read`]"r" Mode for [`lio_listio`](fn.lio_listio.html)"LioModer" Requests that [`lio_listio`](fn.lio_listio.html) block until all"r" requested operations have been completed"r" Requests that [`lio_listio`](fn.lio_listio.html) return immediately"AioCancelStatAioCanceled/// All outstanding requests were canceledAioNotCanceled/// Some requests were not canceled.  Their status should be checked with/// `AioCb::error`AioAllDone/// All of the requests have already finished/// Return values for [`AioCb::cancel`](struct.AioCb.html#method.cancel) and/// [`aio_cancel_all`](fn.aio_cancel_all.html)LibcAiocb/// Newtype that adds Send and Sync to libc::aiocb, which contains raw pointers/// Tracks whether the buffer pointed to by `libc::aiocb.aio_buf` is mutable/// Could this `AioCb` potentially have any in-kernel state?AioCb/// AIO Control Block./// The basic structure used by all aio functions.  Each `AioCb` represents one/// I/O request./// Returns the underlying file descriptor associated with the `AioCb`SigevNotify/// Constructs a new `AioCb` with no associated buffer./// The resulting `AioCb` structure is suitable for use with `AioCb::fsync`./// * `fd`:           File descriptor.  Required for all aio functions./// * `prio`:         If POSIX Prioritized IO is supported, then the///                   operation will be prioritized at the process's///                   priority level minus `prio`./// * `sigev_notify`: Determines how you will be notified of event///                    completion./// Create an `AioCb` from a raw file descriptor and use it for an/// [`fsync`](#method.fsync) operation./// # use nix::sys::aio::*;/// # use nix::sys::signal::SigevNotify::SigevNone;/// # use std::{thread, time};/// # use std::os::unix::io::AsRawFd;/// # use tempfile::tempfile;/// let f = tempfile().unwrap();/// let mut aiocb = AioCb::from_fd( f.as_raw_fd(), 0, SigevNone);/// aiocb.fsync(AioFsyncMode::O_SYNC).expect("aio_fsync failed early");/// while (aiocb.error() == Err(Errno::EINPROGRESS)) {///     thread::sleep(time::Duration::from_millis(10));/// aiocb.aio_return().expect("aio_fsync failed late");from_mut_slice_unpinned// Private helper/// Constructs a new `AioCb` from a mutable slice./// The resulting `AioCb` will be suitable for both read and write/// operations, but only if the borrow checker can guarantee that the slice/// will outlive the `AioCb`.  That will usually be the case if the `AioCb`/// is stack-allocated./// * `offs`:         File offset/// * `buf`:          A memory buffer///                   priority level minus `prio`///                   completion./// * `opcode`:       This field is only used for `lio_listio`.  It///                   determines which operation to use for this individual///                   aiocb/// Create an `AioCb` from a mutable slice and read into it./// # use nix::sys::signal::SigevNotify;/// const INITIAL: &[u8] = b"abcdef123456";/// const LEN: usize = 4;/// let mut rbuf = vec![0; LEN];/// let mut f = tempfile().unwrap();/// f.write_all(INITIAL).unwrap();///     let mut aiocb = AioCb::from_mut_slice( f.as_raw_fd(),///         2,   //offset///         &mut rbuf,///         0,   //priority///         SigevNotify::SigevNone,///         LioOpcode::LIO_NOP);///     aiocb.read().unwrap();///     while (aiocb.error() == Err(Errno::EINPROGRESS)) {///         thread::sleep(time::Duration::from_millis(10));///     assert_eq!(aiocb.aio_return().unwrap() as usize, LEN);/// assert_eq!(rbuf, b"cdef");/// Constructs a new `AioCb` from a mutable raw pointer/// Unlike `from_mut_slice`, this method returns a structure suitable for/// placement on the heap.  It may be used for both reads and writes.  Due/// to its unsafety, this method is not recommended.  It is most useful when/// heap allocation is required./// * `buf`:          Pointer to the memory buffer/// * `len`:          Length of the buffer pointed to by `buf`/// The caller must ensure that the storage pointed to by `buf` outlives the/// `AioCb`.  The lifetime checker can't help here./// Constructs a new `AioCb` from a raw pointer./// Unlike `from_slice`, this method returns a structure suitable for/// placement on the heap.  Due to its unsafety, this method is not/// recommended.  It is most useful when heap allocation is required.from_slice_unpinned/// Like [`AioCb::from_mut_slice`], but works on constant slices rather than/// mutable slices./// An `AioCb` created this way cannot be used with `read`, and its/// `LioOpcode` cannot be set to `LIO_READ`.  This method is useful when/// writing a const buffer with `AioCb::write`, since `from_mut_slice` can't/// work with const buffers./// Construct an `AioCb` from a slice and use it for writing./// const WBUF: &[u8] = b"abcdef123456";/// let mut aiocb = AioCb::from_slice( f.as_raw_fd(),///     2,   //offset///     WBUF,///     0,   //priority///     SigevNotify::SigevNone,///     LioOpcode::LIO_NOP);/// aiocb.write().unwrap();/// assert_eq!(aiocb.aio_return().unwrap() as usize, WBUF.len());// Note: another solution to the problem of writing const buffers would be// to genericize AioCb for both &mut [u8] and &[u8] buffers.  AioCb::read// could take the former and AioCb::write could take the latter.  However,// then lio_listio wouldn't work, because that function needs a slice of// AioCb, and they must all be of the same type.common_initset_sigev_notify/// Update the notification settings for an existing `aiocb`/// Cancels an outstanding AIO request./// The operating system is not required to implement cancellation for all/// file and device types.  Even if it does, there is no guarantee that the/// operation has not already completed.  So the caller must check the/// result and handle operations that were not canceled or that have already/// completed./// Cancel an outstanding aio operation.  Note that we must still call/// `aio_return` to free resources, even though we don't care about the/// result./// let wbuf = b"CDEF";///     &wbuf[..],/// let cs = aiocb.cancel().unwrap();/// if cs == AioCancelStat::AioNotCanceled {/// // Must call `aio_return`, but ignore the result/// let _ = aiocb.aio_return();/// # References/// [aio_cancel](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_cancel.html)error_unpinned/// Retrieve error status of an asynchronous operation./// If the request has not yet completed, returns `EINPROGRESS`.  Otherwise,/// returns `Ok` or any other error./// Issue an aio operation and use `error` to poll for completion.  Polling/// is an alternative to `aio_suspend`, used by most of the other examples./// [aio_error](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_error.html)/// An asynchronous version of `fsync(2)`./// [aio_fsync](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_fsync.html)lio_opcode/// Returns the `aiocb`'s `LioOpcode` field/// If the value cannot be represented as an `LioOpcode`, returns `None`/// Returns the requested length of the aio operation in bytes/// This method returns the *requested* length of the operation.  To get the/// number of bytes actually read or written by a completed operation, use/// `aio_return` instead./// Returns the file offset stored in the `AioCb`/// Returns the priority of the `AioCb`/// Asynchronously reads from a file descriptor into a buffer/// [aio_read](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_read.html)SigEvent/// Returns the `SigEvent` stored in the `AioCb`aio_return_unpinned/// Retrieve return status of an asynchronous operation./// Should only be called once for each `AioCb`, after `AioCb::error`/// indicates that it has completed.  The result is the same as for the/// synchronous `read(2)`, `write(2)`, of `fsync(2)` functions./// [aio_return](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_return.html)// Note: this should be just `return`, but that's a reserved word/// Asynchronously writes from a buffer to a file descriptor/// [aio_write](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_write.html)aio_cancel_all/// Cancels outstanding AIO requests for a given file descriptor./// Issue an aio operation, then cancel all outstanding operations on that file/// let cs = aio_cancel_all(f.as_raw_fd()).unwrap();/// [`aio_cancel`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_cancel.html)/// Suspends the calling process until at least one of the specified `AioCb`s/// has completed, a signal is delivered, or the timeout has passed./// If `timeout` is `None`, `aio_suspend` will block indefinitely./// Use `aio_suspend` to block until an aio operation completes./// aio_suspend(&[aiocb.as_ref()], None).expect("aio_suspend failed");/// [`aio_suspend`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_suspend.html)/// If the `AioCb` has no remaining state in the kernel, just drop it./// Otherwise, dropping constitutes a resource leak, which is an erroraiocbs/// A collection of [`AioCb`]s.  All of these will be issued simultaneously/// by the [`listio`] method./// [`AioCb`]: struct.AioCb.html/// [`listio`]: #method.listio// Their locations in memory must be fixed once they are passed to the// kernel.  So this field must be non-public so the user can't swap./// The actual list passed to `libc::lio_listio`./// It must live for as long as any of the operations are still being/// processesed, because the aio subsystem uses its address as a unique/// A partial set of results.  This field will get populated by/// `listio_resubmit` when an `LioCb` is resubmitted after an errorLioCb/// LIO Control Block./// The basic structure used to issue multiple AIO operations simultaneously./// LioCb can't automatically impl Send and Sync just because of the raw/// pointers in list.  But that's stupid.  There's no reason that raw pointers/// should automatically be non-Send/// Are no [`AioCb`]s contained?/// Return the number of individual [`AioCb`]s contained.listio/// Submits multiple asynchronous I/O requests with a single system call./// They are not guaranteed to complete atomically, and the order in which/// the requests are carried out is not specified.  Reads, writes, and/// fsyncs may be freely mixed./// This function is useful for reducing the context-switch overhead of/// submitting many AIO operations.  It can also be used with/// `LioMode::LIO_WAIT` to block on the result of several independent/// operations.  Used that way, it is often useful in programs that/// otherwise make little use of AIO./// Use `listio` to submit an aio operation and wait for its completion.  In/// this case, there is no need to use [`aio_suspend`] to wait or/// [`AioCb::error`] to poll./// let mut liocb = LioCbBuilder::with_capacity(1)///     .emplace_slice(///         f.as_raw_fd(),///         WBUF,///         LioOpcode::LIO_WRITE///     ).finish();/// liocb.listio(LioMode::LIO_WAIT,///              SigevNotify::SigevNone).unwrap();/// assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());/// [`lio_listio`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lio_listio.html)/// [`aio_suspend`]: fn.aio_suspend.html/// [`AioCb::error`]: struct.AioCb.html#method.errorlistio_resubmit/// Resubmits any incomplete operations with [`lio_listio`]./// Sometimes, due to system resource limitations, an `lio_listio` call will/// return `EIO`, or `EAGAIN`.  Or, if a signal is received, it may return/// `EINTR`.  In any of these cases, only a subset of its constituent/// operations will actually have been initiated.  `listio_resubmit` will/// resubmit any operations that are still uninitiated./// After calling `listio_resubmit`, results should be collected by/// [`LioCb::aio_return`]./// let mut err = liocb.listio(LioMode::LIO_WAIT, SigevNotify::SigevNone);/// while err == Err(Errno::EIO) ||///       err == Err(Errno::EAGAIN) {///     err = liocb.listio_resubmit(LioMode::LIO_WAIT, SigevNotify::SigevNone);/// [`lio_listio`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/lio_listio.html/// [`LioCb::aio_return`]: struct.LioCb.html#method.aio_return// Note: the addresses of any EINPROGRESS or EOK aiocbs _must_ not be// changed by this method, because the kernel relies on their addresses// being stable.// Note: aiocbs that are Ok(()) must be finalized by aio_return, or else the// sigev_notify will immediately refire./// Collect final status for an individual `AioCb` submitted as part of an/// `LioCb`./// This is just like [`AioCb::aio_return`], except it takes into account/// operations that were restarted by [`LioCb::listio_resubmit`]/// [`AioCb::aio_return`]: struct.AioCb.html#method.aio_return/// [`LioCb::listio_resubmit`]: #method.listio_resubmit/// Retrieve error status of an individual `AioCb` submitted as part of an/// This is just like [`AioCb::error`], except it takes into account/// A collection of [`AioCb`]s.LioCbBuilder/// Used to construct `LioCb`// This must be a separate class from LioCb due to pinning constraints.  LioCb// must use a boxed slice of AioCbs so they will have stable storage, but// LioCbBuilder must use a Vec to make construction possible when the final size// is unknown./// Initialize an empty `LioCb`emplace_slice/// Add a new operation on an immutable slice to the [`LioCb`] under/// construction./// Arguments are the same as for [`AioCb::from_slice`]/// [`LioCb`]: struct.LioCb.html/// [`AioCb::from_slice`]: struct.AioCb.html#method.from_sliceemplace_mut_slice/// Add a new operation on a mutable slice to the [`LioCb`] under/// Arguments are the same as for [`AioCb::from_mut_slice`]/// [`AioCb::from_mut_slice`]: struct.AioCb.html#method.from_mut_slice/// Finalize this [`LioCb`]./// Afterwards it will be possible to issue the operations with/// [`LioCb::listio`].  Conversely, it will no longer be possible to add new/// operations with [`LioCbBuilder::emplace_slice`] or/// [`LioCbBuilder::emplace_mut_slice`]./// [`LioCb::listio`]: struct.LioCb.html#method.listio/// [`LioCb::from_mut_slice`]: struct.LioCb.html#method.from_mut_slice/// [`LioCb::from_slice`]: struct.LioCb.html#method.from_sliceliocb_is_unpin// It's important that `LioCb` be `UnPin`.  The tokio-file crate relies on// it.// vim: tw=80//! POSIX Asynchronous I/O//! The POSIX AIO interface is used for asynchronous I/O on files and disk-like//! devices.  It supports [`read`](struct.AioCb.html#method.read),//! [`write`](struct.AioCb.html#method.write), and//! [`fsync`](struct.AioCb.html#method.fsync) operations.  Completion//! notifications can optionally be delivered via//! [signals](../signal/enum.SigevNotify.html#variant.SigevSignal), via the//! [`aio_suspend`](fn.aio_suspend.html) function, or via polling.  Some//! platforms support other completion//! notifications, such as//! [kevent](../signal/enum.SigevNotify.html#variant.SigevKevent).//! Multiple operations may be submitted in a batch with//! [`lio_listio`](fn.lio_listio.html), though the standard does not guarantee//! that they will be executed atomically.//! Outstanding operations may be cancelled with//! [`cancel`](struct.AioCb.html#method.cancel) or//! [`aio_cancel_all`](fn.aio_cancel_all.html), though the operating system may//! not support this for all filesystems and devices.EpollFlagsEpollOpEpollCtlAddEpollCtlDelEpollCtlModEpollCreateFlagsEpollEventKEvent// Redefine kevent in terms of programmer-friendly enums and bitfields.type_of_udatatype_of_datatype_of_event_filtertype_of_event_flag// KEvent can't derive Send because on some operating systems, udata is defined// as a void*.  However, KEvent's public API always treats udata as an intptr_t,// which is safe to Send.EventFilterEventFlagFilterFlagfflagsudatatype_of_nchangeskevent_tsev_settest_struct_keventtest_kevent_filter/* TOOD: Implement for other kqueue based systems
 */EfdFlagsr" Configuration options for [`inotify_add_watch`](fn.inotify_add_watch.html)."AddWatchFlagsr" Configuration options for [`inotify_init1`](fn.inotify_init1.html)."InitFlags/// An inotify instance. This is also a file descriptor, you can feed it to/// other interfaces consuming file descriptors, epoll for example./// This object is returned when you create a new watch on an inotify instance./// It is then returned as part of an event once triggered. It allows you to/// know which watch triggered which event./// Watch descriptor. This field corresponds to the watch descriptor you/// were issued when calling add_watch. It allows you to know which watch/// this event comes from./// Event mask. This field is a bitfield describing the exact event that/// occured./// This cookie is a number that allows you to connect related events. For/// now only IN_MOVED_FROM and IN_MOVED_TO can be connected./// Filename. This field exists only if the event was triggered for a file/// inside the watched directory.InotifyEvent/// A single inotify event./// For more documentation see, [inotify(7)](https://man7.org/linux/man-pages/man7/inotify.7.html)./// Initialize a new inotify instance./// Returns a Result containing an inotify instance./// For more information see, [inotify_init(2)](https://man7.org/linux/man-pages/man2/inotify_init.2.html)./// Adds a new watch on the target file or directory./// Returns a watch descriptor. This is not a File Descriptor!/// For more information see, [inotify_add_watch(2)](https://man7.org/linux/man-pages/man2/inotify_add_watch.2.html)./// Removes an existing watch using the watch descriptor returned by/// inotify_add_watch./// Returns an EINVAL error if the watch descriptor is invalid./// For more information see, [inotify_rm_watch(2)](https://man7.org/linux/man-pages/man2/inotify_rm_watch.2.html)./// Reads a collection of events from the inotify file descriptor. This call/// can either be blocking or non blocking depending on whether IN_NONBLOCK/// was set at initialization./// Returns as many events as available. If the call was non blocking and no/// events could be read then the EAGAIN error is returned.//! Monitoring API for filesystem events.//! Inotify is a Linux-only API to monitor filesystems events.//! For more documentation, please read [inotify(7)](https://man7.org/linux/man-pages/man7/inotify.7.html).//! Monitor all events happening in directory "test"://! # use nix::sys::inotify::{AddWatchFlags,InitFlags,Inotify};//! // We create a new inotify instance.//! let instance = Inotify::init(InitFlags::empty()).unwrap();//! // We add a new watch on directory "test" for all events.//! let wd = instance.add_watch("test", AddWatchFlags::IN_ALL_EVENTS).unwrap();//!     // We read from our inotify instance for events.//!     let events = instance.read_events().unwrap();//!     println!("Events: {:?}", events);ioctl_num_type/// The datatype used for the ioctl number/// The datatype used for the 3rd argumentINOUTiocrequest_code_none/// Generate an ioctl request code for a command that passes no data./// This is equivalent to the `_IO()` macro exposed by the C ioctl API./// You should only use this macro directly if the `ioctl` you're working/// with is "bad" and you cannot use `ioctl_none!()` directly./// # #[macro_use] extern crate nix;/// const KVMIO: u8 = 0xAE;/// ioctl_write_int_bad!(kvm_create_vm, request_code_none!(KVMIO, 0x03));request_code_write_int/// Generate an ioctl request code for a command that passes an integer/// This is equivalent to the `_IOWINT()` macro exposed by the C ioctl API./// with is "bad" and you cannot use `ioctl_write_int!()` directly./// Generate an ioctl request code for a command that reads./// This is equivalent to the `_IOR()` macro exposed by the C ioctl API./// with is "bad" and you cannot use `ioctl_read!()` directly./// The read/write direction is relative to userland, so this/// command would be userland is reading and the kernel isrequest_code_write/// Generate an ioctl request code for a command that writes./// This is equivalent to the `_IOW()` macro exposed by the C ioctl API./// with is "bad" and you cannot use `ioctl_write!()` directly./// command would be userland is writing and the kernel is/// reading.request_code_readwrite/// Generate an ioctl request code for a command that reads and writes./// This is equivalent to the `_IOWR()` macro exposed by the C ioctl API./// with is "bad" and you cannot use `ioctl_readwrite!()` directly.NRBITSTYPEBITSSIZEBITSDIRBITS// "Generic" ioctl protocolNRSHIFTTYPESHIFTSIZESHIFTDIRSHIFTNRMASKTYPEMASKSIZEMASKDIRMASK/// Encode an ioctl command./// Convert raw ioctl return value to a Nix result/// Generates a wrapper function for an ioctl that passes no data to the kernel./// The arguments to this macro are:/// * The function name/// * The ioctl identifier/// * The ioctl sequence number/// The generated function has the following signature:/// pub unsafe fn FUNCTION_NAME(fd: libc::c_int) -> Result<libc::c_int>/// For a more in-depth explanation of ioctls, see [`::sys::ioctl`](sys/ioctl/index.html)./// The `videodev2` driver on Linux defines the `log_status` `ioctl` as:/// #define VIDIOC_LOG_STATUS         _IO('V', 70)/// This can be implemented in Rust like:/// ioctl_none!(log_status, b'V', 70);/// fn main() {}ioctl_none_bad/// Generates a wrapper function for a "bad" ioctl that passes no data to the kernel./// * The ioctl request code/// # use libc::TIOCNXCL;/// ioctl_none_bad!(tiocnxcl, TIOCNXCL);///     let file = File::open("/dev/ttyUSB0").unwrap();///     unsafe { tiocnxcl(file.as_raw_fd()) }.unwrap();// TODO: add an example using request_code_*!()/// Generates a wrapper function for an ioctl that reads data from the kernel./// * The data type passed by this ioctl/// pub unsafe fn FUNCTION_NAME(fd: libc::c_int, data: *mut DATA_TYPE) -> Result<libc::c_int>/// const SPI_IOC_MAGIC: u8 = b'k'; // Defined in linux/spi/spidev.h/// const SPI_IOC_TYPE_MODE: u8 = 1;/// ioctl_read!(spi_read_mode, SPI_IOC_MAGIC, SPI_IOC_TYPE_MODE, u8);ioctl_read_bad/// Generates a wrapper function for a "bad" ioctl that reads data from the kernel./// # #[cfg(any(target_os = "android", target_os = "linux"))]/// ioctl_read_bad!(tcgets, libc::TCGETS, libc::termios);/// Generates a wrapper function for an ioctl that writes data through a pointer to the kernel./// pub unsafe fn FUNCTION_NAME(fd: libc::c_int, data: *const DATA_TYPE) -> Result<libc::c_int>/// # pub struct v4l2_audio {}/// ioctl_write_ptr!(s_audio, b'V', 34, v4l2_audio);ioctl_write_ptr_bad/// Generates a wrapper function for a "bad" ioctl that writes data through a pointer to the kernel./// ioctl_write_ptr_bad!(tcsets, libc::TCSETS, libc::termios);r" Generates a wrapper function for a ioctl that writes an integer to the kernel."r" The arguments to this macro are:"r" * The function name"r" * The ioctl identifier"r" * The ioctl sequence number"r" The generated function has the following signature:"r" ```rust,ignore"r" pub unsafe fn FUNCTION_NAME(fd: libc::c_int, data: nix::sys::ioctl::ioctl_param_type) -> Result<libc::c_int>"r" `nix::sys::ioctl::ioctl_param_type` depends on the OS:"r" *   BSD - `libc::c_int`"r" *   Linux - `libc::c_ulong`"r" For a more in-depth explanation of ioctls, see [`::sys::ioctl`](sys/ioctl/index.html)."r" # #[macro_use] extern crate nix;"r" const HCI_IOC_MAGIC: u8 = b'k';"r" const HCI_IOC_HCIDEVUP: u8 = 1;"r" ioctl_write_int!(hci_dev_up, HCI_IOC_MAGIC, HCI_IOC_HCIDEVUP);"r" # fn main() {}"ioctl_write_int_bad/// Generates a wrapper function for a "bad" ioctl that writes an integer to the kernel./// pub unsafe fn FUNCTION_NAME(fd: libc::c_int, data: libc::c_int) -> Result<libc::c_int>/// ioctl_write_int_bad!(tcsbrk, libc::TCSBRK);/// Generates a wrapper function for an ioctl that reads and writes data to the kernel./// ioctl_readwrite!(enum_audio, b'V', 65, v4l2_audio);ioctl_readwrite_bad/// Generates a wrapper function for a "bad" ioctl that reads and writes data to the kernel.// TODO: Find an example for ioctl_readwrite_bad/// Generates a wrapper function for an ioctl that reads an array of elements from the kernel./// pub unsafe fn FUNCTION_NAME(fd: libc::c_int, data: &mut [DATA_TYPE]) -> Result<libc::c_int>// TODO: Find an example for ioctl_read_buf/// Generates a wrapper function for an ioctl that writes an array of elements to the kernel./// pub unsafe fn FUNCTION_NAME(fd: libc::c_int, data: &[DATA_TYPE]) -> Result<libc::c_int>/// const SPI_IOC_TYPE_MESSAGE: u8 = 0;/// # pub struct spi_ioc_transfer(u64);/// ioctl_write_buf!(spi_transfer, SPI_IOC_MAGIC, SPI_IOC_TYPE_MESSAGE, spi_ioc_transfer);ioctl_readwrite_buf/// Generates a wrapper function for an ioctl that reads and writes an array of elements to the kernel.// TODO: Find an example for readwrite_buf//! Provide helpers for making ioctl system calls.//! This library is pretty low-level and messy. `ioctl` is not fun.//! What is an `ioctl`?//! ===================//! The `ioctl` syscall is the grab-bag syscall on POSIX systems. Don't want to add a new//! syscall? Make it an `ioctl`! `ioctl` refers to both the syscall, and the commands that can be//! sent with it. `ioctl` stands for "IO control", and the commands are always sent to a file//! descriptor.//! It is common to see `ioctl`s used for the following purposes://!   * Provide read/write access to out-of-band data related to a device such as configuration//!     (for instance, setting serial port options)//!   * Provide a mechanism for performing full-duplex data transfers (for instance, xfer on SPI//!     devices).//!   * Provide access to control functions on a device (for example, on Linux you can send//!     commands like pause, resume, and eject to the CDROM device.//!   * Do whatever else the device driver creator thought made most sense.//! `ioctl`s are synchronous system calls and are similar to read and write calls in that regard.//! They operate on file descriptors and have an identifier that specifies what the ioctl is.//! Additionally they may read or write data and therefore need to pass along a data pointer.//! Besides the semantics of the ioctls being confusing, the generation of this identifer can also//! be difficult.//! Historically `ioctl` numbers were arbitrary hard-coded values. In Linux (before 2.6) and some//! unices this has changed to a more-ordered system where the ioctl numbers are partitioned into//! subcomponents (For linux this is documented in//! [`Documentation/ioctl/ioctl-number.rst`](https://elixir.bootlin.com/linux/latest/source/Documentation/userspace-api/ioctl/ioctl-number.rst))://!   * Number: The actual ioctl ID//!   * Type: A grouping of ioctls for a common purpose or driver//!   * Size: The size in bytes of the data that will be transferred//!   * Direction: Whether there is any data and if it's read, write, or both//! Newer drivers should not generate complete integer identifiers for their `ioctl`s instead//! preferring to use the 4 components above to generate the final ioctl identifier. Because of//! how old `ioctl`s are, however, there are many hard-coded `ioctl` identifiers. These are//! commonly referred to as "bad" in `ioctl` documentation.//! Defining `ioctl`s//! =================//! This library provides several `ioctl_*!` macros for binding `ioctl`s. These generate public//! unsafe functions that can then be used for calling the ioctl. This macro has a few different//! ways it can be used depending on the specific ioctl you're working with.//! A simple `ioctl` is `SPI_IOC_RD_MODE`. This ioctl works with the SPI interface on Linux. This//! specific `ioctl` reads the mode of the SPI device as a `u8`. It's declared in//! `/include/uapi/linux/spi/spidev.h` as `_IOR(SPI_IOC_MAGIC, 1, __u8)`. Since it uses the `_IOR`//! macro, we know it's a `read` ioctl and can use the `ioctl_read!` macro as follows://! # #[macro_use] extern crate nix;//! const SPI_IOC_MAGIC: u8 = b'k'; // Defined in linux/spi/spidev.h//! const SPI_IOC_TYPE_MODE: u8 = 1;//! ioctl_read!(spi_read_mode, SPI_IOC_MAGIC, SPI_IOC_TYPE_MODE, u8);//! This generates the function://! # use std::mem;//! # use nix::{libc, Result};//! # use nix::errno::Errno;//! # use nix::libc::c_int as c_int;//! # const SPI_IOC_MAGIC: u8 = b'k'; // Defined in linux/spi/spidev.h//! # const SPI_IOC_TYPE_MODE: u8 = 1;//! pub unsafe fn spi_read_mode(fd: c_int, data: *mut u8) -> Result<c_int> {//!     let res = libc::ioctl(fd, request_code_read!(SPI_IOC_MAGIC, SPI_IOC_TYPE_MODE, mem::size_of::<u8>()), data);//!     Errno::result(res)//! The return value for the wrapper functions generated by the `ioctl_*!` macros are `nix::Error`s.//! These are generated by assuming the return value of the ioctl is `-1` on error and everything//! else is a valid return value. If this is not the case, `Result::map` can be used to map some//! of the range of "good" values (-Inf..-2, 0..Inf) into a smaller range in a helper function.//! Writing `ioctl`s generally use pointers as their data source and these should use the//! `ioctl_write_ptr!`. But in some cases an `int` is passed directly. For these `ioctl`s use the//! `ioctl_write_int!` macro. This variant does not take a type as the last argument://! const HCI_IOC_MAGIC: u8 = b'k';//! const HCI_IOC_HCIDEVUP: u8 = 1;//! ioctl_write_int!(hci_dev_up, HCI_IOC_MAGIC, HCI_IOC_HCIDEVUP);//! Some `ioctl`s don't transfer any data, and those should use `ioctl_none!`. This macro//! doesn't take a type and so it is declared similar to the `write_int` variant shown above.//! The mode for a given `ioctl` should be clear from the documentation if it has good//! documentation. Otherwise it will be clear based on the macro used to generate the `ioctl`//! number where `_IO`, `_IOR`, `_IOW`, and `_IOWR` map to "none", "read", "write_*", and "readwrite"//! respectively. To determine the specific `write_` variant to use you'll need to find//! what the argument type is supposed to be. If it's an `int`, then `write_int` should be used,//! otherwise it should be a pointer and `write_ptr` should be used. On Linux the//! [`ioctl_list` man page](https://man7.org/linux/man-pages/man2/ioctl_list.2.html) describes a//! large number of `ioctl`s and describes their argument data type.//! Using "bad" `ioctl`s//! --------------------//! As mentioned earlier, there are many old `ioctl`s that do not use the newer method of//! generating `ioctl` numbers and instead use hardcoded values. These can be used with the//! `ioctl_*_bad!` macros. This naming comes from the Linux kernel which refers to these//! `ioctl`s as "bad". These are a different variant as they bypass calling the macro that generates//! the ioctl number and instead use the defined value directly.//! For example the `TCGETS` `ioctl` reads a `termios` data structure for a given file descriptor.//! It's defined as `0x5401` in `ioctls.h` on Linux and can be implemented as://! # #[cfg(any(target_os = "android", target_os = "linux"))]//! # use nix::libc::TCGETS as TCGETS;//! # use nix::libc::termios as termios;//! ioctl_read_bad!(tcgets, TCGETS, termios);//! The generated function has the same form as that generated by `ioctl_read!`://! pub unsafe fn tcgets(fd: c_int, data: *mut termios) -> Result<c_int>;//! Working with Arrays//! -------------------//! Some `ioctl`s work with entire arrays of elements. These are supported by the `ioctl_*_buf`//! family of macros: `ioctl_read_buf`, `ioctl_write_buf`, and `ioctl_readwrite_buf`. Note that//! there are no "bad" versions for working with buffers. The generated functions include a `len`//! argument to specify the number of elements (where the type of each element is specified in the//! macro).//! Again looking to the SPI `ioctl`s on Linux for an example, there is a `SPI_IOC_MESSAGE` `ioctl`//! that queues up multiple SPI messages by writing an entire array of `spi_ioc_transfer` structs.//! `linux/spi/spidev.h` defines a macro to calculate the `ioctl` number like://! ```C//! #define SPI_IOC_MAGIC 'k'//! #define SPI_MSGSIZE(N) ...//! #define SPI_IOC_MESSAGE(N) _IOW(SPI_IOC_MAGIC, 0, char[SPI_MSGSIZE(N)])//! The `SPI_MSGSIZE(N)` calculation is already handled by the `ioctl_*!` macros, so all that's//! needed to define this `ioctl` is://! const SPI_IOC_TYPE_MESSAGE: u8 = 0;//! # pub struct spi_ioc_transfer(u64);//! ioctl_write_buf!(spi_transfer, SPI_IOC_MAGIC, SPI_IOC_TYPE_MESSAGE, spi_ioc_transfer);//! This generates a function like://! # const SPI_IOC_MAGIC: u8 = b'k';//! # const SPI_IOC_TYPE_MESSAGE: u8 = 0;//! pub unsafe fn spi_message(fd: c_int, data: &mut [spi_ioc_transfer]) -> Result<c_int> {//!     let res = libc::ioctl(fd,//!                           request_code_write!(SPI_IOC_MAGIC, SPI_IOC_TYPE_MESSAGE, data.len() * mem::size_of::<spi_ioc_transfer>()),//!                           data);//! Finding `ioctl` Documentation//! -----------------------------//! For Linux, look at your system's headers. For example, `/usr/include/linux/input.h` has a lot//! of lines defining macros which use `_IO`, `_IOR`, `_IOW`, `_IOC`, and `_IOWR`. Some `ioctl`s are//! documented directly in the headers defining their constants, but others have more extensive//! documentation in man pages (like termios' `ioctl`s which are in `tty_ioctl(4)`).//! Documenting the Generated Functions//! ===================================//! In many cases, users will wish for the functions generated by the `ioctl`//! macro to be public and documented. For this reason, the generated functions//! are public by default. If you wish to hide the ioctl, you will need to put//! them in a private module.//! For documentation, it is possible to use doc comments inside the `ioctl_*!` macros. Here is an//! example ://! # use nix::libc::c_int;//! ioctl_read! {//!     /// Make the given terminal the controlling terminal of the calling process. The calling//!     /// process must be a session leader and not have a controlling terminal already. If the//!     /// terminal is already the controlling terminal of a different session group then the//!     /// ioctl will fail with **EPERM**, unless the caller is root (more precisely: has the//!     /// **CAP_SYS_ADMIN** capability) and arg equals 1, in which case the terminal is stolen//!     /// and all processes that had it as controlling terminal lose it.//!     tiocsctty, b't', 19, c_intr" Options that change the behavior of [`memfd_create`]."MemFdCreateFlagr" Set the close-on-exec ([`FD_CLOEXEC`]) flag on the new file descriptor."r" By default, the new file descriptor is set to remain open across an [`execve`]"r" (the `FD_CLOEXEC` flag is initially disabled). This flag can be used to change"r" this default. The file offset is set to the beginning of the file (see [`lseek`])."r" See also the description of the `O_CLOEXEC` flag in [`open(2)`]."r" [`execve`]: crate::unistd::execve"r" [`lseek`]: crate::unistd::lseek"r" [`FD_CLOEXEC`]: crate::fcntl::FdFlag::FD_CLOEXEC"r" [`open(2)`]: https://man7.org/linux/man-pages/man2/open.2.html"r" Allow sealing operations on this file."r" See also the file sealing notes given in [`memfd_create(2)`]."r" [`memfd_create(2)`]: https://man7.org/linux/man-pages/man2/memfd_create.2.html"/// Creates an anonymous file that lives in memory, and return a file-descriptor to it./// The file behaves like a regular file, and so can be modified, truncated, memory-mapped, and so on./// However, unlike a regular file, it lives in RAM and has a volatile backing storage./// For more information, see [`memfd_create(2)`]./// [`memfd_create(2)`]: https://man7.org/linux/man-pages/man2/memfd_create.2.html//! Interfaces for managing memory-backed files.r" Desired memory protection of a memory mapping."ProtFlagsr" Pages cannot be accessed."r" Pages can be read."r" Pages can be written."r" Pages can be executed"r" Apply protection up to the end of a mapping that grows upwards."r" Apply protection down to the beginning of a mapping that grows downwards."r" Additional parameters for [`mmap`]."MapFlagsr" Compatibility flag. Ignored."r" Share this mapping. Mutually exclusive with `MAP_PRIVATE`."r" Create a private copy-on-write mapping. Mutually exclusive with `MAP_SHARED`."r" Place the mapping at exactly the address specified in `addr`."r" Synonym for `MAP_ANONYMOUS`."r" The mapping is not backed by any file."r" Put the mapping into the first 2GB of the process address space."r" Used for stacks; indicates to the kernel that the mapping should extend downward in memory."r" Mark the mmaped region to be locked in the same way as `mlock(2)`."r" Do not reserve swap space for this mapping."r" This was removed in FreeBSD 11 and is unused in DragonFlyBSD."r" Populate page tables for a mapping."r" Only meaningful when used with `MAP_POPULATE`. Don't perform read-ahead."r#" Allocate the mapping using "huge pages.""#r" Make use of 64KB huge page (must be supported by the system)"r" Make use of 512KB huge page (must be supported by the system)"r" Make use of 1MB huge page (must be supported by the system)"r" Make use of 2MB huge page (must be supported by the system)"r" Make use of 8MB huge page (must be supported by the system)"r" Make use of 16MB huge page (must be supported by the system)"r" Make use of 32MB huge page (must be supported by the system)"r" Make use of 256MB huge page (must be supported by the system)"r" Make use of 512MB huge page (must be supported by the system)"r" Make use of 1GB huge page (must be supported by the system)"r" Make use of 2GB huge page (must be supported by the system)"r" Make use of 16GB huge page (must be supported by the system)"r" Region grows down, like a stack."r" Options for [`mremap`]."MRemapFlagsr" Permit the kernel to relocate the mapping to a new virtual address, if necessary."r" Place the mapping at exactly the address specified in `new_address`."r" Usage information for a range of memory to allow for performance optimizations by the kernel."r" Used by [`madvise`]."MmapAdviser" No further special treatment. This is the default."r" Expect random page references."r" Expect sequential page references."r" Expect access in the near future."r" Do not expect access in the near future."r" Free up a given range of pages and its associated backing store."r" Do not make pages in this range available to the child after a `fork(2)`."r" Undo the effect of `MADV_DONTFORK`."r" Poison the given pages."r" Subsequent references to those pages are treated like hardware memory corruption."r" Enable Kernel Samepage Merging (KSM) for the given pages."r" Undo the effect of `MADV_MERGEABLE`"r" Preserve the memory of each page but offline the original page."r" Enable Transparent Huge Pages (THP) for pages in the given range."r" Undo the effect of `MADV_HUGEPAGE`."r" Exclude the given range from a core dump."r" Undo the effect of an earlier `MADV_DONTDUMP`."r" Specify that the application no longer needs the pages in the given range."r" Configuration flags for [`msync`]."r" Schedule an update but return immediately."r" Invalidate all cached data."r" Perform an update and wait for it to complete."r" Flags for [`mlockall`]."MlockAllFlagsr" Lock pages that are currently mapped into the address space of the process."r" Lock pages which will become mapped into the address space of the process in the future."/// Locks all memory pages that contain part of the address range with `length`/// bytes starting at `addr`./// Locked pages never move to the swap area./// `addr` must meet all the requirements described in the [`mlock(2)`] man page./// [`mlock(2)`]: https://man7.org/linux/man-pages/man2/mlock.2.html/// Unlocks all memory pages that contain part of the address range with/// `length` bytes starting at `addr`./// `addr` must meet all the requirements described in the [`munlock(2)`] man/// page./// [`munlock(2)`]: https://man7.org/linux/man-pages/man2/munlock.2.html/// Locks all memory pages mapped into this process' address space./// Locked pages never move to the swap area. For more information, see [`mlockall(2)`]./// [`mlockall(2)`]: https://man7.org/linux/man-pages/man2/mlockall.2.html/// Unlocks all memory pages mapped into this process' address space./// For more information, see [`munlockall(2)`]./// [`munlockall(2)`]: https://man7.org/linux/man-pages/man2/munlockall.2.html/// allocate memory, or map files or devices into memory/// See the [`mmap(2)`] man page for detailed requirements./// [`mmap(2)`]: https://man7.org/linux/man-pages/man2/mmap.2.html/// Expands (or shrinks) an existing memory mapping, potentially moving it at/// the same time./// See the `mremap(2)` [man page](https://man7.org/linux/man-pages/man2/mremap.2.html) for/// detailed requirements./// remove a mapping/// `addr` must meet all the requirements described in the [`munmap(2)`] man/// [`munmap(2)`]: https://man7.org/linux/man-pages/man2/munmap.2.html/// give advice about use of memory/// See the [`madvise(2)`] man page.  Take special care when using/// [`MmapAdvise::MADV_FREE`]./// [`madvise(2)`]: https://man7.org/linux/man-pages/man2/madvise.2.html/// Set protection of memory mapping./// See [`mprotect(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mprotect.html) for/// Calls to `mprotect` are inherently unsafe, as changes to memory protections can lead to/// SIGSEGVs./// # use nix::libc::size_t;/// # use nix::sys::mman::{mmap, mprotect, MapFlags, ProtFlags};/// # use std::ptr;/// const ONE_K: size_t = 1024;/// let mut slice: &mut [u8] = unsafe {///     let mem = mmap(ptr::null_mut(), ONE_K, ProtFlags::PROT_NONE,///                    MapFlags::MAP_ANON | MapFlags::MAP_PRIVATE, -1, 0).unwrap();///     mprotect(mem, ONE_K, ProtFlags::PROT_READ | ProtFlags::PROT_WRITE).unwrap();///     std::slice::from_raw_parts_mut(mem as *mut u8, ONE_K)/// assert_eq!(slice[0], 0x00);/// slice[0] = 0xFF;/// assert_eq!(slice[0], 0xFF);/// synchronize a mapped region/// `addr` must meet all the requirements described in the [`msync(2)`] man/// [`msync(2)`]: https://man7.org/linux/man-pages/man2/msync.2.html/// Creates and opens a new, or opens an existing, POSIX shared memory object./// For more information, see [`shm_open(3)`]./// [`shm_open(3)`]: https://man7.org/linux/man-pages/man3/shm_open.3.html/// Performs the converse of [`shm_open`], removing an object previously created./// For more information, see [`shm_unlink(3)`]./// [`shm_unlink(3)`]: https://man7.org/linux/man-pages/man3/shm_unlink.3.html//! Memory management declarations.aiomemfdmmanpthreadquotatimerfd//! Mostly platform-specific functionalityr" Flags used and returned by [`get()`](fn.get.html) and"r" [`set()`](fn.set.html)."Persona/// Retrieve the current process personality./// Returns a Result containing a Persona instance./// # use nix::sys::personality::{self, Persona};/// let pers = personality::get().unwrap();/// assert!(!pers.contains(Persona::WHOLE_SECONDS));/// Set the current process personality./// Returns a Result containing the *previous* personality for the/// process, as a Persona./// For more information, see [personality(2)](https://man7.org/linux/man-pages/man2/personality.2.html)/// **NOTE**: This call **replaces** the current personality entirely./// To **update** the personality, first call `get()` and then `set()`/// with the modified persona./// let mut pers = personality::get().unwrap();/// assert!(!pers.contains(Persona::ADDR_NO_RANDOMIZE));/// personality::set(pers | Persona::ADDR_NO_RANDOMIZE);Pthread/// Identifies an individual thread./// Obtain ID of the calling thread (see/// [`pthread_self(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_self.html)/// The thread ID returned by `pthread_self()` is not the same thing as/// the kernel thread ID returned by a call to `gettid(2)`./// Send a signal to a thread (see [`pthread_kill(3)`])./// If `signal` is `None`, `pthread_kill` will only preform error checking and/// won't send any signal./// [`pthread_kill(3)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_kill.html//! Low level threading primitivesRequestTypeptrace_otherAddressTypetraceme/// Sets the process as traceable, as with `ptrace(PT_TRACEME, ...)`/// Indicates that this process is to be traced by its parent./// This is the only ptrace request to be issued by the tracee./// Attach to a running process, as with `ptrace(PT_ATTACH, ...)`/// Attaches to the process specified by `pid`, making it a tracee of the calling process./// Detaches the current running process, as with `ptrace(PT_DETACH, ...)`/// Detaches from the process specified by `pid` allowing it to run freely, optionally delivering a/// signal specified by `sig`.cont/// Restart the stopped tracee process, as with `ptrace(PTRACE_CONT, ...)`/// Continues the execution of the process with PID `pid`, optionally/// delivering a signal specified by `sig`./// Issues a kill request as with `ptrace(PT_KILL, ...)`/// This request is equivalent to `ptrace(PT_CONTINUE, ..., SIGKILL);` /// Move the stopped tracee process forward by a single step as with/// `ptrace(PT_STEP, ...)`/// Advances the execution of the process with PID `pid` by a single step optionally delivering a/// use nix::sys::ptrace::step;/// use nix::sys::signal::Signal;/// use nix::sys::wait::*;/// // If a process changes state to the stopped state because of a SIGUSR1/// // signal, this will step the process forward and forward the user/// // signal to the stopped process/// match waitpid(Pid::from_raw(-1), None) {///     Ok(WaitStatus::Stopped(pid, Signal::SIGUSR1)) => {///         let _ = step(pid, Signal::SIGUSR1);/// Reads a word from a processes memory at the given address// Technically, ptrace doesn't dereference the pointer.  It passes it directly// to the kernel./// Writes a word into the processes memory at the given addressr" Ptrace Request enum defining the action to be taken."r" Using the ptrace options the tracer can configure the tracee to stop"r" at certain events. This enum is used to define those events as defined"r" in `man ptrace`."r" Event that stops before a return from fork or clone."r" Event that stops before a return from vfork or clone."r" Event that stops before a return from clone."r" Event that stops before a return from execve."r" Event for a return from vfork."r" Event for a stop before an exit. Unlike the waitpid Exit status program."r" registers can still be examined"r" Stop triggered by a seccomp rule on a tracee."r" Stop triggered by the `INTERRUPT` syscall, or a group stop,"r" or when a new child is attached."r" Ptrace options used in conjunction with the PTRACE_SETOPTIONS request."r" See `man ptrace` for more details."r" When delivering system call traps set a bit to allow tracer to"r" distinguish between normal stops or syscall stops. May not work on"r" all systems."r" Stop tracee at next fork and start tracing the forked process."r" Stop tracee at next vfork call and trace the vforked process."r" Stop tracee at next clone call and trace the cloned process."r" Stop tracee at next execve call."r" Stop tracee at vfork completion."r" Stop tracee at next exit call. Stops before exit commences allowing"r" tracer to see location of exit and register states."r" Stop tracee when a SECCOMP_RET_TRACE rule is triggered. See `man seccomp` for more"r" details."r" Send a SIGKILL to the tracee if the tracer exits.  This is useful"r" for ptrace jailers to prevent tracees from escaping their control."ptrace_peekgetregs/// Get user registers, as with `ptrace(PTRACE_GETREGS, ...)`setregs/// Set user registers, as with `ptrace(PTRACE_SETREGS, ...)`ptrace_get_data/// Function for ptrace requests that return values from the data field./// Some ptrace get requests populate structs or larger elements than `c_long`/// and therefore use the data field to return values. This function handles thesesetoptions/// Set options, as with `ptrace(PTRACE_SETOPTIONS,...)`.getevent/// Gets a ptrace event as described by `ptrace(PTRACE_GETEVENTMSG,...)`getsiginfo/// Get siginfo as with `ptrace(PTRACE_GETSIGINFO,...)`setsiginfo/// Set siginfo as with `ptrace(PTRACE_SETSIGINFO,...)`/// Sets the process as traceable, as with `ptrace(PTRACE_TRACEME, ...)`/// Continue execution until the next syscall, as with `ptrace(PTRACE_SYSCALL, ...)`/// Arranges for the tracee to be stopped at the next entry to or exit from a system call,/// optionally delivering a signal specified by `sig`.sysemu/// Continue execution until the next syscall, as with `ptrace(PTRACE_SYSEMU, ...)`/// In contrast to the `syscall` function, the syscall stopped at will not be executed./// Thus the the tracee will only be stopped once per syscall,/// Attach to a running process, as with `ptrace(PTRACE_ATTACH, ...)`seize/// Attach to a running process, as with `ptrace(PTRACE_SEIZE, ...)`/// Attaches to the process specified in pid, making it a tracee of the calling process./// Detaches the current running process, as with `ptrace(PTRACE_DETACH, ...)`/// Stop a tracee, as with `ptrace(PTRACE_INTERRUPT, ...)`/// This request is equivalent to `ptrace(PTRACE_INTERRUPT, ...)`/// Issues a kill request as with `ptrace(PTRACE_KILL, ...)`/// This request is equivalent to `ptrace(PTRACE_CONT, ..., SIGKILL);`/// `ptrace(PTRACE_SINGLESTEP, ...)`sysemu_step/// Move the stopped tracee process forward by a single step or stop at the next syscall/// as with `ptrace(PTRACE_SYSEMU_SINGLESTEP, ...)`/// Advances the execution by a single step or until the next syscall./// In case the tracee is stopped at a syscall, the syscall will not be executed./// Optionally, the signal specified by `sig` is delivered to the tracee upon continuation./// The `data` argument is passed directly to `ptrace(2)`.  Read that man page/// for guidance.//! For detailed description of the ptrace requests, consult `man ptrace`.///! Provides helpers for making ptrace system calls QuotaSubCmdQuotaTypeQuotaCmd// linux quota version >= 2r" The scope of the quota."r" Specify a user quota"r" Specify a group quota"r" The type of quota format to use."QuotaFmtr" Use the original quota format."r" Use the standard VFS v0 quota format."r" Handles 32-bit UIDs/GIDs and quota limits up to 2<sup>32</sup> bytes/2<sup>32</sup> inodes."r" Use the VFS v1 quota format."r" Handles 32-bit UIDs/GIDs and quota limits of 2<sup>64</sup> bytes/2<sup>64</sup> inodes."r" Indicates the quota fields that are valid to read from."QuotaValidFlagsr" The block hard & soft limit fields."r" The current space field."r" The inode hard & soft limit fields."r" The current inodes field."r" The disk use time limit field."r" The file quote time limit field."r" All block & inode limits."r" The space & inodes usage fields."r" The time limit fields."r" All fields."Dqblk/// Wrapper type for `if_dqblk`blocks_hard_limit/// The absolute limit on disk quota blocks allocated.set_blocks_hard_limit/// Set the absolute limit on disk quota blocks allocated.blocks_soft_limit/// Preferred limit on disk quota blocksset_blocks_soft_limit/// Set the preferred limit on disk quota blocks allocated.occupied_space/// Current occupied space (bytes).inodes_hard_limit/// Maximum number of allocated inodes.set_inodes_hard_limit/// Set the maximum number of allocated inodes.inodes_soft_limit/// Preferred inode limitset_inodes_soft_limit/// Set the preferred limit of allocated inodes.allocated_inodes/// Current number of allocated inodes.block_time_limit/// Time limit for excessive disk use.set_block_time_limit/// Set the time limit for excessive disk use.inode_time_limit/// Time limit for excessive files.set_inode_time_limit/// Set the time limit for excessive files.quotactl_on/// Turn on disk quotas for a block device.quotactl_off/// Disable disk quotas for a block device.quotactl_sync/// Update the on-disk copy of quota usages for a filesystem./// If `special` is `None`, then all file systems with active quotas are sync'd.quotactl_get/// Get disk quota limits and current usage for the given user/group id.quotactl_set/// Configure quota values for the specified fields for a given user/group id.//! Set and configure disk quotas for users, groups, or projects.//! Enabling and setting a quota://! # use nix::sys::quota::{Dqblk, quotactl_on, quotactl_set, QuotaFmt, QuotaType, QuotaValidFlags};//! quotactl_on(QuotaType::USRQUOTA, "/dev/sda1", QuotaFmt::QFMT_VFS_V1, "aquota.user");//! let mut dqblk: Dqblk = Default::default();//! dqblk.set_blocks_hard_limit(10000);//! dqblk.set_blocks_soft_limit(8000);//! quotactl_set(QuotaType::USRQUOTA, "/dev/sda1", 50, &dqblk, QuotaValidFlags::QIF_BLIMITS);r" How exactly should the system be rebooted."r" See [`set_cad_enabled()`](fn.set_cad_enabled.html) for"r" enabling/disabling Ctrl-Alt-Delete."RebootModeset_cad_enabled/// Enable or disable the reboot keystroke (Ctrl-Alt-Delete)./// Corresponds to calling `reboot(RB_ENABLE_CAD)` or `reboot(RB_DISABLE_CAD)` in C.//! Reboot/shutdown or enable/disable Ctrl-Alt-Delete.r" The Resource enum is platform dependent. Check different platform"r" manuals for more details. Some platform links has been provided for"r" earier reference (non-exhaustive)."r" * [Linux](https://man7.org/linux/man-pages/man2/getrlimit.2.html)"r" * [FreeBSD](https://www.freebsd.org/cgi/man.cgi?query=setrlimit)"r" The maximum amount (in bytes) of virtual memory the process is"r" allowed to map."r" The largest size (in bytes) core(5) file that may be created."r" The maximum amount of cpu time (in seconds) to be used by each"r" The maximum size (in bytes) of the data segment for a process"r" The largest size (in bytes) file that may be created."r" The maximum number of open files for this process."r" The maximum size (in bytes) of the stack segment for a process."r" A limit on the combined number of flock locks and fcntl leases that"r" this process may establish."r" The maximum size (in bytes) which a process may lock into memory"r" using the mlock(2) system call."r" A limit on the number of bytes that can be allocated for POSIX"r" message queues  for  the  real  user  ID  of  the  calling process."r" A ceiling to which the process's nice value can be raised using"r" setpriority or nice."r" The maximum number of simultaneous processes for this user id."r" When there is memory pressure and swap is available, prioritize"r" eviction of a process' resident pages beyond this amount (in bytes)."r" A ceiling on the real-time priority that may be set for this process"r" using sched_setscheduler and  sched_set‐ param."r" A limit (in microseconds) on the amount of CPU time that a process"r" scheduled under a real-time scheduling policy may con‐ sume without"r" making a blocking system call."r" A limit on the number of signals that may be queued for the real"r" user ID of the  calling  process."/// Get the current processes resource limits/// A value of `None` indicates the value equals to `RLIM_INFINITY` which means/// there is no limit./// * `resource`: The [`Resource`] that we want to get the limits of./// # use nix::sys::resource::{getrlimit, Resource};/// let (soft_limit, hard_limit) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();/// println!("current soft_limit: {:?}", soft_limit);/// println!("current hard_limit: {:?}", hard_limit);/// [getrlimit(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getrlimit.html#tag_16_215)/// [`Resource`]: enum.Resource.html/// Set the current processes resource limits/// * `resource`: The [`Resource`] that we want to set the limits of./// * `soft_limit`: The value that the kernel enforces for the corresponding///   resource. Note: `None` input will be replaced by constant `RLIM_INFINITY`./// * `hard_limit`: The ceiling for the soft limit. Must be lower or equal to///   the current hard limit for non-root users. Note: `None` input will be///   replaced by constant `RLIM_INFINITY`./// > Note: for some os (linux_gnu), setting hard_limit to `RLIM_INFINITY` can/// > results `EPERM` Error. So you will need to set the number explicitly./// # use nix::sys::resource::{setrlimit, Resource};/// let soft_limit = Some(512);/// let hard_limit = Some(1024);/// setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();/// [setrlimit(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getrlimit.html#tag_16_215)/// Note: `setrlimit` provides a safe wrapper to libc's `setrlimit`.//! Configure the process resource limits.FdSet/// Contains a set of file descriptors used by [`select`]assert_fd_valid/// Create an empty `FdSet`/// Add a file descriptor to an `FdSet`/// Remove a file descriptor from an `FdSet`/// Test an `FdSet` for the presence of a certain file descriptor./// Remove all file descriptors from this `FdSet`.highest/// Finds the highest file descriptor in the set./// Returns `None` if the set is empty./// This can be used to calculate the `nfds` parameter of the [`select`] function./// # use nix::sys::select::FdSet;/// let mut set = FdSet::new();/// set.insert(9);/// assert_eq!(set.highest(), Some(9));/// [`select`]: fn.select.html/// Returns an iterator over the file descriptors in the set./// For performance, it takes an optional higher bound: the iterator will/// not return any elements of the set greater than the given file/// # use std::os::unix::io::RawFd;/// let fds: Vec<RawFd> = set.fds(None).collect();/// assert_eq!(fds, vec![4, 9]);/// Iterator over `FdSet`./// Monitors file descriptors for readiness/// Returns the total number of ready file descriptors in all sets. The sets are changed so that all/// file descriptors that are ready for the given operation are set./// When this function returns, `timeout` has an implementation-defined value./// * `nfds`: The highest file descriptor set in any of the passed `FdSet`s, plus 1. If `None`, this///   is calculated automatically by calling [`FdSet::highest`] on all descriptor sets and adding 1///   to the maximum of that./// * `readfds`: File descriptors to check for being ready to read./// * `writefds`: File descriptors to check for being ready to write./// * `errorfds`: File descriptors to check for pending error conditions./// * `timeout`: Maximum time to wait for descriptors to become ready (`None` to block///   indefinitely)./// [select(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/select.html)/// [`FdSet::highest`]: struct.FdSet.html#method.highest/// Monitors file descriptors for readiness with an altered signal mask./// When this function returns, the original signal mask is restored./// Unlike [`select`](#fn.select), `pselect` does not mutate the `timeout` value./// * `readfds`: File descriptors to check for read readiness/// * `writefds`: File descriptors to check for write readiness/// * `sigmask`: Signal mask to activate while waiting for file descriptors to turn///    ready (`None` to set no alternative signal mask)./// [pselect(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html)/// [The new pselect() system call](https://lwn.net/Articles/176911/)TimeValLikefdset_insertfdset_removefdset_clearfdset_highestfdset_fdstest_selecttest_select_nfdstest_select_nfds2//! Portably monitor a group of file descriptors for readiness./// Copy up to `count` bytes to `out_fd` from `in_fd` starting at `offset`./// Returns a `Result` with the number of bytes written./// If `offset` is `None`, `sendfile` will begin reading at the current offset of `in_fd`and will/// update the offset of `in_fd`. If `offset` is `Some`, `sendfile` will begin at the specified/// offset and will not update the offset of `in_fd`. Instead, it will mutate `offset` to point to/// the byte after the last byte copied./// `in_fd` must support `mmap`-like operations and therefore cannot be a socket./// For more information, see [the sendfile(2) man page.](https://man7.org/linux/man-pages/man2/sendfile.2.html)//! Send data from a file to a socket, bypassing userland.r" Types of operating system signals"r" Hangup"r" Interrupt"r" Quit"r" Illegal instruction (not reset when caught)"r" Trace trap (not reset when caught)"r" Abort"r" Bus error"r" Floating point exception"r" Kill (cannot be caught or ignored)"r" User defined signal 1"r" Segmentation violation"r" User defined signal 2"r" Write on a pipe with no one to read it"r" Alarm clock"r" Software termination signal from kill"r" Stack fault (obsolete)"r" To parent on child stop or exit"r" Continue a stopped process"r" Sendable stop signal not from tty"r" Stop signal from tty"r" To readers pgrp upon background tty read"r" Like TTIN if (tp->t_local&LTOSTOP)"r" Urgent condition on IO channel"r" Exceeded CPU time limit"r" Exceeded file size limit"r" Virtual time alarm"r" Profiling time alarm"r" Window size changes"r" Input/output possible signal"r" Power failure imminent."r" Bad system call"/// Returns name of signal./// This function is equivalent to `<Signal as AsRef<str>>::as_ref()`,/// with difference that returned string is `'static`/// and not bound to `self`'s lifetime.SIGNALSSignalIterator/// Iterate through all signals defined by this operating system/// Iterate through all signals defined by this OS/// Alias for [`SIGABRT`]/// Alias for [`SIGIO`]/// Alias for [`SIGSYS`]SaFlags_tr" Controls the behavior of a [`SigAction`]"SaFlagsr" When catching a [`Signal::SIGCHLD`] signal, the signal will be"r" generated only when a child process exits, not when a child process"r" stops."r" When catching a [`Signal::SIGCHLD`] signal, the system will not"r" create zombie processes when children of the calling process exit."r" Further occurrences of the delivered signal are not masked during"r" the execution of the handler."r" The system will deliver the signal to the process on a signal stack,"r" specified by each thread with sigaltstack(2)."r" The handler is reset back to the default at the moment the signal is"r" delivered."r" Requests that certain system calls restart if interrupted by this"r" signal.  See the man page for complete details."r" This flag is controlled internally by Nix."r" Specifies how certain functions should manipulate a signal mask"SigmaskHowr" The new mask is the union of the current mask and the specified set."r" The new mask is the intersection of the current mask and the"r" complement of the specified set."r" The current mask is replaced by the specified set."sigset/// Specifies a set of [`Signal`]s that may be blocked, waited for, etc./// Initialize to include all signals./// Initialize to include nothing./// Add the specified signal to the set./// Remove all signals from this set./// Remove the specified signal from this set./// Return whether this set includes the specified signal./// Merge all of `other`'s signals into this set.// TODO: use libc::sigorset on supported operating systems.thread_get_mask/// Gets the currently blocked (masked) set of signals for the calling thread.thread_set_mask/// Sets the set of signals as the signal mask for the calling thread.thread_block/// Adds the set of signals to the signal mask for the calling thread.thread_unblock/// Removes the set of signals from the signal mask for the calling thread.thread_swap_mask/// Sets the set of signals as the signal mask, and returns the old mask./// Suspends execution of the calling thread until one of the signals in the/// signal mask becomes pending, and returns the accepted signal.// RedoxFS does not yet support sigwaitSigHandlerSigDfl/// Default signal handling.SigIgn/// Request that the signal be ignored./// Use the given signal-catching function, which takes in the signal.SigAction/// Use the given signal-catching function, which takes in the signal, information about how/// the signal was generated, and a pointer to the threads `ucontext_t`./// A signal handler./// Action to take on receipt of a signal. Corresponds to `sigaction`./// Creates a new action./// The `SA_SIGINFO` bit in the `flags` argument is ignored (it will be set only if `handler`/// is the `SigAction` variant). `mask` specifies other signals to block during execution of/// the signal-catching function./// Returns the flags set on the action./// Returns the set of signals that are blocked during execution of the action's/// signal-catching function./// Returns the action's handler./// Changes the action taken by a process on receipt of a specific signal./// `signal` can be any signal except `SIGKILL` or `SIGSTOP`. On success, it returns the previous/// action for the given signal. If `sigaction` fails, no new signal handler is installed./// * Signal handlers may be called at any point during execution, which limits///   what is safe to do in the body of the signal-catching function. Be certain///   to only make syscalls that are explicitly marked safe for signal handlers///   and only share global data using atomics./// * There is also no guarantee that the old signal handler was installed///   correctly.  If it was installed by this crate, it will be.  But if it was///   installed by, for example, C code, then there is no guarantee its function///   pointer is valid.  In that case, this function effectively dereferences a///   raw pointer of unknown provenance./// Signal management (see [signal(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/signal.html))/// Installs `handler` for the given `signal`, returning the previous signal/// handler. `signal` should only be used following another call to `signal` or/// if the current handler is the default. The return value of `signal` is/// undefined after setting the handler with [`sigaction`][SigActionFn]./// If the pointer to the previous signal handler is invalid, undefined/// behavior could be invoked when casting it back to a [`SigAction`][SigActionStruct]./// Ignore `SIGINT`:/// # use nix::sys::signal::{self, Signal, SigHandler};/// unsafe { signal::signal(Signal::SIGINT, SigHandler::SigIgn) }.unwrap();/// Use a signal handler to set a flag variable:/// # #[macro_use] extern crate lazy_static;/// # use std::sync::atomic::{AtomicBool, Ordering};///    static ref SIGNALED: AtomicBool = AtomicBool::new(false);/// extern fn handle_sigint(signal: libc::c_int) {///     let signal = Signal::try_from(signal).unwrap();///     SIGNALED.store(signal == Signal::SIGINT, Ordering::Relaxed);///     let handler = SigHandler::Handler(handle_sigint);///     unsafe { signal::signal(Signal::SIGINT, handler) }.unwrap();/// Returns [`Error(Errno::EOPNOTSUPP)`] if `handler` is/// [`SigAction`][SigActionStruct]. Use [`sigaction`][SigActionFn] instead./// `signal` also returns any error from `libc::signal`, such as when an attempt/// is made to catch a signal that cannot be caught or to ignore a signal that/// cannot be ignored./// [`Error::UnsupportedOperation`]: ../../enum.Error.html#variant.UnsupportedOperation/// [SigActionStruct]: struct.SigAction.html/// [sigactionFn]: fn.sigaction.htmldo_pthread_sigmask/// Manages the signal mask (set of blocked signals) for the calling thread./// If the `set` parameter is `Some(..)`, then the signal mask will be updated with the signal set./// The `how` flag decides the type of update. If `set` is `None`, `how` will be ignored,/// and no modification will take place./// If the 'oldset' parameter is `Some(..)` then the current signal mask will be written into it./// If both `set` and `oldset` is `Some(..)`, the current signal mask will be written into oldset,/// and then it will be updated with `set`./// If both `set` and `oldset` is None, this function is a no-op./// For more information, visit the [`pthread_sigmask`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_sigmask.html),/// or [`sigprocmask`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html) man pages./// Examine and change blocked signals./// For more informations see the [`sigprocmask` man/// pages](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html)./// Send a signal to a process/// * `pid` -    Specifies which processes should receive the signal.///   - If positive, specifies an individual process///   - If zero, the signal will be sent to all processes whose group///     ID is equal to the process group ID of the sender.  This is a///     variant of [`killpg`].///   - If `-1` and the process has super-user privileges, the signal///     is sent to all processes exclusing system processes.///   - If less than `-1`, the signal is sent to all processes whose///     process group ID is equal to the absolute value of `pid`./// * `signal` - Signal to send. If `None`, error checking is performed///              but no signal is actually sent./// See Also/// [`kill(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html)/// Send a signal to a process group/// * `pgrp` -   Process group to signal.  If less then or equal 1, the behavior///              is platform-specific./// * `signal` - Signal to send. If `None`, `killpg` will only preform error///              checking and won't send any signal./// See Also [killpg(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/killpg.html)./// Send a signal to the current thread/// See Also [raise(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/raise.html)type_of_thread_id/// Identifies a thread for [`SigevNotify::SigevThreadId`]SigevNone/// No notification will be delivered/// Signal to deliver/// Will be present in the `si_value` field of the [`libc::siginfo_t`]/// structure of the queued signal.SigevSignal/// Notify by delivering a signal to the process./// Signal to send/// LWP ID of the thread to notifySigevThreadId/// Notify by delivering a signal to a thread./// Specifies the notification method used by a [`SigEvent`]// sigval is actually a union of a int and a void*.  But it's never really used// as a pointer, because neither libc nor the kernel ever dereference it.  nix// therefore presents it as an intptr_t, which is how kevent uses it./// Used to request asynchronous notification of the completion of certain/// events, such as POSIX AIO and timers./// **Note:** this constructor does not allow the user to set the/// `sigev_notify_kevent_flags` field.  That's considered ok because on FreeBSD/// at least those flags don't do anything useful.  That field is part of a/// union that shares space with the more genuinely useful fields./// **Note:** This constructor also doesn't allow the caller to set the/// `sigev_notify_function` or `sigev_notify_attributes` fields, which are/// required for `SIGEV_THREAD`.  That's considered ok because on no operating/// system is `SIGEV_THREAD` the most efficient way to deliver AIO/// notification.  FreeBSD and DragonFly BSD programs should prefer `SIGEV_KEVENT`./// Linux, Solaris, and portable programs should prefer `SIGEV_THREAD_ID` or/// `SIGEV_SIGNAL`.  That field is part of a union that shares space with the/// more genuinely useful `sigev_notify_thread_id`// Allow invalid_value warning on Fuchsia only.// See https://github.com/nix-rust/nix/issues/1441/// Return a copy of the inner structuretest_cleartest_from_str_round_tripstest_from_str_invalid_valuetest_thread_signal_set_masktest_thread_signal_blocktest_thread_signal_unblocktest_thread_signal_swaptest_sigactiontest_sigwait// Portions of this file are Copyright 2014 The Rust Project Developers.// See https://www.rust-lang.org/policies/licenses.//! Operating system signals.SIGNALFD_NEWSIGNALFD_SIGINFO_SIZE/// Creates a new file descriptor for reading signals./// **Important:** please read the module level documentation about signal discarding before using/// this function!/// The `mask` parameter specifies the set of signals that can be accepted via this file descriptor./// A signal must be blocked on every thread in a process, otherwise it won't be visible from/// signalfd (the default handler will be invoked instead)./// See [the signalfd man page for more information](https://man7.org/linux/man-pages/man2/signalfd.2.html)/// A helper struct for creating, reading and closing a `signalfd` instance./// this struct!/// # use nix::sys::signalfd::*;/// // Set the thread to block the SIGUSR1 signal, otherwise the default handler will be used/// let mut mask = SigSet::empty();/// mask.add(signal::SIGUSR1);/// mask.thread_block().unwrap();/// // Signals are queued up on the file descriptor/// let mut sfd = SignalFd::with_flags(&mask, SfdFlags::SFD_NONBLOCK).unwrap();/// match sfd.read_signal() {///     // we caught a signal///     Ok(Some(sig)) => (),///     // there were no signals waiting (only happens when the SFD_NONBLOCK flag is set,///     // otherwise the read_signal call blocks)///     Ok(None) => (),///     Err(err) => (), // some error happendset_maskread_signalcreate_signalfdcreate_signalfd_with_optsread_empty_signalfd//! Interface for the `signalfd` syscall.//! # Signal discarding//! When a signal can't be delivered to a process (or thread), it will become a pending signal.//! Failure to deliver could happen if the signal is blocked by every thread in the process or if//! the signal handler is still handling a previous signal.//! If a signal is sent to a process (or thread) that already has a pending signal of the same//! type, it will be discarded. This means that if signals of the same type are received faster than//! they are processed, some of those signals will be dropped. Because of this limitation,//! `signalfd` in itself cannot be used for reliable communication between processes or threads.//! Once the signal is unblocked, or the signal handler is finished, and a signal is still pending//! (ie. not consumed from a signalfd) it will be delivered to the signal handler.//! Please note that signal discarding is not specific to `signalfd`, but also happens with regular//! signal handlers.NetlinkAddrAlgAddrdatalinkLinkAddrvsockVsockAddr/// Local communication (see [`unix(7)`](https://man7.org/linux/man-pages/man7/unix.7.html))Inet/// IPv4 Internet protocols (see [`ip(7)`](https://man7.org/linux/man-pages/man7/ip.7.html))Inet6/// IPv6 Internet protocols (see [`ipv6(7)`](https://man7.org/linux/man-pages/man7/ipv6.7.html))Netlink/// Kernel user interface device (see [`netlink(7)`](https://man7.org/linux/man-pages/man7/netlink.7.html))/// Low level packet interface (see [`packet(7)`](https://man7.org/linux/man-pages/man7/packet.7.html))Ax25/// Amateur radio AX.25 protocolIpx/// IPX - Novell protocolsAppleTalk/// AppleTalkNetRomBridgeAtmPvc/// Access to raw ATM PVCs/// ITU-T X.25 / ISO-8208 protocol (see [`x25(7)`](https://man7.org/linux/man-pages/man7/x25.7.html))RoseDecnetNetBeuiAshEconetAtmSvcRdsSnaIrdaPppoxWanpipeLlcIbMplsCanTipcIucvRxRpcPhonetIeee802154Caif/// Interface to kernel crypto APINfcVsockUnspec/// Unspecified address family, (see [`getaddrinfo(3)`](https://man7.org/linux/man-pages/man3/getaddrinfo.3.html))/// These constants specify the protocol family to be used/// in [`socket`](fn.socket.html) and [`socketpair`](fn.socketpair.html)/// Create a new `AddressFamily` from an integer value retrieved from `libc`, usually from/// the `sa_family` field of a `sockaddr`./// Currently only supports these address families: Unix, Inet (v4 & v6), Netlink, Link/Packet/// and System. Returns None for unsupported or unknown address families.InetAddr// It isn't needless on all OSes/// Gets the IP address associated with this socket address./// Gets the port number associated with this socket address/*
 *
 * ===== IpAddr =====
 *
 */new_v4/// Create a new IpAddr that contains an IPv4 address./// The result will represent the IP address a.b.c.dnew_v6/// Create a new IpAddr that contains an IPv6 address./// The result will represent the IP address a:b:c:d:e:f// More readable this way// Use pass by reference for symmetry with Ipv6Addr::from_stdto_u8_arrayto_u16_array/// Return the eight 16-bit segments that make up this address// INVARIANT: sun & path_len are valid as defined by docs for from_raw_partsUnixAddr/// A wrapper around `sockaddr_un`.UnixAddrKind// linux man page unix(7) says there are 3 kinds of unix socket:// pathname: addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(sun_path) + 1// unnamed: addrlen = sizeof(sa_family_t)// abstract: addren > sizeof(sa_family_t), name = sun_path[..(addrlen - sizeof(sa_family_t))]// what we call path_len = addrlen - offsetof(struct sockaddr_un, sun_path)/// Safety: sun & path_len must be valid/// Create a new sockaddr_un representing a filesystem path.new_abstract/// Create a new `sockaddr_un` representing an address in the "abstract namespace"./// The leading null byte for the abstract namespace is automatically added;/// thus the input `path` is expected to be the bare name, not null-prefixed./// This is a Linux-specific extension, primarily used to allow chrooted/// processes to communicate with processes having a different filesystem view./// Create a UnixAddr from a raw `sockaddr_un` struct and a size. `path_len` is the "addrlen"/// of this address, but minus `offsetof(struct sockaddr_un, sun_path)`. Basically the length/// of the data in `sun_path`./// This pair of sockaddr_un & path_len must be a valid unix addr, which means:/// - path_len <= sockaddr_un.sun_path.len()/// - if this is a unix addr with a pathname, sun.sun_path is a nul-terminated fs path and///   sun.sun_path[path_len - 1] == 0 || sun.sun_path[path_len] == 0/// If this address represents a filesystem path, return that path.as_abstract/// If this address represents an abstract socket, return its name./// For abstract sockets only the bare name is returned, without the/// leading null byte. `None` is returned for unnamed or path-backed sockets./// Returns the addrlen of this socket - `offsetof(struct sockaddr_un, sun_path)`/// Returns a pointer to the raw `sockaddr_un` struct/// Returns a mutable pointer to the raw `sockaddr_un` structfmt_abstract/// Datalink address (MAC)/// Represents a socket addressnew_inetnew_unixnew_netlinknew_algnew_vsockfrom_libc_sockaddr/// Creates a `SockAddr` struct from libc's sockaddr./// Supports only the following address families: Unix, Inet (v4 & v6), Netlink and System./// Returns None for unsupported families./// unsafe because it takes a raw pointer as argument.  The caller must/// ensure that the pointer is valid.as_ffi_pair/// Conversion from nix's SockAddr type to the underlying libc sockaddr type./// This is useful for interfacing with other libc functions that don't yet have nix wrappers./// Returns a reference to the underlying data type (as a sockaddr reference) along/// with the size of the actual data type. sockaddr is commonly used as a proxy for/// a superclass as C doesn't support inheritance, so many functions that take/// a sockaddr * need to take the size of the underlying type as well and then internally cast it back.// , PartialEq, Eq, Debug, Hashalg_type/// Hardware Address/// Always AF_PACKET/// Physical-layer protocol/// Interface numberhatype/// ARP hardware typepkttype/// Packet typehalen/// Length of MAC address/// Physical-layer address (MAC)cid/// Context Identifier (CID)/// Port number/// VSOCK Address/// The address for AF_VSOCK socket is defined as a combination of a/// 32-bit Context Identifier (CID) and a 32-bit port number.test_abstract_sun_path/*
 *
 * ===== Ipv4Addr =====
 *
 *//*
 *
 * ===== Ipv6Addr =====
 *
 */// Note that IPv6 addresses are stored in big endian order on all architectures.// See https://tools.ietf.org/html/rfc1700 or consult your favorite search// engine.sockopt// Needed by the cmsg_space macroSockType/// Provides sequenced, reliable, two-way, connection-/// based byte streams.  An out-of-band data transmission/// mechanism may be supported./// Supports datagrams (connectionless, unreliable/// messages of a fixed maximum length).SeqPacket/// Provides a sequenced, reliable, two-way connection-/// based data transmission path for datagrams of fixed/// maximum length; a consumer is required to read an/// entire packet with each input system call./// Provides raw network protocol access.Rdm/// Provides a reliable datagram layer that does not/// guarantee ordering./// These constants are used to specify the communication semantics/// when creating a socket with [`socket()`](fn.socket.html)// The TryFrom impl could've been derived using libc_enum!.  But for// backwards-compatibility with Nix-0.25.0 we manually implement it, so as to// keep the old variant names.SockProtocol/// TCP protocol ([ip(7)](https://man7.org/linux/man-pages/man7/ip.7.html))/// UDP protocol ([ip(7)](https://man7.org/linux/man-pages/man7/ip.7.html))NetlinkRoute/// Receives routing and link updates and may be used to modify the routing tables (both IPv4 and IPv6), IP addresses, link// parameters, neighbor setups, queueing disciplines, traffic classes and packet classifiers/// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))NetlinkUserSock/// Reserved for user-mode socket protocolsNetlinkSockDiag/// Query information about sockets of various protocol families from the kernelNetlinkSELinux/// SELinux event notifications.NetlinkISCSI/// Open-iSCSINetlinkAudit/// AuditingNetlinkFIBLookup/// Access to FIB lookup from user spaceNetlinkNetFilter/// Netfilter subsystemNetlinkSCSITransport/// SCSI TransportsNetlinkRDMA/// Infiniband RDMANetlinkIPv6Firewall/// Transport IPv6 packets from netfilter to user space.  Used by ip6_queue kernel module.NetlinkDECNetRoutingMessage/// DECnet routing messagesNetlinkKObjectUEvent/// Kernel messages to user spaceNetlinkCrypto/// Netlink interface to request information about ciphers registered with the kernel crypto API as well as allow/// configuration of the kernel crypto API./// Constants used in [`socket`](fn.socket.html) and [`socketpair`](fn.socketpair.html)/// to specify the protocol to use.r" Additional socket options"SockFlagr" Set non-blocking mode on the new socket"r" Set close-on-exec on the new descriptor"r" Flags for send/recv and their relatives"MsgFlagsr" Sends or requests out-of-band data on sockets that support this notion"r" (e.g., of type [`Stream`](enum.SockType.html)); the underlying protocol must also"r" support out-of-band data."r" Peeks at an incoming message. The data is treated as unread and the next"r" [`recv()`](fn.recv.html)"r" or similar function shall still return this data."r" Receive operation blocks until the full amount of data can be"r" returned. The function may return smaller amount of data if a signal"r" is caught, an error or disconnect occurs."r" Enables nonblocking operation; if the operation would block,"r" `EAGAIN` or `EWOULDBLOCK` is returned.  This provides similar"r" behavior to setting the `O_NONBLOCK` flag"r" (via the [`fcntl`](../../fcntl/fn.fcntl.html)"r" `F_SETFL` operation), but differs in that `MSG_DONTWAIT` is a per-"r" call option, whereas `O_NONBLOCK` is a setting on the open file"r" description (see [open(2)](https://man7.org/linux/man-pages/man2/open.2.html)),"r" which will affect all threads in"r" the calling process and as well as other processes that hold"r" file descriptors referring to the same open file description."r" Receive flags: Control Data was discarded (buffer too small)"r" For raw ([`Packet`](addr/enum.AddressFamily.html)), Internet datagram"r" (since Linux 2.4.27/2.6.8),"r" netlink (since Linux 2.6.22) and UNIX datagram (since Linux 3.4)"r" sockets: return the real length of the packet or datagram, even"r" when it was longer than the passed buffer. Not implemented for UNIX"r" domain ([unix(7)](https://linux.die.net/man/7/unix)) sockets."r" For use with Internet stream sockets, see [tcp(7)](https://linux.die.net/man/7/tcp)."r" Terminates a record (when this notion is supported, as for"r" sockets of type [`SeqPacket`](enum.SockType.html))."r" This flag specifies that queued errors should be received from"r" the socket error queue. (For more details, see"r" [recvfrom(2)](https://linux.die.net/man/2/recvfrom))"r" Set the `close-on-exec` flag for the file descriptor received via a UNIX domain"r" file descriptor using the `SCM_RIGHTS` operation (described in"r" [unix(7)](https://linux.die.net/man/7/unix))."r" This flag is useful for the same reasons as the `O_CLOEXEC` flag of"r" [open(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html)."r" Only used in [`recvmsg`](fn.recvmsg.html) function."r" Unix credentials of the sending process."r" This struct is used with the `SO_PEERCRED` ancillary message"r" and the `SCM_CREDENTIALS` control message for UNIX sockets."UnixCredentialsr" Creates a new instance with the credentials of the current process"r" Returns the process identifier"r" Returns the user identifier"r" Returns the group identifier"IpMembershipRequest/// Request for multicast socket operations/// This is a wrapper type around `ip_mreq`./// Instantiate a new `IpMembershipRequest`/// If `interface` is `None`, then `Ipv4Addr::any()` will be used for the interface.Ipv6MembershipRequest/// Request for ipv6 multicast socket operations/// This is a wrapper type around `ipv6_mreq`./// Instantiate a new `Ipv6MembershipRequest`cmsg_space/// Create a buffer large enough for storing some control messages as returned/// by [`recvmsg`](fn.recvmsg.html)./// # use nix::sys::time::TimeVal;/// // Create a buffer for a `ControlMessageOwned::ScmTimestamp` message/// let _ = cmsg_space!(TimeVal);/// // Create a buffer big enough for a `ControlMessageOwned::ScmRights` message/// // with two file descriptors/// let _ = cmsg_space!([RawFd; 2]);/// // and a `ControlMessageOwned::ScmTimestamp` message/// let _ = cmsg_space!(RawFd, TimeVal);// Unfortunately, CMSG_SPACE isn't a const_fn, or else we could return a// stack-allocated array.mhdrRecvMsgcmsgsCmsgIterator/// Iterate over the valid control messages pointed to by this/// msghdr./// Control message buffer to decode from. Must adhere to cmsg alignment.ControlMessageOwnedScmRights/// Received version of [`ControlMessage::ScmRights`]ScmCredentials/// Received version of [`ControlMessage::ScmCredentials`]ScmTimestamp/// A message of type `SCM_TIMESTAMP`, containing the time the/// packet was received by the kernel./// See the kernel's explanation in "SO_TIMESTAMP" of/// [networking/timestamping](https://www.kernel.org/doc/Documentation/networking/timestamping.txt)./// # use nix::sys::socket::*;/// # use nix::sys::uio::IoVec;/// # use nix::sys::time::*;/// # use std::time::*;/// // Set up/// let message = "Ohayō!".as_bytes();/// let in_socket = socket(///     AddressFamily::Inet,///     SockType::Datagram,///     SockFlag::empty(),///     None).unwrap();/// setsockopt(in_socket, sockopt::ReceiveTimestamp, &true).unwrap();/// let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);/// bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();/// let address = getsockname(in_socket).unwrap();/// // Get initial time/// let time0 = SystemTime::now();/// // Send the message/// let iov = [IoVec::from_slice(message)];/// let flags = MsgFlags::empty();/// let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();/// assert_eq!(message.len(), l);/// // Receive the message/// let mut buffer = vec![0u8; message.len()];/// let mut cmsgspace = cmsg_space!(TimeVal);/// let iov = [IoVec::from_mut_slice(&mut buffer)];/// let r = recvmsg(in_socket, &iov, Some(&mut cmsgspace), flags).unwrap();/// let rtime = match r.cmsgs().next() {///     Some(ControlMessageOwned::ScmTimestamp(rtime)) => rtime,///     Some(_) => panic!("Unexpected control message"),///     None => panic!("No control message")/// // Check the final time/// let time1 = SystemTime::now();/// // the packet's received timestamp should lie in-between the two system/// // times, unless the system clock was adjusted in the meantime./// let rduration = Duration::new(rtime.tv_sec() as u64,///                               rtime.tv_usec() as u32 * 1000);/// assert!(time0.duration_since(UNIX_EPOCH).unwrap() <= rduration);/// assert!(rduration <= time1.duration_since(UNIX_EPOCH).unwrap());/// // Close socket/// nix::unistd::close(in_socket).unwrap();ScmTimestampns/// Nanoseconds resolution timestamp/// [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)Ipv4PacketInfoIpv6PacketInfoUdpGroSegments/// UDP Generic Receive Offload (GRO) allows receiving multiple UDP/// packets from a single sender./// Fixed-size payloads are following one by one in a receive buffer./// This Control Message indicates the size of all smaller packets,/// except, maybe, the last one./// `UdpGroSegment` socket option should be enabled on a socket/// to allow receiving GRO packets.RxqOvfl/// SO_RXQ_OVFL indicates that an unsigned 32 bit value/// ancilliary msg (cmsg) should be attached to recieved/// skbs indicating the number of packets dropped by the/// socket between the last recieved packet and this/// received packet./// `RxqOvfl` socket option should be enabled on a socket/// to allow receiving the drop counter.Ipv4RecvErr/// Socket error queue control messages read with the `MSG_ERRQUEUE` flag.Ipv6RecvErrUnknownCmsg/// Catch-all variant for unimplemented cmsg types./// A type-safe wrapper around a single control message, as used with/// [`recvmsg`](#fn.recvmsg)./// [Further reading](https://man7.org/linux/man-pages/man3/cmsg.3.html)//  Nix version 0.13.0 and earlier used ControlMessage for both recvmsg and//  sendmsg.  However, on some platforms the messages returned by recvmsg may be//  unaligned.  ControlMessageOwned takes those messages by copy, obviating any//  alignment issues.//  See https://github.com/nix-rust/nix/issues/999decode_from/// Decodes a `ControlMessageOwned` from raw bytes./// This is only safe to call if the data is correct for the message type/// specified in the header. Normally, the kernel ensures that this is the/// case. "Correct" in this case includes correct length, alignment and/// actual content.// Clippy complains about the pointer alignment of `p`, not understanding// that it's being fed to a function that can handle that.recv_err_helperControlMessage/// A message of type `SCM_RIGHTS`, containing an array of file/// descriptors passed between processes./// See the description in the "Ancillary messages" section of the/// [unix(7) man page](https://man7.org/linux/man-pages/man7/unix.7.html)./// Using multiple `ScmRights` messages for a single `sendmsg` call isn't/// recommended since it causes platform-dependent behaviour: It might/// swallow all but the first `ScmRights` message or fail with `EINVAL`./// Instead, you can put all fds to be passed into a single `ScmRights`/// A message of type `SCM_CREDENTIALS`, containing the pid, uid and gid of/// a process connected to the socket./// This is similar to the socket option `SO_PEERCRED`, but requires a/// process to explicitly send its credentials. A process running as root is/// allowed to specify any credentials, while credentials sent by other/// processes are verified by the kernel./// For further information, please refer to the/// [`unix(7)`](https://man7.org/linux/man-pages/man7/unix.7.html) man page.AlgSetIv/// Set IV for `AF_ALG` crypto API./// [`documentation`](https://kernel.readthedocs.io/en/sphinx-samples/crypto-API.html)AlgSetOp/// Set crypto operation for `AF_ALG` crypto API. It may be one of/// `ALG_OP_ENCRYPT` or `ALG_OP_DECRYPT`AlgSetAeadAssoclen/// Set the length of associated authentication data (AAD) (applicable only to AEAD algorithms)/// for `AF_ALG` crypto API.UdpGsoSegments/// UDP GSO makes it possible for applications to generate network packets/// for a virtual MTU much greater than the real one./// The length of the send data no longer matches the expected length on/// the wire./// The size of the datagram payload as it should appear on the wire may be/// passed through this control message./// Send buffer should consist of multiple fixed-size wire payloads/// following one by one, and the last, possibly smaller one./// Configure the sending addressing and interface for v4/// [`ip(7)`](https://man7.org/linux/man-pages/man7/ip.7.html) man page./// Configure the sending addressing and interface for v6/// [`ipv6(7)`](https://man7.org/linux/man-pages/man7/ipv6.7.html) man page./// A type-safe zero-copy wrapper around a single control message, as used wih/// [`sendmsg`](#fn.sendmsg).  More types may be added to this enum; do not/// exhaustively pattern-match it.// An opaque structure used to prevent cmsghdr from being a public type/// The value of CMSG_SPACE on this message./// Safe because CMSG_SPACE is always safe/// The value of CMSG_LEN on this message./// Safe because CMSG_LEN is always safecopy_to_cmsg_data/// Return a reference to the payload data as a byte pointer/// The size of the payload, excluding its cmsghdr/// Returns the value to put into the `cmsg_level` field of the header./// Returns the value to put into the `cmsg_type` field of the header.// Unsafe: cmsg must point to a valid cmsghdr with enough space to// encode self./// Send data in scatter-gather vectors to a socket, possibly accompanied/// by ancillary data. Optionally direct the message at the given address,/// as with sendto./// Allocates if cmsgs is nonempty._ltSendMmsgData/// An extension of `sendmsg` that allows the caller to transmit multiple/// messages on a socket using a single system call. This has performance/// benefits for some applications./// Allocations are performed for cmsgs and to build `msghdr` buffer/// * `fd`:             Socket file descriptor/// * `data`:           Struct that implements `IntoIterator` with `SendMmsgData` items/// * `flags`:          Optional flags passed directly to the operating system./// `Vec` with numbers of sent bytes on each sent message./// [`sendmsg`](fn.sendmsg.html)cmsg_bufferRecvMmsgData/// An extension of `recvmsg` that allows the caller to receive multiple/// messages from a socket using a single system call. This has/// performance benefits for some applications./// `iov` and `cmsg_buffer` should be constructed similarly to `recvmsg`/// Multiple allocations are performed/// * `data`:           Struct that implements `IntoIterator` with `RecvMmsgData` items/// # RecvMmsgData/// * `iov`:            Scatter-gather list of buffers to receive the message/// * `cmsg_buffer`:    Space to receive ancillary data.  Should be created by///                     [`cmsg_space!`](macro.cmsg_space.html)/// A `Vec` with multiple `RecvMsg`, one per received message/// - [`recvmsg`](fn.recvmsg.html)/// - [`RecvMsg`](struct.RecvMsg.html)// Complicated false positiveread_mhdrpack_mhdr_to_receivepack_mhdr_to_send/// Receive message in scatter-gather vectors from a socket, and/// optionally receive ancillary data into the provided buffer./// If no ancillary data is desired, use () as the type parameter./// [recvmsg(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html)/// Create an endpoint for communication/// The `protocol` specifies a particular protocol to be used with the/// socket.  Normally only a single protocol exists to support a/// particular socket type within a given protocol family, in which case/// protocol can be specified as `None`.  However, it is possible that many/// protocols may exist, in which case a particular protocol must be/// specified in this manner./// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html)/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/socketpair.html)/// Listen for connections on a socket/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html)/// Bind a name to a socket/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html)/// Accept a connection on a socket/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html)/// [Further reading](https://man7.org/linux/man-pages/man2/accept.2.html)/// Initiate a connection on a socket/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html)/// Receive data from a connection-oriented socket. Returns the number of/// bytes read/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/recv.html)/// Receive data from a connectionless or connection-oriented socket. Returns/// the number of bytes read and, for connectionless sockets,  the socket/// address of the sender./// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html)/// Send a message to a socket/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html)/// Send data to a connection-oriented socket. Returns the number of bytes read/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/send.html)/// Look up the value of this socket option on the given socket.GetSockOpt/// Represents a socket option that can be retrieved./// Set the value of this socket option on the given socket.SetSockOpt/// Represents a socket option that can be set./// Get the current value for the requested socket option/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockopt.html)/// Sets the value for the requested socket option/// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsockopt.html)/// use nix::sys::socket::setsockopt;/// use nix::sys::socket::sockopt::KeepAlive;/// let listener = TcpListener::bind("0.0.0.0:0").unwrap();/// let fd = listener.as_raw_fd();/// let res = setsockopt(fd, KeepAlive, &true);/// Get the address of the peer connected to the socket `fd`./// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html)/// Get the current address to which the socket `fd` is bound./// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html)sockaddr_storage_to_addr/// Return the appropriate `SockAddr` type from a `sockaddr_storage` of a/// certain size./// In C this would usually be done by casting.  The `len` argument/// should be the number of bytes in the `sockaddr_storage` that are actually/// allocated and valid.  It must be at least as large as all the useful parts/// of the structure.  Note that in the case of a `sockaddr_un`, `len` need not/// include the terminating null./// Further receptions will be disallowed./// Further  transmissions will be disallowed./// Further receptions and transmissions will be disallowed./// Shut down part of a full-duplex connection./// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html)can_use_cmsg_space//! Socket interface functions//! [Further reading](https://man7.org/linux/man-pages/man7/socket.7.html)/*
 *
 * ===== Re-exports =====
 *
 *//*
 *
 * ===== Socket Options =====
 *
 */TCP_CA_NAME_MAX// TCP_CA_NAME_MAX isn't defined in user space include filessetsockopt_impl/// Helper for implementing `SetSockOpt` for a given socket option. See/// [`::sys::socket::SetSockOpt`](sys/socket/trait.SetSockOpt.html)./// This macro aims to help implementing `SetSockOpt` for different socket options that accept/// different kinds of data to be used with `setsockopt`./// Instead of using this macro directly consider using `sockopt_impl!`, especially if the option/// you are implementing represents a simple type./// * `$name:ident`: name of the type you want to implement `SetSockOpt` for./// * `$level:expr` : socket layer, or a `protocol level`: could be *raw sockets*///    (`libc::SOL_SOCKET`), *ip protocol* (libc::IPPROTO_IP), *tcp protocol* (`libc::IPPROTO_TCP`),///    and more. Please refer to your system manual for more options. Will be passed as the second///    argument (`level`) to the `setsockopt` call./// * `$flag:path`: a flag name to set. Some examples: `libc::SO_REUSEADDR`, `libc::TCP_NODELAY`,///    `libc::IP_ADD_MEMBERSHIP` and others. Will be passed as the third argument (`option_name`)///    to the `setsockopt` call./// * Type of the value that you are going to set./// * Type that implements the `Set` trait for the type from the previous item (like `SetBool` for///    `bool`, `SetUsize` for `usize`, etc.).getsockopt_impl/// Helper for implementing `GetSockOpt` for a given socket option. See/// [`::sys::socket::GetSockOpt`](sys/socket/trait.GetSockOpt.html)./// This macro aims to help implementing `GetSockOpt` for different socket options that accept/// different kinds of data to be use with `getsockopt`./// * Name of the type you want to implement `GetSockOpt` for./// * Socket layer, or a `protocol level`: could be *raw sockets* (`lic::SOL_SOCKET`),  *ip///    protocol* (libc::IPPROTO_IP), *tcp protocol* (`libc::IPPROTO_TCP`),  and more. Please refer///    to your system manual for more options. Will be passed as the second argument (`level`) to///    the `getsockopt` call./// * A flag to set. Some examples: `libc::SO_REUSEADDR`, `libc::TCP_NODELAY`,///    `libc::SO_ORIGINAL_DST` and others. Will be passed as the third argument (`option_name`) to/// * Type of the value that you are going to get./// * Type that implements the `Get` trait for the type from the previous item (`GetBool` for///    `bool`, `GetUsize` for `usize`, etc.).sockopt_impl/*
     * Matchers with generic getter types must be placed at the end, so
     * they'll only match _after_ specialized matchers fail
     *//// Helper to generate the sockopt accessors. See/// [`::sys::socket::GetSockOpt`](sys/socket/trait.GetSockOpt.html) and/// This macro aims to help implementing `GetSockOpt` and `SetSockOpt` for different socket options/// that accept different kinds of data to be use with `getsockopt` and `setsockopt` respectively./// Basically this macro wraps up the [`getsockopt_impl!`](macro.getsockopt_impl.html) and/// [`setsockopt_impl!`](macro.setsockopt_impl.html) macros./// * `GetOnly`, `SetOnly` or `Both`: whether you want to implement only getter, only setter or///    both of them./// * `$name:ident`: name of type `GetSockOpt`/`SetSockOpt` will be implemented for.///    (`lic::SOL_SOCKET`), *ip protocol* (libc::IPPROTO_IP), *tcp protocol* (`libc::IPPROTO_TCP`),///    argument (`level`) to the `getsockopt`/`setsockopt` call.///    to the `setsockopt`/`getsockopt` call./// * `$ty:ty`: type of the value that will be get/set./// * `$getter:ty`: `Get` implementation; optional; only for `GetOnly` and `Both`./// * `$setter:ty`: `Set` implementation; optional; only for `SetOnly` and `Both`.r" Enables local address reuse"ReuseAddrr" Permits multiple AF_INET or AF_INET6 sockets to be bound to an"r" identical socket address."ReusePortr" Under most circumstances, TCP sends data when it is presented; when"r" outstanding data has not yet been acknowledged, it gathers small amounts"r" of output to be sent in a single packet once an acknowledgement is"r" received.  For a small number of clients, such as window systems that"r" send a stream of mouse events which receive no replies, this"r" packetization may cause significant delays.  The boolean option"r" TCP_NODELAY defeats this algorithm."TcpNoDelayr" When enabled,  a close(2) or shutdown(2) will not return until all"r" queued messages for the socket have been successfully sent or the"r" linger timeout has been reached."Lingerr" Join a multicast group"IpAddMembershipr" Leave a multicast group."IpDropMembershipr" Join an IPv6 multicast group."Ipv6AddMembershipr" Leave an IPv6 multicast group."Ipv6DropMembershipr" Set or read the time-to-live value of outgoing multicast packets for"r" this socket."IpMulticastTtlr" Set or read a boolean integer argument that determines whether sent"r" multicast packets should be looped back to the local sockets."IpMulticastLoopr" If enabled, this boolean option allows binding to an IP address that"r" is nonlocal or does not (yet) exist."IpFreebindr" Specify the receiving timeout until reporting an error."ReceiveTimeoutr" Specify the sending timeout until reporting an error."SendTimeoutr" Set or get the broadcast flag."Broadcastr" If this option is enabled, out-of-band data is directly placed into"r" the receive data stream."OobInliner" Get and clear the pending socket error."SocketErrorr" Enable sending of keep-alive messages on connection-oriented sockets."r" Return the credentials of the foreign process connected to this socket."PeerCredentialsr" The time (in seconds) the connection needs to remain idle before TCP"r" starts sending keepalive probes"TcpKeepIdler" The maximum segment size for outgoing TCP packets."TcpMaxSegr" The maximum number of keepalive probes TCP should send before"r" dropping the connection."TcpKeepCountTcpRepairr" The time (in seconds) between individual keepalive probes."TcpKeepIntervalr" Specifies the maximum amount of time in milliseconds that transmitted"r" data may remain unacknowledged before TCP will forcibly close the"r" corresponding connection"TcpUserTimeoutr" Sets or gets the maximum socket receive buffer in bytes."RcvBufr" Sets or gets the maximum socket send buffer in bytes."SndBufr" Using this socket option, a privileged (`CAP_NET_ADMIN`) process can"r" perform the same task as `SO_RCVBUF`, but the `rmem_max limit` can be"r" overridden."RcvBufForcer" Using this socket option, a privileged (`CAP_NET_ADMIN`)  process can"r" perform the same task as `SO_SNDBUF`, but the `wmem_max` limit can be"SndBufForcer" Gets the socket type as an integer."r" Returns a value indicating whether or not this socket has been marked to"r" accept connections with `listen(2)`."AcceptConnr" Bind this socket to a particular device like “eth0”."BindToDeviceOriginalDstIp6tOriginalDstr" Enable or disable the receiving of the `SO_TIMESTAMP` control message."ReceiveTimestampr" Enable or disable the receiving of the `SO_TIMESTAMPNS` control message."ReceiveTimestampnsr" Setting this boolean option enables transparent proxying on this socket."IpTransparentr" Set the mark for each packet sent through this socket (similar to the"r" netfilter MARK target but socket-based)."r" Enable or disable the receiving of the `SCM_CREDENTIALS` control"PassCredr" This option allows the caller to set the TCP congestion control"r" algorithm to be used,  on a per-socket basis."TcpCongestionr" Pass an `IP_PKTINFO` ancillary message that contains a pktinfo"r" structure that supplies some information about the incoming packet."r" Set delivery of the `IPV6_PKTINFO` control message on incoming"r" datagrams."Ipv6RecvPacketInfoUdpGsoSegmentUdpGroSegmentr" Indicates that an unsigned 32-bit value ancillary message (cmsg) should"r" be attached to received skbs indicating the number of packets dropped by"r" the socket since its creation."r" The socket is restricted to sending and receiving IPv6 packets only."Ipv6V6Onlyr" Enable extended reliable error message passing."r" Control receiving of asynchronous error options."r" Set or retrieve the current time-to-live field that is used in every"r" packet sent from this socket."Ipv4Ttlr" Set the unicast hop limit for the socket."Ipv6TtlAlgSetAeadAuthSize// Not documented by Linux!// ALG_SET_AEAD_AUTH_SIZE read the length from passed `option_len`// See https://elixir.bootlin.com/linux/v4.4/source/crypto/af_alg.c#L222AlgSetKeyffi_ptr/// Returns a pointer to the stored value. This pointer will be passed to the system's/// `getsockopt` call (`man 3p getsockopt`, argument `option_value`).ffi_len/// Returns length of the stored value. This pointer will be passed to the system's/// `getsockopt` call (`man 3p getsockopt`, argument `option_len`).assume_init/// Returns the hopefully initialized inner value./// Helper trait that describes what is expected from a `GetSockOpt` getter./// Initialize the setter with a given value./// `setsockopt` call (`man 3p setsockopt`, argument `option_value`)./// `setsockopt` call (`man 3p setsockopt`, argument `option_len`)./// Helper trait that describes what is expected from a `SetSockOpt` setter.GetStruct/// Getter for an arbitrary `struct`.SetStruct/// Setter for an arbitrary `struct`.GetBool/// Getter for a boolean value.SetBool/// Setter for a boolean value.GetU8/// Getter for an `u8` value.SetU8/// Setter for an `u8` value.GetUsize/// Getter for an `usize` value.SetUsize/// Setter for an `usize` value.GetOsString/// Getter for a `OsString` value.SetOsString/// Setter for a `OsString` value.can_get_peercred_on_unix_socketis_socket_type_unixis_socket_type_dgramcan_get_listen_on_tcp_socket//! Socket options as used by `setsockopt` and `getsockopt`./*
 *
 * ===== Define sockopts =====
 *
 *//*
 *
 * ===== Accessor helpers =====
 *
 */FileStatr#" "File type" flags for `mknod` and related functions."#SFlagr#" "File mode / permissions" flags."#/// Create a special or ordinary file, by pathname./// Create a special or ordinary file, relative to a given directory./// Change the file permission bits of the file specified by a file descriptor./// [fchmod(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmod.html).FchmodatFlagsFollowSymlinkNoFollowSymlink/// Flags for `fchmodat` function./// Change the file permission bits./// The file to be changed is determined relative to the directory associated/// with the file descriptor `dirfd` or the current working directory/// if `dirfd` is `None`./// If `flag` is `FchmodatFlags::NoFollowSymlink` and `path` names a symbolic link,/// then the mode of the symbolic link is changed./// `fchmodat(None, path, mode, FchmodatFlags::FollowSymlink)` is identical to/// a call `libc::chmod(path, mode)`. That's why `chmod` is unimplemented/// in the `nix` crate./// [fchmodat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmodat.html)./// Change the access and modification times of a file./// `utimes(path, times)` is identical to/// `utimensat(None, path, times, UtimensatFlags::FollowSymlink)`. The former/// is a deprecated API so prefer using the latter if the platforms you care/// about support it./// [utimes(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimes.html)./// Change the access and modification times of a file without following symlinks./// `lutimes(path, times)` is identical to/// `utimensat(None, path, times, UtimensatFlags::NoFollowSymlink)`. The former/// [lutimes(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lutimes.html)./// Change the access and modification times of the file specified by a file descriptor./// [futimens(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/futimens.html).UtimensatFlags/// Flags for `utimensat` function.// TODO: replace with fcntl::AtFlags/// If `flag` is `UtimensatFlags::NoFollowSymlink` and `path` names a symbolic link,/// `utimensat(None, path, times, UtimensatFlags::FollowSymlink)` is identical to/// `utimes(path, times)`. The latter is a deprecated API so prefer using the/// former if the platforms you care about support it./// [utimensat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimens.html)./// Identifies a mounted file systemStatfs/// Describes a mounted file systemfs_type_tFsType/// Describes the file system type as known by the operating system.// These constants are defined without documentation in the Linux headers, so we// can't very well document them here.filesystem_type/// Magic code defining system typeoptimal_transfer_size/// Optimal transfer block size/// Size of a block// f_bsize on linux: https://github.com/torvalds/linux/blob/master/fs/nfs/super.c#L471maximum_name_length/// Maximum length of filenames/// Total data blocks in filesystemblocks_free/// Free blocks in filesystemblocks_available/// Free blocks available to unprivileged user/// Total file nodes in filesystemfiles_free/// Free file nodes in filesystemfilesystem_id/// Filesystem ID/// Describes a mounted file system./// The result is OS-dependent.  For a portabable alternative, see/// [`statvfs`](crate::sys::statvfs::statvfs)./// `path` - Path to any file within the file system to describe/// [`fstatvfs`](crate::sys::statvfs::fstatvfs)./// `fd` - File descriptor of any open file within the file system to describestatfs_callfstatfs_callcheck_fstatfscheck_statfsassert_fs_equalsStatvfsstatfs_call_strict// This test is ignored because files_free/blocks_free can change after statvfs call and before// statfs call.fstatfs_call_strict// fstatfs call.check_fstatfs_strictcheck_statfs_strictassert_fs_equals_strict//! Get filesystem statistics, non-portably//! See [`statvfs`](crate::sys::statvfs) for a portable alternative.r" File system mount Flags"FsFlagsr" Read Only"r" Do not allow the set-uid bits to have an effect"r" Do not interpret character or block-special devices"r" Do not allow execution of binaries on the filesystem"r" All IO should be done synchronously"r" Allow mandatory locks on the filesystem"r" Write on file/directory/symlink"r" Append-only file"r" Immutable file"r" Do not update access times on files"r" Update access time relative to modify/change time"/// Wrapper around the POSIX `statvfs` struct/// For more information see the [`statvfs(3)` man pages](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_statvfs.h.html)./// get the file system block sizefragment_size/// Get the fundamental file system block size/// Get the number of blocks./// Units are in units of `fragment_size()`/// Get the number of free blocks in the file system/// Get the number of free blocks for unprivileged users/// Get the total number of file inodes/// Get the number of free file inodesfiles_available/// Get the number of free file inodes for unprivileged users/// Get the file system id/// Get the mount flags/// Get the maximum filename length/// Return a `Statvfs` object with information about the `path`/// Return a `Statvfs` object with information about `fd`statvfs_callfstatvfs_call//! Get filesystem statistics//! See [the man pages](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstatvfs.html)//! for more details.SysInfo/// System info structure returned by `sysinfo`.mem_blocks_t/// Returns the load average tuple./// The returned values represent the load average over time intervals of/// 1, 5, and 15 minutes, respectively./// Returns the time since system boot.process_count/// Current number of processes./// Returns the amount of swap memory in Bytes./// Returns the amount of unused swap memory in Bytes.ram_total/// Returns the total amount of installed RAM in Bytes.ram_unused/// Returns the amount of completely unused RAM in Bytes./// "Unused" in this context means that the RAM in neither actively used by/// programs, nor by the operating system as disk cache or buffer. It is/// "wasted" RAM since it currently serves no purpose.scale_mem/// Returns system information./// [See `sysinfo(2)`](https://man7.org/linux/man-pages/man2/sysinfo.2.html).input_flagsInputFlags/// Input mode flags (see `termios.c_iflag` documentation)output_flagsOutputFlags/// Output mode flags (see `termios.c_oflag` documentation)control_flags/// Control mode flags (see `termios.c_cflag` documentation)local_flagsLocalFlags/// Local mode flags (see `termios.c_lflag` documentation)control_chars/// Control characters (see `termios.c_cc` documentation)/// Stores settings for the termios API/// This is a wrapper around the `libc::termios` struct that provides a safe interface for the/// standard fields. The only safe way to obtain an instance of this struct is to extract it from/// an open port using `tcgetattr()`.get_libc_termios/// Exposes an immutable reference to the underlying `libc::termios` data structure./// This is not part of `nix`'s public API because it requires additional work to maintain type/// safety.get_libc_termios_mut/// Exposes the inner `libc::termios` datastore within `Termios`./// This is unsafe because if this is used to modify the inner `libc::termios` struct, it will/// not automatically update the safe wrapper type around it. In this case it should also be/// paired with a call to `update_wrapper()` so that the wrapper-type and internal/// representation stay consistent.update_wrapper/// Updates the wrapper values from the internal `libc::termios` data structure.r" Baud rates supported by the system."r" For the BSDs, arbitrary baud rates can be specified by using `u32`s directly instead of this"r" enum."r" B0 is special and will disable the port."r" Specify when a port configuration change should occur."r" Used as an argument to `tcsetattr()`"SetArgr" The change will occur immediately"r" The change occurs after all output has been written"r" Same as `TCSADRAIN`, but will also flush the input buffer"// TODO: Add TCSASOFT, which will require treating this as a bitfield.r" Specify a combination of the input and output buffers to flush"r" Used as an argument to `tcflush()`."FlushArgr" Flush data that was received but not read"r" Flush data written but not transmitted"r" Flush both received data not read and written data not transmitted"r" Specify how transmission flow should be altered"r" Used as an argument to `tcflow()`."FlowArgr" Suspend transmission"r" Resume transmission"r" Transmit a STOP character, which should disable a connected terminal device"r" Transmit a START character, which should re-enable a connected terminal device"r" Indices into the `termios.c_cc` array for special characters."SpecialCharacterIndices// TODO: Make this usable directly as a slice index.r" Flags for configuring the input mode of a terminal"r" Flags for configuring the output mode of a terminal"r" Flags for setting the control mode of a terminal"r" Flags for setting any local modes"r" Get input baud rate (see"r" [cfgetispeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfgetispeed.html))."r" `cfgetispeed()` extracts the input baud rate from the given `Termios` structure."r" Get output baud rate (see"r" [cfgetospeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfgetospeed.html))."r" `cfgetospeed()` extracts the output baud rate from the given `Termios` structure."r" Set input baud rate (see"r" [cfsetispeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfsetispeed.html))."r" `cfsetispeed()` sets the intput baud rate in the given `Termios` structure."r" Set output baud rate (see"r" [cfsetospeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfsetospeed.html))."r" `cfsetospeed()` sets the output baud rate in the given `Termios` structure."r" Set both the input and output baud rates (see"r" [termios(3)](https://www.freebsd.org/cgi/man.cgi?query=cfsetspeed))."r" `cfsetspeed()` sets the input and output baud rate in the given `Termios` structure. Note that"r" this is part of the 4.4BSD standard and not part of POSIX."/// Configures the port to something like the "raw" mode of the old Version 7 terminal driver (see/// [termios(3)](https://man7.org/linux/man-pages/man3/termios.3.html))./// `cfmakeraw()` configures the termios structure such that input is available character-by-/// character, echoing is disabled, and all special input and output processing is disabled. Note/// that this is a non-standard function, but is available on Linux and BSDs./// Return the configuration of a port/// [tcgetattr(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetattr.html))./// `tcgetattr()` returns a `Termios` structure with the current configuration for a port. Modifying/// this structure *will not* reconfigure the port, instead the modifications should be done to/// the `Termios` structure and then the port should be reconfigured using `tcsetattr()`./// Set the configuration for a terminal (see/// [tcsetattr(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsetattr.html))./// `tcsetattr()` reconfigures the given port based on a given `Termios` structure. This change/// takes affect at a time specified by `actions`. Note that this function may return success if/// *any* of the parameters were successfully set, not only if all were set successfully./// Block until all output data is written (see/// [tcdrain(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcdrain.html))./// Suspend or resume the transmission or reception of data (see/// [tcflow(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcflow.html))./// `tcflow()` suspends of resumes the transmission or reception of data for the given port/// depending on the value of `action`./// Discard data in the output or input queue (see/// [tcflush(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcflush.html))./// `tcflush()` will discard data for a terminal port in the input queue, output queue, or both/// Send a break for a specific duration (see/// [tcsendbreak(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsendbreak.html))./// When using asynchronous data transmission `tcsendbreak()` will transmit a continuous stream/// of zero-valued bits for an implementation-defined duration./// Get the session controlled by the given terminal (see/// [tcgetsid(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetsid.html)).//! An interface for controlling asynchronous communication ports//! This interface provides a safe wrapper around the termios subsystem defined by POSIX. The//! underlying types are all implemented in libc for most platforms and either wrapped in safer//! types here or exported directly.//! If you are unfamiliar with the `termios` API, you should first read the//! [API documentation](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/termios.h.html) and//! then come back to understand how `nix` safely wraps it.//! It should be noted that this API incurs some runtime overhead above the base `libc` definitions.//! As this interface is not used with high-bandwidth information, this should be fine in most//! cases. The primary cost when using this API is that the `Termios` datatype here duplicates the//! standard fields of the underlying `termios` struct and uses safe type wrappers for those fields.//! This means that when crossing the FFI interface to the underlying C library, data is first//! copied into the underlying `termios` struct, then the operation is done, and the data is copied//! back (with additional sanity checking) into the safe wrapper types. The `termios` struct is//! relatively small across all platforms (on the order of 32-64 bytes).//! The following examples highlight some of the API use cases such that users coming from using C//! or reading the standard documentation will understand how to use the safe API exposed here.//! Example disabling processing of the end-of-file control character://! # use self::nix::sys::termios::SpecialCharacterIndices::VEOF;//! # use self::nix::sys::termios::{_POSIX_VDISABLE, Termios};//! # let mut termios: Termios = unsafe { std::mem::zeroed() };//! termios.control_chars[VEOF as usize] = _POSIX_VDISABLE;//! The flags within `Termios` are defined as bitfields using the `bitflags` crate. This provides//! an interface for working with bitfields that is similar to working with the raw unsigned//! integer types but offers type safety because of the internal checking that values will always//! be a valid combination of the defined flags.//! An example showing some of the basic operations for interacting with the control flags://! # use self::nix::sys::termios::{ControlFlags, Termios};//! termios.control_flags & ControlFlags::CSIZE == ControlFlags::CS5;//! termios.control_flags |= ControlFlags::CS5;//! # Baud rates//! This API is not consistent across platforms when it comes to `BaudRate`: Android and Linux both//! only support the rates specified by the `BaudRate` enum through their termios API while the BSDs//! support arbitrary baud rates as the values of the `BaudRate` enum constants are the same integer//! value of the constant (`B9600` == `9600`). Therefore the `nix::termios` API uses the following//! conventions://! * `cfgetispeed()` - Returns `u32` on BSDs, `BaudRate` on Android/Linux//! * `cfgetospeed()` - Returns `u32` on BSDs, `BaudRate` on Android/Linux//! * `cfsetispeed()` - Takes `u32` or `BaudRate` on BSDs, `BaudRate` on Android/Linux//! * `cfsetospeed()` - Takes `u32` or `BaudRate` on BSDs, `BaudRate` on Android/Linux//! * `cfsetspeed()` - Takes `u32` or `BaudRate` on BSDs, `BaudRate` on Android/Linux//! The most common use case of specifying a baud rate using the enum will work the same across//! platforms://! # use nix::sys::termios::{BaudRate, cfsetispeed, cfsetospeed, cfsetspeed, Termios};//! # let mut t: Termios = unsafe { std::mem::zeroed() };//! cfsetispeed(&mut t, BaudRate::B9600);//! cfsetospeed(&mut t, BaudRate::B9600);//! cfsetspeed(&mut t, BaudRate::B9600);//! Additionally round-tripping baud rates is consistent across platforms://! # use nix::sys::termios::{BaudRate, cfgetispeed, cfgetospeed, cfsetispeed, cfsetspeed, Termios};//! # cfsetspeed(&mut t, BaudRate::B9600);//! let speed = cfgetispeed(&t);//! assert_eq!(speed, cfgetospeed(&t));//! cfsetispeed(&mut t, speed);//! On non-BSDs, `cfgetispeed()` and `cfgetospeed()` both return a `BaudRate`://! # use nix::sys::termios::{BaudRate, cfgetispeed, cfgetospeed, cfsetspeed, Termios};//! assert_eq!(cfgetispeed(&t), BaudRate::B9600);//! assert_eq!(cfgetospeed(&t), BaudRate::B9600);//! But on the BSDs, `cfgetispeed()` and `cfgetospeed()` both return `u32`s://! # cfsetspeed(&mut t, 9600u32);//! assert_eq!(cfgetispeed(&t), 9600u32);//! assert_eq!(cfgetospeed(&t), 9600u32);//! It's trivial to convert from a `BaudRate` to a `u32` on BSDs://! # use nix::sys::termios::{BaudRate, cfgetispeed, cfsetspeed, Termios};//! assert_eq!(cfgetispeed(&t), BaudRate::B9600.into());//! assert_eq!(u32::from(BaudRate::B9600), 9600u32);//! And on BSDs you can specify arbitrary baud rates (**note** this depends on hardware support)//! by specifying baud rates directly using `u32`s://! # use nix::sys::termios::{cfsetispeed, cfsetospeed, cfsetspeed, Termios};//! cfsetispeed(&mut t, 9600u32);//! cfsetospeed(&mut t, 9600u32);//! cfsetspeed(&mut t, 9600u32);// https://github.com/rust-lang/libc/issues/1848TIMESPEC_ZEROTS_MAX_SECONDSTS_MIN_SECONDStimespec_tv_nsec_t// The implementation of cmp is simplified by assuming that the struct is// normalized.  That is, tv_nsec must always be within [0, 1_000_000_000)/// Makes a new `TimeSpec` with given number of microseconds./// Makes a new `TimeSpec` with given number of nanoseconds.nanos_mod_secTV_MAX_SECONDSTV_MIN_SECONDS// normalized.  That is, tv_usec must always be within [0, 1_000_000)/// Makes a new `TimeVal` with given number of microseconds./// Makes a new `TimeVal` with given number of nanoseconds.  Some precision/// will be lostmicros_mod_secdiv_floor_64mod_floor_64div_rem_64test_timespectest_timespec_fromtest_timespec_negtest_timespec_ordtest_timespec_fmttest_timevaltest_timeval_ordtest_timeval_negtest_timeval_fmtTimerFd/// A timerfd instance. This is also a file descriptor, you can feed it tor" The type of the clock used to mark the progress of the timer. For more"r" details on each kind of clock, please refer to [timerfd_create(2)](https://man7.org/linux/man-pages/man2/timerfd_create.2.html)."r" Additional flags to change the behaviour of the file descriptor at the"r" time of creation."TimerFlagsr" Flags that are used for arming the timer."TimerSetTimeFlagsTimerSpecIntervalDelayedInterval/// An enumeration allowing the definition of the expiration time of an alarm,/// recurring or not./// Creates a new timer based on the clock defined by `clockid`. The/// underlying fd can be assigned specific flags with `flags` (CLOEXEC,/// NONBLOCK). The underlying fd will be closed on drop./// Sets a new alarm on the timer./// # Types of alarm/// There are 3 types of alarms you can set:///   - one shot: the alarm will trigger once after the specified amount of///     Example: I want an alarm to go off in 60s and then disables itself.///   - interval: the alarm will trigger every specified interval of time.///     Example: I want an alarm to go off every 60s. The alarm will first///     go off 60s after I set it and every 60s after that. The alarm will///     not disable itself.///   - interval delayed: the alarm will trigger after a certain amount of///     time and then trigger at a specified interval.///     Example: I want an alarm to go off every 60s but only start in 1h.///     The alarm will first trigger 1h after I set it and then every 60s///     after that. The alarm will not disable itself./// # Relative vs absolute alarm/// If you do not set any `TimerSetTimeFlags`, then the `TimeSpec` you pass/// to the `Expiration` you want is relative. If however you want an alarm/// to go off at a certain point in time, you can set `TFD_TIMER_ABSTIME`./// Then the one shot TimeSpec and the delay TimeSpec of the delayed/// interval are going to be interpreted as absolute./// # Disabling alarms/// Note: Only one alarm can be set for any given timer. Setting a new alarm/// actually removes the previous one./// Note: Setting a one shot alarm with a 0s TimeSpec disables the alarm/// altogether./// Get the parameters for the alarm currently set, if any./// Remove the alarm if any is set./// Wait for the configured alarm to expire./// Note: If the alarm is unset, then you will wait forever.//! Timer API via file descriptors.//! Timer FD is a Linux-only API to create timers and get expiration//! notifications through file descriptors.//! For more documentation, please read [timerfd_create(2)](https://man7.org/linux/man-pages/man2/timerfd_create.2.html).//! Create a new one-shot timer that expires after 1 second.//! # use std::os::unix::io::AsRawFd;//! # use nix::sys::timerfd::{TimerFd, ClockId, TimerFlags, TimerSetTimeFlags,//! #    Expiration};//! # use nix::sys::time::{TimeSpec, TimeValLike};//! # use nix::unistd::read;//! // We create a new monotonic timer.//! let timer = TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty())//! // We set a new one-shot timer in 1 seconds.//! timer.set(//!     Expiration::OneShot(TimeSpec::seconds(1)),//!     TimerSetTimeFlags::empty()//! // We wait for the timer to expire.//! timer.wait().unwrap();/// Low-level vectored write to a raw file descriptor/// See also [writev(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/writev.html)/// Low-level vectored read from a raw file descriptor/// See also [readv(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/readv.html)/// Write to `fd` at `offset` from buffers in `iov`./// Buffers in `iov` will be written in order until all buffers have been written/// or an error occurs. The file offset is not changed./// See also: [`writev`](fn.writev.html) and [`pwrite`](fn.pwrite.html)/// Read from `fd` at `offset` filling buffers in `iov`./// Buffers in `iov` will be filled in order until all buffers have been filled,/// no more bytes are available, or an error occurs. The file offset is not/// See also: [`readv`](fn.readv.html) and [`pread`](fn.pread.html)/// Low-level write to a file, with specified offset./// See also [pwrite(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pwrite.html)// TODO: move to unistd/// See also [pread(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pread.html)/// The starting address of this slice (`iov_base`)./// The number of bytes in this slice (`iov_len`).RemoteIoVec/// A slice of memory in a remote process, starting at address `base`/// and consisting of `len` bytes./// This is the same underlying C structure as [`IoVec`](struct.IoVec.html),/// except that it refers to memory in some other process, and is/// therefore not represented in Rust by an actual slice as `IoVec` is. It/// is used with [`process_vm_readv`](fn.process_vm_readv.html)/// and [`process_vm_writev`](fn.process_vm_writev.html)./// Write data directly to another process's virtual memory/// (see [`process_vm_writev`(2)])./// `local_iov` is a list of [`IoVec`]s containing the data to be written,/// and `remote_iov` is a list of [`RemoteIoVec`]s identifying where the/// data should be written in the target process. On success, returns the/// number of bytes written, which will always be a whole/// number of `remote_iov` chunks./// This requires the same permissions as debugging the process using/// [ptrace]: you must either be a privileged process (with/// `CAP_SYS_PTRACE`), or you must be running as the same user as the/// target process and the OS must have unprivileged debugging enabled./// This function is only available on Linux./// [`process_vm_writev`(2)]: https://man7.org/linux/man-pages/man2/process_vm_writev.2.html/// [ptrace]: ../ptrace/index.html/// [`IoVec`]: struct.IoVec.html/// [`RemoteIoVec`]: struct.RemoteIoVec.html/// Read data directly from another process's virtual memory/// (see [`process_vm_readv`(2)])./// `local_iov` is a list of [`IoVec`]s containing the buffer to copy/// data into, and `remote_iov` is a list of [`RemoteIoVec`]s identifying/// where the source data is in the target process. On success,/// returns the number of bytes written, which will always be a whole/// [`ptrace`]: you must either be a privileged process (with/// [`process_vm_readv`(2)]: https://man7.org/linux/man-pages/man2/process_vm_readv.2.html/// [`ptrace`]: ../ptrace/index.html/// A vector of buffers./// Vectored I/O methods like [`writev`] and [`readv`] use this structure for/// both reading and writing.  Each `IoVec` specifies the base address and/// length of an area in memory./// View the `IoVec` as a Rust slice./// Create an `IoVec` from a Rust slice./// Create an `IoVec` from a mutable Rust slice.//! Vectored I/OUtsName/// Describes the running system.  Return type of [`uname`]./// Name of the operating system implementation/// Network name of this machine./// Release level of the operating system./// Version level of the operating system./// Machine hardware platform./// Get system identificationtest_uname_linux//! Get system identificationr" Controls the behavior of [`waitpid`]."WaitPidFlagr" Do not block when there are no processes wishing to report status."r" Report the status of selected processes which are stopped due to a"r" [`SIGTTIN`](crate::sys::signal::Signal::SIGTTIN),"r" [`SIGTTOU`](crate::sys::signal::Signal::SIGTTOU),"r" [`SIGTSTP`](crate::sys::signal::Signal::SIGTSTP), or"r" [`SIGSTOP`](crate::sys::signal::Signal::SIGSTOP) signal."r" Report the status of selected processes which have terminated."r" Report the status of selected processes that have continued from a"r" job control stop by receiving a"r" [`SIGCONT`](crate::sys::signal::Signal::SIGCONT) signal."r" An alias for WUNTRACED."r" Don't reap, just poll status."r" Don't wait on children of other threads in this group"r" Wait on all children, regardless of type"r#" Wait for "clone" children only."#WaitStatusExited/// The process exited normally (as with `exit()` or returning from/// `main`) with the given exit code. This case matches the C macro/// `WIFEXITED(status)`; the second field is `WEXITSTATUS(status)`.Signaled/// The process was killed by the given signal. The third field/// indicates whether the signal generated a core dump. This case/// matches the C macro `WIFSIGNALED(status)`; the last two fields/// correspond to `WTERMSIG(status)` and `WCOREDUMP(status)`./// The process is alive, but was stopped by the given signal. This/// is only reported if `WaitPidFlag::WUNTRACED` was passed. This/// case matches the C macro `WIFSTOPPED(status)`; the second field/// is `WSTOPSIG(status)`.PtraceEvent/// The traced process was stopped by a `PTRACE_EVENT_*` event. See/// [`nix::sys::ptrace`] and [`ptrace`(2)] for more information. All/// currently-defined events use `SIGTRAP` as the signal; the third/// field is the `PTRACE_EVENT_*` value of the event./// [`nix::sys::ptrace`]: ../ptrace/index.html/// [`ptrace`(2)]: https://man7.org/linux/man-pages/man2/ptrace.2.htmlPtraceSyscall/// The traced process was stopped by execution of a system call,/// and `PTRACE_O_TRACESYSGOOD` is in effect. See [`ptrace`(2)] forContinued/// The process was previously stopped but has resumed execution/// after receiving a `SIGCONT` signal. This is only reported if/// `WaitPidFlag::WCONTINUED` was passed. This case matches the C/// macro `WIFCONTINUED(status)`.StillAlive/// There are currently no state changes to report in any awaited/// child process. This is only returned if `WaitPidFlag::WNOHANG`/// was used (otherwise `wait()` or `waitpid()` would block until/// there was something to report)./// Possible return values from `wait()` or `waitpid()`./// Each status (other than `StillAlive`) describes a state transition/// in a child process `Pid`, such as the process exiting or stopping,/// plus additional data about the transition if any./// Note that there are two Linux-specific enum variants, `PtraceEvent`/// and `PtraceSyscall`. Portable code should avoid exhaustively/// matching on `WaitStatus`./// Extracts the PID from the WaitStatus unless it equals StillAlive.exitedsignaledterm_signaldumped_corestoppedstop_signalsyscall_stopstop_additionalcontinued/// Convert a raw `wstatus` as returned by `waitpid`/`wait` into a `WaitStatus`/// Returns an `Error` corresponding to `EINVAL` for invalid status values./// Convert a `wstatus` obtained from `libc::waitpid` into a `WaitStatus`:/// use nix::sys::wait::WaitStatus;/// let pid = nix::unistd::Pid::from_raw(1);/// let status = WaitStatus::from_raw(pid, 0x0002);/// assert_eq!(status, Ok(WaitStatus::Signaled(pid, Signal::SIGINT, false)));/// Wait for a process to change status/// See also [waitpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/waitpid.html)/// Wait for any child process to change status or a signal is received./// See also [wait(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html)//! Wait for a process to change status/// Clock identifier/// Newtype pattern around `clockid_t` (which is just alias). It pervents bugs caused by/// accidentally passing wrong value./// Creates `ClockId` from raw `clockid_t`pid_cpu_clock_id/// Returns `ClockId` of a `pid` CPU-time clock/// Returns resolution of the clock id/// Returns the current time on the clock id/// Sets time to `timespec` on the clock id/// Gets the raw `clockid_t` wrapped by `self`/// Get the resolution of the specified clock, (see/// [clock_getres(2)](https://pubs.opengroup.org/onlinepubs/7908799/xsh/clock_getres.html))./// Get the time of the specified clock, (see/// [clock_gettime(2)](https://pubs.opengroup.org/onlinepubs/7908799/xsh/clock_gettime.html))./// Set the time of the specified clock, (see/// [clock_settime(2)](https://pubs.opengroup.org/onlinepubs/7908799/xsh/clock_settime.html))./// Get the clock id of the specified process id, (see/// [clock_getcpuclockid(3)](https://pubs.opengroup.org/onlinepubs/009695399/functions/clock_getcpuclockid.html)).UContextsigmask_mutpivot_rootsetresgetres/// User identifier/// Newtype pattern around `uid_t` (which is just alias). It prevents bugs caused by accidentally/// passing wrong value./// Creates `Uid` from raw `uid_t`./// Returns Uid of calling process. This is practically a more Rusty alias for `getuid`./// Returns effective Uid of calling process. This is practically a more Rusty alias for `geteuid`.is_root/// Returns true if the `Uid` represents privileged user - root. (If it equals zero.)/// Get the raw `uid_t` wrapped by `self`.ROOT/// Constant for UID = 0/// Group identifier/// Newtype pattern around `gid_t` (which is just alias). It prevents bugs caused by accidentally/// Creates `Gid` from raw `gid_t`./// Returns Gid of calling process. This is practically a more Rusty alias for `getgid`./// Returns effective Gid of calling process. This is practically a more Rusty alias for `getegid`./// Get the raw `gid_t` wrapped by `self`./// Process identifier/// Newtype pattern around `pid_t` (which is just alias). It prevents bugs caused by accidentally/// Creates `Pid` from raw `pid_t`./// Returns PID of calling process/// Returns PID of parent of calling process/// Get the raw `pid_t` wrapped by `self`./// Represents the successful result of calling `fork`/// When `fork` is called, the process continues execution in the parent process/// and in the new child.  This return type can be examined to determine whether/// you are now executing in the parent process or in the child.is_child/// Return `true` if this is the child process of the `fork()`is_parent/// Returns `true` if this is the parent process of the `fork()`/// Create a new child process duplicating the parent process ([see/// fork(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html))./// After calling the fork system call (successfully) two processes will/// be created that are identical with the exception of their pid and the/// return value of this function.  As an example:/// use nix::{sys::wait::waitpid,unistd::{fork, ForkResult, write}};/// match unsafe{fork()} {///    Ok(ForkResult::Parent { child, .. }) => {///        println!("Continuing execution in parent process, new child has pid: {}", child);///        waitpid(child, None).unwrap();///    Ok(ForkResult::Child) => {///        // Unsafe to use `println!` (or `unwrap`) here. See Safety.///        write(libc::STDOUT_FILENO, "I'm a new child process\n".as_bytes()).ok();///        unsafe { libc::_exit(0) };///    Err(_) => println!("Fork failed"),/// This will print something like the following (order indeterministic).  The/// thing to note is that you end up with two processes continuing execution/// immediately after the fork call but with different match arms./// Continuing execution in parent process, new child has pid: 1234/// I'm a new child process/// Get the pid of this process (see/// [getpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpid.html))./// Since you are running code, there is always a pid to return, so there/// is no error case that needs to be handled./// Get the pid of this processes' parent (see/// [getpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getppid.html))./// There is always a parent pid to return, so there is no error case that needs/// to be handled./// Set a process group ID (see/// [setpgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setpgid.html))./// Set the process group id (PGID) of a particular process.  If a pid of zero/// is specified, then the pid of the calling process is used.  Process groups/// may be used to group together a set of processes in order for the OS to/// apply some operations across the group./// `setsid()` may be used to create a new process group./// Create new session and set process group id (see/// [setsid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsid.html))./// Get the process group ID of a session leader/// [getsid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsid.html)./// Obtain the process group ID of the process that is the session leader of the process specified/// by pid. If pid is zero, it specifies the calling process./// Get the terminal foreground process group (see/// [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetpgrp.html))./// Get the group process id (GPID) of the foreground process group on the/// terminal associated to file descriptor (FD)./// Set the terminal foreground process group (see/// [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsetpgrp.html))./// Get the group process id (PGID) to the foreground process group on the/// Get the group id of the calling process (see///[getpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgrp.html))./// Get the process group id (PGID) of the calling process./// According to the man page it is always successful./// Get the caller's thread ID (see/// [gettid(2)](https://man7.org/linux/man-pages/man2/gettid.2.html)./// This function is only available on Linux based systems.  In a single/// threaded process, the main thread will have the same ID as the process.  In/// a multithreaded process, each thread will have a unique thread id but the/// same process ID./// No error handling is required as a thread id should always exist for any/// process, even if threads are not being used./// Create a copy of the specified file descriptor (see/// [dup(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html))./// The new file descriptor will be have a new index but refer to the same/// resource as the old file descriptor and the old and new file descriptors may/// be used interchangeably.  The new and old file descriptor share the same/// underlying resource, offset, and file status flags.  The actual index used/// for the file descriptor will be the lowest fd index that is available./// The two file descriptors do not share file descriptor flags (e.g. `OFlag::FD_CLOEXEC`)./// Create a copy of the specified file descriptor using the specified fd (see/// This function behaves similar to `dup()` except that it will try to use the/// specified fd instead of allocating a new one.  See the man pages for more/// detail on the exact behavior of this function./// Create a new copy of the specified file descriptor using the specified fd/// and flags (see [dup(2)](https://man7.org/linux/man-pages/man2/dup.2.html))./// This function behaves similar to `dup2()` but allows for flags to bedup3_polyfill/// Change the current working directory of the calling process (see/// [chdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html))./// This function may fail in a number of different scenarios.  See the man/// pages for additional details on possible failure cases./// Change the current working directory of the process to the one/// given as an open file descriptor (see/// [fchdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchdir.html))./// Creates new directory `path` with access rights `mode`.  (see [mkdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdir.html))/// There are several situations where mkdir might fail:/// - current user has insufficient rights in the parent directory/// - the path already exists/// - the path name is too long (longer than `PATH_MAX`, usually 4096 on linux, 1024 on OS X)/// use nix::unistd;/// use nix::sys::stat;/// let tmp_dir1 = tempdir().unwrap();/// let tmp_dir2 = tmp_dir1.path().join("new_dir");/// // create new directory and give read, write and execute rights to the owner/// match unistd::mkdir(&tmp_dir2, stat::Mode::S_IRWXU) {///    Ok(_) => println!("created {:?}", tmp_dir2),///    Err(err) => println!("Error creating directory: {}", err),/// Creates new fifo special file (named pipe) with path `path` and access rights `mode`./// There are several situations where mkfifo might fail:/// For a full list consult/// [posix specification](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkfifo.html)/// let tmp_dir = tempdir().unwrap();/// let fifo_path = tmp_dir.path().join("foo.pipe");/// // create new fifo and give read, write and execute rights to the owner/// match unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) {///    Ok(_) => println!("created {:?}", fifo_path),///    Err(err) => println!("Error creating fifo: {}", err),// RedoxFS does not support fifo yet/// If `dirfd` has a value, then `path` is relative to directory associated with the file descriptor./// If `dirfd` is `None`, then `path` is relative to the current working directory./// [mkfifoat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkfifoat.html).// mkfifoat is not implemented in OSX or android/// Creates a symbolic link at `path2` which points to `path1`./// If `dirfd` has a value, then `path2` is relative to directory associated/// with the file descriptor./// If `dirfd` is `None`, then `path2` is relative to the current working/// directory. This is identical to `libc::symlink(path1, path2)`./// See also [symlinkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/symlinkat.html).reserve_double_buffer_size// Double the buffer capacity up to limit. In case it already has// reached the limit, return Errno::ERANGE./// Returns the current directory as a `PathBuf`/// Err is returned if the current user doesn't have the permission to read or search a component/// of the current path./// // assume that we are allowed to get current directory/// let dir = unistd::getcwd().unwrap();/// println!("The current directory is {:?}", dir);chown_raw_ids/// Computes the raw UID and GID values to pass to a `*chown` call./// Change the ownership of the file at `path` to be owned by the specified/// `owner` (user) and `group` (see/// [chown(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/chown.html))./// The owner/group for the provided path name will not be modified if `None` is/// provided for that argument.  Ownership change will be attempted for the path/// only if `Some` owner/group is provided./// Change the ownership of the file referred to by the open file descriptor `fd` to be owned by/// the specified `owner` (user) and `group` (see/// [fchown(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchown.html))./// The owner/group for the provided file will not be modified if `None` isFchownatFlags/// Flags for `fchownat` function./// `owner` (user) and `group`./// If `flag` is `FchownatFlags::NoFollowSymlink` and `path` names a symbolic link,/// `fchownat(None, path, mode, FchownatFlags::NoFollowSymlink)` is identical to/// a call `libc::lchown(path, mode)`.  That's why `lchmod` is unimplemented in/// the `nix` crate./// [fchownat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchownat.html).to_exec_array/// Replace the current process image with a new one (see/// [exec(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html))./// See the `::nix::unistd::execve` system call for additional details.  `execv`/// performs the same action but does not allow for customization of the/// environment for the new process.SASE/// [execve(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html))./// The execve system call allows for another process to be "called" which will/// replace the current process image.  That is, this process becomes the new/// command that is run. On success, this function will not return. Instead,/// the new program will run until it exits./// `::nix::unistd::execv` and `::nix::unistd::execve` take as arguments a slice/// of `::std::ffi::CString`s for `args` and `env` (for `execve`). Each element/// in the `args` list is an argument to the new process. Each element in the/// `env` list should be a string in the form "key=value"./// Replace the current process image with a new one and replicate shell `PATH`/// searching behavior (see/// See `::nix::unistd::execve` for additional details.  `execvp` behaves the/// same as execv except that it will examine the `PATH` environment variables/// for file names not specified with a leading slash.  For example, `execv`/// would not work if "bash" was specified for the path argument, but `execvp`/// would assuming that a bash executable was on the system `PATH`./// [`execvpe(3)`](https://man7.org/linux/man-pages/man3/exec.3.html))./// This functions like a combination of `execvp(2)` and `execve(2)` to pass an/// environment and have a search path. See these two for additional/// [fexecve(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fexecve.html))./// The `fexecve` function allows for another process to be "called" which will/// This function is similar to `execve`, except that the program to be executed/// is referenced as a file descriptor instead of a path.// Note for NetBSD and OpenBSD: although rust-lang/libc includes it (under// unix/bsd/netbsdlike/) fexecve is not currently implemented on NetBSD nor on// OpenBSD./// Execute program relative to a directory file descriptor (see/// [execveat(2)](https://man7.org/linux/man-pages/man2/execveat.2.html))./// The `execveat` function allows for another process to be "called" which will/// is referenced as a file descriptor to the base directory plus a path./// Daemonize this process by detaching from the controlling terminal (see/// [daemon(3)](https://man7.org/linux/man-pages/man3/daemon.3.html))./// When a process is launched it is typically associated with a parent and it,/// in turn, by its controlling terminal/process.  In order for a process to run/// in the "background" it must daemonize itself by detaching itself.  Under/// posix, this is done by doing the following:/// 1. Parent process (this one) forks/// 2. Parent process exits/// 3. Child process continues to run./// `nochdir`:/// * `nochdir = true`: The current working directory after daemonizing will///    be the current working directory./// *  `nochdir = false`: The current working directory after daemonizing will///    be the root direcory, `/`./// `noclose`:/// * `noclose = true`: The process' current stdin, stdout, and stderr file///   descriptors will remain identical after daemonizing./// * `noclose = false`: The process' stdin, stdout, and stderr will point to///   `/dev/null` after daemonizing./// Set the system host name (see/// [sethostname(2)](https://man7.org/linux/man-pages/man2/gethostname.2.html))./// Given a name, attempt to update the system host name to the given string./// On some systems, the host name is limited to as few as 64 bytes.  An error/// will be return if the name is not valid or the current process does not have/// permissions to update the host name./// Get the host name and store it in the provided buffer, returning a pointer/// the `CStr` in that buffer on success (see/// [gethostname(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/gethostname.html))./// This function call attempts to get the host name for the running system and/// store it in a provided buffer.  The buffer will be populated with bytes up/// to the length of the provided slice including a NUL terminating byte.  If/// the hostname is longer than the length provided, no error will be provided./// The posix specification does not specify whether implementations will/// null-terminate in this case, but the nix implementation will ensure that the/// buffer is null terminated in this case./// let mut buf = [0u8; 64];/// let hostname_cstr = unistd::gethostname(&mut buf).expect("Failed getting hostname");/// let hostname = hostname_cstr.to_str().expect("Hostname wasn't valid UTF-8");/// println!("Hostname: {}", hostname);/// Close a raw file descriptor/// Be aware that many Rust types implicitly close-on-drop, including/// `std::fs::File`.  Explicitly closing them with this method too can result in/// a double-close condition, which can cause confusing `EBADF` errors in/// seemingly unrelated code.  Caveat programmer.  See also/// [close(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html)./// use nix::unistd::close;/// let f = tempfile::tempfile().unwrap();/// close(f.as_raw_fd()).unwrap();   // Bad!  f will also close on drop!/// use std::os::unix::io::IntoRawFd;/// close(f.into_raw_fd()).unwrap(); // Good.  into_raw_fd consumes f/// Read from a raw file descriptor./// See also [read(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html)/// Write to a raw file descriptor./// See also [write(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html)WhenceSeekSet/// Specify an offset relative to the start of the file.SeekCur/// Specify an offset relative to the current file location.SeekEnd/// Specify an offset relative to the end of the file.SeekData/// Specify an offset relative to the next location in the file greater than or/// equal to offset that contains some data. If offset points to/// some data, then the file offset is set to offset.SeekHole/// Specify an offset relative to the next hole in the file greater than/// or equal to offset. If offset points into the middle of a hole, then/// the file offset should be set to offset. If there is no hole past offset,/// then the file offset should be adjusted to the end of the file (i.e., there/// is an implicit hole at the end of any file)./// Directive that tells [`lseek`] and [`lseek64`] what the offset is relative to./// [`lseek`]: ./fn.lseek.html/// [`lseek64`]: ./fn.lseek64.html/// Move the read/write file offset./// See also [lseek(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lseek.html)/// Create an interprocess channel./// See also [pipe(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.html)/// Like `pipe`, but allows setting certain file descriptor flags./// The following flags are supported, and will be set atomically as the pipe is/// created:/// - `O_CLOEXEC`:    Set the close-on-exec flag for the new file descriptors./// - `O_NONBLOCK`:   Set the non-blocking flag for the ends of the pipe./// See also [pipe(2)](https://man7.org/linux/man-pages/man2/pipe.2.html)/// Truncate a file to a specified length/// [truncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/truncate.html)/// [ftruncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html)LinkatFlagsSymlinkFollowNoSymlinkFollow/// Flags for `linkat` function./// Link one file to another file/// Creates a new link (directory entry) at `newpath` for the existing file at `oldpath`. In the/// case of a relative `oldpath`, the path is interpreted relative to the directory associated/// with file descriptor `olddirfd` instead of the current working directory and similiarly for/// `newpath` and file descriptor `newdirfd`. In case `flag` is LinkatFlags::SymlinkFollow and/// `oldpath` names a symoblic link, a new link for the target of the symbolic link is created./// If either `olddirfd` or `newdirfd` is `None`, `AT_FDCWD` is used respectively where `oldpath`/// and/or `newpath` is then interpreted relative to the current working directory of the calling/// process. If either `oldpath` or `newpath` is absolute, then `dirfd` is ignored./// See also [linkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/linkat.html)// RedoxFS does not support symlinks yet/// Remove a directory entry/// See also [unlink(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlink.html)UnlinkatFlagsRemoveDirNoRemoveDir/// Flags for `unlinkat` function./// In the case of a relative path, the directory entry to be removed is determined relative to/// the directory associated with the file descriptor `dirfd` or the current working directory/// if `dirfd` is `None`. In the case of an absolute `path` `dirfd` is ignored. If `flag` is/// `UnlinkatFlags::RemoveDir` then removal of the directory entry specified by `dirfd` and `path`/// is performed./// See also [unlinkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlinkat.html)/// Commit filesystem caches to disk/// See also [sync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sync.html)/// Synchronize changes to a file/// See also [fsync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html)/// Synchronize the data of a file/// [fdatasync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fdatasync.html)// `fdatasync(2) is in POSIX, but in libc it is only defined in `libc::notbsd`.// TODO: exclude only Apple systems after https://github.com/rust-lang/libc/pull/211/// Get a real user ID/// See also [getuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getuid.html)// POSIX requires that getuid is always successful, so no need to check return// value or errno./// Get the effective user ID/// See also [geteuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/geteuid.html)// POSIX requires that geteuid is always successful, so no need to check return/// Get the real group ID/// See also [getgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getgid.html)// POSIX requires that getgid is always successful, so no need to check return/// Get the effective group ID/// See also [getegid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getegid.html)// POSIX requires that getegid is always successful, so no need to check return/// Set the effective user ID/// See also [seteuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/seteuid.html)/// Set the effective group ID/// See also [setegid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setegid.html)/// Set the user ID/// See also [setuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setuid.html)/// Set the group ID/// See also [setgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setgid.html)/// Set the user identity used for filesystem checks per-thread./// On both success and failure, this call returns the previous filesystem user/// ID of the caller./// See also [setfsuid(2)](https://man7.org/linux/man-pages/man2/setfsuid.2.html)/// Set the group identity used for filesystem checks per-thread./// On both success and failure, this call returns the previous filesystem group/// See also [setfsgid(2)](https://man7.org/linux/man-pages/man2/setfsgid.2.html)/// Get the list of supplementary group IDs of the calling process./// [Further reading](https://pubs.opengroup.org/onlinepubs/009695399/functions/getgroups.html)/// **Note:** This function is not available for Apple platforms. On those/// platforms, checking group membership should be achieved via communication/// with the `opendirectoryd` service./// Set the list of supplementary group IDs for the calling process./// [Further reading](https://man7.org/linux/man-pages/man2/getgroups.2.html)/// platforms, group membership management should be achieved via communication/// `setgroups` can be used when dropping privileges from the root user to a/// specific user and group. For example, given the user `www-data` with UID/// `33` and the group `backup` with the GID `34`, one could switch the user as/// # use nix::unistd::*;/// # fn try_main() -> Result<(), Box<Error>> {/// let uid = Uid::from_raw(33);/// let gid = Gid::from_raw(34);/// setgroups(&[gid])?;/// setgid(gid)?;/// setuid(uid)?;/// # try_main().unwrap();/// Calculate the supplementary group access list./// Gets the group IDs of all groups that `user` is a member of. The additional/// group `group` is also added to the list./// [Further reading](https://man7.org/linux/man-pages/man3/getgrouplist.3.html)/// Although the `getgrouplist()` call does not return any specific/// errors on any known platforms, this implementation will return a system/// error of `EINVAL` if the number of groups to be fetched exceeds the/// `NGROUPS_MAX` sysconf value. This mimics the behaviour of `getgroups()`/// and `setgroups()`. Additionally, while some implementations will return a/// partial list of groups when `NGROUPS_MAX` is exceeded, this implementation/// will only ever return the complete list or else an error./// Initialize the supplementary group access list./// Sets the supplementary group IDs for the calling process using all groups/// that `user` is a member of. The additional group `group` is also added to/// the list./// [Further reading](https://man7.org/linux/man-pages/man3/initgroups.3.html)/// `initgroups` can be used when dropping privileges from the root user to/// another user. For example, given the user `www-data`, we could look up the/// UID and GID for the user in the system's password database (usually found/// in `/etc/passwd`). If the `www-data` user's UID and GID were `33` and `33`,/// respectively, one could switch the user as follows:/// # use std::ffi::CString;/// let user = CString::new("www-data").unwrap();/// let gid = Gid::from_raw(33);/// initgroups(&user, gid)?;/// Suspend the thread until a signal is received./// See also [pause(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pause.html)./// Schedule an alarm signal./// This will cause the system to generate a `SIGALRM` signal for the/// process after the specified number of seconds have elapsed./// Returns the leftover time of a previously set alarm if there was one./// Cancel an previously set alarm signal.//! Alarm signal scheduling.//! Scheduling an alarm will trigger a `SIGALRM` signal when the time has//! elapsed, which has to be caught, because the default action for the//! signal is to terminate the program. This signal also can't be ignored//! because the system calls like `pause` will not be interrupted, see the//! second example below.//! Canceling an alarm://! use nix::unistd::alarm;//! // Set an alarm for 60 seconds from now.//! alarm::set(60);//! // Cancel the above set alarm, which returns the number of seconds left//! // of the previously set alarm.//! assert_eq!(alarm::cancel(), Some(60));//! Scheduling an alarm and waiting for the signal://! use nix::unistd::{alarm, pause};//! use nix::sys::signal::*;//! // We need to setup an empty signal handler to catch the alarm signal,//! // otherwise the program will be terminated once the signal is delivered.//! extern fn signal_handler(_: nix::libc::c_int) { }//! let sa = SigAction::new(//!     SigHandler::Handler(signal_handler),//!     SaFlags::SA_RESTART,//!     SigSet::empty()//! unsafe {//!     sigaction(Signal::SIGALRM, &sa);//! // Set an alarm for 1 second from now.//! alarm::set(1);//! // Pause the process until the alarm signal is received.//! let mut sigset = SigSet::empty();//! sigset.add(Signal::SIGALRM);//! sigset.wait();//! assert!(start.elapsed() >= Duration::from_secs(1));//! See also [alarm(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/alarm.html)./// Suspend execution for an interval of time/// See also [sleep(2)](https://pubs.opengroup.org/onlinepubs/009695399/functions/sleep.html#tag_03_705_05)// Per POSIX, does not fail/// Enable process accounting/// See also [acct(2)](https://linux.die.net/man/2/acct)/// Disable process accounting/// Creates a regular file which persists even after process termination/// * `template`: a path whose 6 rightmost characters must be X, e.g. `/tmp/tmpfile_XXXXXX`/// * returns: tuple of file descriptor and filename/// Err is returned either if no temporary filename could be created or the template doesn't/// end with XXXXXX/// See also [mkstemp(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkstemp.html)/// let _ = match unistd::mkstemp("/tmp/tempfile_XXXXXX") {///     Ok((fd, path)) => {///         unistd::unlink(path.as_path()).unwrap(); // flag file to be deleted at app termination///         fd///     Err(e) => panic!("mkstemp failed: {}", e)/// // do something with fdPathconfVarFILESIZEBITS/// Minimum number of bits needed to represent, as a signed integer value,/// the maximum size of a regular file allowed in the specified directory./// Maximum number of links to a single file./// Maximum number of bytes in a terminal canonical input line./// Minimum number of bytes for which space is available in a terminal input/// queue; therefore, the maximum number of bytes a conforming application/// may require to be typed as input before reading them./// Maximum number of bytes in a filename (not including the terminating/// null of a filename string)./// Maximum number of bytes the implementation will store as a pathname in a/// user-supplied buffer of unspecified size, including the terminating null/// character. Minimum number the implementation will accept as the maximum/// number of bytes in a pathname./// Maximum number of bytes that is guaranteed to be atomic when writing to/// a pipe.POSIX2_SYMLINKS/// Symbolic links can be created.POSIX_ALLOC_SIZE_MIN/// Minimum number of bytes of storage actually allocated for any portion of/// a file.POSIX_REC_INCR_XFER_SIZE/// Recommended increment for file transfer sizes between the/// `POSIX_REC_MIN_XFER_SIZE` and `POSIX_REC_MAX_XFER_SIZE` values.POSIX_REC_MAX_XFER_SIZE/// Maximum recommended file transfer size.POSIX_REC_MIN_XFER_SIZE/// Minimum recommended file transfer size.POSIX_REC_XFER_ALIGN///  Recommended file transfer buffer alignment.SYMLINK_MAX/// Maximum number of bytes in a symbolic link._POSIX_CHOWN_RESTRICTED/// The use of `chown` and `fchown` is restricted to a process with/// appropriate privileges, and to changing the group ID of a file only to/// the effective group ID of the process or to one of its supplementary/// group IDs._POSIX_NO_TRUNC/// Pathname components longer than {NAME_MAX} generate an error./// This symbol shall be defined to be the value of a character that shall/// disable terminal special character handling._POSIX_ASYNC_IO/// Asynchronous input or output operations may be performed for the/// associated file._POSIX_PRIO_IO/// Prioritized input or output operations may be performed for the_POSIX_SYNC_IO/// Synchronized input or output operations may be performed for the/// Variable names for `pathconf`/// Nix uses the same naming convention for these variables as the/// [getconf(1)](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/getconf.html) utility./// That is, `PathconfVar` variables have the same name as the abstract/// variables  shown in the `pathconf(2)` man page.  Usually, it's the same as/// the C variable name without the leading `_PC_`./// POSIX 1003.1-2008 standardizes all of these variables, but some OSes choose/// not to implement variables that cannot change at runtime./// - [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html)/// - [limits.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html)/// - [unistd.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/unistd.h.html)/// Like `pathconf`, but works with file descriptors instead of paths (see/// [fpathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html))/// - `fd`:   The file descriptor whose variable should be interrogated/// - `var`:  The pathconf variable to lookup/// - `Ok(Some(x))`: the variable's limit (for limit variables) or its///     implementation level (for option variables).  Implementation levels are///     usually a decimal-coded date, such as 200112 for POSIX 2001.12/// - `Ok(None)`: the variable has no limit (for limit variables) or is///     unsupported (for option variables)/// - `Err(x)`: an error occurred/// Get path-dependent configurable system variables (see/// [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html))/// Returns the value of a path-dependent configurable system variable.  Most/// supported variables also have associated compile-time constants, but POSIX/// allows their values to change at runtime.  There are generally two types of/// `pathconf` variables: options and limits.  See [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html) for more details./// - `path`: Lookup the value of `var` for this file or directory/// - `var`:  The `pathconf` variable to lookupSysconfVar/// Maximum number of I/O operations in a single list I/O call supported by/// the implementation.AIO_MAX/// Maximum number of outstanding asynchronous I/O operations supported byAIO_PRIO_DELTA_MAX/// The maximum amount by which a process can decrease its asynchronous I/O/// priority level from its own scheduling priority./// Maximum length of argument to the exec functions including environment data.ATEXIT_MAX/// Maximum number of functions that may be registered with `atexit`./// Maximum obase values allowed by the bc utility./// Maximum number of elements permitted in an array by the bc utility./// Maximum scale value allowed by the bc utility./// Maximum length of a string constant accepted by the bc utility./// Maximum number of simultaneous processes per real user ID.CLK_TCK// The number of clock ticks per second./// Maximum number of weights that can be assigned to an entry of the/// LC_COLLATE order keyword in the locale definition file/// Maximum number of timer expiration overruns./// Maximum number of expressions that can be nested within parentheses by/// the expr utility.HOST_NAME_MAX/// Maximum length of a host name (not including the terminating null) as/// returned from the `gethostname` function/// Maximum number of iovec structures that one process has available for/// use with `readv` or `writev`./// Unless otherwise noted, the maximum length, in bytes, of a utility's/// input line (either standard input or another file), when the utility is/// described as processing text files. The length includes room for the/// trailing newline./// Maximum length of a login name./// Maximum number of simultaneous supplementary group IDs per process.GETGR_R_SIZE_MAX/// Initial size of `getgrgid_r` and `getgrnam_r` data buffersGETPW_R_SIZE_MAX/// Initial size of `getpwuid_r` and `getpwnam_r` data buffersMQ_OPEN_MAX/// The maximum number of open message queue descriptors a process may hold./// The maximum number of message priorities supported by the implementation./// A value one greater than the maximum value that the system may assign to/// a newly-created file descriptor._POSIX_ADVISORY_INFO/// The implementation supports the Advisory Information option._POSIX_BARRIERS/// The implementation supports barriers._POSIX_ASYNCHRONOUS_IO/// The implementation supports asynchronous input and output._POSIX_CLOCK_SELECTION/// The implementation supports clock selection._POSIX_CPUTIME/// The implementation supports the Process CPU-Time Clocks option._POSIX_FSYNC/// The implementation supports the File Synchronization option._POSIX_IPV6/// The implementation supports the IPv6 option._POSIX_JOB_CONTROL/// The implementation supports job control._POSIX_MAPPED_FILES/// The implementation supports memory mapped Files._POSIX_MEMLOCK/// The implementation supports the Process Memory Locking option._POSIX_MEMLOCK_RANGE/// The implementation supports the Range Memory Locking option._POSIX_MEMORY_PROTECTION/// The implementation supports memory protection._POSIX_MESSAGE_PASSING/// The implementation supports the Message Passing option._POSIX_MONOTONIC_CLOCK/// The implementation supports the Monotonic Clock option._POSIX_PRIORITIZED_IO/// The implementation supports the Prioritized Input and Output option._POSIX_PRIORITY_SCHEDULING/// The implementation supports the Process Scheduling option._POSIX_RAW_SOCKETS/// The implementation supports the Raw Sockets option._POSIX_READER_WRITER_LOCKS/// The implementation supports read-write locks._POSIX_REALTIME_SIGNALS/// The implementation supports realtime signals._POSIX_REGEXP/// The implementation supports the Regular Expression Handling option._POSIX_SAVED_IDS/// Each process has a saved set-user-ID and a saved set-group-ID._POSIX_SEMAPHORES/// The implementation supports semaphores._POSIX_SHARED_MEMORY_OBJECTS/// The implementation supports the Shared Memory Objects option._POSIX_SHELL/// The implementation supports the POSIX shell._POSIX_SPAWN/// The implementation supports the Spawn option._POSIX_SPIN_LOCKS/// The implementation supports spin locks._POSIX_SPORADIC_SERVER/// The implementation supports the Process Sporadic Server option._POSIX_SS_REPL_MAX_POSIX_SYNCHRONIZED_IO/// The implementation supports the Synchronized Input and Output option._POSIX_THREAD_ATTR_STACKADDR/// The implementation supports the Thread Stack Address Attribute option._POSIX_THREAD_ATTR_STACKSIZE/// The implementation supports the Thread Stack Size Attribute option._POSIX_THREAD_CPUTIME/// The implementation supports the Thread CPU-Time Clocks option._POSIX_THREAD_PRIO_INHERIT/// The implementation supports the Non-Robust Mutex Priority Inheritance_POSIX_THREAD_PRIO_PROTECT/// The implementation supports the Non-Robust Mutex Priority Protection option._POSIX_THREAD_PRIORITY_SCHEDULING/// The implementation supports the Thread Execution Scheduling option._POSIX_THREAD_PROCESS_SHARED/// The implementation supports the Thread Process-Shared Synchronization_POSIX_THREAD_ROBUST_PRIO_INHERIT/// The implementation supports the Robust Mutex Priority Inheritance option._POSIX_THREAD_ROBUST_PRIO_PROTECT/// The implementation supports the Robust Mutex Priority Protection option._POSIX_THREAD_SAFE_FUNCTIONS/// The implementation supports thread-safe functions._POSIX_THREAD_SPORADIC_SERVER/// The implementation supports the Thread Sporadic Server option._POSIX_THREADS/// The implementation supports threads._POSIX_TIMEOUTS/// The implementation supports timeouts._POSIX_TIMERS/// The implementation supports timers._POSIX_TRACE/// The implementation supports the Trace option._POSIX_TRACE_EVENT_FILTER/// The implementation supports the Trace Event Filter option._POSIX_TRACE_EVENT_NAME_MAX_POSIX_TRACE_INHERIT/// The implementation supports the Trace Inherit option._POSIX_TRACE_LOG/// The implementation supports the Trace Log option._POSIX_TRACE_NAME_MAX_POSIX_TRACE_SYS_MAX_POSIX_TRACE_USER_EVENT_MAX_POSIX_TYPED_MEMORY_OBJECTS/// The implementation supports the Typed Memory Objects option._POSIX_VERSION/// Integer value indicating version of this standard (C-language binding)/// to which the implementation conforms. For implementations conforming to/// POSIX.1-2008, the value shall be 200809L._POSIX_V6_ILP32_OFF32/// The implementation provides a C-language compilation environment with/// 32-bit `int`, `long`, `pointer`, and `off_t` types._POSIX_V6_ILP32_OFFBIG/// 32-bit `int`, `long`, and pointer types and an `off_t` type using at/// least 64 bits._POSIX_V6_LP64_OFF64/// 32-bit `int` and 64-bit `long`, `pointer`, and `off_t` types._POSIX_V6_LPBIG_OFFBIG/// The implementation provides a C-language compilation environment with an/// `int` type using at least 32 bits and `long`, pointer, and `off_t` types/// using at least 64 bits._POSIX2_C_BIND/// The implementation supports the C-Language Binding option._POSIX2_C_DEV/// The implementation supports the C-Language Development Utilities option._POSIX2_CHAR_TERM/// The implementation supports the Terminal Characteristics option._POSIX2_FORT_DEV/// The implementation supports the FORTRAN Development Utilities option._POSIX2_FORT_RUN/// The implementation supports the FORTRAN Runtime Utilities option._POSIX2_LOCALEDEF/// The implementation supports the creation of locales by the localedef/// utility._POSIX2_PBS/// The implementation supports the Batch Environment Services and Utilities_POSIX2_PBS_ACCOUNTING/// The implementation supports the Batch Accounting option._POSIX2_PBS_CHECKPOINT/// The implementation supports the Batch Checkpoint/Restart option._POSIX2_PBS_LOCATE/// The implementation supports the Locate Batch Job Request option._POSIX2_PBS_MESSAGE/// The implementation supports the Batch Job Message Request option._POSIX2_PBS_TRACK/// The implementation supports the Track Batch Job Request option._POSIX2_SW_DEV/// The implementation supports the Software Development Utilities option._POSIX2_UPE/// The implementation supports the User Portability Utilities option._POSIX2_VERSION/// Integer value indicating version of the Shell and Utilities volume of/// POSIX.1 to which the implementation conforms.PAGE_SIZE/// The size of a system page in bytes./// POSIX also defines an alias named `PAGESIZE`, but Rust does not allow two/// enum constants to have the same value, so nix omits `PAGESIZE`.PTHREAD_THREADS_MAXSIGQUEUE_MAXSTREAM_MAXSYMLOOP_MAXTIMER_MAXTTY_NAME_MAXTZNAME_MAX_XOPEN_CRYPT/// The implementation supports the X/Open Encryption Option Group._XOPEN_ENH_I18N/// The implementation supports the Issue 4, Version 2 Enhanced/// Internationalization Option Group._XOPEN_LEGACY_XOPEN_REALTIME/// The implementation supports the X/Open Realtime Option Group._XOPEN_REALTIME_THREADS/// The implementation supports the X/Open Realtime Threads Option Group._XOPEN_SHM/// The implementation supports the Issue 4, Version 2 Shared Memory Option/// Group._XOPEN_STREAMS/// The implementation supports the XSI STREAMS Option Group._XOPEN_UNIX/// The implementation supports the XSI option_XOPEN_VERSION/// Integer value indicating version of the X/Open Portability Guide to/// which the implementation conforms./// Variable names for `sysconf`/// That is, `SysconfVar` variables have the same name as the abstract variables/// shown in the `sysconf(3)` man page.  Usually, it's the same as the C/// variable name without the leading `_SC_`./// All of these symbols are standardized by POSIX 1003.1-2008, but haven't been/// implemented by all platforms./// - [sysconf(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html)/// Get configurable system variables (see/// [sysconf(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html))/// Returns the value of a configurable system variable.  Most supported/// variables also have associated compile-time constants, but POSIX/// sysconf variables: options and limits.  See sysconf(3) for more details./// Sets the real, effective, and saved uid./// ([see setresuid(2)](https://man7.org/linux/man-pages/man2/setresuid.2.html))/// * `ruid`: real user id/// * `euid`: effective user id/// * `suid`: saved user id/// * returns: Ok or libc error code./// Err is returned if the user doesn't have permission to set this UID./// Sets the real, effective, and saved gid./// * `rgid`: real group id/// * `egid`: effective group id/// * `sgid`: saved group id/// Err is returned if the user doesn't have permission to set this GID.ResUid/// Real, effective and saved user IDs.ResGid/// Real, effective and saved group IDs./// Gets the real, effective, and saved user IDs./// ([see getresuid(2)](http://man7.org/linux/man-pages/man2/getresuid.2.html))/// #Returns/// - `Ok((Uid, Uid, Uid))`: tuple of real, effective and saved uids on success./// - `Err(x)`: libc error code on failure./// Gets the real, effective, and saved group IDs./// ([see getresgid(2)](http://man7.org/linux/man-pages/man2/getresgid.2.html))/// - `Ok((Gid, Gid, Gid))`: tuple of real, effective and saved gids on success.r" Options for access()"AccessFlagsr" Test for existence of file."r" Test for read permission."r" Test for write permission."r" Test for execute (search) permission."/// Checks the file named by `path` for accessibility according to the flags given by `amode`/// See [access(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/access.html)/// Username/// User password (probably encrypted)/// User ID/// Group IDgecos/// User information/// Home directory/// Path to shell/// Representation of a User, based on `libc::passwd`/// The reason some fields in this struct are `String` and others are `CString` is because some/// fields are based on the user's locale, which could be non-UTF8, while other fields are/// guaranteed to conform to [`NAME_REGEX`](https://serverfault.com/a/73101/407341), which only/// contains ASCII.// RedoxFS does not support passwdfrom_anything/// Get a user by UID./// Internally, this function calls/// [getpwuid_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)/// use nix::unistd::{Uid, User};/// // Returns an Result<Option<User>>, thus the double unwrap./// let res = User::from_uid(Uid::from_raw(0)).unwrap().unwrap();/// assert!(res.name == "root");/// Get a user by name./// [getpwnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)/// use nix::unistd::User;/// let res = User::from_name("root").unwrap().unwrap();/// Group name/// Group password/// List of Group members/// Representation of a Group, based on `libc::group`membersfrom_gid/// Get a group by GID./// [getgrgid_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)// Disable this test on all OS except Linux as root group may not exist./// use nix::unistd::{Gid, Group};/// // Returns an Result<Option<Group>>, thus the double unwrap./// let res = Group::from_gid(Gid::from_raw(0)).unwrap().unwrap();/// Get a group by name./// [getgrnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)/// use nix::unistd::Group;/// let res = Group::from_name("root").unwrap().unwrap();/// Get the name of the terminal device that is open on file descriptor fd/// (see [`ttyname(3)`](https://man7.org/linux/man-pages/man3/ttyname.3.html)).//! Safe wrappers around functions found in libc "unistd.h" headerrequire_mount/// Skip the test if we don't have the ability to mount file systems.skip_if_cirrusskip_if_jailedskip_if_not_roottest_signaltest_aio// NOTE: DragonFly lacks a kernel-level implementation of Posix AIO as of// this writing. There is an user-level implementation, but whether aio// works or not heavily depends on which pthread implementation is chosen// by the user at link time. For this reason we do not want to run aio test// cases on DragonFly.test_mmantest_signalfdtest_sockettest_sockopttest_sysinfotest_termiostest_ioctltest_uiotest_epolltest_inotifytest_pthreadtest_ptracetest_timerfdpoll_aio// Helper that polls an AioCb for completion or errorpoll_lio// Helper that polls a component of an LioCb for completion or errortest_accessorstest_cancel// Tests AioCb.cancel.  We aren't trying to test the OS's implementation, only// our bindings.  So it's sufficient to check that AioCb.cancel returned any// AioCancelStat value.test_aio_cancel_all// Tests using aio_cancel_all for all outstanding IOs.test_fsynctest_fsync_error/// `AioCb::fsync` should not modify the `AioCb` object if `libc::aio_fsync` returns/// an error// Skip on Linux, because Linux's AIO implementation can't detect errors// synchronouslytest_aio_suspend// On Cirrus on Linux, this test fails due to a glibc bug.// https://github.com/nix-rust/nix/issues/1099// On Cirrus, aio_suspend is failing with EINVAL// https://github.com/nix-rust/nix/issues/1361// Test a simple aio operation with no completion notification.  We must poll// for completiontest_read_error/// `AioCb::read` should not modify the `AioCb` object if `libc::aio_read`/// returns an errortest_read_into_mut_slice// Tests from_mut_slicetest_read_into_pointer// Tests from_ptrtest_read_immutable_buffer// Test reading into an immutable buffer.  It should fail// FIXME: This test fails to panic on Linux/musl// for completion.  Unlike test_aio_read, this test uses AioCb::from_slicetest_write_from_pointer// Tests `AioCb::from_ptr`test_write_error/// `AioCb::write` should not modify the `AioCb` object if `libc::aio_write`sigfunctest_write_sigev_signal// Test an aio operation with completion delivered by a signal// FIXME: This test is ignored on mips because of failures in qemu in CItest_liocb_listio_wait// Test LioCb::listio with LIO_WAIT, so all AIO ops should be complete by the// time listio returns.test_liocb_listio_nowait// Test LioCb::listio with LIO_NOWAIT and no SigEvent, so we must use some other// mechanism to check for the individual AioCb's completion.test_liocb_listio_signal// Test LioCb::listio with LIO_NOWAIT and a SigEvent to indicate when all// AioCb's are complete.// FIXME: This test is ignored on mips/mips64 because of failures in qemu in CI.test_liocb_listio_read_immutable// Try to use LioCb::listio to read into an immutable buffer.  It should failtest_drop// Test dropping an AioCb that hasn't yet finished.// This must happen in its own process, because on OSX this test seems to hose// the AIO subsystem and causes subsequent tests to failtest_epoll_errnotest_epoll_ctltest_inotify_multi_events// Simple tests to ensure macro generated fns compileSPI_IOC_MAGICSPI_IOC_MESSAGEtest_op_nonetest_op_writetest_op_write_64test_op_readtest_op_read_64test_op_read_writetest_op_read_write_64test_op_write_inttest_ioctl_none_badtest_ioctl_read_badtest_ioctl_write_int_badtest_ioctl_write_ptr_bad// From linux/videodev2.htest_ioctl_nonev4l2_audiotest_ioctl_write_ptrHCI_IOC_MAGIC// From linux/net/bluetooth/hci_sock.hHCI_IOC_HCIDEVUPtest_ioctl_write_inttest_ioctl_readtest_ioctl_readwritetx_bufrx_bufspeed_hzdelay_usecsbits_per_wordcs_changetx_nbitsrx_nbitsspi_ioc_transfer// From linux/spi/spidev.htest_ioctl_write_buf// FIXME: Find a suitable example for `ioctl_readwrite_bad`// FIXME: Find a suitable example for `ioctl_read_buf`.// FIXME: Find a suitable example for `ioctl_readwrite_buf`.linux_ioctlsTTY_IOC_MAGIC// From sys/sys/ttycom.hTTY_IOC_TYPE_NXCLTTY_IOC_TYPE_GETATTY_IOC_TYPE_SETAfreebsd_ioctls// See C code for source of values for op calculations (does NOT work for mips/powerpc):// https://gist.github.com/posborne/83ea6880770a1aef332e// TODO:  Need a way to compute these constants at test time.  Using precomputed// values is fragile and needs to be maintained.CtlValueBYTES_PER_OPfinish_liocb/// Attempt to collect final status for all of `liocb`'s operations, freeing/// system resourcestest_lio_listio_resubmit// Deliberately exceed system resource limits, causing lio_listio to return EIO.// This test must run in its own process since it deliberately uses all AIO// resources.  ATM it is only enabled on FreeBSD, because I don't know how to// check system AIO limits on other operating systems.// Annoyingly, Cargo is unable to conditionally build an entire test binary.  So// we must disable the test here rather than in Cargo.tomltest_mmap_anonymoustest_mremap_growtest_mremap_shrink// Segfaults for unknown reasons under QEMU for 32-bit targetstest_pthread_selftest_pthread_kill_nonetest_ptrace_setoptions// Just make sure ptrace_setoptions can be called at all, for now.test_ptrace_getevent// Just make sure ptrace_getevent can be called at all, for now.test_ptrace_getsiginfo// Just make sure ptrace_getsiginfo can be called at all, for now.test_ptrace_setsiginfo// Just make sure ptrace_setsiginfo can be called at all, for now.test_ptrace_conttest_ptrace_interrupttest_ptrace_syscall// ptrace::{setoptions, getregs} are only available in these platformstest_pselecttest_pselect_nfds2generate_fdset_bad_fd_teststest_fdset_negative_fdtest_fdset_too_large_fdtest_kill_nonetest_killpg_nonetest_old_sigaction_flagstest_sigprocmask_nooptest_sigprocmasktest_sigaction_handlertest_sigaction_actiontest_signal_sigactiontest_inetv4_addr_to_sock_addrtest_inetv4_addr_roundtrip_sockaddr_storage_to_addrtest_inetv6_addr_to_sock_addrtest_inetv6_addr_roundtrip_sockaddr_storage_to_addrtest_path_to_sock_addrcalculate_hashtest_addr_equality_pathtest_abstract_sun_path_too_longtest_addr_equality_abstracttest_abstract_uds_addr// Test getting/setting abstract addresses (without unix socket creation)test_getsocknametest_socketpairFsFrsendrecvgso// Disable the test under emulation because it fails in Cirrus-CI.  Lack// of QEMU support is suspected.gro// Disable the test on emulated platforms because it fails in Cirrus-CI.// Lack of QEMU support is suspected.udp_offloadudp_sendmmsgudp_recvmmsgudp_recvmmsg_dontwait_short_readtest_recvmsg_ebadf// Test error handling of our recvmsg wrappertest_scm_rights// Disable the test on emulated platforms due to a bug in QEMU versions <// 2.12.0.  https://bugs.launchpad.net/qemu/+bug/1701808test_af_alg_cipher// Disable the test on emulated platforms due to not enabled support of AF_ALG in QEMU from rust crosstest_af_alg_aead// Disable the test on emulated platforms due to not enabled support of AF_ALG// in QEMU from rust crosstest_sendmsg_ipv4packetinfo// Verify `ControlMessage::Ipv4PacketInfo` for `sendmsg`.// This creates a (udp) socket bound to localhost, then sends a message to// itself but uses Ipv4PacketInfo to force the source address to be localhost.// This would be a more interesting test if we could assume that the test host// has more than one IP address (since we could select a different address to// test from).test_sendmsg_ipv6packetinfo// Verify `ControlMessage::Ipv6PacketInfo` for `sendmsg`.// This creates a (udp) socket bound to ip6-localhost, then sends a message to// itself but uses Ipv6PacketInfo to force the source address to be// ip6-localhost.test_scm_rights_single_cmsg_multiple_fds/// Tests that passing multiple fds using a single `ControlMessage` works.test_sendmsg_empty_cmsgs// Verify `sendmsg` builds a valid `msghdr` when passing an empty// `cmsgs` argument.  This should result in a msghdr with a nullptr// msg_control field and a msg_controllen of 0 when calling into the// raw `sendmsg`.test_scm_credentialstest_scm_credentials_and_rights/// Ensure that we can send `SCM_CREDENTIALS` and `SCM_RIGHTS` with a single/// `sendmsg` call.// qemu's handling of multiple cmsgs is bugged, ignore tests under emulation// see https://bugs.launchpad.net/qemu/+bug/1781280test_too_large_cmsgspace/// Ensure that passing a an oversized control message buffer to recvmsg/// still works.test_impl_scm_credentials_and_rightstest_unixdomain// Test creating and using named unix domain socketstest_syscontrol// Test creating and using named system control socketsloopback_addresstest_recv_ipv4pktinfo// qemu doesn't seem to be emulating this correctly in these architecturestest_recviftest_recv_ipv6pktinfotest_vsocktest_recvmsg_timestampns// Disable the test on emulated platforms because it fails in Cirrus-CI.  Lacktest_recvmmsg_timestampnstest_recvmsg_rxq_ovfltest_recverr_v4// Send a UDP datagram to a bogus destination address and observe an ICMP error (v4).// Disable the test on QEMU because QEMU emulation of IP_RECVERR is broken (as documented on PR// #1514).test_recverr_v6// Essentially the same test as v4.// Disable the test on QEMU because QEMU emulation of IPV6_RECVERR is broken (as documented on// PR #1514).OPTTESTFtest_recverr_impllinux_errqueuetest_local_peercred_seqpacket// NB: FreeBSD supports LOCAL_PEERCRED for SOCK_SEQPACKET, but OSX does not.test_local_peercred_streamis_so_mark_functionaltest_so_buftest_so_tcp_maxsegtest_so_typetest_so_type_unknown/// getsockopt(_, sockopt::SockType) should gracefully handle unknown socket/// types.  Regression test for https://github.com/nix-rust/nix/issues/1819test_tcp_congestion// The CI doesn't supported getsockopt and setsockopt on emulated processors.// It's beleived that a QEMU issue, the tests run ok on a fully emulated system.// Current CI just run the binary with QEMU but the Kernel remains the same as the host.// So the syscall doesn't work properly unless the kernel is also emulated.test_bindtodevicetest_so_tcp_keepalivetest_ttl_optstest_chflags// The conversion is not useless on all platforms.sysinfo_works/// Helper function analogous to `std::io::Write::write_all`, but for `RawFd`stest_tcgetattr_pty// Test tcgetattr on a terminaltest_tcgetattr_enotty// Test tcgetattr on something that isn't a terminaltest_tcgetattr_ebadf// Test tcgetattr on an invalid file descriptortest_output_flags// Test modifying output flagstest_local_flags// Test modifying local flagstest_timerfd_oneshottest_timerfd_intervaltest_timerfd_unsettest_writevtest_readvtest_pwritetest_preadtest_pwritevtest_preadvtest_process_vm_readv// qemu-user doesn't implement process_vm_readv/writev on most archestest_wait_signaltest_wait_exittest_waitstatus_from_rawtest_waitstatus_pidptrace_childptrace_parenttest_wait_ptrace// FIXME: qemu-user doesn't implement ptrace on most archestest_dirtest_fcntltest_kmodtest_nmounttest_mqtest_nettest_nix_pathtest_resourcetest_polltest_ptytest_schedtest_sendfiletest_stattest_timetest_unistd/// Helper function analogous to `std::io::Read::read_exact`, but for `RawFD`s_gDirRestore/// RAII object that restores a test's original directory on dropebadftest_openattest_renameattest_renameat2_behaves_like_renameat_with_no_flagstest_renameat2_exchangetest_renameat2_noreplacetest_readlinktest_copy_file_range/// This test creates a temporary file containing the contents/// 'foobarbaz' and uses the `copy_file_range` call to transfer/// 3 bytes at offset 3 (`bar`) to another empty file at offset 0. The/// resulting file is read and should contain the contents `bar`./// The from_offset should be updated by the call to reflect/// the 3 bytes read (6).// QEMU does not support copy_file_range. Skip under qemutest_splicetest_teetest_vmsplicetest_fallocatetest_ofd_write_locktest_ofd_read_locklock_info// The tests below are disabled for the listed targets// due to OFD locks not being available in the kernel/libc// versions used in the CI environment, probably because// they run under QEMU.test_successtest_errnotest_posix_fadvisetest_posix_fallocatecompile_kernel_moduletest_finit_and_delete_moduletest_finit_and_delete_module_with_paramstest_init_and_delete_moduletest_init_and_delete_module_with_paramstest_finit_module_invalidtest_finit_module_twice_and_delete_moduletest_delete_module_not_loadedSCRIPT_CONTENTSEXPECTED_STATUStest_mount_tmpfs_without_flags_allows_rwxtest_mount_rdonly_disallows_writetest_mount_noexec_disallows_exectest_mount_bindsetup_namespacestest_mountrun_tests/// Mimic normal test output (hackishly).// Impelmentation note: to allow unprivileged users to run it, this test makes// use of user and mount namespaces. On systems that allow unprivileged user// namespaces (Linux >= 3.8 compiled with CONFIG_USER_NS), the test should run// without root.// Test runnertest_mq_send_and_receivetest_mq_getattrtest_mq_setattr// FIXME: Fix failures for mips in QEMUtest_mq_set_nonblockingtest_mq_unlinkLOOPBACKtest_if_nametoindexbad_fstypeloop_while_eintrtest_ppoll// ppoll(2) is the same as poll except for how it handles timeouts and signals.// Repeating the test for poll(2) should be sufficient to check that our// bindings are correct.test_pollfd_fdtest_pollfd_eventstest_explicit_close/// Regression test for Issue #659/// This is the correct way to explicitly close a `PtyMaster`test_ptsname_equivalence/// Test equivalence of `ptsname` and `ptsname_r`test_ptsname_copy/// Test data copying of `ptsname`// TODO need to run in a subprocess, since ptsname is non-reentranttest_ptsname_r_copy/// Test data copying of `ptsname_r`test_ptsname_unique/// Test that `ptsname` returns different names for different devicesopen_ptty_pair/// Common setup for testing PTTY pairstest_open_ptty_pair/// Test opening a master/slave PTTY pair/// This uses a common `open_ptty_pair` because much of these functions aren't useful by/// themselves. So for this test we perform the basic act of getting a file handle for a/// master/slave PTTY pair, then just sanity-check the raw values.make_raw/// Put the terminal in raw mode.test_read_ptty_pair/// Test `io::Read` on the PTTY mastertest_write_ptty_pair/// Test `io::Write` on the PTTY mastertest_openptytest_openpty_with_termiostest_forkptytest_double_close/// `PtyMaster` should panic rather than double close the file descriptor/// This must run in its own test process because it deliberately creates a/// race condition.test_resource_limits_nofile/// Tests the RLIMIT_NOFILE functionality of getrlimit(), where the resource RLIMIT_NOFILE refers/// to the maximum file descriptor number that can be opened by the process (aka the maximum number/// of file descriptors that the process can open, since Linux 4.5)./// We first fetch the existing file descriptor maximum values using getrlimit(), then edit the/// soft limit to make sure it has a new and distinct value to the hard limit. We then setrlimit()/// to put the new soft limit in effect, and then getrlimit() once more to ensure the limits have/// been updated.test_sched_affinitytest_sendfile_linuxtest_sendfile64_linuxtest_sendfile_freebsdtest_sendfile_darwinassert_stat_resultsassert_lstat_results// (Android's st_blocks is ulonglong which is always non-negative.)// Not absurd on all OSestest_stat_and_fstattest_fstatattest_stat_fstat_lstattest_fchmodtest_fchmodatassert_times_eq/// Asserts that the atime and mtime in a file's metadata match expected values./// The atime and mtime are expressed with a resolution of seconds because some file systems/// (like macOS's HFS+) do not have higher granularity.test_utimestest_lutimestest_futimenstest_utimensattest_mkdirat_success_pathtest_mkdirat_success_modetest_mkdirat_failtest_mknodtest_mknodattest_clock_getrestest_clock_gettimetest_clock_getcpuclockidtest_clock_id_restest_clock_id_nowtest_clock_id_pid_cpu_clock_idtest_fork_and_waitpidtest_mkstemptest_mkstemp_directorytest_mkfifotest_mkfifo_directorytest_mkfifoat_nonetest_mkfifoattest_mkfifoat_directory_nonetest_mkfifoat_directorytest_getpidtest_getsidtest_gettidtest_setgroups// `getgroups()` and `setgroups()` do not behave as expected on Apple platformstest_initgroupsexecve_test_factorytest_fchdirtest_getcwdtest_chowntest_fchowntest_fchownattest_lseektest_lseek64test_accttest_fpathconf_limitedtest_pathconf_limitedtest_sysconf_limitedtest_sysconf_unsupportedtest_getresuidtest_getresgidtest_pipe// Test that we can create a pair of pipes.  No need to verify that they pass// data; that's the domain of the OS, not nix.test_pipe2// pipe2(2) is the same as pipe(2), except it allows setting some flags.  Check// that we can set a flag.test_truncatetest_ftruncateALARM_CALLED// Used in `test_alarm`.alarm_signal_handlertest_alarmtest_canceling_alarmtest_symlinkattest_linkat_filetest_linkat_olddirfd_nonetest_linkat_newdirfd_nonetest_linkat_no_follow_symlinktest_linkat_follow_symlinktest_unlinkat_dir_noremovedirtest_unlinkat_dir_removedirtest_unlinkat_filetest_access_not_existingtest_access_file_existstest_user_into_passwdtest_setfsuid/// Tests setting the filesystem UID with `setfsuid`.test_ttynametest_ttyname_not_ptytest_ttyname_invalid_fdtest_getpeereidtest_getpeereid_invalid_fd/// Return type of [`Dir::iter`]./// The file descriptor continues to be owned by the `OwningIter`,/// so callers must not keep a `RawFd` after the `OwningIter` is dropped./// FIFO (Named pipe)/// Character device/// Directory/// Block device/// Regular file/// Symbolic link/// Unix-domain socket/// Type of file referenced by a directory entry//! List directory contentsfeaturer" Computes the raw fd consumed by a function of the form `*at`."r" Copy a range of data from one file to another"r" The `copy_file_range` system call performs an in-kernel copy between"r" file descriptors `fd_in` and `fd_out` without the additional cost of"r" transferring data from the kernel to user space and then back into the"r" kernel. It copies up to `len` bytes of data from file descriptor `fd_in` to"r" file descriptor `fd_out`, overwriting any data that exists within the"r" requested range of the target file."r" If the `off_in` and/or `off_out` arguments are used, the values"r" will be mutated to reflect the new position within the file after"r" copying. If they are not used, the relevant filedescriptors will be seeked"r" to the new position."r" On successful completion the number of bytes actually copied will be"r" Manipulates file space."r" Allows the caller to directly manipulate the allocated disk space for the"r" file referred to by fd."SockaddrLikeSockaddrStorage/// in the specific variant of `SockaddrStorage` returned for the fields/// `address`, `netmask`, `broadcast`, and `destination`. For any entry not/// supported, the returned list will contain a `None` entry.test_getifaddrs_netmask_correct// Ensures getting the netmask works, and in particular that// `workaround_xnu_bug` works properly.with_nix_path_allocating//! Nix uses the following Cargo features to enable optional functionality.//! They may be enabled in any combination.//! * `acct` - Process accounting//! * `aio` - POSIX AIO//! * `dir` - Stuff relating to directory iteration//! * `env` - Manipulate environment variables//! * `event` - Event-driven APIs, like `kqueue` and `epoll`//! * `feature` - Query characteristics of the OS at runtime//! * `fs` - File system functionality//! * `hostname` - Get and set the system's hostname//! * `inotify` - Linux's `inotify` file system notification API//! * `ioctl` - The `ioctl` syscall, and wrappers for my specific instances//! * `kmod` - Load and unload kernel modules//! * `mman` - Stuff relating to memory management//! * `mount` - Mount and unmount file systems//! * `mqueue` - POSIX message queues//! * `net` - Networking-related functionality//! * `personality` - Set the process execution domain//! * `poll` - APIs like `poll` and `select`//! * `process` - Stuff relating to running processes//! * `pthread` - POSIX threads//! * `ptrace` - Process tracing and debugging//! * `quota` - File system quotas//! * `reboot` - Reboot the system//! * `resource` - Process resource limits//! * `sched` - Manipulate process's scheduling//! * `socket` - Sockets, whether for networking or local use//! * `signal` - Send and receive signals to processes//! * `term` - Terminal control APIs//! * `time` - Query the operating system's clocks//! * `ucontext` - User thread context//! * `uio` - Vectored I/O//! * `user` - Stuff relating to users and groups//! * `zerocopy` - APIs like `sendfile` and `copy_file_range`// Thanks to Tokio for this macro// n.b. notgull: In reality, this is a list that contains//               both mutable and immutable pointers.//               Be careful using this./// # use ::sysctl::{CtlValue, Sysctl};/// # let ctl = ::sysctl::Ctl::new("vfs.usermount").unwrap();/// # if !Uid::current().is_root() && CtlValue::Int(0) == ctl.value().unwrap() {push_slice/// Helper function to push a slice onto the `iov` array.push_pointer_and_length/// Helper function to push a pointer and its length onto the `iov` array.push_nix_path/// Helper function to push a `nix` path as owned.r" Used with [`mq_open`]."r" Open the message queue for receiving messages."r" Open the queue for sending messages."r" Open the queue for both receiving and sending messages"r" Create a message queue."r" If set along with `O_CREAT`, `mq_open` will fail if the message"r" queue name exists."r" `mq_send` and `mq_receive` should fail with `EAGAIN` rather than"r" wait for resources that are not currently available."r" Set the close-on-exec flag for the message queue descriptor."/// A message-queue attribute, optionally used with [`mq_setattr`] and/// [`mq_getattr`] and optionally [`mq_open`],MqdT/// Identifies an open POSIX Message Queue// A safer wrapper around libc::mqd_t, which is a pointer on some platforms// Deliberately is not Clone to prevent use-after-close scenarios/// Size of a message queue attribute member/// Create a new message queue attribute/// - `mq_flags`:   Either `0` or `O_NONBLOCK`./// - `mq_maxmsg`:  Maximum number of messages on the queue./// - `mq_msgsize`: Maximum message size in bytes./// - `mq_curmsgs`: Number of messages currently in the queue./// The current flags, either `0` or `O_NONBLOCK`.maxmsg/// The max number of messages that can be held by the queuemsgsize/// The maximum size of each message (in bytes)curmsgs/// The number of messages currently held in the queue// no_run because a kernel module may be required.//! # use std::ffi::CString;//! # use nix::mqueue::*;//! use nix::sys::stat::Mode;//! const MSG_SIZE: mq_attr_member_t = 32;//! let mq_name= CString::new("/a_nix_test_queue").unwrap();//! let oflag0 = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;//! let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;//! let mqd0 = mq_open(&mq_name, oflag0, mode, None).unwrap();//! let msg_to_send = b"msg_1";//! mq_send(&mqd0, msg_to_send, 1).unwrap();//! let oflag1 = MQ_OFlag::O_CREAT | MQ_OFlag::O_RDONLY;//! let mqd1 = mq_open(&mq_name, oflag1, mode, None).unwrap();//! let mut buf = [0u8; 32];//! let mut prio = 0u32;//! let len = mq_receive(&mqd1, &mut buf, &mut prio).unwrap();//! assert_eq!(prio, 1);//! assert_eq!(msg_to_send, &buf[0..len]);//! mq_close(mqd1).unwrap();//! mq_close(mqd0).unwrap();/// After a call to `poll` or `ppoll`, the events that occurred can be/// Returns the events that occurred in the last call to `poll` or `ppoll`.  Will only returnr" `ppoll()` allows an application to safely wait until either a file"r" descriptor becomes ready or until a signal is caught."r" ([`poll(2)`](https://man7.org/linux/man-pages/man2/poll.2.html))"r" `ppoll` behaves like `poll`, but let you specify what signals may interrupt it"r" with the `sigmask` argument. If you want `ppoll` to block indefinitely,"r" specify `None` as `timeout` (it is like `timeout = -1` for `poll`)."r" If `sigmask` is `None`, then no signal mask manipulation is performed,"r" so in that case `ppoll` differs from `poll` only in the precision of the"r" timeout argument."r" Representation of a master with a forked pty"r" This is returned by `forkpty`. Note that this type does *not* implement `Drop`, so the user"r" must manually close the file descriptors."r" The master port in a virtual pty pair"r" Metadata about forked process"/// `posix_openpt()` returns a file descriptor to an existing unused pseudoterminal master device./// pseudoterminal.r" Create a new pseudoterminal, returning the master file descriptor and forked pid."r" in `ForkptyResult`"r" (see [`forkpty`](https://man7.org/linux/man-pages/man3/forkpty.3.html))."r" If `winsize` is not `None`, the window size of the slave will be set to"r" the values in `winsize`. If `termios` is not `None`, the pseudoterminal's"r" terminal settings of the slave will be set to the values in `termios`."r" In a multithreaded program, only [async-signal-safe] functions like `pause`"r" and `_exit` may be called by the child (the parent isn't restricted). Note"r" that memory allocation may **not** be async-signal-safe and thus must be"r" prevented."r" Those functions are only a small subset of your operating system's API, so"r" special care must be taken to only invoke code you can control and audit."r" [async-signal-safe]: https://man7.org/linux/man-pages/man7/signal-safety.7.html"sched_affinity/// cpu_set.set(0).unwrap();/// sched_setaffinity(Pid::from_raw(0), &cpu_set).unwrap();unsafe_pinned// It would be really nice to perform the in-progress check entirely at// compile time.  But I can't figure out how, because:// * Future::poll takes a `Pin<&mut self>` rather than `self`, and// * Rust's lack of an equivalent of C++'s Guaranteed Copy Elision means//   that there's no way to write an AioCb constructor that neither boxes//   the object itself, nor moves it during return./// Base class for all AIO operations.  Should only be used directly when/// checking for completion.// We could create some kind of AsPinnedMut trait, and implement it for all aio// ops, allowing the crate's users to get pinned references to `AioCb`.  That// could save some code for things like polling methods.  But IMHO it would// provide polymorphism at the wrong level.  Instead, the best place for// polymorphism is at the level of `Futures`.unsafe_unpinned'__aset_in_progress/// Update the notification settings for an existing AIO operation that has/// not yet been submitted.// Takes a normal reference rather than a pinned one because this method is// normally called before the object needs to be pinned, that is, before// it's been submitted to the kernel./// The return type of [`Aio::aio_return`]./// Should only be called once for each operation, after [`Aio::error`]/// let mut aiocb = Box::pin(AioWrite::new(f.as_raw_fd(),///     SigevNotify::SigevNone));/// aiocb.as_mut().submit().unwrap();/// let cs = aiocb.as_mut().cancel().unwrap();///     while (aiocb.as_mut().error() == Err(Errno::EINPROGRESS)) {/// let _ = aiocb.as_mut().aio_return();/// while (aiocb.as_mut().error() == Err(Errno::EINPROGRESS)) {/// assert_eq!(aiocb.as_mut().aio_return().unwrap(), WBUF.len());/// Returns the underlying file descriptor associated with the operation./// Does this operation currently have any in-kernel state?/// Dropping an operation that does have in-kernel state constitutes a/// resource leak./// let mut aiof = Box::pin(AioFsync::new(f.as_raw_fd(), AioFsyncMode::O_SYNC,///     0, SigevNone));/// assert!(!aiof.as_mut().in_progress());/// aiof.as_mut().submit().expect("aio_fsync failed early");/// assert!(aiof.as_mut().in_progress());/// while (aiof.as_mut().error() == Err(Errno::EINPROGRESS)) {/// aiof.as_mut().aio_return().expect("aio_fsync failed late");/// Returns the `SigEvent` that will be used for notification.submit/// Actually start the I/O operation./// After calling this method and until [`Aio::aio_return`] returns `Ok`,/// the structure may not be moved in memory.Aio/// Methods common to all AIO operationsaio_methodsAioFsync/// Returns the operation's fsync mode: data and metadata or data only?/// Create a new `AioFsync`./// * `fd`:           File descriptor to sync./// * `mode`:         Whether to sync file metadata too, or just data.AioRead///     let mut aior = Box::pin(///         AioRead::new(///             f.as_raw_fd(),///             2,   //offset///             &mut rbuf,///             0,   //priority///             SigevNotify::SigevNone///     aior.as_mut().submit().unwrap();///     while (aior.as_mut().error() == Err(Errno::EINPROGRESS)) {///     assert_eq!(aior.as_mut().aio_return().unwrap(), LEN);/// Create a new `AioRead`, placing the data in a mutable slice./// * `fd`:           File descriptor to read from/// * `buf`:          A memory buffer.  It must outlive the `AioRead`./// Returns the file offset of the operation.AioWrite/// let mut aiow = Box::pin(///     AioWrite::new(///         SigevNotify::SigevNone/// aiow.as_mut().submit().unwrap();/// while (aiow.as_mut().error() == Err(Errno::EINPROGRESS)) {/// assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());/// Construct a new `AioWrite`./// * `fd`:           File descriptor to write to/// * `buf`:          A memory buffer.  It must outlive the `AioWrite`./// Suspends the calling process until at least one of the specified operations/// have completed, a signal is delivered, or the timeout has passed./// aio_suspend(&[&*aiocb], None).expect("aio_suspend failed");/// assert_eq!(aiocb.as_mut().aio_return().unwrap() as usize, WBUF.len());/// They are not guaranteed to complete atomically, and the order in which the/// requests are carried out is not specified. Reads, and writes may be freely/// mixed./// Use `lio_listio` to submit an aio operation and wait for its completion. In/// this case, there is no need to use aio_suspend to wait or `error` to poll./// This mode is useful for otherwise-synchronous programs that want to execute/// a handful of I/O operations in parallel./// let mut aiow = Box::pin(AioWrite::new(///     f.as_raw_fd(),///     2,      // offset///     0,      // priority///     SigevNotify::SigevNone/// lio_listio(LioMode::LIO_WAIT, &mut[aiow.as_mut()], SigevNotify::SigevNone)/// // At this point, we are guaranteed that aiow is complete./// Use `lio_listio` to submit multiple asynchronous operations with a single/// syscall, but receive notification individually.  This is an efficient/// technique for reducing overall context-switch overhead, especially when/// combined with kqueue./// # use std::thread;/// # use std::time;/// lio_listio(LioMode::LIO_NOWAIT, &mut[aiow.as_mut()], SigevNotify::SigevNone)/// // We must wait for the completion of each individual operation/// Use `lio_listio` to submit multiple operations, and receive notification/// only when all of them are complete.  This can be useful when there is some/// logical relationship between the operations.  But beware!  Errors or system/// resource limitations may cause `lio_listio` to return `EIO`, `EAGAIN`, or/// `EINTR`, in which case some but not all operations may have been submitted./// In that case, you must check the status of each individual operation, and/// possibly resubmit some./// # use libc::c_int;/// # use lazy_static::lazy_static;/// # use nix::sys::signal::*;///     pub static ref SIGNALED: AtomicBool = AtomicBool::new(false);/// extern fn sigfunc(_: c_int) {///     SIGNALED.store(true, Ordering::Relaxed);/// let sa = SigAction::new(SigHandler::Handler(sigfunc),///                         SaFlags::SA_RESETHAND,///                         SigSet::empty());/// SIGNALED.store(false, Ordering::Relaxed);/// unsafe { sigaction(Signal::SIGUSR2, &sa) }.unwrap();/// let sev = SigevNotify::SigevSignal { signal: Signal::SIGUSR2, si_value: 0 };/// lio_listio(LioMode::LIO_NOWAIT, &mut[aiow.as_mut()], sev).unwrap();/// while !SIGNALED.load(Ordering::Relaxed) {/// // At this point, since `lio_listio` returned success and delivered its/// // notification, we know that all operations are complete.casting/// aio_suspend relies on casting Rust Aio* struct pointers to libc::aiocb/// pointers.  This test ensures that such casts are valid.//! devices.  It supports [`read`](struct.AioRead.html#method.new),//! [`write`](struct.AioWrite.html#method.new),//! [`fsync`](struct.AioFsync.html#method.new),//! [`readv`](struct.AioReadv.html#method.new), and//! [`writev`](struct.AioWritev.html#method.new), operations, subject to//! platform support.  Completion//! [`cancel`](trait.Aio.html#method.cancel) or// AioFsync does not need AsMut, since it can't be used with lio_listio// Not needless on all platforms.r" File was accessed."r" File was modified."r" Metadata changed."r" Writable file was closed."r" Nonwritable file was closed."r" File was opened."r" File was moved from X."r" File was moved to Y."r" Subfile was created."r" Subfile was deleted."r" Self was deleted."r" Self was moved."r" Backing filesystem was unmounted."r" Event queue overflowed."r" File was ignored."r" Combination of `IN_CLOSE_WRITE` and `IN_CLOSE_NOWRITE`."r" Combination of `IN_MOVED_FROM` and `IN_MOVED_TO`."r" Only watch the path if it is a directory."r" Don't follow symlinks."r" Event occurred against directory."r" Only send event once."r" All of the events."r" Set the `FD_CLOEXEC` flag on the file descriptor."r" Set the `O_NONBLOCK` flag on the open file description referred to by the new file descriptor."r" Place the mapping at exactly the address specified in `addr`, but never clobber an existing range."r" Creates and opens a new, or opens an existing, POSIX shared memory object."r" For more information, see [`shm_open(3)`]."r" [`shm_open(3)`]: https://man7.org/linux/man-pages/man3/shm_open.3.html"r" Provide the legacy virtual address space layout."r" Disable address-space-layout randomization."r" Limit the address space to 32 bits."r" Use `0xc0000000` as the offset at which to search a virtual memory"r" chunk on [`mmap(2)`], otherwise use `0xffffe000`."r" [`mmap(2)`]: https://man7.org/linux/man-pages/man2/mmap.2.html"r" User-space function pointers to signal handlers point to descriptors."r" Map page 0 as read-only."r" `PROT_READ` implies `PROT_EXEC` for [`mmap(2)`]."r" No effects."r" [`select(2)`], [`pselect(2)`], and [`ppoll(2)`] do not modify the"r" returned timeout argument when interrupted by a signal handler."r" [`select(2)`]: https://man7.org/linux/man-pages/man2/select.2.html"r" [`pselect(2)`]: https://man7.org/linux/man-pages/man2/pselect.2.html"r" [`ppoll(2)`]: https://man7.org/linux/man-pages/man2/ppoll.2.html"r" Have [`uname(2)`] report a 2.6.40+ version number rather than a 3.x"r" version number."r" [`uname(2)`]: https://man7.org/linux/man-pages/man2/uname.2.html"/// personality::set(pers | Persona::ADDR_NO_RANDOMIZE).unwrap();//! Process execution domainsr" Send a signal to a thread (see [`pthread_kill(3)`])."r" If `signal` is `None`, `pthread_kill` will only preform error checking and"r" won't send any signal."r" [`pthread_kill(3)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_kill.html"read_user/// Reads a word from a user area at `offset`./// The user struct definition can be found in `/usr/include/sys/user.h`.write_user/// Writes a word to a user area at `offset`.//! quotactl_on(QuotaType::USRQUOTA, "/dev/sda1", QuotaFmt::QFMT_VFS_V1, "aquota.user").unwrap();//! quotactl_set(QuotaType::USRQUOTA, "/dev/sda1", 50, &dqblk, QuotaValidFlags::QIF_BLIMITS).unwrap();r" Halt the system."r" Execute a kernel that has been loaded earlier with"r" [`kexec_load(2)`](https://man7.org/linux/man-pages/man2/kexec_load.2.html)."r" Stop the system and switch off power, if possible."r" Restart the system."r" Suspend the system using software suspend."/// Reboots or shuts down the system.r" Types of process resources."r" manuals for more details. Some platform links have been provided for"r" easier reference (non-exhaustive)."r" * [NetBSD](https://man.netbsd.org/setrlimit.2)"/// The special value `RLIM_INFINITY` indicates that no limit will be/// enforced./// println!("current soft_limit: {}", soft_limit);/// println!("current hard_limit: {}", hard_limit);///   resource.///   the current hard limit for non-root users./// let soft_limit = 512;/// let hard_limit = 1024;r" Whose resource usage should be returned by [`getrusage`]."UsageWhor" Resource usage for the current process."r" Resource usage for all the children that have terminated and been waited for."r" Resource usage for the calling thread."/// Output of `getrusage` with information about resource usage. Some of the fields/// may be unused in some platforms, and will be always zeroed out. See their manualsuser_time/// Total amount of time spent executing in user mode./// Total amount of time spent executing in kernel mode./// The resident set size at its peak, in kilobytes.shared_integral/// Integral value expressed in kilobytes times ticks of execution indicating/// the amount of text memory shared with other processes.unshared_data_integral/// the amount of unshared memory used by data.unshared_stack_integral/// the amount of unshared memory used for stack space.minor_page_faults/// Number of page faults that were served without resorting to I/O, with pages/// that have been allocated previously by the kernel.major_page_faults/// Number of page faults that were served through I/O (i.e. swap).full_swaps/// Number of times all of the memory was fully swapped out.block_reads/// Number of times a read was done from a block device.block_writes/// Number of times a write was done to a block device.ipc_sends/// Number of IPC messages sent.ipc_receives/// Number of IPC messages received./// Number of signals received.voluntary_context_switches/// Number of times a context switch was voluntarily invoked.involuntary_context_switches/// Number of times a context switch was imposed by the kernel (usually due to/// time slice expiring or preemption by a higher priority process)./// Get usage information for a process, its children or the current thread/// Real time information can be obtained for either the current process or (in some/// systems) thread, but information about children processes is only provided for/// those that have terminated and been waited for (see [`super::wait::wait`])./// Some information may be missing depending on the platform, and the way information/// is provided for children may also vary. Check the manuals for details./// * [getrusage(2)](https://pubs.opengroup.org/onlinepubs/009696699/functions/getrusage.html)/// * [Linux](https://man7.org/linux/man-pages/man2/getrusage.2.html)/// * [FreeBSD](https://www.freebsd.org/cgi/man.cgi?query=getrusage)/// * [NetBSD](https://man.netbsd.org/getrusage.2)/// * [MacOS](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getrusage.2.html)/// [`UsageWho`]: enum.UsageWho.html/// Note: `getrusage` provides a safe wrapper to libc's [`libc::getrusage`].test_self_cpu_timer" Monitors file descriptors for readiness with an altered signal mask."r" Returns the total number of ready file descriptors in all sets. The sets are changed so that all"r" file descriptors that are ready for the given operation are set."r" When this function returns, the original signal mask is restored."r" Unlike [`select`](#fn.select), `pselect` does not mutate the `timeout` value."r" # Parameters"r" * `nfds`: The highest file descriptor set in any of the passed `FdSet`s, plus 1. If `None`, this"r"   is calculated automatically by calling [`FdSet::highest`] on all descriptor sets and adding 1"r"   to the maximum of that."r" * `readfds`: File descriptors to check for read readiness"r" * `writefds`: File descriptors to check for write readiness"r" * `errorfds`: File descriptors to check for pending error conditions."r" * `timeout`: Maximum time to wait for descriptors to become ready (`None` to block"r"   indefinitely)."r" * `sigmask`: Signal mask to activate while waiting for file descriptors to turn"r"    ready (`None` to set no alternative signal mask)."r" # References"r" [pselect(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html)"r" [The new pselect() system call](https://lwn.net/Articles/176911/)"r" [`FdSet::highest`]: struct.FdSet.html#method.highest"r" Iterate through all signals defined by this operating system"r" Iterate through all signals defined by this OS"r" Alias for [`SIGABRT`]"r" Alias for [`SIGIO`]"r" Alias for [`SIGSYS`]"r" Specifies a set of [`Signal`]s that may be blocked, waited for, etc."r" Initialize to include all signals."r" Initialize to include nothing."r" Add the specified signal to the set."r" Remove all signals from this set."r" Remove the specified signal from this set."r" Return whether this set includes the specified signal."r" Returns an iterator that yields the signals contained in this set."SigSetIterr" Gets the currently blocked (masked) set of signals for the calling thread."r" Sets the set of signals as the signal mask for the calling thread."r" Adds the set of signals to the signal mask for the calling thread."r" Removes the set of signals from the signal mask for the calling thread."r" Sets the set of signals as the signal mask, and returns the old mask."r" Suspends execution of the calling thread until one of the signals in the"r" signal mask becomes pending, and returns the accepted signal."r" Converts a `libc::sigset_t` object to a [`SigSet`] without checking  whether the"r" `libc::sigset_t` is already initialized."r" The `sigset` passed in must be a valid an initialized `libc::sigset_t` by calling either"r" [`sigemptyset(3)`](https://man7.org/linux/man-pages/man3/sigemptyset.3p.html) or"r" [`sigfillset(3)`](https://man7.org/linux/man-pages/man3/sigfillset.3p.html)."r" Otherwise, the results are undefined."from_sigset_t_uncheckedr" Iterator for a [`SigSet`]."r" Call [`SigSet::iter`] to create an iterator."r" A signal handler."r" Default signal handling."r" Request that the signal be ignored."r" Use the given signal-catching function, which takes in the signal."r" Use the given signal-catching function, which takes in the signal, information about how"r" the signal was generated, and a pointer to the threads `ucontext_t`."r" Action to take on receipt of a signal. Corresponds to `sigaction`."r" Creates a new action."r" The `SA_SIGINFO` bit in the `flags` argument is ignored (it will be set only if `handler`"r" is the `SigAction` variant). `mask` specifies other signals to block during execution of"r" the signal-catching function."r" Returns the flags set on the action."r" Returns the set of signals that are blocked during execution of the action's"r" signal-catching function."r" Returns the action's handler."r" Changes the action taken by a process on receipt of a specific signal."r" `signal` can be any signal except `SIGKILL` or `SIGSTOP`. On success, it returns the previous"r" action for the given signal. If `sigaction` fails, no new signal handler is installed."r" * Signal handlers may be called at any point during execution, which limits"r"   what is safe to do in the body of the signal-catching function. Be certain"r"   to only make syscalls that are explicitly marked safe for signal handlers"r"   and only share global data using atomics."r" * There is also no guarantee that the old signal handler was installed"r"   correctly.  If it was installed by this crate, it will be.  But if it was"r"   installed by, for example, C code, then there is no guarantee its function"r"   pointer is valid.  In that case, this function effectively dereferences a"r"   raw pointer of unknown provenance."r" Signal management (see [signal(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/signal.html))"r" Installs `handler` for the given `signal`, returning the previous signal"r" handler. `signal` should only be used following another call to `signal` or"r" if the current handler is the default. The return value of `signal` is"r" undefined after setting the handler with [`sigaction`][SigActionFn]."r" If the pointer to the previous signal handler is invalid, undefined"r" behavior could be invoked when casting it back to a [`SigAction`][SigActionStruct]."r" Ignore `SIGINT`:"r" ```no_run"r" # use nix::sys::signal::{self, Signal, SigHandler};"r" unsafe { signal::signal(Signal::SIGINT, SigHandler::SigIgn) }.unwrap();"r" Use a signal handler to set a flag variable:"r" # #[macro_use] extern crate lazy_static;"r" # use std::convert::TryFrom;"r" # use std::sync::atomic::{AtomicBool, Ordering};"r" lazy_static! {"r"    static ref SIGNALED: AtomicBool = AtomicBool::new(false);"r" extern fn handle_sigint(signal: libc::c_int) {"r"     let signal = Signal::try_from(signal).unwrap();"r"     SIGNALED.store(signal == Signal::SIGINT, Ordering::Relaxed);"r" fn main() {"r"     let handler = SigHandler::Handler(handle_sigint);"r"     unsafe { signal::signal(Signal::SIGINT, handler) }.unwrap();"r" # Errors"r" Returns [`Error(Errno::EOPNOTSUPP)`] if `handler` is"r" [`SigAction`][SigActionStruct]. Use [`sigaction`][SigActionFn] instead."r" `signal` also returns any error from `libc::signal`, such as when an attempt"r" is made to catch a signal that cannot be caught or to ignore a signal that"r" cannot be ignored."r" [`Error::UnsupportedOperation`]: ../../enum.Error.html#variant.UnsupportedOperation"r" [SigActionStruct]: struct.SigAction.html"r" [sigactionFn]: fn.sigaction.html"r" Manages the signal mask (set of blocked signals) for the calling thread."r" If the `set` parameter is `Some(..)`, then the signal mask will be updated with the signal set."r" The `how` flag decides the type of update. If `set` is `None`, `how` will be ignored,"r" and no modification will take place."r" If the 'oldset' parameter is `Some(..)` then the current signal mask will be written into it."r" If both `set` and `oldset` is `Some(..)`, the current signal mask will be written into oldset,"r" and then it will be updated with `set`."r" If both `set` and `oldset` is None, this function is a no-op."r" For more information, visit the [`pthread_sigmask`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_sigmask.html),"r" or [`sigprocmask`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html) man pages."r" Examine and change blocked signals."r" For more information see the [`sigprocmask` man"r" pages](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html)."r" Send a signal to a process"r" # Arguments"r" * `pid` -    Specifies which processes should receive the signal."r"   - If positive, specifies an individual process"r"   - If zero, the signal will be sent to all processes whose group"r"     ID is equal to the process group ID of the sender.  This is a"r"     variant of [`killpg`]."r"   - If `-1` and the process has super-user privileges, the signal"r"     is sent to all processes exclusing system processes."r"   - If less than `-1`, the signal is sent to all processes whose"r"     process group ID is equal to the absolute value of `pid`."r" * `signal` - Signal to send. If `None`, error checking is performed"r"              but no signal is actually sent."r" See Also"r" [`kill(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html)"r" Send a signal to a process group"r" * `pgrp` -   Process group to signal.  If less then or equal 1, the behavior"r"              is platform-specific."r" * `signal` - Signal to send. If `None`, `killpg` will only preform error"r"              checking and won't send any signal."r" See Also [killpg(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/killpg.html)."r" Send a signal to the current thread"r" See Also [raise(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/raise.html)"r" Identifies a thread for [`SigevNotify::SigevThreadId`]"r" Specifies the notification method used by a [`SigEvent`]"r" No notification will be delivered"r" Notify by delivering a signal to the process."r" Signal to deliver"r" Will be present in the `si_value` field of the [`libc::siginfo_t`]"r" structure of the queued signal."r" Notify by delivering a signal to a thread."r" Signal to send"r" LWP ID of the thread to notify"r" Used to request asynchronous notification of the completion of certain"r" events, such as POSIX AIO and timers."r" **Note:** this constructor does not allow the user to set the"r" `sigev_notify_kevent_flags` field.  That's considered ok because on FreeBSD"r" at least those flags don't do anything useful.  That field is part of a"r" union that shares space with the more genuinely useful fields."r" **Note:** This constructor also doesn't allow the caller to set the"r" `sigev_notify_function` or `sigev_notify_attributes` fields, which are"r" required for `SIGEV_THREAD`.  That's considered ok because on no operating"r" system is `SIGEV_THREAD` the most efficient way to deliver AIO"r" notification.  FreeBSD and DragonFly BSD programs should prefer `SIGEV_KEVENT`."r" Linux, Solaris, and portable programs should prefer `SIGEV_THREAD_ID` or"r" `SIGEV_SIGNAL`.  That field is part of a union that shares space with the"r" more genuinely useful `sigev_notify_thread_id`"r" Return a copy of the inner structure"r" Returns a mutable pointer to the `sigevent` wrapped by `self`"test_from_and_into_iteratortest_from_sigset_t_uncheckedipv4addr_to_libc/// Convert a std::net::Ipv4Addr into the libc form.ipv6addr_to_libc/// Convert a std::net::Ipv6Addr into the libc form./// AX.25 packet layer protocol./// (see [netrom(4)](https://www.unix.com/man-page/linux/4/netrom/))/// Can't be used for creating sockets; mostly used for bridge/// links in/// [rtnetlink(7)](https://man7.org/linux/man-pages/man7/rtnetlink.7.html)/// protocol commands./// RATS (Radio Amateur Telecommunications Society) Open/// Systems environment (ROSE) AX.25 packet layer protocol./// DECet protocol sockets./// Reserved for "802.2LLC project"; never used./// This was a short-lived (between Linux 2.1.30 and/// 2.1.99pre2) protocol family for firewall upcalls./// Key management protocol.// Not documented anywhere that I can find/// Acorn Econet protocol/// Access to ATM Switched Virtual Circuits/// Reliable Datagram Sockets (RDS) protocol/// IBM SNA/// Socket interface over IrDA/// Generic PPP transport layer, for setting up L2 tunnels (L2TP and PPPoE)/// Legacy protocol for wide area network (WAN) connectivity that was used/// by Sangoma WAN cards/// Logical link control (IEEE 802.2 LLC) protocol/// InfiniBand native addressing /// Multiprotocol Label Switching/// Controller Area Network automotive bus protocol/// TIPC, "cluster domain sockets" protocol/// Bluetooth low-level socket protocol/// IUCV (inter-user communication vehicle) z/VM protocol for/// hypervisor-guest interaction/// Rx, Andrew File System remote procedure call protocol/// New "modular ISDN" driver interface protocol/// Nokia cellular modem IPC/RPC interface/// IEEE 802.15.4 WPAN (wireless personal area network) raw packet protocol/// Ericsson's Communication CPU to Application CPU interface (CAIF)/// protocol./// Near field communication/// VMWare VSockets protocol for hypervisor-guest interaction./// [address_families(7)](https://man7.org/linux/man-pages/man7/address_families.7.html)// Should this be u8?r" Gets the IP address associated with this socket address."r" Gets the port number associated with this socket address"r" Create a new IpAddr that contains an IPv4 address."r" The result will represent the IP address a.b.c.d"r" Create a new IpAddr that contains an IPv6 address."r" The result will represent the IP address a:b:c:d:e:f"r" Return the eight 16-bit segments that make up this address"// INVARIANT: sun & sun_len are valid as defined by docs for from_raw_partssun_len/// The length of the valid part of `sun`, including the sun_family field/// but excluding any trailing nul.// On the BSDs, this field is built into sun/// Safety: sun & sun_len must be valid/// The leading nul byte for the abstract namespace is automatically added;/// thus the input `path` is expected to be the bare name, not NUL-prefixed./// Create a UnixAddr from a raw `sockaddr_un` struct and a size. `sun_len`/// is the size of the valid portion of the struct, excluding any trailing/// NUL./// This pair of sockaddr_un & sun_len must be a valid unix addr, which/// means:/// - sun_len >= offset_of(sockaddr_un, sun_path)/// - sun_len <= sockaddr_un.sun_path.len() - offset_of(sockaddr_un, sun_path)/// - if this is a unix addr with a pathname, sun.sun_path is a///   fs path, not necessarily nul-terminated./// leading NUL byte. `None` is returned for unnamed or path-backed sockets.SockaddrLikePriv/// Returns a raw pointer to the inner structure.  Useful for FFI./// Unsafe constructor from a variable length source/// Some C APIs from provide `len`, and others do not.  If it's provided it/// will be validated.  If not, it will be guessed based on the family./// - `addr`:   raw pointer to something that can be cast to a///             `libc::sockaddr`. For example, `libc::sockaddr_in`,///             `libc::sockaddr_in6`, etc./// - `len`:    For fixed-width types like `sockaddr_in`, it will be///             validated if present and ignored if not.  For variable-width///             types it is required and must be the total length of valid///             data.  For example, if `addr` points to a///             named `sockaddr_un`, then `len` must be the length of the///             structure up to but not including the trailing NUL./// `addr` must be valid for the specific type of sockaddr.  `len`, if/// present, must not exceed the length of valid data in `addr`./// Return the address family of this socket/// One common use is to match on the family of a union type, like this:/// let fd = socket(AddressFamily::Inet, SockType::Stream,///     SockFlag::empty(), None).unwrap();/// let ss: SockaddrStorage = getsockname(fd).unwrap();/// match ss.family().unwrap() {///     AddressFamily::Inet => println!("{}", ss.as_sockaddr_in().unwrap()),///     AddressFamily::Inet6 => println!("{}", ss.as_sockaddr_in6().unwrap()),///     _ => println!("Unexpected address family")r" Return the length of valid data in the sockaddr structure."r" For fixed-size sockaddrs, this should be the size of the"r" structure.  But for variable-sized types like [`UnixAddr`] it"r" may be less."/// Return the available space in the structure/// Anything that, in C, can be cast back and forth to `sockaddr`./// Most implementors also implement `AsRef<libc::XXX>` to access their/// inner type read-only./// `()` can be used in place of a real Sockaddr when no address is expected,/// for example for a field of `Option<S> where S: SockaddrLike`.// If this RFC ever stabilizes, then ! will be a better choice.// https://github.com/rust-lang/rust/issues/35121SockaddrIn/// An IPv4 socket address// This is identical to net::SocketAddrV4.  But the standard library// doesn't allow direct access to the libc fields, which we need.  So we// reimplement it here./// Returns the IP address associated with this socket address, in native/// Creates a new socket address from IPv4 octets and a port number./// Returns the port number associated with this socket address, in nativeSockaddrIn6/// An IPv6 socket address/// Returns the flow information associated with this address./// Returns the IP address associated with this socket address./// Returns the scope ID associated with this address.dlsin6su/// A container for any sockaddr type/// Just like C's `sockaddr_storage`, this type is large enough to hold any type/// of sockaddr.  It can be used as an argument with functions like/// [`bind`](super::bind) and [`getsockname`](super::getsockname).  Though it is/// a union, it can be safely accessed through the `as_*` methods./// let localhost = SockaddrIn::from_str("127.0.0.1:8081").unwrap();/// let fd = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(),/// bind(fd, &localhost).expect("bind");/// let ss: SockaddrStorage = getsockname(fd).expect("getsockname");/// assert_eq!(&localhost, ss.as_sockaddr_in().unwrap());accessorsas_unix_addr/// Downcast to an immutable `[UnixAddr]` reference.as_unix_addr_mut/// Downcast to a mutable `[UnixAddr]` reference.r" Safely and falliably downcast to an immutable reference"as_alg_addrr" Safely and falliably downcast to a mutable reference"as_alg_addr_mutas_link_addras_link_addr_mutas_sockaddr_inas_sockaddr_in_mutas_sockaddr_in6as_sockaddr_in6_mutas_netlink_addras_netlink_addr_mutas_vsock_addras_vsock_addr_mut/// Returns a mutable raw pointer to the inner structure./// This method is technically safe, but modifying the inner structure's/// `family` or `len` fields may result in violating Nix's invariants./// It is best to use this method only with foreign functions that do/// not change the sockaddr type.// Since they're all deprecated anyway/// Address for the Linux kernel user interface device./// [netlink(7)](https://man7.org/linux/man-pages/man7/netlink.7.html)/// Construct a new socket address from its port ID and multicast groups/// mask./// Return the socket's port ID./// Return the socket's multicast groups mask/// Socket address for the Linux kernel crypto API/// Construct an `AF_ALG` socket from its cipher name and type./// Return the socket's cipher type, for example `hash` or `aead`./// Return the socket's cipher name, for example `sha1`.r" Hardware Address"r" Physical-layer protocol"r" Interface number"r" ARP hardware type"r" Packet type"r" Length of MAC address"r" Physical-layer address (MAC)"/// Socket address for VMWare VSockets protocol/// [vsock(7)](https://man7.org/linux/man-pages/man7/vsock.7.html)/// Construct a `VsockAddr` from its raw fields.test_ipv4addr_to_libctest_ipv6addr_to_libclinux_loopbackfrom_sockaddr_un_namedfrom_sockaddr_un_abstract_namedfrom_sockaddr_un_abstract_unnamedabstract_sun_pathunixaddrEthAll/// Non-DIX type protocol number defined for the Ethernet IEEE 802.3 interface that allows packets of all protocols/// defined in the interface to be received./// ([ref](https://man7.org/linux/man-pages/man7/packet.7.html))// The protocol number is fed into the socket syscall in network byte order.r" Configuration flags for `SO_TIMESTAMPING` interface"r" For use with [`Timestamping`][sockopt::Timestamping]."r" [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)"TimestampingFlagr" Report any software timestamps when available."r" Report hardware timestamps as generated by SOF_TIMESTAMPING_TX_HARDWARE when available."r" Collect transmiting timestamps as reported by hardware"r" Collect transmiting timestamps as reported by software"r" Collect receiving timestamps as reported by hardware"r" Collect receiving timestamps as reported by software"r" Requests not to send `SIGPIPE` errors when the other end breaks the connection."r" (For more details, see [send(2)](https://linux.die.net/man/2/send))."r" Request for multicast socket operations"r" This is a wrapper type around `ip_mreq`."r" Instantiate a new `IpMembershipRequest`"r" If `interface` is `None`, then `Ipv4Addr::any()` will be used for the interface."r" Request for ipv6 multicast socket operations"r" This is a wrapper type around `ipv6_mreq`."r" Instantiate a new `Ipv6MembershipRequest`"r" Create a buffer large enough for storing some control messages as returned"r" by [`recvmsg`](fn.recvmsg.html)."r" # use nix::sys::time::TimeVal;"r" # use std::os::unix::io::RawFd;"r" # fn main() {"r" // Create a buffer for a `ControlMessageOwned::ScmTimestamp` message"r" let _ = cmsg_space!(TimeVal);"r" // Create a buffer big enough for a `ControlMessageOwned::ScmRights` message"r" // with two file descriptors"r" let _ = cmsg_space!([RawFd; 2]);"r" // and a `ControlMessageOwned::ScmTimestamp` message"r" let _ = cmsg_space!(RawFd, TimeVal);"r" Iterate over the valid control messages pointed to by this"r" msghdr."r" Control message buffer to decode from. Must adhere to cmsg alignment."r" A type-safe wrapper around a single control message, as used with"r" [`recvmsg`](#fn.recvmsg)."r" [Further reading](https://man7.org/linux/man-pages/man3/cmsg.3.html)"r" Received version of [`ControlMessage::ScmRights`]"r" Received version of [`ControlMessage::ScmCredentials`]"r" A message of type `SCM_TIMESTAMP`, containing the time the"r" packet was received by the kernel."r#" See the kernel's explanation in "SO_TIMESTAMP" of"#r" [networking/timestamping](https://www.kernel.org/doc/Documentation/networking/timestamping.txt)."r" # use nix::sys::socket::*;"r" # use nix::sys::time::*;"r" # use std::io::{IoSlice, IoSliceMut};"r" # use std::time::*;"r" # use std::str::FromStr;"r" // Set up"r#" let message = "Ohayō!".as_bytes();"#r" let in_socket = socket("r"     AddressFamily::Inet,"r"     SockType::Datagram,"r"     SockFlag::empty(),"r"     None).unwrap();"r" setsockopt(in_socket, sockopt::ReceiveTimestamp, &true).unwrap();"r#" let localhost = SockaddrIn::from_str("127.0.0.1:0").unwrap();"#r" bind(in_socket, &localhost).unwrap();"r" let address: SockaddrIn = getsockname(in_socket).unwrap();"r" // Get initial time"r" let time0 = SystemTime::now();"r" // Send the message"r" let iov = [IoSlice::new(message)];"r" let flags = MsgFlags::empty();"r" let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();"r" assert_eq!(message.len(), l);"r" // Receive the message"r" let mut buffer = vec![0u8; message.len()];"r" let mut cmsgspace = cmsg_space!(TimeVal);"r" let mut iov = [IoSliceMut::new(&mut buffer)];"r" let r = recvmsg::<SockaddrIn>(in_socket, &mut iov, Some(&mut cmsgspace), flags)"r" let rtime = match r.cmsgs().next() {"r"     Some(ControlMessageOwned::ScmTimestamp(rtime)) => rtime,"r#"     Some(_) => panic!("Unexpected control message"),"#r#"     None => panic!("No control message")"#r" // Check the final time"r" let time1 = SystemTime::now();"r" // the packet's received timestamp should lie in-between the two system"r" // times, unless the system clock was adjusted in the meantime."r" let rduration = Duration::new(rtime.tv_sec() as u64,"r"                               rtime.tv_usec() as u32 * 1000);"r" assert!(time0.duration_since(UNIX_EPOCH).unwrap() <= rduration);"r" assert!(rduration <= time1.duration_since(UNIX_EPOCH).unwrap());"r" // Close socket"r" nix::unistd::close(in_socket).unwrap();"r" A set of nanosecond resolution timestamps"ScmTimestampsnsr" Nanoseconds resolution timestamp"Ipv4OrigDstAddrIpv6OrigDstAddrr" UDP Generic Receive Offload (GRO) allows receiving multiple UDP"r" packets from a single sender."r" Fixed-size payloads are following one by one in a receive buffer."r" This Control Message indicates the size of all smaller packets,"r" except, maybe, the last one."r" `UdpGroSegment` socket option should be enabled on a socket"r" to allow receiving GRO packets."r" SO_RXQ_OVFL indicates that an unsigned 32 bit value"r" ancilliary msg (cmsg) should be attached to recieved"r" skbs indicating the number of packets dropped by the"r" socket between the last recieved packet and this"r" received packet."r" `RxqOvfl` socket option should be enabled on a socket"r" to allow receiving the drop counter."r" Socket error queue control messages read with the `MSG_ERRQUEUE` flag."r" Catch-all variant for unimplemented cmsg types."r" For representing packet timestamps via `SO_TIMESTAMPING` interface"r" software based timestamp, usually one containing data"r" legacy timestamp, usually empty"hw_transr" hardware based timestamp"hw_rawr" Decodes a `ControlMessageOwned` from raw bytes."r" This is only safe to call if the data is correct for the message type"r" specified in the header. Normally, the kernel ensures that this is the"r#" case. "Correct" in this case includes correct length, alignment and"#r" actual content."r" A type-safe zero-copy wrapper around a single control message, as used wih"r" [`sendmsg`](#fn.sendmsg).  More types may be added to this enum; do not"r" exhaustively pattern-match it."r" A message of type `SCM_RIGHTS`, containing an array of file"r" descriptors passed between processes."r#" See the description in the "Ancillary messages" section of the"#r" [unix(7) man page](https://man7.org/linux/man-pages/man7/unix.7.html)."r" Using multiple `ScmRights` messages for a single `sendmsg` call isn't"r" recommended since it causes platform-dependent behaviour: It might"r" swallow all but the first `ScmRights` message or fail with `EINVAL`."r" Instead, you can put all fds to be passed into a single `ScmRights`"r" A message of type `SCM_CREDENTIALS`, containing the pid, uid and gid of"r" a process connected to the socket."r" This is similar to the socket option `SO_PEERCRED`, but requires a"r" process to explicitly send its credentials. A process running as root is"r" allowed to specify any credentials, while credentials sent by other"r" processes are verified by the kernel."r" For further information, please refer to the"r" [`unix(7)`](https://man7.org/linux/man-pages/man7/unix.7.html) man page."r" Set IV for `AF_ALG` crypto API."r" [`documentation`](https://kernel.readthedocs.io/en/sphinx-samples/crypto-API.html)"r" Set crypto operation for `AF_ALG` crypto API. It may be one of"r" `ALG_OP_ENCRYPT` or `ALG_OP_DECRYPT`"r" Set the length of associated authentication data (AAD) (applicable only to AEAD algorithms)"r" for `AF_ALG` crypto API."r" UDP GSO makes it possible for applications to generate network packets"r" for a virtual MTU much greater than the real one."r" The length of the send data no longer matches the expected length on"r" the wire."r" The size of the datagram payload as it should appear on the wire may be"r" passed through this control message."r" Send buffer should consist of multiple fixed-size wire payloads"r" following one by one, and the last, possibly smaller one."r" Configure the sending addressing and interface for v4"r" [`ip(7)`](https://man7.org/linux/man-pages/man7/ip.7.html) man page."r" Configure the sending addressing and interface for v6"r" [`ipv6(7)`](https://man7.org/linux/man-pages/man7/ipv6.7.html) man page."r" Configure the transmission time of packets."r" [`tc-etf(8)`](https://man7.org/linux/man-pages/man8/tc-etf.8.html) man"r" page."TxTimer" The value of CMSG_SPACE on this message."r" Safe because CMSG_SPACE is always safe"r" The value of CMSG_LEN on this message."r" Safe because CMSG_LEN is always safe"r" Return a reference to the payload data as a byte pointer"r" The size of the payload, excluding its cmsghdr"r" Returns the value to put into the `cmsg_level` field of the header."r" Returns the value to put into the `cmsg_type` field of the header."r" Send data in scatter-gather vectors to a socket, possibly accompanied"r" by ancillary data. Optionally direct the message at the given address,"r" as with sendto."r" Allocates if cmsgs is nonempty."r" When not directing to any specific address, use `()` for the generic type"r" # use nix::unistd::pipe;"r" # use std::io::IoSlice;"r" let (fd1, fd2) = socketpair(AddressFamily::Unix, SockType::Stream, None,"r"     SockFlag::empty())"r" let (r, w) = pipe().unwrap();"r#" let iov = [IoSlice::new(b"hello")];"#r" let fds = [r];"r" let cmsg = ControlMessage::ScmRights(&fds);"r" sendmsg::<()>(fd1, &iov, &[cmsg], MsgFlags::empty(), None).unwrap();"r" When directing to a specific address, the generic type will be inferred."r#" let localhost = SockaddrIn::from_str("1.2.3.4:8080").unwrap();"#r" let fd = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(),"r" sendmsg(fd, &iov, &[cmsg], MsgFlags::empty(), Some(&localhost)).unwrap();"r" An extension of `sendmsg` that allows the caller to transmit multiple"r" messages on a socket using a single system call. This has performance"r" benefits for some applications."r" Allocations are performed for cmsgs and to build `msghdr` buffer"r" * `fd`:             Socket file descriptor"r" * `data`:           Struct that implements `IntoIterator` with `SendMmsgData` items"r" * `flags`:          Optional flags passed directly to the operating system."r" # Returns"r" `Vec` with numbers of sent bytes on each sent message."r" [`sendmsg`](fn.sendmsg.html)"r" An extension of `recvmsg` that allows the caller to receive multiple"r" messages from a socket using a single system call. This has"r" performance benefits for some applications."r" `iov` and `cmsg_buffer` should be constructed similarly to `recvmsg`"r" Multiple allocations are performed"r" * `data`:           Struct that implements `IntoIterator` with `RecvMmsgData` items"r" # RecvMmsgData"r" * `iov`:            Scatter-gather list of buffers to receive the message"r" * `cmsg_buffer`:    Space to receive ancillary data.  Should be created by"r"                     [`cmsg_space!`](../../macro.cmsg_space.html)"r" A `Vec` with multiple `RecvMsg`, one per received message"r" - [`recvmsg`](fn.recvmsg.html)"r" - [`RecvMsg`](struct.RecvMsg.html)"'outerr" Receive message in scatter-gather vectors from a socket, and"r" optionally receive ancillary data into the provided buffer."r" If no ancillary data is desired, use () as the type parameter."r" [recvmsg(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html)"r" Set or get the don't route flag."DontRouter" Specifies exact type of timestamping information collected by the kernel"Timestampingr" The `recvmsg(2)` call will return the destination IP address for a UDP"r" datagram."r" Configures the behavior of time-based transmission of packets, for use"r" with the `TxTime` control message."r#" Set "don't fragment packet" flag on the IPv6 packet."#Ipv6DontFrag/// The result is OS-dependent.  For a portable alternative, seer" Get the session controlled by the given terminal (see"r" [tcgetsid(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetsid.html))."//! cfsetispeed(&mut t, BaudRate::B9600).unwrap();//! cfsetospeed(&mut t, BaudRate::B9600).unwrap();//! cfsetspeed(&mut t, BaudRate::B9600).unwrap();//! # cfsetspeed(&mut t, BaudRate::B9600).unwrap();//! cfsetispeed(&mut t, speed).unwrap();/// Alarm will trigger once after the time given in `TimeSpec`/// Alarm will trigger after a specified delay and then every interval of/// Alarm will trigger every specified interval of time./// Construct a new `TimeSpec` from its components/// Construct a new `TimeVal` from its components/// A Unix signal per-process timer./// Creates a new timer based on the clock defined by `clockid`. The details/// of the signal and its handler are defined by the passed `sigevent`./// Set a new alarm on the timer.///     Example: I want an alarm to go off in 60s and then disable itself./// Note: Setting a one shot alarm with a 0s TimeSpec disable the alarmoverruns/// Return the number of timers that have overrun/// Each timer is able to queue one signal to the process at a time, meaning/// if the signal is not handled before the next expiration the timer has/// 'overrun'. This function returns how many times that has happened to/// this timer, up to `libc::DELAYTIMER_MAX`. If more than the maximum/// number of overruns have happened the return is capped to the maximum.//! Timer API via signals.//! Timer is a POSIX API to create timers and get expiration notifications//! through queued Unix signals, for the current process. This is similar to//! Linux's timerfd mechanism, except that API is specific to Linux and makes//! use of file polling.//! For more documentation, please read [timer_create](https://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_create.html).//! Create an interval timer that signals SIGALARM every 250 milliseconds.//! use nix::sys::signal::{self, SigEvent, SigHandler, SigevNotify, Signal};//! use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};//! use nix::time::ClockId;//! use std::convert::TryFrom;//! use std::sync::atomic::{AtomicU64, Ordering};//! use std::thread::yield_now;//! const SIG: Signal = Signal::SIGALRM;//! static ALARMS: AtomicU64 = AtomicU64::new(0);//! extern "C" fn handle_alarm(signal: libc::c_int) {//!     let signal = Signal::try_from(signal).unwrap();//!     if signal == SIG {//!         ALARMS.fetch_add(1, Ordering::Relaxed);//!     let clockid = ClockId::CLOCK_MONOTONIC;//!     let sigevent = SigEvent::new(SigevNotify::SigevSignal {//!         signal: SIG,//!         si_value: 0,//!     let mut timer = Timer::new(clockid, sigevent).unwrap();//!     let expiration = Expiration::Interval(Duration::from_millis(250).into());//!     let flags = TimerSetTimeFlags::empty();//!     timer.set(expiration, flags).expect("could not set timer");//!     let handler = SigHandler::Handler(handle_alarm);//!     unsafe { signal::signal(SIG, handler) }.unwrap();//!         let alarms = ALARMS.load(Ordering::Relaxed);//!         if alarms >= 10 {//!             println!("total alarms handled: {}", alarms);//!             break;//!         yield_now()r" A settable system-wide real-time clock."r" A non-settable monotonically increasing clock."r" Does not change after system startup."r" Does not measure time while the system is suspended."r" Like `CLOCK_MONOTONIC`, except that `CLOCK_BOOTTIME` includes the time"r" that the system was suspended."r" Like `CLOCK_REALTIME`, but will wake the system if it is suspended."r" Like `CLOCK_BOOTTIME`, but will wake the system if it is suspended."/// Low-level read from a file, with specified offset./// This is the same underlying C structure as `IoSlice`,/// therefore not represented in Rust by an actual slice as `IoSlice` is. It// Clippy false positive: https://github.com/rust-lang/rust-clippy/issues/8867// The only reason IoVec isn't automatically Send+Sync is because libc::iovec// contains raw pointers.r" Write data directly to another process's virtual memory"r" (see [`process_vm_writev`(2)])."r" `local_iov` is a list of [`IoSlice`]s containing the data to be written,"r" and `remote_iov` is a list of [`RemoteIoVec`]s identifying where the"r" data should be written in the target process. On success, returns the"r" number of bytes written, which will always be a whole"r" number of `remote_iov` chunks."r" This requires the same permissions as debugging the process using"r" [ptrace]: you must either be a privileged process (with"r" `CAP_SYS_PTRACE`), or you must be running as the same user as the"r" target process and the OS must have unprivileged debugging enabled."r" This function is only available on Linux and Android(SDK23+)."r" [`process_vm_writev`(2)]: https://man7.org/linux/man-pages/man2/process_vm_writev.2.html"r" [ptrace]: ../ptrace/index.html"r" [`IoSlice`]: https://doc.rust-lang.org/std/io/struct.IoSlice.html"r" [`RemoteIoVec`]: struct.RemoteIoVec.html"r" Read data directly from another process's virtual memory"r" (see [`process_vm_readv`(2)])."r" `local_iov` is a list of [`IoSliceMut`]s containing the buffer to copy"r" data into, and `remote_iov` is a list of [`RemoteIoVec`]s identifying"r" where the source data is in the target process. On success,"r" returns the number of bytes written, which will always be a whole"r" [`ptrace`]: you must either be a privileged process (with"r" [`process_vm_readv`(2)]: https://man7.org/linux/man-pages/man2/process_vm_readv.2.html"r" [`ptrace`]: ../ptrace/index.html"r" [`IoSliceMut`]: https://doc.rust-lang.org/std/io/struct.IoSliceMut.html"/// Name of the operating system implementation.cast_and_trimfrom_siginfo/// Convert a `siginfo_t` as returned by `waitid` to a `WaitStatus`/// Returns an `Error` corresponding to `EINVAL` for invalid values./// siginfo_t is actually a union, not all fields may be initialized./// The functions si_pid() and si_status() must be valid to call on/// the passed siginfo_t./// Wait for any child/// Wait for the child whose process ID matches the given PIDPGid/// Wait for the child whose process group ID matches the given PID/// If the PID is zero, the caller's process group is used since Linux 5.4.PIDFd/// Wait for the child referred to by the given PID file descriptor/// The ID argument for `waitid`/// See also [waitid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/waitid.html)/// Newtype pattern around `clockid_t` (which is just alias). It prevents bugs caused byr" Returns `ClockId` of a `pid` CPU-time clock"r" User identifier"r" Newtype pattern around `uid_t` (which is just alias). It prevents bugs caused by accidentally"r" passing wrong value."r" Creates `Uid` from raw `uid_t`."r" Returns Uid of calling process. This is practically a more Rusty alias for `getuid`."r" Returns effective Uid of calling process. This is practically a more Rusty alias for `geteuid`."r" Returns true if the `Uid` represents privileged user - root. (If it equals zero.)"r" Get the raw `uid_t` wrapped by `self`."r" Constant for UID = 0"r" Group identifier"r" Newtype pattern around `gid_t` (which is just alias). It prevents bugs caused by accidentally"r" Creates `Gid` from raw `gid_t`."r" Returns Gid of calling process. This is practically a more Rusty alias for `getgid`."r" Returns effective Gid of calling process. This is practically a more Rusty alias for `getegid`."r" Get the raw `gid_t` wrapped by `self`."r" Process identifier"r" Newtype pattern around `pid_t` (which is just alias). It prevents bugs caused by accidentally"r" Creates `Pid` from raw `pid_t`."r" Returns PID of calling process"r" Returns PID of parent of calling process"r" Get the raw `pid_t` wrapped by `self`."r" Represents the successful result of calling `fork`"r" When `fork` is called, the process continues execution in the parent process"r" and in the new child.  This return type can be examined to determine whether"r" you are now executing in the parent process or in the child."r" Return `true` if this is the child process of the `fork()`"r" Returns `true` if this is the parent process of the `fork()`"r" Create a new child process duplicating the parent process ([see"r" fork(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html))."r" After successfully calling the fork system call, a second process will"r" be created which is identical to the original except for the pid and the"r" return value of this function.  As an example:"r" use nix::{sys::wait::waitpid,unistd::{fork, ForkResult, write}};"r" match unsafe{fork()} {"r"    Ok(ForkResult::Parent { child, .. }) => {"r#"        println!("Continuing execution in parent process, new child has pid: {}", child);"#r"        waitpid(child, None).unwrap();"r"    }"r"    Ok(ForkResult::Child) => {"r"        // Unsafe to use `println!` (or `unwrap`) here. See Safety."r#"        write(libc::STDOUT_FILENO, "I'm a new child process\n".as_bytes()).ok();"#r"        unsafe { libc::_exit(0) };"r#"    Err(_) => println!("Fork failed"),"#r" This will print something like the following (order nondeterministic).  The"r" thing to note is that you end up with two processes continuing execution"r" immediately after the fork call but with different match arms."r" ```text"r" Continuing execution in parent process, new child has pid: 1234"r" I'm a new child process"r" Get the pid of this process (see"r" [getpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpid.html))."r" Since you are running code, there is always a pid to return, so there"r" is no error case that needs to be handled."r" Get the pid of this processes' parent (see"r" [getpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getppid.html))."r" There is always a parent pid to return, so there is no error case that needs"r" to be handled."r" Set a process group ID (see"r" [setpgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setpgid.html))."r" Set the process group id (PGID) of a particular process.  If a pid of zero"r" is specified, then the pid of the calling process is used.  Process groups"r" may be used to group together a set of processes in order for the OS to"r" apply some operations across the group."r" `setsid()` may be used to create a new process group."r" Create new session and set process group id (see"r" [setsid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsid.html))."r" Get the process group ID of a session leader"r" [getsid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsid.html)."r" Obtain the process group ID of the process that is the session leader of the process specified"r" by pid. If pid is zero, it specifies the calling process."r" Get the terminal foreground process group (see"r" [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetpgrp.html))."r" Get the group process id (GPID) of the foreground process group on the"r" terminal associated to file descriptor (FD)."r" Set the terminal foreground process group (see"r" [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsetpgrp.html))."r" Get the group process id (PGID) to the foreground process group on the"r" Get the group id of the calling process (see"r"[getpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgrp.html))."r" Get the process group id (PGID) of the calling process."r" According to the man page it is always successful."r" Get the caller's thread ID (see"r" [gettid(2)](https://man7.org/linux/man-pages/man2/gettid.2.html)."r" This function is only available on Linux based systems.  In a single"r" threaded process, the main thread will have the same ID as the process.  In"r" a multithreaded process, each thread will have a unique thread id but the"r" same process ID."r" No error handling is required as a thread id should always exist for any"r" process, even if threads are not being used."r" Create a copy of the specified file descriptor (see"r" [dup(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html))."r" The new file descriptor will be have a new index but refer to the same"r" resource as the old file descriptor and the old and new file descriptors may"r" be used interchangeably.  The new and old file descriptor share the same"r" underlying resource, offset, and file status flags.  The actual index used"r" for the file descriptor will be the lowest fd index that is available."r" The two file descriptors do not share file descriptor flags (e.g. `OFlag::FD_CLOEXEC`)."r" Create a copy of the specified file descriptor using the specified fd (see"r" This function behaves similar to `dup()` except that it will try to use the"r" specified fd instead of allocating a new one.  See the man pages for more"r" detail on the exact behavior of this function."r" Create a new copy of the specified file descriptor using the specified fd"r" and flags (see [dup(2)](https://man7.org/linux/man-pages/man2/dup.2.html))."r" This function behaves similar to `dup2()` but allows for flags to be"r" specified."r" Change the current working directory of the calling process (see"r" [chdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html))."r" This function may fail in a number of different scenarios.  See the man"r" pages for additional details on possible failure cases."r" Change the current working directory of the process to the one"r" given as an open file descriptor (see"r" [fchdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchdir.html))."r" Creates new directory `path` with access rights `mode`.  (see [mkdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdir.html))"r" There are several situations where mkdir might fail:"r" - current user has insufficient rights in the parent directory"r" - the path already exists"r" - the path name is too long (longer than `PATH_MAX`, usually 4096 on linux, 1024 on OS X)"r" use nix::unistd;"r" use nix::sys::stat;"r" use tempfile::tempdir;"r" let tmp_dir1 = tempdir().unwrap();"r#" let tmp_dir2 = tmp_dir1.path().join("new_dir");"#r" // create new directory and give read, write and execute rights to the owner"r" match unistd::mkdir(&tmp_dir2, stat::Mode::S_IRWXU) {"r#"    Ok(_) => println!("created {:?}", tmp_dir2),"#r#"    Err(err) => println!("Error creating directory: {}", err),"#r" Creates new fifo special file (named pipe) with path `path` and access rights `mode`."r" There are several situations where mkfifo might fail:"r" For a full list consult"r" [posix specification](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkfifo.html)"r" let tmp_dir = tempdir().unwrap();"r#" let fifo_path = tmp_dir.path().join("foo.pipe");"#r" // create new fifo and give read, write and execute rights to the owner"r" match unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) {"r#"    Ok(_) => println!("created {:?}", fifo_path),"#r#"    Err(err) => println!("Error creating fifo: {}", err),"#r" If `dirfd` has a value, then `path` is relative to directory associated with the file descriptor."r" If `dirfd` is `None`, then `path` is relative to the current working directory."r" [mkfifoat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkfifoat.html)."r" Creates a symbolic link at `path2` which points to `path1`."r" If `dirfd` has a value, then `path2` is relative to directory associated"r" with the file descriptor."r" If `dirfd` is `None`, then `path2` is relative to the current working"r" directory. This is identical to `libc::symlink(path1, path2)`."r" See also [symlinkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/symlinkat.html)."r" Returns the current directory as a `PathBuf`"r" Err is returned if the current user doesn't have the permission to read or search a component"r" of the current path."r" // assume that we are allowed to get current directory"r" let dir = unistd::getcwd().unwrap();"r#" println!("The current directory is {:?}", dir);"#r" Computes the raw UID and GID values to pass to a `*chown` call."r" Change the ownership of the file at `path` to be owned by the specified"r" `owner` (user) and `group` (see"r" [chown(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/chown.html))."r" The owner/group for the provided path name will not be modified if `None` is"r" provided for that argument.  Ownership change will be attempted for the path"r" only if `Some` owner/group is provided."r" Change the ownership of the file referred to by the open file descriptor `fd` to be owned by"r" the specified `owner` (user) and `group` (see"r" [fchown(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchown.html))."r" The owner/group for the provided file will not be modified if `None` is"r" Flags for `fchownat` function."r" `owner` (user) and `group`."r" The file to be changed is determined relative to the directory associated"r" with the file descriptor `dirfd` or the current working directory"r" if `dirfd` is `None`."r" If `flag` is `FchownatFlags::NoFollowSymlink` and `path` names a symbolic link,"r" then the mode of the symbolic link is changed."r" `fchownat(None, path, owner, group, FchownatFlags::NoFollowSymlink)` is identical to"r" a call `libc::lchown(path, owner, group)`.  That's why `lchown` is unimplemented in"r" the `nix` crate."r" [fchownat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchownat.html)."r" Replace the current process image with a new one (see"r" [exec(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html))."r" See the `::nix::unistd::execve` system call for additional details.  `execv`"r" performs the same action but does not allow for customization of the"r" environment for the new process."r" [execve(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html))."r#" The execve system call allows for another process to be "called" which will"#r" replace the current process image.  That is, this process becomes the new"r" command that is run. On success, this function will not return. Instead,"r" the new program will run until it exits."r" `::nix::unistd::execv` and `::nix::unistd::execve` take as arguments a slice"r" of `::std::ffi::CString`s for `args` and `env` (for `execve`). Each element"r" in the `args` list is an argument to the new process. Each element in the"r#" `env` list should be a string in the form "key=value"."#r" Replace the current process image with a new one and replicate shell `PATH`"r" searching behavior (see"r" See `::nix::unistd::execve` for additional details.  `execvp` behaves the"r" same as execv except that it will examine the `PATH` environment variables"r" for file names not specified with a leading slash.  For example, `execv`"r#" would not work if "bash" was specified for the path argument, but `execvp`"#r" would assuming that a bash executable was on the system `PATH`."r" [`execvpe(3)`](https://man7.org/linux/man-pages/man3/exec.3.html))."r" This functions like a combination of `execvp(2)` and `execve(2)` to pass an"r" environment and have a search path. See these two for additional"r" [fexecve(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fexecve.html))."r#" The `fexecve` function allows for another process to be "called" which will"#r" This function is similar to `execve`, except that the program to be executed"r" is referenced as a file descriptor instead of a path."r" Execute program relative to a directory file descriptor (see"r" [execveat(2)](https://man7.org/linux/man-pages/man2/execveat.2.html))."r#" The `execveat` function allows for another process to be "called" which will"#r" is referenced as a file descriptor to the base directory plus a path."r" Daemonize this process by detaching from the controlling terminal (see"r" [daemon(3)](https://man7.org/linux/man-pages/man3/daemon.3.html))."r" When a process is launched it is typically associated with a parent and it,"r" in turn, by its controlling terminal/process.  In order for a process to run"r#" in the "background" it must daemonize itself by detaching itself.  Under"#r" posix, this is done by doing the following:"r" 1. Parent process (this one) forks"r" 2. Parent process exits"r" 3. Child process continues to run."r" `nochdir`:"r" * `nochdir = true`: The current working directory after daemonizing will"r"    be the current working directory."r" *  `nochdir = false`: The current working directory after daemonizing will"r"    be the root direcory, `/`."r" `noclose`:"r" * `noclose = true`: The process' current stdin, stdout, and stderr file"r"   descriptors will remain identical after daemonizing."r" * `noclose = false`: The process' stdin, stdout, and stderr will point to"r"   `/dev/null` after daemonizing."r" Set the system host name (see"r" [sethostname(2)](https://man7.org/linux/man-pages/man2/gethostname.2.html))."r" Given a name, attempt to update the system host name to the given string."r" On some systems, the host name is limited to as few as 64 bytes.  An error"r" will be returned if the name is not valid or the current process does not"r" have permissions to update the host name."r" Get the host name and store it in an internally allocated buffer, returning an"r" `OsString` on success (see"r" [gethostname(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/gethostname.html))."r" This function call attempts to get the host name for the running system and"r" store it in an internal buffer, returning it as an `OsString` if successful."r#" let hostname = unistd::gethostname().expect("Failed getting hostname");"#r#" let hostname = hostname.into_string().expect("Hostname wasn't valid UTF-8");"#r#" println!("Hostname: {}", hostname);"#r" Directive that tells [`lseek`] and [`lseek64`] what the offset is relative to."r" [`lseek`]: ./fn.lseek.html"r" [`lseek64`]: ./fn.lseek64.html"r" Specify an offset relative to the start of the file."r" Specify an offset relative to the current file location."r" Specify an offset relative to the end of the file."r" Specify an offset relative to the next location in the file greater than or"r" equal to offset that contains some data. If offset points to"r" some data, then the file offset is set to offset."r" Specify an offset relative to the next hole in the file greater than"r" or equal to offset. If offset points into the middle of a hole, then"r" the file offset should be set to offset. If there is no hole past offset,"r" then the file offset should be adjusted to the end of the file (i.e., there"r" is an implicit hole at the end of any file)."r" Move the read/write file offset."r" See also [lseek(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lseek.html)"r" Like `pipe`, but allows setting certain file descriptor flags."r" The following flags are supported, and will be set atomically as the pipe is"r" created:"r" - `O_CLOEXEC`:    Set the close-on-exec flag for the new file descriptors."r" - `O_NONBLOCK`:   Set the non-blocking flag for the ends of the pipe."r" See also [pipe(2)](https://man7.org/linux/man-pages/man2/pipe.2.html)"r" Truncate a file to a specified length"r" See also"r" [truncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/truncate.html)"r" [ftruncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html)"r" Flags for `linkat` function."r" Link one file to another file"r" Creates a new link (directory entry) at `newpath` for the existing file at `oldpath`. In the"r" case of a relative `oldpath`, the path is interpreted relative to the directory associated"r" with file descriptor `olddirfd` instead of the current working directory and similiarly for"r" `newpath` and file descriptor `newdirfd`. In case `flag` is LinkatFlags::SymlinkFollow and"r" `oldpath` names a symoblic link, a new link for the target of the symbolic link is created."r" If either `olddirfd` or `newdirfd` is `None`, `AT_FDCWD` is used respectively where `oldpath`"r" and/or `newpath` is then interpreted relative to the current working directory of the calling"r" process. If either `oldpath` or `newpath` is absolute, then `dirfd` is ignored."r" See also [linkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/linkat.html)"r" Remove a directory entry"r" See also [unlink(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlink.html)"r" Flags for `unlinkat` function."r" In the case of a relative path, the directory entry to be removed is determined relative to"r" the directory associated with the file descriptor `dirfd` or the current working directory"r" if `dirfd` is `None`. In the case of an absolute `path` `dirfd` is ignored. If `flag` is"r" `UnlinkatFlags::RemoveDir` then removal of the directory entry specified by `dirfd` and `path`"r" is performed."r" See also [unlinkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlinkat.html)"r" Commit filesystem caches to disk"r" See also [sync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sync.html)"r" Synchronize changes to a file"r" See also [fsync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html)"r" Synchronize the data of a file"r" [fdatasync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fdatasync.html)"r" Get a real user ID"r" See also [getuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getuid.html)"r" Get the effective user ID"r" See also [geteuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/geteuid.html)"r" Get the real group ID"r" See also [getgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getgid.html)"r" Get the effective group ID"r" See also [getegid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getegid.html)"r" Set the effective user ID"r" See also [seteuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/seteuid.html)"r" Set the effective group ID"r" See also [setegid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setegid.html)"r" Set the user ID"r" See also [setuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setuid.html)"r" Set the group ID"r" See also [setgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setgid.html)"r" Set the user identity used for filesystem checks per-thread."r" On both success and failure, this call returns the previous filesystem user"r" ID of the caller."r" See also [setfsuid(2)](https://man7.org/linux/man-pages/man2/setfsuid.2.html)"r" Set the group identity used for filesystem checks per-thread."r" On both success and failure, this call returns the previous filesystem group"r" See also [setfsgid(2)](https://man7.org/linux/man-pages/man2/setfsgid.2.html)"r" Get the list of supplementary group IDs of the calling process."r" [Further reading](https://pubs.opengroup.org/onlinepubs/009695399/functions/getgroups.html)"r" **Note:** This function is not available for Apple platforms. On those"r" platforms, checking group membership should be achieved via communication"r" with the `opendirectoryd` service."r" Set the list of supplementary group IDs for the calling process."r" [Further reading](https://man7.org/linux/man-pages/man2/getgroups.2.html)"r" platforms, group membership management should be achieved via communication"r" `setgroups` can be used when dropping privileges from the root user to a"r" specific user and group. For example, given the user `www-data` with UID"r" `33` and the group `backup` with the GID `34`, one could switch the user as"r" follows:"r" ```rust,no_run"r" # use nix::unistd::*;"r" # fn try_main() -> Result<(), Box<dyn Error>> {"r" let uid = Uid::from_raw(33);"r" let gid = Gid::from_raw(34);"r" setgroups(&[gid])?;"r" setgid(gid)?;"r" setuid(uid)?;"r" # try_main().unwrap();"r" Calculate the supplementary group access list."r" Gets the group IDs of all groups that `user` is a member of. The additional"r" group `group` is also added to the list."r" [Further reading](https://man7.org/linux/man-pages/man3/getgrouplist.3.html)"r" Although the `getgrouplist()` call does not return any specific"r" errors on any known platforms, this implementation will return a system"r" error of `EINVAL` if the number of groups to be fetched exceeds the"r" `NGROUPS_MAX` sysconf value. This mimics the behaviour of `getgroups()`"r" and `setgroups()`. Additionally, while some implementations will return a"r" partial list of groups when `NGROUPS_MAX` is exceeded, this implementation"r" will only ever return the complete list or else an error."r" Initialize the supplementary group access list."r" Sets the supplementary group IDs for the calling process using all groups"r" that `user` is a member of. The additional group `group` is also added to"r" the list."r" [Further reading](https://man7.org/linux/man-pages/man3/initgroups.3.html)"r" `initgroups` can be used when dropping privileges from the root user to"r" another user. For example, given the user `www-data`, we could look up the"r" UID and GID for the user in the system's password database (usually found"r" in `/etc/passwd`). If the `www-data` user's UID and GID were `33` and `33`,"r" respectively, one could switch the user as follows:"r" # use std::ffi::CString;"r#" let user = CString::new("www-data").unwrap();"#r" let gid = Gid::from_raw(33);"r" initgroups(&user, gid)?;"r" Suspend the thread until a signal is received."r" See also [pause(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pause.html)."r" Alarm signal scheduling."r" Scheduling an alarm will trigger a `SIGALRM` signal when the time has"r" elapsed, which has to be caught, because the default action for the"r" signal is to terminate the program. This signal also can't be ignored"r" because the system calls like `pause` will not be interrupted, see the"r" second example below."r" Canceling an alarm:"r" use nix::unistd::alarm;"r" // Set an alarm for 60 seconds from now."r" alarm::set(60);"r" // Cancel the above set alarm, which returns the number of seconds left"r" // of the previously set alarm."r" assert_eq!(alarm::cancel(), Some(60));"r" Scheduling an alarm and waiting for the signal:"r" use std::time::{Duration, Instant};"r" use nix::unistd::{alarm, pause};"r" use nix::sys::signal::*;"r" // We need to setup an empty signal handler to catch the alarm signal,"r" // otherwise the program will be terminated once the signal is delivered."r" extern fn signal_handler(_: nix::libc::c_int) { }"r" let sa = SigAction::new("r"     SigHandler::Handler(signal_handler),"r"     SaFlags::SA_RESTART,"r"     SigSet::empty()"r" unsafe {"r"     sigaction(Signal::SIGALRM, &sa);"r" let start = Instant::now();"r" // Set an alarm for 1 second from now."r" alarm::set(1);"r" // Pause the process until the alarm signal is received."r" let mut sigset = SigSet::empty();"r" sigset.add(Signal::SIGALRM);"r" sigset.wait();"r" assert!(start.elapsed() >= Duration::from_secs(1));"r" See also [alarm(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/alarm.html)."r" Schedule an alarm signal."r" This will cause the system to generate a `SIGALRM` signal for the"r" process after the specified number of seconds have elapsed."r" Returns the leftover time of a previously set alarm if there was one."r" Cancel an previously set alarm signal."r" Enable process accounting"r" See also [acct(2)](https://linux.die.net/man/2/acct)"r" Disable process accounting"r" Creates a regular file which persists even after process termination"r" * `template`: a path whose 6 rightmost characters must be X, e.g. `/tmp/tmpfile_XXXXXX`"r" * returns: tuple of file descriptor and filename"r" Err is returned either if no temporary filename could be created or the template doesn't"r" end with XXXXXX"r" See also [mkstemp(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkstemp.html)"r#" let _ = match unistd::mkstemp("/tmp/tempfile_XXXXXX") {"#r"     Ok((fd, path)) => {"r"         unistd::unlink(path.as_path()).unwrap(); // flag file to be deleted at app termination"r"         fd"r#"     Err(e) => panic!("mkstemp failed: {}", e)"#r" // do something with fd"r" Variable names for `pathconf`"r" Nix uses the same naming convention for these variables as the"r" [getconf(1)](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/getconf.html) utility."r" That is, `PathconfVar` variables have the same name as the abstract"r" variables  shown in the `pathconf(2)` man page.  Usually, it's the same as"r" the C variable name without the leading `_PC_`."r" POSIX 1003.1-2008 standardizes all of these variables, but some OSes choose"r" not to implement variables that cannot change at runtime."r" - [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html)"r" - [limits.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html)"r" - [unistd.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/unistd.h.html)"r" Minimum number of bits needed to represent, as a signed integer value,"r" the maximum size of a regular file allowed in the specified directory."r" Maximum number of links to a single file."r" Maximum number of bytes in a terminal canonical input line."r" Minimum number of bytes for which space is available in a terminal input"r" queue; therefore, the maximum number of bytes a conforming application"r" may require to be typed as input before reading them."r" Maximum number of bytes in a filename (not including the terminating"r" null of a filename string)."r" Maximum number of bytes the implementation will store as a pathname in a"r" user-supplied buffer of unspecified size, including the terminating null"r" character. Minimum number the implementation will accept as the maximum"r" number of bytes in a pathname."r" Maximum number of bytes that is guaranteed to be atomic when writing to"r" a pipe."r" Symbolic links can be created."r" Minimum number of bytes of storage actually allocated for any portion of"r" a file."r" Recommended increment for file transfer sizes between the"r" `POSIX_REC_MIN_XFER_SIZE` and `POSIX_REC_MAX_XFER_SIZE` values."r" Maximum recommended file transfer size."r" Minimum recommended file transfer size."r"  Recommended file transfer buffer alignment."r" Maximum number of bytes in a symbolic link."r" The use of `chown` and `fchown` is restricted to a process with"r" appropriate privileges, and to changing the group ID of a file only to"r" the effective group ID of the process or to one of its supplementary"r" group IDs."r" Pathname components longer than {NAME_MAX} generate an error."r" This symbol shall be defined to be the value of a character that shall"r" disable terminal special character handling."r" Asynchronous input or output operations may be performed for the"r" associated file."r" Prioritized input or output operations may be performed for the"r" Synchronized input or output operations may be performed for the"r" Like `pathconf`, but works with file descriptors instead of paths (see"r" [fpathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html))"r" - `fd`:   The file descriptor whose variable should be interrogated"r" - `var`:  The pathconf variable to lookup"r" - `Ok(Some(x))`: the variable's limit (for limit variables) or its"r"     implementation level (for option variables).  Implementation levels are"r"     usually a decimal-coded date, such as 200112 for POSIX 2001.12"r" - `Ok(None)`: the variable has no limit (for limit variables) or is"r"     unsupported (for option variables)"r" - `Err(x)`: an error occurred"r" Get path-dependent configurable system variables (see"r" [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html))"r" Returns the value of a path-dependent configurable system variable.  Most"r" supported variables also have associated compile-time constants, but POSIX"r" allows their values to change at runtime.  There are generally two types of"r" `pathconf` variables: options and limits.  See [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html) for more details."r" - `path`: Lookup the value of `var` for this file or directory"r" - `var`:  The `pathconf` variable to lookup"r" Variable names for `sysconf`"r" That is, `SysconfVar` variables have the same name as the abstract variables"r" shown in the `sysconf(3)` man page.  Usually, it's the same as the C"r" variable name without the leading `_SC_`."r" All of these symbols are standardized by POSIX 1003.1-2008, but haven't been"r" implemented by all platforms."r" - [sysconf(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html)"r" Maximum number of I/O operations in a single list I/O call supported by"r" the implementation."r" Maximum number of outstanding asynchronous I/O operations supported by"r" The maximum amount by which a process can decrease its asynchronous I/O"r" priority level from its own scheduling priority."r" Maximum length of argument to the exec functions including environment data."r" Maximum number of functions that may be registered with `atexit`."r" Maximum obase values allowed by the bc utility."r" Maximum number of elements permitted in an array by the bc utility."r" Maximum scale value allowed by the bc utility."r" Maximum length of a string constant accepted by the bc utility."r" Maximum number of simultaneous processes per real user ID."r" Maximum number of weights that can be assigned to an entry of the"r" LC_COLLATE order keyword in the locale definition file"r" Maximum number of timer expiration overruns."r" Maximum number of expressions that can be nested within parentheses by"r" the expr utility."r" Maximum length of a host name (not including the terminating null) as"r" returned from the `gethostname` function"r" Maximum number of iovec structures that one process has available for"r" use with `readv` or `writev`."r" Unless otherwise noted, the maximum length, in bytes, of a utility's"r" input line (either standard input or another file), when the utility is"r" described as processing text files. The length includes room for the"r" trailing newline."r" Maximum length of a login name."r" Maximum number of simultaneous supplementary group IDs per process."r" Initial size of `getgrgid_r` and `getgrnam_r` data buffers"r" Initial size of `getpwuid_r` and `getpwnam_r` data buffers"r" The maximum number of open message queue descriptors a process may hold."r" The maximum number of message priorities supported by the implementation."r" A value one greater than the maximum value that the system may assign to"r" a newly-created file descriptor."r" The implementation supports the Advisory Information option."r" The implementation supports barriers."r" The implementation supports asynchronous input and output."r" The implementation supports clock selection."r" The implementation supports the Process CPU-Time Clocks option."r" The implementation supports the File Synchronization option."r" The implementation supports the IPv6 option."r" The implementation supports job control."r" The implementation supports memory mapped Files."r" The implementation supports the Process Memory Locking option."r" The implementation supports the Range Memory Locking option."r" The implementation supports memory protection."r" The implementation supports the Message Passing option."r" The implementation supports the Monotonic Clock option."r" The implementation supports the Prioritized Input and Output option."r" The implementation supports the Process Scheduling option."r" The implementation supports the Raw Sockets option."r" The implementation supports read-write locks."r" The implementation supports realtime signals."r" The implementation supports the Regular Expression Handling option."r" Each process has a saved set-user-ID and a saved set-group-ID."r" The implementation supports semaphores."r" The implementation supports the Shared Memory Objects option."r" The implementation supports the POSIX shell."r" The implementation supports the Spawn option."r" The implementation supports spin locks."r" The implementation supports the Process Sporadic Server option."r" The implementation supports the Synchronized Input and Output option."r" The implementation supports the Thread Stack Address Attribute option."r" The implementation supports the Thread Stack Size Attribute option."r" The implementation supports the Thread CPU-Time Clocks option."r" The implementation supports the Non-Robust Mutex Priority Inheritance"r" option."r" The implementation supports the Non-Robust Mutex Priority Protection option."r" The implementation supports the Thread Execution Scheduling option."r" The implementation supports the Thread Process-Shared Synchronization"r" The implementation supports the Robust Mutex Priority Inheritance option."r" The implementation supports the Robust Mutex Priority Protection option."r" The implementation supports thread-safe functions."r" The implementation supports the Thread Sporadic Server option."r" The implementation supports threads."r" The implementation supports timeouts."r" The implementation supports timers."r" The implementation supports the Trace option."r" The implementation supports the Trace Event Filter option."r" The implementation supports the Trace Inherit option."r" The implementation supports the Trace Log option."r" The implementation supports the Typed Memory Objects option."r" Integer value indicating version of this standard (C-language binding)"r" to which the implementation conforms. For implementations conforming to"r" POSIX.1-2008, the value shall be 200809L."r" The implementation provides a C-language compilation environment with"r" 32-bit `int`, `long`, `pointer`, and `off_t` types."r" 32-bit `int`, `long`, and pointer types and an `off_t` type using at"r" least 64 bits."r" 32-bit `int` and 64-bit `long`, `pointer`, and `off_t` types."r" The implementation provides a C-language compilation environment with an"r" `int` type using at least 32 bits and `long`, pointer, and `off_t` types"r" using at least 64 bits."r" The implementation supports the C-Language Binding option."r" The implementation supports the C-Language Development Utilities option."r" The implementation supports the Terminal Characteristics option."r" The implementation supports the FORTRAN Development Utilities option."r" The implementation supports the FORTRAN Runtime Utilities option."r" The implementation supports the creation of locales by the localedef"r" utility."r" The implementation supports the Batch Environment Services and Utilities"r" The implementation supports the Batch Accounting option."r" The implementation supports the Batch Checkpoint/Restart option."r" The implementation supports the Locate Batch Job Request option."r" The implementation supports the Batch Job Message Request option."r" The implementation supports the Track Batch Job Request option."r" The implementation supports the Software Development Utilities option."r" The implementation supports the User Portability Utilities option."r" Integer value indicating version of the Shell and Utilities volume of"r" POSIX.1 to which the implementation conforms."r" The size of a system page in bytes."r" POSIX also defines an alias named `PAGESIZE`, but Rust does not allow two"r" enum constants to have the same value, so nix omits `PAGESIZE`."r" The implementation supports the X/Open Encryption Option Group."r" The implementation supports the Issue 4, Version 2 Enhanced"r" Internationalization Option Group."r" The implementation supports the X/Open Realtime Option Group."r" The implementation supports the X/Open Realtime Threads Option Group."r" The implementation supports the Issue 4, Version 2 Shared Memory Option"r" Group."r" The implementation supports the XSI STREAMS Option Group."r" The implementation supports the XSI option"r" Integer value indicating version of the X/Open Portability Guide to"r" which the implementation conforms."r" The number of pages of physical memory. Note that it is possible for"r" the product of this value to overflow."_PHYS_PAGESr" The number of currently available pages of physical memory."_AVPHYS_PAGESr" The number of processors configured."_NPROCESSORS_CONFr" The number of processors currently online (available)."_NPROCESSORS_ONLNr" Get configurable system variables (see"r" [sysconf(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html))"r" Returns the value of a configurable system variable.  Most supported"r" variables also have associated compile-time constants, but POSIX"r" sysconf variables: options and limits.  See sysconf(3) for more details."r" Sets the real, effective, and saved uid."r" ([see setresuid(2)](https://man7.org/linux/man-pages/man2/setresuid.2.html))"r" * `ruid`: real user id"r" * `euid`: effective user id"r" * `suid`: saved user id"r" * returns: Ok or libc error code."r" Err is returned if the user doesn't have permission to set this UID."r" Sets the real, effective, and saved gid."r" * `rgid`: real group id"r" * `egid`: effective group id"r" * `sgid`: saved group id"r" Err is returned if the user doesn't have permission to set this GID."r" Real, effective and saved user IDs."r" Real, effective and saved group IDs."r" Gets the real, effective, and saved user IDs."r" ([see getresuid(2)](http://man7.org/linux/man-pages/man2/getresuid.2.html))"r" #Returns"r" - `Ok((Uid, Uid, Uid))`: tuple of real, effective and saved uids on success."r" - `Err(x)`: libc error code on failure."r" Gets the real, effective, and saved group IDs."r" ([see getresgid(2)](http://man7.org/linux/man-pages/man2/getresgid.2.html))"r" - `Ok((Gid, Gid, Gid))`: tuple of real, effective and saved gids on success."r" Checks the file named by `path` for accessibility according to the flags given by `amode`"r" See [access(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/access.html)"r" Checks the file named by `path` for accessibility according to the flags given by `mode`"r" [faccessat(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/faccessat.html)"r" Representation of a User, based on `libc::passwd`"r" The reason some fields in this struct are `String` and others are `CString` is because some"r" fields are based on the user's locale, which could be non-UTF8, while other fields are"r" guaranteed to conform to [`NAME_REGEX`](https://serverfault.com/a/73101/407341), which only"r" contains ASCII."r" Username"r" User password (probably hashed)"r" User ID"r" Group ID"r" User information"r" Home directory"r" Path to shell"r" Get a user by UID."r" Internally, this function calls"r" [getpwuid_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)"r" use nix::unistd::{Uid, User};"r" // Returns an Result<Option<User>>, thus the double unwrap."r" let res = User::from_uid(Uid::from_raw(0)).unwrap().unwrap();"r#" assert_eq!(res.name, "root");"#r" Get a user by name."r" [getpwnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)"r" use nix::unistd::User;"r#" let res = User::from_name("root").unwrap().unwrap();"#r" Representation of a Group, based on `libc::group`"r" Group name"r" Group password"r" List of Group members"r" Get a group by GID."r" [getgrgid_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)"r" use nix::unistd::{Gid, Group};"r" // Returns an Result<Option<Group>>, thus the double unwrap."r" let res = Group::from_gid(Gid::from_raw(0)).unwrap().unwrap();"r#" assert!(res.name == "root");"#r" Get a group by name."r" [getgrnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html)"r" use nix::unistd::Group;"r#" let res = Group::from_name("root").unwrap().unwrap();"#r" Get the name of the terminal device that is open on file descriptor fd"r" (see [`ttyname(3)`](https://man7.org/linux/man-pages/man3/ttyname.3.html))."/// `AioFsync::submit` should not modify the `AioCb` object if/// `libc::aio_fsync` returns an error// Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,// only our bindings.  So it's sufficient to check that cancel// returned any AioCancelStat value./// `AioRead::submit` should not modify the `AioCb` object if/// `libc::aio_read` returns an error// Test a simple aio operation with no completion notification.  We must// poll for completion// Like ok, but allocates the structure on the stack.// poll for completion./// `AioWrite::write` should not modify the `AioCb` object if/// `libc::aio_write` returns an error.sigev_signaltest_timestampingtest_std_conversionsudp_inet6test_sendmsg_ipv4sendsrcaddr// Verify that ControlMessage::Ipv4SendSrcAddr works for sendmsg. This// creates a UDP socket bound to all local interfaces (0.0.0.0). It then// sends message to itself at 127.0.0.1 while explicitly specifying// 127.0.0.1 as the source address through an Ipv4SendSrcAddr// (IP_SENDSRCADDR) control message.// Note that binding to 0.0.0.0 is *required* on FreeBSD; sendmsg// returns EINVAL otherwise. (See FreeBSD's ip(4) man page.)test_recvif_ipv4test_recvif_ipv6test_txtime// It's believed that a QEMU issue, the tests run ok on a fully emulated system.test_dontfrag_optstest_v6dontfrag_opts// uclibc doesn't implement process_vm_readvtest_waitid_signaltest_waitid_exittest_waitid_pidptrace_wait_parentptrace_waitid_parenttest_waitid_ptracetest_timer// QEMU does not handle openat well enough to satisfy this test// https://gitlab.com/qemu-project/qemu/-/issues/829// uclibc doesn't support OFD locks, but the test should still compile// Implementation note: to allow unprivileged users to run it, this test makesassert_attr_eq// Defined as a macro such that the error source is reported as the caller's location.test_sendfile_dragonflySIGhandle_sigalarmalarm_fires//Clippy false positive https://github.com/rust-lang/rust-clippy/issues/9111test_faccessat_none_not_existingtest_faccessat_not_existingtest_faccessat_none_file_existstest_faccessat_file_exists// The pass by mut is technically needless only because the inner NonNull is// Copy.  But philosophically we're mutating the Dir, so we pass by mut./// Returns if any of the events of interest occured in the last call to `poll` or `ppoll`. Will/// only return `None` if the kernel provides status flags that Nix does not know about./// Equivalent to `x.revents()? != PollFlags::empty()`./// This is marginally more efficient than [`PollFd::all`]./// Returns if all the events of interest occured in the last call to `poll` or `ppoll`. Will/// Equivalent to `x.revents()? & x.events() == x.events()`./// This is marginally less efficient than [`PollFd::any`]./// Determines the CPU on which the calling thread is running./// let one_k_non_zero = std::num::NonZeroUsize::new(ONE_K).unwrap();///     let mem = mmap(None, one_k_non_zero, ProtFlags::PROT_NONE,// Disable test on aarch64 until we know why it fails.// https://github.com/nix-rust/nix/issues/2060/// This request is equivalent to `ptrace(PT_CONTINUE, ..., SIGKILL);`//! Provides helpers for making ptrace system calls/// The special value [`RLIM_INFINITY`] indicates that no limit will ber"   - If positive, specifies an individual process."/// InfiniBand native addressing// Not unnecessary on all platformsnew_unnamed/// Create a new `sockaddr_un` representing an "unnamed" unix socket address./// Check if this address is an "unnamed" unix socket address.SocketAddressLengthNotDynamic/// Set the length of this socket address/// This method may only be called on socket addresses whose lengths are dynamic, and it/// returns an error if called on a type whose length is static./// `new_length` must be a valid length for this type of address. Specifically, reads of that/// length from `self` must be valid./// The error returned by [`SockaddrLike::set_length`] on an address whose length is statically/// fixed.to_and_from// Ensure that we can convert to-and-from std::net variants without change./// Raw sockets ([raw(7)](https://man7.org/linux/man-pages/man7/raw.7.html))r" Contains outcome of sending or receiving a message"r" Use [`cmsgs`][RecvMsg::cmsgs] to access all the control messages present, and"r" [`iovs`][RecvMsg::iovs`] to access underlying io slices."iobufsXSMultiHeadersMultiResultsr" Preallocated structures needed for [`recvmmsg`] and [`sendmmsg`] functions"cmsg_buffersr" Preallocate structure used by [`recvmmsg`] and [`sendmmsg`] takes number of headers to preallocate"r" `cmsg_buffer` should be created with [`cmsg_space!`] if needed"preallocater" An extension of recvmsg that allows the caller to receive multiple messages from a socket using a single system call."r" This has performance benefits for some applications."r" This method performs no allocations."r" Returns an iterator producing [`RecvMsg`], one per received messages. Each `RecvMsg` can produce"r" iterators over [`IoSlice`] with [`iovs`][RecvMsg::iovs`] and"r" `ControlMessageOwned` with [`cmsgs`][RecvMsg::cmsgs]."r" # Bugs (in underlying implementation, at least in Linux)"r" The timeout argument does not work as intended. The timeout is checked only after the receipt"r" of each datagram, so that if up to `vlen`-1 datagrams are received before the timeout expires,"r" but then no further datagrams are received, the call will block forever."r" If an error occurs after at least one message has been received, the call succeeds, and returns"r" the number of messages received. The error code is expected to be returned on a subsequent"r" call to recvmmsg(). In the current implementation, however, the error code can be"r" overwritten in the meantime by an unrelated network event on a socket, for example an"r" incoming ICMP packet."r" Iterator over results of [`recvmmsg`]/[`sendmmsg`]"rmmr" Iterate over the filled io slices pointed by this msghdr"iovsIoSliceIteratortest_recvmm2r" Pack pointers to various structures into into msghdr"r" `iov_buffer` and `iov_buffer_len` must point to a slice"r" of `IoSliceMut` and number of available elements or be a null pointer and 0"r" `cmsg_buffer` and `cmsg_capacity` must point to a byte buffer used"r" to store control headers later or be a null pointer and 0 if control"r" headers are not used"r" Buffers must remain valid for the whole lifetime of msghdr"r" Set the protocol-defined priority for all packets to be"r" sent on this socket"r" Set or receive the Type-Of-Service (TOS) field that is"r" sent with every IP packet originating from this socket"IpTosr" Traffic class associated with outgoing packets"Ipv6TClassr" Fetch the current system-estimated Path MTU."IpMtur" Read, write and execute for owner."r" Read for owner."r" Write for owner."r" Execute for owner."r" Read write and execute for group."r" Read fr group."r" Write for group."r" Execute for group."r" Read, write and execute for other."r" Read for other."r" Write for other."r" Execute for other."r" Set user id on execution."r" Set group id on execution."type_of_statfsLIBC_FSTATFSLIBC_STATFS// The f_flags field exists on Android and Fuchsia too, but without man// pages I can't tell if it can be cast to FsFlags.line_discipline/// Line discipline (see `termios.c_line` documentation)zero_init_timespec// Clippy doesn't know that we need to pass iov mutably only because the// mutation happens after converting iov to a pointer/// NIS or YP domain name of this machine.r" The new file descriptor will have a new index but refer to the same"r" Commit filesystem caches containing file referred to by the open file"r" descriptor `fd` to disk"r" See also [syncfs(2)](https://man7.org/linux/man-pages/man2/sync.2.html)"r" Checks the file named by `path` for accessibility according to the flags given"r" by `mode` using effective UID, effective GID and supplementary group lists."r" * [FreeBSD man page](https://www.freebsd.org/cgi/man.cgi?query=eaccess&sektion=2&n=1)"r" * [Linux man page](https://man7.org/linux/man-pages/man3/euidaccess.3.html)"test_unnamed_uds_addr// Test getting an unnamed address (without unix socket creation)test_recvmsg_sockaddr_untest_named_unixdomaintest_unnamed_unixdomain// Test using unnamed unix domain addressestest_unnamed_unixdomain_autobind// Test creating and using unnamed unix domain addresses for autobinding socketstest_get_mtutest_so_prioritytest_ip_tostest_ipv6_tclasstest_eaccess_not_existingtest_eaccess_file_exists/// Returns the current value of errnolast_raw/// Returns the current raw i32 value of errno/// Sets the value of errno./// use nix::errno::Errno;/// Errno::EIO.set();/// assert_eq!(Errno::last(), Errno::EIO);set_raw/// Sets the raw i32 value of errno./// Errno::clear();/// let err = Errno::last();/// assert_ne!(err, Errno::EIO);/// assert_eq!(err, Errno::from_raw(0));//! Safe wrappers around errno functions//! use nix::errno::Errno;//! Errno::EIO.set();//! assert_eq!(Errno::last(), Errno::EIO);//! Errno::clear();//! assert_eq!(Errno::last(), Errno::from_raw(0));r" Flags that control how the various *at syscalls behave."r" Used with [`linkat`](crate::unistd::linkat`) to create a link to a symbolic link's"r" target, instead of to the symbolic link itself."r" Used with functions like [`fstatat`](crate::sys::stat::fstatat`) to operate on a link"r" itself, instead of the symbolic link's target."r#" Don't automount the terminal ("basename") component of pathname if it is a directory"#r" that is an automount point."r" If the provided path is an empty string, operate on the provided directory file"r" descriptor instead."r" Used with [`faccessat`](crate::unistd::faccessat), the checks for accessibility are"r" performed using the effective user and group IDs instead of the real user and group ID"r" open or create a file for reading, writing or executing"r" # See Also"r" [`open`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html)"r" The `openat` function is equivalent to the [`open`] function except in the case where the path"r" specifies a relative path.  In that case, the file to be opened is determined relative to the"r" directory associated with the file descriptor `fd`."r" [`openat`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/openat.html)"r" Change the name of a file."r" The `renameat` function is equivalent to `rename` except in the case where either `old_path`"r" or `new_path` specifies a relative path.  In such cases, the file to be renamed (or the its new"r" name, respectively) is located relative to `old_dirfd` or `new_dirfd`, respectively"r" [`renameat`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/rename.html)"r" Flags for use with [`renameat2`]."r" Atomically exchange `old_path` and `new_path`."r" Don't overwrite `new_path` of the rename.  Return an error if `new_path` already"r" exists."r#" creates a "whiteout" object at the source of the rename at the same time as performing"#r" the rename."r" This operation makes sense only for overlay/union filesystem implementations."r" Like [`renameat`], but with an additional `flags` argument."r" A `renameat2` call with an empty flags argument is equivalent to `renameat`."r" * [`rename`](https://man7.org/linux/man-pages/man2/rename.2.html)"r" Read value of a symbolic link"r" * [`readlink`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html)"r" Read value of a symbolic link."r" Equivalent to [`readlink` ] except where `path` specifies a relative path.  In that case,"r" interpret `path` relative to open file specified by `dirfd`."r" The file contents cannot be modified, except via shared writable mappings that were"r" created prior to the seal being set. Since Linux 5.1."r" Commands for use with [`fcntl`]."r" Duplicate the provided file descriptor"r" Duplicate the provided file descriptor and set the `FD_CLOEXEC` flag on it."r" Get the close-on-exec flag associated with the file descriptor"r" Set the close-on-exec flag associated with the file descriptor"r" Get descriptor status flags"r" Set descriptor status flags"r" Set or clear a file segment lock"r" Like [`F_SETLK`](FcntlArg::F_SETLK) except that if a shared or exclusive lock is blocked by"r" other locks, the process waits until the request can be satisfied."r" Get the first lock that blocks the lock description"r" Acquire or release an open file description lock"r" Like [`F_OFD_SETLK`](FcntlArg::F_OFD_SETLK) except that if a conflicting lock is held on"r" the file, then wait for that lock to be released."r" Determine whether it would be possible to create the given lock.  If not, return details"r" about one existing lock that would prevent it."r" Add seals to the file"r" Get seals associated with the file"r" Return the capacity of a pipe"r" Change the capacity of a pipe"r" Perform various operations on open file descriptors."r" * [`fcntl`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html)"r" Operations for use with [`Flock::lock`]."r" shared file lock"r" exclusive file lock"r" Unlock file"r" Shared lock.  Do not block when locking."r" Exclusive lock.  Do not block when locking."r" Represents valid types for flock."r" Types implementing this must not be `Clone`."Flockabler" Represents an owned flock, which unlocks on drop."r" See [flock(2)](https://linux.die.net/man/2/flock) for details on locking semantics."Flockr" Obtain a/an flock."r" # use std::io::Write;"r" # use nix::fcntl::{Flock, FlockArg};"r" # fn do_stuff(file: File) {"r"   let mut file = match Flock::lock(file, FlockArg::LockExclusive) {"r"       Ok(l) => l,"r"       Err(_) => return,"r"   // Do stuff"r#"   let data = "Foo bar";"#r"   _ = file.write(data.as_bytes());"r"   _ = file.sync_data();"r" Remove the lock and return the object wrapped within."r" fn do_stuff(file: File) -> nix::Result<()> {"r"     let mut lock = match Flock::lock(file, FlockArg::LockExclusive) {"r"         Ok(l) => l,"r"         Err((_,e)) => return Err(e),"r"     // Do critical section"r"     // Unlock"r"     let file = match lock.unlock() {"r"         Ok(f) => f,"r"         Err((_, e)) => return Err(e),"r"     // Do anything else"r"     Ok(())"r" The specific advice provided to [`posix_fadvise`]."r" Revert to the default data access behavior."r" The file data will be accessed sequentially."r" A hint that file data will be accessed randomly, and prefetching is likely not"r" advantageous."r" The specified data will only be accessed once and then not reused."r" The specified data will be accessed in the near future."r" The specified data will not be accessed in the near future."r" Allows a process to describe to the system its data access behavior for an open file"r" descriptor."r" * [`posix_fadvise`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_fadvise.html)"r" Pre-allocate storage for a range in a file"r" * [`posix_fallocate`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_fallocate.html)"//! file control options//! * `fanotify` - Linux's `fanotify` filesystem events monitoring API//! * `ioctl` - The `ioctl` syscall, and wrappers for many specific instances///         #[cfg(linux_android)]/// Mount a file system./// - `source`  -   Specifies the file system.  e.g. `/dev/sd0`./// - `target` -    Specifies the destination.  e.g. `/mnt`./// - `fstype` -    The file system type, e.g. `ext4`./// - `flags` -     Optional flags controlling the mount./// - `data` -      Optional file system specific data./// [`mount`](https://man7.org/linux/man-pages/man2/mount.2.html)/// Unmount the file system mounted at `target`./// See also [`umount`](https://man7.org/linux/man-pages/man2/umount.2.html)// x32 compatibility// See https://sourceware.org/bugzilla/show_bug.cgi?id=21279// The mode.bits() cast is only lossless on some OSes/// Borrow the underlying message queue descriptor./// Return the underlying message queue descriptor./// Returned descriptor is a "shallow copy" of the descriptor, so it refers///  to the same underlying kernel object as `self`./// Construct an [MqdT] from [RawFd]./// The `fd` given must be a valid and open file descriptor for a message///  queue./// Consume this [MqdT] and return a [RawFd].//! let mq_name= "/a_nix_test_queue";//! let mqd0 = mq_open(mq_name, oflag0, mode, None).unwrap();//! let mqd1 = mq_open(mq_name, oflag1, mode, None).unwrap();IflagsType/// type alias for InterfaceFlagspoll_timeoutPollTimeout/// # use std::os::unix::io::{AsFd, AsRawFd, FromRawFd};/// # use nix::{/// #     poll::{PollTimeout, PollFd, PollFlags, poll},/// #     unistd::{pipe, read}/// let (r, w) = pipe().unwrap();/// let pfd = PollFd::new(r.as_fd(), PollFlags::POLLIN);/// let mut fds = [pfd];/// poll(&mut fds, PollTimeout::NONE).unwrap();/// let mut buf = [0u8; 80];/// read(r.as_raw_fd(), &mut buf[..]);// Unlike I/O functions, constructors like this must take `BorrowedFd`// instead of AsFd or &AsFd.  Otherwise, an `OwnedFd` argument would be// dropped at the end of the method, leaving the structure referencing a// closed file descriptor.  For example:// let (r, _) = pipe().unwrap();// let pollfd = PollFd::new(r, flag);  // Drops the OwnedFd// // Do something with `pollfd`, which uses the CLOSED fd./// interval may overrun by a small amount.  Specifying a [`PollTimeout::NONE`]/// in timeout means an infinite timeout.  Specifying a timeout of/// [`PollTimeout::ZERO`] causes `poll()` to return immediately, even if no file/// descriptors are ready./// PollTimeout argument for polling./// Blocks indefinitely./// > Specifying a negative value in timeout means an infinite timeout./// Returns immediately./// > Specifying a timeout of zero causes poll() to return immediately, even if no file/// > descriptors are ready./// Blocks for at most [`i32::MAX`] milliseconds./// Returns if `self` equals [`PollTimeout::NONE`]./// Returns if `self` does not equal [`PollTimeout::NONE`]./// Returns the timeout in milliseconds if there is some, otherwise returns `None`./// Returns the timeout as a `Duration` if there is some, otherwise returns `None`.PollTimeoutTryFromErrorTooNegative/// Passing a value less than -1 is invalid on some systems, see/// <https://man.freebsd.org/cgi/man.cgi?poll#end>.TooPositive/// Passing a value greater than `i32::MAX` is invalid./// Error type for integer conversions into `PollTimeout`./// This is returned by [`openpty`]./// While this datatype is a thin wrapper around `OwnedFd`, it enforces that the available PTY/// functions are given the correct file descriptor./// Because `clone` creates a child process with its stack located in/// `stack` without specifying the size of the stack, special care must be/// taken to ensure that the child process does not overflow the provided/// stack space./// See [`fork`](crate::unistd::fork) for additional safety concerns related/// to executing child processes.AioReadv/// Asynchronously reads from a file descriptor into a scatter/gather list of buffers./// [aio_readv](https://www.freebsd.org/cgi/man.cgi?query=aio_readv)/// # use std::io::{IoSliceMut, Write};/// let mut rbuf0 = vec![0; 4];/// let mut rbuf1 = vec![0; 2];/// let expected_len = rbuf0.len() + rbuf1.len();/// let mut rbufs = [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];///         AioReadv::new(///             &mut rbufs,///     assert_eq!(aior.as_mut().aio_return().unwrap(), expected_len);/// assert_eq!(rbuf0, b"cdef");/// assert_eq!(rbuf1, b"12");iovlen/// Returns the number of buffers the operation will read into./// Create a new `AioReadv`, placing the data in a list of mutable slices./// * `bufs`:         A scatter/gather list of memory buffers.  They must///                   outlive the `AioReadv`.AioWritev/// Asynchronously writes from a scatter/gather list of buffers to a file descriptor./// [aio_writev](https://www.freebsd.org/cgi/man.cgi?query=aio_writev)/// # use std::io::IoSlice;/// const wbuf0: &[u8] = b"abcdef";/// const wbuf1: &[u8] = b"123456";/// let len = wbuf0.len() + wbuf1.len();/// let wbufs = [IoSlice::new(wbuf0), IoSlice::new(wbuf1)];///     AioWritev::new(///         &wbufs,/// assert_eq!(aiow.as_mut().aio_return().unwrap(), len);/// Construct a new `AioWritev`.///                   outlive the `AioWritev`./// pub static SIGNALED: AtomicBool = AtomicBool::new(false);EpollTimeoutEpoll/// A safe wrapper around [`epoll`](https://man7.org/linux/man-pages/man7/epoll.7.html)./// # use nix::sys::{epoll::{EpollTimeout, Epoll, EpollEvent, EpollFlags, EpollCreateFlags}, eventfd::{EventFd, EfdFlags}};/// # use nix::unistd::write;/// # use std::os::unix::io::{OwnedFd, FromRawFd, AsFd};/// # use std::time::{Instant, Duration};/// # fn main() -> nix::Result<()> {/// const DATA: u64 = 17;/// const MILLIS: u8 = 100;/// // Create epoll/// let epoll = Epoll::new(EpollCreateFlags::empty())?;/// // Create eventfd & Add event/// let eventfd = EventFd::new()?;/// epoll.add(&eventfd, EpollEvent::new(EpollFlags::EPOLLIN,DATA))?;/// // Arm eventfd & Time wait/// eventfd.arm()?;/// // Wait on event/// let mut events = [EpollEvent::empty()];/// epoll.wait(&mut events, MILLIS)?;/// // Assert data correct & timeout didn't occur/// assert_eq!(events[0].data(), DATA);/// assert!(now.elapsed().as_millis() < MILLIS.into());/// Creates a new epoll instance and returns a file descriptor referring to that instance./// [`epoll_create1`](https://man7.org/linux/man-pages/man2/epoll_create1.2.html)./// Add an entry to the interest list of the epoll file descriptor for/// specified in events./// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) with `EPOLL_CTL_ADD`./// Remove (deregister) the target file descriptor `fd` from the interest list./// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) with `EPOLL_CTL_DEL` ./// Change the settings associated with `fd` in the interest list to the new settings specified/// in `event`./// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) with `EPOLL_CTL_MOD`./// Waits for I/O events, blocking the calling thread if no events are currently available./// (This can be thought of as fetching items from the ready list of the epoll instance.)/// [`epoll_wait`](https://man7.org/linux/man-pages/man2/epoll_wait.2.html)/// This system call is used to add, modify, or remove entries in the interest list of the epoll/// instance referred to by `self`. It requests that the operation `op` be performed for the/// target file descriptor, `fd`./// When possible prefer [`Epoll::add`], [`Epoll::delete`] and [`Epoll::modify`]./// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html)/// A kernel event queue.  Used to notify a process of various asynchronousKqueue/// A kernel event queue./// Used by the kernel to notify the process of various types of asynchronous/// Create a new kernel event queue./// Register new events with the kqueue, and return any pending events to/// the user./// This method will block until either the timeout expires, or a registered/// event triggers a notification./// - `changelist` - Any new kevents to register for notifications./// - `eventlist` - Storage space for the kernel to return notifications./// - `timeout` - An optional timeout./// Returns the number of events placed in the `eventlist`.  If an error/// occurs while processing an element of the `changelist` and there is/// enough room in the `eventlist`, then the event will be placed in the/// `eventlist` with `EV_ERROR` set in `flags` and the system error in/// Construct a new `KEvent` suitable for submission to the kernel via the/// `changelist` argument of [`Kqueue::kevent`]./// Value used to identify this event.  The exact interpretation is/// determined by the attached filter, but often is a raw file descriptor./// Identifies the kernel filter used to process this event./// Will only return an error if the kernel reports an event via a filter/// that is unknown to Nix./// Flags control what the kernel will do when this event is added with/// [`Kqueue::kevent`]./// Filter-specific flags./// Filter-specific data value./// Opaque user-defined value passed through the kernel unchanged./// Modify an existing [`KEvent`].// Probably should deprecate.  Would anybody ever use it over `KEvent::new`?//! Kernel event notification mechanism//! # See Also//! [kqueue(2)](https://www.freebsd.org/cgi/man.cgi?query=kqueue)EventFd/// [`EventFd::from_value_and_flags`] with `init_val = 0` and `flags = EfdFlags::empty()`.from_value_and_flags/// Constructs [`EventFd`] with the given `init_val` and `flags`./// Wrapper around [`libc::eventfd`].from_flags/// [`EventFd::from_value_and_flags`] with `init_val = 0` and given `flags`./// [`EventFd::from_value_and_flags`] with given `init_val` and `flags = EfdFlags::empty()`./// Arms `self`, a following call to `poll`, `select` or `epoll` will return immediately./// [`EventFd::write`] with `1`.defuse/// Defuses `self`, a following call to `poll`, `select` or `epoll` will block./// [`EventFd::write`] with `0`./// Enqueues `value` triggers./// The next `value` calls to `poll`, `select` or `epoll` will return immediately./// [`EventFd::write`] with `value`.// Reads the value from the file descriptor.EventFFlags/// Compile version number of fanotify API.FanotifyEvent/// Abstract over `libc::fanotify_event_metadata`, which represents an event/// received via `Fanotify::read_events`.// Is not Clone due to fd field, to avoid use-after-close scenarios./// Version number for the structure. It must be compared to/// `FANOTIFY_METADATA_VERSION` to verify compile version and runtime/// version does match. It can be done with the/// `FanotifyEvent::check_version` method./// Checks that compile fanotify API version is equal to the version of theMaskFlags/// Mask flags of the events./// The file descriptor of the event. If the value is `None` when reading/// from the fanotify group, this event is to notify that a group queue/// overflow occured./// PID of the process that caused the event. TID in case flag/// `FAN_REPORT_TID` was set at group initialization._borrowed_fdFanotifyResponse/// Abstraction over the structure to be sent to allow or deny a given event./// Create a new response.Fanotify/// A fanotify group. This is also a file descriptor that can feed to other/// interfaces consuming file descriptors./// Initialize a new fanotify group./// Returns a Result containing a Fanotify instance./// For more information, see [fanotify_init(2)](https://man7.org/linux/man-pages/man7/fanotify_init.2.html).MarkFlags/// Add, remove, or modify an fanotify mark on a filesystem object./// If `dirfd` is `None`, `AT_FDCWD` is used./// Returns a Result containing either `()` on success or errno otherwise./// For more information, see [fanotify_mark(2)](https://man7.org/linux/man-pages/man7/fanotify_mark.2.html)./// Read incoming events from the fanotify group./// Returns a Result containing either a `Vec` of events on success or errno/// Possible errors can be those that are explicitly listed in/// [fanotify(2)](https://man7.org/linux/man-pages/man7/fanotify.2.html) in/// addition to the possible errors caused by `read` call./// In particular, `EAGAIN` is returned when no event is available on a/// group that has been initialized with the flag `InitFlags::FAN_NONBLOCK`,/// thus making this method nonblocking.write_response/// Write an event response on the fanotify group./// addition to the possible errors caused by `write` call./// In particular, `EAGAIN` or `EWOULDBLOCK` is returned when no event is/// available on a group that has been initialized with the flag/// `InitFlags::FAN_NONBLOCK`, thus making this method nonblocking.//! Fanotify is a Linux-only API to monitor filesystems events.//! Additional capabilities compared to the `inotify` API include the ability to//! monitor all of the objects in a mounted filesystem, the ability to make//! access permission decisions, and the possibility to read or modify files//! before access by other applications.//! For more documentation, please read//! [fanotify(7)](https://man7.org/linux/man-pages/man7/fanotify.7.html)./// # #[cfg(linux_android)]//!     let res = unsafe { libc::ioctl(fd, request_code_read!(SPI_IOC_MAGIC, SPI_IOC_TYPE_MODE, mem::size_of::<u8>()), data) };//! # #[cfg(linux_android)]//!     let res = unsafe {//!         libc::ioctl(//!             fd,//!             request_code_write!(SPI_IOC_MAGIC, SPI_IOC_TYPE_MESSAGE, data.len() * mem::size_of::<spi_ioc_transfer>()),//!             datar" Anonymous file will be created using huge pages. It should be safe now to"r" combine with [`MFD_ALLOW_SEALING`] too."r" However, despite its presence, on FreeBSD it is unimplemented for now (ENOSYS)."r" See also the hugetlb filesystem in [`memfd_create(2)`]."r" Following are to be used with [`MFD_HUGETLB`], indicating the desired hugetlb size."r" hugetlb size of 2MB."r" hugetlb size of 8MB."r" hugetlb size of 16MB."r" hugetlb size of 32MB."r" hugetlb size of 256MB."r" hugetlb size of 512MB."r" hugetlb size of 1GB."r" hugetlb size of 2GB."r" hugetlb size of 16GB."// Delays codegen, preventing linker errors with dylibs and --no-allow-shlib-undefinedmap_hugetlb_with_size_log2/// Create `MAP_HUGETLB` with provided size of huge page./// Under the hood it computes `MAP_HUGETLB | (huge_page_size_log2 << libc::MAP_HUGE_SHIFT`)./// `huge_page_size_log2` denotes logarithm of huge page size to use and should be/// between 16 and 63 (inclusively)./// # use nix::sys::mman::MapFlags;/// let f = MapFlags::map_hugetlb_with_size_log2(30).unwrap();/// assert_eq!(f, MapFlags::MAP_HUGETLB | MapFlags::MAP_HUGE_1GB);/// Allocate memory, or map files or devices into memory/// For anonymous mappings (`MAP_ANON`/`MAP_ANONYMOUS`), see [mmap_anonymous].mmap_anonymous/// Create an anonymous memory mapping./// This function is a wrapper around [`mmap`]:/// `mmap(ptr, len, prot, MAP_ANONYMOUS | flags, -1, 0)`.// For Hurd as `MADV_FREE` is not available on it/// # use nix::sys::mman::{mmap_anonymous, mprotect, MapFlags, ProtFlags};/// # use std::os::unix::io::BorrowedFd;///     let mem = mmap_anonymous(None, one_k_non_zero, ProtFlags::PROT_NONE, MapFlags::MAP_PRIVATE)///     std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)r" The type of hardware memory corruption kill policy for the thread."PrctlMCEKillPolicyr" The thread will receive SIGBUS as soon as a memory corruption is detected."r" The process is killed only when it accesses a corrupted page."r" Uses the system-wide default."prctl_set_boolprctl_get_boolset_child_subreaper/// Set the "child subreaper" attribute for this processget_child_subreaper/// Get the "child subreaper" attribute for this processset_dumpable/// Set the dumpable attribute which determines if core dumps are created for this process.get_dumpable/// Get the dumpable attribute for this process.set_keepcaps/// Set the "keep capabilities" attribute for this process. This causes the thread to retain/// capabilities even if it switches its UID to a nonzero value.get_keepcaps/// Get the "keep capabilities" attribute for this processclear_mce_kill/// Clear the thread memory corruption kill policy and use the system-wide defaultset_mce_kill/// Set the thread memory corruption kill policyget_mce_kill/// Get the thread memory corruption kill policyset_pdeathsig/// Set the parent-death signal of the calling process. This is the signal that the calling process/// will get when its parent dies.get_pdeathsig/// Returns the current parent-death signal/// Set the name of the calling thread. Strings longer than 15 bytes will be truncated./// Return the name of the calling threadset_timerslack/// Sets the timer slack value for the calling thread. Timer slack is used by the kernel to group/// timer expirations and make them the supplied amount of nanoseconds late.get_timerslack/// Get the timerslack for the calling thread.task_perf_events_disable/// Disable all performance counters attached to the calling process.task_perf_events_enable/// Enable all performance counters attached to the calling process.set_no_new_privs/// Set the calling threads "no new privs" attribute. Once set this option can not be unset.get_no_new_privs/// Get the "no new privs" attribute for the calling thread.set_thp_disable/// Set the state of the "THP disable" flag for the calling thread. Setting this disables/// transparent huge pages.get_thp_disable/// Get the "THP disable" flag for the calling thread.//! prctl is a Linux-only API for performing operations on a process or thread.//! Note that careless use of some prctl() operations can confuse the user-space run-time//! environment, so these operations should be used with care.//! For more documentation, please read [prctl(2)](https://man7.org/linux/man-pages/man2/prctl.2.html)./// Set options, as with `ptrace(PTRACE_SETOPTIONS, ...)`./// Gets a ptrace event as described by `ptrace(PTRACE_GETEVENTMSG, ...)`/// Get siginfo as with `ptrace(PTRACE_GETSIGINFO, ...)`/// Set siginfo as with `ptrace(PTRACE_SETSIGINFO, ...)`/// Reads a word from a processes memory at the given address, as with/// ptrace(PTRACE_PEEKDATA, ...)/// Writes a word into the processes memory at the given address, as with/// ptrace(PTRACE_POKEDATA, ...)/// Reads a word from a user area at `offset`, as with ptrace(PTRACE_PEEKUSER, ...)./// Writes a word to a user area at `offset`, as with ptrace(PTRACE_POKEUSER, ...).//! Reboot/shutdown//! On Linux, This can also be used to enable/disable Ctrl-Alt-Delete./// # use std::os::unix::io::{AsRawFd, BorrowedFd};/// let fd_four = unsafe {BorrowedFd::borrow_raw(4)};/// let fd_nine = unsafe {BorrowedFd::borrow_raw(9)};/// set.insert(fd_four);/// set.insert(fd_nine);/// assert_eq!(set.highest().map(|borrowed_fd|borrowed_fd.as_raw_fd()), Some(9));/// # use std::os::unix::io::{AsRawFd, BorrowedFd, RawFd};/// let fds: Vec<RawFd> = set.fds(None).map(|borrowed_fd|borrowed_fd.as_raw_fd()).collect();/// For more information, see [the sendfile(2) man page.](https://man7.org/linux/man-pages/man2/sendfile.2.html) for Linux,/// see [the sendfile(2) man page.](https://docs.oracle.com/cd/E88353_01/html/E37843/sendfile-3c.html) for Solaris.r" Wait for a signal"r" # Return value"r" If `sigsuspend(2)` is interrupted (EINTR), this function returns `Ok`."r" If `sigsuspend(2)` set other error, this function returns `Err`."r" For more information see the"r" [`sigsuspend(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigsuspend.html)."suspendr" static SIGNALED: AtomicBool = AtomicBool::new(false);"libc_sigevent_signalfd/// let ss: SockaddrStorage = getsockname(fd.as_raw_fd()).unwrap();/// bind(fd.as_raw_fd(), &localhost).expect("bind");/// let ss: SockaddrStorage = getsockname(fd.as_raw_fd()).expect("getsockname");NetlinkNFLOG/// Netfilter/iptables ULOG.NetlinkGeneric/// Generic netlink family for simplified netlink usage.Icmp/// ICMP protocol ([icmp(7)](https://man7.org/linux/man-pages/man7/icmp.7.html))IcmpV6/// ICMPv6 protocol (ICMP over IPv6)CanRaw/// The Controller Area Network raw socket protocol/// ([ref](https://docs.kernel.org/networking/can.html#how-to-use-socketcan))CanBcm/// The Controller Area Network broadcast manager protocol// Matches libc::CAN_RAW// Matches libc::CAN_BCM// Matches libc::SYSPROTO_EVENTr" Collect transmitting timestamps as reported by hardware"r" Collect transmitting timestamps as reported by software"r" Generate a unique identifier along with each transmitted packet"r" Return transmit timestamps alongside an empty packet instead of the original packet"r" Turns on [`MSG_DONTWAIT`] after the first message has been received (only for"r" `recvmmsg()`)."BacklogMAXCONN/// Sets the listen queue size to system `SOMAXCONN` valueMAXALLOWABLE/// Sets the listen queue size to -1 for system supporting it/// Create a `Backlog`, an `EINVAL` will be returned if `val` is invalid./// let fd = listener;/// let res = setsockopt(&fd, KeepAlive, &true);r" Set or read the hop limit value of outgoing IPv6 multicast packets for"Ipv6MulticastHopsr" If enabled, the kernel will not reserve an ephemeral port when binding"r" socket with a port number of 0. The port will later be automatically"r" chosen at connect time, in a way that allows sharing a source port as"r" long as the 4-tuple is unique."IpBindAddressNoPortr" Enables TCP Fast Open (RFC 7413) on a connecting socket. If a fast open"r" cookie is not available (first attempt to connect), `connect` syscall"r" will behave as usual, except for internally trying to solicit a cookie"r" from remote peer. When cookie is available, the next `connect` syscall"r" will immediately succeed without actually establishing TCP connection."r" The connection establishment will be defered till the next `write` or"r" `sendmsg` syscalls on the socket, allowing TCP prtocol to establish"r" connection and send data in the same packets. Note: calling `read` right"r" after `connect` without `write` on the socket will cause the blocking"r" socket to be blocked forever."TcpFastOpenConnectTcpUlp/// Set the Upper Layer Protocol (ULP) on the TCP socket./// For example, to enable the TLS ULP on a socket, the C function call would be:/// setsockopt(sock, SOL_TCP, TCP_ULP, "tls", sizeof("tls"));/// ... and the `nix` equivalent is:/// ```ignore,rust/// setsockopt(sock, TcpUlp::default(), b"tls");/// Note that the ULP name does not need a trailing NUL terminator (`\0`).TlsCryptoInfo/// AES-128-GCM/// AES-256-GCMChacha20Poly1305/// CHACHA20-POLY1305/// Value used with the [`TcpTlsTx`] and [`TcpTlsRx`] socket options.TcpTlsTx/// Set the Kernel TLS write parameters on the TCP socket./// For example, the C function call would be:/// setsockopt(sock, SOL_TLS, TLS_TX, &crypto_info, sizeof(crypto_info));/// setsockopt(sock, TcpTlsTx, &crypto_info);TcpTlsRx/// Set the Kernel TLS read parameters on the TCP socket./// setsockopt(sock, SOL_TLS, TLS_RX, &crypto_info, sizeof(crypto_info));/// setsockopt(sock, TcpTlsRx, &crypto_info);r" Read for group."/// If you want to set the timestamp to now, use `TimeSpec::UTIME_NOW`. Use/// `TimeSpec::UTIME_OMIT` if you don't want to change it./// Configures the port to "sane" mode (like the configuration of a newly created terminal) (see/// [tcsetattr(3)](https://www.freebsd.org/cgi/man.cgi?query=tcsetattr))./// Note that this is a non-standard function, available on FreeBSD./// Leave the timestamp unchanged.// At the time of writing this PR, redox does not support this feature/// Update the timestamp to `Now`/// other interfaces taking file descriptors as arguments, [`epoll`] for example./// [`epoll`]: crate::sys::epoll/// # Cancel on a clock change/// If you set a `TFD_TIMER_CANCEL_ON_SET` alongside `TFD_TIMER_ABSTIME`/// and the clock for this timer is `CLOCK_REALTIME` or `CLOCK_REALTIME_ALARM`,/// then this timer is marked as cancelable if the real-time clock undergoes/// a discontinuous change._Unreachable/// A helper variant to resolve the unused parameter (`'fd`) problem on platforms/// other than Linux and Android./// Newtype pattern around [`libc::clockid_t`]./// Starts at zero when the kernel boots and increments monotonically in SI seconds while the/// machine is running./// Like [`CLOCK_BOOTTIME`](ClockId::CLOCK_BOOTTIME), but will wake the system if it is/// suspended../// Increments in SI seconds./// Like [`CLOCK_MONOTONIC`](ClockId::CLOCK_MONOTONIC), but optimized for execution time at the expense of accuracy./// Like [`CLOCK_MONOTONIC`](ClockId::CLOCK_MONOTONIC), but optimized for accuracy at the expense of execution time./// Similar to [`CLOCK_MONOTONIC`](ClockId::CLOCK_MONOTONIC), but provides access to a raw/// hardware-based time that is not subject to NTP adjustments./// Returns the execution time of the calling process./// Increments when the CPU is running in user or kernel mode/// Increments as a wall clock should./// Like [`CLOCK_REALTIME`](ClockId::CLOCK_REALTIME), but not settable./// Like [`CLOCK_REALTIME`](ClockId::CLOCK_REALTIME), but optimized for execution time at the expense of accuracy./// Like [`CLOCK_REALTIME`](ClockId::CLOCK_REALTIME), but optimized for accuracy at the expense of execution time./// Returns the current second without performing a full time counter query, using an in-kernel/// cached value of the current second.// Undocumented on Linux!/// International Atomic Time./// A nonsettable system-wide clock derived from wall-clock time but ignoring leap seconds./// Returns the execution time of the calling thread./// Like [`CLOCK_UPTIME`](ClockId::CLOCK_UPTIME), but optimized for execution time at the expense of accuracy./// Like [`CLOCK_UPTIME`](ClockId::CLOCK_UPTIME), but optimized for accuracy at the expense of execution time./// Increments only when the CPU is running in user mode on behalf of the calling process.ClockNanosleepFlags/// Suspend execution of this thread for the amount of time specified by `request`/// and measured against the clock speficied by `clock_id`./// If `flags` is [`TIMER_ABSTIME`](ClockNanosleepFlags::TIMER_ABSTIME), this function will suspend/// execution until the time value of clock_id reaches the absolute time specified by `request`. If/// a signal is caught by a signal-catching function, or a signal causes the process to terminate,/// this sleep is interrrupted./// see also [man 3 clock_nanosleep](https://pubs.opengroup.org/onlinepubs/009695399/functions/clock_nanosleep.html)//! Sleep, query system clocks, and set system clockr" This is the parent process of the fork."r" The PID of the fork's child process"r" This is the child process of the fork."r#"        write(std::io::stdout(), "I'm a new child process\n".as_bytes()).ok();"#r" Get process group"r" See Also [`getpgid`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgid.html)"r" and flags (see [`dup(2)`](https://man7.org/linux/man-pages/man2/dup.2.html))."r" Unlike [`lseek`], it takes a 64-bit argument even on platforms where [`libc::off_t`] is"r" 32 bits."r" Determines if the file descriptor refers to a valid terminal type device."r" `newpath` and file descriptor `newdirfd`. In case `flag` is `AtFlags::AT_SYMLINK_FOLLOW` and"r" Remove the directory entry as a directory, not a normal file"r" Remove the directory entry as a normal file, not a directory"r" Change a process's root directory"/// Change the root file system./// See Also [`pivot_root`](https://man7.org/linux/man-pages/man2/pivot_root.2.html)test_fanotifytest_eventtest_statvfstest_utsnametest_statfsSIGNALEDcasting_vectoredfanotify/// Run fanotify tests sequentially to avoid tmp files racestest_fanotify_notificationstest_fanotify_responsestest_get_set_subreapertest_get_set_dumpabletest_get_set_keepcapstest_get_set_clear_mce_killtest_get_set_pdeathsigtest_get_set_nametest_get_set_timerslacktest_disable_enable_perf_eventstest_get_set_no_new_privstest_get_set_thp_disabletest_prctltest_sigsuspendtest_eq_emptytest_eq_alltest_hash_emptytest_hash_alltest_signalfd_setmask/// Update the signal mask of an already existing signalfd.test_timestamping_realtimetest_timestamping_monotonictest_listen_wrongbacklogtest_icmp_protocol// cfg needed for capability check.// test contains both recvmmsg and timestaping which is linux only// there are existing tests for recvmmsg only in tests/can_open_routing_sockettest_local_peer_pidtest_so_listen_q_limittest_multicast_ttl_opts_ipv4test_multicast_ttl_opts_ipv6test_ipv6_multicast_hopstest_receive_timestamptest_ts_clock_realtime_microtest_ts_clock_bintimetest_ts_clock_realtimetest_ts_clock_monotonictest_ip_bind_address_no_port// Disable the test under emulation because it fails with ENOPROTOOPT in CI// on cross target. Lack of QEMU support is suspected.test_tcp_fast_open_connecttest_ktls// Some architectures running under cross don't support `setsockopt(SOL_TCP, TCP_ULP)`// because the cross image is based on Ubuntu 16.04 which predates TCP ULP support// (it was added in kernel v4.13 released in 2017). For these architectures,// the `setsockopt(SOL_TCP, TCP_ULP, "tls", sizeof("tls"))` call succeeds// but the subsequent `setsockopt(SOL_TLS, TLS_TX, ...)` call fails with `ENOPROTOOPT`.// It's as if the first `setsockopt` call enabled some other option, not `TCP_ULP`.// For example, `strace` says://     [pid   813] setsockopt(4, SOL_TCP, 0x1f /* TCP_??? */, [7564404], 4) = 0// It's not clear why `setsockopt(SOL_TCP, TCP_ULP)` succeeds if the container image libc doesn't support it,// but in any case we can't run the test on such an architecture, so skip it./// Helper function analogous to `std::io::Write::write_all`, but for `Fd`stest_baudrate_try_fromtest_uname_darwintest_uname_freebsd/// Helper function analogous to `std::io::Read::read_exact`, but for `Fd`sFORK_MTX/// Any test that creates child processes must grab this mutex, regardless/// of what it does with those children.CWD_LOCK/// Any test that changes the process's current working directory must grab/// the RwLock exclusively.  Any process that cares about the current/// working directory must grab it shared.GROUPS_MTX/// Any test that changes the process's supplementary groups must grab this/// mutexKMOD_MTX/// Any tests that loads or unloads kernel modules must grab this mutexPTSNAME_MTX/// Any test that calls ptsname(3) must grab this mutex.SIGNAL_MTX/// Any test that alters signal handling must grab this mutex.errno_set_and_readerrno_set_and_cleartest_f_get_pathtest_f_get_path_nofirmlinktest_f_kinfoverify_lock_and_drop/// Verify that `Flock::lock()` correctly obtains a lock, and subsequently unlocks upon drop.verify_unlock/// Verify that `Flock::unlock()` correctly obtains unlocks.test_flock/// Test `Flock` and associated functions.test_mq_timedreceive/// master/slave PTTY pair.test_sendfilevtest_futimens_unchangedtest_utimensat_unchangedtest_clock_nanosleeptest_rfork_and_waitpidtest_group_from/// Converts from a file descriptor, closing it on failure.r" Path resolution flags."r" See [path resolution(7)](https://man7.org/linux/man-pages/man7/path_resolution.7.html)"r" for details of the resolution process."ResolveFlagr" Do not permit the path resolution to succeed if any component of"r" the resolution is not a descendant of the directory indicated by"r" dirfd.  This causes absolute symbolic links (and absolute values of"r" pathname) to be rejected."r" Treat the directory referred to by dirfd as the root directory"r" while resolving pathname."r" Disallow all magic-link resolution during path resolution. Magic"r" links are symbolic link-like objects that are most notably found"r" in proc(5);  examples include `/proc/[pid]/exe` and `/proc/[pid]/fd/*`."r" See symlink(7) for more details."r" Disallow resolution of symbolic links during path resolution. This"r" option implies RESOLVE_NO_MAGICLINKS."r" Disallow traversal of mount points during path resolution (including"r" all bind mounts)."r" Specifies how [openat2] should open a pathname."r" See <https://man7.org/linux/man-pages/man2/open_how.2type.html>"OpenHowr" Create a new zero-filled `open_how`."r" Set the open flags used to open a file, completely overwriting any"r" existing flags."r" Set the file mode new files will be created with, overwriting any"r" Set resolve flags, completely overwriting any existing flags."r" See [ResolveFlag] for more detail."r" Open or create a file for reading, writing or executing."r" `openat2` is an extension of the [`openat`] function that allows the caller"r" to control how path resolution happens."r" # See also"r" [openat2](https://man7.org/linux/man-pages/man2/openat2.2.html)"openat2r" Relock the file.  This can upgrade or downgrade the lock type."r" # use tempfile::tempfile;"r" let f: std::fs::File = tempfile().unwrap();"r" let locked_file = Flock::lock(f, FlockArg::LockExclusive).unwrap();"r" // Do stuff, then downgrade the lock"r" locked_file.relock(FlockArg::LockShared).unwrap();"relockworkaround_xnu_bug/// Workaround a bug in XNU where netmasks will always have the wrong size in/// the sa_len field due to the kernel ignoring trailing zeroes in the structure/// when setting the field. See https://github.com/nix-rust/nix/issues/1709#issuecomment-1199304470/// To fix this, we stack-allocate a new sockaddr_storage, zero it out, and/// memcpy sa_len of the netmask to that new storage. Finally, we reset the/// ss_len field to sizeof(sockaddr_storage). This is supposedly valid as all/// members of the sockaddr_storage are "ok" with being zeroed out (there are/// no pointers)./// # see also/// [`mount`](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/mount.2.html)/// Umount the file system mounted at `target`.bsd_without_apple/// Resolve an interface into an interface number./// Resolve an interface number into an interface.r" A successful result of [`forkpty()`]."r" This is the parent process of the underlying fork."r" A file descriptor referring to master side of the pseudoterminal of"r" the child process."r" This is the child process of the underlying fork."r" Create a new process operating in a pseudoterminal."r" # Reference"r" * [FreeBSD](https://man.freebsd.org/cgi/man.cgi?query=forkpty)"r" * [Linux](https://man7.org/linux/man-pages/man3/forkpty.3.html)"/// # use std::os::unix::io::AsFd;/// let mut aiocb = Box::pin(AioWrite::new(f.as_fd(),/// let mut aiof = Box::pin(AioFsync::new(f.as_fd(), AioFsyncMode::O_SYNC,///             f.as_fd(),///         f.as_fd(),/// let cs = aio_cancel_all(f.as_fd()).unwrap();///     f.as_fd(),set_vma_anon_name/// Set an identifier (or reset it) to the address memory range.RegisterSetValue/// Corresponding type of registers in the kernel.Regs/// Struct representing the register space.RegisterSet/// Represents register set areas, such as general-purpose registers or/// floating-point registers./// This trait is marked unsafe, since implementation of the trait must match/// ptrace's request `VALUE` and return data type `Regs`./// General-purpose registers./// Floating-point registers.user_fpsimd_struct__riscv_mc_d_ext_stateregset/// Register sets used in [`getregset`] and [`setregset`]/// Note that since `PTRACE_GETREGS` are not available on all platforms (as in [ptrace(2)]),/// `ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, ...)` is used instead to achieve the same effect/// on aarch64 and riscv64./// [ptrace(2)]: https://www.man7.org/linux/man-pages/man2/ptrace.2.htmlgetregset/// Get a particular set of user registers, as with `ptrace(PTRACE_GETREGSET, ...)`/// Note that since `PTRACE_SETREGS` are not available on all platforms (as in [ptrace(2)]),/// `ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, ...)` is used instead to achieve the same effectsetregset/// Set a particular set of user registers, as with `ptrace(PTRACE_SETREGSET, ...)`/// The resident set size at its peak,sys_controlSysControlAddrRoute/// Kernel interface for interacting with the routing table/// KEXT Controls and NotificationsImpLink/// ARPANet IMP addressesPup/// PUP protocols, e.g. BSPChaos/// MIT CHAOS protocols/// Novell and Xerox protocolIsoDatakit/// Bell Labs virtual circuit switch ?Ccitt/// CCITT protocols, X.25 etcDli/// DEC Direct data link interfaceLatHylink/// NSC Hyperchannel/// Link layer interfaceCoip/// connection-oriented IP, aka ST IICnt/// Computer Network TechnologyNatm/// Native ATM accesssctltest_datalink_display/// Don't panic when trying to display an empty datalink addressmacos_loopbackmacos_tapsolarish_tapKextControl/// Allows applications to configure and control a KEXT/// ([ref](https://developer.apple.com/library/content/documentation/Darwin/Conceptual/NKEConceptual/control/control.html))KextEvent/// Allows applications and other KEXTs to be notified when certain kernel events occurGetCString/// Getter for a `CString` value.r" If `flag` is `AtFlags::AT_SYMLINK_NOFOLLOW` and `path` names a symbolic link,"r" `fchownat(None, path, owner, group, AtFlags::AT_SYMLINK_NOFOLLOW)` is identical to"r" Creates a directory which persists even after process termination"r" * `template`: a path whose rightmost characters contain some number of X, e.g. `/tmp/tmpdir_XXXXXX`"r" * returns: filename"r" Err is returned either if no temporary filename could be created or the template had insufficient X"r" See also [mkstemp(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdtemp.html)"r#" match unistd::mkdtemp("/tmp/tempdir_XXXXXX") {"#r"     Ok(_path) => {"r"         // do something with directory"r#"     Err(e) => panic!("mkdtemp failed: {}", e)"#r" The frequency of the statistics clock in ticks per second."r" The number of replenishment operations that can be simultaneously pending for a particular"r" sporadic server scheduler."r" Maximum size of a trace event name in characters."r" The length in bytes of a trace generation version string or a trace stream name."r" Maximum number of times `posix_trace_create` may be called from the same or different"r" processes."r" Maximum number of user trace event type identifiers for a single process."r" Maximum number of attempts made to destroy a thread's thread-specific data values on thread"r" exit."r" Maximum number of data keys that can be created by a process."r" Minimum size in bytes of thread stack storage."r" Maximum number of threads that can be created per process."r" The maximum number of repeated occurrences of a regular expression permitted when using"r" interval notation."r" Maximum number of realtime signals reserved for application use."r" Maximum number of semaphores that a process may have."r" The maximum value a semaphore may have."r" Maximum number of queued signals that a process may send and have pending at the"r" receiver(s) at any time."r" The minimum maximum number of streams that a process may have open at any one time."r" Maximum number of symbolic links that can be reliably traversed in the resolution of a"r" pathname in the absence of a loop."r" Maximum number of timers per process supported."r" Maximum length of terminal device name."r" The minimum maximum number of types supported for the name of a timezone."r" The implementation supports the XOpen Legacy Option group."r" See Also <https://pubs.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap02.html>"r" Real UID"r" Effective UID"r" Saved UID"r" Real GID"r" Effective GID"r" Saved GID"r" If `f` writes to its `*mut *mut libc::passwd` parameter, then it must"r" also initialize the value pointed to by its `*mut libc::group`"r" parameter."r" [getpwnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwnam_r.html)"r" If `f` writes to its `*mut *mut libc::group` parameter, then it must"test_mount_appletest_fanotify_overflowtest_set_vma_anon_nametest_ptrace_regsetstest_too_small_cmsgspacetest_utun_ifnametest_reuseport_lb/// Any test that creates child processes or can be affected by child processes must grab this mutex, regardless/// of what it does with those children. It must hold the mutex until the/// child processes are waited upon.test_openat2test_openat2_forbiddenlock_and_drop/// An exclusive lock can be downgraded/// A shared lock can be upgradedtest_if_indextonameInputIterToUsize/// Generates a parser taking `count` bits/// # use nom::bits::complete::take;/// # use nom::IResult;/// # use nom::error::{Error, ErrorKind};/// // Input is a tuple of (input: I, bit_offset: usize)/// fn parser(input: (&[u8], usize), count: usize)-> IResult<(&[u8], usize), u8> {///  take(count)(input)/// // Consumes 0 bits, returns 0/// assert_eq!(parser(([0b00010010].as_ref(), 0), 0), Ok((([0b00010010].as_ref(), 0), 0)));/// // Consumes 4 bits, returns their values and increase offset to 4/// assert_eq!(parser(([0b00010010].as_ref(), 0), 4), Ok((([0b00010010].as_ref(), 4), 0b00000001)));/// // Consumes 4 bits, offset is 4, returns their values and increase offset to 0 of next byte/// assert_eq!(parser(([0b00010010].as_ref(), 4), 4), Ok((([].as_ref(), 0), 0b00000010)));/// // Tries to consume 12 bits but only 8 are available/// assert_eq!(parser(([0b00010010].as_ref(), 0), 12), Err(nom::Err::Error(Error{input: ([0b00010010].as_ref(), 0), code: ErrorKind::Eof })));/// Generates a parser taking `count` bits and comparing them to `pattern`/// Parses one specific bit as a bool./// # use nom::bits::complete::bool;/// fn parse(input: (&[u8], usize)) -> IResult<(&[u8], usize), bool> {///     bool(input)/// assert_eq!(parse(([0b10000000].as_ref(), 0)), Ok((([0b10000000].as_ref(), 1), true)));/// assert_eq!(parse(([0b10000000].as_ref(), 1)), Ok((([0b10000000].as_ref(), 2), false)));test_take_0test_take_eoftest_take_span_over_multiple_bytestest_bool_0test_bool_eof//! Bit level parsersErrorConvert/// Converts a byte-level input to a bit-level input, for consumption by a parser that uses bits./// Afterwards, the input is converted back to a byte-level parser, with any remaining bits thrown/// away./// use nom::bits::{bits, streaming::take};/// use nom::error::Error;/// use nom::IResult;/// fn parse(input: &[u8]) -> IResult<&[u8], (u8, u8)> {///     bits::<_, _, Error<(&[u8], usize)>, _, _>(tuple((take(4usize), take(8usize))))(input)/// let input = &[0x12, 0x34, 0xff, 0xff];/// let output = parse(input).expect("We take 1.5 bytes and the input is longer than 2 bytes");/// // The first byte is consumed, the second byte is partially consumed and dropped./// let remaining = output.0;/// assert_eq!(remaining, [0xff, 0xff]);/// let parsed = output.1;/// assert_eq!(parsed.0, 0x01);/// assert_eq!(parsed.1, 0x23);/// Counterpart to `bits`, `bytes` transforms its bit stream input into a byte slice for the underlying/// parser, allowing byte-slice parsers to work on bit streams./// A partial byte remaining in the input will be ignored and the given parser will start parsing/// at the next full byte./// use nom::bits::{bits, bytes, streaming::take};/// use nom::combinator::rest;/// fn parse(input: &[u8]) -> IResult<&[u8], (u8, u8, &[u8])> {///   bits::<_, _, Error<(&[u8], usize)>, _, _>(tuple((///     take(4usize),///     take(8usize),///     bytes::<_, _, Error<&[u8]>, _, _>(rest)///   )))(input)/// assert_eq!(parse( input ), Ok(( &[][..], (0x01, 0x23, &[0xff, 0xff][..]) )));test_complete_byte_consumption_bits/// Take the `bits` function and assert that remaining bytes are correctly returned, if the/// previous bytes are fully consumedtest_partial_byte_consumption_bits/// previous bytes are NOT fully consumed. Partially consumed bytes are supposed to be dropped./// I.e. if we consume 1.5 bytes of 4 bytes, 2 bytes will be returned, bits 13-16 will betest_incomplete_bits/// Ensure that in Incomplete error is thrown, if too few bytes are passed for a given parser.test_tag_oktest_tag_err/// Tests each parser in the tuple and returns the result of the first one that succeeds/// Helper trait for the [alt()] combinator./// This trait is implemented for tuples of up to 21 elements/// Tests a list of parsers one by one until one succeeds./// It takes as argument a tuple of parsers. There is a maximum of 21/// parsers. If you need more, it is possible to nest them in other `alt` calls,/// like this: `alt(parser_a, alt(parser_b, parser_c))`/// # use nom::error_position;/// # use nom::{Err,error::ErrorKind, Needed, IResult};/// use nom::character::complete::{alpha1, digit1};/// use nom::branch::alt;/// fn parser(input: &str) -> IResult<&str, &str> {///   alt((alpha1, digit1))(input)/// // the first parser, alpha1, recognizes the input/// assert_eq!(parser("abc"), Ok(("", "abc")));/// // the first parser returns an error, so alt tries the second one/// assert_eq!(parser("123456"), Ok(("", "123456")));/// // both parsers failed, and with the default error type, alt will return the last error/// assert_eq!(parser(" "), Err(Err::Error(error_position!(" ", ErrorKind::Digit))));/// With a custom error type, it is possible to have alt return the error of the parser/// that went the farthest in the input datapermutation/// Tries to apply all parsers in the tuple in various orders until all of them succeedPermutation/// Helper trait for the [permutation()] combinator./// Applies a list of parsers in any order./// Permutation will succeed if all of the child parsers succeeded./// It takes as argument a tuple of parsers, and returns a/// tuple of the parser results./// # use nom::{Err,error::{Error, ErrorKind}, Needed, IResult};/// use nom::branch::permutation;/// fn parser(input: &str) -> IResult<&str, (&str, &str)> {///   permutation((alpha1, digit1))(input)/// // permutation recognizes alphabetic characters then digit/// assert_eq!(parser("abc123"), Ok(("", ("abc", "123"))));/// // but also in inverse order/// assert_eq!(parser("123abc"), Ok(("", ("abc", "123"))));/// // it will fail if one of the parsers failed/// assert_eq!(parser("abc;"), Err(Err::Error(Error::new(";", ErrorKind::Digit))));/// The parsers are applied greedily: if there are multiple unapplied parsers/// that could parse the next slice of input, the first one is used./// # use nom::{Err, error::{Error, ErrorKind}, IResult};/// use nom::character::complete::{anychar, char};/// fn parser(input: &str) -> IResult<&str, (char, char)> {///   permutation((anychar, char('a')))(input)/// // anychar parses 'b', then char('a') parses 'a'/// assert_eq!(parser("ba"), Ok(("", ('b', 'a'))));/// // anychar parses 'a', then char('a') fails on 'b',/// // even though char('a') followed by anychar would succeed/// assert_eq!(parser("ab"), Err(Err::Error(Error::new("b", ErrorKind::Char))));alt_traitalt_trait_implalt_trait_inner// Manually implement Alt for (A,), the 1-tuple typepermutation_traitpermutation_trait_implpermutation_trait_innerFnAFnBFnCFnDFnEFnFFnGFnHFnIFnJFnKFnLFnMFnNFnOFnPFnQFnRFnSFnTFnU//! Choice combinatorsErrorStralt_testalt_incompletepermutation_testCompareResultFindSubstringFindTokenInputTakeInputTakeAtPosition/// Recognizes a pattern/// The input data will be compared to the tag combinator's argument and will return the part of/// the input that matches the argument/// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};/// use nom::bytes::complete::tag;/// fn parser(s: &str) -> IResult<&str, &str> {///   tag("Hello")(s)/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));tag_no_case/// Recognizes a case insensitive pattern./// the input that matches the argument with no regard to case./// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern./// use nom::bytes::complete::tag_no_case;///   tag_no_case("hello")(s)/// assert_eq!(parser("hello, World!"), Ok((", World!", "hello")));/// assert_eq!(parser("HeLlO, World!"), Ok((", World!", "HeLlO")));/// Parse till certain characters are met./// The parser will return the longest slice till one of the characters of the combinator's argument are met./// It doesn't consume the matched character./// It will return a `Err::Error(("", ErrorKind::IsNot))` if the pattern wasn't met./// use nom::bytes::complete::is_not;/// fn not_space(s: &str) -> IResult<&str, &str> {///   is_not(" \t\r\n")(s)/// assert_eq!(not_space("Hello, World!"), Ok((" World!", "Hello,")));/// assert_eq!(not_space("Sometimes\t"), Ok(("\t", "Sometimes")));/// assert_eq!(not_space("Nospace"), Ok(("", "Nospace")));/// assert_eq!(not_space(""), Err(Err::Error(Error::new("", ErrorKind::IsNot))));/// Returns the longest slice of the matches the pattern./// The parser will return the longest slice consisting of the characters in provided in the/// combinator's argument./// It will return a `Err(Err::Error((_, ErrorKind::IsA)))` if the pattern wasn't met./// use nom::bytes::complete::is_a;/// fn hex(s: &str) -> IResult<&str, &str> {///   is_a("1234567890ABCDEF")(s)/// assert_eq!(hex("123 and voila"), Ok((" and voila", "123")));/// assert_eq!(hex("DEADBEEF and others"), Ok((" and others", "DEADBEEF")));/// assert_eq!(hex("BADBABEsomething"), Ok(("something", "BADBABE")));/// assert_eq!(hex("D15EA5E"), Ok(("", "D15EA5E")));/// assert_eq!(hex(""), Err(Err::Error(Error::new("", ErrorKind::IsA))));/// Returns the longest input slice (if any) that matches the predicate./// The parser will return the longest slice that matches the given predicate *(a function that/// takes the input and returns a bool)*./// # use nom::{Err, error::ErrorKind, Needed, IResult};/// use nom::bytes::complete::take_while;/// use nom::character::is_alphabetic;/// fn alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {///   take_while(is_alphabetic)(s)/// assert_eq!(alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));/// assert_eq!(alpha(b"12345"), Ok((&b"12345"[..], &b""[..])));/// assert_eq!(alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));/// assert_eq!(alpha(b""), Ok((&b""[..], &b""[..])));take_while1/// Returns the longest (at least 1) input slice that matches the predicate./// It will return an `Err(Err::Error((_, ErrorKind::TakeWhile1)))` if the pattern wasn't met./// use nom::bytes::complete::take_while1;///   take_while1(is_alphabetic)(s)/// assert_eq!(alpha(b"12345"), Err(Err::Error(Error::new(&b"12345"[..], ErrorKind::TakeWhile1))));take_while_m_n/// Returns the longest (m <= len <= n) input slice  that matches the predicate./// It will return an `Err::Error((_, ErrorKind::TakeWhileMN))` if the pattern wasn't met or is out/// of range (m <= len <= n)./// use nom::bytes::complete::take_while_m_n;/// fn short_alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {///   take_while_m_n(3, 6, is_alphabetic)(s)/// assert_eq!(short_alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));/// assert_eq!(short_alpha(b"lengthy"), Ok((&b"y"[..], &b"length"[..])));/// assert_eq!(short_alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));/// assert_eq!(short_alpha(b"ed"), Err(Err::Error(Error::new(&b"ed"[..], ErrorKind::TakeWhileMN))));/// assert_eq!(short_alpha(b"12345"), Err(Err::Error(Error::new(&b"12345"[..], ErrorKind::TakeWhileMN))));take_till/// Returns the longest input slice (if any) till a predicate is met./// The parser will return the longest slice till the given predicate *(a function that/// use nom::bytes::complete::take_till;/// fn till_colon(s: &str) -> IResult<&str, &str> {///   take_till(|c| c == ':')(s)/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));/// assert_eq!(till_colon(":empty matched"), Ok((":empty matched", ""))); //allowed/// assert_eq!(till_colon("12345"), Ok(("", "12345")));/// assert_eq!(till_colon(""), Ok(("", "")));take_till1/// Returns the longest (at least 1) input slice till a predicate is met./// It will return `Err(Err::Error((_, ErrorKind::TakeTill1)))` if the input is empty or the/// predicate matches the first input./// use nom::bytes::complete::take_till1;///   take_till1(|c| c == ':')(s)/// assert_eq!(till_colon(":empty matched"), Err(Err::Error(Error::new(":empty matched", ErrorKind::TakeTill1))));/// assert_eq!(till_colon(""), Err(Err::Error(Error::new("", ErrorKind::TakeTill1))));/// Returns an input slice containing the first N input elements (Input[..N])./// It will return `Err(Err::Error((_, ErrorKind::Eof)))` if the input is shorter than the argument./// use nom::bytes::complete::take;/// fn take6(s: &str) -> IResult<&str, &str> {///   take(6usize)(s)/// assert_eq!(take6("1234567"), Ok(("7", "123456")));/// assert_eq!(take6("things"), Ok(("", "things")));/// assert_eq!(take6("short"), Err(Err::Error(Error::new("short", ErrorKind::Eof))));/// assert_eq!(take6(""), Err(Err::Error(Error::new("", ErrorKind::Eof))));/// The units that are taken will depend on the input type. For example, for a/// `&str` it will take a number of `char`'s, whereas for a `&[u8]` it will/// take that many `u8`'s:/// assert_eq!(take::<_, _, Error<_>>(1usize)("💙"), Ok(("", "💙")));/// assert_eq!(take::<_, _, Error<_>>(1usize)("💙".as_bytes()), Ok((b"\x9F\x92\x99".as_ref(), b"\xF0".as_ref())));/// Returns the input slice up to the first occurrence of the pattern./// It doesn't consume the pattern. It will return `Err(Err::Error((_, ErrorKind::TakeUntil)))`/// if the pattern wasn't met./// use nom::bytes::complete::take_until;/// fn until_eof(s: &str) -> IResult<&str, &str> {///   take_until("eof")(s)/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));/// assert_eq!(until_eof("hello, world"), Err(Err::Error(Error::new("hello, world", ErrorKind::TakeUntil))));/// assert_eq!(until_eof(""), Err(Err::Error(Error::new("", ErrorKind::TakeUntil))));/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));take_until1/// Returns the non empty input slice up to the first occurrence of the pattern./// use nom::bytes::complete::take_until1;///   take_until1("eof")(s)/// assert_eq!(until_eof("eof"), Err(Err::Error(Error::new("eof", ErrorKind::TakeUntil))));escapedAsChar/// Matches a byte string with escaped characters./// * The first argument matches the normal characters (it must not accept the control character)/// * The second argument is the control character (like `\` in most languages)/// * The third argument matches the escaped characters/// # use nom::character::complete::digit1;/// use nom::bytes::complete::escaped;/// use nom::character::complete::one_of;/// fn esc(s: &str) -> IResult<&str, &str> {///   escaped(digit1, '\\', one_of(r#""n\"#))(s)/// assert_eq!(esc("123;"), Ok((";", "123")));/// assert_eq!(esc(r#"12\"34;"#), Ok((";", r#"12\"34"#)));ExtendItemescaped_transformExtenderExtendInto/// * The first argument matches the normal characters (it must not match the control character)/// * The third argument matches the escaped characters and transforms them/// As an example, the chain `abc\tdef` could be `abc    def` (it also consumes the control character)/// # use std::str::from_utf8;/// use nom::bytes::complete::{escaped_transform, tag};/// use nom::character::complete::alpha1;/// use nom::combinator::value;/// fn parser(input: &str) -> IResult<&str, String> {///   escaped_transform(///     alpha1,///     '\\',///     alt((///       value("\\", tag("\\")),///       value("\"", tag("\"")),///       value("\n", tag("n")),///     ))///   )(input)/// assert_eq!(parser("ab\\\"cd"), Ok(("", String::from("ab\"cd"))));/// assert_eq!(parser("ab\\ncd"), Ok(("", String::from("ab\ncd"))));complete_take_while_m_n_utf8_all_matchingcomplete_take_while_m_n_utf8_all_matching_substringescaped_string// issue #1336 "escaped hangs if normal parser accepts empty"escaped_hang// issue ##1118 escaped does not work with empty stringescaped_hang_1118//! Parsers recognizing bytes streams, complete input version//! Parsers recognizing bytes streams/// Recognizes a pattern./// the input that matches the argument./// use nom::bytes::streaming::tag;/// assert_eq!(parser("S"), Err(Err::Error(Error::new("S", ErrorKind::Tag))));/// assert_eq!(parser("H"), Err(Err::Incomplete(Needed::new(4))));/// use nom::bytes::streaming::tag_no_case;/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::new(5))));/// It will return a `Err::Incomplete(Needed::new(1))` if the pattern wasn't met./// use nom::bytes::streaming::is_not;/// assert_eq!(not_space("Nospace"), Err(Err::Incomplete(Needed::new(1))));/// assert_eq!(not_space(""), Err(Err::Incomplete(Needed::new(1))));/// # Streaming specific/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the pattern wasn't met/// or if the pattern reaches the end of the input./// use nom::bytes::streaming::is_a;/// assert_eq!(hex("D15EA5E"), Err(Err::Incomplete(Needed::new(1))));/// assert_eq!(hex(""), Err(Err::Incomplete(Needed::new(1))));/// # Streaming Specific/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the pattern reaches the end of the input./// use nom::bytes::streaming::take_while;/// assert_eq!(alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));/// assert_eq!(alpha(b""), Err(Err::Incomplete(Needed::new(1))));/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` or if the pattern reaches the end of the input./// use nom::bytes::streaming::take_while1;/// It will return an `Err::Error((_, ErrorKind::TakeWhileMN))` if the pattern wasn't met./// *Streaming version* will return a `Err::Incomplete(Needed::new(1))`  if the pattern reaches the end of the input or is too short./// use nom::bytes::streaming::take_while_m_n;/// assert_eq!(short_alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));/// assert_eq!(short_alpha(b"ed"), Err(Err::Incomplete(Needed::new(1))));/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the match reaches the/// end of input or if there was not match./// use nom::bytes::streaming::take_till;/// assert_eq!(till_colon("12345"), Err(Err::Incomplete(Needed::new(1))));/// assert_eq!(till_colon(""), Err(Err::Incomplete(Needed::new(1))));/// use nom::bytes::streaming::take_till1;/// *Streaming version* if the input has less than N elements, `take` will/// return a `Err::Incomplete(Needed::new(M))` where M is the number of/// additional bytes the parser would need to succeed./// It is well defined for `&[u8]` as the number of elements is the byte size,/// but for types like `&str`, we cannot know how many bytes correspond for/// the next few chars, so the result will be `Err::Incomplete(Needed::Unknown)`/// use nom::bytes::streaming::take;/// assert_eq!(take6("short"), Err(Err::Incomplete(Needed::Unknown)));/// It doesn't consume the pattern./// *Streaming version* will return a `Err::Incomplete(Needed::new(N))` if the input doesn't/// contain the pattern or if the input is smaller than the pattern./// use nom::bytes::streaming::take_until;/// assert_eq!(until_eof("hello, world"), Err(Err::Incomplete(Needed::Unknown)));/// assert_eq!(until_eof("hello, worldeo"), Err(Err::Incomplete(Needed::Unknown)));/// use nom::bytes::streaming::take_until1;/// assert_eq!(until_eof("eof"),  Err(Err::Error(Error::new("eof", ErrorKind::TakeUntil))));/// use nom::bytes::streaming::escaped;/// use nom::character::streaming::one_of;///   escaped(digit1, '\\', one_of("\"n\\"))(s)/// assert_eq!(esc("12\\\"34;"), Ok((";", "12\\\"34")));/// use nom::bytes::streaming::{escaped_transform, tag};/// use nom::character::streaming::alpha1;/// assert_eq!(parser("ab\\\"cd\""), Ok(("\"", String::from("ab\"cd"))));//! Parsers recognizing bytes streams, streaming versionalpha1alphanumeric1digit1hex_digit1hex_digitmultispace1multispaceoct_digit1oct_digitspace1escapingescaping_strto_sescape_transformescape_transform_strtake_until_incompletetake_until_incomplete_stake_while_utf8take_till_utf8take_utf8take_while_m_n_utf8take_while_m_n_utf8_full_matchrecognize_take_whilelength_bytestag_fixed_size_array/// Recognizes one character./// *Complete version*: Will return an error if there's not enough input data./// # use nom::{Err, error::{ErrorKind, Error}, IResult};/// # use nom::character::complete::char;/// fn parser(i: &str) -> IResult<&str, char> {///     char('a')(i)/// assert_eq!(parser("abc"), Ok(("bc", 'a')));/// assert_eq!(parser(" abc"), Err(Err::Error(Error::new(" abc", ErrorKind::Char))));/// assert_eq!(parser("bc"), Err(Err::Error(Error::new("bc", ErrorKind::Char))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Char))));satisfy/// Recognizes one character and checks that it satisfies a predicate/// # use nom::{Err, error::{ErrorKind, Error}, Needed, IResult};/// # use nom::character::complete::satisfy;///     satisfy(|c| c == 'a' || c == 'b')(i)/// assert_eq!(parser("cd"), Err(Err::Error(Error::new("cd", ErrorKind::Satisfy))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Satisfy))));/// Recognizes one of the provided characters./// # use nom::{Err, error::ErrorKind};/// # use nom::character::complete::one_of;/// assert_eq!(one_of::<_, _, (&str, ErrorKind)>("abc")("b"), Ok(("", 'b')));/// assert_eq!(one_of::<_, _, (&str, ErrorKind)>("a")("bc"), Err(Err::Error(("bc", ErrorKind::OneOf))));/// assert_eq!(one_of::<_, _, (&str, ErrorKind)>("a")(""), Err(Err::Error(("", ErrorKind::OneOf))));none_of/// Recognizes a character that is not in the provided characters./// # use nom::character::complete::none_of;/// assert_eq!(none_of::<_, _, (&str, ErrorKind)>("abc")("z"), Ok(("", 'z')));/// assert_eq!(none_of::<_, _, (&str, ErrorKind)>("ab")("a"), Err(Err::Error(("a", ErrorKind::NoneOf))));/// assert_eq!(none_of::<_, _, (&str, ErrorKind)>("a")(""), Err(Err::Error(("", ErrorKind::NoneOf))));crlf/// Recognizes the string "\r\n"./// # use nom::character::complete::crlf;///     crlf(input)/// assert_eq!(parser("\r\nc"), Ok(("c", "\r\n")));/// assert_eq!(parser("ab\r\nc"), Err(Err::Error(Error::new("ab\r\nc", ErrorKind::CrLf))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::CrLf))));not_line_ending//FIXME: there's still an incomplete/// Recognizes a string of any char except '\r\n' or '\n'./// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};/// # use nom::character::complete::not_line_ending;///     not_line_ending(input)/// assert_eq!(parser("ab\r\nc"), Ok(("\r\nc", "ab")));/// assert_eq!(parser("ab\nc"), Ok(("\nc", "ab")));/// assert_eq!(parser(""), Ok(("", "")));/// assert_eq!(parser("a\rb\nc"), Err(Err::Error(Error { input: "a\rb\nc", code: ErrorKind::Tag })));/// assert_eq!(parser("a\rbc"), Err(Err::Error(Error { input: "a\rbc", code: ErrorKind::Tag })));/// Recognizes an end of line (both '\n' and '\r\n')./// # use nom::character::complete::line_ending;///     line_ending(input)/// Matches a newline character '\n'./// # use nom::character::complete::newline;/// fn parser(input: &str) -> IResult<&str, char> {///     newline(input)/// assert_eq!(parser("\nc"), Ok(("c", '\n')));/// assert_eq!(parser("\r\nc"), Err(Err::Error(Error::new("\r\nc", ErrorKind::Char))));tab/// Matches a tab character '\t'./// # use nom::character::complete::tab;///     tab(input)/// assert_eq!(parser("\tc"), Ok(("c", '\t')));anychar/// Matches one byte as a character. Note that the input type will/// accept a `str`, but not a `&[u8]`, unlike many other nom parsers./// # use nom::{character::complete::anychar, Err, error::{Error, ErrorKind}, IResult};///     anychar(input)/// assert_eq!(parser("abc"), Ok(("bc",'a')));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Eof))));alpha0/// Recognizes zero or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z/// *Complete version*: Will return the whole input if no terminating token is found (a non/// alphabetic character)./// # use nom::{Err, error::ErrorKind, IResult, Needed};/// # use nom::character::complete::alpha0;///     alpha0(input)/// assert_eq!(parser("ab1c"), Ok(("1c", "ab")));/// assert_eq!(parser("1c"), Ok(("1c", "")));/// Recognizes one or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z/// *Complete version*: Will return an error if there's not enough input data,/// or the whole input if no terminating token is found  (a non alphabetic character)./// # use nom::character::complete::alpha1;///     alpha1(input)/// assert_eq!(parser("aB1c"), Ok(("1c", "aB")));/// assert_eq!(parser("1c"), Err(Err::Error(Error::new("1c", ErrorKind::Alpha))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Alpha))));digit0/// Recognizes zero or more ASCII numerical characters: 0-9/// or the whole input if no terminating token is found (a non digit character)./// # use nom::character::complete::digit0;///     digit0(input)/// assert_eq!(parser("21c"), Ok(("c", "21")));/// assert_eq!(parser("21"), Ok(("", "21")));/// assert_eq!(parser("a21c"), Ok(("a21c", "")));/// Recognizes one or more ASCII numerical characters: 0-9///     digit1(input)/// assert_eq!(parser("c1"), Err(Err::Error(Error::new("c1", ErrorKind::Digit))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Digit))));/// ## Parsing an integer/// You can use `digit1` in combination with [`map_res`] to parse an integer:/// # use nom::combinator::map_res;/// fn parser(input: &str) -> IResult<&str, u32> {///   map_res(digit1, str::parse)(input)/// assert_eq!(parser("416"), Ok(("", 416)));/// assert_eq!(parser("12b"), Ok(("b", 12)));/// assert!(parser("b").is_err());/// [`map_res`]: crate::combinator::map_reshex_digit0/// Recognizes zero or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f/// *Complete version*: Will return the whole input if no terminating token is found (a non hexadecimal digit character)./// # use nom::character::complete::hex_digit0;///     hex_digit0(input)/// assert_eq!(parser("21cZ"), Ok(("Z", "21c")));/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));/// Recognizes one or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f/// or the whole input if no terminating token is found (a non hexadecimal digit character)./// # use nom::character::complete::hex_digit1;///     hex_digit1(input)/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::HexDigit))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::HexDigit))));oct_digit0/// Recognizes zero or more octal characters: 0-7/// *Complete version*: Will return the whole input if no terminating token is found (a non octal/// digit character)./// # use nom::character::complete::oct_digit0;///     oct_digit0(input)/// assert_eq!(parser("21cZ"), Ok(("cZ", "21")));/// Recognizes one or more octal characters: 0-7/// or the whole input if no terminating token is found (a non octal digit character)./// # use nom::character::complete::oct_digit1;///     oct_digit1(input)/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::OctDigit))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::OctDigit))));alphanumeric0/// Recognizes zero or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z/// alphanumerical character)./// # use nom::character::complete::alphanumeric0;///     alphanumeric0(input)/// assert_eq!(parser("21cZ%1"), Ok(("%1", "21cZ")));/// assert_eq!(parser("&Z21c"), Ok(("&Z21c", "")));/// Recognizes one or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z/// or the whole input if no terminating token is found (a non alphanumerical character)./// # use nom::character::complete::alphanumeric1;///     alphanumeric1(input)/// assert_eq!(parser("&H2"), Err(Err::Error(Error::new("&H2", ErrorKind::AlphaNumeric))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::AlphaNumeric))));space0/// Recognizes zero or more spaces and tabs./// *Complete version*: Will return the whole input if no terminating token is found (a non space/// character)./// # use nom::character::complete::space0;///     space0(input)/// assert_eq!(parser(" \t21c"), Ok(("21c", " \t")));/// Recognizes one or more spaces and tabs./// or the whole input if no terminating token is found (a non space character)./// # use nom::character::complete::space1;///     space1(input)/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::Space))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Space))));multispace0/// Recognizes zero or more spaces, tabs, carriage returns and line feeds./// *Complete version*: will return the whole input if no terminating token is found (a non space/// # use nom::character::complete::multispace0;///     multispace0(input)/// assert_eq!(parser(" \t\n\r21c"), Ok(("21c", " \t\n\r")));/// Recognizes one or more spaces, tabs, carriage returns and line feeds./// *Complete version*: will return an error if there's not enough input data,/// # use nom::character::complete::multispace1;///     multispace1(input)/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::MultiSpace))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::MultiSpace))));intsr" will parse a number in text form to a number"r" *Complete version*: can parse until the end of input."uintsParseToassert_parsecharacter_sis_not_line_ending_bytesis_not_line_ending_strhex_digit_testoct_digit_testfull_line_windowsfull_line_unixcheck_windows_lineendingcheck_unix_lineendingcr_lfend_of_linedigit_to_i16digit_to_u32//! Character specific parsers and combinators, complete input version.//! Functions recognizing specific characters./// Tests if byte is ASCII alphabetic: A-Z, a-z/// # use nom::character::is_alphabetic;/// assert_eq!(is_alphabetic(b'9'), false);/// assert_eq!(is_alphabetic(b'a'), true);is_digit/// Tests if byte is ASCII digit: 0-9/// # use nom::character::is_digit;/// assert_eq!(is_digit(b'a'), false);/// assert_eq!(is_digit(b'9'), true);is_hex_digit/// Tests if byte is ASCII hex digit: 0-9, A-F, a-f/// # use nom::character::is_hex_digit;/// assert_eq!(is_hex_digit(b'a'), true);/// assert_eq!(is_hex_digit(b'9'), true);/// assert_eq!(is_hex_digit(b'A'), true);/// assert_eq!(is_hex_digit(b'x'), false);is_oct_digit/// Tests if byte is ASCII octal digit: 0-7/// # use nom::character::is_oct_digit;/// assert_eq!(is_oct_digit(b'a'), false);/// assert_eq!(is_oct_digit(b'9'), false);/// assert_eq!(is_oct_digit(b'6'), true);is_alphanumeric/// Tests if byte is ASCII alphanumeric: A-Z, a-z, 0-9/// # use nom::character::is_alphanumeric;/// assert_eq!(is_alphanumeric(b'-'), false);/// assert_eq!(is_alphanumeric(b'a'), true);/// assert_eq!(is_alphanumeric(b'9'), true);/// assert_eq!(is_alphanumeric(b'A'), true);is_space/// Tests if byte is ASCII space or tab/// # use nom::character::is_space;/// assert_eq!(is_space(b'\n'), false);/// assert_eq!(is_space(b'\r'), false);/// assert_eq!(is_space(b' '), true);/// assert_eq!(is_space(b'\t'), true);is_newline/// Tests if byte is ASCII newline: \n/// # use nom::character::is_newline;/// assert_eq!(is_newline(b'\n'), true);/// assert_eq!(is_newline(b'\r'), false);/// assert_eq!(is_newline(b' '), false);/// assert_eq!(is_newline(b'\t'), false);//! Character specific parsers and combinators//! Functions recognizing specific characters/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data./// # use nom::character::streaming::char;/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::satisfy;/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::Unknown)));/// # use nom::{Err, error::ErrorKind, Needed};/// # use nom::character::streaming::one_of;/// assert_eq!(one_of::<_, _, (_, ErrorKind)>("abc")("b"), Ok(("", 'b')));/// assert_eq!(one_of::<_, _, (_, ErrorKind)>("a")("bc"), Err(Err::Error(("bc", ErrorKind::OneOf))));/// assert_eq!(one_of::<_, _, (_, ErrorKind)>("a")(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::none_of;/// assert_eq!(none_of::<_, _, (_, ErrorKind)>("abc")("z"), Ok(("", 'z')));/// assert_eq!(none_of::<_, _, (_, ErrorKind)>("ab")("a"), Err(Err::Error(("a", ErrorKind::NoneOf))));/// assert_eq!(none_of::<_, _, (_, ErrorKind)>("a")(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::crlf;/// assert_eq!(crlf::<_, (_, ErrorKind)>("\r\nc"), Ok(("c", "\r\n")));/// assert_eq!(crlf::<_, (_, ErrorKind)>("ab\r\nc"), Err(Err::Error(("ab\r\nc", ErrorKind::CrLf))));/// assert_eq!(crlf::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(2))));/// # use nom::character::streaming::not_line_ending;/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("ab\r\nc"), Ok(("\r\nc", "ab")));/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("abc"), Err(Err::Incomplete(Needed::Unknown)));/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::Unknown)));/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("a\rb\nc"), Err(Err::Error(("a\rb\nc", ErrorKind::Tag ))));/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("a\rbc"), Err(Err::Error(("a\rbc", ErrorKind::Tag ))));/// # use nom::character::streaming::line_ending;/// assert_eq!(line_ending::<_, (_, ErrorKind)>("\r\nc"), Ok(("c", "\r\n")));/// assert_eq!(line_ending::<_, (_, ErrorKind)>("ab\r\nc"), Err(Err::Error(("ab\r\nc", ErrorKind::CrLf))));/// assert_eq!(line_ending::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// Matches a newline character '\\n'./// # use nom::character::streaming::newline;/// assert_eq!(newline::<_, (_, ErrorKind)>("\nc"), Ok(("c", '\n')));/// assert_eq!(newline::<_, (_, ErrorKind)>("\r\nc"), Err(Err::Error(("\r\nc", ErrorKind::Char))));/// assert_eq!(newline::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::tab;/// assert_eq!(tab::<_, (_, ErrorKind)>("\tc"), Ok(("c", '\t')));/// assert_eq!(tab::<_, (_, ErrorKind)>("\r\nc"), Err(Err::Error(("\r\nc", ErrorKind::Char))));/// assert_eq!(tab::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::{character::streaming::anychar, Err, error::ErrorKind, IResult, Needed};/// assert_eq!(anychar::<_, (_, ErrorKind)>("abc"), Ok(("bc",'a')));/// assert_eq!(anychar::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,/// or if no terminating token is found (a non alphabetic character)./// # use nom::character::streaming::alpha0;/// assert_eq!(alpha0::<_, (_, ErrorKind)>("ab1c"), Ok(("1c", "ab")));/// assert_eq!(alpha0::<_, (_, ErrorKind)>("1c"), Ok(("1c", "")));/// assert_eq!(alpha0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::alpha1;/// assert_eq!(alpha1::<_, (_, ErrorKind)>("aB1c"), Ok(("1c", "aB")));/// assert_eq!(alpha1::<_, (_, ErrorKind)>("1c"), Err(Err::Error(("1c", ErrorKind::Alpha))));/// assert_eq!(alpha1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// or if no terminating token is found (a non digit character)./// # use nom::character::streaming::digit0;/// assert_eq!(digit0::<_, (_, ErrorKind)>("21c"), Ok(("c", "21")));/// assert_eq!(digit0::<_, (_, ErrorKind)>("a21c"), Ok(("a21c", "")));/// assert_eq!(digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::digit1;/// assert_eq!(digit1::<_, (_, ErrorKind)>("21c"), Ok(("c", "21")));/// assert_eq!(digit1::<_, (_, ErrorKind)>("c1"), Err(Err::Error(("c1", ErrorKind::Digit))));/// assert_eq!(digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// or if no terminating token is found (a non hexadecimal digit character)./// # use nom::character::streaming::hex_digit0;/// assert_eq!(hex_digit0::<_, (_, ErrorKind)>("21cZ"), Ok(("Z", "21c")));/// assert_eq!(hex_digit0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));/// assert_eq!(hex_digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::hex_digit1;/// assert_eq!(hex_digit1::<_, (_, ErrorKind)>("21cZ"), Ok(("Z", "21c")));/// assert_eq!(hex_digit1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::HexDigit))));/// assert_eq!(hex_digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// or if no terminating token is found (a non octal digit character)./// # use nom::character::streaming::oct_digit0;/// assert_eq!(oct_digit0::<_, (_, ErrorKind)>("21cZ"), Ok(("cZ", "21")));/// assert_eq!(oct_digit0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));/// assert_eq!(oct_digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::oct_digit1;/// assert_eq!(oct_digit1::<_, (_, ErrorKind)>("21cZ"), Ok(("cZ", "21")));/// assert_eq!(oct_digit1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::OctDigit))));/// assert_eq!(oct_digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// or if no terminating token is found (a non alphanumerical character)./// # use nom::character::streaming::alphanumeric0;/// assert_eq!(alphanumeric0::<_, (_, ErrorKind)>("21cZ%1"), Ok(("%1", "21cZ")));/// assert_eq!(alphanumeric0::<_, (_, ErrorKind)>("&Z21c"), Ok(("&Z21c", "")));/// assert_eq!(alphanumeric0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::alphanumeric1;/// assert_eq!(alphanumeric1::<_, (_, ErrorKind)>("21cZ%1"), Ok(("%1", "21cZ")));/// assert_eq!(alphanumeric1::<_, (_, ErrorKind)>("&H2"), Err(Err::Error(("&H2", ErrorKind::AlphaNumeric))));/// assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// or if no terminating token is found (a non space character)./// # use nom::character::streaming::space0;/// assert_eq!(space0::<_, (_, ErrorKind)>(" \t21c"), Ok(("21c", " \t")));/// assert_eq!(space0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));/// assert_eq!(space0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::space1;/// assert_eq!(space1::<_, (_, ErrorKind)>(" \t21c"), Ok(("21c", " \t")));/// assert_eq!(space1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::Space))));/// assert_eq!(space1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::multispace0;/// assert_eq!(multispace0::<_, (_, ErrorKind)>(" \t\n\r21c"), Ok(("21c", " \t\n\r")));/// assert_eq!(multispace0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));/// assert_eq!(multispace0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));/// # use nom::character::streaming::multispace1;/// assert_eq!(multispace1::<_, (_, ErrorKind)>(" \t\n\r21c"), Ok(("21c", " \t\n\r")));/// assert_eq!(multispace1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::MultiSpace))));/// assert_eq!(multispace1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));anychar_str//! Character specific parsers and combinators, streaming versionone_of_testnone_of_testchar_byteslicechar_str/// Return the remaining input./// # use nom::error::ErrorKind;/// assert_eq!(rest::<_,(_, ErrorKind)>("abc"), Ok(("", "abc")));/// assert_eq!(rest::<_,(_, ErrorKind)>(""), Ok(("", "")));rest_len/// Return the length of the remaining input./// use nom::combinator::rest_len;/// assert_eq!(rest_len::<_,(_, ErrorKind)>("abc"), Ok(("abc", 3)));/// assert_eq!(rest_len::<_,(_, ErrorKind)>(""), Ok(("", 0)));/// Maps a function on the result of a parser./// use nom::{Err,error::ErrorKind, IResult,Parser};/// use nom::character::complete::digit1;/// let mut parser = map(digit1, |s: &str| s.len());/// // the parser will count how many characters were returned by digit1/// assert_eq!(parser.parse("123456"), Ok(("", 6)));/// // this will fail if digit1 fails/// assert_eq!(parser.parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit))));map_res/// Applies a function returning a `Result` over the result of a parser./// # use nom::{Err,error::ErrorKind, IResult};/// let mut parse = map_res(digit1, |s: &str| s.parse::<u8>());/// // the parser will convert the result of digit1 to a number/// assert_eq!(parse("123"), Ok(("", 123)));/// assert_eq!(parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit))));/// // this will fail if the mapped function fails (a `u8` is too small to hold `123456`)/// assert_eq!(parse("123456"), Err(Err::Error(("123456", ErrorKind::MapRes))));/// Applies a function returning an `Option` over the result of a parser./// use nom::combinator::map_opt;/// let mut parse = map_opt(digit1, |s: &str| s.parse::<u8>().ok());/// assert_eq!(parse("123456"), Err(Err::Error(("123456", ErrorKind::MapOpt))));map_parser/// Applies a parser over the result of another one./// use nom::combinator::map_parser;/// let mut parse = map_parser(take(5u8), digit1);/// assert_eq!(parse("12345"), Ok(("", "12345")));/// assert_eq!(parse("123ab"), Ok(("", "123")));/// assert_eq!(parse("123"), Err(Err::Error(("123", ErrorKind::Eof))));/// Creates a new parser from the output of the first parser, then apply that parser over the rest of the input./// use nom::number::complete::u8;/// use nom::combinator::flat_map;/// let mut parse = flat_map(u8, take);/// assert_eq!(parse(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..])));/// assert_eq!(parse(&[4, 0, 1, 2][..]), Err(Err::Error((&[0, 1, 2][..], ErrorKind::Eof))));/// Optional parser, will return `None` on [`Err::Error`]./// To chain an error up, see [`cut`]./// use nom::combinator::opt;/// fn parser(i: &str) -> IResult<&str, Option<&str>> {///   opt(alpha1)(i)/// assert_eq!(parser("abcd;"), Ok((";", Some("abcd"))));/// assert_eq!(parser("123;"), Ok(("123;", None)));/// Calls the parser if the condition is met./// use nom::combinator::cond;/// fn parser(b: bool, i: &str) -> IResult<&str, Option<&str>> {///   cond(b, alpha1)(i)/// assert_eq!(parser(true, "abcd;"), Ok((";", Some("abcd"))));/// assert_eq!(parser(false, "abcd;"), Ok(("abcd;", None)));/// assert_eq!(parser(true, "123;"), Err(Err::Error(Error::new("123;", ErrorKind::Alpha))));/// assert_eq!(parser(false, "123;"), Ok(("123;", None)));/// Tries to apply its parser without consuming the input./// use nom::combinator::peek;/// let mut parser = peek(alpha1);/// assert_eq!(parser("abcd;"), Ok(("abcd;", "abcd")));/// assert_eq!(parser("123;"), Err(Err::Error(("123;", ErrorKind::Alpha))));/// returns its input if it is at the end of input data/// When we're at the end of the data, this combinator/// will succeed/// # use std::str;/// # use nom::{Err, error::ErrorKind, IResult};/// # use nom::combinator::eof;/// let parser = eof;/// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Eof))));/// Transforms Incomplete into `Error`./// let mut parser = complete(take(5u8));/// assert_eq!(parser("abcdefg"), Ok(("fg", "abcde")));/// assert_eq!(parser("abcd"), Err(Err::Error(("abcd", ErrorKind::Complete))));/// Succeeds if all the input has been consumed by its child parser./// use nom::combinator::all_consuming;/// let mut parser = all_consuming(alpha1);/// assert_eq!(parser("abcd"), Ok(("", "abcd")));/// assert_eq!(parser("abcd;"),Err(Err::Error((";", ErrorKind::Eof))));/// assert_eq!(parser("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha))));/// Returns the result of the child parser if it satisfies a verification function./// The verification function takes as argument a reference to the output of the/// parser./// use nom::combinator::verify;/// let mut parser = verify(alpha1, |s: &str| s.len() == 4);/// assert_eq!(parser("abcde"), Err(Err::Error(("abcde", ErrorKind::Verify))));/// Returns the provided value if the child parser succeeds./// let mut parser = value(1234, alpha1);/// assert_eq!(parser("abcd"), Ok(("", 1234)));/// assert_eq!(parser("123abcd;"), Err(Err::Error(("123abcd;", ErrorKind::Alpha))));/// Succeeds if the child parser returns an error./// use nom::combinator::not;/// let mut parser = not(alpha1);/// assert_eq!(parser("123"), Ok(("123", ())));/// assert_eq!(parser("abcd"), Err(Err::Error(("abcd", ErrorKind::Not))));/// If the child parser was successful, return the consumed input as produced value./// use nom::combinator::recognize;/// use nom::character::complete::{char, alpha1};/// use nom::sequence::separated_pair;/// let mut parser = recognize(separated_pair(alpha1, char(','), alpha1));/// assert_eq!(parser("abcd,efgh"), Ok(("", "abcd,efgh")));/// assert_eq!(parser("abcd;"),Err(Err::Error((";", ErrorKind::Char))));/// if the child parser was successful, return the consumed input with the output/// as a tuple. Functions similarly to [recognize](fn.recognize.html) except it/// returns the parser output as well./// This can be useful especially in cases where the output is not the same type/// as the input, or the input is a user defined type./// Returned tuple is of the format `(consumed input, produced output)`./// use nom::combinator::{consumed, value, recognize, map};/// fn inner_parser(input: &str) -> IResult<&str, bool> {///     value(true, tag("1234"))(input)/// let mut consumed_parser = consumed(value(true, separated_pair(alpha1, char(','), alpha1)));/// assert_eq!(consumed_parser("abcd,efgh1"), Ok(("1", ("abcd,efgh", true))));/// assert_eq!(consumed_parser("abcd;"),Err(Err::Error((";", ErrorKind::Char))));/// // the first output (representing the consumed input)/// // should be the same as that of the `recognize` parser./// let mut recognize_parser = recognize(inner_parser);/// let mut consumed_parser = map(consumed(inner_parser), |(consumed, output)| consumed);/// assert_eq!(recognize_parser("1234"), consumed_parser("1234"));/// assert_eq!(recognize_parser("abcd"), consumed_parser("abcd"));/// Transforms an [`Err::Error`] (recoverable) to [`Err::Failure`] (unrecoverable)/// This commits the parse result, preventing alternative branch paths like with/// [`nom::branch::alt`][crate::branch::alt]./// Without `cut`:/// # use nom::character::complete::{one_of, digit1};/// # use nom::combinator::rest;/// # use nom::branch::alt;/// # use nom::sequence::preceded;///   alt((///     preceded(one_of("+-"), digit1),///     rest///   ))(input)/// assert_eq!(parser("+10 ab"), Ok((" ab", "10")));/// assert_eq!(parser("ab"), Ok(("", "ab")));/// assert_eq!(parser("+"), Ok(("", "+")));/// With `cut`:/// # use nom::{Err,error::ErrorKind, IResult, error::Error};/// use nom::combinator::cut;///     preceded(one_of("+-"), cut(digit1)),/// assert_eq!(parser("+"), Err(Err::Failure(Error { input: "", code: ErrorKind::Digit })));/// automatically converts the child parser's result to another type/// it will be able to convert the output value and the error value/// as long as the `Into` implementations are available/// use nom::combinator::into;///  fn parser1(i: &str) -> IResult<&str, &str> {///    alpha1(i)///  let mut parser2 = into(parser1);/// // the parser converts the &str output of the child parser into a Vec<u8>/// let bytes: IResult<&str, Vec<u8>> = parser2("abcd");/// assert_eq!(bytes, Ok(("", vec![97, 98, 99, 100])));ParserIterator/// Creates an iterator from input data and a parser./// Call the iterator's [ParserIterator::finish] method to get the remaining input if successful,/// or the error value if we encountered an error./// On [`Err::Error`], iteration will stop. To instead chain an error up, see [`cut`]./// use nom::{combinator::iterator, IResult, bytes::complete::tag, character::complete::alpha1, sequence::terminated};/// let data = "abc|defg|hijkl|mnopqr|123";/// let mut it = iterator(data, terminated(alpha1, tag("|")));/// let parsed = it.map(|v| (v, v.len())).collect::<HashMap<_,_>>();/// let res: IResult<_,_> = it.finish();/// assert_eq!(parsed, [("abc", 3usize), ("defg", 4), ("hijkl", 5), ("mnopqr", 6)].iter().cloned().collect());/// assert_eq!(res, Ok(("123", ())));/// Main structure associated to the [iterator] function./// Returns the remaining input if parsing was successful, or the error if we encountered an error./// a parser which always succeeds with given value without consuming any input./// It can be used for example as the last alternative in `alt` to/// specify the default case./// use nom::combinator::{success, value};/// use nom::character::complete::char;/// let mut parser = success::<_,_,(_,ErrorKind)>(10);/// assert_eq!(parser("xyz"), Ok(("xyz", 10)));/// let mut sign = alt((value(-1, char('-')), value(1, char('+')), success::<_,_,(_,ErrorKind)>(1)));/// assert_eq!(sign("+10"), Ok(("10", 1)));/// assert_eq!(sign("-10"), Ok(("10", -1)));/// assert_eq!(sign("10"), Ok(("10", 1)));/// A parser which always fails./// use nom::combinator::fail;/// let s = "string";/// assert_eq!(fail::<_, &str, _>(s), Err(Err::Error((s, ErrorKind::Fail))));//! General purpose combinatorseof_on_sliceseof_on_strsrest_on_slicesrest_on_strsrest_len_on_slicescustom_errortest_flat_maptest_map_opttest_map_parsertest_all_consumingtest_verify_reftest_verify_alloctest_intoopt_testpeek_testnot_testverify_testfail_test/*#[test]
fn t1() {
  let v1:Vec<u8> = vec![1,2,3];
  let v2:Vec<u8> = vec![4,5,6];
  let d = Ok((&v1[..], &v2[..]));
  let res = d.flat_map(print);
  assert_eq!(res, Ok((&v2[..], ())));
}*//*
#[test]
fn end_of_input() {
    let not_over = &b"Hello, world!"[..];
    let is_over = &b""[..];
    named!(eof_test, eof!());

    let res_not_over = eof_test(not_over);
    assert_eq!(res_not_over, Err(Err::Error(error_position!(not_over, ErrorKind::Eof))));

    let res_over = eof_test(is_over);
    assert_eq!(res_over, Ok((is_over, is_over)));
}
*//// Creates an error from the input position and an [ErrorKind]/// Combines an existing error with a new one created from the input/// position and an [ErrorKind]. This is useful when backtracking/// through a parse tree, accumulating error context on the wayfrom_char/// Creates an error from an input position and an expected character/// Combines two existing errors. This function is used to compare errors/// generated in various branches of `alt`./// This trait must be implemented by the error type of a nom parser./// There are already implementations of it for `(Input, ErrorKind)`/// and `VerboseError<Input>`./// It provides methods to create an error from some combinators,/// and combine existing errors in combinators like `alt`./// Creates a new error from an input position, a static string and an existing error./// This is used mainly in the [context] combinator, to add user friendly information/// to errors when backtracking through a parse tree/// This trait is required by the `context` combinator to add a static string/// to an existing error/// Creates a new error from an input position, an [ErrorKind] indicating the/// wrapping parser, and an external error/// This trait is required by the `map_res` combinator to integrate/// error types from external functions, like [std::str::FromStr]/// position of the error in the input data/// nom error code/// default error type, only contains the error' location and code/// creates a new basic error/// Create a new error from an input position and an external error/// The Display implementation allows the std::error::Error implementation// for backward compatibility, keep those trait implementations// for the previously used error typemake_errorappend_errorVerboseErrorKind/// List of errors accumulated by `VerboseError`, containing the affected/// part of input data, and some contextVerboseError/// This error type accumulates errors and their position when backtracking/// through a parse tree. With some post processing (cf `examples/json.rs`),/// it can be used to display user friendly error messages/// Static string added by the `context` function/// Indicates which character was expected by the `char` functionNom/// Error kind given by various nom parsers/// Error context for `VerboseError`/// Create a new error from an input position, a static string and an existing error.convert_error/// Transforms a `VerboseError` into a trace with input position informationMapResMapOptIsNotSeparatedListSeparatedNonEmptyListMany0Many1ManyTillLengthValueTagClosureDigitHexDigitOctDigitAlphaNumericMultiSpaceLengthValueFnTagBitsOneOfNoneOfRegexpMatchRegexpMatchesRegexpFindRegexpCaptureRegexpCapturesTakeWhile1FixEscapedEscapedTransformNonEmptyManyMNVerifyTakeTill1TakeWhileMNMany0CountMany1CountSatisfy/// Indicates which parser returned an errorerror_to_u32/// Converts an ErrorKind to a number/// Converts an ErrorKind to a text descriptionerror_position/// Creates a parse error from a `nom::ErrorKind`/// and the position in the inputerror_node_position/// Creates a parse error from a `nom::ErrorKind`,/// the position in the input and the next error in/// the parsing treedbg_dmp/// Prints a message and the input if the parser fails./// The message prints the `Error` or `Incomplete`/// and the parser's calling code./// It also displays the input in hexdump format/// use nom::{IResult, error::dbg_dmp, bytes::complete::tag};/// fn f(i: &[u8]) -> IResult<&[u8], &[u8]> {///   dbg_dmp(tag("abcd"), "tag")(i)///   let a = &b"efghijkl"[..];/// // Will print the following message:/// // Error(Position(0, [101, 102, 103, 104, 105, 106, 107, 108])) at l.5 by ' tag ! ( "abcd" ) '/// // 00000000        65 66 67 68 69 6a 6b 6c         efghijkl/// f(a);convert_error_panic//! Error management//! Parsers are generic over their error type, requiring that it implements//! the `error::ParseError<Input>` trait./*
#[cfg(feature = "alloc")]
use lib::std::{vec::Vec, collections::HashMap};

#[cfg(feature = "std")]
use lib::std::hash::Hash;

#[cfg(feature = "std")]
pub fn add_error_pattern<'a, I: Clone + Hash + Eq, O, E: Clone + Hash + Eq>(
  h: &mut HashMap<VerboseError<I>, &'a str>,
  e: VerboseError<I>,
  message: &'a str,
) -> bool {
  h.insert(e, message);
  true
}

pub fn slice_to_offsets(input: &[u8], s: &[u8]) -> (usize, usize) {
  let start = input.as_ptr();
  let off1 = s.as_ptr() as usize - start as usize;
  let off2 = off1 + s.len();
  (off1, off2)
}

#[cfg(feature = "std")]
pub fn prepare_errors<O, E: Clone>(input: &[u8], e: VerboseError<&[u8]>) -> Option<Vec<(ErrorKind, usize, usize)>> {
  let mut v: Vec<(ErrorKind, usize, usize)> = Vec::new();

  for (p, kind) in e.errors.drain(..) {
    let (o1, o2) = slice_to_offsets(input, p);
    v.push((kind, o1, o2));
  }

  v.reverse();
  Some(v)
}

#[cfg(feature = "std")]
pub fn print_error<O, E: Clone>(input: &[u8], res: VerboseError<&[u8]>) {
  if let Some(v) = prepare_errors(input, res) {
    let colors = generate_colors(&v);
    println!("parser codes: {}", print_codes(&colors, &HashMap::new()));
    println!("{}", print_offsets(input, 0, &v));
  } else {
    println!("not an error");
  }
}

#[cfg(feature = "std")]
pub fn generate_colors<E>(v: &[(ErrorKind, usize, usize)]) -> HashMap<u32, u8> {
  let mut h: HashMap<u32, u8> = HashMap::new();
  let mut color = 0;

  for &(ref c, _, _) in v.iter() {
    h.insert(error_to_u32(c), color + 31);
    color = color + 1 % 7;
  }

  h
}

pub fn code_from_offset(v: &[(ErrorKind, usize, usize)], offset: usize) -> Option<u32> {
  let mut acc: Option<(u32, usize, usize)> = None;
  for &(ref ek, s, e) in v.iter() {
    let c = error_to_u32(ek);
    if s <= offset && offset <= e {
      if let Some((_, start, end)) = acc {
        if start <= s && e <= end {
          acc = Some((c, s, e));
        }
      } else {
        acc = Some((c, s, e));
      }
    }
  }
  if let Some((code, _, _)) = acc {
    return Some(code);
  } else {
    return None;
  }
}

#[cfg(feature = "alloc")]
pub fn reset_color(v: &mut Vec<u8>) {
  v.push(0x1B);
  v.push(b'[');
  v.push(0);
  v.push(b'm');
}

#[cfg(feature = "alloc")]
pub fn write_color(v: &mut Vec<u8>, color: u8) {
  v.push(0x1B);
  v.push(b'[');
  v.push(1);
  v.push(b';');
  let s = color.to_string();
  let bytes = s.as_bytes();
  v.extend(bytes.iter().cloned());
  v.push(b'm');
}

#[cfg(feature = "std")]
#[cfg_attr(feature = "cargo-clippy", allow(implicit_hasher))]
pub fn print_codes(colors: &HashMap<u32, u8>, names: &HashMap<u32, &str>) -> String {
  let mut v = Vec::new();
  for (code, &color) in colors {
    if let Some(&s) = names.get(code) {
      let bytes = s.as_bytes();
      write_color(&mut v, color);
      v.extend(bytes.iter().cloned());
    } else {
      let s = code.to_string();
      let bytes = s.as_bytes();
      write_color(&mut v, color);
      v.extend(bytes.iter().cloned());
    }
    reset_color(&mut v);
    v.push(b' ');
  }
  reset_color(&mut v);

  String::from_utf8_lossy(&v[..]).into_owned()
}

#[cfg(feature = "std")]
pub fn print_offsets(input: &[u8], from: usize, offsets: &[(ErrorKind, usize, usize)]) -> String {
  let mut v = Vec::with_capacity(input.len() * 3);
  let mut i = from;
  let chunk_size = 8;
  let mut current_code: Option<u32> = None;
  let mut current_code2: Option<u32> = None;

  let colors = generate_colors(&offsets);

  for chunk in input.chunks(chunk_size) {
    let s = format!("{:08x}", i);
    for &ch in s.as_bytes().iter() {
      v.push(ch);
    }
    v.push(b'\t');

    let mut k = i;
    let mut l = i;
    for &byte in chunk {
      if let Some(code) = code_from_offset(&offsets, k) {
        if let Some(current) = current_code {
          if current != code {
            reset_color(&mut v);
            current_code = Some(code);
            if let Some(&color) = colors.get(&code) {
              write_color(&mut v, color);
            }
          }
        } else {
          current_code = Some(code);
          if let Some(&color) = colors.get(&code) {
            write_color(&mut v, color);
          }
        }
      }
      v.push(CHARS[(byte >> 4) as usize]);
      v.push(CHARS[(byte & 0xf) as usize]);
      v.push(b' ');
      k = k + 1;
    }

    reset_color(&mut v);

    if chunk_size > chunk.len() {
      for _ in 0..(chunk_size - chunk.len()) {
        v.push(b' ');
        v.push(b' ');
        v.push(b' ');
      }
    }
    v.push(b'\t');

    for &byte in chunk {
      if let Some(code) = code_from_offset(&offsets, l) {
        if let Some(current) = current_code2 {
          if current != code {
            reset_color(&mut v);
            current_code2 = Some(code);
            if let Some(&color) = colors.get(&code) {
              write_color(&mut v, color);
            }
          }
        } else {
          current_code2 = Some(code);
          if let Some(&color) = colors.get(&code) {
            write_color(&mut v, color);
          }
        }
      }
      if (byte >= 32 && byte <= 126) || byte >= 128 {
        v.push(byte);
      } else {
        v.push(b'.');
      }
      l = l + 1;
    }
    reset_color(&mut v);

    v.push(b'\n');
    i = i + chunk_size;
  }

  String::from_utf8_lossy(&v[..]).into_owned()
}
*//// It depends on the input type `I`, the output type `O`, and the error type `E`/// (by default `(I, nom::ErrorKind)`)/// The `Ok` side is a pair containing the remainder of the input (the part of the data that/// was not parsed) and the produced value. The `Err` side contains an instance of `nom::Err`./// Outside of the parsing code, you can use the [Finish::finish] method to convert/// it to a more common result type/// converts the parser's result to a type that is more consumable by error/// management libraries. It keeps the same `Ok` branch, and merges `Err::Error`/// and `Err::Failure` into the `Err` side./// *warning*: if the result is `Err(Err::Incomplete(_))`, this method will panic./// - "complete" parsers: It will not be an issue, `Incomplete` is never used/// - "streaming" parsers: `Incomplete` will be returned if there's not enough data/// for the parser to decide, and you should gather more data before parsing again./// Once the parser returns either `Ok(_)`, `Err(Err::Error(_))` or `Err(Err::Failure(_))`,/// you can get out of the parsing loop and call `finish()` on the parser's result/// Helper trait to convert a parser's result to a more manageable type/// Needs more data, but we do not know how much/// Contains the required data size in bytes/// Contains information on needed data if a parser returned `Incomplete`/// Creates `Needed` instance, returns `Needed::Unknown` if the argument is zerois_known/// Indicates if we know how many bytes we need/// Maps a `Needed` to `Needed` by applying a function to a contained `Size` value./// There was not enough data/// The parser had an error (recoverable)/// The parser had an unrecoverable error: we got to the right/// branch and we know other branches won't work, so backtrack/// as fast as possible/// The `Err` enum indicates the parser was not successful/// It has three cases:/// * `Incomplete` indicates that more data is needed to decide. The `Needed` enum/// can contain how many additional bytes are necessary. If you are sure your parser/// is working on full data, you can wrap your parser with the `complete` combinator/// to transform that case in `Error`/// * `Error` means some parser did not succeed, but another one might (as an example,/// when testing different branches of an `alt` combinator)/// * `Failure` indicates an unrecoverable error. As an example, if you recognize a prefix/// to decide on the next parser to apply, and that parser fails, you know there's no need/// to try other parsers, you were already in the right branch, so the data is invalidis_incomplete/// Tests if the result is Incomplete/// Applies the given function to the inner error/// Automatically converts between errors if the underlying type supports itmap_input/// Maps `Err<(T, ErrorKind)>` to `Err<(U, ErrorKind)>` with the given `F: T -> U`/// Maps `Err<error::Error<T>>` to `Err<error::Error<U>>` with the given `F: T -> U`/// Obtaining ownership/// A parser takes in input type, and returns a `Result` containing/// either the remaining input and the output value, or an error/// Maps a function over the result of a parser/// Creates a second parser from the output of the first one, then apply over the rest of the input/// Applies a second parser over the output of the first one/// Applies a second parser after the first one, return their results as a tuple/// Applies a second parser over the input if the first one failed/// automatically converts the parser's output and error values to another type, as long as they/// implement the `From` trait/// All nom parsers implement this trait/// Implementation of `Parser::map`/// Implementation of `Parser::flat_map`/// Implementation of `Parser::and_then`/// Implementation of `Parser::and`/// Implementation of `Parser::or`phantom_out1phantom_err1phantom_out2phantom_err2/// Implementation of `Parser::into`assert_sizesize_testerr_map_test//! Basic types to build the parsers/// internal reproduction of std prelude/// internal std exports for no_std compatibility/// Lib module to re-export everything needed from `std` or `core`/`alloc`. This is how `serde` does/// it, albeit there it is not public.//! # nom, eating data byte by byte//! nom is a parser combinator library with a focus on safe parsing,//! streaming patterns, and as much as possible zero copy.//! use nom::{//!   IResult,//!   bytes::complete::{tag, take_while_m_n},//!   combinator::map_res,//!   sequence::tuple};//! #[derive(Debug,PartialEq)]//! pub struct Color {//!   pub red:     u8,//!   pub green:   u8,//!   pub blue:    u8,//! fn from_hex(input: &str) -> Result<u8, std::num::ParseIntError> {//!   u8::from_str_radix(input, 16)//! fn is_hex_digit(c: char) -> bool {//!   c.is_digit(16)//! fn hex_primary(input: &str) -> IResult<&str, u8> {//!   map_res(//!     take_while_m_n(2, 2, is_hex_digit),//!     from_hex//!   )(input)//! fn hex_color(input: &str) -> IResult<&str, Color> {//!   let (input, _) = tag("#")(input)?;//!   let (input, (red, green, blue)) = tuple((hex_primary, hex_primary, hex_primary))(input)?;//!   Ok((input, Color { red, green, blue }))//!   assert_eq!(hex_color("#2F14DF"), Ok(("", Color {//!     red: 47,//!     green: 20,//!     blue: 223,//!   })));//! The code is available on [Github](https://github.com/Geal/nom)//! There are a few [guides](https://github.com/Geal/nom/tree/main/doc) with more details//! about [how to write parsers](https://github.com/Geal/nom/blob/main/doc/making_a_new_parser_from_scratch.md),//! or the [error management system](https://github.com/Geal/nom/blob/main/doc/error_management.md).//! You can also check out the [recipes] module that contains examples of common patterns.//! **Looking for a specific combinator? Read the//! ["choose a combinator" guide](https://github.com/Geal/nom/blob/main/doc/choosing_a_combinator.md)**//! If you are upgrading to nom 5.0, please read the//! [migration document](https://github.com/Geal/nom/blob/main/doc/upgrading_to_nom_5.md).//! ## Parser combinators//! Parser combinators are an approach to parsers that is very different from//! software like [lex](https://en.wikipedia.org/wiki/Lex_(software)) and//! [yacc](https://en.wikipedia.org/wiki/Yacc). Instead of writing the grammar//! in a separate syntax and generating the corresponding code, you use very small//! functions with very specific purposes, like "take 5 bytes", or "recognize the//! word 'HTTP'", and assemble them in meaningful patterns like "recognize//! 'HTTP', then a space, then a version".//! The resulting code is small, and looks like the grammar you would have//! written with other parser approaches.//! This gives us a few advantages://! - The parsers are small and easy to write//! - The parsers components are easy to reuse (if they're general enough, please add them to nom!)//! - The parsers components are easy to test separately (unit tests and property-based tests)//! - The parser combination code looks close to the grammar you would have written//! - You can build partial parsers, specific to the data you need at the moment, and ignore the rest//! Here is an example of one such parser, to recognize text between parentheses://!   sequence::delimited,//!   // see the "streaming/complete" paragraph lower for an explanation of these submodules//!   character::complete::char,//!   bytes::complete::is_not//! fn parens(input: &str) -> IResult<&str, &str> {//!   delimited(char('('), is_not(")"), char(')'))(input)//! It defines a function named `parens` which will recognize a sequence of the//! character `(`, the longest byte array not containing `)`, then the character//! `)`, and will return the byte array in the middle.//! Here is another parser, written without using nom's combinators this time://! use nom::{IResult, Err, Needed};//! fn take4(i: &[u8]) -> IResult<&[u8], &[u8]>{//!   if i.len() < 4 {//!     Err(Err::Incomplete(Needed::new(4)))//!   } else {//!     Ok((&i[4..], &i[0..4]))//! This function takes a byte array as input, and tries to consume 4 bytes.//! Writing all the parsers manually, like this, is dangerous, despite Rust's//! safety features. There are still a lot of mistakes one can make. That's why//! nom provides a list of functions to help in developing parsers.//! With functions, you would write it like this://! use nom::{IResult, bytes::streaming::take};//! fn take4(input: &str) -> IResult<&str, &str> {//!   take(4u8)(input)//! A parser in nom is a function which, for an input type `I`, an output type `O`//! and an optional error type `E`, will have the following signature://! fn parser(input: I) -> IResult<I, O, E>;//! Or like this, if you don't want to specify a custom error type (it will be `(I, ErrorKind)` by default)://! fn parser(input: I) -> IResult<I, O>;//! `IResult` is an alias for the `Result` type://! use nom::{Needed, error::Error};//! type IResult<I, O, E = Error<I>> = Result<(I, O), Err<E>>;//! enum Err<E> {//!   Incomplete(Needed),//!   Error(E),//!   Failure(E),//! It can have the following values://! - A correct result `Ok((I,O))` with the first element being the remaining of the input (not parsed yet), and the second the output value;//! - An error `Err(Err::Error(c))` with `c` an error that can be built from the input position and a parser specific error//! - An error `Err(Err::Incomplete(Needed))` indicating that more input is necessary. `Needed` can indicate how much data is needed//! - An error `Err(Err::Failure(c))`. It works like the `Error` case, except it indicates an unrecoverable error: We cannot backtrack and test another parser//! Please refer to the ["choose a combinator" guide](https://github.com/Geal/nom/blob/main/doc/choosing_a_combinator.md) for an exhaustive list of parsers.//! See also the rest of the documentation [here](https://github.com/Geal/nom/blob/main/doc).//! ## Making new parsers with function combinators//! nom is based on functions that generate parsers, with a signature like//! this: `(arguments) -> impl Fn(Input) -> IResult<Input, Output, Error>`.//! The arguments of a combinator can be direct values (like `take` which uses//! a number of bytes or character as argument) or even other parsers (like//! `delimited` which takes as argument 3 parsers, and returns the result of//! the second one if all are successful).//! Here are some examples://! use nom::IResult;//! use nom::bytes::complete::{tag, take};//! fn abcd_parser(i: &str) -> IResult<&str, &str> {//!   tag("abcd")(i) // will consume bytes if the input begins with "abcd"//! fn take_10(i: &[u8]) -> IResult<&[u8], &[u8]> {//!   take(10u8)(i) // will consume and return 10 bytes of input//! ## Combining parsers//! There are higher level patterns, like the **`alt`** combinator, which//! provides a choice between multiple parsers. If one branch fails, it tries//! the next, and returns the result of the first parser that succeeds://! use nom::branch::alt;//! use nom::bytes::complete::tag;//! let mut alt_tags = alt((tag("abcd"), tag("efgh")));//! assert_eq!(alt_tags(&b"abcdxxx"[..]), Ok((&b"xxx"[..], &b"abcd"[..])));//! assert_eq!(alt_tags(&b"efghxxx"[..]), Ok((&b"xxx"[..], &b"efgh"[..])));//! assert_eq!(alt_tags(&b"ijklxxx"[..]), Err(nom::Err::Error((&b"ijklxxx"[..], nom::error::ErrorKind::Tag))));//! The **`opt`** combinator makes a parser optional. If the child parser returns//! an error, **`opt`** will still succeed and return None://! use nom::{IResult, combinator::opt, bytes::complete::tag};//! fn abcd_opt(i: &[u8]) -> IResult<&[u8], Option<&[u8]>> {//!   opt(tag("abcd"))(i)//! assert_eq!(abcd_opt(&b"abcdxxx"[..]), Ok((&b"xxx"[..], Some(&b"abcd"[..]))));//! assert_eq!(abcd_opt(&b"efghxxx"[..]), Ok((&b"efghxxx"[..], None)));//! **`many0`** applies a parser 0 or more times, and returns a vector of the aggregated results://! use nom::{IResult, multi::many0, bytes::complete::tag};//! use std::str;//! fn multi(i: &str) -> IResult<&str, Vec<&str>> {//!   many0(tag("abcd"))(i)//! let a = "abcdef";//! let b = "abcdabcdef";//! let c = "azerty";//! assert_eq!(multi(a), Ok(("ef",     vec!["abcd"])));//! assert_eq!(multi(b), Ok(("ef",     vec!["abcd", "abcd"])));//! assert_eq!(multi(c), Ok(("azerty", Vec::new())));//! Here are some basic combinators available://! - **`opt`**: Will make the parser optional (if it returns the `O` type, the new parser returns `Option<O>`)//! - **`many0`**: Will apply the parser 0 or more times (if it returns the `O` type, the new parser returns `Vec<O>`)//! - **`many1`**: Will apply the parser 1 or more times//! There are more complex (and more useful) parsers like `tuple`, which is//! used to apply a series of parsers then assemble their results.//! Example with `tuple`://! use nom::{error::ErrorKind, Needed,//! number::streaming::be_u16,//! bytes::streaming::{tag, take},//! sequence::tuple};//! let mut tpl = tuple((be_u16, take(3u8), tag("fg")));//!   tpl(&b"abcdefgh"[..]),//!   Ok((//!     &b"h"[..],//!     (0x6162u16, &b"cde"[..], &b"fg"[..])//!   ))//! assert_eq!(tpl(&b"abcde"[..]), Err(nom::Err::Incomplete(Needed::new(2))));//! let input = &b"abcdejk"[..];//! assert_eq!(tpl(input), Err(nom::Err::Error((&input[5..], ErrorKind::Tag))));//! But you can also use a sequence of combinators written in imperative style,//! thanks to the `?` operator://! use nom::{IResult, bytes::complete::tag};//! #[derive(Debug, PartialEq)]//! struct A {//!   a: u8,//!   b: u8//! fn ret_int1(i:&[u8]) -> IResult<&[u8], u8> { Ok((i,1)) }//! fn ret_int2(i:&[u8]) -> IResult<&[u8], u8> { Ok((i,2)) }//! fn f(i: &[u8]) -> IResult<&[u8], A> {//!   // if successful, the parser returns `Ok((remaining_input, output_value))` that we can destructure//!   let (i, _) = tag("abcd")(i)?;//!   let (i, a) = ret_int1(i)?;//!   let (i, _) = tag("efgh")(i)?;//!   let (i, b) = ret_int2(i)?;//!   Ok((i, A { a, b }))//! let r = f(b"abcdefghX");//! assert_eq!(r, Ok((&b"X"[..], A{a: 1, b: 2})));//! ## Streaming / Complete//! Some of nom's modules have `streaming` or `complete` submodules. They hold//! different variants of the same combinators.//! A streaming parser assumes that we might not have all of the input data.//! This can happen with some network protocol or large file parsers, where the//! input buffer can be full and need to be resized or refilled.//! A complete parser assumes that we already have all of the input data.//! This will be the common case with small files that can be read entirely to//! memory.//! Here is how it works in practice://! use nom::{IResult, Err, Needed, error::{Error, ErrorKind}, bytes, character};//! fn take_streaming(i: &[u8]) -> IResult<&[u8], &[u8]> {//!   bytes::streaming::take(4u8)(i)//! fn take_complete(i: &[u8]) -> IResult<&[u8], &[u8]> {//!   bytes::complete::take(4u8)(i)//! // both parsers will take 4 bytes as expected//! assert_eq!(take_streaming(&b"abcde"[..]), Ok((&b"e"[..], &b"abcd"[..])));//! assert_eq!(take_complete(&b"abcde"[..]), Ok((&b"e"[..], &b"abcd"[..])));//! // if the input is smaller than 4 bytes, the streaming parser//! // will return `Incomplete` to indicate that we need more data//! assert_eq!(take_streaming(&b"abc"[..]), Err(Err::Incomplete(Needed::new(1))));//! // but the complete parser will return an error//! assert_eq!(take_complete(&b"abc"[..]), Err(Err::Error(Error::new(&b"abc"[..], ErrorKind::Eof))));//! // the alpha0 function recognizes 0 or more alphabetic characters//! fn alpha0_streaming(i: &str) -> IResult<&str, &str> {//!   character::streaming::alpha0(i)//! fn alpha0_complete(i: &str) -> IResult<&str, &str> {//!   character::complete::alpha0(i)//! // if there's a clear limit to the recognized characters, both parsers work the same way//! assert_eq!(alpha0_streaming("abcd;"), Ok((";", "abcd")));//! assert_eq!(alpha0_complete("abcd;"), Ok((";", "abcd")));//! // but when there's no limit, the streaming version returns `Incomplete`, because it cannot//! // know if more input data should be recognized. The whole input could be "abcd;", or//! // "abcde;"//! assert_eq!(alpha0_streaming("abcd"), Err(Err::Incomplete(Needed::new(1))));//! // while the complete version knows that all of the data is there//! assert_eq!(alpha0_complete("abcd"), Ok(("", "abcd")));//! **Going further:** Read the [guides](https://github.com/Geal/nom/tree/main/doc),//! check out the [recipes]!MAX_INITIAL_CAPACITY_BYTES/// Don't pre-allocate more than 64KiB when calling `Vec::with_capacity`./// Pre-allocating memory is a nice optimization but count fields can't/// always be trusted. We should clamp initial capacities to some reasonable/// amount. This reduces the risk of a bogus count value triggering a panic/// due to an OOM error./// This does not affect correctness. Nom will always read the full number/// of elements regardless of the capacity cap./// Repeats the embedded parser, gathering the results in a `Vec`./// This stops on [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see/// [`cut`][crate::combinator::cut]./// * `f` The parser to apply./// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will/// return an error, to prevent going into an infinite loop/// use nom::multi::many0;/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {///   many0(tag("abc"))(s)/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));/// assert_eq!(parser("123123"), Ok(("123123", vec![])));/// assert_eq!(parser(""), Ok(("", vec![])));/// Runs the embedded parser, gathering the results in a `Vec`./// This stops on [`Err::Error`] if there is at least one result,  and returns the results that were accumulated. To instead chain an error up,/// see [`cut`][crate::combinator::cut]./// *Note*: If the parser passed to `many1` accepts empty inputs/// (like `alpha0` or `digit0`), `many1` will return an error,/// to prevent going into an infinite loop.///   many1(tag("abc"))(s)/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));many_till/// Applies the parser `f` until the parser `g` produces a result./// Returns a tuple of the results of `f` in a `Vec` and the result of `g`./// `f` keeps going so long as `g` produces [`Err::Error`]. To instead chain an error up, see [`cut`][crate::combinator::cut]./// use nom::multi::many_till;/// fn parser(s: &str) -> IResult<&str, (Vec<&str>, &str)> {///   many_till(tag("abc"), tag("end"))(s)/// assert_eq!(parser("abcabcend"), Ok(("", (vec!["abc", "abc"], "end"))));/// assert_eq!(parser("abc123end"), Err(Err::Error(Error::new("123end", ErrorKind::Tag))));/// assert_eq!(parser("123123end"), Err(Err::Error(Error::new("123123end", ErrorKind::Tag))));/// assert_eq!(parser("abcendefg"), Ok(("efg", (vec!["abc"], "end"))));/// Alternates between two parsers to produce a list of elements./// This stops when either parser returns [`Err::Error`]  and returns the results that were accumulated. To instead chain an error up, see/// * `sep` Parses the separator between list elements./// * `f` Parses the elements of the list./// use nom::multi::separated_list0;///   separated_list0(tag("|"), tag("abc"))(s)/// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));/// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));/// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));/// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![])));separated_list1/// Alternates between two parsers to produce a list of elements until [`Err::Error`]./// Fails if the element parser does not produce at least one element.$/// use nom::multi::separated_list1;///   separated_list1(tag("|"), tag("abc"))(s)/// assert_eq!(parser("def|abc"), Err(Err::Error(Error::new("def|abc", ErrorKind::Tag))));/// Repeats the embedded parser `m..=n` times/// This stops before `n` when the parser returns [`Err::Error`]  and returns the results that were accumulated. To instead chain an error up, see/// * `m` The minimum number of iterations./// * `n` The maximum number of iterations./// use nom::multi::many_m_n;///   many_m_n(0, 2, tag("abc"))(s)/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));many0_count/// Repeats the embedded parser, counting the results/// This stops on [`Err::Error`]. To instead chain an error up, see/// use nom::multi::many0_count;/// fn parser(s: &str) -> IResult<&str, usize> {///   many0_count(tag("abc"))(s)/// assert_eq!(parser("abcabc"), Ok(("", 2)));/// assert_eq!(parser("abc123"), Ok(("123", 1)));/// assert_eq!(parser("123123"), Ok(("123123", 0)));/// assert_eq!(parser(""), Ok(("", 0)));many1_count/// Runs the embedded parser, counting the results./// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,/// use nom::multi::many1_count;///   many1_count(tag("abc"))(s)/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1Count))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1Count))));/// Runs the embedded parser `count` times, gathering the results in a `Vec`/// * `count` How often to apply the parser./// use nom::multi::count;///   count(tag("abc"), 2)(s)/// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));/// Runs the embedded parser repeatedly, filling the given slice with results./// This parser fails if the input runs out before the given slice is full./// * `buf` The slice to fill/// use nom::multi::fill;/// fn parser(s: &str) -> IResult<&str, [&str; 2]> {///   let mut buf = ["", ""];///   let (rest, ()) = fill(tag("abc"), &mut buf)(s)?;///   Ok((rest, buf))/// assert_eq!(parser("abcabc"), Ok(("", ["abc", "abc"])));/// assert_eq!(parser("abcabcabc"), Ok(("abc", ["abc", "abc"])));/// Repeats the embedded parser, calling `g` to gather the results./// * `init` A function returning the initial value./// * `g` The function that combines a result of `f` with///       the current accumulator./// use nom::multi::fold_many0;///   fold_many0(///     tag("abc"),///     Vec::new,///     |mut acc: Vec<_>, item| {///       acc.push(item);///       acc///   )(s)fold_many1/// use nom::multi::fold_many1;///   fold_many1(/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1))));/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1))));fold_many_m_n/// Repeats the embedded parser `m..=n` times, calling `g` to gather the results/// This stops before `n` when the parser returns [`Err::Error`]. To instead chain an error up, see/// use nom::multi::fold_many_m_n;///   fold_many_m_n(///     0,length_data/// Gets a number from the parser and returns a/// subslice of the input of that size./// If the parser returns `Incomplete`,/// `length_data` will return an error./// use nom::number::complete::be_u16;/// use nom::multi::length_data;/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {///   length_data(be_u16)(s)/// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..])));/// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));length_value/// Gets a number from the first parser,/// takes a subslice of the input of that size,/// then applies the second parser on that subslice./// If the second parser returns `Incomplete`,/// `length_value` will return an error./// * `g` The parser to apply on the subslice./// use nom::multi::length_value;///   length_value(be_u16, tag("abc"))(s)/// assert_eq!(parser(b"\x00\x03123123"), Err(Err::Error(Error::new(&b"123"[..], ErrorKind::Tag))));length_count/// then applies the second parser that many times./// * `f` The parser to apply to obtain the count./// * `g` The parser to apply repeatedly./// use nom::multi::length_count;/// fn parser(s: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {///   length_count(map(u8, |i| {///      println!("got number: {}", i);///      i///   }), tag("abc"))(s)/// assert_eq!(parser(&b"\x02abcabcabc"[..]), Ok(((&b"abc"[..], vec![&b"abc"[..], &b"abc"[..]]))));/// assert_eq!(parser(b"\x03123123123"), Err(Err::Error(Error::new(&b"123123123"[..], ErrorKind::Tag))));//! Combinators applying their child parser multiple timesbe_u16separated_list0_testseparated_list1_testmany0_testmany1_testmany_till_testinfinite_manymany_m_n_testcount_testcount_zeroNilErrorlength_count_testlength_data_testlength_value_testfold_many0_testfold_many1_testfold_many_m_n_testmany0_count_testmany1_count_test/// Recognizes an unsigned 1 byte integer./// *Complete version*: Returns an error if there is not enough input data./// # use nom::Needed::Size;/// use nom::number::complete::be_u8;/// let parser = |s| {///   be_u8(s)/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));/// Recognizes a big endian unsigned 2 bytes integer.///   be_u16(s)/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));be_u24/// Recognizes a big endian unsigned 3 byte integer./// use nom::number::complete::be_u24;///   be_u24(s)/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));be_u32/// Recognizes a big endian unsigned 4 bytes integer./// use nom::number::complete::be_u32;///   be_u32(s)/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));be_u64/// Recognizes a big endian unsigned 8 bytes integer./// use nom::number::complete::be_u64;///   be_u64(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));be_u128/// Recognizes a big endian unsigned 16 bytes integer./// use nom::number::complete::be_u128;///   be_u128(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));be_i8/// Recognizes a signed 1 byte integer./// use nom::number::complete::be_i8;///   be_i8(s)be_i16/// Recognizes a big endian signed 2 bytes integer./// use nom::number::complete::be_i16;///   be_i16(s)be_i24/// Recognizes a big endian signed 3 bytes integer./// use nom::number::complete::be_i24;///   be_i24(s)be_i32/// Recognizes a big endian signed 4 bytes integer./// use nom::number::complete::be_i32;///   be_i32(s)be_i64/// Recognizes a big endian signed 8 bytes integer./// use nom::number::complete::be_i64;///   be_i64(s)be_i128/// Recognizes a big endian signed 16 bytes integer./// use nom::number::complete::be_i128;///   be_i128(s)le_u8/// use nom::number::complete::le_u8;///   le_u8(s)le_u16/// Recognizes a little endian unsigned 2 bytes integer./// use nom::number::complete::le_u16;///   le_u16(s)/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));le_u24/// Recognizes a little endian unsigned 3 byte integer./// use nom::number::complete::le_u24;///   le_u24(s)/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));le_u32/// Recognizes a little endian unsigned 4 bytes integer./// use nom::number::complete::le_u32;///   le_u32(s)/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));le_u64/// Recognizes a little endian unsigned 8 bytes integer./// use nom::number::complete::le_u64;///   le_u64(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));le_u128/// Recognizes a little endian unsigned 16 bytes integer./// use nom::number::complete::le_u128;///   le_u128(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));le_i8/// use nom::number::complete::le_i8;///   le_i8(s)le_i16/// Recognizes a little endian signed 2 bytes integer./// use nom::number::complete::le_i16;///   le_i16(s)le_i24/// Recognizes a little endian signed 3 bytes integer./// use nom::number::complete::le_i24;///   le_i24(s)le_i32/// Recognizes a little endian signed 4 bytes integer./// use nom::number::complete::le_i32;///   le_i32(s)le_i64/// Recognizes a little endian signed 8 bytes integer./// use nom::number::complete::le_i64;///   le_i64(s)le_i128/// Recognizes a little endian signed 16 bytes integer./// use nom::number::complete::le_i128;///   le_i128(s)/// Recognizes an unsigned 1 byte integer/// Note that endianness does not apply to 1 byte numbers./// *complete version*: returns an error if there is not enough input data///   u8(s)Endianness/// Recognizes an unsigned 2 bytes integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian u16 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian u16 integer./// use nom::number::complete::u16;/// let be_u16 = |s| {///   u16(nom::number::Endianness::Big)(s)/// assert_eq!(be_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));/// assert_eq!(be_u16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_u16 = |s| {///   u16(nom::number::Endianness::Little)(s)/// assert_eq!(le_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));/// assert_eq!(le_u16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes an unsigned 3 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian u24 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian u24 integer./// use nom::number::complete::u24;/// let be_u24 = |s| {///   u24(nom::number::Endianness::Big)(s)/// assert_eq!(be_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));/// assert_eq!(be_u24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_u24 = |s| {///   u24(nom::number::Endianness::Little)(s)/// assert_eq!(le_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));/// assert_eq!(le_u24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes an unsigned 4 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian u32 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian u32 integer./// use nom::number::complete::u32;/// let be_u32 = |s| {///   u32(nom::number::Endianness::Big)(s)/// assert_eq!(be_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));/// assert_eq!(be_u32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_u32 = |s| {///   u32(nom::number::Endianness::Little)(s)/// assert_eq!(le_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));/// assert_eq!(le_u32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes an unsigned 8 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian u64 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian u64 integer./// use nom::number::complete::u64;/// let be_u64 = |s| {///   u64(nom::number::Endianness::Big)(s)/// assert_eq!(be_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));/// assert_eq!(be_u64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_u64 = |s| {///   u64(nom::number::Endianness::Little)(s)/// assert_eq!(le_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));/// assert_eq!(le_u64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes an unsigned 16 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian u128 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian u128 integer./// use nom::number::complete::u128;/// let be_u128 = |s| {///   u128(nom::number::Endianness::Big)(s)/// assert_eq!(be_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));/// assert_eq!(be_u128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_u128 = |s| {///   u128(nom::number::Endianness::Little)(s)/// assert_eq!(le_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));/// assert_eq!(le_u128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes a signed 1 byte integer/// use nom::number::complete::i8;///   i8(s)/// Recognizes a signed 2 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian i16 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian i16 integer./// use nom::number::complete::i16;/// let be_i16 = |s| {///   i16(nom::number::Endianness::Big)(s)/// assert_eq!(be_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));/// assert_eq!(be_i16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_i16 = |s| {///   i16(nom::number::Endianness::Little)(s)/// assert_eq!(le_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));/// assert_eq!(le_i16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes a signed 3 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian i24 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian i24 integer./// use nom::number::complete::i24;/// let be_i24 = |s| {///   i24(nom::number::Endianness::Big)(s)/// assert_eq!(be_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));/// assert_eq!(be_i24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_i24 = |s| {///   i24(nom::number::Endianness::Little)(s)/// assert_eq!(le_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));/// assert_eq!(le_i24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes a signed 4 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian i32 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian i32 integer./// use nom::number::complete::i32;/// let be_i32 = |s| {///   i32(nom::number::Endianness::Big)(s)/// assert_eq!(be_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));/// assert_eq!(be_i32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_i32 = |s| {///   i32(nom::number::Endianness::Little)(s)/// assert_eq!(le_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));/// assert_eq!(le_i32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes a signed 8 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian i64 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian i64 integer./// use nom::number::complete::i64;/// let be_i64 = |s| {///   i64(nom::number::Endianness::Big)(s)/// assert_eq!(be_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));/// assert_eq!(be_i64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_i64 = |s| {///   i64(nom::number::Endianness::Little)(s)/// assert_eq!(le_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));/// assert_eq!(le_i64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// Recognizes a signed 16 byte integer/// If the parameter is `nom::number::Endianness::Big`, parse a big endian i128 integer,/// otherwise if `nom::number::Endianness::Little` parse a little endian i128 integer./// use nom::number::complete::i128;/// let be_i128 = |s| {///   i128(nom::number::Endianness::Big)(s)/// assert_eq!(be_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));/// assert_eq!(be_i128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));/// let le_i128 = |s| {///   i128(nom::number::Endianness::Little)(s)/// assert_eq!(le_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));/// assert_eq!(le_i128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));be_f32/// Recognizes a big endian 4 bytes floating point number./// use nom::number::complete::be_f32;///   be_f32(s)/// assert_eq!(parser(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));/// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));be_f64/// Recognizes a big endian 8 bytes floating point number./// use nom::number::complete::be_f64;///   be_f64(s)/// assert_eq!(parser(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));le_f32/// Recognizes a little endian 4 bytes floating point number./// use nom::number::complete::le_f32;///   le_f32(s)/// assert_eq!(parser(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));le_f64/// Recognizes a little endian 8 bytes floating point number./// use nom::number::complete::le_f64;///   le_f64(s)/// assert_eq!(parser(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));/// Recognizes a 4 byte floating point number/// If the parameter is `nom::number::Endianness::Big`, parse a big endian f32 float,/// otherwise if `nom::number::Endianness::Little` parse a little endian f32 float./// use nom::number::complete::f32;/// let be_f32 = |s| {///   f32(nom::number::Endianness::Big)(s)/// assert_eq!(be_f32(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));/// assert_eq!(be_f32(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));/// let le_f32 = |s| {///   f32(nom::number::Endianness::Little)(s)/// assert_eq!(le_f32(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));/// assert_eq!(le_f32(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));/// Recognizes an 8 byte floating point number/// If the parameter is `nom::number::Endianness::Big`, parse a big endian f64 float,/// otherwise if `nom::number::Endianness::Little` parse a little endian f64 float./// use nom::number::complete::f64;/// let be_f64 = |s| {///   f64(nom::number::Endianness::Big)(s)/// assert_eq!(be_f64(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));/// assert_eq!(be_f64(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));/// let le_f64 = |s| {///   f64(nom::number::Endianness::Little)(s)/// assert_eq!(le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));/// assert_eq!(le_f64(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));hex_u32/// Recognizes a hex-encoded integer./// *Complete version*: Will parse until the end of input if it has less than 8 bytes./// use nom::number::complete::hex_u32;///   hex_u32(s)/// assert_eq!(parser(&b"01AE"[..]), Ok((&b""[..], 0x01AE)));/// assert_eq!(parser(&b"abc"[..]), Ok((&b""[..], 0x0ABC)));/// assert_eq!(parser(&b"ggg"[..]), Err(Err::Error((&b"ggg"[..], ErrorKind::IsA))));recognize_float/// Recognizes floating point number in a byte string and returns the corresponding slice./// *Complete version*: Can parse until the end of input./// use nom::number::complete::recognize_float;///   recognize_float(s)/// assert_eq!(parser("11e-1"), Ok(("", "11e-1")));/// assert_eq!(parser("123E-02"), Ok(("", "123E-02")));/// assert_eq!(parser("123K-01"), Ok(("K-01", "123")));/// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Char))));recognize_float_or_exceptions// workaround until issues with minimal-lexical are fixedrecognize_float_parts/// Recognizes a floating point number in text format/// It returns a tuple of (`sign`, `integer part`, `fraction part` and `exponent`) of the inputIterElem/// Recognizes floating point number in text format and returns a f32./// use nom::number::complete::float;///   float(s)/// assert_eq!(parser("11e-1"), Ok(("", 1.1)));/// assert_eq!(parser("123E-02"), Ok(("", 1.23)));/// assert_eq!(parser("123K-01"), Ok(("K-01", 123.0)));/// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Float))));/// Recognizes floating point number in text format and returns a f64./// use nom::number::complete::double;///   double(s)i8_testsbe_i8_testsbe_i16_testsbe_u24_testsbe_i24_testsbe_i32_testsbe_i64_testsbe_i128_testsle_i8_testsle_i16_testsle_u24_testsle_i24_testsle_i32_testsle_i64_testsle_i128_testsbe_f32_testsbe_f64_testsle_f32_testsle_f64_testshex_u32_testsfloat_testconfigurable_endiannessparse_f64//! Parsers recognizing numbers, complete input version/// Big endian/// Little endian/// Will match the host's endianness/// Configurable endianness//! Parsers recognizing numbers/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there is not enough data./// use nom::number::streaming::be_u8;///   be_u8::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01abcd"[..]), Ok((&b"\x01abcd"[..], 0x00)));/// assert_eq!(parser(&b""[..]), Err(Err::Incomplete(Needed::new(1))));/// use nom::number::streaming::be_u16;///   be_u16::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01abcd"[..]), Ok((&b"abcd"[..], 0x0001)));/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(1))));/// use nom::number::streaming::be_u24;///   be_u24::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02abcd"[..]), Ok((&b"abcd"[..], 0x000102)));/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(2))));/// use nom::number::streaming::be_u32;///   be_u32::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03abcd"[..]), Ok((&b"abcd"[..], 0x00010203)));/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(3))));/// use nom::number::streaming::be_u64;///   be_u64::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..]), Ok((&b"abcd"[..], 0x0001020304050607)));/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(7))));/// use nom::number::streaming::be_u128;///   be_u128::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x00010203040506070809101112131415)));/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));/// use nom::number::streaming::be_i8;/// let parser = be_i8::<_, (_, ErrorKind)>;/// use nom::number::streaming::be_i16;/// let parser = be_i16::<_, (_, ErrorKind)>;/// assert_eq!(parser(&b""[..]), Err(Err::Incomplete(Needed::new(2))));/// use nom::number::streaming::be_i24;/// let parser = be_i24::<_, (_, ErrorKind)>;/// assert_eq!(parser(&b""[..]), Err(Err::Incomplete(Needed::new(3))));/// use nom::number::streaming::be_i32;/// let parser = be_i32::<_, (_, ErrorKind)>;/// assert_eq!(parser(&b""[..]), Err(Err::Incomplete(Needed::new(4))));/// use nom::number::streaming::be_i64;/// let parser = be_i64::<_, (_, ErrorKind)>;/// use nom::number::streaming::be_i128;/// let parser = be_i128::<_, (_, ErrorKind)>;/// use nom::number::streaming::le_u8;/// let parser = le_u8::<_, (_, ErrorKind)>;/// use nom::number::streaming::le_u16;///   le_u16::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01abcd"[..]), Ok((&b"abcd"[..], 0x0100)));/// Recognizes a little endian unsigned 3 bytes integer./// use nom::number::streaming::le_u24;///   le_u24::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02abcd"[..]), Ok((&b"abcd"[..], 0x020100)));/// use nom::number::streaming::le_u32;///   le_u32::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03abcd"[..]), Ok((&b"abcd"[..], 0x03020100)));/// use nom::number::streaming::le_u64;///   le_u64::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..]), Ok((&b"abcd"[..], 0x0706050403020100)));/// use nom::number::streaming::le_u128;///   le_u128::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x15141312111009080706050403020100)));/// use nom::number::streaming::le_i8;/// let parser = le_i8::<_, (_, ErrorKind)>;/// use nom::number::streaming::le_i16;///   le_i16::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::le_i24;///   le_i24::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::le_i32;///   le_i32::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::le_i64;///   le_i64::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::le_i128;///   le_i128::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::u8;///   u8::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::u16;///   u16::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_u16(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(1))));///   u16::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_u16(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(1))));/// use nom::number::streaming::u24;///   u24::<_,(_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_u24(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(2))));///   u24::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_u24(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(2))));/// use nom::number::streaming::u32;///   u32::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_u32(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(3))));///   u32::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_u32(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(3))));/// use nom::number::streaming::u64;///   u64::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_u64(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(7))));///   u64::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_u64(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(7))));/// use nom::number::streaming::u128;///   u128::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_u128(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));///   u128::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_u128(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));/// use nom::number::streaming::i8;///   i8::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::i16;///   i16::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_i16(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(1))));///   i16::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_i16(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(1))));/// use nom::number::streaming::i24;///   i24::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_i24(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(2))));///   i24::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_i24(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(2))));/// use nom::number::streaming::i32;///   i32::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_i32(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(3))));///   i32::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_i32(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(3))));/// use nom::number::streaming::i64;///   i64::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_i64(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(7))));///   i64::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_i64(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(7))));/// use nom::number::streaming::i128;///   i128::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_i128(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));///   i128::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_i128(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));/// use nom::number::streaming::be_f32;///   be_f32::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&[0x40, 0x29, 0x00, 0x00][..]), Ok((&b""[..], 2.640625)));/// assert_eq!(parser(&[0x01][..]), Err(Err::Incomplete(Needed::new(3))));/// use nom::number::streaming::be_f64;///   be_f64::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&[0x01][..]), Err(Err::Incomplete(Needed::new(7))));/// use nom::number::streaming::le_f32;///   le_f32::<_, (_, ErrorKind)>(s)/// use nom::number::streaming::le_f64;///   le_f64::<_, (_, ErrorKind)>(s)/// assert_eq!(parser(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 3145728.0)));/// use nom::number::streaming::f32;///   f32::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_f32(&b"abc"[..]), Err(Err::Incomplete(Needed::new(1))));///   f32::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_f32(&b"abc"[..]), Err(Err::Incomplete(Needed::new(1))));/// use nom::number::streaming::f64;///   f64::<_, (_, ErrorKind)>(nom::number::Endianness::Big)(s)/// assert_eq!(be_f64(&b"abc"[..]), Err(Err::Incomplete(Needed::new(5))));///   f64::<_, (_, ErrorKind)>(nom::number::Endianness::Little)(s)/// assert_eq!(le_f64(&b"abc"[..]), Err(Err::Incomplete(Needed::new(5))));/// use nom::number::streaming::hex_u32;/// assert_eq!(parser(b"01AE;"), Ok((&b";"[..], 0x01AE)));/// assert_eq!(parser(b"abc"), Err(Err::Incomplete(Needed::new(1))));/// assert_eq!(parser(b"ggg"), Err(Err::Error((&b"ggg"[..], ErrorKind::IsA))));/// Recognizes a floating point number in text format and returns the corresponding part of the input./// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if it reaches the end of input./// use nom::number::streaming::recognize_float;/// assert_eq!(parser("11e-1;"), Ok((";", "11e-1")));/// assert_eq!(parser("123E-02;"), Ok((";", "123E-02")));i16_testsu24_testsi24_testsi32_testsi64_testsi128_tests//! Parsers recognizing numbers, streaming version/// Gets an object from the first parser,/// then gets another object from the second parser./// * `first` The first parser to apply./// * `second` The second parser to apply./// use nom::sequence::pair;/// let mut parser = pair(tag("abc"), tag("efg"));/// assert_eq!(parser("abcefg"), Ok(("", ("abc", "efg"))));/// assert_eq!(parser("abcefghij"), Ok(("hij", ("abc", "efg"))));/// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));/// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));/// Matches an object from the first parser and discards it,/// then gets an object from the second parser./// * `first` The opening parser./// * `second` The second parser to get object./// use nom::sequence::preceded;/// let mut parser = preceded(tag("abc"), tag("efg"));/// assert_eq!(parser("abcefg"), Ok(("", "efg")));/// assert_eq!(parser("abcefghij"), Ok(("hij", "efg")));/// then matches an object from the second parser and discards it./// * `second` The second parser to match an object./// use nom::sequence::terminated;/// let mut parser = terminated(tag("abc"), tag("efg"));/// assert_eq!(parser("abcefg"), Ok(("", "abc")));/// assert_eq!(parser("abcefghij"), Ok(("hij", "abc")));O3separated_pair/// then matches an object from the sep_parser and discards it,/// * `sep` The separator parser to apply./// let mut parser = separated_pair(tag("abc"), tag("|"), tag("efg"));/// assert_eq!(parser("abc|efg"), Ok(("", ("abc", "efg"))));/// assert_eq!(parser("abc|efghij"), Ok(("hij", ("abc", "efg"))));/// then gets an object from the second parser,/// and finally matches an object from the third parser and discards it./// * `first` The first parser to apply and discard./// * `third` The third parser to apply and discard./// use nom::sequence::delimited;/// let mut parser = delimited(tag("("), tag("abc"), tag(")"));/// assert_eq!(parser("(abc)"), Ok(("", "abc")));/// assert_eq!(parser("(abc)def"), Ok(("def", "abc")));/// Parses the input and returns a tuple of results of each parser./// Helper trait for the tuple combinator./// This trait is implemented for tuples of parsers of up to 21 elements.tuple_traittuple_trait_impltuple_trait_inner// Special case: implement `Tuple` for `()`, the unit type.// This can come up in macros which accept a variable number of arguments.// Literally, `()` is an empty tuple, so it should simply parse nothing.///Applies a tuple of parsers one by one and returns their results as a tuple.///There is a maximum of 21 parsers/// let mut parser = tuple((alpha1, digit1, alpha1));/// assert_eq!(parser("abc123def"), Ok(("", ("abc", "123", "def"))));/// assert_eq!(parser("123def"), Err(Err::Error(("123def", ErrorKind::Alpha))));//! Combinators applying parsers in sequencesingle_element_tuplespair_testseparated_pair_testpreceded_testterminated_testdelimited_testtuple_test/*FIXME: convert code examples to new error management
use util::{add_error_pattern, error_to_list, print_error};

#[cfg(feature = "std")]
#[rustfmt::skip]
fn error_to_string<P: Clone + PartialEq>(e: &Context<P, u32>) -> &'static str {
  let v: Vec<(P, ErrorKind<u32>)> = error_to_list(e);
  // do it this way if you can use slice patterns
  //match &v[..] {
  //  [ErrorKind::Custom(42), ErrorKind::Tag]                         => "missing `ijkl` tag",
  //  [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] => "missing `mnop` tag after `ijkl`",
  //  _            => "unrecognized error"
  //}

  let collected: Vec<ErrorKind<u32>> = v.iter().map(|&(_, ref e)| e.clone()).collect();
  if &collected[..] == [ErrorKind::Custom(42), ErrorKind::Tag] {
    "missing `ijkl` tag"
  } else if &collected[..] == [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] {
    "missing `mnop` tag after `ijkl`"
  } else {
    "unrecognized error"
  }
}

// do it this way if you can use box patterns
//use $crate::lib::std::str;
//fn error_to_string(e:Err) -> String
//  match e {
//    NodePosition(ErrorKind::Custom(42), i1, box Position(ErrorKind::Tag, i2)) => {
//      format!("missing `ijkl` tag, found '{}' instead", str::from_utf8(i2).unwrap())
//    },
//    NodePosition(ErrorKind::Custom(42), i1, box NodePosition(ErrorKind::Custom(128), i2,  box Position(ErrorKind::Tag, i3))) => {
//      format!("missing `mnop` tag after `ijkl`, found '{}' instead", str::from_utf8(i3).unwrap())
//    },
//    _ => "unrecognized error".to_string()
//  }
//}
*/tagtr_succeedtagtr_incompletetagtr_errortake_s_succeedtake_until_succeedtake_s_incompletetake_till_s_succeedtake_while_succeed_noneis_not_succeedtake_while_succeed_someis_not_failtake_while1_succeedis_a_succeedtake_while1_failis_a_failtake_until_errorrecognize_is_autf8_indexing/// Calculates the input length, as indicated by its name,/// and the name of the trait itself/// Abstract method to calculate the input length/// Offset between the first byte of self and the first byte of the argument/// Useful functions to calculate the offset between slices and show a hexdump of a slice/// Casts the input type to a byte slice/// Helper trait for types that can be viewed as a byte sliceas_bytes_array_impls/// makes a char from selfis_alpha/// Tests that self is an alphabetic character/// Warning: for `&str` it recognizes alphabetic/// characters outside of the 52 ASCII lettersis_alphanum/// or a decimal digitis_dec_digit/// Tests that self is a decimal digit/// Tests that self is an hex digit/// Tests that self is an octal digit/// Gets the len in bytes for self/// Transforms common types to a char for basic token parsing/// The current input type is a sequence of that `Item` type./// Example: `u8` for `&[u8]` or `char` for `&str`/// An iterator over the input type, producing the item and its position/// for use with [Slice]. If we're iterating over `&str`, the position/// corresponds to the byte index of the character/// An iterator over the input type, producing the itemiter_indices/// Returns an iterator over the elements and their byte offsetsiter_elements/// Returns an iterator over the elements/// Finds the byte position of the element/// Get the byte offset from the element's position in the stream/// Abstracts common iteration operations on the input type/// Returns a slice of `count` bytes. panics if count > lengthtake_split/// Split the stream at the `count` byte offset. panics if count > length/// Abstracts slicing operations// return byte indexUnspecializedInput/// Dummy trait used for default implementations (currently only used for `InputTakeAtPosition` and `Compare`)./// When implementing a custom input type, it is possible to use directly the/// default implementation: If the input type implements `InputLength`, `InputIter`,/// `InputTake` and `Clone`, you can implement `UnspecializedInput` and get/// a default version of `InputTakeAtPosition` and `Compare`./// For performance reasons, you might want to write a custom implementation of/// `InputTakeAtPosition` (like the one for `&[u8]`).split_at_position/// Looks for the first element of the input type for which the condition returns true,/// and returns the input up to this position./// *streaming version*: If no element is found matching the condition, this will return `Incomplete`split_at_position1/// Looks for the first element of the input type for which the condition returns true/// Fails if the produced slice is empty.split_at_position_complete/// *complete version*: If no element is found matching the condition, this will return the whole inputsplit_at_position1_complete/// Methods to take as much input as possible until the provided function returns true for the current element./// A large part of nom's basic parsers are built using this trait./// Comparison was successful/// We need more data to be sure/// Comparison failed/// Indicates whether a comparison was successful, an error, or/// if more data was needed/// Compares self to another value for equalitycompare_no_case/// independently of the case./// Warning: for `&str`, the comparison is done/// by lowercasing both strings and comparing/// the result. This is a temporary solution until/// a better one appears/// Abstracts comparison operationslowercase_byte//FIXME: this version is too simple and does not use the current locale/// Returns true if self contains the token/// Look for a token in selffind_substring/// Returns the byte position of the substring if it is found/// Look for a substring in self//returns byte indexparse_to/// Succeeds if `parse()` succeeded. The byte slice implementation/// will first convert it to a `&str`, then apply the `parse()` function/// Used to integrate `str`'s `parse()` method/// Slices self according to the range argument/// Slicing operations using ranges./// This trait is loosely based on/// `Index`, but can actually return/// something else than a `&[T]` or `&str`impl_fn_sliceslice_range_implslice_ranges_implarray_impls/// The type that will be produced/// Create a new `Extend` of the correct typeextend_into/// Accumulate the input into an accumulator/// Abstracts something which can extend an `Extend`./// Used to build modified input slices in `escaped_transform`/// converts self to usize/// Helper trait to convert numbers to usize./// By default, usize implements `From<u8>` and `From<u16>` but not/// `From<u32>` and `From<u64>` because that would be invalid on some/// platforms. This trait implements the conversion for platforms/// with 32 and 64 bits pointer platforms/// Transform to another error type/// Equivalent From implementation to avoid orphan rules in bits parsersto_hex/// Converts the value of `self` to a hex dump, returning the owned/// `String`.to_hex_from/// Converts the value of `self` to a hex dump beginning at `from` address, returning the owned/// Helper trait to show a byte slice as a hex dumpCHARStest_offset_u8test_offset_str//! Traits input types have to implement to work with nom combinators/// Like `AnsiString`, but only displays the style prefix./// Like `AnsiString`, but only displays the difference between two/// Like `AnsiString`, but only displays the style suffix./// terminal to use a different color or font style./// use nu_ansi_term::{Style, Color::Blue};/// a reset followed by the next color and style, depending on the two styles./// use nu_ansi_term::{Style, Color::Green};/// to reset back to its normal color and font style./// The prefix bytes for this color as a `Style`. These are the bytes/// that tell the terminal to use a different color or font style./// use nu_ansi_term::Color::Green;/// The infix bytes between this color and `next` color. These are the bytes/// that tell the terminal to use the `next` color, or to do nothing if/// the two colors are equal./// use nu_ansi_term::Color::{Red, Yellow};/// The suffix for this color as a `Style`. These are the bytes that/// tell the terminal to reset back to its normal color and font style./// use nu_ansi_term::Color::Purple;magenta_on_whitemagenta_on_white_2lr_on_lr///     use nu_ansi_term::Color::{Red, Blue};/// When printing out one colored string followed by another, use one of/// use the foreground color green, and reduce it to a single command.color_changeAnsiGenericString/// An `AnsiGenericString` includes a generic string type and a `Style` to/// display that string.  `AnsiString` and `AnsiByteString` are aliases for/// Cloning an `AnsiGenericString` will clone its underlying string./// use nu_ansi_term::AnsiString;/// let plain_string = AnsiString::from("a plain string");AnsiString/// use nu_ansi_term::Color::Red;AnsiByteString/// An `AnsiByteString` represents a formatted series of bytes.  Use/// `AnsiByteString` when styling text with an unknown encoding.AnsiGenericStrings/// A set of `AnsiGenericStrings`s collected together, in order to beAnsiStrings/// A set of `AnsiString`s collected together, in order to be written with a/// A function to construct an `AnsiStrings` instance.AnsiByteStrings/// A set of `AnsiByteString`s collected together, in order to be/// A function to construct an `AnsiByteStrings` instance./// Paints the given text with this color, returning an ANSI string./// use nu_ansi_term::Color::Blue;/// Write an `AnsiByteString` to an `io::Write`.  This writes the escapeWstr/// Write `AnsiByteStrings` to an `io::Write`.  This writes the minimal//     pub struct TextCellContents(Vec<AnsiString<'static>>);/// Start Color of Gradient/// End Color of Gradient/// Linear color gradient between two color stops/// Creates a new [Gradient] with two [Rgb] colors, `start` and `end`from_color_rgb/// Computes the [Rgb] color between `start` and `end` for `t`/// Returns the reverse of `self`TargetGroundbuild_all_gradient_textForegroundansi_color_codeANSIColorCode"nu_ansi_term"gradient//! This is a library for controlling colors and formatting, such as//! concerned with: [`AnsiString`], [`Style`], and [`Color`].//! A `Style` holds stylistic information: foreground and background colors,//! [`Color`] enum represents the available colors. And an [`AnsiString`] is a//! [`Color`] is also available as an alias to `Color`.//! To format a string, call the `paint` method on a `Style` or a `Color`,//! use nu_ansi_term::Color::Red;//! an [`AnsiString`] value that has a [`Display`] implementation that, when//! [`AnsiString`] to a string as you would any other `Display` value://! For anything more complex than plain foreground color changes, you need to//! construct `Style` values themselves, rather than beginning with a `Color`.//! use nu_ansi_term::Style;//! For brevity, these methods have also been implemented for `Color` values,//! so you can give your styles a foreground color without having to begin with//! use nu_ansi_term::Color::{Blue, Yellow};//! background colors.//! existing `Style` rather than starting from the appropriate `Color`.//! use nu_ansi_term::Color::{Blue, Cyan, Yellow};//! You can turn a `Color` into a `Style` with the [`normal`] method.//! This will produce the exact same `AnsiString` as if you just used the//! `paint` method on the `Color` directly, but it’s useful in certain cases://! ## Extended colors//! You can access the extended range of 256 colors by using the `Color::Fixed`//! variant, which takes an argument of the color number to use. This can be//! included wherever you would use a `Color`://! use nu_ansi_term::Color::Fixed;//! standard color variants. There’s nothing stopping you from using these as//! `Fixed` colors instead, but there’s nothing to be gained by doing so//! You can also access full 24-bit color by using the `Color::Rgb` variant,//! use nu_ansi_term::Color::Rgb;//! Rgb(70, 130, 180).paint("Steel blue");//! ## Combining successive colored strings//! *stack*: you do not need to end every colored string with a reset code if//! this, making life easier for your terminal renderer. The [`AnsiStrings`]//! type takes a slice of several [`AnsiString`] values, and will iterate over//! use nu_ansi_term::{AnsiString, AnsiStrings};//! let strings: &[AnsiString<'static>] = &[//! println!("Value: {}", AnsiStrings(strings));//! *either* an owned [`String`] or a borrowed [`&str`]. Internally, an [`AnsiString`]//! statically-available `&str` slices. Secondly, that the [`AnsiStrings`] value//! [`Color`] support painting `\[u8]` values, resulting in an [`AnsiByteString`].//! use nu_ansi_term::Color::Green;//! Similarly, the type [`AnsiByteStrings`] supports writing a list of//! [`AnsiByteString`] values with minimal escape sequences://! use nu_ansi_term::AnsiByteStrings;//! AnsiByteStrings(&[//! [`AnsiString`]: type.AnsiString.html//! [`AnsiStrings`]: type.AnsiStrings.html//! [`AnsiByteString`]: type.AnsiByteString.html//! [`AnsiByteStrings`]: type.AnsiByteStrings.html//! [`write_to`]: type.AnsiByteString.html#method.write_to//! [`paint`]: type.AnsiByteString.html#method.write_to//! [`normal`]: enum.Color.html#method.normal// #![warn(unused_extern_crates, unused_qualifications)]// Code liberally borrowed from here// https://github.com/navierr/coloriz/// Creates a new [Rgb] color/// Creates a new [Rgb] color with a hex codefrom_hex_string/// Creates a new [Rgb] color with three [f32] valuesgray/// Creates a grayscale [Rgb] colorgray_f32/// Creates a grayscale [Rgb] color with a [f32] value/// Computes the linear interpolation between `self` and `other` for `t`/// Creates a new [Rgb] color from a [HSL] color// pub fn from_hsl(hsl: HSL) -> Self {//     if hsl.s == 0.0 {//         return Self::gray_f32(hsl.l);//     let q = if hsl.l < 0.5 {//         hsl.l * (1.0 + hsl.s)//         hsl.l + hsl.s - hsl.l * hsl.s//     let p = 2.0 * hsl.l - q;//     let h2c = |t: f32| {//         let t = t.clamp(0.0, 1.0);//         if 6.0 * t < 1.0 {//             p + 6.0 * (q - p) * t//         } else if t < 0.5 {//             q//         } else if 1.0 < 1.5 * t {//             p + 6.0 * (q - p) * (1.0 / 1.5 - t)//             p//     Self::from_f32(h2c(hsl.h + 1.0 / 3.0), h2c(hsl.h), h2c(hsl.h - 1.0 / 3.0))_overload_binary_overload_binary_internal_overload_unary_overload_unary_internal/// The style's foreground color, if it has one./// The style's background color, if it has one./// Whether this style has reverse colors./// use nu_ansi_term::{Style, Color};/// let style = Style::new().bold().on(Color::Black);/// use nu_ansi_term::Style;/// Returns a `Style` with the foreground color property set./// let style = Style::new().fg(Color::Yellow);/// Returns a `Style` with the background color property set./// let style = Style::new().on(Color::Blue);/// Color #0 (foreground code `30`, background code `40`)./// This is not necessarily the background color, and using it as one mayDarkGray/// Color #0 (foreground code `90`, background code `100`)./// Color #1 (foreground code `31`, background code `41`).LightRed/// Color #1 (foreground code `91`, background code `101`)./// Color #2 (foreground code `32`, background code `42`).LightGreen/// Color #2 (foreground code `92`, background code `102`)./// Color #3 (foreground code `33`, background code `43`).LightYellow/// Color #3 (foreground code `93`, background code `103`)./// Color #4 (foreground code `34`, background code `44`).LightBlue/// Color #4 (foreground code `94`, background code `104`)./// Color #5 (foreground code `35`, background code `45`).LightPurple/// Color #5 (foreground code `95`, background code `105`).LightMagenta/// Color #6 (foreground code `36`, background code `46`).LightCyan/// Color #6 (foreground code `96`, background code `106`)./// Color #7 (foreground code `37`, background code `47`)./// As above, this is not necessarily the foreground color, and may beLightGray/// Color #7 (foreground code `97`, background code `107`)./// A color number from 0 to 255, for use in 256-color terminal/// - colors 0 to 7 are the `Black` to `White` variants respectively.///   These colors can usually be changed in the terminal emulator./// - colors 8 to 15 are brighter versions of the eight colors above.///   could be configured to use the original colors and show the text in/// - colors 16 to 231 contain several palettes of bright colors,/// - colors 232 to 255 are shades of grey from black to white./// It might make more sense to look at a [color chart][cc]./// A 24-bit Rgb color, as specified by ISO-8613-3./// The default color (foreground code `39`, background codr `49`)./// A color is one specific type of ANSI escape code, and can refer/// to either the foreground or background color./// Returns a `Style` with the foreground color set to this color./// use nu_ansi_term::Color;/// let style = Color::Red.normal();/// Returns a `Style` with the foreground color set to this color and the/// let style = Color::Green.bold();/// let style = Color::Yellow.dimmed();/// let style = Color::Blue.italic();/// let style = Color::Purple.underline();/// let style = Color::Cyan.blink();/// let style = Color::Black.reverse();/// let style = Color::White.hidden();/// let style = Color::Fixed(244).strikethrough();/// background color property set to the given color./// let style = Color::Rgb(31, 31, 31).on(Color::White);/// You can turn a `Color` into a `Style` with the foreground color set/// let green_foreground = Style::default().fg(Color::Green);/// assert_eq!(green_foreground, Color::Green.normal());/// assert_eq!(green_foreground, Color::Green.into());/// assert_eq!(green_foreground, Style::from(Color::Green));// ---- colors ----/// Return a substring of the given AnsiStrings sequence, while keeping the formatting./// Return the unstyled length of AnsiStrings. This is equaivalent to `unstyle(strs).len()`./// # #[cfg(not(feature = "gnu_legacy"))]/// # Examples with gnu_legacy feature enabled/// Styles like bold, underlined, etc. are two-digit now/// # #[cfg(feature = "gnu_legacy")]/// assert_eq!("\x1b[01m",/// assert_eq!("\x1b[01;34m",///            Green.prefix().to_string());yellow_on_blue_resetyellow_on_blue_reset_2bold_with_resetbold_with_reset_2OSControloscontrol/// Directly access the underlying string// Instances that imply wrapping in OSC sequences// and do not get displayed in the terminal text// area./// Produce an ANSI string that changes the title shown/// by the terminal emulator./// use nu_ansi_term::AnsiGenericString;/// let title_string = AnsiGenericString::title("My Title");/// println!("{}", title_string);/// Should produce an empty line but set the terminal title./// Cause the styled ANSI string to link to the given URL/// let link_string = Red.paint("a red string").hyperlink("https://www.example.com");/// println!("{}", link_string);/// Should show a red-painted string which, on terminals/// that support it, is a clickable hyperlink.url_string/// Get any URL associated with the string// Annotations (OSC sequences that do more than wrap)write_inner// write the part within the styling prefix and suffixidempotent// NOTE: unstyled because it could have OSC escape sequenceshyperlinksrgb_addrgb_subrgb_mul_f32rgb_negateprefix_with_reset/// Wether this style is always displayed starting with a reset code to clear any remaining style artifactsreset_before_style/// Returns a [`Style`] with the `Style.prefix_with_reset` property set./// let style = Style::new().reset_before_style();/// Returns a `Style` thats resets all styling before applying/// the foreground color set to this color./// let style = Color::Fixed(244).reset_before_style();CheckedUnsignedAbsSignNoSignUnsignedAbsIsizePromotionUsizePromotionbigint_add// We want to forward to BigUint::add, but it's not clear how that will go until// we compare both sign and magnitude.  So we duplicate this body for every// val/ref combination, deferring that decision to BigUint's own forwarding.forward_val_assignpromote_all_scalarspromote_unsigned_scalarspromote_scalarsforward_all_scalar_binop_to_val_valforward_scalar_val_ref_binop_to_val_valforward_scalar_ref_val_binop_to_val_valforward_scalar_ref_ref_binop_to_val_valpromote_signed_scalarspromote_all_scalars_assignpromote_unsigned_scalars_assignpromote_scalars_assignpromote_signed_scalars_assignforward_all_scalar_binop_to_val_val_commutativeforward_scalar_val_val_binop_commutativeimpl_sum_iter_typeshrinkarbitrary_take_restbig_digitBigDigitDoubleBigDigitbiguintIntDigitsnegate_carry// Negation in two's complement.// acc must be initialized as 1 for least-significant digit.// When negating, a carry (acc == 1) means that all the digits// considered to this point were zero. This means that if all the// digits of a negative BigInt have been considered, carry must be// zero as we cannot have negative zero.//    01 -> ...f    ff//    ff -> ...f    01// 01 00 -> ...f ff 00// 01 01 -> ...f fe ff// 01 ff -> ...f fe 01// ff 00 -> ...f 01 00// ff 01 -> ...f 00 ff// ff ff -> ...f 00 01bitand_pos_neg// + 1 & -ff = ...0 01 & ...f 01 = ...0 01 = + 1// +ff & - 1 = ...0 ff & ...f ff = ...0 ff = +ff// answer is pos, has length of abitand_neg_pos// - 1 & +ff = ...f ff & ...0 ff = ...0 ff = +ff// -ff & + 1 = ...f 01 & ...0 01 = ...0 01 = + 1// answer is pos, has length of bbitand_neg_neg// - 1 & -ff = ...f ff & ...f 01 = ...f 01 = - ff// -ff & - 1 = ...f 01 & ...f ff = ...f 01 = - ff// -ff & -fe = ...f 01 & ...f 02 = ...f 00 = -100// answer is neg, has length of longest with a possible carryforward_val_val_binopforward_ref_val_binop// do not use forward_ref_ref_binop_commutative! for bitand so that we can// clone as needed, avoiding over-allocationbitor_pos_neg// + 1 | -ff = ...0 01 | ...f 01 = ...f 01 = -ff// +ff | - 1 = ...0 ff | ...f ff = ...f ff = - 1// answer is neg, has length of bbitor_neg_pos// - 1 | +ff = ...f ff | ...0 ff = ...f ff = - 1// -ff | + 1 = ...f 01 | ...0 01 = ...f 01 = -ff// answer is neg, has length of abitor_neg_neg// - 1 | -ff = ...f ff | ...f 01 = ...f ff = -1// -ff | - 1 = ...f 01 | ...f ff = ...f ff = -1// answer is neg, has length of shortest// do not use forward_ref_ref_binop_commutative! for bitor so that we canbitxor_pos_neg// + 1 ^ -ff = ...0 01 ^ ...f 01 = ...f 00 = -100// +ff ^ - 1 = ...0 ff ^ ...f ff = ...f 00 = -100bitxor_neg_pos// - 1 ^ +ff = ...f ff ^ ...0 ff = ...f 00 = -100// -ff ^ + 1 = ...f 01 ^ ...0 01 = ...f 00 = -100bitxor_neg_neg// - 1 ^ -ff = ...f ff ^ ...f 01 = ...0 fe = +fe// -ff & - 1 = ...f 01 ^ ...f ff = ...0 fe = +fe// answer is pos, has length of longestforward_all_binop_to_val_ref_commutativeforward_val_val_binop_commutativeforward_ref_val_binop_commutativeforward_ref_ref_binop_commutativeset_negative_bitToBigIntTryFromBigIntErrorParseBigIntErrorToBigUint/// Creates and initializes a [`BigInt`].impl_try_from_bigintimpl_bigint_from_intimpl_bigint_from_uintto_bigintto_biguintimpl_to_bigintfrom_signed_bytes_befrom_signed_bytes_leto_signed_bytes_beto_signed_bytes_letwos_complement_le/// Perform in-place two's complement of the given binary representation,/// in little-endian byte order.twos_complement_be/// Perform in-place two's complement of the given binary representation/// in big-endian byte order.twos_complement/// Perform in-place two's complement of the given digit iterator/// starting from the least significant byte.CheckedDivCheckedEuclidEuclidforward_all_binop_to_ref_refforward_val_ref_binopchecked_div_rem_eucliddiv_rem_euclidimpl_mul_assignimpl_product_iter_typepowsign/// Help function for pow/// Computes the effect of the exponent on the sign.pow_implmodpowPrimIntimpl_shiftshr_round_down// Negative values need a rounding adjustment if there are any ones in the// bits that are getting shifted out.bigint_sub// We want to forward to BigUint::sub, but it's not clear how that will go untilRootsConstZeroto_str_radix_reversedU32DigitsU64Digitsadditionmultiplicationsubtraction/// A `Sign` is a [`BigInt`]'s composing element./// Negate `Sign` value./// A big signed integer type.// Note: derived `Clone` doesn't specialize `clone_from`,// but we want to keep the allocation in `data`.// !-2 = !...f fe = ...0 01 = +1// !-1 = !...f ff = ...0 00 =  0// ! 0 = !...0 00 = ...f ff = -1// !+1 = !...0 01 = ...f fe = -2set_zero// forward to the inherent constset_oneis_onechecked_uabsimpl_unsigned_absdiv_floormod_floor/// Calculates the Greatest Common Divisor (GCD) of the number and `other`./// The result is always positive.lcm/// Calculates the Lowest Common Multiple (LCM) of the number and `other`.gcd_lcm/// Calculates the Greatest Common Divisor (GCD) and/// Lowest Common Multiple (LCM) together.extended_gcd_lcmExtendedGcd/// Greatest common divisor, least common multiple, and Bézout coefficients.divides/// Deprecated, use `is_multiple_of` instead.is_multiple_of/// Returns `true` if the number is a multiple of `other`./// Returns `true` if the number is divisible by `2`./// Returns `true` if the number is not divisible by `2`.next_multiple_of/// Rounds up to nearest multiple of argument.prev_multiple_of/// Rounds down to nearest multiple of argument.nth_rootdigits_mut/// Converts the value of `self` to a [`BigInt`]./// A generic trait for converting a value to a [`BigInt`]. This may return/// `None` when converting from `f32` or `f64`, and will always succeed/// when converting from any integer or unsigned primitive, or [`BigUint`]./// A constant `BigInt` with value 0, useful for static initialization./// The base 2<sup>32</sup> digits are ordered least significant digit first.from_biguintassign_from_slice/// Reinitializes a [`BigInt`].from_bytes_be/// The bytes are in big-endian byte order./// use num_bigint::{BigInt, Sign};/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"A"),///            BigInt::parse_bytes(b"65", 10).unwrap());/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AA"),///            BigInt::parse_bytes(b"16705", 10).unwrap());/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AB"),///            BigInt::parse_bytes(b"16706", 10).unwrap());/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"Hello world!"),///            BigInt::parse_bytes(b"22405534230753963835153736737", 10).unwrap());from_bytes_le/// The bytes are in little-endian byte order./// Creates and initializes a [`BigInt`] from an array of bytes in/// two's complement binary representation./// The digits are in big-endian base 2<sup>8</sup>./// Creates and initializes a [`BigInt`] from an array of bytes in two's complement./// The digits are in little-endian base 2<sup>8</sup>./// use num_bigint::{BigInt, ToBigInt};/// assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234));/// assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD));/// assert_eq!(BigInt::parse_bytes(b"G", 16), None);from_radix_be/// Creates and initializes a [`BigInt`]. Each `u8` of the input slice is/// interpreted as one digit of the number/// and must therefore be less than `radix`./// `radix` must be in the range `2...256`./// let inbase190 = vec![15, 33, 125, 12, 14];/// let a = BigInt::from_radix_be(Sign::Minus, &inbase190, 190).unwrap();/// assert_eq!(a.to_radix_be(190), (Sign:: Minus, inbase190));from_radix_le/// let inbase190 = vec![14, 12, 125, 33, 15];/// assert_eq!(a.to_radix_be(190), (Sign::Minus, inbase190));to_bytes_be/// Returns the sign and the byte representation of the [`BigInt`] in big-endian byte order./// use num_bigint::{ToBigInt, Sign};/// let i = -1125.to_bigint().unwrap();/// assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101]));to_bytes_le/// Returns the sign and the byte representation of the [`BigInt`] in little-endian byte order./// assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4]));to_u32_digits/// Returns the sign and the `u32` digits representation of the [`BigInt`] ordered least/// significant digit first./// assert_eq!(BigInt::from(-1125).to_u32_digits(), (Sign::Minus, vec![1125]));/// assert_eq!(BigInt::from(4294967295u32).to_u32_digits(), (Sign::Plus, vec![4294967295]));/// assert_eq!(BigInt::from(4294967296u64).to_u32_digits(), (Sign::Plus, vec![0, 1]));/// assert_eq!(BigInt::from(-112500000000i64).to_u32_digits(), (Sign::Minus, vec![830850304, 26]));/// assert_eq!(BigInt::from(112500000000i64).to_u32_digits(), (Sign::Plus, vec![830850304, 26]));to_u64_digits/// Returns the sign and the `u64` digits representation of the [`BigInt`] ordered least/// assert_eq!(BigInt::from(-1125).to_u64_digits(), (Sign::Minus, vec![1125]));/// assert_eq!(BigInt::from(4294967295u32).to_u64_digits(), (Sign::Plus, vec![4294967295]));/// assert_eq!(BigInt::from(4294967296u64).to_u64_digits(), (Sign::Plus, vec![4294967296]));/// assert_eq!(BigInt::from(-112500000000i64).to_u64_digits(), (Sign::Minus, vec![112500000000]));/// assert_eq!(BigInt::from(112500000000i64).to_u64_digits(), (Sign::Plus, vec![112500000000]));/// assert_eq!(BigInt::from(1u128 << 64).to_u64_digits(), (Sign::Plus, vec![0, 1]));iter_u32_digits/// Returns an iterator of `u32` digits representation of the [`BigInt`] ordered least/// use num_bigint::BigInt;/// assert_eq!(BigInt::from(-1125).iter_u32_digits().collect::<Vec<u32>>(), vec![1125]);/// assert_eq!(BigInt::from(4294967295u32).iter_u32_digits().collect::<Vec<u32>>(), vec![4294967295]);/// assert_eq!(BigInt::from(4294967296u64).iter_u32_digits().collect::<Vec<u32>>(), vec![0, 1]);/// assert_eq!(BigInt::from(-112500000000i64).iter_u32_digits().collect::<Vec<u32>>(), vec![830850304, 26]);/// assert_eq!(BigInt::from(112500000000i64).iter_u32_digits().collect::<Vec<u32>>(), vec![830850304, 26]);iter_u64_digits/// Returns an iterator of `u64` digits representation of the [`BigInt`] ordered least/// assert_eq!(BigInt::from(-1125).iter_u64_digits().collect::<Vec<u64>>(), vec![1125u64]);/// assert_eq!(BigInt::from(4294967295u32).iter_u64_digits().collect::<Vec<u64>>(), vec![4294967295u64]);/// assert_eq!(BigInt::from(4294967296u64).iter_u64_digits().collect::<Vec<u64>>(), vec![4294967296u64]);/// assert_eq!(BigInt::from(-112500000000i64).iter_u64_digits().collect::<Vec<u64>>(), vec![112500000000u64]);/// assert_eq!(BigInt::from(112500000000i64).iter_u64_digits().collect::<Vec<u64>>(), vec![112500000000u64]);/// assert_eq!(BigInt::from(1u128 << 64).iter_u64_digits().collect::<Vec<u64>>(), vec![0, 1]);/// Returns the two's-complement byte representation of the [`BigInt`] in big-endian byte order./// use num_bigint::ToBigInt;/// assert_eq!(i.to_signed_bytes_be(), vec![251, 155]);/// Returns the two's-complement byte representation of the [`BigInt`] in little-endian byte order./// assert_eq!(i.to_signed_bytes_le(), vec![155, 251]);to_str_radix/// Returns the integer formatted as a string in the given radix./// `radix` must be in the range `2...36`./// let i = BigInt::parse_bytes(b"ff", 16).unwrap();/// assert_eq!(i.to_str_radix(16), "ff");to_radix_be/// Returns the integer in the requested base in big-endian digit order./// The output is not given in a human readable alphabet but as a zero/// based `u8` number./// assert_eq!(BigInt::from(-0xFFFFi64).to_radix_be(159),///            (Sign::Minus, vec![2, 94, 27]));/// // 0xFFFF = 65535 = 2*(159^2) + 94*159 + 27to_radix_le/// Returns the integer in the requested base in little-endian digit order./// assert_eq!(BigInt::from(-0xFFFFi64).to_radix_le(159),///            (Sign::Minus, vec![27, 94, 2]));/// // 0xFFFF = 65535 = 27 + 94*159 + 2*(159^2)/// Returns the sign of the [`BigInt`] as a [`Sign`]./// assert_eq!(BigInt::from(1234).sign(), Sign::Plus);/// assert_eq!(BigInt::from(-4321).sign(), Sign::Minus);/// assert_eq!(BigInt::ZERO.sign(), Sign::NoSign);/// Returns the magnitude of the [`BigInt`] as a [`BigUint`]./// use num_bigint::{BigInt, BigUint};/// use num_traits::Zero;/// assert_eq!(BigInt::from(1234).magnitude(), &BigUint::from(1234u32));/// assert_eq!(BigInt::from(-4321).magnitude(), &BigUint::from(4321u32));/// assert!(BigInt::ZERO.magnitude().is_zero());/// Convert this [`BigInt`] into its [`Sign`] and [`BigUint`] magnitude,/// the reverse of [`BigInt::from_biguint()`]./// use num_bigint::{BigInt, BigUint, Sign};/// assert_eq!(BigInt::from(1234).into_parts(), (Sign::Plus, BigUint::from(1234u32)));/// assert_eq!(BigInt::from(-4321).into_parts(), (Sign::Minus, BigUint::from(4321u32)));/// assert_eq!(BigInt::ZERO.into_parts(), (Sign::NoSign, BigUint::ZERO));/// Determines the fewest bits necessary to express the [`BigInt`],/// not including the sign./// Converts this [`BigInt`] into a [`BigUint`], if it's not negative./// Returns `self ^ exponent`./// Returns `(self ^ exponent) mod modulus`/// Note that this rounds like `mod_floor`, not like the `%` operator,/// which makes a difference when given a negative `self` or `modulus`./// The result will be in the interval `[0, modulus)` for `modulus > 0`,/// or in the interval `(modulus, 0]` for `modulus < 0`/// Panics if the exponent is negative or the modulus is zero.modinv/// Returns the modular multiplicative inverse if it exists, otherwise `None`./// This solves for `x` such that `self * x ≡ 1 (mod modulus)`./// The solution will be in the interval `[0, modulus)` for `modulus > 0`,/// or in the interval `(modulus, 0]` for `modulus < 0`,/// and it exists if and only if `gcd(self, modulus) == 1`./// use num_integer::Integer;/// use num_traits::{One, Zero};/// let m = BigInt::from(383);/// // Trivial cases/// assert_eq!(BigInt::zero().modinv(&m), None);/// assert_eq!(BigInt::one().modinv(&m), Some(BigInt::one()));/// let neg1 = &m - 1u32;/// assert_eq!(neg1.modinv(&m), Some(neg1));/// // Positive self and modulus/// let a = BigInt::from(271);/// let x = a.modinv(&m).unwrap();/// assert_eq!(x, BigInt::from(106));/// assert_eq!(x.modinv(&m).unwrap(), a);/// assert_eq!((&a * x).mod_floor(&m), BigInt::one());/// // Negative self and positive modulus/// let b = -&a;/// let x = b.modinv(&m).unwrap();/// assert_eq!(x, BigInt::from(277));/// assert_eq!((&b * x).mod_floor(&m), BigInt::one());/// // Positive self and negative modulus/// let n = -&m;/// let x = a.modinv(&n).unwrap();/// assert_eq!(x, BigInt::from(-277));/// assert_eq!((&a * x).mod_floor(&n), &n + 1);/// // Negative self and modulus/// let x = b.modinv(&n).unwrap();/// assert_eq!(x, BigInt::from(-106));/// assert_eq!((&b * x).mod_floor(&n), &n + 1);/// Returns the truncated principal square root of `self` --/// see [`num_integer::Roots::sqrt()`]./// Returns the truncated principal cube root of `self` --/// see [`num_integer::Roots::cbrt()`]./// Returns the truncated principal `n`th root of `self` --/// See [`num_integer::Roots::nth_root()`]./// Returns the number of least-significant bits that are zero,/// or `None` if the entire number is zero./// Returns whether the bit in position `bit` is set,/// using the two's complement for negative numbers/// Sets or clears the bit in the given position,/// Note that setting/clearing a bit (for positive/negative numbers,/// respectively) greater than the current bit length, a reallocation/// may be needed to store the new digitstest_from_biguinttest_assign_from_slice// `Add`/`Sub` ops may flip from `BigInt` to its `BigUint` magnitudebiguint_from_vecgen_biguint/// Generate a random [`BigUint`] of the given bit size.gen_bigint/// Generate a random [ BigInt`] of the given bit size.gen_biguint_below/// Generate a random [`BigUint`] less than the given bound. Fails/// when the bound is zero.gen_biguint_range/// Generate a random [`BigUint`] within the given range. The lower/// bound is inclusive; the upper bound is exclusive. Fails when/// the upper bound is not greater than the lower bound.gen_bigint_range/// Generate a random [`BigInt`] within the given range. The lowerRandBigInt/// A trait for sampling random big integers./// The `rand` feature must be enabled to use this. See crate-level documentation for details.gen_bitscfg_digitUniformBigUint/// The back-end implementing rand's [`UniformSampler`] for [`BigUint`].sample_singleUniformBigInt/// The back-end implementing rand's [`UniformSampler`] for [`BigInt`].RandomBits/// A random distribution for [`BigUint`] and [`BigInt`] values of a particular bit size.//! Randomization of big integerscfg_64// Add with carry:cfg_32__add2/// Two argument addition of raw slices, `a += b`, returning the carry./// This is used when the data `Vec` might need to resize to push a non-zero carry, so we perform/// the addition first hoping that it will fit./// The caller _must_ ensure that `a` is at least as long as `b`./// Two argument addition of raw slices:/// a += b/// The caller _must_ ensure that a is big enough to store the result - typically this means/// resizing a to max(a.len(), b.len()) + 1, to fit a possible carry.// clone the smaller value rather than the larger, avoiding over-allocationdiv_rem_digitFAST_DIV_WIDEmac_with_carry/// Find last set bit/// fls(0) == 0, fls(u32::MAX) == 32ilog2from_bitwise_digits_le// Convert from a power of two radix (bits == ilog2(radix)) where bits evenly divides// BigDigit::BITSfrom_inexact_bitwise_digits_le// Convert from a power of two radix (bits == ilog2(radix)) where bits doesn't evenly dividefrom_radix_digits_be// Read little-endian radix digits/// Creates and initializes a `BigUint`.high_bits_to_u64impl_try_from_biguintimpl_biguint_from_uintimpl_biguint_try_from_intimpl_to_biguintto_bitwise_digits_le// Extract bitwise digits that evenly divide BigDigitto_inexact_bitwise_digits_le// Extract bitwise digits that don't evenly divide BigDigitto_radix_digits_le// Extract little-endian radix digits// forced inline to get const-prop for radix=10get_radix_base/// Returns the greatest power of the radix for the `BigDigit` bit sizeget_half_radix_base/// Returns the greatest power of the radix for half the `BigDigit` bit sizegenerate_radix_bases/// Generate tables of the greatest power of each radix that is less that the given maximum. These/// are returned from `get_radix_base` to batch the multiplication/division of radix conversions on/// full `BigUint` values, operating on primitive integers as much as possible./// e.g. BASES_16[3] = (59049, 10) // 3¹⁰ fits in u16, but 3¹¹ is too big///      BASES_32[3] = (3486784401, 20)///      BASES_64[3] = (12157665459056928801, 40)/// Powers of two are not included, just zeroed, as they're implemented with shifts.test_radix_basestest_half_radix_bases// This uses stdlib features higher than the MSRV// 1.35cmp_slicediv_wide/// x86 and x86_64 can use a real `div` instruction.div_half/// For small divisors, we can divide without promoting to `DoubleBigDigit` by/// using half-size pieces of digit, like long-division.rem_digitsub_mul_digit_same_len/// Subtract a multiple./// a -= b * c/// Returns a borrow (if a < b then borrow > 0).div_rem_refdiv_rem_core/// An implementation of the base division algorithm./// Knuth, TAOCP vol 2 section 4.3.1, algorithm D, with an improvement from exercises 19-21.forward_all_scalar_binop_to_ref_valforward_scalar_val_val_binop_to_ref_valforward_scalar_val_ref_binop_to_ref_valforward_scalar_ref_ref_binop_to_ref_valimpl_rem_assign_scalarforward_val_assign_scalar// we can scalar %= BigUint for any scalar, including signed typesr" An iterator of `u32` digits representation of a `BigUint` or `BigInt`,"r" ordered least significant digit first."next_is_lolast_hi_is_zeror" An iterator of `u64` digits representation of a `BigUint` or `BigInt`,"test_iter_u32_digitstest_iter_u64_digitstest_iter_u32_digits_betest_iter_u64_digits_ben0invMontyReducerinv_mod_alt// k0 = -m**-1 mod 2**BITS. Algorithm from: Dumas, J.G. "On Newton–Raphson// Iteration for Multiplicative Inverses Modulo Prime Powers"./// Computes z mod m = x * y * 2 ** (-n*_W) mod m/// assuming k = -1/m mod 2**_W/// See Gueron, "Efficient Software Implementations of Modular Exponentiation"./// <https://eprint.iacr.org/2011/239.pdf>/// In the terminology of that paper, this is an "Almost Montgomery Multiplication":/// x and y are required to satisfy 0 <= z < 2**(n*_W) and then the result/// z is guaranteed to satisfy 0 <= z < 2**(n*_W), but it may not be < m.add_mul_vvwsub_vv/// The resulting carry c is either 0 or 1.add_ww/// z1<<_W + z0 = x+y+c, with c == 0 or 1mul_add_www/// z1 << _W + z0 = x * y + cmonty_modpow/// Calculates x ** y mod m using a fixed, 4-bit window.sub2mul_with_carrymac_digit/// Three argument multiply accumulate:/// acc += b * cbigint_from_slicemac3mul3sub_signtest_sub_signmontyplain_modpowtest_plain_modpowtest_pow_biguint// `cautious` is based on the function of the same name in `serde`, but specialized to `u32`:// https://github.com/dtolnay/serde/blob/399ef081ecc36d2f165ff1f6debdcbf6a1dc7efb/serde/src/private/size_hint.rs#L11-L22U32Visitorbiguint_shlbiguint_shl2biguint_shrbiguint_shr2// Subtract with borrow:__sub2rev// Only for the Sub impl. `a` and `b` must have same length.sub2revforward_ref_ref_binop/// A big unsigned integer type.// BigUint { data: Vec::new() };fixpoint// Reference:// Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 1.14// Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 1.13// nth_root, sqrt and cbrt use Newton's method to compute// principal root of a given degree for a given integer./// Converts the value of `self` to a [`BigUint`]./// A generic trait for converting a value to a [`BigUint`]./// Creates and initializes a [`BigUint`]./// The digits are in little-endian base matching `BigDigit`./// A constant `BigUint` with value 0, useful for static initialization./// Assign a value to a [`BigUint`]./// use num_bigint::BigUint;/// assert_eq!(BigUint::from_bytes_be(b"A"),///            BigUint::parse_bytes(b"65", 10).unwrap());/// assert_eq!(BigUint::from_bytes_be(b"AA"),///            BigUint::parse_bytes(b"16705", 10).unwrap());/// assert_eq!(BigUint::from_bytes_be(b"AB"),///            BigUint::parse_bytes(b"16706", 10).unwrap());/// assert_eq!(BigUint::from_bytes_be(b"Hello world!"),///            BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap());/// Creates and initializes a [`BigUint`]. The input slice must contain/// ascii/utf8 characters in [0-9a-zA-Z]./// The function `from_str_radix` from the `Num` trait provides the same logic/// for `&str` buffers./// use num_bigint::{BigUint, ToBigUint};/// assert_eq!(BigUint::parse_bytes(b"1234", 10), ToBigUint::to_biguint(&1234));/// assert_eq!(BigUint::parse_bytes(b"ABCD", 16), ToBigUint::to_biguint(&0xABCD));/// assert_eq!(BigUint::parse_bytes(b"G", 16), None);/// Creates and initializes a [`BigUint`]. Each `u8` of the input slice is/// use num_bigint::{BigUint};/// let inbase190 = &[15, 33, 125, 12, 14];/// let a = BigUint::from_radix_be(inbase190, 190).unwrap();/// assert_eq!(a.to_radix_be(190), inbase190);/// let inbase190 = &[14, 12, 125, 33, 15];/// Returns the byte representation of the [`BigUint`] in big-endian byte order./// let i = BigUint::parse_bytes(b"1125", 10).unwrap();/// assert_eq!(i.to_bytes_be(), vec![4, 101]);/// Returns the byte representation of the [`BigUint`] in little-endian byte order./// assert_eq!(i.to_bytes_le(), vec![101, 4]);/// Returns the `u32` digits representation of the [`BigUint`] ordered least significant digit/// assert_eq!(BigUint::from(1125u32).to_u32_digits(), vec![1125]);/// assert_eq!(BigUint::from(4294967295u32).to_u32_digits(), vec![4294967295]);/// assert_eq!(BigUint::from(4294967296u64).to_u32_digits(), vec![0, 1]);/// assert_eq!(BigUint::from(112500000000u64).to_u32_digits(), vec![830850304, 26]);/// Returns the `u64` digits representation of the [`BigUint`] ordered least significant digit/// assert_eq!(BigUint::from(1125u32).to_u64_digits(), vec![1125]);/// assert_eq!(BigUint::from(4294967295u32).to_u64_digits(), vec![4294967295]);/// assert_eq!(BigUint::from(4294967296u64).to_u64_digits(), vec![4294967296]);/// assert_eq!(BigUint::from(112500000000u64).to_u64_digits(), vec![112500000000]);/// assert_eq!(BigUint::from(1u128 << 64).to_u64_digits(), vec![0, 1]);/// Returns an iterator of `u32` digits representation of the [`BigUint`] ordered least/// assert_eq!(BigUint::from(1125u32).iter_u32_digits().collect::<Vec<u32>>(), vec![1125]);/// assert_eq!(BigUint::from(4294967295u32).iter_u32_digits().collect::<Vec<u32>>(), vec![4294967295]);/// assert_eq!(BigUint::from(4294967296u64).iter_u32_digits().collect::<Vec<u32>>(), vec![0, 1]);/// assert_eq!(BigUint::from(112500000000u64).iter_u32_digits().collect::<Vec<u32>>(), vec![830850304, 26]);/// Returns an iterator of `u64` digits representation of the [`BigUint`] ordered least/// assert_eq!(BigUint::from(1125u32).iter_u64_digits().collect::<Vec<u64>>(), vec![1125]);/// assert_eq!(BigUint::from(4294967295u32).iter_u64_digits().collect::<Vec<u64>>(), vec![4294967295]);/// assert_eq!(BigUint::from(4294967296u64).iter_u64_digits().collect::<Vec<u64>>(), vec![4294967296]);/// assert_eq!(BigUint::from(112500000000u64).iter_u64_digits().collect::<Vec<u64>>(), vec![112500000000]);/// assert_eq!(BigUint::from(1u128 << 64).iter_u64_digits().collect::<Vec<u64>>(), vec![0, 1]);/// let i = BigUint::parse_bytes(b"ff", 16).unwrap();/// assert_eq!(BigUint::from(0xFFFFu64).to_radix_be(159),///            vec![2, 94, 27]);/// based u8 number./// assert_eq!(BigUint::from(0xFFFFu64).to_radix_le(159),///            vec![27, 94, 2]);/// Determines the fewest bits necessary to express the [`BigUint`]./// Strips off trailing zero bigdigits - comparisons require the last element in the vector to/// be nonzero./// Returns a normalized [`BigUint`]./// Returns `(self ^ exponent) % modulus`./// Panics if the modulus is zero./// This solves for `x` in the interval `[0, modulus)` such that `self * x ≡ 1 (mod modulus)`./// The solution exists if and only if `gcd(self, modulus) == 1`./// let m = BigUint::from(383_u32);/// assert_eq!(BigUint::zero().modinv(&m), None);/// assert_eq!(BigUint::one().modinv(&m), Some(BigUint::one()));/// let a = BigUint::from(271_u32);/// assert_eq!(x, BigUint::from(106_u32));/// assert!((a * x % m).is_one());/// see [Roots::sqrt](https://docs.rs/num-integer/0.1/num_integer/trait.Roots.html#method.sqrt)/// see [Roots::cbrt](https://docs.rs/num-integer/0.1/num_integer/trait.Roots.html#method.cbrt)./// see [Roots::nth_root](https://docs.rs/num-integer/0.1/num_integer/trait.Roots.html#tymethod.nth_root)./// Returns the number of least-significant bits that are ones./// Returns the number of one bits./// Returns whether the bit in the given position is set/// Sets or clears the bit in the given position/// Note that setting a bit greater than the current bit length, a reallocation may be needed/// to store the new digitsu32_chunk_to_u64/// Convert a `u32` chunk (len is either 1 or 2) to a single `u64` digitcfg_32_or_testr" Combine four `u32`s into a single `u128`."u32_to_u128r" Split a single `u128` into four `u32`."u32_from_u128test_u32_u128test_u128_u32_roundtripbigrandBigIntErrorKind__description/// The error type returned when a checked conversion regarding big integer fails.into_original/// Extract the original value, if available. The value will be available/// if the type before conversion was either [`BigInt`] or [`BigUint`].// A [`BigDigit`] is a [`BigUint`]'s composing element.// A [`DoubleBigDigit`] is the internal type used to do the computations.  Its// size is the double of the size of [`BigDigit`].HALF_BITSLO_MASKget_higet_lofrom_doublebigdigit/// Split one [`DoubleBigDigit`] into two [`BigDigit`]s.to_doublebigdigit/// Join two [`BigDigit`]s into one [`DoubleBigDigit`].// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT//! Big Integer Types for Rust//! * A [`BigUint`] is unsigned and represented as a vector of digits.//! * A [`BigInt`] is signed and is a combination of [`BigUint`] and [`Sign`].//! Common numerical operations are overloaded, so we can treat them//! the same way we treat other numbers.//! use num_bigint::BigUint;//! use num_traits::One;//! // Calculate large fibonacci numbers.//! fn fib(n: usize) -> BigUint {//!     let mut f0 = BigUint::ZERO;//!     let mut f1 = BigUint::one();//!     for _ in 0..n {//!         let f2 = f0 + &f1;//!         f0 = f1;//!         f1 = f2;//!     f0//! // This is a very large number.//! println!("fib(1000) = {}", fib(1000));//! It's easy to generate large random numbers://! use num_bigint::{ToBigInt, RandBigInt};//! let mut rng = rand::thread_rng();//! let a = rng.gen_bigint(1000);//! let low = -10000.to_bigint().unwrap();//! let high = 10000.to_bigint().unwrap();//! let b = rng.gen_bigint_range(&low, &high);//! // Probably an even larger number.//! println!("{}", a * b);//! See the "Features" section for instructions for enabling random number generation.//! The `std` crate feature is enabled by default, which enables [`std::error::Error`]//! implementations and some internal use of floating point approximations. This can be disabled by//! depending on `num-bigint` with `default-features = false`. Either way, the `alloc` crate is//! always required for heap allocation of the `BigInt`/`BigUint` digits.//! ### Random Generation//! `num-bigint` supports the generation of random big integers when the `rand`//! feature is enabled. To enable it include rand as//! rand = "0.8"//! num-bigint = { version = "0.4", features = ["rand"] }//! Note that you must use the version of `rand` that `num-bigint` is compatible//! with: `0.8`.//! ### Arbitrary Big Integers//! `num-bigint` supports `arbitrary` and `quickcheck` features to implement//! [`arbitrary::Arbitrary`] and [`quickcheck::Arbitrary`], respectively, for both `BigInt` and//! `BigUint`. These are useful for fuzzing and other forms of randomized testing.//! ### Serialization//! The `serde` feature adds implementations of [`Serialize`][serde::Serialize] and//! [`Deserialize`][serde::Deserialize] for both `BigInt` and `BigUint`. Their serialized data is//! generated portably, regardless of platform differences like the internal digit size.//! ## Compatibility//! The `num-bigint` crate is tested for rustc 1.60 and greater.cfg_digit_expr/// use this if val_val_binop is already implemented and the reversed order is required// Forward scalar to ref-val, when reusing storage is not helpful// Forward everything to ref-ref, when reusing storage is not helpfulforward_all_binop_to_val_ref// Forward everything to val-ref, so LHS storage can be reused// Forward everything to val-ref, commutatively, so either LHS or RHS storage can be reusedimpl_to_primitiveto_isize// Returns None if Complex part is non-zeroimpl_from_primitivetest_to_primitivetest_from_primitivetest_num_casttest_as_primitive// impl_to_primitive// impl_from_primitiveSeal/// The type used to represent the real coefficients of this complex number./// Returns `true` if this value is `NaN` and false otherwise./// Returns `true` if this value is positive infinity or negative infinity and/// false otherwise./// Returns `true` if the number is neither zero, infinite,/// [subnormal](http://en.wikipedia.org/wiki/Denormal_number), or `NaN`./// Take the reciprocal (inverse) of a number, `1/x`. See also [Complex::finv]./// Raises `self` to a signed integer power./// Raises `self` to a real power.powc/// Raises `self` to a complex power./// Take the square root of a number./// Returns `base^(self)`./// Take the cubic root of a number.re/// Returns the real part of the number.im/// Returns the imaginary part of the number./// Returns the absolute value of the number. See also [Complex::norm]l1_norm/// Returns the L1 norm `|re| + |im|` -- the [Manhattan distance] from the origin./// [Manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry/// Computes the argument of the number.conj/// Computes the complex conjugate of the number./// Formula: `a+bi -> a-bi`ComplexFloat/// Generic trait for floating point complex numbers./// This trait defines methods which are common to complex floating point/// numbers and regular floating point numbers./// This trait is sealed to prevent it from being implemented by anything other/// than floating point scalars and [Complex] floats.forward_ref// `Complex::l1_norm` uses `Signed::abs` to let it work// for integers too, but we can just use `Float::abs`.// `Complex::is_*` methods use `T: FloatCore`, but we// have `T: Float` that can do them as well.complex_float_0_0i_0_1i_1_0i_1_1iclosefclose_to_tolftest_exp2test_exptest_powitest_powztest_log2test_log10test_conjtest_is_nantest_is_infinitetest_is_finitetest_is_normaltest_arg// for constants before Rust 1.43.// Keeps us from accidentally creating a recursive impl rather than a real one.ReImComplexDistribution/// A generic random value distribution for complex numbers./// Creates a complex distribution from independent/// distributions of the real and imaginary parts.test_rngstandard_f64generic_standard_f64generic_uniform_f64generic_mixed_f64generic_uniform_i32//! Rand implementations for complex numbersConstOneInvMulAdd/// Real portion of the complex number/// Imaginary portion of the complex number/// A complex number in Cartesian form./// ## Representation and Foreign Function Interface Compatibility/// `Complex<T>` is memory layout compatible with an array `[T; 2]`./// Note that `Complex<F>` where F is a floating point type is **only** memory/// layout compatible with C's complex types, **not** necessarily calling/// convention compatible.  This means that for FFI you can only pass/// `Complex<F>` behind a pointer, not as a value./// Example of extern function declaration./// use num_complex::Complex;/// use std::os::raw::c_int;///     fn zaxpy_(n: *const c_int, alpha: *const Complex<f64>,///               x: *const Complex<f64>, incx: *const c_int,///               y: *mut Complex<f64>, incy: *const c_int);Complex32/// Alias for a [`Complex<f32>`]c32/// Create a new [`Complex<f32>`] with arguments that can convert [`Into<f32>`]./// use num_complex::{c32, Complex32};/// assert_eq!(c32(1u8, 2), Complex32::new(1.0, 2.0));/// Note: ambiguous integer literals in Rust will [default] to `i32`, which does **not** implement/// `Into<f32>`, so a call like `c32(1, 2)` will result in a type error. The example above uses a/// suffixed `1u8` to set its type, and then the `2` can be inferred as the same type./// [default]: https://doc.rust-lang.org/reference/expressions/literal-expr.html#integer-literal-expressionsComplex64/// Alias for a [`Complex<f64>`]c64/// Create a new [`Complex<f64>`] with arguments that can convert [`Into<f64>`]./// use num_complex::{c64, Complex64};/// assert_eq!(c64(1, 2), Complex64::new(1.0, 2.0));/// Create a new `Complex`/// Returns the imaginary unit./// See also [`Complex::I`].norm_sqr/// Returns the square of the norm (since `T` doesn't necessarily/// have a sqrt function), i.e. `re^2 + im^2`./// Multiplies `self` by the scalar `t`.unscale/// Divides `self` by the scalar `t`.powu/// Raises `self` to an unsigned integer power./// Returns the complex conjugate. i.e. `re - i im`/// Returns `1/self`cis/// Create a new Complex with a given phase: `exp(i * phase)`./// See [cis (mathematics)](https://en.wikipedia.org/wiki/Cis_(mathematics)).norm/// Calculate |self|/// Calculate the principal Arg of self.to_polar/// Convert to polar form (r, theta), such that/// `self = r * exp(i * theta)`from_polar/// Convert a polar representation into a complex number./// Computes `e^(self)`, where `e` is the base of the natural logarithm./// Computes the principal value of natural logarithm of `self`./// This function has one branch cut:/// * `(-∞, 0]`, continuous from above./// The branch satisfies `-π ≤ arg(ln(z)) ≤ π`./// Computes the principal value of the square root of `self`./// * `(-∞, 0)`, continuous from above./// The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`./// Computes the principal value of the cube root of `self`./// The branch satisfies `-π/3 ≤ arg(cbrt(z)) ≤ π/3`./// Note that this does not match the usual result for the cube root of/// negative real numbers. For example, the real cube root of `-8` is `-2`,/// but the principal complex cube root of `-8` is `1 + i√3`./// Raises `self` to a floating point power./// Returns the logarithm of `self` with respect to an arbitrary base./// Raises a floating point number to the complex power `self`./// Computes the sine of `self`./// Computes the cosine of `self`./// Computes the tangent of `self`./// Computes the principal value of the inverse sine of `self`./// This function has two branch cuts:/// * `(-∞, -1)`, continuous from above./// * `(1, ∞)`, continuous from below./// The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`./// Computes the principal value of the inverse cosine of `self`./// The branch satisfies `0 ≤ Re(acos(z)) ≤ π`./// Computes the principal value of the inverse tangent of `self`./// * `(-∞i, -i]`, continuous from the left./// * `[i, ∞i)`, continuous from the right./// The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`./// Computes the hyperbolic sine of `self`./// Computes the hyperbolic cosine of `self`./// Computes the hyperbolic tangent of `self`./// Computes the principal value of inverse hyperbolic sine of `self`./// * `(-∞i, -i)`, continuous from the left./// * `(i, ∞i)`, continuous from the right./// The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`./// Computes the principal value of inverse hyperbolic cosine of `self`./// * `(-∞, 1)`, continuous from above./// The branch satisfies `-π ≤ Im(acosh(z)) ≤ π` and `0 ≤ Re(acosh(z)) < ∞`./// Computes the principal value of inverse hyperbolic tangent of `self`./// * `(-∞, -1]`, continuous from above./// * `[1, ∞)`, continuous from below./// The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`.finv/// Returns `1/self` using floating-point operations./// This may be more accurate than the generic `self.inv()` in cases/// where `self.norm_sqr()` would overflow to ∞ or underflow to 0./// use num_complex::Complex64;/// let c = Complex64::new(1e300, 1e300);/// // The generic `inv()` will overflow./// assert!(!c.inv().is_normal());/// // But we can do better for `Float` types./// let inv = c.finv();/// assert!(inv.is_normal());/// println!("{:e}", inv);/// let expected = Complex64::new(5e-301, -5e-301);/// assert!((inv - expected).norm() < 1e-315);fdiv/// Returns `self/other` using floating-point operations./// This may be more accurate than the generic `Div` implementation in cases/// where `other.norm_sqr()` would overflow to ∞ or underflow to 0./// let a = Complex64::new(2.0, 3.0);/// let b = Complex64::new(1e300, 1e300);/// // Generic division will overflow./// assert!(!(a / b).is_normal());/// let quotient = a.fdiv(b);/// assert!(quotient.is_normal());/// println!("{:e}", quotient);/// let expected = Complex64::new(2.5e-300, 5e-301);/// assert!((quotient - expected).norm() < 1e-315);/// Computes `2^(self)`./// Computes the principal value of log base 2 of `self`./// Computes the principal value of log base 10 of `self`./// Checks if the given complex number is NaN/// Checks if the given complex number is infinite/// Checks if the given complex number is finite/// Checks if the given complex number is normalforward_all_binop// arithmetic// (a + i b) + (c + i d) == (a + c) + i (b + d)// (a + i b) - (c + i d) == (a - c) + i (b - d)// (a + i b) * (c + i d) == (a*c - b*d) + i (a*d + b*c)// (a + i b) * (c + i d) + (e + i f) == ((a*c + e) - b*d) + i (a*d + (b*c + f))// (a + i b) / (c + i d) == [(a + i b) * (c - i d)] / (c*c + d*d)//   == [(a*c + b*d) / (c*c + d*d)] + i [(b*c - a*d) / (c*c + d*d)]div_trunc/// Find the gaussian integer corresponding to the true ratio rounded towards zero.MulAddAssignNumAssignmul_add_assign// (a + i b) * (c + i d) + (e + i f) == ((a*c + e) - b*d) + i (b*c + (a*d + f))forward_op_assignopassignreal_arithmetic/// A constant `Complex` 0./// A constant `Complex` 1./// A constant `Complex` _i_, the imaginary unit.write_complex// string conversionsfrom_str_genericParseComplexError/// Parses `a +/- bi`; `ai +/- b`; `a`; or `bi` where `a` and `b` are of type `T`/// `radix` must be <= 18; larger radix would include *i* and *j* as digits,/// which cannot be supported./// The conversion returns an error if 18 <= radix <= 36; it panics if radix > 36./// The elements of `T` are parsed using `Num::from_str_radix` too, and errors/// (or panics) from that are reflected here as well.ComplexErrorKindExprErrorUnsupportedRadixexpr_errorunsupported_radix_neg1_1i_05_05iall_consts_4_2i_1_infi_neg1_infi_1_nani_neg1_nani_inf_0i_neginf_1i_neginf_neg1i_inf_1i_inf_neg1i_neginf_infi_inf_infi_neginf_nani_inf_nani_nan_0i_nan_1i_nan_neg1i_nan_nanitest_conststest_scale_unscaletest_invtest_divide_by_zero_naturaltest_inv_zerotest_l1_normtest_powtest_cistest_norm// FIXME #7158: (maybe?) currently failing on x86.test_polar_convclose_to_tolclose_naninf// Version that also works if re or im are +inf, -inf, or nanclose_naninf_to_toltest_lntest_powctest_powftest_logtest_some_expf_casestest_sqrttest_sqrt_realtest_sqrt_imagtest_cbrttest_cbrt_realtest_cbrt_imagtest_sintest_costest_tantest_asintest_acostest_atantest_sinhtest_coshtest_tanhtest_asinhtest_acoshtest_atanhtest_exp_lntest_exp2_logtest_trig_to_hyperbolictest_trig_identitiestest_hyperbolic_identitestest_a_op_b// Test both a + b and a += btest_op// Test both a + b and a + &btest_subtest_multest_mul_add_floattest_mul_addtest_divtest_remtest_negcomplex_arithmetictest_div_rem_gaussiantest_to_stringtest_string_formattingtest_hashsettest_is_nan_special_casestest_from_str_radixtest_from_str_radix_failtest_from_str_failtest_sumtest_prodtest_zerotest_one//! Complex numbers.//! The `num-complex` crate is tested for rustc 1.60 and greater.// FIXME #1284: handle complex NaN & infinity etc. This// probably doesn't map to C's _Complex correctly.// Op Assignpowf_impl// Note: we can't add `impl<T: Float> Pow<T> for Complex<T>` because new blanket impls are a// breaking change.  Someone could already have their own `F` and `impl Pow<F> for Complex<F>`// which would conflict.  We can't even do this in a new semantic version, because we have to// gate it on the "std" feature, and features can't add breaking changes either.// These blanket impls are OK, because both the target type and the trait parameter would be// foreign to anyone else trying to implement something that would overlap, raising E0117.CastSignedCastUnsignedTruncate/// Anonymously import all extension traits./// This allows you to use the methods without worrying about polluting the namespace or importing/// them individually./// use num_conv::prelude::*;impl_integerExtendTargetSealedTruncateTargetSealed/// The signed integer type with the same size as `Self`.cast_signed/// Cast an integer to the signed integer of the same size./// Cast to a signed integer of the same size./// This trait is implemented for all integers. Unsigned to signed casts are equivalent to/// `0.wrapping_add_signed(value)`, while signed to signed casts are an identity conversion./// # use num_conv::CastSigned;/// assert_eq!(u8::MAX.cast_signed(), -1_i8);/// assert_eq!(u16::MAX.cast_signed(), -1_i16);/// assert_eq!(u32::MAX.cast_signed(), -1_i32);/// assert_eq!(u64::MAX.cast_signed(), -1_i64);/// assert_eq!(u128::MAX.cast_signed(), -1_i128);/// assert_eq!(usize::MAX.cast_signed(), -1_isize);/// assert_eq!(0_i8.cast_signed(), 0_i8);/// assert_eq!(0_i16.cast_signed(), 0_i16);/// assert_eq!(0_i32.cast_signed(), 0_i32);/// assert_eq!(0_i64.cast_signed(), 0_i64);/// assert_eq!(0_i128.cast_signed(), 0_i128);/// assert_eq!(0_isize.cast_signed(), 0_isize);/// The unsigned integer type with the same size as `Self`.cast_unsigned/// Cast an integer to the unsigned integer of the same size./// Cast to an unsigned integer of the same size./// This trait is implemented for all integers. Signed to unsigned casts are equivalent to/// `0.wrapping_add_unsigned(value)`, while unsigned to unsigned casts are an identity conversion./// # use num_conv::CastUnsigned;/// assert_eq!((-1_i8).cast_unsigned(), u8::MAX);/// assert_eq!((-1_i16).cast_unsigned(), u16::MAX);/// assert_eq!((-1_i32).cast_unsigned(), u32::MAX);/// assert_eq!((-1_i64).cast_unsigned(), u64::MAX);/// assert_eq!((-1_i128).cast_unsigned(), u128::MAX);/// assert_eq!((-1_isize).cast_unsigned(), usize::MAX);/// assert_eq!(0_u8.cast_unsigned(), 0_u8);/// assert_eq!(0_u16.cast_unsigned(), 0_u16);/// assert_eq!(0_u32.cast_unsigned(), 0_u32);/// assert_eq!(0_u64.cast_unsigned(), 0_u64);/// assert_eq!(0_u128.cast_unsigned(), 0_u128);/// assert_eq!(0_usize.cast_unsigned(), 0_usize);ExtendTarget/// A type that can be used with turbofish syntax in [`Extend::extend`]./// It is unlikely that you will want to use this trait directly. You are probably looking for the/// [`Extend`] trait.TruncateTarget/// A type that can be used with turbofish syntax in [`Truncate::truncate`]./// [`Truncate`] trait./// Extend an integer to an integer of the same size or larger, preserving its value./// Extend to an integer of the same size or larger, preserving its value./// # use num_conv::Extend;/// assert_eq!(0_u8.extend::<u16>(), 0_u16);/// assert_eq!(0_u16.extend::<u32>(), 0_u32);/// assert_eq!(0_u32.extend::<u64>(), 0_u64);/// assert_eq!(0_u64.extend::<u128>(), 0_u128);/// assert_eq!((-1_i8).extend::<i16>(), -1_i16);/// assert_eq!((-1_i16).extend::<i32>(), -1_i32);/// assert_eq!((-1_i32).extend::<i64>(), -1_i64);/// assert_eq!((-1_i64).extend::<i128>(), -1_i128);/// Truncate an integer to an integer of the same size or smaller, preserving the least/// significant bits./// Truncate to an integer of the same size or smaller, preserving the least significant bits./// # use num_conv::Truncate;/// assert_eq!(u16::MAX.truncate::<u8>(), u8::MAX);/// assert_eq!(u32::MAX.truncate::<u16>(), u16::MAX);/// assert_eq!(u64::MAX.truncate::<u32>(), u32::MAX);/// assert_eq!(u128::MAX.truncate::<u64>(), u64::MAX);/// assert_eq!((-1_i16).truncate::<i8>(), -1_i8);/// assert_eq!((-1_i32).truncate::<i16>(), -1_i16);/// assert_eq!((-1_i64).truncate::<i32>(), -1_i32);/// assert_eq!((-1_i128).truncate::<i64>(), -1_i64);impl_cast_signedimpl_cast_unsignedimpl_extendimpl_truncate//! `num_conv` is a crate to convert between integer types without using `as` casts. This provides//! better certainty when refactoring, makes the exact behavior of code more explicit, and allows//! using turbofish syntax."proc-macro""512"/// Try to parse the tokens, or else return a compilation error/// suggesting "full-syntax" if that's not already enabled.dummy_const_trick// Within `exp`, you can bring things into scope with `extern crate`.// We don't want to assume that `num_traits::` is in scope - the user may have imported it under a// different name, or may have imported it in a non-toplevel module (common when putting impls// behind a feature gate).// Solution: let's just generate `extern crate num_traits as _num_traits` and then refer to// `_num_traits` in the derived code.  However, macros are not allowed to produce `extern crate`// statements at the toplevel.// Solution: let's generate `mod _impl_foo` and import num_traits within that.  However, now we// lose access to private members of the surrounding module.  This is a problem if, for example,// we're deriving for a newtype, where the inner type is defined in the same module, but not// exported.// Solution: use the dummy const trick.  For some reason, `extern crate` statements are allowed// here, but everything from the surrounding module is in scope.  This trick is taken from serde.unrawnewtype_inner// If `data` is a newtype, return the type it's wrapping.importNumTraits/// Derives [`num_traits::FromPrimitive`][from] for simple enums and newtypes./// [from]: https://docs.rs/num-traits/0.2/num_traits/cast/trait.FromPrimitive.html/// Simple enums can be derived:/// # extern crate num_derive;/// #[derive(FromPrimitive)]/// enum Color {///     Red,///     Blue,///     Green = 42,/// Enums that contain data are not allowed:///     Rgb(u8, u8, u8),///     Hsv(u8, u8, u8),/// Structs are not allowed:/// struct Color {///     r: u8,///     g: u8,///     b: u8,to_primitive/// Derives [`num_traits::ToPrimitive`][to] for simple enums and newtypes./// [to]: https://docs.rs/num-traits/0.2/num_traits/cast/trait.ToPrimitive.html/// #[derive(ToPrimitive)]NEWTYPE_ONLYnum_ops/// Derives [`num_traits::NumOps`][num_ops] for newtypes.  The inner type must already implement/// `NumOps`./// [num_ops]: https://docs.rs/num-traits/0.2/num_traits/trait.NumOps.html/// Note that, since `NumOps` is really a trait alias for `Add + Sub + Mul + Div + Rem`, this macro/// generates impls for _those_ traits.  Furthermore, in all generated impls, `RHS=Self` and/// `Output=Self`.num_cast/// Derives [`num_traits::NumCast`][num_cast] for newtypes.  The inner type must already implement/// `NumCast`./// [num_cast]: https://docs.rs/num-traits/0.2/num_traits/cast/trait.NumCast.html/// Derives [`num_traits::Zero`][zero] for newtypes.  The inner type must already implement `Zero`./// [zero]: https://docs.rs/num-traits/0.2/num_traits/identities/trait.Zero.html/// Derives [`num_traits::One`][one] for newtypes.  The inner type must already implement `One`./// [one]: https://docs.rs/num-traits/0.2/num_traits/identities/trait.One.html/// Derives [`num_traits::Num`][num] for newtypes.  The inner type must already implement `Num`./// [num]: https://docs.rs/num-traits/0.2/num_traits/trait.Num.html/// Derives [`num_traits::Float`][float] for newtypes.  The inner type must already implement/// `Float`./// [float]: https://docs.rs/num-traits/0.2/num_traits/float/trait.Float.html// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT//! Procedural macros to derive numeric traits in Rust.//! num-traits = "0.2"//! num-derive = "0.3"//! Then you can derive traits on your own types://! extern crate num_derive;//! #[derive(FromPrimitive, ToPrimitive)]//!     Red,//!     Blue,//!     Green,//! ## Explicit import//! By default the `num_derive` procedural macros assume that the//! `num_traits` crate is a direct dependency. If `num_traits` is instead//! a transitive dependency, the `num_traits` helper attribute can be//! used to tell `num_derive` to use a specific identifier for its imports.//! // Lets pretend this is a transitive dependency from another crate//! // reexported as `some_other_ident`.//! extern crate num_traits as some_other_ident;//! #[num_traits = "some_other_ident"]issue16// We need "syn/full" to parse macros.// Use `--nocapture` to check the quality of the error message./// macro_rules! get_an_isize {///     () => (0_isize)/// #[derive(num_derive::FromPrimitive)]/// pub enum CLikeEnum {///     VarA = get_an_isize!(), // error without "syn/full"///     VarB = 2,//! This module uses doc-tests on modules for `compile_fail`average_ceil/// Returns the ceiling value of the average of `self` and `other`./// -- `⌈(self + other)/2⌉`/// use num_integer::Average;/// assert_eq!(( 3).average_ceil(&10),  7);/// assert_eq!((-2).average_ceil(&-5), -3);/// assert_eq!(( 4).average_ceil(& 4),  4);/// assert_eq!(u8::max_value().average_ceil(&2), 129);/// assert_eq!(i8::min_value().average_ceil(&-1), -64);/// assert_eq!(i8::min_value().average_ceil(&i8::max_value()), 0);average_floor/// Returns the floor value of the average of `self` and `other`./// -- `⌊(self + other)/2⌋`/// assert_eq!(( 3).average_floor(&10),  6);/// assert_eq!((-2).average_floor(&-5), -4);/// assert_eq!(( 4).average_floor(& 4),  4);/// assert_eq!(u8::max_value().average_floor(&2), 128);/// assert_eq!(i8::min_value().average_floor(&-1), -65);/// assert_eq!(i8::min_value().average_floor(&i8::max_value()), -1);Average/// Provides methods to compute the average of two integers, without overflows./// Returns the ceil value of the average of `self` and `other`.// The Henry Gordon Dietz implementation as shown in the Hacker's Delight,// see http://aggregate.org/MAGIC/#Average%20of%20Integers/// Returns the floor value of the average of `x` and `y` --/// see [Average::average_floor](trait.Average.html#tymethod.average_floor)./// Returns the ceiling value of the average of `x` and `y` --/// see [Average::average_ceil](trait.Average.html#tymethod.average_ceil).average/// Floored integer division./// ~~~/// # use num_integer::Integer;/// assert!(( 8).div_floor(& 3) ==  2);/// assert!(( 8).div_floor(&-3) == -3);/// assert!((-8).div_floor(& 3) == -3);/// assert!((-8).div_floor(&-3) ==  2);/// assert!(( 1).div_floor(& 2) ==  0);/// assert!(( 1).div_floor(&-2) == -1);/// assert!((-1).div_floor(& 2) == -1);/// assert!((-1).div_floor(&-2) ==  0);/// Floored integer modulo, satisfying:/// # let n = 1; let d = 1;/// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n)/// assert!(( 8).mod_floor(& 3) ==  2);/// assert!(( 8).mod_floor(&-3) == -1);/// assert!((-8).mod_floor(& 3) ==  1);/// assert!((-8).mod_floor(&-3) == -2);/// assert!(( 1).mod_floor(& 2) ==  1);/// assert!(( 1).mod_floor(&-2) == -1);/// assert!((-1).mod_floor(& 2) ==  1);/// assert!((-1).mod_floor(&-2) == -1);/// Ceiled integer division./// assert_eq!(( 8).div_ceil( &3),  3);/// assert_eq!(( 8).div_ceil(&-3), -2);/// assert_eq!((-8).div_ceil( &3), -2);/// assert_eq!((-8).div_ceil(&-3),  3);/// assert_eq!(( 1).div_ceil( &2), 1);/// assert_eq!(( 1).div_ceil(&-2), 0);/// assert_eq!((-1).div_ceil( &2), 0);/// assert_eq!((-1).div_ceil(&-2), 1);/// Greatest Common Divisor (GCD)./// assert_eq!(6.gcd(&8), 2);/// assert_eq!(7.gcd(&3), 1);/// Lowest Common Multiple (LCM)./// assert_eq!(7.lcm(&3), 21);/// assert_eq!(2.lcm(&4), 4);/// assert_eq!(0.lcm(&0), 0);/// Greatest Common Divisor (GCD) and/// Potentially more efficient than calling `gcd` and `lcm`/// individually for identical inputs./// assert_eq!(10.gcd_lcm(&4), (2, 20));/// assert_eq!(8.gcd_lcm(&9), (1, 72));extended_gcd/// Greatest common divisor and Bézout coefficients./// # use num_integer::{ExtendedGcd, Integer};/// # use num_traits::NumAssign;/// fn check<A: Copy + Integer + NumAssign>(a: A, b: A) -> bool {///     let ExtendedGcd { gcd, x, y, .. } = a.extended_gcd(&b);///     gcd == x * a + y * b/// assert!(check(10isize, 4isize));/// assert!(check(8isize,  9isize));/// Returns `true` if `self` is a multiple of `other`./// assert_eq!(9.is_multiple_of(&3), true);/// assert_eq!(3.is_multiple_of(&9), false);/// Returns `true` if the number is even./// assert_eq!(3.is_even(), false);/// assert_eq!(4.is_even(), true);/// Returns `true` if the number is odd./// assert_eq!(3.is_odd(), true);/// assert_eq!(4.is_odd(), false);/// Simultaneous truncated integer division and modulus./// Returns `(quotient, remainder)`./// assert_eq!(( 8).div_rem( &3), ( 2,  2));/// assert_eq!(( 8).div_rem(&-3), (-2,  2));/// assert_eq!((-8).div_rem( &3), (-2, -2));/// assert_eq!((-8).div_rem(&-3), ( 2, -2));/// assert_eq!(( 1).div_rem( &2), ( 0,  1));/// assert_eq!(( 1).div_rem(&-2), ( 0,  1));/// assert_eq!((-1).div_rem( &2), ( 0, -1));/// assert_eq!((-1).div_rem(&-2), ( 0, -1));/// Simultaneous floored integer division and modulus./// assert_eq!(( 8).div_mod_floor( &3), ( 2,  2));/// assert_eq!(( 8).div_mod_floor(&-3), (-3, -1));/// assert_eq!((-8).div_mod_floor( &3), (-3,  1));/// assert_eq!((-8).div_mod_floor(&-3), ( 2, -2));/// assert_eq!(( 1).div_mod_floor( &2), ( 0,  1));/// assert_eq!(( 1).div_mod_floor(&-2), (-1, -1));/// assert_eq!((-1).div_mod_floor( &2), (-1,  1));/// assert_eq!((-1).div_mod_floor(&-2), ( 0, -1));/// For signed types, `a.next_multiple_of(b) = a.prev_multiple_of(b.neg())`./// assert_eq!(( 16).next_multiple_of(& 8),  16);/// assert_eq!(( 23).next_multiple_of(& 8),  24);/// assert_eq!(( 16).next_multiple_of(&-8),  16);/// assert_eq!(( 23).next_multiple_of(&-8),  16);/// assert_eq!((-16).next_multiple_of(& 8), -16);/// assert_eq!((-23).next_multiple_of(& 8), -16);/// assert_eq!((-16).next_multiple_of(&-8), -16);/// assert_eq!((-23).next_multiple_of(&-8), -24);/// For signed types, `a.prev_multiple_of(b) = a.next_multiple_of(b.neg())`./// assert_eq!(( 16).prev_multiple_of(& 8),  16);/// assert_eq!(( 23).prev_multiple_of(& 8),  16);/// assert_eq!(( 16).prev_multiple_of(&-8),  16);/// assert_eq!(( 23).prev_multiple_of(&-8),  24);/// assert_eq!((-16).prev_multiple_of(& 8), -16);/// assert_eq!((-23).prev_multiple_of(& 8), -24);/// assert_eq!((-16).prev_multiple_of(&-8), -16);/// assert_eq!((-23).prev_multiple_of(&-8), -16);/// Decrements self by one./// let mut x: i32 = 43;/// x.dec();/// assert_eq!(x, 42);/// Increments self by one./// let mut x: i32 = 41;/// x.inc();/// Greatest common divisor and Bézout coefficients/// let e = isize::extended_gcd(a, b);/// assert_eq!(e.gcd, e.x*a + e.y*b);/// Simultaneous integer division and modulus/// Floored integer division/// Floored integer modulus/// Simultaneous floored integer division and modulus/// Ceiled integer division/// Calculates the Greatest Common Divisor (GCD) of the number and `other`. The/// result is always non-negative./// Lowest Common Multiple (LCM) of the number and `other`.impl_integer_for_isizer" Floored integer division"r" Floored integer modulo"r" Calculates `div_floor` and `mod_floor` simultaneously"r" Calculates the Greatest Common Divisor (GCD) of the number and"r" `other`. The result is always non-negative."r" Calculates the Lowest Common Multiple (LCM) of the number and"r" Calculates the Greatest Common Divisor (GCD) and"r" Lowest Common Multiple (LCM) of the number and `other`."r" Returns `true` if the number is a multiple of `other`."r" Returns `true` if the number is divisible by `2`"r" Returns `true` if the number is not divisible by `2`"r" Simultaneous truncated integer division and modulus."r" Rounds up to nearest multiple of argument."r" Rounds down to nearest multiple of argument."r" Checks that the division rule holds for:"r" - `n`: numerator (dividend)"r" - `d`: denominator (divisor)"r" - `qr`: quotient and remainder"test_division_ruletest_div_remtest_div_mod_floortest_gcdtest_gcd_cmp_with_euclideantest_gcd_min_valtest_gcd_min_val_min_valtest_gcd_min_val_0test_gcd_0_min_valtest_lcmtest_gcd_lcmtest_extended_gcd_lcmtest_eventest_oddtest_multiple_of_one_limitstest_integer_i8test_integer_i16test_integer_i32test_integer_i64test_integer_i128test_integer_isizeimpl_integer_for_usizer" Unsigned integer division. Returns the same result as `div` (`/`)."r" Unsigned integer modulo operation. Returns the same result as `rem` (`%`)."r" Calculates the Greatest Common Divisor (GCD) of the number and `other`"r" Calculates the Lowest Common Multiple (LCM) of the number and `other`."r" Returns `true` if the number is divisible by `2`."r" Returns `true` if the number is not divisible by `2`."test_is_multiple_oftest_integer_u8test_integer_u16test_integer_u32test_integer_u64test_integer_u128test_integer_usizeIterBinomial/// An iterator over binomial coefficients./// For a given n, iterate over all binomial coefficients binomial(n, k), for k=0...n./// Note that this might overflow, depending on `T`. For the primitive/// integer types, the following n are the largest ones for which there will/// be no overflow:/// type | n/// -----|---/// u8   | 10/// i8   |  9/// u16  | 18/// i16  | 17/// u32  | 34/// i32  | 33/// u64  | 67/// i64  | 66/// For larger n, `T` should be a bigint type.multiply_and_divide/// Calculate r * a / b, avoiding overflows and fractions./// Assumes that b divides r * a evenly.binomial/// Calculate the binomial coefficient./// Note that this might overflow, depending on `T`. For the primitive integer/// types, the following n are the largest ones possible such that there will/// be no overflow for any k:/// For larger n, consider using a bigint type for `T`.multinomial/// Calculate the multinomial coefficient.test_lcm_overflowtest_iter_binomialtest_binomialtest_multinomial//! Integer trait and functions.//! The `num-integer` crate is tested for rustc 1.31 and greater./// Returns the truncated principal `n`th root of an integer/// -- `if x >= 0 { ⌊ⁿ√x⌋ } else { ⌈ⁿ√x⌉ }`/// This is solving for `r` in `rⁿ = x`, rounding toward zero./// If `x` is positive, the result will satisfy `rⁿ ≤ x < (r+1)ⁿ`./// If `x` is negative and `n` is odd, then `(r-1)ⁿ < x ≤ rⁿ`./// Panics if `n` is zero:/// # use num_integer::Roots;/// println!("can't compute ⁰√x : {}", 123.nth_root(0));/// or if `n` is even and `self` is negative:/// println!("no imaginary numbers... {}", (-1).nth_root(10));/// use num_integer::Roots;/// let x: i32 = 12345;/// assert_eq!(x.nth_root(1), x);/// assert_eq!(x.nth_root(2), x.sqrt());/// assert_eq!(x.nth_root(3), x.cbrt());/// assert_eq!(x.nth_root(4), 10);/// assert_eq!(x.nth_root(13), 2);/// assert_eq!(x.nth_root(14), 1);/// assert_eq!(x.nth_root(std::u32::MAX), 1);/// assert_eq!(std::i32::MAX.nth_root(30), 2);/// assert_eq!(std::i32::MAX.nth_root(31), 1);/// assert_eq!(std::i32::MIN.nth_root(31), -2);/// assert_eq!((std::i32::MIN + 1).nth_root(31), -1);/// assert_eq!(std::u32::MAX.nth_root(31), 2);/// assert_eq!(std::u32::MAX.nth_root(32), 1);/// Returns the truncated principal square root of an integer -- `⌊√x⌋`/// This is solving for `r` in `r² = x`, rounding toward zero./// The result will satisfy `r² ≤ x < (r+1)²`./// Panics if `self` is less than zero:/// println!("no imaginary numbers... {}", (-1).sqrt());/// assert_eq!((x * x).sqrt(), x);/// assert_eq!((x * x + 1).sqrt(), x);/// assert_eq!((x * x - 1).sqrt(), x - 1);/// Returns the truncated principal cube root of an integer --/// `if x >= 0 { ⌊∛x⌋ } else { ⌈∛x⌉ }`/// This is solving for `r` in `r³ = x`, rounding toward zero./// If `x` is positive, the result will satisfy `r³ ≤ x < (r+1)³`./// If `x` is negative, then `(r-1)³ < x ≤ r³`./// let x: i32 = 1234;/// assert_eq!((x * x * x).cbrt(), x);/// assert_eq!((x * x * x + 1).cbrt(), x);/// assert_eq!((x * x * x - 1).cbrt(), x - 1);/// assert_eq!((-(x * x * x)).cbrt(), -x);/// assert_eq!((-(x * x * x + 1)).cbrt(), -x);/// assert_eq!((-(x * x * x - 1)).cbrt(), -(x - 1));/// Provides methods to compute an integer's square root, cube root,/// and arbitrary `n`th root./// Returns the truncated principal square root of an integer --/// see [Roots::sqrt](trait.Roots.html#method.sqrt)./// see [Roots::cbrt](trait.Roots.html#method.cbrt)./// Returns the truncated principal `n`th root of an integer --/// see [Roots::nth_root](trait.Roots.html#tymethod.nth_root).signed_rootsunsigned_roots/// Numerator./// Denominator./// Represents the ratio between two numbers./// Alias for a `Ratio` of machine-sized integers./// Alias for a `Ratio` of 32-bit-sized integers.Rational64/// Alias for a `Ratio` of 64-bit-sized integers./// Creates a `Ratio` without checking for `denom == 0` or reducing./// **There are several methods that will panic if used on a `Ratio` with/// `denom == 0`.**/// Gets an immutable reference to the numerator./// Gets an immutable reference to the denominator./// These method are `const` for Rust 1.31 and later./// Creates a new `Ratio`./// **Panics if `denom` is zero.**/// Creates a `Ratio` representing the integer `t`./// Converts to an integer, rounding towards zero./// Returns true if the rational number is an integer (denominator is 1)./// Puts self into lowest terms, with `denom` > 0.reduced/// Returns a reduced copy of self./// In general, it is not necessary to use this method, as the only/// method of procuring a non-reduced fraction is through `new_raw`./// Returns the reciprocal./// **Panics if the `Ratio` is zero.**into_recip/// Rounds towards minus infinity./// Rounds towards plus infinity./// Rounds to the nearest integer. Rounds half-way cases away from zero./// Rounds towards zero./// Returns the fractional part of a number, with division rounded towards zero./// Satisfies `self == self.trunc() + self.fract()`./// Raises the `Ratio` to the power of an exponent.// From integer// From pair (through the `new` constructor)// NB: We can't just `#[derive(Hash)]`, because it needs to agree// with `Eq` even for non-reduced ratios.iter_sum_product// (a/b) / (c/d) = (a/gcd_ac)*(d/gcd_bd) / ((c/gcd_ac)*(b/gcd_bd))// a/b * c/d = (a/gcd_ad)*(c/gcd_bc) / ((d/gcd_ad)*(b/gcd_bc))// a/b + c/1 = (a*1 + b*c) / (b*1) = (a + b*c) / b// a/b % c/1 = (a*1 % b*c) / (b*1) = (a % b*c) / b// a/b - c/1 = (a*1 - b*c) / (b*1) = (a - b*c) / b// a/b * c/1 = (a*c) / (b*1) = (a*c) / b// (a/b) / (c/1) = (a*1) / (b*c) = a / (b*c)arith_impl// a/b * c/d = (a*c)/(b*d)// (a/b) / (c/d) = (a*d)/(b*c)checked_arith_impl// As arith_impl! but for Checked{Add,Sub} traits// a/b + c/d = (lcm/b*a + lcm/d*c)/lcm, where lcm = lcm(b,d)// a/b - c/d = (lcm/b*a - lcm/d*c)/lcm, where lcm = lcm(b,d)ParseRatioError/// Parses `numer/denom` where the numbers are in base `radix`.impl_formatting// String conversions/// Parses `numer/denom` or just `numer`.RatioErrorKind// FIXME: Bubble up specific errorsZeroDenominatorfrom_primitive_integerapproximate_floatapproximate_float_unsigned// No Unsigned constraint because this also works on positive integers and is called// like that, see aboveto_primitive_smallto_primitive_64ratio_to_f64/// Converts a ratio of `T` to an f64./// In addition to stated trait bounds, `T` must be able to hold numbers 56 bits larger than/// the largest of `numer` and `denom`. This is automatically true if `T` is `BigInt`._NEG2_15_16_1_2_1_8_1_15_1_16_3_2_5_2_NEG1_2_1_NEG2_NEG1_NEG2_1_3_NEG1_3_2_3_NEG2_3_MIN_MIN_P1_MAX_MAX_M1_BILLIONto_bigtest_test_constantstest_new_reducetest_new_zerotest_approximate_floattest_cmptest_cmp_overflowtest_to_integertest_numertest_denomtest_is_integerNoStdTesterWRITE_ERRassert_fmt_eqtest_add_overflowtest_sub_overflowtest_mul_overflowtest_div_overflowtest_rem_overflowtest_div_0test_checked_failurestest_checked_zerostest_checked_mintest_checked_maxtest_checked_min_maxarithtest_roundtest_fracttest_reciptest_recip_failtest_signedtest_into_pairtest_from_pairratio_iter_sumratio_iter_producttest_num_zerotest_num_onetest_ratio_to_i64test_ratio_to_f64//! Rational numbers//! The `num-rational` crate is tested for rustc 1.31 and greater.// Ratio ops often use other "suspicious" ops// Comparisons// Mathematically, comparing a/b and c/d is the same as comparing a*d and b*c, but it's very easy// for those multiplications to overflow fixed-size integers, so we need to take care.pow_unsigned_implpow_signed_impl// pub use real::Real; // NOTE: Don't do this, it breaks `use num_traits::*;`.CheckedShlCheckedShrWrappingAddWrappingMulWrappingSubsaturatingNumOpsNumRefRefNumNumAssignOpsNumAssignRefFloatErrorKind//! Numeric traits for generic mathematics//! This version of the crate only exists to re-export compatible//! items from num-traits 0.2.  Please consider updating!// Re-exports from num-traits 0.2!// Note: the module structure is explicitly re-created, rather than re-exporting en masse,// so we won't expose any items that may be added later in the new version.// FIXME (#5527): These should be associated constants/// Returns the smallest finite number this type can represent/// Returns the largest finite number this type can represent/// Numbers which have upper and lower boundsLowerBounded/// Numbers which have lower bounds// FIXME: With a major version bump, this should be a supertrait insteadUpperBounded/// Numbers which have upper boundsbounded_implfor_each_tuple_for_each_tuplebounded_tuplewrapping_boundedwrapping_bounded_i128wrapping_is_bounded/// Converts the value of `self` to an `isize`. If the value cannot be/// represented by an `isize`, then `None` is returned./// Converts the value of `self` to an `i8`. If the value cannot be/// represented by an `i8`, then `None` is returned./// Converts the value of `self` to an `i16`. If the value cannot be/// represented by an `i16`, then `None` is returned./// Converts the value of `self` to an `i32`. If the value cannot be/// represented by an `i32`, then `None` is returned./// Converts the value of `self` to an `i64`. If the value cannot be/// represented by an `i64`, then `None` is returned./// Converts the value of `self` to an `i128`. If the value cannot be/// represented by an `i128` (`i64` under the default implementation), then/// The default implementation converts through `to_i64()`. Types implementing/// this trait should override this method if they can represent a greater range./// Converts the value of `self` to a `usize`. If the value cannot be/// represented by a `usize`, then `None` is returned./// Converts the value of `self` to a `u8`. If the value cannot be/// represented by a `u8`, then `None` is returned./// Converts the value of `self` to a `u16`. If the value cannot be/// represented by a `u16`, then `None` is returned./// Converts the value of `self` to a `u32`. If the value cannot be/// represented by a `u32`, then `None` is returned./// Converts the value of `self` to a `u64`. If the value cannot be/// represented by a `u64`, then `None` is returned./// Converts the value of `self` to a `u128`. If the value cannot be/// represented by a `u128` (`u64` under the default implementation), then/// The default implementation converts through `to_u64()`. Types implementing/// Converts the value of `self` to an `f32`. Overflows may map to positive/// or negative inifinity, otherwise `None` is returned if the value cannot/// be represented by an `f32`./// Converts the value of `self` to an `f64`. Overflows may map to positive/// be represented by an `f64`./// The default implementation tries to convert through `to_i64()`, and/// failing that through `to_u64()`. Types implementing this trait should/// override this method if they can represent a greater range./// A generic trait for converting a value to a number./// A value can be represented by the target type when it lies within/// the range of scalars supported by the target type./// For example, a negative integer cannot be represented by an unsigned/// integer type, and an `i64` with a very high magnitude might not be/// convertible to an `i32`./// On the other hand, conversions with possible precision loss or truncation/// are admitted, like an `f32` with a decimal part to an integer type, or/// even a large `f64` saturating to `f32` infinity.impl_to_primitive_int_to_intimpl_to_primitive_int_to_uintimpl_to_primitive_intimpl_to_primitive_uint_to_intimpl_to_primitive_uint_to_uintimpl_to_primitive_uintimpl_to_primitive_float_to_floatfloat_to_int_unchecked// SAFETY: Must not be NaN or infinite; must be representable as the integer after truncating.// We already checked that the float is in the exclusive range `(MIN-1, MAX+1)`.impl_to_primitive_float_to_signed_intimpl_to_primitive_float_to_unsigned_intimpl_to_primitive_float/// Converts an `isize` to return an optional value of this type. If the/// value cannot be represented by this type, then `None` is returned./// Converts an `i8` to return an optional value of this type. If the/// Converts an `i16` to return an optional value of this type. If the/// Converts an `i32` to return an optional value of this type. If the/// Converts an `i64` to return an optional value of this type. If the/// Converts an `i128` to return an optional value of this type. If the/// The default implementation converts through `from_i64()`. Types implementing/// Converts a `usize` to return an optional value of this type. If the/// Converts an `u8` to return an optional value of this type. If the/// Converts an `u16` to return an optional value of this type. If the/// Converts an `u32` to return an optional value of this type. If the/// Converts an `u64` to return an optional value of this type. If the/// Converts an `u128` to return an optional value of this type. If the/// The default implementation converts through `from_u64()`. Types implementing/// Converts a `f32` to return an optional value of this type. If the/// Converts a `f64` to return an optional value of this type. If the/// The default implementation tries to convert through `from_i64()`, and/// failing that through `from_u64()`. Types implementing this trait should/// A generic trait for converting a number to a value.impl_to_primitive_wrappingimpl_from_primitive_wrapping/// Cast from one machine scalar to another./// # use num_traits as num;/// let twenty: f32 = num::cast(0x14).unwrap();/// assert_eq!(twenty, 20f32);/// Creates a number from another value that can be converted into/// a primitive via the `ToPrimitive` trait. If the source value cannot be/// represented by the target type, then `None` is returned./// An interface for casting between machine scalars.impl_num_cast/// Convert a value to another, using the `as` operator./// A generic interface for casting between machine scalars with the/// `as` operator, which admits narrowing and precision loss./// Implementers of this trait `AsPrimitive` should behave like a primitive/// numeric type (e.g. a newtype around another primitive), and the/// intended conversion must never fail./// # use num_traits::AsPrimitive;/// let three: i32 = (3.14159265f32).as_();/// assert_eq!(three, 3);/// **In Rust versions before 1.45.0**, some uses of the `as` operator were not entirely safe./// In particular, it was undefined behavior if/// a truncated floating point value could not fit in the target integer/// type ([#10184](https://github.com/rust-lang/rust/issues/10184))./// let x: u8 = (1.04E+17).as_(); // UBimpl_as_primitive/// Returns positive infinity./// use num_traits::float::FloatCore;/// use std::{f32, f64};/// fn check<T: FloatCore>(x: T) {///     assert!(T::infinity() == x);/// check(f32::INFINITY);/// check(f64::INFINITY);/// Returns negative infinity.///     assert!(T::neg_infinity() == x);/// check(f32::NEG_INFINITY);/// check(f64::NEG_INFINITY);/// Returns NaN./// fn check<T: FloatCore>() {///     let n = T::nan();///     assert!(n != n);/// check::<f32>();/// check::<f64>();/// Returns `-0.0`./// fn check<T: FloatCore>(n: T) {///     let z = T::neg_zero();///     assert!(z.is_zero());///     assert!(T::one() / z == n);/// Returns the smallest finite value that this type can represent.///     assert!(T::min_value() == x);/// check(f32::MIN);/// check(f64::MIN);/// Returns the smallest positive, normalized value that this type can represent.///     assert!(T::min_positive_value() == x);/// check(f32::MIN_POSITIVE);/// check(f64::MIN_POSITIVE);/// Returns epsilon, a small positive value.///     assert!(T::epsilon() == x);/// check(f32::EPSILON);/// check(f64::EPSILON);/// Returns the largest finite value that this type can represent.///     assert!(T::max_value() == x);/// check(f32::MAX);/// check(f64::MAX);/// Returns `true` if the number is NaN./// fn check<T: FloatCore>(x: T, p: bool) {///     assert!(x.is_nan() == p);/// check(f32::NAN, true);/// check(f32::INFINITY, false);/// check(f64::NAN, true);/// check(0.0f64, false);/// Returns `true` if the number is infinite.///     assert!(x.is_infinite() == p);/// check(f32::INFINITY, true);/// check(f32::NEG_INFINITY, true);/// check(f32::NAN, false);/// check(f64::INFINITY, true);/// check(f64::NEG_INFINITY, true);/// Returns `true` if the number is neither infinite or NaN.///     assert!(x.is_finite() == p);/// check(f32::MAX, true);/// check(f64::NEG_INFINITY, false);/// check(f64::MIN_POSITIVE, true);/// check(f64::NAN, false);/// Returns `true` if the number is neither zero, infinite, subnormal or NaN.///     assert!(x.is_normal() == p);is_subnormal/// Returns `true` if the number is [subnormal]./// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308_f64/// let max = f64::MAX;/// let lower_than_min = 1.0e-308_f64;/// let zero = 0.0_f64;/// assert!(!min.is_subnormal());/// assert!(!max.is_subnormal());/// assert!(!zero.is_subnormal());/// assert!(!f64::NAN.is_subnormal());/// assert!(!f64::INFINITY.is_subnormal());/// assert!(lower_than_min.is_subnormal());/// [subnormal]: https://en.wikipedia.org/wiki/Subnormal_number/// fn check<T: FloatCore>(x: T, c: FpCategory) {///     assert!(x.classify() == c);/// check(f32::INFINITY, FpCategory::Infinite);/// check(f32::MAX, FpCategory::Normal);/// check(f64::NAN, FpCategory::Nan);/// check(f64::MIN_POSITIVE, FpCategory::Normal);/// check(f64::MIN_POSITIVE / 2.0, FpCategory::Subnormal);/// check(0.0f64, FpCategory::Zero);/// Returns the largest integer less than or equal to a number./// fn check<T: FloatCore>(x: T, y: T) {///     assert!(x.floor() == y);/// check(f32::INFINITY, f32::INFINITY);/// check(0.9f32, 0.0);/// check(1.0f32, 1.0);/// check(1.1f32, 1.0);/// check(-0.0f64, 0.0);/// check(-0.9f64, -1.0);/// check(-1.0f64, -1.0);/// check(-1.1f64, -2.0);/// check(f64::MIN, f64::MIN);/// Returns the smallest integer greater than or equal to a number.///     assert!(x.ceil() == y);/// check(0.9f32, 1.0);/// check(1.1f32, 2.0);/// check(-0.9f64, -0.0);/// check(-1.1f64, -1.0);/// Returns the nearest integer to a number. Round half-way cases away from `0.0`.///     assert!(x.round() == y);/// check(0.4f32, 0.0);/// check(0.5f32, 1.0);/// check(0.6f32, 1.0);/// check(-0.4f64, 0.0);/// check(-0.5f64, -1.0);/// check(-0.6f64, -1.0);/// Return the integer part of a number.///     assert!(x.trunc() == y);/// Returns the fractional part of a number.///     assert!(x.fract() == y);/// check(f32::MAX, 0.0);/// check(0.75f32, 0.75);/// check(1.0f32, 0.0);/// check(1.25f32, 0.25);/// check(-0.75f64, -0.75);/// check(-1.0f64, 0.0);/// check(-1.25f64, -0.25);/// check(f64::MIN, 0.0);/// Computes the absolute value of `self`. Returns `FloatCore::nan()` if the/// number is `FloatCore::nan()`.///     assert!(x.abs() == y);/// check(0.0f64, 0.0);/// check(-1.0f64, 1.0);/// check(f64::MIN, f64::MAX);/// - `1.0` if the number is positive, `+0.0` or `FloatCore::infinity()`/// - `-1.0` if the number is negative, `-0.0` or `FloatCore::neg_infinity()`/// - `FloatCore::nan()` if the number is `FloatCore::nan()`///     assert!(x.signum() == y);/// check(f32::INFINITY, 1.0);/// check(3.0f32, 1.0);/// check(0.0f32, 1.0);/// check(-0.0f64, -1.0);/// check(-3.0f64, -1.0);/// check(f64::MIN, -1.0);/// Returns `true` if `self` is positive, including `+0.0` and/// `FloatCore::infinity()`, and `FloatCore::nan()`.///     assert!(x.is_sign_positive() == p);/// check(0.0f32, true);/// check(-0.0f64, false);/// check(-f64::NAN, false);/// Returns `true` if `self` is negative, including `-0.0` and/// `FloatCore::neg_infinity()`, and `-FloatCore::nan()`.///     assert!(x.is_sign_negative() == p);/// check(f32::MAX, false);/// check(0.0f32, false);/// check(-0.0f64, true);/// check(f64::MIN_POSITIVE, false);/// check(-f64::NAN, true);/// fn check<T: FloatCore>(x: T, y: T, min: T) {///     assert!(x.min(y) == min);/// check(1.0f32, 2.0, 1.0);/// check(f32::NAN, 2.0, 2.0);/// check(1.0f64, -2.0, -2.0);/// check(1.0f64, f64::NAN, 1.0);/// fn check<T: FloatCore>(x: T, y: T, max: T) {///     assert!(x.max(y) == max);/// check(1.0f32, 2.0, 2.0);/// check(1.0f32, f32::NAN, 1.0);/// check(-1.0f64, 2.0, 2.0);/// check(-1.0f64, f64::NAN, -1.0);/// A value bounded by a minimum and a maximum///  If input is less than min then this returns min.///  If input is greater than max then this returns max.///  Otherwise this returns input./// **Panics** in debug mode if `!(min <= max)`./// fn check<T: FloatCore>(val: T, min: T, max: T, expected: T) {///     assert!(val.clamp(min, max) == expected);/// check(1.0f32, 0.0, 2.0, 1.0);/// check(1.0f32, 2.0, 3.0, 2.0);/// check(3.0f32, 0.0, 2.0, 2.0);/// check(1.0f64, 0.0, 2.0, 1.0);/// check(1.0f64, 2.0, 3.0, 2.0);/// check(3.0f64, 0.0, 2.0, 2.0);/// Returns the reciprocal (multiplicative inverse) of the number.///     assert!(x.recip() == y);///     assert!(y.recip() == x);/// check(f32::INFINITY, 0.0);/// check(2.0f32, 0.5);/// check(-0.25f64, -4.0);/// check(-0.0f64, f64::NEG_INFINITY);/// Raise a number to an integer power./// Using this function is generally faster than using `powf`/// fn check<T: FloatCore>(x: T, exp: i32, powi: T) {///     assert!(x.powi(exp) == powi);/// check(9.0f32, 2, 81.0);/// check(1.0f32, -2, 1.0);/// check(10.0f64, 20, 1e20);/// check(4.0f64, -2, 0.0625);/// check(-1.0f64, std::i32::MIN, 1.0);/// Converts to degrees, assuming the number is in radians./// fn check<T: FloatCore>(rad: T, deg: T) {///     assert!(rad.to_degrees() == deg);/// check(0.0f32, 0.0);/// check(f32::consts::PI, 180.0);/// check(f64::consts::FRAC_PI_4, 45.0);/// check(f64::INFINITY, f64::INFINITY);/// Converts to radians, assuming the number is in degrees./// fn check<T: FloatCore>(deg: T, rad: T) {///     assert!(deg.to_radians() == rad);/// check(180.0, f32::consts::PI);/// check(45.0, f64::consts::FRAC_PI_4);/// Returns the mantissa, base 2 exponent, and sign as integers, respectively./// The original number can be recovered by `sign * mantissa * 2 ^ exponent`./// fn check<T: FloatCore>(x: T, m: u64, e: i16, s:i8) {///     let (mantissa, exponent, sign) = x.integer_decode();///     assert_eq!(mantissa, m);///     assert_eq!(exponent, e);///     assert_eq!(sign, s);/// check(2.0f32, 1 << 23, -22, 1);/// check(-2.0f32, 1 << 23, -22, -1);/// check(f32::INFINITY, 1 << 23, 105, 1);/// check(f64::NEG_INFINITY, 1 << 52, 972, -1);/// Generic trait for floating point numbers that works with `no_std`./// This trait implements a subset of the `Float` trait./// Returns the `NaN` value./// use num_traits::Float;/// let nan: f32 = Float::nan();/// Returns the infinite value./// let infinity: f32 = Float::infinity();/// assert!(infinity.is_infinite());/// assert!(!infinity.is_finite());/// assert!(infinity > f32::MAX);/// Returns the negative infinite value./// let neg_infinity: f32 = Float::neg_infinity();/// assert!(neg_infinity.is_infinite());/// assert!(!neg_infinity.is_finite());/// assert!(neg_infinity < f32::MIN);/// use num_traits::{Zero, Float};/// let inf: f32 = Float::infinity();/// let zero: f32 = Zero::zero();/// let neg_zero: f32 = Float::neg_zero();/// assert_eq!(zero, neg_zero);/// assert_eq!(7.0f32/inf, zero);/// assert_eq!(zero * 10.0, zero);/// let x: f64 = Float::min_value();/// assert_eq!(x, f64::MIN);/// let x: f64 = Float::min_positive_value();/// assert_eq!(x, f64::MIN_POSITIVE);/// let x: f64 = Float::epsilon();/// assert_eq!(x, f64::EPSILON);/// The default implementation will panic if `f32::EPSILON` cannot/// be cast to `Self`./// let x: f64 = Float::max_value();/// assert_eq!(x, f64::MAX);/// let nan = f64::NAN;/// let f = 7.0;/// let f = 7.0f32;/// let neg_inf: f32 = Float::neg_infinity();/// let nan: f32 = f32::NAN;/// [subnormal][subnormal], or `NaN`./// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32/// let max = f32::MAX;/// let lower_than_min = 1.0e-40_f32;/// let zero = 0.0f32;/// assert!(!f32::NAN.is_normal());/// assert!(!f32::INFINITY.is_normal());/// [subnormal]: http://en.wikipedia.org/wiki/Subnormal_number/// let num = 12.4f32;/// let inf = f32::INFINITY;/// let f = 3.99;/// let g = 3.0;/// assert_eq!(f.floor(), 3.0);/// assert_eq!(g.floor(), 3.0);/// let f = 3.01;/// let g = 4.0;/// assert_eq!(f.ceil(), 4.0);/// assert_eq!(g.ceil(), 4.0);/// Returns the nearest integer to a number. Round half-way cases away from/// `0.0`./// let f = 3.3;/// let g = -3.3;/// assert_eq!(f.round(), 3.0);/// assert_eq!(g.round(), -3.0);/// let g = -3.7;/// assert_eq!(f.trunc(), 3.0);/// assert_eq!(g.trunc(), -3.0);/// let x = 3.5;/// let y = -3.5;/// let abs_difference_x = (x.fract() - 0.5).abs();/// let abs_difference_y = (y.fract() - (-0.5)).abs();/// Computes the absolute value of `self`. Returns `Float::nan()` if the/// number is `Float::nan()`./// let abs_difference_x = (x.abs() - x).abs();/// let abs_difference_y = (y.abs() - (-y)).abs();/// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`/// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`/// - `Float::nan()` if the number is `Float::nan()`/// let f = 3.5;/// assert_eq!(f.signum(), 1.0);/// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);/// assert!(f64::NAN.signum().is_nan());/// Returns `true` if `self` is positive, including `+0.0`,/// `Float::infinity()`, and `Float::nan()`./// let nan: f64 = f64::NAN;/// let neg_nan: f64 = -f64::NAN;/// let g = -7.0;/// assert!(nan.is_sign_positive());/// assert!(!neg_nan.is_sign_positive());/// Returns `true` if `self` is negative, including `-0.0`,/// `Float::neg_infinity()`, and `-Float::nan()`./// assert!(!nan.is_sign_negative());/// assert!(neg_nan.is_sign_negative());/// Using `mul_add` can be more performant than an unfused multiply-add if/// the target architecture has a dedicated `fma` CPU instruction./// let m = 10.0;/// let x = 4.0;/// let b = 60.0;/// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();/// Take the reciprocal (inverse) of a number, `1/x`./// let x = 2.0;/// let abs_difference = (x.recip() - (1.0/x)).abs();/// let abs_difference = (x.powi(2) - x*x).abs();/// Raise a number to a floating point power./// let abs_difference = (x.powf(2.0) - x*x).abs();/// Returns NaN if `self` is a negative number./// let positive = 4.0;/// let negative = -4.0;/// let abs_difference = (positive.sqrt() - 2.0).abs();/// assert!(negative.sqrt().is_nan());/// let one = 1.0;/// let f = 2.0;/// let abs_difference = (f.exp2() - 4.0).abs();/// let ten = 10.0;/// let two = 2.0;/// // log10(10) - 1 == 0/// let abs_difference_10 = (ten.log(10.0) - 1.0).abs();/// // log2(2) - 1 == 0/// let abs_difference_2 = (two.log(2.0) - 1.0).abs();/// assert!(abs_difference_10 < 1e-10);/// let abs_difference = (two.log2() - 1.0).abs();/// let abs_difference = (ten.log10() - 1.0).abs();/// use std::f64::consts;/// let angle = consts::PI;/// let abs_difference = (angle.to_degrees() - 180.0).abs();/// let angle = 180.0_f64;/// let abs_difference = (angle.to_radians() - consts::PI).abs();/// let x = 1.0;/// let y = 2.0;/// Clamps a value between a min and max./// let z = 3.0;/// assert_eq!(x.clamp(y, z), 2.0);/// The positive difference of two numbers./// * If `self <= other`: `0:0`/// * Else: `self - other`/// let x = 3.0;/// let y = -3.0;/// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();/// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();/// let x = 8.0;/// let abs_difference = (x.cbrt() - 2.0).abs();/// Calculate the length of the hypotenuse of a right-angle triangle given/// legs of length `x` and `y`./// let y = 3.0;/// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();/// let x = f64::consts::PI/2.0;/// let abs_difference = (x.sin() - 1.0).abs();/// let x = 2.0*f64::consts::PI;/// let abs_difference = (x.cos() - 1.0).abs();/// let x = f64::consts::PI/4.0;/// let abs_difference = (x.tan() - 1.0).abs();/// let f = f64::consts::PI / 2.0;/// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs();/// let f = f64::consts::PI / 4.0;/// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs();/// let f = 1.0;/// let abs_difference = (f.tan().atan() - 1.0).abs();/// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`)./// let pi = f64::consts::PI;/// // All angles from horizontal right (+x)/// // 45 deg counter-clockwise/// let x1 = 3.0;/// let y1 = -3.0;/// // 135 deg clockwise/// let x2 = -3.0;/// let y2 = 3.0;/// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();/// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();/// let f = x.sin_cos();/// let x = 7.0;/// // e^(ln(7)) - 1/// let abs_difference = (x.ln().exp_m1() - 6.0).abs();/// let x = f64::consts::E - 1.0;/// // ln(1 + (e - 1)) == ln(e) == 1/// let abs_difference = (x.ln_1p() - 1.0).abs();/// let e = f64::consts::E;/// let f = x.sinh();/// let g = (e*e - 1.0)/(2.0*e);/// let f = x.cosh();/// let g = (e*e + 1.0)/(2.0*e);/// let f = x.tanh();/// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));/// let f = x.sinh().asinh();/// let f = x.cosh().acosh();/// let f = e.tanh().atanh();/// let num = 2.0f32;/// // (8388608, -22, 1)/// let (mantissa, exponent, sign) = Float::integer_decode(num);/// let sign_f = sign as f32;/// let mantissa_f = mantissa as f32;/// let exponent_f = num.powf(exponent as f32);/// // 1 * 8388608 * 2^(-22) == 2/// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs();/// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of/// `sign` is returned./// let f = 3.5_f32;/// assert_eq!(f.copysign(0.42), 3.5_f32);/// assert_eq!(f.copysign(-0.42), -3.5_f32);/// assert_eq!((-f).copysign(0.42), 3.5_f32);/// assert_eq!((-f).copysign(-0.42), -3.5_f32);/// assert!(f32::nan().copysign(1.0).is_nan());/// Generic trait for floating point numbers/// This trait is only available with the `std` feature, or with the `libm` feature otherwise.float_impl_stdinteger_decode_f32integer_decode_f64float_const_impl"Return Euler’s number.""Return `1.0 / π`.""Return `1.0 / sqrt(2.0)`.""Return `2.0 / π`.""Return `2.0 / sqrt(π)`.""Return `π / 2.0`.""Return `π / 3.0`.""Return `π / 4.0`.""Return `π / 6.0`.""Return `π / 8.0`.""Return `ln(10.0)`.""Return `ln(2.0)`.""Return `log10(e)`.""Return `log2(e)`.""Return Archimedes’ constant `π`.""Return `sqrt(2.0)`.""Return the full circle constant `τ`."TAU"Return `log10(2.0)`.""Return `log2(10.0)`."/// Return the ordering between `self` and `other`./// [`PartialOrd`] and [`PartialEq`] implementations. For example,/// use num_traits::float::TotalOrder;/// fn check_eq<T: TotalOrder>(x: T, y: T) {///     assert_eq!(x.total_cmp(&y), Ordering::Equal);/// check_eq(f64::NAN, f64::NAN);/// check_eq(f32::NAN, f32::NAN);/// fn check_lt<T: TotalOrder>(x: T, y: T) {///     assert_eq!(x.total_cmp(&y), Ordering::Less);/// check_lt(-f64::NAN, f64::NAN);/// check_lt(f64::INFINITY, f64::NAN);/// check_lt(-0.0_f64, 0.0_f64);TotalOrder/// Trait for floating point numbers that provide an implementation/// of the `totalOrder` predicate as defined in the IEEE 754 (2008 revision)/// floating point standard.totalorder_implDEG_RAD_PAIRSconvert_deg_radconvert_deg_rad_stdto_degrees_roundingextra_logstest_copysignftest_copysign_generictest_subnormalsubnormal// FIXME: these doctests aren't actually helpful, because they're using and// testing the inherent methods directly, not going through `Float`./// Returns the additive identity element of `Self`, `0`./// # Purity/// This function should return the same result at all times regardless of/// external mutable state, for example values stored in TLS or in/// `static mut`s.// This cannot be an associated constant, because of bignums./// Sets `self` to the additive identity element of `Self`, `0`./// Returns `true` if `self` is equal to the additive identity./// Defines an additive identity element for `Self`./// # Laws/// a + 0 = a       ∀ a ∈ Self/// 0 + a = a       ∀ a ∈ Self/// The additive identity element of `Self`, `0`./// Defines an associated constant representing the additive identity element/// for `Self`.zero_impl/// Returns the multiplicative identity element of `Self`, `1`./// Sets `self` to the multiplicative identity element of `Self`, `1`./// Returns `true` if `self` is equal to the multiplicative identity./// For performance reasons, it's best to implement this manually./// After a semver bump, this method will be required, and the/// `where Self: PartialEq` bound will be removed./// Defines a multiplicative identity element for `Self`./// a * 1 = a       ∀ a ∈ Self/// 1 * a = a       ∀ a ∈ Self/// The multiplicative identity element of `Self`, `1`./// Defines an associated constant representing the multiplicative identity/// element for `Self`.one_impl/// Returns the additive identity, `0`./// Returns the multiplicative identity, `1`.wrapping_identitieswrapping_is_zerowrapping_is_one// Some helper functions provided for backwards compatibility./// use num_traits::PrimInt;/// let n = 0b01001100u8;/// assert_eq!(n.count_ones(), 3);/// assert_eq!(n.count_zeros(), 5);/// Returns the number of leading ones in the binary representation/// of `self`./// let n = 0xF00Du16;/// assert_eq!(n.leading_ones(), 4);/// Returns the number of leading zeros in the binary representation/// let n = 0b0101000u16;/// assert_eq!(n.leading_zeros(), 10);/// Returns the number of trailing ones in the binary representation/// let n = 0xBEEFu16;/// assert_eq!(n.trailing_ones(), 4);/// Returns the number of trailing zeros in the binary representation/// assert_eq!(n.trailing_zeros(), 3);/// Shifts the bits to the left by a specified amount, `n`, wrapping/// the truncated bits to the end of the resulting integer./// let n = 0x0123456789ABCDEFu64;/// let m = 0x3456789ABCDEF012u64;/// assert_eq!(n.rotate_left(12), m);/// Shifts the bits to the right by a specified amount, `n`, wrapping/// the truncated bits to the beginning of the resulting integer./// let m = 0xDEF0123456789ABCu64;/// assert_eq!(n.rotate_right(12), m);signed_shl/// Shifts the bits to the left by a specified amount, `n`, filling/// zeros in the least significant bits./// This is bitwise equivalent to signed `Shl`./// let m = 0x3456789ABCDEF000u64;/// assert_eq!(n.signed_shl(12), m);signed_shr/// Shifts the bits to the right by a specified amount, `n`, copying/// the "sign bit" in the most significant bits even for unsigned types./// This is bitwise equivalent to signed `Shr`./// let n = 0xFEDCBA9876543210u64;/// let m = 0xFFFFEDCBA9876543u64;/// assert_eq!(n.signed_shr(12), m);unsigned_shl/// This is bitwise equivalent to unsigned `Shl`./// let n = 0x0123456789ABCDEFi64;/// let m = 0x3456789ABCDEF000i64;/// assert_eq!(n.unsigned_shl(12), m);unsigned_shr/// Shifts the bits to the right by a specified amount, `n`, filling/// zeros in the most significant bits./// This is bitwise equivalent to unsigned `Shr`./// let n = -8i8; // 0b11111000/// let m = 62i8; // 0b00111110/// assert_eq!(n.unsigned_shr(2), m);/// let m = 0xEFCDAB8967452301u64;/// assert_eq!(n.swap_bytes(), m);/// Reverses the order of bits in the integer./// The least significant bit becomes the most significant bit, second least-significant bit/// becomes second most-significant bit, etc./// let n = 0x12345678u32;/// let m = 0x1e6a2c48u32;/// assert_eq!(n.reverse_bits(), m);/// assert_eq!(0u32.reverse_bits(), 0);/// Convert an integer from big endian to the target's endianness.///     assert_eq!(u64::from_be(n), n)///     assert_eq!(u64::from_be(n), n.swap_bytes())/// Convert an integer from little endian to the target's endianness.///     assert_eq!(u64::from_le(n), n)///     assert_eq!(u64::from_le(n), n.swap_bytes())/// Convert `self` to big endian from the target's endianness.///     assert_eq!(n.to_be(), n)///     assert_eq!(n.to_be(), n.swap_bytes())/// Convert `self` to little endian from the target's endianness.///     assert_eq!(n.to_le(), n)///     assert_eq!(n.to_le(), n.swap_bytes())/// assert_eq!(2i32.pow(4), 16);/// Generic trait for primitive integers./// The `PrimInt` trait is an abstraction over the builtin primitive integer types (e.g., `u8`,/// `u32`, `isize`, `i128`, ...). It inherits the basic numeric traits and extends them with/// bitwise operators and non-wrapping arithmetic./// The trait explicitly inherits `Copy`, `Eq`, `Ord`, and `Sized`. The intention is that all/// types implementing this trait behave like primitive types that are passed by value by default/// and behave like builtin integers. Furthermore, the types are expected to expose the integer/// value in binary representation and support bitwise operators. The standard bitwise operations/// (e.g., bitwise-and, bitwise-or, right-shift, left-shift) are inherited and the trait extends/// these with introspective queries (e.g., `PrimInt::count_ones()`, `PrimInt::leading_zeros()`),/// bitwise combinators (e.g., `PrimInt::rotate_left()`), and endianness converters (e.g.,/// `PrimInt::to_be()`)./// All `PrimInt` types are expected to be fixed-width binary integers. The width can be queried/// via `T::zero().count_zeros()`. The trait currently lacks a way to query the width at/// compile-time./// While a default implementation for all builtin primitive integers is provided, the trait is in/// no way restricted to these. Other integer types that fulfil the requirements are free to/// implement the trait was well./// This trait and many of the method names originate in the unstable `core::num::Int` trait from/// the rust standard library. The original trait was never stabilized and thus removed from theone_per_bytereverse_bits_fallbackprim_int_impl// prim_int_impl!(type, signed, unsigned);reverse_bits_i128// Need to explicitly bring the crate in for inherent float methods// pub use real::{FloatCore, Real}; // NOTE: Don't do this, it breaks `use num_traits::*;`.CheckedNegCheckedRemeuclidSaturatingAddSaturatingMulSaturatingSubWrappingNegWrappingShlWrappingShr/// Convert from a string and radix (typically `2..=36`)./// use num_traits::Num;/// let result = <i32 as Num>::from_str_radix("27", 10);/// assert_eq!(result, Ok(27));/// let result = <i32 as Num>::from_str_radix("foo", 10);/// # Supported radices/// The exact range of supported radices is at the discretion of each type implementation. For/// primitive integers, this is implemented by the inherent `from_str_radix` methods in the/// standard library, which **panic** if the radix is not in the range from 2 to 36. The/// implementation in this crate for primitive floats is similar./// For third-party types, it is suggested that implementations should follow suit and at least/// accept `2..=36` without panicking, but an `Err` may be returned for any unsupported radix./// It's possible that a type might not even support the common radix 10, nor any, if string/// parsing doesn't make sense for that type./// The base trait for numeric types, covering `0` and `1` values,/// comparisons, basic numeric operations, and string conversion./// Generic trait for types implementing basic numeric operations/// This is automatically implemented for types which implement the operators./// The trait for `Num` types which also implement numeric operations taking/// the second operand by reference./// The trait for `Num` references which implement numeric operations, taking the/// second operand either by value or by reference./// This is automatically implemented for all types which implement the operators. It covers/// every type implementing the operations though, regardless of it being a reference or/// related to `Num`./// Generic trait for types implementing numeric assignment operators (like `+=`)./// The trait for `Num` types which also implement assignment operators./// The trait for `NumAssign` types which also implement assignment operations/// taking the second operand by reference.int_trait_impl// FIXME: core::num::ParseFloatError is stable in 1.0, but opaque to us,// so there's not really any way for us to reuse it.str_to_ascii_lower_eq_strfloat_trait_impl// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck// with this implementation ourselves until we want to make a breaking change.// (would have to drop it from `Num` though)clamp_min/// A value bounded by a minimum value///  `clamp_min(std::f32::NAN, 1.0)` preserves `NAN` different from `f32::min(std::f32::NAN, 1.0)`./// **Panics** in debug mode if `!(min == min)`. (This occurs if `min` is `NAN`.)clamp_max/// A value bounded by a maximum value///  `clamp_max(std::f32::NAN, 1.0)` preserves `NAN` different from `f32::max(std::f32::NAN, 1.0)`./// **Panics** in debug mode if `!(max == max)`. (This occurs if `max` is `NAN`.)clamp_testfrom_str_radix_unwrapfrom_str_radix_multi_byte_failfrom_str_radix_ignore_casewrapping_is_numwrapping_from_str_radixcheck_num_opscheck_numref_opscheck_refnum_opscheck_refref_opscheck_numassign_opscheck_numassignref_ops//! The `num-traits` crate is tested for rustc 1.60 and greater./// Forward a method to an inherent method or a base trait method.// not all are used in all features configurationsNumBytes/// Return the memory representation of this number as a byte array in big-endian byte order./// use num_traits::ToBytes;/// let bytes = ToBytes::to_be_bytes(&0x12345678u32);/// assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78]);/// Return the memory representation of this number as a byte array in little-endian byte order./// let bytes = ToBytes::to_le_bytes(&0x12345678u32);/// assert_eq!(bytes, [0x78, 0x56, 0x34, 0x12]);/// Return the memory representation of this number as a byte array in native byte order./// As the target platform's native endianness is used,/// portable code should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate, instead./// [`to_be_bytes`]: #method.to_be_bytes/// [`to_le_bytes`]: #method.to_le_bytes/// #[cfg(target_endian = "big")]/// let expected = [0x12, 0x34, 0x56, 0x78];/// #[cfg(target_endian = "little")]/// let expected = [0x78, 0x56, 0x34, 0x12];/// let bytes = ToBytes::to_ne_bytes(&0x12345678u32);/// assert_eq!(bytes, expected)/// Create a number from its representation as a byte array in big endian./// use num_traits::FromBytes;/// let value: u32 = FromBytes::from_be_bytes(&[0x12, 0x34, 0x56, 0x78]);/// assert_eq!(value, 0x12345678);/// Create a number from its representation as a byte array in little endian./// let value: u32 = FromBytes::from_le_bytes(&[0x78, 0x56, 0x34, 0x12]);/// Create a number from its memory representation as a byte array in native endianness./// portable code likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as appropriate instead./// [`from_be_bytes`]: #method.from_be_bytes/// [`from_le_bytes`]: #method.from_le_bytes/// let bytes = [0x12, 0x34, 0x56, 0x78];/// let bytes = [0x78, 0x56, 0x34, 0x12];/// let value: u32 = FromBytes::from_ne_bytes(&bytes);/// assert_eq!(value, 0x12345678)float_to_from_bytes_implint_to_from_bytes_implcheck_to_from_bytesconvert_between_int_and_bytesconvert_between_float_and_bytes/// Adds two numbers, checking for overflow. If overflow happens, `None` is/// Performs addition that returns `None` instead of wrapping around onchecked_impl/// Subtracts two numbers, checking for underflow. If underflow happens,/// Performs subtraction that returns `None` instead of wrapping around on underflow./// Multiplies two numbers, checking for underflow or overflow. If underflow/// or overflow happens, `None` is returned./// Performs multiplication that returns `None` instead of wrapping around on underflow or/// Divides two numbers, checking for underflow, overflow and division by/// zero. If any of that happens, `None` is returned./// Performs division that returns `None` instead of panicking on division by zero and instead of/// wrapping around on underflow and overflow./// Finds the remainder of dividing two numbers, checking for underflow, overflow and division/// by zero. If any of that happens, `None` is returned./// use num_traits::CheckedRem;/// use std::i32::MIN;/// assert_eq!(CheckedRem::checked_rem(&10, &7), Some(3));/// assert_eq!(CheckedRem::checked_rem(&10, &-7), Some(3));/// assert_eq!(CheckedRem::checked_rem(&-10, &7), Some(-3));/// assert_eq!(CheckedRem::checked_rem(&-10, &-7), Some(-3));/// assert_eq!(CheckedRem::checked_rem(&10, &0), None);/// assert_eq!(CheckedRem::checked_rem(&MIN, &1), Some(0));/// assert_eq!(CheckedRem::checked_rem(&MIN, &-1), None);/// Performs an integral remainder that returns `None` instead of panicking on division by zero and/// instead of wrapping around on underflow and overflow.checked_impl_unary/// Negates a number, returning `None` for results that can't be represented, like signed `MIN`/// values that can't be positive, or non-zero unsigned values that can't be negative./// use num_traits::CheckedNeg;/// assert_eq!(CheckedNeg::checked_neg(&1_i32), Some(-1));/// assert_eq!(CheckedNeg::checked_neg(&-1_i32), Some(1));/// assert_eq!(CheckedNeg::checked_neg(&MIN), None);/// assert_eq!(CheckedNeg::checked_neg(&0_u32), Some(0));/// assert_eq!(CheckedNeg::checked_neg(&1_u32), None);/// Performs negation that returns `None` if the result can't be represented./// Checked shift left. Computes `self << rhs`, returning `None`/// if `rhs` is larger than or equal to the number of bits in `self`./// use num_traits::CheckedShl;/// let x: u16 = 0x0001;/// assert_eq!(CheckedShl::checked_shl(&x, 0),  Some(0x0001));/// assert_eq!(CheckedShl::checked_shl(&x, 1),  Some(0x0002));/// assert_eq!(CheckedShl::checked_shl(&x, 15), Some(0x8000));/// assert_eq!(CheckedShl::checked_shl(&x, 16), None);/// Performs a left shift that returns `None` on shifts larger than/// or equal to the type width.checked_shift_impl/// Checked shift right. Computes `self >> rhs`, returning `None`/// use num_traits::CheckedShr;/// let x: u16 = 0x8000;/// assert_eq!(CheckedShr::checked_shr(&x, 0),  Some(0x8000));/// assert_eq!(CheckedShr::checked_shr(&x, 1),  Some(0x4000));/// assert_eq!(CheckedShr::checked_shr(&x, 15), Some(0x0001));/// assert_eq!(CheckedShr::checked_shr(&x, 16), None);/// Performs a right shift that returns `None` on shifts larger than/// `self = n * v + self.rem_euclid(v)`./// In other words, the result is `self / v` rounded to the integer `n`/// such that `self >= n * v`./// use num_traits::Euclid;/// let a: i32 = 7;/// let b: i32 = 4;/// assert_eq!(Euclid::div_euclid(&a, &b), 1); // 7 > 4 * 1/// assert_eq!(Euclid::div_euclid(&-a, &b), -2); // -7 >= 4 * -2/// assert_eq!(Euclid::div_euclid(&a, &-b), -1); // 7 >= -4 * -1/// assert_eq!(Euclid::div_euclid(&-a, &-b), 2); // -7 >= -4 * 2/// Calculates the least nonnegative remainder of `self (mod v)`./// In particular, the return value `r` satisfies `0.0 <= r < v.abs()` in/// result in `r == v.abs()`, violating the mathematical definition, if/// `self` is much smaller than `v.abs()` in magnitude and `self < 0.0`./// property `self == self.div_euclid(v) * v + self.rem_euclid(v)`/// approximatively./// assert_eq!(Euclid::rem_euclid(&a, &b), 3);/// assert_eq!(Euclid::rem_euclid(&-a, &b), 1);/// assert_eq!(Euclid::rem_euclid(&a, &-b), 3);/// assert_eq!(Euclid::rem_euclid(&-a, &-b), 1);/// Returns both the quotient and remainder from Euclidean division./// By default, it internally calls both `Euclid::div_euclid` and `Euclid::rem_euclid`,/// but it can be overridden in order to implement some optimization./// # use num_traits::Euclid;/// let x = 5u8;/// let y = 3u8;/// let div = Euclid::div_euclid(&x, &y);/// let rem = Euclid::rem_euclid(&x, &y);/// assert_eq!((div, rem), Euclid::div_rem_euclid(&x, &y));euclid_forward_impl/// Performs euclid division that returns `None` instead of panicking on division by zero/// and instead of wrapping around on underflow and overflow./// Finds the euclid remainder of dividing two numbers, checking for underflow, overflow and/// division by zero. If any of that happens, `None` is returned./// Returns both the quotient and remainder from checked Euclidean division./// By default, it internally calls both `CheckedEuclid::checked_div_euclid` and `CheckedEuclid::checked_rem_euclid`,/// # use num_traits::CheckedEuclid;/// let div = CheckedEuclid::checked_div_euclid(&x, &y);/// let rem = CheckedEuclid::checked_rem_euclid(&x, &y);/// assert_eq!(Some((div.unwrap(), rem.unwrap())), CheckedEuclid::checked_div_rem_euclid(&x, &y));checked_euclid_forward_impleuclid_unsignedeuclid_signedeuclid_floateuclid_checked/// The result after applying the operator./// Returns the multiplicative inverse of `self`./// use std::f64::INFINITY;/// use num_traits::Inv;/// assert_eq!(7.0.inv() * 7.0, 1.0);/// assert_eq!((-0.0).inv(), -INFINITY);/// Unary operator for retrieving the multiplicative inverse, or reciprocal, of a value.overflowing/// The resulting type after applying the fused multiply-add./// Performs the fused multiply-add operation `(self * a) + b`/// Note that `A` and `B` are `Self` by default, but this is not mandatory./// let m = 10.0_f32;/// let x = 4.0_f32;/// let b = 60.0_f32;/// assert!(abs_difference <= 100.0 * f32::EPSILON);/// Performs the fused multiply-add assignment operation `*self = (*self * a) + b`/// The fused multiply-add assignment operation `*self = (*self * a) + b`mul_add_implmul_add_assign_implmul_add_integermul_add_floatoverflowing_impl/// Returns a tuple of the sum along with a boolean indicating whether an arithmetic overflow would occur./// If an overflow would have occurred then the wrapped value is returned.OverflowingAdd/// Performs addition with a flag for overflow./// Returns a tuple of the difference along with a boolean indicating whether an arithmetic overflow would occur.OverflowingSub/// Performs substraction with a flag for overflow./// Returns a tuple of the product along with a boolean indicating whether an arithmetic overflow would occur.OverflowingMul/// Performs multiplication with a flag for overflow.test_overflowing_traits/// Saturating addition operator./// Returns a+b, saturating at the numeric bounds instead of overflowing./// Saturating subtraction operator./// Returns a-b, saturating at the numeric bounds instead of overflowing./// Saturating math operations. Deprecated, use `SaturatingAdd`, `SaturatingSub` and/// `SaturatingMul` instead.deprecated_saturating_implsaturating_impl/// Saturating addition. Computes `self + other`, saturating at the relevant high or low boundary of/// the type./// Performs addition that saturates at the numeric bounds instead of overflowing./// Saturating subtraction. Computes `self - other`, saturating at the relevant high or low boundary of/// Performs subtraction that saturates at the numeric bounds instead of overflowing./// Saturating multiplication. Computes `self * other`, saturating at the relevant high or low boundary of/// Performs multiplication that saturates at the numeric bounds instead of overflowing.test_saturating_traits// TODO: add SaturatingNeg for signed integer primitives once the saturating_neg() API is stable.wrapping_impl/// Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of/// Performs addition that wraps around on overflow./// Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary/// of the type./// Performs subtraction that wraps around on overflow./// Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary/// Performs multiplication that wraps around on overflow.wrapping_unary_impl/// Wrapping (modular) negation. Computes `-self`,/// wrapping around at the boundary of the type./// Since unsigned types do not have negative equivalents/// all applications of this function will wrap (except for `-0`)./// For values smaller than the corresponding signed type's maximum/// the result is the same as casting the corresponding signed value./// Any larger values are equivalent to `MAX + 1 - (val - MAX - 1)` where/// `MAX` is the corresponding signed type's maximum./// use num_traits::WrappingNeg;/// assert_eq!(100i8.wrapping_neg(), -100);/// assert_eq!((-100i8).wrapping_neg(), 100);/// assert_eq!((-128i8).wrapping_neg(), -128); // wrapped!/// Performs a negation that does not panic.wrapping_shift_impl/// Panic-free bitwise shift-left; yields `self << mask(rhs)`,/// where `mask` removes any high order bits of `rhs` that would/// cause the shift to exceed the bitwidth of the type./// use num_traits::WrappingShl;/// assert_eq!(WrappingShl::wrapping_shl(&x, 0),  0x0001);/// assert_eq!(WrappingShl::wrapping_shl(&x, 1),  0x0002);/// assert_eq!(WrappingShl::wrapping_shl(&x, 15), 0x8000);/// assert_eq!(WrappingShl::wrapping_shl(&x, 16), 0x0001);/// Performs a left shift that does not panic./// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,/// use num_traits::WrappingShr;/// assert_eq!(WrappingShr::wrapping_shr(&x, 0),  0x8000);/// assert_eq!(WrappingShr::wrapping_shr(&x, 1),  0x4000);/// assert_eq!(WrappingShr::wrapping_shr(&x, 15), 0x0001);/// assert_eq!(WrappingShr::wrapping_shr(&x, 16), 0x8000);/// Performs a right shift that does not panic.// Well this is a bit funny, but all the more appropriate.test_wrapping_traitswrapping_is_wrappingaddwrapping_is_wrappingsubwrapping_is_wrappingmulwrapping_is_wrappingnegwrapping_is_wrappingshlwrapping_is_wrappingshr/// Returns `self` to the power `rhs`./// use num_traits::Pow;/// assert_eq!(Pow::pow(10u32, 2u32), 100);/// Binary operator for raising a value to a power.float_impls/// Raises a value to the power of exp, using exponentiation by squaring./// Note that `0⁰` (`pow(0, 0)`) returns `1`. Mathematically this is undefined./// use num_traits::pow;/// assert_eq!(pow(2i8, 4), 16);/// assert_eq!(pow(6u8, 3), 216);/// assert_eq!(pow(0u8, 0), 1); // Be aware if this case affects you/// Raises a value to the power of exp, returning `None` if an overflow occurred./// Note that `0⁰` (`checked_pow(0, 0)`) returns `Some(1)`. Mathematically this is undefined./// Otherwise same as the `pow` function./// use num_traits::checked_pow;/// assert_eq!(checked_pow(2i8, 4), Some(16));/// assert_eq!(checked_pow(7i8, 8), None);/// assert_eq!(checked_pow(7u32, 8), Some(5_764_801));/// assert_eq!(checked_pow(0u32, 0), Some(1)); // Be aware if this case affect you// FIXME: these should be possible// pow_impl!(u8, u64);// pow_impl!(i16, u64);// pow_impl!(i8, u64);// pow_impl!(u16, u64);// pow_impl!(u32, u64);// pow_impl!(i32, u64);// pow_impl!(u64, u64);// pow_impl!(i64, u64);// pow_impl!(usize, u64);// pow_impl!(isize, u64);/// use num_traits::real::Real;/// let x: f64 = Real::min_value();/// let x: f64 = Real::min_positive_value();/// let x: f64 = Real::epsilon();/// let x: f64 = Real::max_value();/// assert!(::num_traits::Float::is_nan(f64::NAN.abs()));/// `Float::infinity()`, and with newer versions of Rust `f64::NAN`./// `Float::neg_infinity()`, and with newer versions of Rust `-f64::NAN`./// Raise a number to a real number power./// Returns NaN if `self` is a negative floating-point number./// If the implementing type doesn't support NaN, this method should panic if `self < 0`./// assert!(::num_traits::Float::is_nan(negative.sqrt()));/// If `self <= 0` and this type does not support a NaN representation, this function should panic./// If this type does not support a NaN representation, this function should panic/// if the number is outside the range [-1, 1]./// if `self-1 <= 0`./// A trait for real number types that do not necessarily have/// floating-point-specific characteristics such as NaN and infinity./// See [this Wikipedia article](https://en.wikipedia.org/wiki/Real_data_type)/// for a list of data types that could meaningfully implement this trait.// NOTE: These doctests have the same issue as those in src/float.rs.// They're testing the inherent methods directly, and not those of `Real`./// Computes the absolute value./// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`./// For signed integers, `::MIN` will be returned if the number is `::MIN`./// Returns `zero` if the number is less than or equal to `other`, otherwise the difference/// between `self` and `other` is returned./// Returns the sign of the number./// For `f32` and `f64`:/// * `1.0` if the number is positive, `+0.0` or `INFINITY`/// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`/// * `NaN` if the number is `NaN`/// For signed integers:/// * `0` if the number is zero/// * `1` if the number is positive/// * `-1` if the number is negative/// Returns true if the number is positive and false if the number is zero or negative./// Returns true if the number is negative and false if the number is zero or positive./// Useful functions for signed numbers (i.e. numbers that can be negative).signed_implsigned_float_implr" Computes the absolute value. Returns `NAN` if the number is `NAN`."r" The positive difference of two numbers. Returns `0.0` if the number is"r" less than or equal to `other`, otherwise the difference between`self`"r" and `other` is returned."r" - `1.0` if the number is positive, `+0.0` or `INFINITY`"r" - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`"r" - `NAN` if the number is NaN"r" Returns `true` if the number is positive, including `+0.0` and `INFINITY`"r" Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY`"/// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`/// Returns zero if `x` is less than or equal to `y`, otherwise the difference/// between `x` and `y` is returned./// A trait for values which cannot be negativeempty_trait_implunsigned_wrapping_is_unsignedsigned_wrapping_is_signedget_num_cpusget_num_physical_cpus/// Returns the number of available CPUs of the current system./// This function will get the number of logical cores. Sometimes this is different from the number/// of physical cores (See [Simultaneous multithreading on Wikipedia][smt])./// This will always return at least `1`./// let cpus = num_cpus::get();/// if cpus > 1 {///     println!("We are on a multicore system with {} CPUs", cpus);///     println!("We are on a single core system");/// This will check [sched affinity] on Linux, showing a lower number of CPUs if the current/// thread does not have access to all the computer's CPUs./// This will also check [cgroups], frequently used in containers to constrain CPU usage./// [smt]: https://en.wikipedia.org/wiki/Simultaneous_multithreading/// [sched affinity]: http://www.gnu.org/software/libc/manual/html_node/CPU-Affinity.html/// [cgroups]: https://www.kernel.org/doc/Documentation/cgroup-v1/cgroups.txtget_physical/// Returns the number of physical cores of the current system./// Physical count is supported only on Linux, mac OS and Windows platforms./// On other platforms, or if the physical count fails on supported platforms,/// this function returns the same as [`get()`], which is the number of logical/// CPUS./// let logical_cpus = num_cpus::get();/// let physical_cpus = num_cpus::get_physical();/// if logical_cpus > physical_cpus {///     println!("We have simultaneous multithreading with about {:.2} \///               logical cores to 1 physical core.", ///               (logical_cpus as f64) / (physical_cpus as f64));/// } else if logical_cpus == physical_cpus {///     println!("Either we don't have simultaneous multithreading, or our \///               system doesn't support getting the number of physical CPUs.");///     println!("We have less logical CPUs than physical CPUs, maybe we only have access to \///               some of the CPUs on our system.");/// [`get()`]: fn.get.htmltest_get_physical//! A crate with utilities to determine the number of CPUs available on the//! current system.//! Sometimes the CPU will exaggerate the number of CPUs it contains, because it can use//! [processor tricks] to deliver increased performance when there are more threads. This //! crate provides methods to get both the logical and physical numbers of cores.//! This information can be used as a guide to how many tasks can be run in parallel.//! There are many properties of the system architecture that will affect parallelism,//! for example memory access speeds (for all the caches and RAM) and the physical//! architecture of the processor, so the number of CPUs should be used as a rough guide//! only.//! Fetch the number of logical CPUs.//! let cpus = num_cpus::get();//! See [`rayon::Threadpool`] for an example of where the number of CPUs could be//! used when setting up parallel jobs (Where the threadpool example uses a fixed//! number 8, it could use the number of CPUs).//! [processor tricks]: https://en.wikipedia.org/wiki/Simultaneous_multithreading//! [`rayon::ThreadPool`]: https://docs.rs/rayon/1.*/rayon/struct.ThreadPool.htmllogical_cpusCGROUPS_CPUS/// Cached CPUs calculated from cgroups./// If 0, check logical cpus.// Allow deprecation warnings, we want to work on older rustccgroups_num_cpusinit_cgroupsload_cgroupsCgroupVersionCgroupMountInfoSubsyscpu_quotaquota_usperiod_usraw_paramload_cpuparse_lineFIXTURES_PROC// `static_in_const` feature is not stable in Rust 1.13.FIXTURES_CGROUPStest_load_mountinfotest_load_subsystest_cgroup_mounttest_cgroup_cpu_quotatest_cgroup_cpu_quota_divide_by_zerotest_cgroup_cpu_quota_ceiltest_load_subsys_multi// https://www.ibm.com/docs/en/aix/7.3?topic=files-proc-file// The 'status' file is defined as binary format below//   uint32_t pr_flag;  /* process flags from proc struct p_flag *///   uint32_t pr_flag2; /* process flags from proc struct p_flag2 *///   uint32_t pr_flags; /* /proc flags *///   uint32_t pr_nlwp;  /* number of threads in the process *///   ...                /* Omitted */mach_port_name_t// https://developer.apple.com/documentation/kernel/mach_port_name_tmach_vm_deallocate// https://developer.apple.com/documentation/kernel/1402285-mach_vm_deallocatemach_port_deallocate// https://developer.apple.com/documentation/kernel/1578777-mach_port_deallocate//! Fallback if no OS matches./// Obtain the number of threads currently part of the active process. Returns `None` if the number/// of threads cannot be determined.is_single_threaded/// Determine if the current process is single-threaded. Returns `None` if the number of threads//! Minimum supported Rust version: 1.28MAGIC/// File identification bytes stored at the beginning of the file.AIX_BIG_MAGIC/// File identification bytes at the beginning of AIX big archive.THIN_MAGIC/// File identification bytes stored at the beginning of a thin archive./// A thin archive only contains a symbol table and file names.TERMINATOR/// The terminator for each archive member header./// File modification timestamp in decimal./// User ID in decimal./// Group ID in decimal./// File mode in octal./// File size in decimal./// Must be equal to `TERMINATOR`./// The header at the start of an archive member./// File member size in decimal.nxtmem/// Next member offset in decimal.prvmem/// Previous member offset in decimal./// File member date in decimal./// File member user id in decimal./// File member group id in decimal./// File member mode in octal.namlen/// File member name length in decimal.AixHeader/// The header at the start of an AIX big archive member, without name./// Archive magic string.memoff/// Offset of member table.gstoff/// Offset of global symbol table.gst64off/// Offset of global symbol table for 64-bit objects.fstmoff/// Offset of first member.lstmoff/// Offset of last member.freeoff/// Offset of first member on free list.AixFileHeader/// The AIX big archive's fixed length header at file beginning.AixMemberOffset/// Offset of a member in an AIX big archive./// This is used in the member index.unsafe_impl_pod//! Archive definitions.//! These definitions are independent of read/write support, although we do implement//! some traits useful for those./// A byte slice./// Uses copy-on-write to avoid unnecessary allocations. The bytes can be/// accessed as a slice using the `Deref` trait, or as a mutable `Vec` using the/// `to_mut` method./// Provides a `Debug` implementation that shows the first 8 bytes and the length./// Acquire a mutable reference to the bytes./// Clones the bytes if they are shared./// Get the bytes as a slice.debug_list_bytes// Only for Debug impl of `Bytes`./// A byte slice that is a string of an unknown encoding./// Provides a `Debug` implementation that interprets the bytes as UTF-8.IdPrivateDynRelaFileKindReadRef/// The endianness./// Used to set the data encoding when writing the ELF file.is_64/// Whether file is 64-bit./// Use to set the file class when writing the ELF file.load_align/// The alignment of [`elf::PT_LOAD`] segments./// This is an informational field and is not used when writing the ELF file./// It can optionally be used when calling [`Segments::add_load_segment`]./// It is determined heuristically when reading the ELF file. Currently,/// if all load segments have the same alignment, that alignment is used,/// otherwise it is set to 1./// The file header.Segments/// The segment table./// The section table.Symbols/// The symbol table.dynamic_symbolsDynamicSymbols/// The dynamic symbol table.version_base/// The base version for the GNU version definitions./// This will be written as a version definition with index 1./// The GNU version definitions and dependencies.version_filesVersionFiles/// The filenames used in the GNU version definitions.hash_bucket_count/// The bucket count parameter for the hash table.gnu_hash_bloom_shift/// The bloom shift parameter for the GNU hash table.gnu_hash_bloom_count/// The bloom count parameter for the GNU hash table.gnu_hash_bucket_count/// The bucket count parameter for the GNU hash table./// A builder for reading, modifying, and then writing ELF files./// Public fields are available for modifying the values that will be written./// Methods are available to add elements to tables, and elements can be deleted/// from tables by setting the `delete` field in the element./// Create a new ELF builder./// Read the ELF file from file data.read32/// Read a 32-bit ELF file from file data.read64/// Read a 64-bit ELF file from file data.Relread_relocationsSectionIndexSymbolTableSectionDataDYNAMICread_relocations_implread_dynamicsread_symbolsread_attributesAttributesSectionread_gnu_versionsWritableBuffer/// Write the ELF file to the buffer.delete_orphans/// Delete segments, symbols, relocations, and dynamics that refer/// to deleted items./// This calls `delete_orphan_segments`, `delete_orphan_symbols`,/// `delete_orphan_relocations`, and `delete_orphan_dynamics`.delete_orphan_segments/// Set the delete flag for segments that only refer to deleted sections.delete_orphan_symbols/// Set the delete flag for symbols that refer to deleted sections.delete_orphan_relocations/// Delete relocations that refer to deleted symbols.delete_orphan_dynamics/// Delete dynamic entries that refer to deleted sections.delete_unused_versions/// Delete unused GNU version entries./// Return the ELF file class that will be written./// This can be useful for calculating sizes.file_header_size/// Calculate the size of the file header.program_headers_size/// Calculate the size of the program headers.dynamic_symbol_size/// Calculate the size of the dynamic symbol table./// To get an accurate result, you may need to first call/// [`Self::delete_orphan_symbols`].dynamic_string_size/// Calculate the size of the dynamic string table./// This adds all of the currently used dynamic strings to a string table,/// calculates the size of the string table, and discards the string table./// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`].hash_size/// Calculate the size of the hash table.gnu_hash_size/// Calculate the size of the GNU hash table.gnu_versym_size/// Calculate the size of the GNU symbol version section.gnu_verdef_size/// Calculate the size of the GNU version definition section.gnu_verneed_size/// Calculate the size of the GNU version dependency section.section_size/// Calculate the memory size of a section./// Returns 0 for sections that are deleted or aren't allocated.set_section_sizes/// Set the `sh_size` field for every allocated section./// This is useful to call prior to doing memory layout.dynamic_section/// Find the section containing the dynamic table./// This uses the `PT_DYNAMIC` program header to find the dynamic section.dynamic_data/// Find the dynamic table entries./// This uses the `PT_DYNAMIC` program header to find the dynamic section,dynamic_data_mutinterp_section/// Find the section containing the interpreter path./// This uses the `PT_INTERP` program header to find the interp section.interp_data/// Find the interpreter path.interp_data_mutos_abi/// The OS ABI field in the file header./// One of the `ELFOSABI*` constants.abi_version/// The ABI version field in the file header./// The meaning of this field depends on the `os_abi` value./// The object file type in the file header./// One of the `ET_*` constants./// The architecture in the file header./// One of the `EM_*` constants./// Entry point virtual address in the file header./// The processor-specific flags in the file header./// A combination of the `EF_*` constants./// The file offset of the program header table./// Writing will fail if the program header table cannot be placed at this offset./// ELF file header./// This corresponds to fields in [`elf::FileHeader32`] or [`elf::FileHeader64`]./// This only contains the ELF file header fields that can be modified./// The other fields are automatically calculated.SegmentId/// An ID for referring to a segment in [`Segments`]./// Ignore this segment when writing the ELF file./// The `p_type` field in the ELF program header./// One of the `PT_*` constants./// The `p_flags` field in the ELF program header./// A combination of the `PF_*` constants./// The `p_offset` field in the ELF program header./// This is the file offset of the data in the segment. This should/// correspond to the file offset of the sections that are placed in/// this segment. Currently there is no support for section data/// that is not contained in sections./// The `p_vaddr` field in the ELF program header./// The `p_paddr` field in the ELF program header./// The `p_filesz` field in the ELF program header./// The `p_memsz` field in the ELF program header./// The `p_align` field in the ELF program header./// The sections contained in this segment.// Might need to add reference to data if no sections./// A segment in [`Segments`]./// This corresponds to [`elf::ProgramHeader32`] or [`elf::ProgramHeader64`]./// The ID used for referring to this segment.is_load/// Returns true if the segment type is `PT_LOAD`.contains_offset/// Returns true if the segment contains the given file offset.address_from_offset/// Return the address corresponding to the given file offset./// This will return a meaningless value if `contains_offset` is false.contains_address/// Returns true if the segment contains the given address.remove_sections/// Remove all sections from the segment, and set its size to zero./// Add a section to the segment./// If this is a [`elf::PT_LOAD`] segment, then the file offset and address of the/// section is changed to be at the end of the segment./// The segment's file and address ranges are extended to include the section./// This uses the `sh_size` field of the section, not the size of the section data./// The section's id is added to the segment's list of sections.append_section_range/// Extend this segment's file and address ranges to include the given section./// If the segment's `p_memsz` is zero, then this signifies that the segment/// has no file or address range yet. In this case, the segment's file and address/// ranges are set equal to the section. Otherwise, the segment's file and address/// ranges are extended to include the section.recalculate_ranges/// Recalculate the file and address ranges of the segment./// Resets the segment's file and address ranges to zero, and then/// calls `append_section_range` for each section in the segment./// A segment table./// Add a new segment to the table.find_load_segment_from_offset/// Find a `PT_LOAD` segment containing the given offset.add_load_segment/// Add a new `PT_LOAD` segment to the table./// The file offset and address will be derived from the current maximum for any segment./// The address will be chosen so that `p_paddr % align == p_offset % align`./// You may wish to use [`Builder::load_align`] for the alignment./// Add a copy of a segment to the table./// This will copy the segment type, flags and alignment./// Additionally, if the segment type is `PT_LOAD`, then the file offset and address/// will be set as in `add_load_segment`./// An ID for referring to a section in [`Sections`]./// Ignore this section when writing the ELF file./// The name of the section./// This is automatically added to the section header string table,/// and the resulting string table offset is used to set the `sh_name`/// field in the ELF section header./// The `sh_type` field in the ELF section header./// One of the `SHT_*` constants./// The `sh_flags` field in the ELF section header./// A combination of the `SHF_*` constants./// The `sh_addr` field in the ELF section header./// The `sh_offset` field in the ELF section header./// This is the file offset of the data in the section./// Writing will fail if the data cannot be placed at this offset./// This is only used for sections that have `SHF_ALLOC` set./// For other sections, the section data is written at the next available/// The `sh_size` field in the ELF section header./// This size is not used when writing. The size of the `data` field issh_link_section/// The ID of the section linked to by the `sh_link` field in the ELF section header./// The `sh_info` field in the ELF section header./// Only used if `sh_info_section` is `None`.sh_info_section/// The ID of the section linked to by the `sh_info` field in the ELF section header./// The `sh_addralign` field in the ELF section header./// The `sh_entsize` field in the ELF section header./// The section data./// A section in [`Sections`]./// This corresponds to [`elf::SectionHeader32`] or [`elf::SectionHeader64`]./// The ID used for referring to this section.is_alloc/// Returns true if the section flags include `SHF_ALLOC`./// Return the segment permission flags that are equivalent to the section flags./// The section contains the given raw data bytes.UninitializedData/// The section contains uninitialised data bytes of the given length./// The section contains relocations.DynamicRelocation/// The section contains dynamic relocations./// The section contains notes.// TODO: parse notes/// The section contains dynamic entries./// The section contains attributes./// This may be GNU attributes or other vendor-specific attributes.SectionString/// The section contains the strings for the section headers./// The section contains the symbol table.SymbolSectionIndex/// The section contains the extended section index for the symbol table./// The section contains the strings for symbol table.DynamicSymbol/// The section contains the dynamic symbol table.DynamicString/// The section contains the dynamic string table./// The section contains the hash table.GnuHash/// The section contains the GNU hash table.GnuVersym/// The section contains the GNU symbol versions.GnuVerdef/// The section contains the GNU version definitions.GnuVerneed/// The section contains the GNU version dependencies./// The data for a [`Section`]./// A section table./// Add a new section to the table./// Add a copy of a section to the table./// This will set the file offset of the copy to zero./// [`Segment::append_section`] can be used to assign a valid file offset and a new address.SymbolId/// An ID for referring to a symbol in [`Symbols`]./// Ignore this symbol when writing the ELF file./// The name of the symbol./// The section referenced by the symbol./// Used to set the `st_shndx` field in the ELF symbol./// The `st_info` field in the ELF symbol./// The `st_other` field in the ELF symbol./// The `st_shndx` field in the ELF symbol./// Only used if `Self::section` is `None`./// The `st_value` field in the ELF symbol./// The `st_size` field in the ELF symbol.VersionId/// GNU version for dynamic symbols.version_hidden/// Set the [`elf::VERSYM_HIDDEN`] flag for this symbol./// A symbol in [`Symbols`]./// This corresponds to [`elf::Sym32`] or [`elf::Sym64`]./// The ID used for referring to this symbol.st_bind/// Get the `st_bind` component of the `st_info` field.st_type/// Get the `st_type` component of the `st_info` field.set_st_info/// Set the `st_info` field given the `st_bind` and `st_type` components./// A symbol table.count_defined/// Number of defined symbols./// Add a new symbol to the table./// The `r_offset` field in the ELF relocation./// The symbol referenced by the ELF relocation.r_type/// The `r_type` field in the ELF relocation./// The `r_addend` field in the ELF relocation./// Only used if the section type is `SHT_RELA`./// A relocation stored in a [`Section`]./// This corresponds to [`elf::Rel32`], [`elf::Rela32`], [`elf::Rel64`] or [`elf::Rela64`].DynamicSymbolId/// A dynamic symbol ID./// A dynamic symbol./// A dynamic symbol table./// A dynamic relocation./// The `d_tag` field in the dynamic entry./// One of the `DT_*` values./// The value is an automatically generated integer./// Writing will fail if the value cannot be automatically generated./// The `d_val` field in the dynamic entry./// The value is an integer./// The string value./// This will be stored in the dynamic string section./// The value is a string./// An entry in the dynamic section./// This corresponds to [`elf::Dyn32`] or [`elf::Dyn64`].VersionFileId/// An ID for referring to a filename in [`VersionFiles`]./// Ignore this file when writing the ELF file./// The filename.VersionFile/// A filename used for GNU versioning./// Stored in [`VersionFiles`]./// The ID used for referring to this filename./// A table of filenames used for GNU versioning./// Add a new filename to the table.VERSION_ID_BASE/// An ID for referring to a version in [`Versions`]./// Return `True` if this is a special version that does not exist in the version table./// Return the ID for a version index of [`elf::VER_NDX_LOCAL`]./// Return the ID for a version index of [`elf::VER_NDX_GLOBAL`].VersionData/// The data for this version./// Ignore this version when writing the ELF file./// A version for a symbol./// The ID used for referring to this version.VersionDefDef/// The version for a defined symbol.VersionNeedNeed/// The version for an undefined symbol./// The data for a version for a symbol./// The names for the version./// This usually has two elements. The first element is the name of this/// version, and the second element is the name of the previous version/// in the tree of versions./// The version flags./// A combination of the `VER_FLG_*` constants./// A GNU version definition./// The filename of the library providing this version./// The name of the version./// A GNU version dependency./// A table of versions that are referenced by symbols./// Add a version.subsectionsAttributesSubsection/// The subsections./// The contents of an attributes section./// Create a new attributes section./// The vendor namespace for these attributes.subsubsectionsAttributesSubsubsection/// The sub-subsections./// A subsection of an attributes section./// Create a new subsection.AttributeTag/// The sub-subsection tag./// The data containing the attributes./// A sub-subsection in an attributes section./// The attributes apply to the whole file./// Correspeonds to [`elf::Tag_File`]./// The attributes apply to the given sections./// Correspeonds to [`elf::Tag_Section`]./// The attributes apply to the given symbols./// Correspeonds to [`elf::Tag_Symbol`]./// The tag for a sub-subsection in an attributes section./// Return the corresponding `elf::Tag_*` value for this tag.//! This module provides a [`Builder`] for reading, modifying, and then writing ELF files./// The error type used within the build module./// The result type used within the build module.//! Interface for building object files.//! This module provides common types and traits used in the builders.//! The submodules define the builders for each file format./// The type of identifier for the item./// Return `True` if the item is deleted./// An item in a [`Table`]./// Return the index of the item in the table./// An identifier for referring to an item in a [`Table`].id_private/// A table of items./// Each item has a unique identifier./// Items can be deleted without changing the identifiers of other items.next_id/// Number of items, including deleted items./// Return `True` if there are no non-deleted items./// Number of non-deleted items./// Return a reference to an item./// Return a mutable reference to a segment.TableIter/// Return an iterator for the segments.TableIterMut/// Return a mutable iterator for the segments./// An iterator for non-deleted items in a [`Table`].ArchitectureAarch64Aarch64_Ilp32AvrBpfCskyI386X86_64_X32HexagonLoongArch64MipsMips64Msp430Riscv32Riscv64S390xSbfSharcSparc32PlusSparc64Wasm32Wasm64Xtensa/// A CPU architecture.SubArchitectureArm64EArm64EC/// A CPU sub-architecture.AddressSize/// The size of an address value for this architecture./// Returns `None` for unknown architectures./// The size of an address value for an architecture./// This may differ from the address size supported by the file format (such as for COFF)./// The size in bytes of an address value.BinaryFormatCoffMachO/// A binary file format.native_object/// The target's native binary format for relocatable object files./// Defaults to `Elf` for unknown platforms./// The section kind is unknown./// An executable code section./// Example ELF sections: `.text`/// Example Mach-O sections: `__TEXT/__text`/// A data section./// Example ELF sections: `.data`/// Example Mach-O sections: `__DATA/__data`ReadOnlyData/// A read only data section./// Example ELF sections: `.rodata`/// Example Mach-O sections: `__TEXT/__const`, `__DATA/__const`, `__TEXT/__literal4`ReadOnlyDataWithRel/// A read only data section with relocations./// This is the same as either `Data` or `ReadOnlyData`, depending on the file format./// This value is only used in the API for writing files. It is never returned when reading files.ReadOnlyString/// A loadable string section./// Example ELF sections: `.rodata.str`/// Example Mach-O sections: `__TEXT/__cstring`/// An uninitialized data section./// Example ELF sections: `.bss`/// Example Mach-O sections: `__DATA/__bss`/// An uninitialized common data section./// Example Mach-O sections: `__DATA/__common`/// A TLS data section./// Example ELF sections: `.tdata`/// Example Mach-O sections: `__DATA/__thread_data`UninitializedTls/// An uninitialized TLS data section./// Example ELF sections: `.tbss`/// Example Mach-O sections: `__DATA/__thread_bss`TlsVariables/// A TLS variables section./// This contains TLS variable structures, rather than the variable initializers./// Example Mach-O sections: `__DATA/__thread_vars`OtherString/// A non-loadable string section./// Example ELF sections: `.comment`, `.debug_str`/// Some other non-loadable section./// Example ELF sections: `.debug_info`/// Debug information./// Example Mach-O sections: `__DWARF/__debug_info`DebugString/// Debug strings./// This is the same as either `Debug` or `OtherString`, depending on the file format.Linker/// Information for the linker./// Example COFF sections: `.drectve`/// ELF note section./// Metadata such as symbols or relocations./// Example ELF sections: `.symtab`, `.strtab`, `.group`/// Some other ELF section type./// This is the `sh_type` field in the section header./// The meaning may be dependent on the architecture./// The kind of a section.is_bss/// Return true if this section contains zerofill data.ComdatKind/// The selection kind is unknown./// Multiple definitions are allowed./// An arbitrary definition is selected, and the rest are removed./// This is the only supported selection kind for ELF.NoDuplicates/// Multiple definitions are not allowed./// This is used to group sections without allowing duplicates.SameSize/// Multiple definitions must have the same size.ExactMatch/// Multiple definitions must match exactly.Largest/// Multiple definitions are allowed, and the largest is selected./// An arbitrary definition with the largest size is selected, and the rest are removed.Newest/// Multiple definitions are allowed, and the newest is selected./// The selection kind for a COMDAT section group./// This determines the way in which the linker resolves multiple definitions of the COMDATSymbolKind/// The symbol kind is unknown./// The symbol is for executable code./// The symbol is for a data object./// The symbol is for a section./// The symbol is the name of a file. It precedes symbols within that file./// The symbol is for a code label./// The symbol is for a thread local storage entity./// The kind of a symbol.SymbolScope/// Unknown scope./// Symbol is visible to the compilation unit./// Symbol is visible to the static linkage unit./// Symbol is visible to dynamically linked objects./// A symbol scope.RelocationKind/// The operation is unknown./// S + A/// S + A - PGot/// G + A - GotBaseGotRelative/// G + A - PGotBaseRelative/// GotBase + A - PGotBaseOffset/// S + A - GotBasePltRelative/// L + A - PImageOffset/// S + A - ImageSectionOffset/// S + A - Section/// The index of the section containing the symbol./// The operation used to calculate the result of the relocation./// The relocation descriptions use the following definitions. Note that/// these definitions probably don't match any ELF ABI./// * A - The value of the addend./// * G - The address of the symbol's entry within the global offset table./// * L - The address of the symbol's entry within the procedure linkage table./// * P - The address of the place of the relocation./// * S - The address of the symbol./// * GotBase - The address of the global offset table./// * Image - The base address of the image./// * Section - The address of the section containing the symbol./// 'XxxRelative' means 'Xxx + A - P'.  'XxxOffset' means 'S + A - Xxx'.RelocationEncoding/// The relocation encoding is unknown./// Generic encoding.X86Signed/// x86 sign extension at runtime./// Used with `RelocationKind::Absolute`.X86RipRelative/// x86 rip-relative addressing./// The `RelocationKind` must be PC relative.X86RipRelativeMovq/// x86 rip-relative addressing in movq instruction.X86Branch/// x86 branch instruction.S390xDbl/// s390x PC-relative offset shifted right by one bit.AArch64Call/// AArch64 call target.LoongArchBranch/// LoongArch branch offset with two trailing zeros.SharcTypeA/// SHARC+ 48-bit Type A instruction/// Represents these possible variants, each with a corresponding/// `R_SHARC_*` constant:/// * 24-bit absolute address/// * 32-bit absolute address/// * 6-bit relative address/// * 24-bit relative address/// * 6-bit absolute address in the immediate value field/// * 16-bit absolute address in the immediate value fieldSharcTypeB/// SHARC+ 32-bit Type B instruction/// * 7-bit absolute address in the immediate value field/// * 16-bit absolute address/// Information about how the result of the relocation operation is encoded in the place./// This is usually architecture specific, such as specifying an addressing mode or/// a specific instruction.FileFlags/// No file flags./// `os_abi` field in the ELF file header./// `abi_version` field in the ELF file header./// `e_flags` field in the ELF file header./// ELF file flags./// `flags` field in the Mach-O file header./// Mach-O file flags.characteristics/// `Characteristics` field in the COFF file header./// COFF file flags./// `f_flags` field in the XCOFF file header./// XCOFF file flags./// File flags that are specific to each file format./// No segment flags./// `p_flags` field in the segment header./// ELF segment flags./// `flags` field in the segment header.maxprot/// `maxprot` field in the segment header.initprot/// `initprot` field in the segment header./// Mach-O segment flags./// `Characteristics` field in the segment header./// COFF segment flags./// Segment flags that are specific to each file format.SectionFlags/// No section flags./// `sh_flags` field in the section header./// ELF section flags./// `flags` field in the section header./// Mach-O section flags./// `Characteristics` field in the section header./// COFF section flags.s_flags/// `s_flags` field in the section header./// XCOFF section flags./// Section flags that are specific to each file format./// No symbol flags./// `st_info` field in the ELF symbol./// `st_other` field in the ELF symbol./// ELF symbol flags.n_desc/// `n_desc` field in the Mach-O symbol./// Mach-O symbol flags./// `Selection` field in the auxiliary symbol for the section.associative_section/// `Number` field in the auxiliary symbol for the section.CoffSection/// COFF flags for a section symbol.n_sclass/// `n_sclass` field in the XCOFF symbol.x_smtyp/// `x_smtyp` field in the CSECT auxiliary symbol./// Only valid if `n_sclass` is `C_EXT`, `C_WEAKEXT`, or `C_HIDEXT`.x_smclas/// `x_smclas` field in the CSECT auxiliary symbol.containing_csect/// The containing csect for the symbol./// Only valid if `x_smtyp` is `XTY_LD`./// XCOFF symbol flags./// Symbol flags that are specific to each file format.RelocationFlags/// The size in bits of the place of relocation./// Format independent representation./// `r_type` field in the ELF relocation./// ELF relocation fields./// `r_type` field in the Mach-O relocation.r_pcrel/// `r_pcrel` field in the Mach-O relocation.r_length/// `r_length` field in the Mach-O relocation./// Mach-O relocation fields./// `typ` field in the COFF relocation./// COFF relocation fields.r_rtype/// `r_rtype` field in the XCOFF relocation.r_rsize/// `r_rsize` field in the XCOFF relocation./// XCOFF relocation fields./// Relocation fields that are specific to each file format and architecture.U32BytesU64Bytes/// Magic number and other information./// Object file type. One of the `ET_*` constants./// Architecture. One of the `EM_*` constants./// Object file version. Must be `EV_CURRENT`./// Entry point virtual address./// Program header table file offset./// Section header table file offset./// Processor-specific flags./// Size in bytes of this header./// Program header table entry size./// Program header table entry count./// If the count is greater than or equal to `PN_XNUM` then this field is set to/// `PN_XNUM` and the count is stored in the `sh_info` field of section 0./// Section header table entry size./// Section header table entry count./// If the count is greater than or equal to `SHN_LORESERVE` then this field is set to/// `0` and the count is stored in the `sh_size` field of section 0./// first section header./// Section header string table index./// If the index is greater than or equal to `SHN_LORESERVE` then this field is set to/// `SHN_XINDEX` and the index is stored in the `sh_link` field of section 0./// The header at the start of every 32-bit ELF file./// The header at the start of every 64-bit ELF file./// Magic number. Must be `ELFMAG`./// File class. One of the `ELFCLASS*` constants./// Data encoding. One of the `ELFDATA*` constants./// ELF version. Must be `EV_CURRENT`./// OS ABI identification. One of the `ELFOSABI*` constants./// ABI version./// Padding bytes./// Contained in the file header./// File identification bytes stored in `Ident::magic`.// Values for `Ident::class`./// Invalid class./// 32-bit object./// 64-bit object.// Values for `Ident::data`./// Invalid data encoding./// 2's complement, little endian./// 2's complement, big endian.// Values for `Ident::os_abi`./// UNIX System V ABI./// Alias./// HP-UX./// NetBSD./// Object uses GNU ELF extensions./// Compatibility alias.ELFOSABI_HURD/// GNU/Hurd./// Sun Solaris./// IBM AIX./// SGI Irix./// FreeBSD./// Compaq TRU64 UNIX./// Novell Modesto./// OpenBSD.ELFOSABI_OPENVMS/// OpenVMS.ELFOSABI_NSK/// Hewlett-Packard Non-Stop Kernel.ELFOSABI_AROS/// AROSELFOSABI_FENIXOS/// FenixOSELFOSABI_CLOUDABI/// Nuxi CloudABI/// ARM EABI./// ARM./// Standalone (embedded) application.// Values for `FileHeader*::e_type`./// No file type./// Relocatable file./// Executable file./// Shared object file./// Core file./// OS-specific range start./// OS-specific range end./// Processor-specific range start./// Processor-specific range end.// Values for `FileHeader*::e_machine`./// No machine/// AT&T WE 32100/// SUN SPARC/// Intel 80386/// Motorola m68k family/// Motorola m88k familyEM_IAMCU/// Intel MCU/// Intel 80860/// MIPS R3000 big-endian/// IBM System/370/// MIPS R3000 little-endian/// HPPA/// Fujitsu VPP500/// Sun's "v8plus"/// Intel 80960/// PowerPC/// PowerPC 64-bit/// IBM S390/// IBM SPU/SPC/// NEC V800 series/// Fujitsu FR20/// TRW RH-32/// Motorola RCE/// ARM/// Digital Alpha/// Hitachi SH/// SPARC v9 64-bit/// Siemens Tricore/// Argonaut RISC Core/// Hitachi H8/300/// Hitachi H8/300H/// Hitachi H8S/// Hitachi H8/500/// Intel Merced/// Stanford MIPS-X/// Motorola Coldfire/// Motorola M68HC12/// Fujitsu MMA Multimedia Accelerator/// Siemens PCP/// Sony nCPU embeeded RISC/// Denso NDR1 microprocessor/// Motorola Start*Core processor/// Toyota ME16 processor/// STMicroelectronic ST100 processor/// Advanced Logic Corp. Tinyj emb.fam/// AMD x86-64 architecture/// Sony DSP ProcessorEM_PDP10/// Digital PDP-10EM_PDP11/// Digital PDP-11/// Siemens FX66 microcontroller/// STMicroelectronics ST9+ 8/16 mc/// STmicroelectronics ST7 8 bit mc/// Motorola MC68HC16 microcontroller/// Motorola MC68HC11 microcontroller/// Motorola MC68HC08 microcontroller/// Motorola MC68HC05 microcontroller/// Silicon Graphics SVx/// STMicroelectronics ST19 8 bit mc/// Digital VAX/// Axis Communications 32-bit emb.proc/// Infineon Technologies 32-bit emb.proc/// Element 14 64-bit DSP Processor/// LSI Logic 16-bit DSP Processor/// Donald Knuth's educational 64-bit proc/// Harvard University machine-independent object files/// SiTera Prism/// Atmel AVR 8-bit microcontroller/// Fujitsu FR30/// Mitsubishi D10V/// Mitsubishi D30V/// NEC v850/// Mitsubishi M32R/// Matsushita MN10300/// Matsushita MN10200/// picoJava/// OpenRISC 32-bit embedded processorEM_ARC_COMPACT/// ARC International ARCompact/// Tensilica Xtensa ArchitectureEM_VIDEOCORE/// Alphamosaic VideoCoreEM_TMM_GPP/// Thompson Multimedia General Purpose ProcEM_NS32K/// National Semi. 32000EM_TPC/// Tenor Network TPCEM_SNP1K/// Trebia SNP 1000EM_ST200/// STMicroelectronics ST200EM_IP2K/// Ubicom IP2xxxEM_MAX/// MAX processorEM_CR/// National Semi. CompactRISCEM_F2MC16/// Fujitsu F2MC16EM_MSP430/// Texas Instruments msp430/// Analog Devices Blackfin DSPEM_SE_C33/// Seiko Epson S1C33 familyEM_SEP/// Sharp embedded microprocessorEM_ARCA/// Arca RISC/// PKU-Unity & MPRC Peking Uni. mc seriesEM_EXCESS/// eXcess configurable cpuEM_DXP/// Icera Semi. Deep Execution Processor/// Altera Nios IIEM_CRX/// National Semi. CompactRISC CRXEM_XGATE/// Motorola XGATEEM_C166/// Infineon C16x/XC16xEM_M16C/// Renesas M16CEM_DSPIC30F/// Microchip Technology dsPIC30FEM_CE/// Freescale Communication Engine RISCEM_M32C/// Renesas M32CEM_TSK3000/// Altium TSK3000EM_RS08/// Freescale RS08EM_SHARC/// Analog Devices SHARC familyEM_ECOG2/// Cyan Technology eCOG2EM_SCORE7/// Sunplus S+core7 RISCEM_DSP24/// New Japan Radio (NJR) 24-bit DSPEM_VIDEOCORE3/// Broadcom VideoCore IIIEM_LATTICEMICO32/// RISC for Lattice FPGAEM_SE_C17/// Seiko Epson C17/// Texas Instruments TMS320C6000 DSPEM_TI_C2000/// Texas Instruments TMS320C2000 DSPEM_TI_C5500/// Texas Instruments TMS320C55x DSPEM_TI_ARP32/// Texas Instruments App. Specific RISCEM_TI_PRU/// Texas Instruments Prog. Realtime UnitEM_MMDSP_PLUS/// STMicroelectronics 64bit VLIW DSPEM_CYPRESS_M8C/// Cypress M8CEM_R32C/// Renesas R32CEM_TRIMEDIA/// NXP Semi. TriMedia/// QUALCOMM HexagonEM_8051/// Intel 8051 and variantsEM_STXP7X/// STMicroelectronics STxP7x/// Andes Tech. compact code emb. RISCEM_ECOG1X/// Cyan Technology eCOG1XEM_MAXQ30/// Dallas Semi. MAXQ30 mcEM_XIMO16/// New Japan Radio (NJR) 16-bit DSPEM_MANIK/// M2000 Reconfigurable RISCEM_CRAYNV2/// Cray NV2 vector architectureEM_RX/// Renesas RXEM_METAG/// Imagination Tech. METAEM_MCST_ELBRUS/// MCST ElbrusEM_ECOG16/// Cyan Technology eCOG16EM_CR16/// National Semi. CompactRISC CR16EM_ETPU/// Freescale Extended Time Processing UnitEM_SLE9X/// Infineon Tech. SLE9XEM_L10M/// Intel L10MEM_K10M/// Intel K10M/// ARM AARCH64EM_AVR32/// Amtel 32-bit microprocessorEM_STM8/// STMicroelectronics STM8EM_TILE64/// Tileta TILE64/// Tilera TILEPro/// Xilinx MicroBlazeEM_CUDA/// NVIDIA CUDA/// Tilera TILE-GxEM_CLOUDSHIELD/// CloudShieldEM_COREA_1ST/// KIPO-KAIST Core-A 1st gen.EM_COREA_2ND/// KIPO-KAIST Core-A 2nd gen.EM_ARC_COMPACT2/// Synopsys ARCompact V2EM_OPEN8/// Open8 RISCEM_RL78/// Renesas RL78EM_VIDEOCORE5/// Broadcom VideoCore VEM_78KOR/// Renesas 78KOREM_56800EX/// Freescale 56800EX DSCEM_BA1/// Beyond BA1EM_BA2/// Beyond BA2EM_XCORE/// XMOS xCOREEM_MCHP_PIC/// Microchip 8-bit PIC(r)EM_KM32/// KM211 KM32EM_KMX32/// KM211 KMX32EM_EMX16/// KM211 KMX16EM_EMX8/// KM211 KMX8EM_KVARC/// KM211 KVARCEM_CDP/// Paneve CDPEM_COGE/// Cognitive Smart Memory ProcessorEM_COOL/// Bluechip CoolEngineEM_NORC/// Nanoradio Optimized RISCEM_CSR_KALIMBA/// CSR KalimbaEM_Z80/// Zilog Z80EM_VISIUM/// Controls and Data Services VISIUMcoreEM_FT32/// FTDI Chip FT32EM_MOXIE/// Moxie processorEM_AMDGPU/// AMD GPU/// RISC-V/// Linux BPF -- in-kernel virtual machine/// C-SKY/// Loongson LoongArchEM_SBF/// Solana Binary Format// Values for `FileHeader*::e_version` and `Ident::version`./// Invalid ELF version./// Current ELF version./// Section name./// This is an offset into the section header string table./// Section type. One of the `SHT_*` constants./// Section flags. A combination of the `SHF_*` constants./// Section virtual address at execution./// Section file offset./// Section size in bytes./// Link to another section./// The section relationship depends on the `sh_type` value./// Additional section information./// The meaning of this field depends on the `sh_type` value./// Section alignment./// Entry size if the section holds a table.SectionHeader32/// Section header.SectionHeader64// Special values for section indices./// Undefined section./// Start of reserved section indices./// Start of processor-specific section indices./// End of processor-specific section indices.SHN_LOOS/// Start of OS-specific section indices.SHN_HIOS/// End of OS-specific section indices./// Associated symbol is absolute./// Associated symbol is common.SHN_XINDEX/// Section index is in the `SHT_SYMTAB_SHNDX` section./// End of reserved section indices.// Values for `SectionHeader*::sh_type`./// Section header table entry is unused./// Program data./// Symbol table./// String table./// Relocation entries with explicit addends./// Symbol hash table./// Dynamic linking information./// Notes./// Program space with no data (bss)./// Relocation entries without explicit addends./// Reserved section type./// Dynamic linker symbol table.SHT_INIT_ARRAY/// Array of constructors.SHT_FINI_ARRAY/// Array of destructors.SHT_PREINIT_ARRAY/// Array of pre-constructors.SHT_GROUP/// Section group.SHT_SYMTAB_SHNDX/// Extended section indices for a symbol table.SHT_LOOS/// Start of OS-specific section types.SHT_GNU_ATTRIBUTES/// Object attributes.SHT_GNU_HASH/// GNU-style hash table.SHT_GNU_LIBLIST/// Prelink library listSHT_CHECKSUM/// Checksum for DSO content.SHT_LOSUNW/// Sun-specific low bound.SHT_SUNW_moveSHT_SUNW_COMDATSHT_SUNW_syminfoSHT_GNU_VERDEF/// Version definition section.SHT_GNU_VERNEED/// Version needs section.SHT_GNU_VERSYM/// Version symbol table.SHT_HISUNW/// Sun-specific high bound.SHT_HIOS/// End of OS-specific section types./// Start of processor-specific section types./// End of processor-specific section types./// Start of application-specific section types./// End of application-specific section types.// Values for `SectionHeader*::sh_flags`./// Section is writable./// Section occupies memory during execution./// Section is executable./// Section may be be merged to eliminate duplication./// Section contains nul-terminated strings./// The `sh_info` field contains a section header table index./// Section has special ordering requirements when combining sections./// Section requires special OS-specific handling./// Section is a member of a group./// Section holds thread-local storage./// Section is compressed./// Compressed sections begin with one of the `CompressionHeader*` headers./// OS-specific section flags./// Processor-specific section flags./// This section is excluded from the final executable or shared library./// Compression format. One of the `ELFCOMPRESS_*` values./// Uncompressed data size./// Uncompressed data alignment.CompressionHeader32/// Section compression header./// Used when `SHF_COMPRESSED` is set./// Note: this type currently allows for misaligned headers, but that may be/// changed in a future version./// Reserved.CompressionHeader64/// ZLIB/DEFLATE algorithm.ELFCOMPRESS_ZSTD/// Zstandard algorithm.ELFCOMPRESS_LOOS/// Start of OS-specific compression types.ELFCOMPRESS_HIOS/// End of OS-specific compression types.ELFCOMPRESS_LOPROC/// Start of processor-specific compression types.ELFCOMPRESS_HIPROC/// End of processor-specific compression types.GRP_COMDAT// Values for the flag entry for section groups./// Mark group as COMDAT./// Symbol name./// This is an offset into the symbol string table./// Symbol value./// Symbol size./// Symbol type and binding./// Use the `st_type` and `st_bind` methods to access this value./// Symbol visibility./// Use the `st_visibility` method to access this value./// Section index or one of the `SHN_*` values.Sym32/// Symbol table entry.st_visibility/// Get the `st_visibility` component of the `st_info` field./// Use the `st_bind` and `st_type` methods to access this value.Sym64si_boundto/// Direct bindings, symbol bound to.si_flags/// Per symbol flags.Syminfo32/// Additional information about a `Sym32`.Syminfo64/// Additional information about a `Sym64`.SYMINFO_BT_SELF// Values for `Syminfo*::si_boundto`./// Symbol bound to selfSYMINFO_BT_PARENT/// Symbol bound to parentSYMINFO_BT_LOWRESERVE/// Beginning of reserved entriesSYMINFO_FLG_DIRECT// Values for `Syminfo*::si_flags`./// Direct bound symbolSYMINFO_FLG_PASSTHRU/// Pass-thru symbol for translatorSYMINFO_FLG_COPY/// Symbol is a copy-relocSYMINFO_FLG_LAZYLOAD/// Symbol bound to object to be lazy loadedSYMINFO_NONE// Syminfo version values.SYMINFO_CURRENTSYMINFO_NUM// Values for bind component of `Sym*::st_info`./// Local symbol./// Global symbol./// Weak symbol.STB_LOOS/// Start of OS-specific symbol binding.STB_GNU_UNIQUE/// Unique symbol.STB_HIOS/// End of OS-specific symbol binding.STB_LOPROC/// Start of processor-specific symbol binding.STB_HIPROC/// End of processor-specific symbol binding.// Values for type component of `Sym*::st_info`./// Symbol type is unspecified./// Symbol is a data object./// Symbol is a code object./// Symbol is associated with a section./// Symbol's name is a file name./// Symbol is a common data object./// Symbol is a thread-local storage object.STT_LOOS/// Start of OS-specific symbol types.STT_GNU_IFUNC/// Symbol is an indirect code object.STT_HIOS/// End of OS-specific symbol types.STT_LOPROC/// Start of processor-specific symbol types.STT_HIPROC/// End of processor-specific symbol types.// Values for visibility component of `Symbol*::st_other`./// Default symbol visibility rules.STV_INTERNAL/// Processor specific hidden class.STV_HIDDEN/// Symbol is not visible to other components.STV_PROTECTED/// Symbol is visible to other components, but is not preemptible./// Relocation address./// Relocation type and symbol index.Rel32/// Relocation table entry without explicit addend.r_sym/// Get the `r_sym` component of the `r_info` field./// Get the `r_type` component of the `r_info` field./// Calculate the `r_info` field given the `r_sym` and `r_type` components.set_r_info/// Set the `r_info` field given the `r_sym` and `r_type` components./// Explicit addend.Rela32/// Relocation table entry with explicit addend.Rel64Rela64get_r_info/// Segment type. One of the `PT_*` constants./// Segment file offset./// Segment virtual address./// Segment physical address./// Segment size in the file./// Segment size in memory./// Segment flags. A combination of the `PF_*` constants./// Segment alignment.ProgramHeader32/// Program segment header./// Special value for `FileHeader*::e_phnum`./// This indicates that the real number of program headers is too large to fit into e_phnum./// Instead the real value is in the field `sh_info` of section 0.// Values for `ProgramHeader*::p_type`./// Program header table entry is unused./// Loadable program segment./// Program interpreter./// Auxiliary information./// Segment contains the program header table./// Thread-local storage segment./// Start of OS-specific segment types./// GCC `.eh_frame_hdr` segment./// Indicates stack executability./// Read-only after relocation./// Segment containing `.note.gnu.property` section./// End of OS-specific segment types./// Start of processor-specific segment types./// End of processor-specific segment types.// Values for `ProgramHeader*::p_flags`./// Segment is executable./// Segment is writable./// Segment is readable./// OS-specific segment flags./// Processor-specific segment flags.ELF_NOTE_CORE/// Note name for core files.ELF_NOTE_LINUX/// Note name for linux core files./// Notes in linux core files may also use `ELF_NOTE_CORE`.// Values for `NoteHeader*::n_type` in core files./// Contains copy of prstatus struct./// Contains copy of fpregset struct./// Contains copy of prpsinfo struct./// Contains copy of prxregset struct./// Contains copy of task structure./// String from sysinfo(SI_PLATFORM)./// Contains copy of auxv array./// Contains copy of gwindows struct./// Contains copy of asrset struct./// Contains copy of pstatus struct./// Contains copy of psinfo struct./// Contains copy of prcred struct./// Contains copy of utsname struct./// Contains copy of lwpstatus struct./// Contains copy of lwpinfo struct./// Contains copy of fprxregset struct./// Contains copy of siginfo_t, size might increase./// Contains information about mapped files./// Contains copy of user_fxsr_struct./// PowerPC Altivec/VMX registers./// PowerPC SPE/EVR registers./// PowerPC VSX registers./// Target Address Register./// Program Priority Register./// Data Stream Control Register./// Event Based Branch Registers./// Performance Monitor Registers./// TM checkpointed GPR Registers./// TM checkpointed FPR Registers./// TM checkpointed VMX Registers./// TM checkpointed VSX Registers./// TM Special Purpose Registers./// TM checkpointed Target Address Register./// TM checkpointed Program Priority Register./// TM checkpointed Data Stream Control Register./// Memory Protection Keys registers./// i386 TLS slots (struct user_desc)./// x86 io permission bitmap (1=deny)./// x86 extended state using xsave./// s390 upper register halves./// s390 timer register./// s390 TOD clock comparator register./// s390 TOD programmable register./// s390 control registers./// s390 prefix register./// s390 breaking event address./// s390 system call restart data./// s390 transaction diagnostic block./// s390 vector registers 0-15 upper half./// s390 vector registers 16-31./// s390 guarded storage registers./// s390 guarded storage broadcast control block./// s390 runtime instrumentation./// ARM VFP/NEON registers./// ARM TLS register./// ARM hardware breakpoint registers./// ARM hardware watchpoint registers./// ARM system call number./// ARM Scalable Vector Extension registers./// Vmcore Device Dump Note./// MIPS DSP ASE registers./// MIPS floating-point mode.NT_VERSION/// Note type for version string./// This note may appear in object files./// It must be handled as a special case because it has no descriptor, and instead/// uses the note name as the version string./// Dynamic entry type./// Value (integer or address).Dyn32/// Dynamic section entry.Dyn64/// Marks end of dynamic section/// Name of needed library/// Size in bytes of PLT relocs/// Processor defined value/// Address of symbol hash table/// Address of string table/// Address of symbol table/// Address of Rela relocs/// Total size of Rela relocs/// Size of one Rela reloc/// Size of string table/// Size of one symbol table entry/// Address of init function/// Address of termination function/// Name of shared object/// Library search path (deprecated)/// Start symbol search here/// Address of Rel relocs/// Total size of Rel relocs/// Size of one Rel reloc/// Type of reloc in PLT/// For debugging; unspecified/// Reloc might modify .text/// Address of PLT relocsDT_BIND_NOW/// Process relocations of objectDT_INIT_ARRAY/// Array with addresses of init fctDT_FINI_ARRAY/// Array with addresses of fini fctDT_INIT_ARRAYSZ/// Size in bytes of DT_INIT_ARRAYDT_FINI_ARRAYSZ/// Size in bytes of DT_FINI_ARRAYDT_RUNPATH/// Library search pathDT_FLAGS/// Flags for the object being loaded/// Start of encoded rangeDT_PREINIT_ARRAY/// Array with addresses of preinit fctDT_PREINIT_ARRAYSZ/// size in bytes of DT_PREINIT_ARRAYDT_SYMTAB_SHNDX/// Address of SYMTAB_SHNDX section/// Start of OS-specific/// End of OS-specific/// Start of processor-specific/// End of processor-specific// `DT_*` entries between `DT_VALRNGHI` & `DT_VALRNGLO` use `d_val` as a value.DT_GNU_PRELINKED/// Prelinking timestampDT_GNU_CONFLICTSZ/// Size of conflict sectionDT_GNU_LIBLISTSZ/// Size of library listDT_CHECKSUMDT_PLTPADSZDT_MOVEENTDT_MOVESZDT_FEATURE_1/// Feature selection (DTF_*).DT_POSFLAG_1/// Flags for DT_* entries, affecting the following DT_* entry.DT_SYMINSZ/// Size of syminfo table (in bytes)DT_SYMINENT/// Entry size of syminfo// `DT_*` entries between `DT_ADDRRNGHI` & `DT_ADDRRNGLO` use `d_val` as an address.// If any adjustment is made to the ELF object after it has been// built these entries will need to be adjusted.DT_TLSDESC_PLTDT_TLSDESC_GOTDT_GNU_CONFLICT/// Start of conflict sectionDT_GNU_LIBLIST/// Library listDT_CONFIG/// Configuration information.DT_DEPAUDIT/// Dependency auditing.DT_AUDIT/// Object auditing.DT_PLTPAD/// PLT padding.DT_MOVETAB/// Move table.DT_SYMINFO/// Syminfo table.// The versioning entry types.  The next are defined as part of the// GNU extension./// State flags, see DF_1_* below./// Address of version definition table/// Number of version definitions/// Address of table with needed versions/// Number of needed versionsDT_AUXILIARY// Machine-independent extensions in the "processor-specific" range./// Shared object to load before selfDT_FILTER/// Shared object to get values fromDF_ORIGIN// Values of `Dyn*::d_val` in the `DT_FLAGS` entry./// Object may use DF_ORIGINDF_SYMBOLIC/// Symbol resolutions starts hereDF_TEXTREL/// Object contains text relocationsDF_BIND_NOW/// No lazy binding for this objectDF_STATIC_TLS/// Module uses the static TLS modelDF_1_NOW// Values of `Dyn*::d_val` in the `DT_FLAGS_1` entry./// Set RTLD_NOW for this object.DF_1_GLOBAL/// Set RTLD_GLOBAL for this object.DF_1_GROUP/// Set RTLD_GROUP for this object.DF_1_NODELETE/// Set RTLD_NODELETE for this object.DF_1_LOADFLTR/// Trigger filtee loading at runtime.DF_1_INITFIRST/// Set RTLD_INITFIRST for this object.DF_1_NOOPEN/// Set RTLD_NOOPEN for this object.DF_1_ORIGIN/// $ORIGIN must be handled.DF_1_DIRECT/// Direct binding enabled.DF_1_TRANSDF_1_INTERPOSE/// Object is used to interpose.DF_1_NODEFLIB/// Ignore default lib search path.DF_1_NODUMP/// Object can't be dldump'ed.DF_1_CONFALT/// Configuration alternative created.DF_1_ENDFILTEE/// Filtee terminates filters search.DF_1_DISPRELDNE/// Disp reloc applied at build time.DF_1_DISPRELPND/// Disp reloc applied at run-time.DF_1_NODIRECT/// Object has no-direct binding.DF_1_IGNMULDEFDF_1_NOKSYMSDF_1_NOHDRDF_1_EDITED/// Object is modified after built.DF_1_NORELOCDF_1_SYMINTPOSE/// Object has individual interposers.DF_1_GLOBAUDIT/// Global auditing required.DF_1_SINGLETON/// Singleton symbols are used.DF_1_STUBDF_1_PIEVersym/// Version symbol informationVERSYM_HIDDEN/// Symbol is hidden.VERSYM_VERSION/// Symbol version index./// Version revision/// Version information/// Version Index/// Number of associated aux entries/// Version name hash value/// Offset in bytes to verdaux array/// Offset in bytes to next verdef entryVerdef/// Version definition sectionsVER_DEF_NONE// Legal values for vd_version (version revision)./// No version/// Current version// Legal values for vd_flags (version information flags)./// Version definition of file itself// Legal values for vd_flags and vna_flags (version information flags)./// Weak version identifierVER_NDX_LOCAL// Versym symbol index values./// Symbol is local.VER_NDX_GLOBAL/// Symbol is global./// Version or dependency names/// Offset in bytes to next verdauxVerdaux/// Auxiliary version information.vn_version/// Version of structurevn_cntvn_file/// Offset of filename for this dependencyvn_aux/// Offset in bytes to vernaux arrayvn_next/// Offset in bytes to next verneed entryVerneed/// Version dependency.VER_NEED_NONE// Legal values for vn_version (version revision).VER_NEED_CURRENTvna_hash/// Hash value of dependency namevna_flags/// Dependency specific informationvna_othervna_name/// Dependency name string offsetvna_next/// Offset in bytes to next vernaux entryVernaux/// Auxiliary needed version information./// Length of the note's name./// Some known names are defined by the `ELF_NOTE_*` constants./// Length of the note's descriptor./// The content of the descriptor depends on the note name and type./// Type of the note./// One of the `NT_*` constants. The note name determines which/// `NT_*` constants are valid.NoteHeader32/// Note section entry header./// A note consists of a header followed by a variable length name and descriptor.NoteHeader64ELF_NOTE_SOLARIS/// Solaris entries in the note section have this name.NT_SOLARIS_PAGESIZE_HINT// Values for `n_type` when the name is `ELF_NOTE_SOLARIS`./// Desired pagesize for the binary./// GNU entries in the note section have this name.ELF_NOTE_GO/// Go entries in the note section have this name.// See https://go-review.googlesource.com/9520 and https://go-review.googlesource.com/10704.NT_GNU_ABI_TAG/// ABI information./// The descriptor consists of words:/// - word 0: OS descriptor/// - word 1: major version of the ABI/// - word 2: minor version of the ABI/// - word 3: subminor version of the ABIELF_NOTE_OS_LINUX/// OS descriptor for `NT_GNU_ABI_TAG`.ELF_NOTE_OS_GNUELF_NOTE_OS_SOLARIS2ELF_NOTE_OS_FREEBSDNT_GNU_HWCAP/// Synthetic hwcap information./// The descriptor begins with two words:/// - word 0: number of entries/// - word 1: bitmask of enabled entries/// Then follow variable-length entries, one byte followed by a/// '\0'-terminated hwcap name string.  The byte gives the bit/// number to test if enabled, (1U << bit) & bitmask.  *//// Build ID bits as generated by `ld --build-id`./// The descriptor consists of any nonzero number of bytes.NT_GO_BUILD_ID/// Build ID bits as generated by Go's gc compiler.// See https://go-review.googlesource.com/10707.NT_GNU_GOLD_VERSION/// Version note generated by GNU gold containing a version string./// Program property.GNU_PROPERTY_STACK_SIZE/// Stack size.GNU_PROPERTY_NO_COPY_ON_PROTECTED/// No copy relocation on protected data symbol.GNU_PROPERTY_UINT32_AND_LO// A 4-byte unsigned integer property: A bit is set if it is set in all// relocatable inputs.GNU_PROPERTY_UINT32_AND_HIGNU_PROPERTY_UINT32_OR_LO// A 4-byte unsigned integer property: A bit is set if it is set in anyGNU_PROPERTY_UINT32_OR_HIGNU_PROPERTY_1_NEEDED/// The needed properties by the object file.  */GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS/// Set if the object file requires canonical function pointers and/// cannot be used with copy relocation.GNU_PROPERTY_LOPROC/// Processor-specific semantics, loGNU_PROPERTY_HIPROC/// Processor-specific semantics, hiGNU_PROPERTY_LOUSER/// Application-specific semantics, loGNU_PROPERTY_HIUSER/// Application-specific semantics, hi/// AArch64 specific GNU properties.GNU_PROPERTY_AARCH64_FEATURE_PAUTHGNU_PROPERTY_AARCH64_FEATURE_1_PACGNU_PROPERTY_X86_UINT32_AND_LOGNU_PROPERTY_X86_UINT32_AND_HIGNU_PROPERTY_X86_UINT32_OR_LOGNU_PROPERTY_X86_UINT32_OR_HIGNU_PROPERTY_X86_UINT32_OR_AND_LO// relocatable inputs and the property is present in all relocatable// inputs.GNU_PROPERTY_X86_UINT32_OR_AND_HIGNU_PROPERTY_X86_ISA_1_USED/// The x86 instruction sets indicated by the corresponding bits are/// used in program.  Their support in the hardware is optional.GNU_PROPERTY_X86_ISA_1_NEEDED/// used in program and they must be supported by the hardware.GNU_PROPERTY_X86_FEATURE_1_AND/// X86 processor-specific features used in program.GNU_PROPERTY_X86_ISA_1_BASELINE/// GNU_PROPERTY_X86_ISA_1_BASELINE: CMOV, CX8 (cmpxchg8b), FPU (fld),/// MMX, OSFXSR (fxsave), SCE (syscall), SSE and SSE2.GNU_PROPERTY_X86_ISA_1_V2/// GNU_PROPERTY_X86_ISA_1_V2: GNU_PROPERTY_X86_ISA_1_BASELINE,/// CMPXCHG16B (cmpxchg16b), LAHF-SAHF (lahf), POPCNT (popcnt), SSE3,/// SSSE3, SSE4.1 and SSE4.2.GNU_PROPERTY_X86_ISA_1_V3/// GNU_PROPERTY_X86_ISA_1_V3: GNU_PROPERTY_X86_ISA_1_V2, AVX, AVX2, BMI1,/// BMI2, F16C, FMA, LZCNT, MOVBE, XSAVE.GNU_PROPERTY_X86_ISA_1_V4/// GNU_PROPERTY_X86_ISA_1_V4: GNU_PROPERTY_X86_ISA_1_V3, AVX512F,/// AVX512BW, AVX512CD, AVX512DQ and AVX512VL.GNU_PROPERTY_X86_FEATURE_1_IBT/// This indicates that all executable sections are compatible with IBT.GNU_PROPERTY_X86_FEATURE_1_SHSTK/// This indicates that all executable sections are compatible with SHSTK.bucket_count/// The number of hash buckets.chain_count/// The number of chain values.// Array of hash bucket start indices.// buckets: U32<E>[bucket_count]// Array of hash chain links. An index of 0 terminates the chain.// chains: U32<E>[chain_count]HashHeader/// Header of `SHT_HASH` section./// Calculate the SysV hash for a symbol name./// Used for `SHT_HASH`.symbol_base/// The symbol table index of the first symbol in the hash.bloom_count/// The number of words in the bloom filter./// Must be a non-zero power of 2.bloom_shift/// The bit shift count for the bloom filter.// Array of bloom filter words.// bloom_filters: U32<E>[bloom_count] or U64<E>[bloom_count]// Array of hash values, one for each symbol starting at symbol_base.// values: U32<E>[symbol_count]GnuHashHeader/// Header of `SHT_GNU_HASH` section.gnu_hash/// Calculate the GNU hash for a symbol name./// Used for `SHT_GNU_HASH`.R_68K_NONE/// No relocR_68K_32/// Direct 32 bitR_68K_16/// Direct 16 bitR_68K_8/// Direct 8 bitR_68K_PC32/// PC relative 32 bitR_68K_PC16/// PC relative 16 bitR_68K_PC8/// PC relative 8 bitR_68K_GOT32/// 32 bit PC relative GOT entryR_68K_GOT16/// 16 bit PC relative GOT entryR_68K_GOT8/// 8 bit PC relative GOT entryR_68K_GOT32O/// 32 bit GOT offsetR_68K_GOT16O/// 16 bit GOT offsetR_68K_GOT8O/// 8 bit GOT offsetR_68K_PLT32/// 32 bit PC relative PLT addressR_68K_PLT16/// 16 bit PC relative PLT addressR_68K_PLT8/// 8 bit PC relative PLT addressR_68K_PLT32O/// 32 bit PLT offsetR_68K_PLT16O/// 16 bit PLT offsetR_68K_PLT8O/// 8 bit PLT offsetR_68K_COPY/// Copy symbol at runtimeR_68K_GLOB_DAT/// Create GOT entryR_68K_JMP_SLOT/// Create PLT entryR_68K_RELATIVE/// Adjust by program baseR_68K_TLS_GD32/// 32 bit GOT offset for GDR_68K_TLS_GD16/// 16 bit GOT offset for GDR_68K_TLS_GD8/// 8 bit GOT offset for GDR_68K_TLS_LDM32/// 32 bit GOT offset for LDMR_68K_TLS_LDM16/// 16 bit GOT offset for LDMR_68K_TLS_LDM8/// 8 bit GOT offset for LDMR_68K_TLS_LDO32/// 32 bit module-relative offsetR_68K_TLS_LDO16/// 16 bit module-relative offsetR_68K_TLS_LDO8/// 8 bit module-relative offsetR_68K_TLS_IE32/// 32 bit GOT offset for IER_68K_TLS_IE16/// 16 bit GOT offset for IER_68K_TLS_IE8/// 8 bit GOT offset for IER_68K_TLS_LE32/// 32 bit offset relative to static TLS blockR_68K_TLS_LE16/// 16 bit offset relative to static TLS blockR_68K_TLS_LE8/// 8 bit offset relative to static TLS blockR_68K_TLS_DTPMOD32/// 32 bit module numberR_68K_TLS_DTPREL32R_68K_TLS_TPREL32/// 32 bit TP-relative offsetR_386_NONER_386_32R_386_PC32R_386_GOT32/// 32 bit GOT entryR_386_PLT32/// 32 bit PLT addressR_386_COPYR_386_GLOB_DATR_386_JMP_SLOTR_386_RELATIVER_386_GOTOFF/// 32 bit offset to GOTR_386_GOTPC/// 32 bit PC relative offset to GOTR_386_32PLT/// Direct 32 bit PLT addressR_386_TLS_TPOFF/// Offset in static TLS blockR_386_TLS_IE/// Address of GOT entry for static TLS block offsetR_386_TLS_GOTIE/// GOT entry for static TLS block offsetR_386_TLS_LE/// Offset relative to static TLS blockR_386_TLS_GD/// Direct 32 bit for GNU version of general dynamic thread local dataR_386_TLS_LDM/// Direct 32 bit for GNU version of local dynamic thread local data in LE codeR_386_16R_386_PC16R_386_8R_386_PC8R_386_TLS_GD_32/// Direct 32 bit for general dynamic thread local dataR_386_TLS_GD_PUSH/// Tag for pushl in GD TLS codeR_386_TLS_GD_CALL/// Relocation for call to __tls_get_addr()R_386_TLS_GD_POP/// Tag for popl in GD TLS codeR_386_TLS_LDM_32/// Direct 32 bit for local dynamic thread local data in LE codeR_386_TLS_LDM_PUSH/// Tag for pushl in LDM TLS codeR_386_TLS_LDM_CALL/// Relocation for call to __tls_get_addr() in LDM codeR_386_TLS_LDM_POP/// Tag for popl in LDM TLS codeR_386_TLS_LDO_32/// Offset relative to TLS blockR_386_TLS_IE_32/// GOT entry for negated static TLS block offsetR_386_TLS_LE_32/// Negated offset relative to static TLS blockR_386_TLS_DTPMOD32/// ID of module containing symbolR_386_TLS_DTPOFF32/// Offset in TLS blockR_386_TLS_TPOFF32/// Negated offset in static TLS blockR_386_SIZE32/// 32-bit symbol sizeR_386_TLS_GOTDESC/// GOT offset for TLS descriptor.R_386_TLS_DESC_CALL/// Marker of call through TLS descriptor for relaxation.R_386_TLS_DESC/// TLS descriptor containing pointer to code and to argument, returning the TLS offset for the symbol.R_386_IRELATIVE/// Adjust indirectly by program baseR_386_GOT32X/// Load from 32 bit GOT entry, relaxable.R_SHARC_ADDR24_V3/// 24-bit absolute address in bits 23:0 of a 48-bit instr/// Targets:/// * Type 25a (PC_DIRECT)R_SHARC_ADDR32_V3/// 32-bit absolute address in bits 31:0 of a 48-bit instr/// * Type 14a/// * Type 14d/// * Type 15a/// * Type 16a/// * Type 17a/// * Type 18a/// * Type 19aR_SHARC_ADDR_VAR_V3/// 32-bit absolute address in bits 31:0 of a 32-bit data location/// Represented with `RelocationEncoding::Generic`R_SHARC_PCRSHORT_V3/// 6-bit PC-relative address in bits 32:27 of a 48-bit instr/// * Type 9a/// * Type 10aR_SHARC_PCRLONG_V3/// 24-bit PC-relative address in bits 23:0 of a 48-bit instr/// * Type 8a/// * Type 12a (truncated to 23 bits after relocation)/// * Type 13a (truncated to 23 bits after relocation)/// * Type 25a (PC Relative)R_SHARC_DATA6_V3/// 6-bit absolute address in bits 32:27 of a 48-bit instr/// * Type 4a/// * Type 4b/// * Type 4dR_SHARC_DATA16_V3/// 16-bit absolute address in bits 39:24 of a 48-bit instr/// * Type 12aR_SHARC_DATA6_VISA_V3/// 6-bit absolute address into bits 16:11 of a 32-bit instrR_SHARC_DATA7_VISA_V3/// 7-bit absolute address into bits 6:0 of a 32-bit instrR_SHARC_DATA16_VISA_V3/// 16-bit absolute address into bits 15:0 of a 32-bit instrR_SHARC_PCR6_VISA_V3/// 6-bit PC-relative address into bits 16:11 of a Type B/// * Type 9bR_SHARC_ADDR_VAR16_V3/// 16-bit absolute address into bits 15:0 of a 16-bit location.R_SHARC_CALC_PUSH_ADDRR_SHARC_CALC_PUSH_ADDENDR_SHARC_CALC_ADDR_SHARC_CALC_SUBR_SHARC_CALC_MULR_SHARC_CALC_DIVR_SHARC_CALC_MODR_SHARC_CALC_LSHIFTR_SHARC_CALC_RSHIFTR_SHARC_CALC_ANDR_SHARC_CALC_ORR_SHARC_CALC_XORR_SHARC_CALC_PUSH_LENR_SHARC_CALC_NOTSHT_SHARC_ADI_ATTRIBUTES/// .adi.attributesSTT_SPARC_REGISTER/// Global register reserved to app.EF_SPARCV9_MMEF_SPARCV9_TSOEF_SPARCV9_PSOEF_SPARCV9_RMOEF_SPARC_LEDATA/// little endian dataEF_SPARC_EXT_MASKEF_SPARC_32PLUS/// generic V8+ featuresEF_SPARC_SUN_US1/// Sun UltraSPARC1 extensionsEF_SPARC_HAL_R1/// HAL R1 extensionsEF_SPARC_SUN_US3/// Sun UltraSPARCIII extensionsR_SPARC_NONER_SPARC_8R_SPARC_16R_SPARC_32R_SPARC_DISP8R_SPARC_DISP16R_SPARC_DISP32R_SPARC_WDISP30/// PC relative 30 bit shiftedR_SPARC_WDISP22/// PC relative 22 bit shiftedR_SPARC_HI22/// High 22 bitR_SPARC_22/// Direct 22 bitR_SPARC_13/// Direct 13 bitR_SPARC_LO10/// Truncated 10 bitR_SPARC_GOT10/// Truncated 10 bit GOT entryR_SPARC_GOT13/// 13 bit GOT entryR_SPARC_GOT22/// 22 bit GOT entry shiftedR_SPARC_PC10/// PC relative 10 bit truncatedR_SPARC_PC22R_SPARC_WPLT30/// 30 bit PC relative PLT addressR_SPARC_COPYR_SPARC_GLOB_DATR_SPARC_JMP_SLOTR_SPARC_RELATIVER_SPARC_UA32/// Direct 32 bit unalignedR_SPARC_PLT32/// Direct 32 bit ref to PLT entryR_SPARC_HIPLT22/// High 22 bit PLT entryR_SPARC_LOPLT10/// Truncated 10 bit PLT entryR_SPARC_PCPLT32/// PC rel 32 bit ref to PLT entryR_SPARC_PCPLT22/// PC rel high 22 bit PLT entryR_SPARC_PCPLT10/// PC rel trunc 10 bit PLT entryR_SPARC_10/// Direct 10 bitR_SPARC_11/// Direct 11 bitR_SPARC_64/// Direct 64 bitR_SPARC_OLO10/// 10bit with secondary 13bit addendR_SPARC_HH22/// Top 22 bits of direct 64 bitR_SPARC_HM10/// High middle 10 bits of ...R_SPARC_LM22/// Low middle 22 bits of ...R_SPARC_PC_HH22/// Top 22 bits of pc rel 64 bitR_SPARC_PC_HM10/// High middle 10 bit of ...R_SPARC_PC_LM22/// Low miggle 22 bits of ...R_SPARC_WDISP16/// PC relative 16 bit shiftedR_SPARC_WDISP19/// PC relative 19 bit shiftedR_SPARC_GLOB_JMP/// was part of v9 ABI but was removedR_SPARC_7/// Direct 7 bitR_SPARC_5/// Direct 5 bitR_SPARC_6/// Direct 6 bitR_SPARC_DISP64/// PC relative 64 bitR_SPARC_PLT64/// Direct 64 bit ref to PLT entryR_SPARC_HIX22/// High 22 bit complementedR_SPARC_LOX10/// Truncated 11 bit complementedR_SPARC_H44/// Direct high 12 of 44 bitR_SPARC_M44/// Direct mid 22 of 44 bitR_SPARC_L44/// Direct low 10 of 44 bitR_SPARC_REGISTER/// Global register usageR_SPARC_UA64/// Direct 64 bit unalignedR_SPARC_UA16/// Direct 16 bit unalignedR_SPARC_TLS_GD_HI22R_SPARC_TLS_GD_LO10R_SPARC_TLS_GD_ADDR_SPARC_TLS_GD_CALLR_SPARC_TLS_LDM_HI22R_SPARC_TLS_LDM_LO10R_SPARC_TLS_LDM_ADDR_SPARC_TLS_LDM_CALLR_SPARC_TLS_LDO_HIX22R_SPARC_TLS_LDO_LOX10R_SPARC_TLS_LDO_ADDR_SPARC_TLS_IE_HI22R_SPARC_TLS_IE_LO10R_SPARC_TLS_IE_LDR_SPARC_TLS_IE_LDXR_SPARC_TLS_IE_ADDR_SPARC_TLS_LE_HIX22R_SPARC_TLS_LE_LOX10R_SPARC_TLS_DTPMOD32R_SPARC_TLS_DTPMOD64R_SPARC_TLS_DTPOFF32R_SPARC_TLS_DTPOFF64R_SPARC_TLS_TPOFF32R_SPARC_TLS_TPOFF64R_SPARC_GOTDATA_HIX22R_SPARC_GOTDATA_LOX10R_SPARC_GOTDATA_OP_HIX22R_SPARC_GOTDATA_OP_LOX10R_SPARC_GOTDATA_OPR_SPARC_H34R_SPARC_SIZE32R_SPARC_SIZE64R_SPARC_WDISP10R_SPARC_JMP_IRELR_SPARC_IRELATIVER_SPARC_GNU_VTINHERITR_SPARC_GNU_VTENTRYR_SPARC_REV32DT_SPARC_REGISTEREF_MIPS_NOREORDER/// A .noreorder directive was used.EF_MIPS_PIC/// Contains PIC code.EF_MIPS_CPIC/// Uses PIC calling sequence.EF_MIPS_XGOTEF_MIPS_64BIT_WHIRLEF_MIPS_ABI2EF_MIPS_ABI_ON32EF_MIPS_FP64/// Uses FP64 (12 callee-saved).EF_MIPS_NAN2008/// Uses IEEE 754-2008 NaN encoding.EF_MIPS_ARCH/// MIPS architecture level.EF_MIPS_ABI_O32/// The first MIPS 32 bit ABIEF_MIPS_ABI_O64/// O32 ABI extended for 64-bit architecturesEF_MIPS_ABI_EABI32/// EABI in 32-bit modeEF_MIPS_ABI_EABI64/// EABI in 64-bit modeEF_MIPS_ABI/// Mask for selecting EF_MIPS_ABI_ variantEF_MIPS_ARCH_1/// -mips1 code.EF_MIPS_ARCH_2/// -mips2 code.EF_MIPS_ARCH_3/// -mips3 code.EF_MIPS_ARCH_4/// -mips4 code.EF_MIPS_ARCH_5/// -mips5 code.EF_MIPS_ARCH_32/// MIPS32 code.EF_MIPS_ARCH_64/// MIPS64 code.EF_MIPS_ARCH_32R2/// MIPS32r2 code.EF_MIPS_ARCH_64R2/// MIPS64r2 code.EF_MIPS_ARCH_32R6/// MIPS32r6 codeEF_MIPS_ARCH_64R6/// MIPS64r6 codeSHN_MIPS_ACOMMON/// Allocated common symbols.SHN_MIPS_TEXT/// Allocated test symbols.SHN_MIPS_DATA/// Allocated data symbols.SHN_MIPS_SCOMMON/// Small common symbols.SHN_MIPS_SUNDEFINED/// Small undefined symbols.SHT_MIPS_LIBLIST/// Shared objects used in link.SHT_MIPS_MSYMSHT_MIPS_CONFLICT/// Conflicting symbols.SHT_MIPS_GPTAB/// Global data area sizes.SHT_MIPS_UCODE/// Reserved for SGI/MIPS compilersSHT_MIPS_DEBUG/// MIPS ECOFF debugging info.SHT_MIPS_REGINFO/// Register usage information.SHT_MIPS_PACKAGESHT_MIPS_PACKSYMSHT_MIPS_RELDSHT_MIPS_IFACESHT_MIPS_CONTENTSHT_MIPS_OPTIONS/// Miscellaneous options.SHT_MIPS_SHDRSHT_MIPS_FDESCSHT_MIPS_EXTSYMSHT_MIPS_DENSESHT_MIPS_PDESCSHT_MIPS_LOCSYMSHT_MIPS_AUXSYMSHT_MIPS_OPTSYMSHT_MIPS_LOCSTRSHT_MIPS_LINESHT_MIPS_RFDESCSHT_MIPS_DELTASYMSHT_MIPS_DELTAINSTSHT_MIPS_DELTACLASSSHT_MIPS_DWARF/// DWARF debugging information.SHT_MIPS_DELTADECLSHT_MIPS_SYMBOL_LIBSHT_MIPS_EVENTS/// Event section.SHT_MIPS_TRANSLATESHT_MIPS_PIXIESHT_MIPS_XLATESHT_MIPS_XLATE_DEBUGSHT_MIPS_WHIRLSHT_MIPS_EH_REGIONSHT_MIPS_XLATE_OLDSHT_MIPS_PDR_EXCEPTIONSHF_MIPS_GPREL/// Must be in global data area.SHF_MIPS_MERGESHF_MIPS_ADDRSHF_MIPS_STRINGSSHF_MIPS_NOSTRIPSHF_MIPS_LOCALSHF_MIPS_NAMESSHF_MIPS_NODUPESTO_MIPS_PLTSTO_MIPS_SC_ALIGN_UNUSED/// Only valid for `STB_MIPS_SPLIT_COMMON`.STB_MIPS_SPLIT_COMMON// MIPS values for `Sym32::st_info'.ODK_NULL/// Undefined.ODK_REGINFOODK_EXCEPTIONS/// Exception processing options.ODK_PAD/// Section padding options.ODK_HWPATCH/// Hardware workarounds performedODK_FILL/// record the fill value used by the linker.ODK_TAGS/// reserve space for desktop tools to write.ODK_HWAND/// HW workarounds.  'AND' bits when merging.ODK_HWOR/// HW workarounds.  'OR' bits when merging.OEX_FPU_MIN/// FPE's which MUST be enabled.OEX_FPU_MAX/// FPE's which MAY be enabled.OEX_PAGE0/// page zero must be mapped.OEX_SMM/// Force sequential memory mode?OEX_FPDBUG/// Force floating point debug mode?OEX_PRECISEFPOEX_DISMISS/// Dismiss invalid address faults?OEX_FPU_INVALOEX_FPU_DIV0OEX_FPU_OFLOOEX_FPU_UFLOOEX_FPU_INEXOHW_R4KEOP// Masks for `Elf_Options::info` for an `ODK_HWPATCH` entry.  *//// R4000 end-of-page patch.OHW_R8KPFETCH/// may need R8000 prefetch patch.OHW_R5KEOP/// R5000 end-of-page patch.OHW_R5KCVTL/// R5000 cvt.\[ds\].l bug.  clean=1.OPAD_PREFIXOPAD_POSTFIXOPAD_SYMBOLOHWA0_R4KEOP_CHECKEDOHWA1_R4KEOP_CLEANR_MIPS_NONER_MIPS_16R_MIPS_32R_MIPS_REL32R_MIPS_26/// Direct 26 bit shiftedR_MIPS_HI16/// High 16 bitR_MIPS_LO16/// Low 16 bitR_MIPS_GPREL16/// GP relative 16 bitR_MIPS_LITERAL/// 16 bit literal entryR_MIPS_GOT16/// 16 bit GOT entryR_MIPS_PC16R_MIPS_CALL16/// 16 bit GOT entry for functionR_MIPS_GPREL32/// GP relative 32 bitR_MIPS_SHIFT5R_MIPS_SHIFT6R_MIPS_64R_MIPS_GOT_DISPR_MIPS_GOT_PAGER_MIPS_GOT_OFSTR_MIPS_GOT_HI16R_MIPS_GOT_LO16R_MIPS_SUBR_MIPS_INSERT_AR_MIPS_INSERT_BR_MIPS_DELETER_MIPS_HIGHERR_MIPS_HIGHESTR_MIPS_CALL_HI16R_MIPS_CALL_LO16R_MIPS_SCN_DISPR_MIPS_REL16R_MIPS_ADD_IMMEDIATER_MIPS_PJUMPR_MIPS_RELGOTR_MIPS_JALRR_MIPS_TLS_DTPMOD32/// Module number 32 bitR_MIPS_TLS_DTPREL32/// Module-relative offset 32 bitR_MIPS_TLS_DTPMOD64/// Module number 64 bitR_MIPS_TLS_DTPREL64/// Module-relative offset 64 bitR_MIPS_TLS_GDR_MIPS_TLS_LDMR_MIPS_TLS_DTPREL_HI16/// Module-relative offset, high 16 bitsR_MIPS_TLS_DTPREL_LO16/// Module-relative offset, low 16 bitsR_MIPS_TLS_GOTTPRELR_MIPS_TLS_TPREL32/// TP-relative offset, 32 bitR_MIPS_TLS_TPREL64/// TP-relative offset, 64 bitR_MIPS_TLS_TPREL_HI16/// TP-relative offset, high 16 bitsR_MIPS_TLS_TPREL_LO16/// TP-relative offset, low 16 bitsR_MIPS_GLOB_DATR_MIPS_COPYR_MIPS_JUMP_SLOTPT_MIPS_REGINFOPT_MIPS_RTPROC/// Runtime procedure table.PT_MIPS_OPTIONSPT_MIPS_ABIFLAGS/// FP mode requirement.PF_MIPS_LOCALDT_MIPS_RLD_VERSION/// Runtime linker interface versionDT_MIPS_TIME_STAMP/// TimestampDT_MIPS_ICHECKSUM/// ChecksumDT_MIPS_IVERSION/// Version string (string tbl index)DT_MIPS_FLAGS/// FlagsDT_MIPS_BASE_ADDRESS/// Base addressDT_MIPS_MSYMDT_MIPS_CONFLICT/// Address of CONFLICT sectionDT_MIPS_LIBLIST/// Address of LIBLIST sectionDT_MIPS_LOCAL_GOTNO/// Number of local GOT entriesDT_MIPS_CONFLICTNO/// Number of CONFLICT entriesDT_MIPS_LIBLISTNO/// Number of LIBLIST entriesDT_MIPS_SYMTABNO/// Number of DYNSYM entriesDT_MIPS_UNREFEXTNO/// First external DYNSYMDT_MIPS_GOTSYM/// First GOT entry in DYNSYMDT_MIPS_HIPAGENO/// Number of GOT page table entriesDT_MIPS_RLD_MAP/// Address of run time loader map.DT_MIPS_DELTA_CLASS/// Delta C++ class definition.DT_MIPS_DELTA_CLASS_NO/// Number of entries in DT_MIPS_DELTA_CLASS.DT_MIPS_DELTA_INSTANCE/// Delta C++ class instances.DT_MIPS_DELTA_INSTANCE_NO/// Number of entries in DT_MIPS_DELTA_INSTANCE.DT_MIPS_DELTA_RELOC/// Delta relocations.DT_MIPS_DELTA_RELOC_NO/// Number of entries in DT_MIPS_DELTA_RELOC.DT_MIPS_DELTA_SYM/// Delta symbols that Delta relocations refer to.DT_MIPS_DELTA_SYM_NO/// Number of entries in DT_MIPS_DELTA_SYM.DT_MIPS_DELTA_CLASSSYM/// Delta symbols that hold the class declaration.DT_MIPS_DELTA_CLASSSYM_NO/// Number of entries in DT_MIPS_DELTA_CLASSSYM.DT_MIPS_CXX_FLAGS/// Flags indicating for C++ flavor.DT_MIPS_PIXIE_INITDT_MIPS_SYMBOL_LIBDT_MIPS_LOCALPAGE_GOTIDXDT_MIPS_LOCAL_GOTIDXDT_MIPS_HIDDEN_GOTIDXDT_MIPS_PROTECTED_GOTIDXDT_MIPS_OPTIONS/// Address of .options.DT_MIPS_INTERFACE/// Address of .interface.DT_MIPS_DYNSTR_ALIGNDT_MIPS_INTERFACE_SIZE/// Size of the .interface section.DT_MIPS_RLD_TEXT_RESOLVE_ADDR/// Address of rld_text_rsolve function stored in GOT.DT_MIPS_PERF_SUFFIX/// Default suffix of dso to be added by rld on dlopen() calls.DT_MIPS_COMPACT_SIZE/// (O32)Size of compact rel section.DT_MIPS_GP_VALUE/// GP value for aux GOTs.DT_MIPS_AUX_DYNAMIC/// Address of aux .dynamic.DT_MIPS_PLTGOT/// The address of .got.plt in an executable using the new non-PIC ABI.DT_MIPS_RWPLT/// The base of the PLT in an executable using the new non-PIC ABI if that PLT is writable.  For a non-writable PLT, this is omitted or has a zero value.DT_MIPS_RLD_MAP_REL/// An alternative description of the classic MIPS RLD_MAP that is usable in a PIE as it stores a relative offset from the address of the tag rather than an absolute address.RHF_NONE/// No flagsRHF_QUICKSTART/// Use quickstartRHF_NOTPOT/// Hash size not power of 2RHF_NO_LIBRARY_REPLACEMENT/// Ignore LD_LIBRARY_PATHRHF_NO_MOVERHF_SGI_ONLYRHF_GUARANTEE_INITRHF_DELTA_C_PLUS_PLUSRHF_GUARANTEE_START_INITRHF_PIXIERHF_DEFAULT_DELAY_LOADRHF_REQUICKSTARTRHF_REQUICKSTARTEDRHF_CORDRHF_NO_UNRES_UNDEFRHF_RLD_ORDER_SAFELL_NONELL_EXACT_MATCH/// Require exact matchLL_IGNORE_INT_VER/// Ignore interface versionLL_REQUIRE_MINORLL_EXPORTSLL_DELAY_LOADLL_DELTAEF_PARISC_TRAPNIL/// Trap nil pointer dereference.EF_PARISC_EXT/// Program uses arch. extensions.EF_PARISC_LSB/// Program expects little endian.EF_PARISC_WIDE/// Program expects wide mode.EF_PARISC_NO_KABP/// No kernel assisted branch prediction.EF_PARISC_LAZYSWAP/// Allow lazy swapping.EF_PARISC_ARCH/// Architecture version.EFA_PARISC_1_0/// PA-RISC 1.0 big-endian.EFA_PARISC_1_1/// PA-RISC 1.1 big-endian.EFA_PARISC_2_0/// PA-RISC 2.0 big-endian.SHN_PARISC_ANSI_COMMON/// Section for tentatively declared symbols in ANSI C.SHN_PARISC_HUGE_COMMON/// Common blocks in huge model.SHT_PARISC_EXT/// Contains product specific ext.SHT_PARISC_UNWIND/// Unwind information.SHT_PARISC_DOC/// Debug info for optimized code.SHF_PARISC_SHORT/// Section with short addressing.SHF_PARISC_HUGE/// Section far from gp.SHF_PARISC_SBP/// Static branch prediction code.STT_PARISC_MILLICODE/// Millicode function entry point.STT_HP_OPAQUESTT_HP_STUBR_PARISC_NONE/// No reloc.R_PARISC_DIR32/// Direct 32-bit reference.R_PARISC_DIR21L/// Left 21 bits of eff. address.R_PARISC_DIR17R/// Right 17 bits of eff. address.R_PARISC_DIR17F/// 17 bits of eff. address.R_PARISC_DIR14R/// Right 14 bits of eff. address.R_PARISC_PCREL32/// 32-bit rel. address.R_PARISC_PCREL21L/// Left 21 bits of rel. address.R_PARISC_PCREL17R/// Right 17 bits of rel. address.R_PARISC_PCREL17F/// 17 bits of rel. address.R_PARISC_PCREL14R/// Right 14 bits of rel. address.R_PARISC_DPREL21LR_PARISC_DPREL14RR_PARISC_GPREL21L/// GP-relative, left 21 bits.R_PARISC_GPREL14R/// GP-relative, right 14 bits.R_PARISC_LTOFF21L/// LT-relative, left 21 bits.R_PARISC_LTOFF14R/// LT-relative, right 14 bits.R_PARISC_SECREL32/// 32 bits section rel. address.R_PARISC_SEGBASE/// No relocation, set segment base.R_PARISC_SEGREL32/// 32 bits segment rel. address.R_PARISC_PLTOFF21L/// PLT rel. address, left 21 bits.R_PARISC_PLTOFF14R/// PLT rel. address, right 14 bits.R_PARISC_LTOFF_FPTR32/// 32 bits LT-rel. function pointer.R_PARISC_LTOFF_FPTR21L/// LT-rel. fct ptr, left 21 bits.R_PARISC_LTOFF_FPTR14R/// LT-rel. fct ptr, right 14 bits.R_PARISC_FPTR64/// 64 bits function address.R_PARISC_PLABEL32/// 32 bits function address.R_PARISC_PLABEL21L/// Left 21 bits of fdesc address.R_PARISC_PLABEL14R/// Right 14 bits of fdesc address.R_PARISC_PCREL64/// 64 bits PC-rel. address.R_PARISC_PCREL22F/// 22 bits PC-rel. address.R_PARISC_PCREL14WR/// PC-rel. address, right 14 bits.R_PARISC_PCREL14DR/// PC rel. address, right 14 bits.R_PARISC_PCREL16F/// 16 bits PC-rel. address.R_PARISC_PCREL16WFR_PARISC_PCREL16DFR_PARISC_DIR64/// 64 bits of eff. address.R_PARISC_DIR14WR/// 14 bits of eff. address.R_PARISC_DIR14DRR_PARISC_DIR16F/// 16 bits of eff. address.R_PARISC_DIR16WFR_PARISC_DIR16DFR_PARISC_GPREL64/// 64 bits of GP-rel. address.R_PARISC_GPREL14WR/// GP-rel. address, right 14 bits.R_PARISC_GPREL14DRR_PARISC_GPREL16F/// 16 bits GP-rel. address.R_PARISC_GPREL16WFR_PARISC_GPREL16DFR_PARISC_LTOFF64/// 64 bits LT-rel. address.R_PARISC_LTOFF14WR/// LT-rel. address, right 14 bits.R_PARISC_LTOFF14DRR_PARISC_LTOFF16F/// 16 bits LT-rel. address.R_PARISC_LTOFF16WFR_PARISC_LTOFF16DFR_PARISC_SECREL64/// 64 bits section rel. address.R_PARISC_SEGREL64/// 64 bits segment rel. address.R_PARISC_PLTOFF14WR/// PLT-rel. address, right 14 bits.R_PARISC_PLTOFF14DRR_PARISC_PLTOFF16FR_PARISC_PLTOFF16WF/// 16 bits PLT-rel. address.R_PARISC_PLTOFF16DFR_PARISC_LTOFF_FPTR64/// 64 bits LT-rel. function ptr.R_PARISC_LTOFF_FPTR14WR/// LT-rel. fct. ptr., right 14 bits.R_PARISC_LTOFF_FPTR14DRR_PARISC_LTOFF_FPTR16F/// 16 bits LT-rel. function ptr.R_PARISC_LTOFF_FPTR16WFR_PARISC_LTOFF_FPTR16DFR_PARISC_LORESERVER_PARISC_COPY/// Copy relocation.R_PARISC_IPLT/// Dynamic reloc, imported PLTR_PARISC_EPLT/// Dynamic reloc, exported PLTR_PARISC_TPREL32/// 32 bits TP-rel. address.R_PARISC_TPREL21L/// TP-rel. address, left 21 bits.R_PARISC_TPREL14R/// TP-rel. address, right 14 bits.R_PARISC_LTOFF_TP21L/// LT-TP-rel. address, left 21 bits.R_PARISC_LTOFF_TP14R/// LT-TP-rel. address, right 14 bits.R_PARISC_LTOFF_TP14F/// 14 bits LT-TP-rel. address.R_PARISC_TPREL64/// 64 bits TP-rel. address.R_PARISC_TPREL14WRR_PARISC_TPREL14DRR_PARISC_TPREL16F/// 16 bits TP-rel. address.R_PARISC_TPREL16WFR_PARISC_TPREL16DFR_PARISC_LTOFF_TP64/// 64 bits LT-TP-rel. address.R_PARISC_LTOFF_TP14WRR_PARISC_LTOFF_TP14DRR_PARISC_LTOFF_TP16F/// 16 bits LT-TP-rel. address.R_PARISC_LTOFF_TP16WFR_PARISC_LTOFF_TP16DFR_PARISC_GNU_VTENTRYR_PARISC_GNU_VTINHERITR_PARISC_TLS_GD21L/// GD 21-bit left.R_PARISC_TLS_GD14R/// GD 14-bit right.R_PARISC_TLS_GDCALL/// GD call to __t_g_a.R_PARISC_TLS_LDM21L/// LD module 21-bit left.R_PARISC_TLS_LDM14R/// LD module 14-bit right.R_PARISC_TLS_LDMCALL/// LD module call to __t_g_a.R_PARISC_TLS_LDO21L/// LD offset 21-bit left.R_PARISC_TLS_LDO14R/// LD offset 14-bit right.R_PARISC_TLS_DTPMOD32/// DTP module 32-bit.R_PARISC_TLS_DTPMOD64/// DTP module 64-bit.R_PARISC_TLS_DTPOFF32/// DTP offset 32-bit.R_PARISC_TLS_DTPOFF64R_PARISC_TLS_LE21LR_PARISC_TLS_LE14RR_PARISC_TLS_IE21LR_PARISC_TLS_IE14RR_PARISC_TLS_TPREL32R_PARISC_TLS_TPREL64R_PARISC_HIRESERVEPT_HP_TLSPT_HP_CORE_NONEPT_HP_CORE_VERSIONPT_HP_CORE_KERNELPT_HP_CORE_COMMPT_HP_CORE_PROCPT_HP_CORE_LOADABLEPT_HP_CORE_STACKPT_HP_CORE_SHMPT_HP_CORE_MMFPT_HP_PARALLELPT_HP_FASTBINDPT_HP_OPT_ANNOTPT_HP_HSL_ANNOTPT_HP_STACKPT_PARISC_ARCHEXTPT_PARISC_UNWINDPF_PARISC_SBPPF_HP_PAGE_SIZEPF_HP_FAR_SHAREDPF_HP_NEAR_SHAREDPF_HP_CODEPF_HP_MODIFYPF_HP_LAZYSWAPPF_HP_SBPEF_ALPHA_32BIT/// All addresses must be < 2GB.EF_ALPHA_CANRELAX/// Relocations for relaxing exist.SHT_ALPHA_DEBUG// These two are primerily concerned with ECOFF debugging info.SHT_ALPHA_REGINFOSHF_ALPHA_GPRELSTO_ALPHA_NOPV// Alpha values for `Sym64::st_other`./// No PV required.STO_ALPHA_STD_GPLOAD/// PV only used for initial ldgp.R_ALPHA_NONER_ALPHA_REFLONGR_ALPHA_REFQUADR_ALPHA_GPREL32R_ALPHA_LITERAL/// GP relative 16 bit w/optimizationR_ALPHA_LITUSE/// Optimization hint for LITERALR_ALPHA_GPDISP/// Add displacement to GPR_ALPHA_BRADDR/// PC+4 relative 23 bit shiftedR_ALPHA_HINT/// PC+4 relative 16 bit shiftedR_ALPHA_SREL16R_ALPHA_SREL32R_ALPHA_SREL64R_ALPHA_GPRELHIGH/// GP relative 32 bit, high 16 bitsR_ALPHA_GPRELLOW/// GP relative 32 bit, low 16 bitsR_ALPHA_GPREL16R_ALPHA_COPYR_ALPHA_GLOB_DATR_ALPHA_JMP_SLOTR_ALPHA_RELATIVER_ALPHA_TLS_GD_HIR_ALPHA_TLSGDR_ALPHA_TLS_LDMR_ALPHA_DTPMOD64R_ALPHA_GOTDTPRELR_ALPHA_DTPREL64R_ALPHA_DTPRELHIR_ALPHA_DTPRELLOR_ALPHA_DTPREL16R_ALPHA_GOTTPRELR_ALPHA_TPREL64R_ALPHA_TPRELHIR_ALPHA_TPRELLOR_ALPHA_TPREL16LITUSE_ALPHA_ADDR// Magic values of the `R_ALPHA_LITUSE` relocation addend.LITUSE_ALPHA_BASELITUSE_ALPHA_BYTOFFLITUSE_ALPHA_JSRLITUSE_ALPHA_TLS_GDLITUSE_ALPHA_TLS_LDMDT_ALPHA_PLTRO// Alpha values for `Dyn64::d_tag`.EF_PPC_EMB// PowerPC values for `FileHeader*::e_flags`./// PowerPC embedded flagEF_PPC_RELOCATABLE// Cygnus local bits below ./// PowerPC -mrelocatable flagEF_PPC_RELOCATABLE_LIB/// PowerPC -mrelocatable-lib flagR_PPC_NONE// PowerPC values for `Rel*::r_type` defined by the ABIs.R_PPC_ADDR32/// 32bit absolute addressR_PPC_ADDR24/// 26bit address, 2 bits ignored.R_PPC_ADDR16/// 16bit absolute addressR_PPC_ADDR16_LO/// lower 16bit of absolute addressR_PPC_ADDR16_HI/// high 16bit of absolute addressR_PPC_ADDR16_HA/// adjusted high 16bitR_PPC_ADDR14/// 16bit address, 2 bits ignoredR_PPC_ADDR14_BRTAKENR_PPC_ADDR14_BRNTAKENR_PPC_REL24/// PC relative 26 bitR_PPC_REL14R_PPC_REL14_BRTAKENR_PPC_REL14_BRNTAKENR_PPC_GOT16R_PPC_GOT16_LOR_PPC_GOT16_HIR_PPC_GOT16_HAR_PPC_PLTREL24R_PPC_COPYR_PPC_GLOB_DATR_PPC_JMP_SLOTR_PPC_RELATIVER_PPC_LOCAL24PCR_PPC_UADDR32R_PPC_UADDR16R_PPC_REL32R_PPC_PLT32R_PPC_PLTREL32R_PPC_PLT16_LOR_PPC_PLT16_HIR_PPC_PLT16_HAR_PPC_SDAREL16R_PPC_SECTOFFR_PPC_SECTOFF_LOR_PPC_SECTOFF_HIR_PPC_SECTOFF_HAR_PPC_TLS// PowerPC values for `Rel*::r_type` defined for the TLS access ABI./// none    (sym+add)@tlsR_PPC_DTPMOD32/// word32  (sym+add)@dtpmodR_PPC_TPREL16/// half16* (sym+add)@tprelR_PPC_TPREL16_LO/// half16  (sym+add)@tprel@lR_PPC_TPREL16_HI/// half16  (sym+add)@tprel@hR_PPC_TPREL16_HA/// half16  (sym+add)@tprel@haR_PPC_TPREL32/// word32  (sym+add)@tprelR_PPC_DTPREL16/// half16*(sym+add)@dtprelR_PPC_DTPREL16_LO/// half16  (sym+add)@dtprel@lR_PPC_DTPREL16_HI/// half16  (sym+add)@dtprel@hR_PPC_DTPREL16_HA/// half16  (sym+add)@dtprel@haR_PPC_DTPREL32/// word32  (sym+add)@dtprelR_PPC_GOT_TLSGD16/// half16* (sym+add)@got@tlsgdR_PPC_GOT_TLSGD16_LO/// half16  (sym+add)@got@tlsgd@lR_PPC_GOT_TLSGD16_HI/// half16  (sym+add)@got@tlsgd@hR_PPC_GOT_TLSGD16_HA/// half16  (sym+add)@got@tlsgd@haR_PPC_GOT_TLSLD16/// half16* (sym+add)@got@tlsldR_PPC_GOT_TLSLD16_LO/// half16  (sym+add)@got@tlsld@lR_PPC_GOT_TLSLD16_HI/// half16  (sym+add)@got@tlsld@hR_PPC_GOT_TLSLD16_HA/// half16  (sym+add)@got@tlsld@haR_PPC_GOT_TPREL16/// half16* (sym+add)@got@tprelR_PPC_GOT_TPREL16_LO/// half16  (sym+add)@got@tprel@lR_PPC_GOT_TPREL16_HI/// half16  (sym+add)@got@tprel@hR_PPC_GOT_TPREL16_HA/// half16  (sym+add)@got@tprel@haR_PPC_GOT_DTPREL16/// half16* (sym+add)@got@dtprelR_PPC_GOT_DTPREL16_LO/// half16* (sym+add)@got@dtprel@lR_PPC_GOT_DTPREL16_HI/// half16* (sym+add)@got@dtprel@hR_PPC_GOT_DTPREL16_HA/// half16* (sym+add)@got@dtprel@haR_PPC_TLSGD/// none    (sym+add)@tlsgdR_PPC_TLSLD/// none    (sym+add)@tlsldR_PPC_EMB_NADDR32// PowerPC values for `Rel*::r_type` from the Embedded ELF ABI.R_PPC_EMB_NADDR16R_PPC_EMB_NADDR16_LOR_PPC_EMB_NADDR16_HIR_PPC_EMB_NADDR16_HAR_PPC_EMB_SDAI16R_PPC_EMB_SDA2I16R_PPC_EMB_SDA2RELR_PPC_EMB_SDA21/// 16 bit offset in SDAR_PPC_EMB_MRKREFR_PPC_EMB_RELSEC16R_PPC_EMB_RELST_LOR_PPC_EMB_RELST_HIR_PPC_EMB_RELST_HAR_PPC_EMB_BIT_FLDR_PPC_EMB_RELSDA/// 16 bit relative offset in SDAR_PPC_DIAB_SDA21_LO// Diab tool values for `Rel*::r_type`./// like EMB_SDA21, but lower 16 bitR_PPC_DIAB_SDA21_HI/// like EMB_SDA21, but high 16 bitR_PPC_DIAB_SDA21_HA/// like EMB_SDA21, adjusted high 16R_PPC_DIAB_RELSDA_LO/// like EMB_RELSDA, but lower 16 bitR_PPC_DIAB_RELSDA_HI/// like EMB_RELSDA, but high 16 bitR_PPC_DIAB_RELSDA_HA/// like EMB_RELSDA, adjusted high 16R_PPC_IRELATIVE/// GNU extension to support local ifunc.R_PPC_REL16// GNU relocs used in PIC code sequences./// half16   (sym+add-.)R_PPC_REL16_LO/// half16   (sym+add-.)@lR_PPC_REL16_HI/// half16   (sym+add-.)@hR_PPC_REL16_HA/// half16   (sym+add-.)@haR_PPC_TOC16/// This is a phony reloc to handle any old fashioned TOC16 references that may/// still be in object files.DT_PPC_GOT// PowerPC specific values for `Dyn*::d_tag`.DT_PPC_OPTPPC_OPT_TLS// PowerPC specific values for the `DT_PPC_OPT` entry.R_PPC64_NONE// PowerPC64 values for `Rel*::r_type` defined by the ABIs.R_PPC64_ADDR32R_PPC64_ADDR24/// 26bit address, word alignedR_PPC64_ADDR16R_PPC64_ADDR16_LO/// lower 16bits of addressR_PPC64_ADDR16_HI/// high 16bits of address.R_PPC64_ADDR16_HA/// adjusted high 16bits.R_PPC64_ADDR14/// 16bit address, word alignedR_PPC64_ADDR14_BRTAKENR_PPC64_ADDR14_BRNTAKENR_PPC64_REL24/// PC-rel. 26 bit, word alignedR_PPC64_REL14R_PPC64_REL14_BRTAKENR_PPC64_REL14_BRNTAKENR_PPC64_GOT16R_PPC64_GOT16_LOR_PPC64_GOT16_HIR_PPC64_GOT16_HAR_PPC64_COPYR_PPC64_GLOB_DATR_PPC64_JMP_SLOTR_PPC64_RELATIVER_PPC64_UADDR32R_PPC64_UADDR16R_PPC64_REL32R_PPC64_PLT32R_PPC64_PLTREL32R_PPC64_PLT16_LOR_PPC64_PLT16_HIR_PPC64_PLT16_HAR_PPC64_SECTOFFR_PPC64_SECTOFF_LOR_PPC64_SECTOFF_HIR_PPC64_SECTOFF_HAR_PPC64_ADDR30/// word30 (S + A - P) >> 2R_PPC64_ADDR64/// doubleword64 S + AR_PPC64_ADDR16_HIGHER/// half16 #higher(S + A)R_PPC64_ADDR16_HIGHERA/// half16 #highera(S + A)R_PPC64_ADDR16_HIGHEST/// half16 #highest(S + A)R_PPC64_ADDR16_HIGHESTA/// half16 #highesta(S + A)R_PPC64_UADDR64R_PPC64_REL64/// doubleword64 S + A - PR_PPC64_PLT64/// doubleword64 L + AR_PPC64_PLTREL64/// doubleword64 L + A - PR_PPC64_TOC16/// half16* S + A - .TOCR_PPC64_TOC16_LO/// half16 #lo(S + A - .TOC.)R_PPC64_TOC16_HI/// half16 #hi(S + A - .TOC.)R_PPC64_TOC16_HA/// half16 #ha(S + A - .TOC.)R_PPC64_TOC/// doubleword64 .TOCR_PPC64_PLTGOT16/// half16* M + AR_PPC64_PLTGOT16_LO/// half16 #lo(M + A)R_PPC64_PLTGOT16_HI/// half16 #hi(M + A)R_PPC64_PLTGOT16_HA/// half16 #ha(M + A)R_PPC64_ADDR16_DS/// half16ds* (S + A) >> 2R_PPC64_ADDR16_LO_DS/// half16ds  #lo(S + A) >> 2R_PPC64_GOT16_DS/// half16ds* (G + A) >> 2R_PPC64_GOT16_LO_DS/// half16ds  #lo(G + A) >> 2R_PPC64_PLT16_LO_DS/// half16ds  #lo(L + A) >> 2R_PPC64_SECTOFF_DS/// half16ds* (R + A) >> 2R_PPC64_SECTOFF_LO_DS/// half16ds  #lo(R + A) >> 2R_PPC64_TOC16_DS/// half16ds* (S + A - .TOC.) >> 2R_PPC64_TOC16_LO_DS/// half16ds  #lo(S + A - .TOC.) >> 2R_PPC64_PLTGOT16_DS/// half16ds* (M + A) >> 2R_PPC64_PLTGOT16_LO_DS/// half16ds  #lo(M + A) >> 2R_PPC64_TLS// PowerPC64 values for `Rel*::r_type` defined for the TLS access ABI.R_PPC64_DTPMOD64/// doubleword64 (sym+add)@dtpmodR_PPC64_TPREL16R_PPC64_TPREL16_LOR_PPC64_TPREL16_HIR_PPC64_TPREL16_HAR_PPC64_TPREL64/// doubleword64 (sym+add)@tprelR_PPC64_DTPREL16/// half16* (sym+add)@dtprelR_PPC64_DTPREL16_LOR_PPC64_DTPREL16_HIR_PPC64_DTPREL16_HAR_PPC64_DTPREL64/// doubleword64 (sym+add)@dtprelR_PPC64_GOT_TLSGD16R_PPC64_GOT_TLSGD16_LOR_PPC64_GOT_TLSGD16_HIR_PPC64_GOT_TLSGD16_HAR_PPC64_GOT_TLSLD16R_PPC64_GOT_TLSLD16_LOR_PPC64_GOT_TLSLD16_HIR_PPC64_GOT_TLSLD16_HAR_PPC64_GOT_TPREL16_DS/// half16ds* (sym+add)@got@tprelR_PPC64_GOT_TPREL16_LO_DS/// half16ds (sym+add)@got@tprel@lR_PPC64_GOT_TPREL16_HIR_PPC64_GOT_TPREL16_HAR_PPC64_GOT_DTPREL16_DS/// half16ds* (sym+add)@got@dtprelR_PPC64_GOT_DTPREL16_LO_DS/// half16ds (sym+add)@got@dtprel@lR_PPC64_GOT_DTPREL16_HI/// half16  (sym+add)@got@dtprel@hR_PPC64_GOT_DTPREL16_HA/// half16  (sym+add)@got@dtprel@haR_PPC64_TPREL16_DS/// half16ds* (sym+add)@tprelR_PPC64_TPREL16_LO_DS/// half16ds (sym+add)@tprel@lR_PPC64_TPREL16_HIGHER/// half16  (sym+add)@tprel@higherR_PPC64_TPREL16_HIGHERA/// half16  (sym+add)@tprel@higheraR_PPC64_TPREL16_HIGHEST/// half16  (sym+add)@tprel@highestR_PPC64_TPREL16_HIGHESTA/// half16  (sym+add)@tprel@highestaR_PPC64_DTPREL16_DS/// half16ds* (sym+add)@dtprelR_PPC64_DTPREL16_LO_DS/// half16ds (sym+add)@dtprel@lR_PPC64_DTPREL16_HIGHER/// half16  (sym+add)@dtprel@higherR_PPC64_DTPREL16_HIGHERA/// half16  (sym+add)@dtprel@higheraR_PPC64_DTPREL16_HIGHEST/// half16  (sym+add)@dtprel@highestR_PPC64_DTPREL16_HIGHESTA/// half16  (sym+add)@dtprel@highestaR_PPC64_TLSGDR_PPC64_TLSLDR_PPC64_TOCSAVE/// noneR_PPC64_ADDR16_HIGH// Added when HA and HI relocs were changed to report overflows.R_PPC64_ADDR16_HIGHAR_PPC64_TPREL16_HIGHR_PPC64_TPREL16_HIGHAR_PPC64_DTPREL16_HIGHR_PPC64_DTPREL16_HIGHAR_PPC64_JMP_IRELR_PPC64_IRELATIVER_PPC64_REL16R_PPC64_REL16_LOR_PPC64_REL16_HIR_PPC64_REL16_HAEF_PPC64_ABI// PowerPC64 values for `FileHeader64::e_flags./// PowerPC64 bits specifying ABI./// 1 for original function descriptor using ABI,/// 2 for revised ABI without function descriptors,/// 0 for unspecified or not using any features affected by the differences.DT_PPC64_GLINK// PowerPC64 values for `Dyn64::d_tag.DT_PPC64_OPDDT_PPC64_OPDSZDT_PPC64_OPTPPC64_OPT_TLS// PowerPC64 bits for `DT_PPC64_OPT` entry.PPC64_OPT_MULTI_TOCPPC64_OPT_LOCALENTRYSTO_PPC64_LOCAL_BIT// PowerPC64 values for `Sym64::st_other.STO_PPC64_LOCAL_MASKEF_ARM_RELEXEC// ARM values for `FileHeader*::e_flags`.EF_ARM_HASENTRYEF_ARM_INTERWORKEF_ARM_APCS_26EF_ARM_APCS_FLOATEF_ARM_PICEF_ARM_ALIGN8/// 8-bit structure alignment is in useEF_ARM_NEW_ABIEF_ARM_OLD_ABIEF_ARM_SOFT_FLOATEF_ARM_VFP_FLOATEF_ARM_MAVERICK_FLOATEF_ARM_ABI_FLOAT_SOFT/// NB conflicts with EF_ARM_SOFT_FLOATEF_ARM_ABI_FLOAT_HARD/// NB conflicts with EF_ARM_VFP_FLOATEF_ARM_SYMSARESORTED// Other constants defined in the ARM ELF spec. version B-01.// NB. These conflict with values defined above.EF_ARM_DYNSYMSUSESEGIDXEF_ARM_MAPSYMSFIRSTEF_ARM_BE8// Constants defined in AAELF.EF_ARM_LE8EF_ARM_EABIMASKEF_ARM_EABI_UNKNOWNEF_ARM_EABI_VER1EF_ARM_EABI_VER2EF_ARM_EABI_VER3EF_ARM_EABI_VER4EF_ARM_EABI_VER5STT_ARM_TFUNC// ARM Thumb values for `st_type` component of `Sym*::st_info`./// A Thumb function.STT_ARM_16BIT/// A Thumb label.SHF_ARM_ENTRYSECT// ARM values for `SectionHeader*::sh_flags`./// Section contains an entry pointSHF_ARM_COMDEF/// Section may be multiply defined in the input to a link step.PF_ARM_SB// ARM values for `ProgramHeader*::p_flags`./// Segment contains the location addressed by the static base.PF_ARM_PI/// Position-independent segment.PF_ARM_ABS/// Absolute segment.PT_ARM_EXIDX// ARM values for `ProgramHeader*::p_type`./// ARM unwind segment.SHT_ARM_EXIDX// ARM values for `SectionHeader*::sh_type`./// ARM unwind section.SHT_ARM_PREEMPTMAP/// Preemption details.SHT_ARM_ATTRIBUTES/// ARM attributes section.SHT_AARCH64_ATTRIBUTES// AArch64 values for `SectionHeader*::sh_type`./// AArch64 attributes section.R_AARCH64_NONE/// No relocation.R_AARCH64_P32_ABS32// ILP32 AArch64 relocs./// Direct 32 bit.R_AARCH64_P32_COPY/// Copy symbol at runtime.R_AARCH64_P32_GLOB_DAT/// Create GOT entry.R_AARCH64_P32_JUMP_SLOT/// Create PLT entry.R_AARCH64_P32_RELATIVE/// Adjust by program base.R_AARCH64_P32_TLS_DTPMOD/// Module number, 32 bit.R_AARCH64_P32_TLS_DTPREL/// Module-relative offset, 32 bit.R_AARCH64_P32_TLS_TPREL/// TP-relative offset, 32 bit.R_AARCH64_P32_TLSDESC/// TLS Descriptor.R_AARCH64_P32_IRELATIVE/// STT_GNU_IFUNC relocation.R_AARCH64_ABS64// LP64 AArch64 relocs./// Direct 64 bit.R_AARCH64_ABS32R_AARCH64_ABS16/// Direct 16-bit.R_AARCH64_PREL64/// PC-relative 64-bit.R_AARCH64_PREL32/// PC-relative 32-bit.R_AARCH64_PREL16/// PC-relative 16-bit.R_AARCH64_MOVW_UABS_G0/// Dir. MOVZ imm. from bits 15:0.R_AARCH64_MOVW_UABS_G0_NC/// Likewise for MOVK; no check.R_AARCH64_MOVW_UABS_G1/// Dir. MOVZ imm. from bits 31:16.R_AARCH64_MOVW_UABS_G1_NCR_AARCH64_MOVW_UABS_G2/// Dir. MOVZ imm. from bits 47:32.R_AARCH64_MOVW_UABS_G2_NCR_AARCH64_MOVW_UABS_G3/// Dir. MOV{K,Z} imm. from 63:48.R_AARCH64_MOVW_SABS_G0/// Dir. MOV{N,Z} imm. from 15:0.R_AARCH64_MOVW_SABS_G1/// Dir. MOV{N,Z} imm. from 31:16.R_AARCH64_MOVW_SABS_G2/// Dir. MOV{N,Z} imm. from 47:32.R_AARCH64_LD_PREL_LO19/// PC-rel. LD imm. from bits 20:2.R_AARCH64_ADR_PREL_LO21/// PC-rel. ADR imm. from bits 20:0.R_AARCH64_ADR_PREL_PG_HI21/// Page-rel. ADRP imm. from 32:12.R_AARCH64_ADR_PREL_PG_HI21_NC/// Likewise; no overflow check.R_AARCH64_ADD_ABS_LO12_NC/// Dir. ADD imm. from bits 11:0.R_AARCH64_LDST8_ABS_LO12_NC/// Likewise for LD/ST; no check.R_AARCH64_TSTBR14/// PC-rel. TBZ/TBNZ imm. from 15:2.R_AARCH64_CONDBR19/// PC-rel. cond. br. imm. from 20:2.R_AARCH64_JUMP26/// PC-rel. B imm. from bits 27:2.R_AARCH64_CALL26/// Likewise for CALL.R_AARCH64_LDST16_ABS_LO12_NC/// Dir. ADD imm. from bits 11:1.R_AARCH64_LDST32_ABS_LO12_NC/// Likewise for bits 11:2.R_AARCH64_LDST64_ABS_LO12_NC/// Likewise for bits 11:3.R_AARCH64_MOVW_PREL_G0/// PC-rel. MOV{N,Z} imm. from 15:0.R_AARCH64_MOVW_PREL_G0_NCR_AARCH64_MOVW_PREL_G1/// PC-rel. MOV{N,Z} imm. from 31:16.R_AARCH64_MOVW_PREL_G1_NCR_AARCH64_MOVW_PREL_G2/// PC-rel. MOV{N,Z} imm. from 47:32.R_AARCH64_MOVW_PREL_G2_NCR_AARCH64_MOVW_PREL_G3/// PC-rel. MOV{N,Z} imm. from 63:48.R_AARCH64_LDST128_ABS_LO12_NC/// Dir. ADD imm. from bits 11:4.R_AARCH64_MOVW_GOTOFF_G0/// GOT-rel. off. MOV{N,Z} imm. 15:0.R_AARCH64_MOVW_GOTOFF_G0_NCR_AARCH64_MOVW_GOTOFF_G1/// GOT-rel. o. MOV{N,Z} imm. 31:16.R_AARCH64_MOVW_GOTOFF_G1_NCR_AARCH64_MOVW_GOTOFF_G2/// GOT-rel. o. MOV{N,Z} imm. 47:32.R_AARCH64_MOVW_GOTOFF_G2_NCR_AARCH64_MOVW_GOTOFF_G3/// GOT-rel. o. MOV{N,Z} imm. 63:48.R_AARCH64_GOTREL64/// GOT-relative 64-bit.R_AARCH64_GOTREL32/// GOT-relative 32-bit.R_AARCH64_GOT_LD_PREL19/// PC-rel. GOT off. load imm. 20:2.R_AARCH64_LD64_GOTOFF_LO15/// GOT-rel. off. LD/ST imm. 14:3.R_AARCH64_ADR_GOT_PAGE/// P-page-rel. GOT off. ADRP 32:12.R_AARCH64_LD64_GOT_LO12_NC/// Dir. GOT off. LD/ST imm. 11:3.R_AARCH64_LD64_GOTPAGE_LO15/// GOT-page-rel. GOT off. LD/ST 14:3R_AARCH64_TLSGD_ADR_PREL21/// PC-relative ADR imm. 20:0.R_AARCH64_TLSGD_ADR_PAGE21/// page-rel. ADRP imm. 32:12.R_AARCH64_TLSGD_ADD_LO12_NC/// direct ADD imm. from 11:0.R_AARCH64_TLSGD_MOVW_G1/// GOT-rel. MOV{N,Z} 31:16.R_AARCH64_TLSGD_MOVW_G0_NC/// GOT-rel. MOVK imm. 15:0.R_AARCH64_TLSLD_ADR_PREL21/// Like 512; local dynamic model.R_AARCH64_TLSLD_ADR_PAGE21/// Like 513; local dynamic model.R_AARCH64_TLSLD_ADD_LO12_NC/// Like 514; local dynamic model.R_AARCH64_TLSLD_MOVW_G1/// Like 515; local dynamic model.R_AARCH64_TLSLD_MOVW_G0_NC/// Like 516; local dynamic model.R_AARCH64_TLSLD_LD_PREL19/// TLS PC-rel. load imm. 20:2.R_AARCH64_TLSLD_MOVW_DTPREL_G2/// TLS DTP-rel. MOV{N,Z} 47:32.R_AARCH64_TLSLD_MOVW_DTPREL_G1/// TLS DTP-rel. MOV{N,Z} 31:16.R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC/// Likewise; MOVK; no check.R_AARCH64_TLSLD_MOVW_DTPREL_G0/// TLS DTP-rel. MOV{N,Z} 15:0.R_AARCH64_TLSLD_MOVW_DTPREL_G0_NCR_AARCH64_TLSLD_ADD_DTPREL_HI12/// DTP-rel. ADD imm. from 23:12.R_AARCH64_TLSLD_ADD_DTPREL_LO12/// DTP-rel. ADD imm. from 11:0.R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC/// Likewise; no ovfl. check.R_AARCH64_TLSLD_LDST8_DTPREL_LO12/// DTP-rel. LD/ST imm. 11:0.R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC/// Likewise; no check.R_AARCH64_TLSLD_LDST16_DTPREL_LO12/// DTP-rel. LD/ST imm. 11:1.R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NCR_AARCH64_TLSLD_LDST32_DTPREL_LO12/// DTP-rel. LD/ST imm. 11:2.R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NCR_AARCH64_TLSLD_LDST64_DTPREL_LO12/// DTP-rel. LD/ST imm. 11:3.R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NCR_AARCH64_TLSIE_MOVW_GOTTPREL_G1R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC/// GOT-rel. MOVK 15:0.R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21/// Page-rel. ADRP 32:12.R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC/// Direct LD off. 11:3.R_AARCH64_TLSIE_LD_GOTTPREL_PREL19/// PC-rel. load imm. 20:2.R_AARCH64_TLSLE_MOVW_TPREL_G2/// TLS TP-rel. MOV{N,Z} 47:32.R_AARCH64_TLSLE_MOVW_TPREL_G1/// TLS TP-rel. MOV{N,Z} 31:16.R_AARCH64_TLSLE_MOVW_TPREL_G1_NCR_AARCH64_TLSLE_MOVW_TPREL_G0/// TLS TP-rel. MOV{N,Z} 15:0.R_AARCH64_TLSLE_MOVW_TPREL_G0_NCR_AARCH64_TLSLE_ADD_TPREL_HI12/// TP-rel. ADD imm. 23:12.R_AARCH64_TLSLE_ADD_TPREL_LO12/// TP-rel. ADD imm. 11:0.R_AARCH64_TLSLE_ADD_TPREL_LO12_NCR_AARCH64_TLSLE_LDST8_TPREL_LO12/// TP-rel. LD/ST off. 11:0.R_AARCH64_TLSLE_LDST8_TPREL_LO12_NCR_AARCH64_TLSLE_LDST16_TPREL_LO12/// TP-rel. LD/ST off. 11:1.R_AARCH64_TLSLE_LDST16_TPREL_LO12_NCR_AARCH64_TLSLE_LDST32_TPREL_LO12/// TP-rel. LD/ST off. 11:2.R_AARCH64_TLSLE_LDST32_TPREL_LO12_NCR_AARCH64_TLSLE_LDST64_TPREL_LO12/// TP-rel. LD/ST off. 11:3.R_AARCH64_TLSLE_LDST64_TPREL_LO12_NCR_AARCH64_TLSDESC_LD_PREL19/// PC-rel. load immediate 20:2.R_AARCH64_TLSDESC_ADR_PREL21/// PC-rel. ADR immediate 20:0.R_AARCH64_TLSDESC_ADR_PAGE21/// Page-rel. ADRP imm. 32:12.R_AARCH64_TLSDESC_LD64_LO12/// Direct LD off. from 11:3.R_AARCH64_TLSDESC_ADD_LO12/// Direct ADD imm. from 11:0.R_AARCH64_TLSDESC_OFF_G1/// GOT-rel. MOV{N,Z} imm. 31:16.R_AARCH64_TLSDESC_OFF_G0_NC/// GOT-rel. MOVK imm. 15:0; no ck.R_AARCH64_TLSDESC_LDR/// Relax LDR.R_AARCH64_TLSDESC_ADD/// Relax ADD.R_AARCH64_TLSDESC_CALL/// Relax BLR.R_AARCH64_TLSLE_LDST128_TPREL_LO12/// TP-rel. LD/ST off. 11:4.R_AARCH64_TLSLE_LDST128_TPREL_LO12_NCR_AARCH64_TLSLD_LDST128_DTPREL_LO12/// DTP-rel. LD/ST imm. 11:4.R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NCR_AARCH64_COPYR_AARCH64_GLOB_DATR_AARCH64_JUMP_SLOTR_AARCH64_RELATIVER_AARCH64_TLS_DTPMOD/// Module number, 64 bit.R_AARCH64_TLS_DTPREL/// Module-relative offset, 64 bit.R_AARCH64_TLS_TPREL/// TP-relative offset, 64 bit.R_AARCH64_TLSDESCR_AARCH64_IRELATIVEEF_AVR_ARCH/// Bitmask for `EF_AVR_ARCH_*`.EF_AVR_LINKRELAX_PREPARED/// If set, it is assumed that the elf file uses local symbols as reference/// for the relocations so that linker relaxation is possible.EF_AVR_ARCH_AVR1EF_AVR_ARCH_AVR2EF_AVR_ARCH_AVR25EF_AVR_ARCH_AVR3EF_AVR_ARCH_AVR31EF_AVR_ARCH_AVR35EF_AVR_ARCH_AVR4EF_AVR_ARCH_AVR5EF_AVR_ARCH_AVR51EF_AVR_ARCH_AVR6EF_AVR_ARCH_AVRTINYEF_AVR_ARCH_XMEGA1EF_AVR_ARCH_XMEGA2EF_AVR_ARCH_XMEGA3EF_AVR_ARCH_XMEGA4EF_AVR_ARCH_XMEGA5EF_AVR_ARCH_XMEGA6EF_AVR_ARCH_XMEGA7R_AVR_NONER_AVR_32R_AVR_7_PCRELR_AVR_13_PCRELR_AVR_16R_AVR_16_PMR_AVR_LO8_LDIR_AVR_HI8_LDIR_AVR_HH8_LDIR_AVR_LO8_LDI_NEGR_AVR_HI8_LDI_NEGR_AVR_HH8_LDI_NEGR_AVR_LO8_LDI_PMR_AVR_HI8_LDI_PMR_AVR_HH8_LDI_PMR_AVR_LO8_LDI_PM_NEGR_AVR_HI8_LDI_PM_NEGR_AVR_HH8_LDI_PM_NEGR_AVR_CALLR_AVR_LDIR_AVR_6R_AVR_6_ADIWR_AVR_MS8_LDIR_AVR_MS8_LDI_NEGR_AVR_LO8_LDI_GSR_AVR_HI8_LDI_GSR_AVR_8R_AVR_8_LO8R_AVR_8_HI8R_AVR_8_HLO8R_AVR_DIFF8R_AVR_DIFF16R_AVR_DIFF32R_AVR_LDS_STS_16R_AVR_PORT6R_AVR_PORT5R_AVR_32_PCRELR_MSP430_32R_MSP430_16_BYTER_HEX_32R_ARM_NONER_ARM_PC24/// Deprecated PC relative 26 bit branch.R_ARM_ABS32R_ARM_REL32R_ARM_PC13R_ARM_ABS16R_ARM_ABS12/// Direct 12 bitR_ARM_THM_ABS5/// Direct & 0x7C (`LDR`, `STR`).R_ARM_ABS8R_ARM_SBREL32R_ARM_THM_PC22/// PC relative 24 bit (Thumb32 `BL`).R_ARM_THM_PC8/// PC relative & 0x3FC (Thumb16 `LDR`, `ADD`, `ADR`).R_ARM_AMP_VCALL9R_ARM_SWI24/// Obsolete static relocation.R_ARM_TLS_DESC/// Dynamic relocation.R_ARM_THM_SWI8R_ARM_XPC25R_ARM_THM_XPC22R_ARM_TLS_DTPMOD32R_ARM_TLS_DTPOFF32R_ARM_TLS_TPOFF32R_ARM_COPYR_ARM_GLOB_DATR_ARM_JUMP_SLOTR_ARM_RELATIVER_ARM_GOTOFFR_ARM_GOTPCR_ARM_GOT32R_ARM_PLT32/// Deprecated, 32 bit PLT address.R_ARM_CALL/// PC relative 24 bit (`BL`, `BLX`).R_ARM_JUMP24/// PC relative 24 bit (`B`, `BL<cond>`).R_ARM_THM_JUMP24/// PC relative 24 bit (Thumb32 `B.W`).R_ARM_BASE_ABSR_ARM_ALU_PCREL_7_0/// Obsolete.R_ARM_ALU_PCREL_15_8R_ARM_ALU_PCREL_23_15R_ARM_LDR_SBREL_11_0/// Deprecated, prog. base relative.R_ARM_ALU_SBREL_19_12R_ARM_ALU_SBREL_27_20R_ARM_TARGET1R_ARM_SBREL31/// Program base relative.R_ARM_V4BXR_ARM_TARGET2R_ARM_PREL31/// 32 bit PC relative.R_ARM_MOVW_ABS_NC/// Direct 16-bit (`MOVW`).R_ARM_MOVT_ABS/// Direct high 16-bit (`MOVT`).R_ARM_MOVW_PREL_NC/// PC relative 16-bit (`MOVW`).R_ARM_MOVT_PREL/// PC relative (MOVT).R_ARM_THM_MOVW_ABS_NC/// Direct 16 bit (Thumb32 `MOVW`).R_ARM_THM_MOVT_ABS/// Direct high 16 bit (Thumb32 `MOVT`).R_ARM_THM_MOVW_PREL_NC/// PC relative 16 bit (Thumb32 `MOVW`).R_ARM_THM_MOVT_PREL/// PC relative high 16 bit (Thumb32 `MOVT`).R_ARM_THM_JUMP19/// PC relative 20 bit (Thumb32 `B<cond>.W`).R_ARM_THM_JUMP6/// PC relative X & 0x7E (Thumb16 `CBZ`, `CBNZ`).R_ARM_THM_ALU_PREL_11_0/// PC relative 12 bit (Thumb32 `ADR.W`).R_ARM_THM_PC12/// PC relative 12 bit (Thumb32 `LDR{D,SB,H,SH}`).R_ARM_ABS32_NOI/// Direct 32-bit.R_ARM_REL32_NOI/// PC relative 32-bit.R_ARM_ALU_PC_G0_NC/// PC relative (`ADD`, `SUB`).R_ARM_ALU_PC_G0R_ARM_ALU_PC_G1_NCR_ARM_ALU_PC_G1R_ARM_ALU_PC_G2R_ARM_LDR_PC_G1/// PC relative (`LDR`,`STR`,`LDRB`,`STRB`).R_ARM_LDR_PC_G2R_ARM_LDRS_PC_G0/// PC relative (`STR{D,H}`, `LDR{D,SB,H,SH}`).R_ARM_LDRS_PC_G1R_ARM_LDRS_PC_G2R_ARM_LDC_PC_G0/// PC relative (`LDC`, `STC`).R_ARM_LDC_PC_G1R_ARM_LDC_PC_G2R_ARM_ALU_SB_G0_NC/// Program base relative (`ADD`,`SUB`).R_ARM_ALU_SB_G0R_ARM_ALU_SB_G1_NCR_ARM_ALU_SB_G1R_ARM_ALU_SB_G2R_ARM_LDR_SB_G0/// Program base relative (`LDR`, `STR`, `LDRB`, `STRB`).R_ARM_LDR_SB_G1R_ARM_LDR_SB_G2R_ARM_LDRS_SB_G0R_ARM_LDRS_SB_G1R_ARM_LDRS_SB_G2R_ARM_LDC_SB_G0/// Program base relative (`LDC`,`STC`).R_ARM_LDC_SB_G1R_ARM_LDC_SB_G2R_ARM_MOVW_BREL_NC/// Program base relative 16 bit (`MOVW`).R_ARM_MOVT_BREL/// Program base relative high 16 bit (`MOVT`).R_ARM_MOVW_BRELR_ARM_THM_MOVW_BREL_NC/// Program base relative 16 bit (Thumb32 `MOVW`).R_ARM_THM_MOVT_BREL/// Program base relative high 16 bit (Thumb32 `MOVT`).R_ARM_THM_MOVW_BRELR_ARM_TLS_GOTDESCR_ARM_TLS_CALLR_ARM_TLS_DESCSEQ/// TLS relaxation.R_ARM_THM_TLS_CALLR_ARM_PLT32_ABSR_ARM_GOT_ABS/// GOT entry.R_ARM_GOT_PREL/// PC relative GOT entry.R_ARM_GOT_BREL12/// GOT entry relative to GOT origin (`LDR`).R_ARM_GOTOFF12/// 12 bit, GOT entry relative to GOT origin (`LDR`, `STR`).R_ARM_GOTRELAXR_ARM_GNU_VTENTRYR_ARM_GNU_VTINHERITR_ARM_THM_PC11/// PC relative & 0xFFE (Thumb16 `B`).R_ARM_THM_PC9/// PC relative & 0x1FE (Thumb16 `B`/`B<cond>`).R_ARM_TLS_GD32/// PC-rel 32 bit for global dynamic thread local dataR_ARM_TLS_LDM32/// PC-rel 32 bit for local dynamic thread local dataR_ARM_TLS_LDO32/// 32 bit offset relative to TLS blockR_ARM_TLS_IE32/// PC-rel 32 bit for GOT entry of static TLS block offsetR_ARM_TLS_LE32R_ARM_TLS_LDO12/// 12 bit relative to TLS block (`LDR`, `STR`).R_ARM_TLS_LE12/// 12 bit relative to static TLS block (`LDR`, `STR`).R_ARM_TLS_IE12GP/// 12 bit GOT entry relative to GOT origin (`LDR`).R_ARM_ME_TOOR_ARM_THM_TLS_DESCSEQR_ARM_THM_TLS_DESCSEQ16R_ARM_THM_TLS_DESCSEQ32R_ARM_THM_GOT_BREL12/// GOT entry relative to GOT origin, 12 bit (Thumb32 `LDR`).R_ARM_IRELATIVER_ARM_RXPC25R_ARM_RSBREL32R_ARM_THM_RPC22R_ARM_RREL32R_ARM_RABS22R_ARM_RPC24R_ARM_RBASER_CKCORE_NONE// C-SKY values for `Rel*::r_type`./// no relocR_CKCORE_ADDR32/// direct 32 bit (S + A)R_CKCORE_PCRELIMM8BY4/// disp ((S + A - P) >> 2) & 0xffR_CKCORE_PCRELIMM11BY2/// disp ((S + A - P) >> 1) & 0x7ffR_CKCORE_PCREL32/// 32-bit rel (S + A - P)R_CKCORE_PCRELJSR_IMM11BY2/// disp ((S + A - P) >>1) & 0x7ffR_CKCORE_RELATIVE/// 32 bit adjust program base(B + A)R_CKCORE_COPY/// 32 bit adjust by program baseR_CKCORE_GLOB_DAT/// off between got and sym (S)R_CKCORE_JUMP_SLOT/// PLT entry (S)R_CKCORE_GOTOFF/// offset to GOT (S + A - GOT)R_CKCORE_GOTPC/// PC offset to GOT (GOT + A - P)R_CKCORE_GOT32/// 32 bit GOT entry (G)R_CKCORE_PLT32/// 32 bit PLT entry (G)R_CKCORE_ADDRGOT/// GOT entry in GLOB_DAT (GOT + G)R_CKCORE_ADDRPLT/// PLT entry in GLOB_DAT (GOT + G)R_CKCORE_PCREL_IMM26BY2/// ((S + A - P) >> 1) & 0x3ff_ffffR_CKCORE_PCREL_IMM16BY2/// disp ((S + A - P) >> 1) & 0xffffR_CKCORE_PCREL_IMM16BY4/// disp ((S + A - P) >> 2) & 0xffffR_CKCORE_PCREL_IMM10BY2/// disp ((S + A - P) >> 1) & 0x3ffR_CKCORE_PCREL_IMM10BY4/// disp ((S + A - P) >> 2) & 0x3ffR_CKCORE_ADDR_HI16/// high & low 16 bit ADDR, ((S + A) >> 16) & 0xffffR_CKCORE_ADDR_LO16/// (S + A) & 0xffffR_CKCORE_GOTPC_HI16/// high & low 16 bit GOTPC, ((GOT + A - P) >> 16) & 0xffffR_CKCORE_GOTPC_LO16/// (GOT + A - P) & 0xffffR_CKCORE_GOTOFF_HI16/// high & low 16 bit GOTOFF, ((S + A - GOT) >> 16) & 0xffffR_CKCORE_GOTOFF_LO16/// (S + A - GOT) & 0xffffR_CKCORE_GOT12/// 12 bit disp GOT entry (G)R_CKCORE_GOT_HI16/// high & low 16 bit GOT, (G >> 16) & 0xffffR_CKCORE_GOT_LO16/// (G & 0xffff)R_CKCORE_PLT12/// 12 bit disp PLT entry (G)R_CKCORE_PLT_HI16/// high & low 16 bit PLT, (G >> 16) & 0xffffR_CKCORE_PLT_LO16/// G & 0xffffR_CKCORE_ADDRGOT_HI16/// high & low 16 bit ADDRGOT, (GOT + G * 4) & 0xffffR_CKCORE_ADDRGOT_LO16/// (GOT + G * 4) & 0xffffR_CKCORE_ADDRPLT_HI16/// high & low 16 bit ADDRPLT, ((GOT + G * 4) >> 16) & 0xFFFFR_CKCORE_ADDRPLT_LO16/// (GOT+G*4) & 0xffffR_CKCORE_PCREL_JSR_IMM26BY2/// disp ((S+A-P) >>1) & x3ff_ffffR_CKCORE_TOFFSET_LO16/// (S+A-BTEXT) & 0xffffR_CKCORE_DOFFSET_LO16R_CKCORE_PCREL_IMM18BY2/// disp ((S+A-P) >>1) & 0x3ffffR_CKCORE_DOFFSET_IMM18/// disp (S+A-BDATA) & 0x3ffffR_CKCORE_DOFFSET_IMM18BY2/// disp ((S+A-BDATA)>>1) & 0x3ffffR_CKCORE_DOFFSET_IMM18BY4/// disp ((S+A-BDATA)>>2) & 0x3ffffR_CKCORE_GOT_IMM18BY4/// disp (G >> 2)R_CKCORE_PLT_IMM18BY4R_CKCORE_PCREL_IMM7BY4/// disp ((S+A-P) >>2) & 0x7fR_CKCORE_TLS_LE32/// 32 bit offset to TLS blockR_CKCORE_TLS_IE32R_CKCORE_TLS_GD32R_CKCORE_TLS_LDM32R_CKCORE_TLS_LDO32R_CKCORE_TLS_DTPMOD32R_CKCORE_TLS_DTPOFF32R_CKCORE_TLS_TPOFF32EF_CSKY_ABIMASK// C-SKY values for `FileHeader*::e_flags`.EF_CSKY_OTHEREF_CSKY_PROCESSOREF_CSKY_ABIV1EF_CSKY_ABIV2SHT_CSKY_ATTRIBUTES// C-SKY values for `SectionHeader*::sh_type`./// C-SKY attributes section.EF_IA_64_MASKOS// IA-64 values for `FileHeader64::e_flags`./// os-specific flagsEF_IA_64_ABI64/// 64-bit ABIEF_IA_64_ARCH/// arch. version maskPT_IA_64_ARCHEXT// IA-64 values for `ProgramHeader64::p_type`./// arch extension bitsPT_IA_64_UNWIND/// ia64 unwind bitsPT_IA_64_HP_OPT_ANOTPT_IA_64_HP_HSL_ANOTPT_IA_64_HP_STACKPF_IA_64_NORECOV// IA-64 values for `ProgramHeader64::p_flags`./// spec insns w/o recoverySHT_IA_64_EXT// IA-64 values for `SectionHeader64::sh_type`./// extension bitsSHT_IA_64_UNWIND/// unwind bitsSHF_IA_64_SHORT// IA-64 values for `SectionHeader64::sh_flags`./// section near gpSHF_IA_64_NORECOVDT_IA_64_PLT_RESERVE// IA-64 values for `Dyn64::d_tag`.R_IA64_NONE// IA-64 values for `Rel*::r_type`.R_IA64_IMM14/// symbol + addend, add imm14R_IA64_IMM22/// symbol + addend, add imm22R_IA64_IMM64/// symbol + addend, mov imm64R_IA64_DIR32MSB/// symbol + addend, data4 MSBR_IA64_DIR32LSB/// symbol + addend, data4 LSBR_IA64_DIR64MSB/// symbol + addend, data8 MSBR_IA64_DIR64LSB/// symbol + addend, data8 LSBR_IA64_GPREL22/// @gprel(sym + add), add imm22R_IA64_GPREL64I/// @gprel(sym + add), mov imm64R_IA64_GPREL32MSB/// @gprel(sym + add), data4 MSBR_IA64_GPREL32LSB/// @gprel(sym + add), data4 LSBR_IA64_GPREL64MSB/// @gprel(sym + add), data8 MSBR_IA64_GPREL64LSB/// @gprel(sym + add), data8 LSBR_IA64_LTOFF22/// @ltoff(sym + add), add imm22R_IA64_LTOFF64I/// @ltoff(sym + add), mov imm64R_IA64_PLTOFF22/// @pltoff(sym + add), add imm22R_IA64_PLTOFF64I/// @pltoff(sym + add), mov imm64R_IA64_PLTOFF64MSB/// @pltoff(sym + add), data8 MSBR_IA64_PLTOFF64LSB/// @pltoff(sym + add), data8 LSBR_IA64_FPTR64I/// @fptr(sym + add), mov imm64R_IA64_FPTR32MSB/// @fptr(sym + add), data4 MSBR_IA64_FPTR32LSB/// @fptr(sym + add), data4 LSBR_IA64_FPTR64MSB/// @fptr(sym + add), data8 MSBR_IA64_FPTR64LSB/// @fptr(sym + add), data8 LSBR_IA64_PCREL60B/// @pcrel(sym + add), brlR_IA64_PCREL21B/// @pcrel(sym + add), ptb, callR_IA64_PCREL21M/// @pcrel(sym + add), chk.sR_IA64_PCREL21F/// @pcrel(sym + add), fchkfR_IA64_PCREL32MSB/// @pcrel(sym + add), data4 MSBR_IA64_PCREL32LSB/// @pcrel(sym + add), data4 LSBR_IA64_PCREL64MSB/// @pcrel(sym + add), data8 MSBR_IA64_PCREL64LSB/// @pcrel(sym + add), data8 LSBR_IA64_LTOFF_FPTR22/// @ltoff(@fptr(s+a)), imm22R_IA64_LTOFF_FPTR64I/// @ltoff(@fptr(s+a)), imm64R_IA64_LTOFF_FPTR32MSB/// @ltoff(@fptr(s+a)), data4 MSBR_IA64_LTOFF_FPTR32LSB/// @ltoff(@fptr(s+a)), data4 LSBR_IA64_LTOFF_FPTR64MSB/// @ltoff(@fptr(s+a)), data8 MSBR_IA64_LTOFF_FPTR64LSB/// @ltoff(@fptr(s+a)), data8 LSBR_IA64_SEGREL32MSB/// @segrel(sym + add), data4 MSBR_IA64_SEGREL32LSB/// @segrel(sym + add), data4 LSBR_IA64_SEGREL64MSB/// @segrel(sym + add), data8 MSBR_IA64_SEGREL64LSB/// @segrel(sym + add), data8 LSBR_IA64_SECREL32MSB/// @secrel(sym + add), data4 MSBR_IA64_SECREL32LSB/// @secrel(sym + add), data4 LSBR_IA64_SECREL64MSB/// @secrel(sym + add), data8 MSBR_IA64_SECREL64LSB/// @secrel(sym + add), data8 LSBR_IA64_REL32MSB/// data 4 + RELR_IA64_REL32LSBR_IA64_REL64MSB/// data 8 + RELR_IA64_REL64LSBR_IA64_LTV32MSBR_IA64_LTV32LSBR_IA64_LTV64MSBR_IA64_LTV64LSBR_IA64_PCREL21BI/// @pcrel(sym + add), 21bit instR_IA64_PCREL22/// @pcrel(sym + add), 22bit instR_IA64_PCREL64I/// @pcrel(sym + add), 64bit instR_IA64_IPLTMSB/// dynamic reloc, imported PLT, MSBR_IA64_IPLTLSB/// dynamic reloc, imported PLT, LSBR_IA64_COPY/// copy relocationR_IA64_SUB/// Addend and symbol differenceR_IA64_LTOFF22X/// LTOFF22, relaxable.R_IA64_LDXMOV/// Use of LTOFF22X.R_IA64_TPREL14/// @tprel(sym + add), imm14R_IA64_TPREL22/// @tprel(sym + add), imm22R_IA64_TPREL64I/// @tprel(sym + add), imm64R_IA64_TPREL64MSB/// @tprel(sym + add), data8 MSBR_IA64_TPREL64LSB/// @tprel(sym + add), data8 LSBR_IA64_LTOFF_TPREL22/// @ltoff(@tprel(s+a)), imm2R_IA64_DTPMOD64MSB/// @dtpmod(sym + add), data8 MSBR_IA64_DTPMOD64LSB/// @dtpmod(sym + add), data8 LSBR_IA64_LTOFF_DTPMOD22/// @ltoff(@dtpmod(sym + add)), imm22R_IA64_DTPREL14/// @dtprel(sym + add), imm14R_IA64_DTPREL22/// @dtprel(sym + add), imm22R_IA64_DTPREL64I/// @dtprel(sym + add), imm64R_IA64_DTPREL32MSB/// @dtprel(sym + add), data4 MSBR_IA64_DTPREL32LSB/// @dtprel(sym + add), data4 LSBR_IA64_DTPREL64MSB/// @dtprel(sym + add), data8 MSBR_IA64_DTPREL64LSB/// @dtprel(sym + add), data8 LSBR_IA64_LTOFF_DTPREL22/// @ltoff(@dtprel(s+a)), imm22EF_SH_MACH_MASK// SH values `FileHeader*::e_flags`.EF_SH_UNKNOWNEF_SH1EF_SH2EF_SH3EF_SH_DSPEF_SH3_DSPEF_SH4AL_DSPEF_SH3EEF_SH4EF_SH2EEF_SH4AEF_SH2AEF_SH4_NOFPUEF_SH4A_NOFPUEF_SH4_NOMMU_NOFPUEF_SH2A_NOFPUEF_SH3_NOMMUEF_SH2A_SH4_NOFPUEF_SH2A_SH3_NOFPUEF_SH2A_SH4EF_SH2A_SH3ER_SH_NONE// SH values `Rel*::r_type`.R_SH_DIR32R_SH_REL32R_SH_DIR8WPNR_SH_IND12WR_SH_DIR8WPLR_SH_DIR8WPZR_SH_DIR8BPR_SH_DIR8WR_SH_DIR8LR_SH_SWITCH16R_SH_SWITCH32R_SH_USESR_SH_COUNTR_SH_ALIGNR_SH_CODER_SH_DATAR_SH_LABELR_SH_SWITCH8R_SH_GNU_VTINHERITR_SH_GNU_VTENTRYR_SH_TLS_GD_32R_SH_TLS_LD_32R_SH_TLS_LDO_32R_SH_TLS_IE_32R_SH_TLS_LE_32R_SH_TLS_DTPMOD32R_SH_TLS_DTPOFF32R_SH_TLS_TPOFF32R_SH_GOT32R_SH_PLT32R_SH_COPYR_SH_GLOB_DATR_SH_JMP_SLOTR_SH_RELATIVER_SH_GOTOFFR_SH_GOTPCEF_S390_HIGH_GPRS/// High GPRs kernel facility needed.R_390_NONER_390_8/// Direct 8 bit.R_390_12/// Direct 12 bit.R_390_16/// Direct 16 bit.R_390_32R_390_PC32/// PC relative 32 bit.R_390_GOT12/// 12 bit GOT offset.R_390_GOT32/// 32 bit GOT offset.R_390_PLT32/// 32 bit PC relative PLT address.R_390_COPYR_390_GLOB_DATR_390_JMP_SLOTR_390_RELATIVER_390_GOTOFF32/// 32 bit offset to GOT.R_390_GOTPC/// 32 bit PC relative offset to GOT.R_390_GOT16/// 16 bit GOT offset.R_390_PC16/// PC relative 16 bit.R_390_PC16DBL/// PC relative 16 bit shifted by 1.R_390_PLT16DBL/// 16 bit PC rel. PLT shifted by 1.R_390_PC32DBL/// PC relative 32 bit shifted by 1.R_390_PLT32DBL/// 32 bit PC rel. PLT shifted by 1.R_390_GOTPCDBL/// 32 bit PC rel. GOT shifted by 1.R_390_64R_390_PC64/// PC relative 64 bit.R_390_GOT64/// 64 bit GOT offset.R_390_PLT64/// 64 bit PC relative PLT address.R_390_GOTENT/// 32 bit PC rel. to GOT entry >> 1.R_390_GOTOFF16/// 16 bit offset to GOT.R_390_GOTOFF64/// 64 bit offset to GOT.R_390_GOTPLT12/// 12 bit offset to jump slot.R_390_GOTPLT16/// 16 bit offset to jump slot.R_390_GOTPLT32/// 32 bit offset to jump slot.R_390_GOTPLT64/// 64 bit offset to jump slot.R_390_GOTPLTENT/// 32 bit rel. offset to jump slot.R_390_PLTOFF16/// 16 bit offset from GOT to PLT.R_390_PLTOFF32/// 32 bit offset from GOT to PLT.R_390_PLTOFF64R_390_TLS_LOAD/// Tag for load insn in TLS code.R_390_TLS_GDCALL/// Tag for function call in general dynamic TLS code.R_390_TLS_LDCALL/// Tag for function call in local dynamic TLS code.R_390_TLS_GD32/// Direct 32 bit for general dynamic thread local data.R_390_TLS_GD64/// Direct 64 bit for general dynamic thread local data.R_390_TLS_GOTIE12/// 12 bit GOT offset for static TLS block offset.R_390_TLS_GOTIE32/// 32 bit GOT offset for static TLS block offset.R_390_TLS_GOTIE64/// 64 bit GOT offset for static TLS block offset.R_390_TLS_LDM32/// Direct 32 bit for local dynamic thread local data in LE code.R_390_TLS_LDM64/// Direct 64 bit for local dynamic thread local data in LE code.R_390_TLS_IE32/// 32 bit address of GOT entry for negated static TLS block offset.R_390_TLS_IE64/// 64 bit address of GOT entry for negated static TLS block offset.R_390_TLS_IEENT/// 32 bit rel. offset to GOT entry for negated static TLS block offset.R_390_TLS_LE32/// 32 bit negated offset relative to static TLS block.R_390_TLS_LE64/// 64 bit negated offset relative to static TLS block.R_390_TLS_LDO32/// 32 bit offset relative to TLS block.R_390_TLS_LDO64/// 64 bit offset relative to TLS block.R_390_TLS_DTPMOD/// ID of module containing symbol.R_390_TLS_DTPOFF/// Offset in TLS block.R_390_TLS_TPOFF/// Negated offset in static TLS block.R_390_20/// Direct 20 bit.R_390_GOT20/// 20 bit GOT offset.R_390_GOTPLT20/// 20 bit offset to jump slot.R_390_TLS_GOTIE20/// 20 bit GOT offset for static TLS block offset.R_390_IRELATIVER_CRIS_NONE// CRIS values `Rel*::r_type`.R_CRIS_8R_CRIS_16R_CRIS_32R_CRIS_8_PCRELR_CRIS_16_PCRELR_CRIS_32_PCRELR_CRIS_GNU_VTINHERITR_CRIS_GNU_VTENTRYR_CRIS_COPYR_CRIS_GLOB_DATR_CRIS_JUMP_SLOTR_CRIS_RELATIVER_CRIS_16_GOTR_CRIS_32_GOTR_CRIS_16_GOTPLTR_CRIS_32_GOTPLTR_CRIS_32_GOTRELR_CRIS_32_PLT_GOTRELR_CRIS_32_PLT_PCRELR_X86_64_NONE// AMD x86-64 values `Rel*::r_type`.R_X86_64_64R_X86_64_PC32/// PC relative 32 bit signedR_X86_64_GOT32R_X86_64_PLT32R_X86_64_COPYR_X86_64_GLOB_DATR_X86_64_JUMP_SLOTR_X86_64_RELATIVER_X86_64_GOTPCREL/// 32 bit signed PC relative offset to GOTR_X86_64_32/// Direct 32 bit zero extendedR_X86_64_32S/// Direct 32 bit sign extendedR_X86_64_16/// Direct 16 bit zero extendedR_X86_64_PC16/// 16 bit sign extended pc relativeR_X86_64_8/// Direct 8 bit sign extendedR_X86_64_PC8/// 8 bit sign extended pc relativeR_X86_64_DTPMOD64R_X86_64_DTPOFF64/// Offset in module's TLS blockR_X86_64_TPOFF64/// Offset in initial TLS blockR_X86_64_TLSGD/// 32 bit signed PC relative offset to two GOT entries for GD symbolR_X86_64_TLSLD/// 32 bit signed PC relative offset to two GOT entries for LD symbolR_X86_64_DTPOFF32R_X86_64_GOTTPOFF/// 32 bit signed PC relative offset to GOT entry for IE symbolR_X86_64_TPOFF32R_X86_64_PC64R_X86_64_GOTOFF64/// 64 bit offset to GOTR_X86_64_GOTPC32/// 32 bit signed pc relative offset to GOTR_X86_64_GOT64/// 64-bit GOT entry offsetR_X86_64_GOTPCREL64/// 64-bit PC relative offset to GOT entryR_X86_64_GOTPC64/// 64-bit PC relative offset to GOTR_X86_64_GOTPLT64/// like GOT64, says PLT entry neededR_X86_64_PLTOFF64/// 64-bit GOT relative offset to PLT entryR_X86_64_SIZE32/// Size of symbol plus 32-bit addendR_X86_64_SIZE64/// Size of symbol plus 64-bit addendR_X86_64_GOTPC32_TLSDESCR_X86_64_TLSDESC_CALL/// Marker for call through TLS descriptor.R_X86_64_TLSDESC/// TLS descriptor.R_X86_64_IRELATIVER_X86_64_RELATIVE64/// 64-bit adjust by program baseR_X86_64_GOTPCRELX// 39 Reserved was R_X86_64_PC32_BND// 40 Reserved was R_X86_64_PLT32_BND/// Load from 32 bit signed pc relative offset to GOT entry without REX prefix, relaxable.R_X86_64_REX_GOTPCRELX/// Load from 32 bit signed pc relative offset to GOT entry with REX prefix, relaxable.SHT_X86_64_UNWIND// AMD x86-64 values `SectionHeader*::sh_type`.R_MN10300_NONE// AM33 values `Rel*::r_type`.R_MN10300_32R_MN10300_16R_MN10300_8R_MN10300_PCREL32R_MN10300_PCREL16/// PC-relative 16-bit signed.R_MN10300_PCREL8/// PC-relative 8-bit signed.R_MN10300_GNU_VTINHERIT/// Ancient C++ vtable garbage...R_MN10300_GNU_VTENTRY/// ... collection annotation.R_MN10300_24/// Direct 24 bit.R_MN10300_GOTPC32/// 32-bit PCrel offset to GOT.R_MN10300_GOTPC16/// 16-bit PCrel offset to GOT.R_MN10300_GOTOFF32/// 32-bit offset from GOT.R_MN10300_GOTOFF24/// 24-bit offset from GOT.R_MN10300_GOTOFF16/// 16-bit offset from GOT.R_MN10300_PLT32/// 32-bit PCrel to PLT entry.R_MN10300_PLT16/// 16-bit PCrel to PLT entry.R_MN10300_GOT32/// 32-bit offset to GOT entry.R_MN10300_GOT24/// 24-bit offset to GOT entry.R_MN10300_GOT16/// 16-bit offset to GOT entry.R_MN10300_COPYR_MN10300_GLOB_DATR_MN10300_JMP_SLOTR_MN10300_RELATIVER_MN10300_TLS_GD/// 32-bit offset for global dynamic.R_MN10300_TLS_LD/// 32-bit offset for local dynamic.R_MN10300_TLS_LDO/// Module-relative offset.R_MN10300_TLS_GOTIE/// GOT offset for static TLS block offset.R_MN10300_TLS_IE/// GOT address for static TLS block offset.R_MN10300_TLS_LE/// Offset relative to static TLS block.R_MN10300_TLS_DTPMODR_MN10300_TLS_DTPOFF/// Offset in module TLS block.R_MN10300_TLS_TPOFF/// Offset in static TLS block.R_MN10300_SYM_DIFF/// Adjustment for next reloc as needed by linker relaxation.R_MN10300_ALIGN/// Alignment requirement for linker relaxation.R_M32R_NONE// M32R values `Rel32::r_type`.R_M32R_16R_M32R_32R_M32R_24R_M32R_10_PCREL/// PC relative 10 bit shifted.R_M32R_18_PCREL/// PC relative 18 bit shifted.R_M32R_26_PCREL/// PC relative 26 bit shifted.R_M32R_HI16_ULO/// High 16 bit with unsigned low.R_M32R_HI16_SLO/// High 16 bit with signed low.R_M32R_LO16/// Low 16 bit.R_M32R_SDA16/// 16 bit offset in SDA.R_M32R_GNU_VTINHERITR_M32R_GNU_VTENTRYR_M32R_16_RELA// M32R values `Rela32::r_type`.R_M32R_32_RELAR_M32R_24_RELAR_M32R_10_PCREL_RELAR_M32R_18_PCREL_RELAR_M32R_26_PCREL_RELAR_M32R_HI16_ULO_RELA/// High 16 bit with unsigned lowR_M32R_HI16_SLO_RELA/// High 16 bit with signed lowR_M32R_LO16_RELAR_M32R_SDA16_RELAR_M32R_RELA_GNU_VTINHERITR_M32R_RELA_GNU_VTENTRYR_M32R_REL32R_M32R_GOT24/// 24 bit GOT entryR_M32R_26_PLTREL/// 26 bit PC relative to PLT shiftedR_M32R_COPYR_M32R_GLOB_DATR_M32R_JMP_SLOTR_M32R_RELATIVER_M32R_GOTOFF/// 24 bit offset to GOTR_M32R_GOTPC24/// 24 bit PC relative offset to GOTR_M32R_GOT16_HI_ULO/// High 16 bit GOT entry with unsigned lowR_M32R_GOT16_HI_SLO/// High 16 bit GOT entry with signed lowR_M32R_GOT16_LO/// Low 16 bit GOT entryR_M32R_GOTPC_HI_ULO/// High 16 bit PC relative offset to GOT with unsigned lowR_M32R_GOTPC_HI_SLO/// High 16 bit PC relative offset to GOT with signed lowR_M32R_GOTPC_LO/// Low 16 bit PC relative offset to GOTR_M32R_GOTOFF_HI_ULO/// High 16 bit offset to GOT with unsigned lowR_M32R_GOTOFF_HI_SLO/// High 16 bit offset to GOT with signed lowR_M32R_GOTOFF_LO/// Low 16 bit offset to GOTR_M32R_NUM/// Keep this the last entry.R_MICROBLAZE_NONE// MicroBlaze values `Rel*::r_type`.R_MICROBLAZE_32R_MICROBLAZE_32_PCRELR_MICROBLAZE_64_PCRELR_MICROBLAZE_32_PCREL_LO/// Low 16 bits of PCREL32.R_MICROBLAZE_64R_MICROBLAZE_32_LOR_MICROBLAZE_SRO32/// Read-only small data area.R_MICROBLAZE_SRW32/// Read-write small data area.R_MICROBLAZE_64_NONER_MICROBLAZE_32_SYM_OP_SYM/// Symbol Op Symbol relocation.R_MICROBLAZE_GNU_VTINHERIT/// GNU C++ vtable hierarchy.R_MICROBLAZE_GNU_VTENTRY/// GNU C++ vtable member usage.R_MICROBLAZE_GOTPC_64/// PC-relative GOT offset.R_MICROBLAZE_GOT_64/// GOT entry offset.R_MICROBLAZE_PLT_64/// PLT offset (PC-relative).R_MICROBLAZE_RELR_MICROBLAZE_JUMP_SLOTR_MICROBLAZE_GLOB_DATR_MICROBLAZE_GOTOFF_64R_MICROBLAZE_GOTOFF_32R_MICROBLAZE_COPY/// Runtime copy.R_MICROBLAZE_TLS/// TLS Reloc.R_MICROBLAZE_TLSGD/// TLS General Dynamic.R_MICROBLAZE_TLSLD/// TLS Local Dynamic.R_MICROBLAZE_TLSDTPMOD32/// TLS Module ID.R_MICROBLAZE_TLSDTPREL32/// TLS Offset Within TLS Block.R_MICROBLAZE_TLSDTPREL64R_MICROBLAZE_TLSGOTTPREL32/// TLS Offset From Thread Pointer.R_MICROBLAZE_TLSTPREL32DT_NIOS2_GP// Nios II values `Dyn::d_tag`./// Address of _gp.R_NIOS2_NONE// Nios II values `Rel*::r_type`.R_NIOS2_S16/// Direct signed 16 bit.R_NIOS2_U16/// Direct unsigned 16 bit.R_NIOS2_PCREL16R_NIOS2_CALL26/// Direct call.R_NIOS2_IMM5/// 5 bit constant expression.R_NIOS2_CACHE_OPX/// 5 bit expression, shift 22.R_NIOS2_IMM6/// 6 bit constant expression.R_NIOS2_IMM8/// 8 bit constant expression.R_NIOS2_HI16/// High 16 bit.R_NIOS2_LO16R_NIOS2_HIADJ16/// High 16 bit, adjusted.R_NIOS2_BFD_RELOC_32/// 32 bit symbol value + addend.R_NIOS2_BFD_RELOC_16/// 16 bit symbol value + addend.R_NIOS2_BFD_RELOC_8/// 8 bit symbol value + addend.R_NIOS2_GPREL/// 16 bit GP pointer offset.R_NIOS2_GNU_VTINHERITR_NIOS2_GNU_VTENTRYR_NIOS2_UJMP/// Unconditional branch.R_NIOS2_CJMP/// Conditional branch.R_NIOS2_CALLR/// Indirect call through register.R_NIOS2_ALIGNR_NIOS2_GOT16/// 16 bit GOT entry.R_NIOS2_CALL16/// 16 bit GOT entry for function.R_NIOS2_GOTOFF_LO/// %lo of offset to GOT pointer.R_NIOS2_GOTOFF_HA/// %hiadj of offset to GOT pointer.R_NIOS2_PCREL_LO/// %lo of PC relative offset.R_NIOS2_PCREL_HA/// %hiadj of PC relative offset.R_NIOS2_TLS_GD16/// 16 bit GOT offset for TLS GD.R_NIOS2_TLS_LDM16/// 16 bit GOT offset for TLS LDM.R_NIOS2_TLS_LDO16/// 16 bit module relative offset.R_NIOS2_TLS_IE16/// 16 bit GOT offset for TLS IE.R_NIOS2_TLS_LE16/// 16 bit LE TP-relative offset.R_NIOS2_TLS_DTPMOD/// Module number.R_NIOS2_TLS_DTPRELR_NIOS2_TLS_TPREL/// TP-relative offset.R_NIOS2_COPYR_NIOS2_GLOB_DATR_NIOS2_JUMP_SLOTR_NIOS2_RELATIVER_NIOS2_GOTOFF/// 16 bit offset to GOT pointer.R_NIOS2_CALL26_NOAT/// Direct call in .noat section.R_NIOS2_GOT_LO/// %lo() of GOT entry.R_NIOS2_GOT_HA/// %hiadj() of GOT entry.R_NIOS2_CALL_LO/// %lo() of function GOT entry.R_NIOS2_CALL_HA/// %hiadj() of function GOT entry.R_TILEPRO_NONE// TILEPro values `Rel*::r_type`.R_TILEPRO_32R_TILEPRO_16R_TILEPRO_8R_TILEPRO_32_PCRELR_TILEPRO_16_PCRELR_TILEPRO_8_PCRELR_TILEPRO_LO16R_TILEPRO_HI16R_TILEPRO_HA16/// High 16 bit, adjustedR_TILEPRO_COPY/// Copy relocationR_TILEPRO_GLOB_DATR_TILEPRO_JMP_SLOTR_TILEPRO_RELATIVER_TILEPRO_BROFF_X1/// X1 pipe branch offsetR_TILEPRO_JOFFLONG_X1/// X1 pipe jump offsetR_TILEPRO_JOFFLONG_X1_PLT/// X1 pipe jump offset to PLTR_TILEPRO_IMM8_X0/// X0 pipe 8-bitR_TILEPRO_IMM8_Y0/// Y0 pipe 8-bitR_TILEPRO_IMM8_X1/// X1 pipe 8-bitR_TILEPRO_IMM8_Y1/// Y1 pipe 8-bitR_TILEPRO_MT_IMM15_X1/// X1 pipe mtsprR_TILEPRO_MF_IMM15_X1/// X1 pipe mfsprR_TILEPRO_IMM16_X0/// X0 pipe 16-bitR_TILEPRO_IMM16_X1/// X1 pipe 16-bitR_TILEPRO_IMM16_X0_LO/// X0 pipe low 16-bitR_TILEPRO_IMM16_X1_LO/// X1 pipe low 16-bitR_TILEPRO_IMM16_X0_HI/// X0 pipe high 16-bitR_TILEPRO_IMM16_X1_HI/// X1 pipe high 16-bitR_TILEPRO_IMM16_X0_HA/// X0 pipe high 16-bit, adjustedR_TILEPRO_IMM16_X1_HA/// X1 pipe high 16-bit, adjustedR_TILEPRO_IMM16_X0_PCREL/// X0 pipe PC relative 16 bitR_TILEPRO_IMM16_X1_PCREL/// X1 pipe PC relative 16 bitR_TILEPRO_IMM16_X0_LO_PCREL/// X0 pipe PC relative low 16 bitR_TILEPRO_IMM16_X1_LO_PCREL/// X1 pipe PC relative low 16 bitR_TILEPRO_IMM16_X0_HI_PCREL/// X0 pipe PC relative high 16 bitR_TILEPRO_IMM16_X1_HI_PCREL/// X1 pipe PC relative high 16 bitR_TILEPRO_IMM16_X0_HA_PCREL/// X0 pipe PC relative ha() 16 bitR_TILEPRO_IMM16_X1_HA_PCREL/// X1 pipe PC relative ha() 16 bitR_TILEPRO_IMM16_X0_GOT/// X0 pipe 16-bit GOT offsetR_TILEPRO_IMM16_X1_GOT/// X1 pipe 16-bit GOT offsetR_TILEPRO_IMM16_X0_GOT_LO/// X0 pipe low 16-bit GOT offsetR_TILEPRO_IMM16_X1_GOT_LO/// X1 pipe low 16-bit GOT offsetR_TILEPRO_IMM16_X0_GOT_HI/// X0 pipe high 16-bit GOT offsetR_TILEPRO_IMM16_X1_GOT_HI/// X1 pipe high 16-bit GOT offsetR_TILEPRO_IMM16_X0_GOT_HA/// X0 pipe ha() 16-bit GOT offsetR_TILEPRO_IMM16_X1_GOT_HA/// X1 pipe ha() 16-bit GOT offsetR_TILEPRO_MMSTART_X0/// X0 pipe mm "start"R_TILEPRO_MMEND_X0/// X0 pipe mm "end"R_TILEPRO_MMSTART_X1/// X1 pipe mm "start"R_TILEPRO_MMEND_X1/// X1 pipe mm "end"R_TILEPRO_SHAMT_X0/// X0 pipe shift amountR_TILEPRO_SHAMT_X1/// X1 pipe shift amountR_TILEPRO_SHAMT_Y0/// Y0 pipe shift amountR_TILEPRO_SHAMT_Y1/// Y1 pipe shift amountR_TILEPRO_DEST_IMM8_X1/// X1 pipe destination 8-bitR_TILEPRO_TLS_GD_CALL// Relocs 56-59 are currently not defined./// "jal" for TLS GDR_TILEPRO_IMM8_X0_TLS_GD_ADD/// X0 pipe "addi" for TLS GDR_TILEPRO_IMM8_X1_TLS_GD_ADD/// X1 pipe "addi" for TLS GDR_TILEPRO_IMM8_Y0_TLS_GD_ADD/// Y0 pipe "addi" for TLS GDR_TILEPRO_IMM8_Y1_TLS_GD_ADD/// Y1 pipe "addi" for TLS GDR_TILEPRO_TLS_IE_LOAD/// "lw_tls" for TLS IER_TILEPRO_IMM16_X0_TLS_GD/// X0 pipe 16-bit TLS GD offsetR_TILEPRO_IMM16_X1_TLS_GD/// X1 pipe 16-bit TLS GD offsetR_TILEPRO_IMM16_X0_TLS_GD_LO/// X0 pipe low 16-bit TLS GD offsetR_TILEPRO_IMM16_X1_TLS_GD_LO/// X1 pipe low 16-bit TLS GD offsetR_TILEPRO_IMM16_X0_TLS_GD_HI/// X0 pipe high 16-bit TLS GD offsetR_TILEPRO_IMM16_X1_TLS_GD_HI/// X1 pipe high 16-bit TLS GD offsetR_TILEPRO_IMM16_X0_TLS_GD_HA/// X0 pipe ha() 16-bit TLS GD offsetR_TILEPRO_IMM16_X1_TLS_GD_HA/// X1 pipe ha() 16-bit TLS GD offsetR_TILEPRO_IMM16_X0_TLS_IE/// X0 pipe 16-bit TLS IE offsetR_TILEPRO_IMM16_X1_TLS_IE/// X1 pipe 16-bit TLS IE offsetR_TILEPRO_IMM16_X0_TLS_IE_LO/// X0 pipe low 16-bit TLS IE offsetR_TILEPRO_IMM16_X1_TLS_IE_LO/// X1 pipe low 16-bit TLS IE offsetR_TILEPRO_IMM16_X0_TLS_IE_HI/// X0 pipe high 16-bit TLS IE offsetR_TILEPRO_IMM16_X1_TLS_IE_HI/// X1 pipe high 16-bit TLS IE offsetR_TILEPRO_IMM16_X0_TLS_IE_HA/// X0 pipe ha() 16-bit TLS IE offsetR_TILEPRO_IMM16_X1_TLS_IE_HA/// X1 pipe ha() 16-bit TLS IE offsetR_TILEPRO_TLS_DTPMOD32R_TILEPRO_TLS_DTPOFF32R_TILEPRO_TLS_TPOFF32R_TILEPRO_IMM16_X0_TLS_LE/// X0 pipe 16-bit TLS LE offsetR_TILEPRO_IMM16_X1_TLS_LE/// X1 pipe 16-bit TLS LE offsetR_TILEPRO_IMM16_X0_TLS_LE_LO/// X0 pipe low 16-bit TLS LE offsetR_TILEPRO_IMM16_X1_TLS_LE_LO/// X1 pipe low 16-bit TLS LE offsetR_TILEPRO_IMM16_X0_TLS_LE_HI/// X0 pipe high 16-bit TLS LE offsetR_TILEPRO_IMM16_X1_TLS_LE_HI/// X1 pipe high 16-bit TLS LE offsetR_TILEPRO_IMM16_X0_TLS_LE_HA/// X0 pipe ha() 16-bit TLS LE offsetR_TILEPRO_IMM16_X1_TLS_LE_HA/// X1 pipe ha() 16-bit TLS LE offsetR_TILEPRO_GNU_VTINHERIT/// GNU C++ vtable hierarchyR_TILEPRO_GNU_VTENTRY/// GNU C++ vtable member usageR_TILEGX_NONE// TILE-Gx values `Rel*::r_type`.R_TILEGX_64R_TILEGX_32R_TILEGX_16R_TILEGX_8R_TILEGX_64_PCRELR_TILEGX_32_PCRELR_TILEGX_16_PCRELR_TILEGX_8_PCRELR_TILEGX_HW0/// hword 0 16-bitR_TILEGX_HW1/// hword 1 16-bitR_TILEGX_HW2/// hword 2 16-bitR_TILEGX_HW3/// hword 3 16-bitR_TILEGX_HW0_LAST/// last hword 0 16-bitR_TILEGX_HW1_LAST/// last hword 1 16-bitR_TILEGX_HW2_LAST/// last hword 2 16-bitR_TILEGX_COPYR_TILEGX_GLOB_DATR_TILEGX_JMP_SLOTR_TILEGX_RELATIVER_TILEGX_BROFF_X1R_TILEGX_JUMPOFF_X1R_TILEGX_JUMPOFF_X1_PLTR_TILEGX_IMM8_X0R_TILEGX_IMM8_Y0R_TILEGX_IMM8_X1R_TILEGX_IMM8_Y1R_TILEGX_DEST_IMM8_X1R_TILEGX_MT_IMM14_X1R_TILEGX_MF_IMM14_X1R_TILEGX_MMSTART_X0R_TILEGX_MMEND_X0R_TILEGX_SHAMT_X0R_TILEGX_SHAMT_X1R_TILEGX_SHAMT_Y0R_TILEGX_SHAMT_Y1R_TILEGX_IMM16_X0_HW0/// X0 pipe hword 0R_TILEGX_IMM16_X1_HW0/// X1 pipe hword 0R_TILEGX_IMM16_X0_HW1/// X0 pipe hword 1R_TILEGX_IMM16_X1_HW1/// X1 pipe hword 1R_TILEGX_IMM16_X0_HW2/// X0 pipe hword 2R_TILEGX_IMM16_X1_HW2/// X1 pipe hword 2R_TILEGX_IMM16_X0_HW3/// X0 pipe hword 3R_TILEGX_IMM16_X1_HW3/// X1 pipe hword 3R_TILEGX_IMM16_X0_HW0_LAST/// X0 pipe last hword 0R_TILEGX_IMM16_X1_HW0_LAST/// X1 pipe last hword 0R_TILEGX_IMM16_X0_HW1_LAST/// X0 pipe last hword 1R_TILEGX_IMM16_X1_HW1_LAST/// X1 pipe last hword 1R_TILEGX_IMM16_X0_HW2_LAST/// X0 pipe last hword 2R_TILEGX_IMM16_X1_HW2_LAST/// X1 pipe last hword 2R_TILEGX_IMM16_X0_HW0_PCREL/// X0 pipe PC relative hword 0R_TILEGX_IMM16_X1_HW0_PCREL/// X1 pipe PC relative hword 0R_TILEGX_IMM16_X0_HW1_PCREL/// X0 pipe PC relative hword 1R_TILEGX_IMM16_X1_HW1_PCREL/// X1 pipe PC relative hword 1R_TILEGX_IMM16_X0_HW2_PCREL/// X0 pipe PC relative hword 2R_TILEGX_IMM16_X1_HW2_PCREL/// X1 pipe PC relative hword 2R_TILEGX_IMM16_X0_HW3_PCREL/// X0 pipe PC relative hword 3R_TILEGX_IMM16_X1_HW3_PCREL/// X1 pipe PC relative hword 3R_TILEGX_IMM16_X0_HW0_LAST_PCREL/// X0 pipe PC-rel last hword 0R_TILEGX_IMM16_X1_HW0_LAST_PCREL/// X1 pipe PC-rel last hword 0R_TILEGX_IMM16_X0_HW1_LAST_PCREL/// X0 pipe PC-rel last hword 1R_TILEGX_IMM16_X1_HW1_LAST_PCREL/// X1 pipe PC-rel last hword 1R_TILEGX_IMM16_X0_HW2_LAST_PCREL/// X0 pipe PC-rel last hword 2R_TILEGX_IMM16_X1_HW2_LAST_PCREL/// X1 pipe PC-rel last hword 2R_TILEGX_IMM16_X0_HW0_GOT/// X0 pipe hword 0 GOT offsetR_TILEGX_IMM16_X1_HW0_GOT/// X1 pipe hword 0 GOT offsetR_TILEGX_IMM16_X0_HW0_PLT_PCREL/// X0 pipe PC-rel PLT hword 0R_TILEGX_IMM16_X1_HW0_PLT_PCREL/// X1 pipe PC-rel PLT hword 0R_TILEGX_IMM16_X0_HW1_PLT_PCREL/// X0 pipe PC-rel PLT hword 1R_TILEGX_IMM16_X1_HW1_PLT_PCREL/// X1 pipe PC-rel PLT hword 1R_TILEGX_IMM16_X0_HW2_PLT_PCREL/// X0 pipe PC-rel PLT hword 2R_TILEGX_IMM16_X1_HW2_PLT_PCREL/// X1 pipe PC-rel PLT hword 2R_TILEGX_IMM16_X0_HW0_LAST_GOT/// X0 pipe last hword 0 GOT offsetR_TILEGX_IMM16_X1_HW0_LAST_GOT/// X1 pipe last hword 0 GOT offsetR_TILEGX_IMM16_X0_HW1_LAST_GOT/// X0 pipe last hword 1 GOT offsetR_TILEGX_IMM16_X1_HW1_LAST_GOT/// X1 pipe last hword 1 GOT offsetR_TILEGX_IMM16_X0_HW3_PLT_PCREL/// X0 pipe PC-rel PLT hword 3R_TILEGX_IMM16_X1_HW3_PLT_PCREL/// X1 pipe PC-rel PLT hword 3R_TILEGX_IMM16_X0_HW0_TLS_GD/// X0 pipe hword 0 TLS GD offsetR_TILEGX_IMM16_X1_HW0_TLS_GD/// X1 pipe hword 0 TLS GD offsetR_TILEGX_IMM16_X0_HW0_TLS_LE/// X0 pipe hword 0 TLS LE offsetR_TILEGX_IMM16_X1_HW0_TLS_LE/// X1 pipe hword 0 TLS LE offsetR_TILEGX_IMM16_X0_HW0_LAST_TLS_LE/// X0 pipe last hword 0 LE offR_TILEGX_IMM16_X1_HW0_LAST_TLS_LE/// X1 pipe last hword 0 LE offR_TILEGX_IMM16_X0_HW1_LAST_TLS_LE/// X0 pipe last hword 1 LE offR_TILEGX_IMM16_X1_HW1_LAST_TLS_LE/// X1 pipe last hword 1 LE offR_TILEGX_IMM16_X0_HW0_LAST_TLS_GD/// X0 pipe last hword 0 GD offR_TILEGX_IMM16_X1_HW0_LAST_TLS_GD/// X1 pipe last hword 0 GD offR_TILEGX_IMM16_X0_HW1_LAST_TLS_GD/// X0 pipe last hword 1 GD offR_TILEGX_IMM16_X1_HW1_LAST_TLS_GD/// X1 pipe last hword 1 GD offR_TILEGX_IMM16_X0_HW0_TLS_IE// Relocs 90-91 are currently not defined./// X0 pipe hword 0 TLS IE offsetR_TILEGX_IMM16_X1_HW0_TLS_IE/// X1 pipe hword 0 TLS IE offsetR_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL/// X0 pipe PC-rel PLT last hword 0R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL/// X1 pipe PC-rel PLT last hword 0R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL/// X0 pipe PC-rel PLT last hword 1R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL/// X1 pipe PC-rel PLT last hword 1R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL/// X0 pipe PC-rel PLT last hword 2R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL/// X1 pipe PC-rel PLT last hword 2R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE/// X0 pipe last hword 0 IE offR_TILEGX_IMM16_X1_HW0_LAST_TLS_IE/// X1 pipe last hword 0 IE offR_TILEGX_IMM16_X0_HW1_LAST_TLS_IE/// X0 pipe last hword 1 IE offR_TILEGX_IMM16_X1_HW1_LAST_TLS_IE/// X1 pipe last hword 1 IE offR_TILEGX_TLS_DTPMOD64// Relocs 104-105 are currently not defined./// 64-bit ID of symbol's moduleR_TILEGX_TLS_DTPOFF64/// 64-bit offset in TLS blockR_TILEGX_TLS_TPOFF64/// 64-bit offset in static TLS blockR_TILEGX_TLS_DTPMOD32/// 32-bit ID of symbol's moduleR_TILEGX_TLS_DTPOFF32/// 32-bit offset in TLS blockR_TILEGX_TLS_TPOFF32/// 32-bit offset in static TLS blockR_TILEGX_TLS_GD_CALLR_TILEGX_IMM8_X0_TLS_GD_ADDR_TILEGX_IMM8_X1_TLS_GD_ADDR_TILEGX_IMM8_Y0_TLS_GD_ADDR_TILEGX_IMM8_Y1_TLS_GD_ADDR_TILEGX_TLS_IE_LOAD/// "ld_tls" for TLS IER_TILEGX_IMM8_X0_TLS_ADD/// X0 pipe "addi" for TLS GD/IER_TILEGX_IMM8_X1_TLS_ADD/// X1 pipe "addi" for TLS GD/IER_TILEGX_IMM8_Y0_TLS_ADD/// Y0 pipe "addi" for TLS GD/IER_TILEGX_IMM8_Y1_TLS_ADD/// Y1 pipe "addi" for TLS GD/IER_TILEGX_GNU_VTINHERITR_TILEGX_GNU_VTENTRYEF_RISCV_RVC// RISC-V values `FileHeader*::e_flags`.EF_RISCV_FLOAT_ABIEF_RISCV_FLOAT_ABI_SOFTEF_RISCV_FLOAT_ABI_SINGLEEF_RISCV_FLOAT_ABI_DOUBLEEF_RISCV_FLOAT_ABI_QUADEF_RISCV_RVEEF_RISCV_TSOSHT_RISCV_ATTRIBUTES// RISC-V values for `SectionHeader*::sh_type`./// RISC-V attributes section.R_RISCV_NONE// RISC-V values `Rel*::r_type`.R_RISCV_32R_RISCV_64R_RISCV_RELATIVER_RISCV_COPYR_RISCV_JUMP_SLOTR_RISCV_TLS_DTPMOD32R_RISCV_TLS_DTPMOD64R_RISCV_TLS_DTPREL32R_RISCV_TLS_DTPREL64R_RISCV_TLS_TPREL32R_RISCV_TLS_TPREL64R_RISCV_BRANCHR_RISCV_JALR_RISCV_CALLR_RISCV_CALL_PLTR_RISCV_GOT_HI20R_RISCV_TLS_GOT_HI20R_RISCV_TLS_GD_HI20R_RISCV_PCREL_HI20R_RISCV_PCREL_LO12_IR_RISCV_PCREL_LO12_SR_RISCV_HI20R_RISCV_LO12_IR_RISCV_LO12_SR_RISCV_TPREL_HI20R_RISCV_TPREL_LO12_IR_RISCV_TPREL_LO12_SR_RISCV_TPREL_ADDR_RISCV_ADD8R_RISCV_ADD16R_RISCV_ADD32R_RISCV_ADD64R_RISCV_SUB8R_RISCV_SUB16R_RISCV_SUB32R_RISCV_SUB64R_RISCV_GNU_VTINHERITR_RISCV_GNU_VTENTRYR_RISCV_ALIGNR_RISCV_RVC_BRANCHR_RISCV_RVC_JUMPR_RISCV_RVC_LUIR_RISCV_GPREL_IR_RISCV_GPREL_SR_RISCV_TPREL_IR_RISCV_TPREL_SR_RISCV_RELAXR_RISCV_SUB6R_RISCV_SET6R_RISCV_SET8R_RISCV_SET16R_RISCV_SET32R_RISCV_32_PCRELR_RISCV_IRELATIVER_RISCV_PLT32R_RISCV_SET_ULEB128R_RISCV_SUB_ULEB128R_RISCV_TLSDESC_HI20R_RISCV_TLSDESC_LOAD_LO12R_RISCV_TLSDESC_ADD_LO12R_RISCV_TLSDESC_CALLR_BPF_NONE// BPF values `Rel*::r_type`.R_BPF_64_64R_BPF_64_32R_SBF_NONE// SBF values `Rel*::r_type`.R_SBF_64_64R_SBF_64_32R_METAG_HIADDR16R_METAG_LOADDR16R_METAG_ADDR32R_METAG_NONER_METAG_RELBRANCHR_METAG_GETSETOFFR_METAG_REG32OP1// Backward compatibilityR_METAG_REG32OP2R_METAG_REG32OP3R_METAG_REG16OP1R_METAG_REG16OP2R_METAG_REG16OP3R_METAG_REG32OP4R_METAG_HIOGR_METAG_LOOGR_METAG_REL8R_METAG_REL16R_METAG_GNU_VTINHERITR_METAG_GNU_VTENTRYR_METAG_HI16_GOTOFF// PIC relocationsR_METAG_LO16_GOTOFFR_METAG_GETSET_GOTOFFR_METAG_GETSET_GOTR_METAG_HI16_GOTPCR_METAG_LO16_GOTPCR_METAG_HI16_PLTR_METAG_LO16_PLTR_METAG_RELBRANCH_PLTR_METAG_GOTOFFR_METAG_PLTR_METAG_COPYR_METAG_JMP_SLOTR_METAG_RELATIVER_METAG_GLOB_DATR_METAG_TLS_GD// TLS relocationsR_METAG_TLS_LDMR_METAG_TLS_LDO_HI16R_METAG_TLS_LDO_LO16R_METAG_TLS_LDOR_METAG_TLS_IER_METAG_TLS_IENONPICR_METAG_TLS_IENONPIC_HI16R_METAG_TLS_IENONPIC_LO16R_METAG_TLS_TPOFFR_METAG_TLS_DTPMODR_METAG_TLS_DTPOFFR_METAG_TLS_LER_METAG_TLS_LE_HI16R_METAG_TLS_LE_LO16R_NDS32_NONE// NDS32 values `Rel*::r_type`.R_NDS32_32_RELAR_NDS32_COPYR_NDS32_GLOB_DATR_NDS32_JMP_SLOTR_NDS32_RELATIVER_NDS32_TLS_TPOFFR_NDS32_TLS_DESCEF_LARCH_ABI_MODIFIER_MASK// LoongArch values `FileHeader*::e_flags`./// Additional properties of the base ABI type, including the FP calling/// convention.EF_LARCH_ABI_SOFT_FLOAT/// Uses GPRs and the stack for parameter passingEF_LARCH_ABI_SINGLE_FLOAT/// Uses GPRs, 32-bit FPRs and the stack for parameter passingEF_LARCH_ABI_DOUBLE_FLOAT/// Uses GPRs, 64-bit FPRs and the stack for parameter passingEF_LARCH_OBJABI_V1/// Uses relocation types directly writing to immediate slotsR_LARCH_NONE// LoongArch values `Rel*::r_type`.R_LARCH_32/// Runtime address resolvingR_LARCH_64R_LARCH_RELATIVE/// Runtime fixup for load-addressR_LARCH_COPY/// Runtime memory copy in executableR_LARCH_JUMP_SLOT/// Runtime PLT supportingR_LARCH_TLS_DTPMOD32/// Runtime relocation for TLS-GDR_LARCH_TLS_DTPMOD64R_LARCH_TLS_DTPREL32R_LARCH_TLS_DTPREL64R_LARCH_TLS_TPREL32/// Runtime relocation for TLE-IER_LARCH_TLS_TPREL64R_LARCH_IRELATIVE/// Runtime local indirect function resolvingR_LARCH_MARK_LA/// Mark la.abs: load absolute address for static link.R_LARCH_MARK_PCREL/// Mark external label branch: access PC relative address for static link.R_LARCH_SOP_PUSH_PCREL/// Push PC-relative offsetR_LARCH_SOP_PUSH_ABSOLUTE/// Push constant or absolute addressR_LARCH_SOP_PUSH_DUP/// Duplicate stack topR_LARCH_SOP_PUSH_GPREL/// Push for access GOT entryR_LARCH_SOP_PUSH_TLS_TPREL/// Push for TLS-LER_LARCH_SOP_PUSH_TLS_GOT/// Push for TLS-IER_LARCH_SOP_PUSH_TLS_GD/// Push for TLS-GDR_LARCH_SOP_PUSH_PLT_PCREL/// Push for external function callingR_LARCH_SOP_ASSERT/// Assert stack topR_LARCH_SOP_NOT/// Stack top logical not (unary)R_LARCH_SOP_SUB/// Stack top subtraction (binary)R_LARCH_SOP_SL/// Stack top left shift (binary)R_LARCH_SOP_SR/// Stack top right shift (binary)R_LARCH_SOP_ADD/// Stack top addition (binary)R_LARCH_SOP_AND/// Stack top bitwise and (binary)R_LARCH_SOP_IF_ELSE/// Stack top selection (tertiary)R_LARCH_SOP_POP_32_S_10_5/// Pop stack top to fill 5-bit signed immediate operandR_LARCH_SOP_POP_32_U_10_12/// Pop stack top to fill 12-bit unsigned immediate operandR_LARCH_SOP_POP_32_S_10_12/// Pop stack top to fill 12-bit signed immediate operandR_LARCH_SOP_POP_32_S_10_16/// Pop stack top to fill 16-bit signed immediate operandR_LARCH_SOP_POP_32_S_10_16_S2/// Pop stack top to fill 18-bit signed immediate operand with two trailing/// zeros impliedR_LARCH_SOP_POP_32_S_5_20/// Pop stack top to fill 20-bit signed immediate operandR_LARCH_SOP_POP_32_S_0_5_10_16_S2/// Pop stack top to fill 23-bit signed immediate operand with two trailingR_LARCH_SOP_POP_32_S_0_10_10_16_S2/// Pop stack top to fill 28-bit signed immediate operand with two trailingR_LARCH_SOP_POP_32_U/// Pop stack top to fill an instructionR_LARCH_ADD8/// 8-bit in-place additionR_LARCH_ADD16/// 16-bit in-place additionR_LARCH_ADD24/// 24-bit in-place additionR_LARCH_ADD32/// 32-bit in-place additionR_LARCH_ADD64/// 64-bit in-place additionR_LARCH_SUB8/// 8-bit in-place subtractionR_LARCH_SUB16/// 16-bit in-place subtractionR_LARCH_SUB24/// 24-bit in-place subtractionR_LARCH_SUB32/// 32-bit in-place subtractionR_LARCH_SUB64/// 64-bit in-place subtractionR_LARCH_GNU_VTINHERITR_LARCH_GNU_VTENTRYR_LARCH_B16/// 18-bit PC-relative jump offset with two trailing zerosR_LARCH_B21/// 23-bit PC-relative jump offset with two trailing zerosR_LARCH_B26/// 28-bit PC-relative jump offset with two trailing zerosR_LARCH_ABS_HI20/// 12..=31 bits of 32/64-bit absolute addressR_LARCH_ABS_LO12/// 0..=11 bits of 32/64-bit absolute addressR_LARCH_ABS64_LO20/// 32..=51 bits of 64-bit absolute addressR_LARCH_ABS64_HI12/// 52..=63 bits of 64-bit absolute addressR_LARCH_PCALA_HI20/// The signed 32-bit offset `offs` from `PC & 0xfffff000` to/// `(S + A + 0x800) & 0xfffff000`, with 12 trailing zeros removed./// We define the *PC relative anchor* for `S + A` as `PC + offs` (`offs`/// is sign-extended to VA bits).R_LARCH_PCALA_LO12/// Same as R_LARCH_ABS_LO12.  0..=11 bits of the 32/64-bit offset from the/// [PC relative anchor][R_LARCH_PCALA_HI20].R_LARCH_PCALA64_LO20/// 32..=51 bits of the 64-bit offset from theR_LARCH_PCALA64_HI12/// 52..=63 bits of the 64-bit offset from theR_LARCH_GOT_PC_HI20/// `(GP + G + 0x800) & 0xfffff000`, with 12 trailing zeros removed./// We define the *PC relative anchor* for the GOT entry at `GP + G` as/// `PC + offs` (`offs` is sign-extended to VA bits).R_LARCH_GOT_PC_LO12/// 0..=11 bits of the 32/64-bit offset from the/// [PC relative anchor][R_LARCH_GOT_PC_HI20] to the GOT entry.R_LARCH_GOT64_PC_LO20R_LARCH_GOT64_PC_HI12R_LARCH_GOT_HI20/// 12..=31 bits of 32/64-bit GOT entry absolute addressR_LARCH_GOT_LO12/// 0..=11 bits of 32/64-bit GOT entry absolute addressR_LARCH_GOT64_LO20/// 32..=51 bits of 64-bit GOT entry absolute addressR_LARCH_GOT64_HI12/// 52..=63 bits of 64-bit GOT entry absolute addressR_LARCH_TLS_LE_HI20/// 12..=31 bits of TLS LE 32/64-bit offset from thread pointerR_LARCH_TLS_LE_LO12/// 0..=11 bits of TLS LE 32/64-bit offset from thread pointerR_LARCH_TLS_LE64_LO20/// 32..=51 bits of TLS LE 64-bit offset from thread pointerR_LARCH_TLS_LE64_HI12/// 52..=63 bits of TLS LE 64-bit offset from thread pointerR_LARCH_TLS_IE_PC_HI20/// `(GP + IE + 0x800) & 0xfffff000`, with 12 trailing zeros removed./// We define the *PC relative anchor* for the TLS IE GOT entry at/// `GP + IE` as `PC + offs` (`offs` is sign-extended to VA bits).R_LARCH_TLS_IE_PC_LO12/// 0..=12 bits of the 32/64-bit offset from the/// [PC-relative anchor][R_LARCH_TLS_IE_PC_HI20] to the TLS IE GOT entry.R_LARCH_TLS_IE64_PC_LO20R_LARCH_TLS_IE64_PC_HI12R_LARCH_TLS_IE_HI20/// 12..=31 bits of TLS IE GOT entry 32/64-bit absolute addressR_LARCH_TLS_IE_LO12/// 0..=11 bits of TLS IE GOT entry 32/64-bit absolute addressR_LARCH_TLS_IE64_LO20/// 32..=51 bits of TLS IE GOT entry 64-bit absolute addressR_LARCH_TLS_IE64_HI12/// 51..=63 bits of TLS IE GOT entry 64-bit absolute addressR_LARCH_TLS_LD_PC_HI20/// 12..=31 bits of the offset from `PC` to `GP + GD + 0x800`, where/// `GP + GD` is a TLS LD GOT entryR_LARCH_TLS_LD_HI20/// 12..=31 bits of TLS LD GOT entry 32/64-bit absolute addressR_LARCH_TLS_GD_PC_HI20/// 12..=31 bits of the 32/64-bit PC-relative offset to the PC-relative/// anchor for the TLE GD GOT entry.R_LARCH_TLS_GD_HI20/// 12..=31 bits of TLS GD GOT entry 32/64-bit absolute addressR_LARCH_32_PCREL/// 32-bit PC relativeR_LARCH_RELAX/// Paired with a normal relocation at the same address to indicate the/// instruction can be relaxedR_LARCH_DELETER_LARCH_ALIGN/// Delete some bytes to ensure the instruction at PC + A aligned to/// `A.next_power_of_two()`-byte boundaryR_LARCH_PCREL20_S2/// 22-bit PC-relative offset with two trailing zerosR_LARCH_CFAR_LARCH_ADD6/// 6-bit in-place additionR_LARCH_SUB6/// 6-bit in-place subtractionR_LARCH_ADD_ULEB128/// LEB128 in-place additionR_LARCH_SUB_ULEB128/// LEB128 in-place subtractionR_LARCH_64_PCREL/// 64-bit PC relativeR_LARCH_CALL36/// 18..=37 bits of `S + A - PC` into the `pcaddu18i` instruction at `PC`,/// and 2..=17 bits of `S + A - PC` into the `jirl` instruction at `PC + 4`R_XTENSA_NONE// Xtensa values Rel*::r_type`.R_XTENSA_32R_XTENSA_RTLDR_XTENSA_GLOB_DATR_XTENSA_JMP_SLOTR_XTENSA_RELATIVER_XTENSA_PLTR_XTENSA_OP0R_XTENSA_OP1R_XTENSA_OP2R_XTENSA_ASM_EXPANDR_XTENSA_ASM_SIMPLIFYR_XTENSA_32_PCRELR_XTENSA_GNU_VTINHERITR_XTENSA_GNU_VTENTRYR_XTENSA_DIFF8R_XTENSA_DIFF16R_XTENSA_DIFF32R_XTENSA_SLOT0_OPR_XTENSA_SLOT1_OPR_XTENSA_SLOT2_OPR_XTENSA_SLOT3_OPR_XTENSA_SLOT4_OPR_XTENSA_SLOT5_OPR_XTENSA_SLOT6_OPR_XTENSA_SLOT7_OPR_XTENSA_SLOT8_OPR_XTENSA_SLOT9_OPR_XTENSA_SLOT10_OPR_XTENSA_SLOT11_OPR_XTENSA_SLOT12_OPR_XTENSA_SLOT13_OPR_XTENSA_SLOT14_OPR_XTENSA_SLOT0_ALTR_XTENSA_SLOT1_ALTR_XTENSA_SLOT2_ALTR_XTENSA_SLOT3_ALTR_XTENSA_SLOT4_ALTR_XTENSA_SLOT5_ALTR_XTENSA_SLOT6_ALTR_XTENSA_SLOT7_ALTR_XTENSA_SLOT8_ALTR_XTENSA_SLOT9_ALTR_XTENSA_SLOT10_ALTR_XTENSA_SLOT11_ALTR_XTENSA_SLOT12_ALTR_XTENSA_SLOT13_ALTR_XTENSA_SLOT14_ALTR_XTENSA_TLSDESC_FNR_XTENSA_TLSDESC_ARGR_XTENSA_TLS_DTPOFFR_XTENSA_TLS_TPOFFR_XTENSA_TLS_FUNCR_XTENSA_TLS_ARGR_XTENSA_TLS_CALLR_XTENSA_PDIFF8R_XTENSA_PDIFF16R_XTENSA_PDIFF32R_XTENSA_NDIFF8R_XTENSA_NDIFF16R_XTENSA_NDIFF32Tag_FileTag_SectionTag_Symbolunsafe_impl_endian_pod//! ELF definitions.//! This module is the equivalent of /usr/include/elf.h, and is based heavily on it.// Values for `Dyn*::d_tag`.// TODO: Elf*_auxv_t, AT_*// Note types for `ELF_NOTE_GNU`.// Values used in GNU .note.gnu.property notes (NT_GNU_PROPERTY_TYPE_0).// TODO: Elf*_Move// Motorola 68k specific definitions.// m68k values for `Rel*::r_type`.// Intel 80386 specific definitions.// i386 values for `Rel*::r_type`.// ADI SHARC specific definitions// SHARC values for `Rel*::r_type`// SHARC values for `SectionHeader*::sh_type`.// SUN SPARC specific definitions.// SPARC values for `st_type` component of `Sym*::st_info`.// SPARC values for `FileHeader64::e_flags`.// SPARC values for `Rel*::r_type`.// Sparc64 values for `Rel*::r_type`.// Sparc64 values for `Dyn32::d_tag`.// MIPS R3000 specific definitions.// MIPS values for `FileHeader32::e_flags`.// Legal values for MIPS architecture level.// MIPS values for `Sym32::st_shndx`.// MIPS values for `SectionHeader32::sh_type`.// MIPS values for `SectionHeader32::sh_flags`.// MIPS values for `Sym32::st_other`.// Entries found in sections of type `SHT_MIPS_GPTAB`.// TODO: Elf32_gptab, Elf32_RegInfo, Elf_Options// Values for `Elf_Options::kind`.// Values for `Elf_Options::info` for `ODK_EXCEPTIONS` entries.// Entries found in sections of type `SHT_MIPS_OPTIONS`.// TODO: Elf_Options_Hw// Masks for `ElfOptions::info` for `ODK_HWAND` and `ODK_HWOR` entries.// MIPS values for `Rel*::r_type`.// MIPS values for `ProgramHeader32::p_type`.// MIPS values for `ProgramHeader32::p_flags`.// MIPS values for `Dyn32::d_tag`.// Values for `DT_MIPS_FLAGS` `Dyn32` entry.// Entries found in sections of type `SHT_MIPS_LIBLIST`.// TODO: Elf32_Lib, Elf64_Lib// Values for `Lib*::l_flags`.// TODO: MIPS ABI flags// PA-RISC specific definitions.// PA-RISC values for `FileHeader32::e_flags`.// Values for `EF_PARISC_ARCH'.// PA-RISC values for `Sym*::st_shndx`.// PA-RISC values for `SectionHeader32::sh_type`.// PA-RISC values for `SectionHeader32::sh_flags`.// PA-RISC values for `st_type` component of `Sym32::st_info`.// PA-RISC values for `Rel*::r_type`.// PA-RISC values for `ProgramHeader*::p_type`.// PA-RISC values for `ProgramHeader*::p_flags`.// Alpha specific definitions.// Alpha values for `FileHeader64::e_flags`.// Alpha values for `SectionHeader64::sh_type`.// Alpha values for `SectionHeader64::sh_flags`.// Alpha values for `Rel64::r_type`.// PowerPC specific declarations.// ARM specific declarations.// AArch64 values for `Rel*::r_type`.// AVR values for `FileHeader*::e_flags`.// AVR values for `Rel*::r_type`.// MSP430 values for `Rel*::r_type`.// Hexagon values for `Rel*::r_type`.// ARM values for `Rel*::r_type`.// IA-64 specific declarations.// SH specific declarations.// S/390 specific definitions.// S/390 values `FileHeader*::e_flags`.// S/390 values `Rel*::r_type`.// Imagination Meta values `Rel*::r_type`.from_big_endian/// Construct a specification for the endianness of some values./// Returns `None` if the type does not support specifying the given endianness.from_little_endian/// Converts an unsigned 16 bit integer to native endian./// Converts an unsigned 32 bit integer to native endian./// Converts an unsigned 64 bit integer to native endian./// Converts a signed 16 bit integer to native endian./// Converts a signed 32 bit integer to native endian./// Converts a signed 64 bit integer to native endian.read_u16_bytes/// Converts an unaligned unsigned 16 bit integer to native endian.read_u32_bytes/// Converts an unaligned unsigned 32 bit integer to native endian.read_u64_bytes/// Converts an unaligned unsigned 64 bit integer to native endian.read_i16_bytes/// Converts an unaligned signed 16 bit integer to native endian.read_i32_bytes/// Converts an unaligned signed 32 bit integer to native endian.read_i64_bytes/// Converts an unaligned signed 64 bit integer to native endian./// Converts an unsigned 16 bit integer from native endian./// Converts an unsigned 32 bit integer from native endian./// Converts an unsigned 64 bit integer from native endian./// Converts a signed 16 bit integer from native endian./// Converts a signed 32 bit integer from native endian./// Converts a signed 64 bit integer from native endian.write_u16_bytes/// Converts an unaligned unsigned 16 bit integer from native endian.write_u32_bytes/// Converts an unaligned unsigned 32 bit integer from native endian.write_u64_bytes/// Converts an unaligned unsigned 64 bit integer from native endian.write_i16_bytes/// Converts an unaligned signed 16 bit integer from native endian.write_i32_bytes/// Converts an unaligned signed 32 bit integer from native endian.write_i64_bytes/// Converts an unaligned signed 64 bit integer from native endian./// A trait for using an endianness specification./// Provides methods for converting between the specified endianness and/// the native endianness of the target machine./// This trait does not require that the endianness is known at compile time./// An endianness that is selectable at run-time./// Compile-time little endian byte order./// Compile-time big endian byte order./// The native endianness for the target platform.U16Bytes/// A `u16` value with an externally specified endianness of type `E`./// A `u32` value with an externally specified endianness of type `E`./// A `u64` value with an externally specified endianness of type `E`.I16Bytes/// An `i16` value with an externally specified endianness of type `E`.I32Bytes/// An `i32` value with an externally specified endianness of type `E`.I64Bytes/// An `i64` value with an externally specified endianness of type `E`./// An unaligned `u16` value with an externally specified endianness of type `E`./// Construct a new value given bytes that already have the required endianness./// Construct a new value given a native endian value./// Return the value as a native endian value./// Set the value given a native endian value./// An unaligned `u32` value with an externally specified endianness of type `E`./// An unaligned `u64` value with an externally specified endianness of type `E`./// An unaligned `i16` value with an externally specified endianness of type `E`./// An unaligned `i32` value with an externally specified endianness of type `E`./// An unaligned `i64` value with an externally specified endianness of type `E`.//! Types for compile-time and run-time endianness.//! # `object`//! The `object` crate provides a unified interface to working with object files//! across platforms. It supports reading relocatable object files and executable files,//! and writing relocatable object files and some executable files.//! ## Raw struct definitions//! Raw structs are defined for: [ELF](elf), [Mach-O](macho), [PE/COFF](pe),//! [XCOFF](xcoff), [archive].//! Types and traits for zerocopy support are defined in the [`pod`] and [`endian`] modules.//! ## Unified read API//! The [`read`] module provides a unified read API using the [`read::Object`] trait.//! There is an implementation of this trait for [`read::File`], which allows reading any//! file format, as well as implementations for each file format.//! ## Low level read API//! The [`read#modules`] submodules define helpers that operate on the raw structs.//! These can be used instead of the unified API, or in conjunction with it to access//! details that are not available via the unified API.//! ## Unified write API//! The [`mod@write`] module provides a unified write API for relocatable object files//! using [`write::Object`]. This does not support writing executable files.//! ## Low level write API//! The [`mod@write#modules`] submodules define helpers for writing the raw structs.//! ## Build API//! The [`mod@build`] submodules define helpers for building object files, either from//! scratch or by modifying existing files.//! ## Shared definitions//! The crate provides a number of definitions that are used by both the read and write//! APIs. These are defined at the top level module, but none of these are the main entry//! points of the crate.// Occurs due to fallible iteration.// Unit errors are converted to other types by callers.CPU_ARCH_MASK/// mask for architecture bitsCPU_ARCH_ABI64/// 64 bit ABICPU_ARCH_ABI64_32/// ABI for 64-bit hardware with 32-bit types; LP32CPU_TYPE_ANYCPU_TYPE_VAXCPU_TYPE_MC680X0CPU_TYPE_X86CPU_TYPE_X86_64CPU_TYPE_MIPSCPU_TYPE_MC98000CPU_TYPE_HPPACPU_TYPE_ARMCPU_TYPE_ARM64CPU_TYPE_ARM64_32CPU_TYPE_MC88000CPU_TYPE_SPARCCPU_TYPE_I860CPU_TYPE_ALPHACPU_TYPE_POWERPCCPU_TYPE_POWERPC64CPU_SUBTYPE_MASK/*
 * Capability bits used in the definition of cpu_subtype.
 *//// mask for feature flagsCPU_SUBTYPE_LIB64/// 64 bit librariesCPU_SUBTYPE_PTRAUTH_ABI/// pointer authentication with versioned ABICPU_SUBTYPE_ANY/// When selecting a slice, ANY will pick the slice with the best/// grading for the selected cpu_type_t, unlike the "ALL" subtypes,/// which are the slices that can run on any hardware for that cpu type.CPU_SUBTYPE_MULTIPLE/*
 *	Object files that are hand-crafted to run on any
 *	implementation of an architecture are tagged with
 *	CPU_SUBTYPE_MULTIPLE.  This functions essentially the same as
 *	the "ALL" subtype of an architecture except that it allows us
 *	to easily find object files that may need to be modified
 *	whenever a new implementation of an architecture comes out.
 *
 *	It is the responsibility of the implementor to make sure the
 *	software handles unsupported implementations elegantly.
 */CPU_SUBTYPE_LITTLE_ENDIANCPU_SUBTYPE_BIG_ENDIANCPU_SUBTYPE_VAX_ALLCPU_SUBTYPE_VAX780CPU_SUBTYPE_VAX785CPU_SUBTYPE_VAX750CPU_SUBTYPE_VAX730CPU_SUBTYPE_UVAXICPU_SUBTYPE_UVAXIICPU_SUBTYPE_VAX8200CPU_SUBTYPE_VAX8500CPU_SUBTYPE_VAX8600CPU_SUBTYPE_VAX8650CPU_SUBTYPE_VAX8800CPU_SUBTYPE_UVAXIIICPU_SUBTYPE_MC680X0_ALLCPU_SUBTYPE_MC68030// compatCPU_SUBTYPE_MC68040CPU_SUBTYPE_MC68030_ONLYcpu_subtype_intelCPU_SUBTYPE_I386_ALLCPU_SUBTYPE_386CPU_SUBTYPE_486CPU_SUBTYPE_486SXCPU_SUBTYPE_586CPU_SUBTYPE_PENTCPU_SUBTYPE_PENTPROCPU_SUBTYPE_PENTII_M3CPU_SUBTYPE_PENTII_M5CPU_SUBTYPE_CELERONCPU_SUBTYPE_CELERON_MOBILECPU_SUBTYPE_PENTIUM_3CPU_SUBTYPE_PENTIUM_3_MCPU_SUBTYPE_PENTIUM_3_XEONCPU_SUBTYPE_PENTIUM_MCPU_SUBTYPE_PENTIUM_4CPU_SUBTYPE_PENTIUM_4_MCPU_SUBTYPE_ITANIUMCPU_SUBTYPE_ITANIUM_2CPU_SUBTYPE_XEONCPU_SUBTYPE_XEON_MPcpu_subtype_intel_familyCPU_SUBTYPE_INTEL_FAMILY_MAXcpu_subtype_intel_modelCPU_SUBTYPE_INTEL_MODEL_ALLCPU_SUBTYPE_X86_ALLCPU_SUBTYPE_X86_64_ALLCPU_SUBTYPE_X86_ARCH1CPU_SUBTYPE_X86_64_H/// Haswell feature subsetCPU_SUBTYPE_MIPS_ALLCPU_SUBTYPE_MIPS_R2300CPU_SUBTYPE_MIPS_R2600CPU_SUBTYPE_MIPS_R2800CPU_SUBTYPE_MIPS_R2000A/// pmaxCPU_SUBTYPE_MIPS_R2000CPU_SUBTYPE_MIPS_R3000A/// 3maxCPU_SUBTYPE_MIPS_R3000CPU_SUBTYPE_MC98000_ALL/*
 *	MC98000 (PowerPC) subtypes
 */CPU_SUBTYPE_MC98601CPU_SUBTYPE_HPPA_ALLCPU_SUBTYPE_HPPA_7100LCCPU_SUBTYPE_MC88000_ALL/*
 *	MC88000 subtypes.
 */CPU_SUBTYPE_MC88100CPU_SUBTYPE_MC88110CPU_SUBTYPE_SPARC_ALL/*
 *	SPARC subtypes
 */CPU_SUBTYPE_I860_ALL/*
 *	I860 subtypes
 */CPU_SUBTYPE_I860_860CPU_SUBTYPE_POWERPC_ALL/*
 *	PowerPC subtypes
 */CPU_SUBTYPE_POWERPC_601CPU_SUBTYPE_POWERPC_602CPU_SUBTYPE_POWERPC_603CPU_SUBTYPE_POWERPC_603ECPU_SUBTYPE_POWERPC_603EVCPU_SUBTYPE_POWERPC_604CPU_SUBTYPE_POWERPC_604ECPU_SUBTYPE_POWERPC_620CPU_SUBTYPE_POWERPC_750CPU_SUBTYPE_POWERPC_7400CPU_SUBTYPE_POWERPC_7450CPU_SUBTYPE_POWERPC_970CPU_SUBTYPE_ARM_ALL/*
 *	ARM subtypes
 */CPU_SUBTYPE_ARM_V4TCPU_SUBTYPE_ARM_V6CPU_SUBTYPE_ARM_V5TEJCPU_SUBTYPE_ARM_XSCALECPU_SUBTYPE_ARM_V7/// ARMv7-A and ARMv7-RCPU_SUBTYPE_ARM_V7F/// Cortex A9CPU_SUBTYPE_ARM_V7S/// SwiftCPU_SUBTYPE_ARM_V7KCPU_SUBTYPE_ARM_V8CPU_SUBTYPE_ARM_V6M/// Not meant to be run under xnuCPU_SUBTYPE_ARM_V7MCPU_SUBTYPE_ARM_V7EMCPU_SUBTYPE_ARM_V8MCPU_SUBTYPE_ARM64_ALL/*
 *  ARM64 subtypes
 */CPU_SUBTYPE_ARM64_V8CPU_SUBTYPE_ARM64ECPU_SUBTYPE_ARM64_32_ALL/*
 *  ARM64_32 subtypes
 */CPU_SUBTYPE_ARM64_32_V8/// read permission/// write permission/// execute permission/// e.g. "dyld_v0    i386"mapping_offset/// file offset to first dyld_cache_mapping_infomapping_count// offset: 0x10/// number of dyld_cache_mapping_info entriesimages_offset// offset: 0x14/// file offset to first dyld_cache_image_infoimages_count// offset: 0x18/// number of dyld_cache_image_info entriesdyld_base_address// offset: 0x1c/// base address of dyld when cache was built// offset: 0x20local_symbols_offset// offset: 0x28/// file offset of where local symbols are storedlocal_symbols_size// offset: 0x48/// size of local symbols information// offset: 0x50/// unique value for each shared cache file// offset: 0x58// offset: 0x68// offset: 0x88// offset: 0xa8// offset: 0xc8// offset: 0xe8// offset: 0x108reserved9// offset: 0x128reserved10// offset: 0x148subcaches_offset// offset: 0x168/// file offset to first dyld_subcache_infosubcaches_count// offset: 0x188/// number of dyld_subcache_info entriessymbols_subcache_uuid// offset: 0x18c/// the UUID of the .symbols subcachereserved11// offset: 0x190images_across_all_subcaches_offset// offset: 0x1a0/// Use this  instead of images_offset if mapping_offset is at least 0x1c4.images_across_all_subcaches_count// offset: 0x1c0/// Use this  instead of images_count if mapping_offset is at least 0x1c4.// offset: 0x1c4DyldCacheHeader/// The dyld cache header./// Corresponds to struct dyld_cache_header from dyld_cache_format.h./// This header has grown over time. Only the fields up to and including dyld_base_address/// are guaranteed to be present. For all other fields, check the header size before/// accessing the field. The header size is stored in mapping_offset; the mappings start/// right after the theader.file_offsetmax_protinit_protDyldCacheMappingInfo/// Corresponds to struct dyld_cache_mapping_info from dyld_cache_format.h.mod_timepath_file_offsetDyldCacheImageInfo/// Corresponds to struct dyld_cache_image_info from dyld_cache_format.h./// The UUID of this subcache.cache_vm_offset/// The offset of this subcache from the main cache base address.DyldSubCacheEntryV1/// Added in dyld-940, which shipped with macOS 12 / iOS 15./// Originally called `dyld_subcache_entry`, renamed to `dyld_subcache_entry_v1`/// in dyld-1042.1.file_suffix/// The file name suffix of the subCache file, e.g. ".25.data" or ".03.development".DyldSubCacheEntryV2/// Added in dyld-1042.1, which shipped with macOS 13 / iOS 16./// Called `dyld_subcache_entry` as of dyld-1042.1.FAT_MAGICFAT_CIGAM/// NXSwapLong(FAT_MAGIC)/// FAT_MAGIC or FAT_MAGIC_64nfat_arch/// number of structs that followFatHeadercputype/// cpu specifier (int)cpusubtype/// machine specifier (int)/// file offset to this object file/// size of this object file/// alignment as a power of 2FatArch32FAT_MAGIC_64/*
 * The support for the 64-bit fat file format described here is a work in
 * progress and not yet fully supported in all the Apple Developer Tools.
 *
 * When a slice is greater than 4mb or an offset to a slice is greater than 4mb
 * then the 64-bit fat file format is used.
 */FAT_CIGAM_64/// NXSwapLong(FAT_MAGIC_64)/// reservedFatArch64/// mach magic number identifier/// cpu specifier/// machine specifierfiletype/// type of filencmds/// number of load commandssizeofcmds/// the size of all the load commands/// flags/// The 32-bit mach header./// Appears at the very beginning of the object file for 32-bit architectures.// Values for `MachHeader32::magic`./// the mach magic numberMH_CIGAM/// NXSwapInt(MH_MAGIC)/// The 64-bit mach header./// Appears at the very beginning of object files for 64-bit architectures.// Values for `MachHeader64::magic`./// the 64-bit mach magic numberMH_CIGAM_64/// NXSwapInt(MH_MAGIC_64)MH_OBJECT// Values for `MachHeader*::filetype`./// relocatable object fileMH_EXECUTE/// demand paged executable fileMH_FVMLIB/// fixed VM shared library fileMH_CORE/// core fileMH_PRELOAD/// preloaded executable fileMH_DYLIB/// dynamically bound shared libraryMH_DYLINKER/// dynamic link editorMH_BUNDLE/// dynamically bound bundle fileMH_DYLIB_STUB/// shared library stub for static linking only, no section contentsMH_DSYM/// companion file with only debug sectionsMH_KEXT_BUNDLE/// x86_64 kextsMH_FILESET/// set of mach-o'sMH_NOUNDEFS// Values for `MachHeader*::flags`./// the object file has no undefined referencesMH_INCRLINK/// the object file is the output of an incremental link against a base file and can't be link edited againMH_DYLDLINK/// the object file is input for the dynamic linker and can't be statically link edited againMH_BINDATLOAD/// the object file's undefined references are bound by the dynamic linker when loaded.MH_PREBOUND/// the file has its dynamic undefined references prebound.MH_SPLIT_SEGS/// the file has its read-only and read-write segments splitMH_LAZY_INIT/// the shared library init routine is to be run lazily via catching memory faults to its writeable segments (obsolete)MH_TWOLEVEL/// the image is using two-level name space bindingsMH_FORCE_FLAT/// the executable is forcing all images to use flat name space bindingsMH_NOMULTIDEFS/// this umbrella guarantees no multiple definitions of symbols in its sub-images so the two-level namespace hints can always be used.MH_NOFIXPREBINDING/// do not have dyld notify the prebinding agent about this executableMH_PREBINDABLE/// the binary is not prebound but can have its prebinding redone. only used when MH_PREBOUND is not set.MH_ALLMODSBOUND/// indicates that this binary binds to all two-level namespace modules of its dependent libraries. only used when MH_PREBINDABLE and MH_TWOLEVEL are both set.MH_SUBSECTIONS_VIA_SYMBOLS/// safe to divide up the sections into sub-sections via symbols for dead code strippingMH_CANONICAL/// the binary has been canonicalized via the unprebind operationMH_WEAK_DEFINES/// the final linked image contains external weak symbolsMH_BINDS_TO_WEAK/// the final linked image uses weak symbolsMH_ALLOW_STACK_EXECUTION/// When this bit is set, all stacks in the task will be given stack execution privilege.  Only used in MH_EXECUTE filetypes.MH_ROOT_SAFE/// When this bit is set, the binary declares it is safe for use in processes with uid zeroMH_SETUID_SAFE/// When this bit is set, the binary declares it is safe for use in processes when issetugid() is trueMH_NO_REEXPORTED_DYLIBS/// When this bit is set on a dylib, the static linker does not need to examine dependent dylibs to see if any are re-exportedMH_PIE/// When this bit is set, the OS will load the main executable at a random address.  Only used in MH_EXECUTE filetypes.MH_DEAD_STRIPPABLE_DYLIB/// Only for use on dylibs.  When linking against a dylib that has this bit set, the static linker will automatically not create a LC_LOAD_DYLIB load command to the dylib if no symbols are being referenced from the dylib.MH_HAS_TLV_DESCRIPTORS/// Contains a section of type S_THREAD_LOCAL_VARIABLESMH_NO_HEAP_EXECUTION/// When this bit is set, the OS will run the main executable with a non-executable heap even on platforms (e.g. i386) that don't require it. Only used in MH_EXECUTE filetypes.MH_APP_EXTENSION_SAFE/// The code was linked for use in an application extension.MH_NLIST_OUTOFSYNC_WITH_DYLDINFO/// The external symbols listed in the nlist symbol table do not include all the symbols listed in the dyld info.MH_SIM_SUPPORT/// Allow LC_MIN_VERSION_MACOS and LC_BUILD_VERSION load commands with/// the platforms macOS, iOSMac, iOSSimulator, tvOSSimulator and watchOSSimulator.MH_DYLIB_IN_CACHE/// Only for use on dylibs. When this bit is set, the dylib is part of the dyld/// shared cache, rather than loose in the filesystem./// Type of load command./// One of the `LC_*` constants.cmdsize/// Total size of command in bytes.LoadCommand/// Common fields at the start of every load command./// The load commands directly follow the mach_header.  The total size of all/// of the commands is given by the sizeofcmds field in the mach_header.  All/// load commands must have as their first two fields `cmd` and `cmdsize`.  The `cmd`/// field is filled in with a constant for that command type.  Each command type/// has a structure specifically for it.  The `cmdsize` field is the size in bytes/// of the particular load command structure plus anything that follows it that/// is a part of the load command (i.e. section structures, strings, etc.).  To/// advance to the next load command the `cmdsize` can be added to the offset or/// pointer of the current load command.  The `cmdsize` for 32-bit architectures/// MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple/// of 8 bytes (these are forever the maximum alignment of any load commands)./// The padded bytes must be zero.  All tables in the object file must also/// follow these rules so the file can be memory mapped.  Otherwise the pointers/// to these tables will not work well or at all on some machines.  With all/// padding zeroed like objects will compare byte for byte.LC_REQ_DYLD/*
 * After MacOS X 10.1 when a new load command is added that is required to be
 * understood by the dynamic linker for the image to execute properly the
 * LC_REQ_DYLD bit will be or'ed into the load command constant.  If the dynamic
 * linker sees such a load command it it does not understand will issue a
 * "unknown load command required for execution" error and refuse to use the
 * image.  Other load commands without this bit that are not understood will
 * simply be ignored.
 *//* Constants for the cmd field of all load commands, the type *//// segment of this file to be mappedLC_SYMTAB/// link-edit stab symbol table infoLC_SYMSEG/// link-edit gdb symbol table info (obsolete)LC_THREAD/// threadLC_UNIXTHREAD/// unix thread (includes a stack)LC_LOADFVMLIB/// load a specified fixed VM shared libraryLC_IDFVMLIB/// fixed VM shared library identificationLC_IDENT/// object identification info (obsolete)LC_FVMFILE/// fixed VM file inclusion (internal use)LC_PREPAGE/// prepage command (internal use)LC_DYSYMTAB/// dynamic link-edit symbol table infoLC_LOAD_DYLIB/// load a dynamically linked shared libraryLC_ID_DYLIB/// dynamically linked shared lib identLC_LOAD_DYLINKER/// load a dynamic linkerLC_ID_DYLINKER/// dynamic linker identificationLC_PREBOUND_DYLIB/// modules prebound for a dynamically linked shared libraryLC_ROUTINES/// image routinesLC_SUB_FRAMEWORK/// sub frameworkLC_SUB_UMBRELLA/// sub umbrellaLC_SUB_CLIENT/// sub clientLC_SUB_LIBRARY/// sub libraryLC_TWOLEVEL_HINTS/// two-level namespace lookup hintsLC_PREBIND_CKSUM/// prebind checksumLC_LOAD_WEAK_DYLIB/// load a dynamically linked shared library that is allowed to be missing/// (all symbols are weak imported)./// 64-bit segment of this file to be mappedLC_ROUTINES_64/// 64-bit image routinesLC_UUID/// the uuidLC_RPATH/// runpath additionsLC_CODE_SIGNATURE/// local of code signatureLC_SEGMENT_SPLIT_INFO/// local of info to split segmentsLC_REEXPORT_DYLIB/// load and re-export dylibLC_LAZY_LOAD_DYLIB/// delay load of dylib until first useLC_ENCRYPTION_INFO/// encrypted segment informationLC_DYLD_INFO/// compressed dyld informationLC_DYLD_INFO_ONLY/// compressed dyld information onlyLC_LOAD_UPWARD_DYLIB/// load upward dylibLC_VERSION_MIN_MACOSX/// build for MacOSX min OS versionLC_VERSION_MIN_IPHONEOS/// build for iPhoneOS min OS versionLC_FUNCTION_STARTS/// compressed table of function start addressesLC_DYLD_ENVIRONMENT/// string for dyld to treat like environment variableLC_MAIN/// replacement for LC_UNIXTHREADLC_DATA_IN_CODE/// table of non-instructions in __textLC_SOURCE_VERSION/// source version used to build binaryLC_DYLIB_CODE_SIGN_DRS/// Code signing DRs copied from linked dylibsLC_ENCRYPTION_INFO_64/// 64-bit encrypted segment informationLC_LINKER_OPTION/// linker options in MH_OBJECT filesLC_LINKER_OPTIMIZATION_HINT/// optimization hints in MH_OBJECT filesLC_VERSION_MIN_TVOS/// build for AppleTV min OS versionLC_VERSION_MIN_WATCHOS/// build for Watch min OS versionLC_NOTE/// arbitrary data included within a Mach-O fileLC_BUILD_VERSION/// build for platform min OS versionLC_DYLD_EXPORTS_TRIE/// used with `LinkeditDataCommand`, payload is trieLC_DYLD_CHAINED_FIXUPS/// used with `LinkeditDataCommand`LC_FILESET_ENTRY/// used with `FilesetEntryCommand`/// offset to the stringLcStr/// A variable length string in a load command./// The strings are stored just after the load command structure and/// the offset is from the start of the load command structure.  The size/// of the string is reflected in the `cmdsize` field of the load command./// Once again any padded bytes to bring the `cmdsize` field to a multiple/// of 4 bytes must be zero./// LC_SEGMENT/// includes sizeof section structs/// segment namevmaddr/// memory address of this segmentvmsize/// memory size of this segmentfileoff/// file offset of this segmentfilesize/// amount to map from the file/// maximum VM protection/// initial VM protectionnsects/// number of sections in segmentSegmentCommand32/// 32-bit segment load command./// The segment load command indicates that a part of this file is to be/// mapped into the task's address space.  The size of this segment in memory,/// vmsize, maybe equal to or larger than the amount to map from this file,/// filesize.  The file is mapped starting at fileoff to the beginning of/// the segment in memory, vmaddr.  The rest of the memory of the segment,/// if any, is allocated zero fill on demand.  The segment's maximum virtual/// memory protection and initial virtual memory protection are specified/// by the maxprot and initprot fields.  If the segment has sections then the/// `Section32` structures directly follow the segment command and their size is/// reflected in `cmdsize`./// LC_SEGMENT_64/// includes sizeof section_64 structsSegmentCommand64/// 64-bit segment load command./// The 64-bit segment load command indicates that a part of this file is to be/// mapped into a 64-bit task's address space.  If the 64-bit segment has/// sections then `Section64` structures directly follow the 64-bit segment/// command and their size is reflected in `cmdsize`.SG_HIGHVM// Values for `SegmentCommand*::flags`./// the file contents for this segment is for the high part of the VM space, the low part is zero filled (for stacks in core files)SG_FVMLIB/// this segment is the VM that is allocated by a fixed VM library, for overlap checking in the link editorSG_NORELOC/// this segment has nothing that was relocated in it and nothing relocated to it, that is it maybe safely replaced without relocationSG_PROTECTED_VERSION_1/// This segment is protected.  If the segment starts at file offset 0, the first page of the segment is not protected.  All other pages of the segment are protected.SG_READ_ONLY/// This segment is made read-only after fixupssectname/// name of this section/// segment this section goes in/// memory address of this section/// size in bytes of this section/// file offset of this section/// section alignment (power of 2)reloff/// file offset of relocation entriesnreloc/// number of relocation entries/// flags (section type and attributes)/// reserved (for offset or index)/// reserved (for count or sizeof)Section32/*
 * A segment is made up of zero or more sections.  Non-MH_OBJECT files have
 * all of their segments with the proper sections in each, and padded to the
 * specified segment alignment when produced by the link editor.  The first
 * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header
 * and load commands of the object file before its first section.  The zero
 * fill sections are always last in their segment (in all formats).  This
 * allows the zeroed segment padding to be mapped into memory where zero fill
 * sections might be. The gigabyte zero fill sections, those with the section
 * type S_GB_ZEROFILL, can only be in a segment with sections of this type.
 * These segments are then placed after all other segments.
 *
 * The MH_OBJECT format has all of its sections in one segment for
 * compactness.  There is no padding to a specified segment boundary and the
 * mach_header and load commands are not part of the segment.
 *
 * Sections with the same section name, sectname, going into the same segment,
 * segname, are combined by the link editor.  The resulting section is aligned
 * to the maximum alignment of the combined sections and is the new section's
 * alignment.  The combined sections are aligned to their original alignment in
 * the combined section.  Any padded bytes to get the specified alignment are
 * zeroed.
 *
 * The format of the relocation entries referenced by the reloff and nreloc
 * fields of the section structure for mach object files is described in the
 * header file <reloc.h>.
 *//// 32-bit section.Section64/// 64-bit section.SECTION_TYPE/*
 * The flags field of a section structure is separated into two parts a section
 * type and section attributes.  The section types are mutually exclusive (it
 * can only have one type) but the section attributes are not (it may have more
 * than one attribute).
 *//// 256 section typesSECTION_ATTRIBUTES/// 24 section attributesS_REGULAR/* Constants for the type of a section *//// regular sectionS_ZEROFILL/// zero fill on demand sectionS_CSTRING_LITERALS/// section with only literal C stringsS_4BYTE_LITERALS/// section with only 4 byte literalsS_8BYTE_LITERALS/// section with only 8 byte literalsS_LITERAL_POINTERS/// section with only pointers to literalsS_NON_LAZY_SYMBOL_POINTERS/*
 * For the two types of symbol pointers sections and the symbol stubs section
 * they have indirect symbol table entries.  For each of the entries in the
 * section the indirect symbol table entries, in corresponding order in the
 * indirect symbol table, start at the index stored in the reserved1 field
 * of the section structure.  Since the indirect symbol table entries
 * correspond to the entries in the section the number of indirect symbol table
 * entries is inferred from the size of the section divided by the size of the
 * entries in the section.  For symbol pointers sections the size of the entries
 * in the section is 4 bytes and for symbol stubs sections the byte size of the
 * stubs is stored in the reserved2 field of the section structure.
 *//// section with only non-lazy symbol pointersS_LAZY_SYMBOL_POINTERS/// section with only lazy symbol pointersS_SYMBOL_STUBS/// section with only symbol stubs, byte size of stub in the reserved2 fieldS_MOD_INIT_FUNC_POINTERS/// section with only function pointers for initializationS_MOD_TERM_FUNC_POINTERS/// section with only function pointers for terminationS_COALESCED/// section contains symbols that are to be coalescedS_GB_ZEROFILL/// zero fill on demand section (that can be larger than 4 gigabytes)S_INTERPOSING/// section with only pairs of function pointers for interposingS_16BYTE_LITERALS/// section with only 16 byte literalsS_DTRACE_DOF/// section contains DTrace Object FormatS_LAZY_DYLIB_SYMBOL_POINTERS/// section with only lazy symbol pointers to lazy loaded dylibsS_THREAD_LOCAL_REGULAR/*
 * Section types to support thread local variables
 *//// template of initial values for TLVsS_THREAD_LOCAL_ZEROFILLS_THREAD_LOCAL_VARIABLES/// TLV descriptorsS_THREAD_LOCAL_VARIABLE_POINTERS/// pointers to TLV descriptorsS_THREAD_LOCAL_INIT_FUNCTION_POINTERS/// functions to call to initialize TLV valuesS_INIT_FUNC_OFFSETS/// 32-bit offsets to initializersSECTION_ATTRIBUTES_USR/*
 * Constants for the section attributes part of the flags field of a section
 * structure.
 *//// User setable attributesS_ATTR_PURE_INSTRUCTIONS/// section contains only true machine instructionsS_ATTR_NO_TOC/// section contains coalesced symbols that are not to be in a ranlib table of contentsS_ATTR_STRIP_STATIC_SYMS/// ok to strip static symbols in this section in files with the MH_DYLDLINK flagS_ATTR_NO_DEAD_STRIP/// no dead strippingS_ATTR_LIVE_SUPPORT/// blocks are live if they reference live blocksS_ATTR_SELF_MODIFYING_CODE/// Used with i386 code stubs written on by dyldS_ATTR_DEBUG/*
 * If a segment contains any sections marked with S_ATTR_DEBUG then all
 * sections in that segment must have this attribute.  No section other than
 * a section marked with this attribute may reference the contents of this
 * section.  A section with this attribute may contain no symbols and must have
 * a section type S_REGULAR.  The static linker will not copy section contents
 * from sections with this attribute into its output file.  These sections
 * generally contain DWARF debugging info.
 *//// a debug sectionSECTION_ATTRIBUTES_SYS/// system setable attributesS_ATTR_SOME_INSTRUCTIONS/// section contains some machine instructionsS_ATTR_EXT_RELOC/// section has external relocation entriesS_ATTR_LOC_RELOC/// section has local relocation entriesSEG_PAGEZERO/// the pagezero segment which has no protections and catches NULL references for MH_EXECUTE filesSEG_TEXT/// the tradition UNIX text segmentSECT_TEXT/// the real text part of the text section no headers, and no paddingSECT_FVMLIB_INIT0/// the fvmlib initialization sectionSECT_FVMLIB_INIT1/// the section following the fvmlib initialization sectionSEG_DATA/// the tradition UNIX data segmentSECT_DATA/// the real initialized data section no padding, no bss overlapSECT_BSS/// the real uninitialized data section no paddingSECT_COMMON/// the section common symbols are allocated in by the link editorSEG_OBJC/// objective-C runtime segmentSECT_OBJC_SYMBOLS/// symbol tableSECT_OBJC_MODULES/// module informationSECT_OBJC_STRINGS/// string tableSECT_OBJC_REFSSEG_ICON/// the icon segmentSECT_ICON_HEADER/// the icon headersSECT_ICON_TIFF/// the icons in tiff formatSEG_LINKEDIT/// the segment containing all structs created and maintained by the link editor.  Created with -seglinkedit option to ld(1) for MH_EXECUTE and FVMLIB file types onlySEG_LINKINFO/// the segment overlapping with linkedit containing linking informationSEG_UNIXSTACK/// the unix stack segmentSEG_IMPORT/// the segment for the self (dyld) modifying code stubs that has read, write and execute permissions/// library's target pathname/// library's minor version numberheader_addr/// library's header addressFvmlib/*
 * Fixed virtual memory shared libraries are identified by two things.  The
 * target pathname (the name of the library as found for execution), and the
 * minor version number.  The address of where the headers are loaded is in
 * header_addr. (THIS IS OBSOLETE and no longer supported).
 *//// LC_IDFVMLIB or LC_LOADFVMLIB/// includes pathname stringfvmlib/// the library identificationFvmlibCommand/*
 * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)
 * contains a `FvmlibCommand` (cmd == LC_IDFVMLIB) to identify the library.
 * An object that uses a fixed virtual shared library also contains a
 * `FvmlibCommand` (cmd == LC_LOADFVMLIB) for each library it uses.
 * (THIS IS OBSOLETE and no longer supported).
 *//// library's path name/// library's build time stampcurrent_version/// library's current version numbercompatibility_version/// library's compatibility vers numberDylib/*
 * Dynamically linked shared libraries are identified by two things.  The
 * pathname (the name of the library as found for execution), and the
 * compatibility version number.  The pathname must match and the compatibility
 * number in the user of the library must be greater than or equal to the
 * library being used.  The time stamp is used to record the time a library was
 * built and copied into user so it can be use to determined if the library used
 * at runtime is exactly the same as used to built the program.
 *//// LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, LC_REEXPORT_DYLIBdylibDylibCommand/*
 * A dynamically linked shared library (filetype == MH_DYLIB in the mach header)
 * contains a `DylibCommand` (cmd == LC_ID_DYLIB) to identify the library.
 * An object that uses a dynamically linked shared library also contains a
 * `DylibCommand` (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
 * LC_REEXPORT_DYLIB) for each library it uses.
 *//// LC_SUB_FRAMEWORK/// includes umbrella stringumbrella/// the umbrella framework nameSubFrameworkCommand/*
 * A dynamically linked shared library may be a subframework of an umbrella
 * framework.  If so it will be linked with "-umbrella umbrella_name" where
 * Where "umbrella_name" is the name of the umbrella framework. A subframework
 * can only be linked against by its umbrella framework or other subframeworks
 * that are part of the same umbrella framework.  Otherwise the static link
 * editor produces an error and states to link against the umbrella framework.
 * The name of the umbrella framework for subframeworks is recorded in the
 * following structure.
 *//// LC_SUB_CLIENT/// includes client string/// the client nameSubClientCommand/*
 * For dynamically linked shared libraries that are subframework of an umbrella
 * framework they can allow clients other than the umbrella framework or other
 * subframeworks in the same umbrella framework.  To do this the subframework
 * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load
 * command is created for each -allowable_client flag.  The client_name is
 * usually a framework name.  It can also be a name used for bundles clients
 * where the bundle is built with "-client_name client_name".
 *//// LC_SUB_UMBRELLA/// includes sub_umbrella stringsub_umbrella/// the sub_umbrella framework nameSubUmbrellaCommand/*
 * A dynamically linked shared library may be a sub_umbrella of an umbrella
 * framework.  If so it will be linked with "-sub_umbrella umbrella_name" where
 * Where "umbrella_name" is the name of the sub_umbrella framework.  When
 * statically linking when -twolevel_namespace is in effect a twolevel namespace
 * umbrella framework will only cause its subframeworks and those frameworks
 * listed as sub_umbrella frameworks to be implicited linked in.  Any other
 * dependent dynamic libraries will not be linked it when -twolevel_namespace
 * is in effect.  The primary library recorded by the static linker when
 * resolving a symbol in these libraries will be the umbrella framework.
 * Zero or more sub_umbrella frameworks may be use by an umbrella framework.
 * The name of a sub_umbrella framework is recorded in the following structure.
 *//// LC_SUB_LIBRARY/// includes sub_library stringsub_library/// the sub_library nameSubLibraryCommand/*
 * A dynamically linked shared library may be a sub_library of another shared
 * library.  If so it will be linked with "-sub_library library_name" where
 * Where "library_name" is the name of the sub_library shared library.  When
 * statically linking when -twolevel_namespace is in effect a twolevel namespace
 * shared library will only cause its subframeworks and those frameworks
 * listed as sub_umbrella frameworks and libraries listed as sub_libraries to
 * be implicited linked in.  Any other dependent dynamic libraries will not be
 * linked it when -twolevel_namespace is in effect.  The primary library
 * recorded by the static linker when resolving a symbol in these libraries
 * will be the umbrella framework (or dynamic library). Zero or more sub_library
 * shared libraries may be use by an umbrella framework or (or dynamic library).
 * The name of a sub_library framework is recorded in the following structure.
 * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".
 *//// LC_PREBOUND_DYLIB/// includes stringsnmodules/// number of modules in librarylinked_modules/// bit vector of linked modulesPreboundDylibCommand/*
 * A program (filetype == MH_EXECUTE) that is
 * prebound to its dynamic libraries has one of these for each library that
 * the static linker used in prebinding.  It contains a bit vector for the
 * modules in the library.  The bits indicate which modules are bound (1) and
 * which are not (0) from the library.  The bit for module 0 is the low bit
 * of the first byte.  So the bit for the Nth module is:
 * (linked_modules[N/8] >> N%8) & 1
 *//// LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT/// dynamic linker's path nameDylinkerCommand/*
 * A program that uses a dynamic linker contains a `DylinkerCommand` to identify
 * the name of the dynamic linker (LC_LOAD_DYLINKER).  And a dynamic linker
 * contains a `DylinkerCommand` to identify the dynamic linker (LC_ID_DYLINKER).
 * A file can have at most one of these.
 * This struct is also used for the LC_DYLD_ENVIRONMENT load command and
 * contains string for dyld to treat like environment variable.
 *//// LC_THREAD or  LC_UNIXTHREAD/// total size of this command/* uint32_t flavor		   flavor of thread state *//* uint32_t count		   count of uint32_t's in thread state *//* struct XXX_thread_state state   thread state for this flavor *//* ... */ThreadCommand/*
 * Thread commands contain machine-specific data structures suitable for
 * use in the thread state primitives.  The machine specific data structures
 * follow the struct `ThreadCommand` as follows.
 * Each flavor of machine specific data structure is preceded by an uint32_t
 * constant for the flavor of that data structure, an uint32_t that is the
 * count of uint32_t's of the size of the state data structure and then
 * the state data structure follows.  This triple may be repeated for many
 * flavors.  The constants for the flavors, counts and state data structure
 * definitions are expected to be in the header file <machine/thread_status.h>.
 * These machine specific data structures sizes must be multiples of
 * 4 bytes.  The `cmdsize` reflects the total size of the `ThreadCommand`
 * and all of the sizes of the constants for the flavors, counts and state
 * data structures.
 *
 * For executable objects that are unix processes there will be one
 * `ThreadCommand` (cmd == LC_UNIXTHREAD) created for it by the link-editor.
 * This is the same as a LC_THREAD, except that a stack is automatically
 * created (based on the shell's limit for the stack size).  Command arguments
 * and environment variables are copied onto that stack.
 *//* for 32-bit architectures *//// LC_ROUTINESinit_address/// address of initialization routine/// index into the module table that the init routine is defined inRoutinesCommand32/*
 * The routines command contains the address of the dynamic shared library
 * initialization routine and an index into the module table for the module
 * that defines the routine.  Before any modules are used from the library the
 * dynamic linker fully binds the module that defines the initialization routine
 * and then calls it.  This gets called before any module initialization
 * routines (used for C++ static constructors) in the library.
 *//* for 64-bit architectures *//// LC_ROUTINES_64RoutinesCommand64/*
 * The 64-bit routines command.  Same use as above.
 *//// LC_SYMTAB/// sizeof(struct SymtabCommand)symoff/// symbol table offsetnsyms/// number of symbol table entriesstroff/// string table offsetstrsize/// string table size in bytesSymtabCommand/*
 * The `SymtabCommand` contains the offsets and sizes of the link-edit 4.3BSD
 * "stab" style symbol table information as described in the header files
 * <nlist.h> and <stab.h>.
 *//// LC_DYSYMTAB/// sizeof(struct DysymtabCommand)ilocalsym/*
     * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
     * are grouped into the following three groups:
     *    local symbols (further grouped by the module they are from)
     *    defined external symbols (further grouped by the module they are from)
     *    undefined symbols
     *
     * The local symbols are used only for debugging.  The dynamic binding
     * process may have to use them to indicate to the debugger the local
     * symbols for a module that is being bound.
     *
     * The last two groups are used by the dynamic binding process to do the
     * binding (indirectly through the module table and the reference symbol
     * table when this is a dynamically linked shared library file).
     *//// index to local symbolsnlocalsym/// number of local symbolsiextdefsym/// index to externally defined symbolsnextdefsym/// number of externally defined symbolsiundefsym/// index to undefined symbolsnundefsym/// number of undefined symbolstocoff/*
     * For the for the dynamic binding process to find which module a symbol
     * is defined in the table of contents is used (analogous to the ranlib
     * structure in an archive) which maps defined external symbols to modules
     * they are defined in.  This exists only in a dynamically linked shared
     * library file.  For executable and object modules the defined external
     * symbols are sorted by name and is use as the table of contents.
     *//// file offset to table of contents/// number of entries in table of contentsmodtaboff/*
     * To support dynamic binding of "modules" (whole object files) the symbol
     * table must reflect the modules that the file was created from.  This is
     * done by having a module table that has indexes and counts into the merged
     * tables for each module.  The module structure that these two entries
     * refer to is described below.  This exists only in a dynamically linked
     * shared library file.  For executable and object modules the file only
     * contains one module so everything in the file belongs to the module.
     *//// file offset to module tablenmodtab/// number of module table entriesextrefsymoff/*
     * To support dynamic module binding the module structure for each module
     * indicates the external references (defined and undefined) each module
     * makes.  For each module there is an offset and a count into the
     * reference symbol table for the symbols that the module references.
     * This exists only in a dynamically linked shared library file.  For
     * executable and object modules the defined external symbols and the
     * undefined external symbols indicates the external references.
     *//// offset to referenced symbol tablenextrefsyms/// number of referenced symbol table entriesindirectsymoff/*
     * The sections that contain "symbol pointers" and "routine stubs" have
     * indexes and (implied counts based on the size of the section and fixed
     * size of the entry) into the "indirect symbol" table for each pointer
     * and stub.  For every section of these two types the index into the
     * indirect symbol table is stored in the section header in the field
     * reserved1.  An indirect symbol table entry is simply a 32bit index into
     * the symbol table to the symbol that the pointer or stub is referring to.
     * The indirect symbol table is ordered to match the entries in the section.
     *//// file offset to the indirect symbol tablenindirectsyms/// number of indirect symbol table entriesextreloff/*
     * To support relocating an individual module in a library file quickly the
     * external relocation entries for each module in the library need to be
     * accessed efficiently.  Since the relocation entries can't be accessed
     * through the section headers for a library file they are separated into
     * groups of local and external entries further grouped by module.  In this
     * case the presents of this load command who's extreloff, nextrel,
     * locreloff and nlocrel fields are non-zero indicates that the relocation
     * entries of non-merged sections are not referenced through the section
     * structures (and the reloff and nreloc fields in the section headers are
     * set to zero).
     *
     * Since the relocation entries are not accessed through the section headers
     * this requires the r_address field to be something other than a section
     * offset to identify the item to be relocated.  In this case r_address is
     * set to the offset from the vmaddr of the first LC_SEGMENT command.
     * For MH_SPLIT_SEGS images r_address is set to the the offset from the
     * vmaddr of the first read-write LC_SEGMENT command.
     *
     * The relocation entries are grouped by module and the module table
     * entries have indexes and counts into them for the group of external
     * relocation entries for that the module.
     *
     * For sections that are merged across modules there must not be any
     * remaining external relocation entries for them (for merged sections
     * remaining relocation entries must be local).
     *//// offset to external relocation entriesnextrel/// number of external relocation entrieslocreloff/*
     * All the local relocation entries are grouped together (they are not
     * grouped by their module since they are only used if the object is moved
     * from it statically link edited address).
     *//// offset to local relocation entriesnlocrel/// number of local relocation entriesDysymtabCommand/*
 * This is the second set of the symbolic information which is used to support
 * the data structures for the dynamically link editor.
 *
 * The original set of symbolic information in the `SymtabCommand` which contains
 * the symbol and string tables must also be present when this load command is
 * present.  When this load command is present the symbol table is organized
 * into three groups of symbols:
 *	local symbols (static and debugging symbols) - grouped by module
 *	defined external symbols - grouped by module (sorted by name if not lib)
 *	undefined external symbols (sorted by name if MH_BINDATLOAD is not set,
 *	     			    and in order the were seen by the static
 *				    linker if MH_BINDATLOAD is set)
 * In this load command there are offsets and counts to each of the three groups
 * of symbols.
 *
 * This load command contains a the offsets and sizes of the following new
 * symbolic information tables:
 *	table of contents
 *	module table
 *	reference symbol table
 *	indirect symbol table
 * The first three tables above (the table of contents, module table and
 * reference symbol table) are only present if the file is a dynamically linked
 * shared library.  For executable and object modules, which are files
 * containing only one module, the information that would be in these three
 * tables is determined as follows:
 * 	table of contents - the defined external symbols are sorted by name
 *	module table - the file contains only one module so everything in the
 *		       file is part of the module.
 *	reference symbol table - is the defined and undefined external symbols
 *
 * For dynamically linked shared library files this load command also contains
 * offsets and sizes to the pool of relocation entries for all sections
 * separated into two groups:
 *	external relocation entries
 *	local relocation entries
 * For executable and object modules the relocation entries continue to hang
 * off the section structures.
 */INDIRECT_SYMBOL_LOCAL/*
 * An indirect symbol table entry is simply a 32bit index into the symbol table
 * to the symbol that the pointer or stub is referring to.  Unless it is for a
 * non-lazy symbol pointer section for a defined symbol which strip(1) as
 * removed.  In which case it has the value INDIRECT_SYMBOL_LOCAL.  If the
 * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.
 */INDIRECT_SYMBOL_ABS/// the defined external symbol (index into the symbol table)module_index/// index into the module table this symbol is defined inDylibTableOfContents/* a table of contents entry *//// the module name (index into string table)/// index into externally defined symbolsirefsym/// index into reference symbol tablenrefsym/// number of reference symbol table entries/// index into symbols for local symbolsiextrel/// index into external relocation entriesiinit_iterm/// low 16 bits are the index into the init section, high 16 bits are the index into the term sectionninit_nterm/// low 16 bits are the number of init section entries, high 16 bits are the number of term section entriesobjc_module_info_addr/// for this module address of the start of the (__OBJC,__module_info) sectionobjc_module_info_size/// for this module size of the (__OBJC,__module_info) sectionDylibModule32/* a module table entry */DylibModule64/* a 64-bit module table entry */bitfield/* TODO:
    uint32_t isym:24,		/* index into the symbol table */
              flags:8;	/* flags to indicate the type of reference */
    */DylibReference/*
 * The entries in the reference symbol table are used when loading the module
 * (both by the static and dynamic link editors) and if the module is unloaded
 * or replaced.  Therefore all external symbols (defined and undefined) are
 * listed in the module's reference table.  The flags describe the type of
 * reference that is being made.  The constants for the flags are defined in
 * <mach-o/nlist.h> as they are also used for symbol table entries.
 *//// LC_TWOLEVEL_HINTS/// sizeof(struct TwolevelHintsCommand)/// offset to the hint tablenhints/// number of hints in the hint tableTwolevelHintsCommand/*
 * The TwolevelHintsCommand contains the offset and number of hints in the
 * two-level namespace lookup hints table.
 *//* TODO:
    uint32_t
    isub_image:8,	/* index into the sub images */
    itoc:24;	/* index into the table of contents */
    */TwolevelHint/*
 * The entries in the two-level namespace lookup hints table are TwolevelHint
 * structs.  These provide hints to the dynamic link editor where to start
 * looking for an undefined symbol in a two-level namespace image.  The
 * isub_image field is an index into the sub-images (sub-frameworks and
 * sub-umbrellas list) that made up the two-level image that the undefined
 * symbol was found in when it was built by the static link editor.  If
 * isub-image is 0 the the symbol is expected to be defined in library and not
 * in the sub-images.  If isub-image is non-zero it is an index into the array
 * of sub-images for the umbrella with the first index in the sub-images being
 * 1. The array of sub-images is the ordered list of sub-images of the umbrella
 * that would be searched for a symbol that has the umbrella recorded as its
 * primary library.  The table of contents index is an index into the
 * library's table of contents.  This is used as the starting point of the
 * binary search or a directed linear search.
 *//// LC_PREBIND_CKSUM/// sizeof(struct PrebindCksumCommand)cksum/// the check sum or zeroPrebindCksumCommand/*
 * The PrebindCksumCommand contains the value of the original check sum for
 * prebound files or zero.  When a prebound file is first created or modified
 * for other than updating its prebinding information the value of the check sum
 * is set to zero.  When the file has it prebinding re-done and if the value of
 * the check sum is zero the original check sum is calculated and stored in
 * cksum field of this load command in the output file.  If when the prebinding
 * is re-done and the cksum field is non-zero it is left unchanged from the
 * input file.
 *//// LC_UUID/// sizeof(struct UuidCommand)/// the 128-bit uuidUuidCommand/*
 * The uuid load command contains a single 128-bit unique random number that
 * identifies an object produced by the static link editor.
 *//// LC_RPATH/// includes string/// path to add to run pathRpathCommand/*
 * The RpathCommand contains a path which at runtime should be added to
 * the current run path used to find @rpath prefixed dylibs.
 *//// `LC_CODE_SIGNATURE`, `LC_SEGMENT_SPLIT_INFO`, `LC_FUNCTION_STARTS`,/// `LC_DATA_IN_CODE`, `LC_DYLIB_CODE_SIGN_DRS`, `LC_LINKER_OPTIMIZATION_HINT`,/// `LC_DYLD_EXPORTS_TRIE`, or `LC_DYLD_CHAINED_FIXUPS`./// sizeof(struct LinkeditDataCommand)dataoff/// file offset of data in __LINKEDIT segmentdatasize/// file size of data in __LINKEDIT segmentLinkeditDataCommand/*
 * The LinkeditDataCommand contains the offsets and sizes of a blob
 * of data in the __LINKEDIT segment.
 */// LC_FILESET_ENTRY/// includes id string/// memory address of the dylib/// file offset of the dylib/// contained entry id/// entry_id is 32-bits long, so this is the reserved paddingFilesetEntryCommand/// LC_ENCRYPTION_INFO/// sizeof(struct EncryptionInfoCommand32)cryptoff/// file offset of encrypted rangecryptsize/// file size of encrypted rangecryptid/// which enryption system, 0 means not-encrypted yetEncryptionInfoCommand32/*
 * The EncryptionInfoCommand32 contains the file offset and size of an
 * of an encrypted segment.
 *//// LC_ENCRYPTION_INFO_64/// sizeof(struct EncryptionInfoCommand64)/// padding to make this struct's size a multiple of 8 bytesEncryptionInfoCommand64/*
 * The EncryptionInfoCommand64 contains the file offset and size of an
 * of an encrypted segment (for use in x86_64 targets).
 *//// LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS or LC_VERSION_MIN_WATCHOS or LC_VERSION_MIN_TVOS/// sizeof(struct VersionMinCommand)/// X.Y.Z is encoded in nibbles xxxx.yy.zzVersionMinCommand/*
 * The VersionMinCommand contains the min OS version on which this
 * binary was built to run.
 *//// LC_BUILD_VERSION/// sizeof(struct BuildVersionCommand) plus ntools * sizeof(struct BuildToolVersion)/// platformminosntools/// number of tool entries following thisBuildVersionCommand/*
 * The BuildVersionCommand contains the min OS version on which this
 * binary was built to run for its platform.  The list of known platforms and
 * tool values following it.
 *//// enum for the tool/// version number of the toolBuildToolVersionPLATFORM_MACOS/* Known values for the platform field above. */PLATFORM_IOSPLATFORM_TVOSPLATFORM_WATCHOSPLATFORM_BRIDGEOSPLATFORM_MACCATALYSTPLATFORM_IOSSIMULATORPLATFORM_TVOSSIMULATORPLATFORM_WATCHOSSIMULATORPLATFORM_DRIVERKITPLATFORM_XROSPLATFORM_XROSSIMULATORTOOL_CLANG/* Known values for the tool field above. */TOOL_SWIFTTOOL_LD/// LC_DYLD_INFO or LC_DYLD_INFO_ONLY/// sizeof(struct DyldInfoCommand)rebase_off/*
     * Dyld rebases an image whenever dyld loads it at an address different
     * from its preferred address.  The rebase information is a stream
     * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.
     * Conceptually the rebase information is a table of tuples:
     *    <seg-index, seg-offset, type>
     * The opcodes are a compressed way to encode the table by only
     * encoding when a column changes.  In addition simple patterns
     * like "every n'th offset for m times" can be encoded in a few
     * bytes.
     *//// file offset to rebase inforebase_size/// size of rebase infobind_off/*
     * Dyld binds an image during the loading process, if the image
     * requires any pointers to be initialized to symbols in other images.
     * The bind information is a stream of byte sized
     * opcodes whose symbolic names start with BIND_OPCODE_.
     * Conceptually the bind information is a table of tuples:
     *    <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>
     * The opcodes are a compressed way to encode the table by only
     * encoding when a column changes.  In addition simple patterns
     * like for runs of pointers initialized to the same value can be
     * encoded in a few bytes.
     *//// file offset to binding infobind_size/// size of binding infoweak_bind_off/*
     * Some C++ programs require dyld to unique symbols so that all
     * images in the process use the same copy of some code/data.
     * This step is done after binding. The content of the weak_bind
     * info is an opcode stream like the bind_info.  But it is sorted
     * alphabetically by symbol name.  This enable dyld to walk
     * all images with weak binding information in order and look
     * for collisions.  If there are no collisions, dyld does
     * no updating.  That means that some fixups are also encoded
     * in the bind_info.  For instance, all calls to "operator new"
     * are first bound to libstdc++.dylib using the information
     * in bind_info.  Then if some image overrides operator new
     * that is detected when the weak_bind information is processed
     * and the call to operator new is then rebound.
     *//// file offset to weak binding infoweak_bind_size/// size of weak binding infolazy_bind_off/*
     * Some uses of external symbols do not need to be bound immediately.
     * Instead they can be lazily bound on first use.  The lazy_bind
     * are contains a stream of BIND opcodes to bind all lazy symbols.
     * Normal use is that dyld ignores the lazy_bind section when
     * loading an image.  Instead the static linker arranged for the
     * lazy pointer to initially point to a helper function which
     * pushes the offset into the lazy_bind area for the symbol
     * needing to be bound, then jumps to dyld which simply adds
     * the offset to lazy_bind_off to get the information on what
     * to bind.
     *//// file offset to lazy binding infolazy_bind_size/// size of lazy binding infsexport_off/*
     * The symbols exported by a dylib are encoded in a trie.  This
     * is a compact representation that factors out common prefixes.
     * It also reduces LINKEDIT pages in RAM because it encodes all
     * information (name, address, flags) in one small, contiguous range.
     * The export area is a stream of nodes.  The first node sequentially
     * is the start node for the trie.
     *
     * Nodes for a symbol start with a uleb128 that is the length of
     * the exported symbol information for the string so far.
     * If there is no exported symbol, the node starts with a zero byte.
     * If there is exported info, it follows the length.
     *
     * First is a uleb128 containing flags. Normally, it is followed by
     * a uleb128 encoded offset which is location of the content named
     * by the symbol from the mach_header for the image.  If the flags
     * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
     * a uleb128 encoded library ordinal, then a zero terminated
     * UTF8 string.  If the string is zero length, then the symbol
     * is re-export from the specified dylib with the same name.
     * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
     * the flags is two uleb128s: the stub offset and the resolver offset.
     * The stub is used by non-lazy pointers.  The resolver is used
     * by lazy pointers and must be called to get the actual address to use.
     *
     * After the optional exported symbol information is a byte of
     * how many edges (0-255) that this node has leaving it,
     * followed by each edge.
     * Each edge is a zero terminated UTF8 of the addition chars
     * in the symbol, followed by a uleb128 offset for the node that
     * edge points to.
     *
     */export_sizeDyldInfoCommand/*
 * The DyldInfoCommand contains the file offsets and sizes of
 * the new compressed form of the information dyld needs to
 * load the image.  This information is used by dyld on Mac OS X
 * 10.6 and later.  All information pointed to by this command
 * is encoded using byte streams, so no endian swapping is needed
 * to interpret it.
 */REBASE_TYPE_POINTER/*
 * The following are used to encode rebasing information
 */REBASE_TYPE_TEXT_ABSOLUTE32REBASE_TYPE_TEXT_PCREL32REBASE_OPCODE_MASKREBASE_IMMEDIATE_MASKREBASE_OPCODE_DONEREBASE_OPCODE_SET_TYPE_IMMREBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEBREBASE_OPCODE_ADD_ADDR_ULEBREBASE_OPCODE_ADD_ADDR_IMM_SCALEDREBASE_OPCODE_DO_REBASE_IMM_TIMESREBASE_OPCODE_DO_REBASE_ULEB_TIMESREBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEBREBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEBBIND_TYPE_POINTER/*
 * The following are used to encode binding information
 */BIND_TYPE_TEXT_ABSOLUTE32BIND_TYPE_TEXT_PCREL32BIND_SPECIAL_DYLIB_SELFBIND_SPECIAL_DYLIB_MAIN_EXECUTABLEBIND_SPECIAL_DYLIB_FLAT_LOOKUPBIND_SPECIAL_DYLIB_WEAK_LOOKUPBIND_SYMBOL_FLAGS_WEAK_IMPORTBIND_SYMBOL_FLAGS_NON_WEAK_DEFINITIONBIND_OPCODE_MASKBIND_IMMEDIATE_MASKBIND_OPCODE_DONEBIND_OPCODE_SET_DYLIB_ORDINAL_IMMBIND_OPCODE_SET_DYLIB_ORDINAL_ULEBBIND_OPCODE_SET_DYLIB_SPECIAL_IMMBIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMMBIND_OPCODE_SET_TYPE_IMMBIND_OPCODE_SET_ADDEND_SLEBBIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEBBIND_OPCODE_ADD_ADDR_ULEBBIND_OPCODE_DO_BINDBIND_OPCODE_DO_BIND_ADD_ADDR_ULEBBIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALEDBIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEBBIND_OPCODE_THREADEDBIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEBBIND_SUBOPCODE_THREADED_APPLYEXPORT_SYMBOL_FLAGS_KIND_MASK/*
 * The following are used on the flags byte of a terminal node
 * in the export information.
 */EXPORT_SYMBOL_FLAGS_KIND_REGULAREXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCALEXPORT_SYMBOL_FLAGS_KIND_ABSOLUTEEXPORT_SYMBOL_FLAGS_WEAK_DEFINITIONEXPORT_SYMBOL_FLAGS_REEXPORTEXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER/// LC_LINKER_OPTION only used in MH_OBJECT filetypes/// number of strings/* concatenation of zero terminated UTF8 strings.
    Zero filled at end to align */LinkerOptionCommand/*
 * The LinkerOptionCommand contains linker options embedded in object files.
 *//// LC_SYMSEG/// sizeof(struct SymsegCommand)/// symbol segment offset/// symbol segment size in bytesSymsegCommand/*
 * The SymsegCommand contains the offset and size of the GNU style
 * symbol table information as described in the header file <symseg.h>.
 * The symbol roots of the symbol segments must also be aligned properly
 * in the file.  So the requirement of keeping the offsets aligned to a
 * multiple of a 4 bytes translates to the length field of the symbol
 * roots also being a multiple of a long.  Also the padding must again be
 * zeroed. (THIS IS OBSOLETE and no longer supported).
 *//// LC_IDENT/// strings that follow this commandIdentCommand/*
 * The IdentCommand contains a free format string table following the
 * IdentCommand structure.  The strings are null terminated and the size of
 * the command is padded out with zero bytes to a multiple of 4 bytes/
 * (THIS IS OBSOLETE and no longer supported).
 *//// LC_FVMFILE/// files pathname/// files virtual addressFvmfileCommand/*
 * The FvmfileCommand contains a reference to a file to be loaded at the
 * specified virtual address.  (Presently, this command is reserved for
 * internal use.  The kernel ignores this command when loading a program into
 * memory).
 *//// LC_MAIN only used in MH_EXECUTE filetypes/// 24entryoff/// file (__TEXT) offset of main()stacksize/// if not zero, initial stack sizeEntryPointCommand/*
 * The EntryPointCommand is a replacement for thread_command.
 * It is used for main executables to specify the location (file offset)
 * of main().  If -stack_size was used at link time, the stacksize
 * field will contain the stack size need for the main thread.
 *//// LC_SOURCE_VERSION/// 16/// A.B.C.D.E packed as a24.b10.c10.d10.e10SourceVersionCommand/*
 * The SourceVersionCommand is an optional load command containing
 * the version of the sources used to build the binary.
 *//// from mach_header to start of data range/// number of bytes in data range/// a DICE_KIND_* valueDataInCodeEntry/*
 * The LC_DATA_IN_CODE load commands uses a LinkeditDataCommand
 * to point to an array of DataInCodeEntry entries. Each entry
 * describes a range of data in a code section.
 */DICE_KIND_DATADICE_KIND_JUMP_TABLE8DICE_KIND_JUMP_TABLE16DICE_KIND_JUMP_TABLE32DICE_KIND_ABS_JUMP_TABLE32/// LC_NOTE/// sizeof(struct NoteCommand)data_owner/// owner name for this LC_NOTE/// file offset of this data/// length of data regionNoteCommand/*
 * LC_NOTE commands describe a region of arbitrary data included in a Mach-O
 * file.  Its initial use is to record extra data in MH_CORE files.
 */n_strx/// index into the string table/// type flag, see belown_sect/// section number or NO_SECT/// see <mach-o/stab.h>n_value/// value of this symbol (or stab offset)Nlist32// Note: 4 byte alignment has been observed in practice.Nlist64/*
 * This is the symbol table entry structure for 64-bit architectures.
 */N_STAB/*
 * The n_type field really contains four fields:
 *	unsigned char N_STAB:3,
 *		      N_PEXT:1,
 *		      N_TYPE:3,
 *		      N_EXT:1;
 * which are used via the following masks.
 *//// if any of these bits set, a symbolic debugging entryN_PEXT/// private external symbol bitN_TYPE/// mask for the type bitsN_EXT/// external symbol bit, set for external symbolsN_UNDF/*
 * Values for N_TYPE bits of the n_type field.
 *//// undefined, n_sect == NO_SECTN_ABS/// absolute, n_sect == NO_SECTN_SECT/// defined in section number n_sectN_PBUD/// prebound undefined (defined in a dylib)N_INDR/// indirectNO_SECT/*
 * If the type is N_SECT then the n_sect field contains an ordinal of the
 * section the symbol is defined in.  The sections are numbered from 1 and
 * refer to sections in order they appear in the load commands for the file
 * they are in.  This means the same ordinal may very well refer to different
 * sections in different files.
 *
 * The n_value field for all symbol table entries (including N_STAB's) gets
 * updated by the link editor based on the value of it's n_sect field and where
 * the section n_sect references gets relocated.  If the value of the n_sect
 * field is NO_SECT then it's n_value field is not changed by the link editor.
 *//// symbol is not in any sectionMAX_SECT/// 1 thru 255 inclusiveREFERENCE_TYPE/*
 * To support the lazy binding of undefined symbols in the dynamic link-editor,
 * the undefined symbols in the symbol table (the nlist structures) are marked
 * with the indication if the undefined reference is a lazy reference or
 * non-lazy reference.  If both a non-lazy reference and a lazy reference is
 * made to the same symbol the non-lazy reference takes precedence.  A reference
 * is lazy only when all references to that symbol are made through a symbol
 * pointer in a lazy symbol pointer section.
 *
 * The implementation of marking nlist structures in the symbol table for
 * undefined symbols will be to use some of the bits of the n_desc field as a
 * reference type.  The mask REFERENCE_TYPE will be applied to the n_desc field
 * of an nlist structure for an undefined symbol to determine the type of
 * undefined reference (lazy or non-lazy).
 *
 * The constants for the REFERENCE FLAGS are propagated to the reference table
 * in a shared library file.  In that case the constant for a defined symbol,
 * REFERENCE_FLAG_DEFINED, is also used.
 *//* Reference type bits of the n_desc field of undefined symbols */REFERENCE_FLAG_UNDEFINED_NON_LAZY/* types of references */REFERENCE_FLAG_UNDEFINED_LAZYREFERENCE_FLAG_DEFINEDREFERENCE_FLAG_PRIVATE_DEFINEDREFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZYREFERENCE_FLAG_PRIVATE_UNDEFINED_LAZYREFERENCED_DYNAMICALLY/*
 * To simplify stripping of objects that use are used with the dynamic link
 * editor, the static link editor marks the symbols defined an object that are
 * referenced by a dynamically bound object (dynamic shared libraries, bundles).
 * With this marking strip knows not to strip these symbols.
 */SELF_LIBRARY_ORDINAL/*
 * For images created by the static link editor with the -twolevel_namespace
 * option in effect the flags field of the mach header is marked with
 * MH_TWOLEVEL.  And the binding of the undefined references of the image are
 * determined by the static link editor.  Which library an undefined symbol is
 * bound to is recorded by the static linker in the high 8 bits of the n_desc
 * field using the SET_LIBRARY_ORDINAL macro below.  The ordinal recorded
 * references the libraries listed in the Mach-O's LC_LOAD_DYLIB,
 * LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB, LC_LOAD_UPWARD_DYLIB, and
 * LC_LAZY_LOAD_DYLIB, etc. load commands in the order they appear in the
 * headers.   The library ordinals start from 1.
 * For a dynamic library that is built as a two-level namespace image the
 * undefined references from module defined in another use the same nlist struct
 * an in that case SELF_LIBRARY_ORDINAL is used as the library ordinal.  For
 * defined symbols in all images they also must have the library ordinal set to
 * SELF_LIBRARY_ORDINAL.  The EXECUTABLE_ORDINAL refers to the executable
 * image for references from plugins that refer to the executable that loads
 * them.
 *
 * The DYNAMIC_LOOKUP_ORDINAL is for undefined symbols in a two-level namespace
 * image that are looked up by the dynamic linker with flat namespace semantics.
 * This ordinal was added as a feature in Mac OS X 10.3 by reducing the
 * value of MAX_LIBRARY_ORDINAL by one.  So it is legal for existing binaries
 * or binaries built with older tools to have 0xfe (254) dynamic libraries.  In
 * this case the ordinal value 0xfe (254) must be treated as a library ordinal
 * for compatibility.
 *//* TODO:
#define GET_LIBRARY_ORDINAL(n_desc) (((n_desc) >> 8) & 0xff)
#define SET_LIBRARY_ORDINAL(n_desc,ordinal) \
    (n_desc) = (((n_desc) & 0x00ff) | (((ordinal) & 0xff) << 8))
 */MAX_LIBRARY_ORDINALDYNAMIC_LOOKUP_ORDINALEXECUTABLE_ORDINALN_NO_DEAD_STRIP/*
 * The N_NO_DEAD_STRIP bit of the n_desc field only ever appears in a
 * relocatable .o file (MH_OBJECT filetype). And is used to indicate to the
 * static link editor it is never to dead strip the symbol.
 *//// symbol is not to be dead strippedN_DESC_DISCARDED/*
 * The N_DESC_DISCARDED bit of the n_desc field never appears in linked image.
 * But is used in very rare cases by the dynamic link editor to mark an in
 * memory symbol as discared and longer used for linking.
 *//// symbol is discardedN_WEAK_REF/*
 * The N_WEAK_REF bit of the n_desc field indicates to the dynamic linker that
 * the undefined symbol is allowed to be missing and is to have the address of
 * zero when missing.
 *//// symbol is weak referencedN_WEAK_DEF/*
 * The N_WEAK_DEF bit of the n_desc field indicates to the static and dynamic
 * linkers that the symbol definition is weak, allowing a non-weak symbol to
 * also be used which causes the weak definition to be discared.  Currently this
 * is only supported for symbols in coalesced sections.
 *//// coalesced symbol is a weak definitionN_REF_TO_WEAK/*
 * The N_REF_TO_WEAK bit of the n_desc field indicates to the dynamic linker
 * that the undefined symbol should be resolved using flat namespace searching.
 *//// reference to a weak symbolN_ARM_THUMB_DEF/*
 * The N_ARM_THUMB_DEF bit of the n_desc field indicates that the symbol is
 * a definition of a Thumb function.
 *//// symbol is a Thumb function (ARM)N_SYMBOL_RESOLVER/*
 * The N_SYMBOL_RESOLVER bit of the n_desc field indicates that the
 * that the function is actually a resolver function and should
 * be called to get the address of the real function to use.
 * This bit is only available in .o files (MH_OBJECT filetype)
 */N_ALT_ENTRY/*
 * The N_ALT_ENTRY bit of the n_desc field indicates that the
 * symbol is pinned to the previous content.
 */N_GSYM/*
 * Symbolic debugger symbols.  The comments give the conventional use for
 *
 * 	.stabs "n_name", n_type, n_sect, n_desc, n_value
 *
 * where n_type is the defined constant and not listed in the comment.  Other
 * fields not listed are zero. n_sect is the section ordinal the entry is
 * referring to.
 *//// global symbol: name,,NO_SECT,type,0N_FNAME/// procedure name (f77 kludge): name,,NO_SECT,0,0N_FUN/// procedure: name,,n_sect,linenumber,addressN_STSYM/// static symbol: name,,n_sect,type,addressN_LCSYM/// .lcomm symbol: name,,n_sect,type,addressN_BNSYM/// begin nsect sym: 0,,n_sect,0,addressN_AST/// AST file path: name,,NO_SECT,0,0N_OPT/// emitted with gcc2_compiled and in gcc sourceN_RSYM/// register sym: name,,NO_SECT,type,registerN_SLINE/// src line: 0,,n_sect,linenumber,addressN_ENSYM/// end nsect sym: 0,,n_sect,0,addressN_SSYM/// structure elt: name,,NO_SECT,type,struct_offsetN_SO/// source file name: name,,n_sect,0,addressN_OSO/// object file name: name,,0,0,st_mtimeN_LSYM/// local sym: name,,NO_SECT,type,offsetN_BINCL/// include file beginning: name,,NO_SECT,0,sumN_SOL/// #included file name: name,,n_sect,0,addressN_PARAMS/// compiler parameters: name,,NO_SECT,0,0N_VERSION/// compiler version: name,,NO_SECT,0,0N_OLEVEL/// compiler -O level: name,,NO_SECT,0,0N_PSYM/// parameter: name,,NO_SECT,type,offsetN_EINCL/// include file end: name,,NO_SECT,0,0N_ENTRY/// alternate entry: name,,n_sect,linenumber,addressN_LBRAC/// left bracket: 0,,NO_SECT,nesting level,addressN_EXCL/// deleted include file: name,,NO_SECT,0,sumN_RBRAC/// right bracket: 0,,NO_SECT,nesting level,addressN_BCOMM/// begin common: name,,NO_SECT,0,0N_ECOMM/// end common: name,,n_sect,0,0N_ECOML/// end common (local name): 0,,n_sect,0,addressN_LENG/// second stab entry with length informationN_PC/*
 * for the berkeley pascal compiler, pc(1):
 *//// global pascal symbol: name,,NO_SECT,subtype,liner_word0r_word1/// A relocation entry./// Mach-O relocations have plain and scattered variants, with the/// meaning of the fields depending on the variant./// This type provides functions for determining whether the relocation/// is scattered, and for accessing the fields of each variant.r_scattered/// Determine whether this is a scattered relocation.RelocationInfo/// Return the fields of a plain relocation.scattered_infoScatteredRelocationInfo/// Return the fields of a scattered relocation.r_address/// offset in the section to what is being relocatedr_symbolnum/// symbol index if r_extern == 1 or section ordinal if r_extern == 0/// was relocated pc relative already/// 0=byte, 1=word, 2=long, 3=quadr_extern/// does not include value of sym referenced/// if not 0, machine specific relocation typerelocation/// Combine the fields into a `Relocation`.R_ABS/// absolute relocation type for Mach-O filesR_SCATTERED/// Bit set in `Relocation::r_word0` for scattered relocations.r_value/// the value the item to be relocated is referring to (without any offset added)GENERIC_RELOC_VANILLA/*
 * Relocation types used in a generic implementation.  Relocation entries for
 * normal things use the generic relocation as described above and their r_type
 * is GENERIC_RELOC_VANILLA (a value of zero).
 *
 * Another type of generic relocation, GENERIC_RELOC_SECTDIFF, is to support
 * the difference of two symbols defined in different sections.  That is the
 * expression "symbol1 - symbol2 + constant" is a relocatable expression when
 * both symbols are defined in some section.  For this type of relocation the
 * both relocations entries are scattered relocation entries.  The value of
 * symbol1 is stored in the first relocation entry's r_value field and the
 * value of symbol2 is stored in the pair's r_value field.
 *
 * A special case for a prebound lazy pointer is needed to beable to set the
 * value of the lazy pointer back to its non-prebound state.  This is done
 * using the GENERIC_RELOC_PB_LA_PTR r_type.  This is a scattered relocation
 * entry where the r_value feild is the value of the lazy pointer not prebound.
 *//// generic relocation as described aboveGENERIC_RELOC_PAIR/// Only follows a GENERIC_RELOC_SECTDIFFGENERIC_RELOC_SECTDIFFGENERIC_RELOC_PB_LA_PTR/// prebound lazy pointerGENERIC_RELOC_LOCAL_SECTDIFFGENERIC_RELOC_TLV/// thread local variablesARM_RELOC_VANILLA/*
 * Relocation types used in the arm implementation.  Relocation entries for
 * things other than instructions use the same generic relocation as described
 * in <mach-o/reloc.h> and their r_type is ARM_RELOC_VANILLA, one of the
 * *_SECTDIFF or the *_PB_LA_PTR types.  The rest of the relocation types are
 * for instructions.  Since they are for instructions the r_address field
 * indicates the 32 bit instruction that the relocation is to be performed on.
 */ARM_RELOC_PAIR/// the second relocation entry of a pairARM_RELOC_SECTDIFF/// a PAIR follows with subtract symbol valueARM_RELOC_LOCAL_SECTDIFF/// like ARM_RELOC_SECTDIFF, but the symbol referenced was local.ARM_RELOC_PB_LA_PTRARM_RELOC_BR24/// 24 bit branch displacement (to a word address)ARM_THUMB_RELOC_BR22/// 22 bit branch displacement (to a half-word address)ARM_THUMB_32BIT_BRANCH/// obsolete - a thumb 32-bit branch instruction possibly needing page-spanning branch workaroundARM_RELOC_HALF/*
 * For these two r_type relocations they always have a pair following them
 * and the r_length bits are used differently.  The encoding of the
 * r_length is as follows:
 * low bit of r_length:
 *  0 - :lower16: for movw instructions
 *  1 - :upper16: for movt instructions
 * high bit of r_length:
 *  0 - arm instructions
 *  1 - thumb instructions
 * the other half of the relocated expression is in the following pair
 * relocation entry in the the low 16 bits of r_address field.
 */ARM_RELOC_HALF_SECTDIFFARM64_RELOC_UNSIGNED/*
 * Relocation types used in the arm64 implementation.
 *//// for pointersARM64_RELOC_SUBTRACTOR/// must be followed by a ARM64_RELOC_UNSIGNEDARM64_RELOC_BRANCH26/// a B/BL instruction with 26-bit displacementARM64_RELOC_PAGE21/// pc-rel distance to page of targetARM64_RELOC_PAGEOFF12/// offset within page, scaled by r_lengthARM64_RELOC_GOT_LOAD_PAGE21/// pc-rel distance to page of GOT slotARM64_RELOC_GOT_LOAD_PAGEOFF12/// offset within page of GOT slot, scaled by r_lengthARM64_RELOC_POINTER_TO_GOT/// for pointers to GOT slotsARM64_RELOC_TLVP_LOAD_PAGE21/// pc-rel distance to page of TLVP slotARM64_RELOC_TLVP_LOAD_PAGEOFF12/// offset within page of TLVP slot, scaled by r_lengthARM64_RELOC_ADDEND/// must be followed by PAGE21 or PAGEOFF12ARM64_RELOC_AUTHENTICATED_POINTER// An arm64e authenticated pointer.// Represents a pointer to a symbol (like ARM64_RELOC_UNSIGNED).// Additionally, the resulting pointer is signed.  The signature is// specified in the target location: the addend is restricted to the lower// 32 bits (instead of the full 64 bits for ARM64_RELOC_UNSIGNED)://   |63|62|61-51|50-49|  48  |47     -     32|31  -  0|//   | 1| 0|  0  | key | addr | discriminator | addend |// The key is one of://   IA: 00 IB: 01//   DA: 10 DB: 11// The discriminator field is used as extra signature diversification.// The addr field indicates whether the target address should be blended// into the discriminator.PPC_RELOC_VANILLA/*
 * Relocation types used in the ppc implementation.  Relocation entries for
 * things other than instructions use the same generic relocation as described
 * above and their r_type is RELOC_VANILLA.  The rest of the relocation types
 * are for instructions.  Since they are for instructions the r_address field
 * indicates the 32 bit instruction that the relocation is to be performed on.
 * The fields r_pcrel and r_length are ignored for non-RELOC_VANILLA r_types
 * except for PPC_RELOC_BR14.
 *
 * For PPC_RELOC_BR14 if the r_length is the unused value 3, then the branch was
 * statically predicted setting or clearing the Y-bit based on the sign of the
 * displacement or the opcode.  If this is the case the static linker must flip
 * the value of the Y-bit if the sign of the displacement changes for non-branch
 * always conditions.
 */PPC_RELOC_PAIRPPC_RELOC_BR14/// 14 bit branch displacement (to a word address)PPC_RELOC_BR24PPC_RELOC_HI16/// a PAIR follows with the low halfPPC_RELOC_LO16/// a PAIR follows with the high halfPPC_RELOC_HA16/// Same as the RELOC_HI16 except the low 16 bits and the high 16 bits are added together/// with the low 16 bits sign extended first.  This means if bit 15 of the low 16 bits is/// set the high 16 bits stored in the instruction will be adjusted.PPC_RELOC_LO14/// Same as the LO16 except that the low 2 bits are not stored in the instruction and are/// always zero.  This is used in double word load/store instructions.PPC_RELOC_SECTDIFFPPC_RELOC_PB_LA_PTRPPC_RELOC_HI16_SECTDIFF/// section difference forms of above.  a PAIRPPC_RELOC_LO16_SECTDIFF/// follows these with subtract symbol valuePPC_RELOC_HA16_SECTDIFFPPC_RELOC_JBSRPPC_RELOC_LO14_SECTDIFFPPC_RELOC_LOCAL_SECTDIFF/// like PPC_RELOC_SECTDIFF, but the symbol referenced was local.X86_64_RELOC_UNSIGNED/*
 * Relocations for x86_64 are a bit different than for other architectures in
 * Mach-O: Scattered relocations are not used.  Almost all relocations produced
 * by the compiler are external relocations.  An external relocation has the
 * r_extern bit set to 1 and the r_symbolnum field contains the symbol table
 * index of the target label.
 *
 * When the assembler is generating relocations, if the target label is a local
 * label (begins with 'L'), then the previous non-local label in the same
 * section is used as the target of the external relocation.  An addend is used
 * with the distance from that non-local label to the target label.  Only when
 * there is no previous non-local label in the section is an internal
 * relocation used.
 *
 * The addend (i.e. the 4 in _foo+4) is encoded in the instruction (Mach-O does
 * not have RELA relocations).  For PC-relative relocations, the addend is
 * stored directly in the instruction.  This is different from other Mach-O
 * architectures, which encode the addend minus the current section offset.
 *
 * The relocation types are:
 *
 * 	X86_64_RELOC_UNSIGNED	// for absolute addresses
 * 	X86_64_RELOC_SIGNED		// for signed 32-bit displacement
 * 	X86_64_RELOC_BRANCH		// a CALL/JMP instruction with 32-bit displacement
 * 	X86_64_RELOC_GOT_LOAD	// a MOVQ load of a GOT entry
 * 	X86_64_RELOC_GOT		// other GOT references
 * 	X86_64_RELOC_SUBTRACTOR	// must be followed by a X86_64_RELOC_UNSIGNED
 *
 * The following are sample assembly instructions, followed by the relocation
 * and section content they generate in an object file:
 *
 * 	call _foo
 * 		r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		E8 00 00 00 00
 *
 * 	call _foo+4
 * 		r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		E8 04 00 00 00
 *
 * 	movq _foo@GOTPCREL(%rip), %rax
 * 		r_type=X86_64_RELOC_GOT_LOAD, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		48 8B 05 00 00 00 00
 *
 * 	pushq _foo@GOTPCREL(%rip)
 * 		r_type=X86_64_RELOC_GOT, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		FF 35 00 00 00 00
 *
 * 	movl _foo(%rip), %eax
 * 		r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		8B 05 00 00 00 00
 *
 * 	movl _foo+4(%rip), %eax
 * 		r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		8B 05 04 00 00 00
 *
 * 	movb  $0x12, _foo(%rip)
 * 		r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		C6 05 FF FF FF FF 12
 *
 * 	movl  $0x12345678, _foo(%rip)
 * 		r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
 * 		C7 05 FC FF FF FF 78 56 34 12
 *
 * 	.quad _foo
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		00 00 00 00 00 00 00 00
 *
 * 	.quad _foo+4
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		04 00 00 00 00 00 00 00
 *
 * 	.quad _foo - _bar
 * 		r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		00 00 00 00 00 00 00 00
 *
 * 	.quad _foo - _bar + 4
 * 		r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		04 00 00 00 00 00 00 00
 *
 * 	.long _foo - _bar
 * 		r_type=X86_64_RELOC_SUBTRACTOR, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_bar
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		00 00 00 00
 *
 * 	lea L1(%rip), %rax
 * 		r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_prev
 * 		48 8d 05 12 00 00 00
 * 		// assumes _prev is the first non-local label 0x12 bytes before L1
 *
 * 	lea L0(%rip), %rax
 * 		r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
 * 		48 8d 05 56 00 00 00
 *		// assumes L0 is in third section and there is no previous non-local label.
 *		// The rip-relative-offset of 0x00000056 is L0-address_of_next_instruction.
 *		// address_of_next_instruction is the address of the relocation + 4.
 *
 *     add     $6,L0(%rip)
 *             r_type=X86_64_RELOC_SIGNED_1, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
 *		83 05 18 00 00 00 06
 *		// assumes L0 is in third section and there is no previous non-local label.
 *		// The rip-relative-offset of 0x00000018 is L0-address_of_next_instruction.
 *		// address_of_next_instruction is the address of the relocation + 4 + 1.
 *		// The +1 comes from SIGNED_1.  This is used because the relocation is not
 *		// at the end of the instruction.
 *
 * 	.quad L1
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
 * 		12 00 00 00 00 00 00 00
 * 		// assumes _prev is the first non-local label 0x12 bytes before L1
 *
 * 	.quad L0
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=0, r_pcrel=0, r_symbolnum=3
 * 		56 00 00 00 00 00 00 00
 * 		// assumes L0 is in third section, has an address of 0x00000056 in .o
 * 		// file, and there is no previous non-local label
 *
 * 	.quad _foo - .
 * 		r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		EE FF FF FF FF FF FF FF
 * 		// assumes _prev is the first non-local label 0x12 bytes before this
 * 		// .quad
 *
 * 	.quad _foo - L1
 * 		r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
 * 		r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
 * 		EE FF FF FF FF FF FF FF
 * 		// assumes _prev is the first non-local label 0x12 bytes before L1
 *
 * 	.quad L1 - _prev
 * 		// No relocations.  This is an assembly time constant.
 * 		12 00 00 00 00 00 00 00
 * 		// assumes _prev is the first non-local label 0x12 bytes before L1
 *
 *
 *
 * In final linked images, there are only two valid relocation kinds:
 *
 *     r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=1, r_symbolnum=sym_index
 *	This tells dyld to add the address of a symbol to a pointer sized (8-byte)
 *  piece of data (i.e on disk the 8-byte piece of data contains the addend). The
 *  r_symbolnum contains the index into the symbol table of the target symbol.
 *
 *     r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=0, r_symbolnum=0
 * This tells dyld to adjust the pointer sized (8-byte) piece of data by the amount
 * the containing image was loaded from its base address (e.g. slide).
 *
 *//// for absolute addressesX86_64_RELOC_SIGNED/// for signed 32-bit displacementX86_64_RELOC_BRANCH/// a CALL/JMP instruction with 32-bit displacementX86_64_RELOC_GOT_LOAD/// a MOVQ load of a GOT entryX86_64_RELOC_GOT/// other GOT referencesX86_64_RELOC_SUBTRACTOR/// must be followed by a X86_64_RELOC_UNSIGNEDX86_64_RELOC_SIGNED_1/// for signed 32-bit displacement with a -1 addendX86_64_RELOC_SIGNED_2/// for signed 32-bit displacement with a -2 addendX86_64_RELOC_SIGNED_4/// for signed 32-bit displacement with a -4 addendX86_64_RELOC_TLV/// for thread local variables//! Mach-O definitions.//! This module is based heavily on header files from MacOSX11.1.sdk.// Definitions from "/usr/include/mach/machine.h"./*
 * Capability bits used in the definition of cpu_type.
 *//*
 *	Machine types known by all.
 *//*
 *	VAX subtypes (these do *not* necessary conform to the actual cpu
 *	ID assigned by DEC available via the SID register).
 *//*
 *      680x0 subtypes
 *
 * The subtype definitions here are unusual for historical reasons.
 * NeXT used to consider 68030 code as generic 68000 code.  For
 * backwards compatibility:
 *
 *	CPU_SUBTYPE_MC68030 symbol has been preserved for source code
 *	compatibility.
 *
 *	CPU_SUBTYPE_MC680x0_ALL has been defined to be the same
 *	subtype as CPU_SUBTYPE_MC68030 for binary comatability.
 *
 *	CPU_SUBTYPE_MC68030_ONLY has been added to allow new object
 *	files to be tagged as containing 68030-specific instructions.
 *//*
 *	I386 subtypes
 *//*
 *	X86 subtypes.
 *//*
 *	Mips subtypes.
 *//*
 *	HPPA subtypes for Hewlett-Packard HP-PA family of
 *	risc processors. Port by NeXT to 700 series.
 */// Definitions from "/usr/include/mach/vm_prot.h".// Definitions from https://opensource.apple.com/source/dyld/dyld-210.2.3/launch-cache/dyld_cache_format.h.auto.html// Definitions from "/usr/include/mach-o/loader.h"./*
 * This header file describes the structures of the file format for "fat"
 * architecture specific file (wrapper design).  At the beginning of the file
 * there is one `FatHeader` structure followed by a number of `FatArch*`
 * structures.  For each architecture in the file, specified by a pair of
 * cputype and cpusubtype, the `FatHeader` describes the file offset, file
 * size and alignment in the file of the architecture specific member.
 * The padded bytes in the file to place each member on it's specific alignment
 * are defined to be read as zeros and can be left as "holes" if the file system
 * can support them as long as they read as zeros.
 *
 * All structures defined here are always written and read to/from disk
 * in big-endian order.
 *//*
 * The layout of the file depends on the filetype.  For all but the MH_OBJECT
 * file type the segments are padded out and aligned on a segment alignment
 * boundary for efficient demand pageing.  The MH_EXECUTE, MH_FVMLIB, MH_DYLIB,
 * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part
 * of their first segment.
 *
 * The file type MH_OBJECT is a compact format intended as output of the
 * assembler and input (and possibly output) of the link editor (the .o
 * format).  All sections are in one unnamed segment with no segment padding.
 * This format is used as an executable format when the file is so small the
 * segment padding greatly increases its size.
 *
 * The file type MH_PRELOAD is an executable format intended for things that
 * are not executed under the kernel (proms, stand alones, kernels, etc).  The
 * format can be executed under the kernel but may demand paged it and not
 * preload it before execution.
 *
 * A core file is in MH_CORE format and can be any in an arbritray legal
 * Mach-O file.
 *//*
 * The names of segments and sections in them are mostly meaningless to the
 * link-editor.  But there are few things to support traditional UNIX
 * executables that require the link-editor and assembler to use some names
 * agreed upon by convention.
 *
 * The initial protection of the "__TEXT" segment has write protection turned
 * off (not writeable).
 *
 * The link-editor will allocate common symbols at the end of the "__common"
 * section in the "__DATA" segment.  It will create the section and segment
 * if needed.
 *//* The currently known segment names and the section names in those segments *//*
 * Sections of type S_THREAD_LOCAL_VARIABLES contain an array
 * of TlvDescriptor structures.
 *//* TODO:
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct TlvDescriptor<E: Endian>
{
    void*		(*thunk)(struct TlvDescriptor*);
    unsigned long	key;
    unsigned long	offset;
}
*/// Definitions from "/usr/include/mach-o/nlist.h"./*
 * Symbols with a index into the string table of zero (n_un.n_strx == 0) are
 * defined to have a null, "", name.  Therefore all string indexes to non null
 * names must not have a zero string index.  This is bit historical information
 * that has never been well documented.
 *//*
 * Only symbolic debugging entries have some of the N_STAB bits set and if any
 * of these bits are set then it is a symbolic debugging entry (a stab).  In
 * which case then the values of the n_type field (the entire field) are given
 * in <mach-o/stab.h>
 *//*
 * If the type is N_INDR then the symbol is defined to be the same as another
 * symbol.  In this case the n_value field is an index into the string table
 * of the other symbol's name.  When the other symbol is defined then they both
 * take on the defined type and value.
 *//*
 * Common symbols are represented by undefined (N_UNDF) external (N_EXT) types
 * who's values (n_value) are non-zero.  In which case the value of the n_value
 * field is the size (in bytes) of the common symbol.  The n_sect field is set
 * to NO_SECT.  The alignment of a common symbol may be set as a power of 2
 * between 2^1 and 2^15 as part of the n_desc field using the macros below. If
 * the alignment is not set (a value of zero) then natural alignment based on
 * the size is used.
 *//* TODO:
#define GET_COMM_ALIGN(n_desc) (((n_desc) >> 8) & 0x0f)
#define SET_COMM_ALIGN(n_desc,align) \
    (n_desc) = (((n_desc) & 0xf0ff) | (((align) & 0x0f) << 8))
 *//*
 * The bit 0x0020 of the n_desc field is used for two non-overlapping purposes
 * and has two different symbolic names, N_NO_DEAD_STRIP and N_DESC_DISCARDED.
 */// Definitions from "/usr/include/mach-o/stab.h"./*
 * This file gives definitions supplementing <nlist.h> for permanent symbol
 * table entries of Mach-O files.  Modified from the BSD definitions.  The
 * modifications from the original definitions were changing what the values of
 * what was the n_other field (an unused field) which is now the n_sect field.
 * These modifications are required to support symbols in an arbitrary number of
 * sections not just the three sections (text, data and bss) in a BSD file.
 * The values of the defined constants have NOT been changed.
 *
 * These must have one of the N_STAB bits on.  The n_value fields are subject
 * to relocation according to the value of their n_sect field.  So for types
 * that refer to things in sections the n_sect field must be filled in with the
 * proper section ordinal.  For types that are not to have their n_value field
 * relocatated the n_sect field must be NO_SECT.
 */// Definitions from "/usr/include/mach-o/reloc.h"./*
 * Format of a relocation entry of a Mach-O file.  Modified from the 4.3BSD
 * format.  The modifications from the original format were changing the value
 * of the r_symbolnum field for "local" (r_extern == 0) relocation entries.
 * This modification is required to support symbols in an arbitrary number of
 * sections not just the three sections (text, data and bss) in a 4.3BSD file.
 * Also the last 4 bits have had the r_type tag added to them.
 *//*
 * The r_address is not really the address as it's name indicates but an offset.
 * In 4.3BSD a.out objects this offset is from the start of the "segment" for
 * which relocation entry is for (text or data).  For Mach-O object files it is
 * also an offset but from the start of the "section" for which the relocation
 * entry is for.  See comments in <mach-o/loader.h> about the r_address feild
 * in images for used with the dynamic linker.
 *
 * In 4.3BSD a.out objects if r_extern is zero then r_symbolnum is an ordinal
 * for the segment the symbol being relocated is in.  These ordinals are the
 * symbol types N_TEXT, N_DATA, N_BSS or N_ABS.  In Mach-O object files these
 * ordinals refer to the sections in the object file in the order their section
 * structures appear in the headers of the object file they are in.  The first
 * section has the ordinal 1, the second 2, and so on.  This means that the
 * same ordinal in two different object files could refer to two different
 * sections.  And further could have still different ordinals when combined
 * by the link-editor.  The value R_ABS is used for relocation entries for
 * absolute symbols which need no further relocation.
 *//*
 * For RISC machines some of the references are split across two instructions
 * and the instruction does not contain the complete value of the reference.
 * In these cases a second, or paired relocation entry, follows each of these
 * relocation entries, using a PAIR r_type, which contains the other part of the
 * reference not contained in the instruction.  This other part is stored in the
 * pair's r_address field.  The exact number of bits of the other part of the
 * reference store in the r_address field is dependent on the particular
 * relocation type for the particular architecture.
 *//*
 * To make scattered loading by the link editor work correctly "local"
 * relocation entries can't be used when the item to be relocated is the value
 * of a symbol plus an offset (where the resulting expression is outside the
 * block the link editor is moving, a blocks are divided at symbol addresses).
 * In this case. where the item is a symbol value plus offset, the link editor
 * needs to know more than just the section the symbol was defined.  What is
 * needed is the actual value of the symbol without the offset so it can do the
 * relocation correctly based on where the value of the symbol got relocated to
 * not the value of the expression (with the offset added to the symbol value).
 * So for the NeXT 2.0 release no "local" relocation entries are ever used when
 * there is a non-zero offset added to a symbol.  The "external" and "local"
 * relocation entries remain unchanged.
 *
 * The implementation is quite messy given the compatibility with the existing
 * relocation entry format.  The ASSUMPTION is that a section will never be
 * bigger than 2**24 - 1 (0x00ffffff or 16,777,215) bytes.  This assumption
 * allows the r_address (which is really an offset) to fit in 24 bits and high
 * bit of the r_address field in the relocation_info structure to indicate
 * it is really a scattered_relocation_info structure.  Since these are only
 * used in places where "local" relocation entries are used and not where
 * "external" relocation entries are used the r_extern field has been removed.
 *
 * For scattered loading to work on a RISC machine where some of the references
 * are split across two instructions the link editor needs to be assured that
 * each reference has a unique 32 bit reference (that more than one reference is
 * NOT sharing the same high 16 bits for example) so it move each referenced
 * item independent of each other.  Some compilers guarantees this but the
 * compilers don't so scattered loading can be done on those that do guarantee
 * this.
 */// Definitions from "/usr/include/mach-o/arm/reloc.h".// Definitions from "/usr/include/mach-o/arm64/reloc.h".// Definitions from "/usr/include/mach-o/ppc/reloc.h".// Definitions from "/usr/include/mach-o/x86_64/reloc.h".IMAGE_DOS_SIGNATURE/// MZIMAGE_OS2_SIGNATURE/// NEIMAGE_OS2_SIGNATURE_LE/// LEIMAGE_VXD_SIGNATUREIMAGE_NT_SIGNATURE/// PE00e_magic/// Magic numbere_cblp/// Bytes on last page of filee_cp/// Pages in filee_crlc/// Relocationse_cparhdr/// Size of header in paragraphse_minalloc/// Minimum extra paragraphs needede_maxalloc/// Maximum extra paragraphs needede_ss/// Initial (relative) SS valuee_sp/// Initial SP valuee_csume_ip/// Initial IP valuee_cs/// Initial (relative) CS valuee_lfarlc/// File address of relocation tablee_ovno/// Overlay numbere_res/// Reserved wordse_oemid/// OEM identifier (for e_oeminfo)e_oeminfo/// OEM information; e_oemid specifice_res2e_lfanew/// File address of new exe header/// DOS .EXE headerne_magicne_ver/// Version numberne_rev/// Revision numberne_enttab/// Offset of Entry Tablene_cbenttab/// Number of bytes in Entry Tablene_crc/// Checksum of whole filene_flags/// Flag wordne_autodata/// Automatic data segment numberne_heap/// Initial heap allocationne_stack/// Initial stack allocationne_csip/// Initial CS:IP settingne_sssp/// Initial SS:SP settingne_cseg/// Count of file segmentsne_cmod/// Entries in Module Reference Tablene_cbnrestab/// Size of non-resident name tablene_segtab/// Offset of Segment Tablene_rsrctab/// Offset of Resource Tablene_restab/// Offset of resident name tablene_modtab/// Offset of Module Reference Tablene_imptab/// Offset of Imported Names Tablene_nrestab/// Offset of Non-resident Names Tablene_cmovent/// Count of movable entriesne_align/// Segment alignment shift countne_cres/// Count of resource segmentsne_exetyp/// Target Operating systemne_flagsothers/// Other .EXE flagsne_pretthunks/// offset to return thunksne_psegrefbytes/// offset to segment ref. bytesne_swaparea/// Minimum code swap area sizene_expver/// Expected Windows version numberImageOs2Header/// OS/2 .EXE headere32_magice32_border/// The byte ordering for the VXDe32_worder/// The word ordering for the VXDe32_level/// The EXE format level for now = 0e32_cpu/// The CPU typee32_os/// The OS typee32_ver/// Module versione32_mflags/// Module flagse32_mpages/// Module # pagese32_startobj/// Object # for instruction pointere32_eip/// Extended instruction pointere32_stackobj/// Object # for stack pointere32_esp/// Extended stack pointere32_pagesize/// VXD page sizee32_lastpagesize/// Last page size in VXDe32_fixupsize/// Fixup section sizee32_fixupsum/// Fixup section checksume32_ldrsize/// Loader section sizee32_ldrsum/// Loader section checksume32_objtab/// Object table offsete32_objcnt/// Number of objects in modulee32_objmap/// Object page map offsete32_itermap/// Object iterated data map offsete32_rsrctabe32_rsrccnt/// Number of resource entriese32_restabe32_enttabe32_dirtab/// Offset of Module Directive Tablee32_dircnt/// Number of module directivese32_fpagetab/// Offset of Fixup Page Tablee32_frectab/// Offset of Fixup Record Tablee32_impmod/// Offset of Import Module Name Tablee32_impmodcnt/// Number of entries in Import Module Name Tablee32_impproc/// Offset of Import Procedure Name Tablee32_pagesum/// Offset of Per-Page Checksum Tablee32_datapage/// Offset of Enumerated Data Pagese32_preload/// Number of preload pagese32_nrestabe32_cbnrestab/// Size of Non-resident Name Tablee32_nressum/// Non-resident Name Table Checksume32_autodata/// Object # for automatic data objecte32_debuginfo/// Offset of the debugging informatione32_debuglen/// The length of the debugging info. in bytese32_instpreload/// Number of instance pages in preload section of VXD filee32_instdemand/// Number of instance pages in demand load section of VXD filee32_heapsize/// Size of heap - for 16-bit appse32_res3e32_winresoffe32_winreslene32_devid/// Device ID for VxDe32_ddkver/// DDK version for VxDImageVxdHeader/// Windows VXD headermasked_comp_idmasked_countMaskedRichHeaderEntry/// A PE rich header entry./// Rich headers have no official documentation, but have been heavily/// reversed-engineered and documented in the wild, e.g.:/// * `http://www.ntcore.com/files/richsign.htm`/// * `https://www.researchgate.net/figure/Structure-of-the-Rich-Header_fig1_318145388`/// This data is "masked", i.e. XORed with a checksum derived from the file data.number_of_sectionstime_date_stamppointer_to_symbol_tablenumber_of_symbolssize_of_optional_headerImageFileHeaderIMAGE_SIZEOF_FILE_HEADERIMAGE_FILE_RELOCS_STRIPPED/// Relocation info stripped from file.IMAGE_FILE_EXECUTABLE_IMAGE/// File is executable  (i.e. no unresolved external references).IMAGE_FILE_LINE_NUMS_STRIPPED/// Line numbers stripped from file.IMAGE_FILE_LOCAL_SYMS_STRIPPED/// Local symbols stripped from file.IMAGE_FILE_AGGRESIVE_WS_TRIM/// Aggressively trim working setIMAGE_FILE_LARGE_ADDRESS_AWARE/// App can handle >2gb addressesIMAGE_FILE_BYTES_REVERSED_LO/// Bytes of machine word are reversed.IMAGE_FILE_32BIT_MACHINE/// 32 bit word machine.IMAGE_FILE_DEBUG_STRIPPED/// Debugging info stripped from file in .DBG fileIMAGE_FILE_REMOVABLE_RUN_FROM_SWAP/// If Image is on removable media, copy and run from the swap file.IMAGE_FILE_NET_RUN_FROM_SWAP/// If Image is on Net, copy and run from the swap file.IMAGE_FILE_SYSTEM/// System File.IMAGE_FILE_DLL/// File is a DLL.IMAGE_FILE_UP_SYSTEM_ONLY/// File should only be run on a UP machineIMAGE_FILE_BYTES_REVERSED_HIIMAGE_FILE_MACHINE_UNKNOWNIMAGE_FILE_MACHINE_TARGET_HOST/// Useful for indicating we want to interact with the host and not a WoW guest.IMAGE_FILE_MACHINE_I386/// Intel 386.IMAGE_FILE_MACHINE_R3000/// MIPS little-endian, 0x160 big-endianIMAGE_FILE_MACHINE_R4000/// MIPS little-endianIMAGE_FILE_MACHINE_R10000IMAGE_FILE_MACHINE_WCEMIPSV2/// MIPS little-endian WCE v2IMAGE_FILE_MACHINE_ALPHA/// Alpha_AXPIMAGE_FILE_MACHINE_SH3/// SH3 little-endianIMAGE_FILE_MACHINE_SH3DSPIMAGE_FILE_MACHINE_SH3E/// SH3E little-endianIMAGE_FILE_MACHINE_SH4/// SH4 little-endianIMAGE_FILE_MACHINE_SH5/// SH5IMAGE_FILE_MACHINE_ARM/// ARM Little-EndianIMAGE_FILE_MACHINE_THUMB/// ARM Thumb/Thumb-2 Little-EndianIMAGE_FILE_MACHINE_ARMNT/// ARM Thumb-2 Little-EndianIMAGE_FILE_MACHINE_AM33IMAGE_FILE_MACHINE_POWERPC/// IBM PowerPC Little-EndianIMAGE_FILE_MACHINE_POWERPCFPIMAGE_FILE_MACHINE_IA64/// Intel 64IMAGE_FILE_MACHINE_MIPS16/// MIPSIMAGE_FILE_MACHINE_ALPHA64/// ALPHA64IMAGE_FILE_MACHINE_MIPSFPUIMAGE_FILE_MACHINE_MIPSFPU16IMAGE_FILE_MACHINE_AXP64IMAGE_FILE_MACHINE_TRICORE/// InfineonIMAGE_FILE_MACHINE_CEFIMAGE_FILE_MACHINE_EBC/// EFI Byte Code/// AMD64 (K8)IMAGE_FILE_MACHINE_M32R/// M32R little-endianIMAGE_FILE_MACHINE_ARM64/// ARM64 Little-EndianIMAGE_FILE_MACHINE_ARM64EC/// ARM64EC ("Emulation Compatible")IMAGE_FILE_MACHINE_CEEIMAGE_FILE_MACHINE_RISCV32/// RISCV32IMAGE_FILE_MACHINE_RISCV64/// RISCV64IMAGE_FILE_MACHINE_RISCV128/// RISCV128virtual_addressImageDataDirectoryIMAGE_NUMBEROF_DIRECTORY_ENTRIES// Standard fields.major_linker_versionminor_linker_versionsize_of_codesize_of_initialized_datasize_of_uninitialized_dataaddress_of_entry_pointbase_of_codebase_of_dataimage_base// NT additional fields.section_alignmentfile_alignmentmajor_operating_system_versionminor_operating_system_versionmajor_image_versionminor_image_versionmajor_subsystem_versionminor_subsystem_versionwin32_version_valuesize_of_imagesize_of_headerscheck_sumsubsystemdll_characteristicssize_of_stack_reservesize_of_stack_commitsize_of_heap_reservesize_of_heap_commitloader_flagsnumber_of_rva_and_sizes//pub data_directory: [ImageDataDirectory; IMAGE_NUMBEROF_DIRECTORY_ENTRIES],ImageOptionalHeader32base_of_bssgpr_maskcpr_maskgp_valueImageRomOptionalHeaderImageOptionalHeader64IMAGE_NT_OPTIONAL_HDR32_MAGICIMAGE_NT_OPTIONAL_HDR64_MAGICIMAGE_ROM_OPTIONAL_HDR_MAGICfile_headeroptional_headerImageRomHeadersIMAGE_SUBSYSTEM_UNKNOWN/// Unknown subsystem.IMAGE_SUBSYSTEM_NATIVE/// Image doesn't require a subsystem.IMAGE_SUBSYSTEM_WINDOWS_GUI/// Image runs in the Windows GUI subsystem.IMAGE_SUBSYSTEM_WINDOWS_CUI/// Image runs in the Windows character subsystem.IMAGE_SUBSYSTEM_OS2_CUI/// image runs in the OS/2 character subsystem.IMAGE_SUBSYSTEM_POSIX_CUI/// image runs in the Posix character subsystem.IMAGE_SUBSYSTEM_NATIVE_WINDOWS/// image is a native Win9x driver.IMAGE_SUBSYSTEM_WINDOWS_CE_GUI/// Image runs in the Windows CE subsystem.IMAGE_SUBSYSTEM_EFI_APPLICATIONIMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVERIMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVERIMAGE_SUBSYSTEM_EFI_ROMIMAGE_SUBSYSTEM_XBOXIMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATIONIMAGE_SUBSYSTEM_XBOX_CODE_CATALOGIMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA//      IMAGE_LIBRARY_PROCESS_INIT            0x0001     // Reserved.//      IMAGE_LIBRARY_PROCESS_TERM            0x0002     // Reserved.//      IMAGE_LIBRARY_THREAD_INIT             0x0004     // Reserved.//      IMAGE_LIBRARY_THREAD_TERM             0x0008     // Reserved./// Image can handle a high entropy 64-bit virtual address space.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE/// DLL can move.IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY/// Code Integrity ImageIMAGE_DLLCHARACTERISTICS_NX_COMPAT/// Image is NX compatibleIMAGE_DLLCHARACTERISTICS_NO_ISOLATION/// Image understands isolation and doesn't want itIMAGE_DLLCHARACTERISTICS_NO_SEH/// Image does not use SEH.  No SE handler may reside in this imageIMAGE_DLLCHARACTERISTICS_NO_BIND/// Do not bind this image.IMAGE_DLLCHARACTERISTICS_APPCONTAINER/// Image should execute in an AppContainerIMAGE_DLLCHARACTERISTICS_WDM_DRIVER/// Driver uses WDM modelIMAGE_DLLCHARACTERISTICS_GUARD_CF/// Image supports Control Flow Guard.IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWAREIMAGE_DIRECTORY_ENTRY_EXPORT/// Export DirectoryIMAGE_DIRECTORY_ENTRY_IMPORT/// Import DirectoryIMAGE_DIRECTORY_ENTRY_RESOURCE/// Resource DirectoryIMAGE_DIRECTORY_ENTRY_EXCEPTION/// Exception DirectoryIMAGE_DIRECTORY_ENTRY_SECURITY/// Security DirectoryIMAGE_DIRECTORY_ENTRY_BASERELOC/// Base Relocation TableIMAGE_DIRECTORY_ENTRY_DEBUG/// Debug DirectoryIMAGE_DIRECTORY_ENTRY_ARCHITECTURE//      IMAGE_DIRECTORY_ENTRY_COPYRIGHT       7   // (X86 usage)/// Architecture Specific DataIMAGE_DIRECTORY_ENTRY_GLOBALPTR/// RVA of GPIMAGE_DIRECTORY_ENTRY_TLS/// TLS DirectoryIMAGE_DIRECTORY_ENTRY_LOAD_CONFIG/// Load Configuration DirectoryIMAGE_DIRECTORY_ENTRY_BOUND_IMPORT/// Bound Import Directory in headersIMAGE_DIRECTORY_ENTRY_IAT/// Import Address TableIMAGE_DIRECTORY_ENTRY_DELAY_IMPORT/// Delay Load Import DescriptorsIMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR/// COM Runtime descriptorGuidClsIdsig1/// Must be IMAGE_FILE_MACHINE_UNKNOWNsig2/// Must be 0xffff/// >= 1 (implies the ClsId field is present)class_id/// Used to invoke CoCreateInstancesize_of_data/// Size of data that follows the headerAnonObjectHeader/// Non-COFF Object file header/// >= 2 (implies the Flags field is present - otherwise V1)/// 0x1 -> contains metadatameta_data_size/// Size of CLR metadatameta_data_offset/// Offset of CLR metadataAnonObjectHeaderV2ANON_OBJECT_HEADER_BIGOBJ_CLASS_ID/// The required value of `AnonObjectHeaderBigobj::class_id`./* same as ANON_OBJECT_HEADER_V2 *//// >= 2 (implies the Flags field is present)/// Actual machine - IMAGE_FILE_MACHINE_xxx/// Must be `ANON_OBJECT_HEADER_BIGOBJ_CLASS_ID`./* bigobj specifics *//// extended from WORDAnonObjectHeaderBigobjIMAGE_SIZEOF_SHORT_NAMEvirtual_sizesize_of_raw_datapointer_to_raw_datapointer_to_relocationspointer_to_linenumbersnumber_of_relocationsnumber_of_linenumbersImageSectionHeaderIMAGE_SIZEOF_SECTION_HEADERIMAGE_SCN_TYPE_NO_PAD//      IMAGE_SCN_TYPE_REG                   0x00000000  // Reserved.//      IMAGE_SCN_TYPE_DSECT                 0x00000001  // Reserved.//      IMAGE_SCN_TYPE_NOLOAD                0x00000002  // Reserved.//      IMAGE_SCN_TYPE_GROUP                 0x00000004  // Reserved.IMAGE_SCN_CNT_CODE/// Section contains code.IMAGE_SCN_CNT_INITIALIZED_DATA/// Section contains initialized data.IMAGE_SCN_CNT_UNINITIALIZED_DATA/// Section contains uninitialized data.IMAGE_SCN_LNK_OTHERIMAGE_SCN_LNK_INFO/// Section contains comments or some other type of information.IMAGE_SCN_LNK_REMOVE//      IMAGE_SCN_TYPE_OVER                  0x00000400  // Reserved./// Section contents will not become part of image.IMAGE_SCN_LNK_COMDAT/// Section contents comdat.IMAGE_SCN_NO_DEFER_SPEC_EXC//                                           0x00002000  // Reserved.//      IMAGE_SCN_MEM_PROTECTED - Obsolete   0x00004000/// Reset speculative exceptions handling bits in the TLB entries for this section.IMAGE_SCN_GPREL/// Section content can be accessed relative to GPIMAGE_SCN_MEM_FARDATAIMAGE_SCN_MEM_PURGEABLE//      IMAGE_SCN_MEM_SYSHEAP  - Obsolete    0x00010000IMAGE_SCN_MEM_16BITIMAGE_SCN_MEM_LOCKEDIMAGE_SCN_MEM_PRELOADIMAGE_SCN_ALIGN_1BYTESIMAGE_SCN_ALIGN_2BYTESIMAGE_SCN_ALIGN_4BYTESIMAGE_SCN_ALIGN_8BYTESIMAGE_SCN_ALIGN_16BYTES/// Default alignment if no others are specified.IMAGE_SCN_ALIGN_32BYTESIMAGE_SCN_ALIGN_64BYTESIMAGE_SCN_ALIGN_128BYTESIMAGE_SCN_ALIGN_256BYTESIMAGE_SCN_ALIGN_512BYTESIMAGE_SCN_ALIGN_1024BYTESIMAGE_SCN_ALIGN_2048BYTESIMAGE_SCN_ALIGN_4096BYTESIMAGE_SCN_ALIGN_8192BYTESIMAGE_SCN_ALIGN_MASK// Unused                                    0x00F0_0000IMAGE_SCN_LNK_NRELOC_OVFL/// Section contains extended relocations.IMAGE_SCN_MEM_DISCARDABLE/// Section can be discarded.IMAGE_SCN_MEM_NOT_CACHED/// Section is not cacheable.IMAGE_SCN_MEM_NOT_PAGED/// Section is not pageable.IMAGE_SCN_MEM_SHARED/// Section is shareable.IMAGE_SCN_MEM_EXECUTEIMAGE_SCN_MEM_READ/// Section is readable.IMAGE_SCN_MEM_WRITE/// Section is writeable.IMAGE_SCN_SCALE_INDEX// TLS Characteristic Flags/// Tls index is scaled/// If first 4 bytes are 0, then second 4 bytes are offset into string table.section_numberstorage_classnumber_of_aux_symbols// This struct has alignment 1.IMAGE_SIZEOF_SYMBOLImageSymbolBytesImageSymbolExIMAGE_SIZEOF_SYMBOL_EXImageSymbolExBytesIMAGE_SYM_UNDEFINED/// Symbol is undefined or is common.IMAGE_SYM_ABSOLUTE/// Symbol is an absolute value.IMAGE_SYM_DEBUG/// Symbol is a special debug item.IMAGE_SYM_SECTION_MAX/// Values 0xFF00-0xFFFF are specialIMAGE_SYM_SECTION_MAX_EXIMAGE_SYM_TYPE_NULL/// no type.IMAGE_SYM_TYPE_VOIDIMAGE_SYM_TYPE_CHAR/// type character.IMAGE_SYM_TYPE_SHORT/// type short integer.IMAGE_SYM_TYPE_INTIMAGE_SYM_TYPE_LONGIMAGE_SYM_TYPE_FLOATIMAGE_SYM_TYPE_DOUBLEIMAGE_SYM_TYPE_STRUCTIMAGE_SYM_TYPE_UNIONIMAGE_SYM_TYPE_ENUM/// enumeration.IMAGE_SYM_TYPE_MOE/// member of enumeration.IMAGE_SYM_TYPE_BYTEIMAGE_SYM_TYPE_WORDIMAGE_SYM_TYPE_UINTIMAGE_SYM_TYPE_DWORDIMAGE_SYM_TYPE_PCODEIMAGE_SYM_DTYPE_NULL/// no derived type.IMAGE_SYM_DTYPE_POINTERIMAGE_SYM_DTYPE_FUNCTIONIMAGE_SYM_DTYPE_ARRAYIMAGE_SYM_CLASS_END_OF_FUNCTION// Values for `ImageSymbol::storage_class`.IMAGE_SYM_CLASS_NULLIMAGE_SYM_CLASS_AUTOMATICIMAGE_SYM_CLASS_EXTERNALIMAGE_SYM_CLASS_STATICIMAGE_SYM_CLASS_REGISTERIMAGE_SYM_CLASS_EXTERNAL_DEFIMAGE_SYM_CLASS_LABELIMAGE_SYM_CLASS_UNDEFINED_LABELIMAGE_SYM_CLASS_MEMBER_OF_STRUCTIMAGE_SYM_CLASS_ARGUMENTIMAGE_SYM_CLASS_STRUCT_TAGIMAGE_SYM_CLASS_MEMBER_OF_UNIONIMAGE_SYM_CLASS_UNION_TAGIMAGE_SYM_CLASS_TYPE_DEFINITIONIMAGE_SYM_CLASS_UNDEFINED_STATICIMAGE_SYM_CLASS_ENUM_TAGIMAGE_SYM_CLASS_MEMBER_OF_ENUMIMAGE_SYM_CLASS_REGISTER_PARAMIMAGE_SYM_CLASS_BIT_FIELDIMAGE_SYM_CLASS_FAR_EXTERNALIMAGE_SYM_CLASS_BLOCKIMAGE_SYM_CLASS_FUNCTIONIMAGE_SYM_CLASS_END_OF_STRUCTIMAGE_SYM_CLASS_FILEIMAGE_SYM_CLASS_SECTION// newIMAGE_SYM_CLASS_WEAK_EXTERNALIMAGE_SYM_CLASS_CLR_TOKENN_BTMASKN_TMASKN_TMASK1N_TMASK2N_BTSHFTN_TSHIFTIMAGE_SYM_DTYPE_SHIFTaux_type/// IMAGE_AUX_SYMBOL_TYPE/// Must be 0symbol_table_indexImageAuxSymbolTokenDef// Used for both ImageSymbol and ImageSymbolEx (with padding).IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEFtag_indextotal_sizepointer_to_linenumberpointer_to_next_functionImageAuxSymbolFunction/// Auxiliary symbol format 1: function definitions.linenumber/// declaration line numberImageAuxSymbolFunctionBeginEnd/// Auxiliary symbol format 2: .bf and .ef symbols.weak_default_sym_index/// the weak extern default symbol indexweak_search_typeImageAuxSymbolWeak/// Auxiliary symbol format 3: weak externals./// Used for both `ImageSymbol` and `ImageSymbolEx` (both with padding)./// section length/// number of line numbers/// checksum for communal/// section number to associate with/// communal selection typehigh_number/// high bits of the section numberImageAuxSymbolSection/// Auxiliary symbol format 5: sections./// Used for both `ImageSymbol` and `ImageSymbolEx` (with padding).ImageAuxSymbolCrc// Used for both ImageSymbol and ImageSymbolEx (both with padding).IMAGE_COMDAT_SELECT_NODUPLICATESIMAGE_COMDAT_SELECT_ANYIMAGE_COMDAT_SELECT_SAME_SIZEIMAGE_COMDAT_SELECT_EXACT_MATCHIMAGE_COMDAT_SELECT_ASSOCIATIVEIMAGE_COMDAT_SELECT_LARGESTIMAGE_COMDAT_SELECT_NEWESTIMAGE_WEAK_EXTERN_SEARCH_NOLIBRARYIMAGE_WEAK_EXTERN_SEARCH_LIBRARYIMAGE_WEAK_EXTERN_SEARCH_ALIASIMAGE_WEAK_EXTERN_ANTI_DEPENDENCY/// Also `RelocCount` when IMAGE_SCN_LNK_NRELOC_OVFL is setImageRelocationIMAGE_REL_I386_ABSOLUTE// I386 relocation types./// Reference is absolute, no relocation is necessaryIMAGE_REL_I386_DIR16/// Direct 16-bit reference to the symbols virtual addressIMAGE_REL_I386_REL16/// PC-relative 16-bit reference to the symbols virtual addressIMAGE_REL_I386_DIR32/// Direct 32-bit reference to the symbols virtual addressIMAGE_REL_I386_DIR32NB/// Direct 32-bit reference to the symbols virtual address, base not includedIMAGE_REL_I386_SEG12/// Direct 16-bit reference to the segment-selector bits of a 32-bit virtual addressIMAGE_REL_I386_SECTIONIMAGE_REL_I386_SECRELIMAGE_REL_I386_TOKEN/// clr tokenIMAGE_REL_I386_SECREL7/// 7 bit offset from base of section containing targetIMAGE_REL_I386_REL32/// PC-relative 32-bit reference to the symbols virtual addressIMAGE_REL_MIPS_ABSOLUTE// MIPS relocation types.IMAGE_REL_MIPS_REFHALFIMAGE_REL_MIPS_REFWORDIMAGE_REL_MIPS_JMPADDRIMAGE_REL_MIPS_REFHIIMAGE_REL_MIPS_REFLOIMAGE_REL_MIPS_GPRELIMAGE_REL_MIPS_LITERALIMAGE_REL_MIPS_SECTIONIMAGE_REL_MIPS_SECRELIMAGE_REL_MIPS_SECRELLO/// Low 16-bit section relative reference (used for >32k TLS)IMAGE_REL_MIPS_SECRELHI/// High 16-bit section relative reference (used for >32k TLS)IMAGE_REL_MIPS_TOKENIMAGE_REL_MIPS_JMPADDR16IMAGE_REL_MIPS_REFWORDNBIMAGE_REL_MIPS_PAIRIMAGE_REL_ALPHA_ABSOLUTE// Alpha Relocation types.IMAGE_REL_ALPHA_REFLONGIMAGE_REL_ALPHA_REFQUADIMAGE_REL_ALPHA_GPREL32IMAGE_REL_ALPHA_LITERALIMAGE_REL_ALPHA_LITUSEIMAGE_REL_ALPHA_GPDISPIMAGE_REL_ALPHA_BRADDRIMAGE_REL_ALPHA_HINTIMAGE_REL_ALPHA_INLINE_REFLONGIMAGE_REL_ALPHA_REFHIIMAGE_REL_ALPHA_REFLOIMAGE_REL_ALPHA_PAIRIMAGE_REL_ALPHA_MATCHIMAGE_REL_ALPHA_SECTIONIMAGE_REL_ALPHA_SECRELIMAGE_REL_ALPHA_REFLONGNBIMAGE_REL_ALPHA_SECRELLO/// Low 16-bit section relative referenceIMAGE_REL_ALPHA_SECRELHI/// High 16-bit section relative referenceIMAGE_REL_ALPHA_REFQ3/// High 16 bits of 48 bit referenceIMAGE_REL_ALPHA_REFQ2/// Middle 16 bits of 48 bit referenceIMAGE_REL_ALPHA_REFQ1/// Low 16 bits of 48 bit referenceIMAGE_REL_ALPHA_GPRELLO/// Low 16-bit GP relative referenceIMAGE_REL_ALPHA_GPRELHI/// High 16-bit GP relative referenceIMAGE_REL_PPC_ABSOLUTE// IBM PowerPC relocation types./// NOPIMAGE_REL_PPC_ADDR64/// 64-bit addressIMAGE_REL_PPC_ADDR32/// 32-bit addressIMAGE_REL_PPC_ADDR24/// 26-bit address, shifted left 2 (branch absolute)IMAGE_REL_PPC_ADDR16/// 16-bit addressIMAGE_REL_PPC_ADDR14/// 16-bit address, shifted left 2 (load doubleword)IMAGE_REL_PPC_REL24/// 26-bit PC-relative offset, shifted left 2 (branch relative)IMAGE_REL_PPC_REL14/// 16-bit PC-relative offset, shifted left 2 (br cond relative)IMAGE_REL_PPC_TOCREL16/// 16-bit offset from TOC baseIMAGE_REL_PPC_TOCREL14/// 16-bit offset from TOC base, shifted left 2 (load doubleword)IMAGE_REL_PPC_ADDR32NB/// 32-bit addr w/o image baseIMAGE_REL_PPC_SECREL/// va of containing section (as in an image sectionhdr)IMAGE_REL_PPC_SECTION/// sectionheader numberIMAGE_REL_PPC_IFGLUE/// substitute TOC restore instruction iff symbol is glue codeIMAGE_REL_PPC_IMGLUE/// symbol is glue code; virtual address is TOC restore instructionIMAGE_REL_PPC_SECREL16/// va of containing section (limited to 16 bits)IMAGE_REL_PPC_REFHIIMAGE_REL_PPC_REFLOIMAGE_REL_PPC_PAIRIMAGE_REL_PPC_SECRELLOIMAGE_REL_PPC_SECRELHIIMAGE_REL_PPC_GPRELIMAGE_REL_PPC_TOKENIMAGE_REL_PPC_TYPEMASK/// mask to isolate above values in IMAGE_RELOCATION.TypeIMAGE_REL_PPC_NEG/// subtract reloc value rather than adding itIMAGE_REL_PPC_BRTAKEN/// fix branch prediction bit to predict branch takenIMAGE_REL_PPC_BRNTAKEN/// fix branch prediction bit to predict branch not takenIMAGE_REL_PPC_TOCDEFN/// toc slot defined in file (or, data in toc)IMAGE_REL_SH3_ABSOLUTE// Hitachi SH3 relocation types./// No relocationIMAGE_REL_SH3_DIRECT16/// 16 bit directIMAGE_REL_SH3_DIRECT32/// 32 bit directIMAGE_REL_SH3_DIRECT8/// 8 bit direct, -128..255IMAGE_REL_SH3_DIRECT8_WORD/// 8 bit direct .W (0 ext.)IMAGE_REL_SH3_DIRECT8_LONG/// 8 bit direct .L (0 ext.)IMAGE_REL_SH3_DIRECT4/// 4 bit direct (0 ext.)IMAGE_REL_SH3_DIRECT4_WORD/// 4 bit direct .W (0 ext.)IMAGE_REL_SH3_DIRECT4_LONG/// 4 bit direct .L (0 ext.)IMAGE_REL_SH3_PCREL8_WORD/// 8 bit PC relative .WIMAGE_REL_SH3_PCREL8_LONG/// 8 bit PC relative .LIMAGE_REL_SH3_PCREL12_WORD/// 12 LSB PC relative .WIMAGE_REL_SH3_STARTOF_SECTION/// Start of EXE sectionIMAGE_REL_SH3_SIZEOF_SECTION/// Size of EXE sectionIMAGE_REL_SH3_SECTION/// Section table indexIMAGE_REL_SH3_SECREL/// Offset within sectionIMAGE_REL_SH3_DIRECT32_NB/// 32 bit direct not basedIMAGE_REL_SH3_GPREL4_LONG/// GP-relative addressingIMAGE_REL_SH3_TOKENIMAGE_REL_SHM_PCRELPT/// Offset from current instruction in longwords/// if not NOMODE, insert the inverse of the low bit at bit 32 to select PTA/PTBIMAGE_REL_SHM_REFLO/// Low bits of 32-bit addressIMAGE_REL_SHM_REFHALF/// High bits of 32-bit addressIMAGE_REL_SHM_RELLO/// Low bits of relative referenceIMAGE_REL_SHM_RELHALF/// High bits of relative referenceIMAGE_REL_SHM_PAIR/// offset operand for relocationIMAGE_REL_SH_NOMODE/// relocation ignores section modeIMAGE_REL_ARM_ABSOLUTE/// No relocation requiredIMAGE_REL_ARM_ADDR32/// 32 bit addressIMAGE_REL_ARM_ADDR32NB/// 32 bit address w/o image baseIMAGE_REL_ARM_BRANCH24/// 24 bit offset << 2 & sign ext.IMAGE_REL_ARM_BRANCH11/// Thumb: 2 11 bit offsetsIMAGE_REL_ARM_TOKENIMAGE_REL_ARM_GPREL12/// GP-relative addressing (ARM)IMAGE_REL_ARM_GPREL7/// GP-relative addressing (Thumb)IMAGE_REL_ARM_BLX24IMAGE_REL_ARM_BLX11IMAGE_REL_ARM_REL32/// 32-bit relative address from byte following relocIMAGE_REL_ARM_SECTIONIMAGE_REL_ARM_SECRELIMAGE_REL_ARM_MOV32A/// ARM: MOVW/MOVTIMAGE_REL_ARM_MOV32/// ARM: MOVW/MOVT (deprecated)IMAGE_REL_ARM_MOV32T/// Thumb: MOVW/MOVTIMAGE_REL_THUMB_MOV32/// Thumb: MOVW/MOVT (deprecated)IMAGE_REL_ARM_BRANCH20T/// Thumb: 32-bit conditional BIMAGE_REL_THUMB_BRANCH20/// Thumb: 32-bit conditional B (deprecated)IMAGE_REL_ARM_BRANCH24T/// Thumb: 32-bit B or BLIMAGE_REL_THUMB_BRANCH24/// Thumb: 32-bit B or BL (deprecated)IMAGE_REL_ARM_BLX23T/// Thumb: BLX immediateIMAGE_REL_THUMB_BLX23/// Thumb: BLX immediate (deprecated)IMAGE_REL_AM_ABSOLUTEIMAGE_REL_AM_ADDR32IMAGE_REL_AM_ADDR32NBIMAGE_REL_AM_CALL32IMAGE_REL_AM_FUNCINFOIMAGE_REL_AM_REL32_1IMAGE_REL_AM_REL32_2IMAGE_REL_AM_SECRELIMAGE_REL_AM_SECTIONIMAGE_REL_AM_TOKENIMAGE_REL_ARM64_ABSOLUTEIMAGE_REL_ARM64_ADDR32/// 32 bit address. Review! do we need it?IMAGE_REL_ARM64_ADDR32NB/// 32 bit address w/o image base (RVA: for Data/PData/XData)IMAGE_REL_ARM64_BRANCH26/// 26 bit offset << 2 & sign ext. for B & BLIMAGE_REL_ARM64_PAGEBASE_REL21/// ADRPIMAGE_REL_ARM64_REL21/// ADRIMAGE_REL_ARM64_PAGEOFFSET_12A/// ADD/ADDS (immediate) with zero shift, for page offsetIMAGE_REL_ARM64_PAGEOFFSET_12L/// LDR (indexed, unsigned immediate), for page offsetIMAGE_REL_ARM64_SECRELIMAGE_REL_ARM64_SECREL_LOW12A/// ADD/ADDS (immediate) with zero shift, for bit 0:11 of section offsetIMAGE_REL_ARM64_SECREL_HIGH12A/// ADD/ADDS (immediate) with zero shift, for bit 12:23 of section offsetIMAGE_REL_ARM64_SECREL_LOW12L/// LDR (indexed, unsigned immediate), for bit 0:11 of section offsetIMAGE_REL_ARM64_TOKENIMAGE_REL_ARM64_SECTIONIMAGE_REL_ARM64_ADDR64/// 64 bit addressIMAGE_REL_ARM64_BRANCH19/// 19 bit offset << 2 & sign ext. for conditional BIMAGE_REL_ARM64_BRANCH14/// TBZ/TBNZIMAGE_REL_ARM64_REL32IMAGE_REL_AMD64_ABSOLUTE// x64 relocationsIMAGE_REL_AMD64_ADDR64/// 64-bit address (VA).IMAGE_REL_AMD64_ADDR32/// 32-bit address (VA).IMAGE_REL_AMD64_ADDR32NB/// 32-bit address w/o image base (RVA).IMAGE_REL_AMD64_REL32IMAGE_REL_AMD64_REL32_1/// 32-bit relative address from byte distance 1 from relocIMAGE_REL_AMD64_REL32_2/// 32-bit relative address from byte distance 2 from relocIMAGE_REL_AMD64_REL32_3/// 32-bit relative address from byte distance 3 from relocIMAGE_REL_AMD64_REL32_4/// 32-bit relative address from byte distance 4 from relocIMAGE_REL_AMD64_REL32_5/// 32-bit relative address from byte distance 5 from relocIMAGE_REL_AMD64_SECTION/// Section indexIMAGE_REL_AMD64_SECREL/// 32 bit offset from base of section containing targetIMAGE_REL_AMD64_SECREL7/// 7 bit unsigned offset from base of section containing targetIMAGE_REL_AMD64_TOKEN/// 32 bit metadata tokenIMAGE_REL_AMD64_SREL32/// 32 bit signed span-dependent value emitted into objectIMAGE_REL_AMD64_PAIRIMAGE_REL_AMD64_SSPAN32/// 32 bit signed span-dependent value applied at link timeIMAGE_REL_AMD64_EHANDLERIMAGE_REL_AMD64_IMPORT_BR/// Indirect branch to an importIMAGE_REL_AMD64_IMPORT_CALL/// Indirect call to an importIMAGE_REL_AMD64_CFG_BR/// Indirect branch to a CFG checkIMAGE_REL_AMD64_CFG_BR_REX/// Indirect branch to a CFG check, with REX.W prefixIMAGE_REL_AMD64_CFG_CALL/// Indirect call to a CFG checkIMAGE_REL_AMD64_INDIR_BR/// Indirect branch to a target in RAX (no CFG)IMAGE_REL_AMD64_INDIR_BR_REX/// Indirect branch to a target in RAX, with REX.W prefix (no CFG)IMAGE_REL_AMD64_INDIR_CALL/// Indirect call to a target in RAX (no CFG)IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_FIRST/// Indirect branch for a switch table using Reg 0 (RAX)IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_LAST/// Indirect branch for a switch table using Reg 15 (R15)IMAGE_REL_IA64_ABSOLUTE// IA64 relocation types.IMAGE_REL_IA64_IMM14IMAGE_REL_IA64_IMM22IMAGE_REL_IA64_IMM64IMAGE_REL_IA64_DIR32IMAGE_REL_IA64_DIR64IMAGE_REL_IA64_PCREL21BIMAGE_REL_IA64_PCREL21MIMAGE_REL_IA64_PCREL21FIMAGE_REL_IA64_GPREL22IMAGE_REL_IA64_LTOFF22IMAGE_REL_IA64_SECTIONIMAGE_REL_IA64_SECREL22IMAGE_REL_IA64_SECREL64IIMAGE_REL_IA64_SECREL32IMAGE_REL_IA64_DIR32NBIMAGE_REL_IA64_SREL14IMAGE_REL_IA64_SREL22IMAGE_REL_IA64_SREL32IMAGE_REL_IA64_UREL32IMAGE_REL_IA64_PCREL60X/// This is always a BRL and never convertedIMAGE_REL_IA64_PCREL60B/// If possible, convert to MBB bundle with NOP.B in slot 1IMAGE_REL_IA64_PCREL60F/// If possible, convert to MFB bundle with NOP.F in slot 1IMAGE_REL_IA64_PCREL60I/// If possible, convert to MIB bundle with NOP.I in slot 1IMAGE_REL_IA64_PCREL60M/// If possible, convert to MMB bundle with NOP.M in slot 1IMAGE_REL_IA64_IMMGPREL64IMAGE_REL_IA64_TOKENIMAGE_REL_IA64_GPREL32IMAGE_REL_IA64_ADDENDIMAGE_REL_CEF_ABSOLUTE// CEF relocation types.IMAGE_REL_CEF_ADDR32IMAGE_REL_CEF_ADDR64IMAGE_REL_CEF_ADDR32NBIMAGE_REL_CEF_SECTIONIMAGE_REL_CEF_SECRELIMAGE_REL_CEF_TOKENIMAGE_REL_CEE_ABSOLUTE// clr relocation types.IMAGE_REL_CEE_ADDR32IMAGE_REL_CEE_ADDR64IMAGE_REL_CEE_ADDR32NBIMAGE_REL_CEE_SECTIONIMAGE_REL_CEE_SECRELIMAGE_REL_CEE_TOKENIMAGE_REL_M32R_ABSOLUTEIMAGE_REL_M32R_ADDR32IMAGE_REL_M32R_ADDR32NBIMAGE_REL_M32R_ADDR24/// 24 bit addressIMAGE_REL_M32R_GPREL16/// GP relative addressingIMAGE_REL_M32R_PCREL24IMAGE_REL_M32R_PCREL16/// 16 bit offset << 2 & sign ext.IMAGE_REL_M32R_PCREL8/// 8 bit offset << 2 & sign ext.IMAGE_REL_M32R_REFHALF/// 16 MSBsIMAGE_REL_M32R_REFHI/// 16 MSBs; adj for LSB sign ext.IMAGE_REL_M32R_REFLO/// 16 LSBsIMAGE_REL_M32R_PAIR/// Link HI and LOIMAGE_REL_M32R_SECTIONIMAGE_REL_M32R_SECREL32/// 32 bit section relative referenceIMAGE_REL_M32R_TOKENIMAGE_REL_EBC_ABSOLUTEIMAGE_REL_EBC_ADDR32NBIMAGE_REL_EBC_REL32IMAGE_REL_EBC_SECTIONIMAGE_REL_EBC_SECRELEMARCH_ENC_I17_IMM7B_INST_WORD_X/// Intel-IA64-FillerEMARCH_ENC_I17_IMM7B_SIZE_XEMARCH_ENC_I17_IMM7B_INST_WORD_POS_XEMARCH_ENC_I17_IMM7B_VAL_POS_XEMARCH_ENC_I17_IMM9D_INST_WORD_XEMARCH_ENC_I17_IMM9D_SIZE_XEMARCH_ENC_I17_IMM9D_INST_WORD_POS_XEMARCH_ENC_I17_IMM9D_VAL_POS_XEMARCH_ENC_I17_IMM5C_INST_WORD_XEMARCH_ENC_I17_IMM5C_SIZE_XEMARCH_ENC_I17_IMM5C_INST_WORD_POS_XEMARCH_ENC_I17_IMM5C_VAL_POS_XEMARCH_ENC_I17_IC_INST_WORD_XEMARCH_ENC_I17_IC_SIZE_XEMARCH_ENC_I17_IC_INST_WORD_POS_XEMARCH_ENC_I17_IC_VAL_POS_XEMARCH_ENC_I17_IMM41A_INST_WORD_XEMARCH_ENC_I17_IMM41A_SIZE_XEMARCH_ENC_I17_IMM41A_INST_WORD_POS_XEMARCH_ENC_I17_IMM41A_VAL_POS_XEMARCH_ENC_I17_IMM41B_INST_WORD_XEMARCH_ENC_I17_IMM41B_SIZE_XEMARCH_ENC_I17_IMM41B_INST_WORD_POS_XEMARCH_ENC_I17_IMM41B_VAL_POS_XEMARCH_ENC_I17_IMM41C_INST_WORD_XEMARCH_ENC_I17_IMM41C_SIZE_XEMARCH_ENC_I17_IMM41C_INST_WORD_POS_XEMARCH_ENC_I17_IMM41C_VAL_POS_XEMARCH_ENC_I17_SIGN_INST_WORD_XEMARCH_ENC_I17_SIGN_SIZE_XEMARCH_ENC_I17_SIGN_INST_WORD_POS_XEMARCH_ENC_I17_SIGN_VAL_POS_XX3_OPCODE_INST_WORD_XX3_OPCODE_SIZE_XX3_OPCODE_INST_WORD_POS_XX3_OPCODE_SIGN_VAL_POS_XX3_I_INST_WORD_XX3_I_SIZE_XX3_I_INST_WORD_POS_XX3_I_SIGN_VAL_POS_XX3_D_WH_INST_WORD_XX3_D_WH_SIZE_XX3_D_WH_INST_WORD_POS_XX3_D_WH_SIGN_VAL_POS_XX3_IMM20_INST_WORD_XX3_IMM20_SIZE_XX3_IMM20_INST_WORD_POS_XX3_IMM20_SIGN_VAL_POS_XX3_IMM39_1_INST_WORD_XX3_IMM39_1_SIZE_XX3_IMM39_1_INST_WORD_POS_XX3_IMM39_1_SIGN_VAL_POS_XX3_IMM39_2_INST_WORD_XX3_IMM39_2_SIZE_XX3_IMM39_2_INST_WORD_POS_XX3_IMM39_2_SIGN_VAL_POS_XX3_P_INST_WORD_XX3_P_SIZE_XX3_P_INST_WORD_POS_XX3_P_SIGN_VAL_POS_XX3_TMPLT_INST_WORD_XX3_TMPLT_SIZE_XX3_TMPLT_INST_WORD_POS_XX3_TMPLT_SIGN_VAL_POS_XX3_BTYPE_QP_INST_WORD_XX3_BTYPE_QP_SIZE_XX3_BTYPE_QP_INST_WORD_POS_XX3_BTYPE_QP_INST_VAL_POS_XX3_EMPTY_INST_WORD_XX3_EMPTY_SIZE_XX3_EMPTY_INST_WORD_POS_XX3_EMPTY_INST_VAL_POS_Xsymbol_table_index_or_virtual_address/// Symbol table index of function name if Linenumber is 0./// Otherwise virtual address of line number./// Line number.ImageLinenumbersize_of_block//  pub type_offset[1]: U16<LE>,ImageBaseRelocationIMAGE_REL_BASED_ABSOLUTEIMAGE_REL_BASED_HIGHIMAGE_REL_BASED_LOWIMAGE_REL_BASED_HIGHLOWIMAGE_REL_BASED_HIGHADJIMAGE_REL_BASED_MACHINE_SPECIFIC_5IMAGE_REL_BASED_RESERVEDIMAGE_REL_BASED_MACHINE_SPECIFIC_7IMAGE_REL_BASED_MACHINE_SPECIFIC_8IMAGE_REL_BASED_MACHINE_SPECIFIC_9IMAGE_REL_BASED_DIR64IMAGE_REL_BASED_IA64_IMM64IMAGE_REL_BASED_MIPS_JMPADDRIMAGE_REL_BASED_MIPS_JMPADDR16IMAGE_REL_BASED_ARM_MOV32IMAGE_REL_BASED_THUMB_MOV32IMAGE_REL_BASED_RISCV_HIGH20IMAGE_REL_BASED_RISCV_LOW12IIMAGE_REL_BASED_RISCV_LOW12SIMAGE_ARCHIVE_START_SIZEIMAGE_ARCHIVE_STARTIMAGE_ARCHIVE_ENDIMAGE_ARCHIVE_PADIMAGE_ARCHIVE_LINKER_MEMBERIMAGE_ARCHIVE_LONGNAMES_MEMBERIMAGE_ARCHIVE_HYBRIDMAP_MEMBER/// File member name - `/' terminated./// File member date - decimal./// File member user id - decimal./// File member group id - decimal./// File member mode - octal./// File member size - decimal.end_header/// String to end header.ImageArchiveMemberHeaderIMAGE_SIZEOF_ARCHIVE_MEMBER_HDRnumber_of_functionsnumber_of_namesaddress_of_functions/// RVA from base of imageaddress_of_namesaddress_of_name_ordinalsImageExportDirectory//pub name: [i8; 1],ImageImportByNameImageThunkData64ImageThunkData32IMAGE_ORDINAL_FLAG64IMAGE_ORDINAL_FLAG32start_address_of_raw_dataend_address_of_raw_dataaddress_of_index/// PDWORDaddress_of_call_backs/// PIMAGE_TLS_CALLBACK *;size_of_zero_fillImageTlsDirectory64/// PIMAGE_TLS_CALLBACK *ImageTlsDirectory32original_first_thunk/// RVA to original unbound IAT (`ImageThunkData32`/`ImageThunkData64`)/// 0 for terminating null import descriptor/// 0 if not bound,/// -1 if bound, and real date\time stamp///     in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)/// O.W. date/time stamp of DLL bound to (Old BIND)forwarder_chain/// -1 if no forwardersfirst_thunk/// RVA to IAT (if bound this IAT has actual addresses)ImageImportDescriptor/// Tell whether this import descriptor is the null descriptor/// (used to mark the end of the iterator array in a PE)offset_module_namenumber_of_module_forwarder_refs// Array of zero or more IMAGE_BOUND_FORWARDER_REF followsImageBoundImportDescriptorImageBoundForwarderRefdll_name_rva/// RVA to the name of the target library (NULL-terminate ASCII string)module_handle_rva/// RVA to the HMODULE caching location (PHMODULE)import_address_table_rva/// RVA to the start of the IAT (PIMAGE_THUNK_DATA)import_name_table_rva/// RVA to the start of the name table (PIMAGE_THUNK_DATA::AddressOfData)bound_import_address_table_rva/// RVA to an optional bound IATunload_information_table_rva/// RVA to an optional unload info table/// 0 if not bound, otherwise, date/time of the target DLLImageDelayloadDescriptor/// Tell whether this delay-load import descriptor is the null descriptorIMAGE_DELAYLOAD_RVA_BASED/// Delay load version 2 flag for `ImageDelayloadDescriptor::attributes`.number_of_named_entriesnumber_of_id_entriesImageResourceDirectoryIMAGE_RESOURCE_NAME_IS_STRINGIMAGE_RESOURCE_DATA_IS_DIRECTORYname_or_idoffset_to_data_or_directoryImageResourceDirectoryEntry//pub name_string: [i8; 1],ImageResourceDirectoryString//pub name_string: [U16<LE>; 1],ImageResourceDirStringUoffset_to_data/// RVA of the data.code_pageImageResourceDataEntryRT_CURSOR/// ID for: Hardware-dependent cursor resource.RT_BITMAP/// ID for: Bitmap resource.RT_ICON/// ID for: Hardware-dependent icon resource.RT_MENU/// ID for: Menu resource.RT_DIALOG/// ID for: Dialog box.RT_STRING/// ID for: String-table entry.RT_FONTDIR/// ID for: Font directory resource.RT_FONT/// ID for: Font resource.RT_ACCELERATOR/// ID for: Accelerator table.RT_RCDATA/// ID for: Application-defined resource (raw data).RT_MESSAGETABLE/// ID for: Message-table entry.RT_GROUP_CURSOR/// ID for: Hardware-independent cursor resource.RT_GROUP_ICON/// ID for: Hardware-independent icon resource.RT_VERSION/// ID for: Version resource.RT_DLGINCLUDE/// ID for: Allows a resource editing tool to associate a string with an .rc file.RT_PLUGPLAY/// ID for: Plug and Play resource.RT_VXD/// ID for: VXD.RT_ANICURSOR/// ID for: Animated cursor.RT_ANIICON/// ID for: Animated icon.RT_HTML/// ID for: HTML resource.RT_MANIFEST/// ID for: Side-by-Side Assembly Manifest./// Flags to indicate if CI information is available, etc.catalog/// 0xFFFF means not availablecatalog_offset/// Additional bitmask to be defined laterImageLoadConfigCodeIntegrity// DynamicRelocations: [ImageDynamicRelocation; 0],ImageDynamicRelocationTablebase_reloc_size// BaseRelocations: [ImageBaseRelocation; 0],ImageDynamicRelocation32ImageDynamicRelocation64fixup_info_sizesymbol_group// ...     variable length header fields// pub     fixup_info: [u8; fixup_info_size]ImageDynamicRelocation32V2// pub     fixup_info[u8; fixup_info_size]ImageDynamicRelocation64V2IMAGE_DYNAMIC_RELOCATION_GUARD_RF_PROLOGUEIMAGE_DYNAMIC_RELOCATION_GUARD_RF_EPILOGUEIMAGE_DYNAMIC_RELOCATION_GUARD_IMPORT_CONTROL_TRANSFERIMAGE_DYNAMIC_RELOCATION_GUARD_INDIR_CONTROL_TRANSFERIMAGE_DYNAMIC_RELOCATION_GUARD_SWITCHTABLE_BRANCHprologue_byte_count// pub prologue_bytes: [u8; prologue_byte_count],ImagePrologueDynamicRelocationHeaderepilogue_countepilogue_byte_countbranch_descriptor_element_sizebranch_descriptor_count// pub branch_descriptors[...],// pub branch_descriptor_bit_map[...],ImageEpilogueDynamicRelocationHeaderglobal_flags_clearglobal_flags_setcritical_section_default_timeoutde_commit_free_block_thresholdde_commit_total_free_thresholdlock_prefix_table/// VAmaximum_allocation_sizevirtual_memory_thresholdprocess_heap_flagsprocess_affinity_maskcsd_versiondependent_load_flagsedit_listsecurity_cookiesehandler_tablesehandler_countguard_cf_check_function_pointerguard_cf_dispatch_function_pointerguard_cf_function_tableguard_cf_function_countguard_flagscode_integrityguard_address_taken_iat_entry_tableguard_address_taken_iat_entry_countguard_long_jump_target_tableguard_long_jump_target_countdynamic_value_reloc_tablechpe_metadata_pointerguard_rf_failure_routineguard_rf_failure_routine_function_pointerdynamic_value_reloc_table_offsetdynamic_value_reloc_table_sectionguard_rf_verify_stack_pointer_function_pointerhot_patch_table_offsetenclave_configuration_pointervolatile_metadata_pointerImageLoadConfigDirectory32ImageLoadConfigDirectory64base_image_listbase_image_countbuffer_offset/// Version 2 and laterextra_patch_size/// Version 3 and laterImageHotPatchInfooriginal_time_date_stamporiginal_check_sumcode_integrity_infocode_integrity_sizepatch_tableImageHotPatchBasesha256ImageHotPatchHashesIMAGE_HOT_PATCH_BASE_OBLIGATORYIMAGE_HOT_PATCH_BASE_CAN_ROLL_BACKIMAGE_HOT_PATCH_CHUNK_INVERSEIMAGE_HOT_PATCH_CHUNK_OBLIGATORYIMAGE_HOT_PATCH_CHUNK_RESERVEDIMAGE_HOT_PATCH_CHUNK_TYPEIMAGE_HOT_PATCH_CHUNK_SOURCE_RVAIMAGE_HOT_PATCH_CHUNK_TARGET_RVAIMAGE_HOT_PATCH_CHUNK_SIZEIMAGE_HOT_PATCH_NONEIMAGE_HOT_PATCH_FUNCTIONIMAGE_HOT_PATCH_ABSOLUTEIMAGE_HOT_PATCH_REL32IMAGE_HOT_PATCH_CALL_TARGETIMAGE_HOT_PATCH_INDIRECTIMAGE_HOT_PATCH_NO_CALL_TARGETIMAGE_HOT_PATCH_DYNAMIC_VALUEIMAGE_GUARD_CF_INSTRUMENTED/// Module performs control flow integrity checks using system-supplied supportIMAGE_GUARD_CFW_INSTRUMENTED/// Module performs control flow and write integrity checksIMAGE_GUARD_CF_FUNCTION_TABLE_PRESENT/// Module contains valid control flow target metadataIMAGE_GUARD_SECURITY_COOKIE_UNUSED/// Module does not make use of the /GS security cookieIMAGE_GUARD_PROTECT_DELAYLOAD_IAT/// Module supports read only delay load IATIMAGE_GUARD_DELAYLOAD_IAT_IN_ITS_OWN_SECTION/// Delayload import table in its own .didat section (with nothing else in it) that can be freely reprotectedIMAGE_GUARD_CF_EXPORT_SUPPRESSION_INFO_PRESENT/// Module contains suppressed export information./// This also infers that the address taken taken IAT table is also present in the load config.IMAGE_GUARD_CF_ENABLE_EXPORT_SUPPRESSION/// Module enables suppression of exportsIMAGE_GUARD_CF_LONGJUMP_TABLE_PRESENT/// Module contains longjmp target informationIMAGE_GUARD_RF_INSTRUMENTED/// Module contains return flow instrumentation and metadataIMAGE_GUARD_RF_ENABLE/// Module requests that the OS enable return flow protectionIMAGE_GUARD_RF_STRICT/// Module requests that the OS enable return flow protection in strict modeIMAGE_GUARD_RETPOLINE_PRESENT/// Module was built with retpoline supportIMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK/// Stride of Guard CF function table encoded in these bits (additional count of bytes per element)IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_SHIFT/// Shift to right-justify Guard CF function table strideIMAGE_GUARD_FLAG_FID_SUPPRESSED/// The containing GFID entry is suppressedIMAGE_GUARD_FLAG_EXPORT_SUPPRESSED/// The containing GFID entry is export suppressedbegin_addressunwind_dataImageArmRuntimeFunctionEntryImageArm64RuntimeFunctionEntryexception_handlerhandler_dataprolog_end_addressImageAlpha64RuntimeFunctionEntryImageAlphaRuntimeFunctionEntryunwind_info_address_or_dataImageRuntimeFunctionEntryIMAGE_ENCLAVE_LONG_ID_LENGTHIMAGE_ENCLAVE_SHORT_ID_LENGTHminimum_required_config_sizepolicy_flagsnumber_of_importsimport_listimport_entry_sizefamily_idimage_versionsecurity_versionenclave_sizenumber_of_threadsenclave_flagsImageEnclaveConfig32ImageEnclaveConfig64IMAGE_ENCLAVE_POLICY_DEBUGGABLEIMAGE_ENCLAVE_FLAG_PRIMARY_IMAGEmatch_typeminimum_security_versionunique_or_author_idimport_nameImageEnclaveImportIMAGE_ENCLAVE_IMPORT_MATCH_NONEIMAGE_ENCLAVE_IMPORT_MATCH_UNIQUE_IDIMAGE_ENCLAVE_IMPORT_MATCH_AUTHOR_IDIMAGE_ENCLAVE_IMPORT_MATCH_FAMILY_IDIMAGE_ENCLAVE_IMPORT_MATCH_IMAGE_IDaddress_of_raw_dataImageDebugDirectoryIMAGE_DEBUG_TYPE_UNKNOWNIMAGE_DEBUG_TYPE_COFFIMAGE_DEBUG_TYPE_CODEVIEWIMAGE_DEBUG_TYPE_FPOIMAGE_DEBUG_TYPE_MISCIMAGE_DEBUG_TYPE_EXCEPTIONIMAGE_DEBUG_TYPE_FIXUPIMAGE_DEBUG_TYPE_OMAP_TO_SRCIMAGE_DEBUG_TYPE_OMAP_FROM_SRCIMAGE_DEBUG_TYPE_BORLANDIMAGE_DEBUG_TYPE_RESERVED10IMAGE_DEBUG_TYPE_CLSIDIMAGE_DEBUG_TYPE_VC_FEATUREIMAGE_DEBUG_TYPE_POGOIMAGE_DEBUG_TYPE_ILTCGIMAGE_DEBUG_TYPE_MPXIMAGE_DEBUG_TYPE_REPROlva_to_first_symbollva_to_first_linenumberrva_to_first_byte_of_coderva_to_last_byte_of_coderva_to_first_byte_of_datarva_to_last_byte_of_dataImageCoffSymbolsHeaderFRAME_FPOFRAME_TRAPFRAME_TSSFRAME_NONFPOIMAGE_DEBUG_MISC_EXENAME/// type of misc data, see defines/// total length of record, rounded to four byte multiple./// TRUE if data is unicode string// Actual data//pub data: [u8; 1],ImageDebugMiscstarting_addressending_addressend_of_prologueImageFunctionEntryend_of_prologue_or_unwind_info_addressImageFunctionEntry64exported_names_sizedebug_directory_sizeImageSeparateDebugHeader//debug_directory_size//ImageDebugDirectoryNonPagedDebugInfoIMAGE_SEPARATE_DEBUG_SIGNATURENON_PAGED_DEBUG_SIGNATUREIMAGE_SEPARATE_DEBUG_FLAGS_MASKIMAGE_SEPARATE_DEBUG_MISMATCH/// when DBG was updated, the old checksum didn't match.fixup_inst_rva/// RVA of instruction to fixupnew_inst/// fixup instruction (see alphaops.h)ImageArchitectureEntryIMPORT_OBJECT_HDR_SIG2/// Must be IMPORT_OBJECT_HDR_SIG2./// Time/date stamp/// particularly useful for incremental linksordinal_or_hint/// if grf & IMPORT_OBJECT_ORDINALname_type// WORD    Type : 2;// WORD    NameType : 3;// WORD    Reserved : 11;ImportObjectHeaderIMPORT_OBJECT_TYPE_MASKIMPORT_OBJECT_TYPE_SHIFTIMPORT_OBJECT_CODEIMPORT_OBJECT_DATAIMPORT_OBJECT_CONSTIMPORT_OBJECT_NAME_MASKIMPORT_OBJECT_NAME_SHIFTIMPORT_OBJECT_ORDINAL/// Import by ordinalIMPORT_OBJECT_NAME/// Import name == public symbol name.IMPORT_OBJECT_NAME_NO_PREFIX/// Import name == public symbol name skipping leading ?, @, or optionally _.IMPORT_OBJECT_NAME_UNDECORATE/// Import name == public symbol name skipping leading ?, @, or optionally _ and truncating at first @.IMPORT_OBJECT_NAME_EXPORTAS/// Import name == a name is explicitly provided after the DLL name.COMIMAGE_FLAGS_ILONLY// COM+ Header entry point flags.COMIMAGE_FLAGS_32BITREQUIREDCOMIMAGE_FLAGS_IL_LIBRARYCOMIMAGE_FLAGS_STRONGNAMESIGNEDCOMIMAGE_FLAGS_NATIVE_ENTRYPOINTCOMIMAGE_FLAGS_TRACKDEBUGDATACOMIMAGE_FLAGS_32BITPREFERREDCOR_VERSION_MAJOR_V2// Version flags for image.COR_VERSION_MAJORCOR_VERSION_MINORCOR_DELETED_NAME_LENGTHCOR_VTABLEGAP_NAME_LENGTHNATIVE_TYPE_MAX_CB// Maximum size of a NativeType descriptor.COR_ILMETHOD_SECT_SMALL_MAX_DATASIZEIMAGE_COR_MIH_METHODRVA// Consts for the MIH FLAGSIMAGE_COR_MIH_EHRVAIMAGE_COR_MIH_BASICBLOCKCOR_VTABLE_32BIT// V-table constants/// V-table slots are 32-bits in size.COR_VTABLE_64BIT/// V-table slots are 64-bits in size.COR_VTABLE_FROM_UNMANAGED/// If set, transition from unmanaged.COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN/// If set, transition from unmanaged with keeping the current appdomain.COR_VTABLE_CALL_MOST_DERIVED/// Call most derived method described byIMAGE_COR_EATJ_THUNK_SIZE// EATJ constants/// Size of a jump thunk reserved range.MAX_CLASS_NAME// Max name lengthsMAX_PACKAGE_NAME// Header versioningmajor_runtime_versionminor_runtime_version// Symbol table and startup informationentry_point_token_or_rva// If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is not set, EntryPointToken represents a managed entrypoint.// If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is set, EntryPointRVA represents an RVA to a native entrypoint.resources// Binding informationstrong_name_signaturecode_manager_table// Regular fixup and binding informationvtable_fixupsexport_address_table_jumpsmanaged_native_header// Precompiled image info (internal use only - set to zero)ImageCor20Header// CLR 2.0 header structure.//! PE/COFF definitions.//! This module is based heavily on "winnt.h" (10.0.17763.0).// File header format.// Directory format.// Optional header format.// Values for `ImageOptionalHeader*::subsystem`.// Values for `ImageOptionalHeader*::dll_characteristics`.// Indices for `ImageOptionalHeader*::data_directory`.// Section header format.// Values for `ImageSectionHeader::characteristics`.//      IMAGE_SCN_TYPE_COPY                  0x00000010  // Reserved.// Symbol format.// Values for `ImageSymbol::section_number`.// Symbols have a section number of the section in which they are// defined. Otherwise, section numbers have the following meanings:// Values for `ImageSymbol::typ` (basic component).// Values for `ImageSymbol::typ` (derived component).// type packing constants// Auxiliary entry format.// Communal selection types.// Relocation format.// Flag bits in `ImageRelocation::typ`.// ARM64 relocations types./*
// TODO?
#define EXT_IMM64(Value, Address, Size, InstPos, ValPos)  /* Intel-IA64-Filler */           \
    Value |= (((ULONGLONG)((*(Address) >> InstPos) & (((ULONGLONG)1 << Size) - 1))) << ValPos)  // Intel-IA64-Filler

#define INS_IMM64(Value, Address, Size, InstPos, ValPos)  /* Intel-IA64-Filler */\
    *(PDWORD)Address = (*(PDWORD)Address & ~(((1 << Size) - 1) << InstPos)) | /* Intel-IA64-Filler */\
          ((DWORD)((((ULONGLONG)Value >> ValPos) & (((ULONGLONG)1 << Size) - 1))) << InstPos)  // Intel-IA64-Filler
*/// Line number format.// Based relocation format.// Based relocation types.// Platform-specific based relocation types.// Archive format.// DLL support.// Export Format// Import Format/*
    union {
/// PBYTE
        pub forwarder_string: U64<LE>,
/// PDWORD
        pub function: U64<LE>,
        pub ordinal: U64<LE>,
/// PIMAGE_IMPORT_BY_NAME
        pub address_of_data: U64<LE>,
    } u1;
*//*
    union {
/// PBYTE
        pub forwarder_string: U32<LE>,
/// PDWORD
        pub function: U32<LE>,
        pub ordinal: U32<LE>,
/// PIMAGE_IMPORT_BY_NAME
        pub address_of_data: U32<LE>,
    } u1;
}
*//*
#define IMAGE_ORDINAL64(Ordinal) (Ordinal & 0xffff)
#define IMAGE_ORDINAL32(Ordinal) (Ordinal & 0xffff)
#define IMAGE_SNAP_BY_ORDINAL64(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG64) != 0)
#define IMAGE_SNAP_BY_ORDINAL32(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG32) != 0)

*/// Thread Local Storage// New format import descriptors pointed to by DataDirectory[ IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT ]// Resource Format.// Resource directory consists of two counts, following by a variable length// array of directory entries.  The first count is the number of entries at// beginning of the array that have actual names associated with each entry.// The entries are in ascending order, case insensitive strings.  The second// count is the number of entries that immediately follow the named entries.// This second count identifies the number of entries that have 16-bit integer// Ids as their name.  These entries are also sorted in ascending order.// This structure allows fast lookup by either name or number, but for any// given resource entry only one form of lookup is supported, not both.// This is consistent with the syntax of the .RC file and the .RES file.// Each directory contains the 32-bit Name of the entry and an offset,// relative to the beginning of the resource directory of the data associated// with this directory entry.  If the name of the entry is an actual text// string instead of an integer Id, then the high order bit of the name field// is set to one and the low order 31-bits are an offset, relative to the// beginning of the resource directory of the string, which is of type// IMAGE_RESOURCE_DIRECTORY_STRING.  Otherwise the high bit is clear and the// low-order 16-bits are the integer Id that identify this resource directory// entry. If the directory entry is yet another resource directory (i.e. a// subdirectory), then the high order bit of the offset field will be// set to indicate this.  Otherwise the high bit is clear and the offset// field points to a resource data entry.// For resource directory entries that have actual string names, the Name// field of the directory entry points to an object of the following type.// All of these string objects are stored together after the last resource// directory entry and before the first resource data object.  This minimizes// the impact of these variable length objects on the alignment of the fixed// size directory entry objects.// Each resource data entry describes a leaf node in the resource directory// tree.  It contains an offset, relative to the beginning of the resource// directory of the data for the resource, a size field that gives the number// of bytes of data at that offset, a CodePage that should be used when// decoding code point values within the resource data.  Typically for new// applications the code page would be the unicode code page.// Resource type: https://docs.microsoft.com/en-us/windows/win32/menurc/resource-types// Code Integrity in loadconfig (CI)// Dynamic value relocation table in loadconfig// Dynamic value relocation entries following IMAGE_DYNAMIC_RELOCATION_TABLE// Defined symbolic dynamic relocation entries./*
// TODO? bitfields
// TODO: unaligned?
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct ImageImportControlTransferDynamicRelocation {
    DWORD       PageRelativeOffset : 12;
    DWORD       IndirectCall       : 1;
    DWORD       IATIndex           : 19;
}

// TODO: unaligned?
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct ImageIndirControlTransferDynamicRelocation {
    WORD        PageRelativeOffset : 12;
    WORD        IndirectCall       : 1;
    WORD        RexWPrefix         : 1;
    WORD        CfgCheck           : 1;
    WORD        Reserved           : 1;
}

// TODO: unaligned?
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct ImageSwitchtableBranchDynamicRelocation {
    WORD        PageRelativeOffset : 12;
    WORD        RegisterNumber     : 4;
}
*/// Load Configuration Directory Entry// GFIDS table entry flags.// WIN CE Exception table format// Function table entry format.  Function table is pointed to by the// IMAGE_DIRECTORY_ENTRY_EXCEPTION directory entry./*
// TODO? bitfields
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct ImageCeRuntimeFunctionEntry {
    pub func_start: U32<LE>,
    DWORD PrologLen : 8;
    DWORD FuncLen : 22;
    DWORD ThirtyTwoBit : 1;
    DWORD ExceptionFlag : 1;
}
*/// Software enclave information//pub const IMAGE_ENCLAVE_MINIMUM_CONFIG_SIZE: usize = FIELD_OFFSET(IMAGE_ENCLAVE_CONFIG, EnclaveFlags);// Debug Format/*
// TODO? bitfields
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct FpoData {
/// offset 1st byte of function code
    pub ul_off_start: U32<LE>,
/// # bytes in function
    pub cb_proc_size: U32<LE>,
/// # bytes in locals/4
    pub cdw_locals: U32<LE>,
/// # bytes in params/4
    pub cdw_params: U16<LE>,
/// # bytes in prolog
    WORD        cbProlog : 8;
/// # regs saved
    WORD        cbRegs   : 3;
/// TRUE if SEH in func
    WORD        fHasSEH  : 1;
/// TRUE if EBP has been allocated
    WORD        fUseBP   : 1;
/// reserved for future use
    WORD        reserved : 1;
/// frame type
    WORD        cbFrame  : 2;
}
pub const SIZEOF_RFPO_DATA: usize = 16;
*/// Function table extracted from MIPS/ALPHA/IA64 images.  Does not contain// information needed only for runtime support.  Just those fields for// each entry needed by a debugger.// Debugging information can be stripped from an image file and placed// in a separate .DBG file, whose file name part is the same as the// image file name part (e.g. symbols for CMD.EXE could be stripped// and placed in CMD.DBG).  This is indicated by the IMAGE_FILE_DEBUG_STRIPPED// flag in the Characteristics field of the file header.  The beginning of// the .DBG file contains the following structure which captures certain// information from the image file.  This allows a debug to proceed even if// the original image file is not accessible.  This header is followed by// zero of more IMAGE_SECTION_HEADER structures, followed by zero or more// IMAGE_DEBUG_DIRECTORY structures.  The latter structures and those in// the image file contain file offsets relative to the beginning of the// .DBG file.// If symbols have been stripped from an image, the IMAGE_DEBUG_MISC structure// is left in the image file, but not mapped.  This allows a debugger to// compute the name of the .DBG file, from the name of the image in the// IMAGE_DEBUG_MISC structure.//  The .arch section is made up of headers, each describing an amask position/value//  pointing to an array of IMAGE_ARCHITECTURE_ENTRY's.  Each "array" (both the header//  and entry arrays) are terminiated by a quadword of 0xffffffffL.//  NOTE: There may be quadwords of 0 sprinkled around and must be skipped./*
// TODO? bitfields
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct ImageArchitectureHeader {
    /// 1 -> code section depends on mask bit
    /// 0 -> new instruction depends on mask bit
    unsigned int AmaskValue: 1;
    /// MBZ
    int :7;
    /// Amask bit in question for this fixup
    unsigned int AmaskShift: 8;
    /// MBZ
    int :16;
    /// RVA into .arch section to array of ARCHITECTURE_ENTRY's
    pub first_entry_rva: U32<LE>,
}
*/// The following structure defines the new import object.  Note the values of the first two fields,// which must be set as stated in order to differentiate old and new import members.// Following this structure, the linker emits two null-terminated strings used to recreate the// import at the time of use.  The first string is the import's name, the second is the dll's name./// A trait for types that can safely be converted from and to byte slices./// A type that is `Pod` must:/// - be `#[repr(C)]` or `#[repr(transparent)]`/// - have no invalid byte values/// - have no padding/// Cast the head of a byte slice to a `Pod` type./// Returns the type and the tail of the byte slice./// Returns an error if the byte slice is too short or the alignment is invalid./// Cast the head of a mutable byte slice to a `Pod` type.slice_from_bytes/// Cast the head of a byte slice to a slice of a `Pod` type./// Returns the type slice and the tail of the byte slice.slice_from_bytes_mut/// Cast the head of a mutable byte slice to a slice of a `Pod` type.slice_from_all_bytes/// Cast all of a byte slice to a slice of a `Pod` type./// Returns the type slice./// Returns an error if the size of the byte slice is not an exact multiple/// of the type size, or the alignment is invalid.slice_from_all_bytes_mut/// Cast a `Pod` type to a byte slice./// Cast a `Pod` type to a mutable byte slice.bytes_of_slice/// Cast a slice of a `Pod` type to a byte slice.bytes_of_slice_mut/// Cast a slice of a `Pod` type to a mutable byte slice.//! Tools for converting file format structures to and from bytes.//! This module should be replaced once rust provides safe transmutes.// This module provides functions for both read and write features.// Unused for WasmCodeViewCompressedFileRangeObjectComdatObjectKindObjectSegmentObjectSymbolTableRelocationMapSymbolIndexSymbolMapSymbolMapNameSymbolSection/// Evaluate an expression on the contents of a file format enum./// This is a hack to avoid virtual calls.with_inner_mutmap_inner/// Like `with_inner!`, but wraps the result in another enum.map_inner_option/// Like `map_inner!`, but the result is a Result or Option.map_inner_option_mutnext_inner/// Call `next` for a file format iterator.CoffFileCoffBigFileCoffBigElfFile32Elf32ElfFile64Elf64MachOFile32MachO32MachOFile64MachO64PeFile32Pe32PeFile64Pe64XcoffFile32Xcoff32XcoffFile64Xcoff64/// An object file that can be any supported file format./// Most functionality is provided by the [`Object`] trait implementation./// Parse the raw file data.'cacheparse_dyld_cache_imageDyldCacheImage/// Parse a Mach-O image from the dyld shared cache./// Return the file format.'fileSegmentIteratorSectionIteratorComdatComdatIteratorSymbolIteratorDynamicRelocationIteratorarchitecturesub_architecturesection_by_name_bytessection_by_indexcomdatssymbol_by_indexdynamic_symbol_tabledynamic_relocationssymbol_mapimportshas_debug_symbolsmach_uuidgnu_debuglinkgnu_debugaltlinkpdb_inforelative_address_baseSegmentIteratorInternal/// An iterator for the loadable segments in a [`File`].CoffSegmentIteratorCoffBigSegmentIteratorElfSegmentIterator32ElfSegmentIterator64MachOSegmentIterator32MachOSegmentIterator64PeSegmentIterator32PeSegmentIterator64XcoffSegmentIterator32XcoffSegmentIterator64SegmentInternal/// A loadable segment in a [`File`]./// Most functionality is provided by the [`ObjectSegment`] trait implementation.CoffSegmentCoffBigSegmentElfSegment32ElfSegment64MachOSegment32MachOSegment64PeSegment32PeSegment64XcoffSegment32XcoffSegment64file_rangedata_rangeSectionIteratorInternal/// An iterator for the sections in a [`File`].CoffSectionIteratorCoffBigSectionIteratorElfSectionIterator32ElfSectionIterator64MachOSectionIterator32MachOSectionIterator64PeSectionIterator32PeSectionIterator64XcoffSectionIterator32XcoffSectionIterator64// we wrap our enums in a struct so that they are kept private.SectionInternal/// A section in a [`File`]./// Most functionality is provided by the [`ObjectSection`] trait implementation.CoffBigSectionElfSection32ElfSection64MachOSection32MachOSection64PeSection32PeSection64XcoffSection32XcoffSection64RelocationIteratorSectionRelocationIteratorcompressed_file_rangecompressed_datasegment_name_bytessegment_namerelocation_mapComdatIteratorInternal/// An iterator for the COMDAT section groups in a [`File`].CoffComdatIteratorCoffBigComdatIteratorElfComdatIterator32ElfComdatIterator64MachOComdatIterator32MachOComdatIterator64PeComdatIterator32PeComdatIterator64XcoffComdatIterator32XcoffComdatIterator64ComdatInternal/// A COMDAT section group in a [`File`]./// Most functionality is provided by the [`ObjectComdat`] trait implementation.CoffComdatCoffBigComdatElfComdat32ElfComdat64MachOComdat32MachOComdat64PeComdat32PeComdat64XcoffComdat32XcoffComdat64ComdatSectionIteratorComdatSectionIteratorInternal/// An iterator for the sections in a [`Comdat`].CoffComdatSectionIteratorCoffBigComdatSectionIteratorElfComdatSectionIterator32ElfComdatSectionIterator64MachOComdatSectionIterator32MachOComdatSectionIterator64PeComdatSectionIterator32PeComdatSectionIterator64XcoffComdatSectionIterator32XcoffComdatSectionIterator64SymbolTableInternal/// A symbol table in a [`File`]./// Most functionality is provided by the [`ObjectSymbolTable`] trait implementation.CoffSymbolTableCoffBigSymbolTableElfSymbolTable32ElfSymbolTable64MachOSymbolTable32MachOSymbolTable64XcoffSymbolTable32XcoffSymbolTable64SymbolIteratorInternal/// An iterator for the symbols in a [`SymbolTable`].CoffSymbolIteratorCoffBigSymbolIteratorElfSymbolIterator32ElfSymbolIterator64MachOSymbolIterator32MachOSymbolIterator64XcoffSymbolIterator32XcoffSymbolIterator64SymbolInternal/// An symbol in a [`SymbolTable`]./// Most functionality is provided by the [`ObjectSymbol`] trait implementation.CoffSymbolCoffBigSymbolElfSymbol32ElfSymbol64MachOSymbol32MachOSymbol64XcoffSymbol32XcoffSymbol64is_commonis_weakDynamicRelocationIteratorInternal/// An iterator for the dynamic relocation entries in a [`File`].ElfDynamicRelocationIterator32ElfDynamicRelocationIterator64// We need to always use the lifetime parameters.SectionRelocationIteratorInternal/// An iterator for the relocation entries in a [`Section`].CoffRelocationIteratorCoffBigRelocationIteratorElfSectionRelocationIterator32ElfSectionRelocationIterator64MachORelocationIterator32MachORelocationIterator64PeRelocationIteratorXcoffRelocationIterator32XcoffRelocationIterator64ArchiveKind/// There are no special files that indicate the archive format./// The GNU (or System V) archive format.Gnu64/// The GNU (or System V) archive format with 64-bit symbol table./// The BSD archive format.Bsd64/// The BSD archive format with 64-bit symbol table./// This is used for Darwin./// The Windows COFF archive format.AixBig/// The AIX big archive format./// The kind of archive format.Members/// The list of members in the archive.thin/// A partially parsed archive file./// Parse the archive header and special members.parse_aixbig/// Return the archive format.is_thin/// Return true if the archive is a thin archive.ArchiveMemberIterator/// Iterate over the members of the archive./// This does not return special members.ArchiveOffsetArchiveMember/// Return the member at the given offset.ArchiveSymbolIterator/// Iterate over the symbols in the archive./// An iterator over the members of an archive.MemberHeader/// Common header used by many formats./// AIX big archive header/// An archive member header.// May be zero for thin members./// A partially parsed archive member./// Parse the member header, name, and file data in an archive with the common format./// This reads the extended name (if any) and adjusts the file size.parse_aixbig_index/// Parse a member index entry in an AIX big archive,/// and then parse the member header, name, and file data./// Parse the member header, name, and file data in an AIX big archive./// Return the raw header that is common to many archive formats./// Returns `None` if this archive does not use the common header format.aix_header/// Return the raw header for AIX big archives./// Returns `None` if this is not an AIX big archive./// Return the parsed file name./// This may be an extended file name./// Parse the file modification timestamp from the header./// Parse the user ID from the header./// Parse the group ID from the header./// Parse the file mode from the header./// Return the size of the file data./// Return the offset and size of the file data./// Return true if the member is a thin member./// Thin members have no file data./// Return the file data./// This is an empty slice for thin members./// An offset of a member in an archive./// An iterator over the symbols in the archive symbol table./// There is no symbol table./// A GNU symbol table./// Contains:/// - the number of symbols as a 32-bit big-endian integer/// - the offsets of the member headers as 32-bit big-endian integers/// - the symbol names as null-terminated strings/// A GNU 64-bit symbol table/// - the number of symbols as a 64-bit big-endian integer/// - the offsets of the member headers as 64-bit big-endian integers/// A BSD symbol table./// - the size in bytes of the offsets array as a 32-bit little-endian integer/// - the offsets array, for which each entry is a pair of 32-bit little-endian integers/// for the offset of the member header and the offset of the symbol name/// - the size in bytes of the symbol names as a 32-bit little-endian integer/// A BSD 64-bit symbol table./// - the size in bytes of the offsets array as a 64-bit little-endian integer/// - the offsets array, for which each entry is a pair of 64-bit little-endian integers/// - the size in bytes of the symbol names as a 64-bit little-endian integer/// A Windows COFF symbol table./// - the number of members as a 32-bit little-endian integer/// - the offsets of the member headers as 32-bit little-endian integers/// - the number of symbols as a 32-bit little-endian integer/// - the member index for each symbol as a 16-bit little-endian integer/// - the symbol names as null-terminated strings in lexical orderArchiveSymbol/// A symbol in the archive symbol table./// This is used to find the member containing the symbol./// Return the symbol name./// Return the offset of the header for the member containing the symbol.parse_u64_digits// Ignores bytes starting from the first space.parse_sysv_extended_name/// Digits are a decimal offset into the extended name table./// Name is terminated by "/\n" (for GNU) or a null byte (for COFF).parse_bsd_extended_name/// Digits are a decimal length of the extended name, which is contained/// in `data` at `offset`./// Modifies `offset` and `size` to start after the extended name.gnu_namesthin_gnu_namesbsd_namesaix_names//! Support for archive files.//!  ```no_run//! use object::{Object, ObjectSection};//! use std::error::Error;//! /// Reads an archive and displays the name of each member.//! fn main() -> Result<(), Box<dyn Error>> {//! #   #[cfg(feature = "std")] {//!     let data = fs::read("path/to/binary")?;//!     let file = object::read::archive::ArchiveFile::parse(&*data)?;//!     for member in file.members() {//!         let member = member?;//!         println!("{}", String::from_utf8_lossy(member.name()));//! #   }CoffHeader/// An iterator for the COMDAT section groups in a [`CoffBigFile`](super::CoffBigFile)./// An iterator for the COMDAT section groups in a [`CoffFile`]./// A COMDAT section group in a [`CoffBigFile`](super::CoffBigFile)./// A COMDAT section group in a [`CoffFile`]./// An iterator for the sections in a COMDAT section group in a [`CoffBigFile`](super::CoffBigFile)./// An iterator for the sections in a COMDAT section group in a [`CoffFile`].NoDynamicRelocationIteratorCoffCommon/// The common parts of `PeFile` and `CoffFile`./// A COFF bigobj object file with 32-bit section numbers./// This is a file that starts with [`pe::AnonObjectHeaderBigobj`], and corresponds/// to [`crate::FileKind::CoffBig`]./// A COFF object file./// This is a file that starts with [`pe::ImageFileHeader`], and corresponds/// to [`crate::FileKind::Coff`]./// Parse the raw COFF file data.coff_header/// Get the raw COFF file header.coff_section_table/// Get the COFF section table.coff_symbol_table/// Get the COFF symbol table.anon_object_class_id/// Read the `class_id` field from a [`pe::AnonObjectHeader`]./// This can be used to determine the format of the header.is_type_bigobj/// Return true if this type is [`pe::AnonObjectHeaderBigobj`]./// This is a property of the type, not a value in the header data./// Read the file header./// `data` must be the entire file data./// `offset` must be the file header offset. It is updated to point after the optional header,/// which is where the section headers are located./// Read the section table./// `offset` must be after the optional file header./// Read the symbol table and string table./// A trait for generic access to [`pe::ImageFileHeader`] and [`pe::AnonObjectHeaderBigobj`].ImportTypedllImportFile/// A Windows short form description of a symbol to import./// Used in Windows import libraries to provide a mapping from/// a symbol name to a DLL export. This is not an object file./// This is a file that starts with [`pe::ImportObjectHeader`], and corresponds/// to [`crate::FileKind::CoffImport`]./// Parse it./// Get the machine type./// Get the sub machine type, if available./// The public symbol name./// The name of the DLL to import the symbol from.ImportName/// The name exported from the DLL.import_type/// The type of import. Usually either a function or data./// Import by ordinal. Ordinarily this is a 1-based index./// Import by name./// The name or ordinal to import from a DLL./// An executable code symbol./// A data symbol./// A constant value./// The kind of import symbol./// Read the short import header./// Also checks that the signature and version are valid./// Directly following this header will be the string data.ImportObjectData/// Parse the data following the header./// The type of import./// This is one of the `IMPORT_OBJECT_*` constants./// The type of import name./// The data following [`pe::ImportObjectHeader`]./// This is only set if the name is not derived from the symbol name.//! Support for reading short import files.//! These are used by some Windows linkers as a more compact way to describe//! dynamically imported symbols.comdat//! Support for reading Windows COFF files.//! Traits are used to abstract over the difference between COFF object files//! and COFF bigobj files. The primary trait for this is [`CoffHeader`].//! ## High level API//! [`CoffFile`] implements the [`Object`](crate::read::Object) trait for//! COFF files. [`CoffFile`] is parameterised by [`CoffHeader`].//! The default parameter allows reading regular COFF object files,//! while the type alias [`CoffBigFile`] allows reading COFF bigobj files.//! [`ImportFile`] allows reading COFF short imports that are used in import//! libraries. Currently these are not integrated with the unified read API.//! ## Low level API//! The [`CoffHeader`] trait can be directly used to parse both COFF//! object files (which start with [`pe::ImageFileHeader`]) and COFF bigobj//! files (which start with [`pe::AnonObjectHeaderBigobj`]).//! ### Example for low level API//! use object::pe;//! use object::read::coff::{CoffHeader, ImageSymbol as _};//! /// Reads a file and displays the name of each section and symbol.//!     let mut offset = 0;//!     let header = pe::ImageFileHeader::parse(&*data, &mut offset)?;//!     let sections = header.sections(&*data, offset)?;//!     let symbols = header.symbols(&*data)?;//!     for section in sections.iter() {//!         println!("{}", String::from_utf8_lossy(section.name(symbols.strings())?));//!     for (_index, symbol) in symbols.iter() {//!         println!("{}", String::from_utf8_lossy(symbol.name(symbols.strings())?));/// An iterator for the relocations in a [`CoffBigSection`](super::CoffBigSection)./// An iterator for the relocations in a [`CoffSection`](super::CoffSection)./// Get the index of the symbol referenced by this relocation./// The table of section headers in a COFF or PE file./// Returned by [`CoffHeader::sections`] and/// [`ImageNtHeaders::sections`](crate::read::pe::ImageNtHeaders::sections)./// Parse the section table./// Iterate over the section headers./// Warning: section indices start at 1./// Iterate over the section headers and their indices./// Return true if the section table is empty./// The number of section headers./// Return the section header at the given index./// The index is 1-based.section_by_name/// Return the section header with the given name./// The returned index is 1-based./// Ignores sections with invalid names.max_section_file_offset/// Compute the maximum file offset used by sections./// This will usually match the end of file, unless the PE file has a/// [data overlay](https://security.stackexchange.com/questions/77336/how-is-the-file-overlay-read-by-an-exe-virus)/// An iterator for the loadable sections in a [`CoffBigFile`](super::CoffBigFile)./// An iterator for the loadable sections in a [`CoffFile`]./// A loadable section in a [`CoffBigFile`](super::CoffBigFile)./// A loadable section in a [`CoffFile`].coff_file/// Get the COFF file containing this segment.coff_section/// Get the raw COFF section header./// An iterator for the sections in a [`CoffBigFile`](super::CoffBigFile)./// An iterator for the sections in a [`CoffFile`]./// A section in a [`CoffBigFile`](super::CoffBigFile)./// A section in a [`CoffFile`]./// Get the COFF file containing this section.coff_relocations/// Get the raw COFF relocations for this section.name_offset/// Return the string table offset of the section name./// Returns `Ok(None)` if the name doesn't use the string table/// and can be obtained with `raw_name` instead./// Return the section name./// This handles decoding names that are offsets into the symbol string table./// Return the raw section name.coff_file_range/// Return the offset and size of the section in a COFF file./// Returns `None` for sections that have no data in the file.coff_data/// Return the section data in a COFF file./// Returns `Ok(&[])` if the section has no data./// Returns `Err` for invalid values.coff_alignment/// Return the section alignment in bytes./// This is only valid for sections in a COFF file./// Read the relocations in a COFF file.SymbolMapEntry/// A table of symbol entries in a COFF or PE file./// Also includes the string table used for the symbol names./// Returned by [`CoffHeader::symbols`] and/// [`ImageNtHeaders::symbols`](crate::read::pe::ImageNtHeaders::symbols)./// Read the symbol table./// Return the string table used for the symbol names./// Return true if the symbol table is empty./// The number of symbol table entries./// This includes auxiliary symbol table entries.'table/// Iterate over the symbols./// Return the symbol table entry at the given index.aux_function/// Return the auxiliary function symbol for the symbol table entry at the given index./// Note that the index is of the symbol, not the first auxiliary record.aux_section/// Return the auxiliary section symbol for the symbol table entry at the given index.aux_file_name/// Return the auxiliary file name for the symbol table entry at the given index./// Return the symbol table entry or auxiliary record at the given index and offset./// Construct a map from addresses to a user-defined map entry./// An iterator for symbol entries in a COFF or PE file./// Yields the index and symbol structure for each symbol./// A symbol table in a [`CoffBigFile`](super::CoffBigFile)./// A symbol table in a [`CoffFile`](super::CoffFile)/// or [`PeFile`](crate::read::pe::PeFile)./// An iterator for the symbols in a [`CoffBigFile`](super::CoffBigFile)./// An iterator for the symbols in a [`CoffFile`](super::CoffFile)/// A symbol in a [`CoffBigFile`](super::CoffBigFile)./// A symbol in a [`CoffFile`](super::CoffFile) or [`PeFile`](crate::read::pe::PeFile).raw_symbol/// Get the raw `ImageSymbol` struct.coff_symbol/// Parse a COFF symbol name./// `strings` must be the string table used for symbol names./// Return the symbol address./// This takes into account the image base and the section address,/// and only returns an address for symbols that have an address./// Return the section index for the symbol./// Return true if the symbol is a definition of a function or data object.has_aux_file_name/// Return true if the symbol has an auxiliary file name.has_aux_function/// Return true if the symbol has an auxiliary function symbol.has_aux_section/// Return true if the symbol has an auxiliary section symbol.derived_type/// A trait for generic access to [`pe::ImageSymbol`] and [`pe::ImageSymbolEx`]./// An ELF attributes section./// This may be a GNU attributes section, or an architecture specific attributes section./// An attributes section contains a series of [`AttributesSubsection`]./// Returned by [`SectionHeader::attributes`](super::SectionHeader::attributes)/// and [`SectionHeader::gnu_attributes`](super::SectionHeader::gnu_attributes)./// Parse an ELF attributes section given the section data./// Return the version of the attributes section.AttributesSubsectionIterator/// Return an iterator over the subsections./// An iterator for the subsections in an [`AttributesSection`]./// Return the next subsection./// A subsection in an [`AttributesSection`]./// A subsection is identified by a vendor name.  It contains a series of/// [`AttributesSubsubsection`]./// Return the length of the attributes subsection./// Return the vendor name of the attributes subsection.AttributesSubsubsectionIterator/// Return an iterator over the sub-subsections./// An iterator for the sub-subsections in an [`AttributesSubsection`]./// Return the next sub-subsection./// A sub-subsection in an [`AttributesSubsection`]./// A sub-subsection is identified by a tag.  It contains an optional series of indices,/// followed by a series of attributes./// Return the tag of the attributes sub-subsection./// Return the length of the attributes sub-subsection.indices_data/// Return the data containing the indices.AttributeIndexIterator/// Return the indices./// This will be section indices if the tag is `Tag_Section`,/// or symbol indices if the tag is `Tag_Symbol`,/// and otherwise it will be empty.attributes_data/// Return the data containing the attributes.AttributeReader/// Return a parser for the data containing the attributes./// An iterator over the indices in an [`AttributesSubsubsection`]./// Parse the next index./// A parser for the attributes in an [`AttributesSubsubsection`]./// The parser relies on the caller to know the format of the data for each attribute tag./// Parse a tag.read_integer/// Parse an integer value./// Parse a string value.ElfFileElfComdatIterator/// An iterator for the COMDAT section groups in an [`ElfFile32`](super::ElfFile32)./// An iterator for the COMDAT section groups in an [`ElfFile64`](super::ElfFile64)./// An iterator for the COMDAT section groups in an [`ElfFile`].ElfComdat/// A COMDAT section group in an [`ElfFile32`](super::ElfFile32)./// A COMDAT section group in an [`ElfFile64`](super::ElfFile64)./// A COMDAT section group in an [`ElfFile`].elf_file/// Get the ELF file containing this COMDAT section group.elf_section_header/// Get the raw ELF section header for the COMDAT section group.ElfComdatSectionIterator/// An iterator for the sections in a COMDAT section group in an [`ElfFile32`](super::ElfFile32)./// An iterator for the sections in a COMDAT section group in an [`ElfFile64`](super::ElfFile64)./// An iterator for the sections in a COMDAT section group in an [`ElfFile`]./// A trait for generic access to [`elf::CompressionHeader32`] and [`elf::CompressionHeader64`].tag32/// Try to convert the tag to a `u32`.val32/// Try to convert the value to a `u32`./// Return true if the value is an offset in the dynamic string table./// Use the value to get a string in a string table./// Does not check for an appropriate tag.is_address/// Return true if the value is an address./// A trait for generic access to [`elf::Dyn32`] and [`elf::Dyn64`].ElfDynamicRelocationIteratorElfSectionElfSectionIteratorElfSegmentElfSegmentIteratorElfSymbolElfSymbolIteratorElfSymbolTableNoteHeaderRelocationSections/// A 32-bit ELF object file./// This is a file that starts with [`elf::FileHeader32`], and corresponds/// to [`crate::FileKind::Elf32`]./// A 64-bit ELF object file./// This is a file that starts with [`elf::FileHeader64`], and corresponds/// to [`crate::FileKind::Elf64`]./// A partially parsed ELF file./// Parse the raw ELF file data./// Returns the endianness./// Returns the raw data./// Returns the raw ELF file header.raw_segments/// Returns the raw ELF segments.elf_header/// Get the raw ELF file header.elf_program_headers/// Get the raw ELF program headers./// Returns an empty slice if the file has no program headers.elf_section_table/// Get the ELF section table./// Returns an empty section table if the file has no section headers.elf_symbol_table/// Get the ELF symbol table./// Returns an empty symbol table if the file has no symbol table.elf_dynamic_symbol_table/// Get the ELF dynamic symbol table./// Returns an empty symbol table if the file has no dynamic symbol table.elf_relocation_sections/// Get a mapping for linked relocation sections.raw_section_by_namezdebug_section_by_name// Ideally this would be a `u64: From<Word>`, but can't express that.Swordis_type_64/// Return true if this type is a 64-bit header.is_type_64_sized/// This is the same as [`Self::is_type_64`], but is non-dispatchable./// Also checks that the ident field in the file header is a supported format./// Check that the ident field in the file header is a supported format./// This checks the magic number, version, class, and endianness.is_class_32is_class_64section_0/// Return the first section header, if present./// Section 0 is a special case because getting the section headers normally/// requires `shnum`, but `shnum` may be in the first section header./// Return the `e_phnum` field of the header. Handles extended values.shnum/// Return the `e_shnum` field of the header. Handles extended values.shstrndx/// Return the `e_shstrndx` field of the header. Handles extended values./// Returns `Err` for invalid values (including if the index is 0)./// Return the slice of program headers./// Returns `Ok(&[])` if there are no program headers.section_headers/// Return the slice of section headers./// Returns `Ok(&[])` if there are no section headers.section_strings_index/// Get the section index of the section header string table.section_strings/// Return the string table for the section headers./// Return the section table.is_mips64el/// Returns whether this is a mips64el elf file.// Provided methods./// A trait for generic access to [`elf::FileHeader32`] and [`elf::FileHeader64`].VersionTablechains/// A SysV symbol hash table in an ELF file./// Returned by [`SectionHeader::hash`](super::SectionHeader::hash)./// Parse a SysV hash table./// `data` should be from an [`elf::SHT_HASH`] section, or from a/// segment pointed to via the [`elf::DT_HASH`] entry./// The header is read at offset 0 in the given `data`.symbol_table_length/// Return the symbol table length./// Use the hash table to find the symbol table entry with the given name, hash and version.bloom_filtersGnuHashTable/// A GNU symbol hash table in an ELF file./// Returned by [`SectionHeader::gnu_hash`](super::SectionHeader::gnu_hash)./// Parse a GNU hash table./// `data` should be from an [`elf::SHT_GNU_HASH`] section, or from a/// segment pointed to via the [`elf::DT_GNU_HASH`] entry./// The header does not contain a length field, and so all of `data`/// will be used as the hash table values. It does not matter if this/// is longer than needed, and this will often the case when accessing/// the hash table via the [`elf::DT_GNU_HASH`] entry./// Return the symbol table index of the first symbol in the hash table./// Determine the symbol table length by finding the last entry in the hash table./// Returns `None` if the hash table is empty or invalid./// Use the hash table to find the symbol table entry with the given name, hash, and version.//! Support for reading ELF files.//! Traits are used to abstract over the difference between 32-bit and 64-bit ELF.//! The primary trait for this is [`FileHeader`].//! [`ElfFile`] implements the [`Object`](crate::read::Object) trait for ELF files.//! [`ElfFile`] is parameterised by [`FileHeader`] to allow reading both 32-bit and//! 64-bit ELF. There are type aliases for these parameters ([`ElfFile32`] and//! [`ElfFile64`]).//! The [`FileHeader`] trait can be directly used to parse both [`elf::FileHeader32`]//! and [`elf::FileHeader64`].//! use object::elf;//! use object::read::elf::{FileHeader, Sym};//! /// Reads a file and displays the name of each symbol.//!     let elf = elf::FileHeader64::<object::Endianness>::parse(&*data)?;//!     let endian = elf.endian()?;//!     let sections = elf.sections(endian, &*data)?;//!     let symbols = sections.symbols(endian, &*data, elf::SHT_SYMTAB)?;//!     for symbol in symbols.iter() {//!         let name = symbol.name(endian, symbols.strings())?;//!         println!("{}", String::from_utf8_lossy(name));NoteIterator/// An iterator over the notes in an ELF section or segment./// Returned [`ProgramHeader::notes`](super::ProgramHeader::notes)/// and [`SectionHeader::notes`](super::SectionHeader::notes)./// `align` should be from the `p_align` field of the segment,/// or the `sh_addralign` field of the section. Supported values are/// either 4 or 8, but values less than 4 are treated as 4./// This matches the behaviour of binutils./// Returns `Err` if `align` is invalid./// Returns the next note./// A parsed [`NoteHeader`]./// Return the `n_type` field of the `NoteHeader`./// The meaning of this field is determined by `name`./// Return the `n_namesz` field of the `NoteHeader`./// Return the `n_descsz` field of the `NoteHeader`./// Return the bytes for the name field following the `NoteHeader`./// This field is usually a string including one or more trailing null bytes/// (but it is not required to be)./// The length of this field is given by `n_namesz`./// Return the bytes for the name field following the `NoteHeader`,/// excluding all trailing null bytes./// Return the bytes for the desc field following the `NoteHeader`./// The length of this field is given by `n_descsz`. The meaning/// of this field is determined by `name` and `n_type`.gnu_propertiesGnuPropertyIterator/// Return an iterator for properties if this note's type is [`elf::NT_GNU_PROPERTY_TYPE_0`]./// A trait for generic access to [`elf::NoteHeader32`] and [`elf::NoteHeader64`]./// An iterator for the properties in a [`elf::NT_GNU_PROPERTY_TYPE_0`] note./// Returned by [`Note::gnu_properties`].GnuProperty/// Returns the next property.pr_typepr_data/// A property in a [`elf::NT_GNU_PROPERTY_TYPE_0`] note./// Return the property type./// This is one of the `GNU_PROPERTY_*` constants./// Return the property data.data_u32/// Parse the property data as an unsigned 32-bit integer./// A mapping from section index to associated relocation sections./// Create a new mapping using the section table./// Skips relocation sections that do not use the given symbol table section./// Given a section index, return the section index of the associated relocation section./// This may also be called with a relocation section index, and it will return the/// next associated relocation section.ElfRelaIteratoris_rel/// An iterator for the dynamic relocations in an [`ElfFile32`](super::ElfFile32)./// An iterator for the dynamic relocations in an [`ElfFile64`](super::ElfFile64).section_index/// The current relocation section index./// An iterator for the dynamic relocations in an [`ElfFile`].ElfSectionRelocationIterator/// An iterator for the relocations for an [`ElfSection32`](super::ElfSection32)./// An iterator for the relocations for an [`ElfSection64`](super::ElfSection64)./// The current pointer in the chain of relocation sections./// An iterator for the relocations for an [`ElfSection`](super::ElfSection).parse_relocation/// Get the symbol index referenced by the relocation./// Returns `None` for the null symbol index./// A trait for generic access to [`elf::Rel32`] and [`elf::Rel64`]./// A trait for generic access to [`elf::Rela32`] and [`elf::Rela64`].gnu_compressionCompressionFormatVerdefIteratorVerneedIterator/// The table of section headers in an ELF file./// Also includes the string table used for the section names./// Returned by [`FileHeader::sections`]./// Create a new section table./// This includes the null section at index 0, which you will usually need to skip./// Get the section header at the given index./// Returns an error for the null section at index 0./// Return the section name for the given section header./// Return the string table at the given section index./// Returns an empty string table if the index is 0./// Returns an error if the section is not a string table./// Return the symbol table of the given section type./// Returns an empty symbol table if the symbol table does not exist.symbol_table_by_index/// Return the symbol table at the given section index./// Returns an error if the section is not a symbol table.relocation_sections/// Create a mapping from section index to associated relocation sections./// Return the contents of a dynamic section./// Also returns the linked string table index./// Returns `Ok(None)` if there is no `SHT_DYNAMIC` section.hash_header/// Return the header of a SysV hash section./// Returns `Ok(None)` if there is no SysV GNU hash section./// Return the contents of a SysV hash section./// Also returns the linked symbol table index./// Returns `Ok(None)` if there is no SysV hash section.gnu_hash_header/// Return the header of a GNU hash section./// Returns `Ok(None)` if there is no GNU hash section./// Return the contents of a GNU hash section.gnu_versym/// Return the contents of a `SHT_GNU_VERSYM` section./// Returns `Ok(None)` if there is no `SHT_GNU_VERSYM` section.gnu_verdef/// Return the contents of a `SHT_GNU_VERDEF` section./// Returns `Ok(None)` if there is no `SHT_GNU_VERDEF` section.gnu_verneed/// Return the contents of a `SHT_GNU_VERNEED` section./// Returns `Ok(None)` if there is no `SHT_GNU_VERNEED` section./// Returns the symbol version table./// An iterator for the sections in an [`ElfFile32`](super::ElfFile32)./// An iterator for the sections in an [`ElfFile64`](super::ElfFile64)./// An iterator for the sections in an [`ElfFile`]./// A section in an [`ElfFile32`](super::ElfFile32)./// A section in an [`ElfFile64`](super::ElfFile64)./// A section in an [`ElfFile`]./// Get the ELF file containing this section./// Get the raw ELF section header.elf_relocation_section_index/// Get the index of the relocation section that references this section./// Returns `None` if there are no relocations./// Returns an error if there are multiple relocation sections that reference this section.elf_relocation_section/// Get the relocation section that references this section.elf_linked_rel/// Get the `Elf::Rel` entries that apply to this section./// Returns an empty slice if there are no relocations.elf_linked_rela/// Get the `Elf::Rela` entries that apply to this section.maybe_compressedmaybe_compressed_gnu// Try GNU-style "ZLIB" header decompression./// Parse the section name from the string table./// Get the `sh_link` field as a section index./// This may return a null section index, and does not check for validity.has_info_link/// Return true if the `SHF_INFO_LINK` flag is set.info_link/// Get the `sh_info` field as a section index./// This does not check the `SHF_INFO_LINK` flag./// Return the offset and size of the section in the file./// Return the section data.data_as_array/// Return the section data as a slice of the given type./// Allows padding at the end of the data./// Returns `Err` for invalid values, including bad alignment./// Return the strings in the section./// Returns `Ok(None)` if the section does not contain strings./// Return the symbols in the section./// Also finds the linked string table in `sections`./// `section_index` must be the 0-based index of this section, and is used/// to find the corresponding extended section index table in `sections`./// Returns `Ok(None)` if the section does not contain symbols.rel/// Return the `Elf::Rel` entries in the section./// Returns `Ok(None)` if the section does not contain relocations.rela/// Return the `Elf::Rela` entries in the section./// Return entries in a dynamic section./// Returns `Ok(None)` if the section type is not `SHT_DYNAMIC`./// Return a note iterator for the section data./// Returns `Ok(None)` if the section does not contain notes./// Return the contents of a group section./// The first value is a `GRP_*` value, and the remaining values/// are section indices./// Returns `Ok(None)` if the section does not define a group./// Returns `Ok(None)` if the section does not contain a SysV hash./// Returns `Ok(None)` if the section does not contain a GNU hash./// Returns `Ok(None)` if the section type is not `SHT_GNU_VERSYM`./// Return an iterator for the entries of a `SHT_GNU_VERDEF` section./// Returns `Ok(None)` if the section type is not `SHT_GNU_VERDEF`./// Return an iterator for the entries of a `SHT_GNU_VERNEED` section./// Returns `Ok(None)` if the section type is not `SHT_GNU_VERNEED`.gnu_attributes/// Return the contents of a `SHT_GNU_ATTRIBUTES` section./// Returns `Ok(None)` if the section type is not `SHT_GNU_ATTRIBUTES`./// Parse the contents of the section as attributes./// This function does not check whether section type corresponds/// to a section that contains attributes./// Parse the compression header if present./// Returns the header, and the offset and size of the compressed section data/// in the file./// Returns `Ok(None)` if the section flags do not have `SHF_COMPRESSED`./// A trait for generic access to [`elf::SectionHeader32`] and [`elf::SectionHeader64`]./// An iterator for the segments in an [`ElfFile32`](super::ElfFile32)./// An iterator for the segments in an [`ElfFile64`](super::ElfFile64)./// An iterator for the segments in an [`ElfFile`]./// A segment in an [`ElfFile32`](super::ElfFile32)./// A segment in an [`ElfFile64`](super::ElfFile64)./// A segment in an [`ElfFile`]./// Get the ELF file containing this segment.elf_program_header/// Get the raw ELF program header for the segment./// Return the offset and size of the segment in the file./// Return the segment data./// Return the segment data as a slice of the given type./// Returns `Ok(&[])` if the segment has no data./// Return the segment data in the given virtual address range/// Returns `Ok(None)` if the segment does not contain the address./// Return entries in a dynamic segment./// Returns `Ok(None)` if the segment is not `PT_DYNAMIC`.interpreter/// Return the data in an interpreter segment./// Returns `Ok(None)` if the segment is not `PT_INTERP`./// Return a note iterator for the segment data./// Returns `Ok(None)` if the segment does not contain notes./// A trait for generic access to [`elf::ProgramHeader32`] and [`elf::ProgramHeader64`].string_sectionshndx_sectionshndx/// A table of symbol entries in an ELF file./// Returned by [`SectionTable::symbols`]./// Parse the given symbol table section./// Return the section index of this symbol table./// Return the section index of the shndx table./// Return the section index of the linked string table./// Return the symbol table./// This includes the null symbol at index 0, which you will usually need to skip./// Iterate over the symbols and their indices./// The number of symbols./// Get the symbol at the given index./// Returns an error for null entry at index 0./// Return the extended section index for the given symbol if present.symbol_section/// Return the section index for the given symbol./// This uses the extended section index if present./// Return the symbol name for the given symbol./// A symbol table in an [`ElfFile32`](super::ElfFile32)./// A symbol table in an [`ElfFile`](super::ElfFile)./// An iterator for the symbols in an [`ElfFile32`](super::ElfFile32)./// An iterator for the symbols in an [`ElfFile64`](super::ElfFile64)./// An iterator for the symbols in an [`ElfFile`](super::ElfFile)./// A symbol in an [`ElfFile32`](super::ElfFile32)./// A symbol in an [`ElfFile64`](super::ElfFile64)./// A symbol in an [`ElfFile`](super::ElfFile)./// Get the endianness of the ELF file./// Return a reference to the raw symbol structure.elf_symbol/// Get the raw ELF symbol structure./// Parse the symbol name from the string table./// Return true if the symbol section is `SHN_UNDEF`./// Return true if the symbol section is `SHN_COMMON`./// Return true if the symbol section is `SHN_ABS`./// Return true if the symbol binding is `STB_LOCAL`./// Return true if the symbol binding is `STB_WEAK`./// A trait for generic access to [`elf::Sym32`] and [`elf::Sym64`].VersionIndex/// A version index./// Return the version index./// Return true if it is the local index./// Return true if it is the global index./// Return the hidden flag.// Used to keep track of valid indices in `VersionTable`./// A version definition or requirement./// This is derived from entries in the [`elf::SHT_GNU_VERDEF`] and [`elf::SHT_GNU_VERNEED`] sections./// Return the version name./// Return hash of the version name./// Return the filename of the library containing this version./// This is the `vn_file` field of the associated entry in [`elf::SHT_GNU_VERNEED`]./// or `None` if the version info was parsed from a [`elf::SHT_GNU_VERDEF`] section./// A table of version definitions and requirements./// It allows looking up the version information for a given symbol index./// This is derived from entries in the [`elf::SHT_GNU_VERSYM`], [`elf::SHT_GNU_VERDEF`]/// and [`elf::SHT_GNU_VERNEED`] sections./// Returned by [`SectionTable::versions`](super::SectionTable::versions)./// Parse the version sections./// Return true if the version table is empty.version_index/// Return version index for a given symbol index./// Return version information for a given symbol version index./// Returns `Ok(None)` for local and global versions./// Returns `Err(_)` if index is invalid./// Return true if the given symbol index satisfies the requirements of `need`./// Returns false for any error./// Note: this function hasn't been fully tested and is likely to be incomplete./// An iterator for the entries in an ELF [`elf::SHT_GNU_VERDEF`] section.VerdauxIterator/// Return the next `Verdef` entry./// An iterator for the auxiliary records for an entry in an ELF [`elf::SHT_GNU_VERDEF`] section./// Return the next `Verdaux` entry./// An iterator for the entries in an ELF [`elf::SHT_GNU_VERNEED`] section.VernauxIterator/// Return the next `Verneed` entry./// An iterator for the auxiliary records for an entry in an ELF [`elf::SHT_GNU_VERNEED`] section./// Return the next `Vernaux` entry./// Parse the version name from the string table./// Parse the file from the string table.// Attempt to parse the the CompressedFileRange for a section using the GNU-style// inline compression header format. This is used by the Go compiler in Mach-O files// as well as by the GNU linker in some ELF files.subcachesDyldSubCacheDyldCache/// A parsed representation of the dyld shared cache./// Information about a subcache.DyldSubCacheSlice/// V1, used between dyld-940 and dyld-1042.1./// V2, used since dyld-1042.1./// A slice of structs describing each subcache. The struct gained/// an additional field (the file suffix) in dyld-1042.1 (macOS 13 / iOS 16),/// so this is an enum of the two possible slice types.MIN_HEADER_SIZE_SUBCACHES_V1// This is the offset of the end of the images_across_all_subcaches_count field.MIN_HEADER_SIZE_SUBCACHES_V2// This is the offset of the end of the cacheSubType field.// This field comes right after the images_across_all_subcaches_count field,// and we don't currently have it in our definition of the DyldCacheHeader type./// Parse the raw dyld shared cache data./// For shared caches from macOS 12 / iOS 15 and above, the subcache files need to be/// supplied as well, in the correct order, with the `.symbols` subcache last (if present)./// For example, `data` would be the data for `dyld_shared_cache_x86_64`,/// and `subcache_data` would be the data for `[dyld_shared_cache_x86_64.1, dyld_shared_cache_x86_64.2, ...]`./// Get the architecture type of the file.endianness/// Get the endianness of the file./// Return true if the file is little endian, false if it is big endian.DyldCacheImageIterator/// Iterate over the images in this cache.data_and_offset_for_address/// Find the address in a mapping and return the cache or subcache data it was found in,/// together with the translated file offset./// An iterator over all the images (dylibs) in the dyld shared cache./// One image (dylib) from inside the dyld shared cache./// The file system path of this image.image_data_and_offset/// The subcache data which contains the Mach-O header for this image,/// together with the file offset at which this image starts.parse_object/// Parse this image into an Object./// Read the dyld cache header.parse_magic/// Returns (arch, endian) based on the magic string./// Return the mapping information table./// Return the information about subcaches, if present./// Returns `None` for dyld caches produced before dyld-940 (macOS 12)./// Return the UUID for the .symbols subcache, if present./// Return the image information table./// Find the file offset of the image by looking up its address in the mappings.address_to_file_offsetMachOFatFile32MachOFatFile/// A 32-bit Mach-O universal binary./// This is a file that starts with [`macho::FatHeader`], and corresponds/// to [`crate::FileKind::MachOFat32`].MachOFatFile64/// A 64-bit Mach-O universal binary./// to [`crate::FileKind::MachOFat64`].archesFatArch/// A Mach-O universal binary./// to [`crate::FileKind::MachOFat32`] or [`crate::FileKind::MachOFat64`]./// Attempt to parse the fat header and fat arches./// Return the fat header/// Return the array of fat arches./// A trait for generic access to [`macho::FatArch32`] and [`macho::FatArch64`].LoadCommandIteratorMachOSectionMachOSectionInternalMachOSectionIteratorMachOSegmentMachOSegmentInternalMachOSegmentIteratorMachOSymbolMachOSymbolIteratorMachOSymbolTableMachOFile/// A 32-bit Mach-O object file./// This is a file that starts with [`macho::MachHeader32`], and corresponds/// to [`crate::FileKind::MachO32`]./// A 64-bit Mach-O object file./// This is a file that starts with [`macho::MachHeader64`], and corresponds/// to [`crate::FileKind::MachO64`].header_offset/// A partially parsed Mach-O file./// Most of the functionality of this type is provided by the [`Object`] trait implementation./// Parse the raw Mach-O file data./// Parse the Mach-O file for the given image from the dyld shared cache./// This will read different sections from different subcaches, if necessary.section_internal/// Return the section at the given index./// Returns the raw Mach-O file header.macho_header/// Get the raw Mach-O file header.macho_load_commands/// Get the Mach-O load commands.macho_symbol_table/// Get the Mach-O symbol table.build_version/// Return the `LC_BUILD_VERSION` load command if present.MachOComdatMachOComdatIterator/// An iterator for the COMDAT section groups in a [`MachOFile64`]./// An iterator for the COMDAT section groups in a [`MachOFile`]./// This is a stub that doesn't implement any functionality./// A COMDAT section group in a [`MachOFile32`]./// A COMDAT section group in a [`MachOFile64`]./// A COMDAT section group in a [`MachOFile`].MachOComdatSectionIterator/// An iterator for the sections in a COMDAT section group in a [`MachOFile32`]./// An iterator for the sections in a COMDAT section group in a [`MachOFile64`]./// An iterator for the sections in a COMDAT section group in a [`MachOFile`]./// Return true if the `magic` field signifies big-endian./// Return true if the `magic` field signifies little-endian./// Also checks that the magic field in the file header is a supported format.load_commands/// Return the UUID from the `LC_UUID` load command, if one is present./// A trait for generic access to [`macho::MachHeader32`] and [`macho::MachHeader64`]./// An iterator for the load commands from a [`MachHeader`].LoadCommandData/// Return the next load command.// Includes the header./// The data for a [`macho::LoadCommand`]./// Return the `cmd` field of the [`macho::LoadCommand`]./// This is one of the `LC_` constants./// Return the `cmdsize` field of the [`macho::LoadCommand`]./// Parse the data as the given type./// Raw bytes of this [`macho::LoadCommand`] structure./// Parse a load command string value./// Strings used by load commands are specified by offsets that are/// relative to the load command header.LoadCommandVariant/// Parse the command data according to the `cmd` field.segment_32/// Try to parse this command as a [`macho::SegmentCommand32`]./// Returns the segment command and the data containing the sections.symtab/// Try to parse this command as a [`macho::SymtabCommand`].dysymtab/// Try to parse this command as a [`macho::DysymtabCommand`]./// Try to parse this command as a [`macho::DylibCommand`]./// Try to parse this command as a [`macho::UuidCommand`].segment_64/// Try to parse this command as a [`macho::SegmentCommand64`].dyld_info/// Try to parse this command as a [`macho::DyldInfoCommand`].entry_point/// Try to parse this command as an [`macho::EntryPointCommand`]./// Try to parse this command as a [`macho::BuildVersionCommand`].Segment32/// `LC_SEGMENT`/// `LC_SYMTAB`// obsolete: `LC_SYMSEG`//Symseg(&'data macho::SymsegCommand<E>),/// `LC_THREAD` or `LC_UNIXTHREAD`Dysymtab// obsolete: `LC_IDFVMLIB` or `LC_LOADFVMLIB`//Fvmlib(&'data macho::FvmlibCommand<E>),// obsolete: `LC_IDENT`//Ident(&'data macho::IdentCommand<E>),// internal: `LC_FVMFILE`//Fvmfile(&'data macho::FvmfileCommand<E>),// internal: `LC_PREPAGE`/// `LC_DYSYMTAB`/// `LC_LOAD_DYLIB`, `LC_LOAD_WEAK_DYLIB`, `LC_REEXPORT_DYLIB`,/// `LC_LAZY_LOAD_DYLIB`, or `LC_LOAD_UPWARD_DYLIB`IdDylib/// `LC_ID_DYLIB`LoadDylinker/// `LC_LOAD_DYLINKER`IdDylinker/// `LC_ID_DYLINKER`PreboundDylib/// `LC_PREBOUND_DYLIB`Routines32/// `LC_ROUTINES`SubFramework/// `LC_SUB_FRAMEWORK`SubUmbrella/// `LC_SUB_UMBRELLA`SubClient/// `LC_SUB_CLIENT`SubLibrary/// `LC_SUB_LIBRARY`TwolevelHints/// `LC_TWOLEVEL_HINTS`PrebindCksum/// `LC_PREBIND_CKSUM`Segment64/// `LC_SEGMENT_64`Routines64/// `LC_ROUTINES_64`/// `LC_UUID`Rpath/// `LC_RPATH`LinkeditDataEncryptionInfo32/// `LC_ENCRYPTION_INFO`DyldInfo/// `LC_DYLD_INFO` or `LC_DYLD_INFO_ONLY`VersionMin/// `LC_VERSION_MIN_MACOSX`, `LC_VERSION_MIN_IPHONEOS`, `LC_VERSION_MIN_WATCHOS`,/// or `LC_VERSION_MIN_TVOS`DyldEnvironment/// `LC_DYLD_ENVIRONMENT`EntryPoint/// `LC_MAIN`SourceVersion/// `LC_SOURCE_VERSION`EncryptionInfo64/// `LC_ENCRYPTION_INFO_64`LinkerOption/// `LC_LINKER_OPTION`/// `LC_NOTE`BuildVersion/// `LC_BUILD_VERSION`FilesetEntry/// `LC_FILESET_ENTRY`/// An unrecognized or obsolete load command./// A [`macho::LoadCommand`] that has been interpreted according to its `cmd` field./// Return the symbol table that this command references.cmd_size_invaliddyld_cachefatload_command//! Support for reading Mach-O files.//! Traits are used to abstract over the difference between 32-bit and 64-bit Mach-O//! files. The primary trait for this is [`MachHeader`].//! [`MachOFile`] implements the [`Object`](crate::read::Object) trait for Mach-O files.//! [`MachOFile`] is parameterised by [`MachHeader`] to allow reading both 32-bit and//! 64-bit Mach-O files. There are type aliases for these parameters ([`MachOFile32`] and//! [`MachOFile64`]).//! The [`MachHeader`] trait can be directly used to parse both [`macho::MachHeader32`]//! and [`macho::MachHeader64`]. Additionally, [`FatHeader`] and the [`FatArch`] trait//! can be used to iterate images in multi-architecture binaries, and [`DyldCache`] can//! be used to locate images in a dyld shared cache.//! use object::macho;//! use object::read::macho::{MachHeader, Nlist};//!     let header = macho::MachHeader64::<object::Endianness>::parse(&*data, 0)?;//!     let endian = header.endian()?;//!     let mut commands = header.load_commands(endian, &*data, 0)?;//!     while let Some(command) = commands.next()? {//!         if let Some(symtab_command) = command.symtab()? {//!             let symbols = symtab_command.symbols::<macho::MachHeader64<_>, _>(endian, &*data)?;//!             for symbol in symbols.iter() {//!                 let name = symbol.name(endian, symbols.strings())?;//!                 println!("{}", String::from_utf8_lossy(name));MachORelocationIterator/// An iterator for the relocations in a [`MachOSection32`](super::MachOSection32)./// An iterator for the relocations in a [`MachOSection64`](super::MachOSection64)./// An iterator for the relocations in a [`MachOSection`](super::MachOSection)./// An iterator for the sections in a [`MachOFile32`](super::MachOFile32)./// An iterator for the sections in a [`MachOFile64`](super::MachOFile64)./// An iterator for the sections in a [`MachOFile`]./// A section in a [`MachOFile32`](super::MachOFile32)./// A section in a [`MachOFile64`](super::MachOFile64)./// A section in a [`MachOFile`].macho_file/// Get the Mach-O file containing this section.macho_section/// Get the raw Mach-O section structure.macho_relocations/// Get the raw Mach-O relocation entries./// The data for the file that contains the section data./// This is required for dyld caches, where this may be a different subcache/// from the file containing the Mach-O load commands./// Return the `sectname` bytes up until the null terminator./// Return the `segname` bytes up until the null terminator./// Return the relocation array./// A trait for generic access to [`macho::Section32`] and [`macho::Section64`]./// An iterator for the segments in a [`MachOFile32`](super::MachOFile32)./// An iterator for the segments in a [`MachOFile64`](super::MachOFile64)./// An iterator for the segments in a [`MachOFile`]./// A segment in a [`MachOFile32`](super::MachOFile32)./// A segment in a [`MachOFile64`](super::MachOFile64)./// A segment in a [`MachOFile`]./// Get the Mach-O file containing this segment.macho_segment/// Get the raw Mach-O segment structure./// The data for the file that contains the segment data./// Get the segment data from the file data./// Get the array of sections from the data following the segment command./// A trait for generic access to [`macho::SegmentCommand32`] and [`macho::SegmentCommand64`].ObjectMapEntry/// A table of symbol entries in a Mach-O file./// Returned by [`macho::SymtabCommand::symbols`]./// Return the symbol at the given index./// Construct a map from addresses to symbol names and object file names./// A symbol table in a [`MachOFile32`](super::MachOFile32)./// A symbol table in a [`MachOFile64`](super::MachOFile64)./// A symbol table in a [`MachOFile`]./// An iterator for the symbols in a [`MachOFile32`](super::MachOFile32)./// An iterator for the symbols in a [`MachOFile64`](super::MachOFile64)./// An iterator for the symbols in a [`MachOFile`]./// A symbol in a [`MachOFile32`](super::MachOFile32)./// A symbol in a [`MachOFile64`](super::MachOFile64)./// A symbol in a [`MachOFile`]./// Get the Mach-O file containing this symbol.macho_symbol/// Get the raw Mach-O symbol structure.is_stab/// Return true if this is a STAB symbol./// This determines the meaning of the `n_type` field./// Return true if this is an undefined symbol.library_ordinal/// Return the library ordinal./// This is either a 1-based index into the dylib load commands,/// or a special ordinal./// A trait for generic access to [`macho::Nlist32`] and [`macho::Nlist64`].read_refread_cache/// The error type used within the read module./// The result type used within the read module.read_errorNativeFile/// The native executable file for the target platform./// A Unix archive./// See [`archive::ArchiveFile`]./// See [`coff::CoffFile`]./// A COFF bigobj object file./// This supports a larger number of sections./// See [`coff::CoffBigFile`].CoffImport/// A Windows short import file./// See [`coff::ImportFile`]./// A dyld cache file containing Mach-O images./// See [`macho::DyldCache`]/// A 32-bit ELF file./// See [`elf::ElfFile32`]./// A 64-bit ELF file./// See [`elf::ElfFile64`]./// A 32-bit Mach-O file./// See [`macho::MachOFile32`]./// A 64-bit Mach-O file./// See [`macho::MachOFile64`].MachOFat32/// A 32-bit Mach-O fat binary./// See [`macho::MachOFatFile32`].MachOFat64/// A 64-bit Mach-O fat binary./// See [`macho::MachOFatFile64`]./// A 32-bit PE file./// See [`pe::PeFile32`]./// A 64-bit PE file./// See [`pe::PeFile64`]./// A 32-bit XCOFF file./// See [`xcoff::XcoffFile32`]./// A 64-bit XCOFF file./// See [`xcoff::XcoffFile64`]./// A file format kind./// Determine a file kind by parsing the start of the file.parse_at/// Determine a file kind by parsing at the given offset./// The object kind is unknown.Relocatable/// Relocatable object.Executable/// Executable./// Dynamic shared object./// Core./// An object kind./// Returned by [`Object::kind`]./// The index used to identify a section in a file./// The index used to identify a symbol in a symbol table./// The section is unknown./// The section is not applicable for this symbol (such as file symbols)./// The symbol is undefined./// The symbol has an absolute value./// The symbol is a zero-initialized symbol that will be combined with duplicate definitions./// The symbol is defined in the given section./// The section where an [`ObjectSymbol`] is defined./// Returns the section index for the section where the symbol is defined./// May return `None` if the symbol is not defined in a section./// The symbol address./// An entry in a [`SymbolMap`]./// A map from addresses to symbol information./// The symbol information depends on the chosen entry type, such as [`SymbolMapName`]./// Returned by [`Object::symbol_map`]./// Construct a new symbol map./// This function will sort the symbols by address./// Get the symbol before the given address./// Get all symbols in the map./// The type used for entries in a [`SymbolMap`] that maps from addresses to names./// Construct a `SymbolMapName`./// The symbol name./// A map from addresses to symbol names and object files./// This is derived from STAB entries in Mach-O files./// Returned by [`Object::object_map`]./// Get the entry containing the given address./// Get all objects in the map./// A symbol in an [`ObjectMap`]./// Get the symbol address./// Get the symbol size./// This may be 0 if the size is unknown./// Get the symbol name.object_index/// Get the index of the object file name./// Get the object file name./// An object file name in an [`ObjectMap`]./// Get the path to the file containing the object./// If the file is an archive, get the name of the member containing the object.// TODO: or ordinal/// An imported symbol./// Returned by [`Object::imports`]./// The name of the library to import the symbol from.// TODO: and ordinal?/// An exported symbol./// Returned by [`Object::exports`]./// The virtual address of the symbol./// PDB information from the debug directory in a PE file./// The path to the PDB as stored in CodeView./// The age of the PDB./// The GUID of the PDB./// The target is a symbol./// The target is a section./// The offset is an absolute address./// The target referenced by a [`Relocation`].implicit_addend/// Returned by [`Object::dynamic_relocations`] or [`ObjectSection::relocations`]./// The size in bits of the place of the relocation./// If 0, then the size is determined by the relocation kind./// The addend to use in the relocation calculation.set_addend/// Set the addend to use in the relocation calculation.has_implicit_addend/// Returns true if there is an implicit addend stored in the data at the offset/// to be relocated./// Relocation flags that are specific to each file format./// The values returned by `kind`, `encoding` and `size` are derived/// from these flags.RelocationMapEntry/// A map from section offsets to relocation information./// This can be used to apply relocations to a value at a given section offset./// This is intended for use with DWARF in relocatable object files, and only/// supports relocations that are used in DWARF./// Returned by [`ObjectSection::relocation_map`]./// Construct a new relocation map for a section./// Fails if any relocation cannot be added to the map./// You can manually use `add` if you need different error handling,/// such as to list all errors or to ignore them./// Add a single relocation to the map./// Relocate a value that was read from the section at the given offset./// The data is uncompressed./// The data is compressed, but the compression format is unknown./// ZLIB/DEFLATE./// Used for ELF compression and GNU compressed debug information.Zstandard/// Zstandard./// Used for ELF compression./// A data compression format./// The data compression format./// The file offset of the compressed data./// The compressed data size.uncompressed_size/// The uncompressed data size./// A range in a file that may be compressed./// Returned by [`ObjectSection::compressed_file_range`]./// Data that is uncompressed./// Convert to [`CompressedData`] by reading from the file./// The compressed data./// Data that may be compressed./// Returned by [`ObjectSection::compressed_data`]./// Return the uncompressed data./// Returns an error for invalid data or unsupported compression./// This includes if the data is compressed but the `compression` feature/// for this crate is disabled.//! Interface for reading object files.//! The [`Object`] trait provides a unified read API for accessing common features of//! object files, such as sections and symbols. There is an implementation of this//! trait for [`File`], which allows reading any file format, as well as implementations//! for each file format://! [`ElfFile`](elf::ElfFile), [`MachOFile`](macho::MachOFile), [`CoffFile`](coff::CoffFile),//! [`PeFile`](pe::PeFile), [`WasmFile`](wasm::WasmFile), [`XcoffFile`](xcoff::XcoffFile).//! The submodules for each file format define helpers that operate on the raw structs.//! See the [submodules](#modules) for examples of the low level read API.//! ## Naming Convention//! Types that form part of the unified API for a file format are prefixed with the//! name of the file format.//! ## Example for unified read API//! /// Reads a file and displays the name of each section.//! #   #[cfg(all(feature = "read", feature = "std"))] {//!     let file = object::File::parse(&*data)?;//!     for section in file.sections() {//!         println!("{}", section.name()?);DelayLoadImportTableExportTableImportTableRelocationBlockIteratorResourceDirectoryDataDirectories/// The table of data directories in a PE file./// Returned by [`ImageNtHeaders::parse`](super::ImageNtHeaders::parse)./// Parse the data directory table./// `data` must be the remaining optional data following the/// [optional header](pe::ImageOptionalHeader64).  `number` must be from the/// [`number_of_rva_and_sizes`](pe::ImageOptionalHeader64::number_of_rva_and_sizes)/// field of the optional header./// The number of data directories./// Iterator over the data directories./// Iterator which gives the directories as well as their index (one of the IMAGE_DIRECTORY_ENTRY_* constants)./// Returns the data directory at the given index./// Index should be one of the `IMAGE_DIRECTORY_ENTRY_*` constants./// Returns `None` if the index is larger than the table size,/// or if the entry at the index has a zero virtual address.export_directory/// Returns the unparsed export directory.export_table/// Returns the partially parsed export directory.import_table/// Returns the partially parsed import directory.delay_load_import_table/// Returns the partially parsed delay-load import directory.relocation_blocks/// Returns the blocks in the base relocation directory.resource_directory/// Returns the resource directory./// Return the virtual address range of this directory entry./// Return the file offset and size of this directory entry./// This function has some limitations:/// - It requires that the data is contained in a single section./// - It uses the size field of the directory entry, which is/// not desirable for all data directories./// - It uses the `virtual_address` of the directory entry as an address,/// which is not valid for `IMAGE_DIRECTORY_ENTRY_SECURITY`./// Get the data referenced by this directory entry.ExportTarget/// The address of the export, relative to the image base.ForwardByOrdinal/// Forwarded to an export ordinal in another DLL./// This gives the name of the DLL, and the ordinal.ForwardByName/// Forwarded to an export name in another DLL./// This gives the name of the DLL, and the export name./// Where an export is pointing to./// Returns true if the target is an address.is_forward/// Returns true if the export is forwarded to another DLL./// The ordinal of the export./// These are sequential, starting at a base specified in the DLL./// The name of the export, if known./// The target of this export./// An export from a PE file./// There are multiple kinds of PE exports (with or without a name, and local or forwarded).name_ordinals/// A partially parsed PE export table./// Returned by [`DataDirectories::export_table`](super::DataDirectories::export_table)./// Parse the export table given its section data and address.parse_directory/// Parse the export directory given its section data./// Returns the header of the export table.ordinal_base/// Returns the base value of ordinals./// Adding this to an address index will give an ordinal./// Returns the unparsed address table./// An address table entry may be a local address, or the address of a forwarded export entry./// See [`Self::is_forward`] and [`Self::target_from_address`].name_pointers/// Returns the unparsed name pointer table./// A name pointer table entry can be used with [`Self::name_from_pointer`]./// Returns the unparsed ordinal table./// An ordinal table entry is a 0-based index into the address table./// See [`Self::address_by_index`] and [`Self::target_by_index`].name_iter/// Returns an iterator for the entries in the name pointer table and ordinal table.address_by_index/// Returns the export address table entry at the given address index./// This may be a local address, or the address of a forwarded export entry./// `index` is a 0-based index into the export address table.address_by_ordinal/// Returns the export address table entry at the given ordinal.target_by_index/// Returns the target of the export at the given address index.target_by_ordinal/// Returns the target of the export at the given ordinal.target_from_address/// Convert an export address table entry into a target.forward_offset/// Return true if the export address table entry is a forward.forward_string/// Return the forward string if the export address table entry is a forward.name_from_pointer/// Convert an export name pointer table entry into a name./// Returns the parsed exports in this table.parse_ordinalImageThunkDataPeSectionPeSectionIteratorPeSegmentPeSegmentIteratorRichHeaderInfoPeFile/// A PE32 (32-bit) image file./// This is a file that starts with [`pe::ImageNtHeaders32`], and corresponds/// to [`crate::FileKind::Pe32`]./// A PE32+ (64-bit) image file./// This is a file that starts with [`pe::ImageNtHeaders64`], and corresponds/// to [`crate::FileKind::Pe64`].dos_headernt_headersdata_directories/// A PE image file./// Parse the raw PE file data./// Returns this binary data./// Return the DOS header of this file./// Return the NT Headers of this file.rich_header_info/// Returns information about the rich header of this file (if any).section_table/// Returns the section table of this binary./// Returns the data directories of this file.data_directory/// Returns the export table of this file./// The export table is located using the data directory./// Returns the import table of this file./// The import table is located using the data directory.PeComdatPeComdatIterator/// An iterator for the COMDAT section groups in a [`PeFile32`]./// An iterator for the COMDAT section groups in a [`PeFile64`]./// An iterator for the COMDAT section groups in a [`PeFile`]./// A COMDAT section group in a [`PeFile32`]./// A COMDAT section group in a [`PeFile64`]./// A COMDAT section group in a [`PeFile`].PeComdatSectionIterator/// An iterator for the sections in a COMDAT section group in a [`PeFile32`]./// An iterator for the sections in a COMDAT section group in a [`PeFile64`]./// An iterator for the sections in a COMDAT section group in a [`PeFile`]./// Read the DOS header./// Also checks that the `e_magic` field in the header is valid.nt_headers_offset/// Return the file offset of the nt_headers.optional_header_magic/// Find the optional header and read its `magic` field./// It can be useful to know this magic value before trying to/// fully parse the NT headers.is_valid_optional_magic/// Return true if the magic field in the optional header is valid./// Return the signature/// Return the file header./// Return the optional header./// Read the NT headers, including the data directories./// `data` must be for the entire file./// `offset` must be headers offset, which can be obtained from [`pe::ImageDosHeader::nt_headers_offset`]./// It is updated to point after the optional header, which is where the section headers are located./// Also checks that the `signature` and `magic` fields in the headers are valid./// Read the COFF symbol table and string table./// A trait for generic access to [`pe::ImageNtHeaders32`] and [`pe::ImageNtHeaders64`]./// A trait for generic access to [`pe::ImageOptionalHeader32`] and [`pe::ImageOptionalHeader64`].section_datasection_addressimport_address/// Information for parsing a PE import table./// Returned by [`DataDirectories::import_table`](super::DataDirectories::import_table)./// Create a new import table parser./// The import descriptors start at `import_address`./// The size declared in the `IMAGE_DIRECTORY_ENTRY_IMPORT` data directory is/// ignored by the Windows loader, and so descriptors will be parsed until a null entry./// `section_data` should be from the section containing `import_address`, and/// `section_address` should be the address of that section. Pointers within the/// descriptors and thunks may point to anywhere within the section data.descriptorsImportDescriptorIterator/// Return an iterator for the import descriptors./// Return a library name given its address./// This address may be from [`pe::ImageImportDescriptor::name`].thunksImportThunkList/// Return a list of thunks given its address./// This address may be from [`pe::ImageImportDescriptor::original_first_thunk`]/// or [`pe::ImageImportDescriptor::first_thunk`]./// Parse a thunk.hint_name/// Return the hint and name at the given address./// This address may be from [`pe::ImageThunkData32`] or [`pe::ImageThunkData64`]./// The hint is an index into the export name pointer table in the target library./// A fallible iterator for the descriptors in the import data directory./// Return the next descriptor./// Returns `Ok(None)` when a null descriptor is found./// A list of import thunks./// These may be in the import lookup table, or the import address table./// Get the thunk at the given index./// Return the first thunk in the list, and update `self` to point after it./// Returns `Ok(None)` when a null thunk is found./// Import by ordinal./// Includes a hint for the index into the export name pointer table in the target library./// A parsed import thunk./// Return the raw thunk value.is_ordinal/// Returns true if the ordinal flag is set./// Return the ordinal portion of the thunk./// Does not check the ordinal flag./// Return the RVA portion of the thunk./// A trait for generic access to [`pe::ImageThunkData32`] and [`pe::ImageThunkData64`]./// Information for parsing a PE delay-load import table./// Returned by/// [`DataDirectories::delay_load_import_table`](super::DataDirectories::delay_load_import_table)./// Create a new delay load import table parser./// This table works in the same way the import table does: descriptors will be/// parsed until a null entry.DelayLoadDescriptorIterator/// This address may be from [`pe::ImageDelayloadDescriptor::dll_name_rva`]./// This address may be from the INT, i.e. from/// [`pe::ImageDelayloadDescriptor::import_name_table_rva`]./// Please note that others RVA values from [`pe::ImageDelayloadDescriptor`] are used/// by the delay loader at runtime to store values, and thus do not point inside the same/// section as the INT. Calling this function on those addresses will fail./// A fallible iterator for the descriptors in the delay-load data directory.rich//! Support for reading PE files.//! Traits are used to abstract over the difference between PE32 and PE32+.//! The primary trait for this is [`ImageNtHeaders`].//! [`PeFile`] implements the [`Object`](crate::read::Object) trait for//! PE files. [`PeFile`] is parameterised by [`ImageNtHeaders`] to allow//! reading both PE32 and PE32+. There are type aliases for these parameters//! ([`PeFile32`] and [`PeFile64`]).//! The [`ImageNtHeaders`] trait can be directly used to parse both//! [`pe::ImageNtHeaders32`] and [`pe::ImageNtHeaders64`].//! use object::read::pe::ImageNtHeaders;//!     let dos_header = pe::ImageDosHeader::parse(&*data)?;//!     let mut offset = dos_header.nt_headers_offset().into();//!     let (nt_headers, data_directories) = pe::ImageNtHeaders64::parse(&*data, &mut offset)?;//!     let sections = nt_headers.sections(&*data, offset)?;//!     let symbols = nt_headers.symbols(&*data)?;/// An iterator over the relocation blocks in the `.reloc` section of a PE file./// Returned by [`DataDirectories::relocation_blocks`](super::DataDirectories::relocation_blocks)./// Construct a new iterator from the data of the `.reloc` section./// Read the next relocation page.relocs/// An iterator of the relocations in a block in the `.reloc` section of a PE file./// Return the virtual address of the page that this block of relocations applies to./// Return the size in bytes of this block of relocations./// The virtual address of the relocation./// One of the `pe::IMAGE_REL_BASED_*` constants./// A relocation in the `.reloc` section of a PE file./// The `.rsrc` section of a PE file./// Returned by [`DataDirectories::resource_directory`](super::DataDirectories::resource_directory)./// Construct from the data of the `.rsrc` section.ResourceDirectoryTable/// Parses the root resource directory./// The table header./// The table entries./// A table of resource entries.has_name/// Returns true if the entry has a name, rather than an ID.ResourceName/// Returns the section offset of the name./// Valid if `has_name()` returns true./// Returns the ID./// Valid if `has_string_name()` returns false.ResourceNameOrId/// Returns the entry nameis_table/// Returns true if the entry is a subtable./// Returns the section offset of the associated table or data.ResourceDirectoryEntryData/// Returns the data associated to this directory entry./// A subtable entry./// A resource data entry./// Data associated with a resource directory entry./// Converts to an option of table./// Helper for iterator filtering./// Converts to an option of data entry./// A resource name./// Converts to a `String`./// Returns the string unicode buffer./// Returns the string buffer as raw bytes./// A resource ID./// A resource name or ID./// Can be either a string or a numeric ID./// Converts to an option of name./// Converts to an option of ID./// The offset at which the rich header starts./// The length (in bytes) of the rich header./// This includes the payload, but also the 16-byte start sequence and the/// 8-byte final "Rich" and XOR key.xor_key/// The XOR key used to mask the rich header./// Unless the file has been tampered with, it should be equal to a checksum/// of the file header.masked_entries/// Parsed information about a Rich Header.comp_id/// ID of the component./// Number of times this component has been used when building this PE.RichHeaderEntry/// A PE rich header entry after it has been unmasked./// See [`pe::MaskedRichHeaderEntry`]./// Try to locate a rich header and its entries in the current PE file.unmasked_entries/// Returns an iterator over the unmasked entries./// Find the offset of the first occurrence of needle in the data./// The offset must have the given alignment.//! PE rich header handling/// An iterator for the loadable sections in a [`PeFile32`](super::PeFile32)./// An iterator for the loadable sections in a [`PeFile64`](super::PeFile64)./// An iterator for the loadable sections in a [`PeFile`]./// A loadable section in a [`PeFile32`](super::PeFile32)./// A loadable section in a [`PeFile64`](super::PeFile64)./// A loadable section in a [`PeFile`].pe_file/// Get the PE file containing this segment.pe_section/// Get the raw PE section header./// An iterator for the sections in a [`PeFile32`](super::PeFile32)./// An iterator for the sections in a [`PeFile64`](super::PeFile64)./// An iterator for the sections in a [`PeFile`]./// A section in a [`PeFile32`](super::PeFile32)./// A section in a [`PeFile64`](super::PeFile64)./// A section in a [`PeFile`].pe_file_range_at/// Return the file offset of the given virtual address, and the size up/// to the end of the section containing it./// Returns `None` if no section contains the address.pe_data_at/// Return the data starting at the given virtual address, up to the end of the/// section containing it./// Ignores sections with invalid data.pe_data_containing/// Return the data of the section that contains the given virtual address in a PE file./// Also returns the virtual address of that section.section_containing/// Return the section that contains a given virtual address.pe_file_range/// Return the offset and size of the section in a PE file./// The size of the range will be the minimum of the file size and virtual size./// Return the file offset of the given virtual address, and the remaining size up/// to the end of the section./// Returns `None` if the section does not contain the address.pe_address_range/// Return the virtual address and size of the section.pe_data/// Return the section data in a PE file./// The length of the data will be the minimum of the file size and virtual size.contains_rva/// Tests whether a given RVA is part of this section/// Return the section data if it contains the given virtual address./// An iterator for the relocations in an [`PeSection`].ReadCacheInternalReadCacheOpsReadCache/// An implementation of [`ReadRef`] for data in a stream that implements/// `Read + Seek`./// Contains a cache of read-only blocks of data, allowing references to/// them to be returned. Entries in the cache are never removed./// Entries are keyed on the offset and size of the read./// Currently overlapping reads are considered separate reads./// This is primarily intended for environments where memory mapped files/// are not available or not suitable, such as WebAssembly./// Note that malformed files can cause the cache to grow much larger than/// the file size.range_in_bounds/// Ensures this range is contained in the len of the file/// The length of the underlying read, memoized/// Create an empty `ReadCache` for the given stream.ReadCacheRange/// Return an implementation of `ReadRef` that restricts reads/// to the given range of the stream./// Free buffers used by the cache./// Unwrap this `ReadCache<R>`, returning the underlying reader.read_bytes_atread_bytes_at_until/// An implementation of [`ReadRef`] for a range of data in a stream that/// implements `Read + Seek`./// Shares an underlying [`ReadCache`] with a lifetime of `'a`./// Return the length of the stream./// Equivalent to `std::io::Seek::seek(SeekFrom::End(0))`./// Seek to the given position in the stream./// Equivalent to `std::io::Seek::seek` with `SeekFrom::Start(pos)`./// Read up to `buf.len()` bytes into `buf`./// Equivalent to `std::io::Read::read`./// Equivalent to `std::io::Read::read_exact`./// Operations required to implement [`ReadCache`]./// This is a subset of the `Read` and `Seek` traits./// A blanket implementation is provided for all types that implement/// The total size of the block of data./// Get a reference to a `u8` slice at the given offset./// Returns an error if offset or size are out of bounds./// Get a reference to a delimited `u8` slice which starts at range.start./// Does not include the delimiter./// Returns an error if the range is out of bounds or the delimiter is/// not found in the range./// Get a reference to a `u8` slice at the given offset, and update the offset./// Get a reference to a `Pod` type at the given offset, and update the offset./// The default implementation uses `read_bytes`, and returns an error if/// `read_bytes` does not return bytes with the correct alignment for `T`./// Implementors may want to provide their own implementation that ensures/// the alignment can be satisfied. Alternatively, only use this method with/// types that do not need alignment (see the `unaligned` feature of this crate).read_at/// Get a reference to a `Pod` type at the given offset./// Also see the `read` method for information regarding alignment of `T`./// Get a reference to a slice of a `Pod` type at the given offset, and update the offset.read_slice_at/// Get a reference to a slice of a `Pod` type at the given offset./// A trait for reading references to [`Pod`] types from a block of data./// This allows parsers to handle both of these cases:/// - the block of data exists in memory, and it is desirable///   to use references to this block instead of copying it,/// - the block of data exists in storage, and it is desirable///   to read on demand to minimize I/O and memory usage./// A block of data typically exists in memory as a result of using a memory/// mapped file, and the crate was written with this use case in mind./// Reading the entire file into a `Vec` is also possible, but it often uses/// more I/O and memory./// Both of these are handled by the `ReadRef` implementation for `&[u8]`./// For the second use case, the `ReadRef` trait is implemented for/// [`&ReadCache`](super::ReadCache). This is useful for environments where/// memory mapped files are not available or not suitable, such as WebAssembly./// This differs from reading into a `Vec` in that it only reads the portions/// of the file that are needed for parsing./// The methods accept `self` by value because `Self` is expected to behave/// similar to a reference: it may be a reference with a lifetime of `'a`,/// or it may be a wrapper of a reference./// The `Clone` and `Copy` bounds are for convenience, and since `Self` is/// expected to be similar to a reference, these are easily satisfied./// Object file parsers typically use offsets to locate the structures/// in the block, and will most commonly use the `*_at` methods to/// read a structure at a known offset./// Occasionally file parsers will need to treat the block as a stream,/// and so convenience methods are provided that update an offset with/// the size that was read.// An alternative would be for methods to accept `&mut self` and use a// `seek` method instead of the `offset` parameters, but this is less// convenient for implementers./// A loadable segment in the object file./// An iterator for the loadable segments in the object file./// A section in the object file./// An iterator for the sections in the object file./// A COMDAT section group in the object file./// An iterator for the COMDAT section groups in the object file./// A symbol in the object file./// An iterator for symbols in the object file./// A symbol table in the object file./// An iterator for the dynamic relocations in the file./// The first field in the item tuple is the address/// that the relocation applies to./// Get the sub-architecture type of the file if known./// A value of `None` has a range of meanings: the file supports all/// sub-architectures, the file does not explicitly specify a/// sub-architecture, or the sub-architecture is currently unrecognized./// Return true if the file can contain 64-bit addresses./// Return the kind of this object./// Get an iterator for the loadable segments in the file./// For ELF, this is program headers with type [`PT_LOAD`](crate::elf::PT_LOAD)./// For Mach-O, this is load commands with type [`LC_SEGMENT`](crate::macho::LC_SEGMENT)/// or [`LC_SEGMENT_64`](crate::macho::LC_SEGMENT_64)./// For PE, this is all sections./// Get the section named `section_name`, if such a section exists./// If `section_name` starts with a '.' then it is treated as a system/// section name, and is compared using the conventions specific to the/// object file format. This includes:/// - if ".debug_str_offsets" is requested for a Mach-O object file, then///   the actual section name that is searched for is "__debug_str_offs"./// - if ".debug_info" is requested for an ELF object file, then///   ".zdebug_info" may be returned (and similarly for other debug///   sections). Similarly, if ".debug_info" is requested for a Mach-O///   object file, then "__zdebug_info" may be returned./// For some object files, multiple segments may contain sections with the/// same name. In this case, the first matching section will be used./// This method skips over sections with invalid names./// Like [`Self::section_by_name`], but allows names that are not UTF-8./// Get the section at the given index./// The meaning of the index depends on the object file./// For some object files, this requires iterating through all sections./// Returns an error if the index is invalid./// Get an iterator for the sections in the file./// Get an iterator for the COMDAT section groups in the file./// Get the debugging symbol table, if any./// Get the debugging symbol at the given index./// Get an iterator for the debugging symbols in the file./// This may skip over symbols that are malformed or unsupported./// For Mach-O files, this does not include STAB entries.symbol_by_name/// Get the symbol named `symbol_name`, if the symbol exists.symbol_by_name_bytes/// Like [`Self::symbol_by_name`], but allows names that are not UTF-8./// Get the dynamic linking symbol table, if any./// Only ELF has a separate dynamic linking symbol table./// Consider using [`Self::exports`] or [`Self::imports`] instead./// Get an iterator for the dynamic linking symbols in the file./// Only ELF has dynamic linking symbols./// Other file formats will return an empty iterator./// Get the dynamic relocations for this file./// Symbol indices in these relocations refer to the dynamic symbol table./// Only ELF has dynamic relocations./// Construct a map from addresses to symbol names./// The map will only contain defined text and data symbols./// The dynamic symbol table will only be used if there are no debugging symbols./// This is derived from Mach-O STAB entries./// Get the imported symbols./// Get the exported symbols that expose both a name and an address./// Some file formats may provide other kinds of symbols that can be retrieved using/// the low level API./// Return true if the file contains DWARF debug information sections, false if not./// The UUID from a Mach-O [`LC_UUID`](crate::macho::LC_UUID) load command./// The build ID from an ELF [`NT_GNU_BUILD_ID`](crate::elf::NT_GNU_BUILD_ID) note./// The filename and CRC from a `.gnu_debuglink` section./// The filename and build ID from a `.gnu_debugaltlink` section./// The filename and GUID from the PE CodeView section./// Get the base address used for relative virtual addresses./// Currently this is only non-zero for PE./// Get the virtual address of the entry point of the binary./// An object file./// This is the primary trait for the unified read API./// Returns the virtual address of the segment./// Returns the size of the segment in memory./// Returns the alignment of the segment in memory./// Returns the offset and size of the segment in the file./// Returns a reference to the file contents of the segment./// The length of this data may be different from the size of the/// segment in memory./// Return the segment data in the given range./// Returns `Ok(None)` if the segment does not contain the given range./// Returns the name of the segment./// Returns an error if the name is not UTF-8./// Return the flags of segment./// A loadable segment in an [`Object`]./// This trait is part of the unified read API./// An iterator for the relocations for a section./// The first field in the item tuple is the section offset/// Returns the section index./// Returns the address of the section./// Returns the size of the section in memory./// Returns the alignment of the section in memory./// Returns offset and size of on-disk segment (if any)./// Returns the raw contents of the section./// section in memory./// This does not do any decompression./// Return the raw contents of the section data in the given range./// Returns `Ok(None)` if the section does not contain the given range./// Returns the potentially compressed file range of the section,/// along with information about the compression./// Returns the potentially compressed contents of the section,uncompressed_data/// Returns the uncompressed contents of the section./// If no compression is detected, then returns the data unchanged./// Returns `Err` if decompression fails./// Returns the name of the section./// Returns the name of the segment for this section./// Return the kind of this section./// Get the relocations for this section./// Construct a relocation map for this section./// A section in an [`Object`]./// An iterator for the sections in the section group./// Returns the COMDAT selection kind./// Returns the index of the symbol used for the name of COMDAT section group./// Returns the name of the COMDAT section group./// Get the sections in this section group./// A COMDAT section group in an [`Object`]./// A symbol table entry./// An iterator for the symbols in a symbol table./// Get an iterator for the symbols in the table./// A symbol table in an [`Object`]./// The index of the symbol./// The address of the symbol. May be zero if the address is unknown./// The size of the symbol. May be zero if the size is unknown./// Return the kind of this symbol./// Returns the section where the symbol is defined./// Returns the section index for the section containing this symbol./// Return true if the symbol is undefined./// Return true if the symbol is a definition of a function or data object/// that has a known address./// This is primarily used to implement [`Object::symbol_map`]./// Return true if the symbol is common data./// Note: does not check for [`SymbolSection::Section`] with [`SectionKind::Common`]./// Return true if the symbol is weak./// Returns the symbol scope./// Return true if the symbol visible outside of the compilation unit./// This treats [`SymbolScope::Unknown`] as global./// Return true if the symbol is only visible within the compilation unit./// A symbol table entry in an [`Object`]./// An iterator for files that don't have dynamic relocations./// A newtype for byte slices./// It has these important features:/// - no methods that can panic, such as `Index`/// - convenience methods for `Pod` types/// - a useful `Debug` implementation/// Return the length of the byte slice./// Return true if the byte slice is empty./// Skip over the given number of bytes at the start of the byte slice./// Modifies the byte slice to start after the bytes./// Returns an error if there are too few bytes./// Return a reference to the given number of bytes at the start of the byte slice./// Return a reference to the given number of bytes at the given offset of the byte slice./// Returns an error if the offset is invalid or there are too few bytes./// Return a reference to a `Pod` struct at the start of the byte slice./// Returns an error if there are too few bytes or the slice is incorrectly aligned./// Return a reference to a `Pod` struct at the given offset of the byte slice./// Returns an error if there are too few bytes or the offset is incorrectly aligned./// Return a reference to a slice of `Pod` structs at the start of the byte slice./// Return a reference to a slice of `Pod` structs at the given offset of the byte slice./// Read a null terminated string./// Does not assume any encoding./// Reads past the null byte, but doesn't return it.read_string_at/// Read a null terminated string at an offset./// Does not assume any encoding. Does not return the null byte./// Read an unsigned LEB128 number./// Read a signed LEB128 number./// A newtype for byte strings./// For byte slices that are strings of an unknown encoding./// A table of zero-terminated strings./// This is used by most file formats for strings such as section names and symbol names./// Interpret the given data as a string table./// Return the string at the given offset.bytes_debugwasmparserwpDataCountMAX_SECTION_ID// Update this constant when adding new section id:has_memory64// All sections, including custom sections.id_sections// Indices into `sections` of sections with a non-zero id.// Whether the file has DWARF information.WasmSymbolInternal// Symbols collected from imports, exports, code and name sections.// Address of the function body for the entry point.WasmFile/// A WebAssembly object file.LocalFunctionKindsymbol_idsExportedsymbol_id/// Parse the raw wasm data.add_sectionWasmSegmentWasmSegmentIteratorWasmSectionWasmSectionIteratorWasmComdatWasmComdatIteratorWasmSymbolWasmSymbolIteratorWasmSymbolTable/// An iterator for the segments in a [`WasmFile`]./// A segment in a [`WasmFile`]./// An iterator for the sections in a [`WasmFile`]./// A section in a [`WasmFile`].WasmRelocationIterator/// An iterator for the COMDAT section groups in a [`WasmFile`]./// A COMDAT section group in a [`WasmFile`].WasmComdatSectionIterator/// An iterator for the sections in a COMDAT section group in a [`WasmFile`]./// A symbol table in a [`WasmFile`]./// An iterator for the symbols in a [`WasmFile`]./// A symbol in a [`WasmFile`]./// An iterator for the relocations for a [`WasmSection`].//! Support for reading Wasm files.//! [`WasmFile`] implements the [`Object`] trait for Wasm files.XcoffComdatIterator/// An iterator for the COMDAT section groups in a [`XcoffFile32`](super::XcoffFile32)./// An iterator for the COMDAT section groups in a [`XcoffFile64`](super::XcoffFile64)./// An iterator for the COMDAT section groups in a [`XcoffFile`].XcoffComdat/// A COMDAT section group in a [`XcoffFile32`](super::XcoffFile32)./// A COMDAT section group in a [`XcoffFile64`](super::XcoffFile64)./// A COMDAT section group in a [`XcoffFile`].XcoffComdatSectionIterator/// An iterator for the sections in a COMDAT section group in a [`XcoffFile32`](super::XcoffFile32)./// An iterator for the sections in a COMDAT section group in a [`XcoffFile64`](super::XcoffFile64)./// An iterator for the sections in a COMDAT section group in a [`XcoffFile`].//! XCOFF doesn't support the COMDAT section.CsectAuxFileAuxXcoffSectionXcoffSectionIteratorXcoffSegmentXcoffSegmentIteratorXcoffSymbolIteratorXcoffSymbolTable/// A 32-bit XCOFF object file./// This is a file that starts with [`xcoff::FileHeader32`], and corresponds/// to [`crate::FileKind::Xcoff32`]./// A 64-bit XCOFF object file./// This is a file that starts with [`xcoff::FileHeader64`], and corresponds/// to [`crate::FileKind::Xcoff64`].aux_headerAuxHeader/// A partially parsed XCOFF file./// Parse the raw XCOFF file data./// Returns the raw XCOFF file header.xcoff_header/// Get the raw XCOFF file header.xcoff_aux_header/// Get the raw XCOFF auxiliary header.xcoff_section_table/// Get the XCOFF section table.xcoff_symbol_table/// Get the XCOFF symbol table.f_magicf_nscnsf_timdatf_symptrf_nsymsf_opthdr/// Read the auxiliary file header./// A trait for generic access to [`xcoff::FileHeader32`] and [`xcoff::FileHeader64`].AuxHeader32Symbol32FileAux32CsectAux32AuxHeader64Symbol64FileAux64CsectAux64o_mflago_vstampo_tsizeo_dsizeo_bsizeo_entryo_text_starto_data_starto_toco_snentryo_sntexto_sndatao_sntoco_snloadero_snbsso_algntexto_algndatao_modtypeo_cpuflago_cputypeo_maxstacko_maxdatao_debuggero_textpsizeo_datapsizeo_stackpsizeo_flagso_sntdatao_sntbsso_x64flags/// A trait for generic access to [`xcoff::AuxHeader32`] and [`xcoff::AuxHeader64`].//! Support for reading AIX XCOFF files.//! Traits are used to abstract over the difference between 32-bit and 64-bit XCOFF.//! [`XcoffFile`] implements the [`Object`](crate::read::Object) trait for XCOFF files.//! [`XcoffFile`] is parameterised by [`FileHeader`] to allow reading both 32-bit and//! 64-bit XCOFF. There are type aliases for these parameters ([`XcoffFile32`] and//! [`XcoffFile64`]).//! The [`FileHeader`] trait can be directly used to parse both [`xcoff::FileHeader32`]//! and [`xcoff::FileHeader64`].//! use object::xcoff;//! use object::read::xcoff::{FileHeader, SectionHeader, Symbol};//!     let header = xcoff::FileHeader64::parse(&*data, &mut offset)?;//!     let aux_header = header.aux_header(&*data, &mut offset)?;//!     let sections = header.sections(&*data, &mut offset)?;//!         println!("{}", String::from_utf8_lossy(section.name()));XcoffRelocationIterator/// An iterator for the relocations in an [`XcoffSection32`](super::XcoffSection32)./// An iterator for the relocations in an [`XcoffSection64`](super::XcoffSection64)./// An iterator for the relocations in an [`XcoffSection`](super::XcoffSection).r_vaddrr_symndx/// A trait for generic access to [`xcoff::Rel32`] and [`xcoff::Rel64`]./// An iterator for the sections in an [`XcoffFile32`](super::XcoffFile32)./// An iterator for the sections in an [`XcoffFile64`](super::XcoffFile64)./// An iterator for the sections in an [`XcoffFile`]./// A section in an [`XcoffFile32`](super::XcoffFile32)./// A section in an [`XcoffFile64`](super::XcoffFile64)./// A section in an [`XcoffFile`].xcoff_file/// Get the XCOFF file containing this section.xcoff_section/// Get the raw XCOFF section header.xcoff_relocations/// Get the raw XCOFF relocation entries for this section./// The table of section headers in an XCOFF file.HalfWords_paddrs_vaddrs_sizes_scnptrs_relptrs_lnnoptrs_nrelocs_nlnno/// Read the relocations./// A trait for generic access to [`xcoff::SectionHeader32`] and [`xcoff::SectionHeader64`]./// Read the relocations in a XCOFF32 file./// Read the relocations in a XCOFF64 file./// An iterator for the segments in an [`XcoffFile32`](super::XcoffFile32)./// An iterator for the segments in an [`XcoffFile64`](super::XcoffFile64)./// An iterator for the segments in an [`XcoffFile`]./// A segment in an [`XcoffFile32`](super::XcoffFile32)./// A segment in an [`XcoffFile64`](super::XcoffFile64)./// A loadable section in an [`XcoffFile`].//! TODO: Support the segment for XCOFF when auxiliary file header and loader section is ready.SymbolBytes/// A table of symbol entries in an XCOFF file./// Returned by [`FileHeader::symbols`]./// Parse the symbol table./// This does not return null symbols.iter_none/// Empty symbol iterator./// Return the symbol entry at the given index and offset.symbol_unchecked/// This does not check if the symbol is null, but does check if the index is in bounds./// Returns an error for null symbols and out of bounds indices./// Note that this is unable to check whether the index is an auxiliary symbol.aux_file/// Return a file auxiliary symbol.aux_csect/// Return the csect auxiliary symbol./// An iterator for symbol entries in an XCOFF file./// A symbol table in an [`XcoffFile32`](super::XcoffFile32)./// A symbol table in an [`XcoffFile64`](super::XcoffFile64)./// A symbol table in an [`XcoffFile`]./// An iterator for the symbols in an [`XcoffFile32`](super::XcoffFile32)./// An iterator for the symbols in an [`XcoffFile64`](super::XcoffFile64)./// An iterator for the symbols in an [`XcoffFile`]./// A symbol in an [`XcoffFile32`](super::XcoffFile32)./// A symbol in an [`XcoffFile64`](super::XcoffFile64)./// A symbol in an [`XcoffFile`]./// Get the XCOFF file containing this symbol.xcoff_symbol/// Get the raw XCOFF symbol structure.n_scnumn_numaux/// Return true if the symbol is a null placeholder.has_aux_file/// Return true if the symbol has file auxiliary entry.has_aux_csect/// Return true if the symbol has csect auxiliary entry./// A csect auxiliary entry is required for each symbol table entry that has/// a storage class value of C_EXT, C_WEAKEXT, or C_HIDEXT./// A trait for generic access to [`xcoff::Symbol32`] and [`xcoff::Symbol64`]./// Parse the symbol name for XCOFF64./// Parse the symbol name for XCOFF32.x_fnamex_ftypex_auxtypefname/// Parse the x_fname field, which may be an inline string or a string table offset./// A trait for generic access to [`xcoff::FileAux32`] and [`xcoff::FileAux64`].x_scnlenx_parmhashx_snhashx_stabx_snstabsym_type/// A trait for generic access to [`xcoff::CsectAux32`] and [`xcoff::CsectAux64`].//! Support for writing COFF files.//! Provides [`Writer`] for low level writing of COFF files.//! This is also used to provide COFF support for [`write::Object`](crate::write::Object).reloc_offsetSectionOffsetsaux_countSymbolOffsetsCoffExportStyle/// MSVC format supported by link.exe and LLD./// Gnu format supported by GNU LD and LLD./// Internal format to use for the `.drectve` section containing linker/// directives for symbol exports.coff_section_infoStandardSectioncoff_subsection_namecoff_translate_relocationcoff_adjust_addendcoff_relocation_sizecoff_add_stub_symboladd_coff_exports/// Appends linker directives to the `.drectve` section to tell the linker/// to export all symbols with `SymbolScope::Dynamic`./// This must be called after all symbols have been defined.coff_write// JamCRCsection_numsymtab_offsetsymtab_numstrtabstrtab_lenstrtab_offsetstrtab_data/// A helper for writing COFF files./// Writing uses a two phase approach. The first phase builds up all of the information/// that may need to be known ahead of time:/// - build string table/// - reserve section indices/// - reserve symbol indices/// - reserve file ranges for headers and sections/// Some of the information has ordering requirements. For example, strings must be added/// to the string table before reserving the file range for the string table. There are debug/// asserts to check some of these requirements./// The second phase writes everything out in order. Thus the caller must ensure writing/// is in the same order that file ranges were reserved. There are debug asserts to assist/// with checking this./// Create a new `Writer`.reserved_len/// Return the current file length that has been reserved./// Return the current file length that has been written./// Reserve a file range with the given size and starting alignment./// Returns the aligned offset of the start of the range./// `align_start` must be a power of two.write_align/// Write alignment padding bytes.reserve_until/// Reserve the file range up to the given file offset.pad_until/// Write padding up to the given file offset.reserve_file_header/// Reserve the range for the file header./// This must be at the start of the file.write_file_header/// Write the file header./// Fields that can be derived from known information are automatically set by this function.reserve_section_headers/// Reserve the range for the section headers.write_section_header/// Write a section header.reserve_section/// Reserve the range for the section data./// Does nothing and returns 0 if the length is zero.write_section_align/// Write the alignment bytes prior to section data./// This is unneeded if you are using `write_section` or `write_section_zeroes`/// for the data.write_section/// Write the section data./// Writes alignment bytes prior to the data./// Does nothing if the data is empty.write_section_zeroes/// Write the section data using zero bytes./// Does nothing if the length is zero.reserve_relocations/// Reserve a file range for the given number of relocations./// This will automatically reserve an extra relocation if there are more than 0xffff./// Returns the offset of the range./// Does nothing and returns 0 if the count is zero.write_relocations_count/// Write a relocation containing the count if required./// This should be called before writing the first relocation for a section.write_relocation/// Write a relocation.reserve_symbol_index/// Reserve a symbol table entry./// This must be called before [`Self::reserve_symtab_strtab`].reserve_symbol_indices/// Reserve a number of symbol table entries.write_symbol/// Write a symbol table entry.reserve_aux_file_name/// Reserve auxiliary symbols for a file name./// Returns the number of auxiliary symbols required.write_aux_file_name/// Write auxiliary symbols for a file name.reserve_aux_section/// Reserve an auxiliary symbol for a section.write_aux_sectionAuxSymbolSection/// Write an auxiliary symbol for a section.symbol_count/// Return the number of reserved symbol table entries.add_string/// Add a string to the string table.add_name/// Add a section or symbol name to the string table if required.reserve_symtab_strtab/// Reserve the range for the symbol table and string table./// This must be called after functions that reserve symbol/// indices or add strings.write_strtab/// Write the string table./// Shortened and native endian version of [`pe::ImageFileHeader`]./// An inline name./// An id of a string table entry./// A section or symbol name.// From isn't useful./// This will automatically be clamped if there are more than 0xffff./// Native endian version of [`pe::ImageSectionHeader`]./// Native endian version of [`pe::ImageSymbol`]./// Native endian version of [`pe::ImageAuxSymbolSection`]./// Native endian version of [`pe::ImageRelocation`].//! Helper for writing COFF files.//! Support for writing ELF files.//! Provides [`Writer`] for low level writing of ELF files.//! This is also used to provide ELF support for [`write::Object`](crate::write::Object).str_idComdatOffsetsreloc_str_idadd_elf_gnu_property_u32/// Add a property with a u32 value to the ELF ".note.gnu.property" section./// Requires `feature = "elf"`.// Public methods.elf_section_infoelf_subsection_nameelf_has_relocation_addendelf_translate_relocationelf_adjust_addendelf_relocation_sizeelf_is_64elf_write// Private methods./// The index of an ELF section./// The index of an ELF symbol.elf_alignsegment_offsetsegment_numsection_offsetshstrtabshstrtab_str_idshstrtab_indexshstrtab_offsetshstrtab_dataneed_strtabstrtab_str_idstrtab_indexsymtab_str_idsymtab_indexneed_symtab_shndxsymtab_shndx_str_idsymtab_shndx_offsetsymtab_shndx_dataneed_dynstrdynstrdynstr_str_iddynstr_indexdynstr_offsetdynstr_datadynsym_str_iddynsym_indexdynsym_offsetdynsym_numdynamic_str_iddynamic_offsetdynamic_numhash_str_idhash_offsetgnu_hash_str_idgnu_hash_offsetgnu_versym_str_idgnu_versym_offsetgnu_verdef_str_idgnu_verdef_offsetgnu_verdef_countgnu_verdef_remaininggnu_verdaux_remaininggnu_verneed_str_idgnu_verneed_offsetgnu_verneed_countgnu_verneed_remaininggnu_vernaux_remaininggnu_attributes_str_idgnu_attributes_offsetgnu_attributes_size/// A helper for writing ELF files./// - build string tables/// to string tables before reserving the file range for the string table. Symbol indices/// must be reserved after reserving the section indices they reference. There are debug/// Create a new `Writer` for the given endianness and ELF class./// Get the file class that will be written./// This is typically used to write section data.reserve_program_headers/// Reserve the range for the program headers.write_align_program_headers/// Write alignment padding bytes prior to the program headers.write_program_header/// Write a program header.reserve_null_section_index/// Reserve the section index for the null section header./// The null section header is usually automatically reserved,/// but this can be used to force an empty section table./// This must be called before [`Self::reserve_section_headers`].reserve_section_index/// Reserve a section table index./// Automatically also reserves the null section header if required./// This function does nothing if no sections were reserved./// This must be called after [`Self::reserve_section_index`]/// and other functions that reserve section indices.write_null_section_header/// Write the null section header./// This must be the first section header that is written.add_section_name/// Add a section name to the section header string table./// This will be stored in the `.shstrtab` section./// This must be called before [`Self::reserve_shstrtab`].reserve_shstrtab/// Reserve the range for the section header string table./// This range is used for a section named `.shstrtab`./// This must be called after [`Self::add_section_name`]./// and other functions that reserve section names and indices.write_shstrtab/// Write the section header string table./// This function does nothing if the section was not reserved.reserve_shstrtab_section_index/// Reserve the section index for the section header string table./// This must be called before [`Self::reserve_shstrtab`]/// and [`Self::reserve_section_headers`].reserve_shstrtab_section_index_with_namewrite_shstrtab_section_header/// Write the section header for the section header string table./// This function does nothing if the section index was not reserved./// This will be stored in the `.strtab` section./// This must be called before [`Self::reserve_strtab`].strtab_needed/// Return true if `.strtab` is needed.require_strtab/// Require the string table even if no strings were added.reserve_strtab/// Reserve the range for the string table./// This range is used for a section named `.strtab`./// This function does nothing if no strings were defined./// This must be called after [`Self::add_string`].reserve_strtab_section_index/// Reserve the section index for the string table.reserve_strtab_section_index_with_namewrite_strtab_section_header/// Write the section header for the string table.reserve_null_symbol_index/// Reserve the null symbol table entry./// This will be stored in the `.symtab` section./// The null symbol table entry is usually automatically reserved,/// but this can be used to force an empty symbol table./// This must be called before [`Self::reserve_symtab`]./// `section_index` is used to determine whether `.symtab_shndx` is required./// Automatically also reserves the null symbol if required./// Callers may assume that the returned indices will be sequential/// starting at 1./// This must be called before [`Self::reserve_symtab`] and/// [`Self::reserve_symtab_shndx`]./// Includes the null symbol.reserve_symtab/// Reserve the range for the symbol table./// This range is used for a section named `.symtab`./// This function does nothing if no symbols were reserved./// This must be called after [`Self::reserve_symbol_index`].write_null_symbol/// Write the null symbol./// This must be the first symbol that is written./// Write a symbol.reserve_symtab_section_index/// Reserve the section index for the symbol table.reserve_symtab_section_index_with_name/// Return the section index of the symbol table.write_symtab_section_header/// Write the section header for the symbol table.symtab_shndx_needed/// Return true if `.symtab_shndx` is needed.require_symtab_shndx/// Require the extended section indices for the symbol table even/// if no section indices are too large.reserve_symtab_shndx/// Reserve the range for the extended section indices for the symbol table./// This range is used for a section named `.symtab_shndx`./// This also reserves a section index./// This function does nothing if extended section indices are not needed.write_symtab_shndx/// Write the extended section indices for the symbol table.reserve_symtab_shndx_section_index/// Reserve the section index for the extended section indices symbol table./// You should check [`Self::symtab_shndx_needed`] before calling this/// unless you have other means of knowing if this section is needed.reserve_symtab_shndx_section_index_with_namewrite_symtab_shndx_section_header/// Write the section header for the extended section indices for the symbol table.add_dynamic_string/// Add a string to the dynamic string table./// This will be stored in the `.dynstr` section./// This must be called before [`Self::reserve_dynstr`].get_dynamic_string/// Get a string that was previously added to the dynamic string table./// Panics if the string was not added.dynstr_needed/// Return true if `.dynstr` is needed.require_dynstr/// Require the dynamic string table even if no strings were added.reserve_dynstr/// Reserve the range for the dynamic string table./// This range is used for a section named `.dynstr`./// This function does nothing if no dynamic strings were defined./// This must be called after [`Self::add_dynamic_string`].dynstr_len/// Return the size of the dynamic string table./// This must be called after [`Self::reserve_dynstr`].write_dynstr/// Write the dynamic string table.reserve_dynstr_section_index/// Reserve the section index for the dynamic string table.reserve_dynstr_section_index_with_name/// Return the section index of the dynamic string table.write_dynstr_section_header/// Write the section header for the dynamic string table.reserve_null_dynamic_symbol_index/// Reserve the null dynamic symbol table entry./// This will be stored in the `.dynsym` section./// The null dynamic symbol table entry is usually automatically reserved,/// but this can be used to force an empty dynamic symbol table./// This must be called before [`Self::reserve_dynsym`].reserve_dynamic_symbol_index/// Reserve a dynamic symbol table entry.dynamic_symbol_count/// Return the number of reserved dynamic symbols.reserve_dynsym/// Reserve the range for the dynamic symbol table./// This range is used for a section named `.dynsym`./// This function does nothing if no dynamic symbols were reserved./// This must be called after [`Self::reserve_dynamic_symbol_index`].write_null_dynamic_symbol/// Write the null dynamic symbol./// This must be the first dynamic symbol that is written.write_dynamic_symbol/// Write a dynamic symbol.reserve_dynsym_section_index/// Reserve the section index for the dynamic symbol table.reserve_dynsym_section_index_with_name/// Return the section index of the dynamic symbol table.write_dynsym_section_header/// Write the section header for the dynamic symbol table.reserve_dynamic/// Reserve the range for the `.dynamic` section./// This function does nothing if `dynamic_num` is zero.write_align_dynamic/// Write alignment padding bytes prior to the `.dynamic` section.reserve_dynamics/// Reserve a file range for the given number of dynamic entries.write_dynamic_string/// Write a dynamic string entry.write_dynamic/// Write a dynamic value entry.reserve_dynamic_section_index/// Reserve the section index for the dynamic table.write_dynamic_section_header/// Write the section header for the dynamic table.reserve_hash/// Reserve a file range for a SysV hash section./// `symbol_count` is the number of symbols in the hash,/// not the total number of symbols.write_hash/// Write a SysV hash section./// `chain_count` is the number of symbols in the hash./// The argument to `hash` will be in the range `0..chain_count`.reserve_hash_section_index/// Reserve the section index for the SysV hash table.reserve_hash_section_index_with_namewrite_hash_section_header/// Write the section header for the SysV hash table.reserve_gnu_hash/// Reserve a file range for a GNU hash section.write_gnu_hash/// Write a GNU hash section./// `symbol_count` is the number of symbols in the hash./// The argument to `hash` will be in the range `0..symbol_count`./// This requires that symbols are already sorted by bucket.reserve_gnu_hash_section_index/// Reserve the section index for the GNU hash table.reserve_gnu_hash_section_index_with_namewrite_gnu_hash_section_header/// Write the section header for the GNU hash table.reserve_gnu_versym/// Reserve the range for the `.gnu.version` section.write_null_gnu_versym/// Write the null symbol version entry./// This must be the first symbol version that is written.write_gnu_versym/// Write a symbol version entry.reserve_gnu_versym_section_index/// Reserve the section index for the `.gnu.version` section.reserve_gnu_versym_section_index_with_namewrite_gnu_versym_section_header/// Write the section header for the `.gnu.version` section.reserve_gnu_verdef/// Reserve the range for the `.gnu.version_d` section.write_align_gnu_verdef/// Write alignment padding bytes prior to a `.gnu.version_d` section.write_gnu_verdef/// Write a version definition entry.write_gnu_verdaux/// Write a version definition auxiliary entry.reserve_gnu_verdef_section_index/// Reserve the section index for the `.gnu.version_d` section.reserve_gnu_verdef_section_index_with_namewrite_gnu_verdef_section_header/// Write the section header for the `.gnu.version_d` section.reserve_gnu_verneed/// Reserve the range for the `.gnu.version_r` section.write_align_gnu_verneed/// Write alignment padding bytes prior to a `.gnu.version_r` section.write_gnu_verneed/// Write a version need entry.write_gnu_vernaux/// Write a version need auxiliary entry.reserve_gnu_verneed_section_index/// Reserve the section index for the `.gnu.version_r` section.reserve_gnu_verneed_section_index_with_namewrite_gnu_verneed_section_header/// Write the section header for the `.gnu.version_r` section.reserve_gnu_attributes_section_index/// Reserve the section index for the `.gnu.attributes` section.reserve_gnu_attributes_section_index_with_namereserve_gnu_attributes/// Reserve the range for the `.gnu.attributes` section.write_gnu_attributes_section_header/// Write the section header for the `.gnu.attributes` section.write_gnu_attributes/// Write the data for the `.gnu.attributes` section.write_align_relocation/// Write alignment padding bytes prior to a relocation section.write_relocation_section_header/// Write the section header for a relocation section./// `section` is the index of the section the relocations apply to,/// or 0 if none./// `symtab` is the index of the symbol table the relocations refer to,/// `offset` is the file offset of the relocations.reserve_comdat/// Reserve a file range for a COMDAT section./// `count` is the number of sections in the COMDAT group.write_comdat_header/// Write `GRP_COMDAT` at the start of the COMDAT section.write_comdat_entry/// Write an entry in a COMDAT section.write_comdat_section_header/// Write the section header for a COMDAT section.attributes_writerAttributesWriter/// Return a helper for writing an attributes section.subsection_offsetsubsubsection_offset/// A helper for writing an attributes section./// Attributes have a variable length encoding, so it is awkward to write them in a/// single pass. Instead, we build the entire attributes section data in memory, using/// placeholders for unknown lengths that are filled in later./// Create a new `AttributesWriter` for the given endianness.start_subsection/// Start a new subsection with the given vendor name.end_subsection/// End the subsection./// The subsection length is automatically calculated and written.start_subsubsection/// Start a new sub-subsection with the given tag.write_subsubsection_index/// Write a section or symbol index to the sub-subsection./// The user must also call this function to write the terminating 0 index.write_subsubsection_indices/// Write raw index data to the sub-subsection./// The terminating 0 index is automatically written.write_attribute_tag/// Write an attribute tag to the sub-subsection.write_attribute_integer/// Write an attribute integer value to the sub-subsection.write_attribute_string/// Write an attribute string value to the sub-subsection./// The value must not include the null terminator.write_subsubsection_attributes/// Write raw attribute data to the sub-subsection.end_subsubsection/// End the sub-subsection./// The sub-subsection length is automatically calculated and written./// Return the completed section data./// Whether the file is 64-bit./// An ELF file class./// Return the alignment size./// Return the size of the file header.program_header_size/// Return the size of a program header.section_header_size/// Return the size of a section header.sym_size/// Return the size of a symbol.rel_size/// Return the size of a relocation entry.dyn_size/// Return the size of a dynamic entry./// Return the size of a hash table./// Return the size of a GNU hash table./// Return the size of a GNU symbol version section./// Return the size of a GNU version definition section./// Return the size of a GNU version dependency section./// Native endian version of [`elf::FileHeader64`]./// Native endian version of [`elf::ProgramHeader64`]./// Native endian version of [`elf::SectionHeader64`]./// Native endian version of [`elf::Sym64`]./// Unified native endian version of [`elf::Rel64`] and [`elf::Rela64`]./// The name for the first [`elf::Verdaux`] entry./// Information required for writing [`elf::Verdef`]./// Information required for writing [`elf::Verneed`]./// Information required for writing [`elf::Vernaux`].//! Helper for writing ELF files.reloc_count/// One of the `PLATFORM_` constants (for example,/// [`object::macho::PLATFORM_MACOS`](macho::PLATFORM_MACOS))./// The minimum OS version, where `X.Y.Z` is encoded in nibbles as/// `xxxx.yy.zz`./// The SDK version as `X.Y.Z`, where `X.Y.Z` is encoded in nibbles asMachOBuildVersion/// The customizable portion of a [`macho::BuildVersionCommand`].// May want to add the tool list?set_macho_cpu_subtype/// Specify the Mach-O CPU subtype./// Requires `feature = "macho"`.set_macho_build_version/// Specify information for a Mach-O `LC_BUILD_VERSION` command.macho_segment_nameStandardSegmentmacho_section_infomacho_tlv_bootstrapmacho_add_thread_var/// Create the `__thread_vars` entry for a TLS variable./// The symbol given by `symbol_id` will be updated to point to this entry./// A new `SymbolId` will be returned. The caller must update this symbol/// to point to the initializer./// If `symbol_id` is not for a TLS variable, then it is returned unchanged.macho_translate_relocationmacho_adjust_addendmacho_relocation_sizemacho_writeSegmentCommandmach_header_sizesegment_command_sizenlist_sizewrite_mach_headerwrite_segment_commandwrite_nlist/// The error type used within the write module./// The result type used within the write module.standard_sectionsMangling/// The symbol name mangling scheme.stub_symbolstlv_bootstrap/// Mach-O "_tlv_bootstrap" symbol.macho_cpu_subtype/// Mach-O CPU subtype.macho_build_versionmacho_subsections_via_symbols/// Mach-O MH_SUBSECTIONS_VIA_SYMBOLS flag. Only ever set if format is Mach-O./// A writable relocatable object file./// Create an empty object file./// Return the architecture./// Return the sub-architecture.set_sub_architecture/// Specify the sub-architecture./// Return the current mangling setting.set_mangling/// Specify the mangling setting./// Return the name for a standard segment./// This will vary based on the file format./// Get the section with the given `SectionId`.section_mut/// Mutably get the section with the given `SectionId`.set_section_data/// Set the data for an existing section./// Must not be called for sections that already have data, or that contain uninitialized data./// `align` must be a power of two.append_section_data/// Append data to an existing section. Returns the section offset of the data./// Must not be called for sections that contain uninitialized data.append_section_bss/// Append zero-initialized data to an existing section. Returns the section offset of the data./// Must not be called for sections that contain initialized data.section_id/// Return the `SectionId` of a standard section./// If the section doesn't already exist then it is created./// Add a new section and return its `SectionId`./// This also creates a section symbol.section_infoadd_subsection/// Add a subsection. Returns the `SectionId` and section offset of the data./// For Mach-O, this does not create a subsection, and instead uses the/// section from [`Self::section_id`]. Use [`Self::set_subsections_via_symbols`]/// to enable subsections via symbols.has_subsections_via_symbolsset_subsections_via_symbols/// Enable subsections via symbols if supported./// This should be called before adding any subsections or symbols./// For Mach-O, this sets the `MH_SUBSECTIONS_VIA_SYMBOLS` flag./// For other formats, this does nothing.subsection_infosubsection_nameComdatId/// Get the COMDAT section group with the given `ComdatId`.comdat_mut/// Mutably get the COMDAT section group with the given `ComdatId`.add_comdat/// Add a new COMDAT section group and return its `ComdatId`./// Get the `SymbolId` of the symbol with the given name./// Get the symbol with the given `SymbolId`.symbol_mut/// Mutably get the symbol with the given `SymbolId`./// Add a new symbol and return its `SymbolId`.add_raw_symbolhas_uninitialized_tls/// Return true if the file format supports `StandardSection::UninitializedTls`.has_common/// Return true if the file format supports `StandardSection::Common`.add_common_symbol/// Add a new common symbol and return its `SymbolId`./// For Mach-O, this appends the symbol to the `__common` section.add_file_symbol/// Add a new file symbol and return its `SymbolId`.section_symbol/// Get the symbol for a section.add_symbol_data/// Append data to an existing section, and update a symbol to refer to it./// For Mach-O, this also creates a `__thread_vars` entry for TLS symbols, and the/// symbol will indirectly point to the added data via the `__thread_vars` entry./// For Mach-O, if [`Self::set_subsections_via_symbols`] is enabled, this will/// automatically ensure the data size is at least 1./// Returns the section offset of the data.add_symbol_bss/// Append zero-initialized data to an existing section, and update a symbol to refer to it.set_symbol_data/// Update a symbol to refer to the given data within a section./// symbol will indirectly point to the data via the `__thread_vars` entry.symbol_section_and_offset/// Convert a symbol to a section symbol and offset./// Returns `None` if the symbol does not have a section.add_relocation/// Add a relocation to a section./// Relocations must only be added after the referenced symbols have been added/// and defined (if applicable).write_relocation_addend/// Write the object to a `Vec`./// Write the object to a `Write` implementation./// Also flushes the writer./// It is advisable to use a buffered writer like [`BufWriter`](std::io::BufWriter)/// instead of an unbuffered writer like [`File`](std::fs::File)./// Write the object to a `WritableBuffer`./// A standard segment kind./// Zero-fill TLS initializers. Unsupported for COFF./// TLS variable structures. Only supported for Mach-O./// Common data. Only supported for Mach-O./// Notes for GNU properties. Only supported for ELF./// A standard section kind./// Return the section kind of a standard section.// TODO: remembering to update this is error-prone, can we do better?/// An identifier used to reference a section./// A section in an object file./// Try to convert the name to a utf8 string./// Try to convert the segment to a utf8 string./// Set the data for a section.append_data/// Append data to a section.append_bss/// Append uninitialized data to a section./// Returns the section as-built so far./// This requires that the section is not a bss section./// The section where a symbol is defined./// Returns the section id for the section where the symbol is defined./// An identifier used to reference a symbol./// The value of the symbol./// If the symbol defined in a section, then this is the section offset of the symbol./// The size of the symbol./// The kind of the symbol./// The scope of the symbol./// Whether the symbol has weak binding./// The section containing the symbol./// A symbol in an object file./// Note: does not check for `SymbolSection::Section` with `SectionKind::Common`./// Return true if the symbol scope is local./// The section offset of the place of the relocation./// The symbol referred to by the relocation./// This may be a section symbol./// This may be in addition to an implicit addend stored at the place of the relocation./// The fields that define the relocation type./// A relocation in an object file./// An identifier used to reference a COMDAT section group./// The COMDAT selection kind./// The COMDAT symbol./// If this symbol is referenced, then all sections in the group will be included by the/// linker./// The sections in the group./// A COMDAT section group./// No symbol mangling./// Windows COFF symbol mangling.CoffI386/// Windows COFF i386 symbol mangling./// ELF symbol mangling./// Mach-O symbol mangling./// Xcoff symbol mangling./// Return the default symboling mangling for the given format and architecture.global_prefix/// Return the prefix to use for global symbols.//! Interface for writing object files.//! This module provides a unified write API for relocatable object files//! using [`Object`]. This does not support writing executable files.//! This supports the following file formats: COFF, ELF, Mach-O, and XCOFF.//! The submodules define helpers for writing the raw structs. These support//! writing both relocatable and executable files. There are writers for//! the following file formats: [COFF](coff::Writer), [ELF](elf::Writer),//! and [PE](pe::Writer).virtual_lenheaders_lencode_addressdata_addresscode_lenbss_lenDataDirectorysection_header_numsymbol_offsetsymbol_numreloc_blocksRelocBlock/// A helper for writing PE files./// Writing uses a two phase approach. The first phase reserves file ranges and virtual/// address ranges for everything in the order that they will be written./// is in the same order that file ranges were reserved./// The alignment values must be powers of two./// Return the current virtual address size that has been reserved./// This is only valid after section headers have been reserved.reserve_virtual/// Reserve a virtual address range with the given size./// The reserved length will be increased to match the section alignment.reserve_virtual_until/// Reserve up to the given virtual address.reserve_file/// Reserve a file range with the given size and using the file alignment.reserve_align/// Reserve alignment padding bytes.write_file_align/// Write padding up to the next multiple of file alignment.reserve_dos_header/// Reserve the range for the DOS header./// When writing, you may use `write_custom_dos_header` or `write_empty_dos_header`.write_custom_dos_header/// Write a custom DOS header.write_empty_dos_header/// Write the DOS header for a file without a stub./// Uses default values for all fields.reserve_dos_header_and_stub/// Reserve a fixed DOS header and stub./// Use `reserve_dos_header` and `reserve` if you need a custom stub.write_dos_header_and_stub/// Write a fixed DOS header and stub./// Use `write_custom_dos_header` and `write` if you need a custom stub.nt_headers_sizeoptional_header_size/// Return the offset of the NT headers, if reserved.reserve_nt_headers/// Reserve the range for the NT headers.set_data_directory/// Set the virtual address and size of a data directory.write_nt_headersNtHeaders/// Write the NT headers./// Reserve the section headers./// The number of reserved section headers must be the same as the number of sections that/// are later reserved.// TODO: change this to a maximum number of sections?write_section_headers/// Write the section headers./// This uses information that was recorded when the sections were reserved.SectionRange/// Reserve a section./// Returns the file range and virtual address range that are reserved/// for the section./// Write the data for a section.reserve_text_section/// Reserve a `.text` section./// Contains executable code.reserve_data_section/// Reserve a `.data` section./// Contains initialized data./// May also contain uninitialized data if `virtual_size` is greater than `data_size`.reserve_rdata_section/// Reserve a `.rdata` section./// Contains read-only initialized data.reserve_bss_section/// Reserve a `.bss` section./// Contains uninitialized data.reserve_idata_section/// Reserve an `.idata` section./// Contains import tables. Note that it is permissible to store import tables in a different/// This also sets the `pe::IMAGE_DIRECTORY_ENTRY_IMPORT` data directory.reserve_edata_section/// Reserve an `.edata` section./// Contains export tables./// This also sets the `pe::IMAGE_DIRECTORY_ENTRY_EXPORT` data directory.reserve_pdata_section/// Reserve a `.pdata` section./// Contains exception information./// This also sets the `pe::IMAGE_DIRECTORY_ENTRY_EXCEPTION` data directory.reserve_xdata_section/// Reserve a `.xdata` section.reserve_rsrc_section/// Reserve a `.rsrc` section./// Contains the resource directory./// This also sets the `pe::IMAGE_DIRECTORY_ENTRY_RESOURCE` data directory.add_reloc/// Add a base relocation./// `typ` must be one of the `IMAGE_REL_BASED_*` constants.has_relocs/// Return true if a base relocation has been added.reserve_reloc_section/// Reserve a `.reloc` section./// This contains the base relocations that were added with `add_reloc`./// This also sets the `pe::IMAGE_DIRECTORY_ENTRY_BASERELOC` data directory.write_reloc_section/// Write a `.reloc` section.reserve_certificate_table/// Reserve the certificate table./// This also sets the `pe::IMAGE_DIRECTORY_ENTRY_SECURITY` data directory.// TODO: reserve individual certificateswrite_certificate_table/// Write the certificate table.// TODO: write individual certificates// ImageFileHeader// ImageOptionalHeader/// Information required for writing [`pe::ImageNtHeaders32`] or [`pe::ImageNtHeaders64`]./// Information required for writing [`pe::ImageSectionHeader`]./// The file range and virtual address range for a section.//! Helper for writing PE files./// An identifier for an entry in a string table./// Panics if the string table has already been written, or/// if the string contains a null byte./// Return the id of the given string./// Panics if the string is not in the string table./// Return the string for the given id./// Return the offset of the given string./// Panics if the string table has not been written, or/// if the string is not in the string table./// Append the string table to the given `Vec`, and/// calculate the list of string offsets./// `base` is the initial string table offset. For example,/// this should be 1 for ELF, to account for the initial/// null byte (which must have been written by the caller)./// Panics if the string table has already been written./// Calculate the size in bytes of the string table./// null byte.// Multi-key quicksort.// Ordering is such that if a string is a suffix of at least one other string,// then it is placed immediately after one of those strings. That is:// - comparison starts at the end of the string// - shorter strings come later// Based on the implementation in LLVM.string_table/// Returns position/offset for data to be written at./// Should only be used in debug assertions/// Reserves specified number of bytes in the buffer./// This will be called exactly once before writing anything to the buffer,/// and the given size is the exact total number of bytes that will be written./// Writes zero bytes at the end of the buffer until the buffer/// has the specified length./// Writes the specified slice of bytes at the end of the buffer.write_pod/// Writes the specified `Pod` type at the end of the buffer.write_pod_slice/// Writes the specified `Pod` slice at the end of the buffer./// Trait for writable buffer.StreamingBuffer/// A [`WritableBuffer`] that streams data to a [`Write`](std::io::Write) implementation./// [`Self::result`] must be called to determine if an I/O error occurred during writing./// Create a new `StreamingBuffer` backed by the given writer./// Unwraps this [`StreamingBuffer`] giving back the original writer./// Returns any error that occurred during writing./// A trait for mutable byte slices./// It provides convenience methods for `Pod` types./// Write an unsigned number using the LEB128 encoding to a buffer./// Write a signed number using the LEB128 encoding to a buffer.align_u32align_u64xcoff_section_infoxcoff_translate_relocationxcoff_adjust_addendxcoff_relocation_sizexcoff_write/// Magic number. Must be 0x01DF./// Number of sections./// Time and date of file creation./// Byte offset to symbol table start./// Number of entries in symbol table./// Number of bytes in optional header/// Extra flags./// The header at the start of every 32-bit XCOFF file./// Magic number. Must be 0x01F7./// Time and date of file creation/// The header at the start of every 64-bit XCOFF file.MAGIC_64// Values for `f_magic`.MAGIC_32/// the 32-bit mach magic numberF_RELFLG// Values for `f_flags`./// Indicates that the relocation information for binding has been removed from/// the file.F_EXEC/// Indicates that the file is executable. No unresolved external references exist.F_LNNO/// Indicates that line numbers have been stripped from the file by a utility program.F_FDPR_PROF/// Indicates that the file was profiled with the fdpr command.F_FDPR_OPTI/// Indicates that the file was reordered with the fdpr command.F_DSA/// Indicates that the file uses Very Large Program Support.F_VARPG/// Indicates that one of the members of the auxiliary header specifying the/// medium page sizes is non-zero.F_DYNLOAD/// Indicates the file is dynamically loadable and executable. External references/// are resolved by way of imports, and the file might contain exports and loader/// relocation.F_SHROBJ/// Indicates the file is a shared object (shared library). The file is separately/// loadable. That is, it is not normally bound with other objects, and its loader/// exports symbols are used as automatic import symbols for other object files.F_LOADONLY/// If the object file is a member of an archive, it can be loaded by the system/// loader, but the member is ignored by the binder. If the object file is not in/// an archive, this flag has no effect./// Version./// Text size in bytes./// Initialized data size in bytes./// Uninitialized data size in bytes./// Entry point descriptor (virtual address)./// Base address of text (virtual address)./// Base address of data (virtual address)./// Address of TOC anchor./// Section number for entry point./// Section number for .text./// Section number for .data./// Section number for TOC./// Section number for loader data./// Section number for .bss./// Maximum alignment for .text./// Maximum alignment for .data./// Module type field./// Bit flags - cpu types of objects./// Reserved for CPU type./// Maximum stack size allowed (bytes)./// Maximum data size allowed (bytes)./// Reserved for debuggers./// Requested text page size./// Requested data page size./// Requested stack page size./// Flags and thread-local storage alignment./// Section number for .tdata./// Section number for .tbss./// The auxiliary header immediately following file header. If the value of the/// f_opthdr field in the file header is 0, the auxiliary header does not exist./// XCOFF64 flags.o_resv3ao_resv3AOUTHSZ_SHORT/// Some AIX programs generate auxiliary headers for 32-bit object files that/// end after the data_start field./// Physical address./// Virtual address (same as physical address)./// Section size./// Offset in file to raw data for section./// Offset in file to relocation entries for section./// Offset in file to line number entries for section./// Number of relocation entries./// Number of line number entries./// Flags to define the section type.s_reserveSTYP_REG// Values for `s_flags`./// "regular" sectionSTYP_PAD/// Specifies a pad section. A section of this type is used to provide alignment/// padding between sections within an XCOFF executable object file. This section/// header type is obsolete since padding is allowed in an XCOFF file without a/// corresponding pad section header.STYP_DWARF/// Specifies a DWARF debugging section, which provide source file and symbol/// information for the symbolic debugger.STYP_TEXT/// Specifies an executable text (code) section. A section of this type contains/// the executable instructions of a program.STYP_DATA/// Specifies an initialized data section. A section of this type contains the/// initialized data and the TOC of a program.STYP_BSS/// Specifies an uninitialized data section. A section header of this type/// defines the uninitialized data of a program.STYP_EXCEPT/// Specifies an exception section. A section of this type provides information/// to identify the reason that a trap or exception occurred within an executable/// object program.STYP_INFO/// Specifies a comment section. A section of this type provides comments or data/// to special processing utility programs.STYP_TDATA/// Specifies an initialized thread-local data section.STYP_TBSS/// Specifies an uninitialized thread-local data section.STYP_LOADER/// Specifies a loader section. A section of this type contains object file/// information for the system loader to load an XCOFF executable. The information/// includes imported symbols, exported symbols, relocation data, type-check/// information, and shared object names.STYP_DEBUG/// Specifies a debug section. A section of this type contains stabstring/// information used by the symbolic debugger.STYP_TYPCHK/// Specifies a type-check section. A section of this type contains/// parameter/argument type-check strings used by the binder.STYP_OVRFLO/// Specifies a relocation or line-number field overflow section. A section/// header of this type contains the count of relocation entries and line/// number entries for some other section. This section header is required/// when either of the counts exceeds 65,534.SSUBTYP_DWINFOSSUBTYP_DWLINESSUBTYP_DWPBNMSSSUBTYP_DWPBTYPSSUBTYP_DWARNGESSUBTYP_DWABREVSSUBTYP_DWSTRSSUBTYP_DWRNGESSSUBTYP_DWLOCSSUBTYP_DWFRAMESSUBTYP_DWMACSIZEOF_SYMBOLn_name/// Symbol value; storage class-dependent./// Section number of symbol./// Basic and derived type specification./// Storage class of symbol./// Number of auxiliary entries.n_offset/// Offset of the name in string table or .debug section.N_DEBUG// Values for `n_scnum`./// A special symbolic debugging symbol./// An absolute symbol. The symbol has a value but is not relocatable.N_UNDEF/// An undefined external symbol.SYM_V_MASK// Values for `n_type`./// Values for visibility as they would appear when encoded in the high 4 bits/// of the 16-bit unsigned n_type field of symbol table entries. Valid for/// 32-bit XCOFF only when the o_vstamp in the auxiliary header is greater than 1.SYM_V_INTERNALSYM_V_HIDDENSYM_V_PROTECTEDSYM_V_EXPORTEDC_FILE// Values for `n_sclass`.// Storage classes used for symbolic debugging symbols./// Source file name and compiler information.C_BINCL/// Beginning of include file.C_EINCL/// Ending of include file.C_GSYM/// Global variable.C_STSYM/// Statically allocated symbol.C_BCOMM/// Beginning of common block.C_ECOMM/// End of common block.C_ENTRY/// Alternate entry.C_BSTAT/// Beginning of static block.C_ESTAT/// End of static block.C_GTLS/// Global thread-local variable.C_STTLS/// Static thread-local variable.C_DWARF/// DWARF section symbol.C_LSYM// Storage classes used for absolute symbols./// Automatic variable allocated on stack.C_PSYM/// Argument to subroutine allocated on stack.C_RSYM/// Register variable.C_RPSYM/// Argument to function or procedure stored in register.C_ECOML/// Local member of common block.C_FUN/// Function or procedure.C_EXT// Storage classes used for undefined external symbols or symbols of general sections./// External symbol.C_WEAKEXT/// Weak external symbol.C_NULL// Storage classes used for symbols of general sections./// Symbol table entry marked for deletion.C_STAT/// Static.C_BLOCK/// Beginning or end of inner block.C_FCN/// Beginning or end of function.C_HIDEXT/// Un-named external symbol.C_INFO/// Comment string in .info section.C_DECL/// Declaration of object (type).C_AUTO// Storage classes - Obsolete/Undocumented./// Automatic variable.C_REGC_EXTDEF/// External definition.C_LABEL/// Label.C_ULABEL/// Undefined label.C_MOS/// Member of structure.C_ARG/// Function argument.C_STRTAG/// Structure tag.C_MOU/// Member of union.C_UNTAG/// Union tag.C_TPDEF/// Type definition.C_USTATIC/// Undefined static.C_ENTAG/// Enumeration tag.C_MOE/// Member of enumeration.C_REGPARM/// Register parameter.C_FIELD/// Bit field.C_EOS/// End of structure.C_ALIAS/// Duplicate tag.C_HIDDEN/// Special storage class for external.C_EFCN/// Physical end of function.C_TCSYM/// The source file name or compiler-related string.x_fpad/// Pad size for file name./// The source-file string type.x_freserve/// File Auxiliary Entry for C_FILE Symbols./// Specifies the type of auxiliary entry. Contains _AUX_FILE for this auxiliary entry.XFT_FN// Values for `x_ftype`./// Specifies the source-file name.XFT_CT/// Specifies the compiler time stamp.XFT_CV/// Specifies the compiler version number.XFT_CD/// Specifies compiler-defined information./// Section length./// Offset of parameter type-check hash in .typchk section./// .typchk section number./// Symbol alignment and type./// Storage mapping class./// x_snstab./// Csect auxiliary entry for C_EXT, C_WEAKEXT, and C_HIDEXT symbols.x_scnlen_lo/// Low 4 bytes of section length.x_scnlen_hi/// High 4 bytes of section length./// Contains _AUX_CSECT; indicates type of auxiliary entry.XTY_ER// Values for `x_smtyp`./// External reference.XTY_SD/// Csect definition for initialized storage.XTY_LD/// Defines an entry point to an initialized csect.XTY_CM/// Common csect definition. For uninitialized storage.XMC_PR// Values for `x_smclas`.// READ ONLY CLASSES/// Program CodeXMC_RO/// Read Only ConstantXMC_DB/// Debug Dictionary TableXMC_GL/// Global Linkage (Interfile Interface Code)XMC_XO/// Extended Operation (Pseudo Machine Instruction)XMC_SV/// Supervisor Call (32-bit process only)XMC_SV64/// Supervisor Call for 64-bit processXMC_SV3264/// Supervisor Call for both 32- and 64-bit processesXMC_TI/// Traceback Index csectXMC_TB/// Traceback Table csectXMC_RW// READ WRITE CLASSES/// Read Write DataXMC_TC0/// TOC Anchor for TOC AddressabilityXMC_TC/// General TOC itemXMC_TD/// Scalar data item in the TOCXMC_DS/// Descriptor csectXMC_UA/// Unclassified - Treated as Read WriteXMC_BS/// BSS class (uninitialized static internal)XMC_UC/// Un-named Fortran CommonXMC_TL/// Initialized thread-local variableXMC_UL/// Uninitialized thread-local variableXMC_TE/// Symbol mapped at the end of TOCx_exptr/// File offset to exception table entry.x_fsize/// Size of function in bytes.x_lnnoptr/// File pointer to line numberx_endndx/// Symbol table index of next entry beyond this function./// PadFunAux32/// Function auxiliary entry./// Contains _AUX_FCN; Type of auxiliary entry.FunAux64/// Contains _AUX_EXCEPT; Type of auxiliary entryExpAux/// Exception auxiliary entry. (XCOFF64 only)x_lnnohi/// High-order 2 bytes of the source line number.x_lnnolo/// Low-order 2 bytes of the source line number.BlockAux32/// Block auxiliary entry for the C_BLOCK and C_FCN Symbols.x_lnno/// Source line number./// Contains _AUX_SYM; Type of auxiliary entry.BlockAux64x_nrelocx_nlinno/// Number of line numbers.StatAux/// Section auxiliary entry for the C_STAT Symbol. (XCOFF32 Only)/// Length of portion of section represented by symbol./// Number of relocation entries in section.DwarfAux32/// Section auxiliary entry Format for C_DWARF symbols./// Contains _AUX_SECT; Type of Auxiliary entry.DwarfAux64AUX_EXCEPT// Values for `x_auxtype`/// Identifies an exception auxiliary entry.AUX_FCN/// Identifies a function auxiliary entry.AUX_SYM/// Identifies a symbol auxiliary entry.AUX_FILE/// Identifies a file auxiliary entry.AUX_CSECT/// Identifies a csect auxiliary entry.AUX_SECT/// Identifies a SECT auxiliary entry./// Virtual address (position) in section to be relocated./// Symbol table index of item that is referenced./// Relocation size and information./// Relocation type./// Relocation table entryR_POS// Values for `r_rtype`./// Positive relocation.R_RL/// Positive indirect load relocation.R_RLA/// Positive load address relocation. Modifiable instruction.R_NEG/// Negative relocation.R_REL/// Relative to self relocation.R_TOC/// Relative to the TOC relocation.R_TRL/// TOC relative indirect load relocation.R_TRLA/// Relative to the TOC or to the thread-local storage base relocation.R_GL/// Global linkage-external TOC address relocation.R_TCL/// Local object TOC address relocation.R_REF/// A non-relocating relocation.R_BA/// Branch absolute relocation. References a non-modifiable instruction.R_BR/// Branch relative to self relocation. References a non-modifiable instruction.R_RBA/// Branch absolute relocation. References a modifiable instruction.R_RBR/// Branch relative to self relocation. References a modifiable instruction.R_TLS/// General-dynamic reference to TLS symbol.R_TLS_IE/// Initial-exec reference to TLS symbol.R_TLS_LD/// Local-dynamic reference to TLS symbol.R_TLS_LE/// Local-exec reference to TLS symbol.R_TLSM/// Module reference to TLS.R_TLSML/// Module reference to the local TLS storage.R_TOCU/// Relative to TOC upper.R_TOCL/// Relative to TOC lower.//! XCOFF definitions//! This module is the equivalent of /usr/include/xcoff.h, and is based heavily on it./* missing_docs,
      rust_2018_idioms,*/sn// Short nameOidEntry/// An entry stored in the OID registry/// Create a new entry/// Get the short name for this entry/// Get the description for this entryOidRegistry/// Registry of known OIDs/// Use `OidRegistry::default()` to create an empty registry. If the corresponding features have/// been selected, the `with_xxx()` methods can be used to add sets of known objets to the/// database./// use oid_registry::{OidEntry, OidRegistry};/// let mut registry = OidRegistry::default()/// # #[cfg(feature = "crypto")] {/// #     registry = registry///     .with_crypto() // only if the 'crypto' feature is enabled/// ;/// // entries can be added by creating an OidEntry object:/// let entry = OidEntry::new("shortName", "description");/// registry.insert(oid!(1.2.3.4), entry);/// // when using static strings, a tuple can also be used directly for the entry:/// registry.insert(oid!(1.2.3.5), ("shortName", "A description"));/// // To query an entry, use the `get` method:/// const OID_1234: Oid<'static> = oid!(1.2.3.4);/// let e = registry.get(&OID_1234);/// assert!(e.is_some());/// if let Some(e) = e {///     assert_eq!(e.sn(), "shortName");/// Insert a new entry/// Returns a reference to the registry entry, if found for this OID./// Return an Iterator over references to the OID numbers (registry keys)/// Return an Iterator over references to the `OidEntry` values/// Return an Iterator over references to the `(Oid, OidEntry)` key/value pairsiter_by_sn/// Return the `(Oid, OidEntry)` key/value pairs, matching a short name/// The registry should not contain entries with same short name to avoid ambiguity, but it is/// not mandatory./// This function returns an iterator over the key/value pairs. In most cases, it will have 0/// (not found) or 1 item, but can contain more if there are multiple definitions./// # use oid_registry::OidRegistry;/// # let registry = OidRegistry::default();/// // iterate all entries matching "shortName"/// for (oid, entry) in registry.iter_by_sn("shortName") {///     // do something/// // if you are *sure* that there is at most one entry:/// let opt_sn = registry.iter_by_sn("shortName").next();/// if let Some((oid, entry)) = opt_sn {with_crypto/// Populate registry with common crypto OIDs (encryption, hash algorithms)with_all_crypto/// Populate registry with all known crypto OIDs (encryption, hash algorithms, PKCS constants,/// etc.)format_oid/// Format a OID to a `String`, using the provided registry to get the short name if present." 1.3.133.16.840.63.0.2"OID_KDF_SHA1_SINGLE" 1.3.6.1.4.1.311.2.1.4"SPC_INDIRECT_DATA_OBJID" 1.3.6.1.4.1.311.2.1.11"SPC_STATEMENT_TYPE_OBJID" 1.3.6.1.4.1.311.2.1.12"SPC_SP_OPUS_INFO_OBJID" 1.3.6.1.4.1.311.2.1.15"SPC_PE_IMAGE_DATA" 1.3.6.1.4.1.311.2.1.21"SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID" 1.3.6.1.4.1.311.10.1"MS_CTL" 1.3.132.0.34"OID_NIST_EC_P384" 1.3.132.0.35"OID_NIST_EC_P521" 1.3.14.3.2.25"OID_MD5_WITH_RSA" 1.3.14.3.2.26"OID_HASH_SHA1" 1.3.14.3.2.29"OID_SHA1_WITH_RSA" 2.16.840.1.101.3.4.1.42"OID_NIST_ENC_AES256_CBC" 2.16.840.1.101.3.4.2.1"OID_NIST_HASH_SHA256" 2.16.840.1.101.3.4.2.2"OID_NIST_HASH_SHA384" 2.16.840.1.101.3.4.2.3"OID_NIST_HASH_SHA512" 1.2.840.113549.1.1.1"OID_PKCS1_RSAENCRYPTION" 1.2.840.113549.1.1.2"OID_PKCS1_MD2WITHRSAENC" 1.2.840.113549.1.1.3"OID_PKCS1_MD4WITHRSAENC" 1.2.840.113549.1.1.4"OID_PKCS1_MD5WITHRSAENC" 1.2.840.113549.1.1.5"OID_PKCS1_SHA1WITHRSA" 1.2.840.113549.1.1.10"OID_PKCS1_RSASSAPSS" 1.2.840.113549.1.1.11"OID_PKCS1_SHA256WITHRSA" 1.2.840.113549.1.1.12"OID_PKCS1_SHA384WITHRSA" 1.2.840.113549.1.1.13"OID_PKCS1_SHA512WITHRSA" 1.2.840.113549.1.1.14"OID_PKCS1_SHA224WITHRSA" 1.2.840.113549.1.12"OID_PKCS12" 1.2.840.113549.1.12.1"OID_PKCS12_PBEIDS" 1.2.840.113549.1.12.1.1"OID_PKCS12_PBE_SHA1_128RC4" 1.2.840.113549.1.12.1.2"OID_PKCS12_PBE_SHA1_40RC4" 1.2.840.113549.1.12.1.3"OID_PKCS12_PBE_SHA1_3K_3DES_CBC" 1.2.840.113549.1.12.1.4"OID_PKCS12_PBE_SHA1_2K_3DES_CBC" 1.2.840.113549.1.12.1.5"OID_PKCS12_PBE_SHA1_128RC2_CBC" 1.2.840.113549.1.12.1.6"OID_PKCS12_PBE_SHA1_40RC2_CBC" 1.2.840.113549.1.7.1"OID_PKCS7_ID_DATA" 1.2.840.113549.1.7.2"OID_PKCS7_ID_SIGNED_DATA" 1.2.840.113549.1.7.3"OID_PKCS7_ID_ENVELOPED_DATA" 1.2.840.113549.1.7.4"OID_PKCS7_ID_SIGNED_ENVELOPED_DATA" 1.2.840.113549.1.7.5"OID_PKCS7_ID_DIGESTED_DATA" 1.2.840.113549.1.7.6"OID_PKCS7_ID_ENCRYPTED_DATA" 1.2.840.113549.1.9.1"OID_PKCS9_EMAIL_ADDRESS" 1.2.840.113549.1.9.2"OID_PKCS9_UNSTRUCTURED_NAME" 1.2.840.113549.1.9.3"OID_PKCS9_CONTENT_TYPE" 1.2.840.113549.1.9.4"OID_PKCS9_ID_MESSAGE_DIGEST" 1.2.840.113549.1.9.5"OID_PKCS9_SIGNING_TIME" 1.2.840.113549.1.9.7"OID_PKCS9_CHALLENGE_PASSWORD" 1.2.840.113549.1.9.14"OID_PKCS9_EXTENSION_REQUEST" 1.2.840.113549.1.9.15"OID_PKCS9_SMIME_CAPABILITIES" 1.2.840.113549.1.9.20"OID_PKCS9_FRIENDLY_NAME" 2.5"OID_X500" 0.9.2342.19200300.100.1.1"OID_USERID" 0.9.2342.19200300.100.1.25"OID_DOMAIN_COMPONENT" 1.2.643.2.2.3"OID_SIG_GOST_R3411_94_WITH_R3410_2001" 1.2.643.2.2.19"OID_GOST_R3410_2001" 1.2.643.7.1.1.1.1"OID_KEY_TYPE_GOST_R3410_2012_256" 1.2.643.7.1.1.1.2"OID_KEY_TYPE_GOST_R3410_2012_512" 1.2.643.7.1.1.3.2"OID_SIG_GOST_R3410_2012_256" 1.2.643.7.1.1.3.3"OID_SIG_GOST_R3410_2012_512" 1.2.840.10040.4.1"OID_KEY_TYPE_DSA" 1.2.840.10040.4.3"OID_SIG_DSA_WITH_SHA1" 1.3.36.3.3.1.2"OID_SIG_RSA_RIPE_MD160" 1.3.101.112"OID_SIG_ED25519" 1.3.101.113"OID_SIG_ED448" 1.3.6.1.4.1.311.60.2.1.1"MS_JURISDICTION_LOCALITY" 1.3.6.1.4.1.311.60.2.1.2"MS_JURISDICTION_STATE_OR_PROVINCE" 1.3.6.1.4.1.311.60.2.1.3"MS_JURISDICTION_COUNTRY" 1.3.6.1.4.1.11129.2.4.2"OID_CT_LIST_SCT" 1.3.6.1.5.5.7.1.1"OID_PKIX_AUTHORITY_INFO_ACCESS" 1.3.6.1.5.5.7.48.1"OID_PKIX_ACCESS_DESCRIPTOR_OCSP" 1.3.6.1.5.5.7.48.2"OID_PKIX_ACCESS_DESCRIPTOR_CA_ISSUERS" 1.3.6.1.5.5.7.48.3"OID_PKIX_ACCESS_DESCRIPTOR_TIMESTAMPING" 1.3.6.1.5.5.7.48.4"OID_PKIX_ACCESS_DESCRIPTOR_DVCS" 1.3.6.1.5.5.7.48.5"OID_PKIX_ACCESS_DESCRIPTOR_CA_REPOSITORY" 1.3.6.1.5.5.7.48.6"OID_PKIX_ACCESS_DESCRIPTOR_HTTP_CERTS" 1.3.6.1.5.5.7.48.7"OID_PKIX_ACCESS_DESCRIPTOR_HTTP_CRLS" 1.3.6.1.5.5.7.48.10"OID_PKIX_ACCESS_DESCRIPTOR_RPKI_MANIFEST" 1.3.6.1.5.5.7.48.11"OID_PKIX_ACCESS_DESCRIPTOR_SIGNED_OBJECT" 1.3.6.1.5.5.7.48.12"OID_PKIX_ACCESS_DESCRIPTOR_CMC" 1.3.6.1.5.5.7.48.13"OID_PKIX_ACCESS_DESCRIPTOR_RPKI_NOTIFY" 1.3.6.1.5.5.7.48.14"OID_PKIX_ACCESS_DESCRIPTOR_STIRTNLIST" 2.5.4"OID_X509" 2.5.4.0"OID_X509_OBJECT_CLASS" 2.5.4.1"OID_X509_ALIASED_ENTRY_NAME" 2.5.4.2"OID_X509_KNOWLEDGE_INFORMATION" 2.5.4.3"OID_X509_COMMON_NAME" 2.5.4.4"OID_X509_SURNAME" 2.5.4.5"OID_X509_SERIALNUMBER" 2.5.4.6"OID_X509_COUNTRY_NAME" 2.5.4.7"OID_X509_LOCALITY_NAME" 2.5.4.8"OID_X509_STATE_OR_PROVINCE_NAME" 2.5.4.9"OID_X509_STREET_ADDRESS" 2.5.4.10"OID_X509_ORGANIZATION_NAME" 2.5.4.11"OID_X509_ORGANIZATIONAL_UNIT" 2.5.4.12"OID_X509_TITLE" 2.5.4.13"OID_X509_DESCRIPTION" 2.5.4.14"OID_X509_SEARCH_GUIDE" 2.5.4.15"OID_X509_BUSINESS_CATEGORY" 2.5.4.16"OID_X509_POSTAL_ADDRESS" 2.5.4.17"OID_X509_POSTAL_CODE" 2.5.4.41"OID_X509_NAME" 2.5.4.42"OID_X509_GIVEN_NAME" 2.5.4.43"OID_X509_INITIALS" 2.5.4.44"OID_X509_GENERATION_QUALIFIER" 2.5.4.45"OID_X509_UNIQUE_IDENTIFIER" 2.5.4.46"OID_X509_DN_QUALIFIER" 2.5.29.1"OID_X509_OBSOLETE_AUTHORITY_KEY_IDENTIFIER" 2.5.29.2"OID_X509_OBSOLETE_KEY_ATTRIBUTES" 2.5.29.3"OID_X509_OBSOLETE_CERTIFICATE_POLICIES" 2.5.29.4"OID_X509_OBSOLETE_KEY_USAGE" 2.5.29.5"OID_X509_OBSOLETE_POLICY_MAPPING" 2.5.29.6"OID_X509_OBSOLETE_SUBTREES_CONSTRAINT" 2.5.29.7"OID_X509_OBSOLETE_SUBJECT_ALT_NAME" 2.5.29.8"OID_X509_OBSOLETE_ISSUER_ALT_NAME" 2.5.29.14"OID_X509_EXT_SUBJECT_KEY_IDENTIFIER" 2.5.29.15"OID_X509_EXT_KEY_USAGE" 2.5.29.16"OID_X509_EXT_PRIVATE_KEY_USAGE_PERIOD" 2.5.29.17"OID_X509_EXT_SUBJECT_ALT_NAME" 2.5.29.18"OID_X509_EXT_ISSUER_ALT_NAME" 2.5.29.19"OID_X509_EXT_BASIC_CONSTRAINTS" 2.5.29.20"OID_X509_EXT_CRL_NUMBER" 2.5.29.21"OID_X509_EXT_REASON_CODE" 2.5.29.23"OID_X509_EXT_HOLD_INSTRUCTION_CODE" 2.5.29.24"OID_X509_EXT_INVALIDITY_DATE" 2.5.29.27"OID_X509_EXT_DELTA_CRL_INDICATOR" 2.5.29.28"OID_X509_EXT_ISSUER_DISTRIBUTION_POINT" 2.5.29.29"OID_X509_EXT_ISSUER" 2.5.29.30"OID_X509_EXT_NAME_CONSTRAINTS" 2.5.29.31"OID_X509_EXT_CRL_DISTRIBUTION_POINTS" 2.5.29.32"OID_X509_EXT_CERTIFICATE_POLICIES" 2.5.29.33"OID_X509_EXT_POLICY_MAPPINGS" 2.5.29.35"OID_X509_EXT_AUTHORITY_KEY_IDENTIFIER" 2.5.29.36"OID_X509_EXT_POLICY_CONSTRAINTS" 2.5.29.37"OID_X509_EXT_EXTENDED_KEY_USAGE" 2.5.29.46"OID_X509_EXT_FRESHEST_CRL" 2.5.29.54"OID_X509_EXT_INHIBITANT_ANY_POLICY" 2.16.840.1.113730.1.1"OID_X509_EXT_CERT_TYPE" 2.16.840.1.113730.1.2"OID_X509_EXT_BASE_URL" 2.16.840.1.113730.1.3"OID_X509_EXT_REVOCATION_URL" 2.16.840.1.113730.1.4"OID_X509_EXT_CA_REVOCATION_URL" 2.16.840.1.113730.1.5"OID_X509_EXT_CA_CRL_URL" 2.16.840.1.113730.1.6"OID_X509_EXT_CA_CERT_URL" 2.16.840.1.113730.1.7"OID_X509_EXT_RENEWAL_URL" 2.16.840.1.113730.1.8"OID_X509_EXT_CA_POLICY_URL" 2.16.840.1.113730.1.9"OID_X509_EXT_HOMEPAGE_URL" 2.16.840.1.113730.1.10"OID_X509_EXT_ENTITY_LOGO" 2.16.840.1.113730.1.11"OID_X509_EXT_USER_PICTURE" 2.16.840.1.113730.1.12"OID_X509_EXT_SSL_SERVER_NAME" 2.16.840.1.113730.1.13"OID_X509_EXT_CERT_COMMENT" 1.2.840.10045.2.1"OID_KEY_TYPE_EC_PUBLIC_KEY" 1.2.840.10045.4.3.1"OID_SIG_ECDSA_WITH_SHA224" 1.2.840.10045.4.3.2"OID_SIG_ECDSA_WITH_SHA256" 1.2.840.10045.4.3.3"OID_SIG_ECDSA_WITH_SHA384" 1.2.840.10045.4.3.4"OID_SIG_ECDSA_WITH_SHA512" 1.2.840.10045.3.1.7"OID_EC_P256"Load all known OIDs for feature `kdf` in the registry."with_kdf"Load all known OIDs for feature `nist_algs` in the registry."with_nist_algs"Load all known OIDs for feature `pkcs1` in the registry."with_pkcs1"Load all known OIDs for feature `pkcs12` in the registry."with_pkcs12"Load all known OIDs for feature `pkcs7` in the registry."with_pkcs7"Load all known OIDs for feature `pkcs9` in the registry."with_pkcs9"Load all known OIDs for feature `x509` in the registry."with_x509"Load all known OIDs for feature `x962` in the registry."with_x962test_lifetimes// This test is mostly a compile test, to ensure the API has not changed//! [![docs.rs](https://docs.rs/oid-registry/badge.svg)](https://docs.rs/oid-registry)//! [![crates.io](https://img.shields.io/crates/v/oid-registry.svg)](https://crates.io/crates/oid-registry)//! [![Github CI](https://github.com/rusticata/oid-registry/workflows/Continuous%20integration/badge.svg)](https://github.com/rusticata/oid-registry/actions)//! # OID Registry//! This crate is a helper crate, containing a database of OID objects. These objects are intended//! for use when manipulating ASN.1 grammars and BER/DER encodings, for example.//! This crate provides only a simple registry (similar to a `HashMap`) by default. This object can//! be used to get names and descriptions from OID.//! This crate provides default lists of known OIDs, that can be selected using the build features.//! By default, the registry has no feature enabled, to avoid embedding a huge database in crates.//! It also declares constants for most of these OIDs.//! use oid_registry::OidRegistry;//! let mut registry = OidRegistry::default()//! # ;//! # #[cfg(feature = "crypto")] {//! #     registry = registry//!     .with_crypto() // only if the 'crypto' feature is enabled//! ;//! let e = registry.get(&oid_registry::OID_PKCS1_SHA256WITHRSA);//! if let Some(entry) = e {//!     // get sn: sha256WithRSAEncryption//!     println!("sn: {}", entry.sn());//!     // get description: SHA256 with RSA encryption//!     println!("description: {}", entry.description());//! ## Extending the registry//! These provided lists are often incomplete, or may lack some specific OIDs.//! This is why the registry allows adding new entries after construction://! use asn1_rs::oid;//! use oid_registry::{OidEntry, OidRegistry};//! let mut registry = OidRegistry::default();//! // entries can be added by creating an OidEntry object://! let entry = OidEntry::new("shortName", "description");//! registry.insert(oid!(1.2.3.4), entry);//! // when using static strings, a tuple can also be used directly for the entry://! registry.insert(oid!(1.2.3.5), ("shortName", "A description"));//! ## Versions and compatibility with `asn1-rs`//! Versions of `oid-registry` must be chosen specifically, to depend on a precise version of `asn1-rs`.//! The following table summarizes the matching versions://! - `oid-registry` 0.7.x depends on `asn1-rs` 0.6.0//! - `oid-registry` 0.6.x depends on `asn1-rs` 0.5.0//! - `oid-registry` 0.5.x depends on `asn1-rs` 0.4.0//! ## Contributing OIDs//! All OID values, constants, and features are derived from files in the `assets` directory in the//! build script (see `build.rs`).//! See `load_file` for documentation of the file format.// #![deny(intra_doc_link_resolution_failure)]/// Name of the global constant for this entry./// If `name` is "", then no global constant is defined/// Textual representation of OID (ex: 2.5.4.3)/// A short name to describe OID. Should be unique (no check is done)/// A description for this entryLoadedEntry/// Temporary structure, created when reading a file containing OID declarationsLoadedMap/// Load a file to an OID description map/// format of the file: tab-separated values/// feature   name   oid   short_name   description (until end of line)/// `name` is used to declare a global constant when creating output file (see `generate_file`)./// If `name` is "" then no constant will be writtengenerate_file/// Generate a file containing a `with_<feat>` method for OidRegistrycritical_sectionCriticalSection// Use `unsync::OnceCell` internally since `Mutex` does not provide// interior mutability and to be able to re-use `get_or_try_init`.// Why do we need `T: Send`?// Thread A creates a `OnceCell` and shares it with// scoped thread B, which fills the cell, which is// then destroyed by A. That is, destructor observes// a sent value./// Get the reference to the underlying value, without checking if the cell/// is initialized./// Caller must ensure that the cell is in initialized state, and that/// the contents are acquired by (synchronized to) this thread.INCOMPLETE/// Safety: synchronizes with store to value via Release/Acquire./// Safety: synchronizes with store to value via `is_initialized` or mutex/// lock/unlock, writes value only once because of the mutex./// Gets the mutable reference to the underlying value./// Returns `None` if the cell is empty./// Consumes this `OnceCell`, returning the wrapped value./// Returns `None` if the cell was empty.new_stateinitialize_inner// Note: this is intentionally monomorphic// This `queue` field is the core of the implementation. It encodes two// pieces of information:// * The current state of the cell (`INCOMPLETE`, `RUNNING`, `COMPLETE`)// * Linked list of threads waiting for the current cell.// State is encoded in two low bits. Only `INCOMPLETE` and `RUNNING` states// allow waiters./// Safety: synchronizes with store to value via Release/(Acquire|SeqCst)./// Safety: synchronizes with store to value via SeqCst read from state,/// writes value only once because we never get to INCOMPLETE state after a/// successful write.// Three states that a OnceCell can be in, encoded into the lower bits of `queue` in// the OnceCell structure.INCOMPLETE_PTRCOMPLETE_PTRSTATE_MASK// Mask to learn about the state. All other bits are the queue of waiters if// this is in the RUNNING state./// Representation of a node in the linked list of waiters in the RUNNING state./// A waiters is stored on the stack of the waiting threads.// Ensure the two lower bits are free to use as state bits.new_queue/// Drains and notifies the queue of waiters on drop.// Corresponds to `std::sync::Once::call_inner`.// Originally copied from std, but since modified to remove poisoning and to// support wait.with_addrmap_addrstrict// Polyfill of strict provenance from https://crates.io/crates/sptr.// Use free-standing function rather than a trait to keep things simple and// avoid any potential conflicts with future stabile std API.smoke_oncestampede_oncepoison_badwait_for_force_to_finish// These test are snatched from std as well.// There's a lot of scary concurrent code in this module, but it is copied from// `std::sync::Once` with two changes://   * no poisoning//   * init function can fail"imp_std.rs"// Invariant: written to at most once./// A cell which can be written to only once. It is not thread safe./// Unlike [`std::cell::RefCell`], a `OnceCell` provides simple `&`/// references to the contents./// [`std::cell::RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html/// use once_cell::unsync::OnceCell;/// let value: &String = cell.get_or_init(|| {///     "Hello, World!".to_string()/// assert_eq!(value, "Hello, World!");/// assert!(cell.get().is_some());// Similarly to a `Sync` bound on `sync::OnceCell`, we can use// `&unsync::OnceCell` to sneak a `T` through `catch_unwind`,// by initializing the cell in closure and extracting the value in the// `Drop`./// Creates a new initialized cell./// Gets a reference to the underlying value./// Gets a mutable reference to the underlying value./// This method is allowed to violate the invariant of writing to a `OnceCell`/// at most once because it requires `&mut` access to `self`. As with all/// interior mutability, `&mut` access permits arbitrary modification:/// let mut cell: OnceCell<u32> = OnceCell::new();/// cell.set(92).unwrap();/// *cell.get_mut().unwrap() = 93;/// assert_eq!(cell.get(), Some(&93));/// Sets the contents of this cell to `value`./// Returns `Ok(())` if the cell was empty and `Err(value)` if it was/// assert_eq!(cell.set(92), Ok(()));/// assert_eq!(cell.set(62), Err(62));/// Like [`set`](Self::set), but also returns a reference to the final cell value./// assert_eq!(cell.try_insert(92), Ok(&92));/// assert_eq!(cell.try_insert(62), Err((&92, 62)));/// Gets the contents of the cell, initializing it with `f`/// if the cell was empty./// It is an error to reentrantly initialize the cell from `f`. Doing/// so results in a panic./// let value = cell.get_or_init(|| 92);/// assert_eq!(value, &92);/// let value = cell.get_or_init(|| unreachable!());/// Gets the contents of the cell, initializing it with `f` if/// the cell was empty. If the cell was empty and `f` failed, an/// assert_eq!(cell.get_or_try_init(|| Err(())), Err(()));/// let value = cell.get_or_try_init(|| -> Result<i32, ()> {///     Ok(92)/// assert_eq!(value, Ok(&92));/// assert_eq!(cell.get(), Some(&92))/// Takes the value out of this `OnceCell`, moving it back to an uninitialized state./// Has no effect and returns `None` if the `OnceCell` hasn't been initialized./// let mut cell: OnceCell<String> = OnceCell::new();/// assert_eq!(cell.take(), None);/// cell.set("hello".to_string()).unwrap();/// assert_eq!(cell.take(), Some("hello".to_string()));/// assert_eq!(cell.get(), None);/// cell = OnceCell::new();/// Consumes the `OnceCell`, returning the wrapped value./// let cell: OnceCell<String> = OnceCell::new();/// assert_eq!(cell.into_inner(), None);/// assert_eq!(cell.into_inner(), Some("hello".to_string()));/// A value which is initialized on the first access./// use once_cell::unsync::Lazy;/// let lazy: Lazy<i32> = Lazy::new(|| {///     println!("initializing");///     92/// println!("ready");/// println!("{}", *lazy);/// // Prints:/// //   ready/// //   initializing/// //   92/// Creates a new lazy value with the given initializing function./// let hello = "Hello, World!".to_string();/// let lazy = Lazy::new(|| hello.to_uppercase());/// assert_eq!(&*lazy, "HELLO, WORLD!");/// Consumes this `Lazy` returning the stored value./// Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise./// Forces the evaluation of this lazy value and returns a reference to/// This is equivalent to the `Deref` impl, but is explicit./// let lazy = Lazy::new(|| 92);/// assert_eq!(Lazy::force(&lazy), &92);/// assert_eq!(&*lazy, &92);force_mut/// Forces the evaluation of this lazy value and returns a mutable reference to/// This is equivalent to the `DerefMut` impl, but is explicit./// let mut lazy = Lazy::new(|| 92);/// assert_eq!(Lazy::force_mut(&mut lazy), &92);/// assert_eq!(*lazy, 92);/// Gets the reference to the result of this lazy value if/// it was initialized, otherwise returns `None`./// assert_eq!(Lazy::get(&lazy), None);/// assert_eq!(Lazy::get(&lazy), Some(&92));/// Gets the mutable reference to the result of this lazy value if/// assert_eq!(Lazy::get_mut(&mut lazy), None);/// assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92));/// Creates a new lazy value using `Default` as the initializing function./// Single-threaded version of `OnceCell`./// A thread-safe cell which can be written to only once./// `OnceCell` provides `&` references to the contents without RAII guards./// Reading a non-`None` value out of `OnceCell` establishes a/// happens-before relationship with a corresponding write. For example, if/// thread A initializes the cell with `get_or_init(f)`, and thread B/// subsequently reads the result of this call, B also observes all the side/// effects of `f`./// use once_cell::sync::OnceCell;/// static CELL: OnceCell<String> = OnceCell::new();/// assert!(CELL.get().is_none());/// std::thread::spawn(|| {///     let value: &String = CELL.get_or_init(|| {///         "Hello, World!".to_string()///     assert_eq!(value, "Hello, World!");/// let value: Option<&String> = CELL.get();/// assert!(value.is_some());/// assert_eq!(value.unwrap().as_str(), "Hello, World!");/// Gets the reference to the underlying value./// Returns `None` if the cell is empty, or being initialized. This/// method never blocks./// Gets the reference to the underlying value, blocking the current/// thread until it is set./// let mut cell = std::sync::Arc::new(OnceCell::new());/// let t = std::thread::spawn({///     let cell = std::sync::Arc::clone(&cell);///     move || cell.set(92).unwrap()/// // Returns immediately, but might return None./// let _value_or_none = cell.get();/// // Will return 92, but might block until the other thread does `.set`./// let value: &u32 = cell.wait();/// assert_eq!(*value, 92);/// t.join().unwrap();/// Get the reference to the underlying value, without checking if the/// cell is initialized./// static CELL: OnceCell<i32> = OnceCell::new();///     assert!(CELL.get().is_none());///     std::thread::spawn(|| {///         assert_eq!(CELL.set(92), Ok(()));///     }).join().unwrap();///     assert_eq!(CELL.set(62), Err(62));///     assert_eq!(CELL.get(), Some(&92));/// 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./// Consumes the `OnceCell`, returning the wrapped value. Returns/// `None` if the cell was empty./// This type is thread-safe and can be used in statics./// static HASHMAP: Lazy<HashMap<i32, String>> = Lazy::new(|| {///     let mut m = HashMap::new();///     m.insert(13, "Spica".to_string());///     m.insert(74, "Hoyten".to_string());///     m///     println!("ready");///         println!("{:?}", HASHMAP.get(&13));///     println!("{:?}", HASHMAP.get(&74));///     // Prints:///     //   ready///     //   initializing///     //   Some("Spica")///     //   Some("Hoyten")// We never create a `&F` from a `&Lazy<T, F>` so it is fine to not impl// `Sync` for `F`. We do create a `&mut Option<F>` in `force`, but this is// properly synchronized, so it only happens once so it also does not// contribute to this impl./// Creates a new lazy value with the given initializing/// Forces the evaluation of this lazy value and/// returns a reference to the result. This is equivalent/// to the `Deref` impl, but is explicit./// returns a mutable reference to the result. This is equivalent/// assert_eq!(Lazy::force_mut(&mut lazy), &mut 92);/// struct S(*mut ());/// unsafe impl Sync for S {}/// fn share<T: Sync>(_: &T) {}/// share(&once_cell::sync::OnceCell::<S>::new());/// share(&once_cell::sync::Lazy::<S>::new(|| unimplemented!()));// auto-derived `Send` impl is OK./// Thread-safe, blocking version of `OnceCell`.//! `once_cell` provides two new cell-like types, [`unsync::OnceCell`] and//! [`sync::OnceCell`]. A `OnceCell` might store arbitrary non-`Copy` types, can//! be assigned to at most once and provides direct access to the stored//! contents. The core API looks *roughly* like this (and there's much more//! inside, read on!)://! impl<T> OnceCell<T> {//!     const fn new() -> OnceCell<T> { ... }//!     fn set(&self, value: T) -> Result<(), T> { ... }//!     fn get(&self) -> Option<&T> { ... }//! Note that, like with [`RefCell`] and [`Mutex`], the `set` method requires//! only a shared reference. Because of the single assignment restriction `get`//! can return a `&T` instead of `Ref<T>` or `MutexGuard<T>`.//! The `sync` flavor is thread-safe (that is, implements the [`Sync`] trait),//! while the `unsync` one is not.//! [`unsync::OnceCell`]: unsync/struct.OnceCell.html//! [`sync::OnceCell`]: sync/struct.OnceCell.html//! [`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html//! [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html//! [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html//! `OnceCell` might be useful for a variety of patterns.//! ## Safe Initialization of Global Data//! use std::{env, io};//! use once_cell::sync::OnceCell;//! pub struct Logger {//! static INSTANCE: OnceCell<Logger> = OnceCell::new();//! impl Logger {//!     pub fn global() -> &'static Logger {//!         INSTANCE.get().expect("logger is not initialized")//!     fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {//!        // ...//! #      Ok(Logger {})//!     let logger = Logger::from_cli(env::args()).unwrap();//!     INSTANCE.set(logger).unwrap();//!     // use `Logger::global()` from now on//! ## Lazy Initialized Global Data//! This is essentially the `lazy_static!` macro, but without a macro.//! use std::{sync::Mutex, collections::HashMap};//! fn global_data() -> &'static Mutex<HashMap<i32, String>> {//!     static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new();//!     INSTANCE.get_or_init(|| {//!         let mut m = HashMap::new();//!         m.insert(13, "Spica".to_string());//!         m.insert(74, "Hoyten".to_string());//!         Mutex::new(m)//! There are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types to//! streamline this pattern://! use once_cell::sync::Lazy;//! static GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {//!     let mut m = HashMap::new();//!     m.insert(13, "Spica".to_string());//!     m.insert(74, "Hoyten".to_string());//!     Mutex::new(m)//!     println!("{:?}", GLOBAL_DATA.lock().unwrap());//! Note that the variable that holds `Lazy` is declared as `static`, *not*//! `const`. This is important: using `const` instead compiles, but works wrong.//! [`sync::Lazy`]: sync/struct.Lazy.html//! [`unsync::Lazy`]: unsync/struct.Lazy.html//! ## General purpose lazy evaluation//! Unlike `lazy_static!`, `Lazy` works with local variables.//! use once_cell::unsync::Lazy;//!     let ctx = vec![1, 2, 3];//!     let thunk = Lazy::new(|| {//!         ctx.iter().sum::<i32>()//!     assert_eq!(*thunk, 6);//! If you need a lazy field in a struct, you probably should use `OnceCell`//! directly, because that will allow you to access `self` during//! use std::{fs, path::PathBuf};//! use once_cell::unsync::OnceCell;//! struct Ctx {//!     config_path: PathBuf,//!     config: OnceCell<String>,//! impl Ctx {//!     pub fn get_config(&self) -> Result<&str, std::io::Error> {//!         let cfg = self.config.get_or_try_init(|| {//!             fs::read_to_string(&self.config_path)//!         })?;//!         Ok(cfg.as_str())//! ## Lazily Compiled Regex//! This is a `regex!` macro which takes a string literal and returns an//! *expression* that evaluates to a `&'static Regex`://! macro_rules! regex {//!     ($re:literal $(,)?) => {{//!         static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();//!         RE.get_or_init(|| regex::Regex::new($re).unwrap())//!     }};//! This macro can be useful to avoid the "compile regex on every loop//! iteration" problem.//! ## Runtime `include_bytes!`//! The `include_bytes` macro is useful to include test resources, but it slows//! down test compilation a lot. An alternative is to load the resources at//! runtime://! use std::path::Path;//! pub struct TestResource {//!     path: &'static str,//!     cell: OnceCell<Vec<u8>>,//! impl TestResource {//!     pub const fn new(path: &'static str) -> TestResource {//!         TestResource { path, cell: OnceCell::new() }//!     pub fn bytes(&self) -> &[u8] {//!         self.cell.get_or_init(|| {//!             let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();//!             let path = Path::new(dir.as_str()).join(self.path);//!             std::fs::read(&path).unwrap_or_else(|_err| {//!                 panic!("failed to load test resource: {}", path.display())//!         }).as_slice()//! static TEST_IMAGE: TestResource = TestResource::new("test_data/lena.png");//! #[test]//! fn test_sobel_filter() {//!     let rgb: &[u8] = TEST_IMAGE.bytes();//! # drop(rgb);//! ## `lateinit`//! `LateInit` type for delayed initialization. It is reminiscent of Kotlin's//! `lateinit` keyword and allows construction of cyclic data structures://! pub struct LateInit<T> { cell: OnceCell<T> }//! impl<T> LateInit<T> {//!     pub fn init(&self, value: T) {//!         assert!(self.cell.set(value).is_ok())//! impl<T> Default for LateInit<T> {//!     fn default() -> Self { LateInit { cell: OnceCell::default() } }//! impl<T> std::ops::Deref for LateInit<T> {//!     type Target = T;//!     fn deref(&self) -> &T {//!         self.cell.get().unwrap()//! #[derive(Default)]//! struct A<'a> {//!     b: LateInit<&'a B<'a>>,//! struct B<'a> {//!     a: LateInit<&'a A<'a>>//! fn build_cycle() {//!     let a = A::default();//!     let b = B::default();//!     a.b.init(&b);//!     b.a.init(&a);//!     let _a = &a.b.a.b.a;//! # Comparison with std//! |`!Sync` types         | Access Mode            | Drawbacks                                     |//! |----------------------|------------------------|-----------------------------------------------|//! |`Cell<T>`             | `T`                    | requires `T: Copy` for `get`                  |//! |`RefCell<T>`          | `RefMut<T>` / `Ref<T>` | may panic at runtime                          |//! |`unsync::OnceCell<T>` | `&T`                   | assignable only once                          |//! |`Sync` types          | Access Mode            | Drawbacks                                     |//! |`AtomicT`             | `T`                    | works only with certain `Copy` types          |//! |`Mutex<T>`            | `MutexGuard<T>`        | may deadlock at runtime, may block the thread |//! |`sync::OnceCell<T>`   | `&T`                   | assignable only once, may block the thread    |//! Technically, calling `get_or_init` will also cause a panic or a deadlock if//! it recursively calls itself. However, because the assignment can happen only//! once, such cases should be more rare than equivalents with `RefCell` and//! `Mutex`.//! # Minimum Supported `rustc` Version//! If only the `std`, `alloc`, or `race` features are enabled, MSRV will be//! updated conservatively, supporting at least latest 8 versions of the compiler.//! When using other features, like `parking_lot`, MSRV might be updated more//! frequently, up to the latest stable. In both cases, increasing MSRV is *not*//! considered a semver-breaking change and requires only a minor version bump.//! # Implementation details//! The implementation is based on the//! [`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs/) and//! [`lazy_cell`](https://github.com/indiv0/lazycell/) crates and//! [`std::sync::Once`]. In some sense, `once_cell` just streamlines and unifies//! those APIs.//! To implement a sync flavor of `OnceCell`, this crates uses either a custom//! re-implementation of `std::sync::Once` or `parking_lot::Mutex`. This is//! controlled by the `parking_lot` feature (disabled by default). Performance//! is the same for both cases, but the `parking_lot` based `OnceCell<T>` is//! smaller by up to 16 bytes.//! This crate uses `unsafe`.//! [`std::sync::Once`]: https://doc.rust-lang.org/std/sync/struct.Once.html//! # F.A.Q.//! **Should I use the sync or unsync flavor?**//! Because Rust compiler checks thread safety for you, it's impossible to//! accidentally use `unsync` where `sync` is required. So, use `unsync` in//! single-threaded code and `sync` in multi-threaded. It's easy to switch//! between the two if code becomes multi-threaded later.//! At the moment, `unsync` has an additional benefit that reentrant//! initialization causes a panic, which might be easier to debug than a//! deadlock.//! **Does this crate support async?**//! No, but you can use//! [`async_once_cell`](https://crates.io/crates/async_once_cell) instead.//! **Does this crate support `no_std`?**//! Yes, but with caveats. `OnceCell` is a synchronization primitive which//! _semantically_ relies on blocking. `OnceCell` guarantees that at most one//! `f` will be called to compute the value. If two threads of execution call//! `get_or_init` concurrently, one of them has to wait.//! Waiting fundamentally requires OS support. Execution environment needs to//! understand who waits on whom to prevent deadlocks due to priority inversion.//! You _could_ make code to compile by blindly using pure spinlocks, but the//! runtime behavior would be subtly wrong.//! Given these constraints, `once_cell` provides the following options://! - The `race` module provides similar, but distinct synchronization primitive//!   which is compatible with `no_std`. With `race`, the `f` function can be//!   called multiple times by different threads, but only one thread will win//!   to install the value.//! - `critical-section` feature (with a `-`, not `_`) uses `critical_section`//!   to implement blocking.//! **Can I bring my own mutex?**//! There is [generic_once_cell](https://crates.io/crates/generic_once_cell) to//! allow just that.//! **Should I use `std::cell::OnceCell`, `once_cell`, or `lazy_static`?**//! If you can use `std` version (your MSRV is at least 1.70, and you don't need//! extra features `once_cell` provides), use `std`. Otherwise, use `once_cell`.//! Don't use `lazy_static`.//! # Related crates//! * Most of this crate's functionality is available in `std` starting with//!   Rust 1.70. See `std::cell::OnceCell` and `std::sync::OnceLock`.//! * [double-checked-cell](https://github.com/niklasf/double-checked-cell)//! * [lazy-init](https://crates.io/crates/lazy-init)//! * [lazycell](https://crates.io/crates/lazycell)//! * [mitochondria](https://crates.io/crates/mitochondria)//! * [lazy_static](https://crates.io/crates/lazy_static)//! * [async_once_cell](https://crates.io/crates/async_once_cell)//! * [generic_once_cell](https://crates.io/crates/generic_once_cell) (bring//!   your own mutex)OnceNonZeroUsize/// Gets the underlying value./// Returns `Ok(())` if the cell was empty and `Err(())` if it was/// Gets the contents of the cell, initializing it with `f` if the cell was/// If several threads concurrently run `get_or_init`, more than one `f` can/// be called. However, all threads will return the same value, produced by/// some `f`.OnceBoolghostOnceRef// TODO: Replace UnsafeCell with SyncUnsafeCell once stabilized/// use once_cell::race::OnceRef;/// let mut l = OnceRef::new();///     let y = 2;///     let mut r = OnceRef::new();///     r.set(&y).unwrap();///     core::mem::swap(&mut l, &mut r);/// // l now contains a dangling reference to y/// eprintln!("uaf: {}", l.get().unwrap());once_box/// share(&once_cell::race::OnceBox::<S>::new());//! Thread-safe, non-blocking, "first one wins" flavor of `OnceCell`.//! If two threads race to initialize a type from the `race` module, they//! don't block, execute initialization function together, but only one of//! them stores the result.//! This module does not require `std` feature.//! All types in this module use `Acquire` and `Release`//! [atomic orderings](Ordering) for all their operations. While this is not//! strictly necessary for types other than `OnceBox`, it is useful for users as//! it allows them to be certain that after `get` or `get_or_init` returns on//! one thread, any side-effects caused by the setter thread prior to them//! calling `set` or `get_or_init` will be made visible to that thread; without//! it, it's possible for it to appear as if they haven't happened yet from the//! getter thread's perspective. This is an acceptable tradeoff to make since//! `Acquire` and `Release` have very little performance overhead on most//! architectures versus `Relaxed`.format_params/// Macro for implementing an opaque `Debug` implementation.//! Macro for opaque [`Debug`] trait implementation.//! In many cases it's convenient to have `Debug` implementation for all crate types,//! e.g. to allow deriving of `Debug` in user-defined structs. But at the same time, using//! the default derive macro can be a security hazard since it cause leaking of sensitive//! information, for example, through uncareful logging.//! This crate introduces the [`implement!`] macro which creates an opaque [`Debug`]//! implementation, which does not expose any internal type data.//! pub struct CryptoStuff {//!     key: [u8; 16],//! opaque_debug::implement!(CryptoStuff);//! let val = CryptoStuff { key: [42; 16] };//! assert_eq!(format!("{:?}", val), "CryptoStuff { ... }")//! The macro also support generic paramters://! pub struct GenricCryptoStuff<K> {//!     key: K,//! opaque_debug::implement!(GenricCryptoStuff<K>);//! let val = GenricCryptoStuff { key: [42u8; 16] };//! assert_eq!(format!("{:?}", val), "GenricCryptoStuff<[u8; 16]> { ... }")correspondsKeyError/// Provides Error handling for parsing keys.AES_KEYAesKey/// The key used to encrypt or decrypt cipher blocks.AesBitTypeAesSizeType" Prepares a key for encryption."" # Failure"" Returns an error if the key is not 128, 192, or 256 bits.""This corresponds to [`AES_set_encrypt_key`](https://www.openssl.org/docs/manmaster/man3/AES_set_encrypt_key.html)."new_encrypt" Prepares a key for decryption.""This corresponds to [`AES_set_decrypt_key`](https://www.openssl.org/docs/manmaster/man3/AES_set_decrypt_key.html)."new_decrypt" Performs AES IGE encryption or decryption"" AES IGE (Infinite Garble Extension) is a form of AES block cipher utilized in"" OpenSSL.  Infinite Garble refers to propagating forward errors.  IGE, like other"" block ciphers implemented for AES requires an initialization vector.  The IGE mode"" allows a stream of blocks to be encrypted or decrypted without having the entire"" plaintext available.  For more information, visit [AES IGE Encryption]."" This block cipher uses 16 byte blocks.  The rust implementation will panic"" if the input or output does not meet this 16-byte boundary.  Attention must"" be made in this low level implementation to pad the value to the 128-bit boundary."" [AES IGE Encryption]: http://www.links.org/files/openssl-ige.pdf"" # Panics"" Panics if `in_` is not the same length as `out`, if that length is not a multiple of 16, or if"" `iv` is not at least 32 bytes.""This corresponds to [`AES_ige_encrypt`](https://www.openssl.org/docs/manmaster/man3/AES_ige_encrypt.html)."aes_ige" Wrap a key, according to [RFC 3394](https://tools.ietf.org/html/rfc3394)"" * `key`: The key-encrypting-key to use. Must be a encrypting key"" * `iv`: The IV to use. You must use the same IV for both wrapping and unwrapping"" * `out`: The output buffer to store the ciphertext"" * `in_`: The input buffer, storing the key to be wrapped"" Returns the number of bytes written into `out`"" Panics if either `out` or `in_` do not have sizes that are a multiple of 8, or if"" `out` is not 8 bytes longer than `in_`""This corresponds to [`AES_wrap_key`](https://www.openssl.org/docs/manmaster/man3/AES_wrap_key.html)."wrap_key" Unwrap a key, according to [RFC 3394](https://tools.ietf.org/html/rfc3394)"" * `key`: The key-encrypting-key to decrypt the wrapped key. Must be a decrypting key"" * `iv`: The same IV used for wrapping the key"" * `out`: The buffer to write the unwrapped key to"" * `in_`: The input ciphertext"" Panics if either `out` or `in_` do not have sizes that are a multiple of 8, or"" if `in_` is not 8 bytes longer than `out`""This corresponds to [`AES_unwrap_key`](https://www.openssl.org/docs/manmaster/man3/AES_unwrap_key.html)."unwrap_keyige_vector_1// From https://www.mgp25.com/AESIGE/test_wrap_unwrap// from the RFC https://tools.ietf.org/html/rfc3394#section-2.2.3//! Low level AES IGE and key wrapping functionality//! AES ECB, CBC, XTS, CTR, CFB, GCM and other conventional symmetric encryption//! modes are found in [`symm`].  This is the implementation of AES IGE and key wrapping//! Advanced Encryption Standard (AES) provides symmetric key cipher that//! the same key is used to encrypt and decrypt data.  This implementation//! uses 128, 192, or 256 bit keys.  This module provides functions to//! create a new key with [`new_encrypt`] and perform an encryption/decryption//! using that key with [`aes_ige`].//! [`new_encrypt`]: struct.AesKey.html#method.new_encrypt//! [`aes_ige`]: fn.aes_ige.html//! The [`symm`] module should be used in preference to this module in most cases.//! The IGE block cipher is a non-traditional cipher mode.  More traditional AES//! encryption methods are found in the [`Crypter`] and [`Cipher`] structs.//! [`symm`]: ../symm/index.html//! [`Crypter`]: ../symm/struct.Crypter.html//! [`Cipher`]: ../symm/struct.Cipher.html//! ## Key wrapping//! use openssl::aes::{AesKey, unwrap_key, wrap_key};//! let kek = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";//! let key_to_wrap = b"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF";//! let enc_key = AesKey::new_encrypt(kek).unwrap();//! let mut ciphertext = [0u8; 24];//! wrap_key(&enc_key, None, &mut ciphertext, &key_to_wrap[..]).unwrap();//! let dec_key = AesKey::new_decrypt(kek).unwrap();//! let mut orig_key = [0u8; 16];//! unwrap_key(&dec_key, None, &mut orig_key, &ciphertext[..]).unwrap();//! assert_eq!(&orig_key[..], &key_to_wrap[..]);bioMemBiobnBigNumBigNumRefStackableOpensslStringcvt_pforeign_type_and_impl_send_syncr" Non-UTC representation of time"r" If a time can be represented by UTCTime, UTCTime is used"r" otherwise, ASN1_GENERALIZEDTIME is used.  This would be, for"r" example outside the year range of 1950-2049."r" [ASN1_GENERALIZEDTIME_set] documentation from OpenSSL provides"r" further details of implementation.  Note: these docs are from the master"r" branch as documentation on the 1.1.0 branch did not include this page."r" [ASN1_GENERALIZEDTIME_set]: https://www.openssl.org/docs/manmaster/man3/ASN1_GENERALIZEDTIME_set.html"ASN1_GENERALIZEDTIMEAsn1GeneralizedTimeAsn1GeneralizedTimeRefr" Reference to a [`Asn1GeneralizedTime`]"r" [`Asn1GeneralizedTime`]: struct.Asn1GeneralizedTime.html"/// The type of an ASN.1 value.EOCINTEGERBIT_STRINGOCTET_STRINGOBJECT_DESCRIPTORREALENUMERATEDUTF8STRINGSEQUENCENUMERICSTRINGPRINTABLESTRINGT61STRINGTELETEXSTRINGVIDEOTEXSTRINGIA5STRINGUTCTIMEGENERALIZEDTIMEGRAPHICSTRINGISO64STRINGVISIBLESTRINGGENERALSTRINGUNIVERSALSTRINGBMPSTRING/// Constructs an `Asn1Type` from a raw OpenSSL value./// Returns the raw OpenSSL value represented by this type.// no need to document the constants/// Difference in days/// Difference in seconds./// This is always less than the number of seconds in a day.TimeDiff/// Difference between two ASN1 times./// This `struct` is created by the [`diff`] method on [`Asn1TimeRef`]. See its/// [`diff`]: struct.Asn1TimeRef.html#method.diff/// [`Asn1TimeRef`]: struct.Asn1TimeRef.htmlr" Time storage and comparison"r" Asn1Time should be used to store and share time information"r" using certificates.  If Asn1Time is set using a string, it must"r" be in either YYMMDDHHMMSSZ, YYYYMMDDHHMMSSZ, or another ASN.1 format."r" [ASN_TIME_set] documentation at OpenSSL explains the ASN.1 implementation"r" used by OpenSSL."r" [ASN_TIME_set]: https://www.openssl.org/docs/manmaster/crypto/ASN1_TIME_set.html"ASN1_TIMEAsn1TimeAsn1TimeRefr" Reference to an [`Asn1Time`]"r" [`Asn1Time`]: struct.Asn1Time.html"" Find difference between two times""This corresponds to [`ASN1_TIME_diff`](https://www.openssl.org/docs/manmaster/man3/ASN1_TIME_diff.html)."" Compare two times""This corresponds to [`ASN1_TIME_compare`](https://www.openssl.org/docs/manmaster/man3/ASN1_TIME_compare.html).""This corresponds to [`ASN1_TIME_new`](https://www.openssl.org/docs/manmaster/man3/ASN1_TIME_new.html).""This corresponds to [`X509_gmtime_adj`](https://www.openssl.org/docs/manmaster/man3/X509_gmtime_adj.html)."from_perioddays_from_now/// Creates a new time on specified interval in days from now" Creates a new time from the specified `time_t` value""This corresponds to [`ASN1_TIME_set`](https://www.openssl.org/docs/manmaster/man3/ASN1_TIME_set.html)."from_unix" Creates a new time corresponding to the specified ASN1 time string.""This corresponds to [`ASN1_TIME_set_string`](https://www.openssl.org/docs/manmaster/man3/ASN1_TIME_set_string.html)."" Creates a new time corresponding to the specified X509 time string."" Requires BoringSSL or OpenSSL 1.1.1 or newer.""This corresponds to [`ASN1_TIME_set_string_X509`](https://www.openssl.org/docs/manmaster/man3/ASN1_TIME_set_string_X509.html)."from_str_x509r" Primary ASN.1 type used by OpenSSL"r" Almost all ASN.1 types in OpenSSL are represented by ASN1_STRING"r" structures.  This implementation uses [ASN1_STRING-to_UTF8] to preserve"r" compatibility with Rust's String."r" [ASN1_STRING-to_UTF8]: https://www.openssl.org/docs/manmaster/crypto/ASN1_STRING_to_UTF8.html"ASN1_STRINGAsn1StringAsn1StringRefr" A reference to an [`Asn1String`]."" Converts the ASN.1 underlying format to UTF8"" ASN.1 strings may utilize UTF-16, ASCII, BMP, or UTF8.  This is important to"" consume the string in a meaningful way without knowing the underlying"" format.""This corresponds to [`ASN1_STRING_to_UTF8`](https://www.openssl.org/docs/manmaster/man3/ASN1_STRING_to_UTF8.html)."" Return the string as an array of bytes."" The bytes do not directly correspond to UTF-8 encoding.  To interact with"" strings in rust, it is preferable to use [`as_utf8`]"" [`as_utf8`]: struct.Asn1String.html#method.as_utf8""This corresponds to [`ASN1_STRING_get0_data`](https://www.openssl.org/docs/manmaster/man3/ASN1_STRING_get0_data.html)."" Returns the number of bytes in the string.""This corresponds to [`ASN1_STRING_length`](https://www.openssl.org/docs/manmaster/man3/ASN1_STRING_length.html)."/// Determines if the string is empty.r" Numeric representation"r" Integers in ASN.1 may include BigNum, int64 or uint64.  BigNum implementation"r" can be found within [`bn`] module."r" OpenSSL documentation includes [`ASN1_INTEGER_set`]."r" [`bn`]: ../bn/index.html"r" [`ASN1_INTEGER_set`]: https://www.openssl.org/docs/manmaster/crypto/ASN1_INTEGER_set.html"ASN1_INTEGERAsn1IntegerAsn1IntegerRefr" A reference to an [`Asn1Integer`]."from_bn/// Converts a bignum to an `Asn1Integer`./// Corresponds to [`BN_to_ASN1_INTEGER`]. Also see/// [`BigNumRef::to_asn1_integer`]./// [`BN_to_ASN1_INTEGER`]: https://www.openssl.org/docs/manmaster/crypto/BN_to_ASN1_INTEGER.html/// [`BigNumRef::to_asn1_integer`]: ../bn/struct.BigNumRef.html#method.to_asn1_integer" Converts the integer to a `BigNum`.""This corresponds to [`ASN1_INTEGER_to_BN`](https://www.openssl.org/docs/manmaster/man3/ASN1_INTEGER_to_BN.html)."to_bn" Sets the ASN.1 value to the value of a signed 32-bit integer, for larger numbers"" see [`bn`]."" [`bn`]: ../bn/struct.BigNumRef.html#method.to_asn1_integer""This corresponds to [`ASN1_INTEGER_set`](https://www.openssl.org/docs/manmaster/man3/ASN1_INTEGER_set.html)."" Creates a new Asn1Integer with the same value.""This corresponds to [`ASN1_INTEGER_dup`](https://www.openssl.org/docs/manmaster/man3/ASN1_INTEGER_dup.html)."r" Sequence of bytes"r" Asn1BitString is used in [`x509`] certificates for the signature."r" The bit string acts as a collection of bytes."r" [`x509`]: ../x509/struct.X509.html#method.signature"ASN1_BIT_STRINGAsn1BitStringAsn1BitStringRefr" A reference to an [`Asn1BitString`]."" Returns the Asn1BitString as a slice."r" ASN.1 OCTET STRING type"ASN1_OCTET_STRINGAsn1OctetStringAsn1OctetStringRefr" A reference to an [`Asn1OctetString`]."new_from_bytes/// Creates an Asn1OctetString from bytes" Returns the octet string as an array of bytes."" Returns the number of bytes in the octet string."r" Object Identifier"r" Represents an ASN.1 Object.  Typically, NIDs, or numeric identifiers"r" are stored as a table within the [`Nid`] module.  These constants are"r" used to determine attributes of a certificate, such as mapping the"r#" attribute "CommonName" to "CN" which is represented as the OID of 13."#r" This attribute is a constant in the [`nid::COMMONNAME`]."r" OpenSSL documentation at [`OBJ_nid2obj`]"r" [`Nid`]: ../nid/index.html"r" [`nid::COMMONNAME`]: ../nid/constant.COMMONNAME.html"r" [`OBJ_nid2obj`]: https://www.openssl.org/docs/manmaster/crypto/OBJ_obj2nid.html"ASN1_OBJECTAsn1ObjectAsn1ObjectRefr" A reference to an [`Asn1Object`]."StackTypestack_st_ASN1_OBJECT" Constructs an ASN.1 Object Identifier from a string representation of the OID.""This corresponds to [`OBJ_txt2obj`](https://www.openssl.org/docs/manmaster/man3/OBJ_txt2obj.html)."" Return the OID as an DER encoded array of bytes. This is the ASN.1"" value, not including tag or length."" Requires OpenSSL 1.1.1 or newer.""This corresponds to [`OBJ_get0_data`](https://www.openssl.org/docs/manmaster/man3/OBJ_get0_data.html)."/// Returns the NID associated with this OID.ASN1_STRING_get0_datar" An ASN.1 enumerated."ASN1_ENUMERATEDAsn1EnumeratedAsn1EnumeratedRefr" A reference to an [`Asn1Enumerated`]."" Get the value, if it fits in the required bounds.""This corresponds to [`ASN1_ENUMERATED_get_int64`](https://www.openssl.org/docs/manmaster/man3/ASN1_ENUMERATED_get_int64.html)."bn_cvt/// Tests conversion between BigNum and Asn1Integer.time_from_strtime_from_unixtime_eqtime_ordinteger_to_ownedinteger_cmpobject_from_strobject_from_str_with_invalid_inputobject_to_sliceasn1_octet_string//! Defines the format of certificates//! This module is used by [`x509`] and other certificate building functions//! to describe time, strings, and objects.//! Abstract Syntax Notation One is an interface description language.//! The specification comes from [X.208] by OSI, and rewritten in X.680.//! ASN.1 describes properties of an object with a type set.  Those types//! can be atomic, structured, choice, and other (CHOICE and ANY).  These//! types are expressed as a number and the assignment operator ::=  gives//! the type a name.//! The implementation here provides a subset of the ASN.1 types that OpenSSL//! uses, especially in the properties of a certificate used in HTTPS.//! [X.208]: https://www.itu.int/rec/T-REC-X.208-198811-W/en//! [`x509`]: ../x509/struct.X509Builder.html//! use openssl::asn1::Asn1Time;//! let tomorrow = Asn1Time::days_from_now(1);cvt_nLenType" Encodes a slice of bytes to a base64 string."" Panics if the input length or computed output length overflow a signed C integer.""This corresponds to [`EVP_EncodeBlock`](https://www.openssl.org/docs/manmaster/man3/EVP_EncodeBlock.html)."" Decodes a base64-encoded string to bytes.""This corresponds to [`EVP_DecodeBlock`](https://www.openssl.org/docs/manmaster/man3/EVP_DecodeBlock.html)."test_encode_blocktest_decode_blocktest_strip_whitespace//! Base64 encoding support.BIOMemBioSliceget_bufBIO_new_mem_buftest_mem_bio_get_buf_emptyBN_get_rfc2409_prime_1024BN_get_rfc2409_prime_768BN_get_rfc3526_prime_1536BN_get_rfc3526_prime_2048BN_get_rfc3526_prime_3072BN_get_rfc3526_prime_4096BN_get_rfc3526_prime_6144BN_get_rfc3526_prime_8192BN_is_negativeMsbOption/// Options for the most significant bits of a randomly generated `BigNum`.MAYBE_ZERO/// The most significant bit of the number may be 0./// The most significant bit of the number must be 1.TWO_ONES/// The most significant two bits of the number must be 1./// The number of bits in the product of two such numbers will always be exactly twice the/// number of bits in the original numbers.r" Temporary storage for BigNums on the secure heap"r" BigNum values are stored dynamically and therefore can be expensive"r" to allocate.  BigNumContext and the OpenSSL [`BN_CTX`] structure are used"r" internally when passing BigNum values between subroutines."r" [`BN_CTX`]: https://www.openssl.org/docs/manmaster/crypto/BN_CTX_new.html"BN_CTXBigNumContextBigNumContextRefr" Reference to [`BigNumContext`]"r" [`BigNumContext`]: struct.BigNumContext.html"" Returns a new `BigNumContext`.""This corresponds to [`BN_CTX_new`](https://www.openssl.org/docs/manmaster/man3/BN_CTX_new.html)."" Returns a new secure `BigNumContext`.""This corresponds to [`BN_CTX_secure_new`](https://www.openssl.org/docs/manmaster/man3/BN_CTX_secure_new.html)."new_securer" Dynamically sized large number implementation"r" Perform large number mathematics.  Create a new BigNum"r" with [`new`].  Perform standard mathematics on large numbers using"r" methods from [`Dref<Target = BigNumRef>`]"r" OpenSSL documentation at [`BN_new`]."r" [`new`]: struct.BigNum.html#method.new"r" [`Dref<Target = BigNumRef>`]: struct.BigNum.html#deref-methods"r" [`BN_new`]: https://www.openssl.org/docs/manmaster/crypto/BN_new.html"r" use openssl::bn::BigNum;"r" # use openssl::error::ErrorStack;"r" # fn bignums() -> Result< (), ErrorStack > {"r" let little_big = BigNum::from_u32(std::u32::MAX)?;"r" assert_eq!(*&little_big.num_bytes(), 4);"r" # fn main () { bignums(); }"BIGNUMr" Reference to a [`BigNum`]"r" [`BigNum`]: struct.BigNum.html"" Erases the memory used by this `BigNum`, resetting its value to 0."" This can be used to destroy sensitive data such as keys when they are no longer needed.""This corresponds to [`BN_clear`](https://www.openssl.org/docs/manmaster/man3/BN_clear.html)."" Adds a `u32` to `self`.""This corresponds to [`BN_add_word`](https://www.openssl.org/docs/manmaster/man3/BN_add_word.html)."add_word" Subtracts a `u32` from `self`.""This corresponds to [`BN_sub_word`](https://www.openssl.org/docs/manmaster/man3/BN_sub_word.html)."" Multiplies a `u32` by `self`.""This corresponds to [`BN_mul_word`](https://www.openssl.org/docs/manmaster/man3/BN_mul_word.html)."mul_word" Divides `self` by a `u32`, returning the remainder.""This corresponds to [`BN_div_word`](https://www.openssl.org/docs/manmaster/man3/BN_div_word.html)."" Returns the result of `self` modulo `w`.""This corresponds to [`BN_mod_word`](https://www.openssl.org/docs/manmaster/man3/BN_mod_word.html)."mod_word" Places a cryptographically-secure pseudo-random nonnegative"" number less than `self` in `rnd`.""This corresponds to [`BN_rand_range`](https://www.openssl.org/docs/manmaster/man3/BN_rand_range.html)."rand_range" The cryptographically weak counterpart to `rand_in_range`.""This corresponds to [`BN_pseudo_rand_range`](https://www.openssl.org/docs/manmaster/man3/BN_pseudo_rand_range.html)."pseudo_rand_range" Sets bit `n`. Equivalent to `self |= (1 << n)`."" When setting a bit outside of `self`, it is expanded.""This corresponds to [`BN_set_bit`](https://www.openssl.org/docs/manmaster/man3/BN_set_bit.html)."" Clears bit `n`, setting it to 0. Equivalent to `self &= ~(1 << n)`."" When clearing a bit outside of `self`, an error is returned.""This corresponds to [`BN_clear_bit`](https://www.openssl.org/docs/manmaster/man3/BN_clear_bit.html)."clear_bit" Returns `true` if the `n`th bit of `self` is set to 1, `false` otherwise.""This corresponds to [`BN_is_bit_set`](https://www.openssl.org/docs/manmaster/man3/BN_is_bit_set.html)."" Truncates `self` to the lowest `n` bits."" An error occurs if `self` is already shorter than `n` bits.""This corresponds to [`BN_mask_bits`](https://www.openssl.org/docs/manmaster/man3/BN_mask_bits.html)."mask_bits" Places `a << 1` in `self`.  Equivalent to `self * 2`.""This corresponds to [`BN_lshift1`](https://www.openssl.org/docs/manmaster/man3/BN_lshift1.html)."lshift1" Places `a >> 1` in `self`. Equivalent to `self / 2`.""This corresponds to [`BN_rshift1`](https://www.openssl.org/docs/manmaster/man3/BN_rshift1.html)."rshift1" Places `a + b` in `self`.  [`core::ops::Add`] is also implemented for `BigNumRef`."" [`core::ops::Add`]: struct.BigNumRef.html#method.add""This corresponds to [`BN_add`](https://www.openssl.org/docs/manmaster/man3/BN_add.html)."" Places `a - b` in `self`. [`core::ops::Sub`] is also implemented for `BigNumRef`."" [`core::ops::Sub`]: struct.BigNumRef.html#method.sub""This corresponds to [`BN_sub`](https://www.openssl.org/docs/manmaster/man3/BN_sub.html)."" Places `a << n` in `self`.  Equivalent to `a * 2 ^ n`.""This corresponds to [`BN_lshift`](https://www.openssl.org/docs/manmaster/man3/BN_lshift.html)."lshift" Places `a >> n` in `self`. Equivalent to `a / 2 ^ n`.""This corresponds to [`BN_rshift`](https://www.openssl.org/docs/manmaster/man3/BN_rshift.html)."rshift" Creates a new BigNum with the same value.""This corresponds to [`BN_dup`](https://www.openssl.org/docs/manmaster/man3/BN_dup.html)."" Sets the sign of `self`.  Pass true to set `self` to a negative.  False sets"" `self` positive.""This corresponds to [`BN_set_negative`](https://www.openssl.org/docs/manmaster/man3/BN_set_negative.html)."set_negative" Compare the absolute values of `self` and `oth`."" # Examples"" # use openssl::bn::BigNum;"" # use std::cmp::Ordering;"" let s = -BigNum::from_u32(8).unwrap();"" let o = BigNum::from_u32(8).unwrap();"" assert_eq!(s.ucmp(&o), Ordering::Equal);""This corresponds to [`BN_ucmp`](https://www.openssl.org/docs/manmaster/man3/BN_ucmp.html)."ucmp" Returns `true` if `self` is negative.""This corresponds to [`BN_is_negative`](https://www.openssl.org/docs/manmaster/man3/BN_is_negative.html)."" Returns `true` is `self` is even.""This corresponds to [`BN_is_even`](https://www.openssl.org/docs/manmaster/man3/BN_is_even.html)."" Returns `true` is `self` is odd.""This corresponds to [`BN_is_odd`](https://www.openssl.org/docs/manmaster/man3/BN_is_odd.html)."" Returns the number of significant bits in `self`.""This corresponds to [`BN_num_bits`](https://www.openssl.org/docs/manmaster/man3/BN_num_bits.html)."/// Returns the size of `self` in bytes. Implemented natively." Generates a cryptographically strong pseudo-random `BigNum`, placing it in `self`."" # Parameters"" * `bits`: Length of the number in bits."" * `msb`: The desired properties of the most significant bit. See [`constants`]."" * `odd`: If `true`, the generated number will be odd."" use openssl::bn::{BigNum, MsbOption};"" use openssl::error::ErrorStack;"" fn generate_random() -> Result< BigNum, ErrorStack > {""    let mut big = BigNum::new()?;""    // Generates a 128-bit odd random number""    big.rand(128, MsbOption::MAYBE_ZERO, true);""    Ok((big))"" [`constants`]: index.html#constants""This corresponds to [`BN_rand`](https://www.openssl.org/docs/manmaster/man3/BN_rand.html)."" The cryptographically weak counterpart to `rand`.  Not suitable for key generation.""This corresponds to [`BN_pseudo_rand`](https://www.openssl.org/docs/manmaster/man3/BN_pseudo_rand.html)."pseudo_rand" Generates a prime number, placing it in `self`."" * `bits`: The length of the prime in bits (lower bound)."" * `safe`: If true, returns a \"safe\" prime `p` so that `(p-1)/2` is also prime."" * `add`/`rem`: If `add` is set to `Some(add)`, `p % add == rem` will hold, where `p` is the""   generated prime and `rem` is `1` if not specified (`None`)."" use openssl::bn::BigNum;"" fn generate_weak_prime() -> Result< BigNum, ErrorStack > {""    // Generates a 128-bit simple prime number""    big.generate_prime(128, false, None, None);""This corresponds to [`BN_generate_prime_ex`](https://www.openssl.org/docs/manmaster/man3/BN_generate_prime_ex.html)."generate_prime" Places the result of `a * b` in `self`."" [`core::ops::Mul`] is also implemented for `BigNumRef`."" [`core::ops::Mul`]: struct.BigNumRef.html#method.mul""This corresponds to [`BN_mul`](https://www.openssl.org/docs/manmaster/man3/BN_mul.html)."" Places the result of `a / b` in `self`. The remainder is discarded."" [`core::ops::Div`] is also implemented for `BigNumRef`."" [`core::ops::Div`]: struct.BigNumRef.html#method.div""This corresponds to [`BN_div`](https://www.openssl.org/docs/manmaster/man3/BN_div.html)."" Places the result of `a % b` in `self`."" Places the result of `a / b` in `self` and `a % b` in `rem`."" Places the result of `a²` in `self`.""This corresponds to [`BN_sqr`](https://www.openssl.org/docs/manmaster/man3/BN_sqr.html)."sqr" Places the result of `a mod m` in `self`.  As opposed to `div_rem`"" the result is non-negative.""This corresponds to [`BN_nnmod`](https://www.openssl.org/docs/manmaster/man3/BN_nnmod.html)."nnmod" Places the result of `(a + b) mod m` in `self`.""This corresponds to [`BN_mod_add`](https://www.openssl.org/docs/manmaster/man3/BN_mod_add.html)."mod_add" Places the result of `(a - b) mod m` in `self`.""This corresponds to [`BN_mod_sub`](https://www.openssl.org/docs/manmaster/man3/BN_mod_sub.html)."mod_sub" Places the result of `(a * b) mod m` in `self`.""This corresponds to [`BN_mod_mul`](https://www.openssl.org/docs/manmaster/man3/BN_mod_mul.html)."mod_mul" Places the result of `a² mod m` in `self`.""This corresponds to [`BN_mod_sqr`](https://www.openssl.org/docs/manmaster/man3/BN_mod_sqr.html)."mod_sqr" Places into `self` the modular square root of `a` such that `self^2 = a (mod p)`""This corresponds to [`BN_mod_sqrt`](https://www.openssl.org/docs/manmaster/man3/BN_mod_sqrt.html)."mod_sqrt" Places the result of `a^p` in `self`.""This corresponds to [`BN_exp`](https://www.openssl.org/docs/manmaster/man3/BN_exp.html)."" Places the result of `a^p mod m` in `self`.""This corresponds to [`BN_mod_exp`](https://www.openssl.org/docs/manmaster/man3/BN_mod_exp.html)."mod_exp" Places the inverse of `a` modulo `n` in `self`.""This corresponds to [`BN_mod_inverse`](https://www.openssl.org/docs/manmaster/man3/BN_mod_inverse.html)."mod_inverse" Places the greatest common denominator of `a` and `b` in `self`.""This corresponds to [`BN_gcd`](https://www.openssl.org/docs/manmaster/man3/BN_gcd.html)."" Checks whether `self` is prime."" Performs a Miller-Rabin probabilistic primality test with `checks` iterations."" # Return Value"" Returns `true` if `self` is prime with an error probability of less than `0.25 ^ checks`.""This corresponds to [`BN_is_prime_ex`](https://www.openssl.org/docs/manmaster/man3/BN_is_prime_ex.html)."is_prime" Checks whether `self` is prime with optional trial division."" If `do_trial_division` is `true`, first performs trial division by a number of small primes."" Then, like `is_prime`, performs a Miller-Rabin probabilistic primality test with `checks`"" iterations.""This corresponds to [`BN_is_prime_fasttest_ex`](https://www.openssl.org/docs/manmaster/man3/BN_is_prime_fasttest_ex.html)."is_prime_fasttest" Returns a big-endian byte vector representation of the absolute value of `self`."" `self` can be recreated by using `from_slice`."" let s = -BigNum::from_u32(4543).unwrap();"" let r = BigNum::from_u32(4543).unwrap();"" let s_vec = s.to_vec();"" assert_eq!(BigNum::from_slice(&s_vec).unwrap(), r);""This corresponds to [`BN_bn2bin`](https://www.openssl.org/docs/manmaster/man3/BN_bn2bin.html)."" Returns a big-endian byte vector representation of the absolute value of `self` padded"" to `pad_to` bytes."" If `pad_to` is less than `self.num_bytes()` then an error is returned."" let bn = BigNum::from_u32(0x4543).unwrap();"" let bn_vec = bn.to_vec_padded(4).unwrap();"" assert_eq!(&bn_vec, &[0, 0, 0x45, 0x43]);"" let r = bn.to_vec_padded(1);"" assert!(r.is_err());"" let bn = -BigNum::from_u32(0x4543).unwrap();""This corresponds to [`BN_bn2binpad`](https://www.openssl.org/docs/manmaster/man3/BN_bn2binpad.html)."to_vec_padded" Returns a decimal string representation of `self`."" let s = -BigNum::from_u32(12345).unwrap();"" assert_eq!(&**s.to_dec_str().unwrap(), \"-12345\");""This corresponds to [`BN_bn2dec`](https://www.openssl.org/docs/manmaster/man3/BN_bn2dec.html)."to_dec_str" Returns a hexadecimal string representation of `self`."" let s = -BigNum::from_u32(0x99ff).unwrap();"" assert_eq!(s.to_hex_str().unwrap().to_uppercase(), \"-99FF\");""This corresponds to [`BN_bn2hex`](https://www.openssl.org/docs/manmaster/man3/BN_bn2hex.html)."to_hex_str" Returns an `Asn1Integer` containing the value of `self`.""This corresponds to [`BN_to_ASN1_INTEGER`](https://www.openssl.org/docs/manmaster/man3/BN_to_ASN1_INTEGER.html)."to_asn1_integer" Force constant time computation on this value.""This corresponds to [`BN_set_flags`](https://www.openssl.org/docs/manmaster/man3/BN_set_flags.html)."set_const_time" Returns true if `self` is in const time mode.""This corresponds to [`BN_get_flags`](https://www.openssl.org/docs/manmaster/man3/BN_get_flags.html)."is_const_time" Returns true if `self` was created with [`BigNum::new_secure`]."is_secure" Creates a new `BigNum` with the value 0.""This corresponds to [`BN_new`](https://www.openssl.org/docs/manmaster/man3/BN_new.html)."" Returns a new secure `BigNum`.""This corresponds to [`BN_secure_new`](https://www.openssl.org/docs/manmaster/man3/BN_secure_new.html)."" Creates a new `BigNum` with the given value.""This corresponds to [`BN_set_word`](https://www.openssl.org/docs/manmaster/man3/BN_set_word.html)."" Creates a `BigNum` from a decimal string.""This corresponds to [`BN_dec2bn`](https://www.openssl.org/docs/manmaster/man3/BN_dec2bn.html)."from_dec_str" Creates a `BigNum` from a hexadecimal string.""This corresponds to [`BN_hex2bn`](https://www.openssl.org/docs/manmaster/man3/BN_hex2bn.html)."from_hex_str" Returns a constant used in IKE as defined in [`RFC 2409`].  This prime number is in"" the order of magnitude of `2 ^ 768`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled Oakley group id 1."" [`RFC 2409`]: https://tools.ietf.org/html/rfc2409#page-21""This corresponds to [`BN_get_rfc2409_prime_768`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc2409_prime_768.html)."get_rfc2409_prime_768" the order of magnitude of `2 ^ 1024`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled Oakly group 2.""This corresponds to [`BN_get_rfc2409_prime_1024`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc2409_prime_1024.html)."get_rfc2409_prime_1024" Returns a constant used in IKE as defined in [`RFC 3526`].  The prime is in the order"" of magnitude of `2 ^ 1536`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled MODP group 5."" [`RFC 3526`]: https://tools.ietf.org/html/rfc3526#page-3""This corresponds to [`BN_get_rfc3526_prime_1536`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc3526_prime_1536.html)."get_rfc3526_prime_1536" of magnitude of `2 ^ 2048`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled MODP group 14.""This corresponds to [`BN_get_rfc3526_prime_2048`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc3526_prime_2048.html)."get_rfc3526_prime_2048" of magnitude of `2 ^ 3072`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled MODP group 15."" [`RFC 3526`]: https://tools.ietf.org/html/rfc3526#page-4""This corresponds to [`BN_get_rfc3526_prime_3072`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc3526_prime_3072.html)."get_rfc3526_prime_3072" of magnitude of `2 ^ 4096`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled MODP group 16.""This corresponds to [`BN_get_rfc3526_prime_4096`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc3526_prime_4096.html)."get_rfc3526_prime_4096" of magnitude of `2 ^ 6144`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled MODP group 17."" [`RFC 3526`]: https://tools.ietf.org/html/rfc3526#page-6""This corresponds to [`BN_get_rfc3526_prime_6114`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc3526_prime_6114.html)."get_rfc3526_prime_6144" of magnitude of `2 ^ 8192`.  This number is used during calculated key"" exchanges such as Diffie-Hellman.  This number is labeled MODP group 18.""This corresponds to [`BN_get_rfc3526_prime_8192`](https://www.openssl.org/docs/manmaster/man3/BN_get_rfc3526_prime_8192.html)."get_rfc3526_prime_8192" Creates a new `BigNum` from an unsigned, big-endian encoded number of arbitrary length."" OpenSSL documentation at [`BN_bin2bn`]"" [`BN_bin2bn`]: https://www.openssl.org/docs/manmaster/crypto/BN_bin2bn.html"" let bignum = BigNum::from_slice(&[0x12, 0x00, 0x34]).unwrap();"" assert_eq!(bignum, BigNum::from_u32(0x120034).unwrap());""This corresponds to [`BN_bin2bn`](https://www.openssl.org/docs/manmaster/man3/BN_bin2bn.html)."" Copies data from a slice overwriting what was in the BigNum."" This function can be used to copy data from a slice to a"" [secure BigNum][`BigNum::new_secure`]."" let mut bignum = BigNum::new().unwrap();"" bignum.copy_from_slice(&[0x12, 0x00, 0x34]).unwrap();"test_to_from_slicetest_negationtest_shifttest_rand_rangetest_pseudo_rand_rangetest_prime_numberstest_secure_bn_ctxtest_secure_bntest_const_time_bntest_mod_sqrttest_odd_even//! BigNum implementation//! Large numbers are important for a cryptographic library.  OpenSSL implementation//! of BigNum uses dynamically assigned memory to store an array of bit chunks.  This//! allows numbers of any size to be compared and mathematical functions performed.//! OpenSSL wiki describes the [`BIGNUM`] data structure.//! use openssl::bn::BigNum;//! use openssl::error::ErrorStack;//! fn main() -> Result<(), ErrorStack> {//!   let a = BigNum::new()?; // a = 0//!   let b = BigNum::from_dec_str("1234567890123456789012345")?;//!   let c = &a * &b;//!   assert_eq!(a, c);//!   Ok(())//! [`BIGNUM`]: https://wiki.openssl.org/index.php/Manual:Bn_internal(3)lib_ctxLibCtxRefEVP_CIPHER_block_sizeEVP_CIPHER_iv_lengthEVP_CIPHER_key_lengthEVP_CIPHERCipherRef/// A symmetric cipher." Looks up the cipher for a certain nid.""This corresponds to [`EVP_get_cipherbynid`](https://www.openssl.org/docs/manmaster/man3/EVP_get_cipherbynid.html)."from_nid" Fetches a cipher object corresponding to the specified algorithm name and properties."" Requires OpenSSL 3.0.0 or newer.""This corresponds to [`EVP_CIPHER_fetch`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_fetch.html)."aes_128_ecbaes_128_cbcaes_128_xtsaes_256_xtsaes_128_ctraes_128_cfb1aes_128_cfb128aes_128_cfb8aes_128_gcmaes_128_ccmaes_128_ofbaes_128_ocb/// Requires OpenSSL 1.1.0 or newer.aes_128_wrap/// Requires OpenSSL 1.0.2 or newer.aes_128_wrap_padaes_192_ecbaes_192_cbcaes_192_ctraes_192_cfb1aes_192_cfb128aes_192_cfb8aes_192_gcmaes_192_ccmaes_192_ofbaes_192_ocbaes_192_wrapaes_192_wrap_padaes_256_ecbaes_256_cbcaes_256_ctraes_256_cfb1aes_256_cfb128aes_256_cfb8aes_256_gcmaes_256_ccmaes_256_ofbaes_256_ocbaes_256_wrapaes_256_wrap_padbf_cbcbf_ecbbf_cfb64bf_ofbdes_cbcdes_ecbdes_ede3des_ede3_ecbdes_ede3_cbcdes_ede3_cfb8des_ede3_cfb64des_ede3_ofbrc4cast5_cfb64cast5_ecbcast5_cbccast5_ofbchacha20_poly1305sm4_ecbsm4_cbcsm4_ctrsm4_cfb128sm4_ofb/// A reference to a [`Cipher`]." Returns the cipher\'s Nid.""This corresponds to [`EVP_CIPHER_nid`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_nid.html)."" Returns the length of keys used with this cipher.""This corresponds to [`EVP_CIPHER_key_length`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_key_length.html)."key_length" Returns the length of the IV used with this cipher."" # Note"" Ciphers that do not use an IV have an IV length of 0.""This corresponds to [`EVP_CIPHER_iv_length`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_iv_length.html)."iv_length" Returns the block size of the cipher."" Stream ciphers have a block size of 1.""This corresponds to [`EVP_CIPHER_block_size`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_block_size.html)."//! Symmetric ciphers.HasPrivateHasPublicPKeyRefEVP_CIPHER_CTX_get0_cipherr" A context object used to perform symmetric encryption operations."EVP_CIPHER_CTXCipherCtxCipherCtxRefr" A reference to a [`CipherCtx`]."r" Flags for `EVP_CIPHER_CTX`."CipherCtxFlagsr" The flag used to opt into AES key wrap ciphers."FLAG_WRAP_ALLOW" Creates a new context.""This corresponds to [`EVP_CIPHER_CTX_new`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_new.html).""This corresponds to [`EVP_CIPHER_CTX_copy`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_copy.html)."" Initializes the context for encryption."" Normally this is called once to set all of the cipher, key, and IV. However, this process can be split up"" by first setting the cipher with no key or IV and then setting the key and IV with no cipher. This can be used"" to, for example, use a nonstandard IV size."" Panics if the key buffer is smaller than the key size of the cipher, the IV buffer is smaller than the IV size"" of the cipher, or if a key or IV is provided before a cipher.""This corresponds to [`EVP_EncryptInit_ex`](https://www.openssl.org/docs/manmaster/man3/EVP_EncryptInit_ex.html)."encrypt_init" Initializes the context for decryption.""This corresponds to [`EVP_DecryptInit_ex`](https://www.openssl.org/docs/manmaster/man3/EVP_DecryptInit_ex.html)."decrypt_initcipher_initENGINE" Initializes the context to perform envelope encryption."" Normally this is called once to set both the cipher and public keys. However, this process may be split up by"" first providing the cipher with no public keys and then setting the public keys with no cipher."" `encrypted_keys` will contain the generated symmetric key encrypted with each corresponding asymmetric private"" key. The generated IV will be written to `iv`."" Panics if `pub_keys` is not the same size as `encrypted_keys`, the IV buffer is smaller than the cipher\'s IV"" size, or if an IV is provided before the cipher.""This corresponds to [`EVP_SealInit`](https://www.openssl.org/docs/manmaster/man3/EVP_SealInit.html)."seal_init" Initializes the context to perform envelope decryption."" Normally this is called once with all of the arguments present. However, this process may be split up by first"" providing the cipher alone and then after providing the rest of the arguments in a second call."" Panics if the IV buffer is smaller than the cipher\'s required IV size or if the IV is provided before the"" cipher.""This corresponds to [`EVP_OpenInit`](https://www.openssl.org/docs/manmaster/man3/EVP_OpenInit.html)."open_initassert_cipher" Returns the block size of the context\'s cipher."" Stream ciphers will report a block size of 1."" Panics if the context has not been initialized with a cipher.""This corresponds to [`EVP_CIPHER_CTX_block_size`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_block_size.html)."" Returns the key length of the context\'s cipher.""This corresponds to [`EVP_CIPHER_CTX_key_length`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_key_length.html)."" Generates a random key based on the configured cipher."" Panics if the context has not been initialized with a cipher or if the buffer is smaller than the cipher\'s key"" length.""This corresponds to [`EVP_CIPHER_CTX_rand_key`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_rand_key.html)."rand_key" Sets the length of the key expected by the context."" Only some ciphers support configurable key lengths.""This corresponds to [`EVP_CIPHER_CTX_set_key_length`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_set_key_length.html)."set_key_length" Returns the length of the IV expected by this context."" Returns 0 if the cipher does not use an IV.""This corresponds to [`EVP_CIPHER_CTX_iv_length`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_iv_length.html)."" Returns the `num` parameter of the cipher."" Built-in ciphers typically use this to track how much of the"" current underlying block has been \"used\" already.""This corresponds to [`EVP_CIPHER_CTX_num`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_num.html)."" Sets the length of the IV expected by this context."" Only some ciphers support configurable IV lengths.""This corresponds to [`EVP_CIPHER_CTX_ctrl`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_ctrl.html)."set_iv_length" Returns the length of the authentication tag expected by this context."" Returns 0 if the cipher is not authenticated.""This corresponds to [`EVP_CIPHER_CTX_get_tag_length`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_get_tag_length.html)."tag_length" Retrieves the calculated authentication tag from the context."" This should be called after [`Self::cipher_final`], and is only supported by authenticated ciphers."" The size of the buffer indicates the size of the tag. While some ciphers support a range of tag sizes, it is"" recommended to pick the maximum size."" Sets the length of the generated authentication tag."" This must be called when encrypting with a cipher in CCM mode to use a tag size other than the default."set_tag_length" Sets the authentication tag for verification during decryption."set_tag" Enables or disables padding."" If padding is disabled, the plaintext must be an exact multiple of the cipher\'s block size.""This corresponds to [`EVP_CIPHER_CTX_set_padding`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_set_padding.html)."" Sets the total length of plaintext data."" This is required for ciphers operating in CCM mode.""This corresponds to [`EVP_CipherUpdate`](https://www.openssl.org/docs/manmaster/man3/EVP_CipherUpdate.html)."set_data_len" Set ctx flags."" This function is currently used to enable AES key wrap feature supported by OpenSSL 1.0.2 or newer.""This corresponds to [`EVP_CIPHER_CTX_set_flags`](https://www.openssl.org/docs/manmaster/man3/EVP_CIPHER_CTX_set_flags.html)."" Writes data into the context."" Providing no output buffer will cause the input to be considered additional authenticated data (AAD)."" Returns the number of bytes written to `output`."" Panics if `output` doesn\'t contain enough space for data to be"" written."cipher_update" This function is the same as [`Self::cipher_update`] but with the"" output size check removed. It can be used when the exact"" buffer size control is maintained by the caller."" # Safety"" The caller is expected to provide `output` buffer"" large enough to contain correct number of bytes. For streaming"" ciphers the output buffer size should be at least as big as"" the input buffer. For block ciphers the size of the output"" buffer depends on the state of partially updated blocks."cipher_update_uncheckedcipher_update_vec/// Like [`Self::cipher_update`] except that it appends output to a [`Vec`]." Like [`Self::cipher_update`] except that it writes output into the"" `data` buffer. The `inlen` parameter specifies the number of bytes in"" `data` that are considered the input. For streaming ciphers, the size of"" `data` must be at least the input size. Otherwise, it must be at least"" an additional block size larger."" Note: Use [`Self::cipher_update`] with no output argument to write AAD."" This function panics if the input size cannot be represented as `int` or"" exceeds the buffer size, or if the output buffer does not contain enough"" additional space."cipher_update_inplace" Finalizes the encryption or decryption process."" Any remaining data will be written to the output buffer."" Panics if `output` is smaller than the cipher\'s block size.""This corresponds to [`EVP_CipherFinal`](https://www.openssl.org/docs/manmaster/man3/EVP_CipherFinal.html)."cipher_final" This function is the same as [`Self::cipher_final`] but with"" the output buffer size check removed."" ciphers the output buffer can be empty, for block ciphers the"" output buffer should be at least as big as the block."cipher_final_uncheckedcipher_final_vec/// Like [`Self::cipher_final`] except that it appends output to a [`Vec`].rand_bytesseal_openfetched_aes_128_cbcdefault_aes_128_cbctest_stream_cipherstest_stream_cipherfull_block_updates_aes_128full_block_updates_aes_256full_block_updates_3desoutput_buffer_too_smallcipher_wrap_testtest_aes128_wraptest_aes128_wrap_default_ivtest_aes128_wrap_padtest_aes128_wrap_pad_default_ivtest_aes192_wraptest_aes192_wrap_default_ivtest_aes192_wrap_padtest_aes192_wrap_pad_default_ivtest_aes256_wraptest_aes256_wrap_default_ivtest_aes256_wrap_padtest_aes256_wrap_pad_default_iv//! The symmetric encryption context.//! Encrypt data with AES128 CBC//! use openssl::cipher::Cipher;//! use openssl::cipher_ctx::CipherCtx;//! let cipher = Cipher::aes_128_cbc();//! let data = b"Some Crypto Text";//! let key = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";//! let iv = b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07";//! let mut ctx = CipherCtx::new().unwrap();//! ctx.encrypt_init(Some(cipher), Some(key), Some(iv)).unwrap();//! let mut ciphertext = vec![];//! ctx.cipher_update_vec(data, &mut ciphertext).unwrap();//! ctx.cipher_final_vec(&mut ciphertext).unwrap();//!     b"\xB4\xB9\xE7\x30\xD6\xD6\xF7\xDE\x77\x3F\x1C\xFF\xB3\x3E\x44\x5A\x91\xD7\x27\x62\x87\x4D\//!       \xFB\x3C\x5E\xC4\x59\x72\x4A\xF4\x7C\xA1",//!     &ciphertext[..],//! Decrypt data with AES128 CBC//! let data = b"\xB4\xB9\xE7\x30\xD6\xD6\xF7\xDE\x77\x3F\x1C\xFF\xB3\x3E\x44\x5A\x91\xD7\x27\x62\//!              \x87\x4D\xFB\x3C\x5E\xC4\x59\x72\x4A\xF4\x7C\xA1";//! ctx.decrypt_init(Some(cipher), Some(key), Some(iv)).unwrap();//! let mut plaintext = vec![];//! ctx.cipher_update_vec(data, &mut plaintext).unwrap();//! ctx.cipher_final_vec(&mut plaintext).unwrap();//! assert_eq!(b"Some Crypto Text", &plaintext[..]);StackRefX509StoreRefX509RefCMSOptionsCMS_NOCERTSNO_CONTENT_VERIFYNO_ATTR_VERIFYNOSIGSNOINTERNNO_SIGNER_CERT_VERIFYNOVERIFYDETACHEDNOATTRNOSMIMECAPNOOLDMIMETYPECRLFEOLSTREAMNOCRLPARTIALREUSE_DIGESTUSE_KEYIDDEBUG_DECRYPTr" High level CMS wrapper"r" CMS supports nesting various types of data, including signatures, certificates,"r" encrypted data, smime messages (encrypted email), and data digest.  The ContentInfo"r" content type is the encapsulation of all those content types.  [`RFC 5652`] describes"r" CMS and OpenSSL follows this RFC's implementation."r" [`RFC 5652`]: https://tools.ietf.org/html/rfc5652#page-6"CMS_ContentInfoCmsContentInfoCmsContentInfoRefr" Reference to [`CMSContentInfo`]"r" [`CMSContentInfo`]:struct.CmsContentInfo.html"" Given the sender\'s private key, `pkey` and the recipient\'s certificate, `cert`,"" decrypt the data in `self`.""This corresponds to [`CMS_decrypt`](https://www.openssl.org/docs/manmaster/man3/CMS_decrypt.html)."" Given the sender\'s private key, `pkey`,"" decrypt the data in `self` without validating the recipient certificate."" *Warning*: Not checking the recipient certificate may leave you vulnerable to Bleichenbacher\'s attack on PKCS#1 v1.5 RSA padding."decrypt_without_cert_checkr" Serializes this CmsContentInfo using DER.""This corresponds to [`i2d_CMS_ContentInfo`](https://www.openssl.org/docs/manmaster/man3/i2d_CMS_ContentInfo.html).""This corresponds to [`PEM_write_bio_CMS`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_CMS.html)."" Parses a smime formatted `vec` of bytes into a `CmsContentInfo`.""This corresponds to [`SMIME_read_CMS`](https://www.openssl.org/docs/manmaster/man3/SMIME_read_CMS.html)."smime_read_cmsr" Deserializes a DER-encoded ContentInfo structure.""This corresponds to [`d2i_CMS_ContentInfo`](https://www.openssl.org/docs/manmaster/man3/d2i_CMS_ContentInfo.html)."r" Deserializes a PEM-encoded ContentInfo structure.""This corresponds to [`PEM_read_bio_CMS`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_CMS.html)."" Given a signing cert `signcert`, private key `pkey`, a certificate stack `certs`,"" data `data` and flags `flags`, create a CmsContentInfo struct."" All arguments are optional.""This corresponds to [`CMS_sign`](https://www.openssl.org/docs/manmaster/man3/CMS_sign.html)."" Given a certificate stack `certs`, data `data`, cipher `cipher` and flags `flags`,"" create a CmsContentInfo struct."" OpenSSL documentation at [`CMS_encrypt`]"" [`CMS_encrypt`]: https://www.openssl.org/docs/manmaster/man3/CMS_encrypt.html""This corresponds to [`CMS_encrypt`](https://www.openssl.org/docs/manmaster/man3/CMS_encrypt.html)."" Verify this CmsContentInfo\'s signature,"" This will search the \'certs\' list for the signing certificate.      "" Additional certificates, needed for building the certificate chain, may be"" given in \'store\' as well as additional CRLs."" A detached signature may be passed in `detached_data`. The signed content"" without signature, will be copied into output_data if it is present.""This corresponds to [`CMS_verify`](https://www.openssl.org/docs/manmaster/man3/CMS_verify.html)."X509Storecms_encrypt_decryptcms_sign_verify_generic_helpercms_sign_verify_okcms_sign_verify_detached_okcms_sign_verify_error//! SMIME implementation using CMS//! CMS (PKCS#7) is an encryption standard.  It allows signing and encrypting data using//! X.509 certificates.  The OpenSSL implementation of CMS is used in email encryption//! generated from a `Vec` of bytes.  This `Vec` follows the smime protocol standards.//! Data accepted by this module will be smime type `enveloped-data`.CONFConfConfRefCONF_METHODConfMethod" Retrieve handle to the default OpenSSL configuration file processing function.""This corresponds to [`NCONF_default`](https://www.openssl.org/docs/manmaster/man3/NCONF_default.html)."/// Construct from raw pointer./// The caller must ensure that the pointer is valid./// Convert to raw pointer." Create a configuration parser."" use openssl::conf::{Conf, ConfMethod};"" let conf = Conf::new(ConfMethod::default());""This corresponds to [`NCONF_new`](https://www.openssl.org/docs/manmaster/man3/NCONF_new.html)."//! Interface for processing OpenSSL configuration files.EVP_PKEY_CTXDeriver/// A type used to derive a shared secret between two keys./// Creates a new `Deriver` using the provided private key./// This corresponds to [`EVP_PKEY_derive_init`]./// [`EVP_PKEY_derive_init`]: https://www.openssl.org/docs/manmaster/crypto/EVP_PKEY_derive_init.html" Sets the peer key used for secret derivation.""This corresponds to [`EVP_PKEY_derive_set_peer`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_derive_set_peer.html)."set_peer" Sets the peer key used for secret derivation along with optionally validating the peer public key.""This corresponds to [`EVP_PKEY_derive_set_peer_ex`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_derive_set_peer_ex.html)."set_peer_ex/// Returns the size of the shared secret./// It can be used to size the buffer passed to [`Deriver::derive`]./// This corresponds to [`EVP_PKEY_derive`]./// [`Deriver::derive`]: #method.derive/// [`EVP_PKEY_derive`]: https://www.openssl.org/docs/manmaster/crypto/EVP_PKEY_derive_init.html/// Derives a shared secret between the two keys, writing it into the buffer.derive_to_vec/// A convenience function which derives a shared secret and returns it in a new buffer./// This simply wraps [`Deriver::len`] and [`Deriver::derive`]./// [`Deriver::len`]: #method.lenecEcGroupEcKeyderive_without_peertest_ec_key_derivetest_ec_key_derive_ex//! Shared secret derivation.//! The following example implements [ECDH] using `NIST P-384` keys://! # use std::convert::TryInto;//! use openssl::bn::BigNumContext;//! use openssl::pkey::PKey;//! use openssl::derive::Deriver;//! use openssl::ec::{EcGroup, EcKey, EcPoint, PointConversionForm};//! use openssl::nid::Nid;//! let group = EcGroup::from_curve_name(Nid::SECP384R1)?;//! let first: PKey<_> = EcKey::generate(&group)?.try_into()?;//! // second party generates an ephemeral key and derives//! // a shared secret using first party's public key//! let shared_key = EcKey::generate(&group)?;//! // shared_public is sent to first party//! let mut ctx = BigNumContext::new()?;//! let shared_public = shared_key.public_key().to_bytes(//!        &group,//!        PointConversionForm::COMPRESSED,//!        &mut ctx,//!    )?;//! let shared_key: PKey<_> = shared_key.try_into()?;//! let mut deriver = Deriver::new(&shared_key)?;//! deriver.set_peer(&first)?;//! // secret can be used e.g. as a symmetric encryption key//! let secret = deriver.derive_to_vec()?;//! # drop(deriver);//! // first party derives the same shared secret using//! // shared_public//! let point = EcPoint::from_bytes(&group, &shared_public, &mut ctx)?;//! let recipient_key: PKey<_> = EcKey::from_public_key(&group, &point)?.try_into()?;//! let mut deriver = Deriver::new(&first)?;//! deriver.set_peer(&recipient_key)?;//! let first_secret = deriver.derive_to_vec()?;//! assert_eq!(secret, first_secret);//! [ECDH]: https://wiki.openssl.org/index.php/Elliptic_Curve_Diffie_HellmanHasParamsgeneric_foreign_type_and_impl_send_syncDHDhDhRefr" Serializes the parameters into a PEM-encoded PKCS#3 DHparameter structure."r" The output will have a header of `-----BEGIN DH PARAMETERS-----`.""This corresponds to [`PEM_write_bio_DHparams`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_DHparams.html)."params_to_pemr" Serializes the parameters into a DER-encoded PKCS#3 DHparameter structure.""This corresponds to [`i2d_DHparams`](https://www.openssl.org/docs/manmaster/man3/i2d_DHparams.html)."params_to_der" Validates DH parameters for correctness""This corresponds to [`DH_check_key`](https://www.openssl.org/docs/manmaster/man3/DH_check_key.html)."check_keyfrom_params" Creates a DH instance based upon the given primes and generator params.""This corresponds to [`DH_set0_pqg`](https://www.openssl.org/docs/manmaster/man3/DH_set0_pqg.html)."from_pqgset_public_key/// Sets the public key on the DH object.set_private_key/// Sets the private key on the DH object and recomputes the public key./// Sets the public and private keys on the DH object." Generates DH params based on the given `prime_len` and a fixed `generator` value.""This corresponds to [`DH_generate_parameters_ex`](https://www.openssl.org/docs/manmaster/man3/DH_generate_parameters_ex.html)."" Generates a public and a private key based on the DH params.""This corresponds to [`DH_generate_key`](https://www.openssl.org/docs/manmaster/man3/DH_generate_key.html)."r" Deserializes a PEM-encoded PKCS#3 DHpararameters structure."r" The input should have a header of `-----BEGIN DH PARAMETERS-----`.""This corresponds to [`PEM_read_bio_DHparams`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_DHparams.html)."params_from_pemr" Deserializes a DER-encoded PKCS#3 DHparameters structure.""This corresponds to [`d2i_DHparams`](https://www.openssl.org/docs/manmaster/man3/d2i_DHparams.html)."params_from_der" Requires OpenSSL 1.0.2 or newer.""This corresponds to [`DH_get_1024_160`](https://www.openssl.org/docs/manmaster/man3/DH_get_1024_160.html)."get_1024_160"This corresponds to [`DH_get_2048_224`](https://www.openssl.org/docs/manmaster/man3/DH_get_2048_224.html)."get_2048_224"This corresponds to [`DH_get_2048_256`](https://www.openssl.org/docs/manmaster/man3/DH_get_2048_256.html)."get_2048_256" Returns the prime `p` from the DH instance.""This corresponds to [`DH_get0_pqg`](https://www.openssl.org/docs/manmaster/man3/DH_get0_pqg.html)."prime_p" Returns the prime `q` from the DH instance."prime_q" Returns the generator from the DH instance."" Returns the public key from the DH instance.""This corresponds to [`DH_get0_key`](https://www.openssl.org/docs/manmaster/man3/DH_get0_key.html)."" Computes a shared secret from the own private key and the given `public_key`.""This corresponds to [`DH_compute_key`](https://www.openssl.org/docs/manmaster/man3/DH_compute_key.html)."compute_key" Returns the private key from the DH instance."DH_set0_pqgDH_get0_pqgDH_get0_keyDH_set0_keydhtest_dh_rfc5114test_dh_paramstest_from_dhx_serializes_qtest_dh_stored_restoredtest_set_keystest_dh_from_pemtest_dh_from_dertest_dh_generate_key_compute_keytest_dh_generate_params_generate_key_compute_keytest_dh_check_key//! Diffie-Hellman key agreement.ForeignTypeRefExtr" Object representing DSA keys."r" A DSA object contains the parameters p, q, and g.  There is a private"r" and public key.  The values p, g, and q are:"r" * `p`: DSA prime parameter"r" * `q`: DSA sub-prime parameter"r" * `g`: DSA base parameter"r" These values are used to calculate a pair of asymmetrical keys used for"r" signing."r" OpenSSL documentation at [`DSA_new`]"r" [`DSA_new`]: https://www.openssl.org/docs/manmaster/crypto/DSA_new.html"r" use openssl::dsa::Dsa;"r" use openssl::error::ErrorStack;"r" use openssl::pkey::Private;"r" fn create_dsa() -> Result<Dsa<Private>, ErrorStack> {"r"     let sign = Dsa::generate(2048)?;"r"     Ok(sign)"r" #    create_dsa();"DsaDsaRefr" Reference to [`Dsa`]."r" [`Dsa`]: struct.Dsa.html"r" Serializes the public key into a PEM-encoded SubjectPublicKeyInfo structure."r" The output will have a header of `-----BEGIN PUBLIC KEY-----`.""This corresponds to [`PEM_write_bio_DSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_DSA_PUBKEY.html)."public_key_to_pemr" Serializes the public key into a DER-encoded SubjectPublicKeyInfo structure.""This corresponds to [`i2d_DSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/i2d_DSA_PUBKEY.html)."public_key_to_der" Returns a reference to the public key component of `self`.""This corresponds to [`DSA_get0_key`](https://www.openssl.org/docs/manmaster/man3/DSA_get0_key.html)."pub_keyprivate_key_to_pemr" Serializes the private key to a PEM-encoded DSAPrivateKey structure."r" The output will have a header of `-----BEGIN DSA PRIVATE KEY-----`.""This corresponds to [`PEM_write_bio_DSAPrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_DSAPrivateKey.html)."r" Serializes the private key to a PEM-encoded encrypted DSAPrivateKey structure."private_key_to_pem_passphraser" Serializes the private_key to a DER-encoded `DSAPrivateKey` structure.""This corresponds to [`i2d_DSAPrivateKey`](https://www.openssl.org/docs/manmaster/man3/i2d_DSAPrivateKey.html)."private_key_to_der" Returns a reference to the private key component of `self`."priv_key" Returns the maximum size of the signature output by `self` in bytes.""This corresponds to [`DSA_size`](https://www.openssl.org/docs/manmaster/man3/DSA_size.html)."" Returns the DSA prime parameter of `self`.""This corresponds to [`DSA_get0_pqg`](https://www.openssl.org/docs/manmaster/man3/DSA_get0_pqg.html)."" Returns the DSA sub-prime parameter of `self`."" Returns the DSA base parameter of `self`."BitType" Creates a DSA params based upon the given parameters.""This corresponds to [`DSA_set0_pqg`](https://www.openssl.org/docs/manmaster/man3/DSA_set0_pqg.html)."" Generates DSA params based on the given number of bits.""This corresponds to [`DSA_generate_parameters_ex`](https://www.openssl.org/docs/manmaster/man3/DSA_generate_parameters_ex.html)."" Generates a private key based on the DSA params.""This corresponds to [`DSA_generate_key`](https://www.openssl.org/docs/manmaster/man3/DSA_generate_key.html)."/// Generate a DSA key pair./// The `bits` parameter corresponds to the length of the prime `p`.from_private_components/// Create a DSA key pair with the given parameters/// `p`, `q` and `g` are the common parameters./// `priv_key` is the private component of the key pair./// `pub_key` is the public component of the key. Can be computed via `g^(priv_key) mod p`r" Decodes a PEM-encoded SubjectPublicKeyInfo structure containing a DSA key."r" The input should have a header of `-----BEGIN PUBLIC KEY-----`.""This corresponds to [`PEM_read_bio_DSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_DSA_PUBKEY.html)."public_key_from_pemr" Decodes a DER-encoded SubjectPublicKeyInfo structure containing a DSA key.""This corresponds to [`d2i_DSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/d2i_DSA_PUBKEY.html)."public_key_from_derfrom_public_components/// Create a new DSA key with only public components./// `pub_key` is the public component of the key.DSA_get0_keyDSA_get0_pqgDSA_set0_keyDSA_set0_pqgr" Object representing DSA signature."r" DSA signatures consist of two components: `r` and `s`."r" use std::convert::TryInto;"r" use openssl::dsa::{Dsa, DsaSig};"r" use openssl::hash::MessageDigest;"r" use openssl::pkey::PKey;"r" use openssl::sign::{Signer, Verifier};"r" const TEST_DATA: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];"r" let dsa_ref = Dsa::generate(1024).unwrap();"r" let pub_key: PKey<_> = dsa_ref.clone().try_into().unwrap();"r" let priv_key: PKey<_> = dsa_ref.try_into().unwrap();"r" let mut signer = if let Ok(signer) = Signer::new(MessageDigest::sha256(), &priv_key) {"r"     signer"r" } else {"r"     // DSA signing is not supported (eg. BoringSSL)"r"     return;"r" signer.update(TEST_DATA).unwrap();"r" let signature = signer.sign_to_vec().unwrap();"r" // Parse DER-encoded DSA signature"r" let signature = DsaSig::from_der(&signature).unwrap();"r" // Extract components `r` and `s`"r" let r = BigNum::from_slice(&signature.r().to_vec()).unwrap();"r" let s = BigNum::from_slice(&signature.s().to_vec()).unwrap();"r" // Construct new DSA signature from components"r" let signature = DsaSig::from_private_components(r, s).unwrap();"r" // Serialize DSA signature to DER"r" let signature = signature.to_der().unwrap();"r" let mut verifier = Verifier::new(MessageDigest::sha256(), &pub_key).unwrap();"r" verifier.update(TEST_DATA).unwrap();"r" assert!(verifier.verify(&signature[..]).unwrap());"DSA_SIGDsaSigDsaSigRefr" Reference to a [`DsaSig`]."" Returns a new `DsaSig` by setting the `r` and `s` values associated with an DSA signature.""This corresponds to [`DSA_SIG_set0`](https://www.openssl.org/docs/manmaster/man3/DSA_SIG_set0.html)."r" Decodes a DER-encoded DSA signature.""This corresponds to [`d2i_DSA_SIG`](https://www.openssl.org/docs/manmaster/man3/d2i_DSA_SIG.html)."r" Serializes the DSA signature into a DER-encoded `DSASignature` structure.""This corresponds to [`i2d_DSA_SIG`](https://www.openssl.org/docs/manmaster/man3/i2d_DSA_SIG.html)."" Returns internal component `r` of an `DsaSig`.""This corresponds to [`DSA_SIG_get0`](https://www.openssl.org/docs/manmaster/man3/DSA_SIG_get0.html)."" Returns internal component `s` of an `DsaSig`."DSA_SIG_set0DSA_SIG_get0test_generatetest_pubkey_generationtest_priv_key_from_partstest_pub_key_from_partstest_paramstest_signaturetest_signature_derdsa_sig_debug//! Digital Signatures//! DSA ensures a message originated from a known sender, and was not modified.//! DSA uses asymmetrical keys and an algorithm to output a signature of the message//! using the private key that can be validated with the public key but not be generated//! without the private key.point_conversion_form_tPointConversionForm/// Compressed or Uncompressed conversion/// Conversion from the binary value of the point on the curve is performed in one of/// compressed, uncompressed, or hybrid conversions.  The default is compressed, except/// for binary curves./// Further documentation is available in the [X9.62] standard./// [X9.62]: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdfCOMPRESSED/// Compressed conversion from point value./// Uncompressed conversion from point value.HYBRID/// Performs both compressed and uncompressed conversions.Asn1Flag/// Named Curve or Explicit/// This type acts as a boolean as to whether the `EcGroup` is named or explicit.EXPLICIT_CURVE/// Curve defined using polynomial parameters/// Most applications use a named EC_GROUP curve, however, support/// is included to explicitly define the curve used to calculate keys/// This information would need to be known by both endpoint to make communication/// OPENSSL_EC_EXPLICIT_CURVE, but that was only added in 1.1./// Man page documents that 0 can be used in older versions./// OpenSSL documentation at [`EC_GROUP`]/// [`EC_GROUP`]: https://www.openssl.org/docs/manmaster/crypto/EC_GROUP_get_seed_len.htmlNAMED_CURVE/// Standard Curves/// Curves that make up the typical encryption use cases.  The collection of curves/// are well known but extensible./// [`EC_GROUP`]: https://www.openssl.org/docs/manmaster/man3/EC_GROUP_order_bits.htmlr" Describes the curve"r" A curve can be of the named curve type.  These curves can be discovered"r" using openssl binary `openssl ecparam -list_curves`.  Other operations"r" are available in the [wiki].  These named curves are available in the"r" [`Nid`] module."r" Curves can also be generated using prime field parameters or a binary field."r" Prime fields use the formula `y^2 mod p = x^3 + ax + b mod p`.  Binary"r" fields use the formula `y^2 + xy = x^3 + ax^2 + b`.  Named curves have"r" assured security.  To prevent accidental vulnerabilities, they should"r" be preferred."r" [wiki]: https://wiki.openssl.org/index.php/Command_Line_Elliptic_Curve_Operations"EC_GROUPEcGroupRefr" Reference to [`EcGroup`]"r" [`EcGroup`]: struct.EcGroup.html"" Returns the group of a standard named curve."" # fn main() -> Result<(), Box<dyn std::error::Error>> {"" use openssl::nid::Nid;"" use openssl::ec::{EcGroup, EcKey};"" let nid = Nid::X9_62_PRIME256V1; // NIST P-256 curve"" let group = EcGroup::from_curve_name(nid)?;"" let key = EcKey::generate(&group)?;"" # Ok(()) }""This corresponds to [`EC_GROUP_new_by_curve_name`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_new_by_curve_name.html)."from_curve_name" Returns the group for given parameters""This corresponds to [`EC_GROUP_new_curve_GFp`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_new_curve_GFp.html)."" Places the components of a curve over a prime field in the provided `BigNum`s."" The components make up the formula `y^2 mod p = x^3 + ax + b mod p`.""This corresponds to [`EC_GROUP_get_curve_GFp`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_curve_GFp.html)."components_gfp" Places the components of a curve over a binary field in the provided `BigNum`s."" The components make up the formula `y^2 + xy = x^3 + ax^2 + b`."" In this form `p` relates to the irreducible polynomial.  Each bit represents"" a term in the polynomial.  It will be set to 3 `1`s or 5 `1`s depending on"" using a trinomial or pentanomial.""This corresponds to [`EC_GROUP_get_curve_GF2m`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_curve_GF2m.html)."components_gf2m" Places the cofactor of the group in the provided `BigNum`.""This corresponds to [`EC_GROUP_get_cofactor`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_cofactor.html)."" Returns the degree of the curve.""This corresponds to [`EC_GROUP_get_degree`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_degree.html)."" Returns the number of bits in the group order.""This corresponds to [`EC_GROUP_order_bits`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_order_bits.html)."order_bits" Returns the generator for the given curve as an [`EcPoint`].""This corresponds to [`EC_GROUP_get0_generator`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get0_generator.html)."EcPointRef" Sets the generator point for the given curve""This corresponds to [`EC_GROUP_set_generator`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_set_generator.html)."set_generatorEcPoint" Places the order of the curve in the provided `BigNum`.""This corresponds to [`EC_GROUP_get_order`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_order.html)."" Sets the flag determining if the group corresponds to a named curve or must be explicitly"" parameterized."" This defaults to `EXPLICIT_CURVE` in OpenSSL 1.0.1 and 1.0.2, but `NAMED_CURVE` in OpenSSL"" 1.1.0.""This corresponds to [`EC_GROUP_set_asn1_flag`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_set_asn1_flag.html)."set_asn1_flag" Gets the flag determining if the group corresponds to a named curve.""This corresponds to [`EC_GROUP_get_asn1_flag`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_asn1_flag.html)."asn1_flag" Returns the name of the curve, if a name is associated.""This corresponds to [`EC_GROUP_get_curve_name`](https://www.openssl.org/docs/manmaster/man3/EC_GROUP_get_curve_name.html)."curve_namer" Represents a point on the curve"EC_POINTr" A reference a borrowed [`EcPoint`]."" Computes `a + b`, storing the result in `self`.""This corresponds to [`EC_POINT_add`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_add.html)."" Computes `q * m`, storing the result in `self`.""This corresponds to [`EC_POINT_mul`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_mul.html)."" Computes `generator * n`, storing the result in `self`."mul_generator" Computes `generator * n + q * m`, storing the result in `self`."mul_full" Inverts `self`.""This corresponds to [`EC_POINT_invert`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_invert.html)."" Serializes the point to a binary representation.""This corresponds to [`EC_POINT_point2oct`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_point2oct.html)."" Serializes the point to a hexadecimal string representation.""This corresponds to [`EC_POINT_point2hex`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_point2hex.html)."" Creates a new point on the specified curve with the same value.""This corresponds to [`EC_POINT_dup`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_dup.html)."" Determines if this point is equal to another.""This corresponds to [`EC_POINT_cmp`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_cmp.html)."" Places affine coordinates of a curve over a prime field in the provided"" `x` and `y` `BigNum`s.""This corresponds to [`EC_POINT_get_affine_coordinates`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_get_affine_coordinates.html)."affine_coordinates" `x` and `y` `BigNum`s""This corresponds to [`EC_POINT_get_affine_coordinates_GFp`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_get_affine_coordinates_GFp.html)."affine_coordinates_gfp" Sets affine coordinates of a curve over a prime field using the provided""This corresponds to [`EC_POINT_set_affine_coordinates_GFp`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_set_affine_coordinates_GFp.html)."set_affine_coordinates_gfp" Places affine coordinates of a curve over a binary field in the provided""This corresponds to [`EC_POINT_get_affine_coordinates_GF2m`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_get_affine_coordinates_GF2m.html)."affine_coordinates_gf2m" Checks if point is infinity""This corresponds to [`EC_POINT_is_at_infinity`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_is_at_infinity.html)."is_infinity" Checks if point is on a given curve""This corresponds to [`EC_POINT_is_on_curve`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_is_on_curve.html)."is_on_curve" Creates a new point on the specified curve.""This corresponds to [`EC_POINT_new`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_new.html)."" Creates point from a binary representation""This corresponds to [`EC_POINT_oct2point`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_oct2point.html)."" Creates point from a hexadecimal string representation""This corresponds to [`EC_POINT_hex2point`](https://www.openssl.org/docs/manmaster/man3/EC_POINT_hex2point.html)."r" Public and optional private key on the given curve."EC_KEYEcKeyRefr" A reference to an [`EcKey`]."r" Serializes the private key to a PEM-encoded ECPrivateKey structure."r" The output will have a header of `-----BEGIN EC PRIVATE KEY-----`.""This corresponds to [`PEM_write_bio_ECPrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_ECPrivateKey.html)."r" Serializes the private key to a PEM-encoded encrypted ECPrivateKey structure."r" Serializes the private key into a DER-encoded ECPrivateKey structure.""This corresponds to [`i2d_ECPrivateKey`](https://www.openssl.org/docs/manmaster/man3/i2d_ECPrivateKey.html)."" Returns the private key value.""This corresponds to [`EC_KEY_get0_private_key`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_get0_private_key.html)."" Returns the public key.""This corresponds to [`EC_KEY_get0_public_key`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_get0_public_key.html).""This corresponds to [`PEM_write_bio_EC_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_EC_PUBKEY.html).""This corresponds to [`i2d_EC_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/i2d_EC_PUBKEY.html)."" Returns the key\'s group.""This corresponds to [`EC_KEY_get0_group`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_get0_group.html)."" Checks the key for validity.""This corresponds to [`EC_KEY_check_key`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_check_key.html)."" Constructs an `EcKey` corresponding to a known curve."" It will not have an associated public or private key. This kind of key is primarily useful"" to be provided to the `set_tmp_ecdh` methods on `Ssl` and `SslContextBuilder`.""This corresponds to [`EC_KEY_new_by_curve_name`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_new_by_curve_name.html)."" Constructs an `EcKey` corresponding to a curve.""This corresponds to [`EC_KEY_set_group`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_set_group.html)."from_group" Constructs an `EcKey` from the specified group with the associated [`EcPoint`]: `public_key`."" This will only have the associated `public_key`."" use openssl::bn::BigNumContext;"" use openssl::ec::*;"" use openssl::pkey::PKey;"" let group = EcGroup::from_curve_name(Nid::SECP384R1)?;"" let mut ctx = BigNumContext::new()?;"" // get bytes from somewhere"" let public_key = // ..."" # EcKey::generate(&group)?.public_key().to_bytes(&group,"" # PointConversionForm::COMPRESSED, &mut ctx)?;"" // create an EcKey from the binary form of a EcPoint"" let point = EcPoint::from_bytes(&group, &public_key, &mut ctx)?;"" let key = EcKey::from_public_key(&group, &point)?;"" key.check_key()?;""This corresponds to [`EC_KEY_set_public_key`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_set_public_key.html)."from_public_key" Constructs a public key from its affine coordinates.""This corresponds to [`EC_KEY_set_public_key_affine_coordinates`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_set_public_key_affine_coordinates.html)."from_public_key_affine_coordinatesr" Decodes a PEM-encoded SubjectPublicKeyInfo structure containing a EC key.""This corresponds to [`PEM_read_bio_EC_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_EC_PUBKEY.html)."r" Decodes a DER-encoded SubjectPublicKeyInfo structure containing a EC key.""This corresponds to [`d2i_EC_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/d2i_EC_PUBKEY.html)."" Generates a new public/private key pair on the specified curve."" use openssl::ec::{EcGroup, EcKey, PointConversionForm};"" let public_key = &key.public_key().to_bytes(""     &group,""     PointConversionForm::COMPRESSED,""     &mut ctx,"" )?;"" assert_eq!(public_key.len(), 33);"" assert_ne!(public_key[0], 0x04);"" let private_key = key.private_key().to_vec();"" assert!(private_key.len() >= 31);""This corresponds to [`EC_KEY_generate_key`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_generate_key.html)."" Constructs an public/private key pair given a curve, a private key and a public key point.""This corresponds to [`EC_KEY_set_private_key`](https://www.openssl.org/docs/manmaster/man3/EC_KEY_set_private_key.html)."private_key_from_pemr" Deserializes a private key from a PEM-encoded ECPrivateKey structure."r" The input should have a header of `-----BEGIN EC PRIVATE KEY-----`.""This corresponds to [`PEM_read_bio_ECPrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_ECPrivateKey.html)."r" Deserializes a private key from a PEM-encoded encrypted ECPrivateKey structure."private_key_from_pem_passphraser" The callback should fill the password into the provided buffer and return its length."private_key_from_pem_callbackr" Decodes a DER-encoded elliptic curve private key structure.""This corresponds to [`d2i_ECPrivateKey`](https://www.openssl.org/docs/manmaster/man3/d2i_ECPrivateKey.html)."private_key_from_derkey_new_by_curve_nameec_group_from_componentsec_point_set_affineec_group_set_generatorpoint_newpoint_bytespoint_hex_strpoint_ownedkey_from_public_keykey_from_private_componentskey_from_affine_coordinatesget_affine_coordinatesget_affine_coordinates_gfp//! Elliptic Curve//! Cryptography relies on the difficulty of solving mathematical problems, such as the factor//! of large integers composed of two large prime numbers and the discrete logarithm of a//! random elliptic curve.  This module provides low-level features of the latter.//! Elliptic Curve protocols can provide the same security with smaller keys.//! There are 2 forms of elliptic curves, `Fp` and `F2^m`.  These curves use irreducible//! trinomial or pentanomial.  Being a generic interface to a wide range of algorithms,//! the curves are generally referenced by [`EcGroup`].  There are many built-in groups//! found in [`Nid`].//! OpenSSL Wiki explains the fields and curves in detail at [Elliptic Curve Cryptography].//! [`EcGroup`]: struct.EcGroup.html//! [`Nid`]: ../nid/struct.Nid.html//! [Elliptic Curve Cryptography]: https://wiki.openssl.org/index.php/Elliptic_Curve_Cryptographyr" A low level interface to ECDSA."ECDSA_SIGEcdsaSigEcdsaSigRefr" A reference to an [`EcdsaSig`]."" Computes a digital signature of the hash value `data` using the private EC key eckey.""This corresponds to [`ECDSA_do_sign`](https://www.openssl.org/docs/manmaster/man3/ECDSA_do_sign.html)."" Returns a new `EcdsaSig` by setting the `r` and `s` values associated with an ECDSA signature.""This corresponds to [`ECDSA_SIG_set0`](https://www.openssl.org/docs/manmaster/man3/ECDSA_SIG_set0.html)."r" Decodes a DER-encoded ECDSA signature.""This corresponds to [`d2i_ECDSA_SIG`](https://www.openssl.org/docs/manmaster/man3/d2i_ECDSA_SIG.html)."r" Serializes the ECDSA signature into a DER-encoded ECDSASignature structure.""This corresponds to [`i2d_ECDSA_SIG`](https://www.openssl.org/docs/manmaster/man3/i2d_ECDSA_SIG.html)."" Verifies if the signature is a valid ECDSA signature using the given public key.""This corresponds to [`ECDSA_do_verify`](https://www.openssl.org/docs/manmaster/man3/ECDSA_do_verify.html)."" Returns internal component: `r` of an `EcdsaSig`. (See X9.62 or FIPS 186-2)""This corresponds to [`ECDSA_SIG_get0`](https://www.openssl.org/docs/manmaster/man3/ECDSA_SIG_get0.html)."" Returns internal components: `s` of an `EcdsaSig`. (See X9.62 or FIPS 186-2)"ECDSA_SIG_set0ECDSA_SIG_get0get_public_keysign_and_verifycheck_private_componentsserialize_deserialize//! Low level Elliptic Curve Digital Signature Algorithm (ECDSA) functions.pctxEncrypter/// A type which encrypts data./// Creates a new `Encrypter`./// OpenSSL documentation at [`EVP_PKEY_encrypt_init`]./// [`EVP_PKEY_encrypt_init`]: https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_encrypt_init.htmlrsa_padding/// Returns the RSA padding mode in use./// This is only useful for RSA keys./// This corresponds to `EVP_PKEY_CTX_get_rsa_padding`.set_rsa_padding/// Sets the RSA padding mode./// This corresponds to [`EVP_PKEY_CTX_set_rsa_padding`]./// [`EVP_PKEY_CTX_set_rsa_padding`]: https://www.openssl.org/docs/manmaster/crypto/EVP_PKEY_CTX_set_rsa_padding.htmlset_rsa_mgf1_md/// Sets the RSA MGF1 algorithm./// This corresponds to [`EVP_PKEY_CTX_set_rsa_mgf1_md`]./// [`EVP_PKEY_CTX_set_rsa_mgf1_md`]: https://www.openssl.org/docs/manmaster/man7/RSA-PSS.htmlset_rsa_oaep_md/// Sets the RSA OAEP algorithm./// This corresponds to [`EVP_PKEY_CTX_set_rsa_oaep_md`]./// [`EVP_PKEY_CTX_set_rsa_oaep_md`]: https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_rsa_oaep_md.htmlset_rsa_oaep_label/// Sets the RSA OAEP label./// This corresponds to [`EVP_PKEY_CTX_set0_rsa_oaep_label`]./// [`EVP_PKEY_CTX_set0_rsa_oaep_label`]: https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set0_rsa_oaep_label.html/// Performs public key encryption./// In order to know the size needed for the output buffer, use [`encrypt_len`](Encrypter::encrypt_len)./// Note that the length of the output buffer can be greater of the length of the encoded data./// # use openssl::{/// #   encrypt::Encrypter,/// #   pkey::PKey,/// #   rsa::{Rsa, Padding},/// # let key = include_bytes!("../test/rsa.pem");/// # let private_key = Rsa::private_key_from_pem(key).unwrap();/// # let pkey = PKey::from_rsa(private_key).unwrap();/// # let input = b"hello world".to_vec();/// let mut encrypter = Encrypter::new(&pkey).unwrap();/// encrypter.set_rsa_padding(Padding::PKCS1).unwrap();/// // Get the length of the output buffer/// let buffer_len = encrypter.encrypt_len(&input).unwrap();/// let mut encoded = vec![0u8; buffer_len];/// // Encode the data and get its length/// let encoded_len = encrypter.encrypt(&input, &mut encoded).unwrap();/// // Use only the part of the buffer with the encoded data/// let encoded = &encoded[..encoded_len];/// This corresponds to [`EVP_PKEY_encrypt`]./// [`EVP_PKEY_encrypt`]: https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_encrypt.htmlencrypt_len/// Gets the size of the buffer needed to encrypt the input data./// This corresponds to [`EVP_PKEY_encrypt`] called with a null pointer as output argument.Decrypter/// A type which decrypts data./// Creates a new `Decrypter`./// OpenSSL documentation at [`EVP_PKEY_decrypt_init`]./// [`EVP_PKEY_decrypt_init`]: https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_decrypt_init.html/// Performs public key decryption./// In order to know the size needed for the output buffer, use [`decrypt_len`](Decrypter::decrypt_len)./// Note that the length of the output buffer can be greater of the length of the decoded data./// #   encrypt::Decrypter,/// # const INPUT: &[u8] = b"\/// #     \x26\xa1\xc1\x13\xc5\x7f\xb4\x9f\xa0\xb4\xde\x61\x5e\x2e\xc6\xfb\x76\x5c\xd1\x2b\x5f\/// #     \x1d\x36\x60\xfa\xf8\xe8\xb3\x21\xf4\x9c\x70\xbc\x03\xea\xea\xac\xce\x4b\xb3\xf6\x45\/// #     \xcc\xb3\x80\x9e\xa8\xf7\xc3\x5d\x06\x12\x7a\xa3\x0c\x30\x67\xf1\xe7\x94\x6c\xf6\x26\/// #     \xac\x28\x17\x59\x69\xe1\xdc\xed\x7e\xc0\xe9\x62\x57\x49\xce\xdd\x13\x07\xde\x18\x03\/// #     \x0f\x9d\x61\x65\xb9\x23\x8c\x78\x4b\xad\x23\x49\x75\x47\x64\xa0\xa0\xa2\x90\xc1\x49\/// #     \x1b\x05\x24\xc2\xe9\x2c\x0d\x49\x78\x72\x61\x72\xed\x8b\x6f\x8a\xe8\xca\x05\x5c\x58\/// #     \xd6\x95\xd6\x7b\xe3\x2d\x0d\xaa\x3e\x6d\x3c\x9a\x1c\x1d\xb4\x6c\x42\x9d\x9a\x82\x55\/// #     \xd9\xde\xc8\x08\x7b\x17\xac\xd7\xaf\x86\x7b\x69\x9e\x3c\xf4\x5e\x1c\x39\x52\x6d\x62\/// #     \x50\x51\xbd\xa6\xc8\x4e\xe9\x34\xf0\x37\x0d\xa9\xa9\x77\xe6\xf5\xc2\x47\x2d\xa8\xee\/// #     \x3f\x69\x78\xff\xa9\xdc\x70\x22\x20\x9a\x5c\x9b\x70\x15\x90\xd3\xb4\x0e\x54\x9e\x48\/// #     \xed\xb6\x2c\x88\xfc\xb4\xa9\x37\x10\xfa\x71\xb2\xec\x75\xe7\xe7\x0e\xf4\x60\x2c\x7b\/// #     \x58\xaf\xa0\x53\xbd\x24\xf1\x12\xe3\x2e\x99\x25\x0a\x54\x54\x9d\xa1\xdb\xca\x41\x85\/// #     \xf4\x62\x78\x64";/// # let input = INPUT.to_vec();/// let mut decrypter = Decrypter::new(&pkey).unwrap();/// decrypter.set_rsa_padding(Padding::PKCS1).unwrap();/// let buffer_len = decrypter.decrypt_len(&input).unwrap();/// let mut decoded = vec![0u8; buffer_len];/// // Decrypt the data and get its length/// let decoded_len = decrypter.decrypt(&input, &mut decoded).unwrap();/// // Use only the part of the buffer with the decrypted data/// let decoded = &decoded[..decoded_len];/// This corresponds to [`EVP_PKEY_decrypt`]./// [`EVP_PKEY_decrypt`]: https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_decrypt.htmldecrypt_len/// Gets the size of the buffer needed to decrypt the input data./// This corresponds to [`EVP_PKEY_decrypt`] called with a null pointer as output argument.rsa_encrypt_decryptrsa_encrypt_decrypt_with_sha256rsa_encrypt_decrypt_oaep_label//! Message encryption.//! The [`Encrypter`] allows for encryption of data given a public key. The [`Decrypter`] can be//! used with the corresponding private key to decrypt the data.//! Encrypt and decrypt data given an RSA keypair://! use openssl::encrypt::{Encrypter, Decrypter};//! use openssl::rsa::{Rsa, Padding};//! // Generate a keypair//! let keypair = Rsa::generate(2048).unwrap();//! let keypair = PKey::from_rsa(keypair).unwrap();//! let data = b"hello, world!";//! // Encrypt the data with RSA PKCS1//! let mut encrypter = Encrypter::new(&keypair).unwrap();//! encrypter.set_rsa_padding(Padding::PKCS1).unwrap();//! // Create an output buffer//! let buffer_len = encrypter.encrypt_len(data).unwrap();//! let mut encrypted = vec![0; buffer_len];//! // Encrypt and truncate the buffer//! let encrypted_len = encrypter.encrypt(data, &mut encrypted).unwrap();//! encrypted.truncate(encrypted_len);//! // Decrypt the data//! let mut decrypter = Decrypter::new(&keypair).unwrap();//! decrypter.set_rsa_padding(Padding::PKCS1).unwrap();//! let buffer_len = decrypter.decrypt_len(&encrypted).unwrap();//! let mut decrypted = vec![0; buffer_len];//! let decrypted_len = decrypter.decrypt(&encrypted, &mut decrypted).unwrap();//! decrypted.truncate(decrypted_len);//! assert_eq!(&*decrypted, data);cipher_ctxenc_keys/// Represents an EVP_Seal context./// Creates a new `Seal`./// Returns the initialization vector, if the cipher uses one.encrypted_keys/// Returns the encrypted keys./// Feeds data from `input` through the cipher, writing encrypted bytes into `output`./// The number of bytes written to `output` is returned. Note that this may/// not be equal to the length of `input`./// Panics if `output.len() < input.len() + block_size` where `block_size` is/// the block size of the cipher (see `Cipher::block_size`), or if/// `output.len() > c_int::MAX`./// Finishes the encryption process, writing any remaining data to `output`./// The number of bytes written to `output` is returned./// `update` should not be called after this method./// Panics if `output` is less than the cipher's block size./// Represents an EVP_Open context./// Creates a new `Open`./// Feeds data from `input` through the cipher, writing decrypted bytes into `output`./// Panics if `output.len() < input.len() + block_size` where/// `block_size` is the block size of the cipher (see `Cipher::block_size`),/// or if `output.len() > c_int::MAX`./// Finishes the decryption process, writing any remaining data to `output`.public_encrypt_private_decrypt//! Envelope encryption.//! use openssl::rsa::Rsa;//! use openssl::envelope::Seal;//! use openssl::symm::Cipher;//! let rsa = Rsa::generate(2048).unwrap();//! let key = PKey::from_rsa(rsa).unwrap();//! let cipher = Cipher::aes_256_cbc();//! let mut seal = Seal::new(cipher, &[key]).unwrap();//! let secret = b"My secret message";//! let mut encrypted = vec![0; secret.len() + cipher.block_size()];//! let mut enc_len = seal.update(secret, &mut encrypted).unwrap();//! enc_len += seal.finalize(&mut encrypted[enc_len..]).unwrap();//! encrypted.truncate(enc_len);/// Collection of [`Error`]s from OpenSSL./// [`Error`]: struct.Error.html/// Returns the contents of the OpenSSL error stack./// Pushes the errors back onto the OpenSSL error stack./// Returns the errors in the stack.ShimStr/// An error reported from OpenSSL./// Returns the first error on the OpenSSL error stack./// Pushes the error back onto the OpenSSL error stack.put_error/// Returns the raw OpenSSL error code for this error./// Returns the name of the library reporting the error, if available.library_code/// Returns the raw OpenSSL error constant for the library reporting the// On BoringSSL ERR_GET_{LIB,FUNC,REASON} are `unsafe`, but on// OpenSSL/LibreSSL they're safe.RetStr/// Returns the name of the function reporting the error./// Returns the reason for the error./// Returns the raw OpenSSL error constant for the reason for the error./// Returns the name of the source file which encountered the error./// Returns the line in the source file which encountered the error./// Returns additional data describing the error.ERR_get_error_all//! Errors returned by OpenSSL library.//! OpenSSL errors are stored in an `ErrorStack`.  Most methods in the crate//! returns a `Result<T, ErrorStack>` type.//! let an_error = BigNum::from_dec_str("Cannot parse letters");//! match an_error {//!     Ok(_)  => (),//!     Err(e) => println!("Parsing Error: {:?}", e),/// A slot in a type's "extra data" structure./// It is parameterized over the type containing the extra data as well as the/// type of the data in the slot./// Creates an `Index` from a raw integer index./// The caller must ensure that the index correctly maps to a `U` value stored in a `T`./// Moves the library into or out of the FIPS 140-2 mode of operation./// Determines if the library is running in the FIPS 140-2 mode of operation.//! FIPS 140-2 support.//! See [OpenSSL's documentation] for details.//! [OpenSSL's documentation]: https://www.openssl.org/docs/fips/UserGuide-2.0.pdfEVP_MD_CTX_freeEVP_MD_CTX_newEVP_MD/// A message digest algorithm./// Creates a `MessageDigest` from a raw OpenSSL pointer./// The caller must ensure the pointer is valid." Returns the `MessageDigest` corresponding to an `Nid`.""This corresponds to [`EVP_get_digestbynid`](https://www.openssl.org/docs/manmaster/man3/EVP_get_digestbynid.html)."" Returns the `MessageDigest` corresponding to an algorithm name.""This corresponds to [`EVP_get_digestbyname`](https://www.openssl.org/docs/manmaster/man3/EVP_get_digestbyname.html)."sha224sha384sha512sha3_224sha3_256sha3_384sha3_512shake_128shake_256ripemd160sm3/// The block size of the digest in bytes./// The size of the digest in bytes./// The name of the digest.UpdatedFinalizedEVP_MD_CTXmd/// Provides message digest (hash) computation./// use openssl::hash::{Hasher, MessageDigest};/// let data = [b"\x42\xF4", b"\x97\xE0"];/// let spec = b"\x7c\x43\x0f\x17\x8a\xef\xdf\x14\x87\xfe\xe7\x14\x4e\x96\x41\xe2";/// let mut h = Hasher::new(MessageDigest::md5())?;/// h.update(data[0])?;/// h.update(data[1])?;/// let res = h.finish()?;/// assert_eq!(&*res, spec);/// Don't actually use MD5 and SHA-1 hashes, they're not secure anymore./// Don't ever hash passwords, use the functions in the `pkcs5` module or bcrypt/scrypt instead./// For extendable output functions (XOFs, i.e. SHAKE128/SHAKE256),/// you must use [`Hasher::finish_xof`] instead of [`Hasher::finish`]/// and provide a `buf` to store the hash. The hash will be as long as/// the `buf`./// Creates a new `Hasher` with the specified hash type./// Feeds data into the hasher.DigestBytes/// Returns the hash of the data written and resets the non-XOF hasher.finish_xof/// Writes the hash of the data into the supplied buf and resets the XOF hasher./// The hash will be as long as the buf.EVP_MAX_MD_SIZE/// The resulting bytes of a digest./// This type derefs to a byte slice - it exists to avoid allocating memory to/// store the digest data./// Computes the hash of the `data` with the non-XOF hasher `t`./// use openssl::hash::{hash, MessageDigest};/// let data = b"\x42\xF4\x97\xE0";/// let res = hash(MessageDigest::md5(), data)?;hash_xof/// Computes the hash of the `data` with the XOF hasher `t` and stores it in `buf`./// use openssl::hash::{hash_xof, MessageDigest};/// let data = b"\x41\x6c\x6c\x20\x79\x6f\x75\x72\x20\x62\x61\x73\x65\x20\x61\x72\x65\x20\x62\x65\x6c\x6f\x6e\x67\x20\x74\x6f\x20\x75\x73";/// let spec = b"\x49\xd0\x69\x7f\xf5\x08\x11\x1d\x8b\x84\xf1\x5e\x46\xda\xf1\x35";/// let mut buf = vec![0; 16];/// hash_xof(MessageDigest::shake_128(), data, buf.as_mut_slice()).unwrap();/// assert_eq!(buf, spec);hash_testhash_xof_testhash_recycle_testMD5_TESTS// Test vectors from http://www.nsrl.nist.gov/testdata/test_md5test_md5_recycletest_finish_twicetest_sha1test_sha256test_sha512test_sha3_224test_sha3_256test_sha3_384test_sha3_512test_shake_128test_shake_256test_ripemd160test_sm3//! Message digest (hash) computation support.//! Calculate a hash in one go://! use openssl::hash::{hash, MessageDigest};//! let data = b"\x42\xF4\x97\xE0";//! let spec = b"\x7c\x43\x0f\x17\x8a\xef\xdf\x14\x87\xfe\xe7\x14\x4e\x96\x41\xe2";//! let res = hash(MessageDigest::md5(), data)?;//! assert_eq!(&*res, spec);//! Supply the input in chunks://! use openssl::hash::{Hasher, MessageDigest};//! let mut hasher = Hasher::new(MessageDigest::sha256())?;//! hasher.update(b"test")?;//! hasher.update(b"this")?;//! let digest: &[u8] = &hasher.finish()?;//! let expected = hex::decode("9740e652ab5b4acd997a7cca13d6696702ccb2d441cca59fc6e285127f28cfe6")?;//! assert_eq!(digest, expected);EVP_KDFEvpKdfEVP_KDF_CTXEvpKdfCtxr" Derives a key using the argon2id algorithm."r" To use multiple cores to process the lanes in parallel you must"r" set a global max thread count using `OSSL_set_max_threads`. On"r" builds with no threads all lanes will be processed sequentially."r" Requires OpenSSL 3.2.0 or newer."argon2idargon2id_no_ad_secretcmsconfdsaex_datakdfmd_ctxocsppkcs5pkcs7pkey_ctxshaSLenTypecvt_p_constcvt_long// cvt_long is currently only used in functions that require openssl >= 3.0.0,// so this cfg statement is used to avoid "unused function" errors when// compiling with openssl < 3.0.0//! Bindings to OpenSSL//! This crate provides a safe interface to the popular OpenSSL cryptography library. OpenSSL versions 1.0.1 through//! 3.x.x and LibreSSL versions 2.5 through 3.7.x are supported.//! # Building//! Both OpenSSL libraries and headers are required to build this crate. There are multiple options available to locate//! OpenSSL.//! ## Vendored//! If the `vendored` Cargo feature is enabled, the `openssl-src` crate will be used to compile and statically link to//! a copy of OpenSSL. The build process requires a C compiler, perl (and perl-core), and make. The OpenSSL version will generally track//! the newest OpenSSL release, and changes to the version are *not* considered breaking changes.//! openssl = { version = "0.10", features = ["vendored"] }//! The vendored copy will be configured to automatically find a configuration and root certificates at `/usr/local/ssl`.//! This path can be overridden with an environment variable (see the manual section below).//! Alternatively, the `openssl-probe` crate can be used to find root certificates at runtime.//! ## Automatic//! The `openssl-sys` crate will automatically detect OpenSSL installations via Homebrew on macOS and vcpkg on Windows.//! Additionally, it will use `pkg-config` on Unix-like systems to find the system installation.//! ```not_rust//! # macOS (Homebrew)//! $ brew install openssl@3//! # macOS (MacPorts)//! $ sudo port install openssl//! # macOS (pkgsrc)//! $ sudo pkgin install openssl//! # Arch Linux//! $ sudo pacman -S pkgconf openssl//! # Debian and Ubuntu//! $ sudo apt-get install pkg-config libssl-dev//! # Fedora//! $ sudo dnf install pkgconf perl-FindBin perl-IPC-Cmd openssl-devel//! # Alpine Linux//! $ apk add pkgconf openssl-dev//! # openSUSE//! $ sudo zypper in libopenssl-devel//! ## Manual//! A set of environment variables can be used to point `openssl-sys` towards an OpenSSL installation. They will//! override the automatic detection logic.//! * `OPENSSL_DIR` - If specified, the directory of an OpenSSL installation. The directory should contain `lib` and//!     `include` subdirectories containing the libraries and headers respectively.//! * `OPENSSL_LIB_DIR` and `OPENSSL_INCLUDE_DIR` - If specified, the directories containing the OpenSSL libraries and//!     headers respectively. This can be used if the OpenSSL installation is split in a nonstandard directory layout.//! * `OPENSSL_STATIC` - If set, the crate will statically link to OpenSSL rather than dynamically link.//! * `OPENSSL_LIBS` - If set, a `:`-separated list of library names to link to (e.g. `ssl:crypto`). This can be used//!     if nonstandard library names were used for whatever reason.//! * `OPENSSL_NO_VENDOR` - If set, always find OpenSSL in the system, even if the `vendored` feature is enabled.//! If the `vendored` Cargo feature is enabled, the following environment variable can also be used to further configure//! the OpenSSL build.//! * `OPENSSL_CONFIG_DIR` - If set, the copy of OpenSSL built by the `openssl-src` crate will be configured to look for//!     configuration files and root certificates in this directory.//! Additionally, these variables can be prefixed with the upper-cased target architecture (e.g.//!     `X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR`), which can be useful when cross compiling.//! # Feature Detection//! APIs have been added to and removed from the various supported OpenSSL versions, and this library exposes the//! functionality available in the version being linked against. This means that methods, constants, and even modules//! will be present when building against one version of OpenSSL but not when building against another! APIs will//! document any version-specific availability restrictions.//! A build script can be used to detect the OpenSSL or LibreSSL version at compile time if needed. The `openssl-sys`//! crate propagates the version via the `DEP_OPENSSL_VERSION_NUMBER` and `DEP_OPENSSL_LIBRESSL_VERSION_NUMBER`//! environment variables to build scripts. The version format is a hex-encoding of the OpenSSL release version://! `0xMNNFFPPS`. For example, version 1.0.2g's encoding is `0x1_00_02_07_0`.//! For example, let's say we want to adjust the TLSv1.3 cipher suites used by a client, but also want to compile//! against OpenSSL versions that don't support TLSv1.3://! Cargo.toml://! openssl-sys = "0.9"//! openssl = "0.10"//! build.rs://!     if let Ok(v) = env::var("DEP_OPENSSL_VERSION_NUMBER") {//!         let version = u64::from_str_radix(&v, 16).unwrap();//!         if version >= 0x1_01_01_00_0 {//!             println!("cargo:rustc-cfg=openssl111");//! lib.rs://! use openssl::ssl::{SslConnector, SslMethod};//! let mut ctx = SslConnector::builder(SslMethod::tls()).unwrap();//! // set_ciphersuites was added in OpenSSL 1.1.1, so we can only call it when linking against that version//! #[cfg(openssl111)]//! ctx.set_ciphersuites("TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256").unwrap();OSSL_LIB_CTXLibCtx"This corresponds to [`OSSL_LIB_CTX_new`](https://www.openssl.org/docs/manmaster/man3/OSSL_LIB_CTX_new.html)."MdMdRef" Returns the `Md` corresponding to an [`Nid`]."" Fetches an `Md` object corresponding to the specified algorithm name and properties.""This corresponds to [`EVP_MD_fetch`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_fetch.html)."shake128shake256/// A reference to an [`Md`]." Returns the block size of the digest in bytes.""This corresponds to [`EVP_MD_block_size`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_block_size.html)."" Returns the size of the digest in bytes.""This corresponds to [`EVP_MD_size`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_size.html)."" Returns the [`Nid`] of the digest.""This corresponds to [`EVP_MD_type`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_type.html)."//! Message digest algorithms.PkeyCtxRefMdCtxMdCtxRefr" A reference to an [`MdCtx`].""This corresponds to [`EVP_MD_CTX_new`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_CTX_new.html)."" Initializes the context to compute the digest of data.""This corresponds to [`EVP_DigestInit_ex`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestInit_ex.html)."digest_init" Initializes the context to compute the signature of data."" A reference to the context\'s inner `PkeyCtx` is returned, allowing signature settings to be configured.""This corresponds to [`EVP_DigestSignInit`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestSignInit.html)."digest_sign_init" Initializes the context to verify the signature of data.""This corresponds to [`EVP_DigestVerifyInit`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestVerifyInit.html)."digest_verify_init" Updates the context with more data.""This corresponds to [`EVP_DigestUpdate`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestUpdate.html)."digest_update"This corresponds to [`EVP_DigestSignUpdate`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestSignUpdate.html)."digest_sign_update"This corresponds to [`EVP_DigestVerifyUpdate`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestVerifyUpdate.html)."digest_verify_update" Copies the computed digest into the buffer, returning the number of bytes written.""This corresponds to [`EVP_DigestFinal`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestFinal.html)."digest_final" Copies the computed digest into the buffer.""This corresponds to [`EVP_DigestFinalXOF`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestFinalXOF.html)."digest_final_xof" Signs the computed digest."" If `out` is set to `None`, an upper bound on the number of bytes required for the output buffer will be""This corresponds to [`EVP_DigestSignFinal`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestSignFinal.html)."digest_sign_finaldigest_sign_final_to_vec/// Like [`Self::digest_sign_final`] but appends the signature to a [`Vec`]." Verifies the provided signature."" Returns `Ok(true)` if the signature is valid, `Ok(false)` if the signature is invalid, and `Err` if an error"" occurred.""This corresponds to [`EVP_DigestVerifyFinal`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestVerifyFinal.html)."digest_verify_final" Computes the signature of the data in `from`."" If `to` is set to `None`, an upper bound on the number of bytes required for the output buffer will be""This corresponds to [`EVP_DigestSign`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestSign.html)."digest_signdigest_sign_to_vec/// Like [`Self::digest_sign`] but appends the signature to a [`Vec`]." Verifies the signature of the data in `data`.""This corresponds to [`EVP_DigestVerify`](https://www.openssl.org/docs/manmaster/man3/EVP_DigestVerify.html)."digest_verify" Returns the size of the message digest, i.e. the size of the hash""This corresponds to [`EVP_MD_CTX_size`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_CTX_size.html)."" Resets the underlying EVP_MD_CTX instance""This corresponds to [`EVP_MD_CTX_reset`](https://www.openssl.org/docs/manmaster/man3/EVP_MD_CTX_reset.html)."verify_failverify_successverify_with_public_successverify_md_ctx_sizeverify_md_ctx_reset//! The message digest context.//! Compute the SHA256 checksum of data//! use openssl::md::Md;//! use openssl::md_ctx::MdCtx;//! let mut ctx = MdCtx::new().unwrap();//! ctx.digest_init(Md::sha256()).unwrap();//! ctx.digest_update(b"Some Crypto Text").unwrap();//! let mut digest = [0; 32];//! ctx.digest_final(&mut digest).unwrap();//!     digest,//!     *b"\x60\x78\x56\x38\x8a\xca\x5c\x51\x83\xc4\xd1\x4d\xc8\xf9\xcc\xf2\//!        \xa5\x21\xb3\x10\x93\x72\xfa\xd6\x7c\x55\xf5\xc9\xe3\xd1\x83\x19",//! Sign and verify data with RSA and SHA256//! // Generate a random RSA key.//! let key = Rsa::generate(4096).unwrap();//! let key = PKey::from_rsa(key).unwrap();//! let text = b"Some Crypto Text";//! // Create the signature.//! ctx.digest_sign_init(Some(Md::sha256()), &key).unwrap();//! ctx.digest_sign_update(text).unwrap();//! let mut signature = vec![];//! ctx.digest_sign_final_to_vec(&mut signature).unwrap();//! // Verify the signature.//! ctx.digest_verify_init(Some(Md::sha256()), &key).unwrap();//! ctx.digest_verify_update(text).unwrap();//! let valid = ctx.digest_verify_final(&signature).unwrap();//! assert!(valid);" Returns `true` iff `a` and `b` contain the same bytes."" This operation takes an amount of time dependent on the length of the two"" arrays given, but is independent of the contents of a and b."" This function will panic the current task if `a` and `b` do not have the same"" To perform a constant-time comparison of two arrays of the same length but different"" values:"" use openssl::memcmp::eq;"" // We want to compare `a` to `b` and `c`, without giving"" // away through timing analysis that `c` is more similar to `a`"" // than `b`."" let a = [0, 0, 0];"" let b = [1, 1, 1];"" let c = [0, 0, 1];"" // These statements will execute in the same amount of time."" assert!(!eq(&a, &b));"" assert!(!eq(&a, &c));""This corresponds to [`CRYPTO_memcmp`](https://www.openssl.org/docs/manmaster/man3/CRYPTO_memcmp.html)."test_diff_lens//! Utilities to safely compare cryptographic values.//! Extra care must be taken when comparing values in//! cryptographic code. If done incorrectly, it can lead//! to a [timing attack](https://en.wikipedia.org/wiki/Timing_attack).//! By analyzing the time taken to execute parts of a cryptographic//! algorithm, and attacker can attempt to compromise the//! cryptosystem.//! The utilities in this module are designed to be resistant//! to this type of attack.//! To perform a constant-time comparison of two arrays of the same length but different//! values://! use openssl::memcmp::eq;//! // We want to compare `a` to `b` and `c`, without giving//! // away through timing analysis that `c` is more similar to `a`//! // than `b`.//! let a = [0, 0, 0];//! let b = [1, 1, 1];//! let c = [0, 0, 1];//! // These statements will execute in the same amount of time.//! assert!(!eq(&a, &b));//! assert!(!eq(&a, &c));/// The signature's digest./// If the signature does not specify a digest, this will be `NID::UNDEF`./// The signature's public-key.SignatureAlgorithms/// The digest and public-key algorithms associated with a signature./// A numerical identifier for an OpenSSL object./// Objects in OpenSSL can have a short name, a long name, and/// a numerical identifier (NID). For convenience, objects/// are usually represented in source code using these numeric/// Users should generally not need to create new `Nid`s./// To view the integer representation of a `Nid`:/// use openssl::nid::Nid;/// assert!(Nid::AES_256_GCM.as_raw() == 901);/// # External Documentation/// The following documentation provides context about `Nid`s and their usage/// in OpenSSL./// - [Obj_nid2obj](https://www.openssl.org/docs/manmaster/crypto/OBJ_create.html)/// Create a `Nid` from an integer representation./// Return the integer representation of a `Nid`." Creates a new `Nid` for the `oid` with short name `sn` and long name `ln`.""This corresponds to [`OBJ_create`](https://www.openssl.org/docs/manmaster/man3/OBJ_create.html)."" Returns the `Nid`s of the digest and public key algorithms associated with a signature ID.""This corresponds to [`OBJ_find_sigid_algs`](https://www.openssl.org/docs/manmaster/man3/OBJ_find_sigid_algs.html)."signature_algorithms" Returns the string representation of a `Nid` (long).""This corresponds to [`OBJ_nid2ln`](https://www.openssl.org/docs/manmaster/man3/OBJ_nid2ln.html)."" Returns the string representation of a `Nid` (short).""This corresponds to [`OBJ_nid2sn`](https://www.openssl.org/docs/manmaster/man3/OBJ_nid2sn.html)."UNDEFITU_TCCITTISOJOINT_ISO_ITU_TJOINT_ISO_CCITTMEMBER_BODYIDENTIFIED_ORGANIZATIONHMAC_MD5HMAC_SHA1CERTICOM_ARCINTERNATIONAL_ORGANIZATIONSWAPWAP_WSGSELECTED_ATTRIBUTE_TYPESCLEARANCEISO_USX9_57X9CMDSAWITHSHA1ANSI_X9_62X9_62_PRIME_FIELDX9_62_CHARACTERISTIC_TWO_FIELDX9_62_ID_CHARACTERISTIC_TWO_BASISX9_62_ONBASISX9_62_TPBASISX9_62_PPBASISX9_62_ID_ECPUBLICKEYX9_62_C2PNB163V1X9_62_C2PNB163V2X9_62_C2PNB163V3X9_62_C2PNB176V1X9_62_C2TNB191V1X9_62_C2TNB191V2X9_62_C2TNB191V3X9_62_C2ONB191V4X9_62_C2ONB191V5X9_62_C2PNB208W1X9_62_C2TNB239V1X9_62_C2TNB239V2X9_62_C2TNB239V3X9_62_C2ONB239V4X9_62_C2ONB239V5X9_62_C2PNB272W1X9_62_C2PNB304W1X9_62_C2TNB359V1X9_62_C2PNB368W1X9_62_C2TNB431R1X9_62_PRIME192V1X9_62_PRIME192V2X9_62_PRIME192V3X9_62_PRIME239V1X9_62_PRIME239V2X9_62_PRIME239V3X9_62_PRIME256V1ECDSA_WITH_SHA1ECDSA_WITH_RECOMMENDEDECDSA_WITH_SPECIFIEDECDSA_WITH_SHA224ECDSA_WITH_SHA256ECDSA_WITH_SHA384ECDSA_WITH_SHA512SECP112R1SECP112R2SECP128R1SECP128R2SECP160K1SECP160R1SECP160R2SECP192K1SECP224K1SECP224R1SECP256K1SECP384R1SECP521R1SECT113R1SECT113R2SECT131R1SECT131R2SECT163K1SECT163R1SECT163R2SECT193R1SECT193R2SECT233K1SECT233R1SECT239K1SECT283K1SECT283R1SECT409K1SECT409R1SECT571K1SECT571R1BRAINPOOL_P256R1BRAINPOOL_P320R1BRAINPOOL_P384R1BRAINPOOL_P512R1WAP_WSG_IDM_ECID_WTLS1WAP_WSG_IDM_ECID_WTLS3WAP_WSG_IDM_ECID_WTLS4WAP_WSG_IDM_ECID_WTLS5WAP_WSG_IDM_ECID_WTLS6WAP_WSG_IDM_ECID_WTLS7WAP_WSG_IDM_ECID_WTLS8WAP_WSG_IDM_ECID_WTLS9WAP_WSG_IDM_ECID_WTLS10WAP_WSG_IDM_ECID_WTLS11WAP_WSG_IDM_ECID_WTLS12CAST5_CBCCAST5_ECBCAST5_CFB64CAST5_OFB64PBEWITHMD5ANDCAST5_CBCID_PASSWORDBASEDMACID_DHBASEDMACPKCSPKCS1RSAENCRYPTIONMD2WITHRSAENCRYPTIONMD4WITHRSAENCRYPTIONMD5WITHRSAENCRYPTIONSHA1WITHRSAENCRYPTIONRSAESOAEPMGF1RSASSAPSSSHA256WITHRSAENCRYPTIONSHA384WITHRSAENCRYPTIONSHA512WITHRSAENCRYPTIONSHA224WITHRSAENCRYPTIONPKCS3DHKEYAGREEMENTPKCS5PBEWITHMD2ANDDES_CBCPBEWITHMD5ANDDES_CBCPBEWITHMD2ANDRC2_CBCPBEWITHMD5ANDRC2_CBCPBEWITHSHA1ANDDES_CBCPBEWITHSHA1ANDRC2_CBCID_PBKDF2PBES2PBMAC1PKCS7PKCS7_DATAPKCS7_SIGNEDPKCS7_ENVELOPEDPKCS7_SIGNEDANDENVELOPEDPKCS7_DIGESTPKCS7_ENCRYPTEDPKCS9PKCS9_EMAILADDRESSPKCS9_UNSTRUCTUREDNAMEPKCS9_CONTENTTYPEPKCS9_MESSAGEDIGESTPKCS9_SIGNINGTIMEPKCS9_COUNTERSIGNATUREPKCS9_CHALLENGEPASSWORDPKCS9_UNSTRUCTUREDADDRESSPKCS9_EXTCERTATTRIBUTESEXT_REQSMIMECAPABILITIESSMIMEID_SMIME_MODID_SMIME_CTID_SMIME_AAID_SMIME_ALGID_SMIME_CDID_SMIME_SPQID_SMIME_CTIID_SMIME_MOD_CMSID_SMIME_MOD_ESSID_SMIME_MOD_OIDID_SMIME_MOD_MSG_V3ID_SMIME_MOD_ETS_ESIGNATURE_88ID_SMIME_MOD_ETS_ESIGNATURE_97ID_SMIME_MOD_ETS_ESIGPOLICY_88ID_SMIME_MOD_ETS_ESIGPOLICY_97ID_SMIME_CT_RECEIPTID_SMIME_CT_AUTHDATAID_SMIME_CT_PUBLISHCERTID_SMIME_CT_TSTINFOID_SMIME_CT_TDTINFOID_SMIME_CT_CONTENTINFOID_SMIME_CT_DVCSREQUESTDATAID_SMIME_CT_DVCSRESPONSEDATAID_SMIME_CT_COMPRESSEDDATAID_CT_ASCIITEXTWITHCRLFID_SMIME_AA_RECEIPTREQUESTID_SMIME_AA_SECURITYLABELID_SMIME_AA_MLEXPANDHISTORYID_SMIME_AA_CONTENTHINTID_SMIME_AA_MSGSIGDIGESTID_SMIME_AA_ENCAPCONTENTTYPEID_SMIME_AA_CONTENTIDENTIFIERID_SMIME_AA_MACVALUEID_SMIME_AA_EQUIVALENTLABELSID_SMIME_AA_CONTENTREFERENCEID_SMIME_AA_ENCRYPKEYPREFID_SMIME_AA_SIGNINGCERTIFICATEID_SMIME_AA_SMIMEENCRYPTCERTSID_SMIME_AA_TIMESTAMPTOKENID_SMIME_AA_ETS_SIGPOLICYIDID_SMIME_AA_ETS_COMMITMENTTYPEID_SMIME_AA_ETS_SIGNERLOCATIONID_SMIME_AA_ETS_SIGNERATTRID_SMIME_AA_ETS_OTHERSIGCERTID_SMIME_AA_ETS_CONTENTTIMESTAMPID_SMIME_AA_ETS_CERTIFICATEREFSID_SMIME_AA_ETS_REVOCATIONREFSID_SMIME_AA_ETS_CERTVALUESID_SMIME_AA_ETS_REVOCATIONVALUESID_SMIME_AA_ETS_ESCTIMESTAMPID_SMIME_AA_ETS_CERTCRLTIMESTAMPID_SMIME_AA_ETS_ARCHIVETIMESTAMPID_SMIME_AA_SIGNATURETYPEID_SMIME_AA_DVCS_DVCID_SMIME_ALG_ESDHWITH3DESID_SMIME_ALG_ESDHWITHRC2ID_SMIME_ALG_3DESWRAPID_SMIME_ALG_RC2WRAPID_SMIME_ALG_ESDHID_SMIME_ALG_CMS3DESWRAPID_SMIME_ALG_CMSRC2WRAPID_ALG_PWRI_KEKID_SMIME_CD_LDAPID_SMIME_SPQ_ETS_SQT_URIID_SMIME_SPQ_ETS_SQT_UNOTICEID_SMIME_CTI_ETS_PROOFOFORIGINID_SMIME_CTI_ETS_PROOFOFRECEIPTID_SMIME_CTI_ETS_PROOFOFDELIVERYID_SMIME_CTI_ETS_PROOFOFSENDERID_SMIME_CTI_ETS_PROOFOFAPPROVALID_SMIME_CTI_ETS_PROOFOFCREATIONFRIENDLYNAMELOCALKEYIDMS_CSP_NAMELOCALKEYSETX509CERTIFICATESDSICERTIFICATEX509CRLPBE_WITHSHA1AND128BITRC4PBE_WITHSHA1AND40BITRC4PBE_WITHSHA1AND3_KEY_TRIPLEDES_CBCPBE_WITHSHA1AND2_KEY_TRIPLEDES_CBCPBE_WITHSHA1AND128BITRC2_CBCPBE_WITHSHA1AND40BITRC2_CBCKEYBAGPKCS8SHROUDEDKEYBAGCERTBAGCRLBAGSECRETBAGSAFECONTENTSBAGMD2MD4MD5MD5_SHA1HMACWITHMD5HMACWITHSHA1HMACWITHSHA224HMACWITHSHA256HMACWITHSHA384HMACWITHSHA512RC2_CBCRC2_ECBRC2_CFB64RC2_OFB64RC2_40_CBCRC2_64_CBCRC4RC4_40DES_EDE3_CBCRC5_CBCRC5_ECBRC5_CFB64RC5_OFB64MS_EXT_REQMS_CODE_INDMS_CODE_COMMS_CTL_SIGNMS_SGCMS_EFSMS_SMARTCARD_LOGINMS_UPNIDEA_CBCIDEA_ECBIDEA_CFB64IDEA_OFB64BF_CBCBF_ECBBF_CFB64BF_OFB64ID_PKIX_MODID_PKIX1_EXPLICIT_88ID_PKIX1_IMPLICIT_88ID_PKIX1_EXPLICIT_93ID_PKIX1_IMPLICIT_93ID_MOD_CRMFID_MOD_CMCID_MOD_KEA_PROFILE_88ID_MOD_KEA_PROFILE_93ID_MOD_CMPID_MOD_QUALIFIED_CERT_88ID_MOD_QUALIFIED_CERT_93ID_MOD_ATTRIBUTE_CERTID_MOD_TIMESTAMP_PROTOCOLID_MOD_OCSPID_MOD_DVCSID_MOD_CMP2000INFO_ACCESSBIOMETRICINFOQCSTATEMENTSAC_AUDITENTITYAC_TARGETINGAACONTROLSSBGP_IPADDRBLOCKSBGP_AUTONOMOUSSYSNUMSBGP_ROUTERIDENTIFIERAC_PROXYINGSINFO_ACCESSPROXYCERTINFOTEXTNOTICESERVER_AUTHCLIENT_AUTHCODE_SIGNEMAIL_PROTECTIPSECENDSYSTEMIPSECTUNNELIPSECUSERTIME_STAMPOCSP_SIGNDVCSID_IT_CAPROTENCCERTID_IT_SIGNKEYPAIRTYPESID_IT_ENCKEYPAIRTYPESID_IT_PREFERREDSYMMALGID_IT_CAKEYUPDATEINFOID_IT_CURRENTCRLID_IT_UNSUPPORTEDOIDSID_IT_SUBSCRIPTIONREQUESTID_IT_SUBSCRIPTIONRESPONSEID_IT_KEYPAIRPARAMREQID_IT_KEYPAIRPARAMREPID_IT_REVPASSPHRASEID_IT_IMPLICITCONFIRMID_IT_CONFIRMWAITTIMEID_IT_ORIGPKIMESSAGEID_IT_SUPPLANGTAGSID_REGCTRLID_REGINFOID_REGCTRL_REGTOKENID_REGCTRL_AUTHENTICATORID_REGCTRL_PKIPUBLICATIONINFOID_REGCTRL_PKIARCHIVEOPTIONSID_REGCTRL_OLDCERTIDID_REGCTRL_PROTOCOLENCRKEYID_REGINFO_UTF8PAIRSID_REGINFO_CERTREQID_ALG_DES40ID_ALG_NOSIGNATUREID_ALG_DH_SIG_HMAC_SHA1ID_ALG_DH_POPID_CMC_STATUSINFOID_CMC_IDENTITYPROOFID_CMC_DATARETURNID_CMC_TRANSACTIONIDID_CMC_SENDERNONCEID_CMC_RECIPIENTNONCEID_CMC_ADDEXTENSIONSID_CMC_ENCRYPTEDPOPID_CMC_DECRYPTEDPOPID_CMC_LRAPOPWITNESSID_CMC_GETCERTID_CMC_GETCRLID_CMC_REVOKEREQUESTID_CMC_REGINFOID_CMC_RESPONSEINFOID_CMC_QUERYPENDINGID_CMC_POPLINKRANDOMID_CMC_POPLINKWITNESSID_CMC_CONFIRMCERTACCEPTANCEID_ON_PERSONALDATAID_ON_PERMANENTIDENTIFIERID_PDA_DATEOFBIRTHID_PDA_PLACEOFBIRTHID_PDA_GENDERID_PDA_COUNTRYOFCITIZENSHIPID_PDA_COUNTRYOFRESIDENCEID_ACA_AUTHENTICATIONINFOID_ACA_ACCESSIDENTITYID_ACA_CHARGINGIDENTITYID_ACA_ROLEID_ACA_ENCATTRSID_QCS_PKIXQCSYNTAX_V1ID_CCT_CRSID_CCT_PKIDATAID_CCT_PKIRESPONSEID_PPL_ANYLANGUAGEID_PPL_INHERITALLINDEPENDENTAD_OCSPAD_CA_ISSUERSAD_TIMESTAMPINGAD_DVCSCAREPOSITORYID_PKIX_OCSP_CRLIDID_PKIX_OCSP_ACCEPTABLERESPONSESID_PKIX_OCSP_ARCHIVECUTOFFID_PKIX_OCSP_SERVICELOCATORID_PKIX_OCSP_EXTENDEDSTATUSID_PKIX_OCSP_VALIDID_PKIX_OCSP_PATHID_PKIX_OCSP_TRUSTROOTALGORITHMMD5WITHRSADES_ECBDES_CBCDES_OFB64DES_CFB64RSASIGNATUREDSA_2DSAWITHSHASHAWITHRSAENCRYPTIONDES_EDE_ECBDES_EDE3_ECBDES_EDE_CBCDES_EDE_CFB64DES_EDE3_CFB64DES_EDE_OFB64DES_EDE3_OFB64DESX_CBCSHASHA1DSAWITHSHA1_2SHA1WITHRSARIPEMD160RIPEMD160WITHRSASXNETX500COMMONNAMESERIALNUMBERCOUNTRYNAMELOCALITYNAMESTATEORPROVINCENAMESTREETADDRESSORGANIZATIONNAMEORGANIZATIONALUNITNAMESEARCHGUIDEBUSINESSCATEGORYPOSTALADDRESSPOSTALCODEPOSTOFFICEBOXPHYSICALDELIVERYOFFICENAMETELEPHONENUMBERTELEXNUMBERTELETEXTERMINALIDENTIFIERFACSIMILETELEPHONENUMBERX121ADDRESSINTERNATIONALISDNNUMBERREGISTEREDADDRESSDESTINATIONINDICATORPREFERREDDELIVERYMETHODPRESENTATIONADDRESSSUPPORTEDAPPLICATIONCONTEXTROLEOCCUPANTSEEALSOUSERPASSWORDUSERCERTIFICATECACERTIFICATEAUTHORITYREVOCATIONLISTCERTIFICATEREVOCATIONLISTCROSSCERTIFICATEPAIRGIVENNAMEGENERATIONQUALIFIERX500UNIQUEIDENTIFIERDNQUALIFIERENHANCEDSEARCHGUIDEPROTOCOLINFORMATIONDISTINGUISHEDNAMEUNIQUEMEMBERHOUSEIDENTIFIERSUPPORTEDALGORITHMSDELTAREVOCATIONLISTDMDNAMEROLEX500ALGORITHMSRSAMDC2WITHRSAMDC2SUBJECT_DIRECTORY_ATTRIBUTESSUBJECT_KEY_IDENTIFIERKEY_USAGEPRIVATE_KEY_USAGE_PERIODSUBJECT_ALT_NAMEISSUER_ALT_NAMEBASIC_CONSTRAINTSCRL_NUMBERCRL_REASONINVALIDITY_DATEISSUING_DISTRIBUTION_POINTCERTIFICATE_ISSUERNAME_CONSTRAINTSCRL_DISTRIBUTION_POINTSCERTIFICATE_POLICIESPOLICY_MAPPINGSAUTHORITY_KEY_IDENTIFIERPOLICY_CONSTRAINTSEXT_KEY_USAGEFRESHEST_CRLINHIBIT_ANY_POLICYTARGET_INFORMATIONNO_REV_AVAILANYEXTENDEDKEYUSAGENETSCAPENETSCAPE_CERT_EXTENSIONNETSCAPE_DATA_TYPENETSCAPE_CERT_TYPENETSCAPE_BASE_URLNETSCAPE_REVOCATION_URLNETSCAPE_CA_REVOCATION_URLNETSCAPE_RENEWAL_URLNETSCAPE_CA_POLICY_URLNETSCAPE_SSL_SERVER_NAMENETSCAPE_COMMENTNETSCAPE_CERT_SEQUENCENS_SGCORGDODIANAMANAGEMENTEXPERIMENTALSECURITYSNMPV2ENTERPRISESDCOBJECTMIME_MHSMIME_MHS_HEADINGSMIME_MHS_BODIESID_HEX_PARTIAL_MESSAGEID_HEX_MULTIPART_MESSAGEZLIB_COMPRESSIONAES_128_ECBAES_128_CBCAES_128_OFB128AES_128_CFB128ID_AES128_WRAPAES_128_GCMAES_128_CCMID_AES128_WRAP_PADAES_192_ECBAES_192_CBCAES_192_OFB128AES_192_CFB128ID_AES192_WRAPAES_192_GCMAES_192_CCMID_AES192_WRAP_PADAES_256_ECBAES_256_CBCAES_256_OFB128AES_256_CFB128ID_AES256_WRAPAES_256_GCMAES_256_CCMID_AES256_WRAP_PADAES_128_CFB1AES_192_CFB1AES_256_CFB1AES_128_CFB8AES_192_CFB8AES_256_CFB8AES_128_CTRAES_192_CTRAES_256_CTRAES_128_XTSAES_256_XTSDES_CFB1DES_CFB8DES_EDE3_CFB1DES_EDE3_CFB8SHA256SHA384SHA512SHA224DSA_WITH_SHA224DSA_WITH_SHA256HOLD_INSTRUCTION_CODEHOLD_INSTRUCTION_NONEHOLD_INSTRUCTION_CALL_ISSUERHOLD_INSTRUCTION_REJECTPSSUCLPILOTPILOTATTRIBUTETYPEPILOTATTRIBUTESYNTAXPILOTOBJECTCLASSPILOTGROUPSIA5STRINGSYNTAXCASEIGNOREIA5STRINGSYNTAXPILOTOBJECTPILOTPERSONDOCUMENTSERIESRFC822LOCALPARTDNSDOMAINDOMAINRELATEDOBJECTFRIENDLYCOUNTRYSIMPLESECURITYOBJECTPILOTORGANIZATIONPILOTDSAQUALITYLABELLEDDATAUSERIDTEXTENCODEDORADDRESSRFC822MAILBOXFAVOURITEDRINKROOMNUMBERUSERCLASSDOCUMENTIDENTIFIERDOCUMENTTITLEDOCUMENTVERSIONDOCUMENTAUTHORDOCUMENTLOCATIONHOMETELEPHONENUMBEROTHERMAILBOXLASTMODIFIEDTIMELASTMODIFIEDBYDOMAINCOMPONENTARECORDPILOTATTRIBUTETYPE27MXRECORDNSRECORDSOARECORDCNAMERECORDASSOCIATEDDOMAINASSOCIATEDNAMEHOMEPOSTALADDRESSPERSONALTITLEMOBILETELEPHONENUMBERPAGERTELEPHONENUMBERFRIENDLYCOUNTRYNAMEORGANIZATIONALSTATUSJANETMAILBOXMAILPREFERENCEOPTIONBUILDINGNAMEDSAQUALITYSINGLELEVELQUALITYSUBTREEMINIMUMQUALITYSUBTREEMAXIMUMQUALITYPERSONALSIGNATUREDITREDIRECTDOCUMENTPUBLISHERID_SETSET_CTYPESET_MSGEXTSET_ATTRSET_POLICYSET_CERTEXTSET_BRANDSETCT_PANDATASETCT_PANTOKENSETCT_PANONLYSETCT_OIDATASETCT_PISETCT_PIDATASETCT_PIDATAUNSIGNEDSETCT_HODINPUTSETCT_AUTHRESBAGGAGESETCT_AUTHREVREQBAGGAGESETCT_AUTHREVRESBAGGAGESETCT_CAPTOKENSEQSETCT_PINITRESDATASETCT_PI_TBSSETCT_PRESDATASETCT_AUTHREQTBSSETCT_AUTHRESTBSSETCT_AUTHRESTBSXSETCT_AUTHTOKENTBSSETCT_CAPTOKENDATASETCT_CAPTOKENTBSSETCT_ACQCARDCODEMSGSETCT_AUTHREVREQTBSSETCT_AUTHREVRESDATASETCT_AUTHREVRESTBSSETCT_CAPREQTBSSETCT_CAPREQTBSXSETCT_CAPRESDATASETCT_CAPREVREQTBSSETCT_CAPREVREQTBSXSETCT_CAPREVRESDATASETCT_CREDREQTBSSETCT_CREDREQTBSXSETCT_CREDRESDATASETCT_CREDREVREQTBSSETCT_CREDREVREQTBSXSETCT_CREDREVRESDATASETCT_PCERTREQDATASETCT_PCERTRESTBSSETCT_BATCHADMINREQDATASETCT_BATCHADMINRESDATASETCT_CARDCINITRESTBSSETCT_MEAQCINITRESTBSSETCT_REGFORMRESTBSSETCT_CERTREQDATASETCT_CERTREQTBSSETCT_CERTRESDATASETCT_CERTINQREQTBSSETCT_ERRORTBSSETCT_PIDUALSIGNEDTBESETCT_PIUNSIGNEDTBESETCT_AUTHREQTBESETCT_AUTHRESTBESETCT_AUTHRESTBEXSETCT_AUTHTOKENTBESETCT_CAPTOKENTBESETCT_CAPTOKENTBEXSETCT_ACQCARDCODEMSGTBESETCT_AUTHREVREQTBESETCT_AUTHREVRESTBESETCT_AUTHREVRESTBEBSETCT_CAPREQTBESETCT_CAPREQTBEXSETCT_CAPRESTBESETCT_CAPREVREQTBESETCT_CAPREVREQTBEXSETCT_CAPREVRESTBESETCT_CREDREQTBESETCT_CREDREQTBEXSETCT_CREDRESTBESETCT_CREDREVREQTBESETCT_CREDREVREQTBEXSETCT_CREDREVRESTBESETCT_BATCHADMINREQTBESETCT_BATCHADMINRESTBESETCT_REGFORMREQTBESETCT_CERTREQTBESETCT_CERTREQTBEXSETCT_CERTRESTBESETCT_CRLNOTIFICATIONTBSSETCT_CRLNOTIFICATIONRESTBSSETCT_BCIDISTRIBUTIONTBSSETEXT_GENCRYPTSETEXT_MIAUTHSETEXT_PINSECURESETEXT_PINANYSETEXT_TRACK2SETEXT_CVSET_POLICY_ROOTSETCEXT_HASHEDROOTSETCEXT_CERTTYPESETCEXT_MERCHDATASETCEXT_CCERTREQUIREDSETCEXT_TUNNELINGSETCEXT_SETEXTSETCEXT_SETQUALFSETCEXT_PGWYCAPABILITIESSETCEXT_TOKENIDENTIFIERSETCEXT_TRACK2DATASETCEXT_TOKENTYPESETCEXT_ISSUERCAPABILITIESSETATTR_CERTSETATTR_PGWYCAPSETATTR_TOKENTYPESETATTR_ISSCAPSET_ROOTKEYTHUMBSET_ADDPOLICYSETATTR_TOKEN_EMVSETATTR_TOKEN_B0PRIMESETATTR_ISSCAP_CVMSETATTR_ISSCAP_T2SETATTR_ISSCAP_SIGSETATTR_GENCRYPTGRMSETATTR_T2ENCSETATTR_T2CLEARTXTSETATTR_TOKICCSIGSETATTR_SECDEVSIGSET_BRAND_IATA_ATASET_BRAND_DINERSSET_BRAND_AMERICANEXPRESSSET_BRAND_JCBSET_BRAND_VISASET_BRAND_MASTERCARDSET_BRAND_NOVUSDES_CDMFRSAOAEPENCRYPTIONSETIPSEC3IPSEC4WHIRLPOOLCRYPTOPROCRYPTOCOMID_GOSTR3411_94_WITH_GOSTR3410_2001ID_GOSTR3411_94_WITH_GOSTR3410_94ID_GOSTR3411_94ID_HMACGOSTR3411_94ID_GOSTR3410_2001ID_GOSTR3410_94ID_GOST28147_89GOST89_CNTID_GOST28147_89_MACID_GOSTR3411_94_PRFID_GOSTR3410_2001DHID_GOSTR3410_94DHID_GOST28147_89_CRYPTOPRO_KEYMESHINGID_GOST28147_89_NONE_KEYMESHINGID_GOSTR3411_94_TESTPARAMSETID_GOSTR3411_94_CRYPTOPROPARAMSETID_GOST28147_89_TESTPARAMSETID_GOST28147_89_CRYPTOPRO_A_PARAMSETID_GOST28147_89_CRYPTOPRO_B_PARAMSETID_GOST28147_89_CRYPTOPRO_C_PARAMSETID_GOST28147_89_CRYPTOPRO_D_PARAMSETID_GOST28147_89_CRYPTOPRO_OSCAR_1_1_PARAMSETID_GOST28147_89_CRYPTOPRO_OSCAR_1_0_PARAMSETID_GOST28147_89_CRYPTOPRO_RIC_1_PARAMSETID_GOSTR3410_94_TESTPARAMSETID_GOSTR3410_94_CRYPTOPRO_A_PARAMSETID_GOSTR3410_94_CRYPTOPRO_B_PARAMSETID_GOSTR3410_94_CRYPTOPRO_C_PARAMSETID_GOSTR3410_94_CRYPTOPRO_D_PARAMSETID_GOSTR3410_94_CRYPTOPRO_XCHA_PARAMSETID_GOSTR3410_94_CRYPTOPRO_XCHB_PARAMSETID_GOSTR3410_94_CRYPTOPRO_XCHC_PARAMSETID_GOSTR3410_2001_TESTPARAMSETID_GOSTR3410_2001_CRYPTOPRO_A_PARAMSETID_GOSTR3410_2001_CRYPTOPRO_B_PARAMSETID_GOSTR3410_2001_CRYPTOPRO_C_PARAMSETID_GOSTR3410_2001_CRYPTOPRO_XCHA_PARAMSETID_GOSTR3410_2001_CRYPTOPRO_XCHB_PARAMSETID_GOSTR3410_94_AID_GOSTR3410_94_ABISID_GOSTR3410_94_BID_GOSTR3410_94_BBISID_GOST28147_89_CCID_GOSTR3410_94_CCID_GOSTR3410_2001_CCID_GOSTR3411_94_WITH_GOSTR3410_94_CCID_GOSTR3411_94_WITH_GOSTR3410_2001_CCID_GOSTR3410_2001_PARAMSET_CCCAMELLIA_128_CBCCAMELLIA_192_CBCCAMELLIA_256_CBCID_CAMELLIA128_WRAPID_CAMELLIA192_WRAPID_CAMELLIA256_WRAPCAMELLIA_128_ECBCAMELLIA_128_OFB128CAMELLIA_128_CFB128CAMELLIA_192_ECBCAMELLIA_192_OFB128CAMELLIA_192_CFB128CAMELLIA_256_ECBCAMELLIA_256_OFB128CAMELLIA_256_CFB128CAMELLIA_128_CFB1CAMELLIA_192_CFB1CAMELLIA_256_CFB1CAMELLIA_128_CFB8CAMELLIA_192_CFB8CAMELLIA_256_CFB8KISASEED_ECBSEED_CBCSEED_CFB128SEED_OFB128HMACCMACRC4_HMAC_MD5AES_128_CBC_HMAC_SHA1AES_192_CBC_HMAC_SHA1AES_256_CBC_HMAC_SHA1SM2SM3SHA3_224SHA3_256SHA3_384SHA3_512SHAKE128SHAKE256CHACHA20_POLY1305signature_digesttest_long_name_conversiontest_short_name_conversion//! A collection of numerical identifiers for OpenSSL objects.OcspFlagNO_CERTSNO_INTERNNO_CHAINNO_VERIFYNO_EXPLICITNO_CA_SIGNNO_DELEGATEDNO_CHECKSTRUST_OTHERRESPID_KEYNO_TIMEOcspResponseStatusSUCCESSFULMALFORMED_REQUESTINTERNAL_ERRORTRY_LATERSIG_REQUIREDOcspCertStatusGOODOcspRevokedStatusNO_STATUSKEY_COMPROMISECA_COMPROMISEAFFILIATION_CHANGEDSTATUS_SUPERSEDEDSTATUS_CESSATION_OF_OPERATIONSTATUS_CERTIFICATE_HOLDREMOVE_FROM_CRL/// The overall status of the response./// If `status` is `CERT_STATUS_REVOKED`, the reason for the revocation.revocation_time/// If `status` is `CERT_STATUS_REVOKED`, the time at which the certificate was revoked.this_update/// The time that this revocation check was performed./// The time at which this revocation check expires.OcspStatus" Checks validity of the `this_update` and `next_update` fields."" The `nsec` parameter specifies an amount of slack time that will be used when comparing"" those times with the current time to account for delays and clock skew."" The `maxsec` parameter limits the maximum age of the `this_update` parameter to prohibit"" very old responses.""This corresponds to [`OCSP_check_validity`](https://www.openssl.org/docs/manmaster/man3/OCSP_check_validity.html)."OCSP_BASICRESPOcspBasicResponseOcspBasicResponseRef" Verifies the validity of the response."" The `certs` parameter contains a set of certificates that will be searched when locating the"" OCSP response signing certificate. Some responders do not include this in the response.""This corresponds to [`OCSP_basic_verify`](https://www.openssl.org/docs/manmaster/man3/OCSP_basic_verify.html)."" Looks up the status for the specified certificate ID.""This corresponds to [`OCSP_resp_find_status`](https://www.openssl.org/docs/manmaster/man3/OCSP_resp_find_status.html)."find_statusOcspCertIdRefOCSP_CERTIDOcspCertId" Constructs a certificate ID for certificate `subject`.""This corresponds to [`OCSP_cert_to_id`](https://www.openssl.org/docs/manmaster/man3/OCSP_cert_to_id.html)."from_certOCSP_RESPONSEOcspResponseOcspResponseRef" Creates an OCSP response from the status and optional body."" A body should only be provided if `status` is `RESPONSE_STATUS_SUCCESSFUL`.""This corresponds to [`OCSP_response_create`](https://www.openssl.org/docs/manmaster/man3/OCSP_response_create.html)."r" Deserializes a DER-encoded OCSP response.""This corresponds to [`d2i_OCSP_RESPONSE`](https://www.openssl.org/docs/manmaster/man3/d2i_OCSP_RESPONSE.html)."r" Serializes the response to its standard DER encoding.""This corresponds to [`i2d_OCSP_RESPONSE`](https://www.openssl.org/docs/manmaster/man3/i2d_OCSP_RESPONSE.html)."" Returns the status of the response.""This corresponds to [`OCSP_response_status`](https://www.openssl.org/docs/manmaster/man3/OCSP_response_status.html)."" Returns the basic response."" This will only succeed if `status()` returns `RESPONSE_STATUS_SUCCESSFUL`.""This corresponds to [`OCSP_response_get1_basic`](https://www.openssl.org/docs/manmaster/man3/OCSP_response_get1_basic.html)."OCSP_REQUESTOcspRequestOcspRequestRef"This corresponds to [`OCSP_REQUEST_new`](https://www.openssl.org/docs/manmaster/man3/OCSP_REQUEST_new.html)."r" Deserializes a DER-encoded OCSP request.""This corresponds to [`d2i_OCSP_REQUEST`](https://www.openssl.org/docs/manmaster/man3/d2i_OCSP_REQUEST.html)."r" Serializes the request to its standard DER encoding.""This corresponds to [`i2d_OCSP_REQUEST`](https://www.openssl.org/docs/manmaster/man3/i2d_OCSP_REQUEST.html).""This corresponds to [`OCSP_request_add0_id`](https://www.openssl.org/docs/manmaster/man3/OCSP_request_add0_id.html)."OcspOneReqRefOCSP_ONEREQOcspOneReqForeignTypeExtPKCS12Pkcs12Refr" Serializes the `Pkcs12` to its standard DER encoding.""This corresponds to [`i2d_PKCS12`](https://www.openssl.org/docs/manmaster/man3/i2d_PKCS12.html)."ParsedPkcs12/// Deprecated." Extracts the contents of the `Pkcs12`.""This corresponds to [`PKCS12_parse`](https://www.openssl.org/docs/manmaster/man3/PKCS12_parse.html)."ParsedPkcs12_2r" Deserializes a DER-encoded PKCS#12 archive.""This corresponds to [`d2i_PKCS12`](https://www.openssl.org/docs/manmaster/man3/d2i_PKCS12.html)."Pkcs12Builder/// Creates a new builder for a protected pkcs12 certificate./// This uses the defaults from the OpenSSL library:/// * `nid_key` - `AES_256_CBC` (3.0.0+) or `PBE_WITHSHA1AND3_KEY_TRIPLEDES_CBC`/// * `nid_cert` - `AES_256_CBC` (3.0.0+) or `PBE_WITHSHA1AND40BITRC2_CBC`/// * `iter` - `2048`/// * `mac_iter` - `2048`/// * `mac_md` - `SHA-256` (3.0.0+) or `SHA-1` (`SHA-1` only for BoringSSL)ca// FIXME borrownid_keynid_certmac_itermac_md// FIXME remove/// The `friendlyName` used for the certificate and private key./// The private key./// The certificate./// An additional set of certificates to include in the archive beyond the one provided to/// `build`.key_algorithm/// The encryption algorithm that should be used for the keycert_algorithm/// The encryption algorithm that should be used for the certkey_iter/// Key iteration count, default is 2048 as of this writing/// MAC iteration count, default is the same as key_iter./// Old implementations don't understand MAC iterations greater than 1, (pre 1.0.1?), if such/// compatibility is required this should be set to 1./// MAC message digest type" Builds the PKCS#12 object.""This corresponds to [`PKCS12_create`](https://www.openssl.org/docs/manmaster/man3/PKCS12_create.html)."build2KeyUsageX509Nameparse_empty_chaincreate_only_ca//! PKCS #12 archives.KeyIvPair" Derives a key and an IV from various parameters."" If specified, `salt` must be 8 bytes in length."" If the total key and IV length is less than 16 bytes and MD5 is used then"" the algorithm is compatible with the key derivation algorithm from PKCS#5"" v1.5 or PBKDF1 from PKCS#5 v2.0."" New applications should not use this and instead use"" `pbkdf2_hmac` or another more modern key derivation algorithm.""This corresponds to [`EVP_BytesToKey`](https://www.openssl.org/docs/manmaster/man3/EVP_BytesToKey.html)."bytes_to_key" Derives a key from a password and salt using the PBKDF2-HMAC algorithm with a digest function.""This corresponds to [`PKCS5_PBKDF2_HMAC`](https://www.openssl.org/docs/manmaster/man3/PKCS5_PBKDF2_HMAC.html)."pbkdf2_hmac" Derives a key from a password and salt using the scrypt algorithm."" Requires OpenSSL 1.1.0 or newer.""This corresponds to [`EVP_PBE_scrypt`](https://www.openssl.org/docs/manmaster/man3/EVP_PBE_scrypt.html)."scryptpbkdf2_hmac_sha256// Test vectors from// https://git.lysator.liu.se/nettle/nettle/blob/nettle_3.1.1_release_20150424/testsuite/pbkdf2-test.cpbkdf2_hmac_sha512PKCS7_SIGNER_INFOPkcs7SignerInfoPkcs7SignerInfoRefstack_st_PKCS7_SIGNER_INFOr" A PKCS#7 structure."r" Contains signed and/or encrypted data."Pkcs7Refr" Reference to `Pkcs7`"r" A PKCS#7 signed data structure."r" Contains signed data."Pkcs7SignedPkcs7SignedRefr" Reference to `Pkcs7Signed`"Pkcs7FlagsNOCERTSNOCHAINr" Deserializes a PEM-encoded PKCS#7 signature"r" The input should have a header of `-----BEGIN PKCS7-----`.""This corresponds to [`PEM_read_bio_PKCS7`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_PKCS7.html)."r" Deserializes a DER-encoded PKCS#7 signature""This corresponds to [`d2i_PKCS7`](https://www.openssl.org/docs/manmaster/man3/d2i_PKCS7.html)."" Parses a message in S/MIME format."" Returns the loaded signature, along with the cleartext message (if"" available).""This corresponds to [`SMIME_read_PKCS7`](https://www.openssl.org/docs/manmaster/man3/SMIME_read_PKCS7.html)."from_smime" Creates and returns a PKCS#7 `envelopedData` structure."" `certs` is a list of recipient certificates. `input` is the content to be"" encrypted. `cipher` is the symmetric cipher to use. `flags` is an optional"" set of flags.""This corresponds to [`PKCS7_encrypt`](https://www.openssl.org/docs/manmaster/man3/PKCS7_encrypt.html)."" Creates and returns a PKCS#7 `signedData` structure."" `signcert` is the certificate to sign with, `pkey` is the corresponding"" private key. `certs` is an optional additional set of certificates to"" include in the PKCS#7 structure (for example any intermediate CAs in the"" chain).""This corresponds to [`PKCS7_sign`](https://www.openssl.org/docs/manmaster/man3/PKCS7_sign.html)."" Converts PKCS#7 structure to S/MIME format""This corresponds to [`SMIME_write_PKCS7`](https://www.openssl.org/docs/manmaster/man3/SMIME_write_PKCS7.html)."to_smimer" Serializes the data into a PEM-encoded PKCS#7 structure."r" The output will have a header of `-----BEGIN PKCS7-----`.""This corresponds to [`PEM_write_bio_PKCS7`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_PKCS7.html)."r" Serializes the data into a DER-encoded PKCS#7 structure.""This corresponds to [`i2d_PKCS7`](https://www.openssl.org/docs/manmaster/man3/i2d_PKCS7.html)."" Decrypts data using the provided private key."" `pkey` is the recipient\'s private key, and `cert` is the recipient\'s"" certificate."" Returns the decrypted message.""This corresponds to [`PKCS7_decrypt`](https://www.openssl.org/docs/manmaster/man3/PKCS7_decrypt.html)."" Verifies the PKCS#7 `signedData` structure contained by `&self`."" `certs` is a set of certificates in which to search for the signer\'s"" certificate. `store` is a trusted certificate store (used for chain"" verification). `indata` is the signed data if the content is not present"" in `&self`. The content is written to `out` if it is not `None`.""This corresponds to [`PKCS7_verify`](https://www.openssl.org/docs/manmaster/man3/PKCS7_verify.html)."" Retrieve the signer\'s certificates from the PKCS#7 structure without verifying them.""This corresponds to [`PKCS7_get0_signers`](https://www.openssl.org/docs/manmaster/man3/PKCS7_get0_signers.html)."signers/// Return the type of a PKCS#7 structure as an Asn1Object/// Get the signed data of a PKCS#7 structure of type PKCS7_SIGNED/// Get the stack of certificates from the PKCS7_SIGNED objectencrypt_decrypt_testsign_verify_test_detachedsign_verify_test_normal/// https://marc.info/?l=openbsd-cvs&m=166602943014106&w=2invalid_from_smimesigned_data_certificatessigned_data_certificates_no_signed_dataPkeyCtxinvoke_passwd_cbCallbackState/// A tag type indicating that a key only has parameters./// A tag type indicating that a key only has public components./// A tag type indicating that a key has private components./// An identifier of a kind of key.RSA_PSSDHXECHKDFED25519ED448X448POLY1305/// Creates a `Id` from an integer representation./// Returns the integer representation of the `Id`./// A trait indicating that a key has parameters./// A trait indicating that a key has public components./// A trait indicating that a key has private components.r" A public or private key."EVP_PKEYr" Reference to `PKey`."" Returns a copy of the internal RSA key.""This corresponds to [`EVP_PKEY_get1_RSA`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_get1_RSA.html)."" Returns a copy of the internal DSA key.""This corresponds to [`EVP_PKEY_get1_DSA`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_get1_DSA.html)."" Returns a copy of the internal DH key.""This corresponds to [`EVP_PKEY_get1_DH`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_get1_DH.html)."" Returns a copy of the internal elliptic curve key.""This corresponds to [`EVP_PKEY_get1_EC_KEY`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_get1_EC_KEY.html)."ec_key" Returns the `Id` that represents the type of this key.""This corresponds to [`EVP_PKEY_id`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_id.html)."" Returns the maximum size of a signature in bytes.""This corresponds to [`EVP_PKEY_size`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_size.html).""This corresponds to [`PEM_write_bio_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_PUBKEY.html).""This corresponds to [`i2d_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/i2d_PUBKEY.html)."" Returns the size of the key."" This corresponds to the bit length of the modulus of an RSA key, and the bit length of the"" group order for an elliptic curve key, for example.""This corresponds to [`EVP_PKEY_bits`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_bits.html).""Returns the number of security bits.""Bits of security is defined in NIST SP800-57.""This corresponds to [`EVP_PKEY_security_bits`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_security_bits.html)."security_bits" Compares the public component of this key with another.""This corresponds to [`EVP_PKEY_cmp`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_cmp.html)."public_eq" Raw byte representation of a public key."" This function only works for algorithms that support raw public keys."" Currently this is: [`Id::X25519`], [`Id::ED25519`], [`Id::X448`] or [`Id::ED448`].""This corresponds to [`EVP_PKEY_get_raw_public_key`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_get_raw_public_key.html)."raw_public_keyr" Serializes the private key to a PEM-encoded PKCS#8 PrivateKeyInfo structure."r" The output will have a header of `-----BEGIN PRIVATE KEY-----`.""This corresponds to [`PEM_write_bio_PKCS8PrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_PKCS8PrivateKey.html)."private_key_to_pem_pkcs8r" Serializes the private key to a PEM-encoded PKCS#8 EncryptedPrivateKeyInfo structure."r" The output will have a header of `-----BEGIN ENCRYPTED PRIVATE KEY-----`."private_key_to_pem_pkcs8_passphraser" Serializes the private key to a DER-encoded key type specific format.""This corresponds to [`i2d_PrivateKey`](https://www.openssl.org/docs/manmaster/man3/i2d_PrivateKey.html)."" Raw byte representation of a private key."" This function only works for algorithms that support raw private keys."" Currently this is: [`Id::HMAC`], [`Id::X25519`], [`Id::ED25519`], [`Id::X448`] or [`Id::ED448`].""This corresponds to [`EVP_PKEY_get_raw_private_key`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_get_raw_private_key.html)."raw_private_key" Serializes a private key into an unencrypted DER-formatted PKCS#8""This corresponds to [`i2d_PKCS8PrivateKey_bio`](https://www.openssl.org/docs/manmaster/man3/i2d_PKCS8PrivateKey_bio.html)."private_key_to_pkcs8" Serializes a private key into a DER-formatted PKCS#8, using the supplied password to"" encrypt the key."private_key_to_pkcs8_passphrase" Creates a new `PKey` containing an RSA key.""This corresponds to [`EVP_PKEY_set1_RSA`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_set1_RSA.html)."from_rsa" Creates a new `PKey` containing a DSA key.""This corresponds to [`EVP_PKEY_set1_DSA`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_set1_DSA.html)."from_dsa" Creates a new `PKey` containing a Diffie-Hellman key.""This corresponds to [`EVP_PKEY_set1_DH`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_set1_DH.html)."from_dhfrom_dhx/// Creates a new `PKey` containing a Diffie-Hellman key with type DHX." Creates a new `PKey` containing an elliptic curve key.""This corresponds to [`EVP_PKEY_set1_EC_KEY`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_set1_EC_KEY.html)."from_ec_key" Creates a new `PKey` containing an HMAC key."" To compute HMAC values, use the `sign` module.""This corresponds to [`EVP_PKEY_new_mac_key`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_new_mac_key.html)."cmac/// Creates a new `PKey` containing a CMAC key./// To compute CMAC values, use the `sign` module.generate_eddsagenerate_x25519/// Generates a new private X25519 key./// To import a private key from raw bytes see [`PKey::private_key_from_raw_bytes`]./// use openssl::pkey::{PKey, Id};/// use openssl::derive::Deriver;/// let public = // .../// # &PKey::generate_x25519()?.raw_public_key()?;/// let public_key = PKey::public_key_from_raw_bytes(public, Id::X25519)?;/// let key = PKey::generate_x25519()?;/// let mut deriver = Deriver::new(&key)?;/// deriver.set_peer(&public_key)?;/// let secret = deriver.derive_to_vec()?;/// assert_eq!(secret.len(), 32);generate_x448/// Generates a new private X448 key./// # &PKey::generate_x448()?.raw_public_key()?;/// let public_key = PKey::public_key_from_raw_bytes(public, Id::X448)?;/// let key = PKey::generate_x448()?;/// assert_eq!(secret.len(), 56);generate_ed25519/// Generates a new private Ed25519 key./// use openssl::sign::Signer;/// let key = PKey::generate_ed25519()?;/// let public_key = key.raw_public_key()?;/// let mut signer = Signer::new_without_digest(&key)?;/// let digest = // .../// # &vec![0; 32];/// let signature = signer.sign_oneshot_to_vec(digest)?;/// assert_eq!(signature.len(), 64);generate_ed448/// Generates a new private Ed448 key./// let key = PKey::generate_ed448()?;/// assert_eq!(signature.len(), 114);" Generates a new EC key using the provided curve.""This corresponds to [`EVP_EC_gen`](https://www.openssl.org/docs/manmaster/man3/EVP_EC_gen.html)."ec_genr" Deserializes a private key from a PEM-encoded key type specific format.""This corresponds to [`PEM_read_bio_PrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_PrivateKey.html)."r" Deserializes a private key from a PEM-encoded encrypted key type specific format."r" Decodes a DER-encoded private key."r" This function will attempt to automatically detect the underlying key format, and"r" supports the unencrypted PKCS#8 PrivateKeyInfo structures as well as key type specific"r" formats.""This corresponds to [`d2i_AutoPrivateKey`](https://www.openssl.org/docs/manmaster/man3/d2i_AutoPrivateKey.html)."private_key_from_pkcs8/// Deserializes a DER-formatted PKCS#8 unencrypted private key./// This method is mainly for interoperability reasons. Encrypted keyfiles should be preferred." Deserializes a DER-formatted PKCS#8 private key, using a callback to retrieve the password"" if the key is encrypted."" The callback should copy the password into the provided buffer and return the number of"" bytes written.""This corresponds to [`d2i_PKCS8PrivateKey_bio`](https://www.openssl.org/docs/manmaster/man3/d2i_PKCS8PrivateKey_bio.html)."private_key_from_pkcs8_callback" Deserializes a DER-formatted PKCS#8 private key, using the supplied password if the key is"" encrypted."" Panics if `passphrase` contains an embedded null."private_key_from_pkcs8_passphrase" Creates a private key from its raw byte representation"" Algorithm types that support raw private keys are HMAC, X25519, ED25519, X448 or ED448""This corresponds to [`EVP_PKEY_new_raw_private_key`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_new_raw_private_key.html)."private_key_from_raw_bytesr" Decodes a PEM-encoded SubjectPublicKeyInfo structure.""This corresponds to [`PEM_read_bio_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_PUBKEY.html)."public_key_from_pem_passphrasepublic_key_from_pem_callbackr" Decodes a DER-encoded SubjectPublicKeyInfo structure.""This corresponds to [`d2i_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/d2i_PUBKEY.html)."" Creates a public key from its raw byte representation"" Algorithm types that support raw public keys are X25519, ED25519, X448 or ED448""This corresponds to [`EVP_PKEY_new_raw_public_key`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_new_raw_public_key.html)."public_key_from_raw_bytesEVP_PKEY_up_reftest_to_passwordtest_unencrypted_pkcs8test_encrypted_pkcs8_passphrasetest_encrypted_pkcs8_callbacktest_private_key_from_pemtest_public_key_from_pemtest_public_key_from_dertest_private_key_from_dertest_pemtest_rsa_accessortest_dsa_accessortest_dh_accessortest_ec_key_accessortest_rsa_conversiontest_dsa_conversiontest_ec_key_conversiontest_security_bitstest_dh_conversiontest_raw_public_keytest_raw_private_keytest_raw_public_key_bytestest_raw_private_key_bytestest_raw_hmactest_raw_key_failtest_ec_gentest_public_eq//! Public/private key processing.//! Asymmetric public key algorithms solve the problem of establishing and sharing//! secret keys to securely send and receive messages.//! This system uses a pair of keys: a public key, which can be freely//! distributed, and a private key, which is kept to oneself. An entity may//! encrypt information using a user's public key. The encrypted information can//! only be deciphered using that user's private key.//! This module offers support for five popular algorithms://! * RSA//! * DSA//! * Diffie-Hellman//! * Elliptic Curves//! * HMAC//! These algorithms rely on hard mathematical problems - namely integer factorization,//! discrete logarithms, and elliptic curve relationships - that currently do not//! yield efficient solutions. This property ensures the security of these//! cryptographic algorithms.//! Generate a 2048-bit RSA public/private key pair and print the public key.//! let pkey = PKey::from_rsa(rsa).unwrap();//! let pub_key: Vec<u8> = pkey.public_key_to_pem().unwrap();//! println!("{:?}", str::from_utf8(pub_key.as_slice()).unwrap());RsaPssSaltlenHkdfMode/// HKDF modes of operation.EXTRACT_THEN_EXPAND/// This is the default mode. Calling [`derive`][PkeyCtxRef::derive] on a [`PkeyCtxRef`] set up/// for HKDF will perform an extract followed by an expand operation in one go. The derived key/// returned will be the result after the expand operation. The intermediate fixed-length/// pseudorandom key K is not returned.EXTRACT_ONLY/// In this mode calling [`derive`][PkeyCtxRef::derive] will just perform the extract operation./// The value returned will be the intermediate fixed-length pseudorandom key K./// The digest, key and salt values must be set before a key is derived or an error occurs.EXPAND_ONLY/// In this mode calling [`derive`][PkeyCtxRef::derive] will just perform the expand operation./// The input key should be set to the intermediate fixed-length pseudorandom key K returned/// from a previous extract operation./// The digest, key and info values must be set before a key is derived or an error occurs.NonceType/// Nonce type for ECDSA and DSA.RANDOM_K/// This is the default mode. It uses a random value for the nonce k as defined in FIPS 186-4 Section 6.3/// “Secret Number Generation”.DETERMINISTIC_K/// Uses a deterministic value for the nonce k as defined in RFC #6979 (See Section 3.2 “Generation of k”).r" A context object which can perform asymmetric cryptography operations."r" A reference to a [`PkeyCtx`]."" Creates a new pkey context using the provided key.""This corresponds to [`EVP_PKEY_CTX_new`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_new.html)."" Creates a new pkey context for the specified algorithm ID.""This corresponds to [`EVP_PKEY_new_id`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_new_id.html)."new_id" Prepares the context for encryption using the public key.""This corresponds to [`EVP_PKEY_encrypt_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_encrypt_init.html)."" Prepares the context for signature verification using the public key.""This corresponds to [`EVP_PKEY_verify_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_verify_init.html)."verify_init" Prepares the context for signature recovery using the public key.""This corresponds to [`EVP_PKEY_verify_recover_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_verify_recover_init.html)."verify_recover_init" Encrypts data using the public key.""This corresponds to [`EVP_PKEY_encrypt`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_encrypt.html)."encrypt_to_vec/// Like [`Self::encrypt`] but appends ciphertext to a [`Vec`]." Verifies the signature of data using the public key."" This verifies the signature of the *raw* data. It is more common to compute and verify the signature of the"" cryptographic hash of an arbitrary amount of data. The [`MdCtx`](crate::md_ctx::MdCtx) type can be used to do"" that.""This corresponds to [`EVP_PKEY_verify`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_verify.html)."" Recovers the original data signed by the private key. You almost"" always want `verify` instead."" Returns the number of bytes written to `to`, or the number of bytes"" that would be written, if `to` is `None.""This corresponds to [`EVP_PKEY_verify_recover`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_verify_recover.html)."verify_recover" Prepares the context for decryption using the private key.""This corresponds to [`EVP_PKEY_decrypt_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_decrypt_init.html)."" Prepares the context for signing using the private key.""This corresponds to [`EVP_PKEY_sign_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_sign_init.html)."sign_initderive_set_peer" Decrypts data using the private key.""This corresponds to [`EVP_PKEY_decrypt`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_decrypt.html)."decrypt_to_vec/// Like [`Self::decrypt`] but appends plaintext to a [`Vec`]." Signs the contents of `data`."" If `sig` is set to `None`, an upper bound on the number of bytes required for the output buffer will be"" This computes the signature of the *raw* bytes of `data`. It is more common to sign the cryptographic hash of"" an arbitrary amount of data. The [`MdCtx`](crate::md_ctx::MdCtx) type can be used to do that.""This corresponds to [`EVP_PKEY_sign`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_sign.html)."sign_to_vec/// Like [`Self::sign`] but appends the signature to a [`Vec`]." Prepares the context for shared secret derivation.""This corresponds to [`EVP_PKEY_derive_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_derive_init.html)."derive_init" Prepares the context for key generation.""This corresponds to [`EVP_PKEY_keygen_init`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_keygen_init.html)."keygen_init" Sets which algorithm was used to compute the digest used in a"" signature. With RSA signatures this causes the signature to be wrapped"" in a `DigestInfo` structure. This is almost always what you want with"" RSA signatures.""This corresponds to [`EVP_PKEY_CTX_set_signature_md`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_signature_md.html)."set_signature_md" Returns the RSA padding mode in use."" This is only useful for RSA keys.""This corresponds to [`EVP_PKEY_CTX_get_rsa_padding`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_get_rsa_padding.html)."" Sets the RSA padding mode.""This corresponds to [`EVP_PKEY_CTX_set_rsa_padding`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_rsa_padding.html)."" Sets the RSA PSS salt length.""This corresponds to [`EVP_PKEY_CTX_set_rsa_pss_saltlen`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_rsa_pss_saltlen.html)."set_rsa_pss_saltlen" Sets the RSA MGF1 algorithm.""This corresponds to [`EVP_PKEY_CTX_set_rsa_mgf1_md`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_rsa_mgf1_md.html)."" Sets the RSA OAEP algorithm.""This corresponds to [`EVP_PKEY_CTX_set_rsa_oaep_md`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_rsa_oaep_md.html)."" Sets the RSA OAEP label.""This corresponds to [`EVP_PKEY_CTX_set0_rsa_oaep_label`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set0_rsa_oaep_label.html)."" Sets the cipher used during key generation.""This corresponds to [`EVP_PKEY_CTX_ctrl`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_ctrl.html)."set_keygen_cipher" Sets the key MAC key used during key generation."set_keygen_mac_key" Sets the digest used for HKDF derivation.""This corresponds to [`EVP_PKEY_CTX_set_hkdf_md`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_hkdf_md.html)."set_hkdf_md" Sets the HKDF mode of operation."" Defaults to [`HkdfMode::EXTRACT_THEN_EXPAND`]."" WARNING: Although this API calls it a \"mode\", HKDF-Extract and HKDF-Expand are distinct"" operations with distinct inputs and distinct kinds of keys. Callers should not pass input"" secrets for one operation into the other.""This corresponds to [`EVP_PKEY_CTX_set_hkdf_mode`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_hkdf_mode.html)."set_hkdf_mode" Sets the input material for HKDF generation as the \"key\"."" Which input is the key depends on the \"mode\" (see [`set_hkdf_mode`][Self::set_hkdf_mode])."" If [`HkdfMode::EXTRACT_THEN_EXPAND`] or [`HkdfMode::EXTRACT_ONLY`], this function specifies"" the input keying material (IKM) for HKDF-Extract. If [`HkdfMode::EXPAND_ONLY`], it instead"" specifies the pseudorandom key (PRK) for HKDF-Expand.""This corresponds to [`EVP_PKEY_CTX_set1_hkdf_key`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set1_hkdf_key.html)."set_hkdf_key" Sets the salt value for HKDF generation."" If performing HKDF-Expand only, this parameter is ignored.""This corresponds to [`EVP_PKEY_CTX_set1_hkdf_salt`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set1_hkdf_salt.html)."set_hkdf_salt" Appends info bytes for HKDF generation."" If performing HKDF-Extract only, this parameter is ignored.""This corresponds to [`EVP_PKEY_CTX_add1_hkdf_info`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_add1_hkdf_info.html)."add_hkdf_info" Derives a shared secret between two keys."" If `buf` is set to `None`, an upper bound on the number of bytes required for the buffer will be returned.""This corresponds to [`EVP_PKEY_derive`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_derive.html)."/// Like [`Self::derive`] but appends the secret to a [`Vec`]." Generates a new public/private keypair.""This corresponds to [`EVP_PKEY_keygen`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_keygen.html)."keygen" Sets the nonce type for a private key context."" The nonce for DSA and ECDSA can be either random (the default) or deterministic (as defined by RFC 6979)."" This is only useful for DSA and ECDSA."" Requires OpenSSL 3.2.0 or newer.""This corresponds to [`EVP_PKEY_CTX_set_params`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_set_params.html)."set_nonce_type" Gets the nonce type for a private key context.""This corresponds to [`EVP_PKEY_CTX_get_params`](https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_CTX_get_params.html)."nonce_typersa_oaeprsa_signrsa_sign_psscmac_keygenhkdf_expandhkdf_extractverify_fail_ectest_verify_recoverecdsa_deterministic_signature// Test vector from// https://github.com/openssl/openssl/blob/openssl-3.2.0/test/recipes/30-test_evp_data/evppkey_ecdsa_rfc6979.txt//! The asymmetric encryption context.//! Encrypt data with RSA//! use openssl::pkey_ctx::PkeyCtx;//! let mut ctx = PkeyCtx::new(&key).unwrap();//! ctx.encrypt_init().unwrap();//! ctx.encrypt_to_vec(data, &mut ciphertext).unwrap();//! Sign and verify data with RSA//! ctx.sign_init().unwrap();//! ctx.sign_to_vec(text, &mut signature).unwrap();//! ctx.verify_init().unwrap();//! let valid = ctx.verify(text, &signature).unwrap();OSSL_PROVIDERProviderProviderRefr" A reference to a [`Provider`]."ossl_provider_free" Loads a new provider into the specified library context, disabling the fallback providers."" If `ctx` is `None`, the provider will be loaded in to the default library context.""This corresponds to [`OSSL_provider_load`](https://www.openssl.org/docs/manmaster/man3/OSSL_provider_load.html)."" Loads a new provider into the specified library context, disabling the fallback providers if `retain_fallbacks`"" is `false` and the load succeeds."" If `ctx` is `None`, the provider will be loaded into the default library context.""This corresponds to [`OSSL_provider_try_load`](https://www.openssl.org/docs/manmaster/man3/OSSL_provider_try_load.html)."try_load" Specifies the default search path that is to be used for looking for providers in the specified library context."" If left unspecified, an environment variable and a fall back default value will be used instead""This corresponds to [`OSSL_PROVIDER_set_default_search_path`](https://www.openssl.org/docs/manmaster/man3/OSSL_PROVIDER_set_default_search_path.html)."set_default_search_path" Fill buffer with cryptographically strong pseudo-random bytes."" To generate a buffer with cryptographically strong random bytes:"" use openssl::rand::rand_bytes;"" let mut buf = [0; 256];"" rand_bytes(&mut buf).unwrap();""This corresponds to [`RAND_bytes`](https://www.openssl.org/docs/manmaster/man3/RAND_bytes.html)."" Fill buffer with cryptographically strong pseudo-random bytes. It is"" intended to be used for generating values that should remain private."" use openssl::rand::rand_priv_bytes;"" rand_priv_bytes(&mut buf).unwrap();""This corresponds to [`RAND_priv_bytes`](https://www.openssl.org/docs/manmaster/man3/RAND_priv_bytes.html)."rand_priv_bytes" Controls random device file descriptor behavior.""This corresponds to [`RAND_keep_random_devices_open`](https://www.openssl.org/docs/manmaster/man3/RAND_keep_random_devices_open.html)."keep_random_devices_opentest_rand_bytestest_rand_priv_bytes//! Utilities for secure random number generation.//! To generate a buffer with cryptographically strong bytes://! use openssl::rand::rand_bytes;//! let mut buf = [0; 256];//! rand_bytes(&mut buf).unwrap();/// Type of encryption padding to use./// Random length padding is primarily used to prevent attackers from/// predicting or knowing the exact length of a plaintext message that/// can possibly lead to breaking encryption.PKCS1_OAEPPKCS1_PSS/// Creates a `Padding` from an integer representation./// Returns the integer representation of `Padding`.r" An RSA key."RsaRefr" Reference to `RSA`"r" Serializes the private key to a PEM-encoded PKCS#1 RSAPrivateKey structure."r" The output will have a header of `-----BEGIN RSA PRIVATE KEY-----`.""This corresponds to [`PEM_write_bio_RSAPrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_RSAPrivateKey.html)."r" Serializes the private key to a PEM-encoded encrypted PKCS#1 RSAPrivateKey structure."r" Serializes the private key to a DER-encoded PKCS#1 RSAPrivateKey structure.""This corresponds to [`i2d_RSAPrivateKey`](https://www.openssl.org/docs/manmaster/man3/i2d_RSAPrivateKey.html)."" Decrypts data using the private key, returning the number of decrypted bytes."" Panics if `self` has no private components, or if `to` is smaller"" than `self.size()`.""This corresponds to [`RSA_private_decrypt`](https://www.openssl.org/docs/manmaster/man3/RSA_private_decrypt.html)."private_decrypt" Encrypts data using the private key, returning the number of encrypted bytes.""This corresponds to [`RSA_private_encrypt`](https://www.openssl.org/docs/manmaster/man3/RSA_private_encrypt.html)."private_encrypt" Returns a reference to the private exponent of the key.""This corresponds to [`RSA_get0_key`](https://www.openssl.org/docs/manmaster/man3/RSA_get0_key.html)."" Returns a reference to the first factor of the exponent of the key.""This corresponds to [`RSA_get0_factors`](https://www.openssl.org/docs/manmaster/man3/RSA_get0_factors.html)."" Returns a reference to the second factor of the exponent of the key."" Returns a reference to the first exponent used for CRT calculations.""This corresponds to [`RSA_get0_crt_params`](https://www.openssl.org/docs/manmaster/man3/RSA_get0_crt_params.html)."dmp1" Returns a reference to the second exponent used for CRT calculations."dmq1" Returns a reference to the coefficient used for CRT calculations."iqmp" Validates RSA parameters for correctness""This corresponds to [`RSA_check_key`](https://www.openssl.org/docs/manmaster/man3/RSA_check_key.html).""This corresponds to [`PEM_write_bio_RSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_RSA_PUBKEY.html).""This corresponds to [`i2d_RSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/i2d_RSA_PUBKEY.html)."r" Serializes the public key into a PEM-encoded PKCS#1 RSAPublicKey structure."r" The output will have a header of `-----BEGIN RSA PUBLIC KEY-----`.""This corresponds to [`PEM_write_bio_RSAPublicKey`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_RSAPublicKey.html)."public_key_to_pem_pkcs1r" Serializes the public key into a DER-encoded PKCS#1 RSAPublicKey structure.""This corresponds to [`i2d_RSAPublicKey`](https://www.openssl.org/docs/manmaster/man3/i2d_RSAPublicKey.html)."public_key_to_der_pkcs1" Returns the size of the modulus in bytes.""This corresponds to [`RSA_size`](https://www.openssl.org/docs/manmaster/man3/RSA_size.html)."" Decrypts data using the public key, returning the number of decrypted bytes."" Panics if `to` is smaller than `self.size()`.""This corresponds to [`RSA_public_decrypt`](https://www.openssl.org/docs/manmaster/man3/RSA_public_decrypt.html)."public_decrypt" Encrypts data using the public key, returning the number of encrypted bytes.""This corresponds to [`RSA_public_encrypt`](https://www.openssl.org/docs/manmaster/man3/RSA_public_encrypt.html)."public_encrypt" Returns a reference to the modulus of the key."" Returns a reference to the public exponent of the key."/// Creates a new RSA key with only public components./// `n` is the modulus common to both public and private key./// `e` is the public exponent./// This corresponds to [`RSA_new`] and uses [`RSA_set0_key`]./// [`RSA_new`]: https://www.openssl.org/docs/manmaster/crypto/RSA_new.html/// [`RSA_set0_key`]: https://www.openssl.org/docs/manmaster/crypto/RSA_set0_key.htmlr" Decodes a PEM-encoded SubjectPublicKeyInfo structure containing an RSA key.""This corresponds to [`PEM_read_bio_RSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_RSA_PUBKEY.html)."r" Decodes a PEM-encoded PKCS#1 RSAPublicKey structure."r" The input should have a header of `-----BEGIN RSA PUBLIC KEY-----`.""This corresponds to [`PEM_read_bio_RSAPublicKey`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_RSAPublicKey.html)."public_key_from_pem_pkcs1r" Decodes a DER-encoded SubjectPublicKeyInfo structure containing an RSA key.""This corresponds to [`d2i_RSA_PUBKEY`](https://www.openssl.org/docs/manmaster/man3/d2i_RSA_PUBKEY.html)."r" Decodes a DER-encoded PKCS#1 RSAPublicKey structure.""This corresponds to [`d2i_RSAPublicKey`](https://www.openssl.org/docs/manmaster/man3/d2i_RSAPublicKey.html)."public_key_from_der_pkcs1RsaPrivateKeyBuilder/// Creates a new `RsaPrivateKeyBuilder`./// `e` is the public exponent and `d` is the private exponent." Sets the factors of the Rsa key."" `p` and `q` are the first and second factors of `n`.""This corresponds to [`RSA_set0_factors`](https://www.openssl.org/docs/manmaster/man3/RSA_set0_factors.html)."set_factors" Sets the Chinese Remainder Theorem params of the Rsa key."" `dmp1`, `dmq1`, and `iqmp` are the exponents and coefficient for"" CRT calculations which is used to speed up RSA operations.""This corresponds to [`RSA_set0_crt_params`](https://www.openssl.org/docs/manmaster/man3/RSA_set0_crt_params.html)."set_crt_params/// Returns the Rsa key./// Creates a new RSA key with private components (public components are assumed)./// This a convenience method over:/// # use openssl::rsa::RsaPrivateKeyBuilder;/// # let bn = || openssl::bn::BigNum::new().unwrap();/// # let (n, e, d, p, q, dmp1, dmq1, iqmp) = (bn(), bn(), bn(), bn(), bn(), bn(), bn(), bn());/// RsaPrivateKeyBuilder::new(n, e, d)?///     .set_factors(p, q)?///     .set_crt_params(dmp1, dmq1, iqmp)?" Generates a public/private key pair with the specified size."" The public exponent will be 65537.""This corresponds to [`RSA_generate_key_ex`](https://www.openssl.org/docs/manmaster/man3/RSA_generate_key_ex.html)."" Generates a public/private key pair with the specified size and a custom exponent."" Unless you have specific needs and know what you\'re doing, use `Rsa::generate` instead."generate_with_er" Deserializes a private key from a PEM-encoded PKCS#1 RSAPrivateKey structure.""This corresponds to [`PEM_read_bio_RSAPrivateKey`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_RSAPrivateKey.html)."r" Deserializes a private key from a PEM-encoded encrypted PKCS#1 RSAPrivateKey structure."// FIXME these need to identify input formatsr" Decodes a DER-encoded PKCS#1 RSAPrivateKey structure.""This corresponds to [`d2i_RSAPrivateKey`](https://www.openssl.org/docs/manmaster/man3/d2i_RSAPrivateKey.html)."RSA_get0_keyRSA_get0_factorsRSA_get0_crt_paramsRSA_set0_keyRSA_set0_factorsRSA_set0_crt_paramstest_from_passwordtest_from_password_callbacktest_public_encrypt_private_decrypt_with_paddingtest_private_encrypttest_public_encrypttest_public_key_from_pem_pkcs1test_public_key_from_pem_pkcs1_file_panictest_public_key_to_pem_pkcs1test_public_key_from_pem_pkcs1_generate_panictest_pem_pkcs1_encrypttest_pem_pkcs1_paddingtest_check_key//! Rivest–Shamir–Adleman cryptosystem//! RSA is one of the earliest asymmetric public key encryption schemes.//! Like many other cryptosystems, RSA relies on the presumed difficulty of a hard//! mathematical problem, namely factorization of the product of two large prime//! numbers. At the moment there does not exist an algorithm that can factor such//! large numbers in reasonable time. RSA is used in a wide variety of//! applications including digital signatures and key exchanges such as//! establishing a TLS/SSL connection.//! The RSA acronym is derived from the first letters of the surnames of the//! algorithm's founding trio.//! Generate a 2048-bit RSA key pair and use the public key to encrypt some data.//! let data = b"foobar";//! let mut buf = vec![0; rsa.size() as usize];//! let encrypted_len = rsa.public_encrypt(data, &mut buf, Padding::PKCS1).unwrap();" Computes the SHA1 hash of some data."" SHA1 is known to be insecure - it should not be used unless required for"" compatibility with existing systems.""This corresponds to [`SHA1`](https://www.openssl.org/docs/manmaster/man3/SHA1.html)."" Computes the SHA224 hash of some data.""This corresponds to [`SHA224`](https://www.openssl.org/docs/manmaster/man3/SHA224.html)."" Computes the SHA256 hash of some data.""This corresponds to [`SHA256`](https://www.openssl.org/docs/manmaster/man3/SHA256.html)."" Computes the SHA384 hash of some data.""This corresponds to [`SHA384`](https://www.openssl.org/docs/manmaster/man3/SHA384.html)."" Computes the SHA512 hash of some data.""This corresponds to [`SHA512`](https://www.openssl.org/docs/manmaster/man3/SHA512.html)."r" An object which calculates a SHA1 hash of some data."r" # Warning"r" SHA1 is known to be insecure - it should not be used unless required for"r" compatibility with existing systems."SHA_CTXr" Creates a new hasher.""This corresponds to [`SHA1_Init`](https://www.openssl.org/docs/manmaster/man3/SHA1_Init.html)."r" Feeds some data into the hasher."r" This can be called multiple times.""This corresponds to [`SHA1_Update`](https://www.openssl.org/docs/manmaster/man3/SHA1_Update.html)."r" Returns the hash of the data.""This corresponds to [`SHA1_Final`](https://www.openssl.org/docs/manmaster/man3/SHA1_Final.html)."r" An object which calculates a SHA224 hash of some data."SHA256_CTX"This corresponds to [`SHA224_Init`](https://www.openssl.org/docs/manmaster/man3/SHA224_Init.html).""This corresponds to [`SHA224_Update`](https://www.openssl.org/docs/manmaster/man3/SHA224_Update.html).""This corresponds to [`SHA224_Final`](https://www.openssl.org/docs/manmaster/man3/SHA224_Final.html)."r" An object which calculates a SHA256 hash of some data.""This corresponds to [`SHA256_Init`](https://www.openssl.org/docs/manmaster/man3/SHA256_Init.html).""This corresponds to [`SHA256_Update`](https://www.openssl.org/docs/manmaster/man3/SHA256_Update.html).""This corresponds to [`SHA256_Final`](https://www.openssl.org/docs/manmaster/man3/SHA256_Final.html)."r" An object which calculates a SHA384 hash of some data."SHA512_CTX"This corresponds to [`SHA384_Init`](https://www.openssl.org/docs/manmaster/man3/SHA384_Init.html).""This corresponds to [`SHA384_Update`](https://www.openssl.org/docs/manmaster/man3/SHA384_Update.html).""This corresponds to [`SHA384_Final`](https://www.openssl.org/docs/manmaster/man3/SHA384_Final.html)."r" An object which calculates a SHA512 hash of some data.""This corresponds to [`SHA512_Init`](https://www.openssl.org/docs/manmaster/man3/SHA512_Init.html).""This corresponds to [`SHA512_Update`](https://www.openssl.org/docs/manmaster/man3/SHA512_Update.html).""This corresponds to [`SHA512_Final`](https://www.openssl.org/docs/manmaster/man3/SHA512_Final.html)."standalone_1struct_1cloning_allows_incremental_hashingstandalone_224struct_224standalone_256struct_256standalone_384struct_384standalone_512struct_512//! The SHA family of hashes.//! SHA, or Secure Hash Algorithms, are a family of cryptographic hashing algorithms published by//! the National Institute of Standards and Technology (NIST).  Hash algorithms such as those in//! the SHA family are used to map data of an arbitrary size to a fixed-size string of bytes.//! As cryptographic hashing algorithms, these mappings have the property of being irreversible.//! This property makes hash algorithms like these excellent for uses such as verifying the//! contents of a file- if you know the hash you expect beforehand, then you can verify that the//! data you have is correct if it hashes to the same value.//! When dealing with data that becomes available in chunks, such as while buffering data from IO,//! you can create a hasher that you can repeatedly update to add bytes to.//! use openssl::sha;//! let mut hasher = sha::Sha256::new();//! hasher.update(b"Hello, ");//! hasher.update(b"world");//! let hash = hasher.finish();//! println!("Hashed \"Hello, world\" to {}", hex::encode(hash));//! On the other hand, if you already have access to all of the data you would like to hash, you//! may prefer to use the slightly simpler method of simply calling the hash function corresponding//! to the algorithm you want to use.//! use openssl::sha::sha256;//! let hash = sha256(b"your data or message");//! println!("Hash = {}", hex::encode(hash));/// Salt lengths that must be used with `set_rsa_pss_saltlen`./// Returns the integer representation of `RsaPssSaltlen`./// Sets the salt length to the given value.DIGEST_LENGTH/// The salt length is set to the digest length./// Corresponds to the special value `-1`.MAXIMUM_LENGTH/// The salt length is set to the maximum permissible value./// Corresponds to the special value `-2`./// A type which computes cryptographic signatures of data." Creates a new `Signer`."" This cannot be used with Ed25519 or Ed448 keys. Please refer to"" `new_without_digest`."" Creates a new `Signer` without a digest."" This is the only way to create a `Verifier` for Ed25519 or Ed448 keys."" It can also be used to create a CMAC."new_without_digestnew_intern" Feeds more data into the `Signer`."" Please note that PureEdDSA (Ed25519 and Ed448 keys) do not support streaming."" Use `sign_oneshot` instead."" Computes an upper bound on the signature length."" The actual signature may be shorter than this value. Check the return value of"" `sign` to get the exact length."len_intern" Writes the signature into the provided buffer, returning the number of bytes written."" This method will fail if the buffer is not large enough for the signature. Use the `len`"" method to get an upper bound on the required size."/// Returns the signature./// This is a simple convenience wrapper over `len` and `sign`." Signs the data in `data_buf` and writes the signature into the buffer `sig_buf`, returning the"" number of bytes written."" For PureEdDSA (Ed25519 and Ed448 keys), this is the only way to sign data."sign_oneshotsign_oneshot_to_vec/// This is a simple convenience wrapper over `len` and `sign_oneshot`.pkey_pd/// A type which can be used to verify the integrity and authenticity/// of data given the signature." Creates a new `Verifier`."" [`Verifier::new_without_digest`]."" Creates a new `Verifier` without a digest."" Feeds more data into the `Verifier`."" Use [`Verifier::verify_oneshot`] instead."" Determines if the data fed into the `Verifier` matches the provided signature."" Determines if the data given in `buf` matches the provided signature."verify_oneshot/// A type which verifies cryptographic signatures of data.EVP_DigestVerifyFinalrsa_verify_okrsa_verify_invalidtest_hmachmac_md5hmac_sha1test_cmaceddsarsa_sign_verify//! Message signatures.//! The `Signer` allows for the computation of cryptographic signatures of//! data given a private key. The `Verifier` can then be used with the//! corresponding public key to verify the integrity and authenticity of that//! data given the signature.//! Sign and verify data given an RSA keypair://! use openssl::sign::{Signer, Verifier};//! use openssl::hash::MessageDigest;//! let data2 = b"hola, mundo!";//! // Sign the data//! let mut signer = Signer::new(MessageDigest::sha256(), &keypair).unwrap();//! signer.update(data).unwrap();//! signer.update(data2).unwrap();//! let signature = signer.sign_to_vec().unwrap();//! // Verify the data//! let mut verifier = Verifier::new(MessageDigest::sha256(), &keypair).unwrap();//! verifier.update(data).unwrap();//! verifier.update(data2).unwrap();//! assert!(verifier.verify(&signature).unwrap());SRTP_PROTECTION_PROFILE/// fake free method, since SRTP_PROTECTION_PROFILE is staticSrtpProtectionProfileRefr" Reference to `SrtpProtectionProfile`."stack_st_SRTP_PROTECTION_PROFILESrtpProfileId/// An identifier of an SRTP protection profile.SRTP_AES128_CM_SHA1_80SRTP_AES128_CM_SHA1_32SRTP_AES128_F8_SHA1_80SRTP_AES128_F8_SHA1_32SRTP_NULL_SHA1_80SRTP_NULL_SHA1_32SRTP_AEAD_AES_128_GCMSRTP_AEAD_AES_256_GCM/// Creates a `SrtpProfileId` from an integer representation./// Returns the integer representation of `SrtpProfileId`.BIO_clear_retry_flagsBIO_newBIO_set_retry_readBIO_set_retry_writeBIO_CTRL_DGRAM_QUERY_MTUBIO_CTRL_FLUSHdtls_mtu_sizeBIO_METHODBioMethod/// Safe wrapper for `BIO_METHOD`take_panicset_dtls_mtu_sizebwritebreadretriable_error// matches macro requires rust 1.42.0bputsBIO_get_dataBIO_set_dataBIO_set_flagsBIO_set_initBIO_set_numAlpnErrortry_get_session_ctx_indexSniErrorSslAlertSslContextRefSslRefSslSessionSslSessionRefClientHelloResponseExtensionContextX509StoreContextX509StoreContextRefraw_verifyX509_STORE_CTXraw_client_pskSSLraw_server_pskssl_raw_verifyraw_sniraw_alpn_selectraw_tmp_dhraw_tmp_dh_sslraw_tlsext_statusraw_new_sessionSSL_SESSIONraw_remove_sessionSSL_CTXDataPtrraw_get_sessionraw_keylograw_stateless_cookie_generateraw_stateless_cookie_verifyraw_cookie_generateCookiePtrraw_cookie_verifyCustomExtAddStateraw_custom_ext_addraw_custom_ext_freeraw_custom_ext_parseraw_client_helloSslVersionSslModeSslOptionsFFDHE_2048/// A type which wraps client-side streams in a TLS session./// OpenSSL's default configuration is highly insecure. This connector manages the OpenSSL/// structures, configuring cipher suites, session options, hostname verification, and more./// OpenSSL's built-in hostname verification is used when linking against OpenSSL 1.0.2 or 1.1.0,/// and a custom implementation is used when linking against OpenSSL 1.0.1.SslConnectorBuilder/// Creates a new builder for TLS connections./// The default configuration is subject to change, and is currently derived from Python./// Initiates a client-side TLS session on a stream./// The domain is used for SNI and hostname verification.ConnectConfiguration/// Returns a structure allowing for configuration of a single TLS session before connection.into_context/// Consumes the `SslConnector`, returning the inner raw `SslContext`./// Returns a shared reference to the inner raw `SslContext`./// A builder for `SslConnector`s./// Consumes the builder, returning an `SslConnector`.sniverify_hostname/// A type which allows for configuration of a client-side TLS session before connection.use_server_name_indication/// A builder-style version of `set_use_server_name_indication`.set_use_server_name_indication/// Configures the use of Server Name Indication (SNI) when connecting./// A builder-style version of `set_verify_hostname`.set_verify_hostname/// Configures the use of hostname verification when connecting./// You should think very carefully before you use this method. If hostname verification is not/// used, *any* valid certificate for *any* site will be trusted for use from any other. This/// introduces a significant vulnerability to man-in-the-middle attacks.into_ssl/// Returns an `Ssl` configured to connect to the provided domain./// The domain is used for SNI (if it is not an IP address) and hostname verification if enabled./// The domain is used for SNI and hostname verification if enabled./// A type which wraps server-side streams in a TLS session./// structures, configuring cipher suites, session options, and more.mozilla_intermediate_v5SslAcceptorBuilder/// Creates a new builder configured to connect to non-legacy clients. This should generally be/// considered a reasonable default choice./// This corresponds to the intermediate configuration of version 5 of Mozilla's server side TLS/// recommendations. See its [documentation][docs] for more details on specifics./// [docs]: https://wiki.mozilla.org/Security/Server_Side_TLSmozilla_modern_v5/// Creates a new builder configured to connect to modern clients./// This corresponds to the modern configuration of version 5 of Mozilla's server side TLS recommendations./// See its [documentation][docs] for more details on specifics./// Requires OpenSSL 1.1.1 or LibreSSL 3.4.0 or newer.mozilla_intermediate/// This corresponds to the intermediate configuration of version 4 of Mozilla's server side TLS// FIXME remove in next major versionmozilla_modern/// This corresponds to the modern configuration of version 4 of Mozilla's server side TLS recommendations./// Initiates a server-side TLS session on a stream./// Consumes the `SslAcceptor`, returning the inner raw `SslContext`./// A builder for `SslAcceptor`s./// Consumes the builder, returning a `SslAcceptor`.setup_curvessetup_verifysetup_verify_hostname/// An error code returned from SSL functions.ZERO_RETURN/// The SSL session has been closed.WANT_READ/// An attempt to read data from the underlying socket returned `WouldBlock`./// Wait for read readiness and retry the operation.WANT_WRITE/// An attempt to write data to the underlying socket returned `WouldBlock`./// Wait for write readiness and retry the operation.SYSCALL/// A non-recoverable IO error occurred./// An error occurred in the SSL library.WANT_CLIENT_HELLO_CB/// The client hello callback indicated that it needed to be retried./// Requires OpenSSL 1.1.1 or newer./// An SSL error.into_io_errorssl_errorSetupFailure/// Setup failed./// The handshake failed./// The handshake encountered a `WouldBlock` error midway through./// This error will never be returned for blocking streams./// An error or intermediate state after a TLS handshake attempt.// FIXME overhaulX509StoreBuilderRefX509VerifyParamRef" Returns the OpenSSL name of a cipher corresponding to an RFC-standard cipher name."" If the cipher has no corresponding OpenSSL name, the string `(NONE)` is returned.""This corresponds to [`OPENSSL_cipher_name`](https://www.openssl.org/docs/manmaster/man3/OPENSSL_cipher_name.html)."cipher_nameSslOptionsReprr" Options controlling the behavior of an `SslContext`."r" Disables a countermeasure against an SSLv3/TLSv1.0 vulnerability affecting CBC ciphers."DONT_INSERT_EMPTY_FRAGMENTSr#" A "reasonable default" set of options which enables compatibility flags."#r" Do not query the MTU."r" Only affects DTLS connections."NO_QUERY_MTUr" Enables Cookie Exchange as described in [RFC 4347 Section 4.2.1]."r" [RFC 4347 Section 4.2.1]: https://tools.ietf.org/html/rfc4347#section-4.2.1"COOKIE_EXCHANGEr" Disables the use of session tickets for session resumption."NO_TICKETr" Always start a new session when performing a renegotiation on the server side."NO_SESSION_RESUMPTION_ON_RENEGOTIATIONr" Disables the use of TLS compression."NO_COMPRESSIONr" Allow legacy insecure renegotiation with servers or clients that do not support secure"r" renegotiation."ALLOW_UNSAFE_LEGACY_RENEGOTIATIONr" Creates a new key for each session when using ECDHE."r" This is always enabled in OpenSSL 1.1.0."SINGLE_ECDH_USEr" Creates a new key for each session when using DHE."SINGLE_DH_USEr" Use the server's preferences rather than the client's when selecting a cipher."r" This has no effect on the client side."CIPHER_SERVER_PREFERENCEr" Disables version rollback attach detection."TLS_ROLLBACK_BUGr" Disables the use of SSLv2."NO_SSLV2r" Disables the use of SSLv3."NO_SSLV3r" Disables the use of TLSv1.0."NO_TLSV1r" Disables the use of TLSv1.1."NO_TLSV1_1r" Disables the use of TLSv1.2."NO_TLSV1_2r" Disables the use of TLSv1.3."r" Requires OpenSSL 1.1.1 or LibreSSL 3.4.0 or newer."NO_TLSV1_3r" Disables the use of DTLSv1.0"r" Requires OpenSSL 1.0.2 or LibreSSL 3.3.2 or newer."NO_DTLSV1r" Disables the use of DTLSv1.2."NO_DTLSV1_2r" Disables the use of all (D)TLS protocol versions."r" This can be used as a mask when whitelisting protocol versions."r" Requires OpenSSL 1.0.2 or newer."r" Only support TLSv1.2:"r" use openssl::ssl::SslOptions;"r" let options = SslOptions::NO_SSL_MASK & !SslOptions::NO_TLSV1_2;"NO_SSL_MASKr" Disallow all renegotiation in TLSv1.2 and earlier."r" Requires OpenSSL 1.1.0h or newer."NO_RENEGOTIATIONr" Enable TLSv1.3 Compatibility mode."r" Requires OpenSSL 1.1.1 or newer. This is on by default in 1.1.1, but a future version"r" may have this disabled by default."ENABLE_MIDDLEBOX_COMPATr" Prioritize ChaCha ciphers when preferred by clients."r" Temporarily reprioritize ChaCha20-Poly1305 ciphers to the top of the server cipher list"r" if a ChaCha20-Poly1305 cipher is at the top of the client cipher list. This helps those"r" clients (e.g. mobile) use ChaCha20-Poly1305 if that cipher is anywhere in the server"r" cipher list; but still allows other clients to use AES and other ciphers."r" Requires enable [`SslOptions::CIPHER_SERVER_PREFERENCE`]."r" Requires OpenSSL 1.1.1 or newer."r" [`SslOptions::CIPHER_SERVER_PREFERENCE`]: struct.SslOptions.html#associatedconstant.CIPHER_SERVER_PREFERENCE"PRIORITIZE_CHACHAr#" Enables "short writes"."#r" Normally, a write in OpenSSL will always write out all of the requested data, even if it"r" requires more than one TLS record or write to the underlying stream. This option will"r" cause a write to return after writing a single TLS record instead."ENABLE_PARTIAL_WRITEr" Disables a check that the data buffer has not moved between calls when operating in a"r" non-blocking context."ACCEPT_MOVING_WRITE_BUFFERr" Enables automatic retries after TLS session events such as renegotiations or heartbeats."r" By default, OpenSSL will return a `WantRead` error after a renegotiation or heartbeat."r" This option will cause OpenSSL to automatically continue processing the requested"r" operation instead."r" Note that `SslStream::read` and `SslStream::write` will automatically retry regardless"r" of the state of this option. It only affects `SslStream::ssl_read` and"r" `SslStream::ssl_write`."AUTO_RETRYr" Disables automatic chain building when verifying a peer's certificate."r" TLS peers are responsible for sending the entire certificate chain from the leaf to a"r" trusted root, but some will incorrectly not do so. OpenSSL will try to build the chain"r" out of certificates it knows of, and this option will disable that behavior."NO_AUTO_CHAINr" Release memory buffers when the session does not need them."r" This saves ~34 KiB of memory for idle streams."RELEASE_BUFFERSr" Sends the fake `TLS_FALLBACK_SCSV` cipher suite in the ClientHello message of a"r" handshake."r" This should only be enabled if a client has failed to connect to a server which"r" attempted to downgrade the protocol version of the session."r" Do not use this unless you know what you're doing!"SEND_FALLBACK_SCSVSslBitTypeSSL_METHOD/// A type specifying the kind of protocol an `SslContext` will speak." Support all versions of the TLS protocol.""This corresponds to [`TLS_method`](https://www.openssl.org/docs/manmaster/man3/TLS_method.html)."" Support all versions of the DTLS protocol.""This corresponds to [`DTLS_method`](https://www.openssl.org/docs/manmaster/man3/DTLS_method.html)."" Support all versions of the TLS protocol, explicitly as a client.""This corresponds to [`TLS_client_method`](https://www.openssl.org/docs/manmaster/man3/TLS_client_method.html)."tls_client" Support all versions of the TLS protocol, explicitly as a server.""This corresponds to [`TLS_server_method`](https://www.openssl.org/docs/manmaster/man3/TLS_server_method.html)."tls_server/// Constructs an `SslMethod` from a pointer to the underlying OpenSSL value./// Returns a pointer to the underlying OpenSSL value.r" Options controlling the behavior of certificate verification."r" Verifies that the peer's certificate is trusted."r" On the server side, this will cause OpenSSL to request a certificate from the client."PEERr" Disables verification of the peer's certificate."r" On the server side, this will cause OpenSSL to not request a certificate from the"r" client. On the client side, the certificate will be checked for validity, but the"r" negotiation will continue regardless of the result of that check."r" On the server side, abort the handshake if the client did not send a certificate."r" This should be paired with `SSL_VERIFY_PEER`. It has no effect on the client side."FAIL_IF_NO_PEER_CERTSslTimeTyr" Options controlling the behavior of session caching."SslSessionCacheModer" No session caching for the client or server takes place."OFFr" Enable session caching on the client side."r" OpenSSL has no way of identifying the proper session to reuse automatically, so the"r" application is responsible for setting it explicitly via [`SslRef::set_session`]."r" [`SslRef::set_session`]: struct.SslRef.html#method.set_session"r" Enable session caching on the server side."r" This is the default mode."r" Enable session caching on both the client and server side."r" Disable automatic removal of expired sessions from the session cache."NO_AUTO_CLEARr" Disable use of the internal session cache for session lookups."NO_INTERNAL_LOOKUPr" Disable use of the internal session cache for session storage."NO_INTERNAL_STOREr" Disable use of the internal session cache for storage and lookup."NO_INTERNALr" Which messages and under which conditions an extension should be added or expected."r" This extension is only allowed in TLS"TLS_ONLYr" This extension is only allowed in DTLS"DTLS_ONLYr" Some extensions may be allowed in DTLS but we don't implement them for it"TLS_IMPLEMENTATION_ONLYr" Most extensions are not defined for SSLv3 but EXT_TYPE_renegotiate is"SSL3_ALLOWEDr" Extension is only defined for TLS1.2 and below"TLS1_2_AND_BELOW_ONLYr" Extension is only defined for TLS1.3 and above"TLS1_3_ONLYr" Ignore this extension during parsing if we are resuming"IGNORE_ON_RESUMPTIONCLIENT_HELLOr" Really means TLS1.2 or below"TLS1_2_SERVER_HELLOTLS1_3_SERVER_HELLOTLS1_3_ENCRYPTED_EXTENSIONSTLS1_3_HELLO_RETRY_REQUESTTLS1_3_CERTIFICATETLS1_3_NEW_SESSION_TICKETTLS1_3_CERTIFICATE_REQUESTSslFiletype/// An identifier of the format of a certificate or key file.PEM/// The PEM format./// This corresponds to `SSL_FILETYPE_PEM`.ASN1/// The ASN1 format./// This corresponds to `SSL_FILETYPE_ASN1`./// Constructs an `SslFiletype` from a raw OpenSSL value.StatusType/// An identifier of a certificate status type.OCSP/// An OSCP status./// Constructs a `StatusType` from a raw OpenSSL value.NameType/// An identifier of a session name type.HOST_NAME/// A host name.INDEXESSSL_INDEXESSESSION_CTX_INDEXfree_data_boxCRYPTO_EX_DATA/// An error returned from the SNI callback.ALERT_FATAL/// Abort the handshake with a fatal alert.ALERT_WARNING/// Send a warning alert to the client and continue the handshake.NOACK/// An SSL/TLS alert.UNRECOGNIZED_NAME/// Alert 112 - `unrecognized_name`.ILLEGAL_PARAMETERDECODE_ERROR/// An error returned from an ALPN selection callback./// Requires OpenSSL 1.0.2 or LibreSSL 2.6.1 or newer./// Terminate the handshake with a fatal alert./// Do not select a protocol, but continue the handshake./// The result of a client hello callback./// Continue the handshake./// Return from the handshake with an `ErrorCode::WANT_CLIENT_HELLO_CB` error./// An SSL/TLS protocol version.SSL3/// SSLv3TLS1/// TLSv1.0TLS1_1/// TLSv1.1TLS1_2/// TLSv1.2TLS1_3/// TLSv1.3/// Requires BoringSSL or OpenSSL 1.1.1 or LibreSSL 3.4.0 or newer.DTLS1/// DTLSv1.0/// DTLS 1.0 corresponds to TLS 1.1.DTLS1_2/// DTLSv1.2/// DTLS 1.2 corresponds to TLS 1.2 to harmonize versions. There was never a DTLS 1.1.SslCacheTySslCacheSizeMtuTySizeTy" A standard implementation of protocol selection for Application Layer Protocol Negotiation"" (ALPN)."" `server` should contain the server\'s list of supported protocols and `client` the client\'s. They"" must both be in the ALPN wire format. See the documentation for"" [`SslContextBuilder::set_alpn_protos`] for details."" It will select the first protocol supported by the server which is also supported by the client."" [`SslContextBuilder::set_alpn_protos`]: struct.SslContextBuilder.html#method.set_alpn_protos""This corresponds to [`SSL_select_next_proto`](https://www.openssl.org/docs/manmaster/man3/SSL_select_next_proto.html)."select_next_proto/// A builder for `SslContext`s." Creates a new `SslContextBuilder`.""This corresponds to [`SSL_CTX_new`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_new.html)."/// Creates an `SslContextBuilder` from a pointer to a raw OpenSSL value./// The caller must ensure that the pointer is valid and uniquely owned by the builder./// Returns a pointer to the raw OpenSSL value." Configures the certificate verification method for new connections.""This corresponds to [`SSL_CTX_set_verify`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_verify.html)."set_verify" Configures the certificate verification method for new connections and"" registers a verification callback."" The callback is passed a boolean indicating if OpenSSL\'s internal verification succeeded as"" well as a reference to the `X509StoreContext` which can be used to examine the certificate"" chain. It should return a boolean indicating if verification succeeded."set_verify_callback" Configures the server name indication (SNI) callback for new connections."" SNI is used to allow a single server to handle requests for multiple domains, each of which"" has its own certificate chain and configuration."" Obtain the server name with the `servername` method and then set the corresponding context"" with `set_ssl_context`""This corresponds to [`SSL_CTX_set_tlsext_servername_callback`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_tlsext_servername_callback.html)."set_servername_callback" Sets the certificate verification depth."" If the peer\'s certificate chain is longer than this value, verification will fail.""This corresponds to [`SSL_CTX_set_verify_depth`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_verify_depth.html)."set_verify_depth" Sets a custom certificate store for verifying peer certificates.""This corresponds to [`SSL_CTX_set0_verify_cert_store`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set0_verify_cert_store.html)."set_verify_cert_store" Replaces the context\'s certificate store.""This corresponds to [`SSL_CTX_set_cert_store`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_cert_store.html)."set_cert_store" Controls read ahead behavior."" If enabled, OpenSSL will read as much data as is available from the underlying stream,"" instead of a single record at a time."" It has no effect when used with DTLS.""This corresponds to [`SSL_CTX_set_read_ahead`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_read_ahead.html)."set_read_ahead" Sets the mode used by the context, returning the previous mode.""This corresponds to [`SSL_CTX_set_mode`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_mode.html)."" Sets the parameters to be used during ephemeral Diffie-Hellman key exchange.""This corresponds to [`SSL_CTX_set_tmp_dh`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_tmp_dh.html)."set_tmp_dh" Sets the callback which will generate parameters to be used during ephemeral Diffie-Hellman"" key exchange."" The callback is provided with a reference to the `Ssl` for the session, as well as a boolean"" indicating if the selected cipher is export-grade, and the key length. The export and key"" length options are archaic and should be ignored in almost all cases.""This corresponds to [`SSL_CTX_set_tmp_dh_callback`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_tmp_dh_callback.html)."set_tmp_dh_callback" Sets the parameters to be used during ephemeral elliptic curve Diffie-Hellman key exchange.""This corresponds to [`SSL_CTX_set_tmp_ecdh`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_tmp_ecdh.html)."set_tmp_ecdh" Use the default locations of trusted certificates for verification."" These locations are read from the `SSL_CERT_FILE` and `SSL_CERT_DIR` environment variables"" if present, or defaults specified at OpenSSL build time otherwise.""This corresponds to [`SSL_CTX_set_default_verify_paths`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_default_verify_paths.html)."set_default_verify_paths" Loads trusted root certificates from a file."" The file should contain a sequence of PEM-formatted CA certificates.""This corresponds to [`SSL_CTX_load_verify_locations`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_load_verify_locations.html)."set_ca_file" Sets the list of CA names sent to the client."" The CA certificates must still be added to the trust root - they are not automatically set"" as trusted by this method.""This corresponds to [`SSL_CTX_set_client_CA_list`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_client_CA_list.html)."set_client_ca_list" Add the provided CA certificate to the list sent by the server to the client when"" requesting client-side TLS authentication.""This corresponds to [`SSL_CTX_add_client_CA`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_add_client_CA.html)."add_client_ca" Set the context identifier for sessions."" This value identifies the server\'s session cache to clients, telling them when they\'re"" able to reuse sessions. It should be set to a unique value per server, unless multiple"" servers share a session cache."" This value should be set when using client certificates, or each request will fail its"" handshake and need to be restarted.""This corresponds to [`SSL_CTX_set_session_id_context`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_session_id_context.html)."set_session_id_context" Loads a leaf certificate from a file."" Only a single certificate will be loaded - use `add_extra_chain_cert` to add the remainder"" of the certificate chain, or `set_certificate_chain_file` to load the entire chain from a"" single file.""This corresponds to [`SSL_CTX_use_certificate_file`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_use_certificate_file.html)."set_certificate_file" Loads a certificate chain from a file."" The file should contain a sequence of PEM-formatted certificates, the first being the leaf"" certificate, and the remainder forming the chain of certificates up to and including the"" trusted root certificate.""This corresponds to [`SSL_CTX_use_certificate_chain_file`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_use_certificate_chain_file.html)."set_certificate_chain_file" Sets the leaf certificate."" Use `add_extra_chain_cert` to add the remainder of the certificate chain.""This corresponds to [`SSL_CTX_use_certificate`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_use_certificate.html)."" Appends a certificate to the certificate chain."" This chain should contain all certificates necessary to go from the certificate specified by"" `set_certificate` to a trusted root.""This corresponds to [`SSL_CTX_add_extra_chain_cert`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_add_extra_chain_cert.html)."add_extra_chain_cert" Loads the private key from a file.""This corresponds to [`SSL_CTX_use_PrivateKey_file`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_use_PrivateKey_file.html)."set_private_key_file" Sets the private key.""This corresponds to [`SSL_CTX_use_PrivateKey`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_use_PrivateKey.html)."" Sets the list of supported ciphers for protocols before TLSv1.3."" The `set_ciphersuites` method controls the cipher suites for TLSv1.3."" See [`ciphers`] for details on the format."" [`ciphers`]: https://www.openssl.org/docs/manmaster/apps/ciphers.html""This corresponds to [`SSL_CTX_set_cipher_list`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_cipher_list.html)."set_cipher_list" Sets the list of supported ciphers for the TLSv1.3 protocol."" The `set_cipher_list` method controls the cipher suites for protocols before TLSv1.3."" The format consists of TLSv1.3 cipher suite names separated by `:` characters in order of"" preference."" Requires OpenSSL 1.1.1 or LibreSSL 3.4.0 or newer.""This corresponds to [`SSL_CTX_set_ciphersuites`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_ciphersuites.html)."set_ciphersuites" Sets the options used by the context, returning the old set."" This *enables* the specified options, but does not disable unspecified options. Use"" `clear_options` for that.""This corresponds to [`SSL_CTX_set_options`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_options.html)."" Returns the options used by the context.""This corresponds to [`SSL_CTX_get_options`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_options.html)."" Clears the options used by the context, returning the old set.""This corresponds to [`SSL_CTX_clear_options`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_clear_options.html)."clear_options" Sets the minimum supported protocol version."" A value of `None` will enable protocol versions down to the lowest version supported by"" OpenSSL."" Requires BoringSSL or OpenSSL 1.1.0 or LibreSSL 2.6.1 or newer.""This corresponds to [`SSL_CTX_set_min_proto_version`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_min_proto_version.html)."set_min_proto_version" Sets the maximum supported protocol version."" A value of `None` will enable protocol versions up to the highest version supported by"" Requires BoringSSL or OpenSSL 1.1.0 or or LibreSSL 2.6.1 or newer.""This corresponds to [`SSL_CTX_set_max_proto_version`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_max_proto_version.html)."set_max_proto_version" Gets the minimum supported protocol version."" A value of `None` indicates that all versions down to the lowest version supported by"" OpenSSL are enabled."" Requires OpenSSL 1.1.0g or LibreSSL 2.7.0 or newer.""This corresponds to [`SSL_CTX_get_min_proto_version`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_min_proto_version.html)."min_proto_version" Gets the maximum supported protocol version."" A value of `None` indicates that all versions up to the highest version supported by""This corresponds to [`SSL_CTX_get_max_proto_version`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_max_proto_version.html)."max_proto_version" Sets the protocols to sent to the server for Application Layer Protocol Negotiation (ALPN)."" The input must be in ALPN \"wire format\". It consists of a sequence of supported protocol"" names prefixed by their byte length. For example, the protocol list consisting of `spdy/1`"" and `http/1.1` is encoded as `b\"\\x06spdy/1\\x08http/1.1\"`. The protocols are ordered by"" Requires BoringSSL or OpenSSL 1.0.2 or LibreSSL 2.6.1 or newer.""This corresponds to [`SSL_CTX_set_alpn_protos`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_alpn_protos.html)."set_alpn_protos" Enables the DTLS extension \"use_srtp\" as defined in RFC5764.""This corresponds to [`SSL_CTX_set_tlsext_use_srtp`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_tlsext_use_srtp.html)."set_tlsext_use_srtp" Sets the callback used by a server to select a protocol for Application Layer Protocol"" Negotiation (ALPN)."" The callback is provided with the client\'s protocol list in ALPN wire format. See the"" documentation for [`SslContextBuilder::set_alpn_protos`] for details. It should return one"" of those protocols on success. The [`select_next_proto`] function implements the standard"" protocol selection algorithm."" Requires OpenSSL 1.0.2 or LibreSSL 2.6.1 or newer."" [`select_next_proto`]: fn.select_next_proto.html""This corresponds to [`SSL_CTX_set_alpn_select_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_alpn_select_cb.html)."set_alpn_select_callback" Checks for consistency between the private key and certificate.""This corresponds to [`SSL_CTX_check_private_key`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_check_private_key.html)."check_private_key" Returns a shared reference to the context\'s certificate store.""This corresponds to [`SSL_CTX_get_cert_store`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_cert_store.html)."" Returns a mutable reference to the context\'s certificate store."cert_store_mut" Returns a reference to the X509 verification configuration."" Requires BoringSSL or OpenSSL 1.0.2 or newer.""This corresponds to [`SSL_CTX_get0_param`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get0_param.html)."verify_param" Returns a mutable reference to the X509 verification configuration."verify_param_mut" Sets the callback dealing with OCSP stapling."" On the client side, this callback is responsible for validating the OCSP status response"" returned by the server. The status may be retrieved with the `SslRef::ocsp_status` method."" A response of `Ok(true)` indicates that the OCSP status is valid, and a response of"" `Ok(false)` indicates that the OCSP status is invalid and the handshake should be"" terminated."" On the server side, this callback is responsible for setting the OCSP status response to be"" returned to clients. The status may be set with the `SslRef::set_ocsp_status` method. A"" response of `Ok(true)` indicates that the OCSP status should be returned to the client, and"" `Ok(false)` indicates that the status should not be returned to the client.""This corresponds to [`SSL_CTX_set_tlsext_status_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_tlsext_status_cb.html)."set_status_callback" Sets the callback for providing an identity and pre-shared key for a TLS-PSK client."" The callback will be called with the SSL context, an identity hint if one was provided"" by the server, a mutable slice for each of the identity and pre-shared key bytes. The"" identity must be written as a null-terminated C string.""This corresponds to [`SSL_CTX_set_psk_client_callback`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_psk_client_callback.html)."set_psk_client_callbackset_psk_callback" Sets the callback for providing an identity and pre-shared key for a TLS-PSK server."" The callback will be called with the SSL context, an identity provided by the client,"" and, a mutable slice for the pre-shared key bytes. The callback returns the number of"" bytes in the pre-shared key.""This corresponds to [`SSL_CTX_set_psk_server_callback`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_psk_server_callback.html)."set_psk_server_callback" Sets the callback which is called when new sessions are negotiated."" This can be used by clients to implement session caching. While in TLSv1.2 the session is"" available to access via [`SslRef::session`] immediately after the handshake completes, this"" is not the case for TLSv1.3. There, a session is not generally available immediately, and"" the server may provide multiple session tokens to the client over a single session. The new"" session callback is a portable way to deal with both cases."" Note that session caching must be enabled for the callback to be invoked, and it defaults"" off for clients. [`set_session_cache_mode`] controls that behavior."" [`SslRef::session`]: struct.SslRef.html#method.session"" [`set_session_cache_mode`]: #method.set_session_cache_mode""This corresponds to [`SSL_CTX_sess_set_new_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_sess_set_new_cb.html)."set_new_session_callback" Sets the callback which is called when sessions are removed from the context."" Sessions can be removed because they have timed out or because they are considered faulty.""This corresponds to [`SSL_CTX_sess_set_remove_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_sess_set_remove_cb.html)."set_remove_session_callback" Sets the callback which is called when a client proposed to resume a session but it was not"" found in the internal cache."" The callback is passed a reference to the session ID provided by the client. It should"" return the session corresponding to that ID if available. This is only used for servers, not"" clients."" The returned `SslSession` must not be associated with a different `SslContext`.""This corresponds to [`SSL_CTX_sess_set_get_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_sess_set_get_cb.html)."set_get_session_callback" Sets the TLS key logging callback."" The callback is invoked whenever TLS key material is generated, and is passed a line of NSS"" SSLKEYLOGFILE-formatted text. This can be used by tools like Wireshark to decrypt message"" traffic. The line does not contain a trailing newline.""This corresponds to [`SSL_CTX_set_keylog_callback`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_keylog_callback.html)."set_keylog_callback" Sets the session caching mode use for connections made with the context."" Returns the previous session caching mode.""This corresponds to [`SSL_CTX_set_session_cache_mode`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_session_cache_mode.html)."set_session_cache_mode" Sets the callback for generating an application cookie for TLS1.3"" stateless handshakes."" The callback will be called with the SSL context and a slice into which the cookie"" should be written. The callback should return the number of bytes written.""This corresponds to [`SSL_CTX_set_stateless_cookie_generate_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_stateless_cookie_generate_cb.html)."set_stateless_cookie_generate_cb" Sets the callback for verifying an application cookie for TLS1.3"" The callback will be called with the SSL context and the cookie supplied by the"" client. It should return true if and only if the cookie is valid."" Note that the OpenSSL implementation independently verifies the integrity of"" application cookies using an HMAC before invoking the supplied callback.""This corresponds to [`SSL_CTX_set_stateless_cookie_verify_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_stateless_cookie_verify_cb.html)."set_stateless_cookie_verify_cb" Sets the callback for generating a DTLSv1 cookie""This corresponds to [`SSL_CTX_set_cookie_generate_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_cookie_generate_cb.html)."set_cookie_generate_cb" Sets the callback for verifying a DTLSv1 cookie""This corresponds to [`SSL_CTX_set_cookie_verify_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_cookie_verify_cb.html)."set_cookie_verify_cb" Sets the extra data at the specified index."" This can be used to provide data to callbacks registered with the context. Use the"" `SslContext::new_ex_index` method to create an `Index`.""This corresponds to [`SSL_CTX_set_ex_data`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_ex_data.html)."set_ex_dataset_ex_data_innerex_data_mut" Adds a custom extension for a TLS/DTLS client or server for all supported protocol versions.""This corresponds to [`SSL_CTX_add_custom_ext`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_add_custom_ext.html)."AddFnParseFnadd_custom_ext" Sets the maximum amount of early data that will be accepted on incoming connections."" Defaults to 0.""This corresponds to [`SSL_CTX_set_max_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_max_early_data.html)."set_max_early_data" Sets a callback which will be invoked just after the client\'s hello message is received.""This corresponds to [`SSL_CTX_set_client_hello_cb`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_client_hello_cb.html)."set_client_hello_callback" Sets the context\'s session cache size limit, returning the previous limit."" A value of 0 means that the cache size is unbounded.""This corresponds to [`SSL_CTX_sess_set_cache_size`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_sess_set_cache_size.html)."set_session_cache_size" Sets the context\'s supported signature algorithms.""This corresponds to [`SSL_CTX_set1_sigalgs_list`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set1_sigalgs_list.html)."set_sigalgs_list" Sets the context\'s supported elliptic curve groups."" Requires BoringSSL or OpenSSL 1.1.1 or LibreSSL 2.5.1 or newer.""This corresponds to [`SSL_CTX_set1_groups_list`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set1_groups_list.html)."set_groups_list" Sets the number of TLS 1.3 session tickets that will be sent to a client after a full"" handshake.""This corresponds to [`SSL_CTX_set_num_tickets`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_num_tickets.html)."set_num_tickets" Set the context\'s security level to a value between 0 and 5, inclusive."" A security value of 0 allows allows all parameters and algorithms.""This corresponds to [`SSL_CTX_set_security_level`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_security_level.html)."set_security_level/// Consumes the builder, returning a new `SslContext`.r" A context object for TLS streams."r" Applications commonly configure a single `SslContext` that is shared by all of its"r" `SslStreams`."r" Reference to [`SslContext`]"r" [`SslContext`]: struct.SslContext.html"// TODO: add useful info here/// Creates a new builder object for an `SslContext`." Returns a new extra data index."" Each invocation of this function is guaranteed to return a distinct index. These can be used"" to store data in the context that can be retrieved later by callbacks, for example.""This corresponds to [`SSL_CTX_get_ex_new_index`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_ex_new_index.html)."new_ex_indexcached_ex_index// FIXME should return a result?" Returns the certificate associated with this `SslContext`, if present."" Requires OpenSSL 1.0.2 or LibreSSL 2.7.0 or newer.""This corresponds to [`SSL_CTX_get0_certificate`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get0_certificate.html)."" Returns the private key associated with this `SslContext`, if present."" Requires OpenSSL 1.0.2 or LibreSSL 3.4.0 or newer.""This corresponds to [`SSL_CTX_get0_privatekey`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get0_privatekey.html)."" Returns a shared reference to the certificate store used for verification."" Returns a shared reference to the stack of certificates making up the chain from the leaf.""This corresponds to [`SSL_CTX_get_extra_chain_certs`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_extra_chain_certs.html)."extra_chain_certs" Returns a reference to the extra data at the specified index.""This corresponds to [`SSL_CTX_get_ex_data`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_ex_data.html)."" Gets the maximum amount of early data that will be accepted on incoming connections.""This corresponds to [`SSL_CTX_get_max_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_max_early_data.html)."max_early_data" Adds a session to the context\'s cache."" Returns `true` if the session was successfully added to the cache, and `false` if it was already present."" The caller of this method is responsible for ensuring that the session has never been used with another"" `SslContext` than this one.""This corresponds to [`SSL_CTX_add_session`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_add_session.html)."add_session" Removes a session from the context\'s cache and marks it as non-resumable."" Returns `true` if the session was successfully found and removed, and `false` otherwise.""This corresponds to [`SSL_CTX_remove_session`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_remove_session.html)."remove_session" Returns the context\'s session cache size limit.""This corresponds to [`SSL_CTX_sess_get_cache_size`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_sess_get_cache_size.html)."session_cache_size" Returns the verify mode that was set on this context from [`SslContextBuilder::set_verify`]."" [`SslContextBuilder::set_verify`]: struct.SslContextBuilder.html#method.set_verify""This corresponds to [`SSL_CTX_get_verify_mode`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_verify_mode.html)."verify_mode" Gets the number of TLS 1.3 session tickets that will be sent to a client after a full""This corresponds to [`SSL_CTX_get_num_tickets`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_num_tickets.html)."num_tickets" Get the context\'s security level, which controls the allowed parameters"" and algorithms.""This corresponds to [`SSL_CTX_get_security_level`](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_get_security_level.html)."security_levelsecret/// The number of secret bits used for the cipher./// The number of bits processed by the chosen algorithm.CipherBits/// Information about the state of a cipher.SSL_CIPHERSslCipher/// Information about a cipher.SslCipherRefstack_st_SSL_CIPHER/// Reference to an [`SslCipher`]./// [`SslCipher`]: struct.SslCipher.html" Returns the name of the cipher.""This corresponds to [`SSL_CIPHER_get_name`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_get_name.html)."" Returns the RFC-standard name of the cipher, if one exists.""This corresponds to [`SSL_CIPHER_standard_name`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_standard_name.html)."standard_name" Returns the SSL/TLS protocol version that first defined the cipher.""This corresponds to [`SSL_CIPHER_get_version`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_get_version.html)."" Returns the number of bits used for the cipher.""This corresponds to [`SSL_CIPHER_get_bits`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_get_bits.html)."" Returns a textual description of the cipher.""This corresponds to [`SSL_CIPHER_description`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_description.html)."" Returns the handshake digest of the cipher.""This corresponds to [`SSL_CIPHER_get_handshake_digest`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_get_handshake_digest.html)."handshake_digest" Returns the NID corresponding to the cipher."" Requires OpenSSL 1.1.0 or LibreSSL 2.7.0 or newer.""This corresponds to [`SSL_CIPHER_get_cipher_nid`](https://www.openssl.org/docs/manmaster/man3/SSL_CIPHER_get_cipher_nid.html)."cipher_nidsuitessignalling_suitesCipherLists/// A stack of selected ciphers, and a stack of selected signalling cipher suitesr" An encoded SSL session."r" These can be cached to share sessions across connections."r" Reference to [`SslSession`]."r" [`SslSession`]: struct.SslSession.html"r" Deserializes a DER-encoded session structure.""This corresponds to [`d2i_SSL_SESSION`](https://www.openssl.org/docs/manmaster/man3/d2i_SSL_SESSION.html)."" Returns the SSL session ID.""This corresponds to [`SSL_SESSION_get_id`](https://www.openssl.org/docs/manmaster/man3/SSL_SESSION_get_id.html)."" Returns the length of the master key.""This corresponds to [`SSL_SESSION_get_master_key`](https://www.openssl.org/docs/manmaster/man3/SSL_SESSION_get_master_key.html)."master_key_len" Copies the master key into the provided buffer."" Returns the number of bytes written, or the size of the master key if the buffer is empty."master_key" Gets the maximum amount of early data that can be sent on this session.""This corresponds to [`SSL_SESSION_get_max_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_SESSION_get_max_early_data.html)."" Returns the time at which the session was established, in seconds since the Unix epoch.""This corresponds to [`SSL_SESSION_get_time`](https://www.openssl.org/docs/manmaster/man3/SSL_SESSION_get_time.html)."" Returns the sessions timeout, in seconds."" A session older than this time should not be used for session resumption.""This corresponds to [`SSL_SESSION_get_timeout`](https://www.openssl.org/docs/manmaster/man3/SSL_SESSION_get_timeout.html)."" Returns the session\'s TLS protocol version.""This corresponds to [`SSL_SESSION_get_protocol_version`](https://www.openssl.org/docs/manmaster/man3/SSL_SESSION_get_protocol_version.html)."r" Serializes the session into a DER-encoded structure.""This corresponds to [`i2d_SSL_SESSION`](https://www.openssl.org/docs/manmaster/man3/i2d_SSL_SESSION.html)."r" The state of an SSL/TLS session."r" `Ssl` objects are created from an [`SslContext`], which provides configuration defaults."r" These defaults can be overridden on a per-`Ssl` basis, however."r" Reference to an [`Ssl`]."r" [`Ssl`]: struct.Ssl.html""This corresponds to [`SSL_get_ex_new_index`](https://www.openssl.org/docs/manmaster/man3/SSL_get_ex_new_index.html)."" Creates a new `Ssl`.""This corresponds to [`SSL_new`](https://www.openssl.org/docs/manmaster/man3/SSL_new.html)."" Initiates a client-side TLS handshake."" OpenSSL\'s default configuration is insecure. It is highly recommended to use"" `SslConnector` rather than `Ssl` directly, as it manages that configuration.""This corresponds to [`SSL_connect`](https://www.openssl.org/docs/manmaster/man3/SSL_connect.html)."" Initiates a server-side TLS handshake."" `SslAcceptor` rather than `Ssl` directly, as it manages that configuration.""This corresponds to [`SSL_accept`](https://www.openssl.org/docs/manmaster/man3/SSL_accept.html)."get_raw_rbio" Configure as an outgoing stream from a client.""This corresponds to [`SSL_set_connect_state`](https://www.openssl.org/docs/manmaster/man3/SSL_set_connect_state.html)."set_connect_state" Configure as an incoming stream to a server.""This corresponds to [`SSL_set_accept_state`](https://www.openssl.org/docs/manmaster/man3/SSL_set_accept_state.html)."set_accept_state" Like [`SslContextBuilder::set_verify`].""This corresponds to [`SSL_set_verify`](https://www.openssl.org/docs/manmaster/man3/SSL_set_verify.html)."" Returns the verify mode that was set using `set_verify`.""This corresponds to [`SSL_set_verify_mode`](https://www.openssl.org/docs/manmaster/man3/SSL_set_verify_mode.html)."" Like [`SslContextBuilder::set_verify_callback`]."" [`SslContextBuilder::set_verify_callback`]: struct.SslContextBuilder.html#method.set_verify_callback"" Like [`SslContextBuilder::set_tmp_dh`]."" [`SslContextBuilder::set_tmp_dh`]: struct.SslContextBuilder.html#method.set_tmp_dh""This corresponds to [`SSL_set_tmp_dh`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tmp_dh.html)."" Like [`SslContextBuilder::set_tmp_dh_callback`]."" [`SslContextBuilder::set_tmp_dh_callback`]: struct.SslContextBuilder.html#method.set_tmp_dh_callback""This corresponds to [`SSL_set_tmp_dh_callback`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tmp_dh_callback.html)."" Like [`SslContextBuilder::set_tmp_ecdh`]."" [`SslContextBuilder::set_tmp_ecdh`]: struct.SslContextBuilder.html#method.set_tmp_ecdh""This corresponds to [`SSL_set_tmp_ecdh`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tmp_ecdh.html)."" Like [`SslContextBuilder::set_alpn_protos`].""This corresponds to [`SSL_set_alpn_protos`](https://www.openssl.org/docs/manmaster/man3/SSL_set_alpn_protos.html)."" Returns the current cipher if the session is active.""This corresponds to [`SSL_get_current_cipher`](https://www.openssl.org/docs/manmaster/man3/SSL_get_current_cipher.html)."current_cipher" Returns a short string describing the state of the session.""This corresponds to [`SSL_state_string`](https://www.openssl.org/docs/manmaster/man3/SSL_state_string.html)."state_string" Returns a longer string describing the state of the session.""This corresponds to [`SSL_state_string_long`](https://www.openssl.org/docs/manmaster/man3/SSL_state_string_long.html)."state_string_long" Sets the host name to be sent to the server for Server Name Indication (SNI)."" It has no effect for a server-side connection.""This corresponds to [`SSL_set_tlsext_host_name`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tlsext_host_name.html)."set_hostname" Returns the peer\'s certificate, if present.""This corresponds to [`SSL_get_peer_certificate`](https://www.openssl.org/docs/manmaster/man3/SSL_get_peer_certificate.html)."" Returns the certificate chain of the peer, if present."" On the client side, the chain includes the leaf certificate, but on the server side it does"" not. Fun!""This corresponds to [`SSL_get_peer_cert_chain`](https://www.openssl.org/docs/manmaster/man3/SSL_get_peer_cert_chain.html)."peer_cert_chain" Returns the verified certificate chain of the peer, including the leaf certificate."" If verification was not successful (i.e. [`verify_result`] does not return"" [`X509VerifyResult::OK`]), this chain may be incomplete or invalid."" [`verify_result`]: #method.verify_result"" [`X509VerifyResult::OK`]: ../x509/struct.X509VerifyResult.html#associatedconstant.OK""This corresponds to [`SSL_get0_verified_chain`](https://www.openssl.org/docs/manmaster/man3/SSL_get0_verified_chain.html)."verified_chain" Like [`SslContext::certificate`].""This corresponds to [`SSL_get_certificate`](https://www.openssl.org/docs/manmaster/man3/SSL_get_certificate.html)."" Like [`SslContext::private_key`]."" [`SslContext::private_key`]: struct.SslContext.html#method.private_key""This corresponds to [`SSL_get_privatekey`](https://www.openssl.org/docs/manmaster/man3/SSL_get_privatekey.html)."" Returns the protocol version of the session.""This corresponds to [`SSL_version`](https://www.openssl.org/docs/manmaster/man3/SSL_version.html)."version2" Returns a string describing the protocol version of the session.""This corresponds to [`SSL_get_version`](https://www.openssl.org/docs/manmaster/man3/SSL_get_version.html)."version_str" Returns the protocol selected via Application Layer Protocol Negotiation (ALPN)."" The protocol\'s name is returned is an opaque sequence of bytes. It is up to the client"" to interpret it.""This corresponds to [`SSL_get0_alpn_selected`](https://www.openssl.org/docs/manmaster/man3/SSL_get0_alpn_selected.html)."selected_alpn_protocol"This corresponds to [`SSL_set_tlsext_use_srtp`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tlsext_use_srtp.html)."" Gets all SRTP profiles that are enabled for handshake via set_tlsext_use_srtp"" DTLS extension \"use_srtp\" as defined in RFC5764 has to be enabled.""This corresponds to [`SSL_get_srtp_profiles`](https://www.openssl.org/docs/manmaster/man3/SSL_get_srtp_profiles.html)."srtp_profiles" Gets the SRTP profile selected by handshake.""This corresponds to [`SSL_get_selected_srtp_profile`](https://www.openssl.org/docs/manmaster/man3/SSL_get_selected_srtp_profile.html)."selected_srtp_profile" Returns the number of bytes remaining in the currently processed TLS record."" If this is greater than 0, the next call to `read` will not call down to the underlying"" stream.""This corresponds to [`SSL_pending`](https://www.openssl.org/docs/manmaster/man3/SSL_pending.html)."" Returns the servername sent by the client via Server Name Indication (SNI)."" It is only useful on the server side."" While the SNI specification requires that servernames be valid domain names (and therefore"" ASCII), OpenSSL does not enforce this restriction. If the servername provided by the client"" is not valid UTF-8, this function will return `None`. The `servername_raw` method returns"" the raw bytes and does not have this restriction."" [`SSL_get_servername`]: https://www.openssl.org/docs/manmaster/man3/SSL_get_servername.html""This corresponds to [`SSL_get_servername`](https://www.openssl.org/docs/manmaster/man3/SSL_get_servername.html)."servername" Unlike `servername`, this method does not require the name be valid UTF-8."servername_raw" Changes the context corresponding to the current connection."" It is most commonly used in the Server Name Indication (SNI) callback.""This corresponds to [`SSL_set_SSL_CTX`](https://www.openssl.org/docs/manmaster/man3/SSL_set_SSL_CTX.html)."set_ssl_context" Returns the context corresponding to the current connection.""This corresponds to [`SSL_get_SSL_CTX`](https://www.openssl.org/docs/manmaster/man3/SSL_get_SSL_CTX.html)."ssl_context"This corresponds to [`SSL_get0_param`](https://www.openssl.org/docs/manmaster/man3/SSL_get0_param.html)."param_mut" Returns the certificate verification result.""This corresponds to [`SSL_get_verify_result`](https://www.openssl.org/docs/manmaster/man3/SSL_get_verify_result.html)."verify_result" Returns a shared reference to the SSL session.""This corresponds to [`SSL_get_session`](https://www.openssl.org/docs/manmaster/man3/SSL_get_session.html)."" Copies the `client_random` value sent by the client in the TLS handshake into a buffer."" Returns the number of bytes copied, or if the buffer is empty, the size of the `client_random`"" value.""This corresponds to [`SSL_get_client_random`](https://www.openssl.org/docs/manmaster/man3/SSL_get_client_random.html)."client_random" Copies the `server_random` value sent by the server in the TLS handshake into a buffer."" Returns the number of bytes copied, or if the buffer is empty, the size of the `server_random`""This corresponds to [`SSL_get_server_random`](https://www.openssl.org/docs/manmaster/man3/SSL_get_server_random.html)."server_random" Derives keying material for application use in accordance to RFC 5705.""This corresponds to [`SSL_export_keying_material`](https://www.openssl.org/docs/manmaster/man3/SSL_export_keying_material.html)."" This function is only usable with TLSv1.3, wherein there is no distinction between an empty context and no"" context. Therefore, unlike `export_keying_material`, `context` must always be supplied.""This corresponds to [`SSL_export_keying_material_early`](https://www.openssl.org/docs/manmaster/man3/SSL_export_keying_material_early.html)."export_keying_material_early" Sets the session to be used."" This should be called before the handshake to attempt to reuse a previously established"" session. If the server is not willing to reuse the session, a new one will be transparently"" negotiated."" The caller of this method is responsible for ensuring that the session is associated"" with the same `SslContext` as this `Ssl`.""This corresponds to [`SSL_set_session`](https://www.openssl.org/docs/manmaster/man3/SSL_set_session.html)."set_session" Determines if the session provided to `set_session` was successfully reused.""This corresponds to [`SSL_session_reused`](https://www.openssl.org/docs/manmaster/man3/SSL_session_reused.html)."session_reused" Sets the status response a client wishes the server to reply with.""This corresponds to [`SSL_set_tlsext_status_type`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tlsext_status_type.html)."set_status_type" Determines if current session used Extended Master Secret"" Returns `None` if the handshake is still in-progress.""This corresponds to [`SSL_get_extms_support`](https://www.openssl.org/docs/manmaster/man3/SSL_get_extms_support.html)."extms_support" Returns the server\'s OCSP response, if present.""This corresponds to [`SSL_get_tlsext_status_ocsp_resp`](https://www.openssl.org/docs/manmaster/man3/SSL_get_tlsext_status_ocsp_resp.html)."ocsp_status" Sets the OCSP response to be returned to the client.""This corresponds to [`SSL_set_tlsext_status_oscp_resp`](https://www.openssl.org/docs/manmaster/man3/SSL_set_tlsext_status_oscp_resp.html)."set_ocsp_status" Determines if this `Ssl` is configured for server-side or client-side use.""This corresponds to [`SSL_is_server`](https://www.openssl.org/docs/manmaster/man3/SSL_is_server.html)."" `Ssl::new_ex_index` method to create an `Index`.""This corresponds to [`SSL_set_ex_data`](https://www.openssl.org/docs/manmaster/man3/SSL_set_ex_data.html).""This corresponds to [`SSL_get_ex_data`](https://www.openssl.org/docs/manmaster/man3/SSL_get_ex_data.html)."" Returns a mutable reference to the extra data at the specified index."" Sets the maximum amount of early data that will be accepted on this connection.""This corresponds to [`SSL_set_max_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_set_max_early_data.html)."" Gets the maximum amount of early data that can be sent on this connection.""This corresponds to [`SSL_get_max_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_get_max_early_data.html)."" Copies the contents of the last Finished message sent to the peer into the provided buffer."" The total size of the message is returned, so this can be used to determine the size of the"" buffer required.""This corresponds to [`SSL_get_finished`](https://www.openssl.org/docs/manmaster/man3/SSL_get_finished.html)."" Copies the contents of the last Finished message received from the peer into the provided"" buffer.""This corresponds to [`SSL_get_peer_finished`](https://www.openssl.org/docs/manmaster/man3/SSL_get_peer_finished.html)."peer_finished" Determines if the initial handshake has been completed.""This corresponds to [`SSL_is_init_finished`](https://www.openssl.org/docs/manmaster/man3/SSL_is_init_finished.html)."is_init_finished" Determines if the client\'s hello message is in the SSLv2 format."" This can only be used inside of the client hello callback. Otherwise, `false` is returned.""This corresponds to [`SSL_client_hello_isv2`](https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_isv2.html)."client_hello_isv2" Returns the legacy version field of the client\'s hello message."" This can only be used inside of the client hello callback. Otherwise, `None` is returned.""This corresponds to [`SSL_client_hello_get0_legacy_version`](https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_get0_legacy_version.html)."client_hello_legacy_version" Returns the random field of the client\'s hello message.""This corresponds to [`SSL_client_hello_get0_random`](https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_get0_random.html)."client_hello_random" Returns the session ID field of the client\'s hello message.""This corresponds to [`SSL_client_hello_get0_session_id`](https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_get0_session_id.html)."client_hello_session_id" Returns the ciphers field of the client\'s hello message.""This corresponds to [`SSL_client_hello_get0_ciphers`](https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_get0_ciphers.html)."client_hello_ciphers" Decodes a slice of wire-format cipher suite specification bytes. Unsupported cipher suites"" are ignored.""This corresponds to [`SSL_bytes_to_cipher_list`](https://www.openssl.org/docs/manmaster/man3/SSL_bytes_to_cipher_list.html)."bytes_to_cipher_list" Returns the compression methods field of the client\'s hello message.""This corresponds to [`SSL_client_hello_get0_compression_methods`](https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_get0_compression_methods.html)."client_hello_compression_methods" Sets the MTU used for DTLS connections.""This corresponds to [`SSL_set_mtu`](https://www.openssl.org/docs/manmaster/man3/SSL_set_mtu.html)."set_mtu" Returns the PSK identity hint used during connection setup."" May return `None` if no PSK identity hint was used during the connection setup.""This corresponds to [`SSL_get_psk_identity_hint`](https://www.openssl.org/docs/manmaster/man3/SSL_get_psk_identity_hint.html)."" Returns the PSK identity used during connection setup.""This corresponds to [`SSL_get_psk_identity`](https://www.openssl.org/docs/manmaster/man3/SSL_get_psk_identity.html)."psk_identity"This corresponds to [`SSL_add0_chain_cert`](https://www.openssl.org/docs/manmaster/man3/SSL_add0_chain_cert.html)."add_chain_certset_method/// Sets a new default TLS/SSL method for SSL objects"This corresponds to [`SSL_use_Private_Key_file`](https://www.openssl.org/docs/manmaster/man3/SSL_use_Private_Key_file.html).""This corresponds to [`SSL_use_PrivateKey`](https://www.openssl.org/docs/manmaster/man3/SSL_use_PrivateKey.html)."" Sets the certificate""This corresponds to [`SSL_use_certificate`](https://www.openssl.org/docs/manmaster/man3/SSL_use_certificate.html).""This corresponds to [`SSL_use_certificate_chain_file`](https://www.openssl.org/docs/manmaster/man3/SSL_use_certificate_chain_file.html)."" Sets ca certificate that client trusted""This corresponds to [`SSL_add_client_CA`](https://www.openssl.org/docs/manmaster/man3/SSL_add_client_CA.html).""This corresponds to [`SSL_set_client_CA_list`](https://www.openssl.org/docs/manmaster/man3/SSL_set_client_CA_list.html).""This corresponds to [`SSL_set_min_proto_version`](https://www.openssl.org/docs/manmaster/man3/SSL_set_min_proto_version.html).""This corresponds to [`SSL_set_max_proto_version`](https://www.openssl.org/docs/manmaster/man3/SSL_set_max_proto_version.html).""This corresponds to [`SSL_set_ciphersuites`](https://www.openssl.org/docs/manmaster/man3/SSL_set_ciphersuites.html).""This corresponds to [`SSL_set_cipher_list`](https://www.openssl.org/docs/manmaster/man3/SSL_set_cipher_list.html)."" Set the certificate store used for certificate verification""This corresponds to [`SSL_set_cert_store`](https://www.openssl.org/docs/manmaster/man3/SSL_set_cert_store.html).""This corresponds to [`SSL_set_num_tickets`](https://www.openssl.org/docs/manmaster/man3/SSL_set_num_tickets.html).""This corresponds to [`SSL_get_num_tickets`](https://www.openssl.org/docs/manmaster/man3/SSL_get_num_tickets.html).""This corresponds to [`SSL_set_security_level`](https://www.openssl.org/docs/manmaster/man3/SSL_set_security_level.html)."" Get the connection\'s security level, which controls the allowed parameters""This corresponds to [`SSL_get_security_level`](https://www.openssl.org/docs/manmaster/man3/SSL_get_security_level.html)."" Get the temporary key provided by the peer that is used during key"" exchange.""This corresponds to [`SSL_get_peer_tmp_key`](https://www.openssl.org/docs/manmaster/man3/SSL_get_peer_tmp_key.html)."peer_tmp_key" Returns the temporary key from the local end of the connection that is"" used during key exchange.""This corresponds to [`SSL_get_tmp_key`](https://www.openssl.org/docs/manmaster/man3/SSL_get_tmp_key.html)."tmp_key/// An SSL stream midway through the handshake process./// Returns a shared reference to the `Ssl` of the stream./// Returns the underlying error which interrupted this handshake./// Consumes `self`, returning its error." Restarts the handshake process.""This corresponds to [`SSL_do_handshake`](https://www.openssl.org/docs/manmaster/man3/SSL_do_handshake.html)."/// A TLS session over a stream." Creates a new `SslStream`."" This function performs no IO; the stream will not have performed any part of the handshake"" with the peer. If the `Ssl` was configured with [`SslRef::set_connect_state`] or"" [`SslRef::set_accept_state`], the handshake can be performed automatically during the first"" call to read or write. Otherwise the `connect` and `accept` methods can be used to"" explicitly perform the handshake.""This corresponds to [`SSL_set_bio`](https://www.openssl.org/docs/manmaster/man3/SSL_set_bio.html)."/// Constructs an `SslStream` from a pointer to the underlying OpenSSL `SSL` struct./// This is useful if the handshake has already been completed elsewhere." Read application data transmitted by a client before handshake completion."" Useful for reducing latency, but vulnerable to replay attacks. Call"" [`SslRef::set_accept_state`] first."" Returns `Ok(0)` if all early data has been read.""This corresponds to [`SSL_read_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_read_early_data.html)."read_early_data" Send data to the server without blocking on handshake completion."" [`SslRef::set_connect_state`] first.""This corresponds to [`SSL_write_early_data`](https://www.openssl.org/docs/manmaster/man3/SSL_write_early_data.html)."write_early_data" Initiates the handshake."" This will fail if `set_accept_state` or `set_connect_state` was not called first."do_handshake" Perform a stateless server-side handshake."" Requires that cookie generation and verification callbacks were"" set on the SSL context."" Returns `Ok(true)` if a complete ClientHello containing a valid cookie"" was read, in which case the handshake should be continued via"" `accept`. If a HelloRetryRequest containing a fresh cookie was"" transmitted, `Ok(false)` is returned instead. If the handshake cannot"" proceed at all, `Err` is returned.""This corresponds to [`SSL_stateless`](https://www.openssl.org/docs/manmaster/man3/SSL_stateless.html)."stateless" Like `read`, but takes a possibly-uninitialized slice."" No portion of `buf` will be de-initialized by this method. If the method returns `Ok(n)`,"" then the first `n` bytes of `buf` are guaranteed to be initialized.""This corresponds to [`SSL_read_ex`](https://www.openssl.org/docs/manmaster/man3/SSL_read_ex.html)."read_uninit" Like `read`, but returns an `ssl::Error` rather than an `io::Error`."" It is particularly useful with a non-blocking socket, where the error value will identify if"" OpenSSL is waiting on read or write readiness."ssl_read" Like `read_ssl`, but takes a possibly-uninitialized slice."ssl_read_uninit" Like `write`, but returns an `ssl::Error` rather than an `io::Error`.""This corresponds to [`SSL_write_ex`](https://www.openssl.org/docs/manmaster/man3/SSL_write_ex.html)."ssl_write" Reads data from the stream, without removing it from the queue.""This corresponds to [`SSL_peek_ex`](https://www.openssl.org/docs/manmaster/man3/SSL_peek_ex.html)."ssl_peek" Shuts down the session."" The shutdown process consists of two steps. The first step sends a close notify message to"" the peer, after which `ShutdownResult::Sent` is returned. The second step awaits the receipt"" of a close notify message from the peer, after which `ShutdownResult::Received` is returned."" While the connection may be closed after the first step, it is recommended to fully shut the"" session down. In particular, it must be fully shut down if the connection is to be used for"" further communication in the future.""This corresponds to [`SSL_shutdown`](https://www.openssl.org/docs/manmaster/man3/SSL_shutdown.html)."ShutdownResult" Returns the session\'s shutdown state.""This corresponds to [`SSL_get_shutdown`](https://www.openssl.org/docs/manmaster/man3/SSL_get_shutdown.html)."get_shutdownShutdownState" Sets the session\'s shutdown state."" This can be used to tell OpenSSL that the session should be cached even if a full two-way"" shutdown was not completed.""This corresponds to [`SSL_set_shutdown`](https://www.openssl.org/docs/manmaster/man3/SSL_set_shutdown.html)."set_shutdownget_bio_error/// Returns a shared reference to the underlying stream./// Returns a mutable reference to the underlying stream./// It is inadvisable to read from or write to the underlying stream as it/// will most likely corrupt the SSL session./// Returns a shared reference to the `Ssl` object associated with this stream.SslStreamBuilder/// A partially constructed `SslStream`, useful for unusual handshakes./// Begin creating an `SslStream` atop `stream`" Perform a stateless server-side handshake"/// See `Ssl::connect`/// See `Ssl::accept`" Read application data transmitted by a client before handshake"" completion."" `set_accept_state` first."" `set_connect_state` first."/// Returns a shared reference to the `Ssl` object associated with this builder./// Set the DTLS MTU size./// It will be ignored if the value is smaller than the minimum packet size/// the DTLS protocol requires./// This function panics if the given mtu size can't be represented in a positive `c_long` rangeSent/// A close notify message has been sent to the peer.Received/// A close notify response message has been received from the peer./// The result of a shutdown request.r" The shutdown state of a session."r" A close notify message has been sent to the peer."SENTr" A close notify message has been received from the peer."RECEIVEDSSL_CTX_up_refSSL_SESSION_get_master_keySSL_SESSION_up_refSSL_is_serverSSL_get1_peer_certificateTLS_methodDTLS_methodTLS_client_methodTLS_server_methodget_new_idxCRYPTO_EX_freeget_new_ssl_idx//! SSL/TLS support.//! `SslConnector` and `SslAcceptor` should be used in most cases - they handle//! configuration of the OpenSSL primitives for you.//! use openssl::ssl::{SslMethod, SslConnector};//! let connector = SslConnector::builder(SslMethod::tls()).unwrap().build();//! use openssl::ssl::{SslMethod, SslAcceptor, SslStream, SslFiletype};//! let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();//! acceptor.set_private_key_file("key.pem", SslFiletype::PEM).unwrap();//! acceptor.set_certificate_chain_file("certs.pem").unwrap();//! acceptor.check_private_key().unwrap();//! let acceptor = Arc::new(acceptor.build());//! fn handle_client(stream: SslStream<TcpStream>) {X509CheckFlagsROOT_CERTCERTverify_untrustedverify_trustedverify_trusted_with_set_certverify_untrusted_callback_override_okverify_untrusted_callback_override_badverify_trusted_callback_override_okverify_trusted_callback_override_badverify_callback_load_certsverify_trusted_get_error_okverify_trusted_get_error_errverify_callbackssl_verify_callbackget_ctx_optionsset_ctx_optionsclear_ctx_optionszero_length_bufferspeer_tmp_key_p384// when a connection uses ECDHE P-384 key exchange, then the temp key APIs// return P-384 keys, and the peer and local keys are different.peer_tmp_key_rsa// when a connection uses RSA key exchange, then the peer (server) temp key is// an Error because there is no temp key, and the local (client) temp key is the// temp key sent in the initial key share.test_connect_with_srtp_ctx/// Tests that when both the client as well as the server use SRTP and their/// lists of supported protocols have an overlap -- with only ONE protocol/// being valid for both.test_connect_with_srtp_ssltest_alpn_server_advertise_multiple/// Tests that when the `SslStream` is created as a server stream, the protocols/// are correctly advertised to the client.test_alpn_server_select_none_fataltest_alpn_server_select_nonetest_alpn_server_unilateralwrite_panicread_panicflush_panicrefcount_ssl_contextdefault_verify_pathsverify_valid_hostnameverify_invalid_hostnameconnector_valid_hostnameconnector_invalid_hostnameconnector_invalid_no_hostname_verificationconnector_no_hostname_still_verifiesconnector_can_disable_verifyconnector_does_use_sni_with_dnsnamesconnector_doesnt_use_sni_with_ipstest_mozilla_serverconnector_client_server_mozilla_intermediateconnector_client_server_mozilla_modernconnector_client_server_mozilla_intermediate_v5connector_client_server_mozilla_modern_v5client_ca_listtmp_dh_callbacktmp_dh_callback_sslidle_sessionactive_session/// LibreSSL 3.2.1 enabled TLSv1.3 by default for clients and sessions do/// not work due to lack of PSK support. The test passes with NO_TLSV1_3,/// but let's ignore it until LibreSSL supports it out of the box.status_callbacksnew_session_callbacknew_session_callback_swapped_ctxkeying_exportno_version_overlapcustom_extensionspsk_cipherssni_callback_swapped_ctxclient_helloopenssl_cipher_nameset_ssl_certificate_key_related_apitest_ssl_set_cert_chain_filessl_ctx_ex_data_leakssl_ex_data_leakconnect_tcpssl_cbio_cbshould_errorconnect_errClientSslBuilderOPENSSL_sk_popOPENSSL_sk_freeOPENSSL_sk_numOPENSSL_sk_valueOPENSSL_STACKOPENSSL_sk_new_nullOPENSSL_sk_push/// The C stack type for this element./// Generally called `stack_st_{ELEMENT_TYPE}`, normally hidden by the/// `STACK_OF(ELEMENT_TYPE)` macro in the OpenSSL API./// Trait implemented by types which can be placed in a stack./// It should not be implemented for any type outside of this crate./// An owned stack of `T`.idxsas_stack/// Returns the number of items in the stack./// Determines if the stack is empty./// Returns a reference to the element at the given index in the/// stack or `None` if the index is out of bounds/// Returns a mutable reference to the element at the given index in the/// Pushes a value onto the top of the stack./// Removes the last element from the stack and returns it./// An iterator over the stack's contents./// A mutable iterator over the stack's contents.OpensslStringRefstack_st_OPENSSL_STRINGEncrypt/// Represents a particular cipher algorithm./// See OpenSSL doc at [`EVP_EncryptInit`] for more information on each algorithms./// [`EVP_EncryptInit`]: https://www.openssl.org/docs/manmaster/crypto/EVP_EncryptInit.html/// Creates a `Cipher` from a raw pointer to its OpenSSL type./// The caller must ensure the pointer is valid for the `'static` lifetime./// Returns the length of keys used with this cipher.iv_len/// Returns the length of the IV used with this cipher, or `None` if the/// cipher does not use an IV./// Returns the block size of the cipher./// Stream ciphers such as RC4 have a block size of 1.is_ccm/// Determines whether the cipher is using CCM modeis_ocb/// Determines whether the cipher is using OCB modeCrypter/// Represents a symmetric cipher context./// Padding is enabled by default./// Encrypt some plaintext in chunks, then decrypt the ciphertext back into plaintext, in AES 128/// CBC mode./// use openssl::symm::{Cipher, Mode, Crypter};/// let plaintexts: [&[u8]; 2] = [b"Some Stream of", b" Crypto Text"];/// let key = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";/// let iv = b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07";/// let data_len = plaintexts.iter().fold(0, |sum, x| sum + x.len());/// // Create a cipher context for encryption./// let mut encrypter = Crypter::new(///     Cipher::aes_128_cbc(),///     Mode::Encrypt,///     key,///     Some(iv)).unwrap();/// let block_size = Cipher::aes_128_cbc().block_size();/// let mut ciphertext = vec![0; data_len + block_size];/// // Encrypt 2 chunks of plaintexts successively./// let mut count = encrypter.update(plaintexts[0], &mut ciphertext).unwrap();/// count += encrypter.update(plaintexts[1], &mut ciphertext[count..]).unwrap();/// count += encrypter.finalize(&mut ciphertext[count..]).unwrap();/// ciphertext.truncate(count);///     b"\x0F\x21\x83\x7E\xB2\x88\x04\xAF\xD9\xCC\xE2\x03\x49\xB4\x88\xF6\xC4\x61\x0E\x32\x1C\xF9\///       \x0D\x66\xB1\xE6\x2C\x77\x76\x18\x8D\x99",///     &ciphertext[..]/// // Let's pretend we don't know the plaintext, and now decrypt the ciphertext./// let data_len = ciphertext.len();/// let ciphertexts = [&ciphertext[..9], &ciphertext[9..]];/// // Create a cipher context for decryption./// let mut decrypter = Crypter::new(///     Mode::Decrypt,/// let mut plaintext = vec![0; data_len + block_size];/// // Decrypt 2 chunks of ciphertexts successively./// let mut count = decrypter.update(ciphertexts[0], &mut plaintext).unwrap();/// count += decrypter.update(ciphertexts[1], &mut plaintext[count..]).unwrap();/// count += decrypter.finalize(&mut plaintext[count..]).unwrap();/// plaintext.truncate(count);/// assert_eq!(b"Some Stream of Crypto Text", &plaintext[..]);/// Creates a new `Crypter`.  The initialisation vector, `iv`, is not necessary for certain/// types of `Cipher`./// Panics if an IV is required by the cipher but not provided.  Also make sure that the key/// and IV size are appropriate for your cipher./// Enables or disables padding./// If padding is disabled, total amount of data encrypted/decrypted must/// be a multiple of the cipher's block size./// Sets the tag used to authenticate ciphertext in AEAD ciphers such as AES GCM./// When decrypting cipher text using an AEAD cipher, this must be called before `finalize`.set_tag_len/// Sets the length of the authentication tag to generate in AES CCM./// When encrypting with AES CCM, the tag length needs to be explicitly set in order/// to use a value different than the default 12 bytes./// Feeds total plaintext length to the cipher./// The total plaintext or ciphertext length MUST be passed to the cipher when it operates in/// CCM mode.aad_update/// Feeds Additional Authenticated Data (AAD) through the cipher./// This can only be used with AEAD ciphers such as AES GCM. Data fed in is not encrypted, but/// is factored into the authentication tag. It must be called before the first call to/// `update`./// Feeds data from `input` through the cipher, writing encrypted/decrypted/// bytes into `output`./// Panics for stream ciphers if `output.len() < input.len()`./// Panics for block ciphers if `output.len() < input.len() + block_size`,/// where `block_size` is the block size of the cipher (see `Cipher::block_size`)./// Panics if `output.len() > c_int::MAX`.update_unchecked/// The caller must provide an `output` buffer large enough to contain/// correct number of bytes. For streaming ciphers the output buffer size/// should be at least as big as the input buffer. For block ciphers the/// size of the output buffer depends on the state of partially updated/// blocks./// Finishes the encryption/decryption process, writing any remaining data/// to `output`./// Panics for block ciphers if `output.len() < block_size`,/// Retrieves the authentication tag used to authenticate ciphertext in AEAD ciphers such/// as AES GCM./// When encrypting data with an AEAD cipher, this must be called after `finalize`./// The size of the buffer indicates the required size of the tag. While some ciphers support a/// range of tag sizes, it is recommended to pick the maximum size. For AES GCM, this is 16/// bytes, for example./// Encrypts data in one go, and returns the encrypted data./// Data is encrypted using the specified cipher type `t` in encrypt mode with the specified `key`/// and initialization vector `iv`. Padding is enabled./// This is a convenient interface to `Crypter` to encrypt all data in one go.  To encrypt a stream/// of data incrementally , use `Crypter` instead./// Encrypt data in AES128 CBC mode/// use openssl::symm::{encrypt, Cipher};/// let cipher = Cipher::aes_128_cbc();/// let data = b"Some Crypto Text";/// let ciphertext = encrypt(///     cipher,///     Some(iv),///     data).unwrap();///     b"\xB4\xB9\xE7\x30\xD6\xD6\xF7\xDE\x77\x3F\x1C\xFF\xB3\x3E\x44\x5A\x91\xD7\x27\x62\x87\x4D\///       \xFB\x3C\x5E\xC4\x59\x72\x4A\xF4\x7C\xA1",///     &ciphertext[..]);/// Decrypts data in one go, and returns the decrypted data./// Data is decrypted using the specified cipher type `t` in decrypt mode with the specified `key`/// This is a convenient interface to `Crypter` to decrypt all data in one go.  To decrypt a  stream/// Decrypt data in AES128 CBC mode/// use openssl::symm::{decrypt, Cipher};/// let data = b"\xB4\xB9\xE7\x30\xD6\xD6\xF7\xDE\x77\x3F\x1C\xFF\xB3\x3E\x44\x5A\x91\xD7\x27\x62\///              \x87\x4D\xFB\x3C\x5E\xC4\x59\x72\x4A\xF4\x7C\xA1";/// let ciphertext = decrypt(///     b"Some Crypto Text",encrypt_aead/// Like `encrypt`, but for AEAD ciphers such as AES GCM./// Additional Authenticated Data can be provided in the `aad` field, and the authentication tag/// will be copied into the `tag` field./// The size of the `tag` buffer indicates the required size of the tag. While some ciphers support/// a range of tag sizes, it is recommended to pick the maximum size. For AES GCM, this is 16 bytes,decrypt_aead/// Like `decrypt`, but for AEAD ciphers such as AES GCM./// should be provided in the `tag` field.test_stream_cipher_outputtest_aes_256_ecb// Test vectors from FIPS-197:// http://csrc.nist.gov/publications/fips/fips197/fips-197.pdftest_aes_256_cbc_decryptcipher_testcipher_test_nopadtest_rc4test_aes256_xtstest_aes128_ctrtest_aes128_cfb1test_aes128_cfb128test_aes128_cfb8test_aes128_ofbtest_aes192_ctrtest_aes192_cfb1test_aes192_cfb128test_aes192_cfb8test_aes192_ofbtest_aes256_cfb1test_aes256_cfb128test_aes256_cfb8test_aes256_ofbtest_bf_cbctest_bf_ecbtest_bf_cfb64test_bf_ofbtest_des_cbctest_des_ecbtest_des_ede3test_des_ede3_cbctest_des_ede3_cfb64test_aes128_gcmtest_aes128_ccmtest_aes128_ccm_verify_failtest_aes256_ccmtest_aes256_ccm_verify_failtest_aes_128_ocbtest_aes_128_ocb_failtest_chacha20test_chacha20_poly1305test_sm4_ecb// GB/T 32907-2016// http://openstd.samr.gov.cn/bzgk/gb/newGbInfo?hcno=7803DE42D3BC5E80B0C3E5D8E873D56A//! High level interface to certain symmetric ciphers.//! Encrypt data in AES128 CBC mode//! use openssl::symm::{encrypt, Cipher};//! let ciphertext = encrypt(//!     cipher,//!     key,//!     Some(iv),//!     data).unwrap();//!     &ciphertext[..]);//! Encrypting an asymmetric key with a symmetric cipher//! use openssl::rsa::{Padding, Rsa};//! // Generate keypair and encrypt private key://! let pubkey_pem = keypair.public_key_to_pem_pkcs1().unwrap();//! let privkey_pem = keypair.private_key_to_pem_passphrase(cipher, b"Rust").unwrap();//! // pubkey_pem and privkey_pem could be written to file here.//! // Load private and public key from string://! let pubkey = Rsa::public_key_from_pem_pkcs1(&pubkey_pem).unwrap();//! let privkey = Rsa::private_key_from_pem_passphrase(&privkey_pem, b"Rust").unwrap();//! // Use the asymmetric keys to encrypt and decrypt a short message://! let msg = b"Foo bar";//! let mut encrypted = vec![0; pubkey.size() as usize];//! let mut decrypted = vec![0; privkey.size() as usize];//! let len = pubkey.public_encrypt(msg, &mut encrypted, Padding::PKCS1).unwrap();//! assert!(len > msg.len());//! let len = privkey.private_decrypt(&encrypted, &mut decrypted, Padding::PKCS1).unwrap();//! let output_string = String::from_utf8(decrypted[..len].to_vec()).unwrap();//! assert_eq!("Foo bar", output_string);//! println!("Decrypted: '{}'", output_string);/// The user callback. Taken out of the `Option` when called./// If the callback panics, we place the panic object here, to be re-thrown once OpenSSL/// returns./// Wraps a user-supplied callback and a slot for panics thrown inside the callback (while FFI/// frames are on the stack)./// When dropped, checks if the callback has panicked, and resumes unwinding if so./// Password callback function, passed to private key loading functions./// `cb_state` is expected to be a pointer to a `CallbackState`.from_ptr_optFTfrom_const_ptrfrom_const_ptr_opt/// The same as `slice::from_raw_parts`, except that `data` may be `NULL` if/// `len` is 0./// The same as `slice::from_raw_parts_mut`, except that `data` may be `NULL`/// if `len` is 0.OPENSSL_VERSIONOPENSSL_CFLAGSOPENSSL_BUILT_ONOPENSSL_PLATFORMOPENSSL_DIROpenSSL_version_numOpenSSL_version" OPENSSL_VERSION_NUMBER is a numeric release version identifier:"" `MNNFFPPS: major minor fix patch status`"" The status nibble has one of the values 0 for development, 1 to e for betas 1 to 14, and f for release."" for example"" `0x000906000 == 0.9.6 dev`"" `0x000906023 == 0.9.6b beta 3`"" `0x00090605f == 0.9.6e release`""This corresponds to [`OpenSSL_version_num`](https://www.openssl.org/docs/manmaster/man3/OpenSSL_version_num.html)."" The text variant of the version number and the release date. For example, \"OpenSSL 0.9.5a 1 Apr 2000\".""This corresponds to [`OpenSSL_version`](https://www.openssl.org/docs/manmaster/man3/OpenSSL_version.html)."" The compiler flags set for the compilation process in the form \"compiler: ...\" if available or"" \"compiler: information not available\" otherwise."c_flags" The date of the build process in the form \"built on: ...\" if available or \"built on: date not available\" otherwise."built_on" The \"Configure\" target of the library build in the form \"platform: ...\" if available or \"platform: information not available\" otherwise."" The \"OPENSSLDIR\" setting of the library build in the form \"OPENSSLDIR: \"...\"\" if available or \"OPENSSLDIR: N/A\" otherwise."test_versions/// This test ensures that we do not segfault when calling the functions of this module/// and that the strings respect a reasonable format.//     http://www.apache.org/licenses/LICENSE-2.0//! Build and version information.GeneralNameX509ExtensionX509v3ContextpathlenBasicConstraints/// An extension which indicates whether a certificate is a CA certificate./// Construct a new `BasicConstraints` extension./// Sets the `critical` flag to `true`. The extension will be critical./// Sets the `ca` flag to `true`./// Sets the `pathlen` to an optional non-negative value. The `pathlen` is the/// maximum number of CAs that can appear below this one in a chain./// Return the `BasicConstraints` extension as an `X509Extension`.// Temporarily silence the deprecation warning - this should be ported to// `X509Extension::new_internal`.digital_signaturenon_repudiationkey_enciphermentdata_enciphermentkey_agreementkey_cert_signcrl_signencipher_onlydecipher_only/// An extension consisting of a list of names of the permitted key usages./// Construct a new `KeyUsage` extension./// Sets the `digitalSignature` flag to `true`./// Sets the `nonRepudiation` flag to `true`./// Sets the `keyEncipherment` flag to `true`./// Sets the `dataEncipherment` flag to `true`./// Sets the `keyAgreement` flag to `true`./// Sets the `keyCertSign` flag to `true`./// Sets the `cRLSign` flag to `true`./// Sets the `encipherOnly` flag to `true`./// Sets the `decipherOnly` flag to `true`./// Return the `KeyUsage` extension as an `X509Extension`.ExtendedKeyUsage/// An extension consisting of a list of usages indicating purposes/// for which the certificate public key can be used for./// Construct a new `ExtendedKeyUsage` extension.server_auth/// Sets the `serverAuth` flag to `true`./// Sets the `clientAuth` flag to `true`.code_signing/// Sets the `codeSigning` flag to `true`.email_protection/// Sets the `emailProtection` flag to `true`.time_stamping/// Sets the `timeStamping` flag to `true`.ms_code_ind/// Sets the `msCodeInd` flag to `true`.ms_code_com/// Sets the `msCodeCom` flag to `true`.ms_ctl_sign/// Sets the `msCTLSign` flag to `true`.ms_sgc/// Sets the `msSGC` flag to `true`.ms_efs/// Sets the `msEFS` flag to `true`.ns_sgc/// Sets the `nsSGC` flag to `true`./// Sets a flag not already defined./// Return the `ExtendedKeyUsage` extension as an `X509Extension`.SubjectKeyIdentifier/// An extension that provides a means of identifying certificates that contain a/// particular public key./// Construct a new `SubjectKeyIdentifier` extension./// Return a `SubjectKeyIdentifier` extension as an `X509Extension`.keyidAuthorityKeyIdentifier/// An extension that provides a means of identifying the public key corresponding/// to the private key used to sign a CRL./// Construct a new `AuthorityKeyIdentifier` extension./// Sets the `keyid` flag./// Sets the `issuer` flag./// Return a `AuthorityKeyIdentifier` extension as an `X509Extension`.RustGeneralNameDnsRidOtherNameSubjectAlternativeName/// An extension that allows additional identities to be bound to the subject/// of the certificate./// Construct a new `SubjectAlternativeName` extension./// Sets the `email` flag./// Sets the `uri` flag./// Sets the `dns` flag.rid/// Sets the `rid` flag./// Sets the `ip` flag."dir_name is deprecated and always panics. Please file a bug if you have a use case for this."dir_name/// Sets the `dirName` flag./// Not currently actually supported, always panics."other_name is deprecated and always panics. Please use other_name2."other_name/// Sets the `otherName` flag./// Not currently actually supported, always panics. Please use other_name2other_name2/// `content` must be a valid der encoded ASN1_TYPE/// If you want to add just a ia5string use `other_name_ia5string`/// Return a `SubjectAlternativeName` extension as an `X509Extension`.//! Add extensions to an `X509` certificate or certificate request.//! The extensions defined for X.509 v3 certificates provide methods for//! associating additional attributes with users or public keys and for//! managing relationships between CAs. The extensions created using this//! module can be used with `X509v3Context` objects.//! use openssl::x509::extension::BasicConstraints;//! use openssl::x509::X509Extension;//! let mut bc = BasicConstraints::new();//! let bc = bc.critical().ca().pathlen(1);//! let extension: X509Extension = bc.build().unwrap();NIDExtensionType/// A type of X509 extension./// The value of NID and Output must match those in OpenSSL so that/// `Output::from_ptr_opt(*_get_ext_d2i(*, NID, ...))` is valid.r" An `X509` certificate store context."r" A reference to an [`X509StoreContext`]."" Returns the index which can be used to obtain a reference to the `Ssl` associated with a"" context.""This corresponds to [`SSL_get_ex_data_X509_STORE_CTX_idx`](https://www.openssl.org/docs/manmaster/man3/SSL_get_ex_data_X509_STORE_CTX_idx.html)."ssl_idx" Creates a new `X509StoreContext` instance.""This corresponds to [`X509_STORE_CTX_new`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_new.html)."" Returns application data pertaining to an `X509` store context.""This corresponds to [`X509_STORE_CTX_get_ex_data`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_get_ex_data.html)."" Returns the error code of the context.""This corresponds to [`X509_STORE_CTX_get_error`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_get_error.html)."/// Initializes this context with the given certificate, certificates chain and certificate/// store. After initializing the context, the `with_context` closure is called with the prepared/// context. As long as the closure is running, the context stays initialized and can be used/// to e.g. verify a certificate. The context will be cleaned up, after the closure finished./// * `trust` - The certificate store with the trusted certificates./// * `cert` - The certificate that should be verified./// * `cert_chain` - The certificates chain./// * `with_context` - The closure that is called with the initialized context./// This corresponds to [`X509_STORE_CTX_init`] before calling `with_context` and to/// [`X509_STORE_CTX_cleanup`] after calling `with_context`./// [`X509_STORE_CTX_init`]:  https://www.openssl.org/docs/manmaster/crypto/X509_STORE_CTX_init.html/// [`X509_STORE_CTX_cleanup`]:  https://www.openssl.org/docs/manmaster/crypto/X509_STORE_CTX_cleanup.html" Verifies the stored certificate."" Returns `true` if verification succeeds. The `error` method will return the specific"" validation error if the certificate was not valid."" This will only work inside of a call to `init`.""This corresponds to [`X509_verify_cert`](https://www.openssl.org/docs/manmaster/man3/X509_verify_cert.html)."verify_cert" Set the error code of the context.""This corresponds to [`X509_STORE_CTX_set_error`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_set_error.html)."" Returns a reference to the certificate which caused the error or None if"" no certificate is relevant to the error.""This corresponds to [`X509_STORE_CTX_get_current_cert`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_get_current_cert.html)."current_cert" Returns a non-negative integer representing the depth in the certificate"" chain where the error occurred. If it is zero it occurred in the end"" entity certificate, one if it is the certificate which signed the end"" entity certificate and so on.""This corresponds to [`X509_STORE_CTX_get_error_depth`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_get_error_depth.html)."error_depth" Returns a reference to a complete valid `X509` certificate chain.""This corresponds to [`X509_STORE_CTX_get0_chain`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_CTX_get0_chain.html)."X509Builder/// A builder used to construct an `X509`." Creates a new builder.""This corresponds to [`X509_new`](https://www.openssl.org/docs/manmaster/man3/X509_new.html)."" Sets the notAfter constraint on the certificate.""This corresponds to [`X509_set1_notAfter`](https://www.openssl.org/docs/manmaster/man3/X509_set1_notAfter.html)."set_not_after" Sets the notBefore constraint on the certificate.""This corresponds to [`X509_set1_notBefore`](https://www.openssl.org/docs/manmaster/man3/X509_set1_notBefore.html)."set_not_before" Sets the version of the certificate."" Note that the version is zero-indexed; that is, a certificate corresponding to version 3 of"" the X.509 standard should pass `2` to this method.""This corresponds to [`X509_set_version`](https://www.openssl.org/docs/manmaster/man3/X509_set_version.html)."" Sets the serial number of the certificate.""This corresponds to [`X509_set_serialNumber`](https://www.openssl.org/docs/manmaster/man3/X509_set_serialNumber.html)."set_serial_number" Sets the issuer name of the certificate.""This corresponds to [`X509_set_issuer_name`](https://www.openssl.org/docs/manmaster/man3/X509_set_issuer_name.html)."set_issuer_nameX509NameRef" Sets the subject name of the certificate."" When building certificates, the `C`, `ST`, and `O` options are common when using the openssl command line tools."" The `CN` field is used for the common name, such as a DNS name."" use openssl::x509::{X509, X509NameBuilder};"" let mut x509_name = openssl::x509::X509NameBuilder::new().unwrap();"" x509_name.append_entry_by_text(\"C\", \"US\").unwrap();"" x509_name.append_entry_by_text(\"ST\", \"CA\").unwrap();"" x509_name.append_entry_by_text(\"O\", \"Some organization\").unwrap();"" x509_name.append_entry_by_text(\"CN\", \"www.example.com\").unwrap();"" let x509_name = x509_name.build();"" let mut x509 = openssl::x509::X509::builder().unwrap();"" x509.set_subject_name(&x509_name).unwrap();""This corresponds to [`X509_set_subject_name`](https://www.openssl.org/docs/manmaster/man3/X509_set_subject_name.html)."set_subject_name" Sets the public key associated with the certificate.""This corresponds to [`X509_set_pubkey`](https://www.openssl.org/docs/manmaster/man3/X509_set_pubkey.html)."set_pubkey" Returns a context object which is needed to create certain X509 extension values."" Set `issuer` to `None` if the certificate will be self-signed.""This corresponds to [`X509V3_set_ctx`](https://www.openssl.org/docs/manmaster/man3/X509V3_set_ctx.html)."x509v3_contextappend_extension/// Adds an X509 extension value to the certificate./// This works just as `append_extension` except it takes ownership of the `X509Extension`." Adds an X509 extension value to the certificate.""This corresponds to [`X509_add_ext`](https://www.openssl.org/docs/manmaster/man3/X509_add_ext.html)."append_extension2X509ExtensionRef" Signs the certificate with a private key.""This corresponds to [`X509_sign`](https://www.openssl.org/docs/manmaster/man3/X509_sign.html)."/// Consumes the builder, returning the certificate.r" An `X509` public key certificate."r" Reference to `X509`."" Returns this certificate\'s subject name.""This corresponds to [`X509_get_subject_name`](https://www.openssl.org/docs/manmaster/man3/X509_get_subject_name.html)."subject_name" Returns the hash of the certificates subject""This corresponds to [`X509_subject_name_hash`](https://www.openssl.org/docs/manmaster/man3/X509_subject_name_hash.html)."subject_name_hash" Returns this certificate\'s issuer name.""This corresponds to [`X509_get_issuer_name`](https://www.openssl.org/docs/manmaster/man3/X509_get_issuer_name.html)."issuer_name" Returns the hash of the certificates issuer""This corresponds to [`X509_issuer_name_hash`](https://www.openssl.org/docs/manmaster/man3/X509_issuer_name_hash.html)."issuer_name_hash" Returns this certificate\'s subject alternative name entries, if they exist.""This corresponds to [`X509_get_ext_d2i`](https://www.openssl.org/docs/manmaster/man3/X509_get_ext_d2i.html)."subject_alt_names" Returns this certificate\'s CRL distribution points, if they exist."crl_distribution_pointsDistPoint" Returns this certificate\'s issuer alternative name entries, if they exist."issuer_alt_names" Returns this certificate\'s [`authority information access`] entries, if they exist."" [`authority information access`]: https://tools.ietf.org/html/rfc5280#section-4.2.2.1"authority_infoAccessDescription" Retrieves the path length extension from a certificate, if it exists.""This corresponds to [`X509_get_pathlen`](https://www.openssl.org/docs/manmaster/man3/X509_get_pathlen.html)."" Returns this certificate\'s subject key id, if it exists.""This corresponds to [`X509_get0_subject_key_id`](https://www.openssl.org/docs/manmaster/man3/X509_get0_subject_key_id.html)."subject_key_id" Returns this certificate\'s authority key id, if it exists.""This corresponds to [`X509_get0_authority_key_id`](https://www.openssl.org/docs/manmaster/man3/X509_get0_authority_key_id.html)."authority_key_id" Returns this certificate\'s authority issuer name entries, if they exist.""This corresponds to [`X509_get0_authority_issuer`](https://www.openssl.org/docs/manmaster/man3/X509_get0_authority_issuer.html)."authority_issuer" Returns this certificate\'s authority serial number, if it exists.""This corresponds to [`X509_get0_authority_serial`](https://www.openssl.org/docs/manmaster/man3/X509_get0_authority_serial.html)."authority_serial"This corresponds to [`X509_get_pubkey`](https://www.openssl.org/docs/manmaster/man3/X509_get_pubkey.html)."" Returns a digest of the DER representation of the certificate.""This corresponds to [`X509_digest`](https://www.openssl.org/docs/manmaster/man3/X509_digest.html)."fingerprint" Returns the certificate\'s Not After validity period.""This corresponds to [`X509_getm_notAfter`](https://www.openssl.org/docs/manmaster/man3/X509_getm_notAfter.html)."not_after" Returns the certificate\'s Not Before validity period.""This corresponds to [`X509_getm_notBefore`](https://www.openssl.org/docs/manmaster/man3/X509_getm_notBefore.html)."not_before" Returns the certificate\'s signature""This corresponds to [`X509_get0_signature`](https://www.openssl.org/docs/manmaster/man3/X509_get0_signature.html)."" Returns the certificate\'s signature algorithm."signature_algorithmX509AlgorithmRef" Returns the list of OCSP responder URLs specified in the certificate\'s Authority Information"" Access field.""This corresponds to [`X509_get1_ocsp`](https://www.openssl.org/docs/manmaster/man3/X509_get1_ocsp.html)."ocsp_responders" Checks that this certificate issued `subject`.""This corresponds to [`X509_check_issued`](https://www.openssl.org/docs/manmaster/man3/X509_check_issued.html)."issued" Returns certificate version. If this certificate has no explicit version set, it defaults to"" version 1."" Note that `0` return value stands for version 1, `1` for version 2 and so on.""This corresponds to [`X509_get_version`](https://www.openssl.org/docs/manmaster/man3/X509_get_version.html)."" Check if the certificate is signed using the given public key."" Only the signature is checked: no other checks (such as certificate chain validity)"" are performed."" Returns `true` if verification succeeds.""This corresponds to [`X509_verify`](https://www.openssl.org/docs/manmaster/man3/X509_verify.html)."" Returns this certificate\'s serial number.""This corresponds to [`X509_get_serialNumber`](https://www.openssl.org/docs/manmaster/man3/X509_get_serialNumber.html)."" Returns this certificate\'s \"alias\". This field is populated by"" OpenSSL in some situations -- specifically OpenSSL will store a"" PKCS#12 `friendlyName` in this field. This is not a part of the X.509"" certificate itself, OpenSSL merely attaches it to this structure in"" memory.""This corresponds to [`X509_alias_get0`](https://www.openssl.org/docs/manmaster/man3/X509_alias_get0.html)."r" Serializes the certificate into a PEM-encoded X509 structure."r" The output will have a header of `-----BEGIN CERTIFICATE-----`.""This corresponds to [`PEM_write_bio_X509`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_X509.html)."r" Serializes the certificate into a DER-encoded X509 structure.""This corresponds to [`i2d_X509`](https://www.openssl.org/docs/manmaster/man3/i2d_X509.html)."r" Converts the certificate to human readable text.""This corresponds to [`X509_print`](https://www.openssl.org/docs/manmaster/man3/X509_print.html)."r" Deserializes a PEM-encoded X509 structure."r" The input should have a header of `-----BEGIN CERTIFICATE-----`.""This corresponds to [`PEM_read_bio_X509`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_X509.html)."r" Deserializes a DER-encoded X509 structure.""This corresponds to [`d2i_X509`](https://www.openssl.org/docs/manmaster/man3/d2i_X509.html)."" Deserializes a list of PEM-formatted certificates."stack_from_pemstack_st_X509X509V3_CTX/// A context object required to construct certain `X509` extension values.r" Permit additional fields to be added to an `X509` v3 certificate."X509_EXTENSIONr" Reference to `X509Extension`."stack_st_X509_EXTENSION/// Constructs an X509 extension value. See `man x509v3_config` for information on supported/// names and their value formats./// Some extension types, such as `subjectAlternativeName`, require an `X509v3Context` to be/// DO NOT CALL THIS WITH UNTRUSTED `value`: `value` is an OpenSSL/// mini-language that can read arbitrary files./// See the extension module for builder types which will construct certain common extensions./// This function is deprecated, `X509Extension::new_from_der` or the/// types in `x509::extension` should be used in its place.new_nid/// extensions and their value formats./// Some extension types, such as `nid::SUBJECT_ALTERNATIVE_NAME`, require an `X509v3Context` to/// be provided.new_from_der/// Constructs a new X509 extension value from its OID, whether it's/// critical, and its DER contents./// The extent structure of the DER value will vary based on the/// extension type, and can generally be found in the RFC defining the/// For common extension types, there are Rust APIs provided in/// `openssl::x509::extensions` which are more ergonomic." Adds an alias for an extension"" This method modifies global state without locking and therefore is not thread safe""This corresponds to [`X509V3_EXT_add_alias`](https://www.openssl.org/docs/manmaster/man3/X509V3_EXT_add_alias.html)."add_aliasr" Serializes the Extension to its standard DER encoding.""This corresponds to [`i2d_X509_EXTENSION`](https://www.openssl.org/docs/manmaster/man3/i2d_X509_EXTENSION.html)."X509NameBuilder/// A builder used to construct an `X509Name`./// Creates a new builder." Add a name entry""This corresponds to [`X509_NAME_add_entry`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_add_entry.html)."X509NameEntryRef" Add a field entry by str.""This corresponds to [`X509_NAME_add_entry_by_txt`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_add_entry_by_txt.html)."append_entry_by_text" Add a field entry by str with a specific type."append_entry_by_text_with_type" Add a field entry by NID.""This corresponds to [`X509_NAME_add_entry_by_NID`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_add_entry_by_NID.html)."append_entry_by_nid" Add a field entry by NID with a specific type."append_entry_by_nid_with_type/// Return an `X509Name`.r" The names of an `X509` certificate."X509_NAMEr" Reference to `X509Name`."load_client_ca_file/// Loads subject names from a file containing PEM-formatted certificates./// This is commonly used in conjunction with `SslContextBuilder::set_client_ca_list`.r" Deserializes a DER-encoded X509 name structure."r" This corresponds to [`d2i_X509_NAME`]."r" [`d2i_X509_NAME`]: https://www.openssl.org/docs/manmaster/man3/d2i_X509_NAME.html"stack_st_X509_NAMEentries_by_nidX509NameEntries/// Returns the name entries by the nid./// Returns an iterator over all `X509NameEntry` values" Compare two names, like [`Ord`] but it may fail."" With OpenSSL versions from 3.0.0 this may return an error if the underlying `X509_NAME_cmp`"" call fails."" For OpenSSL versions before 3.0.0 it will never return an error, but due to a bug it may"" spuriously return `Ordering::Less` if the `X509_NAME_cmp` call fails.""This corresponds to [`X509_NAME_cmp`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_cmp.html)."try_cmp" Copies the name to a new `X509Name`.""This corresponds to [`X509_NAME_dup`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_dup.html)."r" Serializes the certificate into a DER-encoded X509 name structure."r" This corresponds to [`i2d_X509_NAME`]."r" [`i2d_X509_NAME`]: https://www.openssl.org/docs/manmaster/crypto/i2d_X509_NAME.html"/// A type to destructure and examine an `X509Name`.r" A name entry associated with a `X509Name`."X509_NAME_ENTRYX509NameEntryr" Reference to `X509NameEntry`."" Returns the field value of an `X509NameEntry`.""This corresponds to [`X509_NAME_ENTRY_get_data`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_ENTRY_get_data.html)."" Returns the `Asn1Object` value of an `X509NameEntry`."" This is useful for finding out about the actual `Nid` when iterating over all `X509NameEntries`.""This corresponds to [`X509_NAME_ENTRY_get_object`](https://www.openssl.org/docs/manmaster/man3/X509_NAME_ENTRY_get_object.html)."X509ReqX509ReqBuilder/// A builder used to construct an `X509Req`." Returns a builder for a certificate request.""This corresponds to [`X509_REQ_new`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_new.html)."" Set the numerical value of the version field.""This corresponds to [`X509_REQ_set_version`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_set_version.html)."" Set the issuer name.""This corresponds to [`X509_REQ_set_subject_name`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_set_subject_name.html)."" Set the public key.""This corresponds to [`X509_REQ_set_pubkey`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_set_pubkey.html)."/// Return an `X509v3Context`. This context object can be used to construct/// certain `X509` extensions.add_extensions/// Permits any number of extension fields to be added to the certificate." Sign the request using a private key.""This corresponds to [`X509_REQ_sign`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_sign.html)."/// Returns the `X509Req`.r" An `X509` certificate request."X509_REQX509ReqRefr" Reference to `X509Req`."/// A builder for `X509Req`.r" Deserializes a PEM-encoded PKCS#10 certificate request structure."r" The input should have a header of `-----BEGIN CERTIFICATE REQUEST-----`."r" This corresponds to [`PEM_read_bio_X509_REQ`]."r" [`PEM_read_bio_X509_REQ`]: https://www.openssl.org/docs/manmaster/crypto/PEM_read_bio_X509_REQ.html"r" Deserializes a DER-encoded PKCS#10 certificate request structure."r" This corresponds to [`d2i_X509_REQ`]."r" [`d2i_X509_REQ`]: https://www.openssl.org/docs/manmaster/crypto/d2i_X509_REQ.html"r" Serializes the certificate request to a PEM-encoded PKCS#10 structure."r" The output will have a header of `-----BEGIN CERTIFICATE REQUEST-----`."r" This corresponds to [`PEM_write_bio_X509_REQ`]."r" [`PEM_write_bio_X509_REQ`]: https://www.openssl.org/docs/manmaster/crypto/PEM_write_bio_X509_REQ.html"r" Serializes the certificate request to a DER-encoded PKCS#10 structure."r" This corresponds to [`i2d_X509_REQ`]."r" [`i2d_X509_REQ`]: https://www.openssl.org/docs/manmaster/crypto/i2d_X509_REQ.html"r" Converts the request to human readable text.""This corresponds to [`X509_Req_print`](https://www.openssl.org/docs/manmaster/man3/X509_Req_print.html)."" Returns the numerical value of the version field of the certificate request.""This corresponds to [`X509_REQ_get_version`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_get_version.html)."" Returns the subject name of the certificate request.""This corresponds to [`X509_REQ_get_subject_name`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_get_subject_name.html)."" Returns the public key of the certificate request.""This corresponds to [`X509_REQ_get_pubkey`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_get_pubkey.html)."" Check if the certificate request is signed using the given public key.""This corresponds to [`X509_REQ_verify`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_verify.html)."" Returns the extensions of the certificate request.""This corresponds to [`X509_REQ_get_extensions`](https://www.openssl.org/docs/manmaster/man3/X509_REQ_get_extensions.html)."CrlReason/// The reason that a certificate was revoked.SUPERSEDEDCESSATION_OF_OPERATIONCERTIFICATE_HOLDPRIVILEGE_WITHDRAWNAA_COMPROMISE/// Constructs an `CrlReason` from a raw OpenSSL value.r" An `X509` certificate revocation status."X509_REVOKEDX509RevokedX509RevokedRefr" Reference to `X509Revoked`."stack_st_X509_REVOKEDr" Deserializes a DER-encoded certificate revocation status""This corresponds to [`d2i_X509_REVOKED`](https://www.openssl.org/docs/manmaster/man3/d2i_X509_REVOKED.html)."r" Serializes the certificate request to a DER-encoded certificate revocation status"" Copies the entry to a new `X509Revoked`."" Get the date that the certificate was revoked""This corresponds to [`X509_REVOKED_get0_revocationDate`](https://www.openssl.org/docs/manmaster/man3/X509_REVOKED_get0_revocationDate.html)."revocation_date" Get the serial number of the revoked certificate""This corresponds to [`X509_REVOKED_get0_serialNumber`](https://www.openssl.org/docs/manmaster/man3/X509_REVOKED_get0_serialNumber.html)."" Get the criticality and value of an extension."" This returns None if the extension is not present or occurs multiple times.""This corresponds to [`X509_REVOKED_get_ext_d2i`](https://www.openssl.org/docs/manmaster/man3/X509_REVOKED_get_ext_d2i.html)."ReasonCode/// The CRL entry extension identifying the reason for revocation see [`CrlReason`],/// this is as defined in RFC 5280 Section 5.3.1.// SAFETY: CertificateIssuer is defined to be a stack of GeneralName in the RFC// and in OpenSSL.CertificateIssuer/// The CRL entry extension identifying the issuer of a certificate used in/// indirect CRLs, as defined in RFC 5280 Section 5.3.3.AuthorityInformationAccess/// The CRL extension identifying how to access information and services for the issuer of the CRL// SAFETY: AuthorityInformationAccess is defined to be a stack of AccessDescription in the RFCr" An `X509` certificate revocation list."X509_CRLX509CrlX509CrlRefr" Reference to `X509Crl`."CrlStatusNotRevoked/// The certificate is not present in the listRevoked/// The certificate is in the list and is revokedRemoveFromCrl/// The certificate is in the list, but has the "removeFromCrl" status./// This can occur if the certificate was revoked with the "CertificateHold"/// reason, and has since been unrevoked./// The status of a certificate in a revoction list/// Corresponds to the return value from the [`X509_CRL_get0_by_*`] methods./// [`X509_CRL_get0_by_*`]: https://www.openssl.org/docs/man1.1.0/man3/X509_CRL_get0_by_serial.htmlfrom_ffi_status// Helper used by the X509_CRL_get0_by_* methods to convert their return// value to the status enum.// Safety note: the returned CrlStatus must not outlive the owner of the// revoked_entry pointer.r" Deserializes a PEM-encoded Certificate Revocation List"r" The input should have a header of `-----BEGIN X509 CRL-----`.""This corresponds to [`PEM_read_bio_X509_CRL`](https://www.openssl.org/docs/manmaster/man3/PEM_read_bio_X509_CRL.html)."r" Deserializes a DER-encoded Certificate Revocation List""This corresponds to [`d2i_X509_CRL`](https://www.openssl.org/docs/manmaster/man3/d2i_X509_CRL.html)."r" Serializes the certificate request to a PEM-encoded Certificate Revocation List."r" The output will have a header of `-----BEGIN X509 CRL-----`.""This corresponds to [`PEM_write_bio_X509_CRL`](https://www.openssl.org/docs/manmaster/man3/PEM_write_bio_X509_CRL.html)."r" Serializes the certificate request to a DER-encoded Certificate Revocation List.""This corresponds to [`i2d_X509_CRL`](https://www.openssl.org/docs/manmaster/man3/i2d_X509_CRL.html)."get_revoked/// Get the stack of revocation entries" Returns the CRL\'s `lastUpdate` time.""This corresponds to [`X509_CRL_get0_lastUpdate`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_get0_lastUpdate.html)."" Returns the CRL\'s `nextUpdate` time."" If the `nextUpdate` field is missing, returns `None`.""This corresponds to [`X509_CRL_get0_nextUpdate`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_get0_nextUpdate.html)."" Get the revocation status of a certificate by its serial number""This corresponds to [`X509_CRL_get0_by_serial`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_get0_by_serial.html)."get_by_serial" Get the revocation status of a certificate""This corresponds to [`X509_CRL_get0_by_cert`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_get0_by_cert.html)."get_by_cert" Get the issuer name from the revocation list.""This corresponds to [`X509_CRL_get_issuer`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_get_issuer.html)."" Check if the CRL is signed using the given public key.""This corresponds to [`X509_CRL_verify`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_verify.html).""This corresponds to [`X509_CRL_get_ext_d2i`](https://www.openssl.org/docs/manmaster/man3/X509_CRL_get_ext_d2i.html)."/// The result of peer certificate verification./// Creates an `X509VerifyResult` from a raw error number./// Some methods on `X509VerifyResult` are not thread safe if the error/// number is invalid./// Return the integer representation of an `X509VerifyResult`." Return a human readable error string from the verification error.""This corresponds to [`X509_verify_cert_error_string`](https://www.openssl.org/docs/manmaster/man3/X509_verify_cert_error_string.html)."/// Successful peer certificate verification.APPLICATION_VERIFICATION/// Application verification failure.r" An `X509` certificate alternative names."GENERAL_NAMEGeneralNameRefr" Reference to `GeneralName`."new_emailnew_dnsnew_ipnew_ridnew_other_name/// Returns the contents of this `GeneralName` if it is an `rfc822Name`.directory_name/// Returns the contents of this `GeneralName` if it is a `directoryName`.dnsname/// Returns the contents of this `GeneralName` if it is a `dNSName`./// Returns the contents of this `GeneralName` if it is an `uniformResourceIdentifier`.ipaddress/// Returns the contents of this `GeneralName` if it is an `iPAddress`.stack_st_GENERAL_NAMEr" A `X509` distribution point."DIST_POINTDistPointRefr" Reference to `DistPoint`."distpointDistPointNameRef/// Returns the name of this distribution point if it existsDIST_POINT_NAMEDistPointNamer" Reference to `DistPointName`."fullname/// Returns the contents of this DistPointName if it is a fullname.stack_st_DIST_POINTr" `AccessDescription` of certificate authority information."ACCESS_DESCRIPTIONAccessDescriptionRefr" Reference to `AccessDescription`."/// Returns the access method OID.// Returns the access location.stack_st_ACCESS_DESCRIPTIONr" An `X509` certificate signature algorithm."X509_ALGORX509Algorithmr" Reference to `X509Algorithm`."/// Returns the ASN.1 OID of this algorithm.r" An `X509` or an X509 certificate revocation list."X509_OBJECTX509ObjectX509ObjectRefr" Reference to `X509Object`"stack_st_X509_OBJECTX509_getm_notAfterX509_getm_notBeforeX509_up_refX509_get0_signatureX509_ALGOR_get0X509_STORE_CTX_get0_chainX509_set1_notAfterX509_set1_notBeforeX509_REQ_get_versionX509_REQ_get_subject_nameX509_OBJECT_get0_X509X509_OBJECT_freeX509_CRL_get_issuerX509_CRL_get0_nextUpdateX509_CRL_get0_lastUpdateX509_CRL_get_REVOKEDX509_REVOKED_get0_revocationDateX509_REVOKED_get0_serialNumberX509PurposeIdSSL_CLIENTSSL_SERVERNS_SSL_SERVERSMIME_SIGNSMIME_ENCRYPTCRL_SIGNOCSP_HELPERTIMESTAMP_SIGN/// Constructs an `X509PurposeId` from a raw OpenSSL value.X509PurposeRef/// A reference to an [`X509_PURPOSE`].X509_PURPOSE/// Implements a wrapper type for the static `X509_PURPOSE` table in OpenSSL.get_by_sname/// Get the internal table index of an X509_PURPOSE for a given short name. Valid short/// names include///  - "sslclient",///  - "sslserver",///  - "nssslserver",///  - "smimesign",///  - "smimeencrypt",///  - "crlsign",///  - "any",///  - "ocsphelper",///  - "timestampsign"/// The index can be used with `X509PurposeRef::from_idx()` to get the purpose." Get an `X509PurposeRef` for a given index value. The index can be obtained from e.g."" `X509PurposeRef::get_by_sname()`.""This corresponds to [`X509_PURPOSE_get0`](https://www.openssl.org/docs/manmaster/man3/X509_PURPOSE_get0.html)."from_idx/// Get the purpose value from an X509Purpose structure. This value is one of/// - `X509_PURPOSE_SSL_CLIENT`/// - `X509_PURPOSE_SSL_SERVER`/// - `X509_PURPOSE_NS_SSL_SERVER`/// - `X509_PURPOSE_SMIME_SIGN`/// - `X509_PURPOSE_SMIME_ENCRYPT`/// - `X509_PURPOSE_CRL_SIGN`/// - `X509_PURPOSE_ANY`/// - `X509_PURPOSE_OCSP_HELPER`/// - `X509_PURPOSE_TIMESTAMP_SIGN`//! The standard defining the format of public key certificates.//! An `X509` certificate binds an identity to a public key, and is either//! signed by a certificate authority (CA) or self-signed. An entity that gets//! a hold of a certificate can both verify your identity (via a CA) and encrypt//! data with the included public key. `X509` certificates are used in many//! Internet protocols, including SSL/TLS, which is the basis for HTTPS,//! the secure protocol for browsing the web.X509VerifyFlagsr" A builder type used to construct an `X509Store`."X509_STOREr" A reference to an [`X509StoreBuilder`]."" Returns a builder for a certificate store."" The store is initially empty.""This corresponds to [`X509_STORE_new`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_new.html)."/// Constructs the `X509Store`." Adds a certificate to the certificate store.""This corresponds to [`X509_STORE_add_cert`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_add_cert.html)."add_cert" Load certificates from their default locations."" These locations are read from the `SSL_CERT_FILE` and `SSL_CERT_DIR`"" environment variables if present, or defaults specified at OpenSSL"" build time otherwise.""This corresponds to [`X509_STORE_set_default_paths`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_set_default_paths.html)."set_default_paths" Adds a lookup method to the store.""This corresponds to [`X509_STORE_add_lookup`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_add_lookup.html)."add_lookupX509LookupMethodRefX509LookupRef" Sets certificate chain validation related flags.""This corresponds to [`X509_STORE_set_flags`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_set_flags.html)."" Sets the certificate purpose."" The purpose value can be obtained by `X509PurposeRef::get_by_sname()`""This corresponds to [`X509_STORE_set_purpose`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_set_purpose.html)."set_purpose" Sets certificate chain validation related parameters.""This corresponds to [`X509_STORE_set1_param`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_set1_param.html)."set_paramr" Information used by an `X509Store` to look up certificates and CRLs."X509_LOOKUPX509Lookupr" A reference to an [`X509Lookup`]."HashDir/// Marker type corresponding to the [`X509_LOOKUP_hash_dir`] lookup method./// [`X509_LOOKUP_hash_dir`]: https://www.openssl.org/docs/manmaster/crypto/X509_LOOKUP_hash_dir.html// FIXME should be an enum" Lookup method that loads certificates and CRLs on demand and caches"" them in memory once they are loaded. It also checks for newer CRLs upon"" each lookup, so that newer CRLs are used as soon as they appear in the"" directory.""This corresponds to [`X509_LOOKUP_hash_dir`](https://www.openssl.org/docs/manmaster/man3/X509_LOOKUP_hash_dir.html)."hash_dir" Specifies a directory from which certificates and CRLs will be loaded"" on-demand. Must be used with `X509Lookup::hash_dir`.""This corresponds to [`X509_LOOKUP_add_dir`](https://www.openssl.org/docs/manmaster/man3/X509_LOOKUP_add_dir.html)."add_dir/// Marker type corresponding to the [`X509_LOOKUP_file`] lookup method./// [`X509_LOOKUP_file`]: https://www.openssl.org/docs/man1.1.1/man3/X509_LOOKUP_file.html" Lookup method loads all the certificates or CRLs present in a file"" into memory at the time the file is added as a lookup source.""This corresponds to [`X509_LOOKUP_file`](https://www.openssl.org/docs/manmaster/man3/X509_LOOKUP_file.html)."" Specifies a file from which certificates will be loaded""This corresponds to [`X509_load_cert_file`](https://www.openssl.org/docs/manmaster/man3/X509_load_cert_file.html)."load_cert_file" Specifies a file from which certificate revocation lists will be loaded""This corresponds to [`X509_load_crl_file`](https://www.openssl.org/docs/manmaster/man3/X509_load_crl_file.html)."load_crl_filer" Method used to look up certificates and CRLs."X509_LOOKUP_METHODX509LookupMethodr" A reference to an [`X509LookupMethod`]."r" A certificate store to hold trusted `X509` certificates."r" Reference to an `X509Store`."" Get a reference to the cache of certificates in this store."" This method is deprecated. It is **unsound** and will be removed in a"" future version of rust-openssl. `X509StoreRef::all_certificates`"" should be used instead.""This corresponds to [`X509_STORE_get0_objects`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_get0_objects.html)."" Returns a stack of all the certificates in this store.""This corresponds to [`X509_STORE_get1_all_certs`](https://www.openssl.org/docs/manmaster/man3/X509_STORE_get1_all_certs.html)."all_certificatesX509_STORE_get0_objectsX509_LOOKUP_meth_free//! Describe a context in which to verify an `X509` certificate.//! The `X509` certificate store holds trusted CA certificates used to verify//! peer certificates.//! use openssl::x509::store::{X509StoreBuilder, X509Store};//! use openssl::x509::{X509, X509Name};//! let mut name = X509Name::builder().unwrap();//! name.append_entry_by_nid(Nid::COMMONNAME, "foobar.com").unwrap();//! let name = name.build();//! // Sep 27th, 2016//! let sample_time = Asn1Time::from_unix(1474934400).unwrap();//! let mut builder = X509::builder().unwrap();//! builder.set_version(2).unwrap();//! builder.set_subject_name(&name).unwrap();//! builder.set_issuer_name(&name).unwrap();//! builder.set_pubkey(&pkey).unwrap();//! builder.set_not_before(&sample_time);//! builder.set_not_after(&sample_time);//! builder.sign(&pkey, MessageDigest::sha256()).unwrap();//! let certificate: X509 = builder.build();//! let mut builder = X509StoreBuilder::new().unwrap();//! let _ = builder.add_cert(certificate);//! let store: X509Store = builder.build();X509VerifyParamtest_cert_loadingtest_cert_issue_validitytest_save_dertest_subject_read_cntest_nid_valuestest_nameref_iteratortest_nid_uid_valuetest_subject_alt_nametest_retrieve_pathlentest_subject_key_idtest_authority_key_idtest_authority_issuer_and_serialtest_subject_alt_name_itertest_aia_ca_issuerx509_builderx509_extension_new// This tests `X509Extension::new`, even though its deprecated.x509_extension_new_from_derx509_extension_to_dereku_invalid_otherx509_req_buildertest_stack_from_pemclone_x509test_verify_certtest_verify_failstest_verify_fails_with_crl_flag_set_and_no_crltest_verify_cert_with_purposetest_verify_cert_with_wrong_purpose_failsx509_ref_versionx509_ref_version_no_version_settest_load_crltest_crl_entry_extensionstest_save_subject_dertest_load_subject_dertest_convert_to_texttest_convert_req_to_texttest_name_cmptest_name_to_ownedtest_verify_param_set_time_fails_verificationtest_verify_param_set_timetest_verify_param_set_depthtest_verify_param_set_depth_fails_verificationtest_load_cert_filetest_verify_param_auth_leveltest_set_purposetest_set_purpose_fails_verificationtest_add_name_entrytest_load_crl_file_failipaddress_as_subject_alternative_name_is_formatted_in_debugipv4_as_subject_alternative_name_is_formatted_in_debugipv6_as_subject_alternative_name_is_formatted_in_debugother_name_as_subject_alternative_nametest_dist_pointtest_dist_point_nulltest_store_all_certificatesr" Flags used to check an `X509` certificate."ALWAYS_CHECK_SUBJECTNO_WILDCARDSNO_PARTIAL_WILDCARDSMULTI_LABEL_WILDCARDSSINGLE_LABEL_SUBDOMAINSr" Requires OpenSSL 1.1.0 or newer."NEVER_CHECK_SUBJECTFLAG_NO_WILDCARDSr" Flags used to verify an `X509` certificate chain."CB_ISSUER_CHECKUSE_CHECK_TIMECRL_CHECKCRL_CHECK_ALLIGNORE_CRITICALX509_STRICTALLOW_PROXY_CERTSPOLICY_CHECKEXPLICIT_POLICYINHIBIT_ANYINHIBIT_MAPNOTIFY_POLICYEXTENDED_CRL_SUPPORTUSE_DELTASCHECK_SS_SIGNATURETRUSTED_FIRSTSUITEB_128_LOS_ONLYSUITEB_192_LOSSUITEB_128_LOSPARTIAL_CHAINNO_ALT_CHAINSNO_CHECK_TIMEr" Adjust parameters associated with certificate verification."X509_VERIFY_PARAMr" Reference to `X509VerifyParam`."" Create an X509VerifyParam""This corresponds to [`X509_VERIFY_PARAM_new`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_new.html)."" Set the host flags.""This corresponds to [`X509_VERIFY_PARAM_set_hostflags`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_hostflags.html)."set_hostflags" Set verification flags.""This corresponds to [`X509_VERIFY_PARAM_set_flags`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_flags.html)."" Clear verification flags.""This corresponds to [`X509_VERIFY_PARAM_clear_flags`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_clear_flags.html)."clear_flags" Gets verification flags.""This corresponds to [`X509_VERIFY_PARAM_get_flags`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_get_flags.html)."" Set the expected DNS hostname.""This corresponds to [`X509_VERIFY_PARAM_set1_host`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set1_host.html)."" Set the expected email address.""This corresponds to [`X509_VERIFY_PARAM_set1_email`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set1_email.html)."set_email" Set the expected IPv4 or IPv6 address.""This corresponds to [`X509_VERIFY_PARAM_set1_ip`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set1_ip.html)."" Set the verification time, where time is of type time_t, traditionaly defined as seconds since the epoch""This corresponds to [`X509_VERIFY_PARAM_set_time`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_time.html)."" Set the verification depth""This corresponds to [`X509_VERIFY_PARAM_set_depth`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_depth.html)."set_depth" Sets the authentication security level to auth_level""This corresponds to [`X509_VERIFY_PARAM_set_auth_level`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_auth_level.html)."set_auth_level" Gets the current authentication security level""This corresponds to [`X509_VERIFY_PARAM_get_auth_level`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_get_auth_level.html)."auth_level" Sets the verification purpose""This corresponds to [`X509_VERIFY_PARAM_set_purpose`](https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_purpose.html)."ENV_CERT_FILE/// The OpenSSL environment variable to configure what certificate file to use.ENV_CERT_DIR/// The OpenSSL environment variable to configure what certificates directory to use.cert_filecert_dirProbeResultfind_certs_dirs/// Probe the system for the directory in which CA certificates should likely be/// This will only search known system locations.cert_dirs_iter// TODO: when we bump to 0.2, make this the `find_certs_dirs` functioninit_ssl_cert_env_vars/// Probe for SSL certificates on the system, then configure the SSL certificate `SSL_CERT_FILE`/// and `SSL_CERT_DIR` environment variables in this process for OpenSSL to use./// Preconfigured values in the environment variables will not be overwritten if the paths they/// point to exist and are accessible.try_init_ssl_cert_env_vars/// Returns `true` if any certificate file or directory was found while probing./// Combine this with `has_ssl_cert_env_vars()` to check whether previously configured environment/// variables are valid.has_ssl_cert_env_vars/// Check whether the OpenSSL `SSL_CERT_FILE` and/or `SSL_CERT_DIR` environment variable is/// configured in this process with an existing file or directory./// That being the case would indicate that certificates will be found successfully by OpenSSL./// Returns `true` if either variable is set to an existing file or directory.probe_from_envsource_diropenssl_dir// Only affects non-windows builds for now.include_dirlib_dirbin_dirArtifactscmd_makeis_nasm_ready/// Exits the process on failure. Use `try_build` to handle the error.sanitize_shprint_cargo_metadataget_opensslresolve_with_wellknown_homebrew_locationresolve_with_wellknown_locationfind_openssl_dirtry_pkg_config/// Attempt to find OpenSSL through pkg-config./// Note that if this succeeds then the function does not return as pkg-config/// typically tells us all the information that we need./// Attempt to find OpenSSL through vcpkg./// Note that if this succeeds then the function does not return as vcpkg/// should emit all of the cargo metadata that we need.execute_command_and_get_outputcfgsfind_normalfind_vendoredrun_bindgenOpenssl3xxOpenssl11xOpenssl10xLibresslBoringsslenv_innerfind_opensslcheck_ssl_kindpostprocessvalidate_headers/// Validates the header files found in `include_dir` and then returns the/// version string of OpenSSL.version_error// parses a string that looks like "0x100020cfL"parse_new_version// parses a string that looks like 3_0_0determine_mode/// Given a libdir for OpenSSL (where artifacts are located) as well as the name/// of the libraries we're linking to, figure out whether we should link them/// statically or dynamically.run_boringsslOpensslCallbacks// for now we'll continue hand-writing constantsAES_ENCRYPTAES_DECRYPTAES_MAXNRAES_BLOCK_SIZEV_ASN1_EOC// ASN.1 tag valuesV_ASN1_BOOLEANV_ASN1_INTEGERV_ASN1_BIT_STRINGV_ASN1_OCTET_STRINGV_ASN1_NULLV_ASN1_OBJECTV_ASN1_OBJECT_DESCRIPTORV_ASN1_EXTERNALV_ASN1_REALV_ASN1_ENUMERATEDV_ASN1_UTF8STRINGV_ASN1_SEQUENCEV_ASN1_SETV_ASN1_NUMERICSTRINGV_ASN1_PRINTABLESTRINGV_ASN1_T61STRINGV_ASN1_TELETEXSTRINGV_ASN1_VIDEOTEXSTRING// aliasV_ASN1_IA5STRINGV_ASN1_UTCTIMEV_ASN1_GENERALIZEDTIMEV_ASN1_GRAPHICSTRINGV_ASN1_ISO64STRINGV_ASN1_VISIBLESTRINGV_ASN1_GENERALSTRINGV_ASN1_UNIVERSALSTRINGV_ASN1_BMPSTRINGMBSTRING_FLAGMBSTRING_UTF8MBSTRING_ASCMBSTRING_BMPMBSTRING_UNIVBIO_TYPE_NONEBIO_CTRL_EOFBIO_CTRL_INFOBIO_C_SET_BUF_MEM_EOF_RETURNBIO_FLAGS_READBIO_FLAGS_WRITEBIO_FLAGS_IO_SPECIALBIO_FLAGS_RWSBIO_FLAGS_SHOULD_RETRYBIO_get_mem_dataBIO_meth_set_writeBIO_meth_set_readBIO_meth_set_putsBIO_meth_set_ctrlBIO_meth_set_createBIO_meth_set_destroyBIO_CTRL_DGRAM_GET_MTUBIO_CTRL_DGRAM_SET_MTUBIO_CTRL_DGRAM_GET_LOCAL_ADDR_CAPBIO_CTRL_DGRAM_GET_LOCAL_ADDR_ENABLEBIO_CTRL_DGRAM_SET_LOCAL_ADDR_ENABLEBIO_CTRL_DGRAM_GET_CAPSBIO_CTRL_DGRAM_SET_CAPSBIO_CTRL_DGRAM_GET_NO_TRUNCBIO_CTRL_DGRAM_SET_NO_TRUNCBIO_dgram_get_no_truncBIO_dgram_set_no_truncBIO_dgram_get_capBIO_dgram_set_capBIO_dgram_get_local_addr_capBIO_dgram_get_local_addr_enableBIO_dgram_set_local_addr_enableBIO_dgram_get_mtuBIO_dgram_set_mtuBN_ULONGBN_FLG_MALLOCEDBN_FLG_STATIC_DATABN_FLG_CONSTTIMEBN_FLG_SECURECMS_TEXTCMS_NO_CONTENT_VERIFYCMS_NO_ATTR_VERIFYCMS_NOSIGSCMS_NOINTERNCMS_NO_SIGNER_CERT_VERIFYCMS_NOVERIFYCMS_DETACHEDCMS_BINARYCMS_NOATTRCMS_NOSMIMECAPCMS_NOOLDMIMETYPECMS_CRLFEOLCMS_STREAMCMS_NOCRLCMS_PARTIALCMS_REUSE_DIGESTCMS_USE_KEYIDCMS_DEBUG_DECRYPTCMS_KEY_PARAMCMS_ASCIICRLFCRYPTO_EX_new_retCRYPTO_EX_dup_fromCRYPTO_EX_dup_from_dCRYPTO_EX_new// FIXME should be optionsCRYPTO_EX_dupOPENSSL_mallocOPENSSL_freeCRYPTO_EX_INDEX_SSLCRYPTO_EX_INDEX_SSL_CTXCRYPTO_LOCKDTLS1_COOKIE_LENGTHOPENSSL_EC_NAMED_CURVEEVP_EC_genERR_TXT_MALLOCEDERR_TXT_STRINGERR_LIB_SYSERR_LIB_PEMERR_LIB_ASN1ERR_SYSTEM_FLAGERR_SYSTEM_MASKERR_LIB_OFFSETERR_LIB_MASKERR_RFLAGS_OFFSETERR_RFLAGS_MASKERR_REASON_MASKERR_RFLAG_FATALERR_SYSTEM_ERRORERR_GET_LIBERR_GET_FUNCERR_GET_REASONERR_PACKPKCS5_SALT_LENPKCS12_DEFAULT_ITEREVP_PKEY_RSAEVP_PKEY_RSA_PSSEVP_PKEY_DSAEVP_PKEY_DHEVP_PKEY_DHXEVP_PKEY_ECEVP_PKEY_SM2EVP_PKEY_X25519EVP_PKEY_ED25519EVP_PKEY_X448EVP_PKEY_ED448EVP_PKEY_HMACEVP_PKEY_CMACEVP_PKEY_POLY1305EVP_PKEY_HKDFEVP_CIPHER_CTX_FLAG_WRAP_ALLOWEVP_CTRL_GCM_SET_IVLENEVP_CTRL_GCM_GET_TAGEVP_CTRL_GCM_SET_TAGEVP_get_digestbynidEVP_MD_CTX_mdEVP_MD_CTX_get_sizeEVP_MD_CTX_sizeEVP_MD_block_sizeEVP_MD_sizeEVP_MD_typeEVP_CIPHER_nidEVP_CIPHER_CTX_block_sizeEVP_CIPHER_CTX_key_lengthEVP_CIPHER_CTX_iv_lengthEVP_CIPHER_CTX_numEVP_PKEY_sizeEVP_PKEY_idEVP_PKEY_bitsEVP_PKEY_security_bitsEVP_PKEY_OP_KEYGENEVP_PKEY_OP_SIGNEVP_PKEY_OP_VERIFYEVP_PKEY_OP_VERIFYRECOVEREVP_PKEY_OP_SIGNCTXEVP_PKEY_OP_VERIFYCTXEVP_PKEY_OP_ENCRYPTEVP_PKEY_OP_DECRYPTEVP_PKEY_OP_DERIVEEVP_PKEY_OP_SIGNMSGEVP_PKEY_OP_VERIFYMSGEVP_PKEY_OP_TYPE_SIGEVP_PKEY_OP_TYPE_CRYPTEVP_PKEY_CTRL_MDEVP_PKEY_CTRL_SET_MAC_KEYEVP_PKEY_CTRL_CIPHEREVP_PKEY_ALG_CTRLEVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPANDEVP_PKEY_HKDEF_MODE_EXTRACT_ONLYEVP_PKEY_HKDEF_MODE_EXPAND_ONLYEVP_PKEY_CTRL_HKDF_MDEVP_PKEY_CTRL_HKDF_SALTEVP_PKEY_CTRL_HKDF_KEYEVP_PKEY_CTRL_HKDF_INFOEVP_PKEY_CTRL_HKDF_MODEEVP_PKEY_assign_RSAEVP_PKEY_assign_DSAEVP_PKEY_assign_DHEVP_PKEY_assign_EC_KEYrd_key// There is some business with AES_LONG which is there to ensure the values here are 32 bitsAES_set_encrypt_keyAES_set_decrypt_keyAES_ige_encryptAES_wrap_keyAES_unwrap_keyASN1_ENCODINGASN1_OBJECT_freeOBJ_dupASN1_TYPE_valueASN1_TYPEASN1_BOOLEANASN1_PRINTABLESTRINGt61stringASN1_T61STRINGASN1_IA5STRINGASN1_GENERALSTRINGASN1_BMPSTRINGASN1_UNIVERSALSTRINGASN1_UTCTIMEASN1_VISIBLESTRINGASN1_UTF8STRINGasn1_valueASN1_VALUEASN1_STRING_type_newASN1_STRING_newASN1_OCTET_STRING_newASN1_STRING_freeASN1_STRING_lengthASN1_STRING_setASN1_OCTET_STRING_setASN1_BIT_STRING_freeASN1_OCTET_STRING_freeASN1_GENERALIZEDTIME_freeASN1_GENERALIZEDTIME_printASN1_TIME_newASN1_TIME_diffASN1_TIME_freeASN1_TIME_printASN1_TIME_setASN1_INTEGER_freeASN1_INTEGER_dupASN1_INTEGER_getASN1_INTEGER_setASN1_INTEGER_cmpBN_to_ASN1_INTEGERASN1_INTEGER_to_BNASN1_TIME_set_stringASN1_TIME_set_string_X509ASN1_ENUMERATED_freeASN1_ENUMERATED_get_int64ASN1_TYPE_newASN1_TYPE_setASN1_TYPE_freed2i_ASN1_TYPEconst_ptr_apiASN1_STRING_to_UTF8ASN1_STRING_typeASN1_generate_v3i2d_ASN1_TYPEBIO_clear_flagsbio_info_cbBIO_s_fileBIO_new_fpBIO_writeBIO_readBIO_ctrlBIO_free_allBIO_s_memBIO_new_socketBIO_meth_newBIO_meth_free"BIO_meth_set_write"BIO_meth_set_write__fixed_rust"BIO_meth_set_read"BIO_meth_set_read__fixed_rust"BIO_meth_set_puts"BIO_meth_set_puts__fixed_rust"BIO_meth_set_ctrl"BIO_meth_set_ctrl__fixed_rust"BIO_meth_set_create"BIO_meth_set_create__fixed_rust"BIO_meth_set_destroy"BIO_meth_set_destroy__fixed_rustBIO_meth_set_sendmmsgBIO_MSGBIO_meth_set_recvmmsgBIO_new_bio_dgram_pairBIO_s_dgram_pairBIO_s_datagramBIO_get_rpoll_descriptorBIO_POLL_DESCRIPTORBIO_get_wpoll_descriptorBIO_sendmmsgBIO_recvmmsgBIO_err_is_non_fatalBN_CTX_newBN_CTX_secure_newBN_CTX_freeBN_randBN_pseudo_randBN_rand_rangeBN_pseudo_rand_rangeBN_newBN_secure_newBN_set_flagsBN_get_flagsBN_num_bitsBN_clear_freeBN_bin2bnBN_bn2binBN_bn2binpadBN_subBN_addBN_mulBN_sqrBN_set_negativeBN_is_oddBN_divBN_nnmodBN_mod_addBN_mod_subBN_mod_mulBN_mod_sqrBN_mod_sqrtBN_mod_wordBN_div_wordBN_mul_wordBN_add_wordBN_sub_wordBN_set_wordBN_cmpBN_freeBN_is_bit_setBN_lshiftBN_lshift1BN_expBN_mod_expBN_mask_bitsBN_rshiftBN_rshift1BN_bn2hexBN_bn2decBN_hex2bnBN_dec2bnBN_gcdBN_mod_inverseBN_clearBN_dupBN_ucmpBN_set_bitBN_clear_bitBN_generate_prime_exBN_GENCBBN_is_prime_exBN_is_prime_fasttest_exCMAC_CTX_newCMAC_CTXCMAC_CTX_freeCMAC_InitCMAC_UpdateCMAC_FinalCMAC_CTX_copyCMS_ContentInfo_freei2d_CMS_ContentInfod2i_CMS_ContentInfoSMIME_read_CMSCMS_signCMS_verifyCMS_encryptCMS_decryptNCONF_newNCONF_defaultNCONF_freestack_st_voidCRYPTO_get_ex_new_indexCRYPTO_mallocCRYPTO_freeCRYPTO_memcmpOSSL_LIB_CTX_newOSSL_LIB_CTX_freeDH_newDH_freeDH_checkDH_generate_parametersDH_generate_parameters_exDH_generate_keyDH_compute_keyDH_sized2i_DHparamsi2d_DHparamsDH_get_1024_160DH_get_2048_224DH_get_2048_256DSA_newDSA_freeDSA_up_refDSA_sizeDSA_signDSA_verifyd2i_DSAPublicKeyd2i_DSAPrivateKeyDSA_generate_parameters_exDSA_generate_keyi2d_DSAPublicKeyi2d_DSAPrivateKeyd2i_DSA_SIGi2d_DSA_SIGDSA_SIG_newDSA_SIG_freePOINT_CONVERSION_COMPRESSEDPOINT_CONVERSION_UNCOMPRESSEDPOINT_CONVERSION_HYBRIDEC_METHODEC_GF2m_simple_methodEC_GROUP_newEC_GROUP_freeEC_GROUP_get_orderEC_GROUP_get_cofactorEC_GROUP_get0_generatorEC_GROUP_set_generatorEC_GROUP_get_curve_nameEC_GROUP_set_asn1_flagEC_GROUP_get_asn1_flagEC_GROUP_get_curve_GFpEC_GROUP_get_curve_GF2mEC_GROUP_get_degreeEC_GROUP_order_bitsEC_GROUP_new_curve_GFpEC_GROUP_new_curve_GF2mEC_GROUP_new_by_curve_nameEC_POINT_is_at_infinityEC_POINT_is_on_curveEC_POINT_newEC_POINT_freeEC_POINT_dupEC_POINT_get_affine_coordinatesEC_POINT_get_affine_coordinates_GFpEC_POINT_set_affine_coordinates_GFpEC_POINT_get_affine_coordinates_GF2mEC_POINT_point2octEC_POINT_oct2pointEC_POINT_point2hexEC_POINT_hex2pointEC_POINT_addEC_POINT_invertEC_POINT_cmpEC_POINT_mulEC_KEY_newEC_KEY_new_by_curve_nameEC_KEY_freeEC_KEY_dupEC_KEY_up_refEC_KEY_get0_groupEC_KEY_set_groupEC_KEY_get0_private_keyEC_KEY_set_private_keyEC_KEY_get0_public_keyEC_KEY_set_public_keyEC_KEY_generate_keyEC_KEY_check_keyEC_KEY_set_public_key_affine_coordinatesECDSA_SIG_newECDSA_SIG_freeECDSA_do_signECDSA_do_verifyd2i_ECDSA_SIGi2d_ECDSA_SIGERR_STRING_DATAERR_newERR_set_debugERR_set_errorERR_set_error_dataERR_get_errorERR_get_error_line_dataERR_peek_last_errorERR_clear_errorERR_lib_error_stringERR_func_error_stringERR_reason_error_stringERR_load_stringsERR_get_next_error_libraryEVP_MD_get_block_sizeEVP_MD_get_sizeEVP_MD_get_typeEVP_MD_CTX_get0_mdEVP_CIPHER_get_key_lengthEVP_CIPHER_get_block_sizeEVP_CIPHER_get_iv_lengthEVP_CIPHER_get_nidEVP_CIPHER_fetchEVP_CIPHER_freeEVP_CIPHER_CTX_get_block_sizeEVP_CIPHER_CTX_get_key_lengthEVP_CIPHER_CTX_get_iv_lengthEVP_CIPHER_CTX_get_tag_lengthEVP_CIPHER_CTX_get_numEVP_default_properties_is_fips_enabledEVP_default_properties_enable_fipsEVP_DigestInit_exEVP_DigestUpdateEVP_DigestFinal_exEVP_Q_digestEVP_DigestInitEVP_DigestFinalEVP_DigestFinalXOFEVP_DigestSqueezeEVP_MD_fetchEVP_MD_freeEVP_BytesToKeyEVP_CipherInitEVP_CipherInit_exEVP_CipherUpdateEVP_CipherFinalEVP_DigestSignInitEVP_DigestSignUpdateEVP_DigestSignFinalEVP_DigestVerifyInitEVP_DigestVerifyUpdateEVP_SealInitEVP_SealFinalEVP_EncryptInit_exEVP_EncryptUpdateEVP_EncryptFinal_exEVP_OpenInitEVP_OpenFinalEVP_DecryptInit_exEVP_DecryptUpdateEVP_DecryptFinal_exEVP_PKEY_get_sizeEVP_DigestSignEVP_DigestVerifyEVP_CIPHER_CTX_newEVP_CIPHER_CTX_freeEVP_CIPHER_CTX_copyEVP_MD_CTX_copy_exEVP_MD_CTX_resetEVP_CIPHER_CTX_set_key_lengthEVP_CIPHER_CTX_set_paddingEVP_CIPHER_CTX_ctrlEVP_CIPHER_CTX_rand_keyEVP_CIPHER_CTX_set_flagsEVP_md_nullEVP_md5EVP_sha1EVP_sha224EVP_sha256EVP_sha384EVP_sha512EVP_sha3_224EVP_sha3_256EVP_sha3_384EVP_sha3_512EVP_shake128EVP_shake256EVP_ripemd160EVP_sm3EVP_des_ecbEVP_des_ede3EVP_des_ede3_cbcEVP_des_ede3_ecbEVP_des_ede3_cfb64EVP_des_ede3_cfb8EVP_des_ede3_ofbEVP_des_cbcEVP_rc4EVP_bf_ecbEVP_bf_cbcEVP_bf_cfb64EVP_bf_ofbEVP_aes_128_ecbEVP_aes_128_cbcEVP_aes_128_cfb1EVP_aes_128_cfb8EVP_aes_128_cfb128EVP_aes_128_ctrEVP_aes_128_ccmEVP_aes_128_gcmEVP_aes_128_xtsEVP_aes_128_ofbEVP_aes_128_ocbEVP_aes_128_wrapEVP_aes_128_wrap_padEVP_aes_192_ecbEVP_aes_192_cbcEVP_aes_192_cfb1EVP_aes_192_cfb8EVP_aes_192_cfb128EVP_aes_192_ctrEVP_aes_192_ccmEVP_aes_192_gcmEVP_aes_192_ofbEVP_aes_192_ocbEVP_aes_192_wrapEVP_aes_192_wrap_padEVP_aes_256_ecbEVP_aes_256_cbcEVP_aes_256_cfb1EVP_aes_256_cfb8EVP_aes_256_cfb128EVP_aes_256_ctrEVP_aes_256_ccmEVP_aes_256_gcmEVP_aes_256_xtsEVP_aes_256_ofbEVP_aes_256_ocbEVP_aes_256_wrapEVP_aes_256_wrap_padEVP_chacha20EVP_chacha20_poly1305EVP_sm4_ecbEVP_sm4_cbcEVP_sm4_cfb128EVP_sm4_ofbEVP_sm4_ctrEVP_cast5_cfb64EVP_cast5_ecbEVP_cast5_cbcEVP_cast5_ofbEVP_get_digestbynameEVP_get_cipherbynameEVP_PKEY_get_idEVP_PKEY_get_bitsEVP_PKEY_get_security_bitsEVP_PKEY_assignEVP_PKEY_set1_RSAEVP_PKEY_get1_RSAEVP_PKEY_set1_DSAEVP_PKEY_get1_DSAEVP_PKEY_set1_DHEVP_PKEY_get1_DHEVP_PKEY_set1_EC_KEYEVP_PKEY_get1_EC_KEYEVP_PKEY_newEVP_PKEY_freed2i_AutoPrivateKeyEVP_PKEY_cmpEVP_PKEY_copy_parametersPKCS5_PBKDF2_HMAC_SHA1PKCS5_PBKDF2_HMACEVP_PBE_scryptEVP_PKEY_CTX_newEVP_PKEY_CTX_new_idEVP_PKEY_CTX_freeEVP_PKEY_CTX_ctrlEVP_PKEY_CTX_set_signature_mdEVP_PKEY_CTX_set_paramsOSSL_PARAMEVP_PKEY_CTX_get_paramsEVP_PKEY_new_mac_keyEVP_PKEY_derive_initEVP_PKEY_derive_set_peerEVP_PKEY_derive_set_peer_exEVP_PKEY_deriveEVP_PKEY_Q_keygenEVP_PKEY_keygen_initEVP_PKEY_keygenEVP_PKEY_sign_initEVP_PKEY_signEVP_PKEY_verify_initEVP_PKEY_verifyEVP_PKEY_encrypt_initEVP_PKEY_encryptEVP_PKEY_decrypt_initEVP_PKEY_decryptEVP_PKEY_verify_recover_initEVP_PKEY_verify_recoverEVP_PKCS82PKEYPKCS8_PRIV_KEY_INFOEVP_PKEY_get_raw_public_keyEVP_PKEY_new_raw_public_keyEVP_PKEY_get_raw_private_keyEVP_PKEY_new_raw_private_keyEVP_EncodeBlockEVP_DecodeBlockHMAC_CTX_newHMAC_CTXHMAC_CTX_freeHMAC_Init_exHMAC_UpdateHMAC_FinalHMAC_CTX_copyEVP_PKEY_CTX_set_hkdf_modeEVP_PKEY_CTX_set_hkdf_mdEVP_PKEY_CTX_set1_hkdf_saltEVP_PKEY_CTX_set1_hkdf_keyEVP_PKEY_CTX_add1_hkdf_infoEVP_KDF_CTX_newEVP_KDF_CTX_freeEVP_KDF_CTX_resetEVP_KDF_CTX_get_kdf_sizeEVP_KDF_deriveEVP_KDF_fetchEVP_KDF_freeevpsafestacktls1x509_vfyx509v3OBJ_nid2lnOBJ_nid2snOBJ_nid2objOBJ_obj2nidOBJ_obj2txtOBJ_find_sigid_algsOBJ_sn2nidOBJ_txt2objOBJ_createOBJ_lengthOBJ_get0_dataOBJ_cmpOCSP_cert_to_idOCSP_request_add0_idOCSP_resp_find_statusOCSP_check_validityOCSP_response_statusOCSP_response_get1_basicOCSP_response_createOCSP_BASICRESP_newOCSP_BASICRESP_freeOCSP_RESPONSE_newOCSP_RESPONSE_freei2d_OCSP_RESPONSEd2i_OCSP_RESPONSEOCSP_ONEREQ_freeOCSP_CERTID_freeOCSP_REQUEST_newOCSP_REQUEST_freei2d_OCSP_REQUESTd2i_OCSP_REQUESTOCSP_basic_verifyOSSL_PARAM_construct_uintOSSL_PARAM_construct_endOSSL_PARAM_construct_octet_stringpem_password_cbPEM_write_bio_X509PEM_write_bio_X509_REQPEM_write_bio_X509_CRLPEM_write_bio_RSAPrivateKeyPEM_write_bio_RSA_PUBKEYPEM_write_bio_DSAPrivateKeyPEM_write_bio_ECPrivateKeyPEM_write_bio_DSA_PUBKEYPEM_write_bio_PrivateKeyPEM_write_bio_PUBKEYPEM_write_bio_PKCS8PrivateKeyPEM_write_bio_PKCS7PEM_write_bio_EC_PUBKEYi2d_PKCS8PrivateKey_bioPEM_read_bio_X509PEM_read_bio_X509_REQPEM_read_bio_X509_CRLPEM_read_bio_RSAPrivateKeyPEM_read_bio_RSAPublicKeyPEM_write_bio_RSAPublicKeyPEM_read_bio_RSA_PUBKEYPEM_read_bio_DSAPrivateKeyPEM_read_bio_DSA_PUBKEYPEM_read_bio_ECPrivateKeyPEM_read_bio_EC_PUBKEYPEM_read_bio_DHparamsPEM_write_bio_DHparamsPEM_read_bio_PrivateKeyPEM_read_bio_PUBKEYd2i_PKCS8PrivateKey_biod2i_PKCS8_PRIV_KEY_INFOPKCS8_PRIV_KEY_INFO_freePEM_read_bio_PKCS7PEM_read_bio_CMSPEM_write_bio_CMSPKCS12_freei2d_PKCS12d2i_PKCS12PKCS12_parsePKCS12_set_macPKCS12_createi2d_PKCS12_biolibctxpropqPKCS7_CTXmd_algsstack_st_X509_ALGOR/* version 1 *//* md used */crlstack_st_X509_CRL/* [ 0 ] */signer_info/* [ 1 ] */PKCS7_ENC_CONTENTrecipientinfostack_st_PKCS7_RECIP_INFO/* version 0 */PKCS7_ENVELOPEPKCS7_SIGN_ENVELOPEPKCS7_ENCRYPTPKCS7_SIGNED_freePKCS7_ENC_CONTENT_freePKCS7_ENVELOPE_freePKCS7_SIGN_ENVELOPE_freePKCS7_DIGEST_freePKCS7_SIGNER_INFO_freePKCS7_ENCRYPT_freePKCS7_ISSUER_AND_SERIAL_freePKCS7_ISSUER_AND_SERIALPKCS7_RECIP_INFO_freePKCS7_RECIP_INFO/*
     * The following is non NULL if it contains ASN1 encoding of this
     * structure
     */// # define PKCS7_S_HEADER  0// # define PKCS7_S_BODY    1// # define PKCS7_S_TAIL    2/* used during processing */PKCS7_data/* content as defined by the type *//*
     * all encryption/message digests are applied to the 'contents', leaving
     * out the 'type' field.
     *//* NID_pkcs7_data *//* NID_pkcs7_signed */enveloped/* NID_pkcs7_enveloped */signed_and_enveloped/* NID_pkcs7_signedAndEnveloped *//* NID_pkcs7_digest */encrypted/* NID_pkcs7_encrypted *//* Anything else */issuer_and_serialdigest_algauth_attrstack_st_X509_ATTRIBUTEdigest_enc_algenc_digestunauth_attr/* The private key to sign with */key_enc_algorenc_key/* get the pub-key from this */d2i_PKCS7i2d_PKCS7i2d_PKCS7_bioPKCS7_encryptPKCS7_verifyPKCS7_get0_signersPKCS7_signPKCS7_decryptPKCS7_freeSMIME_write_PKCS7SMIME_read_PKCS7PKCS7_newPKCS7_set_typePKCS7_add_certificatePKCS7_add_signaturePKCS7_set_signed_attributesPKCS7_add_signed_attributePKCS7_content_newPKCS7_dataInitPKCS7_dataFinalPKCS7_get_signer_infoPKCS7_SIGNER_INFO_get0_algsPKCS7_get_signed_attributeOSSL_PROVIDER_loadOSSL_PROVIDER_try_loadOSSL_PROVIDER_unloadOSSL_PROVIDER_set_default_search_pathRAND_bytesRAND_priv_bytesRAND_keep_random_devices_openRAND_statusRAND_addEVP_PKEY_CTX_set_rsa_paddingEVP_PKEY_CTX_get_rsa_paddingEVP_PKEY_CTX_set_rsa_pss_saltlenEVP_PKEY_CTX_set_rsa_mgf1_mdRSA_newRSA_sizeRSA_generate_key_exRSA_public_encryptRSA_private_encryptRSA_public_decryptRSA_private_decryptRSA_check_keyRSA_freeRSA_up_refi2d_RSAPublicKeyd2i_RSAPublicKeyi2d_RSAPrivateKeyd2i_RSAPrivateKeyRSA_signRSA_verifyRSA_padding_check_PKCS1_type_2h0SHA_LONGh3h4NlNhSHA_LBLOCKSHA1_InitSHA1_UpdateSHA1_Finalmd_lenSHA224_InitSHA224_UpdateSHA224_FinalSHA256_InitSHA256_UpdateSHA256_FinalSHA_LONG64SHA384_InitSHA384_UpdateSHA384_FinalSHA512_InitSHA512_UpdateSHA512_FinalSSL_CTX_set_tlsext_use_srtpSSL_set_tlsext_use_srtpSSL_get_srtp_profilesSSL_get_selected_srtp_profiletls_session_ticket_ext_cb_fntls_session_secret_cb_fnSSL_custom_ext_add_cb_exSSL_custom_ext_free_cb_exSSL_custom_ext_parse_cb_exSSL_CTX_get_optionsSSL_CTX_set_optionsSSL_CTX_clear_optionsGEN_SESSION_CBSSL_CTX_sess_set_new_cbSSL_CTX_sess_set_remove_cbSSL_CTX_sess_set_get_cbSSL_CTX_set_cookie_generate_cb// FIXME change to unsafe extern "C" fnSSL_CTX_set_cookie_verify_cbSSL_CTX_set_stateless_cookie_generate_cbSSL_CTX_set_stateless_cookie_verify_cbSSL_CTX_set_next_protos_advertised_cbSSL_CTX_set_next_proto_select_cbSSL_get0_next_proto_negotiatedSSL_select_next_protoSSL_CTX_set_alpn_protosSSL_set_alpn_protos"SSL_CTX_set_alpn_select_cb"SSL_CTX_set_alpn_select_cb__fixed_rustSSL_get0_alpn_selectedSSL_CTX_set_psk_client_callbackSSL_CTX_set_psk_server_callbackSSL_get_psk_identity_hintSSL_get_psk_identitySSL_CTX_add_custom_extSSL_extension_supportedSSL_CTX_keylog_cb_funcSSL_CTX_set_keylog_callbackSSL_CTX_set_max_early_dataSSL_CTX_get_max_early_dataSSL_set_max_early_dataSSL_get_max_early_dataSSL_get_finishedSSL_get_peer_finishedSSL_CTX_get_verify_modeSSL_get_verify_modeSSL_is_init_finishedSSL_CTX_set_cipher_listSSL_CTX_newSSL_CTX_freeSSL_CTX_get_cert_storeSSL_CTX_set_cert_storeSSL_get_current_cipherSSL_CIPHER_get_bitsSSL_CIPHER_get_versionSSL_CIPHER_get_handshake_digestSSL_CIPHER_get_nameSSL_CIPHER_standard_nameOPENSSL_cipher_nameSSL_pendingSSL_set_bioSSL_get_rbioSSL_get_wbioSSL_CTX_set_ciphersuitesSSL_set_ciphersuitesSSL_set_cipher_listSSL_set_ssl_methodSSL_set_verify// FIXME should be unsafeSSL_CTX_use_PrivateKeySSL_CTX_use_certificateSSL_CTX_use_PrivateKey_fileSSL_CTX_use_certificate_fileSSL_CTX_use_certificate_chain_fileSSL_use_PrivateKey_fileSSL_use_PrivateKeySSL_use_certificateSSL_use_certificate_chain_fileSSL_set_client_CA_listSSL_add_client_CASSL_load_client_CA_fileSSL_state_stringSSL_state_string_longSSL_SESSION_get_timeSSL_SESSION_get_timeoutSSL_SESSION_get_protocol_versionSSL_SESSION_set_max_early_dataSSL_SESSION_get_max_early_dataSSL_SESSION_get_idSSL_SESSION_freei2d_SSL_SESSIONSSL_set_sessionSSL_CTX_add_sessionSSL_CTX_remove_sessiond2i_SSL_SESSIONSSL_get_peer_cert_chainSSL_CTX_set_verifySSL_CTX_set_verify_depthSSL_CTX_set_post_handshake_authSSL_CTX_check_private_keySSL_CTX_set_session_id_contextSSL_newSSL_CTX_get0_paramSSL_get0_paramSSL_client_hello_cb_fnSSL_CTX_set_client_hello_cbSSL_client_hello_isv2SSL_client_hello_get0_legacy_versionSSL_client_hello_get0_randomSSL_client_hello_get0_session_idSSL_client_hello_get0_ciphersSSL_client_hello_get0_compression_methodsSSL_client_hello_get1_extensions_presentSSL_client_hello_get0_extSSL_freeSSL_acceptSSL_statelessSSL_connectSSL_readSSL_read_exSSL_peekSSL_peek_exSSL_read_early_dataSSL_bytes_to_cipher_listSSL_writeSSL_write_exSSL_write_early_dataSSL_ctrlSSL_CTX_ctrl"SSL_CTX_callback_ctrl"SSL_CTX_callback_ctrl__fixed_rustSSL_get_errorSSL_get_versionSSL_do_handshakeSSL_shutdownSSL_CTX_set_client_CA_listSSL_CTX_add_client_CASSL_CTX_set_default_verify_pathsSSL_CTX_load_verify_locationsSSL_get_ssl_methodSSL_set_connect_stateSSL_set_accept_stateSSL_CIPHER_descriptionSSL_get_certificateSSL_get_privatekeySSL_CTX_get0_certificateSSL_CTX_get0_privatekeySSL_set_shutdownSSL_get_shutdownSSL_versionSSL_get_sessionSSL_get_SSL_CTXSSL_set_SSL_CTXSSL_get_verify_resultSSL_get0_verified_chainSSL_get_client_randomSSL_get_server_randomSSL_set_ex_dataSSL_get_ex_dataSSL_CTX_set_ex_dataSSL_CTX_get_ex_dataSSL_get_ex_data_X509_STORE_CTX_idx"SSL_CTX_set_tmp_dh_callback"SSL_CTX_set_tmp_dh_callback__fixed_rust"SSL_set_tmp_dh_callback"SSL_set_tmp_dh_callback__fixed_rustSSL_CIPHER_get_cipher_nidSSL_CIPHER_get_digest_nidSSL_session_reusedOPENSSL_init_sslOPENSSL_INIT_SETTINGSSSL_CTX_set_num_ticketsSSL_set_num_ticketsSSL_CTX_get_num_ticketsSSL_get_num_ticketsSSL_CTX_set_security_levelSSL_set_security_levelSSL_CTX_get_security_levelSSL_get_security_levelOSSL_QUIC_client_methodOSSL_QUIC_client_thread_methodSSL_get_event_timeoutSSL_handle_eventsSSL_get_blocking_modeSSL_set_blocking_modeSSL_get_rpoll_descriptorSSL_get_wpoll_descriptorSSL_net_read_desiredSSL_net_write_desiredSSL_set1_initial_peer_addrBIO_ADDRSSL_shutdown_exSSL_SHUTDOWN_EX_ARGSSSL_stream_concludeSSL_stream_resetSSL_STREAM_RESET_ARGSSSL_get_stream_read_stateSSL_get_stream_write_stateSSL_get_conn_close_infoSSL_CONN_CLOSE_INFOSSL_get0_connectionSSL_is_connectionSSL_get_stream_typeSSL_get_stream_idSSL_new_streamSSL_accept_streamSSL_set_incoming_stream_policySSL_get_accept_stream_queue_lenSSL_set_default_stream_modeSSL_write_ex2SSL_get_value_uintSSL_set_value_uintOPENSSL_sk_pop_freeOSSL_set_max_threadsOSSL_get_max_threadsSSL_get_servernameSSL_export_keying_materialSSL_export_keying_material_earlyASN1_NULLbio_stBN_BLINDINGBN_MONT_CTXEVP_PKEY_ASN1_METHODDH_METHODDSA_METHODRSA_METHODissuer_certsubject_certsubject_reqdb_methdbissuer_pkey// I like the last comment line, it is copied from OpenSSL sources:// Maybe more hereframe_typereason_lenquic_error_codequic_reasonCOMP_CTXCOMP_METHODreturn_sizenotBeforenotAfterX509_VALstack_st_X509_NAME_ENTRYX509_ATTRIBUTEX509_REQ_INFOX509_CRL_INFOX509_CINFstack_st_X509_LOOKUPX509_verify_cert_error_stringX509_signX509_digestX509_REQ_signi2d_X509_bioi2d_X509_REQ_bioi2d_PrivateKey_bioi2d_PUBKEY_bioi2d_PUBKEYi2d_RSA_PUBKEYi2d_DSA_PUBKEYi2d_PrivateKeyi2d_ECPrivateKeyi2d_EC_PUBKEYd2i_PUBKEYd2i_RSA_PUBKEYd2i_DSA_PUBKEYd2i_EC_PUBKEYd2i_ECPrivateKeyX509_gmtime_adjX509_to_X509_REQX509_ALGOR_freeX509_REVOKED_newX509_REVOKED_freeX509_REVOKED_dupd2i_X509_REVOKEDi2d_X509_REVOKEDX509_CRL_newX509_CRL_freed2i_X509_CRLi2d_X509_CRLX509_CRL_dupX509_REQ_newX509_REQ_freed2i_X509_REQi2d_X509_REQX509_REQ_dupX509_get_signature_nidX509_EXTENSION_freeX509_NAME_ENTRY_freeX509_NAME_newX509_NAME_cmpX509_NAME_freeX509_newX509_freei2d_X509X509_NAME_dupX509_dupX509_NAME_add_entryd2i_X509d2i_X509_bioX509_get_pubkeyX509_set_versionX509_get_versionX509_set_serialNumberX509_get_serialNumberX509_alias_get0X509_set_issuer_nameX509_issuer_name_hashX509_subject_name_hashX509_get_issuer_nameX509_set_subject_nameX509_get_subject_nameX509_REQ_set_versionX509_REQ_set_subject_nameX509_REQ_set_pubkeyX509_REQ_get_pubkeyX509_REQ_get_extensionsX509_REQ_add_extensionsX509_REQ_get_attr_countX509_REQ_get_attr_by_NIDX509_REQ_get_attrX509_REQ_delete_attrX509_REQ_add1_attr_by_txtX509_REQ_add1_attr_by_NIDX509_REQ_add1_attr_by_OBJX509_set_pubkeyX509_REQ_verifyX509_REVOKED_get0_extensionsX509_REVOKED_set_serialNumberX509_REVOKED_set_revocationDateX509_CRL_signX509_CRL_digestX509_CRL_verifyX509_CRL_get0_by_certX509_CRL_get0_by_serialX509_get0_extensionsX509_CRL_set_versionX509_CRL_set_issuer_nameX509_CRL_sortX509_CRL_up_refX509_CRL_add0_revokedX509_CRL_set1_lastUpdateX509_CRL_set1_nextUpdateX509_NAME_entry_countX509_NAME_get_index_by_NIDX509_NAME_get_entryX509_NAME_add_entry_by_NIDi2d_X509_NAMEX509_NAME_ENTRY_get_objectX509_NAME_ENTRY_get_dataX509_NAME_add_entry_by_txtd2i_X509_NAMEX509_delete_ext// in X509X509_add_extX509_add1_ext_i2dX509_CRL_delete_ext// in X509_CRLX509_CRL_add_extX509_CRL_add1_ext_i2dX509_REVOKED_delete_ext// in X509_REVOKEDX509_REVOKED_add_extX509_REVOKED_add1_ext_i2dX509v3_get_ext_count// X509_EXTENSION stack// - these getters always used *const STACKX509v3_get_ext_by_NIDX509v3_get_ext_by_criticalX509v3_get_extX509v3_delete_extX509v3_add_extX509_EXTENSION_create_by_NID// - X509V3_add1_i2d in x509v3.rs// X509_EXTENSION itselfX509_EXTENSION_set_criticalX509_EXTENSION_set_dataX509_EXTENSION_get_objectX509_EXTENSION_get_datai2d_X509_EXTENSIONX509_get_ext_countX509_get_ext_by_NIDX509_get_ext_by_OBJX509_get_ext_by_criticalX509_get_extX509_get_ext_d2iX509_CRL_get_ext_countX509_CRL_get_ext_by_NIDX509_CRL_get_ext_by_OBJX509_CRL_get_ext_by_criticalX509_CRL_get_extX509_CRL_get_ext_d2iX509_REVOKED_get_ext_countX509_REVOKED_get_ext_by_NIDX509_REVOKED_get_ext_by_OBJX509_REVOKED_get_ext_by_criticalX509_REVOKED_get_extX509_REVOKED_get_ext_d2iX509v3_get_ext_by_OBJX509_EXTENSION_create_by_OBJX509_EXTENSION_set_objectX509_EXTENSION_get_criticalX509_verify_certX509_STORE_get1_all_certsX509_get_default_cert_file_envX509_get_default_cert_fileX509_get_default_cert_dir_envX509_get_default_cert_dirX509_cmpX509_issuer_and_serial_cmpX509_issuer_name_cmpX509_subject_name_cmpX509_CRL_cmpX509_CRL_matchX509_printX509_REQ_printtrustcheck_purposesnameusr_dataX509_PURPOSE_get_by_snameX509_PURPOSE_get_idX509_PURPOSE_get0X509_ATTRIBUTE_newX509_ATTRIBUTE_freeX509_ATTRIBUTE_createX509_ATTRIBUTE_create_by_NIDX509_ATTRIBUTE_create_by_OBJX509_ATTRIBUTE_create_by_txtX509_ATTRIBUTE_set1_objectX509_ATTRIBUTE_set1_dataX509_ATTRIBUTE_get0_dataX509_ATTRIBUTE_get0_objectX509_ATTRIBUTE_get0_typed2i_X509_ATTRIBUTEX509_ATTRIBUTE_counti2d_X509_ATTRIBUTEX509_ATTRIBUTE_dup// "raw" X509_EXTENSION related functionsX509_LOOKUP_hash_dirX509_LOOKUP_fileX509_LOOKUP_freeX509_LOOKUP_ctrlX509_load_cert_fileX509_load_crl_fileX509_STORE_newX509_STORE_freeX509_STORE_CTX_newX509_STORE_CTX_freeX509_STORE_CTX_initX509_STORE_CTX_cleanupX509_STORE_add_certX509_STORE_set_default_pathsX509_STORE_set_flagsX509_STORE_set_purposeX509_STORE_set_trustX509_STORE_add_lookupX509_STORE_set1_paramX509_STORE_CTX_get_ex_dataX509_STORE_CTX_get_errorX509_STORE_CTX_get_error_depthX509_STORE_CTX_get_current_certX509_STORE_CTX_set_errorX509_VERIFY_PARAM_newX509_VERIFY_PARAM_freeX509_VERIFY_PARAM_set_flagsX509_VERIFY_PARAM_clear_flagsX509_VERIFY_PARAM_set_timeX509_VERIFY_PARAM_set_depthX509_VERIFY_PARAM_get_flagsX509_VERIFY_PARAM_set1_hostX509_VERIFY_PARAM_set_hostflagsX509_VERIFY_PARAM_set1_emailX509_VERIFY_PARAM_set1_ipX509_VERIFY_PARAM_set_auth_levelX509_VERIFY_PARAM_get_auth_levelX509_VERIFY_PARAM_set_purposeGENERAL_NAME_newGENERAL_NAME_freeGENERAL_NAME_set0_othernameACCESS_DESCRIPTION_freeAUTHORITY_KEYIDAUTHORITY_KEYID_freeX509V3_EXT_nconf_nidX509V3_EXT_nconfX509_check_issuedX509_verifyX509V3_set_nconfX509V3_set_ctxX509_get1_ocspX509V3_get_d2iX509V3_extensions_printX509V3_EXT_add_aliasX509V3_EXT_d2iX509V3_EXT_i2dX509V3_add1_i2dX509V3_EXT_printX509_get_pathlenX509_get_extension_flagsX509_get_key_usageX509_get_extended_key_usageX509_get0_subject_key_idX509_get0_authority_key_idX509_get0_authority_issuerX509_get0_authority_serialDIST_POINT_NAME_st_anon_uniondpnamerelativenamereasonsCRLissuerdp_reasonsDIST_POINT_freeDIST_POINT_NAME_freeX509_check_hostX509_check_emailX509_check_ipX509_check_ip_asc"."dtls1handwrittenobj_macssl3// explicitly initialize to work around https://github.com/openssl/openssl/issues/3505PasswordCallback/// Disable explicit initialization of the openssl libs./// This is only appropriate to use if the openssl crate is being consumed by an application/// that will be performing the initialization explicitly./// In some versions of openssl, skipping initialization will fall back to the default procedure/// while other will cause difficult to debug errors so care must be taken when calling this.// configure fixed limit across all rust versions// vendored from the cfg-if crate to avoid breaking ctest// ----------------------------------------------------------------// (partialarg): partial argument, waiting for "final" argument type// MAGIC PART 1: hande conditional const ptr in argument type// continue partial argument with `*mut` pointer (might need special const handling in inner type)// continue partial argument with `*const` pointer (might need special const handling in inner type)// finish partial argument with trailing comma// finish final partial argument (no trailing comma)// (parseargs): parsing arguments// start next argument// end of arguments, there is a return type; start parsing it// end of arguments, no return type// (partialret): have partial return type, waiting for final return type// MAGIC PART 2: hande conditional const ptr in return type// `* mut` part in return type; continue parsing to find inner conditional const ptr// `* const` part in return type; continue parsing to find inner conditional const ptr// final part of return type// generate// (fn): gather tokens for return type until ";"// found end; start parsing current function, and parse remaining functions// not ";" - all other tokens are part of the return type.// don't expand return type yet; otherwise we'd have to remember in which branch `rem` needs// to be used to parse further functions.// (extern): in extern block, find next function// try to split into functions as fast as possible to reduce recursion depth// end of extern block// macro start; find extern block// openssl changes `*mut` to `*const` in certain parameters in certain versions;// in C this is ABI and (mostly) API compatible.// We need to handle this explicitly, and this macro helps annotate which// parameter got converted in which version.// Input is://    extern "C" {//        #[attributes...]//        pub fn name(args) -> rettype; // `-> rettype` optional//        // more functions...// This macro replaces `#[const_ptr_if(...)]` in types with `*const` or `*mut`// (depending on the inner cfg flags)// Walks through all argument and return types, but only finds inner types of// `*const` and `*mut`; doesn't walk arrays or generics.// NOTE: can't abstract `pub` as `$fn_vis:vis`, as ctest macro handling doesn't// support it (old syntax crate). But we really only need `pub` anyway.// NOTE: ctest seams to simply ignore macros it can't expand (whatever the// reason)NID_undefNID_itu_tNID_ccittNID_isoNID_joint_iso_itu_tNID_joint_iso_ccittNID_member_bodyNID_identified_organizationNID_hmac_md5NID_hmac_sha1NID_certicom_arcNID_international_organizationsNID_wapNID_wap_wsgNID_selected_attribute_typesNID_clearanceNID_ISO_USNID_X9_57NID_X9cmNID_dsaNID_dsaWithSHA1NID_ansi_X9_62NID_X9_62_prime_fieldNID_X9_62_characteristic_two_fieldNID_X9_62_id_characteristic_two_basisNID_X9_62_onBasisNID_X9_62_tpBasisNID_X9_62_ppBasisNID_X9_62_id_ecPublicKeyNID_X9_62_c2pnb163v1NID_X9_62_c2pnb163v2NID_X9_62_c2pnb163v3NID_X9_62_c2pnb176v1NID_X9_62_c2tnb191v1NID_X9_62_c2tnb191v2NID_X9_62_c2tnb191v3NID_X9_62_c2onb191v4NID_X9_62_c2onb191v5NID_X9_62_c2pnb208w1NID_X9_62_c2tnb239v1NID_X9_62_c2tnb239v2NID_X9_62_c2tnb239v3NID_X9_62_c2onb239v4NID_X9_62_c2onb239v5NID_X9_62_c2pnb272w1NID_X9_62_c2pnb304w1NID_X9_62_c2tnb359v1NID_X9_62_c2pnb368w1NID_X9_62_c2tnb431r1NID_X9_62_prime192v1NID_X9_62_prime192v2NID_X9_62_prime192v3NID_X9_62_prime239v1NID_X9_62_prime239v2NID_X9_62_prime239v3NID_X9_62_prime256v1NID_ecdsa_with_SHA1NID_ecdsa_with_RecommendedNID_ecdsa_with_SpecifiedNID_ecdsa_with_SHA224NID_ecdsa_with_SHA256NID_ecdsa_with_SHA384NID_ecdsa_with_SHA512NID_secp112r1NID_secp112r2NID_secp128r1NID_secp128r2NID_secp160k1NID_secp160r1NID_secp160r2NID_secp192k1NID_secp224k1NID_secp224r1NID_secp256k1NID_secp384r1NID_secp521r1NID_sect113r1NID_sect113r2NID_sect131r1NID_sect131r2NID_sect163k1NID_sect163r1NID_sect163r2NID_sect193r1NID_sect193r2NID_sect233k1NID_sect233r1NID_sect239k1NID_sect283k1NID_sect283r1NID_sect409k1NID_sect409r1NID_sect571k1NID_sect571r1NID_brainpoolP256r1NID_brainpoolP320r1NID_brainpoolP384r1NID_brainpoolP512r1NID_wap_wsg_idm_ecid_wtls1NID_wap_wsg_idm_ecid_wtls3NID_wap_wsg_idm_ecid_wtls4NID_wap_wsg_idm_ecid_wtls5NID_wap_wsg_idm_ecid_wtls6NID_wap_wsg_idm_ecid_wtls7NID_wap_wsg_idm_ecid_wtls8NID_wap_wsg_idm_ecid_wtls9NID_wap_wsg_idm_ecid_wtls10NID_wap_wsg_idm_ecid_wtls11NID_wap_wsg_idm_ecid_wtls12NID_cast5_cbcNID_cast5_ecbNID_cast5_cfb64NID_cast5_ofb64NID_pbeWithMD5AndCast5_CBCNID_id_PasswordBasedMACNID_id_DHBasedMacNID_rsadsiNID_pkcsNID_pkcs1NID_rsaEncryptionNID_md2WithRSAEncryptionNID_md4WithRSAEncryptionNID_md5WithRSAEncryptionNID_sha1WithRSAEncryptionNID_rsaesOaepNID_mgf1NID_rsassaPssNID_sha256WithRSAEncryptionNID_sha384WithRSAEncryptionNID_sha512WithRSAEncryptionNID_sha224WithRSAEncryptionNID_pkcs3NID_dhKeyAgreementNID_dhpublicnumberNID_pkcs5NID_pbeWithMD2AndDES_CBCNID_pbeWithMD5AndDES_CBCNID_pbeWithMD2AndRC2_CBCNID_pbeWithMD5AndRC2_CBCNID_pbeWithSHA1AndDES_CBCNID_pbeWithSHA1AndRC2_CBCNID_id_pbkdf2NID_pbes2NID_pbmac1NID_pkcs7NID_pkcs7_dataNID_pkcs7_signedNID_pkcs7_envelopedNID_pkcs7_signedAndEnvelopedNID_pkcs7_digestNID_pkcs7_encryptedNID_pkcs9NID_pkcs9_emailAddressNID_pkcs9_unstructuredNameNID_pkcs9_contentTypeNID_pkcs9_messageDigestNID_pkcs9_signingTimeNID_pkcs9_countersignatureNID_pkcs9_challengePasswordNID_pkcs9_unstructuredAddressNID_pkcs9_extCertAttributesNID_ext_reqNID_SMIMECapabilitiesNID_SMIMENID_id_smime_modNID_id_smime_ctNID_id_smime_aaNID_id_smime_algNID_id_smime_cdNID_id_smime_spqNID_id_smime_ctiNID_id_smime_mod_cmsNID_id_smime_mod_essNID_id_smime_mod_oidNID_id_smime_mod_msg_v3NID_id_smime_mod_ets_eSignature_88NID_id_smime_mod_ets_eSignature_97NID_id_smime_mod_ets_eSigPolicy_88NID_id_smime_mod_ets_eSigPolicy_97NID_id_smime_ct_receiptNID_id_smime_ct_authDataNID_id_smime_ct_publishCertNID_id_smime_ct_TSTInfoNID_id_smime_ct_TDTInfoNID_id_smime_ct_contentInfoNID_id_smime_ct_DVCSRequestDataNID_id_smime_ct_DVCSResponseDataNID_id_smime_ct_compressedDataNID_id_ct_asciiTextWithCRLFNID_id_smime_aa_receiptRequestNID_id_smime_aa_securityLabelNID_id_smime_aa_mlExpandHistoryNID_id_smime_aa_contentHintNID_id_smime_aa_msgSigDigestNID_id_smime_aa_encapContentTypeNID_id_smime_aa_contentIdentifierNID_id_smime_aa_macValueNID_id_smime_aa_equivalentLabelsNID_id_smime_aa_contentReferenceNID_id_smime_aa_encrypKeyPrefNID_id_smime_aa_signingCertificateNID_id_smime_aa_smimeEncryptCertsNID_id_smime_aa_timeStampTokenNID_id_smime_aa_ets_sigPolicyIdNID_id_smime_aa_ets_commitmentTypeNID_id_smime_aa_ets_signerLocationNID_id_smime_aa_ets_signerAttrNID_id_smime_aa_ets_otherSigCertNID_id_smime_aa_ets_contentTimestampNID_id_smime_aa_ets_CertificateRefsNID_id_smime_aa_ets_RevocationRefsNID_id_smime_aa_ets_certValuesNID_id_smime_aa_ets_revocationValuesNID_id_smime_aa_ets_escTimeStampNID_id_smime_aa_ets_certCRLTimestampNID_id_smime_aa_ets_archiveTimeStampNID_id_smime_aa_signatureTypeNID_id_smime_aa_dvcs_dvcNID_id_smime_alg_ESDHwith3DESNID_id_smime_alg_ESDHwithRC2NID_id_smime_alg_3DESwrapNID_id_smime_alg_RC2wrapNID_id_smime_alg_ESDHNID_id_smime_alg_CMS3DESwrapNID_id_smime_alg_CMSRC2wrapNID_id_alg_PWRI_KEKNID_id_smime_cd_ldapNID_id_smime_spq_ets_sqt_uriNID_id_smime_spq_ets_sqt_unoticeNID_id_smime_cti_ets_proofOfOriginNID_id_smime_cti_ets_proofOfReceiptNID_id_smime_cti_ets_proofOfDeliveryNID_id_smime_cti_ets_proofOfSenderNID_id_smime_cti_ets_proofOfApprovalNID_id_smime_cti_ets_proofOfCreationNID_friendlyNameNID_localKeyIDNID_ms_csp_nameNID_LocalKeySetNID_x509CertificateNID_sdsiCertificateNID_x509CrlNID_pbe_WithSHA1And128BitRC4NID_pbe_WithSHA1And40BitRC4NID_pbe_WithSHA1And3_Key_TripleDES_CBCNID_pbe_WithSHA1And2_Key_TripleDES_CBCNID_pbe_WithSHA1And128BitRC2_CBCNID_pbe_WithSHA1And40BitRC2_CBCNID_keyBagNID_pkcs8ShroudedKeyBagNID_certBagNID_crlBagNID_secretBagNID_safeContentsBagNID_md2NID_md4NID_md5NID_md5_sha1NID_hmacWithMD5NID_hmacWithSHA1NID_hmacWithSHA224NID_hmacWithSHA256NID_hmacWithSHA384NID_hmacWithSHA512NID_rc2_cbcNID_rc2_ecbNID_rc2_cfb64NID_rc2_ofb64NID_rc2_40_cbcNID_rc2_64_cbcNID_rc4NID_rc4_40NID_des_ede3_cbcNID_rc5_cbcNID_rc5_ecbNID_rc5_cfb64NID_rc5_ofb64NID_ms_ext_reqNID_ms_code_indNID_ms_code_comNID_ms_ctl_signNID_ms_sgcNID_ms_efsNID_ms_smartcard_loginNID_ms_upnNID_idea_cbcNID_idea_ecbNID_idea_cfb64NID_idea_ofb64NID_bf_cbcNID_bf_ecbNID_bf_cfb64NID_bf_ofb64NID_id_pkixNID_id_pkix_modNID_id_peNID_id_qtNID_id_kpNID_id_itNID_id_pkipNID_id_algNID_id_cmcNID_id_onNID_id_pdaNID_id_acaNID_id_qcsNID_id_cctNID_id_pplNID_id_adNID_id_pkix1_explicit_88NID_id_pkix1_implicit_88NID_id_pkix1_explicit_93NID_id_pkix1_implicit_93NID_id_mod_crmfNID_id_mod_cmcNID_id_mod_kea_profile_88NID_id_mod_kea_profile_93NID_id_mod_cmpNID_id_mod_qualified_cert_88NID_id_mod_qualified_cert_93NID_id_mod_attribute_certNID_id_mod_timestamp_protocolNID_id_mod_ocspNID_id_mod_dvcsNID_id_mod_cmp2000NID_info_accessNID_biometricInfoNID_qcStatementsNID_ac_targetingNID_aaControlsNID_sbgp_ipAddrBlockNID_sbgp_autonomousSysNumNID_sbgp_routerIdentifierNID_ac_proxyingNID_sinfo_accessNID_proxyCertInfoNID_id_qt_cpsNID_id_qt_unoticeNID_textNoticeNID_server_authNID_client_authNID_code_signNID_email_protectNID_ipsecEndSystemNID_ipsecTunnelNID_ipsecUserNID_time_stampNID_OCSP_signNID_dvcsNID_id_it_caProtEncCertNID_id_it_signKeyPairTypesNID_id_it_encKeyPairTypesNID_id_it_preferredSymmAlgNID_id_it_caKeyUpdateInfoNID_id_it_currentCRLNID_id_it_unsupportedOIDsNID_id_it_subscriptionRequestNID_id_it_subscriptionResponseNID_id_it_keyPairParamReqNID_id_it_keyPairParamRepNID_id_it_revPassphraseNID_id_it_implicitConfirmNID_id_it_confirmWaitTimeNID_id_it_origPKIMessageNID_id_it_suppLangTagsNID_id_regCtrlNID_id_regInfoNID_id_regCtrl_regTokenNID_id_regCtrl_authenticatorNID_id_regCtrl_pkiPublicationInfoNID_id_regCtrl_pkiArchiveOptionsNID_id_regCtrl_oldCertIDNID_id_regCtrl_protocolEncrKeyNID_id_regInfo_utf8PairsNID_id_regInfo_certReqNID_id_alg_des40NID_id_alg_noSignatureNID_id_alg_dh_sig_hmac_sha1NID_id_alg_dh_popNID_id_cmc_statusInfoNID_id_cmc_identificationNID_id_cmc_identityProofNID_id_cmc_dataReturnNID_id_cmc_transactionIdNID_id_cmc_senderNonceNID_id_cmc_recipientNonceNID_id_cmc_addExtensionsNID_id_cmc_encryptedPOPNID_id_cmc_decryptedPOPNID_id_cmc_lraPOPWitnessNID_id_cmc_getCertNID_id_cmc_getCRLNID_id_cmc_revokeRequestNID_id_cmc_regInfoNID_id_cmc_responseInfoNID_id_cmc_queryPendingNID_id_cmc_popLinkRandomNID_id_cmc_popLinkWitnessNID_id_cmc_confirmCertAcceptanceNID_id_on_personalDataNID_id_on_permanentIdentifierNID_id_pda_dateOfBirthNID_id_pda_placeOfBirthNID_id_pda_genderNID_id_pda_countryOfCitizenshipNID_id_pda_countryOfResidenceNID_id_aca_authenticationInfoNID_id_aca_accessIdentityNID_id_aca_chargingIdentityNID_id_aca_groupNID_id_aca_roleNID_id_aca_encAttrsNID_id_qcs_pkixQCSyntax_v1NID_id_cct_crsNID_id_cct_PKIDataNID_id_cct_PKIResponseNID_id_ppl_anyLanguageNID_id_ppl_inheritAllNID_IndependentNID_ad_OCSPNID_ad_ca_issuersNID_ad_timeStampingNID_ad_dvcsNID_caRepositoryNID_id_pkix_OCSP_basicNID_id_pkix_OCSP_NonceNID_id_pkix_OCSP_CrlIDNID_id_pkix_OCSP_acceptableResponsesNID_id_pkix_OCSP_noCheckNID_id_pkix_OCSP_archiveCutoffNID_id_pkix_OCSP_serviceLocatorNID_id_pkix_OCSP_extendedStatusNID_id_pkix_OCSP_validNID_id_pkix_OCSP_pathNID_id_pkix_OCSP_trustRootNID_algorithmNID_md5WithRSANID_des_ecbNID_des_cbcNID_des_ofb64NID_des_cfb64NID_rsaSignatureNID_dsa_2NID_dsaWithSHANID_shaWithRSAEncryptionNID_des_ede_ecbNID_des_ede3_ecbNID_des_ede_cbcNID_des_ede_cfb64NID_des_ede3_cfb64NID_des_ede_ofb64NID_des_ede3_ofb64NID_desx_cbcNID_shaNID_sha1NID_dsaWithSHA1_2NID_sha1WithRSANID_ripemd160NID_ripemd160WithRSANID_sxnetNID_X500NID_X509NID_commonNameNID_surnameNID_serialNumberNID_countryNameNID_localityNameNID_stateOrProvinceNameNID_streetAddressNID_organizationNameNID_organizationalUnitNameNID_titleNID_descriptionNID_searchGuideNID_businessCategoryNID_postalAddressNID_postalCodeNID_postOfficeBoxNID_physicalDeliveryOfficeNameNID_telephoneNumberNID_telexNumberNID_teletexTerminalIdentifierNID_facsimileTelephoneNumberNID_x121AddressNID_internationaliSDNNumberNID_registeredAddressNID_destinationIndicatorNID_preferredDeliveryMethodNID_presentationAddressNID_supportedApplicationContextNID_memberNID_ownerNID_roleOccupantNID_seeAlsoNID_userPasswordNID_userCertificateNID_cACertificateNID_authorityRevocationListNID_certificateRevocationListNID_crossCertificatePairNID_nameNID_givenNameNID_initialsNID_generationQualifierNID_x500UniqueIdentifierNID_dnQualifierNID_enhancedSearchGuideNID_protocolInformationNID_distinguishedNameNID_uniqueMemberNID_houseIdentifierNID_supportedAlgorithmsNID_deltaRevocationListNID_dmdNameNID_pseudonymNID_roleNID_X500algorithmsNID_rsaNID_mdc2WithRSANID_mdc2NID_id_ceNID_subject_directory_attributesNID_subject_key_identifierNID_key_usageNID_private_key_usage_periodNID_subject_alt_nameNID_issuer_alt_nameNID_basic_constraintsNID_crl_numberNID_crl_reasonNID_invalidity_dateNID_delta_crlNID_issuing_distribution_pointNID_certificate_issuerNID_name_constraintsNID_crl_distribution_pointsNID_certificate_policiesNID_any_policyNID_policy_mappingsNID_authority_key_identifierNID_policy_constraintsNID_ext_key_usageNID_freshest_crlNID_inhibit_any_policyNID_target_informationNID_no_rev_availNID_anyExtendedKeyUsageNID_netscapeNID_netscape_cert_extensionNID_netscape_data_typeNID_netscape_cert_typeNID_netscape_base_urlNID_netscape_revocation_urlNID_netscape_ca_revocation_urlNID_netscape_renewal_urlNID_netscape_ca_policy_urlNID_netscape_ssl_server_nameNID_netscape_commentNID_netscape_cert_sequenceNID_ns_sgcNID_orgNID_dodNID_ianaNID_DirectoryNID_ManagementNID_ExperimentalNID_PrivateNID_SecurityNID_SNMPv2NID_MailNID_EnterprisesNID_dcObjectNID_mime_mhsNID_mime_mhs_headingsNID_mime_mhs_bodiesNID_id_hex_partial_messageNID_id_hex_multipart_messageNID_zlib_compressionNID_aes_128_ecbNID_aes_128_cbcNID_aes_128_ofb128NID_aes_128_cfb128NID_id_aes128_wrapNID_aes_128_gcmNID_aes_128_ccmNID_id_aes128_wrap_padNID_aes_192_ecbNID_aes_192_cbcNID_aes_192_ofb128NID_aes_192_cfb128NID_id_aes192_wrapNID_aes_192_gcmNID_aes_192_ccmNID_id_aes192_wrap_padNID_aes_256_ecbNID_aes_256_cbcNID_aes_256_ofb128NID_aes_256_cfb128NID_id_aes256_wrapNID_aes_256_gcmNID_aes_256_ccmNID_id_aes256_wrap_padNID_aes_128_cfb1NID_aes_192_cfb1NID_aes_256_cfb1NID_aes_128_cfb8NID_aes_192_cfb8NID_aes_256_cfb8NID_aes_128_ctrNID_aes_192_ctrNID_aes_256_ctrNID_aes_128_xtsNID_aes_256_xtsNID_des_cfb1NID_des_cfb8NID_des_ede3_cfb1NID_des_ede3_cfb8NID_sha256NID_sha384NID_sha512NID_sha224NID_dsa_with_SHA224NID_dsa_with_SHA256NID_hold_instruction_codeNID_hold_instruction_noneNID_hold_instruction_call_issuerNID_hold_instruction_rejectNID_dataNID_pssNID_uclNID_pilotNID_pilotAttributeTypeNID_pilotAttributeSyntaxNID_pilotObjectClassNID_pilotGroupsNID_iA5StringSyntaxNID_caseIgnoreIA5StringSyntaxNID_pilotObjectNID_pilotPersonNID_accountNID_documentNID_roomNID_documentSeriesNID_DomainNID_rFC822localPartNID_dNSDomainNID_domainRelatedObjectNID_friendlyCountryNID_simpleSecurityObjectNID_pilotOrganizationNID_pilotDSANID_qualityLabelledDataNID_userIdNID_textEncodedORAddressNID_rfc822MailboxNID_infoNID_favouriteDrinkNID_roomNumberNID_photoNID_userClassNID_hostNID_managerNID_documentIdentifierNID_documentTitleNID_documentVersionNID_documentAuthorNID_documentLocationNID_homeTelephoneNumberNID_secretaryNID_otherMailboxNID_lastModifiedTimeNID_lastModifiedByNID_domainComponentNID_aRecordNID_pilotAttributeType27NID_mXRecordNID_nSRecordNID_sOARecordNID_cNAMERecordNID_associatedDomainNID_associatedNameNID_homePostalAddressNID_personalTitleNID_mobileTelephoneNumberNID_pagerTelephoneNumberNID_friendlyCountryNameNID_organizationalStatusNID_janetMailboxNID_mailPreferenceOptionNID_buildingNameNID_dSAQualityNID_singleLevelQualityNID_subtreeMinimumQualityNID_subtreeMaximumQualityNID_personalSignatureNID_dITRedirectNID_audioNID_documentPublisherNID_id_setNID_set_ctypeNID_set_msgExtNID_set_attrNID_set_policyNID_set_certExtNID_set_brandNID_setct_PANDataNID_setct_PANTokenNID_setct_PANOnlyNID_setct_OIDataNID_setct_PINID_setct_PIDataNID_setct_PIDataUnsignedNID_setct_HODInputNID_setct_AuthResBaggageNID_setct_AuthRevReqBaggageNID_setct_AuthRevResBaggageNID_setct_CapTokenSeqNID_setct_PInitResDataNID_setct_PI_TBSNID_setct_PResDataNID_setct_AuthReqTBSNID_setct_AuthResTBSNID_setct_AuthResTBSXNID_setct_AuthTokenTBSNID_setct_CapTokenDataNID_setct_CapTokenTBSNID_setct_AcqCardCodeMsgNID_setct_AuthRevReqTBSNID_setct_AuthRevResDataNID_setct_AuthRevResTBSNID_setct_CapReqTBSNID_setct_CapReqTBSXNID_setct_CapResDataNID_setct_CapRevReqTBSNID_setct_CapRevReqTBSXNID_setct_CapRevResDataNID_setct_CredReqTBSNID_setct_CredReqTBSXNID_setct_CredResDataNID_setct_CredRevReqTBSNID_setct_CredRevReqTBSXNID_setct_CredRevResDataNID_setct_PCertReqDataNID_setct_PCertResTBSNID_setct_BatchAdminReqDataNID_setct_BatchAdminResDataNID_setct_CardCInitResTBSNID_setct_MeAqCInitResTBSNID_setct_RegFormResTBSNID_setct_CertReqDataNID_setct_CertReqTBSNID_setct_CertResDataNID_setct_CertInqReqTBSNID_setct_ErrorTBSNID_setct_PIDualSignedTBENID_setct_PIUnsignedTBENID_setct_AuthReqTBENID_setct_AuthResTBENID_setct_AuthResTBEXNID_setct_AuthTokenTBENID_setct_CapTokenTBENID_setct_CapTokenTBEXNID_setct_AcqCardCodeMsgTBENID_setct_AuthRevReqTBENID_setct_AuthRevResTBENID_setct_AuthRevResTBEBNID_setct_CapReqTBENID_setct_CapReqTBEXNID_setct_CapResTBENID_setct_CapRevReqTBENID_setct_CapRevReqTBEXNID_setct_CapRevResTBENID_setct_CredReqTBENID_setct_CredReqTBEXNID_setct_CredResTBENID_setct_CredRevReqTBENID_setct_CredRevReqTBEXNID_setct_CredRevResTBENID_setct_BatchAdminReqTBENID_setct_BatchAdminResTBENID_setct_RegFormReqTBENID_setct_CertReqTBENID_setct_CertReqTBEXNID_setct_CertResTBENID_setct_CRLNotificationTBSNID_setct_CRLNotificationResTBSNID_setct_BCIDistributionTBSNID_setext_genCryptNID_setext_miAuthNID_setext_pinSecureNID_setext_pinAnyNID_setext_track2NID_setext_cvNID_set_policy_rootNID_setCext_hashedRootNID_setCext_certTypeNID_setCext_merchDataNID_setCext_cCertRequiredNID_setCext_tunnelingNID_setCext_setExtNID_setCext_setQualfNID_setCext_PGWYcapabilitiesNID_setCext_TokenIdentifierNID_setCext_Track2DataNID_setCext_TokenTypeNID_setCext_IssuerCapabilitiesNID_setAttr_CertNID_setAttr_PGWYcapNID_setAttr_TokenTypeNID_setAttr_IssCapNID_set_rootKeyThumbNID_set_addPolicyNID_setAttr_Token_EMVNID_setAttr_Token_B0PrimeNID_setAttr_IssCap_CVMNID_setAttr_IssCap_T2NID_setAttr_IssCap_SigNID_setAttr_GenCryptgrmNID_setAttr_T2EncNID_setAttr_T2cleartxtNID_setAttr_TokICCsigNID_setAttr_SecDevSigNID_set_brand_IATA_ATANID_set_brand_DinersNID_set_brand_AmericanExpressNID_set_brand_JCBNID_set_brand_VisaNID_set_brand_MasterCardNID_set_brand_NovusNID_des_cdmfNID_rsaOAEPEncryptionSETNID_ipsec3NID_ipsec4NID_whirlpoolNID_cryptoproNID_cryptocomNID_id_GostR3411_94_with_GostR3410_2001NID_id_GostR3411_94_with_GostR3410_94NID_id_GostR3411_94NID_id_HMACGostR3411_94NID_id_GostR3410_2001NID_id_GostR3410_94NID_id_Gost28147_89NID_gost89_cntNID_id_Gost28147_89_MACNID_id_GostR3411_94_prfNID_id_GostR3410_2001DHNID_id_GostR3410_94DHNID_id_Gost28147_89_CryptoPro_KeyMeshingNID_id_Gost28147_89_None_KeyMeshingNID_id_GostR3411_94_TestParamSetNID_id_GostR3411_94_CryptoProParamSetNID_id_Gost28147_89_TestParamSetNID_id_Gost28147_89_CryptoPro_A_ParamSetNID_id_Gost28147_89_CryptoPro_B_ParamSetNID_id_Gost28147_89_CryptoPro_C_ParamSetNID_id_Gost28147_89_CryptoPro_D_ParamSetNID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSetNID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSetNID_id_Gost28147_89_CryptoPro_RIC_1_ParamSetNID_id_GostR3410_94_TestParamSetNID_id_GostR3410_94_CryptoPro_A_ParamSetNID_id_GostR3410_94_CryptoPro_B_ParamSetNID_id_GostR3410_94_CryptoPro_C_ParamSetNID_id_GostR3410_94_CryptoPro_D_ParamSetNID_id_GostR3410_94_CryptoPro_XchA_ParamSetNID_id_GostR3410_94_CryptoPro_XchB_ParamSetNID_id_GostR3410_94_CryptoPro_XchC_ParamSetNID_id_GostR3410_2001_TestParamSetNID_id_GostR3410_2001_CryptoPro_A_ParamSetNID_id_GostR3410_2001_CryptoPro_B_ParamSetNID_id_GostR3410_2001_CryptoPro_C_ParamSetNID_id_GostR3410_2001_CryptoPro_XchA_ParamSetNID_id_GostR3410_2001_CryptoPro_XchB_ParamSetNID_id_GostR3410_94_aNID_id_GostR3410_94_aBisNID_id_GostR3410_94_bNID_id_GostR3410_94_bBisNID_id_Gost28147_89_ccNID_id_GostR3410_94_ccNID_id_GostR3410_2001_ccNID_id_GostR3411_94_with_GostR3410_94_ccNID_id_GostR3411_94_with_GostR3410_2001_ccNID_id_GostR3410_2001_ParamSet_ccNID_camellia_128_cbcNID_camellia_192_cbcNID_camellia_256_cbcNID_id_camellia128_wrapNID_id_camellia192_wrapNID_id_camellia256_wrapNID_camellia_128_ecbNID_camellia_128_ofb128NID_camellia_128_cfb128NID_camellia_192_ecbNID_camellia_192_ofb128NID_camellia_192_cfb128NID_camellia_256_ecbNID_camellia_256_ofb128NID_camellia_256_cfb128NID_camellia_128_cfb1NID_camellia_192_cfb1NID_camellia_256_cfb1NID_camellia_128_cfb8NID_camellia_192_cfb8NID_camellia_256_cfb8NID_kisaNID_seed_ecbNID_seed_cbcNID_seed_cfb128NID_seed_ofb128NID_hmacNID_cmacNID_rc4_hmac_md5NID_aes_128_cbc_hmac_sha1NID_aes_192_cbc_hmac_sha1NID_aes_256_cbc_hmac_sha1NID_X25519NID_X448NID_hkdfNID_poly1305NID_ED25519NID_ED448NID_sm2NID_sm3NID_sm3WithRSAEncryptionNID_sm4_ecbNID_sm4_cbcNID_sm4_ofb128NID_sm4_cfb128NID_sm4_cfb1NID_sm4_cfb8NID_sm4_ctrNID_sha3_224NID_sha3_256NID_sha3_384NID_sha3_512NID_shake128NID_shake256NID_chacha20_poly1305NID_ac_auditEntityOCSP_REVOKED_STATUS_NOSTATUSOCSP_REVOKED_STATUS_UNSPECIFIEDOCSP_REVOKED_STATUS_KEYCOMPROMISEOCSP_REVOKED_STATUS_CACOMPROMISEOCSP_REVOKED_STATUS_AFFILIATIONCHANGEDOCSP_REVOKED_STATUS_SUPERSEDEDOCSP_REVOKED_STATUS_CESSATIONOFOPERATIONOCSP_REVOKED_STATUS_CERTIFICATEHOLDOCSP_REVOKED_STATUS_REMOVEFROMCRLOCSP_NOCERTSOCSP_NOINTERNOCSP_NOSIGSOCSP_NOCHAINOCSP_NOVERIFYOCSP_NOEXPLICITOCSP_NOCASIGNOCSP_NODELEGATEDOCSP_NOCHECKSOCSP_TRUSTOTHEROCSP_RESPID_KEYOCSP_NOTIMEOCSP_RESPONSE_STATUS_SUCCESSFULOCSP_RESPONSE_STATUS_MALFORMEDREQUESTOCSP_RESPONSE_STATUS_INTERNALERROROCSP_RESPONSE_STATUS_TRYLATEROCSP_RESPONSE_STATUS_SIGREQUIREDOCSP_RESPONSE_STATUS_UNAUTHORIZEDV_OCSP_CERTSTATUS_GOODV_OCSP_CERTSTATUS_REVOKEDV_OCSP_CERTSTATUS_UNKNOWNPEM_R_NO_START_LINEPKCS7_TEXTPKCS7_NOCERTSPKCS7_NOSIGSPKCS7_NOCHAINPKCS7_NOINTERNPKCS7_NOVERIFYPKCS7_DETACHEDPKCS7_BINARYPKCS7_NOATTRPKCS7_NOSMIMECAPPKCS7_NOOLDMIMETYPEPKCS7_CRLFEOLPKCS7_STREAMPKCS7_NOCRLPKCS7_PARTIALPKCS7_REUSE_DIGESTRSA_F4EVP_PKEY_CTX_set_rsa_oaep_mdEVP_PKEY_CTX_set0_rsa_oaep_labelEVP_PKEY_CTRL_RSA_PADDINGEVP_PKEY_CTRL_RSA_PSS_SALTLENEVP_PKEY_CTRL_RSA_MGF1_MDEVP_PKEY_CTRL_GET_RSA_PADDINGEVP_PKEY_CTRL_RSA_OAEP_MDEVP_PKEY_CTRL_RSA_OAEP_LABELRSA_PKCS1_PADDINGRSA_NO_PADDINGRSA_PKCS1_OAEP_PADDINGRSA_X931_PADDINGRSA_PKCS1_PSS_PADDING/* AEAD SRTP protection profiles from RFC 7714 */SSL_SENT_SHUTDOWNSSL_RECEIVED_SHUTDOWNSSL_FILETYPE_PEMSSL_FILETYPE_ASN1SSL_EXT_TLS_ONLYSSL_EXT_DTLS_ONLY/* This extension is only allowed in DTLS */SSL_EXT_TLS_IMPLEMENTATION_ONLY/* Some extensions may be allowed in DTLS but we don't implement them for it */SSL_EXT_SSL3_ALLOWED/* Most extensions are not defined for SSLv3 but EXT_TYPE_renegotiate is */SSL_EXT_TLS1_2_AND_BELOW_ONLY/* Extension is only defined for TLS1.2 and below */SSL_EXT_TLS1_3_ONLY/* Extension is only defined for TLS1.3 and above */SSL_EXT_IGNORE_ON_RESUMPTION/* Ignore this extension during parsing if we are resuming */SSL_EXT_CLIENT_HELLOSSL_EXT_TLS1_2_SERVER_HELLO/* Really means TLS1.2 or below */SSL_EXT_TLS1_3_SERVER_HELLOSSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONSSSL_EXT_TLS1_3_HELLO_RETRY_REQUESTSSL_EXT_TLS1_3_CERTIFICATESSL_EXT_TLS1_3_NEW_SESSION_TICKETSSL_EXT_TLS1_3_CERTIFICATE_REQUESTssl_op_typeSSL_OP_LEGACY_SERVER_CONNECTSSL_OP_TLSEXT_PADDINGSSL_OP_SAFARI_ECDHE_ECDSA_BUGSSL_OP_DONT_INSERT_EMPTY_FRAGMENTSSSL_OP_NO_QUERY_MTUSSL_OP_COOKIE_EXCHANGESSL_OP_NO_TICKETSSL_OP_CISCO_ANYCONNECTSSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATIONSSL_OP_NO_COMPRESSIONSSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATIONSSL_OP_ENABLE_MIDDLEBOX_COMPATSSL_OP_PRIORITIZE_CHACHASSL_OP_CIPHER_SERVER_PREFERENCESSL_OP_TLS_ROLLBACK_BUGSSL_OP_NO_SSLv3SSL_OP_NO_TLSv1_1SSL_OP_NO_TLSv1_2SSL_OP_NO_TLSv1SSL_OP_NO_DTLSv1SSL_OP_NO_DTLSv1_2SSL_OP_NO_TLSv1_3SSL_OP_NO_RENEGOTIATIONSSL_OP_NO_SSL_MASKSSL_OP_CRYPTOPRO_TLSEXT_BUGSSL_OP_ALLSSL_OP_MICROSOFT_SESS_ID_BUGSSL_OP_NETSCAPE_CHALLENGE_BUGSSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUGSSL_OP_MICROSOFT_BIG_SSLV3_BUFFERSSL_OP_SSLEAY_080_CLIENT_DH_BUGSSL_OP_TLS_D5_BUGSSL_OP_TLS_BLOCK_PADDING_BUGSSL_OP_SINGLE_ECDH_USESSL_OP_SINGLE_DH_USESSL_OP_NO_SSLv2SSL_MODE_ENABLE_PARTIAL_WRITESSL_MODE_ACCEPT_MOVING_WRITE_BUFFERSSL_MODE_AUTO_RETRYSSL_MODE_NO_AUTO_CHAINSSL_MODE_RELEASE_BUFFERSSSL_MODE_SEND_CLIENTHELLO_TIMESSL_MODE_SEND_SERVERHELLO_TIMESSL_MODE_SEND_FALLBACK_SCSVSSL_CTX_set_modeSSL_COOKIE_LENGTHSSL_set_mtuSSL_get_extms_supportSSL_SESS_CACHE_OFFSSL_SESS_CACHE_CLIENTSSL_SESS_CACHE_SERVERSSL_SESS_CACHE_BOTHSSL_SESS_CACHE_NO_AUTO_CLEARSSL_SESS_CACHE_NO_INTERNAL_LOOKUPSSL_SESS_CACHE_NO_INTERNAL_STORESSL_SESS_CACHE_NO_INTERNALOPENSSL_NPN_UNSUPPORTEDOPENSSL_NPN_NEGOTIATEDOPENSSL_NPN_NO_OVERLAPSSL_AD_ILLEGAL_PARAMETERSSL_AD_DECODE_ERRORSSL_AD_UNRECOGNIZED_NAMESSL_ERROR_NONESSL_ERROR_SSLSSL_ERROR_SYSCALLSSL_ERROR_WANT_ACCEPTSSL_ERROR_WANT_CONNECTSSL_ERROR_WANT_READSSL_ERROR_WANT_WRITESSL_ERROR_WANT_X509_LOOKUPSSL_ERROR_ZERO_RETURNSSL_ERROR_WANT_CLIENT_HELLO_CBSSL_VERIFY_NONESSL_VERIFY_PEERSSL_VERIFY_FAIL_IF_NO_PEER_CERTSSL_CTRL_SET_TMP_DHSSL_CTRL_SET_TMP_ECDHSSL_CTRL_EXTRA_CHAIN_CERTSSL_CTRL_SET_MTUSSL_CTRL_MODESSL_CTRL_SET_READ_AHEADSSL_CTRL_SET_SESS_CACHE_SIZESSL_CTRL_GET_SESS_CACHE_SIZESSL_CTRL_SET_SESS_CACHE_MODESSL_CTRL_SET_TLSEXT_SERVERNAME_CBSSL_CTRL_SET_TLSEXT_SERVERNAME_ARGSSL_CTRL_SET_TLSEXT_HOSTNAMESSL_CTRL_SET_TLSEXT_STATUS_REQ_CBSSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARGSSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPESSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESPSSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESPSSL_CTRL_GET_EXTRA_CHAIN_CERTSSSL_CTRL_CHAIN_CERTSSL_CTRL_SET_GROUPS_LISTSSL_CTRL_SET_SIGALGS_LISTSSL_CTRL_SET_VERIFY_CERT_STORESSL_CTRL_GET_PEER_TMP_KEYSSL_CTRL_GET_EXTMS_SUPPORTSSL_CTRL_SET_MIN_PROTO_VERSIONSSL_CTRL_SET_MAX_PROTO_VERSIONSSL_CTRL_GET_MIN_PROTO_VERSIONSSL_CTRL_GET_MAX_PROTO_VERSIONSSL_CTRL_GET_TMP_KEYSSL_CTX_set_tmp_dhSSL_CTX_set_tmp_ecdhSSL_set_tmp_dhSSL_set_tmp_ecdhSSL_CTX_add_extra_chain_certSSL_CTX_get_extra_chain_certsSSL_CTX_set0_verify_cert_storeSSL_set0_verify_cert_storeSSL_CTX_set1_groups_listSSL_add0_chain_certSSL_CTX_set1_sigalgs_listSSL_CTX_set_min_proto_versionSSL_CTX_set_max_proto_versionSSL_set_min_proto_versionSSL_set_max_proto_versionSSL_CTX_get_min_proto_versionSSL_CTX_get_max_proto_versionSSL_get_min_proto_versionSSL_get_max_proto_versionSSL_get_peer_tmp_keySSL_get_tmp_keySSL_CLIENT_HELLO_SUCCESSSSL_CLIENT_HELLO_ERRORSSL_CLIENT_HELLO_RETRYSSL_READ_EARLY_DATA_ERRORSSL_READ_EARLY_DATA_SUCCESSSSL_READ_EARLY_DATA_FINISHSSL_get_ex_new_indexSSL_CTX_get_ex_new_indexSSL_CTX_sess_set_cache_sizeSSL_CTX_sess_get_cache_sizeSSL_CTX_set_session_cache_modeSSL_CTX_set_read_aheadSSL_CTX_set_tmp_dh_callbackSSL_set_tmp_dh_callbackSSL_CTX_callback_ctrlSSL_CTX_set_alpn_select_cbOPENSSL_INIT_LOAD_SSL_STRINGSOPENSSL_INIT_NO_ATEXITSSL_VALUE_CLASS_GENERICSSL_VALUE_CLASS_FEATURE_REQUESTSSL_VALUE_CLASS_FEATURE_PEER_REQUESTSSL_VALUE_CLASS_FEATURE_NEGOTIATEDSSL_VALUE_NONESSL_VALUE_QUIC_STREAM_BIDI_LOCAL_AVAILSSL_VALUE_QUIC_STREAM_BIDI_REMOTE_AVAILSSL_VALUE_QUIC_STREAM_UNI_LOCAL_AVAILSSL_VALUE_QUIC_STREAM_UNI_REMOTE_AVAILSSL_VALUE_QUIC_IDLE_TIMEOUTSSL_VALUE_EVENT_HANDLING_MODESSL_VALUE_STREAM_WRITE_BUF_SIZESSL_VALUE_STREAM_WRITE_BUF_USEDSSL_VALUE_STREAM_WRITE_BUF_AVAILSSL_VALUE_EVENT_HANDLING_MODE_INHERITSSL_VALUE_EVENT_HANDLING_MODE_IMPLICITSSL_VALUE_EVENT_HANDLING_MODE_EXPLICITSSL_get_generic_value_uintSSL_set_generic_value_uintSSL_get_feature_request_uintSSL_set_feature_request_uintSSL_get_feature_peer_request_uintSSL_get_feature_negotiated_uintSSL_get_quic_stream_bidi_local_availSSL_get_quic_stream_bidi_remote_availSSL_get_quic_stream_uni_local_availSSL_get_quic_stream_uni_remote_availSSL_get_event_handling_modeSSL_set_event_handling_modeSSL_get_stream_write_buf_sizeSSL_get_stream_write_buf_availSSL_get_stream_write_buf_usedSSL3_VERSIONSSL3_AD_ILLEGAL_PARAMETERTLS1_VERSIONTLS1_1_VERSIONTLS1_2_VERSIONTLS1_3_VERSIONDTLS1_VERSIONDTLS1_2_VERSIONTLS1_AD_DECODE_ERRORTLS1_AD_UNRECOGNIZED_NAMETLSEXT_NAMETYPE_host_nameTLSEXT_STATUSTYPE_ocspSSL_set_tlsext_host_nameSSL_set_tlsext_status_typeSSL_get_tlsext_status_ocsp_respSSL_set_tlsext_status_ocsp_respSSL_CTX_set_tlsext_servername_callback// FIXME should have the right signatureSSL_CTX_set_tlsext_servername_callback__fixed_rustSSL_TLSEXT_ERR_OKSSL_TLSEXT_ERR_ALERT_WARNINGSSL_TLSEXT_ERR_ALERT_FATALSSL_TLSEXT_ERR_NOACKSSL_CTX_set_tlsext_servername_argSSL_CTX_set_tlsext_status_cbSSL_CTX_set_tlsext_status_argX509_FILETYPE_PEMX509_FILETYPE_ASN1X509_FILETYPE_DEFAULTASN1_R_HEADER_TOO_LONGX509_V_OKX509_V_ERR_UNSPECIFIEDX509_V_ERR_UNABLE_TO_GET_ISSUER_CERTX509_V_ERR_UNABLE_TO_GET_CRLX509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATUREX509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATUREX509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEYX509_V_ERR_CERT_SIGNATURE_FAILUREX509_V_ERR_CRL_SIGNATURE_FAILUREX509_V_ERR_CERT_NOT_YET_VALIDX509_V_ERR_CERT_HAS_EXPIREDX509_V_ERR_CRL_NOT_YET_VALIDX509_V_ERR_CRL_HAS_EXPIREDX509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELDX509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELDX509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELDX509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELDX509_V_ERR_OUT_OF_MEMX509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERTX509_V_ERR_SELF_SIGNED_CERT_IN_CHAINX509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLYX509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATUREX509_V_ERR_CERT_CHAIN_TOO_LONGX509_V_ERR_CERT_REVOKEDX509_V_ERR_NO_ISSUER_PUBLIC_KEYX509_V_ERR_PATH_LENGTH_EXCEEDEDX509_V_ERR_INVALID_PURPOSEX509_V_ERR_CERT_UNTRUSTEDX509_V_ERR_CERT_REJECTEDX509_V_ERR_SUBJECT_ISSUER_MISMATCHX509_V_ERR_AKID_SKID_MISMATCHX509_V_ERR_AKID_ISSUER_SERIAL_MISMATCHX509_V_ERR_KEYUSAGE_NO_CERTSIGNX509_V_ERR_UNABLE_TO_GET_CRL_ISSUERX509_V_ERR_UNHANDLED_CRITICAL_EXTENSIONX509_V_ERR_KEYUSAGE_NO_CRL_SIGNX509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSIONX509_V_ERR_INVALID_NON_CAX509_V_ERR_PROXY_PATH_LENGTH_EXCEEDEDX509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATUREX509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWEDX509_V_ERR_INVALID_EXTENSIONX509_V_ERR_INVALID_POLICY_EXTENSIONX509_V_ERR_NO_EXPLICIT_POLICYX509_V_ERR_DIFFERENT_CRL_SCOPEX509_V_ERR_UNSUPPORTED_EXTENSION_FEATUREX509_V_ERR_UNNESTED_RESOURCEX509_V_ERR_PERMITTED_VIOLATIONX509_V_ERR_EXCLUDED_VIOLATIONX509_V_ERR_SUBTREE_MINMAXX509_V_ERR_APPLICATION_VERIFICATIONX509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPEX509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAXX509_V_ERR_UNSUPPORTED_NAME_SYNTAXX509_V_ERR_CRL_PATH_VALIDATION_ERRORX509_V_ERR_SUITE_B_INVALID_VERSIONX509_V_ERR_SUITE_B_INVALID_ALGORITHMX509_V_ERR_SUITE_B_INVALID_CURVEX509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHMX509_V_ERR_SUITE_B_LOS_NOT_ALLOWEDX509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256X509_V_ERR_HOSTNAME_MISMATCHX509_V_ERR_EMAIL_MISMATCHX509_V_ERR_IP_ADDRESS_MISMATCHX509_V_ERR_DANE_NO_MATCHX509_V_ERR_EE_KEY_TOO_SMALLX509_V_ERR_CA_KEY_TOO_SMALLX509_V_ERR_CA_MD_TOO_WEAKX509_V_ERR_INVALID_CALLX509_V_ERR_STORE_LOOKUPX509_V_ERR_NO_VALID_SCTSX509_V_ERR_INVALID_CAX509_V_FLAG_CB_ISSUER_CHECKX509_V_FLAG_USE_CHECK_TIMEX509_V_FLAG_CRL_CHECKX509_V_FLAG_CRL_CHECK_ALLX509_V_FLAG_IGNORE_CRITICALX509_V_FLAG_X509_STRICTX509_V_FLAG_ALLOW_PROXY_CERTSX509_V_FLAG_POLICY_CHECKX509_V_FLAG_EXPLICIT_POLICYX509_V_FLAG_INHIBIT_ANYX509_V_FLAG_INHIBIT_MAPX509_V_FLAG_NOTIFY_POLICYX509_V_FLAG_EXTENDED_CRL_SUPPORTX509_V_FLAG_USE_DELTASX509_V_FLAG_CHECK_SS_SIGNATUREX509_V_FLAG_TRUSTED_FIRSTX509_V_FLAG_SUITEB_128_LOS_ONLYX509_V_FLAG_SUITEB_192_LOSX509_V_FLAG_SUITEB_128_LOSX509_V_FLAG_PARTIAL_CHAINX509_V_FLAG_NO_ALT_CHAINSX509_V_FLAG_NO_CHECK_TIMEX509_LOOKUP_add_dir// FIXME should be a unionGEN_OTHERNAMEGEN_EMAILGEN_DNSGEN_X400GEN_DIRNAMEGEN_EDIPARTYGEN_URIGEN_IPADDGEN_RIDX509_CHECK_FLAG_ALWAYS_CHECK_SUBJECTX509_CHECK_FLAG_NO_WILDCARDSX509_CHECK_FLAG_NO_PARTIAL_WILDCARDSX509_CHECK_FLAG_MULTI_LABEL_WILDCARDSX509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINSX509_CHECK_FLAG_NEVER_CHECK_SUBJECTX509V3_ADD_DEFAULTX509V3_ADD_APPENDX509V3_ADD_REPLACEX509V3_ADD_REPLACE_EXISTINGX509V3_ADD_KEEP_EXISTINGX509V3_ADD_DELETEX509V3_ADD_SILENTEXFLAG_BCONSEXFLAG_KUSAGEEXFLAG_XKUSAGEEXFLAG_NSCERTEXFLAG_CAEXFLAG_SIEXFLAG_V1EXFLAG_INVALIDEXFLAG_SETEXFLAG_CRITICALEXFLAG_PROXYEXFLAG_INVALID_POLICYEXFLAG_FRESHESTEXFLAG_SSX509v3_KU_DIGITAL_SIGNATUREX509v3_KU_NON_REPUDIATIONX509v3_KU_KEY_ENCIPHERMENTX509v3_KU_DATA_ENCIPHERMENTX509v3_KU_KEY_AGREEMENTX509v3_KU_KEY_CERT_SIGNX509v3_KU_CRL_SIGNX509v3_KU_ENCIPHER_ONLYX509v3_KU_DECIPHER_ONLYX509v3_KU_UNDEFXKU_SSL_SERVERXKU_SSL_CLIENTXKU_SMIMEXKU_CODE_SIGNXKU_SGCXKU_OCSP_SIGNXKU_TIMESTAMPXKU_DVCSXKU_ANYEKUX509_PURPOSE_SSL_CLIENTX509_PURPOSE_SSL_SERVERX509_PURPOSE_NS_SSL_SERVERX509_PURPOSE_SMIME_SIGNX509_PURPOSE_SMIME_ENCRYPTX509_PURPOSE_CRL_SIGNX509_PURPOSE_ANYX509_PURPOSE_OCSP_HELPERX509_PURPOSE_TIMESTAMP_SIGNX509_PURPOSE_CODE_SIGNX509_PURPOSE_MINX509_PURPOSE_MAXCRL_REASON_UNSPECIFIEDCRL_REASON_KEY_COMPROMISECRL_REASON_CA_COMPROMISECRL_REASON_AFFILIATION_CHANGEDCRL_REASON_SUPERSEDEDCRL_REASON_CESSATION_OF_OPERATIONCRL_REASON_CERTIFICATE_HOLDCRL_REASON_REMOVE_FROM_CRLCRL_REASON_PRIVILEGE_WITHDRAWNCRL_REASON_AA_COMPROMISEmap_or2map_or_else2r#impl/// Returns `true` if the option is a [`Some`] value containing the given value./// use option_ext::OptionExt;/// let x: Option<u32> = Some(2);/// assert_eq!(x.contains(&2), true);/// let x: Option<u32> = Some(3);/// assert_eq!(x.contains(&2), false);/// let x: Option<u32> = None;/// Returns the result from applying the function to the contained value if the option is [`Some`],/// or returns provided default result if the option is [`None`]./// The `f` argument of `map_or2` is only evaluated  if the option is [`Some`]./// The default argument of `map_or2` is always evaluated – even if the option is [`Some`]./// Use [`map_or_else2`] to avoid this./// [`map_or_else2`]: OptionExt::map_or_else2/// let x = Some("bar");/// assert_eq!(x.map_or2(|v| v.len(), 42), 3);/// let x: Option<&str> = None;/// assert_eq!(x.map_or2(|v| v.len(), 42), 42);/// or returns the result from evaluating the provided default function if the option is [`None`]./// The `f` argument of `map_or_else2` is only evaluated  if the option is [`Some`]./// The default argument of `map_or_else2` is only evaluated if the option is [`None`]./// Use [`map_or2`] to always evaluate the default argument./// [`map_or2`]: OptionExt::map_or2/// let k = 23;/// assert_eq!(x.map_or_else2(|v| v.len(), || 2 * k), 3);/// assert_eq!(x.map_or_else2(|v| v.len(), || 2 * k), 46);/// Extension trait providing additional methods for `Option`.list_ordered_multimapListOrderedMultimapVecListIntoIterVecListIterVecListIterMut/// The hasher builder that constructs new hashers for hashing keys. We have to keep this
/// separate from the hashmap itself as we need to be able to access it when the hashmap keys
/// are reallocated due to reallocation. We cannot use the hash of the actual keys in the map
/// as those hashes are not representative of what hash they truly represent.
/// The list of the keys in the multimap. This is ordered by time of insertion.
MapEntryDummyState/// The map from indices of keys to the indices of their values in the value list. The list of
/// the indices is ordered by time of insertion. We never use hasher of the hashmap explicitly
/// here, we instead use [`ListOrderedMultimap::build_hasher`].
ValueEntry/// The list of the values in the multimap. This is ordered by time of insertion.
/// Creates a new multimap with no initial capacity.
/// use ordered_multimap::ListOrderedMultimap;
/// let mut map = ListOrderedMultimap::new();
/// map.insert("key1", "value1");
/// assert_eq!(map.get(&"key1"), Some(&"value1"));
/// Creates a new multimap with the specified capacities.
/// The multimap will be able to hold at least `key_capacity` keys and `value_capacity` values
/// without reallocating. A capacity of 0 will result in no allocation for the respective
/// container.
/// let map: ListOrderedMultimap<&str, &str> = ListOrderedMultimap::new();
/// assert_eq!(map.keys_capacity(), 0);
/// assert_eq!(map.values_capacity(), 0);
/// let map: ListOrderedMultimap<&str, &str> = ListOrderedMultimap::with_capacity(5, 10);
/// assert_eq!(map.keys_capacity(), 5);
/// assert_eq!(map.values_capacity(), 10);
/// Appends a value to the list of values associated with the given key.
/// If the key is not already in the multimap, this will be identical to an insert and the
/// return value will be `false`. Otherwise, `true` will be returned.
/// let already_exists = map.append("key", "value");
/// assert!(!already_exists);
/// assert_eq!(map.values_len(), 1);
/// assert_eq!(map.get(&"key"), Some(&"value"));
/// let already_exists = map.append("key", "value2");
/// assert!(already_exists);
/// assert_eq!(map.values_len(), 2);
/// Returns an immutable reference to the first key-value pair in the multimap
/// assert_eq!(map.back(), None);
/// map.insert("key", "value");
/// assert_eq!(map.back(), Some((&"key", &"value")));
/// assert_eq!(map.back_mut(), None);
/// assert_eq!(map.back_mut(), Some((&"key", &mut "value")));
/// Removes all keys and values from the multimap.
/// Complexity: O(|K| + |V|) where |K| is the number of keys and |V| is the number of values.
/// assert_eq!(map.keys_len(), 1);
/// map.clear();
/// assert_eq!(map.keys_len(), 0);
/// assert_eq!(map.values_len(), 0);
KeyQuery/// Returns whether the given key is in the multimap.
/// assert!(!map.contains_key(&"key"));
/// assert!(map.contains_key(&"key"));
/// let value = map.entry("key").or_insert("value");
/// assert_eq!(value, &"value");
/// Returns the number of values associated with a key.
/// assert_eq!(map.entry_len(&"key"), 0);
/// map.insert("key", "value1");
/// assert_eq!(map.entry_len(&"key"), 1);
/// map.append(&"key", "value2");
/// assert_eq!(map.entry_len(&"key"), 2);
/// assert_eq!(map.front(), None);
/// assert_eq!(map.front(), Some((&"key", &"value")));
/// assert_eq!(map.front_mut(), None);
/// assert_eq!(map.front_mut(), Some((&"key", &mut "value")));
/// Returns an immutable reference to the first value, by insertion order, associated with the
/// given key, or `None` if the key is not in the multimap.
/// let mut map: ListOrderedMultimap<&str, &str> = ListOrderedMultimap::new();
/// assert_eq!(map.get(&"key"), None);
EntryValues/// Returns an iterator that yields immutable references to all values associated with the
/// given key by insertion order.
/// If the key is not in the multimap, the iterator will yield no values.
/// map.append("key", "value2");
/// let mut iter = map.get_all(&"key");
/// assert_eq!(iter.next(), Some(&"value"));
/// assert_eq!(iter.next(), Some(&"value2"));
get_all_mutEntryValuesMut/// Returns an iterator that yields mutable references to all values associated with the given
/// key by insertion order.
/// let mut iter = map.get_all_mut(&"key");
/// let first = iter.next().unwrap();
/// assert_eq!(first, &mut "value1");
/// *first = "value3";
/// assert_eq!(iter.next(), Some(&mut "value2"));
/// assert_eq!(map.get(&"key"), Some(&"value3"));
/// Returns a mutable reference to the first value, by insertion order, associated with the
/// let mut value = map.get_mut(&"key").unwrap();
/// *value = "value2";
/// assert_eq!(map.get(&"key"), Some(&"value2"));
/// Returns a reference to the multimap's [`BuildHasher`].
/// let hasher = map.hasher();
/// Inserts the key-value pair into the multimap and returns the first value, by insertion
/// order, that was already associated with the key.
/// If the key is not already in the multimap, `None` will be returned. If the key is already in
/// the multimap, the insertion ordering of the keys will remain unchanged.
/// Complexity: O(1) amortized
/// assert!(map.is_empty());
/// let old_value = map.insert("key", "value");
/// assert!(old_value.is_none());
/// let old_value = map.insert("key", "value2");
/// assert_eq!(old_value, Some("value"));
insert_allEntryValuesDrain/// Inserts the key-value pair into the multimap and returns an iterator that yields all values
/// previously associated with the key by insertion order.
/// If the key is not already in the multimap, the iterator will yield no values.If the key is
/// already in the multimap, the insertion ordering of the keys will remain unchanged.
///     let mut old_values = map.insert_all("key", "value");
///     assert_eq!(old_values.next(), None);
///     let mut old_values = map.insert_all("key", "value3");
///     assert_eq!(old_values.next(), Some("value"));
///     assert_eq!(old_values.next(), Some("value2"));
/// Returns whether the multimap is empty.
/// map.insert("key1", "value");
/// assert!(!map.is_empty());
/// map.remove(&"key1");
/// Returns an iterator that yields immutable references to all key-value pairs in the multimap
/// by insertion order.
/// map.insert("key2", "value1");
/// map.append(&"key1", "value2");
/// map.append(&"key2", "value2");
/// let mut iter = map.iter();
/// assert_eq!(iter.size_hint(), (4, Some(4)));
/// assert_eq!(iter.next(), Some((&"key1", &"value1")));
/// assert_eq!(iter.next(), Some((&"key2", &"value1")));
/// assert_eq!(iter.next(), Some((&"key1", &"value2")));
/// assert_eq!(iter.next(), Some((&"key2", &"value2")));
/// Returns an iterator that yields mutable references to all key-value pairs in the multimap by
/// insertion order.
/// Only the values are mutable, the keys are immutable.
/// let mut iter = map.iter_mut();
/// assert_eq!(first, (&"key1", &mut "value1"));
/// *first.1 = "value3";
/// assert_eq!(iter.next(), Some((&"key2", &mut "value1")));
/// assert_eq!(iter.next(), Some((&"key1", &mut "value2")));
/// assert_eq!(iter.next(), Some((&"key2", &mut "value2")));
/// assert_eq!(map.get(&"key1"), Some(&"value3"));
/// Returns an iterator that yields immutable references to all keys in the multimap by
/// Insertion order of keys is determined by the order in which a given key is first inserted
/// into the multimap with a value. Any subsequent insertions with that key without first
/// removing it will not affect its ordering.
/// map.insert("key2", "value");
/// map.insert("key3", "value");
/// let mut keys = map.keys();
/// assert_eq!(keys.next(), Some(&"key1"));
/// assert_eq!(keys.next(), Some(&"key2"));
/// assert_eq!(keys.next(), Some(&"key3"));
/// assert_eq!(keys.next(), None);
keys_capacity/// Returns the number of keys the multimap can hold without reallocating.
/// This number is a lower bound, and the multimap may be able to hold more.
/// assert!(map.keys_capacity() > 0);
/// Returns the number of keys in the multimap.
/// assert_eq!(map.keys_len(), 3);
/// Reorganizes the multimap to ensure maximum spatial locality and changes the key and value
/// capacities to the provided values.
/// This function can be used to actually increase the capacity of the multimap.
/// Panics if either of the given minimum capacities are less than their current respective
/// lengths.
/// let mut map = ListOrderedMultimap::with_capacity(10, 10);
/// map.insert("key2", "value2");
/// map.append("key2", "value3");
/// map.append("key1", "value4");
/// map.pack_to(5, 5);
/// assert_eq!(map.keys_len(), 2);
/// assert_eq!(map.values_capacity(), 5);
/// assert_eq!(map.values_len(), 4);
/// Reorganizes the multimap to ensure maximum spatial locality and removes any excess key and
/// value capacity.
/// let mut map = ListOrderedMultimap::with_capacity(5, 5);
/// map.pack_to_fit();
/// assert_eq!(map.keys_capacity(), 2);
/// assert_eq!(map.values_capacity(), 4);
pairsKeyValues/// Returns an iterator that yields immutable references to keys and all associated values with
/// those keys as separate iterators. The order of yielded pairs will be the order in which the
/// keys were first inserted into the multimap.
/// let mut iter = map.pairs();
/// let (key, mut values) = iter.next().unwrap();
/// assert_eq!(key, &"key");
/// assert_eq!(values.next(), Some(&"value1"));
/// assert_eq!(values.next(), Some(&"value2"));
/// assert_eq!(values.next(), None);
pairs_mutKeyValuesMut/// Returns an iterator that yields immutable references to keys and mutable references to all
/// associated values with those keys as separate iterators. The order of yielded pairs will be
/// the order in which the keys were first inserted into the multimap.
/// let mut iter = map.pairs_mut();
/// assert_eq!(values.next(), Some(&mut "value1"));
/// assert_eq!(values.next(), Some(&mut "value2"));
KeyWrapper/// Removes the last key-value pair to have been inserted.
/// Because a single key can be associated with many values, the key returned by this function
/// is a [`KeyWrapper`] which can be either owned or borrowed. If the value removed was the only
/// value associated with the key, then the key will be returned. Otherwise, a reference to the
/// key will be returned.
/// This function along with [`ListOrderedMultimap::pop_front`] act as replacements for a drain
/// iterator since an iterator cannot be done over [`KeyWrapper`].
/// use ordered_multimap::list_ordered_multimap::KeyWrapper;
/// let (key, value) = map.pop_back().unwrap();
/// assert_eq!(key, KeyWrapper::Borrowed(&"key"));
/// assert_eq!(&value, &"value2");
/// assert_eq!(key, KeyWrapper::Owned("key"));
/// assert_eq!(&value, &"value1");
/// Removes the first key-value pair to have been inserted.
/// This function along with [`ListOrderedMultimap::pop_back`] act as replacements for a drain
/// let (key, value) = map.pop_front().unwrap();
/// Removes all values associated with the given key from the map and returns the first value
/// let removed_value = map.remove(&"key");
/// assert_eq!(removed_value, None);
/// assert_eq!(removed_value, Some("value"));
/// Removes all values associated with the given key from the map and returns an iterator that
/// yields those values.
/// If the key is not already in the map, the iterator will yield no values.
///     let mut removed_values = map.remove_all(&"key");
///     assert_eq!(removed_values.next(), None);
/// assert_eq!(map.get(&"key"), Some(&"value1"));
///     assert_eq!(removed_values.next(), Some("value1"));
///     assert_eq!(removed_values.next(), Some("value2"));
/// Removes all values associated with the given key from the map and returns the key and first
/// value.
/// If the key is not already in the map, then `None` will be returned.
/// let entry = map.remove_entry(&"key");
/// assert_eq!(entry, None);
/// assert_eq!(entry, Some(("key", "value")));
remove_entry_all/// Removes all values associated with the given key from the map and returns the key and an
/// iterator that yields those values.
///     let entry = map.remove_entry_all(&"key");
///     assert!(entry.is_none());
///     let (key, mut iter) = map.remove_entry_all(&"key").unwrap();
///     assert_eq!(key, "key");
///     assert_eq!(iter.next(), Some("value1"));
///     assert_eq!(iter.next(), Some("value2"));
reserve_keys/// Reserves additional capacity such that more keys can be stored in the multimap.
/// If the existing capacity minus the current length is enough to satisfy the additional
/// capacity, the capacity will remain unchanged.
/// If the capacity is increased, the capacity may be increased by more than what was requested.
/// let mut map = ListOrderedMultimap::with_capacity(1, 1);
/// assert_eq!(map.keys_capacity(), 1);
/// map.reserve_keys(10);
/// assert!(map.keys_capacity() >= 11);
reserve_values/// Reserves additional capacity such that more values can be stored in the multimap.
/// assert_eq!(map.values_capacity(), 1);
/// map.reserve_values(10);
/// assert!(map.values_capacity() >= 11);
/// Keeps all key-value pairs that satisfy the given predicate function.
/// Complexity: O(|V|) where |V| is the number of values
/// map.insert("key1", 1);
/// map.insert("key2", 5);
/// map.append("key1", -1);
/// map.insert("key3", -10);
/// map.retain(|_, &mut value| value >= 0);
/// assert_eq!(iter.next(), Some((&"key1", &1)));
/// assert_eq!(iter.next(), Some((&"key2", &5)));
retain_helper/// Helper function for [`ListOrderedMultimap::retain`] to deal with borrowing issues.
/// Returns an iterator that yields immutable references to all values in the multimap by
/// let mut iter = map.values();
/// assert_eq!(iter.next(), Some(&"value1"));
/// Returns an iterator that yields mutable references to all values in the multimap by
/// let mut iter = map.values_mut();
/// assert_eq!(iter.next(), Some(&mut "value1"));
values_capacity/// Returns the number of values the multimap can hold without reallocating.
/// assert!(map.values_capacity() > 0);
values_len/// Returns the total number of values in the multimap across all keys.
/// map.append("key1", "value2");
/// Creates a new multimap with the specified capacities and the given hash builder to hash
/// keys.
/// The `state` is normally randomly generated and is designed to allow multimaps to be
/// resistant to attacks that cause many collisions and very poor performance. Setting it
/// manually using this function can expose a DoS attack vector.
/// use std::collections::hash_map::RandomState;
/// let state = RandomState::new();
/// let mut map = ListOrderedMultimap::with_capacity_and_hasher(10, 10, state);
/// assert_eq!(map.keys_capacity(), 10);
/// Creates a new multimap with no capacity which will use the given hash builder to hash keys.
/// let mut map = ListOrderedMultimap::with_hasher(state);
/// An immutable reference to a key. This implies that the key is still associated to at least
/// one value in the multimap.
/// An owned key. This will occur when a key is no longer associated with any values in the
/// multimap.
/// A wrapper around a key that is either borrowed or owned.
/// This type is similar to [`std::borrow::Cow`] but does not require a [`Clone`] trait bound on the
/// key.
/// If the key wrapped is owned, it is returned. Otherwise, the borrowed key is cloned and
/// returned.
/// let borrowed = KeyWrapper::Borrowed(&0);
/// assert_eq!(borrowed.into_owned(), 0);
/// let owned = KeyWrapper::Owned(0);
is_borrowed/// Returns whether the wrapped key is borrowed.
/// assert!(borrowed.is_borrowed());
/// assert!(!owned.is_borrowed());
/// Returns whether the wrapped key is owned.
/// assert!(!borrowed.is_owned());
/// assert!(owned.is_owned());
head_index/// The index of the first value for this entry.
/// The number of values for this entry.
tail_index/// The index of the last value for this entry.
/// The value type of the internal hash map.
/// Convenience function for adding a new value to the entry.
/// Convenience function for creating a new multimap entry.
/// Convenience function for resetting the entry to contain only one value.
key_index/// The index of the key in the key list for this entry.
/// The index of the next value with the same key.
previous_index/// The index of the previous value with the same key.
/// The actual value stored in this entry.
/// The value entry that is contained within the internal values list.
/// Convenience function for creating a new value entry.
/// An occupied entry associated with one or more values.
/// A vacant entry with no associated values.
/// A view into a single entry in the multimap, which may either be vacant or occupied.
/// Calls the given function with a mutable reference to the first value of this entry, by
/// insertion order, if it is vacant, otherwise this function is a no-op.
/// map.entry("key")
///     .and_modify(|value| *value += 1)
///     .or_insert(42);
/// assert_eq!(map.get(&"key"), Some(&42));
/// assert_eq!(map.get(&"key"), Some(&43));
/// If the entry is vacant, the given value will be inserted into it and a mutable reference to
/// that value will be returned. Otherwise, a mutable reference to the first value, by insertion
/// order, will be returned.
/// let value = map.entry("key").or_insert("value2");
/// assert_eq!(value, &"value1");
/// let value = map.entry("key2").or_insert("value2");
/// assert_eq!(value, &"value2");
/// If the entry is vacant, the given value will be inserted into it and the new occupied entry
/// will be returned. Otherwise, the existing occupied entry will be returned.
/// let entry = map.entry("key").or_insert_entry("value2");
/// assert_eq!(entry.into_mut(), &"value1");
/// let entry = map.entry("key2").or_insert_entry("value2");
/// assert_eq!(entry.into_mut(), &"value2");
/// If the entry is vacant, the value returned from the given function will be inserted into it
/// and a mutable reference to that value will be returned. Otherwise, a mutable reference to
/// the first value, by insertion order, will be returned.
/// let value = map.entry("key").or_insert_with(|| "value2");
/// let value = map.entry("key2").or_insert_with(|| "value2");
or_insert_with_entry/// and the new occupied entry will be returned. Otherwise, the existing occupied entry will be
/// let entry = map.entry("key").or_insert_with_entry(|| "value2");
/// let entry = map.entry("key2").or_insert_with_entry(|| "value2");
/// A view into an occupied entry in the multimap.
/// use ordered_multimap::list_ordered_multimap::Entry;
/// let mut entry = match map.entry("key") {
///     Entry::Occupied(entry) => entry,
///     _ => panic!("expected occupied entry")
/// };
/// entry.append("value2");
/// assert_eq!(entry.get(), &"value");
/// assert_eq!(entry.get(), &mut "value");
/// entry.insert("value2");
/// let mut iter = entry.insert_all("value3");
/// assert_eq!(iter.next(), Some("value1"));
/// assert_eq!(iter.next(), Some("value2"));
/// assert_eq!(entry.into_mut(), &mut "value");
/// let mut iter = entry.iter();
/// let mut iter = entry.iter_mut();
/// assert_eq!(entry.key(), &"key");
/// assert_eq!(entry.len(), 1);
/// assert_eq!(entry.len(), 2);
/// assert_eq!(entry.remove(), "value");
/// let mut iter = entry.remove_all();
/// assert_eq!(entry.remove_entry(), ("key", "value"));
/// let (key, mut iter) = entry.remove_entry_all();
/// assert_eq!(key, "key");
/// The builder hasher for the map, kept separately for mutability concerns.
/// The hash of the key for the entry.
/// The key for this entry for when it is to be inserted into the map.
/// Reference to the multimap.
/// A view into a vacant entry in the multimap.
///     Entry::Vacant(entry) => entry,
///     _ => panic!("expected vacant entry")
/// assert_eq!(entry.insert("value"), &"value");
/// let mut entry = entry.insert_entry("value");
/// assert_eq!(entry.into_key(), "key");
/// The first index of the values not yet yielded.
/// The remaining number of values to be yielded.
/// The last index of the values not yet yielded.
/// The list of the values in the map. This is ordered by time of insertion.
/// An iterator that yields immutable references to all values of a given key. The order of the
/// values is always in the order that they were inserted.
/// Convenience function for creating an empty iterator.
from_map_entry/// Convenience function for creating a new iterator from a map entry.
/// An iterator that moves all values of a given key out of a multimap but preserves the underlying
/// capacity. The order of the values is always in the order that they were inserted.
/// Creates an iterator that yields immutable references to all values of a given key.
/// Because [`EntryValuesMut::values`] is a pointer, we need to have a phantom data here for the
/// An iterator that yields mutable references to all values of a given key. The order of the values
/// is always in the order that they were inserted.
// The list of the keys in the map. This is ordered by time of insertion.
/// The iterator over the list of all values. This is ordered by time of insertion.
/// An iterator that owns and yields all key-value pairs in a multimap by cloning the keys for their
/// possibly multiple values. This is unnecessarily expensive whenever [`Iter`] or [`IterMut`] would
/// suit as well. The order of the yielded items is always in the order that they were inserted.
/// Creates an iterator that yields immutable references to all key-value pairs in a multimap.
/// An iterator that yields immutable references to all key-value pairs in a multimap. The order of
/// the yielded items is always in the order that they were inserted.
/// An iterator that yields mutable references to all key-value pairs in a multimap. The order of
/// The internal mapping from key hashes to associated value indices.
/// An iterator that yields immutable references to all keys and their value iterators. The order of
/// the yielded items is always in the order the keys were first inserted.
/// Creates an iterator that yields mutable references to all key-value pairs of a multimap.
/// An iterator that yields immutable references to all keys in the multimap. The order of the keys
/// is always in the order that they were first inserted.
/// An iterator that yields immutable references to all values of a multimap. The order of the
/// An iterator that yields mutable references to all values of a multimap. The order of the values
/// Creates an iterator that yields immutable references to all values of a multimap.
/// Dummy builder hasher that is not meant to be used. It is simply a placeholder.
DummyHasher/// Dummy hasher that is not meant to be used. It is simply a placeholder.
hash_key/// Computes the hash value of the given key.
raw_entry_mut_emptytest_collisiontest_entry_and_modifytest_entry_or_inserttest_entry_or_insert_entrytest_entry_or_insert_withtest_entry_or_insert_with_entrytest_entry_values_debugtest_entry_values_double_endedtest_entry_values_drain_debugtest_entry_values_drain_double_endedtest_entry_values_drain_emptytest_entry_values_drain_fusedtest_entry_values_drain_size_hinttest_entry_values_emptytest_entry_values_fusedtest_entry_values_mut_debugtest_entry_values_mut_double_endedtest_entry_values_mut_emptytest_entry_values_mut_fusedtest_entry_values_mut_size_hinttest_entry_values_size_hinttest_key_values_debugtest_key_values_double_endedtest_key_values_emptytest_key_values_fusedtest_key_values_mut_debugtest_key_values_mut_double_endedtest_key_values_mut_emptytest_key_values_mut_fusedtest_key_values_mut_size_hinttest_key_values_size_hinttest_keys_debugtest_keys_double_endedtest_keys_emptytest_keys_fusedtest_keys_size_hinttest_list_ordered_multimap_appendtest_list_ordered_multimap_backtest_list_ordered_multimap_back_muttest_list_ordered_multimap_cleartest_list_ordered_multimap_contains_keytest_list_ordered_multimap_debugtest_list_ordered_multimap_entrytest_list_ordered_multimap_entry_lentest_list_ordered_multimap_equalitytest_list_ordered_multimap_extendtest_list_ordered_multimap_from_iteratortest_list_ordered_multimap_gettest_list_ordered_multimap_get_alltest_list_ordered_multimap_get_all_muttest_list_ordered_multimap_get_muttest_list_ordered_multimap_inserttest_list_ordered_multimap_insert_alltest_list_ordered_multimap_is_emptytest_list_ordered_multimap_itertest_list_ordered_multimap_iter_muttest_list_ordered_multimap_keystest_list_ordered_multimap_keys_capacitytest_list_ordered_multimap_keys_lentest_list_ordered_multimap_newtest_list_ordered_multimap_pack_totest_list_ordered_multimap_pack_to_panic_key_capacitytest_list_ordered_multimap_pack_to_panic_value_capacitytest_list_ordered_multimap_pack_to_fittest_list_ordered_multimap_pairstest_list_ordered_multimap_pairs_muttest_list_ordered_multimap_pop_backtest_list_ordered_multimap_pop_fronttest_list_ordered_multimap_removetest_list_ordered_multimap_remove_alltest_list_ordered_multimap_remove_entrytest_list_ordered_multimap_remove_entry_alltest_list_ordered_multimap_reserve_keystest_list_ordered_multimap_reserve_valuestest_list_ordered_multimap_retaintest_list_ordered_multimap_valuestest_list_ordered_multimap_values_muttest_list_ordered_multimap_values_capacitytest_list_ordered_multimap_values_lentest_list_ordered_multimap_with_capacitytest_list_ordered_multimap_with_capacity_and_hashertest_occupied_entry_debugtest_vacant_entry_debugtest_values_debugtest_values_double_endedtest_values_emptytest_values_fusedtest_values_mut_debugtest_values_mut_double_endedtest_values_mut_emptytest_values_mut_fusedtest_values_mut_size_hinttest_values_size_hintListOrderedMultimapVisitor/// Apply a closure to the data./// This does not change the ordering.map_itemMapItem/// Apply a closure to the items that has access to the ordering data.NewOrderingNewDatamap_orderingMapOrdering/// Apply a closure to the items that can change the type of the ordering value./// A bidirectional mapping for ordering values is required in order to remap `before` values./// It is the caller's responsibility to ensure that the items in the mapped stream still meet/// the ordering requirements that [`OrderedStream`] expects./// Apply a closure that produces a [`Future`] to items, running the future on each item in/// sequence before processing the next./// This has the side effect of buffering items that are not before the requested ordering/// point; you can use [`ready`](core::future::ready) as the closure to take advantage of this/// behavior if you don't want to buffer items yourself./// Convert this into a [`Stream`], discarding the ordering information.into_tuple_streamIntoTupleStream/// Convert this into a [`Stream`], keeping the ordering objects.into_orderingIntoOrdering/// Convert this into a [`Stream`], keeping only the ordering objects./// Return the next item in this stream.next_beforeNextBefore/// Return a [`PollResult`] corresponding to the next item in the stream.OrderedStreamExtOrderedStream/// Helpers for chaining [`OrderedStream`]s.r" An [`OrderedStream`] wrapper around a [`Stream`]."r" This does not use any future or past knowledge of elements, and so is suitable if the"r" stream rarely or never blocks.  Prefer using [`FromStream`] if you plan to filter or join"r" this stream and want other streams to be able to make progress while this one blocks."split_itemFromStreamDirect/// Create a new [`OrderedStream`] by applying a `split_item` closure to each element/// produced by the original stream.with_ordering/// Helper function to simplify the creation of a stream when you have a get_ordering function.poll_next_beforePollResultFusedOrderedStreamr" Unlike [`FromStream`], the items in the [`Stream`] are themselves ordered with no"r" additional data."FromSortedStreamr" This caches the last-used ordering point returned by the stream and uses it to produce"r" NoneBefore results.  This makes it suitable for using to adapt streams that are filtered"r" or mapped before joining.  It still relies on the original stream producing a later-ordered"r" element to allow other streams to progress, however."FromStreamposition_hintMaybeBorrowedr" A [`Stream`] for the [`into_stream`](OrderedStreamExt::into_stream) function."r" A [`Stream`] for the [`into_tuple_stream`](OrderedStreamExt::into_tuple_stream) function."r" A [`Stream`] for the [`into_ordering`](OrderedStreamExt::into_ordering) function."r" An [`OrderedStream`] wrapper around an [`OrderedFuture`]."FromFutureOrderedFuturer" A stream for the [`map`](OrderedStreamExt::map) function."/// Convert to source stream.r" A stream for the [`map_item`](OrderedStreamExt::map_item) function."r" A stream for the [`map_ordering`](OrderedStreamExt::map_ordering) function."r" A stream for the [`filter`](OrderedStreamExt::filter) function."r" A stream for the [`filter_map`](OrderedStreamExt::filter_map) function."ThenItemThenProjThenDoner" A stream for the [`then`](OrderedStreamExt::then) function."/// A future for the [`next`](OrderedStreamExt::next) function.before/// A future for the [`next_before`](OrderedStreamExt::next_before) function.r" A stream for the [`peekable`](OrderedStreamExt::peekable) function."/// Convert into the source stream./// This method returns the source stream along with any buffered item and its/// The current item, without pollingpoll_peek_before/// Peek on the next item in the streamr" A stream for the [`join`](fn.join.html) function."stream_astream_bJoinState/// Join two streams while preserving the overall ordering of elements./// You can think of this as implementing the "merge" step of a merge sort on the two streams,/// producing a single stream that is sorted given two sorted streams.  If the streams return/// [`PollResult::NoneBefore`] as intended, then the joined stream will be able to produce items/// when only one of the sources has unblocked.OnlyPollAOnlyPollBNoneBefore/// A helper equivalent to Poll<PollResult<T, I>> but easier to match/// Split into the source streams./// This method returns the source streams along with any buffered item and its/// Provide direct access to the underlying stream./// This may be useful if the stream provides APIs beyond [OrderedStream].  Note that the join/// itself may be buffering an item from this stream, so you should consult/// [Self::peek_buffered] and, if needed, [Self::take_buffered] before polling it directly.peek_buffered/// Allow access to the buffered item, if any./// At most one of the two sides will be `Some`.  The returned item is a candidate for being/// the next item returned by the joined stream, but it could not be returned by the most/// recent [`OrderedStream::poll_next_before`] call.take_buffered/// Remove the buffered item, if one is present./// This does not poll either underlying stream.  See [Self::peek_buffered] for details on why/// buffering exists.join_twojoin_one_slow/// The type ordered by this stream./// Each stream must produce values that are in ascending order according to this function,/// although there is no requirement that the values be strictly ascending./// The unordered data carried by this stream/// This is split from the `Ordering` type to allow specifying a smaller or cheaper-to-generate/// type as the ordering key.  This is especially useful if you generate values to pass in to/// `before`./// Attempt to pull out the next value of this stream, registering the current task for wakeup/// if needed, and returning `NoneBefore` if it is known that the stream will not produce any/// more values ordered before the given point./// There are several possible return values, each indicating a distinct stream state depending/// on the value passed in `before`:/// - If `before` was `None`, `Poll::Pending` means that this stream's next value is not ready/// yet. Implementations will ensure that the current task is notified when the next value may/// be ready./// - If `before` was `Some`, `Poll::Pending` means that this stream's next value is not ready/// and that it is not yet known if the stream will produce a value ordered prior to the given/// ordering value.  Implementations will ensure that the current task is notified when either/// the next value is ready or once it is known that no such value will be produced./// - `Poll::Ready(PollResult::Item)` means that the stream has successfully produced/// an item.  The stream may produce further values on subsequent `poll_next_before` calls./// The returned ordering value must not be less than any prior ordering value returned by this/// stream.  The returned ordering value **may** be greater than the value passed to `before`./// - `Poll::Ready(PollResult::Terminated)` means that the stream has terminated, and/// `poll_next_before` should not be invoked again./// - `Poll::Ready(PollResult::NoneBefore)` means that the stream will not produce/// any further ordering tokens less than the given token.  Subsequent `poll_next_before` calls/// may still produce additional items, but their tokens will be greater than or equal to the/// given token.  It does not make sense to return this value if `before` was `None`./// The minimum value of the ordering for any future items./// If this does not return `None`, the returned ordering must be less than or equal to the/// ordering of any future item returned from [`Self::poll_next_before`].  This value should/// (but is not required to) be greater than or equal to the ordering of the most recent item/// A stream that produces items that are ordered according to some token./// The main advantage of this trait over the standard `Stream` trait is the ability to implement a/// [`join`](join()) function that does not either block until both source streams produce an item/// or contain a race condition when rejoining streams that originated from a common well-ordered/// A value that is either borrowed or owned./// This is similar to `std::borrow::Cow`, but does not require the ability to convert from/// borrowed to owned./// An [`OrderedStream`] that tracks if the underlying stream should be polled./// An item with a corresponding ordering token./// This stream will not return any items prior to the given point./// This stream is terminated and should not be polled again./// The result of a [`OrderedStream::poll_next_before`] operation./// Extract the data from the result./// Extract the item from the result./// Extract the error of a [`Result`] item.transpose_result_item/// Extract the error and ordering from a [`Result`] item./// See [`OrderedStream::Ordering`]./// See [`OrderedStream::Data`].poll_before/// Attempt to pull out the value of this future, registering the current task for wakeup if/// needed, and returning `None` if it is known that the future will not produce a value/// ordered before the given point./// There are several possible return values, each indicating a distinct state depending on the/// value passed in `before`:/// - If `before` was `None`, `Poll::Pending` means that this future's value is not ready yet./// Implementations will ensure that the current task is notified when the next value may be/// - If `before` was `Some`, `Poll::Pending` means that this future's value is not ready and/// that it is not yet known if the value will be ordered prior to the given ordering value./// Implementations will ensure that the current task is notified when either the next value is/// ready or once it is known that no such value will be produced./// - `Poll::Ready(Some(Data))` means that the future has successfully terminated.  The/// returned ordering value **may** be greater than the value passed to `before`.  The/// `poll_before` function should not be invoked again./// - `Poll::Ready(None)` means that this future will not produce an ordering token less than/// the given token.  It is an error to return `None` if `before` was `None`./// The minimum value of the ordering of the item./// See [`OrderedStream::position_hint`] for details./// A [`Future`](core::future::Future) that produces an item with an associated ordering./// This is equivalent to an [`OrderedStream`] that always produces exactly one item.  This trait/// is not very useful on its own; see [`FromFuture`] to convert it to a stream./// It is valid to implement both [`Future`](core::future::Future) and [`OrderedFuture`] on the/// same type.  In this case, unless otherwise documented by the implementing type, neither poll/// function should be invoked after either returns an output value.adapterspoll_multiple_stepJoinMultiple/// Join a collection of [`OrderedStream`]s./// This is similar to repeatedly using [`join()`] on all the streams in the contained collection./// It is not optimized to avoid polling streams that are not ready, so it works best if the number/// of streams is relatively small.// Unlike `FutureUnordered` or `SelectAll`, the ordering properties that this struct provides can// easily require that all items in the collection be consulted before returning any item.  An// example of such a situation is a series of streams that all generate timestamps (locally) for// their items and only return `NoneBefore` for past timestamps.  If only one stream produces an// item for each call to `JoinMultiple::poll_next_before`, that timestamp must be checked against// every other stream, and no amount of preparatory work or hints will help this.// On the other hand, if all streams provide a position hint that matches their next item, it is// possible to build a priority queue to sort the streams and reduce the cost of a single poll from// `n` to `log(n)`.  This does require maintaining a snapshot of the hints (so S::Ordering: Clone),// and will significantly increase the worst-case workload, so it should be a distinct type.r" Join a collection of pinned [`OrderedStream`]s."r" This is identical to [`JoinMultiple`], but accepts [`OrderedStream`]s that are not [`Unpin`] by"r" requiring that the collection provide a pinned [`IntoIterator`] implementation."r" This is not a feature available in most `std` collections.  If you wish to use them, you"r" should use `Box::pin` to make the stream [`Unpin`] before inserting it in the collection,"r" and then use [`JoinMultiple`] on the resulting collection."JoinMultiplePinjoin_mutipledistroversion_nameparse_valuedetect_debiandetect_archlinuxdetect_alpinedetect_ubuntudetect_centosntstatusGetModuleHandleAsysinfoapiVER_NT_WORKSTATIONVER_SUITE_WH_SERVERSM_SERVERR2OSVERSIONINFOEXOSVERSIONINFOEXAversion_info// Calls the Win32 API function RtlGetVersion to get the OS version information:// https://msdn.microsoft.com/en-us/library/mt723418(v=vs.85).aspxedition// Examines data in the OSVERSIONINFOEX structure to determine the Windows edition:// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx// borrowed from https://github.com/DarkEld3r/os_info/blob/master/src/windows/winapi.rs/// Windows doesn't have a native equivalent for cat, so we use this little/// Rust implementation instead.//! This little test binary reads stdin, and then writes what it read to both//! stdout and stderr, with a little tag to differentiate them. We use it to//! test duping the standard file descriptors.args_os/// This little test binary reads stdin and write what it reads to both/// stdout and stderr. It depends on os_pipe's parent_* functions, and/// we use it to test them.// We use std::fs::File here for two reasons: OwnedFd and OwnedHandle are platform-specific,// and this gives us read/write/flush for free./// The reading end of a pipe, returned by [`pipe`](fn.pipe.html)./// `PipeReader` implements `Into<Stdio>`, so you can pass it as an argument to/// `Command::stdin` to spawn a child process that reads from the pipe./// The writing end of a pipe, returned by [`pipe`](fn.pipe.html)./// `PipeWriter` implements `Into<Stdio>`, so you can pass it as an argument to/// `Command::stdout` or `Command::stderr` to spawn a child process that writes/// to the pipe./// Open a new pipe and return a [`PipeReader`] and [`PipeWriter`] pair./// This corresponds to the `pipe2` library call on Posix and the/// `CreatePipe` library call on Windows (though these implementation/// details might change). These pipes are non-inheritable, so new child/// processes won't receive a copy of them unless they're explicitly/// passed as stdin/stdout/stderr./// [`PipeReader`]: struct.PipeReader.html/// [`PipeWriter`]: struct.PipeWriter.htmldup_stdin/// Get a duplicated copy of the current process's standard input, as a/// [`PipeReader`]./// Reading directly from this pipe isn't recommended, because it's not/// synchronized with [`std::io::stdin`]. [`PipeReader`] implements/// [`Into<Stdio>`], so it can be passed directly to [`Command::stdin`]. This is/// equivalent to [`Stdio::inherit`], though, so it's usually not necessary/// unless you need a collection of different pipes./// [`std::io::stdin`]: https://doc.rust-lang.org/std/io/fn.stdin.html/// [`Into<Stdio>`]: https://doc.rust-lang.org/std/process/struct.Stdio.html/// [`Command::stdin`]: https://doc.rust-lang.org/std/process/struct.Command.html#method.stdin/// [`Stdio::inherit`]: https://doc.rust-lang.org/std/process/struct.Stdio.html#method.inheritdup_stdout/// Get a duplicated copy of the current process's standard output, as a/// [`PipeWriter`](struct.PipeWriter.html)./// Writing directly to this pipe isn't recommended, because it's not/// synchronized with [`std::io::stdout`]. [`PipeWriter`] implements/// [`Into<Stdio>`], so it can be passed directly to [`Command::stdout`] or/// [`Command::stderr`]. This can be useful if you want the child's stderr to go/// to the parent's stdout./// [`std::io::stdout`]: https://doc.rust-lang.org/std/io/fn.stdout.html/// [`Command::stdout`]: https://doc.rust-lang.org/std/process/struct.Command.html#method.stdout/// [`Command::stderr`]: https://doc.rust-lang.org/std/process/struct.Command.html#method.stderrdup_stderr/// Get a duplicated copy of the current process's standard error, as a/// synchronized with [`std::io::stderr`]. [`PipeWriter`] implements/// [`Command::stderr`]. This can be useful if you want the child's stdout to go/// to the parent's stderr./// [`std::io::stderr`]: https://doc.rust-lang.org/std/io/fn.stderr.htmlEXE_EXTENSIONpath_to_exetest_pipe_some_datatest_pipe_some_data_with_refstest_pipe_no_datatest_pipe_a_megabyte_of_data_from_another_threadtest_pipes_are_not_inheritabletest_parent_handlestest_parent_handles_dont_closetest_try_clone//! A cross-platform library for opening OS pipes, like those from//! [`pipe`](https://man7.org/linux/man-pages/man2/pipe.2.html) on Linux//! or//! [`CreatePipe`](https://docs.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-createpipe)//! on Windows. The Rust standard library provides//! [`Stdio::piped`](https://doc.rust-lang.org/std/process/struct.Stdio.html#method.piped)//! for simple use cases involving child processes, but it doesn't//! support creating pipes directly. This crate fills that gap.//! - [Docs](https://docs.rs/os_pipe)//! - [Crate](https://crates.io/crates/os_pipe)//! - [Repo](https://github.com/oconnor663/os_pipe.rs)//! # Common deadlocks related to pipes//! When you work with pipes, you often end up debugging a deadlock at//! some point. These can be confusing if you don't know why they//! happen. Here are two things you need to know://! 1. Pipe reads will block waiting for input as long as there's at//!    least one writer still open. **If you forget to close a writer,//!    reads will block forever.** This includes writers that you give//!    to child processes.//! 2. Pipes have an internal buffer of some fixed size. On Linux for//!    example, pipe buffers are 64 KiB by default. When the buffer is//!    full, writes will block waiting for space. **If the buffer is//!    full and there aren't any readers, writes will block forever.**//! Deadlocks caused by a forgotten writer usually show up immediately,//! which makes them relatively easy to fix once you know what to look//! for. (See "Avoid a deadlock!" in the example code below.) However,//! deadlocks caused by full pipe buffers are trickier. These might only//! show up for larger inputs, and they might be timing-dependent or//! platform-dependent. If you find that writing to a pipe deadlocks//! sometimes, think about who's supposed to be reading from that pipe,//! and whether that thread or process might be blocked on something//! else. For more on this, see the [Gotchas//! Doc](https://github.com/oconnor663/duct.py/blob/master/gotchas.md#using-io-threads-to-avoid-blocking-children)//! from the [`duct`](https://github.com/oconnor663/duct.rs) crate. (And//! consider whether [`duct`](https://github.com/oconnor663/duct.rs)//! might be a good fit for your use case.)//! Here we write a single byte into a pipe and read it back out://! let (mut reader, mut writer) = os_pipe::pipe()?;//! // XXX: If this write blocks, we'll never get to the read.//! writer.write_all(b"x")?;//! let mut output = [0];//! reader.read_exact(&mut output)?;//! assert_eq!(b"x", &output);//! This is a minimal working example, but as discussed in the section//! above, reading and writing on the same thread like this is//! deadlock-prone. If we wrote 100 KB instead of just one byte, this//! example would block on `write_all`, it would never make it to//! `read_exact`, and that would be a deadlock. Doing the read and write//! from different threads or different processes would fix the//! For a more complex example, here we join the stdout and stderr of a//! child process into a single pipe. To do that we open a pipe, clone//! its writer, and set that pair of writers as the child's stdout and//! stderr. (This is possible because `PipeWriter` implements//! `Into<Stdio>`.) Then we can read interleaved output from the pipe//! reader. This example is deadlock-free, but note the comment about//! closing the writers.//! # use std::io::prelude::*;//! // We're going to spawn a child process that prints "foo" to stdout//! // and "bar" to stderr, and we'll combine these into a single pipe.//! let mut command = std::process::Command::new("python");//! command.args(&["-c", r#"//! import sys//! sys.stdout.write("foo")//! sys.stdout.flush()//! sys.stderr.write("bar")//! sys.stderr.flush()//! "#]);//! // Here's the interesting part. Open a pipe, clone its writer, and//! // set that pair of writers as the child's stdout and stderr.//! let (mut reader, writer) = os_pipe::pipe()?;//! let writer_clone = writer.try_clone()?;//! command.stdout(writer);//! command.stderr(writer_clone);//! // Now start the child process running.//! let mut handle = command.spawn()?;//! // Avoid a deadlock! This parent process is still holding open pipe//! // writers inside the Command object, and we have to close those//! // before we read. Here we do this by dropping the Command object.//! drop(command);//! // Finally we can read all the output and clean up the child.//! let mut output = String::new();//! reader.read_to_string(&mut output)?;//! handle.wait()?;//! assert_eq!(output, "foobar");//! Note that the [`duct`](https://github.com/oconnor663/duct.rs) crate//! can reproduce the example above in a single line of code, with no//! risk of deadlocks and no risk of leaking [zombie//! children](https://en.wikipedia.org/wiki/Zombie_process).pipe2_cloexec// We need to atomically create pipes and set the CLOEXEC flag on them. This is// done with the pipe2() API. However, macOS doesn't support pipe2. There, all// we can do is call pipe() followed by fcntl(), and hope that no other threads// fork() in between. The following code is copied from the nix crate, where it// works but is deprecated._overload_assignment_overload_assignment_internalassignment// Unary (both owned and borrowed)
// Unary (either owned or borrowed)
// Assignment (both owned and borrowed)
// Assignment (either owned or borrowed)
// Binary (both - both)
// Binary (both - either)
// Binary (either - both)
// Binary (either - either)
/// Overloads an operator. See the [module level documentation](index.html) for more information.
//! Provides a macro to simplify operator overloading.
//! 
//! To use, include the following:
//! extern crate overload;
//! use overload::overload;
//! use std::ops; // <- don't forget this or you'll get nasty errors
//! # Introduction
//! Suppose we have the following `struct` definition:
//! ``` 
//! #[derive(PartialEq, Debug)]
//! struct Val {
//!     v: i32
//! We can overload the addition of `Val`s like so:
//! # extern crate overload;
//! # use overload::overload;
//! # use std::ops;
//! # #[derive(PartialEq, Debug)]
//! # struct Val {
//! #   v: i32
//! overload!((a: Val) + (b: Val) -> Val { Val { v: a.v + b.v } });
//! The macro call above generates the following code:
//! ```ignore
//! impl ops::Add<Val> for Val {
//!     type Output = Val;
//!     fn add(self, b: Val) -> Self::Output {
//!         let a = self;
//!         Val { v: a.v + b.v }
//!     }
//! We are now able to add `Val`s:
//! # overload!((a: Val) + (b: Val) -> Val { Val { v: a.v + b.v } });
//! assert_eq!(Val{v:3} + Val{v:5}, Val{v:8});
//! # Owned and borrowed types
//! If we also wanted to overload addition for the borrowed type `&Val` we could write:
//! overload!((a: &Val) + (b: &Val) -> Val { Val { v: a.v + b.v } });
//! We might also want to overload addition between the owned and borrowed types:
//! overload!((a: Val) + (b: &Val) -> Val { Val { v: a.v + b.v } });
//! overload!((a: &Val) + (b: Val) -> Val { Val { v: a.v + b.v } });
//! Let's see how we can write these combinations more concisely.
//! We can include a `?` in front of a type to indicate that it should stand in for both the owned and borrowed type.
//! To overload addition for all four combinations between `Val` and `&Val` we can therefore simply include a `?` in front of both types:
//! overload!((a: ?Val) + (b: ?Val) -> Val { Val { v: a.v + b.v } });
//! impl ops::Add<&Val> for Val {
//!     fn add(self, b: &Val) -> Self::Output {
//! impl ops::Add<Val> for &Val {
//! impl ops::Add<&Val> for &Val {
//! We are now able to add `Val`s and `&Val`s in any combination:
//! # overload!((a: ?Val) + (b: ?Val) -> Val { Val { v: a.v + b.v } });
//! assert_eq!(Val{v:3} + &Val{v:5}, Val{v:8});
//! assert_eq!(&Val{v:3} + Val{v:5}, Val{v:8});
//! assert_eq!(&Val{v:3} + &Val{v:5}, Val{v:8});
//! # Binary operators
//! The general syntax to overload a binary operator between types `<a_type>` and `<b_type>` is:
//! overload!((<a_ident>: <a_type>) <op> (<b_ident>: <b_type>) -> <out_type> { /*body*/ });
//! Inside the body you can use `<a_ident>` and `<b_ident>` freely to perform any computation.
//! The last line of the body needs to be an expression (i.e. no `;` at the end of the line) of type `<out_type>`.
//! | Operator | Example                                                         | Trait  |
//! |----------|-----------------------------------------------------------------|--------|
//! | +        | `overload!((a: A) + (b: B) -> C { /*...*/ );`                   | Add    |           
//! | -        | `overload!((a: A) - (b: B) -> C { /*...*/ );`                   | Sub    |
//! | *        | `overload!((a: A) * (b: B) -> C { /*...*/ );`                   | Mul    |
//! | /        | `overload!((a: A) / (b: B) -> C { /*...*/ );`                   | Div    |
//! | %        | `overload!((a: A) % (b: B) -> C { /*...*/ );`                   | Rem    |
//! | &        | `overload!((a: A) & (b: B) -> C { /*...*/ );`                   | BitAnd |
//! | \|       | <code>overload!((a: A) &vert; (b: B) -> C { /\*...*\/ );</code> | BitOr  |
//! | ^        | `overload!((a: A) ^ (b: B) -> C { /*...*/ );`                   | BitXor |
//! | <<       | `overload!((a: A) << (b: B) -> C { /*...*/ );`                  | Shl    |
//! | >>       | `overload!((a: A) >> (b: B) -> C { /*...*/ );`                  | Shr    |
//! # Assignment operators
//! The general syntax to overload an assignment operator between types `<a_type>` and `<b_type>` is:
//! overload!((<a_ident>: &mut <a_type>) <op> (<b_ident>: <b_type>) { /*body*/ });
//! Inside the body you can use `<a_ident>` and `<b_ident>` freely to perform any computation and mutate `<a_ident>` as desired.
//! | Operator | Example                                                          | Trait        |
//! |----------|------------------------------------------------------------------|--------------|
//! | +=       | `overload!((a: &mut A) += (b: B) { /*...*/ );`                   | AddAssign    |           
//! | -=       | `overload!((a: &mut A) -= (b: B) { /*...*/ );`                   | SubAssign    |
//! | *=       | `overload!((a: &mut A) *= (b: B) { /*...*/ );`                   | MulAssign    |
//! | /=       | `overload!((a: &mut A) /= (b: B) { /*...*/ );`                   | DivAssign    |
//! | %=       | `overload!((a: &mut A) %= (b: B) { /*...*/ );`                   | RemAssign    |
//! | &=       | `overload!((a: &mut A) &= (b: B) { /*...*/ );`                   | BitAndAssign |
//! | \|=      | <code>overload!((a: &mut A) &vert;= (b: B) { /\*...*\/ );</code> | BitOrAssign  |
//! | ^=       | `overload!((a: &mut A) ^= (b: B) { /*...*/ );`                   | BitXorAssign |
//! | <<=      | `overload!((a: &mut A) <<= (b: B) { /*...*/ );`                  | ShlAssign    |
//! | >>=      | `overload!((a: &mut A) >>= (b: B) { /*...*/ );`                  | ShrAssign    |
//! # Unary operators
//! The general syntax to overload a unary operator for type `<a_type>` is:
//! overload!(<op> (<a_ident>: <a_type>) -> <out_type> { /*body*/ });
//! Inside the body you can use `<a_ident>` freely to perform any computation.
//! | Operator | Example                                                 | Trait |
//! |----------|---------------------------------------------------------|-------|
//! | -        | `overload!(- (a: A) -> B { /*...*/ );`                  | Neg   |
//! | !        | `overload!(! (a: A) -> B { /*...*/ );`                  | Not   |  
//! # Notes
//! Remember that you can only overload operators between one or more types if at least one of the types is defined in the current crate.
as_face_ref/// Convert to a [`Face`](struct.Face.html) reference./// Used to perform a cheap conversion to a [`Face`](struct.Face.html) reference./// Sets a variation axis coordinate./// See [`ttf_parser::Face::set_variation`]./// Trait exposing mutable operations on a [`ttf_parser::Face`].preparse//! Extends [ttf_parser](https://docs.rs/ttf-parser) with owned version of//! [`Face`](struct.Face.html): [`OwnedFace`](struct.OwnedFace.html).//! Re-exports `ttf_parser::*`.//! use owned_ttf_parser::{AsFaceRef, Face, OwnedFace};//! # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();//! let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();//! let face_ref: &Face<'_> = owned_face.as_face_ref();//! assert_eq!(face_ref.ascender(), 2254);FaceSubtablesSelfRefVecFace/// An owned version of font [`Face`](struct.Face.html).FaceParsingError/// Creates an `OwnedFace` from owned data./// You can set index for font collections. For simple ttf fonts set index to 0./// # use owned_ttf_parser::OwnedFace;/// # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();/// let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();// Note: not `try_from_vec` to better mimic `ttf_parser::Face::from_data`.pre_parse_subtables/// Extracts a slice containing the data passed into [`OwnedFace::from_vec`]./// let data_clone = owned_font_data.clone();/// assert_eq!(owned_face.as_slice(), data_clone);/// Unwraps the data passed into [`OwnedFace::from_vec`]./// assert_eq!(owned_face.into_vec(), data_clone);// Face data in a `Vec` with a self-referencing `Face`./// Creates an underlying face object from owned data.// Must not leak the fake 'static lifetime that we lied about earlier to the// compiler. Since the lifetime 'a will not outlive our owned data it's// safe to provide Face<'a>// explicit is nice as it's important 'static isn't leaked/// Underlying face.subtables'face// note must not be public as could be self-referencing/// A `Face` with cmap & kern subtables parsed once on initialization./// Provides much faster [`PreParsedSubtables::glyph_index`] &/// [`PreParsedSubtables::glyphs_hor_kerning`] methods compared to the/// `.as_face_ref()` equivalents that must parse their subtables on each call./// use owned_ttf_parser::{AsFaceRef, GlyphId, OwnedFace, PreParsedSubtables};/// let faster_face = PreParsedSubtables::from(owned_face);/// // Lookup a GlyphId using the pre-parsed cmap subtables/// // this is much faster than doing: .as_face_ref().glyph_index('x')/// assert_eq!(faster_face.glyph_index('x'), Some(GlyphId(91)));/// // The rest of the methods are still available as normal/// assert_eq!(faster_face.as_face_ref().ascender(), 2254);Subtable/// Unicode cmap subtables.h_kern/// Horizontal kern subtables.glyph_index/// Maps a character to a `GlyphId` using pre-parsed unicode cmap subtables.glyph_variation_index/// Maps a variation of a character to a `GlyphId` using pre-parsed unicode cmap subtables.glyphs_hor_kerning/// Returns horizontal kerning for a pair of glyphs using pre-parsed kern subtables.//! Logic to avoid re-parsing subtables in ttf_parser::Face methodsR_2/// Raw field element.fe_from_montgomery/// Translate a field element out of the Montgomery domain.fe_to_montgomery/// Translate a field element into the Montgomery domain.fe_add/// Returns `a + b mod p`.fe_sub/// Returns `a - b mod p`.fe_mul/// Returns `a * b mod p`.fe_neg/// Returns `-w mod p`.fe_square/// Returns `w * w mod p`./// Montgomery Reduction/// The general algorithm is:/// A <- input (2n b-limbs)/// for i in 0..n {///     k <- A[i] p' mod b///     A <- A + k p b^i/// A <- A / b^n/// if A >= p {///     A <- A - p/// For secp256r1, we have the following simplifications:/// - `p'` is 1, so our multiplicand is simply the first limb of the intermediate A./// - The first limb of p is 2^64 - 1; multiplications by this limb can be simplified///   to a shift and subtraction:///   ```text///       a_i * (2^64 - 1) = a_i * 2^64 - a_i = (a_i << 64) - a_i///   However, because `p' = 1`, the first limb of p is multiplied by limb i of the///   intermediate A and then immediately added to that same limb, so we simply///   initialize the carry to limb i of the intermediate./// - The third limb of p is zero, so we can ignore any multiplications by it and just///   add the carry./// - Handbook of Applied Cryptography, Chapter 14///   Algorithm 14.32///   http://cacr.uwaterloo.ca/hac/about/chap14.pdf/// - Efficient and Secure Elliptic Curve Cryptography Implementation of Curve P-256///   Algorithm 7) Montgomery Word-by-Word Reduction///   https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session6-adalier-mehmet.pdfsub_innerfe32_to_fe64// TODO(tarcieri): replace this with proper 32-bit arithmetic//! 32-bit secp256r1 base field implementation// TODO(tarcieri): adapt 64-bit arithmetic to proper 32-bit arithmetic//! 64-bit secp256r1 base field implementationfield_implNistP256MODULUS_HEX/// Field modulus serialized as hex./// p = 2^{224}(2^{32} − 1) + 2^{192} + 2^{96} − 1/// Constant representing the modulus./// R^2 = 2^512 mod p/// An element in the finite field modulo p = 2^{224}(2^{32} − 1) + 2^{192} + 2^{96} − 1./// The internal representation is in little-endian order. Elements are always in/// Montgomery form; i.e., FieldElement(a) = aR mod p, with R = 2^256.impl_mont_field_elementr" Zero element."r" Multiplicative identity."r" Create a [`"r" `] from a canonical big-endian representation."r" Decode [`"r" `] from a big endian byte slice."r" `]"r" from [`"r" `] converting it into Montgomery form:"r" w * R^2 * R^-1 mod p = wR mod p"r" Parse a [`"r" `] from big endian hex-encoded bytes."r" Does *not* perform a check that the field element does not overflow the order."r" This method is primarily intended for defining internal constants."r" Convert a `u64` into a [`"r" `]."r" `] from [`"r" `] converting it into Montgomery form."r" Used incorrectly this can lead to invalid results!"r" Returns the big-endian encoding of this [`"r" Translate [`"r" `] out of the Montgomery domain, returning a [`"r" `] in canonical form."to_canonicalr" Determine if this [`"r" `] is odd in the SEC1 sense: `self mod 2 == 1`."r" If odd, return `Choice(1)`.  Otherwise, return `Choice(0)`."r" `] is even in the SEC1 sense: `self mod 2 == 0`."r" If even, return `Choice(1)`.  Otherwise, return `Choice(0)`."r" `] is zero."r" If zero, return `Choice(1)`.  Otherwise, return `Choice(0)`."r" Add elements."r" Double element (add it to itself)."r" Subtract elements."r" Multiply elements."r" Negate element."r" Compute modular square."r" Returns `self^exp`, where `exp` is a little-endian integer exponent."r" **This operation is variable time with respect to the exponent.**"r" If the exponent is fixed, this operation is effectively constant time."impl_mont_field_element_arithmeticimpl_field_op/// Returns the multiplicative inverse of self, if self is non-zero.invert_unchecked/// Returns the multiplicative inverse of self./// Does not check that self is non-zero./// Returns the square root of self mod p, or `None` if no square root exists.sqn/// Returns self^(2^n) mod pDBL_TEST_VECTORSimpl_field_identity_testsimpl_field_invert_testsimpl_field_sqrt_testsimpl_primefield_tests/// t = (modulus - 1) >> Szero_is_additive_identityone_is_multiplicative_identitytwo_inv_constantroot_of_unity_constantroot_of_unity_inv_constantdelta_constantrepeated_addrepeated_doublerepeated_mulnegation//! Field arithmetic modulo p = 2^{224}(2^{32} − 1) + 2^{192} + 2^{96} − 1hash2curveProptestConfighash_to_curve// TODO(tarcieri): fix commented out codehash_to_scalar_voprf/// Taken from <https://www.ietf.org/archive/id/draft-irtf-cfrg-voprf-16.html#name-oprfp-256-sha-256-2>.from_okm_fuzzMUbarrett_reduce/// Barrett Reduction/// p = n = order of group/// b = 2^64 = 64bit machine word/// k = 4/// a \in [0, 2^512]/// mu := floor(b^{2k} / p)/// q1 := floor(a / b^{k - 1})/// q2 := q1 * mu/// q3 := <- floor(a / b^{k - 1})/// r1 := a mod b^{k + 1}/// r2 := q3 * m mod b^{k + 1}/// r := r1 - r2/// if r < 0: r := r + b^{k + 1}/// while r >= p: do r := r - p (at most twice)///   Algorithm 14.42///   Algorithm 6) Barrett Reduction modulo pq1_times_mu_shift_fiveq3_times_n_keep_fivesub_inner_fivesubtract_n_if_necessaryu256_to_u64x4//! 32-bit secp256r1 scalar field algorithms.//! 64-bit secp256r1 scalar field algorithms.scalar_implORDER_HEX/// Constant representing the modulus/// n = FFFFFFFF 00000000 FFFFFFFF FFFFFFFF BCE6FAAD A7179E84 F3B9CAC2 FC632551FRAC_MODULUS_2/// `MODULUS / 2`/// MU = floor(2^512 / n)///    = 115792089264276142090721624801893421302707618245269942344307673200490803338238///    = 0x100000000fffffffffffffffeffffffff43190552df1a6c21012ffd85eedf9bfe/// Scalars are elements in the finite field modulo n./// # Trait impls/// Much of the important functionality of scalars is provided by traits from/// the [`ff`](https://docs.rs/ff/) crate, which is re-exported as/// `p256::elliptic_curve::ff`:/// - [`Field`](https://docs.rs/ff/latest/ff/trait.Field.html) -///   represents elements of finite fields and provides:///   - [`Field::random`](https://docs.rs/ff/latest/ff/trait.Field.html#tymethod.random) -///     generate a random scalar///   - `double`, `square`, and `invert` operations///   - Bounds for [`Add`], [`Sub`], [`Mul`], and [`Neg`] (as well as `*Assign` equivalents)///   - Bounds for [`ConditionallySelectable`] from the `subtle` crate/// - [`PrimeField`](https://docs.rs/ff/latest/ff/trait.PrimeField.html) -///   represents elements of prime fields and provides:///   - `from_repr`/`to_repr` for converting field elements from/to big integers.///   - `multiplicative_generator` and `root_of_unity` constants./// - [`PrimeFieldBits`](https://docs.rs/ff/latest/ff/trait.PrimeFieldBits.html) -///   operations over field elements represented as bits (requires `bits` feature)/// Please see the documentation for the relevant traits for more information./// When the `serde` feature of this crate is enabled, the `Serialize` and/// `Deserialize` traits are impl'd for this type./// Returns the SEC1 encoding of this scalar./// Returns self + rhs mod n/// Returns 2*self./// Returns self - rhs mod n./// Returns self * rhs mod n/// Returns self * self mod p/// Right shifts the scalar./// Note: not constant-time with respect to the `shift` parameter./// Returns the multiplicative inverse of self, if self is non-zero/// Is integer representing equivalence class odd?/// Is integer representing equivalence class even?/// Tonelli-Shank's algorithm for q mod 16 = 1/// <https://eprint.iacr.org/2012/685.pdf> (page 12, algorithm 5)/// Attempts to parse the given byte array as an SEC1-encoded scalar./// Returns None if the byte array does not contain a big-endian integer in the range/// [0, p)./// Fast variable-time inversion using Stein's algorithm./// Returns none if the scalar is zero./// <https://link.springer.com/article/10.1007/s13389-016-0135-4>/// This method should not be used with (unblinded) secret scalars, as its/// variable-time operation can potentially leak secrets through/// sidechannels.from_to_bytes_roundtrip/// Basic tests that multiplication works.from_ec_secret/// Tests that a Scalar can be safely converted to a SecretKey and back//! Scalar field arithmetic modulo n = 115792089210356248762697446949407573529996955224135760342422259061068512044369/// Computes `a + b + carry`, returning the result along with the new carry. 64-bit version./// Computes `a - (b + borrow)`, returning the result along with the new borrow. 64-bit version.//! Helper functions.// TODO(tarcieri): replace these with `crypto-bigint`point_arithmeticPrimeCurveParamsPointArithmeticEquationAIsMinusThreeEQUATION_A/// a = -3EQUATION_BGENERATOR/// Base point of P-256./// Defined in NIST SP 800-186 § G.1.2:/// Gₓ = 6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296/// Gᵧ = 4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5/// Adapted from [NIST SP 800-186] § G.1.2: Curve P-256./// [NIST SP 800-186]: https://csrc.nist.gov/publications/detail/sp/800-186/final//! Pure Rust implementation of group operations on secp256r1.//! Curve parameters can be found in [NIST SP 800-186] § G.1.2: Curve P-256.//! [NIST SP 800-186]: https://csrc.nist.gov/publications/detail/sp/800-186/final/// NIST P-256 Ephemeral Diffie-Hellman Secret.//! Elliptic Curve Diffie-Hellman (Ephemeral) Support.//! This module contains a high-level interface for performing ephemeral//! Diffie-Hellman key exchanges using the secp256r1 elliptic curve.//! This usage example is from the perspective of two participants in the//! exchange, nicknamed "Alice" and "Bob".//! use p256::{EncodedPoint, PublicKey, ecdh::EphemeralSecret};//! use rand_core::OsRng; // requires 'getrandom' feature//! // Alice//! let alice_secret = EphemeralSecret::random(&mut OsRng);//! let alice_pk_bytes = EncodedPoint::from(alice_secret.public_key());//! // Bob//! let bob_secret = EphemeralSecret::random(&mut OsRng);//! let bob_pk_bytes = EncodedPoint::from(bob_secret.public_key());//! // Alice decodes Bob's serialized public key and computes a shared secret from it//! let bob_public = PublicKey::from_sec1_bytes(bob_pk_bytes.as_ref())//!     .expect("bob's public key is invalid!"); // In real usage, don't panic, handle this!//! let alice_shared = alice_secret.diffie_hellman(&bob_public);//! // Bob decodes Alice's serialized public key and computes the same shared secret//! let alice_public = PublicKey::from_sec1_bytes(alice_pk_bytes.as_ref())//!     .expect("alice's public key is invalid!"); // In real usage, don't panic, handle this!//! let bob_shared = bob_secret.diffie_hellman(&alice_public);//! // Both participants arrive on the same shared secret//! assert_eq!(alice_shared.raw_secret_bytes(), bob_shared.raw_secret_bytes());/// ECDSA/P-256 signature (fixed-size)DerSignature/// ECDSA/P-256 signature (ASN.1 DER encoded)/// ECDSA/P-256 signing key/// ECDSA/P-256 verification key (i.e. public key)ECDSA_TEST_VECTORS// Test vector from RFC 6979 Appendix 2.5 (NIST P-256 + SHA-256)// <https://tools.ietf.org/html/rfc6979#appendix-A.2.5>prehash_signer_signing_with_sha384// Test signing with PrehashSigner using SHA-384 which output is larger than P-256 field size.prehash_signer_verification_with_sha384// Test verifying with PrehashVerifier using SHA-256 which output is larger than P-256 field size.scalar_blindingwycheproof//! Elliptic Curve Digital Signature Algorithm (ECDSA)//! This module contains support for computing and verifying ECDSA signatures.//! To use it, you will need to enable one of the two following Cargo features://! - `ecdsa-core`: provides only the [`Signature`] type (which represents an//!   ECDSA/P-256 signature). Does not require the `arithmetic` feature.//!   This is useful for 3rd-party crates which wish to use the `Signature`//!   type for interoperability purposes (particularly in conjunction with the//!   [`signature::Signer`] trait. Example use cases for this include other//!   software implementations of ECDSA/P-256 and wrappers for cloud KMS//!   services or hardware devices (HSM or crypto hardware wallet).//! - `ecdsa`: provides `ecdsa-core` features plus the [`SigningKey`] and//!   [`VerifyingKey`] types which natively implement ECDSA/P-256 signing and//!   verification.//! ## Signing/Verification Example//! This example requires the `ecdsa` Cargo feature is enabled://! # #[cfg(feature = "ecdsa")]//! use p256::{//!     ecdsa::{SigningKey, Signature, signature::Signer},//! // Signing//! let signing_key = SigningKey::random(&mut OsRng); // Serialize with `::to_bytes()`//! let message = b"ECDSA proves knowledge of a secret number in the context of a single message";//! let signature: Signature = signing_key.sign(message);//! // Verification//! use p256::ecdsa::{VerifyingKey, signature::Verifier};//! let verifying_key = VerifyingKey::from(&signing_key); // Serialize with `::to_encoded_point()`//! assert!(verifying_key.verify(message, &signature).is_ok());/// Order of NIST P-256's elliptic curve group (i.e. scalar modulus) serialized/// as hexadecimal./// # Calculating the order/// One way to calculate the order is with `GP/PARI`:/// p = (2^224) * (2^32 - 1) + 2^192 + 2^96 - 1/// b = 41058363725152142129326129780047268409114441015993725554835256314039467401291/// E = ellinit([Mod(-3, p), Mod(b, p)])/// default(parisize, 120000000)/// n = ellsea(E)/// isprime(n)/// NIST P-256 elliptic curve./// This curve is also known as prime256v1 (ANSI X9.62) and secp256r1 (SECG)/// and is specified in [NIST SP 800-186]:/// Recommendations for Discrete Logarithm-based Cryptography:/// Elliptic Curve Domain Parameters./// It's included in the US National Security Agency's "Suite B" and is widely/// used in protocols like TLS and the associated X.509 PKI./// Its equation is `y² = x³ - 3x + b` over a ~256-bit prime field where `b` is/// the "verifiably random"† constant:/// † *NOTE: the specific origins of this constant have never been fully disclosed///   (it is the SHA-1 digest of an unknown NSA-selected constant)*/// 32-byte serialized field elements./// 256-bit integer type used for internally representing field elements./// Order of NIST P-256's elliptic curve group (i.e. scalar modulus)./// NIST P-256 points are typically uncompressed./// Blinded scalar./// Compressed SEC1-encoded NIST P-256 curve point./// NIST P-256 SEC1 encoded point./// NIST P-256 field element serialized as bytes./// Byte array containing a serialized field element value (base field or scalar)./// Non-zero NIST P-256 scalar field element./// NIST P-256 public key./// NIST P-256 secret key.//! `Deserialize` are impl'd for the following types://! - [`AffinePoint`]//! - [`Scalar`]//! - [`ecdsa::VerifyingKey`]/// ECDSA/P-256 test vectors./// Adapted from the FIPS 186-4 ECDSA test vectors/// (P-256, SHA-256, from `SigGen.txt` in `186-4ecdsatestvectors.zip`)/// <https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/digital-signatures>/// The `m` field contains a SHA-256 prehash of the `Msg` field in the/// original `SigTen.txt`.//! ECDSA/secp256r1 test vectors/// Repeated doubling of the multiplicative identity.//! Test vectors for the secp256r1 base field.ADD_TEST_VECTORS/// Repeated addition of the generator./// These are the first 20 test vectors from <http://point-at-infinity.org/ecc/nisttv>MUL_TEST_VECTORS/// Scalar multiplication with the generator./// These are the test vectors from <http://point-at-infinity.org/ecc/nisttv> that are not/// part of [`ADD_TEST_VECTORS`].//! Test vectors for the secp256r1 group.//! secp256r1 test vectors." fiat-crypto output postprocessed by fiat-constify: https://github.com/rustcrypto/utils"" Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p384 32 '2^384 - 2^128 - 2^96 + 2^32 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp"" curve description: p384"" machine_wordsize = 32 (from \"32\")"" requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp"" m = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff (from \"2^384 - 2^128 - 2^96 + 2^32 - 1\")"" NOTE: In addition to the bounds specified above each function, all""   functions synthesized for this Montgomery arithmetic require the""   input to be strictly less than the prime modulus (m), and also""   require the input to be in the unique saturated representation.""   All functions also ensure that these two properties are true of""   return values."" Computed values:""   eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160)""   bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178)""   twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in""                            if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384"fiat_p384_u1fiat_p384_i1fiat_p384_u2fiat_p384_i2fiat_p384_montgomery_domain_field_elementfiat_p384_non_montgomery_domain_field_element" The function fiat_p384_addcarryx_u32 is an addition with carry."" Postconditions:""   out1 = (arg1 + arg2 + arg3) mod 2^32""   out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋"" Input Bounds:""   arg1: [0x0 ~> 0x1]""   arg2: [0x0 ~> 0xffffffff]""   arg3: [0x0 ~> 0xffffffff]"" Output Bounds:""   out1: [0x0 ~> 0xffffffff]""   out2: [0x0 ~> 0x1]"fiat_p384_addcarryx_u32" The function fiat_p384_subborrowx_u32 is a subtraction with borrow.""   out1 = (-arg1 + arg2 + -arg3) mod 2^32""   out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋"fiat_p384_subborrowx_u32" The function fiat_p384_mulx_u32 is a multiplication, returning the full double-width result.""   out1 = (arg1 * arg2) mod 2^32""   out2 = ⌊arg1 * arg2 / 2^32⌋""   arg1: [0x0 ~> 0xffffffff]""   out2: [0x0 ~> 0xffffffff]"fiat_p384_mulx_u32" The function fiat_p384_cmovznz_u32 is a single-word conditional move.""   out1 = (if arg1 = 0 then arg2 else arg3)"fiat_p384_cmovznz_u32" The function fiat_p384_mul multiplies two field elements in the Montgomery domain."" Preconditions:""   0 ≤ eval arg1 < m""   0 ≤ eval arg2 < m""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m""   0 ≤ eval out1 < m"fiat_p384_mul" The function fiat_p384_square squares a field element in the Montgomery domain.""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m"fiat_p384_square" The function fiat_p384_add adds two field elements in the Montgomery domain.""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m"fiat_p384_add" The function fiat_p384_sub subtracts two field elements in the Montgomery domain.""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m"fiat_p384_sub" The function fiat_p384_opp negates a field element in the Montgomery domain.""   eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m"fiat_p384_opp" The function fiat_p384_from_montgomery translates a field element out of the Montgomery domain.""   eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m"fiat_p384_from_montgomery" The function fiat_p384_to_montgomery translates a field element into the Montgomery domain.""   eval (from_montgomery out1) mod m = eval arg1 mod m"fiat_p384_to_montgomery" The function fiat_p384_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.""   out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0""   arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]"fiat_p384_nonzero" The function fiat_p384_selectznz is a multi-limb conditional select.""   eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)""   arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]"fiat_p384_selectznz" The function fiat_p384_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.""   out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47]""   out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]"fiat_p384_to_bytes" The function fiat_p384_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.""   0 ≤ bytes_eval arg1 < m""   eval out1 mod m = bytes_eval arg1 mod m""   arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]"fiat_p384_from_bytes" The function fiat_p384_set_one returns the field element one in the Montgomery domain.""   eval (from_montgomery out1) mod m = 1 mod m"fiat_p384_set_one" The function fiat_p384_msat returns the saturated representation of the prime modulus.""   twos_complement_eval out1 = m""   out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]"fiat_p384_msat" The function fiat_p384_divstep computes a divstep.""   0 ≤ eval arg4 < m""   0 ≤ eval arg5 < m""   out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)""   twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)""   twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)""   eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)""   eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)""   0 ≤ eval out5 < m""   0 ≤ eval out2 < m""   0 ≤ eval out3 < m""   arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]""   out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]"fiat_p384_divstep" The function fiat_p384_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).""   eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)"fiat_p384_divstep_precomp" Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p384 64 '2^384 - 2^128 - 2^96 + 2^32 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp"" machine_wordsize = 64 (from \"64\")""   eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140)""   twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in"" The function fiat_p384_addcarryx_u64 is an addition with carry.""   out1 = (arg1 + arg2 + arg3) mod 2^64""   out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋""   arg2: [0x0 ~> 0xffffffffffffffff]""   arg3: [0x0 ~> 0xffffffffffffffff]""   out1: [0x0 ~> 0xffffffffffffffff]"fiat_p384_addcarryx_u64" The function fiat_p384_subborrowx_u64 is a subtraction with borrow.""   out1 = (-arg1 + arg2 + -arg3) mod 2^64""   out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋"fiat_p384_subborrowx_u64" The function fiat_p384_mulx_u64 is a multiplication, returning the full double-width result.""   out1 = (arg1 * arg2) mod 2^64""   out2 = ⌊arg1 * arg2 / 2^64⌋""   arg1: [0x0 ~> 0xffffffffffffffff]""   out2: [0x0 ~> 0xffffffffffffffff]"fiat_p384_mulx_u64" The function fiat_p384_cmovznz_u64 is a single-word conditional move."fiat_p384_cmovznz_u64"   eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^6) mod m""   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]""   out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]"NistP384/// p = 2^{384} − 2^{128} − 2^{96} + 2^{32} − 1/// Element of the secp384r1 base field used for curve coordinates./// Compute [`FieldElement`] inversion: `1 / self`./// Returns the square root of self mod p, or `None` if no square root/// Returns self^(2^n) mod p./// Basic tests that field inversion works.//! Field arithmetic modulo p = 2^{384} − 2^{128} − 2^{96} + 2^{32} − 1//! Arithmetic implementations are extracted Rust code from the Coq fiat-crypto//! libraries.//! # License//! Copyright (c) 2015-2020 the fiat-crypto authors//! fiat-crypto is distributed under the terms of the MIT License, the//! Apache License (Version 2.0), and the BSD 1-Clause License;//! users may pick which license to apply./// Taken from <https://www.ietf.org/archive/id/draft-irtf-cfrg-voprf-16.html#name-oprfp-384-sha-384-2>.impl_field_invert/// Implement field element inversion." Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p384_scalar 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp"" curve description: p384_scalar"" m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from \"2^384 - 1388124618062372383947042015309946732620727252194336364173\")"fiat_p384_scalar_u1fiat_p384_scalar_i1fiat_p384_scalar_u2fiat_p384_scalar_i2fiat_p384_scalar_montgomery_domain_field_elementfiat_p384_scalar_non_montgomery_domain_field_element" The function fiat_p384_scalar_addcarryx_u32 is an addition with carry."fiat_p384_scalar_addcarryx_u32" The function fiat_p384_scalar_subborrowx_u32 is a subtraction with borrow."fiat_p384_scalar_subborrowx_u32" The function fiat_p384_scalar_mulx_u32 is a multiplication, returning the full double-width result."fiat_p384_scalar_mulx_u32" The function fiat_p384_scalar_cmovznz_u32 is a single-word conditional move."fiat_p384_scalar_cmovznz_u32" The function fiat_p384_scalar_mul multiplies two field elements in the Montgomery domain."fiat_p384_scalar_mul" The function fiat_p384_scalar_square squares a field element in the Montgomery domain."fiat_p384_scalar_square" The function fiat_p384_scalar_add adds two field elements in the Montgomery domain."fiat_p384_scalar_add" The function fiat_p384_scalar_sub subtracts two field elements in the Montgomery domain."fiat_p384_scalar_sub" The function fiat_p384_scalar_opp negates a field element in the Montgomery domain."fiat_p384_scalar_opp" The function fiat_p384_scalar_from_montgomery translates a field element out of the Montgomery domain."fiat_p384_scalar_from_montgomery" The function fiat_p384_scalar_to_montgomery translates a field element into the Montgomery domain."fiat_p384_scalar_to_montgomery" The function fiat_p384_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise."fiat_p384_scalar_nonzero" The function fiat_p384_scalar_selectznz is a multi-limb conditional select."fiat_p384_scalar_selectznz" The function fiat_p384_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order."fiat_p384_scalar_to_bytes" The function fiat_p384_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order."fiat_p384_scalar_from_bytes" The function fiat_p384_scalar_set_one returns the field element one in the Montgomery domain."fiat_p384_scalar_set_one" The function fiat_p384_scalar_msat returns the saturated representation of the prime modulus."fiat_p384_scalar_msat" The function fiat_p384_scalar_divstep computes a divstep."fiat_p384_scalar_divstep" The function fiat_p384_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form)."fiat_p384_scalar_divstep_precomp" Autogenerated: './word_by_word_montgomery' --lang Rust --inline p384_scalar"" 64 39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643"" requested operations: (all)"" m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from \"39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643\")""   eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] <<"" 256) + (z[5] << 0x140)   bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) +"" (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) +"" (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96)"" + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17]"" << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168)"" + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26]"" << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240)"" + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) +"" (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) +"" (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) +"" (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) +"" (z[47] << 0x178)   twos_complement_eval z = let x1 := z[0] + (z[1] << 64) +"" (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in""                            if x1 & (2^384-1) < 2^383 then x1 & (2^384-1)"" else (x1 & (2^384-1)) - 2^384"" The function fiat_p384_scalar_addcarryx_u64 is an addition with carry."fiat_p384_scalar_addcarryx_u64" The function fiat_p384_scalar_subborrowx_u64 is a subtraction with borrow."fiat_p384_scalar_subborrowx_u64" The function fiat_p384_scalar_mulx_u64 is a multiplication, returning the"" full double-width result."fiat_p384_scalar_mulx_u64" The function fiat_p384_scalar_cmovznz_u64 is a single-word conditional move."fiat_p384_scalar_cmovznz_u64" The function fiat_p384_scalar_mul multiplies two field elements in the"" Montgomery domain.""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval"" (from_montgomery arg2)) mod m   0 ≤ eval out1 < m"" The function fiat_p384_scalar_square squares a field element in the"" (from_montgomery arg1)) mod m   0 ≤ eval out1 < m"" The function fiat_p384_scalar_add adds two field elements in the Montgomery"" domain.""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval"" The function fiat_p384_scalar_sub subtracts two field elements in the""   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval"" The function fiat_p384_scalar_opp negates a field element in the Montgomery"" The function fiat_p384_scalar_from_montgomery translates a field element out"" of the Montgomery domain."" The function fiat_p384_scalar_to_montgomery translates a field element into"" the Montgomery domain.""   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]   arg3: [[0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] Output Bounds:""   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]"" The function fiat_p384_scalar_to_bytes serializes a field element NOT in the"" Montgomery domain to bytes in little-endian order.""   out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋)"" [0..47]""   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~>""   out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~>"" 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~>"" 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]"" The function fiat_p384_scalar_from_bytes deserializes a field element NOT in"" the Montgomery domain from bytes in little-endian order.""   arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~>"" 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] Output Bounds:"" The function fiat_p384_scalar_set_one returns the field element one in the"" The function fiat_p384_scalar_msat returns the saturated representation of"" the prime modulus."" 0xffffffffffffffff]]"" The function fiat_p384_scalar_divstep_precomp returns the precomputed value"" for Bernstein-Yang-inversion (in montgomery form).""   eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then"" ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)""   out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1"" else 1 + arg1)   twos_complement_eval out2 = (if 0 < arg1 ∧"" (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else"" twos_complement_eval arg2)   twos_complement_eval out3 = (if 0 < arg1 ∧"" (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 -"" twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 +"" (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)""   eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval"" arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval"" (from_montgomery arg4)) mod m)   eval (from_montgomery out5) mod m = (if 0 <"" arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4)"" - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) +"" (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)"" 0xffffffffffffffff]]   arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]   arg4: [[0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]   arg5: [[0x0 ~>""   out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~>"" 0xffffffffffffffff]]   out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]   out4: [[0x0 ~>"" 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]   out5: [[0x0 ~>"/// Scalars are elements in the finite field modulo `n`./// `p384::elliptic_curve::ff`:/// Compute [`Scalar`] inversion: `1 / self`./// Compute modular square root./// Basic tests that scalar inversion works./// Basic tests that sqrt works.//! secp384r1 scalar field elements./// a = -3 (0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffc)/// b = b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112///     0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef/// Base point of P-384./// Defined in NIST SP 800-186 § G.1.3: Curve P-384./// Gₓ = aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98///      59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7/// Gᵧ = 3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c///      e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f/// Adapted from [NIST SP 800-186] § G.1.3: Curve P-384.//! Pure Rust implementation of group operations on secp384r1.//! Curve parameters can be found in [NIST SP 800-186] § G.1.3: Curve P-384./// NIST P-384 Ephemeral Diffie-Hellman Secret.//! Diffie-Hellman key exchanges using the secp384 elliptic curve.//! use p384::{EncodedPoint, PublicKey, ecdh::EphemeralSecret};/// ECDSA/P-384 signature (fixed-size)/// ECDSA/P-384 signature (ASN.1 DER encoded)/// ECDSA/P-384 signing key/// ECDSA/P-384 verification key (i.e. public key)// Test vector from RFC 6979 Appendix 2.6 (NIST P-384 + SHA-384)// <https://tools.ietf.org/html/rfc6979#appendix-A.2.6>prehash_signer_signing_with_sha256// Test signing with PrehashSigner using SHA-256 which output is smaller than P-384 field size.prehash_signer_verification_with_sha256// Test verifying with PrehashVerifier using SHA-256 which output is smaller than P-384 field size.signing_secret_key_equivalent//!   ECDSA/P-384 signature). Does not require the `arithmetic` feature. This is//!   useful for 3rd-party crates which wish to use the `Signature` type for//!   interoperability purposes (particularly in conjunction with the//!   software implementations of ECDSA/P-384 and wrappers for cloud KMS//!   [`VerifyingKey`] types which natively implement ECDSA/P-384 signing and//! use p384::ecdsa::{signature::Signer, Signature, SigningKey};//! use p384::ecdsa::{signature::Verifier, VerifyingKey};/// Order of NIST P-384's elliptic curve group (i.e. scalar modulus) in hexadecimal./// NIST P-384 elliptic curve./// 48-byte serialized field elements./// 384-bit integer type used for internally representing field elements./// Order of NIST P-384's elliptic curve group (i.e. scalar modulus)./// NIST P-384 points are typically uncompressed./// Compressed SEC1-encoded NIST P-384 curve point./// NIST P-384 SEC1 encoded point./// NIST P-384 field element serialized as bytes./// Byte array containing a serialized field element value (base field or/// scalar)./// Non-zero NIST P-384 scalar field element./// NIST P-384 public key./// NIST P-384 secret key./// ECDSA/P-384 test vectors./// (P-384, SHA-384, from `SigGen.txt` in `186-4ecdsatestvectors.zip`)/// The `m` field contains a SHA-384 prehash of the `Msg` field in the//! ECDSA/secp384r1 test vectors//! Test vectors for the secp384r1 group.//! secp384r1 test vectors./// This function retrieves the system's memory page size./// extern crate page_size;/// println!("{}", page_size::get());get_granularity/// This function retrieves the system's memory allocation granularity./// println!("{}", page_size::get_granularity());get_helperget_granularity_helper// Unix does not have a specific allocation granularity.// The page size works well.test_get_granularity//! This crate provides an easy, fast, cross-platform way to retrieve the//! memory page size of the current system.//! Modern hardware and software tend to load data into RAM (and transfer data//! from RAM to disk) in discrete chunk called pages. This crate provides a//! helper method to retrieve the size in bytes of these pages. Since the page//! size *should not* change during execution, this crate will cache the result//! after it has been called once.//! To make this crate useful for writing memory allocators, it does not require//! (but can use) the Rust standard library.//! Since Windows addresses sometimes have to correspond with an allocation//! granularity that does not always match the size of the page, I have included//! a method to retrieve that as well.//! extern crate page_size;//! println!("{}", page_size::get());// Unix Section// WebAssembly section// Windows Section// Stub SectionPangoAnalysisextra_attrsAttrTypeAttrClassPangoAttrClassdefine_attribute_structAttrColorPangoAttrColorIsAttributeATTR_TYPESPangoAttributenew_backgroundnew_foregroundnew_strikethrough_colornew_underline_colorAttrFloatPangoAttrFloatnew_scaleAttrFontDescPangoAttrFontDescAttrFontFeaturesPangoAttrFontFeaturesGravityHintAttrIntPangoAttrIntnew_background_alphanew_fallbacknew_foreground_alphanew_gravity_hintnew_weightnew_gravitynew_letter_spacingnew_risenew_stretchnew_strikethroughnew_stylenew_underlinenew_variantPangoAttrIteratorAttrIteratornext_style_changeAttrIntoIterattr_iteratorAttrLanguagePangoAttrLanguagechangeAttrShapePangoAttrShapeink_rectlogical_rectAttrSizePangoAttrSizenew_size_absoluteAttrStringPangoAttrStringnew_familyattr_classset_start_indexset_end_indexGlyphUnitLayoutRunGlyphItemPangoColorFontMetricsFontsetPangoContextClassbase_dirbase_gravityfont_descriptiongravity_hintmetricslist_familiesload_fontload_fontsetset_base_dirset_base_gravityset_font_descriptionset_gravity_hintPangoAlignmentFontDescShapeFallbackLetterSpacingUnderlineColorStrikethroughColorAbsoluteSizeFontFeaturesForegroundAlphaBackgroundAlphaAllowBreaksShowInsertHyphensOverlineOverlineColorPangoAttrTypeBidiTypeLreLroRloEnEsEtAnCsNsmBnWsLriRliFsiPdifor_unicharPangoBidiTypeCoverageLevelApproximatePangoCoverageLevelTtbLtrTtbRtlWeakLtrWeakRtlNeutralfor_matrixfor_scriptfor_script_and_widthto_rotationPangoGravityPangoGravityHintRenderPartPangoRenderPartsample_languagePangoScriptUltraCondensedExtraCondensedSemiCondensedSemiExpandedExtraExpandedUltraExpandedPangoStretchPangoStyleTabAlignPangoTabAlignDoubleLineErrorLinePangoUnderlineSmallCapsPangoVariantUltraboldUltraheavyPangoWeightFontMaskFAMILYWEIGHTSTRETCHGRAVITYVARIATIONSPangoFontMaskCoveragePangoFontPangoFontClassdescribe_with_absolute_sizecoverage//#[cfg(feature = "v1_44")]//#[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]//#[doc(alias = "pango_font_get_features")]//#[doc(alias = "get_features")]//fn features(&self, features: /*Unimplemented*/&mut Basic: Pointer, len: u32, num_features: &mut u32) {//    unsafe { TODO: call ffi:pango_font_get_features() }//#[doc(alias = "pango_font_get_hb_font")]//#[doc(alias = "get_hb_font")]//fn hb_font(&self) -> /*Ignored*/Option<harf_buzz::font_t> {//    unsafe { TODO: call ffi:pango_font_get_hb_font() }FontExtbetter_matchset_fieldsis_size_absoluteset_absolute_sizeto_filenameunset_fieldsPangoFontFaceClassface_nameis_synthesizedlist_sizesFontFaceExtPangoFontFamilyClasslist_facesFontFamilyExtPangoFontMapClassFontMapExtPangoFontMetricsapproximate_char_widthapproximate_digit_widthstrikethrough_positionstrikethrough_thicknessunderline_positionunderline_thicknessPangoFontsetPangoFontsetClassFontsetExtFontsetSimplePangoFontsetSimplePangoFontsetSimpleClassGlyphStringfind_base_dirfind_paragraph_boundaryitemizeitemize_with_base_dirmarkup_parser_finishmarkup_parser_newparse_markupparse_stretchparse_variantparse_weightquantize_line_geometryshapeunichar_directionunits_from_doubleunits_to_double//#[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")]//#[doc(alias = "pango_break")]//#[doc(alias = "break")]//pub fn break_(text: &str, analysis: &mut Analysis, attrs: /*Ignored*/&[LogAttr]) {//    unsafe { TODO: call ffi:pango_break() }//#[doc(alias = "pango_default_break")]//pub fn default_break(text: &str, analysis: Option<&mut Analysis>, attrs: /*Ignored*/&mut LogAttr, attrs_len: i32) {//    unsafe { TODO: call ffi:pango_default_break() }//#[doc(alias = "pango_get_log_attrs")]//#[doc(alias = "get_log_attrs")]//pub fn log_attrs(text: &str, level: i32, language: &mut Language, attrs: /*Ignored*/&[LogAttr]) {//    unsafe { TODO: call ffi:pango_get_log_attrs() }//#[cfg(feature = "v1_50")]//#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]//#[doc(alias = "pango_shape_item")]//pub fn shape_item(item: &mut Item, paragraph_text: Option<&str>, log_attrs: /*Ignored*/Option<&mut LogAttr>, glyphs: &mut GlyphString, flags: ShapeFlags) {//    unsafe { TODO: call ffi:pango_shape_item() }//#[doc(alias = "pango_tailor_break")]//pub fn tailor_break(text: &str, analysis: &mut Analysis, offset: i32, attrs: /*Ignored*/&[LogAttr]) {//    unsafe { TODO: call ffi:pango_tailor_break() }PangoGlyphItemapply_attrs//#[doc(alias = "pango_glyph_item_letter_space")]//pub fn letter_space(&mut self, text: &str, log_attrs: /*Ignored*/&[LogAttr], letter_spacing: i32) {//    unsafe { TODO: call ffi:pango_glyph_item_letter_space() }PangoGlyphStringextents_rangeindex_to_xx_to_index//#[doc(alias = "pango_glyph_string_index_to_x_full")]//pub fn index_to_x_full(&mut self, text: &str, analysis: &mut Analysis, attrs: /*Ignored*/Option<&mut LogAttr>, index_: i32, trailing: bool) -> i32 {//    unsafe { TODO: call ffi:pango_glyph_string_index_to_x_full() }PangoItemsample_stringincludes_scriptLayoutIterPangoLayoutClasscontext_changedis_auto_dircursor_posis_justifyline_readonlylines_readonlypixel_extentsunknown_glyphs_countindex_to_line_xindex_to_posis_ellipsizedis_wrappedmove_cursor_visuallyset_auto_dirset_markup_with_accelxy_to_index//#[doc(alias = "pango_layout_get_log_attrs")]//pub fn log_attrs(&self, attrs: /*Ignored*/Vec<LogAttr>) -> i32 {//    unsafe { TODO: call ffi:pango_layout_get_log_attrs() }//#[doc(alias = "pango_layout_get_log_attrs_readonly")]//#[doc(alias = "get_log_attrs_readonly")]//pub fn log_attrs_readonly(&self) -> /*Ignored*/Vec<LogAttr> {//    unsafe { TODO: call ffi:pango_layout_get_log_attrs_readonly() }PangoLayoutIterat_last_linechar_extentscluster_extentslayout_extentsline_extentsrun_extentsrun_readonlynext_charnext_clusternext_runx_rangesPangoMatrixfont_scale_factorfont_scale_factorsfontsetfontset_simplerendererattr_listfont_metricsglyph_itemglyph_stringlayout_iterlayout_linetab_arrayRendererExtPangoRendererPangoRendererClassdraw_error_underlinedraw_glyphdraw_glyph_itemdraw_glyphsdraw_layout_linedraw_rectangledraw_trapezoidpart_changedis_positions_in_pixelsset_tab//#[doc(alias = "pango_tab_array_new_with_positions")]//#[doc(alias = "new_with_positions")]//pub fn with_positions(size: i32, positions_in_pixels: bool, first_alignment: TabAlign, first_position: i32, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> TabArray {//    unsafe { TODO: call ffi:pango_tab_array_new_with_positions() }PangoCoverage// There was no get_type() function before 1.44PangoGlyphGeometryGlyphGeometryset_x_offsety_offsetset_y_offsetPangoGlyphInfoGlyphInfoset_glyphgeometry_mutlogical_widthsPangoGlyphItemIter'itemGlyphItemIternew_endprev_clusterstart_glyphstart_charend_glyphend_charGlyphItemIntoIterglyph_infoglyph_info_mutlog_clusterslog_clusters_mutglyph_string_logical_widthsnum_charsscriptsis_insideHitPosition/// The result of [`LayoutLine::x_to_index`]./// The UTF-8 byte offset of the grapheme closest to the position./// This position is relative to the start of the [`Layout`]'s text./// [`Layout`]: crate::Layout/// The codepoint within the grapheme of the position./// This will always be either `0`, or the number of `char`s (*not bytes!*)/// in the grapheme. This represents whether the user clicked near the start/// of the grapheme or near the end; this is important for things like/// resolving cursor positions./// Whether or not the position was within the bounds of the line./// If this is `false`, then `index` and `trailing` will always resolve/// to either the very first or the very last position in the line; this/// behaviour is dependent on the line's resolved writing direction./// The byte index of the start of this line into the text used to create/// the source [`Layout`]./// The length of this line's text, in bytes.runsSCALEANALYSIS_FLAG_CENTERED_BASELINEANALYSIS_FLAG_IS_ELLIPSISANALYSIS_FLAG_NEED_HYPHENATTR_INDEX_FROM_TEXT_BEGINNINGATTR_INDEX_TO_TEXT_ENDGLYPH_EMPTYGLYPH_INVALID_INPUTGLYPH_UNKNOWN_FLAGSCALE_XX_SMALL/// The scale factor for three shrinking steps (1 / (1.2 * 1.2 * 1.2)).SCALE_X_SMALL/// The scale factor for two shrinking steps (1 / (1.2 * 1.2)).SCALE_SMALL/// The scale factor for one shrinking step (1 / 1.2).SCALE_MEDIUM/// The scale factor for normal size (1.0).SCALE_LARGE/// The scale factor for one magnification step (1.2).SCALE_X_LARGE/// The scale factor for two magnification steps (1.2 * 1.2).SCALE_XX_LARGE/// The scale factor for three magnification steps (1.2 * 1.2 * 1.2).attr_colorattr_floatattr_font_descattr_font_featuresattr_intattr_languageattr_shapeattr_sizeglyph_geometryglyph_item_iterscript_iterScriptIntoIterScriptIterreorder_itemsshape_fullextents_to_pixelstransform_pixel_rectangletransform_rectanglePangoRectanglePangoScriptIter'textnext_rangeSCRIPTStab_array_tabsPangoGlyphPangoGlyphUnitPangoLayoutRunPANGO_ALIGN_LEFTPANGO_ALIGN_CENTERPANGO_ALIGN_RIGHTPANGO_ATTR_INVALIDPANGO_ATTR_LANGUAGEPANGO_ATTR_FAMILYPANGO_ATTR_STYLEPANGO_ATTR_WEIGHTPANGO_ATTR_VARIANTPANGO_ATTR_STRETCHPANGO_ATTR_SIZEPANGO_ATTR_FONT_DESCPANGO_ATTR_FOREGROUNDPANGO_ATTR_BACKGROUNDPANGO_ATTR_UNDERLINEPANGO_ATTR_STRIKETHROUGHPANGO_ATTR_RISEPANGO_ATTR_SHAPEPANGO_ATTR_SCALEPANGO_ATTR_FALLBACKPANGO_ATTR_LETTER_SPACINGPANGO_ATTR_UNDERLINE_COLORPANGO_ATTR_STRIKETHROUGH_COLORPANGO_ATTR_ABSOLUTE_SIZEPANGO_ATTR_GRAVITYPANGO_ATTR_GRAVITY_HINTPANGO_ATTR_FONT_FEATURESPANGO_ATTR_FOREGROUND_ALPHAPANGO_ATTR_BACKGROUND_ALPHAPANGO_ATTR_ALLOW_BREAKSPANGO_ATTR_SHOWPANGO_ATTR_INSERT_HYPHENSPANGO_ATTR_OVERLINEPANGO_ATTR_OVERLINE_COLORPANGO_ATTR_LINE_HEIGHTPANGO_ATTR_ABSOLUTE_LINE_HEIGHTPANGO_ATTR_TEXT_TRANSFORMPANGO_ATTR_WORDPANGO_ATTR_SENTENCEPANGO_ATTR_BASELINE_SHIFTPANGO_ATTR_FONT_SCALEPangoBaselineShiftPANGO_BASELINE_SHIFT_NONEPANGO_BASELINE_SHIFT_SUPERSCRIPTPANGO_BASELINE_SHIFT_SUBSCRIPTPANGO_BIDI_TYPE_LPANGO_BIDI_TYPE_LREPANGO_BIDI_TYPE_LROPANGO_BIDI_TYPE_RPANGO_BIDI_TYPE_ALPANGO_BIDI_TYPE_RLEPANGO_BIDI_TYPE_RLOPANGO_BIDI_TYPE_PDFPANGO_BIDI_TYPE_ENPANGO_BIDI_TYPE_ESPANGO_BIDI_TYPE_ETPANGO_BIDI_TYPE_ANPANGO_BIDI_TYPE_CSPANGO_BIDI_TYPE_NSMPANGO_BIDI_TYPE_BNPANGO_BIDI_TYPE_BPANGO_BIDI_TYPE_SPANGO_BIDI_TYPE_WSPANGO_BIDI_TYPE_ONPANGO_BIDI_TYPE_LRIPANGO_BIDI_TYPE_RLIPANGO_BIDI_TYPE_FSIPANGO_BIDI_TYPE_PDIPANGO_COVERAGE_NONEPANGO_COVERAGE_FALLBACKPANGO_COVERAGE_APPROXIMATEPANGO_COVERAGE_EXACTPANGO_DIRECTION_LTRPANGO_DIRECTION_RTLPANGO_DIRECTION_TTB_LTRPANGO_DIRECTION_TTB_RTLPANGO_DIRECTION_WEAK_LTRPANGO_DIRECTION_WEAK_RTLPANGO_DIRECTION_NEUTRALPANGO_ELLIPSIZE_NONEPANGO_ELLIPSIZE_STARTPANGO_ELLIPSIZE_MIDDLEPANGO_ELLIPSIZE_ENDPangoFontScalePANGO_FONT_SCALE_NONEPANGO_FONT_SCALE_SUPERSCRIPTPANGO_FONT_SCALE_SUBSCRIPTPANGO_FONT_SCALE_SMALL_CAPSPANGO_GRAVITY_SOUTHPANGO_GRAVITY_EASTPANGO_GRAVITY_NORTHPANGO_GRAVITY_WESTPANGO_GRAVITY_AUTOPANGO_GRAVITY_HINT_NATURALPANGO_GRAVITY_HINT_STRONGPANGO_GRAVITY_HINT_LINEPangoLayoutDeserializeErrorPANGO_LAYOUT_DESERIALIZE_INVALIDPANGO_LAYOUT_DESERIALIZE_INVALID_VALUEPANGO_LAYOUT_DESERIALIZE_MISSING_VALUEPangoOverlinePANGO_OVERLINE_NONEPANGO_OVERLINE_SINGLEPANGO_RENDER_PART_FOREGROUNDPANGO_RENDER_PART_BACKGROUNDPANGO_RENDER_PART_UNDERLINEPANGO_RENDER_PART_STRIKETHROUGHPANGO_RENDER_PART_OVERLINEPANGO_SCRIPT_INVALID_CODEPANGO_SCRIPT_COMMONPANGO_SCRIPT_INHERITEDPANGO_SCRIPT_ARABICPANGO_SCRIPT_ARMENIANPANGO_SCRIPT_BENGALIPANGO_SCRIPT_BOPOMOFOPANGO_SCRIPT_CHEROKEEPANGO_SCRIPT_COPTICPANGO_SCRIPT_CYRILLICPANGO_SCRIPT_DESERETPANGO_SCRIPT_DEVANAGARIPANGO_SCRIPT_ETHIOPICPANGO_SCRIPT_GEORGIANPANGO_SCRIPT_GOTHICPANGO_SCRIPT_GREEKPANGO_SCRIPT_GUJARATIPANGO_SCRIPT_GURMUKHIPANGO_SCRIPT_HANPANGO_SCRIPT_HANGULPANGO_SCRIPT_HEBREWPANGO_SCRIPT_HIRAGANAPANGO_SCRIPT_KANNADAPANGO_SCRIPT_KATAKANAPANGO_SCRIPT_KHMERPANGO_SCRIPT_LAOPANGO_SCRIPT_LATINPANGO_SCRIPT_MALAYALAMPANGO_SCRIPT_MONGOLIANPANGO_SCRIPT_MYANMARPANGO_SCRIPT_OGHAMPANGO_SCRIPT_OLD_ITALICPANGO_SCRIPT_ORIYAPANGO_SCRIPT_RUNICPANGO_SCRIPT_SINHALAPANGO_SCRIPT_SYRIACPANGO_SCRIPT_TAMILPANGO_SCRIPT_TELUGUPANGO_SCRIPT_THAANAPANGO_SCRIPT_THAIPANGO_SCRIPT_TIBETANPANGO_SCRIPT_CANADIAN_ABORIGINALPANGO_SCRIPT_YIPANGO_SCRIPT_TAGALOGPANGO_SCRIPT_HANUNOOPANGO_SCRIPT_BUHIDPANGO_SCRIPT_TAGBANWAPANGO_SCRIPT_BRAILLEPANGO_SCRIPT_CYPRIOTPANGO_SCRIPT_LIMBUPANGO_SCRIPT_OSMANYAPANGO_SCRIPT_SHAVIANPANGO_SCRIPT_LINEAR_BPANGO_SCRIPT_TAI_LEPANGO_SCRIPT_UGARITICPANGO_SCRIPT_NEW_TAI_LUEPANGO_SCRIPT_BUGINESEPANGO_SCRIPT_GLAGOLITICPANGO_SCRIPT_TIFINAGHPANGO_SCRIPT_SYLOTI_NAGRIPANGO_SCRIPT_OLD_PERSIANPANGO_SCRIPT_KHAROSHTHIPANGO_SCRIPT_UNKNOWNPANGO_SCRIPT_BALINESEPANGO_SCRIPT_CUNEIFORMPANGO_SCRIPT_PHOENICIANPANGO_SCRIPT_PHAGS_PAPANGO_SCRIPT_NKOPANGO_SCRIPT_KAYAH_LIPANGO_SCRIPT_LEPCHAPANGO_SCRIPT_REJANGPANGO_SCRIPT_SUNDANESEPANGO_SCRIPT_SAURASHTRAPANGO_SCRIPT_CHAMPANGO_SCRIPT_OL_CHIKIPANGO_SCRIPT_VAIPANGO_SCRIPT_CARIANPANGO_SCRIPT_LYCIANPANGO_SCRIPT_LYDIANPANGO_SCRIPT_BATAKPANGO_SCRIPT_BRAHMIPANGO_SCRIPT_MANDAICPANGO_SCRIPT_CHAKMAPANGO_SCRIPT_MEROITIC_CURSIVEPANGO_SCRIPT_MEROITIC_HIEROGLYPHSPANGO_SCRIPT_MIAOPANGO_SCRIPT_SHARADAPANGO_SCRIPT_SORA_SOMPENGPANGO_SCRIPT_TAKRIPANGO_SCRIPT_BASSA_VAHPANGO_SCRIPT_CAUCASIAN_ALBANIANPANGO_SCRIPT_DUPLOYANPANGO_SCRIPT_ELBASANPANGO_SCRIPT_GRANTHAPANGO_SCRIPT_KHOJKIPANGO_SCRIPT_KHUDAWADIPANGO_SCRIPT_LINEAR_APANGO_SCRIPT_MAHAJANIPANGO_SCRIPT_MANICHAEANPANGO_SCRIPT_MENDE_KIKAKUIPANGO_SCRIPT_MODIPANGO_SCRIPT_MROPANGO_SCRIPT_NABATAEANPANGO_SCRIPT_OLD_NORTH_ARABIANPANGO_SCRIPT_OLD_PERMICPANGO_SCRIPT_PAHAWH_HMONGPANGO_SCRIPT_PALMYRENEPANGO_SCRIPT_PAU_CIN_HAUPANGO_SCRIPT_PSALTER_PAHLAVIPANGO_SCRIPT_SIDDHAMPANGO_SCRIPT_TIRHUTAPANGO_SCRIPT_WARANG_CITIPANGO_SCRIPT_AHOMPANGO_SCRIPT_ANATOLIAN_HIEROGLYPHSPANGO_SCRIPT_HATRANPANGO_SCRIPT_MULTANIPANGO_SCRIPT_OLD_HUNGARIANPANGO_SCRIPT_SIGNWRITINGPANGO_STRETCH_ULTRA_CONDENSEDPANGO_STRETCH_EXTRA_CONDENSEDPANGO_STRETCH_CONDENSEDPANGO_STRETCH_SEMI_CONDENSEDPANGO_STRETCH_NORMALPANGO_STRETCH_SEMI_EXPANDEDPANGO_STRETCH_EXPANDEDPANGO_STRETCH_EXTRA_EXPANDEDPANGO_STRETCH_ULTRA_EXPANDEDPANGO_STYLE_NORMALPANGO_STYLE_OBLIQUEPANGO_STYLE_ITALICPANGO_TAB_LEFTPANGO_TAB_RIGHTPANGO_TAB_CENTERPANGO_TAB_DECIMALPangoTextTransformPANGO_TEXT_TRANSFORM_NONEPANGO_TEXT_TRANSFORM_LOWERCASEPANGO_TEXT_TRANSFORM_UPPERCASEPANGO_TEXT_TRANSFORM_CAPITALIZEPANGO_UNDERLINE_NONEPANGO_UNDERLINE_SINGLEPANGO_UNDERLINE_DOUBLEPANGO_UNDERLINE_LOWPANGO_UNDERLINE_ERRORPANGO_UNDERLINE_SINGLE_LINEPANGO_UNDERLINE_DOUBLE_LINEPANGO_UNDERLINE_ERROR_LINEPANGO_VARIANT_NORMALPANGO_VARIANT_SMALL_CAPSPANGO_VARIANT_ALL_SMALL_CAPSPANGO_VARIANT_PETITE_CAPSPANGO_VARIANT_ALL_PETITE_CAPSPANGO_VARIANT_UNICASEPANGO_VARIANT_TITLE_CAPSPANGO_WEIGHT_THINPANGO_WEIGHT_ULTRALIGHTPANGO_WEIGHT_LIGHTPANGO_WEIGHT_SEMILIGHTPANGO_WEIGHT_BOOKPANGO_WEIGHT_NORMALPANGO_WEIGHT_MEDIUMPANGO_WEIGHT_SEMIBOLDPANGO_WEIGHT_BOLDPANGO_WEIGHT_ULTRABOLDPANGO_WEIGHT_HEAVYPANGO_WEIGHT_ULTRAHEAVYPANGO_WRAP_WORDPANGO_WRAP_CHARPANGO_WRAP_WORD_CHARPANGO_ANALYSIS_FLAG_CENTERED_BASELINEPANGO_ANALYSIS_FLAG_IS_ELLIPSISPANGO_ANALYSIS_FLAG_NEED_HYPHENPANGO_ATTR_INDEX_FROM_TEXT_BEGINNINGPANGO_ATTR_INDEX_TO_TEXT_ENDPANGO_GLYPH_EMPTYPANGO_GLYPH_INVALID_INPUTPANGO_GLYPH_UNKNOWN_FLAGPANGO_SCALEPANGO_FONT_MASK_FAMILYPANGO_FONT_MASK_STYLEPANGO_FONT_MASK_VARIANTPANGO_FONT_MASK_WEIGHTPANGO_FONT_MASK_STRETCHPANGO_FONT_MASK_SIZEPANGO_FONT_MASK_GRAVITYPANGO_FONT_MASK_VARIATIONSPangoLayoutDeserializeFlagsPANGO_LAYOUT_DESERIALIZE_DEFAULTPANGO_LAYOUT_DESERIALIZE_CONTEXTPangoLayoutSerializeFlagsPANGO_LAYOUT_SERIALIZE_DEFAULTPANGO_LAYOUT_SERIALIZE_CONTEXTPANGO_LAYOUT_SERIALIZE_OUTPUTPangoShapeFlagsPANGO_SHAPE_NONEPANGO_SHAPE_ROUND_POSITIONSPangoShowFlagsPANGO_SHOW_NONEPANGO_SHOW_SPACESPANGO_SHOW_LINE_BREAKSPANGO_SHOW_IGNORABLESPangoAttrDataCopyFuncPangoAttrFilterFuncPangoFontsetForeachFuncshape_enginelang_enginecopy_funcdestroy_func_PangoContextClassget_coverageget_glyph_extentsdescribe_absolutecreate_hb_fontget_face_name_pango_reserved3_pango_reserved4is_variableget_face_pango_reserved2shape_engine_typeget_fontget_language_pango_reserved1_PangoFontsetSimpleClassPangoGlyphVisAttrglyphsstart_x_offsetend_x_offsetis_cluster_start_PangoLayoutClassis_paragraph_start// field resolved_dir has incomplete typeis_line_break// field is_mandatory_break has incomplete typePangoLogAttrdraw_shapeprepare_run_PangoRendererPrivatePangoRendererPrivateactive_countpango_alignment_get_type// PangoAlignmentpango_attr_type_get_type// PangoAttrTypepango_attr_type_get_namepango_attr_type_registerpango_bidi_type_get_type// PangoBidiTypepango_bidi_type_for_unicharpango_coverage_level_get_type// PangoCoverageLevelpango_direction_get_type// PangoDirectionpango_ellipsize_mode_get_type// PangoEllipsizeModepango_gravity_get_type// PangoGravitypango_gravity_get_for_matrixpango_gravity_get_for_scriptpango_gravity_get_for_script_and_widthpango_gravity_to_rotationpango_gravity_hint_get_type// PangoGravityHintpango_render_part_get_type// PangoRenderPartpango_script_get_type// PangoScriptpango_script_for_unicharpango_script_get_sample_languagepango_stretch_get_type// PangoStretchpango_style_get_type// PangoStylepango_tab_align_get_type// PangoTabAlignpango_underline_get_type// PangoUnderlinepango_variant_get_type// PangoVariantpango_weight_get_type// PangoWeightpango_wrap_mode_get_type// PangoWrapModepango_font_mask_get_type// PangoFontMaskpango_attr_font_desc_new// PangoAttrFontDescpango_attr_font_features_new// PangoAttrFontFeaturespango_attr_iterator_copypango_attr_iterator_destroypango_attr_iterator_getpango_attr_iterator_get_attrspango_attr_iterator_get_fontpango_attr_iterator_nextpango_attr_iterator_rangepango_attr_language_new// PangoAttrLanguagepango_attr_list_get_type// PangoAttrListpango_attr_list_newpango_attr_list_changepango_attr_list_copypango_attr_list_filterpango_attr_list_get_iteratorpango_attr_list_insertpango_attr_list_insert_beforepango_attr_list_refpango_attr_list_splicepango_attr_list_unrefpango_attr_shape_new// PangoAttrShapepango_attr_shape_new_with_datapango_attr_size_new// PangoAttrSizepango_attr_size_new_absolutepango_attribute_copypango_attribute_destroypango_attribute_equalpango_attribute_initpango_color_get_type// PangoColorpango_color_copypango_color_freepango_color_parsepango_color_to_stringpango_font_description_get_type// PangoFontDescriptionpango_font_description_newpango_font_description_better_matchpango_font_description_copypango_font_description_copy_staticpango_font_description_equalpango_font_description_freepango_font_description_get_familypango_font_description_get_gravitypango_font_description_get_set_fieldspango_font_description_get_sizepango_font_description_get_size_is_absolutepango_font_description_get_stretchpango_font_description_get_stylepango_font_description_get_variantpango_font_description_get_weightpango_font_description_hashpango_font_description_mergepango_font_description_merge_staticpango_font_description_set_absolute_sizepango_font_description_set_familypango_font_description_set_family_staticpango_font_description_set_gravitypango_font_description_set_sizepango_font_description_set_stretchpango_font_description_set_stylepango_font_description_set_variantpango_font_description_set_weightpango_font_description_to_filenamepango_font_description_to_stringpango_font_description_unset_fieldspango_font_description_from_stringpango_font_metrics_get_type// PangoFontMetricspango_font_metrics_get_approximate_char_widthpango_font_metrics_get_approximate_digit_widthpango_font_metrics_get_ascentpango_font_metrics_get_descentpango_font_metrics_get_strikethrough_positionpango_font_metrics_get_strikethrough_thicknesspango_font_metrics_get_underline_positionpango_font_metrics_get_underline_thicknesspango_font_metrics_refpango_font_metrics_unrefpango_glyph_item_get_type// PangoGlyphItempango_glyph_item_apply_attrspango_glyph_item_copypango_glyph_item_freepango_glyph_item_get_logical_widthspango_glyph_item_letter_spacepango_glyph_item_splitpango_glyph_item_iter_get_type// PangoGlyphItemIterpango_glyph_item_iter_copypango_glyph_item_iter_freepango_glyph_item_iter_init_endpango_glyph_item_iter_init_startpango_glyph_item_iter_next_clusterpango_glyph_item_iter_prev_clusterpango_glyph_string_get_type// PangoGlyphStringpango_glyph_string_newpango_glyph_string_copypango_glyph_string_extentspango_glyph_string_extents_rangepango_glyph_string_freepango_glyph_string_get_logical_widthspango_glyph_string_get_widthpango_glyph_string_index_to_xpango_glyph_string_set_sizepango_glyph_string_x_to_indexpango_item_get_type// PangoItempango_item_newpango_item_copypango_item_freepango_item_splitpango_language_get_type// PangoLanguagepango_language_get_sample_stringpango_language_get_scriptspango_language_includes_scriptpango_language_matchespango_language_to_stringpango_language_from_stringpango_language_get_defaultpango_layout_iter_get_type// PangoLayoutIterpango_layout_iter_at_last_linepango_layout_iter_copypango_layout_iter_freepango_layout_iter_get_baselinepango_layout_iter_get_char_extentspango_layout_iter_get_cluster_extentspango_layout_iter_get_indexpango_layout_iter_get_layoutpango_layout_iter_get_layout_extentspango_layout_iter_get_linepango_layout_iter_get_line_extentspango_layout_iter_get_line_readonlypango_layout_iter_get_line_yrangepango_layout_iter_get_runpango_layout_iter_get_run_extentspango_layout_iter_get_run_readonlypango_layout_iter_next_charpango_layout_iter_next_clusterpango_layout_iter_next_linepango_layout_iter_next_runpango_layout_line_get_type// PangoLayoutLinepango_layout_line_get_extentspango_layout_line_get_pixel_extentspango_layout_line_get_x_rangespango_layout_line_index_to_xpango_layout_line_refpango_layout_line_unrefpango_layout_line_x_to_indexpango_matrix_get_type// PangoMatrixpango_matrix_concatpango_matrix_copypango_matrix_freepango_matrix_get_font_scale_factorpango_matrix_get_font_scale_factorspango_matrix_rotatepango_matrix_scalepango_matrix_transform_distancepango_matrix_transform_pixel_rectanglepango_matrix_transform_pointpango_matrix_transform_rectanglepango_matrix_translatepango_script_iter_newpango_script_iter_freepango_script_iter_get_rangepango_script_iter_nextpango_tab_array_get_type// PangoTabArraypango_tab_array_newpango_tab_array_new_with_positionspango_tab_array_copypango_tab_array_freepango_tab_array_get_positions_in_pixelspango_tab_array_get_sizepango_tab_array_get_tabpango_tab_array_get_tabspango_tab_array_resizepango_tab_array_set_tabpango_context_get_type// PangoContextpango_context_newpango_context_changedpango_context_get_base_dirpango_context_get_base_gravitypango_context_get_font_descriptionpango_context_get_font_mappango_context_get_gravitypango_context_get_gravity_hintpango_context_get_languagepango_context_get_matrixpango_context_get_metricspango_context_get_serialpango_context_list_familiespango_context_load_fontpango_context_load_fontsetpango_context_set_base_dirpango_context_set_base_gravitypango_context_set_font_descriptionpango_context_set_font_mappango_context_set_gravity_hintpango_context_set_languagepango_context_set_matrixpango_coverage_newpango_coverage_from_bytespango_coverage_copypango_coverage_getpango_coverage_maxpango_coverage_refpango_coverage_setpango_coverage_to_bytespango_coverage_unrefpango_font_get_type// PangoFontpango_font_descriptions_freepango_font_describepango_font_describe_with_absolute_sizepango_font_get_coveragepango_font_get_font_mappango_font_get_glyph_extentspango_font_get_metricspango_font_face_get_type// PangoFontFacepango_font_face_describepango_font_face_get_face_namepango_font_face_is_synthesizedpango_font_face_list_sizespango_font_family_get_type// PangoFontFamilypango_font_family_get_namepango_font_family_is_monospacepango_font_family_list_facespango_font_map_get_type// PangoFontMappango_font_map_changedpango_font_map_create_contextpango_font_map_get_serialpango_font_map_list_familiespango_font_map_load_fontpango_font_map_load_fontsetpango_fontset_get_type// PangoFontsetpango_fontset_foreachpango_fontset_get_fontpango_fontset_get_metricspango_fontset_simple_get_type// PangoFontsetSimplepango_fontset_simple_newpango_fontset_simple_appendpango_fontset_simple_sizepango_layout_get_type// PangoLayoutpango_layout_newpango_layout_context_changedpango_layout_copypango_layout_get_alignmentpango_layout_get_attributespango_layout_get_auto_dirpango_layout_get_baselinepango_layout_get_character_countpango_layout_get_contextpango_layout_get_cursor_pospango_layout_get_ellipsizepango_layout_get_extentspango_layout_get_font_descriptionpango_layout_get_heightpango_layout_get_indentpango_layout_get_iterpango_layout_get_justifypango_layout_get_linepango_layout_get_line_countpango_layout_get_line_readonlypango_layout_get_linespango_layout_get_lines_readonlypango_layout_get_log_attrspango_layout_get_log_attrs_readonlypango_layout_get_pixel_extentspango_layout_get_pixel_sizepango_layout_get_serialpango_layout_get_single_paragraph_modepango_layout_get_sizepango_layout_get_spacingpango_layout_get_tabspango_layout_get_textpango_layout_get_unknown_glyphs_countpango_layout_get_widthpango_layout_get_wrappango_layout_index_to_line_xpango_layout_index_to_pospango_layout_is_ellipsizedpango_layout_is_wrappedpango_layout_move_cursor_visuallypango_layout_set_alignmentpango_layout_set_attributespango_layout_set_auto_dirpango_layout_set_ellipsizepango_layout_set_font_descriptionpango_layout_set_heightpango_layout_set_indentpango_layout_set_justifypango_layout_set_markuppango_layout_set_markup_with_accelpango_layout_set_single_paragraph_modepango_layout_set_spacingpango_layout_set_tabspango_layout_set_textpango_layout_set_widthpango_layout_set_wrappango_layout_xy_to_indexpango_renderer_get_type// PangoRendererpango_renderer_activatepango_renderer_deactivatepango_renderer_draw_error_underlinepango_renderer_draw_glyphpango_renderer_draw_glyph_itempango_renderer_draw_glyphspango_renderer_draw_layoutpango_renderer_draw_layout_linepango_renderer_draw_rectanglepango_renderer_draw_trapezoidpango_renderer_get_alphapango_renderer_get_colorpango_renderer_get_layoutpango_renderer_get_layout_linepango_renderer_get_matrixpango_renderer_part_changedpango_renderer_set_alphapango_renderer_set_colorpango_renderer_set_matrixpango_attr_background_alpha_newpango_attr_background_newpango_attr_fallback_newpango_attr_family_newpango_attr_foreground_alpha_newpango_attr_foreground_newpango_attr_gravity_hint_newpango_attr_gravity_newpango_attr_letter_spacing_newpango_attr_rise_newpango_attr_scale_newpango_attr_stretch_newpango_attr_strikethrough_color_newpango_attr_strikethrough_newpango_attr_style_newpango_attr_underline_color_newpango_attr_underline_newpango_attr_variant_newpango_attr_weight_newpango_breakpango_default_breakpango_extents_to_pixelspango_find_base_dirpango_find_paragraph_boundarypango_get_log_attrspango_get_mirror_charpango_is_zero_widthpango_itemizepango_itemize_with_base_dirpango_log2vis_get_embedding_levelspango_markup_parser_finishpango_markup_parser_newpango_parse_enumpango_parse_markuppango_parse_stretchpango_parse_stylepango_parse_variantpango_parse_weightpango_quantize_line_geometrypango_read_linepango_reorder_itemspango_scan_intpango_scan_stringpango_scan_wordpango_shapepango_shape_fullpango_skip_spacepango_split_file_listpango_trim_stringpango_unichar_directionpango_units_from_doublepango_units_to_doublepango_versionpango_version_checkpango_version_stringWake/// Creates a parker and an associated unparker./// let (p, u) = parking::pair();/// Waits for a notification./// Creates a new parker./// use parking::Parker;/// Blocks until notified and then goes back into unnotified state./// let u = p.unparker();/// // Notify the parker./// // Wakes up immediately because the parker is notified./// Blocks until notified and then goes back into unnotified state, or times out after/// `duration`./// Returns `true` if notified before the timeout./// // Wait for a notification, or time out after 500 ms./// Blocks until notified and then goes back into unnotified state, or times out at `instant`./// Returns `true` if notified before the deadline./// p.park_deadline(Instant::now() + Duration::from_millis(500));/// Notifies the parker./// Returns `true` if this call is the first to notify the parker, or `false` if the parker/// was already notified./// assert_eq!(p.unpark(), true);/// assert_eq!(p.unpark(), false);/// // Wakes up immediately./// Returns a handle for unparking./// The returned [`Unparker`] can be cloned and shared among threads./// Notifies a parker./// Notifies the associated parker./// // Wakes up when `u.unpark()` notifies and then goes back into unnotified state.will_unpark/// Indicates whether this unparker will unpark the associated parker./// This can be used to avoid unnecessary work before calling `unpark()`./// assert!(u.will_unpark(&p));same_parker/// Indicates whether two unparkers will unpark the same parker./// let u1 = p.unparker();/// let u2 = p.unparker();/// assert!(u1.same_parker(&u2));//! Thread parking and unparking.//! A parker is in either notified or unnotified state. Method [`park()`][`Parker::park()`] blocks//! the current thread until the parker becomes notified and then puts it back into unnotified//! state. Method [`unpark()`][`Unparker::unpark()`] puts it into notified state.//! use parking::Parker;//! let p = Parker::new();//! let u = p.unparker();//! // Notify the parker.//! u.unpark();//! // Wakes up immediately because the parker is notified.//! p.park();//!     thread::sleep(Duration::from_millis(500));//!     u.unpark();//! // Wakes up when `u.unpark()` notifies and then goes back into unnotified state.raw_mutexTOKEN_HANDOFFTOKEN_NORMALdeadlockRawMutex_ParkResultRequeueOpUnparkResultDEFAULT_PARK_TOKENWaitTimeoutResult/// A type indicating whether a timed wait on a condition variable returned/// due to a time out or not.timed_out/// Returns whether the wait was known to have timed out./// A Condition Variable/// Condition variables represent the ability to block a thread such that it/// consumes no CPU time while waiting for an event to occur. Condition/// variables are typically associated with a boolean predicate (a condition)/// and a mutex. The predicate is always verified inside of the mutex before/// determining that thread must block./// Note that this module places one additional restriction over the system/// condition variables: each condvar can be used with only one mutex at a/// time. Any attempt to use multiple mutexes on the same condition variable/// simultaneously will result in a runtime panic. However it is possible to/// switch to a different mutex if there are no threads currently waiting on/// the condition variable./// # Differences from the standard library `Condvar`/// - No spurious wakeups: A wait will only return a non-timeout result if it///   was woken up by `notify_one` or `notify_all`./// - `Condvar::notify_all` will only wake up a single thread, the rest are///   requeued to wait for the `Mutex` to be unlocked by the thread that was///   woken up./// - Only requires 1 word of space, whereas the standard library boxes the///   `Condvar` due to platform limitations./// - Can be statically constructed./// - Does not require any drop glue when dropped./// - Inline fast path for the uncontended case./// use parking_lot::{Mutex, Condvar};/// let pair = Arc::new((Mutex::new(false), Condvar::new()));/// let pair2 = pair.clone();/// // Inside of our lock, spawn a new thread, and then wait for it to start/// thread::spawn(move|| {///     let &(ref lock, ref cvar) = &*pair2;///     let mut started = lock.lock();///     *started = true;///     cvar.notify_one();/// // wait for the thread to start up/// let &(ref lock, ref cvar) = &*pair;/// let mut started = lock.lock();/// if !*started {///     cvar.wait(&mut started);/// // Note that we used an if instead of a while loop above. This is only/// // possible because parking_lot's Condvar will never spuriously wake up./// // This means that wait() will only return after notify_one or notify_all is/// // called./// Creates a new condition variable which is ready to be waited on and/// notified.notify_one/// Wakes up one blocked thread on this condvar./// Returns whether a thread was woken up./// If there is a blocked thread on this condition variable, then it will/// be woken up from its call to `wait` or `wait_timeout`. Calls to/// `notify_one` are not buffered in any way./// To wake up all threads, see `notify_all()`./// use parking_lot::Condvar;/// let condvar = Condvar::new();/// // do something with condvar, share it with other threads/// if !condvar.notify_one() {///     println!("Nobody was listening for this.");notify_one_slownotify_all/// Wakes up all blocked threads on this condvar./// Returns the number of threads woken up./// This method will ensure that any current waiters on the condition/// variable are awoken. Calls to `notify_all()` are not buffered in any/// way./// To wake up only one thread, see `notify_one()`.notify_all_slow/// Blocks the current thread until this condition variable receives a/// This function will atomically unlock the mutex specified (represented by/// `mutex_guard`) and block the current thread. This means that any calls/// to `notify_*()` which happen logically after the mutex is unlocked are/// candidates to wake this thread up. When this function call returns, the/// lock specified will have been re-acquired./// This function will panic if another thread is waiting on the `Condvar`/// with a different `Mutex` object./// Waits on this condition variable for a notification, timing out after/// the specified time instant./// The semantics of this function are equivalent to `wait()` except that/// the thread will be blocked roughly until `timeout` is reached. This/// method should not be used for precise timing due to anomalies such as/// preemption or platform differences that may not cause the maximum/// amount of time waited to be precisely `timeout`./// Note that the best effort is made to ensure that the time waited is/// measured with a monotonic clock, and not affected by the changes made to/// the system time./// The returned `WaitTimeoutResult` value indicates if the timeout is/// known to have elapsed./// Like `wait`, the lock specified will be re-acquired when this function/// returns, regardless of whether the timeout elapsed or not.wait_until_internal// This is a non-generic function to reduce the monomorphization cost of// using `wait_until`.wait_for/// Waits on this condition variable for a notification, timing out after a/// specified duration./// the thread will be blocked for roughly no longer than `timeout`. Thiswait_while_until_internalwait_while/// notification. If the provided condition evaluates to `false`, then the/// thread is no longer blocked and the operation is completed. If the/// condition evaluates to `true`, then the thread is blocked again and/// waits for another notification before repeating this process.wait_while_until/// the specified time instant. If the provided condition evaluates to/// `false`, then the thread is no longer blocked and the operation is/// completed. If the condition evaluates to `true`, then the thread is/// blocked again and waits for another notification before repeating/// this process.wait_while_for/// specified duration. If the provided condition evaluates to `false`,/// then the thread is no longer blocked and the operation is completed./// If the condition evaluates to `true`, then the thread is blocked again/// and waits for another notification before repeating this process.notify_one_return_truenotify_one_return_falsenotify_all_returnspawn_wait_while_notifierwait_while_until_internal_does_not_wait_if_initially_falsewait_while_until_internal_times_out_before_falsetwo_mutexestwo_mutexes_disjointtest_debug_condvartest_condvar_requeueNotifyStyleshould_continuerun_queue_testconsumer_threadproducer_threadrun_queue_testssanity_check_queuesanity_check_queue_timeoutnew_test_without_timeout_5one_producer_one_consumer_one_slotone_producer_one_consumer_one_slot_timeoutone_producer_one_consumer_hundred_slotsten_producers_one_consumer_one_slotten_producers_one_consumer_hundred_slots_notify_allten_producers_one_consumer_hundred_slots_notify_oneone_producer_ten_consumers_one_slotone_producer_ten_consumers_hundred_slots_notify_allone_producer_ten_consumers_hundred_slots_notify_oneten_producers_ten_consumers_one_slotten_producers_ten_consumers_hundred_slots_notify_allten_producers_ten_consumers_hundred_slots_notify_onewebkit_queue_test/// This module contains an integration test that is heavily inspired from WebKit's own integration/// tests for it's own Condvar.acquire_resourcerelease_resource//! \[Experimental\] Deadlock detection//! This feature is optional and can be enabled via the `deadlock_detection` feature flag.//! #[cfg(feature = "deadlock_detection")]//! { // only for #[cfg]//! use parking_lot::deadlock;//! // Create a background thread which checks for deadlocks every 10s//!         thread::sleep(Duration::from_secs(10));//!         let deadlocks = deadlock::check_deadlock();//!         if deadlocks.is_empty() {//!             continue;//!         println!("{} deadlocks detected", deadlocks.len());//!         for (i, threads) in deadlocks.iter().enumerate() {//!             println!("Deadlock #{}", i);//!             for t in threads {//!                 println!("Thread Id {:#?}", t.thread_id());//!                 println!("{:#?}", t.backtrace());//! } // only for #[cfg]IntTypeelision_compare_exchange_acquire// Perform a compare_exchange and start a transactionelision_fetch_sub_release// Perform a fetch_sub and end a transactionAtomicElisionExt// Extension trait to add lock elision primitives to atomic typeshave_elision// Indicates whether the target architecture supports lock elision// This implementation is never actually called because it is guarded by// have_elision().raw_fair_mutexRawFairMutex/// A mutual exclusive primitive that is always fair, useful for protecting shared data/// mutex can be statically initialized or created by the `new`/// The regular mutex provided by `parking_lot` uses eventual fairness/// (after some time it will default to the fair algorithm), but eventual/// fairness does not provide the same guarantees an always fair method would./// Fair mutexes are generally slower, but sometimes needed./// In a fair mutex the waiters form a queue, and the lock is always granted to/// the next requester in the queue, in first-in first-out order. This ensures/// that one thread cannot starve others by quickly re-acquiring the lock after/// releasing it./// A fair mutex may not be interesting if threads have different priorities (this is known as/// priority inversion)./// # Differences from the standard library `Mutex`/// - No poisoning, the lock is released normally on panic./// - Only requires 1 byte of space, whereas the standard library boxes the///   `FairMutex` due to platform limitations./// - Efficient handling of micro-contention using adaptive spinning./// - Allows raw locking & unlocking without a guard./// use parking_lot::FairMutex;/// use std::sync::{Arc, mpsc::channel};/// const N: usize = 10;/// // Spawn a few threads to increment a shared variable (non-atomically), and/// // let the main thread know once all increments are done./// // Here we're using an Arc to share memory among threads, and the data inside/// // the Arc is protected with a mutex./// let data = Arc::new(FairMutex::new(0));///     let (data, tx) = (Arc::clone(&data), tx.clone());///         // The shared state can only be accessed once the lock is held.///         // Our non-atomic increment is safe because we're the only thread///         // which can access the shared state when the lock is held.///         let mut data = data.lock();///         *data += 1;///         if *data == N {///             tx.send(()).unwrap();///         // the lock is unlocked here when `data` goes out of scope./// rx.recv().unwrap();const_fair_mutex/// Creates a new fair mutex in an unlocked state ready for use./// This allows creating a fair mutex in a constant context on stable Rust.FairMutexGuardMappedFairMutexGuard/// An RAII mutex guard returned by `FairMutexGuard::map`, which can point to a/// The main difference between `MappedFairMutexGuard` and `FairMutexGuard` is that theNonCopylots_and_lotstest_into_inner_droptest_get_muttest_mutex_arc_nestedtest_mutex_arc_access_in_unwindtest_mutex_unsizedtest_mutexguard_synctest_mutex_debugcondvarelisionfair_mutexraw_rwlockconst_mutexOnceStateconst_reentrant_mutexRawThreadIdconst_rwlock//! This library provides implementations of `Mutex`, `RwLock`, `Condvar` and//! `Once` that are smaller, faster and more flexible than those in the Rust//! standard library. It also provides a `ReentrantMutex` type./// A typical unfair lock can often end up in a situation where a single thread/// quickly acquires and releases the same mutex in succession, which can starve/// other threads waiting to acquire the mutex. While this improves throughput/// because it doesn't force a context switch when a thread tries to re-acquire/// a mutex it has just released, this can starve other threads./// This mutex uses [eventual fairness](https://trac.webkit.org/changeset/203350)/// to ensure that the lock will be fair on average without sacrificing/// throughput. This is done by forcing a fair unlock on average every 0.5ms,/// which will force the lock to go to the next thread waiting for the mutex./// Additionally, any critical section longer than 1ms will always use a fair/// unlock, which has a negligible impact on throughput considering the length/// of the critical section./// You can also force a fair unlock by calling `MutexGuard::unlock_fair` when/// unlocking a mutex instead of simply dropping the `MutexGuard`.///   `Mutex` due to platform limitations./// - Supports eventual fairness so that the mutex is fair on average./// - Optionally allows making the mutex fair by calling `MutexGuard::unlock_fair`./// use parking_lot::Mutex;/// let data = Arc::new(Mutex::new(0));test_mutex_arc_condvarUncheckedOptionExtDEFAULT_UNPARK_TOKENDONE_BITPOISON_BITLOCKED_BITPARKED_BIT/// A closure has not been executed yetPoisoned/// A closure was executed but panicked./// A thread is currently executing a closure./// A closure has completed successfully./// Current state of a `Once`./// Returns whether the associated `Once` has been poisoned./// Once an initialization routine for a `Once` has panicked it will forever/// indicate to future forced initialization routines that it is poisoned./// Returns whether the associated `Once` has successfully executed a/// A synchronization primitive which can be used to run a one-time/// initialization. Useful for one-time initialization for globals, FFI or/// related functionality./// # Differences from the standard library `Once`/// - Only requires 1 byte of space, instead of 1 word./// - Not required to be `'static`./// - Relaxed memory barriers in the fast path, which can significantly improve///   performance on some architectures./// use parking_lot::Once;/// static START: Once = Once::new();/// START.call_once(|| {///     // run initialization here/// Creates a new `Once` value./// Returns the current state of this `Once`./// Performs an initialization routine once and only once. The given closure/// will be executed if this is the first time `call_once` has been called,/// and otherwise the routine will *not* be invoked./// This method will block the calling thread if another initialization/// routine is currently running./// When this function returns, it is guaranteed that some initialization/// has run and completed (it may not be the closure specified). It is also/// guaranteed that any memory writes performed by the executed closure can/// be reliably observed by other threads at this point (there is a/// happens-before relation between the closure and code executing after the/// return)./// static mut VAL: usize = 0;/// static INIT: Once = Once::new();/// // Accessing a `static mut` is unsafe much of the time, but if we do so/// // in a synchronized fashion (e.g. write once or read all) then we're/// // good to go!/// // This function will only call `expensive_computation` once, and will/// // otherwise always return the value returned from the first invocation./// fn get_cached_val() -> usize {///         INIT.call_once(|| {///             VAL = expensive_computation();///         VAL/// fn expensive_computation() -> usize {/// # 2/// The closure `f` will only be executed once if this is called/// concurrently amongst many threads. If that closure panics, however, then/// it will *poison* this `Once` instance, causing all future invocations of/// `call_once` to also panic.call_once_force/// Performs the same function as `call_once` except ignores poisoning./// If this `Once` has been poisoned (some initialization panicked) then/// this function will continue to attempt to call initialization functions/// until one of them doesn't panic./// The closure `f` is yielded a structure which can be used to query the/// state of this `Once` (whether initialization has previously panicked or/// not).call_once_slow// using `call_once` (this isn't exactly a trivial or small implementation).// Additionally, this is tagged with `#[cold]` as it should indeed be cold// and it helps let LLVM know that calls to this function should be off the// fast path. Essentially, this should help generate more straight line code// in LLVM.// Finally, this takes an `FnMut` instead of a `FnOnce` because there's// currently no way to take an `FnOnce` and call it via virtual dispatch// without some allocation overhead.test_once_debug/// Raw fair mutex type backed by the parking lot.// UnparkToken used to indicate that that the target thread should attempt to// lock the mutex again as soon as it is unparked.// UnparkToken used to indicate that the mutex is being handed off to the target// thread directly without unlocking it./// This bit is set in the `state` of a `RawMutex` when that mutex is locked by some thread./// This bit is set in the `state` of a `RawMutex` just before parking a thread. A thread is being/// parked if it wants to lock the mutex, but it is currently being held by some other thread./// This atomic integer holds the current state of the mutex instance. Only the two lowest bits/// are used. See `LOCKED_BIT` and `PARKED_BIT` for the bitmask for these bits./// # State table:/// PARKED_BIT | LOCKED_BIT | Description///     0      |     0      | The mutex is not locked, nor is anyone waiting for it./// -----------+------------+------------------------------------------------------------------///     0      |     1      | The mutex is locked by exactly one thread. No other thread is///            |            | waiting for it.///     1      |     0      | The mutex is not locked. One or more thread is parked or about to///            |            | park. At least one of the parked threads are just about to be///            |            | unparked, or a thread heading for parking might abort the park.///     1      |     1      | The mutex is locked by exactly one thread. One or more thread is///            |            | parked or about to park, waiting for the lock to become available.///            |            | In this state, PARKED_BIT is only ever cleared when a bucket lock///            |            | is held (i.e. in a parking_lot_core callback). This ensures that///            |            | we never end up in a situation where there are parked threads but///            |            | PARKED_BIT is not set (which would result in those threads///            |            | potentially never getting woken up)./// Raw mutex type backed by the parking lot.mark_parked_if_locked// Used by Condvar when requeuing threads to us, must be called while// holding the queue lock.mark_parkedlock_slowunlock_slowbump_slowRawRwLock_// There is at least one thread in the main queue.WRITER_PARKED_BIT// There is a parked thread holding WRITER_BIT. WRITER_BIT must be set.UPGRADABLE_BIT// A reader is holding an upgradable lock. The reader count must be non-zero and// WRITER_BIT must not be set.// If the reader count is zero: a writer is currently holding an exclusive lock.// Otherwise: a writer is waiting for the remaining readers to exit the lock.READERS_MASK// Mask of bits used to count readers.// Base unit for counting readers.TOKEN_SHARED// Token indicating what type of lock a queued thread is trying to acquireTOKEN_EXCLUSIVETOKEN_UPGRADABLE/// Raw reader-writer lock type backed by the parking lot.try_lock_upgradable_fasttry_lock_upgradable_slowlock_upgradable_slowunlock_upgradable_slowtry_upgrade_slowupgrade_slowdowngrade_slowdowngrade_to_upgradable_slowbump_shared_slowbump_exclusive_slowbump_upgradable_slowwake_parked_threads/// Common code for waking up parked threads after releasing `WRITER_BIT` or/// `UPGRADABLE_BIT`./// `callback` must uphold the requirements of the `callback` parameter to/// `parking_lot_core::unpark_filter`. Meaning no panics or calls into any function in/// `parking_lot`.// Common code for waiting for readers to exit the lock after acquiring// WRITER_BIT.lock_common/// Common code for acquiring a lockdeadlock_acquiredeadlock_release// This reader-writer lock implementation is based on Boost's upgrade_mutex:// https://github.com/boostorg/thread/blob/fc08c1fe2840baeeee143440fba31ef9e9a813c8/include/boost/thread/v2/shared_mutex.hpp#L432// This implementation uses 2 wait queues, one at key [addr] and one at key// [addr + 1]. The primary queue is used for all new waiting threads, and the// secondary queue is used by the thread which has acquired WRITER_BIT but is// waiting for the remaining readers to exit the lock.// This implementation is fair between readers and writers since it uses the// order in which threads first started queuing to alternate between read phases// and write phases. In particular is it not vulnerable to write starvation// since readers will block if there is a pending writer./// Implementation of the `GetThreadId` trait for `lock_api::ReentrantMutex`./// This allows creating a reentrant mutex in a constant context on stable Rust.is_mutextrylock_workstest_reentrant_mutex_debugtest_reentrant_mutex_bump/// This lock uses a task-fair locking policy which avoids both reader and/// writer starvation. This means that readers trying to acquire the lock will/// block even if the lock is unlocked when there are writers waiting to acquire/// the lock. Because of this, attempts to recursively acquire a read lock/// within a single thread may result in a deadlock./// quickly acquires and releases the same lock in succession, which can starve/// other threads waiting to acquire the rwlock. While this improves throughput/// a rwlock it has just released, this can starve other threads./// This rwlock uses [eventual fairness](https://trac.webkit.org/changeset/203350)/// which will force the lock to go to the next thread waiting for the rwlock./// You can also force a fair unlock by calling `RwLockReadGuard::unlock_fair`/// or `RwLockWriteGuard::unlock_fair` when unlocking a mutex instead of simply/// dropping the guard./// # Differences from the standard library `RwLock`/// - Supports atomically downgrading a write lock into a read lock./// - Task-fair locking policy instead of an unspecified platform default.///   `RwLock` due to platform limitations./// - Supports eventual fairness so that the rwlock is fair on average./// - Optionally allows making the rwlock fair by calling///   `RwLockReadGuard::unlock_fair` and `RwLockWriteGuard::unlock_fair`./// use parking_lot::RwLock;/// // many reader locks can be held at once///     let r1 = lock.read();///     let r2 = lock.read();/// } // read locks are dropped at this point/// // only one write lock may be held, however///     let mut w = lock.write();/// } // write lock is dropped here/// This allows creating a `RwLock<T>` in a constant context on stable Rust.frobtest_rw_arc_no_poison_wrtest_rw_arc_no_poison_wwtest_rw_arc_no_poison_rrtest_rw_arc_no_poison_rwtest_ruw_arctest_rw_arctest_rw_arc_access_in_unwindtest_rwlock_unsizedtest_rwlock_try_readtest_rwlock_try_writetest_rwlock_try_upgradetest_rwlockguard_synctest_rwlock_downgradetest_rwlock_recursivetest_rwlock_debugtest_issue_203test_rw_write_is_lockedunchecked_unwrap// Option::unchecked_unwrap// hint::unreachable_unchecked() in release modeto_deadline// Automatically detect tsan in a way that's compatible with both stable (which// doesn't support sanitizers) and nightly (which does). Works because build// scripts gets `cfg` info, even if the cfg is unstable.spinwaitthread_parkerword_lockunpark_allunpark_filterunpark_requeue//! This library exposes a low-level API for creating your own efficient//! synchronization primitives.//! # The parking lot//! To keep synchronization primitives small, all thread queuing and suspending//! functionality is offloaded to the *parking lot*. The idea behind this is based//! on the Webkit [`WTF::ParkingLot`](https://webkit.org/blog/6161/locking-in-webkit/)//! class, which essentially consists of a hash table mapping of lock addresses//! to queues of parked (sleeping) threads. The Webkit parking lot was itself//! inspired by Linux [futexes](http://man7.org/linux/man-pages/man2/futex.2.html),//! but it is more powerful since it allows invoking callbacks while holding a//! queue lock.//! There are two main operations that can be performed on the parking lot://!  - *Parking* refers to suspending the thread while simultaneously enqueuing it//! on a queue keyed by some address.//! - *Unparking* refers to dequeuing a thread from a queue keyed by some address//! and resuming it.//! See the documentation of the individual functions for more details.//! # Building custom synchronization primitives//! Building custom synchronization primitives is very simple since the parking//! lot takes care of all the hard parts for you. A simple example for a//! custom primitive would be to integrate a `Mutex` inside another data type.//! Since a mutex only requires 2 bits, it can share space with other data.//! For example, one could create an `ArcMutex` type that combines the atomic//! reference count and the two mutex bits in the same atomic word.ThreadParkerThreadParkerTUnparkHandleTWordLockTimeoutInstant// Don't use Instant on wasm32-unknown-unknown, it just panics.HASHTABLE/// Holds the pointer to the currently active `HashTable`./// Except for the initial value of null, it must always point to a valid `HashTable` instance./// Any `HashTable` this global static has ever pointed to must never be freed.LOAD_FACTOR// Even with 3x more buckets than threads, the memory overhead per thread is// still only a few hundred bytes per thread.// Hash buckets for the tablehash_bits// Number of bits used for the hash function_prev// Previous table. This is only kept to keep leak detectors happy.// Lock protecting the queuequeue_headThreadData// Linked list of threads waiting on this bucketqueue_tailfair_timeoutFairTimeout// Next time at which point be_fair should be set// the PRNG state for calculating the next timeoutshould_timeout// Determine whether we should force a fair unlock, and update the timeout// Pseudorandom number generator from the "Xorshift RNGs" paper by George Marsaglia.// Key that this thread is sleeping on. This may change if the thread is// requeued to a different key.next_in_queue// Linked list of parked threads in a bucketunpark_token// UnparkToken passed to this thread when it is unparkedpark_token// ParkToken value set by the thread when it was parkedparked_with_timeout// Is the thread parked with a timeout?with_thread_data// Invokes the given closure with a reference to the current thread `ThreadData`.get_hashtable/// Returns a reference to the latest hash table, creating one if it doesn't exist yet./// The reference is valid forever. However, the `HashTable` it references might become stale/// at any point. Meaning it still exists, but it is not the instance in active use.create_hashtablegrow_hashtable// Grow the hash table so that it is big enough for the given number of threads.// This isn't performance-critical since it is only done when a ThreadData is// created, which only happens once per thread.rehash_bucket_into/// Iterate through all `ThreadData` objects in the bucket and insert them into the given table/// in the bucket their key correspond to for this table./// The given `bucket` must have a correctly constructed linked list under `queue_head`, containing/// `ThreadData` instances that must stay valid at least as long as the given `table` is in use./// The given `table` must only contain buckets with correctly constructed linked lists.lock_bucket/// Locks the bucket for the given key and returns a reference to it./// The returned bucket must be unlocked again in order to not cause deadlocks.lock_bucket_checked/// Locks the bucket for the given key and returns a reference to it. But checks that the key/// hasn't been changed in the meantime due to a requeue.lock_bucket_pair/// Locks the two buckets for the given pair of keys and returns references to them./// The returned buckets must be unlocked again in order to not cause deadlocks./// If both keys hash to the same value, both returned references will be to the same bucket. Be/// careful to only unlock it once in this case, always use `unlock_bucket_pair`.unlock_bucket_pair/// Unlock a pair of buckets/// Both buckets must be lockedUnparked/// We were unparked by another thread with the given token./// The validation callback returned false./// The timeout expired./// Result of a park operation.is_unparked/// Returns true if we were unparked by another thread.unparked_threads/// The number of threads that were unparked.requeued_threads/// The number of threads that were requeued.have_more_threads/// Whether there are any threads remaining in the queue. This only returns/// true if a thread was unparked.be_fair/// This is set to true on average once every 0.5ms for any given key. It/// should be used to switch to a fair unlocking mechanism for a particular/// unlock._sealed/// Private field so new fields can be added without breakage./// Result of an unpark operation./// Abort the operation without doing anything.UnparkOneRequeueRest/// Unpark one thread and requeue the rest onto the target queue.RequeueAll/// Requeue all threads onto the target queue.UnparkOne/// Unpark one thread and leave the rest parked. No requeuing is done.RequeueOne/// Requeue one thread and leave the rest parked on the original queue./// Operation that `unpark_requeue` should perform.Unpark/// Unpark the thread and continue scanning the list of parked threads./// Don't unpark the thread and continue scanning the list of parked threads./// Don't unpark the thread and stop scanning the list of parked threads./// Operation that `unpark_filter` should perform for each thread./// A value which is passed from an unparker to a parked thread./// A value associated with a parked thread which can be used by `unpark_filter`./// A default unpark token to use./// A default park token to use./// Parks the current thread in the queue associated with the given key./// The `validate` function is called while the queue is locked and can abort/// the operation by returning false. If `validate` returns true then the/// current thread is appended to the queue and the queue is unlocked./// The `before_sleep` function is called after the queue is unlocked but before/// the thread is put to sleep. The thread will then sleep until it is unparked/// or the given timeout is reached./// The `timed_out` function is also called while the queue is locked, but only/// if the timeout was reached. It is passed the key of the queue it was in when/// it timed out, which may be different from the original key if/// `unpark_requeue` was called. It is also passed a bool which indicates/// whether it was the last thread in the queue./// You should only call this function with an address that you control, since/// you could otherwise interfere with the operation of other synchronization/// primitives./// The `validate` and `timed_out` functions are called while the queue is/// locked and must not panic or call into any function in `parking_lot`./// The `before_sleep` function is called outside the queue lock and is allowed/// to call `unpark_one`, `unpark_all`, `unpark_requeue` or `unpark_filter`, but/// it is not allowed to call `park` or panic./// Unparks one thread from the queue associated with the given key./// The `callback` function is called while the queue is locked and before the/// target thread is woken up. The `UnparkResult` argument to the function/// indicates whether a thread was found in the queue and whether this was the/// last thread in the queue. This value is also returned by `unpark_one`./// The `callback` function should return an `UnparkToken` value which will be/// passed to the thread that is unparked. If no thread is unparked then the/// returned value is ignored./// The `callback` function is called while the queue is locked and must not/// panic or call into any function in `parking_lot`./// The `parking_lot` functions are not re-entrant and calling this method/// from the context of an asynchronous signal handler may result in undefined/// behavior, including corruption of internal state and/or deadlocks./// Unparks all threads in the queue associated with the given key./// The given `UnparkToken` is passed to all unparked threads./// This function returns the number of threads that were unparked./// Removes all threads from the queue associated with `key_from`, optionally/// unparks the first one and requeues the rest onto the queue associated with/// `key_to`./// The `validate` function is called while both queues are locked. Its return/// value will determine which operation is performed, or whether the operation/// should be aborted. See `RequeueOp` for details about the different possible/// return values./// The `callback` function is also called while both queues are locked. It is/// passed the `RequeueOp` returned by `validate` and an `UnparkResult`/// indicating whether a thread was unparked and whether there are threads still/// parked in the new queue. This `UnparkResult` value is also returned by/// `unpark_requeue`./// The `validate` and `callback` functions are called while the queue is locked/// and must not panic or call into any function in `parking_lot`./// Unparks a number of threads from the front of the queue associated with/// `key` depending on the results of a filter function which inspects the/// `ParkToken` associated with each thread./// The `filter` function is called for each thread in the queue or until/// `FilterOp::Stop` is returned. This function is passed the `ParkToken`/// associated with a particular thread, which is unparked if `FilterOp::Unpark`/// passed an `UnparkResult` indicating the number of threads that were unparked/// and whether there are still parked threads in the queue. This `UnparkResult`/// value is also returned by `unpark_filter`./// passed to all threads that are unparked. If no thread is unparked then the/// The `filter` and `callback` functions are called while the queue is locked/// Acquire a resource identified by key in the deadlock detector/// Noop if `deadlock_detection` feature isn't enabled./// Call after the resource is acquired/// Release a resource identified by key in the deadlock detector./// Panics if the resource was already released or wasn't acquired in this thread./// Call before the resource is releasedon_unpark/// \[Experimental\] Deadlock detection/// Enabled via the `deadlock_detection` feature flag./// Calls a closure for every `ThreadData` currently parked on a given keyunpark_all_one_fastunpark_all_hundred_fastunpark_one_one_fastunpark_one_hundred_fastunpark_one_fifty_then_fifty_all_fastunpark_all_oneunpark_all_hundredunpark_one_oneunpark_one_fiftyunpark_one_fifty_then_fifty_allhundred_unpark_all_one_fasthundred_unpark_all_onerun_parking_testnum_awakelast_awoken/// Holds the pointer to the last *unprocessed* woken up thread./// Total number of threads participating in this test.SingleLatchTestsemaphore_addrcpu_relax// Wastes some CPU time for the given number of iterations,// using a hint to indicate to the CPU that we are spinning./// A counter used to perform exponential backoff in spin loops./// Creates a new `SpinWait`./// Resets a `SpinWait` to its initial state./// Spins until the sleep threshold has been reached./// This function returns whether the sleep threshold has been reached, at/// which point further spinning has diminishing returns and the thread/// should be parked instead./// The spin strategy will initially use a CPU-bound loop but will fall back/// to yielding the CPU to the OS after a few iterations.spin_no_yield/// Spins without yielding the thread to the OS./// Instead, the backoff is simply capped at a maximum value. This can be/// used to improve throughput in `compare_exchange` loops that have highparked// Helper type for putting a thread to sleep until some other thread wakes it upUnparkHandleIS_CHEAP_TO_CONSTRUCTprepare_parkpark_untilunpark_lockthread_yield//! A simple spin lock based thread parker. Used on platforms without better//! parking facilities available.tv_nsec_t// Locks the parker to prevent the target thread from exiting. This is// necessary to ensure that thread-local ThreadData objects remain valid.// This should be called while holding the queue lock./// Prepares the parker. This should be called before adding it to the queue./// Checks if the park timed out. This should be called while holding the/// queue lock after `park_until` has returned false./// Parks the thread until it is unparked. This should be called after it has/// been added to the queue, after unlocking the queue./// Parks the thread until it is unparked or the timeout is reached. This/// should be called after it has been added to the queue, after unlocking/// the queue. Returns true if we were unparked and false if we timed out./// Locks the parker to prevent the target thread from exiting. This is/// necessary to ensure that thread-local `ThreadData` objects remain valid./// This should be called while holding the queue lock./// Trait for the platform thread parker implementation./// All unsafe methods are unsafe because the Unix thread parker is based on/// pthread mutexes and condvars. Those primitives must not be moved and used/// from any other memory address than the one they were located at when they/// were initialized. As such, it's UB to call any unsafe method on/// `ThreadParkerT` if the implementing instance has moved since the last/// call to any of the unsafe methods./// Wakes up the parked thread. This should be called after the queue lock is/// released to avoid blocking the queue for too long./// This method is unsafe for the same reason as the unsafe methods in/// `ThreadParkerT`./// Handle for a thread that is about to be unparked. We need to mark the thread/// as unparked while holding the queue lock, but we delay the actual unparking/// until after the queue lock is released.UNPARKEDfortanix_sgxcurrent_tcsusercallsTcsEV_UNPARKWAIT_INDEFINITEtcs// x32 Linux uses a non-standard type for tv_nsec in timespec.// See https://sourceware.org/bugzilla/show_bug.cgi?id=16437should_park/// Initializes the condvar to use CLOCK_MONOTONIC instead of CLOCK_REALTIME.timespec_now// Returns the current time on the clock used by pthread_cond_t as a timespec.timeout_to_timespec// Converts a relative timeout into an absolute timeout in the clock used by// pthread_cond_t.//! The wasm platform can't park when atomic support is not available.//! So this ThreadParker just panics on any attempt to park.ERROR_TIMEOUTGENERIC_READGENERIC_WRITESTATUS_TIMEOUTWaitOnAddressWakeByAddressSingle//! Manual bindings to the win32 API to avoid dependencies on windows-sys or winapi//! as these bindings will **never** change and `parking_lot_core` is a foundational//! dependency for the Rust ecosystem, so the dependencies used by it have an//! outsize affectSTATE_UNPARKEDSTATE_PARKEDSTATE_TIMED_OUTbindingsNtReleaseKeyedEventNtWaitForKeyedEventKeyedEventkeyed_event// Handle for a thread that is about to be unparked. We need to mark the thread// as unparked while holding the queue lock, but we delay the actual unparking// until after the queue lock is released.// Wakes up the parked thread. This should be called after the queue lock is// released to avoid blocking the queue for too long.waitaddressWaitAddressBACKEND// Prepares the parker. This should be called before adding it to the queue.// Checks if the park timed out. This should be called while holding the// queue lock after park_until has returned false.// Parks the thread until it is unparked. This should be called after it has// been added to the queue, after unlocking the queue.// Parks the thread until it is unparked or the timeout is reached. This// should be called after it has been added to the queue, after unlocking// the queue. Returns true if we were unparked and false if we timed out.// Yields the rest of the current timeslice to the OSwait_on_address// Linked list of threads in the queue. The queue is split into two parts:// the processed part and the unprocessed part. When new nodes are added to// the list, they only have the next pointer set, and queue_tail is null.// Nodes are processed with the queue lock held, which consists of setting// the prev pointer for each node and setting the queue_tail pointer on the// first processed node of the list.// This setup allows nodes to be added to the queue without a lock, while// still allowing O(1) removal of nodes from the processed part of the list.// The only cost is the O(n) processing, but this only needs to be done// once for each node, and therefore isn't too expensive.QUEUE_LOCKED_BITQUEUE_MASK// Word-sized lock that is used to implement the parking_lot API. Since this// can't use parking_lot, it instead manages its own queue of waiting threads./// Returns a new, unlocked, `WordLock`./// Must not be called on an already unlocked `WordLock`!fence_acquire// Thread-Sanitizer only has partial fence support, so when running under it, we// try and avoid false positives by using a discarded acquire load instead.is_queue_lockedwith_queue_headLockStateB64B64Error/// "B64" encoding: standard Base64 without padding./// <https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#b64>Bcrypt/// bcrypt encoding.Crypt/// `crypt(3)` encoding./// Base64 encoding variants.//! Base64 encoding variants./// Unsupported algorithm.B64Encoding/// "B64" encoding error.Crypto/// Cryptographic error.OutputTooShort/// Output too short (min 10-bytes).OutputTooLong/// Output too long (max 64-bytes).ParamNameDuplicated/// Duplicate parameter name encountered.ParamNameInvalid/// Invalid parameter name.ParamValueInvalid/// Invalid parameter value.ParamsMaxExceeded/// Maximum number of parameters exceeded./// Invalid password.PhcStringInvalid/// Password hash string contains invalid characters.PhcStringTooShort/// Password hash string too short.PhcStringTooLong/// Password hash string too long.SaltInvalid/// Salt invalid./// Invalid algorithm version./// Password hashing errors.InvalidChar/// Character is not in the allowed set./// Format is invalid.Malformed/// Value is malformed./// Value exceeds the maximum allowed length./// Value does not satisfy the minimum length./// Parse errors relating to invalid parameter values or salts.param_error/// Create an [`Error::ParamValueInvalid`] which warps this error.salt_error/// Create an [`Error::SaltInvalid`] which wraps this error./// Algorithm or parameter identifier./// This type encompasses both the "function symbolic name" and "parameter name"/// use cases as described in the [PHC string format specification][1]./// # Constraints/// - ASCII-encoded string consisting of the characters `[a-z0-9-]`///   (lowercase letters, digits, and the minus sign)/// - Minimum length: 1 ASCII character (i.e. 1-byte)/// - Maximum length: 32 ASCII characters (i.e. 32-bytes)/// [1]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.mdMAX_LENGTH/// Maximum length of an [`Ident`] - 32 ASCII characters (i.e. 32-bytes)./// This value corresponds to the maximum size of a function symbolic names/// and parameter names according to the PHC string format./// Parse an [`Ident`] from a string./// String must conform to the constraints given in the type-level/// Parse an [`Ident`] from a string, panicking on parse errors./// be bound to a constant value./// Borrow this ident as a `str`// Note: this uses `TryFrom` instead of `FromStr` to support a lifetime on// the `str` the value is being parsed from.INVALID_EMPTY// Invalid ident examplesINVALID_CHARINVALID_TOO_LONGINVALID_CHAR_AND_TOO_LONGparse_validreject_emptyreject_invalidreject_too_longreject_invalid_char_and_too_long//! Algorithm or parameter identifier.//! Implements the following parts of the [PHC string format specification][1]://! > The function symbolic name is a sequence of characters in: `[a-z0-9-]`//! > (lowercase letters, digits, and the minus sign). No other character is//! > allowed. Each function defines its own identifier (or identifiers in case//! > of a function family); identifiers should be explicit (human readable,//! > not a single digit), with a length of about 5 to 10 characters. An//! > identifier name MUST NOT exceed 32 characters in length.//! > Each parameter name shall be a sequence of characters in: `[a-z0-9-]`//! > allowed. Parameter names SHOULD be readable for a human user. A//! > parameter name MUST NOT exceed 32 characters in length.//! [1]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.mdParamsStringSaltSaltStringMcfHasherPasswordHasherPasswordVerifierPASSWORD_HASH_SEPARATOR/// Separator character used in password hashes (e.g. `$6$...`)./// Password hashing algorithm identifier./// This corresponds to the `<id>` field in a PHC string, a.k.a. the/// symbolic name for the function./// Optional version field./// This corresponds to the `<version>` field in a PHC string./// Algorithm-specific parameters./// This corresponds to the set of `$<param>=<value>(,<param>=<value>)*`/// name/value pairs in a PHC string./// [`Salt`] string for personalizing a password hash output./// This corresponds to the `<salt>` value in a PHC string./// Password hashing function [`Output`], a.k.a. hash/digest./// This corresponds to the `<hash>` output in a PHC string.PasswordHash/// Password hash./// This type corresponds to the parsed representation of a PHC string as/// described in the [PHC string format specification][1]./// PHC strings have the following format:/// $<id>[$v=<version>][$<param>=<value>(,<param>=<value>)*][$<salt>[$<hash>]]/// where:/// - `<id>` is the symbolic name for the function/// - `<version>` is the algorithm version/// - `<param>` is a parameter name/// - `<value>` is a parameter value/// - `<salt>` is an encoding of the salt/// - `<hash>` is an encoding of the hash output/// The string is then the concatenation, in that order, of:/// - a `$` sign;/// - the function symbolic name;/// - optionally, a `$` sign followed by the algorithm version with a `v=version` format;/// - optionally, a `$` sign followed by one or several parameters, each with a `name=value` format;///   the parameters are separated by commas;/// - optionally, a `$` sign followed by the (encoded) salt value;/// - optionally, a `$` sign followed by the (encoded) hash output (the hash output may be present///   only if the salt is present)./// [1]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#specification/// Parse a password hash from a string in the PHC string format./// Parse a password hash from the given [`Encoding`]./// Generate a password hash using the supplied algorithm.verify_password/// Verify this password hash using the specified set of supported/// [`PasswordHasher`] trait objects./// Get the [`Encoding`] that this [`PasswordHash`] is serialized with.//! This crate represents password hashes using the [`PasswordHash`] type, which//! represents a parsed "PHC string" with the following format://! $<id>[$v=<version>][$<param>=<value>(,<param>=<value>)*][$<salt>[$<hash>]]//! For more information, please see the documentation for [`PasswordHash`]./// Byte array containing a password hashing function output./// Length of the password hashing function output in bytes./// Encoding which output should be serialized with./// Output from password hashing functions, i.e. the "hash" or "digest"/// as raw bytes./// The [`Output`] type implements the RECOMMENDED best practices described in/// the [PHC string format specification][1], namely:/// > The hash output, for a verification, must be long enough to make preimage/// > attacks at least as hard as password guessing. To promote wide acceptance,/// > a default output size of 256 bits (32 bytes, encoded as 43 characters) is/// > recommended. Function implementations SHOULD NOT allow outputs of less/// > than 80 bits to be used for password verification./// # Recommended length/// Per the description above, the recommended default length for an [`Output`]/// of a password hashing function is **32-bytes** (256-bits)./// The above guidelines are interpreted into the following constraints:/// - Minimum length: **10**-bytes (80-bits)/// - Maximum length: **64**-bytes (512-bits)/// The specific recommendation of a 64-byte maximum length is taken as a best/// practice from the hash output guidelines for [Argon2 Encoding][2] given in/// the same document:/// > The hash output...length shall be between 12 and 64 bytes (16 and 86/// > characters, respectively). The default output length is 32 bytes/// > (43 characters)./// Based on this guidance, this type enforces an upper bound of 64-bytes/// as a reasonable maximum, and recommends using 32-bytes./// # Constant-time comparisons/// The [`Output`] type impls the [`ConstantTimeEq`] trait from the [`subtle`]/// crate and uses it to perform constant-time comparisons./// Additionally the [`PartialEq`] and [`Eq`] trait impls for [`Output`] use/// [`ConstantTimeEq`] when performing comparisons./// ## Attacks on non-constant-time password hash comparisons/// Comparing password hashes in constant-time is known to mitigate at least/// one [poorly understood attack][3] involving an adversary with the following/// knowledge/capabilities:/// - full knowledge of what password hashing algorithm is being used///   including any relevant configurable parameters/// - knowledge of the salt for a particular victim/// - ability to accurately measure a timing side-channel on comparisons///   of the password hash over the network/// An attacker with the above is able to perform an offline computation of/// the hash for any chosen password in such a way that it will match the/// hash computed by the server./// As noted above, they also measure timing variability in the server's/// comparison of the hash it computes for a given password and a target hash/// the attacker is trying to learn./// When the attacker observes a hash comparison that takes longer than their/// previous attempts, they learn that they guessed another byte in the/// password hash correctly. They can leverage repeated measurements and/// observations with different candidate passwords to learn the password/// hash a byte-at-a-time in a manner similar to other such timing side-channel/// attacks./// The attack may seem somewhat counterintuitive since learning prefixes of a/// password hash does not reveal any additional information about the password/// itself. However, the above can be combined with an offline dictionary/// attack where the attacker is able to determine candidate passwords to send/// to the server by performing a brute force search offline and selecting/// candidate passwords whose hashes match the portion of the prefix they have/// learned so far./// As the attacker learns a longer and longer prefix of the password hash,/// they are able to more effectively eliminate candidate passwords offline as/// part of a dictionary attack, until they eventually guess the correct/// password or exhaust their set of candidate passwords./// ## Mitigations/// While we have taken care to ensure password hashes are compared in constant/// time, we would also suggest preventing such attacks by using randomly/// generated salts and keeping those salts secret./// The [`SaltString::generate`][`crate::SaltString::generate`] function can be/// used to generate random high-entropy salt values./// [1]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#function-duties/// [2]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#argon2-encoding/// [3]: https://web.archive.org/web/20130208100210/http://security-assessment.com/files/documents/presentations/TimingAttackPresentation2012.pdfMIN_LENGTH/// Minimum length of a [`Output`] string: 10-bytes./// Maximum length of [`Output`] string: 64-bytes./// See type-level documentation about [`Output`] for more information.B64_MAX_LENGTH/// Maximum length of [`Output`] when encoded as B64 string: 86-bytes/// (i.e. 86 ASCII characters)/// Create a [`Output`] from the given byte slice, validating it according/// to [`Output::MIN_LENGTH`] and [`Output::MAX_LENGTH`] restrictions.new_with_encoding/// Create a [`Output`] from the given byte slice and [`Encoding`],/// validating it according to [`Output::MIN_LENGTH`] and/// [`Output::MAX_LENGTH`] restrictions.init_with/// Initialize an [`Output`] using the provided method, which is given/// a mutable byte slice into which it should write the output./// The `output_size` (in bytes) must be known in advance, as well as at/// least [`Output::MIN_LENGTH`] bytes and at most [`Output::MAX_LENGTH`]/// Borrow the output value as a byte slice./// Get the [`Encoding`] that this [`Output`] is serialized with./// Get the length of the output value as a byte slice.b64_decode/// Parse B64-encoded [`Output`], i.e. using the PHC string/// specification's restricted interpretation of Base64.b64_encode/// Write B64-encoded [`Output`] to the provided buffer, returning/// a sub-slice containing the encoded data./// Returns an error if the buffer is too short to contain the output./// Decode the given input string using the specified [`Encoding`]./// Encode this [`Output`] using the specified [`Encoding`]./// Get the length of this [`Output`] when encoded as B64.new_with_valid_min_length_inputnew_with_valid_max_length_inputreject_new_too_shortreject_new_too_longpartialeq_truepartialeq_false//! Outputs from password hashing functions./// Individual parameter name/value pair.PAIR_DELIMITER/// Delimiter character between name/value pairs.PARAMS_DELIMITER/// Delimiter character between parameters./// Maximum number of supported parameters.INVARIANT_VIOLATED_MSG/// Error message used with `expect` for when internal invariants are violated/// (i.e. the contents of a [`ParamsString`] should always be valid)/// Algorithm parameter string./// The [PHC string format specification][1] defines a set of optional/// algorithm-specific name/value pairs which can be encoded into a/// PHC-formatted parameter string as follows:/// $<param>=<value>(,<param>=<value>)*/// This type represents that set of parameters./// Create new empty [`ParamsString`].add_b64_bytes/// Add the given byte value to the [`ParamsString`], encoding it as "B64".add_decimal/// Add a key/value pair with a decimal value to the [`ParamsString`].add_str/// Add a key/value pair with a string value to the [`ParamsString`]./// Borrow the contents of this [`ParamsString`] as a byte slice./// Borrow the contents of this [`ParamsString`] as a `str`./// Get the count of the number ASCII characters in this [`ParamsString`]./// Is this set of parameters empty?/// Iterate over the parameters./// Get a parameter [`Value`] by name./// Get a parameter as a `str`.get_decimal/// Get a parameter as a [`Decimal`]./// See [`Value::decimal`] for format information./// Add a value to this [`ParamsString`] using the provided callback./// Iterator over algorithm parameters stored in a [`ParamsString`] struct./// Create a new [`Iter`]./// Byte array containing an ASCII-encoded string./// Length of the string in ASCII characters (i.e. bytes)./// Parameter buffer.duplicate_namesparse_emptyparse_many// `FromStr` tests// `Display` tests//! Algorithm parameters./// (i.e. the contents of a [`Salt`] should always be valid)/// Salt string./// In password hashing, a "salt" is an additional value used to/// personalize/tweak the output of a password hashing function for a given/// input password./// Salts help defend against attacks based on precomputed tables of hashed/// passwords, i.e. "[rainbow tables][1]"./// The [`Salt`] type implements the RECOMMENDED best practices for salts/// described in the [PHC string format specification][2], namely:/// > - Maximum lengths for salt, output and parameter values are meant to help/// >   consumer implementations, in particular written in C and using/// >   stack-allocated buffers. These buffers must account for the worst case,/// >   i.e. the maximum defined length. Therefore, keep these lengths low./// > - The role of salts is to achieve uniqueness. A random salt is fine for/// >   that as long as its length is sufficient; a 16-byte salt would work well/// >   (by definition, UUID are very good salts, and they encode over exactly/// >   16 bytes). 16 bytes encode as 22 characters in B64. Functions should/// >   disallow salt values that are too small for security (4 bytes should be/// >   viewed as an absolute minimum)./// The recommended default length for a salt string is **16-bytes** (128-bits)./// See [`Salt::RECOMMENDED_LENGTH`] for more information./// Salt strings are constrained to the following set of characters per the/// PHC spec:/// > The salt consists in a sequence of characters in: `[a-zA-Z0-9/+.-]`/// > (lowercase letters, uppercase letters, digits, /, +, . and -)./// Additionally the following length restrictions are enforced based on the/// guidelines from the spec:/// - Minimum length: **4**-bytes/// - Maximum length: **64**-bytes/// A maximum length is enforced based on the above recommendation for/// supporting stack-allocated buffers (which this library uses), and the/// specific determination of 64-bytes is taken as a best practice from the/// [Argon2 Encoding][3] specification in the same document:/// > The length in bytes of the salt is between 8 and 64 bytes<sup>†</sup>, thus/// > yielding a length in characters between 11 and 64 characters (and that/// > length is never equal to 1 modulo 4). The default byte length of the salt/// > is 16 bytes (22 characters in B64 encoding). An encoded UUID, or a/// > sequence of 16 bytes produced with a cryptographically strong PRNG, are/// > appropriate salt values./// > <sup>†</sup>The Argon2 specification states that the salt can be much longer, up/// > to 2^32-1 bytes, but this makes little sense for password hashing./// > Specifying a relatively small maximum length allows for parsing with a/// > stack allocated buffer.)/// as a reasonable maximum, and recommends using 16-bytes./// [1]: https://en.wikipedia.org/wiki/Rainbow_table/// [2]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#function-duties/// [3]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#argon2-encoding/// Minimum length of a [`Salt`] string: 4-bytes./// Maximum length of a [`Salt`] string: 64-bytes./// See type-level documentation about [`Salt`] for more information.RECOMMENDED_LENGTH/// Recommended length of a salt: 16-bytes./// This recommendation comes from the [PHC string format specification]:/// > The role of salts is to achieve uniqueness. A *random* salt is fine/// > for that as long as its length is sufficient; a 16-byte salt would/// > work well (by definition, UUID are very good salts, and they encode/// > over exactly 16 bytes). 16 bytes encode as 22 characters in B64./// [PHC string format specification]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#function-duties/// Create a [`Salt`] from the given `str`, validating it according to/// [`Salt::MIN_LENGTH`] and [`Salt::MAX_LENGTH`] length restrictions./// Attempt to decode a B64-encoded [`Salt`], writing the decoded result/// into the provided buffer, and returning a slice of the buffer/// containing the decoded result on success./// [1]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#argon2-encoding/// Borrow this value as a `str`./// Borrow this value as bytes./// Get the length of this value in ASCII characters./// Byte array containing an ASCiI-encoded string./// Owned stack-allocated equivalent of [`Salt`]./// Generate a random B64-encoded [`SaltString`]./// Create a new [`SaltString`]./// Encode the given byte slice as B64 into a new [`SaltString`]./// Returns `None` if the slice is too long./// Decode this [`SaltString`] from B64 into the provided output buffer.as_salt/// Borrow the contents of a [`SaltString`] as a [`Salt`]./// Borrow the contents of a [`SaltString`] as a `str`.reject_new_invalid_char//! Salt string support.hash_password_customized/// Compute a [`PasswordHash`] from the provided password using an/// explicit set of customized algorithm parameters as opposed to the/// defaults./// When in doubt, use [`PasswordHasher::hash_password`] instead.hash_password/// Simple API for computing a [`PasswordHash`] from a password and/// salt value./// Uses the default recommended parameters for a given algorithm./// Trait for password hashing functions./// Compute this password hashing function against the provided password/// using the parameters from the provided password hash and see if the/// computed output matches./// Trait for password verification./// Automatically impl'd for any type that impls [`PasswordHasher`]./// This trait is object safe and can be used to implement abstractions over/// multiple password hashing algorithms. One such abstraction is provided by/// the [`PasswordHash::verify_password`] method.upgrade_mcf_hash/// Upgrade an MCF hash to a PHC hash. MCF follow this rough format:/// $<id>$<content>/// MCF hashes are otherwise largely unstructured and parsed according to/// algorithm-specific rules so hashers must parse a raw string themselves.verify_mcf_hash/// Verify a password hash in MCF format against the provided password./// Trait for password hashing algorithms which support the legacy/// [Modular Crypt Format (MCF)][MCF]./// [MCF]: https://passlib.readthedocs.io/en/stable/modular_crypt_format.html//! Trait definitions./// Type used to represent decimal (i.e. integer) values./// Algorithm parameter value string./// Parameter values are defined in the [PHC string format specification][1]./// - ASCII-encoded string consisting of the characters `[a-zA-Z0-9/+.-]`/// - Minimum length: 0 (i.e. empty values are allowed)/// - Maximum length: 64 ASCII characters (i.e. 64-bytes)/// # Additional Notes/// The PHC spec allows for algorithm-defined maximum lengths for parameter/// values, however this library defines a [`Value::MAX_LENGTH`] of 64 ASCII/// Maximum length of an [`Value`] - 64 ASCII characters (i.e. 64-bytes)./// This value is selected to match the maximum length of a [`Salt`][`crate::Salt`]/// as this library internally uses this type to represent salts./// Parse a [`Value`] from the provided `str`, validating it according to/// the PHC string format's rules./// Attempt to decode a B64-encoded [`Value`], writing the decoded/// result into the provided buffer, and returning a slice of the buffer/// Examples of "B64"-encoded parameters in practice are the `keyid` and/// `data` parameters used by the [Argon2 Encoding][1] as described in the/// PHC string format specification./// Is this value empty?/// Attempt to parse this [`Value`] as a PHC-encoded decimal (i.e. integer)./// Decimal values are integers which follow the rules given in the/// ["Decimal Encoding" section of the PHC string format specification][1]./// The decimal encoding rules are as follows:/// > For an integer value x, its decimal encoding consist in the following:/// > - If x < 0, then its decimal encoding is the minus sign - followed by the decimal/// >   encoding of -x./// > - If x = 0, then its decimal encoding is the single character 0./// > - If x > 0, then its decimal encoding is the smallest sequence of ASCII digits that/// >   matches its value (i.e. there is no leading zero)./// > Thus, a value is a valid decimal for an integer x if and only if all of the following hold true:/// > - The first character is either a - sign, or an ASCII digit./// > - All characters other than the first are ASCII digits./// > - If the first character is - sign, then there is at least another character, and the/// >   second character is not a 0./// > - If the string consists in more than one character, then the first one cannot be a 0./// Note: this implementation does not support negative decimals despite/// them being allowed per the spec above. If you need to parse a negative/// number, please parse it from the string representation directly e.g./// `value.as_str().parse::<i32>()`/// [1]: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#decimal-encodingis_decimal/// Does this value parse successfully as a decimal?assert_valid_value/// Are all of the given bytes allowed in a [`Value`]?is_char_valid/// Ensure the given ASCII character (i.e. byte) is allowed in a [`Value`].// Invalid value examplesdecimal_valuereject_decimal_with_leading_zeroreject_overlong_decimalreject_negativereject_invalid_char// Decimal parsing tests// String parsing tests//! Algorithm parameter value as defined by the [PHC string format].//! Implements the following parts of the specification://! > The value for each parameter consists in characters in: `[a-zA-Z0-9/+.-]`//! > (lowercase letters, uppercase letters, digits, /, +, . and -). No other//! > character is allowed. Interpretation of the value depends on the//! > parameter and the function. The function specification MUST unambiguously//! > define the set of valid parameter values. The function specification MUST//! > define a maximum length (in characters) for each parameter. For numerical//! > parameters, functions SHOULD use plain decimal encoding (other encodings//! > are possible as long as they are clearly defined).RustcVersionexpand_attrdo_paste_name_value_attris_stringlikenew2LookbehindJointColonDoubleColonPoundPoundBangis_single_interpolation_group// https://github.com/dtolnay/paste/issues/26is_paste_operationparse_bracket_as_segmentspasted_to_tokens//! [![github]](https://github.com/dtolnay/paste)&ensp;[![crates-io]](https://crates.io/crates/paste)&ensp;[![docs-rs]](https://docs.rs/paste)//! The nightly-only [`concat_idents!`] macro in the Rust standard library is//! notoriously underpowered in that its concatenated identifiers can only refer to//! existing items, they can never be used to define something new.//! [`concat_idents!`]: https://doc.rust-lang.org/std/macro.concat_idents.html//! This crate provides a flexible way to paste together identifiers in a macro,//! including using pasted identifiers to define new items.//! This approach works with any Rust compiler 1.31+.//! # Pasting identifiers//! Within the `paste!` macro, identifiers inside `[<`...`>]` are pasted//! together to form a single identifier.//! use paste::paste;//! paste! {//!     // Defines a const called `QRST`.//!     const [<Q R S T>]: &str = "success!";//!         paste! { [<Q R S T>].len() },//!         8,//! # More elaborate example//! The next example shows a macro that generates accessor methods for some//! struct fields. It demonstrates how you might find it useful to bundle a//! paste invocation inside of a macro\_rules macro.//! macro_rules! make_a_struct_and_getters {//!     ($name:ident { $($field:ident),* }) => {//!         // Define a struct. This expands to://!         //     pub struct S {//!         //         a: String,//!         //         b: String,//!         //         c: String,//!         //     }//!         pub struct $name {//!             $(//!                 $field: String,//!             )*//!         // Build an impl block with getters. This expands to://!         //     impl S {//!         //         pub fn get_a(&self) -> &str { &self.a }//!         //         pub fn get_b(&self) -> &str { &self.b }//!         //         pub fn get_c(&self) -> &str { &self.c }//!         paste! {//!             impl $name {//!                 $(//!                     pub fn [<get_ $field>](&self) -> &str {//!                         &self.$field//!                 )*//! make_a_struct_and_getters!(S { a, b, c });//! fn call_some_getters(s: &S) -> bool {//!     s.get_a() == s.get_b() && s.get_c().is_empty()//! # Case conversion//! Use `$var:lower` or `$var:upper` in the segment list to convert an//! interpolated segment to lower- or uppercase as part of the paste. For//! example, `[<ld_ $reg:lower _expr>]` would paste to `ld_bc_expr` if invoked//! with $reg=`Bc`.//! Use `$var:snake` to convert CamelCase input to snake\_case.//! Use `$var:camel` to convert snake\_case to CamelCase.//! These compose, so for example `$var:snake:upper` would give you SCREAMING\_CASE.//! The precise Unicode conversions are as defined by [`str::to_lowercase`] and//! [`str::to_uppercase`].//! [`str::to_lowercase`]: https://doc.rust-lang.org/std/primitive.str.html#method.to_lowercase//! [`str::to_uppercase`]: https://doc.rust-lang.org/std/primitive.str.html#method.to_uppercase//! # Pasting documentation strings//! Within the `paste!` macro, arguments to a #\[doc ...\] attribute are//! implicitly concatenated together to form a coherent documentation string.//! macro_rules! method_new {//!     ($ret:ident) => {//!             #[doc = "Create a new `" $ret "` object."]//!             pub fn new() -> $ret { todo!() }//! pub struct Paste {}//! method_new!(Paste);  // expands to #[doc = "Create a new `Paste` object"]ApostrophePbkdf2PRFpbkdf2_body/// Generic implementation of PBKDF2 algorithm.//! This crate implements the PBKDF2 key derivation function as specified//! in [RFC 2898](https://tools.ietf.org/html/rfc2898).//! If you are only using the low-level [`pbkdf2`] function instead of the//! higher-level [`Pbkdf2`] struct to produce/verify hash strings,//! it's recommended to disable default features in your `Cargo.toml`://! pbkdf2 = { version = "0.11", default-features = false }//! # Usage (simple with default params)//! Note: this example requires the `rand_core` crate with the `std` feature//! enabled for `rand_core::OsRng` (embedded platforms can substitute their//! own RNG)//! Add the following to your crate's `Cargo.toml` to import it://! pbkdf2 = "0.10"//! rand_core = { version = "0.6", features = ["std"] }//! The following example demonstrates the high-level password hashing API://! # #[cfg(all(feature = "simple", feature = "std"))]//! use pbkdf2::{//!     password_hash::{//!         rand_core::OsRng,//!         PasswordHash, PasswordHasher, PasswordVerifier, SaltString//!     Pbkdf2//! let password = b"hunter42"; // Bad password; don't actually use!//! let salt = SaltString::generate(&mut OsRng);//! // Hash password to PHC string ($pbkdf2-sha256$...)//! let password_hash = Pbkdf2.hash_password(password, &salt)?.to_string();//! // Verify password against PHC string//! let parsed_hash = PasswordHash::new(&password_hash)?;//! assert!(Pbkdf2.verify_password(password, &parsed_hash).is_ok());PBKDF2_SHA256/// PBKDF2 (SHA-256)PBKDF2_SHA512/// PBKDF2 (SHA-512)/// PBKDF2 type for use with [`PasswordHasher`].Pbkdf2Sha256/// PBKDF2 SHA-256Pbkdf2Sha512/// PBKDF2 SHA-512/// PBKDF2 variants./// <https://en.wikipedia.org/wiki/PBKDF2>/// Parse an [`Algorithm`] from the provided string./// Get the [`Ident`] that corresponds to this PBKDF2 [`Algorithm`]./// Get the identifier string for this PBKDF2 [`Algorithm`]./// Number of roundsoutput_length/// Size of the output (in bytes)/// PBKDF2 params//! Implementation of the `password-hash` crate API./// The iterator returned by `peeking_take_while`./// See the [module documentation](./index.html) for details./// The `Iterator` extension trait that provides the `peeking_take_while`//! # `peeking_take_while`//! Provides the `peeking_take_while` iterator adaptor method.//! The `peeking_take_while` method is very similar to `take_while`, but behaves//! differently when used with a borrowed iterator (perhaps returned by//! `Iterator::by_ref`).//! `peeking_take_while` peeks at the next item in the iterator and runs the//! predicate on that peeked item. This avoids consuming the first item yielded//! by the underlying iterator for which the predicate returns `false`. On the//! other hand, `take_while` will consume that first item for which the//! predicate returns `false`, and it will be lost.//! extern crate peeking_take_while;//! // Bring the `peeking_take_while` method for peekable iterators into//! // scope.//! use peeking_take_while::PeekableExt;//! // Let's say we have two collections we want to iterate through: `xs` and//! // `ys`. We want to perform one operation on all the leading contiguous//! // elements that match some predicate, and a different thing with the rest of//! // the elements. With the `xs`, we will use the normal `take_while`. With the//! // `ys`, we will use `peeking_take_while`.//! let xs: Vec<u8> = (0..100).collect();//! let ys = xs.clone();//! let mut iter_xs = xs.into_iter();//! let mut iter_ys = ys.into_iter().peekable();//!     // Let's do one thing with all the items that are less than 10.//! #   fn do_things_with<T>(_: T) {}//!     let xs_less_than_ten = iter_xs.by_ref().take_while(|x| *x < 10);//!     for x in xs_less_than_ten {//!         do_things_with(x);//!     let ys_less_than_ten = iter_ys.by_ref().peeking_take_while(|y| *y < 10);//!     for y in ys_less_than_ten {//!         do_things_with(y);//! // And now we will do some other thing with the items that are greater than//! // or equal to 10.//! // ...except, when using plain old `take_while` we lost 10!//! assert_eq!(iter_xs.next(), Some(11));//! // However, when using `peeking_take_while` we did not! Great!//! assert_eq!(iter_ys.next(), Some(10));// Copyright 2017 Jonathan Creekmore// Licensed under the MIT license <LICENSE.md or// http://opensource.org/licenses/MIT>. This file may not bePemErrorMismatchedTagsMalformedFramingMissingBeginTagMissingEndTagMissingDataInvalidHeaderNotUtf8/// The `pem` error type./// The `pem` result type.parse_capturesparse_captures_iterLINE_WRAP/// The line length for PEM encoding/// Windows-like (`\r\n`)/// Unix-like (`\n`)/// Enum describing line endings/// Line ending to use during encodingline_wrap/// Line length to use during encodingEncodeConfig/// Configuration for Pem encoding/// A representation of Pem-encoded data/// Provides access to the headers that might be found in a Pem-encoded filedecode_dataHeadersIter/// Iterator across all headers in the Pem-encoded datasplit_header/// Get an iterator across all header key-value pairs/// Get the last set value corresponding to the header key/// Create a new encode config with default values.set_line_ending/// Set the line ending to use for the encoding./// Set the line length to use for the encoding./// Create a new Pem struct/// Get the tag extracted from the Pem-encoded data/// Get the binary contents extracted from the Pem-encoded datainto_contents/// Consume the Pem struct to get an owned copy of the binary contents/// Get the header map for the headers in the Pem-encoded data/// Get the header map for modificationnew_from_captures/// Parses a single PEM-encoded data from a data-type that can be dereferenced as a [u8]./// # Example: parse PEM-encoded data from a Vec<u8>/// use pem::parse;/// const SAMPLE: &'static str = "-----BEGIN RSA PRIVATE KEY-----/// MIIBPQIBAAJBAOsfi5AGYhdRs/x6q5H7kScxA0Kzzqe6WI6gf6+tc6IvKQJo5rQc/// dWWSQ0nRGt2hOPDO+35NKhQEjBQxPh/v7n0CAwEAAQJBAOGaBAyuw0ICyENy5NsO/// 2gkT00AWTSzM9Zns0HedY31yEabkuFvrMCHjscEF7u3Y6PB7An3IzooBHchsFDei/// AAECIQD/JahddzR5K3A6rzTidmAf1PBtqi7296EnWv8WvpfAAQIhAOvowIXZI4Un/// DXjgZ9ekuUjZN+GUQRAVlkEEohGLVy59AiEA90VtqDdQuWWpvJX0cM08V10tLXrT/// TTGsEtITid1ogAECIQDAaFl90ZgS5cMrL3wCeatVKzVUmuJmB/VAmlLFFGzK0QIh/// ANJGc7AFk4fyFD/OezhwGHbWmo/S+bfeAiIh2Ss2FxKJ/// -----END RSA PRIVATE KEY-----/// let SAMPLE_BYTES: Vec<u8> = SAMPLE.into();///  let pem = parse(SAMPLE_BYTES).unwrap();///  assert_eq!(pem.tag(), "RSA PRIVATE KEY");/// # Example: parse PEM-encoded data from a String/// let SAMPLE_STRING: String = SAMPLE.into();///  let pem = parse(SAMPLE_STRING).unwrap();/// Parses a set of PEM-encoded data from a data-type that can be dereferenced as a [u8]./// # Example: parse a set of PEM-encoded data from a Vec<u8>/// use pem::parse_many;/// const SAMPLE: &'static str = "-----BEGIN INTERMEDIATE CERT-----/// -----END INTERMEDIATE CERT-----/// -----BEGIN CERTIFICATE-----/// -----END CERTIFICATE-----///  let pems = parse_many(SAMPLE_BYTES).unwrap();///  assert_eq!(pems.len(), 2);///  assert_eq!(pems[0].tag(), "INTERMEDIATE CERT");///  assert_eq!(pems[1].tag(), "CERTIFICATE");/// # Example: parse a set of PEM-encoded data from a String///  let SAMPLE_STRING: Vec<u8> = SAMPLE.into();///  let pems = parse_many(SAMPLE_STRING).unwrap();/// Encode a PEM struct into a PEM-encoded data string///  use pem::{Pem, encode};///  let pem = Pem::new("FOO", [1, 2, 3, 4]);///  encode(&pem);encode_config/// Encode a PEM struct into a PEM-encoded data string with additional/// configuration options///  use pem::{Pem, encode_config, EncodeConfig, LineEnding};///  encode_config(&pem, EncodeConfig::new().set_line_ending(LineEnding::LF));encode_many/// Encode multiple PEM structs into a PEM-encoded data string///  use pem::{Pem, encode_many};///  let data = vec![///     Pem::new("FOO", [1, 2, 3, 4]),///     Pem::new("BAR", [5, 6, 7, 8]),///  ];///  encode_many(&data);encode_many_config/// Encode multiple PEM structs into a PEM-encoded data string with additional/// Same config will be used for each PEM struct.///  use pem::{Pem, encode_many_config, EncodeConfig, LineEnding};///   ];///   encode_many_config(&data, EncodeConfig::new().set_line_ending(LineEnding::LF));SAMPLE_CRLFSAMPLE_LFSAMPLE_WSSAMPLE_DEFAULT_LINE_WRAPSAMPLE_CUSTOM_LINE_WRAP_4test_parse_workstest_parse_empty_spacetest_parse_invalid_framingtest_parse_invalid_begintest_parse_invalid_endtest_parse_invalid_datatest_parse_empty_datatest_parse_many_workstest_parse_many_errors_on_invalid_sectiontest_encode_default_line_wraptest_encode_custom_line_wrap_4test_encode_empty_contentstest_encode_contentstest_encode_manytest_encode_config_contentstest_encode_many_configHEADER_CRLFHEADER_CRLF_DATAHEADER_LFHEADER_LF_DATAcmp_datatest_parse_many_with_headers_crlftest_parse_many_with_headers_lftest_extract_headerstest_get_headertest_only_get_latest// Copyright 2016-2017 Jonathan Creekmore//! This crate provides a parser and encoder for PEM-encoded binary data.//! PEM-encoded binary data is essentially a beginning and matching end//! tag that encloses base64-encoded binary data (see://! https://en.wikipedia.org/wiki/Privacy-enhanced_Electronic_Mail).//! This crate's documentation provides a few simple examples along with//! documentation on the public methods for the crate.//! This crate is [on crates.io](https://crates.io/crates/pem) and can be used//! by adding `pem` to your dependencies in your project's `Cargo.toml`.//! pem = "3"//! Using the `serde` feature will implement the serde traits for//! the `Pem` struct.//! # Example: parse a single chunk of PEM-encoded text//! Generally, PEM-encoded files contain a single chunk of PEM-encoded//! text. Commonly, this is in some sort of a key file or an x.509//! certificate.//! use pem::parse;//! const SAMPLE: &'static str = "-----BEGIN RSA PRIVATE KEY-----//! MIIBPQIBAAJBAOsfi5AGYhdRs/x6q5H7kScxA0Kzzqe6WI6gf6+tc6IvKQJo5rQc//! dWWSQ0nRGt2hOPDO+35NKhQEjBQxPh/v7n0CAwEAAQJBAOGaBAyuw0ICyENy5NsO//! 2gkT00AWTSzM9Zns0HedY31yEabkuFvrMCHjscEF7u3Y6PB7An3IzooBHchsFDei//! AAECIQD/JahddzR5K3A6rzTidmAf1PBtqi7296EnWv8WvpfAAQIhAOvowIXZI4Un//! DXjgZ9ekuUjZN+GUQRAVlkEEohGLVy59AiEA90VtqDdQuWWpvJX0cM08V10tLXrT//! TTGsEtITid1ogAECIQDAaFl90ZgS5cMrL3wCeatVKzVUmuJmB/VAmlLFFGzK0QIh//! ANJGc7AFk4fyFD/OezhwGHbWmo/S+bfeAiIh2Ss2FxKJ//! -----END RSA PRIVATE KEY-----//!  let pem = parse(SAMPLE).unwrap();//!  assert_eq!(pem.tag(), "RSA PRIVATE KEY");//! # Example: parse a set of PEM-encoded text//! Sometimes, PEM-encoded files contain multiple chunks of PEM-encoded//! text. You might see this if you have an x.509 certificate file that//! also includes intermediate certificates.//! use pem::parse_many;//! const SAMPLE: &'static str = "-----BEGIN INTERMEDIATE CERT-----//! -----END INTERMEDIATE CERT-----//! -----BEGIN CERTIFICATE-----//! -----END CERTIFICATE-----//!  let pems = parse_many(SAMPLE).unwrap();//!  assert_eq!(pems.len(), 2);//!  assert_eq!(pems[0].tag(), "INTERMEDIATE CERT");//!  assert_eq!(pems[1].tag(), "CERTIFICATE");//! This crate supports two features: `std` and `serde`.//! The `std` feature is enabled by default. If you specify//! `default-features = false` to disable `std`, be aware that//! this crate still needs an allocator.//! The `serde` feature implements `serde::{Deserialize, Serialize}`//! for this crate's `Pem` struct.CaptureMatchesparse_beginparse_payloadextract_headers_and_dataparse_endparser_innerskip_whitespace// Equivalent to the regex [ \t\n\r]*// Equivalent to (.*?) followed by a string// Returns the remaining input (after the secondary matched string) and the matched datagrammarBase64DecoderBASE64_WRAP_WIDTHPOST_ENCAPSULATION_BOUNDARYPRE_ENCAPSULATION_BOUNDARY/// Decode a PEM document according to RFC 7468's "Strict" grammar./// On success, writes the decoded document into the provided buffer, returning/// the decoded label and the portion of the provided buffer containing the/// decoded message./// Decode a PEM document according to RFC 7468's "Strict" grammar, returning/// the result as a [`Vec`] upon success.decode_label/// Decode the encapsulation boundaries of a PEM document according to RFC 7468's "Strict" grammar./// On success, returning the decoded label./// PEM type label./// Buffered Base64 decoder./// Buffered PEM decoder./// Stateful buffered decoder type which decodes an input PEM document according/// to RFC 7468's "Strict" grammar./// Create a new PEM [`Decoder`] with the default options./// Create a new PEM [`Decoder`] which wraps at the given line width./// Get the PEM type label for the input document./// Decode data into the provided output buffer./// There must be at least as much remaining Base64 input to be decoded/// in order to completely fill `buf`./// Decode all of the remaining data in the input buffer into `buf`./// Get the decoded length of the remaining PEM data after Base64 decoding./// Are we finished decoding the PEM input?/// Type label extracted from the pre/post-encapsulation boundaries./// From RFC 7468 Section 2:/// > The type of data encoded is labeled depending on the type label in/// > the "-----BEGIN " line (pre-encapsulation boundary).  For example,/// > the line may be "-----BEGIN CERTIFICATE-----" to indicate that the/// > content is a PKIX certificate (see further below).  Generators MUST/// > put the same label on the "-----END " line (post-encapsulation/// > boundary) as the corresponding "-----BEGIN " line.  Labels are/// > formally case-sensitive, uppercase, and comprised of zero or more/// > characters; they do not contain consecutive spaces or hyphen-minuses,/// > nor do they contain spaces or hyphen-minuses at either end.  Parsers/// > MAY disregard the label in the post-encapsulation boundary instead of/// > signaling an error if there is a label mismatch: some extant/// > implementations require the labels to match; others do not.encapsulated_text/// Encapsulated text portion contained between the boundaries./// This data should be encoded as Base64, however this type performs no/// validation of it so it can be handled in constant-time.Encapsulation/// PEM encapsulation parser./// This parser performs an initial pass over the data, locating the/// pre-encapsulation (`---BEGIN [...]---`) and post-encapsulation/// (`---END [...]`) boundaries while attempting to avoid branching/// on the potentially secret Base64-encoded data encapsulated between/// the two boundaries./// It only supports a single encapsulated message at present. Future work/// could potentially include extending it provide an iterator over a series/// of encapsulated messages./// Parse the type label and encapsulated text from between the/// pre/post-encapsulation boundaries./// Get the label parsed from the encapsulation boundaries.check_for_headers/// Check for PEM headers in the input, as they are disallowed by RFC7468./// Returns `Error::HeaderDisallowed` if headers are encountered.pkcs8_example//! Decoder for PEM encapsulated data.//! From RFC 7468 Section 2://! > Textual encoding begins with a line comprising "-----BEGIN ", a//! > label, and "-----", and ends with a line comprising "-----END ", a//! > label, and "-----".  Between these lines, or "encapsulation//! > boundaries", are base64-encoded data according to Section 4 of//! > [RFC 4648].//! [RFC 4648]: https://datatracker.ietf.org/doc/html/rfc4648Base64EncoderENCAPSULATION_BOUNDARY_DELIMITERencapsulated_len/// Compute the length of a PEM encoded document which encapsulates a/// Base64-encoded body including line endings every 64 characters./// The `input_len` parameter specifies the length of the raw input/// bytes prior to Base64 encoding./// Note that the current implementation of this function computes an upper/// bound of the length and the actual encoded document may be slightly shorter/// (typically 1-byte). Downstream consumers of this function should check the/// actual encoded length and potentially truncate buffers allocated using this/// function to estimate the encapsulated size./// Use [`encoded_len`] (when possible) to obtain a precise length./// - `Ok(len)` on success/// - `Err(Error::Length)` on length overflowencapsulated_len_wrapped/// Compute the length of a PEM encoded document with the Base64 body/// line wrapped at the specified `width`./// This is the same as [`encapsulated_len`], which defaults to a width of 64./// Note that per [RFC7468 § 2] encoding PEM with any other wrap width besides/// 64 is technically non-compliant:/// > Generators MUST wrap the base64-encoded lines so that each line/// > consists of exactly 64 characters except for the final line, which/// > will encode the remainder of the data (within the 64-character line/// > boundary)/// [RFC7468 § 2]: https://datatracker.ietf.org/doc/html/rfc7468#section-2/// Get the length of a PEM encoded document with the given bytes and label./// This function computes a precise length of the PEM encoding of the given/// `input` data./// Encode a PEM document according to RFC 7468's "Strict" grammar./// Encode a PEM document according to RFC 7468's "Strict" grammar, returning/// the result as a [`String`].encapsulated_len_inner/// Compute the encapsulated length of Base64 data of the given length.base64_len_wrapped/// Compute Base64 length line-wrapped at the specified width with the given/// line ending./// Line ending used to wrap Base64./// Buffered Base64 encoder./// Buffered PEM encoder./// Stateful buffered encoder type which encodes an input PEM document according/// Create a new PEM [`Encoder`] with the default options which/// writes output into the provided buffer./// Create a new PEM [`Encoder`] which wraps at the given line width./// This method is provided with the intended purpose of implementing the/// OpenSSH private key format, which uses a non-standard wrap width of 70./// Get the PEM type label used for this document./// Encode the provided input data./// This method can be called as many times as needed with any sized input/// to write data encoded data into the output buffer, so long as there is/// sufficient space in the buffer to handle the resulting Base64 encodedbase64_encoder/// Borrow the inner [`Base64Encoder`]./// On success, returns the total number of bytes written to the output//! PEM encoder./// Result type with the `pem-rfc7468` crate's [`Error`] type./// Base64-related errors.CharacterEncoding/// Character encoding-related errors.EncapsulatedText/// Errors in the encapsulated text (which aren't specifically Base64-related).HeaderDisallowed/// Header detected in the encapsulated text./// Invalid label./// Invalid length./// "Preamble" (text before pre-encapsulation boundary) contains invalid data.PreEncapsulationBoundary/// Errors in the pre-encapsulation boundary.PostEncapsulationBoundary/// Errors in the post-encapsulation boundary./// Type label that was expected.UnexpectedTypeLabel/// Unexpected PEM type label./// PEM errors.CHAR_NUL/// NUL charCHAR_HT/// Horizontal tabCHAR_SP/// SpaceCHAR_COLON/// Colon ':'is_labelchar/// Any printable character except hyphen-minus, as defined in the/// 'labelchar' production in the RFC 7468 ABNF grammaris_allowed_in_label/// Does the provided byte match a character allowed in a label?// TODO: allow hyphen-minus to match the 'label' production in the ABNF grammaris_wsp/// Does the provided byte match the "WSP" ABNF production from Section 3?/// > The common ABNF production WSP is congruent with "blank";/// > a new production W is used for "whitespace"strip_preamble/// Strip the "preamble", i.e. data that appears before the PEM/// pre-encapsulation boundary./// Presently no attempt is made to ensure the preamble decodes successfully/// under any particular character encoding. The only byte which is disallowed/// is the NUL byte. This restriction does not appear in RFC7468, but rather/// is inspired by the OpenSSL PEM decoder./// Returns a slice which starts at the beginning of the encapsulated text./// From RFC7468:/// > Data before the encapsulation boundaries are permitted, and/// > parsers MUST NOT malfunction when processing such data.strip_leading_eol/// Strip a newline (`eol`) from the beginning of the provided byte slice./// The newline is considered mandatory and a decoding error will occur if it/// is not present./// From RFC 7468 Section 3:/// > lines are divided with CRLF, CR, or LF.strip_trailing_eol/// Strip a newline (`eol`) from the end of the provided byte slice.split_label/// Split a slice beginning with a type label as located in an encapsulation/// boundary. Returns the label as a `&str`, and slice beginning with the/// encapsulated text with leading `-----` and newline removed./// This implementation follows the rules put forth in Section 2, which are/// stricter than those found in the ABNF grammar:/// > Labels are formally case-sensitive, uppercase, and comprised of zero or more/// > nor do they contain spaces or hyphen-minuses at either end./// We apply a slightly stricter interpretation:/// - Labels MAY be empty/// - Non-empty labels MUST start with an upper-case letter: `'A'..='Z'`/// - The only allowable characters subsequently are `'A'..='Z'` or WSP.///   (NOTE: this is an overly strict initial implementation and should be relaxed)/// - Whitespace MUST NOT contain more than one consecutive WSP character// TODO(tarcieri): evaluate whether this is too strict; support '-'validate_label/// Validate that the given bytes are allowed as a PEM type label, i.e. the/// label encoded in the `BEGIN` and `END` encapsulation boundaries.split_label_empty/// Empty label is OK.split_label_with_text/// Label containing text.split_label_with_repeat_wsp_is_err/// Reject labels containing repeated spacesvalidate_private_key_label/// Basic validation of a labelvalidate_private_key_label_reject_double_space/// Reject labels with double spaces//! Helper functions and rules for enforcing the ABNF grammar for//! RFC 7468-flavored PEM as described in Section 3.//! The grammar described below is intended to follow the "ABNF (Strict)"//! subset of the grammar as described in Section 3 Figure 3./// The pre-encapsulation boundary appears before the encapsulated text./// > There are exactly five hyphen-minus (also known as dash) characters ("-")/// > on both ends of the encapsulation boundaries, no more, no less./// The post-encapsulation boundary appears immediately after the encapsulated text./// Delimiter of encapsulation boundaries./// Width at which the Base64 body of RFC7468-compliant PEM is wrapped./// From [RFC7468 § 2]:/// > boundary), and they MUST NOT emit extraneous whitespace.  Parsers MAY/// > handle other line sizes./// Buffered Base64 decoder type./// Buffered Base64 encoder type.PEM_LABEL/// Expected PEM type label for a given document, e.g. `"PRIVATE KEY"`validate_pem_label/// Validate that a given label matches the expected label./// Marker trait for types with an associated PEM type label.//! /// Example PEM document//! /// NOTE: do not actually put private key literals into your source code!!!//! let example_pem = "\//! -----BEGIN PRIVATE KEY-----//! MC4CAQAwBQYDK2VwBCIEIBftnHPp22SewYmmEoMcX8VwI4IHwaqd+9LFPj/15eqF//! -----END PRIVATE KEY-----//! // Decode PEM//! let (type_label, data) = pem_rfc7468::decode_vec(example_pem.as_bytes())?;//! assert_eq!(type_label, "PRIVATE KEY");//!     data,//!         48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32, 23, 237, 156, 115, 233, 219,//!         100, 158, 193, 137, 166, 18, 131, 28, 95, 197, 112, 35, 130, 7, 193, 170, 157, 251,//!         210, 197, 62, 63, 245, 229, 234, 133//!     ]//! // Encode PEM//! use pem_rfc7468::LineEnding;//! let encoded_pem = pem_rfc7468::encode_string(type_label, LineEnding::default(), &data)?;//! assert_eq!(&encoded_pem, example_pem);ASCII_RANGE_LENBITS_PER_CHUNK/// Represents a set of characters or bytes in the ASCII range./// This is used in [`percent_encode`] and [`utf8_percent_encode`]./// This is similar to [percent-encode sets](https://url.spec.whatwg.org/#percent-encoded-bytes)./// Use the `add` method of an existing set to define a new set. For example:/// use percent_encoding::{AsciiSet, CONTROLS};/// /// https://url.spec.whatwg.org/#fragment-percent-encode-set/// const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');/// Called with UTF-8 bytes rather than code points./// Not used for non-ASCII bytes.should_percent_encodeCONTROLS/// The set of 0x00 to 0x1F (C0 controls), and 0x7F (DEL)./// Note that this includes the newline and tab characters, but not the space 0x20./// <https://url.spec.whatwg.org/#c0-control-percent-encode-set>static_assert_static_assertNON_ALPHANUMERIC/// Everything that is not an ASCII letter or digit./// This is probably more eager than necessary in any context./// Return the percent-encoding of the given byte./// This is unconditional, unlike `percent_encode()` which has an `AsciiSet` parameter./// use percent_encoding::percent_encode_byte;/// assert_eq!("foo bar".bytes().map(percent_encode_byte).collect::<String>(),///            "%66%6F%6F%20%62%61%72");PercentEncode/// Percent-encode the given bytes with the given set./// Non-ASCII bytes and bytes in `ascii_set` are encoded./// The return type:/// * Implements `Iterator<Item = &str>` and therefore has a `.collect::<String>()` method,/// * Implements `Display` and therefore has a `.to_string()` method,/// * Implements `Into<Cow<str>>` borrowing `input` when none of its bytes are encoded./// use percent_encoding::{percent_encode, NON_ALPHANUMERIC};/// assert_eq!(percent_encode(b"foo bar?", NON_ALPHANUMERIC).to_string(), "foo%20bar%3F");utf8_percent_encode/// Percent-encode the UTF-8 encoding of the given string./// See [`percent_encode`] regarding the return type./// use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};/// assert_eq!(utf8_percent_encode("foo bar?", NON_ALPHANUMERIC).to_string(), "foo%20bar%3F");ascii_set/// The return type of [`percent_encode`] and [`utf8_percent_encode`].PercentDecode/// Percent-decode the given string./// <https://url.spec.whatwg.org/#string-percent-decode>/// See [`percent_decode`] regarding the return type./// Percent-decode the given bytes./// <https://url.spec.whatwg.org/#percent-decode>/// Any sequence of `%` followed by two hexadecimal digits is decoded./// * Implements `Into<Cow<u8>>` borrowing `input` when it contains no percent-encoded sequence,/// * Implements `Iterator<Item = u8>` and therefore has a `.collect::<Vec<u8>>()` method,/// * Has `decode_utf8()` and `decode_utf8_lossy()` methods./// use percent_encoding::percent_decode;/// assert_eq!(percent_decode(b"foo%20bar%3f").decode_utf8().unwrap(), "foo bar?");/// The return type of [`percent_decode`].after_percent_signif_any/// If the percent-decoding is different from the input, return it as a new bytes vector.decode_utf8/// Decode the result of percent-decoding as UTF-8./// This is return `Err` when the percent-decoded bytes are not well-formed in UTF-8./// Decode the result of percent-decoding as UTF-8, lossily./// Invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD,/// the replacement character.//! URLs use special characters to indicate the parts of the request.//! For example, a `?` question mark marks the end of a path and the start of a query string.//! In order for that character to exist inside a path, it needs to be encoded differently.//! Percent encoding replaces reserved characters with the `%` escape character//! followed by a byte value as two hexadecimal digits.//! For example, an ASCII space is replaced with `%20`.//! When encoding, the set of characters that can (and should, for readability) be left alone//! depends on the context.//! The `?` question mark mentioned above is not a separator when used literally//! inside of a query string, and therefore does not need to be encoded.//! The [`AsciiSet`] parameter of [`percent_encode`] and [`utf8_percent_encode`]//! lets callers configure this.//! This crate deliberately does not provide many different sets.//! Users should consider in what context the encoded string will be used,//! read relevant specifications, and define their own set.//! This is done by using the `add` method of an existing set.//! use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};//! /// https://url.spec.whatwg.org/#fragment-percent-encode-set//! const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');//! assert_eq!(utf8_percent_encode("foo <bar>", FRAGMENT).to_string(), "foo%20%3Cbar%3E");DataMapDataMapMutiter_formatNoPrettyEdgeCountEdgeRefGetAdjacencyMatrixIntoEdgeReferencesIntoNeighborsNodeCountDefaultIxIndexTypeIxNodeIndex/// Adjacency list node index type, a plain integer./// Source of the edge.successor_index/// Index of the sucessor in the successor list.EdgeIndex/// Adjacency list edge index type, a pair of integers.iterator_wrapr" An Iterator over the indices of the outgoing edges from a node."r" It does not borrow the graph during iteration."OutgoingEdgeIndicessuc/// Index of the sucessor./// Weight of the edge to `suc`.WSuc/// Weighted sucessorRow/// One row of the adjacency list.RowIterr" An iterator over the indices of the neighbors of a node."Neighbors/// index of the edge/// a reference to the corresponding item in the adjacency listEdgeReference/// A reference to an edge of the graph.NodeIdEdgeIdrow_indexrow_lenEdgeIndicesr" An iterator over all node indices in the graph."NodeIndices/// An adjacency list with labeled edges./// Can be interpreted as a directed graph/// with unweighted nodes./// This is the most simple adjacency list you can imagine. [`Graph`](../graph/struct.Graph.html), in contrast,/// maintains both the list of successors and predecessors for each node,/// which is a different trade-off./// Allows parallel edges and self-loops./// This data structure is append-only (except for [`clear`](#method.clear)), so indices/// returned at some point for a given graph will stay valid with this same/// graph until it is dropped or [`clear`](#method.clear) is called./// Space consumption: **O(|E|)**./// Creates a new, empty adjacency list./// Creates a new, empty adjacency list tailored for `nodes` nodes./// Removes all nodes and edges from the list.edge_count/// Returns the number of edges in the list/// Computes in **O(|V|)** time.add_node/// Adds a new node to the list. This allocates a new `Vec` and then should/// run in amortized **O(1)** time.add_node_with_capacityadd_node_from_edges/// Adds a new node to the list by giving its list of successors and the corresponding/// weigths.add_edge/// Add an edge from `a` to `b` to the graph, with its associated/// data `weight`./// Return the index of the new edge./// **Panics** if the source node does not exist.<br>/// **Note:** `List` allows adding parallel (“duplicate”) edges. If you want/// to avoid this, use [`.update_edge(a, b, weight)`](#method.update_edge) instead.get_edgeget_edge_mutedge_endpoints/// Accesses the source and target of edge `e`/// Computes in **O(1)**edge_indices_fromcontains_edge/// Lookups whether there is an edge from `a` to `b`./// Computes in **O(e')** time, where **e'** is the number of successors of `a`.find_edgenode_indices/// Returns an iterator over all node indices of the graph./// Consuming the whole iterator take **O(|V|)**.edge_indices/// Returns an iterator over all edge indices of the graph./// Consuming the whole iterator take **O(|V| + |E|)**.UnweightedList/// A very simple adjacency list with no node or label weights.update_edge/// Updates or adds an edge from `a` to `b` to the graph, with its associatedEdgeReferencesGraphBasereset_mapVisitableNodeIdentifiersnode_identifiersIntoNodeIdentifiersNodeRefNodeReferencesnode_referencesIntoNodeReferencesNodeWeightEdgeWeightneighbors/// Returns an iterator of all nodes with an edge starting from `a`./// Panics if `a` is out of bounds./// Use [`List::edge_indices_from`] instead if you do not want to borrow the adjacency list while/// iterating.SomeIterr" An iterator over the [`EdgeReference`] of all the edges of the graph."proj1proj2edge_referencesr" Iterator over the [`EdgeReference`] of the outgoing edges from a node."OutgoingEdgeReferencesEdgesedgesIntoEdgesEdgeTypeDirectedis_directedGraphPropnode_count/// Returns the number of nodes in the listnode_boundNodeIndexableNodeCompactIndexablenode_weightedge_weight/// Accesses the weight of edge `e`node_weight_mutedge_weight_mutAdjMatrixadjacency_matrixis_adjacent/// The adjacency matrix for **List** is a bitmap that's computed by/// `.adjacency_matrix()`.//! Simple adjacency list.scoredMinScoredMeasureIsGoalastar/// \[Generic\] A* shortest path algorithm./// Computes the shortest path from `start` to `finish`, including the total path cost./// `finish` is implicitly given via the `is_goal` callback, which should return `true` if the/// given node is the finish node./// The function `edge_cost` should return the cost for a particular edge. Edge costs must be/// non-negative./// The function `estimate_cost` should return the estimated cost to the finish for a particular/// node. For the algorithm to find the actual shortest path, it should be admissible, meaning that/// it should never overestimate the actual cost to get to the nearest goal node. Estimate costs/// must also be non-negative./// The graph should be `Visitable` and implement `IntoEdges`./// use petgraph::Graph;/// use petgraph::algo::astar;/// let mut g = Graph::new();/// let a = g.add_node((0., 0.));/// let b = g.add_node((2., 0.));/// let c = g.add_node((1., 1.));/// let d = g.add_node((0., 2.));/// let e = g.add_node((3., 3.));/// let f = g.add_node((4., 2.));/// g.extend_with_edges(&[///     (a, b, 2),///     (a, d, 4),///     (b, c, 1),///     (b, f, 7),///     (c, e, 5),///     (e, f, 1),///     (d, e, 1),/// // Graph represented with the weight of each edge/// // Edges with '*' are part of the optimal path./// //     2       1/// // a ----- b ----- c/// // | 4*    | 7     |/// // d       f       | 5/// // | 1*    | 1*    |/// // \------ e ------//// let path = astar(&g, a, |finish| finish == f, |e| *e.weight(), |_| 0);/// assert_eq!(path, Some((6, vec![a, d, e, f])));/// Returns the total cost + the path of subsequent `NodeId` from start to finish, if one wascame_fromPathTrackerset_predecessorreconstruct_path_toVisitMapFloatMeasureNegativeCycledistancespredecessorsbellman_ford/// \[Generic\] Compute shortest paths from node `source` to all other./// Using the [Bellman–Ford algorithm][bf]; negative edge costs are/// permitted, but the graph must not have a cycle of negative weights/// (in that case it will return an error)./// On success, return one vec with path costs, and another one which points/// out the predecessor of a node along a shortest path. The vectors/// are indexed by the graph's node indices./// [bf]: https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm/// use petgraph::algo::bellman_ford;/// use petgraph::prelude::*;/// let a = g.add_node(()); // node with no weight/// let b = g.add_node(());/// let c = g.add_node(());/// let d = g.add_node(());/// let e = g.add_node(());/// let f = g.add_node(());///     (0, 1, 2.0),///     (0, 3, 4.0),///     (1, 2, 1.0),///     (1, 5, 7.0),///     (2, 4, 5.0),///     (4, 5, 1.0),///     (3, 4, 1.0),/// // | 4     | 7     |/// // | 1     | 1     |/// let path = bellman_ford(&g, a);/// assert!(path.is_ok());/// let path = path.unwrap();/// assert_eq!(path.distances, vec![    0.0,     2.0,    3.0,    4.0,     5.0,     6.0]);/// assert_eq!(path.predecessors, vec![None, Some(a),Some(b),Some(a), Some(d), Some(e)]);/// // Node f (indice 5) can be reach from a with a path costing 6./// // Predecessor of f is Some(e) which predecessor is Some(d) which predecessor is Some(a)./// // Thus the path from a to f is a <-> d <-> e <-> f/// let graph_with_neg_cycle = Graph::<(), f32, Undirected>::from_edges(&[///         (0, 1, -2.0),///         (0, 3, -4.0),///         (1, 2, -1.0),///         (1, 5, -25.0),///         (2, 4, -5.0),///         (4, 5, -25.0),///         (3, 4, -1.0),/// assert!(bellman_ford(&graph_with_neg_cycle, NodeIndex::new(0)).is_err());find_negative_cycle/// \[Generic\] Find the path of a negative cycle reachable from node `source`./// Using the [find_negative_cycle][nc]; will search the Graph for negative cycles using/// [Bellman–Ford algorithm][bf]. If no negative cycle is found the function will return `None`./// If a negative cycle is found from source, return one vec with a path of `NodeId`s./// The time complexity of this algorithm should be the same as the Bellman-Ford (O(|V|·|E|))./// [nc]: https://blogs.asarkar.com/assets/docs/algorithms-curated/Negative-Weight%20Cycle%20Algorithms%20-%20Huang.pdf/// use petgraph::algo::find_negative_cycle;/// let graph_with_neg_cycle = Graph::<(), f32, Directed>::from_edges(&[///         (0, 1, 1.),///         (0, 2, 1.),///         (0, 3, 1.),///         (1, 3, 1.),///         (2, 1, 1.),///         (3, 2, -3.),/// let path = find_negative_cycle(&graph_with_neg_cycle, NodeIndex::new(0));///     path,///     Some([NodeIndex::new(1), NodeIndex::new(3), NodeIndex::new(2)].to_vec())bellman_ford_initialize_relax// Perform Step 1 and Step 2 of the Bellman-Ford algorithm.//! Bellman-Ford algorithms.dijkstra/// \[Generic\] Dijkstra's shortest path algorithm./// Compute the length of the shortest path from `start` to every reachable/// node./// The graph should be `Visitable` and implement `IntoEdges`. The function/// `edge_cost` should return the cost for a particular edge, which is used/// to compute path costs. Edge costs must be non-negative./// If `goal` is not `None`, then the algorithm terminates once the `goal` node's/// cost is calculated./// Returns a `HashMap` that maps `NodeId` to path cost./// use petgraph::algo::dijkstra;/// let mut graph: Graph<(), (), Directed> = Graph::new();/// let a = graph.add_node(()); // node with no weight/// let b = graph.add_node(());/// let c = graph.add_node(());/// let d = graph.add_node(());/// let e = graph.add_node(());/// let f = graph.add_node(());/// let g = graph.add_node(());/// let h = graph.add_node(());/// // z will be in another connected component/// let z = graph.add_node(());/// graph.extend_with_edges(&[///     (a, b),///     (b, c),///     (c, d),///     (d, a),///     (e, f),///     (b, e),///     (f, g),///     (g, h),///     (h, e),/// // a ----> b ----> e ----> f/// // ^       |       ^       |/// // |       v       |       v/// // d <---- c       h <---- g/// let expected_res: HashMap<NodeIndex, usize> = [///     (a, 3),///     (b, 0),///     (c, 1),///     (d, 2),///     (e, 1),///     (f, 2),///     (g, 3),///     (h, 4),/// ].iter().cloned().collect();/// let res = dijkstra(&graph, b, None, |_| 1);/// assert_eq!(res, expected_res);/// // z is not inside res because there is not path from b to z.DfsPostOrderWalkerdominatorsDominators/// The dominance relation for some graph and root./// Get the root node used to construct these dominance relations.immediate_dominator/// Get the immediate dominator of the given node./// Returns `None` for any node that is not reachable from the root, and for/// the root itself.strict_dominatorsDominatorsIter/// Iterate over the given node's strict dominators./// If the given node is not reachable from the root, then `None` is/// Iterate over all of the given node's dominators (including the given/// node itself).immediately_dominated_byDominatedByIter/// Iterate over all nodes immediately dominated by the given node (not/// including the given node itself)./// Iterator for a node's dominators./// Iterator for nodes dominated by a given node.UNDEFINED/// The undefined dominator sentinel, for when we have not yet discovered a/// node's dominator.simple_fast/// This is an implementation of the engineered ["Simple, Fast Dominance/// Algorithm"][0] discovered by Cooper et al./// This algorithm is **O(|V|²)**, and therefore has slower theoretical running time/// than the Lengauer-Tarjan algorithm (which is **O(|E| log |V|)**. However,/// Cooper et al found it to be faster in practice on control flow graphs of up/// to ~30,000 vertices./// [0]: http://www.hipersoft.rice.edu/grads/publications/dom14.pdfpredecessor_sets_to_idx_vecsPredecessorSetssimple_fast_post_ordertest_iter_dominators//! Compute dominators of a control-flow graph.//! # The Dominance Relation//! In a directed graph with a root node **R**, a node **A** is said to *dominate* a//! node **B** iff every path from **R** to **B** contains **A**.//! The node **A** is said to *strictly dominate* the node **B** iff **A** dominates//! **B** and **A ≠ B**.//! The node **A** is said to be the *immediate dominator* of a node **B** iff it//! strictly dominates **B** and there does not exist any node **C** where **A**//! dominates **C** and **C** dominates **B**.GraphIndexLinkedListEntrygreedy_feedback_arc_set/// \[Generic\] Finds a [feedback arc set]: a set of edges in the given directed graph, which when/// removed, make the graph acyclic./// Uses a [greedy heuristic algorithm] to select a small number of edges, but does not necessarily/// find the minimum feedback arc set. Time complexity is roughly **O(|E|)** for an input graph with/// edges **E**./// Does not consider edge/node weights when selecting edges for the feedback arc set./// Loops (edges to and from the same node) are always included in the returned set./// # #[cfg(feature = "stable_graph")] {/// use petgraph::{///     algo::{greedy_feedback_arc_set, is_cyclic_directed},///     graph::EdgeIndex,///     stable_graph::StableGraph,///     visit::EdgeRef,/// let mut g: StableGraph<(), ()> = StableGraph::from_edges(&[///     (0, 1),///     (1, 2),///     (2, 3),///     (3, 4),///     (4, 5),///     (5, 0),///     (4, 1),///     (1, 3),/// assert!(is_cyclic_directed(&g));/// let fas: Vec<EdgeIndex> = greedy_feedback_arc_set(&g).map(|e| e.id()).collect();/// // Remove edges in feedback arc set from original graph/// for edge_id in fas {///     g.remove_edge(edge_id);/// assert!(!is_cyclic_directed(&g));/// [feedback arc set]: https://en.wikipedia.org/wiki/Feedback_arc_set/// [greedy heuristic algorithm]: https://doi.org/10.1016/0020-0190(93)90079-Ogood_node_sequenceNodeLinkedListFasNodeFasNodeContainerFasNodeIndexsinks_or_isolatedbidirectional_pve_dd/// Bidirectional nodes with positive-or-0 delta degreebidirectional_nve_dd/// Bidirectional nodes with negative delta degree (index 0 is -1 dd, 1 is -2 etc)graph_ix/// Node index in input graph.out_edges/// All outward edges from this node (not removed during processing)in_edges/// All inward edges from this node (not removed during processing)out_degree/// Current out-degree of this node (decremented during processing as connected nodes are/// removed)in_degree/// Current in-degree of this node (decremented during processing as connected nodes are/// Represents a node from the input graph, tracking its current delta degreesuitable_bucketupdate_neighbour_node_bucketstrim_bucket_listLinkedListPositionis_in_listpos_mut/// `remove_ix` **must** be a member of the list headed by `self`/// For debug purposesBoundedMeasurefloyd_warshall/// \[Generic\] [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm) is an algorithm for all pairs shortest path problem/// Compute shortest paths in a weighted graph with positive or negative edge weights (but with no negative cycles)/// * `graph`: graph with no negative cycle/// * `edge_cost`: closure that returns cost of a particular edge/// * `Ok`: (if graph contains no negative cycle) a hashmap containing all pairs shortest paths/// * `Err`: if graph contains negative cycle./// use petgraph::{prelude::*, Graph, Directed};/// use petgraph::algo::floyd_warshall;/// let a = graph.add_node(());///    (a, b),///    (a, c),///    (a, d),///    (b, c),///    (b, d),///    (c, d)/// let weight_map: HashMap<(NodeIndex, NodeIndex), i32> = [///    ((a, a), 0), ((a, b), 1), ((a, c), 4), ((a, d), 10),///    ((b, b), 0), ((b, c), 2), ((b, d), 2),///    ((c, c), 0), ((c, d), 2)/// //     ----- b --------/// //    |      ^         | 2/// //    |    1 |    4    v/// //  2 |      a ------> c/// //    |   10 |         | 2/// //    |      v         v/// //     --->  d <-------/// let inf = std::i32::MAX;/// let expected_res: HashMap<(NodeIndex, NodeIndex), i32> = [///    ((a, a), 0), ((a, b), 1), ((a, c), 3), ((a, d), 3),///    ((b, a), inf), ((b, b), 0), ((b, c), 2), ((b, d), 2),///    ((c, a), inf), ((c, b), inf), ((c, c), 0), ((c, d), 2),///    ((d, a), inf), ((d, b), inf), ((d, c), inf), ((d, d), 0),/// let res = floyd_warshall(&graph, |edge| {///     if let Some(weight) = weight_map.get(&(edge.source(), edge.target())) {///         *weight///         inf/// let nodes = [a, b, c, d];/// for node1 in &nodes {///     for node2 in &nodes {///         assert_eq!(res.get(&(*node1, *node2)).unwrap(), expected_res.get(&(*node1, *node2)).unwrap());EdgeIndexableIntoEdgesDirectedPositiveMeasureresidual_capacityother_endpoint/// Gets the other endpoint of graph edge, if any, otherwise panics.has_augmented_path/// Tells whether there is an augmented path in the graphadjust_residual_flowford_fulkerson/// \[Generic\] Ford-Fulkerson algorithm./// Computes the [maximum flow][ff] of a weighted directed graph./// If it terminates, it returns the maximum flow and also the computed edge flows./// [ff]: https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm/// use petgraph::algo::ford_fulkerson;/// // Example from CLRS book/// let mut graph = Graph::<u8, u8>::new();/// let source = graph.add_node(0);/// let _ = graph.add_node(1);/// let _ = graph.add_node(2);/// let _ = graph.add_node(3);/// let _ = graph.add_node(4);/// let destination = graph.add_node(5);///    (0, 1, 16),///    (0, 2, 13),///    (1, 2, 10),///    (1, 3, 12),///    (2, 1, 4),///    (2, 4, 14),///    (3, 2, 9),///    (3, 5, 20),///    (4, 3, 7),///    (4, 5, 4),/// let (max_flow, _) = ford_fulkerson(&graph, source, destination);/// assert_eq!(23, max_flow);IntoNeighborsDirectedsemanticEdgeMatcherNoSemanticMatchNodeMatcherVf2State/// A reference to the graph this state was built from./// The current mapping M(s) of nodes from G0 → G1 and G1 → G0,/// `usize::MAX` for no mapping./// out[i] is non-zero if i is in either M_0(s) or Tout_0(s)/// These are all the next vertices that are not mapped yet, but/// have an outgoing edge from the mapping./// ins[i] is non-zero if i is in either M_0(s) or Tin_0(s)/// These are all the incoming vertices, those not mapped yet, but/// have an edge from them into the mapping./// Unused if graph is undirected -- it's identical with out in that case.ins_size// TODO: make mapping generic over the index type of the other graph./// Return **true** if we have a complete mappingpush_mapping/// Add mapping **from** <-> **to** to the state.pop_mapping/// Restore the state to before the last added mappingnext_out_index/// Find the next (least) node in the Tout set.next_in_index/// Find the next (least) node in the Tin set.next_rest_index/// Find the next (least) node in the N - M set.G0OpenListopen_listUnwindNMis_feasiblenext_candidatenext_from_ixtry_match/// Return Some(bool) if isomorphism is decided, else None.isomorphismsnode_matchedge_matchmatch_subgraphGraphMatcheris_isomorphic/// \[Generic\] Return `true` if the graphs `g0` and `g1` are isomorphic./// Using the VF2 algorithm, only matching graph syntactically (graph/// The graphs should not be multigraphs./// **Reference**/// * Luigi P. Cordella, Pasquale Foggia, Carlo Sansone, Mario Vento;///   *A (Sub)Graph Isomorphism Algorithm for Matching Large Graphs*is_isomorphic_matching/// Using the VF2 algorithm, examining both syntactic and semantic/// graph isomorphism (graph structure and matching node and edge weights).is_isomorphic_subgraph/// \[Generic\] Return `true` if `g0` is isomorphic to a subgraph of `g1`./// # Subgraph isomorphism/// (adapted from [`networkx` documentation](https://networkx.github.io/documentation/stable/reference/algorithms/isomorphism.vf2.html))/// Graph theory literature can be ambiguous about the meaning of the above statement,/// and we seek to clarify it now./// In the VF2 literature, a mapping **M** is said to be a *graph-subgraph isomorphism*/// iff **M** is an isomorphism between **G2** and a subgraph of **G1**. Thus, to say/// that **G1** and **G2** are graph-subgraph isomorphic is to say that a subgraph of/// **G1** is isomorphic to **G2**./// Other literature uses the phrase ‘subgraph isomorphic’ as in/// ‘**G1** does not have a subgraph isomorphic to **G2**’. Another use is as an in adverb/// for isomorphic. Thus, to say that **G1** and **G2** are subgraph isomorphic is to say/// that a subgraph of **G1** is isomorphic to **G2**./// Finally, the term ‘subgraph’ can have multiple meanings. In this context,/// ‘subgraph’ always means a ‘node-induced subgraph’. Edge-induced subgraph/// isomorphisms are not directly supported. For subgraphs which are not/// induced, the term ‘monomorphism’ is preferred over ‘isomorphism’.is_isomorphic_subgraph_matchingsubgraph_isomorphisms_iter/// Using the VF2 algorithm, examine both syntactic and semantic graph/// isomorphism (graph structure and matching node and edge weights) and,/// if `g0` is isomorphic to a subgraph of `g1`, return the mappings betweenk_shortest_path/// \[Generic\] k'th shortest path algorithm./// Compute the length of the k'th shortest path from `start` to every reachable/// Computes in **O(k * (|E| + |V|*log(|V|)))** time (average)./// use petgraph::algo::k_shortest_path;/// let mut graph : Graph<(),(),Directed>= Graph::new();///     (h, e)///      (a, 7),///      (b, 4),///      (c, 5),///      (d, 6),///      (e, 5),///      (f, 6),///      (g, 7),///      (h, 8)///     ].iter().cloned().collect();/// let res = k_shortest_path(&graph,b,None,2, |_| 1);maten_edgesMatching/// Computed/// [*matching*](https://en.wikipedia.org/wiki/Matching_(graph_theory)#Definitions)/// of the graph./// Gets the matched counterpart of given node, if there is any./// Returns `None` if the node is not matched or does not exist.MatchedEdges/// Iterates over all edges from the matching./// An edge is represented by its endpoints. The graph is considered/// undirected and every pair of matched nodes is reported only once.MatchedNodes/// Iterates over all nodes from the matching./// Returns `true` if given edge is in the matching, or `false` otherwise./// If any of the nodes does not exist, `false` is returned.contains_node/// Returns `true` if given node is in the matching, or `false` otherwise./// If the node does not exist, `false` is returned./// Gets the number of matched **edges**./// Returns `true` if the number of matched **edges** is 0.is_perfect/// Returns `true` if the matching is perfect./// A matching is/// [*perfect*](https://en.wikipedia.org/wiki/Matching_(graph_theory)#Definitions)/// if every node in the graph is incident to an edge from the matching.dummy_idxnode_bound_with_dummytry_from_index/// Convert `i` to a node index, returns None for the dummy nodeWithDummygreedy_matching/// \[Generic\] Compute a/// [*matching*](https://en.wikipedia.org/wiki/Matching_(graph_theory)) using a/// greedy heuristic./// The input graph is treated as if undirected. The underlying heuristic is/// unspecified, but is guaranteed to be bounded by *O(|V| + |E|)*. No/// guarantees about the output are given other than that it is a valid/// matching./// If you require a maximum matching, use [`maximum_matching`][1] function/// [1]: fn.maximum_matching.htmlgreedy_matching_innernon_backtracking_dfsVertex// If node v is outer node, then label(v) = w is another outer node on path// from v to start u.// If node v is outer node, then label(v) = (r, s) are two outer vertices// (connected by an edge)// Flag is a special label used in searching for the join vertex of two// paths.is_outeris_innerto_vertexis_flaggedmaximum_matching/// \[Generic\] Compute the [*maximum/// matching*](https://en.wikipedia.org/wiki/Matching_(graph_theory)) using/// [Gabow's algorithm][1]./// [1]: https://dl.acm.org/doi/10.1145/321941.321942/// The input graph is treated as if undirected. The algorithm runs in/// *O(|V|³)*. An algorithm with a better time complexity might be used in the/// **Panics** if `g.node_bound()` is `std::usize::MAX`./// use petgraph::algo::maximum_matching;/// // The example graph:/// //    +-- b ---- d ---- f/// //   /    |      |/// //  a     |      |/// //   \    |      |/// //    +-- c ---- e/// // Maximum matching: { (a, b), (c, e), (d, f) }/// let mut graph: UnGraph<(), ()> = UnGraph::new_undirected();/// graph.extend_with_edges(&[(a, b), (a, c), (b, c), (b, d), (c, e), (d, e), (d, f)]);/// let matching = maximum_matching(&graph);/// assert!(matching.contains_edge(a, b));/// assert!(matching.contains_edge(c, e));/// assert_eq!(matching.mate(d), Some(f));/// assert_eq!(matching.mate(f), Some(d));find_joinaugment_pathunionfindUnionFindmin_spanning_treeMinSpanningTree/// \[Generic\] Compute a *minimum spanning tree* of a graph./// The input graph is treated as if undirected./// Using Kruskal's algorithm with runtime **O(|E| log |E|)**. We actually/// return a minimum spanning forest, i.e. a minimum spanning tree for each connected/// component of the graph./// The resulting graph has all the vertices of the input graph (with identical node indices),/// and **|V| - c** edges, where **c** is the number of connected components in `g`./// Use `from_elements` to create a graph from the resulting iterator.node_idssubgraphssort_edgesnode_map/// An iterator producing a minimum spanning forest of a graph.//! Minimum Spanning Tree algorithms.feedback_arc_setisomorphismpage_ranksimple_pathstredGraphRefReversedall_simple_pathsconnected_components/// \[Generic\] Return the number of connected components of the graph./// For a directed graph, this is the *weakly* connected components./// use petgraph::algo::connected_components;/// // a ----> b       e ----> f/// assert_eq!(connected_components(&graph),2);/// graph.add_edge(b,e,());/// assert_eq!(connected_components(&graph),1);is_cyclic_undirected/// \[Generic\] Return `true` if the input graph contains a cycle./// Always treats the input graph as if undirected.toposortDfsSpace/// \[Generic\] Perform a topological sort of a directed graph./// If the graph was acyclic, return a vector of nodes in topological order:/// each node is ordered before its successors./// Otherwise, it will return a `Cycle` error. Self loops are also cycles./// To handle graphs with cycles, use the scc algorithms or `DfsPostOrder`/// instead of this function./// If `space` is not `None`, it is used instead of creating a new workspace for/// graph traversal. The implementation is iterative.is_cyclic_directed/// \[Generic\] Return `true` if the input directed graph contains a cycle./// This implementation is recursive; use `toposort` if an alternative isDfsSpaceTypedfsVMDfs/// Workspace for a graph traversal.with_dfs/// Create a Dfs if it's neededhas_path_connecting/// \[Generic\] Check if there exists a path starting at `from` and reaching `to`./// If `from` and `to` are equal, this function returns true./// graph traversal.scc/// Renamed to `kosaraju_scc`.kosaraju_scc/// \[Generic\] Compute the *strongly connected components* using [Kosaraju's algorithm][1]./// [1]: https://en.wikipedia.org/wiki/Kosaraju%27s_algorithm/// Return a vector where each element is a strongly connected component (scc)./// The order of node ids within each scc is arbitrary, but the order of/// the sccs is their postorder (reverse topological sort)./// For an undirected graph, the sccs are simply the connected components./// This implementation is iterative and does two passes over the nodes.rootindexNodeDatacomponentcountTarjanScc/// A reusable state for computing the *strongly connected components* using [Tarjan's algorithm][1]./// [1]: https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm/// Creates a new `TarjanScc`/// \[Generic\] Compute the *strongly connected components* using Algorithm 3 in/// [A Space-Efficient Algorithm for Finding Strongly Connected Components][1] by David J. Pierce,/// which is a memory-efficient variation of [Tarjan's algorithm][2]./// [1]: https://homepages.ecs.vuw.ac.nz/~djp/files/P05.pdf/// [2]: https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm/// Calls `f` for each strongly strongly connected component (scc)./// This implementation is recursive and does one pass over the nodes.node_component_index/// Returns the index of the component in which v has been assigned. Allows for using self as a lookup table for an scc decomposition produced by self.run().tarjan_scc/// \[Generic\] Compute the *strongly connected components* using [Tarjan's algorithm][1]./// [2]: https://homepages.ecs.vuw.ac.nz/~djp/files/P05.pdf/// This implementation is recursive and does one pass over the nodes. It is based on/// [A Space-Efficient Algorithm for Finding Strongly Connected Components][2] by David J. Pierce,/// to provide a memory-efficient implementation of [Tarjan's algorithm][1].condensation/// [Graph] Condense every strongly connected component into a single node and return the result./// If `make_acyclic` is true, self-loops and multi edges are ignored, guaranteeing that/// the output is acyclic./// use petgraph::algo::condensation;/// let mut graph : Graph<(),(),Directed> = Graph::new();/// let condensed_graph = condensation(graph,false);/// let A = NodeIndex::new(0);/// let B = NodeIndex::new(1);/// assert_eq!(condensed_graph.node_count(), 2);/// assert_eq!(condensed_graph.edge_count(), 9);/// assert_eq!(condensed_graph.neighbors(A).collect::<Vec<_>>(), vec![A, A, A, A]);/// assert_eq!(condensed_graph.neighbors(B).collect::<Vec<_>>(), vec![A, B, B, B, B]);/// If `make_acyclic` is true, self-loops and multi edges are ignored:/// # use petgraph::Graph;/// # use petgraph::algo::condensation;/// # use petgraph::prelude::*;/// # let mut graph : Graph<(),(),Directed> = Graph::new();/// # let a = graph.add_node(()); // node with no weight/// # let b = graph.add_node(());/// # let c = graph.add_node(());/// # let d = graph.add_node(());/// # let e = graph.add_node(());/// # let f = graph.add_node(());/// # let g = graph.add_node(());/// # let h = graph.add_node(());/// # graph.extend_with_edges(&[/// #    (a, b),/// #    (b, c),/// #    (c, d),/// #    (d, a),/// #    (b, e),/// #    (e, f),/// #    (f, g),/// #    (g, h),/// #    (h, e)/// let acyclic_condensed_graph = condensation(graph, true);/// assert_eq!(acyclic_condensed_graph.node_count(), 2);/// assert_eq!(acyclic_condensed_graph.edge_count(), 1);/// assert_eq!(acyclic_condensed_graph.neighbors(B).collect::<Vec<_>>(), vec![A]);/// An algorithm error: a cycle was found in the graph.node_id/// Return a node id that participates in the cycle/// An algorithm error: a cycle of negative weights was found in the graph.is_bipartite_undirected/// Return `true` if the graph is bipartite. A graph is bipartite if its nodes can be divided into/// two disjoint and indepedent sets U and V such that every edge connects U to one in V. This/// algorithm implements 2-coloring algorithm based on the BFS algorithm./// Associated data that can be used for measures (such as length).infinite/// A floating-point measure.impl_bounded_measure_integerimpl_bounded_measure_floatdefault_tolUnitMeasure/// A floating-point measure that can be computed from `usize`/// and with a default measure of proximity.  impl_unit_measure/// Some measure of positive numbers, assuming positive/// float-pointing numbersimpl_positive_measure//! Graph algorithms.//! It is a goal to gradually migrate the algorithms to be based on graph traits//! so that they are generally applicable. For now, some of these still require//! the `Graph` type./// \[Generic\] Page Rank algorithm./// Computes the ranks of every node in a graph using the [Page Rank algorithm][pr]./// Returns a `Vec` container mapping each node index to its rank./// The damping factor should be a number of type `f32` or `f64` between 0 and 1 (0 and 1 included). Otherwise, it panics./// Time complexity is **O(N|V|²|E|)**./// Space complexity is **O(|V| + |E|)**/// where **N** is the number of iterations, **|V|** the number of vertices (i.e nodes) and **|E|** the number of edges./// [pr]: https://en.wikipedia.org/wiki/PageRank/// use petgraph::algo::page_rank;/// let mut g: Graph<(), usize> = Graph::new();/// assert_eq!(page_rank(&g, 0.5_f64, 1), vec![]); // empty graphs have no node ranks./// let a = g.add_node(());/// g.extend_with_edges(&[(0, 1), (0, 3), (1, 2), (1, 3)]);/// // With the following dot representation./// //digraph {/// //    0 [ label = "()" ]/// //    1 [ label = "()" ]/// //    2 [ label = "()" ]/// //    3 [ label = "()" ]/// //    4 [ label = "()" ]/// //    0 -> 1 [ label = "0.0" ]/// //    0 -> 3 [ label = "0.0" ]/// //    1 -> 2 [ label = "0.0" ]/// //    1 -> 3 [ label = "0.0" ]/// //}/// let damping_factor = 0.7_f32;/// let number_iterations = 10;/// let output_ranks = page_rank(&g, damping_factor, number_iterations);/// let expected_ranks = vec![0.14685437, 0.20267677, 0.22389607, 0.27971846, 0.14685437];/// assert_eq!(expected_ranks, output_ranks);out_edges_infoTargetColl/// Returns an iterator that produces all simple paths from `from` node to `to`, which contains at least `min_intermediate_nodes` nodes/// and at most `max_intermediate_nodes`, if given, or limited by the graph's order otherwise. The simple path is a path without repetitions./// This algorithm is adapted from <https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.simple_paths.all_simple_paths.html>./// use petgraph::{algo, prelude::*};/// let mut graph = DiGraph::<&str, i32>::new();/// let a = graph.add_node("a");/// let b = graph.add_node("b");/// let c = graph.add_node("c");/// let d = graph.add_node("d");/// graph.extend_with_edges(&[(a, b, 1), (b, c, 1), (c, d, 1), (a, b, 1), (b, d, 1)]);/// let ways = algo::all_simple_paths::<Vec<_>, _>(&graph, a, d, 0, None)///   .collect::<Vec<_>>();/// assert_eq!(4, ways.len());DiGraphtest_all_simple_pathstest_one_simple_pathtest_no_simple_pathsadjdag_to_toposorted_adjacency_list/// Creates a representation of the same graph respecting topological order for use in `tred::dag_transitive_reduction_closure`./// `toposort` must be a topological order on the node indices of `g` (for example obtained/// from [`toposort`])./// [`toposort`]: ../fn.toposort.html/// Returns a pair of a graph `res` and the reciprocal of the topological sort `revmap`./// `res` is the same graph as `g` with the following differences:/// * Node and edge weights are stripped,/// * Node indices are replaced by the corresponding rank in `toposort`,/// * Iterating on the neighbors of a node respects topological order./// `revmap` is handy to get back to map indices in `g` to indices in `res`./// use petgraph::graph::DefaultIx;/// use petgraph::visit::IntoNeighbors;/// use petgraph::algo::tred::dag_to_toposorted_adjacency_list;/// let mut g = Graph::<&str, (), Directed, DefaultIx>::new();/// let second = g.add_node("second child");/// let top = g.add_node("top");/// let first = g.add_node("first child");/// g.extend_with_edges(&[(top, second), (top, first), (first, second)]);/// let toposort = vec![top, first, second];/// let (res, revmap) = dag_to_toposorted_adjacency_list(&g, &toposort);/// // let's compute the children of top in topological order/// let children: Vec<NodeIndex> = res///     .neighbors(revmap[top.index()])///     .map(|ix: NodeIndex| toposort[ix.index()])/// assert_eq!(children, vec![first, second])/// Runtime: **O(|V| + |E|)**./// Space complexity: **O(|V| + |E|)**.dag_transitive_reduction_closure/// Computes the transitive reduction and closure of a DAG./// The algorithm implemented here comes from [On the calculation of/// transitive reduction-closure of/// orders](https://www.sciencedirect.com/science/article/pii/0012365X9390164O) by Habib, Morvan/// and Rampon./// The input graph must be in a very specific format: an adjacency/// list such that:/// * Node indices are a toposort, and/// * The neighbors of all nodes are stored in topological order./// To get such a representation, use the function [`dag_to_toposorted_adjacency_list`]./// [`dag_to_toposorted_adjacency_list`]: ./fn.dag_to_toposorted_adjacency_list.html/// The output is the pair of the transitive reduction and the transitive closure./// Runtime complexity: **O(|V| + \sum_{(x, y) \in Er} d(y))** where **d(y)**/// denotes the outgoing degree of **y** in the transitive closure of **G**./// This is still **O(|V|³)** in the worst case like the naive algorithm but/// should perform better for some classes of graphs./// Space complexity: **O(|E|)**.test_easy_tred//! Compute the transitive reduction and closure of a directed acyclic graph//! ## Transitive reduction and closure//! The *transitive closure* of a graph **G = (V, E)** is the graph **Gc = (V, Ec)**//! such that **(i, j)** belongs to **Ec** if and only if there is a path connecting//! **i** to **j** in **G**. The *transitive reduction* of **G** is the graph **Gr//! = (V, Er)** such that **Er** is minimal wrt. inclusion in **E** and the transitive//! closure of **Gr** is the same as that of **G**.//! The transitive reduction is well-defined for acyclic graphs only.IntoWeightedEdge/// Csr node index type, a plain integer./// Csr edge index type, a plain integer.BINARY_SEARCH_CUTOFF/// Column of next edge/// weight of each edge; lock step with column/// Index of start of row Always node_count + 1 long./// Last element is always equal to column.len()node_weightsCsr/// Compressed Sparse Row ([`CSR`]) is a sparse adjacency matrix graph./// `CSR` is parameterized over:/// - Associated data `N` for nodes and `E` for edges, called *weights*.///   The associated data can be of arbitrary type./// - Edge type `Ty` that determines whether the graph edges are directed or undirected./// - Index type `Ix`, which determines the maximum size of the graph./// Using **O(|E| + |V|)** space./// Self loops are allowed, no parallel edges./// Fast iteration of the outgoing edges of a vertex./// [`CSR`]: https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)/// Create an empty `Csr`.with_nodes/// Create a new `Csr` with `n` nodes. `N` must implement [`Default`] for the weight of each node./// [`Default`]: https://doc.rust-lang.org/nightly/core/default/trait.Default.html/// use petgraph::csr::Csr;/// let graph = Csr::<u8,()>::with_nodes(5);/// assert_eq!(graph.node_count(),5);/// assert_eq!(graph.edge_count(),0);/// assert_eq!(graph[0],0);/// assert_eq!(graph[4],0);EdgesNotSorted/// Csr creation error: edges were not in sorted order.from_sorted_edges/// Create a new `Csr` from a sorted sequence of edges/// Edges **must** be sorted and unique, where the sort order is the default/// order for the pair *(u, v)* in Rust (*u* has priority)./// Computes in **O(|E| + |V|)** time./// let graph = Csr::<(),()>::from_sorted_edges(&[///                     (0, 1), (0, 2),///                     (1, 0), (1, 2), (1, 3),///                     (2, 0),///                     (3, 1),clear_edges/// Remove all edges/// Adds a new node with the given weight, returning the corresponding node index./// Return `true` if the edge was added/// If you add all edges in row-major order, the time complexity/// is **O(|V|·|E|)** for the whole operation./// **Panics** if `a` or `b` are out of bounds.add_edge_// Return false if the edge already existsfind_edge_pos/// Computes in **O(log |V|)** time./// **Panics** if the node `a` does not exist.neighbors_rangeneighbors_ofneighbors_sliceedges_slice/// Return an iterator of all edges of `a`./// - `Directed`: Outgoing edges from `a`./// - `Undirected`: All edges connected to `a`./// **Panics** if the node `a` does not exist.<br>/// Iterator element type is `EdgeReference<E, Ty, Ix>`./// Access the edge’s weight./// **NOTE** that this method offers a longer lifetime/// than the trait (unfortunately they don't match yet).source_indexedge_ranges// index into edges vector/// Return an iterator of all neighbors of `a`./// - `Directed`: Targets of outgoing edges from `a`./// - `Undirected`: Opposing endpoints of all edges connected to `a`./// Iterator element type is `NodeIndex<Ix>`./// Iterator over all nodes of a graph./// The adjacency matrix for **Csr** is a bitmap that's computed byUndirectedcsr1csr_undirectedcsr_from_error_1csr_from_error_2csr_fromcsr_dfscsr_tarjantest_bellman_fordtest_bellman_ford_neg_cycletest_find_neg_cycle1test_find_neg_cycle2test_find_neg_cycle3test_find_neg_cycle4test_edge_referencestest_add_nodetest_add_node_with_existing_edgestest_node_references//! Compressed Sparse Row (CSR) is a sparse adjacency matrix graph./*
 *
Example

[ a 0 b
  c d e
  0 0 f ]

Values: [a, b, c, d, e, f]
Column: [0, 2, 0, 1, 2, 2]
Row   : [0, 2, 5]   <- value index of row start

 * */graphmapGraphMapNodeTraitstable_graphStableGraphtrait_templateremove_sections_innerr" Access node and edge weights (associated data)."access0delegate_implr" Access node and edge weights mutably."/// Add a new edge. If parallel edges (duplicate) are not allowed and/// the edge already exists, return `None`./// Add or update the edge from `a` to `b`. Return the id of the affected/// A graph that can be extended with further nodes and edges/// A graph that can be created/// A graph node./// A graph edge./// A graph element./// A sequence of Elements, for example an iterator, is laid out as follows:/// Nodes are implicitly given the index of their appearance in the sequence./// The edges’ source and target fields refer to these indices.from_elementsFromElements/// Create a graph from an iterator of elements.from_elements_indexablefilter_elementsFilterElements/// Create an iterator adaptor that filters graph elements./// The function `f` is called with each element and if its return value/// is `true` the element is accepted and if `false` it is removed./// `f` is called with mutable references to the node and edge weights,/// so that they can be mutated (but the edge endpoints can not)./// This filter adapts the edge source and target indices in the/// stream so that they are correct after the removals.ElementIterator/// Iterator adaptors for iterators of `Element`.node_index/// An iterator that filters graph elements./// See [`.filter_elements()`][1] for more information./// [1]: trait.ElementIterator.html#method.filter_elements//! Graph traits for associated data and graph construction.get_edge_attributesget_node_attributesConfigs/// `Dot` implements output to graphviz .dot format for a graph./// Formatting and options are rather simple, this is mostly intended/// for debugging. Exact output may change./// use petgraph::dot::{Dot, Config};/// let mut graph = Graph::<_, ()>::new();/// graph.add_node("A");/// graph.add_node("B");/// graph.add_node("C");/// graph.add_node("D");///     (0, 1), (0, 2), (0, 3),///     (1, 2), (1, 3),/// println!("{:?}", Dot::with_config(&graph, &[Config::EdgeNoLabel]));/// // In this case the output looks like this:/// // digraph {/// //     0 [label="\"A\""]/// //     1 [label="\"B\""]/// //     2 [label="\"C\""]/// //     3 [label="\"D\""]/// //     0 -> 1/// //     0 -> 2/// //     0 -> 3/// //     1 -> 2/// //     1 -> 3/// //     2 -> 3/// // If you need multiple config options, just list them all in the slice.EDGEINDENT/// Create a `Dot` formatting wrapper with default configuration.with_config/// Create a `Dot` formatting wrapper with custom configuration.with_attr_gettersNodeIndexLabel/// Use indices for node labels.EdgeIndexLabel/// Use indices for edge labels.EdgeNoLabel/// Use no edge labels.NodeNoLabel/// Use no node labels.GraphContentOnly/// Do not print the graph/digraph string._Incomplete/// `Dot` configuration./// This enum does not have an exhaustive definition (will be expanded)// TODO: #[non_exhaustive] once MSRV >= 1.40,// and/or for a breaking change make this something like an EnumSet: https://docs.rs/enumsetmake_config_structgraph_fmtEscaper/// Escape for Graphviz/// Pass Display formatting through a simple escaping filterFnFmt/// Format data using a specific format functiontest_escapesimple_graphtest_nodeindexlable_optiontest_edgeindexlable_optiontest_edgenolable_optiontest_nodenolable_optiontest_with_attr_getters//! Simple graphviz dot file format output.acyclicselfloopsnedges/// number of possible edges/// current edge bitmap/// A graph generator of “all” graphs of a particular size./// ***Unstable: API may change at any time.*** Depends on `feature = "generate"`.directed_acyclic/// Generate all possible Directed acyclic graphs (DAGs) of a particular number of vertices./// These are only generated with one per isomorphism, so they use/// one canonical node labeling where node *i* can only have edges to node *j* if *i < j*./// For a graph of *k* vertices there are *e = (k - 1) k / 2* possible edges and/// *2<sup>e</sup>* DAGs./// Generate all possible graphs of a particular number of vertices./// All permutations are generated, so the graphs are not unique down to isomorphism./// For a graph of *k* vertices there are *e = k²* possible edges and/// *2<sup>k<sup>2</sup></sup>* graphs.state_to_graphnext_ref//! ***Unstable.*** Graph generation.//! ***Unstable: API may change at any time.*** Depends on `feature = "generate"`.// A DAG has the property that the adjacency matrix is lower triangular,// diagonal zero.// This means we only allow edges i → j where i < j.// The set of all DAG of a particular size is simply the power set of all// possible edges.// For a graph of n=3 nodes we have (n - 1) * n / 2 = 3 possible edges./// Create a new `Frozen` from a mutable reference to a graph./// Deref allows transparent access to all shared reference (read-only)/// functionality in the underlying graph.index_twice_mut/// Index the `Graph` by two indices, any combination of/// node or edge indices is fine./// **Panics** if the indices are equal or if they are out of bounds.EdgesDirectededges_directedNeighborsDirectedneighbors_directededge_boundIterFormatExt/// The default integer type for graph indices./// `u32` is the default to reduce the size of the graph's data and improve/// performance in the common case./// Used for node and edge indices in `Graph` and `StableGraph`, used/// for node indices in `Csr`./// Trait for the unsigned integer type used for node and edge indices./// Marked `unsafe` because: the trait must faithfully preserve/// and convert index values./// Node identifier._into_edge/// Short version of `NodeIndex::new`edge_index/// Short version of `EdgeIndex::new`/// Edge identifier./// An invalid `EdgeIndex` used to denote absence of an edge, for example/// to end an adjacency list._into_nodeDIRECTIONS/// Associated node data./// Next edge in outgoing and incoming edge lists./// The graph's node type.next_edge/// Accessor for data structure internals: the first edge in the given direction./// Associated edge data./// Start and End node index/// The graph's edge type./// Accessor for data structure internals: the next edge for the given direction./// Return the source node index./// Return the target node index./// `Graph<N, E, Ty, Ix>` is a graph datastructure using an adjacency list representation./// `Graph` is parameterized over:/// The `Graph` is a regular Rust collection and is `Send` and `Sync` (as long/// as associated data `N` and `E` are)./// The graph uses **O(|V| + |E|)** space, and allows fast node and edge insert,/// efficient graph search and graph algorithms./// It implements **O(e')** edge lookup and edge and node removals, where **e'**/// is some local measure of edge count./// Based on the graph datastructure used in rustc./// Here's an example of building a graph with directed edges, and below/// an illustration of how it could be rendered with graphviz (see/// [`Dot`](../dot/struct.Dot.html)):/// let mut deps = Graph::<&str, &str>::new();/// let pg = deps.add_node("petgraph");/// let fb = deps.add_node("fixedbitset");/// let qc = deps.add_node("quickcheck");/// let rand = deps.add_node("rand");/// let libc = deps.add_node("libc");/// deps.extend_with_edges(&[///     (pg, fb), (pg, qc),///     (qc, rand), (rand, libc), (qc, libc),/// ![graph-example](https://bluss.github.io/ndarray/images/graph-example.svg)/// ### Graph Indices/// The graph maintains indices for nodes and edges, and node and edge/// weights may be accessed mutably. Indices range in a compact interval, for/// example for *n* nodes indices are 0 to *n* - 1 inclusive./// `NodeIndex` and `EdgeIndex` are types that act as references to nodes and edges,/// but these are only stable across certain operations:/// * **Removing nodes or edges may shift other indices.** Removing a node will/// force the last node to shift its index to take its place. Similarly,/// removing an edge shifts the index of the last edge./// * Adding nodes or edges keeps indices stable./// The `Ix` parameter is `u32` by default. The goal is that you can ignore this parameter/// completely unless you need a very big graph -- then you can use `usize`./// * The fact that the node and edge indices in the graph each are numbered in compact/// intervals (from 0 to *n* - 1 for *n* nodes) simplifies some graph algorithms./// * You can select graph index integer type after the size of the graph. A smaller/// size may have better performance./// * Using indices allows mutation while traversing the graph, see `Dfs`,/// and `.neighbors(a).detach()`./// * You can create several graphs using the equal node indices but with/// differing weights or differing edges./// * Indices don't allow as much compile time checking as references./// A `Graph` with directed edges./// For example, an edge from *1* to *2* is distinct from an edge from *2* to/// *1*.UnGraph/// A `Graph` with undirected edges./// For example, an edge between *1* and *2* is equivalent to an edge between/// *2* and *1*./// The resulting cloned graph has the same graph indices as `self`.index_twice/// Get mutable references at index `a` and `b`./// Create a new `Graph` with directed edges./// This is a convenience method. Use `Graph::with_capacity` or `Graph::default` for/// a constructor that is generic in all the type parameters of `Graph`.new_undirected/// Create a new `Graph` with undirected edges./// Create a new `Graph` with estimated capacity./// Return the number of nodes (vertices) in the graph./// Return the number of edges in the graph./// Whether the graph has directed edges or not./// Add a node (also called vertex) with associated data `weight` to the graph./// Return the index of the new node./// **Panics** if the Graph is at the maximum number of nodes for its index/// type (N/A if usize)./// Access the weight for node `a`./// If node `a` doesn't exist in the graph, return `None`./// Also available with indexing syntax: `&graph[a]`./// Access the weight for node `a`, mutably./// Also available with indexing syntax: `&mut graph[a]`./// **Panics** if any of the nodes don't exist.<br>/// **Panics** if the Graph is at the maximum number of edges for its index/// **Note:** `Graph` allows adding parallel (“duplicate”) edges. If you want/// Add or update an edge from `a` to `b`./// If the edge already exists, its weight is updated./// Return the index of the affected edge./// Computes in **O(e')** time, where **e'** is the number of edges/// connected to `a` (and `b`, if the graph edges are undirected)./// **Panics** if any of the nodes doesn't exist./// Access the weight for edge `e`./// If edge `e` doesn't exist in the graph, return `None`./// Also available with indexing syntax: `&graph[e]`./// Access the weight for edge `e`, mutably./// Also available with indexing syntax: `&mut graph[e]`./// Access the source and target nodes for `e`.remove_node/// Remove `a` from the graph if it exists, and return its weight./// If it doesn't exist in the graph, return `None`./// Apart from `a`, this invalidates the last node index in the graph/// (that node will adopt the removed node index). Edge indices are/// invalidated as they would be following the removal of each edge/// with an endpoint in `a`./// Computes in **O(e')** time, where **e'** is the number of affected/// edges, including *n* calls to `.remove_edge()` where *n* is the number/// of edges with an endpoint in `a`, and including the edges with an/// endpoint in the displaced node.change_edge_links/// For edge `e` with endpoints `edge_node`, replace links to it,/// with links to `edge_next`.remove_edge/// Remove an edge and return its edge weight, or `None` if it didn't exist./// Apart from `e`, this invalidates the last edge index in the graph/// (that edge will adopt the removed edge index)./// Computes in **O(e')** time, where **e'** is the size of four particular edge lists, for/// the vertices of `e` and the vertices of another affected edge.remove_edge_adjust_indices/// Return an iterator of all nodes with an edge starting from `a`./// - `Undirected`: All edges from or to `a`./// Produces an empty iterator if the node doesn't exist.<br>/// Use [`.neighbors(a).detach()`][1] to get a neighbor walker that does/// not borrow from the graph./// [1]: struct.Neighbors.html#method.detach/// Return an iterator of all neighbors that have an edge between them and/// `a`, in the specified direction./// If the graph's edges are undirected, this is equivalent to *.neighbors(a)*./// - `Directed`, `Outgoing`: All edges from `a`./// - `Directed`, `Incoming`: All edges to `a`./// For a `Directed` graph, neighbors are listed in reverse order of their/// addition to the graph, so the most recently added edge's neighbor is/// listed first. The order in an `Undirected` graph is arbitrary./// Use [`.neighbors_directed(a, dir).detach()`][1] to get a neighbor walker that doesneighbors_undirected/// `a`, in either direction./// - `Directed` and `Undirected`: All edges from or to `a`./// Use [`.neighbors_undirected(a).detach()`][1] to get a neighbor walker that does/// Iterator element type is `EdgeReference<E, Ix>`./// Return an iterator of all edges of `a`, in the specified direction./// - `Undirected`, `Outgoing`: All edges connected to `a`, with `a` being the source of each///   edge./// - `Undirected`, `Incoming`: All edges connected to `a`, with `a` being the target of each/// Produces an empty iterator if the node `a` doesn't exist.<br>edges_connectingEdgesConnecting/// Return an iterator over all the edges connecting `a` and `b`./// Lookup if there is an edge from `a` to `b`./// Lookup an edge from `a` to `b`.find_edge_directed_from_nodefind_edge_undirected/// Lookup an edge between `a` and `b`, in either direction./// If the graph is undirected, then this is equivalent to `.find_edge()`./// Return the edge index and its directionality, with `Outgoing` meaning/// from `a` to `b` and `Incoming` the reverse,/// or `None` if the edge does not exist.find_edge_undirected_from_nodeexternalsExternals/// Return an iterator over either the nodes without edges to them/// (`Incoming`) or from them (`Outgoing`)./// An *internal* node has both incoming and outgoing edges./// The nodes in `.externals(Incoming)` are the source nodes and/// `.externals(Outgoing)` are the sinks of the graph./// For a graph with undirected edges, both the sinks and the sources are/// just the nodes without edges./// The whole iteration computes in **O(|V|)** time./// Return an iterator over the node indices of the graph./// For example, in a rare case where a graph algorithm were not applicable,/// the following code will iterate through all nodes to find a/// specific index:/// # let mut g = Graph::<&str, i32>::new();/// # g.add_node("book");/// let index = g.node_indices().find(|i| g[*i] == "book").unwrap();node_weights_mutNodeWeightsMut/// Return an iterator yielding mutable access to all node weights./// The order in which weights are yielded matches the order of their/// node indices.NodeWeights/// Return an iterator yielding immutable access to all node weights./// Return an iterator over the edge indices of the graph/// Create an iterator over all edges, in indexed order.edge_weightsEdgeWeights/// Return an iterator yielding immutable access to all edge weights./// edge indices.edge_weights_mutEdgeWeightsMut/// Return an iterator yielding mutable access to all edge weights.raw_nodes/// Access the internal node array.raw_edges/// Access the internal edge array.into_nodes_edges/// Convert the graph into a vector of Nodes and a vector of Edgesfirst_edge/// use petgraph::{Graph, Incoming};/// use petgraph::visit::Dfs;/// let mut gr = Graph::new();/// let a = gr.add_node(0.);/// let b = gr.add_node(0.);/// let c = gr.add_node(0.);/// gr.add_edge(a, b, 3.);/// gr.add_edge(b, c, 2.);/// gr.add_edge(c, b, 1.);/// // walk the graph and sum incoming edges into the node weight/// let mut dfs = Dfs::new(&gr, a);/// while let Some(node) = dfs.next(&gr) {///     // use a walker -- a detached neighbors iterator///     let mut edges = gr.neighbors_directed(node, Incoming).detach();///     while let Some(edge) = edges.next_edge(&gr) {///         let (nw, ew) = gr.index_twice_mut(node, edge);///         *nw += *ew;/// // check the result/// assert_eq!(gr[a], 0.);/// assert_eq!(gr[b], 4.);/// assert_eq!(gr[c], 2.);/// Reverse the direction of all edges/// Remove all nodes and edges/// Return the current node and edge capacity of the graph.reserve_nodes/// Reserves capacity for at least `additional` more nodes to be inserted in/// the graph. Graph may reserve more space to avoid frequent reallocations./// **Panics** if the new capacity overflows `usize`.reserve_edges/// Reserves capacity for at least `additional` more edges to be inserted inreserve_exact_nodes/// Reserves the minimum capacity for exactly `additional` more nodes to be/// inserted in the graph. Does nothing if the capacity is already/// sufficient./// Prefer `reserve_nodes` if future insertions are expected.reserve_exact_edges/// Reserves the minimum capacity for exactly `additional` more edges to be/// inserted in the graph./// Does nothing if the capacity is already sufficient./// Prefer `reserve_edges` if future insertions are expected.shrink_to_fit_nodes/// Shrinks the capacity of the underlying nodes collection as much as possible.shrink_to_fit_edges/// Shrinks the capacity of the underlying edges collection as much as possible./// Shrinks the capacity of the graph as much as possible.retain_nodes/// Keep all nodes that return `true` from the `visit` closure,/// remove the others./// `visit` is provided a proxy reference to the graph, so that/// the graph can be walked and associated data modified./// The order nodes are visited is not specified.retain_edges/// Keep all edges that return `true` from the `visit` closure,/// The order edges are visited is not specified.from_edges/// Create a new `Graph` from an iterable of edges./// Node weights `N` are set to default values./// Edge weights `E` may either be specified in the list,/// or they are filled with default values./// Nodes are inserted automatically to match the edges./// let gr = Graph::<(), i32>::from_edges(&[extend_with_edges/// Extend the graph from an iterable of edges./// Create a new `Graph` by mapping node and/// edge weights to new values./// The resulting graph has the same structure and the same/// graph indices as `self`./// Create a new `Graph` by mapping nodes and edges./// A node or edge may be mapped to `None` to exclude it from/// the resulting graph./// Nodes are mapped first with the `node_map` closure, then/// `edge_map` is called for the edges that have not had any endpoint/// The resulting graph has the structure of a subgraph of the original graph./// If no nodes are removed, the resulting graph has compatible node/// indices; if neither nodes nor edges are removed, the result has/// the same graph indices as `self`.NewTyinto_edge_type/// Convert the graph into either undirected or directed. No edge adjustments/// are done, so you may want to go over the result to remove or add edges.// Remaining methods are of the more internal flavour, read-only access to// the data structure's internals./// An iterator over either the nodes without edges to them or from them.skip_start/// starting node to skip over/// Iterator over the neighbors of a node./// Created with [`.neighbors()`][1], [`.neighbors_directed()`][2] or/// [`.neighbors_undirected()`][3]./// [1]: struct.Graph.html#method.neighbors/// [2]: struct.Graph.html#method.neighbors_directed/// [3]: struct.Graph.html#method.neighbors_undirectedWalkNeighbors/// Return a “walker” object that can be used to step through the/// neighbors and edges from the origin node./// Note: The walker does not borrow from the graph, this is to allow mixing/// edge walking with mutating the graph's weights.EdgesWalkerMutedges_walker_mut/// Next edge to visit./// For directed graphs: the direction to iterate in/// For undirected graphs: the direction of edges/// Iterator over the edges of from or to a nodetarget_node/// Iterator over the multiple directed edges connecting a source node to a target nodeswap_pair/// Iterator yielding immutable access to all node weights.// TODO: change type to something that implements Clone?/// Iterator yielding mutable access to all node weights./// Iterator yielding immutable access to all edge weights./// Iterator yielding mutable access to all edge weights./// Index the `Graph` by `NodeIndex` to access node weights./// **Panics** if the node doesn't exist./// Index the `Graph` by `EdgeIndex` to access edge weights./// **Panics** if the edge doesn't exist./// Create a new empty `Graph`.is_node_index/// A `GraphIndex` is a node or edge index./// A “walker” object that can be used to step through the edge list of a node./// Created with [`.detach()`](struct.Neighbors.html#method.detach)./// The walker does not borrow from the graph, so it lets you step through/// neighbors or incident edges while also mutating graph weights, as/// in the following example:/// // step through the graph and sum incoming edges into the node weight///     // use a detached neighbors walker///         gr[node] += gr[edge];/// Step to the next edge and its endpoint node in the walk for graph `g`./// The next node indices are always the others than the starting point/// where the `WalkNeighbors` value was created./// For an `Outgoing` walk, the target nodes,/// for an `Incoming` walk, the source nodes of the edge.next_node/// Iterator over the node indices of a graph./// Iterator over the edge indices of a graph./// Reference to a `Graph` edge./// Iterator over all edges of a graph.frozen/// `Frozen` is a graph wrapper./// The `Frozen` only allows shared access (read-only) to the/// underlying graph `G`, but it allows mutable access to its/// node and edge weights./// This is used to ensure immutability of the graph's structure/// while permitting weights to be both read and written./// See indexing implementations and the traits `Data` and `DataMap`/// for read-write access to the graph's weights./*
 * FIXME: Use this impl again, when we don't need to add so many bounds
impl<Ix: IndexType> fmt::Debug for EdgeIndex<Ix>
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        try!(write!(f, "EdgeIndex("));
        if *self == EdgeIndex::end() {
            try!(write!(f, "End"));
        } else {
            try!(write!(f, "{}", self.index()));
        }
        write!(f, ")")
    }
}
*/serde_utilsCollectSeqWithLengthMappedSequenceVisitorFromDeserializedIntoSerializablenode_holesedge_propertyEdgePropertySerGraph/// Serialization representation for Graph/// Keep in sync with deserialization and StableGraph/// The serialization format is as follows, in Pseudorust:/// Graph {///     nodes: [N],///     node_holes: [NodeIndex<Ix>],///     edge_property: EdgeProperty,///     edges: [Option<(NodeIndex<Ix>, NodeIndex<Ix>, E)>]/// The same format is used by both Graph and StableGraph./// For graph there are restrictions:/// node_holes is always empty and edges are always Some/// A stable graph serialization that obeys these restrictions/// (effectively, it has no interior vacancies) can de deserialized/// as a graph./// Node indices are serialized as integers and are fixed size for/// binary formats, so the Ix parameter matters there.DeserGraph// Deserialization representation for Graph// Keep in sync with serialization and StableGraphfrom_deserializedser_graph_nodesser_graph_edgesdeser_graph_nodesdeser_graph_node_holesdeser_graph_edgesinto_serializable/// Requires crate feature `"serde-1"`invalid_node_errinvalid_hole_errinvalid_length_erriter_utilsIterUtilsExt// reexport those things that are shared with Graphfree_node// node and edge free lists (both work the same way)// free_node, if not NodeIndex::end(), points to a node index// that is vacant (after a deletion).// The free nodes form a doubly linked list using the fields Node.next[0]// for forward references and Node.next[1] for backwards ones.// The nodes are stored as EdgeIndex, and the _into_edge()/_into_node()// methods convert.// free_edge, if not EdgeIndex::end(), points to a free edge.// The edges only form a singly linked list using Edge.next[0] to store// the forward reference.free_edge/// `StableGraph<N, E, Ty, Ix>` is a graph datastructure using an adjacency/// list representation./// The graph **does not invalidate** any unrelated node or edge indices when/// items are removed./// `StableGraph` is parameterized over:/// - Associated data `N` for nodes and `E` for edges, also called *weights*./// The graph uses **O(|V| + |E|)** space, and allows fast node and edge insert/// and efficient graph search./// - Nodes and edges are each numbered in an interval from *0* to some number/// *m*, but *not all* indices in the range are valid, since gaps are formed/// by deletions./// - You can select graph index integer type after the size of the graph. A smaller/// - Using indices allows mutation while traversing the graph, see `Dfs`./// - The `StableGraph` is a regular rust collection and is `Send` and `Sync`/// (as long as associated data `N` and `E` are)./// - Indices don't allow as much compile time checking as references./// Depends on crate feature `stable_graph` (default). *Stable Graph is still/// missing a few methods compared to Graph. You can contribute to help it/// achieve parity.*StableDiGraph/// A `StableGraph` with directed edges.StableUnGraph/// A `StableGraph` with undirected edges./// Create a new `StableGraph` with directed edges./// This is a convenience method. See `StableGraph::with_capacity`/// or `StableGraph::default` for a constructor that is generic in all the/// type parameters of `StableGraph`./// Create a new `StableGraph` with estimated capacity./// **Panics** if the `StableGraph` is at the maximum number of nodes for/// its index type.add_vacant_node/// free_node: Which free list to update for the vacancy/// The node index `a` is invalidated, but none other./// Edge indices are invalidated as they would be following the removal of/// each edge with an endpoint in `a`./// of edges with an endpoint in `a`.get_node// Return the Node if it is not vacant (non-None weight)/// **Panics** if the `StableGraph` is at the maximum number of edges for/// **Note:** `StableGraph` allows adding parallel (“duplicate”) edges.add_vacant_edge/// free_edge: Which free list to update for the vacancy/// **Panics** if any of the nodes don't exist./// Invalidates the edge index `e` but no other./// connected to the same endpoints as `e`./// The order in which weights are yielded matches the order of their node/// Return an iterator over the node indices of the graph/// Access the weight for edge `e`, mutably/// The order in which weights are yielded matches the order of their edge/// Return an iterator of all neighbors that have an edge between them and `a`,/// in the specified direction./// in either direction./// - `Directed` and `Undirected`: All edges connected to `a`./// Index the `StableGraph` by two indices, any combination of/// The node indices of the removed nodes are invalidated, but none other./// each edge with an endpoint in a removed node./// Computes in **O(n + e')** time, where **n** is the number of node indices and///  **e'** is the number of affected edges, including *n* calls to `.remove_edge()`/// where *n* is the number of edges with an endpoint in a removed node./// The edge indices of the removed edes are invalidated, but none other./// Computes in **O(e'')** time, **e'** is the number of affected edges,/// including the calls to `.remove_edge()` for each removed edge./// Create a new `StableGraph` from an iterable of edges./// use petgraph::stable_graph::StableGraph;/// let gr = StableGraph::<(), i32>::from_edges(&[/// Create a new `StableGraph` by mapping node and/// Create a new `StableGraph` by mapping nodes and edges./// Nodes and edges that are not removed maintain their old node or edge// internal methodsoccupy_vacant_node/// Create a new node using a vacant position,/// updating the free nodes doubly linked list.ensure_node_exists/// Create the node if it does not exist,/// adding vacant nodes for padding if needed.check_free_lists/// Index the `StableGraph` by `NodeIndex` to access node weights./// Index the `StableGraph` by `EdgeIndex` to access edge weights./// Create a new empty `StableGraph`./// Convert a `Graph` into a `StableGraph`/// Computes in **O(|V| + |E|)** time./// The resulting graph has the same node and edge indices as/// the original graph./// Convert a `StableGraph` into a `Graph`/// This translates the stable graph into a graph with node and edge indices in/// a compact interval without holes (like `Graph`s always are)./// Only if the stable graph had no vacancies after deletions (if node bound was/// equal to node count, and the same for edges), would the resulting graph have/// the same node and edge indices as the input./// Reference to a `StableGraph` edge./// Iterator element type is `NodeIndex`./// See [*.detach()*](struct.Neighbors.html#method.detach) for more information./// use petgraph::Incoming;/// let mut gr = StableGraph::new();/// Return an upper bound of the node indices in the graph/// Create an iterator over all edges in the graph, in indexed order.test_retain_nodestest_reverse//! `StableGraph` keeps indices stable across removals.//! Depends on `feature = "stable_graph"`.serializationSomesHolesSerStableGraph// Serialization representation for StableGraph// Keep in sync with deserialization and GraphDeserStableGraph// Deserialization representation for StableGraph// Keep in sync with serialization and Graph/// `Somes` are the present node weights N, with known length./// Holes are the node indices of vacancies, with known lengthser_stable_graph_edgesdeser_stable_graph_nodesdeser_stable_graph_edgestest_from_deserialized_with_holesIndexMapIterIndexMapIterMutUnGraphMap/// A `GraphMap` with undirected edges.DiGraphMap/// A `GraphMap` with directed edges.CompactDirection/// `GraphMap<N, E, Ty>` is a graph datastructure using an associative array/// of its node weights `N`./// It uses an combined adjacency list and sparse adjacency matrix/// representation, using **O(|V| + |E|)** space, and allows testing for edge/// existence in constant time./// `GraphMap` is parameterized over:/// - The node weight `N` must implement `Copy` and will be used as node/// identifier, duplicated into several places in the data structure./// It must be suitable as a hash table key (implementing `Eq + Hash`)./// The node type must also implement `Ord` so that the implementation can/// order the pair (`a`, `b`) for an edge connecting any two nodes `a` and `b`./// - `E` can be of arbitrary type./// - Edge type `Ty` that determines whether the graph edges are directed or/// undirected./// You can use the type aliases `UnGraphMap` and `DiGraphMap` for convenience./// `GraphMap` does not allow parallel edges, but self loops are allowed./// Depends on crate feature `graphmap` (default)./// A trait group for `GraphMap`'s node identifier.// non-repr(usize) version of Directionopposite/// Return the opposite `CompactDirection`./// Create a new `GraphMap`/// Create a new `GraphMap` with estimated capacity./// Create a new `GraphMap` with estimated capacity, and specified hasher.edge_key/// Use their natural order to map the node pair (a, b) to a canonical edge id./// Whether the graph has directed edges./// Create a new `GraphMap` from an iterable of edges./// Node values are taken directly from the list./// use petgraph::graphmap::UnGraphMap;/// // Create a new undirected GraphMap./// // Use a type hint to have `()` be the edge weight type./// let gr = UnGraphMap::<_, ()>::from_edges(&[/// Return the number of nodes in the graph./// Add node `n` to the graph./// Return `true` if node `n` was removed./// Computes in **O(V)** time, due to the removal of edges with other nodes./// Return `true` if the node is contained in the graph./// Add an edge connecting `a` and `b` to the graph, with associated/// data `weight`. For a directed graph, the edge is directed from `a`/// to `b`./// Inserts nodes `a` and/or `b` if they aren't already part of the graph./// Return `None` if the edge did not previously exist, otherwise,/// the associated data is updated and the old value is returned/// as `Some(old_weight)`./// // Create a GraphMap with directed edges, and add one edge to it/// use petgraph::graphmap::DiGraphMap;/// let mut g = DiGraphMap::new();/// g.add_edge("x", "y", -1);/// assert_eq!(g.node_count(), 2);/// assert_eq!(g.edge_count(), 1);/// assert!(g.contains_edge("x", "y"));/// assert!(!g.contains_edge("y", "x"));remove_single_edge/// Remove edge relation from a to b/// Return `true` if it did exist./// Remove edge from `a` to `b` from the graph and return the edge weight./// Return `None` if the edge didn't exist./// // Create a GraphMap with undirected edges, and add and remove an edge./// let mut g = UnGraphMap::new();/// let edge_data = g.remove_edge("y", "x");/// assert_eq!(edge_data, Some(-1));/// assert_eq!(g.edge_count(), 0);/// Return `true` if the edge connecting `a` with `b` is contained in the graph.Nodes/// Return an iterator over the nodes of the graph./// Iterator element type is `N`./// Return an iterator of target nodes with an edge starting from `a`,/// paired with their respective edge weights./// Iterator element type is `(N, N, &E)`./// Return a reference to the edge weight connecting `a` with `b`, or/// `None` if the edge does not exist in the graph./// Return a mutable reference to the edge weight connecting `a` with `b`, orAllEdges/// Return an iterator over all edges of the graph with their weight in arbitrary order./// Iterator element type is `(N, N, &E)`all_edges_mutAllEdgesMut/// Return an iterator over all edges of the graph in arbitrary order, with a mutable reference/// to their weight./// Iterator element type is `(N, N, &mut E)`into_graph/// Return a `Graph` that corresponds to this `GraphMap`./// 1. Note that node and edge indices in the `Graph` have nothing in common///    with the `GraphMap`s node weights `N`. The node weights `N` are used as///    node weights in the resulting `Graph`, too./// 2. Note that the index type is user-chosen./// Computes in **O(|V| + |E|)** time (average)./// **Panics** if the number of nodes or edges does not fit with/// the resulting graph's index type.from_graph/// Creates a `GraphMap` that corresponds to the given `Graph`./// **Warning**: Nodes with the same weight are merged and only the last parallel edge/// is kept. Node and edge indices of the `Graph` are lost. Only use this function/// if the node weights are distinct and there are no parallel edges.start_node// TODO: change to something that implements Debug + Clone?/// Index `GraphMap` by node pairs to access edge weights./// Create a new empty `GraphMap`./// A reference that is hashed and compared by its pointer value./// `Ptr` is used for certain configurations of `GraphMap`,/// in particular in the combination where the node type for/// `GraphMap` is something of type for example `Ptr(&Cell<T>)`,/// with the `Cell<T>` being `TypedArena` allocated./// Ptr compares by pointer equality, i.e if they point to the same value/// Ptr is ordered by pointer value, i.e. an arbitrary but stable and total order.edge_ty/// The `GraphMap` keeps an adjacency matrix internally.//! `GraphMap<N, E, Ty>` is a graph datastructure where node values are mapping//! keys./// Format the iterator like a map/// Avoid "pretty" debug//! Formatting utilsex_find_map/// Return the first element that maps to `Some(_)`, or None if the iterator/// was exhausted.ex_rfind_map/// Return the last element from the back that maps to `Some(_)`, or/// None if the iterator was exhausted.// these modules define trait-implementing macroscsrgraph_implmatrix_graphtraits_graph/// An `Outgoing` edge is an outward edge *from* the current node./// An `Incoming` edge is an inbound edge *to* the current node.// Index into the NodeIndex and EdgeIndex arrays/// Edge direction./// Return the opposite `Direction`./// Return `0` for `Outgoing` and `1` for `Incoming`.EdgeDirection/// Marker type for a directed graph./// Marker type for an undirected graph./// A graph's edge type determines whether it has directed edges or not.into_weighted_edge/// Convert an element like `(i, j)` or `(i, j, w)` into/// a triple of source, target, edge weight./// For `Graph::from_edges` and `GraphMap::from_edges`.//! `petgraph` is a graph data structure library.//! Graphs are collections of nodes, and edges between nodes. `petgraph`//! provides several [graph types](index.html#graph-types) (each differing in the//! tradeoffs taken in their internal representation),//! [algorithms](./algo/index.html#functions) on those graphs, and functionality to//! [output graphs](./dot/struct.Dot.html) in//! [`graphviz`](https://www.graphviz.org/) format. Both nodes and edges//! can have arbitrary associated data, and edges may be either directed or undirected.//! use petgraph::graph::{NodeIndex, UnGraph};//! use petgraph::algo::{dijkstra, min_spanning_tree};//! use petgraph::data::FromElements;//! use petgraph::dot::{Dot, Config};//! // Create an undirected graph with `i32` nodes and edges with `()` associated data.//! let g = UnGraph::<i32, ()>::from_edges(&[//!     (1, 2), (2, 3), (3, 4),//!     (1, 4)]);//! // Find the shortest path from `1` to `4` using `1` as the cost for every edge.//! let node_map = dijkstra(&g, 1.into(), Some(4.into()), |_| 1);//! assert_eq!(&1i32, node_map.get(&NodeIndex::new(4)).unwrap());//! // Get the minimum spanning tree of the graph as a new graph, and check that//! // one edge was trimmed.//! let mst = UnGraph::<_, _>::from_elements(min_spanning_tree(&g));//! assert_eq!(g.raw_edges().len() - 1, mst.raw_edges().len());//! // Output the tree to `graphviz` `DOT` format//! println!("{:?}", Dot::with_config(&mst, &[Config::EdgeNoLabel]));//! // graph {//! //     0 [label="\"0\""]//! //     1 [label="\"0\""]//! //     2 [label="\"0\""]//! //     3 [label="\"0\""]//! //     1 -- 2//! //     3 -- 4//! //     2 -- 3//! // }//! # Graph types//! * [`Graph`](./graph/struct.Graph.html) -//!   An adjacency list graph with arbitrary associated data.//! * [`StableGraph`](./stable_graph/struct.StableGraph.html) -//!   Similar to `Graph`, but it keeps indices stable across removals.//! * [`GraphMap`](./graphmap/struct.GraphMap.html) -//!   An adjacency list graph backed by a hash table. The node identifiers are the keys//!   into the table.//! * [`MatrixGraph`](./matrix_graph/struct.MatrixGraph.html) -//!   An adjacency matrix graph.//! * [`CSR`](./csr/struct.Csr.html) -//!   A sparse adjacency matrix graph with arbitrary associated data.//! ### Generic parameters//! Each graph type is generic over a handful of parameters. All graphs share 3 common//! parameters, `N`, `E`, and `Ty`. This is a broad overview of what those are. Each//! type's documentation will have finer detail on these parameters.//! `N` & `E` are called *weights* in this implementation, and are associated with//! nodes and edges respectively. They can generally be of arbitrary type, and don't have to//! be what you might conventionally consider weight-like. For example, using `&str` for `N`//! will work. Many algorithms that require costs let you provide a cost function that//! translates your `N` and `E` weights into costs appropriate to the algorithm. Some graph//! types and choices do impose bounds on `N` or `E`.//! [`min_spanning_tree`](./algo/fn.min_spanning_tree.html) for example requires edge weights that//! implement [`PartialOrd`](https://doc.rust-lang.org/stable/core/cmp/trait.PartialOrd.html).//! [`GraphMap`](./graphmap/struct.GraphMap.html) requires node weights that can serve as hash//! map keys, since that graph type does not create standalone node indices.//! `Ty` controls whether edges are [`Directed`](./enum.Directed.html) or//! [`Undirected`](./enum.Undirected.html).//! `Ix` appears on graph types that use indices. It is exposed so you can control//! the size of node and edge indices, and therefore the memory footprint of your graphs.//! Allowed values are `u8`, `u16`, `u32`, and `usize`, with `u32` being the default.//! ### Shorthand types//! Each graph type vends a few shorthand type definitions that name some specific//! generic choices. For example, [`DiGraph<_, _>`](./graph/type.DiGraph.html) is shorthand//! for [`Graph<_, _, Directed>`](graph/struct.Graph.html).//! [`UnMatrix<_, _>`](./matrix_graph/type.UnMatrix.html) is shorthand for//! [`MatrixGraph<_, _, Undirected>`](./matrix_graph/struct.MatrixGraph.html). Each graph type's//! module documentation lists the available shorthand types.//! # Crate features//! * **serde-1** -//!   Defaults off. Enables serialization for ``Graph, StableGraph, GraphMap`` using//!   [`serde 1.0`](https://crates.io/crates/serde). May require a more recent version//!   of Rust than petgraph alone.//! * **graphmap** -//!   Defaults on. Enables [`GraphMap`](./graphmap/struct.GraphMap.html).//! * **stable_graph** -//!   Defaults on. Enables [`StableGraph`](./stable_graph/struct.StableGraph.html).//! * **matrix_graph** -//!   Defaults on. Enables [`MatrixGraph`](./matrix_graph/struct.MatrixGraph.html).GraphNodeIndex// The following types are used to control the max size of the adjacency matrix. Since the maximum// size of the matrix vector's is the square of the maximum number of nodes, the number of nodes// should be reasonably picked.NotZeroWrapped/// Wrapper trait for an `Option`, allowing user-defined structs to be input as containers when/// defining a null element./// Note: this trait is currently *sealed* and cannot be implemented for types outside this crate./// `NotZero` is used to optimize the memory usage of edge weights `E` in a/// [`MatrixGraph`](struct.MatrixGraph.html), replacing the default `Option<E>` sentinel./// Pre-requisite: edge weight should implement [`Zero`](trait.Zero.html)./// Note that if you're already using the standard non-zero types (such as `NonZeroU32`), you don't/// have to use this wrapper and can leave the default `Null` type argument.// implemented here for optimization purposes/// Return the singleton object which can be used as a sentinel value./// Return true if `self` is equal to the sentinel value./// Base trait for types that can be wrapped in a [`NotZero`](struct.NotZero.html)./// Implementors must provide a singleton object that will be used to mark empty edges in a/// [`MatrixGraph`](struct.MatrixGraph.html)./// Note that this trait is already implemented for the base numeric types.not_zero_implnot_zero_impls/// Short version of `NodeIndex::new` (with Ix = `DefaultIx`)node_adjacenciesnode_capacityIdStoragenb_edgesixMatrixGraph/// `MatrixGraph<N, E, Ty, Null>` is a graph datastructure using an adjacency matrix/// `MatrixGraph` is parameterized over:/// - Nullable type `Null`, which denotes the edges' presence (defaults to `Option<E>`). You may///   specify [`NotZero<E>`](struct.NotZero.html) if you want to use a sentinel value (such as 0)///   to mark the absence of an edge./// - Index type `Ix` that sets the maximum size for the graph (defaults to `DefaultIx`)./// The graph uses **O(|V^2|)** space, with fast edge insertion & amortized node insertion, as well/// as efficient graph search and graph algorithms on dense graphs./// This graph is backed by a flattened 2D array. For undirected graphs, only the lower triangular/// matrix is stored. Since the backing array stores edge weights, it is recommended to box large/// edge weights.DiMatrix/// A `MatrixGraph` with directed edges.UnMatrix/// A `MatrixGraph` with undirected edges./// Create a new `MatrixGraph` with estimated capacity for nodes.to_edge_positionto_edge_position_unchecked/// Remove all nodes and edges./// Return whether the graph has directed edges or not./// **Panics** if the MatrixGraph is at the maximum number of nodes for its index type./// Remove `a` from the graph.extend_capacity_for_nodeextend_capacity_for_edge/// Update the edge from `a` to `b` to the graph, with its associated data `weight`./// Return the previous data, if any./// Computes in **O(1)** time, best case./// Computes in **O(|V|^2)** time, worst case (matrix needs to be re-allocated)./// **Panics** if an edge already exists from `a` to `b`./// **Note:** `MatrixGraph` does not allow adding parallel (“duplicate”) edges. If you want to avoid/// this, use [`.update_edge(a, b, weight)`](#method.update_edge) instead./// Remove the edge from `a` to `b` to the graph./// **Panics** if no edge exists between `a` and `b`.has_edge/// Return true if there is an edge between `a` and `b`./// Iterator element type is [`NodeIndex<Ix>`](../graph/struct.NodeIndex.html)./// Iterator element type is `(NodeIndex<Ix>, NodeIndex<Ix>, &E)`./// Create a new `MatrixGraph` from an iterable of edges./// use petgraph::matrix_graph::MatrixGraph;/// let gr = MatrixGraph::<(), i32>::from_edges(&[/// - `Outgoing`: All edges from `a`./// - `Incoming`: All edges to `a`.IdIterator/// Iterator over the node identifiers of a graph./// Created from a call to [`.node_identifiers()`][1] on a [`MatrixGraph`][2]./// [1]: ../visit/trait.IntoNodeIdentifiers.html#tymethod.node_identifiers/// [2]: struct.MatrixGraph.html/// Created from a call to [`.node_references()`][1] on a [`MatrixGraph`][2]./// [1]: ../visit/trait.IntoNodeReferences.html#tymethod.node_references/// Created from a call to [`.edge_references()`][1] on a [`MatrixGraph`][2]./// [1]: ../visit/trait.IntoEdgeReferences.html#tymethod.edge_references/// Created with [`.neighbors()`][1], [`.neighbors_directed()`][2]./// [1]: struct.MatrixGraph.html#method.neighbors/// [2]: struct.MatrixGraph.html#method.neighbors_directedNeighborIterDirectionColumnsiter_direction/// Created with [`.edges()`][1], [`.edges_directed()`][2]./// [1]: struct.MatrixGraph.html#method.edges/// [2]: struct.MatrixGraph.html#method.edges_directedon_columnson_rowsto_linearized_matrix_positionextend_linearized_matrixto_flat_square_matrix_positionextend_flat_square_matrixto_lower_triangular_matrix_positionextend_lower_triangular_matrixensure_len/// Grow a Vec by appending the type's default value until the `size` is reached.removed_idsiter_ids/// Create a new empty `MatrixGraph`./// Create a new `MatrixGraph` with directed edges./// This is a convenience method. Use `MatrixGraph::with_capacity` or `MatrixGraph::default` for/// a constructor that is generic in all the type parameters of `MatrixGraph`./// Create a new `MatrixGraph` with undirected edges./// Index the `MatrixGraph` by `NodeIndex` to access node weights./// Index the `MatrixGraph` by `NodeIndex` pair to access edge weights.test_with_capacitytest_node_indexingtest_remove_nodetest_add_edgetest_add_edge_with_extension/// Adds an edge that triggers a second extension of the matrix./// From #425test_matrix_resizetest_add_edge_with_weightstest_add_edge_with_weights_undirectedIntoVec/// Shorthand for `.collect::<Vec<_>>()`test_clear_undirectedinto_sorted_vecIntoSortedVec/// Helper trait for always sorting before testing.sorted_vec/// Helper macro for always sorting before testing.test_neighborstest_neighbors_undirectedtest_remove_node_and_edgestest_remove_node_and_edges_undirectedtest_node_identifierstest_edges_directedtest_edges_undirectedtest_edges_of_absent_node_is_empty_iteratortest_neighbors_of_absent_node_is_empty_iteratortest_edge_references_undirectedtest_id_storagetest_not_zerotest_not_zero_assertedtest_not_zero_floattest_tarjan_scc_with_removed_node// From https://github.com/petgraph/petgraph/issues/523test_kosaraju_scc_with_removed_node//! `MatrixGraph<N, E, Ty, NullN, NullE, Ix>` is a graph datastructure backed by an adjacency matrix./// \[Generic\] complement of the graph/// Computes the graph complement of the input Graph and stores it/// in the provided empty output Graph./// The function does not create self-loops./// Computes in **O(|V|^2*log(|V|))** time (average)./// Returns the complement./// use petgraph::operator::complement;/// let mut graph: Graph<(),(),Directed> = Graph::new();/// // a ----> b ----> c ----> d/// let mut output: Graph<(), (), Directed> = Graph::new();/// complement(&graph, &mut output, ());/// let mut expected_res: Graph<(), (), Directed> = Graph::new();/// let a = expected_res.add_node(());/// let b = expected_res.add_node(());/// let c = expected_res.add_node(());/// let d = expected_res.add_node(());/// expected_res.extend_with_edges(&[///     (a, c),///     (a, d),///     (b, a),///     (b, d),///     (c, a),///     (c, b),///     (d, b),///     (d, c),/// for x in graph.node_indices() {///     for y in graph.node_indices() {///         assert_eq!(output.contains_edge(x, y), expected_res.contains_edge(x, y));//! Operators for creating new graphs from existings ones.Bfs//! Commonly used items.//! use petgraph::prelude::*;random_01/// Return a random float in the range [0, 1.)// shrink the graph by splitting it in two by a very// simple algorithm, just even and odd node indices/// `Arbitrary` for `Graph` creates a graph by selecting a node count/// and a probability for each possible edge to exist./// The result will be simple graph or digraph, self loops/// possible, no parallel edges./// The exact properties of the produced graph is subject to change./// Requires crate feature `"quickcheck"`/// `Arbitrary` for `StableGraph` creates a graph by selecting a node count/// The result will be simple graph or digraph, with possible/// self loops, no parallel edges./// Requires crate features `"quickcheck"` and `"stable_graph"`/// `Arbitrary` for `GraphMap` creates a graph by selecting a node count/// Requires crate features `"quickcheck"` and `"graphmap"`/// `MinScored<K, T>` holds a score `K` and a scored object `T` in/// a pair for use with a `BinaryHeap`./// `MinScored` compares in reverse order by the score, so that we can/// use `BinaryHeap` as a min-heap to extract the score-value pair with the/// least score./// **Note:** `MinScored` implements a total order (`Ord`), so that it is/// possible to use float types as scores./// Map to serializeable representation/// Map from deserialized representation/// Serde combinator. A sequence visitor that maps deserialized elements/// lazily; the visitor can also emit new errors if the elements have errors.collect_seq_with_lengthcollect_seq_exact/// The adjacency matrix for **Graph** is a bitmap that's computed by// For element at index *i*, store the index of its parent; the representative itself// stores its own index. This forms equivalence classes which are the disjoint sets, each// with a unique representative.// It is a balancing tree structure,// so the ranks are logarithmic in the size of the container -- a byte is more than enough.// Rank is separated out both to save space and to save cache in when searching in the parent// vector./// `UnionFind<K>` is a disjoint-set data structure. It tracks set membership of *n* elements/// indexed from *0* to *n - 1*. The scalar type is `K` which must be an unsigned integer type./// <http://en.wikipedia.org/wiki/Disjoint-set_data_structure>/// Too awesome not to quote:/// “The amortized time per operation is **O(α(n))** where **α(n)** is the/// inverse of **f(x) = A(x, x)** with **A** being the extremely fast-growing Ackermann function.”/// Create a new `UnionFind` of `n` disjoint sets./// Return the representative for `x`./// **Panics** if `x` is out of bounds./// Write back the found representative, flattening the internal/// datastructure in the process and quicken future lookups.find_mut_recursiveequiv/// Returns `true` if the given elements belong to the same set, and returns/// Unify the two sets containing `x` and `y`./// Return `false` if the sets were already the same, `true` if they were unified./// **Panics** if `x` or `y` is out of bounds.into_labeling/// Return a vector mapping each element to its representative.//! `UnionFind<K>` is a disjoint-set data structure./// Strictly monotonically increasing event time for a depth first search.DfsEventDiscoverTreeEdge/// An edge of the tree formed by the traversal.BackEdge/// An edge to an already visited node.CrossForwardEdge/// A cross or forward edge./// For an edge *(u, v)*, if the discover time of *v* is greater than *u*,/// then it is a forward edge, else a cross edge./// All edges from a node have been reported./// A depth first search (DFS) visitor event.try_control/// Return if the expression is a break value, execute the provided statement/// if it is a prune value./// Continue the DFS traversal as normal.Prune/// Prune the current node from the DFS traversal. No more edges from this/// node will be reported to the callback. A `DfsEvent::Finish` for this/// node will still be reported. This can be returned in response to any/// `DfsEvent`, except `Finish`, which will panic./// Stop the DFS traversal and return the provided value./// Control flow for `depth_first_search` callbacks.breakingbreak_value/// Get the value in `Control::Break(_)`, if present.continuingshould_breakshould_prune/// Control flow for callbacks./// The empty return value `()` is equivalent to continue./// The default is `Continue`.depth_first_search/// A recursive depth first search./// Starting points are the nodes in the iterator `starts` (specify just one/// start vertex *x* by using `Some(x)`)./// The traversal emits discovery and finish events for each reachable vertex,/// and edge classification of each reachable edge. `visitor` is called for each/// event, see [`DfsEvent`][de] for possible values./// The return value should implement the trait `ControlFlow`, and can be used to change/// the control flow of the search./// `Control` Implements `ControlFlow` such that `Control::Continue` resumes the search./// `Control::Break` will stop the visit early, returning the contained value./// `Control::Prune` will stop traversing any additional edges from the current/// node and proceed immediately to the `Finish` event./// There are implementations of `ControlFlow` for `()`, and `Result<C, E>` where/// `C: ControlFlow`. The implementation for `()` will continue until finished./// For `Result`, upon encountering an `E` it will break, otherwise acting the same as `C`./// ***Panics** if you attempt to prune a node from its `Finish` event./// [de]: enum.DfsEvent.html/// # Example returning `Control`./// Find a path from vertex 0 to 5, and exit the visit as soon as we reach/// the goal vertex./// use petgraph::graph::node_index as n;/// use petgraph::visit::depth_first_search;/// use petgraph::visit::{DfsEvent, Control};/// let gr: Graph<(), ()> = Graph::from_edges(&[///     (2, 3), (2, 4),///     (4, 0), (4, 5),/// // record each predecessor, mapping node → node/// let mut predecessor = vec![NodeIndex::end(); gr.node_count()];/// let start = n(0);/// let goal = n(5);/// depth_first_search(&gr, Some(start), |event| {///     if let DfsEvent::TreeEdge(u, v) = event {///         predecessor[v.index()] = u;///         if v == goal {///             return Control::Break(v);///     Control::Continue/// let mut next = goal;/// let mut path = vec![next];/// while next != start {///     let pred = predecessor[next.index()];///     path.push(pred);///     next = pred;/// path.reverse();/// assert_eq!(&path, &[n(0), n(2), n(4), n(5)]);/// # Example returning a `Result`./// use petgraph::visit::{DfsEvent, Time};/// let gr: Graph<(), ()> = Graph::from_edges(&[(0, 1), (1, 2), (1, 1), (2, 1)]);/// let mut back_edges = 0;/// let mut discover_time = 0;/// // Stop the search, the first time a BackEdge is encountered./// let result = depth_first_search(&gr, Some(start), |event| {///         // In the cases where Ok(()) is returned,///         // Result falls back to the implementation of Control on the value ().///         // In the case of (), this is to always return Control::Continue.///         // continuing the search.///         DfsEvent::Discover(_, Time(t)) => {///             discover_time = t;///         DfsEvent::BackEdge(_, _) => {///             back_edges += 1;///             // the implementation of ControlFlow for Result,///             // treats this Err value as Continue::Break///             Err(event)///         _ => Ok(()),/// // Even though the graph has more than one cycle,/// // The number of back_edges visited by the search should always be 1./// assert_eq!(back_edges, 1);/// println!("discover time:{:?}", discover_time);/// println!("number of backedges encountered: {}", back_edges);/// println!("back edge: {:?}", result);dfs_visitortime_post_incinclude_node/// Return true to have the node be part of the graphFilterNode/// A graph filter for nodes./// This filter includes the nodes that are contained in the set.// Can't express these as a generic impl over all references since that would conflict with the// impl for Fn.NodeFiltered/// A node-filtering graph adaptor./// Create an `NodeFiltered` adaptor from the closure `filter`.NodeFilteredNeighborsinclude_source/// A filtered neighbors iterator.NodeFilteredNodes/// A filtered node references iterator.NodeFilteredEdgeReferences/// A filtered edges iterator.NodeFilteredEdgesinclude_edge/// Return true to have the edge be part of the graphFilterEdge/// A graph filter for edgesEdgeFiltered/// An edge-filtering graph adaptor./// The adaptor may filter out edges. The filter implements the trait/// `FilterEdge`. Closures of type `Fn(G::EdgeRef) -> bool` already/// implement this trait./// The filter may use edge source, target, id, and weight to select whether to/// include the edge or not./// Create an `EdgeFiltered` adaptor from the closure `filter`.EdgeFilteredNeighborsEdgeFilteredNeighborsDirectedEdgeFilteredEdges/// A filtered neighbors-directed iterator./// Define a trait as usual, and a macro that can be used to instantiate/// implementations of it./// There *must* be section markers in the trait definition:/// @section type for associated types/// @section self for methods/// @section nodelegate for arbitrary tail that is not forwarded.// escape the following tt// This is the outer layer, just find the { } of the actual trait definition// recurse once into { }, but not more.deref_twice/// Implement a trait by delegation. By default as if we are delegating/// from &G to G.// filter, reversed have their `mod` lines at the end,// so that they can use the trait template macrosdfsvisitr" edge identifier"r" node identifier"r" Base graph trait: defines the associated node identifier and"r" edge identifier types."/// A copyable reference to a graph.r" Return an iterator of the neighbors of node `a`."r" Access to the neighbors of each node"r" The neighbors are, depending on the graph’s edge type:"r" - `Directed`: All targets of edges from `a`."r" - `Undirected`: All other endpoints of edges connected to `a`."r" Access to the neighbors of each node, through incoming or outgoing edges."r" Depending on the graph’s edge type, the neighbors of a given directionality"r" are:"r" - `Directed`, `Outgoing`: All targets of edges from `a`."r" - `Directed`, `Incoming`: All sources of edges to `a`."r" Access to the edges of each node."r" The edges are, depending on the graph’s edge type:"r" - `Directed`: All edges from `a`."r" - `Undirected`: All edges connected to `a`, with `a` being the source of each edge."r" This is an extended version of the trait `IntoNeighbors`; the former"r" only iterates over the target node identifiers, while this trait"r" yields edge references (trait [`EdgeRef`][er])."r" [er]: trait.EdgeRef.html"r" Access to all edges of each node, in the specified direction."r" The edges are, depending on the direction and the graph’s edge type:"r" - `Directed`, `Outgoing`: All edges from `a`."r" - `Directed`, `Incoming`: All edges to `a`."r" - `Undirected`, `Outgoing`: All edges connected to `a`, with `a` being the source of each edge."r" - `Undirected`, `Incoming`: All edges connected to `a`, with `a` being the target of each edge."r" This is an extended version of the trait `IntoNeighborsDirected`; the former"r" Access to the sequence of the graph’s `NodeId`s."r" Define associated data for nodes and edges"/// The source node of the edge./// The target node of the edge./// A reference to the weight of the edge./// The edge’s identifier./// An edge reference./// Edge references are used by traits `IntoEdges` and `IntoEdgeReferences`./// A node reference.r" Access to the sequence of the graph’s nodes"r" Access to the sequence of the graph’s edges"r" The kind of edges in the graph."r" Edge kind property (directed or undirected edges)"r" Return an upper bound of the node indices in the graph"r" (suitable for the size of a bitmap)."r" Convert `a` to an integer index."r" Convert `i` to a node index. `i` must be a valid value in the graph."r" The graph’s `NodeId`s map to indices"r" Return an upper bound of the edge indices in the graph"r" Convert `i` to an edge index. `i` must be a valid value in the graph."r" A graph with a known node count."r" The graph’s `NodeId`s map to indices, in a range without holes."r" The graph's node identifiers correspond to exactly the indices"r" `0..self.node_bound()`."/// Mark `a` as visited./// Return **true** if this is the first visit, false otherwise./// Return whether `a` has been visited before./// A mapping for storing the visited status for NodeId `N`.r" The associated map type"r" Create a new visitor map"r" Reset the visitor map (and resize to new size of graph if needed)"r" A graph that can create a map that tracks the visited status of its nodes."r" The associated adjacency matrix type"r" Create the adjacency matrix"r" Return true if there is an edge from `a` to `b`, false otherwise."r" Computes in O(1) time."r" Create or access the adjacency matrix of a graph."r" The implementor can either create an adjacency matrix, or it can return"r" a placeholder if it has the needed representation internally."r" Return the number of edges in the graph."r" A graph with a known edge count."//! Graph traits and graph traversals.//! ### The `Into-` Traits//! Graph traits like [`IntoNeighbors`][in] create iterators and use the same//! pattern that `IntoIterator` does: the trait takes a reference to a graph,//! and produces an iterator. These traits are quite composable, but with the//! limitation that they only use shared references to graphs.//! ### Graph Traversal//! [`Dfs`](struct.Dfs.html), [`Bfs`][bfs], [`DfsPostOrder`][dfspo] and//! [`Topo`][topo]  are basic visitors and they use “walker” methods: the//! visitors don't hold the graph as borrowed during traversal, only for the//! `.next()` call on the walker. They can be converted to iterators//! through the [`Walker`][w] trait.//! There is also the callback based traversal [`depth_first_search`][dfs].//! [bfs]: struct.Bfs.html//! [dfspo]: struct.DfsPostOrder.html//! [topo]: struct.Topo.html//! [dfs]: fn.depth_first_search.html//! [w]: trait.Walker.html//! ### Other Graph Traits//! The traits are rather loosely coupled at the moment (which is intentional,//! but will develop a bit), and there are traits missing that could be added.//! Not much is needed to be able to use the visitors on a graph. A graph//! needs to define [`GraphBase`][gb], [`IntoNeighbors`][in] and//! [`Visitable`][vis] as a minimum.//! [gb]: trait.GraphBase.html//! [in]: trait.IntoNeighbors.html//! [vis]: trait.Visitable.html//! ### Graph Trait Implementations//! The following table lists the traits that are implemented for each graph type://! |                       | Graph | StableGraph | GraphMap | MatrixGraph | Csr   | List  |//! | --------------------- | :---: | :---------: | :------: | :---------: | :---: | :---: |//! | GraphBase             | x     |  x          |    x     | x           | x     |  x    |//! | GraphProp             | x     |  x          |    x     | x           | x     |  x    |//! | NodeCount             | x     |  x          |    x     | x           | x     |  x    |//! | NodeIndexable         | x     |  x          |    x     | x           | x     |  x    |//! | NodeCompactIndexable  | x     |             |    x     |             | x     |  x    |//! | EdgeCount             | x     |  x          |    x     | x           | x     |  x    |//! | EdgeIndexable         | x     |  x          |    x     |             |       |       |//! | Data                  | x     |  x          |    x     | x           | x     |  x    |//! | IntoNodeIdentifiers   | x     |  x          |    x     | x           | x     |  x    |//! | IntoNodeReferences    | x     |  x          |    x     | x           | x     |  x    |//! | IntoEdgeReferences    | x     |  x          |    x     | x           | x     |  x    |//! | IntoNeighbors         | x     |  x          |    x     | x           | x     |  x    |//! | IntoNeighborsDirected | x     |  x          |    x     | x           |       |       |//! | IntoEdges             | x     |  x          |    x     | x           | x     |  x    |//! | IntoEdgesDirected     | x     |  x          |    x     | x           |       |       |//! | Visitable             | x     |  x          |    x     | x           | x     |  x    |//! | GetAdjacencyMatrix    | x     |  x          |    x     | x           | x     |  x    |/// An edge-reversing graph adaptor./// All edges have the opposite direction with `Reversed`.ReversedEdges/// A reversed edges iterator.ReversedEdgeReference/// A reversed edge referenceas_unreversed/// Return the original, unreversed edge reference.into_unreversed/// Consume `self` and return the original, unreversed edge reference./// An edge referenceReversedEdgeReferences/// A reversed edge references iterator./// The stack of nodes to visitdiscovered/// The map of discovered nodes/// Visit nodes of a graph in a depth-first-search (DFS) emitting nodes in/// preorder (when they are first discovered)./// The traversal starts at a given node and only traverses nodes reachable/// `Dfs` is not recursive./// `Dfs` does not itself borrow the graph, and because of this you can run/// a traversal over a graph while still retaining mutable access to it, if you/// use it like the following example:/// let mut graph = Graph::<_,()>::new();/// let a = graph.add_node(0);/// let mut dfs = Dfs::new(&graph, a);/// while let Some(nx) = dfs.next(&graph) {///     // we can access `graph` mutably here still///     graph[nx] += 1;/// assert_eq!(graph[a], 1);/// **Note:** The algorithm may not behave correctly if nodes are removed/// during iteration. It may not necessarily visit added nodes or edges./// Create a new **Dfs**, using the graph's visitor map, and put **start**/// in the stack of nodes to visit./// Create a `Dfs` from a vector and a visit map/// Clear the visit state/// Create a new **Dfs** using the graph's visitor map, and no stack./// Keep the discovered map, but clear the visit stack and restart/// the dfs from a particular node./// Return the next node in the dfs, or **None** if the traversal is done./// The map of finished nodes/// Visit nodes in a depth-first-search (DFS) emitting nodes in postorder/// (each node after all its descendants have been emitted)./// `DfsPostOrder` is not recursive./// Create a new `DfsPostOrder` using the graph's visitor map, and put/// `start` in the stack of nodes to visit./// Create a new `DfsPostOrder` using the graph's visitor map, and no stack./// Keep the discovered and finished map, but clear the visit stack and restart/// Return the next node in the traversal, or `None` if the traversal is done./// The queue of nodes to visit/// A breadth first search (BFS) of a graph./// `Bfs` is not recursive./// `Bfs` does not itself borrow the graph, and because of this you can run/// use petgraph::visit::Bfs;/// let mut bfs = Bfs::new(&graph, a);/// while let Some(nx) = bfs.next(&graph) {/// Create a new **Bfs**, using the graph's visitor map, and put **start**/// Return the next node in the bfs, or **None** if the traversal is done.tovisitorderedTopo/// A topological order traversal for a graph./// **Note** that `Topo` only visits nodes that are not part of cycles,/// i.e. nodes in a true DAG. Use other visitors like `DfsPostOrder` or/// algorithms like kosaraju_scc to handle graphs with possible cycles./// Create a new `Topo`, using the graph's visitor map, and put all/// initial nodes in the to visit list.with_initials/// Create a new `Topo` with initial nodes./// Nodes with incoming edges are ignored.extend_with_initials/* Private until it has a use *//// Create a new `Topo`, using the graph's visitor map with *no* starting/// index specified./// Clear visited state, and put all initial nodes in the to visit list./// Return the next node in the current topological order traversal, or/// `None` if the traversal is at the end./// *Note:* The graph may not have a complete topological order, and the only/// way to know is to run the whole traversal and make sure it visits every node.walk_next/// Advance to the next itemWalkerIter/// Create an iterator out of the walker and given `context`./// A walker is a traversal state, but where part of the traversal/// information is supplied manually to each next call./// This for example allows graph traversals that don't hold a borrow of the/// graph they are traversing.walker/// A walker and its context wrapped into an iterator.ordered_mapOrderedMapordered_setOrderedSetPhfHash//! Rust-PHF is a library to generate efficient lookup tables at compile time using//! [perfect hash functions](http://en.wikipedia.org/wiki/Perfect_hash_function).//! It currently uses the//! [CHD algorithm](http://cmph.sourceforge.net/papers/esa09.pdf) and can generate//! a 100,000 entry map in roughly .4 seconds.//! MSRV (minimum supported rust version) is Rust 1.61.//! PHF data structures can be constructed via either the procedural//! macros in the `phf_macros` crate or code generation supported by the//! `phf_codegen` crate. If you prefer macros, you can easily use them by//! enabling the `macros` feature of the `phf` crate, like://!```toml//! phf = { version = "0.11", features = ["macros"] }//! To compile the `phf` crate with a dependency on//! libcore instead of libstd, enabling use in environments where libstd//! will not work, set `default-features = false` for the dependency://! # to use `phf` in `no_std` environments//! phf = { version = "0.11", default-features = false }//! ## Example (with the `macros` feature enabled)//! use phf::phf_map;//! pub enum Keyword {//!     Loop,//!     Continue,//!     Break,//!     Fn,//!     Extern,//! static KEYWORDS: phf::Map<&'static str, Keyword> = phf_map! {//!     "loop" => Keyword::Loop,//!     "continue" => Keyword::Continue,//!     "break" => Keyword::Break,//!     "fn" => Keyword::Fn,//!     "extern" => Keyword::Extern,//! pub fn parse_keyword(keyword: &str) -> Option<Keyword> {//!     KEYWORDS.get(keyword).cloned()//! Alternatively, you can use the [`phf_codegen`] crate to generate PHF datatypes//! in a build script.//! [`phf_codegen`]: https://docs.rs/phf_codegen//! ## Note//! Currently, the macro syntax has some limitations and may not//! work as you want. See [#183] or [#196] for example.//! [#183]: https://github.com/rust-phf/rust-phf/issues/183//! [#196]: https://github.com/rust-phf/rust-phf/issues/196HashKeyPhfBorrowdisps/// An immutable map constructed at compile time./// The fields of this struct are public so that they may be initialized by the/// `phf_map!` macro and code generation. They are subject to change at any/// time and should never be accessed directly./// Create a new, empty, immutable map./// Returns the number of entries in the `Map`./// Returns true if the `Map` is empty./// Determines if `key` is in the `Map`./// Returns a reference to the value that `key` maps to./// Returns a reference to the map's internal static instance of the given/// key./// This can be useful for interning schemes./// Like `get`, but returns both the key and the value./// Returns an iterator over the key/value pairs in the map./// Entries are returned in an arbitrary but fixed order./// Returns an iterator over the keys in the map./// Keys are returned in an arbitrary but fixed order./// Returns an iterator over the values in the map./// Values are returned in an arbitrary but fixed order./// An iterator over the key/value pairs in a `Map`./// An iterator over the keys in a `Map`./// An iterator over the values in a `Map`.//! An immutable map constructed at compile time./// An order-preserving immutable map constructed at compile time./// Unlike a `Map`, iteration order is guaranteed to match the definition/// `phf_ordered_map!` macro and code generation. They are subject to change at/// any time and should never be accessed directly./// Returns the number of entries in the `OrderedMap`./// Returns true if the `OrderedMap` is empty./// Determines if `key` is in the `OrderedMap`./// Returns the index of the key within the list used to initialize/// the ordered map./// Returns references to both the key and values at an index/// within the list used to initialize the ordered map. See `.get_index(key)`./// Entries are returned in the same order in which they were defined./// Keys are returned in the same order in which they were defined./// Values are returned in the same order in which they were defined./// An iterator over the entries in a `OrderedMap`./// An iterator over the keys in a `OrderedMap`./// An iterator over the values in a `OrderedMap`.//! An order-preserving immutable map constructed at compile time./// An order-preserving immutable set constructed at compile time./// Unlike a `Set`, iteration order is guaranteed to match the definition/// `phf_ordered_set!` macro and code generation. They are subject to change at/// Returns the number of elements in the `OrderedSet`./// Returns true if the `OrderedSet` contains no elements./// Returns a reference to the set's internal static instance of the given/// the ordered set./// Returns a reference to the key at an index/// within the list used to initialize the ordered set. See `.get_index(key)`./// Returns true if `value` is in the `OrderedSet`./// Returns an iterator over the values in the set./// Returns true if `other` shares no elements with `self`./// Returns true if `other` contains all values in `self`./// Returns true if `self` contains all values in `other`./// An iterator over the values in a `OrderedSet`.//! An order-preserving immutable set constructed at compile time./// An immutable set constructed at compile time./// `phf_set!` macro and code generation. They are subject to change at any/// Returns the number of elements in the `Set`./// Returns true if the `Set` contains no elements./// Returns true if `value` is in the `Set`./// An iterator over the values in a `Set`.//! An immutable set constructed at compile time.// WARNING: this is not considered part of phf's public API and is subject to// change at any time.// Basically Cow, but with the Owned version conditionally compiled//! Compile-time generated maps and sets.//! The `phf::Map` and `phf::Set` types have roughly comparable performance to//! a standard hash table, but can be generated as compile-time static values.//! If the `macros` Cargo feature is enabled, the `phf_map`, `phf_set`,//! `phf_ordered_map`, and `phf_ordered_set` macros can be used to construct//! the PHF type. This currently requires a nightly compiler.//! phf = { version = "0.7.24", features = ["macros"] }//! #![feature(proc_macro_hygiene)]//! use phf::{phf_map, phf_set};//! static MY_MAP: phf::Map<&'static str, u32> = phf_map! {//!     "hello" => 1,//!     "world" => 2,//! static MY_SET: phf::Set<&'static str> = phf_set! {//!     "hello world",//!     "hola mundo",//!     assert_eq!(MY_MAP["hello"], 1);//!     assert!(MY_SET.contains("hello world"));//! Alternatively, you can use the phf_codegen crate to generate PHF datatypes//! in a build script. This method can be used with a stable compiler.FmtConstHashStateDelegate/// A builder for the `phf::Map` type./// Creates a new `phf::Map` builder.phf_path/// Set the path to the `phf` crate from the global namespace/// Adds an entry to the builder./// `value` will be written exactly as provided in the constructed source.DisplayMap/// Calculate the hash parameters and return a struct implementing/// [`Display`](::std::fmt::Display) which will print the constructed `phf::Map`./// Panics if there are any duplicate keys./// An adapter for printing a [`Map`](Map)./// A builder for the `phf::Set` type./// Constructs a new `phf::Set` builder.DisplaySet/// [`Display`](::std::fmt::Display) which will print the constructed `phf::Set`./// An adapter for printing a [`Set`](Set)./// A builder for the `phf::OrderedMap` type./// Constructs a enw `phf::OrderedMap` builder.DisplayOrderedMap/// [`Display`](::std::fmt::Display) which will print the constructed/// `phf::OrderedMap`./// An adapter for printing a [`OrderedMap`](OrderedMap)./// A builder for the `phf::OrderedSet` type./// Constructs a new `phf::OrderedSet` builder.DisplayOrderedSet/// `phf::OrderedSet`./// An adapter for printing a [`OrderedSet`](OrderedSet).//! A set of builders to generate Rust source for PHF data structures at//! compile time.//! The provided builders are intended to be used in a Cargo build script to//! generate a Rust source file that will be included in a library at build//! For more information about `rust-phf` crates, see [the `phf` crate's documentation][phf].//! [phf]: https://docs.rs/phf//! To use `phf_codegen` on build.rs, you have to add dependencies under `[build-dependencies]`://! phf = { version = "0.11.1", default-features = false }//! phf_codegen = "0.11.1"//! Then put code on build.rs://! use std::io::{BufWriter, Write};//!     let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");//!     let mut file = BufWriter::new(File::create(&path).unwrap());//!     write!(//!         &mut file,//!         "static KEYWORDS: phf::Map<&'static str, Keyword> = {}",//!         phf_codegen::Map::new()//!             .entry("loop", "Keyword::Loop")//!             .entry("continue", "Keyword::Continue")//!             .entry("break", "Keyword::Break")//!             .entry("fn", "Keyword::Fn")//!             .entry("extern", "Keyword::Extern")//!             .build()//!     write!(&mut file, ";\n").unwrap();//! and lib.rs://! enum Keyword {//! include!(concat!(env!("OUT_DIR"), "/codegen.rs"));//! ### Byte-String Keys//! Byte strings by default produce references to fixed-size arrays; the compiler needs a hint//! to coerce them to slices://!     writeln!(//!          "static KEYWORDS: phf::Map<&'static [u8], Keyword> = \n{};\n",//!          phf_codegen::Map::<&[u8]>::new()//!              .entry(b"loop", "Keyword::Loop")//!              .entry(b"continue", "Keyword::Continue")//!              .entry(b"break", "Keyword::Break")//!              .entry(b"fn", "Keyword::Fn")//!              .entry(b"extern", "Keyword::Extern")//!              .build()//!     ).unwrap();//! pub fn parse_keyword(keyword: &[u8]) -> Option<Keyword> {//! The compiler's stack will overflow when processing extremely long method//! chains (500+ calls). When generating large PHF data structures, consider//! looping over the entries or making each call a separate statement://! let entries = [("hello", "1"), ("world", "2")];//! let mut builder = phf_codegen::Map::new();//! for &(key, value) in &entries {//!     builder.entry(key, value);//! builder.entry("hello", "1");//! builder.entry("world", "2");/// Constructs a `phf::Map`, outputting Rust source to the provided writer./// Constructs a `phf::Set`, outputting Rust source to the provided writer./// Panics if there are any duplicate entries./// Constructs a `phf::OrderedMap`, outputting Rust source to the provided/// writer./// Constructs a `phf::OrderedSet`, outputting Rust source to the provided//! build.rs//! extern crate phf_codegen;//! write!(&mut file, "static KEYWORDS: phf::Map<&'static str, Keyword> =//! ").unwrap();//!     phf_codegen::Map::new()//!         .entry("loop", "Keyword::Loop")//!         .entry("continue", "Keyword::Continue")//!         .entry("break", "Keyword::Break")//!         .entry("fn", "Keyword::Fn")//!         .entry("extern", "Keyword::Extern")//!         .build(&mut file)//! lib.rs//! extern crate phf;gen_vecHashesDEFAULT_LAMBDAFIXED_SEEDgenerate_hash_with_hash_fnhashestry_generate_hash//! See [the `phf` crate's documentation][phf] for details.sip128Hash128Hasher128SipHasher13f1f2/// A central typedef for hash keys/// Makes experimentation easier by only needing to be updated here.displace/// `key` is from `phf_generator::HashState`./// Return an index into `phf_generator::HashState::map`./// * `hash` is from `hash()` in this crate./// * `disps` is from `phf_generator::HashState::disps`./// * `len` is the length of `phf_generator::HashState::map`.phf_hash/// Feeds the value into the state given, updating the hasher as necessary.phf_hash_slice/// Feeds a slice of this type into the state provided./// A trait implemented by types which can be used in PHF data structures./// This differs from the standard library's `Hash` trait in that `PhfHash`'s/// results must be architecture independent so that hashes will be consistent/// between the host and target when cross compiling.fmt_const/// Print a `const` expression representing this value./// Trait for printing types with `const` constructors, used by `phf_codegen` and `phf_macros`./// Convert a reference to `self` to a reference to the borrowed type./// Identical to `std::borrow::Borrow` except omitting blanket impls to facilitate other/// borrowing patterns./// The same semantic requirements apply:/// > In particular `Eq`, `Ord` and `Hash` must be equivalent for borrowed and owned values:/// `x.borrow() == y.borrow()` should give the same result as `x == y`./// (This crate's API only requires `Eq` and `PhfHash`, however.)/// ### Motivation/// The conventional signature for lookup methods on collections looks something like this:/// impl<K, V> Map<K, V> where K: PhfHash + Eq {///     fn get<T: ?Sized>(&self, key: &T) -> Option<&V> where T: PhfHash + Eq, K: Borrow<T> {/// This allows the key type used for lookup to be different than the key stored in the map so for/// example you can use `&str` to look up a value in a `Map<String, _>`. However, this runs into/// a problem in the case where `T` and `K` are both a `Foo<_>` type constructor but/// the contained type is different (even being the same type with different lifetimes)./// The main issue for this crate's API is that, with this method signature, you cannot perform a/// lookup on a `Map<UniCase<&'static str>, _>` with a `UniCase<&'a str>` where `'a` is not/// `'static`; there is no impl of `Borrow` that resolves to/// `impl Borrow<UniCase<'a>> for UniCase<&'static str>` and one cannot be added either because of/// all the blanket impls./// Instead, this trait is implemented conservatively, without blanket impls, so that impls like/// this may be added. This is feasible since the set of types that implement `PhfHash` is/// intentionally small./// This likely won't be fixable with specialization alone but will require full support for lattice/// impls since we technically want to add overlapping blanket impls.delegate_debug/// Create an impl of `FmtConst` delegating to `fmt::Debug` for types that can deal with it./// Ideally with specialization this could be just one default impl and then specialized where/// it doesn't apply.impl_reflexive/// `impl PhfBorrow<T> for T`sip_implfmt_array// minimize duplicated code since formatting drags in quite a bitslice_implsip/// `key` is from `phf_generator::HashState::key`.// Lints that may help when writing public library.// clippy::missing_inline_in_public_items,pinned_dropUnsafeUnpin/// A trait used for custom implementations of [`Unpin`]./// This trait is used in conjunction with the `UnsafeUnpin` argument to/// the [`#[pin_project]`][macro@pin_project] attribute./// The Rust [`Unpin`] trait is safe to implement - by itself,/// implementing it cannot lead to [undefined behavior][undefined-behavior]./// Undefined behavior can only occur when other unsafe code is used./// It turns out that using pin projections, which requires unsafe code,/// imposes additional requirements on an [`Unpin`] impl. Normally, all of this/// unsafety is contained within this crate, ensuring that it's impossible for/// you to violate any of the guarantees required by pin projection./// However, things change if you want to provide a custom [`Unpin`] impl/// for your `#[pin_project]` type. As stated in [the Rust/// documentation][pin-projection], you must be sure to only implement [`Unpin`]/// when all of your `#[pin]` fields (i.e. structurally pinned fields) are also/// [`Unpin`]./// To help highlight this unsafety, the `UnsafeUnpin` trait is provided./// Implementing this trait is logically equivalent to implementing [`Unpin`] -/// this crate will generate an [`Unpin`] impl for your type that 'forwards' to/// your `UnsafeUnpin` impl. However, this trait is `unsafe` - since your type/// uses structural pinning (otherwise, you wouldn't be using this crate!),/// you must be sure that your `UnsafeUnpin` impls follows all of/// the requirements for an [`Unpin`] impl of a structurally-pinned type./// Note that if you specify `#[pin_project(UnsafeUnpin)]`, but do *not*/// provide an impl of `UnsafeUnpin`, your type will never implement [`Unpin`]./// This is effectively the same thing as adding a [`PhantomPinned`] to your/// Since this trait is `unsafe`, impls of it will be detected by the/// `unsafe_code` lint, and by tools like [`cargo geiger`][cargo-geiger]./// An `UnsafeUnpin` impl which, in addition to requiring that structurally/// pinned fields be [`Unpin`], imposes an additional requirement:/// use pin_project::{pin_project, UnsafeUnpin};/// #[pin_project(UnsafeUnpin)]/// struct Struct<K, V> {///     #[pin]///     field_1: K,///     field_2: V,/// unsafe impl<K, V> UnsafeUnpin for Struct<K, V> where K: Unpin + Clone {}/// [`PhantomPinned`]: core::marker::PhantomPinned/// [cargo-geiger]: https://github.com/rust-secure-code/cargo-geiger/// [pin-projection]: core::pin#projections-and-structural-pinning/// [undefined-behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html__PinProjectInternalDerivePinnedDrop// An internal trait used for custom implementations of [`Drop`].// **Do not call or implement this trait directly.**// # Why this trait is private and `#[pinned_drop]` attribute is needed?// Implementing `PinnedDrop::drop` is safe, but calling it is not safe.// This is because destructors can be called multiple times in safe code and// [double dropping is unsound][rust-lang/rust#62360].// Ideally, it would be desirable to be able to forbid manual calls in// the same way as [`Drop::drop`], but the library cannot do it. So, by using// macros and replacing them with private traits,// this crate prevent users from calling `PinnedDrop::drop` in safe code.// This allows implementing [`Drop`] safely using `#[pinned_drop]`.// Also by using the [`drop`] function just like dropping a type that directly// implements [`Drop`], can drop safely a type that implements `PinnedDrop`.// [rust-lang/rust#62360]: https://github.com/rust-lang/rust/pull/62360Wrapper// This is an internal helper struct used by `pin-project-internal`.// This allows us to force an error if the user tries to provide// a regular `Unpin` impl when they specify the `UnsafeUnpin` argument.// This is why we need Wrapper:// Supposed we have the following code:// #[pin_project(UnsafeUnpin)]// struct MyStruct<T> {//     #[pin] field: T// impl<T> Unpin for MyStruct<T> where MyStruct<T>: UnsafeUnpin {} // generated by pin-project-internal// impl<T> Unpin for MyStruct<T> where T: Copy // written by the user// We want this code to be rejected - the user is completely bypassing// `UnsafeUnpin`, and providing an unsound Unpin impl in safe code!// Unfortunately, the Rust compiler will accept the above code.// Because MyStruct is declared in the same crate as the user-provided impl,// the compiler will notice that `MyStruct<T>: UnsafeUnpin` never holds.// The solution is to introduce the `Wrapper` struct, which is defined// in the `pin-project` crate.// We now have code that looks like this:// impl<T> Unpin for MyStruct<T> where Wrapper<MyStruct<T>>: UnsafeUnpin {} // generated by pin-project-internal// We also have `unsafe impl<T> UnsafeUnpin for Wrapper<T> where T: UnsafeUnpin {}`// Now, our generated impl has a bound involving a type defined in another// crate - Wrapper. This will cause rust to conservatively assume that// `Wrapper<MyStruct<T>>: UnsafeUnpin` holds, in the interest of preserving// forwards compatibility (in case such an impl is added for Wrapper<T> in// a new version of the crate).// This will cause rust to reject any other `Unpin` impls for MyStruct<T>,// since it will assume that our generated impl could potentially apply in// any situation.// This achieves the desired effect - when the user writes// `#[pin_project(UnsafeUnpin)]`, the user must either provide no impl of// `UnsafeUnpin` (which is equivalent to making the type never implement// Unpin), or provide an impl of `UnsafeUnpin`. It is impossible for them to// provide an impl of `Unpin`// SAFETY: `T` implements UnsafeUnpin.AlwaysUnpin// See https://github.com/taiki-e/pin-project/pull/53 for more details.UnsafeDropInPlaceGuard// This is an internal helper used to ensure a value is dropped.UnsafeOverwriteGuard// This is an internal helper used to ensure a value is overwritten without// its destructor being called./*!
<!-- tidy:crate-doc:start -->
A crate for safe and ergonomic [pin-projection].

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
pin-project = "1"
```

*Compiler support: requires rustc 1.56+*

## Examples

[`#[pin_project]`][`pin_project`] attribute creates projection types
covering all the fields of struct or enum.

```rust
use std::pin::Pin;

use pin_project::pin_project;

#[pin_project]
struct Struct<T, U> {
    #[pin]
    pinned: T,
    unpinned: U,
}

impl<T, U> Struct<T, U> {
    fn method(self: Pin<&mut Self>) {
        let this = self.project();
        let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
        let _: &mut U = this.unpinned; // Normal reference to the field
    }
}
```

[*code like this will be generated*][struct-default-expanded]

To use `#[pin_project]` on enums, you need to name the projection type
returned from the method.

```rust
use std::pin::Pin;

use pin_project::pin_project;

#[pin_project(project = EnumProj)]
enum Enum<T, U> {
    Pinned(#[pin] T),
    Unpinned(U),
}

impl<T, U> Enum<T, U> {
    fn method(self: Pin<&mut Self>) {
        match self.project() {
            EnumProj::Pinned(x) => {
                let _: Pin<&mut T> = x;
            }
            EnumProj::Unpinned(y) => {
                let _: &mut U = y;
            }
        }
    }
}
```

[*code like this will be generated*][enum-default-expanded]

See [`#[pin_project]`][`pin_project`] attribute for more details, and
see [examples] directory for more examples and generated code.

## Related Projects

- [pin-project-lite]: A lightweight version of pin-project written with declarative macros.

[enum-default-expanded]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/enum-default-expanded.rs
[examples]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/README.md
[pin-project-lite]: https://github.com/taiki-e/pin-project-lite
[pin-projection]: https://doc.rust-lang.org/std/pin/index.html#projections-and-structural-pinning
[struct-default-expanded]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/struct-default-expanded.rs

<!-- tidy:crate-doc:end -->
*//// An attribute that creates projection types covering all the fields of/// struct or enum./// This attribute creates projection types according to the following rules:/// - For the fields that use `#[pin]` attribute, create the pinned reference to///   the field./// - For the other fields, create a normal reference to the field./// And the following methods are implemented on the original type:/// # type Projection<'a> = &'a ();/// # type ProjectionRef<'a> = &'a ();/// # trait Dox {/// fn project(self: Pin<&mut Self>) -> Projection<'_>;/// fn project_ref(self: Pin<&Self>) -> ProjectionRef<'_>;/// By passing an argument with the same name as the method to the attribute,/// you can name the projection type returned from the method. This allows you/// to use pattern matching on the projected types./// # use pin_project::pin_project;/// #[pin_project(project = EnumProj)]/// enum Enum<T> {///     Variant(#[pin] T),/// impl<T> Enum<T> {///     fn method(self: Pin<&mut Self>) {///         let this: EnumProj<'_, T> = self.project();///         match this {///             EnumProj::Variant(x) => {///                 let _: Pin<&mut T> = x;/// Note that the projection types returned by `project` and `project_ref` have/// an additional lifetime at the beginning of generics./// let this: EnumProj<'_, T> = self.project();///                    ^^/// The visibility of the projected types and projection methods is based on the/// original type. However, if the visibility of the original type is `pub`, the/// visibility of the projected types and the projection methods is downgraded/// to `pub(crate)`./// This attribute is completely safe. In the absence of other `unsafe` code/// *that you write*, it is impossible to cause [undefined/// behavior][undefined-behavior] with this attribute./// This is accomplished by enforcing the four requirements for pin projection/// stated in [the Rust documentation][pin-projection]:/// 1. The struct must only be [`Unpin`] if all the structural fields are///    [`Unpin`].///    To enforce this, this attribute will automatically generate an [`Unpin`]///    implementation for you, which will require that all structurally pinned///    fields be [`Unpin`].///    If you attempt to provide an [`Unpin`] impl, the blanket impl will then///    apply to your type, causing a compile-time error due to the conflict with///    the second impl.///    If you wish to provide a manual [`Unpin`] impl, you can do so via the///    [`UnsafeUnpin`][unsafe-unpin] argument./// 2. The destructor of the struct must not move structural fields out of its///    argument.///    To enforce this, this attribute will generate code like this:///    ```///    struct MyStruct {}///    trait MyStructMustNotImplDrop {}///    # #[allow(unknown_lints, drop_bounds)]///    impl<T: Drop> MyStructMustNotImplDrop for T {}///    impl MyStructMustNotImplDrop for MyStruct {}///    If you attempt to provide an [`Drop`] impl, the blanket impl will then///    If you wish to provide a custom [`Drop`] impl, you can annotate an impl///    with [`#[pinned_drop]`][pinned-drop]. This impl takes a pinned version of///    your struct - that is, [`Pin`]`<&mut MyStruct>` where `MyStruct` is the///    type of your struct.///    You can call `.project()` on this type as usual, along with any other///    methods you have defined. Because your code is never provided with///    a `&mut MyStruct`, it is impossible to move out of pin-projectable///    fields in safe code in your destructor./// 3. You must make sure that you uphold the [`Drop`///    guarantee][drop-guarantee]: once your struct is pinned, the memory that///    contains the content is not overwritten or deallocated without calling///    the content's destructors.///    Safe code doesn't need to worry about this - the only way to violate///    this requirement is to manually deallocate memory (which is `unsafe`),///    or to overwrite a field with something else.///    Because your custom destructor takes [`Pin`]`<&mut MyStruct>`, it's///    impossible to obtain a mutable reference to a pin-projected field in safe///    code./// 4. You must not offer any other operations that could lead to data being///    moved out of the structural fields when your type is pinned.///    As with requirement 3, it is impossible for safe code to violate this.///    This crate ensures that safe code can never obtain a mutable reference to///    `#[pin]` fields, which prevents you from ever moving out of them in safe/// Pin projections are also incompatible with [`#[repr(packed)]`][repr-packed]/// types. Attempting to use this attribute on a `#[repr(packed)]` type results/// in a compile-time error./// `#[pin_project]` can be used on structs and enums./// use pin_project::pin_project;/// #[pin_project]/// struct Struct<T, U> {///     pinned: T,///     unpinned: U,/// impl<T, U> Struct<T, U> {///         let this = self.project();///         let _: Pin<&mut T> = this.pinned;///         let _: &mut U = this.unpinned;/// struct TupleStruct<T, U>(#[pin] T, U);/// impl<T, U> TupleStruct<T, U> {///         let _: Pin<&mut T> = this.0;///         let _: &mut U = this.1;/// To use `#[pin_project]` on enums, you need to name the projection type/// returned from the method./// enum Enum<T, U> {///     Tuple(#[pin] T),///     Struct { field: U },/// impl<T, U> Enum<T, U> {///         match self.project() {///             EnumProj::Tuple(x) => {///             EnumProj::Struct { field } => {///                 let _: &mut U = field;///             EnumProj::Unit => {}/// When `#[pin_project]` is used on enums, only named projection types and/// methods are generated because there is no way to access variants of/// projected types without naming it./// For example, in the above example, only the `project` method is generated,/// and the `project_ref` method is not generated./// (When `#[pin_project]` is used on structs, both methods are always generated.)/// ```compile_fail,E0599/// # #[pin_project(project = EnumProj)]/// # enum Enum<T, U> {/// #     Tuple(#[pin] T),/// #     Struct { field: U },/// #     Unit,///     fn call_project_ref(self: Pin<&Self>) {///         let _this = self.project_ref();///         //~^ ERROR no method named `project_ref` found for struct `Pin<&Enum<T, U>>` in the current scope/// If you want to call `.project()` multiple times or later use the/// original [`Pin`] type, it needs to use [`.as_mut()`][`Pin::as_mut`] to avoid/// consuming the [`Pin`]./// struct Struct<T> {///     field: T,/// impl<T> Struct<T> {///     fn call_project_twice(mut self: Pin<&mut Self>) {///         // `project` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.///         self.as_mut().project();/// # `!Unpin`/// If you want to ensure that [`Unpin`] is not implemented, use the `!Unpin`/// argument to `#[pin_project]`./// #[pin_project(!Unpin)]/// This is equivalent to using `#[pin]` attribute for the [`PhantomPinned`]/// use std::marker::PhantomPinned;///     #[pin] // <------ This `#[pin]` is required to make `Struct` to `!Unpin`.///     _pin: PhantomPinned,/// Note that using [`PhantomPinned`] without `#[pin]` attribute has no effect./// # `UnsafeUnpin`/// If you want to implement [`Unpin`] manually, you must use the `UnsafeUnpin`/// unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}/// Note the usage of the unsafe [`UnsafeUnpin`] trait, instead of the usual/// [`Unpin`] trait. [`UnsafeUnpin`] behaves exactly like [`Unpin`], except that/// is unsafe to implement. This unsafety comes from the fact that pin/// projections are being used. If you implement [`UnsafeUnpin`], you must/// ensure that it is only implemented when all pin-projected fields implement/// See [`UnsafeUnpin`] trait for more details./// # `#[pinned_drop]`/// In order to correctly implement pin projections, a type's [`Drop`] impl must/// not move out of any structurally pinned fields. Unfortunately,/// [`Drop::drop`] takes `&mut Self`, not [`Pin`]`<&mut Self>`./// To ensure that this requirement is upheld, the `#[pin_project]` attribute/// will provide a [`Drop`] impl for you. This [`Drop`] impl will delegate to/// an impl block annotated with `#[pinned_drop]` if you use the `PinnedDrop`/// This impl block acts just like a normal [`Drop`] impl,/// except for the following two:/// - `drop` method takes [`Pin`]`<&mut Self>`/// - Name of the trait is `PinnedDrop`./// pub trait PinnedDrop {///     fn drop(self: Pin<&mut Self>);/// `#[pin_project]` implements the actual [`Drop`] trait via `PinnedDrop` you/// implemented. To drop a type that implements `PinnedDrop`, use the [`drop`]/// function just like dropping a type that directly implements [`Drop`]./// In particular, it will never be called more than once, just like/// [`Drop::drop`]./// use std::{fmt::Debug, pin::Pin};/// use pin_project::{pin_project, pinned_drop};/// #[pin_project(PinnedDrop)]/// struct PrintOnDrop<T: Debug, U: Debug> {///     pinned_field: T,///     unpin_field: U,/// #[pinned_drop]/// impl<T: Debug, U: Debug> PinnedDrop for PrintOnDrop<T, U> {///     fn drop(self: Pin<&mut Self>) {///         println!("Dropping pinned field: {:?}", self.pinned_field);///         println!("Dropping unpin field: {:?}", self.unpin_field);///     let _x = PrintOnDrop { pinned_field: true, unpin_field: 40 };/// See also [`#[pinned_drop]`][macro@pinned_drop] attribute./// # `project_replace` method/// In addition to the `project` and `project_ref` methods which are always/// provided when you use the `#[pin_project]` attribute, there is a third/// method, `project_replace` which can be useful in some situations. It is/// equivalent to [`Pin::set`], except that the unpinned fields are moved and/// returned, instead of being dropped in-place./// # type ProjectionOwned = ();/// fn project_replace(self: Pin<&mut Self>, other: Self) -> ProjectionOwned;/// The `ProjectionOwned` type is identical to the `Self` type, except that/// all pinned fields have been replaced by equivalent [`PhantomData`] types./// This method is opt-in, because it is only supported for [`Sized`] types, and/// because it is incompatible with the [`#[pinned_drop]`][pinned-drop]/// attribute described above. It can be enabled by using/// `#[pin_project(project_replace)]`./// use std::{marker::PhantomData, pin::Pin};/// #[pin_project(project_replace)]///     unpinned_field: U,///     fn method(self: Pin<&mut Self>, other: Self) {///         let this = self.project_replace(other);///         let _: U = this.unpinned_field;///         let _: PhantomData<T> = this.pinned_field;/// By passing the value to the `project_replace` argument, you can name the/// returned type of the `project_replace` method. This is necessary whenever/// destructuring the return type of the `project_replace` method, and work in exactly/// the same way as the `project` and `project_ref` arguments./// #[pin_project(project_replace = EnumProjOwn)]///     A {///         #[pin]///         pinned_field: T,///         unpinned_field: U,/// let mut x = Box::pin(Enum::A { pinned_field: 42, unpinned_field: "hello" });/// match x.as_mut().project_replace(Enum::B) {///     EnumProjOwn::A { unpinned_field, .. } => assert_eq!(unpinned_field, "hello"),///     EnumProjOwn::B => unreachable!(),/// [`PhantomData`]: core::marker::PhantomData/// [`Pin::as_mut`]: core::pin::Pin::as_mut/// [`Pin::set`]: core::pin::Pin::set/// [`Pin`]: core::pin::Pin/// [`UnsafeUnpin`]: https://docs.rs/pin-project/1/pin_project/trait.UnsafeUnpin.html/// [drop-guarantee]: core::pin#drop-guarantee/// [pinned-drop]: macro@pin_project#pinned_drop/// [repr-packed]: https://doc.rust-lang.org/nomicon/other-reprs.html#reprpacked/// [unsafe-unpin]: macro@pin_project#unsafeunpin/// An attribute used for custom implementations of [`Drop`]./// This attribute is used in conjunction with the `PinnedDrop` argument to/// The impl block annotated with this attribute acts just like a normal/// [`Drop`] impl, except for the following two:/// struct PrintOnDrop {///     field: u8,/// impl PinnedDrop for PrintOnDrop {///         println!("Dropping: {}", self.field);///     let _x = PrintOnDrop { field: 50 };/// See also ["pinned-drop" section of `#[pin_project]` attribute][pinned-drop]./// # Why `#[pinned_drop]` attribute is needed?/// Implementing `PinnedDrop::drop` is safe, but calling it is not safe./// This is because destructors can be called multiple times in safe code and/// [double dropping is unsound][rust-lang/rust#62360]./// Ideally, it would be desirable to be able to forbid manual calls in/// the same way as [`Drop::drop`], but the library cannot do it. So, by using/// macros and replacing them with private traits like the following,/// this crate prevent users from calling `PinnedDrop::drop` in safe code.///     unsafe fn drop(self: Pin<&mut Self>);/// This allows implementing [`Drop`] safely using `#[pinned_drop]`./// Also by using the [`drop`] function just like dropping a type that directly/// implements [`Drop`], can drop safely a type that implements `PinnedDrop`./// [rust-lang/rust#62360]: https://github.com/rust-lang/rust/pull/62360__pin_project_internal_derive//! Implementation detail of the `pin-project` crate. - **do not use directly**PINParseBufferExtSliceExtparse_args/// `PinnedDrop` argument.unpin_implUnpinImpl/// `UnsafeUnpin` or `!Unpin` argument./// `project = <ident>` argument.project_ref/// `project_ref = <ident>` argument.project_replaceProjReplace/// `project_replace [= <ident>]` argument./// `UnsafeUnpin`./// `!Unpin`./// `project_replace`./// `project_replace = <ident>`./// Return the span of this argument.// To generate the correct `Unpin` implementation and the projection methods,// we need to collect the types of the pinned fields.// However, since proc-macro-attribute is applied before `cfg` and `cfg_attr`// on fields, we cannot be collecting field types properly at this timing.// So instead of generating the `Unpin` implementation and the projection// methods here, delegate their processing to proc-macro-derive.// At this stage, only attributes are parsed and the following attributes are// added to the attributes of the item.// - `#[derive(InternalDerive)]` - An internal helper macro that does the above//   processing.// - `#[pin(__private(#args))]` - Pass the argument of `#[pin_project]` to//   proc-macro-derive (`InternalDerive`).determine_lifetime_namedetermine_visibilityinsert_lifetime_and_boundReplaceReceiverVariantsparse_deriveexposedGenerateTokensinto_tokensglobal_allowed_lints/// Returns attributes that should be applied to all generated code.proj_allowed_lints/// Returns attributes used on projected types.OriginalTypeProjectedType/// The projected types.pinned_fields/// Types of the pinned fields./// Kind of the original type: struct or enum/// `project` argument./// `project_ref` argument./// Attributes of the original type./// Visibility of the original type./// Name of the original type./// Generics of the original type./// Visibility of the projected types.mut_ident/// Name of the projected type returned by `project` method.ref_ident/// Name of the projected type returned by `project_ref` method.own_ident/// Name of the projected type returned by `project_replace` method./// Lifetime on the generated projected types./// Generics of the projected types.where_clause/// `where` clause of the projected types. This has an additional/// bound generated by `insert_lifetime_and_bound`proj_variantsproj_ref_variantsproj_own_variantsproj_armsproj_ref_armsproj_own_armsProjectedVariantsproj_patproj_bodyproj_own_bodyproj_fieldsproj_ref_fieldsproj_own_fieldsProjectedFieldsvalidate_structvalidate_enumBraceparse_structvisit_variantsvisit_fields/// Generates the processing that `project_replace` does for the struct or each variant./// Note: `pinned_fields` must be in declaration order.make_unpin_impl/// Creates `Unpin` implementation for the original type./// The kind of `Unpin` impl generated depends on `unpin_impl` field:/// - `UnpinImpl::Unsafe` - Implements `Unpin` via `UnsafeUnpin` impl./// - `UnpinImpl::Negative` - Generates `Unpin` impl with bounds that will never be true./// - `UnpinImpl::Default` - Generates `Unpin` impl that requires `Unpin` for all pinned fields.make_drop_impl/// Creates `Drop` implementation for the original type./// The kind of `Drop` impl generated depends on `pinned_drop` field:/// - `Some` - implements `Drop` via `PinnedDrop` impl./// - `None` - generates code that ensures that `Drop` trait is not implemented,///            instead of generating `Drop` impl.make_proj_impl/// Creates an implementation of the projection methods./// On structs, both the `project` and `project_ref` methods are always generated,/// and the `project_replace` method is only generated if `ProjReplace::span` is `Some`./// On enums, only methods that the returned projected type is named will be generated.ensure_not_packed/// Checks that the `[repr(packed)]` attribute is not included./// This currently does two checks:/// - Checks the attributes of structs to ensure there is no `[repr(packed)]`./// - Generates a function that borrows fields without an unsafe block and///   forbidding `unaligned_references` lint./// The annotation for pinned type.validate_impl/// Validates the signature of given `PinnedDrop` impl.validate_sig/// Validates the signature of given `PinnedDrop::drop` method./// The correct signature is: `(mut) self: (<path>::)Pin<&mut Self>`expand_impl// from:// fn drop(self: Pin<&mut Self>) {//     // ...// into:// unsafe fn drop(self: Pin<&mut Self>) {//     fn __drop_inner<T>(__self: Pin<&mut Foo<'_, T>>) {//         fn __drop_inner() {}//         // ...//     __drop_inner(self);ExprStructPatStructPatTupleStructQSelf/// Determines the lifetime names. Ensure it doesn't overlap with any existing/// lifetime names./// Like `insert_lifetime`, but also generates a bound of the form/// `OriginalType<A, B>: 'lifetime`. Used when generating the definition/// of a projection typeinsert_lifetime/// Inserts a `lifetime` at position `0` of `generics.params`./// Determines the visibility of the projected types and projection methods./// If given visibility is `pub`, returned visibility is `pub(crate)`./// Otherwise, returned visibility is the same as given visibility.respanrespan_tokensposition_exact/// - There are multiple specified attributes./// - The `Attribute::tokens` field of the specified attribute is not empty.self_to_qselfself_to_expr_pathvisit_type_mut// `Self` -> `Receiver`// `Self::Assoc` -> `<Receiver>::Assoc`// `Self::method` -> `<Receiver>::method`visit_expr_struct_mutvisit_pat_struct_mutvisit_pat_tuple_struct_mut// =================================================================================================// extension traits// visitors// Replace `self`/`Self` with `__self`/`self_ty`.// Based on:// - https://github.com/dtolnay/async-trait/blob/0.1.35/src/receiver.rs// - https://github.com/dtolnay/async-trait/commit/6029cbf375c562ca98fa5748e9d950a8ff93b0e7/// A macro that creates a projection type covering all the fields of struct./// This macro creates a projection type according to the following rules:/// - For the field that uses `#[pin]` attribute, makes the pinned reference to the field./// - For the other fields, makes the unpinned reference to the field./// By passing an attribute with the same name as the method to the macro,/// # use pin_project_lite::pin_project;/// pin_project! {///     #[project = EnumProj]///     enum Enum<T> {///         Variant { #[pin] field: T },///             EnumProj::Variant { field } => {///                 let _: Pin<&mut T> = field;/// By passing the `#[project_replace = MyProjReplace]` attribute you may create an additional/// method which allows the contents of `Pin<&mut Self>` to be replaced while simultaneously moving/// out all unpinned fields in `Self`./// # type MyProjReplace = ();/// fn project_replace(self: Pin<&mut Self>, replacement: Self) -> MyProjReplace;/// Also, note that the projection types returned by `project` and `project_ref` have/// `pin_project!` macro guarantees safety in much the same way as [pin-project] crate./// Both are completely safe unless you write other unsafe code./// See [pin-project] crate for more details./// use pin_project_lite::pin_project;///     struct Struct<T, U> {///         pinned: T,///         unpinned: U,///         let _: Pin<&mut T> = this.pinned; // Pinned reference to the field///         let _: &mut U = this.unpinned; // Normal reference to the field/// To use `pin_project!` on enums, you need to name the projection type///         Struct {///             #[pin]///             field: T,///         Unit,/// If you want to call the `project()` method multiple times or later use the///     struct Struct<T> {///         field: T,/// If you want to make sure `Unpin` is not implemented, use the `#[project(!Unpin)]`/// attribute.///      #[project(!Unpin)]///      struct Struct<T> {///          #[pin]///          field: T,/// This is equivalent to using `#[pin]` attribute for a [`PhantomPinned`] field.///         _pin: PhantomPinned,/// Note that using [`PhantomPinned`] without `#[pin]` or `#[project(!Unpin)]`/// attribute has no effect./// # Pinned Drop/// In order to correctly implement pin projections, a type’s [`Drop`] impl must not move out of any/// structurally pinned fields. Unfortunately, [`Drop::drop`] takes `&mut Self`, not `Pin<&mut/// Self>`./// To implement [`Drop`] for type that has pin, add an `impl PinnedDrop` block at the end of the/// [`pin_project`] macro block. PinnedDrop has the following interface:/// trait PinnedDrop {///     fn drop(this: Pin<&mut Self>);/// Note that the argument to `PinnedDrop::drop` cannot be named `self`./// `pin_project!` implements the actual [`Drop`] trait via PinnedDrop you implemented. To/// explicitly drop a type that implements PinnedDrop, use the [drop] function just like dropping a/// type that directly implements [`Drop`]./// `PinnedDrop::drop` will never be called more than once, just like [`Drop::drop`].///     pub struct Struct<'a> {///         was_dropped: &'a mut bool,///         field: u8,///     impl PinnedDrop for Struct<'_> {///         fn drop(this: Pin<&mut Self>) { // <----- NOTE: this is not `self`///             **this.project().was_dropped = true;/// let mut was_dropped = false;/// drop(Struct { was_dropped: &mut was_dropped, field: 42 });/// assert!(was_dropped);/// [pin-project]: https://github.com/taiki-e/pin-project__pin_project_make_proj_replace_block__pin_project_struct_make_proj_method__pin_project_struct_make_proj_replace_method__pin_project_enum_make_proj_method__pin_project_enum_make_proj_replace_method__pin_project_make_unpin_impl__pin_project_make_drop_impl__pin_project_make_unpin_bound__pin_project_make_unsafe_field_proj__pin_project_make_replace_field_proj__pin_project_make_unsafe_drop_in_place_guard__pin_project_make_proj_field_ref// parsing proj_mut_ident// parsing proj_ref_ident// parsing proj_replace_ident// parsing !Unpin// this is actually part of a recursive step that picks off a single non-`pin_project_lite` attribute// there could be more to parse// now determine visibility// if public, downgrade// This is an internal helper struct used by `pin_project!`./*!
<!-- tidy:crate-doc:start -->
A lightweight version of [pin-project] written with declarative macros.

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
pin-project-lite = "0.2"
```

*Compiler support: requires rustc 1.37+*

## Examples

[`pin_project!`] macro creates a projection type covering all the fields of
struct.

```rust
use std::pin::Pin;

use pin_project_lite::pin_project;

pin_project! {
    struct Struct<T, U> {
        #[pin]
        pinned: T,
        unpinned: U,
    }
}

impl<T, U> Struct<T, U> {
    fn method(self: Pin<&mut Self>) {
        let this = self.project();
        let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
        let _: &mut U = this.unpinned; // Normal reference to the field
    }
}
```

To use [`pin_project!`] on enums, you need to name the projection type
returned from the method.

```rust
use std::pin::Pin;

use pin_project_lite::pin_project;

pin_project! {
    #[project = EnumProj]
    enum Enum<T, U> {
        Variant { #[pin] pinned: T, unpinned: U },
    }
}

impl<T, U> Enum<T, U> {
    fn method(self: Pin<&mut Self>) {
        match self.project() {
            EnumProj::Variant { pinned, unpinned } => {
                let _: Pin<&mut T> = pinned;
                let _: &mut U = unpinned;
            }
        }
    }
}
```

## [pin-project] vs pin-project-lite

Here are some similarities and differences compared to [pin-project].

### Similar: Safety

pin-project-lite guarantees safety in much the same way as [pin-project].
Both are completely safe unless you write other unsafe code.

### Different: Minimal design

This library does not tackle as expansive of a range of use cases as
[pin-project] does. If your use case is not already covered, please use
[pin-project].

### Different: No proc-macro related dependencies

This is the **only** reason to use this crate. However, **if you already
have proc-macro related dependencies in your crate's dependency graph, there
is no benefit from using this crate.** (Note: There is almost no difference
in the amount of code generated between [pin-project] and pin-project-lite.)

### Different: No useful error messages

This macro does not handle any invalid input. So error messages are not to
be useful in most cases. If you do need useful error messages, then upon
error you can pass the same input to [pin-project] to receive a helpful
description of the compile error.

### Different: No support for custom Unpin implementation

pin-project supports this by [`UnsafeUnpin`][unsafe-unpin]. (`!Unpin` is supported by both [pin-project][not-unpin] and [pin-project-lite][not-unpin-lite].)

### Different: No support for tuple structs and tuple variants

pin-project supports this.

[not-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin
[not-unpin-lite]: https://docs.rs/pin-project-lite/0.2/pin_project_lite/macro.pin_project.html#unpin
[pin-project]: https://github.com/taiki-e/pin-project
[unsafe-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unsafeunpin

<!-- tidy:crate-doc:end -->
*/// #![warn(unsafe_op_in_unsafe_fn)] // requires Rust 1.52// limitations:// - no support for tuple structs and tuple variant (wontfix).// - no support for multiple trait/lifetime bounds.// - no support for `Self` in where clauses. (wontfix)// - no support for overlapping lifetime names. (wontfix)// - no interoperability with other field attributes.// - no useful error messages. (wontfix)// etc...stack_pin//! Utilities for pinning/// A pinned projection of a struct field./// To make using this macro safe, three things need to be ensured:/// - If the struct implements [`Drop`], the [`drop`] method is not allowed to///   move the value of the field./// - If the struct wants to implement [`Unpin`], it has to do so conditionally:///   The struct can only implement [`Unpin`] if the field's type is [`Unpin`]./// - The struct must not be `#[repr(packed)]`./// use pin_utils::unsafe_pinned;/// use std::marker::Unpin;/// struct Foo<T> {/// impl<T> Foo<T> {///     unsafe_pinned!(field: T);///     fn baz(mut self: Pin<&mut Self>) {///         let _: Pin<&mut T> = self.field(); // Pinned reference to the field/// impl<T: Unpin> Unpin for Foo<T> {} // Conditional Unpin impl/// Note: borrowing the field multiple times requires using `.as_mut()` to/// avoid consuming the `Pin`./// [`Unpin`]: core::marker::Unpin/// [`drop`]: Drop::drop/// An unpinned projection of a struct field./// This macro is unsafe because it creates a method that returns a normal/// non-pin reference to the struct field. It is up to the programmer to ensure/// that the contained value can be considered not pinned in the current/// use pin_utils::unsafe_unpinned;/// struct Bar;///     field: Bar,///     unsafe_unpinned!(field: Bar);///         let _: &mut Bar = self.field(); // Normal reference to the field/// avoid consuming the [`Pin`]./// Pins a value on the stack./// # use pin_utils::pin_mut;/// # use core::pin::Pin;/// # struct Foo {}/// let foo = Foo { /* ... */ };/// pin_mut!(foo);/// let _: Pin<&mut Foo> = foo;/// Creates a bounded single-producer single-consumer pipe./// A pipe is a ring buffer of `cap` bytes that can be asynchronously read from and written to./// See the [crate-level documentation](index.html) for more details./// This function panics if `cap` is 0 or if `cap * 2` overflows a `usize`.// false positive: https://github.com/rust-lang/rust-clippy/issues/12280/// The inner ring buffer./// The head index, moved by the reader, in the range `0..2*cap`./// This index always matches `inner.head`./// The tail index, moved by the writer, in the range `0..2*cap`./// This index is a snapshot of `index.tail` that might become stale at any point./// Random number generator./// The reading side of a pipe./// This type is created by the [`pipe`] function. See its documentation for more details./// This index is a snapshot of `index.head` that might become stale at any point./// This index always matches `inner.tail`.zeroed_until/// How many bytes at the beginning of the buffer have been zeroed./// The pipe allocates an uninitialized buffer, and we must be careful about passing/// uninitialized data to user code. Zeroing the buffer right after allocation would be too/// expensive, so we zero it in smaller chunks as the writer makes progress./// The writing side of a pipe./// A waker representing the blocked reader./// A waker representing the blocked writer./// Set to `true` if the reader or writer was dropped./// The byte buffer./// The buffer capacity./// Head and tail indices are in the range `0..2*cap`, even though they really map onto the/// `0..cap` range. The distance between head and tail indices is never more than `cap`./// The reason why indices are not in the range `0..cap` is because we need to distinguish between/// the pipe being empty and being full. If head and tail were in `0..cap`, then `head == tail`/// could mean the pipe is either empty or full, but we don't know which!/// Get the length of the data in the pipe./// Gets the total length of the data in the pipe./// This method returns the number of bytes that have been written into the pipe but haven't been/// read yet./// # futures_lite::future::poll_fn(|cx| {/// let (mut reader, mut writer) = piper::pipe(10);/// let _ = writer.poll_fill_bytes(cx, &[0u8; 5]);/// assert_eq!(reader.len(), 5);/// # std::task::Poll::Ready(()) }).await;/// Tell whether or not the pipe is empty./// This method returns `true` if the pipe is empty, and `false` otherwise./// assert!(reader.is_empty());/// assert!(!reader.is_empty());/// Gets the total capacity of the pipe./// This method returns the number of bytes that the pipe can hold at a time./// let (reader, _) = piper::pipe(10);/// assert_eq!(reader.capacity(), 10);/// Tell whether or not the pipe is full./// The pipe is full if the number of bytes written into it is equal to its capacity. At this point,/// writes will block until some data is read from the pipe./// This method returns `true` if the pipe is full, and `false` otherwise./// assert!(!reader.is_full());/// let _ = writer.poll_fill_bytes(cx, &[0u8; 10]);/// assert!(reader.is_full());/// let _ = reader.poll_drain_bytes(cx, &mut [0u8; 5]);/// Tell whether or not the pipe is closed./// The pipe is closed if either the reader or the writer has been dropped. At this point, attempting/// to write into the pipe will return `Poll::Ready(Ok(0))` and attempting to read from the pipe after/// any previously written bytes are read will return `Poll::Ready(Ok(0))`./// assert!(!reader.is_closed());/// drop(writer);/// assert!(reader.is_closed());poll_drain/// Reads bytes from this reader and writes into blocking `dest`./// This method reads directly from the pipe's internal buffer into `dest`. This avoids an extra copy,/// but it may block the thread if `dest` blocks./// If the pipe is empty, this method returns `Poll::Pending`. If the pipe is closed, this method/// returns `Poll::Ready(Ok(0))`. Errors in `dest` are bubbled up through `Poll::Ready(Err(e))`./// Otherwise, this method returns `Poll::Ready(Ok(n))` where `n` is the number of bytes written./// This method is only available when the `std` feature is enabled. For `no_std` environments,/// consider using [`poll_drain_bytes`] instead./// [`poll_drain_bytes`]: #method.poll_drain_bytes/// use futures_lite::{future, prelude::*};/// # future::block_on(async {/// let (mut r, mut w) = piper::pipe(1024);/// // Write some data to the pipe./// w.write_all(b"hello world").await.unwrap();/// // Try reading from the pipe./// let mut buf = [0; 1024];/// let n = future::poll_fn(|cx| r.poll_drain(cx, &mut buf[..])).await.unwrap();/// // The data was written to the buffer./// assert_eq!(&buf[..n], b"hello world");poll_drain_bytes/// Reads bytes from this reader./// Rather than taking a `Write` trait object, this method takes a slice of bytes to write into./// Because of this, it is infallible and can be used in `no_std` environments./// The same conditions that apply to [`poll_drain`] apply to this method./// [`poll_drain`]: #method.poll_drain/// let n = future::poll_fn(|cx| r.poll_drain_bytes(cx, &mut buf[..])).await;try_drain/// Tries to read bytes from this reader./// Returns the total number of bytes that were read from this reader./// // `try_drain()` returns 0 off the bat./// let mut buf = [0; 10];/// assert_eq!(r.try_drain(&mut buf), 0);/// // After a write it returns the data./// w.try_fill(&[0, 1, 2, 3, 4]);/// assert_eq!(r.try_drain(&mut buf), 5);/// assert_eq!(&buf[..5], &[0, 1, 2, 3, 4]);WriteLikedrain_inner/// let (_reader, mut writer) = piper::pipe(10);/// assert_eq!(writer.len(), 5);/// assert!(!writer.is_empty());/// let (_, writer) = piper::pipe(10);/// assert_eq!(writer.capacity(), 10);/// assert!(!writer.is_full());/// assert!(writer.is_full());/// let (reader, writer) = piper::pipe(10);/// assert!(!writer.is_closed());/// drop(reader);/// assert!(writer.is_closed());/// Reads bytes from blocking `src` and writes into this writer./// This method writes directly from `src` into the pipe's internal buffer. This avoids an extra copy,/// but it may block the thread if `src` blocks./// If the pipe is full, this method returns `Poll::Pending`. If the pipe is closed, this method/// returns `Poll::Ready(Ok(0))`. Errors in `src` are bubbled up through `Poll::Ready(Err(e))`./// Otherwise, this method returns `Poll::Ready(Ok(n))` where `n` is the number of bytes read./// consider using [`poll_fill_bytes`] instead./// [`poll_fill_bytes`]: #method.poll_fill_bytes/// // Create a pipe./// let (mut reader, mut writer) = piper::pipe(1024);/// // Fill the pipe with some bytes./// let data = b"hello world";/// let n = future::poll_fn(|cx| writer.poll_fill(cx, &data[..])).await.unwrap();/// assert_eq!(n, data.len());/// // Read the bytes back./// reader.read_exact(&mut buf[..data.len()]).await.unwrap();/// assert_eq!(&buf[..data.len()], data);poll_fill_bytes/// Writes bytes into this writer./// Rather than taking a `Read` trait object, this method takes a slice of bytes to read from./// The same conditions that apply to [`poll_fill`] apply to this method./// [`poll_fill`]: #method.poll_fill/// let n = future::poll_fn(|cx| writer.poll_fill_bytes(cx, &data[..])).await;try_fill/// Tries to write bytes to this writer./// assert_eq!(w.try_fill(&[0, 1, 2, 3, 4]), 5);ReadLike/// The error type./// Reads bytes into the given buffer./// A trait for reading bytes into a pipe.ReadBytes/// Implements `no_std` reading around a byte slice./// Writes bytes from the given buffer./// A trait for writing bytes from a pipe.WriteBytes/// Implements `no_std` writing around a byte slice.maybe_yield/// Yield with some small probability./// Get a random number generator./// use piper::{Reader, Writer};/// fn _send_sync<T: Send + Sync>() {}/// _send_sync::<Reader>();/// _send_sync::<Writer>();//! A bounded single-producer single-consumer pipe.//! This crate provides a ring buffer that can be asynchronously read from and written to. It is//! created via the [`pipe`] function, which returns a pair of [`Reader`] and [`Writer`] handles.//! They implement the [`AsyncRead`] and [`AsyncWrite`] traits, respectively.//! The handles are single-producer/single-consumer; to clarify, they cannot be cloned and need `&mut`//! access to read or write to them. If multiple-producer/multiple-consumer handles are needed,//! consider wrapping them in an `Arc<Mutex<...>>` or similar.//! When the sender is dropped, remaining bytes in the pipe can still be read. After that, attempts//! to read will result in `Ok(0)`, i.e. they will always 'successfully' read 0 bytes.//! When the receiver is dropped, the pipe is closed and no more bytes and be written into it.//! Further writes will result in `Ok(0)`, i.e. they will always 'successfully' write 0 bytes.//! # Version 0.2.0 Notes//! Previously, this crate contained other synchronization primitives, such as bounded channels, locks,//! and event listeners. These have been split out into their own crates://! - [`async-channel`](https://docs.rs/async-channel)//! - [`async-dup`](https://docs.rs/async-dup)//! - [`async-lock`](https://docs.rs/async-lock)//! - [`async-mutex`](https://docs.rs/async-mutex)//! - [`event-listener`](https://docs.rs/event-listener)//! ## Asynchronous Tasks//! Communicate between asynchronous tasks, potentially on other threads.//! use async_channel::unbounded;//! use easy_parallel::Parallel;//! use futures_lite::{future, prelude::*};//! # if cfg!(miri) { return; }//! // Create a pair of handles.//! let (mut reader, mut writer) = piper::pipe(1024);//! // Create the executor.//! let (signal, shutdown) = unbounded::<()>();//! // Spawn a detached task for random data to the pipe.//! let writer = ex.spawn(async move {//!     for _ in 0..1_000 {//!         // Generate 8 random numnbers.//!         let random = fastrand::u64(..).to_le_bytes();//!         // Write them to the pipe.//!         writer.write_all(&random).await.unwrap();//!         // Wait a bit.//!         async_io::Timer::after(Duration::from_millis(5)).await;//!     // Drop the writer to close the pipe.//!     drop(writer);//! // Detach the task so that it runs in the background.//! writer.detach();//! // Spawn a task for reading from the pipe.//! let reader = ex.spawn(async move {//!     let mut buf = vec![];//!     // Read all bytes from the pipe.//!     reader.read_to_end(&mut buf).await.unwrap();//!     println!("Random data: {:#?}", buf);//! Parallel::new()//!     // Run four executor threads.//!     .each(0..4, |_| future::block_on(ex.run(shutdown.recv())))//!     // Run the main future on the current thread.//!     .finish(|| future::block_on(async {//!         // Wait for the reader to finish.//!         reader.await;//!         // Signal the executor threads to shut down.//!         drop(signal);//! ## Blocking I/O//! File I/O is blocking; therefore, in `async` code, you must run it on another thread. This example//! spawns another thread for reading a file and writing it to a pipe.//! let (mut r, mut w) = piper::pipe(1024);//! // Spawn a thread for reading a file.//!     let mut file = File::open("Cargo.toml").unwrap();//!     // Read the file into a buffer.//!     let mut buf = [0u8; 16384];//!     future::block_on(async move {//!         loop {//!             // Read a chunk of bytes from the file.//!             // Blocking is okay here, since this is a separate thread.//!             let n = file.read(&mut buf).unwrap();//!             if n == 0 {//!             // Write the chunk to the pipe.//!             w.write_all(&buf[..n]).await.unwrap();//!         // Close the pipe.//!         drop(w);//! # future::block_on(async move {//! // Read bytes from the pipe.//! let mut buf = vec![];//! r.read_to_end(&mut buf).await.unwrap();//! println!("Read {} bytes", buf.len());//! However, the lower-level [`poll_fill`] and [`poll_drain`] methods take `impl Read` and `impl Write`//! arguments, respectively. This allows you to skip the buffer entirely and read/write directly from//! the file into the pipe. This approach should be preferred when possible, as it avoids an extra//! copy.//! # use futures_lite::future;//! # let mut file: File = unimplemented!();//! # let mut w: piper::Writer = unimplemented!();//! // In the `future::block_on` call above...//!     let n = future::poll_fn(|cx| w.poll_fill(cx, &mut file)).await.unwrap();//!     if n == 0 {//! The [`blocking`] crate is preferred in this use case, since it uses more efficient strategies for//! thread management and pipes.//! [`poll_fill`]: struct.Writer.html#method.poll_fill//! [`poll_drain`]: struct.Reader.html#method.poll_drainEncryptionSchemepbes2encryption_algorithm/// Algorithm identifier describing a password-based symmetric encryption/// scheme used to encrypt the `encrypted_data` field.encrypted_data/// Private key dataEncryptedPrivateKeyInfo/// PKCS#8 `EncryptedPrivateKeyInfo`./// ASN.1 structure containing a PKCS#5 [`EncryptionScheme`] identifier for a/// password-based symmetric encryption scheme and encrypted private key data./// ## Schema/// Structure described in [RFC 5208 Section 6]:/// EncryptedPrivateKeyInfo ::= SEQUENCE {///   encryptionAlgorithm  EncryptionAlgorithmIdentifier,///   encryptedData        EncryptedData }/// EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier/// EncryptedData ::= OCTET STRING/// [RFC 5208 Section 6]: https://tools.ietf.org/html/rfc5208#section-6/// Attempt to decrypt this encrypted private key using the provided/// password to derive an encryption key./// Encrypt the given ASN.1 DER document using a symmetric encryption key/// derived from the provided password.encrypt_with/// Encrypt this private key using a symmetric encryption key derived/// from the provided password and [`pbes2::Parameters`].//! PKCS#8 `EncryptedPrivateKeyInfo`Asn1/// ASN.1 DER-related errors.KeyMalformed/// Malformed cryptographic key contained in a PKCS#8 document./// This is intended for relaying errors related to the raw data contained/// within [`PrivateKeyInfo::private_key`][`crate::PrivateKeyInfo::private_key`]/// or [`SubjectPublicKeyInfo::subject_public_key`][`crate::SubjectPublicKeyInfo::subject_public_key`].ParametersMalformed/// [`AlgorithmIdentifier::parameters`][`crate::AlgorithmIdentifierRef::parameters`]/// is malformed or otherwise encoded in an unexpected manner./// Public key errors propagated from the [`spki::Error`] type.private_key_info//! ## About this crate//! This library provides generalized PKCS#8 support designed to work with a//! number of different algorithms. It supports `no_std` platforms including//! ones without a heap (albeit with reduced functionality).//! It supports decoding/encoding the following types://! - [`EncryptedPrivateKeyInfo`]: (with `pkcs5` feature) encrypted key.//! - [`PrivateKeyInfo`]: algorithm identifier and data representing a private key.//!   Optionally also includes public key data for asymmetric keys.//! - [`SubjectPublicKeyInfo`]: algorithm identifier and data representing a public key//!   (re-exported from the [`spki`] crate)//! When the `pem` feature is enabled, it also supports decoding/encoding//! documents from "PEM encoding" format as defined in RFC 7468.//! ## Encrypted Private Key Support//! [`EncryptedPrivateKeyInfo`] supports decoding/encoding encrypted PKCS#8//! private keys and is gated under the `pkcs5` feature.//! When the `encryption` feature of this crate is enabled, it provides//! [`EncryptedPrivateKeyInfo::decrypt`] and [`PrivateKeyInfo::encrypt`]//! functions which are able to decrypt/encrypt keys using the following//! algorithms://! - [PKCS#5v2 Password Based Encryption Scheme 2 (RFC 8018)]//!   - Key derivation functions://!     - [scrypt] ([RFC 7914])//!     - PBKDF2 ([RFC 8018](https://datatracker.ietf.org/doc/html/rfc8018#section-5.2))//!       - SHA-2 based PRF with HMAC-SHA224, HMAC-SHA256, HMAC-SHA384, or HMAC-SHA512//!       - SHA-1 based PRF with HMAC-SHA1, when the `sha1` feature of this crate is enabled.//!   - Symmetric encryption: AES-128-CBC, AES-192-CBC, or AES-256-CBC//!     (best available options for PKCS#5v2)//!  //! ## Legacy DES-CBC and DES-EDE3-CBC (3DES) support (optional)//! When the `des-insecure` and/or `3des` features are enabled this crate provides support for//! private keys encrypted with with DES-CBC and DES-EDE3-CBC (3DES or Triple DES) symmetric//! encryption, respectively.//! ⚠️ WARNING ⚠️//! DES support (gated behind the `des-insecure` feature) is implemented to//! allow for decryption of legacy PKCS#8 files only.//! Such PKCS#8 documents should be considered *INSECURE* due to the short//! 56-bit key size of DES.//! New keys should use AES instead.//! [RFC 5208]: https://tools.ietf.org/html/rfc5208//! [RFC 5958]: https://tools.ietf.org/html/rfc5958//! [RFC 7914]: https://datatracker.ietf.org/doc/html/rfc7914//! [PKCS#5v2 Password Based Encryption Scheme 2 (RFC 8018)]: https://tools.ietf.org/html/rfc8018#section-6.2//! [scrypt]: https://en.wikipedia.org/wiki/ScryptPUBLIC_KEY_TAG/// Context-specific tag number for the public key./// X.509 `AlgorithmIdentifier` for the private key type./// Private key data./// Public key data, optionally available if version is V2./// PKCS#8 `PrivateKeyInfo`./// ASN.1 structure containing an `AlgorithmIdentifier`, private key/// data in an algorithm specific format, and optional attributes/// (ignored by this implementation)./// Supports PKCS#8 v1 as described in [RFC 5208] and PKCS#8 v2 as described/// in [RFC 5958]. PKCS#8 v2 keys include an additional public key field./// # PKCS#8 v1 `PrivateKeyInfo`/// Described in [RFC 5208 Section 5]:/// PrivateKeyInfo ::= SEQUENCE {///         version                   Version,///         privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,///         privateKey                PrivateKey,///         attributes           [0]  IMPLICIT Attributes OPTIONAL }/// Version ::= INTEGER/// PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier/// PrivateKey ::= OCTET STRING/// Attributes ::= SET OF Attribute/// # PKCS#8 v2 `OneAsymmetricKey`/// PKCS#8 `OneAsymmetricKey` as described in [RFC 5958 Section 2]:/// PrivateKeyInfo ::= OneAsymmetricKey/// OneAsymmetricKey ::= SEQUENCE {///     version                   Version,///     privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,///     privateKey                PrivateKey,///     attributes            [0] Attributes OPTIONAL,///     ...,///     [[2: publicKey        [1] PublicKey OPTIONAL ]],/// Version ::= INTEGER { v1(0), v2(1) } (v1, ..., v2)/// PublicKey ::= BIT STRING/// [RFC 5208]: https://tools.ietf.org/html/rfc5208/// [RFC 5958]: https://datatracker.ietf.org/doc/html/rfc5958/// [RFC 5208 Section 5]: https://tools.ietf.org/html/rfc5208#section-5/// [RFC 5958 Section 2]: https://datatracker.ietf.org/doc/html/rfc5958#section-2/// Create a new PKCS#8 [`PrivateKeyInfo`] message./// This is a helper method which initializes `attributes` and `public_key`/// to `None`, helpful if you aren't using those./// Get the PKCS#8 [`Version`] for this structure./// [`Version::V1`] if `public_key` is `None`, [`Version::V2`] if `Some`.public_key_bit_string/// Get a `BIT STRING` representation of the public key, if present.//! PKCS#8 `PrivateKeyInfo`.from_pkcs8_der/// Deserialize PKCS#8 private key from ASN.1 DER-encoded data/// (binary format).from_pkcs8_pem/// Deserialize PKCS#8-encoded private key from PEM./// Keys in this format begin with the following delimiter:read_pkcs8_der_file/// Load PKCS#8 private key from an ASN.1 DER-encoded file on the local/// filesystem (binary format).read_pkcs8_pem_file/// Load PKCS#8 private key from a PEM-encoded file on the local filesystem./// Parse a private key object from a PKCS#8 encoded document./// Serialize a [`SecretDocument`] containing a PKCS#8-encoded private key.to_pkcs8_pem/// Serialize this private key as PEM-encoded PKCS#8 with the given [`LineEnding`].write_pkcs8_der_file/// Write ASN.1 DER-encoded PKCS#8 private key to the given pathwrite_pkcs8_pem_file/// Serialize a private key object to a PKCS#8 encoded document.//! Traits for parsing objects from PKCS#8 encoded documents/// Denotes PKCS#8 v1: no public key field./// Denotes PKCS#8 v2: `OneAsymmetricKey` with public key field./// Version identifier for PKCS#8 documents./// (RFC 5958 designates `0` and `1` as the only valid versions for PKCS#8 documents)has_public_key/// Is this version expected to have a public key?//! PKCS#8 version identifier.env_varsWrappedCommand/// Wrapper struct to polyfill methods introduced in 1.57 (`get_envs`, `get_args` etc)./// This is needed to reconstruct the pkg-config command for output in a copy-/// paste friendly format via `Display`.statikextra_argsenv_metadataprint_system_libsprint_system_cflags/// Libraries specified by -llink_paths/// Library search paths specified by -Llink_files/// Library file paths specified without -lframeworks/// Darwin frameworks specified by -frameworkframework_paths/// Darwin framework search paths specified by -Finclude_paths/// C/C++ header include paths specified by -Ild_args/// Linker options specified by -Wl/// C/C++ definitions specified by -D/// Version specified by .pc file's Version field/// Ensure that this struct can only be created via its private `[Library::new]` constructor./// Users of this crate can only access the struct via `[Config::probe]`.EnvNoPkgConfig/// Aborted because of `*_NO_PKG_CONFIG` environment variable./// Contains the name of the responsible environment variable.CrossCompilation/// Detected cross compilation without a custom sysroot./// Ignore the error with `PKG_CONFIG_ALLOW_CROSS=1`,/// which may let `pkg-config` select libraries/// for the host's architecture instead of the target's./// Failed to run `pkg-config`./// Contains the command and the cause./// `pkg-config` did not exit successfully after probing a library./// Contains the command and output.ProbeFailure/// `pkg-config` did not exit successfully on the first attempt to probe a library.// please don't match on this, we're likely to add more variants over time/// Represents all reasons `pkg-config` might not succeed or be run at all./// Output a command invocation that can be copy-pasted into the terminal./// `Command`'s existing debug implementation is not used for that reason,/// as it can sometimes lead to output such as:/// `PKG_CONFIG_ALLOW_SYSTEM_CFLAGS="1" PKG_CONFIG_ALLOW_SYSTEM_LIBS="1" "pkg-config" "--libs" "--cflags" "mylibrary"`/// Which cannot be copy-pasted into terminals such as nushell, and is a bit noisy./// This will look something like:/// `PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=1 PKG_CONFIG_ALLOW_SYSTEM_LIBS=1 pkg-config --libs --cflags mylibrary`format_outputfind_library/// Deprecated in favor of the probe_library functionprobe_library/// Simple shortcut for using all default options for finding a library.target_supported/// Run `pkg-config` to get the value of a variable from a package using/// `--variable`./// The content of `PKG_CONFIG_SYSROOT_DIR` is not injected in paths that are/// returned by `pkg-config --variable`, which makes them unsuitable to use/// during cross-compilation unless specifically designed to be used/// at that time./// Creates a new set of configuration options which are all initially set/// to "blank"./// Indicate whether the `--static` flag should be passed./// This will override the inference from environment variables described in/// the crate documentation.atleast_version/// Indicate that the library must be at least version `vers`.exactly_version/// Indicate that the library must be equal to version `vers`.range_version/// Indicate that the library's version must be in `range`./// Add an argument to pass to pkg-config./// It's placed after all of the arguments generated by this library./// Define whether metadata should be emitted for cargo allowing to/// automatically rebuild when environment variables change. Defaults to/// Enable or disable the `PKG_CONFIG_ALLOW_SYSTEM_LIBS` environment/// variable./// This env var is enabled by default./// Enable or disable the `PKG_CONFIG_ALLOW_SYSTEM_CFLAGS` environment/// Deprecated in favor fo the `probe` function/// Run `pkg-config` to find the library `name`./// This will use all configuration previously set to specify how/// `pkg-config` is run./// True if pkg-config is used for the host system, or configured for cross-compilation/// Deprecated in favor of the top level `get_variable` functiontargeted_env_varenv_var_osinfer_static// Implement Default manually since Bound does not implement Default.extract_lib_from_filename/// Extract the &str to pass to cargo:rustc-link-lib from a filename (just the file name, not including directories)/// using target-specific logic.parse_libs_cflagsparse_modversionenvifyis_static_available/// System libraries should only be linked dynamicallysplit_flags/// Split output produced by pkg-config --cflags and / or --libs into separate flags./// Backslash in output is used to preserve literal meaning of following byte.  Different words are/// separated by unescaped space. Other whitespace characters generally should not occur unescaped/// at all, apart from the newline at the end of output. For compatibility with what others/// consumers of pkg-config output would do in this scenario, they are used here for splitting assystem_library_linux_testtest_library_filenamelink_filename_linuxlink_filename_applelink_filename_msvclink_filename_mingw//! A build dependency for Cargo libraries to find system artifacts through the//! `pkg-config` utility.//! This library will shell out to `pkg-config` as part of build scripts and//! probe the system to determine how to link to a specified library. The//! `Config` structure serves as a method of configuring how `pkg-config` is//! invoked in a builder style.//! After running `pkg-config` all appropriate Cargo metadata will be printed on//! stdout if the search was successful.//! # Environment variables//! A number of environment variables are available to globally configure how//! this crate will invoke `pkg-config`://! * `FOO_NO_PKG_CONFIG` - if set, this will disable running `pkg-config` when//!   probing for the library named `foo`.//! ### Linking//! There are also a number of environment variables which can configure how a//! library is linked to (dynamically vs statically). These variables control//! whether the `--static` flag is passed. Note that this behavior can be//! overridden by configuring explicitly on `Config`. The variables are checked//! in the following order://! * `FOO_STATIC` - pass `--static` for the library `foo`//! * `FOO_DYNAMIC` - do not pass `--static` for the library `foo`//! * `PKG_CONFIG_ALL_STATIC` - pass `--static` for all libraries//! * `PKG_CONFIG_ALL_DYNAMIC` - do not pass `--static` for all libraries//! ### Cross-compilation//! In cross-compilation context, it is useful to manage separately//! `PKG_CONFIG_PATH` and a few other variables for the `host` and the `target`//! platform.//! The supported variables are: `PKG_CONFIG_PATH`, `PKG_CONFIG_LIBDIR`, and//! `PKG_CONFIG_SYSROOT_DIR`.//! Each of these variables can also be supplied with certain prefixes and//! suffixes, in the following prioritized order://! 1. `<var>_<target>` - for example, `PKG_CONFIG_PATH_x86_64-unknown-linux-gnu`//! 2. `<var>_<target_with_underscores>` - for example,//!    `PKG_CONFIG_PATH_x86_64_unknown_linux_gnu`//! 3. `<build-kind>_<var>` - for example, `HOST_PKG_CONFIG_PATH` or//!    `TARGET_PKG_CONFIG_PATH`//! 4. `<var>` - a plain `PKG_CONFIG_PATH`//! This crate will allow `pkg-config` to be used in cross-compilation//! if `PKG_CONFIG_SYSROOT_DIR` or `PKG_CONFIG` is set. You can set//! `PKG_CONFIG_ALLOW_CROSS=1` to bypass the compatibility check, but please//! note that enabling use of `pkg-config` in cross-compilation without//! appropriate sysroot and search paths set is likely to break builds.//! Find the system library named `foo`, with minimum version 1.2.3://!     pkg_config::Config::new().atleast_version("1.2.3").probe("foo").unwrap();//! Find the system library named `foo`, with no version requirement (not//! recommended)://!     pkg_config::probe_library("foo").unwrap();//! Configure how library `foo` is linked to.//!     pkg_config::Config::new().atleast_version("1.2.3").statik(true).probe("foo").unwrap();current_passAdam7Iterator/// This iterator iterates over the different passes of an image Adam7 encoded/// PNG image/// The pattern is:///     16462646///     77777777///     56565656///     36463646init_pass/// Calculates the bounds of the current pass/// The current pass#./// Iterates over the (passes, lines, widths)subbyte_pixelsexpand_adam7_bits/// Given pass, image width, and line number, produce an iterator of bit positions of pixels to copy/// from the input scanline to the image buffer.expand_pass/// Expands an Adam 7 passtest_adam7test_subbyte_pixelstest_expand_adam7_bitstest_expand_pass_subbyteBytesPerPixelBitDepthunfilter/// Re-exporting `unfilter` to make it easier to benchmark, despite some items being only/// `pub(crate)`: `fn unfilter`, `enum BytesPerPixel`.create_transform_fncreate_info_from_plte_trns_bitdepth//! Development-time-only helper module for exporting private APIs so that they can be benchmarked.//! This module is gated behind the "benchmarks" feature.ChunkTypeIHDR/// Image headerPLTE/// PaletteIDAT/// Image dataIEND/// Image trailertRNS/// TransparencybKGD/// Background colourtIME/// Image last-modification timepHYs/// Physical pixel dimensionscHRM/// Source system's pixel chromaticitiesgAMA/// Source system's gamma valuesRGB/// sRGB color space chunkiCCP/// ICC profile chunktEXt/// Latin-1 uncompressed textual datazTXt/// Latin-1 compressed textual dataiTXt/// UTF-8 textual dataacTL/// Animation controlfcTL/// Frame controlfdATis_critical/// Returns true if the chunk is critical./// Returns true if the chunk is private.reserved_set/// Checks whether the reserved bit of the chunk name is set./// If it is set the chunk name is invalid.safe_to_copy/// Returns true if the chunk is safe to copy if unknown.//! Chunk types and functions// -- Critical chunks --// -- Ancillary chunks --// -- Extension chunks --// -- Chunk type determination --text_metadataEncodableTextChunkITXtChunkTEXtChunkZTXtChunk/// 1 grayscale sample./// 1 red sample, 1 green sample, 1 blue sample./// 1 sample for the palette index./// 1 grayscale sample, then 1 alpha sample./// 1 red sample, 1 green sample, 1 blue sample, and finally, 1 alpha sample./// Describes how a pixel is encoded./// Returns the number of samples used per pixel encoded in this way.samples_u8/// u8 -> Self. Temporary solution until Rust provides a canonical one.checked_raw_row_lengthraw_row_length_from_widthis_combination_invalidFourEightSixteen/// Bit depth of the PNG file./// Specifies the number of bits per sample.Six/// Internal count of bytes per pixel./// This is used for filtering which never uses sub-byte units. This essentially reduces the number/// of possible byte chunk lengths to a very small set of values appropriate to be defined as anxppu/// Pixels per unit, X axisyppu/// Pixels per unit, Y axis/// Either *Meter* or *Unspecified*PixelDimensions/// Pixel dimensions informationMeter/// Physical unit of the pixel dimensions/// Leave the buffer unchanged./// Clear buffer with the background color./// Reset the buffer to the state before the current frame./// How to reset buffer of an animated png (APNG) at the end of a frame./// u8 -> Self. Using enum_primitive or transmute is probably the right thing but this will do for now./// Pixels overwrite the value at their position./// The new pixels are blended into the current state based on alpha./// How pixels are written into the buffer./// Sequence number of the animation chunk, starting from 0/// Width of the following frame/// Height of the following frame/// X position at which to render the following frame/// Y position at which to render the following framedelay_num/// Frame delay fraction numeratordelay_den/// Frame delay fraction denominatordispose_op/// Type of frame area disposal to be done after rendering this frameblend_op/// Type of frame area rendering for this frameFrameControl/// Frame control informationset_seq_numinc_seq_numnum_frames/// Number of framesnum_plays/// Number of times to loop this APNG.  0 indicates infinite looping.AnimationControl/// Animation control information/// Default level/// Fast minimal compression/// Higher compression level/// Best in this context isn't actually the highest possible level/// the encoder can do, but is meant to emulate the `Best` setting in the `Flate2`/// The type and strength of applied compression.ScaledFloat/// An unsigned integer scaled version of a floating point value,/// equivalent to an integer quotient with fixed denominator (100_000)).SCALING/// Gets whether the value is within the clamped range of this type./// Gets whether the value can be exactly converted in round-trip.// Stupid tool, the exact float compare is _the entire point_./// Slightly inaccurate scaling and quantization./// Clamps the value into the representable range if it is negative or too large.from_scaled/// Fully accurate construction from a value scaled as per specification./// Get the accurate encoded value./// Get the unscaled value as a floating point.encode_gamaSourceChromaticities/// Chromaticities of the color space primariesSrgbRenderingIntentPerceptual/// For images preferring good adaptation to the output device gamut at the expense of colorimetric accuracy, such as photographs.RelativeColorimetric/// For images requiring colour appearance matching (relative to the output device white point), such as logos./// For images preferring preservation of saturation at the expense of hue and lightness, such as charts and graphs.AbsoluteColorimetric/// For images requiring preservation of absolute colorimetry, such as previews of images destined for a different output device (proofs)./// The rendering intent for an sRGB image./// Presence of this data also indicates that the image conforms to the sRGB color space./// How colors are stored in the image./// The image's `tRNS` chunk, if present; contains the alpha channel of the image's palette, 1 byte per entry.pixel_dims/// The image's `PLTE` chunk, if present; contains the RGB channels (in that order) of the image's palettes, 3 bytes per entry (1 per channel).gama_chunk/// The contents of the image's gAMA chunk, if present./// Prefer `source_gamma` to also get the derived replacement gamma from sRGB chunks.chrm_chunk/// The contents of the image's `cHRM` chunk, if present./// Prefer `source_chromaticities` to also get the derived replacements from sRGB chunks.frame_controlanimation_controlsource_gamma/// Gamma of the source system./// Set by both `gAMA` as well as to a replacement by `sRGB` chunk.source_chromaticities/// Chromaticities of the source system./// Set by both `cHRM` as well as to a replacement by `sRGB` chunk.srgb/// The rendering intent of an SRGB image./// Presence of this value also indicates that the image conforms to the SRGB color space./// The ICC profile for the image.uncompressed_latin1_text/// tEXt fieldcompressed_latin1_text/// zTXt fieldutf8_text/// iTXt field/// PNG info struct/// A utility constructor for a default info with width and height./// Size of the image, width then height.is_animated/// Returns true if the image is an APNG image./// Returns the frame control information of the image./// Returns the frame control information of the current frame/// Returns the number of bits per pixel./// Returns the number of bytes per pixel.bpp_in_prediction/// Return the number of bytes for this pixel used in prediction./// Some filters use prediction, over the raw bytes of a scanline. Where a previous pixel is/// require for such forms the specification instead references previous bytes. That is, for/// a gray pixel of bit depth 2, the pixel used in prediction is actually 4 pixels prior. This/// has the consequence that the number of possible values is rather small. To make this fact/// more obvious in the type system and the optimizer we use an explicit enum here./// Returns the number of bytes needed for one deinterlaced image.raw_row_length/// Returns the number of bytes needed for one deinterlaced row./// Returns the number of bytes needed for one deinterlaced row of width `width`./// Encode this header to the writer./// Note that this does _not_ include the PNG signature, it starts with the IHDR chunk and then/// includes other chunks that were added to the header.r" Output transformations"r" Many flags from libpng are not yet supported. A PR discussing/adding them would be nice.""
    ```c
    /// Discard the alpha channel
    const STRIP_ALPHA         = 0x0002; // read only
    /// Expand 1; 2 and 4-bit samples to bytes
    const PACKING             = 0x0004; // read and write
    /// Change order of packed pixels to LSB first
    const PACKSWAP            = 0x0008; // read and write
    /// Invert monochrome images
    const INVERT_MONO         = 0x0020; // read and write
    /// Normalize pixels to the sBIT depth
    const SHIFT               = 0x0040; // read and write
    /// Flip RGB to BGR; RGBA to BGRA
    const BGR                 = 0x0080; // read and write
    /// Flip RGBA to ARGB or GA to AG
    const SWAP_ALPHA          = 0x0100; // read and write
    /// Byte-swap 16-bit samples
    const SWAP_ENDIAN         = 0x0200; // read and write
    /// Change alpha from opacity to transparency
    const INVERT_ALPHA        = 0x0400; // read and write
    const STRIP_FILLER        = 0x0800; // write only
    const STRIP_FILLER_BEFORE = 0x0800; // write only
    const STRIP_FILLER_AFTER  = 0x1000; // write only
    const GRAY_TO_RGB         = 0x2000; // read only
    const EXPAND_16           = 0x4000; // read only
    /// Similar to STRIP_16 but in libpng considering gamma?
    /// Not entirely sure the documentation says it is more
    /// accurate but doesn't say precisely how.
    const SCALE_16            = 0x8000; // read only
    ```
    "Transformationsr" No transformation"r" Strip 16-bit samples to 8 bits"STRIP_16r" Expand paletted images to RGB; expand grayscale images of"r" less than 8-bit depth to 8-bit depth; and expand tRNS chunks"r" to alpha channels."EXPANDr" Expand paletted images to include an alpha channel. Implies `EXPAND`."normalize_to_color8/// Transform every input to 8bit grayscale or color./// This sets `EXPAND` and `STRIP_16` which is similar to the default transformation used by/// this library prior to `0.17`./// Instantiate the default transformations, the identity transform.ImageBufferSize/// A provided buffer must be have the exact size to hold the image data. Where the buffer can/// be allocated by the caller, they must ensure that it has a minimum size as hinted previously./// Even though the size is calculated from image data, this does counts as a parameter error/// because they must react to a value produced by this library, which can have been subjected/// to limits.PolledAfterEndOfImage/// A bit like return `None` from an iterator./// We use it to differentiate between failing to seek to the next image in a sequence and the/// absence of a next image. This is an error of the caller because they should have checked/// the number of images by inspecting the header data returned when opening the image. This/// library will perform the checks necessary to ensure that data was accurate or error with a/// format error otherwise.//! Common types shared between the encoder and decoderFormatErrorInnerCHUNCK_BUFFER_SIZEadam7/// The pixel width of this frame./// The pixel height of this frame./// The chosen output color type./// The chosen output bit depth.line_size/// The byte count of each scan line in the image.OutputInfo/// Output info./// This describes one particular frame of the image that was written into the output buffer./// Returns the size needed to hold a decoded frame/// If the output buffer was larger then bytes after this count should be ignored. They may/// still have been changed./// maximum number of bytes the decoder is allowed to allocate, default is 64Mib/// Limits on the resources the `Decoder` is allowed too usereserve_bytesread_decoder/// Output transformations/// PNG DecoderinterlaceInterlaceInfoInterlacedRow/// A row of data with interlace information attached./// the null method means no interlacingAdam7/// Adam7 derives its name from doing 7 passes over the image, only decoding a subset of all pixels in each pass./// The following table shows pictorially what parts of each 8x8 area of the image is found in each pass:/// 1 6 4 6 2 6 4 6/// 7 7 7 7 7 7 7 7/// 5 6 5 6 5 6 5 6/// 3 6 4 6 3 6 4 6/// PNG (2003) specifies two interlace modes, but reserves future extensions./// A row of data without interlace information./// Create a new decoder configuration with default limits.new_with_limits/// Create a new decoder configuration with custom limits.new_with_options/// Create a new decoder configuration with custom `DecodeOptions`./// Limit resource usage./// Note that your allocations, e.g. when reading into a pre-allocated buffer, are __NOT__/// considered part of the limits. Nevertheless, required intermediate buffers such as for/// singular lines is checked against the limit./// Note that this is a best-effort basis./// use png::{Decoder, Limits};/// // This image is 32×32, 1bit per pixel. The reader buffers one row which requires 4 bytes./// let mut limits = Limits::default();/// limits.bytes = 3;/// let mut decoder = Decoder::new_with_limits(File::open("tests/pngsuite/basi0g01.png").unwrap(), limits);/// assert!(decoder.read_info().is_err());/// // This image is 32x32 pixels, so the decoder will allocate less than 10Kib/// limits.bytes = 10*1024;/// assert!(decoder.read_info().is_ok());read_header_info/// Read the PNG header and return the information contained within./// Most image metadata will not be read until `read_info` is called, so those fields will be/// None or empty./// Reads all meta data until the first IDAT chunkset_transformations/// Set the allowed and performed transformations./// A transformation is a pre-processing on the raw image data modifying content or encoding./// Many options have an impact on memory or CPU usage during decoding.set_ignore_text_chunk/// Set the decoder to ignore all text chunks while parsing./// eg./// use png::Decoder;/// let mut decoder = Decoder::new(File::open("tests/pngsuite/basi0g01.png").unwrap());/// decoder.set_ignore_text_chunk(true);ignore_checksums/// Set the decoder to ignore and not verify the Adler-32 checksum/// and CRC code./// Returns the next decoded chunk. If the chunk is an ImageData chunk, its contents are written/// into image_data.subframeSubframeInfofctl_read/// Number of frame control chunks read./// By the APNG specification the total number must equal the count specified in the animation/// control chunk. The IDAT image _may_ have such a chunk applying to it.SubframeIdxdata_stream/// Vec containing the uncompressed image data currently being processed.prev_start/// Index in `data_stream` where the previous row starts.current_start/// Index in `data_stream` where the current row starts.transform_fn/// Function that can transform decompressed, unfiltered rows into final output./// See the `transform.rs` module for more details.scratch_buffer/// This buffer is only used so that `next_row` and `next_interlaced_row` can return reference/// to a byte slice. In a future version of this library, this buffer will be removed and/// `next_row` and `next_interlaced_row` will write directly into a user provided output buffer./// PNG reader (mostly high-level interface)/// Provides a high level that iterates over lines or whole images.rowlenInterlaceIterconsumed_and_flushed/// The subframe specific information./// In APNG the frames are constructed by combining previous frame and a new subframe (through a/// combination of `dispose_op` and `overlay_op`). These sub frames specify individual dimension/// information and reuse the global interlace options. This struct encapsulates the state of where/// in a particular IDAT-frame or subframe we are./// The initial frame in an IDAT chunk without fcTL chunk applying to it./// Note that this variant precedes `Some` as IDAT frames precede fdAT frames and all fdAT/// frames must have a fcTL applying to it./// An IDAT frame with fcTL or an fdAT frame./// The past-the-end index./// Denote a frame as given by sequence numbers.read_until_image_data/// Reads all meta data until the next frame data starts./// Requires IHDR before the IDAT and fcTL before fdAT./// Get information on the image./// The structure will change as new frames of an animated image are decoded./// Decodes the next frame into `buf`./// Note that this decodes raw subframes that need to be mixed according to blend-op and/// dispose-op by the caller./// The caller must always provide a buffer large enough to hold a complete frame (the APNG/// specification restricts subframes to the dimensions given in the image header). The region/// that has been written be checked afterwards by calling `info` after a successful call and/// inspecting the `frame_control` data. This requirement may be lifted in a later version of/// `png`./// Output lines will be written in row-major, packed matrix with width and height of the read/// frame (or subframe), all samples are in big endian byte order where this matters./// Returns the next processed row of the imagenext_interlaced_row/// Read the rest of the image and chunks and finish up, including text chunks or others/// This will discard the rest of the image if the image is not read already with [`Reader::next_frame`], [`Reader::next_row`] or [`Reader::next_interlaced_row`]next_interlaced_row_impl/// Fetch the next interlaced row and filter it according to our own transformations.output_color_type/// Returns the color type and the number of bits per sample/// of the data returned by `Reader::next_row` and Reader::frames`.output_buffer_size/// Returns the number of bytes required to hold a deinterlaced image frame/// that is decoded using the given input transformations.output_line_size/// Returns the number of bytes required to hold a deinterlaced row.next_passnext_raw_interlaced_row/// Write the next raw interlaced row into `self.prev`./// The scanline is filtered against the previous scanline according to the specification.not_yet_init/*
pub enum InterlaceHandling {
    /// Outputs the raw rows
    RawRows,
    /// Fill missing the pixels from the existing ones
    Rectangle,
    /// Only fill the needed pixels
    Sparkle
}
*/Crc32ZlibStreamTextDecodingError/// TODO check if these size are reasonableCHECKSUM_DISABLED/// Determines if checksum checks should be disabled globally./// This is used only in fuzzing. `afl` automatically adds `--cfg fuzzing` to RUSTFLAGS which can/// be used to detect that build.U32ValueKindSignature1stU32/// First 4 bytes of the PNG signature - see/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#PNG-file-signatureSignature2ndU32/// Second 4 bytes of the PNG signature - see/// Chunk length - see/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#Chunk-layout/// Chunk type - see/// Chunk checksum - seeApngSequenceNumber/// Sequence number from an `fdAT` chunk - see/// https://wiki.mozilla.org/APNG_Specification#.60fdAT.60:_The_Frame_Data_Chunk/// Kind of `u32` value that is being read via `State::U32`.accumulated_count/// In this state we are reading a u32 value from external input.  We start with/// `accumulated_count` set to `0`. After reading or accumulating the required 4 bytes we will/// call `parse_32` which will then move onto the next state.ReadChunkData/// In this state we are reading chunk data from external input, and appending it to/// `ChunkState::raw_bytes`.ParseChunkData/// In this state we check if all chunk data has been already read into `ChunkState::raw_bytes`/// and if so then we parse the chunk.  Otherwise, we go back to the `ReadChunkData` state./// In this state we are reading image data from external input and feeding it directly into/// `StreamingDecoder::inflater`.new_u32/// Nothing decoded yetChunkBeginChunkComplete/// Decoded raw image data.ImageDataFlushed/// The last of a consecutive chunk of IDAT was done./// This is distinct from ChunkComplete which only marks that some IDAT chunk was completed but/// not that no additional IDAT chunk follows.PartialChunkImageEnd/// Result of the decoding process/// An error in IO of the underlying reader./// The input image was not a valid PNG./// There isn't a lot that can be done here, except if the program itself was responsible for/// creating this image then investigate the generator. This is internally implemented with a/// large Enum. If You are interested in accessing some of the more exact information on the/// variant then we can discuss in an issue./// An interface was used incorrectly./// This is used in cases where it's expected that the programmer might trip up and stability/// could be affected. For example when:/// * The decoder is polled for more animation frames despite being done (or not being animated///   in the first place)./// * The output buffer does not have the required size./// As a rough guideline for introducing new variants parts of the requirements are dynamically/// derived from the (untrusted) input data while the other half is from the caller. In the/// above cases the number of frames respectively the size is determined by the file while the/// number of calls/// If you're an application you might want to signal that a bug report is appreciated.LimitsExceeded/// The image would have required exceeding the limits configured with the decoder./// Note that Your allocations, e.g. when reading into a pre-allocated buffer, is __NOT__/// Any kind of error during PNG decoding./// This enumeration provides a very rough analysis on the origin of the failure. That is, each/// variant corresponds to one kind of actor causing the error. It should not be understood as a/// direct blame but can inform the search for a root cause or if such a search is required.crc_val/// Stored CRC32 valuecrc_sum/// Calculated CRC32 sum/// The chunk type that has the CRC mismatch.CrcMismatch/// Bad framing./// Not a PNG, the magic signature is missing./// End of file, within a chunk event.UnexpectedEndOfChunk/// End of file, while expecting more image data.MissingIhdr// Errors of chunk level ordering, missing etc./// Ihdr must occur.MissingFctl/// Fctl must occur if an animated chunk occurs.MissingImageData/// Image data that was indicated in IHDR or acTL is missing.ChunkBeforeIhdr/// 4.3., Must be first.AfterIdat/// 4.3., some chunks must be before IDAT.AfterPlte/// 4.3., some chunks must be before PLTE.OutsidePlteIdat/// 4.3., some chunks must be between PLTE and IDAT.DuplicateChunk/// 4.3., some chunks must be unique./// The sequence number in the chunk./// The one that should have been present.ApngOrder/// Specifically for fdat there is an embedded sequence number for chunks.ShortPalette// Errors specific to particular chunk data to be validated./// The palette did not even contain a single pixel data.PaletteRequired/// A palletized image did not have a palette.InvalidColorBitDepth/// The color-depth combination is not valid according to Table 11.1.ColorWithBadTrnsInvalidDimensions/// The image width or height is zero.InvalidBitDepthInvalidColorTypeInvalidDisposeOpInvalidBlendOpInvalidUnitInvalidSrgbRenderingIntent/// The rendering intent of the sRGB chunk is invalid.UnknownCompressionMethodUnknownFilterMethodUnknownInterlaceMethodBadSubFrameBounds/// The subframe is not in bounds of the image./// TODO: fields with relevant data.CorruptFlateStream// Errors specific to the IDAT/fDAT chunks./// The compression of the data stream was faulty.NoMoreImageData/// The image data chunk was too short for the expected pixel count.BadTextEncoding/// Bad text encodingFdatShorterThanFourBytes/// fdAT shorter than 4 bytesignore_crcignore_text_chunkskip_ancillary_crc_failures/// Decoder configuration optionsset_ignore_adler32/// When set, the decoder will not compute and verify the Adler-32 checksum.set_ignore_crc/// When set, the decoder will not compute and verify the CRC code.set_ignore_checksums/// Flag to ignore computing and verifying the Adler-32 checksum and CRC/// Ignore text chunks while decoding.set_skip_ancillary_crc_failures/// Ignore ancillary chunks if CRC fails/// Defaults to `true`current_chunkChunkState/// The inflater state handling consecutive `IDAT` and `fdAT` chunks./// The complete image info read from all prior chunks.current_seq_no/// The animation chunk sequence number.have_idat/// Whether we have already seen a start of an IDAT chunk.  (Used to validate chunk ordering -/// some chunk types can only appear before or after an IDAT chunk.)decode_options/// PNG StreamingDecoder (low-level interface)/// By default, the decoder does not verify Adler-32 checksum computation. To/// enable checksum verification, set it with [`StreamingDecoder::set_ignore_adler32`]/// before starting decompression./// The type of the current chunk./// Relevant for `IDAT` and `fdAT` which aggregate consecutive chunks of their own type./// Partial crc until now./// Remaining bytes to be read./// Non-decoded bytes in the chunk./// Creates a new StreamingDecoder/// Allocates the internal buffers./// Resets the StreamingDecoder/// Provides access to the inner `info` field/// Return whether the decoder is set to ignore the Adler-32 checksum./// Set whether to compute and verify the Adler-32 checksum during/// decompression. Return `true` if the flag was successfully set./// The decoder defaults to `true`./// This flag cannot be modified after decompression has started until the/// [`StreamingDecoder`] is reset./// The decoder defaults to `false`./// Low level StreamingDecoder interface./// Allows to stream partial data to the encoder. Returns a tuple containing the bytes that have/// been consumed from the input buffer and the current decoding result. If the decoded chunk/// was an image data chunk, it also appends the read data to `image_data`.reserve_current_chunkparse_chunkparse_fctlparse_actlparse_plteparse_trnsparse_physparse_chrmparse_gamaparse_srgbparse_iccpparse_ihdrsplit_keywordparse_textparse_ztxtparse_itxtimage_gammaimage_source_chromaticitiestest_two_iccp_chunks/// Test handling of a PNG file that contains *two* iCCP chunks./// This is a regression test for https://github.com/image-rs/image/issues/1825.write_actl/// Writes an acTL chunk./// See https://wiki.mozilla.org/APNG_Specification#.60acTL.60:_The_Animation_Control_Chunkwrite_fctl/// Writes an fcTL chunk./// See https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunkwrite_fdat/// Writes an fdAT chunk./// See https://wiki.mozilla.org/APNG_Specification#.60fdAT.60:_The_Frame_Data_Chunkwrite_fdat_prefix/// Writes PNG signature and chunks that can precede an fdAT chunk that is expected/// to have/// - `sequence_number` set to 0/// - image data with rgba8 pixels in a `width` by `width` imagetest_fdat_chunk_payload_length_0test_fdat_chunk_payload_length_3test_frame_split_across_two_fdat_chunkstest_idat_bigger_than_image_size_from_ihdrunpack_bitscreate_expansion_into_rgb8create_expansion_into_rgba8create_rgba_paletteexpand_8bit_into_rgb8expand_into_rgb8expand_paletted_into_rgba8oracle_expand_paletted_into_rgb8/// Old, non-memoized version of the code is used as a test oracle.oracle_expand_paletted_into_rgba8create_infoexpand_palettedtest_expand_paletted_rgba_8bittest_expand_paletted_rgb_8bittest_expand_paletted_rgba_4bittest_expand_paletted_rgb_4bittest_expand_paletted_rgba_8bit_more_trns_entries_than_palette_entriestest_expand_paletted_rgba_8bit_less_trns_entries_than_palette_entriestest_create_rgba_palette//! Helpers for taking a slice of indeces (indices into `PLTE` and/or `trNS`//! entries) and transforming this into RGB or RGBA output.//! # Memoization//! To achieve higher throughput, `create_rgba_palette` combines entries from//! `PLTE` and `trNS` chunks into a single lookup table.  This is based on the//! ideas explored in https://crbug.com/706134.//! Memoization is a trade-off://! * On one hand, memoization requires spending X ns before starting to call//!   `expand_paletted_...` functions.//! * On the other hand, memoization improves the throughput of the//!   `expand_paletted_...` functions - they take Y ns less to process each byte//! Based on X and Y, we can try to calculate the breakeven point.  It seems//! that memoization is a net benefit for images bigger than around 13x13 pixels./// Type of a function that can transform a decompressed, unfiltered row (the/// 1st argument) into the final pixels (the 2nd argument), optionally using/// image metadata (e.g. PLTE data can be accessed using the 3rd argument)./// TODO: If some precomputed state is needed (e.g. to make `expand_paletted...`/// faster) then consider changing this into `Box<dyn Fn(...)>`./// Returns a transformation function that should be applied to image rows based/// on 1) decoded image metadata (`info`) and 2) the transformations requested/// by the crate client (`transform`).copy_rowtransform_row_strip16expand_trns_lineexpand_trns_line16expand_trns_and_strip_line16expand_gray_u8expand_gray_u8_with_trns//! Transforming a decompressed, unfiltered row into the final output./// Current decoding state./// If there has been a call to decompress already./// Remaining buffered decoded bytes./// The decoder sometimes wants inspect some already finished bytes for further decoding. So we/// keep a total of 32KB of decoded data available as long as more data may be appended.out_pos/// The first index of `out_buffer` where new data can be written./// The first index of `out_buffer` that hasn't yet been passed to our client/// (i.e. not yet appended to the `image_data` parameter of `fn decompress` or `fn/// finish_compressed_chunks`).max_total_output/// Limit on how many bytes can be decompressed in total.  This field is mostly used for/// performance optimizations (e.g. to avoid allocating and zeroing out large buffers when only/// a small image is being decoded)./// Ignore and do not calculate the Adler-32 checksum. Defaults to `true`./// This flag overrides `TINFL_FLAG_COMPUTE_ADLER32`./// This flag should not be modified after decompression has started./// Ergonomics wrapper around `miniz_oxide::inflate::stream` for zlib compressed data.set_max_total_output/// Set the `ignore_adler32` flag and return `true` if the flag was/// successfully set./// [ZlibStream] is reset./// Return the `ignore_adler32` flag./// Fill the decoded buffer as far as possible from `data`./// On success returns the number of consumed input bytes.finish_compressed_chunks/// Called after all consecutive IDAT chunks were handled./// The compressed stream can be split on arbitrary byte boundaries. This enables some cleanup/// within the decompressor and flushing additional data which may have been kept back in case/// more data were passed to it.prepare_vec_for_appending/// Resize the vector to allow allocation of more data.decoding_sizetransfer_finished_datacompact_out_buffer_if_neededAdaptiveFilterTypeTextEncodingErrorFormatErrorKindZeroWidthZeroHeightInvalidColorCombinationNoPaletteWrittenTooMuch// TODO: wait, what?NotAnimatedOutOfBoundsEndReachedZeroFramesMissingFramesUnrecoverable// Private impl./// PNG Encoder./// This configures the PNG format options such as animation chunks, palette use, color types,/// auxiliary chunks etc./// FIXME: Configuring APNG might be easier (less individual errors) if we had an _adapter_ which/// borrows this mutably but guarantees that `info.frame_control` is not `None`.adaptive_filtersep_def_imgvalidate_sequence/// Decoding options, internal type, forwarded to the Writer.with_infoset_animated/// Specify that the image is animated./// `num_frames` controls how many frames the animation has, while/// `num_plays` controls how many times the animation should be/// repeated until it stops, if it's zero then it will repeat/// infinitely./// When this method is returns successfully then the images written will be encoded as fdAT/// chunks, except for the first image that is still encoded as `IDAT`. You can control if the/// first frame should be treated as an animation frame with [`Encoder::set_sep_def_img()`]./// This method returns an error if `num_frames` is 0.set_sep_def_img/// Mark the first animated frame as a 'separate default image'./// In APNG each animated frame is preceded by a special control chunk, `fcTL`. It's up to the/// encoder to decide if the first image, the standard `IDAT` data, should be part of the/// animation by emitting this chunk or by not doing so. A default image that is _not_ part of/// the animation is often interpreted as a thumbnail./// This method will return an error when animation control was not configured/// (which is done by calling [`Encoder::set_animated`])./// Sets the raw byte contents of the PLTE chunk. This method accepts/// both borrowed and owned byte data.set_trns/// Sets the raw byte contents of the tRNS chunk. This method acceptsset_source_gamma/// Set the display gamma of the source system on which the image was generated or last edited.set_source_chromaticities/// Set the chromaticities for the source system's display channels (red, green, blue) and the whitepoint/// of the source system on which the image was generated or last edited.set_srgb/// Mark the image data as conforming to the SRGB color space with the specified rendering intent./// Matching source gamma and chromaticities chunks are added automatically./// Any manually specified source gamma or chromaticities will be ignored./// Start encoding by writing the header data./// The remaining data can be supplied by methods on the returned [`Writer`]./// Set the color of the encoded image./// These correspond to the color types in the png IHDR data that will be written. The length/// of the image data that is later supplied must match the color type, otherwise an error will/// be emitted./// Set the indicated depth of the image data.set_compression/// Set compression parameters./// Accepts a `Compression` or any type that can transform into a `Compression`. Notably `deflate::Compression` and/// `deflate::CompressionOptions` which "just work"./// Set the used filter type./// The default filter is [`FilterType::Sub`] which provides a basic prediction algorithm for/// sample values based on the previous. For a potentially better compression ratio, at the/// cost of more complex processing, try out [`FilterType::Paeth`]./// [`FilterType::Sub`]: enum.FilterType.html#variant.Sub/// [`FilterType::Paeth`]: enum.FilterType.html#variant.Paethset_adaptive_filter/// Set the adaptive filter type./// Adaptive filtering attempts to select the best filter for each line/// based on heuristics which minimize the file size for compression rather/// than use a single filter for the entire image. The default method is/// [`AdaptiveFilterType::NonAdaptive`]./// [`AdaptiveFilterType::NonAdaptive`]: enum.AdaptiveFilterType.htmlset_frame_delay/// Set the fraction of time every frame is going to be displayed, in seconds./// *Note that this parameter can be set for each individual frame after/// [`Encoder::write_header`] is called. (see [`Writer::set_frame_delay`])*/// If the denominator is 0, it is to be treated as if it were 100/// (that is, the numerator then specifies 1/100ths of a second)./// If the the value of the numerator is 0 the decoder should render the next frame/// as quickly as possible, though viewers may impose a reasonable lower bound./// The default value is 0 for both the numerator and denominator./// This method will return an error if the image is not animated./// (see [`set_animated`])/// [`write_header`]: struct.Encoder.html#method.write_header/// [`set_animated`]: struct.Encoder.html#method.set_animated/// [`Writer::set_frame_delay`]: struct.Writer#method.set_frame_delayset_blend_op/// Set the blend operation for every frame./// The blend operation specifies whether the frame is to be alpha blended/// into the current output buffer content, or whether it should completely/// replace its region in the output buffer./// [`write_header`] is called. (see [`Writer::set_blend_op`])*/// See the [`BlendOp`] documentation for the possible values and their effects./// *Note that for the first frame the two blend modes are functionally/// equivalent due to the clearing of the output buffer at the beginning/// of each play.*/// The default value is [`BlendOp::Source`]./// [`BlendOP`]: enum.BlendOp.html/// [`BlendOP::Source`]: enum.BlendOp.html#variant.Source/// [`Writer::set_blend_op`]: struct.Writer#method.set_blend_opset_dispose_op/// Set the dispose operation for every frame./// The dispose operation specifies how the output buffer should be changed/// at the end of the delay (before rendering the next frame)/// [`write_header`] is called (see [`Writer::set_dispose_op`])*/// See the [`DisposeOp`] documentation for the possible values and their effects./// *Note that if the first frame uses [`DisposeOp::Previous`]/// it will be treated as [`DisposeOp::Background`].*/// The default value is [`DisposeOp::None`]./// [`DisposeOp`]: ../common/enum.BlendOp.html/// [`DisposeOp::Previous`]: ../common/enum.BlendOp.html#variant.Previous/// [`DisposeOp::Background`]: ../common/enum.BlendOp.html#variant.Background/// [`DisposeOp::None`]: ../common/enum.BlendOp.html#variant.None/// [`Writer::set_dispose_op`]: struct.Writer#method.set_dispose_opset_pixel_dimsadd_text_chunk/// Convenience function to add tEXt chunks to [`Info`] structadd_ztxt_chunk/// Convenience function to add zTXt chunks to [`Info`] structadd_itxt_chunk/// Convenience function to add iTXt chunks to [`Info`] struct/// This function only sets the `keyword` and `text` field of the iTXt chunk./// To set the other fields, create a [`ITXtChunk`] directly, and then encode it to the output stream./// Validate the written image sequence./// When validation is turned on (it's turned off by default) then attempts to write more than/// one `IDAT` image or images beyond the number of frames indicated in the animation control/// chunk will fail and return an error result instead. Attempts to [finish][finish] the image/// with missing frames will also return an error./// [finish]: StreamWriter::finish/// (It's possible to circumvent these checks by writing raw chunks instead.)/// The underlying writer.PartialInfo/// The local version of the `Info` struct./// Global encoding options.images_written/// The total number of image frames, counting all consecutive IDAT and fdAT chunks.animation_written/// The total number of animation frames, that is equivalent to counting fcTL chunks.iend_written/// A flag to note when the IEND chunk was already added./// This is only set on code paths that drop `Self` to control the destructor./// PNG writer/// Progresses through the image by writing images, frames, or raw individual chunks. This is/// constructed through [`Encoder::write_header()`]./// FIXME: Writing of animated chunks might be clearer if we had an _adapter_ that you would call/// to guarantee the next image to be prefaced with a fcTL-chunk, and all other chunks would be/// guaranteed to be `IDAT`/not affected by APNG's frame control./// Contains the subset of attributes of [Info] needed for [Writer] to functionto_info/// Converts this partial info to an owned Info struct,/// setting missing values to their defaultsDEFAULT_BUFFER_LENGTH/// Write a raw chunk of PNG data./// The chunk will have its CRC calculated and correctly. The data is not filtered in any way,/// but the chunk needs to be short enough to have its length encoded correctly.write_text_chunkvalidate_new_image/// Check if we should allow writing another image.validate_sequence_doneMAX_IDAT_CHUNK_LENMAX_fdAT_CHUNK_LENwrite_image_data/// Writes the next image data.increment_images_writtenwrite_iendshould_skip_frame_control_on_default_imagewrite_zlib_encoded_idat/// Set the used filter type for the following frames./// Set the adaptive filter type for the following frames./// Set the fraction of time the following frames are going to be displayed,/// in secondsset_frame_dimension/// Set the dimension of the following frames./// This function will return an error when:/// - The image is not an animated;/// - The selected dimension, considering also the current frame position,///   goes outside the image boundaries;/// - One or both the width and height are 0;// ??? TODO ???// - The next frame is the default imageset_frame_position/// Set the position of the following frames./// An error will be returned if:/// - The image is not animated;/// - The selected position, considering also the current frame dimension,reset_frame_dimension/// Set the frame dimension to occupy all the image, starting from/// the current position./// To reset the frame to the full image size [`reset_frame_position`]/// should be called first./// [`reset_frame_position`]: struct.Writer.html#method.reset_frame_positionreset_frame_position/// Set the frame position to (0, 0)./// Equivalent to calling [`set_frame_position(0, 0)`]./// [`set_frame_position(0, 0)`]: struct.Writer.html#method.set_frame_position/// Set the blend operation for the following frames./// Set the dispose operation for the following frames.stream_writerStreamWriter/// Create a stream writer./// This allows you to create images that do not fit in memory. The default/// chunk size is 4K, use `stream_writer_with_size` to set another chunk/// This borrows the writer which allows for manually appending additional/// chunks after the image data has been written.stream_writer_with_size/// Create a stream writer with custom buffer size./// See [`stream_writer`]./// [`stream_writer`]: #fn.stream_writerinto_stream_writer/// Turn this into a stream writer for image data.into_stream_writer_with_size/// Turn this into a stream writer with custom buffer size./// See [`into_stream_writer`]./// [`into_stream_writer`]: #fn.into_stream_writer/// Consume the stream writer with validation./// Unlike a simple drop this ensures that the final chunk was written correctly. When other/// validation options (chunk sequencing) had been turned on in the configuration then it will/// also do a check on their correctness _before_ writing the final chunk.ChunkOutput// opted for deref for practical reasons/// keeps track of where the last byte was writtencurr_chunk/// This writer is used between the actual writer and the/// ZlibEncoder and has the job of packaging the compressed/// data into a PNG chunk, based on the image metadata/// Currently the way it works is that the specified buffer/// will hold one chunk at the time and buffer the incoming/// data until `flush` is called or the maximum chunk size/// The maximum chunk is the smallest between the selected buffer size/// and `u32::MAX >> 1` (`0x7fffffff` or `2147483647` dec)/// When a chunk has to be flushed the length (that is now known)/// and the CRC will be written at the correct locations in the chunk./// Returns the size of each scanline for the next frame/// paired with the size of the whole frame/// This is used by the `StreamWriter` to know when the scanline ends/// so it can filter compress it and also to know when to start/// the next one/// NOTE: this bypasses the internal buffer so the flush method should be called before this///       in the case there is some data left in the buffer when this is called, it will panicset_fctl/// Set the `FrameControl` for the following frame/// It will ignore the `sequence_number` of the parameter/// as it is updated internally.flush_inner/// Flushes the current chunk/// This is used in-between, should never be matched// TODO: find a better name/// This enum is used to be allow the `StreamWriter` to keep/// its inner `ChunkWriter` without wrapping it inside a/// `ZlibEncoder`. This is used in the case that between the/// change of state that happens when the last write of a frame/// is performed an error occurs, which obviously has to be returned./// This creates the problem of where to store the writer before/// exiting the function, and this is where `Wrapper` comes in./// Unfortunately the `ZlibWriter` can't be used because on the/// write following the error, `finish` would be called and that/// would write some data even if 0 bytes where compressed./// If the `finish` function fails then there is nothing much to/// do as the `ChunkWriter` would get lost so the `Unrecoverable`/// variant is used to signal that./// Like `Option::take` this returns the `Wrapper` contained/// in `self` and replaces it with `Wrapper::None`/// The option here is needed in order to access the inner `ChunkWriter` in-between/// each frame, which is needed for writing the fcTL chunks between each frameprev_bufcurr_buf/// Amount of data already writtenline_len/// length of the current scanlineto_write/// size of the frame (width * height * sample_size)fctl/// Streaming PNG writer/// This may silently fail in the destructor, so it is a good idea to call/// [`finish`](#method.finish) or [`flush`] before dropping./// [`flush`]: https://doc.rust-lang.org/stable/std/io/trait.Write.html#tymethod.flush/// Set the used filter type for the next frame./// Set the adaptive filter type for the next frame./// Unlike a simple drop this ensures that the all data was written correctly. When other/// validation options (chunk sequencing) had been turned on in the configuration of inner/// [`Writer`], then it will also do a check on their correctness. Differently from/// [`Writer::finish`], this just `flush`es, returns error if some data is abandoned.new_frame/// Flushes the buffered chunk, checks if it was the last frame,/// writes the next frame header and gets the next frame scanline size/// and image size./// NOTE: This method must only be called when the writer is the variant Chunk(_)to_options/// Mod to encapsulate the converters depending on the `deflate` crate./// Since this only contains trait impls, there is no need to make this public, they are simply/// available when the mod is compiled as well.roundtrip_streamimage_paletteexpect_error_on_wrong_image_lenexpect_error_on_empty_imageexpect_error_on_invalid_bit_depth_color_type_combinationcan_write_header_with_valid_bit_depth_color_type_combinationall_filters_roundtripsome_gamma_roundtripwrite_image_chunks_beyond_firstimage_validate_sequence_without_animationimage_validate_animationimage_validate_animation2image_validate_animation_sep_def_imageimage_validate_missing_imageimage_validate_missing_animated_frameissue_307_stream_validationstream_filteringexper_error_on_huge_chunkexper_error_on_non_u32_chunkfinish_drops_inner_writerRandomChunkWriter/// A Writer that only writes a few bytes at a time/// The byte level filter applied to scanlines to prepare them for compression./// Compression in general benefits from repetitive data. The filter is a content-aware method of/// compressing the range of occurring byte values to help the compression algorithm. Note that/// this does not operate on pixels but on raw bytes of a scanline.NonAdaptive/// The filtering method for preprocessing scanline data before compression./// Adaptive filtering performs additional computation in an attempt to maximize/// the compression of the data. [`NonAdaptive`] filtering is the default./// [`NonAdaptive`]: enum.AdaptiveFilterType.html#variant.NonAdaptivefilter_paeth_decodefilter_paethfilter_internalsum_buffer// Helper function for Adaptive filter buffer summationroundtrip_ascending_previous_linesum_buffer_test// This tests that converting u8 to i8 doesn't overflow when taking the// absolute value for adaptive filtering: -128_i8.abs() will panic in debug// or produce garbage in release mode. The sum of 0..=255u8 should equal the// sum of the absolute values of -128_i8..=127, or abs(-128..=0) + 1..=127.//! # PNG encoder and decoder//! This crate contains a PNG encoder and decoder. It supports reading of single lines or whole frames.//! ## The decoder//! The most important types for decoding purposes are [`Decoder`](struct.Decoder.html) and//! [`Reader`](struct.Reader.html). They both wrap a `std::io::Read`.//! `Decoder` serves as a builder for `Reader`. Calling `Decoder::read_info` reads from the `Read` until the//! image data is reached.//! ### Using the decoder//! // The decoder is a build for reader and can be used to set various decoding options//! // via `Transformations`. The default output transformation is `Transformations::IDENTITY`.//! let decoder = png::Decoder::new(File::open("tests/pngsuite/basi0g01.png").unwrap());//! let mut reader = decoder.read_info().unwrap();//! // Allocate the output buffer.//! let mut buf = vec![0; reader.output_buffer_size()];//! // Read the next frame. An APNG might contain multiple frames.//! let info = reader.next_frame(&mut buf).unwrap();//! // Grab the bytes of the image.//! let bytes = &buf[..info.buffer_size()];//! // Inspect more details of the last read frame.//! let in_animation = reader.info().frame_control.is_some();//! ## Encoder//! ### Using the encoder//! // For reading and opening files//! use std::io::BufWriter;//! let path = Path::new(r"/path/to/image.png");//! let file = File::create(path).unwrap();//! let ref mut w = BufWriter::new(file);//! let mut encoder = png::Encoder::new(w, 2, 1); // Width is 2 pixels and height is 1.//! encoder.set_color(png::ColorType::Rgba);//! encoder.set_depth(png::BitDepth::Eight);//! encoder.set_source_gamma(png::ScaledFloat::from_scaled(45455)); // 1.0 / 2.2, scaled by 100000//! encoder.set_source_gamma(png::ScaledFloat::new(1.0 / 2.2));     // 1.0 / 2.2, unscaled, but rounded//! let source_chromaticities = png::SourceChromaticities::new(     // Using unscaled instantiation here//!     (0.31270, 0.32900),//!     (0.64000, 0.33000),//!     (0.30000, 0.60000),//!     (0.15000, 0.06000)//! encoder.set_source_chromaticities(source_chromaticities);//! let mut writer = encoder.write_header().unwrap();//! let data = [255, 0, 0, 255, 0, 0, 0, 255]; // An array containing a RGBA sequence. First pixel is red and second pixel is black.//! writer.write_image_data(&data).unwrap(); // Savesubstitute_gamma/// Get the gamma that should be substituted for images conforming to the sRGB color space.substitute_chromaticities/// Get the chromaticities that should be substituted for images conforming to the sRGB color space.write_noncompressed_png/// Generates a store-only, non-compressed image:/// * `00` compression mode (i.e.`BTYPE` = `00` = no compression) is used/// * No filter is applied to the image rows/// Currently the image always has the following properties:/// * Single `IDAT` chunk/// * Zlib chunks of maximum possible size/// * 8-bit RGBA/// These images are somewhat artificial, but may be useful for benchmarking performance of parts/// outside of `fdeflate` crate and/or the `unfilter` function (e.g. these images were originally/// used to evaluate changes to minimize copying of image pixels between various buffers - see/// [this/// discussion](https://github.com/image-rs/image-png/discussions/416#discussioncomment-7436871)/// for more details).// Used from `benches/decoder.rs`write_png_sig/// Writes PNG signature./// See http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#PNG-file-signature/// Writes an arbitrary PNG chunk.write_rgba8_ihdr_with_width/// Writes an IHDR chunk that indicates a non-interlaced RGBA8 that uses the same height and/// `width`.  See http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IHDRgenerate_rgba8_with_width_and_height/// Generates RGBA8 `width` x `height` image and wraps it in a store-only zlib container.write_rgba8_idats/// Writes an IDAT chunk./// Writes an IEND chunk./// See http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IEND//! A set of test utilities.//! There is some overlap between this module and `src/encoder.rs` module, but://! * This module (unlike `src/encoder.rs`) performs no validation of the data being written - this//!   allows building testcases that use arbitrary, potentially invalid PNGs as input.//! * This module can be reused from `benches/decoder.rs` (a separate crate).DECOMPRESSION_LIMIT/// Default decompression limit for compressed text chunks.Unrepresentable/// Unrepresentable characters in stringInvalidKeywordSize/// Keyword longer than 79 bytes or emptyCompressionError/// Error encountered while compressing text/// Text encoding errors that is wrapped by the standard EncodingError typeMissingNullSeparator/// Missing null separatorInflationError/// Compressed text cannot be uncompressedOutOfDecompressionSpace/// Needs more space to decompressInvalidCompressionMethod/// Using an unspecified value for the compression methodInvalidCompressionFlag/// Using a byte that is not 0 or 255 as compression flag in iTXt chunkMissingCompressionFlag/// Missing the compression flag/// Text decoding error that is wrapped by the standard DecodingError type/// Encode text chunk as Vec<u8> to a `Write`/// A generalized text chunk trait/// Keyword field of the tEXt chunk. Needs to be between 1-79 bytes when encoded as Latin-1./// Text field of tEXt chunk. Can be at most 2GB./// Struct representing a tEXt chunkdecode_iso_8859_1encode_iso_8859_1encode_iso_8859_1_intoencode_iso_8859_1_iterdecode_ascii/// Constructs a new TEXtChunk./// Not sure whether it should take &str or String./// Decodes a slice of bytes to a String using Latin-1 decoding./// The decoder runs in strict mode, and any decoding errors are passed along to the caller./// Encodes TEXtChunk to a Writer. The keyword and text are separated by a byte of zeroes.OptCompressed/// Text field of zTXt chunk. It is compressed by default, but can be uncompressed if necessary./// Struct representing a zTXt chunkCompressed/// Compressed version of text field. Can be at most 2GB./// Uncompressed text field./// Private enum encoding the compressed and uncompressed states of zTXt/iTXt text field./// Creates a new ZTXt chunk.decompress_text/// Decompresses the inner text, mutating its own state. Can only handle decompressed text up to `DECOMPRESSION_LIMIT` bytes.decompress_text_with_limit/// Decompresses the inner text, mutating its own state. Can only handle decompressed text up to `limit` bytes./// Decompresses the inner text, and returns it as a `String`./// If decompression uses more the 2MiB, first call decompress with limit, and then this method.compress_text/// Compresses the inner text, mutating its own state./// The keyword field. This needs to be between 1-79 bytes when encoded as Latin-1./// Indicates whether the text will be (or was) compressed in the PNG.language_tag/// A hyphen separated list of languages that the keyword is translated to. This is ASCII-7 encoded.translated_keyword/// Translated keyword. This is UTF-8 encoded./// Text field of iTXt chunk. It is compressed by default, but can be uncompressed if necessary./// Struct encoding an iTXt chunk/// Constructs a new iTXt chunk. Leaves all but keyword and text to default values./// If decompression takes more than 2 MiB, try `decompress_text_with_limit` followed by this method.//! # Text chunks (tEXt/zTXt/iTXt) structs and functions//! The [PNG spec](https://www.w3.org/TR/2003/REC-PNG-20031110/#11textinfo) optionally allows for//! embedded text chunks in the file. They may appear either before or after the image data//! chunks. There are three kinds of text chunks.//!  -   `tEXt`: This has a `keyword` and `text` field, and is ISO 8859-1 encoded.//!  -   `zTXt`: This is semantically the same as `tEXt`, i.e. it has the same fields and//!       encoding, but the `text` field is compressed before being written into the PNG file.//!  -   `iTXt`: This chunk allows for its `text` field to be any valid UTF-8, and supports//!        compression of the text field as well.//!  The `ISO 8859-1` encoding technically doesn't allow any control characters//!  to be used, but in practice these values are encountered anyway. This can//!  either be the extended `ISO-8859-1` encoding with control characters or the//!  `Windows-1252` encoding. This crate assumes the `ISO-8859-1` encoding is//!  used.//!  ## Reading text chunks//!  As a PNG is decoded, any text chunk encountered is appended the//!  [`Info`](`crate::common::Info`) struct, in the `uncompressed_latin1_text`,//!  `compressed_latin1_text`, and the `utf8_text` fields depending on whether the encountered//!  chunk is `tEXt`, `zTXt`, or `iTXt`.//!  ```//!  use std::fs::File;//!  use std::iter::FromIterator;//!  use std::path::PathBuf;//!  // Opening a png file that has a zTXt chunk//!  let decoder = png::Decoder::new(//!      File::open(PathBuf::from_iter([//!          "tests",//!          "text_chunk_examples",//!          "ztxt_example.png",//!      ]))//!      .unwrap(),//!  );//!  let mut reader = decoder.read_info().unwrap();//!  // If the text chunk is before the image data frames, `reader.info()` already contains the text.//!  for text_chunk in &reader.info().compressed_latin1_text {//!      println!("{:?}", text_chunk.keyword); // Prints the keyword//!      println!("{:#?}", text_chunk); // Prints out the text chunk.//!      // To get the uncompressed text, use the `get_text` method.//!      println!("{}", text_chunk.get_text().unwrap());//!  }//!  ## Writing text chunks//!  There are two ways to write text chunks: the first is to add the appropriate text structs directly to the encoder header before the header is written to file.//!  To add a text chunk at any point in the stream, use the `write_text_chunk` method.//!  # use png::text_metadata::{ITXtChunk, ZTXtChunk};//!  # use std::env;//!  # use std::fs::File;//!  # use std::io::BufWriter;//!  # use std::iter::FromIterator;//!  # use std::path::PathBuf;//!  # let file = File::create(PathBuf::from_iter(["target", "text_chunk.png"])).unwrap();//!  # let ref mut w = BufWriter::new(file);//!  let mut encoder = png::Encoder::new(w, 2, 1); // Width is 2 pixels and height is 1.//!  encoder.set_color(png::ColorType::Rgba);//!  encoder.set_depth(png::BitDepth::Eight);//!  // Adding text chunks to the header//!  encoder//!     .add_text_chunk(//!         "Testing tEXt".to_string(),//!         "This is a tEXt chunk that will appear before the IDAT chunks.".to_string(),//!      .add_ztxt_chunk(//!          "Testing zTXt".to_string(),//!          "This is a zTXt chunk that is compressed in the png file.".to_string(),//!      )//!      .unwrap();//!      .add_itxt_chunk(//!          "Testing iTXt".to_string(),//!          "iTXt chunks support all of UTF8. Example: हिंदी.".to_string(),//!  let mut writer = encoder.write_header().unwrap();//!  let data = [255, 0, 0, 255, 0, 0, 0, 255]; // An array containing a RGBA sequence. First pixel is red and second pixel is black.//!  writer.write_image_data(&data).unwrap(); // Save//!  // We can add a tEXt/zTXt/iTXt at any point before the encoder is dropped from scope. These chunks will be at the end of the png file.//!  let tail_ztxt_chunk = ZTXtChunk::new("Comment".to_string(), "A zTXt chunk after the image data.".to_string());//!  writer.write_text_chunk(&tail_ztxt_chunk).unwrap();//!  // The fields of the text chunk are public, so they can be mutated before being written to the file.//!  let mut tail_itxt_chunk = ITXtChunk::new("Author".to_string(), "सायंतन खान".to_string());//!  tail_itxt_chunk.compressed = true;//!  tail_itxt_chunk.language_tag = "hi".to_string();//!  tail_itxt_chunk.translated_keyword = "लेखक".to_string();//!  writer.write_text_chunk(&tail_itxt_chunk).unwrap();// 2 MiBread_bytes_extwrite_bytes_extread_be/// Read `T` from a bytes stream. Most significant byte first./// Read extension to read big endian datawrite_be/// Writes `T` to a bytes stream. Most significant byte first./// Write extension to write big endian dataepoll_fd/// File descriptor for the epoll instance.
event_fd/// File descriptor for the eventfd that produces notifications.
timer_fd/// File descriptor for the timerfd that produces timeouts.
/// Interface to epoll.
/// Creates a new poller.
supports_level/// Whether this poller supports level-triggered events.
supports_edge/// Whether the poller supports edge-triggered events.
/// Adds a new file descriptor.
/// Modifies an existing file descriptor.
/// Deletes a file descriptor.
/// Waits for I/O events with an optional timeout.
/// Sends a notification to wake up the current or next `wait()` call.
/// Passes arguments to `epoll_ctl`.
TS_ZERO/// `timespec` value that equals zero.
read_flags/// Epoll flags for all possible readability events.
/// Epoll flags for all possible writability events.
/// A list of reported I/O events.
/// Creates an empty list.
/// Iterates over I/O events.
//! Bindings to epoll (Linux, Android).
CompletionCompletionHandleWSAIoctlSIO_BASE_HANDLESIO_BSP_HANDLE_POLLFILE_OPENOBJECT_ATTRIBUTES/// The timeout for this poll.
/// The number of handles being polled.
/// Whether or not this poll is exclusive for this handle.
/// The handles to poll.
/// The handle to poll.
AfdPollMask/// The events to poll for.
/// The status of the poll.
afd_infoHasAfdInfodefine_ntdll_importforce_loadNtdllImports/// The handle to the AFD device.
/// We own `T`.
/// Create a new AFD device.
/// Begin polling with the provided handle.
/// Cancel an ongoing poll operation.
/// The poll operation must currently be in progress for this AFD.
AsIoStatusBlock/// The value.
/// The one-time initialization.
/// A one-time initialization cell.
/// Creates a new `OnceCell`.
/// Gets the value or initializes it.
/// Can be transmuted to an I/O status block.
/// A pointer to `T` must be able to be converted to a pointer to `IO_STATUS_BLOCK`
/// without any issues.
/// Get the base socket associated with a socket.
try_socket_ioctl/// Run an IOCTL on a socket and return a socket.
/// The `ioctl` parameter must be a valid I/O control that returns a valid socket.
//! Safe wrapper around \Device\Afd
IoCompletionPortOverlappedEntry/// Macro to lock and ignore lock poisoning.
/// The I/O completion port.
/// List of currently active AFD instances.
/// Weak references are kept here so that the AFD handle is automatically dropped
/// when the last associated socket is dropped.
/// The state of the sources registered with this poller.
pending_updates/// Sockets with pending updates.
/// Are we currently polling?
/// A list of completion packets.
/// The packet used to notify the poller.
/// Interface to I/O completion ports.
/// Whether this poller supports edge-triggered events.
/// Add a new source to the poller.
/// Update a source in the poller.
/// Delete a source from the poller.
/// Wait for events.
/// Notify this poller.
/// Push an IOCP packet into the queue.
update_packet/// Run an update on a packet.
drain_update_queue/// Drain the update queue.
afd_handle/// Get a handle to the AFD reference.
/// List of IOCP packets.
/// The container for events.
/// Creates an empty list of events.
/// Iterate over I/O events.
/// A packet used to wake up the poller with an event.
/// Create a new completion packet with a custom event.
/// Get the event associated with this packet.
PacketUnwrapped/// The type of our completion packet.
PacketInner/// Set the new events that this socket is waiting on.
/// Returns `true` if we need to be updated.
/// Update the socket and install the new status in AFD.
FeedEventResult/// This socket state was notified; see if we need to update it.
begin_delete/// Begin deleting this socket.
SocketState/// The raw socket handle.
/// The base socket handle.
/// The event that this socket is currently waiting on.
interest_error/// Whether to listen for error events.
/// The current poll mode.
/// The AFD instance that this socket is registered with.
waiting_on_delete/// Whether this socket is waiting to be deleted.
SocketStatus/// The current status of the socket.
/// Per-socket state.
/// We are currently not polling.
/// We are currently polling for readable events.
/// We are currently polling for writable events.
/// We are currently polling these events.
/// The last poll operation was cancelled, and we're waiting for it to
/// complete.
/// The mode that a socket can be in.
NoEvent/// No event was yielded.
/// An event was yielded.
/// The poller has been notified.
/// The result of calling `feed_event`.
event_to_afd_maskafd_mask_to_event//! Bindings to Windows I/O Completion Ports.
//! I/O Completion Ports is a completion-based API rather than a polling-based API, like
//! epoll or kqueue. Therefore, we have to adapt the IOCP API to the crate's API.
//! WinSock is powered by the Auxillary Function Driver (AFD) subsystem, which can be
//! accessed directly by using unstable `ntdll` functions. AFD exposes features that are not
//! available through the normal WinSock interface, such as IOCTL_AFD_POLL. This function is
//! similar to the exposed `WSAPoll` method. However, once the targeted socket is "ready",
//! a completion packet is queued to an I/O completion port.
//! We take advantage of IOCTL_AFD_POLL to "translate" this crate's polling-based API
//! to the one Windows expects. When a device is added to the `Poller`, an IOCTL_AFD_POLL
//! operation is started and queued to the IOCP. To modify a currently registered device
//! (e.g. with `modify()` or `delete()`), the ongoing POLL is cancelled and then restarted
//! with new parameters. Whn the POLL eventually completes, the packet is posted to the IOCP.
//! From here it's a simple matter of using `GetQueuedCompletionStatusEx` to read the packets
//! from the IOCP and react accordingly. Notifying the poller is trivial, because we can
//! simply post a packet to the IOCP to wake it up.
//! The main disadvantage of this strategy is that it relies on unstable Windows APIs.
//! However, as `libuv` (the backing I/O library for Node.JS) relies on the same unstable
//! AFD strategy, it is unlikely to be broken without plenty of advanced warning.
//! Previously, this crate used the `wepoll` library for polling. `wepoll` uses a similar
//! AFD-based strategy for polling.
SetFileCompletionNotificationModesFILE_SKIP_SET_EVENT_ON_HANDLE/// Signal to the completion block that we are about to start an operation.
/// Unlock the completion block.
/// A completion block which can be used with I/O completion ports.
/// This must be a valid completion block.
/// Type of the completion block.
/// Get a pointer to the completion block.
/// The pointer is pinned since the underlying object should not be moved
/// after creation. This prevents it from being invalidated while it's
/// used in an overlapped operation.
/// Convert this block into a pointer that can be passed as `*mut OVERLAPPED`.
/// Convert a pointer that was passed as `*mut OVERLAPPED` into a pointer to this block.
/// This must be a valid pointer to a completion block.
/// Convert to a pointer without losing ownership.
/// The pointer to a completion block.
/// The underlying handle.
/// We own the status block.
/// A handle to the I/O completion port.
/// Create a new I/O completion port.
// TODO change to AsHandle
/// Register a handle with this I/O completion port.
/// Post a completion packet to this port.
/// Wait for completion packets to arrive.
/// The underlying entry.
/// An `OVERLAPPED_ENTRY` resulting from an I/O completion port.
into_packet/// Convert into the completion packet.
/// Get the packet reference that this entry refers to.
/// This function should only be called once, since it moves
/// out the `T` from the `OVERLAPPED_ENTRY`.
// Implementation taken from https://github.com/rust-lang/rust/blob/db5476571d9b27c862b95c1e64764b0ac8980e23/src/libstd/sys/windows/mod.rs
//! A safe wrapper around the Windows I/O API.
kqueue_fd/// File descriptor for the kqueue instance.
/// Notification pipe for waking up the poller.
/// On platforms that support `EVFILT_USER`, this uses that to wake up the poller. Otherwise, it
/// uses a pipe.
/// Interface to kqueue.
submit_changes/// Submit one or more changes to the kernel queue and check to see if they succeeded.
mode_to_flagsFilterFlagsFilterName/// A notification pipe.
/// This implementation uses `EVFILT_USER` to avoid allocating a pipe.
/// Creates a new notification pipe.
/// Registers this notification pipe in the `Poller`.
/// Reregister this notification pipe in the `Poller`.
/// Notifies the `Poller`.
/// Deregisters this notification pipe from the `Poller`.
has_fd/// Whether this raw file descriptor is associated with this pipe.
NOTIFY_KEYread_stream/// The read end of the pipe.
/// The write end of the pipe.
/// This implementation uses a pipe to send notifications.
//! Bindings to kqueue (macOS, iOS, tvOS, watchOS, FreeBSD, NetBSD, OpenBSD, DragonFly BSD).
/// Calls a libc function and results in `io::Result`.
/// Key associated with notifications.
/// Key identifying the file descriptor or socket.
/// Can it do a read operation without blocking?
/// Can it do a write operation without blocking?
/// Indicates that a file descriptor or socket can read or write without blocking.
/// Poll in oneshot mode.
/// In this mode, the poller will only deliver one event per file descriptor or socket.
/// Once an event has been delivered, interest in the event needs to be re-enabled
/// by calling `Poller::modify` or `Poller::add`.
/// This is the default mode.
/// Poll in level-triggered mode.
/// Once an event has been delivered, polling will continue to deliver that event
/// until interest in the event is disabled by calling `Poller::modify` or `Poller::delete`.
/// Not all operating system support this mode. Trying to register a file descriptor with
/// this mode in an unsupported operating system will raise an error. You can check if
/// the operating system supports this mode by calling `Poller::supports_level`.
/// Poll in edge-triggered mode.
/// Once an event has been delivered, polling will not deliver that event again unless
/// a new event occurs.
/// the operating system supports this mode by calling `Poller::supports_edge`.
EdgeOneshot/// Poll in both edge-triggered and oneshot mode.
/// This mode is similar to the `Oneshot` mode, but it will only deliver one event per new
/// event.
/// The mode in which the poller waits for I/O events.
/// All kinds of events (readable and writable).
/// Equivalent to: `Event { key, readable: true, writable: true }`
/// Only the readable event.
/// Equivalent to: `Event { key, readable: true, writable: false }`
/// Only the writable event.
/// Equivalent to: `Event { key, readable: false, writable: true }`
/// No events.
/// Equivalent to: `Event { key, readable: false, writable: false }`
/// Waits for I/O events.
/// use polling::Poller;
/// let poller = Poller::new()?;
/// # std::io::Result::Ok(())
/// Tell whether or not this `Poller` supports level-triggered polling.
/// Tell whether or not this `Poller` supports edge-triggered polling.
/// Adds a file descriptor or socket to the poller.
/// A file descriptor or socket is considered readable or writable when a read or write
/// operation on it would not block. This doesn't mean the read or write operation will
/// succeed, it only means the operation will return immediately.
/// If interest is set in both readability and writability, the two kinds of events might be
/// delivered either separately or together.
/// For example, interest in `Event { key: 7, readable: true, writable: true }` might result in
/// a single [`Event`] of the same form, or in two separate [`Event`]s:
/// - `Event { key: 7, readable: true, writable: false }`
/// - `Event { key: 7, readable: false, writable: true }`
/// Note that interest in I/O events needs to be re-enabled using
/// [`modify()`][`Poller::modify()`] again after an event is delivered if we're interested in
/// the next event of the same kind.
/// Don't forget to [`delete()`][`Poller::delete()`] the file descriptor or socket when it is
/// no longer used!
/// This method returns an error in the following situations:
/// * If `key` equals `usize::MAX` because that key is reserved for internal use.
/// * If an error is returned by the syscall.
/// Set interest in all events:
/// use polling::{Event, Poller};
/// let source = std::net::TcpListener::bind("127.0.0.1:0")?;
/// source.set_nonblocking(true)?;
/// let key = 7;
/// poller.add(&source, Event::all(key))?;
add_with_mode/// Adds a file descriptor or socket to the poller in the specified mode.
/// This is identical to the `add()` function, but allows specifying the
/// polling mode to use for this socket.
/// If the operating system does not support the specified mode, this function
/// will return an error.
/// Modifies the interest in a file descriptor or socket.
/// This method has the same behavior as [`add()`][`Poller::add()`] except it modifies the
/// interest of a previously added file descriptor or socket.
/// To use this method with a file descriptor or socket, you must first add it using
/// [`add()`][`Poller::add()`].
/// To enable interest in all events:
/// # use polling::{Event, Poller};
/// # let source = std::net::TcpListener::bind("127.0.0.1:0")?;
/// # let key = 7;
/// # let poller = Poller::new()?;
/// # poller.add(&source, Event::none(key))?;
/// poller.modify(&source, Event::all(key))?;
/// To enable interest in readable events and disable interest in writable events:
/// poller.modify(&source, Event::readable(key))?;
/// To disable interest in readable events and enable interest in writable events:
/// poller.modify(&source, Event::writable(key))?;
/// To disable interest in all events:
/// poller.modify(&source, Event::none(key))?;
modify_with_mode/// Modifies interest in a file descriptor or socket to the poller, but with the specified
/// mode.
/// This is identical to the `modify()` function, but allows specifying the polling mode
/// to use for this socket.
/// # Performance Notes
/// This function can be used to change a source from one polling mode to another. However,
/// on some platforms, this switch can cause delays in the delivery of events.
/// If the operating system does not support the specified mode, this function will return
/// an error.
/// Removes a file descriptor or socket from the poller.
/// Unlike [`add()`][`Poller::add()`], this method only removes the file descriptor or
/// socket from the poller without putting it back into blocking mode.
/// use std::net::TcpListener;
/// let socket = TcpListener::bind("127.0.0.1:0")?;
/// socket.set_nonblocking(true)?;
/// poller.add(&socket, Event::all(key))?;
/// poller.delete(&socket)?;
/// Waits for at least one I/O event and returns the number of new events.
/// New events will be appended to `events`. If necessary, make sure to clear the [`Vec`]
/// before calling [`wait()`][`Poller::wait()`]!
/// This method will return with no new events if a notification is delivered by the
/// [`notify()`] method, or the timeout is reached. Sometimes it may even return with no events
/// spuriously.
/// Only one thread can wait on I/O. If another thread is already in [`wait()`], concurrent
/// calls to this method will return immediately with no new events.
/// If the operating system is ready to deliver a large number of events at once, this method
/// may decide to deliver them in smaller batches.
/// [`notify()`]: `Poller::notify()`
/// [`wait()`]: `Poller::wait()`
/// use std::time::Duration;
/// let mut events = Vec::new();
/// let n = poller.wait(&mut events, Some(Duration::from_secs(1)))?;
/// Wakes up the current or the following invocation of [`wait()`].
/// If no thread is calling [`wait()`] right now, this method will cause the following call
/// to wake up immediately.
/// // Notify the poller.
/// poller.notify()?;
/// poller.wait(&mut events, None)?; // wakes up immediately
/// assert!(events.is_empty());
raw_fd_implr" Returns the [`RawFd`] for this I/O object.
"r" A [`RawFd`] or a reference to a type implementing [`AsRawFd`].
"unsupported_error//! Portable interface to epoll, kqueue, event ports, and IOCP.
//! Supported platforms:
//! - [epoll](https://en.wikipedia.org/wiki/Epoll): Linux, Android
//! - [kqueue](https://en.wikipedia.org/wiki/Kqueue): macOS, iOS, tvOS, watchOS, FreeBSD, NetBSD, OpenBSD,
//!   DragonFly BSD
//! - [event ports](https://illumos.org/man/port_create): illumos, Solaris
//! - [poll](https://en.wikipedia.org/wiki/Poll_(Unix)): VxWorks, Fuchsia, other Unix systems
//! - [IOCP](https://learn.microsoft.com/en-us/windows/win32/fileio/i-o-completion-ports): Windows, Wine (version 7.13+)
//! By default, polling is done in oneshot mode, which means interest in I/O events needs to
//! be re-enabled after an event is delivered if we're interested in the next event of the same
//! kind. However, level and edge triggered modes are also available for certain operating
//! systems. See the documentation of the [`PollMode`] type for more information.
//! Only one thread can be waiting for I/O events at a time.
//! # Examples
//! use polling::{Event, Poller};
//! use std::net::TcpListener;
//! // Create a TCP listener.
//! let socket = TcpListener::bind("127.0.0.1:8000")?;
//! socket.set_nonblocking(true)?;
//! let key = 7; // Arbitrary key identifying the socket.
//! // Create a poller and register interest in readability on the socket.
//! let poller = Poller::new()?;
//! poller.add(&socket, Event::readable(key))?;
//! // The event loop.
//! let mut events = Vec::new();
//! loop {
//!     // Wait for at least one I/O event.
//!     events.clear();
//!     poller.wait(&mut events, None)?;
//!     for ev in &events {
//!         if ev.key == key {
//!             // Perform a non-blocking accept operation.
//!             socket.accept()?;
//!             // Set interest in the next readability event.
//!             poller.modify(&socket, Event::readable(key))?;
//!         }
//! # std::io::Result::Ok(())
PollerSealed/// Post a new [`Event`] to the poller.
/// use polling::{Poller, Event};
/// use polling::os::iocp::{CompletionPacket, PollerIocpExt};
/// use std::thread;
/// use std::sync::Arc;
/// # fn main() -> std::io::Result<()> {
/// // Spawn a thread to wake us up after 100ms.
/// let poller = Arc::new(Poller::new()?);
/// thread::spawn({
///     let poller = poller.clone();
///     move || {
///         let packet = CompletionPacket::new(Event::readable(0));
///         thread::sleep(Duration::from_millis(100));
///         poller.post(packet).unwrap();
/// });
/// // Wait for the event.
/// let mut events = vec![];
/// poller.wait(&mut events, None)?;
/// assert_eq!(events.len(), 1);
/// # Ok(()) }
/// Extension trait for the [`Poller`] type that provides functionality specific to IOCP-based
/// platforms.
/// [`Poller`]: crate::Poller
//! Functionality that is only availale for IOCP-based platforms.
FilterSealed/// Add a filter to the poller.
/// This is similar to [`add`][Poller::add], but it allows you to specify a filter instead of
/// a socket. See the implementors of the [`Filter`] trait for more information.
/// use polling::{Poller, PollMode};
/// use polling::os::kqueue::{Filter, PollerKqueueExt, Signal};
/// let poller = Poller::new().unwrap();
/// // Register the SIGINT signal.
/// poller.add_filter(Signal(libc::SIGINT), 0, PollMode::Oneshot).unwrap();
/// // Wait for the signal.
/// poller.wait(&mut events, None).unwrap();
/// # let _ = events;
modify_filter/// Modify a filter in the poller.
/// This is similar to [`modify`][Poller::modify], but it allows you to specify a filter
/// instead of a socket. See the implementors of the [`Filter`] trait for more information.
/// // Re-register with a different key.
/// poller.modify_filter(Signal(libc::SIGINT), 1, PollMode::Oneshot).unwrap();
delete_filter/// Remove a filter from the poller.
/// This is used to remove filters that were previously added with
/// [`add_filter`](PollerKqueueExt::add_filter).
/// // Remove the filter.
/// poller.delete_filter(Signal(libc::SIGINT)).unwrap();
// TODO(notgull): We should also have EVFILT_AIO, EVFILT_VNODE and EVFILT_USER. However, the current
// API makes it difficult to effectively express events from these filters. At the next breaking
// change, we should change `Event` to be a struct with private fields, and encode additional
// information in there.
/// Functionality that is only available for `kqueue`-based platforms.
/// `kqueue` is able to monitor much more than just read/write readiness on file descriptors. Using
/// this extension trait, you can monitor for signals, process exits, and more. See the implementors
/// of the [`Filter`] trait for more information.
/// A filter that can be registered into a `kqueue`.
/// Monitor this signal number.
/// No matter what `PollMode` is specified, this filter will always be
/// oneshot-only.
/// Alias for `libc::c_int`.
/// The child process to monitor.
/// The operation to monitor.
/// Monitor a child process.
/// The process exited.
/// The process was forked.
/// The process executed a new process.
/// The operations that a monitored process can perform.
/// Identifier for the timer.
/// The timeout to wait for.
/// Wait for a timeout to expire.
/// Modifying the timeout after it has been added to the poller will reset it.
/// Get the filter for the given event.
/// This filter's flags must have `EV_RECEIPT`.
//! Functionality that is only available for `kqueue`-based platforms.
//! Platform-specific functionality.
// std::os::unix doesn't exist on Fuchsia
/// File descriptors to poll.
/// The file descriptor of the read half of the notify pipe. This is also stored as the first
/// file descriptor in `fds.poll_fds`.
notify_write/// The file descriptor of the write half of the notify pipe.
/// Data is written to this to wake up the current instance of `wait`, which can occur when the
/// user notifies it (in which case `notified` would have been set) or when an operation needs
/// to occur (in which case `waiting_operations` would have been incremented).
/// The number of operations (`add`, `modify` or `delete`) that are currently waiting on the
/// mutex to become free. When this is nonzero, `wait` must be suspended until it reaches zero
/// again.
/// Whether `wait` has been notified by the user.
/// The condition variable that gets notified when `waiting_operations` reaches zero or
/// `notified` becomes true.
/// This is used with the `fds` mutex.
/// Interface to poll.
/// The list of `pollfds` taken by poll.
/// The first file descriptor is always present and is used to notify the poller. It is also
/// stored in `notify_read`.
/// The map of each file descriptor to data associated with it. This does not include the file
/// descriptors `notify_read` or `notify_write`.
/// The file descriptors to poll in a `Poller`.
/// Transparent wrapper around `libc::pollfd`, used to support `Debug` derives without adding the
/// `extra_traits` feature of `libc`.
/// The index into `poll_fds` this file descriptor is.
/// The key of the `Event` associated with this file descriptor.
/// Whether to remove this file descriptor from the poller on the next call to `wait`.
/// Data associated with a file descriptor in a poller.
/// Perform a modification on `fds`, interrupting the current caller of `wait` if it's running.
notify_inner/// Wake the current thread that is calling `wait`.
pop_notification/// Remove a notification created by `notify_inner`.
/// Get the input poll events for the given event.
READ_REVENTS/// Returned poll events for reading.
WRITE_REVENTS/// Returned poll events for writing.
/// Helper function to call poll.
cvt_mode_as_remove//! Bindings to poll (VxWorks, Fuchsia, other Unix systems).
port_fd/// File descriptor for the port instance.
/// Interface to event ports.
/// Adds a file descriptor.
/// Poll flags for all possible readability events.
/// Poll flags for all possible writability events.
//! Bindings to event port (illumos, Solaris).
ItimerspecTimerfdClockIdTimerfdFlagsTimerfdTimerFlagsTimespecfcntl_getflfcntl_setflOFlagsfcntl_getfdfcntl_setfdFdFlagspipe_withPipeFlags/// File descriptor for the epoll instance./// Notifier used to wake up epoll./// File descriptor for the timerfd that produces timeouts./// Redox does not support timerfd./// Interface to epoll./// Creates a new poller./// Whether this poller supports level-triggered events./// Whether the poller supports edge-triggered events./// Adds a new file descriptor./// The `fd` must be a valid file descriptor. The usual condition of remaining registered in/// the `Poller` doesn't apply to `epoll`./// Modifies an existing file descriptor./// Deletes a file descriptor./// Waits for I/O events with an optional timeout./// Sends a notification to wake up the current or next `wait()` call./// `timespec` value that equals zero.epoll_flagsEventFlags/// Get the EPOLL flags for the interest./// Epoll flags for all possible readability events./// Epoll flags for all possible writability events.EventVec/// A list of reported I/O events./// Creates an empty list./// Iterates over I/O events./// Clear the list./// Get the capacity of the list.EventExtra/// Extra information about this event./// Create an empty version of the data.set_hup/// Add the interrupt flag to this event.set_pri/// Add the priority flag to this event.is_hup/// Tell if the interrupt flag is set.is_pri/// Tell if the priority flag is set.is_connect_failed/// The primary notifier, using eventfd.read_pipe/// The read end of the pipe.write_pipe/// The write end of the pipe./// The fallback notifier, using a pipe./// The notifier for Linux./// Certain container runtimes do not expose eventfd to the client, as it relies on the host and/// can be used to "escape" the container under certain conditions. Gramine is the prime example,/// see [here](gramine). In this case, fall back to using a pipe./// [gramine]: https://gramine.readthedocs.io/en/stable/manifest-syntax.html#allowing-eventfd/// Create a new notifier./// The file descriptor to register in the poller./// Clear the notification.//! Bindings to epoll (Linux, Android)./// The timeout for this poll./// The number of handles being polled./// Whether or not this poll is exclusive for this handle./// The handles to poll./// The handle to poll./// The events to poll for./// The status of the poll.RECEIVERECEIVE_EXPEDITEDSENDDISCONNECTABORTLOCAL_CLOSECONNECT_FAIL/// Creates an empty mask./// Checks if this mask contains the other mask./// Sets a flag./// The handle to the AFD device./// We own `T`./// Create a new AFD device./// Begin polling with the provided handle./// Cancel an ongoing poll operation./// The poll operation must currently be in progress for this AFD./// The one-time initialization./// A one-time initialization cell./// Creates a new `OnceCell`./// Gets the value or initializes it./// Can be transmuted to an I/O status block./// A pointer to `T` must be able to be converted to a pointer to `IO_STATUS_BLOCK`/// without any issues./// Get the base socket associated with a socket./// Run an IOCTL on a socket and return a socket./// The `ioctl` parameter must be a valid I/O control that returns a valid socket.//! Safe wrapper around \Device\AfdUnregisterWaitWT_EXECUTELONGFUNCTIONWT_EXECUTEONLYONCE/// Macro to lock and ignore lock poisoning./// The I/O completion port./// List of currently active AFD instances./// AFD acts as the actual source of the socket events. It's essentially running `WSAPoll` on/// the sockets and then posting the events to the IOCP./// AFD instances can be keyed to an unlimited number of sockets. However, each AFD instance/// polls their sockets linearly. Therefore, it is best to limit the number of sockets each AFD/// instance is responsible for. The limit of 32 is chosen because that's what `wepoll` uses./// Weak references are kept here so that the AFD handle is automatically dropped when the last/// associated socket is dropped./// The state of the sources registered with this poller./// Each source is keyed by its raw socket ID.waitables/// The state of the waitable handles registered with this poller./// Sockets with pending updates./// This list contains packets with sockets that need to have their AFD state adjusted by/// calling the `update()` function on them. It's best to queue up packets as they need to/// be updated and then run all of the updates before we start waiting on the IOCP, rather than/// updating them as we come. If we're waiting on the IOCP updates should be run immediately./// Are we currently polling?/// This indicates whether or not we are blocking on the IOCP, and is used to determine/// whether pending updates should be run immediately or queued./// The packet used to notify the poller./// This is a special-case packet that is used to wake up the poller when it is waiting./// Interface to I/O completion ports./// Whether this poller supports edge-triggered events./// Add a new source to the poller./// The socket must be a valid socket and must last until it is deleted./// Update a source in the poller./// Delete a source from the poller.add_waitable/// Add a new waitable to the poller.modify_waitable/// Update a waitable in the poller.remove_waitable/// Delete a waitable from the poller./// Wait for events./// Notify this poller./// Push an IOCP packet into the queue./// Run an update on a packet./// Drain the update queue./// Get a handle to the AFD reference./// This finds an AFD handle with less than 32 associated sockets, or creates a new one if/// one does not exist./// List of IOCP packets./// Buffer for completion packets./// The container for events./// Creates an empty list of events./// Iterate over I/O events./// Clear the list of events./// The capacity of the list of events./// Flags associated with this event./// Extra information about an event./// Create a new, empty version of this struct./// Is this a HUP event?/// Is this a PRI event?/// Set up a listener for HUP events./// Set up a listener for PRI events./// Check if TCP connect failed. Deprecated./// Check if TCP connect failed./// A packet used to wake up the poller with an event./// Create a new completion packet with a custom event./// Get the event associated with this packet./// The type of our completion packet./// It needs to be pinned, since it contains data that is expected by IOCP not to be moved./// Set the new events that this socket is waiting on./// Returns `true` if we need to be updated./// Update the socket and install the new status in AFD./// This function does one of the following:/// - Nothing, if the packet is waiting on being dropped anyways./// - Cancels the ongoing poll, if we want to poll for different events than we are currently///   polling for./// - Starts a new AFD_POLL operation, if we are not currently polling./// This socket state was notified; see if we need to update it./// This indicates that this packet was indicated as "ready" by the IOCP and needs to be/// Begin deleting this socket./// The raw socket handle./// The base socket handle./// The event that this socket is currently waiting on./// Whether to listen for error events./// The current poll mode./// The AFD instance that this socket is registered with./// Whether this socket is waiting to be deleted./// The current status of the socket./// Per-socket state./// We are currently not polling./// The flags we are currently polling for./// We are currently polling these events./// The last poll operation was cancelled, and we're waiting for it to/// The mode that a socket can be in./// The handle that this state is for./// The IO completion port that this handle is registered with./// The event that this handle will report.WaitableStatus/// The status of this waitable.WaitableState/// Per-waitable handle state./// We are not polling.WaitHandle/// We are waiting on this handle to become signaled./// This handle has been cancelled./// No event was yielded./// An event was yielded./// The poller has been notified./// The result of calling `feed_event`./// A handle for an ongoing wait operation./// Wait for a waitable handle to become signaled./// Translate an event to the mask expected by AFD.event_properties_to_afd_mask/// Convert the mask reported by AFD to an event./// String description of what happened./// The underlying system error.AfdError/// An error type that wraps around failing to open AFD.//! Bindings to Windows I/O Completion Ports.//! I/O Completion Ports is a completion-based API rather than a polling-based API, like//! epoll or kqueue. Therefore, we have to adapt the IOCP API to the crate's API.//! WinSock is powered by the Auxillary Function Driver (AFD) subsystem, which can be//! accessed directly by using unstable `ntdll` functions. AFD exposes features that are not//! available through the normal WinSock interface, such as IOCTL_AFD_POLL. This function is//! similar to the exposed `WSAPoll` method. However, once the targeted socket is "ready",//! a completion packet is queued to an I/O completion port.//! We take advantage of IOCTL_AFD_POLL to "translate" this crate's polling-based API//! to the one Windows expects. When a device is added to the `Poller`, an IOCTL_AFD_POLL//! operation is started and queued to the IOCP. To modify a currently registered device//! (e.g. with `modify()` or `delete()`), the ongoing POLL is cancelled and then restarted//! with new parameters. Whn the POLL eventually completes, the packet is posted to the IOCP.//! From here it's a simple matter of using `GetQueuedCompletionStatusEx` to read the packets//! from the IOCP and react accordingly. Notifying the poller is trivial, because we can//! simply post a packet to the IOCP to wake it up.//! The main disadvantage of this strategy is that it relies on unstable Windows APIs.//! However, as `libuv` (the backing I/O library for Node.JS) relies on the same unstable//! AFD strategy, it is unlikely to be broken without plenty of advanced warning.//! Previously, this crate used the `wepoll` library for polling. `wepoll` uses a similar//! AFD-based strategy for polling./// Signal to the completion block that we are about to start an operation./// Unlock the completion block./// A completion block which can be used with I/O completion ports./// This must be a valid completion block./// Type of the completion block./// Get a pointer to the completion block./// The pointer is pinned since the underlying object should not be moved/// after creation. This prevents it from being invalidated while it's/// used in an overlapped operation./// Convert this block into a pointer that can be passed as `*mut OVERLAPPED`./// Convert a pointer that was passed as `*mut OVERLAPPED` into a pointer to this block./// This must be a valid pointer to a completion block./// Convert to a pointer without losing ownership./// The pointer to a completion block./// The underlying handle./// We own the status block./// A handle to the I/O completion port./// Create a new I/O completion port.// TODO change to AsHandle/// Register a handle with this I/O completion port./// Post a completion packet to this port./// Wait for completion packets to arrive./// The underlying entry./// An `OVERLAPPED_ENTRY` resulting from an I/O completion port./// Convert into the completion packet./// Get the packet reference that this entry refers to./// This function should only be called once, since it moves/// out the `T` from the `OVERLAPPED_ENTRY`.//! A safe wrapper around the Windows I/O API./// File descriptor for the kqueue instance./// List of sources currently registered in this poller./// This is used to make sure the same source is not registered twice./// Notification pipe for waking up the poller./// On platforms that support `EVFILT_USER`, this uses that to wake up the poller. Otherwise, it/// uses a pipe./// Interface to kqueue./// Registered file descriptor./// Signal./// Process ID./// Timer ID./// Identifier for a source./// The file descriptor must be valid and it must last until it is deleted./// Submit one or more changes to the kernel queue and check to see if they succeeded.add_source/// Add a source to the sources set.has_source/// Tell if a source is currently inside the set.remove_source/// Remove a source from the sources set./// Clears the list./// Extra information associated with an event./// Set the interrupt flag./// Set the priority flag./// Is the interrupt flag set?/// Is the priority flag set?/// A notification pipe./// This implementation uses `EVFILT_USER` to avoid allocating a pipe./// Creates a new notification pipe./// Registers this notification pipe in the `Poller`./// Reregister this notification pipe in the `Poller`./// Notifies the `Poller`./// Deregisters this notification pipe from the `Poller`./// Whether this raw file descriptor is associated with this pipe./// This implementation uses a pipe to send notifications.//! Bindings to kqueue (macOS, iOS, tvOS, watchOS, FreeBSD, NetBSD, OpenBSD, DragonFly BSD)./// Key associated with notifications./// Key identifying the file descriptor or socket./// Can it do a read operation without blocking?/// Can it do a write operation without blocking?/// System-specific event data./// Indicates that a file descriptor or socket can read or write without blocking./// Poll in oneshot mode./// In this mode, the poller will only deliver one event per file descriptor or socket./// Once an event has been delivered, interest in the event needs to be re-enabled/// by calling `Poller::modify` or `Poller::add`./// This is the default mode./// Poll in level-triggered mode./// Once an event has been delivered, polling will continue to deliver that event/// until interest in the event is disabled by calling `Poller::modify` or `Poller::delete`./// Not all operating system support this mode. Trying to register a file descriptor with/// this mode in an unsupported operating system will raise an error. You can check if/// the operating system supports this mode by calling `Poller::supports_level`./// Poll in edge-triggered mode./// Once an event has been delivered, polling will not deliver that event again unless/// a new event occurs./// the operating system supports this mode by calling `Poller::supports_edge`./// Poll in both edge-triggered and oneshot mode./// This mode is similar to the `Oneshot` mode, but it will only deliver one event per new/// The mode in which the poller waits for I/O events./// Create a new event./// All kinds of events (readable and writable)./// Equivalent to: `Event::new(key, true, true)`/// Only the readable event./// Equivalent to: `Event::new(key, true, false)`/// Only the writable event./// Equivalent to: `Event::new(key, false, true)`/// No events./// Equivalent to: `Event::new(key, false, false)`set_interrupt/// Add interruption events to this interest./// This usually indicates that the file descriptor or socket has been closed. It corresponds/// to the `EPOLLHUP` and `POLLHUP` events./// Interruption events are only supported on the following platforms:/// - `epoll`/// - `poll`/// - IOCP/// - Event Ports/// On other platforms, this function is a no-op.with_interrupt/// Add priority events to this interest./// This indicates that there is urgent data to read. It corresponds to the `EPOLLPRI` and/// `POLLPRI` events./// Priority events are only supported on the following platforms:with_priorityis_interrupt/// Tell if this event is the result of an interrupt notification./// On other platforms, this always returns `false`./// Tell if this event is the result of a priority notification./// Tells if this event is the result of a connection failure./// This function checks if a TCP connection has failed. It corresponds to the `EPOLLERR`  or `EPOLLHUP` event in Linux/// and `CONNECT_FAILED` event in Windows IOCP./// use std::{io, net};/// // Assuming polling and socket2 are included as dependencies in Cargo.toml/// use polling::Event;/// use socket2::Type;/// fn main() -> io::Result<()> {///     let socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;///     let poller = polling::Poller::new()?;///         poller.add(&socket, Event::new(0, true, true))?;///     let addr = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 8080);///     socket.set_nonblocking(true)?;///     let _ = socket.connect(&addr.into());///     let mut events = polling::Events::new();///     events.clear();///     poller.wait(&mut events, None)?;///     let event = events.iter().next();///     let event = match event {///         Some(event) => event,///             println!("no event");///     println!("event: {:?}", event);///     if event///         .is_connect_failed()///         .unwrap_or_default()///         println!("connect failed");/// Returns `Some(true)` if the connection has failed, `Some(false)` if the connection has not failed,/// or `None` if the platform does not support detecting this condition./// This function checks if an error exist, particularly useful in detecting if TCP connection failed. It corresponds to the `EPOLLERR` event in Linux/// In `epoll`, a TCP connection failure is indicated by `EPOLLERR` + `EPOLLHUP`, though just `EPOLLERR` is enough to indicate a connection failure./// EPOLLHUP may happen when we haven't event called `connect` on the socket, but it is still a valid event to check for./// Returns `Some(true)` if the connection has failed, `Some(false)` if there is no error,clear_extra/// Remove any extra information from this event.with_no_extra/// Get a version of this event with no extra information./// This is useful for comparing events with `==`./// Waits for I/O events./// use polling::Poller;/// let poller = Poller::new()?;/// Tell whether or not this `Poller` supports level-triggered polling./// Tell whether or not this `Poller` supports edge-triggered polling.AsRawSource/// Adds a file descriptor or socket to the poller./// A file descriptor or socket is considered readable or writable when a read or write/// operation on it would not block. This doesn't mean the read or write operation will/// succeed, it only means the operation will return immediately./// If interest is set in both readability and writability, the two kinds of events might be/// delivered either separately or together./// For example, interest in `Event { key: 7, readable: true, writable: true }` might result in/// a single [`Event`] of the same form, or in two separate [`Event`]s:/// - `Event { key: 7, readable: true, writable: false }`/// - `Event { key: 7, readable: false, writable: true }`/// Note that interest in I/O events needs to be re-enabled using/// [`modify()`][`Poller::modify()`] again after an event is delivered if we're interested in/// the next event of the same kind./// It is possible to register interest in the same file descriptor or socket using multiple/// separate [`Poller`] instances. When the event is delivered, one or more [`Poller`]s are/// notified with that event. The exact number of [`Poller`]s notified depends on the/// underlying platform. When registering multiple sources into one event, the user should/// be careful to accommodate for events lost to other pollers./// One may also register one source into other, non-`polling` event loops, like GLib's/// context. While the plumbing will vary from platform to platform, in general the [`Poller`]/// will act as if the source was registered with another [`Poller`], with the same caveats/// as above./// The source must be [`delete()`]d from this `Poller` before it is dropped./// [`delete()`]: Poller::delete/// This method returns an error in the following situations:/// * If `key` equals `usize::MAX` because that key is reserved for internal use./// * If an error is returned by the syscall./// Set interest in all events:/// use polling::{Event, Poller};/// let source = std::net::TcpListener::bind("127.0.0.1:0")?;/// source.set_nonblocking(true)?;/// let key = 7;///     poller.add(&source, Event::all(key))?;/// poller.delete(&source)?;/// Adds a file descriptor or socket to the poller in the specified mode./// This is identical to the `add()` function, but allows specifying the/// polling mode to use for this socket./// If the operating system does not support the specified mode, this function/// will return an error.AsSource/// Modifies the interest in a file descriptor or socket./// This method has the same behavior as [`add()`][`Poller::add()`] except it modifies the/// interest of a previously added file descriptor or socket./// To use this method with a file descriptor or socket, you must first add it using/// [`add()`][`Poller::add()`]./// To enable interest in all events:/// # use polling::{Event, Poller};/// # let source = std::net::TcpListener::bind("127.0.0.1:0")?;/// # let key = 7;/// # let poller = Poller::new()?;/// # unsafe { poller.add(&source, Event::none(key))?; }/// poller.modify(&source, Event::all(key))?;/// To enable interest in readable events and disable interest in writable events:/// poller.modify(&source, Event::readable(key))?;/// # poller.delete(&source)?;/// To disable interest in readable events and enable interest in writable events:/// # unsafe { poller.add(&source, Event::none(key))? };/// poller.modify(&source, Event::writable(key))?;/// To disable interest in all events:/// poller.modify(&source, Event::none(key))?;/// Modifies interest in a file descriptor or socket to the poller, but with the specified/// mode./// This is identical to the `modify()` function, but allows specifying the polling mode/// to use for this socket./// # Performance Notes/// This function can be used to change a source from one polling mode to another. However,/// on some platforms, this switch can cause delays in the delivery of events./// If the operating system does not support the specified mode, this function will return/// Removes a file descriptor or socket from the poller./// Unlike [`add()`][`Poller::add()`], this method only removes the file descriptor or/// socket from the poller without putting it back into blocking mode./// let socket = TcpListener::bind("127.0.0.1:0")?;/// socket.set_nonblocking(true)?;/// unsafe { poller.add(&socket, Event::all(key))?; }/// poller.delete(&socket)?;/// Waits for at least one I/O event and returns the number of new events./// New events will be appended to `events`. If necessary, make sure to clear the/// [`Events`][Events::clear()] before calling [`wait()`][`Poller::wait()`]!/// This method will return with no new events if a notification is delivered by the/// [`notify()`] method, or the timeout is reached. Sometimes it may even return with no events/// spuriously./// Only one thread can wait on I/O. If another thread is already in [`wait()`], concurrent/// calls to this method will return immediately with no new events./// If the operating system is ready to deliver a large number of events at once, this method/// may decide to deliver them in smaller batches./// [`notify()`]: `Poller::notify()`/// [`wait()`]: `Poller::wait()`/// use polling::{Event, Events, Poller};///     poller.add(&socket, Event::all(key))?;/// let mut events = Events::new();/// let n = poller.wait(&mut events, Some(Duration::from_secs(1)))?;/// Wakes up the current or the following invocation of [`wait()`]./// If no thread is calling [`wait()`] right now, this method will cause the following call/// to wake up immediately./// use polling::{Events, Poller};/// // Notify the poller./// poller.notify()?;/// poller.wait(&mut events, None)?; // wakes up immediately_not_sync/// This is intended to be used from &mut, thread locally, so we should make it !Sync/// for consistency with the rest of the API./// A container for I/O events./// Create a new container for events, using the default capacity./// The default capacity is 1024./// use polling::Events;/// let events = Events::new();/// Create a new container with the provided capacity./// use std::num::NonZeroUsize;/// let capacity = NonZeroUsize::new(1024).unwrap();/// let events = Events::with_capacity(capacity);/// Create a new iterator over I/O events./// This returns all of the events in the container, excluding the notification event./// poller.wait(&mut events, Some(Duration::from_secs(0)))?;/// assert!(events.iter().next().is_none());/// Delete all of the events in the container./// /* register some sources *//// poller.wait(&mut events, None)?;/// Returns the number of events in the container./// assert_eq!(events.len(), 0);/// Returns `true` if the container contains no events./// Get the total capacity of the list./// let cap = NonZeroUsize::new(10).unwrap();/// let events = Events::with_capacity(std::num::NonZeroUsize::new(10).unwrap());/// assert_eq!(events.capacity(), cap);r" Returns the raw file descriptor."r" A resource with a raw file descriptor."r" Returns the borrowed file descriptor."r" A resource with a borrowed file descriptor."_assert_send_and_sync//! Portable interface to epoll, kqueue, event ports, and IOCP.//! Supported platforms://! - [epoll](https://en.wikipedia.org/wiki/Epoll): Linux, Android, RedoxOS//! - [kqueue](https://en.wikipedia.org/wiki/Kqueue): macOS, iOS, tvOS, watchOS, FreeBSD, NetBSD, OpenBSD,//!   DragonFly BSD//! - [event ports](https://illumos.org/man/port_create): illumos, Solaris//! - [poll](https://en.wikipedia.org/wiki/Poll_(Unix)): VxWorks, Fuchsia, HermitOS, other Unix systems//! - [IOCP](https://learn.microsoft.com/en-us/windows/win32/fileio/i-o-completion-ports): Windows, Wine (version 7.13+)//! By default, polling is done in oneshot mode, which means interest in I/O events needs to//! be re-enabled after an event is delivered if we're interested in the next event of the same//! kind. However, level and edge triggered modes are also available for certain operating//! systems. See the documentation of the [`PollMode`] type for more information.//! Only one thread can be waiting for I/O events at a time.//! use polling::{Event, Events, Poller};//! use std::net::TcpListener;//! // Create a TCP listener.//! let socket = TcpListener::bind("127.0.0.1:8000")?;//! socket.set_nonblocking(true)?;//! let key = 7; // Arbitrary key identifying the socket.//! // Create a poller and register interest in readability on the socket.//! let poller = Poller::new()?;//!     poller.add(&socket, Event::readable(key))?;//! // The event loop.//! let mut events = Events::new();//!     // Wait for at least one I/O event.//!     events.clear();//!     poller.wait(&mut events, None)?;//!     for ev in events.iter() {//!         if ev.key == key {//!             // Perform a non-blocking accept operation.//!             socket.accept()?;//!             // Set interest in the next readability event.//!             poller.modify(&socket, Event::readable(key))?;//! poller.delete(&socket)?;//! # std::io::Result::Ok(())/// Post a new [`Event`] to the poller./// use polling::{Poller, Event, Events};/// use polling::os::iocp::{CompletionPacket, PollerIocpExt};/// // Spawn a thread to wake us up after 100ms./// let poller = Arc::new(Poller::new()?);///     let poller = poller.clone();///         let packet = CompletionPacket::new(Event::readable(0));///         thread::sleep(Duration::from_millis(100));///         poller.post(packet).unwrap();/// // Wait for the event./// assert_eq!(events.len(), 1);AsRawWaitable/// Add a waitable handle to this poller./// Some handles in Windows are "waitable", which means that they emit a "readiness" signal/// after some event occurs. This function can be used to wait for such events to occur/// on a handle. This function can be used in addition to regular socket polling./// Once the object has been signalled, the poller will emit the `interest` event./// The added handle must not be dropped before it is deleted./// use polling::{Poller, Event, Events, PollMode};/// use polling::os::iocp::PollerIocpExt;/// // Spawn a new process./// let mut child = Command::new("echo")///     .arg("Hello, world!")///     .spawn()/// // Create a new poller./// let poller = Poller::new().unwrap();/// // Add the child process to the poller.///     poller.add_waitable(&child, Event::all(0), PollMode::Oneshot).unwrap();/// // Wait for the child process to exit./// poller.wait(&mut events, None).unwrap();/// assert_eq!(events.iter().next().unwrap(), Event::all(0));AsWaitable/// Modify an existing waitable handle./// This function can be used to change the emitted event and/or mode of an existing waitable/// handle. The handle must have been previously added to the poller using [`add_waitable`]./// [`add_waitable`]: Self::add_waitable/// // Modify the waitable handle./// poller.modify_waitable(&child, Event::readable(0), PollMode::Oneshot).unwrap();/// Remove a waitable handle from this poller./// This function can be used to remove a waitable handle from the poller. The handle must/// have been previously added to the poller using [`add_waitable`]./// // Remove the waitable handle./// poller.remove_waitable(&child).unwrap();/// Extension trait for the [`Poller`] type that provides functionality specific to IOCP-based/// [`Poller`]: crate::Poller/// Returns the raw handle of this waitable./// A type that represents a waitable handle.as_waitable//! Functionality that is only available for IOCP-based platforms./// Add a filter to the poller./// This is similar to [`add`][Poller::add], but it allows you to specify a filter instead of/// a socket. See the implementors of the [`Filter`] trait for more information./// use polling::{Events, Poller, PollMode};/// use polling::os::kqueue::{Filter, PollerKqueueExt, Signal};/// // Register the SIGINT signal./// poller.add_filter(Signal(rustix::process::Signal::Int as _), 0, PollMode::Oneshot).unwrap();/// // Wait for the signal./// # let _ = events;/// Modify a filter in the poller./// This is similar to [`modify`][Poller::modify], but it allows you to specify a filter/// instead of a socket. See the implementors of the [`Filter`] trait for more information./// // Re-register with a different key./// poller.modify_filter(Signal(rustix::process::Signal::Int as _), 1, PollMode::Oneshot).unwrap();/// Remove a filter from the poller./// This is used to remove filters that were previously added with/// [`add_filter`](PollerKqueueExt::add_filter)./// use polling::{Poller, PollMode};/// // Remove the filter./// poller.delete_filter(Signal(rustix::process::Signal::Int as _)).unwrap();/// Functionality that is only available for `kqueue`-based platforms./// `kqueue` is able to monitor much more than just read/write readiness on file descriptors. Using/// this extension trait, you can monitor for signals, process exits, and more. See the implementors/// of the [`Filter`] trait for more information./// A filter that can be registered into a `kqueue`./// Monitor this signal number./// No matter what `PollMode` is specified, this filter will always be/// oneshot-only./// The process ID to monitor./// The operation to monitor./// Lifetime of the underlying process./// Monitor a child process./// The process exited./// The process was forked./// The process executed a new process./// The operations that a monitored process can perform./// Once registered into the `Poller`, the `Child` object must outlive this filter's/// registration into the poller.from_pid/// Create a `Process` from a PID./// The PID must be tied to an actual child process./// Identifier for the timer./// The timeout to wait for./// Wait for a timeout to expire./// Modifying the timeout after it has been added to the poller will reset it./// Get the filter for the given event./// This filter's flags must have `EV_RECEIPT`./// Get the source ID for this source.// TODO(notgull): We should also have EVFILT_AIO, EVFILT_VNODE and EVFILT_USER. However, the current// API makes it difficult to effectively express events from these filters. At the next breaking// change, we should change `Event` to be a struct with private fields, and encode additional// information in there.// std::os::unix doesn't exist on Fuchsia/// On all platforms except ESP IDF, the `pipe` syscall is used./// On ESP IDF, the `eventfd` syscall is used instead./// Whether `wait` has been notified by the user./// The first file descriptor is always present and is used to notify the poller. It is also/// stored in `notify_read`./// descriptors `notify_read` or `notify_write`./// Whether to remove this file descriptor from the poller on the next call to `wait`./// Returned poll events for reading.write_events/// Returned poll events for writing./// Creates an empty set of extra information./// Is this an interrupt event?/// Is this a priority event?/// Create an eventfd./// Read some bytes./// Write some bytes./// Safe wrapper around the `poll` system call.hermit_abi/// Safe wrapper around `pollfd`.from_borrowed_fd/// Wrapper around polling flags./// Empty set of flags.WRBAND/// Tell if this contains some flags./// Set a flag./// Tell if this is empty./// Tell if this intersects with some flags./// Convert a number to an actual result.// TODO: Remove this shim once HermitOS is supported in Rustix./// The file descriptor of the read half of the notify pipe. This is also stored as the first/// file descriptor in `fds.poll_fds`./// The file descriptor of the write half of the notify pipe./// Data is written to this to wake up the current instance of `Poller::wait`, which can occur when the/// user notifies it (in which case `Poller::notified` would have been set) or when an operation needs/// to occur (in which case `Poller::waiting_operations` would have been incremented)./// Provides the file handle of the read half of the notify pipe that needs to be registered by the `Poller`.poll_flags/// Provides the poll flags to be used when registering the read half of the notify pipe with the `Poller`./// Notifies the `Poller` instance via the write half of the notify pipe./// Pops a notification (if any) from the pipe.pop_all_notifications/// Pops all notifications from the pipe./// Whether this raw file descriptor is associated with this notifier./// The file descriptor of the eventfd object. This is also stored as the first/// This implementation uses the `eventfd` syscall to send notifications./// Provides the eventfd file handle that needs to be registered by the `Poller`./// Provides the eventfd file handle poll flags to be used when registering it with the `Poller`./// Notifies the `Poller` instance via the eventfd file descriptor./// Pops a notification (if any) from the eventfd file descriptor./// Pops all notifications from the eventfd file descriptor./// Since the eventfd object accumulates all writes in a single 64 bit value,/// this operation is - in fact - equivalent to `pop_notification`.//! Bindings to poll (VxWorks, Fuchsia, other Unix systems)./// File descriptor for the port instance./// Interface to event ports./// Adds a file descriptor./// The `fd` must be a valid file descriptor and it must last until it is deleted./// Poll flags for all possible readability events./// Poll flags for all possible writability events.//! Bindings to event port (illumos, Solaris).afl/// Initialize Poly1305 [`State`] with the given keycompute_block/// Compute a Poly1305 block/// Finalize output producing a [`Tag`]//! Autodetection support for AVX2 CPU intrinsics on x86 CPUs, with fallback//! to the "soft" backend when it's unavailable.set02write_130/// Helper for Display impls of aligned values.write_130_wide/// Helper for Display impls of unreduced values.prepare_keysAdditionKeyPrecomputedMultiplier/// Derives the Poly1305 addition and polynomial keys.Aligned130/// A 130-bit integer aligned across five 26-bit limbs./// The top three 32-bit words of the underlying 256-bit vector are ignored.from_block/// Aligns a 16-byte Poly1305 block at 26-bit boundaries within 32-bit words, and sets/// the high bit.from_partial_block/// Aligns a partial Poly1305 block at 26-bit boundaries within 32-bit words./// Assumes that the high bit is already correctly set for the partial block./// Splits a 130-bit integer into five 26-bit limbs.a_5/// A pre-computed multiplier.Unreduced130/// Multiplies 2 values using lazy reduction./// Context switches from 32 bit to 64 bit.v0/// The unreduced output of an `Aligned130` multiplication./// Represented internally with 64-bit limbs./// Reduces x modulo 2^130 - 5./// Context switches from 64 bit to 32 bit./// Carry chain/// Reduction modulus 2^130-5Aligned2x130/// A pair of `Aligned130`s.from_blocks/// Aligns two 16-byte Poly1305 blocks at 26-bit boundaries within 32-bit words, and/// sets the high bit for each block./// Panics if `src.len() < 32`.mul_and_sum/// Multiplies 2x2 and add both results simultaneously using lazy reduction./// Adds `other` into the lower integer of `self`.r1SpacedMultiplier4x130/// A multiplier that takes 130-bit integers `(x3, x2, x1, x0)` and computes/// `(x3·R^4, x2·R^3, x1·R^2, x0·R) mod 2^130 - 5`./// Returns `(multipler, R^4)` given `(R^1, R^2)`.Aligned4x130/// Four 130-bit integers aligned across five 26-bit limbs each./// Unlike `Aligned2x130` which wraps two `Aligned130`s, this struct represents the four/// integers as 20 limbs spread across three 256-bit vectors./// Aligns four 16-byte Poly1305 blocks at 26-bit boundaries within 32-bit words, and/// Panics if `src.len() < 64`.from_par_blocksfrom_loaded_blocks/// The four blocks must be in the following 32-bit word layout:///      [b33, b32, b31, b30, b23, b22, b21, b20]///      [b13, b12, b11, b10, b03, b02, b01, b00]Unreduced4x130/// The unreduced output of an Aligned4x130 multiplication./// Returns the unreduced sum of the four 130-bit integers.IntegerTag/// Computes x + k mod 2^128//! AVX2 helpers for implementing Poly1305 using 26-bit limbs./// Four Poly1305 blocks (64-bytes)r4cached_blocksnum_cached_blockspartial_blockcompute_par_blocks/// Process four Poly1305 blocks at once.process_blocksblocks_needed_to_align//! AVX2 implementation of the Poly1305 state machine.// The State struct and its logic was originally derived from Goll and Gueron's AVX2 C// code://     [Vectorization of Poly1305 message authentication code](https://ieeexplore.ieee.org/document/7113463)// which was sourced from Bhattacharyya and Sarkar's modified variant://     [Improved SIMD Implementation of Poly1305](https://eprint.iacr.org/2019/842)//     https://github.com/Sreyosi/Improved-SIMD-Implementation-of-Poly1305// The logic has been extensively rewritten and documented, and several bugs in the// original C code were fixed.// Note that State only implements the original Goll-Gueron algorithm, not the// optimisations provided by Bhattacharyya and Sarkar. The latter require the message// length to be known, which is incompatible with the streaming API of UniversalHash.finalize_mut//! Software implementation of the Poly1305 state machine.// This code originates from the rust-crypto project:// <https://github.com/DaGenix/rust-crypto>// ...and was originally a port of Andrew Moons poly1305-donna// https://github.com/floodyberry/poly1305-donna//! Poly1305 backendsfuzz_avx2/// Helper function for fuzzing the AVX2 backend.avx2_fuzzer_test_casecrash_0crash_1crash_2crash_3crash_4crash_5crash_6crash_7crash_8KEY_SIZE/// Size of a Poly1305 key/// Size of the blocks Poly1305 acts upon/// Poly1305 keys (32-bytes)/// Poly1305 blocks (16-bytes)/// Poly1305 tags (16-bytes)/// The Poly1305 universal hash function./// Note that Poly1305 is not a traditional MAC and is single-use only/// (a.k.a. "one-time authenticator")./// For this reason it doesn't impl the `crypto_mac::Mac` trait./// Initialize Poly1305 with the given key/// Get the hashed outputcompute_unpadded/// Compute unpadded Poly1305 for the given input data./// The main use case for this is XSalsa20Poly1305.//! The Poly1305 universal hash function and message authentication code.//! Poly1305 is a universal hash function suitable for use as a one-time//! authenticator and, when combined with a cipher, a message authentication//! code (MAC).//! It takes a 32-byte one-time key and a message and produces a 16-byte tag,//! which can be used to authenticate the message.//! Poly1305 is primarily notable for its use in the [`ChaCha20Poly1305`] and//! [`XSalsa20Poly1305`] authenticated encryption algorithms.//! Rust **1.56** or higher.//! Minimum supported Rust version may be changed in the future, but such//! changes will be accompanied with a minor version bump.//! # Security Notes//! This crate has received one [security audit by NCC Group][audit], with no//! significant findings. We would like to thank [MobileCoin] for funding the//! audit.//! NOTE: the audit predates the AVX2 backend, which has not yet been audited.//! All implementations contained in the crate are designed to execute in constant//! time, either by relying on hardware intrinsics (e.g. AVX2 on x86/x86_64), or//! using a portable implementation which is only constant time on processors which//! implement constant-time multiplication.//! It is not suitable for use on processors with a variable-time multiplication//! operation (e.g. short circuit on multiply-by-zero / multiply-by-one, such as//! certain 32-bit PowerPC CPUs and some non-ARM microcontrollers).//! [`ChaCha20Poly1305`]: https://docs.rs/chacha20poly1305//! [`XSalsa20Poly1305`]: https://docs.rs/xsalsa20poly1305//! [audit]: https://research.nccgroup.com/2020/02/26/public-report-rustcrypto-aes-gcm-and-chacha20poly1305-implementation-review///! [MobileCoin]: https://mobilecoin.comclmulmul_intrinsics/// **POLYVAL**: GHASH-like universal hash over GF(2^128)./// Initialize POLYVAL with the given `H` field element and initial block/// Initialize POLYVAL with the given `H` field element/// Get POLYVAL result (i.e. computed `S` field element)//! Autodetection for CPU intrinsics, with fallback to the "soft" backend when//! they are unavailable.// `aes` implies PMULLxor4xor5//! Intel `CLMUL`-accelerated implementation for modern x86/x86_64 CPUs//! (i.e. Intel Sandy Bridge-compatible or newer)/// Get POLYVAL output./// POLYVAL carryless multiplication.// TODO(tarcieri): investigate ordering optimizations and fusions e.g.`fuse-crypto-eor`karatsuba1/// Karatsuba decomposition for `x*y`.karatsuba2/// Karatsuba combine.mont_reducepmull/// Multiplies the low bits in `a` and `b`.pmull2/// Multiplies the high bits in `a` and `b`.//! ARMv8 `PMULL`-accelerated implementation of POLYVAL.//! <https://github.com/noloader/AES-Intrinsics/blob/master/clmul-arm.c>//! For more information about PMULL, see://! - <https://developer.arm.com/documentation/100069/0608/A64-SIMD-Vector-Instructions/PMULL--PMULL2--vector->//! - <https://eprint.iacr.org/2015/688.pdf>// TODO(tarcieri): zeroize support// #[cfg(feature = "zeroize")]// impl Drop for Polyval {//     fn drop(&mut self) {//         use zeroize::Zeroize;//         self.h.zeroize();//         self.y.zeroize();U32x4/// GF(2^128) field element input blocks are multiplied by/// Field element representing the computed universal hash/// 4 x `u32` values/// Adds two POLYVAL field elements./// Computes carryless POLYVAL multiplication over GF(2^128) in constant time./// Method described at:/// <https://www.bearssl.org/constanttime.html#ghash-for-gcm>/// POLYVAL multiplication is effectively the little endian equivalent of/// GHASH multiplication, aside from one small detail described here:/// <https://crypto.stackexchange.com/questions/66448/how-does-bearssls-gcm-modular-reduction-work/66462#66462>/// > The product of two bit-reversed 128-bit polynomials yields the/// > bit-reversed result over 255 bits, not 256. The BearSSL code ends up/// > with a 256-bit result in zw[], and that value is shifted by one bit,/// > because of that reversed convention issue. Thus, the code must/// > include a shifting step to put it back where it should/// This shift is unnecessary for POLYVAL and has been removed.bmul32/// Multiplication in GF(2)[X], truncated to the low 32-bits, with “holes”/// (sequences of zeroes) to avoid carry spilling./// When carries do occur, they wind up in a "hole" and are subsequently masked/// out of the result.rev32/// Bit-reverse a 32-bit word in constant time.//! Constant-time software implementation of POLYVAL for 32-bit architectures//! Adapted from BearSSL's `ghash_ctmul32.c`://! <https://bearssl.org/gitweb/?p=BearSSL;a=blob;f=src/hash/ghash_ctmul32.c;hb=4b6046412>//! Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>//! This implementation uses 32-bit multiplications, and only the low//! 32 bits for each multiplication result. This is meant primarily for//! the ARM Cortex M0 and M0+, whose multiplication opcode does not yield//! the upper 32 bits; but it might also be useful on architectures where//! access to the upper 32 bits requires use of specific registers that//! create contention (e.g. on i386, "mul" necessarily outputs the result//! in edx:eax, while "imul" can use any registers but is limited to the//! low 32 bits).//! The implementation trick that is used here is bit-reversing (bit 0//! is swapped with bit 31, bit 1 with bit 30, and so on). In GF(2)[X],//! for all values x and y, we have://! rev32(x) * rev32(y) = rev64(x * y)//! In other words, if we bit-reverse (over 32 bits) the operands, then we//! bit-reverse (over 64 bits) the result.U64x2/// 2 x `u64` valuesbmul64/// Multiplication in GF(2)[X], truncated to the low 64-bits, with “holes”rev64/// Bit-reverse a `u64` in constant time//! Constant-time software implementation of POLYVAL for 64-bit architectures.//! Adapted from BearSSL's `ghash_ctmul64.c`://! <https://bearssl.org/gitweb/?p=BearSSL;a=blob;f=src/hash/ghash_ctmul64.c;hb=4b6046412>//! POLYVAL backendsmulx/// Size of a POLYVAL block in bytes/// Size of a POLYVAL key in bytes/// POLYVAL keys (16-bytes)/// POLYVAL blocks (16-bytes)/// POLYVAL tags (16-bytes)//! **POLYVAL** is a GHASH-like universal hash over GF(2^128) useful for//! implementing [AES-GCM-SIV] or [AES-GCM/GMAC].//! From [RFC 8452 Section 3] which defines POLYVAL for use in AES-GCM-SIV://! > "POLYVAL, like GHASH (the authenticator in AES-GCM; ...), operates in a//! > binary field of size 2^128.  The field is defined by the irreducible//! > polynomial x^128 + x^127 + x^126 + x^121 + 1."//! By multiplying (in the finite field sense) a sequence of 128-bit blocks of//! input data data by a field element `H`, POLYVAL can be used to authenticate//! the message sequence as powers (in the finite field sense) of `H`.//! In the future the minimum supported Rust version may be changed, but it//! be will be accompanied with a minor version bump.//! implementation based on [BearSSL], which is a straightforward and//! compact implementation which uses a clever but simple technique to avoid//! carry-spilling.//! ## ARMv8 intrinsics (`PMULL`, MSRV 1.61+)//! support for using the `PMULL` instructions in ARMv8's Cryptography Extensions//! with the following `RUSTFLAGS`://! --cfg polyval_armv8//! On Linux and macOS when the ARMv8 features are enabled, support for `PMULL`  //! intrinsics is autodetected at runtime. On other platforms the `crypto`//! ## `x86`/`x86_64` intrinsics (`CMLMUL`)//! in order to determine if `CLMUL` is available, and if it is not, it will//! For optimal performance, set `target-cpu` in `RUSTFLAGS` to `sandybridge`//! or newer://! $ RUSTFLAGS="-Ctarget-cpu=sandybridge" cargo bench//! # Relationship to GHASH//! POLYVAL can be thought of as the little endian equivalent of GHASH, which//! affords it a small performance advantage over GHASH when used on little//! endian architectures.//! It has also been designed so it can also be used to compute GHASH and with//! it GMAC, the Message Authentication Code (MAC) used by AES-GCM.//! From [RFC 8452 Appendix A]://! > "GHASH and POLYVAL both operate in GF(2^128), although with different//! > that these irreducible polynomials are the 'reverse' of each other."//! [AES-GCM-SIV]: https://en.wikipedia.org/wiki/AES-GCM-SIV//! [AES-GCM/GMAC]: https://en.wikipedia.org/wiki/Galois/Counter_Mode//! [BearSSL]: https://www.bearssl.org/constanttime.html#ghash-for-gcm//! [RFC 8452 Section 3]: https://tools.ietf.org/html/rfc8452#section-3//! [RFC 8452 Appendix A]: https://tools.ietf.org/html/rfc8452#appendix-A/// The `mulX_POLYVAL()` function as defined in [RFC 8452 Appendix A][1]./// Performs a doubling (a.k.a. "multiply by x") over GF(2^128)./// This is useful for implementing GHASH in terms of POLYVAL./// [1]: https://tools.ietf.org/html/rfc8452#appendix-Arfc8452_vector/// Test vector given in RFC 8452 Appendix A./// NOTE: the vector in the RFC actually contains a typo which has been/// reported (and accepted) as RFC errata, so we use the vector from the/// errata instead:/// <https://www.rfc-editor.org/errata_search.php?rfc=8452>mulx_vectors/// Test against the `MULX_TEST_VECTORS` given below, which cover the full/// size of a POLYVAL field element.MULX_TEST_VECTORS/// `mulX_POLYVAL()` test vectors./// These were generated by this crate when in a known-correct state,/// verified by a GHASH implementation based on a POLYVAL core successfully/// passing the NIST test vectors.//! The `mulX_POLYVAL()` function."version.rs""src/gen/build.rs"needs_target_feature_fallback// HACK: Currently, it seems that the only way to handle unstable target// features on the stable is to parse the `-C target-feature` in RUSTFLAGS.// - #[cfg(target_feature = "unstable_target_feature")] doesn't work on stable.// - CARGO_CFG_TARGET_FEATURE excludes unstable target features on stable.// As mentioned in the [RFC2045], unstable target features are also passed to LLVM// (e.g., https://godbolt.org/z/4rr7rMcfG), so this hack works properly on stable.// [RFC2045]: https://rust-lang.github.io/rfcs/2045-target-feature.html#backend-compilation-optionstarget_feature_fallbacktarget_cpuis_allowed_feature// Adapted from https://github.com/crossbeam-rs/crossbeam/blob/crossbeam-utils-0.8.14/build-common.rs.// str::strip_prefix requires Rust 1.45// str::strip_suffix requires Rust 1.45// https://github.com/rust-lang/rust-clippy/issues/12044cfg_has_atomic_8cfg_no_atomic_8cfg_has_atomic_16cfg_no_atomic_16atomic_8_16_macroscfg_has_atomic_32cfg_no_atomic_32atomic_32_macroscfg_has_atomic_64cfg_no_atomic_64atomic_64_macroscfg_has_atomic_128cfg_no_atomic_128atomic_128_macroscfg_has_atomic_cascfg_no_atomic_cascfg_has_atomic_cas_or_amo32cfg_has_atomic_cas_or_amo8atomic_cas_macroscfg_no_atomic_cas_or_amo32cfg_no_atomic_cas_or_amo8_Atomic8_Atomic16_Atomic32_Atomic64_Atomic128cfg_has_atomic_ptr_AtomicPtrcfg_no_atomic_ptr__AtomicPtr// Check that all cfg_ macros work.NO_ATOMIC_CAS// Note: This is the list as of nightly-2022-02-10. We don't refer to this in// nightly-2022-02-11+ because feature(cfg_target_has_atomic) stabilized.NO_ATOMIC_64cfg_has_fast_atomic_64cfg_no_fast_atomic_64fast_atomic_64_macros// Some 64-bit architectures have ABI with 32-bit pointer width (e.g., x86_64 X32 ABI,// AArch64 ILP32 ABI, MIPS64 N32 ABI). On those targets, AtomicU64 is available// and fast, so use it to implement normal sequence lock.// See ptr_reg macro for the reason why all known 64-bit architectures are listed.// This file is @generated by target_spec.sh."../detect/auxv.rs"// On musl with static linking, it seems that getauxval is not always available.// See detect/auxv.rs for more."../detect/aarch64_aa64reg.rs""../detect/aarch64_illumos.rs"// TODO(aarch64-illumos): currently disabled by default"../detect/aarch64_fuchsia.rs""../detect/aarch64_windows.rs"detect_aa64reg// test only"../detect/aarch64_apple.rs"detect_appledetect_auxvdebug_assert_lsedebug_assert_lse2debug_assert_lse128debug_assert_rcpc3start_lse// Refs: https://developer.arm.com/documentation/100067/0611/armclang-Integrated-Assembler/AArch32-Target-selection-directives// This is similar to #[target_feature(enable = "lse")], except that there are// no compiler guarantees regarding (un)inlining, and the scope is within an asm// block rather than a function. We use this directive because #[target_feature(enable = "lse")]// is unstable on pre-1.61 rustc and incompatible with rustc_codegen_cranelift:// https://github.com/rust-lang/rustc_codegen_cranelift/issues/1400#issuecomment-1774599775// The .arch_extension directive in asm! is effective until the end of the assembly block and// is not propagated to subsequent code, so the end_lse macro is unneeded.// https://godbolt.org/z/o6EPndP94// https://github.com/torvalds/linux/commit/e0d5896bd356cd577f9710a02d7a474cdf58426b// https://github.com/torvalds/linux/commit/dd1f6308b28edf0452dd5dc7877992903ec61e69// (It seems GCC effectively ignores this directive and always allow FEAT_LSE instructions: https://godbolt.org/z/W9W6rensG)// Note that the .arch_extension directive in global_asm!/naked_asm! which are// not used in this crate has different behavior: https://github.com/rust-lang/rust/pull/137720#discussion_r1973608259// The .arch directive has a similar effect, but we don't use it due to the following issue:// Note: If FEAT_LSE is not available at compile-time, we must guarantee that// the function that uses it is not inlined into a function where it is not// clear whether FEAT_LSE is available. Otherwise, (even if we checked whether// FEAT_LSE is available at run-time) optimizations that reorder its// instructions across the if condition might introduce undefined behavior.// (see also https://rust-lang.github.io/rfcs/2045-target-feature.html#safely-inlining-target_feature-functions-on-more-contexts)// However, our code uses the ifunc helper macro that works with function pointers,// so we don't have to worry about this unless calling without helper macro.start_lse128start_rcpc3select_le_or_beatomic_rmwatomic_rmw_inst_atomic_load_ldp// if compile_time(FEAT_LSE2) => ldp:// cfg guarantee that the CPU supports FEAT_LSE2.// If CPU supports FEAT_LSE2, LDP/LDIAPP is single-copy atomic reads,// otherwise it is two single-copy atomic reads.// Refs: B2.2.1 of the Arm Architecture Reference Manual Armv8, for Armv8-A architecture profile_atomic_load_ldiapp_atomic_load_casp// Do not use _atomic_compare_exchange_casp because it needs extra MOV to implement load._atomic_load_ldxp_stxp_atomic_store_stp// if compile_time(FEAT_LSE2) => stp:// If CPU supports FEAT_LSE2, STP/STILP is single-copy atomic writes,// otherwise it is two single-copy atomic writes._atomic_store_stilp_atomic_store_ldxp_stxp// Do not use _atomic_swap_ldxp_stxp because it needs extra registers to implement store._atomic_compare_exchange_casp_atomic_compare_exchange_ldxp_stxp// casp is always strong, and ldxp requires a corresponding (succeed) stxp for// its atomicity (see code comment in _atomic_compare_exchange_ldxp_stxp).// (i.e., AArch64 doesn't have 128-bit weak CAS)_atomic_swap_casp// If FEAT_LSE is available at compile-time and portable_atomic_ll_sc_rmw cfg is not set,// we use CAS-based atomic RMW._atomic_swap_ldxp_stxp_atomic_swap_swpp// Do not use atomic_rmw_cas_3 because it needs extra MOV to implement swap.// Do not use atomic_rmw_ll_sc_3 because it needs extra MOV to implement swap.atomic_rmw_ll_sc_3/// Atomic RMW by LL/SC loop (3 arguments)/// `unsafe fn(dst: *mut u128, val: u128, order: Ordering) -> u128;`/// `$op` can use the following registers:/// - val_lo/val_hi pair: val argument (read-only for `$op`)/// - prev_lo/prev_hi pair: previous value loaded by ll (read-only for `$op`)/// - new_lo/new_hi pair: new value that will be stored by scatomic_rmw_cas_3/// Atomic RMW by CAS loop (3 arguments)/// - x6/x7 pair: previous value loaded (read-only for `$op`)/// - x4/x5 pair: new value that will be storedatomic_rmw_ll_sc_2/// Atomic RMW by LL/SC loop (2 arguments)/// `unsafe fn(dst: *mut u128, order: Ordering) -> u128;`atomic_rmw_cas_2/// Atomic RMW by CAS loop (2 arguments)// Do not use `preserves_flags` because ADDS modifies the condition flags.// Do not use `preserves_flags` because SUBS modifies the condition flags.// Do not use `preserves_flags` because NEGS modifies the condition flags.// Do not use `preserves_flags` because CMP and SBCS modify the condition flags.IS_ALWAYS_LOCK_FREEatomic128test_atomic_intstress_test// load/store/swap implementation is not affected by signedness, so it is// enough to test only unsigned types./*
128-bit atomic implementation on AArch64.

This architecture provides the following 128-bit atomic instructions:

- LDXP/STXP: LL/SC (Armv8.0 baseline)
- CASP: CAS (added as Armv8.1 FEAT_LSE (optional from Armv8.0, mandatory from Armv8.1))
- LDP/STP: load/store (if Armv8.4 FEAT_LSE2 (optional from Armv8.2, mandatory from Armv8.4) is available)
- LDIAPP/STILP: acquire-load/release-store (added as Armv8.9 FEAT_LRCPC3 (optional from Armv8.2) (if FEAT_LSE2 is also available))
- LDCLRP/LDSETP/SWPP: fetch-and-{clear,or},swap (added as Armv9.4 FEAT_LSE128 (optional from Armv9.3))

This module supports all of these instructions and attempts to select the best
one based on compile-time and run-time information about available CPU features
and platforms. For example:

- If outline-atomics is not enabled and FEAT_LSE is not available at
  compile-time, we use LDXP/STXP loop.
- If outline-atomics is enabled and FEAT_LSE is not available at
  compile-time, we use CASP for CAS if FEAT_LSE is available
  at run-time, otherwise, use LDXP/STXP loop.
- If FEAT_LSE is available at compile-time, we use CASP for load/store/CAS/RMW.
  However, when portable_atomic_ll_sc_rmw cfg is set, use LDXP/STXP loop instead of CASP
  loop for RMW (by default, it is set on Apple hardware where CASP is slow;
  see build script for details).
- If outline-atomics is enabled and FEAT_LSE2 is not available at compile-time,
  we use LDP/STP (and also LDIAPP/STILP/SWPP if FEAT_LRCPC3/FEAT_LSE128 is
  available) for load/store if FEAT_LSE2 is available at run-time, otherwise,
  use LDXP/STXP or CASP depending on whether FEAT_LSE is available.
- If FEAT_LSE2 is available at compile-time, we use LDP/STP for load/store.
- If FEAT_LSE128 is available at compile-time, we use LDCLRP/LDSETP/SWPP for fetch_and/fetch_or/swap/{release,seqcst}-store.
- If FEAT_LSE2 and FEAT_LRCPC3 are available at compile-time, we use LDIAPP/STILP for acquire-load/release-store.

See each "Instruction selection flow for ..." comment in this file for the exact
instruction selection per operation.

Note: FEAT_LSE2 doesn't imply FEAT_LSE. FEAT_LSE128 implies FEAT_LSE but not FEAT_LSE2.

Note that we do not separate LL and SC into separate functions, but handle
them within a single asm block. This is because it is theoretically possible
for the compiler to insert operations that might clear the reservation between
LL and SC. Considering the type of operations we are providing and the fact
that [progress64](https://github.com/ARM-software/progress64) uses such code,
this is probably not a problem for AArch64, but it seems that AArch64 doesn't
guarantee it and hexagon is the only architecture with hardware guarantees
that such code works. See also:

- https://yarchive.net/comp/linux/cmpxchg_ll_sc_portability.html
- https://lists.llvm.org/pipermail/llvm-dev/2016-May/099490.html
- https://lists.llvm.org/pipermail/llvm-dev/2018-June/123993.html

Also, even when using a CAS loop to implement atomic RMW, include the loop itself
in the asm block because it is more efficient for some codegen backends.
https://github.com/rust-lang/compiler-builtins/issues/339#issuecomment-1191260474

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use intrinsics.rs instead.

Refs:
- Arm A-profile A64 Instruction Set Architecture
  https://developer.arm.com/documentation/ddi0602/2024-12
- Arm Compiler armasm User Guide
  https://developer.arm.com/documentation/dui0801/latest
- Arm Architecture Reference Manual for A-profile architecture
  https://developer.arm.com/documentation/ddi0487/latest (PDF)
- atomic-maybe-uninit https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- aarch64 https://godbolt.org/z/aEWe7zhMh
- aarch64 msvc https://godbolt.org/z/Phq7M6MPs
- aarch64 (+lse) https://godbolt.org/z/9Go3dT6sW
- aarch64 msvc (+lse) https://godbolt.org/z/vGvc6bTMT
- aarch64 (+lse,+lse2) https://godbolt.org/z/KddzqsM9o
- aarch64 (+lse,+lse2,+rcpc3) https://godbolt.org/z/sePheahxh
- aarch64 (+lse2,+lse128) https://godbolt.org/z/WPqM9M1r3
- aarch64 (+lse2,+lse128,+rcpc3) https://godbolt.org/z/5Mf8dc88Y
*/// -----------------------------------------------------------------------------// load/*

Instruction selection flow for load:
- if compile_time(FEAT_LSE2) => ldp:
  - if compile_time(FEAT_LRCPC3) && order != relaxed => ldiapp
  - else => ldp
- if platform_supports_detection_of(FEAT_LSE2):
  - if detect(FEAT_LSE2) && detect(FEAT_LRCPC3) && order != relaxed => lse2_rcpc3 (ldiapp)
  - if detect(FEAT_LSE2) => lse2 (ldp)
- else => no_lse2:
  - if compile_time(FEAT_LSE) => casp
  - else => ldxp_stxp

Note:
- If FEAT_LSE2 is available at compile-time, we don't do run-time detection of
  FEAT_LRCPC3 at this time, since FEAT_LRCPC3 is not yet available for most CPUs.
  (macOS that doesn't have any FEAT_LRCPC3-enabled CPUs as of M4 is only a platform
  that currently enables FEAT_LSE2 at compile-time by default.)
- If FEAT_LSE2 is not available at compile-time, we want to do run-time detection
  of FEAT_LSE2, so we do run-time detection of FEAT_LRCPC3 at the same time.
- We don't do run-time detection of FEAT_LSE for load at this time, but since
  load by CAS is wait-free, it would probably make sense to do run-time detection. (TODO)

*/// store/*

Instruction selection flow for store:
- if compile_time(FEAT_LSE2) => stp:
  - if compile_time(FEAT_LSE128) && order == seqcst => swpp
  - if compile_time(FEAT_LRCPC3) && order != relaxed => stilp
  - if compile_time(FEAT_LSE128) && order != relaxed => swpp
  - else => stp
- if platform_supports_detection_of(FEAT_LSE2):
  - if detect(FEAT_LSE2) && detect(FEAT_LSE128) && order == seqcst => lse128 (swpp)
  - if detect(FEAT_LSE2) && detect(FEAT_LRCPC3) && order != relaxed => lse2_rcpc3 (stilp)
  - if detect(FEAT_LSE2) && detect(FEAT_LSE128) && order != relaxed => lse128 (swpp)
  - if detect(FEAT_LSE2) => lse2 (stp)
- else => no_lse2:
  - if compile_time(FEAT_LSE) && not(ll_sc_rmw) => casp
  - else => ldxp_stxp

Note:
- If FEAT_LSE2 is available at compile-time, we don't do run-time detection of
  FEAT_LRCPC3/FEAT_LSE128 at this time, since FEAT_LRCPC3/FEAT_LSE128 is not yet available for most CPUs.
  (macOS that doesn't have any FEAT_LRCPC3/FEAT_LSE128-enabled CPUs as of M4 is only a platform
  that currently enables FEAT_LSE2 at compile-time by default.)
- If FEAT_LSE2 is not available at compile-time, we want to do run-time detection
  of FEAT_LSE2, so we do run-time detection of FEAT_LRCPC3/FEAT_LSE128 at the same time.
- We don't do run-time detection of FEAT_LSE for store at this time.

*/// compare_exchange/*

Instruction selection flow for compare_exchange:
- if compile_time(FEAT_LSE) => casp
- if platform_supports_detection_of(FEAT_LSE):
  - if detect(FEAT_LSE) => casp
- else => ldxp_stxp

*/// RMW/*

Instruction selection flow for swap/fetch_and/fetch_or:
- if compile_time(FEAT_LSE128) => swpp/ldclrp/ldsetp
- if compile_time(FEAT_LSE) && not(ll_sc_rmw) => casp
- else => ldxp_stxp

Instruction selection flow for other RMWs:
- if compile_time(FEAT_LSE) && not(ll_sc_rmw) => casp
- else => ldxp_stxp

Note:
- We don't do run-time detection of FEAT_LSE128 at this time, because
  FEAT_LSE128 is not yet available for most CPUs, but since
  swpp/ldclrp/ldsetp is wait-free, it would make sense to do run-time
  detection in the future. (TODO)
- We don't do run-time detection of FEAT_LSE for store at this time.

*/"../fallback/outline_atomics.rs"// we only use compare_exchange."../detect/x86_64.rs"// even without panics, this helps for Miri backtracesatomic_updateatomic_rmw_by_atomic_update// On x86_64, we use core::arch::x86_64::cmpxchg16b instead of core::intrinsics.// - On s390x, old LLVM (pre-18) generates libcalls for operations other than load/store/cmpxchg (see also module-level comment).// On powerpc64, LLVM doesn't support 128-bit atomic min/max (see also module-level comment).atomic_nandatomic_notatomic_neg/*
128-bit atomic implementation without inline assembly.

Adapted from https://github.com/rust-lang/rust/blob/1.84.0/library/core/src/sync/atomic.rs.

Note: This module is currently only enabled on Miri and ThreadSanitizer which
do not support inline assembly.

This uses `core::arch::x86_64::cmpxchg16b` on x86_64 and
`core::intrinsics::atomic_*` on aarch64, powerpc64, and s390x.

See README.md of this directory for performance comparison with the
implementation with inline assembly.

Note:
- This currently needs Rust 1.70 on x86_64, otherwise nightly compilers.
- On powerpc64, this requires LLVM 15+ and quadword-atomics target feature:
  https://github.com/llvm/llvm-project/commit/549e118e93c666914a1045fde38a2cac33e1e445
- On s390x, old LLVM (pre-18) generates libcalls for operations other than load/store/cmpxchg:
  https://github.com/llvm/llvm-project/commit/c568927f3e2e7d9804ea74ecbf11c16c014ddcbc
- On aarch64 big-endian, LLVM (as of 17) generates broken code. (wrong result in stress test)
  (on cfg(miri)/cfg(sanitize) it may be fine though)
- On powerpc64, LLVM (as of 17) doesn't support 128-bit atomic min/max:
  https://github.com/llvm/llvm-project/issues/68390
- On powerpc64le, LLVM (as of 17) generates broken code. (wrong result from fetch_add)
- On riscv64, LLVM does not automatically use 128-bit atomic instructions even if zacas feature is
  enabled, because doing it changes the ABI. (If the ability to do that is provided by LLVM in the
  future, it should probably be controlled by another ABI feature similar to forced-atomics.)
*/// also used by intrinsics.rs// x86_64// Use intrinsics.rs on Miri and Sanitizer that do not support inline assembly./*
128-bit atomic implementations on 64-bit architectures

See README.md for details.
*/"../detect/powerpc64_aix.rs"// SIGTRAP on LLVM 19// TODO(aix): currently disabled by defaultdebug_assert_pwr8start_pwr8// Refs: https://www.ibm.com/docs/en/aix/7.3?topic=ops-machine-pseudo-op// This is similar to #[target_feature(enable = "quadword-atomics")], except that there are// block rather than a function. We use this directive because #[target_feature(enable = "quadword-atomics")]// is unstable and unavailable on old nightly and incompatible with rustc_codegen_cranelift:// Note: start_pwr8 and end_pwr8 must be used in pairs.// Note: If power8 instructions are not available at compile-time, we must guarantee that// clear whether power8 instructions are available. Otherwise, (even if we checked whether// power8 instructions are available at run-time) optimizations that reorder itsend_pwr8atomic_castest_cr0_eq// Extracts and checks the EQ bit of cr0.atomic_load_pwr8// If quadword-atomics is available at compile-time, we can always use pwr8_fn.// Otherwise, we need to do run-time detection and can use pwr8_fn only if quadword-atomics is available.atomic_store_pwr8atomic_compare_exchange_pwr8// Always use strong CAS for outline-atomics.atomic_compare_exchange_weak_pwr8atomic_swap_pwr8// Do not use atomic_rmw_ll_sc_3 because it needs extra MR to implement swap./// $op can use the following registers:/// - val_hi/val_lo pair: val argument (read-only for `$op`)/// - r6/r7 pair: previous value loaded by ll (read-only for `$op`)/// - r8/r9 pair: new value that will be stored by scatomic_not_pwr8// LLVM 15 miscompiles subfic.select_atomic_rmw/*
128-bit atomic implementation on PowerPC64.

This architecture provides the following 128-bit atomic instructions:

- lq/stq: load/store (ISA 2.07 or later, included in the Linux Compliancy subset and AIX Compliancy subset)
- lqarx/stqcx.: LL/SC (ISA 2.07 or later, included in the Linux Compliancy subset and AIX Compliancy subset)
- plq/pstq: load/store (ISA 3.1 or later, included in the Linux Compliancy subset and AIX Compliancy subset)

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#powerpc

Note that we do not separate LL and SC into separate functions, but handle
them within a single asm block. This is because it is theoretically possible
for the compiler to insert operations that might clear the reservation between
LL and SC. See aarch64.rs for details.

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use intrinsics.rs instead.

Refs:
- Power ISA
  https://openpowerfoundation.org/specifications/isa
- AIX Assembler language reference
  https://www.ibm.com/docs/en/aix/7.3?topic=aix-assembler-language-reference
- atomic-maybe-uninit
  https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- powerpc64 (pwr8) https://godbolt.org/z/TjKsPbWc6
- powerpc64le https://godbolt.org/z/5WqPGhb3Y
*/"../detect/riscv_linux.rs"debug_assert_zacasstart_zacas// `.option arch, +zacas` directive requires LLVM 20, so we use .4byte directive for old LLVM.// Note that `.insn <value>` directive requires LLVM 19.// https://github.com/llvm/llvm-project/commit/2a086dce691e3cc34a2fc27f4fb255bb2cbbfac9// https://github.com/riscv-non-isa/riscv-asm-manual/blob/ad0de8c004e29c9a7ac33cfd054f4d4f9392f2fb/src/asm-manual.adoc#archend_zacasatomic_rmw_amocas_orderatomic_rmw_amocas_order_insnatomic_load_zacas// If zacas is available at compile-time, we can always use zacas_fn.// Otherwise, we need to do run-time detection and can use zacas_fn only if zacas is available.atomic_compare_exchange_zacas// amocas is always strong.byte_wise_atomic_load// 128-bit atomic load by two 64-bit atomic loads./*
128-bit atomic implementation on riscv64.

This architecture provides the following 128-bit atomic instructions:

- amocas.q: CAS (Zacas extension)

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#risc-v

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use fallback implementation instead.

Refs:
- RISC-V Instruction Set Manual
  "Zacas" Extension for Atomic Compare-and-Swap (CAS) Instructions
  https://github.com/riscv/riscv-isa-manual/blob/riscv-isa-release-8b9dc50-2024-08-30/src/zacas.adoc
- RISC-V Atomics ABI Specification
  https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/draft-20240829-13bfa9f54634cb60d86b9b333e109f077805b4b3/riscv-atomic.adoc

Generated asm:
- riscv64gc (+zacas) https://godbolt.org/z/c59a9fs63
*/// bcr 14,0 requires fast-BCR-serialization facility added in arch9 (z196).distinct_op// Use distinct operands on z196 or later, otherwise split to lgr and $op.select_op// Use selgr$cond on z15 or later, otherwise split to locgr$cond and $op.extract_cc// Extracts and checks condition code.// cdsg is always strong./// - r0/r1 pair: previous value loaded (read-only for `$op`)/// - r12/r13 pair: new value that will be stored// We could use atomic_update here, but using an inline assembly allows omitting// the comparison of results and the storing/comparing of condition flags.// Use nngrk on z15 or later.// We use atomic_update for atomic min/max on pre-z196 because// z10 doesn't seem to have a good way to implement 128-bit min/max.// loc{,g}r requires z196 or later.// https://godbolt.org/z/EqoMEP8b3/*
128-bit atomic implementation on s390x.

This architecture provides the following 128-bit atomic instructions:

- LPQ/STPQ: load/store (arch1 or later, i.e., baseline)
- CDSG: CAS (arch1 or later, i.e., baseline)

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#s390x

LLVM's minimal supported architecture level is arch8 (z10):
https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/llvm/lib/Target/SystemZ/SystemZProcessors.td#L16-L17
This does not appear to have changed since the current s390x backend was added in LLVM 3.3:
https://github.com/llvm/llvm-project/commit/5f613dfd1f7edb0ae95d521b7107b582d9df5103#diff-cbaef692b3958312e80fd5507a7e2aff071f1acb086f10e8a96bc06a7bb289db

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use intrinsics.rs instead.

Refs:
- z/Architecture Principles of Operation, Fourteenth Edition (SA22-7832-13)
  https://publibfp.dhe.ibm.com/epubs/pdf/a227832d.pdf
- atomic-maybe-uninit
  https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- s390x https://godbolt.org/z/oPxYYEvPG
- s390x (z196) https://godbolt.org/z/M69KrKT7Y
- s390x (z15,-vector) https://godbolt.org/z/Wec8b3ada
- s390x (z15) https://godbolt.org/z/KxWcrbfYh
*/debug_assert_cmpxchg16b// Asserts that the function is called in the correct context.debug_assert_vmovdqa_atomicptr_modifiercmpxchg16b// Unlike AArch64 and RISC-V, x86's assembler doesn't check instruction// requirements for the currently enabled target features. In the first place,// there is no option in the x86 assembly for such case, like Arm .arch_extension,// RISC-V .option arch, PowerPC .machine, etc.// However, we set target_feature(enable) when available (Rust 1.69+) in case a// new codegen backend is added that checks for it in the future, or an option// is added to the assembler to check for it.atomic_load_vmovdqa// VMOVDQA is atomic on Intel, AMD, and Zhaoxin CPUs with AVX.// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104688 for details.// Refs: https://www.felixcloutier.com/x86/movdqa:vmovdqa32:vmovdqa64// Use cfg(target_feature = "sse") here -- SSE is included in the x86_64// baseline and is always available, but the SSE target feature is disabled for// use cases such as kernels and firmware that should not use vector registers.// So, do not use vector registers unless SSE target feature is enabled.// See also https://github.com/rust-lang/rust/blob/1.84.0/src/doc/rustc/src/platform-support/x86_64-unknown-none.md.atomic_store_vmovdqaload_store_detectatomic_load_cmpxchg16b// See cmpxchg16b() for target_feature(enable).atomic_store_cmpxchg16b// cmpxchg16b is always strong.atomic_swap_cmpxchg16b/// - rsi/r8 pair: val argument (read-only for `$op`)/// - rax/rdx pair: previous value loaded (read-only for `$op`)/// - rbx/rcx pair: new value that will be stored// We could use CAS loop by atomic_compare_exchange here, but using an inline assembly allows// omitting the storing/comparing of condition flags and reducing uses of xchg/mov to handle rbx.// omitting the storing of condition flags and avoid use of xchg to handle rbx.atomic_add_cmpxchg16batomic_sub_cmpxchg16batomic_and_cmpxchg16batomic_nand_cmpxchg16batomic_or_cmpxchg16batomic_xor_cmpxchg16batomic_not_cmpxchg16batomic_neg_cmpxchg16batomic_max_cmpxchg16batomic_umax_cmpxchg16batomic_min_cmpxchg16batomic_umin_cmpxchg16bAtomicI128impl_default_no_fetch_opsimpl_default_bit_optsbit_clearbit_togglefetch_notfetch_negAtomicU128stress_test_load_store/*
128-bit atomic implementation on x86_64.

This architecture provides the following 128-bit atomic instructions:

- CMPXCHG16B: CAS (CMPXCHG16B)
- VMOVDQA: load/store (Intel, AMD, or Zhaoxin CPU with AVX)

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use intrinsics.rs instead.

Refs:
- x86 and amd64 instruction reference https://www.felixcloutier.com/x86
- atomic-maybe-uninit https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- x86_64 (+cmpxchg16b) https://godbolt.org/z/rfs1jxd51
*/// TODO: use core::arch::x86_64::cmpxchg16b where available and efficient than asmKUSER_HELPER_VERSION// https://github.com/torvalds/linux/blob/v6.13/Documentation/arch/arm/kernel_user_helpers.rstKUSER_CMPXCHG64// __kuser_helper_version >= 5 (kernel version 3.1+)__kuser_helper_versionhas_kuser_cmpxchg64__kuser_cmpxchg64// 64-bit atomic load by two 32-bit atomic loads.select_atomicatomic64kuser_helper_version/*
64-bit atomic implementation using kuser_cmpxchg64 on pre-v6 Arm Linux/Android.

Refs:
- https://github.com/torvalds/linux/blob/v6.13/Documentation/arch/arm/kernel_user_helpers.rst
- https://github.com/rust-lang/compiler-builtins/blob/compiler_builtins-v0.1.124/src/arm_linux.rs

Note: __kuser_cmpxchg64 is always SeqCst.
https://github.com/torvalds/linux/blob/v6.13/arch/arm/kernel/entry-armv.S#L700-L707

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use fallback implementation instead.
*/// TODO: Since Rust 1.64, the Linux kernel requirement for Rust when using std is 3.2+, so it should// be possible to omit the dynamic kernel version check if the std feature is enabled on Rust 1.64+.// https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.htmlarm_linux// pre-v6 Arm Linux// Miri and Sanitizer do not support inline assembly.// riscv32/*
64-bit atomic implementations on 32-bit architectures

See README.md for details.
*//*
64-bit atomic implementation on riscv32.

This architecture provides the following 64-bit atomic instructions:

- amocas.d: CAS (Zacas extension)

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#risc-v

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use fallback implementation instead.

Refs:
- RISC-V Instruction Set Manual
  "Zacas" Extension for Atomic Compare-and-Swap (CAS) Instructions
  https://github.com/riscv/riscv-isa-manual/blob/riscv-isa-release-8b9dc50-2024-08-30/src/zacas.adoc
- RISC-V Atomics ABI Specification
  https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/draft-20240829-13bfa9f54634cb60d86b9b333e109f077805b4b3/riscv-atomic.adoc

Generated asm:
- riscv32imac (+zacas) https://godbolt.org/z/9bTdfhKre
*/// TODO: merge duplicated code with atomic128/riscv64.rsatomic8/*
Atomic load/store implementation on AVR.

Operations not supported here are provided by disabling interrupts.
See also src/imp/interrupt/avr.rs.

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#avr

Note: Ordering is always SeqCst.

Refs:
- AVR® Instruction Set Manual, Rev. DS40002198B
  https://ww1.microchip.com/downloads/en/DeviceDoc/AVR-InstructionSet-Manual-DS40002198.pdf
- atomic-maybe-uninit
  https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- avr https://godbolt.org/z/j49rYbj4d
*/NotRefUnwindSafe// core::panic::RefUnwindSafe is only available on Rust 1.56+, so on pre-1.56// Rust, we implement RefUnwindSafe when "std" feature is enabled.// However, on pre-1.56 Rust, the standard library's atomic types implement// RefUnwindSafe when "linked to std", and that's behavior that our other atomic// implementations can't emulate, so use PhantomData<NotRefUnwindSafe> to match// conditions where our other atomic implementations implement RefUnwindSafe.// If we do not do this, for example, downstream that is only tested on x86_64// may incorrectly assume that AtomicU64 always implements RefUnwindSafe even on// older rustc, and may be broken on platforms where std AtomicU64 is not available.// SAFETY: this is a marker type and we'll never access the value._not_ref_unwind_safe// Prevent RefUnwindSafe from being propagated from the std atomic type. See NotRefUnwindSafe for more.atomic_intfetch_update_/*
Wrap the standard library's atomic types in newtype.

This is not a reexport, because we want to backport changes like
https://github.com/rust-lang/rust/pull/98383 to old compilers.
*/aa64isar0aa64isar1aa64isar3aa64mmfr2AA64Reg_detectCpuInfoaa64reg// This module is test-only. See parent module docs for details.c_size_tsys_structsys_fn// libc requires Rust 1.63sysctl_cpu_id// NetBSD doesn't trap the mrs instruction, but exposes the system registers through sysctl.// https://github.com/NetBSD/src/commit/0e9d25528729f7fea53e78275d1bc5039dfe8ffb// https://github.com/golang/sys/commit/ef9fd89ba245e184bdd308f7f2b4f3c551fa5b0fsys_const// sysctl returns an unsupported error if operation is not supported,// so we can safely use this function on older versions of OpenBSD.sysctl64// OpenBSD doesn't trap the mrs instruction, but exposes the system registers through sysctl.// https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8// https://github.com/golang/go/commit/cd54ef1f61945459486e9eea2f016d99ef1da925test_aa64regtest_alternative/*
Run-time CPU feature detection on AArch64 Linux/Android/FreeBSD/NetBSD/OpenBSD by parsing system registers.

As of nightly-2024-09-07, is_aarch64_feature_detected doesn't support run-time detection on NetBSD.
https://github.com/rust-lang/stdarch/blob/d9466edb4c53cece8686ee6e17b028436ddf4151/crates/std_detect/src/detect/mod.rs
Run-time detection on OpenBSD by is_aarch64_feature_detected is supported on Rust 1.70+.
https://github.com/rust-lang/stdarch/pull/1374

Refs:
- https://developer.arm.com/documentation/ddi0601/2024-12/AArch64-Registers
- https://github.com/torvalds/linux/blob/v6.13/Documentation/arch/arm64/cpu-feature-registers.rst
- https://github.com/rust-lang/stdarch/blob/a0c30f3e3c75adcd6ee7efc94014ebcead61c507/crates/std_detect/src/detect/os/aarch64.rs

Supported platforms:
- Linux 4.11+ (emulate mrs instruction)
  https://github.com/torvalds/linux/commit/77c97b4ee21290f5f083173d957843b615abbff2
- FreeBSD 12.0+ (emulate mrs instruction)
  https://github.com/freebsd/freebsd-src/commit/398810619cb32abf349f8de23f29510b2ee0839b
- NetBSD 9.0+ (through sysctl/sysctlbyname)
  https://github.com/NetBSD/src/commit/0e9d25528729f7fea53e78275d1bc5039dfe8ffb
  sysctl/sysctlbyname returns an unsupported error if operation is not supported,
  so we can safely use this on older versions.
- OpenBSD 7.1+ (through sysctl)
  https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8
  sysctl returns an unsupported error if operation is not supported,
  so we can safely use this on older versions.

For now, this module is only used on NetBSD/OpenBSD.

On Linux/Android/FreeBSD, we use auxv.rs and this module is test-only because:
- On Linux/Android, this approach requires a higher kernel version than Rust supports,
  and also does not work with qemu-user (as of 7.2) and Valgrind (as of 3.24).
  (Looking into HWCAP_CPUID in auxvec, it appears that Valgrind is setting it
  to false correctly, but qemu-user is setting it to true.)
  - qemu-user issue seem to be fixed as of 9.2.
- On FreeBSD, this approach does not work on FreeBSD 12 on QEMU (confirmed on
  FreeBSD 12.{2,3,4}), and we got SIGILL (worked on FreeBSD 13 and 14).
*/sysctlbyname32/*
Run-time CPU feature detection on AArch64 Apple targets by using sysctlbyname.

On macOS, this module is currently only enabled on tests because there are no
instructions that were not available on the M1 but are now available on the
latest Apple hardware and this library currently wants to use:

```console
$ comm -23 <(rustc --print cfg --target aarch64-apple-darwin -C target-cpu=apple-m4 | grep -F target_feature) <(rustc --print cfg --target aarch64-apple-darwin | grep -F target_feature)
target_feature="bf16"
target_feature="bti"
target_feature="ecv"
target_feature="i8mm"
target_feature="sme"
target_feature="sme-f64f64"
target_feature="sme-i16i64"
target_feature="sme2"
target_feature="v8.5a"
target_feature="v8.6a"
target_feature="v8.7a"
target_feature="wfxt"
```

Refs: https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics

TODO: non-macOS targets doesn't always supports FEAT_LSE2, but sysctl on them on the App Store is...?
- https://developer.apple.com/forums/thread/9440
- https://nabla-c0d3.github.io/blog/2015/06/16/ios9-security-privacy
- https://github.com/rust-lang/stdarch/pull/1636
*/sys_typezx_system_get_featureszx_status_t// https://fuchsia.dev/reference/syscalls/system_get_features// TODO: use sys_fn!test_fuchsia/*
Run-time CPU feature detection on AArch64 Fuchsia by using zx_system_get_features.

As of nightly-2024-09-07, is_aarch64_feature_detected doesn't support run-time detection on Fuchsia.
https://github.com/rust-lang/stdarch/blob/d9466edb4c53cece8686ee6e17b028436ddf4151/crates/std_detect/src/detect/mod.rs

Refs:
- https://fuchsia.dev/reference/syscalls/system_get_features
- https://github.com/llvm/llvm-project/commit/4e731abc55681751b5d736b613f7720e50eb1ad4
*//*
Run-time CPU feature detection on AArch64 illumos by using getisax.

As of nightly-2024-09-07, is_aarch64_feature_detected doesn't support run-time detection on illumos.
https://github.com/rust-lang/stdarch/blob/d9466edb4c53cece8686ee6e17b028436ddf4151/crates/std_detect/src/detect/mod.rs

Run-time detection on AArch64 illumos is currently disabled by default as experimental
because illumos AArch64 port is experimental and we cannot run tests on the VM or real machine.
*/// windows-sys requires Rust 1.60/*
Run-time CPU feature detection on AArch64 Windows by using IsProcessorFeaturePresent.

Run-time detection of FEAT_LSE on Windows by is_aarch64_feature_detected is supported on Rust 1.70+.
https://github.com/rust-lang/stdarch/pull/1373

Refs: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-isprocessorfeaturepresent
*/GetauxvalTyElfAuxInfoTy// Basically, Linux/FreeBSD/OpenBSD use the same hwcap values.// FreeBSD and OpenBSD usually support a subset of the hwcap values supported by Linux.CpuInfoFlagtest_androidtest_dlsym_getauxvaltest_dlsym_elf_aux_info/*
Run-time CPU feature detection on AArch64/PowerPC64 Linux/Android/FreeBSD/OpenBSD by parsing ELF auxiliary vectors.

Supported platforms:
- Linux 6.4+ (through prctl)
  https://github.com/torvalds/linux/commit/ddc65971bb677aa9f6a4c21f76d3133e106f88eb
  prctl returns an unsupported error if operation is not supported,
  so we can safely use this on older versions.
- glibc 2.16+ (through getauxval)
  https://github.com/bminor/glibc/commit/c7683a6d02f3ed59f5cd119b3e8547f45a15912f
  Always available on:
  - aarch64 (glibc 2.17+ https://github.com/bminor/glibc/blob/glibc-2.17/NEWS#L36)
  - powerpc64 (le) (glibc 2.19+ or RHEL/CentOS's patched glibc 2.17+ https://github.com/bminor/glibc/blob/glibc-2.19/NEWS#L108)
  Not always available on:
  - powerpc64 (be) (glibc 2.3+ https://github.com/bminor/glibc/blob/glibc-2.3/NEWS#L56)
  Since Rust 1.64, std requires glibc 2.17+ https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html
- musl 1.1.0+ (through getauxval)
  https://github.com/bminor/musl/commit/21ada94c4b8c01589367cea300916d7db8461ae7
  Always available on:
  - aarch64 (musl 1.1.7+ https://github.com/bminor/musl/blob/v1.1.7/WHATSNEW#L1422)
  - powerpc64 (musl 1.1.15+ https://github.com/bminor/musl/blob/v1.1.15/WHATSNEW#L1702)
  At least since Rust 1.15, std requires musl 1.1.14+ https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15
  Since Rust 1.18, std requires musl 1.1.16+ https://github.com/rust-lang/rust/pull/41089
  Since Rust 1.23, std requires musl 1.1.17+ https://github.com/rust-lang/rust/pull/45393
  Since Rust 1.25, std requires musl 1.1.18+ https://github.com/rust-lang/rust/pull/47283
  Since Rust 1.29, std requires musl 1.1.19+ https://github.com/rust-lang/rust/pull/52087
  Since Rust 1.31, std requires musl 1.1.20+ https://github.com/rust-lang/rust/pull/54430
  Since Rust 1.37, std requires musl 1.1.22+ https://github.com/rust-lang/rust/pull/61252
  Since Rust 1.46, std requires musl 1.1.24+ https://github.com/rust-lang/rust/pull/73089
  Since Rust 1.71, std requires musl 1.2.3+ https://blog.rust-lang.org/2023/05/09/Updating-musl-targets.html
  OpenHarmony uses a fork of musl 1.2 https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md
- uClibc-ng 1.0.43+ (through getauxval)
  https://github.com/wbx-github/uclibc-ng/commit/d869bb1600942c01a77539128f9ba5b5b55ad647
  Not always available on:
  - aarch64 (uClibc-ng 1.0.22+ https://github.com/wbx-github/uclibc-ng/commit/dba942c80dc2cfa5768a856fff98e22a755fdd27)
  (powerpc64 is not supported https://github.com/wbx-github/uclibc-ng/commit/d4d4f37fda7fa57e57132ff2f0d735ce7cc2178e)
  In L4Re which uses uClibc-ng, a dummy API was added first in 2020 that always returns 0 (https://github.com/kernkonzept/l4re-core/commit/e88fa67198074d3e6b4983c5c8af1538e2089ff3),
  then implemented in 2024 (https://github.com/kernkonzept/l4re-core/commit/3ee2a50dd1b3bc22955e593004990887a0a5b4a3).
  However, getauxval(AT_HWCAP*) always returns 0 (as of 2025-03-20). (see tests/l4re test)
- Picolibc 1.4.6+ (through getauxval)
  https://github.com/picolibc/picolibc/commit/19bfe51d62ad7e32533c7f664b5bca8e26286e31
- Android 4.3+ (API level 18+) (through getauxval)
  https://github.com/aosp-mirror/platform_bionic/commit/2c5153b043b44e9935a334ae9b2d5a4bc5258b40
  https://github.com/aosp-mirror/platform_bionic/commit/655e430b28d7404f763e7ebefe84fba5a387666d
  Always available on:
  - 64-bit architectures (Android 5.0+ (API level 21+) https://android-developers.googleblog.com/2014/10/whats-new-in-android-50-lollipop.html)
  Since Rust 1.68, std requires API level 19+ https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html
  Since Rust 1.82, std requires API level 21+ https://github.com/rust-lang/rust/pull/120593
- FreeBSD 12.0+ and 11.4+ (through elf_aux_info)
  https://github.com/freebsd/freebsd-src/commit/0b08ae2120cdd08c20a2b806e2fcef4d0a36c470
  https://github.com/freebsd/freebsd-src/blob/release/11.4.0/sys/sys/auxv.h
  Always available on:
  - powerpc64 (le) (FreeBSD 12.4+ https://www.freebsd.org/releases/12.4R/announce, https://man.freebsd.org/cgi/man.cgi?arch)
  Not always available on:
  - aarch64 (FreeBSD 11.0+ https://www.freebsd.org/releases/11.0R/announce, https://man.freebsd.org/cgi/man.cgi?arch)
  - powerpc64 (be) (FreeBSD 9.0+ https://www.freebsd.org/releases/9.0R/announce, https://man.freebsd.org/cgi/man.cgi?arch)
  Since Rust 1.75, std requires FreeBSD 12+ https://github.com/rust-lang/rust/pull/114521
  Dropping support for FreeBSD 12 in std was decided in https://github.com/rust-lang/rust/pull/120869,
  but the actual update to the FreeBSD 13 toolchain was attempted twice, but both times there were
  problems, so they were reverted: https://github.com/rust-lang/rust/pull/132228 https://github.com/rust-lang/rust/pull/136582
- OpenBSD 7.6+ (through elf_aux_info)
  https://github.com/openbsd/src/commit/ef873df06dac50249b2dd380dc6100eee3b0d23d
  Not always available on:
  - aarch64 (OpenBSD 6.1+ https://www.openbsd.org/61.html)
  - powerpc64 (OpenBSD 6.8+ https://www.openbsd.org/68.html)

On platforms that we can assume that getauxval/elf_aux_info is always available, we directly call
them on except for musl with static linking. (At this time, we also retain compatibility with
versions that reached EoL or no longer supported by `std`, with the exception of AArch64 FreeBSD described below.)

On musl with static linking, it seems that getauxval is not always available, independent of version
requirements: https://github.com/rust-lang/rust/issues/89626
(That problem may have been fixed in https://github.com/rust-lang/rust/commit/9a04ae4997493e9260352064163285cddc43de3c,
but even in the version containing that patch, [there is report](https://github.com/rust-lang/rust/issues/89626#issuecomment-1242636038)
of the same error.)
This seems to be due to the fact that compiler-builtins is built before libc (which is a dependency
of std) links musl. And the std and its dependent can use getauxval without this problem at least
since the rust-lang/rust patch mentioned above:
https://github.com/rust-lang/rust/blob/1.85.0/library/std/src/sys/pal/unix/stack_overflow.rs#L268
(According to https://github.com/rust-lang/rust/issues/89626#issuecomment-2420469392, this problem
may have been fixed in https://github.com/rust-lang/rust/commit/9ed0d11efbec18a1fa4155576a3bcb685676d23c.)
See also https://github.com/rust-lang/stdarch/pull/1746.
So as for musl with static linking, we assume that getauxval is always available also when `std` feature enabled.

On platforms that we cannot assume that getauxval/elf_aux_info is always available, so we use dlsym
instead of directly calling getauxval/elf_aux_info. (You can force getauxval/elf_aux_info to be
called directly instead of using dlsym by `--cfg portable_atomic_outline_atomics`).

Also, note that dlsym usually not working with static linking.

# Linux/Android

As of Rust 1.69, is_aarch64_feature_detected always uses dlsym by default
on AArch64 Linux/Android, but on some platforms, we can safely assume
getauxval is linked to the binary (see the above).

See also https://github.com/rust-lang/stdarch/pull/1375

See tests::test_alternative and aarch64_aa64reg.rs for (test-only) alternative implementations.

# FreeBSD

As of nightly-2024-09-07, is_aarch64_feature_detected always uses mrs on
AArch64 FreeBSD. However, they do not work on FreeBSD 12 on QEMU (confirmed
on FreeBSD 12.{2,3,4}), and we got SIGILL (worked on FreeBSD 13 and 14).

So use elf_aux_info instead of mrs like compiler-rt does.
https://reviews.llvm.org/D109330

elf_aux_info is available on FreeBSD 12.0+ and 11.4+:
https://github.com/freebsd/freebsd-src/commit/0b08ae2120cdd08c20a2b806e2fcef4d0a36c470
https://github.com/freebsd/freebsd-src/blob/release/11.4.0/sys/sys/auxv.h
On FreeBSD, [AArch64 support is available on FreeBSD 11.0+](https://www.freebsd.org/releases/11.0R/announce),
but FreeBSD 11 (11.4) was EoL on 2021-09-30, and FreeBSD 11.3 was EoL on 2020-09-30:
https://www.freebsd.org/security/unsupported
See also https://github.com/rust-lang/stdarch/pull/611#issuecomment-445464613

See tests::test_alternative and aarch64_aa64reg.rs for (test-only) alternative implementations.

# OpenBSD

elf_aux_info is available on OpenBSD 7.6+:
https://github.com/openbsd/src/commit/ef873df06dac50249b2dd380dc6100eee3b0d23d

On AArch64, there is an alternative that available on older version,
so we use it (see aarch64_aa64reg.rs).

*/// LLVM definitions: https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/llvm/lib/Target/X86/X86.tdtest_bit_flagsprint_featurestests_common// rustc definitions: https://github.com/rust-lang/rust/blob/e6af292f91f21f12ac1aab6825efb7e1e3381cbb/compiler/rustc_target/src/target_features.rsPOWER_10// TODO: use sys_const! once libc crate defined it.// https://github.com/golang/go/blob/go1.24.0/src/internal/cpu/cpu_ppc64x_aix.go/*
Run-time CPU feature detection on PowerPC64 AIX by using getsystemcfg.

Refs:
- https://github.com/golang/go/blob/go1.24.0/src/internal/cpu/cpu_ppc64x_aix.go

As of nightly-2024-09-07, is_powerpc_feature_detected doesn't support run-time detection on AIX.
https://github.com/rust-lang/stdarch/blob/d9466edb4c53cece8686ee6e17b028436ddf4151/crates/std_detect/src/detect/mod.rs

Run-time detection on PowerPC64 AIX is currently disabled by default as experimental
because we cannot run tests on the VM or real machine.
*/riscv_hwprobe// Use asm-based syscall for compatibility with non-libc targets if possible.__riscv_hwprobe// https://github.com/torvalds/linux/blob/v6.13/Documentation/arch/riscv/hwprobe.rst// syscall returns an unsupported error if riscv_hwprobe is not supported,// so we can safely use this function on older versions of Linux.// We use asm-based syscall for compatibility with non-libc targets.// This test tests that our ones and libc::syscall returns the same result./*
Run-time CPU feature detection on RISC-V Linux/Android by using riscv_hwprobe.

On RISC-V, detection using auxv only supports single-letter extensions.
So, we use riscv_hwprobe that supports multi-letter extensions.

Refs: https://github.com/torvalds/linux/blob/v6.13/Documentation/arch/riscv/hwprobe.rst
*/vmovdqa_atomicALL_FLAGStest_detectCpuidResult__cpuid// Workaround for https://github.com/rust-lang/rust/issues/101346// It is not clear if our use cases are affected, but we implement this just in case.// Refs:// - https://www.felixcloutier.com/x86/cpuid// - https://en.wikipedia.org/wiki/CPUID// - https://github.com/rust-lang/stdarch/blob/a0c30f3e3c75adcd6ee7efc94014ebcead61c507/crates/core_arch/src/x86/cpuid.rs_VENDOR_ID_INTEL// https://en.wikipedia.org/wiki/CPUID_VENDOR_ID_INTEL2// Intel_VENDOR_ID_AMD// Intel https://github.com/InstLatx64/InstLatx64/commit/8fdd319884c67d2c6ec1ca0c595b42c1c4b8d803_VENDOR_ID_CENTAUR// AMD_VENDOR_ID_ZHAOXIN// Centaur/VIA/Zhaoxin_vender// Zhaoxin_vendor_id_vendor_has_vmovdqa_atomictest_cpuid/*
Run-time CPU feature detection on x86_64 by using CPUID.

Adapted from https://github.com/rust-lang/stdarch.
*/// AArch64 ILP32 ABI, mips64 N32 ABI). On those targets, AtomicU64 is available and fast,// so use it to implement normal sequence lock.AtomicChunk// AArch64 ILP32 ABI, mips64 N32 ABI). On those targets, AtomicU64 is fast,// so use it to reduce chunks of byte-wise atomic memcpy.// Adapted from https://github.com/crossbeam-rs/crossbeam/blob/crossbeam-utils-0.8.7/crossbeam-utils/src/atomic/atomic_cell.rs#L969-L1016./*
Fallback implementation using global locks.

This implementation uses seqlock for global locks.

This is basically based on global locks in crossbeam-utils's `AtomicCell`,
but seqlock is implemented in a way that does not depend on UB
(see comments in optimistic_read method in atomic! macro for details).

Note that we cannot use a lock per atomic type, since the in-memory representation of the atomic
type and the value type must be the same.
*/UdwAtomicUdwAtomicIdwdebug_assert_outline_atomicsfn_aliasatomic_load_seqcstatomic_store_non_seqcstatomic_store_seqcstatomic_compare_exchange_seqcstatomic_rmw_3atomic_rmw_2atomic_swap_seqcstatomic_add_seqcstatomic_sub_seqcstatomic_and_seqcstatomic_nand_seqcstatomic_or_seqcstatomic_xor_seqcstatomic_max_seqcstatomic_umax_seqcstatomic_min_seqcstatomic_umin_seqcstatomic_not_seqcstatomic_neg_seqcst/*
Helper for outline-atomics.

On architectures where DW atomics are not supported on older CPUs, we use
fallback implementation when DW atomic instructions are not supported and
outline-atomics is enabled.

This module provides helpers to implement them.
*/AtomicStampStamp// See mod.rs for details.// Adapted from https://github.com/crossbeam-rs/crossbeam/blob/crossbeam-utils-0.8.7/crossbeam-utils/src/atomic/seq_lock.rs.// Adapted from https://github.com/crossbeam-rs/crossbeam/blob/crossbeam-utils-0.8.7/crossbeam-utils/src/atomic/seq_lock_wide.rs.// Adapted from https://github.com/crossbeam-rs/crossbeam/blob/crossbeam-utils-0.8.21/crossbeam-utils/src/cache_padded.rs.// aarch64/arm64ec's big.LITTLE architecture has asymmetric cores and "big" cores have 128-byte cache line size.// Adapted from https://github.com/crossbeam-rs/crossbeam/blob/crossbeam-utils-0.8.7/crossbeam-utils/src/backoff.rs.// Adjusted to reduce spinning.// https://github.com/oneapi-src/oneTBB/blob/v2021.5.0/include/oneapi/tbb/detail/_utils.h#L46-L48AtomicF16AtomicF128AtomicF32AtomicF64start_lsfeatomic_floatf128/*
Atomic float implementation based on AArch64 with FEAT_LSFE.

This module provides atomic float implementations using FEAT_LSFE instructions.

Generated asm:
- aarch64 (+lsfe) https://godbolt.org/z/7vaxeofv1
*/// TODO: optimize no return cases:// https://developer.arm.com/documentation/ddi0602/2024-12/SIMD-FP-Instructions/STFADD--STFADDL--Floating-point-atomic-add-in-memory--without-return-// https://developer.arm.com/documentation/ddi0602/2024-12/SIMD-FP-Instructions/STFMAXNM--STFMAXNML--Floating-point-atomic-maximum-number-in-memory--without-return-// https://developer.arm.com/documentation/ddi0602/2024-12/SIMD-FP-Instructions/STFMINNM--STFMINNML--Floating-point-atomic-minimum-number-in-memory--without-return-/*
Atomic float implementation based on atomic integer.

This module provides atomic float implementations using atomic integer.

Note that most of `fetch_*` operations of atomic floats are implemented using
CAS loops, which can be slower than equivalent operations of atomic integers.

AArch64 with FEAT_LSFE and GPU targets have atomic instructions for float.
See aarch64.rs for AArch64 with FEAT_LSFE.
GPU targets will also use architecture-specific implementations instead of this implementation in the
future: https://github.com/taiki-e/portable-atomic/issues/34 / https://github.com/taiki-e/portable-atomic/pull/45
*/// TODO: fetch_{minimum,maximum}* https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3008r2.html / https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0493r5.pdf/*
Atomic float implementations
*/// - 0x80 - I (IRQ mask) bit (1 << 7)// - 0x40 - F (FIQ mask) bit (1 << 6)// We disable only IRQs by default. See also https://github.com/taiki-e/portable-atomic/pull/28#issuecomment-1214146912.instruction_set/// Disables interrupts and returns the previous interrupt state./// Restores the previous interrupt state./// The state must be the one retrieved by the previous `disable`.// On pre-v6 Arm, we cannot use core::sync::atomic here because they call the// `__sync_*` builtins for non-relaxed load/store (because pre-v6 Arm doesn't// have Data Memory Barrier).// Generated asm:// - armv5te https://godbolt.org/z/deqTqPzqz/*
Refs: https://developer.arm.com/documentation/ddi0406/cb/System-Level-Architecture/The-System-Level-Programmers--Model/ARM-processor-modes-and-ARM-core-registers/Program-Status-Registers--PSRs-

Generated asm:
- armv5te https://godbolt.org/z/fhaW3d9Kv
*//*
Adapted from https://github.com/rust-embedded/cortex-m.

Refs: https://developer.arm.com/documentation/ddi0419/c/System-Level-Architecture/System-Level-Programmers--Model/Registers/The-special-purpose-mask-register--PRIMASK

Generated asm:
- armv6-m https://godbolt.org/z/1sqKnsY6n
*//*
Adapted from https://github.com/Rahix/avr-device.

See also src/imp/avr.rs.

Refs:
- AVR® Instruction Set Manual, Rev. DS40002198B
  https://ww1.microchip.com/downloads/en/DeviceDoc/AVR-InstructionSet-Manual-DS40002198.pdf

Generated asm:
- avr https://godbolt.org/z/W5jxGsToc
*/// On some platforms, atomic load/store can be implemented in a more efficient// way than disabling interrupts. On MSP430, some RMWs that do not return the// previous value can also be optimized.// Note: On single-core systems, it is okay to use critical session-based// CAS together with atomic load/store. The load/store will not be// called while interrupts are disabled, and since the load/store is// atomic, it is not affected by interrupts even if interrupts are enabled.// Critical section implementations might use locks internally.// Consider atomic operations based on disabling interrupts on single-core// systems are lock-free. (We consider the pre-v6 Arm Linux's atomic operations// provided in a similar way by the Linux kernel to be lock-free.)// SAFETY: any data races are prevented by disabling interrupts or// atomic intrinsics (see module-level comments).as_native// RISC-V 32-bit(RV32)/{32,64}-bit(RV64) RMW with Zaamo extension// RISC-V 8-bit/16-bit RMW with Zabha extension// RISC-V 8-bit/16-bit RMW with Zaamo extensiontest_atomic_ptr_single_threadtest_atomic_int_single_thread/*
Critical section based fallback implementations

This module supports two different critical section implementations:
- Built-in "disable all interrupts".
- Call into the `critical-section` crate (which allows the user to plug any implementation).

The `critical-section`-based fallback is enabled when the user asks for it with the `critical-section`
Cargo feature.

The "disable interrupts" fallback is not sound on multi-core systems.
Also, this uses privileged instructions to disable interrupts, so it usually
doesn't work on unprivileged mode. Using this fallback in an environment where privileged
instructions are not available is also usually considered **unsound**,
although the details are system-dependent.

Therefore, this implementation will only be enabled in one of the following cases:

- When the user explicitly declares that the system is single-core and that
  privileged instructions are available using an unsafe cfg.
- When we can safely assume that the system is single-core and that
  privileged instructions are available on the system.

AVR, which is single core[^avr1] and LLVM also generates code that disables
interrupts [^avr2] in atomic ops by default, is considered the latter.
MSP430 as well.

See also README.md of this directory.

[^avr1]: https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/llvm/lib/Target/AVR/AVRExpandPseudoInsts.cpp#L1074
[^avr2]: https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/llvm/test/CodeGen/AVR/atomics/load16.ll#L5
*//*
Adapted from https://github.com/rust-embedded/msp430.

See also src/imp/msp430.rs.

Refs:
- MSP430x5xx and MSP430x6xx Family User's Guide, Rev. Q
  https://www.ti.com/lit/ug/slau208q/slau208q.pdf

Generated asm:
- msp430 https://godbolt.org/z/fc6h89xac
*/riscv// Status register// MIE (Machine Interrupt Enable) bit (1 << 3)// SIE (Supervisor Interrupt Enable) bit (1 << 1)/*
Refs:
- RISC-V Instruction Set Manual
  Machine Status (mstatus and mstatush) Registers
  https://github.com/riscv/riscv-isa-manual/blob/riscv-isa-release-8b9dc50-2024-08-30/src/machine.adoc#machine-status-mstatus-and-mstatush-registers
  Supervisor Status (sstatus) Register
  https://github.com/riscv/riscv-isa-manual/blob/riscv-isa-release-8b9dc50-2024-08-30/src/supervisor.adoc#supervisor-status-sstatus-register

See also src/imp/riscv.rs.

Generated asm:
- riscv64gc https://godbolt.org/z/zTrzT1Ee7
*//*
Refs:
- Xtensa Instruction Set Architecture (ISA) Summary for all Xtensa LX Processors
  https://www.cadence.com/content/dam/cadence-www/global/en_US/documents/tools/silicon-solutions/compute-ip/isa-summary.pdf
- Linux kernel's Xtensa atomic implementation
  https://github.com/torvalds/linux/blob/v6.13/arch/xtensa/include/asm/atomic.h
*/core_atomic// x86-specific optimizations// 128-bit atomic implementations on 64-bit architectures// has CAS | (has core atomic & !(avr | msp430 | critical section)) => core atomic// no core (64-bit | 128-bit) atomic & has CAS => use lock-base fallback// x86_64 & (cmpxchg16b | outline-atomics)// Lock-free implementations// Lock-based fallback implementations// Critical section based fallback implementations// Atomic float implementations/// An atomic fence./// Panics if `order` is [`Relaxed`](Ordering::Relaxed)./// A compiler memory fence./*
Atomic implementation on MSP430.

Adapted from https://github.com/pftbest/msp430-atomic.

Operations not supported here are provided by disabling interrupts.
See also src/imp/interrupt/msp430.rs.

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#msp430

Note: Ordering is always SeqCst.

Refs:
- MSP430x5xx and MSP430x6xx Family User's Guide, Rev. Q
  https://www.ti.com/lit/ug/slau208q/slau208q.pdf
- atomic-maybe-uninit
  https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- msp430 https://godbolt.org/z/MGrd4jPoq
*/atomic_rmw_amo_ext// Use +a also for zaamo because `option arch +zaamo` requires LLVM 19.// https://github.com/llvm/llvm-project/commit/8be079cdddfd628d356d9ddb5ab397ea95fb1030atomic_rmw_amosllw// 32-bit val.wrapping_shl(shift) but no extra `& (u32::BITS - 1)`srlw// 32-bit val.wrapping_shr(shift) but no extra `& (u32::BITS - 1)`atomic_load_storeatomic_ptrzero_extend/// Zero-extends `self` to `u32` if it is smaller than 32-bit.ZeroExtendatomic_sub_wordtest_atomic_ptr_load_storetest_atomic_int_load_storetest_atomic_ptr_amotest_atomic_int_amotest_atomic_int_amo_sub_word/*
Atomic load/store implementation on RISC-V.

This is for RISC-V targets without A extension. (pre-1.76 rustc doesn't provide atomics
at all on such targets. https://github.com/rust-lang/rust/pull/114499)

Also, optionally provides RMW implementation when Zaamo extension or force-amo feature is enabled.

See "Atomic operation overview by architecture" in atomic-maybe-uninit for a more comprehensive and
detailed description of the atomic and synchronize instructions in this architecture:
https://github.com/taiki-e/atomic-maybe-uninit/blob/HEAD/src/arch/README.md#risc-v

Refs:
- RISC-V Instruction Set Manual
  "Zaamo" Extension for Atomic Memory Operations
  https://github.com/riscv/riscv-isa-manual/blob/riscv-isa-release-8b9dc50-2024-08-30/src/a-st-ext.adoc#zaamo-extension-for-atomic-memory-operations
  "Zabha" Extension for Byte and Halfword Atomic Memory Operations
  https://github.com/riscv/riscv-isa-manual/blob/riscv-isa-release-8b9dc50-2024-08-30/src/zabha.adoc
- RISC-V Atomics ABI Specification
  https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/draft-20240829-13bfa9f54634cb60d86b9b333e109f077805b4b3/riscv-atomic.adoc
- atomic-maybe-uninit
  https://github.com/taiki-e/atomic-maybe-uninit

Generated asm:
- riscv64gc https://godbolt.org/z/Ws933n9jE
- riscv64gc (+zabha) https://godbolt.org/z/zEKPPW11f
- riscv32imac https://godbolt.org/z/TKbYdbaE9
- riscv32imac (+zabha) https://godbolt.org/z/TnePfK6co
*/// TODO: Zacas/Zalrsc extensionatomic_bit_opts/*
Atomic operations implementation on x86/x86_64.

This module provides atomic operations not supported by LLVM or optimizes
cases where LLVM code generation is not optimal.

Note: On Miri and ThreadSanitizer which do not support inline assembly, we don't use
this module and use CAS loop instead.

Refs:
- x86 and amd64 instruction reference https://www.felixcloutier.com/x86

Generated asm:
- x86_64 https://godbolt.org/z/ETa1MGTP3
*/// missing_docs,// Code outside of cfg(feature = "float") shouldn't use float./// Emits a machine instruction to signal the processor that it is running in/// a busy-wait spin-loop ("spin lock")./// Upon receiving the spin-loop signal the processor can optimize its behavior by,/// for example, saving power or switching hyper-threads./// This function is different from [`thread::yield_now`] which directly/// yields to the system's scheduler, whereas `spin_loop` does not interact/// with the operating system./// A common use case for `spin_loop` is implementing bounded optimistic/// spinning in a CAS loop in synchronization primitives. To avoid problems/// like priority inversion, it is strongly recommended that the spin loop is/// terminated after a finite amount of iterations and an appropriate blocking/// syscall is made./// **Note:** On platforms that do not support receiving spin-loop hints this/// function does not do anything at all./// [`thread::yield_now`]: https://doc.rust-lang.org/std/thread/fn.yield_now.html//! Re-export of the [`core::hint`] module.//! The only difference from the [`core::hint`] module is that [`spin_loop`]//! is available in all rust versions that this crate supports.//! use portable_atomic::hint;//! hint::spin_loop();r" A boolean type which can be safely shared between threads."r" This type has the same in-memory representation as a [`bool`]."r" If the compiler and the platform support atomic loads and stores of `u8`,"r" this type is a wrapper for the standard library's"r" [`AtomicBool`](core::sync::atomic::AtomicBool). If the platform supports it"r" but the compiler does not, atomic operations are implemented using inline"r" assembly."r" Creates an `AtomicBool` initialized to `false`."r" Converts a `bool` into an `AtomicBool`."impl_debug_and_serder" Creates a new `AtomicBool`."r" use portable_atomic::AtomicBool;"r" let atomic_true = AtomicBool::new(true);"r" let atomic_false = AtomicBool::new(false);"r" Creates a new `AtomicBool` from a pointer."r" This is `const fn` on Rust 1.83+."r" * `ptr` must be aligned to `align_of::<AtomicBool>()` (note that on some platforms this can"r"   be bigger than `align_of::<bool>()`)."r" * `ptr` must be [valid] for both reads and writes for the whole lifetime `'a`."r" * If this atomic type is [lock-free](Self::is_lock_free), non-atomic accesses to the value"r"   behind `ptr` must have a happens-before relationship with atomic accesses via the returned"r"   value (or vice-versa)."r"   * In other words, time periods where the value is accessed atomically may not overlap"r"     with periods where the value is accessed non-atomically."r"   * This requirement is trivially satisfied if `ptr` is never used non-atomically for the"r"     duration of lifetime `'a`. Most use cases should be able to follow this guideline."r"   * This requirement is also trivially satisfied if all accesses (atomic or not) are done"r"     from the same thread."r" * If this atomic type is *not* lock-free:"r"   * Any accesses to the value behind `ptr` must have a happens-before relationship"r"     with accesses via the returned value (or vice-versa)."r"   * Any concurrent accesses to the value behind `ptr` for the duration of lifetime `'a` must"r"     be compatible with operations performed by this atomic type."r" * This method must not be used to create overlapping or mixed-size atomic accesses, as"r"   these are not supported by the memory model."r" [valid]: core::ptr#safety"r" Returns `true` if operations on values of this type are lock-free."r" If the compiler or the platform doesn't support the necessary"r" atomic instructions, global locks for every potentially"r" concurrent atomic operation will be used."r" let is_lock_free = AtomicBool::is_lock_free();"r" **Note:** If the atomic operation relies on dynamic CPU feature detection,"r" this type may be lock-free even if the function returns false."r" const IS_ALWAYS_LOCK_FREE: bool = AtomicBool::is_always_lock_free();"is_always_lock_freer" Returns a mutable reference to the underlying [`bool`]."r" This is safe because the mutable reference guarantees that no other threads are"r" concurrently accessing the atomic data."r" use portable_atomic::{AtomicBool, Ordering};"r" let mut some_bool = AtomicBool::new(true);"r" assert_eq!(*some_bool.get_mut(), true);"r" *some_bool.get_mut() = false;"r" assert_eq!(some_bool.load(Ordering::SeqCst), false);"r" Consumes the atomic and returns the contained value."r" This is safe because passing `self` by value guarantees that no other threads are"r" This is `const fn` on Rust 1.56+."r" let some_bool = AtomicBool::new(true);"r" assert_eq!(some_bool.into_inner(), true);"r" Loads a value from the bool."r" `load` takes an [`Ordering`] argument which describes the memory ordering"r" of this operation. Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`]."r" Panics if `order` is [`Release`] or [`AcqRel`]."r" assert_eq!(some_bool.load(Ordering::Relaxed), true);"r" Stores a value into the bool."r" `store` takes an [`Ordering`] argument which describes the memory ordering"r" of this operation. Possible values are [`SeqCst`], [`Release`] and [`Relaxed`]."r" Panics if `order` is [`Acquire`] or [`AcqRel`]."r" some_bool.store(false, Ordering::Relaxed);"r" assert_eq!(some_bool.load(Ordering::Relaxed), false);"r" Stores a value into the bool, returning the previous value."r" `swap` takes an [`Ordering`] argument which describes the memory ordering"r" of this operation. All ordering modes are possible. Note that using"r" [`Acquire`] makes the store part of this operation [`Relaxed`], and"r" using [`Release`] makes the load part [`Relaxed`]."r" assert_eq!(some_bool.swap(false, Ordering::Relaxed), true);"r" Stores a value into the [`bool`] if the current value is the same as the `current` value."r" The return value is a result indicating whether the new value was written and containing"r" the previous value. On success this value is guaranteed to be equal to `current`."r" `compare_exchange` takes two [`Ordering`] arguments to describe the memory"r" ordering of this operation. `success` describes the required ordering for the"r" read-modify-write operation that takes place if the comparison with `current` succeeds."r" `failure` describes the required ordering for the load operation that takes place when"r" the comparison fails. Using [`Acquire`] as success ordering makes the store part"r" of this operation [`Relaxed`], and using [`Release`] makes the successful load"r" [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]."r" Panics if `failure` is [`Release`], [`AcqRel`]."r"     some_bool.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed),"r"     Ok(true)"r"     some_bool.compare_exchange(true, true, Ordering::SeqCst, Ordering::Acquire),"r"     Err(false)"r" Unlike [`AtomicBool::compare_exchange`], this function is allowed to spuriously fail even when the"r" comparison succeeds, which can result in more efficient code on some platforms. The"r" return value is a result indicating whether the new value was written and containing the"r" previous value."r" `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory"r" let val = AtomicBool::new(false);"r" let new = true;"r" let mut old = val.load(Ordering::Relaxed);"r"     match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {"r"         Ok(_) => break,"r"         Err(x) => old = x,"r#" Logical "and" with a boolean value."#r#" Performs a logical "and" operation on the current value and the argument `val`, and sets"#r" the new value to the result."r" Returns the previous value."r" `fetch_and` takes an [`Ordering`] argument which describes the memory ordering"r" let foo = AtomicBool::new(true);"r" assert_eq!(foo.fetch_and(false, Ordering::SeqCst), true);"r" assert_eq!(foo.load(Ordering::SeqCst), false);"r" assert_eq!(foo.fetch_and(true, Ordering::SeqCst), true);"r" assert_eq!(foo.load(Ordering::SeqCst), true);"r" let foo = AtomicBool::new(false);"r" assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false);"r" Unlike `fetch_and`, this does not return the previous value."r" `and` takes an [`Ordering`] argument which describes the memory ordering"r" This function may generate more efficient code than `fetch_and` on some platforms."r" - x86/x86_64: `lock and` instead of `cmpxchg` loop"r" - MSP430: `and` instead of disabling interrupts"r" Note: On x86/x86_64, the use of either function should not usually"r" affect the generated code, because LLVM can properly optimize the case"r" where the result is unused."r" foo.and(false, Ordering::SeqCst);"r" foo.and(true, Ordering::SeqCst);"r#" Logical "nand" with a boolean value."#r#" Performs a logical "nand" operation on the current value and the argument `val`, and sets"#r" `fetch_nand` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true);"r" assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true);"r" assert_eq!(foo.load(Ordering::SeqCst) as usize, 0);"r" assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);"r#" Logical "or" with a boolean value."#r#" Performs a logical "or" operation on the current value and the argument `val`, and sets the"#r" new value to the result."r" `fetch_or` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true);"r" assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true);"r" assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false);"r" Unlike `fetch_or`, this does not return the previous value."r" `or` takes an [`Ordering`] argument which describes the memory ordering"r" This function may generate more efficient code than `fetch_or` on some platforms."r" - x86/x86_64: `lock or` instead of `cmpxchg` loop"r" - MSP430: `bis` instead of disabling interrupts"r" foo.or(false, Ordering::SeqCst);"r" foo.or(true, Ordering::SeqCst);"r#" Logical "xor" with a boolean value."#r#" Performs a logical "xor" operation on the current value and the argument `val`, and sets"#r" `fetch_xor` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true);"r" assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true);"r" assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);"r" Unlike `fetch_xor`, this does not return the previous value."r" `xor` takes an [`Ordering`] argument which describes the memory ordering"r" This function may generate more efficient code than `fetch_xor` on some platforms."r" - x86/x86_64: `lock xor` instead of `cmpxchg` loop"r" - MSP430: `xor` instead of disabling interrupts"r" foo.xor(false, Ordering::SeqCst);"r" foo.xor(true, Ordering::SeqCst);"r#" Logical "not" with a boolean value."#r#" Performs a logical "not" operation on the current value, and sets"#r" `fetch_not` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_not(Ordering::SeqCst), true);"r" assert_eq!(foo.fetch_not(Ordering::SeqCst), false);"r" Unlike `fetch_not`, this does not return the previous value."r" `not` takes an [`Ordering`] argument which describes the memory ordering"r" This function may generate more efficient code than `fetch_not` on some platforms."r" foo.not(Ordering::SeqCst);"r" Fetches the value, and applies a function to it that returns an optional"r" new value. Returns a `Result` of `Ok(previous_value)` if the function"r" returned `Some(_)`, else `Err(previous_value)`."r" Note: This may call the function multiple times if the value has been"r" changed from other threads in the meantime, as long as the function"r" returns `Some(_)`, but the function will have been applied only once to"r" the stored value."r" `fetch_update` takes two [`Ordering`] arguments to describe the memory"r" ordering of this operation. The first describes the required ordering for"r" when the operation finally succeeds while the second describes the"r" required ordering for loads. These correspond to the success and failure"r" orderings of [`compare_exchange`](Self::compare_exchange) respectively."r" Using [`Acquire`] as success ordering makes the store part of this"r" operation [`Relaxed`], and using [`Release`] makes the final successful"r" load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`],"r" [`Acquire`] or [`Relaxed`]."r" # Considerations"r" This method is not magic; it is not provided by the hardware."r" It is implemented in terms of [`compare_exchange_weak`](Self::compare_exchange_weak),"r" and suffers from the same drawbacks."r" In particular, this method will not circumvent the [ABA Problem]."r" [ABA Problem]: https://en.wikipedia.org/wiki/ABA_problem"r" Panics if `fetch_order` is [`Release`], [`AcqRel`]."r" let x = AtomicBool::new(false);"r" assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(false));"r" assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(false));"r" assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(true));"r" assert_eq!(x.load(Ordering::SeqCst), false);"r" Returns a mutable pointer to the underlying [`bool`]."r" Returning an `*mut` pointer from a shared reference to this atomic is"r" safe because the atomic types work with interior mutability. Any use of"r" the returned raw pointer requires an `unsafe` block and has to uphold"r" the safety requirements. If there is concurrent access, note the following"r" additional safety requirements:"r" - If this atomic type is [lock-free](Self::is_lock_free), any concurrent"r"   operations on it must be atomic."r" - Otherwise, any concurrent operations on it must be compatible with"r"   operations performed by this atomic type."r" This is `const fn` on Rust 1.58+."as_atomic_u8r" A raw pointer type which can be safely shared between threads."r" This type has the same in-memory representation as a `*mut T`."r" If the compiler and the platform support atomic loads and stores of pointers,"r" [`AtomicPtr`](core::sync::atomic::AtomicPtr). If the platform supports it"r" Creates a null `AtomicPtr<T>`."r" Creates a new `AtomicPtr`."r" use portable_atomic::AtomicPtr;"r" let ptr = &mut 5;"r" let atomic_ptr = AtomicPtr::new(ptr);"r" Creates a new `AtomicPtr` from a pointer."r" * `ptr` must be aligned to `align_of::<AtomicPtr<T>>()` (note that on some platforms this"r"   can be bigger than `align_of::<*mut T>()`)."r" let is_lock_free = AtomicPtr::<()>::is_lock_free();"r" const IS_ALWAYS_LOCK_FREE: bool = AtomicPtr::<()>::is_always_lock_free();"r" Returns a mutable reference to the underlying pointer."r" use portable_atomic::{AtomicPtr, Ordering};"r" let mut data = 10;"r" let mut atomic_ptr = AtomicPtr::new(&mut data);"r" let mut other_data = 5;"r" *atomic_ptr.get_mut() = &mut other_data;"r" assert_eq!(unsafe { *atomic_ptr.load(Ordering::SeqCst) }, 5);"r" let mut data = 5;"r" let atomic_ptr = AtomicPtr::new(&mut data);"r" assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);"r" Loads a value from the pointer."r" let some_ptr = AtomicPtr::new(ptr);"r" let value = some_ptr.load(Ordering::Relaxed);"r" Stores a value into the pointer."r" let other_ptr = &mut 10;"r" some_ptr.store(other_ptr, Ordering::Relaxed);"r" Stores a value into the pointer, returning the previous value."r" let value = some_ptr.swap(other_ptr, Ordering::Relaxed);"r" Stores a value into the pointer if the current value is the same as the `current` value."r" let value = some_ptr.compare_exchange(ptr, other_ptr, Ordering::SeqCst, Ordering::Relaxed);"r" Unlike [`AtomicPtr::compare_exchange`], this function is allowed to spuriously fail even when the"r" let some_ptr = AtomicPtr::new(&mut 5);"r" let new = &mut 10;"r" let mut old = some_ptr.load(Ordering::Relaxed);"r"     match some_ptr.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {"r" let ptr: *mut _ = &mut 5;"r" let new: *mut _ = &mut 10;"r" assert_eq!(some_ptr.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(ptr));"r" let result = some_ptr.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| {"r"     if x == ptr {"r"         Some(new)"r"         None"r" assert_eq!(result, Ok(ptr));"r" assert_eq!(some_ptr.load(Ordering::SeqCst), new);"r" Offsets the pointer's address by adding `val` (in units of `T`),"r" returning the previous pointer."r" This is equivalent to using [`wrapping_add`] to atomically perform the"r" equivalent of `ptr = ptr.wrapping_add(val);`."r" This method operates in units of `T`, which means that it cannot be used"r" to offset the pointer by an amount which is not a multiple of"r" `size_of::<T>()`. This can sometimes be inconvenient, as you may want to"r" work with a deliberately misaligned pointer. In such cases, you may use"r" the [`fetch_byte_add`](Self::fetch_byte_add) method instead."r" `fetch_ptr_add` takes an [`Ordering`] argument which describes the"r" memory ordering of this operation. All ordering modes are possible. Note"r" that using [`Acquire`] makes the store part of this operation"r" [`Relaxed`], and using [`Release`] makes the load part [`Relaxed`]."r" [`wrapping_add`]: https://doc.rust-lang.org/std/primitive.pointer.html#method.wrapping_add"r" # #![allow(unstable_name_collisions)]"r" # #[allow(unused_imports)] use sptr::Strict as _; // strict provenance polyfill for old rustc"r" let atom = AtomicPtr::<i64>::new(core::ptr::null_mut());"r" assert_eq!(atom.fetch_ptr_add(1, Ordering::Relaxed).addr(), 0);"r" // Note: units of `size_of::<i64>()`."r" assert_eq!(atom.load(Ordering::Relaxed).addr(), 8);"fetch_ptr_addr" Offsets the pointer's address by subtracting `val` (in units of `T`),"r" This is equivalent to using [`wrapping_sub`] to atomically perform the"r" equivalent of `ptr = ptr.wrapping_sub(val);`."r" the [`fetch_byte_sub`](Self::fetch_byte_sub) method instead."r" `fetch_ptr_sub` takes an [`Ordering`] argument which describes the memory"r" ordering of this operation. All ordering modes are possible. Note that"r" using [`Acquire`] makes the store part of this operation [`Relaxed`],"r" and using [`Release`] makes the load part [`Relaxed`]."r" [`wrapping_sub`]: https://doc.rust-lang.org/std/primitive.pointer.html#method.wrapping_sub"r" let array = [1i32, 2i32];"r" let atom = AtomicPtr::new(array.as_ptr().wrapping_add(1) as *mut _);"r" assert!(core::ptr::eq(atom.fetch_ptr_sub(1, Ordering::Relaxed), &array[1]));"r" assert!(core::ptr::eq(atom.load(Ordering::Relaxed), &array[0]));"fetch_ptr_subr" Offsets the pointer's address by adding `val` *bytes*, returning the"r" previous pointer."r" This is equivalent to using [`wrapping_add`] and [`cast`] to atomically"r" perform `ptr = ptr.cast::<u8>().wrapping_add(val).cast::<T>()`."r" `fetch_byte_add` takes an [`Ordering`] argument which describes the"r" [`cast`]: https://doc.rust-lang.org/std/primitive.pointer.html#method.cast"r" assert_eq!(atom.fetch_byte_add(1, Ordering::Relaxed).addr(), 0);"r" // Note: in units of bytes, not `size_of::<i64>()`."r" assert_eq!(atom.load(Ordering::Relaxed).addr(), 1);"fetch_byte_addr" Offsets the pointer's address by subtracting `val` *bytes*, returning the"r" This is equivalent to using [`wrapping_sub`] and [`cast`] to atomically"r" perform `ptr = ptr.cast::<u8>().wrapping_sub(val).cast::<T>()`."r" `fetch_byte_sub` takes an [`Ordering`] argument which describes the"r" let atom = AtomicPtr::<i64>::new(sptr::invalid_mut(1));"r" assert_eq!(atom.fetch_byte_sub(1, Ordering::Relaxed).addr(), 1);"r" assert_eq!(atom.load(Ordering::Relaxed).addr(), 0);"fetch_byte_subr#" Performs a bitwise "or" operation on the address of the current pointer,"#r" and the argument `val`, and stores a pointer with provenance of the"r" current pointer and the resulting address."r" This is equivalent to using [`map_addr`] to atomically perform"r" `ptr = ptr.map_addr(|a| a | val)`. This can be used in tagged"r" pointer schemes to atomically set tag bits."r" **Caveat**: This operation returns the previous value. To compute the"r" stored value without losing provenance, you may use [`map_addr`]. For"r" example: `a.fetch_or(val).map_addr(|a| a | val)`."r" `fetch_or` takes an [`Ordering`] argument which describes the memory"r" This API and its claimed semantics are part of the Strict Provenance"r" experiment, see the [module documentation for `ptr`][core::ptr] for"r" [`map_addr`]: https://doc.rust-lang.org/std/primitive.pointer.html#method.map_addr"r" let pointer = &mut 3i64 as *mut i64;"r" let atom = AtomicPtr::<i64>::new(pointer);"r" // Tag the bottom bit of the pointer."r" assert_eq!(atom.fetch_or(1, Ordering::Relaxed).addr() & 1, 0);"r" // Extract and untag."r" let tagged = atom.load(Ordering::Relaxed);"r" assert_eq!(tagged.addr() & 1, 1);"r" assert_eq!(tagged.map_addr(|p| p & !1), pointer);"r#" Performs a bitwise "and" operation on the address of the current"#r" pointer, and the argument `val`, and stores a pointer with provenance of"r" the current pointer and the resulting address."r" `ptr = ptr.map_addr(|a| a & val)`. This can be used in tagged"r" pointer schemes to atomically unset tag bits."r" example: `a.fetch_and(val).map_addr(|a| a & val)`."r" `fetch_and` takes an [`Ordering`] argument which describes the memory"r" // A tagged pointer"r" let atom = AtomicPtr::<i64>::new(pointer.map_addr(|a| a | 1));"r" assert_eq!(atom.fetch_or(1, Ordering::Relaxed).addr() & 1, 1);"r" // Untag, and extract the previously tagged pointer."r" let untagged = atom.fetch_and(!1, Ordering::Relaxed).map_addr(|a| a & !1);"r" assert_eq!(untagged, pointer);"r#" Performs a bitwise "xor" operation on the address of the current"#r" `ptr = ptr.map_addr(|a| a ^ val)`. This can be used in tagged"r" pointer schemes to atomically toggle tag bits."r" example: `a.fetch_xor(val).map_addr(|a| a ^ val)`."r" `fetch_xor` takes an [`Ordering`] argument which describes the memory"r" // Toggle a tag bit on the pointer."r" atom.fetch_xor(1, Ordering::Relaxed);"r" assert_eq!(atom.load(Ordering::Relaxed).addr() & 1, 1);"r" Sets the bit at the specified bit-position to 1."r" Returns `true` if the specified bit was previously set to 1."r" `bit_set` takes an [`Ordering`] argument which describes the memory ordering"r" This corresponds to x86's `lock bts`, and the implementation calls them on x86/x86_64."r" assert!(!atom.bit_set(0, Ordering::Relaxed));"r" Clears the bit at the specified bit-position to 1."r" `bit_clear` takes an [`Ordering`] argument which describes the memory ordering"r" This corresponds to x86's `lock btr`, and the implementation calls them on x86/x86_64."r" assert!(atom.bit_set(0, Ordering::Relaxed));"r" // Untag"r" assert!(atom.bit_clear(0, Ordering::Relaxed));"r" Toggles the bit at the specified bit-position."r" `bit_toggle` takes an [`Ordering`] argument which describes the memory ordering"r" This corresponds to x86's `lock btc`, and the implementation calls them on x86/x86_64."r" atom.bit_toggle(0, Ordering::Relaxed);"as_atomic_usizer" Returns a mutable pointer to the underlying pointer."// Atomic{I,U}* impls// AtomicF* implsr" Returns a mutable pointer to the underlying integer."// See https://github.com/taiki-e/portable-atomic/issues/180/*!
<!-- Note: Document from sync-markdown-to-rustdoc:start through sync-markdown-to-rustdoc:end
     is synchronized from README.md. Any changes to that range are not preserved. -->
<!-- tidy:sync-markdown-to-rustdoc:start -->

Portable atomic types including support for 128-bit atomics, atomic float, etc.

- Provide all atomic integer types (`Atomic{I,U}{8,16,32,64}`) for all targets that can use atomic CAS. (i.e., all targets that can use `std`, and most no-std targets)
- Provide `AtomicI128` and `AtomicU128`.
- Provide `AtomicF32` and `AtomicF64`. ([optional, requires the `float` feature](#optional-features-float))
- Provide `AtomicF16` and `AtomicF128` for [unstable `f16` and `f128`](https://github.com/rust-lang/rust/issues/116909). ([optional, requires the `float` feature and unstable cfgs](#optional-features-float))
- Provide atomic load/store for targets where atomic is not available at all in the standard library. (RISC-V without A-extension, MSP430, AVR)
- Provide atomic CAS for targets where atomic CAS is not available in the standard library. (thumbv6m, pre-v6 Arm, RISC-V without A-extension, MSP430, AVR, Xtensa, etc.) (always enabled for MSP430 and AVR, [optional](#optional-features-critical-section) otherwise)
- Provide stable equivalents of the standard library's atomic types' unstable APIs, such as [`AtomicPtr::fetch_*`](https://github.com/rust-lang/rust/issues/99108).
- Make features that require newer compilers, such as [`fetch_{max,min}`](https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.fetch_max), [`fetch_update`](https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update), [`as_ptr`](https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.as_ptr), [`from_ptr`](https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.from_ptr), [`AtomicBool::fetch_not`](https://doc.rust-lang.org/std/sync/atomic/struct.AtomicBool.html#method.fetch_not) and [stronger CAS failure ordering](https://github.com/rust-lang/rust/pull/98383) available on Rust 1.34+.
- Provide workaround for bugs in the standard library's atomic-related APIs, such as [rust-lang/rust#100650], `fence`/`compiler_fence` on MSP430 that cause LLVM error, etc.

<!-- TODO:
- mention Atomic{I,U}*::fetch_neg, Atomic{I*,U*,Ptr}::bit_*, etc.
- mention optimizations not available in the standard library's equivalents
-->

portable-atomic version of `std::sync::Arc` is provided by the [portable-atomic-util](https://github.com/taiki-e/portable-atomic/tree/HEAD/portable-atomic-util) crate.

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
portable-atomic = "1"
```

The default features are mainly for users who use atomics larger than the pointer width.
If you don't need them, disabling the default features may reduce code size and compile time slightly.

```toml
[dependencies]
portable-atomic = { version = "1", default-features = false }
```

If your crate supports no-std environment and requires atomic CAS, enabling the `require-cas` feature will allow the `portable-atomic` to display a [helpful error message](https://github.com/taiki-e/portable-atomic/pull/100) to users on targets requiring additional action on the user side to provide atomic CAS.

```toml
[dependencies]
portable-atomic = { version = "1.3", default-features = false, features = ["require-cas"] }
```

## 128-bit atomics support

Native 128-bit atomic operations are available on x86_64 (Rust 1.59+), AArch64 (Rust 1.59+), riscv64 (Rust 1.59+), Arm64EC (Rust 1.84+), s390x (Rust 1.84+), and powerpc64 (nightly only), otherwise the fallback implementation is used.

On x86_64, even if `cmpxchg16b` is not available at compile-time (Note: `cmpxchg16b` target feature is enabled by default only on Apple, Windows (except Windows 7), and Fuchsia targets), run-time detection checks whether `cmpxchg16b` is available. If `cmpxchg16b` is not available at either compile-time or run-time detection, the fallback implementation is used. See also [`portable_atomic_no_outline_atomics`](#optional-cfg-no-outline-atomics) cfg.

They are usually implemented using inline assembly, and when using Miri or ThreadSanitizer that do not support inline assembly, core intrinsics are used instead of inline assembly if possible.

See the [`atomic128` module's readme](https://github.com/taiki-e/portable-atomic/blob/HEAD/src/imp/atomic128/README.md) for details.

## Optional features

- **`fallback`** *(enabled by default)*<br>
  Enable fallback implementations.

  Disabling this allows only atomic types for which the platform natively supports atomic operations.

- <a name="optional-features-float"></a>**`float`**<br>
  Provide `AtomicF{32,64}`.

  - When unstable `--cfg portable_atomic_unstable_f16` is also enabled, `AtomicF16` for [unstable `f16`](https://github.com/rust-lang/rust/issues/116909) is also provided.
  - When unstable `--cfg portable_atomic_unstable_f128` is also enabled, `AtomicF128` for [unstable `f128`](https://github.com/rust-lang/rust/issues/116909) is also provided.

  Note:
  - Atomic float's `fetch_{add,sub,min,max}` are usually implemented using CAS loops, which can be slower than equivalent operations of atomic integers. As an exception, AArch64 with FEAT_LSFE and GPU targets have atomic float instructions and we use them on AArch64 when `lsfe` target feature is available at compile-time. We [plan to use atomic float instructions for GPU targets as well in the future.](https://github.com/taiki-e/portable-atomic/issues/34))
  - Unstable cfgs are outside of the normal semver guarantees and minor or patch versions of portable-atomic may make breaking changes to them at any time.

- **`std`**<br>
  Use `std`.

- <a name="optional-features-require-cas"></a>**`require-cas`**<br>
  Emit compile error if atomic CAS is not available. See [Usage](#usage) section and [#100](https://github.com/taiki-e/portable-atomic/pull/100) for more.

- <a name="optional-features-serde"></a>**`serde`**<br>
  Implement `serde::{Serialize,Deserialize}` for atomic types.

  Note:
  - The MSRV when this feature is enabled depends on the MSRV of [serde].

- <a name="optional-features-critical-section"></a>**`critical-section`**<br>
  When this feature is enabled, this crate uses [critical-section] to provide atomic CAS for targets where
  it is not natively available. When enabling it, you should provide a suitable critical section implementation
  for the current target, see the [critical-section] documentation for details on how to do so.

  `critical-section` support is useful to get atomic CAS when the [`unsafe-assume-single-core` feature](#optional-features-unsafe-assume-single-core) can't be used,
  such as multi-core targets, unprivileged code running under some RTOS, or environments where disabling interrupts
  needs extra care due to e.g. real-time requirements.

  Note that with the `critical-section` feature, critical sections are taken for all atomic operations, while with
  [`unsafe-assume-single-core` feature](#optional-features-unsafe-assume-single-core) some operations don't require disabling interrupts (loads and stores, but
  additionally on MSP430 `add`, `sub`, `and`, `or`, `xor`, `not`). Therefore, for better performance, if
  all the `critical-section` implementation for your target does is disable interrupts, prefer using
  `unsafe-assume-single-core` feature instead.

  Note:
  - The MSRV when this feature is enabled depends on the MSRV of [critical-section].
  - It is usually *not* recommended to always enable this feature in dependencies of the library.

    Enabling this feature will prevent the end user from having the chance to take advantage of other (potentially) efficient implementations ([Implementations provided by `unsafe-assume-single-core` feature, default implementations on MSP430 and AVR](#optional-features-unsafe-assume-single-core), implementation proposed in [#60], etc. Other systems may also be supported in the future).

    The recommended approach for libraries is to leave it up to the end user whether or not to enable this feature. (However, it may make sense to enable this feature by default for libraries specific to a platform where other implementations are known not to work.)

    As an example, the end-user's `Cargo.toml` that uses a crate that provides a critical-section implementation and a crate that depends on portable-atomic as an option would be expected to look like this:

    ```toml
    [dependencies]
    portable-atomic = { version = "1", default-features = false, features = ["critical-section"] }
    crate-provides-critical-section-impl = "..."
    crate-uses-portable-atomic-as-feature = { version = "...", features = ["portable-atomic"] }
    ```

- <a name="optional-features-unsafe-assume-single-core"></a>**`unsafe-assume-single-core`**<br>
  Assume that the target is single-core.
  When this feature is enabled, this crate provides atomic CAS for targets where atomic CAS is not available in the standard library by disabling interrupts.

  This feature is `unsafe`, and note the following safety requirements:
  - Enabling this feature for multi-core systems is always **unsound**.
  - This uses privileged instructions to disable interrupts, so it usually doesn't work on unprivileged mode.
    Enabling this feature in an environment where privileged instructions are not available, or if the instructions used are not sufficient to disable interrupts in the system, it is also usually considered **unsound**, although the details are system-dependent.

    The following are known cases:
    - On pre-v6 Arm, this disables only IRQs by default. For many systems (e.g., GBA) this is enough. If the system need to disable both IRQs and FIQs, you need to enable the `disable-fiq` feature together.
    - On RISC-V without A-extension, this generates code for machine-mode (M-mode) by default. If you enable the `s-mode` together, this generates code for supervisor-mode (S-mode). In particular, `qemu-system-riscv*` uses [OpenSBI](https://github.com/riscv-software-src/opensbi) as the default firmware.

    See also the [`interrupt` module's readme](https://github.com/taiki-e/portable-atomic/blob/HEAD/src/imp/interrupt/README.md).

  Consider using the [`critical-section` feature](#optional-features-critical-section) for systems that cannot use this feature.

  It is **very strongly discouraged** to enable this feature in libraries that depend on `portable-atomic`. The recommended approach for libraries is to leave it up to the end user whether or not to enable this feature. (However, it may make sense to enable this feature by default for libraries specific to a platform where it is guaranteed to always be sound, for example in a hardware abstraction layer targeting a single-core chip.)

  Armv6-M (thumbv6m), pre-v6 Arm (e.g., thumbv4t, thumbv5te), RISC-V without A-extension, and Xtensa are currently supported.

  Since all MSP430 and AVR are single-core, we always provide atomic CAS for them without this feature.

  Enabling this feature for targets that have atomic CAS will result in a compile error.

  Feel free to submit an issue if your target is not supported yet.

## Optional cfg

One of the ways to enable cfg is to set [rustflags in the cargo config](https://doc.rust-lang.org/cargo/reference/config.html#targettriplerustflags):

```toml
# .cargo/config.toml
[target.<target>]
rustflags = ["--cfg", "portable_atomic_no_outline_atomics"]
```

Or set environment variable:

```sh
RUSTFLAGS="--cfg portable_atomic_no_outline_atomics" cargo ...
```

- <a name="optional-cfg-unsafe-assume-single-core"></a>**`--cfg portable_atomic_unsafe_assume_single_core`**<br>
  Since 1.4.0, this cfg is an alias of [`unsafe-assume-single-core` feature](#optional-features-unsafe-assume-single-core).

  Originally, we were providing these as cfgs instead of features, but based on a strong request from the embedded ecosystem, we have agreed to provide them as features as well. See [#94](https://github.com/taiki-e/portable-atomic/pull/94) for more.

- <a name="optional-cfg-no-outline-atomics"></a>**`--cfg portable_atomic_no_outline_atomics`**<br>
  Disable dynamic dispatching by run-time CPU feature detection.

  If dynamic dispatching by run-time CPU feature detection is enabled, it allows maintaining support for older CPUs while using features that are not supported on older CPUs, such as CMPXCHG16B (x86_64) and FEAT_LSE/FEAT_LSE2 (AArch64).

  Note:
  - Dynamic detection is currently only supported in x86_64, AArch64, Arm, RISC-V, Arm64EC, and powerpc64, otherwise it works the same as when this cfg is set.
  - If the required target features are enabled at compile-time, the atomic operations are inlined.
  - This is compatible with no-std (as with all features except `std`).
  - On some targets, run-time detection is disabled by default mainly for compatibility with incomplete build environments or support for it is experimental, and can be enabled by `--cfg portable_atomic_outline_atomics`. (When both cfg are enabled, `*_no_*` cfg is preferred.)
  - Some AArch64 targets enable LLVM's `outline-atomics` target feature by default, so if you set this cfg, you may want to disable that as well. (portable-atomic's outline-atomics does not depend on the compiler-rt symbols, so even if you need to disable LLVM's outline-atomics, you may not need to disable portable-atomic's outline-atomics.)

  See also the [`atomic128` module's readme](https://github.com/taiki-e/portable-atomic/blob/HEAD/src/imp/atomic128/README.md).

## Related Projects

- [atomic-maybe-uninit]: Atomic operations on potentially uninitialized integers.
- [atomic-memcpy]: Byte-wise atomic memcpy.

[#60]: https://github.com/taiki-e/portable-atomic/issues/60
[atomic-maybe-uninit]: https://github.com/taiki-e/atomic-maybe-uninit
[atomic-memcpy]: https://github.com/taiki-e/atomic-memcpy
[critical-section]: https://github.com/rust-embedded/critical-section
[rust-lang/rust#100650]: https://github.com/rust-lang/rust/issues/100650
[serde]: https://github.com/serde-rs/serde

<!-- tidy:sync-markdown-to-rustdoc:end -->
*/// module-level #![allow(missing_docs)] doesn't work for macros on old rustc// asm_experimental_arch// AVR, MSP430, and Xtensa are tier 3 platforms and require nightly anyway.// On tier 2 platforms (powerpc64), we use cfg set by build script to// determine whether this feature is available or not.// f16/f128// cfg is unstable and explicitly enabled by the user// Old nightly only// These features are already stabilized or have already been removed from compilers,// and can safely be enabled for old nightly as long as version detection works.// - cfg(target_has_atomic)// - asm! on AArch64, Arm, RISC-V, x86, x86_64, Arm64EC, s390x// - llvm_asm! on AVR (tier 3) and MSP430 (tier 3)// - #[instruction_set] on non-Linux/Android pre-v6 Arm (tier 3)// This also helps us test that our assembly code works with the minimum external// LLVM version of the first rustc version that inline assembly stabilized.// Miri and/or ThreadSanitizer only// They do not support inline assembly, so we need to use unstable features instead.// Since they require nightly compilers anyway, we can use the unstable features.// This is not an ideal situation, but it is still better than always using lock-based// fallback and causing memory ordering problems to be missed by these checkers.// docs.rs only (cfg is enabled by docs.rs, not build script)// cfg_has_atomic_8!// cfg_has_atomic_ptr!// cfg_no_atomic_cas!helper__test_atomic_common__test_atomic_pub_common__test_atomic_int_load_store__test_atomic_float_load_store__test_atomic_bool_load_store__test_atomic_ptr_load_store__test_atomic_int__test_atomic_float__test_atomic_bool__test_atomic_ptr__test_atomic_int_pub__test_atomic_float_pub__test_atomic_bool_pub__test_atomic_ptr_pubtest_atomic_ptrtest_atomic_int_pubtest_atomic_bool_pubtest_atomic_ptr_pubassert_panic// for old rustcrand_load_orderingtest_load_orderingrand_store_orderingtest_store_orderingrand_compare_exchange_orderingtest_compare_exchange_orderingrand_swap_orderingtest_swap_orderingstress_test_config// for stress test generated by __test_atomic_* macrosskip_should_panic_testis_panic_abort// For -C panic=abort -Z panic_abort_tests: https://github.com/rust-lang/rust/issues/67650LOAD_ORDERINGSSTORE_ORDERINGSSWAP_ORDERINGSCOMPARE_EXCHANGE_ORDERINGSAlign16__stress_test_acquire_release// Test the cases that should not fail if the memory ordering is implemented correctly.// This is still not exhaustive and only tests a few cases.// This currently only supports 32-bit or more integers.__stress_test_seqcstcatch_unwind_on_weak_memory_arch// Catches unwinding panic on architectures with weak memory models.catch_unwind_on_non_seqcst_arch// Catches unwinding panic on architectures with non-sequentially consistent memory models."../../version.rs"test_helperassert_auto_traitsaccessorstatic_load_onlyassert_ref_unwind_safetest_atomic_boolsptrStrictptr_add_nullptr_add_dataptr_bitopsptr_bitops_tagging_atomic_bool_ffi_safety_atomic_ptr_ffi_safety_atomic_isize_ffi_safety_atomic_usize_ffi_safety_atomic_i8_ffi_safety_atomic_u8_ffi_safety_atomic_i16_ffi_safety_atomic_u16_ffi_safety_atomic_i32_ffi_safety_atomic_u32_ffi_safety_atomic_i64_ffi_safety_atomic_u64_ffi_safetytest_is_lock_freetest_rustc_version// test version parsing code used in the build script."gen/utils.rs"_assert_is_boolstatic_assert_layout// #[doc = concat!(...)] requires Rust 1.54ifunc// Adapted from https://github.com/BurntSushi/memchr/blob/2.4.1/src/memchr/x86/mod.rs#L9-L71./// - the caller must uphold the safety contract for the function returned by $detect_body./// - the memory pointed by the function pointer returned by $detect_body must be visible from any threads./// The second requirement is always met if the function pointer is to the function definition./// (Currently, all uses of this macro in our code are in this case.)// TODO(f16_and_f128): Implement serde traits for f16 & f128 once stabilized./// Implements `core::fmt::Debug` and `serde::{Serialize, Deserialize}` (when serde/// feature is enabled) for atomic bool, integer, or float.// We do not provide `nand` because it cannot be optimized on neither x86 nor MSP430.// https://godbolt.org/z/ahWejchbT// This just outputs the input as is, but can be used like an item-level block by using it with cfg.assert_unchecked// Stable version of https://doc.rust-lang.org/nightly/std/hint/fn.assert_unchecked.html.// TODO: use real core::hint::assert_unchecked on 1.81+ https://github.com/rust-lang/rust/pull/123588assert_load_ordering// https://github.com/rust-lang/rust/blob/1.84.0/library/core/src/sync/atomic.rs#L3338assert_store_ordering// https://github.com/rust-lang/rust/blob/1.84.0/library/core/src/sync/atomic.rs#L3323assert_compare_exchange_ordering// https://github.com/rust-lang/rust/blob/1.84.0/library/core/src/sync/atomic.rs#L3404upgrade_success_ordering// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0418r2.html// https://github.com/rust-lang/rust/pull/98383whole/// A 128-bit value represented as a pair of 64-bit values./// This type is `#[repr(C)]`, both fields have the same in-memory representation/// and are plain old data types, so access to the fields is always safe.// little endian orderwith_exposed_provenancewith_exposed_provenance_mut// This module provides core::ptr strict_provenance/exposed_provenance polyfill for pre-1.84 rustc.// c_{,u}long is {i,u}64 on non-Windows 64-bit targets, otherwise {i,u}32.// https://github.com/rust-lang/rust/blob/1.84.0/library/core/src/ffi/mod.rs#L168// c_size_t is currently always usize.// https://github.com/rust-lang/rust/blob/1.84.0/library/core/src/ffi/mod.rs#L76// Static assertions for C type definitions.from_bytes_with_nul_unchecked/// The provided slice **must** be nul-terminated and not contain any interior/// nul bytes.to_bytes_with_nul_const_is_c_str/// Defines types with #[cfg(test)] static assertions which checks/// types are the same as the platform's latest header files' ones.// Note: This macro is sys_ty!({ }), not sys_ty! { }.// An extra brace is used in input to make contents rustfmt-able./// Defines #[repr(C)] structs with #[cfg(test)] static assertions which checks/// fields are the same as the platform's latest header files' ones.// Note: This macro is sys_struct!({ }), not sys_struct! { }./// Defines constants with #[cfg(test)] static assertions which checks/// values are the same as the platform's latest header files' ones.// Note: This macro is sys_const!({ }), not sys_const! { }.sys_const_cmp/// Defines functions with #[cfg(test)] static assertions which checks/// signatures are the same as the platform's latest header files' ones.// Note: This macro is sys_fn!({ }), not sys_fn! { }.sys_fn_cmptest_c_macrotest_is_c_str// This module provides:// - core::ffi polyfill (c_* type aliases and CStr) for pre-1.64 rustc compatibility.//   (core::ffi::* (except c_void) requires Rust 1.64)// - safe abstraction (c! macro) for creating static C strings without runtime checks.//   (c"..." requires Rust 1.77)// - helper macros for defining FFI bindings.commit_dateLATEST// The known latest stable version. If we unable to determine// the rustc version, we assume this is the current version.// It is no problem if this is older than the actual latest stable.// LLVM version is assumed to be the minimum external LLVM version:// https://github.com/rust-lang/rust/blob/1.87.0/src/bootstrap/src/core/build_steps/llvm.rs#L617WriteBuffer/// A buffer for construct a string while avoiding heap allocation./// The only requirement is that the buffer is large enough to hold the formatted string./// Creates an empty buffer./// Obtain the contents of the buffer as a string./// Determine how many bytes are remaining in the buffer.RIGHT_SIZELEFT_SIZEmaybe_uninit_uninit_array/// Equivalent of [`MaybeUninit::uninit_array`] that compiles on stable.maybe_uninit_write_slice/// Equivalent of [`MaybeUninit::write_slice`] that compiles on stable.maybe_uninit_slice_assume_init_mut/// Equivalent of [`MaybeUninit::slice_assume_init_mut`] that compiles on stable./// See [`MaybeUninit::slice_assume_init_mut`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#method.slice_assume_init_mut).maybe_uninit_slice_assume_init_ref/// Equivalent of [`MaybeUninit::slice_assume_init_ref`] that compiles on stable./// See [`MaybeUninit::slice_assume_init_ref`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#method.slice_assume_init_ref).//! A buffer for constructing a string while avoiding heap allocation.pad_with_width/// Writes the given arguments to the formatter, padding them with the given width. If `width`/// is incorrect, the resulting output will not be the requested width.FormatterExt/// An extension trait for [`core::fmt::Formatter`].//! Extension traits.smart_display_impls//! `powerfmt` is a library that provides utilities for formatting values. Specifically, it makes it//! significantly easier to support filling to a minimum width with alignment, avoid heap//! allocation, and avoid repetitive calculations.__not_public_at_root__padded_width_of// Base case// Options base case// Options entry point// Entry point// This is done with `#[cfg(doc)]` to avoid showing the various rules.padded_width_ofFlagBitSignPlusSignMinusSignAwareZeroPadWidthIsInitializedPrecisionIsInitialized/// Configuration for formatting./// This struct is obtained from a [`Formatter`]. It provides the same functionality as that of a/// reference to a `Formatter`. However, it is not possible to construct a `Formatter`, which is/// necessary for some use cases of [`SmartDisplay`]. `FormatterOptions` implements [`Default`] and/// has builder methods to alleviate this.with_fill/// Sets the fill character to use whenever there is alignment.with_sign_plus/// Set whether the `+` flag is specified.with_sign_minus/// Set whether the `-` flag is specified.with_align/// Set the flag indicating what form of alignment is requested, if any.with_width/// Set the optional integer width that the output should be.with_precision/// Set the optional precision for numeric types. Alternatively, the maximum width for stringwith_alternate/// Set whether the `#` flag is specified.with_sign_aware_zero_pad/// Set whether the `0` flag is specified./// Character used as 'fill' whenever there is alignment./// Flag indicating what form of alignment was requested./// Optionally specified integer width that the output should be./// Optionally specified precision for numeric types. Alternatively, the maximum width for/// string types.sign_plus/// Determines if the `+` flag was specified.sign_minus/// Determines if the `-` flag was specified.alternate/// Determines if the `#` flag was specified.sign_aware_zero_pad/// Determines if the `0` flag was specified.unpadded_width_value// variance/// Information used to format a value. This is returned by [`SmartDisplay::metadata`]./// This type is generic over any user-provided type. This allows the author to store any/// information that is needed. For example, a type's implementation of [`SmartDisplay`] may need/// to calculate something before knowing its width. This calculation can be performed, with the/// result being stored in the custom metadata type./// Note that `Metadata` _always_ contains the width of the type. Authors do not need to store this/// information in their custom metadata type./// Generally speaking, a type should be able to be formatted using only its metadata, fields, and/// the formatter. Any other information should be stored in the metadata type.// manual impls for bounds/// Creates a new `Metadata` with the given width and metadata. While the width _should_ be/// exact, this is not a requirement for soundness./// Reuse the metadata for another type. This is useful when implementing [`SmartDisplay`] for a/// type that wraps another type. Both type's metadata type must be the same./// Obtain the width of the value before padding.padded_width/// Obtain the width of the value after padding.unpadded_width_of/// Obtain the width of the value before padding, given the formatter options./// Obtain the width of the value after padding, given the formatter options./// Permit using `Metadata` as a smart pointer to the user-provided metadata./// User-provided metadata type./// Compute any information needed to format the value. This must, at a minimum, determine the/// width of the value before any padding is added by the formatter./// If the type uses other types that implement `SmartDisplay` verbatim, the inner types should/// have their metadata calculated and included in the returned value./// # Lifetimes/// This method's return type contains a lifetime to `self`. This ensures that the metadata will/// neither outlive the value nor be invalidated by a mutation of the value (barring interior/// mutability)./// # use std::fmt;/// # use std::fmt::Write;/// # use powerfmt::buf::WriteBuffer;/// # use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};/// struct WrappedBuffer(WriteBuffer<128>);/// #[smart_display::delegate]/// impl SmartDisplay for WrappedBuffer {///     type Metadata = ();///     fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {///         Metadata::new(self.0.len(), self, ())///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {///         f.pad(self.0.as_str())/// let mut buf = WrappedBuffer(WriteBuffer::new());/// let metadata = buf.metadata(FormatterOptions::default());/// // We cannot mutate the buffer while it is borrowed and use its previous metadata on the/// // following line./// write!(buf.0, "Hello, world!")?;/// assert_eq!(metadata.width(), 13);/// Format the value using the given formatter and metadata. The formatted output should have/// the width indicated by the metadata. This is before any padding is added by the/// formatter./// If the metadata is not needed, you should implement the `fmt` method instead./// Format the value using the given formatter. This is the same as [`Display::fmt`]./// The default implementation of this method calls `fmt_with_metadata` with the result of/// `metadata`. Generally speaking, this method should not be implemented. You should implement/// the `fmt_with_metadata` method instead./// Format trait that allows authors to provide additional information./// This trait is similar to [`Display`], but allows the author to provide additional information/// to the formatter. This information is provided in the form of a custom metadata type./// The only required piece of metadata is the width of the value. This is _before_ it is passed to/// the formatter (i.e. it does not include any padding added by the formatter). Other information/// can be stored in a custom metadata type as needed. This information may be made available to/// downstream users, but it is not required./// **Note**: While both `fmt_with_metadata` and `fmt` have default implementations, it is strongly/// recommended to implement only `fmt_with_metadata`. `fmt` should be implemented if and only if/// the type does not require any of the calculated metadata. In that situation, `fmt_with_metadata`/// should be omitted.//! Definition of [`SmartDisplay`] and its related items.//! [`SmartDisplay`] is a trait that allows authors to provide additional information to both the//! formatter and other users. This information is provided in the form of a metadata type. The only//! required piece of metadata is the width of the value. This is _before_ it is passed to the//! formatter (i.e. it does not include any padding added by the formatter). Other information//! can be stored in a custom metadata type as needed. This information may be made available to//! downstream users, but it is not required.//! This module contains the [`SmartDisplay`] and associated items.//! use powerfmt::ext::FormatterExt as _;//! use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};//! struct User {//!     id: usize,//! // If you try to use `UserMetadata` in the `SmartDisplay` implementation, you will get a//! // compiler error about a private type being used publicly. To avoid this, use this attribute to//! // declare a private metadata type. You shouldn't need to worry about how this works, but be//! // aware that any public fields or methods remain usable by downstream users.//! #[smart_display::private_metadata]//! struct UserMetadata {//!     username: String,//!     legal_name: String,//! // This attribute can be applied to `SmartDisplay` implementations. It will generate an//! // implementation of `Display` that delegates to `SmartDisplay`, avoiding the need to write//! // boilerplate.//! #[smart_display::delegate]//! impl SmartDisplay for User {//!     type Metadata = UserMetadata;//!     fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {//!         // This could be obtained from a database, for example.//!         let legal_name = "John Doe".to_owned();//!         let username = "jdoe".to_owned();//!         // Note that this must be kept in sync with the implementation of `fmt_with_metadata`.//!         let width = smart_display::padded_width_of!(username, " (", legal_name, ")",);//!         Metadata::new(//!             width,//!             self,//!             UserMetadata {//!                 username,//!                 legal_name,//!     // Use the now-generated metadata to format the value. Here we use the `pad_with_width`//!     // method to use the alignment and desired width from the formatter.//!     fn fmt_with_metadata(//!         f: &mut fmt::Formatter<'_>,//!         metadata: Metadata<Self>,//!     ) -> fmt::Result {//!         f.pad_with_width(//!             metadata.unpadded_width(),//!             format_args!("{} ({})", metadata.username, metadata.legal_name),//! let user = User { id: 42 };//! assert_eq!(user.to_string(), "jdoe (John Doe)");//! assert_eq!(format!("{user:>20}"), "     jdoe (John Doe)");/// Implement [`SmartDisplay`] for unsigned integers./// Implement [`SmartDisplay`] for signed integers.//! Implementation of [`SmartDisplay`] for various types.x4vec128_storagevec256_storagenew128split128vec512_storagedmapdmap2qmapqmap2o_of_qq_of_oomapomap2u128x1_genericRotateEachWord128BitOps128BitOps64u64x2_genericBitOps32u32x4_genericBitOps0impl_bitopsrotate_each_word_right7rotate_each_word_right8rotate_each_word_right11rotate_each_word_right12rotate_each_word_right16rotate_each_word_right20rotate_each_word_right24rotate_each_word_right25RotateEachWord32rotate_each_word_right32RotateEachWord64rotate_u128_right// workaround for koute/cargo-web#52 (u128::rotate_* broken with cargo web)test_rotate_u128GenericMachineu32x4u64x2u128x1u32x4x2u32x4x2_genericu64x2x2u64x2x2_genericu64x4_genericu128x2u128x2_genericu32x4x4u32x4x4_genericu64x2x4u64x2x4_genericu128x4u128x4_genericMachineArithOpsbswapBSwapunsafe_read_leunsafe_read_beStoreBytesto_scalarsto_lanesfrom_lanesMultiLaneVec4shuffle2301shuffle1230shuffle3012Words4shuffle_lane_words2301shuffle_lane_words1230shuffle_lane_words3012LaneWords4dispatch_light128dispatch_light256dispatch_light512test_bswap32// Design:// - safety: safe creation of any machine type is done only by instance methods of a//   Machine (which is a ZST + Copy type), which can only by created unsafely or safely//   through feature detection (e.g. fn AVX2::try_get() -> Option<Machine>).fwd_binop_x2fwd_binop_assign_x2fwd_unop_x2andnotAndNotswap1swap2swap4swap8swap16swap32swap64Swap64fwd_binop_x4fwd_binop_assign_x4fwd_unop_x4transpose4Vec4Ext//! Implement 256- and 512- bit in terms of 128-bit, for machines without native wide SIMD./// Ops that depend on word size/// Ops that are independent of word size and endian/// A vector composed of two elements, which may be words or themselves vectors./// A vector composed of four elements, which may be words or themselves vectors./// Vec4 functions which may not be implemented yet for all Vec4 types./// NOTE: functions in this trait may be moved to Vec4 in any patch release. To avoid breakage,/// import Vec4Ext only together with Vec4, and don't qualify its methods.// TODO: multiples of 4 should inherit this/// A vector composed of four words; depending on their size, operations may cross lanes./// A vector composed one or more lanes each composed of four words.// TODO: make this a part of BitOps/// Exchange neigboring ranges of bits of the specified size// TODO: Words4/// Split a multi-lane vector into single-lane vectors./// Build a multi-lane vector from individual lanes./// A vector composed of multiple 128-bit lanes.vzipVZip/// Combine single vectors into a multi-lane vector.read_le/// Caller must ensure the type of Self is appropriate for the hardware of the execution// Vector type naming scheme:// uN[xP]xL// Unsigned; N-bit words * P bits per lane * L lanes// A lane is always 128-bits, chosen because common SIMD architectures treat 128-bit units of// wide vectors specially (supporting e.g. intra-lane shuffles), and tend to have limited and// slow inter-lane operations.YesS3NoS3YesS4NoS4YesA1NoA1YesA2NoA2YesNINoNINISseMachineu32x4_sse2u64x2_sse2u128x1_sse2u32x4x2_sse2u64x2x2_sse2u64x4_sse2u128x2_sse2u32x4x4_sse2u64x2x4_sse2u128x4_sse2Avx2Machineu32x4x2_avx2u32x4x4_avx2SSE2SSSE3SSE41AVX/// AVX but not AVX2: only 128-bit integer operations, but use VEX versions of everything/// to avoid expensive SSE/VEX conflicts./// Generic wrapper for unparameterized storage of any of the possible impls./// Converting into and out of this type should be essentially free, although it may be more/// aligned than a particular impl requires.avxu32x16u64x8impl_into/// Generate the full set of optimized implementations to take advantage of the most important/// hardware feature sets./// This dispatcher is suitable for maximizing throughput./// Generate only the basic implementations necessary to be able to operate efficiently on 128-bit/// vectors on this platfrom. For x86-64, that would mean SSE2 and AVX./// This dispatcher is suitable for vector operations that do not benefit from advanced hardware/// features (e.g. because they are done infrequently), so minimizing their contribution to code/// size is more important./// Generate only the basic implementations necessary to be able to operate efficiently on 256-bit/// vectors on this platfrom. For x86-64, that would mean SSE2, AVX, and AVX2.// crate minimums: sse2, x86_64Machine86impl_binopimpl_binop_assigndef_vecimpl_bitops32impl_bitops64impl_bitops128rotr_32_s3rotr_32rotr_64_s3rotr_64rotr_128// TODO: completely unoptimizedbswap32_s2swapiswap16_s2impl_into_xGfeq128_s4eq128_s2test_bswap32_s2_vs_s3test_bswap64_s2_vs_s3test_shuffle32_s2_vs_s3test_shuffle64_s2_vs_s3test_lanes_u32x4test_lanes_u64x2test_vec4_u32x4_s2test_vec4_u32x4_s4test_vec2_u64x2_s2test_vec4_u64x2_s4shuf_lane_bytesimpl_assignimpl_bitop//////////////////////////////////////////////////////////////////////////////////////////////// Debugging//! A Rust library providing pretty hex dump.//! A `simple_hex()` way renders one-line hex dump, and a `pretty_hex()` way renders//! columned multi-line hex dump with addressing and ASCII representation.//! A `config_hex()` way renders hex dump in specified format.//! ## Example of `simple_hex()`//! use pretty_hex::*;//! let v = vec![222, 173, 190, 239, 202, 254, 32, 24];//! assert_eq!(simple_hex(&v), format!("{}", v.hex_dump()));//! println!("{}", v.hex_dump());//! Output://! de ad be ef  ca fe 20 18//! ## Example of `pretty_hex()`//! let v = &include_bytes!("../tests/data");//! assert_eq!(pretty_hex(&v), format!("{:?}", v.hex_dump()));//! println!("{:?}", v.hex_dump());//! Length: 30 (0x1e) bytes//! 0000:   6b 4e 1a c3  af 03 d2 1e  7e 73 ba c8  bd 84 0f 83   kN......~s......//! 0010:   89 d5 cf 90  23 67 4b 48  db b1 bc 35  bf ee         ....#gKH...5..//! ## Example of `config_hex()`//! let cfg = HexConfig {title: false, width: 8, group: 0, ..HexConfig::default() };//! assert_eq!(config_hex(&v, cfg), format!("{:?}", v.hex_conf(cfg)));//! println!("{:?}", v.hex_conf(cfg));//! 0000:   6b 4e 1a c3 af 03 d2 1e   kN......//! 0008:   7e 73 ba c8 bd 84 0f 83   ~s......//! 0010:   89 d5 cf 90 23 67 4b 48   ....#gKH//! 0018:   db b1 bc 35 bf ee         ...5..simple_hex/// Returns a one-line hexdump of `source` grouped in default format without header/// and ASCII column.simple_hex_write/// Dump `source` as hex octets in default format without header and ASCII column to the `writer`./// Return a multi-line hexdump in default format complete with addressing, hex digits,/// and ASCII representation.pretty_hex_write/// Write multi-line hexdump in default format complete with addressing, hex digits,/// and ASCII representation to the writer.config_hexHexConfig/// Return a hexdump of `source` in specified format./// Write first line header with data length./// Append ASCII representation column./// Source bytes per row. 0 for single row without address prefix./// Chunks count per group. 0 for single group (column)./// Source bytes per chunk (word). 0 for single word./// Configuration parameters for hexdump./// Default configuration with `title`, `ascii`, 16 source bytes `width` grouped to 4 separate/// hex bytes. Using in `pretty_hex`, `pretty_hex_write` and `fmt::Debug` implementation./// Returns configuration for `simple_hex`, `simple_hex_write` and `fmt::Display` implementation.to_simpleNON_ASCIIhex_write/// Write hex dump in specified format.Hex/// Reference wrapper for use in arguments formatting./// Formats the value by `simple_hex_write` using the given formatter./// Formats the value by `pretty_hex_write` using the given formatter.hex_dump/// Wrap self reference for use in `std::fmt::Display` and `std::fmt::Debug`/// formatting as hex dumps.hex_conf/// formatting as hex dumps in specified format.PrettyHex/// Allows generates hex dumps to a formatter.MARGINMIN_SPACEBreaksConsistentblank_spacepre_breakpost_breakno_breakif_nonemptynever_breakBreakTokenbreaksBeginTokenPrintFrameFitsBrokenSIZE_INFINITY// Number of spaces left on lineBufEntry// Ring-buffer of tokens and calculated sizesleft_total// Total size of tokens already printedright_total// Total size of tokens enqueued, including printed and not yet printedscan_stack// Holds the ring-buffer index of the Begin that started the current block,// possibly with the most recent Break after that Begin (if there is any) on// top of it. Values are pushed and popped on the back of the queue using it// like stack, and elsewhere old values are popped from the front of the// queue as they become irrelevant due to the primary ring-buffer advancing.print_stack// Stack of blocks-in-progress being flushed by print// Level of indentation of current linepending_indentation// Buffered indentation to avoid writing trailing whitespacePrinterscan_beginscan_endscan_breakscan_stringend_with_max_widthcheck_streamadvance_leftcheck_stackprint_beginprint_endprint_breakprint_stringprint_indent// Adapted from https://github.com/rust-lang/rust/blob/1.57.0/compiler/rustc_ast_pretty/src/pp.rs.// See "Algorithm notes" in the crate-level rustdoc.PathKindAttrStyleMacroDelimiterMetaNameValueouter_attrsinner_attrsmeta_listmeta_name_valueattr_tokensvalue_of_attributehas_outerhas_innertrim_trailing_spacestrim_interior_trailing_spacescan_be_block_commentiboxcboxzerobreaknbsphardbreakspace_if_nonemptyhardbreak_if_nonemptytrailing_commatrailing_comma_or_spaceneverbreakIterDelimitedVisRestrictedfields_unnamedvis_restrictedstmtBinOpExprArrayExprAssignExprAsyncExprAwaitExprBinaryExprBlockExprBreakExprCallExprCastExprConstExprContinueExprFieldExprForLoopExprGroupExprIfExprIndexExprInferExprLetExprLitExprLoopExprMacroExprMatchExprMethodCallExprParenExprRangeExprReferenceExprRepeatExprReturnExprTryExprTryBlockExprTupleExprUnaryExprUnsafeExprWhileExprYieldFieldValueRangeLimitsStmtUnOpexpr_beginning_of_linesubexprwrap_exterior_structexpr_arrayexpr_assignexpr_asyncexpr_awaitsubexpr_awaitexpr_binaryexpr_blockexpr_breakexpr_callsubexpr_callexpr_castexpr_closureexpr_constexpr_continueexpr_fieldsubexpr_fieldexpr_for_loopexpr_groupexpr_ifexpr_indexsubexpr_indexexpr_inferexpr_letexpr_litexpr_loopexpr_macroexpr_matchexpr_method_callsubexpr_method_callexpr_parenexpr_pathexpr_rangeexpr_referenceexpr_repeatexpr_returnexpr_structexpr_trysubexpr_tryexpr_try_blockexpr_tupleexpr_unaryexpr_unsafeexpr_verbatimexpr_whileexpr_yieldfield_valuecall_argssmall_blockbinary_operatorunary_operatorzerobreak_unless_short_identrequires_terminatorcontains_exterior_struct_lit// Expressions that syntactically contain an "exterior" struct literal i.e. not// surrounded by any parens or other delimiters. For example `X { y: 1 }`, `X {// y: 1 }.method()`, `foo == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X// { y: 1 }) == foo` does not.needs_newline_if_wrapis_short_identis_blocklikeparseable_as_stmt// Expressions for which `$expr` and `{ $expr }` mean the same thing.// This is not the case for all expressions. For example `{} | x | x` has some// bitwise OR operators while `{ {} |x| x }` has a block followed by a closure.BoundLifetimesConstParamPredicateLifetimegeneric_parambound_lifetimeslifetime_paramtype_param_boundtrait_boundtrait_bound_modifiertype_param_bound_verbatimconst_paramwhere_clause_for_bodywhere_clause_semiwhere_clause_onelinewhere_clause_oneline_semiwhere_clause_implwhere_predicatepredicate_typepredicate_lifetimeForeignItemForeignItemFnForeignItemMacroForeignItemStaticForeignItemTypeImplItemConstImplItemMacroImplItemTypeItemConstItemExternCrateItemMacroItemStaticItemStructItemTraitAliasItemTypeItemUnionItemUseStaticMutabilityTraitItemMacroUseGlobUseGroupUseNameUsePathUseRenameUseTreeVariadicitem_constitem_enumitem_extern_crateitem_fnitem_foreign_moditem_implitem_macroitem_moditem_staticitem_structitem_traititem_trait_aliasitem_unionitem_useitem_verbatimuse_treeuse_pathuse_nameuse_renameuse_globuse_groupforeign_itemforeign_item_fnforeign_item_staticforeign_item_typeforeign_item_macroforeign_item_verbatimtrait_itemtrait_item_consttrait_item_fntrait_item_typetrait_item_macrotrait_item_verbatimimpl_itemimpl_item_constimpl_item_fnimpl_item_typeimpl_item_macroimpl_item_verbatimfn_argvariadicstatic_mutabilityis_firstDelimitedIteratorItemconvenience// Target line width.// Number of spaces increment at each level of block indentation.// Every line is allowed at least this much space, even if highly indented.unparse//! [![github]](https://github.com/dtolnay/prettyplease)&ensp;[![crates-io]](https://crates.io/crates/prettyplease)&ensp;[![docs-rs]](https://docs.rs/prettyplease)//! **prettyplease::unparse** &mdash; a minimal `syn` syntax tree pretty-printer//! This is a pretty-printer to turn a `syn` syntax tree into a `String` of//! well-formatted source code. In contrast to rustfmt, this library is intended//! to be suitable for arbitrary generated code.//! Rustfmt prioritizes high-quality output that is impeccable enough that you'd//! be comfortable spending your career staring at its output &mdash; but that//! means some heavyweight algorithms, and it has a tendency to bail out on code//! that is hard to format (for example [rustfmt#3697], and there are dozens//! more issues like it). That's not necessarily a big deal for human-generated//! code because when code gets highly nested, the human will naturally be//! inclined to refactor into more easily formattable code. But for generated//! code, having the formatter just give up leaves it totally unreadable.//! [rustfmt#3697]: https://github.com/rust-lang/rustfmt/issues/3697//! This library is designed using the simplest possible algorithm and data//! structures that can deliver about 95% of the quality of rustfmt-formatted//! output. In my experience testing real-world code, approximately 97-98% of//! output lines come out identical between rustfmt's formatting and this//! crate's. The rest have slightly different linebreak decisions, but still//! clearly follow the dominant modern Rust style.//! The tradeoffs made by this crate are a good fit for generated code that you//! will *not* spend your career staring at. For example, the output of//! `bindgen`, or the output of `cargo-expand`. In those cases it's more//! important that the whole thing be formattable without the formatter giving//! up, than that it be flawless.//! # Feature matrix//! Here are a few superficial comparisons of this crate against the AST//! pretty-printer built into rustc, and rustfmt. The sections below go into//! more detail comparing the output of each of these libraries.//! | | prettyplease | rustc | rustfmt |//! |:---|:---:|:---:|:---:|//! | non-pathological behavior on big or generated code | 💚 | ❌ | ❌ |//! | idiomatic modern formatting ("locally indistinguishable from rustfmt") | 💚 | ❌ | 💚 |//! | throughput | 60 MB/s | 39 MB/s | 2.8 MB/s |//! | number of dependencies | 3 | 72 | 66 |//! | compile time including dependencies | 2.4 sec | 23.1 sec | 29.8 sec |//! | buildable using a stable Rust compiler | 💚 | ❌ | ❌ |//! | published to crates.io | 💚 | ❌ | ❌ |//! | extensively configurable output | ❌ | ❌ | 💚 |//! | intended to accommodate hand-maintained source code | ❌ | ❌ | 💚 |//! # Comparison to rustfmt//! - [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)//! - [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)//! - [output.rustfmt.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustfmt.rs)//! If you weren't told which output file is which, it would be practically//! impossible to tell &mdash; **except** for line 435 in the rustfmt output,//! which is more than 1000 characters long because rustfmt just gave up//! formatting that part of the file://! # const _: &str = stringify! {{{//!             match segments[5] {//!                 0 => write!(f, "::{}", ipv4),//!                 0xffff => write!(f, "::ffff:{}", ipv4),//!                 _ => unreachable!(),//!         } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }//!         const IPV6_BUF_LEN: usize = (4 * 8) + 7;//!         let mut buf = [0u8; IPV6_BUF_LEN];//!         let mut buf_slice = &mut buf[..];//! # }};//! This is a pretty typical manifestation of rustfmt bailing out in generated//! code &mdash; a chunk of the input ends up on one line. The other//! manifestation is that you're working on some code, running rustfmt on save//! like a conscientious developer, but after a while notice it isn't doing//! anything. You introduce an intentional formatting issue, like a stray indent//! or semicolon, and run rustfmt to check your suspicion. Nope, it doesn't get//! cleaned up &mdash; rustfmt is just not formatting the part of the file you//! are working on.//! The prettyplease library is designed to have no pathological cases that//! force a bail out; the entire input you give it will get formatted in some//! "good enough" form.//! Separately, rustfmt can be problematic to integrate into projects. It's//! written using rustc's internal syntax tree, so it can't be built by a stable//! compiler. Its releases are not regularly published to crates.io, so in Cargo//! builds you'd need to depend on it as a git dependency, which precludes//! publishing your crate to crates.io also. You can shell out to a `rustfmt`//! binary, but that'll be whatever rustfmt version is installed on each//! developer's system (if any), which can lead to spurious diffs in checked-in//! generated code formatted by different versions. In contrast prettyplease is//! designed to be easy to pull in as a library, and compiles fast.//! # Comparison to rustc_ast_pretty//! - [output.rustc.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustc.rs)//! This is the pretty-printer that gets used when rustc prints source code,//! such as `rustc -Zunpretty=expanded`. It's used also by the standard//! library's `stringify!` when stringifying an interpolated macro_rules AST//! fragment, like an $:expr, and transitively by `dbg!` and many macros in the//! ecosystem.//! Rustc's formatting is mostly okay, but does not hew closely to the dominant//! contemporary style of Rust formatting. Some things wouldn't ever be written//! on one line, like this `match` expression, and certainly not with a comma in//! front of the closing brace://! # const _: &str = stringify! {//! fn eq(&self, other: &IpAddr) -> bool {//!     match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }//! Some places use non-multiple-of-4 indentation, which is definitely not the//! norm://! pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {//!     let [a, b, c, d] = self.octets();//!     Ipv6Addr{inner://!                  c::in6_addr{s6_addr://!                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,//!                                   0xFF, a, b, c, d],},}//! And although there isn't an egregious example of it in the link because the//! input code is pretty tame, in general rustc_ast_pretty has pathological//! behavior on generated code. It has a tendency to use excessive horizontal//! indentation and rapidly run out of width://! ::std::io::_print(::core::fmt::Arguments::new_v1(&[""],//!                                                  &match (&msg,) {//!                                                       _args =>//!                                                       [::core::fmt::ArgumentV1::new(_args.0,//!                                                                                     ::core::fmt::Display::fmt)],//!                                                   }));//! The snippets above are clearly different from modern rustfmt style. In//! contrast, prettyplease is designed to have output that is practically//! indistinguishable from rustfmt-formatted code.//! // [dependencies]//! // prettyplease = "0.2"//! // syn = { version = "2", default-features = false, features = ["full", "parsing"] }//! const INPUT: &str = stringify! {//!     use crate::{//!           lazy::{Lazy, SyncLazy, SyncOnceCell}, panic,//!         sync::{ atomic::{AtomicUsize, Ordering::SeqCst},//!             mpsc::channel, Mutex, },//!       thread,//!     impl<T, U> Into<U> for T where U: From<T> {//!         fn into(self) -> U { U::from(self) }//!     let syntax_tree = syn::parse_file(INPUT).unwrap();//!     let formatted = prettyplease::unparse(&syntax_tree);//!     print!("{}", formatted);//! # Algorithm notes//! The approach and terminology used in the implementation are derived from//! [*Derek C. Oppen, "Pretty Printing" (1979)*][paper], on which//! rustc_ast_pretty is also based, and from rustc_ast_pretty's implementation//! written by Graydon Hoare in 2011 (and modernized over the years by dozens of//! volunteer maintainers).//! [paper]: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/770/CS-TR-79-770.pdf//! The paper describes two language-agnostic interacting procedures `Scan()`//! and `Print()`. Language-specific code decomposes an input data structure//! into a stream of `string` and `break` tokens, and `begin` and `end` tokens//! for grouping. Each `begin`&ndash;`end` range may be identified as either//! "consistent breaking" or "inconsistent breaking". If a group is consistently//! breaking, then if the whole contents do not fit on the line, *every* `break`//! token in the group will receive a linebreak. This is appropriate, for//! example, for Rust struct literals, or arguments of a function call. If a//! group is inconsistently breaking, then the `string` tokens in the group are//! greedily placed on the line until out of space, and linebroken only at those//! `break` tokens for which the next string would not fit. For example, this is//! appropriate for the contents of a braced `use` statement in Rust.//! Scan's job is to efficiently accumulate sizing information about groups and//! breaks. For every `begin` token we compute the distance to the matched `end`//! token, and for every `break` we compute the distance to the next `break`.//! The algorithm uses a ringbuffer to hold tokens whose size is not yet//! ascertained. The maximum size of the ringbuffer is bounded by the target//! line length and does not grow indefinitely, regardless of deep nesting in//! the input stream. That's because once a group is sufficiently big, the//! precise size can no longer make a difference to linebreak decisions and we//! can effectively treat it as "infinity".//! Print's job is to use the sizing information to efficiently assign a//! "broken" or "not broken" status to every `begin` token. At that point the//! output is easily constructed by concatenating `string` tokens and breaking//! at `break` tokens contained within a broken group.//! Leveraging these primitives (i.e. cleverly placing the all-or-nothing//! consistent breaks and greedy inconsistent breaks) to yield//! rustfmt-compatible formatting for all of Rust's syntax tree nodes is a fun//! challenge.//! Here is a visualization of some Rust tokens fed into the pretty printing//! algorithm. Consistently breaking `begin`&mdash;`end` pairs are represented//! by `«`&#8288;`»`, inconsistently breaking by `‹`&#8288;`›`, `break` by `·`,//! and the rest of the non-whitespace are `string`.//! use crate::«{·//! ‹    lazy::«{·‹Lazy,· SyncLazy,· SyncOnceCell›·}»,·//!     panic,·//!     sync::«{·//! ‹        atomic::«{·‹AtomicUsize,· Ordering::SeqCst›·}»,·//!         mpsc::channel,· Mutex›,·//!     }»,·//!     thread›,·//! }»;·//! «‹«impl<«·T‹›,· U‹›·»>» Into<«·U·»>· for T›·//! where·//!     U:‹ From<«·T·»>›,·//! {·//! «    fn into(·«·self·») -> U {·//! ‹        U::from(«·self·»)›·//! »    }·//! »}·//! The algorithm described in the paper is not quite sufficient for producing//! well-formatted Rust code that is locally indistinguishable from rustfmt's//! style. The reason is that in the paper, the complete non-whitespace contents//! are assumed to be independent of linebreak decisions, with Scan and Print//! being only in control of the whitespace (spaces and line breaks). In Rust as//! idiomatically formatted by rustfmt, that is not the case. Trailing commas//! are one example; the punctuation is only known *after* the broken vs//! non-broken status of the surrounding group is known://! # struct Struct { x: u64, y: bool }//! # let xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 0;//! # let yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = true;//! let _ = Struct { x: 0, y: true };//! let _ = Struct {//!     x: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,//!     y: yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,   //<- trailing comma if the expression wrapped//! The formatting of `match` expressions is another case; we want small arms on//! the same line as the pattern, and big arms wrapped in a brace. The presence//! of the brace punctuation, comma, and semicolon are all dependent on whether//! the arm fits on the line://! # struct Entry { nanos: u32 }//! # let total_nanos = 0u64;//! # let mut total_secs = 0u64;//! # let tmp;//! # let entry = Entry { nanos: 0 };//! # const NANOS_PER_SEC: u32 = 1_000_000_000;//! match total_nanos.checked_add(entry.nanos as u64) {//!     Some(n) => tmp = n,   //<- small arm, inline with comma//!     None => {//!         total_secs = total_secs//!             .checked_add(total_nanos / NANOS_PER_SEC as u64)//!             .expect("overflow in iter::sum over durations");//!     }   //<- big arm, needs brace added, and also semicolon^//! The printing algorithm implementation in this crate accommodates all of//! these situations with conditional punctuation tokens whose selection can be//! deferred and populated after it's known that the group is or is not broken.LitBoolLitByteLitByteStrLitCStrLitCharLitFloatlit_strlit_byte_strlit_c_strlit_bytelit_charlit_intlit_floatlit_boollit_verbatimmacro_rulesmacro_rules_tokensis_keywordFieldPatPatOrPatParenPatReferencePatRestPatSlicePatTuplePatWildpat_identpat_orpat_parenpat_referencepat_restpat_slicepat_structpat_tuplepat_tuple_structpat_typepat_verbatimpat_wildfield_patAngleBracketedGenericArgumentsAssocConstAssocTypeConstraintParenthesizedGenericArguments// a::B// a::B<T>// a::B::<T>path_segmentpath_argumentsangle_bracketed_generic_argumentsassoc_typeassoc_constconstraintparenthesized_generic_argumentsqpath// Abstract index of data[0] in infinitely sized queueindex_of_firstpop_firstsecond_lastpop_lastadd_semibreak_afterremove_semisingle_tokentoken_grouptoken_puncttoken_literaldelimiter_opendelimiter_closeBareVariadicTypeArrayTypeGroupTypeInferTypeMacroTypeNeverTypeSliceTypeTraitObjectTypeTupletype_arraytype_bare_fntype_grouptype_impl_traittype_infertype_macrotype_nevertype_parentype_pathtype_ptrtype_referencetype_slicetype_trait_objecttype_tupletype_verbatimbare_fn_argbare_variadicmod_mul_miller_rabin/// Test if `n` is prime, using the deterministic version of the/// Miller-Rabin test./// Doing a lot of primality tests with numbers strictly below some/// upper bound will be faster using the `is_prime` method of a/// `Sieve` instance./// assert_eq!(primal::is_prime(1), false);/// assert_eq!(primal::is_prime(2), true);/// assert_eq!(primal::is_prime(3), true);/// assert_eq!(primal::is_prime(4), false);/// assert_eq!(primal::is_prime(5), true);/// assert_eq!(primal::is_prime(22_801_763_487), false);/// assert_eq!(primal::is_prime(22_801_763_489), true);/// assert_eq!(primal::is_prime(22_801_763_491), false);primalSievemiller_rabin_largeoeis_a014233perfect_poweras_perfect_poweras_prime_power//! Check some primality-related properties of numbers.//! This crate is designed to be used via `primal`./// Returns integers `(y, k)` such that `x = y^k` with `k` maximised/// (other than for `x = 0, 1`, in which case `y = x`, `k = 1`)./// # use primal_check as primal;/// assert_eq!(primal::as_perfect_power(2), (2, 1));/// assert_eq!(primal::as_perfect_power(4), (2, 2));/// assert_eq!(primal::as_perfect_power(8), (2, 3));/// assert_eq!(primal::as_perfect_power(1024), (2, 10));/// assert_eq!(primal::as_perfect_power(1000), (10, 3));/// assert_eq!(primal::as_perfect_power(15), (15, 1));/// Return `Some((p, k))` if `x = p^k` for some prime `p` and `k >= 1`/// (that is, including when `x` is itself a prime)./// Returns `None` if `x` not a perfect power./// assert_eq!(primal::as_prime_power(2), Some((2, 1)));/// assert_eq!(primal::as_prime_power(4), Some((2, 2)));/// assert_eq!(primal::as_prime_power(8), Some((2, 3)));/// assert_eq!(primal::as_prime_power(1024), Some((2, 10)));/// assert_eq!(primal::as_prime_power(1000), None);/// assert_eq!(primal::as_prime_power(15), None);perfect_and_prime_power/// x-coordinate/// y-coordinate/// Is this point the point at infinity? 0 = no, 1 = yes/// This is a proxy for [`Choice`], but uses `u8` instead to permit `const`/// constructors for `IDENTITY` and `GENERATOR`./// Point on a Weierstrass curve in affine coordinates./// Additive identity of the group a.k.a. the point at infinity./// Base point of the curve./// Is this point the point at infinity?to_compact/// Conditionally negate [`AffinePoint`] for use with point compaction./// Attempts to parse the given [`EncodedPoint`] as an SEC1-encoded/// [`AffinePoint`]./// `None` value if `encoded_point` is not on the secp384r1 curve./// NOTE: not constant-time with respect to identity point/// Serialize this value as a  SEC1 compact [`EncodedPoint`]//! Affine curve points.// Arithmetic trait impls// serde supportimpl_projective_arithmetic_tests/// Implement projective arithmetic tests.// TODO(tarcieri): move all development-related macros into this module/// Implements a field element type whose internal representation is in/// Montgomery form, providing a combination of trait impls and inherent impls/// which are `const fn` where possible./// Accepts a set of `const fn` arithmetic operation functions as arguments./// # Inherent impls/// - `const ZERO: Self`/// - `const ONE: Self` (multiplicative identity)/// - `pub fn from_bytes`/// - `pub fn from_slice`/// - `pub fn from_uint`/// - `fn from_uint_unchecked`/// - `pub fn to_bytes`/// - `pub fn to_canonical`/// - `pub fn is_odd`/// - `pub fn is_zero`/// - `pub fn double`/// NOTE: field implementations must provide their own inherent impls of/// the following methods in order for the code generated by this macro to/// compile:/// - `pub fn invert`/// - `pub fn sqrt`/// - `AsRef<$arr>`/// - `ConditionallySelectable`/// - `ConstantTimeEq`/// - `ConstantTimeGreater`/// - `ConstantTimeLess`/// - `Default`/// - `DefaultIsZeroes`/// - `Eq`/// - `Field`/// - `PartialEq`/// ## Ops/// - `Add`/// - `AddAssign`/// - `Sub`/// - `SubAssign`/// - `Mul`/// - `MulAssign`/// - `Neg`/// Add arithmetic impls to the given field element./// Emit impls for a `core::ops` trait for all combinations of reference types,/// which thunk to the given function.impl_bernstein_yang_invert/// Implement Bernstein-Yang field element inversion./// Implement field element identity tests./// Implement field element inversion tests./// Implement field element square root tests./// Implement tests for the `PrimeField` trait.projective/// Base field element type.// TODO(tarcieri): add `Invert` bound/// [Point arithmetic](point_arithmetic) implementation, might be optimized for this specific curve/// Coefficient `a` in the curve equation./// Coefficient `b` in the curve equation./// Generator point's affine coordinates: (x, y)./// Parameters for elliptic curves of prime order which can be described by the/// short Weierstrass equation./// Returns `lhs + rhs`/// Returns `point + point`/// Elliptic point arithmetic implementation/// Provides implementation of point arithmetic (point addition, point doubling) which/// might be optimized for the curve./// Allow crate-local visibilityEquationAIsGeneric/// The 𝒂-coefficient of the short Weierstrass equation does not have specific/// properties which allow for an optimized implementation./// Implements complete addition for any curve/// (Algorithm 1). The comments after each line indicate which algorithm steps/// are being performed./// Implements complete mixed addition for curves with any `a`/// Implements the complete mixed addition formula from [Renes-Costello-Batina 2015]/// (Algorithm 2). The comments after each line indicate which algorithm/// steps are being performed./// Implements point doubling for curves with any `a`/// Implements the exception-free point doubling formula from [Renes-Costello-Batina 2015]/// (Algorithm 3). The comments after each line indicate which algorithm/// The 𝒂-coefficient of the short Weierstrass equation is -3./// Implements complete addition for curves with `a = -3`/// (Algorithm 4). The comments after each line indicate which algorithm steps/// Implements complete mixed addition for curves with `a = -3`/// (Algorithm 5). The comments after each line indicate which algorithm/// Implements point doubling for curves with `a = -3`/// (Algorithm 6). The comments after each line indicate which algorithm//! Point arithmetic implementation optimised for different curve equations//! Support for formulas specialized to the short Weierstrass equation's//! 𝒂-coefficient./// Point on a Weierstrass curve in projective coordinates./// Returns the affine representation of this point, or `None` if it is the identity.to_affine_internal/// Returns `-self`./// Returns `self + other`./// Returns `self - other`.sub_mixed/// Returns `[k] self`.// TODO(tarcieri): re-enable when we can add `Invert` bounds on `FieldElement`// fn batch_normalize(projective: &[Self], affine: &mut [Self::AffineRepr]) {//     assert_eq!(projective.len(), affine.len());//     let mut zs = vec![C::FieldElement::ONE; projective.len()];//     batch_normalize_generic(projective, zs.as_mut_slice(), affine);batch_normalize_generic/// Generic implementation of batch normalization.//! Projective curve points.CargoToml/// Find the crate name for the given `orig_name` in the current `Cargo.toml`./// `orig_name` should be the original name of the searched crate./// The current `Cargo.toml` is determined by taking `CARGO_MANIFEST_DIR/Cargo.toml`./// - `Ok(orig_name)` if the crate was found, but not renamed in the `Cargo.toml`./// - `Ok(RENAMED)` if the crate was found, but is renamed in the `Cargo.toml`. `RENAMED` will be/// the renamed name./// - `Err` if an error occurred./// The returned crate name is sanitized in such a way that it is a valid rust identifier. Thus,/// it is ready to be used in `extern crate` as identifier.sanitize_crate_name/// Make sure that the given crate name is a valid rust identifier.open_cargo_toml/// Open the given `Cargo.toml` and parse it into a hashmap.create_not_found_err/// Create the not found error.extract_crate_name/// Extract the crate name for the given `orig_name` from the given `Cargo.toml` by checking the/// `dependencies` and `dev-dependencies`./// Returns `Ok(orig_name)` if the crate is not renamed in the `Cargo.toml` or otherwise/// the renamed identifier.search_crate_at_key/// Search the `orig_name` crate at the given `key` in `cargo_toml`.extract_crate_name_from_deps/// Extract the crate name from the given dependencies./// Returns `Some(orig_name)` if the crate is not renamed in the `Cargo.toml` or otherwisecreate_testdeps_with_cratedev_deps_with_cratedeps_with_crate_renameddeps_with_crate_renamed_seconddeps_emptycrate_not_foundtarget_dependencytarget_dependency2/*!

[![](https://docs.rs/proc-macro-crate/badge.svg)](https://docs.rs/proc-macro-crate/) [![](https://img.shields.io/crates/v/proc-macro-crate.svg)](https://crates.io/crates/proc-macro-crate) [![](https://img.shields.io/crates/d/proc-macro-crate.png)](https://crates.io/crates/proc-macro-crate) [![Build Status](https://travis-ci.org/bkchr/proc-macro-crate.png?branch=master)](https://travis-ci.org/bkchr/proc-macro-crate)

Providing support for `$crate` in procedural macros.

* [Introduction](#introduction)
* [Example](#example)
* [License](#license)

## Introduction

In `macro_rules!` `$crate` is used to get the path of the crate where a macro is declared in. In
procedural macros there is currently no easy way to get this path. A common hack is to import the
desired crate with a know name and use this. However, with rust edition 2018 and dropping
`extern crate` declarations from `lib.rs`, people start to rename crates in `Cargo.toml` directly.
However, this breaks importing the crate, as the proc-macro developer does not know the renamed
name of the crate that should be imported.

This crate provides a way to get the name of a crate, even if it renamed in `Cargo.toml`. For this
purpose a single function `crate_name` is provided. This function needs to be called in the context
of a proc-macro with the name of the desired crate. `CARGO_MANIFEST_DIR` will be used to find the
current active `Cargo.toml` and this `Cargo.toml` is searched for the desired crate. The returned
name of `crate_name` is either the given original rename (crate not renamed) or the renamed name.

## Example

```
use quote::quote;
use syn::Ident;
use proc_macro2::Span;
use proc_macro_crate::crate_name;

fn import_my_crate() {
    let name = crate_name("my-crate").expect("my-crate is present in `Cargo.toml`");
    let ident = Ident::new(&name, Span::call_site());
    quote!( extern crate #ident as my_crate_known_name );
}

# fn main() {}
```

## License

Licensed under either of

 * [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)

 * [MIT license](http://opensource.org/licenses/MIT)

at your option.
*/TomlErrorCargoManifestDirNotSetCouldNotReadInvalidTomlCrateNotFound/// Error type used by this crate.FoundCrateItself/// The searched crate is this crate itself./// The searched crate was found with this name./// The crate as found by [`crate_name`].CacheEntry// In a rustc invocation, there will only ever be one entry in this map, since every crate is// compiled with its own rustc process. However, the same is not (currently) the case for// rust-analyzer.manifest_tscrate_namesCrateNamescargo_toml_timestampread_cargo_tomlextract_crate_names/// Extract all crate names from the given `Cargo.toml` by checking the `dependencies` and/// `dev-dependencies`.extract_package_nametarget_dep_tablesdep_tablesown_crateown_crate_and_in_depsmultiple_times/*!

[![](https://docs.rs/proc-macro-crate/badge.svg)](https://docs.rs/proc-macro-crate/) [![](https://img.shields.io/crates/v/proc-macro-crate.svg)](https://crates.io/crates/proc-macro-crate) [![](https://img.shields.io/crates/d/proc-macro-crate.png)](https://crates.io/crates/proc-macro-crate) [![Build Status](https://travis-ci.org/bkchr/proc-macro-crate.png?branch=master)](https://travis-ci.org/bkchr/proc-macro-crate)

Providing support for `$crate` in procedural macros.

* [Introduction](#introduction)
* [Example](#example)
* [License](#license)

## Introduction

In `macro_rules!` `$crate` is used to get the path of the crate where a macro is declared in. In
procedural macros there is currently no easy way to get this path. A common hack is to import the
desired crate with a know name and use this. However, with rust edition 2018 and dropping
`extern crate` declarations from `lib.rs`, people start to rename crates in `Cargo.toml` directly.
However, this breaks importing the crate, as the proc-macro developer does not know the renamed
name of the crate that should be imported.

This crate provides a way to get the name of a crate, even if it renamed in `Cargo.toml`. For this
purpose a single function `crate_name` is provided. This function needs to be called in the context
of a proc-macro with the name of the desired crate. `CARGO_MANIFEST_DIR` will be used to find the
current active `Cargo.toml` and this `Cargo.toml` is searched for the desired crate.

## Example

```
use quote::quote;
use syn::Ident;
use proc_macro2::Span;
use proc_macro_crate::{crate_name, FoundCrate};

fn import_my_crate() {
    let found_crate = crate_name("my-crate").expect("my-crate is present in `Cargo.toml`");

    match found_crate {
        FoundCrate::Itself => quote!( crate::Something ),
        FoundCrate::Name(name) => {
            let ident = Ident::new(&name, Span::call_site());
            quote!( #ident::Something )
        }
    };
}

# fn main() {}
```

## Edge cases

There are multiple edge cases when it comes to determining the correct crate. If you for example
import a crate as its own dependency, like this:

```toml
[package]
name = "my_crate"

[dev-dependencies]
my_crate = { version = "0.1", features = [ "test-feature" ] }
```

The crate will return `FoundCrate::Itself` and you will not be able to find the other instance
of your crate in `dev-dependencies`. Other similar cases are when one crate is imported multiple
times:

```toml
[package]
name = "my_crate"

[dependencies]
some-crate = { version = "0.5" }
some-crate-old = { package = "some-crate", version = "0.1" }
```

When searching for `some-crate` in this `Cargo.toml` it will return `FoundCrate::Name("some_old_crate")`,
aka the last definition of the crate in the `Cargo.toml`.

## License

Licensed under either of

 * [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)

 * [MIT license](https://opensource.org/licenses/MIT)

at your option.
*/CargoEnvVariableNotSetFailedGettingWorkspaceManifestPathworkspace_manifest_tsworkspace_manifest_pathextract_workspace_dependencies/// Extract all `[workspace.dependencies]`./// Returns a hash map that maps from dep name to the package name. Dep name/// and package name can be the same if there doesn't exist any rename.workspace_dep_tables/// Return an iterator over all `[workspace.dependencies]`workspace_depsworkspace_deps_twice_renamedabort_nowcheck_correctnessSpanRangeNonExhaustive/// Represents a diagnostic level/// Warnings are ignored on stable/betaspan_rangeSuggestionKind/// Represents a single diagnostic messagespanned_range/// Create a new diagnostic message that points to the `span_range`./// This function is the same as `Diagnostic::spanned` but produces considerably/// better error messages for multi-token spans on stable.span_range_error/// Add another error message to self such that it will be emitted right after/// the main message./// This function is the same as `Diagnostic::span_error` but produces considerablyspan_range_help/// Attach a "help" note to your main message, the note will have it's own span on nightly./// This function is the same as `Diagnostic::span_help` but produces considerably/// # Span/// The span is ignored on stable, the note effectively inherits its parent's (main message) spanspan_range_note/// Attach a note to your main message, the note will have it's own span on nightly./// This function is the same as `Diagnostic::span_note` but produces considerablyDiagnosticExt/// A collection of methods that do not exist in `proc_macro::Diagnostic`/// but still useful to have around./// This trait is sealed and cannot be implemented outside of `proc_macro_error`./// Create a new diagnostic message that points to `Span::call_site()`/// Create a new diagnostic message that points to the `span`span_errorspan_help/// Attach a "help" note to your main message.span_note/// Attach a note to your main message/// The message of main warning/error (no notes attached)/// Abort the proc-macro's execution and display the diagnostic./// Warnings are not emitted on stable and beta, but this function will abort anyway./// Display the diagnostic while not aborting macro execution.span_suggestionsuggestion/// **NOT PUBLIC API! NOTHING TO SEE HERE!!!**DUMMY_IMPLset_dummy/// Sets dummy token stream which will be appended to `compile_error!(msg);...`/// invocations in case you'll emit any errors./// See [guide](../index.html#guide).append_dummy/// Same as [`set_dummy`] but, instead of resetting, appends tokens to the/// existing dummy (if any). Behaves as `set_dummy` if no dummy is present.//! Facility to emit dummy implementations (or whatever) in case//! an error happen.//! `compile_error!` does not abort a compilation right away. This means//! `rustc` doesn't just show you the error and abort, it carries on the//! compilation process looking for other errors to report.//! Let's consider an example://! use proc_macro::TokenStream;//! use proc_macro_error::*;//! trait MyTrait {//!     fn do_thing();//! // this proc macro is supposed to generate MyTrait impl//! #[proc_macro_derive(MyTrait)]//! #[proc_macro_error]//! fn example(input: TokenStream) -> TokenStream {//!     // somewhere deep inside//!     abort!(span, "something's wrong");//!     // this implementation will be generated if no error happened//!     quote! {//!         impl MyTrait for #name {//!             fn do_thing() {/* whatever */}//! // ================//! // in main.rs//! // this derive triggers an error//! #[derive(MyTrait)] // first BOOM!//! struct Foo;//!     Foo::do_thing(); // second BOOM!//! The problem is: the generated token stream contains only `compile_error!`//! invocation, the impl was not generated. That means user will see two compilation//! errors://! error: something's wrong//!  --> $DIR/probe.rs:9:10//! 9 |#[proc_macro_derive(MyTrait)]//!   |                    ^^^^^^^//! error[E0599]: no function or associated item named `do_thing` found for type `Foo` in the current scope//!  --> src\main.rs:3:10//! 1 | struct Foo;//!   | ----------- function or associated item `do_thing` not found for this//! 2 | fn main() {//! 3 |     Foo::do_thing(); // second BOOM!//!   |          ^^^^^^^^ function or associated item not found in `Foo`//! But the second error is meaningless! We definitely need to fix this.//! Most used approach in cases like this is "dummy implementation" -//! omit `impl MyTrait for #name` and fill functions bodies with `unimplemented!()`.//! This is how you do it://!  trait MyTrait {//!      fn do_thing();//!  // this proc macro is supposed to generate MyTrait impl//!  #[proc_macro_derive(MyTrait)]//!  #[proc_macro_error]//!  fn example(input: TokenStream) -> TokenStream {//!      // first of all - we set a dummy impl which will be appended to//!      // `compile_error!` invocations in case a trigger does happen//!      set_dummy(quote! {//!          impl MyTrait for #name {//!              fn do_thing() { unimplemented!() }//!          }//!      });//!      // somewhere deep inside//!      abort!(span, "something's wrong");//!      // this implementation will be generated if no error happened//!      quote! {//!              fn do_thing() {/* whatever */}//!      }//!  // ================//!  // in main.rs//!  // this derive triggers an error//!  #[derive(MyTrait)] // first BOOM!//!  struct Foo;//!  fn main() {//!      Foo::do_thing(); // no more errors!PDiagPLevelabort_if_dirtyemit_diagnostic//! This implementation uses [`proc_macro::Diagnostic`], nightly only.ERR_STORAGE//! This implementation uses self-written stable facilities."imp/fallback.rs"single_span/// Create a range with the `first` and `last` spans being the same.call_site/// Create a `SpanRange` resolving at call site./// Construct span range from a `TokenStream`. This method always preserves all the/// If the stream is empty, the result is `SpanRange::call_site()`. If the stream/// consists of only one `TokenTree`, the result is `SpanRange::single_span(tt.span())`/// that doesn't lose anything.join_range/// Join two span ranges. The resulting range will start at `self.first` and end at/// `other.last`./// Collapse the range into single span, preserving as much information as possible.unwrap_or_abort/// Behaves like `Result::unwrap`: if self is `Ok` yield the contained value,/// otherwise abort macro execution via `abort!`.expect_or_abort/// Behaves like `Result::expect`: if self is `Ok` yield the contained value,/// If it aborts then resulting error message will be preceded with `message`./// This traits expands `Result<T, Into<Diagnostic>>` with some handy shortcuts./// Behaves like `Option::expect`: if self is `Some` yield the contained value,/// otherwise abort macro execution via `abort_call_site!`./// If it aborts the `message` will be used for [`compile_error!`][compl_err] invocation./// [compl_err]: https://doc.rust-lang.org/std/macro.compile_error.html/// This traits expands `Option` with some handy shortcuts./// Abort macro execution and display all the emitted errors, if any./// Does nothing if no errors were emitted (warnings do not count)./// This is the entry point for a proc-macro./// **NOT PUBLIC API, SUBJECT TO CHANGE WITHOUT ANY NOTICE**ENTERED_ENTRY_POINTAbortNow// reexports for use in macrosFIRST_ARG_MUST_EITHER_BE_Span_OR_IMPLEMENT_ToTokens_OR_BE_SpanRangeSpanAsSpanRangeSpan2AsSpanRangeToTokensAsSpanRangeSpanRangeAsSpanRange// inspired by// https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md#simple-application__export/// **ALL THE STUFF INSIDE IS NOT PUBLIC API!!!**//! # proc-macro-error//! This crate aims to make error reporting in proc-macros simple and easy to use.//! Migrate from `panic!`-based errors for as little effort as possible!//! (Also, you can explicitly [append a dummy token stream](dummy/index.html) to your errors).//! To achieve his, this crate serves as a tiny shim around `proc_macro::Diagnostic` and//! `compile_error!`. It detects the best way of emitting available based on compiler's version.//! When the underlying diagnostic type is finally stabilized, this crate will simply be//! delegating to it requiring no changes in your code!//! So you can just use this crate and have *both* some of `proc_macro::Diagnostic` functionality//! available on stable ahead of time *and* your error-reporting code future-proof.//! ## Cargo features//! This crate provides *enabled by default* `syn-error` feature that gates//! `impl From<syn::Error> for Diagnostic` conversion. If you don't use `syn` and want//! to cut off some of compilation time, you can disable it via//! proc-macro-error = { version = "1", default-features = false }//! ***Please note that disabling this feature makes sense only if you don't depend on `syn`//! directly or indirectly, and you very likely do.**//! ## Real world examples//! * [`structopt-derive`](https://github.com/TeXitoi/structopt/tree/master/structopt-derive)//!   (abort-like usage)//! * [`auto-impl`](https://github.com/auto-impl-rs/auto_impl/) (emit-like usage)//! - Warnings are emitted only on nightly, they are ignored on stable.//! - "help" suggestions can't have their own span info on stable,//!   (essentially inheriting the parent span).//! - If a panic occurs somewhere in your macro no errors will be displayed. This is not a//!   technical limitation but rather intentional design. `panic` is not for error reporting.//! ### `#[proc_macro_error]` attribute//! **This attribute MUST be present on the top level of your macro** (the function//! annotated with any of `#[proc_macro]`, `#[proc_macro_derive]`, `#[proc_macro_attribute]`).//! This attribute performs the setup and cleanup necessary to make things work.//! In most cases you'll need the simple `#[proc_macro_error]` form without any//! additional settings. Feel free to [skip the "Syntax" section](#macros).//! #### Syntax//! `#[proc_macro_error]` or `#[proc_macro_error(settings...)]`, where `settings...`//! is a comma-separated list of://! - `proc_macro_hack`://!     In order to correctly cooperate with `#[proc_macro_hack]`, `#[proc_macro_error]`//!     attribute must be placed *before* (above) it, like this://!     ```no_run//!     # use proc_macro2::TokenStream;//!     # const IGNORE: &str = "//!     #[proc_macro_error]//!     #[proc_macro_hack]//!     #[proc_macro]//!     # ";//!     fn my_macro(input: TokenStream) -> TokenStream {//!         unimplemented!()//!     ```//!     If, for some reason, you can't place it like that you can use//!     `#[proc_macro_error(proc_macro_hack)]` instead.//!     # Note//!     If `proc-macro-hack` was detected (by any means) `allow_not_macro`//!     and `assert_unwind_safe` will be applied automatically.//! - `allow_not_macro`://!     By default, the attribute checks that it's applied to a proc-macro.//!     If none of `#[proc_macro]`, `#[proc_macro_derive]` nor `#[proc_macro_attribute]` are//!     present it will panic. It's the intention - this crate is supposed to be used only with//!     proc-macros.//!     This setting is made to bypass the check, useful in certain circumstances.//!     Pay attention: the function this attribute is applied to must return//!     `proc_macro::TokenStream`.//!     This setting is implied if `proc-macro-hack` was detected.//! - `assert_unwind_safe`://!     By default, your code must be [unwind safe]. If your code is not unwind safe,//!     but you believe it's correct, you can use this setting to bypass the check.//!     You would need this for code that uses `lazy_static` or `thread_local` with//!     `Cell/RefCell` inside (and the like).//!     This setting is implied if `#[proc_macro_error]` is applied to a function//!     marked as `#[proc_macro]`, `#[proc_macro_derive]` or `#[proc_macro_attribute]`.//!     This setting is also implied if `proc-macro-hack` was detected.//! ## Macros//! Most of the time you want to use the macros. Syntax is described in the next section below.//! You'll need to decide how you want to emit errors://! * Emit the error and abort. Very much panic-like usage. Served by [`abort!`] and//!   [`abort_call_site!`].//! * Emit the error but do not abort right away, looking for other errors to report.//!   Served by [`emit_error!`] and [`emit_call_site_error!`].//! You **can** mix these usages.//! `abort` and `emit_error` take a "source span" as the first argument. This source//! will be used to highlight the place the error originates from. It must be one of://! * *Something* that implements [`ToTokens`] (most types in `syn` and `proc-macro2` do).//!   This source is the preferable one since it doesn't lose span information on multi-token//!   spans, see [this issue](https://gitlab.com/CreepySkeleton/proc-macro-error/-/issues/6)//!   for details.//! * [`proc_macro::Span`]//! * [`proc-macro2::Span`]//! The rest is your message in format-like style.//! See [the next section](#syntax-1) for detailed syntax.//! - [`abort!`]://!     Very much panic-like usage - abort right away and show the error.//!     Expands to [`!`] (never type).//! - [`abort_call_site!`]://!     Shortcut for `abort!(Span::call_site(), ...)`. Expands to [`!`] (never type).//! - [`emit_error!`]://!     [`proc_macro::Diagnostic`]-like usage - emit the error but keep going,//!     looking for other errors to report.//!     The compilation will fail nonetheless. Expands to [`()`] (unit type).//! - [`emit_call_site_error!`]://!     Shortcut for `emit_error!(Span::call_site(), ...)`. Expands to [`()`] (unit type).//! - [`emit_warning!`]://!     Like `emit_error!` but emit a warning instead of error. The compilation won't fail//!     because of warnings.//!     Expands to [`()`] (unit type).//!     **Beware**: warnings are nightly only, they are completely ignored on stable.//! - [`emit_call_site_warning!`]://!     Shortcut for `emit_warning!(Span::call_site(), ...)`. Expands to [`()`] (unit type).//! - [`diagnostic`]://!     Build an instance of `Diagnostic` in format-like style.//! All the macros have pretty much the same syntax://! 1.  ```ignore//!     abort!(single_expr)//!     Shortcut for `Diagnostic::from(expr).abort()`.//! 2.  ```ignore//!     abort!(span, message)//!     The first argument is an expression the span info should be taken from.//!     The second argument is the error message, it must implement [`ToString`].//! 3.  ```ignore//!     abort!(span, format_literal, format_args...)//!     This form is pretty much the same as 2, except `format!(format_literal, format_args...)`//!     will be used to for the message instead of [`ToString`].//! That's it. `abort!`, `emit_warning`, `emit_error` share this exact syntax.//! `abort_call_site!`, `emit_call_site_warning`, `emit_call_site_error` lack 1 form//! and do not take span in 2'th and 3'th forms. Those are essentially shortcuts for//! `macro!(Span::call_site(), args...)`.//! `diagnostic!` requires a [`Level`] instance between `span` and second argument//! (1'th form is the same).//! > **Important!**//! > If you have some type from `proc_macro` or `syn` to point to, do not call `.span()`//! > on it but rather use it directly://! > ```no_run//! > # use proc_macro_error::abort;//! > # let input = proc_macro2::TokenStream::new();//! > let ty: syn::Type = syn::parse2(input).unwrap();//! > abort!(ty, "BOOM");//! > //     ^^ <-- avoid .span()//! > ```//! > `.span()` calls work too, but you may experience regressions in message quality.//! #### Note attachments//! 3.  Every macro can have "note" attachments (only 2 and 3 form).//!   let opt_help = if have_some_info { Some("did you mean `this`?") } else { None };//!   abort!(//!       span, message; // <--- attachments start with `;` (semicolon)//!       help = "format {} {}", "arg1", "arg2"; // <--- every attachment ends with `;`,//!                                              //      maybe except the last one//!       note = "to_string"; // <--- one arg uses `.to_string()` instead of `format!()`//!       yay = "I see what {} did here", "you"; // <--- "help =" and "hint =" are mapped//!                                              // to Diagnostic::help,//!                                              // anything else is Diagnostic::note//!       wow = note_span => "custom span"; // <--- attachments can have their own span//!                                         //      it takes effect only on nightly though//!       hint =? opt_help; // <-- "optional" attachment, get displayed only if `Some`//!                         //     must be single `Option` expression//!       note =? note_span => opt_help // <-- optional attachments can have custom spans too//!   );//! ### Diagnostic type//! [`Diagnostic`] type is intentionally designed to be API compatible with [`proc_macro::Diagnostic`].//! Not all API is implemented, only the part that can be reasonably implemented on stable.//! [`abort!`]: macro.abort.html//! [`abort_call_site!`]: macro.abort_call_site.html//! [`emit_warning!`]: macro.emit_warning.html//! [`emit_error!`]: macro.emit_error.html//! [`emit_call_site_warning!`]: macro.emit_call_site_error.html//! [`emit_call_site_error!`]: macro.emit_call_site_warning.html//! [`diagnostic!`]: macro.diagnostic.html//! [`Diagnostic`]: struct.Diagnostic.html//! [`proc_macro::Span`]: https://doc.rust-lang.org/proc_macro/struct.Span.html//! [`proc_macro::Diagnostic`]: https://doc.rust-lang.org/proc_macro/struct.Diagnostic.html//! [unwind safe]: https://doc.rust-lang.org/std/panic/trait.UnwindSafe.html#what-is-unwind-safety//! [`!`]: https://doc.rust-lang.org/std/primitive.never.html//! [`()`]: https://doc.rust-lang.org/std/primitive.unit.html//! [`ToString`]: https://doc.rust-lang.org/std/string/trait.ToString.html//! [`proc-macro2::Span`]: https://docs.rs/proc-macro2/1.0.10/proc_macro2/struct.Span.html//! [`ToTokens`]: https://docs.rs/quote/1.0.3/quote/trait.ToTokens.html// from alias// span, message, help// span, message, no help// trailing commas// ($err:expr,) => { $crate::diagnostic!($err) };/// Build [`Diagnostic`](struct.Diagnostic.html) instance from provided arguments./// See [the guide](index.html#guide)./// Abort proc-macro execution right now and display the error./// Shortcut for `abort!(Span::call_site(), msg...)`. This macro/// is still preferable over plain panic, panics are not for error reporting.emit_error/// Emit an error while not aborting the proc-macro right away.emit_call_site_error/// Shortcut for `emit_error!(Span::call_site(), ...)`. This macro/// is still preferable over plain panic, panics are not for error reporting..emit_warning/// Emit a warning. Warnings are not errors and compilation won't fail because of them./// **Does nothing on stable**emit_call_site_warning/// Shortcut for `emit_warning!(Span::call_site(), ...)`.__pme__suggestions// FIXME: this can be greatly simplified via $()?// as soon as MRSV hits 1.32impl_proc_macro_errorgen_bodydetect_proc_macro_hackis_proc_macro//! This is `#[proc_macro_error]` attribute to be used with//! [`proc-macro-error`](https://docs.rs/proc-macro-error/). There you go.parse_next_attrshebangpath_is_identdecl_settingsAllowNotMacroProcMacroHackident_to_settingparse_settingsenable_use_proc_macrofeature_allowed// rustc-cfg emitted by the build script:// "u128"//     Include u128 and i128 constructors for proc_macro2::Literal. Enabled on//     any compiler 1.26+.// "use_proc_macro"//     Link to extern crate proc_macro. Available on any compiler and any target//     except wasm32. Requires "proc-macro" Cargo cfg to be enabled (default is//     enabled). On wasm32 we never link to proc_macro even if "proc-macro" cfg//     is enabled.// "wrap_proc_macro"//     Wrap types from libproc_macro rather than polyfilling the whole API.//     Enabled on rustc 1.29+ as long as procmacro2_semver_exempt is not set,//     because we can't emulate the unstable API without emulating everything//     else. Also enabled unconditionally on nightly, in which case the//     procmacro2_semver_exempt surface area is implemented by using the//     nightly-only proc_macro API.// "slow_extend"//     Fallback when `impl Extend for TokenStream` is not available. These impls//     were added one version later than the rest of the proc_macro token API.//     Enabled on rustc 1.29 only.// "proc_macro_span"//     Enable non-dummy behavior of Span::start and Span::end methods which//     requires an unstable compiler feature. Enabled when building with//     nightly, unless `-Z allow-feature` in RUSTFLAGS disallows unstable//     features.// "super_unstable"//     Implement the semver exempt API in terms of the nightly-only proc_macro//     API. Enabled when using procmacro2_semver_exempt on a nightly compiler.// "span_locations"//     Provide methods Span::start and Span::end which give the line/column//     location of a token. Enabled by procmacro2_semver_exempt or the//     "span-locations" Cargo cfg. This is behind a cfg because tracking//     location inside spans is a performance hit.strnomblock_commentwhitespaceword_breakPResultUnicodeXIDLexErrorget_cursorTokenTreeIterSourceFile/// Get the path to this source file as a string.is_realLineColumndebug_span_field_if_nontrivialis_ident_startis_ident_continuevalidate_ident// Ident(proc_macro), Ident(r#union)suffixed_numbersunsuffixed_numbersu8_suffixedu16_suffixedu32_suffixedu64_suffixedusize_suffixedi8_suffixedi16_suffixedi32_suffixedi64_suffixedisize_suffixedf32_suffixedf64_suffixedu128_suffixedi128_suffixedu8_unsuffixedu16_unsuffixedu32_unsuffixedu64_unsuffixedusize_unsuffixedi8_unsuffixedi16_unsuffixedi32_unsuffixedi64_unsuffixedisize_unsuffixedu128_unsuffixedi128_unsuffixedf32_unsuffixedf64_unsuffixedbyte_stringtoken_treesymbol_leading_wsliteral_nocapturequoted_stringcooked_stringcooked_byte_stringraw_stringcooked_bytecooked_charnext_chbackslash_x_charbackslash_x_bytebackslash_ufloat_digitsop_chardoc_comment_contents"wrapper.rs"/// An abstract stream of tokens, or more concretely a sequence of token trees./// This type provides interfaces for iterating over token trees and for/// collecting token trees into one stream./// Token stream is both the input and output of `#[proc_macro]`,/// `#[proc_macro_attribute]` and `#[proc_macro_derive]` definitions./// Error returned from `TokenStream::from_str`._new_stable/// Returns an empty `TokenStream` containing no token trees./// Checks if this `TokenStream` is empty./// `TokenStream::default()` returns an empty stream,/// i.e. this is equivalent with `TokenStream::new()`./// Attempts to break the string into tokens and parse those tokens into a token/// May fail for a number of reasons, for example, if the string contains/// unbalanced delimiters or characters not existing in the language./// NOTE: Some errors may cause panics instead of returning `LexError`. We/// reserve the right to change these errors into `LexError`s later./// Collects a number of token trees into a single stream./// Prints the token stream as a string that is supposed to be losslessly/// convertible back into the same token stream (modulo spans), except for/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative/// numeric literals./// Prints token in a form convenient for debugging./// A region of source code, along with macro expansion information./// The span of the invocation of the current procedural macro./// Identifiers created with this span will be resolved as if they were/// written directly at the macro call location (call-site hygiene) and/// other code at the macro call site will be able to refer to them as well./// Convert `proc_macro2::Span` to `proc_macro::Span`./// This method is available when building with a nightly compiler, or when/// building with rustc 1.29+ *without* semver exempt features./// Panics if called from outside of a procedural macro. Unlike/// `proc_macro2::Span`, the `proc_macro::Span` type can only exist within/// the context of a procedural macro invocation.unstable// Soft deprecated. Please use Span::unwrap./// Prints a span in a form convenient for debugging./// A token stream surrounded by bracket delimiters./// An identifier./// A single punctuation character (`+`, `,`, `$`, etc.)./// A literal character (`'a'`), string (`"hello"`), number (`2.3`), etc./// A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`)./// Returns the span of this tree, delegating to the `span` method of/// the contained token or a delimited stream./// Configures the span for *only this token*./// Note that if this token is a `Group` then this method will not configure/// the span of each of the internal tokens, this will simply delegate to/// the `set_span` method of each variant./// Prints the token tree as a string that is supposed to be losslessly/// convertible back into the same token tree (modulo spans), except for/// Prints token tree in a form convenient for debugging./// A delimited token stream./// A `Group` internally contains a `TokenStream` which is surrounded by/// `Delimiter`s.Parenthesis/// `( ... )`/// `{ ... }`Bracket/// `[ ... ]`/// `Ø ... Ø`/// An implicit delimiter, that may, for example, appear around tokens/// coming from a "macro variable" `$var`. It is important to preserve/// operator priorities in cases like `$var * 3` where `$var` is `1 + 2`./// Implicit delimiters may not survive roundtrip of a token stream through/// a string./// Describes how a sequence of token trees is delimited./// Creates a new `Group` with the given delimiter and token stream./// This constructor will set the span for this group to/// `Span::call_site()`. To change the span you can use the `set_span`/// method below./// Returns the delimiter of this `Group`/// Returns the `TokenStream` of tokens that are delimited in this `Group`./// Note that the returned token stream does not include the delimiter/// returned above./// Returns the span for the delimiters of this token stream, spanning the/// entire `Group`./// pub fn span(&self) -> Span {///            ^^^^^^^/// Configures the span for this `Group`'s delimiters, but not its internal/// tokens./// This method will **not** set the span of all the internal tokens spanned/// by this group, but rather it will only set the span of the delimiter/// tokens at the level of the `Group`./// Prints the group as a string that should be losslessly convertible back/// into the same group (modulo spans), except for possibly `TokenTree::Group`s/// with `Delimiter::None` delimiters./// An `Punct` is an single punctuation character like `+`, `-` or `#`./// Multicharacter operators like `+=` are represented as two instances of/// `Punct` with different forms of `Spacing` returned.Alone/// E.g. `+` is `Alone` in `+ =`, `+ident` or `+()`.Joint/// E.g. `+` is `Joint` in `+=` or `'#`./// Additionally, single quote `'` can join with identifiers to form/// lifetimes `'ident`./// Whether an `Punct` is followed immediately by another `Punct` or followed by/// another token or whitespace./// Creates a new `Punct` from the given character and spacing./// The `ch` argument must be a valid punctuation character permitted by the/// language, otherwise the function will panic./// The returned `Punct` will have the default span of `Span::call_site()`/// which can be further configured with the `set_span` method below./// Returns the value of this punctuation character as `char`./// Returns the spacing of this punctuation character, indicating whether/// it's immediately followed by another `Punct` in the token stream, so/// they can potentially be combined into a multicharacter operator/// (`Joint`), or it's followed by some other token or whitespace (`Alone`)/// so the operator has certainly ended./// Returns the span for this punctuation character./// Configure the span for this punctuation character./// Prints the punctuation character as a string that should be losslessly/// convertible back into the same character./// A word of Rust code, which may be a keyword or legal variable name./// An identifier consists of at least one Unicode code point, the first of/// which has the XID_Start property and the rest of which have the XID_Continue/// - The empty string is not an identifier. Use `Option<Ident>`./// - A lifetime is not an identifier. Use `syn::Lifetime` instead./// An identifier constructed with `Ident::new` is permitted to be a Rust/// keyword, though parsing one through its [`Parse`] implementation rejects/// Rust keywords. Use `input.call(Ident::parse_any)` when parsing to match the/// behaviour of `Ident::new`./// [`Parse`]: https://docs.rs/syn/0.15/syn/parse/trait.Parse.html/// A new ident can be created from a string using the `Ident::new` function./// A span must be provided explicitly which governs the name resolution/// behavior of the resulting identifier./// ```edition2018/// use proc_macro2::{Ident, Span};///     let call_ident = Ident::new("calligraphy", Span::call_site());///     println!("{}", call_ident);/// An ident can be interpolated into a token stream using the `quote!` macro./// use quote::quote;///     let ident = Ident::new("demo", Span::call_site());///     // Create a variable binding whose name is this ident.///     let expanded = quote! { let #ident = 10; };///     // Create a variable binding with a slightly different name.///     let temp_ident = Ident::new(&format!("new_{}", ident), Span::call_site());///     let expanded = quote! { let #temp_ident = 10; };/// A string representation of the ident is available through the `to_string()`/// # use proc_macro2::{Ident, Span};/// # let ident = Ident::new("another_identifier", Span::call_site());/// // Examine the ident as a string./// let ident_string = ident.to_string();/// if ident_string.len() > 60 {///     println!("Very long identifier: {}", ident_string)/// Creates a new `Ident` with the given `string` as well as the specified/// `span`./// The `string` argument must be a valid identifier permitted by the/// Note that `span`, currently in rustc, configures the hygiene information/// for this identifier./// As of this time `Span::call_site()` explicitly opts-in to "call-site"/// hygiene meaning that identifiers created with this span will be resolved/// as if they were written directly at the location of the macro call, and/// Later spans like `Span::def_site()` will allow to opt-in to/// "definition-site" hygiene meaning that identifiers created with this/// span will be resolved at the location of the macro definition and other/// code at the macro call site will not be able to refer to them./// Due to the current importance of hygiene this constructor, unlike other/// tokens, requires a `Span` to be specified at construction./// Panics if the input string is neither a keyword nor a legal variable/// name. If you are not sure whether the string contains an identifier and/// need to handle an error case, use/// <a href="https://docs.rs/syn/0.15/syn/fn.parse_str.html"><code///   style="padding-right:0;">syn::parse_str</code></a><code///   style="padding-left:0;">::&lt;Ident&gt;</code>/// rather than `Ident::new`._new_raw/// Returns the span of this `Ident`./// Configures the span of this `Ident`, possibly changing its hygiene/// Prints the identifier as a string that should be losslessly convertible back/// into the same identifier./// A literal string (`"hello"`), byte string (`b"hello"`), character (`'a'`),/// byte character (`b'a'`), an integer or floating point number with or without/// a suffix (`1`, `1u8`, `2.3`, `2.3f32`)./// Boolean literals like `true` and `false` do not belong here, they are/// `Ident`s.suffixed_int_literalsunsuffixed_int_literalsr" Creates a new suffixed integer literal with the specified value."r" This function will create an integer like `1u32` where the integer"r" value specified is the first part of the token and the integral is"r" also suffixed at the end. Literals created from negative numbers may"r" not survive rountrips through `TokenStream` or strings and may be"r" broken into two tokens (`-` and positive literal)."r" Literals created through this method have the `Span::call_site()`"r" span by default, which can be configured with the `set_span` method"r" below."r" Creates a new unsuffixed integer literal with the specified value."r" This function will create an integer like `1` where the integer"r" value specified is the first part of the token. No suffix is"r" specified on this token, meaning that invocations like"r" `Literal::i8_unsuffixed(1)` are equivalent to"r" `Literal::u32_unsuffixed(1)`. Literals created from negative numbers"r" may not survive rountrips through `TokenStream` or strings and may"r" be broken into two tokens (`-` and positive literal)."/// Creates a new unsuffixed floating-point literal./// This constructor is similar to those like `Literal::i8_unsuffixed` where/// the float's value is emitted directly into the token but no suffix is/// used, so it may be inferred to be a `f64` later in the compiler./// Literals created from negative numbers may not survive rountrips through/// `TokenStream` or strings and may be broken into two tokens (`-` and/// positive literal)./// This function requires that the specified float is finite, for example/// if it is infinity or NaN this function will panic./// An iterator over `TokenStream`'s `TokenTree`s./// The iteration is "shallow", e.g. the iterator doesn't recurse into/// delimited groups, and returns whole groups as token trees./// Public implementation details for the `TokenStream` type, such as iterators.//! A wrapper around the procedural macro API of the compiler's [`proc_macro`]//! crate. This library serves three purposes://! [`proc_macro`]: https://doc.rust-lang.org/proc_macro///! - **Bring proc-macro-like functionality to other contexts like build.rs and//!   main.rs.** Types from `proc_macro` are entirely specific to procedural//!   macros and cannot ever exist in code outside of a procedural macro.//!   Meanwhile `proc_macro2` types may exist anywhere including non-macro code.//!   By developing foundational libraries like [syn] and [quote] against//!   `proc_macro2` rather than `proc_macro`, the procedural macro ecosystem//!   becomes easily applicable to many other use cases and we avoid//!   reimplementing non-macro equivalents of those libraries.//! - **Make procedural macros unit testable.** As a consequence of being//!   specific to procedural macros, nothing that uses `proc_macro` can be//!   executed from a unit test. In order for helper libraries or components of//!   a macro to be testable in isolation, they must be implemented using//!   `proc_macro2`.//! - **Provide the latest and greatest APIs across all compiler versions.**//!   Procedural macros were first introduced to Rust in 1.15.0 with an//!   extremely minimal interface. Since then, many improvements have landed to//!   make macros more flexible and easier to write. This library tracks the//!   procedural macro API of the most recent stable compiler but employs a//!   polyfill to provide that API consistently across any compiler since//!   1.15.0.//! [syn]: https://github.com/dtolnay/syn//! [quote]: https://github.com/dtolnay/quote//! The skeleton of a typical procedural macro typically looks like this://! extern crate proc_macro;//! #[proc_macro_derive(MyDerive)]//! pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {//!     let input = proc_macro2::TokenStream::from(input);//!     let output: proc_macro2::TokenStream = {//!         /* transform input *///!         # input//!     proc_macro::TokenStream::from(output)//! If parsing with [Syn], you'll use [`parse_macro_input!`] instead to//! propagate parse errors correctly back to the compiler when parsing fails.//! [`parse_macro_input!`]: https://docs.rs/syn/0.15/syn/macro.parse_macro_input.html//! # Unstable features//! The default feature set of proc-macro2 tracks the most recent stable//! compiler API. Functionality in `proc_macro` that is not yet stable is not//! exposed by proc-macro2 by default.//! To opt into the additional APIs available in the most recent nightly//! compiler, the `procmacro2_semver_exempt` config flag must be passed to//! rustc. As usual, we will polyfill those nightly-only APIs all the way back//! to Rust 1.15.0. As these are unstable APIs that track the nightly compiler,//! minor versions of proc-macro2 may make breaking changes to them at any time.//! RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build//! Note that this must not only be done for your crate, but for any crate that//! depends on your crate. This infectious nature is intentional, as it serves//! as a reminder that you are outside of the normal semver guarantees.//! Semver exempt methods are marked as such in the proc-macro2 documentation.// Proc-macro2 types in rustdoc of other crates get linked to here.char_indicesis_whitespacedo_parsetake_until_newline_or_eoftuple_parser/// Do not use directly. Use `tuple!`.punct/// Do not use directly. Use `punct!`.//! Adapted from [`nom`](https://github.com/Geal/nom).nightly_worksmismatchunwrap_nightlyunwrap_stableunsuffixed_integersbyte_rangesubspan// This code exercises the surface area that we expect of Span's unstable API.// If the current toolchain is able to compile it, then proc-macro2 is able to// offer these APIs too.WORKSinside_proc_macroforce_fallbackunforce_fallbackProcMacroAutoTraitsDelimSpanEnumDelimSpan/// An object that holds a [`Group`]'s `span_open()` and `span_close()` together/// in a more compact representation than holding those 2 spans individually./// [`Group`]: crate::Group/// Returns a span covering the entire delimited group./// Returns a span for the opening punctuation of the group only./// Returns a span for the closing punctuation of the group only.//! Items which do not have a correspondence to any API in the proc_macro crate,//! but are necessary to include in proc-macro2.rcvecRcVecRcVecBuilderRcVecIntoIterRcVecMut/// Force use of proc-macro2's fallback implementation of the API for now, even/// if the compiler's implementation is available.unforce/// Resume using the compiler's implementation of the proc macro API if it isfrom_str_checkedpush_token_from_proc_macro// Nonrecursive to prevent stack overflow.TokenStreamBuilderpush_token_from_parsermixed_siteresolved_atlocated_atsource_textfirst_bytelast_bytespan_openspan_close// We attempt to match libproc_macro's formatting.// Empty parens: ()// Nonempty parens: (...)// Empty brackets: []// Nonempty brackets: [...]// Empty braces: { }// Nonempty braces: { ... }new_raw_checkednew_raw_uncheckedvalidate_ident_rawbyte_characterescape_utf8FromStr2detection// Public for proc_macro2::fallback::force() and unforce(), but those are quite// a niche use case so we omit it from rustdoc._new_fallback/// The span located at the invocation of the procedural macro, but with/// local variables, labels, and `$crate` resolved at the definition site/// of the macro. This is the same hygiene behavior as `macro_rules`./// Creates a new span with the same line/column information as `self` but/// that resolves symbols as though it were at `other`./// Creates a new span with the same name resolution behavior as `self` but/// with the line/column information of `other`./// Create a new span encompassing `self` and `other`./// Returns `None` if `self` and `other` are from different files./// Warning: the underlying [`proc_macro::Span::join`] method is/// nightly-only. When called from within a procedural macro not using a/// nightly compiler, this method will always return `None`./// [`proc_macro::Span::join`]: https://doc.rust-lang.org/proc_macro/struct.Span.html#method.join/// Returns the source text behind a span. This preserves the original/// source code, including spaces and comments. It only returns a result if/// the span corresponds to real source code./// Note: The observable result of a macro should only rely on the tokens/// and not on this source text. The result of this function is a best/// effort to be used for diagnostics only./// `∅ ... ∅`/// An invisible delimiter, that may, for example, appear around tokens/// Invisible delimiters may not survive roundtrip of a token stream through/// Note: rustc currently can ignore the grouping of tokens delimited by `None` in the output/// of a proc_macro. Only `None`-delimited groups created by a macro_rules macro in the input/// of a proc_macro macro are preserved, and only in very specific circumstances./// Any `None`-delimited groups (re)created by a proc_macro will therefore not preserve/// operator priorities as indicated above. The other `Delimiter` variants should be used/// instead in this context. This is a rustc bug. For details, see/// [rust-lang/rust#67062](https://github.com/rust-lang/rust/issues/67062)./// Returns the punctuation used as the delimiter for this group: a set of/// parentheses, square brackets, or curly braces./// Returns the span pointing to the opening delimiter of this group./// pub fn span_open(&self) -> Span {///                 ^/// Returns the span pointing to the closing delimiter of this group./// pub fn span_close(&self) -> Span {///                        ^delim_span/// Returns an object that holds this group's `span_open()` and/// `span_close()` together (in a more compact representation than holding/// those 2 spans individually)./// A `Punct` is a single punctuation character like `+`, `-` or `#`./// E.g. `+` is `Joint` in `+=` or `'` is `Joint` in `'#`./// Whether a `Punct` is followed immediately by another `Punct` or followed by/// [`Parse`]: https://docs.rs/syn/2.0/syn/parse/trait.Parse.html/// <a href="https://docs.rs/syn/2.0/syn/fn.parse_str.html"><code/// Same as `Ident::new`, but creates a raw identifier (`r#ident`). The/// `string` argument must be a valid identifier permitted by the language/// (including keywords, e.g. `fn`). Keywords which are usable in path/// segments (e.g. `self`, `super`) are not supported, and will cause ar" not survive roundtrips through `TokenStream` or strings and may be"r" may not survive roundtrips through `TokenStream` or strings and may"/// Literals created from negative numbers may not survive round-trips/// through `TokenStream` or strings and may be broken into two tokens (`-`/// and positive literal)./// Creates a new suffixed floating-point literal./// This constructor will create a literal like `1.0f64` where the value/// specified is the preceding part of the token and `f64` is the suffix of/// the token. This token will always be inferred to be an `f64` in the/// compiler. Literals created from negative numbers may not survive/// round-trips through `TokenStream` or strings and may be broken into two/// tokens (`-` and positive literal)./// This constructor will create a literal like `1.0f32` where the value/// specified is the preceding part of the token and `f32` is the suffix of/// the token. This token will always be inferred to be an `f32` in the/// String literal./// Character literal./// Byte character literal./// Byte string literal./// C string literal./// Returns the span encompassing this literal./// Configures the span associated for this literal./// Returns a `Span` that is a subset of `self.span()` containing only/// the source bytes in range `range`. Returns `None` if the would-be/// trimmed span is outside the bounds of `self`./// Warning: the underlying [`proc_macro::Literal::subspan`] method is/// [`proc_macro::Literal::subspan`]: https://doc.rust-lang.org/proc_macro/struct.Literal.html#method.subspan// Intended for the `quote!` macro to use when constructing a proc-macro2// token out of a macro_rules $:literal token, which is already known to be// a valid literal. This avoids reparsing/validating the literal's string// representation. This is not public API other than for quote.//! [![github]](https://github.com/dtolnay/proc-macro2)&ensp;[![crates-io]](https://crates.io/crates/proc-macro2)&ensp;[![docs-rs]](crate)//! crate. This library serves two purposes://! # #[cfg(wrap_proc_macro)]//! [`parse_macro_input!`]: https://docs.rs/syn/2.0/syn/macro.parse_macro_input.html//! rustc. We will polyfill those nightly-only APIs back to Rust 1.56.0. As//! these are unstable APIs that track the nightly compiler, minor versions of//! proc-macro2 may make breaking changes to them at any time.//! # Thread-Safety//! Most types in this crate are `!Sync` because the underlying compiler//! types make use of thread-local memory, meaning they cannot be accessed from//! a different thread./// The 1-indexed line in the source file on which the span starts or ends/// (inclusive)./// The 0-indexed column (in UTF-8 characters) in the source file on which/// the span starts or ends (inclusive)./// A line-column pair representing the start or end of a `Span`./// This type is semver exempt and not exposed by default.// Zero sized marker with the correct set of autotrait impls we want all proc// macro types to have.starts_with_charstarts_with_fn// Rustc's representation of a macro expansion error in expression position or// type position.lex_errorleaf_tokenident_anyident_not_rawliteral_suffixdelimiter_of_raw_stringraw_byte_stringraw_c_stringcooked_c_stringbackslash_x_nonzerotrailing_backslashpunct_charmake_ownedDeferredTokenStream// Work around https://github.com/rust-lang/rust/issues/65080.// In `impl Extend<TokenTree> for TokenStream` which is used heavily by quote,// we hold on to the appended tokens and do proc_macro::TokenStream::extend as// late as possible to batch together consecutive uses of the Extend impl.CompilerPanic// Rustc was supposed to return a LexError, but it panicked instead.// https://github.com/rust-lang/rust/issues/58736evaluate_nowinto_compiler_token// Assumes inside_proc_macro().cfg_serde/// Expose cfg as constant to be able to typecheck both versions.CachedSize/// Cached size field used in generated code./// It is always equal to itself to simplify generated code./// (Generated code can use `#[derive(Eq)]`)./// This type should rarely be used directly./// Create a new `CachedSize` object./// Get cached size/// Set cached size/// Thin wrapper around `Bytes` which guarantees that bytes are valid UTF-8 string./// Should be API-compatible to `String`./// New empty object./// Clear the buffer./// Try convert from `Bytes`/// Len in bytes./// Self-explanatorytest_display_and_debug// bytes violates SB, see https://github.com/tokio-rs/bytes/issues/522coded_input_streambuf_read_or_readerBufReadOrReaderinput_bufInputBufREAD_RAW_BYTES_MAX_ALLOCProtobufErrorWireErrorINPUT_STREAM_BUFFER_SIZE// If an input stream is constructed with a `Read`, we create a// `BufReader` with an internal buffer of this size.NO_LIMITpos_of_buf_startBufReadIter/// Dangerous implementation of `BufRead`./// Unsafe wrapper around BufRead which assumes that `BufRead` buf is/// not moved when `BufRead` is moved./// This assumption is generally incorrect, however, in practice/// `BufReadIter` is created either from `BufRead` reference (which/// cannot  be moved, because it is locked by `CodedInputStream`) or from/// `BufReader` which does not move its buffer (we know that from/// inspecting rust standard library)./// It is important for `CodedInputStream` performance that small reads/// (e. g. 4 bytes reads) do not involve virtual calls or switches./// This is achievable with `BufReadIter`.from_buf_readfrom_byte_sliceupdate_limit_within_buf/// Recompute `limit_within_buf` after update of `limit`push_limitpop_limitremaining_in_bufremaining_in_buf_lenbytes_until_limitread_byte_slowread_exact_bytesuninit_slice_as_mut_slice/// Returns 0 when EOF or limit reached.consume_bufread_to_vec/// Read at most `max` bytes.read_exact_slowread_exact_to_vec/// Read raw bytes into the supplied vector.  The vector will be resized as needed andfill_buf_slowmake_long_stringread_exact_bytes_from_sliceread_exact_bytes_from_bytestest_byteseof_at_limit/// Helper type to simplify `BufReadIter` implementation.read_exact_uninit/// Similar to `read_exact` but reads into `MaybeUninit`.//! `BufRead` pointer or `BufReader` owned.// Invariants: `0 <= pos_within_buf <= limit_within_buf <= buf.len()`.pos_within_buflimit_within_buffrom_bytes_ignore_lifetimeupdate_limit// Keep the field to clarify we logically hold the reference./// Hold all possible combinations of input sourcebuf_read_itermaybe_ununit_array_assume_initreflectProtobufTypeBoolProtobufTypeDoubleProtobufTypeFixedProtobufTypeFixed32ProtobufTypeFixed64ProtobufTypeFloatProtobufTypeInt32ProtobufTypeInt64ProtobufTypeSfixed32ProtobufTypeSfixed64ProtobufTypeSint32ProtobufTypeSint64ProtobufTypeTraitProtobufTypeUint32ProtobufTypeUint64MessageDescriptorvarintdecode_varint32decode_varint64MAX_VARINT_ENCODED_LENwire_formatWireTypezigzagdecode_zig_zag_32decode_zig_zag_64EnumOrUnknownMessageDynDEFAULT_RECURSION_LIMIT// Default recursion level limit. 100 is the default value of C++'s implementation.// Max allocated vec when reading length-delimited from unknown input streamrecursion_levelCodedInputStream/// Buffered read with handy utilities./// Wrap a `Read`./// Note resulting `CodedInputStream` is buffered./// If `Read` is buffered, the resulting stream will be double buffered,/// consider using [`from_buf_read`](Self::from_buf_read) instead./// Create from `BufRead`./// `CodedInputStream` will utilize `BufRead` buffer./// Read from byte slicefrom_tokio_bytes/// Read from `Bytes`./// `CodedInputStream` operations like/// [`read_tokio_bytes`](crate::CodedInputStream::read_tokio_bytes)/// will return a shared copy of this bytes object.from_buf_read_iterset_recursion_limit/// Set the recursion limit.incr_recursiondecr_recursion/// How many bytes processed/// How many bytes until current limit/// Read bytes into given `buf`.read_raw_tokio_bytes/// Read exact number of bytes as `Bytes` object./// This operation returns a shared view if `CodedInputStream` is/// constructed with `Bytes` parameter.read_raw_byte/// Read one byte/// Push new limit, return previous limit./// Restore previous limit./// Are we at EOF?check_eof/// Check we are at EOF./// Return error if we are not at EOF.read_raw_varint64_slowread_raw_varint32_slowread_raw_varint64/// Read varintread_raw_varint32read_raw_varint32_or_eofread_raw_little_endian32/// Read little-endian 32-bit integerread_raw_little_endian64/// Read little-endian 64-bit integerread_raw_tag_or_eof/// Read tag number as `u32` or None if EOF is reached./// Read tagread_tag_unpack/// Read tag, return it is pair (field number, wire type)read_double/// Read `double`read_float/// Read `float`/// Read `int64`/// Read `int32`/// Read `uint64`/// Read `uint32`read_sint64/// Read `sint64`read_sint32/// Read `sint32`read_fixed64/// Read `fixed64`read_fixed32/// Read `fixed32`read_sfixed64/// Read `sfixed64`read_sfixed32/// Read `sfixed32`/// Read `bool`read_enum_valueread_enum/// Read `enum` as `ProtobufEnum`read_enum_or_unknown/// Read `enum` as `ProtobufEnumOrUnknown`read_repeated_packed_fixed_intoProtobufValueread_repeated_packed_intoread_repeated_packed_double_into/// Read repeated packed `double`read_repeated_packed_float_into/// Read repeated packed `float`read_repeated_packed_int64_into/// Read repeated packed `int64`read_repeated_packed_int32_into/// Read repeated packed `int32`read_repeated_packed_uint64_into/// Read repeated packed `uint64`read_repeated_packed_uint32_into/// Read repeated packed `uint32`read_repeated_packed_sint64_into/// Read repeated packed `sint64`read_repeated_packed_sint32_into/// Read repeated packed `sint32`read_repeated_packed_fixed64_into/// Read repeated packed `fixed64`read_repeated_packed_fixed32_into/// Read repeated packed `fixed32`read_repeated_packed_sfixed64_into/// Read repeated packed `sfixed64`read_repeated_packed_sfixed32_into/// Read repeated packed `sfixed32`read_repeated_packed_bool_into/// Read repeated packed `bool`read_repeated_packed_enum_values_into/// Read repeated packed enum values into the vector.skip_groupskip_group_no_depth_checkread_unknown/// Read `UnknownValue`skip_field/// Skip field.read_raw_bytes_intoread_raw_bytes/// Read exact number of bytesskip_raw_bytes/// Skip exact number of bytes/// Read `bytes` field, length delimitedread_tokio_bytesread_tokio_chars/// Read `string` field, length delimitedread_bytes_intoread_string_intomerge_message/// Read message, do not check if message is initializedmerge_message_no_depth_checkmerge_message_dyn/// Like `merge_message`, but for dynamic messages./// Read messageread_message_dyn/// Read message.decode_hexCodedOutputStreamtest_read_partialtest_read_vtest_input_stream_read_raw_bytetest_input_stream_read_raw_varinttest_input_stream_read_raw_varint_out_of_rangetest_input_stream_read_raw_varint_too_longtest_input_stream_read_raw_varint_unexpected_eoftest_input_stream_read_raw_varint_postest_input_stream_read_int32test_input_stream_read_floattest_input_stream_read_doubletest_input_stream_skip_raw_bytestest_input_stream_read_raw_bytestest_input_stream_limitstest_input_stream_io_readtest_input_stream_io_bufreadtest_input_stream_read_raw_bytes_into_huge// Miri is too slow for this test.test_skip_group// Copy of this test: https://tinyurl.com/34hfavtztest_shallow_nested_unknown_groupstest_deeply_nested_unknown_groups// Actual buffer is owned by `OutputTarget`,// and here we alias the buffer so access to the buffer is branchless:// access does not require switch by actual target type: `&[], `Vec`, `Write` etc.// We don't access the actual buffer in `OutputTarget` except when// we initialize `buffer` field here./// Always correct./// Whole buffer: written data + unwritten data.unfilled_lenreplace_buffer_keep_posoutput_targetcoded_output_streamOutputTargetvec_packed_enum_or_unknown_data_sizevec_packed_fixed_data_sizevec_packed_varint_data_sizevec_packed_varint_zigzag_data_sizeencode_varint32encode_varint64encoded_varint64_lencheck_message_sizeMAX_MESSAGE_SIZEencode_zig_zag_32encode_zig_zag_64MessageFullUnknownFieldsUnknownValueRefOUTPUT_STREAM_BUFFER_SIZE// Equal to the default buffer size of `BufWriter`, so when// `CodedOutputStream` wraps `BufWriter`, it often skips double buffering.pos_of_buffer_start/// Absolute position of the buffer start./// Buffered write with handy utilities/// Construct from given `Write`./// `CodedOutputStream` is buffered even if `Write` is not/// `CodedOutputStream` which writes directly to bytes./// Attempt to write more than bytes capacity results in error./// `CodedOutputStream` which writes directly to `Vec<u8>`.reserve_additionalreserve_additional_for_length_delimitedtotal_bytes_written/// Total number of bytes written to this stream./// This number may be larger than the actual number of bytes written to the underlying stream,/// if the buffer was not flushed./// The number may be inaccurate if there was an error during the write./// Check if EOF is reached./// If underlying write has no EOFrefresh_buffer/// Flush to buffer to the underlying buffer./// Note that `CodedOutputStream` does `flush` in the destructor,/// however, if `flush` in destructor fails, then destructor panics/// and program terminates. So it's advisable to explicitly call flush/// before destructor.write_raw_byte/// Write a bytewrite_raw_bytes/// Write byteswrite_tag/// Write a tagwrite_raw_varint32/// Write varintwrite_raw_varint64write_raw_little_endian32/// Write 32-bit integer little endianwrite_raw_little_endian64/// Write 64-bit integer little endianwrite_float_no_tag/// Write `float`write_double_no_tag/// Write `double`write_float/// Write `float` fieldwrite_double/// Write `double` fieldwrite_uint64_no_tagwrite_uint32_no_tagwrite_int64_no_tagwrite_int32_no_tagwrite_sint64_no_tag/// Write zigzag varintwrite_sint32_no_tagwrite_fixed64_no_tag/// Write `fixed64`write_fixed32_no_tag/// Write `fixed32`write_sfixed64_no_tag/// Write `sfixed64`write_sfixed32_no_tag/// Write `sfixed32`write_bool_no_tag/// Write `bool`write_enum_no_tag/// Write `enum`write_enum_obj_no_tagwrite_enum_or_unknown_no_tagwrite_unknown_no_tag/// Write unknown valuewrite_uint64/// Write `uint64` fieldwrite_uint32/// Write `uint32` fieldwrite_int64/// Write `int64` fieldwrite_int32/// Write `int32` fieldwrite_sint64/// Write `sint64` fieldwrite_sint32/// Write `sint32` fieldwrite_fixed64/// Write `fixed64` fieldwrite_fixed32/// Write `fixed32` fieldwrite_sfixed64/// Write `sfixed64` fieldwrite_sfixed32/// Write `sfixed32` fieldwrite_bool/// Write `bool` fieldwrite_enum/// Write `enum` fieldwrite_enum_objwrite_enum_or_unknownwrite_unknown/// Write unknown fieldwrite_unknown_fields/// Write unknown fieldswrite_unknown_fields_sorted/// Write unknown fields sorting them by name// TODO: make unknown fields deterministic and remove this.write_bytes_no_tagwrite_string_no_tag/// Write stringwrite_message_no_tag/// Write messagewrite_message_no_tag_dyn/// Write dynamic message/// Write `bytes` fieldwrite_string/// Write `string` fieldwrite_repeated_packed_float_no_tag/// Write repeated packed float values.write_repeated_packed_float/// Write field header and data for repeated packed float.write_repeated_packed_double_no_tag/// Write repeated packed double values.write_repeated_packed_double/// Write field header and data for repeated packed double.write_repeated_packed_fixed32_no_tag/// Write repeated packed fixed32 values.write_repeated_packed_fixed32/// Write field header and data for repeated packed fixed32.write_repeated_packed_fixed64_no_tag/// Write repeated packed fixed64 values.write_repeated_packed_fixed64/// Write field header and data for repeated packed fixed64.write_repeated_packed_sfixed32_no_tag/// Write repeated packed sfixed32 values.write_repeated_packed_sfixed32/// Write field header and data for repeated packed sfixed32.write_repeated_packed_sfixed64_no_tag/// Write repeated packed sfixed64 values.write_repeated_packed_sfixed64/// Write field header and data for repeated packed sfixed64.write_repeated_packed_int32_no_tag/// Write repeated packed int32 values.write_repeated_packed_int32/// Write field header and data for repeated packed int32.write_repeated_packed_int64_no_tag/// Write repeated packed int64 values.write_repeated_packed_int64/// Write field header and data for repeated packed int64.write_repeated_packed_uint32_no_tag/// Write repeated packed uint32 values.write_repeated_packed_uint32/// Write field header and data for repeated packed uint32.write_repeated_packed_uint64_no_tag/// Write repeated packed uint64 values.write_repeated_packed_uint64/// Write field header and data for repeated packed uint64.write_repeated_packed_sint32_no_tag/// Write repeated packed sint32 values.write_repeated_packed_sint32/// Write field header and data for repeated packed sint32.write_repeated_packed_sint64_no_tag/// Write repeated packed sint64 values.write_repeated_packed_sint64/// Write field header and data for repeated packed sint64.write_repeated_packed_bool_no_tag/// Write repeated packed bool values.write_repeated_packed_bool/// Write field header and data for repeated packed bool.write_repeated_packed_enum_or_unknown_no_tag/// Write repeated packed enum values.write_repeated_packed_enum_or_unknown/// Write field header and data for repeated packed enum./// Write `message` fieldwrite_message_dyn/// Write dynamic `message` fieldtest_output_stream_write_raw_bytetest_output_stream_write_tagtest_output_stream_write_raw_bytestest_output_stream_write_raw_varint32test_output_stream_write_raw_varint64test_output_stream_write_int32_no_tagtest_output_stream_write_int64_no_tagtest_output_stream_write_raw_little_endian32test_output_stream_write_float_no_tagtest_output_stream_write_double_no_tagtest_output_stream_write_raw_little_endian64test_output_stream_io_writeflush_for_vec_does_not_allocate_moretotal_bytes_written_to_bytestotal_bytes_written_to_vectotal_bytes_written_updated_when_writing_lots_of_bytes/// The buffer is passed as `&[u8]` to `CodedOutputStream` constructor/// and immediately converted to `buffer` field of `CodedOutputStream`,/// it is not needed to be stored here./// Lifetime parameter of `CodedOutputStream` guarantees the buffer is valid/// during the lifetime of `CodedOutputStream`./// Output buffer/writer for `CodedOutputStream`.with_coded_output_streamWithCodedOutputStreamFileDescriptorProto// message fields// @@protoc_insertion_point(field:google.protobuf.FileDescriptorSet.file)special_fieldsSpecialFields// special fields// @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorSet.special_fields)FileDescriptorSet///  The protocol compiler can output a FileDescriptorSet containing the .proto///  files it parses.// @@protoc_insertion_point(message:google.protobuf.FileDescriptorSet)generated_message_descriptor_dataGeneratedMessageDescriptorDatamerge_fromcompute_size// Compute sizes of nested messageswrite_to_with_cached_sizesmut_special_fieldsdefault_instanceRuntimeTypeMessage// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.name)// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.package)dependency///  Names of files imported by this file.// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.dependency)public_dependency///  Indexes of the public imported files in the dependency list above.// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.public_dependency)weak_dependency///  Indexes of the weak imported files in the dependency list.///  For Google-internal migration only. Do not use.// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.weak_dependency)DescriptorProto///  All top-level definitions in this file.// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.message_type)EnumDescriptorProto// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.enum_type)ServiceDescriptorProto// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.service)FieldDescriptorProto// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.extension)FileOptionsMessageField// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.options)source_code_infoSourceCodeInfo///  This field contains optional information about the original source code.///  You may safely remove this entire field without harming runtime///  functionality of the descriptors -- the information is needed only by///  development tools.// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.source_code_info)///  The syntax of the proto file.///  The supported values are "proto2" and "proto3".// @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.syntax)// @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorProto.special_fields)///  Describes a complete .proto file.// @@protoc_insertion_point(message:google.protobuf.FileDescriptorProto)clear_name// Param is passed by value, movedmut_name// Mutable pointer to the field.// If field is not initialized, it is initialized with default value first.take_name// Take fieldclear_packagehas_packageset_packagemut_packagetake_packageclear_syntaxhas_syntaxset_syntaxmut_syntaxtake_syntax// optional string name = 1;// optional string package = 2;// optional string syntax = 12;// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.name)// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.field)// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension)nested_type// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.nested_type)// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.enum_type)extension_rangedescriptor_protoExtensionRange// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension_range)oneof_declOneofDescriptorProto// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.oneof_decl)MessageOptions// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.options)reserved_rangeReservedRange// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_range)reserved_name///  Reserved field names, which may not be used by fields in the same message.///  A given name may only be reserved once.// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_name)// @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.special_fields)///  Describes a message type.// @@protoc_insertion_point(message:google.protobuf.DescriptorProto)// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.start)// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.end)ExtensionRangeOptions// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.options)// @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ExtensionRange.special_fields)// @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ExtensionRange)clear_starthas_startclear_endhas_end// optional int32 start = 1;// optional int32 end = 2;// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.start)// @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.end)// @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ReservedRange.special_fields)///  Range of reserved tag numbers. Reserved tag numbers may not be used by///  fields or extension ranges in the same message. Reserved ranges may///  not overlap.// @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ReservedRange)/// Nested message and enums of message `DescriptorProto`uninterpreted_optionUninterpretedOption///  The parser stores options it doesn't recognize here. See above.// @@protoc_insertion_point(field:google.protobuf.ExtensionRangeOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.ExtensionRangeOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.ExtensionRangeOptions)// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.name)// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.number)field_descriptor_proto// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.label)///  If type_name is set, this need not be set.  If both this and type_name///  are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type)///  For message and enum types, this is the name of the type.  If the name///  starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping///  rules are used to find the type (i.e. first the nested types within this///  message are searched, then within the parent, on up to the root///  namespace).// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type_name)extendee///  For extensions, this is the name of the type being extended.  It is///  resolved in the same manner as type_name.// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.extendee)///  For numeric types, contains the original text representation of the value.///  For booleans, "true" or "false".///  For strings, contains the default text contents (not escaped in any way).///  For bytes, contains the C escaped value.  All bytes >= 128 are escaped.///  TODO(kenton):  Base-64 encode?// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.default_value)oneof_index///  If set, gives the index of a oneof in the containing type's oneof_decl///  list.  This field is a member of that oneof.// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.oneof_index)json_name///  JSON name of this field. The value is set by protocol compiler. If the///  user has set a "json_name" option on this field, that option's value///  will be used. Otherwise, it's deduced from the field's name by converting///  it to camelCase.// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.json_name)FieldOptions// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.options)proto3_optional///  If true, this is a proto3 "optional". When a proto3 field is optional, it///  tracks presence regardless of field type.///  When proto3_optional is true, this field must be belong to a oneof to///  signal to old proto3 clients that presence is tracked for this field. This///  oneof is known as a "synthetic" oneof, and this field must be its sole///  member (each proto3 optional field gets its own synthetic oneof). Synthetic///  oneofs exist in the descriptor only, and do not generate any API. Synthetic///  oneofs must be ordered after all "real" oneofs.///  For message fields, proto3_optional doesn't create any semantic change,///  since non-repeated message fields always track presence. However it still///  indicates the semantic detail of whether the user wrote "optional" or not.///  This can be useful for round-tripping the .proto file. For consistency we///  give message fields a synthetic oneof also, even though it is not required///  to track presence. This is especially important because the parser can't///  tell if a field is a message or an enum, so it must always create a///  synthetic oneof.///  Proto2 optional fields do not set this flag, because they already indicate///  optional with `LABEL_OPTIONAL`.// @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.proto3_optional)// @@protoc_insertion_point(special_field:google.protobuf.FieldDescriptorProto.special_fields)///  Describes a field within a message.// @@protoc_insertion_point(message:google.protobuf.FieldDescriptorProto)clear_numberhas_numberset_numberclear_labelhas_labelclear_type_has_typeclear_type_namehas_type_nameset_type_namemut_type_nametake_type_nameclear_extendeehas_extendeeset_extendeemut_extendeetake_extendeeclear_default_valuehas_default_valueset_default_valuemut_default_valuetake_default_valueclear_oneof_indexhas_oneof_indexset_oneof_indexclear_json_namehas_json_nameset_json_namemut_json_nametake_json_nameclear_proto3_optionalhas_proto3_optionalset_proto3_optional// optional int32 number = 3;// optional .google.protobuf.FieldDescriptorProto.Label label = 4;// optional .google.protobuf.FieldDescriptorProto.Type type = 5;// optional string type_name = 6;// optional string extendee = 2;// optional string default_value = 7;// optional int32 oneof_index = 9;// optional string json_name = 10;// optional bool proto3_optional = 17;TYPE_DOUBLE// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_DOUBLE)TYPE_FLOAT// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FLOAT)TYPE_INT64// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT64)TYPE_UINT64// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT64)TYPE_INT32// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT32)TYPE_FIXED64// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED64)TYPE_FIXED32// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED32)TYPE_BOOL// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BOOL)TYPE_STRING// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_STRING)TYPE_GROUP// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP)TYPE_MESSAGE// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE)TYPE_BYTES// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES)TYPE_UINT32// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT32)TYPE_ENUM// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM)TYPE_SFIXED32// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED32)TYPE_SFIXED64// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED64)TYPE_SINT32// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT32)TYPE_SINT64// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT64)// @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Type)VALUESenum_descriptorEnumDescriptorEnumValueDescriptorEnumFull// Note, `Default` is implemented although default value is not 0generated_enum_descriptor_dataGeneratedEnumDescriptorDataLABEL_OPTIONAL// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_OPTIONAL)LABEL_REQUIRED// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED)LABEL_REPEATED// @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED)// @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Label)/// Nested message and enums of message `FieldDescriptorProto`// @@protoc_insertion_point(field:google.protobuf.OneofDescriptorProto.name)OneofOptions// @@protoc_insertion_point(field:google.protobuf.OneofDescriptorProto.options)// @@protoc_insertion_point(special_field:google.protobuf.OneofDescriptorProto.special_fields)///  Describes a oneof.// @@protoc_insertion_point(message:google.protobuf.OneofDescriptorProto)// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.name)EnumValueDescriptorProto// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.value)EnumOptions// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.options)enum_descriptor_protoEnumReservedRange///  Range of reserved numeric values. Reserved numeric values may not be used///  by enum values in the same enum declaration. Reserved ranges may not///  overlap.// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.reserved_range)///  Reserved enum value names, which may not be reused. A given name may only///  be reserved once.// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.reserved_name)// @@protoc_insertion_point(special_field:google.protobuf.EnumDescriptorProto.special_fields)///  Describes an enum type.// @@protoc_insertion_point(message:google.protobuf.EnumDescriptorProto)// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)// @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)// @@protoc_insertion_point(special_field:google.protobuf.EnumDescriptorProto.EnumReservedRange.special_fields)///  Range of reserved numeric values. Reserved values may not be used by///  entries in the same enum. Reserved ranges may not overlap.///  Note that this is distinct from DescriptorProto.ReservedRange in that it///  is inclusive such that it can appropriately represent the entire int32///  domain.// @@protoc_insertion_point(message:google.protobuf.EnumDescriptorProto.EnumReservedRange)/// Nested message and enums of message `EnumDescriptorProto`// @@protoc_insertion_point(field:google.protobuf.EnumValueDescriptorProto.name)// @@protoc_insertion_point(field:google.protobuf.EnumValueDescriptorProto.number)EnumValueOptions// @@protoc_insertion_point(field:google.protobuf.EnumValueDescriptorProto.options)// @@protoc_insertion_point(special_field:google.protobuf.EnumValueDescriptorProto.special_fields)///  Describes a value within an enum.// @@protoc_insertion_point(message:google.protobuf.EnumValueDescriptorProto)// optional int32 number = 2;// @@protoc_insertion_point(field:google.protobuf.ServiceDescriptorProto.name)MethodDescriptorProto// @@protoc_insertion_point(field:google.protobuf.ServiceDescriptorProto.method)ServiceOptions// @@protoc_insertion_point(field:google.protobuf.ServiceDescriptorProto.options)// @@protoc_insertion_point(special_field:google.protobuf.ServiceDescriptorProto.special_fields)///  Describes a service.// @@protoc_insertion_point(message:google.protobuf.ServiceDescriptorProto)// @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.name)input_type///  Input and output type names.  These are resolved in the same way as///  FieldDescriptorProto.type_name, but must refer to a message type.// @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.input_type)// @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.output_type)MethodOptions// @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.options)client_streaming///  Identifies if client streams multiple client messages// @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.client_streaming)server_streaming///  Identifies if server streams multiple server messages// @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.server_streaming)// @@protoc_insertion_point(special_field:google.protobuf.MethodDescriptorProto.special_fields)///  Describes a method of a service.// @@protoc_insertion_point(message:google.protobuf.MethodDescriptorProto)clear_input_typehas_input_typeset_input_typemut_input_typetake_input_typeclear_output_typehas_output_typeset_output_typemut_output_typetake_output_typeclear_client_streaminghas_client_streamingset_client_streamingclear_server_streaminghas_server_streamingset_server_streaming// optional string input_type = 2;// optional string output_type = 3;// optional bool client_streaming = 5;// optional bool server_streaming = 6;java_package///  Sets the Java package where classes generated from this .proto will be///  placed.  By default, the proto package is used, but this is often///  inappropriate because proto packages do not normally start with backwards///  domain names.// @@protoc_insertion_point(field:google.protobuf.FileOptions.java_package)java_outer_classname///  Controls the name of the wrapper Java class generated for the .proto file.///  That class will always contain the .proto file's getDescriptor() method as///  well as any top-level extensions defined in the .proto file.///  If java_multiple_files is disabled, then all the other classes from the///  .proto file will be nested inside the single wrapper outer class.// @@protoc_insertion_point(field:google.protobuf.FileOptions.java_outer_classname)java_multiple_files///  If enabled, then the Java code generator will generate a separate .java///  file for each top-level message, enum, and service defined in the .proto///  file.  Thus, these types will *not* be nested inside the wrapper class///  named by java_outer_classname.  However, the wrapper class will still be///  generated to contain the file's getDescriptor() method as well as any///  top-level extensions defined in the file.// @@protoc_insertion_point(field:google.protobuf.FileOptions.java_multiple_files)java_generate_equals_and_hash///  This option does nothing.// @@protoc_insertion_point(field:google.protobuf.FileOptions.java_generate_equals_and_hash)java_string_check_utf8///  If set true, then the Java2 code generator will generate code that///  throws an exception whenever an attempt is made to assign a non-UTF-8///  byte sequence to a string field.///  Message reflection will do the same.///  However, an extension field still accepts non-UTF-8 byte sequences.///  This option has no effect on when used with the lite runtime.// @@protoc_insertion_point(field:google.protobuf.FileOptions.java_string_check_utf8)optimize_forfile_optionsOptimizeMode// @@protoc_insertion_point(field:google.protobuf.FileOptions.optimize_for)go_package///  Sets the Go package where structs generated from this .proto will be///  placed. If omitted, the Go package will be derived from the following:///    - The basename of the package import path, if provided.///    - Otherwise, the package statement in the .proto file, if present.///    - Otherwise, the basename of the .proto file, without extension.// @@protoc_insertion_point(field:google.protobuf.FileOptions.go_package)cc_generic_services///  Should generic services be generated in each language?  "Generic" services///  are not specific to any particular RPC system.  They are generated by the///  main code generators in each language (without additional plugins).///  Generic services were the only kind of service generation supported by///  early versions of google.protobuf.///  Generic services are now considered deprecated in favor of using plugins///  that generate code specific to your particular RPC system.  Therefore,///  these default to false.  Old code which depends on generic services should///  explicitly set them to true.// @@protoc_insertion_point(field:google.protobuf.FileOptions.cc_generic_services)java_generic_services// @@protoc_insertion_point(field:google.protobuf.FileOptions.java_generic_services)py_generic_services// @@protoc_insertion_point(field:google.protobuf.FileOptions.py_generic_services)php_generic_services// @@protoc_insertion_point(field:google.protobuf.FileOptions.php_generic_services)///  Is this file deprecated?///  Depending on the target platform, this can emit Deprecated annotations///  for everything in the file, or it will be completely ignored; in the very///  least, this is a formalization for deprecating files.// @@protoc_insertion_point(field:google.protobuf.FileOptions.deprecated)cc_enable_arenas///  Enables the use of arenas for the proto messages in this file. This applies///  only to generated classes for C++.// @@protoc_insertion_point(field:google.protobuf.FileOptions.cc_enable_arenas)objc_class_prefix///  Sets the objective c class prefix which is prepended to all objective c///  generated classes from this .proto. There is no default.// @@protoc_insertion_point(field:google.protobuf.FileOptions.objc_class_prefix)csharp_namespace///  Namespace for generated classes; defaults to the package.// @@protoc_insertion_point(field:google.protobuf.FileOptions.csharp_namespace)swift_prefix///  By default Swift generators will take the proto package and CamelCase it///  replacing '.' with underscore and use that to prefix the types/symbols///  defined. When this options is provided, they will use this value instead///  to prefix the types/symbols defined.// @@protoc_insertion_point(field:google.protobuf.FileOptions.swift_prefix)php_class_prefix///  Sets the php class prefix which is prepended to all php generated classes///  from this .proto. Default is empty.// @@protoc_insertion_point(field:google.protobuf.FileOptions.php_class_prefix)php_namespace///  Use this option to change the namespace of php generated classes. Default///  is empty. When this option is empty, the package name will be used for///  determining the namespace.// @@protoc_insertion_point(field:google.protobuf.FileOptions.php_namespace)php_metadata_namespace///  Use this option to change the namespace of php generated metadata classes.///  Default is empty. When this option is empty, the proto file name will be///  used for determining the namespace.// @@protoc_insertion_point(field:google.protobuf.FileOptions.php_metadata_namespace)ruby_package///  Use this option to change the package of ruby generated classes. Default///  is empty. When this option is not set, the package name will be used for///  determining the ruby package.// @@protoc_insertion_point(field:google.protobuf.FileOptions.ruby_package)///  The parser stores options it doesn't recognize here.///  See the documentation for the "Options" section above.// @@protoc_insertion_point(field:google.protobuf.FileOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.FileOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.FileOptions)clear_java_packagehas_java_packageset_java_packagemut_java_packagetake_java_packageclear_java_outer_classnamehas_java_outer_classnameset_java_outer_classnamemut_java_outer_classnametake_java_outer_classnameclear_java_multiple_fileshas_java_multiple_filesset_java_multiple_filesclear_java_generate_equals_and_hashhas_java_generate_equals_and_hashset_java_generate_equals_and_hashclear_java_string_check_utf8has_java_string_check_utf8set_java_string_check_utf8clear_optimize_forhas_optimize_forset_optimize_forclear_go_packagehas_go_packageset_go_packagemut_go_packagetake_go_packageclear_cc_generic_serviceshas_cc_generic_servicesset_cc_generic_servicesclear_java_generic_serviceshas_java_generic_servicesset_java_generic_servicesclear_py_generic_serviceshas_py_generic_servicesset_py_generic_servicesclear_php_generic_serviceshas_php_generic_servicesset_php_generic_servicesclear_deprecatedhas_deprecatedset_deprecatedclear_cc_enable_arenashas_cc_enable_arenasset_cc_enable_arenasclear_objc_class_prefixhas_objc_class_prefixset_objc_class_prefixmut_objc_class_prefixtake_objc_class_prefixclear_csharp_namespacehas_csharp_namespaceset_csharp_namespacemut_csharp_namespacetake_csharp_namespaceclear_swift_prefixhas_swift_prefixset_swift_prefixmut_swift_prefixtake_swift_prefixclear_php_class_prefixhas_php_class_prefixset_php_class_prefixmut_php_class_prefixtake_php_class_prefixclear_php_namespacehas_php_namespaceset_php_namespacemut_php_namespacetake_php_namespaceclear_php_metadata_namespacehas_php_metadata_namespaceset_php_metadata_namespacemut_php_metadata_namespacetake_php_metadata_namespaceclear_ruby_packagehas_ruby_packageset_ruby_packagemut_ruby_packagetake_ruby_package// optional string java_package = 1;// optional string java_outer_classname = 8;// optional bool java_multiple_files = 10;// optional bool java_generate_equals_and_hash = 20;// optional bool java_string_check_utf8 = 27;// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9;// optional string go_package = 11;// optional bool cc_generic_services = 16;// optional bool java_generic_services = 17;// optional bool py_generic_services = 18;// optional bool php_generic_services = 42;// optional bool deprecated = 23;// optional bool cc_enable_arenas = 31;// optional string objc_class_prefix = 36;// optional string csharp_namespace = 37;// optional string swift_prefix = 39;// optional string php_class_prefix = 40;// optional string php_namespace = 41;// optional string php_metadata_namespace = 44;// optional string ruby_package = 45;SPEED// @@protoc_insertion_point(enum_value:google.protobuf.FileOptions.OptimizeMode.SPEED)CODE_SIZE// @@protoc_insertion_point(enum_value:google.protobuf.FileOptions.OptimizeMode.CODE_SIZE)LITE_RUNTIME// @@protoc_insertion_point(enum_value:google.protobuf.FileOptions.OptimizeMode.LITE_RUNTIME)///  Generated classes can be optimized for speed or code size.// @@protoc_insertion_point(enum:google.protobuf.FileOptions.OptimizeMode)/// Nested message and enums of message `FileOptions`message_set_wire_format// @@protoc_insertion_point(field:google.protobuf.MessageOptions.message_set_wire_format)no_standard_descriptor_accessor///  Disables the generation of the standard "descriptor()" accessor, which can///  conflict with a field of the same name.  This is meant to make migration///  from proto1 easier; new code should avoid fields named "descriptor".// @@protoc_insertion_point(field:google.protobuf.MessageOptions.no_standard_descriptor_accessor)///  Is this message deprecated?///  for the message, or it will be completely ignored; in the very least,///  this is a formalization for deprecating messages.// @@protoc_insertion_point(field:google.protobuf.MessageOptions.deprecated)map_entry// @@protoc_insertion_point(field:google.protobuf.MessageOptions.map_entry)// @@protoc_insertion_point(field:google.protobuf.MessageOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.MessageOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.MessageOptions)clear_message_set_wire_formathas_message_set_wire_formatset_message_set_wire_formatclear_no_standard_descriptor_accessorhas_no_standard_descriptor_accessorset_no_standard_descriptor_accessorclear_map_entryhas_map_entryset_map_entry// optional bool message_set_wire_format = 1;// optional bool no_standard_descriptor_accessor = 2;// optional bool deprecated = 3;// optional bool map_entry = 7;ctypefield_options///  The ctype option instructs the C++ code generator to use a different///  representation of the field than it normally would.  See the specific///  options below.  This option is not yet implemented in the open source///  release -- sorry, we'll try to include it in a future version!// @@protoc_insertion_point(field:google.protobuf.FieldOptions.ctype)///  The packed option can be enabled for repeated primitive fields to enable///  a more efficient representation on the wire. Rather than repeatedly///  writing the tag and type for each element, the entire array is encoded as///  a single length-delimited blob. In proto3, only explicit setting it to///  false will avoid using packed encoding.// @@protoc_insertion_point(field:google.protobuf.FieldOptions.packed)jstypeJSType///  The jstype option determines the JavaScript type used for values of the///  field.  The option is permitted only for 64 bit integral and fixed types///  (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING///  is represented as JavaScript string, which avoids loss of precision that///  can happen when a large value is converted to a floating point JavaScript.///  Specifying JS_NUMBER for the jstype causes the generated JavaScript code to///  use the JavaScript "number" type.  The behavior of the default option///  JS_NORMAL is implementation dependent.///  This option is an enum to permit additional types to be added, e.g.///  goog.math.Integer.// @@protoc_insertion_point(field:google.protobuf.FieldOptions.jstype)///  Should this field be parsed lazily?  Lazy applies only to message-type///  fields.  It means that when the outer message is initially parsed, the///  inner message's contents will not be parsed but instead stored in encoded///  form.  The inner message will actually be parsed when it is first accessed.///  This is only a hint.  Implementations are free to choose whether to use///  eager or lazy parsing regardless of the value of this option.  However,///  setting this option true suggests that the protocol author believes that///  using lazy parsing on this field is worth the additional bookkeeping///  overhead typically needed to implement it.///  This option does not affect the public interface of any generated code;///  all method signatures remain the same.  Furthermore, thread-safety of the///  interface is not affected by this option; const methods remain safe to///  call from multiple threads concurrently, while non-const methods continue///  to require exclusive access.///  Note that implementations may choose not to check required fields within///  a lazy sub-message.  That is, calling IsInitialized() on the outer message///  may return true even if the inner message has missing required fields.///  This is necessary because otherwise the inner message would have to be///  parsed in order to perform the check, defeating the purpose of lazy///  parsing.  An implementation which chooses not to check required fields///  must be consistent about it.  That is, for any particular sub-message, the///  implementation must either *always* check its required fields, or *never*///  check its required fields, regardless of whether or not the message has///  been parsed.// @@protoc_insertion_point(field:google.protobuf.FieldOptions.lazy)///  Is this field deprecated?///  for accessors, or it will be completely ignored; in the very least, this///  is a formalization for deprecating fields.// @@protoc_insertion_point(field:google.protobuf.FieldOptions.deprecated)// @@protoc_insertion_point(field:google.protobuf.FieldOptions.weak)// @@protoc_insertion_point(field:google.protobuf.FieldOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.FieldOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.FieldOptions)clear_ctypehas_ctypeset_ctypeclear_packedhas_packedset_packedclear_jstypehas_jstypeset_jstypeclear_lazyhas_lazyset_lazyclear_weakhas_weakset_weak// optional .google.protobuf.FieldOptions.CType ctype = 1;// optional bool packed = 2;// optional .google.protobuf.FieldOptions.JSType jstype = 6;// optional bool lazy = 5;// optional bool weak = 10;// @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.CType.STRING)CORD// @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.CType.CORD)STRING_PIECE// @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.CType.STRING_PIECE)// @@protoc_insertion_point(enum:google.protobuf.FieldOptions.CType)JS_NORMAL// @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.JSType.JS_NORMAL)JS_STRING// @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.JSType.JS_STRING)JS_NUMBER// @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.JSType.JS_NUMBER)// @@protoc_insertion_point(enum:google.protobuf.FieldOptions.JSType)/// Nested message and enums of message `FieldOptions`// @@protoc_insertion_point(field:google.protobuf.OneofOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.OneofOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.OneofOptions)allow_alias///  Set this option to true to allow mapping different tag names to the same///  value.// @@protoc_insertion_point(field:google.protobuf.EnumOptions.allow_alias)///  Is this enum deprecated?///  for the enum, or it will be completely ignored; in the very least, this///  is a formalization for deprecating enums.// @@protoc_insertion_point(field:google.protobuf.EnumOptions.deprecated)// @@protoc_insertion_point(field:google.protobuf.EnumOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.EnumOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.EnumOptions)clear_allow_aliashas_allow_aliasset_allow_alias// optional bool allow_alias = 2;///  Is this enum value deprecated?///  for the enum value, or it will be completely ignored; in the very least,///  this is a formalization for deprecating enum values.// @@protoc_insertion_point(field:google.protobuf.EnumValueOptions.deprecated)// @@protoc_insertion_point(field:google.protobuf.EnumValueOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.EnumValueOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.EnumValueOptions)// optional bool deprecated = 1;///  Is this service deprecated?///  for the service, or it will be completely ignored; in the very least,///  this is a formalization for deprecating services.// @@protoc_insertion_point(field:google.protobuf.ServiceOptions.deprecated)// @@protoc_insertion_point(field:google.protobuf.ServiceOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.ServiceOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.ServiceOptions)// optional bool deprecated = 33;///  Is this method deprecated?///  for the method, or it will be completely ignored; in the very least,///  this is a formalization for deprecating methods.// @@protoc_insertion_point(field:google.protobuf.MethodOptions.deprecated)idempotency_levelmethod_optionsIdempotencyLevel// @@protoc_insertion_point(field:google.protobuf.MethodOptions.idempotency_level)// @@protoc_insertion_point(field:google.protobuf.MethodOptions.uninterpreted_option)// @@protoc_insertion_point(special_field:google.protobuf.MethodOptions.special_fields)// @@protoc_insertion_point(message:google.protobuf.MethodOptions)clear_idempotency_levelhas_idempotency_levelset_idempotency_level// optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34;IDEMPOTENCY_UNKNOWN// @@protoc_insertion_point(enum_value:google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN)NO_SIDE_EFFECTS// @@protoc_insertion_point(enum_value:google.protobuf.MethodOptions.IdempotencyLevel.NO_SIDE_EFFECTS)IDEMPOTENT// @@protoc_insertion_point(enum_value:google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENT)///  Is this method side-effect-free (or safe in HTTP parlance), or idempotent,///  or neither? HTTP based RPC implementation may choose GET verb for safe///  methods, and PUT verb for idempotent methods instead of the default POST.// @@protoc_insertion_point(enum:google.protobuf.MethodOptions.IdempotencyLevel)/// Nested message and enums of message `MethodOptions`NamePart// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.name)identifier_value///  The value of the uninterpreted option, in whatever type the tokenizer///  identified it as during parsing. Exactly one of these should be set.// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.identifier_value)positive_int_value// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.positive_int_value)negative_int_value// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.negative_int_value)double_value// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.double_value)// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.string_value)aggregate_value// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.aggregate_value)// @@protoc_insertion_point(special_field:google.protobuf.UninterpretedOption.special_fields)///  A message representing a option the parser does not recognize. This only///  appears in options protos created by the compiler::Parser class.///  DescriptorPool resolves these when building Descriptor objects. Therefore,///  options protos in descriptor objects (e.g. returned by Descriptor::options(),///  or produced by Descriptor::CopyTo()) will never have UninterpretedOptions///  in them.// @@protoc_insertion_point(message:google.protobuf.UninterpretedOption)clear_identifier_valuehas_identifier_valueset_identifier_valuemut_identifier_valuetake_identifier_valueclear_positive_int_valuehas_positive_int_valueset_positive_int_valueclear_negative_int_valuehas_negative_int_valueset_negative_int_valueclear_double_valuehas_double_valueset_double_valueclear_string_valuehas_string_valueset_string_valuemut_string_valuetake_string_valueclear_aggregate_valuehas_aggregate_valueset_aggregate_valuemut_aggregate_valuetake_aggregate_value// optional string identifier_value = 3;// optional uint64 positive_int_value = 4;// optional int64 negative_int_value = 5;// optional double double_value = 6;// optional bytes string_value = 7;// optional string aggregate_value = 8;name_part// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.NamePart.name_part)is_extension// @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.NamePart.is_extension)// @@protoc_insertion_point(special_field:google.protobuf.UninterpretedOption.NamePart.special_fields)///  The name of the uninterpreted option.  Each string represents a segment in///  a dot-separated name.  is_extension is true iff a segment represents an///  extension (denoted with parentheses in options specs in .proto files).///  E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents///  "foo.(bar.baz).qux".// @@protoc_insertion_point(message:google.protobuf.UninterpretedOption.NamePart)clear_name_parthas_name_partset_name_partmut_name_parttake_name_partclear_is_extensionhas_is_extensionset_is_extension// required string name_part = 1;// required bool is_extension = 2;/// Nested message and enums of message `UninterpretedOption`// @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.location)// @@protoc_insertion_point(special_field:google.protobuf.SourceCodeInfo.special_fields)///  Encapsulates information about the original source file from which a///  FileDescriptorProto was generated.// @@protoc_insertion_point(message:google.protobuf.SourceCodeInfo)// @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.path)///  Always has exactly three or four elements: start line, start column,///  end line (optional, otherwise assumed same as start line), end column.///  These are packed into a single field for efficiency.  Note that line///  and column numbers are zero-based -- typically you will want to add///  1 to each before displaying to a user.// @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.span)leading_comments// @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.leading_comments)trailing_comments// @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.trailing_comments)leading_detached_comments// @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)// @@protoc_insertion_point(special_field:google.protobuf.SourceCodeInfo.Location.special_fields)// @@protoc_insertion_point(message:google.protobuf.SourceCodeInfo.Location)clear_leading_commentshas_leading_commentsset_leading_commentsmut_leading_commentstake_leading_commentsclear_trailing_commentshas_trailing_commentsset_trailing_commentsmut_trailing_commentstake_trailing_comments// optional string leading_comments = 3;// optional string trailing_comments = 4;/// Nested message and enums of message `SourceCodeInfo`annotationgenerated_code_info///  An Annotation connects some span of text in generated code to an element///  of its generating .proto file.// @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.annotation)// @@protoc_insertion_point(special_field:google.protobuf.GeneratedCodeInfo.special_fields)GeneratedCodeInfo///  Describes the relationship between generated code and its original source///  file. A GeneratedCodeInfo message is associated with only one generated///  source file, but may contain references to different source .proto files.// @@protoc_insertion_point(message:google.protobuf.GeneratedCodeInfo)///  Identifies the element in the original source .proto file. This field///  is formatted the same as SourceCodeInfo.Location.path.// @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.path)///  Identifies the filesystem path to the original source .proto.// @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.source_file)///  Identifies the starting offset in bytes in the generated code///  that relates to the identified object.// @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.begin)///  Identifies the ending offset in bytes in the generated code that///  relates to the identified offset. The end offset should be one past///  the last relevant byte (so the length of the text = end - begin).// @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.end)// @@protoc_insertion_point(special_field:google.protobuf.GeneratedCodeInfo.Annotation.special_fields)// @@protoc_insertion_point(message:google.protobuf.GeneratedCodeInfo.Annotation)clear_source_filehas_source_fileset_source_filemut_source_filetake_source_fileclear_beginhas_beginset_begin// optional string source_file = 2;// optional int32 begin = 3;// optional int32 end = 4;/// Nested message and enums of message `GeneratedCodeInfo`file_descriptor_proto_datafile_descriptor_proto/// `FileDescriptorProto` object which was a source for this generated filefile_descriptor/// `FileDescriptor` object which allows dynamic access to files// This file is generated by rust-protobuf 4.0.0-alpha.0. Do not edit// .proto file is parsed by protoc --rs_out=...// @generated// https://github.com/rust-lang/rust-clippy/issues/702//! Generated file from `google/protobuf/descriptor.proto`// @@protoc_insertion_point(special_field:MyMessage.special_fields)MyMessage// @@protoc_insertion_point(message:MyMessage)//! Generated file from `doctest_pb.proto`/// Get enum value descriptor./// Get enum descriptor by type./// Trait is implemented for all enum types if lite runtime is not requested./// This trait provides access to runtime reflection.runtime_typesRuntimeTypeEnumOrUnknown/// Protobuf enums with possibly unknown values are preserved in this struct.// This should be <E: ProtobufEnum> when it no longer prevents using const fns./// Construct from any `i32` value./// Note passed value is not required to be a valid enum value.// Move into <E: ProtobufEnum> when no longer:// > trait bounds other than `Sized` on const fn parameters are unstable./// Construct from typed enum/// Get contained `i32` value of enumenum_value/// Get `i32` value as typed enum. Return `None` is value is unknown./// Get contained enum, panic if value is unknown.enum_value_or_default/// Get `i32` value as typed enum./// Return default enum value (first value) if value is unknown.enum_value_or/// Return given enum value if value is unknown.cast_to_values/// Enum name as specified in `.proto` file./// There's full reflection when non-lite runtime code generation is used,/// and enums implement [`EnumFull`](crate::EnumFull) trait./// This operation is for lite runtime./// Get enum `i32` value./// Try to create an enum from `i32` value./// Return `None` if value is unknown./// Try to create an enum from `&str` value./// Return `None` if str is unknown./// All enum values for enum type./// Trait implemented by all protobuf enum types./// Additionally, generated enums also implement [`EnumFull`](crate::EnumFull) trait,/// which provides access to reflection.ReflectError/// [`Result`] alias for [`Error`].UnexpectedWireTypeIncorrectTagIncorrectVarintInvalidEnumValueOverRecursionLimitTruncatedMessageLimitOverflow// not really possibleLimitIncreaseU32OverflowI32Overflow/// Enum values added here for diagnostic purposes./// Users should not depend on specific values./// I/O error when reading or writing/// Malformed input/// Protocol contains a string which is not valid UTF-8 stringMessageNotInitialized/// Not all required fields of message set.BufferHasNotEnoughCapacity/// Message is too large.IncompatibleProtobufTypeAndRuntimeType/// Protobuf type and runtime types mismatch.GroupIsNotImplemented/// Group field type not implemented./// Generic protobuf error/// Error type for protobuf operations.error_sizeRuntimeTypeTraitfield_number/// Extension field number.field_type/// Extension field type./// MarkerExtFieldOptional/// Optional ext field/// This is initialized from generated code, do not instantiate directly./// Extension field number/// Field type.ExtFieldRepeated/// Repeated ext field/// Constructor. Called from generated code./// Get a copy of value from a message./// Extension data is stored in [`UnknownFields`](crate::UnknownFields)./// Get a copy of value from a message (**not implemented**).//! Utilities to support "extension" fields.//! This is a stopgap implementation, it only allows to fetch basic singular values,//! and that's it. Anything similar to extension registry is not implemented yet.//! Extensions are [described in the official protobuf documentation][exts].//! [exts]: https://developers.google.com/protocol-buffers/docs/proto#extensions/// Size of this fixed type in bytes.ProtobufFixed/// Fixed size integers./// Technically `bool` is not fixed, but it can be considered as fixed/// for the purpose of encoding./// Lazily initialized static variable./// Used in generated code./// Currently a wrapper around `once_cell`s `OnceCell`./// Uninitialized state./// Lazily initialize the value.enum_fullenum_or_unknownmessage_dynmessage_fieldoneofOneofoneof_fullOneofFullUnknownFieldsIter// generatedrustprotoowning_reftext_formatwell_known_typeswell_known_types_util"../../test-crates/protobuf-test-common/src/hex.rs"// used by testcached_size" protobuf crate version"" This symbol is used by codegen"VERSION_IDENT" This symbol can be referenced to assert that proper version of crate is used"VERSION_3_7_2//! # Library to read and write protocol buffers data//! This crate has one feature, which is `with-bytes`.//! `with-bytes` enables `protobuf` crate support for//! [`bytes` crate](https://github.com/tokio-rs/bytes)://! when parsing bytes or strings from `bytes::Bytes`,//! `protobuf` will be able to reference the input instead of allocating subarrays.//! Note, codegen also need to be instructed to generate `Bytes` or `Chars` for//! `bytes` or `string` protobuf types instead of default `Vec<u8>` or `String`,//! just enabling option on this crate is not enough.//! See `Customize` struct in [`protobuf-codegen` crate](https://docs.rs/protobuf-codegen).//! ## Accompanying crates//! * [`protobuf-json-mapping`](https://docs.rs/protobuf-json-mapping)//!   implements JSON parsing and serialization for protobuf messages.//! * [`protobuf-codegen`](https://docs.rs/protobuf-codegen)//!   can be used to generate rust code from `.proto` crates.//! * [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored)//!   contains `protoc` command packed into the crate.//! * [`protobuf-parse`](https://docs.rs/protobuf-parse) contains//!   `.proto` file parser. Rarely need to be used directly,//!   but can be used for mechanical processing of `.proto` files./// Message name as specified in `.proto` file./// Message name can be accessed using/// [`MessageFull::descriptor`](crate::MessageFull::descriptor),/// but when lite runtime is requested, this field can be used./// True iff all required fields are initialized./// Always returns `true` for protobuf 3./// Update this message object with fields read from given stream./// Parse message from stream./// Write message to the stream./// Sizes of this messages and nested messages must be cached/// by calling `compute_size` prior to this call./// Compute and cache size of this message and all nested messages./// Note if the computation overflows u32, the cached size is stored truncated./// Get size previously computed by `compute_size`./// Note if message size exceeds u32, the cached size is stored truncated./// Write the message to the stream./// Results in error if message is not fully initialized.write_length_delimited_to/// Write the message to the stream prepending the message with message length/// encoded as varint.write_length_delimited_to_vec/// Write the message to the vec, prepend the message with message lengthmerge_from_bytesparse_from_reader/// Parse message from reader./// Parse stops on EOF or when error encountered.parse_from_bytes/// Parse message from byte array.parse_from_tokio_bytes/// Parse message from `Bytes` object./// Resulting message may share references to the passed bytes object.check_initialized/// Check if all required fields of this object are initialized.write_to_writer/// Write the message to the writer.write_to_vec/// Write the message to bytes vec.write_to_bytes/// > **Note**: You can use [`Message::parse_from_bytes`]/// to do the reverse.write_length_delimited_to_writer/// Write the message to the writer, prepend the message with message lengthwrite_length_delimited_to_bytes/// Write the message to the bytes vec, prepend the message with message length/// Special fields (unknown fields and cached size).unknown_fields/// Get a reference to unknown fields.mut_unknown_fields/// Get a mutable reference to unknown fields./// Create an empty message object./// # use protobuf::MessageFull;/// # fn foo<MyMessage: MessageFull>() {/// let m = MyMessage::new();/// Reset all fields./// Return a pointer to default immutable message with static lifetime./// let m: &MyMessage = MyMessage::default_instance();/// Trait which is implemented by all generated message./// Note, by default all generated messages also implement [`MessageFull`](crate::MessageFull)/// trait which provides access to reflection and features which depend on reflection/// (text format and JSON serialization).ReflectEqModedescriptor_dyn/// Message descriptor for this message, used for reflection.merge_from_dyn/// Update this message fields with contents of given stream.write_to_with_cached_sizes_dyn/// Write the message.compute_size_dyn/// Compute (and cache) the message size.is_initialized_dynspecial_fields_dyn/// Get a reference to special fields.mut_special_fields_dyn/// Get a mutable reference to special fields./// Dynamic-dispatch version of either generated message or dynamic message./// Generated messages implement [`MessageFull`](crate::MessageFull) unless lite runtime requested./// Dynamic messages can be created with/// [`FileDescriptor::new_dynamic`](crate::reflect::FileDescriptor::new_dynamic).check_initialized_dynwrite_to_writer_dynwrite_to_vec_dynwrite_to_dynwrite_length_delimited_to_vec_dynmerge_from_bytes_dynwrite_to_bytes_dyn/// > **Note**: You can use [`Message::parse_from_bytes`](crate::Message::parse_from_bytes)write_length_delimited_to_dynwrite_length_delimited_to_writer_dynwrite_length_delimited_to_bytes_dynunknown_fields_dynmut_unknown_fields_dyndowncast_box/// Downcast `Box<dyn Message>` to specific message type./// # use protobuf::{MessageFull, MessageDyn};/// # fn foo<MyMessage: MessageFull>(message: Box<dyn MessageDyn>) {/// let m: Box<dyn MessageDyn> = message;/// let m: Box<MyMessage> = <dyn MessageDyn>::downcast_box(m).unwrap();/// Downcast `&dyn Message` to specific message type./// # fn foo<MyMessage: MessageFull>(message: &dyn MessageDyn) {/// let m: &dyn MessageDyn = message;/// let m: &MyMessage = <dyn MessageDyn>::downcast_ref(m).unwrap();/// Downcast `&mut dyn Message` to specific message type./// # fn foo<MyMessage: MessageFull>(message: &mut dyn MessageDyn) {/// let m: &mut dyn MessageDyn = message;/// let m: &mut MyMessage = <dyn MessageDyn>::downcast_mut(m).unwrap();/// Clone from a `dyn Message` reference.reflect_eq_dyn/// Reflectively compare the messages./// Wrapper around `Option<Box<T>>`, convenient newtype./// # use protobuf::MessageField;/// # use std::ops::Add;/// # struct Address {/// # struct Customer {/// #     address: MessageField<Address>,/// # impl Customer {/// #     fn new() -> Customer { unimplemented!() }/// # fn make_address() -> Address { unimplemented!() }/// let mut customer = Customer::new();/// // field of type `SingularPtrField` can be initialized like this/// customer.address = MessageField::some(make_address());/// // or using `Option` and `Into`/// customer.address = Some(make_address()).into();/// Construct `SingularPtrField` from given object./// Construct an empty `SingularPtrField`.from_option/// Construct `SingularPtrField` from optional./// True iff this object contains data./// True iff this object contains no data./// Convert into `Option<T>`./// View data as reference option./// View data as mutable reference option./// Take the data./// Panics if empty/// Take the data or return supplied default element if empty./// Apply given function to contained data to construct another `SingularPtrField`./// Returns empty `SingularPtrField` if this object is empty./// View data as iterator./// View data as mutable iterator./// Take data as option, leaving this object empty./// Clear this object, but do not call destructor of underlying data.unwrap_or_default/// Get contained data, consume self. Return default value for type if this is empty./// Get a reference to contained value or a default instance.mut_or_insert_default/// Get a mutable reference to contained value, initialize if not initialized yet./// Get a reference to contained value or a default instance if the field is not initialized./// We don't have `From<Option<Box<T>>> for MessageField<T>` because/// it would make type inference worse.reflect_eq/// Get message descriptor for message type./// let descriptor = MyMessage::descriptor();/// assert_eq!("MyMessage", descriptor.name());/// Reflective equality./// # See also/// [`dyn Message::reflect_eq_dyn()`], `dyn` version of this function./// Trait implemented for all the generated messages, except when lite runtime is enabled./// When lite runtime is enabled, only `MessageLite` is implemented./// * Generated messages are generated from `.proto` files/// * Dynamic messages can be created without code generation using only parsed proto files///   (see [FileDescriptor::new_dynamic](crate::reflect::FileDescriptor::new_dynamic))./// Also, generated messages implement `Default + PartialEq`/// This trait is sized, there's accompanying [`MessageDyn`](crate::MessageDyn) trait/// which is implemented for all messages which can be used in functions/// without making message a function type parameter./// ## `Display`/// [`Display`](fmt::Display) implementation for messages does protobuf text format./// See [`text_format`](crate::text_format) for more details./// `MaybeUninit::write_slice` is not stable./// `MaybeUninit::array_assume_init` is not stable.wrappersBoolValueBytesValueDoubleValueFloatValueInt32ValueInt64ValueUInt32ValueUInt64Value// bool <-> BoolValue// Vec<u8> <-> BytesValue// f64 <-> DoubleValue// f32 <-> FloatValue// i32 <-> Int32Value// i64 <-> Int64Value// u32 <-> UInt32Value// u64 <-> UInt64Value// () <-> Empty/// Trait implemented by all oneof types in generated code.OneofDescriptor/// Descriptor object for this oneof./// Implemented by all oneof types when lite runtime is not enabled.OwningRefnew_arcflat_map_slice//! Utility similar to provided by `owning_ref` crate.// @@protoc_insertion_point(field:google.protobuf.compiler.Version.major)// @@protoc_insertion_point(field:google.protobuf.compiler.Version.minor)// @@protoc_insertion_point(field:google.protobuf.compiler.Version.patch)///  A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should///  be empty for mainline stable releases.// @@protoc_insertion_point(field:google.protobuf.compiler.Version.suffix)// @@protoc_insertion_point(special_field:google.protobuf.compiler.Version.special_fields)///  The version number of protocol compiler.// @@protoc_insertion_point(message:google.protobuf.compiler.Version)clear_majorhas_majorset_majorclear_minorhas_minorset_minorclear_patchhas_patchset_patchclear_suffixhas_suffixset_suffixmut_suffixtake_suffix// optional int32 major = 1;// optional int32 minor = 2;// optional int32 patch = 3;// optional string suffix = 4;file_to_generate///  The .proto files that were explicitly listed on the command-line.  The///  code generator should generate code only for these files.  Each file's///  descriptor will be included in proto_file, below.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)///  The generator parameter passed on the command-line.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorRequest.parameter)proto_file///  FileDescriptorProtos for all files in files_to_generate and everything///  they import.  The files will appear in topological order, so each file///  appears before any file that imports it.///  protoc guarantees that all proto_files will be written after///  the fields above, even though this is not technically guaranteed by the///  protobuf wire format.  This theoretically could allow a plugin to stream///  in the FileDescriptorProtos and handle them one by one rather than read///  the entire set into memory at once.  However, as of this writing, this///  is not similarly optimized on protoc's end -- it will store all fields in///  memory at once before sending them to the plugin.///  Type names of fields and extensions in the FileDescriptorProto are always///  fully qualified.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorRequest.proto_file)compiler_version// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)// @@protoc_insertion_point(special_field:google.protobuf.compiler.CodeGeneratorRequest.special_fields)CodeGeneratorRequest///  An encoded CodeGeneratorRequest is written to the plugin's stdin.// @@protoc_insertion_point(message:google.protobuf.compiler.CodeGeneratorRequest)clear_parameterhas_parametermut_parametertake_parameter// optional string parameter = 2;///  Error message.  If non-empty, code generation failed.  The plugin process///  should exit with status code zero even if it reports an error in this way.///  This should be used to indicate errors in .proto files which prevent the///  code generator from generating correct code.  Errors which indicate a///  problem in protoc itself -- such as the input CodeGeneratorRequest being///  unparseable -- should be reported by writing a message to stderr and///  exiting with a non-zero status code.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.error)supported_features///  A bitmask of supported features that the code generator supports.///  This is a bitwise "or" of values from the Feature enum.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.supported_features)code_generator_response// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.file)// @@protoc_insertion_point(special_field:google.protobuf.compiler.CodeGeneratorResponse.special_fields)CodeGeneratorResponse///  The plugin writes an encoded CodeGeneratorResponse to stdout.// @@protoc_insertion_point(message:google.protobuf.compiler.CodeGeneratorResponse)mut_errorclear_supported_featureshas_supported_featuresset_supported_features// optional string error = 1;// optional uint64 supported_features = 2;///  The file name, relative to the output directory.  The name must not///  contain "." or ".." components and must be relative, not be absolute (so,///  the file cannot lie outside the output directory).  "/" must be used as///  the path separator, not "\".///  If the name is omitted, the content will be appended to the previous///  file.  This allows the generator to break large files into small chunks,///  and allows the generated text to be streamed back to protoc so that large///  files need not reside completely in memory at one time.  Note that as of///  this writing protoc does not optimize for this -- it will read the entire///  CodeGeneratorResponse before writing files to disk.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.File.name)insertion_point///  If non-empty, indicates that the named file should already exist, and the///  content here is to be inserted into that file at a defined insertion///  point.  This feature allows a code generator to extend the output///  produced by another code generator.  The original generator may provide///  insertion points by placing special annotations in the file that look///  like:///    @@protoc_insertion_point(NAME)///  The annotation can have arbitrary text before and after it on the line,///  which allows it to be placed in a comment.  NAME should be replaced with///  an identifier naming the point -- this is what other generators will use///  as the insertion_point.  Code inserted at this point will be placed///  immediately above the line containing the insertion point (thus multiple///  insertions to the same point will come out in the order they were added).///  The double-@ is intended to make it unlikely that the generated code///  could contain things that look like insertion points by accident.///  For example, the C++ code generator places the following line in the///  .pb.h files that it generates:///    // @@protoc_insertion_point(namespace_scope)///  This line appears within the scope of the file's package namespace, but///  outside of any particular class.  Another plugin can then specify the///  insertion_point "namespace_scope" to generate additional classes or///  other declarations that should be placed in this scope.///  Note that if the line containing the insertion point begins with///  whitespace, the same whitespace will be added to every line of the///  inserted text.  This is useful for languages like Python, where///  indentation matters.  In these languages, the insertion point comment///  should be indented the same amount as any inserted code will need to be///  in order to work correctly in that context.///  The code generator that generates the initial file and the one which///  inserts into it must both run as part of a single invocation of protoc.///  Code generators are executed in the order in which they appear on the///  command line.///  If |insertion_point| is present, |name| must also be present.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)///  The file contents.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.File.content)///  Information describing the file content being inserted. If an insertion///  point is used, this information will be appropriately offset and inserted///  into the code generation metadata for the generated files.// @@protoc_insertion_point(field:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)// @@protoc_insertion_point(special_field:google.protobuf.compiler.CodeGeneratorResponse.File.special_fields)///  Represents a single generated file.// @@protoc_insertion_point(message:google.protobuf.compiler.CodeGeneratorResponse.File)clear_insertion_pointhas_insertion_pointset_insertion_pointmut_insertion_pointtake_insertion_pointclear_contenthas_contentset_contentmut_contenttake_content// optional string insertion_point = 2;// optional string content = 15;FEATURE_NONE// @@protoc_insertion_point(enum_value:google.protobuf.compiler.CodeGeneratorResponse.Feature.FEATURE_NONE)FEATURE_PROTO3_OPTIONAL// @@protoc_insertion_point(enum_value:google.protobuf.compiler.CodeGeneratorResponse.Feature.FEATURE_PROTO3_OPTIONAL)///  Sync with code_generator.h.// @@protoc_insertion_point(enum:google.protobuf.compiler.CodeGeneratorResponse.Feature)/// Nested message and enums of message `CodeGeneratorResponse`//! Generated file from `google/protobuf/compiler/plugin.proto`AccessorV2ReflectFieldRefGeneratedFieldAccessor_nameFieldAccessor/// Accessor object is constructed in generated code./// Should not be used directly.get_reflectReflectMapMutReflectMapRefRuntimeTypeMapKeymut_reflect_element_typeMapFieldAccessorMapFieldAccessorHolderget_fieldmut_fieldMapFieldAccessorImplmake_map_simpler_accessor/// Make accessor for map field./// This is code generated by rust-protobuf before 3.5.make_map_simpler_accessor_new/// Make accessor for map field, new version// This is only used in generated code.// Rust compiler allows it, and we want to avoid exposing traits in public API.repeatedRepeatedFieldAccessorHoldersingularSingularFieldAccessorHolderRepeatedReflectRepeatedReflectRepeatedMutReflectRepeatedRefget_repeatedmut_repeatedRepeatedFieldAccessorRepeatedFieldGetMutRepeatedFieldGetMutImplRepeatedFieldAccessorImplmake_vec_simpler_accessor/// Make accessor for `Vec` fieldRuntimeTypeWithDerefReflectValueMutReflectOptionalRefReflectValueBoxReflectValueRefmut_field_or_defaultset_fieldclear_fieldSingularFieldAccessor/// This trait should not be used directly, use `FieldDescriptor` insteadnew_get_mutnew_get_option_mut_optionnew_get_mut_messagenew_get_option_set_enumnew_has_get_setnew_has_get_set_derefDerefTargetnew_has_get_mut_setmake_message_field_accessor/// Make accessor for `SingularPtrField`make_option_accessor/// Make accessor for `Option<C>` fieldmake_simpler_field_accessor/// Make accessor for simple fieldmake_oneof_message_has_get_mut_set_accessor/// Make accessor for `oneof` `message` fieldmake_oneof_copy_has_get_set_simpler_accessors/// Make accessor for `Copy` fieldmake_oneof_enum_accessors// TODO: remove thismake_oneof_deref_has_get_set_simpler_accessor/// Make accessor for `oneof` fieldReflectMapReflectMapIterReflectMapIterTraitMapskey_type/// Type of value./// Type of key is defined by the maps key.DynamicMap_value_typeDynamicMapIterImpl_key_typereflect_iterDynamicOptionalDynamicRepeatedprotobuf_type_boxProtobufTypeFieldDescriptorRuntimeFieldTypebytes_sizecompute_raw_varint32_sizecompute_raw_varint64_sizeint32_sizeint64_sizeread_map_templatesint32_sizesint64_sizestring_sizeuint32_sizeuint64_sizeunknown_fields_sizeunknown_or_groupread_unknown_or_skip_group_with_tag_unpackedvec_packed_bool_sizevec_packed_double_sizevec_packed_fixed32_sizevec_packed_fixed64_sizevec_packed_float_sizevec_packed_int32_sizevec_packed_int64_sizevec_packed_sfixed32_sizevec_packed_sfixed64_sizevec_packed_sint32_sizevec_packed_sint64_sizevec_packed_uint32_sizevec_packed_uint64_sizeDynamicFieldValuedefault_for_field/// Fields by index in the description./// This field is lazy-init: it is empty when created.DynamicMessageclear_oneof_group_fields_exceptmut_singular_field_or_defaultmut_mapfor_each_field_to_writeForEachSingularFieldToWriterepeated_packedmap_field_entrysingular_write_to/// Write singular field to output streamcompute_singular_size/// Compute singular field sizecompute_repeated_packed_sizerepeated_write_tocompute_map_entry_field_data_sizemut_or_defaultreflect_singlar_refdrain_iterReflectRepeatedDrainIterReflectRepeatedIter/// Container of repeated values for dynamic messages./// It is logically similar to `Vec<ReflectValueBox>`, but:/// * more efficient/// * asserts all the elements are of the same type, the type which is specified at constructionreflect_drain_iterreflect_extendelement_typedata_enum_valuesdata_booldata_u64data_i32data_i64data_f32data_f64name_in_fileenum_or_unknown_type_id/// Type id of `<E>`_enum_or_unknown_type_id/// Type id of `<ProtobufEnumOrUnknown<E>>`GeneratedEnumDescriptor//! Generated code support for enum descriptors.EnumIndicesFileDescriptorImpl/// Description for enum variant./// Used in reflection./// `.proto` object which declared this value./// Name of enum variant as specified in proto filefull_name/// Fully qualified enum value name: fully qualified enum name followed by value name./// `i32` value of the enum variant/// Get descriptor of enum holding this value./// Convert this value descriptor into proper enum object./// # use protobuf::well_known_types::struct_::NullValue;/// # use protobuf::EnumFull;/// # use protobuf::reflect::EnumValueDescriptor;/// # if !cfg!(miri) {/// let value: EnumValueDescriptor = NullValue::NULL_VALUE.descriptor();/// let null: Option<NullValue> = value.cast();/// assert_eq!(Some(NullValue::NULL_VALUE), null);/// Dynamic representation of enum type./// Can be used in reflective operations.EnumDescriptorImplRef/// Descriptor objects which defined this enum./// Enum name as given in `.proto` fileindex_entry/// Fully qualified protobuf name of enumname_to_package/// Name relative to the package where the message is declared.for_type/// Get `EnumDescriptor` object for given enum typeenclosing_message/// Get a message containing this message, or `None` if this message is declared at file level./// This enum values/// Find enum variant by namevalue_by_number/// Find enum variant by numbervalue_by_index/// Get enum variant by index (as declared in `.proto` file)./// Default enum value (first variant).value_by_number_or_default/// Find enum variant by number or return default (first) enum value/// Check if this enum descriptor corresponds given enum type/// # use protobuf::descriptor::field_descriptor_proto::Label;/// # use protobuf::reflect::EnumDescriptor;/// let descriptor: EnumDescriptor = Label::enum_descriptor();/// assert!(descriptor.is::<Label>())struct_NullValue// Too slow on Miri.MessageNotFoundInFilesDependencyNotFoundNonUniqueDependenciesNonUniqueFieldNameNonUniqueFileDescriptorCycleInFileDescriptorsMapEntryNameMustEndWithEntryMapEntryMustHaveNoMapEntryIncorrectFieldsCouldNotParseDefaultValueForFieldDynamicFieldDescriptorRefprotobuf_field_typeProtobufFieldTypebuildingFileDescriptorBuildingForwardProtobufTypeBoxProtobufTypeBoxCurrentFileEnumCurrentFileMessagefrom_proto_typeresolve_messageForwardProtobufFieldTypeFieldDefaultValueFieldKind/// Message index./// Message index or `None` for file.enum_default_valueparse_default_valueruntime_field_typemessage_refMessageDescriptorImplRefReflectEq/// Singular field, optional or required in proto3 and just plain field in proto3/// Repeated field/// Map field/// Reference to a value stored in a field, optional, repeated or map./// Field descriptor./// Can be used for runtime reflection.regular/// Get `.proto` description of field/// Field name as specified in `.proto` file./// Field number as specified in `.proto` file./// Fully qualified name of the field: fully qualified name of the declaring type/// followed by the field name./// Declaring type is a message (for regular field or extensions) or a package/// (for top-level extensions).containing_oneof_including_synthetic/// Oneof descriptor containing this field. Do not skip synthetic oneofs.containing_oneof/// Oneof containing this field./// Return `None` if this field is not part of oneof or if it is synthetic oneof._declaring_message/// Message which declares this field (for extension, **not** the message we extend).containing_message/// Message which contains this field./// For extension fields, this is the message being extended.index_with_message_lifetime/// JSON field name./// Can be different from `.proto` field name./// See [JSON mapping][json] for details./// [json]: https://developers.google.com/protocol-buffers/docs/proto3#jsonis_singular/// If this field is optional or required.is_required/// Is this field required.is_repeated_or_map/// If this field repeated or map?is_repeated/// Is this field repeated, but not map field?FieldDescriptorImplRef/// If this field a map field?/// Check if field is set in given message./// For repeated field or map field return `true` if/// collection is not empty./// If this field belongs to a different message type.SingularFieldAccessorRefRepeatedFieldAccessorRefMapFieldAccessorRefmap_proto_type/// Obtain type of map key and value./// Get message field or default instance if field is unset./// If this field belongs to a different message type or/// field type is not message.mut_message/// Get a mutable reference to a message field./// Initialize field with default message if unset./// field type is not singular message.singular_default_value/// Default value./// If field is not singular.get_singular_field_or_default/// Get singular field value./// Return field default value if field is unset./// If this field belongs to a different message type or fields is not singular.// Not public because it is not implemented for all typessingular_runtime_type/// Runtime representation of singular field./// If this field belongs to a different message type or field is not singular.set_singular_field/// Set singular field./// field is not singular or value is of different type./// Clear a field./// Dynamic representation of field type with wire type./// Dynamic representation of field type./// Get field of any type.get_singular/// Return `None` if field is unset./// Get repeated field./// If this field belongs to a different message type or field is not repeated./// Get a mutable reference to `repeated` field./// If this field belongs to a different message type or field is not `repeated`.get_map/// Get `map` field./// If this field belongs to a different message type or field is not `map`./// Get a mutable reference to `map` field.// accessors// repeated// map/// Singular field (required, optional for proto2 or singular for proto3)/// Reflective representation of field type plus wire type./// Drop wire type from the type./// Reflective representation of field type.MessageIndicesfind_message_or_enumMessageOrEnumprotobuf_name_starts_with_packageruntime_type_boxcurrent_file_descriptordeps_with_publicmessage_by_name_to_packageenums_by_name_to_packageall_descriptorsfind_enumall_files_strresolve_field_typeresolve_field_element_typemap_fieldFileDescriptorCommonDynamicFileDescriptorbuild_fdsfds_extend_with_publicGeneratedMessageDescriptorGeneratedOneofDescriptoroneofsGeneratedFileDescriptor/// Reflection for objects defined in `.proto` file (messages, enums, etc).new_generated/// This function is called from generated code.is_initialized_is_always_truecompute_is_initialized_is_always_trueconcat_pathsServiceIndexnested_messagesnested_enumsmessage_indexMessageFieldIndicesfirst_field_index/// Index of the first field in global field index.extension_count/// Extensions follow fields in global field index.field_index_by_name// Following fields map to the local field index.field_index_by_name_or_json_namefield_index_by_numberregular_field_rangeextension_field_rangeslice_fieldsindex_by_nameindex_by_numberindex_in_containing_messagesynthetic/// Synthetic oneof for proto3 optional field.OneofIndices/// Direct dependencies of this file./// All messages in this file.top_level_messagesfirst_extension_field_index/// All fields followed by file-level extensions./// Common `FileDescriptor` data for generated and dynamic file descriptors.is_map_entryindex_message_and_innersbuild_message_by_name_to_packagebuild_enum_by_name_to_packagebuild_message_indexindex_messageServiceDescriptor/// The object is refcounted: clone is shallow./// The equality performs pointer comparison: two clones of the same `FileDescriptor`/// objects are equal, but two `FileDescriptor` objects created from the same `FileDescriptorProto`/// objects are **not** equal.common_for_generated_descriptor/// Same as `common`, but returns `&'static`.message_indicesmessage_by_indexmessage_proto_by_indexenum_indices/// Protobuf package./// Syntax of current file./// Top-level messages./// Get top-level enums./// Get services defined in `.proto` file./// Extension fields.message_by_package_relative_name/// Find message by name relative to the package./// Only search in the current file, not in any dependencies.enum_by_package_relative_namemessage_by_full_name/// Find message by fully-qualified name.enum_by_full_name/// Find enum by name fully-qualified name.new_generated_2/// This function is called from generated code, it is not stable, and should not be called.new_dynamic/// Dynamic message created from [`FileDescriptorProto`] without generated files.new_dynamic_fds/// Create a set of file descriptors from individual file descriptors./// `.proto` data for this file.public_deps/// Subset of dependencies which are public_all_filesProto2/// `syntax = "proto2"`.Proto3/// `syntax = "proto3"`./// `.proto` file syntax.of_filefrom_two_optionsDynamicEmptyMapDynamicEmptyMapIterGeneratedMapIterImpl/// Implemented for `HashMap`, `BTreeMap` with appropriate keys and valuesReflectMapRefImplDynamicEmpty/// Dynamic reference to `map` field/// Dynamic mutable reference to `map` field/// Size of the map/// Is map empty?/// Find a value by given key./// Map key type/// Map value type/// Number of map entries/// Is this map empty?/// Find a value for given key/// Insert a value into the map./// If given key has an incompatible key type./// ClearReflectMapRefIter/// Iterator over mapGeneratedOneofDescriptorDatanew_instanceMessageFactory/// Sized to dynamic reflection operations.MessageFactoryImpl/// The only message factory implementation.protobuf_name_to_packagenew_2/// Construct a new message descriptor./// This operation is called from generated code and rarely/// need to be called directly./// This function is not a part of public API.NonMapMessageDescriptornon_mapnew_map_entry//! Generated messages reflection support.ThisFileOtherFilemessage_field_messagesmessage_field_typesis_initialized_is_always_true_ignoring_depsMessageRefImplEmptyDynamic/// Wrapper around either [`MessageFull`] reference or a container for an empty dynamic message./// Wrap a message./// Default (empty) instance of given message type./// Dynamic representation of message type./// Used for reflection./// Get underlying `DescriptorProto` object./// Get a message descriptor for given message type/// Messages declared in this messages./// Get enums declared in this message./// [`FileDescriptor`] containing this message./// `FileDescriptorProto` containg this message type/// This message descriptor is a map entry.assert_not_map_entry/// Message is considered always initialized./// New empty message./// If this message is a map entry message./// Shared immutable empty message./// Returns `None` for dynamic message.clone_message/// Clone a message/// Check if two messages equal./// Is any message has different type than this descriptor./// Similar to `eq`, but considers `NaN` values equal.reflect_eq_maybe_unrelated/// Fully qualified protobuf message nameall_oneofs/// Nested oneofs including synthetic./// Non-synthetic oneofs.oneof_by_name/// Get message oneof by name (**not implemented**)./// Message field descriptors.field_by_indexfield_by_name/// Find message field by protobuf field name/// Note: protobuf field name might be different for Rust field name.// TODO: return value, not pointer, pointer is not compatible with dynamic messagefield_by_name_or_json_name/// Find message field by field name or field JSON namefield_by_number/// Find message field by field nametype_dynamic// Runtime type types are public, but not visible in public API.MethodDescriptorvalue_box//! # Reflection implementation for protobuf data//! ## Generated vs dynamic//! rust-protobuf supports reflection for both://! * generated messages (generated rust code)//! * dynamic messages (created from arbitrary `FileDescriptorProto` without code generation)//! The API to work with these types of messages is the same.//! ## API//! The API roughly follows Google protobuf C++ and Java API.//! Some minor adjustements are made to make code more idiomatic to rust.test_protobuf_name_starts_with_packagenew_synthetic/// Oneof descriptor.OneofDescriptorImplRef/// `.proto` part associated with this descriptor/// Oneof name as specified in `.proto` file._get_impl/// Message which contains this oneof./// This oneof is not present in sources./// Fully qualified name of oneof (fully qualified name of enclosing message/// followed by oneof name)./// Fields in this oneof./// Singular field field and value type./// No value./// Has value.none_fromsome_fromnew_filter_non_zeronew_from_option/// Obtain the value, drop the type./// Runtime type./// Wire type./// Runtime type and protobuf type._into_runtimeread_repeated_intonan_equal/// When `true`, `NaN` values are considered equal to each other._non_exhausitve/// Parameter for [`ReflectEq`]./// Default equality, similar to `#[derive(PartialEq)]`./// Equality where float `NaN` values are considered equal to each other./// Useful in tests./// Perform the equality comparison./// Special version of eq./// With `mode` [`ReflectEqMode::default()`], should be equivalent/// to `#[derive(PartialEq)]`.new_vecvec_downcasttransmute_ref_if_eqVecMutVariant/// Set element at index./// * if index is out of bounds/// * if the element type does not match the collection element type/// Append element./// Get the collection element type./// Get array data for enum elements./// * if the element type is not an enum/// Get array data if the element type is bool./// Get array data if the element type is i32./// Get array data if the element type is u32./// Get array data if the element type is i64./// Get array data if the element type is u64./// Get array data if the element type is f32./// Get array data if the element type is f64.data_implReflectRepeatedRefImpl/// Dynamic reference to repeated field/// Dynamic mutable reference to repeated field/// Number of elements in repeated field/// Repeated field is empty/// Get item by index// TODO: replace with index/// Runtime type of element/// Get an item by index/// Note: return immutable reference./// Set a value at given index./// If index if out of range or value type does not match container element type/// Push an item to repeated field.ReflectRepeatedRefIter/// Iterator over repeated field.transmute_mut_if_eq//! This module contains functions references for reflection in generated code.parse_protobuf_floatstr_litStrLit/// `i32`/// `i64`/// `u32`/// `u64`/// `f32`/// `f64`/// `bool`/// [`String`](std::string::String)VecU8/// [`Vec<u8>`](std::vec::Vec)/// `enum`/// `message`/// Runtime representation of elementary protobuf type.default_value_refdefault_value_box/// Rust type from protobuf type./// Panics for message or enum types (because they can't be resolved without context).parse_proto_default_valueProtobufTypeBytesProtobufTypeEnumOrUnknownProtobufTypeMessageProtobufTypeStringProtobufTypeTokioBytesProtobufTypeTokioChars/// Actual value for this type./// "Box" version of type type./// Default value for this type.from_value_box/// Construct a value from given reflective value./// If reflective value is of incompatible type.into_value_box/// Convert a value into a refletive box value.into_static_value_ref/// Convert a value into a ref value if possible./// For message and enum.// TODO: move the operation into a separate trait/// Pointer to a dynamic reference./// Mutable pointer to a dynamic mutable reference.is_non_zero/// Value is non-default?set_from_value_box/// Write the value.cast_to_enum_values/// Cast values to enum values./// If self is not an enum.get_from_unknown/// Parse the value from unknown fields./// `RuntimeType` is not implemented by all protobuf types directly/// because it's not possible to implement `RuntimeType` for all `Message`/// implementations at once: each `Message` implementation has to reimplement/// all the methods again. With current strategy there's only implementation/// for all messages, which is `RuntimeTypeMessage`./// The downside is that we have to explicitly specify type parameters/// in a lot of places./// Deref target.deref_as_ref/// Deref.// TODO: rename to `deref`/// Runtime type which can be dereferenced.hash_map_get/// Query hash map with a given key.btree_map_get/// Query btree map with a given key./// Types which can be map keys.RuntimeTypeF32/// Implementation for `f32`RuntimeTypeF64/// Implementation for `f64`RuntimeTypeI32/// Implementation for `i32`RuntimeTypeI64RuntimeTypeU32/// Implementation for `u32`RuntimeTypeU64/// Implementation for `u64`RuntimeTypeBool/// Implementation for `bool`RuntimeTypeString/// Implementation for `String`RuntimeTypeVecU8/// Implementation for `Vec<u8>`RuntimeTypeTokioBytes/// Implementation for [`Bytes`].RuntimeTypeTokioChars/// Implementation for [`Chars`]./// Implementation for enum./// Implementation for [`MessageFull`].//! Implementations of `RuntimeType` for all types.MethodIndex/// Dynamic representation of service type./// Rust-protobuf does not support services (it is not an RPC library),/// but it support querying service description. Which might be useful/// for example to generate source files for the services./// or to perform invocations dynamically./// Proto snippet describing this service./// Method descriptors of this service.service_descriptor/// Service method descriptor./// Proto snippet describing this method./// Method input type./// Method output type.wire_type/// Wire type for this type.runtime_type/// Get runtime type for this protobuf type._ProtobufTypeDynamic/// Dynamic version of [`ProtobufType`](crate::reflect::types::ProtobufType)./// This is used internally._ProtobufTypeDynamicImpl//! Reflection internals.value_varint_zigzag_size_no_tag/// Rust type for this protobuf type._dynamic/// Dynamic version of thisWIRE_TYPE/// Wire type for encoding objects of this type/// Read a value from `CodedInputStream`/// Take a value from `UnknownValues`_compute_size/// Compute serialized size of a value_compute_size_with_length_delimiter/// Compute size adding length prefix if wire type is length delimited/// (i. e. string, bytes, message)_get_cached_size/// Get previously computed size_get_cached_size_with_length_delimiter/// Get previously cached size with length prefix_write_with_cached_size/// Write a value with previously cached size/// Encapsulate type-specific serialization and conversion logicENCODED_SIZE/// Encoded size of value in bytes of this type./// E. g. it is `4` for `fixed32`/// All fixed size types/// `float`/// `double`/// `int32`/// `int64`/// `uint32`/// `uint64`/// `sint32`/// `sint64`/// `fixed32`/// `fixed64`/// `sfixed32`/// `sfixed64`/// `string`/// `bytes`/// `bytes` as [`Bytes`](bytes::Bytes)/// `string` as [`Chars`](crate::Chars)/// `enum` as `ProtobufEnumOrUnknown`//! Implementations of `ProtobufType` for all types./// Actual implementation of type properties./// Type implemented by all protobuf singular types/// (primitives, string, messages, enums).// conflicting implementations, so generated code is used instead/*
impl<E : ProtobufEnum> ProtobufValue for E {
}

impl<M : Message> ProtobufValue for M {
}
*//// Owner value of any elementary type_assert_value_box_send_sync/// Type of this value.as_value_ref/// As refas_value_mut/// Downcast to real typed value./// For `enum` `V` can be either `V: ProtobufEnum` or `V: ProtobufEnumOrUnknown<E>`.reflect_value_box_downcast_primitivereflect_value_box_downcast_string/// Enum value./// Note when `allow_alias` option is enabled, more than one enum variant/// may have the same value./// A reference to a value/// Get type of this value./// Value is "non-zero"?/// Take `i32` value./// Take `i64` value./// Take `u32` value./// Take `u64` value./// Take `f32` value./// Take `f64` value./// Take `bool` value./// Take `str` value./// Take `[u8]` value.to_enum_value/// Take enum value./// Take message value.to_box/// Clone to a boxdowncast_clone/// Convert a value to arbitrary value.// Panics if contained type is not hashableread_map_template_newread_singular_message_into_field/// Read singular `message` field.write_message_field_with_cached_size/// Write message with field number and length to the stream.vec_packed_enum_or_unknown_sizeread_repeated_packed_enum_or_unknown_intoread_unknown_or_skip_groupskip_field_for_tag/// Given `u64` value compute varint encoded length./// Given `u32` value compute varint encoded length./// Compute tag size. Size of tag does not depend on wire type.//! # Functions and types used by generated protobuf code//! These are not considered to be public API of rust-protobuf,//! so they can be changed any time (provided compatibility with//! previously generated code is preserved).ProtobufVarintProtobufVarintZigzag/// Size of serialized repeated packed field, excluding length and tag./// Size of serialized repeated packed enum field, excluding length and tag.vec_packed_varint_size/// Size of serialized data with length prefix and tag/// Size of serialized data with length prefix and tag.vec_packed_varint_zigzag_size/// Compute data size of fixed encoding of repeated field data.vec_packed_fixed_size/// Compute field size (data plus header) of fixed encoding of repeated field./// Read repeated enum field when the wire format is length-delimited./// Integer value size when encoded./// Encoded `int32` size./// Encoded `int64` size./// Encoded `uint32` size./// Encoded `uint64` size./// Integer value size when encoded as specified wire type.value_varint_zigzag_size/// Length of value when encoding with zigzag encoding with tag/// Size of serialized `sint32` field./// Size of serialized `sint64` field.bytes_size_no_tag/// Size of encoded bytes field.string_size_no_tag/// Size of encoded string field./// Size of encoded unknown fields size./// Handle unknown field in generated code./// Either store a value in unknown, or skip a group./// Return error if tag is incorrect.generate_accessors_allgenerate_getter_alltokio_bytes_alltokio_bytes_for_string_alloneofs_non_exhaustive_allbtreemap_alllite_runtime_allgenerate_accessorsgenerate_gettertokio_bytestokio_bytes_for_stringoneofs_non_exhaustivebtreemapgenerate_accessors_fieldgenerate_getter_fieldtokio_bytes_fieldtokio_bytes_for_string_fieldoneofs_non_exhaustive_fieldbtreemap_fieldexts/// Extension fields//! Generated file from `rustproto.proto`/// Special fields included in each generated message./// Defaults./// Clear./// Getter./// Setter.merge_from_strprint_to_stringprint_to_string_pretty//! # Protobuf "text format" implementation.//! Text format message look like this://! ```text,ignore//! size: 17//! color: "red"//! children {//!     size: 18//!     color: "blue"//!     size: 19//!     color: "green"//! This format is not specified, but it is implemented by all official//! protobuf implementations, including `protoc` command which can decode//! and encode messages using text format.//! # JSON//! rust-protobuf also supports JSON printing and parsing.//! It is implemented in//! [`protobuf-json-mapping` crate](https://docs.rs/protobuf-json-mapping/%3E=3.0.0-alpha).Locparser_languageParserLanguageStrLitDecodeErrortokenizerTokenizerErrorParseErrorWithoutLocUnknownFieldUnknownEnumValueMapFieldIsSpecifiedMoreThanOnceIntegerOverflowExpectingBool/// Text format parse error.ParseWithLocResultnext_field_nameread_colonread_map_entryread_value_of_typemerge_fieldmerge_inner// Text format/// Parse text format message./// This function does not check if message required fields are set.quote_bytes_toprint_str_todo_indentFieldNameprint_start_fieldprint_end_fieldprint_fieldprint_to_internal/// Text-formatprint_to_string_internal/// Text-format to `fmt::Formatter`./// Unix epoch value of timestamp./// Return current time as `Timestamp`./// Convert from [`Timestamp`]./// This function panics if given `SystemTime` is outside of `Timestamp` range./// Convert into [`SystemTime`]./// The conversion could be lossy if `SystemTime` precision is smaller than nanoseconds./// This function panics:/// * if given `Timestamp` is outside of `SystemTime` range/// * if `Timestamp` is malformedFixed32/// 32-bit unknown (e. g. `fixed32` or `float`)Fixed64/// 64-bit unknown (e. g. `fixed64` or `double`)Varint/// Varint unknown (e. g. `int32` or `bool`)LengthDelimited/// Length-delimited unknown (e. g. `message` or `string`)/// Unknown value./// See [`UnknownFields`](crate::UnknownFields) for the explanations./// Wire type for this unknownint32/// Construct unknown value from `int64` value.sint32/// Construct unknown value from `sint32` value.sint64/// Construct unknown value from `sint64` value./// Construct unknown value from `float` value./// Construct unknown value from `double` value.sfixed32/// Construct unknown value from `sfixed32` value.sfixed64/// Construct unknown value from `sfixed64` value./// 32-bit unknown/// 64-bit unknown/// Varint unknown/// Length-delimited unknown/// Reference to unknown value./// See [`UnknownFields`](crate::UnknownFields) for explanations./// Wire-type to serialize this unknownto_reflect_value_reffixed32/// 32-bit unknownsfixed64/// 64-bit unknowns/// Varint unknownslength_delimited/// Length-delimited unknownsUnknownValues/// Field unknown values./// Add unknown valueUnknownValuesIter/// Iterate over unknown values/// Iterator over unknown values/// The map.// `Option` is needed, because HashMap constructor performs allocation,// and very expensive.// We use "default hasher" to make iteration order deterministic.// Which is used to make codegen output deterministic in presence of unknown fields// (e. g. file options are represented as unknown fields).// Using default hasher is suboptimal, because it makes unknown fields less safe.// Note, Google Protobuf C++ simply uses linear map (which can exploitable the same way),// and Google Protobuf Java uses tree map to store unknown fields// (which is more expensive than hashmap)./// Hold "unknown" fields in parsed message./// Field may be unknown if it they are added in newer version of `.proto`./// Unknown fields are stored in `UnknownFields` structure, so/// protobuf message could process messages without losing data./// For example, in this operation: load from DB, modify, store to DB,/// even when working with older `.proto` file, new fields won't be lost./// Very simple hash implementation of `Hash` for `UnknownFields`./// Since map is unordered, we cannot put entry hashes into hasher,/// instead we summing hashes of entries./// Empty unknown fields./// Clear all unknown fields.init_mapfind_fieldadd_fixed32/// Add unknown fixed 32-bitadd_fixed64/// Add unknown fixed 64-bitadd_varint/// Add unknown varintadd_length_delimited/// Add unknown length delimited/// Remove unknown field by number/// Iterate over all unknowns/// Get any value for unknown fields.UnknownFieldsNotEmptyIter/// Iterator over [`UnknownFields`](crate::UnknownFields)unknown_fields_hashunknown_fields_iteration_order_deterministicMAX_VARINT32_ENCODED_LENMAX_ENCODED_LENLAST_BYTE_MAX_VALUEDecodeVarintdecode_varint_full/// Decode a varint, and return decoded value and decoded byte count.decode_varint_impl/// Try decode a varint. Return `None` if the buffer does not contain complete varint.test_decode_varint64test_decode_varint32//! Varint decode utilities./// Encode u64 as varint./// Panics if buffer length is less than 10./// Encode u32 value as varint./// Panics if buffer length is less than 5./// Encoded size of u64 value.test_encoded_varint64_lenlen_varint/// Size of self when encoded as varint./// Helper trait implemented by integer types which could be encoded as varint./// Encoded varint message is not longer than 10 bytes.type_url///  A URL/resource name that uniquely identifies the type of the serialized///  protocol buffer message. This string must contain at least///  one "/" character. The last segment of the URL's path must represent///  the fully qualified name of the type (as in///  `path/google.protobuf.Duration`). The name should be in a canonical form///  (e.g., leading "." is not accepted).///  In practice, teams usually precompile into the binary all types that they///  expect it to use in the context of Any. However, for URLs which use the///  scheme `http`, `https`, or no scheme, one can optionally set up a type///  server that maps type URLs to message definitions as follows:///  * If no scheme is provided, `https` is assumed.///  * An HTTP GET on the URL must yield a [google.protobuf.Type][]///    value in binary format, or produce an error.///  * Applications are allowed to cache lookup results based on the///    URL, or have them precompiled into a binary to avoid any///    lookup. Therefore, binary compatibility needs to be preserved///    on changes to types. (Use versioned type names to manage///    breaking changes.)///  Note: this functionality is not currently available in the official///  protobuf release, and it is not used for type URLs beginning with///  type.googleapis.com.///  Schemes other than `http`, `https` (or the empty scheme) might be///  used with implementation specific semantics.// @@protoc_insertion_point(field:google.protobuf.Any.type_url)///  Must be a valid serialized protocol buffer of the above specified type.// @@protoc_insertion_point(field:google.protobuf.Any.value)// @@protoc_insertion_point(special_field:google.protobuf.Any.special_fields)// @@protoc_insertion_point(message:google.protobuf.Any)//! Generated file from `google/protobuf/any.proto`///  The fully qualified name of this interface, including package name///  followed by the interface's simple name.// @@protoc_insertion_point(field:google.protobuf.Api.name)///  The methods of this interface, in unspecified order.// @@protoc_insertion_point(field:google.protobuf.Api.methods)///  Any metadata attached to the interface.// @@protoc_insertion_point(field:google.protobuf.Api.options)///  A version string for this interface. If specified, must have the form///  `major-version.minor-version`, as in `1.10`. If the minor version is///  omitted, it defaults to zero. If the entire version field is empty, the///  major version is derived from the package name, as outlined below. If the///  field is not empty, the version in the package name will be verified to be///  consistent with what is provided here.///  The versioning schema uses [semantic///  versioning](http://semver.org) where the major version number///  indicates a breaking change and the minor version an additive,///  non-breaking change. Both version numbers are signals to users///  what to expect from different versions, and should be carefully///  chosen based on the product plan.///  The major version is also reflected in the package name of the///  interface, which must end in `v<major-version>`, as in///  `google.feature.v1`. For major versions 0 and 1, the suffix can///  be omitted. Zero major versions must only be used for///  experimental, non-GA interfaces.// @@protoc_insertion_point(field:google.protobuf.Api.version)source_contextSourceContext///  Source context for the protocol buffer service represented by this///  message.// @@protoc_insertion_point(field:google.protobuf.Api.source_context)mixinsMixin///  Included interfaces. See [Mixin][].// @@protoc_insertion_point(field:google.protobuf.Api.mixins)///  The source syntax of the service.// @@protoc_insertion_point(field:google.protobuf.Api.syntax)// @@protoc_insertion_point(special_field:google.protobuf.Api.special_fields)///  Api is a light-weight descriptor for an API Interface.///  Interfaces are also described as "protocol buffer services" in some contexts,///  such as by the "service" keyword in a .proto file, but they are different///  from API Services, which represent a concrete implementation of an interface///  as opposed to simply a description of methods and bindings. They are also///  sometimes simply referred to as "APIs" in other contexts, such as the name of///  this message itself. See https://cloud.google.com/apis/design/glossary for///  detailed terminology.// @@protoc_insertion_point(message:google.protobuf.Api)///  The simple name of this method.// @@protoc_insertion_point(field:google.protobuf.Method.name)request_type_url///  A URL of the input message type.// @@protoc_insertion_point(field:google.protobuf.Method.request_type_url)request_streaming///  If true, the request is streamed.// @@protoc_insertion_point(field:google.protobuf.Method.request_streaming)response_type_url///  The URL of the output message type.// @@protoc_insertion_point(field:google.protobuf.Method.response_type_url)response_streaming///  If true, the response is streamed.// @@protoc_insertion_point(field:google.protobuf.Method.response_streaming)///  Any metadata attached to the method.// @@protoc_insertion_point(field:google.protobuf.Method.options)///  The source syntax of this method.// @@protoc_insertion_point(field:google.protobuf.Method.syntax)// @@protoc_insertion_point(special_field:google.protobuf.Method.special_fields)///  Method represents a method of an API interface.// @@protoc_insertion_point(message:google.protobuf.Method)///  The fully qualified name of the interface which is included.// @@protoc_insertion_point(field:google.protobuf.Mixin.name)///  If non-empty specifies a path under which inherited HTTP paths///  are rooted.// @@protoc_insertion_point(field:google.protobuf.Mixin.root)// @@protoc_insertion_point(special_field:google.protobuf.Mixin.special_fields)// @@protoc_insertion_point(message:google.protobuf.Mixin)//! Generated file from `google/protobuf/api.proto`///  Signed seconds of the span of time. Must be from -315,576,000,000///  to +315,576,000,000 inclusive. Note: these bounds are computed from:///  60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years// @@protoc_insertion_point(field:google.protobuf.Duration.seconds)///  Signed fractions of a second at nanosecond resolution of the span///  of time. Durations less than one second are represented with a 0///  `seconds` field and a positive or negative `nanos` field. For durations///  of one second or more, a non-zero value for the `nanos` field must be///  of the same sign as the `seconds` field. Must be from -999,999,999///  to +999,999,999 inclusive.// @@protoc_insertion_point(field:google.protobuf.Duration.nanos)// @@protoc_insertion_point(special_field:google.protobuf.Duration.special_fields)// @@protoc_insertion_point(message:google.protobuf.Duration)//! Generated file from `google/protobuf/duration.proto`// @@protoc_insertion_point(special_field:google.protobuf.Empty.special_fields)// @@protoc_insertion_point(message:google.protobuf.Empty)//! Generated file from `google/protobuf/empty.proto`///  The set of field mask paths.// @@protoc_insertion_point(field:google.protobuf.FieldMask.paths)// @@protoc_insertion_point(special_field:google.protobuf.FieldMask.special_fields)FieldMask// @@protoc_insertion_point(message:google.protobuf.FieldMask)//! Generated file from `google/protobuf/field_mask.proto`field_mask// This file is generated. Do not edit//! Generated code for "well known types"//! [This document](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) describes these types.///  The path-qualified name of the .proto file that contained the associated///  protobuf element.  For example: `"google/protobuf/source_context.proto"`.// @@protoc_insertion_point(field:google.protobuf.SourceContext.file_name)// @@protoc_insertion_point(special_field:google.protobuf.SourceContext.special_fields)///  `SourceContext` represents information about the source of a///  protobuf element, like the file in which it is defined.// @@protoc_insertion_point(message:google.protobuf.SourceContext)//! Generated file from `google/protobuf/source_context.proto`///  Unordered map of dynamically typed values.// @@protoc_insertion_point(field:google.protobuf.Struct.fields)// @@protoc_insertion_point(special_field:google.protobuf.Struct.special_fields)///  `Struct` represents a structured data value, consisting of fields///  which map to dynamically typed values. In some languages, `Struct`///  might be supported by a native representation. For example, in///  scripting languages like JS a struct is represented as an///  object. The details of that representation are described together///  with the proto support for the language.///  The JSON representation for `Struct` is JSON object.// @@protoc_insertion_point(message:google.protobuf.Struct)// message oneof groups// @@protoc_insertion_point(special_field:google.protobuf.Value.special_fields)///  `Value` represents a dynamically typed value which can be either///  null, a number, a string, a boolean, a recursive struct value, or a///  list of values. A producer of value is expected to set one of these///  variants. Absence of any variant indicates an error.///  The JSON representation for `Value` is JSON value.// @@protoc_insertion_point(message:google.protobuf.Value)null_valueclear_null_valuehas_null_valueset_null_valuenumber_valueclear_number_valuehas_number_valueset_number_valuebool_valueclear_bool_valuehas_bool_valueset_bool_valuestruct_valueclear_struct_valuehas_struct_valueset_struct_valuemut_struct_valuetake_struct_valuelist_valueListValueclear_list_valuehas_list_valueset_list_valuemut_list_valuetake_list_value// .google.protobuf.NullValue null_value = 1;// double number_value = 2;// string string_value = 3;// bool bool_value = 4;// .google.protobuf.Struct struct_value = 5;// .google.protobuf.ListValue list_value = 6;// @@protoc_insertion_point(oneof_field:google.protobuf.Value.null_value)NumberValue// @@protoc_insertion_point(oneof_field:google.protobuf.Value.number_value)StringValue// @@protoc_insertion_point(oneof_field:google.protobuf.Value.string_value)// @@protoc_insertion_point(oneof_field:google.protobuf.Value.bool_value)StructValue// @@protoc_insertion_point(oneof_field:google.protobuf.Value.struct_value)// @@protoc_insertion_point(oneof_field:google.protobuf.Value.list_value)// @@protoc_insertion_point(oneof:google.protobuf.Value.kind)generated_oneof_descriptor_data/// Nested message and enums of message `Value`///  Repeated field of dynamically typed values.// @@protoc_insertion_point(field:google.protobuf.ListValue.values)// @@protoc_insertion_point(special_field:google.protobuf.ListValue.special_fields)///  `ListValue` is a wrapper around a repeated field of values.///  The JSON representation for `ListValue` is JSON array.// @@protoc_insertion_point(message:google.protobuf.ListValue)NULL_VALUE// @@protoc_insertion_point(enum_value:google.protobuf.NullValue.NULL_VALUE)///  `NullValue` is a singleton enumeration to represent the null value for the///  `Value` type union.///   The JSON representation for `NullValue` is JSON `null`.// @@protoc_insertion_point(enum:google.protobuf.NullValue)//! Generated file from `google/protobuf/struct.proto`///  Represents seconds of UTC time since Unix epoch///  1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to///  9999-12-31T23:59:59Z inclusive.// @@protoc_insertion_point(field:google.protobuf.Timestamp.seconds)///  Non-negative fractions of a second at nanosecond resolution. Negative///  second values with fractions must still have non-negative nanos values///  that count forward in time. Must be from 0 to 999,999,999///  inclusive.// @@protoc_insertion_point(field:google.protobuf.Timestamp.nanos)// @@protoc_insertion_point(special_field:google.protobuf.Timestamp.special_fields)// @@protoc_insertion_point(message:google.protobuf.Timestamp)//! Generated file from `google/protobuf/timestamp.proto`///  The fully qualified message name.// @@protoc_insertion_point(field:google.protobuf.Type.name)///  The list of fields.// @@protoc_insertion_point(field:google.protobuf.Type.fields)///  The list of types appearing in `oneof` definitions in this type.// @@protoc_insertion_point(field:google.protobuf.Type.oneofs)///  The protocol buffer options.// @@protoc_insertion_point(field:google.protobuf.Type.options)///  The source context.// @@protoc_insertion_point(field:google.protobuf.Type.source_context)///  The source syntax.// @@protoc_insertion_point(field:google.protobuf.Type.syntax)// @@protoc_insertion_point(special_field:google.protobuf.Type.special_fields)///  A protocol buffer message type.// @@protoc_insertion_point(message:google.protobuf.Type)///  The field type.// @@protoc_insertion_point(field:google.protobuf.Field.kind)cardinalityCardinality///  The field cardinality.// @@protoc_insertion_point(field:google.protobuf.Field.cardinality)///  The field number.// @@protoc_insertion_point(field:google.protobuf.Field.number)///  The field name.// @@protoc_insertion_point(field:google.protobuf.Field.name)///  The field type URL, without the scheme, for message or enumeration///  types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.// @@protoc_insertion_point(field:google.protobuf.Field.type_url)///  The index of the field type in `Type.oneofs`, for message or enumeration///  types. The first type has index 1; zero means the type is not in the list.// @@protoc_insertion_point(field:google.protobuf.Field.oneof_index)///  Whether to use alternative packed wire representation.// @@protoc_insertion_point(field:google.protobuf.Field.packed)// @@protoc_insertion_point(field:google.protobuf.Field.options)///  The field JSON name.// @@protoc_insertion_point(field:google.protobuf.Field.json_name)///  The string value of the default value of this field. Proto2 syntax only.// @@protoc_insertion_point(field:google.protobuf.Field.default_value)// @@protoc_insertion_point(special_field:google.protobuf.Field.special_fields)///  A single field of a message type.// @@protoc_insertion_point(message:google.protobuf.Field)TYPE_UNKNOWN// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_UNKNOWN)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_DOUBLE)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_FLOAT)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_INT64)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_UINT64)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_INT32)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_FIXED64)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_FIXED32)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_BOOL)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_STRING)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_GROUP)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_MESSAGE)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_BYTES)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_UINT32)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_ENUM)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_SFIXED32)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_SFIXED64)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_SINT32)// @@protoc_insertion_point(enum_value:google.protobuf.Field.Kind.TYPE_SINT64)///  Basic field types.// @@protoc_insertion_point(enum:google.protobuf.Field.Kind)CARDINALITY_UNKNOWN// @@protoc_insertion_point(enum_value:google.protobuf.Field.Cardinality.CARDINALITY_UNKNOWN)CARDINALITY_OPTIONAL// @@protoc_insertion_point(enum_value:google.protobuf.Field.Cardinality.CARDINALITY_OPTIONAL)CARDINALITY_REQUIRED// @@protoc_insertion_point(enum_value:google.protobuf.Field.Cardinality.CARDINALITY_REQUIRED)CARDINALITY_REPEATED// @@protoc_insertion_point(enum_value:google.protobuf.Field.Cardinality.CARDINALITY_REPEATED)///  Whether a field is optional, required, or repeated.// @@protoc_insertion_point(enum:google.protobuf.Field.Cardinality)/// Nested message and enums of message `Field`///  Enum type name.// @@protoc_insertion_point(field:google.protobuf.Enum.name)enumvalue///  Enum value definitions.// @@protoc_insertion_point(field:google.protobuf.Enum.enumvalue)///  Protocol buffer options.// @@protoc_insertion_point(field:google.protobuf.Enum.options)// @@protoc_insertion_point(field:google.protobuf.Enum.source_context)// @@protoc_insertion_point(field:google.protobuf.Enum.syntax)// @@protoc_insertion_point(special_field:google.protobuf.Enum.special_fields)///  Enum type definition.// @@protoc_insertion_point(message:google.protobuf.Enum)///  Enum value name.// @@protoc_insertion_point(field:google.protobuf.EnumValue.name)///  Enum value number.// @@protoc_insertion_point(field:google.protobuf.EnumValue.number)// @@protoc_insertion_point(field:google.protobuf.EnumValue.options)// @@protoc_insertion_point(special_field:google.protobuf.EnumValue.special_fields)///  Enum value definition.// @@protoc_insertion_point(message:google.protobuf.EnumValue)///  The option's name. For protobuf built-in options (options defined in///  descriptor.proto), this is the short name. For example, `"map_entry"`.///  For custom options, it should be the fully-qualified name. For example,///  `"google.api.http"`.// @@protoc_insertion_point(field:google.protobuf.Option.name)///  The option's value packed in an Any message. If the value is a primitive,///  the corresponding wrapper type defined in google/protobuf/wrappers.proto///  should be used. If the value is an enum, it should be stored as an int32///  value using the google.protobuf.Int32Value type.// @@protoc_insertion_point(field:google.protobuf.Option.value)// @@protoc_insertion_point(special_field:google.protobuf.Option.special_fields)///  A protocol buffer option, which can be attached to a message, field,///  enumeration, etc.// @@protoc_insertion_point(message:google.protobuf.Option)SYNTAX_PROTO2// @@protoc_insertion_point(enum_value:google.protobuf.Syntax.SYNTAX_PROTO2)SYNTAX_PROTO3// @@protoc_insertion_point(enum_value:google.protobuf.Syntax.SYNTAX_PROTO3)///  The syntax in which a protocol buffer element is defined.// @@protoc_insertion_point(enum:google.protobuf.Syntax)//! Generated file from `google/protobuf/type.proto`///  The double value.// @@protoc_insertion_point(field:google.protobuf.DoubleValue.value)// @@protoc_insertion_point(special_field:google.protobuf.DoubleValue.special_fields)///  Wrapper message for `double`.///  The JSON representation for `DoubleValue` is JSON number.// @@protoc_insertion_point(message:google.protobuf.DoubleValue)///  The float value.// @@protoc_insertion_point(field:google.protobuf.FloatValue.value)// @@protoc_insertion_point(special_field:google.protobuf.FloatValue.special_fields)///  Wrapper message for `float`.///  The JSON representation for `FloatValue` is JSON number.// @@protoc_insertion_point(message:google.protobuf.FloatValue)///  The int64 value.// @@protoc_insertion_point(field:google.protobuf.Int64Value.value)// @@protoc_insertion_point(special_field:google.protobuf.Int64Value.special_fields)///  Wrapper message for `int64`.///  The JSON representation for `Int64Value` is JSON string.// @@protoc_insertion_point(message:google.protobuf.Int64Value)///  The uint64 value.// @@protoc_insertion_point(field:google.protobuf.UInt64Value.value)// @@protoc_insertion_point(special_field:google.protobuf.UInt64Value.special_fields)///  Wrapper message for `uint64`.///  The JSON representation for `UInt64Value` is JSON string.// @@protoc_insertion_point(message:google.protobuf.UInt64Value)///  The int32 value.// @@protoc_insertion_point(field:google.protobuf.Int32Value.value)// @@protoc_insertion_point(special_field:google.protobuf.Int32Value.special_fields)///  Wrapper message for `int32`.///  The JSON representation for `Int32Value` is JSON number.// @@protoc_insertion_point(message:google.protobuf.Int32Value)///  The uint32 value.// @@protoc_insertion_point(field:google.protobuf.UInt32Value.value)// @@protoc_insertion_point(special_field:google.protobuf.UInt32Value.special_fields)///  Wrapper message for `uint32`.///  The JSON representation for `UInt32Value` is JSON number.// @@protoc_insertion_point(message:google.protobuf.UInt32Value)///  The bool value.// @@protoc_insertion_point(field:google.protobuf.BoolValue.value)// @@protoc_insertion_point(special_field:google.protobuf.BoolValue.special_fields)///  Wrapper message for `bool`.///  The JSON representation for `BoolValue` is JSON `true` and `false`.// @@protoc_insertion_point(message:google.protobuf.BoolValue)///  The string value.// @@protoc_insertion_point(field:google.protobuf.StringValue.value)// @@protoc_insertion_point(special_field:google.protobuf.StringValue.special_fields)///  Wrapper message for `string`.///  The JSON representation for `StringValue` is JSON string.// @@protoc_insertion_point(message:google.protobuf.StringValue)///  The bytes value.// @@protoc_insertion_point(field:google.protobuf.BytesValue.value)// @@protoc_insertion_point(special_field:google.protobuf.BytesValue.special_fields)///  Wrapper message for `bytes`.///  The JSON representation for `BytesValue` is JSON string.// @@protoc_insertion_point(message:google.protobuf.BytesValue)//! Generated file from `google/protobuf/wrappers.proto`type_name_from_type_url/// Pack any message into `well_known_types::Any` value./// use protobuf::well_known_types::any::Any;/// # fn the_test<MyMessage: MessageFull>(message: &MyMessage) -> protobuf::Result<()> {/// let message: &MyMessage = message;/// let any = Any::pack(message)?;/// assert!(any.is::<MyMessage>());/// #   Ok(())pack_dyn/// use protobuf::{MessageFull, MessageDyn};/// # fn the_test(message: &dyn MessageDyn) -> protobuf::Result<()> {/// let message: &dyn MessageDyn = message;/// let any = Any::pack_dyn(message)?;/// assert!(any.is_dyn(&message.descriptor_dyn()));pack_with_type_url_prefix/// Check if `Any` contains a message of given type.is_dyn/// Extract a message from this `Any`./// * `Ok(None)` when message type mismatch/// * `Err` when parse failedunpack_dyn/// Zero seconds zero nanoseconds./// Convert from `std::time::Duration`./// If `std::time::Duration` value is outside of `Duration` supported range./// Convert to `std::time::Duration`./// This conversion might be lossy if `std::time::Duration` precision is smaller than nanoseconds./// If `Duration` value is outside of `std::time::Duration` supported range.to_from_durationto_from_system_timeTAG_TYPE_BITS/// Tag occupies three bits.TAG_TYPE_MASK/// Apply this mask to varint value to obtain a tag.FIELD_NUMBER_MAX/// Max possible field number/// Variable-length integer/// 64-bit field (e. g. `fixed64` or `double`)/// Length-delimited fieldStartGroup/// Groups are not supported in rust-protobufEndGroup/// 32-bit field (e. g. `fixed32` or `float`)/// All supported "wire types" are listed in this enum./// Construct `WireType` from number, or return `None` if type is unknown./// Parsed field tag (a pair of field number and wire type)/// Fold tag to a number to be serialized./// Extract wire type and field number from integer tag/// Construct a tag from a field number and wire type./// If field number is outside of valid range./// Get field number and wire type/// Get wire type/// Get field number//! Constants used in serializations.len_varint_zigzag/// Size of self when encoded as zigzag varint./// Helper trait implemented by integer types which could be encoded as zigzag varint.test_zig_zag// ZigZag endoging used for efficient transfer of signed integers// https://developers.google.com/protocol-buffers/docs/encoding#typescustomizeCustomizeCallbackCustomizeCallbackHoldergen_and_writeCustomizeWhichParserPureProtocOutDirNotSpecifiedwhich_parser/// What parser to use to parse `.proto` files.create_out_dir/// Create out directory./// --lang_out= param/// -I args/// List of .proto files to compile/// Customize code generationcustomize_callbackprotoc/// Protoc command pathprotoc_extra_args/// Extra `protoc` argscapture_stderr/// Capture stderr when running `protoc`./// Entry point for `.proto` to `.rs` code generation./// This is similar to `protoc --rs_out...`./// Create new codegen object./// Uses `protoc` from `$PATH` by default./// Can be switched to pure rust parser using [`pure`](Self::pure) function.pure/// Switch to pure Rust parser of `.proto` files./// Switch to `protoc` parser of `.proto` files./// Output directory for generated code./// When invoking from `build.rs`, consider using/// [`cargo_out_dir`](Self::cargo_out_dir) instead.cargo_out_dir/// Set output directory relative to Cargo output dir./// With this option, output directory is erased and recreated during invocation./// Add an include directory./// Add include directories./// Append a `.proto` file path to compile/// Append multiple `.proto` file paths to compileprotoc_path/// Specify `protoc` command path to be used when invoking code generation./// # mod protoc_bin_vendored {/// #   pub fn protoc_bin_path() -> Result<std::path::PathBuf, std::io::Error> {/// #   }/// use protobuf_codegen::Codegen;/// Codegen::new()///     .protoc()///     .protoc_path(&protoc_bin_vendored::protoc_bin_path().unwrap())///     .run()/// This option is ignored when pure Rust parser is used./// Capture stderr to error when running `protoc`.protoc_extra_arg/// Extra command line flags for `protoc` invocation./// For example, `--experimental_allow_proto3_optional` option./// Set options to customize code generation/// Callback for dynamic per-element customization./// Invoke the code generation./// This is roughly equivalent to `protoc --rs_out=...` but/// without requiring `protoc-gen-rs` command in `$PATH`./// This function uses pure Rust parser or `protoc` parser depending on/// how this object was configured.run_from_script/// Similar to `run`, but prints the message to stderr and exits the process on error.ProtoPathBuffile_descriptorsfiles_to_generateGenRequestGenResultplugin_mainfor_elemfor_childrenCustomizeElemCtxDescriptorForCustomizeSpecialFieldPseudoDescriptorrustproto_protospecial_field/// Dynamic callback to customize code generation.CustomizeCallbackDefault/// Code to insert before the element in the generated file./// When false, `get_`, `set_`, `mut_` etc. accessors are not generated/// When false, `get_` is not generated even if `syntax = "proto2"`/// Use `bytes::Bytes` for `bytes` fields/// Use `bytes::Bytes` for `string` fields/// When false, `#[non_exhaustive]` is not generated for `oneof` fields.lite_runtime/// Enable lite runtime.gen_mod_rs/// Generate `mod.rs` in the output directory./// This option allows inclusion of generated files from cargo output directory./// This option will likely be on by default in rust-protobuf version 3.inside_protobuf/// Used internally to generate protos bundled in protobuf crate/// like `descriptor.proto`/// When true, protobuf maps are represented with `std::collections::BTreeMap`/// Specifies style of generated code./// Generated files can be customized using this proto/// or using `rustproto.proto` options.CustomizeParseParameterErrorCannotParseBoolUnknownOptionName/// Insert code before the element in the generated file/// (e. g. serde annotations, see/// [example here](https://github.com/stepancheg/rust-protobuf/tree/master/protobuf-examples/customize-serde))./// Generate code for "lite runtime". Generated code contains no code for reflection./// So the generated code (and more importantly, generated binary size) is smaller,/// but reflection, text format, JSON serialization won't work./// Note when using `protoc` plugin `protoc-gen-rs`, the option name is just `lite`./// Generate `mod.rs` with all the generated modules./// This option is on by default in rust-protobuf version 3./// Generate code bundled in protobuf crate. Regular users don't need this option.btreemaps/// Use btreemaps for maps representationupdate_with/// Update fields of self with fields defined in other customizeset_defaults_from/// Update unset fields of self with fields from other customizeparse_from_parameter/// Parse customize options from a string passed via protoc flag.customize_from_rustproto_for_messagecustomize_from_rustproto_for_enumcustomize_from_rustproto_for_fieldcustomize_from_rustproto_for_fileProtoPathcompiler_plugingen_filemod_rsRootScopegen_well_known_types_modgen_allrel_pathRustRelativePath/// Field visibility.CodeWriterwith_no_errorwith_implwrite_line_write_textwrite_generated_bywrite_generated_commonunimplementedindentedcommentedpub_constlazy_static_decl_get_simplelazy_static_decl_getstmt_blockimpl_self_blockimpl_for_blockimpl_args_for_blockpub_structpub_enumfield_entryfield_declpub_field_declfield_decl_visdocumentationmod_docall_documentation/// Writes the documentation of the given path./// Protobuf paths are defined in proto/google/protobuf/descriptor.proto,/// in the `SourceCodeInfo` message./// For example, say we have a file like:/// message Foo {///   optional string foo = 1;/// Let's look at just the field definition. We have the following paths:/// path               represents/// [ 4, 0, 2, 0 ]     The whole field definition./// [ 4, 0, 2, 0, 4 ]  The label (optional)./// [ 4, 0, 2, 0, 5 ]  The type (string)./// [ 4, 0, 2, 0, 1 ]  The name (foo)./// [ 4, 0, 2, 0, 3 ]  The number (1)./// The `4`s can be obtained using simple introspection:/// use protobuf::descriptor::FileDescriptorProto;/// use protobuf::reflect::MessageDescriptor;/// let id = MessageDescriptor::for_type::<FileDescriptorProto>()///     .field_by_name("message_type")///     .expect("`message_type` must exist")///     .proto()///     .number();/// assert_eq!(id, 4);/// The first `0` here means this path refers to the first message./// The `2` then refers to the `field` field on the `DescriptorProto` message./// Then comes another `0` to refer to the first field of the current message./// Etc.fn_blockpub_fndef_fnpub_modwhile_blockif_stmt// if ... { ... }if_else_stmt// if ... {} else { ... }if_let_stmt// if let ... = ... { ... }if_let_else_stmt// if let ... = ... { } else { ... }for_stmtmatch_exprcase_blockcase_exprcode_writerfile_descriptor_call_exprinsideprotobuf_crate_pathDESCRIPTOR_FNGET_BY_RELATIVE_NAME_NAMEDescriptor/// Abstract message or enum descriptor.write_fn_descriptorprotoc_insertion_pointwrite_protoc_insertion_point_for_enumwrite_protoc_insertion_point_for_enum_valueRustIdentident_with_pathRustIdentWithPathsnippetsEXPR_NONEEnumValueWithContextEnumWithScopeWithScopeenum_rust_nameEnumValueGen// enum valuerust_name_inner// name of enum variant in generated rust coderust_name_outerenum_with_scopeEnumGen// Codegen for enum definitionvalues_allvalues_uniquewrite_impl_selfwrite_impl_enum_fn_valuewrite_impl_enum_const_namewrite_impl_enum_fn_from_i32write_impl_enum_fn_from_strwrite_impl_enum_const_valueswrite_impl_enumwrite_impl_enum_fullwrite_impl_enum_full_fn_enum_descriptorrust_enum_descriptor_is_enum_indexwrite_impl_enum_full_fn_descriptorwrite_generated_enum_descriptor_datawrite_impl_eqwrite_impl_hashwrite_impl_defaultProtobufAbsPathrust_field_name_for_protobuf_field_namefile_and_modFileAndModRustTypeMessagerust_types_valuesroot_scopeExtGenextendee_rust_namereturn_type_genProtobufTypeGenwrite_extensionsFieldElemFieldElemEnumoption_kindOptionKindRepeatedFieldRepeatedFieldKindSingularFieldSingularFieldFlagFieldGenMapFieldOneofFieldRustType// function type params after first underscorecallback_paramsAccessorFnmake_accessor_fns_lambdamake_accessor_fns_has_get_setmake_accessor_fns_has_get_mut_setaccessor_fn_mapaccessor_fn_repeatedaccessor_fn_oneof_enumaccessor_fn_singular_without_flagaccessor_fn_singular_with_flagaccessor_fn_oneofaccessor_fnwrite_push_accessortype_extTypeExtmessage_or_enum_to_rust_relativePrimitiveTypeVariantRustValueTypedFieldWithContextMessageOrEnumWithScopeMessageWithScope/// Enum default value variant, either from proto or from enum definitionrust_name_relativeenum_rust_typeenum_or_unknown_rust_typedefault_value_rust_exprFieldElemMessagerust_typeHowToGetMessageSizeComputeGetCachedproto_typeis_copyrust_storage_elem_typerust_set_xxx_param_type// Type of set_xxx function parameter type for singular fieldsprimitive_type_variantsingular_field_sizewrite_element_sizewrite_write_elementread_one_linerfield_elemcamel_casemake_tagwrite_protoc_insertion_point_for_fieldquote_escape_bytesquote_escape_strfield_type_protobuf_name_message// optional or required// repeated except map// part of oneofSingularOrOneofFieldgetter_return_type// Type of `xxx` function for singular type.proto_field// field name in generated code// for message levelis_repeated_packedfull_storage_type// type of field in structfull_storage_iter_elem_type// type of `v` in `for v in field`os_write_fn_suffix// suffix `xxx` as in `os.write_xxx_no_tag(..)`os_write_fn_suffix_with_unknown_for_enumset_xxx_param_type// for field `foo`, type of param of `fn set_foo(..)`take_xxx_return_type// for field `foo`, return type if `fn take_foo(..)`mut_xxx_return_type// for field `foo`, return type of `fn mut_foo(..)`// for field `foo`, return type of `fn foo(..)`elem_type_is_copy// elem data is not stored in heapdefaut_value_from_proto_floatsingular_or_oneof_default_value_from_protodefault_value_from_protodefault_value_from_proto_typedxxx_default_value_rust// default value to be returned from `fn xxx` for field `xxx`.element_default_value_rust// default to be assigned to fieldreconstruct_defwrite_clear// output code that writes single element to streamself_fieldself_field_is_someself_field_is_noneself_field_as_option// field data viewed as Optionwrite_struct_fieldwrite_if_let_self_field_is_somewrite_if_self_field_is_nonewrite_for_self_field// repeated or singularwrite_self_field_assignwrite_self_field_assign_somewrite_self_field_assign_value_singularwrite_self_field_assign_valuewrite_self_field_assign_defaultself_field_vec_packed_sizeclear_field_funcwrite_merge_from_field_message_string_bytes_repeatedtag_with_wire_typewrite_merge_from_oneof_case_block// Write `merge_from` part for this oneof fieldwrite_merge_from_map_case_block// Write `merge_from` part for this map fieldwrite_merge_from_singular_case_block// Write `merge_from` part for this singular fieldwrite_merge_from_repeated_case_block// Write `merge_from` part for this repeated fieldwrite_merge_from_field_case_block/// Write `merge_from` part for this fieldwrite_write_map_fieldwrite_message_write_fieldfor_each_map_entrywrite_compute_map_field_sizewrite_message_compute_field_sizewrite_message_field_get_singular_messagewrite_message_field_get_singular_enumwrite_message_field_get_singularwrite_message_field_get_oneofwrite_message_field_gethas_hashas_muthas_takewrite_message_field_haswrite_message_field_setwrite_message_field_mut_singular_with_flagwrite_message_field_mut_singularwrite_message_field_mutwrite_message_field_take_oneofwrite_message_field_take_singularwrite_message_field_takewrite_message_single_field_accessorsrust_variant_name_for_protobuf_oneof_field_name/// Field is `Option<T>`/// Field is `SingularPtrField<T>`/// Optional fields can be stored are `Option<T>` or `SingularPtrField<T>`.wrap_elementas_ref_type// Type of `as_ref()` operation_as_option_refunwrap_ref_or_elsewrap_valueEXPR_VEC_NEW/// Repeated field can be `Vec<T>` or `RepeatedField<T>`.WithFlag// proto2 or proto3 messageWithoutFlag// proto3rust_storage_type_is_s_varintprotobuf_nameos_write_fn_param_typeencoded_size/// True if self is signed integer with zigzag encoding/// Rust type for protobuf base type.// type of `v` in `os.write_xxx_no_tag(v)`/// Size of value for type, None if variable.write_file_descriptor_dataMessageGenproto_path_to_rust_modFileScopeproto_name_to_rscompiler_plugin_resultmod_nameGenFileResultrelative_modproto_path_to_fn_file_descriptorexpr_vec_with_capacity_constescape_bytewrite_generate_file_descriptorwrite_file_descriptorwrite_file_descriptor_proto/// Code to generate call `module::file_descriptor()`.RustPath/// Path to `protobuf` crate, different when `.proto` file is/// used inside or outside of protobuf crate./// Pair of (key, value) if this message is map entrysnake_caseOneofGenOneofVariantGenwrite_protoc_insertion_point_for_messagewrite_protoc_insertion_point_for_special_field/// Protobuf message Rust type name/// Code which emits default instance.message_descriptor/// Message info for codegenrequired_fieldsmessage_fieldsfields_except_oneoffields_except_groupfields_except_oneof_and_groupwrite_match_each_oneof_variantwrite_write_to_with_cached_sizeswrite_default_instance_lazywrite_default_instance_staticwrite_default_instancewrite_compute_sizewrite_field_accessorswrite_merge_fromwrite_impl_message_full_fn_descriptorwrite_generated_message_descriptor_datawrite_is_initializedwrite_impl_messagewrite_impl_message_fullwrite_impl_valuewrite_impl_displaysupports_derive_partial_eqwrite_structwrite_impl_default_for_ampwrite_dummy_impl_partial_eqmessage_name_to_nested_mod_namestrxwrite_protoc_insertion_point_for_oneofwrite_protoc_insertion_point_for_oneof_fieldmake_pathOneofVariantWithContextOneofWithContextoneof_variant_rust_nameoneof_field_name// oneof one { ... }need_boxed// Detecting recursion: if oneof fields contains a self-reference// or another message which has a reference to self,// put oneof variant into a box.variant_path_variantoneof_field_path// Message containing this oneoftype_name_relativevariants_except_groupwrite_impl_oneofwrite_impl_oneof_full_fn_descriptorwrite_impl_oneof_fullwrite_generated_oneof_descriptor_data//! Oneof-related codegen functions.WELL_KNOWN_TYPES_PROTO_FILE_FULL_NAMESident_start// Copy-pasted from libsyntax.ident_continue/// Used in protobuf-codegen-identical-testtest_mod_path_proto_exttest_mod_path_unknown_exttest_mod_path_empty_exttest_mod_path_dirwrite_protoc_insertion_point/// Write `// @protoc_insertion_point(...)` before the element./// This is similar to what `protoc` codegen does for C++ or Java./// This can be used to modify the generated code.parse_rust_keywordRustPathComponentis_rust_keyword/// Valid Rust identifierto_pathinto_rel_pathprepend_identRUST_KEYWORDSRUST_KEYWORDS_WHICH_CANNOT_BE_RAW// https://internals.rust-lang.org/t/raw-identifiers-dont-work-for-all-identifiers/9094/3is_rust_keyword_which_cannot_be_rawsuper_pathwith_identremove_firstappend_componentappend_identappend_with_identinto_relative_or_panictest_quote_escape_bytesinto_path_emptyfrom_identspush_identto_reverseexpr_vec_with_capacityis_well_known_type_full// integer: signed?, size in bits// param is size in bits// [T], not &[T]// str, not &str// Box<T>// &T// protobuf message// protobuf enum, not any enum// protobuf enum or unknown// oneof enum// bytes::Bytes// chars::Chars// group// Represent subset of rust types used in generated codeto_codeamp_stramp_slice_of_u8/// `&[u8]`./// Type is rust primitive?is_u8is_stris_sliceis_slice_u8is_messageis_enum_or_unknownis_refis_box// default value for typedefault_value_typed/// Emit a code to clear a variable `v`into_target// expression to convert `v` of type `self` to type `target`try_into_target// https://github.com/rust-lang-nursery/rustfmt/issues/3131ref_type/// Type to view data of this typeiter_elem_type// type of `v` in `for v in xxx`/// Representation of an expression in code generator: text and typeinto_typefile_last_componenttest_file_last_componentis_descriptor_protomake_path_to_pathtype_name_to_rust_relativeTokioBytes_TokioBytesType// ProtobufType trait nameprotobuf_value_rust_typeinto_target_ref_box_to_refProtobufAbsPathRefProtobufIdentRefProtobufRelPathProtobufRelPathRefpackages_find_enum// find enum by fully qualified namefind_message// find message by fully qualified name// find message or enum by fully qualified nameto_scopefind_message_or_enum_absfind_enums// find all enums in given file descriptorfind_messages/// Find all messages in given file descriptorfind_messages_except_map/// Find all messages in given file descriptor, except map messagesfind_messages_and_enums/// find all messages and enums in given file descriptorfile_scopemessage_descriptors// get message descriptors in this scopeenum_descriptors// get enum descriptors in this scope// get messages with attached scopes in this scope// get enums with attached scopes in this scopemessages_and_enums// get messages and enums with attached scopes in this scopenested_scopes// nested scopes, i. e. scopes of nested messageswalk_scopes_implwalk_scopes// apply callback for this scope and all nested scopesrust_path_to_fileprotobuf_path_to_fileprotobuf_absolute_path// message or enum namename_absolute/// Return absolute name starting with dot// rust type name of this descriptorrust_name_to_filerust_name_with_file// fully-qualified name of this typeinto_scope/// This message is a special message which is a map.en// find enum value by protobuf nameis_oneof// rust type name of enumremove_toremove_suffixtest_remove_totest_remove_suffixtest_capitalizeWELL_KNOWN_TYPES_PROTO_FILE_NAMESNAMESis_well_known_typetest_is_well_known_type_fullOutputIsNotDirectoryOutputDoesNotExistOrNotAccssibleFailedToWriteFileprotoc_gen_rs//! # Protobuf code generator for `protobuf` crate//! This crate is useful mostly from `build.rs` scripts to generate `.rs` files during the build.//! # How to generate code//! There are three main ways to generate `.rs` files from `.proto` files://! * using `protoc` command line tool and `protoc-gen-rs` plugin//! * using this crate `Codegen` with pure rust parser//! * using this crate `Codegen` with `protoc` parser//! Which one should you use depends on your needs.//! If you are using non-cargo build system (like Bazel), you might prefer//! using `protoc-gen-rs` plugin for `protoc`.//! If you build with `cargo`, you probably want to use `Codegen` from this crate.//! # Protoc parser vs pure rust parser//! There are two protobuf parsers which can be plugged into this crate://! * `protoc`-based parser (`protoc` is a command like utility from Google protobuf)//! * pure rust parser (`protobuf-parse` crate)//! `protoc`-based parser is expected to parse `.proto` files very correctly://! all Google's protobuf implementations rely on it.//! While there are no known bugs in `protobuf-parse`, it is not tested very well.//! Also `protobuf-parse` does not implement certain rarely used features of `.proto` parser,//! mostly complex message options specified in `.proto` files.//! I never saw anyone using them, but you have been warned.//! Note `protoc` command can be obtained from//! [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored) crate.//! # mod protoc_bin_vendored {//! #   pub fn protoc_bin_path() -> Result<std::path::PathBuf, std::io::Error> {//! #       unimplemented!()//! // Use this in build.rs//! protobuf_codegen::Codegen::new()//!     // Use `protoc` parser, optional.//!     .protoc()//!     // Use `protoc-bin-vendored` bundled protoc command, optional.//!     .protoc_path(&protoc_bin_vendored::protoc_bin_path().unwrap())//!     // All inputs and imports from the inputs must reside in `includes` directories.//!     .includes(&["src/protos"])//!     // Inputs must reside in some of include paths.//!     .input("src/protos/apple.proto")//!     .input("src/protos/banana.proto")//!     // Specify output directory relative to Cargo output directory.//!     .cargo_out_dir("protos")//!     .run_from_script();//! ## How to use `protoc-gen-rs`//! If you have to.//! (Note `protoc` can be invoked programmatically with//! [protoc crate](https://docs.rs/protoc/))//! 0) Install protobuf for `protoc` binary.//! On OS X [Homebrew](https://github.com/Homebrew/brew) can be used://! brew install protobuf//! On Ubuntu, `protobuf-compiler` package can be installed://! apt-get install protobuf-compiler//! Protobuf is needed only for code generation, `rust-protobuf` runtime//! does not use C++ protobuf library.//! 1) Install `protoc-gen-rs` program (which is `protoc` plugin)//! It can be installed either from source or with `cargo install protobuf-codegen` command.//! 2) Add `protoc-gen-rs` to $PATH//! If you installed it with cargo, it should be//! PATH="$HOME/.cargo/bin:$PATH"//! 3) Generate .rs files://! protoc --rs_out . foo.proto//! This will generate .rs files in current directory.//! # Customize generate code//! Sometimes generated code need to be adjusted, e. g. to have custom derives.//! rust-protobuf provides two options to do that://! * generated `.rs` files contain `@@protoc_insertion_point(...)` markers//!   (similar markers inserts Google's protobuf generator for C++ or Java).//!   Simple script `sed` one-liners can be used to replace these markers with custom annotations.//! * `Codegen::customize_callback` can be used to patch generated code//!   when invoked from `build.rs` script.//! # Serde//! rust-protobuf since version 3 no longer directly supports serde.//! Rust-protobuf 3 fully supports://! * runtime reflection//! * JSON parsing and printing via//!  [`protobuf-json-mapping`](https://docs.rs/protobuf-json-mapping)//! Which covers the most of serde use cases.//! If you still need serde, generic customization callback (see above) can be used//! to insert `#[serde(...)]` annotations.//! [Example project](https://github.com/stepancheg/rust-protobuf/tree/master/protobuf-examples/customize-serde)//! in the rust-protobuf repository demonstrates how to do it.protoc_gen_rust_main// copy-paste from Google Protobuf// must be kept in sync with Google for JSON interoptest_camel_casetest_snake_casecase_convertparse_and_typecheckproto_pathprotobuf_abs_pathprotobuf_identprotobuf_pathprotobuf_rel_pathtest_against_protobuf_protos// Public API// Non-public API used by codegen crate.FileDescriptorPair//! # Parse `.proto` files//! Parse `.proto` file definitions, **not** the protobuf text format serialization.//! Files can be parsed using pure Rust parser (mod `pure`)//! or using the `protoc` command (mod `protoc`).//! This crate is not meant to be used directly, but rather through the `protobuf-codegen` crate.//! If you think this crate might be useful to you,//! please [consider creating an issue](https://github.com/stepancheg/rust-protobuf/issues/new),//! until that this crate is considered to have **no stable API**.relative_paths/// One entry for each input `.proto` file./// All parsed `.proto` files including dependencies of input files./// Description of the parser (e.g. to include in generated files).ParsedAndTypechecked/// Result of parsing `.proto` files./// Configure and invoke `.proto` parser./// Create new default configured parser./// Use pure rust parser./// Use `protoc` for parsing./// Specify `protoc` path used for parsing./// This is ignored if pure rust parser is used./// Extra arguments to pass to `protoc` command (like experimental options)./// Capture stderr and return it in error./// This option applies only to `protoc` parser./// By default `protoc` stderr is inherited from this process stderr./// Parse `.proto` files and typecheck them using pure Rust parser of `protoc` command.file_descriptor_set/// Parse and convert result to `FileDescriptorSet`.is_separatorfs_path_to_proto_pathtest_fs_path_to_proto_pathRUSTPROTO_PROTOANY_PROTOAPI_PROTODESCRIPTOR_PROTODURATION_PROTOEMPTY_PROTOFIELD_MASK_PROTOSOURCE_CONTEXT_PROTOSTRUCT_PROTOTIMESTAMP_PROTOTYPE_PROTOWRAPPERS_PROTO//! This folder contains copy of .proto files//! needed for pure codegen.//! Files are copied here because when publishing to crates,//! referencing files from outside is not allowed.BackslashesEmptyComponent/// Protobuf file relative normalized file path.unchecked_newto_proto_path_bufProtobufIdent/// Protobuf absolute name (e. g. `.foo.Bar`).remove_prefixself_and_parentsis_abs/// If given name is an fully quialified protobuf name.new_from_relpackage_from_file_protopackage_from_file_descriptorfrom_path_without_dotfrom_path_maybe_dotpush_simplepush_relative/// Pop the last name componentto_root_relabsolute_path_push_simpleabsolute_path_remove_prefix/// Identifier in `.proto` fileProtobufPath/// Protobuf identifier can be absolute or relative._resolvesplit_first_remProtocNonZeroProtocNamedNonZeroProtocNamedNonZeroStderrInputIsEmptyOutputIsEmptyOutputDoesNotStartWithPrefixVersionIsEmptyVersionDoesNotStartWithDigitFailedToSpawnCommandProtocOutputIsNotUtf8/// `--file_descriptor_out=...` param/// `-I` args/// List of `.proto` files to compileinclude_imports/// `--include_imports`/// Extra command line flags (like `--experimental_allow_proto3_optional`)/// Capture stderr instead of inheriting it.DescriptorSetOutArgs/// `Protoc --descriptor_set_out...` args/// Set `--file_descriptor_out=...` param/// Append a path to `-I` args/// Append multiple paths to `-I` args/// Set `--include_imports`extra_arg/// Add command line flags like `--experimental_allow_proto3_optional`.write_descriptor_set/// Execute `protoc --descriptor_set_out=`/// Protoc command.from_env_path/// New `protoc` command from `$PATH`/// New `protoc` command from specified path/// // Use a binary from `protoc-bin-vendored` crate/// let protoc = protoc::Protoc::from_path(///     protoc_bin_vendored::protoc_bin_path().unwrap());_check/// Check `protoc` command found and valid/// Obtain `protoc` version/// Execute `protoc` command with given args, check it completed correctly.descriptor_set_out_args/// Get default DescriptorSetOutArgs for this command./// Protobuf (protoc) version._is_3/// `true` if the protoc major version is 3.//! API to invoke `protoc` command.//! `protoc` command must be in `$PATH`, along with `protoc-gen-LANG` command.//! Note that to generate `rust` code from `.proto` files, `protoc-rust` crate//! can be used, which does not require `protoc-gen-rs` present in `$PATH`.//! Parse `.proto` files using `protoc` command.path_to_proto_path/// Parse `.proto` files using `protoc` command.option_resolvertype_resolverescape_bytes_toOptionResolerProtobufOptionsTypeResolverDefaultValueIsNotStringLiteralExpectingMessageExpectingEnumWithFullNameTypeResolvedSint32Sint64Sfixed64Sfixed32from_fieldtype_enumcurrent_filemap_entry_name_for_field_namemap_entry_fieldFieldTypemap_entry_messagegroup_messageWithLocservice_methodis_proto3_optionalfind_message_by_abs_namefind_enum_by_abs_nameEnumerationRulepopulate_dependencies//! Convert parser model to rust-protobuf modelProtobufConstantProtobufConstantMessageProtobufConstantMessageFieldNameProtobufOptionNameProtobufOptionNameExtProtobufOptionNamePartOptionResolverErrorExtensionIsNotMessageUnknownFieldNameWrongExtensionTypeExtensionNotFoundUnsupportedExtensionTypeBuiltinOptionNotFoundBuiltinOptionPointsToNonSingularFieldWrongOptionTypeMessageFieldRequiresMessageConstantMessageNotFoundMessageFoundMoreThanOnceLookupScope2current_pathscopespartial_scopesLookupScopeUnion2as_message_by_name_boolby_name_stringProtobufOptiondescriptor_without_optionsall_filesscope_resolved_candidates_relscope_resolved_candidatesfind_extension_by_abs_pathfind_extension_by_pathext_resolve_field_extext_resolve_fieldcustom_option_ext_stepadd_option_value_to_unknown_fieldscustom_option_extuint32add_option_value_message_to_unknown_fieldscustom_option_builtincustom_optioncustom_optionsenum_optionsenum_value_optionsmessage_optionsoneof_optionsservice_optionsservice_method_optionsTypeResolverErrorNotFoundByAbsPathNotFoundByRelPath_descriptor_typeLookupScopefind_memberfind_message_or_enum_by_abs_nameresolve_message_or_enumparse_dependenciesparse_and_typecheck_custom//! Pure rust `.proto` file parser.format_protobuf_floatParserErrorWithLocationModelErrorInconvertibleValuewith_loc/// Protobuf syntax [2](https://developers.google.com/protocol-buffers/docs/proto) (default)/// Protobuf syntax [3](https://developers.google.com/protocol-buffers/docs/proto3)/// Protobuf syntax./// A well-formed message can have zero or one of this field (but not more than one)./// This field can be repeated any number of times (including zero) in a well-formed message./// The order of the repeated values will be preserved./// A well-formed message must have exactly one of this field./// A field rule/// Protobuf group/// Protobuf int32/// Uses variable-length encoding. Inefficient for encoding negative numbers – if/// your field is likely to have negative values, use sint32 instead./// Protobuf int64/// your field is likely to have negative values, use sint64 instead./// Protobuf uint32/// Uses variable-length encoding./// Protobuf uint64/// Protobuf sint32/// Uses ZigZag variable-length encoding. Signed int value. These more efficiently/// encode negative numbers than regular int32s./// Protobuf sint64/// Protobuf bool/// Protobuf fixed64/// Always eight bytes. More efficient than uint64 if values are often greater than 2^56./// Protobuf sfixed64/// Always eight bytes./// Protobuf double/// Protobuf string/// A string must always contain UTF-8 encoded or 7-bit ASCII text./// Protobuf bytes/// May contain any arbitrary sequence of bytes./// Protobut fixed32/// Always four bytes. More efficient than uint32 if values are often greater than 2^28./// Protobut sfixed32/// Always four bytes./// Protobut float/// Protobuf message or enum (holds the name)/// Protobut map/// Protobuf group (deprecated)/// Protobuf supported field types/// Field name/// Field `Rule`/// Field type/// Non-builtin options/// A Protobuf FieldFieldOrOneOf/// A Protobuf field of oneof group/// Message name/// Message fields and oneofsreserved_nums/// Message reserved numbersreserved_names/// Message reserved names/// Nested messages/// Nested enumsextension_ranges/// Extension field numbers/// Extensions/// A protobuf messageregular_fields_including_in_oneofs/** Find a field by name. */_nested_extensionsregular_fields_for_test/// enum value name/// enum value number/// enum value options/// A protobuf enumeration field/// enum name/// enum values/// enum options/// enum reserved numbers/// enum reserved names/// A protobuf enumerator/// OneOf name/// OneOf fields/// oneof options/// A OneOf/// Extend this type with field/// Extension field/// Method name/// Input type/// Output type/// If this method is client streaming/// If this method is server streaming/// Method options/// Service method/// Service name/// Service definitionfull_type_nameAnyTypeUrl// TODO: eq/// constant = fullIdent |///            ( [ "-" | "+" ] intLit ) |///            ( [ "-" | "+" ] floatLit ) |///            strLit |///            boolLit |///            messageValue/// https://protobuf.dev/reference/protobuf/proto2-spec/#constant/// https://protobuf.dev/reference/protobuf/proto3-spec/#constant/// https://protobuf.dev/reference/protobuf/textformat-spec/#fields/** Interpret .proto constant as an reflection value. */Ext/// Equivalent of `UninterpretedOption.NamePart`.BuiltinImportVis/// Visibility of import statement/// Import statement/// Imports/// Package/// Protobuf Syntax/// Top level messages/// Enums/// Services/// A File descriptor representing a whole .proto file/// Parses a .proto file content into a `FileDescriptor`//! A nom-based protobuf file parser//! This crate can be seen as a rust transcription of the//! [descriptor.proto](https://github.com/google/protobuf/blob/master/src/google/protobuf/descriptor.proto) fileParseAndTypeckErrorFileContentIsNotUtf8FileNotFoundInImportPathFileMustResideInImportPathCouldNotReadFileWithFileErrorResolvedProtoFile/// Resolve a `.proto` file./// Return `None` if a path is unknown, and if a path is a built-in protobuf file,/// like `google/protobuf/descriptor.proto`, it will be handled by the library.ProtoPathResolver/// Resolve `.proto` files. `Display` is used for error messages.parsed_filesfile_and_all_deps_already_parsedall_deps_already_parsedadd_file_contentadd_imported_file/// For error reporting./// File content./// `.proto` file result provided from the [`ProtoPathResolver`].fs_resolver/// Parse `.proto` files using pure Rust implementation./// TODO: this API is to be refactored./// Parse imports from a `.proto` file./// The result is [`FileDescriptorProto`] object with only `*dependency` fields filled.lexer_implLexerErrornum_litNumLitParserErrorIncorrectInputExpectConstantUnknownSyntaxLabelNotAllowedLabelRequiredGroupNameShouldStartWithUpperCaseMapFieldNotAllowedOneOfInGroupOneOfInOneOfOneOfInExtend/// Basic information about parsing error./// 1-basedToI32ToI64MessageBodyParseModeMessageProto2MessageProto3ExtendProto2ExtendProto3label_allowedsome_label_requiredmap_allowedis_most_non_fields_allowedis_option_allowedis_extensions_allowedMessageBodyto_option_valueNumLitExnext_full_ident// fullIdent = ident { "." ident }next_full_ident_relnext_empty_statement_opt// emptyStatement = ";"next_message_or_enum_type// messageName = ident// enumName = ident// messageType = [ "." ] { ident "." } messageName// enumType = [ "." ] { ident "." } enumNamenext_group_name// groupName = capitalLetter { letter | decimalDigit | "_" }next_bool_lit_opt// boolLit = "true" | "false"next_num_litnext_message_constant_field_namenext_message_constantnext_list_constantnext_constant// constant = fullIdent | ( [ "-" | "+" ] intLit ) | ( [ "-" | "+" ] floatLit ) |//            strLit | boolLit | MessageValuenext_field_valuenext_int_litnext_syntax// syntax = "syntax" "=" quote "proto2" quote ";"// syntax = "syntax" "=" quote "proto3" quote ";"next_import_opt// import = "import" [ "weak" | "public" ] strLit ";"next_package_opt// package = "package" fullIdent ";"next_identnext_option_name_componentnext_option_name// https://github.com/google/protobuf/issues/4563// optionName = ( ident | "(" fullIdent ")" ) { "." ident }next_option_opt// option = "option" optionName  "=" constant ";"next_label// label = "required" | "optional" | "repeated"next_field_typenext_field_numbernext_field_option// fieldOption = optionName "=" constantnext_field_options// fieldOptions = fieldOption { ","  fieldOption }next_field// field = label type fieldName "=" fieldNumber [ "[" fieldOptions "]" ] ";"// group = label "group" groupName "=" fieldNumber messageBodynext_oneof_opt// oneof = "oneof" oneofName "{" { oneofField | emptyStatement } "}"// oneofField = type fieldName "=" fieldNumber [ "[" fieldOptions "]" ] ";"next_map_field_type_opt// mapField = "map" "<" keyType "," type ">" mapName "=" fieldNumber [ "[" fieldOptions "]" ] ";"// keyType = "int32" | "int64" | "uint32" | "uint64" | "sint32" | "sint64" |//           "fixed32" | "fixed64" | "sfixed32" | "sfixed64" | "bool" | "string"// range =  intLit [ "to" ( intLit | "max" ) ]next_ranges// ranges = range { "," range }next_extensions_opt// extensions = "extensions" ranges ";"next_reserved_opt// Grammar is incorrect: https://github.com/google/protobuf/issues/4558// reserved = "reserved" ( ranges | fieldNames ) ";"// fieldNames = fieldName { "," fieldName }next_enum_value_option// enumValueOption = optionName "=" constantnext_enum_value// https://github.com/google/protobuf/issues/4561next_enum_field// enumField = ident "=" intLit [ "[" enumValueOption { ","  enumValueOption } "]" ]";"next_enum_opt// enum = "enum" enumName enumBody// enumBody = "{" { option | enumField | emptyStatement | reserved } "}"next_message_body// messageBody = "{" { field | enum | message | extend | extensions | group |//               option | oneof | mapField | reserved | emptyStatement } "}"next_message_opt// message = "message" messageName messageBodynext_extend_opt// extend = "extend" messageType "{" {field | group | emptyStatement} "}"next_options_or_colonnext_stream_opt// stream = "stream" streamName "(" messageType "," messageType ")"//        (( "{" { option | emptyStatement } "}") | ";" )next_rpc_opt// rpc = "rpc" rpcName "(" [ "stream" ] messageType ")"//     "returns" "(" [ "stream" ] messageType ")"//     (( "{" { option | emptyStatement } "}" ) | ";" )next_service_opt// proto2:// service = "service" serviceName "{" { option | rpc | stream | emptyStatement } "}"// proto3:// service = "service" serviceName "{" { option | rpc | emptyStatement } "}"next_proto// proto = syntax { import | package | option | topLevelDef | emptyStatement }// topLevelDef = message | enum | extend | service// Protobuf grammar// Boolean// Constant// Syntax// Import Statement// Package// Option// Fields// Extensions and Reserved// Extensions// Reserved// Top Level definitions// Enum definition// Message definition// Extend// Service definition// Proto filetest_syntaxtest_field_default_value_inttest_field_default_value_floattest_field_optionstest_messagetest_enumtest_ignoretest_importtest_nested_messagetest_oneoftest_reserved_in_messagetest_reserved_in_enumtest_default_value_inttest_default_value_stringtest_default_value_bytestest_grouptest_incorrect_file_descriptorRelPath/// Wrapper for `Path` that asserts that the path is relative._RelPathBuf/// Wrapper for `PathBuf` that asserts that the path is relative._to_ownedparse_recursively/// Pure Rust parser implemented by this crate./// Parse `.proto` files using `protoc --descriptor_set_out=...` command./// Which parse to use to parse `.proto` files./// Implementation must match exactly/// `ToJsonName()` function in C++ `descriptor.cc`.ProtobufFloatParseErrorEmptyStringCannotParseFloatProtobufFloatParseResultPROTOBUF_NANPROTOBUF_INF/// Format float as in protobuf `.proto` files/// Parse float from `.proto` formattest_format_protobuf_float/// Negate `u64` checking for overflow.JsonNumberLitjson_number_litFIRST_COLTokenWithLocation// TODO: something better than thisExpectCharIncorrectFloatLit// TODO: how it is different from ParseFloatError?IncorrectJsonEscapeIncorrectJsonNumberIncorrectUnicodeCharExpectHexDigitExpectOctDigitExpectDecDigitExpectedIdentLexerResult// a single char can be up to 4-bytes when encoded in utf-8DecodedBytes/// The raw bytes for a single char or escape sequence in a string literal/// The raw bytes are available via an `into_iter` implementation.is_letter/// No more charsrem_chars/// Remaining charslookahead_char_islookahead_char_is_innext_char_optskip_whitespaces/// Skip whitespacesskip_c_commentskip_cpp_commentskip_sh_commentskip_commentskip_wslookahead_charlookahead_is_strskip_if_lookahead_is_strnext_char_ifnext_char_if_eqnext_char_if_innext_char_expect_eqnext_char_expectskip_to_pos/// properly update line and columnnext_letter_opt// letter = "A" … "Z" | "a" … "z"// https://github.com/google/protobuf/issues/4565_next_capital_letter_opt// capitalLetter =  "A" … "Z"next_ident_partnext_ident_opt// ident = letter { letter | decimalDigit | "_" }next_hex_lit_opt// hexLit     = "0" ( "x" | "X" ) hexDigit { hexDigit }next_decimal_octal_lit_opt// decimalLit = ( "1" … "9" ) { decimalDigit }// octalLit   = "0" { octalDigit }next_hex_digit// hexDigit     = "0" … "9" | "A" … "F" | "a" … "f"next_octal_digit// octalDigit   = "0" … "7"next_decimal_digit// decimalDigit = "0" … "9"next_decimal_digits// decimals  = decimalDigit { decimalDigit }next_int_lit_opt// intLit     = decimalLit | octalLit | hexLitnext_exponent_opt// exponent  = ( "e" | "E" ) [ "+" | "-" ] decimalsnext_float_lit// floatLit = ( decimals "." [ decimals ] [ exponent ] | decimals exponent | "."decimals [ exponent ] ) | "inf" | "nan"next_str_lit_bytes// charValue = hexEscape | octEscape | charEscape | /[^\0\n\\]/// hexEscape = '\' ( "x" | "X" ) hexDigit hexDigit// https://github.com/google/protobuf/issues/4560// octEscape = '\' octalDigit octalDigit octalDigit// charEscape = '\' ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | '\' | "'" | '"' )// quote = "'" | '"'char_try_fromnext_json_char_valuenext_str_lit_raw// https://github.com/google/protobuf/issues/4564// strLit = ( "'" { charValue } "'" ) | ( '"' { charValue } '"' )next_str_lit_raw_optnext_json_number_opt/// Parse next token as JSON numbernext_token_inner// str functions// char functions// Identifiers// Integer literals// Floating-point literals// String literalslexlex_opttest_lexer_int_littest_lexer_float_littest_lexer_float_lit_leading_zeros_in_expFIRST_LINE/// Location in file//! Implementation of lexer for both protobuf parser and for text format parser.Proto// `.proto` filesTextFormat// Protobuf text formatJson// JSON/// We use the same lexer/tokenizer for all parsers for simplicityStrLitDecodeResult/// String literal, both `string` and `bytes`./// May fail if not valid UTF8quotedIntLit// Protobuf tokenizer has separate tokens for int and float.// Tokens do not include sign.FloatLitJsonNumber// including quotes/// Back to originalto_num_lit// TODO: too broadNotAllowedInThisContextExpectStrLitExpectIntLitExpectFloatLitExpectIdentExpectNamedIdentExpectAnyCharTokenizerResultlast_token_loclookahead_loclookaheadlookahead_somenext_some/// Can be called only after lookahead, otherwise it's errorsyntax_eof/// No more tokensnext_token_if_mapnext_token_check_mapnext_token_ifnext_ident_if_innext_ident_if_eqnext_ident_expect_eqnext_ident_if_eq_errornext_symbol_if_innext_symbol_if_eqnext_symbol_expect_eqnext_symbol_expect_eq_oneoflookahead_is_str_litlookahead_is_int_litlookahead_is_json_numberlookahead_if_symbollookahead_is_symbollookahead_is_identnext_str_littest_identtest_str_lit//! # Supporting code for protobuf crates//! Code in this crate is used in protobuf crates like `protobuf` or `protobuf-parse`.//! None of code in this crate has public API.test_escape_unescapetest_print_to_bytestest_unescape_stringTopoSortCycletest_toposorttest_toposort_checkQOI_OP_INDEXQOI_OP_DIFF// 00xxxxxxQOI_OP_LUMA// 01xxxxxxQOI_OP_RUN// 10xxxxxxQOI_OP_RGB// 11xxxxxxQOI_OP_RGBA// 11111110QOI_MASK_2QOI_HEADER_SIZEQOI_PADDINGQOI_PADDING_SIZE// 7 zeros and one 0x01 markerQOI_MAGICQOI_PIXELS_MAX// 11111111// (11)000000// TODO: can be removed once https://github.com/rust-lang/rust/issues/74985 is stableSupportedChannelsQOI_OP_INDEX_ENDQOI_OP_RUN_ENDQOI_OP_DIFF_END// <- note, 0x3d (not 0x3f)QOI_OP_LUMA_ENDdecode_impl_slicedecode_impl_slice_all/// Decode the image into a pre-allocated buffer./// Note: the resulting number of channels will match the header. In order to change/// the number of channels, use [`Decoder::with_channels`].decode_to_vec/// Decode the image into a newly allocated vector.decode_header/// Decode the image header from a slice of bytes.decode_impl_streamdecode_impl_stream_all/// Decode QOI images from slices or from streams./// Creates a new decoder from a slice of bytes./// The header will be decoded immediately upon construction./// Note: this provides the most efficient decoding, but requires the source data to/// be loaded in memory in order to decode it. In order to decode from a generic/// stream, use [`Decoder::from_stream`] instead./// Returns the undecoded tail of the input slice of bytes./// Creates a new decoder from a generic reader that implements [`Read`](std::io::Read)./// Note: while it's possible to pass a `&[u8]` slice here since it implements `Read`, it/// would be more efficient to use a specialized constructor instead: [`Decoder::new`]./// Returns an immutable reference to the underlying reader./// Consumes the decoder and returns the underlying reader back.new_implwith_channels/// Returns a new decoder with modified number of channels./// By default, the number of channels in the decoded image will be equal/// to whatever is specified in the header. However, it is also possible/// to decode RGB into RGBA (in which case the alpha channel will be set/// to 255), and vice versa (in which case the alpha channel will be ignored)./// Returns the number of channels in the decoded image./// Note: this may differ from the number of channels specified in the header./// Returns the decoded image header.required_buf_len/// The number of bytes the decoded image will take./// Can be used to pre-allocate the buffer to decode the image into./// Decodes the image to a pre-allocated buffer and returns the number of bytes written./// The minimum size of the buffer can be found via [`Decoder::required_buf_len`]./// Decodes the image into a newly allocated vector of bytes and returns it.GenericWriterencode_impl_allencode_max_len/// The maximum number of bytes the encoded image will take./// Can be used to pre-allocate the buffer to encode the image into.encode_to_buf/// Encode the image into a pre-allocated buffer./// Returns the total number of bytes written./// Encode the image into a newly allocated vector./// Encode QOI images into buffers or into streams./// Creates a new encoder from a given array of pixel data and image dimensions./// The number of channels will be inferred automatically (the valid values/// are 3 or 4). The color space will be set to sRGB by default./// Returns a new encoder with modified color space./// Note: the color space doesn't affect encoding or decoding in any way, it's/// a purely informative field that's stored in the image header./// Returns the inferred number of channels./// Returns the header that will be stored in the encoded image./// Encodes the image to a pre-allocated buffer and returns the number of bytes written./// The minimum size of the buffer can be found via [`Encoder::required_buf_len`]./// Encodes the image into a newly allocated vector of bytes and returns it.encode_to_stream/// Encodes the image directly to a generic writer that implements [`Write`](std::io::Write)./// Note: while it's possible to pass a `&mut [u8]` slice here since it implements `Write`,/// it would more effficient to use a specialized method instead: [`Encoder::encode_to_buf`].InvalidMagic/// Leading 4 magic bytes don't match when decodingInvalidChannels/// Invalid number of channels: expected 3 or 4InvalidColorSpace/// Invalid color space: expected 0 or 1InvalidImageDimensions/// Invalid image dimensions: can't be empty or larger than 400MpInvalidImageLength/// Image dimensions are inconsistent with image buffer lengthOutputBufferTooSmall/// Output buffer is too small to fit encoded/decoded imageUnexpectedBufferEnd/// Input buffer ended unexpectedly before decoding was finished/// Invalid stream end marker encountered when decoding/// Generic I/O error from the wrapped reader/writer/// Errors that can occur during encoding or decoding./// Alias for [`Result`](std::result::Result) with the error type of [`Error`]./// Image width in pixels/// Image height in pixels/// Number of 8-bit channels per pixel/// Color space (informative field, doesn't affect encoding)/// Image header: dimensions, channels, color space./// ### Notes/// A valid image header must satisfy the following conditions:/// * Both width and height must be non-zero./// * Maximum number of pixels is 400Mp (=4e8 pixels)./// Creates a new header and validates image dimensions./// Creates a new header with modified channels./// Creates a new header with modified color space./// Serializes the header into a bytes array./// Deserializes the header from a byte array.n_pixels/// Returns a number of pixels in the image.n_bytes/// Returns the total number of bytes in the raw pixel array./// This may come useful when pre-allocating a buffer to decode the image into.//! Fast encoder/decoder for [QOI image format](https://qoiformat.org/), implemented in pure and safe Rust.//! - One of the [fastest](#benchmarks) QOI encoders/decoders out there.//! - Compliant with the [latest](https://qoiformat.org/qoi-specification.pdf) QOI format specification.//! - Zero unsafe code.//! - Supports decoding from / encoding to `std::io` streams directly.//! - `no_std` support.//! - Roundtrip-tested vs the reference C implementation; fuzz-tested.//! use qoi::{encode_to_vec, decode_to_vec};//! let encoded = encode_to_vec(&pixels, width, height)?;//! let (header, decoded) = decode_to_vec(&encoded)?;//! assert_eq!(header.width, width);//! assert_eq!(header.height, height);//! assert_eq!(decoded, pixels);//! ### Benchmarks//!              decode:Mp/s  encode:Mp/s  decode:MB/s  encode:MB/s//! qoi.h              282.9        225.3        978.3        778.9//! qoi-rust           427.4        290.0       1477.7       1002.9//! - Reference C implementation://!   [phoboslab/qoi@00e34217](https://github.com/phoboslab/qoi/commit/00e34217).//! - Benchmark timings were collected on an Apple M1 laptop.//! - 2846 images from the suite provided upstream//!   ([tarball](https://phoboslab.org/files/qoibench/qoi_benchmark_suite.tar))://!   all pngs except two with broken checksums.//! - 1.32 GPixels in total with 4.46 GB of raw pixel data.//! Benchmarks have also been run for all of the other Rust implementations//! of QOI for comparison purposes and, at the time of writing this document,//! this library proved to be the fastest one by a noticeable margin.//! ### Rust version//! The minimum supported Rust version is 1.51.0 (any changes to this would be//! considered to be a breaking change).//! ### `no_std`//! This crate supports `no_std` mode. By default, std is enabled via the `std`//! feature. You can deactivate the `default-features` to target core instead.//! In that case anything related to `std::io`, `std::error::Error` and heap//! allocations is disabled. There is an additional `alloc` feature that can//! be activated to bring back the support for heap allocations.update_rgbupdate_rgbaupdate_diffupdate_lumaas_rgbawith_aa_orhash_index/// sRGB with linear alpha/// All channels are linear/// Image color space./// Note: the color space is purely informative. Although it is saved to the/// file header, it does not affect encoding/decoding in any way.is_srgb/// Returns true if the color space is sRGB with linear alpha.is_linear/// Returns true is all channels are linear./// Converts to an integer (0 if sRGB, 1 if all linear)./// Three 8-bit channels (RGB)/// Four 8-bit channels (RGBA)/// Number of 8-bit channels in a pixel./// Returns true if there are 3 channels (RGB).is_rgba/// Returns true if there are 4 channels (RGBA)./// Converts to an integer (3 if RGB, 4 if RGBA).write_manyn_writtenqr_code_errorQrCodeEccQrSegmentgenerate_qrcodeQRCodeErrorgenerate_qrcode_from_strgenerate_qrcode_from_segmentsto_matrix_innerto_svg_innerto_svg_to_vec_innerto_svg_to_string_innerto_svg_to_file_innerto_image_innerto_png_innerto_png_to_vec_innerto_png_to_file_innerto_image_buffer_innerto_matrix/// Encode data to a QR code matrix.to_matrix_from_str/// Encode text to a QR code matrix.to_matrix_from_segments/// Encode segments to a QR code matrix./// Encode data to raw image in memory.to_image_from_str/// Encode text to raw image in memory.to_image_from_segments/// Encode segments to raw image in memory.DESCto_svg_to_string/// Encode data to a SVG image in memory.to_svg_to_string_from_str/// Encode text to a SVG image in memory.to_svg_to_string_from_segments/// Encode segments to a SVG image in memory.to_svg_to_file/// Encode data to a SVG image via a file path.to_svg_to_file_from_str/// Encode text to a SVG image via a file path.to_svg_to_file_from_segments/// Encode segments to a SVG image via a file path.to_svg_to_writer/// Encode data to a SVG image via a writer.to_svg_to_writer_from_str/// Encode text to a SVG image via a writer.to_svg_to_writer_from_segments/// Encode segments to a SVG image via a writer.to_png_to_vec/// Encode data to a PNG image in memory.to_png_to_vec_from_str/// Encode text to a PNG image in memory.to_png_to_vec_from_segments/// Encode segments to a PNG image in memory.to_png_to_file/// Encode data to a PNG image via a file path.to_png_to_file_from_str/// Encode text to a PNG image via a file path.to_png_to_file_from_segmentsto_png_to_writer/// Encode data to a PNG image via a writer.to_png_to_writer_from_str/// Encode text to a PNG image via a writer.to_png_to_writer_from_segments/// Encode segments to a PNG image via a writer.to_image_buffer/// Encode data to a image buffer.to_image_buffer_from_str/// Encode text to a image buffer.to_image_buffer_from_segments/// Encode segments to a image buffer./*!
# QR Code Generator

This crate provides functions to generate QR Code matrices and images in RAW, PNG and SVG formats.

## Examples

#### Encode any data to a QR Code matrix which is `Vec<Vec<bool>>`.

```rust
use qrcode_generator::QrCodeEcc;

let result: Vec<Vec<bool>> = qrcode_generator::to_matrix("Hello world!", QrCodeEcc::Low).unwrap();

println!("{:?}", result);
```

#### Encode any data to a PNG image stored in a Vec instance.

```rust
use qrcode_generator::QrCodeEcc;

# #[cfg(feature = "image")] {
let result: Vec<u8> = qrcode_generator::to_png_to_vec("Hello world!", QrCodeEcc::Low, 1024).unwrap();

println!("{:?}", result);
# }
```

#### Encode any data to a PNG image stored in a file.

```rust
use qrcode_generator::QrCodeEcc;

# #[cfg(feature = "image")] {
qrcode_generator::to_png_to_file("Hello world!", QrCodeEcc::Low, 1024, "tests/data/file_output.png").unwrap();
# }
```

#### Encode any data to a SVG image stored in a String instance.

```rust
use qrcode_generator::QrCodeEcc;

let result: String = qrcode_generator::to_svg_to_string("Hello world!", QrCodeEcc::Low, 1024, None::<&str>).unwrap();

println!("{:?}", result);
```

#### Encode any data to a SVG image stored in a file.

```rust
use qrcode_generator::QrCodeEcc;

qrcode_generator::to_svg_to_file("Hello world!", QrCodeEcc::Low, 1024, None::<&str>, "tests/data/file_output.png").unwrap();
```

## Low-level Usage

### Raw Image Data

The `to_image` and `to_image_buffer` functions can be used, if you want to modify your image.

### Segments

Every `to_*` function has a corresponding `_from_segments` function. You can concatenate segments by using different encoding methods, such as **numeric**, **alphanumeric** or **binary** to reduce the size (level) of your QR code matrix/image.

```rust
use qrcode_generator::{QrCodeEcc, QrSegment};

let first = "1234567";

let second = "ABCDEFG";

let segments = [QrSegment::make_numeric(&first), QrSegment::make_alphanumeric(&second)];

let result: Vec<Vec<bool>> = qrcode_generator::to_matrix_from_segments(&segments, QrCodeEcc::Low).unwrap();

println!("{:?}", result);
```

More segments optimization apporaches: [magiclen/qrcode-segments-optimizer](https://github.com/magiclen/qrcode-segments-optimizer)
*/// TODO public functionsDataTooLongImageSizeTooSmallImageSizeTooLarge/// Errors when encoding QR code.// Scalar parameters:// The version number of this QR Code, which is between 1 and 40 (inclusive).// This determines the size of this barcode.// The width and height of this QR Code, measured in modules, between// 21 and 177 (inclusive). This is equal to version * 4 + 17.errorcorrectionlevel// The error correction level used in this QR Code.// The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).// Even if a QR Code is created with automatic masking requested (mask = None),// the resulting object still has a mask value between 0 and 7.// Grids of modules/pixels, with dimensions of size*size:// The modules of this QR Code (false = light, true = dark).// Immutable after constructor finishes. Accessed through get_module().isfunction// Indicates function modules that are not subjected to masking. Discarded when constructor finishes./// A QR Code symbol, which is a type of two-dimension barcode./// Invented by Denso Wave and described in the ISO/IEC 18004 standard./// Instances of this struct represent an immutable square grid of dark and light cells./// The impl provides static factory functions to create a QR Code from text or binary data./// The struct and impl cover the QR Code Model 2 specification, supporting all versions/// (sizes) from 1 to 40, all 4 error correction levels, and 4 character encoding modes./// Ways to create a QR Code object:/// - High level: Take the payload data and call `QrCode::encode_text()` or `QrCode::encode_binary()`./// - Mid level: Custom-make the list of segments and call///   `QrCode::encode_segments()` or `QrCode::encode_segments_advanced()`./// - Low level: Custom-make the array of data codeword bytes (including segment///   headers and final padding, excluding error correction codewords), supply the///   appropriate version number, and call the `QrCode::encode_codewords()` constructor./// (Note that all ways require supplying the desired error correction level.)/*---- Static factory functions (high level) ----*//// Returns a QR Code representing the given Unicode text string at the given error correction level./// As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer Unicode/// code points (not UTF-8 code units) if the low error correction level is used. The smallest possible/// QR Code version is automatically chosen for the output. The ECC level of the result may be higher than/// the ecl argument if it can be done without increasing the version./// Returns a wrapped `QrCode` if successful, or `Err` if the/// data is too long to fit in any version at the given ECC level.encode_binary/// Returns a QR Code representing the given binary data at the given error correction level./// This function always encodes using the binary segment mode, not any text mode. The maximum number of/// bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output./// The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.encode_segments/*---- Static factory functions (mid level) ----*//// Returns a QR Code representing the given segments at the given error correction level./// The smallest possible QR Code version is automatically chosen for the output. The ECC level/// of the result may be higher than the ecl argument if it can be done without increasing the version./// This function allows the user to create a custom sequence of segments that switches/// between modes (such as alphanumeric and byte) to encode text in less space./// This is a mid-level API; the high-level API is `encode_text()` and `encode_binary()`.encode_segments_advanced/// Returns a QR Code representing the given segments with the given encoding parameters./// The smallest possible QR Code version within the given range is automatically/// chosen for the output. Iff boostecl is `true`, then the ECC level of the result/// may be higher than the ecl argument if it can be done without increasing the/// version. The mask number is either between 0 to 7 (inclusive) to force that/// mask, or `None` to automatically choose an appropriate mask (which may be slow)./// Returns a wrapped `QrCode` if successful, or `Err` if the data is too/// long to fit in any version in the given range at the given ECC level.encode_codewords/*---- Constructor (low level) ----*//// Creates a new QR Code with the given version number,/// error correction level, data codeword bytes, and mask number./// This is a low-level API that most users should not use directly./// A mid-level API is the `encode_segments()` function./*---- Public methods ----*//// Returns this QR Code's version, in the range [1, 40]./// Returns this QR Code's size, in the range [21, 177].error_correction_level/// Returns this QR Code's error correction level./// Returns this QR Code's mask, in the range [0, 7].get_module/// Returns the color of the module (pixel) at the given coordinates,/// which is `false` for light or `true` for dark./// The top left corner has the coordinates (x=0, y=0). If the given/// coordinates are out of bounds, then `false` (light) is returned.// Returns the color of the module at the given coordinates, which must be in bounds.module_mut// Returns a mutable reference to the module's color at the given coordinates, which must be in bounds.draw_function_patterns/*---- Private helper methods for constructor: Drawing function modules ----*/// Reads this object's version field, and draws and marks all function modules.draw_format_bits// Draws two copies of the format bits (with its own error correction code)// based on the given mask and this object's error correction level field.draw_version// Draws two copies of the version bits (with its own error correction code),// based on this object's version field, iff 7 <= version <= 40.draw_finder_pattern// Draws a 9*9 finder pattern including the border separator,// with the center module at (x, y). Modules can be out of bounds.draw_alignment_pattern// Draws a 5*5 alignment pattern, with the center module// at (x, y). All modules must be in bounds.set_function_module// Sets the color of a module and marks it as a function module.// Only used by the constructor. Coordinates must be in bounds.add_ecc_and_interleave/*---- Private helper methods for constructor: Codewords and masking ----*/// Returns a new byte string representing the given data with the appropriate error correction// codewords appended to it, based on this object's version and error correction level.draw_codewords// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire// data area of this QR Code. Function modules need to be marked off before this is called.apply_mask// XORs the codeword modules in this QR Code with the given mask pattern.// The function modules must be marked and the codeword bits must be drawn// before masking. Due to the arithmetic of XOR, calling apply_mask() with// the same mask value a second time will undo the mask. A final well-formed// QR Code needs exactly one (not zero, two, etc.) mask applied.get_penalty_score// Calculates and returns the penalty score based on state of this QR Code's current modules.// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.get_alignment_pattern_positions/*---- Private helper functions ----*/// Returns an ascending list of positions of alignment patterns for this version number.// Each position is in the range [0,177), and are used on both the x and y axes.// This could be implemented as lookup table of 40 variable-length lists of unsigned bytes.get_num_raw_data_modules// Returns the number of data bits that can be stored in a QR Code of the given version number, after// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.get_num_data_codewords// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any// QR Code of the given version number and error correction level, with remainder bits discarded.// This stateless pure function could be implemented as a (40*4)-cell lookup table.table_get// Returns an entry from the given table based on the given values.reed_solomon_compute_divisor// Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be// implemented as a lookup table over all possible parameter values, instead of as an algorithm.reed_solomon_compute_remainder// Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.reed_solomon_multiply// Returns the product of the two given field elements modulo GF(2^8/0x11D).// All inputs are valid. This could be implemented as a 256*256 lookup table.qr_sizerun_historyFinderPenaltyadd_history// Pushes the given value to the front and drops the last value.count_patterns// Can only be called immediately after a light run is added, and returns either 0, 1, or 2.terminate_and_count// Must be called at the end of a line (row or column) of modules.PENALTY_N1// For use in get_penalty_score(), when evaluating which mask is best.PENALTY_N2PENALTY_N3PENALTY_N4ECC_CODEWORDS_PER_BLOCKNUM_ERROR_CORRECTION_BLOCKS/// The QR Code can tolerate about  7% erroneous codewords./// The QR Code can tolerate about 15% erroneous codewords.Quartile/// The QR Code can tolerate about 25% erroneous codewords./// The QR Code can tolerate about 30% erroneous codewords./// The error correction level in a QR Code symbol.// Returns an unsigned 2-bit integer (in the range 0 to 3).format_bitsQrSegmentMode// The mode indicator of this segment. Accessed through mode().numchars// The length of this segment's unencoded data. Measured in characters for// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.// Not the same as the data's bit length. Accessed through num_chars().// The data bits of this segment. Accessed through data()./// A segment of character/binary/control data in a QR Code symbol./// Instances of this struct are immutable./// The mid-level way to create a segment is to take the payload data/// and call a static factory function such as `QrSegment::make_numeric()`./// The low-level way to create a segment is to custom-make the bit buffer/// and call the `QrSegment::new()` constructor with appropriate values./// This segment struct imposes no length restrictions, but QR Codes have restrictions./// Even in the most favorable conditions, a QR Code can only hold 7089 characters of data./// Any segment longer than this is meaningless for the purpose of generating QR Codes.make_bytes/// Returns a segment representing the given binary data encoded in byte mode./// All input byte slices are acceptable./// Any text string can be converted to UTF-8 bytes and encoded as a byte mode segment.make_numeric/// Returns a segment representing the given string of decimal digits encoded in numeric mode./// Panics if the string contains non-digit characters.make_alphanumeric/// Returns a segment representing the given text string encoded in alphanumeric mode./// The characters allowed are: 0 to 9, A to Z (uppercase only), space,/// dollar, percent, asterisk, plus, hyphen, period, slash, colon./// Panics if the string contains non-encodable characters.make_segments/// Returns a list of zero or more segments to represent the given Unicode text string./// The result may use various segment modes and switch/// modes to optimize the length of the bit stream.make_eci/// Returns a segment representing an Extended Channel Interpretation/// (ECI) designator with the given assignment value./// Creates a new QR Code segment with the given attributes and data./// The character count (numchars) must agree with the mode and/// the bit buffer length, but the constraint isn't checked./*---- Instance field getters ----*//// Returns the mode indicator of this segment./// Returns the character count field of this segment./// Returns the data bits of this segment.get_total_bits/*---- Other static functions ----*/// Calculates and returns the number of bits needed to encode the given// segments at the given version. The result is None if a segment has too many// characters to fit its length field, or the total bits exceeds usize::MAX./// Tests whether the given string can be encoded as a segment in numeric mode./// A string is encodable iff each character is in the range 0 to 9./// Tests whether the given string can be encoded as a segment in alphanumeric mode./// A string is encodable iff each character is in the following set: 0 to 9, A to Z/// (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.ALPHANUMERIC_CHARSET// The set of all legal characters in alphanumeric mode,// where each character value maps to the index in the string.Eci/// Describes how a segment's data bits are interpreted.mode_bits// Returns an unsigned 4-bit integer value (range 0 to 15)// representing the mode indicator bits for this mode object.num_char_count_bits// Returns the bit width of the character count field for a segment in this mode// in a QR Code at the given version number. The result is in the range [0, 16]./// An appendable sequence of bits (0s and 1s)./// Mainly used by QrSegment.append_bits/// Appends the given number of low-order bits of the given value to this buffer./// Requires len &#x2264; 31 and val &lt; 2<sup>len</sup>.SegmentTooLongDataOverCapacity/// The error type when the supplied data does not fit any QR Code version./// Ways to handle this exception include:/// - Decrease the error correction level if it was greater than `QrCodeEcc::Low`./// - If the `encode_segments_advanced()` function was called, then increase the maxversion///   argument if it was less than `Version::MAX`. (This advice does not apply to the///   other factory functions because they search all versions up to `Version::MAX`.)/// - Split the text data into better or optimal segments in order to reduce the number of bits required./// - Change the text or binary data to be shorter./// - Change the text to fit the character set of a particular segment mode (e.g. alphanumeric)./// - Propagate the error upward to the caller/user./// A number between 1 and 40 (inclusive)./// The minimum version number supported in the QR Code Model 2 standard./// The maximum version number supported in the QR Code Model 2 standard./// Creates a version object from the given number./// Panics if the number is outside the range [1, 40]./// Returns the value, which is in the range [1, 40]./// A number between 0 and 7 (inclusive)./// Creates a mask object from the given number./// Panics if the number is outside the range [0, 7]./// Returns the value, which is in the range [0, 7].// Returns true iff the i'th bit of x is set to 1./* 
 * QR Code generator library (Rust)
 * 
 * Copyright (c) Project Nayuki. (MIT License)
 * https://www.nayuki.io/page/qr-code-generator-library
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 * - The above copyright notice and this permission notice shall be included in
 *   all copies or substantial portions of the Software.
 * - The Software is provided "as is", without warranty of any kind, express or
 *   implied, including but not limited to the warranties of merchantability,
 *   fitness for a particular purpose and noninfringement. In no event shall the
 *   authors or copyright holders be liable for any claim, damages or other
 *   liability, whether in an action of contract, tort or otherwise, arising from,
 *   out of or in connection with the Software or the use or other dealings in the
 *   Software.
 *///! Generates QR Codes from text strings and byte arrays.//! This project aims to be the best, clearest QR Code generator library.//! The primary goals are flexible options and absolute correctness.//! Secondary goals are compact implementation size and good documentation comments.//! Home page with live JavaScript demo, extensive descriptions, and competitor comparisons://! [https://www.nayuki.io/page/qr-code-generator-library](https://www.nayuki.io/page/qr-code-generator-library)//! Core features://! - Significantly shorter code but more documentation comments compared to competing libraries//! - Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard//! - Output format: Raw modules/pixels of the QR symbol//! - Detects finder-like penalty patterns more accurately than other implementations//! - Encodes numeric and special-alphanumeric text in less space than general text//! - Open-source code under the permissive MIT License//! Manual parameters://! - User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data//! - User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one//! - User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number//! - User can create a list of data segments manually and add ECI segments//! More information about QR Code technology and this library's design can be found on the project home page.//! extern crate qrcodegen;//! use qrcodegen::Mask;//! use qrcodegen::QrCode;//! use qrcodegen::QrCodeEcc;//! use qrcodegen::QrSegment;//! use qrcodegen::Version;//! Simple operation://! let qr = QrCode::encode_text("Hello, world!",//!     QrCodeEcc::Medium).unwrap();//! let svg = to_svg_string(&qr, 4);  // See qrcodegen-demo//! Manual operation://! let text: &str = "3141592653589793238462643383";//! let segs = QrSegment::make_segments(text);//! let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High,//!     Version::new(5), Version::new(5), Some(Mask::new(2)), false).unwrap();//! for y in 0 .. qr.size() {//!     for x in 0 .. qr.size() {//!         (... paint qr.get_module(x, y) ...)/*---- QrCode functionality ----*//*---- Helper struct for get_penalty_score() ----*//*---- Constants and tables ----*//*---- QrCodeEcc functionality ----*//*---- QrSegment functionality ----*//*---- QrSegmentMode functionality ----*//*---- Bit buffer functionality ----*//*---- Miscellaneous values ----*/Interactiveclear_rightconsoleapiGetConsoleModeSetConsoleModeold_modeinteractiveESC/// The ASCII escape character.ask/// Print a question, in bold, without creating a new line./// Print a message of success, with a newline./// Print an error message, with a newline./// Ask for a password (the password will not be visible)./// Ask for a line of text.yesno/// Ask a yes-or-no question./// `None` indicates an invalid response.editor/// Ask the user to enter some text through their editor./// We'll check the `VISUAL` environment variable, then `EDITOR`, and then/// finally default to `vi`. The message will be the initial contents of the/// file, and the result will be the final contents of the file, after the user/// has quit their editor./// On Windows, the editor defaults to `notepad`./// The text to use when an item is selected./// The text to use when an item is not selected.Boxes/// The text to use when indicating whether an item is selected.choose/// Ask the user to choose exactly one option from a list.//! Command-line input utilities.or2rosimple_typeUnitOnlyQNameCowRefdecode_name/// Decodes raw bytes using the deserializer encoding.
/// The method will borrow if encoding is UTF-8 compatible and `name` contains
/// only UTF-8 compatible characters (usually only ASCII characters).
QNameDeserializer/// A deserializer for xml names of elements and attributes.
/// Used for deserializing values from:
/// - attribute names (`<... name="..." ...>`)
/// - element names (`<name>...</name>`)
/// Converts a name to an identifier string using the following rules:
/// - if it is an [`attribute`] name, put `@` in front of the identifier
/// - if it is a namespace binding (`xmlns` or `xmlns:xxx`) put the decoded name
///   to the identifier
/// - put the decoded [`local_name()`] of a name to the identifier
/// The final identifier looks like `[@]local_name`, or `@xmlns`, or `@xmlns:binding`
/// (where `[]` means optional element).
/// The deserializer also supports deserializing names as other primitive types:
/// - numbers
/// - booleans
/// - unit (`()`) and unit structs
/// - unit variants of the enumerations
/// Because `serde` does not define on which side type conversion should be
/// performed, and because [`Deserialize`] implementation for that primitives
/// in serde does not accept strings, the deserializer will perform conversion
/// by itself.
/// The deserializer is able to deserialize unit and unit structs, but any name
/// will be converted to the same unit instance. This is asymmetry with a serializer,
/// which not able to serialize those types, because empty names are impossible
/// in XML.
/// `deserialize_any()` returns the same result as `deserialize_identifier()`.
/// # Lifetimes
/// - `'i`: lifetime of the data that the deserializer borrows from the parsed input
/// - `'d`: lifetime of a deserializer that holds a buffer with content of events
/// [`attribute`]: Self::from_attr
/// [`local_name()`]: QName::local_name
/// [`Deserialize`]: serde::Deserialize
from_attr/// Creates deserializer from name of an attribute
from_elem/// Creates deserializer from name of an element
/// According to the <https://www.w3.org/TR/xmlschema11-2/#boolean>,
/// valid boolean representations are only `"true"`, `"false"`, `"1"`,
/// and `"0"`.
/// Calls [`Visitor::visit_unit`]
/// Forwards deserialization to the [`Self::deserialize_unit`]
/// Forwards deserialization to the [`Self::deserialize_identifier`]
/// If `name` is an empty string then calls [`Visitor::visit_none`],
/// otherwise calls [`Visitor::visit_some`] with itself
/// Calls a [`Visitor::visit_str`] if [`name`] contains only UTF-8
/// compatible encoded characters and represents an element name and
/// a [`Visitor::visit_string`] in all other cases.
/// [`name`]: Self::name
seQNameSerializerIgnoredAnydeserialized_to_only/// Checks that given `$input` successfully deserializing into given `$result`
deserialized_to/// Checks that attempt to deserialize given `$input` as a `$type` results to a
/// deserialization error `$kind` with `$reason`
// Unit structs cannot be represented in some meaningful way, but it meaningful
// to use them as a placeholder when we want to deserialize _something_
// Field identifiers cannot be serialized, and IgnoredAny represented _something_
// which is not concrete
////////////////////////////////////////////////////////////////////////////////////////////////////
EntityResolverSimpleTypeDeserializerTextDeserializerDeEventXmlReadTEXT_KEYVALUE_KEYBytesStartBorrowedStrDeserializer/// Source are not specified, because [`next_key_seed()`] not yet called.
/// This is an initial state and state after deserializing value
/// (after call of [`next_value_seed()`]).
/// Attempt to call [`next_value_seed()`] while accessor in this state would
/// return a [`DeError::KeyNotRead`] error.
/// [`next_key_seed()`]: MapAccess::next_key_seed
/// [`next_value_seed()`]: MapAccess::next_value_seed
/// Next value should be deserialized from an attribute value; value is located
/// at specified span.
/// Value should be deserialized from the text content of the XML node, which
/// represented or by an ordinary text node, or by a CDATA node:
/// ```xml
/// <any-tag>
///     <key>text content</key>
/// <!--     ^^^^^^^^^^^^ - this will be used to deserialize map value -->
/// </any-tag>
///     <key><![CDATA[cdata content]]></key>
/// <!--              ^^^^^^^^^^^^^ - this will be used to deserialize a map value -->
/// Next value should be deserialized from an element with an any name, except
/// elements with a name matching one of the struct fields. Corresponding tag
/// name will always be associated with a field with name [`VALUE_KEY`].
/// That state is set when call to [`peek()`] returns a [`Start`] event, which
/// [`name()`] is not listed in the [list of known fields] (which for a struct
/// is a list of field names, and for a map that is an empty list), _and_
/// struct has a field with a special name [`VALUE_KEY`].
/// When in this state, next event, returned by [`next()`], will be a [`Start`],
/// which represents both a key, and a value. Value would be deserialized from
/// the whole element and how is will be done determined by the value deserializer.
/// The [`ElementMapAccess`] do not consume any events in that state.
/// Because in that state any encountered `<tag>` is mapped to the [`VALUE_KEY`]
/// field, it is possible to use tag name as an enum discriminator, so `enum`s
/// can be deserialized from that XMLs:
///     <variant1>...</variant1>
/// <!-- ~~~~~~~~               - this data will determine that this is Enum::variant1 -->
/// <!--^^^^^^^^^^^^^^^^^^^^^^^ - this data will be used to deserialize a map value -->
///     <variant2>...</variant2>
/// <!-- ~~~~~~~~               - this data will determine that this is Enum::variant2 -->
/// both can be deserialized into
/// enum Enum {
///   variant1,
///   variant2,
/// struct AnyName {
///   #[serde(rename = "$value")]
///   field: Enum,
/// That is possible, because value deserializer have access to the full content
/// of a `<variant1>...</variant1>` or `<variant2>...</variant2>` node, including
/// the tag name.
/// [`Start`]: DeEvent::Start
/// [`peek()`]: Deserializer::peek()
/// [`next()`]: Deserializer::next()
/// [`name()`]: BytesStart::name()
/// [`Text`]: Self::Text
/// [list of known fields]: ElementMapAccess::fields
Nested/// Next value should be deserialized from an element with a dedicated name.
/// If deserialized type is a sequence, then that sequence will collect all
/// elements with the same name until it will be filled. If not all elements
/// would be consumed, the rest will be ignored.
/// [`name()`] represents a field name. That name will be deserialized as a key.
/// An illustration below shows, what data is used to deserialize key and value:
///     <key>...</key>
/// <!-- ~~~           - this data will be used to deserialize a map key -->
/// <!--^^^^^^^^^^^^^^ - this data will be used to deserialize a map value -->
/// Although value deserializer will have access to the full content of a `<key>`
/// node (including the tag name), it will not get much benefits from that,
/// because tag name will always be fixed for a given map field (equal to a
/// field name). So, if the field type is an `enum`, it cannot select its
/// variant based on the tag name. If that is needed, then [`Content`] variant
/// of this enum should be used. Such usage is enabled by annotating a struct
/// field as "content" field, which implemented as given the field a special
/// [`VALUE_KEY`] name.
/// [`Content`]: Self::Content
/// Defines a source that should be used to deserialize a value in the next call
/// to [`next_value_seed()`](MapAccess::next_value_seed)
/// Tag -- owner of attributes
/// State of the iterator over attributes. Contains the next position in the
/// inner `start` slice, from which next attribute should be parsed.
/// Current state of the accessor that determines what next call to API
/// methods should return.
/// List of field names of the struct. It is empty for maps
has_value_field/// If `true`, then the deserialized struct has a field with a special name:
/// [`VALUE_KEY`]. That field should be deserialized from the whole content
/// of an XML node, including tag name:
/// <tag>value for VALUE_KEY field<tag>
ElementMapAccess/// A deserializer that extracts map-like structures from an XML. This deserializer
/// represents a one XML tag:
/// <tag>...</tag>
/// Name of this tag is stored in a [`Self::start`] property.
/// - `'de` lifetime represents a buffer, from which deserialized values can
///   borrow their data. Depending on the underlying reader, there can be an
///   internal buffer of deserializer (i.e. deserializer itself) or an input
///   (in that case it is possible to approach zero-copy deserialization).
/// - `'d` lifetime represents a parent deserializer, which could own the data
///   buffer.
/// Create a new ElementMapAccess
should_skip_subtree/// Determines if subtree started with the specified event shoould be skipped.
/// Used to map elements with `xsi:nil` attribute set to true to `None` in optional contexts.
/// We need to handle two attributes:
/// - on parent element: <map xsi:nil="true"><foo/></map>
/// - on this element:   <map><foo xsi:nil="true"/></map>
/// We check parent element too because `xsi:nil` affects only nested elements of the
/// tag where it is defined. We can map structure with fields mapped to attributes to
/// the `<map>` element and set to `None` all its optional elements.
/// Access to the map that created this deserializer. Gives access to the
/// context, such as list of fields, that current map known about.
fixed_name/// Whether this deserializer was created for deserialization from an element
/// with fixed name, or the elements with different names or even text are allowed.
/// If this field is `true`, we process `<tag>` element in the following XML shape:
///   <tag>...</tag>
/// The whole map represented by an `<any-tag>` element, the map key is a `tag`,
/// and the value starts with is a `Start("tag")` (the value deserializer will
/// see that event first) and extended to the matching `End("tag")` event.
/// In order to deserialize primitives (such as `usize`) we need to allow to
/// look inside the one levels of tags, so the
/// <tag>42<tag>
/// could be deserialized into `42usize` without problems, and at the same time
/// <tag>
///   <key1/>
///   <key2/>
///   <!--...-->
/// could be deserialized to a struct.
/// If this field is `false`, we processes the one of following XML shapes:
///   text value
///   <![CDATA[cdata value]]>
///   <any>...</any>
/// The whole map represented by an `<any-tag>` element, the map key is
/// implicit and equals to the [`VALUE_KEY`] constant, and the value is
/// a [`Text`], or a [`Start`] event (the value deserializer will see one of
/// those events). In the first two cases the value of this field do not matter
/// (because we already see the textual event and there no reasons to look
/// "inside" something), but in the last case the primitives should raise
/// a deserialization error, because that means that you trying to deserialize
/// the following struct:
///   any_name: String,
/// which means that `any_name` should get a content of the `<any-tag>` element.
/// Changing this can be valuable for <https://github.com/tafia/quick-xml/issues/383>,
/// but those fields should be explicitly marked that they want to get any
/// possible markup as a `String` and that mark is different from marking them
/// as accepting "text content" which the currently `$text` means.
/// [`Text`]: DeEvent::Text
MapValueDeserializer/// A deserializer for a value of map or struct. That deserializer slightly
/// differently processes events for a primitive types and sequences than
/// a [`Deserializer`].
/// This deserializer used to deserialize two kinds of fields:
/// - usual fields with a dedicated name, such as `field_one` or `field_two`, in
///   that case field [`Self::fixed_name`] is `true`;
/// - the special `$value` field which represents any tag or a textual content
///   in the XML which would be found in the document, in that case field
///   [`Self::fixed_name`] is `false`.
/// This deserializer can see two kind of events at the start:
/// - [`DeEvent::Text`]
/// - [`DeEvent::Start`]
/// which represents two possible variants of items:
/// <item>A tag item</item>
/// A text item
/// <yet another="tag item"/>
/// This deserializer are very similar to a [`ElementDeserializer`]. The only difference
/// in the `deserialize_seq` method. This deserializer will act as an iterator
/// over tags / text within it's parent tag, whereas the [`ElementDeserializer`]
/// will represent sequences as an `xs:list`.
/// This deserializer processes items as following:
/// - primitives (numbers, booleans, strings, characters) are deserialized either
///   from a text content, or unwrapped from a one level of a tag. So, `123` and
///   `<int>123</int>` both can be deserialized into an `u32`;
/// - `Option`:
///   - empty text of [`DeEvent::Text`] is deserialized as `None`;
///   - everything else are deserialized as `Some` using the same deserializer,
///     including `<tag/>` or `<tag></tag>`;
/// - units (`()`) and unit structs consumes the whole text or element subtree;
/// - newtype structs are deserialized by forwarding deserialization of inner type
///   with the same deserializer;
/// - sequences, tuples and tuple structs are deserialized by iterating within the
///   parent tag and deserializing each tag or text content using [`ElementDeserializer`];
/// - structs and maps are deserialized using new instance of [`ElementMapAccess`];
/// - enums:
///   - in case of [`DeEvent::Text`] event the text content is deserialized as
///     a `$text` variant. Enum content is deserialized from the text using
///     [`SimpleTypeDeserializer`];
///   - in case of [`DeEvent::Start`] event the tag name is deserialized as
///     an enum tag, and the content inside are deserialized as an enum content.
///     Depending on a variant kind deserialization is performed as:
///     - unit variants: consuming text content or a subtree;
///     - newtype variants: forward deserialization to the inner type using
///       this deserializer;
///     - tuple variants: call [`deserialize_tuple`] of this deserializer;
///     - struct variants: call [`deserialize_struct`] of this deserializer.
/// [`deserialize_tuple`]: #method.deserialize_tuple
/// [`deserialize_struct`]: #method.deserialize_struct
/// Returns a next string as concatenated content of consequent [`Text`] and
/// [`CData`] events, used inside [`deserialize_primitives!()`].
/// [`Text`]: crate::events::Event::Text
/// [`CData`]: crate::events::Event::CData
deserialize_primitives/// Forwards deserialization of the inner type. Always calls [`Visitor::visit_newtype_struct`]
/// with the same deserializer.
/// Deserializes each `<tag>` in
/// as a sequence item, where `<any-tag>` represents a Map in a [`Self::map`],
/// and a `<tag>` is a sequential field of that map.
MapValueVariantAccess/// Access to the map that created this enum accessor. Gives access to the
is_text/// `true` if variant should be deserialized from a textual content
/// and `false` if from tag
not_in/// Check if tag `start` is included in the `fields` list. `decoder` is used to
/// get a string representation of a tag.
/// Returns `true`, if `start` is not in the `fields` list and `false` otherwise.
TagFilter/// A `SeqAccess` interested only in tags with specified name to deserialize
/// an XML like this:
/// <...>
///   <tag/>
///   ...
/// </...>
/// The tag name is stored inside (`b"tag"` for that example)
Exclude//TODO: Need to store only name instead of a whole tag
/// A `SeqAccess` interested in tags with any name, except explicitly listed.
/// Excluded tags are used as struct field names and therefore should not
/// fall into a `$value` category
/// A filter that determines, what tags should form a sequence.
/// There are two types of sequences:
/// - sequence where each element represented by tags with the same name
/// - sequence where each element can have a different tag
/// The first variant could represent a collection of structs, the second --
/// a collection of enum variants.
/// In the second case we don't know what tag name should be expected as a
/// sequence element, so we accept any element. Since the sequence are flattened
/// into maps, we skip elements which have dedicated fields in a struct by using an
/// `Exclude` filter that filters out elements with names matching field names
/// from the struct.
/// `'de` represents a lifetime of the XML input, when filter stores the
/// dedicated tag name
is_suitable/// Accessor to a map that creates this accessor and to a deserializer for
/// a sequence items.
/// Filter that determines whether a tag is a part of this sequence.
/// When feature [`overlapped-lists`] is not activated, iteration will stop
/// when found a tag that does not pass this filter.
/// When feature [`overlapped-lists`] is activated, all tags, that not pass
/// this check, will be skipped.
/// [`overlapped-lists`]: ../../index.html#overlapped-lists
checkpoint/// Checkpoint after which all skipped events should be returned. All events,
/// that was skipped before creating this checkpoint, will still stay buffered
/// and will not be returned
MapValueSeqAccess/// An accessor to sequence elements forming a value for struct field.
/// Technically, this sequence is flattened out into structure and sequence
/// elements are overlapped with other fields of a structure. Each call to
/// [`Self::next_element_seed`] consumes a next sub-tree or consequent list
/// of [`Text`] and [`CData`] events.
/// <>
///   <item>The is the one item</item>
///   This is <![CDATA[one another]]> item<!-- even when--> it splitted by comments
///   <tag>...and that is the third!</tag>
/// </>
/// Depending on [`Self::filter`], only some of that possible constructs would be
/// an element.
ElementDeserializer/// A deserializer for a single tag item of a mixed sequence of tags and text.
/// This deserializer are very similar to a [`MapValueDeserializer`] (when it
/// processes the [`DeEvent::Start`] event). The only difference in the
/// [`deserialize_seq`] method. This deserializer will perform deserialization
/// from the textual content between start and end events, whereas the
/// [`MapValueDeserializer`] will iterate over tags / text within it's parent tag.
/// - numbers are parsed from a text content between tags using [`FromStr`]. So,
///   `<int>123</int>` can be deserialized into an `u32`;
/// - booleans converted from a text content between tags according to the XML
///   [specification]:
///   - `"true"` and `"1"` converted to `true`;
///   - `"false"` and `"0"` converted to `false`;
/// - strings returned as a text content between tags;
/// - characters also returned as strings. If string contain more than one character
///   or empty, it is responsibility of a type to return an error;
/// - `Option` are always deserialized as `Some` using the same deserializer,
///   including `<tag/>` or `<tag></tag>`;
/// - units (`()`) and unit structs consumes the whole element subtree;
/// - newtype structs forwards deserialization to the inner type using
///   [`SimpleTypeDeserializer`];
/// - sequences, tuples and tuple structs are deserialized using [`SimpleTypeDeserializer`]
///   (this is the difference): text content between tags is passed to
///   - the variant name is deserialized using [`QNameDeserializer`] from the element name;
///   - the content is deserialized using the same deserializer:
///     - unit variants: consuming a subtree and return `()`;
///     - newtype variants forwards deserialization to the inner type using
/// [`deserialize_seq`]: #method.deserialize_seq
/// [`FromStr`]: std::str::FromStr
/// [specification]: https://www.w3.org/TR/xmlschema11-2/#boolean
/// with this deserializer.
/// This method deserializes a sequence inside of element that itself is a
/// sequence element:
///   <self>inner sequence</self>
test_not_in//! Serde `Deserializer` module
// Macros should be defined before the modules that using them
// Also, macros should be imported before using them
/// Implement deserialization methods for scalar types, such as numbers, strings,
/// byte arrays, booleans and identifiers.
PredefinedEntityResolverBytesCDataBytesEndBytesTextNsReader/// Data represented by a text node or a CDATA node. XML markup is not expected
/// Data represented by any XML markup inside
/// Decoded and concatenated content of consequent [`Text`] and [`CData`]
/// events. _Consequent_ means that events should follow each other or be
/// delimited only by (any count of) [`Comment`] or [`PI`] events.
/// Internally text is stored in `Cow<str>`. Cloning of text is cheap while it
/// is borrowed and makes copies of data when it is owned.
/// [`Text`]: Event::Text
/// [`CData`]: Event::CData
/// [`Comment`]: Event::Comment
/// [`PI`]: Event::PI
/// Start tag (with attributes) `<tag attr="value">`.
/// End tag `</tag>`.
/// End of XML document.
/// Simplified event which contains only these variants that used by deserializer
PayloadEvent/// Escaped character data between tags.
CData/// Unescaped character data stored in `<![CDATA[...]]>`.
DocType/// Document type definition data (DTD) stored in `<!DOCTYPE ...>`.
/// Simplified event which contains only these variants that used by deserializer,
/// but [`Text`] events not yet fully processed.
/// [`Text`] events should be trimmed if they does not surrounded by the other
/// [`Text`] or [`CData`] events. This event contains intermediate state of [`Text`]
/// event, where they are trimmed from the start, but not from the end. To trim
/// end spaces we should lookahead by one deserializer event (i. e. skip all
/// comments and processing instructions).
/// Ensures that all data is owned to extend the object's lifetime if necessary.
/// A source of low-level XML events
/// Intermediate event, that could be returned by the next call to `next()`.
/// If that is the `Text` event then leading spaces already trimmed, but
/// trailing spaces is not. Before the event will be returned, trimming of
/// the spaces could be necessary
entity_resolver/// Used to resolve unknown entities that would otherwise cause the parser
/// to return an [`EscapeError::UnrecognizedEntity`] error.
/// [`EscapeError::UnrecognizedEntity`]: crate::escape::EscapeError::UnrecognizedEntity
XmlReader/// An intermediate reader that consumes [`PayloadEvent`]s and produces final [`DeEvent`]s.
/// [`PayloadEvent::Text`] events, that followed by any event except
/// [`PayloadEvent::Text`] or [`PayloadEvent::CData`], are trimmed from the end.
/// Returns `true` if all events was consumed
/// Read next event and put it in lookahead, return the current lookahead
current_event_is_last_text/// Returns `true` when next event is not a text event in any form.
drain_text/// Read all consequent [`Text`] and [`CData`] events until non-text event
/// occurs. Content of all events would be appended to `result` and returned
/// as [`DeEvent::Text`].
/// [`Text`]: PayloadEvent::Text
/// [`CData`]: PayloadEvent::CData
/// Return an input-borrowing event.
/// Deserialize an instance of type `T` from a string of XML text.
/// Deserialize from a reader. This method will do internal copies of data
/// read from `reader`. If you want have a `&str` input and want to borrow
/// as much as possible, use [`from_str`].
/// An XML reader that streams events into this deserializer
/// When deserializing sequences sometimes we have to skip unwanted events.
/// That events should be stored and then replayed. This is a replay buffer,
/// that streams events while not empty. When it exhausted, events will
/// requested from [`Self::reader`].
/// When deserializing sequences sometimes we have to skip events, because XML
/// is tolerant to elements order and even if in the XSD order is strictly
/// specified (using `xs:sequence`) most of XML parsers allows order violations.
/// That means, that elements, forming a sequence, could be overlapped with
/// other elements, do not related to that sequence.
/// In order to support this, deserializer will scan events and skip unwanted
/// events, store them here. After call [`Self::start_replay()`] all events
/// moved from this to [`Self::read`].
/// Maximum number of events that can be skipped when processing sequences
/// that occur out-of-order. This field is used to prevent potential
/// denial-of-service (DoS) attacks which could cause infinite memory
/// consumption when parsing a very large amount of XML into a sequence field.
key_buf/// Buffer to store attribute name as a field name exposed to serde consumers
/// A structure that deserializes XML into Rust values.
/// Create an XML deserializer from one of the possible quick_xml input sources.
/// Typically it is more convenient to use one of these methods instead:
///  - [`Deserializer::from_str`]
///  - [`Deserializer::from_reader`]
/// Returns `true` if all events was consumed.
/// Returns the underlying XML reader.
/// # use pretty_assertions::assert_eq;
/// use serde::Deserialize;
/// use quick_xml::de::Deserializer;
/// use quick_xml::NsReader;
/// #[derive(Deserialize)]
/// struct SomeStruct {
///     field1: String,
///     field2: String,
/// // Try to deserialize from broken XML
/// let mut de = Deserializer::from_str(
///     "<SomeStruct><field1><field2></SomeStruct>"
/// //   0                           ^= 28        ^= 41
/// );
/// let err = SomeStruct::deserialize(&mut de);
/// assert!(err.is_err());
/// let reader: &NsReader<_> = de.get_ref().get_ref();
/// assert_eq!(reader.error_position(), 28);
/// assert_eq!(reader.buffer_position(), 41);
event_buffer_size/// Set the maximum number of events that could be skipped during deserialization
/// of sequences.
/// If `<element>` contains more than specified nested elements, `$text` or
/// CDATA nodes, then [`DeError::TooManyEvents`] will be returned during
/// deserialization of sequence field (any type that uses [`deserialize_seq`]
/// for the deserialization, for example, `Vec<T>`).
/// This method can be used to prevent a [DoS] attack and infinite memory
/// consumption when parsing a very large XML to a sequence field.
/// It is strongly recommended to set limit to some value when you parse data
/// from untrusted sources. You should choose a value that your typical XMLs
/// can have _between_ different elements that corresponds to the same sequence.
/// Let's imagine, that we deserialize such structure:
/// struct List {
///   item: Vec<()>,
/// The XML that we try to parse look like this:
/// <any-name>
///   <item/>
///   <!-- Bufferization starts at this point -->
///   <another-item>
///     <some-element>with text</some-element>
///     <yet-another-element/>
///   </another-item>
///   <!-- Buffer will be emptied at this point; 7 events were buffered -->
///   <!-- There is nothing to buffer, because elements follows each other -->
/// </any-name>
/// There, when we deserialize the `item` field, we need to buffer 7 events,
/// before we can deserialize the second `<item/>`:
/// - `<another-item>`
/// - `<some-element>`
/// - `$text(with text)`
/// - `</some-element>`
/// - `<yet-another-element/>` (virtual start event)
/// - `<yet-another-element/>` (virtual end event)
/// - `</another-item>`
/// Note, that `<yet-another-element/>` internally represented as 2 events:
/// one for the start tag and one for the end tag. In the future this can be
/// eliminated, but for now we use [auto-expanding feature] of a reader,
/// because this simplifies deserializer code.
/// [`deserialize_seq`]: serde::Deserializer::deserialize_seq
/// [DoS]: https://en.wikipedia.org/wiki/Denial-of-service_attack
/// [auto-expanding feature]: crate::reader::Config::expand_empty_elements
last_peeked"returned checkpoint should be used in `start_replay`"skip_checkpoint/// Returns the mark after which all events, skipped by [`Self::skip()`] call,
/// should be replayed after calling [`Self::start_replay()`].
/// Extracts XML tree of events from and stores them in the skipped events
/// buffer from which they can be retrieved later. You MUST call
/// [`Self::start_replay()`] after calling this to give access to the skipped
/// events and release internal buffers.
skip_eventstart_replay/// Moves buffered events, skipped after given `checkpoint` from [`Self::write`]
/// skip buffer to [`Self::read`] buffer.
/// After calling this method, [`Self::peek()`] and [`Self::next()`] starts
/// return events that was skipped previously by calling [`Self::skip()`],
/// and only when all that events will be consumed, the deserializer starts
/// to drain events from underlying reader.
/// This method MUST be called if any number of [`Self::skip()`] was called
/// after [`Self::new()`] or `start_replay()` or you'll lost events.
read_string_impl/// Consumes consequent [`Text`] and [`CData`] (both a referred below as a _text_)
/// events, merge them into one string. If there are no such events, returns
/// an empty string.
/// If `allow_start` is `false`, then only text events are consumed, for other
/// events an error is returned (see table below).
/// If `allow_start` is `true`, then two or three events are expected:
/// - [`DeEvent::Start`];
/// - _(optional)_ [`DeEvent::Text`] which content is returned;
/// - [`DeEvent::End`]. If text event was missed, an empty string is returned.
/// Corresponding events are consumed.
/// # Handling events
/// The table below shows how events is handled by this method:
/// |Event             |XML                        |Handling
/// |------------------|---------------------------|----------------------------------------
/// |[`DeEvent::Start`]|`<tag>...</tag>`           |if `allow_start == true`, result determined by the second table, otherwise emits [`UnexpectedStart("tag")`](DeError::UnexpectedStart)
/// |[`DeEvent::End`]  |`</any-tag>`               |This is impossible situation, the method will panic if it happens
/// |[`DeEvent::Text`] |`text content` or `<![CDATA[cdata content]]>` (probably mixed)|Returns event content unchanged
/// |[`DeEvent::Eof`]  |                           |Emits [`UnexpectedEof`](DeError::UnexpectedEof)
/// Second event, consumed if [`DeEvent::Start`] was received and `allow_start == true`:
/// |------------------|---------------------------|----------------------------------------------------------------------------------
/// |[`DeEvent::Start`]|`<any-tag>...</any-tag>`   |Emits [`UnexpectedStart("any-tag")`](DeError::UnexpectedStart)
/// |[`DeEvent::End`]  |`</tag>`                   |Returns an empty slice. The reader guarantee that tag will match the open one
/// |[`DeEvent::Text`] |`text content` or `<![CDATA[cdata content]]>` (probably mixed)|Returns event content unchanged, expects the `</tag>` after that
/// |[`DeEvent::Eof`]  |                           |Emits [`InvalidXml(IllFormed(MissingEndTag))`](DeError::InvalidXml)
read_text/// Consumes one [`DeEvent::Text`] event and ensures that it is followed by the
/// [`DeEvent::End`] event.
/// # Parameters
/// - `name`: name of a tag opened before reading text. The corresponding end tag
///   should present in input just after the text
/// Drops all events until event with [name](BytesEnd::name()) `name` won't be
/// dropped. This method should be called after [`Self::next()`]
skip_next_tree/// Create new deserializer that will borrow data from the specified string.
/// Deserializer created with this method will not resolve custom entities.
from_str_with_resolver/// Create new deserializer that will borrow data from the specified string
/// and use specified entity resolver.
/// Create new deserializer that will copy data from the specified reader
/// into internal buffer.
/// If you already have a string use [`Self::from_str`] instead, because it
/// will borrow instead of copy. If you have `&[u8]` which is known to represent
/// UTF-8, you can decode it first before using [`from_str`].
with_resolver/// into internal buffer and use specified entity resolver.
/// Unit represented in XML as a `xs:element` or text/CDATA content.
/// Any content inside `xs:element` is ignored and skipped.
/// Produces unit struct from any of following inputs:
/// - any `<tag ...>...</tag>`
/// - any `<tag .../>`
/// - any consequent text / CDATA content (can consist of several parts
///   delimited by comments and processing instructions)
/// # Events handling
/// |------------------|---------------------------|-------------------------------------------
/// |[`DeEvent::Start`]|`<tag>...</tag>`           |Calls `visitor.visit_unit()`, consumes all events up to and including corresponding `End` event
/// |[`DeEvent::End`]  |`</tag>`                   |This is impossible situation, the method will panic if it happens
/// |[`DeEvent::Text`] |`text content` or `<![CDATA[cdata content]]>` (probably mixed)|Calls `visitor.visit_unit()`. The content is ignored
/// An accessor to sequence elements forming a value for top-level sequence of XML
/// elements.
/// Technically, multiple top-level elements violates XML rule of only one top-level
/// element, but we consider this as several concatenated XML documents.
trim_start/// If `true`, then leading whitespace will be removed from next returned
/// [`Event::Text`]. This field is set to `true` after reading each event
/// except [`Event::Text`] and [`Event::CData`], so [`Event::Text`] events
/// read right after them does not trimmed.
StartTrimmer/// Helper struct that contains a state for an algorithm of converting events
/// from raw events to semi-trimmed events that is independent from a way of
/// events reading.
/// Converts raw reader's event into a payload event.
/// Returns `None`, if event should be skipped.
/// Skips until end element is found. Unlike `next()` it will not allocate
/// when it cannot satisfy the lifetime.
/// A copy of the reader's decoder used to decode strings.
has_nil_attr/// Checks if the `start` tag has a [`xsi:nil`] attribute. This method ignores
/// any errors in attributes.
/// [`xsi:nil`]: https://www.w3.org/TR/xmlschema-1/#xsi_nil
/// Trait used by the deserializer for iterating over input. This is manually
/// "specialized" for iterating over `&[u8]`.
/// You do not need to implement this trait, it is needed to abstract from
/// [borrowing](SliceReader) and [copying](IoReader) data sources and reuse code in
/// deserializer
start_trimmer/// XML input source that reads from a std::io input stream.
/// You cannot create it, it is created automatically when you call
/// [`Deserializer::from_reader`]
/// use std::io::Cursor;
/// let mut de = Deserializer::from_reader(Cursor::new(
/// ));
/// let reader: &NsReader<Cursor<&str>> = de.get_ref().get_ref();
/// XML input source that reads from a slice of bytes and can borrow from it.
/// [`Deserializer::from_str`].
/// let reader: &NsReader<&[u8]> = de.get_ref().get_ref();
IllFormedErrormake_deread_and_peek/// Checks that `peek()` and `read()` behaves correctly after `skip()`
/// Checks that `read_to_end()` behaves correctly after `skip()`
partial_replay/// Checks that replay replayes only part of events
/// Test for https://github.com/tafia/quick-xml/issues/435
/// Checks that limiting buffer size works correctly
invalid_xml/// Without handling Eof in `skip` this test failed with memory allocation
invalid_xml1invalid_xml2borrowing_reader_parityborrowing_reader_events/// Ensures, that [`Deserializer::read_string()`] never can get an `End` event,
/// because parser reports error early
cdatatext_and_cdatatext_and_empty_cdatacdata_and_textempty_cdata_and_textcdata_and_cdatacomment_betweenpi_betweenmerge_text/// Tests for https://github.com/tafia/quick-xml/issues/474.
/// That tests ensures that comments and processed instructions is ignored
/// and can split one logical string in pieces.
/// Not matching end tag will result to error
/// <tag1><tag2>...
/// <tag></tag>...
// start::text::text has no difference from start::text
/// <tag> text ...
/// <tag><![CDATA[ cdata ]]>...
/// Start from End event will always generate an error
/// Not matching end tag will result in error
/// End event without corresponding start event will always generate an error
// text::text::something is equivalent to text::something
// cdata::text::text is equivalent to cdata::text
triples/// This tests ensures that any combination of payload data is processed
/// as expected.
//! Serde `Deserializer` module.
//! Due to the complexity of the XML standard and the fact that Serde was developed
//! with JSON in mind, not all Serde concepts apply smoothly to XML. This leads to
//! that fact that some XML concepts are inexpressible in terms of Serde derives
//! and may require manual deserialization.
//! The most notable restriction is the ability to distinguish between _elements_
//! and _attributes_, as no other format used by serde has such a conception.
//! Due to that the mapping is performed in a best effort manner.
//! Table of Contents
//! =================
//! - [Mapping XML to Rust types](#mapping-xml-to-rust-types)
//!   - [Basics](#basics)
//!   - [Optional attributes and elements](#optional-attributes-and-elements)
//!   - [Choices (`xs:choice` XML Schema type)](#choices-xschoice-xml-schema-type)
//!   - [Sequences (`xs:all` and `xs:sequence` XML Schema types)](#sequences-xsall-and-xssequence-xml-schema-types)
//! - [Mapping of `xsi:nil`](#mapping-of-xsinil)
//! - [Generate Rust types from XML](#generate-rust-types-from-xml)
//! - [Composition Rules](#composition-rules)
//! - [Enum Representations](#enum-representations)
//!   - [Normal enum variant](#normal-enum-variant)
//!   - [`$text` enum variant](#text-enum-variant)
//! - [`$text` and `$value` special names](#text-and-value-special-names)
//!   - [`$text`](#text)
//!   - [`$value`](#value)
//!     - [Primitives and sequences of primitives](#primitives-and-sequences-of-primitives)
//!     - [Structs and sequences of structs](#structs-and-sequences-of-structs)
//!     - [Enums and sequences of enums](#enums-and-sequences-of-enums)
//! - [Frequently Used Patterns](#frequently-used-patterns)
//!   - [`<element>` lists](#element-lists)
//!   - [Overlapped (Out-of-Order) Elements](#overlapped-out-of-order-elements)
//!   - [Internally Tagged Enums](#internally-tagged-enums)
//! Mapping XML to Rust types
//! =========================
//! Type names are never considered when deserializing, so you can name your
//! types as you wish. Other general rules:
//! - `struct` field name could be represented in XML only as an attribute name
//!   or an element name;
//! - `enum` variant name could be represented in XML only as an attribute name
//! - the unit struct, unit type `()` and unit enum variant can be deserialized
//!   from any valid XML content:
//!   - attribute and element names;
//!   - attribute and element values;
//!   - text or CDATA content (including mixed text and CDATA content).
//! <div style="background:rgba(120,145,255,0.45);padding:0.75em;">
//! NOTE: All tests are marked with an `ignore` option, even though they do
//! compile. This is  because rustdoc marks such blocks with an information
//! icon unlike `no_run` blocks.
//! </div>
//! <table>
//! <thead>
//! <tr><th colspan="2">
//! ## Basics
//! </th></tr>
//! <tr><th>To parse all these XML's...</th><th>...use these Rust type(s)</th></tr>
//! </thead>
//! <tbody style="vertical-align:top;">
//! <tr>
//! <td>
//! Content of attributes and text / CDATA content of elements (including mixed
//! text and CDATA content):
//! ```xml
//! <... ...="content" />
//! <...>content</...>
//! <...><![CDATA[content]]></...>
//! <...>text<![CDATA[cdata]]>text</...>
//! Mixed text / CDATA content represents one logical string, `"textcdatatext"` in that case.
//! </td>
//! You can use any type that can be deserialized from an `&str`, for example:
//! - [`String`] and [`&str`]
//! - [`Cow<str>`]
//! - [`u32`], [`f32`] and other numeric types
//! - `enum`s, like
//!   ```
//!   # use pretty_assertions::assert_eq;
//!   # use serde::Deserialize;
//!   # #[derive(Debug, PartialEq)]
//!   #[derive(Deserialize)]
//!   enum Language {
//!     Rust,
//!     Cpp,
//!     #[serde(other)]
//!     Other,
//!   }
//!   # #[derive(Debug, PartialEq, Deserialize)]
//!   # struct X { #[serde(rename = "$text")] x: Language }
//!   # assert_eq!(X { x: Language::Rust  }, quick_xml::de::from_str("<x>Rust</x>").unwrap());
//!   # assert_eq!(X { x: Language::Cpp   }, quick_xml::de::from_str("<x>C<![CDATA[p]]>p</x>").unwrap());
//!   # assert_eq!(X { x: Language::Other }, quick_xml::de::from_str("<x><![CDATA[other]]></x>").unwrap());
//! NOTE: deserialization to non-owned types (i.e. borrow from the input),
//! such as `&str`, is possible only if you parse document in the UTF-8
//! encoding and content does not contain entity references such as `&amp;`,
//! or character references such as `&#xD;`, as well as text content represented
//! by one piece of [text] or [CDATA] element.
//! <!-- TODO: document an error type returned -->
//! [text]: Event::Text
//! [CDATA]: Event::CData
//! </tr>
//! <!-- 2 ===================================================================================== -->
//! text and CDATA content), which represents a space-delimited lists, as
//! specified in the XML Schema specification for [`xs:list`] `simpleType`:
//! <... ...="element1 element2 ..." />
//! <...>
//!   element1
//!   element2
//!   ...
//! </...>
//! <...><![CDATA[
//! ]]></...>
//! [`xs:list`]: https://www.w3.org/TR/xmlschema11-2/#list-datatypes
//! Use any type that deserialized using [`deserialize_seq()`] call, for example:
//! type List = Vec<u32>;
//! See the next row to learn where in your struct definition you should
//! use that type.
//! According to the XML Schema specification, delimiters for elements is one
//! or more space (`' '`, `'\r'`, `'\n'`, and `'\t'`) character(s).
//! NOTE: according to the XML Schema restrictions, you cannot escape those
//! white-space characters, so list elements will _never_ contain them.
//! In practice you will usually use `xs:list`s for lists of numbers or enumerated
//! values which looks like identifiers in many languages, for example, `item`,
//! `some_item` or `some-item`, so that shouldn't be a problem.
//! NOTE: according to the XML Schema specification, list elements can be
//! delimited only by spaces. Other delimiters (for example, commas) are not
//! allowed.
//! [`deserialize_seq()`]: de::Deserializer::deserialize_seq
//! <!-- 3 ===================================================================================== -->
//! A typical XML with attributes. The root tag name does not matter:
//! <any-tag one="..." two="..."/>
//! A structure where each XML attribute is mapped to a field with a name
//! starting with `@`. Because Rust identifiers do not permit the `@` character,
//! you should use the `#[serde(rename = "@...")]` attribute to rename it.
//! The name of the struct itself does not matter:
//! # use serde::Deserialize;
//! # type T = ();
//! # type U = ();
//! // Get both attributes
//! # #[derive(Debug, PartialEq)]
//! #[derive(Deserialize)]
//! struct AnyName {
//!   #[serde(rename = "@one")]
//!   one: T,
//!   #[serde(rename = "@two")]
//!   two: U,
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag one="..." two="..."/>"#).unwrap();
//! // Get only the one attribute, ignore the other
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag one="..."/>"#).unwrap();
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag one="..."><one>...</one></any-tag>"#).unwrap();
//! // Ignore all attributes
//! // You can also use the `()` type (unit type)
//! struct AnyName;
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag><one>...</one><two>...</two></any-tag>"#).unwrap();
//! All these structs can be used to deserialize from an XML on the
//! left side depending on amount of information that you want to get.
//! Of course, you can combine them with elements extractor structs (see below).
//! NOTE: XML allows you to have an attribute and an element with the same name
//! inside the one element. quick-xml deals with that by prepending a `@` prefix
//! to the name of attributes.
//! <!-- 4 ===================================================================================== -->
//! A typical XML with child elements. The root tag name does not matter:
//! <any-tag>
//!   <one>...</one>
//!   <two>...</two>
//! </any-tag>
//! A structure where each XML child element is mapped to the field.
//! Each element name becomes a name of field. The name of the struct itself
//! does not matter:
//! // Get both elements
//! #
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag one="..." two="..."/>"#).unwrap_err();
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag one="..."><two>...</two></any-tag>"#).unwrap_err();
//! // Get only the one element, ignore the other
//! // Ignore all elements
//! # quick_xml::de::from_str::<AnyName>(r#"<any-tag one="..."><two>...</two></any-tag>"#).unwrap();
//! Of course, you can combine them with attributes extractor structs (see above).
//! <!-- 5 ===================================================================================== -->
//! An XML with an attribute and a child element named equally:
//! <any-tag field="...">
//!   <field>...</field>
//! You MUST specify `#[serde(rename = "@field")]` on a field that will be used
//! for an attribute:
//! # use pretty_assertions::assert_eq;
//!   #[serde(rename = "@field")]
//!   attribute: T,
//!   field: U,
//! # assert_eq!(
//! #   AnyName { attribute: (), field: () },
//! #   quick_xml::de::from_str(r#"
//! #     <any-tag field="...">
//! #       <field>...</field>
//! #     </any-tag>
//! #   "#).unwrap(),
//! # );
//! <!-- ======================================================================================= -->
//! ## Optional attributes and elements
//! <!-- 6 ===================================================================================== -->
//! An optional XML attribute that you want to capture.
//! The root tag name does not matter:
//! <any-tag optional="..."/>
//! <any-tag/>
//! A structure with an optional field, renamed according to the requirements
//! for attributes:
//!   #[serde(rename = "@optional")]
//!   optional: Option<T>,
//! # assert_eq!(AnyName { optional: Some(()) }, quick_xml::de::from_str(r#"<any-tag optional="..."/>"#).unwrap());
//! # assert_eq!(AnyName { optional: None     }, quick_xml::de::from_str(r#"<any-tag/>"#).unwrap());
//! When the XML attribute is present, type `T` will be deserialized from
//! an attribute value (which is a string). Note, that if `T = String` or other
//! string type, the empty attribute is mapped to a `Some("")`, whereas `None`
//! represents the missed attribute:
//! <any-tag optional="..."/><!-- Some("...") -->
//! <any-tag optional=""/>   <!-- Some("") -->
//! <any-tag/>               <!-- None -->
//! NOTE: The behaviour is not symmetric by default. `None` will be serialized as
//! `optional=""`. This behaviour is consistent across serde crates. You should add
//! `#[serde(skip_serializing_if = "Option::is_none")]` attribute to the field to
//! skip `None`s.
//! <!-- 7 ===================================================================================== -->
//! An optional XML elements that you want to capture.
//!   <optional>...</optional>
//!   <optional/>
//! A structure with an optional field:
//! # assert_eq!(AnyName { optional: Some(()) }, quick_xml::de::from_str(r#"<any-tag><optional>...</optional></any-tag>"#).unwrap());
//! When the XML element is present, type `T` will be deserialized from an
//! element (which is a string or a multi-mapping -- i.e. mapping which can have
//! duplicated keys).
//! `<optional/>`. This behaviour is consistent across serde crates. You should add
//! NOTE: Deserializer will automatically handle a [`xsi:nil`] attribute and set field to `None`.
//! For more info see [Mapping of `xsi:nil`](#mapping-of-xsinil).
//! ## Choices (`xs:choice` XML Schema type)
//! <!-- 8 ===================================================================================== -->
//! An XML with different root tag names, as well as text / CDATA content:
//! <one field1="...">...</one>
//! <two>
//!   <field2>...</field2>
//! </two>
//! Text <![CDATA[or (mixed)
//! CDATA]]> content
//! An enum where each variant has the name of a possible root tag. The name of
//! the enum itself does not matter.
//! If you need to get the textual content, mark a variant with `#[serde(rename = "$text")]`.
//! All these structs can be used to deserialize from any XML on the
//! left side depending on amount of information that you want to get:
//! #[serde(rename_all = "snake_case")]
//! enum AnyName {
//!   One { #[serde(rename = "@field1")] field1: T },
//!   Two { field2: U },
//!   /// Use unit variant, if you do not care of a content.
//!   /// You can use tuple variant if you want to parse
//!   /// textual content as an xs:list.
//!   /// Struct variants are will pass a string to the
//!   /// struct enum variant visitor, which typically
//!   /// returns Err(Custom)
//!   #[serde(rename = "$text")]
//!   Text(String),
//! # assert_eq!(AnyName::One { field1: () }, quick_xml::de::from_str(r#"<one field1="...">...</one>"#).unwrap());
//! # assert_eq!(AnyName::Two { field2: () }, quick_xml::de::from_str(r#"<two><field2>...</field2></two>"#).unwrap());
//! # assert_eq!(AnyName::Text("text  cdata ".into()), quick_xml::de::from_str(r#"text <![CDATA[ cdata ]]>"#).unwrap());
//! struct Two {
//!   field2: T,
//!   // `field1` content discarded
//!   One,
//!   Two(Two),
//!   Text,
//! # assert_eq!(AnyName::One,                     quick_xml::de::from_str(r#"<one field1="...">...</one>"#).unwrap());
//! # assert_eq!(AnyName::Two(Two { field2: () }), quick_xml::de::from_str(r#"<two><field2>...</field2></two>"#).unwrap());
//! # assert_eq!(AnyName::Text,                    quick_xml::de::from_str(r#"text <![CDATA[ cdata ]]>"#).unwrap());
//!   // the <two> and textual content will be mapped to this
//!   #[serde(other)]
//!   Other,
//! # assert_eq!(AnyName::One,   quick_xml::de::from_str(r#"<one field1="...">...</one>"#).unwrap());
//! # assert_eq!(AnyName::Other, quick_xml::de::from_str(r#"<two><field2>...</field2></two>"#).unwrap());
//! # assert_eq!(AnyName::Other, quick_xml::de::from_str(r#"text <![CDATA[ cdata ]]>"#).unwrap());
//! NOTE: You should have variants for all possible tag names in your enum
//! or have an `#[serde(other)]` variant.
//! <!-- TODO: document an error type if that requirement is violated -->
//! <!-- 9 ===================================================================================== -->
//! `<xs:choice>` embedded in the other element, and at the same time you want
//! to get access to other attributes that can appear in the same container
//! (`<any-tag>`). Also this case can be described, as if you want to choose
//! Rust enum variant based on a tag name:
//!   Text <![CDATA[or (mixed)
//!   CDATA]]> content
//! A structure with a field which type is an `enum`.
//! If you need to get a textual content, mark a variant with `#[serde(rename = "$text")]`.
//! Names of the enum, struct, and struct field with `Choice` type does not matter:
//! enum Choice {
//!   Two,
//!   field: T,
//!   #[serde(rename = "$value")]
//!   any_name: Choice,
//! #   AnyName { field: (), any_name: Choice::One },
//! #   quick_xml::de::from_str(r#"<any-tag field="..."><one>...</one></any-tag>"#).unwrap(),
//! #   AnyName { field: (), any_name: Choice::Two },
//! #   quick_xml::de::from_str(r#"<any-tag field="..."><two>...</two></any-tag>"#).unwrap(),
//! #   AnyName { field: (), any_name: Choice::Text("text  cdata ".into()) },
//! #   quick_xml::de::from_str(r#"<any-tag field="...">text <![CDATA[ cdata ]]></any-tag>"#).unwrap(),
//! <!-- 10 ==================================================================================== -->
//! to get access to other elements that can appear in the same container
//! #   quick_xml::de::from_str(r#"<any-tag><field>...</field><one>...</one></any-tag>"#).unwrap(),
//! #   quick_xml::de::from_str(r#"<any-tag><two>...</two><field>...</field></any-tag>"#).unwrap(),
//! NOTE: if your `Choice` enum would contain an `#[serde(other)]`
//! variant, element `<field>` will be mapped to the `field` and not to the enum
//! variant.
//! <!-- 11 ==================================================================================== -->
//! `<xs:choice>` encapsulated in other element with a fixed name:
//!   <choice>
//!     <one>...</one>
//!   </choice>
//!     <two>...</two>
//! A structure with a field of an intermediate type with one field of `enum` type.
//! Actually, this example is not necessary, because you can construct it by yourself
//! using the composition rules that were described above. However the XML construction
//! described here is very common, so it is shown explicitly.
//! Names of the enum and struct does not matter:
//! struct Holder {
//!   choice: Holder,
//! #   AnyName { field: (), choice: Holder { any_name: Choice::One } },
//! #   quick_xml::de::from_str(r#"<any-tag field="..."><choice><one>...</one></choice></any-tag>"#).unwrap(),
//! #   AnyName { field: (), choice: Holder { any_name: Choice::Two } },
//! #   quick_xml::de::from_str(r#"<any-tag field="..."><choice><two>...</two></choice></any-tag>"#).unwrap(),
//! <!-- 12 ==================================================================================== -->
//! #   quick_xml::de::from_str(r#"<any-tag><field>...</field><choice><one>...</one></choice></any-tag>"#).unwrap(),
//! #   quick_xml::de::from_str(r#"<any-tag><choice><two>...</two></choice><field>...</field></any-tag>"#).unwrap(),
//! <!-- ======================================================================================== -->
//! ## Sequences (`xs:all` and `xs:sequence` XML Schema types)
//! <!-- 13 ==================================================================================== -->
//! A sequence inside of a tag without a dedicated name:
//!   <item/>
//! A structure with a field which is a sequence type, for example, [`Vec`].
//! Because XML syntax does not distinguish between empty sequences and missed
//! elements, we should indicate that on the Rust side, because serde will require
//! that field `item` exists. You can do that in two possible ways:
//! Use the `#[serde(default)]` attribute for a [field] or the entire [struct]:
//! # type Item = ();
//!   #[serde(default)]
//!   item: Vec<Item>,
//! #   AnyName { item: vec![] },
//! #   quick_xml::de::from_str(r#"<any-tag/>"#).unwrap(),
//! #   AnyName { item: vec![()] },
//! #   quick_xml::de::from_str(r#"<any-tag><item/></any-tag>"#).unwrap(),
//! #   AnyName { item: vec![(), (), ()] },
//! #   quick_xml::de::from_str(r#"<any-tag><item/><item/><item/></any-tag>"#).unwrap(),
//! Use the [`Option`]. In that case inner array will always contains at least one
//! element after deserialization:
//!   item: Option<Vec<Item>>,
//! #   AnyName { item: None },
//! #   AnyName { item: Some(vec![()]) },
//! #   AnyName { item: Some(vec![(), (), ()]) },
//! See also [Frequently Used Patterns](#element-lists).
//! [field]: https://serde.rs/field-attrs.html#default
//! [struct]: https://serde.rs/container-attrs.html#default
//! <!-- 14 ==================================================================================== -->
//! A sequence with a strict order, probably with mixed content
//! (text / CDATA and tags):
//! <one>...</one>
//! text
//! <![CDATA[cdata]]>
//! <two>...</two>
//! NOTE: this is just an example for showing mapping. XML does not allow
//! multiple root tags -- you should wrap the sequence into a tag.
//! All elements mapped to the heterogeneous sequential type: tuple or named tuple.
//! Each element of the tuple should be able to be deserialized from the nested
//! element content (`...`), except the enum types which would be deserialized
//! from the full element (`<one>...</one>`), so they could use the element name
//! to choose the right variant:
//! # type One = ();
//! # type Two = ();
//! # /*
//! type One = ...;
//! type Two = ...;
//! # */
//! struct AnyName(One, String, Two, One);
//! #   AnyName((), "text cdata".into(), (), ()),
//! #   quick_xml::de::from_str(r#"<one>...</one>text <![CDATA[cdata]]><two>...</two><one>...</one>"#).unwrap(),
//! type AnyName = (Choice, String, Two, Choice);
//! #   (Choice::One, "text cdata".to_string(), (), Choice::One),
//! NOTE: consequent text and CDATA nodes are merged into the one text node,
//! so you cannot have two adjacent string types in your sequence.
//! NOTE: In the case that the list might contain tags that are overlapped with
//! tags that do not correspond to the list you should add the feature [`overlapped-lists`].
//! <!-- 15 ==================================================================================== -->
//! A sequence with a non-strict order, probably with a mixed content
//! (text / CDATA and tags).
//! A homogeneous sequence of elements with a fixed or dynamic size:
//! type AnyName = [Choice; 4];
//! #   [Choice::One, Choice::Other, Choice::Two, Choice::One],
//! #   quick_xml::de::from_str::<AnyName>(r#"<one>...</one>text <![CDATA[cdata]]><two>...</two><one>...</one>"#).unwrap(),
//!   Other(String),
//! type AnyName = Vec<Choice>;
//! #   vec![
//! #     Choice::One,
//! #     Choice::Other("text cdata".into()),
//! #     Choice::Two,
//! #   ],
//! <!-- 16 ==================================================================================== -->
//! A sequence with a strict order, probably with a mixed content,
//! (text and tags) inside of the other element:
//! <any-tag attribute="...">
//!   text
//!   <![CDATA[cdata]]>
//! A structure where all child elements mapped to the one field which have
//! a heterogeneous sequential type: tuple or named tuple. Each element of the
//! tuple should be able to be deserialized from the full element (`<one>...</one>`).
//! You MUST specify `#[serde(rename = "$value")]` on that field:
//!   #[serde(rename = "@attribute")]
//! # attribute: (),
//!   attribute: ...,
//!   // Does not (yet?) supported by the serde
//!   // https://github.com/serde-rs/serde/issues/1905
//!   // #[serde(flatten)]
//!   any_name: (One, String, Two, One),
//! #   AnyName { attribute: (), any_name: ((), "text cdata".into(), (), ()) },
//! #   quick_xml::de::from_str("\
//! #     <any-tag attribute='...'>\
//! #       <one>...</one>\
//! #       text \
//! #       <![CDATA[cdata]]>\
//! #       <two>...</two>\
//! #     </any-tag>"
//! #   ).unwrap(),
//! struct NamedTuple(One, String, Two, One);
//!   any_name: NamedTuple,
//! #   AnyName { attribute: (), any_name: NamedTuple((), "text cdata".into(), (), ()) },
//! <!-- 17 ==================================================================================== -->
//! (text / CDATA and tags) inside of the other element:
//! a homogeneous sequential type: array-like container. A container type `T`
//! should be able to be deserialized from the nested element content (`...`),
//! except if it is an enum type which would be deserialized from the full
//! element (`<one>...</one>`).
//!   any_name: [Choice; 4],
//! #   AnyName { attribute: (), any_name: [
//! #   ] },
//!   any_name: Vec<Choice>,
//! #   AnyName { attribute: (), any_name: vec![
//! </tbody>
//! </table>
//! Mapping of `xsi:nil`
//! ====================
//! quick-xml supports handling of [`xsi:nil`] special attribute. When field of optional
//! type is mapped to the XML element which have `xsi:nil="true"` set, or if that attribute
//! is placed on parent XML element, the deserializer will call [`Visitor::visit_none`]
//! and skip XML element corresponding to a field.
//! Examples:
//! #[derive(Deserialize, Debug, PartialEq)]
//! struct TypeWithOptionalField {
//!   element: Option<String>,
//! assert_eq!(
//!   TypeWithOptionalField {
//!     element: None,
//!   },
//!   quick_xml::de::from_str("
//!     <any-tag xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
//!       <element xsi:nil='true'>Content is skiped because of xsi:nil='true'</element>
//!     </any-tag>
//!   ").unwrap(),
//! );
//! You can capture attributes from the optional type, because ` xsi:nil="true"` elements can have
//! attributes:
//!   attribute: usize,
//!   non_optional: String,
//!     attribute: 42,
//!     non_optional: "Note, that non-optional fields will be deserialized as usual".to_string(),
//!     <any-tag attribute='42' xsi:nil='true' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
//!       <element>Content is skiped because of xsi:nil='true'</element>
//!       <non_optional>Note, that non-optional fields will be deserialized as usual</non_optional>
//! Generate Rust types from XML
//! ============================
//! To speed up the creation of Rust types that represent a given XML file you can
//! use the [xml_schema_generator](https://github.com/Thomblin/xml_schema_generator).
//! It provides a standalone binary and a Rust library that parses one or more XML files
//! and generates a collection of structs that are compatible with quick_xml::de.
//! Composition Rules
//! The XML format is very different from other formats supported by `serde`.
//! One such difference it is how data in the serialized form is related to
//! the Rust type. Usually each byte in the data can be associated only with
//! one field in the data structure. However, XML is an exception.
//! For example, took this XML:
//! <any>
//!   <key attr="value"/>
//! </any>
//! and try to deserialize it to the struct `AnyName`:
//! struct AnyName { // AnyName calls `deserialize_struct` on `<any><key attr="value"/></any>`
//!                  //                         Used data:          ^^^^^^^^^^^^^^^^^^^
//!   key: Inner,    // Inner   calls `deserialize_struct` on `<key attr="value"/>`
//!                  //                         Used data:          ^^^^^^^^^^^^
//! struct Inner {
//!   #[serde(rename = "@attr")]
//!   attr: String,  // String  calls `deserialize_string` on `value`
//!                  //                         Used data:     ^^^^^
//! Comments shows what methods of a [`Deserializer`] called by each struct
//! `deserialize` method and which input their seen. **Used data** shows, what
//! content is actually used for deserializing. As you see, name of the inner
//! `<key>` tag used both as a map key / outer struct field name and as part
//! of the inner struct (although _value_ of the tag, i.e. `key` is not used
//! by it).
//! Enum Representations
//! `quick-xml` represents enums differently in normal fields, `$text` fields and
//! `$value` fields. A normal representation is compatible with serde's adjacent
//! and internal tags feature -- tag for adjacently and internally tagged enums
//! are serialized using [`Serializer::serialize_unit_variant`] and deserialized
//! using [`Deserializer::deserialize_enum`].
//! Use those simple rules to remember, how enum would be represented in XML:
//! - In `$value` field the representation is always the same as top-level representation;
//! - In `$text` field the representation is always the same as in normal field,
//!   but surrounding tags with field name are removed;
//! - In normal field the representation is always contains a tag with a field name.
//! Normal enum variant
//! -------------------
//! To model an `xs:choice` XML construct use `$value` field.
//! To model a top-level `xs:choice` just use the enum type.
//! |Kind   |Top-level and in `$value` field          |In normal field      |In `$text` field     |
//! |-------|-----------------------------------------|---------------------|---------------------|
//! |Unit   |`<Unit/>`                                |`<field>Unit</field>`|`Unit`               |
//! |Newtype|`<Newtype>42</Newtype>`                  |Err(Custom) [^0]     |Err(Custom) [^0]     |
//! |Tuple  |`<Tuple>42</Tuple><Tuple>answer</Tuple>` |Err(Custom) [^0]     |Err(Custom) [^0]     |
//! |Struct |`<Struct><q>42</q><a>answer</a></Struct>`|Err(Custom) [^0]     |Err(Custom) [^0]     |
//! `$text` enum variant
//! --------------------
//! |Unit   |_(empty)_                                |`<field/>`           |_(empty)_            |
//! |Newtype|`42`                                     |Err(Custom) [^0] [^1]|Err(Custom) [^0] [^2]|
//! |Tuple  |`42 answer`                              |Err(Custom) [^0] [^3]|Err(Custom) [^0] [^4]|
//! |Struct |Err(Custom) [^0]                         |Err(Custom) [^0]     |Err(Custom) [^0]     |
//! [^0]: Error is returned by the deserialized type. In case of derived implementation a `Custom`
//!       error will be returned, but custom deserialize implementation can successfully deserialize
//!       value from a string which will be passed to it.
//! [^1]: If this serialize as `<field>42</field>` then it will be ambiguity during deserialization,
//!       because it clash with `Unit` representation in normal field.
//! [^2]: If this serialize as `42` then it will be ambiguity during deserialization,
//!       because it clash with `Unit` representation in `$text` field.
//! [^3]: If this serialize as `<field>42 answer</field>` then it will be ambiguity during deserialization,
//! [^4]: If this serialize as `42 answer` then it will be ambiguity during deserialization,
//! `$text` and `$value` special names
//! ==================================
//! quick-xml supports two special names for fields -- `$text` and `$value`.
//! Although they may seem the same, there is a distinction. Two different
//! names is required mostly for serialization, because quick-xml should know
//! how you want to serialize certain constructs, which could be represented
//! through XML in multiple different ways.
//! The only difference is in how complex types and sequences are serialized.
//! If you doubt which one you should select, begin with [`$value`](#value).
//! ## `$text`
//! `$text` is used when you want to write your XML as a text or a CDATA content.
//! More formally, field with that name represents simple type definition with
//! `{variety} = atomic` or `{variety} = union` whose basic members are all atomic,
//! as described in the [specification].
//! As a result, not all types of such fields can be serialized. Only serialization
//! of following types are supported:
//! - all primitive types (strings, numbers, booleans)
//! - unit variants of enumerations (serializes to a name of a variant)
//! - newtypes (delegates serialization to inner type)
//! - [`Option`] of above (`None` serializes to nothing)
//! - sequences (including tuples and tuple variants of enumerations) of above,
//!   excluding `None` and empty string elements (because it will not be possible
//!   to deserialize them back). The elements are separated by space(s)
//! - unit type `()` and unit structs (serializes to nothing)
//! Complex types, such as structs and maps, are not supported in this field.
//! If you want them, you should use `$value`.
//! Sequences serialized to a space-delimited string, that is why only certain
//! types are allowed in this mode:
//! # use serde::{Deserialize, Serialize};
//! # use quick_xml::de::from_str;
//! # use quick_xml::se::to_string;
//! #[derive(Deserialize, Serialize, PartialEq, Debug)]
//!     #[serde(rename = "$text")]
//!     field: Vec<usize>,
//! let obj = AnyName { field: vec![1, 2, 3] };
//! let xml = to_string(&obj).unwrap();
//! assert_eq!(xml, "<AnyName>1 2 3</AnyName>");
//! let object: AnyName = from_str(&xml).unwrap();
//! assert_eq!(object, obj);
//! ## `$value`
//! NOTE: a name `#content` would better explain the purpose of that field,
//! but `$value` is used for compatibility with other XML serde crates, which
//! uses that name. This will allow you to switch XML crates more smoothly if required.
//! Representation of primitive types in `$value` does not differ from their
//! representation in `$text` field. The difference is how sequences are serialized.
//! `$value` serializes each sequence item as a separate XML element. The name
//! of that element is taken from serialized type, and because only `enum`s provide
//! such name (their variant name), only they should be used for such fields.
//! `$value` fields does not support `struct` types with fields, the serialization
//! of such types would end with an `Err(Unsupported)`. Unit structs and unit
//! type `()` serializing to nothing and can be deserialized from any content.
//! Serialization and deserialization of `$value` field performed as usual, except
//! that name for an XML element will be given by the serialized type, instead of
//! field. The latter allow to serialize enumerated types, where variant is encoded
//! as a tag name, and, so, represent an XSD `xs:choice` schema by the Rust `enum`.
//! In the example below, field will be serialized as `<field/>`, because elements
//! get their names from the field name. It cannot be deserialized, because `Enum`
//! expects elements `<A/>`, `<B/>` or `<C/>`, but `AnyName` looked only for `<field/>`:
//! #[derive(Deserialize, Serialize)]
//! enum Enum { A, B, C }
//!     // <field>A</field>, <field>B</field>, or <field>C</field>
//!     field: Enum,
//! #     quick_xml::se::to_string(&AnyName { field: Enum::A }).unwrap(),
//! #     "<AnyName><field>A</field></AnyName>",
//! #     AnyName { field: Enum::B },
//! #     quick_xml::de::from_str("<root><field>B</field></root>").unwrap(),
//! If you rename field to `$value`, then `field` would be serialized as `<A/>`,
//! `<B/>` or `<C/>`, depending on the its content. It is also possible to
//! deserialize it from the same elements:
//! # #[derive(Deserialize, Serialize, PartialEq, Debug)]
//! # enum Enum { A, B, C }
//!     // <A/>, <B/> or <C/>
//!     #[serde(rename = "$value")]
//! #     "<AnyName><A/></AnyName>",
//! #     quick_xml::de::from_str("<root><B/></root>").unwrap(),
//! ### Primitives and sequences of primitives
//! Sequences serialized to a list of elements. Note, that types that does not
//! produce their own tag (i. e. primitives) will produce [`SeError::Unsupported`]
//! if they contains more that one element, because such sequence cannot be
//! deserialized to the same value:
//! // If this object were serialized, it would be represented as "<AnyName>123</AnyName>"
//! to_string(&obj).unwrap_err();
//! let object: AnyName = from_str("<AnyName>123</AnyName>").unwrap();
//! assert_eq!(object, AnyName { field: vec![123] });
//! // `1 2 3` is mapped to a single `usize` element
//! // It is impossible to deserialize list of primitives to such field
//! from_str::<AnyName>("<AnyName>1 2 3</AnyName>").unwrap_err();
//! A particular case of that example is a string `$value` field, which probably
//! would be a most used example of that attribute:
//!     field: String,
//! let obj = AnyName { field: "content".to_string() };
//! assert_eq!(xml, "<AnyName>content</AnyName>");
//! ### Structs and sequences of structs
//! Note, that structures do not have a serializable name as well (name of the
//! type is never used), so it is impossible to serialize non-unit struct or
//! sequence of non-unit structs in `$value` field. (sequences of) unit structs
//! are serialized as empty string, because units itself serializing
//! to nothing:
//! struct Unit;
//!     // #[serde(default)] is required to deserialization of empty lists
//!     // This is a general note, not related to $value
//!     #[serde(rename = "$value", default)]
//!     field: Vec<Unit>,
//! let obj = AnyName { field: vec![Unit, Unit, Unit] };
//! assert_eq!(xml, "<AnyName/>");
//! let object: AnyName = from_str("<AnyName/>").unwrap();
//! assert_eq!(object, AnyName { field: vec![] });
//! let object: AnyName = from_str("<AnyName></AnyName>").unwrap();
//! let object: AnyName = from_str("<AnyName><A/><B/><C/></AnyName>").unwrap();
//! assert_eq!(object, AnyName { field: vec![Unit, Unit, Unit] });
//! ### Enums and sequences of enums
//! Enumerations uses the variant name as an element name:
//!     field: Vec<Enum>,
//! let obj = AnyName { field: vec![Enum::A, Enum::B, Enum::C] };
//!     xml,
//!     "<AnyName>\
//!         <A/>\
//!         <B/>\
//!         <C/>\
//!      </AnyName>"
//! ----------------------------------------------------------------------------
//! You can have either `$text` or `$value` field in your structs. Unfortunately,
//! that is not enforced, so you can theoretically have both, but you should
//! avoid that.
//! Frequently Used Patterns
//! ========================
//! Some XML constructs used so frequent, that it is worth to document the recommended
//! way to represent them in the Rust. The sections below describes them.
//! `<element>` lists
//! -----------------
//! Many XML formats wrap lists of elements in the additional container,
//! although this is not required by the XML rules:
//! <root>
//!   <field1/>
//!   <field2/>
//!   <list><!-- Container -->
//!     <element/>
//!   </list>
//!   <field3/>
//! </root>
//! In this case, there is a great desire to describe this XML in this way:
//! /// Represents <element/>
//! type Element = ();
//! /// Represents <root>...</root>
//!     // Incorrect
//!     list: Vec<Element>,
//! This will not work, because potentially `<list>` element can have attributes
//! and other elements inside. You should define the struct for the `<list>`
//! explicitly, as you do that in the XSD for that XML:
//!     // Correct
//!     list: List,
//! /// Represents <list>...</list>
//! struct List {
//!     element: Vec<Element>,
//! If you want to simplify your API, you could write a simple function for unwrapping
//! inner list and apply it via [`deserialize_with`]:
//! use quick_xml::de::from_str;
//! use serde::{Deserialize, Deserializer};
//!     #[serde(deserialize_with = "unwrap_list")]
//! fn unwrap_list<'de, D>(deserializer: D) -> Result<Vec<Element>, D::Error>
//! where
//!     D: Deserializer<'de>,
//! {
//!     /// Represents <list>...</list>
//!     #[derive(Deserialize)]
//!     struct List {
//!         // default allows empty list
//!         #[serde(default)]
//!         element: Vec<Element>,
//!     Ok(List::deserialize(deserializer)?.element)
//!     AnyName { list: vec![(), (), ()] },
//!     from_str("
//!         <root>
//!           <list>
//!             <element/>
//!           </list>
//!         </root>
//!     ").unwrap(),
//! Instead of writing such functions manually, you also could try <https://lib.rs/crates/serde-query>.
//! Overlapped (Out-of-Order) Elements
//! ----------------------------------
//! In the case that the list might contain tags that are overlapped with
//! tags that do not correspond to the list (this is a usual case in XML
//! documents) like this:
//! <any-name>
//!   <another-item/>
//! </any-name>
//! you should enable the [`overlapped-lists`] feature to make it possible
//! to deserialize this to:
//! #[serde(rename_all = "kebab-case")]
//!     item: Vec<()>,
//!     another_item: (),
//! Internally Tagged Enums
//! -----------------------
//! [Tagged enums] are currently not supported because of an issue in the Serde
//! design (see [serde#1183] and [quick-xml#586]) and missing optimizations in
//! Serde which could be useful for XML parsing ([serde#1495]). This can be worked
//! around by manually implementing deserialize with `#[serde(deserialize_with = "func")]`
//! or implementing [`Deserialize`], but this can get very tedious very fast for
//! files with large amounts of tagged enums. To help with this issue quick-xml
//! provides a macro [`impl_deserialize_for_internally_tagged_enum!`]. See the
//! macro documentation for details.
//! [`overlapped-lists`]: ../index.html#overlapped-lists
//! [specification]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
//! [`deserialize_with`]: https://serde.rs/field-attrs.html#deserialize_with
//! [`xsi:nil`]: https://www.w3.org/TR/xmlschema-1/#xsi_nil
//! [`Serializer::serialize_unit_variant`]: serde::Serializer::serialize_unit_variant
//! [`Deserializer::deserialize_enum`]: serde::Deserializer::deserialize_enum
//! [`SeError::Unsupported`]: crate::errors::serialize::SeError::Unsupported
//! [Tagged enums]: https://serde.rs/enum-representations.html#internally-tagged
//! [serde#1183]: https://github.com/serde-rs/serde/issues/1183
//! [serde#1495]: https://github.com/serde-rs/serde/issues/1495
//! [quick-xml#586]: https://github.com/tafia/quick-xml/issues/586
//! [`impl_deserialize_for_internally_tagged_enum!`]: crate::impl_deserialize_for_internally_tagged_enum
resolve_predefined_entity/// The error type that represents DTD parse error
/// Called on contents of [`Event::DocType`] to capture declared entities.
/// Can be called multiple times, for each parsed `<!DOCTYPE >` declaration.
/// [`Event::DocType`]: crate::events::Event::DocType
/// Called when an entity needs to be resolved.
/// `None` is returned if a suitable value can not be found.
/// In that case an [`EscapeError::UnrecognizedEntity`] will be returned by
/// a deserializer.
/// Used to resolve unknown entities while parsing
/// # Example
/// # use serde::Deserialize;
/// use regex::bytes::Regex;
/// use std::collections::BTreeMap;
/// use std::string::FromUtf8Error;
/// use quick_xml::de::{Deserializer, EntityResolver};
/// use quick_xml::events::BytesText;
/// struct DocTypeEntityResolver {
///     re: Regex,
///     map: BTreeMap<String, String>,
/// impl Default for DocTypeEntityResolver {
///     fn default() -> Self {
///         Self {
///             // We do not focus on true parsing in this example
///             // You should use special libraries to parse DTD
///             re: Regex::new(r#"<!ENTITY\s+([^ \t\r\n]+)\s+"([^"]*)"\s*>"#).unwrap(),
///             map: BTreeMap::new(),
///         }
/// impl EntityResolver for DocTypeEntityResolver {
///     type Error = FromUtf8Error;
///     fn capture(&mut self, doctype: BytesText) -> Result<(), Self::Error> {
///         for cap in self.re.captures_iter(&doctype) {
///             self.map.insert(
///                 String::from_utf8(cap[1].to_vec())?,
///                 String::from_utf8(cap[2].to_vec())?,
///             );
///         Ok(())
///     fn resolve(&self, entity: &str) -> Option<&str> {
///         self.map.get(entity).map(|s| s.as_str())
/// let xml_reader = br#"
///     <!DOCTYPE dict[ <!ENTITY e1 "entity 1"> ]>
///     <root>
///         <entity_one>&e1;</entity_one>
///     </root>
/// "#.as_ref();
/// let mut de = Deserializer::with_resolver(
///     xml_reader,
///     DocTypeEntityResolver::default(),
/// let data: BTreeMap<String, String> = BTreeMap::deserialize(&mut de).unwrap();
/// assert_eq!(data.get("entity_one"), Some(&"entity 1".to_string()));
/// An [`EntityResolver`] that resolves only predefined entities:
/// | Entity | Resolution
/// |--------|------------
/// |`&lt;`  | `<`
/// |`&gt;`  | `>`
/// |`&amp;` | `&`
/// |`&apos;`| `'`
/// |`&quot;`| `"`
//! Entity resolver module
UnitDeserializerdeserialize_primitive/// An input borrowed from the parsed data
/// An input borrowed from the buffer owned by another deserializer
/// An input taken from an external deserializer, owned by that deserializer.
/// Only part of this data, located after offset represented by `usize`, used
/// to deserialize data, the other is a garbage that can't be dropped because
/// we do not want to make reallocations if they will not required.
/// A version of [`Cow`] that can borrow from two different buffers, one of them
/// is a deserializer input, and conceptually contains only part of owned data.
/// - `'de` -- lifetime of the data that deserializer borrow from the parsed input
/// - `'a` -- lifetime of the data that owned by a deserializer
/// Returns string representation of the content
/// Content of the attribute value, text content or CDATA content
/// If `true`, `content` in an escaped form and should be unescaped before use
AtomicDeserializer/// A deserializer that handles ordinary [simple type definition][item] with
/// `{variety} = atomic`, or an ordinary [simple type] definition with
/// `{variety} = union` whose basic members are all atomic.
/// This deserializer can deserialize only primitive types:
/// - strings
/// - units
/// - options
/// - unit variants of enums
/// Identifiers represented as strings and deserialized accordingly.
/// Deserialization of all other types will provide a string and in most cases
/// the deserialization will fail because visitor does not expect that.
/// The `Owned` variant of the content acts as a storage for data, allocated by
/// an external deserializer that pass it via [`ListIter`].
/// [item]: https://www.w3.org/TR/xmlschema11-1/#std-item_type_definition
/// [simple type]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
/// Forwards deserialization to the [`Self::deserialize_str`]
/// Supply to the visitor borrowed string, string slice, or owned string
/// depending on the kind of input and presence of the escaped data.
/// If string requires unescaping, then calls [`Visitor::visit_string`] with
/// new allocated buffer with unescaped data.
/// Otherwise calls
/// - [`Visitor::visit_borrowed_str`] if data borrowed from the input
/// - [`Visitor::visit_str`] if data borrowed from other deserializer
/// - [`Visitor::visit_string`] if data owned by this deserializer
/// If `content` is an empty string then calls [`Visitor::visit_none`],
/// Deserializer of variant data, that supports only unit variants.
/// Attempt to deserialize newtype will provide [`UnitDeserializer`].
/// Attempt to deserialize tuple or struct variant will result to call of
/// [`Visitor::visit_unit`].
/// If `Some`, contains unconsumed data of the list
/// If `true`, `content` in escaped form and should be unescaped before use
ListIter/// Iterator over string sub-slices delimited by one or several spaces.
/// Contains decoded value of the `simpleType`.
/// Iteration ends when list contains `None`.
/// - In case of attribute contains escaped attribute value
/// - In case of text contains unescaped text value
/// Decoder used to deserialize string data, numeric and boolean data.
/// Not used for deserializing raw byte buffers
/// A deserializer for an xml probably escaped and encoded value of XSD [simple types].
/// This deserializer will borrow from the input as much as possible.
/// `deserialize_any()` returns the whole string that deserializer contains.
/// Escaping the value is actually not always necessary, for instance when
/// converting to a float, we don't expect any escapable character anyway.
/// In that cases deserializer skips unescaping step.
/// Used for deserialize values from:
/// - attribute values (`<... ...="value" ...>`)
/// - mixed text / CDATA content (`<...>text<![CDATA[cdata]]></...>`)
/// - numbers are parsed from a text content using [`FromStr`]; in case of error
///   [`Visitor::visit_borrowed_str`], [`Visitor::visit_str`], or [`Visitor::visit_string`]
///   is called; it is responsibility of the type to return an error if it does
///   not able to process passed data;
/// - booleans converted from the text according to the XML [specification]:
///   - everything else calls [`Visitor::visit_borrowed_str`], [`Visitor::visit_str`],
///     or [`Visitor::visit_string`]; it is responsibility of the type to return
///     an error if it does not able to process passed data;
/// - strings returned as is;
/// - `Option` always deserialized as `Some` using the same deserializer.
///   If attribute or text content is missed, then the deserializer even wouldn't
///   be used, so if it is used, then the value should be;
/// - units (`()`) and unit structs always deserialized successfully, the content is ignored;
/// - newtype structs forwards deserialization to the inner type using the same
///   deserializer;
/// - sequences, tuples and tuple structs are deserialized as `xs:list`s. Only
///   sequences of primitive types is possible to deserialize this way and they
///   should be delimited by a space (` `, `\t`, `\r`, or `\n`);
/// - structs and maps delegates to [`Self::deserialize_str`] which calls
///   [`Visitor::visit_borrowed_str`] or [`Visitor::visit_string`]; it is responsibility
///   of the type to return an error if it does not able to process passed data;
///   - the variant name is deserialized using the same deserializer;
///   - the content is deserialized using the deserializer that always returns unit (`()`):
///     - unit variants: just return `()`;
///     - newtype variants: deserialize from [`UnitDeserializer`];
///     - tuple and struct variants: call [`Visitor::visit_unit`];
/// - identifiers are deserialized as strings.
/// [simple types]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
from_text/// Creates a deserializer from a value, that possible borrowed from input.
/// It is assumed that `text` does not have entities.
from_text_content/// Creates a deserializer from an XML text node, that possible borrowed from input.
/// This constructor used internally to deserialize from text nodes.
from_part/// Creates a deserializer from a part of value at specified range.
/// This constructor used internally to deserialize from attribute values.
/// Constructor for tests
/// Decodes raw bytes using the encoding specified.
/// The method will borrow if has the UTF-8 compatible representation.
/// Representation of tuples the same as [sequences][Self::deserialize_seq].
/// Representation of named tuples the same as [unnamed tuples][Self::deserialize_tuple].
QuoteTargetSimpleTypeSerializerQuoteLevelsimple_onlyBorrowedNewtypeAtomicSerializer/// and the result is serialized back to the `$input`
// Serializer will escape space. Because borrowing has meaning only for deserializer,
// no need to test roundtrip here, it is already tested with non-borrowing version
owned_data/// Checks that deserialization from an owned content is working
borrowed_from_deserializer/// Checks that deserialization from a content borrowed from some
/// buffer other that input is working
/// Tests for deserialize atomic and union values, as defined in XSD specification
only_spacesone_itemtwo_itemsleading_spacestrailing_spacesmixed_types/// Module for testing list accessor
// Serializer will not escape space because this is unnecessary.
// Because borrowing has meaning only for deserializer, no need to test
// roundtrip here, it is already tested for strings where compatible list
// of escaped characters is used
to_utf16utf16// UTF-16 data never borrow because data was decoded not in-place
//! Contains Serde `Deserializer` for XML [simple types] [as defined] in the XML Schema.
//! [simple types]: https://www.w3schools.com/xml/el_simpletype.asp
//! [as defined]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
/// A deserializer for a single text node of a mixed sequence of tags and text.
/// processes the [`DeEvent::Text`] event). The only difference in the
/// `deserialize_seq` method. This deserializer will perform deserialization
/// from a textual content, whereas the [`MapValueDeserializer`] will iterate
/// over tags / text within it's parent tag.
///   - empty text is deserialized as `None`;
///   - everything else is deserialized as `Some` using the same deserializer;
///   (this is the difference): text content passed to the deserializer directly;
/// - structs and maps calls [`Visitor::visit_borrowed_str`] or [`Visitor::visit_string`],
///   it is responsibility of the type to return an error if it do not able to process
///   this data;
///   - the variant name is deserialized as `$text`;
///     - newtype variants forwards deserialization to the inner type using the
///       same deserializer;
///     - tuple and struct variants are deserialized using [`SimpleTypeDeserializer`].
/// [`MapValueDeserializer`]: ../map/struct.MapValueDeserializer.html
/// [`DeEvent::Text`]: crate::de::DeEvent::Text
///   inner sequence as xs:list
/// An enum access
UTF8_BOM/// Unicode "byte order mark" (\u{FEFF}) encoded as UTF-8.
/// See <https://unicode.org/faq/utf_bom.html#bom1>
/// Input was not valid UTF-8
/// An error when decoding or encoding
/// If feature [`encoding`] is disabled, the [`EncodingError`] is always [`EncodingError::Utf8`]
/// [`encoding`]: ../index.html#encoding
/// Decoder of byte slices into strings.
/// If feature [`encoding`] is enabled, this encoding taken from the `"encoding"`
/// XML declaration or assumes UTF-8, if XML has no <?xml ?> declaration, encoding
/// key is not defined or contains unknown encoding.
/// The library supports any UTF-8 compatible encodings that crate `encoding_rs`
/// is supported. [*UTF-16 and ISO-2022-JP are not supported at the present*][utf16].
/// If feature [`encoding`] is disabled, the decoder is always UTF-8 decoder:
/// any XML declarations are ignored.
/// [utf16]: https://github.com/tafia/quick-xml/issues/158
/// ## Without `encoding` feature
/// Decodes an UTF-8 slice regardless of XML declaration and ignoring BOM
/// if it is present in the `bytes`.
/// ## With `encoding` feature
/// Decodes specified bytes using encoding, declared in the XML, if it was
/// declared there, or UTF-8 otherwise, and ignoring BOM if it is present
/// in the `bytes`.
/// ----
/// Returns an error in case of malformed sequences in the `bytes`.
/// Like [`decode`][Self::decode] but using a pre-allocated buffer.
decode_cow/// Decodes the `Cow` buffer, preserves the lifetime
//! A module for wrappers that encode / decode data.
EscapeErrorAttrErrorNamespaceErrorSyntaxErrorInvalidBangMarkup/// The parser started to parse `<!`, but the input ended before it can recognize
/// anything.
UnclosedPIOrXmlDecl/// The parser started to parse processing instruction or XML declaration (`<?`),
/// but the input ended before the `?>` sequence was found.
UnclosedComment/// The parser started to parse comment (`<!--`) content, but the input ended
/// before the `-->` sequence was found.
UnclosedDoctype/// The parser started to parse DTD (`<!DOCTYPE`) content, but the input ended
/// before the closing `>` character was found.
UnclosedCData/// The parser started to parse `<![CDATA[` content, but the input ended
/// before the `]]>` sequence was found.
UnclosedTag/// The parser started to parse tag content, but the input ended
/// An error returned if parsed document does not correspond to the XML grammar,
/// for example, a tag opened by `<` not closed with `>`. This error does not
/// represent invalid XML constructs, for example, tags `<>` and `</>` a well-formed
/// from syntax point-of-view.
MissingDeclVersion/// A `version` attribute was not found in an XML declaration or is not the
/// first attribute.
/// According to the [specification], the XML declaration (`<?xml ?>`) MUST contain
/// a `version` attribute and it MUST be the first attribute. This error indicates,
/// that the declaration does not contain attributes at all (if contains `None`)
/// or either `version` attribute is not present or not the first attribute in
/// the declaration. In the last case it contains the name of the found attribute.
/// [specification]: https://www.w3.org/TR/xml11/#sec-prolog-dtd
MissingDoctypeName/// A document type definition (DTD) does not contain a name of a root element.
/// According to the [specification], document type definition (`<!DOCTYPE foo>`)
/// MUST contain a name which defines a document type (`foo`). If that name
/// is missed, this error is returned.
/// [specification]: https://www.w3.org/TR/xml11/#NT-doctypedecl
/// The end tag was not found during reading of a sub-tree of elements due to
/// encountering an EOF from the underlying reader. This error is returned from
/// [`Reader::read_to_end`].
/// [`Reader::read_to_end`]: crate::reader::Reader::read_to_end
UnmatchedEndTag/// The specified end tag was encountered without corresponding open tag at the
/// same level of hierarchy
/// Name of open tag, that is expected to be closed
/// Name of actually closed tag
MismatchedEndTag/// The specified end tag does not match the start tag at that nesting level.
DoubleHyphenInComment/// A comment contains forbidden double-hyphen (`--`) sequence inside.
/// According to the [specification], for compatibility, comments MUST NOT contain
/// double-hyphen (`--`) sequence, in particular, they cannot end by `--->`.
/// The quick-xml by default does not check that, because this restriction is
/// mostly artificial, but you can enable it in the [configuration].
/// [specification]: https://www.w3.org/TR/xml11/#sec-comments
/// [configuration]: crate::reader::Config::check_comments
/// An error returned if parsed document is not [well-formed], for example,
/// an opened tag is not closed before end of input.
/// Those errors are not fatal: after encountering an error you can continue
/// parsing the document.
/// [well-formed]: https://www.w3.org/TR/xml11/#dt-wellformed
/// XML document cannot be read from underlying source.
/// Contains the reference-counted I/O error to make the error type `Clone`able.
/// The document does not corresponds to the XML grammar.
IllFormed/// The document is not [well-formed](https://www.w3.org/TR/xml11/#dt-wellformed).
InvalidAttr/// Attribute parsing error
/// Encoding error
/// Escape error
Namespace/// Parsed XML has some namespace-related problems
/// The error type used by this crate.
missed_end/// Creates a new `Error::Io` from the given error
/// Creates a new `Error::Syntax` from the given error
/// Creates a new `Error::IllFormed` from the given error
/// Creates a new `Error::EncodingError` from the given error
/// Creates a new `Error::EscapeError` from the given error
/// A specialized `Result` type where the error is hard-wired to [`Error`].
//! Error management module
ParseCharRefErrorUnexpectedSign/// Number contains sign character (`+` or `-`) which is not allowed.
InvalidNumber/// Number cannot be parsed due to non-number characters or a numeric overflow.
InvalidCodepoint/// Character reference represents not a valid unicode codepoint.
IllegalCharacter/// Character reference expanded to a not permitted character for an XML.
/// Currently, only `0x0` character produces this error.
/// Error of parsing character reference (`&#<dec-number>;` or `&#x<hex-number>;`).
UnrecognizedEntity/// Referenced entity in unknown to the parser.
UnterminatedEntity/// Cannot find `;` after `&`
InvalidCharRef/// Attempt to parse character reference (`&#<dec-number>;` or `&#x<hex-number>;`)
/// was unsuccessful, not all characters are decimal or hexadecimal numbers.
/// Error for XML escape / unescape.
/// Escapes an `&str` and replaces all xml special characters (`<`, `>`, `&`, `'`, `"`)
/// with their corresponding xml escaped value.
/// This function performs following replacements:
/// | Character | Replacement
/// |-----------|------------
/// | `<`       | `&lt;`
/// | `>`       | `&gt;`
/// | `&`       | `&amp;`
/// | `'`       | `&apos;`
/// | `"`       | `&quot;`
partial_escape/// Escapes an `&str` and replaces xml special characters (`<`, `>`, `&`)
/// Should only be used for escaping text content. In XML text content, it is allowed
/// (though not recommended) to leave the quote special characters `"` and `'` unescaped.
minimal_escape/// XML standard [requires] that only `<` and `&` was escaped in text content or
/// attribute value. All other characters not necessary to be escaped, although
/// for compatibility with SGML they also should be escaped. Practically, escaping
/// only those characters is enough.
/// [requires]: https://www.w3.org/TR/xml11/#syntax
_escape/// Escapes an `&str` and replaces a subset of xml special characters (`<`, `>`,
/// `&`, `'`, `"`) with their corresponding xml escaped value.
/// Unescape an `&str` and replaces all xml escaped characters (`&...;`) into
/// their corresponding value.
/// If feature [`escape-html`] is enabled, then recognizes all [HTML5 escapes].
/// [`escape-html`]: ../index.html#escape-html
/// [HTML5 escapes]: https://dev.w3.org/html5/html-author/charref
'entityunescape_with// the lifetime of the output comes from a capture or is `'static`
/// their corresponding value, using a resolver function for custom entities.
/// Predefined entities will be resolved _after_ trying to resolve with `resolve_entity`,
/// which allows you to override default behavior which required in some XML dialects.
/// Character references (`&#hh;`) cannot be overridden, they are resolved before
/// calling `resolve_entity`.
/// Note, that entities will not be resolved recursively. In order to satisfy the
/// XML [requirements] you should unescape nested entities by yourself.
/// use quick_xml::escape::resolve_xml_entity;
/// # use quick_xml::escape::unescape_with;
/// let override_named_entities = |entity: &str| match entity {
///     // Override standard entities
///     "lt" => Some("FOO"),
///     "gt" => Some("BAR"),
///     // Resolve custom entities
///     "baz" => Some("&lt;"),
///     // Delegate other entities to the default implementation
///     _ => resolve_xml_entity(entity),
/// assert_eq!(
///     unescape_with("&amp;&lt;test&gt;&baz;", override_named_entities).unwrap(),
///     "&FOOtestBAR&lt;"
/// [requirements]: https://www.w3.org/TR/xml11/#intern-replacement
/// Resolves predefined XML entities or all HTML5 entities depending on the feature
/// [`escape-html`](https://docs.rs/quick-xml/latest/quick_xml/#escape-html).
/// Behaves like [`resolve_xml_entity`] if feature is not enabled and as
/// [`resolve_html5_entity`] if enabled.
resolve_xml_entity/// Resolves predefined XML entities. If specified entity is not a predefined XML
/// entity, `None` is returned.
/// The complete list of predefined entities are defined in the [specification].
/// # use quick_xml::escape::resolve_xml_entity;
/// assert_eq!(resolve_xml_entity("lt"), Some("<"));
/// assert_eq!(resolve_xml_entity("gt"), Some(">"));
/// assert_eq!(resolve_xml_entity("amp"), Some("&"));
/// assert_eq!(resolve_xml_entity("apos"), Some("'"));
/// assert_eq!(resolve_xml_entity("quot"), Some("\""));
/// assert_eq!(resolve_xml_entity("foo"), None);
/// [specification]: https://www.w3.org/TR/xml11/#sec-predefined-ent
//! Manage xml character escapes
XmlResultLocalName/// The key to uniquely define the attribute.
/// If [`Attributes::with_checks`] is turned off, the key might not be unique.
/// The raw value of the attribute.
/// A struct representing a key/value XML attribute.
/// Field `value` stores raw bytes, possibly containing escape-sequences. Most users will likely
/// want to access the value using one of the [`unescape_value`] and [`decode_and_unescape_value`]
/// functions.
/// [`unescape_value`]: Self::unescape_value
/// [`decode_and_unescape_value`]: Self::decode_and_unescape_value
unescape_value/// Decodes using UTF-8 then unescapes the value.
/// This is normally the value you are interested in. Escape sequences such as `&gt;` are
/// replaced with their unescaped equivalents such as `>`.
/// This will allocate if the value contains any escape sequences.
/// See also [`unescape_value_with()`](Self::unescape_value_with)
/// This method is available only if [`encoding`] feature is **not** enabled.
/// [`encoding`]: ../../index.html#encoding
unescape_value_with/// Decodes using UTF-8 then unescapes the value, using custom entities.
/// A fallback resolver for additional custom entities can be provided via
/// `resolve_entity`.
/// See also [`unescape_value()`](Self::unescape_value)
decode_and_unescape_value/// Decodes then unescapes the value.
/// This will allocate if the value contains any escape sequences or in
/// non-UTF-8 encoding.
decode_and_unescape_value_with/// Decodes then unescapes the value with custom entities.
/// If attribute value [represents] valid boolean values, returns `Some`, otherwise returns `None`.
/// The valid boolean representations are only `"true"`, `"false"`, `"1"`, and `"0"`.
/// use quick_xml::events::attributes::Attribute;
/// let attr = Attribute::from(("attr", "false"));
/// assert_eq!(attr.as_bool(), Some(false));
/// let attr = Attribute::from(("attr", "0"));
/// let attr = Attribute::from(("attr", "true"));
/// assert_eq!(attr.as_bool(), Some(true));
/// let attr = Attribute::from(("attr", "1"));
/// let attr = Attribute::from(("attr", "bot bool"));
/// assert_eq!(attr.as_bool(), None);
/// [represents]: https://www.w3.org/TR/xmlschema11-2/#boolean
/// Creates new attribute from raw bytes.
/// Does not apply any transformation to both key and value.
/// let features = Attribute::from(("features".as_bytes(), "Bells &amp; whistles".as_bytes()));
/// assert_eq!(features.value, "Bells &amp; whistles".as_bytes());
/// Creates new attribute from text representation.
/// Key is stored as-is, but the value will be escaped.
/// let features = Attribute::from(("features", "Bells & whistles"));
/// # use std::borrow::Cow;
/// use pretty_assertions::assert_eq;
/// let features = Attribute::from(("features", Cow::Borrowed("Bells & whistles")));
/// Slice of `BytesStart` corresponding to attributes
/// Iterator state, independent from the actual source of bytes
/// Iterator over XML attributes.
/// Yields `Result<Attribute>`. An `Err` will be yielded if an attribute is malformed or duplicated.
/// The duplicate check can be turned off by calling [`with_checks(false)`].
/// [`with_checks(false)`]: Self::with_checks
/// Internal constructor, used by `BytesStart`. Supplies data in reader's encoding
/// Creates a new attribute iterator from a buffer.
/// Creates a new attribute iterator from a buffer, allowing HTML attribute syntax.
with_checks/// Changes whether attributes should be checked for uniqueness.
/// The XML specification requires attribute keys in the same element to be unique. This check
/// can be disabled to improve performance slightly.
/// (`true` by default)
has_nil/// Checks if the current tag has a [`xsi:nil`] attribute. This method ignores any errors in
/// attributes.
/// use quick_xml::events::Event;
/// use quick_xml::name::QName;
/// use quick_xml::reader::NsReader;
/// let mut reader = NsReader::from_str("
///     <root xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
///         <true xsi:nil='true'/>
///         <false xsi:nil='false'/>
///         <none/>
///         <non-xsi xsi:nil='true' xmlns:xsi='namespace'/>
///         <unbound-nil nil='true' xmlns='http://www.w3.org/2001/XMLSchema-instance'/>
///         <another-xmlns f:nil='true' xmlns:f='http://www.w3.org/2001/XMLSchema-instance'/>
/// ");
/// reader.config_mut().trim_text(true);
/// macro_rules! check {
///     ($reader:expr, $name:literal, $value:literal) => {
///         let event = match $reader.read_event().unwrap() {
///             Event::Empty(e) => e,
///             e => panic!("Unexpected event {:?}", e),
///         };
///         assert_eq!(
///             (event.name(), event.attributes().has_nil(&$reader)),
///             (QName($name.as_bytes()), $value),
///         );
///     };
/// let root = match reader.read_event().unwrap() {
///     Event::Start(e) => e,
///     e => panic!("Unexpected event {:?}", e),
/// assert_eq!(root.attributes().has_nil(&reader), false);
/// // definitely true
/// check!(reader, "true",          true);
/// // definitely false
/// check!(reader, "false",         false);
/// // absence of the attribute means that attribute is not set
/// check!(reader, "none",          false);
/// // attribute not bound to the correct namespace
/// check!(reader, "non-xsi",       false);
/// // attributes without prefix not bound to any namespace
/// check!(reader, "unbound-nil",   false);
/// // prefix can be any while it is bound to the correct namespace
/// check!(reader, "another-xmlns", true);
ExpectedEq/// Attribute key was not followed by `=`, position relative to the start of
/// the owning tag is provided.
/// Example of input that raises this error:
/// <tag key another="attribute"/>
/// <!--     ^~~ error position, recovery position (8) -->
/// This error can be raised only when the iterator is in XML mode.
ExpectedValue/// Attribute value was not found after `=`, position relative to the start
/// of the owning tag is provided.
/// <tag key = />
/// <!--       ^~~ error position, recovery position (10) -->
/// This error can be returned only for the last attribute in the list,
/// because otherwise any content after `=` will be threated as a value.
/// The XML
/// <tag key = another-key = "value"/>
/// <!--                   ^ ^- recovery position (24) -->
/// <!--                   '~~ error position (22) -->
/// will be treated as `Attribute { key = b"key", value = b"another-key" }`
/// and or [`Attribute`] is returned, or [`AttrError::UnquotedValue`] is raised,
/// depending on the parsing mode.
UnquotedValue/// Attribute value is not quoted, position relative to the start of the
/// owning tag is provided.
/// <tag key = value />
/// <!--       ^    ^~~ recovery position (15) -->
/// <!--       '~~ error position (10) -->
ExpectedQuote/// Attribute value was not finished with a matching quote, position relative
/// to the start of owning tag and a quote is provided. That position is always
/// a last character in the tag content.
/// <tag key = "value  />
/// <tag key = 'value  />
/// <!--               ^~~ error position, recovery position (18) -->
/// because all input was consumed during scanning for a quote.
Duplicated/// An attribute with the same name was already encountered. Two parameters
/// define (1) the error position relative to the start of the owning tag
/// for a new attribute and (2) the start position of a previously encountered
/// attribute with the same name.
/// <tag key = 'value'  key="value2" attr3='value3' />
/// <!-- ^              ^            ^~~ recovery position (32) -->
/// <!-- |              '~~ error position (19) -->
/// <!-- '~~ previous position (4) -->
/// This error is returned only when [`Attributes::with_checks()`] is set
/// to `true` (that is default behavior).
/// Errors that can be raised during parsing attributes.
/// Recovery position in examples shows the position from which parsing of the
/// next attribute will be attempted.
DoubleQ/// Attribute with value enclosed in double quotes (`"`). Attribute key and
/// value provided. This is a canonical XML-style attribute.
SingleQ/// Attribute with value enclosed in single quotes (`'`). Attribute key and
/// value provided. This is an XML-style attribute.
Unquoted/// Attribute with value not enclosed in quotes. Attribute key and value
/// provided. This is HTML-style attribute, it can be returned in HTML-mode
/// parsing only. In an XML mode [`AttrError::UnquotedValue`] will be raised
/// instead.
/// Attribute value can be invalid according to the [HTML specification],
/// in particular, it can contain `"`, `'`, `=`, `<`, and <code>&#96;</code>
/// characters. The absence of the `>` character is nevertheless guaranteed,
/// since the parser extracts [events] based on them even before the start
/// of parsing attributes.
/// [HTML specification]: https://html.spec.whatwg.org/#unquoted
/// [events]: crate::events::Event::Start
/// Attribute without value. Attribute key provided. This is HTML-style attribute,
/// it can be returned in HTML-mode parsing only. In XML mode
/// [`AttrError::ExpectedEq`] will be raised instead.
/// A struct representing a key/value XML or HTML [attribute].
/// [attribute]: https://www.w3.org/TR/xml11/#NT-Attribute
/// Maps an `Attr<T>` to `Attr<U>` by applying a function to a contained key and value.
/// Returns the key value
/// Returns the attribute value. For [`Self::Empty`] variant an empty slice
/// is returned according to the [HTML specification].
/// [HTML specification]: https://www.w3.org/TR/2012/WD-html-markup-20120329/syntax.html#syntax-attr-empty
/// Unpacks attribute key and value into tuple of this two elements.
/// `None` value element is returned only for [`Attr::Empty`] variant.
AttrResult/// Iteration finished, iterator will return `None` to all [`IterState::next`]
/// requests.
/// The last attribute returned was deserialized successfully. Contains an
/// offset from which next attribute should be searched.
SkipValue/// The last attribute returns [`AttrError::UnquotedValue`], offset pointed
/// to the beginning of the value. Recover should skip a value
SkipEqValue/// The last attribute returns [`AttrError::Duplicated`], offset pointed to
/// the equal (`=`) sign. Recover should skip it and a value
/// Iteration state that determines what actions should be done before the
/// actual parsing of the next attribute
/// If `true`, enables ability to parse unquoted values and key-only (empty)
/// attributes
check_duplicates/// If `true`, checks for duplicate names
/// If `check_duplicates` is set, contains the ranges of already parsed attribute
/// names. We store a ranges instead of slices to able to report a previous
/// attribute position
/// External iterator over spans of attribute key and value
recover/// Recover from an error that could have been made on a previous step.
/// Returns an offset from which parsing should continue.
/// If there no input left, returns `None`.
skip_value/// Skip all characters up to first space symbol or end-of-input
skip_eq_valuecheck_for_duplicateskey_only/// - `slice`: content of the tag, used for checking for duplicates
/// - `key`: Range of key in slice, if iterator in HTML mode
/// - `offset`: Position of error if iterator in XML mode
double_qsingle_qsingle_quoted/// Attribute have a value enclosed in single quotes
double_quoted/// Attribute have a value enclosed in double quotes
unquoted/// Attribute have a value, not enclosed in quotes
/// Only attribute key is present
key_start_invalid/// Key is started with an invalid symbol (a single quote in this test).
/// Because we do not check validity of keys and values during parsing,
/// that invalid attribute will be returned
key_contains_invalid/// Key contains an invalid symbol (an ampersand in this test).
missed_value/// Attribute value is missing after `=`
/// Checked attribute is the single attribute
/// Attribute value is missing after `=`.
/// Checked attribute is the first attribute in the list of many attributes
sparsed/// Copy of single, but with additional spaces in markup
with_checkwithout_check/// Check for duplicated names is disabled
duplicated/// Checks that duplicated attributes correctly reported and recovering is
/// possible after that
mixed_quotexml/// Checks, how parsing of XML-style attributes works. Each attribute should
/// have a value, enclosed in single or double quotes.
/// Checks, how parsing of HTML-style attributes works. Each attribute can be
/// in three forms:
/// - XML-like: have a value, enclosed in single or double quotes
/// - have a value, do not enclosed in quotes
/// - without value, key only
//! Xml Attributes module
//! Provides an iterator over attributes key/value pairs
trim_xml_endtrim_xml_startwrite_cow_string/// content of the element, before any utf8 conversion
/// end of the element name, the name starts at that the start of `buf`
/// Opening tag data (`Event::Start`), with optional attributes: `<name attr="value">`.
/// The name can be accessed using the [`name`] or [`local_name`] methods.
/// An iterator over the attributes is returned by the [`attributes`] method.
/// This event implements `Deref<Target = [u8]>`. The `deref()` implementation
/// returns the content of this event between `<` and `>` or `/>`:
/// # use quick_xml::events::{BytesStart, Event};
/// # use quick_xml::reader::Reader;
/// // Remember, that \ at the end of string literal strips
/// // all space characters to the first non-space character
/// let mut reader = Reader::from_str("\
///     <element a1 = 'val1' a2=\"val2\" />\
///     <element a1 = 'val1' a2=\"val2\" >"
/// let content = "element a1 = 'val1' a2=\"val2\" ";
/// let event = BytesStart::from_content(content, 7);
/// assert_eq!(reader.read_event().unwrap(), Event::Empty(event.borrow()));
/// assert_eq!(reader.read_event().unwrap(), Event::Start(event.borrow()));
/// // deref coercion of &BytesStart to &[u8]
/// assert_eq!(&event as &[u8], content.as_bytes());
/// // AsRef<[u8]> for &T + deref coercion
/// assert_eq!(event.as_ref(), content.as_bytes());
/// [`local_name`]: Self::local_name
/// [`attributes`]: Self::attributes
/// Internal constructor, used by `Reader`. Supplies data in reader's encoding
/// Creates a new `BytesStart` from the given name.
/// # Warning
/// `name` must be a valid name.
from_content/// Creates a new `BytesStart` from the given content (name + attributes).
/// `&content[..name_len]` must be a valid name, and the remainder of `content`
/// must be correctly-formed attributes. Neither are checked, it is possible
/// to generate invalid XML if `content` or `name_len` are incorrect.
/// Converts the event into an owned event.
/// Converts the event into an owned event without taking ownership of Event
/// Converts the event into a borrowed event. Most useful when paired with [`to_end`].
/// use quick_xml::events::{BytesStart, Event};
/// # use quick_xml::writer::Writer;
/// # use quick_xml::Error;
/// struct SomeStruct<'a> {
///     attrs: BytesStart<'a>,
///     // ...
/// # impl<'a> SomeStruct<'a> {
/// # fn example(&self) -> Result<(), Error> {
/// # let mut writer = Writer::new(Vec::new());
/// writer.write_event(Event::Start(self.attrs.borrow()))?;
/// // ...
/// writer.write_event(Event::End(self.attrs.to_end()))?;
/// # Ok(())
/// # }}
/// [`to_end`]: Self::to_end
to_end/// Creates new paired close tag
/// Gets the undecoded raw tag name, as present in the input stream.
local_name/// Gets the undecoded raw local tag name (excluding namespace) as present
/// in the input stream.
/// All content up to and including the first `:` character is removed from the tag name.
/// Edit the name of the BytesStart in-place
/// Consumes `self` and yield a new `BytesStart` with additional attributes from an iterator.
/// The yielded items must be convertible to [`Attribute`] using `Into`.
extend_attributes/// Add additional attributes to this tag using an iterator.
push_attribute/// Adds an attribute to this element.
/// Remove all attributes from the ByteStart
/// Returns an iterator over the attributes of this tag.
html_attributes/// Returns an iterator over the HTML-like attributes of this tag (no mandatory quotes or `=`).
attributes_raw/// Gets the undecoded raw string with the attributes of this tag as a `&[u8]`,
/// including the whitespace after the tag name if there is any.
try_get_attribute/// Try to get an attribute
push_attrpush_newline/// Adds new line in existing element
push_indent/// Adds indentation bytes in existing element
/// Attribute-related methods
/// Closing tag data (`Event::End`): `</name>`.
/// returns the content of this event between `</` and `>`.
/// Note, that inner text will not contain `>` character inside:
/// # use quick_xml::events::{BytesEnd, Event};
/// let mut reader = Reader::from_str(r#"<element></element a1 = 'val1' a2="val2" >"#);
/// // Note, that this entire string considered as a .name()
/// let event = BytesEnd::new(content);
/// reader.config_mut().trim_markup_names_in_closing_tags = false;
/// reader.config_mut().check_end_names = false;
/// reader.read_event().unwrap(); // Skip `<element>`
/// assert_eq!(reader.read_event().unwrap(), Event::End(event.borrow()));
/// assert_eq!(event.name().as_ref(), content.as_bytes());
/// // deref coercion of &BytesEnd to &[u8]
/// Creates a new `BytesEnd` borrowing a slice.
/// Converts the event into a borrowed event.
/// Escaped then encoded content of the event. Content is encoded in the XML
/// document encoding when event comes from the reader and should be in the
/// document encoding when event passed to the writer
/// Encoding in which the `content` is stored inside the event
/// Data from various events (most notably, `Event::Text`) that stored in XML
/// in escaped form. Internally data is stored in escaped form.
/// returns the content of this event. In case of comment this is everything
/// between `<!--` and `-->` and the text of comment will not contain `-->` inside.
/// In case of DTD this is everything between `<!DOCTYPE` + spaces and closing `>`
/// (i.e. in case of DTD the first character is never space):
/// # use quick_xml::events::{BytesText, Event};
///     <!DOCTYPE comment or text >\
///     comment or text \
///     <!--comment or text -->"
/// let content = "comment or text ";
/// let event = BytesText::new(content);
/// assert_eq!(reader.read_event().unwrap(), Event::DocType(event.borrow()));
/// assert_eq!(reader.read_event().unwrap(), Event::Text(event.borrow()));
/// assert_eq!(reader.read_event().unwrap(), Event::Comment(event.borrow()));
/// // deref coercion of &BytesText to &[u8]
/// Creates a new `BytesText` from an escaped byte sequence in the specified encoding.
from_escaped/// Creates a new `BytesText` from an escaped string.
/// Creates a new `BytesText` from a string. The string is expected not to
/// be escaped.
/// Ensures that all data is owned to extend the object's lifetime if
/// necessary.
/// Extracts the inner `Cow` from the `BytesText` event container.
/// Decodes then unescapes the content of the event.
/// Decodes then unescapes the content of the event with custom entities.
inplace_trim_start/// Removes leading XML whitespace bytes from text content.
/// Returns `true` if content is empty after that
inplace_trim_end/// Removes trailing XML whitespace bytes from text content.
/// CDATA content contains unescaped data from the reader. If you want to write them as a text,
/// [convert](Self::escape) it to [`BytesText`].
/// returns the content of this event between `<![CDATA[` and `]]>`.
/// Note, that inner text will not contain `]]>` sequence inside:
/// # use quick_xml::events::{BytesCData, Event};
/// let mut reader = Reader::from_str("<![CDATA[ CDATA section ]]>");
/// let content = " CDATA section ";
/// let event = BytesCData::new(content);
/// assert_eq!(reader.read_event().unwrap(), Event::CData(event.borrow()));
/// // deref coercion of &BytesCData to &[u8]
/// Creates a new `BytesCData` from a byte sequence in the specified encoding.
/// Creates a new `BytesCData` from a string.
/// `content` must not contain the `]]>` sequence. You can use
/// [`BytesCData::escaped`] to escape the content instead.
CDataIterator/// Creates an iterator of `BytesCData` from a string.
/// If a string contains `]]>`, it needs to be split into multiple `CDATA`
/// sections, splitting the `]]` and `>` characters, because the CDATA closing
/// sequence cannot be escaped. This iterator yields a `BytesCData` instance
/// for each of those sections.
/// # use quick_xml::events::BytesCData;
/// let content = "";
/// let cdata = BytesCData::escaped(content).collect::<Vec<_>>();
/// assert_eq!(cdata, &[BytesCData::new("")]);
/// let content = "Certain tokens like ]]> can be difficult and <invalid>";
/// assert_eq!(cdata, &[
///     BytesCData::new("Certain tokens like ]]"),
///     BytesCData::new("> can be difficult and <invalid>"),
/// ]);
/// let content = "foo]]>bar]]>baz]]>quux";
///     BytesCData::new("foo]]"),
///     BytesCData::new(">bar]]"),
///     BytesCData::new(">baz]]"),
///     BytesCData::new(">quux"),
/// Extracts the inner `Cow` from the `BytesCData` event container.
/// Converts this CDATA content to an escaped version, that can be written
/// as an usual text in XML.
/// In XML text content, it is allowed (though not recommended) to leave
/// the quote special characters `"` and `'` unescaped.
/// as an usual text in XML. This method escapes only those characters that
/// must be escaped according to the [specification].
/// [specification]: https://www.w3.org/TR/xml11/#syntax
/// Decodes the raw input byte content of the CDATA section into a string,
/// without performing XML entity escaping.
/// When this event produced by the XML reader, it uses the encoding information
/// associated with that reader to interpret the raw bytes contained within this
/// CDATA event.
/// The unprocessed data which should be emitted as `BytesCData` events.
/// At each iteration, the processed data is cut from this slice.
/// Iterator over `CDATA` sections in a string.
/// This iterator is created by the [`BytesCData::escaped`] method.
BytesPI/// [Processing instructions][PI] (PIs) allow documents to contain instructions for applications.
/// returns the content of this event between `<?` and `?>`.
/// Note, that inner text will not contain `?>` sequence inside:
/// # use quick_xml::events::{BytesPI, Event};
/// let mut reader = Reader::from_str("<?processing instruction >:-<~ ?>");
/// let content = "processing instruction >:-<~ ";
/// let event = BytesPI::new(content);
/// assert_eq!(reader.read_event().unwrap(), Event::PI(event.borrow()));
/// // deref coercion of &BytesPI to &[u8]
/// [PI]: https://www.w3.org/TR/xml11/#sec-pi
/// Creates a new `BytesPI` from a byte sequence in the specified encoding.
/// Creates a new `BytesPI` from a string.
/// `content` must not contain the `?>` sequence.
/// Extracts the inner `Cow` from the `BytesPI` event container.
/// A target used to identify the application to which the instruction is directed.
/// use quick_xml::events::BytesPI;
/// let instruction = BytesPI::new(r#"xml-stylesheet href="style.css""#);
/// assert_eq!(instruction.target(), b"xml-stylesheet");
/// Content of the processing instruction. Contains everything between target
/// name and the end of the instruction. A direct consequence is that the first
/// character is always a space character.
/// assert_eq!(instruction.content(), br#" href="style.css""#);
/// A view of the processing instructions' content as a list of key-value pairs.
/// Key-value pairs are used in some processing instructions, for example in
/// `<?xml-stylesheet?>`.
/// Returned iterator does not validate attribute values as may required by
/// target's rules. For example, it doesn't check that substring `?>` is not
/// present in the attribute value. That shouldn't be the problem when event
/// is produced by the reader, because reader detects end of processing instruction
/// by the first `?>` sequence, as required by the specification, and therefore
/// this sequence cannot appear inside it.
/// use std::borrow::Cow;
/// for attr in instruction.attributes() {
///     assert_eq!(attr, Ok(Attribute {
///         key: QName(b"href"),
///         value: Cow::Borrowed(b"style.css"),
///     }));
BytesDecl/// An XML declaration (`Event::Decl`).
/// [W3C XML 1.1 Prolog and Document Type Declaration](http://w3.org/TR/xml11/#sec-prolog-dtd)
/// # use quick_xml::events::{BytesDecl, BytesStart, Event};
/// let mut reader = Reader::from_str("<?xml version = '1.0' ?>");
/// let content = "xml version = '1.0' ";
/// let event = BytesDecl::from_start(BytesStart::from_content(content, 3));
/// assert_eq!(reader.read_event().unwrap(), Event::Decl(event.borrow()));
/// // deref coercion of &BytesDecl to &[u8]
/// Constructs a new `XmlDecl` from the (mandatory) _version_ (should be `1.0` or `1.1`),
/// the optional _encoding_ (e.g., `UTF-8`) and the optional _standalone_ (`yes` or `no`)
/// attribute.
/// Does not escape any of its inputs. Always uses double quotes to wrap the attribute values.
/// The caller is responsible for escaping attribute values. Shouldn't usually be relevant since
/// the double quote character is not allowed in any of the attribute values.
from_start/// Creates a `BytesDecl` from a `BytesStart`
/// Gets xml version, excluding quotes (`'` or `"`).
/// According to the [grammar], the version *must* be the first thing in the declaration.
/// This method tries to extract the first thing in the declaration and return it.
/// In case of multiple attributes value of the first one is returned.
/// If version is missed in the declaration, or the first thing is not a version,
/// [`IllFormedError::MissingDeclVersion`] will be returned.
/// use quick_xml::errors::{Error, IllFormedError};
/// use quick_xml::events::{BytesDecl, BytesStart};
/// // <?xml version='1.1'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" version='1.1'", 0));
/// assert_eq!(decl.version().unwrap(), b"1.1".as_ref());
/// // <?xml version='1.0' version='1.1'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" version='1.0' version='1.1'", 0));
/// assert_eq!(decl.version().unwrap(), b"1.0".as_ref());
/// // <?xml encoding='utf-8'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" encoding='utf-8'", 0));
/// match decl.version() {
///     Err(Error::IllFormed(IllFormedError::MissingDeclVersion(Some(key)))) => assert_eq!(key, "encoding"),
///     _ => assert!(false),
/// // <?xml encoding='utf-8' version='1.1'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" encoding='utf-8' version='1.1'", 0));
/// // <?xml?>
/// let decl = BytesDecl::from_start(BytesStart::from_content("", 0));
///     Err(Error::IllFormed(IllFormedError::MissingDeclVersion(None))) => {},
/// [grammar]: https://www.w3.org/TR/xml11/#NT-XMLDecl
/// Gets xml encoding, excluding quotes (`'` or `"`).
/// Although according to the [grammar] encoding must appear before `"standalone"`
/// and after `"version"`, this method does not check that. The first occurrence
/// of the attribute will be returned even if there are several. Also, method does
/// not restrict symbols that can forming the encoding, so the returned encoding
/// name may not correspond to the grammar.
/// use quick_xml::Error;
/// assert!(decl.encoding().is_none());
/// match decl.encoding() {
///     Some(Ok(Cow::Borrowed(encoding))) => assert_eq!(encoding, b"utf-8"),
/// // <?xml encoding='something_WRONG' encoding='utf-8'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" encoding='something_WRONG' encoding='utf-8'", 0));
///     Some(Ok(Cow::Borrowed(encoding))) => assert_eq!(encoding, b"something_WRONG"),
standalone/// Gets xml standalone, excluding quotes (`'` or `"`).
/// Although according to the [grammar] standalone flag must appear after `"version"`
/// and `"encoding"`, this method does not check that. The first occurrence of the
/// attribute will be returned even if there are several. Also, method does not
/// restrict symbols that can forming the value, so the returned flag name may not
/// correspond to the grammar.
/// assert!(decl.standalone().is_none());
/// // <?xml standalone='yes'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" standalone='yes'", 0));
/// match decl.standalone() {
///     Some(Ok(Cow::Borrowed(encoding))) => assert_eq!(encoding, b"yes"),
/// // <?xml standalone='something_WRONG' encoding='utf-8'?>
/// let decl = BytesDecl::from_start(BytesStart::from_content(" standalone='something_WRONG' encoding='utf-8'", 0));
///     Some(Ok(Cow::Borrowed(flag))) => assert_eq!(flag, b"something_WRONG"),
/// Empty element tag (with attributes) `<tag attr="value" />`.
/// Comment `<!-- ... -->`.
Decl/// XML declaration `<?xml ...?>`.
/// Processing instruction `<?...?>`.
/// Event emitted by [`Reader::read_event_into`].
/// [`Reader::read_event_into`]: crate::reader::Reader::read_event_into
/// Converts the event to an owned version, untied to the lifetime of
/// buffer used when reading but incurring a new, separate allocation.
str_cow_to_bytestrim_cowbytestart_createbytestart_set_namebytestart_clear_attributes//! Defines zero-copy XML events used throughout this library.
//! A XML event often represents part of a XML element.
//! They occur both during reading and writing and are
//! usually used with the stream-oriented API.
//! For example, the XML element
//! <name attr="value">Inner text</name>
//! consists of the three events `Start`, `Text` and `End`.
//! They can also represent other parts in an XML document like the
//! XML declaration. Each Event usually contains further information,
//! like the tag name, the attribute or the inner text.
//! See [`Event`] for a list of all possible events.
//! # Reading
//! When reading a XML stream, the events are emitted by [`Reader::read_event`]
//! and [`Reader::read_event_into`]. You must listen
//! for the different types of events you are interested in.
//! See [`Reader`] for further information.
//! # Writing
//! When writing the XML document, you must create the XML element
//! by constructing the events it consists of and pass them to the writer
//! sequentially.
//! See [`Writer`] for further information.
//! [`Reader::read_event`]: crate::reader::Reader::read_event
//! [`Reader::read_event_into`]: crate::reader::Reader::read_event_into
//! [`Reader`]: crate::reader::Reader
//! [`Writer`]: crate::writer::Writer
//! [`Event`]: crate::events::Event
"1024"/// Not an official API, public for integration tests
// reexports
ElementWriter//! High performance XML reader/writer.
//! # Description
//! quick-xml contains two modes of operation:
//! A streaming API based on the [StAX] model. This is suited for larger XML documents which
//! cannot completely read into memory at once.
//! The user has to explicitly _ask_ for the next XML event, similar to a database cursor.
//! This is achieved by the following two structs:
//! - [`Reader`]: A low level XML pull-reader where buffer allocation/clearing is left to user.
//! - [`Writer`]: A XML writer. Can be nested with readers if you want to transform XMLs.
//! Especially for nested XML elements, the user must keep track _where_ (how deep)
//! in the XML document the current event is located.
//! quick-xml contains optional support of asynchronous reading and writing using [tokio].
//! To get it enable the [`async-tokio`](#async-tokio) feature.
//! Furthermore, quick-xml also contains optional [Serde] support to directly
//! serialize and deserialize from structs, without having to deal with the XML events.
//! To get it enable the [`serialize`](#serialize) feature. Read more about mapping Rust types
//! to XML in the documentation of [`de`] module. Also check [`serde_helpers`]
//! module.
//! - For a reading example see [`Reader`]
//! - For a writing example see [`Writer`]
//! # Features
//! `quick-xml` supports the following features:
//! [StAX]: https://en.wikipedia.org/wiki/StAX
//! [tokio]: https://tokio.rs/
//! [Serde]: https://serde.rs/
//! [`de`]: ./de/index.html
// Enable feature requirements in the docs from 1.57
// See https://stackoverflow.com/questions/61417452
// docs.rs defines `docsrs` when building documentation
write_byte_stringUnknownPrefix/// Specified namespace prefix is unknown, cannot resolve namespace for it
InvalidXmlPrefixBind/// Attempts to bind the `xml` prefix to something other than `http://www.w3.org/XML/1998/namespace`.
/// `xml` prefix can be bound only to `http://www.w3.org/XML/1998/namespace`.
/// Contains the namespace to which `xml` tried to be bound.
InvalidXmlnsPrefixBind/// Attempts to bind the `xmlns` prefix.
/// `xmlns` prefix is always bound to `http://www.w3.org/2000/xmlns/` and cannot be bound
/// to any other namespace or even to `http://www.w3.org/2000/xmlns/`.
/// Contains the namespace to which `xmlns` tried to be bound.
InvalidPrefixForXml/// Attempts to bind some prefix (except `xml`) to `http://www.w3.org/XML/1998/namespace`.
/// Only `xml` prefix can be bound to `http://www.w3.org/XML/1998/namespace`.
/// Contains the prefix that is tried to be bound.
InvalidPrefixForXmlns/// Attempts to bind some prefix to `http://www.w3.org/2000/xmlns/`.
/// `http://www.w3.org/2000/xmlns/` cannot be bound to any prefix, even to `xmlns`.
/// Some namespace was invalid
/// A [qualified name] of an element or an attribute, including an optional
/// namespace [prefix](Prefix) and a [local name](LocalName).
/// [qualified name]: https://www.w3.org/TR/xml-names11/#dt-qualname
/// Converts this name to an internal slice representation.
/// Returns local part of this qualified name.
/// All content up to and including the first `:` character is removed from
/// # use quick_xml::name::QName;
/// let simple = QName(b"simple-name");
/// assert_eq!(simple.local_name().as_ref(), b"simple-name");
/// let qname = QName(b"namespace:simple-name");
/// assert_eq!(qname.local_name().as_ref(), b"simple-name");
/// Returns namespace part of this qualified name or `None` if namespace part
/// is not defined (symbol `':'` not found).
/// # use std::convert::AsRef;
/// assert_eq!(simple.prefix(), None);
/// let qname = QName(b"prefix:simple-name");
/// assert_eq!(qname.prefix().as_ref().map(|n| n.as_ref()), Some(b"prefix".as_ref()));
/// The same as `(qname.local_name(), qname.prefix())`, but does only one
/// lookup for a `':'` symbol.
as_namespace_bindingPrefixDeclaration/// If that `QName` represents `"xmlns"` series of names, returns `Some`,
/// otherwise `None` is returned.
/// # use quick_xml::name::{QName, PrefixDeclaration};
/// let qname = QName(b"xmlns");
/// assert_eq!(qname.as_namespace_binding(), Some(PrefixDeclaration::Default));
/// let qname = QName(b"xmlns:prefix");
/// assert_eq!(qname.as_namespace_binding(), Some(PrefixDeclaration::Named(b"prefix")));
/// // Be aware that this method does not check the validity of the prefix - it can be empty!
/// let qname = QName(b"xmlns:");
/// assert_eq!(qname.as_namespace_binding(), Some(PrefixDeclaration::Named(b"")));
/// let qname = QName(b"other-name");
/// assert_eq!(qname.as_namespace_binding(), None);
/// // https://www.w3.org/TR/xml-names11/#xmlReserved
/// let qname = QName(b"xmlns-reserved-name");
/// Returns the index in the name where prefix ended
/// A [local (unqualified) name] of an element or an attribute, i.e. a name
/// without [prefix](Prefix).
/// [local (unqualified) name]: https://www.w3.org/TR/xml-names11/#dt-localname
/// Creates `LocalName` from a [`QName`]
/// # use quick_xml::name::{LocalName, QName};
/// let local: LocalName = QName(b"unprefixed").into();
/// assert_eq!(local.as_ref(), b"unprefixed");
/// let local: LocalName = QName(b"some:prefix").into();
/// assert_eq!(local.as_ref(), b"prefix");
/// A [namespace prefix] part of the [qualified name](QName) of an element tag
/// or an attribute: a `prefix` in `<prefix:local-element-name>` or
/// `prefix:local-attribute-name="attribute value"`.
/// [namespace prefix]: https://www.w3.org/TR/xml-names11/#dt-prefix
/// Extracts internal slice
/// XML attribute binds a default namespace. Corresponds to `xmlns` in `xmlns="..."`
/// XML attribute binds a specified prefix to a namespace. Corresponds to a
/// `prefix` in `xmlns:prefix="..."`, which is stored as payload of this variant.
/// A namespace prefix declaration, `xmlns` or `xmlns:<name>`, as defined in
/// [XML Schema specification](https://www.w3.org/TR/xml-names11/#ns-decl)
/// A [namespace name] that is declared in a `xmlns[:prefix]="namespace name"`.
/// [namespace name]: https://www.w3.org/TR/xml-names11/#dt-NSName
/// Converts this namespace to an internal slice representation.
/// This is [non-normalized] attribute value, i.e. any entity references is
/// not expanded and space characters are not removed. This means, that
/// different byte slices, returned from this method, can represent the same
/// namespace and would be treated by parser as identical.
/// For example, if the entity **eacute** has been defined to be **é**,
/// the empty tags below all contain namespace declarations binding the
/// prefix `p` to the same [IRI reference], `http://example.org/rosé`.
/// <p:foo xmlns:p="http://example.org/rosé" />
/// <p:foo xmlns:p="http://example.org/ros&#xe9;" />
/// <p:foo xmlns:p="http://example.org/ros&#xE9;" />
/// <p:foo xmlns:p="http://example.org/ros&#233;" />
/// <p:foo xmlns:p="http://example.org/ros&eacute;" />
/// This is because XML entity references are expanded during attribute value
/// normalization.
/// [non-normalized]: https://www.w3.org/TR/xml11/#AVNormalize
/// [IRI reference]: https://datatracker.ietf.org/doc/html/rfc3987
//TODO: implement value normalization and use it when comparing namespaces
'nsResolveResultUnbound/// Qualified name does not contain prefix, and resolver does not define
/// default namespace, so name is not bound to any namespace
/// [`Prefix`] resolved to the specified namespace
/// Specified prefix was not found in scope
/// Result of [prefix] resolution which creates by [`NsReader::resolve_attribute`],
/// [`NsReader::resolve_element`], [`NsReader::read_resolved_event`] and
/// [`NsReader::read_resolved_event_into`] methods.
/// [prefix]: Prefix
/// [`NsReader::resolve_attribute`]: crate::reader::NsReader::resolve_attribute
/// [`NsReader::resolve_element`]: crate::reader::NsReader::resolve_element
/// [`NsReader::read_resolved_event`]: crate::reader::NsReader::read_resolved_event
/// [`NsReader::read_resolved_event_into`]: crate::reader::NsReader::read_resolved_event_into
/// Try to convert this result to an optional namespace and returns
/// [`NamespaceError::UnknownPrefix`] if this result represents unknown prefix
/// Index of the namespace in the buffer
/// Length of the prefix
/// * if greater than zero, then binds this namespace to the slice
///   `[start..start + prefix_len]` in the buffer.
/// * else defines the current default namespace.
/// The length of a namespace name (the URI) of this namespace declaration.
/// Name started just after prefix and extend for `value_len` bytes.
/// The XML standard [specifies] that an empty namespace value 'removes' a namespace declaration
/// for the extent of its scope. For prefix declarations that's not very interesting, but it is
/// vital for default namespace declarations. With `xmlns=""` you can revert back to the default
/// behaviour of leaving unqualified element names unqualified.
/// [specifies]: https://www.w3.org/TR/xml-names11/#scoping
/// Level of nesting at which this namespace was declared. The declaring element is included,
/// i.e., a declaration on the document root has `level = 1`.
/// This is used to pop the namespace when the element gets closed.
NamespaceEntry/// An entry that contains index into the buffer with namespace bindings.
/// Defines a mapping from *[namespace prefix]* to *[namespace name]*.
/// If prefix is empty, defines a *default namespace* binding that applies to
/// unprefixed element names (unprefixed attribute names do not bind to any
/// namespace and they processing is dependent on the element in which their
/// defined).
/// Get the namespace prefix, bound to this namespace declaration, or `None`,
/// if this declaration is for default namespace (`xmlns="..."`).
/// Gets the namespace name (the URI) slice out of namespace buffer
/// Returns `None` if namespace for this prefix was explicitly removed from
/// scope, using `xmlns[:prefix]=""`
/// Buffer that contains names of namespace prefixes (the part between `xmlns:`
/// and an `=`) and namespace values.
/// A stack of namespace bindings to prefixes that currently in scope
nesting_level/// The number of open tags at the moment. We need to keep track of this to know which namespace
/// declarations to remove when we encounter an `End` event.
NamespaceResolver/// A namespace management buffer.
/// Holds all internal logic to push/pop namespaces with their levels.
RESERVED_NAMESPACE_XML/// That constant define the one of [reserved namespaces] for the xml standard.
/// The prefix `xml` is by definition bound to the namespace name
/// `http://www.w3.org/XML/1998/namespace`. It may, but need not, be declared, and must not be
/// undeclared or bound to any other namespace name. Other prefixes must not be bound to this
/// namespace name, and it must not be declared as the default namespace.
/// [reserved namespaces]: https://www.w3.org/TR/xml-names11/#xmlReserved
RESERVED_NAMESPACE_XMLNS/// The prefix `xmlns` is used only to declare namespace bindings and is by definition bound
/// to the namespace name `http://www.w3.org/2000/xmlns/`. It must not be declared or
/// undeclared. Other prefixes must not be bound to this namespace name, and it must not be
///  declared as the default namespace. Element names must not have the prefix `xmlns`.
/// Begins a new scope and add to it all [namespace bindings] that found in
/// the specified start element.
/// [namespace binding]: https://www.w3.org/TR/xml-names11/#dt-NSDecl
/// Ends a top-most scope by popping all [namespace binding], that was added by
/// last call to [`Self::push()`].
/// Resolves a potentially qualified **element name** or **attribute name**
/// into (namespace name, local name).
/// *Qualified* names have the form `prefix:local-name` where the `prefix` is
/// defined on any containing XML element via `xmlns:prefix="the:namespace:uri"`.
/// The namespace prefix can be defined on the same element as the element or
/// attribute in question.
/// *Unqualified* attribute names do *not* inherit the current *default namespace*.
/// - `'n`: lifetime of an attribute or an element name
/// Finds a [namespace name] for a given qualified **element name**, borrow
/// it from the internal buffer.
/// Returns `None`, if:
/// - name is unqualified
/// - prefix not found in the current scope
/// - prefix was [unbound] using `xmlns:prefix=""`
/// [unbound]: https://www.w3.org/TR/xml-names11/#scoping
resolve_prefixmaybe_unknownPrefixIterbindings_cursor/// Iterator on the current declared prefixes.
/// See [`NsReader::prefixes`](crate::NsReader::prefixes) for documentation.
/// Basic tests that checks that basic resolver functionality is working
override_namespace/// Test adding a second level of namespaces, which replaces the previous binding
/// Test adding a second level of namespaces, which reset the previous binding
/// to not bound state by specifying an empty namespace name.
/// See <https://www.w3.org/TR/xml-names11/#scoping>
unprefixed/// Unprefixed attribute names (resolved with `false` flag) never have a namespace
/// according to <https://www.w3.org/TR/xml-names11/#defaulting>:
/// > A default namespace declaration applies to all unprefixed element names
/// > within its scope. Default namespace declarations do not apply directly
/// > to attribute names; the interpretation of unprefixed attributes is
/// > determined by the element on which they appear.
declared_prefixundeclared/// `xml` prefix are always defined, it is not required to define it explicitly.
rebound_to_correct_ns/// `xml` prefix can be declared but it must be bound to the value
/// `http://www.w3.org/XML/1998/namespace`
rebound_to_incorrect_ns/// `xml` prefix cannot be re-declared to another namespace
/// `xml` prefix cannot be unbound
other_prefix_bound_to_xml_namespace/// Other prefix cannot be bound to `xml` namespace
/// `xmlns` prefix are always defined, it is forbidden to define it explicitly
/// `xmlns` prefix cannot be re-declared event to its own namespace
/// `xmlns` prefix cannot be re-declared
/// `xmlns` prefix cannot be unbound
other_prefix_bound_to_xmlns_namespace/// Other prefix cannot be bound to `xmlns` namespace
xmlnsbuiltin_prefixes/// Tests for `xml` and `xmlns` built-in prefixes.
/// See <https://www.w3.org/TR/xml-names11/#xmlReserved>
undeclared_prefixprefix_and_local_name/// Checks how the QName is decomposed to a prefix and a local name
namespaces//! Module for handling names according to the W3C [Namespaces in XML 1.1 (Second Edition)][spec]
//! specification
//! [spec]: https://www.w3.org/TR/xml-names11
ElementParserOutside/// The initial state (inside element, but outside of attribute value).
/// Inside a single-quoted region (`'...'`).
/// Inside a double-quoted region (`"..."`).
/// A parser that search a `>` symbol in the slice outside of quoted regions.
/// The parser considers two quoted regions: a double-quoted (`"..."`) and
/// a single-quoted (`'...'`) region. Matches found inside those regions are not
/// considered as results. Each region starts and ends by its quote symbol,
/// which cannot be escaped (but can be encoded as XML character entity or named
/// entity. Anyway, that encoding does not contain literal quotes).
/// To use a parser create an instance of parser and [`feed`] data into it.
/// After successful search the parser will return [`Some`] with position of
/// found symbol. If search is unsuccessful, a [`None`] will be returned. You
/// typically would expect positive result of search, so that you should feed
/// new data until you get it.
/// NOTE: after successful match the parser does not returned to the initial
/// state and should not be used anymore. Create a new parser if you want to perform
/// new search.
/// use quick_xml::parser::{ElementParser, Parser};
/// let mut parser = ElementParser::default();
/// // Parse `<my-element  with = 'some > inside'>and the text follow...`
/// // splitted into three chunks
/// assert_eq!(parser.feed(b"<my-element"), None);
/// // ...get new chunk of data
/// assert_eq!(parser.feed(b" with = 'some >"), None);
/// // ...get another chunk of data
/// assert_eq!(parser.feed(b" inside'>and the text follow..."), Some(8));
/// //                       ^       ^
/// //                       0       8
/// [`feed`]: Self::feed()
/// Returns number of consumed bytes or `None` if `>` was not found in `bytes`.
eof_error//! Contains a parser for an XML element.
piPiParser/// Process new data and try to determine end of the parsed thing.
/// Returns position of the end of thing in `bytes` in case of successful search
/// and `None` otherwise.
/// - `bytes`: a slice to find the end of a thing.
///   Should contain text in ASCII-compatible encoding
/// Returns parse error produced by this parser in case of reaching end of
/// input without finding the end of a parsed thing.
/// Used to decouple reading of data from data source and parsing XML structure from it.
/// This is a state preserved between getting chunks of bytes from the reader.
/// This trait is implemented for every parser that processes piece of XML grammar.
//! Contains low-level parsers of different XML pieces.
/// A flag that indicates was the `bytes` in the previous attempt to find the
/// end ended with `?`.
/// A parser that search a `?>` sequence in the slice.
/// After successful search the parser will return [`Some`] with position where
/// processing instruction is ended (the position after `?>`). If search was
/// unsuccessful, a [`None`] will be returned. You typically would expect positive
/// result of search, so that you should feed new data until you get it.
/// use quick_xml::parser::{Parser, PiParser};
/// let mut parser = PiParser::default();
/// // Parse `<?instruction with = 'some > and ?' inside?>and the text follow...`
/// assert_eq!(parser.feed(b"<?instruction"), None);
/// assert_eq!(parser.feed(b" with = 'some > and ?"), None);
/// assert_eq!(parser.feed(b"' inside?>and the text follow..."), Some(9));
/// //                       ^        ^
/// //                       0        9
/// Determines the end position of a processing instruction in the provided slice.
/// Processing instruction ends on the first occurrence of `?>` which cannot be
/// escaped.
/// Returns position after the `?>` or `None` if such sequence was not found.
/// [Section 2.6]: Parameter entity references MUST NOT be recognized within
/// processing instructions, so parser do not search for them.
/// - `bytes`: a slice to find the end of a processing instruction.
/// [Section 2.6]: https://www.w3.org/TR/xml11/#sec-pi
//! Contains a parser for an XML processing instruction.
buffered_readerimpl_buffered_sourceBangTypeBinaryStreamReadTextResultTokioAdapter/// A struct for read XML asynchronously from an [`AsyncBufRead`].
/// Having own struct allows us to implement anything without risk of name conflicts
/// and does not suffer from the impossibility of having `async` in traits.
read_event_into_async/// An asynchronous version of [`read_event_into()`]. Reads the next event into
/// given buffer.
/// This is the main entry point for reading XML `Event`s when using an async reader.
/// See the documentation of [`read_event_into()`] for more information.
/// # tokio_test::block_on(async {
/// use quick_xml::reader::Reader;
/// // This explicitly uses `from_reader("...".as_bytes())` to use a buffered
/// // reader instead of relying on the zero-copy optimizations for reading
/// // from byte slices, which provides the sync interface anyway.
/// let mut reader = Reader::from_reader(r#"
///     <tag1 att1 = "test">
///        <tag2><!--Test comment-->Test</tag2>
///        <tag2>Test 2</tag2>
///     </tag1>
/// "#.as_bytes());
/// let mut count = 0;
/// let mut buf = Vec::new();
/// let mut txt = Vec::new();
/// loop {
///     match reader.read_event_into_async(&mut buf).await {
///         Ok(Event::Start(_)) => count += 1,
///         Ok(Event::Text(e)) => txt.push(e.unescape().unwrap().into_owned()),
///         Err(e) => panic!("Error at position {}: {:?}", reader.error_position(), e),
///         Ok(Event::Eof) => break,
///         _ => (),
///     buf.clear();
/// assert_eq!(count, 3);
/// assert_eq!(txt, vec!["Test".to_string(), "Test 2".to_string()]);
/// # }) // tokio_test::block_on
/// [`read_event_into()`]: Reader::read_event_into
read_to_end_into_async// We should name that lifetime due to https://github.com/rust-lang/rust/issues/63033`
/// An asynchronous version of [`read_to_end_into()`].
/// Reads asynchronously until end element is found using provided buffer as
/// intermediate storage for events content. This function is supposed to be
/// called after you already read a [`Start`] event.
/// See the documentation of [`read_to_end_into()`] for more information.
/// This example shows, how you can skip XML content after you read the
/// start event.
///     <outer>
///         <inner>
///             <inner></inner>
///             <inner/>
///             <outer></outer>
///             <outer/>
///         </inner>
///     </outer>
/// let start = BytesStart::new("outer");
/// let end   = start.to_end().into_owned();
/// // First, we read a start event...
/// assert_eq!(reader.read_event_into_async(&mut buf).await.unwrap(), Event::Start(start));
/// // ...then, we could skip all events to the corresponding end event.
/// // This call will correctly handle nested <outer> elements.
/// // Note, however, that this method does not handle namespaces.
/// reader.read_to_end_into_async(end.name(), &mut buf).await.unwrap();
/// // At the end we should get an Eof event, because we ate the whole XML
/// assert_eq!(reader.read_event_into_async(&mut buf).await.unwrap(), Event::Eof);
/// [`read_to_end_into()`]: Self::read_to_end_into
/// [`Start`]: Event::Start
read_until_close_async/// Private function to read until `>` is found. This function expects that
/// it was called just after encounter a `<` symbol.
/// This method manages namespaces but doesn't resolve them automatically.
/// You should call [`resolve_element()`] if you want to get a namespace.
/// You also can use [`read_resolved_event_into_async()`] instead if you want
/// to resolve namespace as soon as you get an event.
/// use quick_xml::name::{Namespace, ResolveResult::*};
/// let mut reader = NsReader::from_reader(r#"
///     <x:tag1 xmlns:x="www.xxxx" xmlns:y="www.yyyy" att1 = "test">
///        <y:tag2><!--Test comment-->Test</y:tag2>
///        <y:tag2>Test 2</y:tag2>
///     </x:tag1>
///     match reader.read_event_into_async(&mut buf).await.unwrap() {
///         Event::Start(e) => {
///             count += 1;
///             let (ns, local) = reader.resolve_element(e.name());
///             match local.as_ref() {
///                 b"tag1" => assert_eq!(ns, Bound(Namespace(b"www.xxxx"))),
///                 b"tag2" => assert_eq!(ns, Bound(Namespace(b"www.yyyy"))),
///                 _ => unreachable!(),
///             }
///         Event::Text(e) => {
///             txt.push(e.unescape().unwrap().into_owned())
///         Event::Eof => break,
/// [`read_event_into()`]: NsReader::read_event_into
/// [`resolve_element()`]: Self::resolve_element
/// [`read_resolved_event_into_async()`]: Self::read_resolved_event_into_async
/// use quick_xml::name::{Namespace, ResolveResult};
///     <outer xmlns="namespace 1">
///         <inner xmlns="namespace 2">
///             <p:outer xmlns:p="ns"></p:outer>
/// let ns = Namespace(b"namespace 1");
/// let start = BytesStart::from_content(r#"outer xmlns="namespace 1""#, 5);
///     reader.read_resolved_event_into_async(&mut buf).await.unwrap(),
///     (ResolveResult::Bound(ns), Event::Start(start))
///     (ResolveResult::Unbound, Event::Eof)
read_resolved_event_into_async// Name 'ns lifetime, because otherwise we get an error
// "implicit elided lifetime not allowed here" on ResolveResult
/// An asynchronous version of [`read_resolved_event_into()`]. Reads the next
/// event into given buffer asynchronously and resolves its namespace (if applicable).
/// Namespace is resolved only for [`Start`], [`Empty`] and [`End`] events.
/// For all other events the concept of namespace is not defined, so
/// a [`ResolveResult::Unbound`] is returned.
/// If you are not interested in namespaces, you can use [`read_event_into_async()`]
/// which will not automatically resolve namespaces for you.
/// use quick_xml::name::{Namespace, QName, ResolveResult::*};
///     match reader.read_resolved_event_into_async(&mut buf).await.unwrap() {
///         (Bound(Namespace(b"www.xxxx")), Event::Start(e)) => {
///             assert_eq!(e.local_name(), QName(b"tag1").into());
///         (Bound(Namespace(b"www.yyyy")), Event::Start(e)) => {
///             assert_eq!(e.local_name(), QName(b"tag2").into());
///         (_, Event::Start(_)) => unreachable!(),
///         (_, Event::Text(e)) => {
///         (_, Event::Eof) => break,
/// [`read_resolved_event_into()`]: NsReader::read_resolved_event_into
/// [`Empty`]: Event::Empty
/// [`End`]: Event::End
/// [`read_event_into_async()`]: Self::read_event_into_async
test_future_is_send//! This is an implementation of [`Reader`] for reading from a [`AsyncBufRead`]
//! as underlying byte stream. This reader fully implements async/await so reading
//! can use non-blocking I/O.
XmlSourceremove_utf8_bomread_bang_elementpeek_one/// Implementation of `XmlSource` for any `BufRead` reader using a user-given
/// `Vec<u8>` as buffer that will be borrowed by events.
read_event_into/// Reads the next `Event`.
/// This is the main entry point for reading XML `Event`s.
/// `Event`s borrow `buf` and can be converted to own their data if needed (uses `Cow`
/// internally).
/// Having the possibility to control the internal buffers gives you some additional benefits
/// such as:
/// - Reduce the number of allocations by reusing the same buffer. For constrained systems,
///   you can call `buf.clear()` once you are done with processing the event (typically at the
///   end of your loop).
/// - Reserve the buffer length if you know the file size (using `Vec::with_capacity`).
/// let xml = r#"<tag1 att1 = "test">
///                 <tag2><!--Test comment-->Test</tag2>
///                 <tag2>Test 2</tag2>
///              </tag1>"#;
/// let mut reader = Reader::from_str(xml);
///     match reader.read_event_into(&mut buf) {
read_to_end_into/// Reads until end element is found using provided buffer as intermediate
/// storage for events content. This function is supposed to be called after
/// you already read a [`Start`] event.
/// Returns a span that cover content between `>` of an opening tag and `<` of
/// a closing tag or an empty slice, if [`expand_empty_elements`] is set and
/// this method was called after reading expanded [`Start`] event.
/// Manages nested cases where parent and child elements have the _literally_
/// same name.
/// If a corresponding [`End`] event is not found, an error of type [`Error::IllFormed`]
/// will be returned. In particularly, that error will be returned if you call
/// this method without consuming the corresponding [`Start`] event first.
/// If your reader created from a string slice or byte array slice, it is
/// better to use [`read_to_end()`] method, because it will not copy bytes
/// into intermediate buffer.
/// The provided `buf` buffer will be filled only by one event content at time.
/// Before reading of each event the buffer will be cleared. If you know an
/// appropriate size of each event, you can preallocate the buffer to reduce
/// number of reallocations.
/// The `end` parameter should contain name of the end element _in the reader
/// encoding_. It is good practice to always get that parameter using
/// [`BytesStart::to_end()`] method.
/// The correctness of the skipped events does not checked, if you disabled
/// the [`check_end_names`] option.
/// # Namespaces
/// While the `Reader` does not support namespace resolution, namespaces
/// does not change the algorithm for comparing names. Although the names
/// `a:name` and `b:name` where both prefixes `a` and `b` resolves to the
/// same namespace, are semantically equivalent, `</b:name>` cannot close
/// `<a:name>`, because according to [the specification]
/// > The end of every element that begins with a **start-tag** MUST be marked
/// > by an **end-tag** containing a name that echoes the element's type as
/// > given in the **start-tag**
/// let mut reader = Reader::from_str(r#"
/// "#);
/// assert_eq!(reader.read_event_into(&mut buf).unwrap(), Event::Start(start));
/// reader.read_to_end_into(end.name(), &mut buf).unwrap();
/// assert_eq!(reader.read_event_into(&mut buf).unwrap(), Event::Eof);
/// [`BytesStart::to_end()`]: crate::events::BytesStart::to_end
/// [`read_to_end()`]: Self::read_to_end
/// [`expand_empty_elements`]: crate::reader::Config::expand_empty_elements
/// [`check_end_names`]: crate::reader::Config::check_end_names
/// [the specification]: https://www.w3.org/TR/xml11/#dt-etag
/// This is an implementation for reading from a [`BufRead`] as underlying byte stream.
/// Creates an XML reader from a file path.
/// Default buffer constructor just pass the byte array from the test
r" Checks that reading CDATA content works correctly
"r" Checks that if input begins like CDATA element, but CDATA start sequence
"r" is not finished, parsing ends with an error
""start CDATA sequence fully checked outside of `read_bang_element`"not_properly_startr" Checks that if CDATA startup sequence was matched, but an end sequence
"r" is not found, parsing ends with an error
"not_closedr" Checks that CDATA element without content inside parsed successfully
"r" Checks that CDATA element with content parsed successfully.
"r" Additionally checks that sequences inside CDATA that may look like
"r" a CDATA end sequence do not interrupt CDATA parsing
"r" Checks that reading XML comments works correctly. According to the [specification],
"r" comment data can contain any sequence except `--`:
"r" ```peg
"r" comment = '<--' (!'--' char)* '-->';
"r" char = [#x1-#x2C]
"r"      / [#x2E-#xD7FF]
"r"      / [#xE000-#xFFFD]
"r"      / [#x10000-#x10FFFF]
"r" ```
"r" The presence of this limitation, however, is simply a poorly designed specification
"r" (maybe for purpose of building of LL(1) XML parser) and quick-xml does not check for
"r" presence of these sequences by default. This tests allow such content.
"r" [specification]: https://www.w3.org/TR/xml11/#dt-comment
""start comment sequence fully checked outside of `read_bang_element`"not_properly_endnot_closed1not_closed2not_closed3r" Checks that reading DOCTYPE definition works correctly
"without_spacedoctyper" Checks that nothing was read from empty buffer
"empty_tagempty_ns_empty_tagempty_nsself_closedread_elementr" Ensures, that no empty `Text` events are generated
"r" When `encoding` feature is enabled, encoding should be detected
"r" from BOM (UTF-8) and BOM should be stripped.
"r" When `encoding` feature is disabled, UTF-8 is assumed and BOM
"r" character should be stripped for consistency
"bom_from_readerr" When parsing from &str, encoding is fixed (UTF-8), so
"r" - when `encoding` feature is disabled, the behavior the
"r"   same as in `bom_from_reader` text
"r" - when `encoding` feature is enabled, the behavior should
"r"   stay consistent, so the first BOM character is stripped
"bom_from_strprocessing_instructionr" Lone closing tags are not allowed, so testing it together with start tag
"start_and_endread_event_impl//! This is an implementation of [`Reader`] for reading from a [`BufRead`] as
//! underlying byte stream.
ReaderStateallow_unmatched_ends/// Whether unmatched closing tag names should be allowed. Unless enabled,
/// in case of a dangling end tag, the [`Error::IllFormed(UnmatchedEndTag)`]
/// is returned from read methods.
/// When set to `true`, it won't check if a closing tag has a corresponding
/// opening tag at all. For example, `<a></a></b>` will be permitted.
/// Note that the emitted [`End`] event will not be modified if this is enabled,
/// ie. it will contain the data of the unmatched end tag.
/// Note, that setting this to `true` will lead to additional allocates that
/// needed to store tag name for an [`End`] event.
/// Default: `false`
/// [`Error::IllFormed(UnmatchedEndTag)`]: crate::errors::IllFormedError::UnmatchedEndTag
/// [`End`]: crate::events::Event::End
check_comments/// Whether comments should be validated. If enabled, in case of invalid comment
/// [`Error::IllFormed(DoubleHyphenInComment)`] is returned from read methods.
/// When set to `true`, every [`Comment`] event will be checked for not
/// containing `--`, which [is not allowed] in XML comments. Most of the time
/// we don't want comments at all so we don't really care about comment
/// correctness, thus the default value is `false` to improve performance.
/// [`Error::IllFormed(DoubleHyphenInComment)`]: crate::errors::IllFormedError::DoubleHyphenInComment
/// [`Comment`]: crate::events::Event::Comment
/// [is not allowed]: https://www.w3.org/TR/xml11/#sec-comments
check_end_names/// Whether mismatched closing tag names should be detected. If enabled, in
/// case of mismatch the [`Error::IllFormed(MismatchedEndTag)`] is returned from
/// read methods.
/// Note, that start and end tags [should match literally][spec], they cannot
/// have different prefixes even if both prefixes resolve to the same namespace.
/// <outer xmlns="namespace" xmlns:p="namespace">
/// </p:outer>
/// is not valid, even though semantically the start tag is the same as the
/// end tag. The reason is that namespaces are an extension of the original
/// XML specification (without namespaces) and it should be backward-compatible.
/// When set to `false`, it won't check if a closing tag matches the corresponding
/// opening tag. For example, `<mytag></different_tag>` will be permitted.
/// If the XML is known to be sane (already processed, etc.) this saves extra time.
/// Note that the emitted [`End`] event will not be modified if this is disabled,
/// ie. it will contain the data of the mismatched end tag.
/// needed to store tag name for an [`End`] event. However if [`expand_empty_elements`]
/// is also set, only one additional allocation will be performed that support
/// both these options.
/// Default: `true`
/// [`Error::IllFormed(MismatchedEndTag)`]: crate::errors::IllFormedError::MismatchedEndTag
/// [spec]: https://www.w3.org/TR/xml11/#dt-etag
/// [`expand_empty_elements`]: Self::expand_empty_elements
expand_empty_elements/// Whether empty elements should be split into an `Open` and a `Close` event.
/// When set to `true`, all [`Empty`] events produced by a self-closing tag
/// like `<tag/>` are expanded into a [`Start`] event followed by an [`End`]
/// event. When set to `false` (the default), those tags are represented by
/// an [`Empty`] event instead.
/// needed to store tag name for an [`End`] event. However if [`check_end_names`]
/// [`Empty`]: crate::events::Event::Empty
/// [`Start`]: crate::events::Event::Start
/// [`check_end_names`]: Self::check_end_names
trim_markup_names_in_closing_tags/// Whether trailing whitespace after the markup name are trimmed in closing
/// tags `</a >`.
/// If `true` the emitted [`End`] event is stripped of trailing whitespace
/// after the markup name.
/// Note that if set to `false` and [`check_end_names`] is `true` the comparison
/// of markup names is going to fail erroneously if a closing tag contains
/// trailing whitespace.
trim_text_start/// Whether whitespace before character data should be removed.
/// When set to `true`, leading whitespace is trimmed in [`Text`] events.
/// If after that the event is empty it will not be pushed.
/// <div style="background:rgba(80, 240, 100, 0.20);padding:0.75em;">
/// WARNING: With this option every text events will be trimmed which is
/// incorrect behavior when text events delimited by comments, processing
/// instructions or CDATA sections. To correctly trim data manually apply
/// [`BytesText::inplace_trim_start`] and [`BytesText::inplace_trim_end`]
/// only to necessary events.
/// </div>
/// [`BytesText::inplace_trim_start`]: crate::events::BytesText::inplace_trim_start
/// [`BytesText::inplace_trim_end`]: crate::events::BytesText::inplace_trim_end
trim_text_end/// Whether whitespace after character data should be removed.
/// When set to `true`, trailing whitespace is trimmed in [`Text`] events.
/// A struct that holds a parser configuration.
/// Current parser configuration can be retrieved by calling [`Reader::config()`]
/// and changed by changing properties of the object returned by a call to
/// [`Reader::config_mut()`].
/// [`Reader::config()`]: crate::reader::Reader::config
/// [`Reader::config_mut()`]: crate::reader::Reader::config_mut
trim_text/// Set both [`trim_text_start`] and [`trim_text_end`] to the same value.
/// [`trim_text_start`]: Self::trim_text_start
/// [`trim_text_end`]: Self::trim_text_end
enable_all_checks/// Turn on or off all checks for well-formedness. Currently it is that settings:
/// - [`check_comments`](Self::check_comments)
/// - [`check_end_names`](Self::check_end_names)
read_until_close/// Read bytes up to the `>` and skip it. This method is expected to be called
/// after seeing the `<` symbol and skipping it. Inspects the next (current)
/// symbol and returns an appropriate [`Event`]:
/// |Symbol |Event
/// |-------|-------------------------------------
/// |`!`    |[`Comment`], [`CData`] or [`DocType`]
/// |`/`    |[`End`]
/// |`?`    |[`PI`]
/// |_other_|[`Start`] or [`Empty`]
/// Moves parser to the `InsideText` state.
/// [`DocType`]: Event::DocType
/// Generalization of `read_to_end` method for buffered and borrowed readers
ns_readerslice_reader/// Range of input in bytes, that corresponds to some piece of XML
/// Initial state in which reader stay after creation. Transition from that
/// state could produce a `Text`, `Decl`, `Comment` or `Start` event. The next
/// state is always `InsideMarkup`. The reader will never return to this state. The
/// event emitted during transition to `InsideMarkup` is a `StartEvent` if the
/// first symbol not `<`, otherwise no event are emitted.
InsideMarkup/// State after seeing the `<` symbol. Depending on the next symbol all other
/// events could be generated.
/// After generating one event the reader moves to the `InsideText` state.
InsideText/// State in which reader searches the `<` symbol of a markup. All bytes before
/// that symbol will be returned in the [`Event::Text`] event. After that
/// the reader moves to the `InsideMarkup` state.
InsideEmpty/// This state is used only if option [`expand_empty_elements`] is set to `true`.
/// Reader enters to this state when it is in a `InsideText` state and emits an
/// [`Event::Start`] event. The next event emitted will be an [`Event::End`],
/// after which reader returned to the `InsideText` state.
/// [`expand_empty_elements`]: Config::expand_empty_elements
/// Reader enters this state when `Eof` event generated or an error occurred.
/// This is the last state, the reader stay in it forever.
/// Possible reader states. The state transition diagram (`true` and `false` shows
/// value of [`Config::expand_empty_elements`] option):
/// ```mermaid
/// flowchart LR
///   subgraph _
///     direction LR
///     Init         -- "(no event)"\n                                       --> InsideMarkup
///     InsideMarkup -- Decl, DocType, PI\nComment, CData\nStart, Empty, End --> InsideText
///     InsideText   -- "#lt;false#gt;\n(no event)"\nText                    --> InsideMarkup
///   end
///   InsideText     -- "#lt;true#gt;"\nStart --> InsideEmpty
///   InsideEmpty    -- End                   --> InsideText
///   _ -. Eof .-> Done
"streams do nothing unless read or polled"/// A direct stream to the underlying [`Reader`]s reader which updates
/// [`Reader::buffer_position()`] when read from it.
/// Returns current position in bytes in the original source.
/// Gets a reference to the underlying reader.
/// Gets a mutable reference to the underlying reader.
/// Avoid read from this reader because this will not update reader's position
/// and will lead to incorrect positions of errors. Read from this stream instead.
/// Source of data for parse
/// Configuration and current parse state
/// A low level encoding-agnostic XML event reader.
/// Consumes bytes and streams XML [`Event`]s.
/// This reader does not manage namespace declarations and not able to resolve
/// prefixes. If you want these features, use the [`NsReader`].
/// // The `Reader` does not implement `Iterator` because it outputs borrowed data (`Cow`s)
///     // NOTE: this is the generic case when we don't know about the input BufRead.
///     // when the input is a &str or a &[u8], we don't actually need to use another
///     // buffer, we could directly call `reader.read_event()`
///         // exits the loop when reaching end of file
///         Ok(Event::Start(e)) => {
///             match e.name().as_ref() {
///                 b"tag1" => println!("attributes values: {:?}",
///                                     e.attributes().map(|a| a.unwrap().value)
///                                     .collect::<Vec<_>>()),
///                 b"tag2" => count += 1,
///                 _ => (),
///         // There are several other `Event`s we do not consider here
///     // if we don't keep a borrow elsewhere, we can clear the buffer to keep memory usage low
/// [`NsReader`]: crate::reader::NsReader
/// Creates a `Reader` that reads from a given reader.
/// Returns reference to the parser configuration
/// Returns mutable reference to the parser configuration
/// Builder methods
/// Consumes `Reader` returning the underlying reader
/// Can be used to compute line and column of a parsing error position
/// use std::{str, io::Cursor};
///                 <tag3>Test 2</tag3>
/// let mut reader = Reader::from_reader(Cursor::new(xml.as_bytes()));
/// fn into_line_and_column(reader: Reader<Cursor<&[u8]>>) -> (usize, usize) {
///     // We known that size cannot exceed usize::MAX because we created parser from single &[u8]
///     let end_pos = reader.buffer_position() as usize;
///     let mut cursor = reader.into_inner();
///     let s = String::from_utf8(cursor.into_inner()[0..end_pos].to_owned())
///         .expect("can't make a string");
///     let mut line = 1;
///     let mut column = 0;
///     for c in s.chars() {
///         if c == '\n' {
///             line += 1;
///             column = 0;
///         } else {
///             column += 1;
///     (line, column)
///         Ok(Event::Start(ref e)) => match e.name().as_ref() {
///             b"tag1" | b"tag2" => (),
///             tag => {
///                 assert_eq!(b"tag3", tag);
///                 assert_eq!((3, 22), into_line_and_column(reader));
///                 break;
///         },
///         Ok(Event::Eof) => unreachable!(),
/// and will lead to incorrect positions of errors. If you want to read, use
/// [`stream()`] instead.
/// [`stream()`]: Self::stream
buffer_position/// Gets the current byte position in the input data.
/// Gets the last error byte position in the input data. If there is no errors
/// yet, returns `0`.
/// Unlike `buffer_position` it will point to the place where it is rational
/// to report error to the end user. For example, all [`SyntaxError`]s are
/// reported when the parser sees EOF inside of some kind of markup. The
/// `buffer_position()` will point to the last byte of input which is not
/// very useful. `error_position()` will point to the start of corresponding
/// markup element (i. e. to the `<` character).
/// This position is always `<= buffer_position()`.
/// Get the decoder, used to decode bytes, read by this reader, to the strings.
/// If [`encoding`] feature is enabled, the used encoding may change after
/// parsing the XML declaration, otherwise encoding is fixed to UTF-8.
/// If [`encoding`] feature is enabled and no encoding is specified in declaration,
/// defaults to UTF-8.
/// Get the direct access to the underlying reader, but tracks the amount of
/// read data and update [`Reader::buffer_position()`] accordingly.
/// Note, that this method gives you access to the internal reader and read
/// data will not be returned in any subsequent events read by `read_event`
/// family of methods.
/// This example demonstrates how to read stream raw bytes from an XML document.
/// This could be used to implement streaming read of text, or to read raw binary
/// bytes embedded in an XML document. (Documents with embedded raw bytes are not
/// valid XML, but XML-derived file formats exist where such documents are valid).
/// use std::io::{BufRead, Read};
/// use quick_xml::events::{BytesEnd, BytesStart, Event};
/// let mut reader = Reader::from_str("<tag>binary << data&></tag>");
/// //                                 ^    ^               ^     ^
/// //                                 0    5              21    27
///     (reader.read_event().unwrap(), reader.buffer_position()),
///     // 5 - end of the `<tag>`
///     (Event::Start(BytesStart::new("tag")), 5)
/// // Reading directly from underlying reader will not update position
/// // let mut inner = reader.get_mut();
/// // Reading from the stream() advances position
/// let mut inner = reader.stream();
/// // Read binary data. We must know its size
/// let mut binary = [0u8; 16];
/// inner.read_exact(&mut binary).unwrap();
/// assert_eq!(&binary, b"binary << data&>");
/// // 21 - end of the `binary << data&>`
/// assert_eq!(inner.offset(), 21);
/// assert_eq!(reader.buffer_position(), 21);
///     // 27 - end of the `</tag>`
///     (Event::End(BytesEnd::new("tag")), 27)
/// assert_eq!(reader.read_event().unwrap(), Event::Eof);
/// Getters
/// Read text into the given buffer, and return an event that borrows from
/// either that buffer or from the input itself, based on the type of the
/// reader.
/// Private sync reading methods
Markup/// Start of markup (`<` character) was found in the first byte.
/// Contains buffer that should be returned back to the next iteration cycle
/// to satisfy borrow checker requirements.
UpToMarkup/// Contains text block up to start of markup (`<` character).
UpToEof/// Contains text block up to EOF, start of markup (`<` character) was not found.
/// IO error occurred.
/// Result of an attempt to read XML textual data from the reader.
/// Removes UTF-8 BOM if it is present
/// Read input until start of markup (the `<`) is found or end of input is reached.
/// - `buf`: Buffer that could be filled from an input (`Self`) and
///   from which [events] could borrow their data
/// - `position`: Will be increased by amount of bytes consumed
/// [events]: crate::events::Event
/// Read input until processing instruction is finished.
/// This method expect that start sequence of a parser already was read.
/// Returns a slice of data read up to the end of the thing being parsed.
/// The end of thing and the returned content is determined by the used parser.
/// If input (`Self`) is exhausted and no bytes was read, or if the specified
/// parser could not find the ending sequence of the thing, returns `SyntaxError`.
/// A `P` type parameter is used to preserve state between calls to the underlying
/// reader which provides bytes fed into the parser.
/// Read input until comment or CDATA is finished.
/// This method expect that `<` already was read.
/// Returns a slice of data read up to end of comment or CDATA (`>`),
/// which does not include into result.
/// If input (`Self`) is exhausted and nothing was read, returns `None`.
/// Consume and discard all the whitespace until the next non-whitespace
/// character or EOF.
/// Return one character without consuming it, so that future `read_*` calls
/// will still include it. On EOF, return `None`.
/// Represents an input for a reader that can return borrowed data.
/// There are two implementors of this trait: generic one that read data from
/// `Self`, copies some part of it into a provided buffer of type `B` and then
/// returns data that borrow from that buffer.
/// The other implementor is for `&[u8]` and instead of copying data returns
/// borrowed data from `Self` instead. This implementation allows zero-copy
/// deserialization.
/// - `'r`: lifetime of a buffer from which events will borrow
/// - `B`: a type of a buffer that can be used to store data read from `Self` and
///   from which events can borrow
/// <![CDATA[...]]>
/// <!--...-->
/// <!DOCTYPE...>. Contains balance of '<' (+1) and '>' (-1)
/// Possible elements started with `<!`
/// If element is finished, returns its content up to `>` symbol and
/// an index of this symbol, otherwise returns `None`
/// - `buf`: buffer with data consumed on previous iterations
/// - `chunk`: data read on current iteration and not yet consumed from reader
to_err/// Checks the internal implementation of the various reader methods
// Export macros for the child modules:
// - buffered_reader
// - slice_reader
//! Contains high-level interface for a pull-based XML parser.
/// An XML reader
ns_resolver/// A buffer to manage namespaces
pending_pop/// We cannot pop data from the namespace stack until returned `Empty` or `End`
/// event will be processed by the user, so we only mark that we should that
/// in the next [`Self::read_event_impl()`] call.
/// A low level encoding-agnostic XML event reader that performs namespace resolution.
/// Consumes a [`BufRead`] and streams XML `Event`s.
/// Creates a `NsReader` that reads from a reader.
prefixes/// Returns all the prefixes currently declared except the default `xml` and `xmlns` namespaces.
/// This example shows what results the returned iterator would return after
/// reading each event of a simple XML.
/// use quick_xml::name::{Namespace, PrefixDeclaration};
/// let src = "<root>
///   <a xmlns=\"a1\" xmlns:a=\"a2\">
///     <b xmlns=\"b1\" xmlns:b=\"b2\">
///       <c/>
///     </b>
///     <d/>
///   </a>
/// </root>";
/// let mut reader = NsReader::from_str(src);
/// // No prefixes at the beginning
/// assert_eq!(reader.prefixes().collect::<Vec<_>>(), vec![]);
/// reader.read_resolved_event()?; // <root>
/// // No prefixes declared on root
/// reader.read_resolved_event()?; // <a>
/// // Two prefixes declared on "a"
/// assert_eq!(reader.prefixes().collect::<Vec<_>>(), vec![
///     (PrefixDeclaration::Default, Namespace(b"a1")),
///     (PrefixDeclaration::Named(b"a"), Namespace(b"a2"))
/// reader.read_resolved_event()?; // <b>
/// // The default prefix got overridden and new "b" prefix
///     (PrefixDeclaration::Named(b"a"), Namespace(b"a2")),
///     (PrefixDeclaration::Default, Namespace(b"b1")),
///     (PrefixDeclaration::Named(b"b"), Namespace(b"b2"))
/// reader.read_resolved_event()?; // <c/>
/// // Still the same
/// reader.read_resolved_event()?; // </b>
/// reader.read_resolved_event()?; // <d/>
/// // </b> got closed so back to the prefixes declared on <a>
/// reader.read_resolved_event()?; // </a>
/// reader.read_resolved_event()?; // </root>
/// // <a> got closed
/// # quick_xml::Result::Ok(())
resolve_event/// Private methods
/// Consumes `NsReader` returning the underlying reader
/// See the [`Reader::into_inner`] for examples
/// into _(namespace name, local name)_.
/// _Qualified_ names have the form `prefix:local-name` where the `prefix`
/// is defined on any containing XML element via `xmlns:prefix="the:namespace:uri"`.
/// The namespace prefix can be defined on the same element as the name in question.
/// The method returns following results depending on the `name` shape,
/// `attribute` flag and the presence of the default namespace:
/// |attribute|`xmlns="..."`|QName              |ResolveResult          |LocalName
/// |---------|-------------|-------------------|-----------------------|------------
/// |`true`   |Not defined  |`local-name`       |[`Unbound`]            |`local-name`
/// |`true`   |Defined      |`local-name`       |[`Unbound`]            |`local-name`
/// |`true`   |_any_        |`prefix:local-name`|[`Bound`] / [`Unknown`]|`local-name`
/// |`false`  |Not defined  |`local-name`       |[`Unbound`]            |`local-name`
/// |`false`  |Defined      |`local-name`       |[`Bound`] (default)    |`local-name`
/// |`false`  |_any_        |`prefix:local-name`|[`Bound`] / [`Unknown`]|`local-name`
/// If you want to clearly indicate that name that you resolve is an element
/// or an attribute name, you could use [`resolve_attribute()`] or [`resolve_element()`]
/// methods.
/// - `'n`: lifetime of a name. Returned local name will be bound to the same
///   lifetime as the name in question.
/// - returned namespace name will be bound to the reader itself
/// [`Bound`]: ResolveResult::Bound
/// [`Unbound`]: ResolveResult::Unbound
/// [`Unknown`]: ResolveResult::Unknown
/// [`resolve_attribute()`]: Self::resolve_attribute()
/// [`resolve_element()`]: Self::resolve_element()
resolve_element/// Resolves a potentially qualified **element name** into _(namespace name, local name)_.
/// _Qualified_ element names have the form `prefix:local-name` where the
/// `prefix` is defined on any containing XML element via `xmlns:prefix="the:namespace:uri"`.
/// The namespace prefix can be defined on the same element as the element
/// in question.
/// _Unqualified_ elements inherits the current _default namespace_.
/// The method returns following results depending on the `name` shape and
/// the presence of the default namespace:
/// |`xmlns="..."`|QName              |ResolveResult          |LocalName
/// |-------------|-------------------|-----------------------|------------
/// |Not defined  |`local-name`       |[`Unbound`]            |`local-name`
/// |Defined      |`local-name`       |[`Bound`] (default)    |`local-name`
/// |_any_        |`prefix:local-name`|[`Bound`] / [`Unknown`]|`local-name`
/// - `'n`: lifetime of an element name. Returned local name will be bound
///   to the same lifetime as the name in question.
/// This example shows how you can resolve qualified name into a namespace.
/// Note, that in the code like this you do not need to do that manually,
/// because the namespace resolution result returned by the [`read_resolved_event()`].
/// let mut reader = NsReader::from_str("<tag xmlns='root namespace'/>");
/// match reader.read_event().unwrap() {
///     Event::Empty(e) => assert_eq!(
///         reader.resolve_element(e.name()),
///         (Bound(Namespace(b"root namespace")), QName(b"tag").into())
///     ),
///     _ => unreachable!(),
/// [`read_resolved_event()`]: Self::read_resolved_event
resolve_attribute/// Resolves a potentially qualified **attribute name** into _(namespace name, local name)_.
/// _Qualified_ attribute names have the form `prefix:local-name` where the
/// The namespace prefix can be defined on the same element as the attribute
/// _Unqualified_ attribute names do *not* inherit the current _default namespace_.
/// |Defined      |`local-name`       |[`Unbound`]            |`local-name`
/// - `'n`: lifetime of an attribute name. Returned local name will be bound
///     <tag one='1'
///          p:two='2'
///          xmlns='root namespace'
///          xmlns:p='other namespace'/>
///     Event::Empty(e) => {
///         let mut iter = e.attributes();
///         // Unlike elements, attributes without explicit namespace
///         // not bound to any namespace
///         let one = iter.next().unwrap().unwrap();
///             reader.resolve_attribute(one.key),
///             (Unbound, QName(b"one").into())
///         let two = iter.next().unwrap().unwrap();
///             reader.resolve_attribute(two.key),
///             (Bound(Namespace(b"other namespace")), QName(b"two").into())
/// Reads the next event into given buffer.
/// You also can use [`read_resolved_event_into()`] instead if you want to resolve
/// namespace as soon as you get an event.
/// let mut reader = NsReader::from_str(r#"
///     match reader.read_event_into(&mut buf).unwrap() {
/// [`read_resolved_event_into()`]: Self::read_resolved_event_into
read_resolved_event_into/// Reads the next event into given buffer and resolves its namespace (if applicable).
/// If you are not interested in namespaces, you can use [`read_event_into()`]
///     match reader.read_resolved_event_into(&mut buf).unwrap() {
/// [`read_event_into()`]: Self::read_event_into
/// If a corresponding [`End`] event is not found, an error of type [`IllFormed`]
/// While the `NsReader` does namespace resolution, namespaces does not
/// change the algorithm for comparing names. Although the names `a:name`
/// and `b:name` where both prefixes `a` and `b` resolves to the same namespace,
/// are semantically equivalent, `</b:name>` cannot close `<a:name>`, because
/// according to [the specification]
///     reader.read_resolved_event_into(&mut buf).unwrap(),
/// [`IllFormed`]: crate::errors::Error::IllFormed
/// Creates an XML reader from a string slice.
read_event/// Reads the next event, borrow its content from the input buffer.
/// You also can use [`read_resolved_event()`] instead if you want to resolve namespace
/// as soon as you get an event.
/// There is no asynchronous `read_event_async()` version of this function,
/// because it is not necessary -- the contents are already in memory and no IO
/// is needed, therefore there is no potential for blocking.
///     match reader.read_event().unwrap() {
read_resolved_event/// Reads the next event, borrow its content from the input buffer, and resolves
/// its namespace (if applicable).
/// If you are not interested in namespaces, you can use [`read_event()`]
/// There is no asynchronous `read_resolved_event_async()` version of this function,
///     match reader.read_resolved_event().unwrap() {
/// [`read_event()`]: Self::read_event
/// Reads until end element is found. This function is supposed to be called
/// after you already read a [`Start`] event.
/// There is no asynchronous `read_to_end_async()` version of this function,
///     reader.read_resolved_event().unwrap(),
/// reader.read_to_end(end.name()).unwrap();
/// Reads content between start and end tags, including any markup. This
/// function is supposed to be called after you already read a [`Start`] event.
/// This method does not unescape read data, instead it returns content
/// "as is" of the XML document. This is because it has no idea what text
/// it reads, and if, for example, it contains CDATA section, attempt to
/// unescape it content will spoil data.
/// Any text will be decoded using the XML current [`decoder()`].
/// Actually, this method perform the following code:
/// let span = reader.read_to_end(end)?;
/// let text = reader.decoder().decode(&reader.inner_slice[span]);
/// This example shows, how you can read a HTML content from your XML document.
///     <html>
///         <title>This is a HTML text</title>
///         <p>Usual XML rules does not apply inside it
///         <p>For example, elements not needed to be &quot;closed&quot;
///     </html>
/// let start = BytesStart::new("html");
/// assert_eq!(reader.read_event().unwrap(), Event::Start(start));
/// // ...and disable checking of end names because we expect HTML further...
/// // ...then, we could read text content until close tag.
/// // This call will correctly handle nested <html> elements.
/// let text = reader.read_text(end.name()).unwrap();
/// assert_eq!(text, Cow::Borrowed(r#"
///     "#));
/// // Now we can enable checks again
/// reader.config_mut().check_end_names = true;
/// [`decoder()`]: Reader::decoder()
//! A reader that manages namespace declarations found in the input and able
//! to resolve [qualified names] to [expanded names].
//! [qualified names]: https://www.w3.org/TR/xml-names11/#dt-qualname
//! [expanded names]: https://www.w3.org/TR/xml-names11/#dt-expname
/// Read an event that borrows from the input rather than a buffer.
///         Event::Start(e) => count += 1,
///         Event::Text(e) => txt.push(e.unescape().unwrap().into_owned()),
/// let mut reader = Reader::from_str("
/// assert!(matches!(text, Cow::Borrowed(_)));
/// [`decoder()`]: Self::decoder()
/// This is an implementation for reading from a `&[u8]` as underlying byte stream.
/// This implementation supports not using an intermediate buffer as the byte slice
/// itself can be used to borrow from.
/// Implementation of `XmlSource` for `&[u8]` reader using a `Self` as buffer
/// that will be borrowed by events. This implementation provides a zero-copy deserialization
//! This is an implementation of [`Reader`] for reading from a `&[u8]` as
//! underlying byte stream. This implementation supports not using an
//! intermediate buffer as the byte slice itself can be used to borrow from.
/// Number of bytes read from the source of data since the reader was created
last_error_offset/// A snapshot of an `offset` of the last error returned. It can be less than
/// `offset`, because some errors conveniently report at earlier position,
/// and changing `offset` is not possible, because `Error::IllFormed` errors
/// are recoverable.
/// Defines how to process next byte
/// User-defined settings that affect parsing
opened_buffer/// All currently Started elements which didn't have a matching
/// End element yet.
/// For an XML
/// <root><one/><inner attr="value">|<tag></inner></root>
/// when cursor at the `|` position buffer contains:
/// ```text
/// rootinner
/// ^   ^
/// The `^` symbols shows which positions stored in the [`Self::opened_starts`]
/// (0 and 4 in that case).
opened_starts/// Opened name start indexes into [`Self::opened_buffer`]. See documentation
/// for that field for details
/// A struct that holds a current reader state and a parser configuration.
/// It is independent on a way of reading data: the reader feed data into it and
/// get back produced [`Event`]s.
emit_text/// Trims end whitespaces from `bytes`, if required, and returns a text event.
/// - `bytes`: data from the start of stream to the first `<` or from `>` to `<`
emit_bang/// Returns `Comment`, `CData` or `DocType` event.
/// `buf` contains data between `<` and `>`:
/// - CDATA: `![CDATA[...]]`
/// - Comment: `!--...--`
/// - Doctype (uppercase): `!D...`
/// - Doctype (lowercase): `!d...`
emit_end/// Wraps content of `buf` into the [`Event::End`] event. Does the check that
/// end name matches the last opened start name if `self.config.check_end_names` is set.
/// `buf` contains data between `<` and `>`, for example `/tag`.
emit_question_mark/// `buf` contains data between `<` and `>` and the first byte is `?`.
/// `self.offset` already after the `>`
/// Returns `Decl` or `PI` event
emit_start/// Converts content of a tag to a `Start` or an `Empty` event
/// - `content`: Content of a tag between `<` and `>`
close_expanded_emptyElementSerializerSeErrorWriteResultXmlNamewrite_primitive/// Defines which XML characters need to be escaped in text content
/// Current indentation level. Note, that `Indent::None` means that there is
/// no indentation at all, but `write_indent == false` means only, that indent
/// writing is disabled in this instantiation of `ContentSerializer`, but
/// child serializers should have access to the actual state of indentation.
write_indent/// If `true`, then current indent will be written before writing the content,
/// but only if content is not empty. This flag is reset after writing indent.
allow_primitive/// If `true`, then primitive types that serializes to a text content without
/// surrounding tag will be allowed, otherwise the [`SeError::Unsupported`]
/// will be returned.
/// This method protects from the situation when two consequent values serialized
/// as a text that makes it impossible to distinguish between them during
/// deserialization. Instead of ambiguous serialization the error is returned.
// If `true`, then empty elements will be serialized as `<element></element>`
// instead of `<element/>`.
ContentSerializer/// A serializer used to serialize content of an element. It does not write
/// surrounding tags. Unlike the [`ElementSerializer`], this serializer serializes
/// enums using variant names as tag names, i. e. as `<variant>...</variant>`.
/// Returns the classification of the last written type.
/// This serializer does the following:
/// - numbers converted to a decimal representation and serialized as naked strings;
/// - booleans serialized ether as `"true"` or `"false"`;
/// - strings and characters are serialized as naked strings;
/// - `None` does not write anything;
/// - `Some` and newtypes are serialized as an inner type using the same serializer;
/// - units (`()`) and unit structs does not write anything;
/// - sequences, tuples and tuple structs are serialized without delimiters.
///   `[1, 2, 3]` would be serialized as `123` (if not using indent);
/// - structs and maps are not supported ([`SeError::Unsupported`] is returned);
///   - unit variants are serialized as self-closed `<variant/>`;
///   - newtype variants are serialized as inner value wrapped in `<variant>...</variant>`;
///   - tuple variants are serialized as sequences where each element is wrapped
///     in `<variant>...</variant>`;
///   - struct variants are serialized as a sequence of fields wrapped in
///     `<variant>...</variant>`. Each field is serialized recursively using
///     either [`ElementSerializer`], `ContentSerializer` (`$value` fields), or
///     [`SimpleTypeSerializer`] (`$text` fields). In particular, the empty struct
///     is serialized as `<variant/>`;
/// Usage of empty tags depends on the [`Self::expand_empty_elements`] setting.
/// The difference between this serializer and [`SimpleTypeSerializer`] is in how
/// sequences and maps are serialized. Unlike `SimpleTypeSerializer` it supports
/// any types in sequences and serializes them as list of elements, but that has
/// drawbacks. Sequence of primitives would be serialized without delimiters and
/// it will be impossible to distinguish between them. Even worse, when serializing
/// with indent, sequence of strings become one big string with additional content
/// and it would be impossible to distinguish between content of the original
/// strings and inserted indent characters.
into_simple_type_serializer_impl/// Turns this serializer into serializer of a text content
into_simple_type_serializer/// Turns this serializer into serializer of a text content if that is allowed,
/// otherwise error is returned
new_seq_element_serializer/// Creates new serializer that shares state with this serializer and
/// writes to the same underlying writer
/// Writes `name` as self-closed tag
write_wrapped/// Writes simple type content between `name` tags
Seq/// Does not write anything
/// If `variant` is a special `$text` variant, then do nothing, otherwise
/// checks `variant` for XML name validity and writes `<variant/>`.
/// If `variant` is a special `$text` variant, then writes `value` as a `xs:simpleType`,
/// otherwise checks `variant` for XML name validity and writes `value` as a new
/// `<variant>` element.
/// Serializes variant as a tuple with name `variant`, producing
/// <variant><!-- 1st element of a tuple --></variant>
/// <variant><!-- 2nd element of a tuple --></variant>
/// <!-- ... -->
/// <variant><!-- Nth element of a tuple --></variant>
/// Serializes variant as an element with name `variant`, producing
/// <variant>
///   <!-- struct fields... -->
/// </variant>
/// If struct has no fields which is represented by nested elements or a text,
/// it may be serialized as self-closed element `<variant/>`.
/// Classification of the result of the last serialized element.
/// Helper struct which remembers the classification of the last serialized element
/// and reports it when the sequence ends
UnitEscaped/// Struct with a special `$text` field
/// Struct with a special `$value` field
/// Attributes identified by starting with `@` character
AttributesBeforeAttributesAfter/// Variant name becomes a tag name, but the name of variant is invalid
/// XML name. Serialization of this element should be forbidden
/// Should be serialized as elements
SpecialEnum/// Struct variant with a special `$text` field
/// Struct variant with a special `$value` field
serialize_as/// Checks that given `$data` successfully serialized as `$expected`
/// Checks that attempt to serialize given `$data` results to a
/// serialization error `$kind` with `$reason`
// Primitives is serialized in the same way as for SimpleTypeSerializer
// Unlike SimpleTypeSerializer, enumeration values serialized as tags
// Newtypes recursively applies ContentSerializer
// Note that sequences of primitives serialized without delimiters!
// Structured types cannot be serialized without surrounding tag, which
// only `enum` can provide
text_field/// Special field name `$text` should be serialized as a text content
// We have no space where name of a variant can be stored
// Sequences are serialized separated by spaces, all spaces inside are escaped
// Complex types cannot be serialized in `$text` field
enum_with_text_field/// `$text` field inside a struct variant of an enum
// We cannot wrap map or struct in any container and should not
// flatten it, so it is impossible to serialize maps and structs
enum_with_value_field/// `$value` field inside a struct variant of an enum
without_indentIndentation/// Special field name `$text` should be serialized as text content
with_indent/// Make tests public to reuse types in `elements::tests` module
//! Contains serializer for content of an XML element
SimpleSeqTextSerializer/// Writes simple type content between [`ElementSerializer::key`] tags.
/// The inner serializer that contains the settings and mostly do the actual work
/// Tag name used to wrap serialized types except enum variants which uses the variant name
/// A serializer used to serialize element with specified name. Unlike the [`ContentSerializer`],
/// this serializer never uses variant names of enum variants, and because of that
/// it is unable to serialize any enum values, except unit variants.
/// This serializer is used for an ordinary fields in structs, which are not special
/// fields named `$text` ([`TEXT_KEY`]) or `$value` ([`VALUE_KEY`]). `$text` field
/// should be serialized using [`SimpleTypeSerializer`] and `$value` field should be
/// serialized using [`ContentSerializer`].
/// - numbers converted to a decimal representation and serialized as `<key>value</key>`;
/// - booleans serialized ether as `<key>true</key>` or `<key>false</key>`;
/// - strings and characters are serialized as `<key>value</key>`. In particular,
///   an empty string is serialized as `<key/>`;
/// - `None` is serialized as `<key/>`;
/// - units (`()`) and unit structs are serialized as `<key/>`;
/// - sequences, tuples and tuple structs are serialized as repeated `<key>` tag.
///   In particular, empty sequence is serialized to nothing;
/// - structs are serialized as a sequence of fields wrapped in a `<key>` tag. Each
///   field is serialized recursively using either `ElementSerializer`, [`ContentSerializer`]
///   (`$value` fields), or [`SimpleTypeSerializer`] (`$text` fields).
///   In particular, the empty struct is serialized as `<key/>`;
/// - maps are serialized as a sequence of entries wrapped in a `<key>` tag. If key is
///   serialized to a special name, the same rules as for struct fields are applied.
///   In particular, the empty map is serialized as `<key/>`;
///   - unit variants are serialized as `<key>variant</key>`;
///   - other variants are not supported ([`SeError::Unsupported`] is returned);
/// Usage of empty tags depends on the [`ContentSerializer::expand_empty_elements`] setting.
/// By serde contract we should serialize key of [`None`] values. If someone
/// wants to skip the field entirely, he should use
/// `#[serde(skip_serializing_if = "Option::is_none")]`.
/// In XML when we serialize field, we write field name as:
/// - element name, or
/// - attribute name
/// and field value as
/// - content of the element, or
/// - attribute value
/// So serialization of `None` works the same as [serialization of `()`](#method.serialize_unit)
/// Writes a tag with name [`Self::key`] and content of unit variant inside.
/// If variant is a special `$text` value, then empty tag `<key/>` is written.
/// Otherwise a `<key>variant</key>` is written.
/// Always returns [`SeError::Unsupported`]. Newtype variants can be serialized
/// only in `$value` fields, which is serialized using [`ContentSerializer`].
/// Always returns [`SeError::Unsupported`]. Tuple variants can be serialized
/// Always returns [`SeError::Unsupported`]. Struct variants can be serialized
/// Serialize each tuple field as an element
/// Serialize tuple as an `xs:list`: space-delimited content of fields
/// A serializer for tuple variants. Tuples can be serialized in two modes:
/// - wrapping each tuple field into a tag
/// - without wrapping, fields are delimited by a space
/// Buffer to store serialized elements
// TODO: Customization point: allow direct writing of elements, but all
// attributes should be listed first. Fail, if attribute encountered after
// element. Use feature to configure
/// Whether need to write indent after the last written field
/// A serializer for struct variants, which serializes the struct contents inside
/// of wrapping tags (`<${tag}>...</${tag}>`).
/// Serialization of each field depends on it representation:
/// - attributes written directly to the higher serializer
/// - elements buffered into internal buffer and at the end written into higher
///   serializer
write_fieldwrite_attribute/// Writes `value` as an attribute
write_element/// Writes `value` either as a text content, or as an element.
/// If `key` has a magic value [`TEXT_KEY`], then `value` serialized as a
/// [simple type].
/// If `key` has a magic value [`VALUE_KEY`], then `value` serialized as a
/// [content] without wrapping in tags, otherwise it is wrapped in
/// `<${key}>...</${key}>`.
/// [simple type]: SimpleTypeSerializer
/// [content]: ContentSerializer
/// Key, serialized by `QNameSerializer` if consumer uses `serialize_key` +
/// `serialize_value` calls instead of `serialize_entry`
make_keyOptionalElementsOptionalAttributes/// `$text` key in a map
/// `$text` field inside a struct
/// Special field name `$text` should be serialized as text content.
/// Sequences serialized as an `xs:list` content
/// `$value` key in a map
/// `$value` field inside a struct
value_field/// Special field name `$value` should be serialized using name, provided
/// by the type of value instead of a key. Sequences serialized as a list
/// of tags with that name (each element can have their own name)
/// Test for https://github.com/tafia/quick-xml/issues/252
/// Checks that given `$data` successfully serialized as `$expected`.
/// Writes `$data` using [`ElementSerializer`] with indent of two spaces.
//! Contains serializer for an XML element
/// Writer to which this serializer writes content
/// A serializer, that ensures, that only plain types can be serialized,
/// so result can be used as an XML tag or attribute name.
/// This serializer does not check that name does not contain characters that
/// [not allowed] in XML names, because in some cases it should pass names
/// that would be filtered on higher level.
/// [not allowed]: https://www.w3.org/TR/xml11/#sec-common-syn
/// Because unit type can be represented only by empty string which is not
/// a valid XML name, serialization of unit returns `Err(Unsupported)`
/// Because unit struct can be represented only by empty string which is not
/// a valid XML name, serialization of unit struct returns `Err(Unsupported)`
/// We cannot store both a variant discriminant and a variant value,
/// so serialization of enum newtype variant returns `Err(Unsupported)`
/// Implements writing primitives to the underlying writer.
/// Implementor must provide `write_str(self, &str) -> Result<(), DeError>` method
ToFmtWrite/// Serialize struct into a `Write`r.
/// # use quick_xml::se::to_writer;
/// # use serde::Serialize;
/// #[derive(Serialize)]
/// struct Root<'a> {
///     #[serde(rename = "@attribute")]
///     attribute: &'a str,
///     element: &'a str,
///     #[serde(rename = "$text")]
///     text: &'a str,
/// let data = Root {
///     attribute: "attribute content",
///     element: "element content",
///     text: "text content",
/// let mut buffer = String::new();
/// to_writer(&mut buffer, &data).unwrap();
///     buffer,
///     // The root tag name is automatically deduced from the struct name
///     // This will not work for other types or struct with #[serde(flatten)] fields
///     "<Root attribute=\"attribute content\">\
///         <element>element content</element>\
///         text content\
///     </Root>"
to_utf8_io_writer/// Serialize struct into a `io::Write`r restricted to utf-8 encoding.
/// # use quick_xml::se::to_utf8_io_writer;
/// # use std::io::BufWriter;
/// # use std::str;
/// let mut buffer = Vec::new();
/// to_utf8_io_writer(&mut BufWriter::new(&mut buffer), &data).unwrap();
///     str::from_utf8(&buffer).unwrap(),
/// Serialize struct into a `String`.
/// # use quick_xml::se::to_string;
///     to_string(&data).unwrap(),
to_writer_with_root/// Serialize struct into a `Write`r using specified root tag name.
/// `root_tag` should be valid [XML name], otherwise error is returned.
/// # use quick_xml::se::to_writer_with_root;
/// to_writer_with_root(&mut buffer, "top-level", &data).unwrap();
///     "<top-level attribute=\"attribute content\">\
///     </top-level>"
/// [XML name]: https://www.w3.org/TR/xml11/#NT-Name
to_string_with_root/// Serialize struct into a `String` using specified root tag name.
/// # use quick_xml::se::to_string_with_root;
///     to_string_with_root("top-level", &data).unwrap(),
/// Performs escaping, escape all characters that could have special meaning
/// in the XML. This mode is compatible with SGML specification.
/// Characters that will be replaced:
/// Original | Replacement
/// ---------|------------
/// `<`      | `&lt;`
/// `>`      | `&gt;`
/// `&`      | `&amp;`
/// `"`      | `&quot;`
/// `'`      | `&apos;`
/// Performs escaping that is compatible with SGML specification.
/// This level adds escaping of `>` to the `Minimal` level, which is [required]
/// for compatibility with SGML.
/// [required]: https://www.w3.org/TR/xml11/#syntax
/// Performs the minimal possible escaping, escape only strictly necessary
/// characters.
/// Defines which characters would be escaped in [`Text`] events and attribute
/// Text with insignificant spaces was written, for example a number. Adding indent to the
/// serialized data does not change meaning of the data.
/// The XML tag was written. Adding indent to the serialized data does not change meaning of the data.
/// Nothing was written (i. e. serialized type not represented in XML a all). Adding indent to the
/// serialized data does not change meaning of the data. This is returned for units, unit structs
/// and unit variants.
SensitiveText/// Text with significant spaces was written, for example a string. Adding indent to the
/// serialized data may change meaning of the data.
SensitiveNothing/// `None` was serialized and nothing was written. `None` does not represented in XML,
/// but adding indent after it may change meaning of the data.
/// Classification of the type written by the serializer.
allow_indent/// Returns `true` if indent should be written after the object (if configured) and `false` otherwise.
/// Returns `true` if self is `Text` or `SensitiveText`.
/// Implements serialization method by forwarding it to the serializer created by
/// the helper method [`Serializer::ser`].
is_xml11_name_start_char/// Almost all characters can form a name. Citation from <https://www.w3.org/TR/xml11/#sec-xml11>:
/// > The overall philosophy of names has changed since XML 1.0. Whereas XML 1.0
/// > provided a rigid definition of names, wherein everything that was not permitted
/// > was forbidden, XML 1.1 names are designed so that everything that is not
/// > forbidden (for a specific reason) is permitted. Since Unicode will continue
/// > to grow past version 4.0, further changes to XML can be avoided by allowing
/// > almost any character, including those not yet assigned, in names.
/// <https://www.w3.org/TR/xml11/#NT-NameStartChar>
is_xml11_name_char/// <https://www.w3.org/TR/xml11/#NT-NameChar>
/// Helper struct to self-defense from errors
/// Checks correctness of the XML name according to [XML 1.1 specification]
/// [XML 1.1 specification]: https://www.w3.org/TR/xml11/#NT-Name
/// No indent should be written before the element
/// The specified indent should be written. The type owns the buffer with indent
/// The specified indent should be written. The type borrows buffer with indent
/// from its owner
root_tag/// Name of the root tag. If not specified, deduced from the structure name
/// A Serializer.
/// Creates a new `Serializer` that uses struct name as a root tag name.
/// Note, that attempt to serialize a non-struct (including unit structs
/// and newtype structs) will end up to an error. Use `with_root` to create
/// serializer with explicitly defined root element name
with_root/// Creates a new `Serializer` that uses specified root tag name. `name` should
/// be valid [XML name], otherwise error is returned.
/// When serializing a primitive type, only its representation will be written:
/// # use quick_xml::se::Serializer;
/// let ser = Serializer::with_root(&mut buffer, Some("root")).unwrap();
/// "node".serialize(ser).unwrap();
/// assert_eq!(buffer, "<root>node</root>");
/// When serializing a struct, newtype struct, unit struct or tuple `root_tag`
/// is used as tag name of root(s) element(s):
/// #[derive(Debug, PartialEq, Serialize)]
/// struct Struct {
///     question: String,
///     answer: u32,
/// let data = Struct {
///     question: "The Ultimate Question of Life, the Universe, and Everything".into(),
///     answer: 42,
/// data.serialize(ser).unwrap();
///     "<root>\
///         <question>The Ultimate Question of Life, the Universe, and Everything</question>\
///         <answer>42</answer>\
///      </root>"
/// Enable or disable expansion of empty elements. Defaults to `false`.
///     question: Option<String>,
/// let mut ser = Serializer::new(&mut buffer);
/// ser.expand_empty_elements(true);
///   question: None,
///     "<Struct><question></question></Struct>"
/// Configure indent for a serializer
set_quote_level/// Set the level of quoting used when writing texts
/// Default: [`QuoteLevel::Minimal`]
/// Set the indent object for a serializer
/// Creates actual serializer or returns an error if root tag is not defined.
/// In that case `err` contains the name of type that cannot be serialized.
ser_name/// Creates actual serializer using root tag or a specified `key` if root tag
/// is not defined. Returns an error if root tag is not defined and a `key`
/// does not conform [XML rules](XmlName::try_from) for names.
Exampledefault_partialquote_level//! Module to handle custom serde `Serializer`
/// Escape data for a text content. No additional escape symbols
DoubleQAttr/// Escape data for a double-quoted attribute. `"` always escaped
SingleQAttr/// Escape data for a single-quoted attribute. `'` always escaped
escape_item/// Escapes atomic value that could be part of a `xs:list`. All whitespace characters
/// additionally escaped
escape_list/// Escapes XSD simple type value
write_atomic/// Defines which XML characters need to be escaped
write_delimiter/// When `true` an `xs:list` delimiter (a space) should be written
/// A serializer that handles ordinary [simple type definition][item] with
/// This serializer can serialize only primitive types:
/// Identifiers represented as strings and serialized accordingly.
/// Serialization of all other types returns [`Unsupported`][SeError::Unsupported] error.
/// This serializer returns `true` if something was written and `false` otherwise.
/// We cannot store anything, so the absence of a unit and presence of it
/// does not differ, so serialization of unit returns `Err(Unsupported)`
/// Target for which element is serializing. Affects additional characters to escape.
/// A serializer for a values representing XSD [simple types], which used in:
/// - text content (`<...>text</...>`)
/// - CDATA content (`<...><![CDATA[cdata]]></...>`)
/// If `true`, nothing was written yet to the `writer`
/// Serializer for a sequence of atomic values delimited by space
double_quote_attrsingle_quote_attr/// Tests for serialize atomic and union values, as defined in XSD specification
empty_seqall_items_emptysome_items_empty1some_items_empty2simple_seq//! Contains Serde `Serializer` for XML [simple types] [as defined] in the XML Schema.
/// A serializer used to serialize a `$text` field of a struct or map.
/// This serializer a very similar to [`SimpleTypeSerializer`], but different
/// from it in how it processes unit enum variants. Unlike [`SimpleTypeSerializer`]
/// this serializer does not write anything for the unit variant.
//! Contains serializer for a special `&text` field
deserialize_variant// Produce struct enum variant
// Produce newtype enum variant
// Produce unit enum variant
deserialize_match// Only default variant
// With default variant
// Without default variant
/// Helper macro that generates different match expressions depending on the presence
/// of default variant
impl_deserialize_for_internally_tagged_enum/// A helper to implement [`Deserialize`] for [internally tagged] enums which
/// does not use [`Deserializer::deserialize_any`] that produces wrong results
/// with XML because of [serde#1183].
/// In contrast to deriving [`Deserialize`] this macro assumes that a tag will be
/// the first element or attribute in the XML.
/// use quick_xml::de::from_str;
/// use quick_xml::impl_deserialize_for_internally_tagged_enum;
/// #[derive(Deserialize, Debug, PartialEq)]
/// struct Root {
///     one: InternallyTaggedEnum,
///     two: InternallyTaggedEnum,
///     three: InternallyTaggedEnum,
/// #[derive(Debug, PartialEq)]
/// // #[serde(tag = "@tag")]
/// enum InternallyTaggedEnum {
///     Unit,
///     Newtype(Newtype),
///     Struct {
///         // #[serde(rename = "@attribute")]
///         attribute: u32,
///         element: f32,
///     },
/// struct Newtype {
///     attribute: u64,
/// // The macro needs the type of the enum, the tag name,
/// // and information about all the variants
/// impl_deserialize_for_internally_tagged_enum!{
///     InternallyTaggedEnum, "@tag",
///     ("Unit"    => Unit),
///     ("Newtype" => Newtype(Newtype)),
///     ("Struct"  => Struct {
///         #[serde(rename = "@attribute")]
///     }),
///     from_str::<Root>(r#"
///         <root>
///             <one tag="Unit" />
///             <two tag="Newtype" attribute="42" />
///             <three tag="Struct" attribute="42">
///                 <element>4.2</element>
///             </three>
///         </root>
///     "#).unwrap(),
///     Root {
///         one: InternallyTaggedEnum::Unit,
///         two: InternallyTaggedEnum::Newtype(Newtype { attribute: 42 }),
///         three: InternallyTaggedEnum::Struct {
///             attribute: 42,
///             element: 4.2,
/// You don't necessarily have to provide all the enumeration variants and can use
/// `_` to put every undefined tag into an enumeration variant.
/// This default variant (`_ => ...`) must be the last one to appear in the macro,
/// like `_ => Other` in the example below:
///     NewType(Newtype),
///     Other,
///     ("NewType" => NewType(Newtype)),
///     (_ => Other),
///             <one tag="NewType" attribute="42" />
///             <two tag="Something" ignoredAttribute="something" />
///             <three tag="SomethingElse">
///                 <ignoredToo />
///         one: InternallyTaggedEnum::NewType(Newtype { attribute: 42 }),
///         two: InternallyTaggedEnum::Other,
///         three: InternallyTaggedEnum::Other,
/// [internally tagged]: https://serde.rs/enum-representations.html#internally-tagged
/// [serde#1183]: https://github.com/serde-rs/serde/issues/1183
/// Serializes `value` as an XSD [simple type]. Intended to use with
/// `#[serde(serialize_with = "...")]`. See example at [`text_content`]
/// module level.
/// Deserializes XSD's [simple type]. Intended to use with
/// `#[serde(deserialize_with = "...")]`. See example at [`text_content`]
text_content/// Provides helper functions to serialization and deserialization of types
/// (usually enums) as a text content of an element and intended to use with
/// [`#[serde(with = "...")]`][with], [`#[serde(deserialize_with = "...")]`][de-with]
/// and [`#[serde(serialize_with = "...")]`][se-with].
/// use quick_xml::se::to_string;
/// use serde::{Serialize, Deserialize};
/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
/// enum SomeEnum {
///     // Default implementation serializes enum as an `<EnumValue/>` element
///     EnumValue,
/// # /*
///     ...
/// # */
/// #[serde(rename = "some-container")]
/// struct SomeContainer {
///     #[serde(with = "quick_xml::serde_helpers::text_content")]
///     field: SomeEnum,
/// let container = SomeContainer {
///     field: SomeEnum::EnumValue,
/// let xml = "\
///     <some-container>\
///         <field>EnumValue</field>\
///     </some-container>";
/// assert_eq!(to_string(&container).unwrap(), xml);
/// assert_eq!(from_str::<SomeContainer>(xml).unwrap(), container);
/// Using of this module is equivalent to replacing `field`'s type to this:
/// # use serde::{Deserialize, Serialize};
/// # type SomeEnum = ();
/// #[derive(Serialize, Deserialize)]
/// struct Field {
///     // Use a special name `$text` to map field to the text content
///     content: SomeEnum,
///     field: Field,
/// Read about the meaning of a special [`$text`] field.
/// In versions of quick-xml before 0.31.0 this module used to represent enum
/// unit variants as `<field>EnumUnitVariant</field>` instead of `<EnumUnitVariant/>`.
/// Since version 0.31.0 this is default representation of enums in normal fields,
/// and `<EnumUnitVariant/>` requires `$value` field:
///     #[serde(rename = "$value")]
///         <EnumValue/>\
/// [with]: https://serde.rs/field-attrs.html#with
/// [de-with]: https://serde.rs/field-attrs.html#deserialize_with
/// [se-with]: https://serde.rs/field-attrs.html#serialize_with
/// [`$text`]: ../../de/index.html#text
//! Provides helper functions to glue an XML with a serde content model.
/// An input taken from an external deserializer, owned by that deserializer
/// is a deserializer input.
/// - `'i`: lifetime of the data that deserializer borrow from the parsed input
/// - `'s`: lifetime of the data that owned by a deserializer
/// Wrapper around `Vec<u8>` that has a human-readable debug representation:
/// printable ASCII symbols output as is, all other output in HEX notation.
/// Also, when [`serialize`] feature is on, this type deserialized using
/// [`deserialize_byte_buf`](serde::Deserializer::deserialize_byte_buf) instead
/// of vector's generic [`deserialize_seq`](serde::Deserializer::deserialize_seq)
/// [`serialize`]: ../index.html#serialize
/// Wrapper around `&[u8]` that has a human-readable debug representation:
/// [`deserialize_bytes`](serde::Deserializer::deserialize_bytes) instead
/// That piece of data repeated infinitely...
/// Part of `chunk` that was consumed by BufRead impl
overall_read/// The overall count of read bytes
Fountain/// A simple producer of infinite stream of bytes, useful in tests.
/// Will repeat `chunk` field indefinitely.
/// A function to check whether the byte is a whitespace (blank, new line, carriage return or tab).
/// Calculates name from an element-like content. Name is the first word in `content`,
/// where word boundaries is XML whitespace characters.
/// 'Whitespace' refers to the definition used by [`is_whitespace`].
/// Returns a byte slice with leading XML whitespace bytes removed.
/// Returns a byte slice with trailing XML whitespace bytes removed.
write_byte_string0write_byte_string1write_byte_string3write_event_async/// Writes the given event to the underlying writer. Async version of [`Writer::write_event`].
write_indent_async/// Manually write a newline and indentation at the proper level. Async version of
/// [`Writer::write_indent`].
/// This method will do nothing if `Writer` was not constructed with [`Writer::new_with_indent`].
write_wrapped_asyncwrite_text_content_async/// Write some text inside the current element.
/// # use quick_xml::events::BytesText;
/// # use tokio::io::AsyncWriteExt;
/// # #[tokio::main(flavor = "current_thread")] async fn main() {
/// let mut tokio_buffer = tokio::io::BufWriter::new(&mut buffer);
/// let mut writer = Writer::new_with_indent(&mut tokio_buffer, b' ', 4);
/// writer
///     .create_element("paired")
///     .with_attribute(("attr1", "value1"))
///     .with_attribute(("attr2", "value2"))
///     .write_text_content_async(BytesText::new("text"))
///     .await
///     .expect("cannot write content");
/// tokio_buffer.flush().await.expect("flush failed");
///     std::str::from_utf8(&buffer).unwrap(),
///     r#"<paired attr1="value1" attr2="value2">text</paired>"#
write_cdata_content_async/// Write a CData event `<![CDATA[...]]>` inside the current element.
///     .write_cdata_content_async(BytesCData::new("text & content"))
///     r#"<paired attr1="value1" attr2="value2"><![CDATA[text & content]]></paired>"#
write_pi_content_async/// Write a processing instruction `<?...?>` inside the current element.
/// # use quick_xml::events::BytesPI;
///     .write_pi_content_async(BytesPI::new(r#"xml-stylesheet href="style.css""#))
///     r#"<paired attr1="value1" attr2="value2">
///     <?xml-stylesheet href="style.css"?>
/// </paired>"#
write_empty_async/// Write an empty (self-closing) tag.
///     .create_element("empty")
///     .write_empty_async()
///     r#"<empty attr1="value1" attr2="value2"/>"#
write_inner_content_async/// Create a new scope for writing XML inside the current element.
///     .create_element("outer")
///     .with_attributes([("attr1", "value1"), ("attr2", "value2")])
///     // We need to provide error type, because it is not named somewhere explicitly
///     .write_inner_content_async::<_, _, Error>(|writer| async move {
///         let fruits = ["apple", "orange", "banana"];
///         for (quant, item) in fruits.iter().enumerate() {
///             writer
///                 .create_element("fruit")
///                 .with_attributes([("quantity", quant.to_string().as_str())])
///                 .write_text_content_async(BytesText::new(item))
///                 .await?;
///         writer
///             .create_element("inner")
///             .write_inner_content_async(|writer| async move {
///                 writer.create_element("empty").write_empty_async().await
///             })
///             .await?;
///         Ok(writer)
///     })
///     r#"<outer attr1="value1" attr2="value2">
///     <fruit quantity="0">apple</fruit>
///     <fruit quantity="1">orange</fruit>
///     <fruit quantity="2">banana</fruit>
///     <inner>
///         <empty/>
///     </inner>
/// </outer>"#
full_tagempty_pairedpaired_with_innerpaired_with_textmixed_contentindentation_async/// underlying writer
/// XML writer. Writes XML [`Event`]s to a [`std::io::Write`] implementor.
/// use quick_xml::events::{Event, BytesEnd, BytesStart};
/// use quick_xml::writer::Writer;
/// let xml = r#"<this_tag k1="v1" k2="v2"><child>text</child></this_tag>"#;
/// let mut writer = Writer::new(Cursor::new(Vec::new()));
///     match reader.read_event() {
///         Ok(Event::Start(e)) if e.name().as_ref() == b"this_tag" => {
///             // crates a new element ... alternatively we could reuse `e` by calling
///             // `e.into_owned()`
///             let mut elem = BytesStart::new("my_elem");
///             // collect existing attributes
///             elem.extend_attributes(e.attributes().map(|attr| attr.unwrap()));
///             // copy existing attributes, adds a new my-key="some value" attribute
///             elem.push_attribute(("my-key", "some value"));
///             // writes the event to the writer
///             assert!(writer.write_event(Event::Start(elem)).is_ok());
///         Ok(Event::End(e)) if e.name().as_ref() == b"this_tag" => {
///             assert!(writer.write_event(Event::End(BytesEnd::new("my_elem"))).is_ok());
///         // we can either move or borrow the event to write, depending on your use-case
///         Ok(e) => assert!(writer.write_event(e.borrow()).is_ok()),
/// let result = writer.into_inner().into_inner();
/// let expected = r#"<my_elem k1="v1" k2="v2" my-key="some value"><child>text</child></my_elem>"#;
/// assert_eq!(result, expected.as_bytes());
/// Creates a `Writer` from a generic writer.
new_with_indent/// Creates a `Writer` with configured indents from a generic writer.
/// Consumes this `Writer`, returning the underlying writer.
/// Get a mutable reference to the underlying writer.
/// Get a reference to the underlying writer.
/// Provides a simple, high-level API for writing XML elements.
/// Returns an [`ElementWriter`] that simplifies setting attributes and writing
/// content inside the element.
/// # use quick_xml::Result;
/// # fn main() -> Result<()> {
/// use quick_xml::events::{BytesStart, BytesText, Event};
/// // writes <tag attr1="value1"/>
/// writer.create_element("tag")
///     .with_attribute(("attr1", "value1"))  // chain `with_attribute()` calls to add many attributes
///     .write_empty()?;
/// // writes <tag attr1="value1" attr2="value2">with some text inside</tag>
///     .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter())  // or add attributes from an iterator
///     .write_text_content(BytesText::new("with some text inside"))?;
/// // writes <tag><fruit quantity="0">apple</fruit><fruit quantity="1">orange</fruit></tag>
///     .write_inner_content(|writer| {
///         let fruits = ["apple", "orange"];
///                 .with_attribute(("quantity", quant.to_string().as_str()))
///                 .write_text_content(BytesText::new(item))?;
///     })?;
write_bom/// Write a [Byte-Order-Mark] character to the document.
/// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
/// writer.write_bom()?;
///     .write_empty()
///     .expect("failure");
///     "\u{FEFF}<empty attr1=\"value1\"/>"
/// [Byte-Order-Mark]: https://unicode.org/faq/utf_bom.html#BOM
write_event/// Writes the given event to the underlying writer.
/// Writes bytes
/// Manually write a newline and indentation at the proper level.
/// This can be used when the heuristic to line break and indent after any
/// [`Event`] apart from [`Text`] fails such as when a [`Start`] occurs directly
/// after [`Text`].
/// This method will do nothing if `Writer` was not constructed with [`new_with_indent`].
/// [`new_with_indent`]: Self::new_with_indent
AttributeIndentNoneAttributesWritten/// Initial state. `ElementWriter` was just created and no attributes written yet
WriteSpaces/// Write specified count of spaces to indent before writing attribute in `with_attribute()`
Spaces/// Keep space indent that should be used if `new_line()` would be called
WriteConfigured/// Write specified count of indent characters before writing attribute in `with_attribute()`
/// Keep indent that should be used if `new_line()` would be called
/// Track indent inside elements state
/// stateDiagram-v2
///     [*] --> NoneAttributesWritten
///     NoneAttributesWritten --> Spaces : .with_attribute()
///     NoneAttributesWritten --> WriteConfigured : .new_line()
///     Spaces --> Spaces : .with_attribute()
///     Spaces --> WriteSpaces : .new_line()
///     WriteSpaces --> Spaces : .with_attribute()
///     WriteSpaces --> WriteSpaces : .new_line()
///     Configured --> Configured : .with_attribute()
///     Configured --> WriteConfigured : .new_line()
///     WriteConfigured --> Configured : .with_attribute()
///     WriteConfigured --> WriteConfigured : .new_line()
start_tag/// Contains spaces used to write space indents of attributes
/// A struct to write an element. Contains methods to add attributes and inner
/// elements to the element
with_attribute/// Add additional attributes to this element using an iterator.
new_line/// Push a new line inside an element between attributes. Note, that this
/// method does nothing if [`Writer`] was created without indentation support.
/// The following code
/// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 2);
///   .create_element("element")
///     //.new_line() (1)
///     .with_attribute(("first", "1"))
///     .with_attribute(("second", "2"))
///     .new_line()
///     .with_attributes([
///         ("third", "3"),
///         ("fourth", "4"),
///     ])
///     //.new_line() (2)
///     .write_empty();
/// will produce the following XMLs:
/// <!-- result of the code above. Spaces always is used -->
/// <element first="1" second="2"
///          third="3" fourth="4"/>
/// <!-- if uncomment only (1) - indent depends on indentation
///      settings - 2 spaces here -->
/// <element
///   first="1" second="2"
///   third="3" fourth="4"/>
/// <!-- if uncomment only (2). Spaces always is used  -->
///          third="3" fourth="4"
/// />
write_attr/// Writes attribute and maintain indentation state
write_text_contentwrite_cdata_contentwrite_pi_contentwrite_inner_contentshould_line_break/// todo: this is an awkward fit as it has no impact on indentation logic, but it is
/// only applicable when an indentation exists. Potentially refactor later
indent_char/// The character code to be used for indentations (e.g. ` ` or `\t`)
indent_size/// How many instances of the indent character ought to be used for each level of indentation
indents/// Used as a cache for the bytes used for indentation
current_indent_len/// The current amount of indentation
/// Increase indentation by one level
/// Decrease indentation by one level. Do nothing, if level already zero
/// Returns indent string for current level
/// Returns indent with current indent plus additional indent
//! Contains high-level interface for an events-based XML emitter.
ConnectionEventVarIntAsyncTimerAsyncUdpSocketRuntimeUdpPollerudp_transmitConnectionHandleConnectionStatsEndpointEventSideStreamEventStreamIdcongestionControllerConnectionRefhandshake_data_ready/// In-progress connection attempt futureinto_0rttZeroRttAccepted/// Convert into a 0-RTT or 0.5-RTT connection at the cost of weakened security/// Returns `Ok` immediately if the local endpoint is able to attempt sending 0/0.5-RTT data./// If so, the returned [`Connection`] can be used to send application data without waiting for/// the rest of the handshake to complete, at the cost of weakened cryptographic security/// guarantees. The returned [`ZeroRttAccepted`] future resolves when the handshake does/// complete, at which point subsequently opened streams and written data will have full/// cryptographic protection./// ## Outgoing/// For outgoing connections, the initial attempt to convert to a [`Connection`] which sends/// 0-RTT data will proceed if the [`crypto::ClientConfig`][crate::crypto::ClientConfig]/// attempts to resume a previous TLS session. However, **the remote endpoint may not actually/// _accept_ the 0-RTT data**--yet still accept the connection attempt in general. This/// possibility is conveyed through the [`ZeroRttAccepted`] future--when the handshake/// completes, it resolves to true if the 0-RTT data was accepted and false if it was rejected./// If it was rejected, the existence of streams opened and other application data sent prior/// to the handshake completing will not be conveyed to the remote application, and local/// operations on them will return `ZeroRttRejected` errors./// A server may reject 0-RTT data at its discretion, but accepting 0-RTT data requires the/// relevant resumption state to be stored in the server, which servers may limit or lose for/// various reasons including not persisting resumption state across server restarts./// If manually providing a [`crypto::ClientConfig`][crate::crypto::ClientConfig], check your/// implementation's docs for 0-RTT pitfalls./// ## Incoming/// For incoming connections, conversion to 0.5-RTT will always fully succeed. `into_0rtt` will/// always return `Ok` and the [`ZeroRttAccepted`] will always resolve to true./// If manually providing a [`crypto::ServerConfig`][crate::crypto::ServerConfig], check your/// ## Security/// On outgoing connections, this enables transmission of 0-RTT data, which is vulnerable to/// replay attacks, and should therefore never invoke non-idempotent operations./// On incoming connections, this enables transmission of 0.5-RTT data, which may be sent/// before TLS client authentication has occurred, and should therefore not be used to send/// data for which client authentication is being used.handshake_data/// Parameters negotiated during the handshake/// The dynamic type returned is determined by the configured/// [`Session`](proto::crypto::Session). For the default `rustls` session, the return value can/// be [`downcast`](Box::downcast) to a/// [`crypto::rustls::HandshakeData`](crate::crypto::rustls::HandshakeData).local_ip/// The local IP address which was used when the peer established/// the connection/// This can be different from the address the endpoint is bound to, in case/// the endpoint is bound to a wildcard address like `0.0.0.0` or `::`./// This will return `None` for clients, or when the platform does not expose this/// information. See [`quinn_udp::RecvMeta::dst_ip`](udp::RecvMeta::dst_ip) for a list of/// supported platforms when using [`quinn_udp`](udp) for I/O, which is the default./// Will panic if called after `poll` has returned `Ready`./// The peer's UDP address/// Future that completes when a connection is fully established/// For clients, the resulting value indicates if 0-RTT was accepted. For servers, the resulting/// value is meaningless."connection drivers must be spawned for their connections to function"ConnectionDriver/// A future that drives protocol logic for a connection/// This future handles the protocol logic for a single connection, routing events from the/// `Connection` API object to the `Endpoint` task and the related stream-related interfaces./// It also keeps track of outstanding timeouts for the `Connection`./// If the connection encounters an error condition, this future will yield an error. It will/// terminate (yielding `Ok(())`) if the connection was closed without error. Unlike other/// connection-related futures, this waits for the draining period to complete to ensure that/// packets still in flight from the peer are handled gracefully./// A QUIC connection./// If all references to a connection (including every clone of the `Connection` handle, streams of/// incoming streams, and the various stream types) have been dropped, then the connection will be/// automatically closed with an `error_code` of 0 and an empty `reason`. You can also close the/// connection explicitly by calling [`Connection::close()`]./// Closing the connection immediately abandons efforts to deliver data to the peer.  Upon/// receiving CONNECTION_CLOSE the peer *may* drop any stream data not yet delivered to the/// application. [`Connection::close()`] describes in more detail how to gracefully close a/// connection without losing application data./// May be cloned to obtain another handle to the same connection./// [`Connection::close()`]: Connection::closeopen_uniOpenUni/// Initiate a new outgoing unidirectional stream./// Streams are cheap and instantaneous to open unless blocked by flow control. As a/// consequence, the peer won't be notified that a stream has been opened until the stream is/// actually used.open_biOpenBi/// Initiate a new outgoing bidirectional stream./// actually used. Calling [`open_bi()`] then waiting on the [`RecvStream`] without writing/// anything to [`SendStream`] will never succeed./// [`open_bi()`]: crate::Connection::open_bi/// [`SendStream`]: crate::SendStream/// [`RecvStream`]: crate::RecvStreamaccept_uniAcceptUni/// Accept the next incoming uni-directional streamaccept_biAcceptBi/// Accept the next incoming bidirectional stream/// **Important Note**: The `Connection` that calls [`open_bi()`] must write to its [`SendStream`]/// before the other `Connection` is able to `accept_bi()`. Calling [`open_bi()`] then/// waiting on the [`RecvStream`] without writing anything to [`SendStream`] will never succeed./// [`accept_bi()`]: crate::Connection::accept_biread_datagramReadDatagram/// Receive an application datagram/// Wait for the connection to be closed for any reason/// Despite the return type's name, closed connections are often not an error condition at the/// application layer. Cases that might be routine include [`ConnectionError::LocallyClosed`]/// and [`ConnectionError::ApplicationClosed`].close_reason/// If the connection is closed, the reason why./// Returns `None` if the connection is still open./// Close the connection immediately./// Pending operations will fail immediately with [`ConnectionError::LocallyClosed`]. No/// more data is sent to the peer and the peer may drop buffered data upon receiving/// the CONNECTION_CLOSE frame./// `error_code` and `reason` are not interpreted, and are provided directly to the peer./// `reason` will be truncated to fit in a single packet with overhead; to improve odds that it/// is preserved in full, it should be kept under 1KiB./// # Gracefully closing a connection/// Only the peer last receiving application data can be certain that all data is/// delivered. The only reliable action it can then take is to close the connection,/// potentially with a custom error code. The delivery of the final CONNECTION_CLOSE/// frame is very likely if both endpoints stay online long enough, and/// [`Endpoint::wait_idle()`] can be used to provide sufficient time. Otherwise, the/// remote peer will time out the connection, provided that the idle timeout is not/// The sending side can not guarantee all stream data is delivered to the remote/// application. It only knows the data is delivered to the QUIC stack of the remote/// endpoint. Once the local side sends a CONNECTION_CLOSE frame in response to calling/// [`close()`] the remote endpoint may drop any data it received but is as yet/// undelivered to the application, including data that was acknowledged as received to/// the local endpoint./// [`ConnectionError::LocallyClosed`]: crate::ConnectionError::LocallyClosed/// [`Endpoint::wait_idle()`]: crate::Endpoint::wait_idle/// [`close()`]: Connection::closesend_datagramSendDatagramError/// Transmit `data` as an unreliable, unordered application datagram/// Application datagrams are a low-level primitive. They may be lost or delivered out of order,/// and `data` must both fit inside a single QUIC packet and be smaller than the maximum/// dictated by the peer./// Previously queued datagrams which are still unsent may be discarded to make space for this/// datagram, in order of oldest to newest.send_datagram_waitSendDatagram/// Unlike [`send_datagram()`], this method will wait for buffer space during congestion/// conditions, which effectively prioritizes old datagrams over new datagrams./// See [`send_datagram()`] for details./// [`send_datagram()`]: Connection::send_datagrammax_datagram_size/// Compute the maximum size of datagrams that may be passed to [`send_datagram()`]./// Returns `None` if datagrams are unsupported by the peer or disabled locally./// This may change over the lifetime of a connection according to variation in the path MTU/// estimate. The peer can also enforce an arbitrarily small fixed limit, but if the peer's/// limit is large this is guaranteed to be a little over a kilobyte at minimum./// Not necessarily the maximum size of received datagrams.datagram_send_buffer_space/// Bytes available in the outgoing datagram buffer/// When greater than zero, calling [`send_datagram()`](Self::send_datagram) with a datagram of/// at most this size is guaranteed not to cause older datagrams to be dropped.side/// The side of the connection (client or server)/// If `ServerConfig::migration` is `true`, clients may change addresses at will, e.g. when/// switching to a cellular internet connection./// Current best estimate of this connection's latency (round-trip-time)/// Returns connection statisticscongestion_state/// Current state of the congestion control algorithm, for debugging purposes/// Guaranteed to return `Some` on fully established connections or after/// [`Connecting::handshake_data()`] succeeds. See that method's documentations for details on/// the returned value./// [`Connection::handshake_data()`]: crate::Connecting::handshake_datapeer_identity/// Cryptographic identity of the peer/// be [`downcast`](Box::downcast) to a <code>Vec<[rustls::pki_types::CertificateDer]></code>stable_id/// A stable identifier for this connection/// Peer addresses and connection IDs can change, but this value will remain/// fixed for the lifetime of the connection.force_key_update/// Update traffic keys spontaneously/// This primarily exists for testing purposes.ExportKeyingMaterialError/// Derive keying material from this connection's TLS session secrets./// When both peers call this method with the same `label` and `context`/// arguments and `output` buffers of equal length, they will get the/// same sequence of bytes in `output`. These bytes are cryptographically/// strong and pseudorandom, and are suitable for use as keying material./// See [RFC5705](https://tools.ietf.org/html/rfc5705) for more information.set_max_concurrent_uni_streams/// Modify the number of remotely initiated unidirectional streams that may be concurrently open/// No streams may be opened by the peer unless fewer than `count` are already open. Large/// `count`s increase both minimum and worst-case memory consumption.set_send_window/// See [`proto::TransportConfig::send_window()`]set_receive_window/// See [`proto::TransportConfig::receive_window()`]set_max_concurrent_bi_streams/// Modify the number of remotely initiated bidirectional streams that may be concurrently openr" Future produced by [`Connection::open_uni`]"r" Future produced by [`Connection::open_bi`]"poll_openr" Future produced by [`Connection::accept_uni`]"r" Future produced by [`Connection::accept_bi`]"poll_acceptr" Future produced by [`Connection::read_datagram`]"r" Future produced by [`Connection::send_datagram_wait`]"ConnectionInnerstream_budget_available/// Notified when new streams may be locally initiated due to an increase in stream ID flow/// control budgetstream_incoming/// Notified when the peer has initiated a new streamdatagram_receiveddatagrams_unblockedon_handshake_dataon_connectedtimer_deadlineconn_eventsendpoint_eventsblocked_writersblocked_readers/// Always set to Some before the connection becomes drained/// Number of live handles that can be used to initiate or handle I/O; excludes the driverio_pollersend_bufferbuffered_transmitTransmit/// We buffer a transmit when the underlying I/O would blockdrive_transmitforward_endpoint_eventsprocess_conn_events/// If this returns `Err`, the endpoint is dead, so the driver should exit immediately.forward_app_eventsdrive_timer/// Wake up a blocked `Driver` task to process I/Oterminate/// Used to wake up all blocked futures when the connection becomes closed for any reasonimplicit_close/// Close for a reason other than the application's explicit requestcheck_0rttwake_streamwake_allwake_stream_notifywake_all_notifyUnsupportedByPeer/// The peer does not support receiving datagram frames/// Datagram support is disabled locally/// The datagram is larger than the connection can currently accommodate/// Indicates that the path MTU minus overhead or the limit advertised by the peer has been/// exceeded.ConnectionLost/// The connection was lost/// Errors that can arise when sending a datagramMAX_TRANSMIT_DATAGRAMS/// The maximum amount of datagrams which will be produced in a single `drive_transmit` call/// This limits the amount of CPU resources consumed by datagram generation,/// and allows other tasks (like receiving ACKs) to run in between.MAX_TRANSMIT_SEGMENTS/// The maximum amount of datagrams that are sent in a single transmit/// This can be lower than the maximum platform capabilities, to avoid excessive/// memory allocations when calling `poll_transmit()`. Benchmarks have shown/// that numbers around 10 are a good compromise.default_runtimeDatagramEventServerConfigBATCH_SIZERecvMetaEndpointConfigIO_LOOP_BOUNDRECV_TIME_BOUNDwork_limiterWorkLimiterEndpointRefdefault_client_config/// A QUIC endpoint./// An endpoint corresponds to a single UDP socket, may host many connections, and may act as both/// client and server for different connections./// May be cloned to obtain another handle to the same endpoint./// Helper to construct an endpoint for use with outgoing connections only/// Note that `addr` is the *local* address to bind to, which should usually be a wildcard/// address like `0.0.0.0:0` or `[::]:0`, which allow communication with any reachable IPv4 or/// IPv6 address respectively from an OS-assigned port./// If an IPv6 address is provided, attempts to make the socket dual-stack so as to allow/// communication with both IPv4 and IPv6 addresses. As such, calling `Endpoint::client` with/// the address `[::]:0` is a reasonable default to maximize the ability to connect to other/// address. For example:/// quinn::Endpoint::client((std::net::Ipv6Addr::UNSPECIFIED, 0).into());/// Some environments may not allow creation of dual-stack sockets, in which case an IPv6/// client will only be able to connect to IPv6 servers. An IPv4 client is never dual-stack.// `EndpointConfig::default()` is only available with theseEndpointStats/// Returns relevant stats from this Endpoint/// Helper to construct an endpoint for use with both incoming and outgoing connections/// Platform defaults for dual-stack sockets vary. For example, any socket bound to a wildcard/// IPv6 address on Windows will not by default be able to communicate with IPv4/// addresses. Portable applications should bind an address that matches the family they wish to/// communicate within./// Construct an endpoint with arbitrary configuration and socketnew_with_abstract_socket/// Construct an endpoint with arbitrary configuration and pre-constructed abstract socket/// Useful when `socket` has additional state (e.g. sidechannels) attached for which shared/// ownership is needed./// Get the next incoming connection attempt from a client/// Yields [`Incoming`]s, or `None` if the endpoint is [`close`](Self::close)d. [`Incoming`]/// can be `await`ed to obtain the final [`Connection`](crate::Connection), or used to e.g./// filter connection attempts or force address validation, or converted into an intermediate/// `Connecting` future which can be used to e.g. send 0.5-RTT data.set_default_client_config/// Set the client configuration used by `connect`/// Connect to a remote endpoint/// `server_name` must be covered by the certificate presented by the server. This prevents a/// connection from being intercepted by an attacker with a valid certificate for some other/// May fail immediately due to configuration errors, or in the future if the connection could/// not be established.connect_with/// Connect to a remote endpoint using a custom configuration./// See [`connect()`] for details./// [`connect()`]: Endpoint::connectrebind/// Switch to a new UDP socket/// See [`Endpoint::rebind_abstract()`] for details.rebind_abstract/// Allows the endpoint's address to be updated live, affecting all active connections. Incoming/// connections and connections to servers unreachable from the new address will be lost./// On error, the old UDP socket is retained.set_server_config/// Replace the server configuration, affecting new incoming connections only/// Useful for e.g. refreshing TLS certificates without disrupting existing connections./// Get the local `SocketAddr` the underlying socket is bound toopen_connections/// Get the number of connections that are currently open/// Close all of this endpoint's connections immediately and cease accepting new connections./// See [`Connection::close()`] for details./// [`Connection::close()`]: crate::Connection::closewait_idle/// Wait for all connections on the endpoint to be cleanly shut down/// Waiting for this condition before exiting ensures that a good-faith effort is made to notify/// peers of recent connection closes, whereas exiting immediately could force them to wait out/// the idle timeout period./// Does not proactively close existing connections or cause incoming connections to be/// rejected. Consider calling [`close()`] if that is desired./// [`close()`]: Endpoint::closeaccepted_handshakes/// Cummulative number of Quic handshakes accepted by this [Endpoint]outgoing_handshakes/// Cummulative number of Quic handshakees sent from this [Endpoint]refused_handshakes/// Cummulative number of Quic handshakes refused on this [Endpoint]ignored_handshakes/// Cummulative number of Quic handshakes ignored on this [Endpoint]/// Statistics on [Endpoint] activity"endpoint drivers must be spawned for I/O to occur"EndpointDriver/// A future that drives IO on an endpoint/// This task functions as the switch point between the UDP socket object and the/// `Endpoint` responsible for routing datagrams to their owning `Connection`./// In order to do so, it also facilitates the exchange of different types of events/// flowing between the `Endpoint` and the tasks managing `Connection`s. As such,/// running this task is necessary to keep the endpoint's connections running./// `EndpointDriver` futures terminate when all clones of the `Endpoint` have been dropped, or when/// an I/O error occurs.EndpointInnerrefuseRetryErrorprev_socket/// During an active migration, abandoned_socket receives traffic/// until the first packet arrives on the new socket.recv_stateRecvStatedriver_lostdrive_recvrespondproto_ecnEcnCodepoint/// Senders for communicating with the endpoint's connections/// Stored to give out clones to new ConnectionInners/// Set if the endpoint has been manually closedConnectionSetensure_ipv6r" Future produced by [`Endpoint::accept`]"recv_bufrecv_limiter/// State directly involved in handling incoming packetspoll_socketPollProgressreceived_connection_packet/// Whether a datagram was routed to an existing connectionkeep_going/// Whether datagram handling was interrupted early by the work limiter for fairnessConnectionId/// An incoming connection for which the server has not yet begun its part of the handshake/// Attempt to accept this incoming connection (an error may still occur)accept_with/// Accept this incoming connection using a custom configuration/// See [`accept()`][Incoming::accept] for more details./// Reject this incoming connection attempt/// Respond with a retry packet, requiring the client to retry with address validation/// Errors if `may_retry()` is false./// Ignore this incoming connection attempt, not sending any packet in response/// The local IP address which was used when the peer established the connectionremote_address_validated/// Whether the socket address that is initiating this connection has been validated/// This means that the sender of the initial packet has proved that they can receive traffic/// sent to `self.remote_address()`./// If `self.remote_address_validated()` is false, `self.may_retry()` is guaranteed to be true./// The inverse is not guaranteed.may_retry/// Whether it is legal to respond with a retry packetorig_dst_cid/// The original destination CID when initiating the connection/// Error for attempting to retry an [`Incoming`] which already bears a token from a previous retryinto_incoming/// Get the [`Incoming`]IncomingFuture/// Basic adapter to let [`Incoming`] be `await`-ed like a [`Connecting`]AckFrequencyConfigApplicationCloseClosedStreamConfigErrorConnectionCloseConnectionIdGeneratorFrameStatsIdleTimeoutMtuDiscoveryConfigNoneTokenLogNoneTokenStorePathStatsStdSystemTimeTimeSourceTokenLogTokenMemoryCacheTokenReuseErrorTokenStoreTransportConfigTransportErrorCodeUdpStatsValidationTokenConfigVarIntBoundsExceededWrittenReadExactErrorReadToEndErrorResetErrorTokioRuntimeStoppedErrorRebindudp_ecn/// Maximum number of datagrams processed in send/recv calls to make before moving on to other processing/// This helps ensure we don't starve anything when the CPU is slower than the link./// Value is selected by picking a low number which didn't degrade throughput in benchmarks./// The maximum amount of time that should be spent in `recvmsg()` calls per endpoint iteration/// 50us are chosen so that an endpoint iteration with a 50us sendmsg limit blocks/// the runtime for a maximum of about 100us./// Going much lower does not yield any noticeable difference, since a single `recvmmsg`/// batch of size 32 was observed to take 30us on some systems.//! QUIC transport protocol implementation//! [QUIC](https://en.wikipedia.org/wiki/QUIC) is a modern transport protocol addressing//! shortcomings of TCP, such as head-of-line blocking, poor security, slow handshakes, and//! inefficient congestion control. This crate provides a portable userspace implementation. It//! builds on top of quinn-proto, which implements protocol logic independent of any particular//! runtime.//! The entry point of this crate is the [`Endpoint`].//! # About QUIC//! A QUIC connection is an association between two endpoints. The endpoint which initiates the//! connection is termed the client, and the endpoint which accepts it is termed the server. A//! single endpoint may function as both client and server for different connections, for example//! in a peer-to-peer application. To communicate application data, each endpoint may open streams//! up to a limit dictated by its peer. Typically, that limit is increased as old streams are//! finished.//! Streams may be unidirectional or bidirectional, and are cheap to create and disposable. For//! example, a traditionally datagram-oriented application could use a new stream for every//! message it wants to send, no longer needing to worry about MTUs. Bidirectional streams behave//! much like a traditional TCP connection, and are useful for sending messages that have an//! immediate response, such as an HTTP request. Stream data is delivered reliably, and there is no//! ordering enforced between data on different streams.//! By avoiding head-of-line blocking and providing unified congestion control across all streams//! of a connection, QUIC is able to provide higher throughput and lower latency than one or//! multiple TCP connections between the same two hosts, while providing more useful behavior than//! raw UDP sockets.//! Quinn also exposes unreliable datagrams, which are a low-level primitive preferred when//! automatic fragmentation and retransmission of certain data is not desired.//! QUIC uses encryption and identity verification built directly on TLS 1.3. Just as with a TLS//! server, it is useful for a QUIC server to be identified by a certificate signed by a trusted//! authority. If this is infeasible--for example, if servers are short-lived or not associated//! with a domain name--then as with TLS, self-signed certificates can be used to provide//! encryption alone./// A Mutex which optionally allows to track the time a lock was held and/// emit warnings in case of excessive lock times/// Acquires the lock for a certain purpose/// The purpose will be recorded in the list of last lock ownersnon_trackingReadableErroris_0rttall_data_read/// A stream that can only be used to receive data/// `stop(0)` is implicitly called on drop unless:/// - A variant of [`ReadError`] has been yielded by a read call/// - [`stop()`] was called explicitly/// # Cancellation/// A `read` method is said to be *cancel-safe* when dropping its future before the future becomes/// ready cannot lead to loss of stream data. This is true of methods which succeed immediately when/// any progress is made, and is not true of methods which might need to perform multiple reads/// internally before succeeding. Each `read` method documents whether it is cancel-safe./// # Common issues/// ## Data never received on a locally-opened stream/// Peers are not notified of streams until they or a later-numbered stream are used to send/// data. If a bidirectional stream is locally opened but never used to send, then the peer may/// never see it. Application protocols should always arrange for the endpoint which will first/// transmit on a stream to be the endpoint responsible for opening it./// ## Data never received on a remotely-opened stream/// Verify that the stream you are receiving is the same one that the server is sending on, e.g. by/// logging the [`id`] of each. Streams are always accepted in the same order as they are created,/// i.e. ascending order by [`StreamId`]. For example, even if a sender first transmits on/// bidirectional stream 1, the first stream yielded by [`Connection::accept_bi`] on the receiver/// will be bidirectional stream 0./// [`ReadError`]: crate::ReadError/// [`stop()`]: RecvStream::stop/// [`SendStream::finish`]: crate::SendStream::finish/// [`WriteError::Stopped`]: crate::WriteError::Stopped/// [`id`]: RecvStream::id/// [`Connection::accept_bi`]: crate::Connection::accept_bi/// Read data contiguously from the stream./// Yields the number of bytes read into `buf` on success, or `None` if the stream was finished./// This operation is cancel-safe./// Read an exact number of bytes contiguously from the stream./// See [`read()`] for details. This operation is *not* cancel-safe./// [`read()`]: RecvStream::read/// Attempts to read from the stream into the provided buffer/// On success, returns `Poll::Ready(Ok(num_bytes_read))` and places data into `buf`. If this/// returns zero bytes read (and `buf` has a non-zero length), that indicates that the remote/// side has [`finish`]ed the stream and the local side has already read all bytes./// If no data is available for reading, this returns `Poll::Pending` and arranges for the/// current task (via `cx.waker()`) to be notified when the stream becomes readable or is/// closed./// [`finish`]: crate::SendStream::finishpoll_read_buf/// Attempts to read from the stream into the provided buffer, which may be uninitialized/// On success, returns `Poll::Ready(Ok(()))` and places data into the unfilled portion of/// `buf`. If this does not write any bytes to `buf` (and `buf.remaining()` is non-zero), that/// indicates that the remote side has [`finish`]ed the stream and the local side has already/// read all bytes./// Read the next segment of data/// Yields `None` if the stream was finished. Otherwise, yields a segment of data and its/// offset in the stream. If `ordered` is `true`, the chunk's offset will be immediately after/// the last data yielded by `read()` or `read_chunk()`. If `ordered` is `false`, segments may/// be received in any order, and the `Chunk`'s `offset` field can be used to determine/// ordering in the caller. Unordered reads are less prone to head-of-line blocking within a/// stream, but require the application to manage reassembling the original data./// Slightly more efficient than `read` due to not copying. Chunk boundaries do not correspond/// to peer writes, and hence cannot be used as framing.poll_read_chunk/// Attempts to read a chunk from the stream./// On success, returns `Poll::Ready(Ok(Some(chunk)))`. If `Poll::Ready(Ok(None))`/// is returned, it implies that EOF has been reached./// and arranges for the current task (via cx.waker()) to receive a notification/// when the stream becomes readable or is closed.read_chunks/// Read the next segments of data/// Fills `bufs` with the segments of data beginning immediately after the/// last data yielded by `read` or `read_chunk`, or `None` if the stream was/// Slightly more efficient than `read` due to not copying. Chunk boundaries/// do not correspond to peer writes, and hence cannot be used as framing.poll_read_chunks/// Foundation of [`Self::read_chunks`]/// Convenience method to read all remaining data into a buffer/// Fails with [`ReadToEndError::TooLong`] on reading more than `size_limit` bytes, discarding/// all data read. Uses unordered reads to be more efficient than using `AsyncRead` would/// allow. `size_limit` should be set to limit worst-case memory use./// If unordered reads have already been made, the resulting buffer may have gaps containing/// arbitrary data./// This operation is *not* cancel-safe./// [`ReadToEndError::TooLong`]: crate::ReadToEndError::TooLong/// Stop accepting data/// Discards unread data and notifies the peer to stop transmitting. Once stopped, further/// attempts to operate on a stream will yield `ClosedStream` errors./// Check if this stream has been opened during 0-RTT./// In which case any non-idempotent request should be considered dangerous at the application/// level. Because read data is subject to replay attacks./// Get the identity of this streamreceived_reset/// Completes when the stream has been reset by the peer or otherwise closed/// Yields `Some` with the reset error code when the stream is reset by the peer. Yields `None`/// when the stream was previously [`stop()`](Self::stop)ed, or when the stream was/// [`finish()`](crate::SendStream::finish)ed by the peer and all data has been received, after/// which it is no longer meaningful for the stream to be reset.poll_read_genericReadStatus/// Handle common logic related to reading out of a receive stream/// This takes an `FnMut` closure that takes care of the actual reading process, matching/// the detailed read semantics for the calling function with a particular return type./// The closure can read from the passed `&mut Chunks` and has to return the status after/// reading: the amount of data read, and the status after the final read call./// Future produced by [`RecvStream::read_to_end()`]./// [`RecvStream::read_to_end()`]: crate::RecvStream::read_to_end/// An error occurred during reading/// The stream is larger than the user-supplied limit/// Errors from [`RecvStream::read_to_end`]/// The peer abandoned transmitting data on this stream/// Carries an application-defined error code./// The stream has already been stopped, finished, or resetIllegalOrderedRead/// Attempted an ordered read following an unordered read/// Performing an unordered read allows discontinuities to arise in the receive buffer of a/// stream which cannot be recovered, making further ordered reads impossible.ZeroRttRejected/// This was a 0-RTT stream and the server rejected it/// Can only occur on clients for 0-RTT streams, which can be opened using/// [`Connecting::into_0rtt()`]./// [`Connecting::into_0rtt()`]: crate::Connecting::into_0rtt()/// Errors that arise from reading from a stream./// Errors that arise while waiting for a stream to be reset/// Future produced by [`RecvStream::read()`]./// [`RecvStream::read()`]: crate::RecvStream::read/// Future produced by [`RecvStream::read_exact()`]./// [`RecvStream::read_exact()`]: crate::RecvStream::read_exactFinishedEarly/// The stream finished before all bytes were read/// A read error occurredReadChunk/// Future produced by [`RecvStream::read_chunk()`]./// [`RecvStream::read_chunk()`]: crate::RecvStream::read_chunkReadChunks/// Future produced by [`RecvStream::read_chunks()`]./// [`RecvStream::read_chunks()`]: crate::RecvStream::read_chunksUdpPollHelpersmolSmolRuntime// Due to MSRV, we must specify `self::` where there's crate/module ambiguity/// A Quinn runtime for smolnew_timerwrap_udp_socketAsyncStdRuntime/// A Quinn runtime for async-stdUdpSocketStatecreate_io_pollermay_fragmentmax_transmit_segmentsmax_receive_segments/// A Quinn runtime for Tokio/// Construct a timer that will expire at `i`/// Drive `future` to completion in the background/// Convert `t` into the socket type used by this runtime/// Look up the current time/// Allows simulating the flow of time for testing./// Abstracts I/O and timer operations for runtime independence/// Update the timer to expire at `i`/// Check whether the timer has expired, and register to be woken if not/// Abstract implementation of an async timer for runtime independence/// Create a [`UdpPoller`] that can register a single task for write-readiness notifications/// A `poll_send` method on a single object can usually store only one [`Waker`] at a time,/// i.e. allow at most one caller to wait for an event. This method allows any number of/// interested tasks to construct their own [`UdpPoller`] object. They can all then wait for the/// same event and be notified concurrently, because each [`UdpPoller`] can store a separate/// [`Waker`]./// Send UDP datagrams from `transmits`, or return `WouldBlock` and clear the underlying/// socket's readiness, or return an I/O error/// If this returns [`io::ErrorKind::WouldBlock`], [`UdpPoller::poll_writable`] must be called/// to register the calling task to be woken when a send should be attempted again./// Receive UDP datagrams, or register to be woken if receiving may succeed in the future/// Look up the local IP address and port used by this socket/// Maximum number of datagrams that a [`Transmit`] may encode/// Maximum number of datagrams that might be described by a single [`RecvMeta`]/// Whether datagrams might get fragmented into multiple parts/// Sockets should prevent this for best performance. See e.g. the `IPV6_DONTFRAG` socket/// Abstract implementation of a UDP socket for runtime independence/// Check whether the associated socket is likely to be writable/// Must be called after [`AsyncUdpSocket::try_send`] returns [`io::ErrorKind::WouldBlock`] to/// register the task associated with `cx` to be woken when a send should be attempted/// again. Unlike in [`Future::poll`], a [`UdpPoller`] may be reused indefinitely no matter how/// many times `poll_writable` returns [`Poll::Ready`]./// An object polled to detect when an associated [`AsyncUdpSocket`] is writable/// Any number of `UdpPoller`s may exist for a single [`AsyncUdpSocket`]. Each `UdpPoller` is/// responsible for notifying at most one task when that socket becomes writable.r" Helper adapting a function `MakeFut` that constructs a single-use future `Fut` into a"r" [`UdpPoller`] that may be reused indefinitely"make_futMakeFut/// Construct a [`UdpPoller`] that calls `make_fut` to get the future to poll, storing it until/// it yields [`Poll::Ready`], then creating a new one on the next/// [`poll_writable`](UdpPoller::poll_writable)/// Automatically select an appropriate runtime from those enabled at compile time/// If `runtime-tokio` is enabled and this function is called from within a Tokio runtime context,/// then `TokioRuntime` is returned. Otherwise, if `runtime-async-std` is enabled, `AsyncStdRuntime`/// is returned. Otherwise, if `runtime-smol` is enabled, `SmolRuntime` is returned./// Otherwise, `None` is returned.// Be sure we return the right thingFinishError/// A stream that can only be used to send data/// If dropped, streams that haven't been explicitly [`reset()`] will be implicitly [`finish()`]ed,/// continuing to (re)transmit previously written data until it has been fully acknowledged or the/// connection is closed./// A `write` method is said to be *cancel-safe* when dropping its future before the future becomes/// ready will always result in no data being written to the stream. This is true of methods which/// succeed immediately when any progress is made, and is not true of methods which might need to/// perform multiple writes internally before succeeding. Each `write` method documents whether it is/// cancel-safe./// [`reset()`]: SendStream::reset/// [`finish()`]: SendStream::finish/// Write a buffer into this stream, returning how many bytes were written/// Unless this method errors, it waits until some amount of `buf` can be written into this/// stream, and then writes as much as it can without waiting again. Due to congestion and flow/// control, this may be shorter than `buf.len()`. On success this yields the length of the/// prefix that was written./// # Cancel safety/// This method is cancellation safe. If this does not resolve, no bytes were written./// Write a buffer into this stream in its entirety/// This method repeatedly calls [`write`](Self::write) until all bytes are written, or an/// This method is *not* cancellation safe. Even if this does not resolve, some prefix of `buf`/// may have been written when previously polled.write_chunks/// Write a slice of [`Bytes`] into this stream, returning how much was written/// Bytes to try to write are provided to this method as an array of cheaply cloneable chunks./// Unless this method errors, it waits until some amount of those bytes can be written into/// this stream, and then writes as much as it can without waiting again. Due to congestion and/// flow control, this may be less than the total number of bytes./// On success, this method both mutates `bufs` and yields an informative [`Written`] struct/// indicating how much was written:/// - [`Bytes`] chunks that were fully written are mutated to be [empty](Bytes::is_empty)./// - If a [`Bytes`] chunk was partially written, it is [split to](Bytes::split_to) contain///   only the suffix of bytes that were not written./// - The yielded [`Written`] struct indicates how many chunks were fully written as well as///   how many bytes were written./// Write a single [`Bytes`] into this stream in its entirety/// Bytes to write are provided to this method as an single cheaply cloneable chunk. This/// method repeatedly calls [`write_chunks`](Self::write_chunks) until all bytes are written,/// or an error occurs./// This method is *not* cancellation safe. Even if this does not resolve, some bytes may have/// been written when previously polled.write_all_chunks/// Write a slice of [`Bytes`] into this stream in its entirety/// Bytes to write are provided to this method as an array of cheaply cloneable chunks. This/// or an error occurs. This method mutates `bufs` by mutating all chunks to be/// [empty](Bytes::is_empty).execute_poll/// Notify the peer that no more data will ever be written to this stream/// It is an error to write to a [`SendStream`] after `finish()`ing it. [`reset()`](Self::reset)/// may still be called after `finish` to abandon transmission of any stream data that might/// still be buffered./// To wait for the peer to receive all buffered stream data, see [`stopped()`](Self::stopped)./// May fail if [`finish()`](Self::finish) or [`reset()`](Self::reset) was previously/// called. This error is harmless and serves only to indicate that the caller may have/// incorrect assumptions about the stream's state./// Close the send stream immediately./// No new data can be written after calling this method. Locally buffered data is dropped, and/// previously transmitted data will no longer be retransmitted if lost. If an attempt has/// already been made to finish the stream, the peer may still receive all written data./// Set the priority of the send stream/// Every send stream has an initial priority of 0. Locally buffered data from streams with/// higher priority will be transmitted before data from streams with lower priority. Changing/// the priority of a stream with pending data may only take effect after that data has been/// transmitted. Using many different priority levels per connection may have a negative/// impact on performance./// Get the priority of the send stream/// Completes when the peer stops the stream or reads the stream to completion/// Yields `Some` with the stop error code if the peer stops the stream. Yields `None` if the/// local side [`finish()`](Self::finish)es the stream and then the peer acknowledges receipt/// of all stream data (although not necessarily the processing of it), after which the peer/// closing the stream is no longer meaningful./// For a variety of reasons, the peer may not send acknowledgements immediately upon receiving/// data. As such, relying on `stopped` to know when the peer has read a stream to completion/// may introduce more latency than using an application-level response of some sort./// Attempt to write bytes from buf into the stream./// On success, returns Poll::Ready(Ok(num_bytes_written))./// If the stream is not ready for writing, the method returns Poll::Pending and arranges/// for the current task (via cx.waker().wake_by_ref()) to receive a notification when the/// stream becomes writable or is closed.send_stream_stopped/// Check if a send stream is stopped./// Returns `Some` if the stream is stopped or the connection is closed./// Returns `None` if the stream is not stopped./// The peer is no longer accepting data on this stream/// The stream has already been finished or reset/// Errors that arise from writing to a stream/// Errors that arise while monitoring for a send stream stop from the peerdefault_providerRandomConnectionIdGeneratorQuicClientConfigStdRngPrivateKeyDerPrivatePkcs8KeyDertracing_futureshandshake_timeoutclose_endpointread_after_closeip_blocking/// Construct an endpoint suitable for connecting to itselfendpoint_with_configendpoint_configEndpointFactory/// Constructs endpoints suitable for connecting to themselves and each otherzero_rttecho_v6echo_v4echo_dualstackstress_receive_windowstress_stream_receive_windowstress_both_windowsrun_echoEchoArgsclient_addrserver_addrnr_streamsstream_sizereceive_windowstream_receive_windowechogen_datasubscriberDefaultGuardrt_basicrt_threadedrebind_recvstream_id_flow_controltwo_datagram_readersmultiple_conns_with_zero_length_cidsstream_stoppedstream_stopped_2/// Whether to measure the required work time, or to use the previous estimates/// The current cycle number/// The time the cycle started - only used in measurement mode/// How many work items have been completed in the cycle/// The amount of work items which are allowed for a cycledesired_cycle_time/// The desired cycle timesmoothed_time_per_work_item_nanos/// The estimated and smoothed time per work item in nanoseconds/// Limits the amount of time spent on a certain type of work in a cycle/// The limiter works dynamically: For a sampled subset of cycles it measures/// the time that is approximately required for fulfilling 1 work item, and/// calculates the amount of allowed work items per cycle./// The estimates are smoothed over all cycles where the exact duration is measured./// In cycles where no measurement is performed the previously determined work limit/// For the limiter the exact definition of a work item does not matter./// It could for example track the amount of transmitted bytes per cycle,/// or the amount of transmitted datagrams per cycle./// It will however work best if the required time to complete a work item is/// constant.start_cycle/// Starts one work cycleallow_work/// Returns whether more work can be performed inside the `desired_cycle_time`/// Requires that previous work was tracked using `record_work`.record_work/// Records that `work` additional work items have been completed inside the cycle/// Must be called between `start_cycle` and `finish_cycle`.finish_cycle/// Finishes one work cycle/// For cycles where the exact duration is measured this will update the estimates/// for the time per work item and the limit of allowed work items per cycle./// The estimate is updated using the same exponential averaging (smoothing)/// mechanism which is used for determining QUIC path rtts: The last value is/// weighted by 1/8, and the previous average by 7/8./// We take a measurement sample once every `SAMPLING_INTERVAL` cyclesHistoricDatalimit_workr" Mocked time"advance_timefastbloomBloomFilterFxBuildHasherBloomTokenLog/// Bloom filter-based [`TokenLog`]/// Parameterizable over an approximate maximum number of bytes to allocate. Starts out by storing/// used tokens in a hash set. Once the hash set becomes too large, converts it to a bloom filter./// This achieves a memory profile of linear growth with an upper bound./// Divides time into periods based on `lifetime` and stores two filters at any given moment, for/// each of the two periods currently non-expired tokens could expire in. As such, turns over/// filters as time goes on to avoid bloom filter false positive rate increasing infinitely overnew_expected_items/// Construct with an approximate maximum memory usage and expected number of validation token/// usages per expiration period/// Calculates the optimal bloom filter k number automatically./// Construct with an approximate maximum memory usage and a [bloom filter k number][bloom]/// [bloom]: https://en.wikipedia.org/wiki/Bloom_filter/// If choosing a custom k number, note that `BloomTokenLog` always maintains two filters/// between them and divides the allocation budget of `max_bytes` evenly between them. As such,/// each bloom filter will contain `max_bytes * 4` bits.check_and_insert/// Default to 20 MiB max memory consumption and expected one million hits/// With the default validation token lifetime of 2 weeks, this corresponds to one token usage per/// 1.21 seconds.FilterConfigperiod_1_start// filter_1 covers tokens that expire in the period starting at period_1_start and extending// lifetime after. filter_2 covers tokens for the next lifetime after that.filter_1filter_2/// Lockable state of [`BloomTokenLog`]filter_max_bytesk_num/// Unchanging parameters governing [`Filter`] behaviorIdentityBuildHasherBloom/// Period filter within [`State`]/// `BuildHasher` of `IdentityHasher`IdentityHasherwrote_8_byte_slice/// Hasher that is the identity operation--it assumes that exactly 8 bytes will be hashed, and the/// resultant hash is those bytes as a `u64`optimal_k_numDEFAULT_MAX_BYTES// remember to change the doc comment for `impl Default for BloomTokenLog` if these ever changeDEFAULT_EXPECTED_HITSPcg32new_rngidentity_hash_testoptimal_k_num_testbloom_token_log_conversionturn_overtest_doesnt_panicmax_bytes_zeroexpected_hits_zerok_num_zeroMAX_CID_SIZEgenerate_cid/// Generates a new CID/// Connection IDs MUST NOT contain any information that can be used by/// an external observer (that is, one that does not cooperate with the/// issuer) to correlate them with other connection IDs for the same/// connection. They MUST have high entropy, e.g. due to encrypted data/// or cryptographic-grade random data.InvalidCid/// Quickly determine whether `cid` could have been generated by this generator/// False positives are permitted, but increase the cost of handling invalid packets.cid_len/// Returns the length of a CID for connections created by this generatorcid_lifetime/// Returns the lifetime of generated Connection IDs/// Connection IDs will be retired after the returned `Duration`, if any. Assumed to be constant./// Generates connection IDs for incoming connections/// The connection ID was not recognized by the [`ConnectionIdGenerator`]/// Generates purely random connection IDs of a specified length/// Random CIDs can be smaller than those produced by [`HashedConnectionIdGenerator`], but cannot be/// usefully [`validate`](ConnectionIdGenerator::validate)d./// Initialize Random CID generator with a fixed CID length/// The given length must be less than or equal to MAX_CID_SIZE.set_lifetime/// Set the lifetime of CIDs created by this generator/// Provide the length of dst_cid in short header packetHashedConnectionIdGenerator/// Generates 8-byte connection IDs that can be efficiently/// [`validate`](ConnectionIdGenerator::validate)d/// This generator uses a non-cryptographic hash and can therefore still be spoofed, but nonetheless/// helps prevents Quinn from responding to non-QUIC packets at very low cost./// Create a generator with a random key/// Create a generator with a specific key/// Allows [`validate`](ConnectionIdGenerator::validate) to recognize a consistent set of/// connection IDs across restartsNONCE_LENSIGNATURE_LEN// Good for more than 16 million connectionsvalidate_keyed_cid// 8-byte total CID lengthResetTokenNewConnectionIdCidData/// DataType stored in CidQueue buffer/// Ring buffer indexed by `self.cursor`/// Index at which circular buffer addressing is based/// Sequence number of `self.buffer[cursor]`/// The sequence number of the active CID; must be the smallest among CIDs in `buffer`.CidQueue/// Sliding window of active Connection IDs/// May contain gaps due to packet loss or reordering/// Handle a `NEW_CONNECTION_ID` frame/// Returns a non-empty range of retired sequence numbers and the reset token of the new active/// CID iff any CIDs were retired./// Switch to next active CID if possible, return/// 1) the corresponding ResetToken and 2) a non-empty range preceding it to retire/// Iterate CIDs in CidQueue that are not `None`, including the active CIDupdate_initial_cid/// Replace the initial CID/// Return active remote CID itselfactive_seq/// Return the sequence number of active remote CIDRetired/// CID was already retiredExceedsLimit/// Sequence number violates the leading edge of the windowinitial_cidnext_densenext_sparseretire_denseretire_sparseretire_manyinsert_limitinsert_duplicateinsert_retiredretire_then_insert_nextalways_valid/// Error indicating that the provided buffer was too small/// Coding result type/// Decode a `Self` from the provided buffer, if the buffer is large enough/// Append the encoding of `self` to the provided buffer/// Infallible encoding and decoding of QUIC primitivesget_varBufExtwrite_varBufMutExt//! Coding related traits.WebPkiServerVerifierQuicServerConfigconfigured_providerDEFAULT_SUPPORTED_VERSIONScid_generatorHandshakeTokenKeyHmacKeyreset_keymax_udp_payload_sizeconnection_id_generator_factory/// CID generator factory/// Create a cid generator for local cid in Endpoint structsupported_versionsgrease_quic_bitmin_reset_interval/// Minimum interval between outgoing stateless reset packetsrng_seed/// Optional seed to be used internally for random number generation/// Global configuration for the endpoint, affecting all connections/// Default values should be suitable for most internet applications./// Create a default config with a particular `reset_key`/// Supply a custom connection ID generator factory/// Called once by each `Endpoint` constructed from this configuration to obtain the CID/// generator which will be used to generate the CIDs used for incoming packets on all/// connections involving that  `Endpoint`. A custom CID generator allows applications to embed/// information in local connection IDs, e.g. to support stateless packet-level load balancers./// Defaults to [`HashedConnectionIdGenerator`]./// Private key used to send authenticated connection resets to peers who were/// communicating with a previous instance of this endpoint./// Maximum UDP payload size accepted from peers (excluding UDP and IP overhead)./// Must be greater or equal than 1200./// Defaults to 1472, which is the largest UDP payload that can be transmitted in the typical/// 1500 byte Ethernet MTU. Deployments on links with larger MTUs (e.g. loopback or Ethernet/// with jumbo frames) can raise this to improve performance at the cost of a linear increase in/// datagram receive buffer size.get_max_udp_payload_size/// Get the current value of [`max_udp_payload_size`](Self::max_udp_payload_size)// While most parameters don't need to be readable, this must be exposed to allow higher-level// layers, e.g. the `quinn` crate, to determine how large a receive buffer to allocate to// support an externally-defined `EndpointConfig`.// While `get_` accessors are typically unidiomatic in Rust, we favor concision for setters,// which will be used far more heavily./// Override supported QUIC versions/// Whether to accept QUIC packets containing any value for the fixed bit/// Enabled by default. Helps protect against protocol ossification and makes traffic less/// identifiable to observers. Disable if helping observers identify this traffic as QUIC is/// Defaults to 20ms. Limits the impact of attacks which flood an endpoint with garbage packets,/// e.g. [ISAKMP/IKE amplification]. Larger values provide a stronger defense, but may delay/// detection of some error conditions by clients. Using a [`ConnectionIdGenerator`] with a low/// rate of false positives in [`validate`](ConnectionIdGenerator::validate) reduces the risk/// incurred by a small minimum reset interval./// [ISAKMP/IKE/// amplification]: https://bughunters.google.com/blog/5960150648750080/preventing-cross-service-udp-loops-in-quic#isakmp-ike-amplification-vs-quic/// By default, quinn will initialize an endpoint's rng using a platform entropy source./// However, you can seed the rng yourself through this method (e.g. if you need to run quinn/// deterministically or if you are using quinn in an environment that doesn't have a source of/// entropy available)./// Transport configuration to use for incoming connections/// TLS configuration used for incoming connections/// Must be set to use TLS 1.3 only.validation_token/// Configuration for sending and handling validation tokenstoken_key/// Used to generate one-time AEAD keys to protect handshake tokensretry_token_lifetime/// Duration after a retry token was issued for which it's considered validmigration/// Whether to allow clients to migrate to new addresses/// Improves behavior for clients that move between different internet connections or suffer NAT/// rebinding. Enabled by default.preferred_address_v4preferred_address_v6max_incomingincoming_buffer_sizeincoming_buffer_size_totaltime_source/// Parameters governing incoming connections/// Create a default config with a particular handshake token keytransport_config/// Set a custom [`TransportConfig`]validation_token_config/// Set a custom [`ValidationTokenConfig`]/// Private key used to authenticate data included in handshake tokens/// Defaults to 15 seconds./// The preferred IPv4 address that will be communicated to clients during handshaking/// If the client is able to reach this address, it will switch to it./// The preferred IPv6 address that will be communicated to clients during handshaking/// Maximum number of [`Incoming`][crate::Incoming] to allow to exist at a time/// An [`Incoming`][crate::Incoming] comes into existence when an incoming connection attempt/// is received and stops existing when the application either accepts it or otherwise disposes/// of it. While this limit is reached, new incoming connection attempts are immediately/// refused. Larger values have greater worst-case memory consumption, but accommodate greater/// application latency in handling incoming connection attempts./// The default value is set to 65536. With a typical Ethernet MTU of 1500 bytes, this limits/// memory consumption from this to under 100 MiB--a generous amount that still prevents memory/// exhaustion in most contexts./// Maximum number of received bytes to buffer for each [`Incoming`][crate::Incoming]/// of it. This limit governs only packets received within that period, and does not include/// the first packet. Packets received in excess of this limit are dropped, which may cause/// 0-RTT or handshake data to have to be retransmitted./// The default value is set to 10 MiB--an amount such that in most situations a client would/// not transmit that much 0-RTT data faster than the server handles the corresponding/// [`Incoming`][crate::Incoming]./// Maximum number of received bytes to buffer for all [`Incoming`][crate::Incoming]/// collectively/// The default value is set to 100 MiB--a generous amount that still prevents memory/// Object to get current [`SystemTime`]/// This exists to allow system time to be mocked in tests, or wherever else desired./// Defaults to [`StdSystemTime`], which simply calls [`SystemTime::now()`](SystemTime::now).has_preferred_addresswith_single_cert/// Create a server config with the given certificate chain to be presented to clients/// Uses a randomized handshake token key./// Create a server config with the given [`crypto::ServerConfig`]sent/// Configuration for sending and handling validation tokens in incoming connections/// ## QUIC Tokens/// The QUIC protocol defines a concept of "[address validation][1]". Essentially, one side of a/// QUIC connection may appear to be receiving QUIC packets from a particular remote UDP address,/// but it will only consider that remote address "validated" once it has convincing evidence that/// the address is not being [spoofed][2]./// Validation is important primarily because of QUIC's "anti-amplification limit." This limit/// prevents a QUIC server from sending a client more than three times the number of bytes it has/// received from the client on a given address until that address is validated. This is designed/// to mitigate the ability of attackers to use QUIC-based servers as reflectors in [amplification/// attacks][3]./// A path may become validated in several ways. The server is always considered validated by the/// client. The client usually begins in an unvalidated state upon first connecting or migrating,/// but then becomes validated through various mechanisms that usually take one network round trip./// However, in some cases, a client which has previously attempted to connect to a server may have/// been given a one-time use cryptographically secured "token" that it can send in a subsequent/// connection attempt to be validated immediately./// There are two ways these tokens can originate:/// - If the server responds to an incoming connection with `retry`, a "retry token" is minted and///   sent to the client, which the client immediately uses to attempt to connect again. Retry///   tokens operate on short timescales, such as 15 seconds./// - If a client's path within an active connection is validated, the server may send the client///   one or more "validation tokens," which the client may store for use in later connections to///   the same server. Validation tokens may be valid for much longer lifetimes than retry token./// The usage of validation tokens is most impactful in situations where 0-RTT data is also being/// used--in particular, in situations where the server sends the client more than three times more/// 0.5-RTT data than it has received 0-RTT data. Since the successful completion of a connection/// handshake implicitly causes the client's address to be validated, transmission of 0.5-RTT data/// is the main situation where a server might be sending application data to an address that could/// be validated by token usage earlier than it would become validated without token usage./// [1]: https://www.rfc-editor.org/rfc/rfc9000.html#section-8/// [2]: https://en.wikipedia.org/wiki/IP_address_spoofing/// [3]: https://en.wikipedia.org/wiki/Denial-of-service_attack#Amplification/// These tokens should not be confused with "stateless reset tokens," which are similarly named/// but entirely unrelated./// Duration after an address validation token was issued for which it's considered valid/// This refers only to tokens sent in NEW_TOKEN frames, in contrast to retry tokens./// Defaults to 2 weeks.// which links are redundant depends on features/// Set a custom [`TokenLog`]/// If the `bloom` feature is enabled (which it is by default), defaults to a default/// [`BloomTokenLog`][crate::BloomTokenLog], which is suitable for most internet applications./// If the `bloom` feature is disabled, defaults to [`NoneTokenLog`][crate::NoneTokenLog],/// which makes the server ignore all address validation tokens (that is, tokens originating/// from NEW_TOKEN frames--retry tokens are not affected)./// Number of address validation tokens sent to a client when its path is validated/// If the `bloom` feature is enabled (which it is by default), defaults to 2. Otherwise,/// defaults to 0./// Transport configuration to use/// Cryptographic configuration to usetoken_store/// Validation token store to useinitial_dst_cid_provider/// Provider that populates the destination connection ID of Initial Packets/// QUIC protocol version to use/// Configuration for outgoing connections/// Create a default config with a particular cryptographic config/// Configure how to populate the destination CID of the initial packet when attempting to/// establish a new connection/// By default, it's populated with random bytes with reasonable length, so unless you have/// a good reason, you do not need to change it./// When prefer to override the default, please note that the generated connection ID MUST be/// at least 8 bytes long and unpredictable, as per section 7.2 of RFC 9000./// Set a custom [`TokenStore`]/// Defaults to [`TokenMemoryCache`], which is suitable for most internet applications./// Set the QUIC version to usewith_root_certificatesVerifierBuilderError/// Create a client configuration that trusts specified trust anchors/// Value exceeds supported bounds/// Errors in the configuration of an endpoint/// Get [`SystemTime::now()`](SystemTime::now) or the mocked equivalent/// Default implementation of [`TimeSource`]/// Implements `now` by calling [`SystemTime::now()`](SystemTime::now).INITIAL_MTUMAX_UDP_PAYLOADqlogQlogSinkmax_concurrent_bidi_streamsmax_concurrent_uni_streamsmax_idle_timeoutsend_windowsend_fairnesspacket_thresholdtime_thresholdinitial_rttinitial_mtumin_mtumtu_discovery_configpad_to_mtuack_frequency_configpersistent_congestion_thresholdcrypto_buffer_sizeallow_spindatagram_receive_buffer_sizedatagram_send_buffer_sizedeterministic_packet_numberscongestion_controller_factoryControllerFactoryenable_segmentation_offloadqlog_sink/// Parameters governing the core QUIC state machine/// Default values should be suitable for most internet applications. Applications protocols which/// forbid remotely-initiated streams should set `max_concurrent_bidi_streams` and/// `max_concurrent_uni_streams` to zero./// In some cases, performance or resource requirements can be improved by tuning these values to/// suit a particular application and/or network connection. In particular, data window sizes can be/// tuned for a particular expected round trip time, link capacity, and memory availability. Tuning/// for higher bandwidths and latencies increases worst-case memory consumption, but does not impair/// performance at lower bandwidths and latencies. The default configuration is tuned for a 100Mbps/// link with a 100ms round trip time./// Maximum number of incoming bidirectional streams that may be open concurrently/// Must be nonzero for the peer to open any bidirectional streams./// Worst-case memory use is directly proportional to `max_concurrent_bidi_streams */// stream_receive_window`, with an upper bound proportional to `receive_window`./// Variant of `max_concurrent_bidi_streams` affecting unidirectional streams/// Maximum duration of inactivity to accept before timing out the connection./// The true idle timeout is the minimum of this and the peer's own max idle timeout. `None`/// represents an infinite timeout. Defaults to 30 seconds./// **WARNING**: If a peer or its network path malfunctions or acts maliciously, an infinite/// idle timeout can result in permanently hung futures!/// # use std::{convert::TryInto, time::Duration};/// # use quinn_proto::{TransportConfig, VarInt, VarIntBoundsExceeded};/// # fn main() -> Result<(), VarIntBoundsExceeded> {/// let mut config = TransportConfig::default();/// // Set the idle timeout as `VarInt`-encoded milliseconds/// config.max_idle_timeout(Some(VarInt::from_u32(10_000).into()));/// // Set the idle timeout as a `Duration`/// config.max_idle_timeout(Some(Duration::from_secs(10).try_into()?));/// Maximum number of bytes the peer may transmit without acknowledgement on any one stream/// before becoming blocked./// This should be set to at least the expected connection latency multiplied by the maximum/// desired throughput. Setting this smaller than `receive_window` helps ensure that a single/// stream doesn't monopolize receive buffers, which may otherwise occur if the application/// chooses not to read from a large stream for a time while still requiring data on other/// Maximum number of bytes the peer may transmit across all streams of a connection before/// becoming blocked./// desired throughput. Larger values can be useful to allow maximum throughput within a/// stream while another is blocked./// Maximum number of bytes to transmit to a peer without acknowledgment/// Provides an upper bound on memory when communicating with peers that issue large amounts of/// flow control credit. Endpoints that wish to handle large numbers of connections robustly/// should take care to set this low enough to guarantee memory exhaustion does not occur if/// every connection uses the entire window./// Whether to implement fair queuing for send streams having the same priority./// When enabled, connections schedule data from outgoing streams having the same priority in a/// round-robin fashion. When disabled, streams are scheduled in the order they are written to./// Note that this only affects streams with the same priority. Higher priority streams always/// take precedence over lower priority streams./// Disabling fairness can reduce fragmentation and protocol overhead for workloads that use/// many small streams./// Maximum reordering in packet number space before FACK style loss detection considers a/// packet lost. Should not be less than 3, per RFC5681./// Maximum reordering in time space before time based loss detection considers a packet lost,/// as a factor of RTT/// The RTT used before an RTT sample is taken/// The initial value to be used as the maximum UDP payload size before running MTU discovery/// (see [`TransportConfig::mtu_discovery_config`])./// Must be at least 1200, which is the default, and known to be safe for typical internet/// applications. Larger values are more efficient, but increase the risk of packet loss due to/// exceeding the network path's IP MTU. If the provided value is higher than what the network/// path actually supports, packet loss will eventually trigger black hole detection and bring/// it down to [`TransportConfig::min_mtu`].get_initial_mtu/// The maximum UDP payload size guaranteed to be supported by the network./// Must be at least 1200, which is the default, and lower than or equal to/// [`TransportConfig::initial_mtu`]./// Real-world MTUs can vary according to ISP, VPN, and properties of intermediate network links/// outside of either endpoint's control. Extreme care should be used when raising this value/// outside of private networks where these factors are fully controlled. If the provided value/// is higher than what the network path actually supports, the result will be unpredictable and/// catastrophic packet loss, without a possibility of repair. Prefer/// [`TransportConfig::initial_mtu`] together with/// [`TransportConfig::mtu_discovery_config`] to set a maximum UDP payload size that robustly/// adapts to the network./// Specifies the MTU discovery config (see [`MtuDiscoveryConfig`] for details)./// Pad UDP datagrams carrying application data to current maximum UDP payload size/// Disabled by default. UDP datagrams containing loss probes are exempt from padding./// Enabling this helps mitigate traffic analysis by network observers, but it increases/// bandwidth usage. Without this mitigation precise plain text size of application datagrams as/// well as the total size of stream write bursts can be inferred by observers under certain/// conditions. This analysis requires either an uncongested connection or application datagrams/// too large to be coalesced./// Specifies the ACK frequency config (see [`AckFrequencyConfig`] for details)/// The provided configuration will be ignored if the peer does not support the acknowledgement/// frequency QUIC extension./// Defaults to `None`, which disables controlling the peer's acknowledgement frequency. Even/// if set to `None`, the local side still supports the acknowledgement frequency QUIC/// extension and may use it in other ways./// Number of consecutive PTOs after which network is considered to be experiencing persistent congestion./// Period of inactivity before sending a keep-alive packet/// Keep-alive packets prevent an inactive but otherwise healthy connection from timing out./// `None` to disable, which is the default. Only one side of any given connection needs keep-alive/// enabled for the connection to be preserved. Must be set lower than the idle_timeout of both/// peers to be effective./// Maximum quantity of out-of-order crypto layer data to buffer/// Whether the implementation is permitted to set the spin bit on this connection/// This allows passive observers to easily judge the round trip time of a connection, which can/// be useful for network administration but sacrifices a small amount of privacy./// Maximum number of incoming application datagram bytes to buffer, or None to disable/// incoming datagrams/// The peer is forbidden to send single datagrams larger than this size. If the aggregate size/// of all datagrams that have been received from the peer but not consumed by the application/// exceeds this value, old datagrams are dropped until it is no longer exceeded./// Maximum number of outgoing application datagram bytes to buffer/// While datagrams are sent ASAP, it is possible for an application to generate data faster/// than the link, or even the underlying hardware, can transmit them. This limits the amount of/// memory that may be consumed in that case. When the send buffer is full and a new datagram is/// sent, older datagrams are dropped until sufficient space is available./// Whether to force every packet number to be used/// By default, packet numbers are occasionally skipped to ensure peers aren't ACKing packets/// before they see them./// How to construct new `congestion::Controller`s/// Typically the refcounted configuration of a `congestion::Controller`,/// e.g. a `congestion::NewRenoConfig`./// # use quinn_proto::*; use std::sync::Arc;/// config.congestion_controller_factory(Arc::new(congestion::NewRenoConfig::default()));/// Whether to use "Generic Segmentation Offload" to accelerate transmits, when supported by the/// environment/// GSO dramatically reduces CPU consumption when sending large numbers of packets with the same/// headers, such as when transmitting bulk data on a connection. However, it is not supported/// by all network interface drivers or packet inspection tools. `quinn-udp` will attempt to/// disable GSO automatically when unavailable, but this can lead to spurious packet loss at/// startup, temporarily degrading performance.ack_eliciting_thresholdmax_ack_delayreordering_threshold/// Parameters for controlling the peer's acknowledgement frequency/// The parameters provided in this config will be sent to the peer at the beginning of the/// connection, so it can take them into account when sending acknowledgements (see each parameter's/// description for details on how it influences acknowledgement frequency)./// Quinn's implementation follows the fourth draft of the/// [QUIC Acknowledgement Frequency extension](https://datatracker.ietf.org/doc/html/draft-ietf-quic-ack-frequency-04)./// The defaults produce behavior slightly different than the behavior without this extension,/// because they change the way reordered packets are handled (see/// [`AckFrequencyConfig::reordering_threshold`] for details)./// The ack-eliciting threshold we will request the peer to use/// This threshold represents the number of ack-eliciting packets an endpoint may receive/// without immediately sending an ACK./// The remote peer should send at least one ACK frame when more than this number of/// ack-eliciting packets have been received. A value of 0 results in a receiver immediately/// acknowledging every ack-eliciting packet./// Defaults to 1, which sends ACK frames for every other ack-eliciting packet./// The `max_ack_delay` we will request the peer to use/// This parameter represents the maximum amount of time that an endpoint waits before sending/// an ACK when the ack-eliciting threshold hasn't been reached./// The effective `max_ack_delay` will be clamped to be at least the peer's `min_ack_delay`/// transport parameter, and at most the greater of the current path RTT or 25ms./// Defaults to `None`, in which case the peer's original `max_ack_delay` will be used, as/// obtained from its transport parameters./// The reordering threshold we will request the peer to use/// This threshold represents the amount of out-of-order packets that will trigger an endpoint/// to send an ACK, without waiting for `ack_eliciting_threshold` to be exceeded or for/// `max_ack_delay` to be elapsed./// A value of 0 indicates out-of-order packets do not elicit an immediate ACK. A value of 1/// immediately acknowledges any packets that are received out of order (this is also the/// behavior when the extension is disabled)./// It is recommended to set this value to [`TransportConfig::packet_threshold`] minus one./// Since the default value for [`TransportConfig::packet_threshold`] is 3, this value defaults/// to 2.minimum_changeblack_hole_cooldown/// Parameters governing MTU discovery./// # The why of MTU discovery/// By design, QUIC ensures during the handshake that the network path between the client and the/// server is able to transmit unfragmented UDP packets with a body of 1200 bytes. In other words,/// once the connection is established, we know that the network path's maximum transmission unit/// (MTU) is of at least 1200 bytes (plus IP and UDP headers). Because of this, a QUIC endpoint can/// split outgoing data in packets of 1200 bytes, with confidence that the network will be able to/// deliver them (if the endpoint were to send bigger packets, they could prove too big and end up/// being dropped)./// There is, however, a significant overhead associated to sending a packet. If the same/// information can be sent in fewer packets, that results in higher throughput. The amount of/// packets that need to be sent is inversely proportional to the MTU: the higher the MTU, the/// bigger the packets that can be sent, and the fewer packets that are needed to transmit a given/// amount of bytes./// Most networks have an MTU higher than 1200. Through MTU discovery, endpoints can detect the/// path's MTU and, if it turns out to be higher, start sending bigger packets./// # MTU discovery internals/// Quinn implements MTU discovery through DPLPMTUD (Datagram Packetization Layer Path MTU/// Discovery), described in [section 14.3 of RFC/// 9000](https://www.rfc-editor.org/rfc/rfc9000.html#section-14.3). This method consists of sending/// QUIC packets padded to a particular size (called PMTU probes), and waiting to see if the remote/// peer responds with an ACK. If an ACK is received, that means the probe arrived at the remote/// peer, which in turn means that the network path's MTU is of at least the packet's size. If the/// probe is lost, it is sent another 2 times before concluding that the MTU is lower than the/// packet's size./// MTU discovery runs on a schedule (e.g. every 600 seconds) specified through/// [`MtuDiscoveryConfig::interval`]. The first run happens right after the handshake, and/// subsequent discoveries are scheduled to run when the interval has elapsed, starting from the/// last time when MTU discovery completed./// Since the search space for MTUs is quite big (the smallest possible MTU is 1200, and the highest/// is 65527), Quinn performs a binary search to keep the number of probes as low as possible. The/// lower bound of the search is equal to [`TransportConfig::initial_mtu`] in the/// initial MTU discovery run, and is equal to the currently discovered MTU in subsequent runs. The/// upper bound is determined by the minimum of [`MtuDiscoveryConfig::upper_bound`] and the/// `max_udp_payload_size` transport parameter received from the peer during the handshake./// # Black hole detection/// If, at some point, the network path no longer accepts packets of the detected size, packet loss/// will eventually trigger black hole detection and reset the detected MTU to 1200. In that case,/// MTU discovery will be triggered after [`MtuDiscoveryConfig::black_hole_cooldown`] (ignoring the/// timer that was set based on [`MtuDiscoveryConfig::interval`])./// # Interaction between peers/// There is no guarantee that the MTU on the path between A and B is the same as the MTU of the/// path between B and A. Therefore, each peer in the connection needs to run MTU discovery/// independently in order to discover the path's MTU./// Specifies the time to wait after completing MTU discovery before starting a new MTU/// discovery run./// Defaults to 600 seconds, as recommended by [RFC/// 8899](https://www.rfc-editor.org/rfc/rfc8899)./// Specifies the upper bound to the max UDP payload size that MTU discovery will search for./// Defaults to 1452, to stay within Ethernet's MTU when using IPv4 and IPv6. The highest/// allowed value is 65527, which corresponds to the maximum permitted UDP payload on IPv6./// It is safe to use an arbitrarily high upper bound, regardless of the network path's MTU. The/// only drawback is that MTU discovery might take more time to finish./// Specifies the amount of time that MTU discovery should wait after a black hole was detected/// before running again. Defaults to one minute./// Black hole detection can be spuriously triggered in case of congestion, so it makes sense to/// try MTU discovery again after a short period of time./// Specifies the minimum MTU change to stop the MTU discovery phase./// Defaults to 20./// Maximum duration of inactivity to accept before timing out the connection/// This wraps an underlying [`VarInt`], representing the duration in milliseconds. Values can be/// constructed by converting directly from `VarInt`, or using `TryFrom<Duration>`./// # use std::{convert::TryFrom, time::Duration};/// # use quinn_proto::{IdleTimeout, VarIntBoundsExceeded, VarInt};/// // A `VarInt`-encoded value in milliseconds/// let timeout = IdleTimeout::from(VarInt::from_u32(10_000));/// // Try to convert a `Duration` into a `VarInt`-encoded timeout/// let timeout = IdleTimeout::try_from(Duration::from_secs(10))?;min_maxtotal_ackedprev_total_ackedacked_timeprev_acked_timetotal_sentprev_total_sentsent_timeprev_sent_timemax_filteracked_at_last_windowBandwidthEstimationon_senton_ackbytes_acked_this_windowend_acksget_estimatebw_from_delta/// round count, not a timestampMinMaxSampleupdate_max/// update_min is also defined in the original source, but removed here since it is not used.subwin_update/* As time advances, update the 1st, 2nd, and 3rd choices. *//// round number, not a timestamp/*
 * Based on Google code released under BSD license here:
 * https://groups.google.com/forum/#!topic/bbr-dev/3RTgkzi5ZD8
 *//*
 * Kathleen Nichols' algorithm for tracking the minimum (or maximum)
 * value of a data stream over some fixed time interval.  (E.g.,
 * the minimum RTT over the past five minutes.) It uses constant
 * space and constant time per update yet almost always delivers
 * the same minimum as an implementation that has to keep all the
 * data in the window.
 *
 * The algorithm keeps track of the best, 2nd best & 3rd best min
 * values, maintaining an invariant that the measurement time of
 * the n'th best >= n-1'th best. It also makes sure that the three
 * values are widely separated in the time window since that bounds
 * the worse case error when that data is monotonically increasing
 * over the window.
 *
 * Upon getting a new min, we can forget everything earlier because
 * it has no value - the new min is <= everything else in the window
 * by definition and it samples the most recent. So we restart fresh on
 * every new min and overwrites 2nd & 3rd choices. The same property
 * holds for 2nd & 3rd best.
 */ControllerMetricsbbrbw_estimationRttEstimatorBASE_DATAGRAM_SIZEBbrConfigcurrent_mtuacked_bytesloss_stateLossStaterecovery_stateRecoveryStaterecovery_windowis_at_full_bandwidthpacing_gainhigh_gaindrain_gaincwnd_gainhigh_cwnd_gainlast_cycle_startcurrent_cycle_offsetinit_cwndmin_cwndprev_in_flight_countexit_probe_rtt_atprobe_rtt_last_started_atmin_rttexiting_quiescencepacing_ratemax_acked_packet_numbermax_sent_packet_numberend_recovery_at_packet_numbercurrent_round_trip_end_packet_numberround_countbw_at_last_roundround_wo_bw_gainack_aggregationAckAggregationStaterandom_number_generatorBbr/// Experimental! Use at your own risk./// Aims for reduced buffer bloat and improved performance over high bandwidth-delay product networks./// Based on google's quiche implementation <https://source.chromium.org/chromium/chromium/src/+/master:net/third_party/quiche/src/quic/core/congestion_control/bbr_sender.cc>/// of BBR <https://datatracker.ietf.org/doc/html/draft-cardwell-iccrg-bbr-congestion-control>./// More discussion and links at <https://groups.google.com/g/bbr-dev>./// Construct a state using the given `config` and current time `now`enter_startup_modeenter_probe_bandwidth_modeupdate_recovery_stateupdate_gain_cycle_phasemaybe_exit_startup_or_drainis_min_rtt_expiredmaybe_enter_or_exit_probe_rttget_target_cwndget_probe_rtt_cwndcalculate_pacing_ratecalculate_cwndcalculate_recovery_windowcheck_if_full_bw_reached/// <https://datatracker.ietf.org/doc/html/draft-cardwell-iccrg-bbr-congestion-control#section-4.3.2.2>on_end_ackson_congestion_eventon_mtu_updateinitial_window/// Configuration for the [`Bbr`] congestion controller/// Default limit on the amount of outstanding data in bytes./// Recommended value: `min(10 * max_datagram_size, max(2 * max_datagram_size, 14720))`max_ack_heightaggregation_epoch_start_timeaggregation_epoch_bytesupdate_ack_aggregation_bytesStartup// Startup phase of the connection.// After achieving the highest possible bandwidth during the startup, lower// the pacing rate in order to drain the queue.ProbeBw// Cruising mode.ProbeRtt// Temporarily slow down sending in order to empty the buffer and measure// the real minimum RTT.NotInRecovery// Do not limit.Conservation// Allow an extra outstanding byte for each byte acknowledged.Growth// Allow two extra outstanding bytes for each byte acknowledged (slow// start).// Indicates how the congestion control limits the amount of bytes in flight.in_recoverylost_byteshas_lossescalculate_min_windowK_DEFAULT_HIGH_GAIN// The gain used for the STARTUP, equal to 2/ln(2).K_DERIVED_HIGH_CWNDGAIN// The newly derived CWND gain for STARTUP, 2.K_PACING_GAIN// The cycle of gains used during the ProbeBw stage.K_STARTUP_GROWTH_TARGETK_ROUND_TRIPS_WITHOUT_GROWTH_BEFORE_EXITING_STARTUPK_MAX_INITIAL_CONGESTION_WINDOW// Do not allow initial congestion window to be greater than 200 packets.PROBE_RTT_BASED_ON_BDPDRAIN_TO_TARGETBETA_CUBIC/// CUBIC Constants./// These are recommended value in RFC8312.w_maxcwnd_inc// Store cwnd increment during congestion avoidance./// CUBIC State Variables./// We need to keep those variables across the connection./// k, w_max are described in the RFC.cubic_k// K = cbrt(w_max * (1 - beta_cubic) / C) (Eq. 2)w_cubic// W_cubic(t) = C * (t - K)^3 - w_max (Eq. 1)w_est// W_est(t) = w_max * beta_cubic + 3 * (1 - beta_cubic) / (1 + beta_cubic) *// (t / RTT) (Eq. 4)/// CUBIC Functions./// Note that these calculations are based on a count of cwnd as bytes,/// not packets./// Unit of t (duration) and RTT are based on seconds (f64).CubicConfig/// Maximum number of bytes in flight that may be sent./// Slow start threshold in bytes. When the congestion window is below ssthresh, the mode is/// slow start and the window grows by the number of bytes acknowledged.recovery_start_time/// The time when QUIC first detects a loss, causing it to enter recovery. When a packet sent/// after this time is acknowledged, QUIC exits recovery.cubic_state/// The RFC8312 congestion controller, as widely used for TCPminimum_window/// Configuration for the `Cubic` congestion controllerNewRenoConfigbytes_acked/// Bytes which had been acked by the peer since leaving slow startNewReno/// A simple, standard congestion controllerloss_reduction_factor/// Configuration for the `NewReno` congestion controller/// Reduction in congestion window when a new loss event is detected.cubicnew_reno/// One or more packets were just sent/// Packet deliveries were confirmed/// `app_limited` indicates whether the connection was blocked on outgoing/// application data prior to receiving these acknowledgements./// Packets are acked in batches, all with the same `now` argument. This indicates one of those batches has completed./// Packets were deemed lost or marked congested/// `in_persistent_congestion` indicates whether all packets sent within the persistent/// congestion threshold period ending when the most recent packet in this batch was sent were/// lost./// `lost_bytes` indicates how many bytes were lost. This value will be 0 for ECN triggers./// The known MTU for the current network path has been updated/// Number of ack-eliciting bytes that may be in flight/// Retrieve implementation-specific metrics used to populate `qlog` traces when they are enabled/// Duplicate the controller's state/// Initial congestion window/// Returns Self for use in down-casting to extract implementation details/// Common interface for different congestion controllerscongestion_window/// Congestion window (bytes)/// Slow start threshold (bytes)/// Pacing rate (bits/s)/// Common congestion controller metrics/// Construct a fresh `Controller`/// Constructs controllers on demand//! Logic for controlling the rate at which data is sentPendingAcksAckFrequencytransport_parametersTransportParametersTIMER_GRANULARITYTransportErrorin_flight_ack_frequency_frame// Sending ACK_FREQUENCY framesnext_outgoing_sequence_numberpeer_max_ack_delaylast_ack_frequency_frame// Receiving ACK_FREQUENCY framesAckFrequencyState/// State associated to ACK frequencycandidate_max_ack_delay/// Returns the `max_ack_delay` that should be requested of the peer when sending an/// ACK_FREQUENCY framemax_ack_delay_for_pto/// Returns the `max_ack_delay` for the purposes of calculating the PTO/// This `max_ack_delay` is defined as the maximum of the peer's current `max_ack_delay` and all/// in-flight `max_ack_delay`s (i.e. proposed values that haven't been acknowledged yet, but/// might be already in use by the peer)./// Returns the next sequence number for an ACK_FREQUENCY frameshould_send_ack_frequency/// Returns true if we should send an ACK_FREQUENCY frameack_frequency_sent/// Notifies the [`AckFrequencyState`] that a packet containing an ACK_FREQUENCY frame was senton_acked/// Notifies the [`AckFrequencyState`] that a packet has been ACKedack_frequency_received/// Notifies the [`AckFrequencyState`] that an ACK_FREQUENCY frame was received/// Updates the endpoint's params according to the payload of the ACK_FREQUENCY frame, or/// returns an error in case the requested `max_ack_delay` is invalid./// Returns `true` if the frame was processed and `false` if it was ignored because of being/// stale.MAX_RTT_ERROR/// Maximum proportion difference between the most recently requested max ACK delay and the/// currently desired one before a new request is sent, when the peer supports the ACK frequency/// extension and an explicit max ACK delay is not configured.MIN_AUTOMATIC_ACK_DELAY/// Minimum value to request the peer set max ACK delay to when the peer supports the ACK frequency// Keep in sync with `AckFrequencyConfig::max_ack_delay` documentationrange_setRangeSet/// Total number of buffered bytes, including duplicates in ordered mode./// Estimated number of allocated bytes, will never be less than `buffered`.bytes_read/// Number of bytes read by the application. When only ordered reads have been used, this is the/// length of the contiguous prefix of the stream which has been consumed by the application,/// aka the stream offset.Assembler/// Helper to assemble unordered stream frames into an ordered stream/// Reset to the initial stateensure_ordering/// Get the the next chunkdefragment/// Copy fragmented chunk data to new chunks backed by a single buffer/// This makes sure we're not unnecessarily holding on to many larger allocations./// We merge contiguous chunks in the process of doing so.// Note: If a packet contains many frames from the same stream, the estimated over-allocation// will be much higher because we are counting the same allocation multiple times./// Number of bytes consumed by the application/// Discard all buffered data/// The offset in the stream/// The contents of the chunk/// A chunk of data from the receive stream/// Size of the allocation behind `bytes`, if `defragmented == false`./// Otherwise this will be set to `bytes.len()` by `try_mark_defragment`./// Will never be less than `bytes.len()`.defragmented/// Constructs a new fragmented Buffernew_defragmented/// Constructs a new defragmented Buffertry_mark_defragment/// Discards data before `offset` and flags `self` as defragmented if it has good utilization// Invert ordering based on offset (max-heap, min offset first),// prioritize longer chunks at the same offset.Orderedrecvd/// The set of offsets that have been received from the peer, including portions not yet/// read by the application.Unorderedis_ordered/// Error indicating that an ordered read was performed on a stream after an unordered readassemble_orderedassemble_unorderedassemble_duplicateassemble_duplicate_compactassemble_containedassemble_contained_compactassemble_containsassemble_contains_compactassemble_overlappingassemble_overlapping_compactassemble_complexassemble_complex_compactassemble_oldcompactdefrag_with_missing_prefixdefrag_read_chunkunordered_happy_pathunordered_dedupchunks_dedupordered_eager_discardordered_insert_unordered_readnext_unorderedIssuedCidretire_timestampCidTimestamp/// Timestamp when issued cids should be retired/// Number of local connection IDs that have been issued in NEW_CONNECTION_ID frames./// Sequence numbers of local connection IDs not yet retired by the peerprev_retire_seq/// Sequence number the peer has already retired all CIDs below at our request via `retire_prior_to`retire_seq/// Sequence number to set in retire_prior_to field in NEW_CONNECTION_ID frame/// cid length used to decode short packet//// cid lifetimeCidState/// Local connection ID managementnext_timeout/// Find the next timestamp when previously issued CID should be retiredtrack_lifetime/// Track the lifetime of issued cids in `retire_timestamp`on_cid_timeout/// Update local CID state when previously issued CID is retired/// Return whether a new CID needs to be pushed that notifies remote peer to respond `RETIRE_CONNECTION_ID`new_cids/// Update cid state when `NewIdentifiers` event is receivedon_cid_retirement/// Update CidState for receipt of a `RETIRE_CONNECTION_ID` frame/// Returns whether a new CID can be issued, or an error if the frame was illegal./// Length of local Connection IDsretire_prior_to/// The value for `retire_prior_to` field in `NEW_CONNECTION_ID` frameassign_retire_seq/// Highest cid sequence number created in a batch/// Timestamp when cid needs to be retired/// Data structure that records when issued cids should be retired//! Maintain the state of local connection IDsFrameStructDatagrams/// API to control datagram traffic/// Queue an unreliable, unordered datagram for immediate transmission/// If `drop` is true, previously queued datagrams which are still unsent may be discarded to/// make space for this datagram, in order of oldest to newest. If `drop` is false, and there/// isn't enough space due to previously queued datagrams, this function will return/// `SendDatagramError::Blocked`. `Event::DatagramsUnblocked` will be emitted once datagrams/// have been sent./// Returns `Err` iff a `len`-byte datagram cannot currently be sent./// Compute the maximum size of datagrams that may passed to `send_datagram`/// Receive an unreliable, unordered datagramsend_buffer_space/// When greater than zero, [`send`](Self::send)ing a datagram of at most this size is/// guaranteed not to cause older datagrams to be dropped.recv_buffered/// Number of bytes of datagrams that have been received by the local transport but not/// delivered to the applicationoutgoingoutgoing_totalsend_blockedDatagramStatedrop_oversized/// Discard outgoing datagrams with a payload larger than `max_payload` bytes/// Used to ensure that reductions in MTU don't get us stuck in a state where we have a datagram/// queued but can't send it./// Attempt to write a datagram frame into `buf`, consuming it from `self.outgoing`/// Returns whether a frame was written. At most `max_size` bytes will be written, including/// framing.Blocked/// Send would blockStreamMetaVecMAX_STREAM_COUNTMIN_INITIAL_SIZEcid_queuecodingPacketKeyNewTokenFixedLengthConnectionIdParserInitialHeaderInitialPacketLongTypePacketNumberPartialDecodeSpaceIdArrayRangeSetConnectionEventInnerDatagramConnectionEventEndpointEventInnerTokenPayloadack_frequencyassemblercid_statedatagramsmtudpacingpacket_builderPacketBuilderpacket_cryptoPrevCryptoZeroRttCryptoPathResponsesRetransmitsPacketNumberFilterPacketSpaceSendableFramesSentPacketThinRetransmitsStreamsStateShouldTransmitStreamsTimerTablehandshake_cid/// The CID we initially chose, for use during the handshakerem_handshake_cid/// The CID the peer initially chose, for use during the handshake/// The "real" local IP address which was was used to receive the initial packet./// This is only populated for the server case, and if knownpath_counter/// Incremented every time we see a new path/// Stored separately from `path.generation` to account for aborted migrationsallow_mtud/// Whether MTU detection is supported in this environmentprev_pathConnectionSidezero_rtt_enabled/// Whether or not 0-RTT was enabled during the handshake. Does not imply acceptance.zero_rtt_crypto/// Set if 0-RTT is supported, then cleared when no longer needed.key_phasekey_phase_size/// How many packets are in the current key phase. Used only for `Data` space.peer_params/// Transport parameters set by the peerorig_rem_cid/// Source ConnectionId of the first packet received from the peerinitial_dst_cid/// Destination ConnectionId sent by the client on the first Initialretry_src_cid/// The value that the server included in the Source Connection ID field of a Retry packet, if/// one was receivedspin_enabled/// Whether the spin bit is in use for this connection/// Outgoing spin bit state/// Packet number spaces: initial, handshake, 1-RTThighest_space/// Highest usable packet number spaceprev_crypto/// 1-RTT keys used prior to a key updatenext_crypto/// 1-RTT keys to be used for the next key update/// These are generated in advance to prevent timing attacks and/or DoS by third-party attackers/// spoofing key updates.accepted_0rttpermit_idle_reset/// Whether the idle timer should be reset the next time an ack-eliciting packet is transmitted./// Negotiated idle timeoutauthentication_failures/// Number of packets received which could not be authenticated/// Why the connection was lost, if it has beenpacket_number_filter/// Identifies Data-space packet numbers to skip. Not used in earlier spaces.path_responses// Queued non-retransmittable 1-RTT data/// Responses to PATH_CHALLENGE frames// ACK frequencypto_count// Loss Detection/// The number of times a PTO has been sent without receiving an ack.receiving_ecn// Congestion Control/// Whether the most recently received packet had an ECN codepoint settotal_authed_packets/// Number of packets authenticatedapp_limited/// Whether the last `poll_transmit` call yielded no data because there was/// no outgoing application data.rem_cids/// Surplus remote CIDs for future use on new pathslocal_cid_state// Attributes of CIDs generated by local peer/// State of the unreliable datagram extension/// Connection level statistics/// QUIC version used for the connection./// Protocol state and logic for a single QUIC connection/// Objects of this type receive [`ConnectionEvent`]s and emit [`EndpointEvent`]s and application/// [`Event`]s to make progress. To handle timeouts, a `Connection` returns timer updates and/// expects timeouts through various methods. A number of simple getter methods are exposed/// to allow callers to inspect some of the connection state./// `Connection` has roughly 4 types of methods:/// - A. Simple getters, taking `&self`/// - B. Handlers for incoming events from the network or system, named `handle_*`./// - C. State machine mutators, for incoming commands from the application. For convenience we///   refer to this as "performing I/O" below, however as per the design of this library none of the///   functions actually perform system-level I/O. For example, [`read`](RecvStream::read) and///   [`write`](SendStream::write), but also things like [`reset`](SendStream::reset)./// - D. Polling functions for outgoing events or actions for the caller to///   take, named `poll_*`./// The simplest way to use this API correctly is to call (B) and (C) whenever/// appropriate, then after each of those calls, as soon as feasible call all/// polling methods (D) and deal with their outputs appropriately, e.g. by/// passing it to the application or by making a system-level I/O call. You/// should call the polling functions in this order:/// 1. [`poll_transmit`](Self::poll_transmit)/// 2. [`poll_timeout`](Self::poll_timeout)/// 3. [`poll_endpoint_events`](Self::poll_endpoint_events)/// 4. [`poll`](Self::poll)/// Currently the only actual dependency is from (2) to (1), however additional/// dependencies may be added in future, so the above order is recommended./// (A) may be called whenever desired./// Care should be made to ensure that the input events represent monotonically/// increasing time. Specifically, calling [`handle_timeout`](Self::handle_timeout)/// with events of the same [`Instant`] may be interleaved in any order with a/// call to [`handle_event`](Self::handle_event) at that same instant; however/// events or timeouts with different instants must not be interleaved.SideArgs/// Returns the next time at which `handle_timeout` should be called/// The value returned may change after:/// - the application performed some I/O on the connection/// - a call was made to `handle_event`/// - a call to `poll_transmit` returned `Some`/// - a call was made to `handle_timeout`/// Returns application-facing events/// Connections should be polled for events after:poll_endpoint_events/// Return endpoint-facing events/// Provide control over streamspoll_transmit/// Returns packets to transmit/// Connections should be polled for transmit after:/// `max_datagrams` specifies how many datagrams can be returned inside a/// single Transmit using GSO. This must be at least 1.send_path_challenge/// Send PATH_CHALLENGE for a previous path if necessaryspace_can_send/// Indicate what types of frames are ready to send for the given space/// Process `ConnectionEvent`s generated by the associated `Endpoint`/// Will execute protocol logic upon receipt of a connection event, in turn preparing signals/// (including application `Event`s, `EndpointEvent`s and outgoing datagrams) that should be/// extracted through the relevant methods.handle_timeout/// Process timer expirations/// Executes protocol logic, potentially preparing signals (including application `Event`s,/// `EndpointEvent`s and outgoing datagrams) that should be extracted through the relevant/// It is most efficient to call this immediately after the system clock reaches the latest/// `Instant` that was output by `poll_timeout`; however spurious extra calls will simply/// no-op and therefore are safe./// Close a connection immediately/// This does not ensure delivery of outstanding data. It is the application's responsibility to/// call this only when all important communications have been completed, e.g. by calling/// [`SendStream::finish`] on outstanding streams and waiting for the corresponding/// [`StreamEvent::Finished`] event./// If [`Streams::send_streams`] returns 0, all outstanding stream data has been/// delivered. There may still be data from the peer that has not been received./// [`StreamEvent::Finished`]: crate::StreamEvent::Finishedclose_inner/// Control datagrams/// Ping the remote endpoint/// Causes an ACK-eliciting packet to be transmitted./// This can be useful for testing key updates, as they otherwise only happen infrequently.initiate_key_update// Compatibility wrapper for quinn < 0.11.7. Remove for 0.12.crypto_session/// Get a session referenceis_handshaking/// Whether the connection is in the process of being established/// If this returns `false`, the connection may be either established or closed, signaled by the/// emission of a `Connected` or `ConnectionLost` message respectively./// Whether the connection is closed/// Closed connections cannot transport any further data. A connection becomes closed when/// either peer application intentionally closes it, or when either transport layer detects an/// error such as a time-out or certificate validation failure./// A `ConnectionLost` event is emitted with details when the connection becomes closed.is_drained/// Whether there is no longer any need to keep the connection around/// Closed connections become drained after a brief timeout to absorb any remaining in-flight/// packets from the peer. All drained connections have been closed./// For clients, if the peer accepted the 0-RTT data packets/// The value is meaningless until after the handshake completes.has_0rtt/// Whether 0-RTT is/was possible during the handshakehas_pending_retransmits/// Whether there are any pending retransmits/// Look up whether we're the client or server of this Connection/// The latest socket address for this connection's peer/// This will return `None` for clients, or when no `local_ip` was passed to/// [`Endpoint::handle()`](crate::Endpoint::handle) for the datagrams establishing this/// Current state of this connection's congestion controller, for debugging purposespath_changed/// Resets path-specific settings./// This will force-reset several subsystems related to a specific network path./// Currently this is the congestion controller, round-trip estimator, and the MTU/// discovery./// This is useful when it is known the underlying network path has changed and the old/// state of these subsystems is no longer valid or optimal. In this case it might be/// faster or reduce loss to settle on optimal values by restarting from the initial/// configuration in the [`TransportConfig`].set_max_concurrent_streams/// Modify the number of remotely initiated streams that may be concurrently open/// Current number of remotely initiated streams that may be concurrently open/// If the target for this limit is reduced using [`set_max_concurrent_streams`](Self::set_max_concurrent_streams),/// it will not change immediately, even if fewer streams are open. Instead, it will/// decrement by one for each time a remotely initiated stream of matching directionality is closed./// See [`TransportConfig::send_window()`]/// See [`TransportConfig::receive_window()`]on_ack_receivedAckprocess_ecnEcnCounts/// Process a new ECN block from an in-order ACKon_packet_acked// Not timing-aware, so it's safe to call this for inferred acks, such as arise from// high-latency handshakesset_key_discard_timeron_loss_detection_timeoutdetect_lost_packetsloss_time_and_spacepto_time_and_spacepeer_completed_address_validationset_loss_detection_timerpto/// Probe Timeouton_packet_authenticatedreset_idle_timeoutreset_keep_alivereset_cid_retirementhandle_first_packet/// Handle the already-decrypted first packet from the client/// Decrypting the first packet in the `Endpoint` allows stateless packet handling to be more/// efficient.init_0rttread_cryptowrite_cryptoupgrade_crypto/// Switch to stronger cryptography during handshakediscard_spacehandle_coalescedhandle_decodeprocess_decrypted_packetprocess_early_payload/// Process an Initial or Handshake packet payloadprocess_payloadmigratelocal_address_changed/// Handle a change in the local address, i.e. an active migrationupdate_rem_cid/// Switch to a previously unused remote connection ID, if possibleset_reset_tokenissue_first_cids/// Issue an initial set of connection IDs to the peer upon connectionpopulate_packetSentFramespopulate_acks/// Write pending ACKs into a buffer/// This method assumes ACKs are pending, and should only be called if/// `!PendingAcks::ranges().is_empty()` returns `true`.close_commonset_close_timerhandle_peer_params/// Handle transport parameters received from the peerset_peer_paramsdecrypt_packetupdate_keyspeer_supports_ack_frequencyimmediate_ack/// Send an IMMEDIATE_ACK frame to the remote endpoint/// According to the spec, this will result in an error if the remote endpoint does not support/// the Acknowledgement Frequency extensiondecode_packet/// Decodes a packet, returning its decrypted payload, so it can be inspected in testsbytes_in_flight/// The number of bytes of packets containing retransmittable frames that have not been/// acknowledged or declared lost./// Number of bytes worth of non-ack-only packets that may be sent/// Whether no timers but keepalive, idle, rtt, pushnewcid, and key discard are runningusing_ecn/// Whether explicit congestion notification is in use on outgoing packets.total_recvd/// The number of received bytes in the current pathactive_local_cid_seqrotate_local_cid/// Instruct the peer to replace previously issued CIDs by sending a NEW_CONNECTION_ID frame/// with updated `retire_prior_to` field set to `v`active_rem_cid_seq/// Check the current active remote CID sequencepath_mtu/// Returns the detected maximum udp payload size for the current pathcan_send_1rtt/// Whether we have 1-RTT data to send/// See also `self.space(SpaceId::Data).can_send()`remove_in_flight/// Update counters to account for a packet becoming acknowledged, lost, or abandoned/// Terminate the connection instantly, without sending a close packet/// Storage size required for the largest packet known to be supported by the current path/// Buffers passed to [`Connection::poll_transmit`] should be at least this large.predict_1rtt_overhead/// Size of non-frame data for a 1-RTT packet/// Quantifies space consumed by the QUIC header and AEAD tag. All other bytes in a packet are/// frames. Changes if the length of the remote connection ID changes, which is expected to be/// rare. If `pn` is specified, may additionally change unpredictably due to variations in/// latency and packet loss.tag_len_1rtton_path_validated/// Mark the path as validated, and enqueue NEW_TOKEN frames to be sent as appropriate/// Sent in every outgoing Initial packet. Always empty after Initial keys are discardedserver_config/// Fields of `Connection` specific to it being client-side or server-sideremote_may_migratepref_addr_cidpath_validated/// Parameters to `Connection::new` specific to it being client-side or server-side/// The peer doesn't implement any supported version/// The peer violated the QUIC specification as understood by this implementationConnectionClosed/// The peer's QUIC stack aborted the connection automaticallyApplicationClosed/// The peer closed the connection/// The peer is unable to continue processing this connection, usually due to having restarted/// Communication with the peer has lapsed for longer than the negotiated idle timeout/// If neither side is sending keep-alives, a connection will time out after a long enough idle/// period even if the peer is still reachable. See also [`TransportConfig::max_idle_timeout()`]/// and [`TransportConfig::keep_alive_interval()`].LocallyClosed/// The local application closed the connectionCidsExhausted/// The connection could not be created because not enough of the CID space is available/// Try using longer connection IDs./// Reasons why a connection might be lost// For compatibility with API consumersDrainingDrained/// Waiting for application to call close so we can dispose of the resources// fuzzing onlyis_handshakerem_cid_set/// Whether the remote CID has been set by the peer yet/// Always set for serversexpected_token/// Stateless retry token received in the first Initial by a server./// Must be present in every Initial. Always empty for clients./// First cryptographic message/// Only set for clientsHandshakeDataReady/// The connection's handshake data is ready/// The connection was successfully established/// Reason that the connection was closed/// Emitted if the peer closes the connection or an error is encountered./// Stream eventsDatagramReceived/// One or more application datagrams have been receivedDatagramsUnblocked/// One or more application datagrams have been sent after blocking/// Events of interest to the applicationinstant_saturating_subget_max_ack_delayMAX_BACKOFF_EXPONENT// Prevents overflow and improves behavior in extreme circumstancesMIN_PACKET_SPACE/// Minimal remaining size to allow packet coalescing, excluding cryptographic tag/// This must be at least as large as the header for a well-formed empty packet to be coalesced,/// plus some space for frames. We only care about handshake headers because short header packets/// necessarily have smaller headers, and initial packets are only ever the first packet in a/// datagram (because we coalesce in ascending packet space order and the only reason to split a/// packet is when packet space changes).MAX_HANDSHAKE_OR_0RTT_HEADER_SIZE/// Largest amount of space that could be occupied by a Handshake or 0-RTT packet's header/// Excludes packet-type-specific fields such as packet number or Initial token// https://www.rfc-editor.org/rfc/rfc9000.html#name-0-rtt: flags + version + dcid len + dcid +// scid len + scid + length + pnKEY_UPDATE_MARGIN/// Perform key updates this many packets before the AEAD confidentiality limit./// Chosen arbitrarily, intended to be large enough to prevent spurious connection loss.retransmitslargest_ackedstream_framesnon_retransmits/// Whether the packet contains non-retransmittable frames (like datagrams)requires_paddingis_ack_only/// Returns whether the packet contains only ACKsnegotiate_max_idle_timeout/// Compute the negotiated idle timeout based on local and remote max_idle_timeout transport parameters./// According to the definition of max_idle_timeout, a value of `0` means the timeout is disabled; see <https://www.rfc-editor.org/rfc/rfc9000#section-18.2-4.4.1.>/// According to the negotiation procedure, either the minimum of the timeouts or one specified is used as the negotiated value; see <https://www.rfc-editor.org/rfc/rfc9000#section-10.1-2.>/// Returns the negotiated idle timeout as a `Duration`, or `None` when both endpoints have opted out of idle timeout.negotiate_max_idle_timeout_commutative/// Detected MTU for the pathEnabledMtuDiscovery/// The state of the MTU discovery, if enabledblack_hole_detectorBlackHoleDetector/// The state of the black hole detectorMtuDiscovery/// Implements Datagram Packetization Layer Path Maximum Transmission Unit Discovery/// See [`MtuDiscoveryConfig`] for details/// MTU discovery will be disabled and the current MTU will be fixed to the provided value/// Returns the current MTU/// Returns the amount of bytes that should be sent as an MTU probe, if anyon_peer_max_udp_payload_size_received/// Notifies the [`MtuDiscovery`] that the peer's `max_udp_payload_size` transport parameter has/// been received/// Notifies the [`MtuDiscovery`] that a packet has been ACKed/// Returns true if the packet was an MTU probein_flight_mtu_probe/// Returns the packet number of the in-flight MTU probe, if anyon_probe_lost/// Notifies the [`MtuDiscovery`] that the in-flight MTU probe was loston_non_probe_lost/// Notifies the [`MtuDiscovery`] that a non-probe packet was lost/// When done notifying of lost packets, [`MtuDiscovery::black_hole_detected`] must be called, to/// ensure the last loss burst is properly processed and to trigger black hole recovery logic ifblack_hole_detected/// Returns true if a black hole was detected/// Calling this function will close the previous loss burst. If a black hole is detected, the/// current MTU will be reset to `min_mtu`.peer_max_udp_payload_size/// Additional state for enabled MTU discoveryon_probe_acked/// Called when a packet is acknowledged in [`SpaceId::Data`]/// Returns the new `current_mtu` if the packet number corresponds to the in-flight MTU probe/// Called when the in-flight MTU probe was loston_black_hole_detected/// Called when a black hole is detected/// We haven't started polling yetSearchStateSearching/// We are currently searching for a higher PMTU/// Searching has completed and will be triggered again at the provided instantlower_bound/// The lower bound for the current binary search/// The upper bound for the current binary search/// The minimum change to stop the current binary searchlast_probed_mtu/// The UDP payload size we last sent a probe forin_flight_probe/// Packet number of an in-flight probe (if any)lost_probe_count/// Lost probes at the current probe size/// Creates a new search state, with the specified lower bound (the upper bound is derived from/// the config and the peer's `max_udp_payload_size` transport parameter)next_mtu_to_probe/// Determines the next MTU to probe using binary searchsuspicious_loss_burstsLossBurst/// Packet loss bursts currently considered suspiciouscurrent_loss_burstCurrentLossBurst/// Loss burst currently being aggregated, if anylargest_post_loss_packet/// Packet number of the biggest packet larger than `min_mtu` which we've received/// acknowledgment of more recently than any suspicious loss burst, if anyacked_mtu/// The maximum of `min_mtu` and the size of `largest_post_loss_packet`, or exactly `min_mtu` if/// no larger packets have been received since the most recent loss burst./// The UDP payload size guaranteed to be supported by the network/// Judges whether packet loss might indicate a drop in MTU/// Our MTU black hole detection scheme is a heuristic based on the order in which packets were sent/// (the packet number order), their sizes, and which are deemed lost./// First, contiguous groups of lost packets ("loss bursts") are aggregated, because a group of/// packets all lost together were probably lost for the same reason./// A loss burst is deemed "suspicious" if it contains no packets that are (a) smaller than the/// minimum MTU or (b) smaller than a more recent acknowledged packet, because such a burst could be/// fully explained by a reduction in MTU./// When the number of suspicious loss bursts exceeds [`BLACK_HOLE_THRESHOLD`], we judge the/// evidence for an MTU black hole to be sufficient.on_non_probe_ackedfinish_loss_burst/// Marks the end of the current loss burst, checking whether it was suspicioussuspicious_loss_burst_countlargest_non_probe_lostsmallest_packet_sizelatest_non_probeMAX_PROBE_RETRANSMITS// Corresponds to the RFC's `MAX_PROBES` constant (see// https://www.rfc-editor.org/rfc/rfc8899#section-5.1.2)BLACK_HOLE_THRESHOLD/// Maximum number of suspicious loss bursts that will not trigger black hole detectiondefault_mtuddrive_to_completion/// Drives mtud until it reaches `Phase::Completed`black_hole_detector_ignores_burst_containing_non_suspicious_packetblack_hole_detector_counts_burst_containing_only_suspicious_packetsblack_hole_detector_ignores_empty_burstmtu_discovery_disabled_does_nothingmtu_discovery_disabled_lost_four_packet_bursts_triggers_black_hole_detectionmtu_discovery_lost_two_packet_bursts_does_not_trigger_black_hole_detectionmtu_discovery_lost_four_packet_bursts_triggers_black_hole_detection_and_resets_timermtu_discovery_after_complete_reactivates_when_interval_elapsedmtu_discovery_lost_three_probes_lowers_probe_sizemtu_discovery_with_peer_max_udp_payload_size_clamps_upper_boundmtu_discovery_with_previous_peer_max_udp_payload_size_clamps_upper_boundmtu_discovery_with_1500_limitmtu_discovery_with_1500_limit_and_10000_upper_boundmtu_discovery_no_lost_probes_finds_maximum_udp_payloadmtu_discovery_lost_half_of_probes_finds_maximum_udp_payloadsearch_state_lower_bound_higher_than_upper_bound_clamps_upper_boundsearch_state_lower_bound_higher_than_peer_max_udp_payload_size_clamps_lower_boundsearch_state_upper_bound_higher_than_peer_max_udp_payload_size_clamps_upper_boundsimple_black_hole_detection// Loss of packets larger than have been acknowledged should indicate a black holenon_suspicious_bursts// Loss of packets followed in transmission order by confirmation of a larger packet should not// indicate a black holedynamic_mtu_reduction// Loss of packets smaller than have been acknowledged previously should still indicate a black// holemixed_non_suspicious_bursts// Bursts containing heterogeneous packets are judged based on the smallestbursts_count_once// Multi-packet bursts are only counted onceinterleaved_bursts// Non-suspicious bursts don't interfere with detection of suspicious burstssuspicious_after_acked// Bursts that are non-suspicious before a delivered packet become suspicious past itretroactively_non_suspicious// Acknowledgment of a packet marks prior loss bursts with the same packet size as// non-suspiciouslast_windowlast_mtuPacer/// A simple token-bucket pacer/// The pacer's capacity is derived on a fraction of the congestion window/// which can be sent in regular intervals/// Once the bucket is empty, further transmission is blocked./// The bucket refills at a rate slightly faster/// than one congestion window per RTT, as recommended in/// <https://tools.ietf.org/html/draft-ietf-quic-recovery-34#section-7.7>/// Obtains a new [`Pacer`].on_transmit/// Record that a packet has been transmitted./// Return how long we need to wait before sending `bytes_to_send`/// If we can send a packet right away, this returns `None`. Otherwise, returns `Some(d)`,/// where `d` is the time before this function should be called again./// The 5/4 ratio used here comes from the suggestion that N = 1.25 in the draft IETF RFC for/// QUIC.optimal_capacity/// Calculates a pacer capacity for a certain window and RTT/// The goal is to emit a burst (of size `capacity`) in timer intervals/// which compromise between/// - ideally distributing datagrams over time/// - constantly waking up the connection to produce additional datagrams/// Too short burst intervals means we will never meet them since the timer/// accuracy in user-space is not high enough. If we miss the interval by more/// than 25%, we will lose that part of the congestion window since no additional/// tokens for the extra-elapsed time can be stored./// Too long burst intervals make pacing less effective.BURST_INTERVAL_NANOS/// The burst interval/// The capacity will we refilled in 4/5 of that time./// 2ms is chosen here since framework timers might have 1ms precision./// If kernel-level pacing is supported later a higher time here might be/// more applicable.MIN_BURST_SIZE/// Allows some usage of GSO, and doesn't slow down the handshake.MAX_BURST_SIZE/// Creating 256 packets took 1ms in a benchmark, so larger bursts don't make sense.does_not_panic_on_bad_instantderives_initial_capacityadjusts_capacitycomputes_pause_correctly//! Pacing of packet transmissions.// 2msFIXED_BITPartialEncodedatagram_startpartial_encodeack_elicitingexact_numbershort_headermin_size/// Smallest absolute position in the associated buffer that must be occupied by this packet's/// frames/// Largest absolute position in the associated buffer that may be occupied by this packet'stag_len_spanEnteredSpan/// Write a new packet header to `buffer` and determine the packet's properties/// Marks the connection drained and returns `None` if the confidentiality limit would be/// violated.pad_to/// Append the minimum amount of padding to the packet such that, after encryption, the/// enclosing datagram will occupy at least `min_size` bytesfinish_and_track/// Encrypt packet, returning the length of the packet and whether padding was addedHeaderKeyRESET_TOKEN_SIZEunprotect_headerUnprotectHeaderResult/// Removes header protection of a packet, or returns `None` if the packet was dropped/// The packet with the now unprotected header (`None` in the case of stateless reset packets/// that fail to be decoded)stateless_reset/// Whether the packet was a stateless reset packetdecrypt_packet_bodyDecryptPacketResult/// Decrypts a packet's body in-place/// The packet numberoutgoing_key_update_acked/// Whether a locally initiated key update has been acknowledged by the peerincoming_key_update/// Whether the peer has initiated a key update/// The keys used for the previous key phase, temporarily retained to decrypt packets sent by/// the peer prior to its own key update.end_packet/// The incoming packet that ends the interval for which these keys are applicable, and the time/// of its receipt./// Incoming packets should be decrypted using these keys iff this is `None` or their packet/// number is lower. `None` indicates that we have not yet received a packet using newer keys,/// which implies that the update was locally initiated.update_unacked/// Whether the following key phase is from a remotely initiated update that we haven't ackedsending_ecn/// Whether we're enabling ECN on outgoing packets/// Congestion controller state/// Pacing statechallengechallenge_pendingvalidated/// Whether we're certain the peer can both send and receive on this address/// Initially equal to `use_stateless_retry` for servers, and becomes false again on every/// migration. Always true for clients./// Total size of all UDP datagrams sent on this path/// Total size of all UDP datagrams received on this path/// The state of the MTU discovery processfirst_packet_after_rtt_sample/// Packet number of the first packet sent after an RTT sample was collected on this path/// Used in persistent congestion determination.in_flightInFlightfirst_packet/// Number of the first packet sent on this path/// Used to determine whether a packet was sent on an earlier path. Insufficient to determine if/// a packet was sent on a later path./// Tag uniquely identifying a path in a connection/// Description of a particular network pathfrom_previous/// Resets RTT, congestion control and MTU states./// This is useful when it is known the underlying path has changed.anti_amplification_blocked/// Indicates whether we're a server that hasn't validated the peer's address and hasn't/// received enough data from the peer to permit sending `bytes_to_send` additional bytes/// Returns the path's current MTU/// Account for transmission of `packet` with number `pn` in `space`/// Remove `packet` with number `pn` from this path's congestion control counters, or return/// `false` if `pn` was sent before this path was established./// The most recent RTT measurement made when receiving an ack for a previously unacked packetsmoothed/// The smoothed RTT of the connection, computed as described in RFC6298/// The RTT variance, computed as described in RFC6298/// The minimum RTT seen in the connection, ignoring ack delay./// RTT estimation for a particular network path/// The current best RTT estimation.conservative/// Conservative estimate of RTT/// Takes the maximum of smoothed and latest RTT, as recommended/// in 6.1.2 of the recovery spec (draft 29)./// Minimum RTT registered so far for this estimator.pto_base// PTO computed as described in RFC9002#6.2.1PathResponsepop_off_pathpop_on_path/// The packet number the corresponding PATH_CHALLENGE was received in/// The address the corresponding PATH_CHALLENGE was received from/// Sum of the sizes of all sent packets considered "in flight" by congestion control/// The size does not include IP or UDP overhead. Packets only containing ACK frames do not/// count towards this to ensure congestion control does not impede congestion feedback./// Number of packets in flight containing frames other than ACK and PADDING/// This can be 0 even when bytes is not 0 because PADDING frames cause a packet to be/// considered "in flight" by congestion control. However, if this is nonzero, bytes will always/// also be nonzero./// Summary statistics of packets that have been sent on a particular path, but which have not yet/// been acked or deemed lost/// A [`QlogStream`] that may be either dynamically disabled or compiled out entirelyemit_recovery_metricsemit_packet_lostemit_packet_sentemit_packet_received// Function bodies in this module are regularly cfg'd outunacked_segments/// Data queued by the application but not yet acknowledged. May or may not have been sent.unacked_len/// Total size of `unacked_segments`/// The first offset that hasn't been written by the application, i.e. the offset past the end of `unacked`unsent/// The first offset that hasn't been sent/// Always lies in (offset - unacked.len())..offsetacks/// Acknowledged ranges which couldn't be discarded yet as they don't include the earliest/// offset in `unacked`// TODO: Recover storage from these by compacting (#700)/// Previously transmitted ranges deemed lostSendBuffer/// Buffer of outgoing retransmittable stream data/// Construct an empty buffer at the initial offset/// Append application data to the end of the stream/// Discard a range of acknowledged stream data/// Compute the next range to transmit on this stream and update state to account for that/// transmission./// `max_len` here includes the space which is available to transmit the/// offset and length of the data to send. The caller has to guarantee that/// there is at least enough space available to write maximum-sized metadata/// (8 byte offset + 8 byte length)./// The method returns a tuple:/// - The first return value indicates the range of data to send/// - The second return value indicates whether the length needs to be encoded///   in the STREAM frames metadata (`true`), or whether it can be omitted///   since the selected range will fill the whole packet./// Returns data which is associated with a range/// This function can return a subset of the range, if the data is stored/// in noncontiguous fashion in the send buffer. In this case callers/// should call the function again with an incremented start offset to/// retrieve more data./// Queue a range of sent but unacknowledged data to be retransmittedretransmit_all_for_0rtt/// First stream offset unwritten by the application, i.e. the offset that the next write will/// begin atis_fully_acked/// Whether all sent data has been acknowledgedhas_unsent_data/// Whether there's data to send/// There may be sent unacknowledged data even when this is false.unacked/// Compute the amount of data that hasn't been acknowledgedfragment_with_lengthfragment_without_lengthreserves_encoded_offsetmultiple_segmentsreordered_ackaggregate_unackedrx_packet/// Highest received packet number/// Data to sendpending_acks/// Packet numbers to acknowledgenext_packet_number/// The packet number of the next packet that will be sent, if any. In the Data space, the/// packet number stored here is sometimes skipped by [`PacketNumberFilter`] logic.largest_acked_packet/// The largest packet number the remote peer acknowledged in an ACK frame.largest_acked_packet_sentlargest_ack_eliciting_sent/// The highest-numbered ACK-eliciting packet we've sentunacked_non_ack_eliciting_tail/// Number of packets in `sent_packets` with numbers above `largest_ack_eliciting_sent`sent_packets/// Transmitted but not acked// We use a BTreeMap here so we can efficiently query by range on ACK and for loss detectionecn_counters/// Number of explicit congestion notification codepoints seen on incoming packetsecn_feedback/// Recent ECN counters sent by the peer in ACK frames/// Updated (and inspected) whenever we receive an ACK with a new highest acked packet/// number. Stored per-space to simplify verification, which would otherwise have difficulty/// distinguishing between ECN bleaching and counts having been updated by a near-simultaneous/// ACK already processed in another space./// Incoming cryptographic handshake streamcrypto_offset/// Current offset of outgoing cryptographic handshake streamtime_of_last_ack_eliciting_packet/// The time the most recently sent retransmittable packet was sent.loss_time/// The time at which the earliest sent packet in this space will be considered lost based on/// exceeding the reordering window in time. Only set for packets numbered prior to a packet/// that has been acknowledged.loss_probes/// Number of tail loss probes to sendping_pendingimmediate_ack_pendingsent_with_keys/// Number of packets sent in the current key phasemaybe_queue_probe/// Queue data for a tail loss probe (or anti-amplification deadlock prevention) packet/// Probes are sent similarly to normal packets when an expected ACK has not arrived. We never/// deem a packet lost until we receive an ACK that should have included it, but if a trailing/// run of packets (or their ACKs) are lost, this might not happen in a timely fashion. We send/// probe packets to force an ACK, and exempt them from congestion control to prevent a deadlock/// when the congestion window is filled with lost tail packets./// We prefer to send new data, to make the most efficient use of bandwidth. If there's no data/// waiting to be sent, then we retransmit in-flight data to reduce odds of loss. If there's no/// in-flight data either, we're probably a client guarding against a handshake/// anti-amplification deadlock and we just make something up.get_tx_number/// Get the next outgoing packet number in this space/// In the Data space, the connection's [`PacketNumberFilter`] must be used rather than calling/// this directly.detect_ecn/// Verifies sanity of an ECN block and returns whether congestion was encountered./// Stop tracking sent packet `number`, and return what we knew about it/// May return a packet that should be forgottenhas_in_flight/// Whether any congestion-controlled packets in this space are not yet acknowledged or lostpath_generation/// [`PathData::generation`](super::PathData::generation) of the path on which this packet was senttime_sent/// The time the packet was sent./// The number of bytes sent in the packet, not including UDP or IP overhead, but including QUIC/// framing overhead. Zero if this packet is not counted towards congestion control, i.e. not an/// "in flight" packet./// Whether an acknowledgement is expected directly in response to this packet./// The largest packet number acknowledged by this packet/// Data which needs to be retransmitted in case the packet is lost./// The data is boxed to minimize `SentPacket` size for the typical case of/// packets only containing ACKs and STREAM frames./// Metadata for stream frames in a packet/// The actual application data is stored with the stream state./// Represents one or more packets subject to retransmissionmax_datamax_stream_idreset_streamstop_sendingStopSendingmax_stream_dataretire_cidshandshake_donenew_tokens/// For each enqueued NEW_TOKEN frame, a copy of the path's remote address/// There are 2 reasons this is unusual:/// - If the path changes, NEW_TOKEN frames bound for the old path are not retransmitted on the///   new path. That is why this field stores the remote address: so that ones for old paths///   can be filtered out./// - If a token is lost, a new randomly generated token is re-transmitted, rather than the///   original. This is so that if both transmissions are received, the client won't risk///   sending the same token twice. That is why this field does _not_ store any actual token./// It is true that a QUIC endpoint will only want to effectively have NEW_TOKEN frames/// enqueued for its current path at a given point in time. Based on that, we could conceivably/// change this from a vector to an `Option<(SocketAddr, usize)>` or just a `usize` or/// something. However, due to the architecture of Quinn, it is considerably simpler to not do/// that; consider what such a change would mean for implementing `BitOrAssign` on Self./// Retransmittable data queue/// A variant of `Retransmits` which only allocates storage when required/// Returns `true` if no retransmits are necessary/// Returns a reference to the retransmits stored in this boxget_or_create/// Returns a mutable reference to the stored retransmits/// This function will allocate a backing storage if required./// Lowest packet number higher than all yet authenticated./// RFC4303-style sliding window packet number deduplicator./// A contiguous bitfield, where each bit corresponds to a packet number and the rightmost bit is/// always set. A set bit represents a packet that has been successfully authenticated. Bits left of/// the window are assumed to be set./// ...xxxxxxxxx 1 0///     ^        ^ ^/// window highest next/// Inner bitfield type./// Because QUIC never reuses packet numbers, this only needs to be large enough to deal with/// packets that are reordered but still delivered in a timely manner./// Number of packets tracked by `Dedup`./// Construct an empty window positioned at the start./// Highest packet number authenticated./// Record a newly authenticated packet number./// Returns whether the packet might be a duplicate.smallest_missing_in_interval/// Returns the packet number of the smallest packet missing between the provided interval/// If there are no missing packets, returns `None`missing_in_interval/// Returns true if there are any missing packets between the provided interval/// The provided packet numbers must have been received before calling this function/// Indicates which data is available for sending/// Returns that no data is available for sending/// Whether no data is sendableimmediate_ack_required/// Whether we should send an ACK immediately, even if that means sending an ACK-only packet/// When `immediate_ack_required` is false, the normal behavior is to send ACK frames only when/// there is other data to send, or when the `MaxAckDelay` timer expires.ack_eliciting_since_last_ack_sent/// The number of ack-eliciting packets received since the last ACK frame was sent/// Once the count _exceeds_ `ack_eliciting_threshold`, an immediate ACK is requirednon_ack_eliciting_since_last_ack_sent/// The reordering threshold, controlling how we respond to out-of-order ack-eliciting packets/// Different values enable different behavior:/// * `0`: no special action is taken/// * `1`: an ACK is immediately sent if it is out-of-order according to RFC 9000/// * `>1`: an ACK is immediately sent if it is out-of-order according to the ACK frequency draftearliest_ack_eliciting_since_last_ack_sent/// The earliest ack-eliciting packet since the last ACK was sent, used to calculate the moment/// upon which `max_ack_delay` elapses/// The packet number ranges of ack-eliciting packets the peer hasn't confirmed receipt of ACKs/// forlargest_packet/// The packet with the largest packet number, and the time upon which it was received (used to/// calculate ACK delay in [`PendingAcks::ack_delay`])largest_ack_eliciting_packet/// The ack-eliciting packet we have received with the largest packet number/// The largest acknowledged packet number sent in an ACK frameset_ack_frequency_paramsset_immediate_ack_requiredon_max_ack_delay_timeoutmax_ack_delay_timeout/// Whether any ACK frames can be sentack_delay/// Returns the delay since the packet with the largest packet number was receivedpacket_received/// Handle receipt of a new packet/// Returns true if the max ack delay timer should be armedis_out_of_orderacks_sent/// Should be called whenever ACKs have been sent/// This will suppress sending further ACKs until additional ACK eliciting frames arriveinsert_one/// Insert one packet that needs to be acknowledgedsubtract_below/// Remove ACKs of packets numbered at or below `max` from the set of pending ACKs/// Returns the set of currently pending ACK rangesmaybe_ack_non_eliciting/// Queue an ACK if a significant number of non-ACK-eliciting packets have not yet been/// acknowledged/// Should be called immediately before a non-probing packet is composed, when we've already/// committed to sending a packet regardless.next_skipped_packet_number/// Next outgoing packet number to skipprev_skipped_packet_number/// Most recently skipped packet number/// Next packet number to skip is randomly selected from 2^n..2^n+1/// Helper for mitigating [optimistic ACK attacks]/// A malicious peer could prompt the local application to begin a large data transfer, and then/// send ACKs without first waiting for data to be received. This could defeat congestion control,/// allowing the connection to consume disproportionate resources. We therefore occasionally skip/// packet numbers, and classify any ACK referencing a skipped packet number as a transport error./// Skipped packet numbers occur only in the application data space (where costly transfers might/// take place) and are distributed exponentially to reflect the reduced likelihood and impact of/// bad behavior from a peer that has been well-behaved for an extended period./// ACKs for packet numbers that have not yet been allocated are also a transport error, but an/// attacker with knowledge of the congestion control algorithm in use could time falsified ACKs to/// arrive after the packets they reference are sent./// [optimistic ACK attacks]: https://www.rfc-editor.org/rfc/rfc9000.html#name-optimistic-ack-attackcheck_ackMAX_ACK_BLOCKS/// Ensures we can always fit all our ACKs in a single minimum-MTU packet with room to sparesanityhappypathdedup_has_missingdedup_outside_of_window_has_missingdedup_smallest_missingpending_acks_first_packet_is_not_considered_reorderedpending_acks_after_immediate_ack_setpending_acks_ack_delaysent_packet_size/// The amount of UDP datagrams observed/// The total amount of bytes which have been transferred inside UDP datagrams/// The amount of I/O operations executed/// Can be less than `datagrams` when GSO, GRO, and/or batched system calls are in use./// Statistics about UDP datagrams transmitted or received on a connection/// All QUIC packets are carried by UDP datagrams. Hence, these statistics cover all traffic on a connection.data_blockedmax_streams_bidimax_streams_uninew_connection_idnew_tokenpath_challengepath_responseretire_connection_idstream_data_blockedstreams_blocked_bidistreams_blocked_uni/// Number of frames transmitted or received of each frame type/// Current congestion window of the connectioncongestion_events/// Congestion events on the connectionlost_packets/// The amount of packets lost on this path/// The amount of bytes lost on this path/// The amount of packets sent on this pathsent_plpmtud_probes/// The amount of PLPMTUD probe packets sent on this path (also counted by `sent_packets`)lost_plpmtud_probes/// The amount of PLPMTUD probe packets lost on this path (ignored by `lost_packets` and/// `lost_bytes`)black_holes_detected/// The number of times a black hole was detected in the path/// Largest UDP payload size the path currently supports/// Statistics related to a transmission pathudp_tx/// Statistics about UDP datagrams transmitted on a connectionudp_rx/// Statistics about UDP datagrams received on a connectionframe_tx/// Statistics about frames transmitted on a connectionframe_rx/// Statistics about frames received on a connection/// Statistics related to the current transmission path/// Connection statistics//! Connection statisticsget_or_insert_recvget_or_insert_sendByteSliceBytesArrayBytesSourceconn_state/// Access to streams/// Open a single stream if possible/// Returns `None` if the streams in the given direction are currently exhausted./// Accept a remotely initiated stream of a certain directionality, if possible/// Returns `None` if there are no new incoming streams for this connection./// Has no impact on the data flow-control or stream concurrency limits./// The number of streams that may have unacknowledged data.remote_open_streams/// The number of remotely initiated open streams of a certain directionality./// Includes remotely initiated streams, which have not been accepted via [`accept`](Self::accept)./// These streams count against the respective concurrency limit reported by/// [`Connection::max_concurrent_streams`](super::Connection::max_concurrent_streams).// Needed for cfg(fuzzing)/// Read from the given recv stream/// `max_length` limits the maximum size of the returned `Bytes` value; passing `usize::MAX`/// will yield the best performance. `ordered` will make sure the returned chunk's offset will/// have an offset exactly equal to the previously returned offset plus the previously returned/// bytes' length./// Yields `Ok(None)` if the stream was finished. Otherwise, yields a segment of data and its/// offset in the stream. If `ordered` is `false`, segments may be received in any order, and/// the `Chunk`'s `offset` field can be used to determine ordering in the caller./// While most applications will prefer to consume stream data in order, unordered reads can/// improve performance when packet loss occurs and data cannot be retransmitted before the flow/// control window is filled. On any given stream, you can switch from ordered to unordered/// reads, but ordered reads on streams that have seen previous unordered reads will return/// `ReadError::IllegalOrderedRead`./// Stop accepting data on the given receive stream/// Check whether this stream has been reset by the peer, returning the reset error code if so/// After returning `Ok(Some(_))` once, stream state will be discarded and all future calls will/// return `Err(ClosedStream)`./// Send data on the given stream/// Returns the number of bytes successfully written./// Returns the number of bytes and chunks successfully written./// Note that this method might also write a partial chunk. In this case/// [`Written::chunks`] will not count this chunk as fully written. However/// the chunk will be advanced and contain only non-written data after the call.write_source/// Check if this stream was stopped, get the reason if it was/// Finish a send stream, signalling that no more data will be sent./// If this fails, no [`StreamEvent::Finished`] will be generated./// Abandon transmitting data on a stream/// - when applied to a receive stream/// Set the priority of a stream/// Get the priority of a streamPendingStream/// The next stream to write out. This is `Some` when `TransportConfig::send_fairness(false)` and writing a stream is/// interrupted while the stream still has some pending data. See `reinsert_pending()`.recency/// A monotonically decreasing counter, used to implement round-robin scheduling for streams of the same priority./// Underflowing is not a practical concern, as it is initialized to u64::MAX and only decremented by 1 in `push_pending`PendingStreamsQueue/// A queue of streams with pending outgoing data, sorted by priorityreinsert_pending/// Reinsert a stream that was pending and still contains unsent data.push_pending/// Push a pending stream ID with the given priority, queued after any already-queued streams for the priority/// The priority of the stream// Note that this field should be kept above the `recency` field, in order for the `Ord` derive to be correct// (See https://doc.rust-lang.org/stable/std/cmp/trait.Ord.html#derivable)/// A tie-breaker for streams of the same priority, used to improve fairness by implementing round-robin scheduling:/// Larger values are prioritized, so it is initialised to `u64::MAX`, and when a stream writes data, we know/// that it currently has the highest recency value, so it is deprioritized by setting its recency to 1 less than the/// previous lowest recency value, such that all other streams of this priority will get processed once before we get back/// round to this one/// The ID of the stream// The way this type is used ensures that every instance has a unique `recency` value, so this field should be kept below// the `priority` and `recency` fields, so that it does not interfere with the behaviour of the `Ord` derive/// The [`StreamId`] of a stream with pending data queued, ordered by its priority and recency/// Directionality for which streams have been opened/// One or more new streams has been opened and might be readable/// Which stream is now readable/// A currently open stream likely has data or errors waiting to be read/// Which stream is now writable/// A formerly write-blocked stream might be ready for a write or have been stopped/// Only generated for streams that are currently open./// Which stream has been finished/// A finished stream has been fully acknowledged or stopped/// Which stream has been stopped/// Error code supplied by the peer/// The peer asked us to stop sending on an outgoing stream/// Directionality for which streams are newly available/// At least one new stream of a certain directionality may be opened/// Application events about streams"A frame might need to be enqueued"/// Indicates whether a frame needs to be transmitted/// This type wraps around bool and uses the `#[must_use]` attribute in order/// to prevent accidental loss of the frame transmission requirement.should_transmit/// Returns whether a frame should be transmitted/// Error indicating that a stream has not been opened or has already been finished or resetStreamHalfStreamRecv// NB: when adding or removing fields, remember to update `reinit`.sent_max_stream_dataingest/// Process a STREAM frame/// Return value is `(number_of_new_bytes_ingested, stream_is_closed)`/// Returns the window that should be advertised in a `MAX_STREAM_DATA` frame/// The method returns a tuple which consists of the window that should be/// announced, as well as a boolean parameter which indicates if a new/// transmission of the value is recommended. If the boolean value is/// `false` the new window should only be transmitted if a previous transmission/// had failed.record_sent_max_stream_data/// Records that a `MAX_STREAM_DATA` announcing a certain window was sent/// This will suppress enqueuing further `MAX_STREAM_DATA` frames unless/// either the previous transmission was not acknowledged or the window/// further increased.final_offset_unknown/// Whether the total amount of data that the peer will send on this stream is unknown/// True until we've received either a reset or the final frame./// Implies that the sender might benefit from stream-level flow control updates, and we might/// need to issue connection-level flow control updates due to flow control budget use by this/// stream in the future, even if it's been stopped.can_send_flow_control/// Whether stream-level flow control updates should be sent for this streamis_receiving/// Whether data is still being accepted from the peerfinal_offset/// Returns `false` iff the reset was redundantreset_codecredit_consumed_by/// Compute the amount of flow control credit consumed, or return an error if more was consumed/// than issuedChunksState/// Chunks returned from [`RecvStream::read()`][crate::RecvStream::read]./// ### Note: Finalization Needed/// Bytes read from the stream are not released from the congestion window until/// either [`Self::finalize()`] is called, or this type is dropped./// It is recommended that you call [`Self::finalize()`] because it returns a flag/// telling you whether reading from the stream has resulted in the need to transmit a packet./// If this type is leaked, the stream will remain blocked on the remote peer until/// another read from the stream is done./// Next/// Should call finalize() when done calling this./// Mark the read data as consumed from the stream./// The number of read bytes will be released from the congestion window,/// allowing the remote peer to send more data if it was previously blocked./// If [`ShouldTransmit::should_transmit()`] returns `true`,/// a packet needs to be sent to the peer informing them that the stream is unblocked./// This means that you should call [`Connection::poll_transmit()`][crate::Connection::poll_transmit]/// and send the returned packet as soon as is reasonable, to unblock the remote peer.finalize_inner/// No more data is currently available on this stream./// If more data on this stream is received from the peer, an `Event::StreamReadable` will be/// generated for this stream, indicating that retrying the read might succeed./// The peer abandoned transmitting data on this stream./// Errors triggered when reading from a recv stream/// The stream has not been opened or was already stopped, finished, or reset/// Errors triggered when opening a recv stream for readingResetRecvdreordered_frames_while_stoppedfin_pending/// Whether a frame containing a FIN bit must be transmitted, even if we don't have any new dataconnection_blocked/// Whether this stream is in the `connection_blocked` list of `Streams`stop_reason/// The reason the peer wants us to stop, if `STOP_SENDING` was receivedis_reset/// Whether the stream has been reset/// Update stream state due to a reset sent by the local applicationtry_stop/// Handle STOP_SENDING/// Returns true if the stream was stopped due to this frame, and false/// if it had been stopped beforeStreamMeta/// Returns whether the stream has been finished and all data has been acknowledged by the peerincrease_max_data/// Handle increase to stream-level flow control limit/// Returns whether the stream was unblocked/// The wrapped slice of `Bytes`/// The amount of chunks consumed from this source/// A [`BytesSource`] implementation for `&'a mut [Bytes]`/// The type allows to dequeue [`Bytes`] chunks from an array of chunks, up to/// a configured limit.pop_chunk/// The wrapped byte slice/// A [`BytesSource`] implementation for `&[u8]`/// The type allows to dequeue a single [`Bytes`] chunk, which will be lazily/// created from a reference. This allows to defer the allocation until it is/// known how much data needs to be copied./// Returns the next chunk from the source of owned chunks./// This method will consume parts of the source./// Calling it will yield `Bytes` elements up to the configured `limit`./// - The first item is the yielded `Bytes` element. The element will be///   empty if the limit is zero or no more data is available./// - The second item returns how many complete chunks inside the source had///   had been consumed. This can be less than 1, if a chunk inside the///   source had been truncated in order to adhere to the limit. It can also///   be more than 1, if zero-length chunks had been skipped./// A source of one or more buffers which can be converted into `Bytes` buffers on demand/// The purpose of this data type is to defer conversion as long as possible,/// so that no heap allocation is required in case no data is writable./// The amount of bytes which had been written/// The amount of full chunks which had been written/// If a chunk was only partially written, it will not be counted by this field./// Indicates how many bytes and chunks had been transferred in a write operation/// The peer is not able to accept additional data, or the connection is congested./// If the peer issues additional flow control credit, a [`StreamEvent::Writable`] event will/// be generated, indicating that retrying the write might succeed./// [`StreamEvent::Writable`]: crate::StreamEvent::Writable/// The peer is no longer accepting data on this stream, and it has been implicitly reset. The/// stream cannot be finished or further written to./// The stream has not been opened or has already been finished or reset/// Errors triggered while writing to a send stream/// Sending new datafinish_ackedDataSent/// Stream was finished; now sending retransmits onlyResetSent/// Sent RESET/// The peer is no longer accepting data on this stream. No/// [`StreamEvent::Finished`] event will be emitted for this stream./// The stream has not been opened or was already finished or reset/// Reasons why attempting to finish a stream might failbytes_arraybyte_slice/// A `Recv` that is ready to be opened/// A `Recv` that has been opened/// Wrapper around `Recv` that facilitates reusing `Recv` instancesas_open_recv/// Returns a reference to the inner `Recv` if the stream is openas_open_recv_mut// Returns a mutable reference to the inner `Recv` if the stream is open// Returns the inner `Recv`// Reinitialize the stream so the inner `Recv` can be reused// Set of streams that are currently open, or could be immediately opened by the peerfree_recv/// Maximum number of locally-initiated streams that may be opened over the lifetime of the/// connection so far, per directionmax_remote/// Maximum number of remotely-initiated streams that may be opened over the lifetime of thesent_max_remote/// Value of `max_remote` most recently transmitted to the peer in a `MAX_STREAMS` frameallocated_remote_count/// Number of streams that we've given the peer permission to open and which aren't fully closedmax_concurrent_remote_count/// Size of the desired stream flow control window. May be smaller than `allocated_remote_count`/// due to `set_max_concurrent` calls.flow_control_adjusted/// Whether `max_concurrent_remote_count` has ever changednext_remote/// Lowest remotely-initiated stream index that haven't actually been opened by the peer/// Whether the remote endpoint has opened any streams the application doesn't know about yet,/// per directionalitynext_reported_remote// Next to report to the application, once opened/// Number of outbound streams/// This differs from `self.send.len()` in that it does not include streams that the peer is/// permitted to open but which have not yet been opened./// Streams with outgoing data queued, sorted by priority/// Streams blocked on connection-level flow control or stream window space/// Streams are only added to this list when a write fails./// Connection-level flow control budget dictated by the peer/// The initial receive windowlocal_max_data/// Limit on incoming data, which is transmitted through `MAX_DATA` framessent_max_data/// The last value of `MAX_DATA` which had been queued for transmission in/// an outgoing `MAX_DATA` framedata_sent/// Sum of current offsets of all send streams.data_recvd/// Sum of end offsets of all receive streams. Includes gaps, so it's an upper bound.unacked_data/// Total quantity of unacknowledged outgoing data/// Configured upper bound for `unacked_data`./// Note this may be less than `unacked_data` if the user has set a new value./// Configured upper bound for how much unacked data the peer can send us per streaminitial_max_stream_data_uni// Pertinent state from the TransportParameters supplied by the peerinitial_max_stream_data_bidi_localinitial_max_stream_data_bidi_remotereceive_window_shrink_debt/// The shrink to be applied to local_max_data when receive_window is shrunkensure_remote_streams/// Ensure we have space for at least a full flow control window of remotely-initiated streams/// to be open, and notify the peer if the window has movedzero_rtt_rejected/// Process incoming stream frame/// If successful, returns whether a `MAX_DATA` frame needs to be transmittedResetStream/// Process incoming RESET_STREAM framereceived_stop_sending/// Process incoming `STOP_SENDING` framereset_ackedcan_send_stream_data/// Whether any stream data is queued, regardless of control frames/// Whether MAX_STREAM_DATA frames could be sent for stream `id`write_control_frameswrite_stream_frameson_stream_frame/// Notify the application that new streams were opened or a stream became readable.received_ack_ofreceived_max_streamsreceived_max_data/// Handle increase to connection-level flow control limitreceived_max_stream_datawrite_limit/// Returns the maximum amount of data this is allowed to be written on the connection/// Yield stream eventsqueue_max_stream_id/// Queues MAX_STREAM_ID frames in `pending` if needed/// Returns whether any frames were queued.validate_receive_id/// Check for errors entailed by the peer's use of `id` as a send streamis_local_unopened/// Whether a locally initiated stream has never been openset_max_concurrentmax_concurrent/// Set the receive_window and returns whether the receive_window has been/// expanded or shrunk: true if expanded, false if shrunk.add_read_credits/// Adds credits to the connection flow control window/// Returns whether a `MAX_DATA` frame should be enqueued as soon as possible./// This will only be the case if the window update would is significant/// enough. As soon as a window update with a `MAX_DATA` frame has been/// queued, the [`Recv::record_sent_max_stream_data`] function should be called to/// suppress sending further updates until the window increases significantlystream_freed/// Update counters for removal of a streamstream_recv_freedmax_send_dataConnStatetrivial_flow_controlreset_flow_controlreset_after_empty_frame_flow_controlduplicate_reset_flow_controlrecv_stoppedstopped_resetsend_stoppedfinal_offset_flow_controlstream_priorityrequeue_stream_prioritysame_stream_priorityunfair_priority_bumpstop_finishedreset_stream_cannot_send// Verify that a stream that's been reset doesn't cause the appearance of pending datastream_limit_fixedstream_limit_growsstream_limit_shrinksremote_stream_capacityexpand_receive_windowshrink_receive_windowexpand_send_windowshrink_send_windowLossDetection/// When to send an ack-eliciting probe packet or declare unacked packets lost/// When to close the connection after no activity/// When the close timer expires, the connection has been gracefully terminated.KeyDiscard/// When keys are discarded because they should not be needed anymorePathValidation/// When to give up on validating a new path to the peer/// When to send a `PING` frame to keep the connection alivePacing/// When pacing will allow us to send a packetPushNewCid/// When to invalidate old CID and proactively push new one via NEW_CONNECTION_ID frameMaxAckDelay/// When to send an immediate ACK if there are unacked ack-eliciting packets of the peer/// A table of data associated with each distinct kind of `Timer`/// Compares byte strings in constant time.CryptoErrorsignature_lenaead_from_hkdfAeadKeyPrkLessSafeKeyquicHeaderProtectionKeyKeyChangeSecretsSuitegot_handshake_datanext_secretssuiteTlsSession/// A rustls TLS sessioninitial_keys/// For the rustls `TlsSession`, the `Any` type is `Vec<rustls::pki_types::CertificateDer>`early_cryptoearly_data_acceptedread_handshakewrite_handshakenext_1rtt_keysis_valid_retryRETRY_INTEGRITY_KEY_DRAFTRETRY_INTEGRITY_NONCE_DRAFTRETRY_INTEGRITY_KEY_V1RETRY_INTEGRITY_NONCE_V1/// The negotiated application protocol, if ALPN is in use/// Guaranteed to be set if a nonempty list of protocols was specified for this connection./// The server name specified by the client, if any/// Always `None` for outgoing connectionsHandshakeData/// Authentication data for (rustls) TLS sessioninitial/// A QUIC-compatible TLS client configuration/// Quinn implicitly constructs a `QuicClientConfig` with reasonable defaults within/// [`ClientConfig::with_root_certificates()`][root_certs] and [`ClientConfig::with_platform_verifier()`][platform]./// Alternatively, `QuicClientConfig`'s [`TryFrom`] implementation can be used to wrap around a/// custom [`rustls::ClientConfig`], in which case care should be taken around certain points:/// - If `enable_early_data` is not set to true, then sending 0-RTT data will not be possible on///   outgoing connections./// - The [`rustls::ClientConfig`] must have TLS 1.3 support enabled for conversion to succeed./// The object in the `resumption` field of the inner [`rustls::ClientConfig`] determines whether/// calling `into_0rtt` on outgoing connections returns `Ok` or `Err`. It typically allows/// `into_0rtt` to proceed if it recognizes the server name, and defaults to an in-memory cache of/// 256 server names./// [root_certs]: crate::config::ClientConfig::with_root_certificates()/// [platform]: crate::config::ClientConfig::with_platform_verifier()/// Initialize a sane QUIC-compatible TLS client configuration/// QUIC requires that TLS 1.3 be enabled. Advanced users can use any [`rustls::ClientConfig`] that/// satisfies this requirement.with_initialNoInitialCipherSuite/// Initialize a QUIC-compatible TLS client configuration with a separate initial cipher suite/// This is useful if you want to avoid the initial cipher suite for traffic encryption.start_sessionspecific/// Whether the initial cipher suite was supplied by the caller/// The initial cipher suite (AES-128-GCM-SHA256) is not available/// When the cipher suite is supplied `with_initial()`, it must be/// [`CipherSuite::TLS13_AES_128_GCM_SHA256`]. When the cipher suite is derived from a config's/// [`CryptoProvider`][provider], that provider must reference a cipher suite with the same ID./// [provider]: rustls::crypto::CryptoProvider/// A QUIC-compatible TLS server configuration/// Quinn implicitly constructs a `QuicServerConfig` with reasonable defaults within/// [`ServerConfig::with_single_cert()`][single]. Alternatively, `QuicServerConfig`'s [`TryFrom`]/// implementation or `with_initial` method can be used to wrap around a custom/// [`rustls::ServerConfig`], in which case care should be taken around certain points:/// - If `max_early_data_size` is not set to `u32::MAX`, the server will not be able to accept///   incoming 0-RTT data. QUIC prohibits `max_early_data_size` values other than 0 or `u32::MAX`./// - The `rustls::ServerConfig` must have TLS 1.3 support enabled for conversion to succeed./// [single]: crate::config::ServerConfig::with_single_cert()/// Initialize a sane QUIC-compatible TLS server configuration/// QUIC requires that TLS 1.3 be enabled, and that the maximum early data size is either 0 or/// `u32::MAX`. Advanced users can use any [`rustls::ServerConfig`] that satisfies these/// requirements.retry_taginitial_suite_from_providerconfidentiality_limitintegrity_limitinterpret_versionring_like/// Cryptography interface based on *ring*/// TLS interface based on rustls/// Create the initial set of keys given the client's initial destination ConnectionId/// Get data negotiated during the handshake, if available/// Returns `None` until the connection emits `HandshakeDataReady`./// Get the peer's identity, if available/// Get the 0-RTT keys if available (clients only)/// On the client side, this method can be used to see if 0-RTT key material is available/// to start sending data before the protocol handshake has completed./// Returns `None` if the key material is not available. This might happen if you have/// not connected to this server before./// If the 0-RTT-encrypted data has been accepted by the peer/// Returns `true` until the connection is fully established./// Read bytes of handshake data/// This should be called with the contents of `CRYPTO` frames. If it returns `Ok`, the/// caller should call `write_handshake()` to check if the crypto protocol has anything/// to send to the peer. This method will only return `true` the first time that/// handshake data is available. Future calls will always return false./// On success, returns `true` iff `self.handshake_data()` has been populated./// The peer's QUIC transport parameters/// These are only available after the first flight from the peer has been received./// Writes handshake bytes into the given buffer and optionally returns the negotiated keys/// When the handshake proceeds to the next phase, this method will return a new set of/// keys to encrypt data with./// Compute keys for the next key update/// Verify the integrity of a retry packet/// Fill `output` with `output.len()` bytes of keying material derived/// from the [Session]'s secrets, using `label` and `context` for domain/// separation./// This function will fail, returning [ExportKeyingMaterialError],/// if the requested output length is too large./// A cryptographic session (commonly TLS)/// Key for encrypting data/// Key for decrypting data/// A pair of keys for bidirectional communication/// Header protection keys/// Packet protection keys/// A complete set of keys for a certain packet space/// Start a client session with this configuration/// Client-side configuration for the crypto protocol/// Generate the integrity tag for a retry packet/// Never called if `initial_keys` rejected `version`./// Start a server session with this configuration/// Server-side configuration for the crypto protocol/// Encrypt the packet payload with the given packet number/// Decrypt the packet payload with the given packet number/// The length of the AEAD tag appended to packets on encryption/// Maximum number of packets that may be sent using a single key/// Maximum number of incoming packets that may fail decryption before the connection must be/// abandoned/// Keys used to protect packet payloads/// Decrypt the given packet's header/// Encrypt the given packet's header/// The sample size used for this key's algorithm/// Keys used to protect packet headers/// Method for signing a message/// Length of `sign`'s output/// Method for verifying a message/// A key for signing with HMAC-based algorithms/// Error returned by [Session::export_keying_material]./// This error occurs if the requested output length is too large./// Derive AEAD using hkdf/// A pseudo random key for HKDF/// Method for sealing message `data`/// Method for opening a sealed message `data`/// A key for sealing data with AEAD-based algorithms/// Generic crypto errors/// Error indicating that the specified QUIC version is not supported//! Traits and implementations for the QUIC cryptography protocol//! The protocol logic in Quinn is contained in types that abstract over the actual//! cryptographic protocol used. This module contains the traits used for this//! abstraction layer as well as a single implementation of these traits that uses//! *ring* and rustls to implement the TLS protocol support.//! Note that usage of any protocol (version) other than TLS 1.3 does not conform to any//! published versions of the specification, and will not be supported in QUIC v1.PacketDecodeErrorProtectedInitialHeaderIncomingTokenInvalidRetryTokenErrorPreferredAddressConnectionIndexConnectionMetalocal_cid_generator/// Whether the underlying UDP socket promises not to fragment packetslast_stateless_reset/// Time at which a stateless reset was most recently sentincoming_buffersIncomingBuffer/// Buffered Initial and 0-RTT messages for pending incoming connectionsall_incoming_buffers_total_bytes/// The main entry point to the library/// This object performs no I/O whatsoever. Instead, it consumes incoming packets and/// connection-generated events via `handle` and `handle_event`./// Create a new endpoint/// `allow_mtud` enables path MTU detection when requested by `Connection` configuration for/// better performance. This requires that outgoing packets are never fragmented, which can be/// achieved via e.g. the `IPV6_DONTFRAG` socket option./// If `rng_seed` is provided, it will be used to initialize the endpoint's rng (having priority/// over the rng seed configured in [`EndpointConfig`]). Note that the `rng_seed` parameter will/// be removed in a future release, so prefer setting it to `None` and configuring rng seeds/// using [`EndpointConfig::rng_seed`]./// Process `EndpointEvent`s emitted from related `Connection`s/// In turn, processing this event may return a `ConnectionEvent` for the same `Connection`./// Process an incoming UDP datagramFourTuple/// Initiate a connectionsend_new_identifiersnew_cid/// Generate a connection ID for `ch`AcceptError// AcceptError cannot be made smaller without semver breakageearly_validate_first_packet/// Check if we should refuse a connection attempt regardless of the packet's contents/// Errors if `incoming.may_retry()` is false./// Doing this actively, rather than merely dropping the [`Incoming`], is necessary to prevent/// memory leaks due to state within [`Endpoint`] tracking the incoming connection.clean_up_incoming/// Clean up endpoint data structures associated with an `Incoming`.add_connectioninitial_close/// Access the configuration used by this endpoint/// Number of connections that are currently openincoming_buffer_bytes/// Counter for the number of bytes currently used/// in the buffers for Initial and 0-RTT messages for pending incoming connectionsknown_connectionsknown_cidscids_exhausted/// Whether we've used up 3/4 of the available CID space/// We leave some space unused so that `new_cid` can be relied upon to finish quickly. We don't/// bother to check when CID longer than 4 bytes are used because 2^40 connections is a lot./// Buffered Initial and 0-RTT messages for a pending incoming connectionRouteDatagramTo/// Part of protocol state incoming datagrams can be routed toconnection_ids_initial/// Identifies connections based on the initial DCID the peer utilized/// Uses a standard `HashMap` to protect against hash collision attacks./// Used by the server, not the client.connection_ids/// Identifies connections based on locally created CIDs/// Uses a cheaper hash function since keys are locally createdincoming_connection_remotes/// Identifies incoming connections with zero-length CIDsoutgoing_connection_remotes/// Identifies outgoing connections with zero-length CIDs/// We don't yet support explicit source addresses for client connections, and zero-length CIDs/// require a unique four-tuple, so at most one client connection with zero-length local CIDs/// may be established per remote. We must omit the local address from the key because we don't/// necessarily know what address we're sending from, and hence receiving at.connection_reset_tokensResetTokenTable/// Reset tokens provided by the peer for the CID each connection is currently sending to/// Incoming stateless resets do not have correct CIDs, so we need this to identify the correct/// recipient, if any./// Maps packets to existing connectionsinsert_initial_incoming/// Associate an incoming connection with its initial destination CIDremove_initial/// Remove an association with an initial destination CIDinsert_initial/// Associate a connection with its initial destination CIDinsert_conn/// Associate a connection with its first locally-chosen destination CID if used, or otherwise/// its current 4-tupleretire/// Discard a connection ID/// Remove all references to a connection/// Find the existing connection that `datagram` should be routed to, if anyinit_cidcids_issuedloc_cids/// Remote/local addresses the connection began with/// Only needed to support connections with zero-length CIDs, which cannot migrate, so we don't/// bother keeping it up to date.reset_token/// Reset token provided by the peer for the CID we're currently sending to, and the address/// being sent to/// Internal identifier for a `Connection` currently associated with an endpoint/// The datagram is redirected to its `Connection`NewConnection/// The datagram may result in starting a new `Connection`/// Response generated directly by the endpoint/// Event resulting from processing a single datagramreceived_atecnincoming_idximproper_drop_warnerIncomingImproperDropWarner/// An incoming connection for which the server has not yet begun its part of the handshake./// This has the same behavior as [`Connection::local_ip`]./// The original destination connection ID sent by the clientEndpointStopping/// The endpoint can no longer create new connections/// Indicates that a necessary component of the endpoint has been dropped or otherwise disabled./// Try using longer connection IDsInvalidServerName/// The given server name was malformedInvalidRemoteAddress/// The remote [`SocketAddr`] supplied was malformed/// Examples include attempting to connect to port 0, or using an inappropriate address family.NoDefaultClientConfig/// No default client configuration was set up/// Use `Endpoint::connect_with` to specify a client configuration./// The local endpoint does not support the QUIC version specified in the client configuration/// Errors in the parameters being used to create a new connection/// These arise before any I/O has been performed./// Underlying error describing reason for failure/// Optional response to transmit back/// Error type for attempting to accept an [`Incoming`]/// Reset Tokens which are associated with peer socket addresses/// The standard `HashMap` is used since both `SocketAddr` and `ResetToken` are/// peer generated and might be usable for hash collision attacks.// A single socket can only listen on a single port, so no need to store it explicitly/// Identifies a connection by the combination of remote and local addresses/// Including the local ensures good behavior when the host has multiple IP addresses on the same/// subnet and zero-length connection IDs are in use./// A QUIC frame typeDatagramInfoSIZE_BOUND/// Smallest number of bytes this type of frame is guaranteed to fit within.frame_typesACK_ECNRESET_STREAMSTOP_SENDINGNEW_TOKENMAX_DATAMAX_STREAM_DATAMAX_STREAMS_BIDIMAX_STREAMS_UNIDATA_BLOCKEDSTREAM_DATA_BLOCKEDSTREAMS_BLOCKED_BIDISTREAMS_BLOCKED_UNINEW_CONNECTION_IDRETIRE_CONNECTION_IDPATH_CHALLENGEPATH_RESPONSECONNECTION_CLOSEAPPLICATION_CLOSEHANDSHAKE_DONEACK_FREQUENCYIMMEDIATE_ACKSTREAM_TYSDATAGRAM_TYSMaxDataMaxStreamDataMaxStreamsDataBlockedStreamDataBlockedStreamsBlockedRetireConnectionIdPathChallengeImmediateAckHandshakeDoneis_ack_elicitingis_transport_layer/// Class of error as encoded in the specification/// Type of frame that caused the close/// Human-readable reason for the close/// Reason given by the transport for closing the connection/// Application-specific reason code/// Reason given by an application for closing the connectionlargestAckIterect0ect1ce/// Metadata from a stream frame// This manual implementation exists because `Default` is not implemented for `StreamId`/// A vector of [`StreamMeta`] with optimization for the single element caselast_tytake_lenIterErrtake_remainingInvalidFramescan_ack_blocks/// Validate exactly `n` ACK ranges in `buf` and return the number of bytes they coverInvalidFrameIdRETIRE_CONNECTION_ID_SIZE_BOUND/// Payload/// An unreliable datagramrequest_max_ack_delayack_codingack_frequency_codingimmediate_ack_codingconstant_timeConnectionIdParserProtectedHeadertransport_errortoken_memory_cache// Deal with time/// The QUIC protocol version implemented./// The initiator of a connection/// The acceptor of a connection/// Whether an endpoint was the initiator of a connection/// Shorthand for `self == Side::Client`/// Shorthand for `self == Side::Server`Bi/// Data flows in both directionsUni/// Data flows only from the stream's initiator/// Whether a stream communicates data in both directions or only from the initiator/// Identifier for a stream within a particular connection/// Create a new StreamId/// Which side of a connection initiated the stream/// Which directions data flows in/// Distinguishes streams of the same initiator and directionality/// The socket this datagram should be sent to/// Explicit congestion notification bits to set on the packet/// Amount of data written to the caller-supplied buffer/// The segment size if this transmission contains multiple datagrams./// This is `None` if the transmit only contains a single datagramsrc_ip/// Optional source IP address for the datagram/// An outgoing packetLOC_CID_COUNT/// The maximum number of CIDs we bother to issue per connection/// <https://www.rfc-editor.org/rfc/rfc9000.html#name-datagram-size>/// Maximum number of streams that can be uniquely identified by a stream ID//! Low-level protocol logic for the QUIC protoocol//! quinn-proto contains a fully deterministic implementation of QUIC protocol logic. It contains//! no networking code and does not get any relevant timestamps from the operating system. Most//! users may want to use the futures-based quinn API instead.//! The quinn-proto API might be of interest if you want to use it from a C or C++ project//! through C bindings or if you want to use a different event loop than the one tokio provides.//! The most important types are `Endpoint`, which conceptually represents the protocol state for//! a single socket and mostly manages configuration and dispatches incoming datagrams to the//! related `Connection`. `Connection` types contain the bulk of the protocol logic related to//! managing a single connection and all the related state (such as streams).// Fixes welcome:// Useful internal constantsplain_header/// Decodes a QUIC packet's invariant header/// Due to packet number encryption, it is impossible to fully decode a header/// (which includes a variable-length packet number) without crypto context./// The crypto context (represented by the `Crypto` type in Quinn) is usually/// part of the `Connection`, or can be derived from the destination CID for/// Initial packets./// To cope with this, we decode the invariant header (which should be stable/// across QUIC versions), which gives us the destination CID and allows us/// to inspect the version and packet type (which depends on the version)./// This information allows us to fully decode and decrypt the packet./// Begin decoding a QUIC packet from `bytes`, returning any trailing data not part of that packet/// The underlying partially-decoded packet datainitial_headerhas_long_headeris_initialdst_cid/// The destination connection ID of the packet/// Length of QUIC packet being decodeddecrypt_headerheader_datareserved_bits_validsrc_cidVersionNegotiateis_protected/// Whether the packet is encrypted on the wireis_1rtthas_frames/// Whether the payload of this packet contains QUIC framespn// Packet number length, payload length needed/// An Initial packet header/// Type of the Long header packet/// Destination Connection ID/// Source Connection ID/// Length of the packet payload/// QUIC version/// A Long packet header, as used during the handshake/// A Retry packet header/// Spin bit/// A short packet header, as used during the data phase/// Random value/// A Version Negotiation packet header/// Plain packet headeras_initial/// The destination Connection ID of the packet/// Decode a plain header from given buffer, with given [`ConnectionIdParser`].token_pos/// The position of a token in the packet buffer/// Header of an Initial packet, before decryption// An encoded packet number/// A [`ConnectionIdParser`] implementation that assumes the connection ID is of fixed length/// Create a new instance of `FixedLengthConnectionIdParser`/// Parse a connection id from given buffer/// Parse connection id in short header packetLongHeaderType/// Long packet type including non-uniform cases/// Handshake packetZeroRtt/// 0-RTT packet/// Long packet types with uniform header structure/// The version that was unsupported/// Packet uses a QUIC version that is not supported/// The packet header is invalid/// Packet decode errorLONG_HEADER_FORMSPIN_BITSHORT_RESERVED_BITSLONG_RESERVED_BITSKEY_PHASE_BIT/// Unprotected packets, used to bootstrap the handshake/// Application data space, used for 0-RTT and post-handshake/1-RTT packets/// Packet number space identifierscheck_pnroundtrip_packet_numberspn_encodepn_expand_roundtripheader_encodingARRAY_RANGE_SET_INLINE_CAPACITY/// A set of u64 values optimized for long runs and random insert/delete/contains/// `ArrayRangeSet` uses an array representation, where each array entry represents/// a range./// The array-based RangeSet provides 2 benefits:/// - There exists an inline representation, which avoids the need of heap///   allocating ACK ranges for SentFrames for small ranges./// - Iterating over ranges should usually be faster since there is only///   a single cache-friendly contiguous range./// `ArrayRangeSet` is especially useful for tracking ACK ranges where the amount/// of ranges is usually very low (since ACK numbers are in consecutive fashion/// unless reordering or packet loss occur)./// The capacity of elements directly stored in [`ArrayRangeSet`]/// An inline capacity of 2 is chosen to keep `SentFrame` below 128 bytes.pop_minExcludedIncluded/// Find closest range to `x` that begins at or before it/// Find the closest range to `x` that begins after it/// Add a range to the set, returning the intersection of current ranges with the new oneEltIterpeek_min/// Portion of the intersection arising from a range beginning at or before the newly inserted/// range/// Union of the input range and all ranges that have been visited by the iterator so far/// Iterator returned by `RangeSet::replace`// https://github.com/rust-lang/rust-clippy/issues/11086replace_containedreplace_containsreplace_predreplace_succreplace_exact_predreplace_exact_succ/// This module contains tests which only apply for this `RangeSet` implementation/// Tests which apply for all implementations can be found in the `tests.rs` modulearray_range_setbtree_range_setcommon_set_testsmerge_and_splitdouble_merge_exactsingle_merge_lowsingle_merge_highdouble_merge_widedouble_removeinsert_multipleremove_multipledouble_insertskip_empty_rangescompare_insert_to_referencecompare_remove_to_referencecreate_initial_setsRefRangeSetassert_sets_equal/// A very simple reference implementation of a RangeSet/// Events sent from an Endpoint to a Connection/// A datagram has been received for the ConnectionNewIdentifiers/// New connection identifiers have been issued for the Connectionfirst_decode/// Variant of [`ConnectionEventInner`]./// Events sent from a Connection to an Endpointdrained/// Construct an event that indicating that a `Connection` will no longer emit events/// Useful for notifying an `Endpoint` that a `Connection` has been destroyed outside of the/// usual state machine flow, e.g. when being dropped by the user./// Determine whether this is the last event a `Connection` will emit/// Useful for determining when connection-related event loop state can be freed./// The connection has been drained/// The reset token and/or address eligible for generating resets has been updatedNeedIdentifiers/// The connection needs connection identifiers/// Stop routing connection ID for this sequence number to the connection/// When `bool == true`, a new connection ID will be issued to peer/// length of CID/// CID in byte array/// Protocol-level identifier for a connection./// Mainly useful for identifying this connection's packets on the wire with tools like Wireshark./// Construct cid from byte arrayfrom_buf/// Constructs cid by reading `len` bytes from a `Buf`/// Callers need to assure that `buf.remaining() >= len`decode_long/// Decode from long header formatencode_long/// Encode in long header formatEct0/// The ECT(0) codepoint, indicating that an endpoint is ECN-capableEct1/// The ECT(1) codepoint, indicating that an endpoint is ECN-capableCe/// The CE codepoint, signalling that congestion was experienced/// Explicit congestion notification codepoint/// Create new object from the given bitsis_ce/// Returns whether the codepoint is a CE, signalling that congestion was experiencedWebPkiClientVerifierversion_negotiate_serverversion_negotiate_clientlifecycledraft_version_compatserver_stateless_resetclient_stateless_resetstateless_reset_limit/// Verify that stateless resets are rate-limitedfinish_stream_simplereject_self_signed_server_certreject_missing_client_certhigh_latency_handshakezero_rtt_happypathzero_rtt_rejectiontest_zero_rtt_incoming_limitzero_rtt_incoming_buffer_sizezero_rtt_incoming_buffer_size_totalalpn_successserver_alpn_unsetclient_alpn_unsetalpn_mismatchstream_id_limitkey_update_simplekey_update_reorderedinitial_retransmitinstant_close_1instant_close_2instant_server_closeconnection_close_sends_acksserver_hs_retransmittest_flow_controlstream_flow_controlconn_flow_controlstop_opens_bidiimplicit_openzero_length_cidcid_rotationcid_retirementfinish_stream_flow_control_reorderedhandshake_1rtt_handlingstop_before_finishstop_during_finishcongested_tail_loss// Ensure we can recover from loss of tail packets when the congestion window is fulltail_loss_small_segment_size// Send a tail-loss probe when GSO segment_size is less than INITIAL_MTUtail_loss_respect_max_datagrams// Respect max_datagrams when TLP happensdatagram_send_recvdatagram_recv_buffer_overflowdatagram_unsupportedlarge_initial/// Ensure that we don't yield a finish event before the actual FIN is acked so the peer isn't left/// hangingfinish_retransmit/// Ensure that we don't yield a finish event while there's still unacknowledged datarepeated_request_response/// Ensures that exchanging data on a client-initiated bidirectional stream works past the initial/// stream window.handshake_anti_deadlock_probe/// Ensures that the client sends an anti-deadlock probe after an incomplete server's first flightserver_can_send_3_inital_packets/// Ensures that the server can respond with 3 initial packets during the handshake/// before the anti-amplification limit kicks in when MTUs are similar.big_cert_and_key/// Generate a big fat certificate that can't fit inside the initial anti-amplification limitmalformed_token_lenloss_probe_requests_immediate_ackconnect_too_low_mtu/// This is mostly a sanity check to ensure our testing code is correctly dropping packets above the/// pmtuconnect_lost_mtu_probes_do_not_trigger_congestion_controlconnect_detects_mtumigrate_detects_new_mtu_and_respects_original_peer_max_udp_payload_sizeconnect_runs_mtud_again_after_600_secondsblackhole_after_mtu_change_repairs_itselfmtud_probes_include_immediate_ackpacket_splitting_with_default_mtupacket_splitting_not_necessary_after_higher_mtu_discoveredsingle_ack_eliciting_packet_triggers_ack_after_delayimmediate_ack_triggers_ackout_of_order_ack_eliciting_packet_triggers_acksingle_ack_eliciting_packet_with_ce_bit_triggers_immediate_acksetup_ack_frequency_testack_frequency_ack_delayed_from_first_of_flight/// Verify that max ACK delay is counted from the first ACK-eliciting packetack_frequency_ack_sent_after_max_ack_delayack_frequency_ack_sent_after_packets_above_thresholdack_frequency_ack_sent_after_reordered_packets_below_thresholdack_frequency_ack_sent_after_reordered_packets_above_thresholdack_frequency_update_max_delaystream_chunkspure_sender_voluntarily_acks/// Verify that an endpoint which receives but does not send ACK-eliciting data still receives ACKs/// occasionally. This is not required for conformance, but makes loss detection more responsive and/// reduces receiver memory use.reject_manuallyvalidate_then_reject_manuallyendpoint_and_connection_impl_send_syncstream_gsodatagram_gsogso_truncation/// Verify that UDP datagrams are padded to MTU if specified in the transport config.large_datagram_with_acks/// Verify that a large application datagram is sent successfully when an ACK frame too large to fit/// alongside it is also queued, in exactly 2 UDP datagrams.voluntary_ack_with_large_datagrams/// Verify that an ACK prompted by receipt of many non-ACK-eliciting packets is sent alongside/// outgoing application datagrams too large to coexist in the same packet with it.reject_short_idcidpreferred_address/// Ensure that a connection can be made when a preferred address is advertised by the server,/// regardless of whether the address is actually used.// Enable this if you want to run these tests in the browser.// Unfortunately it's either-or: Enable this and you can run in the browser, disable to run in nodejs.// #[cfg(all(target_family = "wasm", target_os = "unknown"))]// wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);stateless_retryretry_token_expireduse_tokenretry_then_use_tokenuse_token_then_retryuse_same_token_twiceuse_token_expiredFakeTimeSource//! Tests specifically for tokensKeyLogFileTestEndpoint/// Start time/// Simulates the maximum size allowed for UDP payloads by the link (packets exceeding this size will be dropped)congestion_experienced/// Simulates explicit congestion notification// One-wayspins/// Number of spin bit flipslast_spindefault_with_deterministic_pnsnew_from_endpoint/// Returns whether the connection is not idle/// Advance time until both connections are idledrive_bounded/// Advance time until both connections are idle, or after 100 steps have been executed/// Returns true if the amount of steps exceeds the bounds, because the connections never became/// idledrive_clientdrive_serverbegin_connect/// Just start connecting the clientfinish_connectclient_conn_mutclient_streamsclient_sendclient_recvclient_datagramsserver_conn_mutserver_streamsserver_sendserver_recvserver_datagramsdelayedacceptedcaptured_packetscapture_inbound_packetshandle_incomingIncomingConnectionBehaviorwaiting_incomingvalidate_incomingdrive_incomingdrive_outgoingnext_wakeupdelay_outboundfinish_delaytry_acceptrejectassert_acceptassert_accept_errorassert_no_acceptserver_config_with_certserver_cryptoserver_crypto_with_alpnserver_crypto_with_certserver_crypto_innerclient_config_with_deterministic_pnsclient_config_with_certsclient_cryptoclient_crypto_with_alpnclient_crypto_innermin_optMAX_DATAGRAMS/// The maximum of datagrams TestEndpoint will produce via `poll_transmit`split_transmitpacket_sizeset_congestion_experiencedSimpleTokenLog/// Record that the token was used and, ideally, return a token reuse error if the token may/// have been already used previously/// False negatives and false positives are both permissible. Called when a client uses an/// address validation token./// - `nonce`: A server-generated random unique value for the token./// - `issued`: The time the server issued the token./// - `lifetime`: The expiration time of address validation tokens sent via NEW_TOKEN frames,///   as configured by [`ServerValidationTokenConfig::lifetime`][1]./// [1]: crate::ValidationTokenConfig::lifetime/// ## Security & Performance/// To the extent that it is possible to repeatedly trigger false negatives (returning `Ok` for/// a token which has been reused), an attacker could use the server to perform [amplification/// attacks][2]. The QUIC specification requires that this be limited, if not prevented fully./// A false positive (returning `Err` for a token which has never been used) is not a security/// vulnerability; it is permissible for a `TokenLog` to always return `Err`. A false positive/// causes the token to be ignored, which may cause the transmission of some 0.5-RTT data to be/// delayed until the handshake completes, if a sufficient amount of 0.5-RTT data it sent./// [2]: https://en.wikipedia.org/wiki/Denial-of-service_attack#Amplification/// Responsible for limiting clients' ability to reuse validation tokens/// [_RFC 9000 § 8.1.4:_](https://www.rfc-editor.org/rfc/rfc9000.html#section-8.1.4)/// > Attackers could replay tokens to use servers as amplifiers in DDoS attacks. To protect/// > against such attacks, servers MUST ensure that replay of tokens is prevented or limited./// > Servers SHOULD ensure that tokens sent in Retry packets are only accepted for a short time,/// > as they are returned immediately by clients. Tokens that are provided in NEW_TOKEN frames/// > (Section 19.7) need to be valid for longer but SHOULD NOT be accepted multiple times./// > Servers are encouraged to allow tokens to be used only once, if possible; tokens MAY include/// > additional information about clients to further narrow applicability or reuse./// `TokenLog` pertains only to tokens provided in NEW_TOKEN frames./// Error for when a validation token may have been reused/// Null implementation of [`TokenLog`], which never accepts tokens/// Potentially store a token for later one-time use/// Called when a NEW_TOKEN frame is received from the server./// Try to find and take a token that was stored with the given server name/// The same token must never be returned from `take` twice, as doing so can be used to/// de-anonymize a client's traffic./// Called when trying to connect to a server. It is always ok for this to return `None`./// Responsible for storing validation tokens received from servers and retrieving them for use in/// subsequent connections/// Null implementation of [`TokenStore`], which does not store any tokens/// State in an `Incoming` determined by a token or lack thereoffrom_header/// Construct for an `Incoming` given the first packet header, or error if the connection/// cannot be established/// Error for a token being unambiguously from a Retry packet, and not valid/// The connection cannot be established./// Content that is encrypted from the client/// Randomly generated value, which must be unique, and is visible to the client/// Retry or validation token/// Construct with newly sampled randomness/// Encode and encrypt/// Decode and decrypt/// The client's address/// The destination connection ID set in the very first packet from the client/// The time at which this token was issued/// Token originating from a Retry packet/// The client's IP address (its port is likely to change between sessions)Validation/// Token originating from a NEW_TOKEN frame/// Content of a [`Token`] that is encrypted from the clientTokenType/// Variant tag for a [`TokenPayload`]encode_addrdecode_addrencode_ipdecode_ipencode_unix_secsdecode_unix_secs/// Stateless reset token/// Used for an endpoint to securely communicate that it has lost state for a connection.// Custom PartialEq impl matches derived semanticstoken_round_tripretry_token_sanityvalidation_token_sanityinvalid_token_returns_err/// `TokenStore` implementation that stores up to `N` tokens per server name for up to a/// limited number of server names, in-memory/// Construct empty/// Defaults to a maximum of 256 servers and 2 tokens per servermax_server_namesmax_tokens_per_server// map from server name to index in lru/// Lockable inner state of `TokenMemoryCache`// invariant: tokens is never empty/// Cache entry within `TokenMemoryCache`'s LRU slab/// Construct with a single tokencache_testzero_max_server_nameszero_queue_length//! Storing tokens sent from servers in NEW_TOKEN frames and using them in subsequent connections/// Type of error/// Frame type that triggered the error/// Human-readable explanation of the reason/// Transport-level errors occur when a peer violates the protocol specification/// Transport-level error code/// Create QUIC error code from TLS alert codeCONNECTION_REFUSEDFLOW_CONTROL_ERRORSTREAM_LIMIT_ERRORSTREAM_STATE_ERRORFINAL_SIZE_ERRORFRAME_ENCODING_ERRORTRANSPORT_PARAMETER_ERRORCONNECTION_ID_LIMIT_ERRORPROTOCOL_VIOLATIONINVALID_TOKENAPPLICATION_ERRORCRYPTO_BUFFER_EXCEEDEDKEY_UPDATE_ERRORAEAD_LIMIT_REACHEDNO_VIABLE_PATH"the connection is being closed abruptly in the absence of any error""the endpoint encountered an internal error and cannot continue with the connection""the server refused to accept a new connection""received more data than permitted in advertised data limits""received a frame for a stream identifier that exceeded advertised the stream limit for the corresponding stream type""received a frame for a stream that was not in a state that permitted that frame""received a STREAM frame or a RESET_STREAM frame containing a different final size to the one already established""received a frame that was badly formatted""received transport parameters that were badly formatted, included an invalid value, was absent even though it is mandatory, was present though it is forbidden, or is otherwise in error""the number of connection IDs provided by the peer exceeds the advertised active_connection_id_limit""detected an error with protocol compliance that was not covered by more specific error codes""received an invalid Retry Token in a client Initial""the application or application protocol caused the connection to be closed during the handshake""received more data in CRYPTO frames than can be buffered""key update error""the endpoint has reached the confidentiality or integrity limit for the AEAD algorithm""no viable network path exists"apply_params// Apply a given macro to a list of all the transport parameters having integer types, along with// their codes and default values. Using this helps us avoid error-prone duplication of the// contained information across decoding, encoding, and the `Default` impl. Whenever we want to do// something with transport parameters, we'll handle the bulk of cases by writing a macro that// takes a list of arguments in this form, then passing it to this macro.make_structr" Transport parameters used to negotiate connection-level preferences between peers"r" Milliseconds, disabled if zero"r" Limits the size of UDP payloads that the endpoint is willing to receive"r" Initial value for the maximum amount of data that can be sent on the connection"initial_max_datar" Initial flow control limit for locally-initiated bidirectional streams"r" Initial flow control limit for peer-initiated bidirectional streams"r" Initial flow control limit for unidirectional streams"r" Initial maximum number of bidirectional streams the peer may initiate"initial_max_streams_bidir" Initial maximum number of unidirectional streams the peer may initiate"initial_max_streams_unir" Exponent used to decode the ACK Delay field in the ACK frame"ack_delay_exponentr" Maximum amount of time in milliseconds by which the endpoint will delay sending"r" acknowledgments"r" Maximum number of connection IDs from the peer that an endpoint is willing to store"active_connection_id_limitr" Does the endpoint support active connection migration"disable_active_migrationr" Maximum size for datagram frames"max_datagram_frame_sizer" The value that the endpoint included in the Source Connection ID field of the first"r" Initial packet it sends for the connection"initial_src_cidr" The endpoint is willing to receive QUIC packets containing any value for the fixed"r" bit"r" Minimum amount of time in microseconds by which the endpoint is able to delay"r" sending acknowledgments"r" If a value is provided, it implies that the endpoint supports QUIC Acknowledgement"r" Frequency"min_ack_delayr" The value of the Destination Connection ID field from the first Initial packet sent"r" by the client"original_dst_cidr" The value that the server included in the Source Connection ID field of a Retry"r" packet"r" Token used by the client to verify a stateless reset from the server"stateless_reset_tokenr" The server's preferred address for communication after handshake completion"r" The randomly generated reserved transport parameter to sustain future extensibility"r" of transport parameter extensions."r" When present, it is included during serialization but ignored during deserialization."grease_transport_parameterReservedTransportParameterr" Defines the order in which transport parameters are serialized."r" This field is initialized only for outgoing `TransportParameters` instances and"r" is set to `None` for `TransportParameters` received from a peer."write_orderTransportParameterIdSUPPORTEDr" Standard defaults, used if the peer does not supply a given parameter."validate_resumption_from/// Check that these parameters are legal when resuming from/// certain cached parametersissue_cids_limit/// Maximum number of CIDs to issue to this peer/// Consider both a) the active_connection_id_limit from the other end; and/// b) LOC_CID_COUNT used locallyaddress_v4address_v6/// A server's preferred address/// This is communicated as a transport parameter during TLS session establishment.wire_sizeIllegalValue/// Parameters that are semantically invalid/// Catch-all error for problems while decoding transport parameters/// Errors encountered while decoding `TransportParameters`/// Encode `TransportParameters` into buffer/// Decode `TransportParameters` from buffer/// The reserved identifier of the transport parameterMAX_PAYLOAD_LEN/// Buffer to store the parameter payload/// The number of bytes to include in the wire format from the `payload` buffer/// A reserved transport parameter./// It has an identifier of the form 31 * N + 27 for the integer value of N./// Such identifiers are reserved to exercise the requirement that unknown transport parameters be ignored./// The reserved transport parameter has no semantics and can carry arbitrary values./// It may be included in transport parameters sent to the peer, and should be ignored when received./// See spec: <https://www.rfc-editor.org/rfc/rfc9000.html#section-18.1>/// Generates a transport parameter with a random payload and a reserved ID./// The implementation is inspired by quic-go and quiche:/// 1. <https://github.com/quic-go/quic-go/blob/3e0a67b2476e1819752f04d75968de042b197b56/internal/wire/transport_parameters.go#L338-L344>/// 2. <https://github.com/google/quiche/blob/cb1090b20c40e2f0815107857324e99acf6ec567/quiche/quic/core/crypto/transport_parameters.cc#L843-L860>generate_reserved_id/// Generates a random reserved identifier of the form `31 * N + 27`, as required by RFC 9000./// Reserved transport parameter identifiers are used to test compliance with the requirement/// that unknown transport parameters must be ignored by peers./// See: <https://www.rfc-editor.org/rfc/rfc9000.html#section-18.1> and <https://www.rfc-editor.org/rfc/rfc9000.html#section-22.3>/// The maximum length of the payload to include as the parameter payload./// This value is not a specification-imposed limit but is chosen to match/// the limit used by other implementations of QUIC, e.g., quic-go and quiche.OriginalDestinationConnectionId// https://www.rfc-editor.org/rfc/rfc9000.html#iana-tp-tableMaxIdleTimeoutStatelessResetTokenMaxUdpPayloadSizeInitialMaxData0x05InitialMaxStreamDataBidiLocal0x06InitialMaxStreamDataBidiRemote0x07InitialMaxStreamDataUni0x08InitialMaxStreamsBidiInitialMaxStreamsUni0x0AAckDelayExponent0x0B0x0CDisableActiveMigration0x0D0x0EActiveConnectionIdLimit0x0FInitialSourceConnectionIdRetrySourceConnectionId// Smallest possible ID of reserved transport parameter https://datatracker.ietf.org/doc/html/rfc9000#section-22.3MaxDatagramFrameSize// https://www.rfc-editor.org/rfc/rfc9221.html#section-30x2AB2GreaseQuicBit// https://www.rfc-editor.org/rfc/rfc9287.html#section-30xFF04DE1BMinAckDelayDraft07// https://datatracker.ietf.org/doc/html/draft-ietf-quic-ack-frequency#section-10.1/// Array with all supported transport parameter IDsdecode_cidreserved_transport_parameter_generate_reserved_idStepRngnext_u64reserved_transport_parameter_ignored_when_readread_semantic_validationresumption_params_validation//! QUIC connection transport parameters//! The `TransportParameters` type is used to represent the transport parameters//! negotiated by peers while establishing a QUIC connection. This process//! happens as part of the establishment of the TLS session. As such, the types//! contained in this modules should generally only be referred to by custom//! implementations of the `crypto::Session` trait./// An integer less than 2^62/// Values of this type are suitable for encoding as QUIC variable-length integer.// It would be neat if we could express to Rust that the top two bits are available for use as enum// discriminants/// The largest representable value/// The largest encoded value length/// Construct a `VarInt` infallibly/// Succeeds iff `x` < 2^62from_u64_unchecked/// Create a VarInt without ensuring it's in range/// `x` must be less than 2^62./// Extract the integer value/// Compute the number of bytes needed to encode this value/// Error returned when constructing a `VarInt` from a value >= 2^62AlignedcmsgMsgHdr/// Helper to encode a series of control messages (native "cmsgs") to a buffer for use in `sendmsg`//  like API./// The operation must be "finished" for the native msghdr to be usable, either by calling `finish`/// explicitly or by dropping the `Encoder`./// - `hdr` must contain a suitably aligned pointer to a big enough buffer to hold control messages///   bytes. All bytes of this buffer can be safely written./// - The `Encoder` must be dropped before `hdr` is passed to a system call, and must not be leaked./// Append a control message to the buffer./// - If insufficient buffer space remains./// - If `T` has stricter alignment requirements than `M::ControlMessage`/// Finishes appending control messages to the buffer// Statically guarantees that the encoding operation is "finished" before the control buffer is read// by `sendmsg` like API.CMsgHdr/// `cmsg` must refer to a native cmsg containing a payload of type `T`/// `hdr` must hold a pointer to memory outliving `'a` which can be soundly read for the/// lifetime of the constructed `Iter` and contains a buffer of native cmsgs, i.e. is aligned//  for native `cmsghdr`, is fully initialized, and has correct internal links.cmsg_first_hdrcmsg_nxt_hdrset_control_len/// Sets the number of control messages added to this `struct msghdr`./// Note that this is a destructive operation and should only be done as a finalisationcontrol_len// Helper traits for native types for control messagescmsg_data// Conservative bound for align_of<libc::cmsghdr>/// Helpers for [`libc::msghdr`]/// Helpers for [`libc::cmsghdr`]// Conservative bound for align_of<WinSock::CMSGHDR>CMSGHDRWSAMSG/// Helpers for [`WinSock::WSAMSG`]// https://learn.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-wsamsg// https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Networking/WinSock/struct.WSAMSG.html/// Helpers for [`WinSock::CMSGHDR`]// https://learn.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-wsacmsghdr// https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Networking/WinSock/struct.CMSGHDR.htmlcmsghdr_align// Helpers functions for `WinSock::WSAMSG` and `WinSock::CMSGHDR` are based on C macros from// https://github.com/microsoft/win32metadata/blob/main/generation/WinSDK/RecompiledIdlHeaders/shared/ws2def.h#L741cmsgdata_alignIO_ERROR_LOG_INTERVALUdpSockReflog_sendmsg_errorlast_send_error/// Fallback UDP socket interface that stubs out all special functionality/// Used when a better implementation is not available for a particular target, at the cost of/// reduced performance compared to that enabled by some target-specific interfaces./// Sends a [`Transmit`] on the given socket./// This function will only ever return errors of kind [`io::ErrorKind::WouldBlock`]./// All other errors will be logged and converted to `Ok`./// UDP transmission errors are considered non-fatal because higher-level protocols must/// employ retransmits and timeouts anyway in order to deal with UDP's unreliable nature./// Thus, logging is most likely the only thing you can do with these errors./// If you would like to handle these errors yourself, use [`UdpSocketState::try_send`]/// Sends a [`Transmit`] on the given socket without any additional error handling.max_gso_segmentsgro_segments/// Resize the send buffer of `socket` to `bytes`/// Resize the receive buffer of `socket` to `bytes`/// Get the size of the `socket` send buffer/// Get the size of the `socket` receive buffer/// Number of UDP packets to send/receive at a time/// The source address of the datagram(s) contained in the buffer/// The number of bytes the associated buffer has/// The size of a single datagram in the associated buffer/// When GRO (Generic Receive Offload) is used this indicates the size of a single/// datagram inside the buffer. If the buffer is larger, that is if [`len`] is greater/// then this value, then the individual datagrams contained have their boundaries at/// `stride` increments from the start. The last datagram could be smaller than/// `stride`./// [`len`]: RecvMeta::len/// The Explicit Congestion Notification bits for the datagram(s) in the bufferdst_ip/// The destination IP address which was encoded in this datagram/// Populated on platforms: Windows, Linux, Android (API level > 25),/// FreeBSD, OpenBSD, NetBSD, macOS, and iOS./// Metadata for a single buffer filled with bytes received from the network/// This associated buffer can contain one or more datagrams, see [`stride`]./// [`stride`]: RecvMeta::stride/// Constructs a value with arbitrary fields, intended to be overwritten/// Contents of the datagram/// Log at most 1 IO error per minute/// Logs a warning message when sendmsg fails/// Logging will only be performed if at least [`IO_ERROR_LOG_INTERVAL`]/// has elapsed since the last error was logged.SockRef/// A borrowed UDP socket/// On Unix, constructible via `From<T: AsFd>`. On Windows, constructible via `From<T:/// AsSocket>`.// Wrapper around socket2 to avoid making it a public dependency and incurring stability risk//! Uniform interface to send and receive UDP packets with advanced features useful for QUIC//! This crate exposes kernel UDP stack features available on most modern systems which are required//! for an efficient and conformant QUIC implementation. As of this writing, these are not available//! in std or major async runtimes, and their niche character and complexity are a barrier to adding//! them. Hence, a dedicated crate.//! Exposed features include://! - Segmentation offload for bulk send and receive operations, reducing CPU load.//! - Reporting the exact destination address of received packets and specifying explicit source//!   addresses for sent packets, allowing responses to be sent from the address that the peer//!   expects when there are multiple possibilities. This is common when bound to a wildcard address//!   in IPv6 due to [RFC 8981] temporary addresses.//! - [Explicit Congestion Notification], which is required by QUIC to prevent packet loss and reduce//!   latency on congested links when supported by the network path.//! - Disabled IP-layer fragmentation, which allows the true physical MTU to be detected and reduces//!   risk of QUIC packet loss.//! Some features are unavailable in some environments. This can be due to an outdated operating//! system or drivers. Some operating systems may not implement desired features at all, or may not//! yet be supported by the crate. When support is unavailable, functionality will gracefully//! degrade.//! [RFC 8981]: https://www.rfc-editor.org/rfc/rfc8981.html//! [Explicit Congestion Notification]: https://www.rfc-editor.org/rfc/rfc3168.htmlIpTosTysendmsg_einval/// True if we have received EINVAL error from `sendmsg` system call at least once./// If enabled, we assume that old kernel is used and switch to fallback mode./// In particular, we do not use IP_TOS cmsg_type in this case,/// which is not supported on Linux <3.13 and results in not sending the UDP packet at all./// Tokio-compatible UDP socket with some useful specializations./// Unlike a standard tokio UDP socket, this allows ECN bits to be read and written on some/// The maximum amount of segments which can be transmitted if a platform/// supports Generic Send Offload (GSO)./// This is 1 if the platform doesn't support GSO. Subject to change if errors are detected/// while using GSO./// The number of segments to read when GRO is enabled. Used as a factor to/// compute the receive buffer size./// Returns 1 if the platform doesn't support GRO./// Whether transmitted datagrams might get fragmented by the IP layer/// Returns `false` on targets which employ e.g. the `IPV6_DONTFRAG` socket option./// Returns true if we previously got an EINVAL error from `sendmsg` syscall.set_sendmsg_einval/// Sets the flag indicating we got EINVAL error from `sendmsg` syscall.// only used on Linuxprepare_msg// only used on FreeBSD & macOSprepare_recvdecode_recv// Chosen somewhat arbitrarily; might benefit from additional tuning.SUPPORTED_SINCEKernelVersion// Support for UDP GSO has been added to linux kernel in version 4.18// https://github.com/torvalds/linux/commit/cb586c63e3fc5b227c51fd8c4cb40b34d3750645/// Checks whether GSO support is available by checking the kernel version followed by setting/// the UDP_SEGMENT option on a socketSUPPORTED_BY_CURRENT_KERNEL// Avoid calling `supported_by_current_kernel` for each socket by using `OnceLock`.supported_by_current_kernelkernel_version_stringmajor_revision// https://www.linfo.org/kernel_version_numbering.htmlparse_current_kernel_version_release_stringparse_kernel_version_release_stringset_socket_option_supported/// Returns whether the given socket option is supported on the current platform/// Yields `Ok(true)` if the option was set successfully, `Ok(false)` if setting/// the option raised an `ENOPROTOOPT` or `EOPNOTSUPP` error, and `Err` for any other error.set_socket_optionOPTION_ON/// QUIC-friendly UDP socket for Windows/// Unlike a standard Windows UDP socket, this allows ECN bits to be read and written.set_gro/// Enable or disable receive offloading./// Also referred to as UDP Receive Segment Coalescing Offload (URO) on Windows./// <https://learn.microsoft.com/en-us/windows-hardware/drivers/network/udp-rsc-offload>/// Disabled by default on Windows due to <https://github.com/quinn-rs/quinn/issues/2041>.// Enough to store max(IP_PKTINFO + IP_ECN, IPV6_PKTINFO + IPV6_ECN) + max(UDP_SEND_MSG_SIZE, UDP_COALESCED_INFO) bytes (header + data) and some extra marginWSARECVMSG_PTRLPFN_WSARECVMSG// FIXME this could use [`std::sync::OnceLock`] once the MSRV is bumped to 1.70 and upperMAX_GSO_SEGMENTS/// For use by `ToTokens` implementations./// Appends the token specified to this list of tokens./// # use quote::{quote, TokenStreamExt, ToTokens};/// # use proc_macro2::TokenStream;/// struct X;/// impl ToTokens for X {///     fn to_tokens(&self, tokens: &mut TokenStream) {///         tokens.append_all(&[true, false]);/// let tokens = quote!(#X);/// assert_eq!(tokens.to_string(), "true false");append_separated/// Appends all of the items in the iterator `I`, separated by the tokens/// `U`.append_terminated/// Appends all tokens in the iterator `I`, appending `U` after each/// element, including after the last element of the iterator./// TokenStream extension trait with methods for appending tokens./// This trait is sealed and cannot be implemented outside of the `quote` crate."runtime.rs"__rt/// The whole point./// Performs variable interpolation against the input and produces it as/// [`TokenStream`]. For returning tokens to the compiler in a procedural macro, use/// `into()` to build a `TokenStream`./// [`TokenStream`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.TokenStream.html/// # Interpolation/// Variable interpolation is done with `#var` (similar to `$var` in/// `macro_rules!` macros). This grabs the `var` variable that is currently in/// scope and inserts it in that location in the output tokens. Any type/// implementing the [`ToTokens`] trait can be interpolated. This includes most/// Rust primitive types as well as most of the syntax tree types from the [Syn]/// [`ToTokens`]: trait.ToTokens.html/// [Syn]: https://github.com/dtolnay/syn/// Repetition is done using `#(...)*` or `#(...),*` again similar to/// `macro_rules!`. This iterates through the elements of any variable/// interpolated within the repetition and inserts a copy of the repetition body/// for each one. The variables in an interpolation may be anything that/// implements `IntoIterator`, including `Vec` or a pre-existing iterator./// - `#(#var)*` — no separators/// - `#(#var),*` — the character before the asterisk is used as a separator/// - `#( struct #var; )*` — the repetition can contain other tokens/// - `#( #k => println!("{}", #v), )*` — even multiple interpolations/// There are two limitations around interpolations in a repetition:/// - Every interpolation inside of a repetition must be a distinct variable.///   That is, `#(#a #a)*` is not allowed. Work around this by collecting `a`///   into a vector and taking references `a1 = &a` and `a2 = &a` which you use///   inside the repetition: `#(#a1 #a2)*`. Where possible, use meaningful names///   that indicate the distinct role of each copy./// - Every interpolation inside of a repetition must be iterable. If we have///   `vec` which is a vector and `ident` which is a single identifier,///   `#(#ident #vec)*` is not allowed. Work around this by using///   `std::iter::repeat(ident)` to produce an iterable that can be used from///   within the repetition./// # Hygiene/// Any interpolated tokens preserve the `Span` information provided by their/// `ToTokens` implementation. Tokens that originate within the `quote!`/// invocation are spanned with [`Span::call_site()`]./// [`Span::call_site()`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.html#method.call_site/// A different span can be provided through the [`quote_spanned!`] macro./// [`quote_spanned!`]: macro.quote_spanned.html/// # Return type/// The macro evaluates to an expression of type `proc_macro2::TokenStream`./// Meanwhile Rust procedural macros are expected to return the type/// `proc_macro::TokenStream`./// The difference between the two types is that `proc_macro` types are entirely/// specific to procedural macros and cannot ever exist in code outside of a/// procedural macro, while `proc_macro2` types may exist anywhere including/// tests and non-macro code like main.rs and build.rs. This is why even the/// procedural macro ecosystem is largely built around `proc_macro2`, because/// that ensures the libraries are unit testable and accessible in non-macro/// There is a [`From`]-conversion in both directions so returning the output of/// `quote!` from a procedural macro usually looks like `tokens.into()` or/// `proc_macro::TokenStream::from(tokens)`./// ## Procedural macro/// The structure of a basic procedural macro is as follows. Refer to the [Syn]/// crate for further useful guidance on using `quote!` as part of a procedural/// macro./// # #[cfg(any())]/// extern crate proc_macro;/// # use proc_macro2 as proc_macro;/// use proc_macro::TokenStream;/// # const IGNORE_TOKENS: &'static str = stringify! {/// #[proc_macro_derive(HeapSize)]/// pub fn derive_heap_size(input: TokenStream) -> TokenStream {///     // Parse the input and figure out what implementation to generate...///     # const IGNORE_TOKENS: &'static str = stringify! {///     let name = /* ... */;///     let expr = /* ... */;///     # let name = 0;///     # let expr = 0;///     let expanded = quote! {///         // The generated impl.///         impl heapsize::HeapSize for #name {///             fn heap_size_of_children(&self) -> usize {///                 #expr///     // Hand the output tokens back to the compiler.///     TokenStream::from(expanded)/// ## Combining quoted fragments/// Usually you don't end up constructing an entire final `TokenStream` in one/// piece. Different parts may come from different helper functions. The tokens/// produced by `quote!` themselves implement `ToTokens` and so can be/// interpolated into later `quote!` invocations to build up a final result./// # use quote::quote;/// let type_definition = quote! {...};/// let methods = quote! {...};/// let tokens = quote! {///     #type_definition///     #methods/// ## Constructing identifiers/// Suppose we have an identifier `ident` which came from somewhere in a macro/// input and we need to modify it in some way for the macro output. Let's/// consider prepending the identifier with an underscore./// Simply interpolating the identifier next to an underscore will not have the/// behavior of concatenating them. The underscore and the identifier will/// continue to be two separate tokens as if you had written `_ x`./// # use proc_macro2::{self as syn, Span};/// # let ident = syn::Ident::new("i", Span::call_site());/// // incorrect/// quote! {///     let mut _#ident = 0;/// The solution is to perform token-level manipulations using the APIs provided/// by Syn and proc-macro2./// let concatenated = format!("_{}", ident);/// let varname = syn::Ident::new(&concatenated, ident.span());///     let mut #varname = 0;/// ## Making method calls/// Let's say our macro requires some type specified in the macro input to have/// a constructor called `new`. We have the type in a variable called/// `field_type` of type `syn::Type` and want to invoke the constructor./// # let field_type = quote!(...);///     let value = #field_type::new();/// This works only sometimes. If `field_type` is `String`, the expanded code/// contains `String::new()` which is fine. But if `field_type` is something/// like `Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid/// syntax. Ordinarily in handwritten Rust we would write `Vec::<i32>::new()`/// but for macros often the following is more convenient.///     let value = <#field_type>::new();/// This expands to `<Vec<i32>>::new()` which behaves correctly./// A similar pattern is appropriate for trait methods.///     let value = <#field_type as core::default::Default>::default();/// Same as `quote!`, but applies a given span to all tokens originating within/// the macro invocation./// A span expression of type [`Span`], followed by `=>`, followed by the tokens/// to quote. The span expression should be brief -- use a variable for anything/// more than a few characters. There should be no space before the `=>` token./// [`Span`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.html/// # use proc_macro2::Span;/// # use quote::quote_spanned;/// let span = /* ... */;/// # let span = Span::call_site();/// # let init = 0;/// // On one line, use parentheses./// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init)));/// // On multiple lines, place the span at the top and use braces./// let tokens = quote_spanned! {span=>///     Box::into_raw(Box::new(#init))/// The lack of space before the `=>` should look jarring to Rust programmers/// and this is intentional. The formatting is designed to be visibly/// off-balance and draw the eye a particular way, due to the span expression/// being evaluated in the context of the procedural macro and the remaining/// tokens being evaluated in the generated code./// `ToTokens` implementation. Tokens that originate within the `quote_spanned!`/// invocation are spanned with the given span argument./// The following procedural macro code uses `quote_spanned!` to assert that a/// particular Rust type implements the [`Sync`] trait so that references can be/// safely shared between threads./// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html/// # use quote::{quote_spanned, TokenStreamExt, ToTokens};/// # use proc_macro2::{Span, TokenStream};/// # struct Type;/// # impl Type {/// #     fn span(&self) -> Span {/// #         Span::call_site()/// # impl ToTokens for Type {/// #     fn to_tokens(&self, _tokens: &mut TokenStream) {}/// # let ty = Type;/// # let call_site = Span::call_site();/// let ty_span = ty.span();/// let assert_sync = quote_spanned! {ty_span=>///     struct _AssertSync where #ty: Sync;/// If the assertion fails, the user will see an error like the following. The/// input span of their type is hightlighted in the error./// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied///   --> src/main.rs:10:21/// 10 |     static ref PTR: *const () = &();///    |                     ^^^^^^^^^ `*const ()` cannot be shared between threads safely/// In this example it is important for the where-clause to be spanned with the/// line/column information of the user's input type so that error messages are/// placed appropriately by the compiler. But it is also incredibly important/// that `Sync` resolves at the macro definition site and not the macro call/// site. If we resolve `Sync` at the same span that the user's type is going to/// be resolved, then they could bypass our check by defining their own trait/// named `Sync` that is implemented for their type.pounded_var_names// Extract the names of all #metavariables and pass them to the $finish macro.// in:   pounded_var_names!(then () a #b c #( #d )* #e)// out:  then!(() b d e)nested_tuples_pat// in:   nested_tuples_pat!(() a b c d e)// out:  ((((a b) c) d) e)// in:   nested_tuples_pat!(() a)// out:  amulti_zip_expr// in:   multi_zip_expr!(() a b c d e)// out:  a.into_iter().zip(b).zip(c).zip(d).zip(e)// in:   multi_zip_iter!(() a)quote_each_tokenquote_stringify// Unhygienically invoke whatever `stringify` the caller has in scope i.e. not a// local macro. The macros marked `local_inner_macros` above cannot invoke// `stringify` directly.//! This crate provides the [`quote!`] macro for turning Rust syntax tree data//! structures into tokens of source code.//! [`quote!`]: macro.quote.html//! Procedural macros in Rust receive a stream of tokens as input, execute//! arbitrary Rust code to determine how to manipulate those tokens, and produce//! a stream of tokens to hand back to the compiler to compile into the caller's//! crate. Quasi-quoting is a solution to one piece of that -- producing tokens//! to return to the compiler.//! The idea of quasi-quoting is that we write *code* that we treat as *data*.//! Within the `quote!` macro, we can write what looks like code to our text//! editor or IDE. We get all the benefits of the editor's brace matching,//! syntax highlighting, indentation, and maybe autocompletion. But rather than//! compiling that as code into the current crate, we can treat it as data, pass//! it around, mutate it, and eventually hand it back to the compiler as tokens//! to compile into the macro caller's crate.//! This crate is motivated by the procedural macro use case, but is a//! general-purpose Rust quasi-quoting library and is not specific to procedural//! macros.//! *Version requirement: Quote supports any compiler version back to Rust's//! very first support for procedural macros in Rust 1.15.0.*//! quote = "0.6"//! The following quasi-quoted block of code is something you might find in [a]//! procedural macro having to do with data structure serialization. The `#var`//! syntax performs interpolation of runtime variables into the quoted tokens.//! Check out the documentation of the [`quote!`] macro for more detail about//! the syntax. See also the [`quote_spanned!`] macro which is important for//! implementing hygienic procedural macros.//! [a]: https://serde.rs///! [`quote_spanned!`]: macro.quote_spanned.html//! # use quote::quote;//! # let generics = "";//! # let where_clause = "";//! # let field_ty = "";//! # let item_ty = "";//! # let path = "";//! # let value = "";//! let tokens = quote! {//!     struct SerializeWith #generics #where_clause {//!         value: &'a #field_ty,//!         phantom: core::marker::PhantomData<#item_ty>,//!     impl #generics serde::Serialize for SerializeWith #generics #where_clause {//!         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>//!         where//!             S: serde::Serializer,//!         {//!             #path(self.value, serializer)//!     SerializeWith {//!         value: #value,//!         phantom: core::marker::PhantomData::<#item_ty>,//! # Recursion limit//! The `quote!` macro relies on deep recursion so some large invocations may//! fail with "recursion limit reached" when you compile. If it fails, bump up//! the recursion limit by adding `#![recursion_limit = "128"]` to your crate.//! An even higher limit may be necessary for especially large invocations.// Quote types in rustdoc of other crates get linked to here.push_punctpush_addpush_add_eqpush_andpush_and_andpush_and_eqpush_atpush_bangpush_caretpush_caret_eqpush_colonpush_colon2push_commapush_divpush_div_eqpush_dotpush_dot2push_dot3push_dot_dot_eqpush_eqpush_eq_eqpush_gepush_gtpush_lepush_ltpush_mul_eqpush_nepush_orpush_or_eqpush_or_orpush_poundpush_questionpush_rarrowpush_larrowpush_rempush_rem_eqpush_fat_arrowpush_semipush_shlpush_shl_eqpush_shrpush_shr_eqpush_starpush_subpush_sub_eq/// Write `self` to the given `TokenStream`./// The token append methods provided by the [`TokenStreamExt`] extension/// trait may be useful for implementing `ToTokens`./// [`TokenStreamExt`]: trait.TokenStreamExt.html/// Example implementation for a struct representing Rust paths like/// `std::cmp::PartialEq`:/// use proc_macro2::{TokenTree, Spacing, Span, Punct, TokenStream};/// use quote::{TokenStreamExt, ToTokens};/// pub struct Path {///     pub global: bool,///     pub segments: Vec<PathSegment>,/// impl ToTokens for Path {///         for (i, segment) in self.segments.iter().enumerate() {///             if i > 0 || self.global {///                 // Double colon `::`///                 tokens.append(Punct::new(':', Spacing::Joint));///                 tokens.append(Punct::new(':', Spacing::Alone));///             segment.to_tokens(tokens);/// # pub struct PathSegment;/// # impl ToTokens for PathSegment {/// #     fn to_tokens(&self, tokens: &mut TokenStream) {/// Convert `self` directly into a `TokenStream` object./// This method is implicitly implemented using `to_tokens`, and acts as a/// convenience method for consumers of the `ToTokens` trait./// Types that can be interpolated inside a [`quote!`] invocation./// [`quote!`]: macro.quote.html/// Formatting macro for constructing `Ident`s./// Syntax is copied from the [`format!`] macro, supporting both positional and/// named arguments./// Only a limited set of formatting traits are supported. The current mapping/// of format types to traits is:/// * `{}` ⇒ [`IdentFragment`]/// * `{:o}` ⇒ [`Octal`](std::fmt::Octal)/// * `{:x}` ⇒ [`LowerHex`](std::fmt::LowerHex)/// * `{:X}` ⇒ [`UpperHex`](std::fmt::UpperHex)/// * `{:b}` ⇒ [`Binary`](std::fmt::Binary)/// # IdentFragment/// Unlike `format!`, this macro uses the [`IdentFragment`] formatting trait by/// default. This trait is like `Display`, with a few differences:/// * `IdentFragment` is only implemented for a limited set of types, such as///    unsigned integers and strings./// * [`Ident`] arguments will have their `r#` prefixes stripped, if present./// [`IdentFragment`]: crate::IdentFragment/// [`Ident`]: proc_macro2::Ident/// The [`Span`] of the first `Ident` argument is used as the span of the final/// identifier, falling back to [`Span::call_site`] when no identifiers are/// # use quote::format_ident;/// # let ident = format_ident!("Ident");/// // If `ident` is an Ident, the span of `my_ident` will be inherited from it./// let my_ident = format_ident!("My{}{}", ident, "IsCool");/// assert_eq!(my_ident, "MyIdentIsCool");/// Alternatively, the span can be overridden by passing the `span` named/// let my_span = /* ... */;/// # let my_span = proc_macro2::Span::call_site();/// format_ident!("MyIdent", span = my_span);/// [`Span`]: proc_macro2::Span/// [`Span::call_site`]: proc_macro2::Span::call_site/// <p><br></p>/// This method will panic if the resulting formatted string is not a valid/// Composing raw and non-raw identifiers:/// let my_ident = format_ident!("My{}", "Ident");/// assert_eq!(my_ident, "MyIdent");/// let raw = format_ident!("r#Raw");/// assert_eq!(raw, "r#Raw");/// let my_ident_raw = format_ident!("{}Is{}", my_ident, raw);/// assert_eq!(my_ident_raw, "MyIdentIsRaw");/// Integer formatting options:/// let num: u32 = 10;/// let decimal = format_ident!("Id_{}", num);/// assert_eq!(decimal, "Id_10");/// let octal = format_ident!("Id_{:o}", num);/// assert_eq!(octal, "Id_12");/// let binary = format_ident!("Id_{:b}", num);/// assert_eq!(binary, "Id_1010");/// let lower_hex = format_ident!("Id_{:x}", num);/// assert_eq!(lower_hex, "Id_a");/// let upper_hex = format_ident!("Id_{:X}", num);/// assert_eq!(upper_hex, "Id_A");format_ident_impl// Final state// Span argument// Named argument// Positional argument/// Format this value as an identifier fragment./// Span associated with this `IdentFragment`./// If non-`None`, may be inherited by formatted identifiers.IdentFragment/// Specialized formatting trait used by `format_ident!`./// [`Ident`] arguments formatted using this trait will have their `r#` prefix/// stripped, if present./// See [`format_ident!`] for more information./// [`format_ident!`]: crate::format_identident_fragment_display// Limited set of types which this is implemented for, as we want to avoid types// which will often include non-identifier characters in their `Display` impl.// false positive https://github.com/rust-lang/rust-clippy/issues/6983ident_fragment__quoter" The whole point."r" Performs variable interpolation against the input and produces it as"r" [`proc_macro2::TokenStream`]."r" Note: for returning tokens to the compiler in a procedural macro, use"r" `.into()` on the result to convert to [`proc_macro::TokenStream`]."r" [`TokenStream`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.TokenStream.html"r" <br>"r" # Interpolation"r" Variable interpolation is done with `#var` (similar to `$var` in"r" `macro_rules!` macros). This grabs the `var` variable that is currently in"r" scope and inserts it in that location in the output tokens. Any type"r" implementing the [`ToTokens`] trait can be interpolated. This includes most"r" Rust primitive types as well as most of the syntax tree types from the [Syn]"r" crate."r" [`ToTokens`]: trait.ToTokens.html"r" [Syn]: https://github.com/dtolnay/syn"r" Repetition is done using `#(...)*` or `#(...),*` again similar to"r" `macro_rules!`. This iterates through the elements of any variable"r" interpolated within the repetition and inserts a copy of the repetition body"r" for each one. The variables in an interpolation may be a `Vec`, slice,"r" `BTreeSet`, or any `Iterator`."r" - `#(#var)*` — no separators"r" - `#(#var),*` — the character before the asterisk is used as a separator"r" - `#( struct #var; )*` — the repetition can contain other tokens"r#" - `#( #k => println!("{}", #v), )*` — even multiple interpolations"#r" # Hygiene"r" Any interpolated tokens preserve the `Span` information provided by their"r" `ToTokens` implementation. Tokens that originate within the `quote!`"r" invocation are spanned with [`Span::call_site()`]."r" [`Span::call_site()`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.html#method.call_site"r" A different span can be provided through the [`quote_spanned!`] macro."r" [`quote_spanned!`]: macro.quote_spanned.html"r" # Return type"r" The macro evaluates to an expression of type `proc_macro2::TokenStream`."r" Meanwhile Rust procedural macros are expected to return the type"r" `proc_macro::TokenStream`."r" The difference between the two types is that `proc_macro` types are entirely"r" specific to procedural macros and cannot ever exist in code outside of a"r" procedural macro, while `proc_macro2` types may exist anywhere including"r" tests and non-macro code like main.rs and build.rs. This is why even the"r" procedural macro ecosystem is largely built around `proc_macro2`, because"r" that ensures the libraries are unit testable and accessible in non-macro"r" contexts."r" There is a [`From`]-conversion in both directions so returning the output of"r" `quote!` from a procedural macro usually looks like `tokens.into()` or"r" `proc_macro::TokenStream::from(tokens)`."r" [`From`]: https://doc.rust-lang.org/std/convert/trait.From.html"r" ### Procedural macro"r" The structure of a basic procedural macro is as follows. Refer to the [Syn]"r" crate for further useful guidance on using `quote!` as part of a procedural"r" macro."r" # #[cfg(any())]"r" extern crate proc_macro;"r" # extern crate proc_macro2;"r" use proc_macro::TokenStream;"r" # use proc_macro2::TokenStream;"r" use quote::quote;"r" # const IGNORE_TOKENS: &'static str = stringify! {"r" #[proc_macro_derive(HeapSize)]"r" pub fn derive_heap_size(input: TokenStream) -> TokenStream {"r"     // Parse the input and figure out what implementation to generate..."r"     # const IGNORE_TOKENS: &'static str = stringify! {"r"     let name = /* ... */;"r"     let expr = /* ... */;"r"     # };"r"     #"r"     # let name = 0;"r"     # let expr = 0;"r"     let expanded = quote! {"r"         // The generated impl."r"         impl heapsize::HeapSize for #name {"r"             fn heap_size_of_children(&self) -> usize {"r"                 #expr"r"             }"r"     // Hand the output tokens back to the compiler."r"     TokenStream::from(expanded)"r" <p><br></p>"r" ### Combining quoted fragments"r" Usually you don't end up constructing an entire final `TokenStream` in one"r" piece. Different parts may come from different helper functions. The tokens"r" produced by `quote!` themselves implement `ToTokens` and so can be"r" interpolated into later `quote!` invocations to build up a final result."r" # use quote::quote;"r" let type_definition = quote! {...};"r" let methods = quote! {...};"r" let tokens = quote! {"r"     #type_definition"r"     #methods"r" ### Constructing identifiers"r" Suppose we have an identifier `ident` which came from somewhere in a macro"r" input and we need to modify it in some way for the macro output. Let's"r" consider prepending the identifier with an underscore."r" Simply interpolating the identifier next to an underscore will not have the"r" behavior of concatenating them. The underscore and the identifier will"r" continue to be two separate tokens as if you had written `_ x`."r" # use proc_macro2::{self as syn, Span};"r#" # let ident = syn::Ident::new("i", Span::call_site());"#r" // incorrect"r" quote! {"r"     let mut _#ident = 0;"r" # ;"r" The solution is to build a new identifier token with the correct value. As"r" this is such a common case, the [`format_ident!`] macro provides a"r" convenient utility for doing so correctly."r" # use proc_macro2::{Ident, Span};"r" # use quote::{format_ident, quote};"r#" # let ident = Ident::new("i", Span::call_site());"#r#" let varname = format_ident!("_{}", ident);"#r"     let mut #varname = 0;"r" Alternatively, the APIs provided by Syn and proc-macro2 can be used to"r" directly build the identifier. This is roughly equivalent to the above, but"r" will not handle `ident` being a raw identifier."r#" let concatenated = format!("_{}", ident);"#r" let varname = syn::Ident::new(&concatenated, ident.span());"r" ### Making method calls"r" Let's say our macro requires some type specified in the macro input to have"r" a constructor called `new`. We have the type in a variable called"r" `field_type` of type `syn::Type` and want to invoke the constructor."r" # let field_type = quote!(...);"r"     let value = #field_type::new();"r" This works only sometimes. If `field_type` is `String`, the expanded code"r" contains `String::new()` which is fine. But if `field_type` is something"r" like `Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid"r" syntax. Ordinarily in handwritten Rust we would write `Vec::<i32>::new()`"r" but for macros often the following is more convenient."r"     let value = <#field_type>::new();"r" This expands to `<Vec<i32>>::new()` which behaves correctly."r" A similar pattern is appropriate for trait methods."r"     let value = <#field_type as core::default::Default>::default();"r" ### Interpolating text inside of doc comments"r" Neither doc comments nor string literals get interpolation behavior in"r" quote:"r" ```compile_fail"r"     /// try to interpolate: #ident"r"     ///"r"     /// ..."r#"     #[doc = "try to interpolate: #ident"]"#r" Instead the best way to build doc comments that involve variables is by"r" formatting the doc string literal outside of quote."r" # const IGNORE: &str = stringify! {"r" let msg = format!(...);"r#" # let ident = Ident::new("var", Span::call_site());"#r#" # let msg = format!("try to interpolate: {}", ident);"#r"     #[doc = #msg]"r" ### Indexing into a tuple struct"r" When interpolating indices of a tuple or tuple struct, we need them not to"r" appears suffixed as integer literals by interpolating them as [`syn::Index`]"r" instead."r" [`syn::Index`]: https://docs.rs/syn/2.0/syn/struct.Index.html"r" let i = 0usize..self.fields.len();"r" // expands to 0 + self.0usize.heap_size() + self.1usize.heap_size() + ..."r" // which is not valid syntax"r"     0 #( + self.#i.heap_size() )*"r" # use proc_macro2::{Ident, TokenStream};"r" # mod syn {"r" #     use proc_macro2::{Literal, TokenStream};"r" #     use quote::{ToTokens, TokenStreamExt};"r" #     pub struct Index(usize);"r" #     impl From<usize> for Index {"r" #         fn from(i: usize) -> Self {"r" #             Index(i)"r" #         }"r" #     }"r" #     impl ToTokens for Index {"r" #         fn to_tokens(&self, tokens: &mut TokenStream) {"r" #             tokens.append(Literal::usize_unsuffixed(self.0));"r" # struct Struct {"r" #     fields: Vec<Ident>,"r" # impl Struct {"r" #     fn example(&self) -> TokenStream {"r" let i = (0..self.fields.len()).map(syn::Index::from);"r" // expands to 0 + self.0.heap_size() + self.1.heap_size() + ..."__quote_spannedr" Same as `quote!`, but applies a given span to all tokens originating within"r" the macro invocation."r" # Syntax"r" A span expression of type [`Span`], followed by `=>`, followed by the tokens"r" to quote. The span expression should be brief &mdash; use a variable for"r" anything more than a few characters. There should be no space before the"r" `=>` token."r" [`Span`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.html"r" # use proc_macro2::Span;"r" # use quote::quote_spanned;"r" let span = /* ... */;"r" # let span = Span::call_site();"r" # let init = 0;"r" // On one line, use parentheses."r" let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init)));"r" // On multiple lines, place the span at the top and use braces."r" let tokens = quote_spanned! {span=>"r"     Box::into_raw(Box::new(#init))"r" The lack of space before the `=>` should look jarring to Rust programmers"r" and this is intentional. The formatting is designed to be visibly"r" off-balance and draw the eye a particular way, due to the span expression"r" being evaluated in the context of the procedural macro and the remaining"r" tokens being evaluated in the generated code."r" `ToTokens` implementation. Tokens that originate within the `quote_spanned!`"r" invocation are spanned with the given span argument."r" The following procedural macro code uses `quote_spanned!` to assert that a"r" particular Rust type implements the [`Sync`] trait so that references can be"r" safely shared between threads."r" [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html"r" # use quote::{quote_spanned, TokenStreamExt, ToTokens};"r" # use proc_macro2::{Span, TokenStream};"r" # struct Type;"r" # impl Type {"r" #     fn span(&self) -> Span {"r" #         Span::call_site()"r" # impl ToTokens for Type {"r" #     fn to_tokens(&self, _tokens: &mut TokenStream) {}"r" # let ty = Type;"r" # let call_site = Span::call_site();"r" let ty_span = ty.span();"r" let assert_sync = quote_spanned! {ty_span=>"r"     struct _AssertSync where #ty: Sync;"r" If the assertion fails, the user will see an error like the following. The"r" input span of their type is highlighted in the error."r" error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied"r"   --> src/main.rs:10:21"r"    |"r" 10 |     static ref PTR: *const () = &();"r"    |                     ^^^^^^^^^ `*const ()` cannot be shared between threads safely"r" In this example it is important for the where-clause to be spanned with the"r" line/column information of the user's input type so that error messages are"r" placed appropriately by the compiler."// Extract the names of all #metavariables and pass them to the $call macro.// in:   pounded_var_names!(then!(...) a #b c #( #d )* #e)// out:  then!(... b);//       then!(... d);//       then!(... e);pounded_var_names_with_contextpounded_var_with_contextquote_bind_into_iterquote_bind_next_or_break// The obvious way to write this macro is as a tt muncher. This implementation// does something more complex for two reasons.//   - With a tt muncher it's easy to hit Rust's built-in recursion_limit, which//     this implementation avoids because it isn't tail recursive.//   - Compile times for a tt muncher are quadratic relative to the length of//     the input. This implementation is linear, so it will be faster//     (potentially much faster) for big inputs. However, the constant factors//     of this implementation are higher than that of a tt muncher, so it is//     somewhat slower than a tt muncher if there are many invocations with//     short inputs.// An invocation like this://     quote_each_token!(_s a b c d e f g h i j);// expands to this://     quote_tokens_with_context!(_s//         (@  @  @  @   @   @   a   b   c   d   e   f   g  h  i  j)//         (@  @  @  @   @   a   b   c   d   e   f   g   h  i  j  @)//         (@  @  @  @   a   b   c   d   e   f   g   h   i  j  @  @)//         (@  @  @ (a) (b) (c) (d) (e) (f) (g) (h) (i) (j) @  @  @)//         (@  @  a  b   c   d   e   f   g   h   i   j   @  @  @  @)//         (@  a  b  c   d   e   f   g   h   i   j   @   @  @  @  @)//         (a  b  c  d   e   f   g   h   i   j   @   @   @  @  @  @)// which gets transposed and expanded to this://     quote_token_with_context!(_s @ @ @  @  @ @ a);//     quote_token_with_context!(_s @ @ @  @  @ a b);//     quote_token_with_context!(_s @ @ @  @  a b c);//     quote_token_with_context!(_s @ @ @ (a) b c d);//     quote_token_with_context!(_s @ @ a (b) c d e);//     quote_token_with_context!(_s @ a b (c) d e f);//     quote_token_with_context!(_s a b c (d) e f g);//     quote_token_with_context!(_s b c d (e) f g h);//     quote_token_with_context!(_s c d e (f) g h i);//     quote_token_with_context!(_s d e f (g) h i j);//     quote_token_with_context!(_s e f g (h) i j @);//     quote_token_with_context!(_s f g h (i) j @ @);//     quote_token_with_context!(_s g h i (j) @ @ @);//     quote_token_with_context!(_s h i j  @  @ @ @);//     quote_token_with_context!(_s i j @  @  @ @ @);//     quote_token_with_context!(_s j @ @  @  @ @ @);// Without having used muncher-style recursion, we get one invocation of// quote_token_with_context for each original tt, with three tts of context on// either side. This is enough for the longest possible interpolation form (a// repetition with separator, as in `# (#var) , *`) to be fully represented with// the first or last tt in the middle.// The middle tt (surrounded by parentheses) is the tt being processed.//   - When it is a `#`, quote_token_with_context can do an interpolation. The//     interpolation kind will depend on the three subsequent tts.//   - When it is within a later part of an interpolation, it can be ignored//     because the interpolation has already been done.//   - When it is not part of an interpolation it can be pushed as a single//     token into the output.//   - When the middle token is an unparenthesized `@`, that call is one of the//     first 3 or last 3 calls of quote_token_with_context and does not//     correspond to one of the original input tokens, so turns into nothing.quote_each_token_spanned// See the explanation on quote_each_token.quote_tokens_with_contextquote_tokens_with_context_spannedquote_token_with_context// Unparenthesized `@` indicates this call does not correspond to one of the// original input tokens. Ignore it.// A repetition with no separator.// ... and one step later.// A repetition with separator.// (A special case for `#(var)**`, where the first `*` is treated as the// repetition symbol and the second `*` is treated as an ordinary token.)// A non-repetition interpolation.// An ordinary token, not part of any interpolation.quote_token_with_context_spanned// See the explanation on quote_each_token, and on the individual rules of// quote_token_with_context.quote_token// These rules are ordered by approximate token frequency, at least for the// first 10 or so, to improve compile times. Having `ident` first is by far the// most important because it's typically 2-3x more common than the next most// common token.// Separately, we put the token being matched in the very front so that failing// rules may fail to match as quickly as possible.quote_token_spanned// See the comment above `quote_token!` about the rule ordering.//! [![github]](https://github.com/dtolnay/quote)&ensp;[![crates-io]](https://crates.io/crates/quote)&ensp;[![docs-rs]](https://docs.rs/quote)//! crate. Quasi-quoting is a solution to one piece of that &mdash; producing//! tokens to return to the compiler.//! quote = "1.0"//! # Non-macro code generators//! When using `quote` in a build.rs or main.rs and writing the output out to a//! file, consider having the code generator pass the tokens through//! [prettyplease] before writing. This way if an error occurs in the generated//! code it is convenient for a human to read and debug.//! [prettyplease]: https://github.com/dtolnay/prettypleaseGetSpanGetSpanBaseGetSpanInnerHasIteratorThereIsNoIteratorInRepetition// TrueRepInterpHasIterDoesNotHaveIterbtree_setquote_into_iterRepIteratorExt/// Extension trait providing the `quote_into_iter` method on iterators./// Pretend to be an iterator for the purposes of `quote_into_iter`./// This allows repeated calls to `quote_into_iter` to continue/// correctly returning DoesNotHaveIter.RepToTokensExt/// Extension trait providing the `quote_into_iter` method for/// non-iterable types. These types interpolate the same value in each/// iteration of the repetition.'qRepAsIteratorExt/// Extension trait providing the `quote_into_iter` method for types that/// can be referenced as an iterator./// Extension traits used by the implementation of `quote!`. These are defined/// in separate traits, rather than as a single trait due to ambiguity issues./// These traits expose a `quote_into_iter` method which should allow calling/// whichever impl happens to be applicable. Calling that method repeatedly on/// the returned value should be idempotent.// Helper type used within interpolations to allow for repeated binding names.// Implements the relevant traits, and exports a dummy `next()` method.// This method is intended to look like `Iterator::next`, and is called when// a name is bound multiple times, as the previous binding will shadow the// original `Iterator` object. This allows us to avoid advancing the// iterator multiple times per iteration.__into_spanpush_group_spannedparse_spannedrespan_token_tree// Token tree with every span replaced by the given one.push_ident_spannedpush_lifetimepush_lifetime_spannedpush_add_spannedpush_add_eq_spannedpush_and_spannedpush_and_and_spannedpush_and_eq_spannedpush_at_spannedpush_bang_spannedpush_caret_spannedpush_caret_eq_spannedpush_colon_spannedpush_colon2_spannedpush_comma_spannedpush_div_spannedpush_div_eq_spannedpush_dot_spannedpush_dot2_spannedpush_dot3_spannedpush_dot_dot_eq_spannedpush_eq_spannedpush_eq_eq_spannedpush_ge_spannedpush_gt_spannedpush_le_spannedpush_lt_spannedpush_mul_eq_spannedpush_ne_spannedpush_or_spannedpush_or_eq_spannedpush_or_or_spannedpush_pound_spannedpush_question_spannedpush_rarrow_spannedpush_larrow_spannedpush_rem_spannedpush_rem_eq_spannedpush_fat_arrow_spannedpush_semi_spannedpush_shl_spannedpush_shl_eq_spannedpush_shr_spannedpush_shr_eq_spannedpush_star_spannedpush_sub_spannedpush_sub_eq_spannedpush_underscorepush_underscore_spannedmk_ident// Helper method for constructing identifiers from the `format_ident!` macro,// handling `r#` prefixes.ident_maybe_rawIdentFragmentAdapter// Adapts from `IdentFragment` to `fmt::Display` for use by the `format_ident!`// macro, and exposes span information from these fragments.// This struct also has forwarding implementations of the formatting traits// `Octal`, `LowerHex`, `UpperHex`, and `Binary` to allow for their use within// `format_ident!`.// False__span// Not public API other than via the syn crate. Use syn::spanned::Spanned.join_spans/// Types that can be interpolated inside a `quote!` invocation.has_8/// Target supports 8-bit atomicshas_16/// Target supports 16-bit atomicshas_32/// Target supports 32-bit atomicshas_64/// Target supports 64-bit atomicshas_ptr/// Target supports word-width atomicsAtomics/// Collection of flags indicating whether the target processor supports atomic/// instructions for a certain width.//! Target detection//! This build script translates the target for which `radium` is being compiled//! into a set of directives that the crate can use to control which atomic//! symbols it attempts to name.//! The compiler maintains its store of target information here://! <https://github.com/rust-lang/rust/tree/be28b6235e64e0f662b96b710bf3af9de169215c/compiler/rustc_target/src/spec>//! That module is not easily extracted into something that can be loaded here,//! so we are replicating it through string matching on the target name until//! we are able to uniquely identify targets through `cfg` checks.//! Use `rustc --print target-list` to enumerate the full list of targets//! available, and `rustc --print cfg` (optionally with `-Z unstable-options`)//! to see what `cfg` values are produced for a target.//! The missing `cfg` checks required for conditional compilation, rather than a//! build script, are://! - [`accessible`](https://github.com/rust-lang/rust/issues/64797)//! - [`target_feature`](https://github.com/rust-lang/rust/issues/69098)//! - [`target_has_atomic`](https://github.com/rust-lang/rust/issues/32976)//! Once any of these becomes usable on the stable series, we can switch to a//! set of `cfg` checks instead of a build script./// Creates a new value of this type./// If the underlying value is atomic, calls [`fence`] with the given/// [`Ordering`]. Otherwise, does nothing./// [`Ordering`]: core::sync::atomic::Ordering/// [`fence`]: core::sync::atomic::fence/// Returns a mutable reference to the underlying value./// This is safe because the mutable reference to `self` guarantees that no/// other references exist to this value./// Consumes the wrapper and returns the contained value./// This is safe as passing by value ensures no other references exist./// Load a value from this object./// Ordering values are ignored by non-atomic types./// See also: [`AtomicUsize::load`]./// [`AtomicUsize::load`]: core::sync::atomic::AtomicUsize::load/// Store a value in this object./// Ordering arguments are ignored by non-atomic types./// See also: [`AtomicUsize::store`]./// [`AtomicUsize::store`]: core::sync::atomic::AtomicUsize::store/// Swap with the value stored in this object./// See also: [`AtomicUsize::swap`]./// [`AtomicUsize::swap`]: core::sync::atomic::AtomicUsize::swap"Use `compare_exchange` or `compare_exchange_weak` instead"/// Stores a value into this object if the currently-stored value is the/// same as the `current` value./// The return value is always the previously-stored value. If it is equal to/// `current`, then the value was updated with `new`./// See also: [`AtomicUsize::compare_and_swap`]./// [`AtomicUsize::compare_and_swap`]: core::sync::atomic::AtomicUsize::compare_and_swap/// The return value is a `Result` indicating whether the new value was/// written, and containing the previously-stored value. On success, this/// value is guaranteed to be equal to `current`./// See also: [`AtomicUsize::compare_exchange`]./// [`AtomicUsize::compare_exchange`]: core::sync::atomic::AtomicUsize::compare_exchange/// code on some platforms. The return value is a `Result` indicating/// whether the new value was written, and containing the previously-stored/// See also: [`AtomicUsize::compare_exchange_weak`]./// [`AtomicUsize::compare_exchange_weak`]: core::sync::atomic::AtomicUsize::compare_exchange_weak/// Performs a bitwise "and" on the currently-stored value and the argument/// `value`, and stores the result in `self`./// Returns the previously-stored value./// See also: [`AtomicUsize::fetch_and`]./// [`AtomicUsize::fetch_and`]: core::sync::atomic::AtomicUsize::fetch_and/// Performs a bitwise "nand" on the currently-stored value and the argument/// See also: [`AtomicUsize::fetch_nand`]./// [`AtomicUsize::fetch_nand`]: core::sync::atomic::AtomicUsize::fetch_nand/// Performs a bitwise "or" on the currently-stored value and the argument/// See also: [`AtomicUsize::fetch_or`]./// [`AtomicUsize::fetch_or`]: core::sync::atomic::AtomicUsize::fetch_or/// Performs a bitwise "xor" on the currently-stored value and the argument/// See also: [`AtomicUsize::fetch_xor`]./// [`AtomicUsize::fetch_xor`]: core::sync::atomic::AtomicUsize::fetch_xorNumericOps/// Adds `value` to the currently-stored value, wrapping on overflow, and/// stores the result in `self`./// See also: [`AtomicUsize::fetch_add`]./// [`AtomicUsize::fetch_add`]: core::sync::atomic::AtomicUsize::fetch_add/// Subtracts `value` from the currently-stored value, wrapping on/// underflow, and stores the result in `self`./// See also: [`AtomicUsize::fetch_sub`]./// [`AtomicUsize::fetch_sub`]: core::sync::atomic::AtomicUsize::fetch_sub/// Fetches the value, and applies a function to it that returns an/// optional new value./// Note: This may call the function multiple times if the value has been/// changed from 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./// Returns a `Result` of `Ok(previous_value)` if the function returned/// `Some(_)`, else `Err(previous_value)`./// See also: [`AtomicUsize::fetch_update`]./// [`AtomicUsize::fetch_update`]: core::sync::atomic::AtomicUsize::fetch_update/// A maybe-atomic shared mutable fundamental type `T`./// This trait is implemented by both the [atomic wrapper] type for `T`, and by/// [`Cell<T>`], providing a consistent interface for interacting with the two/// This trait provides methods predicated on marker traits for the underlying/// fundamental. Only types which can be viewed as sequences of bits may use the/// functions for bit-wise arithmetic, and only types which can be used as/// integers may use the functions for numeric arithmetic. Use of these methods/// on insufficient underlying types (for example, `Radium::fetch_and` on an/// atomic or cell-wrapped pointer) will cause a compiler error./// [atomic wrapper]: core::sync::atomic/// [`Cell<T>`]: core::cell::Cell/// Types supporting maybe-atomic bitwise operations./// Types implementing this trait support the [`fetch_and`], [`fetch_nand`],/// [`fetch_or`], and [`fetch_xor`] maybe-atomic operations./// [`fetch_and`]: crate::Radium::fetch_and/// [`fetch_nand`]: crate::Radium::fetch_nand/// [`fetch_or`]: crate::Radium::fetch_or/// [`fetch_xor`]: crate::Radium::fetch_xor/// `bool` and all integer fundamental types implement this./// # use core::sync::atomic::*;/// # use radium::Radium;/// let num: AtomicUsize = AtomicUsize::new(0);/// Radium::fetch_or(&num, 2, Ordering::Relaxed);/// Pointers do not. This will cause a compiler error./// # use core::ptr;/// let ptr: AtomicPtr<usize> = Default::default();/// Radium::fetch_or(&ptr, ptr::null_mut(), Ordering::Relaxed);/// Types supporting maybe-atomic arithmetic operations./// Types implementing this trait support the [`fetch_add`] and/// [`fetch_sub`] maybe-atomic operations./// [`fetch_add`]: crate::Radium::fetch_add/// [`fetch_sub`]: crate::Radium::fetch_sub/// The integer types, such as `usize` and `i32`, implement this trait./// let num: AtomicUsize = AtomicUsize::new(2);/// Radium::fetch_add(&num, 2, Ordering::Relaxed);/// `bool` and pointers do not. This will cause a compiler error./// let bit: AtomicBool = AtomicBool::new(false);/// Radium::fetch_add(&bit, true, Ordering::Relaxed);/// Marker traits used by [`Radium`].// Emit the universal `Radium` trait function bodies for atomic types.// Emit the `Radium` trait function bodies for bit-wise types.// Emit the `Radium` trait function bodies for integral types.// Emit the universal `Radium` trait function bodies for `Cell<_>`.radium_intr" # use std::{ptr, sync::atomic::*, cell::*};"r" # use radium::*;"r" let atom = AtomicBool::new(false);"r" Radium::fetch_add(&atom, true, Ordering::Relaxed);"r" Radium::fetch_sub(&atom, true, Ordering::Relaxed);"/// # use std::{ptr, sync::atomic::*, cell::*};/// # use radium::*;/// let cell = Cell::<bool>::new(false);/// Radium::fetch_add(&cell, true, Ordering::Relaxed);/// Radium::fetch_sub(&cell, true, Ordering::Relaxed);r" let atom = AtomicPtr::<u8>::new(ptr::null_mut());"r" Radium::fetch_and(&atom, ptr::null_mut(), Ordering::Relaxed);"r" Radium::fetch_nand(&atom, ptr::null_mut(), Ordering::Relaxed);"r" Radium::fetch_or(&atom, ptr::null_mut(), Ordering::Relaxed);"r" Radium::fetch_xor(&atom, ptr::null_mut(), Ordering::Relaxed);"r" Radium::fetch_add(&atom, ptr::null_mut(), Ordering::Relaxed);"r" Radium::fetch_sub(&atom, ptr::null_mut(), Ordering::Relaxed);"/// let cell = Cell::<*mut u8>::new(ptr::null_mut());/// Radium::fetch_and(&cell, ptr::null_mut(), Ordering::Relaxed);/// Radium::fetch_nand(&cell, ptr::null_mut(), Ordering::Relaxed);/// Radium::fetch_or(&cell, ptr::null_mut(), Ordering::Relaxed);/// Radium::fetch_xor(&cell, ptr::null_mut(), Ordering::Relaxed);/// Radium::fetch_add(&cell, ptr::null_mut(), Ordering::Relaxed);/// Radium::fetch_sub(&cell, ptr::null_mut(), Ordering::Relaxed);absent_traitspresent_traitsalways_cellalways_aliasmaybe_atom//! `radium` provides a series of helpers for a uniform API over both atomic//! types like [`AtomicUsize`], and non-atomic types like [`Cell<T>`].//! This crate is `#![no_std]`-compatible, and uses no non-core types.//! For details, see the documentation for [`Radium`].//! The `types` module provides type names that are atomic where the target//! supports it, and fall back to `Cell` when the target does not.//! The `if_atomic!` macro provides a means of conditional compilation based on//! the presence of atomic instructions. It is a substitute for the//! `cfg(target_has_atomic)` or `cfg(accessible)` attribute tests, which are not//! yet stabilized.//! ---//! **@kneecaw** - <https://twitter.com/kneecaw/status/1132695060812849154>//! > Feelin' lazy: Has someone already written a helper trait abstracting//! > operations over `AtomicUsize` and `Cell<usize>` for generic code which may//! > not care about atomicity?//! **@ManishEarth** - <https://twitter.com/ManishEarth/status/1132706585300496384>//! > no but call the crate radium//! > (since people didn't care that it was radioactive and used it in everything)//! [`AtomicUsize`]: core::sync::atomic::AtomicUsize//! [`Cell<T>`]: core::cell::Cell/// Conditional compilation based on the presence of atomic instructions./// This macro allows you to write `if`/`else` clauses, evaluated at/// compile-time, that test the presence of atomic instructions and preserve or/// destroy their guarded code accordingly./// The `if atomic(WIDTH)` test preserves the contents of its block when the/// target architecture has atomic instructions for the requested `WIDTH`, and/// removes them from the syntax tree when the target does not. If an `else`/// clause is provided, the contents of the `else` block are used as a/// substitute when the `if` is destroyed./// This macro can be used in any position. When it is used in item or statement/// position, it can contain multiple `if` clauses, and each will be evaluated/// in turn. Expression and type positions can only accept exactly one code/// span, and so may only have exactly one `if`/`else` clause. An `else` clause/// is required here so that the macro will always expand to something; an empty/// expansion is a parse error./// # Macro Syntax/// The macro contents `if atomic() {} else {}` are part of the macro/// invocation. Only the contents of the two blocks are actual Rust code./// The acceptable arguments to `atomic()` are:/// - `8`/// - `16`/// - `32`/// - `64`/// - `ptr`/// - `bool`: alias for `8`/// - `size`: alias for `ptr`/// In addition, the `atomic()` test can be inverted, as `!atomic()`, to reverse/// the preserve/destroy behavior of the `if` and `else` blocks./// This demonstrates the use of `if_atomic!` to produce multiple statements,/// and then to produce a single type-name./// radium::if_atomic! {///   if atomic(size) { use core::sync::atomic::AtomicUsize; }///   if !atomic(size) { use core::cell::Cell; }/// struct RadiumRc<T: ?Sized> {///   strong: radium::if_atomic! {///     if atomic(ptr) { AtomicUsize }///     else { Cell<usize> }///   },///   weak: radium::types::RadiumUsize,///   data: T,RadiumBool/// Best-effort atomic `bool` type.RadiumI8/// Best-effort atomic `i8` type.RadiumU8/// Best-effort atomic `u8` type.RadiumI16/// Best-effort atomic `i16` type.RadiumU16/// Best-effort atomic `u16` type.RadiumI32/// Best-effort atomic `i32` type.RadiumU32/// Best-effort atomic `u32` type.RadiumI64/// Best-effort atomic `i64` type.RadiumU64/// Best-effort atomic `u64` type.RadiumIsize/// Best-effort atomic `isize` type.RadiumUsize/// Best-effort atomic `usize` type.RadiumPtr/// Best-effort atomic pointer type.//! Best-effort atomic types//! This module exports `RadiumType` aliases that map to the `AtomicType` on//! targets that have it, or `Cell<type>` on targets that do not. This alias can//! be used as a consistent name for crates that need portable names for//! non-portable types.BlockRngCoreIsaacRngtry_fill_bytesfrom_seedfrom_rngnew_from_u64Isaac64RngChaChaRngget_word_posset_word_posset_streamHc128RngEntropyRngJitterRngTimerErrornew_with_timerset_roundstimer_statsReadRngRsdrReseedingRng// Copyright 2018 Developers of the Rand project.//! Deprecated re-exports (we can't add deprecation warnings otherwise)p_int/// Probability of success, relative to the maximal integer.Bernoulli/// The Bernoulli distribution./// This is a special case of the Binomial distribution where `n = 1`./// use rand::distributions::{Bernoulli, Distribution};/// let d = Bernoulli::new(0.3);/// let v = d.sample(&mut rand::thread_rng());/// println!("{} is from a Bernoulli distribution", v);/// This `Bernoulli` distribution uses 64 bits from the RNG (a `u64`),/// so only probabilities that are multiples of 2<sup>-64</sup> can beALWAYS_TRUE// To sample from the Bernoulli distribution we use a method that compares a// random `u64` value `v < (p * 2^64)`.// If `p == 1.0`, the integer `v` to compare against can not represented as a// `u64`. We manually set it to `u64::MAX` instead (2^64 - 1 instead of 2^64).// Note that  value of `p < 1.0` can never result in `u64::MAX`, because an// `f64` only has 53 bits of precision, and the next largest value of `p` will// result in `2^64 - 2048`.// Also there is a 100% theoretical concern: if someone consistenly wants to// generate `true` using the Bernoulli distribution (i.e. by using a probability// of `1.0`), just using `u64::MAX` is not enough. On average it would return// false once every 2^64 iterations. Some people apparently care about this// That is why we special-case `u64::MAX` to always return `true`, without using// the RNG, and pay the performance price for all uses that *are* reasonable.// Luckily, if `new()` and `sample` are close, the compiler can optimize out the// extra check.// This is just `2.0.powi(64)`, but written this way because it is not available// in `no_std` mode./// Construct a new `Bernoulli` with the given probability of success `p`./// If `p < 0` or `p > 1`./// For `p = 1.0`, the resulting distribution will always generate true./// For `p = 0.0`, the resulting distribution will always generate false./// This method is accurate for any input `p` in the range `[0, 1]` which is/// a multiple of 2<sup>-64</sup>. (Note that not all multiples of/// 2<sup>-64</sup> in `[0, 1]` can be represented as a `f64`.)/// Construct a new `Bernoulli` with the probability of success of/// `numerator`-in-`denominator`. I.e. `new_ratio(2, 3)` will return/// a `Bernoulli` with a 2-in-3 chance, or about 67%, of returning `true`./// If `numerator == denominator` then the returned `Bernoulli` will always/// return `true`. If `numerator == 0` it will always return `false`./// If `denominator == 0` or `numerator > denominator`.test_trivialtest_average//! The Bernoulli distribution.Cauchylog_gamma/// Number of trials./// Probability of success.Binomial/// The binomial distribution `Binomial(n, p)`./// This distribution has density function:/// `f(k) = n!/(k! (n-k)!) p^k (1-p)^(n-k)` for `k >= 0`./// use rand::distributions::{Binomial, Distribution};/// let bin = Binomial::new(20, 0.3);/// let v = bin.sample(&mut rand::thread_rng());/// println!("{} is from a binomial distribution", v);/// Construct a new `Binomial` with the given shape parameters `n` (number/// of trials) and `p` (probability of success)./// Panics if `p < 0` or `p > 1`.test_binomial_mean_and_variancetest_binomial_end_pointstest_binomial_invalid_lambda_neg// Copyright 2016-2017 The Rust Project Developers.//! The binomial distribution.median/// The Cauchy distribution `Cauchy(median, scale)`./// This distribution has a density function:/// `f(x) = 1 / (pi * scale * (1 + ((x - median) / scale)^2))`/// use rand::distributions::{Cauchy, Distribution};/// let cau = Cauchy::new(2.0, 5.0);/// let v = cau.sample(&mut rand::thread_rng());/// println!("{} is from a Cauchy(2, 5) distribution", v);/// Construct a new `Cauchy` with the given shape parameters/// `median` the peak location and `scale` the scale factor./// Panics if `scale <= 0`.test_cauchy_mediantest_cauchy_meantest_cauchy_invalid_scale_zerotest_cauchy_invalid_scale_neg//! The Cauchy distribution./// Concentration parameters (alpha)Dirichlet/// The dirichelet distribution `Dirichlet(alpha)`./// The Dirichlet distribution is a family of continuous multivariate/// probability distributions parameterized by a vector alpha of positive reals./// It is a multivariate generalization of the beta distribution./// use rand::prelude::*;/// use rand::distributions::Dirichlet;/// let dirichlet = Dirichlet::new(vec![1.0, 2.0, 3.0]);/// let samples = dirichlet.sample(&mut rand::thread_rng());/// println!("{:?} is from a Dirichlet([1.0, 2.0, 3.0]) distribution", samples);/// Construct a new `Dirichlet` with the given alpha parameter `alpha`./// - if `alpha.len() < 2`new_with_param/// Construct a new `Dirichlet` with the given shape parameter `alpha` and `size`./// - if `alpha <= 0.0`/// - if `size < 2`test_dirichlettest_dirichlet_with_paramtest_dirichlet_invalid_lengthtest_dirichlet_invalid_alpha// Copyright 2013 The Rust Project Developers.//! The dirichlet distribution.ziggurat_tableszigguratExp1/// Samples floating-point numbers according to the exponential distribution,/// with rate parameter `λ = 1`. This is equivalent to `Exp::new(1.0)` or/// sampling with `-rng.gen::<f64>().ln()`, but faster./// See `Exp` for the general exponential distribution./// Implemented via the ZIGNOR variant[^1] of the Ziggurat method. The exact/// description in the paper was adjusted to use tables for the exponential/// distribution rather than normal./// [^1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to///       Generate Normal Random Samples*](///       https://www.doornik.com/research/ziggurat.pdf).///       Nuffield College, Oxford/// use rand::distributions::Exp1;/// let val: f64 = SmallRng::from_entropy().sample(Exp1);/// println!("{}", val);// This could be done via `-rng.gen::<f64>().ln()` but that is slower.lambda_inverse/// `lambda` stored as `1/lambda`, since this is what we scale by.Exp/// The exponential distribution `Exp(lambda)`./// This distribution has density function: `f(x) = lambda * exp(-lambda * x)`/// for `x > 0`./// Note that [`Exp1`][crate::distributions::Exp1] is an optimised implementation for `lambda = 1`./// use rand::distributions::{Exp, Distribution};/// let exp = Exp::new(2.0);/// let v = exp.sample(&mut rand::thread_rng());/// println!("{} is from a Exp(2) distribution", v);/// Construct a new `Exp` with the given shape parameter/// `lambda`. Panics if `lambda <= 0`.test_exp_invalid_lambda_zerotest_exp_invalid_lambda_neg//! The exponential distribution.FloatSIMDUtilsOpenClosed01/// A distribution to sample floating point numbers uniformly in the half-open/// interval `(0, 1]`, i.e. including 1 but not 0./// All values that can be generated are of the form `n * ε/2`. For `f32`/// the 23 most significant random bits of a `u32` are used and for `f64` the/// 53 most significant bits of a `u64` are used. The conversion uses the/// multiplicative method./// See also: [`Standard`] which samples from `[0, 1)`, [`Open01`]/// which samples from `(0, 1)` and [`Uniform`] which samples from arbitrary/// ranges./// use rand::{thread_rng, Rng};/// use rand::distributions::OpenClosed01;/// let val: f32 = thread_rng().sample(OpenClosed01);/// println!("f32 from (0, 1): {}", val);/// [`Standard`]: crate::distributions::Standard/// [`Open01`]: crate::distributions::Open01/// [`Uniform`]: crate::distributions::uniform::UniformOpen01/// A distribution to sample floating point numbers uniformly in the open/// interval `(0, 1)`, i.e. not including either endpoint./// All values that can be generated are of the form `n * ε + ε/2`. For `f32`/// the 22 most significant random bits of an `u32` are used, for `f64` 52 from/// an `u64`. The conversion uses a transmute-based method./// See also: [`Standard`] which samples from `[0, 1)`, [`OpenClosed01`]/// which samples from `(0, 1]` and [`Uniform`] which samples from arbitrary/// use rand::distributions::Open01;/// let val: f32 = thread_rng().sample(Open01);/// [`OpenClosed01`]: crate::distributions::OpenClosed01into_float_with_exponent/// Helper method to combine the fraction and a contant exponent into a/// float./// Only the least significant bits of `self` may be set, 23 for `f32` and/// 52 for `f64`./// The resulting value will fall in a range that depends on the exponent./// As an example the range with exponent 0 will be/// [2<sup>0</sup>..2<sup>1</sup>), which is [1..2).IntoFloatEPSILON32EPSILON64f32_edge_casestest_f64f64_edge_cases//! Basic floating-point number distributionsGammaReprChiSquaredRepr/// The Gamma distribution `Gamma(shape, scale)` distribution./// The density function of this distribution is/// f(x) =  x^(k - 1) * exp(-x / θ) / (Γ(k) * θ^k)/// where `Γ` is the Gamma function, `k` is the shape and `θ` is the/// scale and both `k` and `θ` are strictly positive./// The algorithm used is that described by Marsaglia & Tsang 2000[^1],/// falling back to directly sampling from an Exponential for `shape/// == 1`, and using the boosting technique described in that paper for/// `shape < 1`./// use rand::distributions::{Distribution, Gamma};/// let gamma = Gamma::new(2.0, 5.0);/// let v = gamma.sample(&mut rand::thread_rng());/// println!("{} is from a Gamma(2, 5) distribution", v);/// [^1]: George Marsaglia and Wai Wan Tsang. 2000. "A Simple Method for///       Generating Gamma Variables" *ACM Trans. Math. Softw.* 26, 3///       (September 2000), 363-372.///       DOI:[10.1145/358407.358414](https://doi.acm.org/10.1145/358407.358414)GammaLargeShapeGammaSmallShapeinv_shapelarge_shape/// Gamma distribution where the shape parameter is less than 1./// Note, samples from this require a compulsory floating-point `pow`/// call, which makes it significantly slower than sampling from a/// gamma distribution where the shape parameter is greater than or/// equal to 1./// See `Gamma` for sampling from a Gamma distribution with general/// shape parameters./// Gamma distribution where the shape parameter is larger than 1./// Construct an object representing the `Gamma(shape, scale)`/// distribution./// Panics if `shape <= 0` or `scale <= 0`.ChiSquared/// The chi-squared distribution `χ²(k)`, where `k` is the degrees of/// freedom./// For `k > 0` integral, this distribution is the sum of the squares/// of `k` independent standard normal random variables. For other/// `k`, this uses the equivalent characterisation/// `χ²(k) = Gamma(k/2, 2)`./// use rand::distributions::{ChiSquared, Distribution};/// let chi = ChiSquared::new(11.0);/// let v = chi.sample(&mut rand::thread_rng());/// println!("{} is from a χ²(11) distribution", v)DoFExactlyOne// k == 1, Gamma(alpha, ..) is particularly slow for alpha < 1,// e.g. when alpha = 1/2 as it would be for this case, so special-// casing and using the definition of N(0,1)^2 is faster.DoFAnythingElse/// Create a new chi-squared distribution with degrees-of-freedom/// `k`. Panics if `k < 0`.dof_ratio// denom_dof / numer_dof so that this can just be a straight// multiplication, rather than a division.FisherF/// The Fisher F distribution `F(m, n)`./// This distribution is equivalent to the ratio of two normalised/// chi-squared distributions, that is, `F(m,n) = (χ²(m)/m) //// (χ²(n)/n)`./// use rand::distributions::{FisherF, Distribution};/// let f = FisherF::new(2.0, 32.0);/// let v = f.sample(&mut rand::thread_rng());/// println!("{} is from an F(2, 32) distribution", v)/// Create a new `FisherF` distribution, with the given/// parameter. Panics if either `m` or `n` are not positive.chidofStudentT/// The Student t distribution, `t(nu)`, where `nu` is the degrees of/// use rand::distributions::{StudentT, Distribution};/// let t = StudentT::new(11.0);/// let v = t.sample(&mut rand::thread_rng());/// println!("{} is from a t(11) distribution", v)/// Create a new Student t distribution with `n` degrees of/// freedom. Panics if `n <= 0`.gamma_agamma_bBeta/// The Beta distribution with shape parameters `alpha` and `beta`./// use rand::distributions::{Distribution, Beta};/// let beta = Beta::new(2.0, 5.0);/// let v = beta.sample(&mut rand::thread_rng());/// println!("{} is from a Beta(2, 5) distribution", v);/// Construct an object representing the `Beta(alpha, beta)`test_chi_squared_onetest_chi_squared_smalltest_chi_squared_largetest_chi_squared_invalid_doftest_ftest_ttest_betatest_beta_invalid_dof//! The Gamma and derived distributions.// These two helpers could be made public, but saving the// match-on-Gamma-enum branch from using them directly (e.g. if one// knows that the shape is always > 1) doesn't appear to be much// faster.impl_int_from_uinttest_integers//! The implementations of the `Standard` distribution for integer types.bernoulliweightedWeightedIndexWeightedErrorunit_sphereUnitSphereSurfaceunit_circleUnitCircleLogNormalexponentialparetoParetopoissonPoissoncauchydirichlettriangularTriangularweibullWeibull/// Generate a random value of `T`, using `rng` as the source of randomness.sample_iterDistIter/// Create an iterator that generates random values of `T`, using `rng` as/// the source of randomness./// use rand::thread_rng;/// use rand::distributions::{Distribution, Alphanumeric, Uniform, Standard};/// let mut rng = thread_rng();/// // Vec of 16 x f32:/// let v: Vec<f32> = Standard.sample_iter(&mut rng).take(16).collect();/// // String:/// let s: String = Alphanumeric.sample_iter(&mut rng).take(7).collect();/// // Dice-rolling:/// let die_range = Uniform::new_inclusive(1, 6);/// let mut roll_die = die_range.sample_iter(&mut rng);/// while roll_die.next().unwrap() != 6 {///     println!("Not a 6; rolling again!");/// Types (distributions) that can be used to create a random instance of `T`./// It is possible to sample from a distribution through both the/// `Distribution` and [`Rng`] traits, via `distr.sample(&mut rng)` and/// `rng.sample(distr)`. They also both offer the [`sample_iter`] method, which/// produces an iterator that samples from the distribution./// All implementations are expected to be immutable; this has the significant/// advantage of not needing to consider thread safety, and for most/// distributions efficient state-less sampling algorithms are available./// [`sample_iter`]: Distribution::method.sample_iterdistr/// An iterator that generates random values of `T` with distribution `D`,/// using `R` as the source of randomness./// This `struct` is created by the [`sample_iter`] method on [`Distribution`]./// [`sample_iter`]: Distribution::sample_iter/// A generic random value distribution, implemented for many primitive types./// Usually generates values with a numerically uniform distribution, and with a/// range appropriate to the type./// ## Built-in Implementations/// Assuming the provided `Rng` is well-behaved, these implementations/// generate values with the following ranges and distributions:/// * Integers (`i32`, `u32`, `isize`, `usize`, etc.): Uniformly distributed///   over all values of the type./// * `char`: Uniformly distributed over all Unicode scalar values, i.e. all///   code points in the range `0...0x10_FFFF`, except for the range///   `0xD800...0xDFFF` (the surrogate code points). This includes///   unassigned/reserved code points./// * `bool`: Generates `false` or `true`, each with probability 0.5./// * Floating point types (`f32` and `f64`): Uniformly distributed in the///   half-open range `[0, 1)`. See notes below./// * Wrapping integers (`Wrapping<T>`), besides the type identical to their///   normal integer variants./// The following aggregate types also implement the distribution `Standard` as/// long as their component types implement it:/// * Tuples and arrays: Each element of the tuple or array is generated///   independently, using the `Standard` distribution recursively./// * `Option<T>` where `Standard` is implemented for `T`: Returns `None` with///   probability 0.5; otherwise generates a random `x: T` and returns `Some(x)`./// use rand::distributions::Standard;/// let val: f32 = SmallRng::from_entropy().sample(Standard);/// println!("f32 from [0, 1): {}", val);/// # Floating point implementation/// The floating point implementations for `Standard` generate a random value in/// the half-open interval `[0, 1)`, i.e. including 0 but not 1./// multiplicative method: `(rng.gen::<$uty>() >> N) as $ty * (ε/2)`./// See also: [`Open01`] which samples from `(0, 1)`, [`OpenClosed01`] which/// samples from `(0, 1]` and `Rng::gen_range(0, 1)` which also samples from/// `[0, 1)`. Note that `Open01` and `gen_range` (which uses [`Uniform`]) use/// transmute-based methods which yield 1 bit less precision but may perform/// faster on some architectures (on modern Intel CPUs all methods have/// approximately equal performance)./// [`Uniform`]: uniform::Uniform/// The numerical weight of this item/// The actual item which is being weightedWeighted/// A value with a particular weight for use with `WeightedChoice`.weight_rangeWeightedChoice/// A distribution that selects from a finite collection of weighted items./// Deprecated: use [`WeightedIndex`] instead./// [`WeightedIndex`]: WeightedIndex/// Create a new `WeightedChoice`./// - `items` is empty/// - the total weight is 0/// - the total weight is larger than a `u32` can contain.test_weighted_choicetest_weighted_clone_initializationtest_weighted_clone_change_weighttest_weighted_clone_change_itemtest_weighted_choice_no_itemstest_weighted_choice_zero_weighttest_weighted_choice_weight_overflowstest_distributions_iter// Copyright 2013-2017 The Rust Project Developers.//! Generating random samples from probability distributions.//! This module is the home of the [`Distribution`] trait and several of its//! implementations. It is the workhorse behind some of the convenient//! functionality of the [`Rng`] trait, including [`gen`], [`gen_range`] and//! of course [`sample`].//! Abstractly, a [probability distribution] describes the probability of//! occurance of each value in its sample space.//! More concretely, an implementation of `Distribution<T>` for type `X` is an//! algorithm for choosing values from the sample space (a subset of `T`)//! according to the distribution `X` represents, using an external source of//! randomness (an RNG supplied to the `sample` function).//! A type `X` may implement `Distribution<T>` for multiple types `T`.//! Any type implementing [`Distribution`] is stateless (i.e. immutable),//! but it may have internal parameters set at construction time (for example,//! [`Uniform`] allows specification of its sample space as a range within `T`).//! # The `Standard` distribution//! The [`Standard`] distribution is important to mention. This is the//! distribution used by [`Rng::gen()`] and represents the "default" way to//! produce a random value for many different types, including most primitive//! types, tuples, arrays, and a few derived types. See the documentation of//! [`Standard`] for more details.//! Implementing `Distribution<T>` for [`Standard`] for user types `T` makes it//! possible to generate type `T` with [`Rng::gen()`], and by extension also//! with the [`random()`] function.//! # Distribution to sample from a `Uniform` range//! The [`Uniform`] distribution is more flexible than [`Standard`], but also//! more specialised: it supports fewer target types, but allows the sample//! space to be specified as an arbitrary range within its target type `T`.//! Both [`Standard`] and [`Uniform`] are in some sense uniform distributions.//! Values may be sampled from this distribution using [`Rng::gen_range`] or//! by creating a distribution object with [`Uniform::new`],//! [`Uniform::new_inclusive`] or `From<Range>`. When the range limits are not//! known at compile time it is typically faster to reuse an existing//! distribution object than to call [`Rng::gen_range`].//! User types `T` may also implement `Distribution<T>` for [`Uniform`],//! although this is less straightforward than for [`Standard`] (see the//! documentation in the [`uniform`] module. Doing so enables generation of//! values of type `T` with  [`Rng::gen_range`].//! # Other distributions//! There are surprisingly many ways to uniformly generate random floats. A//! range between 0 and 1 is standard, but the exact bounds (open vs closed)//! and accuracy differ. In addition to the [`Standard`] distribution Rand offers//! [`Open01`] and [`OpenClosed01`]. See "Floating point implementation" section of//! [`Standard`] documentation for more details.//! [`Alphanumeric`] is a simple distribution to sample random letters and//! numbers of the `char` type; in contrast [`Standard`] may sample any valid//! `char`.//! [`WeightedIndex`] can be used to do weighted sampling from a set of items,//! such as from an array.//! # Non-uniform probability distributions//! Rand currently provides the following probability distributions://! - Related to real-valued quantities that grow linearly//!   (e.g. errors, offsets)://!   - [`Normal`] distribution, and [`StandardNormal`] as a primitive//!   - [`Cauchy`] distribution//! - Related to Bernoulli trials (yes/no events, with a given probability)://!   - [`Binomial`] distribution//!   - [`Bernoulli`] distribution, similar to [`Rng::gen_bool`].//! - Related to positive real-valued quantities that grow exponentially//!   (e.g. prices, incomes, populations)://!   - [`LogNormal`] distribution//! - Related to the occurrence of independent events at a given rate://!   - [`Pareto`] distribution//!   - [`Poisson`] distribution//!   - [`Exp`]onential distribution, and [`Exp1`] as a primitive//!   - [`Weibull`] distribution//! - Gamma and derived distributions://!   - [`Gamma`] distribution//!   - [`ChiSquared`] distribution//!   - [`StudentT`] distribution//!   - [`FisherF`] distribution//! - Triangular distribution://!   - [`Beta`] distribution//!   - [`Triangular`] distribution//! - Multivariate probability distributions//!   - [`Dirichlet`] distribution//!   - [`UnitSphereSurface`] distribution//!   - [`UnitCircle`] distribution//! Sampling from a distribution://! use rand::{thread_rng, Rng};//! use rand::distributions::Exp;//! let exp = Exp::new(2.0);//! let v = thread_rng().sample(exp);//! println!("{} is from an Exp(2) distribution", v);//! Implementing the [`Standard`] distribution for a user type://! # #![allow(dead_code)]//! use rand::Rng;//! use rand::distributions::{Distribution, Standard};//! struct MyF32 {//!     x: f32,//! impl Distribution<MyF32> for Standard {//!     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> MyF32 {//!         MyF32 { x: rng.gen() }//! [probability distribution]: https://en.wikipedia.org/wiki/Probability_distribution//! [`gen_range`]: Rng::gen_range//! [`gen`]: Rng::gen//! [`sample`]: Rng::sample//! [`new_inclusive`]: Uniform::new_inclusive//! [`Alphanumeric`]: distributions::Alphanumeric//! [`Bernoulli`]: distributions::Bernoulli//! [`Beta`]: distributions::Beta//! [`Binomial`]: distributions::Binomial//! [`Cauchy`]: distributions::Cauchy//! [`ChiSquared`]: distributions::ChiSquared//! [`Dirichlet`]: distributions::Dirichlet//! [`Exp`]: distributions::Exp//! [`Exp1`]: distributions::Exp1//! [`FisherF`]: distributions::FisherF//! [`Gamma`]: distributions::Gamma//! [`LogNormal`]: distributions::LogNormal//! [`Normal`]: distributions::Normal//! [`Open01`]: distributions::Open01//! [`OpenClosed01`]: distributions::OpenClosed01//! [`Pareto`]: distributions::Pareto//! [`Poisson`]: distributions::Poisson//! [`Standard`]: distributions::Standard//! [`StandardNormal`]: distributions::StandardNormal//! [`StudentT`]: distributions::StudentT//! [`Triangular`]: distributions::Triangular//! [`Uniform`]: distributions::Uniform//! [`Uniform::new`]: distributions::Uniform::new//! [`Uniform::new_inclusive`]: distributions::Uniform::new_inclusive//! [`UnitSphereSurface`]: distributions::UnitSphereSurface//! [`UnitCircle`]: distributions::UnitCircle//! [`Weibull`]: distributions::Weibull//! [`WeightedIndex`]: distributions::WeightedIndex/// Samples floating-point numbers according to the normal distribution/// `N(0, 1)` (a.k.a. a standard normal, or Gaussian). This is equivalent to/// `Normal::new(0.0, 1.0)` but faster./// See `Normal` for the general normal distribution./// Implemented via the ZIGNOR variant[^1] of the Ziggurat method./// use rand::distributions::StandardNormal;/// let val: f64 = SmallRng::from_entropy().sample(StandardNormal);meanstd_dev/// The normal distribution `N(mean, std_dev**2)`./// This uses the ZIGNOR variant of the Ziggurat method, see [`StandardNormal`]/// Note that [`StandardNormal`] is an optimised implementation for mean 0, and/// standard deviation 1./// use rand::distributions::{Normal, Distribution};/// // mean 2, standard deviation 3/// let normal = Normal::new(2.0, 3.0);/// let v = normal.sample(&mut rand::thread_rng());/// println!("{} is from a N(2, 9) distribution", v)/// [`StandardNormal`]: crate::distributions::StandardNormal/// Construct a new `Normal` distribution with the given mean and/// standard deviation./// Panics if `std_dev < 0`./// The log-normal distribution `ln N(mean, std_dev**2)`./// If `X` is log-normal distributed, then `ln(X)` is `N(mean, std_dev**2)`/// distributed./// use rand::distributions::{LogNormal, Distribution};/// let log_normal = LogNormal::new(2.0, 3.0);/// let v = log_normal.sample(&mut rand::thread_rng());/// println!("{} is from an ln N(2, 9) distribution", v)/// Construct a new `LogNormal` distribution with the given mean/// and standard deviation.test_normaltest_normal_invalid_sdtest_log_normaltest_log_normal_invalid_sd//! The normal and derived distributions./// Sample a `char`, uniformly distributed over ASCII letters and numbers:/// a-z, A-Z and 0-9./// use rand::{Rng, thread_rng};/// use rand::distributions::Alphanumeric;/// let chars: String = iter::repeat(())///         .map(|()| rng.sample(Alphanumeric))///         .take(7)///         .collect();/// println!("Random chars: {}", chars);// use variables to indicate the arity of the tuple// recursive, given at least one type parameter:// empty case:test_misctest_charstest_alphanumeric//! The implementations of the `Standard` distribution for other built-in types.// ----- Sampling distributions -----// ----- Implementations of distributions -----inv_neg_shape/// Samples floating-point numbers according to the Pareto distribution/// use rand::distributions::Pareto;/// let val: f64 = SmallRng::from_entropy().sample(Pareto::new(1., 2.));/// Construct a new Pareto distribution with given `scale` and `shape`./// In the literature, `scale` is commonly written as x<sub>m</sub> or k and/// `shape` is often written as α./// `scale` and `shape` have to be non-zero and positive.//! The Pareto distribution.lambdaexp_lambda// precalculated valueslog_lambdasqrt_2lambdamagic_val/// The Poisson distribution `Poisson(lambda)`./// `f(k) = lambda^k * exp(-lambda) / k!` for `k >= 0`./// use rand::distributions::{Poisson, Distribution};/// let poi = Poisson::new(2.0);/// let v = poi.sample(&mut rand::thread_rng());/// println!("{} is from a Poisson(2) distribution", v);/// Construct a new `Poisson` with the given shape parametertest_poisson_10test_poisson_15test_poisson_invalid_lambda_zerotest_poisson_invalid_lambda_neg//! The Poisson distribution./// The triangular distribution./// use rand::distributions::{Triangular, Distribution};/// let d = Triangular::new(0., 5., 2.5);/// println!("{} is from a triangular distribution", v);/// Construct a new `Triangular` with minimum `min`, maximum `max` and mode/// `mode`./// If `max < mode`, `mode < max` or `max == min`.test_sample//! The triangular distribution.WideningMultiplyFloatAsSIMDBoolAsSIMD/// Sample values uniformly between two bounds./// [`Uniform::new`] and [`Uniform::new_inclusive`] construct a uniform/// distribution sampling from the given range; these functions may do extra/// work up front to make sampling of multiple values faster./// When sampling from a constant range, many calculations can happen at/// compile-time and all methods should be fast; for floating-point ranges and/// the full range of integer types this should have comparable performance to/// the `Standard` distribution./// Steps are taken to avoid bias which might be present in naive/// implementations; for example `rng.gen::<u8>() % 170` samples from the range/// `[0, 169]` but is twice as likely to select numbers less than 85 than other/// values. Further, the implementations here give more weight to the high-bits/// generated by the RNG than the low bits, since with some RNGs the low-bits/// are of lower quality than the high bits./// Implementations must sample in `[low, high)` range for/// `Uniform::new(low, high)`, i.e., excluding `high`. In particular care must/// be taken to ensure that rounding never results values `< low` or `>= high`./// use rand::distributions::{Distribution, Uniform};///     let between = Uniform::from(10..10000);///     let mut rng = rand::thread_rng();///     let mut sum = 0;///     for _ in 0..1000 {///         sum += between.sample(&mut rng);///     println!("{}", sum);/// [`new`]: Uniform::new/// [`new_inclusive`]: Uniform::new_inclusive/// Create a new `Uniform` instance which samples uniformly from the half/// open range `[low, high)` (excluding `high`). Panics if `low >= high`./// Create a new `Uniform` instance which samples uniformly from the closed/// range `[low, high]` (inclusive). Panics if `low > high`./// The `UniformSampler` implementation supporting type `X`./// Helper trait for creating objects using the correct implementation of/// [`UniformSampler`] for the sampling type./// See the [module documentation] on how to implement [`Uniform`] range/// sampling for a custom type./// [module documentation]: crate::distributions::uniform/// The type sampled by this implementation./// Construct self, with inclusive lower bound and exclusive upper bound/// `[low, high)`./// Usually users should not call this directly but instead use/// `Uniform::new`, which asserts that `low < high` before calling this./// Construct self, with inclusive bounds `[low, high]`./// `Uniform::new_inclusive`, which asserts that `low <= high` before/// Sample a value./// Sample a single value uniformly from a range with inclusive lower bound/// and exclusive upper bound `[low, high)`./// `Uniform::sample_single`, which asserts that `low < high` before calling/// Via this method, implementations can provide a method optimized for/// sampling only a single value from the specified range. The default/// implementation simply calls `UniformSampler::new` then `sample` on the/// Helper trait handling actual uniform sampling./// Implementation of [`sample_single`] is optional, and is only useful when/// the implementation can be faster than `Self::new(low, high).sample(rng)`./// [`sample_single`]: UniformSampler::sample_single/// Immutably borrows from an owned value. See [`Borrow::borrow`]/// [`Borrow::borrow`]: std::borrow::Borrow::borrow/// Helper trait similar to [`Borrow`] but implemented/// only for SampleUniform and references to SampleUniform in/// order to resolve ambiguity issues./// [`Borrow`]: std::borrow::BorrowUniformInt/// The back-end implementing [`UniformSampler`] for integer types./// Unless you are implementing [`UniformSampler`] for your own type, this type/// should not be used directly, use [`Uniform`] instead./// For a closed range, the number of possible numbers we should generate is/// `range = (high - low + 1)`. It is not possible to end up with a uniform/// distribution if we map *all* the random integers that can be generated to/// this range. We have to map integers from a `zone` that is a multiple of the/// range. The rest of the integers, that cause a bias, are rejected./// The problem with `range` is that to cover the full range of the type, it has/// to store `unsigned_max + 1`, which can't be represented. But if the range/// covers the full range of the type, no modulus is needed. A range of size 0/// can't exist, so we use that to represent this special case. Wrapping/// arithmetic even makes representing `unsigned_max + 1` as 0 simple./// We don't calculate `zone` directly, but first calculate the number of/// integers to reject. To handle `unsigned_max + 1` not fitting in the type,/// we use:/// `ints_to_reject = (unsigned_max + 1) % range;`/// `ints_to_reject = (unsigned_max - range + 1) % range;`/// The smallest integer PRNGs generate is `u32`. That is why for small integer/// sizes (`i8`/`u8` and `i16`/`u16`) there is an optimization: don't pick the/// largest zone that can fit in the small type, but pick the largest zone that/// can fit in an `u32`. `ints_to_reject` is always less than half the size of/// the small integer. This means the first bit of `zone` is always 1, and so/// are all the other preceding bits of a larger integer. The easiest way to/// grow the `zone` for the larger type is to simply sign extend it./// An alternative to using a modulus is widening multiply: After a widening/// multiply by `range`, the result is in the high word. Then comparing the low/// word against `zone` makes sure our distribution is uniform.uniform_int_impl/// The back-end implementing [`UniformSampler`] for floating-point types./// Instead of generating a float in the `[0, 1)` range using [`Standard`], the/// `UniformFloat` implementation converts the output of an PRNG itself. This/// way one or two steps can be optimized out./// The floats are first converted to a value in the `[1, 2)` interval using a/// transmute-based method, and then mapped to the expected range with a/// multiply and addition. Values produced this way have what equals 22 bits of/// random digits for an `f32`, and 52 for an `f64`./// [`new`]: UniformSampler::new/// [`new_inclusive`]: UniformSampler::new_inclusiveuniform_float_implUniformDurationModeUniformDuration/// The back-end implementing [`UniformSampler`] for `Duration`./// Unless you are implementing [`UniformSampler`] for your own types, this typemax_secsmax_nanostest_uniform_bad_limits_equal_inttest_uniform_good_limits_equal_inttest_uniform_bad_limits_flipped_inttest_floatstest_float_assertionstest_durationstest_custom_uniformtest_uniform_from_std_rangetest_uniform_from_std_range_inclusive// Copyright 2017 The Rust Project Developers.//! A distribution uniformly sampling numbers within a given range.//! [`Uniform`] is the standard distribution to sample uniformly from a range;//! e.g. `Uniform::new_inclusive(1, 6)` can sample integers from 1 to 6, like a//! standard die. [`Rng::gen_range`] supports any type supported by//! [`Uniform`].//! This distribution is provided with support for several primitive types//! (all integer and floating-point types) as well as [`std::time::Duration`],//! and supports extension to user-defined types via a type-specific *back-end*//! implementation.//! The types [`UniformInt`], [`UniformFloat`] and [`UniformDuration`] are the//! back-ends supporting sampling from primitive integer and floating-point//! ranges as well as from [`std::time::Duration`]; these types do not normally//! need to be used directly (unless implementing a derived back-end).//! # Example usage//! use rand::{Rng, thread_rng};//! use rand::distributions::Uniform;//! let mut rng = thread_rng();//! let side = Uniform::new(-10.0, 10.0);//! // sample between 1 and 10 points//! for _ in 0..rng.gen_range(1, 11) {//!     // sample a point from the square with sides -10 - 10 in two dimensions//!     let (x, y) = (rng.sample(side), rng.sample(side));//!     println!("Point: {}, {}", x, y);//! # Extending `Uniform` to support a custom type//! To extend [`Uniform`] to support your own types, write a back-end which//! implements the [`UniformSampler`] trait, then implement the [`SampleUniform`]//! helper trait to "register" your back-end. See the `MyF32` example below.//! At a minimum, the back-end needs to store any parameters needed for sampling//! (e.g. the target range) and implement `new`, `new_inclusive` and `sample`.//! Those methods should include an assert to check the range is valid (i.e.//! `low < high`). The example below merely wraps another back-end.//! The `new`, `new_inclusive` and `sample_single` functions use arguments of//! type SampleBorrow<X> in order to support passing in values by reference or//! by value. In the implementation of these functions, you can choose to//! simply use the reference returned by [`SampleBorrow::borrow`], or you can choose//! to copy or clone the value, whatever is appropriate for your type.//! use rand::prelude::*;//! use rand::distributions::uniform::{Uniform, SampleUniform,//!         UniformSampler, UniformFloat, SampleBorrow};//! struct MyF32(f32);//! #[derive(Clone, Copy, Debug)]//! struct UniformMyF32 {//!     inner: UniformFloat<f32>,//! impl UniformSampler for UniformMyF32 {//!     type X = MyF32;//!     fn new<B1, B2>(low: B1, high: B2) -> Self//!         where B1: SampleBorrow<Self::X> + Sized,//!               B2: SampleBorrow<Self::X> + Sized//!         UniformMyF32 {//!             inner: UniformFloat::<f32>::new(low.borrow().0, high.borrow().0),//!     fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self//!         UniformSampler::new(low, high)//!     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {//!         MyF32(self.inner.sample(rng))//! impl SampleUniform for MyF32 {//!     type Sampler = UniformMyF32;//! let (low, high) = (MyF32(17.0f32), MyF32(22.0f32));//! let uniform = Uniform::new(low, high);//! let x = uniform.sample(&mut thread_rng());//! [`SampleUniform`]: crate::distributions::uniform::SampleUniform//! [`UniformSampler`]: crate::distributions::uniform::UniformSampler//! [`UniformInt`]: crate::distributions::uniform::UniformInt//! [`UniformFloat`]: crate::distributions::uniform::UniformFloat//! [`UniformDuration`]: crate::distributions::uniform::UniformDuration//! [`SampleBorrow::borrow`]: crate::distributions::uniform::SampleBorrow::borrow// What follows are all back-ends./// Samples uniformly from the edge of the unit circle in two dimensions./// Implemented via a method by von Neumann[^1]./// use rand::distributions::{UnitCircle, Distribution};/// let circle = UnitCircle::new();/// let v = circle.sample(&mut rand::thread_rng());/// println!("{:?} is from the unit circle.", v)/// [^1]: von Neumann, J. (1951) [*Various Techniques Used in Connection with///       Random Digits.*](https://mcnp.lanl.gov/pdf_files/nbs_vonneumann.pdf)///       NBS Appl. Math. Ser., No. 12. Washington, DC: U.S. Government Printing///       Office, pp. 36-38./// Construct a new `UnitCircle` distribution.assert_almost_eq/// Assert that two numbers are almost equal to each other./// On panic, this macro will print the values of the expressions with their/// debug representations.value_stability/// Samples uniformly from the surface of the unit sphere in three dimensions./// Implemented via a method by Marsaglia[^1]./// use rand::distributions::{UnitSphereSurface, Distribution};/// let sphere = UnitSphereSurface::new();/// let v = sphere.sample(&mut rand::thread_rng());/// println!("{:?} is from the unit sphere surface.", v)/// [^1]: Marsaglia, George (1972). [*Choosing a Point from the Surface of a///       Sphere.*](https://doi.org/10.1214/aoms/1177692644)///       Ann. Math. Statist. 43, no. 2, 645--646./// Construct a new `UnitSphereSurface` distribution.wmulwmul_impl// simd bulk implementationwmul_impl_large// This code is a translation of the __mulddi3 function in LLVM's// compiler-rt. It is an optimised variant of the common method// `(a + b) * (c + d) = ac + ad + bc + bd`.// For some reason LLVM can optimise the C version very well, but// keeps shuffling registers in this Rust translation.wmul_impl_usizeall_lt// `PartialOrd` for vectors compares lexicographically. We want to compare all// the individual SIMD lanes instead, and get the combined result over all// lanes. This is possible using something like `a.lt(b).all()`, but we// implement it as a trait so we can write the same code for `f32` and `f64`.// Only the comparison functions we need are implemented.all_leall_finitefinite_maskgt_maskge_maskdecrease_masked// Decrease all lanes where the mask is `true` to the next lower value// representable by the floating-point type. At least one of the lanes// must be set.// Convert from int value. Conversion is done while retaining the numerical// value, not by retaining the binary representation.cast_from_int/// Helper trait when dealing with scalar and SIMD floating point types./// Implement functions available in std builds but missing from core primitiveslanes/// Implement functions on f32/f64 to give them APIs similar to SIMD typesscalar_float_impl/// Calculates ln(gamma(x)) (natural logarithm of the gamma/// function) using the Lanczos approximation./// The approximation expresses the gamma function as:/// `gamma(z+1) = sqrt(2*pi)*(z+g+0.5)^(z+0.5)*exp(-z-g-0.5)*Ag(z)`/// `g` is an arbitrary constant; we use the approximation with `g=5`./// Noting that `gamma(z+1) = z*gamma(z)` and applying `ln` to both sides:/// `ln(gamma(z)) = (z+0.5)*ln(z+g+0.5)-(z+g+0.5) + ln(sqrt(2*pi)*Ag(z)/z)`/// `Ag(z)` is an infinite series with coefficients that can be calculated/// ahead of time - we use just the first 6 terms, which is good enough/// for most purposes.ZigTable/// Sample a random number using the Ziggurat method (specifically the/// ZIGNOR variant from Doornik 2005). Most of the arguments are/// directly from the paper:/// * `rng`: source of randomness/// * `symmetric`: whether this is a symmetric distribution, or one-sided with P(x < 0) = 0./// * `X`: the $x_i$ abscissae./// * `F`: precomputed values of the PDF at the $x_i$, (i.e. $f(x_i)$)/// * `F_DIFF`: precomputed values of $f(x_i) - f(x_{i+1})$/// * `pdf`: the probability density function/// * `zero_case`: manual sampling from the tail when we chose the///    bottom box (i.e. i == 0)// the perf improvement (25-50%) is definitely worth the extra code// size from force-inlining.//! Math helper functions/// Samples floating-point numbers according to the Weibull distribution/// use rand::distributions::Weibull;/// let val: f64 = SmallRng::from_entropy().sample(Weibull::new(1., 10.));/// Construct a new `Weibull` distribution with given `scale` and `shape`.//! The Weibull distribution.cumulative_weightsweight_distribution/// A distribution using weighted sampling to pick a discretely selected/// item./// Sampling a `WeightedIndex` distribution returns the index of a randomly/// selected element from the iterator used when the `WeightedIndex` was/// created. The chance of a given element being picked is proportional to the/// value of the element. The weights can use any type `X` for which an/// implementation of [`Uniform<X>`] exists./// A `WeightedIndex<X>` contains a `Vec<X>` and a [`Uniform<X>`] and so its/// size is the sum of the size of those objects, possibly plus some alignment./// Creating a `WeightedIndex<X>` will allocate enough space to hold `N - 1`/// weights of type `X`, where `N` is the number of weights. However, since/// `Vec` doesn't guarantee a particular growth strategy, additional memory/// might be allocated but not used. Since the `WeightedIndex` object also/// contains, this might cause additional allocations, though for primitive/// types, ['Uniform<X>`] doesn't allocate any memory./// Time complexity of sampling from `WeightedIndex` is `O(log N)` where/// `N` is the number of weights./// Sampling from `WeightedIndex` will result in a single call to/// `Uniform<X>::sample` (method of the [`Distribution`] trait), which typically/// will request a single value from the underlying [`RngCore`], though the/// exact number depends on the implementaiton of `Uniform<X>::sample`./// use rand::distributions::WeightedIndex;/// let choices = ['a', 'b', 'c'];/// let weights = [2,   1,   1];/// let dist = WeightedIndex::new(&weights).unwrap();///     // 50% chance to print 'a', 25% chance to print 'b', 25% chance to print 'c'///     println!("{}", choices[dist.sample(&mut rng)]);/// let items = [('a', 0), ('b', 3), ('c', 7)];/// let dist2 = WeightedIndex::new(items.iter().map(|item| item.1)).unwrap();///     // 0% chance to print 'a', 30% chance to print 'b', 70% chance to print 'c'///     println!("{}", items[dist2.sample(&mut rng)].0);/// [`Uniform<X>`]: crate::distributions::uniform::Uniform/// [`RngCore`]: rand_core::RngCore/// Creates a new a `WeightedIndex` [`Distribution`] using the values/// in `weights`. The weights can use any type `X` for which an/// Returns an error if the iterator is empty, if any weight is `< 0`, or/// if its total value is 0.test_weightedindexNoItem/// The provided iterator contained no items.NegativeWeight/// A weight lower than zero was used.AllWeightsZero/// All items in the provided iterator had a weight of zero./// Error type returned from `WeightedIndex::new`.ZIG_NORM_RZIG_NORM_XZIG_NORM_FZIG_EXP_RZIG_EXP_XZIG_EXP_F// Tables for distributions which are sampled using the ziggurat// algorithm. Autogenerated by `ziggurat_tables.py`.// only for deprecations// Re-exports from rand_core// Public exportsprngisaac/// Return a random value supporting the [`Standard`] distribution./// [`Standard`]: distributions::Standard/// let x: u32 = rng.gen();/// println!("{}", x);/// println!("{:?}", rng.gen::<(f64, bool)>());gen_range/// Generate a random value in the range [`low`, `high`), i.e. inclusive of/// `low` and exclusive of `high`./// This function is optimised for the case that only a single sample is/// made from the given range. See also the [`Uniform`] distribution/// type which may be faster if sampling from the same range repeatedly./// Panics if `low >= high`./// let n: u32 = rng.gen_range(0, 10);/// println!("{}", n);/// let m: f64 = rng.gen_range(-40.0f64, 1.3e5f64);/// println!("{}", m);/// [`Uniform`]: distributions::uniform::Uniform/// Sample a new value, using the given distribution./// use rand::distributions::Uniform;/// let x = rng.sample(Uniform::new(10u32, 15));/// // Type annotation requires two types, the type and distribution; the/// // distribution can be inferred./// let y = rng.sample::<u16, _>(Uniform::new(10, 15));/// Create an iterator that generates values using the given distribution./// use rand::distributions::{Alphanumeric, Uniform, Standard};/// let v: Vec<f32> = thread_rng().sample_iter(&Standard).take(16).collect();/// let s: String = rng.sample_iter(&Alphanumeric).take(7).collect();/// // Combined values/// println!("{:?}", thread_rng().sample_iter(&Standard).take(5)///                              .collect::<Vec<(f64, bool)>>());/// let mut roll_die = rng.sample_iter(&die_range);AsByteSliceMut/// Fill `dest` entirely with random bytes (uniform value distribution),/// where `dest` is any type supporting [`AsByteSliceMut`], namely slices/// and arrays over primitive integer types (`i8`, `i16`, `u32`, etc.)./// On big-endian platforms this performs byte-swapping to ensure/// portability of results from reproducible generators./// This uses [`fill_bytes`] internally which may handle some RNG errors/// implicitly (e.g. waiting if the OS generator is not ready), but panics/// on other errors. See also [`try_fill`] which returns errors./// let mut arr = [0i8; 20];/// thread_rng().fill(&mut arr[..]);/// [`fill_bytes`]: RngCore::fill_bytes/// [`try_fill`]: Rng::try_fill/// This uses [`try_fill_bytes`] internally and forwards all RNG errors. In/// some cases errors may be resolvable; see [`ErrorKind`] and/// documentation for the RNG in use. If you do not plan to handle these/// errors you may prefer to use [`fill`]./// # use rand::Error;/// # fn try_inner() -> Result<(), Error> {/// let mut arr = [0u64; 4];/// thread_rng().try_fill(&mut arr[..])?;/// # try_inner().unwrap()/// [`try_fill_bytes`]: RngCore::try_fill_bytes/// [`fill`]: Rng::fillgen_bool/// Return a bool with a probability `p` of being true./// See also the [`Bernoulli`] distribution, which may be faster if/// sampling from the same probability repeatedly./// println!("{}", rng.gen_bool(1.0 / 3.0));/// [`Bernoulli`]: distributions::bernoulli::Bernoulligen_ratio/// Return a bool with a probability of `numerator/denominator` of being/// true. I.e. `gen_ratio(2, 3)` has chance of 2 in 3, or about 67%, of/// returning true. If `numerator == denominator`, then the returned value/// is guaranteed to be `true`. If `numerator == 0`, then the returned/// value is guaranteed to be `false`./// sampling from the same `numerator` and `denominator` repeatedly./// println!("{}", rng.gen_ratio(2, 3));/// Return a random element from `values`./// Deprecated: use [`seq::SliceRandom::choose`] instead.choose_mut/// Return a mutable pointer to a random element from `values`./// Deprecated: use [`seq::SliceRandom::choose_mut`] instead./// Shuffle a mutable slice in place./// Deprecated: use [`seq::SliceRandom::shuffle`] instead./// An automatically-implemented extension trait on [`RngCore`] providing high-level/// generic methods for sampling values and other convenience methods./// This is the primary trait to use when generating random values./// # Generic usage/// The basic pattern is `fn foo<R: Rng + ?Sized>(rng: &mut R)`. Some/// things are worth noting here:/// - Since `Rng: RngCore` and every `RngCore` implements `Rng`, it makes no///   difference whether we use `R: Rng` or `R: RngCore`./// - The `+ ?Sized` un-bounding allows functions to be called directly on///   type-erased references; i.e. `foo(r)` where `r: &mut RngCore`. Without///   this it would be necessary to write `foo(&mut r)`./// An alternative pattern is possible: `fn foo<R: Rng>(rng: R)`. This has some/// trade-offs. It allows the argument to be consumed directly without a `&mut`/// (which is how `from_rng(thread_rng())` works); also it still works directly/// on references (including type-erased references). Unfortunately within the/// function `foo` it is not known whether `rng` is a reference type or not,/// hence many uses of `rng` require an extra reference, either explicitly/// (`distr.sample(&mut rng)`) or implicitly (`rng.gen()`); one may hope the/// optimiser can remove redundant references later./// # use rand::thread_rng;/// use rand::Rng;/// fn foo<R: Rng + ?Sized>(rng: &mut R) -> f32 {///     rng.gen()/// # let v = foo(&mut thread_rng());as_byte_slice_mut/// Return a mutable reference to self as a byte slice/// Call `to_le` on each element (i.e. byte-swap on Big Endian platforms)./// Trait for casting types to byte slices/// This is used by the [`Rng::fill`] and [`Rng::try_fill`] methods.impl_as_byte_sliceimpl_as_byte_slice_arrays!from_entropy/// Creates a new instance, automatically seeded with fresh entropy./// Normally this will use `OsRng`, but if that fails `JitterRng` will be/// used instead. Both should be suitable for cryptography. It is possible/// that both entropy sources will fail though unlikely; failures would/// almost certainly be platform limitations or build issues, i.e. most/// applications targetting PC/mobile platforms should not need to worry/// about this failing./// If all entropy sources fail this will panic. If you need to handle/// errors, use the following code, equivalent aside from error handling:/// use rand::rngs::EntropyRng;/// // This uses StdRng, but is valid for any R: SeedableRng/// let mut rng = StdRng::from_rng(EntropyRng::new())?;/// println!("random number: {}", rng.gen_range(1, 10));FromEntropy/// A convenience extension to [`SeedableRng`] allowing construction from fresh/// entropy. This trait is automatically implemented for any PRNG implementing/// [`SeedableRng`] and is not intended to be implemented by users./// This is equivalent to using `SeedableRng::from_rng(EntropyRng::new())` then/// unwrapping the result./// Since this is convenient and secure, it is the recommended way to create/// PRNGs, though two alternatives may be considered:/// *   Deterministic creation using [`SeedableRng::from_seed`] with a fixed seed/// *   Seeding from `thread_rng`: `SeedableRng::from_rng(thread_rng())?`;///     this will usually be faster and should also be secure, but requires///     trusting one extra component./// use rand::{Rng, FromEntropy};/// use rand::rngs::StdRng;/// let mut rng = StdRng::from_entropy();/// println!("Random die roll: {}", rng.gen_range(1, 7));/// [`EntropyRng`]: rngs::EntropyRng/// Generates a random value using the thread-local random number generator./// This is simply a shortcut for `thread_rng().gen()`. See [`thread_rng`] for/// documentation of the entropy source and [`Standard`] for documentation of/// distributions and type-specific generation./// let x = rand::random::<u8>();/// let y = rand::random::<f64>();/// println!("{}", y);/// if rand::random() { // generates a boolean///     println!("Better lucky than good!");/// If you're calling `random()` in a loop, caching the generator as in the/// following example can increase performance./// let mut v = vec![1, 2, 3];/// for x in v.iter_mut() {///     *x = rand::random()/// // can be made faster by caching thread_rng/// let mut rng = rand::thread_rng();///     *x = rng.gen();TestRngtest_fill_bytes_defaulttest_filltest_fill_emptytest_gen_rangetest_gen_range_panic_inttest_gen_range_panic_usizetest_gen_booltest_rng_trait_objecttest_rng_boxed_traittest_randomtest_gen_ratio_average//! Utilities for random number generation//! Rand provides utilities to generate random numbers, to convert them to//! useful types and distributions, and some randomness-related algorithms.//! # Quick Start//! To get you started quickly, the easiest and highest-level way to get//! a random value is to use [`random()`]; alternatively you can use//! [`thread_rng()`]. The [`Rng`] trait provides a useful API on all RNGs, while//! the [`distributions`] and [`seq`] modules provide further//! functionality on top of RNGs.//! if rand::random() { // generates a boolean//!     // Try printing a random unicode code point (probably a bad idea)!//!     println!("char: {}", rand::random::<char>());//! let y: f64 = rng.gen(); // generates a float between 0 and 1//! let mut nums: Vec<i32> = (1..100).collect();//! nums.shuffle(&mut rng);//! # The Book//! For the user guide and futher documentation, please read//! [The Rust Rand Book](https://rust-random.github.io/book).// Compatibility re-exports. Documentation is hidden; will be removed eventually.IteratorRandom//! Convenience re-export of common members//! Like the standard library's prelude, this module simplifies importing of//! common items. Unlike the standard prelude, the contents of this module must//! be imported manually://! # let _ = StdRng::from_entropy();//! # let mut r = SmallRng::from_rng(thread_rng()).unwrap();//! # let _: f32 = r.gen();// Deprecations (to be removed in 0.7)// Note: we miss `IsaacCore` here but probably unimportant.isaac64// Note: we miss `ChaChaCore` here but probably unimportant.// Note: we miss `Hc128Core` here but probably unimportant.hc128//! Pseudo-random number generators.//! This module is deprecated://! -   documentation has moved to//!     [The Book](https://rust-random.github.io/book/guide-rngs.html),//! -   PRNGs have moved to other `rand_*` crates.reseeding//! Wrappers / adapters forming RNGs/// An RNG that reads random bytes straight from any type supporting/// [`std::io::Read`], for example files./// This will work best with an infinite reader, but that is not required./// This can be used with `/dev/urandom` on Unix but it is recommended to use/// [`OsRng`] instead./// `ReadRng` uses [`std::io::Read::read_exact`], which retries on interrupts./// All other errors from the underlying reader, including when it does not/// have enough data, will only be reported through [`try_fill_bytes`]./// The other [`RngCore`] methods will panic in case of an error./// use rand::rngs::adapter::ReadRng;/// let data = vec![1, 2, 3, 4, 5, 6, 7, 8];/// let mut rng = ReadRng::new(&data[..]);/// println!("{:x}", rng.gen::<u32>());/// [`OsRng`]: rand_os::OsRng/// Create a new `ReadRng` from a `Read`.test_reader_rng_u64test_reader_rng_u32test_reader_rng_fill_bytestest_reader_rng_insufficient_bytes//! A wrapper around any Read to treat it as an RNG.BlockRngReseedingCore/// A wrapper around any PRNG that implements [`BlockRngCore`], that adds the/// ability to reseed it./// `ReseedingRng` reseeds the underlying PRNG in the following cases:/// - On a manual call to [`reseed()`]./// - After `clone()`, the clone will be reseeded on first use./// - After a process is forked, the RNG in the child process is reseeded within///   the next few generated values, depending on the block size of the///   underlying PRNG. For [`ChaChaCore`] and [`Hc128Core`] this is a maximum of///   15 `u32` values before reseeding./// - After the PRNG has generated a configurable number of random bytes./// # When should reseeding after a fixed number of generated bytes be used?/// Reseeding after a fixed number of generated bytes is never strictly/// *necessary*. Cryptographic PRNGs don't have a limited number of bytes they/// can output, or at least not a limit reachable in any practical way. There is/// no such thing as 'running out of entropy'./// Occasionally reseeding can be seen as some form of 'security in depth'. Even/// if in the future a cryptographic weakness is found in the CSPRNG being used,/// or a flaw in the implementation, occasionally reseeding should make/// exploiting it much more difficult or even impossible./// Use [`ReseedingRng::new`] with a `threshold` of `0` to disable reseeding/// after a fixed number of generated bytes./// # Error handling/// Although unlikely, reseeding the wrapped PRNG can fail. `ReseedingRng` will/// never panic but try to handle the error intelligently through some/// combination of retrying and delaying reseeding until later./// If handling the source error fails `ReseedingRng` will continue generating/// data from the wrapped PRNG without reseeding./// Manually calling [`reseed()`] will not have this retry or delay logic, but/// reports the error./// # extern crate rand;/// # extern crate rand_chacha;/// use rand_chacha::ChaChaCore; // Internal part of ChaChaRng that///                              // implements BlockRngCore/// use rand::rngs::OsRng;/// use rand::rngs::adapter::ReseedingRng;/// let prng = ChaChaCore::from_entropy();// FIXME: it is better to use EntropyRng as reseeder, but that doesn't implement// clone yet./// let reseeder = OsRng::new().unwrap();/// let mut reseeding_rng = ReseedingRng::new(prng, 0, reseeder);/// println!("{}", reseeding_rng.gen::<u64>());/// let mut cloned_rng = reseeding_rng.clone();/// assert!(reseeding_rng.gen::<u64>() != cloned_rng.gen::<u64>());/// [`ChaChaCore`]: rand_chacha::ChaChaCore/// [`Hc128Core`]: rand_hc::Hc128Core/// [`BlockRngCore`]: rand_core::block::BlockRngCore/// [`ReseedingRng::new`]: ReseedingRng::new/// [`reseed()`]: ReseedingRng::reseed/// Create a new `ReseedingRng` from an existing PRNG, combined with a RNG/// to use as reseeder./// `threshold` sets the number of generated bytes after which to reseed the/// PRNG. Set it to zero to never reseed based on the number of generated/// Reseed the internal PRNG.// TODO: this should be implemented for any type where the inner type// implements RngCore, but we can't specify that because ReseedingCore is privatereseederbytes_until_reseedfork_counter/// Create a new `ReseedingCore`.is_forkedreseed_and_generateATOMIC_BOOL_INITRESEEDING_RNG_FORK_COUNTERget_fork_counterFORK_HANDLER_REGISTEREDfork_handlerregister_fork_handler// Fork protection// We implement fork protection on Unix using `pthread_atfork`.// When the process is forked, we increment `RESEEDING_RNG_FORK_COUNTER`.// Every `ReseedingRng` stores the last known value of the static in// `fork_counter`. If the cached `fork_counter` is less than// `RESEEDING_RNG_FORK_COUNTER`, it is time to reseed this RNG.// If reseeding fails, we don't deal with this by setting a delay, but just// don't update `fork_counter`, so a reseed is attempted as soon as// possible.test_reseedingtest_clone_reseeding//! A wrapper around another PRNG that reseeds it after it//! generates a certain number of random bytes./// An interface returning random data from external source(s), provided/// specifically for securely seeding algorithmic generators (PRNGs)./// Where possible, `EntropyRng` retrieves random data from the operating/// system's interface for random numbers ([`OsRng`]); if that fails it will/// fall back to the [`JitterRng`] entropy collector. In the latter case it will/// still try to use [`OsRng`] on the next usage./// If no secure source of entropy is available `EntropyRng` will panic on use;/// i.e. it should never output predictable data./// This is either a little slow ([`OsRng`] requires a system call) or extremely/// slow ([`JitterRng`] must use significant CPU time to generate sufficient/// jitter); for better performance it is common to seed a local PRNG from/// external entropy then primarily use the local PRNG ([`thread_rng`] is/// provided as a convenient, local, automatically-seeded CSPRNG)./// On most systems, like Windows, Linux, macOS and *BSD on common hardware, it/// is highly unlikely for both [`OsRng`] and [`JitterRng`] to fail. But on/// combinations like webassembly without Emscripten or stdweb both sources are/// unavailable. If both sources fail, only [`try_fill_bytes`] is able to/// report the error, and only the one from `OsRng`. The other [`RngCore`]/// methods will panic in case of an error./// [`thread_rng`]: crate::thread_rng/// [`JitterRng`]: crate::rngs::JitterRngJitter/// Create a new `EntropyRng`./// This method will do no system calls or other initialization routines,/// those are done on first use. This is done to make `new` infallible,/// and `try_fill_bytes` the only place to report errors.new_and_fillEntropySourceNoSourcetest_entropy//! Entropy generator, or wrapper around external generators/// A simple implementation of `RngCore` for testing purposes./// This generates an arithmetic sequence (i.e. adds a constant each step)/// over a `u64` number, using wrapping arithmetic. If the increment is 0/// the generator yields a constant./// use rand::rngs::mock::StepRng;/// let mut my_rng = StepRng::new(2, 1);/// let sample: [u64; 3] = my_rng.gen();/// assert_eq!(sample, [2, 3, 4]);/// Create a `StepRng`, yielding an arithmetic sequence starting with/// `initial` and incremented by `increment` each time.//! Mock random number generator// Public so we don't export `StepRng` directly, making it a bit// more clear it is intended for testing.//! Random number generators and adapters for common usage://! - [`ThreadRng`], a fast, secure, auto-seeded thread-local generator//! - [`StdRng`] and [`SmallRng`], algorithms to cover typical usage//! - [`EntropyRng`], [`OsRng`] and [`JitterRng`] as entropy sources//! - [`mock::StepRng`] as a simple counter for tests//! - [`adapter::ReadRng`] to read from a file/stream//! - [`adapter::ReseedingRng`] to reseed a PRNG on clone / process fork etc.//! # Background — Random number generators (RNGs)//! Computers are inherently deterministic, so to get *random* numbers one//! either has to use a hardware generator or collect bits of *entropy* from//! various sources (e.g. event timestamps, or jitter). This is a relatively//! slow and complicated operation.//! Generally the operating system will collect some entropy, remove bias, and//! use that to seed its own PRNG; [`OsRng`] provides an interface to this.//! [`JitterRng`] is an entropy collector included with Rand that measures//! jitter in the CPU execution time, and jitter in memory access time.//! [`EntropyRng`] is a wrapper that uses the best entropy source that is//! available.//! ## Pseudo-random number generators//! What is commonly used instead of "true" random number renerators, are//! *pseudo-random number generators* (PRNGs), deterministic algorithms that//! produce an infinite stream of pseudo-random numbers from a small random//! seed. PRNGs are faster, and have better provable properties. The numbers//! produced can be statistically of very high quality and can be impossible to//! predict. (They can also have obvious correlations and be trivial to predict;//! quality varies.)//! There are two different types of PRNGs: those developed for simulations//! and statistics, and those developed for use in cryptography; the latter are//! called Cryptographically Secure PRNGs (CSPRNG or CPRNG). Both types can//! have good statistical quality but the latter also have to be impossible to//! predict, even after seeing many previous output values. Rand provides a good//! default algorithm from each class://! - [`SmallRng`] is a PRNG chosen for low memory usage, high performance and//!   good statistical quality.//! - [`StdRng`] is a CSPRNG chosen for good performance and trust of security//!   (based on reviews, maturity and usage). The current algorithm is HC-128,//!   which is one of the recommendations by ECRYPT's eSTREAM project.//! The above PRNGs do not cover all use-cases; more algorithms can be found in//! the [`prng`][crate::prng] module, as well as in several other crates. For example, you//! may wish a CSPRNG with significantly lower memory usage than [`StdRng`]//! while being less concerned about performance, in which case [`ChaChaRng`]//! is a good choice.//! One complexity is that the internal state of a PRNG must change with every//! generated number. For APIs this generally means a mutable reference to the//! state of the PRNG has to be passed around.//! A solution is [`ThreadRng`]. This is a thread-local implementation of//! [`StdRng`] with automatic seeding on first use. It is the best choice if you//! "just" want a convenient, secure, fast random number source. Use via the//! [`thread_rng`] function, which gets a reference to the current thread's//! local instance.//! As mentioned above, PRNGs require a random seed in order to produce random//! output. This is especially important for CSPRNGs, which are still//! deterministic algorithms, thus can only be secure if their seed value is//! also secure. To seed a PRNG, use one of://! - [`FromEntropy::from_entropy`]; this is the most convenient way to seed//!   with fresh, secure random data.//! - [`SeedableRng::from_rng`]; this allows seeding from another PRNG or//!   from an entropy source such as [`EntropyRng`].//! - [`SeedableRng::from_seed`]; this is mostly useful if you wish to be able//!   to reproduce the output sequence by using a fixed seed. (Don't use//!   [`StdRng`] or [`SmallRng`] in this case since different algorithms may be//!   used by future versions of Rand; use an algorithm from the//!   [`prng`] module.)//! ## Conclusion//! - [`thread_rng`] is what you often want to use.//! - If you want more control, flexibility, or better performance, use//!   [`StdRng`], [`SmallRng`] or an algorithm from the [`prng`] module.//! - Use [`FromEntropy::from_entropy`] to seed new PRNGs.//! - If you need reproducibility, use [`SeedableRng::from_seed`] combined with//!   a named PRNG.//! More information and notes on cryptographic security can be found//! in the [`prng`] module.//! Examples of seeding PRNGs://! # use rand::Error;//! // StdRng seeded securely by the OS or local entropy collector://! let mut rng = StdRng::from_entropy();//! # let v: u32 = rng.gen();//! // SmallRng seeded from thread_rng://! # fn try_inner() -> Result<(), Error> {//! let mut rng = SmallRng::from_rng(thread_rng())?;//! # try_inner().unwrap();//! // SmallRng seeded by a constant, for deterministic results://! let seed = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16]; // byte array//! let mut rng = SmallRng::from_seed(seed);//! # Implementing custom RNGs//! If you want to implement custom RNG, see the [`rand_core`] crate. The RNG//! will have to implement the [`RngCore`] trait, where the [`Rng`] trait is//! build on top of.//! If the RNG needs seeding, also implement the [`SeedableRng`] trait.//! [`CryptoRng`] is a marker trait cryptographically secure PRNGs can//! implement.//! [`OsRng`]: rand_os::OsRng//! [`SmallRng`]: rngs::SmallRng//! [`StdRng`]: rngs::StdRng//! [`ThreadRng`]: rngs::ThreadRng//! [`EntropyRng`]: rngs::EntropyRng//! [`JitterRng`]: rngs::JitterRng//! [`mock::StepRng`]: rngs::mock::StepRng//! [`adapter::ReadRng`]: rngs::adapter::ReadRng//! [`adapter::ReseedingRng`]: rngs::adapter::ReseedingRng//! [`ChaChaRng`]: rand_chacha::ChaChaRngPcg64Mcg/// An RNG recommended when small state, cheap initialization and good/// performance are required. The PRNG algorithm in `SmallRng` is chosen to be/// efficient on the current platform, **without consideration for cryptography/// or security**. The size of its state is much smaller than for [`StdRng`]./// Reproducibility of output from this generator is however not required, thus/// future library versions may use a different internal generator with/// different output. Further, this generator may not be portable and can/// produce different output depending on the architecture. If you require/// reproducible output, use a named RNG./// Refer to [The Book](https://rust-random.github.io/book/guide-rngs.html)./// The current algorithm is [`Pcg64Mcg`][rand_pcg::Pcg64Mcg] on 64-bit platforms with Rust version/// 1.26 and later, or [`Pcg32`][rand_pcg::Pcg32] otherwise. Both are found in/// the [rand_pcg] crate./// Initializing `SmallRng` with a random seed can be done using [`FromEntropy`]:/// # use rand::Rng;/// use rand::FromEntropy;/// use rand::rngs::SmallRng;/// // Create small, cheap to initialize and fast RNG with a random seed./// // The randomness is supplied by the operating system./// let mut small_rng = SmallRng::from_entropy();/// # let v: u32 = small_rng.gen();/// When initializing a lot of `SmallRng`'s, using [`thread_rng`] can be more/// efficient:/// use rand::{SeedableRng, thread_rng};/// // Create a big, expensive to initialize and slower, but unpredictable RNG./// // This is cached and done only once per thread./// let mut thread_rng = thread_rng();/// // Create small, cheap to initialize and fast RNGs with random seeds./// // One can generally assume this won't fail./// let rngs: Vec<SmallRng> = iter::repeat(())///     .map(|()| SmallRng::from_rng(&mut thread_rng).unwrap())///     .take(10)/// [`FromEntropy`]: crate::FromEntropy/// [`StdRng`]: crate::rngs::StdRng/// [rand_pcg]: https://crates.io/crates/rand_pcg//! A small fast RNG/// The standard RNG. The PRNG algorithm in `StdRng` is chosen to be efficient/// on the current platform, to be statistically strong and unpredictable/// (meaning a cryptographically secure PRNG)./// The current algorithm used on all platforms is [HC-128], found in the/// [rand_hc] crate./// reproducible output, use a named RNG, for example [`ChaChaRng`] from the/// [rand_chacha] crate./// [HC-128]: rand_hc::Hc128Rng/// [`ChaChaRng`]: rand_chacha::ChaChaRng/// [rand_hc]: https://crates.io/crates/rand_hc/// [rand_chacha]: https://crates.io/crates/rand_chachatest_stdrng_construction//! The standard RNGHc128CoreTHREAD_RNG_RESEED_THRESHOLD// Number of generated bytes after which to reseed `TreadRng`.// The time it takes to reseed HC-128 is roughly equivalent to generating 7 KiB.// We pick a treshold here that is large enough to not reduce the average// performance too much, but also small enough to not make reseeding something// that basically never happens.// use of raw pointer implies type is neither Send nor Sync/// The type returned by [`thread_rng`], essentially just a reference to the/// PRNG in thread-local memory./// `ThreadRng` uses [`ReseedingRng`] wrapping the same PRNG as [`StdRng`],/// which is reseeded after generating 32 MiB of random data. A single instance/// is cached per thread and the returned `ThreadRng` is a reference to this/// instance — hence `ThreadRng` is neither `Send` nor `Sync` but is safe to use/// within a single thread. This RNG is seeded and reseeded via [`EntropyRng`]/// as required./// Note that the reseeding is done as an extra precaution against entropy/// leaks and is in theory unnecessary — to predict `ThreadRng`'s output, an/// attacker would have to either determine most of the RNG's seed or internal/// state, or crack the algorithm used./// Like [`StdRng`], `ThreadRng` is a cryptographically secure PRNG. The current/// algorithm used is [HC-128], which is an array-based PRNG that trades memory/// usage for better performance. This makes it similar to ISAAC, the algorithm/// used in `ThreadRng` before rand 0.5./// Cloning this handle just produces a new reference to the same thread-local/// [`ReseedingRng`]: crate::rngs::adapter::ReseedingRngTHREAD_RNG_KEY/// Retrieve the lazily-initialized thread-local random number generator,/// seeded by the system. Intended to be used in method chaining style,/// e.g. `thread_rng().gen::<i32>()`, or cached locally, e.g./// `let mut rng = thread_rng();`.  Invoked by the `Default` trait, making/// `ThreadRng::default()` equivelent./// For more information see [`ThreadRng`].test_thread_rng//! Thread-local random number generator// Rationale for using `UnsafeCell` in `ThreadRng`:// Previously we used a `RefCell`, with an overhead of ~15%. There will only// ever be one mutable reference to the interior of the `UnsafeCell`, because// we only have such a reference inside `next_u32`, `next_u64`, etc. Within a// single thread (which is the definition of `ThreadRng`), there will only ever// be one of these methods active at a time.// A possible scenario where there could be multiple mutable references is if// `ThreadRng` is used inside `next_u32` and co. But the implementation is// completely under our control. We just have to ensure none of them use// `ThreadRng` internally, which is nonsensical anyway. We should also never run// `ThreadRng` in destructors of its implementation, which is also nonsensical.// The additional `Rc` is not strictly neccesary, and could be removed. For now// it ensures `ThreadRng` stays `!Send` and `!Sync`, and implements `Clone`.// 32 MiB// BTreeMap is not as fast in tests, but better than nothing.IndexVecUSize/// A vector of indices./// Multiple internal representations are possible./// Returns the number of indices/// Return the value at the given `index`./// (Note: we cannot implement [`std::ops::Index`] because of lifetime/// restrictions.)/// Return result as a `Vec<usize>`. Conversion may or may not be trivial.IndexVecIter/// Iterate over the indices as a sequence of `usize` valuesIndexVecIntoIter/// Convert into an iterator over the indices as a sequence of `usize` values/// Return type of `IndexVec::iter`./// Return type of `IndexVec::into_iter`./// Randomly sample exactly `amount` distinct indices from `0..length`, and/// return them in random order (fully shuffled)./// This method is used internally by the slice sampling methods, but it can/// sometimes be useful to have the indices themselves so this is provided as/// an alternative./// The implementation used is not specified; we automatically select the/// fastest available algorithm for the `length` and `amount` parameters/// (based on detailed profiling on an Intel Haswell CPU). Roughly speaking,/// complexity is `O(amount)`, except that when `amount` is small, performance/// is closer to `O(amount^2)`, and when `length` is close to `amount` then/// `O(length)`./// Note that performance is significantly better over `u32` indices than over/// `u64` indices. Because of this we hide the underlying type behind an/// abstraction, `IndexVec`./// If an allocation-free `no_std` function is required, it is suggested/// to adapt the internal `sample_floyd` implementation./// Panics if `amount > length`.sample_floyd/// Randomly sample exactly `amount` indices from `0..length`, using Floyd's/// combination algorithm./// The output values are fully shuffled. (Overhead is under 50%.)/// This implementation uses `O(amount)` memory and `O(amount^2)` time.sample_inplace/// Randomly sample exactly `amount` indices from `0..length`, using an inplace/// partial Fisher-Yates method./// Sample an amount of indices using an inplace partial fisher yates method./// This allocates the entire `length` of indices and randomizes only the first `amount`./// It then truncates to `amount` and returns./// This method is not appropriate for large `length` and potentially uses a lot/// of memory; because of this we only implement for `u32` index (which improves/// performance in all cases)./// Set-up is `O(length)` time and memory and shuffling is `O(amount)` time.sample_rejection/// Randomly sample exactly `amount` indices from `0..length`, using rejection/// sampling./// Since `amount <<< length` there is a low chance of a random sample in/// `0..length` being a duplicate. We test for duplicates and resample where/// necessary. The algorithm is `O(amount)` time and memory.test_sample_boundariestest_sample_alg//! Index sampling/// The element type./// Returns a reference to one random element of the slice, or `None` if the/// slice is empty./// Depending on the implementation, complexity is expected to be `O(1)`./// use rand::seq::SliceRandom;/// let choices = [1, 2, 4, 8, 16, 32];/// println!("{:?}", choices.choose(&mut rng));/// assert_eq!(choices[..0].choose(&mut rng), None);/// Returns a mutable reference to one random element of the slice, or/// `None` if the slice is empty.SliceChooseIter/// Produces an iterator that chooses `amount` elements from the slice at/// random without repeating any, and returns them in random order./// In case this API is not sufficiently flexible, use `index::sample` then/// apply the indices to the slice./// Complexity is expected to be the same as `index::sample`./// let mut rng = &mut rand::thread_rng();/// let sample = "Hello, audience!".as_bytes();/// // collect the results into a vector:/// let v: Vec<u8> = sample.choose_multiple(&mut rng, 3).cloned().collect();/// // store in a buffer:/// let mut buf = [0u8; 5];/// for (b, slot) in sample.choose_multiple(&mut rng, buf.len()).zip(buf.iter_mut()) {///     *slot = *b;choose_weighted/// Similar to [`choose`], where the likelihood of each outcome may be/// specified. The specified function `weight` maps items `x` to a relative/// likelihood `weight(x)`. The probability of each item being selected is/// therefore `weight(x) / s`, where `s` is the sum of all `weight(x)`./// let choices = [('a', 2), ('b', 1), ('c', 1)];/// // 50% chance to print 'a', 25% chance to print 'b', 25% chance to print 'c'/// println!("{:?}", choices.choose_weighted(&mut rng, |item| item.1).unwrap().0);/// [`choose`]: SliceRandom::choosechoose_weighted_mut/// Similar to [`choose_mut`], where the likelihood of each outcome may be/// See also [`choose_weighted`]./// [`choose_mut`]: SliceRandom::choose_mut/// [`choose_weighted`]: SliceRandom::choose_weighted/// let mut y = [1, 2, 3, 4, 5];/// println!("Unshuffled: {:?}", y);/// y.shuffle(&mut rng);/// println!("Shuffled:   {:?}", y);partial_shuffle/// Shuffle a slice in place, but exit early./// Returns two mutable slices from the source slice. The first contains/// `amount` elements randomly permuted. The second has the remaining/// elements that are not fully shuffled./// This is an efficient method to select `amount` elements at random from/// the slice, provided the slice may be mutated./// If you only need to choose elements randomly and `amount > self.len()/2`/// then you may improve performance by taking/// `amount = values.len() - amount` and using only the second slice./// If `amount` is greater than the number of elements in the slice, this/// will perform a full shuffle./// Complexity is expected to be `O(m)` where `m = amount`./// Extension trait on slices, providing random mutation and sampling methods./// An implementation is provided for slices. This may also be implementable for/// other types./// Choose one element at random from the iterator. If you have a slice,/// it's significantly faster to call the [`choose`] or [`choose_mut`]/// functions using the slice instead./// Returns `None` if and only if the iterator is empty./// Complexity is `O(n)`, where `n` is the length of the iterator./// This likely consumes multiple random numbers, but the exact number/// [`choose`]: SliceRandom::method.choosechoose_multiple_fill/// Collects `amount` values at random from the iterator into a supplied/// Although the elements are selected randomly, the order of elements in/// the buffer is neither stable nor fully random. If random ordering is/// desired, shuffle the result./// Returns the number of elements added to the buffer. This equals `amount`/// unless the iterator contains insufficient elements, in which case this/// equals the number of elements available./// This is equivalent to `choose_multiple_fill` except for the result type./// Extension trait on iterators, providing random sampling methods./// Iterator over multiple choices, as returned by [`SliceRandom::choose_multiple]/// Randomly sample `amount` elements from a finite iterator./// Deprecated: use [`IteratorRandom::choose_multiple`] instead.sample_slice/// Randomly sample exactly `amount` values from `slice`./// The values are non-repeating and in random order./// This implementation uses `O(amount)` time and memory./// Panics if `amount > slice.len()`/// Deprecated: use [`SliceRandom::choose_multiple`] instead.sample_slice_ref/// Randomly sample exactly `amount` references from `slice`./// The references are non-repeating and in random order.test_slice_chooseUnhintedIteratorchunk_remaininghint_total_sizeChunkHintedIteratorWindowHintedIteratortest_iterator_choosetest_shuffletest_partial_shuffletest_sample_itertest_sample_slice_boundariestest_sample_slicetest_weighted//! Functions for randomly accessing and sampling sequences.//! TODO: module doc/// let d = Bernoulli::new(0.3).unwrap();// Also there is a 100% theoretical concern: if someone consistently wants toBernoulliErrorInvalidProbability/// `p < 0` or `p > 1`./// Error type returned from `Bernoulli::new`./// For `numerator > denominator` and `denominator == 0`, this returns an/// error. Otherwise, for `numerator == denominator`, samples are always/// true; for `numerator == 0` samples are always false.bernoulli_distributions_can_be_compared/// Note that this function takes `self` by value. This works since/// `Distribution<T>` is impl'd for `&D` where `D: Distribution<T>`,/// however borrowing is not automatic hence `distr.sample_iter(...)` may/// need to be replaced with `(&distr).sample_iter(...)` to borrow or/// `(&*distr).sample_iter(...)` to reborrow an existing reference./// let s: String = Alphanumeric///     .sample_iter(&mut rng)///     .take(7)///     .map(char::from)DistMap/// Create a distribution of values of 'S' by mapping the output of `Self`/// through the closure `F`/// let die = Uniform::new_inclusive(1, 6);/// let even_number = die.map(|num| num % 2 == 0);/// while !even_number.sample(&mut rng) {///     println!("Still odd; rolling again!");/// Implementations are typically expected to be portable with reproducible/// results when used with a PRNG with fixed seed; see the/// [portability chapter](https://rust-random.github.io/book/portability.html)/// of The Rust Rand Book. In some cases this does not apply, e.g. the `usize`/// type requires different sampling on 32-bit and 64-bit machines./// A distribution of values of type `S` derived from the distribution `D`/// by mapping its output of type `T` through the closure `F`./// This `struct` is created by the [`Distribution::map`] method.append_string/// Append `len` random chars to `string`/// Generate a `String` of `len` random charsDistString/// `String` sampler/// Sampling a `String` of random characters is not quite the same as collecting/// a sequence of chars. This trait contains some helpers.test_distributions_maptest_make_an_itertest_dist_string//! Distribution trait and associates/// the 24 most significant random bits of a `u32` are used and for `f64` the/// the 23 most significant random bits of an `u32` are used, for `f64` 52 from/// Helper method to combine the fraction and a constant exponent into a// This trait is needed by both this lib and rand_distr hence is a hidden exportimpl_nzintdistributionweighted_index// used by rand_distrhidden_export/// ## Provided implementations/// The `Standard` distribution also supports generation of the following/// compound types where all component types are supported:/// *   Tuples (up to 12 elements): each element is generated sequentially./// *   Arrays (up to 32 elements): each element is generated sequentially;///     see also [`Rng::fill`] which supports arbitrary array length for integer///     and float types and tends to be faster for `u32` and smaller types.///     When using `rustc` ≥ 1.51, enable the `min_const_gen` feature to support///     arrays larger than 32 elements.///     Note that [`Rng::fill`] and `Standard`'s array support are *not* equivalent:///     the former is optimised for integer types (using fewer RNG calls for///     element types smaller than the RNG word size), while the latter supports///     any element type supported by `Standard`./// *   `Option<T>` first generates a `bool`, and if true generates and returns///     `Some(value)` where `value: T`, otherwise returning `None`./// ## Custom implementations/// The [`Standard`] distribution may be implemented for user types as follows:/// # #![allow(dead_code)]/// use rand::distributions::{Distribution, Standard};/// struct MyF32 {///     x: f32,/// impl Distribution<MyF32> for Standard {///     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> MyF32 {///         MyF32 { x: rng.gen() }/// ## Example usage/// let val: f32 = StdRng::from_entropy().sample(Standard);/// samples from `(0, 1]` and `Rng::gen_range(0..1)` which also samples from/// `[0, 1)`. Note that `Open01` uses transmute-based methods which yield 1 bit/// less precision but may perform faster on some architectures (on modern Intel/// CPUs all methods have approximately equal performance).//! Generating random samples from probability distributions//! functionality of the [`Rng`] trait, e.g. [`Rng::gen`] and of course//! [`Rng::sample`].//! occurrence of each value in its sample space.//! distribution used by [`Rng::gen`] and represents the "default" way to//! possible to generate type `T` with [`Rng::gen`], and by extension also//! with the [`random`] function.//! ## Random characters//! # Uniform numeric ranges//! Values may be sampled from this distribution using [`Rng::sample(Range)`] or//! `Uniform` object than to call [`Rng::sample(Range)`].//! documentation in the [`uniform`] module). Doing so enables generation of//! values of type `T` with  [`Rng::sample(Range)`].//! ## Open and half-open ranges//! # Non-uniform sampling//! Sampling a simple true/false outcome with a given probability has a name://! the [`Bernoulli`] distribution (this is used by [`Rng::gen_bool`]).//! For weighted sampling from a sequence of discrete values, use the//! [`WeightedIndex`] distribution.//! This crate no longer includes other non-uniform distributions; instead//! it is recommended that you use either [`rand_distr`] or [`statrs`].//! [`statrs`]: https://crates.io/crates/statrs//! [`random`]: crate::random/// Sample a `u8`, uniformly distributed over ASCII letters and numbers:/// let chars: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect();/// The [`DistString`] trait provides an easier method of generating/// a random `String`, and offers more efficient allocation:/// use rand::distributions::{Alphanumeric, DistString};/// let string = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);/// println!("Random string: {}", string);/// # Passwords/// Users sometimes ask whether it is safe to use a string of random characters/// as a password. In principle, all RNGs in Rand implementing `CryptoRng` are/// suitable as a source of randomness for generating passwords (if they are/// properly seeded), but it is more conservative to only use randomness/// directly from the operating system via the `getrandom` crate, or the/// corresponding bindings of a crypto library./// When generating passwords or keys, it is important to consider the threat/// model and in some cases the memorability of the password. This is out of/// scope of the Rand project, and therefore we defer to the following/// references:/// - [Wikipedia article on Password Strength](https://en.wikipedia.org/wiki/Password_strength)/// - [Diceware for generating memorable passwords](https://en.wikipedia.org/wiki/Diceware)/// Note: the `String` is potentially left with excess capacity; optionally the/// user may call `string.shrink_to_fit()` afterwards./// A distribution to sample items uniformly from a slice./// [`Slice::new`] constructs a distribution referencing a slice and uniformly/// samples references from the items in the slice. It may do extra work up/// front to make sampling of multiple values faster; if only one sample from/// the slice is required, [`SliceRandom::choose`] can be more efficient./// implementations; for example `slice[rng.gen() % slice.len()]` samples from/// the slice, but may be more likely to select numbers in the low range than/// other values./// This distribution samples with replacement; each sample is independent./// Sampling without replacement requires state to be retained, and therefore/// cannot be handled by a distribution; you should instead consider methods/// on [`SliceRandom`], such as [`SliceRandom::choose_multiple`]./// use rand::distributions::Slice;/// let vowels = ['a', 'e', 'i', 'o', 'u'];/// let vowels_dist = Slice::new(&vowels).unwrap();/// let rng = rand::thread_rng();/// // build a string of 10 vowels/// let vowel_string: String = rng///     .sample_iter(&vowels_dist)/// println!("{}", vowel_string);/// assert_eq!(vowel_string.len(), 10);/// assert!(vowel_string.chars().all(|c| vowels.contains(&c)));/// For a single sample, [`SliceRandom::choose`][crate::seq::SliceRandom::choose]/// may be preferred:/// println!("{}", vowels.choose(&mut rng).unwrap())/// [`SliceRandom`]: crate::seq::SliceRandom/// [`SliceRandom::choose`]: crate::seq::SliceRandom::choose/// [`SliceRandom::choose_multiple`]: crate::seq::SliceRandom::choose_multipleEmptySlice/// Create a new `Slice` instance which samples uniformly from the slice./// Returns `Err` if the slice is empty./// Error type indicating that a [`Slice`] distribution was improperly/// constructed with an empty slice.// Copyright 2021 Developers of the Rand project./// work up front to make sampling of multiple values faster. If only one sample/// from the range is required, [`Rng::gen_range`] can be more efficient./// `Uniform::new(low, high)`, i.e., excluding `high`. In particular, care must/// let between = Uniform::from(10..10000);/// for _ in 0..1000 {///     sum += between.sample(&mut rng);/// println!("{}", sum);/// For a single sample, [`Rng::gen_range`] may be preferred:/// println!("{}", rng.gen_range(0..10));/// [`Rng::gen_range`]: Rng::gen_range/// By default this is implemented using/// `UniformSampler::new(low, high).sample(rng)`. However, for some types/// more optimal implementations for single usage may be provided via this/// method (which is the case for integers and floats)./// Results may not be identical./// Note that to use this method in a generic context, the type needs to be/// retrieved via `SampleUniform::Sampler` as follows:/// use rand::{thread_rng, distributions::uniform::{SampleUniform, UniformSampler}};/// # #[allow(unused)]/// fn sample_from_range<T: SampleUniform>(lb: T, ub: T) -> T {///     let mut rng = thread_rng();///     <T as SampleUniform>::Sampler::sample_single(lb, ub, &mut rng)sample_single_inclusive/// and inclusive upper bound `[low, high]`./// `UniformSampler::new_inclusive(low, high).sample(rng)`. However, for/// some types more optimal implementations for single usage may be provided/// via this method./// Generate a sample from the given range./// Check whether the range is empty.SampleRange/// Range that supports generating a single sample efficiently./// Any type implementing this trait can be used to specify the sampled range/// for `Rng::gen_range`.// either ints_to_reject or zone depending on implementation/// For simplicity, we use the same generic struct `UniformInt<X>` for all/// integer types `X`. This gives us only one field type, `X`; to store unsigned/// values of this size, we take use the fact that these conversions are no-ops./// `range = (high - low + 1)`. To avoid bias, we must ensure that the size of/// our sample space, `zone`, is a multiple of `range`; other values must be/// rejected (by replacing with a new random sample)./// As a special case, we use `range = 0` to represent the full range of the/// result type (i.e. for `new_inclusive($ty::MIN, $ty::MAX)`)./// The optimum `zone` is the largest product of `range` which fits in our/// (unsigned) target type. We calculate this by calculating how many numbers we/// must reject: `reject = (MAX + 1) % range = (MAX - range + 1) % range`. Any (large)/// product of `range` will suffice, thus in `sample_single` we multiply by a/// power of 2 via bit-shifting (faster but may cause more rejections)./// The smallest integer PRNGs generate is `u32`. For 8- and 16-bit outputs we/// use `u32` for our `zone` and samples (because it's not slower and because/// it reduces the chance of having to reject a sample). In this case we cannot/// store `zone` in the target type since it is too large, however we know/// `ints_to_reject < range <= $unsigned::MAX`.UniformCharsampler/// The back-end implementing [`UniformSampler`] for `char`./// This differs from integer range sampling since the range `0xD800..=0xDFFF`/// are used for surrogate pairs in UCS and UTF-16, and consequently are not/// valid Unicode code points. We must therefore avoid sampling values in thisCHAR_SURROGATE_START/// UTF-16 surrogate range startCHAR_SURROGATE_LEN/// UTF-16 surrogate range sizechar_to_comp_u32/// Convert `char` to compressed `u32`// if the range is constant, this helps LLVM to do the// calculations at compile-time./// multiply and addition. Values produced this way have what equals 23 bits oftest_chartest_float_overflowtest_float_overflow_singleuniform_distributions_can_be_compared// Copyright 2018-2020 Developers of the Rand project.//! for _ in 0..rng.gen_range(1..=10) {//! struct UniformMyF32(UniformFloat<f32>);//!         UniformMyF32(UniformFloat::<f32>::new(low.borrow().0, high.borrow().0))//!         UniformMyF32(UniformFloat::<f32>::new_inclusive(//!             low.borrow().0,//!             high.borrow().0,//!         ))//!         MyF32(self.0.sample(rng))// False positive: We are following `std` here.// This module exists to provide a deprecation warning which minimises// compile errors, but still fails to compile if ever used.impl_weightalias_method//! Weighted index sampling//! This module is deprecated. Use [`crate::distributions::WeightedIndex`] and//! [`crate::distributions::WeightedError`] instead.// Note that this whole module is only imported if feature="alloc" is enabled.total_weight/// A distribution using weighted sampling of discrete items/// `N` is the number of weights. As an alternative,/// [`rand_distr::weighted_alias`](https://docs.rs/rand_distr/*/rand_distr/weighted_alias/index.html)/// supports `O(1)` sampling, but with much higher initialisation cost./// types, [`Uniform<X>`] doesn't allocate any memory./// exact number depends on the implementation of `Uniform<X>::sample`./// [`Uniform<X>`]: crate::distributions::Uniform/// [`RngCore`]: crate::RngCoreupdate_weights/// Update a subset of weights, without changing the number of weights./// `new_weights` must be sorted by the index./// Using this method instead of `new` might be more efficient if only a small number of/// weights is modified. No allocations are performed, unless the weight type `X` uses/// allocation internally./// In case of error, `self` is not modified.test_accepting_nantest_update_weightsweighted_index_distributions_can_be_compared/// The provided weight collection contains no items./// A weight is either less than zero, greater than the supported maximum,/// NaN, or otherwise invalid./// All items in the provided weight collection are zero.TooMany/// Too many weights are provided (length greater than `u32::MAX`)/// # Provided implementations/// The following types have provided implementations that/// Also supported is the generation of the following///     types and tends to be faster for `u32` and smaller types./// Construct a deterministic RNG with the given seed//! For the user guide and further documentation, please read//! # let mut r = StdRng::from_rng(thread_rng()).unwrap();/// # Arrays and tuples/// The `rng.gen()` method is able to generate arrays (up to 32 elements)/// and tuples (up to 12 elements), so long as all element types can be/// generated./// When using `rustc` ≥ 1.51, enable the `min_const_gen` feature to support/// arrays larger than 32 elements./// For arrays of integers, especially for those with small element types/// (< 64 bit), it will likely be faster to instead use [`Rng::fill`]./// let tuple: (u8, i32, char) = rng.gen(); // arbitrary tuple support/// let arr1: [f32; 32] = rng.gen();        // array construction/// let mut arr2 = [0u8; 128];/// rng.fill(&mut arr2);                    // array fill/// Generate a random value in the given range./// Only `gen_range(low..high)` and `gen_range(low..=high)` are supported./// // Exclusive range/// let n: u32 = rng.gen_range(0..10);/// let m: f64 = rng.gen_range(-40.0..1.3e5);/// // Inclusive range/// let n: u32 = rng.gen_range(0..=10);/// Note that this function takes its arguments by value. This works since/// `(&mut R): Rng where R: Rng` and/// `(&D): Distribution where D: Distribution`,/// however borrowing is not automatic hence `rng.sample_iter(...)` may/// need to be replaced with `(&mut rng).sample_iter(...)`./// let v: Vec<f32> = (&mut rng).sample_iter(Standard).take(16).collect();/// let s: String = (&mut rng).sample_iter(Alphanumeric)/// println!("{:?}", (&mut rng).sample_iter(Standard).take(5)/// let mut roll_die = (&mut rng).sample_iter(die_range);/// Fill any type implementing [`Fill`] with random data/// The distribution is expected to be uniform with portable results, but/// this cannot be guaranteed for third-party implementations./// This is identical to [`try_fill`] except that it panics on error./// This is identical to [`fill`] except that it forwards errors./// [`Bernoulli`]: distributions::Bernoulli/// The basic pattern is `fn foo<R: Rng + ?Sized>(rng: &mut R)`. Some///   type-erased references; i.e. `foo(r)` where `r: &mut dyn RngCore`. Without/// Fill self with random data/// Types which may be filled with random data/// This trait allows arrays to be efficiently filled with random data./// Implementations are expected to be portable across machines unless/// clearly documented otherwise (see the/// [Chapter on Portability](https://rust-random.github.io/book/portability.html)).impl_fill_eachimpl_fillimpl_fill_arraystest_gen_range_inttest_gen_range_float//! [`Rng`] trait/// [`OsRng`]: crate::rngs::OsRng/// `ReadRng` error type/// - When a process is forked on UNIX, the RNGs in both the parent and child///   processes will be reseeded just before the next call to///   [`BlockRngCore::generate`], i.e. "soon". For ChaCha and Hc128 this is a///   maximum of fifteen `u32` values before reseeding./// It is recommended that a `ReseedingRng` (including `ThreadRng`) not be used/// from a fork handler./// Use `OsRng` or `getrandom`, or defer your use of the RNG until later./// use rand_chacha::ChaCha20Core; // Internal part of ChaChaRng that/// let prng = ChaCha20Core::from_entropy();/// let mut reseeding_rng = ReseedingRng::new(prng, 0, OsRng);xoshiro256plusplus//! Random number generators and adapters//! ## Background: Random number generators (RNGs)//! Computers cannot produce random numbers from nowhere. We classify//! random number generators as follows://! -   "True" random number generators (TRNGs) use hard-to-predict data sources//!     (e.g. the high-resolution parts of event timings and sensor jitter) to//!     harvest random bit-sequences, apply algorithms to remove bias and//!     estimate available entropy, then combine these bits into a byte-sequence//!     or an entropy pool. This job is usually done by the operating system or//!     a hardware generator (HRNG).//! -   "Pseudo"-random number generators (PRNGs) use algorithms to transform a//!     seed into a sequence of pseudo-random numbers. These generators can be//!     fast and produce well-distributed unpredictable random numbers (or not).//!     They are usually deterministic: given algorithm and seed, the output//!     sequence can be reproduced. They have finite period and eventually loop;//!     with many algorithms this period is fixed and can be proven sufficiently//!     long, while others are chaotic and the period depends on the seed.//! -   "Cryptographically secure" pseudo-random number generators (CSPRNGs)//!     are the sub-set of PRNGs which are secure. Security of the generator//!     relies both on hiding the internal state and using a strong algorithm.//! ## Traits and functionality//! All RNGs implement the [`RngCore`] trait, as a consequence of which the//! [`Rng`] extension trait is automatically implemented. Secure RNGs may//! additionally implement the [`CryptoRng`] trait.//! All PRNGs require a seed to produce their random number sequence. The//! [`SeedableRng`] trait provides three ways of constructing PRNGs://! -   `from_seed` accepts a type specific to the PRNG//! -   `from_rng` allows a PRNG to be seeded from any other RNG//! -   `seed_from_u64` allows any PRNG to be seeded from a `u64` insecurely//! -   `from_entropy` securely seeds a PRNG from fresh entropy//! Use the [`rand_core`] crate when implementing your own RNGs.//! ## Our generators//! This crate provides several random number generators://! -   [`OsRng`] is an interface to the operating system's random number//!     source. Typically the operating system uses a CSPRNG with entropy//!     provided by a TRNG and some type of on-going re-seeding.//! -   [`ThreadRng`], provided by the [`thread_rng`] function, is a handle to a//!     thread-local CSPRNG with periodic seeding from [`OsRng`]. Because this//!     is local, it is typically much faster than [`OsRng`]. It should be//!     secure, though the paranoid may prefer [`OsRng`].//! -   [`StdRng`] is a CSPRNG chosen for good performance and trust of security//!     (based on reviews, maturity and usage). The current algorithm is ChaCha12,//!     which is well established and rigorously analysed.//!     [`StdRng`] provides the algorithm used by [`ThreadRng`] but without//!     periodic reseeding.//! -   [`SmallRng`] is an **insecure** PRNG designed to be fast, simple, require//!     little memory, and have good output quality.//! The algorithms selected for [`StdRng`] and [`SmallRng`] may change in any//! release and may be platform-dependent, therefore they should be considered//! **not reproducible**.//! ## Additional generators//! **TRNGs**: The [`rdrand`] crate provides an interface to the RDRAND and//! RDSEED instructions available in modern Intel and AMD CPUs.//! The [`rand_jitter`] crate provides a user-space implementation of//! entropy harvesting from CPU timer jitter, but is very slow and has//! [security issues](https://github.com/rust-random/rand/issues/699).//! **PRNGs**: Several companion crates are available, providing individual or//! families of PRNG algorithms. These provide the implementations behind//! [`StdRng`] and [`SmallRng`] but can also be used directly, indeed *should*//! be used directly when **reproducibility** matters.//! Some suggestions are: [`rand_chacha`], [`rand_pcg`], [`rand_xoshiro`].//! A full list can be found by searching for crates with the [`rng` tag].//! [`Rng`]: crate::Rng//! [`RngCore`]: crate::RngCore//! [`CryptoRng`]: crate::CryptoRng//! [`SeedableRng`]: crate::SeedableRng//! [`thread_rng`]: crate::thread_rng//! [`rdrand`]: https://crates.io/crates/rdrand//! [`rand_jitter`]: https://crates.io/crates/rand_jitter//! [`rand_chacha`]: https://crates.io/crates/rand_chacha//! [`rand_pcg`]: https://crates.io/crates/rand_pcg//! [`rand_xoshiro`]: https://crates.io/crates/rand_xoshiro//! [`rng` tag]: https://crates.io/keywords/rngXoshiro256PlusPlus/// A small-state, fast non-crypto PRNG/// `SmallRng` may be a good choice when a PRNG with small state, cheap/// initialization, good statistical quality and good performance are required./// Note that depending on the application, [`StdRng`] may be faster on many/// modern platforms while providing higher-quality randomness. Furthermore,/// `SmallRng` is **not** a good choice when:/// - Security against prediction is important. Use [`StdRng`] instead./// - Seeds with many zeros are provided. In such cases, it takes `SmallRng`///   about 10 samples to produce 0 and 1 bits with equal probability. Either///   provide seeds with an approximately equal number of 0 and 1 (for example///   by using [`SeedableRng::from_entropy`] or [`SeedableRng::seed_from_u64`]),///   or use [`StdRng`] instead./// The algorithm is deterministic but should not be considered reproducible/// due to dependence on platform and possible replacement in future/// library versions. For a reproducible generator, use a named PRNG from an/// external crate, e.g. [rand_xoshiro] or [rand_chacha]./// Refer also to [The Book](https://rust-random.github.io/book/guide-rngs.html)./// The PRNG algorithm in `SmallRng` is chosen to be efficient on the current/// platform, without consideration for cryptography or security. The size of/// its state is much smaller than [`StdRng`]. The current algorithm is/// `Xoshiro256PlusPlus` on 64-bit platforms and `Xoshiro128PlusPlus` on 32-bit/// platforms. Both are also implemented by the [rand_xoshiro] crate./// Initializing `SmallRng` with a random seed can be done using [`SeedableRng::from_entropy`]:/// use rand::{Rng, SeedableRng};/// let rngs: Vec<SmallRng> = (0..10)///     .map(|_| SmallRng::from_rng(&mut thread_rng).unwrap())/// [rand_xoshiro]: https://crates.io/crates/rand_xoshiroChaCha12CoreChaCha12Rng/// The current algorithm used is the ChaCha block cipher with 12 rounds. Please/// see this relevant [rand issue] for the discussion. This may change as new /// evidence of cipher security and performance becomes available./// due to dependence on configuration and possible replacement in future/// library versions. For a secure reproducible generator, we recommend use of/// the [rand_chacha] crate directly./// [rand issue]: https://github.com/rust-random/rand/issues/932// Number of generated bytes after which to reseed `ThreadRng`.// According to benchmarks, reseeding has a noticeable impact with thresholds// of 32 kB and less. We choose 64 kB to avoid significant overhead.// Rc is explicitly !Send and !Sync/// A reference to the thread-local generator/// An instance can be obtained via [`thread_rng`] or via `ThreadRng::default()`./// This handle is safe to use everywhere (including thread-local destructors),/// though it is recommended not to use inside a fork handler./// The handle cannot be passed between threads (is not `Send` or `Sync`)./// `ThreadRng` uses the same PRNG as [`StdRng`] for security and performance/// and is automatically seeded from [`OsRng`]./// Unlike `StdRng`, `ThreadRng` uses the  [`ReseedingRng`] wrapper to reseed/// the PRNG from fresh entropy every 64 kiB of random data as well as after a/// fork on Unix (though not quite immediately; see documentation of/// [`ReseedingRng`])./// Note that the reseeding is done as an extra precaution against side-channel/// attacks and mis-use (e.g. if somehow weak entropy were supplied initially)./// The PRNG algorithms used are assumed to be secure./// `ThreadRng::default()` equivalent.next_u64_via_u32fill_bytes_via_nextXoshiro128PlusPlus/// A xoshiro128++ random number generator./// The xoshiro128++ algorithm is not suitable for cryptographic purposes, but/// is very fast and has excellent statistical properties./// The algorithm used here is translated from [the `xoshiro128plusplus.c`/// reference source code](http://xoshiro.di.unimi.it/xoshiro128plusplus.c) by/// David Blackman and Sebastiano Vigna./// Create a new `Xoshiro128PlusPlus`.  If `seed` is entirely 0, it will be/// mapped to a different seed.seed_from_u64/// Create a new `Xoshiro128PlusPlus` from a `u64` seed./// This uses the SplitMix64 generator internally./// A xoshiro256++ random number generator./// The xoshiro256++ algorithm is not suitable for cryptographic purposes, but/// The algorithm used here is translated from [the `xoshiro256plusplus.c`/// reference source code](http://xoshiro.di.unimi.it/xoshiro256plusplus.c) by/// Create a new `Xoshiro256PlusPlus`.  If `seed` is entirely 0, it will be/// Create a new `Xoshiro256PlusPlus` from a `u64` seed./// Returns `true` if the length is 0.sample_weighted/// return them in an arbitrary order (there is no guarantee of shuffling or/// ordering). The weights are to be provided by the input function `weights`,/// which will be called once for each index./// This implementation uses `O(length + amount)` space and `O(length)` time/// if the "nightly" feature is enabled, or `O(length)` space and/// `O(length + amount * log length)` time otherwise.sample_efraimidis_spirakis/// This implementation uses the algorithm described by Efraimidis and Spirakis/// in this paper: https://doi.org/10.1016/j.ipl.2005.11.003/// It uses `O(length + amount)` space and `O(length)` time if the/// "nightly" feature is enabled, or `O(length)` space and `O(length/// + amount * log length)` time otherwise./// This function  is generic over X primarily so that results are value-stable/// over 32-bit and 64-bit platforms.test_sample_weightedvalue_stability_sample//! Low-level API for sampling indices/// For slices, complexity is `O(1)`./// Chooses `amount` elements from the slice at random, without repetition,/// and in random order. The returned iterator is appropriate both for/// collection into a `Vec` and filling an existing buffer (see example)./// In case this API is not sufficiently flexible, use [`index::sample`]./// For slices, complexity is the same as [`index::sample`]./// Similar to [`choose`], but where the likelihood of each outcome may be/// The specified function `weight` maps each item `x` to a relative/// For slices of length `n`, complexity is `O(n)`./// See also [`choose_weighted_mut`], [`distributions::weighted`]./// [`choose_weighted_mut`]: SliceRandom::choose_weighted_mut/// [`distributions::weighted`]: crate::distributions::weighted/// Similar to [`choose_mut`], but where the likelihood of each outcome may/// be specified./// See also [`choose_weighted`], [`distributions::weighted`].choose_multiple_weighted/// Similar to [`choose_multiple`], but where the likelihood of each element's/// inclusion in the output may be specified. The elements are returned in an/// arbitrary, unspecified order./// If all of the weights are equal, even if they are all zero, each element has/// an equal likelihood of being selected./// The complexity of this method depends on the feature `partition_at_index`./// If the feature is enabled, then for slices of length `n`, the complexity/// is `O(n)` space and `O(n)` time. Otherwise, the complexity is `O(n)` space and/// `O(n * log amount)` time./// // First Draw * Second Draw = total odds/// // -----------------------/// // (50% * 50%) + (25% * 67%) = 41.7% chance that the output is `['a', 'b']` in some order./// // (50% * 50%) + (25% * 67%) = 41.7% chance that the output is `['a', 'c']` in some order./// // (25% * 33%) + (25% * 33%) = 16.6% chance that the output is `['b', 'c']` in some order./// println!("{:?}", choices.choose_multiple_weighted(&mut rng, 2, |item| item.1).unwrap().collect::<Vec<_>>());/// [`choose_multiple`]: SliceRandom::choose_multiple// Note: this is feature-gated on std due to usage of f64::powf.// If necessary, we may use alloc+libm as an alternative (see PR #1089)./// For slices, complexity is `O(m)` where `m = amount`./// This trait is implemented on all `[T]` slice types, providing several/// methods for choosing and shuffling elements. You must `use` this trait:/// let mut bytes = "Hello, random!".to_string().into_bytes();/// bytes.shuffle(&mut rng);/// let str = String::from_utf8(bytes).unwrap();/// println!("{}", str);/// Example output (non-deterministic):/// l,nmroHado !le/// Choose one element at random from the iterator./// This method uses [`Iterator::size_hint`] for optimisation. With an/// accurate hint and where [`Iterator::nth`] is a constant-time operation/// this method can offer `O(1)` performance. Where no size hint is/// available, complexity is `O(n)` where `n` is the iterator length./// Partial hints (where `lower > 0`) also improve performance./// Note that the output values and the number of RNG samples used/// depends on size hints. In particular, `Iterator` combinators that don't/// change the values yielded but change the size hints may result in/// `choose` returning different elements. If you want consistent results/// and RNG usage consider using [`IteratorRandom::choose_stable`].choose_stable/// This method is very similar to [`choose`] except that the result/// only depends on the length of the iterator and the values produced by/// `rng`. Notably for any iterator of a given length this will make the/// same requests to `rng` and if the same sequence of values are produced/// the same index will be selected from `self`. This may be useful if you/// need consistent results no matter what type of iterator you are working/// with. If you do not need this stability prefer [`choose`]./// Note that this method still uses [`Iterator::size_hint`] to skip/// constructing elements where possible, however the selection and `rng`/// calls are the same in the face of this optimization. If you want to/// force every element to be created regardless call `.inspect(|e| ())`./// [`choose`]: IteratorRandom::choose/// Collects values at random from the iterator into a supplied buffer/// until that buffer is filled./// Returns the number of elements added to the buffer. This equals the length/// of the buffer unless the iterator contains insufficient elements, in which/// case this equals the number of elements available./// For slices, prefer [`SliceRandom::choose_multiple`]./// This trait is implemented on all iterators `I` where `I: Iterator + Sized`/// and provides methods for/// choosing one or more elements. You must `use` this trait:/// use rand::seq::IteratorRandom;/// let faces = "😀😎😐😕😠😢";/// println!("I am {}!", faces.chars().choose(&mut rng).unwrap());/// I am 😀!/// An iterator over multiple slice elements./// This struct is created by/// [`SliceRandom::choose_multiple`](trait.SliceRandom.html#tymethod.choose_multiple).// Sample a number uniformly between 0 and `ubound`. Uses 32-bit sampling where// possible, primarily in order to produce the same output on 32-bit and 64-bit// platforms.value_stability_slicetest_iterator_choose_stabletest_iterator_choose_stable_stabilityvalue_stability_choosevalue_stability_choose_stablevalue_stability_choose_multipletest_multiple_weighted_edge_casestest_multiple_weighted_distributions//! Sequence-related functionality//! This module provides://! *   [`SliceRandom`] slice sampling and mutation//! *   [`IteratorRandom`] iterator sampling//! *   [`index::sample`] low-level API to choose multiple indices from//!     `0..length`//! Also see://! *   [`crate::distributions::WeightedIndex`] distribution which provides//!     weighted index sampling.//! In order to make results reproducible across 32-64 bit architectures, all//! `usize` indices are sampled as a `u32` where possible (also providing a//! small performance boost in some cases)./// The [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution) `Bernoulli(p)`./// This distribution describes a single boolean random variable, which is true/// with probability `p` and false with probability `1 - p`./// It is a special case of the Binomial distribution with `n = 1`./// # Plot/// The following plot shows the Bernoulli distribution with `p = 0.1`,/// `p = 0.5`, and `p = 0.9`./// ![Bernoulli distribution](https://raw.githubusercontent.com/rust-random/charts/main/charts/bernoulli.svg)/// use rand::distr::{Bernoulli, Distribution};/// let v = d.sample(&mut rand::rng());/// Error type returned from [`Bernoulli::new`]./// Returns the probability (`p`) of the distribution./// This value may differ slightly from the input due to loss of precision.//! The Bernoulli distribution `Bernoulli(p)`./// use rand::distr::{Distribution, Alphanumeric, Uniform, StandardUniform};/// let mut rng = rand::rng();/// let v: Vec<f32> = StandardUniform.sample_iter(&mut rng).take(16).collect();/// let die_range = Uniform::new_inclusive(1, 6).unwrap();/// Map sampled values to type `S`/// use rand::distr::{Distribution, Uniform};/// let die = Uniform::new_inclusive(1, 6).unwrap();/// while !even_number.sample(&mut rand::rng()) {/// An iterator over a [`Distribution`]/// This iterator yields random values of type `T` with distribution `D`/// from a random generator of type `R`./// Construct this `struct` using [`Distribution::sample_iter`] or/// [`Rng::sample_iter`]. It is also used by [`Rng::random_iter`] and/// [`crate::random_iter`]./// A [`Distribution`] which maps sampled values to type `S`/// Note: implementations may leave `string` with excess capacity. If this/// is undesirable, consider calling [`String::shrink_to_fit`] after this/// Generate a [`String`] of `len` random chars/// Note: implementations may leave the string with excess capacity. If thisSampleString/// Sample or extend a [`String`]/// Helper methods to extend a [`String`] or sample a new [`String`].IntAsSIMDStandardUniform/// See also: [`StandardUniform`] which samples from `[0, 1)`, [`Open01`]/// use rand::distr::OpenClosed01;/// let val: f32 = rand::rng().sample(OpenClosed01);/// [`StandardUniform`]: crate::distr::StandardUniform/// [`Open01`]: crate::distr::Open01/// [`Uniform`]: crate::distr::uniform::Uniform/// See also: [`StandardUniform`] which samples from `[0, 1)`, [`OpenClosed01`]/// use rand::distr::Open01;/// let val: f32 = rand::rng().sample(Open01);/// [`OpenClosed01`]: crate::distr::OpenClosed01//! The implementations of the `StandardUniform` distribution for integer types./// The Standard Uniform distribution/// This [`Distribution`] is the *standard* parameterization of [`Uniform`]. Bounds/// are selected according to the output type./// * Integers (`i8`, `i32`, `u64`, etc.) are uniformly distributed///   over the whole range of the type (thus each possible value may be sampled///   with equal probability)./// * `char` is uniformly distributed over all Unicode scalar values, i.e. all///   For some uses, the [`Alphanumeric`] or [`Alphabetic`] distribution will be more///   appropriate./// * `bool` samples `false` or `true`, each with probability 0.5./// * Floating point types (`f32` and `f64`) are uniformly distributed in the///   half-open range `[0, 1)`. See also the [notes below](#floating-point-implementation)./// * Wrapping integers ([`Wrapping<T>`]), besides the type identical to their/// * Non-zero integers ([`NonZeroU8`]), which are like their normal integer///   variants but cannot sample zero./// The `StandardUniform` distribution also supports generation of the following/// * Tuples (up to 12 elements): each element is sampled sequentially and///   independently (thus, assuming a well-behaved RNG, there is no correlation///   between elements)./// * Arrays `[T; n]` where `T` is supported. Each element is sampled///   sequentially and independently. Note that for small `T` this usually///   results in the RNG discarding random bits; see also [`Rng::fill`] which///   offers a more efficient approach to filling an array of integer types///   with random data./// * SIMD types (requires [`simd_support`] feature) like x86's [`__m128i`]///   and `std::simd`'s [`u32x4`], [`f32x4`] and [`mask32x4`] types are///   effectively arrays of integer or floating-point types. Each lane is///   sampled independently, potentially with more efficient random-bit-usage///   (and a different resulting value) than would be achieved with sequential///   sampling (as with the array types above)./// The [`StandardUniform`] distribution may be implemented for user types as follows:/// use rand::distr::{Distribution, StandardUniform};/// impl Distribution<MyF32> for StandardUniform {///         MyF32 { x: rng.random() }/// use rand::distr::StandardUniform;/// let val: f32 = rand::rng().sample(StandardUniform);/// The floating point implementations for `StandardUniform` generate a random value in/// samples from `(0, 1]` and `Rng::random_range(0..1)` which also samples from/// [`Wrapping<T>`]: std::num::Wrapping/// [`NonZeroU8`]: std::num::NonZeroU8/// [`__m128i`]: https://doc.rust-lang.org/core/arch/x86/struct.__m128i.html/// [`u32x4`]: std::simd::u32x4/// [`f32x4`]: std::simd::f32x4/// [`mask32x4`]: std::simd::mask32x4/// [`simd_support`]: https://github.com/rust-random/rand#crate-features//! functionality of the [`Rng`] trait, e.g. [`Rng::random`] and of course//! # The Standard Uniform distribution//! The [`StandardUniform`] distribution is important to mention. This is the//! distribution used by [`Rng::random`] and represents the "default" way to//! [`StandardUniform`] for more details.//! Implementing [`Distribution<T>`] for [`StandardUniform`] for user types `T` makes it//! possible to generate type `T` with [`Rng::random`], and by extension also//! ## Other standard uniform distributions//! numbers of the `char` type; in contrast [`StandardUniform`] may sample any valid//! There's also an [`Alphabetic`] distribution which acts similarly to [`Alphanumeric`] but//! doesn't include digits.//! For floats (`f32`, `f64`), [`StandardUniform`] samples from `[0, 1)`. Also//! provided are [`Open01`] (samples from `(0, 1)`) and [`OpenClosed01`]//! (samples from `(0, 1]`). No option is provided to sample from `[0, 1]`; it//! is suggested to use one of the above half-open ranges since the failure to//! sample a value which would have a low chance of being sampled anyway is//! rarely an issue in practice.//! # Parameterized Uniform distributions//! The [`Uniform`] distribution provides uniform sampling over a specified//! range on a subset of the types supported by the above distributions.//! Implementations support single-value-sampling via//! [`Rng::random_range(Range)`](Rng::random_range).//! Where a fixed (non-`const`) range will be sampled many times, it is likely//! faster to pre-construct a [`Distribution`] object using//! [`Uniform::new`], [`Uniform::new_inclusive`] or `From<Range>`.//! the [`Bernoulli`] distribution (this is used by [`Rng::random_bool`]).//! For weighted sampling of discrete values see the [`weighted`] module./// use rand::distr::Alphanumeric;/// The [`SampleString`] trait provides an easier method of generating/// a random [`String`], and offers more efficient allocation:/// use rand::distr::{Alphanumeric, SampleString};/// let string = Alphanumeric.sample_string(&mut rand::rng(), 16);/// Sample a [`u8`], uniformly distributed over letters:/// a-z and A-Z./// You're able to generate random Alphabetic characters via mapping or via the/// [`SampleString::sample_string`] method like so:/// use rand::distr::{Alphabetic, SampleString};/// // Manual mapping/// let chars: String = (0..7).map(|_| rng.sample(Alphabetic) as char).collect();/// // Using [`SampleString::sample_string`]/// let string = Alphabetic.sample_string(&mut rand::rng(), 16);/// Refer to [`Alphanumeric#Passwords`]./// Implement `Distribution<(A, B, C, ...)> for StandardUniform`, using the list of/// identifiers/// Looping wrapper for `tuple_impl`. Given (A, B, C), it also generates/// implementations for (A, B) and (A,)//! The implementations of the `StandardUniform` distribution for other built-in types.UniformUsizenum_choicesChoose/// A distribution to uniformly sample elements of a slice/// Like [`IndexedRandom::choose`], this uniformly samples elements of a slice/// without modification of the slice (so called "sampling with replacement")./// This distribution object may be a little faster for repeated sampling (but/// slower for small numbers of samples)./// Since this is a distribution, [`Rng::sample_iter`] and/// [`Distribution::sample_iter`] may be used, for example:/// use rand::distr::{Distribution, slice::Choose};/// let vowels_dist = Choose::new(&vowels).unwrap();/// let vowel_string: String = vowels_dist///     .sample_iter(&mut rand::rng())/// For a single sample, [`IndexedRandom::choose`] may be preferred:/// use rand::seq::IndexedRandom;/// println!("{}", vowels.choose(&mut rng).unwrap());/// [`IndexedRandom::choose`]: crate::seq::IndexedRandom::choose/// [`Rng::sample_iter`]: crate::Rng::sample_iter/// Create a new `Choose` instance which samples uniformly from the slice./// Returns error [`Empty`] if the slice is empty./// Returns the count of choices in this distribution/// Error: empty slice/// This error is returned when [`Choose::new`] is given an empty slice.//! Distributions over slices"uniform_float.rs""uniform_int.rs""uniform_other.rs"EmptyRange/// `low > high`, or equal in case of exclusive range.NonFinite/// Input or range `high - low` is non-finite. Not relevant to integer types./// Error type returned from [`Uniform::new`] and `new_inclusive`./// distribution sampling from the given `low` and `high` limits. `Uniform` may/// also be constructed via [`TryFrom`] as in `Uniform::try_from(1..=6).unwrap()`./// Constructors may do extra work up front to allow faster sampling of multiple/// values. Where only a single sample is required it is suggested to use/// [`Rng::random_range`] or one of the `sample_single` methods instead./// the full range of integer types, this should have comparable performance to/// the [`StandardUniform`](super::StandardUniform) distribution./// - `char` ([`UniformChar`]): samples a range over the implementation for `u32`/// - `f32`, `f64` ([`UniformFloat`]): samples approximately uniformly within a///   range; bias may be present in the least-significant bit of the significand///   and the limits of the input range may be sampled even when an open///   (exclusive) range is used/// - Integer types ([`UniformInt`]) may show a small bias relative to the///   expected uniform distribution of output. In the worst case, bias affects///   1 in `2^n` samples where n is 56 (`i8` and `u8`), 48 (`i16` and `u16`), 96///   (`i32` and `u32`), 64 (`i64` and `u64`), 128 (`i128` and `u128`).///   The `unbiased` feature flag fixes this bias./// - `usize` ([`UniformUsize`]) is handled specially, using the `u32`///   implementation where possible to enable portable results across 32-bit and///   64-bit CPU architectures./// - `Duration` ([`UniformDuration`]): samples a range over the implementation///   for `u32` or `u64`/// - SIMD types (requires [`simd_support`] feature) like x86's [`__m128i`]///   sampled independently from its own range, potentially with more efficient///   random-bit-usage than would be achieved with sequential sampling./// let between = Uniform::try_from(10..10000).unwrap();/// For a single sample, [`Rng::random_range`] may be preferred:/// println!("{}", rng.random_range(0..10));/// [`Rng::random_range`]: Rng::random_range/// Create a new `Uniform` instance, which samples uniformly from the half/// open range `[low, high)` (excluding `high`)./// For discrete types (e.g. integers), samples will always be strictly less/// than `high`. For (approximations of) continuous types (e.g. `f32`, `f64`),/// samples may equal `high` due to loss of precision but may not be/// greater than `high`./// Fails if `low >= high`, or if `low`, `high` or the range `high - low` is/// non-finite. In release mode, only the range is checked./// Create a new `Uniform` instance, which samples uniformly from the closed/// range `[low, high]` (inclusive)./// Fails if `low > high`, or if `low`, `high` or the range `high - low` is/// [module documentation]: crate::distr::uniform/// Construct self, with inclusive lower bound and exclusive upper bound `[low, high)`./// Usually users should not call this directly but prefer to use/// [`Uniform::new`]./// [`Uniform::new_inclusive`]./// use rand::distr::uniform::{SampleUniform, UniformSampler};///     let mut rng = rand::rng();///     <T as SampleUniform>::Sampler::sample_single(lb, ub, &mut rng).unwrap()/// only for [`SampleUniform`] and references to [`SampleUniform`]/// in order to resolve ambiguity issues./// for `Rng::random_range`.impl_sample_range_u//! e.g. `Uniform::new_inclusive(1, 6).unwrap()` can sample integers from 1 to 6, like a//! standard die. [`Rng::random_range`] is implemented over [`Uniform`].//! use rand::distr::Uniform;//! let mut rng = rand::rng();//! let side = Uniform::new(-10.0, 10.0).unwrap();//! for _ in 0..rng.random_range(1..=10) {//! Those methods should include an assertion to check the range is valid (i.e.//! The `new`, `new_inclusive`, `sample_single` and `sample_single_inclusive`//! functions use arguments of//! type `SampleBorrow<X>` to support passing in values by reference or//! use rand::distr::uniform::{Uniform, SampleUniform,//!         UniformSampler, UniformFloat, SampleBorrow, Error};//!     fn new<B1, B2>(low: B1, high: B2) -> Result<Self, Error>//!         UniformFloat::<f32>::new(low.borrow().0, high.borrow().0).map(UniformMyF32)//!     fn new_inclusive<B1, B2>(low: B1, high: B2) -> Result<Self, Error>//!         UniformFloat::<f32>::new_inclusive(low.borrow().0, high.borrow().0).map(UniformMyF32)//! let uniform = Uniform::new(low, high).unwrap();//! let x = uniform.sample(&mut rand::rng());//! [`SampleUniform`]: crate::distr::uniform::SampleUniform//! [`UniformSampler`]: crate::distr::uniform::UniformSampler//! [`UniformInt`]: crate::distr::uniform::UniformInt//! [`UniformFloat`]: crate::distr::uniform::UniformFloat//! [`UniformDuration`]: crate::distr::uniform::UniformDuration//! [`SampleBorrow::borrow`]: crate::distr::uniform::SampleBorrow::borrow/// `UniformFloat` implementations convert RNG output to a float in the range/// `[1, 2)` via transmutation, map this to `[0, 1)`, then scale and translate/// to the desired range. Values produced this way have what equals 23 bits of/// random digits for an `f32` and 52 for an `f64`./// # Bias and range errors/// Bias may be expected within the least-significant bit of the significand./// It is not guaranteed that exclusive limits of a range are respected; i.e./// when sampling the range `[a, b)` it is not guaranteed that `b` is never/// [`Uniform`]: super::Uniformr" Construct, reducing `scale` as required to ensure that rounding"r" can never yield values greater than `high`."r" Note: though it may be tempting to use a variant of this method"r" to ensure that samples from `[low, high)` are always strictly"r" less than `high`, this approach may be very slow where"r" `scale.abs()` is much smaller than `high.abs()`"r" (example: `low=0.99999999997819644, high=1.`)."new_bounded//! `UniformFloat` implementation// #[cfg(feature = "simd_support")]// use core::simd::{LaneCount, SupportedLaneCount};// effectively 2.pow(max(64, uty_bits)) % range/// `ints_to_reject < range <= $uty::MAX`./// # Bias/// Unless the `unbiased` feature flag is used, outputs may have a small bias./// In the worst case, bias affects 1 in `2^n` samples where n is/// 56 (`i8` and `u8`), 48 (`i16` and `u16`), 96 (`i32` and `u32`), 64 (`i64`/// and `u64`), 128 (`i128` and `u128`).r" Sample from distribution, Lemire's method, unbiased"r" Sample single value, Canon's method, biased"r" In the worst case, bias affects 1 in `2^n` samples where n is"r" 56 (`i8`), 48 (`i16`), 96 (`i32`), 64 (`i64`), 128 (`i128`)."/// The lowest possible value./// The number of possible values. `0` has a special meaning: all./// Threshold used when sampling to obtain a uniform distribution.mode64/// Whether the largest possible value is greater than `u32::MAX`.// Handle missing field when deserializing on 64-bit an object serialized// on 32-bit. Can be removed when switching to a custom deserializer./// The back-end implementing [`UniformSampler`] for `usize`./// Sampling a `usize` value is usually used in relation to the length of an/// array or other memory structure, thus it is reasonable to assume that the/// vast majority of use-cases will have a maximum size under [`u32::MAX`]./// In part to optimise for this use-case, but mostly to ensure that results/// are portable across 32-bit and 64-bit architectures (as far as is possible),/// this implementation will use 32-bit sampling when possible.// To be able to deserialize on 32-bit we need to replace this with a custom// implementation of the Deserialize trait, to be able to:// - panic when `mode64` is `true` on 32-bit,// - assign the default value to `mode64` when it's missing on 64-bit,// - panic when the `usize` fields are greater than `u32::MAX` on 32-bit.//! `UniformInt` implementation//! `UniformChar`, `UniformDuration` implementations/// Representation of 0checked_add_assign/// Checked addition/// -   `Result::Ok`: On success, `v` is added to `self`/// -   `Result::Err`: Returns an error when `Self` cannot represent the///     result of `self + v` (i.e. overflow). The value of `self` should be///     discarded./// Bounds on a weight/// See usage in [`WeightedIndex`].impl_weight_intimpl_weight_float/// The input weight sequence is empty, too long, or wrongly ordered/// A weight is negative, too large for the distribution, or not a valid numberInsufficientNonZero/// Not enough non-zero weights are available to sample values/// When attempting to sample a single value this implies that all weights/// are zero. When attempting to sample `amount` values this implies that/// less than `amount` weights are greater than zero./// Overflow when calculating the sum of weights/// Invalid weight errors/// This type represents errors from [`WeightedIndex::new`],/// [`WeightedIndex::update_weights`] and other weighted distributions.// Marked non_exhaustive to allow a new error code in the solution to #1476.//! Weighted (index) sampling//! Primarily, this module houses the [`WeightedIndex`] distribution.//! See also [`rand_distr::weighted`] for alternative implementations supporting//! potentially-faster sampling or a more easily modifiable tree structure.//! [`rand_distr::weighted`]: https://docs.rs/rand_distr/latest/rand_distr/weighted/index.html/// A distribution using weighted sampling of discrete items./// weight of the element. The weights can use any type `X` for which an/// implementation of [`Uniform<X>`] exists. The implementation guarantees that/// elements with zero weight are never picked, even when the weights are/// floating point numbers./// See also [`rand_distr::weighted`] for alternative implementations supporting/// potentially-faster sampling or a more easily modifiable tree structure./// contains an instance of `X::Sampler`, this might cause additional allocations,/// though for primitive types, [`Uniform<X>`] doesn't allocate any memory./// use rand::distr::weighted::WeightedIndex;/// let items = [('a', 0.0), ('b', 3.0), ('c', 7.0)];/// [`Uniform<X>`]: crate::distr::Uniform/// [`rand_distr::weighted`]: https://docs.rs/rand_distr/latest/rand_distr/weighted/index.html/// Error cases:/// -   [`Error::InvalidInput`] when the iterator `weights` is empty./// -   [`Error::InvalidWeight`] when a weight is not-a-number or negative./// -   [`Error::InsufficientNonZero`] when the sum of all weights is zero./// -   [`Error::Overflow`] when the sum of all weights overflows./// [`Uniform<X>`]: crate::distr::uniform::Uniform/// In case of error, `self` is not modified. Error cases:/// -   [`Error::InvalidInput`] when `new_weights` are not ordered by///     index or an index is too large.///     Note that due to floating-point loss of precision, this case is not///     always correctly detected; usage of a fixed-point weight type may be///     preferred./// Updates take `O(N)` time. If you need to frequently update weights, consider/// [`rand_distr::weighted_tree`](https://docs.rs/rand_distr/*/rand_distr/weighted_tree/index.html)/// as an alternative where an update is `O(log N)`.WeightedIndexIter/// A lazy-loading iterator over the weights of a `WeightedIndex` distribution./// This is returned by [`WeightedIndex::weights`]./// Returns the weight at the given index, if it exists./// If the index is out of bounds, this will return `None`./// let weights = [0, 1, 2];/// assert_eq!(dist.weight(0), Some(0));/// assert_eq!(dist.weight(1), Some(1));/// assert_eq!(dist.weight(2), Some(2));/// assert_eq!(dist.weight(3), None);/// Returns a lazy-loading iterator containing the current weights of this distribution./// If this distribution has not been updated since its creation, this will return the/// same weights as were passed to `new`./// let weights = [1, 2, 3];/// let mut dist = WeightedIndex::new(&weights).unwrap();/// assert_eq!(dist.weights().collect::<Vec<_>>(), vec![1, 2, 3]);/// dist.update_weights(&[(0, &2)]).unwrap();/// assert_eq!(dist.weights().collect::<Vec<_>>(), vec![2, 2, 3]);/// Returns the sum of all weights in this distribution.// Re-export rand_core itselfTryCryptoRngTryRngCore//! // The prelude import enables methods we use below, specifically//! // Rng::random, Rng::sample, SliceRandom::shuffle and IndexedRandom::choose.//! // Get an RNG://! // Try printing a random unicode code point (probably a bad idea)!//! println!("char: '{}'", rng.random::<char>());//! // Try printing a random alphanumeric value instead!//! println!("alpha: '{}'", rng.sample(rand::distr::Alphanumeric) as char);//! // Generate and shuffle a sequence://! // And take a random pick (yes, we didn't need to shuffle first!)://! let _ = nums.choose(&mut rng);IndexedMutRandomIndexedRandom//! # let mut r = StdRng::from_rng(&mut rand::rng());//! # let _: f32 = r.random();/// Return a random value via the [`StandardUniform`] distribution./// let x: u32 = rng.random();/// println!("{:?}", rng.random::<(f64, bool)>());/// The `rng.random()` method is able to generate arrays/// (< 64 bit), it will likely be faster to instead use [`Rng::fill`],/// though note that generated values will differ./// let tuple: (u8, i32, char) = rng.random(); // arbitrary tuple support/// let arr1: [f32; 32] = rng.random();        // array construction/// [`StandardUniform`]: distr::StandardUniformrandom_iter/// Return an iterator over [`random`](Self::random) variates/// This is a just a wrapper over [`Rng::sample_iter`] using/// [`distr::StandardUniform`]./// Note: this method consumes its argument. Use/// `(&mut rng).random_iter()` to avoid consuming the RNG./// use rand::{rngs::SmallRng, Rng, SeedableRng};/// let rng = SmallRng::seed_from_u64(0);/// let v: Vec<i32> = rng.random_iter().take(5).collect();/// assert_eq!(v.len(), 5);/// All types support `low..high_exclusive` and `low..=high` range syntax./// Unsigned integer types also support `..high_exclusive` and `..=high` syntax./// Panics if the range is empty, or if `high - low` overflows for floats./// let n: u32 = rng.random_range(..10);/// let m: f64 = rng.random_range(-40.0..1.3e5);/// let n: u32 = rng.random_range(..=10);/// [`Uniform`]: distr::uniform::Uniformrandom_bool/// println!("{}", rng.random_bool(1.0 / 3.0));/// [`Bernoulli`]: distr::Bernoullirandom_ratio/// That is, `random_ratio(2, 3)` has chance of 2 in 3, or about 67%, of/// println!("{}", rng.random_ratio(2, 3));/// use rand::distr::Uniform;/// let x = rng.sample(Uniform::new(10u32, 15).unwrap());/// let y = rng.sample::<u16, _>(Uniform::new(10, 15).unwrap());/// Note: this method consumes its arguments. Use/// `(&mut rng).sample_iter(..)` to avoid consuming the RNG./// use rand::distr::{Alphanumeric, Uniform, StandardUniform};/// let v: Vec<f32> = (&mut rng).sample_iter(StandardUniform).take(16).collect();/// println!("{:?}", (&mut rng).sample_iter(StandardUniform).take(5)/// This method is implemented for types which may be safely reinterpreted/// as an (aligned) `[u8]` slice then filled with random data. It is often/// faster than using [`Rng::random`] but not value-equivalent./// rand::rng().fill(&mut arr[..]);r#gen/// Alias for [`Rng::random`]./// Alias for [`Rng::random_range`]./// Alias for [`Rng::random_bool`]./// Alias for [`Rng::random_ratio`]./// User-level interface for RNGs/// [`RngCore`] is the `dyn`-safe implementation-level interface for Random/// (Number) Generators. This trait, `Rng`, provides a user-level interface on/// RNGs. It is implemented automatically for any `R: RngCore`./// This trait must usually be brought into scope via `use rand::Rng;` or/// `use rand::prelude::*;`./// (which is how `from_rng(rand::rng())` works); also it still works directly/// (`distr.sample(&mut rng)`) or implicitly (`rng.random()`); one may hope the///     rng.random()/// # let v = foo(&mut rand::rng());__unsafe/// Call target for unsafe macros/// Implement `Fill` for given type `$t`./// All bit patterns of `[u8; size_of::<$t>()]` must represent values of `$t`.// SAFETY: All bit patterns of `[u8; size_of::<$t>()]` represent values of `u*`.// SAFETY: All bit patterns of `[u8; size_of::<$t>()]` represent values of `i*`./// A mock generator yielding very predictable output/// Other integer types (64-bit and smaller) are produced via cast from `u64`./// Other types are produced via their implementation of [`Rng`](crate::Rng) or/// [`Distribution`](crate::distr::Distribution)./// Output values may not be intuitive and may change in future releases but/// are considered/// [portable](https://rust-random.github.io/book/portability.html)./// (`bool` output is true when bit `1u64 << 31` is set.)/// let sample: [u64; 3] = my_rng.random();//! This crate provides a small selection of non-[portable] generators.//! See also [Types of generators] and [Our RNGs] in the book.//! ## Generators//! This crate provides a small selection of non-[portable] random number generators://! -   [`OsRng`] is a stateless interface over the operating system's random number//!     source. This is typically secure with some form of periodic re-seeding.//! -   [`ThreadRng`], provided by [`crate::rng()`], is a handle to a//!     thread-local generator with periodic seeding from [`OsRng`]. Because this//!     secure, but see documentation on [`ThreadRng`].//!     [`StdRng`] is the deterministic generator used by [`ThreadRng`] but//!     without the periodic reseeding or thread-local management.//! -   [`SmallRng`] is a relatively simple, insecure generator designed to be//!     fast, use little memory, and pass various statistical tests of//!     randomness quality.//! release and may be platform-dependent, therefore they are not//! [reproducible][portable].//! ### Additional generators//! -   The [`rdrand`] crate provides an interface to the RDRAND and RDSEED//!     instructions available in modern Intel and AMD CPUs.//! -   The [`rand_jitter`] crate provides a user-space implementation of//!     entropy harvesting from CPU timer jitter, but is very slow and has//!     [security issues](https://github.com/rust-random/rand/issues/699).//! -   The [`rand_chacha`] crate provides [portable] implementations of//!     generators derived from the [ChaCha] family of stream ciphers//! -   The [`rand_pcg`] crate provides [portable] implementations of a subset//!     of the [PCG] family of small, insecure generators//! -   The [`rand_xoshiro`] crate provides [portable] implementations of the//!     [xoshiro] family of small, insecure generators//! For more, search [crates with the `rng` tag].//! All generators implement [`RngCore`] and thus also [`Rng`][crate::Rng].//! See also the [Random Values] chapter in the book.//! Secure RNGs may additionally implement the [`CryptoRng`] trait.//! [portable]: https://rust-random.github.io/book/crate-reprod.html//! [Types of generators]: https://rust-random.github.io/book/guide-gen.html//! [Our RNGs]: https://rust-random.github.io/book/guide-rngs.html//! [Random Values]: https://rust-random.github.io/book/guide-values.html//! [crates with the `rng` tag]: https://crates.io/keywords/rng//! [chacha]: https://cr.yp.to/chacha.html//! [PCG]: https://www.pcg-random.org///! [xoshiro]: https://prng.di.unimi.it/CryptoBlockRng/// use rand::rngs::ReseedingRng;/// let mut reseeding_rng = ReseedingRng::<ChaCha20Core, _>::new(0, OsRng).unwrap();/// println!("{}", reseeding_rng.random::<u64>());/// assert!(reseeding_rng.random::<u64>() != cloned_rng.random::<u64>());/// Immediately reseed the generator/// This discards any remaining random data in the cache./// `threshold` is the maximum number of bytes produced by/// [`BlockRngCore::generate`] before attempting reseeding./// A small-state, fast, non-crypto, non-portable PRNG/// This is the "standard small" RNG, a generator with the following properties:/// - Non-[portable]: any future library version may replace the algorithm///   and results may be platform-dependent.///   (For a small portable generator, use the [rand_pcg] or [rand_xoshiro] crate.)/// - Non-cryptographic: output is easy to predict (insecure)/// - [Quality]: statistically good quality/// - Fast: the RNG is fast for both bulk generation and single values, with///   consistent cost of method calls/// - Fast initialization/// - Small state: little memory usage (current state size is 16-32 bytes///   depending on platform)/// The current algorithm is/// ## Seeding (construction)/// This generator implements the [`SeedableRng`] trait. All methods are/// suitable for seeding, but note that, even with a fixed seed, output is not/// [portable]. Some suggestions:/// 1.  To automatically seed with a unique seed, use [`SeedableRng::from_rng`]:///     use rand::SeedableRng;///     use rand::rngs::SmallRng;///     let rng = SmallRng::from_rng(&mut rand::rng());///     # let _: SmallRng = rng;///     or [`SeedableRng::from_os_rng`]:///     # use rand::SeedableRng;///     # use rand::rngs::SmallRng;///     let rng = SmallRng::from_os_rng();/// 2.  To use a deterministic integral seed, use `seed_from_u64`. This uses a///     hash function internally to yield a (typically) good seed from any///     input.///     # use rand::{SeedableRng, rngs::SmallRng};///     let rng = SmallRng::seed_from_u64(1);/// 3.  To seed deterministically from text or other input, use [`rand_seeder`]./// See also [Seeding RNGs] in the book./// ## Generation/// The generators implements [`RngCore`] and thus also [`Rng`][crate::Rng]./// See also the [Random Values] chapter in the book./// [portable]: https://rust-random.github.io/book/crate-reprod.html/// [Seeding RNGs]: https://rust-random.github.io/book/guide-seeding.html/// [Random Values]: https://rust-random.github.io/book/guide-values.html/// [Quality]: https://rust-random.github.io/book/guide-rngs.html#quality/// [`rand_chacha::ChaCha8Rng`]: https://docs.rs/rand_chacha/latest/rand_chacha/struct.ChaCha8Rng.html/// [`rand_seeder`]: https://docs.rs/rand_seeder/latest/rand_seeder/// Fix to 256 bits. Changing this is a breaking change!/// A strong, fast (amortized), non-portable RNG/// This is the "standard" RNG, a generator with the following properties:///   (For a portable version, use the [rand_chacha] crate directly.)/// - [CSPRNG]: statistically good quality of randomness and [unpredictable]/// - Fast ([amortized](https://en.wikipedia.org/wiki/Amortized_analysis)):///   the RNG is fast for bulk generation, but the cost of method calls is not///   consistent due to usage of an output buffer./// see this relevant [rand issue] for the discussion. This may change as new/// This generator implements the [`SeedableRng`] trait. Any method may be used,/// but note that `seed_from_u64` is not suitable for usage where security is/// important. Also note that, even with a fixed seed, output is not [portable]./// Using a fresh seed **direct from the OS** is the most secure option:/// # use rand::{SeedableRng, rngs::StdRng};/// let rng = StdRng::from_os_rng();/// # let _: StdRng = rng;/// Seeding via [`rand::rng()`](crate::rng()) may be faster:/// let rng = StdRng::from_rng(&mut rand::rng());/// Any [`SeedableRng`] method may be used, but note that `seed_from_u64` is not/// suitable where security is required. See also [Seeding RNGs] in the book./// [unpredictable]: https://rust-random.github.io/book/guide-rngs.html#security/// [CSPRNG]: https://rust-random.github.io/book/guide-gen.html#cryptographically-secure-pseudo-random-number-generator/// This type is a reference to a lazily-initialized thread-local generator./// An instance can be obtained via [`rand::rng()`][crate::rng()] or via/// [`ThreadRng::default()`]./// Security must be considered relative to a threat model and validation/// requirements. The Rand project can provide no guarantee of fitness for/// purpose. The design criteria for `ThreadRng` are as follows:/// - Automatic seeding via [`OsRng`] and periodically thereafter (see///   ([`ReseedingRng`] documentation). Limitation: there is no automatic///   reseeding on process fork (see [below](#fork))./// - A rigorusly analyzed, unpredictable (cryptographic) pseudo-random generator///   (see [the book on security](https://rust-random.github.io/book/guide-rngs.html#security)).///   The currently selected algorithm is ChaCha (12-rounds).///   See also [`StdRng`] documentation./// - Not to leak internal state through [`Debug`] or serialization///   implementations./// - No further protections exist to in-memory state. In particular, the///   implementation is not required to zero memory on exit (of the process or///   thread). (This may change in the future.)/// - Be fast enough for general-purpose usage. Note in particular that///   `ThreadRng` is designed to be a "fast, reasonably secure generator"///   (where "reasonably secure" implies the above criteria)./// We leave it to the user to determine whether this generator meets their/// security requirements. For an alternative, see [`OsRng`]./// # Fork/// `ThreadRng` is not automatically reseeded on fork. It is recommended to/// explicitly call [`ThreadRng::reseed`] immediately after a fork, for example:/// fn do_fork() {///     let pid = unsafe { libc::fork() };///     if pid == 0 {///         // Reseed ThreadRng in child processes:///         rand::rng().reseed();/// Methods on `ThreadRng` are not reentrant-safe and thus should not be called/// from an interrupt (e.g. a fork handler) unless it can be guaranteed that no/// other method on the same `ThreadRng` is currently executing./// [`ReseedingRng`]: crate::rngs::ReseedingRng/// Debug implementation does not leak internal state/// Access a fast, pre-initialized generator/// This is a handle to the local [`ThreadRng`]./// See also [`crate::rngs`] for alternatives./// let mut numbers = [1, 2, 3, 4, 5];/// numbers.shuffle(&mut rand::rng());/// println!("Numbers: {numbers:?}");/// // Using a local binding avoids an initialization-check on each usage:/// println!("True or false: {}", rng.random::<bool>());/// println!("A simulated die roll: {}", rng.random_range(1..=6));/// Refer to [`ThreadRng#Security`].test_debug_outputstable_seed_from_u64_and_from_seed// TODO(opt): this should depend on RNG word sizeCoinFlipperrandom_ratio_one_over/// Returns true with a probability of 1 / d/// Uses an expected two bits of randomness/// Panics if d == 0/// Returns true with a probability of n / dflip_c_heads/// If the next `c` bits of randomness all represent heads, consume them, return true/// Otherwise return false and consume the number of heads plus one./// Generates new bits of randomness when necessary (in 32 bit chunks)/// Has a 1 in 2 to the `c` chance of returning true/// `c` must be less than or equal to 32// Copyright 2018-2023 Developers of the Rand project.// Chunk is a random number in [0, (n + 1) * (n + 2) *..* (n + chunk_remaining) )IncreasingUniform/// Similar to a Uniform distribution,/// but after returning a number in the range [0,n], n is increased by 1./// Create a dice roller./// The next item returned will be a random number in the range [0,n]/// Returns a number in [0,n] and increments n by 1./// Generates new random bits as needed/// Panics if `n >= u32::MAX`calculate_bound_u32/// Calculates `bound`, `count` such that bound (m)*(m+1)*..*(m + remaining - 1)coin_flipper/// Uniformly sample one element/// Assuming that the [`Iterator::size_hint`] is correct, this method/// returns one uniformly-sampled random element of the slice, or `None`/// only if the slice is empty. Incorrect bounds on the `size_hint` may/// cause this method to incorrectly return `None` if fewer elements than/// the advertised `lower` bound are present and may prevent sampling of/// elements beyond an advertised `upper` bound (i.e. incorrect `size_hint`/// is memory-safe, but may result in unexpected `None` result and/// non-uniform distribution)./// With an accurate [`Iterator::size_hint`] and where [`Iterator::nth`] is/// a constant-time operation, this method can offer `O(1)` performance./// Where no size hint is/// Note further that [`Iterator::size_hint`] may affect the number of RNG/// samples used as well as the result (while remaining uniform sampling)./// Consider instead using [`IteratorRandom::choose_stable`] to avoid/// [`Iterator`] combinators which only change size hints from affecting the/// results./// let words = "Mary had a little lamb".split(' ');/// println!("{}", words.choose(&mut rand::rng()).unwrap());/// Uniformly sample one element (stable)// Clippy is wrong here: we need to iterate over all entries with the RNG to// ensure that choosing is *stable*.// "allow(unknown_lints)" can be removed when switching to at least// rust-version 1.86.0, see:// https://rust-lang.github.io/rust-clippy/master/index.html#double_ended_iterator_last/// Uniformly sample `amount` distinct elements into a buffer/// For slices, prefer [`IndexedRandom::choose_multiple`]./// Uniformly sample `amount` distinct elements into a [`Vec`]/// println!("I am {}!", faces.chars().choose(&mut rand::rng()).unwrap());// Copyright 2018-2024 Developers of the Rand project.//! `IteratorRandom`increasing_uniform"index.rs"index_WeightErrorsample_array/// Randomly sample exactly `N` distinct indices from `0..len`, and/// This is implemented via Floyd's algorithm. Time complexity is `O(N^2)`/// and memory complexity is `O(N)`./// Returns `None` if (and only if) `N > len`./// Low-level API for sampling indices//! *   [`IndexedRandom`] for sampling slices and other indexable lists//! *   [`IndexedMutRandom`] for sampling slices and other mutably indexable lists//! *   [`SliceRandom`] for mutating slices//! *   [`IteratorRandom`] for sampling iterators//! *   [`crate::distr::weighted::WeightedIndex`] distribution which provides/// The length/// True when the length is zero/// Returns a reference to one uniformly-sampled random element of/// the slice, or `None` if the slice is empty./// Uniformly sample `amount` distinct elements from self/// let mut rng = &mut rand::rng();choose_multiple_array/// Uniformly sample a fixed-size array of distinct elements from self/// Chooses `N` elements from the slice at random, without repetition,/// and in random order./// For slices, complexity is the same as [`index::sample_array`]./// let a: [u8; 3] = sample.choose_multiple_array(&mut rng).unwrap();/// Biased sampling for one element/// Returns a reference to one element of the slice, sampled according/// to the provided weights. Returns `None` only if the slice is empty./// For more information about the underlying algorithm,/// see the [`WeightedIndex`] distribution./// See also [`choose_weighted_mut`]./// let choices = [('a', 2), ('b', 1), ('c', 1), ('d', 0)];/// // 50% chance to print 'a', 25% chance to print 'b', 25% chance to print 'c',/// // and 'd' will never be printed/// [`choose`]: IndexedRandom::choose/// [`choose_weighted_mut`]: IndexedMutRandom::choose_weighted_mut/// [`WeightedIndex`]: crate::distr::weighted::WeightedIndex/// Extension trait on indexable lists, providing random sampling methods./// This trait is implemented on `[T]` slice types. Other types supporting/// [`std::ops::Index<usize>`] may implement this (only [`Self::len`] must be/// specified)./// Uniformly sample one element (mut)/// Returns a mutable reference to one uniformly-sampled random element of/// Biased sampling for one element (mut)/// Returns a mutable reference to one element of the slice, sampled according/// [`choose_mut`]: IndexedMutRandom::choose_mut/// [`choose_weighted`]: IndexedRandom::choose_weighted/// This trait is implemented automatically for every type implementing/// [`IndexedRandom`] and [`std::ops::IndexMut<usize>`]./// The resulting permutation is picked uniformly from the set of all possible permutations./// `amount = self.len() - amount` and using only the second slice./// Extension trait on slices, providing shuffling methods./// [`IndexedRandom::choose_multiple`](trait.IndexedRandom.html#tymethod.choose_multiple).//! `IndexedRandom`, `IndexedMutRandom`, `SliceRandom`SEED_WORDS// 8 words for the 256-bit key/// A cryptographically secure random number generator that uses the ChaCha/// ChaCha is a stream cipher designed by Daniel J. Bernstein[^1], that we use/// as an RNG. It is an improved variant of the Salsa20 cipher family, which was/// selected as one of the "stream ciphers suitable for widespread adoption" by/// eSTREAM[^2]./// ChaCha uses add-rotate-xor (ARX) operations as its basis. These are safe/// against timing attacks, although that is mostly a concern for ciphers and/// not for RNGs. Also it is very suitable for SIMD implementation./// Here we do not provide a SIMD implementation yet, except for what is/// provided by auto-vectorisation./// With the ChaCha algorithm it is possible to choose the number of rounds the/// core algorithm should run. The number of rounds is a tradeoff between/// performance and security, where 8 rounds is the minimum potentially/// secure configuration, and 20 rounds is widely used as a conservative choice./// We use 20 rounds in this implementation, but hope to allow type-level/// configuration in the future./// We use a 64-bit counter and 64-bit stream identifier as in Bernstein's/// implementation[^1] except that we use a stream identifier in place of a/// nonce. A 64-bit counter over 64-byte (16 word) blocks allows 1 ZiB of output/// before cycling, and the stream identifier allows 2<sup>64</sup> unique/// streams of output per seed. Both counter and stream are initialized to zero/// but may be set via [`set_word_pos`] and [`set_stream`]./// The word layout is:/// constant  constant  constant  constant/// seed      seed      seed      seed/// counter   counter   stream_id stream_id/// This implementation uses an output buffer of sixteen `u32` words, and uses/// [`BlockRng`] to implement the [`RngCore`] methods./// [^1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*](///       https://cr.yp.to/chacha.html)/// [^2]: [eSTREAM: the ECRYPT Stream Cipher Project](///       http://www.ecrypt.eu.org/stream/)/// [`set_word_pos`]: #method.set_word_pos/// [`set_stream`]: #method.set_stream/// [`BlockRng`]: ../rand_core/block/struct.BlockRng.html/// [`RngCore`]: ../rand_core/trait.RngCore.html/// Get the offset from the start of the stream, in 32-bit words./// Since the generated blocks are 16 words (2<sup>4</sup>) long and the/// counter is 64-bits, the offset is a 68-bit number. Sub-word offsets are/// not supported, hence the result can simply be multiplied by 4 to get a/// byte-offset./// Note: this function is currently only available with Rust 1.26 or later./// Set the offset from the start of the stream, in 32-bit words./// As with `get_word_pos`, we use a 68-bit number. Since the generator/// simply cycles at the end of its period (1 ZiB), we ignore the upper/// 60 bits./// Set the stream number./// This is initialized to zero; 2<sup>64</sup> unique streams of output/// are available per seed/key./// Note that in order to reproduce ChaCha output with a specific 64-bit/// nonce, one can convert that nonce to a `u64` in little-endian fashion/// and pass to this function. In theory a 96-bit nonce can be used by/// passing the last 64-bits to this function and using the first 32-bits as/// the most significant half of the 64-bit counter (which may be set/// indirectly via `set_word_pos`), but this is not directly supported./// The core of `ChaChaRng`, used with `BlockRng`.// Custom Debug implementation that does not expose the internal statedouble_roundtest_chacha_constructiontest_chacha_true_values_atest_chacha_true_values_btest_chacha_true_values_ctest_chacha_multiple_blockstest_chacha_true_bytestest_chacha_noncetest_chacha_clone_streams// Copyright 2014 The Rust Project Developers.//! The ChaCha random number generator.gutsBUF_BLOCKS// NB. this must remain consistent with some currently hard-coded numbers in this module// number of 32-bit words per ChaCha block (fixed by algorithm definition)Array64chacha_impl"ChaCha with 20 rounds"ChaCha20Corer" A cryptographically secure random number generator that uses the ChaCha algorithm."r" ChaCha is a stream cipher designed by Daniel J. Bernstein[^1], that we use as an RNG. It is"r#" an improved variant of the Salsa20 cipher family, which was selected as one of the "stream"#r#" ciphers suitable for widespread adoption" by eSTREAM[^2]."#r" ChaCha uses add-rotate-xor (ARX) operations as its basis. These are safe against timing"r" attacks, although that is mostly a concern for ciphers and not for RNGs. We provide a SIMD"r" implementation to support high throughput on a variety of common hardware platforms."r" With the ChaCha algorithm it is possible to choose the number of rounds the core algorithm"r" should run. The number of rounds is a tradeoff between performance and security, where 8"r" rounds is the minimum potentially secure configuration, and 20 rounds is widely used as a"r" conservative choice."r" We use a 64-bit counter and 64-bit stream identifier as in Bernstein's implementation[^1]"r" except that we use a stream identifier in place of a nonce. A 64-bit counter over 64-byte"r" (16 word) blocks allows 1 ZiB of output before cycling, and the stream identifier allows"r" 2<sup>64</sup> unique streams of output per seed. Both counter and stream are initialized"r" to zero but may be set via the `set_word_pos` and `set_stream` methods."r" The word layout is:"r" constant  constant  constant  constant"r" seed      seed      seed      seed"r" counter   counter   stream_id stream_id"r" This implementation uses an output buffer of sixteen `u32` words, and uses"r" [`BlockRng`] to implement the [`RngCore`] methods."r" [^1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*]("r"       https://cr.yp.to/chacha.html)"r" [^2]: [eSTREAM: the ECRYPT Stream Cipher Project]("r"       http://www.ecrypt.eu.org/stream/)"ChaCha20Rngr" Get the offset from the start of the stream, in 32-bit words."r" Since the generated blocks are 16 words (2<sup>4</sup>) long and the"r" counter is 64-bits, the offset is a 68-bit number. Sub-word offsets are"r" not supported, hence the result can simply be multiplied by 4 to get a"r" byte-offset."r" Set the offset from the start of the stream, in 32-bit words."r" As with `get_word_pos`, we use a 68-bit number. Since the generator"r" simply cycles at the end of its period (1 ZiB), we ignore the upper"r" 60 bits."r" Set the stream number."r" This is initialized to zero; 2<sup>64</sup> unique streams of output"r" are available per seed/key."r" Note that in order to reproduce ChaCha output with a specific 64-bit"r" nonce, one can convert that nonce to a `u64` in little-endian fashion"r" and pass to this function. In theory a 96-bit nonce can be used by"r" passing the last 64-bits to this function and using the first 32-bits as"r" the most significant half of the 64-bit counter (which may be set"r" indirectly via `set_word_pos`), but this is not directly supported."r" Get the stream number."r" Get the seed."word_posabstract20"ChaCha with 12 rounds"abstract12"ChaCha with 8 rounds"ChaCha8CoreChaCha8Rngabstract8test_chacha_word_pos_wrap_exacttest_chacha_word_pos_wrap_excesstest_chacha_word_pos_zeroBLOCK64LOG2_BUFBLOCKSBUFBLOCKSBUFSZ64BUFSZSTREAM_PARAM_NONCESTREAM_PARAM_BLOCKdiagonalizeundiagonalizepos64refill4/// Produce 4 blocks of output, advancing the stateset_nonceget_noncerefill_wide_implrefill_widerefill_narrow_rounds// Single-block, rounds-only; shared by try_apply_keystream for tails shorter than BUFSZ// and XChaCha's setup step.set_stream_paramget_stream_paramread_u32leinit_chachainit_chacha_x// Copyright 2019 The CryptoCorrosion Contributors// Copyright 2020 Developers of the Rand project./// ChaCha with 20 rounds/// ChaCha with 20 rounds, low-level interfacetest_trait_objectsadd_pos// Pos is packed into the state vectors as a little-endian u64,// so on LE platforms we can use native vector ops to increment it.d0123//! The ChaCha random number generators.//! These are native Rust implementations of RNGs derived from the//! [ChaCha stream ciphers] by D J Bernstein.//! This crate provides 8-, 12- and 20-round variants of generators via a "core"//! implementation (of [`BlockRngCore`]), each with an associated "RNG" type//! (implementing [`RngCore`]).//! These generators are all deterministic and portable (see [Reproducibility]//! in the book), with testing against reference vectors.//! ## Cryptographic (secure) usage//! Where secure unpredictable generators are required, it is suggested to use//! [`ChaCha12Rng`] or [`ChaCha20Rng`] and to seed via//! [`SeedableRng::from_os_rng`].//! See also the [Security] chapter in the rand book. The crate is provided//! "as is", without any form of guarantee, and without a security audit.//! ## Seeding (construction)//! Generators implement the [`SeedableRng`] trait. Any method may be used,//! but note that `seed_from_u64` is not suitable for usage where security is//! important. Some suggestions://! 1.  With a fresh seed, **direct from the OS** (implies a syscall)://!     # use {rand_core::SeedableRng, rand_chacha::ChaCha12Rng};//!     let rng = ChaCha12Rng::from_os_rng();//!     # let _: ChaCha12Rng = rng;//! 2.  **From a master generator.** This could be [`rand::rng`]//!     (effectively a fresh seed without the need for a syscall on each usage)//!     or a deterministic generator such as [`ChaCha20Rng`].//!     Beware that should a weak master generator be used, correlations may be//!     detectable between the outputs of its child generators.//!     ```ignore//!     let rng = ChaCha12Rng::from_rng(&mut rand::rng());//! See also [Seeding RNGs] in the book.//! ## Generation//! Generators implement [`RngCore`], whose methods may be used directly to//! generate unbounded integer or byte values.//! use rand_core::{SeedableRng, RngCore};//! use rand_chacha::ChaCha12Rng;//! let mut rng = ChaCha12Rng::from_seed(Default::default());//! let x = rng.next_u64();//! assert_eq!(x, 0x53f955076a9af49b);//! It is often more convenient to use the [`rand::Rng`] trait, which provides//! further functionality. See also the [Random Values] chapter in the book.//! [ChaCha stream ciphers]: https://cr.yp.to/chacha.html//! [Reproducibility]: https://rust-random.github.io/book/crate-reprod.html//! [Seeding RNGs]: https://rust-random.github.io/book/guide-seeding.html//! [Security]: https://rust-random.github.io/book/guide-rngs.html#security//! [`BlockRngCore`]: rand_core::block::BlockRngCore//! [`RngCore`]: rand_core::RngCore//! [`SeedableRng`]: rand_core::SeedableRng//! [`SeedableRng::from_os_rng`]: rand_core::SeedableRng::from_os_rng//! [`rand::rng`]: https://docs.rs/rand/latest/rand/fn.rng.html//! [`rand::Rng`]: https://docs.rs/rand/latest/rand/trait.Rng.htmlfill_via_u32_chunksfill_via_u64_chunks/// Results element type, e.g. `u32`./// Results type. This is the 'block' an RNG implementing `BlockRngCore`/// generates, which will usually be an array like `[u32; 16]`./// Generate a new block of results./// A trait for RNGs which do not generate random numbers individually, but in/// blocks (typically `[u32; N]`). This technique is commonly used by/// cryptographic RNGs to improve performance./// See the [module][crate::block] documentation for details./// The *core* part of the RNG, implementing the `generate` function./// A wrapper type implementing [`RngCore`] for some type implementing/// [`BlockRngCore`] with `u32` array buffer; i.e. this can be used to implement/// a full RNG from just a `generate` function./// The `core` field may be accessed directly but the results buffer may not./// PRNG implementations can simply use a type alias/// (`pub type MyRng = BlockRng<MyRngCore>;`) but might prefer to use a/// wrapper type (`pub struct MyRng(BlockRng<MyRngCore>);`); the latter must/// re-implement `RngCore` but hides the implementation details and allows/// extra functionality to be defined on the RNG/// (e.g. `impl MyRng { fn set_stream(...){...} }`)./// `BlockRng` has heavily optimized implementations of the [`RngCore`] methods/// reading values from the results buffer, as well as/// calling [`BlockRngCore::generate`] directly on the output array when/// [`fill_bytes`] / [`try_fill_bytes`] is called on a large array. These methods/// also handle the bookkeeping of when to generate a new batch of values./// No whole generated `u32` values are thown away and all values are consumed/// in-order. [`next_u32`] simply takes the next available `u32` value./// [`next_u64`] is implemented by combining two `u32` values, least/// significant first. [`fill_bytes`] and [`try_fill_bytes`] consume a whole/// number of `u32` values, converting each `u32` to a byte slice in/// little-endian order. If the requested byte length is not a multiple of 4,/// some bytes will be discarded./// See also [`BlockRng64`] which uses `u64` array buffers. Currently there is/// no direct support for other buffer types./// For easy initialization `BlockRng` also implements [`SeedableRng`]./// [`next_u32`]: RngCore::next_u32/// [`next_u64`]: RngCore::next_u64// Custom Debug implementation that does not expose the contents of `results`./// Create a new `BlockRng` from an existing RNG implementing/// `BlockRngCore`. Results will be generated on first use./// Get the index into the result buffer./// If this is equal to or larger than the size of the result buffer then/// the buffer is "empty" and `generate()` must be called to produce new/// Reset the number of available results./// This will force a new set of results to be generated on next use.generate_and_set/// Generate a new set of results immediately, setting the index to the// As an optimization we try to write directly into the output buffer.// This is only enabled for little-endian platforms where unaligned writes// are known to be safe and fast.half_used// true if only half of the previous result is usedBlockRng64/// [`BlockRngCore`] with `u64` array buffer; i.e. this can be used to implement/// This is similar to [`BlockRng`], but specialized for algorithms that operate/// on `u64` values./// No whole generated `u64` values are thrown away and all values are consumed/// in-order. [`next_u64`] simply takes the next available `u64` value./// [`next_u32`] is however a bit special: half of a `u64` is consumed, leaving/// the other half in the buffer. If the next function called is [`next_u32`]/// then the other half is then consumed, however both [`next_u64`] and/// [`fill_bytes`] discard the rest of any half-consumed `u64`s when called./// [`fill_bytes`] and [`try_fill_bytes`] consume a whole number of `u64`/// values. If the requested length is not a multiple of 8, some bytes will be//! The `BlockRngCore` trait and implementation helpers//! The [`BlockRngCore`] trait exists to assist in the implementation of RNGs//! which generate a block of data in a cache instead of returning generated//! values directly.//! Usage of this trait is optional, but provides two advantages://! implementations only need to concern themselves with generation of the//! block, not the various [`RngCore`] methods (especially [`fill_bytes`], where//! the optimal implementations are not trivial), and this allows//! `ReseedingRng` (see [`rand`](https://docs.rs/rand) crate) perform periodic//! reseeding with very low overhead.//! ```norun//! use rand_core::block::{BlockRngCore, BlockRng};//! struct MyRngCore;//! impl BlockRngCore for MyRngCore {//!     type Results = [u32; 16];//!     fn generate(&mut self, results: &mut Self::Results) {//! impl SeedableRng for MyRngCore {//!     type Seed = unimplemented!();//!     fn from_seed(seed: Self::Seed) -> Self {//! // optionally, also implement CryptoRng for MyRngCore//! // Final RNG.//! type MyRng = BlockRng<u32, MyRngCore>;//! [`BlockRngCore`]: crate::block::BlockRngCore//! [`fill_bytes`]: RngCore::fill_bytes/// Feature is not available; not recoverable./// This is the most permanent failure type and implies the error cannot be/// resolved simply by retrying (e.g. the feature may not exist in this/// build of the application or on the current platform)./// General failure; there may be a chance of recovery on retry./// This is the catch-all kind for errors from known and unknown sources/// which do not have a more specific kind / handling method./// It is suggested to retry a couple of times or retry later when/// handling; some error sources may be able to resolve themselves,/// although this is not likely./// A transient failure which likely can be resolved or worked around./// This error kind exists for a few specific cases where it is known that/// the error likely can be resolved internally, but is reported anyway./// Not ready yet: recommended to try again a little later./// This error kind implies the generator needs more time or needs some/// other part of the application to do something else first before it is/// ready for use; for example this may be used by external generators/// which require time for initialization./// Error kind which can be matched over.should_retry/// True if this kind of error may resolve itself on retry./// See also `should_wait()`.should_wait/// True if we should retry but wait before retrying/// This implies `should_retry()` is true./// A description of this error kind/// The error kind/// The error message/// Error type of random number generators/// This is a relatively simple error type, designed for compatibility with and/// without the Rust `std` library. It embeds a "kind" code, a message (static/// string only), and an optional chained cause (`std` only). The `kind` and/// `msg` fields can be accessed directly; cause can be accessed via/// `std::error::Error::cause` or `Error::take_cause`. Construction can only be/// done via `Error::new` or `Error::with_cause`./// Create a new instance, with specified kind and a message.with_cause/// Create a new instance, with specified kind, message, and a/// chained cause./// Note: `stdError` is an alias for `std::error::Error`./// If not targetting `std` (i.e. `no_std`), this function is replaced by/// another with the same prototype, except that there are no bounds on the/// type `E` (because both `Box` and `stdError` are unavailable), and the/// `cause` is ignored./// In `no_std` mode the *cause* is ignored.take_cause/// Take the cause, if any. This allows the embedded cause to be extracted./// This uses `Option::take`, leaving `self` with no cause./// Implement `next_u64` via `next_u32`, little-endian order./// Implement `fill_bytes` via `next_u64` and `next_u32`, little-endian order./// The fastest way to fill a slice is usually to work as long as possible with/// integers. That is why this method mostly uses `next_u64`, and only when/// there are 4 or less bytes remaining at the end of the slice it uses/// `next_u32` once.impl_uint_from_fillfill_via_chunks/// Implement `fill_bytes` by reading chunks from the output buffer of a block/// based RNG./// The return values are `(consumed_u32, filled_u8)`./// `filled_u8` is the number of filled bytes in `dest`, which may be less than/// the length of `dest`./// `consumed_u32` is the number of words consumed from `src`, which is the same/// as `filled_u8 / 4` rounded up./// (from `IsaacRng`)/// fn fill_bytes(&mut self, dest: &mut [u8]) {///     let mut read_len = 0;///     while read_len < dest.len() {///         if self.index >= self.rsl.len() {///             self.isaac();///         let (consumed_u32, filled_u8) =///             impls::fill_via_u32_chunks(&mut self.rsl[self.index..],///                                        &mut dest[read_len..]);///         self.index += consumed_u32;///         read_len += filled_u8;/// The return values are `(consumed_u64, filled_u8)`./// `consumed_u64` is the number of words consumed from `src`, which is the same/// as `filled_u8 / 8` rounded up./// See `fill_via_u32_chunks` for an example.next_u32_via_fill/// Implement `next_u32` via `fill_bytes`, little-endian order.next_u64_via_fill/// Implement `next_u64` via `fill_bytes`, little-endian order.//! Helper functions for implementing `RngCore` functions.//! For cross-platform reproducibility, these functions all use Little Endian://! least-significant part first. For example, `next_u64_via_u32` takes `u32`//! values `x, y`, then outputs `(y << 32) | x`. To implement `next_u32`//! from `next_u64` in little-endian order, one should use `next_u64() as u32`.//! Byte-swapping (like the std `to_le` functions) is only needed to convert//! to/from byte sequences, and since its purpose is reproducibility,//! non-reproducible sources (e.g. `OsRng`) need not bother with it.// TODO: implement tests for the above/// Borrowed from the `byteorder` crate.//! Little-Endian utilities//! Little-Endian order has been chosen for internal usage; this makes some//! useful functions available.core4// Copyright 2017-2018 The Rust Project Developers.//! Random number generation traits//! This version of `rand_core` is a compatibility shim around version 0.3.//! This crate is mainly of interest to crates publishing implementations of//! [`RngCore`]. Other users are encouraged to use the [`rand`] crate instead//! which re-exports the main traits and error types.//! [`RngCore`] is the core trait implemented by algorithmic pseudo-random number//! generators and external random-number sources.//! [`SeedableRng`] is an extension trait for construction from fixed seeds and//! other random number generators.//! [`Error`] is provided for error-handling. It is safe to use in `no_std`//! environments.//! The [`impls`] and [`le`] sub-modules include a few small functions to assist//! implementation of [`RngCore`].//! [`rand`]: https://docs.rs/rand/// Return the next random `u32`./// RNGs must implement at least one method from this trait directly. In/// the case this method is not implemented directly, it can be implemented/// using `self.next_u64() as u32` or via/// [`fill_bytes`](impls::next_u32_via_fill)./// Return the next random `u64`./// via [`next_u32`](impls::next_u64_via_u32) or via/// [`fill_bytes`](impls::next_u64_via_fill)./// Fill `dest` with random data./// via [`next_u*`](impls::fill_bytes_via_next) or/// via [`try_fill_bytes`](RngCore::try_fill_bytes); if this generator can/// fail the implementation must choose how best to handle errors here/// (e.g. panic with a descriptive message or log a warning and retry a few/// times)./// This method should guarantee that `dest` is entirely filled/// with new data, and may panic if this is impossible/// (e.g. reading past the end of a file that is being used as the/// source of randomness)./// Fill `dest` entirely with random data./// This is the only method which allows an RNG to report errors while/// generating random data thus making this the primary method implemented/// by external (true) RNGs (e.g. `OsRng`) which can fail. It may be used/// directly to generate keys and to seed (infallible) PRNGs./// Other than error handling, this method is identical to [`fill_bytes`];/// thus this may be implemented using `Ok(self.fill_bytes(dest))` or/// `fill_bytes` may be implemented with/// `self.try_fill_bytes(dest).unwrap()` or more specific error handling./// The core of a random number generator./// This trait encapsulates the low-level functionality common to all/// generators, and is the "back end", to be implemented by generators./// End users should normally use the `Rng` trait from the [`rand`] crate,/// which is automatically implemented for every type implementing `RngCore`./// Three different methods for generating random data are provided since the/// optimal implementation of each is dependent on the type of generator. There/// is no required relationship between the output of each; e.g. many/// implementations of [`fill_bytes`] consume a whole number of `u32` or `u64`/// values and drop any remaining unused bytes./// The [`try_fill_bytes`] method is a variant of [`fill_bytes`] allowing error/// handling; it is not deemed sufficiently useful to add equivalents for/// [`next_u32`] or [`next_u64`] since the latter methods are almost always used/// with algorithmic generators (PRNGs), which are normally infallible./// Algorithmic generators implementing [`SeedableRng`] should normally have/// *portable, reproducible* output, i.e. fix Endianness when converting values/// to avoid platform differences, and avoid making any changes which affect/// output (except by communicating that the release has breaking changes)./// Typically implementators will implement only one of the methods available/// in this trait directly, then use the helper functions from the/// [`impls`] module to implement the other methods./// It is recommended that implementations also implement:/// - `Debug` with a custom implementation which *does not* print any internal///   state (at least, [`CryptoRng`]s should not risk leaking state through///   `Debug`)./// - `Serialize` and `Deserialize` (from Serde), preferably making Serde///   support optional at the crate level in PRNG libs./// - `Clone`, if possible./// - *never* implement `Copy` (accidental copies may cause repeated values)./// - *do not* implement `Default` for pseudorandom generators, but instead///   implement [`SeedableRng`], to guide users towards proper seeding.///   External / hardware RNGs can choose to implement `Default`./// - `Eq` and `PartialEq` could be implemented, but are probably not useful./// A simple example, obviously not generating very *random* output:/// #![allow(dead_code)]/// use rand_core::{RngCore, Error, impls};/// struct CountingRng(u64);/// impl RngCore for CountingRng {///     fn next_u32(&mut self) -> u32 {///         self.next_u64() as u32///     fn next_u64(&mut self) -> u64 {///         self.0 += 1;///         self.0///     fn fill_bytes(&mut self, dest: &mut [u8]) {///         impls::fill_bytes_via_next(self, dest)///     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {///         Ok(self.fill_bytes(dest))/// [`rand`]: https://docs.rs/rand/// A marker trait used to indicate that an [`RngCore`] or [`BlockRngCore`]/// implementation is supposed to be cryptographically secure./// *Cryptographically secure generators*, also known as *CSPRNGs*, should/// satisfy an additional properties over other generators: given the first/// *k* bits of an algorithm's output/// sequence, it should not be possible using polynomial-time algorithms to/// predict the next bit with probability significantly greater than 50%./// Some generators may satisfy an additional property, however this is not/// required by this trait: if the CSPRNG's state is revealed, it should not be/// computationally-feasible to reconstruct output prior to this. Some other/// generators allow backwards-computation and are consided *reversible*./// Note that this trait is provided for guidance only and cannot guarantee/// suitability for cryptographic applications. In general it should only be/// implemented for well-reviewed code implementing well-regarded algorithms./// Note also that use of a `CryptoRng` does not protect against other/// weaknesses such as seeding from a weak entropy source or leaking state./// [`BlockRngCore`]: block::BlockRngCore/// Seed type, which is restricted to types mutably-dereferencable as `u8`/// arrays (we recommend `[u8; N]` for some `N`)./// It is recommended to seed PRNGs with a seed of at least circa 100 bits,/// which means an array of `[u8; 12]` or greater to avoid picking RNGs with/// partially overlapping periods./// For cryptographic RNG's a seed of 256 bits is recommended, `[u8; 32]`./// # Implementing `SeedableRng` for RNGs with large seeds/// Note that the required traits `core::default::Default` and/// `core::convert::AsMut<u8>` are not implemented for large arrays/// `[u8; N]` with `N` > 32. To be able to implement the traits required by/// `SeedableRng` for RNGs with such large seeds, the newtype pattern can be/// used:/// use rand_core::SeedableRng;/// const N: usize = 64;/// pub struct MyRngSeed(pub [u8; N]);/// pub struct MyRng(MyRngSeed);/// impl Default for MyRngSeed {///     fn default() -> MyRngSeed {///         MyRngSeed([0; N])/// impl AsMut<[u8]> for MyRngSeed {///     fn as_mut(&mut self) -> &mut [u8] {///         &mut self.0/// impl SeedableRng for MyRng {///     type Seed = MyRngSeed;///     fn from_seed(seed: MyRngSeed) -> MyRng {///         MyRng(seed)/// Create a new PRNG using the given seed./// PRNG implementations are allowed to assume that bits in the seed are/// well distributed. That means usually that the number of one and zero/// bits are about equal, and values like 0, 1 and (size - 1) are unlikely./// PRNG implementations are recommended to be reproducible. A PRNG seeded/// using this function with a fixed seed should produce the same sequence/// of output in the future and on different architectures (with for example/// different endianness)./// It is however not required that this function yield the same state as a/// reference implementation of the PRNG given equivalent seed; if necessary/// another constructor replicating behaviour from a reference/// implementation can be added./// PRNG implementations should make sure `from_seed` never panics. In the/// case that some special values (like an all zero seed) are not viable/// seeds it is preferable to map these to alternative constant value(s),/// for example `0xBAD5EEDu32` or `0x0DDB1A5E5BAD5EEDu64` ("odd biases? bad/// seed"). This is assuming only a small number of values must be rejected./// Create a new PRNG using a `u64` seed./// This is a convenience-wrapper around `from_seed` to allow construction/// of any `SeedableRng` from a simple `u64` value. It is designed such that/// low Hamming Weight numbers like 0 and 1 can be used and should still/// result in good, independent seeds to the PRNG which is returned./// This **is not suitable for cryptography**, as should be clear given that/// the input size is only 64 bits./// Implementations for PRNGs *may* provide their own implementations of/// this function, but the default implementation should be good enough for/// all purposes. *Changing* the implementation of this function should be/// considered a value-breaking change./// Create a new PRNG seeded from another `Rng`./// This is the recommended way to initialize PRNGs with fresh entropy. The/// `FromEntropy` trait from the [`rand`] crate provides a convenient/// `from_entropy` method based on `from_rng`./// Usage of this method is not recommended when reproducibility is required/// since implementing PRNGs are not required to fix Endianness and are/// allowed to modify implementations in new releases./// It is important to use a good source of randomness to initialize the/// PRNG. Cryptographic PRNG may be rendered insecure when seeded from a/// non-cryptographic PRNG or with insufficient entropy./// Many non-cryptographic PRNGs will show statistical bias in their first/// results if their seed numbers are small or if there is a simple pattern/// between them./// Prefer to seed from a strong external entropy source like `OsRng` from/// the [`rand_os`] crate or from a cryptographic PRNG; if creating a new/// generator for cryptographic uses you *must* seed from a strong source./// Seeding a small PRNG from another small PRNG is possible, but/// something to be careful with. An extreme example of how this can go/// wrong is seeding an Xorshift RNG from another Xorshift RNG, which/// will effectively clone the generator. In general seeding from a/// generator which is hard to predict is probably okay./// PRNG implementations are allowed to assume that a good RNG is provided/// for seeding, and that it is cryptographically secure when appropriate./// [`rand_os`]: https://docs.rs/rand_os/// A random number generator that can be explicitly seeded./// pseudo-random number generators (PRNGs, or algorithmic generators)./// The `FromEntropy` trait from the [`rand`] crate is automatically/// implemented for every type implementing `SeedableRng`, providing/// a convenient `from_entropy()` constructor.// Implement `RngCore` for references to an `RngCore`.// Force inlining all functions, so that it is up to the `RngCore`// implementation and the optimizer to decide on inlining.// Implement `RngCore` for boxed references to an `RngCore`.// Implement `CryptoRng` for references to an `CryptoRng`.// Implement `CryptoRng` for boxed references to an `CryptoRng`.test_seed_from_u64/// No whole generated `u32` values are thrown away and all values are consumedDummyRngblockrng_next_u32_vs_next_u64DummyRng64blockrng64_next_u32_vs_next_u64//! use rand_core::{RngCore, SeedableRng};//!     type Item = u32;//!     type Seed = [u8; 32];//! let mut rng = BlockRng::<MyRngCore>::seed_from_u64(0);//! println!("First value: {}", rng.next_u32());/// In order to be compatible with `std` and `no_std`, this type has two/// possible implementations: with `std` a boxed `Error` trait object is stored,/// while with `no_std` we merely store an error code./// This has a fixed value of `(1 << 31) + (1 << 30) = 0xC000_0000`,/// therefore the number of values available for custom codes is `1 << 30`./// This is identical to [`getrandom::Error::CUSTOM_START`](https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.CUSTOM_START)./// This is identical to [`getrandom::Error::INTERNAL_START`](https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.INTERNAL_START)./// Construct from any type supporting `std::error::Error`/// Available only when configured with `std`./// See also `From<NonZeroU32>`, which is available with and without `std`./// Reference the inner error (`std` only)/// When configured with `std`, this is a trivial operation and never/// panics. Without `std`, this method is simply unavailable./// Unwrap the inner error (`std` only)/// This method is identical to `std::io::Error::raw_os_error()`, except/// Retrieve the error code, if any./// If this `Error` was constructed via `From<NonZeroU32>`, then this method/// will return this `NonZeroU32` code (for `no_std` this is always the/// case). Otherwise, this method will return `None`.test_error_codesas_byte_slice// Contract: observing self is memory-safe (implies no uninitialised padding)Observabletest_fill_via_u32_chunkstest_fill_via_u64_chunks/// using `self.next_u64() as u32` or via [`impls::next_u32_via_fill`]./// via [`impls::next_u64_via_u32`] or via [`impls::next_u64_via_fill`]./// via [`impls::fill_bytes_via_next`] or/// via [`RngCore::try_fill_bytes`]; if this generator can/// Other than error handling, this method is identical to [`RngCore::fill_bytes`];/// values and drop any remaining unused bytes. The same can happen with the/// [`next_u32`] and [`next_u64`] methods, implementations may discard some/// random bits for efficiency./// Implementers should produce bits uniformly. Pathological RNGs (e.g. always/// returning the same value, or never setting certain bits) can break rejection/// sampling used by random distributions, and also break other RNGs when/// seeding them via [`SeedableRng::from_rng`]./// Typically an RNG will implement only one of the methods available/// generators allow backwards-computation and are considered *reversible*.as_rngcore/// Upcast to an [`RngCore`] trait object./// An extension trait that is automatically implemented for any type/// implementing [`RngCore`] and [`CryptoRng`]./// It may be used as a trait object, and supports upcasting to [`RngCore`] via/// the [`CryptoRngCore::as_rngcore`] method./// use rand_core::CryptoRngCore;/// #[allow(unused)]/// fn make_token(rng: &mut dyn CryptoRngCore) -> [u8; 32] {///     let mut buf = [0u8; 32];///     rng.fill_bytes(&mut buf);/// Seed type, which is restricted to types mutably-dereferenceable as `u8`/// bits are roughly equal, and values like 0, 1 and (size - 1) are unlikely./// Note that many non-cryptographic PRNGs will show poor quality output/// if this is not adhered to. If you wish to seed from simple numbers, use/// `seed_from_u64` instead./// All PRNG implementations should be reproducible unless otherwise noted:/// given a fixed `seed`, the same sequence of output should be produced/// on all runs, library versions and architectures (e.g. check endianness)./// Any "value-breaking" changes to the generator should require bumping at/// least the minor version and documentation of the change./// It is not required that this function yield the same state as a/// This may be useful when needing to rapidly seed many PRNGs from a master/// PRNG, and to allow forking of PRNGs. It may be considered deterministic./// The master PRNG should be at least as high quality as the child PRNGs./// When seeding non-cryptographic child PRNGs, we recommend using a/// different algorithm for the master PRNG (ideally a CSPRNG) to avoid/// correlations between the child PRNGs. If this is not possible (e.g./// forking using small non-crypto PRNGs) ensure that your PRNG has a good/// mixing function on the output or consider use of a hash function with/// `from_seed`./// Note that seeding `XorShiftRng` from another `XorShiftRng` provides an/// extreme example of what can go wrong: the new PRNG will be a clone/// of the parent./// As of `rand` 0.7 / `rand_core` 0.5, implementations overriding this/// method should ensure the implementation satisfies reproducibility/// (in prior versions this was not required)./// Creates a new instance of the RNG seeded via [`getrandom`]./// This method is the recommended way to construct non-deterministic PRNGs/// since it is convenient and secure./// In case the overhead of using [`getrandom`] to seed *many* PRNGs is an/// issue, one may prefer to seed from a local PRNG, e.g./// `from_rng(thread_rng()).unwrap()`./// If [`getrandom`] is unable to provide secure entropy this method will panic./// [`getrandom`]: https://docs.rs/getrandom// Implement `CryptoRng` for references to a `CryptoRng`.// Implement `CryptoRng` for boxed references to a `CryptoRng`./// A random number generator that retrieves randomness from the/// operating system./// This is a zero-sized struct. It can be freely constructed with `OsRng`./// The implementation is provided by the [getrandom] crate. Refer to/// [getrandom] documentation for details./// This struct is only available when specifying the crate feature `getrandom`/// or `std`. When using the `rand` lib, it is also available as `rand::rngs::OsRng`./// # Blocking and error handling/// It is possible that when used during early boot the first call to `OsRng`/// will block until the system's RNG is initialised. It is also possible/// (though highly unlikely) for `OsRng` to fail on some platforms, most/// likely due to system mis-configuration./// After the first successful call, it is highly unlikely that failures or/// significant delays will occur (although performance should be expected to/// be much slower than a user-space PRNG)./// # Usage example/// use rand_core::{RngCore, OsRng};/// let mut key = [0u8; 16];/// OsRng.fill_bytes(&mut key);/// let random_u64 = OsRng.next_u64();/// [getrandom]: https://crates.io/crates/getrandomtest_os_rngtest_construction// Copyright 2019 Developers of the Rand project.//! Interface to the random number generator of the operating system./// A marker trait used to indicate that an [`RngCore`] implementation is/// supposed to be cryptographically secure./// See [`CryptoRng`] docs for more information./// [`fill_bytes`] is called on a large array. These methods also handle/// the bookkeeping of when to generate a new batch of values./// significant first. [`fill_bytes`] consume a whole number of `u32` values,/// converting each `u32` to a byte slice in little-endian order. If the requested byte/// length is not a multiple of 4, some bytes will be discarded.try_from_rng/// [`fill_bytes`] consumes a whole number of `u64` values. If the requested length/// is not a multiple of 8, some bytes will be discarded.//! // optionally, also implement CryptoBlockRng for MyRngCore/// Fill dest from src/// Returns `(n, byte_len)`. `src[..n]` is consumed,/// `dest[..byte_len]` is filled. `src[n..]` and `dest[byte_len..]` are left/// unaltered./// `src` is not modified; it is taken as a `&mut` reference for backward/// compatibility with previous versions that did change it./// If `dst` has insufficient space (`4*dst.len() < src.len()`)./// If `dst` has insufficient space (`8*dst.len() < src.len()`)./// via [`impls::fill_bytes_via_next`]./// Implementation-level interface for RNGs/// End users should normally use the [`rand::Rng`] trait/// Note that implementors of [`RngCore`] also automatically implement/// the [`TryRngCore`] trait with the `Error` associated type being/// equal to [`Infallible`]./// use rand_core::{RngCore, impls};///     fn fill_bytes(&mut self, dst: &mut [u8]) {///         impls::fill_bytes_via_next(self, dst)/// [`rand::Rng`]: https://docs.rs/rand/latest/rand/trait.Rng.html/// [`Infallible`]: core::convert::Infallible/// A marker trait over [`RngCore`] for securely unpredictable RNGs/// This marker trait indicates that the implementing generator is intended,/// when correctly seeded and protected from side-channel attacks such as a/// leaking of state, to be a cryptographically secure generator. This trait is/// provided as a tool to aid review of cryptographic code, but does not by/// itself guarantee suitability for cryptographic applications./// Implementors of `CryptoRng` automatically implement the [`TryCryptoRng`]/// Implementors of `CryptoRng` should only implement [`Default`] if the/// `default()` instances are themselves secure generators: for example if the/// implementing type is a stateless interface over a secure external generator/// (like [`OsRng`]) or if the `default()` instance uses a strong, fresh seed./// Formally, a CSPRNG (Cryptographically Secure Pseudo-Random Number Generator)/// should satisfy an additional property over other generators: assuming that/// the generator has been appropriately seeded and has unknown state, then/// given the first *k* bits of an algorithm's output/// An optional property of CSPRNGs is backtracking resistance: if the CSPRNG's/// state is revealed, it will not be computationally-feasible to reconstruct/// prior output values. This property is not required by `CryptoRng`./// The type returned in the event of a RNG error.try_next_u32try_next_u64unwrap_errUnwrapErr/// Wrap RNG with the [`UnwrapErr`] wrapper.unwrap_mutUnwrapMut/// Wrap RNG with the [`UnwrapMut`] wrapper./// A potentially fallible variant of [`RngCore`]/// This trait is a generalization of [`RngCore`] to support potentially-/// fallible IO-based generators such as [`OsRng`]./// All implementations of [`RngCore`] automatically support this `TryRngCore`/// trait, using [`Infallible`][core::convert::Infallible] as the associated/// `Error` type./// An implementation of this trait may be made compatible with code requiring/// an [`RngCore`] through [`TryRngCore::unwrap_err`]. The resulting RNG will/// panic in case the underlying fallible RNG yields an error.// Note that, unfortunately, this blanket impl prevents us from implementing// `TryRngCore` for types which can be dereferenced to `TryRngCore`, i.e. `TryRngCore`// will not be automatically implemented for `&mut R`, `Box<R>`, etc./// A marker trait over [`TryRngCore`] for securely unpredictable RNGs/// This trait is like [`CryptoRng`] but for the trait [`TryRngCore`]./// Implementors of `TryCryptoRng` should only implement [`Default`] if the/// Wrapper around [`TryRngCore`] implementation which implements [`RngCore`]/// by panicking on potential errors./// Reborrow with a new lifetime/// Rust allows references like `&T` or `&mut T` to be "reborrowed" through/// coercion: essentially, the pointer is copied under a new, shorter, lifetime./// Until rfcs#1403 lands, reborrows on user types require a method call./// Note that [`Default`] is not implemented for large arrays `[u8; N]` with/// `N` > 32. To be able to implement the traits required by `SeedableRng`/// for RNGs with such large seeds, the newtype pattern can be used:/// impl AsRef<[u8]> for MyRngSeed {///     fn as_ref(&self) -> &[u8] {/// Create a new PRNG seeded from an infallible `Rng`./// Create a new PRNG seeded from a potentially fallible `Rng`./// See [`from_rng`][SeedableRng::from_rng] docs for more information./// A generator implementing `SeedableRng` will usually be deterministic, but/// beware that portability and reproducibility of results **is not implied**./// Refer to documentation of the generator, noting that generators named after/// a specific algorithm are usually tested for reproducibility against a/// reference vector, while `SmallRng` and `StdRng` specifically opt out of/// reproducibility guarantees./// An interface over the operating-system's random data source/// This is a zero-sized struct. It can be freely constructed with just `OsRng`./// This struct is available as `rand_core::OsRng` and as `rand::rngs::OsRng`./// In both cases, this requires the crate feature `os_rng` or `std`/// (enabled by default in `rand` but not in `rand_core`)./// be much slower than a user-space/// [PRNG](https://rust-random.github.io/book/guide-gen.html#pseudo-random-number-generators))./// use rand_core::{TryRngCore, OsRng};/// OsRng.try_fill_bytes(&mut key).unwrap();/// let random_u64 = OsRng.try_next_u64().unwrap();/// Error type of [`OsRng`]// NOTE: this can use core::error::Error from rustc 1.81.0/// A cryptographically secure random number generator that uses the HC-128/// HC-128 is a stream cipher designed by Hongjun Wu[^1], that we use as an/// RNG. It is selected as one of the "stream ciphers suitable for widespread/// adoption" by eSTREAM[^2]./// HC-128 is an array based RNG. In this it is similar to RC-4 and ISAAC before/// it, but those have never been proven cryptographically secure (or have even/// been significantly compromised, as in the case of RC-4[^5])./// Because HC-128 works with simple indexing into a large array and with a few/// operations that parallelize well, it has very good performance. The size of/// the array it needs, 4kb, can however be a disadvantage./// This implementation is not based on the version of HC-128 submitted to the/// eSTREAM contest, but on a later version by the author with a few small/// improvements from December 15, 2009[^3]./// HC-128 has no known weaknesses that are easier to exploit than doing a/// brute-force search of 2<sup>128</sup>. A very comprehensive analysis of the/// current state of known attacks / weaknesses of HC-128 is given in *Some/// Results On Analysis And Implementation Of HC-128 Stream Cipher*[^4]./// The average cycle length is expected to be/// 2<sup>1024*32+10-1</sup> = 2<sup>32777</sup>./// We support seeding with a 256-bit array, which matches the 128-bit key/// concatenated with a 128-bit IV from the stream cipher./// ## References/// [^1]: Hongjun Wu (2008). ["The Stream Cipher HC-128"](///       http://www.ecrypt.eu.org/stream/p3ciphers/hc/hc128_p3.pdf).///       *The eSTREAM Finalists*, LNCS 4986, pp. 39–47, Springer-Verlag./// [^3]: Hongjun Wu, [Stream Ciphers HC-128 and HC-256](///       https://www.ntu.edu.sg/home/wuhj/research/hc/index.html)/// [^4]: Shashwat Raizada (January 2015),["Some Results On Analysis And///       Implementation Of HC-128 Stream Cipher"](///       http://library.isical.ac.in:8080/jspui/bitstream/123456789/6636/1/TH431.pdf)./// [^5]: Internet Engineering Task Force (February 2015),///       ["Prohibiting RC4 Cipher Suites"](https://tools.ietf.org/html/rfc7465).counter1024/// The core of `Hc128Rng`, used with `BlockRng`.step_p// One step of HC-128, update P and generate 32 bits keystreamstep_q// One step of HC-128, update Q and generate 32 bits keystream// Similar to `step_p`, but `p` and `q` are swapped, and the rotates are to// the left instead of to the right.sixteen_steps// Initialize an HC-128 random number generator. The seed has to be// 256 bits in length (`[u32; 8]`), matching the 128 bit `key` followed by// 128 bit `iv` when HC-128 where to be used as a stream cipher./// Create an HC-128 random number generator with a seed. The seed has to be/// 256 bits in length, matching the 128 bit `key` followed by 128 bit `iv`/// when HC-128 where to be used as a stream cipher.test_hc128_true_values_a// Test vector 1 from the paper "The Stream Cipher HC-128"test_hc128_true_values_b// Test vector 2 from the paper "The Stream Cipher HC-128"test_hc128_true_values_c// Test vector 3 from the paper "The Stream Cipher HC-128"test_hc128_true_values_u64test_hc128_true_values_bytestest_hc128_clone//! The HC-128 random number generator.// 128 bit key followed by 128 bit iv//! The HC128 random number generator.isaac_arrayIsaacArrayw32RAND_SIZE_LENRAND_SIZEIsaacCore/// A random number generator that uses the ISAAC algorithm./// ISAAC stands for "Indirection, Shift, Accumulate, Add, and Count" which are/// the principal bitwise operations employed. It is the most advanced of a/// series of array based random number generator designed by Robert Jenkins/// in 1996[^1][^2]./// ISAAC is notably fast and produces excellent quality random numbers for/// non-cryptographic applications./// In spite of being designed with cryptographic security in mind, ISAAC hasn't/// been stringently cryptanalyzed and thus cryptographers do not not/// consensually trust it to be secure. When looking for a secure RNG, prefer/// [`Hc128Rng`] instead, which, like ISAAC, is an array-based RNG and one of/// the stream-ciphers selected the by eSTREAM contest./// In 2006 an improvement to ISAAC was suggested by Jean-Philippe Aumasson,/// named ISAAC+[^3]. But because the specification is not complete, because/// there is no good implementation, and because the suggested bias may not/// exist, it is not implemented here./// ## Overview of the ISAAC algorithm:/// (in pseudo-code)/// Input: a, b, c, s[256] // state/// Output: r[256]         // results/// mix(a,i) = a ^ a << 13   if i = 0 mod 4///            a ^ a >>  6   if i = 1 mod 4///            a ^ a <<  2   if i = 2 mod 4///            a ^ a >> 16   if i = 3 mod 4/// c = c + 1/// b = b + c/// for i in 0..256 {///     x = s_[i]///     a = f(a,i) + s[i+128 mod 256]///     y = a + b + s[x>>2 mod 256]///     s[i] = y///     b = x + s[y>>10 mod 256]///     r[i] = b/// Numbers are generated in blocks of 256. This means the function above only/// runs once every 256 times you ask for a next random number. In all other/// circumstances the last element of the results array is returned./// ISAAC therefore needs a lot of memory, relative to other non-crypto RNGs./// 2 * 256 * 4 = 2 kb to hold the state and results./// This implementation uses [`BlockRng`] to implement the [`RngCore`] methods./// [^1]: Bob Jenkins, [*ISAAC: A fast cryptographic random number generator*](///       http://burtleburtle.net/bob/rand/isaacafa.html)/// [^2]: Bob Jenkins, [*ISAAC and RC4*](///       http://burtleburtle.net/bob/rand/isaac.html)/// [^3]: Jean-Philippe Aumasson, [*On the pseudo-random generator ISAAC*](///       https://eprint.iacr.org/2006/438)/// [`Hc128Rng`]: ../../rand_hc/struct.Hc128Rng.html/// [`BlockRng`]: ../../rand_core/block/struct.BlockRng.html/// [`RngCore`]: ../../rand_core/trait.RngCore.html/// Create an ISAAC random number generator using an `u64` as seed./// If `seed == 0` this will produce the same stream of random numbers as/// the reference implementation when used unseeded./// The core of `IsaacRng`, used with `BlockRng`./// Refills the output buffer, `results`. See also the pseudocode desciption/// of the algorithm in the [`IsaacRng`] documentation./// Optimisations used (similar to the reference implementation):/// - The loop is unrolled 4 times, once for every constant of mix()./// - The contents of the main loop are moved to a function `rngstep`, to///   reduce code duplication./// - We use local variables for a and b, which helps with optimisations./// - We split the main loop in two, one that operates over 0..128 and one///   over 128..256. This way we can optimise out the addition and modulus///   from `s[i+128 mod 256]`./// - We maintain one index `i` and add `m` or `m2` as base (m2 for the///   `s[i+128 mod 256]`), relying on the optimizer to turn it into pointer///   arithmetic./// - We fill `results` backwards. The reference implementation reads values///   from `results` in reverse. We read them in the normal direction, to///   make `fill_bytes` a memcopy. To maintain compatibility we fill in///   reverse./// [`IsaacRng`]: struct.IsaacRng.html/// Create a new ISAAC random number generator./// The author Bob Jenkins describes how to best initialize ISAAC here:/// <https://rt.cpan.org/Public/Bug/Display.html?id=64324>/// The answer is included here just in case:/// "No, you don't need a full 8192 bits of seed data. Normal key sizes will/// do fine, and they should have their expected strength (eg a 40-bit key/// will take as much time to brute force as 40-bit keys usually will). You/// could fill the remainder with 0, but set the last array element to the/// length of the key provided (to distinguish keys that differ only by/// different amounts of 0 padding). You do still need to call `randinit()`/// to make sure the initial state isn't uniform-looking."/// "After publishing ISAAC, I wanted to limit the key to half the size of/// `r[]`, and repeat it twice. That would have made it hard to provide a/// key that sets the whole internal state to anything convenient. But I'd/// already published it."/// And his answer to the question "For my code, would repeating the key/// over and over to fill 256 integers be a better solution than/// zero-filling, or would they essentially be the same?":/// "If the seed is under 32 bytes, they're essentially the same, otherwise/// repeating the seed would be stronger. randinit() takes a chunk of 32/// bytes, mixes it, and combines that with the next 32 bytes, et cetera./// Then loops over all the elements the same way a second time."test_isaac_constructiontest_isaac_true_values_32test_isaac_true_values_64test_isaac_true_bytestest_isaac_new_uninitializedtest_isaac_clone// Copyright 2013-2018 The Rust Project Developers.//! The ISAAC random number generator.w64Isaac64Core/// A random number generator that uses ISAAC-64, the 64-bit variant of the/// ISAAC algorithm./// in 1996[^1]./// ISAAC-64 is mostly similar to ISAAC. Because it operates on 64-bit integers/// instead of 32-bit, it uses twice as much memory to hold its state and/// results. Also it uses different constants for shifts and indirect indexing,/// optimized to give good results for 64bit arithmetic./// ISAAC-64 is notably fast and produces excellent quality random numbers for/// ## Overview of the ISAAC-64 algorithm:/// Output: r[256] // results/// mix(a,i) = !(a ^ a << 21)  if i = 0 mod 4///              a ^ a >>  5   if i = 1 mod 4///              a ^ a << 12   if i = 2 mod 4///              a ^ a >> 33   if i = 3 mod 4///     a = mix(a,i) + s[i+128 mod 256]///     y = a + b + s[x>>3 mod 256]///     b = x + s[y>>11 mod 256]/// This implementation uses [`BlockRng64`] to implement the [`RngCore`] methods./// See for more information the documentation of [`IsaacRng`]./// [^1]: Bob Jenkins, [*ISAAC and RC4*](/// [`IsaacRng`]: ../isaac/struct.IsaacRng.html/// [`BlockRng64`]: ../../rand_core/block/struct.BlockRng64.html/// Create an ISAAC-64 random number generator using an `u64` as seed./// The core of `Isaac64Rng`, used with `BlockRng`./// of the algorithm in the [`Isaac64Rng`] documentation./// [`Isaac64Rng`]: struct.Isaac64Rng.html/// Create a new ISAAC-64 random number generator.test_isaac64_constructiontest_isaac64_true_values_64test_isaac64_true_values_32test_isaac64_true_values_mixedtest_isaac64_true_bytestest_isaac64_new_uninitializedtest_isaac64_clone//! The ISAAC-64 random number generator.//! ISAAC helper functions for 256-element arrays.// Terrible workaround because arrays with more than 32 elements do not// implement `AsRef`, `Default`, `Serialize`, `Deserialize`, or any other// traits for that matter.//! The ISAAC and ISAAC-64 random number generators.NoTimer/// No timer available.CoarseTimer/// Timer too coarse to use as an entropy source.NotMonotonic/// Timer is not monotonically increasing.TinyVariantions/// Variations of deltas of time too small.TooManyStuck/// Too many stuck results (indicating no added entropy)./// An error that can occur when [`JitterRng::test_timer`] fails./// [`JitterRng::test_timer`]: crate::JitterRng::test_timer// Copyright 2013-2015 The Rust Project Developers.dummy_log// Required for compatibility with Rust < 1.24.MEMORY_BLOCKSMEMORY_BLOCKSIZEMEMORY_SIZE// Actual random number// Number of rounds to run the entropy collector per 64 bits// Timer used by `measure_jitter`mem_prev_index// Memory for the Memory Access noise sourcedata_half_used// Make `next_u32` not waste 32 bits/// A true random number generator based on jitter in the CPU execution time,/// and jitter in memory access time.prev_time// Previous time stamp to determine the timer deltalast_delta// Deltas used for the stuck testlast_delta2EcState// Entropy collector state.// These values are not necessary to preserve across runs.stuck// Stuck test by checking the:// - 1st derivation of the jitter measurement (time delta)// - 2nd derivation of the jitter measurement (delta of time deltas)// - 3rd derivation of the jitter measurement (delta of delta of time//   deltas)// All values must always be non-zero.// This test is a heuristic to see whether the last measurement holds// entropy.JITTER_ROUNDS// Initialise to zero; must be positive/// Create a new `JitterRng`. Makes use of `std::time` for a timer, or a/// platform-specific function with higher accuracy if necessary and/// During initialization CPU execution timing jitter is measured a few/// hundred times. If this does not pass basic quality tests, an error is/// returned. The test result is cached to make subsequent calls faster./// Create a new `JitterRng`./// A custom timer can be supplied, making it possible to use `JitterRng` in/// `no_std` environments./// The timer must have nanosecond precision./// This method is more low-level than `new()`. It is the responsibility of/// the caller to run [`test_timer`] before using any numbers generated with/// `JitterRng`, and optionally call [`set_rounds`]. Also it is important to/// consume at least one `u64` before using the first result to initialize/// the entropy collection pool./// # use rand_jitter::rand_core::{RngCore, Error};/// use rand_jitter::JitterRng;/// fn get_nstime() -> u64 {///     use std::time::{SystemTime, UNIX_EPOCH};///     let dur = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();///     // The correct way to calculate the current time is///     // `dur.as_secs() * 1_000_000_000 + dur.subsec_nanos() as u64`///     // But this is faster, and the difference in terms of entropy is///     // negligible (log2(10^9) == 29.9).///     dur.as_secs() << 30 | dur.subsec_nanos() as u64/// let mut rng = JitterRng::new_with_timer(get_nstime);/// let rounds = rng.test_timer()?;/// rng.set_rounds(rounds); // optional/// let _ = rng.next_u64();/// // Ready for use/// let v: u64 = rng.next_u64();/// # let _ = try_inner();/// [`test_timer`]: JitterRng::test_timer/// [`set_rounds`]: JitterRng::set_rounds/// Configures how many rounds are used to generate each 64-bit value./// This must be greater than zero, and has a big impact on performance/// and output quality./// [`new_with_timer`] conservatively uses 64 rounds, but often less rounds/// can be used. The `test_timer()` function returns the minimum number of/// rounds required for full strength (platform dependent), so one may use/// `rng.set_rounds(rng.test_timer()?);` or cache the value./// [`new_with_timer`]: JitterRng::new_with_timerrandom_loop_cnt// Calculate a random loop count used for the next round of an entropy// collection, based on bits from a fresh value from the timer.// The timer is folded to produce a number that contains at most `n_bits`// Note: A constant should be added to the resulting random loop count to// prevent loops that run 0 times.lfsr_time// CPU jitter noise source// Noise source based on the CPU execution time jitter// This function injects the individual bits of the time value into the// entropy pool using an LFSR.// The code is deliberately inefficient with respect to the bit shifting.// This function not only acts as folding operation, but this function's// execution is used to measure the CPU execution time jitter. Any change to// the loop in this function implies that careful retesting must be done.memaccess// Memory Access noise source// This is a noise source based on variations in memory access times// This function performs memory accesses which will add to the timing// variations due to an unknown amount of CPU wait states that need to be// added when accessing memory. The memory size should be larger than the L1// caches as outlined in the documentation and the associated testing.// The L1 cache has a very high bandwidth, albeit its access rate is usually// slower than accessing CPU registers. Therefore, L1 accesses only add// minimal variations as the CPU has hardly to wait. Starting with L2,// significant variations are added because L2 typically does not belong to// the CPU any more and therefore a wider range of CPU wait states is// necessary for accesses. L3 and real memory accesses have even a wider// range of wait states. However, to reliably access either L3 or memory,// the `self.mem` memory must be quite large which is usually not desirable.measure_jitter// This is the heart of the entropy generation: calculate time deltas and// use the CPU jitter in the time deltas. The jitter is injected into the// entropy pool.// Ensure that `ec.prev_time` is primed before using the output of this// function. This can be done by calling this function and not using its// result.stir_pool// Shuffle the pool a bit by mixing some value with a bijective function// (XOR) into the pool.// The function generates a mixer value that depends on the bits set and// the location of the set bits in the random number generated by the// entropy source. Therefore, based on the generated random number, this// mixer value can have 2^64 different values. That mixer value is// initialized with the first two SHA-1 constants. After obtaining the// mixer value, it is XORed into the random number.// The mixer value is not assumed to contain any entropy. But due to the// XOR operation, it can also not destroy any entropy present in thegen_entropy/// Basic quality tests on the timer, by measuring CPU timing jitter a few/// hundred times./// If successful, this will return the estimated number of rounds necessary/// to collect 64 bits of entropy. Otherwise a [`TimerError`] with the cause/// of the failure will be returned./// Statistical test: return the timer delta of one normal run of the/// `JitterRng` entropy collector./// Setting `var_rounds` to `true` will execute the memory access and the/// CPU jitter noice sources a variable amount of times (just like a real/// `JitterRng` round)./// Setting `var_rounds` to `false` will execute the noice sources the/// minimal number of times. This can be used to measure the minimum amount/// of entropy one round of the entropy collector can collect in the worst/// See this crate's README on how to use `timer_stats` to test the quality/// of `JitterRng`.// A function that is opaque to the optimizer to assist in avoiding dead-code// elimination. Taken from `bencher`.// Based on jitterentropy-library, http://www.chronox.de/jent.html.// Copyright Stephan Mueller <smueller@chronox.de>, 2014 - 2017.// With permission from Stephan Mueller to relicense the Rust translation under// the MIT license.//! Non-physical true random number generator based on timing jitter.//! This is a true random number generator, as opposed to pseudo-random//! generators. Random numbers generated by `JitterRng` can be seen as fresh//! entropy. A consequence is that it is orders of magnitude slower than `OsRng`//! and PRNGs (about 10<sup>3</sup>..10<sup>6</sup> slower).//! There are very few situations where using this RNG is appropriate. Only very//! few applications require true entropy. A normal PRNG can be statistically//! indistinguishable, and a cryptographic PRNG should also be as impossible to//! predict.//! Use of `JitterRng` is recommended for initializing cryptographic PRNGs when//! `OsRng` is not available.//! `JitterRng` can be used without the standard library, but not conveniently,//! you must provide a high-precision timer and carefully have to follow the//! instructions of [`JitterRng::new_with_timer`].//! This implementation is based on [Jitterentropy] version 2.1.0.//! Note: There is no accurate timer available on WASM platforms, to help//! prevent fingerprinting or timing side-channel attacks. Therefore//! [`JitterRng::new()`] is not available on WASM. It is also unavailable//! with disabled `std` feature.//! [Jitterentropy]: http://www.chronox.de/jent.html// Note: the C implementation of `Jitterentropy` relies on being compiled// without optimizations. This implementation goes through lengths to make the// compiler not optimize out code which does influence timing jitter, but is// technically dead code.// Note: `JitterRng` maintains a small 64-bit entropy pool. With every// `generate` 64 new bits should be integrated in the pool. If a round of// `generate` were to collect less than the expected 64 bit, then the returned// value, and the new state of the entropy pool, would be in some way related to// the initial state. It is therefore better if the initial state of the entropy// pool is different on each call to `generate`. This has a few implications:// - `generate` should be called once before using `JitterRng` to produce the//   first usable value (this is done by default in `new`);// - We do not zero the entropy pool after generating a result. The reference//   implementation also does not support zeroing, but recommends generating a//   new value without using it if you want to protect a previously generated//   'secret' value from someone inspecting the memory;// - Implementing `Clone` seems acceptable, as it would not cause the systematic//   bias a constant might cause. Only instead of one value that could be//   potentially related to the same initial state, there are now two.get_nstimecloudabiOsRngImplfill_chunkmethod_str//! Implementation for CloudABIrandom_device//! Implementation for DragonFly / Haiku / Emscripten//! Implementation for FreeBSDfuchsia_cprng/// A random number generator that retrieves randomness straight from the/// Create a new `OsRng`.// Create a new `OsRng` platform interface.// Fill a chunk with random bytes.// Test whether the OS RNG is initialized. This method may not be possible// to support cheaply (or at all) on all operating systems.// If `blocking` is set, this will cause the OS the block execution until// its RNG is initialized.// Random values that are read while this are stored in `dest`, the amount// of read bytes is returned.// Maximum chunk size supported.// Name of the OS interface (used for logging).mod_use//! [`OsRng`] is the preferred external source of entropy for most applications.//! Commonly it is used to initialize a user-space RNG, which can then be used//! to generate random values with much less overhead than `OsRng`.//! You may prefer to use [`EntropyRng`] instead of `OsRng`. It is unlikely, but//! not entirely theoretical, for `OsRng` to fail. In such cases [`EntropyRng`]//! falls back on a good alternative entropy source.//! [`OsRng::new()`] is guaranteed to be very cheap (after the first successful//! call), and will never consume more than one file handle per process.//! # Usage example//! use rand_os::OsRng;//! use rand_os::rand_core::RngCore;//! let mut os_rng = OsRng::new().unwrap();//! let mut key = [0u8; 16];//! os_rng.fill_bytes(&mut key);//! let random_u64 = os_rng.next_u64();//! # Platform sources//! | OS               | interface//! |------------------|---------------------------------------------------------//! | Linux, Android   | [`getrandom`][1] system call if available, otherwise [`/dev/urandom`][2] after reading from `/dev/random` once//! | Windows          | [`RtlGenRandom`][3]//! | macOS, iOS       | [`SecRandomCopyBytes`][4]//! | FreeBSD          | [`kern.arandom`][5]//! | OpenBSD, Bitrig  | [`getentropy`][6]//! | NetBSD           | [`/dev/urandom`][7] after reading from `/dev/random` once//! | Dragonfly BSD    | [`/dev/random`][8]//! | Solaris, illumos | [`getrandom`][9] system call if available, otherwise [`/dev/random`][10]//! | Fuchsia OS       | [`cprng_draw`][11]//! | Redox            | [`rand:`][12]//! | CloudABI         | [`random_get`][13]//! | Haiku            | `/dev/random` (identical to `/dev/urandom`)//! | Web browsers     | [`Crypto.getRandomValues`][14] (see [Support for WebAssembly and ams.js][14])//! | Node.js          | [`crypto.randomBytes`][15] (see [Support for WebAssembly and ams.js][16])//! Rand doesn't have a blanket implementation for all Unix-like operating//! systems that reads from `/dev/urandom`. This ensures all supported operating//! systems are using the recommended interface and respect maximum buffer//! sizes.//! ## Support for WebAssembly and ams.js//! The three Emscripten targets `asmjs-unknown-emscripten`,//! `wasm32-unknown-emscripten` and `wasm32-experimental-emscripten` use//! Emscripten's emulation of `/dev/random` on web browsers and Node.js.//! The bare WASM target `wasm32-unknown-unknown` tries to call the javascript//! methods directly, using either `stdweb` or `wasm-bindgen` depending on what//! features are activated for this crate. Note that if both features are//! enabled `wasm-bindgen` will be used.//! It is possible that early in the boot process the OS hasn't had enough time//! yet to collect entropy to securely seed its RNG, especially on virtual//! machines.//! Some operating systems always block the thread until the RNG is securely//! Others make a best effort to use a seed from before the shutdown and don't//! document much.//! A few, Linux, NetBSD and Solaris, offer a choice between blocking, and//! getting an error. With `try_fill_bytes` we choose to get the error//! ([`ErrorKind::NotReady`]), while the other methods use a blocking interface.//! On Linux (when the `genrandom` system call is not available) and on NetBSD//! reading from `/dev/urandom` never blocks, even when the OS hasn't collected//! enough entropy yet. As a countermeasure we try to do a single read from//! `/dev/random` until we know the OS RNG is initialized (and store this in a//! global static).//! # Panics and error handling//! We cannot guarantee that `OsRng` will fail, but if it does, it will likely//! be either when `OsRng::new()` is first called or when data is first read.//! If you wish to catch errors early, then test reading of at least one byte//! from `OsRng` via [`try_fill_bytes`]. If this succeeds, it is extremely//! unlikely that any further errors will occur.//! Only [`try_fill_bytes`] is able to report the cause of an error; the other//! [`RngCore`] methods may (depending on the error kind) retry several times,//! but must eventually panic if the error persists.//! [`EntropyRng`]: ../rand/rngs/struct.EntropyRng.html//! [`try_fill_bytes`]: RngCore::try_fill_bytes//! [`ErrorKind::NotReady`]: rand_core::ErrorKind//! [1]: http://man7.org/linux/man-pages/man2/getrandom.2.html//! [2]: http://man7.org/linux/man-pages/man4/urandom.4.html//! [3]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx//! [4]: https://developer.apple.com/documentation/security/1399291-secrandomcopybytes?language=objc//! [5]: https://www.freebsd.org/cgi/man.cgi?query=random&sektion=4//! [6]: https://man.openbsd.org/getentropy.2//! [7]: http://netbsd.gw.com/cgi-bin/man-cgi?random+4+NetBSD-current//! [8]: https://leaf.dragonflybsd.org/cgi/web-man?command=random&section=4//! [9]: https://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html//! [10]: https://docs.oracle.com/cd/E86824_01/html/E54777/random-7d.html//! [11]: https://fuchsia.googlesource.com/zircon/+/HEAD/docs/syscalls/cprng_draw.md//! [12]: https://github.com/redox-os/randd/blob/master/src/main.rs//! [13]: https://github.com/NuxiNL/cloudabi/blob/v0.20/cloudabi.txt#L1826//! [14]: https://www.w3.org/TR/WebCryptoAPI/#Crypto-method-getRandomValues//! [15]: https://nodejs.org/api/crypto.html#crypto_crypto_randombytes_size_callback//! [16]: #support-for-webassembly-and-amsjsOsRngMethodGetRandomRandomDeviceNR_GETRANDOMgetrandom_try_fill//! Implementation for Linux / AndroidkSecRandomDefault//! Implementation for MacOS / iOS// Read a single byte from `/dev/random` to determine if the OS RNG is// already seeded. NetBSD always blocks if not yet ready.//! Implementation for OpenBSD / BitrigREAD_RNG_FILE// TODO: remove outer Option when `Mutex::new(None)` is a constant expressionREAD_RNG_ONCE//! Helper functions to read from a random device such as `/dev/urandom`.//! All instances use a single internal file handle, to prevent possible//! exhaustion of file descriptors.//! Implementation for RedoxRdRand// Use dlsym to determine if getrandom(2) is present in libc.  On Solarish// systems, the syscall interface is not stable and can change between// updates.  Even worse, issuing unsupported syscalls will cause the system// to generate a SIGSYS signal (usually terminating the program).// Instead the stable APIs are exposed via libc.  Cache the result of the// lookup for future calls.  This is loosely modeled after the// libstd::sys::unix::weak macro which unfortunately is not exported.//! Implementation for the Solaris family//! Read from `/dev/random`, with chunks of limited size (1040 bytes).//! `/dev/random` uses the Hash_DRBG with SHA512 algorithm from NIST SP 800-90A.//! `/dev/urandom` uses the FIPS 186-2 algorithm, which is considered less//! secure. We choose to read from `/dev/random`.//! Since Solaris 11.3 the `getrandom` syscall is available. To make sure we can//! compile on both Solaris and on OpenSolaris derivatives, that do not have the//! function, we do a direct syscall instead of calling a library function.//! We have no way to differentiate between Solaris, illumos, SmartOS, etc.__wbg_shimsBrowserCrypto//! Implementation for WASM via wasm-bindgenstdwebWebError//! Implementation for WASM via stdwebntsecapipcg128Lcg64Xsh32Mcg128Xsl64//! The PCG random number generators.//! This is a native Rust implementation of a small selection of PCG generators.//! The primary goal of this crate is simple, minimal, well-tested code; in//! other words it is explicitly not a goal to re-implement all of PCG.//! This crate provides://! -   `Pcg32` aka `Lcg64Xsh32`, officially known as `pcg32`, a general//!     purpose RNG. This is a good choice on both 32-bit and 64-bit CPUs//!     (for 32-bit output).//! -   `Pcg64Mcg` aka `Mcg128Xsl64`, officially known as `mcg_xsl_rr_128_64`,//!     a general purpose RNG using 128-bit multiplications. This has poor//!     performance on 32-bit CPUs but is a good choice on 64-bit CPUs for//!     both 32-bit and 64-bit output. (Note: this RNG is only available using//!     Rust 1.26 or later.)//! Both of these use 16 bytes of state and 128-bit seeds, and are considered//! value-stable (i.e. any change affecting the output given a fixed seed would//! be considered a breaking change to the crate).MULTIPLIER// This is the default multiplier used by PCG for 64-bit state./// A PCG random number generator (XSL 128/64 (MCG) variant)./// Permuted Congruential Generator with 128-bit state, internal Multiplicative/// Congruential Generator, and 64-bit output via "xorshift low (bits),/// random rotation" output function./// This is a 128-bit MCG with the PCG-XSL-RR output function./// Note that compared to the standard `pcg64` (128-bit LCG with PCG-XSL-RR/// output function), this RNG is faster, also has a long cycle, and still has/// good performance on statistical tests./// Note: this RNG is only available using Rust 1.26 or later./// A friendly name for `Mcg128Xsl64`./// Construct an instance compatible with PCG seed./// Note that PCG specifies a default value for the parameter:/// - `state = 0xcafef00dd15ea5e5`/// We use a single 126-bit seed to initialise the state and select a stream./// Two `seed` bits (lowest order of last byte) are ignored.// Copyright 2017 Paul Dicker.// Copyright 2014-2017 Melissa O'Neill and PCG Project contributors//! PCG random number generators/// A PCG random number generator (XSH RR 64/32 (LCG) variant)./// Permuted Congruential Generator with 64-bit state, internal Linear/// Congruential Generator, and 32-bit output via "xorshift high (bits),/// This is a 64-bit LCG with explicitly chosen stream with the PCG-XSH-RR/// output function. This combination is the standard `pcg32`./// Despite the name, this implementation uses 16 bytes (128 bit) space/// comprising 64 bits of state and 64 bits stream selector. These are both set/// by `SeedableRng`, using a 128-bit seed./// `Lcg64Xsh32` is also officially known as `pcg32`./// Construct an instance compatible with PCG seed and stream./// Note that PCG specifies default values for both parameters:/// - `stream = 721347520444481703`from_state_incr/// We use a single 127-bit seed to initialise the state and select a stream./// One `seed` bit (lowest bit of `seed[8]`) is ignored./// An Xorshift random number generator./// The Xorshift[^1] algorithm is not suitable for cryptographic purposes/// but is very fast. If you do not know for sure that it fits your/// requirements, use a more secure one such as `StdRng` or `OsRng`./// [^1]: Marsaglia, George (July 2003).///       ["Xorshift RNGs"](https://www.jstatsoft.org/v08/i14/paper).///       *Journal of Statistical Software*. Vol. 8 (Issue 14).//! The xorshift random number generator./// When seeded with zero (i.e. `XorShiftRng::from_seed(0)` is called), this implementation/// actually uses `0xBAD_5EED_0BAD_5EED_0BAD_5EED_0BAD_5EED` for the seed. This arbitrary value is/// used because the underlying algorithm can't escape from an all-zero state, and the function is/// infallible so it can't signal this by returning an error.//! To initialize a generator, use the [`SeedableRng`][rand_core::SeedableRng] trait://! use rand_xorshift::XorShiftRng;//! let mut rng = XorShiftRng::seed_from_u64(0);//! let x = rng.next_u32();AndroidDisplayHandle/// Raw display handle for Android./// Create a new empty display handle./// # use raw_window_handle::AndroidDisplayHandle;/// let handle = AndroidDisplayHandle::new();/// Create an Android-based display handle./// As no data is borrowed by this handle, it is completely safe to create. This function/// may be useful to windowing framework implementations that want to avoid unsafe code./// # use raw_window_handle::{DisplayHandle, HasDisplayHandle};/// # fn do_something(rwh: impl HasDisplayHandle) { let _ = rwh; }/// let handle = DisplayHandle::android();/// do_something(handle);a_native_window/// A pointer to an `ANativeWindow`.AndroidNdkWindowHandle/// Raw window handle for Android NDK./// Create a new handle to an `ANativeWindow`./// # use core::ptr::NonNull;/// # use raw_window_handle::AndroidNdkWindowHandle;/// # type ANativeWindow = ();/// let ptr: NonNull<ANativeWindow>;/// # ptr = NonNull::from(&());/// let handle = AndroidNdkWindowHandle::new(ptr.cast());AppKitDisplayHandle/// Raw display handle for AppKit./// # use raw_window_handle::AppKitDisplayHandle;/// let handle = AppKitDisplayHandle::new();/// Create an AppKit-based display handle./// let handle = DisplayHandle::appkit();/// A pointer to an `NSView` object.AppKitWindowHandle/// Raw window handle for AppKit./// Note that `NSView` can only be accessed from the main thread of the/// application. This struct is `!Send` and `!Sync` to help with ensuring/// Getting the view from a [`WindowHandle`][crate::WindowHandle]./// # fn inner() {/// #![cfg(target_os = "macos")]/// # #[cfg(requires_objc2)]/// use objc2_app_kit::NSView;/// use objc2_foundation::is_main_thread;/// use objc2::rc::Id;/// use raw_window_handle::{WindowHandle, RawWindowHandle};/// let handle: WindowHandle<'_>; // Get the window handle from somewhere else/// # handle = unimplemented!();/// match handle.as_raw() {///     # #[cfg(requires_objc2)]///     RawWindowHandle::AppKit(handle) => {///         assert!(is_main_thread(), "can only access AppKit handles on the main thread");///         let ns_view = handle.ns_view.as_ptr();///         // SAFETY: The pointer came from `WindowHandle`, which ensures///         // that the `AppKitWindowHandle` contains a valid pointer to an///         // `NSView`.///         // Unwrap is fine, since the pointer came from `NonNull`.///         let ns_view: Id<NSView> = unsafe { Id::retain(ns_view.cast()) }.unwrap();///         // Do something with the NSView here, like getting the `NSWindow`///         let ns_window = ns_view.window().expect("view was not installed in a window");///     handle => unreachable!("unknown handle {handle:?} for platform"),/// Create a new handle to a view./// # use raw_window_handle::AppKitWindowHandle;/// # type NSView = ();/// let view: &NSView;/// # view = &();/// let handle = AppKitWindowHandle::new(NonNull::from(view).cast());/// Get a handle to the display controller of the windowing system./// A display that acts as a wrapper around a display handle./// Objects that implement this trait should be able to return a [`DisplayHandle`] for the display/// that they are associated with. This handle should last for the lifetime of the object, and should/// return an error if the application is inactive./// Implementors of this trait will be windowing systems, like [`winit`] and [`sdl2`]. These windowing/// systems should implement this trait on types that represent the top-level display server. It/// should be implemented by tying the lifetime of the [`DisplayHandle`] to the lifetime of the/// display object./// Users of this trait will include graphics libraries, like [`wgpu`] and [`glutin`]. These APIs/// should be generic over a type that implements `HasDisplayHandle`, and should use the/// [`DisplayHandle`] type to access the display handle./// Note that these requirements are not enforced on `HasDisplayHandle`, rather, they are enforced on the/// constructors of [`DisplayHandle`]. This is because the `HasDisplayHandle` trait is safe to implement./// [`winit`]: https://crates.io/crates/winit/// [`sdl2`]: https://crates.io/crates/sdl2/// [`wgpu`]: https://crates.io/crates/wgpu/// [`glutin`]: https://crates.io/crates/glutin/// The handle to the display controller of the windowing system./// This is the primary return type of the [`HasDisplayHandle`] trait. It is guaranteed to contain/// a valid platform-specific display handle for its lifetime./// Create a `DisplayHandle` from a [`RawDisplayHandle`]./// Users can safely assume that non-`null`/`0` fields are valid handles, and it is up to the/// implementer of this trait to ensure that condition is upheld./// Despite that qualification, implementors should still make a best-effort attempt to fill in all/// available fields. If an implementation doesn't, and a downstream user needs the field, it should/// try to derive the field from other fields the implementer *does* provide via whatever methods the/// platform provides./// It is not possible to invalidate a [`DisplayHandle`] on any platform without additional unsafe code./// Get the underlying raw display handle./// Get a handle to the window./// A handle to a window./// Objects that implement this trait should be able to return a [`WindowHandle`] for the window/// systems should implement this trait on types that represent windows./// should be generic over a type that implements `HasWindowHandle`, and should use the/// [`WindowHandle`] type to access the window handle. The window handle should be acquired and held/// while the window is being used, in order to ensure that the window is not deleted while it is in/// The handle to a window./// This is the primary return type of the [`HasWindowHandle`] trait. All *pointers* within this type/// are guaranteed to be valid and not dangling for the lifetime of the handle. This excludes window IDs/// like XIDs and the window ID for web platforms. See the documentation on the [`HasWindowHandle`]/// trait for more information about these safety requirements./// This handle is guaranteed to be safe and valid./// Borrow a `WindowHandle` from a [`RawWindowHandle`]./// Despite that qualification, implementers should still make a best-effort attempt to fill in all/// Note that this guarantee only applies to *pointers*, and not any window ID types in the handle./// This includes Window IDs (XIDs) from X11 and the window ID for web platforms. There is no way for/// Rust to enforce any kind of invariant on these types, since:/// - For all three listed platforms, it is possible for safe code in the same process to delete///   the window./// - For X11, it is possible for code in a different process to delete the window. In fact, it is///   possible for code on a different *machine* to delete the window./// It is *also* possible for the window to be replaced with another, valid-but-different window. User/// code should be aware of this possibility, and should be ready to soundly handle the possible error/// conditions that can arise from this./// Get the underlying raw window handle.//! Borrowable window handles based on the ones in this crate.//! These should be 100% safe to pass around and use, no possibility of dangling or invalidity.HaikuDisplayHandle/// Raw display handle for Haiku./// # use raw_window_handle::HaikuDisplayHandle;/// let handle = HaikuDisplayHandle::new();/// Create an Haiku-based display handle./// let handle = DisplayHandle::haiku();b_window/// A pointer to a BWindow objectb_direct_window/// A pointer to a BDirectWindow object that might be nullHaikuWindowHandle/// Raw window handle for Haiku./// Create a new handle to a window./// # use raw_window_handle::HaikuWindowHandle;/// # type BWindow = ();/// let b_window: NonNull<BWindow>;/// # b_window = NonNull::from(&());/// let mut handle = HaikuWindowHandle::new(b_window.cast());/// // Optionally set `b_direct_window`./// handle.b_direct_window = None;borroweduikitOhosDisplayHandleOhosNdkWindowHandleOrbitalDisplayHandleOrbitalWindowHandleUiKitDisplayHandleUiKitWindowHandleDrmDisplayHandleDrmWindowHandleGbmDisplayHandleGbmWindowHandleWaylandDisplayHandleWaylandWindowHandleXcbDisplayHandleXcbWindowHandleXlibDisplayHandleXlibWindowHandleWebCanvasWindowHandleWebDisplayHandleWebOffscreenCanvasWindowHandleWebWindowHandleWin32WindowHandleWinRtWindowHandleWindowsDisplayHandle"Use `HasWindowHandle` instead"HasRawWindowHandle/// Window that wraps around a raw window handle./// Users can safely assume that pointers and non-zero fields are valid, and it is up to the/// The exact handles returned by `raw_window_handle` must remain consistent between multiple calls/// to `raw_window_handle` as long as not indicated otherwise by platform specific events.UiKit/// A raw window handle for UIKit (Apple's non-macOS windowing library)./// ## Availability Hints/// This variant is likely to be used on iOS, tvOS, (in theory) watchOS, and/// Mac Catalyst (`$arch-apple-ios-macabi` targets, which can notably use/// UIKit *or* AppKit), as these are the targets that (currently) support/// UIKit.AppKit/// A raw window handle for AppKit./// This variant is likely to be used on macOS, although Mac Catalyst/// (`$arch-apple-ios-macabi` targets, which can notably use UIKit *or*/// AppKit) can also use it despite being `target_os = "ios"`.Orbital/// A raw window handle for the Redox operating system./// This variant is used by the Orbital Windowing System in the RedoxOhosNdk/// A raw window handle for the OpenHarmony OS NDK/// This variant is used on OpenHarmony OS (`target_env = "ohos"`)./// A raw window handle for Xlib./// This variant is likely to show up anywhere someone manages to get X11/// working that Xlib can be built for, which is to say, most (but not all)/// Unix systems./// A raw window handle for Xcb./// working that XCB can be built for, which is to say, most (but not all)/// A raw window handle for Wayland./// This variant should be expected anywhere Wayland works, which is/// currently some subset of unix systems./// A raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager/// This variant is used on Linux when neither X nor Wayland are availableGbm/// A raw window handle for the Linux Generic Buffer Manager./// This variant is present regardless of windowing backend and likely to be used with/// EGL_MESA_platform_gbm or EGL_KHR_platform_gbm./// A raw window handle for Win32./// This variant is used on Windows systems.WinRt/// A raw window handle for WinRT./// A raw window handle for the Web./// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.WebCanvas/// A raw window handle for a Web canvas registered via [`wasm-bindgen`]./// [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgenWebOffscreenCanvas/// A raw window handle for a Web offscreen canvas registered via [`wasm-bindgen`].AndroidNdk/// A raw window handle for Android NDK./// This variant is used on Android targets./// A raw window handle for Haiku./// This variant is used on HaikuOS./// A window handle for a particular windowing system./// Each variant contains a struct with fields specific to that windowing system/// (e.g. [`Win32WindowHandle`] will include a [HWND], [`WaylandWindowHandle`] uses [wl_surface],/// [HWND]: https://learn.microsoft.com/en-us/windows/win32/winmsg/about-windows#window-handle/// [wl_surface]: https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_surface/// # Variant Availability/// Note that all variants are present on all targets (none are disabled behind/// `#[cfg]`s), but see the "Availability Hints" section on each variant for/// some hints on where this variant might be expected./// Note that these "Availability Hints" are not normative. That is to say, a/// [`HasWindowHandle`] implementor is completely allowed to return something/// unexpected. (For example, it's legal for someone to return a/// [`RawWindowHandle::Xlib`] on macOS, it would just be weird, and probably/// requires something like XQuartz be used).raw_display_handle"Use `HasDisplayHandle` instead"HasRawDisplayHandle/// Display that wraps around a raw display handle./// The exact handles returned by `raw_display_handle` must remain consistent between multiple calls/// to `raw_display_handle` as long as not indicated otherwise by platform specific events./// A raw display handle for UIKit (Apple's non-macOS windowing library)./// A raw display handle for AppKit./// A raw display handle for the Redox operating system.Ohos/// A raw display handle for OpenHarmony OS NDK/// A raw display handle for Xlib./// A raw display handle for Xcb./// A raw display handle for Wayland./// A raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager/// A raw display handle for the Linux Generic Buffer Manager./// A raw display handle for Win32./// A raw display handle for the Web./// A raw display handle for Android NDK./// A raw display handle for Haiku./// A display server handle for a particular windowing system./// The display usually represents a connection to some display server, but it is not necessarily/// tied to a particular window. Some APIs can use the display handle without ever creating a window/// handle (e.g. offscreen rendering, headless event handling)./// (e.g. [`XlibDisplayHandle`] contains a [Display] connection to an X Server,/// [`WaylandDisplayHandle`] uses [wl_display] to connect to a compositor). Not all windowing/// systems have a separate display handle (or they haven't been implemented yet) and their variants/// contain empty structs./// [Display]: https://www.x.org/releases/current/doc/libX11/libX11/libX11.html#Display_Functions/// [wl_display]: https://wayland.freedesktop.org/docs/html/apb.html#Client-classwl__display/// [`HasDisplayHandle`] implementor is completely allowed to return something/// [`RawDisplayHandle::Xlib`] on macOS, it would just be weird, and probably/// The underlying handle cannot be represented using the types in this crate./// This may be returned if the underlying window system does not support any of the/// representative C window handles in this crate. For instance, if you were using a pure Rust/// library to set up X11 (like [`x11rb`]), you would not be able to use any of the/// [`RawWindowHandle`] variants, as they all represent C types./// Another example would be a system that isn't supported by `raw-window-handle` yet,/// like some game consoles./// In the event that this error is returned, you should try to use the underlying window/// system's native API to get the handle you need./// [`x11rb`]: https://crates.io/crates/x11rb/// The underlying handle is not available./// In some cases the underlying window handle may become temporarily unusable. For example, on/// Android, the native window pointer can arbitrarily be replaced or removed by the system. In/// this case, returning a window handle would be disingenuous, as it would not be usable. A/// similar situation can occur on Wayland for the layer shell windows./// In the event that this error is returned, you should wait until the handle becomes available/// An error that can occur while fetching a display or window handle.from_implassert_not_impl_anyauto_traitsassert_object_safe//! Interoperability library for Rust Windowing applications.//! This library provides standard types for accessing a window's platform-specific raw window//! handle and platforms display handle. This does not provide any utilities for creating and//! managing windows; instead, it provides a common interface that window creation libraries (e.g.//! Winit, SDL) can use to easily talk with graphics libraries (e.g. gfx-hal).//! ## Safety guarantees//! Please see the docs of [`HasWindowHandle`] and [`HasDisplayHandle`].//! ## Platform handle initialization//! Each platform handle struct is purposefully non-exhaustive, so that additional fields may be//! added without breaking backwards compatibility. Each struct provides an `empty` method that may//! be used along with the struct update syntax to construct it. See each specific struct for//! examples.//! ## Display Handles//! Some windowing systems use a separate display handle for some operations. The display usually//! represents a connection to some display server, but it is not necessarily tied to a particular//! window. See [`RawDisplayHandle`] for more details./// Raw display handle for OpenHarmony./// # use raw_window_handle::OhosDisplayHandle;/// let handle = OhosDisplayHandle::new();/// Create an OpenHarmony-based display handle./// let handle = DisplayHandle::ohos();native_window/// Raw window handle for Ohos NDK./// Create a new handle to an [`OHNativeWindow`] on OpenHarmony./// The handle will typically be created from an [`XComponent`], consult the/// [native `XComponent` Guidelines] for more details./// [`XComponent`]: https://gitee.com/openharmony/docs/blob/master/en/application-dev/ui/arkts-common-components-xcomponent.md/// [native `XComponent` Guidelines]: https://gitee.com/openharmony/docs/blob/OpenHarmony-4.0-Release/en/application-dev/napi/xcomponent-guidelines.md/// [`OHNativeWindow`]: https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/apis-arkgraphics2d/_native_window.md/// # use core::ffi::c_void;/// # use raw_window_handle::OhosNdkWindowHandle;/// # #[allow(non_camel_case_types)]/// # type OH_NativeXComponent = ();/// /// Called When the `XComponent` is created./// /// See the [XComponent Guidelines](https://gitee.com/openharmony/docs/blob/OpenHarmony-4.0-Release/en/application-dev/napi/xcomponent-guidelines.md)/// /// for more details/// extern "C" fn on_surface_created_callback(component: *mut OH_NativeXComponent, window: *mut c_void) {///     let handle = OhosNdkWindowHandle::new(NonNull::new(window).unwrap());//! [OpenHarmony] OS Window Handles//! ## Background//! Applications on [OpenHarmony] use [ArkUI] for defining their UI. Applications can use an//! [XComponent] to render using native Code (e.g. Rust) via EGL.//! Native code will receive a callback `OnSurfaceCreatedCB(OH_NativeXComponent *component, void *window)`//! when the `XComponent` is created. The window argument has the type [`OHNativeWindow`] / `EGLNativeWindowType`.//! The window can then be used to create a surface with//! `eglCreateWindowSurface(eglDisplay_, eglConfig_, window, NULL)`//! [OpenHarmony]: https://gitee.com/openharmony/docs/blob/master/en/OpenHarmony-Overview.md//! [ArkUI]: https://gitee.com/openharmony/docs/blob/master/en/application-dev/ui/arkui-overview.md//! [XComponent]: https://gitee.com/openharmony/docs/blob/master/en/application-dev/ui/arkts-common-components-xcomponent.md//! [`OHNativeWindow`]: https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/apis-arkgraphics2d/_native_window.md/// Raw display handle for the Redox operating system./// # use raw_window_handle::OrbitalDisplayHandle;/// let handle = OrbitalDisplayHandle::new();orbital/// Create an Orbital-based display handle./// let handle = DisplayHandle::orbital();/// A pointer to an orbclient window.// TODO(madsmtm): I think this is a file descriptor, so perhaps it should// actually use `std::os::fd::RawFd`, or some sort of integer instead?/// Raw window handle for the Redox operating system./// # use raw_window_handle::OrbitalWindowHandle;/// # type Window = ();/// let window: NonNull<Window>;/// # window = NonNull::from(&());/// let mut handle = OrbitalWindowHandle::new(window.cast());/// Raw display handle for UIKit./// # use raw_window_handle::UiKitDisplayHandle;/// let handle = UiKitDisplayHandle::new();/// Create a UiKit-based display handle./// let handle = DisplayHandle::uikit();/// A pointer to an `UIView` object./// A pointer to an `UIViewController` object, if the view has one./// Raw window handle for UIKit./// Note that `UIView` can only be accessed from the main thread of the/// #![cfg(any(target_os = "ios", target_os = "tvos", target_os = "watchos", target_os = "xros"))]/// use objc2_ui_kit::UIView;///     RawWindowHandle::UIKit(handle) => {///         assert!(is_main_thread(), "can only access UIKit handles on the main thread");///         let ui_view = handle.ui_view.as_ptr();///         // that the `UiKitWindowHandle` contains a valid pointer to an///         // `UIView`.///         let ui_view: Id<UIView> = unsafe { Id::retain(ui_view.cast()) }.unwrap();///         // Do something with the UIView here./// # use raw_window_handle::UiKitWindowHandle;/// # type UIView = ();/// let view: &UIView;/// let mut handle = UiKitWindowHandle::new(NonNull::from(view).cast());/// // Optionally set the view controller./// handle.ui_view_controller = None;/// A pointer to an Xlib `Display`./// It is strongly recommended to set this value, however it may be set to/// `None` to request the default display when using EGL./// An X11 screen to use with this display handle./// Note, that X11 could have multiple screens, however/// graphics APIs could work only with one screen at the time,/// given that multiple screens usually reside on different GPUs./// Raw display handle for Xlib./// Create a new handle to a display./// # use raw_window_handle::XlibDisplayHandle;/// let display: NonNull<c_void>;/// let screen;/// # display = NonNull::from(&()).cast();/// # screen = 0;/// let handle = XlibDisplayHandle::new(Some(display), screen);/// An Xlib `Window`.visual_id/// An Xlib visual ID, or 0 if unknown./// Raw window handle for Xlib./// # use core::ffi::c_ulong;/// # use raw_window_handle::XlibWindowHandle;/// let window: c_ulong;/// # window = 0;/// let mut handle = XlibWindowHandle::new(window);/// // Optionally set the visual ID./// handle.visual_id = 0;/// A pointer to an X server `xcb_connection_t`./// Raw display handle for Xcb./// Create a new handle to a connection and screen./// # use raw_window_handle::XcbDisplayHandle;/// let connection: NonNull<c_void>;/// # connection = NonNull::from(&()).cast();/// let handle = XcbDisplayHandle::new(Some(connection), screen);/// An X11 `xcb_window_t`.// Based on xproto.h/// An X11 `xcb_visualid_t`./// Raw window handle for Xcb./// # use core::num::NonZeroU32;/// # use raw_window_handle::XcbWindowHandle;/// let window: NonZeroU32;/// # window = NonZeroU32::new(1).unwrap();/// let mut handle = XcbWindowHandle::new(window);/// handle.visual_id = None;/// A pointer to a `wl_display`./// Raw display handle for Wayland./// Create a new display handle./// # use raw_window_handle::WaylandDisplayHandle;/// let handle = WaylandDisplayHandle::new(display);/// A pointer to a `wl_surface`./// Raw window handle for Wayland./// Create a new handle to a surface./// # use raw_window_handle::WaylandWindowHandle;/// let surface: NonNull<c_void>;/// # surface = NonNull::from(&()).cast();/// let handle = WaylandWindowHandle::new(surface);/// The drm file descriptor.// TODO: Use `std::os::fd::RawFd`?/// Raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager./// Create a new handle to a file descriptor./// # use raw_window_handle::DrmDisplayHandle;/// let fd: i32;/// # fd = 0;/// let handle = DrmDisplayHandle::new(fd);/// The primary drm plane handle./// Raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager./// Create a new handle to a plane./// # use raw_window_handle::DrmWindowHandle;/// let plane: u32;/// # plane = 0;/// let handle = DrmWindowHandle::new(plane);gbm_device/// The gbm device./// Raw display handle for the Linux Generic Buffer Manager./// Create a new handle to a device./// # use raw_window_handle::GbmDisplayHandle;/// let ptr: NonNull<c_void>;/// # ptr = NonNull::from(&()).cast();/// let handle = GbmDisplayHandle::new(ptr);gbm_surface/// The gbm surface./// Raw window handle for the Linux Generic Buffer Manager./// # use raw_window_handle::GbmWindowHandle;/// let handle = GbmWindowHandle::new(ptr);/// Raw display handle for the Web./// # use raw_window_handle::WebDisplayHandle;/// let handle = WebDisplayHandle::new();/// Create a Web-based display handle./// let handle = DisplayHandle::web();/// An ID value inserted into the [data attributes] of the canvas element as '`raw-handle`'./// When accessing from JS, the attribute will automatically be called `rawHandle`./// Each canvas created by the windowing system should be assigned their own unique ID./// [data attributes]: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/data-*/// Raw window handle for the Web./// Create a new handle to a canvas element./// # use raw_window_handle::WebWindowHandle;/// let id: u32 = 0; // canvas.rawHandle;/// let handle = WebWindowHandle::new(id);/// A pointer to the [`JsValue`] of an [`HtmlCanvasElement`]./// Note: This uses [`c_void`] to avoid depending on `wasm-bindgen`/// [`JsValue`]: https://docs.rs/wasm-bindgen/latest/wasm_bindgen/struct.JsValue.html/// [`HtmlCanvasElement`]: https://docs.rs/web-sys/latest/web_sys/struct.HtmlCanvasElement.html// SAFETY: Not using `JsValue` is sound because `wasm-bindgen` guarantees// that there's only one version of itself in any given binary, and hence// we can't have a type-confusion where e.g. one library used `JsValue`// from `v0.2` of `wasm-bindgen`, and another used `JsValue` from `v1.0`;// the binary will simply fail to compile!// Reference: TODO/// Raw window handle for a Web canvas registered via [`wasm-bindgen`]./// Create a new handle from a pointer to [`HtmlCanvasElement`]./// # use raw_window_handle::WebCanvasWindowHandle;/// # type HtmlCanvasElement = ();/// # type JsValue = ();/// let canvas: &HtmlCanvasElement;/// # canvas = &();/// let value: &JsValue = &canvas; // Deref to `JsValue`/// let obj: NonNull<c_void> = NonNull::from(value).cast();/// let mut handle = WebCanvasWindowHandle::new(obj);/// A pointer to the [`JsValue`] of an [`OffscreenCanvas`]./// [`OffscreenCanvas`]: https://docs.rs/web-sys/latest/web_sys/struct.OffscreenCanvas.html// SAFETY: See WebCanvasWindowHandle./// Raw window handle for a Web offscreen canvas registered via/// [`wasm-bindgen`]./// Create a new handle from a pointer to an [`OffscreenCanvas`]./// # use raw_window_handle::WebOffscreenCanvasWindowHandle;/// # type OffscreenCanvas = ();/// let canvas: &OffscreenCanvas;/// let mut handle = WebOffscreenCanvasWindowHandle::new(obj);/// Raw display handle for Windows./// It can be used regardless of Windows window backend./// # use raw_window_handle::WindowsDisplayHandle;/// let handle = WindowsDisplayHandle::new();/// Create a Windows-based display handle./// let handle = DisplayHandle::windows();/// A Win32 `HWND` handle./// The `GWLP_HINSTANCE` associated with this type's `HWND`./// Raw window handle for Win32./// It is assumed that the Win32 handle belongs to the current thread. This/// is necessary for the handle to be considered "valid" in all cases./// # use core::num::NonZeroIsize;/// # use raw_window_handle::Win32WindowHandle;/// # struct HWND(isize);/// let window: HWND;/// # window = HWND(1);/// let mut handle = Win32WindowHandle::new(NonZeroIsize::new(window.0).unwrap());/// // Optionally set the GWLP_HINSTANCE./// # #[cfg(only_for_showcase)]/// let hinstance = NonZeroIsize::new(unsafe { GetWindowLongPtrW(window, GWLP_HINSTANCE) }).unwrap();/// # let hinstance = None;/// handle.hinstance = hinstance;core_window/// A WinRT `CoreWindow` handle./// Raw window handle for WinRT./// # use raw_window_handle::WinRtWindowHandle;/// # type CoreWindow = ();/// let window: NonNull<CoreWindow>;/// let handle = WinRtWindowHandle::new(window.cast());DrainProducer/// Parallel iterator that moves out of an array.//! Parallel iterator types for [arrays] (`[T; N]`)//! You will rarely need to interact with this module directly unless you need//! to name one of the iterator types.//! [arrays]: https://doc.rust-lang.org/std/primitive.array.html/// Parallel iterator over a binary heapdelegate_indexed_iteratordelegate_iterator/// Parallel iterator over an immutable reference to a binary heapinto_par_vec/// Draining parallel iterator that moves out of a binary heap,/// but keeps the total capacity.ParallelDrainFull//! This module contains the parallel iterator types for heaps//! (`BinaryHeap<T>`). You will rarely need to interact with it directly//! unless you have need to name one of the iterator types.// `BinaryHeap` doesn't have a mutable `Iterator`/// Parallel iterator over a B-Tree map// std doesn't Clone/// Parallel iterator over an immutable reference to a B-Tree map/// Parallel iterator over a mutable reference to a B-Tree map//! This module contains the parallel iterator types for B-Tree maps//! (`BTreeMap<K, V>`). You will rarely need to interact with it directly/// Parallel iterator over a B-Tree set/// Parallel iterator over an immutable reference to a B-Tree set//! This module contains the parallel iterator types for B-Tree sets//! (`BTreeSet<T>`). You will rarely need to interact with it directly// `BTreeSet` doesn't have a mutable `Iterator`/// Parallel iterator over a hash map/// Parallel iterator over an immutable reference to a hash map/// Parallel iterator over a mutable reference to a hash map/// Draining parallel iterator that moves out of a hash map,//! This module contains the parallel iterator types for hash maps//! (`HashMap<K, V>`). You will rarely need to interact with it directly/// Parallel iterator over a hash set/// Parallel iterator over an immutable reference to a hash set/// Draining parallel iterator that moves out of a hash set,//! This module contains the parallel iterator types for hash sets//! (`HashSet<T>`). You will rarely need to interact with it directly// `HashSet` doesn't have a mutable `Iterator`/// Parallel iterator over a linked list/// Parallel iterator over an immutable reference to a linked list/// Parallel iterator over a mutable reference to a linked list//! This module contains the parallel iterator types for linked lists//! (`LinkedList<T>`). You will rarely need to interact with it directly/// Convert an iterable collection into a parallel iterator by first/// collecting into a temporary `Vec`, then iterating that.drain_guardDrainGuard/// A proxy for draining a collection by converting to a `Vec` and back./// This is used for draining `BinaryHeap` and `VecDeque`, which both have/// zero-allocation conversions to/from `Vec`, though not zero-cost:/// - `BinaryHeap` will heapify from `Vec`, but at least that will be empty./// - `VecDeque` has to shift items to offset 0 when converting to `Vec`.//! Parallel iterator types for [standard collections][std::collections]//! [std::collections]: https://doc.rust-lang.org/stable/std/collections//// Parallel iterator over a double-ended queue/// Parallel iterator over an immutable reference to a double-ended queue/// Parallel iterator over a mutable reference to a double-ended queueorig_len/// Draining parallel iterator that moves a range out of a double-ended queue,//! This module contains the parallel iterator types for double-ended queues//! (`VecDeque<T>`). You will rarely need to interact with it directly/*! ```compile_fail,E0599

use rayon::prelude::*;

// zip requires data of exact size, but filter yields only bounded
// size, so check that we cannot apply it.

let a: Vec<usize> = (0..1024).collect();
let mut v = vec![];
a.par_iter()
    .filter_map(|&x| Some(x as f32))
    .collect_into_vec(&mut v); //~ ERROR no method

``` *//*! ```compile_fail,E0277

use rayon::prelude::*;

// zip requires data of exact size, but filter yields only bounded
// size, so check that we cannot apply it.

let mut a: Vec<usize> = (0..1024).rev().collect();
let b: Vec<usize> = (0..1024).collect();

a.par_iter()
    .zip(b.par_iter().filter(|&&x| x > 3)); //~ ERROR

``` *//*! ```compile_fail,E0277

// Check that we can't use the par-iter API to access contents of a `Cell`.

use rayon::prelude::*;
use std::cell::Cell;

let c = Cell::new(42_i32);
(0_i32..1024).into_par_iter()
    .map(|_| c.get()) //~ ERROR E0277
    .min();

``` */cannot_collect_filtermap_data// These modules contain `compile_fail` doc tests.cannot_zip_filtered_datacell_par_iterno_send_par_iterrc_par_iterr" First sanity check that the expression is OK."r" #![deny(unused_must_use)]"r" use rayon::prelude::*;"r" let v: Vec<_> = (0..100).map(Some).collect();"r" let _ ="r" v.par_iter().by_exponential_blocks(); "r" Now trigger the `must_use`."by_exponential_blocksr" v.par_iter().by_uniform_blocks(2); "by_uniform_blocksr" v.par_iter().step_by(2); "r" v.par_iter().chain(&v); "r" v.par_iter().chunks(2); "r" v.par_iter().fold_chunks(2, || 0, |x, _| x); "fold_chunksr" v.par_iter().fold_chunks_with(2, 0, |x, _| x); "fold_chunks_withr" v.par_iter().cloned(); "r" v.par_iter().copied(); "r" v.par_iter().enumerate(); "r" v.par_iter().filter(|_| true); "r" v.par_iter().filter_map(|x| *x); "r" v.par_iter().flat_map(|x| *x); "r" v.par_iter().flat_map_iter(|x| *x); "flat_map_iterr" v.par_iter().flatten(); "r" v.par_iter().flatten_iter(); "flatten_iterr" v.par_iter().fold(|| 0, |x, _| x); "r" v.par_iter().fold_with(0, |x, _| x); "r" v.par_iter().try_fold(|| 0, |x, _| Some(x)); "r" v.par_iter().try_fold_with(0, |x, _| Some(x)); "try_fold_withr" v.par_iter().inspect(|_| {}); "r" v.par_iter().interleave(&v); "r" v.par_iter().interleave_shortest(&v); "r" v.par_iter().intersperse(&None); "r" v.par_iter().map(|x| x); "r" v.par_iter().map_with(0, |_, x| x); "map_withr" v.par_iter().map_init(|| 0, |_, x| x); "map_initr" v.par_iter().panic_fuse(); "panic_fuser" v.par_iter().positions(|_| true); "r" v.par_iter().rev(); "r" v.par_iter().skip(1); "r" v.par_iter().take(1); "r" v.par_iter().update(|_| {}); "r" v.par_iter().cloned().while_some(); "r" v.par_iter().with_max_len(1); "with_max_lenr" v.par_iter().with_min_len(1); "with_min_lenr" v.par_iter().zip(&v); "r" v.par_iter().zip_eq(&v); "// Check that we are flagged for ignoring `must_use` parallel adaptors.// (unfortunately there's no error code for `unused_must_use`)/** ```compile_fail,E0277

use rayon::prelude::*;
use std::ptr::null;

#[derive(Copy, Clone)]
struct NoSend(*const ());

unsafe impl Sync for NoSend {}

let x = Some(NoSend(null()));

x.par_iter()
    .map(|&x| x) //~ ERROR
    .count(); //~ ERROR

``` *//** ```compile_fail,E0277

use rayon::prelude::*;
use std::ptr::null;

#[derive(Copy, Clone)]
struct NoSend(*const ());

unsafe impl Sync for NoSend {}

let x = Some(NoSend(null()));

x.par_iter()
    .filter_map(|&x| Some(x)) //~ ERROR
    .count(); //~ ERROR

``` *//** ```compile_fail,E0277

use rayon::prelude::*;
use std::ptr::null;

#[derive(Copy, Clone)]
struct NoSend(*const ());

unsafe impl Sync for NoSend {}

let x = Some(NoSend(null()));

x.par_iter()
    .cloned() //~ ERROR
    .count(); //~ ERROR

``` */// Check that `!Send` types fail early./*! ```compile_fail,E0599

// Check that we can't use the par-iter API to access contents of an
// `Rc`.

use rayon::prelude::*;
use std::rc::Rc;

let x = vec![Rc::new(22), Rc::new(23)];
let mut y = vec![];
x.into_par_iter() //~ ERROR no method named `into_par_iter`
    .map(|rc| *rc)
    .collect_into_vec(&mut y);

``` *//// Creates a parallel iterator implementation which simply wraps an inner type/// and delegates all methods inward.  The actual struct must already be/// declared with an `inner` field./// The implementation of `IntoParallelIterator` should be added separately./// Creates an indexed parallel iterator implementation which simply wraps an/// inner type and delegates all methods inward.  The actual struct must already/// be declared with an `inner` field.unindexed_exampleindexed_example//! Macros for delegating newtype iterators to inner types.// Note: these place `impl` bounds at the end, as token gobbling is the only way// I know how to consume an arbitrary list of constraints, with `$($args:tt)*`.BlocksCallbackProducerExponentialBlocks/// `ExponentialBlocks` is a parallel iterator that consumes itself as a sequence/// of parallel blocks of increasing sizes (exponentially)./// This struct is created by the [`by_exponential_blocks()`] method on [`IndexedParallelIterator`]/// [`by_exponential_blocks()`]: trait.IndexedParallelIterator.html#method.by_exponential_blocks/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.htmlexponential_sizeUniformBlocks/// `UniformBlocks` is a parallel iterator that consumes itself as a sequence/// of parallel blocks of constant sizes./// This struct is created by the [`by_uniform_blocks()`] method on [`IndexedParallelIterator`]/// [`by_uniform_blocks()`]: trait.IndexedParallelIterator.html#method.by_uniform_blocks/// `Chain` is an iterator that joins `b` after `a` in one continuous iterator./// This struct is created by the [`chain()`] method on [`ParallelIterator`]/// [`chain()`]: trait.ParallelIterator.html#method.chain/// [`ParallelIterator`]: trait.ParallelIterator.html/// Creates a new `Chain` iterator.a_lenChainProducer/// ////////////////////////////////////////////////////////////////////////ChainSeq/// Wrapper for Chain to implement ExactSizeIteratordiv_round_up/// `Chunks` is an iterator that groups elements of an underlying iterator./// This struct is created by the [`chunks()`] method on [`IndexedParallelIterator`]/// [`chunks()`]: trait.IndexedParallelIterator.html#method.chunks/// Creates a new `Chunks` iteratorChunkProducerChunkSeq/// `Cloned` is an iterator that clones the elements of an underlying iterator./// This struct is created by the [`cloned()`] method on [`ParallelIterator`]/// [`cloned()`]: trait.ParallelIterator.html#method.cloned/// Creates a new `Cloned` iterator.ClonedProducerClonedConsumer/// Consumer implementationClonedFolderReducerinto_foldersplit_off_leftto_reducerconsume_iterSendPtr/// See `CollectResult` for explanation of why this is not a sliceCollectConsumerappender/// Create a collector for `len` items in the unused capacity of the vector./// The target memory is considered uninitialized, and will be/// overwritten without reading or dropping existing values./// This pointer and length has the same representation as a slice,/// but retains the provenance of the entire array so that we can merge/// these regions together in `CollectReducer`.total_leninitialized_len/// The current initialized length after `start`invariant_lifetime/// Lifetime invariance guarantees that the data flows from consumer to result,/// especially for the `scope_fn` callback in `Collect::with_consumer`.CollectResult/// CollectResult represents an initialized part of the target slice./// This is a proxy owner of the elements in the slice; when it drops,/// the elements will be dropped, unless its ownership is released before then./// The current length of the collect resultrelease_ownership/// Release ownership of the slice of elements, and return the lengthCollectReducer/// Pretend to be unindexed for `special_collect_into_vec`,/// but we should never actually get used that way.../// CollectReducer combines adjacent chunks; the result must always/// be contiguous so that it is one combined slice.unzip_indexedcollect_into_vec/// Collects the results of the exact iterator into the specified vector./// This is called by `IndexedParallelIterator::collect_into_vec`.special_extend/// Collects the results of the iterator into the specified vector./// Technically, this only works for `IndexedParallelIterator`, but we're faking a/// bit of specialization here until Rust can do that natively.  Callers are/// using `opt_len` to find the length before calling this, and only exact/// iterators will return anything but `None` there./// Since the type system doesn't understand that contract, we have to allow/// *any* `ParallelIterator` here, and `CollectConsumer` has to also implement/// `UnindexedConsumer`.  That implementation panics `unreachable!` in case/// there's a bug where we actually do try to use this unindexed.unzip_into_vecs/// Unzips the results of the exact iterator into the specified vectors./// This is called by `IndexedParallelIterator::unzip_into_vecs`.collect_with_consumer/// Create a consumer on the slice of memory we are collecting into./// The consumer needs to be used inside the scope function, and the/// complete collect result passed back./// This method will verify the collect result, and panic if the slice/// was not fully written into. Otherwise, in the successful case,/// the vector is complete with the collected result.ThreadResultproduce_too_many_items/// Promises to produce 2 items, but then produces 3.  Does not do any/// splits at all.produce_fewer_items/// Produces fewer items than promised. Does not do anyleft_produces_items_with_no_complete// Complete is not called by the consumer. Hence,the collection vector is not fully initialized.right_produces_items_with_no_complete// Complete is not called by the right consumer. Hence,the// collection vector is not fully initialized.produces_items_with_no_completeleft_produces_too_many_items// The left consumer produces too many items while the right// consumer produces correct number.right_produces_too_many_items// The right consumer produces too many items while the leftleft_produces_fewer_items// The left consumer produces fewer items while the rightonly_left_result// The left and right consumer produce the correct number but// only left result is returnedonly_right_result// only right result is returnedreducer_does_not_preserve_order// The left and right consumer produce the correct number but reduce// in the wrong order.right_produces_fewer_items// The right consumer produces fewer items while the leftleft_panics// The left consumer panics and the right stops short, like `panic_fuse()`.// We should get the left panic without finishing `collect_with_consumer`.right_panics// The right consumer panics and the left stops short, like `panic_fuse()`.// We should get the right panic without finishing `collect_with_consumer`.left_produces_fewer_items_drops// consumer produces correct number; check that created elements are droppedDropCounter/// This counter can create elements, and then count and verify/// the number of which have actually been dropped again.assert_drop_countassert_is_panic_with_message/// Assert that the result from catch_unwind is a panic that contains expected message// These tests are primarily targeting "abusive" producers that will// try to drive the "collect consumer" incorrectly. These should// result in panics./// `Copied` is an iterator that copies the elements of an underlying iterator./// This struct is created by the [`copied()`] method on [`ParallelIterator`]/// [`copied()`]: trait.ParallelIterator.html#method.copied/// Creates a new `Copied` iterator.CopiedProducerCopiedConsumerCopiedFolder/// Creates a parallel iterator that produces nothing./// This admits no parallelism on its own, but it could be used for code that/// deals with generic parallel iterators./// use rayon::prelude::*;/// use rayon::iter::empty;/// let pi = (0..1234).into_par_iter()///     .chain(empty())///     .chain(1234..10_000);/// assert_eq!(pi.count(), 10_000);/// Iterator adaptor for [the `empty()` function](fn.empty.html).EmptyProducer/// Private empty producer/// `Enumerate` is an iterator that returns the current count along with the element./// This struct is created by the [`enumerate()`] method on [`IndexedParallelIterator`]/// [`enumerate()`]: trait.IndexedParallelIterator.html#method.enumerate/// Creates a new `Enumerate` iterator.EnumerateProducer/// Producer implementationNoopConsumer/// Performs a generic `par_extend` by collecting to a `LinkedList<Vec<_>>` in/// parallel, then extending the collection sequentially.extend_reserved/// Computes the total length of a `fast_collect` result.string_len/// Computes the total string length of a `fast_collect` result.osstring_len/// Computes the total OS-string length of a `fast_collect` result.fast_collectListVecConsumerListVecFolderListReducer/// Extends a binary heap with items from a parallel iterator./// Extends a binary heap with copied items from a parallel iterator./// Extends a B-tree map with items from a parallel iterator./// Extends a B-tree map with copied items from a parallel iterator./// Extends a B-tree set with items from a parallel iterator./// Extends a B-tree set with copied items from a parallel iterator./// Extends a hash map with items from a parallel iterator./// Extends a hash map with copied items from a parallel iterator./// Extends a hash set with items from a parallel iterator./// Extends a hash set with copied items from a parallel iterator./// Extends a linked list with items from a parallel iterator./// Extends a linked list with copied items from a parallel iterator.ListConsumerListFolder/// Extends an OS-string with string slices from a parallel iterator./// Extends an OS-string with strings from a parallel iterator./// Extends a string with characters from a parallel iterator./// Extends a string with copied characters from a parallel iterator.ListStringConsumerListStringFolder/// Extends a string with string slices from a parallel iterator./// Extends a string with strings from a parallel iterator./// Extends a string with boxed strings from a parallel iterator./// Extends a deque with items from a parallel iterator./// Extends a deque with copied items from a parallel iterator./// Extends a vector with items from a parallel iterator./// Extends a vector with copied items from a parallel iterator./// Collapses all unit items from a parallel iterator into one.filter_op/// `Filter` takes a predicate `filter_op` and filters out elements that match./// This struct is created by the [`filter()`] method on [`ParallelIterator`]/// [`filter()`]: trait.ParallelIterator.html#method.filter/// Creates a new `Filter` iterator.FilterConsumerFilterFolder// This cannot easily specialize `consume_iter` to be better than// the default, because that requires checking `self.base.full()`// during a call to `self.base.consume_iter()`. (#632)/// `FilterMap` creates an iterator that uses `filter_op` to both filter and map elements./// This struct is created by the [`filter_map()`] method on [`ParallelIterator`]./// [`filter_map()`]: trait.ParallelIterator.html#method.filter_map/// Creates a new `FilterMap` iterator.FilterMapConsumerFilterMapFolderfind_opFindConsumerFindFolderFindReducerMatchPositionLeftmostRightmostbetter_position/// Returns true if pos1 is a better match than pos2 according to MatchPositionfind_lastmatch_positionbest_found// The key optimization for find_first is that a consumer can stop its search if// some consumer to its left already found a match (and similarly for consumers// to the right for find_last). To make this work, all consumers need some// notion of their position in the data relative to other consumers, including// unindexed consumers that have no built-in notion of position.// To solve this, we assign each consumer a lower and upper bound for an// imaginary "range" of data that it consumes. The initial consumer starts with// the range 0..usize::max_value(). The split divides this range in half so that// one resulting consumer has the range 0..(usize::max_value() / 2), and the// other has (usize::max_value() / 2)..usize::max_value(). Every subsequent// split divides the range in half again until it cannot be split anymore// (i.e. its length is 1), in which case the split returns two consumers with// the same range. In that case both consumers will continue to consume all// their data regardless of whether a better match is found, but the reducer// will still return the correct answer.same_range_first_consumers_return_correct_answersame_range_last_consumers_return_correct_answerfind_first_folder_does_not_clobber_first_found// These tests requires that a folder be assigned to an iterator with more than// one element. We can't necessarily determine when that will happen for a given// input to find_first/find_last, so we test the folder directly here instead.find_last_folder_yields_last_matchmap_op/// `FlatMap` maps each element to a parallel iterator, then flattens these iterators together./// This struct is created by the [`flat_map()`] method on [`ParallelIterator`]/// [`flat_map()`]: trait.ParallelIterator.html#method.flat_map/// Creates a new `FlatMap` iterator.FlatMapConsumerFlatMapFolderFlatMapIter/// `FlatMapIter` maps each element to a serial iterator, then flattens these iterators together./// This struct is created by the [`flat_map_iter()`] method on [`ParallelIterator`]/// [`flat_map_iter()`]: trait.ParallelIterator.html#method.flat_map_iter/// Creates a new `FlatMapIter` iterator.SIFlatMapIterConsumerFlatMapIterFolder/// `Flatten` turns each element to a parallel iterator, then flattens these iterators/// together. This struct is created by the [`flatten()`] method on [`ParallelIterator`]./// [`flatten()`]: trait.ParallelIterator.html#method.flatten/// Creates a new `Flatten` iterator.FlattenConsumerFlattenFolderFlattenIter/// `FlattenIter` turns each element to a serial iterator, then flattens these iterators/// together. This struct is created by the [`flatten_iter()`] method on [`ParallelIterator`]./// [`flatten_iter()`]: trait.ParallelIterator.html#method.flatten_iter/// Creates a new `FlattenIter` iterator.FlattenIterConsumerFlattenIterFolderfold_op/// `Fold` is an iterator that applies a function over an iterator producing a single value./// This struct is created by the [`fold()`] method on [`ParallelIterator`]/// [`fold()`]: trait.ParallelIterator.html#method.foldFoldConsumerFoldFolderFoldWith/// `FoldWith` is an iterator that applies a function over an iterator producing a single value./// This struct is created by the [`fold_with()`] method on [`ParallelIterator`]/// [`fold_with()`]: trait.ParallelIterator.html#method.fold_withFoldWithConsumer// ///////////////////////////////////////////////////////////////////////////FoldChunks/// `FoldChunks` is an iterator that groups elements of an underlying iterator and applies a/// function over them, producing a single value for each group./// This struct is created by the [`fold_chunks()`] method on [`IndexedParallelIterator`]/// [`fold_chunks()`]: trait.IndexedParallelIterator.html#method.fold_chunks/// Creates a new `FoldChunks` iteratorcheck_fold_chunks// 'closure' values for tests belowcheck_fold_chunks_zero_sizecheck_fold_chunks_even_sizecheck_fold_chunks_emptycheck_fold_chunks_lencheck_fold_chunks_unevenFoldChunksWith/// `FoldChunksWith` is an iterator that groups elements of an underlying iterator and applies a/// This struct is created by the [`fold_chunks_with()`] method on [`IndexedParallelIterator`]/// [`fold_chunks_with()`]: trait.IndexedParallelIterator.html#method.fold_chunks/// Creates a new `FoldChunksWith` iteratorcheck_fold_chunks_with// 'closure' value for tests belowcheck_fold_chunks_with_emptyForEachConsumerNoopReducercollect_extended/// Creates an empty default collection and extends it./// Collects items from a parallel iterator into a vector./// Collects items from a parallel iterator into a boxed slice./// Collects items from a parallel iterator into a reference-counted slice./// Collects items from a parallel iterator into an atomically-reference-counted slice./// Collects items from a parallel iterator into a vecdeque./// Collects items from a parallel iterator into a binaryheap./// The heap-ordering is calculated serially after all items are collected./// Collects items from a parallel iterator into a freshly allocated/// linked list./// Collects (key, value) pairs from a parallel iterator into a/// btreemap. If multiple pairs correspond to the same key, then the/// Collects values from a parallel iterator into a hashset./// Collects values from a parallel iterator into a btreeset./// Collects characters from a parallel iterator into a string./// Collects string slices from a parallel iterator into a string./// Collects strings from a parallel iterator into one large string./// Collects boxed strings from a parallel iterator into one large string./// Collects OS-string slices from a parallel iterator into an OS-string./// Collects OS-strings from a parallel iterator into one large OS-string./// Collects an arbitrary `Cow` collection./// Note, the standard library only has `FromIterator` for `Cow<'a, str>` and/// `Cow<'a, [T]>`, because no one thought to add a blanket implementation/// before it was stabilized./// This is more useful when combined with higher-level abstractions, like/// collecting to a `Result<(), E>` where you only care about errors:/// use std::io::*;/// let data = vec![1, 2, 3, 4, 5];/// let res: Result<()> = data.par_iter()///     .map(|x| writeln!(stdout(), "{}", x))inspect_op/// `Inspect` is an iterator that calls a function with a reference to each/// element before yielding it./// This struct is created by the [`inspect()`] method on [`ParallelIterator`]/// [`inspect()`]: trait.ParallelIterator.html#method.inspect/// Creates a new `Inspect` iterator.InspectProducerInspectConsumerInspectFolder/// `Interleave` is an iterator that interleaves elements of iterators/// `i` and `j` in one continuous iterator. This struct is created by/// the [`interleave()`] method on [`IndexedParallelIterator`]/// [`interleave()`]: trait.IndexedParallelIterator.html#method.interleave/// Creates a new `Interleave` iteratori_lenj_leni_nextInterleaveProducerInterleaveSeq/// We know 0 < index <= self.i_len + self.j_len/// Find a, b satisfying:///  (1) 0 < a <= self.i_len///  (2) 0 < b <= self.j_len///  (3) a + b == index/// For even splits, set a = b = index/2./// For odd splits, set a = (index/2)+1, b = index/2, if `i`/// should yield the next element, otherwise, if `j` should yield/// the next element, set a = index/2 and b = (index/2)+1/// Flag to control which iterator should provide the next element. When/// `false` then `i` produces the next element, otherwise `j` produces the/// next element./// Wrapper for Interleave to implement DoubleEndedIterator and/// ExactSizeIterator./// This iterator is fused./// Iterator implementation for InterleaveSeq. This implementation is/// taken more or less verbatim from itertools. It is replicated here/// (instead of calling itertools directly), because we also need to/// implement `DoubledEndedIterator` and `ExactSizeIterator`.// The implementation for DoubleEndedIterator requires// ExactSizeIterator to provide `next_back()`. The last element will// come from the iterator that runs out last (ie has the most elements// in it). If the iterators have the same number of elements, then the// last iterator will provide the last element./// `InterleaveShortest` is an iterator that works similarly to/// `Interleave`, but this version stops returning elements once one/// of the iterators run out./// This struct is created by the [`interleave_shortest()`] method on/// [`IndexedParallelIterator`]./// [`interleave_shortest()`]: trait.IndexedParallelIterator.html#method.interleave_shortest/// Creates a new `InterleaveShortest` iterator/// `Intersperse` is an iterator that inserts a particular item between each/// item of the adapted iterator.  This struct is created by the/// [`intersperse()`] method on [`ParallelIterator`]/// [`intersperse()`]: trait.ParallelIterator.html#method.intersperse/// Creates a new `Intersperse` iteratorclone_firstIntersperseProducerIntersperseIterclone_lastIntersperseConsumerIntersperseFolderMinLen/// `MinLen` is an iterator that imposes a minimum length on iterator splits./// This struct is created by the [`with_min_len()`] method on [`IndexedParallelIterator`]/// [`with_min_len()`]: trait.IndexedParallelIterator.html#method.with_min_len/// Creates a new `MinLen` iterator.MinLenProducer/// `MinLenProducer` implementation/// `MaxLen` is an iterator that imposes a maximum length on iterator splits./// This struct is created by the [`with_max_len()`] method on [`IndexedParallelIterator`]/// [`with_max_len()`]: trait.IndexedParallelIterator.html#method.with_max_len/// Creates a new `MaxLen` iterator.MaxLenProducer/// `MaxLenProducer` implementation/// `Map` is an iterator that transforms the elements of an underlying iterator./// This struct is created by the [`map()`] method on [`ParallelIterator`]/// [`map()`]: trait.ParallelIterator.html#method.map/// Creates a new `Map` iterator.MapProducerMapConsumerMapFolderMapWith/// `MapWith` is an iterator that transforms the elements of an underlying iterator./// This struct is created by the [`map_with()`] method on [`ParallelIterator`]/// [`map_with()`]: trait.ParallelIterator.html#method.map_with/// Creates a new `MapWith` iterator.MapWithProducerMapWithIterMapWithConsumerMapWithFolderMapInit/// `MapInit` is an iterator that transforms the elements of an underlying iterator./// This struct is created by the [`map_init()`] method on [`ParallelIterator`]/// [`map_init()`]: trait.ParallelIterator.html#method.map_init/// Creates a new `MapInit` iterator.MapInitProducerMapInitConsumer// ------------------------------------------------------------------------------------------------Tryfind_first_lastpar_bridgeskip_anyskip_any_whiletake_anytake_any_whiletry_reducetry_reduce_withwalk_treeMultiZipPanicFuseIterBridgeParallelBridgeSkipAnySkipAnyWhileTakeAnyTakeAnyWhileTryFoldWithwalk_tree_postfixwalk_tree_prefixWalkTreeWalkTreePostfixWalkTreePrefix/// The parallel iterator type that will be created./// The type of item that the parallel iterator will produce./// Converts `self` into a parallel iterator./// println!("counting in parallel:");/// (0..100).into_par_iter()///     .for_each(|i| println!("{}", i));/// This conversion is often implicit for arguments to methods like [`zip`]./// let v: Vec<_> = (0..5).into_par_iter().zip(5..10).collect();/// assert_eq!(v, [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]);/// [`zip`]: trait.IndexedParallelIterator.html#method.zip/// `IntoParallelIterator` implements the conversion to a [`ParallelIterator`]./// By implementing `IntoParallelIterator` for a type, you define how it will/// transformed into an iterator. This is a parallel version of the standard/// library's [`std::iter::IntoIterator`] trait./// [`std::iter::IntoIterator`]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html/// The type of the parallel iterator that will be returned./// This will typically be an `&'data T` reference type./// let v: Vec<_> = (0..100).collect();/// assert_eq!(v.par_iter().sum::<i32>(), 100 * 99 / 2);/// // `v.par_iter()` is shorthand for `(&v).into_par_iter()`,/// // producing the exact same references./// assert!(v.par_iter().zip(&v)///          .all(|(a, b)| std::ptr::eq(a, b)));/// `IntoParallelRefIterator` implements the conversion to a/// [`ParallelIterator`], providing shared references to the data./// This is a parallel version of the `iter()` method/// defined by various collections./// This trait is automatically implemented/// `for I where &I: IntoParallelIterator`. In most cases, users/// will want to implement [`IntoParallelIterator`] rather than implement/// this trait directly./// [`IntoParallelIterator`]: trait.IntoParallelIterator.html/// The type of iterator that will be created./// The type of item that will be produced; this is typically an/// `&'data mut T` reference./// Creates the parallel iterator from `self`./// let mut v = vec![0usize; 5];/// v.par_iter_mut().enumerate().for_each(|(i, x)| *x = i);/// assert_eq!(v, [0, 1, 2, 3, 4]);IntoParallelRefMutIterator/// `IntoParallelRefMutIterator` implements the conversion to a/// [`ParallelIterator`], providing mutable references to the data./// This is a parallel version of the `iter_mut()` method/// `for I where &mut I: IntoParallelIterator`. In most cases, users/// The type of item that this parallel iterator produces./// For example, if you use the [`for_each`] method, this is the type of/// item that your closure will be invoked with./// [`for_each`]: #method.for_eachOP/// Executes `OP` on each item produced by the iterator, in parallel./// (0..100).into_par_iter().for_each(|x| println!("{:?}", x));for_each_with/// Executes `OP` on the given `init` value with each item produced by/// the iterator, in parallel./// The `init` value will be cloned only as needed to be paired with/// the group of items in each rayon job.  It does not require the type/// to be `Sync`./// let (sender, receiver) = channel();/// (0..5).into_par_iter().for_each_with(sender, |s, x| s.send(x).unwrap());/// let mut res: Vec<_> = receiver.iter().collect();/// res.sort();/// assert_eq!(&res[..], &[0, 1, 2, 3, 4])for_each_init/// Executes `OP` on a value returned by `init` with each item produced by/// The `init` function will be called only as needed for a value to be/// paired with the group of items in each rayon job.  There is no/// constraint on that returned type at all!/// let mut v = vec![0u8; 1_000_000];/// v.par_chunks_mut(1000)///     .for_each_init(///         || rand::thread_rng(),///         |rng, chunk| rng.fill(chunk),/// // There's a remote chance that this will fail.../// for i in 0u8..=255 {///     assert!(v.contains(&i));/// Executes a fallible `OP` on each item produced by the iterator, in parallel./// If the `OP` returns `Result::Err` or `Option::None`, we will attempt to/// stop processing the rest of the items in the iterator as soon as/// possible, and we will return that terminating value.  Otherwise, we will/// return an empty `Result::Ok(())` or `Option::Some(())`.  If there are/// multiple errors in parallel, it is not specified which will be returned./// use std::io::{self, Write};/// // This will stop iteration early if there's any write error, like/// // having piped output get closed on the other end.///     .try_for_each(|x| writeln!(io::stdout(), "{:?}", x))///     .expect("expected no write errors");try_for_each_with/// Executes a fallible `OP` on the given `init` value with each item/// produced by the iterator, in parallel./// This combines the `init` semantics of [`for_each_with()`] and the/// failure semantics of [`try_for_each()`]./// [`for_each_with()`]: #method.for_each_with/// [`try_for_each()`]: #method.try_for_each/// (0..5).into_par_iter()///     .try_for_each_with(sender, |s, x| s.send(x))///     .expect("expected no send errors");try_for_each_init/// Executes a fallible `OP` on a value returned by `init` with each item/// This combines the `init` semantics of [`for_each_init()`] and the/// [`for_each_init()`]: #method.for_each_init///     .try_for_each_init(///         |rng, chunk| rng.try_fill(chunk),///     .expect("expected no rand errors");/// Counts the number of items in this parallel iterator./// let count = (0..100).into_par_iter().count();/// assert_eq!(count, 100);/// Applies `map_op` to each item of this iterator, producing a new/// iterator with the results./// let mut par_iter = (0..5).into_par_iter().map(|x| x * 2);/// let doubles: Vec<_> = par_iter.collect();/// assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);/// Applies `map_op` to the given `init` value with each item of this/// iterator, producing a new iterator with the results./// let a: Vec<_> = (0..5)///                 .into_par_iter()            // iterating over i32///                 .map_with(sender, |s, x| {///                     s.send(x).unwrap();     // sending i32 values through the channel///                     x                       // returning i32///                 .collect();                 // collecting the returned values into a vector/// let mut b: Vec<_> = receiver.iter()         // iterating over the values in the channel///                             .collect();     // and collecting them/// b.sort();/// Applies `map_op` to a value returned by `init` with each item of this/// let a: Vec<_> = (1i32..1_000_000)///     .into_par_iter()///     .map_init(///         || rand::thread_rng(),  // get the thread-local RNG///         |rng, x| if rng.gen() { // randomly negate items///             -x///             x///     ).collect();/// assert!(a.iter().any(|&x| x < 0));/// assert!(a.iter().any(|&x| x > 0));/// Creates an iterator which clones all of its elements.  This may be/// useful when you have an iterator over `&T`, but you need `T`, and/// that type implements `Clone`. See also [`copied()`]./// [`copied()`]: #method.copied/// let v_cloned: Vec<_> = a.par_iter().cloned().collect();/// // cloned is the same as .map(|&x| x), for integers/// let v_map: Vec<_> = a.par_iter().map(|&x| x).collect();/// assert_eq!(v_cloned, vec![1, 2, 3]);/// assert_eq!(v_map, vec![1, 2, 3]);/// Creates an iterator which copies all of its elements.  This may be/// that type implements `Copy`. See also [`cloned()`]./// [`cloned()`]: #method.cloned/// let v_copied: Vec<_> = a.par_iter().copied().collect();/// // copied is the same as .map(|&x| x), for integers/// assert_eq!(v_copied, vec![1, 2, 3]);/// Applies `inspect_op` to a reference to each item of this iterator,/// producing a new iterator passing through the original items.  This is/// often useful for debugging to see what's happening in iterator stages./// let a = [1, 4, 2, 3];/// // this iterator sequence is complex./// let sum = a.par_iter()///             .cloned()///             .filter(|&x| x % 2 == 0)///             .reduce(|| 0, |sum, i| sum + i);/// // let's add some inspect() calls to investigate what's happening///             .inspect(|x| println!("about to filter: {}", x))///             .inspect(|x| println!("made it through filter: {}", x))/// Mutates each item of this iterator before yielding it./// let par_iter = (0..5).into_par_iter().update(|x| {*x *= 2;});/// Applies `filter_op` to each item of this iterator, producing a new/// iterator with only the items that gave `true` results./// let mut par_iter = (0..10).into_par_iter().filter(|x| x % 2 == 0);/// let even_numbers: Vec<_> = par_iter.collect();/// assert_eq!(&even_numbers[..], &[0, 2, 4, 6, 8]);/// Applies `filter_op` to each item of this iterator to get an `Option`,/// producing a new iterator with only the items from `Some` results./// let mut par_iter = (0..10).into_par_iter()///                         .filter_map(|x| {///                             if x % 2 == 0 { Some(x * 3) }///                             else { None }///                         });/// assert_eq!(&even_numbers[..], &[0, 6, 12, 18, 24]);/// Applies `map_op` to each item of this iterator to get nested parallel iterators,/// producing a new parallel iterator that flattens these back into one./// See also [`flat_map_iter`](#method.flat_map_iter)./// let a = [[1, 2], [3, 4], [5, 6], [7, 8]];/// let par_iter = a.par_iter().cloned().flat_map(|a| a.to_vec());/// let vec: Vec<_> = par_iter.collect();/// assert_eq!(&vec[..], &[1, 2, 3, 4, 5, 6, 7, 8]);/// Applies `map_op` to each item of this iterator to get nested serial iterators,/// # `flat_map_iter` versus `flat_map`/// These two methods are similar but behave slightly differently. With [`flat_map`],/// each of the nested iterators must be a parallel iterator, and they will be further/// split up with nested parallelism. With `flat_map_iter`, each nested iterator is a/// sequential `Iterator`, and we only parallelize _between_ them, while the items/// produced by each nested iterator are processed sequentially./// When choosing between these methods, consider whether nested parallelism suits the/// potential iterators at hand. If there's little computation involved, or its length/// is much less than the outer parallel iterator, then it may perform better to avoid/// the overhead of parallelism, just flattening sequentially with `flat_map_iter`./// If there is a lot of computation, potentially outweighing the outer parallel/// iterator, then the nested parallelism of `flat_map` may be worthwhile./// [`flat_map`]: #method.flat_map/// let par_iter = a.par_iter().flat_map_iter(|a| {///     // The serial iterator doesn't have to be thread-safe, just its items.///     let cell_iter = RefCell::new(a.iter().cloned());///     std::iter::from_fn(move || cell_iter.borrow_mut().next())/// An adaptor that flattens parallel-iterable `Item`s into one large iterator./// See also [`flatten_iter`](#method.flatten_iter)./// let x: Vec<Vec<_>> = vec![vec![1, 2], vec![3, 4]];/// let y: Vec<_> = x.into_par_iter().flatten().collect();/// assert_eq!(y, vec![1, 2, 3, 4]);/// An adaptor that flattens serial-iterable `Item`s into one large iterator./// See also [`flatten`](#method.flatten) and the analogous comparison of/// [`flat_map_iter` versus `flat_map`](#flat_map_iter-versus-flat_map)./// let iters: Vec<_> = x.into_iter().map(Vec::into_iter).collect();/// let y: Vec<_> = iters.into_par_iter().flatten_iter().collect();/// Reduces the items in the iterator into one item using `op`./// The argument `identity` should be a closure that can produce/// "identity" value which may be inserted into the sequence as/// needed to create opportunities for parallel execution. So, for/// example, if you are doing a summation, then `identity()` ought/// to produce something that represents the zero for your type/// (but consider just calling `sum()` in that case)./// // Iterate over a sequence of pairs `(x0, y0), ..., (xN, yN)`/// // and use reduce to compute one pair `(x0 + ... + xN, y0 + ... + yN)`/// // where the first/second elements are summed separately./// let sums = [(0, 1), (5, 6), (16, 2), (8, 9)]///            .par_iter()        // iterating over &(i32, i32)///            .cloned()          // iterating over (i32, i32)///            .reduce(|| (0, 0), // the "identity" is 0 in both columns///                    |a, b| (a.0 + b.0, a.1 + b.1));/// assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));/// **Note:** unlike a sequential `fold` operation, the order in/// which `op` will be applied to reduce the result is not fully/// specified. So `op` should be [associative] or else the results/// will be non-deterministic. And of course `identity()` should/// produce a true identity./// [associative]: https://en.wikipedia.org/wiki/Associative_propertyreduce_with/// If the iterator is empty, `None` is returned; otherwise,/// `Some` is returned./// This version of `reduce` is simple but somewhat less/// efficient. If possible, it is better to call `reduce()`, which/// requires an identity element.///            .reduce_with(|a, b| (a.0 + b.0, a.1 + b.1))///            .unwrap();/// will be non-deterministic./// Reduces the items in the iterator into one item using a fallible `op`./// The `identity` argument is used the same way as in [`reduce()`]./// [`reduce()`]: #method.reduce/// If a `Result::Err` or `Option::None` item is found, or if `op` reduces/// to one, we will attempt to stop processing the rest of the items in the/// iterator as soon as possible, and we will return that terminating value./// Otherwise, we will return the final reduced `Result::Ok(T)` or/// `Option::Some(T)`.  If there are multiple errors in parallel, it is not/// specified which will be returned./// // Compute the sum of squares, being careful about overflow./// fn sum_squares<I: IntoParallelIterator<Item = i32>>(iter: I) -> Option<i32> {///     iter.into_par_iter()///         .map(|i| i.checked_mul(i))            // square each item,///         .try_reduce(|| 0, i32::checked_add)   // and add them up!/// assert_eq!(sum_squares(0..5), Some(0 + 1 + 4 + 9 + 16));/// // The sum might overflow/// assert_eq!(sum_squares(0..10_000), None);/// // Or the squares might overflow before it even reaches `try_reduce`/// assert_eq!(sum_squares(1_000_000..1_000_001), None);/// Like [`reduce_with()`], if the iterator is empty, `None` is returned;/// otherwise, `Some` is returned.  Beyond that, it behaves like/// [`try_reduce()`] for handling `Err`/`None`./// [`reduce_with()`]: #method.reduce_with/// [`try_reduce()`]: #method.try_reduce/// For instance, with `Option` items, the return value may be:/// - `None`, the iterator was empty/// - `Some(None)`, we stopped after encountering `None`./// - `Some(Some(x))`, the entire iterator reduced to `x`./// With `Result` items, the nesting is more obvious:/// - `Some(Err(e))`, we stopped after encountering an error `e`./// - `Some(Ok(x))`, the entire iterator reduced to `x`./// let files = ["/dev/null", "/does/not/exist"];/// // Find the biggest file/// files.into_par_iter()///     .map(|path| std::fs::metadata(path).map(|m| (path, m.len())))///     .try_reduce_with(|a, b| {///         Ok(if a.1 >= b.1 { a } else { b })///     .expect("Some value, since the iterator is not empty")///     .expect_err("not found");/// Parallel fold is similar to sequential fold except that the/// sequence of items may be subdivided before it is/// folded. Consider a list of numbers like `22 3 77 89 46`. If/// you used sequential fold to add them (`fold(0, |a,b| a+b)`,/// you would wind up first adding 0 + 22, then 22 + 3, then 25 +/// 77, and so forth. The **parallel fold** works similarly except/// that it first breaks up your list into sublists, and hence/// instead of yielding up a single sum at the end, it yields up/// multiple sums. The number of results is nondeterministic, as/// is the point where the breaks occur./// So if we did the same parallel fold (`fold(0, |a,b| a+b)`) on/// our example list, we might wind up with a sequence of two numbers,/// like so:/// 22 3 77 89 46///       |     |///     102   135/// Or perhaps these three numbers:///       |  |  |///     102 89 46/// In general, Rayon will attempt to find good breaking points/// that keep all of your cores busy./// ### Fold versus reduce/// The `fold()` and `reduce()` methods each take an identity element/// and a combining function, but they operate rather differently./// `reduce()` requires that the identity function has the same/// type as the things you are iterating over, and it fully/// reduces the list of items into a single item. So, for example,/// imagine we are iterating over a list of bytes `bytes: [128_u8,/// 64_u8, 64_u8]`. If we used `bytes.reduce(|| 0_u8, |a: u8, b:/// u8| a + b)`, we would get an overflow. This is because `0`,/// `a`, and `b` here are all bytes, just like the numbers in the/// list (I wrote the types explicitly above, but those are the/// only types you can use). To avoid the overflow, we would need/// to do something like `bytes.map(|b| b as u32).reduce(|| 0, |a,/// b| a + b)`, in which case our result would be `256`./// In contrast, with `fold()`, the identity function does not/// have to have the same type as the things you are iterating/// over, and you potentially get back many results. So, if we/// continue with the `bytes` example from the previous paragraph,/// we could do `bytes.fold(|| 0_u32, |a, b| a + (b as u32))` to/// convert our bytes into `u32`. And of course we might not get/// back a single sum./// There is a more subtle distinction as well, though it's/// actually implied by the above points. When you use `reduce()`,/// your reduction function is sometimes called with values that/// were never part of your original parallel iterator (for/// example, both the left and right might be a partial sum). With/// `fold()`, in contrast, the left value in the fold function is/// always the accumulator, and the right value is always from/// your original sequence./// ### Fold vs Map/Reduce/// Fold makes sense if you have some operation where it is/// cheaper to create groups of elements at a time. For example,/// imagine collecting characters into a string. If you were going/// to use map/reduce, you might try this:/// let s =///     ['a', 'b', 'c', 'd', 'e']///     .par_iter()///     .map(|c: &char| format!("{}", c))///     .reduce(|| String::new(),///             |mut a: String, b: String| { a.push_str(&b); a });/// assert_eq!(s, "abcde");/// Because reduce produces the same type of element as its input,/// you have to first map each character into a string, and then/// you can reduce them. This means we create one string per/// element in our iterator -- not so great. Using `fold`, we can/// do this instead:///     .fold(|| String::new(),///             |mut s: String, c: &char| { s.push(*c); s })/// Now `fold` will process groups of our characters at a time,/// and we only make one string per group. We should wind up with/// some small-ish number of strings roughly proportional to the/// number of CPUs you have (it will ultimately depend on how busy/// your processors are). Note that we still need to do a reduce/// afterwards to combine those groups of strings into a single/// You could use a similar trick to save partial results (e.g., a/// cache) or something similar./// ### Combining fold with other operations/// You can combine `fold` with `reduce` if you want to produce a/// single value. This is then roughly equivalent to a map/reduce/// combination in effect:/// let bytes = 0..22_u8;/// let sum = bytes.into_par_iter()///                .fold(|| 0_u32, |a: u32, b: u8| a + (b as u32))///                .sum::<u32>();/// assert_eq!(sum, (0..22).sum()); // compare to sequential/// Applies `fold_op` to the given `init` value with each item of this/// iterator, finally producing the value for further use./// This works essentially like `fold(|| init.clone(), fold_op)`, except/// it doesn't require the `init` type to be `Sync`, nor any other form/// of added synchronization.///                .fold_with(0_u32, |a: u32, b: u8| a + (b as u32))/// Performs a fallible parallel fold./// This is a variation of [`fold()`] for operations which can fail with/// `Option::None` or `Result::Err`.  The first such failure stops/// processing the local set of items, without affecting other folds in the/// iterator's subdivisions./// Often, `try_fold()` will be followed by [`try_reduce()`]/// for a final reduction and global short-circuiting effect./// [`fold()`]: #method.fold///                .try_fold(|| 0_u32, |a: u32, b: u8| a.checked_add(b as u32))///                .try_reduce(|| 0, u32::checked_add);/// assert_eq!(sum, Some((0..22).sum())); // compare to sequential/// Performs a fallible parallel fold with a cloneable `init` value./// This combines the `init` semantics of [`fold_with()`] and the failure/// semantics of [`try_fold()`]./// [`fold_with()`]: #method.fold_with/// [`try_fold()`]: #method.try_fold///                .try_fold_with(0_u32, |a: u32, b: u8| a.checked_add(b as u32))/// Sums up the items in the iterator./// Note that the order in items will be reduced is not specified,/// so if the `+` operator is not truly [associative] \(as is the/// case for floating point numbers), then the results are not/// fully deterministic./// Basically equivalent to `self.reduce(|| 0, |a, b| a + b)`,/// except that the type of `0` and the `+` operation may vary/// depending on the type of value being produced./// let a = [1, 5, 7];/// let sum: i32 = a.par_iter().sum();/// assert_eq!(sum, 13);/// Multiplies all the items in the iterator./// so if the `*` operator is not truly [associative] \(as is the/// Basically equivalent to `self.reduce(|| 1, |a, b| a * b)`,/// except that the type of `1` and the `*` operation may vary/// fn factorial(n: u32) -> u32 {///    (1..n+1).into_par_iter().product()/// assert_eq!(factorial(0), 1);/// assert_eq!(factorial(1), 1);/// assert_eq!(factorial(5), 120);/// Computes the minimum of all the items in the iterator. If the/// iterator is empty, `None` is returned; otherwise, `Some(min)`/// Note that the order in which the items will be reduced is not/// specified, so if the `Ord` impl is not truly associative, then/// the results are not deterministic./// Basically equivalent to `self.reduce_with(|a, b| Ord::min(a, b))`./// let a = [45, 74, 32];/// assert_eq!(a.par_iter().min(), Some(&32));/// let b: [i32; 0] = [];/// assert_eq!(b.par_iter().min(), None);/// Computes the minimum of all the items in the iterator with respect to/// the given comparison function. If the iterator is empty, `None` is/// returned; otherwise, `Some(min)` is returned./// specified, so if the comparison function is not associative, then/// let a = [-3_i32, 77, 53, 240, -1];/// assert_eq!(a.par_iter().min_by(|x, y| x.cmp(y)), Some(&-3));/// Computes the item that yields the minimum value for the given/// function. If the iterator is empty, `None` is returned;/// otherwise, `Some(item)` is returned./// let a = [-3_i32, 34, 2, 5, -10, -3, -23];/// assert_eq!(a.par_iter().min_by_key(|x| x.abs()), Some(&2));/// Computes the maximum of all the items in the iterator. If the/// iterator is empty, `None` is returned; otherwise, `Some(max)`/// Basically equivalent to `self.reduce_with(|a, b| Ord::max(a, b))`./// assert_eq!(a.par_iter().max(), Some(&74));/// assert_eq!(b.par_iter().max(), None);/// Computes the maximum of all the items in the iterator with respect to/// returned; otherwise, `Some(max)` is returned./// assert_eq!(a.par_iter().max_by(|x, y| x.abs().cmp(&y.abs())), Some(&240));/// Computes the item that yields the maximum value for the given/// assert_eq!(a.par_iter().max_by_key(|x| x.abs()), Some(&34));/// Takes two iterators and creates a new iterator over both./// let a = [0, 1, 2];/// let b = [9, 8, 7];/// let par_iter = a.par_iter().chain(b.par_iter());/// let chained: Vec<_> = par_iter.cloned().collect();/// assert_eq!(&chained[..], &[0, 1, 2, 9, 8, 7]);find_any/// Searches for **some** item in the parallel iterator that/// matches the given predicate and returns it. This operation/// is similar to [`find` on sequential iterators][find] but/// the item returned may not be the **first** one in the parallel/// sequence which matches, since we search the entire sequence in parallel./// Once a match is found, we will attempt to stop processing/// the rest of the items in the iterator as soon as possible/// (just as `find` stops iterating once a match is found)./// [find]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find/// let a = [1, 2, 3, 3];/// assert_eq!(a.par_iter().find_any(|&&x| x == 3), Some(&3));/// assert_eq!(a.par_iter().find_any(|&&x| x == 100), None);/// Searches for the sequentially **first** item in the parallel iterator/// that matches the given predicate and returns it./// Once a match is found, all attempts to the right of the match/// will be stopped, while attempts to the left must continue in case/// an earlier match is found./// For added performance, you might consider using `find_first` in conjunction with/// [`by_exponential_blocks()`][IndexedParallelIterator::by_exponential_blocks]./// Note that not all parallel iterators have a useful order, much like/// sequential `HashMap` iteration, so "first" may be nebulous.  If you/// just want the first match that discovered anywhere in the iterator,/// `find_any` is a better choice./// assert_eq!(a.par_iter().find_first(|&&x| x == 3), Some(&3));/// assert_eq!(a.par_iter().find_first(|&&x| x == 100), None);/// Searches for the sequentially **last** item in the parallel iterator/// Once a match is found, all attempts to the left of the match/// will be stopped, while attempts to the right must continue in case/// a later match is found./// sequential `HashMap` iteration, so "last" may be nebulous.  When the/// order doesn't actually matter to you, `find_any` is a better choice./// assert_eq!(a.par_iter().find_last(|&&x| x == 3), Some(&3));/// assert_eq!(a.par_iter().find_last(|&&x| x == 100), None);find_map_any/// Applies the given predicate to the items in the parallel iterator/// and returns **any** non-None result of the map operation./// Once a non-None value is produced from the map operation, we will/// attempt to stop processing the rest of the items in the iterator/// as soon as possible./// Note that this method only returns **some** item in the parallel/// iterator that is not None from the map predicate. The item returned/// may not be the **first** non-None value produced in the parallel/// sequence, since the entire sequence is mapped over in parallel./// let c = ["lol", "NaN", "5", "5"];/// let found_number = c.par_iter().find_map_any(|s| s.parse().ok());/// assert_eq!(found_number, Some(5));find_map_first/// Applies the given predicate to the items in the parallel iterator and/// returns the sequentially **first** non-None result of the map operation./// Once a non-None value is produced from the map operation, all attempts/// to the right of the match will be stopped, while attempts to the left/// must continue in case an earlier match is found./// sequential `HashMap` iteration, so "first" may be nebulous. If you/// just want the first non-None value discovered anywhere in the iterator,/// `find_map_any` is a better choice./// let c = ["lol", "NaN", "2", "5"];/// let first_number = c.par_iter().find_map_first(|s| s.parse().ok());/// assert_eq!(first_number, Some(2));find_map_last/// returns the sequentially **last** non-None result of the map operation./// to the left of the match will be stopped, while attempts to the right/// must continue in case a later match is found./// let last_number = c.par_iter().find_map_last(|s| s.parse().ok());/// assert_eq!(last_number, Some(5));/// matches the given predicate, and if so returns true.  Once/// a match is found, we'll attempt to stop process the rest/// of the items.  Proving that there's no match, returning false,/// does require visiting every item./// let a = [0, 12, 3, 4, 0, 23, 0];/// let is_valid = a.par_iter().any(|&x| x > 10);/// assert!(is_valid);/// Tests that every item in the parallel iterator matches the given/// predicate, and if so returns true.  If a counter-example is found,/// we'll attempt to stop processing more items, then return false./// let is_valid = a.par_iter().all(|&x| x > 10);/// assert!(!is_valid);/// Creates an iterator over the `Some` items of this iterator, halting/// as soon as any `None` is found./// use std::sync::atomic::{AtomicUsize, Ordering};/// let counter = AtomicUsize::new(0);/// let value = (0_i32..2048)///     .map(|x| {///              counter.fetch_add(1, Ordering::SeqCst);///              if x < 1024 { Some(x) } else { None }///          })///     .while_some()/// assert!(value < Some(1024));/// assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one/// Wraps an iterator with a fuse in case of panics, to halt all threads/// Panics within parallel iterators are always propagated to the caller,/// but they don't always halt the rest of the iterator right away, due to/// the internal semantics of [`join`]. This adaptor makes a greater effort/// to stop processing other items sooner, with the cost of additional/// synchronization overhead, which may also inhibit some optimizations./// [`join`]: ../fn.join.html#panics/// If this code didn't use `panic_fuse()`, it would continue processing/// many more items in other threads (with long sleep delays) before the/// panic is finally propagated./// (0..1_000_000)///     .panic_fuse()///     .for_each(|i| {///         // simulate some work///         thread::sleep(time::Duration::from_secs(1));///         assert!(i > 0); // oops!/// Creates a fresh collection containing all the elements produced/// by this parallel iterator./// You may prefer [`collect_into_vec()`] implemented on/// [`IndexedParallelIterator`], if your underlying iterator also implements/// it. [`collect_into_vec()`] allocates efficiently with precise knowledge/// of how many elements the iterator contains, and even allows you to reuse/// an existing vector's backing store rather than allocating a fresh vector./// See also [`collect_vec_list()`][Self::collect_vec_list] for collecting/// into a `LinkedList<Vec<T>>`./// [`collect_into_vec()`]:///     trait.IndexedParallelIterator.html#method.collect_into_vec/// let sync_vec: Vec<_> = (0..100).into_iter().collect();/// let async_vec: Vec<_> = (0..100).into_par_iter().collect();/// assert_eq!(sync_vec, async_vec);/// You can collect a pair of collections like [`unzip`](#method.unzip)/// for paired items:/// let a = [(0, 1), (1, 2), (2, 3), (3, 4)];/// let (first, second): (Vec<_>, Vec<_>) = a.into_par_iter().collect();/// assert_eq!(first, [0, 1, 2, 3]);/// assert_eq!(second, [1, 2, 3, 4]);/// Or like [`partition_map`](#method.partition_map) for `Either` items:/// use rayon::iter::Either;/// let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter().map(|x| {///     if x % 2 == 0 {///         Either::Left(x * 4)///         Either::Right(x * 3)/// }).collect();/// assert_eq!(left, [0, 8, 16, 24]);/// assert_eq!(right, [3, 9, 15, 21]);/// You can even collect an arbitrarily-nested combination of pairs and `Either`:/// let (first, (left, right)): (Vec<_>, (Vec<_>, Vec<_>))///     = (0..8).into_par_iter().map(|x| {///         if x % 2 == 0 {///             (x, Either::Left(x * 4))///             (-x, Either::Right(x * 3))///     }).collect();/// assert_eq!(first, [0, -1, 2, -3, 4, -5, 6, -7]);/// All of that can _also_ be combined with short-circuiting collection of/// `Result` or `Option` types:/// let result: Result<(Vec<_>, (Vec<_>, Vec<_>)), _>///         if x > 5 {///             Err(x)///         } else if x % 2 == 0 {///             Ok((x, Either::Left(x * 4)))///             Ok((-x, Either::Right(x * 3)))/// assert!(error == 6 || error == 7);/// Unzips the items of a parallel iterator into a pair of arbitrary/// `ParallelExtend` containers./// You may prefer to use `unzip_into_vecs()`, which allocates more/// efficiently with precise knowledge of how many elements the/// iterator contains, and even allows you to reuse existing/// vectors' backing stores rather than allocating fresh vectors./// let (left, right): (Vec<_>, Vec<_>) = a.par_iter().cloned().unzip();/// assert_eq!(left, [0, 1, 2, 3]);/// assert_eq!(right, [1, 2, 3, 4]);/// Nested pairs can be unzipped too./// let (values, (squares, cubes)): (Vec<_>, (Vec<_>, Vec<_>)) = (0..4).into_par_iter()///     .map(|i| (i, (i * i, i * i * i)))///     .unzip();/// assert_eq!(values, [0, 1, 2, 3]);/// assert_eq!(squares, [0, 1, 4, 9]);/// assert_eq!(cubes, [0, 1, 8, 27]);/// Partitions the items of a parallel iterator into a pair of arbitrary/// `ParallelExtend` containers.  Items for which the `predicate` returns/// true go into the first container, and the rest go into the second./// Note: unlike the standard `Iterator::partition`, this allows distinct/// collection types for the left and right items.  This is more flexible,/// but may require new type annotations when converting sequential code/// that used type inference assuming the two were the same./// let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter().partition(|x| x % 2 == 0);/// assert_eq!(left, [0, 2, 4, 6]);/// assert_eq!(right, [1, 3, 5, 7]);/// Partitions and maps the items of a parallel iterator into a pair of/// arbitrary `ParallelExtend` containers.  `Either::Left` items go into/// the first container, and `Either::Right` items go into the second./// let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter()///     .partition_map(|x| {///             Either::Left(x * 4)///             Either::Right(x * 3)/// Nested `Either` enums can be split as well./// use rayon::iter::Either::*;/// let ((fizzbuzz, fizz), (buzz, other)): ((Vec<_>, Vec<_>), (Vec<_>, Vec<_>)) = (1..20)///     .partition_map(|x| match (x % 3, x % 5) {///         (0, 0) => Left(Left(x)),///         (0, _) => Left(Right(x)),///         (_, 0) => Right(Left(x)),///         (_, _) => Right(Right(x)),/// assert_eq!(fizzbuzz, [15]);/// assert_eq!(fizz, [3, 6, 9, 12, 18]);/// assert_eq!(buzz, [5, 10]);/// assert_eq!(other, [1, 2, 4, 7, 8, 11, 13, 14, 16, 17, 19]);/// Intersperses clones of an element between items of this iterator./// let x = vec![1, 2, 3];/// let r: Vec<_> = x.into_par_iter().intersperse(-1).collect();/// assert_eq!(r, vec![1, -1, 2, -1, 3]);/// Creates an iterator that yields `n` elements from *anywhere* in the original iterator./// This is similar to [`IndexedParallelIterator::take`] without being/// constrained to the "first" `n` of the original iterator order. The/// taken items will still maintain their relative order where that is/// visible in `collect`, `reduce`, and similar outputs./// let result: Vec<_> = (0..100)///     .filter(|&x| x % 2 == 0)///     .take_any(5)/// assert_eq!(result.len(), 5);/// assert!(result.windows(2).all(|w| w[0] < w[1]));/// Creates an iterator that skips `n` elements from *anywhere* in the original iterator./// This is similar to [`IndexedParallelIterator::skip`] without being/// remaining items will still maintain their relative order where that is///     .skip_any(5)/// assert_eq!(result.len(), 45);/// Creates an iterator that takes elements from *anywhere* in the original iterator/// until the given `predicate` returns `false`./// The `predicate` may be anything -- e.g. it could be checking a fact about the item, a/// global condition unrelated to the item itself, or some combination thereof./// If parallel calls to the `predicate` race and give different results, then the/// `true` results will still take those particular items, while respecting the `false`/// result from elsewhere to skip any further items./// This is similar to [`Iterator::take_while`] without being constrained to the original/// iterator order. The taken items will still maintain their relative order where that is///     .take_any_while(|x| *x < 50)/// assert!(result.len() <= 50);/// // Collect any group of items that sum <= 1000/// let quota = AtomicUsize::new(1000);/// let result: Vec<_> = (0_usize..100)///     .take_any_while(|&x| {///         quota.fetch_update(Relaxed, Relaxed, |q| q.checked_sub(x))///             .is_ok()/// let sum = result.iter().sum::<usize>();/// assert!(matches!(sum, 902..=1000));/// Creates an iterator that skips elements from *anywhere* in the original iterator/// `true` results will still skip those particular items, while respecting the `false`/// This is similar to [`Iterator::skip_while`] without being constrained to the original/// iterator order. The remaining items will still maintain their relative order where that is///     .skip_any_while(|x| *x < 50)/// assert!(result.len() >= 50);collect_vec_list/// Collects this iterator into a linked list of vectors./// This is useful when you need to condense a parallel iterator into a collection,/// but have no specific requirements for what that collection should be. If you/// plan to store the collection longer-term, `Vec<T>` is, as always, likely the/// best default choice, despite the overhead that comes from concatenating each/// vector. Or, if this is an `IndexedParallelIterator`, you should also prefer to/// just collect to a `Vec<T>`./// Internally, most [`FromParallelIterator`]/[`ParallelExtend`] implementations/// use this strategy; each job collecting their chunk of the iterator to a `Vec<T>`/// and those chunks getting merged into a `LinkedList`, before then extending the/// collection with each vector. This is a very efficient way to collect an/// unindexed parallel iterator, without much intermediate data movement./// # use std::collections::LinkedList;/// let result: LinkedList<Vec<_>> = (0..=100)///     .filter(|x| x % 2 == 0)///     .flat_map(|x| 0..x)///     .collect_vec_list();/// // `par_iter.collect_vec_list().into_iter().flatten()` turns/// // a parallel iterator into a serial one/// let total_len = result.into_iter().flatten().count();/// assert_eq!(total_len, 2550);/// Internal method used to define the behavior of this parallel/// iterator. You should not need to call this directly./// This method causes the iterator `self` to start producing/// items and to feed them to the consumer `consumer` one by one./// It may split the consumer before doing so to create the/// opportunity to produce in parallel./// See the [README] for more details on the internals of parallel/// iterators./// [README]: https://github.com/rayon-rs/rayon/blob/main/src/iter/plumbing/README.md/// Returns the number of items produced by this iterator, if known/// statically. This can be used by consumers to trigger special fast/// paths. Therefore, if `Some(_)` is returned, this iterator must only/// use the (indexed) `Consumer` methods when driving a consumer, such/// as `split_at()`. Calling `UnindexedConsumer::split_off_left()` or/// other `UnindexedConsumer` methods -- or returning an inaccurate/// value -- may result in panics./// This method is currently used to optimize `collect` for want/// of true Rust specialization; it may be removed when/// specialization is stable./// Parallel version of the standard iterator trait./// The combinators on this trait are available on **all** parallel/// iterators.  Additional methods can be found on the/// [`IndexedParallelIterator`] trait: those methods are only/// available for parallel iterators where the number of items is/// known in advance (so, e.g., after invoking `filter`, those methods/// become unavailable)./// For examples of using parallel iterators, see [the docs on the/// `iter` module][iter]./// [iter]: index.html/// Divides an iterator into sequential blocks of exponentially-increasing size./// Normally, parallel iterators are recursively divided into tasks in parallel./// This adaptor changes the default behavior by splitting the iterator into a **sequence**/// of parallel iterators of increasing sizes./// Sizes grow exponentially in order to avoid creating/// too many blocks. This also allows to balance the current block with all previous ones./// This can have many applications but the most notable ones are:/// - better performance with [`find_first()`][ParallelIterator::find_first]/// - more predictable performance with [`find_any()`][ParallelIterator::find_any]///   or any interruptible computation/// assert_eq!((0..10_000).into_par_iter()///                       .by_exponential_blocks()///                       .find_first(|&e| e==4_999), Some(4_999))/// In this example, without blocks, rayon will split the initial range into two but all work/// on the right hand side (from 5,000 onwards) is **useless** since the sequential algorithm/// never goes there. This means that if two threads are used there will be **no** speedup **at/// all**./// `by_exponential_blocks` on the other hand will start with the leftmost range from 0/// to `p` (threads number), continue with p to 3p, the 3p to 7p.../// Each subrange is treated in parallel, while all subranges are treated sequentially./// We therefore ensure a logarithmic number of blocks (and overhead) while guaranteeing/// we stop at the first block containing the searched data./// Divides an iterator into sequential blocks of the given size./// of parallel iterators of given `block_size`./// The main application is to obtain better/// memory locality (especially if the reduce operation re-use folded data)./// **Panics** if `block_size` is 0./// // during most reductions v1 and v2 fit the cache/// let v = (0u32..10_000_000)///     .by_uniform_blocks(1_000_000)///     .fold(Vec::new, |mut v, e| { v.push(e); v})///     .reduce(Vec::new, |mut v1, mut v2| { v1.append(&mut v2); v1});/// assert_eq!(v, (0u32..10_000_000).collect::<Vec<u32>>());/// Collects the results of the iterator into the specified/// vector. The vector is always cleared before execution/// begins. If possible, reusing the vector across calls can lead/// to better performance since it reuses the same backing buffer./// // any prior data will be cleared/// let mut vec = vec![-1, -2, -3];///     .collect_into_vec(&mut vec);/// assert_eq!(vec, [0, 1, 2, 3, 4]);/// Unzips the results of the iterator into the specified/// vectors. The vectors are always cleared before execution/// begins. If possible, reusing the vectors across calls can lead/// to better performance since they reuse the same backing buffer./// let mut left = vec![42; 10];/// let mut right = vec![-1; 10];/// (10..15).into_par_iter()///     .enumerate()///     .unzip_into_vecs(&mut left, &mut right);/// assert_eq!(left, [0, 1, 2, 3, 4]);/// assert_eq!(right, [10, 11, 12, 13, 14]);/// Iterates over tuples `(A, B)`, where the items `A` are from/// this iterator and `B` are from the iterator given as argument./// Like the `zip` method on ordinary iterators, if the two/// iterators are of unequal length, you only get the items they/// have in common./// let result: Vec<_> = (1..4)///     .zip(vec!['a', 'b', 'c'])/// assert_eq!(result, [(1, 'a'), (2, 'b'), (3, 'c')]);/// The same as `Zip`, but requires that both iterators have the same length./// Will panic if `self` and `zip_op` are not the same length./// let one = [1u8];/// let two = [2u8, 2];/// let one_iter = one.par_iter();/// let two_iter = two.par_iter();/// // this will panic/// let zipped: Vec<(&u8, &u8)> = one_iter.zip_eq(two_iter).collect();/// // we should never get here/// assert_eq!(1, zipped.len());/// Interleaves elements of this iterator and the other given/// iterator. Alternately yields elements from this iterator and/// the given iterator, until both are exhausted. If one iterator/// is exhausted before the other, the last elements are provided/// from the other./// let (x, y) = (vec![1, 2], vec![3, 4, 5, 6]);/// let r: Vec<i32> = x.into_par_iter().interleave(y).collect();/// assert_eq!(r, vec![1, 3, 2, 4, 5, 6]);/// iterator, until one is exhausted./// let (x, y) = (vec![1, 2, 3, 4], vec![5, 6]);/// let r: Vec<i32> = x.into_par_iter().interleave_shortest(y).collect();/// assert_eq!(r, vec![1, 5, 2, 6, 3]);/// Splits an iterator up into fixed-size chunks./// Returns an iterator that returns `Vec`s of the given number of elements./// If the number of elements in the iterator is not divisible by `chunk_size`,/// the last chunk may be shorter than `chunk_size`./// See also [`par_chunks()`] and [`par_chunks_mut()`] for similar behavior on/// slices, without having to allocate intermediate `Vec`s for the chunks./// [`par_chunks()`]: ../slice/trait.ParallelSlice.html#method.par_chunks/// [`par_chunks_mut()`]: ../slice/trait.ParallelSliceMut.html#method.par_chunks_mut/// **Panics** if `chunk_size` is 0./// let a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];/// let r: Vec<Vec<i32>> = a.into_par_iter().chunks(3).collect();/// assert_eq!(r, vec![vec![1,2,3], vec![4,5,6], vec![7,8,9], vec![10]]);/// Splits an iterator into fixed-size chunks, performing a sequential [`fold()`] on/// each chunk./// Returns an iterator that produces a folded result for each chunk of items/// produced by this iterator./// This works essentially like:/// iter.chunks(chunk_size)///     .map(|chunk|///         chunk.into_iter()///             .fold(identity, fold_op)/// except there is no per-chunk allocation overhead./// [`fold()`]: std::iter::Iterator#method.fold/// let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];/// let chunk_sums = nums.into_par_iter().fold_chunks(2, || 0, |a, n| a + n).collect::<Vec<_>>();/// assert_eq!(chunk_sums, vec![3, 7, 11, 15, 19]);/// This works essentially like `fold_chunks(chunk_size, || init.clone(), fold_op)`,/// except it doesn't require the `init` type to be `Sync`, nor any other form of/// added synchronization./// let chunk_sums = nums.into_par_iter().fold_chunks_with(2, 0, |a, n| a + n).collect::<Vec<_>>();/// Lexicographically compares the elements of this `ParallelIterator` with those of/// another./// use std::cmp::Ordering::*;/// assert_eq!(x.par_iter().cmp(&vec![1, 3, 0]), Less);/// assert_eq!(x.par_iter().cmp(&vec![1, 2, 3]), Equal);/// assert_eq!(x.par_iter().cmp(&vec![1, 2]), Greater);/// use std::f64::NAN;/// let x = vec![1.0, 2.0, 3.0];/// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 3.0, 0.0]), Some(Less));/// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 2.0, 3.0]), Some(Equal));/// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 2.0]), Some(Greater));/// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, NAN]), None);/// Determines if the elements of this `ParallelIterator`/// are equal to those of another/// are unequal to those of another/// are lexicographically less than those of another./// are less or equal to those of another./// are lexicographically greater than those of another./// Yields an index along with each item./// let chars = vec!['a', 'b', 'c'];/// let result: Vec<_> = chars/// assert_eq!(result, [(0, 'a'), (1, 'b'), (2, 'c')]);/// Creates an iterator that steps by the given amount///use rayon::prelude::*;/// let range = (3..10);/// let result: Vec<i32> = range///    .into_par_iter()///    .step_by(3)///    .collect();/// assert_eq!(result, [3, 6, 9])/// Creates an iterator that skips the first `n` elements.///     .skip(95)/// assert_eq!(result, [95, 96, 97, 98, 99]);/// Creates an iterator that yields the first `n` elements.///     .take(5)/// assert_eq!(result, [0, 1, 2, 3, 4]);position_any/// matches the given predicate, and returns its index.  Like/// `ParallelIterator::find_any`, the parallel search will not/// necessarily find the **first** match, and once a match is/// found we'll attempt to stop processing any more./// let i = a.par_iter().position_any(|&x| x == 3).expect("found");/// assert!(i == 2 || i == 3);/// assert_eq!(a.par_iter().position_any(|&x| x == 100), None);position_first/// that matches the given predicate, and returns its index./// Like `ParallelIterator::find_first`, once a match is found,/// all attempts to the right of the match will be stopped, while/// attempts to the left must continue in case an earlier match/// is found./// `position_any` is a better choice./// assert_eq!(a.par_iter().position_first(|&x| x == 3), Some(2));/// assert_eq!(a.par_iter().position_first(|&x| x == 100), None);position_last/// Like `ParallelIterator::find_last`, once a match is found,/// all attempts to the left of the match will be stopped, while/// attempts to the right must continue in case a later match/// order doesn't actually matter to you, `position_any` is a better/// choice./// assert_eq!(a.par_iter().position_last(|&x| x == 3), Some(3));/// assert_eq!(a.par_iter().position_last(|&x| x == 100), None);/// Searches for items in the parallel iterator that match the given/// predicate, and returns their indices./// let primes = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29];/// // Find the positions of primes congruent to 1 modulo 6/// let p1mod6: Vec<_> = primes.par_iter().positions(|&p| p % 6 == 1).collect();/// assert_eq!(p1mod6, [3, 5, 7]); // primes 7, 13, and 19/// // Find the positions of primes congruent to 5 modulo 6/// let p5mod6: Vec<_> = primes.par_iter().positions(|&p| p % 6 == 5).collect();/// assert_eq!(p5mod6, [2, 4, 6, 8, 9]); // primes 5, 11, 17, 23, and 29/// Produces a new iterator with the elements of this iterator in/// reverse order./// let result: Vec<_> = (0..5)///     .rev()/// assert_eq!(result, [4, 3, 2, 1, 0]);/// Sets the minimum length of iterators desired to process in each/// rayon job.  Rayon will not split any smaller than this length, but/// of course an iterator could already be smaller to begin with./// Producers like `zip` and `interleave` will use greater of the two/// minimums./// Chained iterators and iterators inside `flat_map` may each use/// their own minimum length./// let min = (0..1_000_000)///     .with_min_len(1234)///     .fold(|| 0, |acc, _| acc + 1) // count how many are in this segment///     .min().unwrap();/// assert!(min >= 1234);/// Sets the maximum length of iterators desired to process in each/// rayon job.  Rayon will try to split at least below this length,/// unless that would put it below the length from `with_min_len()`./// For example, given min=10 and max=15, a length of 16 will not be/// split any further./// Producers like `zip` and `interleave` will use lesser of the two/// maximums./// their own maximum length./// let max = (0..1_000_000)///     .with_max_len(1234)///     .max().unwrap();/// assert!(max <= 1234);/// Produces an exact count of how many items this iterator will/// produce, presuming no panic occurs./// let par_iter = (0..100).into_par_iter().zip(vec![0; 10]);/// assert_eq!(par_iter.len(), 10);/// assert_eq!(vec.len(), 10);/// opportunity to produce in parallel. If a split does happen, it/// will inform the consumer of the index where the split should/// occur (unlike `ParallelIterator::drive_unindexed()`)./// This method converts the iterator into a producer P and then/// invokes `callback.callback()` with P. Note that the type of/// this producer is not defined as part of the API, since/// `callback` must be defined generically for all producers. This/// allows the producer type to contain references; it also means/// that parallel iterators can adjust that type without causing a/// breaking change./// An iterator that supports "random access" to its data, meaning/// that you can split it at arbitrary indices and draw data from/// those points./// **Note:** Not implemented for `u64`, `i64`, `u128`, or `i128` ranges// Waiting for `ExactSizeIterator::is_empty` to be stabilized. See rust-lang/rust#35428/// Creates an instance of the collection from the parallel iterator `par_iter`./// If your collection is not naturally parallel, the easiest (and/// fastest) way to do this is often to collect `par_iter` into a/// [`LinkedList`] (via [`collect_vec_list`]) or another intermediate/// data structure and then sequentially extend your collection. However,/// a more 'native' technique is to use the [`par_iter.fold`] or/// [`par_iter.fold_with`] methods to create the collection./// Alternatively, if your collection is 'natively' parallel, you/// can use `par_iter.for_each` to process each element in turn./// [`LinkedList`]: https://doc.rust-lang.org/std/collections/struct.LinkedList.html/// [`collect_vec_list`]: ParallelIterator::collect_vec_list/// [`par_iter.fold`]: trait.ParallelIterator.html#method.fold/// [`par_iter.fold_with`]: trait.ParallelIterator.html#method.fold_with/// [`par_iter.for_each`]: trait.ParallelIterator.html#method.for_each/// `FromParallelIterator` implements the creation of a collection/// from a [`ParallelIterator`]. By implementing/// `FromParallelIterator` for a given type, you define how it will be/// created from an iterator./// `FromParallelIterator` is used through [`ParallelIterator`]'s [`collect()`] method./// [`collect()`]: trait.ParallelIterator.html#method.collect/// Implementing `FromParallelIterator` for your type:/// struct BlackHole {///     mass: usize,/// impl<T: Send> FromParallelIterator<T> for BlackHole {///     fn from_par_iter<I>(par_iter: I) -> Self///         where I: IntoParallelIterator<Item = T>///         let par_iter = par_iter.into_par_iter();///         BlackHole {///             mass: par_iter.count() * mem::size_of::<T>(),/// let bh: BlackHole = (0i32..1000).into_par_iter().collect();/// assert_eq!(bh.mass, 4000);/// Extends an instance of the collection with the elements drawn/// from the parallel iterator `par_iter`./// let mut vec = vec![];/// vec.par_extend(0..5);/// vec.par_extend((0..5).into_par_iter().map(|i| i * i));/// assert_eq!(vec, [0, 1, 2, 3, 4, 0, 1, 4, 9, 16]);/// `ParallelExtend` extends an existing collection with items from a [`ParallelIterator`]./// Implementing `ParallelExtend` for your type:/// impl<T: Send> ParallelExtend<T> for BlackHole {///     fn par_extend<I>(&mut self, par_iter: I)///         self.mass += par_iter.count() * mem::size_of::<T>();/// let mut bh = BlackHole { mass: 0 };/// bh.par_extend(0i32..1000);/// bh.par_extend(0i64..10);/// assert_eq!(bh.mass, 4080);/// The draining parallel iterator type that will be created./// This is usually the same as `IntoParallelIterator::Item`./// Returns a draining parallel iterator over an entire collection./// When the iterator is dropped, all items are removed, even if the/// iterator was not fully consumed. If the iterator is leaked, for example/// using `std::mem::forget`, it is unspecified how many items are removed./// use std::collections::{BinaryHeap, HashSet};/// let squares: HashSet<i32> = (0..10).map(|x| x * x).collect();/// let mut heap: BinaryHeap<_> = squares.iter().copied().collect();///     // heaps are drained in arbitrary order///     heap.par_drain()///         .inspect(|x| assert!(squares.contains(x)))///         .count(),///     squares.len(),/// assert!(heap.is_empty());/// assert!(heap.capacity() >= squares.len());/// `ParallelDrainFull` creates a parallel iterator that moves all items/// from a collection while retaining the original capacity./// Types which are indexable typically implement [`ParallelDrainRange`]/// instead, where you can drain fully with `par_drain(..)`./// [`ParallelDrainRange`]: trait.ParallelDrainRange.html/// Returns a draining parallel iterator over a range of the collection./// When the iterator is dropped, all items in the range are removed, even/// if the iterator was not fully consumed. If the iterator is leaked, for/// example using `std::mem::forget`, it is unspecified how many items are/// let squares: Vec<i32> = (0..10).map(|x| x * x).collect();/// println!("RangeFull");/// let mut vec = squares.clone();/// assert!(vec.par_drain(..)///            .eq(squares.par_iter().copied()));/// assert!(vec.is_empty());/// assert!(vec.capacity() >= squares.len());/// println!("RangeFrom");/// assert!(vec.par_drain(5..)///            .eq(squares[5..].par_iter().copied()));/// assert_eq!(&vec[..], &squares[..5]);/// println!("RangeTo");/// assert!(vec.par_drain(..5)///            .eq(squares[..5].par_iter().copied()));/// assert_eq!(&vec[..], &squares[5..]);/// println!("RangeToInclusive");/// assert!(vec.par_drain(..=5)///            .eq(squares[..=5].par_iter().copied()));/// assert_eq!(&vec[..], &squares[6..]);/// println!("Range");/// assert!(vec.par_drain(3..7)///            .eq(squares[3..7].par_iter().copied()));/// assert_eq!(&vec[..3], &squares[..3]);/// assert_eq!(&vec[3..], &squares[7..]);/// println!("RangeInclusive");/// assert!(vec.par_drain(3..=7)///            .eq(squares[3..=7].par_iter().copied()));/// assert_eq!(&vec[3..], &squares[8..]);/// `ParallelDrainRange` creates a parallel iterator that moves a range of items/// Types which are not indexable may implement [`ParallelDrainFull`] instead./// [`ParallelDrainFull`]: trait.ParallelDrainFull.htmlprivate_declr" This trait is private; this method exists to make it"r" impossible to implement outside the crate."__rayon_private__PrivateMarkerResidualfrom_outputfrom_residual/// Clone of `std::ops::Try`./// Implementing this trait is not permitted outside of `rayon`.private_impl/// We hide the `Try` trait in a private module, as it's only meant to be a/// stable clone of the standard library's `Try` trait, as yet unstable.//! Traits for writing parallel programs using an iterator-style interface//! You will rarely need to interact with this module directly unless you have//! need to name one of the iterator types.//! Parallel iterators make it easy to write iterator-like chains that//! execute in parallel: typically all you have to do is convert the//! first `.iter()` (or `iter_mut()`, `into_iter()`, etc) method into//! `par_iter()` (or `par_iter_mut()`, `into_par_iter()`, etc). For//! example, to compute the sum of the squares of a sequence of//! integers, one might write://! use rayon::prelude::*;//! fn sum_of_squares(input: &[i32]) -> i32 {//!     input.par_iter()//!          .map(|i| i * i)//!          .sum()//! Or, to increment all the integers in a slice, you could write://! fn increment_all(input: &mut [i32]) {//!     input.par_iter_mut()//!          .for_each(|p| *p += 1);//! To use parallel iterators, first import the traits by adding//! something like `use rayon::prelude::*` to your module. You can//! then call `par_iter`, `par_iter_mut`, or `into_par_iter` to get a//! parallel iterator. Like a [regular iterator][], parallel//! iterators work by first constructing a computation and then//! executing it.//! In addition to `par_iter()` and friends, some types offer other//! ways to create (or consume) parallel iterators://! - Slices (`&[T]`, `&mut [T]`) offer methods like `par_split` and//!   `par_windows`, as well as various parallel sorting//!   operations. See [the `ParallelSlice` trait] for the full list.//! - Strings (`&str`) offer methods like `par_split` and `par_lines`.//!   See [the `ParallelString` trait] for the full list.//! - Various collections offer [`par_extend`], which grows a//!   collection given a parallel iterator. (If you don't have a//!   collection to extend, you can use [`collect()`] to create a new//!   one from scratch.)//! [the `ParallelSlice` trait]: ../slice/trait.ParallelSlice.html//! [the `ParallelString` trait]: ../str/trait.ParallelString.html//! [`par_extend`]: trait.ParallelExtend.html//! [`collect()`]: trait.ParallelIterator.html#method.collect//! To see the full range of methods available on parallel iterators,//! check out the [`ParallelIterator`] and [`IndexedParallelIterator`]//! If you'd like to build a custom parallel iterator, or to write your own//! combinator, then check out the [split] function and the [plumbing] module.//! [regular iterator]: https://doc.rust-lang.org/std/iter/trait.Iterator.html//! [`ParallelIterator`]: trait.ParallelIterator.html//! [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html//! [split]: fn.split.html//! [plumbing]: plumbing/index.html//! Note: Several of the `ParallelIterator` methods rely on a `Try` trait which//! has been deliberately obscured from the public API.  This trait is intended//! to mirror the unstable `std::ops::Try` with implementations for `Option` and//! `Result`, where `Some`/`Ok` values will let those iterators continue, but//! `None`/`Err` values will exit early.//! A note about object safety: It is currently _not_ possible to wrap//! a `ParallelIterator` (or any trait that depends on it) using a//! `Box<dyn ParallelIterator>` or other kind of dynamic allocation,//! because `ParallelIterator` is **not object-safe**.//! (This keeps the implementation simpler and allows extra optimizations.)// There is a method to the madness here:// - These modules are private but expose certain types to the end-user//   (e.g., `enumerate::Enumerate`) -- specifically, the types that appear in the//   public API surface of the `ParallelIterator` traits.// - In **this** module, those public types are always used unprefixed, which forces//   us to add a `pub use` and helps identify if we missed anything.// - In contrast, items that appear **only** in the body of a method,//   e.g. `find::find()`, are always used **prefixed**, so that they//   can be readily distinguished./// `MultiZip` is an iterator that zips up a tuple of parallel iterators to/// produce tuples of their items./// It is created by calling `into_par_iter()` on a tuple of types that/// implement `IntoParallelIterator`, or `par_iter()`/`par_iter_mut()` with/// types that are iterable by reference./// The implementation currently support tuples up to length 12./// // This will iterate `r` by mutable reference, like `par_iter_mut()`, while/// // ranges are all iterated by value like `into_par_iter()`./// // Note that the zipped iterator is only as long as the shortest input./// let mut r = vec![0; 3];/// (&mut r, 1..10, 10..100, 100..1000).into_par_iter()///     .for_each(|(r, x, y, z)| *r = x * y + z);/// assert_eq!(&r, &[1 * 10 + 100, 2 * 11 + 101, 3 * 12 + 102]);/// For a group that should all be iterated by reference, you can use a tuple reference./// let xs: Vec<_> = (1..10).collect();/// let ys: Vec<_> = (10..100).collect();/// let zs: Vec<_> = (100..1000).collect();/// // Reference each input separately with `IntoParallelIterator`:/// let r1: Vec<_> = (&xs, &ys, &zs).into_par_iter()///     .map(|(x, y, z)| x * y + z)/// // Reference them all together with `IntoParallelRefIterator`:/// let r2: Vec<_> = (xs, ys, zs).par_iter()/// assert_eq!(r1, r2);/// Mutable references to a tuple will work similarly./// let mut xs: Vec<_> = (1..4).collect();/// let mut ys: Vec<_> = (-4..-1).collect();/// let mut zs = vec![0; 3];/// // Mutably reference each input separately with `IntoParallelIterator`:/// (&mut xs, &mut ys, &mut zs).into_par_iter().for_each(|(x, y, z)| {///     *z += *x + *y;///     std::mem::swap(x, y);/// assert_eq!(xs, (vec![-4, -3, -2]));/// assert_eq!(ys, (vec![1, 2, 3]));/// assert_eq!(zs, (vec![-3, -1, 1]));/// // Mutably reference them all together with `IntoParallelRefMutIterator`:/// let mut tuple = (xs, ys, zs);/// tuple.par_iter_mut().for_each(|(x, y, z)| {/// assert_eq!(tuple, (vec![1, 2, 3], vec![-4, -3, -2], vec![-6, -2, 2]));nestmultizip_implsCONSUMER// These macros greedily consume 4 or 2 items first to achieve log2 nesting depth.// For example, 5 => 4,1 => (2,2),1.// The tuples go up to 12, so we might want to greedily consume 8 too, but// the depth works out the same if we let that expand on the right://      9 => 4,5 => (2,2),(4,1) => (2,2),((2,2),1)//     12 => 4,8 => (2,2),(4,4) => (2,2),((2,2),(2,2))// But if we ever increase to 13, we would want to split 8,5 rather than 4,9./// Creates a parallel iterator that produces an element exactly once./// This admits no parallelism on its own, but it could be chained to existing/// parallel iterators to extend their contents, or otherwise used for any code/// that deals with generic parallel iterators./// use rayon::iter::once;///     .chain(once(-1))/// assert_eq!(pi.clone().count(), 10_001);/// assert_eq!(pi.clone().filter(|&x| x < 0).count(), 1);/// assert_eq!(pi.position_any(|x| x < 0), Some(1234));/// Iterator adaptor for [the `once()` function](fn.once.html)./// `PanicFuse` is an adaptor that wraps an iterator with a fuse in case/// of panics, to halt all threads as soon as possible./// This struct is created by the [`panic_fuse()`] method on [`ParallelIterator`]/// [`panic_fuse()`]: trait.ParallelIterator.html#method.panic_fuse/// Helper that sets a bool to `true` if dropped while unwinding./// Creates a new `PanicFuse` iterator.PanicFuseProducerPanicFuseIterPanicFuseConsumerPanicFuseFolderPanicFuseReducer_fusebridge_unindexedcurrent_num_threadscurrent_thread_index/// Creates a bridge from this type to a `ParallelIterator`./// Conversion trait to convert an `Iterator` to a `ParallelIterator`./// This creates a "bridge" from a sequential iterator to a parallel one, by distributing its items/// across the Rayon thread pool. This has the advantage of being able to parallelize just about/// anything, but the resulting `ParallelIterator` can be less efficient than if you started with/// `par_iter` instead. However, it can still be useful for iterators that are difficult to/// parallelize by other means, like channels or file or network I/O./// Iterator items are pulled by `next()` one at a time, synchronized from each thread that is/// ready for work, so this may become a bottleneck if the serial iterator can't keep up with the/// parallel demand. The items are not buffered by `IterBridge`, so it's fine to use this with/// large or even unbounded iterators./// The resulting iterator is not guaranteed to keep the order of the original iterator./// To use this trait, take an existing `Iterator` and call `par_bridge` on it. After that, you can/// use any of the `ParallelIterator` methods:/// use rayon::iter::ParallelBridge;/// use rayon::prelude::ParallelIterator;/// let rx = {///     let (tx, rx) = channel();///     tx.send("one!");///     tx.send("two!");///     tx.send("three!");///     rx/// let mut output: Vec<&'static str> = rx.into_iter().par_bridge().collect();/// output.sort_unstable();/// assert_eq!(&*output, &["one!", "three!", "two!"]);/// `IterBridge` is a parallel iterator that wraps a sequential iterator./// This type is created when using the `par_bridge` method on `ParallelBridge`. See the/// [`ParallelBridge`] documentation for details./// [`ParallelBridge`]: trait.ParallelBridge.htmlsplit_countthreads_startedIterParallelProducerjoin_context/// The type of value returned by this callback. Analogous to/// [`Output` from the `FnOnce` trait][Output]./// [Output]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html#associatedtype.Output/// Invokes the callback with the given producer as argument. The/// key point of this trait is that this method is generic over/// `P`, and hence implementors must be defined for any producer./// The `ProducerCallback` trait is a kind of generic closure,/// [analogous to `FnOnce`][FnOnce]. See [the corresponding section in/// the plumbing README][r] for more details./// [r]: https://github.com/rayon-rs/rayon/blob/main/src/iter/plumbing/README.md#producer-callback/// [FnOnce]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html/// The type of item that will be produced by this producer once/// it is converted into an iterator./// The type of iterator we will become./// Convert `self` into an iterator; at this point, no more parallel splits/// are possible./// The minimum number of items that we will process/// sequentially. Defaults to 1, which means that we will split/// all the way down to a single item. This can be raised higher/// using the [`with_min_len`] method, which will force us to/// create sequential tasks at a larger granularity. Note that/// Rayon automatically normally attempts to adjust the size of/// parallel splits to reduce overhead, so this should not be/// [`with_min_len`]: ../trait.IndexedParallelIterator.html#method.with_min_len/// The maximum number of items that we will process/// sequentially. Defaults to MAX, which means that we can choose/// not to split at all. This can be lowered using the/// [`with_max_len`] method, which will force us to create more/// parallel tasks. Note that Rayon automatically normally/// attempts to adjust the size of parallel splits to reduce/// overhead, so this should not be needed./// [`with_max_len`]: ../trait.IndexedParallelIterator.html#method.with_max_len/// Split into two producers; one produces items `0..index`, the/// other `index..N`. Index must be less than or equal to `N`./// Iterate the producer, feeding each element to `folder`, and/// stop when the folder is full (or all elements have been consumed)./// The provided implementation is sufficient for most iterables./// A `Producer` is effectively a "splittable `IntoIterator`". That/// is, a producer is a value which can be converted into an iterator/// at any time: at that point, it simply produces items on demand,/// like any iterator. But what makes a `Producer` special is that,/// *before* we convert to an iterator, we can also **split** it at a/// particular point using the `split_at` method. This will yield up/// two producers, one producing the items before that point, and one/// producing the items after that point (these two producers can then/// independently be split further, or be converted into iterators)./// In Rayon, this splitting is used to divide between threads./// See [the `plumbing` README][r] for further details./// Note that each producer will always produce a fixed number of/// items N. However, this number N is not queryable through the API;/// the consumer is expected to track it./// NB. You might expect `Producer` to extend the `IntoIterator`/// trait.  However, [rust-lang/rust#20671][20671] prevents us from/// declaring the DoubleEndedIterator and ExactSizeIterator/// constraints on a required IntoIterator trait, so we inline/// IntoIterator here until that issue is fixed./// [r]: https://github.com/rayon-rs/rayon/blob/main/src/iter/plumbing/README.md/// [20671]: https://github.com/rust-lang/rust/issues/20671/// The type of folder that this consumer can be converted into./// The type of reducer that is produced if this consumer is split./// The type of result that this consumer will ultimately produce./// Divide the consumer into two consumers, one processing items/// `0..index` and one processing items from `index..`. Also/// produces a reducer that can be used to reduce the results at/// the end./// Convert the consumer into a folder that can consume items/// sequentially, eventually producing a final result./// Hint whether this `Consumer` would like to stop processing/// further items, e.g. if a search has been completed./// A consumer is effectively a [generalized "fold" operation][fold],/// and in fact each consumer will eventually be converted into a/// [`Folder`]. What makes a consumer special is that, like a/// [`Producer`], it can be **split** into multiple consumers using/// the `split_at` method. When a consumer is split, it produces two/// consumers, as well as a **reducer**. The two consumers can be fed/// items independently, and when they are done the reducer is used to/// combine their two results into one. See [the `plumbing`/// README][r] for further details./// [fold]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.fold/// [`Folder`]: trait.Folder.html/// [`Producer`]: trait.Producer.html/// The type of result that will ultimately be produced by the folder./// Consume next item and return new sequential state./// Consume items from the iterator until full, and return new sequential state./// This method is **optional**. The default simply iterates over/// `iter`, invoking `consume` and checking after each iteration/// whether `full` returns false./// The main reason to override it is if you can provide a more/// specialized, efficient implementation./// Finish consuming items, produce final result./// Hint whether this `Folder` would like to stop processing/// The `Folder` trait encapsulates [the standard fold/// operation][fold].  It can be fed many items using the `consume`/// method. At the end, once all items have been consumed, it can then/// be converted (using `complete`) into a final value./// Reduce two final results into one; this is executed after a/// split./// The reducer is the final step of a `Consumer` -- after a consumer/// has been split into two parts, and each of those parts has been/// fully processed, we are left with two results. The reducer is then/// used to combine those two results into one. See [the `plumbing`/// Splits off a "left" consumer and returns it. The `self`/// consumer should then be used to consume the "right" portion of/// the data. (The ordering matters for methods like find_first --/// values produced by the returned value are given precedence/// over values produced by `self`.) Once the left and right/// halves have been fully consumed, you should reduce the results/// with the result of `to_reducer`./// Creates a reducer that can be used to combine the results from/// a split consumer./// A stateless consumer can be freely copied. These consumers can be/// used like regular consumers, but they also support a/// `split_off_left` method that does not take an index to split, but/// simply splits at some arbitrary point (`for_each`, for example,/// produces an unindexed consumer)./// The type of item returned by this producer./// Split midway into a new producer if possible, otherwise return `None`./// A variant on `Producer` which does not know its exact length or/// cannot represent it in a `usize`. These producers act like/// ordinary producers except that they cannot be told to split at a/// particular point. Instead, you just ask them to split 'somewhere'./// (In principle, `Producer` could extend this trait; however, it/// does not because to do so would require producers to carry their/// own length with them.)splits/// The `splits` tell us approximately how many remaining times we'd/// like to split this job.  We always just divide it by two though, so/// the effective number of pieces will be `next_power_of_two()`./// A splitter controls the policy for splitting into smaller work items./// Thief-splitting is an adaptive policy that starts by splitting into/// enough jobs for every worker thread, and then resets itself whenever a/// job is actually stolen into a different thread.try_split/// The smallest we're willing to divide into.  Usually this is just 1,/// but you can choose a larger working size with `with_min_len()`.LengthSplitter/// The length splitter is built on thief-splitting, but additionally takes/// into account the remaining length of the iterator./// Creates a new splitter based on lengths./// The `min` is a hard lower bound.  We'll never split below that, but/// of course an iterator might start out smaller already./// The `max` is an upper bound on the working size, used to determine/// the minimum number of times we need to split to get under that limit./// The adaptive algorithm may very well split even further, but never/// smaller than the `min`.bridge/// This helper function is used to "connect" a parallel iterator to a/// consumer. It will convert the `par_iter` into a producer P and/// then pull items from P and feed them to `consumer`, splitting and/// creating parallel threads as needed./// This is useful when you are implementing your own parallel/// iterators: it is often used as the definition of the/// [`drive_unindexed`] or [`drive`] methods./// [`drive_unindexed`]: ../trait.ParallelIterator.html#tymethod.drive_unindexed/// [`drive`]: ../trait.IndexedParallelIterator.html#tymethod.drivebridge_producer_consumer/// This helper function is used to "connect" a producer and a/// consumer. You may prefer to call [`bridge`], which wraps this/// function. This function will draw items from `producer` and feed/// them to `consumer`, splitting and creating parallel tasks when/// [`bridge`]: fn.bridge.html/// A variant of [`bridge_producer_consumer`] where the producer is an unindexed producer./// [`bridge_producer_consumer`]: fn.bridge_producer_consumer.htmlbridge_unindexed_producer_consumer//! Traits and functions used to implement parallel iteration.  These are//! low-level details -- users of parallel iterators should not need to//! interact with them directly.  See [the `plumbing` README][r] for a general overview.//! [r]: https://github.com/rayon-rs/rayon/blob/main/src/iter/plumbing/README.md/// `Positions` takes a predicate `predicate` and filters out elements that match,/// yielding their indices./// This struct is created by the [`positions()`] method on [`IndexedParallelIterator`]/// [`positions()`]: trait.IndexedParallelIterator.html#method.positionsPositionsConsumerPositionsFolderProductConsumerProductFolderreduce_opReduceConsumerReduceFolder/// Iterator adaptor for [the `repeat()` function](fn.repeat.html)./// Creates a parallel iterator that endlessly repeats `elt` (by/// cloning it). Note that this iterator has "infinite" length, so/// typically you would want to use `zip` or `take` or some other/// means to shorten it, or consider using/// [the `repeatn()` function](fn.repeatn.html) instead./// use rayon::iter::repeat;/// let x: Vec<(i32, i32)> = repeat(22).zip(0..3).collect();/// assert_eq!(x, vec![(22, 0), (22, 1), (22, 2)]);/// Takes only `n` repeats of the element, similar to the general/// [`take()`](trait.IndexedParallelIterator.html#method.take)./// The resulting `RepeatN` is an `IndexedParallelIterator`, allowing/// more functionality than `Repeat` alone./// Iterates tuples, repeating the element with items from another/// iterator, similar to the general/// [`zip()`](trait.IndexedParallelIterator.html#method.zip).RepeatProducer/// Unindexed producer for `Repeat`./// Iterator adaptor for [the `repeatn()` function](fn.repeatn.html)./// Creates a parallel iterator that produces `n` repeats of `elt`/// (by cloning it)./// use rayon::iter::repeatn;/// let x: Vec<(i32, i32)> = repeatn(22, 3).zip(0..3).collect();RepeatNProducer/// Producer for `RepeatN`./// Iterator for `RepeatN`./// This is conceptually like `std::iter::Take<std::iter::Repeat<T>>`, but/// we need `DoubleEndedIterator` and unconditional `ExactSizeIterator`./// `Rev` is an iterator that produces elements in reverse order. This struct/// is created by the [`rev()`] method on [`IndexedParallelIterator`]/// [`rev()`]: trait.IndexedParallelIterator.html#method.rev/// Creates a new `Rev` iterator.RevProducer/// `Skip` is an iterator that skips over the first `n` elements./// This struct is created by the [`skip()`] method on [`IndexedParallelIterator`]/// [`skip()`]: trait.IndexedParallelIterator.html#method.skip/// Creates a new `Skip` iterator./// `SkipAny` is an iterator that skips over `n` elements from anywhere in `I`./// This struct is created by the [`skip_any()`] method on [`ParallelIterator`]/// [`skip_any()`]: trait.ParallelIterator.html#method.skip_any/// Creates a new `SkipAny` iterator.SkipAnyConsumerSkipAnyFolderchecked_decrement/// `SkipAnyWhile` is an iterator that skips over elements from anywhere in `I`/// until the callback returns `false`./// This struct is created by the [`skip_any_while()`] method on [`ParallelIterator`]/// [`skip_any_while()`]: trait.ParallelIterator.html#method.skip_any_while/// Creates a new `SkipAnyWhile` iterator.skippingSkipAnyWhileConsumerSkipAnyWhileFolder/// The `split` function takes arbitrary data and a closure that knows how to/// split it, and turns this into a `ParallelIterator`./// As a simple example, Rayon can recursively split ranges of indices/// use rayon::iter;/// // We define a range of indices as follows/// type Range1D = Range<usize>;/// // Splitting it in two can be done like this/// fn split_range1(r: Range1D) -> (Range1D, Option<Range1D>) {///     // We are mathematically unable to split the range if there is only///     // one point inside of it, but we could stop splitting before that.///     if r.end - r.start <= 1 { return (r, None); }///     // Here, our range is considered large enough to be splittable///     let midpoint = r.start + (r.end - r.start) / 2;///     (r.start..midpoint, Some(midpoint..r.end))/// // By using iter::split, Rayon will split the range until it has enough work/// // to feed the CPU cores, then give us the resulting sub-ranges/// iter::split(0..4096, split_range1).for_each(|sub_range| {///     // As our initial range had a power-of-two size, the final sub-ranges///     // should have power-of-two sizes too///     assert!((sub_range.end - sub_range.start).is_power_of_two());/// This recursive splitting can be extended to two or three dimensions,/// to reproduce a classic "block-wise" parallelization scheme of graphics and/// numerical simulations:/// # use rayon::iter;/// # use rayon::prelude::*;/// # use std::ops::Range;/// # type Range1D = Range<usize>;/// # fn split_range1(r: Range1D) -> (Range1D, Option<Range1D>) {/// #     if r.end - r.start <= 1 { return (r, None); }/// #     let midpoint = r.start + (r.end - r.start) / 2;/// #     (r.start..midpoint, Some(midpoint..r.end))/// // A two-dimensional range of indices can be built out of two 1D ones/// struct Range2D {///     // Range of horizontal indices///     pub rx: Range1D,///     // Range of vertical indices///     pub ry: Range1D,/// // We want to recursively split them by the largest dimension until we have/// // enough sub-ranges to feed our mighty multi-core CPU. This function/// // carries out one such split./// fn split_range2(r2: Range2D) -> (Range2D, Option<Range2D>) {///     // Decide on which axis (horizontal/vertical) the range should be split///     let width = r2.rx.end - r2.rx.start;///     let height = r2.ry.end - r2.ry.start;///     if width >= height {///         // This is a wide range, split it on the horizontal axis///         let (split_rx, ry) = (split_range1(r2.rx), r2.ry);///         let out1 = Range2D {///             rx: split_rx.0,///             ry: ry.clone(),///         let out2 = split_rx.1.map(|rx| Range2D { rx, ry });///         (out1, out2)///         // This is a tall range, split it on the vertical axis///         let (rx, split_ry) = (r2.rx, split_range1(r2.ry));///             rx: rx.clone(),///             ry: split_ry.0,///         let out2 = split_ry.1.map(|ry| Range2D { rx, ry, });/// // Again, rayon can handle the recursive splitting for us/// let range = Range2D { rx: 0..800, ry: 0..600 };/// iter::split(range, split_range2).for_each(|sub_range| {///     // If the sub-ranges were indeed split by the largest dimension, then///     // if no dimension was twice larger than the other initially, this///     // property will remain true in the final sub-ranges.///     let width = sub_range.rx.end - sub_range.rx.start;///     let height = sub_range.ry.end - sub_range.ry.start;///     assert!((width / 2 <= height) && (height / 2 <= width));/// `Split` is a parallel iterator using arbitrary data and a splitting function./// This struct is created by the [`split()`] function./// [`split()`]: fn.split.htmlSplitProducer/// `StepBy` is an iterator that skips `n` elements between each yield, where `n` is the given step./// This struct is created by the [`step_by()`] method on [`IndexedParallelIterator`]/// [`step_by()`]: trait.IndexedParallelIterator.html#method.step_by/// Creates a new `StepBy` iterator.StepByProducerSumConsumerSumFolder/// `Take` is an iterator that iterates over the first `n` elements./// This struct is created by the [`take()`] method on [`IndexedParallelIterator`]/// [`take()`]: trait.IndexedParallelIterator.html#method.take/// Creates a new `Take` iterator./// `TakeAny` is an iterator that iterates over `n` elements from anywhere in `I`./// This struct is created by the [`take_any()`] method on [`ParallelIterator`]/// [`take_any()`]: trait.ParallelIterator.html#method.take_any/// Creates a new `TakeAny` iterator.TakeAnyConsumerTakeAnyFolder/// `TakeAnyWhile` is an iterator that iterates over elements from anywhere in `I`/// This struct is created by the [`take_any_while()`] method on [`ParallelIterator`]/// [`take_any_while()`]: trait.ParallelIterator.html#method.take_any_while/// Creates a new `TakeAnyWhile` iterator.takingTakeAnyWhileConsumerTakeAnyWhileFolderis_indexedexecute_clonedexecute_rangeexecute_unindexed_rangeexecute_pseudo_indexed_rangecheck_map_indexedmap_summap_reducemap_reduce_withfold_map_reducefold_is_fullcheck_step_bycheck_step_by_unalignedcheck_step_by_revcheck_enumeratecheck_enumerate_revcheck_indices_after_enumerate_splitcheck_incrementcheck_skipcheck_takecheck_inspectcheck_movecheck_dropscheck_slice_indexedcheck_slice_mut_indexedcheck_vec_indexedcheck_range_indexedcheck_cmp_directcheck_cmp_to_seqcheck_cmp_rng_to_seqcheck_cmp_lt_directcheck_cmp_lt_to_seqcheck_cmp_gt_directcheck_cmp_gt_to_seqcheck_cmp_short_circuitcheck_partial_cmp_short_circuitcheck_partial_cmp_nan_short_circuitcheck_partial_cmp_directcheck_partial_cmp_to_seqcheck_partial_cmp_rng_to_seqcheck_partial_cmp_lt_directcheck_partial_cmp_lt_to_seqcheck_partial_cmp_gt_directcheck_partial_cmp_gt_to_seqcheck_partial_cmp_none_directcheck_partial_cmp_none_to_seqcheck_partial_cmp_late_nan_directcheck_partial_cmp_late_nan_to_seqcheck_cmp_lengthscheck_eq_directcheck_eq_to_seqcheck_ne_directcheck_ne_to_seqcheck_ne_lengthscheck_lt_directcheck_lt_to_seqcheck_le_equal_directcheck_le_equal_to_seqcheck_le_less_directcheck_le_less_to_seqcheck_gt_directcheck_gt_to_seqcheck_ge_equal_directcheck_ge_equal_to_seqcheck_ge_greater_directcheck_ge_greater_to_seqcheck_zipcheck_zip_into_par_itercheck_zip_into_mut_par_itercheck_zip_rangecheck_zip_eqcheck_zip_eq_into_par_itercheck_zip_eq_into_mut_par_itercheck_zip_eq_rangecheck_sum_filtered_intscheck_sum_filtermap_intscheck_flat_map_nested_rangescheck_empty_flat_map_sumcheck_flatten_veccheck_flatten_vec_emptycheck_slice_splitcheck_slice_split_inclusivecheck_slice_split_mutcheck_slice_split_inclusive_mutcheck_chunkscheck_chunks_mutcheck_windowscheck_optionscheck_resultscheck_binary_heapcheck_btree_mapcheck_btree_setcheck_hash_mapcheck_hash_setcheck_linked_listcheck_vec_dequecheck_chaincheck_countfind_first_or_lastfind_map_first_or_last_or_anycheck_find_not_presentcheck_find_is_presentcheck_while_somepar_iter_collect_optionpar_iter_collect_resultpar_iter_collectpar_iter_collect_vecdequepar_iter_collect_binaryheappar_iter_collect_hashmappar_iter_collect_hashsetpar_iter_collect_btreemappar_iter_collect_btreesetpar_iter_collect_linked_listpar_iter_collect_linked_list_flat_map_filterpar_iter_collect_cowspar_iter_unindexed_flat_mapmin_max_bymin_max_by_keycheck_revscope_mixdivide_and_conquercheck_splitcheck_lengthscheck_map_withcheck_fold_withcheck_for_each_withcheck_extend_itemscheck_extend_heapcheck_extend_pairscheck_unzip_into_vecscheck_unzipcheck_partitioncheck_partition_mapcheck_eithercheck_either_extendcheck_interleave_eqcheck_interleave_unevencheck_interleave_shortestcheck_chunks_zero_sizecheck_chunks_even_sizecheck_chunks_emptycheck_chunks_lencheck_chunks_unevencheck_repeat_find_anycheck_repeat_takecheck_repeat_zipcheck_repeatn_zip_leftcheck_repeatn_zip_rightcheck_emptycheck_oncecheck_updatewalk_flat_tree_prefixwalk_flat_tree_postfixwalk_tree_prefix_degree5walk_tree_postfix_degree5/// `TryFold` is an iterator that applies a function over an iterator producing a single value./// This struct is created by the [`try_fold()`] method on [`ParallelIterator`]/// [`try_fold()`]: trait.ParallelIterator.html#method.try_foldTryFoldConsumerTryFoldFolder/// `TryFoldWith` is an iterator that applies a function over an iterator producing a single value./// This struct is created by the [`try_fold_with()`] method on [`ParallelIterator`]/// [`try_fold_with()`]: trait.ParallelIterator.html#method.try_fold_withTryFoldWithConsumerTryReduceConsumerTryReduceFolderTryReduceWithConsumerTryReduceWithFolderopt_control/// The type of item expected by the left consumer./// The type of item expected by the right consumer./// Consumes one item and feeds it to one or both of the underlying folders.indexable/// Reports whether this op may support indexed consumers./// - e.g. true for `unzip` where the item count passed through directly./// - e.g. false for `partition` where the sorting is not yet known.UnzipOp/// This trait abstracts the different ways we can "unzip" one parallel/// iterator into two distinct consumers, which we can handle almost/// identically apart from how to process the individual items./// Runs an unzip-like operation into default `ParallelExtend` collections.execute_into/// Runs an unzip-like operation into `ParallelExtend` collections./// This is called by `ParallelIterator::unzip`.CA/// Unzips an `IndexedParallelIterator` into two arbitrary `Consumer`s./// This is called by `super::collect::unzip_into_vecs`./// An `UnzipOp` that splits a tuple directly into the two consumers./// This is called by `ParallelIterator::partition`.Partition/// An `UnzipOp` that routes items depending on a predicate function./// arbitrary `ParallelExtend` containers./// This called by `ParallelIterator::partition_map`.PartitionMap/// An `UnzipOp` that routes items depending on how they are mapped `Either`.UnzipA/// A fake iterator to intercept the `Consumer` for type `A`.left_consumerleft_resultUnzipB/// A fake iterator to intercept the `Consumer` for type `B`.UnzipConsumer/// `Consumer` that unzips into two other `Consumer`sUnzipFolderUnzipReducer/// `Folder` that unzips into two other `Folder`sRB/// `Reducer` that unzips into two other `Reducer`sUnEither/// An `UnzipOp` that routes items depending on their `Either` variant.FLFRFromT/// Shim to implement a one-time `ParallelExtend` using `FromParallelIterator`.update_op/// `Update` is an iterator that mutates the elements of an/// underlying iterator before they are yielded./// This struct is created by the [`update()`] method on [`ParallelIterator`]/// [`update()`]: trait.ParallelIterator.html#method.update/// Creates a new `Update` iterator.UpdateProducerUpdateSeqUpdateConsumerUpdateFolder/// Standard Update adaptor, based on `itertools::adaptors::Update`to_explore// nodes (and subtrees) we have to processchildren_of// nodes which have already been explored// function generating childrenWalkTreePrefixProducer/// ParallelIterator for arbitrary tree-shaped patterns./// Returned by the [`walk_tree_prefix()`] function./// Create a tree-like prefix parallel iterator from an initial root node./// The `children_of` function should take a node and return an iterator over its child nodes./// The best parallelization is obtained when the tree is balanced/// but we should also be able to handle harder cases./// # Ordering/// This function guarantees a prefix ordering. See also [`walk_tree_postfix`],/// which guarantees a postfix order./// If you don't care about ordering, you should use [`walk_tree`],/// which will use whatever is believed to be fastest./// For example a perfect binary tree of 7 nodes will reduced in the following order:///      a///     / \///    /   \///   b     c///  / \   / \/// d   e f   g/// reduced as a,b,d,e,c,f,g///      4///   2     3///        / \///       1   2/// use rayon::iter::walk_tree_prefix;/// let par_iter = walk_tree_prefix(4, |&e| {///     if e <= 2 {///         Vec::new()///         vec![e / 2, e / 2 + 1]/// assert_eq!(par_iter.sum::<u32>(), 12);/// struct Node {///     content: u32,///     left: Option<Box<Node>>,///     right: Option<Box<Node>>,/// // Here we loop on the following tree:/// //       10/// //      /  \/// //     /    \/// //    3     14/// //            \/// //             \/// //              18/// let root = Node {///     content: 10,///     left: Some(Box::new(Node {///         content: 3,///         left: None,///         right: None,///     })),///     right: Some(Box::new(Node {///         content: 14,///         right: Some(Box::new(Node {///             content: 18,///             left: None,///             right: None,///         })),/// let mut v: Vec<u32> = walk_tree_prefix(&root, |r| {///     r.left///         .as_ref()///         .into_iter()///         .chain(r.right.as_ref())///         .map(|n| &**n)/// .map(|node| node.content)/// .collect();/// assert_eq!(v, vec![10, 3, 14, 18]);WalkTreePostfixProducerconsume_rec_postfix/// Returned by the [`walk_tree_postfix()`] function.split_vec/// Divide given vector in two equally sized vectors./// Return `None` if initial size is <=1./// We return the first half and keep the last half in `v`./// Create a tree like postfix parallel iterator from an initial root node./// The `children_of` function should take a node and iterate on all of its child nodes./// This function guarantees a postfix ordering. See also [`walk_tree_prefix`] which guarantees a/// prefix order. If you don't care about ordering, you should use [`walk_tree`], which will use/// whatever is believed to be fastest./// Between siblings, children are reduced in order -- that is first children are reduced first./// reduced as d,e,b,f,g,c,a/// use rayon::iter::walk_tree_postfix;/// let par_iter = walk_tree_postfix(4, |&e| {/// let mut v: Vec<u32> = walk_tree_postfix(&root, |r| {/// assert_eq!(v, vec![3, 18, 14, 10]);/// Returned by the [`walk_tree()`] function./// Create a tree like parallel iterator from an initial root node./// This function does not guarantee any ordering but will/// use whatever algorithm is thought to achieve the fastest traversal./// See also [`walk_tree_prefix`] which guarantees a/// prefix order and [`walk_tree_postfix`] which guarantees a postfix order./// use rayon::iter::walk_tree;/// let par_iter = walk_tree(4, |&e| {// post fix/// `WhileSome` is an iterator that yields the `Some` elements of an iterator,/// halting as soon as any `None` is produced./// This struct is created by the [`while_some()`] method on [`ParallelIterator`]/// [`while_some()`]: trait.ParallelIterator.html#method.while_some/// Creates a new `WhileSome` iterator.WhileSomeConsumerWhileSomeFolder/// `Zip` is an iterator that zips up `a` and `b` into a single iterator/// of pairs. This struct is created by the [`zip()`] method on/// [`IndexedParallelIterator`]/// [`zip()`]: trait.IndexedParallelIterator.html#method.zip/// Creates a new `Zip` iterator.ZipProducer/// An [`IndexedParallelIterator`] that iterates over two parallel iterators of equal/// length simultaneously./// This struct is created by the [`zip_eq`] method on [`IndexedParallelIterator`],/// see its documentation for more information./// [`zip_eq`]: trait.IndexedParallelIterator.html#method.zip_eq/// Creates a new `ZipEq` iterator.split_producerrange_inclusivepar_eithercompile_failFnContextspawn_broadcastBroadcastContextmax_num_threadsin_place_scopein_place_scope_fifoscope_fifoScopeFifospawn_fifoyield_localYield/// We need to transmit raw pointers across threads. It is possible to do this/// without any unsafe code by converting pointers to usize or to AtomicPtr<T>/// then back to a raw pointer for use. We prefer this approach because code/// that uses this type is more explicit./// Unsafe code is still required to dereference the pointer, so this type is/// not unsound on its own, although it does partly lift the unconditional/// !Send and !Sync on raw pointers. As always, dereference with care.// SAFETY: !Send for raw pointers is not for safety, just as a lint// SAFETY: !Sync for raw pointers is not for safety, just as a lint// Helper to avoid disjoint captures of `send_ptr.0`// Implement Clone without the T: Clone bound from the derive// Implement Copy without the T: Copy bound from the derive//! Rayon is a data-parallelism library that makes it easy to convert sequential//! computations into parallel.//! It is lightweight and convenient for introducing parallelism into existing//! code. It guarantees data-race free executions and takes advantage of//! parallelism when sensible, based on work-load at runtime.//! # How to use Rayon//! There are two ways to use Rayon://! - **High-level parallel constructs** are the simplest way to use Rayon and also//!   typically the most efficient.//!   - [Parallel iterators][iter module] make it easy to convert a sequential iterator to//!     execute in parallel.//!     - The [`ParallelIterator`] trait defines general methods for all parallel iterators.//!     - The [`IndexedParallelIterator`] trait adds methods for iterators that support random//!       access.//!   - The [`par_sort`] method sorts `&mut [T]` slices (or vectors) in parallel.//!   - [`par_extend`] can be used to efficiently grow collections with items produced//!     by a parallel iterator.//! - **Custom tasks** let you divide your work into parallel tasks yourself.//!   - [`join`] is used to subdivide a task into two pieces.//!   - [`scope`] creates a scope within which you can create any number of parallel tasks.//!   - [`ThreadPoolBuilder`] can be used to create your own thread pools or customize//!     the global one.//! [iter module]: iter/index.html//! [`join`]: fn.join.html//! [`scope`]: fn.scope.html//! [`par_sort`]: slice/trait.ParallelSliceMut.html#method.par_sort//! [`par_extend`]: iter/trait.ParallelExtend.html#tymethod.par_extend//! [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html//! # Basic usage and the Rayon prelude//! First, you will need to add `rayon` to your `Cargo.toml`.//! Next, to use parallel iterators or the other high-level methods,//! you need to import several traits. Those traits are bundled into//! the module [`rayon::prelude`]. It is recommended that you import//! all of these traits at once by adding `use rayon::prelude::*` at//! the top of each module that uses Rayon methods.//! These traits give you access to the `par_iter` method which provides//! parallel implementations of many iterative functions such as [`map`],//! [`for_each`], [`filter`], [`fold`], and [more].//! [`rayon::prelude`]: prelude/index.html//! [`map`]: iter/trait.ParallelIterator.html#method.map//! [`for_each`]: iter/trait.ParallelIterator.html#method.for_each//! [`filter`]: iter/trait.ParallelIterator.html#method.filter//! [`fold`]: iter/trait.ParallelIterator.html#method.fold//! [more]: iter/trait.ParallelIterator.html#provided-methods//! [`ParallelIterator`]: iter/trait.ParallelIterator.html//! [`IndexedParallelIterator`]: iter/trait.IndexedParallelIterator.html//! # Crate Layout//! Rayon extends many of the types found in the standard library with//! parallel iterator implementations. The modules in the `rayon`//! crate mirror [`std`] itself: so, e.g., the `option` module in//! Rayon contains parallel iterators for the `Option` type, which is//! found in [the `option` module of `std`]. Similarly, the//! `collections` module in Rayon offers parallel iterator types for//! [the `collections` from `std`]. You will rarely need to access//! these submodules unless you need to name iterator types//! explicitly.//! [the `option` module of `std`]: https://doc.rust-lang.org/std/option/index.html//! [the `collections` from `std`]: https://doc.rust-lang.org/std/collections/index.html//! # Targets without threading//! Rayon has limited support for targets without `std` threading implementations.//! See the [`rayon_core`] documentation for more information about its global fallback.//! # Other questions?//! See [the Rayon FAQ][faq].//! [faq]: https://github.com/rayon-rs/rayon/blob/main/FAQ.md/// Divide `n` by `divisor`, and round up to the nearest integer/// if not evenly divisible./// Normalize arbitrary `RangeBounds` to a `Range`check_div_round_up/// A parallel iterator over the value in [`Some`] variant of an [`Option`]./// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none./// This `struct` is created by the [`into_par_iter`] function./// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some/// [`into_par_iter`]: ../iter/trait.IntoParallelIterator.html#tymethod.into_par_iter/// A parallel iterator over a reference to the [`Some`] variant of an [`Option`]./// This `struct` is created by the [`par_iter`] function./// [`par_iter`]: ../iter/trait.IntoParallelRefIterator.html#tymethod.par_iter/// A parallel iterator over a mutable reference to the [`Some`] variant of an [`Option`]./// This `struct` is created by the [`par_iter_mut`] function./// [`par_iter_mut`]: ../iter/trait.IntoParallelRefMutIterator.html#tymethod.par_iter_mutOptionProducer/// Private producer for an option/// Collect an arbitrary `Option`-wrapped collection./// If any item is `None`, then all previous items collected are discarded,/// and it returns only `None`.//! Parallel iterator types for [options][std::option]//! [std::option]: https://doc.rust-lang.org/stable/std/option//// `Either<L, R>` is a parallel iterator if both `L` and `R` are parallel iterators./// `Either<L, R>` can be extended if both `L` and `R` are parallel extendable.ParallelString//! The rayon prelude imports the various `ParallelIterator` traits.//! The intention is that one can include `use rayon::prelude::*` and//! have easy access to the various traits and methods you will need./// If this type is pub but not publicly reachable, third parties/// can't name it and can't implement traits using it.//! The public parts of this private module are used to create traits//! that cannot be implemented outside of our own crate.  This way we//! can feel free to extend those traits without worrying about it//! being a breaking change for other implementations./// Parallel iterator over a range, implemented for all integer types and `char`./// **Note:** The `zip` operation requires `IndexedParallelIterator`/// which is not implemented for `u64`, `i64`, `u128`, or `i128`./// let p = (0..25usize).into_par_iter()///                   .zip(0..25usize)///                   .filter(|&(x, y)| x % 5 == 0 || y % 5 == 0)///                   .map(|(x, y)| x * y)///                   .sum::<usize>();/// let s = (0..25usize).zip(0..25)///                   .sum();/// assert_eq!(p, s);/// Implemented for ranges of all primitive integer types and `char`.IterProducerRangeInteger/// Implementation details of `ParallelIterator for Iter<Self>`IndexedRangeInteger/// Implementation details of `IndexedParallelIterator for Iter<Self>`/// These traits help drive integer type inference. Without them, an unknown `{integer}` type only/// has constraints on `Iter<{integer}>`, which will probably give up and use `i32`. By adding/// these traits on the item type, the compiler can see a more direct constraint to infer like/// `{integer}: RangeInteger`, which works better. See `test_issue_833` for an example./// They have to be `pub` since they're seen in the public `impl ParallelIterator` constraints, but/// we put them in a private modules so they're not actually reachable in our public API.indexed_range_implUnindexedRangeLenunindexed_range_impl// all Range<T> with ExactSizeIterator// other Range<T> with just Iteratorconvert_char// char is special because of the surrogate range hole// Split at the surrogate range first if we're allowed tocheck_range_split_at_overflowtest_i128_len_doesnt_overflowtest_u64_opt_lentest_u128_opt_lentest_usize_i64_overflow// `usize as i64` can overflow, so make sure to wrap it appropriately// when using the `opt_len` "indexed" mode.test_issue_833//! Parallel iterator types for [ranges][std::range],//! the type for values created by `a..b` expressions//! let r = (0..100u64).into_par_iter()//!                    .sum();//! // compare result with sequential calculation//! assert_eq!((0..100).sum::<u64>(), r);//! [std::range]: https://doc.rust-lang.org/core/ops/struct.Range.html/// Parallel iterator over an inclusive range, implemented for all integer types and `char`./// which is only implemented for `u8`, `i8`, `u16`, `i16`, and `char`./// let p = (0..=25u16).into_par_iter()///                   .zip(0..=25u16)///                   .sum::<u16>();/// let s = (0..=25u16).zip(0..=25u16)/// Returns `Some((start, end))` for `start..=end`, or `None` if it is exhausted./// Note that `RangeInclusive` does not specify the bounds of an exhausted iterator,/// so this is a way for us to figure out what we've got.  Thankfully, all of the/// integer types we care about can be trivially cloned.parallel_range_impl// all RangeInclusive<T> with ExactSizeIterator// other RangeInclusive<T> with just Iterator// char is special// Range<u32> is broken on 16 bit platforms, may as well benefit from ittest_u32_opt_len//! Parallel iterator types for [inclusive ranges][std::range],//! the type for values created by `a..=b` expressions//! let r = (0..=100u64).into_par_iter()//!                     .sum();//! assert_eq!((0..=100).sum::<u64>(), r);//! [std::range]: https://doc.rust-lang.org/core/ops/struct.RangeInclusive.html/// Parallel iterator over a result/// Parallel iterator over an immutable reference to a result/// Parallel iterator over a mutable reference to a result/// Collect an arbitrary `Result`-wrapped collection./// If any item is `Err`, then all previous `Ok` items collected are/// discarded, and it returns that error.  If there are multiple errors, the/// one returned is not deterministic.//! Parallel iterator types for [results][std::result]//! [std::result]: https://doc.rust-lang.org/stable/std/result/ChunkBySliceChunkByProducer// Note: this implementation is very similar to `SplitProducer`.ChunkBy/// Parallel iterator over slice in (non-overlapping) chunks separated by a predicate./// This struct is created by the [`par_chunk_by`] method on `&[T]`./// [`par_chunk_by`]: trait.ParallelSlice.html#method.par_chunk_byChunkByMut/// Parallel iterator over slice in (non-overlapping) mutable chunks/// separated by a predicate./// This struct is created by the [`par_chunk_by_mut`] method on `&mut [T]`./// [`par_chunk_by_mut`]: trait.ParallelSliceMut.html#method.par_chunk_by_mut/// Parallel iterator over immutable non-overlapping chunks of a sliceChunksProducer/// Return the remainder of the original slice that is not going to be/// returned by the iterator. The returned slice has at most `chunk_size-1`ChunksExactProducer/// Parallel iterator over mutable non-overlapping chunks of a sliceChunksMutProducer/// Note that this has to consume `self` to return the original lifetime of/// the data, which prevents this from actually being used as a parallel/// iterator since that also consumes. This method is provided for parity/// with `std::iter::ChunksExactMut`, but consider calling `remainder()` or/// `take_remainder()` as alternatives./// Consider `take_remainder()` if you need access to the data with its/// original lifetime, rather than borrowing through `&mut self` here./// elements. Subsequent calls will return an empty slice.ChunksExactMutProducerget_and_incrementdecrement_and_getCopyOnDrop/// When dropped, copies from `src` into `dest` a sequence of length `len`.insert_head/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted./// This is the integral subroutine of insertion sort./// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and/// stores the result into `v[..]`./// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.MergesortResultNonDescending/// The slice has already been sorted./// The slice has been descending and therefore it was left intact.Sorted/// The slice was sorted./// The result of merge sort./// A sorted run that starts at index `start` and is of length `len`./// Examines the stack of runs and identifies the next pair of runs to merge. More specifically,/// if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the/// algorithm should continue building a new run instead, `None` is returned./// TimSort is infamous for its buggy implementations, as described here:/// http://envisage-project.eu/timsort-specification-and-verification//// The gist of the story is: we must enforce the invariants on the top four runs on the stack./// Enforcing them on just top three is not sufficient to ensure that the invariants will still/// hold for *all* runs in the stack./// This function correctly checks invariants for the top four runs. Additionally, if the top/// run starts at index 0, it will always demand a merge operation until the stack is fully/// collapsed, in order to complete the sort./// Sorts a slice using merge sort, unless it is already in descending order./// This function doesn't modify the slice if it is already non-descending or descending./// Otherwise, it sorts the slice into non-descending order./// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail/// [here](https://github.com/python/cpython/blob/main/Objects/listsort.txt)./// The algorithm identifies strictly descending and non-descending subsequences, which are called/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are/// satisfied:/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`/// The invariants ensure that the total running time is *O*(*n* \* log(*n*)) worst-case./// The argument `buf` is used as a temporary buffer and must be at least as long as `v`.split_for_merge/// Splits two sorted slices so that they can be merged in parallel./// Returns two indices `(a, b)` so that slices `left[..a]` and `right[..b]` come before/// `left[a..]` and `right[b..]`.par_merge/// Merges slices `left` and `right` in parallel and stores the result into `dest`./// The `dest` pointer must have enough space to store the result./// Even if `is_less` panics at any point during the merge process, this function will fully copy/// all elements from `left` and `right` into `dest` (not necessarily in sorted order)./// Recursively merges pre-sorted chunks inside `v`./// Chunks of `v` are stored in `chunks` as intervals (inclusive left and exclusive right bound)./// Argument `buf` is an auxiliary buffer that will be used during the procedure./// If `into_buf` is true, the result will be stored into `buf`, otherwise it will be in `v`./// The number of chunks must be positive and they must be adjacent: the right bound of each chunk/// must equal the left bound of the following chunk./// The buffer must be at least as long as `v`.par_mergesort/// Sorts `v` using merge sort in parallel./// The algorithm is stable, allocates memory, and `O(n log n)` worst-case./// The allocated temporary buffer is of the same length as is `v`.test_split_for_merge//! Parallel merge sort.//! This implementation is copied verbatim from `std::slice::sort` and then parallelized.//! The only difference from the original is that the sequential `mergesort` returns//! `MergesortResult` and leaves descending arrays intact.////////////////////////////////////////////////////////////////////////////// Everything above this line is copied from `std::slice::sort` (with very minor tweaks).// Everything below this line is parallelization.chunk_byquicksortpar_quicksortas_parallel_slice/// Returns a plain slice, which is used to implement the rest of the/// parallel methods.par_split/// Returns a parallel iterator over subslices separated by elements that/// match the separator./// let products: Vec<_> = [1, 2, 3, 0, 2, 4, 8, 0, 3, 6, 9]///     .par_split(|i| *i == 0)///     .map(|numbers| numbers.iter().product::<i32>())/// assert_eq!(products, [6, 64, 162]);par_split_inclusive/// match the separator, including the matched part as a terminator./// let lengths: Vec<_> = [1, 2, 3, 0, 2, 4, 8, 0, 3, 6, 9]///     .par_split_inclusive(|i| *i == 0)///     .map(|numbers| numbers.len())/// assert_eq!(lengths, [4, 4, 3]);par_windows/// Returns a parallel iterator over all contiguous windows of length/// `window_size`. The windows overlap./// let windows: Vec<_> = [1, 2, 3].par_windows(2).collect();/// assert_eq!(vec![[1, 2], [2, 3]], windows);par_chunks/// Returns a parallel iterator over at most `chunk_size` elements of/// `self` at a time. The chunks do not overlap./// If the number of elements in the iterator is not divisible by/// `chunk_size`, the last chunk may be shorter than `chunk_size`.  All/// other chunks will have that exact length./// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_chunks(2).collect();/// assert_eq!(chunks, vec![&[1, 2][..], &[3, 4], &[5]]);par_chunks_exact/// Returns a parallel iterator over `chunk_size` elements of/// If `chunk_size` does not divide the length of the slice, then the/// last up to `chunk_size-1` elements will be omitted and can be/// retrieved from the remainder function of the iterator./// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_chunks_exact(2).collect();/// assert_eq!(chunks, vec![&[1, 2][..], &[3, 4]]);par_rchunks/// Returns a parallel iterator over at most `chunk_size` elements of `self` at a time,/// starting at the end. The chunks do not overlap./// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_rchunks(2).collect();/// assert_eq!(chunks, vec![&[4, 5][..], &[2, 3], &[1]]);par_rchunks_exact/// Returns a parallel iterator over `chunk_size` elements of `self` at a time,/// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_rchunks_exact(2).collect();/// assert_eq!(chunks, vec![&[4, 5][..], &[2, 3]]);par_chunk_by/// Returns a parallel iterator over the slice producing non-overlapping runs/// of elements using the predicate to separate them./// The predicate is called on two elements following themselves,/// it means the predicate is called on `slice[0]` and `slice[1]`/// then on `slice[1]` and `slice[2]` and so on./// let chunks: Vec<_> = [1, 2, 2, 3, 3, 3].par_chunk_by(|&x, &y| x == y).collect();/// assert_eq!(chunks[0], &[1]);/// assert_eq!(chunks[1], &[2, 2]);/// assert_eq!(chunks[2], &[3, 3, 3]);/// Parallel extensions for slices.as_parallel_slice_mut/// Returns a plain mutable slice, which is used to implement the rest of/// the parallel methods.par_split_mut/// Returns a parallel iterator over mutable subslices separated by/// elements that match the separator./// let mut array = [1, 2, 3, 0, 2, 4, 8, 0, 3, 6, 9];/// array.par_split_mut(|i| *i == 0)///      .for_each(|slice| slice.reverse());/// assert_eq!(array, [3, 2, 1, 0, 8, 4, 2, 0, 9, 6, 3]);par_split_inclusive_mut/// Returns a parallel iterator over mutable subslices separated by elements/// that match the separator, including the matched part as a terminator./// array.par_split_inclusive_mut(|i| *i == 0)/// assert_eq!(array, [0, 3, 2, 1, 0, 8, 4, 2, 9, 6, 3]);par_chunks_mut/// `self` at a time. The chunks are mutable and do not overlap./// let mut array = [1, 2, 3, 4, 5];/// array.par_chunks_mut(2)/// assert_eq!(array, [2, 1, 4, 3, 5]);par_chunks_exact_mut/// array.par_chunks_exact_mut(3)/// assert_eq!(array, [3, 2, 1, 4, 5]);par_rchunks_mut/// starting at the end. The chunks are mutable and do not overlap./// array.par_rchunks_mut(2)/// assert_eq!(array, [1, 3, 2, 5, 4]);par_rchunks_exact_mut/// array.par_rchunks_exact_mut(3)/// assert_eq!(array, [1, 2, 5, 4, 3]);/// Sorts the slice in parallel./// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case./// When applicable, unstable sorting is preferred because it is generally faster than stable/// sorting and it doesn't allocate auxiliary memory./// See [`par_sort_unstable`](#method.par_sort_unstable)./// The current algorithm is an adaptive merge sort inspired by/// [timsort](https://en.wikipedia.org/wiki/Timsort)./// It is designed to be very fast in cases where the slice is nearly sorted, or consists of/// two or more sorted sequences concatenated one after another./// Also, it allocates temporary storage the same size as `self`, but for very short slices a/// non-allocating insertion sort is used instead./// In order to sort the slice in parallel, the slice is first divided into smaller chunks and/// all chunks are sorted in parallel. Then, adjacent chunks that together form non-descending/// or descending runs are concatenated. Finally, the remaining chunks are merged together using/// parallel subdivision of chunks and parallel merge operation./// let mut v = [-5, 4, 1, -3, 2];/// v.par_sort();/// assert_eq!(v, [-5, -3, 1, 2, 4]);/// Sorts the slice in parallel with a comparator function./// The comparator function must define a total ordering for the elements in the slice. If/// the ordering is not total, the order of the elements is unspecified. An order is a/// total order if it is (for all `a`, `b` and `c`):/// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and/// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`./// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use/// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`./// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];/// floats.par_sort_by(|a, b| a.partial_cmp(b).unwrap());/// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);/// See [`par_sort_unstable_by`](#method.par_sort_unstable_by)./// let mut v = [5, 4, 1, 3, 2];/// v.par_sort_by(|a, b| a.cmp(b));/// // reverse sorting/// v.par_sort_by(|a, b| b.cmp(a));/// assert_eq!(v, [5, 4, 3, 2, 1]);par_sort_by_key/// Sorts the slice in parallel with a key extraction function./// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* \* log(*n*))/// worst-case, where the key function is *O*(*m*)./// For expensive key functions (e.g. functions that are not simple property accesses or/// basic operations), [`par_sort_by_cached_key`](#method.par_sort_by_cached_key) is likely to/// be significantly faster, as it does not recompute element keys./// See [`par_sort_unstable_by_key`](#method.par_sort_unstable_by_key)./// let mut v = [-5i32, 4, 1, -3, 2];/// v.par_sort_by_key(|k| k.abs());/// assert_eq!(v, [1, 2, -3, 4, -5]);/// During sorting, the key function is called at most once per element, by using/// temporary storage to remember the results of key evaluation./// The key function is called in parallel, so the order of calls is completely unspecified./// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* + *n* \* log(*n*))/// For simple key functions (e.g., functions that are property accesses or/// basic operations), [`par_sort_by_key`](#method.par_sort_by_key) is likely to be/// faster./// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,/// which combines the fast average case of randomized quicksort with the fast worst case of/// heapsort, while achieving linear time on slices with certain patterns. It uses some/// randomization to avoid degenerate cases, but with a fixed seed to always provide/// deterministic behavior./// In the worst case, the algorithm allocates temporary storage in a `Vec<(K, usize)>` the/// length of the slice./// All quicksorts work in two stages: partitioning into two halves followed by recursive/// calls. The partitioning phase is sequential, but the two recursive calls are performed in/// parallel. Finally, after sorting the cached keys, the item positions are updated sequentially./// [pdqsort]: https://github.com/orlp/pdqsort/// let mut v = [-5i32, 4, 32, -3, 2];/// v.par_sort_by_cached_key(|k| k.to_string());/// assert!(v == [-3, -5, 2, 32, 4]);/// Sorts the slice in parallel, but might not preserve the order of equal elements./// This sort is unstable (i.e., may reorder equal elements), in-place/// (i.e., does not allocate), and *O*(*n* \* log(*n*)) worst-case./// It is typically faster than stable sorting, except in a few special cases, e.g., when the/// slice consists of several concatenated sorted sequences./// v.par_sort_unstable();/// Sorts the slice in parallel with a comparator function, but might not preserve the order of/// equal elements./// floats.par_sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());/// v.par_sort_unstable_by(|a, b| a.cmp(b));/// v.par_sort_unstable_by(|a, b| b.cmp(a));par_sort_unstable_by_key/// Sorts the slice in parallel with a key extraction function, but might not preserve the order/// of equal elements./// (i.e., does not allocate), and *O*(m \* *n* \* log(*n*)) worst-case,/// where the key function is *O*(*m*)./// Due to its key calling strategy, `par_sort_unstable_by_key` is likely to be slower than/// [`par_sort_by_cached_key`](#method.par_sort_by_cached_key) in cases where the key function/// is expensive./// v.par_sort_unstable_by_key(|k| k.abs());par_chunk_by_mut/// Returns a parallel iterator over the slice producing non-overlapping mutable/// runs of elements using the predicate to separate them./// let mut xs = [1, 2, 2, 3, 3, 3];/// let chunks: Vec<_> = xs.par_chunk_by_mut(|&x, &y| x == y).collect();/// assert_eq!(chunks[0], &mut [1]);/// assert_eq!(chunks[1], &mut [2, 2]);/// assert_eq!(chunks[2], &mut [3, 3, 3]);/// Parallel extensions for mutable slices./// Parallel iterator over immutable items in a slice/// Parallel iterator over immutable overlapping windows of a sliceWindowsProducer/// Parallel iterator over mutable items in a sliceIterMutProducer/// Parallel iterator over slices separated by a predicate/// Parallel iterator over slices separated by a predicate,/// including the matched part as a terminator.midpointINCLfold_splitsFissile/// Implement support for `SplitProducer`./// Parallel iterator over mutable slices separated by a predicate/// Parallel iterator over mutable slices separated by a predicate,//! Parallel iterator types for [slices][std::slice]//! [std::slice]: https://doc.rust-lang.org/stable/std/slice//// `src` is often a local pointer here, make sure we have appropriate/// PhantomData so that dropck can protect us./// When dropped, copies from `src` into `dest`./// Construct from a source pointer and a destination/// Assumes dest lives longer than src, since there is no easy way to/// copy down lifetime information from another pointershift_head/// Shifts the first element to the right until it encounters a greater or equal element.shift_tail/// Shifts the last element to the left until it encounters a smaller or equal element.partial_insertion_sort/// Partially sorts a slice by shifting several out-of-order elements around./// Returns `true` if the slice is sorted at the end. This function is *O*(*n*) worst-case.insertion_sort/// Sorts a slice using insertion sort, which is *O*(*n*^2) worst-case./// Sorts `v` using heapsort, which guarantees *O*(*n* \* log(*n*)) worst-case.partition_in_blocks/// Partitions `v` into elements smaller than `pivot`, followed by elements greater than or equal/// to `pivot`./// Returns the number of elements smaller than `pivot`./// Partitioning is performed block-by-block in order to minimize the cost of branching operations./// This idea is presented in the [BlockQuicksort][pdf] paper./// [pdf]: https://drops.dagstuhl.de/opus/volltexte/2016/6389/pdf/LIPIcs-ESA-2016-38.pdf/// Partitions `v` into elements smaller than `v[pivot]`, followed by elements greater than or/// equal to `v[pivot]`./// Returns a tuple of:/// 1. Number of elements smaller than `v[pivot]`./// 2. True if `v` was already partitioned.partition_equal/// Partitions `v` into elements equal to `v[pivot]` followed by elements greater than `v[pivot]`./// Returns the number of elements equal to the pivot. It is assumed that `v` does not contain/// elements smaller than the pivot.break_patterns/// Scatters some elements around in an attempt to break patterns that might cause imbalanced/// partitions in quicksort.choose_pivot/// Chooses a pivot in `v` and returns the index and `true` if the slice is likely already sorted./// Elements in `v` might be reordered in the process./// Sorts `v` recursively./// If the slice had a predecessor in the original array, it is specified as `pred`./// `limit` is the number of allowed imbalanced partitions before switching to `heapsort`. If zero,/// this function will immediately switch to heapsort./// Sorts `v` using pattern-defeating quicksort in parallel./// The algorithm is unstable, in-place, and *O*(*n* \* log(*n*)) worst-case.test_heapsort//! Parallel quicksort.//! This implementation is copied verbatim from `std::slice::sort_unstable` and then parallelized.//! The only difference from the original is that calls to `recurse` are executed in parallel using//! `rayon_core::join`./// Parallel iterator over immutable non-overlapping chunks of a slice, starting at the end.RChunksProducerRChunksExactProducer/// Parallel iterator over mutable non-overlapping chunks of a slice, starting at the end.RChunksMutProducer/// with `std::iter::RChunksExactMut`, but consider calling `remainder()` orRChunksExactMutProducertest_par_sorttest_par_sort_unstabletest_par_sort_stabilitytest_par_chunks_exact_remaindertest_par_chunks_exact_mut_remaindertest_par_rchunks_exact_remaindertest_par_rchunks_exact_mut_remainderslice_chunk_byslice_chunk_by_mut/// Marks the endpoint beyond which we've already found no separators./// Common producer for splitting on a predicate.SplitInclusiveProducer/// Helper trait so `&str`, `&[T]`, and `&mut [T]` can share `SplitProducer`.new_incl/// Common `fold_with` implementation, integrating `SplitTerminator`'s/// need to sometimes skip its final empty item.//! Common splitter for strings and slices//! This module is private, so these items are effectively `pub(super)`is_char_boundary/// Test if a byte is the start of a UTF-8 character./// (extracted from `str::is_char_boundary`)find_char_midpoint/// Find the index of a character boundary near the midpoint./// Try to split a string near the midpoint.as_parallel_string/// Returns a plain string slice, which is used to implement the rest ofpar_chars/// Returns a parallel iterator over the characters of a string./// let max = "hello".par_chars().max_by_key(|c| *c as i32);/// assert_eq!(Some('o'), max);par_char_indices/// Returns a parallel iterator over the characters of a string, with their positions./// let min = "hello".par_char_indices().min_by_key(|&(_i, c)| c as i32);/// assert_eq!(Some((1, 'e')), min);par_bytes/// Returns a parallel iterator over the bytes of a string./// Note that multi-byte sequences (for code points greater than `U+007F`)/// are produced as separate items, but will not be split across threads./// If you would prefer an indexed iterator without that guarantee, consider/// `string.as_bytes().par_iter().copied()` instead./// let max = "hello".par_bytes().max();/// assert_eq!(Some(b'o'), max);par_encode_utf16EncodeUtf16/// Returns a parallel iterator over a string encoded as UTF-16./// Note that surrogate pairs (for code points greater than `U+FFFF`) are/// produced as separate items, but will not be split across threads./// let max = "hello".par_encode_utf16().max();/// assert_eq!(Some(b'o' as u16), max);/// let text = "Zażółć gęślą jaźń";/// let utf8_len = text.len();/// let utf16_len = text.par_encode_utf16().count();/// assert!(utf16_len <= utf8_len);/// Returns a parallel iterator over substrings separated by a/// given character or predicate, similar to `str::split`./// Note: the `Pattern` trait is private, for use only by Rayon itself./// It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,/// and any function or closure `F: Fn(char) -> bool + Sync + Send`./// let total = "1, 2, buckle, 3, 4, door"///    .par_split(',')///    .filter_map(|s| s.trim().parse::<i32>().ok())///    .sum();/// assert_eq!(10, total);/// given character or predicate, keeping the matched part as a terminator/// of the substring similar to `str::split_inclusive`./// let lines: Vec<_> = "Mary had a little lamb\nlittle lamb\nlittle lamb."///    .par_split_inclusive('\n')/// assert_eq!(lines, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);par_split_terminatorSplitTerminator/// Returns a parallel iterator over substrings terminated by a/// given character or predicate, similar to `str::split_terminator`./// It's equivalent to `par_split`, except it doesn't produce an empty/// substring after a trailing terminator./// let parts: Vec<_> = "((1 + 3) * 2)"///     .par_split_terminator(|c| c == '(' || c == ')')/// assert_eq!(vec!["", "", "1 + 3", " * 2"], parts);par_lines/// Returns a parallel iterator over the lines of a string, ending with an/// optional carriage return and with a newline (`\r\n` or just `\n`)./// The final line ending is optional, and line endings are not included in/// the output strings./// let lengths: Vec<_> = "hello world\nfizbuzz"///     .par_lines()///     .map(|l| l.len())/// assert_eq!(vec![11, 7], lengths);par_split_whitespaceSplitWhitespace/// Returns a parallel iterator over the sub-slices of a string that are/// separated by any amount of whitespace./// As with `str::split_whitespace`, 'whitespace' is defined according to/// the terms of the Unicode Derived Core Property `White_Space`./// If you only want to split on ASCII whitespace instead, use/// [`par_split_ascii_whitespace`][`ParallelString::par_split_ascii_whitespace`]./// let longest = "which is the longest word?"///     .par_split_whitespace()///     .max_by_key(|word| word.len());/// assert_eq!(Some("longest"), longest);/// All kinds of whitespace are considered:/// let words: Vec<&str> = " Mary   had\ta\u{2009}little  \n\t lamb"/// assert_eq!(words, ["Mary", "had", "a", "little", "lamb"]);/// If the string is empty or all whitespace, the iterator yields no string slices:/// assert_eq!("".par_split_whitespace().count(), 0);/// assert_eq!("   ".par_split_whitespace().count(), 0);par_split_ascii_whitespaceSplitAsciiWhitespace/// separated by any amount of ASCII whitespace./// To split by Unicode `White_Space` instead, use/// [`par_split_whitespace`][`ParallelString::par_split_whitespace`].///     .par_split_ascii_whitespace()/// All kinds of ASCII whitespace are considered, but not Unicode `White_Space`:/// assert_eq!(words, ["Mary", "had", "a\u{2009}little", "lamb"]);/// If the string is empty or all ASCII whitespace, the iterator yields no string slices:par_matches/// Returns a parallel iterator over substrings that match a/// given character or predicate, similar to `str::matches`.///    .par_matches(char::is_numeric)///    .map(|s| s.parse::<i32>().expect("digit"))par_match_indicesMatchIndices/// Returns a parallel iterator over substrings that match a given character/// or predicate, with their positions, similar to `str::match_indices`./// let digits: Vec<_> = "1, 2, buckle, 3, 4, door"///    .par_match_indices(char::is_numeric)/// assert_eq!(digits, vec![(0, "1"), (3, "2"), (14, "3"), (17, "4")]);/// Parallel extensions for strings.rfind_inis_suffix_of'chfold_inclusive_splitsfold_matchesfold_match_indices/// Pattern-matching trait for `ParallelString`, somewhat like a mix of/// `std::str::pattern::{Pattern, Searcher}`./// We hide the `Pattern` trait in a private module, as its API is not meant/// for general consumption.  If we could have privacy on trait items, then it/// would be nicer to have its basic existence and implementors public while/// keeping all of the methods private.impl_pattern/// Parallel iterator over the characters of a stringCharsProducer/// Parallel iterator over the characters of a string, with their positionsCharIndicesProducer/// Parallel iterator over the bytes of a stringBytesProducer/// Parallel iterator over a string encoded as UTF-16EncodeUtf16Producer/// Parallel iterator over substrings separated by a pattern/// Parallel iterator over substrings separated by a terminator pattern'sepskip_lastSplitTerminatorProducer/// Parallel iterator over lines in a stringno_carriage_return/// Parallel iterator over substrings separated by whitespacenot_empty/// Parallel iterator over substrings separated by ASCII whitespaceis_ascii_whitespace/// Parallel iterator over substrings that match a pattern'patMatchesProducer/// Parallel iterator over substrings that match a pattern, with their positionsMatchIndicesProducer//! Parallel iterator types for [strings][std::str]//! Note: [`ParallelString::par_split()`] and [`par_split_terminator()`]//! reference a `Pattern` trait which is not visible outside this crate.//! This trait is intentionally kept private, for use only by Rayon itself.//! It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,//! and any function or closure `F: Fn(char) -> bool + Sync + Send`.//! [`ParallelString::par_split()`]: trait.ParallelString.html#method.par_split//! [`par_split_terminator()`]: trait.ParallelString.html#method.par_split_terminator//! [std::str]: https://doc.rust-lang.org/stable/std/str/// /////////////////////////////////////////////////////////////////////////// TODO (MSRV 1.75): use `*self` for array patterns too.// - Needs `DoubleEndedSearcher` so `split.next_back()` works./// Draining parallel iterator that moves a range of characters out of a string,//! This module contains the parallel iterator types for owned strings//! (`String`). You will rarely need to interact with it directly/// Parallel iterator that moves out of a vector./// Draining parallel iterator that moves a range out of a vector, but keeps the total capacity./// Creates a draining producer, which *moves* items from the slice./// Unsafe because `!Copy` data must not be read after the borrow is released./// Creates a draining producer, which *moves* items from the tail of the vector./// Unsafe because we're moving from beyond `vec.len()`, so the caller must ensure/// that data is initialized and not read after the borrow is released.SliceDrain// like std::vec::Drain, without updating a source Vec//! Parallel iterator types for [vectors][std::vec] (`Vec<T>`)//! [std::vec]: https://doc.rust-lang.org/stable/std/vec/// We need a build script to use `link = "rayon-core"`.  But we're not// *actually* linking to anything, just making sure that we're the only// rayon-core in use.jobArcJobStackJoblatchCountLatchLatchRefWorkerThread/// Executes `op` within every thread in the current threadpool. If this is/// called from a non-Rayon thread, it will execute in the global threadpool./// Any attempts to use `join`, `scope`, or parallel iterators will then operate/// within that threadpool. When the call has completed on each thread, returns/// a vector containing all of their return values./// For more information, see the [`ThreadPool::broadcast()`][m] method./// [m]: struct.ThreadPool.html#method.broadcast/// Spawns an asynchronous task on every thread in this thread-pool. This task/// will run in the implicit, global scope, which means that it may outlast the/// current stack frame -- therefore, it cannot capture any references onto the/// stack (you will likely need a `move` closure)./// For more information, see the [`ThreadPool::spawn_broadcast()`][m] method./// [m]: struct.ThreadPool.html#method.spawn_broadcast/// Make sure to prevent auto-traits like `Send` and `Sync`./// Provides context to a closure called by `broadcast`./// Our index amongst the broadcast threads (ranges from `0..self.num_threads()`)./// The number of threads receiving the broadcast in the thread pool./// # Future compatibility note/// Future versions of Rayon might vary the number of threads over time, but/// this method will always return the number of threads which are actually/// receiving your particular `broadcast` call.broadcast_in/// Execute `op` on every thread in the pool. It will be executed on each/// thread when they have nothing else to do locally, before they try to/// steal work from other threads. This function will not return until all/// threads have completed the `op`./// Unsafe because `registry` must not yet have terminated.spawn_broadcast_in/// steal work from other threads. This function returns immediately after/// injecting the jobs.broadcast_globalspawn_broadcast_globalbroadcast_poolspawn_broadcast_poolbroadcast_selfspawn_broadcast_selfbroadcast_mutualspawn_broadcast_mutualbroadcast_mutual_sleepyspawn_broadcast_mutual_sleepybroadcast_panic_onespawn_broadcast_panic_onebroadcast_panic_manyspawn_broadcast_panic_manybroadcast_sleep_racebroadcast_after_spawn_broadcastbroadcast_after_spawnquicksort_race1quicksort_race2quicksort_race3rc_returnrc_upvarscope_join_bad/*! ```compile_fail,E0524

fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
    if v.len() <= 1 {
        return;
    }

    let mid = partition(v);
    let (lo, _hi) = v.split_at_mut(mid);
    rayon_core::join(|| quick_sort(lo), || quick_sort(lo)); //~ ERROR
}

fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
    let pivot = v.len() - 1;
    let mut i = 0;
    for j in 0..pivot {
        if v[j] <= v[pivot] {
            v.swap(i, j);
            i += 1;
        }
    }
    v.swap(i, pivot);
    i
}

fn main() { }

``` *//*! ```compile_fail,E0500

fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
    if v.len() <= 1 {
        return;
    }

    let mid = partition(v);
    let (lo, _hi) = v.split_at_mut(mid);
    rayon_core::join(|| quick_sort(lo), || quick_sort(v)); //~ ERROR
}

fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
    let pivot = v.len() - 1;
    let mut i = 0;
    for j in 0..pivot {
        if v[j] <= v[pivot] {
            v.swap(i, j);
            i += 1;
        }
    }
    v.swap(i, pivot);
    i
}

fn main() { }

``` *//*! ```compile_fail,E0524

fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
    if v.len() <= 1 {
        return;
    }

    let mid = partition(v);
    let (_lo, hi) = v.split_at_mut(mid);
    rayon_core::join(|| quick_sort(hi), || quick_sort(hi)); //~ ERROR
}

fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
    let pivot = v.len() - 1;
    let mut i = 0;
    for j in 0..pivot {
        if v[j] <= v[pivot] {
            v.swap(i, j);
            i += 1;
        }
    }
    v.swap(i, pivot);
    i
}

fn main() { }

``` *//** ```compile_fail,E0277

use std::rc::Rc;

rayon_core::join(|| Rc::new(22), || ()); //~ ERROR

``` *//** ```compile_fail,E0277

use std::rc::Rc;

rayon_core::join(|| (), || Rc::new(23)); //~ ERROR

``` *//*! ```compile_fail,E0277

use std::rc::Rc;

let r = Rc::new(22);
rayon_core::join(|| r.clone(), || r.clone());
//~^ ERROR

``` *//*! ```compile_fail,E0373

fn bad_scope<F>(f: F)
    where F: FnOnce(&i32) + Send,
{
    rayon_core::scope(|s| {
        let x = 22;
        s.spawn(|_| f(&x)); //~ ERROR `x` does not live long enough
    });
}

fn good_scope<F>(f: F)
    where F: FnOnce(&i32) + Send,
{
    let x = 22;
    rayon_core::scope(|s| {
        s.spawn(|_| f(&x));
    });
}

fn main() {
}

``` */LatchJobResult/// Unsafe: this may be called from a different thread than the one/// which scheduled the job, so the implementer must ensure the/// appropriate traits are met, whether `Send`, `Sync`, or both.Job/// A `Job` is used to advertise work for other threads that they may/// want to steal. In accordance with time honored tradition, jobs are/// arranged in a deque, so that thieves can take from the top of the/// deque while the main worker manages the bottom of the deque. This/// deque is managed by the `thread_pool` module.execute_fnJobRef/// Effectively a Job trait object. Each JobRef **must** be executed/// exactly once, or else data may leak./// Internally, we store the job's data in a `*const ()` pointer.  The/// true type is something like `*const StackJob<...>`, but we hide/// it. We also carry the "execute fn" from the `Job` trait./// Unsafe: caller asserts that `data` will remain valid until the/// job is executed./// Returns an opaque handle that can be saved and compared,/// without making `JobRef` itself `Copy + Eq`./// A job that will be owned by a stack slot. This means that when it/// executes it need not free any heap data, the cleanup occurs when/// the stack frame is later popped.  The function parameter indicates/// `true` if the job was stolen -- executed on a different thread.as_job_refrun_inlineHeapJob/// Represents a job stored in the heap. Used to implement/// `scope`. Unlike `StackJob`, when executed, `HeapJob` simply/// invokes a closure, which then triggers the appropriate logic to/// signal that the job executed./// (Probably `StackJob` should be refactored in a similar fashion.)into_job_ref/// Creates a `JobRef` from this job -- note that this hides all/// lifetimes, so it is up to you to ensure that this JobRef/// doesn't outlive any data that it closes over.into_static_job_ref/// Creates a static `JobRef` from this job./// Represents a job stored in an `Arc` -- like `HeapJob`, but may/// be turned into multiple `JobRef`s and called multiple times.as_static_job_refinto_return_value/// Convert the `JobResult` for a job that has finished (and hence/// its JobResult is populated) into its return value./// NB. This will panic if the job panicked.JobFifo/// Indirect queue to provide FIFO job priority.SpinLatch/// Takes two closures and *potentially* runs them in parallel. It/// returns a pair of the results from those closures./// Conceptually, calling `join()` is similar to spawning two threads,/// one executing each of the two closures. However, the/// implementation is quite different and incurs very low/// overhead. The underlying technique is called "work stealing": the/// Rayon runtime uses a fixed pool of worker threads and attempts to/// only execute code in parallel when there are idle CPUs to handle/// When `join` is called from outside the thread pool, the calling/// thread will block while the closures execute in the pool.  When/// `join` is called within the pool, the calling thread still actively/// participates in the thread pool. It will begin by executing closure/// A (on the current thread). While it is doing that, it will advertise/// closure B as being available for other threads to execute. Once closure A/// has completed, the current thread will try to execute closure B;/// if however closure B has been stolen, then it will look for other work/// while waiting for the thief to fully execute closure B. (This is the/// typical work-stealing strategy)./// This example uses join to perform a quick-sort (note this is not a/// particularly optimized implementation: if you **actually** want to/// sort for real, you should prefer [the `par_sort` method] offered/// by Rayon)./// [the `par_sort` method]: ../rayon/slice/trait.ParallelSliceMut.html#method.par_sort/// # use rayon_core as rayon;/// let mut v = vec![5, 1, 8, 22, 0, 44];/// quick_sort(&mut v);/// assert_eq!(v, vec![0, 1, 5, 8, 22, 44]);/// fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {///    if v.len() > 1 {///        let mid = partition(v);///        let (lo, hi) = v.split_at_mut(mid);///        rayon::join(|| quick_sort(lo),///                    || quick_sort(hi));/// // Partition rearranges all items `<=` to the pivot/// // item (arbitrary selected to be the last item in the slice)/// // to the first half of the slice. It then returns the/// // "dividing point" where the pivot is placed./// fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {///     let pivot = v.len() - 1;///     let mut i = 0;///     for j in 0..pivot {///         if v[j] <= v[pivot] {///             v.swap(i, j);///             i += 1;///     v.swap(i, pivot);///     i/// # Warning about blocking I/O/// The assumption is that the closures given to `join()` are/// CPU-bound tasks that do not perform I/O or other blocking/// operations. If you do perform I/O, and that I/O should block/// (e.g., waiting for a network request), the overall performance may/// be poor.  Moreover, if you cause one closure to be blocked waiting/// on another (for example, using a channel), that could lead to a/// deadlock./// No matter what happens, both closures will always be executed.  If/// a single closure panics, whether it be the first or second/// closure, that panic will be propagated and hence `join()` will/// panic with the same panic value. If both closures panic, `join()`/// will panic with the panic value from the first closure./// Identical to `join`, except that the closures have a parameter/// that provides context for the way the closure has been called,/// especially indicating whether they're executing on a different/// thread than where `join_context` was called.  This will occur if/// the second job is stolen by a different thread, or if/// `join_context` was called from outside the thread pool to beginjoin_recover_from_panic/// If job A panics, we still cannot return until we are sure that job/// B is complete. This is because it may contain references into the/// enclosing stack frame(s).// cold pathquick_sortsort_in_poolpanic_propagate_apanic_propagate_bpanic_propagate_bothpanic_b_still_executesjoin_context_bothjoin_context_neitherjoin_context_secondjoin_counter_overflow//! Tests for the join code./// Set the latch, signalling others./// # WARNING/// Setting a latch triggers other threads to wake up and (in some/// cases) complete. This may, in turn, cause memory to be/// deallocated and so forth. One must be very careful about this,/// and it's typically better to read all the fields you will need/// to access *before* a latch is set!/// This function operates on `*const Self` instead of `&self` to allow it/// to become dangling during this call. The caller must ensure that the/// pointer is valid upon entry, and not invalidated during the call by any/// actions other than `set` itself./// We define various kinds of latches, which are all a primitive signaling/// mechanism. A latch starts as false. Eventually someone calls `set()` and/// it becomes true. You can test if it has been set by calling `probe()`./// Some kinds of latches, but not all, support a `wait()` operation/// that will wait until the latch is set, blocking efficiently. That/// is not part of the trait since it is not possibly to do with all/// latches./// The intention is that `set()` is called once, but `probe()` may be/// called any number of times. Once `probe()` returns true, the memory/// effects that occurred before `set()` become visible./// It'd probably be better to refactor the API into two paired types,/// but that's a bit of work, and this is not a public API./// ## Memory ordering/// Latches need to guarantee two things:/// - Once `probe()` returns true, all memory effects from the `set()`///   are visible (in other words, the set should synchronize-with///   the probe)./// - Once `set()` occurs, the next `probe()` *will* observe it.  This///   typically requires a seq-cst ordering. See [the "tickle-then-get-sleepy" scenario in the sleep///   README](/src/sleep/README.md#tickle-then-get-sleepy) for details.as_core_latchCoreLatchAsCoreLatchUNSET/// Latch is not set, owning thread is awakeSLEEPY/// Latch is not set, owning thread is going to sleep on this latch/// (but has not yet fallen asleep).SLEEPING/// Latch is not set, owning thread is asleep on this latch and/// must be awoken./// Latch is set./// Spin latches are the simplest, most efficient kind, but they do/// not support a `wait()` operation. They just have a boolean flag/// that becomes true when `set()` is called.get_sleepy/// Invoked by owning thread as it prepares to sleep. Returns true/// if the owning thread may proceed to fall asleep, false if the/// latch was set in the meantime.fall_asleep/// Invoked by owning thread as it falls asleep sleep. Returns/// true if the owning thread should block, or false if the latch/// was set in the meantime./// Set the latch. If this returns true, the owning thread was sleeping/// and must be awoken./// This is private because, typically, setting a latch involves/// doing some wakeups; those are encapsulated in the surrounding/// latch code./// Test if this latch has been set.core_latchtarget_worker_indexcross/// Creates a new spin latch that is owned by `thread`. This means/// that `thread` is the only thread that should be blocking on/// this latch -- it also means that when the latch is set, we/// will wake `thread` if it is sleeping./// Creates a new spin latch for cross-threadpool blocking.  Notably, we/// need to make sure the registry is kept alive after setting, so we can/// safely call the notification.LockLatch/// A Latch starts as false and eventually becomes true. You can block/// until it becomes true.wait_and_reset/// Block until latch is set, then resets this lock latch so it can be reused again./// Block until latch is set.OnceLatch/// Once latches are used to implement one-time blocking, primarily/// for the termination flag of the threads in the pool./// Note: like a `SpinLatch`, once-latches are always associated with/// some registry that is probing them, which must be tickled when/// they are set. *Unlike* a `SpinLatch`, they don't themselves hold a/// reference to that registry. This is because in some cases the/// registry owns the once-latch, and that would create a cycle. So a/// `OnceLatch` must be given a reference to its owning registry when/// it is set. For this reason, it does not implement the `Latch`/// trait (but it doesn't have to, as it is not used in those generic/// contexts).set_and_tickle_one/// Set the latch, then tickle the specific worker thread,/// which should be the one that owns this latch.CountLatchKind/// Counting latches are used to implement scopes. They track a/// counter. Unlike other latches, calling `set()` does not/// necessarily make the latch be considered `set()`; instead, it just/// decrements the counter. The latch is only "set" (in the sense that/// `probe()` returns true) once the counter reaches zero./// If a worker thread in registry A calls `in_place_scope` on a ThreadPool/// with registry B, when a job completes in a thread of registry B, we may/// need to call `notify_worker_latch_is_set()` to wake the thread in registry A./// That means we need a reference to registry A (since at that point we will/// only have a reference to registry B), so we stash it here.worker_index/// The index of the worker to wake in `registry`Stealing/// A latch for scopes created on a rayon thread which will participate in work-/// stealing while it waits for completion. This thread is not necessarily part/// of the same registry as the scope itself!/// A latch for scopes created on a non-rayon thread which will block to wait.with_count/// `&L` without any implication of `dereferenceable` for `Latch::set`current_thread_has_pending_tasksCustomSpawnDefaultSpawnThreadSpawn/// Returns the maximum number of threads that Rayon supports in a single thread-pool./// If a higher thread count is requested by calling `ThreadPoolBuilder::num_threads` or by setting/// the `RAYON_NUM_THREADS` environment variable, then it will be reduced to this maximum./// The value may vary between different targets, and is subject to change in new Rayon versions./// Returns the number of threads in the current registry. If this/// code is executing within a Rayon thread-pool, then this will be/// the number of threads for the thread-pool of the current/// thread. Otherwise, it will be the number of threads for the global/// thread-pool./// This can be useful when trying to judge how many times to split/// parallel work (the parallel iterator traits use this value/// internally for this purpose)./// Note that unless this thread-pool was created with a/// builder that specifies the number of threads, then this/// number may vary over time in future versions (see [the/// `num_threads()` method for details][snt])./// [snt]: struct.ThreadPoolBuilder.html#method.num_threads/// Error when initializing a thread pool.GlobalPoolAlreadyInitializedCurrentThreadAlreadyInPool/// The number of threads in the rayon thread pool./// If zero will use the RAYON_NUM_THREADS environment variable./// If RAYON_NUM_THREADS is invalid or zero will use the default.use_current_thread/// The thread we're building *from* will also be part of the pool.panic_handlerPanicHandler/// Custom closure, if any, to handle a panic that we cannot propagate/// anywhere else.get_thread_name/// Closure to compute the name of a thread./// The stack size for the created worker threadsstart_handlerStartHandler/// Closure invoked on worker thread start.exit_handlerExitHandler/// Closure invoked on worker thread exit.spawn_handler/// Closure invoked to spawn threads.breadth_first/// If false, worker threads will execute spawned jobs in a/// "depth-first" fashion. If true, they will do a "breadth-first"/// fashion. Depth-first is the default./// Used to create a new [`ThreadPool`] or to configure the global rayon thread pool./// ## Creating a ThreadPool/// The following creates a thread pool with 22 threads./// let pool = rayon::ThreadPoolBuilder::new().num_threads(22).build().unwrap();/// To instead configure the global thread pool, use [`build_global()`]:/// rayon::ThreadPoolBuilder::new().num_threads(22).build_global().unwrap();/// [`ThreadPool`]: struct.ThreadPool.html/// [`build_global()`]: struct.ThreadPoolBuilder.html#method.build_global/// Contains the rayon thread pool configuration. Use [`ThreadPoolBuilder`] instead./// [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html/// The type for a panic handling closure. Note that this same closure/// may be invoked multiple times in parallel./// The type for a closure that gets invoked when a thread starts. The/// closure is passed the index of the thread on which it is invoked./// Note that this same closure may be invoked multiple times in parallel./// The type for a closure that gets invoked when a thread exits. The/// closure is passed the index of the thread on which is is invoked.// NB: We can't `#[derive(Default)]` because `S` is left ambiguous./// Creates and returns a valid rayon thread pool builder, but does not initialize it./// Creates a new `ThreadPool` initialized using this configuration.build_global/// Initializes the global thread pool. This initialization is/// **optional**.  If you do not call this function, the thread pool/// will be automatically initialized with the default/// configuration. Calling `build_global` is not recommended, except/// in two scenarios:/// - You wish to change the default configuration./// - You are running a benchmark, in which case initializing may///   yield slightly more consistent results, since the worker threads///   will already be ready to go even in the first iteration.  But///   this cost is minimal./// Initialization of the global thread pool happens exactly/// once. Once started, the configuration cannot be/// changed. Therefore, if you call `build_global` a second time, it/// will return an error. An `Ok` result indicates that this/// is the first initialization of the thread pool./// Note: the `S: ThreadSpawn` constraint is an internal implementation detail for the/// default spawn and those set by [`spawn_handler`](#method.spawn_handler).build_scoped// expected to call `run()`/// Creates a scoped `ThreadPool` initialized using this configuration./// This is a convenience function for building a pool using [`std::thread::scope`]/// to spawn threads in a [`spawn_handler`](#method.spawn_handler)./// The threads in this pool will start by calling `wrapper`, which should/// do initialization and continue by calling `ThreadBuilder::run()`./// [`std::thread::scope`]: https://doc.rust-lang.org/std/thread/fn.scope.html/// A scoped pool may be useful in combination with scoped thread-local variables./// scoped_tls::scoped_thread_local!(static POOL_DATA: Vec<i32>);/// fn main() -> Result<(), rayon::ThreadPoolBuildError> {///     let pool_data = vec![1, 2, 3];///     // We haven't assigned any TLS data yet.///     assert!(!POOL_DATA.is_set());///     rayon::ThreadPoolBuilder::new()///         .build_scoped(///             // Borrow `pool_data` in TLS for each thread.///             |thread| POOL_DATA.set(&pool_data, || thread.run()),///             // Do some work that needs the TLS data.///             |pool| pool.install(|| assert!(POOL_DATA.is_set())),///         )?;///     // Once we've returned, `pool_data` is no longer borrowed.///     drop(pool_data);/// Sets a custom function for spawning threads./// Note that the threads will not exit until after the pool is dropped. It/// is up to the caller to wait for thread termination if that is important/// for any invariants. For instance, threads created in [`std::thread::scope`]/// will be joined before that scope returns, and this will block indefinitely/// if the pool is leaked. Furthermore, the global thread pool doesn't terminate/// until the entire process exits!/// A minimal spawn handler just needs to call `run()` from an independent thread.///     let pool = rayon::ThreadPoolBuilder::new()///         .spawn_handler(|thread| {///             std::thread::spawn(|| thread.run());///         .build()?;///     pool.install(|| println!("Hello from my custom thread!"));/// The default spawn handler sets the name and stack size if given, and propagates/// any errors from the thread builder.///             let mut b = std::thread::Builder::new();///             if let Some(name) = thread.name() {///                 b = b.name(name.to_owned());///             if let Some(stack_size) = thread.stack_size() {///                 b = b.stack_size(stack_size);///             b.spawn(|| thread.run())?;///     pool.install(|| println!("Hello from my fully custom thread!"));/// This can also be used for a pool of scoped threads like [`crossbeam::scope`],/// or [`std::thread::scope`] introduced in Rust 1.63, which is encapsulated in/// [`build_scoped`](#method.build_scoped)./// [`crossbeam::scope`]: https://docs.rs/crossbeam/0.8/crossbeam/fn.scope.html///     std::thread::scope(|scope| {///         let pool = rayon::ThreadPoolBuilder::new()///             .spawn_handler(|thread| {///                 let mut builder = std::thread::Builder::new();///                 if let Some(name) = thread.name() {///                     builder = builder.name(name.to_string());///                 if let Some(size) = thread.stack_size() {///                     builder = builder.stack_size(size);///                 builder.spawn_scoped(scope, || {///                     // Add any scoped initialization here, then run!///                     thread.run()///                 })?;///                 Ok(())///             })///             .build()?;///         pool.install(|| println!("Hello from my custom scoped thread!"));get_spawn_handler/// Returns a reference to the current spawn handler./// Get the number of threads that will be used for the thread/// pool. See `num_threads()` for more information./// Get the thread name for the thread with the given index.thread_name/// Sets a closure which takes a thread index and returns/// the thread's name./// Sets the number of threads to be used in the rayon threadpool./// If you specify a non-zero number of threads using this/// function, then the resulting thread-pools are guaranteed to/// start at most this number of threads./// If `num_threads` is 0, or you do not call this function, then/// the Rayon runtime will select the number of threads/// automatically. At present, this is based on the/// `RAYON_NUM_THREADS` environment variable (if set),/// or the number of logical CPUs (otherwise)./// In the future, however, the default behavior may/// change to dynamically add or remove threads as needed./// **Future compatibility warning:** Given the default behavior/// may change in the future, if you wish to rely on a fixed/// number of threads, you should use this function to specify/// that number. To reproduce the current default behavior, you/// may wish to use [`std::thread::available_parallelism`]/// to query the number of CPUs dynamically./// **Old environment variable:** `RAYON_NUM_THREADS` is a one-to-one/// replacement of the now deprecated `RAYON_RS_NUM_CPUS` environment/// variable. If both variables are specified, `RAYON_NUM_THREADS` will/// be preferred./// Use the current thread as one of the threads in the pool./// The current thread is guaranteed to be at index 0, and since the thread is not managed by/// rayon, the spawn and exit handlers do not run for that thread./// Note that the current thread won't run the main work-stealing loop, so jobs spawned into/// the thread-pool will generally not be picked up automatically by this thread unless you/// yield to rayon in some way, like via [`yield_now()`], [`yield_local()`], or [`scope()`]./// # Local thread-pools/// Using this in a local thread-pool means the registry will be leaked. In future versions/// there might be a way of cleaning up the current-thread state.take_panic_handler/// Returns a copy of the current panic handler./// Normally, whenever Rayon catches a panic, it tries to/// propagate it to someplace sensible, to try and reflect the/// semantics of sequential execution. But in some cases,/// particularly with the `spawn()` APIs, there is no/// obvious place where we should propagate the panic to./// In that case, this panic handler is invoked./// If no panic handler is set, the default is to abort the/// process, under the principle that panics should not go/// unobserved./// If the panic handler itself panics, this will abort the/// process. To prevent this, wrap the body of your panic handler/// in a call to `std::panic::catch_unwind()`.get_stack_size/// Get the stack size of the worker threads/// Sets the stack size of the worker threads/// **(DEPRECATED)** Suggest to worker threads that they execute/// spawned jobs in a "breadth-first" fashion./// Typically, when a worker thread is idle or blocked, it will/// attempt to execute the job from the *top* of its local deque of/// work (i.e., the job most recently spawned). If this flag is set/// to true, however, workers will prefer to execute in a/// *breadth-first* fashion -- that is, they will search for jobs at/// the *bottom* of their local deque. (At present, workers *always*/// steal from the bottom of other workers' deques, regardless of/// the setting of this flag.)/// If you think of the tasks as a tree, where a parent task/// spawns its children in the tree, then this flag loosely/// corresponds to doing a breadth-first traversal of the tree,/// whereas the default would be to do a depth-first traversal./// **Note that this is an "execution hint".** Rayon's task/// execution is highly dynamic and the precise order in which/// independent tasks are executed is not intended to be/// guaranteed./// This `breadth_first()` method is now deprecated per [RFC #1],/// and in the future its effect may be removed. Consider using/// [`scope_fifo()`] for a similar effect./// [RFC #1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md/// [`scope_fifo()`]: fn.scope_fifo.htmlget_breadth_firsttake_start_handler/// Takes the current thread start callback, leaving `None`./// Sets a callback to be invoked on thread start./// The closure is passed the index of the thread on which it is invoked./// If this closure panics, the panic will be passed to the panic handler./// If that handler returns, then startup will continue normally.take_exit_handler/// Returns a current thread exit callback, leaving `None`./// Sets a callback to be invoked on thread exit./// If that handler returns, then the thread will exit normally./// Creates and return a valid rayon thread pool configuration, but does not initialize it./// Deprecated in favor of `ThreadPoolBuilder::build`./// Deprecated in favor of `ThreadPoolBuilder::thread_name`./// Deprecated in favor of `ThreadPoolBuilder::num_threads`./// Deprecated in favor of `ThreadPoolBuilder::panic_handler`./// Deprecated in favor of `ThreadPoolBuilder::stack_size`./// Deprecated in favor of `ThreadPoolBuilder::breadth_first`./// Deprecated in favor of `ThreadPoolBuilder::start_handler`./// Deprecated in favor of `ThreadPoolBuilder::exit_handler`.into_builder/// Returns a ThreadPoolBuilder with identical parameters.is_unsupportedGLOBAL_POOL_ALREADY_INITIALIZEDCURRENT_THREAD_ALREADY_IN_POOL/// Deprecated in favor of `ThreadPoolBuilder::build_global`.migrated/// disable `Send` and `Sync`, just for a little future-proofing./// Provides the calling context to a closure called by `join_context`./// Returns `true` if the closure was called from a different thread/// than it was provided from.//! Rayon-core houses the core stable APIs of Rayon.//! These APIs have been mirrored in the Rayon crate and it is recommended to use these from there.//! [`join`] is used to take two closures and potentially run them in parallel.//!   - It will run in parallel if task B gets stolen before task A can finish.//!   - It will run sequentially if task A finishes before task B is stolen and can continue on task B.//! [`scope`] creates a scope in which you can run any number of parallel tasks.//! These tasks can spawn nested tasks and scopes, but given the nature of work stealing, the order of execution can not be guaranteed.//! The scope will exist until all tasks spawned within the scope have been completed.//! [`spawn`] add a task into the 'static' or 'global' scope, or a local scope created by the [`scope()`] function.//! [`ThreadPool`] can be used to create your own thread pools (using [`ThreadPoolBuilder`]) or to customize the global one.//! Tasks spawned within the pool (using [`install()`], [`join()`], etc.) will be added to a deque,//! where it becomes available for work stealing from other threads in the local threadpool.//! [`scope()`]: fn.scope.html//! [`spawn`]: fn.spawn.html//! [`ThreadPool`]: struct.threadpool.html//! [`install()`]: struct.ThreadPool.html#method.install//! [`spawn()`]: struct.ThreadPool.html#method.spawn//! [`join()`]: struct.ThreadPool.html#method.join//! # Global fallback when threading is unsupported//! Rayon uses `std` APIs for threading, but some targets have incomplete implementations that//! always return `Unsupported` errors. The WebAssembly `wasm32-unknown-unknown` and `wasm32-wasi`//! targets are notable examples of this. Rather than panicking on the unsupported error when//! creating the implicit global threadpool, Rayon configures a fallback mode instead.//! This fallback mode mostly functions as if it were using a single-threaded "pool", like setting//! `RAYON_NUM_THREADS=1`. For example, `join` will execute its two closures sequentially, since//! there is no other thread to share the work. However, since the pool is not running independent//! of the main thread, non-blocking calls like `spawn` may not execute at all, unless a lower-//! priority call like `broadcast` gives them an opening. The fallback mode does not try to emulate//! anything like thread preemption or `async` task switching, but `yield_now` or `yield_local`//! can also volunteer execution time.//! Explicit `ThreadPoolBuilder` methods always report their error without any fallback.//! # Restricting multiple versions//! In order to ensure proper coordination between threadpools, and especially//! to make sure there's only one global threadpool, `rayon-core` is actively//! restricted from building multiple versions of itself into a single target.//! You may see a build error like this in violation://! error: native library `rayon-core` is being linked to by more//! than one package, and can only be linked to by one package//! While we strive to keep `rayon-core` semver-compatible, it's still//! possible to arrive at this situation if different crates have overly//! restrictive tilde or inequality requirements for `rayon-core`.  The//! conflicting requirements will need to be resolved before the build will//! succeed./// Thread builder used for customization via/// [`ThreadPoolBuilder::spawn_handler`](struct.ThreadPoolBuilder.html#method.spawn_handler)./// Gets the index of this thread in the pool, within `0..num_threads`./// Gets the string that was specified by `ThreadPoolBuilder::name()`./// Gets the value that was specified by `ThreadPoolBuilder::stack_size()`./// Executes the main loop for this thread. This will not return until the/// thread pool is dropped./// Spawn a thread with the `ThreadBuilder` parameters, and then/// call `ThreadBuilder::run()`./// Generalized trait for spawning a thread in the `Registry`./// This trait is pub-in-private -- E0445 forces us to make it public,/// but we don't actually want to expose these details in the API./// Spawns a thread in the "normal" way with `std::thread::Builder`./// This type is pub-in-private -- E0445 forces us to make it public,/// Spawns a thread with a user's custom callback.thread_infosThreadInfoinjected_jobsbroadcaststerminate_count// When this latch reaches 0, it means that all work on this// registry must be complete. This is ensured in the following ways:// - if this is the global registry, there is a ref-count that never//   gets released.// - if this is a user-created thread-pool, then so long as the thread-pool//   exists, it holds a reference.// - when we inject a "blocking job" into the registry with `ThreadPool::install()`,//   no adjustment is needed; the `ThreadPool` holds the reference, and since we won't//   return until the blocking job is complete, that ref will continue to be held.// - when `join()` or `scope()` is invoked, similarly, no adjustments are needed.//   These are always owned by some other job (e.g., one injected by `ThreadPool::install()`)//   and that job will keep the pool alive.THE_REGISTRY/// InitializationTHE_REGISTRY_SETglobal_registry/// Starts the worker threads (if that has not already happened). If/// initialization has not already occurred, use the defaultinit_global_registry/// Starts the worker threads (if that has not already happened) with/// the given builder.set_global_registry/// Starts the worker threads (if that has not already happened)/// by creating a registry with the given callback.default_global_registryTerminator/// Returns the number of threads in the current registry.  This/// is better than `Registry::current().num_threads()` because it/// avoids incrementing the `Arc`.current_thread/// Returns the current `WorkerThread` if it's part of this `Registry`.RegistryId/// Returns an opaque identifier for this registry.wait_until_primed/// Waits for the worker threads to get up and running.  This is/// meant to be used for benchmarking purposes, primarily, so that/// you can get more consistent numbers by having everything/// "ready to go".wait_until_stopped/// Waits for the worker threads to stop. This is used for testing/// -- so we can check that termination actually works.inject_or_push/// MAIN LOOP/// So long as all of the worker threads are hanging out in their/// top-level loop, there is no work to be done./// Push a job into the given `registry`. If we are running on a/// worker thread for the registry, this will push onto the/// deque. Else, it will inject from the outside (which is slower).inject/// Push a job into the "external jobs" queue; it will be taken by/// whatever worker has nothing to do. Use this if you know that/// you are not on a worker of this registry.has_injected_jobpop_injected_jobinject_broadcast/// Push a job into each thread's own "external jobs" queue; it will be/// executed only on that thread, when it has nothing else to do locally,/// before it tries to steal other work./// **Panics** if not given exactly as many jobs as there are threads.in_worker/// If already in a worker-thread of this registry, just execute `op`./// Otherwise, inject `op` in this thread-pool. Either way, block until `op`/// completes and return its return value. If `op` panics, that panic will/// be propagated as well.  The second argument indicates `true` if injection/// was performed, `false` if executed directly.in_worker_coldin_worker_crossincrement_terminate_count/// Increments the terminate counter. This increment should be/// balanced by a call to `terminate`, which will decrement. This/// is used when spawning asynchronous work, which needs to/// prevent the registry from terminating so long as it is active./// Note that blocking functions such as `join` and `scope` do not/// need to concern themselves with this fn; their context is/// responsible for ensuring the current thread-pool will not/// terminate until they return./// The global thread-pool always has an outstanding reference/// (the initial one). Custom thread-pools have one outstanding/// reference that is dropped when the `ThreadPool` is dropped:/// since installing the thread-pool blocks until any joins/scopes/// complete, this ensures that joins/scopes are covered./// The exception is `::spawn()`, which can create a job outside/// of any blocking scope. In that case, the job itself holds a/// terminate count and is responsible for invoking `terminate()`/// when finished./// Signals that the thread-pool which owns this registry has been/// dropped. The worker threads will gradually terminate, once any/// extant work is completed.notify_worker_latch_is_set/// Notify the worker that the latch they are sleeping on has been "set".primed/// Latch set once thread has started and we are entering into the/// main loop. Used to wait for worker threads to become primed,/// primarily of interest for benchmarking./// Latch is set once worker thread has completed. Used to wait/// until workers have stopped; only used for tests./// The latch used to signal that terminated has been requested./// This latch is *set* by the `terminate` method on the/// `Registry`, once the registry's main "terminate" counter/// reaches zero./// the "stealer" half of the worker's deque/// the "worker" half of our local deque/// the "stealer" half of the worker's broadcast dequefifo/// local queue used for `spawn_fifo` indirectionXorShift64Star/// A weak random number generator./// WorkerThread identifiersWORKER_THREAD_STATE// This is a bit sketchy, but basically: the WorkerThread is// allocated on the stack of the worker on entry and stored into this// thread local variable. So it will remain valid at least until the// worker is fully unwound. Using an unsafe pointer avoids the need// for a RefCell<T> etc./// Gets the `WorkerThread` index for the current thread; returns/// NULL if this is not a worker thread. This pointer is valid/// anywhere on the current thread./// Sets `self` as the worker thread index for the current thread./// This is done during worker thread startup./// Returns the registry that owns this worker thread./// Our index amongst the worker threads (ranges from `0..self.num_threads()`).push_fifolocal_deque_is_emptytake_local_job/// Attempts to obtain a "local" job -- typically this means/// popping from the top of the stack, though if we are configured/// for breadth-first execution, it would mean dequeuing from the/// bottom./// Wait until the latch is set. Try to keep busy by popping and/// stealing tasks as necessary.wait_until_coldwait_until_out_of_workfind_work/// Try to steal a single job and return it./// This should only be done as a last resort, when there is no/// local work to do./// If already in a worker-thread, just execute `op`.  Otherwise,/// execute `op` in the default thread-pool. Either way, block until/// `op` completes and return its return value. If `op` panics, that/// panic will be propagated as well.  The second argument indicates/// `true` if injection was performed, `false` if executed directly./// [xorshift*] is a fast pseudorandom number generator which will/// even tolerate weak seeding, as long as it's not zero.next_usizeScopeBase/// Represents a fork-join scope which can be used to spawn any number of tasks./// See [`scope()`] for more information.///[`scope()`]: fn.scope.htmlfifos/// Those spawned from the same thread are prioritized in relative FIFO order./// See [`scope_fifo()`] for more information.///[`scope_fifo()`]: fn.scope_fifo.html/// thread registry where `scope()` was executed or where `in_place_scope()`/// should spawn jobs./// if some job panicked, the error is stored here; it will be/// propagated to the one who created the scopejob_completed_latch/// latch to track job counts/// You can think of a scope as containing a list of closures to execute,/// all of which outlive `'scope`.  They're not actually required to be/// `Sync`, but it's still safe to let the `Scope` implement `Sync` because/// the closures are only *moved* across threads to be executed./// Creates a "fork-join" scope `s` and invokes the closure with a/// reference to `s`. This closure can then spawn asynchronous tasks/// into `s`. Those tasks may run asynchronously with respect to the/// closure; they may themselves spawn additional tasks into `s`. When/// the closure returns, it will block until all tasks that have been/// spawned into `s` complete./// `scope()` is a more flexible building block compared to `join()`,/// since a loop can be used to spawn any number of tasks without/// recursing. However, that flexibility comes at a performance price:/// tasks spawned using `scope()` must be allocated onto the heap,/// whereas `join()` can make exclusive use of the stack. **Prefer/// `join()` (or, even better, parallel iterators) where possible.**/// The Rayon `join()` function launches two closures and waits for them/// to stop. One could implement `join()` using a scope like so, although/// it would be less efficient than the real implementation:/// pub fn join<A,B,RA,RB>(oper_a: A, oper_b: B) -> (RA, RB)///     where A: FnOnce() -> RA + Send,///           B: FnOnce() -> RB + Send,///           RA: Send,///           RB: Send,///     let mut result_a: Option<RA> = None;///     let mut result_b: Option<RB> = None;///     rayon::scope(|s| {///         s.spawn(|_| result_a = Some(oper_a()));///         s.spawn(|_| result_b = Some(oper_b()));///     (result_a.unwrap(), result_b.unwrap())/// # A note on threading/// The closure given to `scope()` executes in the Rayon thread-pool,/// as do those given to `spawn()`. This means that you can't access/// thread-local variables (well, you can, but they may have/// unexpected values)./// # Task execution/// Task execution potentially starts as soon as `spawn()` is called./// The task will end sometime before `scope()` returns. Note that the/// *closure* given to scope may return much earlier. In general/// the lifetime of a scope created like `scope(body)` goes something like this:/// - Scope begins when `scope(body)` is called/// - Scope body `body()` is invoked///     - Scope tasks may be spawned/// - Scope body returns/// - Scope tasks execute, possibly spawning more tasks/// - Once all tasks are done, scope ends and `scope()` returns/// To see how and when tasks are joined, consider this example:/// // point start/// rayon::scope(|s| {///     s.spawn(|s| { // task s.1///         s.spawn(|s| { // task s.1.1///             rayon::scope(|t| {///                 t.spawn(|_| ()); // task t.1///                 t.spawn(|_| ()); // task t.2///     s.spawn(|s| { // task s.2///     // point mid/// // point end/// The various tasks that are run will execute roughly like so:/// | (start)/// |/// | (scope `s` created)/// +-----------------------------------------------+ (task s.2)/// +-------+ (task s.1)                            |/// |       |                                       |/// |       +---+ (task s.1.1)                      |/// |       |   |                                   |/// |       |   | (scope `t` created)               |/// |       |   +----------------+ (task t.2)       |/// |       |   +---+ (task t.1) |                  |/// | (mid) |   |   |            |                  |/// :       |   + <-+------------+ (scope `t` ends) |/// :       |   |                                   |/// |<------+---+-----------------------------------+ (scope `s` ends)/// | (end)/// The point here is that everything spawned into scope `s` will/// terminate (at latest) at the same point -- right before the/// original call to `rayon::scope` returns. This includes new/// subtasks created by other subtasks (e.g., task `s.1.1`). If a new/// scope is created (such as `t`), the things spawned into that scope/// will be joined before that scope returns, which in turn occurs/// before the creating task (task `s.1.1` in this case) finishes./// There is no guaranteed order of execution for spawns in a scope,/// given that other threads may steal tasks at any time. However, they/// are generally prioritized in a LIFO order on the thread from which/// they were spawned. So in this example, absent any stealing, we can/// expect `s.2` to execute before `s.1`, and `t.2` before `t.1`. Other/// threads always steal from the other end of the deque, like FIFO/// order.  The idea is that "recent" tasks are most likely to be fresh/// in the local CPU's cache, while other threads can steal older/// "stale" tasks.  For an alternate approach, consider/// [`scope_fifo()`] instead./// # Accessing stack data/// In general, spawned tasks may access stack data in place that/// outlives the scope itself. Other data must be fully owned by the/// spawned task./// let ok: Vec<i32> = vec![1, 2, 3];///     let bad: Vec<i32> = vec![4, 5, 6];///         // We can access `ok` because outlives the scope `s`.///         println!("ok: {:?}", ok);///         // If we just try to use `bad` here, the closure will borrow `bad`///         // (because we are just printing it out, and that only requires a///         // borrow), which will result in a compilation error. Read on///         // for options.///         // println!("bad: {:?}", bad);///    });/// As the comments example above suggest, to reference `bad` we must/// take ownership of it. One way to do this is to detach the closure/// from the surrounding stack frame, using the `move` keyword. This/// will cause it to take ownership of *all* the variables it touches,/// in this case including both `ok` *and* `bad`:///     s.spawn(move |_| {///         println!("bad: {:?}", bad);///     // That closure is fine, but now we can't use `ok` anywhere else,///     // since it is owned by the previous task:///     // s.spawn(|_| println!("ok: {:?}", ok));/// While this works, it could be a problem if we want to use `ok` elsewhere./// There are two choices. We can keep the closure as a `move` closure, but/// instead of referencing the variable `ok`, we create a shadowed variable that/// is a borrow of `ok` and capture *that*:///     let ok: &Vec<i32> = &ok; // shadow the original `ok`///         println!("ok: {:?}", ok); // captures the shadowed version///     // Now we too can use the shadowed `ok`, since `&Vec<i32>` references///     // can be shared freely. Note that we need a `move` closure here though,///     // because otherwise we'd be trying to borrow the shadowed `ok`,///     // and that doesn't outlive `scope`.///     s.spawn(move |_| println!("ok: {:?}", ok));/// Another option is not to use the `move` keyword but instead to take ownership/// of individual variables:///         // Transfer ownership of `bad` into a local variable (also named `bad`).///         // This will force the closure to take ownership of `bad` from the environment.///         let bad = bad;///         println!("ok: {:?}", ok); // `ok` is only borrowed.///         println!("bad: {:?}", bad); // refers to our local variable, above.///     s.spawn(|_| println!("ok: {:?}", ok)); // we too can borrow `ok`/// If a panic occurs, either in the closure given to `scope()` or in/// any of the spawned jobs, that panic will be propagated and the/// call to `scope()` will panic. If multiple panics occurs, it is/// non-deterministic which of their panic values will propagate./// Regardless, once a task is spawned using `scope.spawn()`, it will/// execute, even if the spawning task should later panic. `scope()`/// returns once all spawned jobs have completed, and any panics are/// propagated at that point./// Creates a "fork-join" scope `s` with FIFO order, and invokes the/// closure with a reference to `s`. This closure can then spawn/// asynchronous tasks into `s`. Those tasks may run asynchronously with/// respect to the closure; they may themselves spawn additional tasks/// into `s`. When the closure returns, it will block until all tasks/// that have been spawned into `s` complete./// Tasks in a `scope_fifo()` run similarly to [`scope()`], but there's a/// difference in the order of execution. Consider a similar example:/// [`scope()`]: fn.scope.html/// rayon::scope_fifo(|s| {///     s.spawn_fifo(|s| { // task s.1///         s.spawn_fifo(|s| { // task s.1.1///             rayon::scope_fifo(|t| {///                 t.spawn_fifo(|_| ()); // task t.1///                 t.spawn_fifo(|_| ()); // task t.2///     s.spawn_fifo(|s| { // task s.2/// | (FIFO scope `s` created)/// +--------------------+ (task s.1)/// +-------+ (task s.2) |/// |       |            +---+ (task s.1.1)/// |       |            |   |/// |       |            |   | (FIFO scope `t` created)/// |       |            |   +----------------+ (task t.1)/// |       |            |   +---+ (task t.2) |/// | (mid) |            |   |   |            |/// :       |            |   + <-+------------+ (scope `t` ends)/// :       |            |   |/// |<------+------------+---+ (scope `s` ends)/// Under `scope_fifo()`, the spawns are prioritized in a FIFO order on/// the thread from which they were spawned, as opposed to `scope()`'s/// LIFO.  So in this example, we can expect `s.1` to execute before/// `s.2`, and `t.1` before `t.2`. Other threads also steal tasks in/// FIFO order, as usual. Overall, this has roughly the same order as/// the now-deprecated [`breadth_first`] option, except the effect is/// isolated to a particular scope. If spawns are intermingled from any/// combination of `scope()` and `scope_fifo()`, or from different/// threads, their order is only specified with respect to spawns in the/// same scope and thread./// For more details on this design, see Rayon [RFC #1]./// [`breadth_first`]: struct.ThreadPoolBuilder.html#method.breadth_first/// If a panic occurs, either in the closure given to `scope_fifo()` or/// in any of the spawned jobs, that panic will be propagated and the/// call to `scope_fifo()` will panic. If multiple panics occurs, it is/// Regardless, once a task is spawned using `scope.spawn_fifo()`, it/// will execute, even if the spawning task should later panic./// `scope_fifo()` returns once all spawned jobs have completed, and any/// panics are propagated at that point./// This is just like `scope()` except the closure runs on the same thread/// that calls `in_place_scope()`. Only work that it spawns runs in the/// thread pool./// If a panic occurs, either in the closure given to `in_place_scope()` or in/// call to `in_place_scope()` will panic. If multiple panics occurs, it is/// execute, even if the spawning task should later panic. `in_place_scope()`do_in_place_scope/// This is just like `scope_fifo()` except the closure runs on the same thread/// that calls `in_place_scope_fifo()`. Only work that it spawns runs in the/// If a panic occurs, either in the closure given to `in_place_scope_fifo()` or in/// call to `in_place_scope_fifo()` will panic. If multiple panics occurs, it is/// Regardless, once a task is spawned using `scope.spawn_fifo()`, it will/// execute, even if the spawning task should later panic. `in_place_scope_fifo()`do_in_place_scope_fifo/// Spawns a job into the fork-join scope `self`. This job will/// execute sometime before the fork-join scope completes.  The/// job is specified as a closure, and this closure receives its/// own reference to the scope `self` as argument. This can be/// used to inject new jobs into `self`./// Nothing. The spawned closures cannot pass back values to the/// caller directly, though they can write to local variables on/// the stack (if those variables outlive the scope) or/// communicate through shared channels./// (The intention is to eventually integrate with Rust futures to/// support spawns of functions that compute a value.)/// let mut value_a = None;/// let mut value_b = None;/// let mut value_c = None;///     s.spawn(|s1| {///           // ^ this is the same scope as `s`; this handle `s1`///           //   is intended for use by the spawned task,///           //   since scope handles cannot cross thread boundaries.///         value_a = Some(22);///         // the scope `s` will not end until all these tasks are done///         s1.spawn(|_| {///             value_b = Some(44);///         value_c = Some(66);/// assert_eq!(value_a, Some(22));/// assert_eq!(value_b, Some(44));/// assert_eq!(value_c, Some(66));/// The [`scope` function] has more extensive documentation about/// task spawning./// [`scope` function]: fn.scope.html/// Spawns a job into every thread of the fork-join scope `self`. This job will/// execute on each thread sometime before the fork-join scope completes.  The/// job is specified as a closure, and this closure receives its own reference/// to the scope `self` as argument, as well as a `BroadcastContext`./// This method is akin to [`Scope::spawn()`], but with a FIFO/// priority.  The [`scope_fifo` function] has more details about/// this distinction./// [`Scope::spawn()`]: struct.Scope.html#method.spawn/// [`scope_fifo` function]: fn.scope_fifo.html/// Creates the base of a new scope for the given registryFUNCheap_job_ref/// Executes `func` as a job, either aborting or executing as/// appropriate.execute_jobexecute_job_closure/// Executes `func` as a job in scope. Adjusts the "job completed"/// counters and also catches any panic and stores it into/// `scope`.job_panickedmaybe_propagate_panicScopePtr/// Used to capture a scope `&Self` pointer in jobs, without faking a lifetime./// Unsafe code is still required to dereference the pointer, but that's fine in/// scope jobs that are guaranteed to execute before the scope ends.// Helper to avoid disjoint captures of `scope_ptr.0`//! Methods for custom fork-join scopes, created by the [`scope()`]//! and [`in_place_scope()`] functions. These are a more flexible alternative to [`join()`].//! [`in_place_scope()`]: fn.in_place_scope.html//! [`join()`]: ../join/join.fn.htmlscope_emptyscope_resultscope_twoscope_divide_and_conquerdivide_and_conquer_sequpdate_in_scoperandom_treerandom_tree1update_treelinear_stack_growth/// Check that if you have a chain of scoped tasks where T0 spawns T1/// spawns T2 and so forth down to Tn, the stack space should not grow/// linearly with N. We test this by some unsafe hackery and/// permitting an approx 10% change with a 10x input change.the_final_countdownpanic_propagate_scopepanic_propagate_spawnpanic_propagate_nested_spawnpanic_propagate_nested_scope_spawnpanic_propagate_still_execute_1panic_propagate_still_execute_2panic_propagate_still_execute_3panic_propagate_still_execute_4test_orderlifo_orderfifo_ordertest_nested_ordernested_lifo_ordernested_fifo_ordernested_lifo_fifo_ordernested_fifo_lifo_orderspawn_pushtest_mixed_order/// Test spawns pushing a series of numbers, interleaved/// such that negative values are using an inner scope.mixed_lifo_ordermixed_fifo_ordermixed_lifo_fifo_ordermixed_fifo_lifo_orderstatic_scope_fifomixed_lifetime_scopemixed_lifetime_scope_fifoscope_spawn_broadcastscope_fifo_spawn_broadcastscope_spawn_broadcast_nestedscope_spawn_broadcast_barrierscope_spawn_broadcast_panic_onescope_spawn_broadcast_panic_many/// Packs together a number of counters. The counters are ordered as/// follows, from least to most significant bits (here, we assuming/// that [`THREADS_BITS`] is equal to 10):/// * Bits 0..10: Stores the number of **sleeping threads**/// * Bits 10..20: Stores the number of **inactive threads**/// * Bits 20..: Stores the **job event counter** (JEC)/// This uses 10 bits ([`THREADS_BITS`]) to encode the number of threads. Note/// that the total number of bits (and hence the number of bits used for the/// JEC) will depend on whether we are using a 32- or 64-bit architecture.AtomicCountersJobsEventCounter/// A value read from the **Jobs Event Counter**./// See the [`README.md`](README.md) for more/// coverage of how the jobs event counter works.DUMMYis_sleepy/// The JEC "is sleepy" if the last thread to increment it was in the/// process of becoming sleepy. This is indicated by its value being *even*./// When new jobs are posted, they check if the JEC is sleepy, and if so/// they incremented it./// The JEC "is active" if the last thread to increment it was posting new/// work. This is indicated by its value being *odd*. When threads get/// sleepy, they will check if the JEC is active, and increment it.THREADS_BITS/// Number of bits used for the thread counters.SLEEPING_SHIFT/// Bits to shift to select the sleeping threads/// (used with `select_bits`).INACTIVE_SHIFT/// Bits to shift to select the inactive threadsJEC_SHIFT/// Bits to shift to select the JEC/// (use JOBS_BITS).THREADS_MAX/// Max value for the thread counters.ONE_SLEEPING/// Constant that can be added to add one sleeping thread.ONE_INACTIVE/// Constant that can be added to add one inactive thread./// An inactive thread is either idle, sleepy, or sleeping.ONE_JEC/// Constant that can be added to add one to the JEC./// Load and return the current value of the various counters./// This value can then be given to other method which will/// attempt to update the counters via compare-and-swap.try_exchangeadd_inactive_thread/// Adds an inactive thread. This cannot fail./// This should be invoked when a thread enters its idle loop looking/// for work. It is decremented when work is found. Note that it is/// not decremented if the thread transitions from idle to sleepy or sleeping;/// so the number of inactive threads is always greater-than-or-equal/// to the number of sleeping threads.increment_jobs_event_counter_if/// Increments the jobs event counter if `increment_when`, when applied to/// the current value, is true. Used to toggle the JEC from even (sleepy) to/// odd (active) or vice versa. Returns the final value of the counters, for/// which `increment_when` is guaranteed to return false.sub_inactive_thread/// Subtracts an inactive thread. This cannot fail. It is invoked/// when a thread finds work and hence becomes active. It returns the/// number of sleeping threads to wake up (if any)./// See `add_inactive_thread`.sub_sleeping_thread/// Subtracts a sleeping thread. This cannot fail, but it is only/// safe to do if you you know the number of sleeping threads is/// non-zero (i.e., because you have just awoken a sleeping/// thread).try_add_sleeping_threadselect_threadselect_jecincrement_jobs_counterjobs_counterinactive_threads/// The number of threads that are not actively/// executing work. They may be idle, sleepy, or asleep.awake_but_idle_threadssleeping_threadsworker_sleep_statesWorkerSleepState/// One "sleep state" per worker. Used to track if a worker is sleeping and to have/// them block./// The `Sleep` struct is embedded into each registry. It governs the waking and sleeping/// of workers. It has callbacks that are invoked periodically at significant events,/// such as when workers are looping and looking for work, when latches are set, or when/// jobs are published, and it either blocks threads or wakes them in response to these/// events. See the [`README.md`] in this module for more details./// [`README.md`] README.md/// What is worker index of the idle thread?/// How many rounds have we been circling without sleeping?/// Once we become sleepy, what was the sleepy counter value?/// Set to `INVALID_SLEEPY_COUNTER` otherwise.IdleState/// An instance of this struct is created when a thread becomes idle./// It is consumed when the thread finds work, and passed by `&mut`/// reference for operations that preserve the idle state. (In other/// words, producing one of these structs is evidence the thread is/// idle.) It tracks state such as how long the thread has been idle./// Set to true when the worker goes to sleep; set to false when/// the worker is notified or when it wakes./// The "sleep state" for an individual worker.ROUNDS_UNTIL_SLEEPYROUNDS_UNTIL_SLEEPINGstart_lookingwork_foundno_work_foundannounce_sleepy/// Notify the given thread that it should wake up (if it is/// sleeping).  When this method is invoked, we typically know the/// thread is asleep, though in rare cases it could have been/// awoken by (e.g.) new work having been posted.new_injected_jobs/// Signals that `num_jobs` new jobs were injected into the thread/// pool from outside. This function will ensure that there are/// threads available to process them, waking threads from sleep/// - `num_jobs` -- lower bound on number of jobs available for stealing.///   We'll try to get at least one thread per job.new_internal_jobs/// Signals that `num_jobs` new jobs were pushed onto a thread's/// local deque. This function will try to ensure that there are/// if necessary. However, this is not guaranteed: under certain/// race conditions, the function may fail to wake any new/// threads; in that case the existing thread should eventually/// pop the job.new_jobs/// Common helper for `new_injected_jobs` and `new_internal_jobs`.wake_any_threadswake_specific_threadwake_fullywake_partly//! Code that decides when workers should go to sleep. See README.md//! for an overview./// Puts the task into the Rayon threadpool's job queue in the "static"/// or "global" scope. Just like a standard thread, this task is not/// tied to the current stack frame, and hence it cannot hold any/// references other than those with `'static` lifetime. If you want/// to spawn a task that references stack data, use [the `scope()`/// function][scope] to create a scope./// [scope]: fn.scope.html/// Since tasks spawned with this function cannot hold references into/// the enclosing stack frame, you almost certainly want to use a/// `move` closure as their argument (otherwise, the closure will/// typically hold references to any variables from the enclosing/// function that you happen to use)./// This API assumes that the closure is executed purely for its/// side-effects (i.e., it might send messages, modify data protected/// by a mutex, or some such thing)./// There is no guaranteed order of execution for spawns, given that/// other threads may steal tasks at any time. However, they are/// generally prioritized in a LIFO order on the thread from which/// they were spawned. Other threads always steal from the other end of/// the deque, like FIFO order.  The idea is that "recent" tasks are/// most likely to be fresh in the local CPU's cache, while other/// threads can steal older "stale" tasks.  For an alternate approach,/// consider [`spawn_fifo()`] instead./// [`spawn_fifo()`]: fn.spawn_fifo.html/// # Panic handling/// If this closure should panic, the resulting panic will be/// propagated to the panic handler registered in the `ThreadPoolBuilder`,/// if any.  See [`ThreadPoolBuilder::panic_handler()`][ph] for more/// [ph]: struct.ThreadPoolBuilder.html#method.panic_handler/// This code creates a Rayon task that increments a global counter./// use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};/// static GLOBAL_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;/// rayon::spawn(move || {///     GLOBAL_COUNTER.fetch_add(1, Ordering::SeqCst);spawn_in/// Spawns an asynchronous job in `registry.`spawn_job/// Fires off a task into the Rayon threadpool in the "static" or/// "global" scope.  Just like a standard thread, this task is not/// to spawn a task that references stack data, use [the `scope_fifo()`/// function](fn.scope_fifo.html) to create a scope./// The behavior is essentially the same as [the `spawn`/// function](fn.spawn.html), except that calls from the same thread/// will be prioritized in FIFO order. This is similar to the now-/// deprecated [`breadth_first`] option, except the effect is isolated/// to relative `spawn_fifo` calls, not all threadpool tasks.spawn_fifo_in/// Spawns an asynchronous FIFO job in `registry.`spawn_then_join_in_workerspawn_then_join_outside_workerpanic_fwdtermination_while_things_are_executing/// Test what happens when the thread-pool is dropped but there are/// still active asynchronous tasks. We expect the thread-pool to stay/// alive and executing until those threads are complete.custom_panic_handler_and_spawncustom_panic_handler_and_nested_spawnlifo_fifo_orderfifo_lifo_orderspawn_send/// Test mixed spawns pushing a series of numbers, interleaved such/// such that negative values are using the second kind of spawn.worker_thread_indexstart_callback_calledexit_callback_calledhandler_panics_handled_correctlycheck_config_build_send_sync/// Helper used by check_error_send_sync to ensure ThreadPoolBuildError is Send + Synccheck_error_send_syncdefault_poolcleared_current_thread/// Test that custom spawned threads get their `WorkerThread` cleared once/// the pool is done with them, allowing them to be used with rayon again/// later. e.g. WebAssembly want to have their own pool of available threads./// Represents a user created [thread-pool]./// Use a [`ThreadPoolBuilder`] to specify the number and/or names of threads/// in the pool. After calling [`ThreadPoolBuilder::build()`], you can then/// execute functions explicitly within this [`ThreadPool`] using/// [`ThreadPool::install()`]. By contrast, top level rayon functions/// (like `join()`) will execute implicitly within the current thread-pool./// let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();/// [`install()`][`ThreadPool::install()`] executes a closure in one of the `ThreadPool`'s/// threads. In addition, any other rayon operations called inside of `install()` will also/// execute in the context of the `ThreadPool`./// When the `ThreadPool` is dropped, that's a signal for the threads it manages to terminate,/// they will complete executing any remaining work that you have spawned, and automatically/// terminate./// [thread-pool]: https://en.wikipedia.org/wiki/Thread_pool/// [`ThreadPool::new()`]: struct.ThreadPool.html#method.new/// [`ThreadPoolBuilder::build()`]: struct.ThreadPoolBuilder.html#method.build/// [`ThreadPool::install()`]: struct.ThreadPool.html#method.installinstall/// Executes `op` within the threadpool. Any attempts to use/// `join`, `scope`, or parallel iterators will then operate/// within that threadpool./// # Warning: thread-local data/// Because `op` is executing within the Rayon thread-pool,/// thread-local data from the current thread will not be/// accessible./// # Warning: execution order/// If the current thread is part of a different thread pool, it will try to/// keep busy while the `op` completes in its target pool, similar to/// calling [`ThreadPool::yield_now()`] in a loop. Therefore, it may/// potentially schedule other tasks to run on the current thread in the/// meantime. For example///     rayon::ThreadPoolBuilder::new().num_threads(1).build_global().unwrap();///     let pool = rayon_core::ThreadPoolBuilder::default().build().unwrap();///     let do_it = || {///         print!("one ");///         pool.install(||{});///         print!("two ");///     rayon::join(|| do_it(), || do_it());/// Since we configured just one thread in the global pool, one might/// expect `do_it()` to run sequentially, producing:/// one two one two/// However each call to `install()` yields implicitly, allowing rayon to/// run multiple instances of `do_it()` concurrently on the single, global/// thread. The following output would be equally valid:/// one one two two/// If `op` should panic, that panic will be propagated./// ## Using `install()`///    # use rayon_core as rayon;///    fn main() {///         let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();///         let n = pool.install(|| fib(20));///         println!("{}", n);///    fn fib(n: usize) -> usize {///         if n == 0 || n == 1 {///             return n;///         let (a, b) = rayon::join(|| fib(n - 1), || fib(n - 2)); // runs inside of `pool`///         return a + b;/// Executes `op` within every thread in the threadpool. Any attempts to use/// `join`, `scope`, or parallel iterators will then operate within that/// threadpool./// Broadcasts are executed on each thread after they have exhausted their/// local work queue, before they attempt work-stealing from other threads./// The goal of that strategy is to run everywhere in a timely manner/// *without* being too disruptive to current work. There may be alternative/// broadcast styles added in the future for more or less aggressive/// injection, if the need arises./// If `op` should panic on one or more threads, exactly one panic/// will be propagated, only after all threads have completed/// (or panicked) their own `op`.///    use std::sync::atomic::{AtomicUsize, Ordering};///         let pool = rayon::ThreadPoolBuilder::new().num_threads(5).build().unwrap();///         // The argument gives context, including the index of each thread.///         let v: Vec<usize> = pool.broadcast(|ctx| ctx.index() * ctx.index());///         assert_eq!(v, &[0, 1, 4, 9, 16]);///         // The closure can reference the local stack///         let count = AtomicUsize::new(0);///         pool.broadcast(|_| count.fetch_add(1, Ordering::Relaxed));///         assert_eq!(count.into_inner(), 5);/// Returns the (current) number of threads in the thread pool./// [`ThreadPoolBuilder`] that specifies the number of threads,/// then this number may vary over time in future versions (see [the/// If called from a Rayon worker thread in this thread-pool,/// returns the index of that thread; if not called from a Rayon/// thread, or called from a Rayon thread that belongs to a/// different thread-pool, returns `None`./// The index for a given thread will not change over the thread's/// lifetime. However, multiple threads may share the same index if/// they are in distinct thread-pools./// Currently, every thread-pool (including the global/// thread-pool) has a fixed number of threads, but this may/// change in future Rayon versions (see [the `num_threads()` method/// for details][snt]). In that case, the index for a/// thread would not change during its lifetime, but thread/// indices may wind up being reused if threads are terminated and/// restarted./// Returns true if the current worker thread currently has "local/// tasks" pending. This can be useful as part of a heuristic for/// deciding whether to spawn a new task or execute code on the/// current thread, particularly in breadth-first/// schedulers. However, keep in mind that this is an inherently/// racy check, as other worker threads may be actively "stealing"/// tasks from our local deque./// **Background:** Rayon's uses a [work-stealing] scheduler. The/// key idea is that each thread has its own [deque] of/// tasks. Whenever a new task is spawned -- whether through/// `join()`, `Scope::spawn()`, or some other means -- that new/// task is pushed onto the thread's *local* deque. Worker threads/// have a preference for executing their own tasks; if however/// they run out of tasks, they will go try to "steal" tasks from/// other threads. This function therefore has an inherent race/// with other active worker threads, which may be removing items/// from the local deque./// [work-stealing]: https://en.wikipedia.org/wiki/Work_stealing/// [deque]: https://en.wikipedia.org/wiki/Double-ended_queue/// Execute `oper_a` and `oper_b` in the thread-pool and return/// the results. Equivalent to `self.install(|| join(oper_a,/// oper_b))`./// Creates a scope that executes within this thread-pool./// Equivalent to `self.install(|| scope(...))`./// See also: [the `scope()` function][scope]./// Spawns from the same thread are prioritized in relative FIFO order./// Equivalent to `self.install(|| scope_fifo(...))`./// See also: [the `scope_fifo()` function][scope_fifo]./// [scope_fifo]: fn.scope_fifo.html/// Creates a scope that spawns work into this thread-pool./// See also: [the `in_place_scope()` function][in_place_scope]./// [in_place_scope]: fn.in_place_scope.html/// Creates a scope that spawns work into this thread-pool in FIFO order./// See also: [the `in_place_scope_fifo()` function][in_place_scope_fifo]./// [in_place_scope_fifo]: fn.in_place_scope_fifo.html/// Spawns an asynchronous task in this thread-pool. This task will/// run in the implicit, global scope, which means that it may outlast/// the current stack frame -- therefore, it cannot capture any references/// onto the stack (you will likely need a `move` closure)./// See also: [the `spawn()` function defined on scopes][spawn]./// [spawn]: struct.Scope.html#method.spawn/// See also: [the `spawn_fifo()` function defined on scopes][spawn_fifo]./// [spawn_fifo]: struct.ScopeFifo.html#method.spawn_fifo/// Cooperatively yields execution to Rayon./// This is similar to the general [`yield_now()`], but only if the current/// thread is part of *this* thread pool./// Returns `Some(Yield::Executed)` if anything was executed, `Some(Yield::Idle)` if/// nothing was available, or `None` if the current thread is not part this pool./// Cooperatively yields execution to local Rayon work./// This is similar to the general [`yield_local()`], but only if the current/// If called from a Rayon worker thread, returns the index of that/// thread within its current pool; if not called from a Rayon thread,/// See also: [the `ThreadPool::current_thread_index()` method]./// [m]: struct.ThreadPool.html#method.current_thread_index/// If called from a Rayon worker thread, indicates whether that/// thread's local deque still has pending tasks. Otherwise, returns/// `None`. For more information, see [the/// `ThreadPool::current_thread_has_pending_tasks()` method][m]./// [m]: struct.ThreadPool.html#method.current_thread_has_pending_tasks/// If the current thread is part of a rayon thread pool, this looks for a/// single unit of pending work in the pool, then executes it. Completion of/// that work might include nested work or further work stealing./// This is similar to [`std::thread::yield_now()`], but does not literally make/// that call. If you are implementing a polling loop, you may want to also/// yield to the OS scheduler yourself if no Rayon work was found./// nothing was available, or `None` if this thread is not part of any pool at all./// single unit of pending work in this thread's queue, then executes it./// Completion of that work might include nested work or further work stealing./// This is similar to [`yield_now()`], but does not steal from other threads.Executed/// Work was found and executed./// No available work was found./// Result of [`yield_now()`] or [`yield_local()`].//! Contains support for user-managed thread pools, represented by the//! the [`ThreadPool`] type (see that struct for details).//! [`ThreadPool`]: struct.ThreadPool.htmlpanic_propagateworkers_stopjoin_a_lotsleeper_stopcount_handler/// Creates a start/exit handler that increments an atomic counter.wait_for_counter/// Wait until a counter is no longer shared, then return its value.failed_thread_stackpanic_thread_nameself_installmutual_installmutual_install_sleepycheck_thread_pool_newtest_scope_orderscope_lifo_orderscope_fifo_ordertest_spawn_orderspawn_lifo_orderspawn_fifo_ordernested_fifo_scopesin_place_scope_no_deadlockin_place_scope_fifo_no_deadlockyield_now_to_spawnyield_local_to_spawnhalt_unwinding/// Executes `f` and captures any panic, translating that panic into a/// `Err` result. The assumption is that any panic will be propagated/// later with `resume_unwinding`, and hence `f` can be treated as/// exception safe.resume_unwindingAbortIfPanic//! Package up unwind recovery. Note that if you are in some sensitive//! place, you can use the `AbortIfPanic` helper to protect against//! accidental panics in the rayon code itself.CertificateSigningRequestDerPrimitiveDateTimemodelsDERWriterCrlDistributionPointCertificateSigningRequestkey_pairserialize_public_key_derPublicKeyDataENCODE_CONFIGwrite_distinguished_namewrite_dt_utc_or_generalizedwrite_x509_authority_key_identifierwrite_x509_extensionDistinguishedNameIssuerKeyIdMethodKeyUsagePurposeSanTypeSerialNumberCertificateParamssubject_public_key_info/// An issued certificate together with the parameters used to generate it./// Returns the certificate parameterskey_identifier/// Calculates a subject key identifier for the certificate subject's public key./// This key identifier is used in the SubjectKeyIdentifier X.509v3 extension./// Get the certificate in DER encoded format./// [`CertificateDer`] implements `Deref<Target = [u8]>` and `AsRef<[u8]>`, so you can easily/// extract the DER bytes from the return value./// Get the certificate in PEM encoded format.distinguished_nameis_caIsCakey_usagesextended_key_usagesExtendedKeyUsagePurposename_constraintsNameConstraints/// An optional list of certificate revocation list (CRL) distribution points as described/// in RFC 5280 Section 4.2.1.13[^1]. Each distribution point contains one or more URIs where/// an up-to-date CRL with scope including this certificate can be retrieved./// [^1]: <https://www.rfc-editor.org/rfc/rfc5280#section-4.2.1.13>CustomExtensionuse_authority_key_identifier_extension/// If `true`, the 'Authority Key Identifier' extension will be added to the generated certkey_identifier_method/// Method to generate key identifiers from public keys/// Defaults to a truncated SHA-256 digest. See [`KeyIdMethod`] for more information./// Parameters used for certificate generation/// Generate certificate parameters with reasonable defaultssigned_by/// Generate a new certificate from the given parameters, signed by the provided issuer./// The returned certificate will have its issuer field set to the subject of the/// provided `issuer`, and the authority key identifier extension will be populated using/// the subject public key of `issuer`. It will be signed by `issuer_key`./// Note that no validation of the `issuer` certificate is performed. Rcgen will not require/// the certificate to be a CA certificate, or have key usage extensions that allow signing./// The returned [`Certificate`] may be serialized using [`Certificate::der`] and/// [`Certificate::pem`].self_signed/// Generates a new self-signed certificate from the given parameters.from_ca_cert_pem/// Parses an existing ca certificate from the ASCII PEM format./// See [`from_ca_cert_der`](Self::from_ca_cert_der) for more details.from_ca_cert_der/// Parses an existing ca certificate from the DER format./// This function is only of use if you have an existing CA certificate/// you would like to use to sign a certificate generated by `rcgen`./// By providing the constructed [`CertificateParams`] and the [`KeyPair`]/// associated with your existing `ca_cert` you can use [`CertificateParams::signed_by()`]/// or [`crate::CertificateSigningRequestParams::signed_by()`] to issue new certificates/// using the CA cert./// In general this function only extracts the information needed for signing./// Other attributes of the [`Certificate`] may be left as defaults./// This function assumes the provided certificate is a CA. It will not check/// for the presence of the `BasicConstraints` extension, or perform any other/// [`rustls_pemfile::certs()`] is often used to obtain a [`CertificateDer`] from PEM input./// If you already have a byte slice containing DER, it can trivially be converted into/// [`CertificateDer`] using the [`Into`] trait./// [`rustls_pemfile::certs()`]: https://docs.rs/rustls-pemfile/latest/rustls_pemfile/fn.certs.htmlconvert_x509_is_caX509Certificateconvert_x509_subject_alternative_nameconvert_x509_key_usagesconvert_x509_extended_key_usagesconvert_x509_name_constraintsconvert_x509_general_subtreesGeneralSubtreewrite_extension_request_attribute/// Write a CSR extension request attribute as defined in [RFC 2985]./// [RFC 2985]: <https://datatracker.ietf.org/doc/html/rfc2985>write_key_usage/// Write a certificate's KeyUsage as defined in RFC 5280.write_extended_key_usagewrite_subject_alt_namesserialize_request/// Generate and serialize a certificate signing request (CSR)./// The constructed CSR will contain attributes based on the certificate parameters,/// and include the subject public key information from `subject_key`. Additionally,/// the CSR will be signed using the subject key./// Note that subsequent invocations of `serialize_request()` will not produce the exact/// same output.serialize_request_with_attributes/// Generate and serialize a certificate signing request (CSR) with custom PKCS #10 attributes./// as defined in [RFC 2986]./// the CSR will be self-signed using the subject key./// Note that subsequent invocations of `serialize_request_with_attributes()` will not produce the exact/// [RFC 2986]: <https://datatracker.ietf.org/doc/html/rfc2986#section-4>serialize_der_with_signerinsert_extended_key_usage/// Insert an extended key usage (EKU) into the parameters if it does not already existwrite_general_subtrees/// `AttributeType` of the `Attribute`, defined as an `OBJECT IDENTIFIER`./// DER-encoded values of the `Attribute`, defined by [RFC 2986] as:/// SET SIZE(1..MAX) OF ATTRIBUTE.&Type({IOSet}{@type})/// [RFC 2986]: https://datatracker.ietf.org/doc/html/rfc2986#section-4/// A PKCS #10 CSR attribute, as defined in [RFC 5280] and constrained/// by [RFC 2986]./// [RFC 5280]: <https://datatracker.ietf.org/doc/html/rfc5280#appendix-A.1>/// The content must be DER-encoded/// A custom extension of a certificate, as specified in/// [RFC 5280](https://tools.ietf.org/html/rfc5280#section-4.2)new_acme_identifier/// Creates a new acmeIdentifier extension for ACME TLS-ALPN-01/// as specified in [RFC 8737](https://tools.ietf.org/html/rfc8737#section-3)/// Panics if the passed `sha_digest` parameter doesn't hold 32 bytes (256 bits).from_oid_content/// Create a new custom extension with the specified contentset_criticality/// Sets the criticality flag of the extension.criticality/// Obtains the criticality flag of the extension./// Obtains the content of the extension.oid_components/// Obtains the OID components of the extensions, as u64 piecesDnTypeCountryName/// X520countryNameLocalityName/// X520LocalityNameStateOrProvinceName/// X520StateOrProvinceNameOrganizationName/// X520OrganizationNameOrganizationalUnitName/// X520OrganizationalUnitNameCommonName/// X520CommonNameCustomDnType/// Custom distinguished name type/// The attribute type of a distinguished name entryto_oidfrom_oid/// Generate a DnType for the provided OID/// anyExtendedKeyUsageServerAuth/// id-kp-serverAuthClientAuth/// id-kp-clientAuthCodeSigning/// id-kp-codeSigningEmailProtection/// id-kp-emailProtectionTimeStamping/// id-kp-timeStampingOcspSigning/// id-kp-OCSPSigning/// A custom purpose not from the pre-specified list of purposes/// One of the purposes contained in the [extended key usage extension](https://tools.ietf.org/html/rfc5280#section-4.2.1.12)permitted_subtrees/// A list of subtrees that the domain has to match.excluded_subtrees/// A list of subtrees that the domain must not match./// Any name matching an excluded subtree is invalid even if it also matches a permitted subtree./// The [NameConstraints extension](https://tools.ietf.org/html/rfc5280#section-4.2.1.10)/// (only relevant for CA certificates)Rfc822Name/// Also known as E-Mail addressDnsNameDirectoryNameCidrSubnetIpAddress/// General Subtree type./// This type has similarities to the [`SanType`] enum but is not equal./// For example, `GeneralSubtree` has CIDR subnets for ip addresses/// while [`SanType`] has IP addresses./// CIDR subnet, as per [RFC 4632](https://tools.ietf.org/html/rfc4632)/// You might know CIDR subnets better by their textual representation/// where they consist of an ip address followed by a slash and a prefix/// number, for example `192.168.99.0/24`./// The first field in the enum is the address, the second is the mask./// Both are specified in network byte order.from_addr_prefix/// Obtains the CidrSubnet from an ip address/// as well as the specified prefix number./// # use rcgen::CidrSubnet;/// // The "192.0.2.0/24" example from/// // https://tools.ietf.org/html/rfc5280#page-42/// let addr = IpAddr::from_str("192.0.2.0").unwrap();/// let subnet = CidrSubnet::from_addr_prefix(addr, 24);/// assert_eq!(subnet, CidrSubnet::V4([0xC0, 0x00, 0x02, 0x00], [0xFF, 0xFF, 0xFF, 0x00]));from_v4_prefix/// Obtains the CidrSubnet from an IPv4 address in network byte order/// as well as the specified prefix.from_v6_prefix/// Obtains the CidrSubnet from an IPv6 address in network byte order/// Obtains the CidrSubnet from the well-known/// addr/prefix notation./// let subnet = CidrSubnet::from_str("192.0.2.0/24").unwrap();date_time_ymd/// Helper to obtain an `OffsetDateTime` from year, month, day values/// The year, month, day values are assumed to be in UTC./// This helper function serves two purposes: first, so that you don't/// have to import the time crate yourself in order to specify date/// information, second so that users don't have to type unproportionately/// long code just to generate an instance of [`OffsetDateTime`].NoCa/// The certificate can only sign itselfExplicitNoCa/// The certificate can only sign itself, adding the extension and `CA:FALSE`Ca/// The certificate may be used to sign other certificates/// Whether the certificate is allowed to sign other certificatesUnconstrained/// No constraintConstrained/// Constrain to the contained number of intermediate certificates/// The path length constraint (only relevant for CA certificates)/// Sets an optional upper limit on the length of the intermediate certificate chain/// length allowed for this CA certificate (not including the end entity certificate).test_with_key_usagestest_with_key_usages_decipheronly_onlytest_with_extended_key_usages_anytest_with_extended_key_usages_othertest_not_windows_line_endingstest_pem_serializationload_ca_and_sign_certtest_key_identifier_from_caCertificateRevocationListDerCertificateRevocationListParamsCertificateRevocationList/// A certificate revocation list (CRL)/// extern crate rcgen;/// use rcgen::*;/// #[cfg(not(feature = "crypto"))]/// struct MyKeyPair { public_key: Vec<u8> }/// impl RemoteKeyPair for MyKeyPair {///   fn public_key(&self) -> &[u8] { &self.public_key }///   fn sign(&self, _: &[u8]) -> Result<Vec<u8>, rcgen::Error> { Ok(vec![]) }///   fn algorithm(&self) -> &'static SignatureAlgorithm { &PKCS_ED25519 }/// # fn main () {/// // Generate a CRL issuer./// let mut issuer_params = CertificateParams::new(vec!["crl.issuer.example.com".to_string()]).unwrap();/// issuer_params.serial_number = Some(SerialNumber::from(9999));/// issuer_params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);/// issuer_params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::DigitalSignature, KeyUsagePurpose::CrlSign];/// #[cfg(feature = "crypto")]/// let key_pair = KeyPair::generate().unwrap();/// let remote_key_pair = MyKeyPair { public_key: vec![] };/// let key_pair = KeyPair::from_remote(Box::new(remote_key_pair)).unwrap();/// let issuer = issuer_params.self_signed(&key_pair).unwrap();/// // Describe a revoked certificate./// let revoked_cert = RevokedCertParams{///   serial_number: SerialNumber::from(9999),///   revocation_time: date_time_ymd(2024, 06, 17),///   reason_code: Some(RevocationReason::KeyCompromise),///   invalidity_date: None,/// // Create a CRL signed by the issuer, revoking revoked_cert./// let crl = CertificateRevocationListParams{///   this_update: date_time_ymd(2023, 06, 17),///   next_update: date_time_ymd(2024, 06, 17),///   crl_number: SerialNumber::from(1234),///   issuing_distribution_point: None,///   revoked_certs: vec![revoked_cert],///   #[cfg(feature = "crypto")]///   key_identifier_method: KeyIdMethod::Sha256,///   #[cfg(not(feature = "crypto"))]///   key_identifier_method: KeyIdMethod::PreSpecified(vec![]),/// }.signed_by(&issuer, &key_pair).unwrap();///# }/// Returns the certificate revocation list (CRL) parameters./// Get the CRL in PEM encoded format./// Get the CRL in DER encoded format./// [`CertificateRevocationListDer`] implements `Deref<Target = [u8]>` and `AsRef<[u8]>`,/// so you can easily extract the DER bytes from the return value./// One or more URI distribution point names, indicating a place the current CRL can/// be retrieved. When present, SHOULD include at least one LDAP or HTTP URI./// A certificate revocation list (CRL) distribution point, to be included in a certificate's/// [distribution points extension](https://www.rfc-editor.org/rfc/rfc5280#section-4.2.1.13) or/// a CRL's [issuing distribution point extension](https://datatracker.ietf.org/doc/html/rfc5280#section-5.2.5)write_distribution_point_name_urisRevocationReasonKeyCompromiseCaCompromiseAffiliationChangedSupersededCessationOfOperationCertificateHold// 7 is not defined.PrivilegeWithdrawnAaCompromise/// Identifies the reason a certificate was revoked./// See [RFC 5280 §5.3.1][1]/// [1]: <https://www.rfc-editor.org/rfc/rfc5280#section-5.3.1>// Not much to add above the code name./// Issue date of the CRL./// The date by which the next CRL will be issued.crl_number/// A monotonically increasing sequence number for a given CRL scope and issuer.issuing_distribution_pointCrlIssuingDistributionPoint/// An optional CRL extension identifying the CRL distribution point and scope for a/// particular CRL as described in RFC 5280 Section 5.2.5[^1]./// [^1]: <https://datatracker.ietf.org/doc/html/rfc5280#section-5.2.5>revoked_certsRevokedCertParams/// A list of zero or more parameters describing revoked certificates included in the CRL./// Defaults to SHA-256./// Parameters used for certificate revocation list (CRL) generation/// Serializes the certificate revocation list (CRL)./// Including a signature from the issuing certificate authority's key.serialize_derdistribution_point/// The CRL's distribution point, containing a sequence of URIs the CRL can be retrieved from.CrlScope/// An optional description of the CRL's scope. If omitted, the CRL may contain/// both user certs and CA certs./// A certificate revocation list (CRL) issuing distribution point, to be included in a CRL's/// [issuing distribution point extension](https://datatracker.ietf.org/doc/html/rfc5280#section-5.2.5).UserCertsOnly/// The CRL contains only end-entity user certificates.CaCertsOnly/// The CRL contains only CA certificates./// Describes the scope of a CRL for an issuing distribution point extension./// Serial number identifying the revoked certificate./// The date at which the CA processed the revocation./// An optional reason code identifying why the certificate was revoked.invalidity_date/// An optional field describing the date on which it was known or suspected that the/// private key was compromised or the certificate otherwise became invalid. This date/// may be earlier than the [`RevokedCertParams::revocation_time`]./// Parameters used for describing a revoked certificate included in a [`CertificateRevocationList`]./// A public key, extracted from a CSR/// The algorithm used to generate the public key and sign the CSR./// A certificate signing request (CSR) that can be encoded to PEM or DER./// Get the PEM-encoded bytes of the certificate signing request./// Get the DER-encoded bytes of the certificate signing request./// [`CertificateSigningRequestDer`] implements `Deref<Target = [u8]>` and `AsRef<[u8]>`,/// Parameters for the certificate to be signed./// Public key to include in the certificate signing request.CertificateSigningRequestParams/// Parameters for a certificate signing request/// Parse a certificate signing request from the ASCII PEM format/// See [`from_der`](Self::from_der) for more details./// Parse a certificate signing request from DER-encoded bytes/// Currently, this only supports the `Subject Alternative Name` extension./// On encountering other extensions, this function will return an error./// [`rustls_pemfile::csr()`] is often used to obtain a [`CertificateSigningRequestDer`] from/// PEM input. If you already have a byte slice containing DER, it can trivially be converted/// into [`CertificateSigningRequestDer`] using the [`Into`] trait./// [`rustls_pemfile::csr()`]: https://docs.rs/rustls-pemfile/latest/rustls_pemfile/fn.csr.html/// Generate a new certificate based on the requested parameters, signed by the provided/// issuer./// The returned certificate will have its issuer field set to the subject of the provided/// `issuer`, and the authority key identifier extension will be populated using the subject/// public key of `issuer`. It will be signed by `issuer_key`.CouldNotParseCertificate/// The given certificate couldn't be parsedCouldNotParseCertificationRequest/// The given certificate signing request couldn't be parsedCouldNotParseKeyPair/// The given key pair couldn't be parsedInvalidNameType/// Invalid subject alternative name typeInvalidAsn1String/// Invalid ASN.1 stringInvalidIpAddressOctetLength/// An IP address was provided as a byte array, but the byte array was an invalid length.KeyGenerationUnavailable/// There is no support for generating/// keys for the given algorithm/// Unsupported extension requested in CSRUnsupportedSignatureAlgorithm/// The requested signature algorithm is not supportedRingUnspecified/// Unspecified `ring` errorRingKeyRejected/// The `ring` library rejected the key upon loading/// Time conversion related errors/// Error from the pem crateRemoteKeyError/// Error generated by a remote key operationUnsupportedInCsr/// Unsupported field when generating a CSRInvalidCrlNextUpdate/// Invalid certificate revocation list (CRL) next update.IssuerNotCrlSigner/// CRL issuer specifies Key Usages that don't include cRLSign./// X509 parsing error/// The error type of the rcgen crate/// Invalid PrintableString type/// Invalid UniversalString type/// Invalid Ia5String type/// Invalid TeletexString type/// Invalid BmpString type/// Invalid ASN.1 string type_err/// A trait describing an error that can be converted into an `rcgen::Error`./// We use this trait to avoid leaking external error types into the public API/// through a `From<x> for Error` implementation.DERWriterSeqring_errorRingKeyPairRsaEncodingRsaKeyPairecdsa_from_pkcs8rsa_key_pair_public_modulus_lensign_algoSignAlgoKeyPairKindEc/// A Ecdsa key pairEd/// A Ed25519 key pair/// A RSA key pairRemoteKeyPair/// A remote key pair/// A key pair variant/// A key pair used to sign certificates and CSRs/// Note that ring, the underlying library to handle RSA keys/// requires them to be in a special format, meaning that/// `openssl genrsa` doesn't work. See ring's [documentation](ring::signature::RsaKeyPair::from_pkcs8)/// for how to generate RSA keys in the wanted format/// and conversion between the formats./// Generate a new random [`PKCS_ECDSA_P256_SHA256`] key pairgenerate_for/// Generate a new random key pair for the specified signature algorithm/// If you're not sure which algorithm to use, [`PKCS_ECDSA_P256_SHA256`] is a good choice./// If passed an RSA signature algorithm, it depends on the backend whether we return/// a generated key or an error for key generation being unavailable./// Currently, only `aws-lc-rs` supports RSA key generation./// Returns the key pair's signature algorithm/// Parses the key pair from the ASCII PEM format/// If `aws_lc_rs` feature is used, then the key must be a DER-encoded plaintext private key; as specified in PKCS #8/RFC 5958, SEC1/RFC 5915, or PKCS#1/RFC 3447;/// Appears as "PRIVATE KEY", "RSA PRIVATE KEY", or "EC PRIVATE KEY" in PEM files./// Otherwise if the `ring` feature is used, then the key must be a DER-encoded plaintext private key; as specified in PKCS #8/RFC 5958;/// Appears as "PRIVATE KEY" in PEM files.from_remote/// Obtains the key pair from a raw public key and a remote private keyfrom_pkcs8_pem_and_sign_algo/// Obtains the key pair from a DER formatted key/// using the specified [`SignatureAlgorithm`]/// The key must be a DER-encoded plaintext private key; as specified in PKCS #8/RFC 5958;/// Appears as "PRIVATE KEY" in PEM files/// Same as [from_pkcs8_pem_and_sign_algo](Self::from_pkcs8_pem_and_sign_algo).from_pkcs8_der_and_sign_algo/// Obtains the key pair from a DER formatted key using the specified [`SignatureAlgorithm`]/// If you have a [`PrivatePkcs8KeyDer`], you can usually rely on the [`TryFrom`] implementation/// to obtain a [`KeyPair`] -- it will determine the correct [`SignatureAlgorithm`] for you./// However, sometimes multiple signature algorithms fit for the same DER key. In those instances,/// you can use this function to precisely specify the `SignatureAlgorithm`./// [`rustls_pemfile::private_key()`] is often used to obtain a [`PrivateKeyDer`] from PEM/// input. If the obtained [`PrivateKeyDer`] is a `Pkcs8` variant, you can use its contents/// as input for this function. Alternatively, if you already have a byte slice containing DER,/// it can trivially be converted into [`PrivatePkcs8KeyDer`] using the [`Into`] trait./// [`rustls_pemfile::private_key()`]: https://docs.rs/rustls-pemfile/latest/rustls_pemfile/fn.private_key.html/// [`PrivateKeyDer`]: https://docs.rs/rustls-pki-types/latest/rustls_pki_types/enum.PrivateKeyDer.htmlfrom_pem_and_sign_algo/// Obtains the key pair from a PEM formatted key/// Same as [from_pem_and_sign_algo](Self::from_pem_and_sign_algo).from_der_and_sign_algo/// Note that using the `ring` feature, this function only support [`PrivateKeyDer::Pkcs8`] variant./// Consider using the `aws_lc_rs` features to support [`PrivateKeyDer`] fully./// If you have a [`PrivateKeyDer`], you can usually rely on the [`TryFrom`] implementation/// You can use [`rustls_pemfile::private_key`] to get the `key` input. If/// you have already a byte slice, just calling `try_into()` will convert it to a [`PrivateKeyDer`]./// [`rustls_pemfile::private_key`]: https://docs.rs/rustls-pemfile/latest/rustls_pemfile/fn.private_key.htmlpublic_key_raw/// Get the raw public key of this key pair/// The key is in raw format, as how [`ring::signature::KeyPair::public_key`]/// would output, and how [`ring::signature::UnparsedPublicKey::verify`]/// would accept./// Check if this key pair can be used with the given signature algorithmcompatible_algs/// Returns (possibly multiple) compatible [`SignatureAlgorithm`]'s/// that the key can be used withsign_derpublic_key_der/// Return the key pair's public key in DER format/// The key is formatted according to the SubjectPublicKeyInfo struct of/// X.509./// See [RFC 5280 section 4.1](https://tools.ietf.org/html/rfc5280#section-4.1).public_key_pem/// Return the key pair's public key in PEM format/// The returned string can be interpreted with `openssl pkey --inform PEM -pubout -pubin -text`/// Serializes the key pair (including the private key) in PKCS#8 format in DER/// Panics if called on a remote key pair./// Returns a reference to the serialized key pair (including the private key)/// in PKCS#8 format in DERas_remote/// Access the remote key pair if it is a remote oneserialize_pem/// Serializes the key pair (including the private key) in PKCS#8 format in PEM/// Returns the public key of this key pair in the binary format as in [`KeyPair::public_key_raw`]/// Signs `msg` using the selected algorithm/// Reveals the algorithm to be used when calling `sign()`/// A private key that is not directly accessible, but can be used to sign messages/// Trait objects based on this trait can be passed to the [`KeyPair::from_remote`] function for generating certificates/// from a remote and raw private key, for example an HSM.KeyRejectedsubject_public_key/// A public key/// Create a `SubjectPublicKey` value from a PEM-encoded SubjectPublicKeyInfo string/// Create a `SubjectPublicKey` value from DER-encoded SubjectPublicKeyInfo bytes/// The public key in DER format/// The algorithm used by the key pair/// The public key data of a key pairECDSA_P256_SHA256_FIXED_SIGNINGtest_subject_public_key_parsingtest_algorithmTAG_BMPSTRINGTAG_TELETEXSTRINGTAG_UNIVERSALSTRINGstring_typesRcgenError/// Type-alias for the old name of [`Error`]./// An issued certificate./// The certificate's subject key pair./// An issued certificate, together with the subject keypair./**
KISS function to generate a self signed certificate

Given a set of domain names you want your certificate to be valid for,
this function fills in the other generation parameters with
reasonable defaults and generates a self signed certificate
and key pair as output.
*/OtherNameValue/// The type of subject alt name/// A string encoded using UTF-8/// An `OtherName` value, defined in [RFC 5280§4.1.2.4]./// While the standard specifies this could be any ASN.1 type rcgen limits/// the value to a UTF-8 encoded string as this will cover the most common/// use cases, for instance smart card user principal names (UPN)./// [RFC 5280§4.1.2.4]: https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.4ip_addr_from_octetstry_from_generalDnValue/// A string encoded using UCS-2/// An ASCII string./// An ASCII string containing only A-Z, a-z, 0-9, '()+,-./:=? and `<SPACE>`/// A string of characters from the T.61 character set/// A string encoded using UTF-32/// A distinguished name entry/**
Distinguished name used e.g. for the issuer and subject fields of a certificate

A distinguished name is a set of (attribute type, attribute value) tuples.

This datastructure keeps them ordered by insertion order.

See also the RFC 5280 sections on the [issuer](https://tools.ietf.org/html/rfc5280#section-4.1.2.4)
and [subject](https://tools.ietf.org/html/rfc5280#section-4.1.2.6) fields.
*//// Creates a new, empty distinguished name/// Obtains the attribute value for the given attribute type/// Removes the attribute with the specified DnType/// Returns true when an actual removal happened, false/// when no attribute with the specified DnType was/// Inserts or updates an attribute that consists of type and name/// # use rcgen::{DistinguishedName, DnType, DnValue};/// let mut dn = DistinguishedName::new();/// dn.push(DnType::OrganizationName, "Crab widgits SE");/// dn.push(DnType::CommonName, DnValue::PrintableString("Master Cert".try_into().unwrap()));/// assert_eq!(dn.get(&DnType::OrganizationName), Some(&DnValue::Utf8String("Crab widgits SE".to_string())));/// assert_eq!(dn.get(&DnType::CommonName), Some(&DnValue::PrintableString("Master Cert".try_into().unwrap())));DistinguishedNameIterator/// Iterate over the entries/**
Iterator over [`DistinguishedName`] entries
*/DigitalSignature/// digitalSignatureContentCommitment/// contentCommitment / nonRepudiationKeyEncipherment/// keyEnciphermentDataEncipherment/// dataEnciphermentKeyAgreement/// keyAgreementKeyCertSign/// keyCertSignCrlSign/// cRLSignEncipherOnly/// encipherOnlyDecipherOnly/// decipherOnly/// One of the purposes contained in the [key usage](https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.3) extension/// Encode a key usage as the value of a BIT STRING as defined by RFC 5280./// [`u16`] is sufficient to encode the largest possible key usage value (two bytes)./// Parse a collection of key usages from a [`u16`] representing the value/// of a KeyUsage BIT STRING as defined by RFC 5280./// RFC 7093 method 1 - a truncated SHA256 digest./// RFC 7093 method 2 - a truncated SHA384 digest./// RFC 7093 method 3 - a truncated SHA512 digest.PreSpecified/// Pre-specified identifier. The exact given value is used as the key identifier./// Method to generate key identifiers from public keys./// Key identifiers should be derived from the public key data. [RFC 7093] defines/// three methods to do so using a choice of SHA256 (method 1), SHA384 (method 2), or SHA512/// (method 3). In each case the first 160 bits of the hash are used as the key identifier/// to match the output length that would be produced were SHA1 used (a legacy option defined/// in RFC 5280)./// In addition to the RFC 7093 mechanisms, rcgen supports using a pre-specified key identifier./// This can be helpful when working with an existing `Certificate`./// [RFC 7093]: https://www.rfc-editor.org/rfc/rfc7093/// Derive a key identifier for the provided subject public key info using the key ID method./// Typically this is a truncated hash over the raw subject public key info, but may/// be a pre-specified value./// This key identifier is used in the SubjectKeyIdentifier and AuthorityKeyIdentifier/// X.509v3 extensions.dt_strip_nanosdt_to_generalized/// Serializes an X.509v3 extension according to RFC 5280/// Serializes an X.509v3 authority key identifier extension according to RFC 5280./// A certificate serial number./// Create a serial number from the given byte slice./// Return the byte representation of the serial number./// Return the length of the serial number in bytes.test_dt_utc_strip_nanostest_dt_to_generalizedsignature_algos_differenttoo_manytest_ip_address_from_octetswith_ipv4test_san_type_from_general_name/*!
Rust X.509 certificate generation utility

This crate provides a way to generate self signed X.509 certificates.

The most simple way of using this crate is by calling the
[`generate_simple_self_signed`] function.
For more customization abilities, construct a [`CertificateParams`] and
a key pair to call [`CertificateParams::signed_by()`] or [`CertificateParams::self_signed()`].
*/// https://tools.ietf.org/html/rfc5280#section-4.1.1// Example certs usable as reference:// Uses ECDSA: https://crt.sh/?asn1=607203242PKCS_9_AT_EXTENSION_REQUEST/// pkcs-9-at-extensionRequest in [RFC 2985](https://www.rfc-editor.org/rfc/rfc2985#appendix-A)/// id-at-countryName in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-at-localityName in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-at-stateOrProvinceName in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)ORG_NAME/// id-at-organizationName in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)ORG_UNIT_NAME/// id-at-organizationalUnitName in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-at-commonName in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)EC_PUBLIC_KEY/// id-ecPublicKey in [RFC 5480](https://datatracker.ietf.org/doc/html/rfc5480#appendix-A)EC_SECP_256_R1/// secp256r1 in [RFC 5480](https://datatracker.ietf.org/doc/html/rfc5480#appendix-A)EC_SECP_384_R1/// secp384r1 in [RFC 5480](https://datatracker.ietf.org/doc/html/rfc5480#appendix-A)/// rsaEncryption in [RFC 4055](https://www.rfc-editor.org/rfc/rfc4055#section-6)RSASSA_PSS/// id-RSASSA-PSS in [RFC 4055](https://www.rfc-editor.org/rfc/rfc4055#section-6)/// id-ce-keyUsage in [RFC 5280](https://tools.ietf.org/html/rfc5280#appendix-A.2)/// id-ce-subjectAltName in [RFC 5280](https://tools.ietf.org/html/rfc5280#appendix-A.2)/// id-ce-basicConstraints in [RFC 5280](https://tools.ietf.org/html/rfc5280#appendix-A.2)/// id-ce-subjectKeyIdentifier in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-ce-authorityKeyIdentifier in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-ce-extKeyUsage in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-ce-nameConstraints in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)/// id-ce-cRLDistributionPoints in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)PE_ACME/// id-pe-acmeIdentifier in/// [IANA SMI Numbers registry](https://www.iana.org/assignments/smi-numbers/smi-numbers.xhtml#smi-numbers-1.3.6.1.5.5.7.1)/// id-ce-cRLNumber in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)CRL_REASONS/// id-ce-cRLReasons in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)CRL_INVALIDITY_DATE/// id-ce-invalidityDate in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)CRL_ISSUING_DISTRIBUTION_POINT/// id-ce-issuingDistributionPoint in [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280#appendix-A)EcdsaSigningAlgorithmSecureRandomEdDSAParametersEcDsaEdDsaSignatureAlgorithmParams/// Omit the parameters/// Write null parametershash_algorithmsalt_lengthRsaPss/// RSASSA-PSS-params as per RFC 4055oids_sign_algsign_alg/// Signature algorithm type/// The `Hash` trait is not derived, but implemented according to impl of the `PartialEq` trait/// Retrieve the SignatureAlgorithm for the provided OIDPKCS_RSA_SHA256/// RSA signing with PKCS#1 1.5 padding and SHA-256 hashing as per [RFC 4055](https://tools.ietf.org/html/rfc4055)PKCS_RSA_SHA384PKCS_RSA_SHA512/// RSA signing with PKCS#1 1.5 padding and SHA-512 hashing as per [RFC 4055](https://tools.ietf.org/html/rfc4055)PKCS_RSA_PSS_SHA256// TODO: not really sure whether the certs we generate actually work.// Both openssl and webpki reject them. It *might* be possible that openssl// accepts the certificate if the key is a proper RSA-PSS key, but ring doesn't// support those: https://github.com/briansmith/ring/issues/1353/// RSA signing with PKCS#1 2.1 RSASSA-PSS padding and SHA-256 hashing as per [RFC 4055](https://tools.ietf.org/html/rfc4055)PKCS_ECDSA_P256_SHA256/// ECDSA signing using the P-256 curves and SHA-256 hashing as per [RFC 5758](https://tools.ietf.org/html/rfc5758#section-3.2)PKCS_ECDSA_P384_SHA384/// ECDSA signing using the P-384 curves and SHA-384 hashing as per [RFC 5758](https://tools.ietf.org/html/rfc5758#section-3.2)PKCS_ED25519/// ED25519 curve signing as per [RFC 8410](https://tools.ietf.org/html/rfc8410)/// The list of supported signature algorithmsalg_ident_oidwrite_paramswrite_alg_ident/// Writes the algorithm identifier as it appears inside a signaturewrite_oids_sign_alg/// Writes the algorithm identifier as it appears inside subjectPublicKeyInfo// Signature algorithm IDs as per https://tools.ietf.org/html/rfc4055/// Supports a subset of the ASCII printable characters (described below)./// [`Ia5String`][`crate::Ia5String`]./// You can create a `PrintableString` from [a literal string][`&str`] with [`PrintableString::try_from`]:/// use rcgen::PrintableString;/// let hello = PrintableString::try_from("hello").unwrap();/// PrintableString is a subset of the [ASCII printable characters]./// For instance, `'@'` is a printable character as per ASCII but can't be part of [ASN.1's `PrintableString`]./// [ASCII printable characters]: https://en.wikipedia.org/wiki/ASCII#Printable_characters/// [ASN.1's `PrintableString`]: https://en.wikipedia.org/wiki/PrintableString/// Extracts a string slice containing the entire `PrintableString`./// Converts a `&str` to a [`PrintableString`]./// Any character not in the [`PrintableString`] charset will be rejected./// See [`PrintableString`] documentation for more information./// The result is allocated on the heap./// Converts a [`String`][`std::string::String`] into a [`PrintableString`]/// This conversion does not allocate or copy memory./// You can create a `Ia5String` from [a literal string][`&str`] with [`Ia5String::try_from`]:/// use rcgen::Ia5String;/// let hello = Ia5String::try_from("hello").unwrap();/// the 128 characters of the ASCII alphabet. (Note: IA5 is now/// For UTF-8, use [`String`][`std::string::String`]./// [International Alphabet No. 5 (IA5)]: https://en.wikipedia.org/wiki/T.50_(standard)/// Extracts a string slice containing the entire `Ia5String`./// Converts a `&str` to a [`Ia5String`]./// Any character not in the [`Ia5String`] charset will be rejected./// See [`Ia5String`] documentation for more information./// Converts a [`String`][`std::string::String`] into a [`Ia5String`]/// You can create a `TeletexString` from [a literal string][`&str`] with [`TeletexString::try_from`]:/// use rcgen::TeletexString;/// let hello = TeletexString::try_from("hello").unwrap();/// [mailing list], "a sizable volume of software in the world treats TeletexString (T61String) as a/// `TeletexString` is included for backward compatibility, [RFC 5280] say it/// SHOULD NOT be used for certificates for new subjects./// [mailing list]: https://www.mail-archive.com/asn1@asn1.org/msg00460.html/// [RFC 5280]: https://datatracker.ietf.org/doc/html/rfc5280#page-25/// Extracts a string slice containing the entire `TeletexString`./// Returns a byte slice of this `TeletexString`’s contents./// Converts a `&str` to a [`TeletexString`]./// Any character not in the [`TeletexString`] charset will be rejected./// See [`TeletexString`] documentation for more information./// Converts a [`String`][`std::string::String`] into a [`TeletexString`]/// You can create a `BmpString` from [a literal string][`&str`] with [`BmpString::try_from`]:/// use rcgen::BmpString;/// let hello = BmpString::try_from("hello").unwrap();/// Bytes are encoded as UTF-16 big-endian./// `BMPString` is included for backward compatibility, [RFC 5280] say it/// Returns a byte slice of this `BmpString`'s contents./// The inverse of this method is [`from_utf16be`]./// [`from_utf16be`]: BmpString::from_utf16be/// let s = BmpString::try_from("hello").unwrap();/// assert_eq!(&[0, 104, 0, 101, 0, 108, 0, 108, 0, 111], s.as_bytes());from_utf16be/// Decode a UTF-16BE–encoded vector `vec` into a `BmpString`, returning [Err](`std::result::Result::Err`) if `vec` contains any invalid data./// Converts a `&str` to a [`BmpString`]./// Any character not in the [`BmpString`] charset will be rejected./// See [`BmpString`] documentation for more information./// Converts a [`String`][`std::string::String`] into a [`BmpString`]/// Parsing a `BmpString` allocates memory since the UTF-8 to UTF-16 conversion requires a memory allocation./// ASN.1 `UniversalString` type./// You can create a `UniversalString` from [a literal string][`&str`] with [`UniversalString::try_from`]:/// use rcgen::UniversalString;/// let hello = UniversalString::try_from("hello").unwrap();/// The characters which can appear in the `UniversalString` type are any of the characters allowed by/// ISO/IEC 10646 (Unicode)./// Bytes are encoded like UTF-32 big-endian./// `UniversalString` is included for backward compatibility, [RFC 5280] say it/// Returns a byte slice of this `UniversalString`'s contents./// The inverse of this method is [`from_utf32be`]./// [`from_utf32be`]: UniversalString::from_utf32be/// let s = UniversalString::try_from("hello").unwrap();/// assert_eq!(&[0, 0, 0, 104, 0, 0, 0, 101, 0, 0, 0, 108, 0, 0, 0, 108, 0, 0, 0, 111], s.as_bytes());from_utf32be/// Decode a UTF-32BE–encoded vector `vec` into a `UniversalString`, returning [Err](`std::result::Result::Err`) if `vec` contains any invalid data./// Converts a `&str` to a [`UniversalString`]./// Any character not in the [`UniversalString`] charset will be rejected./// See [`UniversalString`] documentation for more information./// Converts a [`String`][`std::string::String`] into a [`UniversalString`]/// Parsing a `UniversalString` allocates memory since the UTF-8 to UTF-32 conversion requires a memory allocation.teletext_stringuniversal_stringFftNumFftPlannerResFftError/// The input buffer has the wrong size. The transform was not performed./// The first member of the tuple is the expected size and the second member is the received/// The output buffer has the wrong size. The transform was not performed.ScratchBuffer/// The scratch buffer has the wrong size. The transform was not performed./// The first member of the tuple is the minimum size and the second member is the receivedInputValues/// The input data contained a non-zero imaginary part where there should have been a zero./// The transform was performed, but the result may not be correct./// The first member of the tuple represents the first index of the complex buffer and the/// second member represents the last index of the complex buffer. The values are set to true/// if the corresponding complex value contains a non-zero imaginary part./// Custom error returned by FFTsfmt_internalcompute_twiddlefftFftscratch_lenRealToComplexOddtwiddlesRealToComplexEvenComplexToRealOddComplexToRealEven/// Transform a signal of N real-valued samples,/// storing the resulting complex spectrum in the N/2+1/// (with N/2 rounded down) element long output slice./// The input buffer is used as scratch space,/// so the contents of input should be considered garbage after calling./// It also allocates additional scratch space as needed./// An error is returned if any of the given slices has the wrong length.process_with_scratch/// similar to [`process()`](RealToComplex::process)./// The difference is that this method uses the provided/// scratch buffer instead of allocating new scratch space./// This is faster if the same scratch buffer is used for multiple calls.get_scratch_len/// Get the minimum length of the scratch buffer needed for `process_with_scratch`./// The FFT length./// Get the length of the real signal that this FFT takes as input.complex_len/// Get the number of complex data points that this FFT returns.make_input_vec/// Convenience method to make an input vector of the right type and length.make_output_vec/// Convenience method to make an output vector of the right type and length.make_scratch_vec/// Convenience method to make a scratch vector of the right type and length.RealToComplex/// A forward FFT that takes a real-valued input signal of length N/// and transforms it to a complex spectrum of length N/2+1./// Inverse transform a complex spectrum corresponding to a real-valued signal of length N./// The input is a slice of complex values with length N/2+1 (with N/2 rounded down)./// The resulting real-valued signal is stored in the output slice of length N./// If the input data is invalid, meaning that one of the positions that should/// contain a zero holds a non-zero value, the transform is still performed./// The function then returns an `FftError::InputValues` error to tell that the/// result may not be correct./// Inverse transform a complex spectrum,/// similar to [`process()`](ComplexToReal::process)./// Get the minimum length of the scratch space needed for `process_with_scratch`./// Get the length of the real-valued signal that this FFT returns./// Get the length of the slice slice of complex values that this FFT accepts as input.ComplexToReal/// An inverse FFT that takes a complex spectrum of length N/2+1/// and transforms it to a real-valued signal of length N.zip3plannerr2c_cachec2r_cacheRealFftPlanner/// A planner is used to create FFTs./// It caches results internally,/// so when making more than one FFT it is advisable to reuse the same planner./// Create a new planner.plan_fft_forward/// Plan a real-to-complex forward FFT. Returns the FFT in a shared reference./// If requesting a second forward FFT of the same length,/// the planner will return a new reference to the already existing one.plan_fft_inverse/// Plan a complex-to-real inverse FFT. Returns the FFT in a shared reference./// If requesting a second inverse FFT of the same length,/// Create a new RealToComplex forward FFT for real-valued input data of a given length,/// and uses the given FftPlanner to build the inner FFT./// Panics if the length is not odd./// Panics if the length is not even./// Create a new ComplexToRealOdd inverse FFT for complex input spectra./// The `length` parameter refers to the length of the resulting real-valued signal./// Uses the given FftPlanner to build the inner FFT./// Create a new ComplexToRealEven inverse FFT for complex input spectra.compare_complex// get the largest differencecompare_scalarscomplex_to_real_64// Compare ComplexToReal with standard inverse FFTcomplex_to_real_32complex_to_real_errors_even// Test that ComplexToReal returns the right errorscomplex_to_real_errors_oddreal_to_complex_64// Compare RealToComplex with standard FFTreal_to_complex_32// Check that the ? operator works on the custom errors. No need to run, just needs to compile.//! # RealFFT: Real-to-complex forward FFT and complex-to-real inverse FFT based on RustFFT//! This library is a wrapper for [RustFFT](https://crates.io/crates/rustfft)//! that enables fast and convenient FFT of real-valued data.//! The API is designed to be as similar as possible to RustFFT.//! Using this library instead of RustFFT directly avoids the need of converting//! real-valued data to complex before performing a FFT.//! If the length is even, it also enables faster computations by using a complex FFT of half the length.//! It then packs a real-valued signal of length N into an N/2 long complex buffer,//! which is transformed using a standard complex-to-complex FFT.//! The FFT result is then post-processed to give only the first half of the complex spectrum,//! as an N/2+1 long complex vector.//! The inverse FFT goes through the same steps backwards,//! to transform a complex spectrum of length N/2+1 to a real-valued signal of length N.//! The speed increase compared to just converting the input to a length N complex vector//! and using a length N complex-to-complex FFT depends on the length of the input data.//! The largest improvements are for longer FFTs and for lengths over around 1000 elements//! there is an improvement of about a factor 2.//! The difference shrinks for shorter lengths,//! and around 30 elements there is no longer any difference.//! ## Why use real-to-complex FFT?//! ### Using a complex-to-complex FFT//! A simple way to transform a real valued signal is to convert it to complex,//! and then use a complex-to-complex FFT.//! Let's assume `x` is a 6 element long real vector://! x = [x0r, x1r, x2r, x3r, x4r, x5r]//! We now convert `x` to complex by adding an imaginary part with value zero.//! Using the notation `(xNr, xNi)` for the complex value `xN`, this becomes://! x_c = [(x0r, 0), (x1r, 0), (x2r, 0), (x3r, 0), (x4r, 0), (x5r, 0)]//! Performing a normal complex FFT, the result of `FFT(x_c)` is://! FFT(x_c) = [(X0r, X0i), (X1r, X1i), (X2r, X2i), (X3r, X3i), (X4r, X4i), (X5r, X5i)]//! But because our `x_c` is real-valued (all imaginary parts are zero), some of this becomes redundant://! FFT(x_c) = [(X0r, 0), (X1r, X1i), (X2r, X2i), (X3r, 0), (X2r, -X2i), (X1r, -X1i)]//! The last two values are the complex conjugates of `X1` and `X2`. Additionally, `X0i` and `X3i` are zero.//! As we can see, the output contains 6 independent values, and the rest is redundant.//! But it still takes time for the FFT to calculate the redundant values.//! Converting the input data to complex also takes a little bit of time.//! If the length of `x` instead had been 7, result would have been://! FFT(x_c) = [(X0r, 0), (X1r, X1i), (X2r, X2i), (X3r, X3i), (X3r, -X3i), (X2r, -X2i), (X1r, -X1i)]//! The result is similar, but this time there is no zero at `X3i`.//! Also in this case we got the same number of independent values as we started with.//! ### Real-to-complex//! Using a real-to-complex FFT removes the need for converting the input data to complex.//! It also avoids calculating the redundant output values.//! The result for 6 elements is://! RealFFT(x) = [(X0r, 0), (X1r, X1i), (X2r, X2i), (X3r, 0)]//! The result for 7 elements is://! RealFFT(x) = [(X0r, 0), (X1r, X1i), (X2r, X2i), (X3r, X3i)]//! This is the data layout output by the real-to-complex FFT,//! and the one expected as input to the complex-to-real inverse FFT.//! ## Scaling//! RealFFT matches the behaviour of RustFFT and does not normalize the output of either forward or inverse FFT.//! To get normalized results, each element must be scaled by `1/sqrt(length)`,//! where `length` is the length of the real-valued signal.//! If the processing involves both a forward and an inverse FFT step,//! it is advisable to merge the two normalization steps to a single, by scaling by `1/length`.//! ## Documentation//! The full documentation can be generated by rustdoc. To generate and view it run://! cargo doc --open//! ## Benchmarks//! To run a set of benchmarks comparing real-to-complex FFT with standard complex-to-complex, type://! cargo bench//! The results are printed while running, and are compiled into an html report containing much more details.//! To view, open `target/criterion/report/index.html` in a browser.//! Transform a signal, and then inverse transform the result.//! use realfft::RealFftPlanner;//! use rustfft::num_complex::Complex;//! use rustfft::num_traits::Zero;//! let length = 256;//! // make a planner//! let mut real_planner = RealFftPlanner::<f64>::new();//! // create a FFT//! let r2c = real_planner.plan_fft_forward(length);//! // make a dummy real-valued signal (filled with zeros)//! let mut indata = r2c.make_input_vec();//! // make a vector for storing the spectrum//! let mut spectrum = r2c.make_output_vec();//! // Are they the length we expect?//! assert_eq!(indata.len(), length);//! assert_eq!(spectrum.len(), length/2+1);//! // forward transform the signal//! r2c.process(&mut indata, &mut spectrum).unwrap();//! // create an inverse FFT//! let c2r = real_planner.plan_fft_inverse(length);//! // create a vector for storing the output//! let mut outdata = c2r.make_output_vec();//! assert_eq!(outdata.len(), length);//! // inverse transform the spectrum back to a real-valued signal//! c2r.process(&mut spectrum, &mut outdata).unwrap();//! ### Versions//! - 3.3.0: Add method for getting the length of the complex input/output.//!          Bugfix: clean up numerical noise in the zero imaginary components.//! - 3.2.0: Allow scratch buffer to be larger than needed.//! - 3.1.0: Update to RustFFT 6.1 with Neon support.//! - 3.0.2: Fix confusing typos in errors about scratch length.//! - 3.0.1: More helpful error messages, fix confusing typos.//! - 3.0.0: Improved error reporting.//! - 2.0.1: Minor bugfix.//! - 2.0.0: Update RustFFT to 6.0.0 and num-complex to 0.4.0.//! - 1.1.0: Add missing Sync+Send.//! - 1.0.0: First version with new api.//! ### Compatibility//! The `realfft` crate has the same rustc version requirements as RustFFT.//! The minimum rustc version is 1.37 on all platforms except AArch64.//! On AArch64 the minimum rustc version is 1.61.thompsonWhichCapturesmetacsyntaxc/// A builder for constructing a `Regex`, `bytes::Regex`, `RegexSet` or a/// `bytes::RegexSet`./// This is essentially the implementation of the four different builder types/// in the public API: `RegexBuilder`, `bytes::RegexBuilder`, `RegexSetBuilder`/// and `bytes::RegexSetBuilder`.build_one_stringbuild_one_bytesbuild_many_stringbuild_many_bytesline_terminatornest_limitRegexBuilder/// A configurable builder for a [`Regex`]./// This builder can be used to programmatically set flags such as `i`/// (case insensitive) and `x` (for verbose mode). This builder can also be/// used to configure things like the line terminator and a size limit on/// the compiled regular expression./// Create a new builder with a default configuration for the given/// If the pattern is invalid or exceeds the configured size limits,/// then an error will be returned when [`RegexBuilder::build`] is/// Compiles the pattern given to `RegexBuilder::new` with the/// configuration set on this builder./// If the pattern isn't a valid regex or if a configured size limit/// was exceeded, then an error is returned./// This configures Unicode mode for the entire pattern./// Enabling Unicode mode does a number of things:/// * Most fundamentally, it causes the fundamental atom of matching/// to be a single codepoint. When Unicode mode is disabled, it's a/// single byte. For example, when Unicode mode is enabled, `.` will/// match `💩` once, where as it will match 4 times when Unicode mode/// is disabled. (Since the UTF-8 encoding of `💩` is 4 bytes long.)/// * Case insensitive matching uses Unicode simple case folding rules./// * Unicode character classes like `\p{Letter}` and `\p{Greek}` are/// * Perl character classes are Unicode aware. That is, `\w`, `\s` and/// `\d`./// * The word boundary assertions, `\b` and `\B`, use the Unicode/// definition of a word character./// Note that if Unicode mode is disabled, then the regex will fail to/// compile if it could match invalid UTF-8. For example, when Unicode/// mode is disabled, then since `.` matches any byte (except for/// `\n`), then it can match invalid UTF-8 and thus building a regex/// from it will fail. Another example is `\w` and `\W`. Since `\w` can/// only match ASCII bytes when Unicode mode is disabled, it's allowed./// But `\W` can match more than ASCII bytes, including invalid UTF-8,/// and so it is not allowed. This restriction can be lifted only by/// using a [`bytes::Regex`](crate::bytes::Regex)./// For more details on the Unicode support in this crate, see the/// [Unicode section](crate#unicode) in this crate's top-level/// The default for this is `true`./// use regex::RegexBuilder;/// let re = RegexBuilder::new(r"\w")///     .unicode(false)/// // Normally greek letters would be included in \w, but since/// // Unicode mode is disabled, it only matches ASCII letters./// assert!(!re.is_match("δ"));/// let re = RegexBuilder::new(r"s")///     .case_insensitive(true)/// // Normally 'ſ' is included when searching for 's' case/// // insensitively due to Unicode's simple case folding rules. But/// // when Unicode mode is disabled, only ASCII case insensitive rules/// // are used./// assert!(!re.is_match("ſ"));/// This configures whether to enable case insensitive matching for the/// entire pattern./// This setting can also be configured using the inline flag `i`/// in the pattern. For example, `(?i:foo)` matches `foo` case/// insensitively while `(?-i:foo)` matches `foo` case sensitively./// The default for this is `false`./// let re = RegexBuilder::new(r"foo(?-i:bar)quux")/// assert!(re.is_match("FoObarQuUx"));/// // Even though case insensitive matching is enabled in the builder,/// // it can be locally disabled within the pattern. In this case,/// // `bar` is matched case sensitively./// assert!(!re.is_match("fooBARquux"));/// This configures multi-line mode for the entire pattern./// Enabling multi-line mode changes the behavior of the `^` and `$`/// anchor assertions. Instead of only matching at the beginning and/// end of a haystack, respectively, multi-line mode causes them to/// match at the beginning and end of a line *in addition* to the/// beginning and end of a haystack. More precisely, `^` will match at/// the position immediately following a `\n` and `$` will match at the/// position immediately preceding a `\n`./// The behavior of this option can be impacted by other settings too:/// * The [`RegexBuilder::line_terminator`] option changes `\n` above/// to any ASCII byte./// * The [`RegexBuilder::crlf`] option changes the line terminator to/// be either `\r` or `\n`, but never at the position between a `\r`/// and `\n`./// This setting can also be configured using the inline flag `m` in/// the pattern./// let re = RegexBuilder::new(r"^foo$")///     .multi_line(true)/// assert_eq!(Some(1..4), re.find("\nfoo\n").map(|m| m.range()));/// This configures dot-matches-new-line mode for the entire pattern./// Perhaps surprisingly, the default behavior for `.` is not to match/// any character, but rather, to match any character except for the/// line terminator (which is `\n` by default). When this mode is/// enabled, the behavior changes such that `.` truly matches any/// This setting can also be configured using the inline flag `s` in/// the pattern. For example, `(?s:.)` and `\p{any}` are equivalent/// regexes./// let re = RegexBuilder::new(r"foo.bar")///     .dot_matches_new_line(true)/// let hay = "foo\nbar";/// assert_eq!(Some("foo\nbar"), re.find(hay).map(|m| m.as_str()));/// This configures CRLF mode for the entire pattern./// When CRLF mode is enabled, both `\r` ("carriage return" or CR for/// short) and `\n` ("line feed" or LF for short) are treated as line/// terminators. This results in the following:/// * Unless dot-matches-new-line mode is enabled, `.` will now match/// any character except for `\n` and `\r`./// * When multi-line mode is enabled, `^` will match immediately/// following a `\n` or a `\r`. Similarly, `$` will match immediately/// preceding a `\n` or a `\r`. Neither `^` nor `$` will ever match/// between `\r` and `\n`./// This setting can also be configured using the inline flag `R` in///     .crlf(true)/// let hay = "\r\nfoo\r\n";/// // If CRLF mode weren't enabled here, then '$' wouldn't match/// // immediately after 'foo', and thus no match would be found./// assert_eq!(Some("foo"), re.find(hay).map(|m| m.as_str()));/// This example demonstrates that `^` will never match at a position/// between `\r` and `\n`. (`$` will similarly not match between a `\r`/// and a `\n`.)/// let re = RegexBuilder::new(r"^")/// let hay = "\r\n\r\n";/// let ranges: Vec<_> = re.find_iter(hay).map(|m| m.range()).collect();/// assert_eq!(ranges, vec![0..0, 2..2, 4..4]);/// Configures the line terminator to be used by the regex./// The line terminator is relevant in two ways for a particular regex:/// * When dot-matches-new-line mode is *not* enabled (the default),/// then `.` will match any character except for the configured line/// terminator./// * When multi-line mode is enabled (not the default), then `^` and/// `$` will match immediately after and before, respectively, a line/// In both cases, if CRLF mode is enabled in a particular context,/// then it takes precedence over any configured line terminator./// This option cannot be configured from within the pattern./// The default line terminator is `\n`./// This shows how to treat the NUL byte as a line terminator. This can/// be a useful heuristic when searching binary data.///     .line_terminator(b'\x00')/// let hay = "\x00foo\x00";/// assert_eq!(Some(1..4), re.find(hay).map(|m| m.range()));/// This example shows that the behavior of `.` is impacted by this/// setting as well:/// let re = RegexBuilder::new(r".")/// assert!(re.is_match("\n"));/// assert!(!re.is_match("\x00"));/// This shows that building a regex will fail if the byte given/// is not ASCII and the pattern could result in matching invalid/// UTF-8. This is because any singular non-ASCII byte is not valid/// UTF-8, and it is not permitted for a [`Regex`] to match invalid/// UTF-8. (It is permissible to use a non-ASCII byte when building a/// [`bytes::Regex`](crate::bytes::Regex).)/// assert!(RegexBuilder::new(r".").line_terminator(0x80).build().is_err());/// // Note that using a non-ASCII byte isn't enough on its own to/// // cause regex compilation to fail. You actually have to make use/// // of it in the regex in a way that leads to matching invalid/// // UTF-8. If you don't, then regex compilation will succeed!/// assert!(RegexBuilder::new(r"a").line_terminator(0x80).build().is_ok());/// This configures swap-greed mode for the entire pattern./// When swap-greed mode is enabled, patterns like `a+` will become/// non-greedy and patterns like `a+?` will become greedy. In other/// words, the meanings of `a+` and `a+?` are switched./// This setting can also be configured using the inline flag `U` in/// let re = RegexBuilder::new(r"a+")///     .swap_greed(true)/// assert_eq!(Some("a"), re.find("aaa").map(|m| m.as_str()));/// This configures verbose mode for the entire pattern./// When enabled, whitespace will treated as insignifcant in the/// pattern and `#` can be used to start a comment until the next new/// Normally, in most places in a pattern, whitespace is treated/// literally. For example ` +` will match one or more ASCII whitespace/// When verbose mode is enabled, `\#` can be used to match a literal/// `#` and `\ ` can be used to match a literal ASCII whitespace/// Verbose mode is useful for permitting regexes to be formatted and/// broken up more nicely. This may make them more easily readable./// This setting can also be configured using the inline flag `x` in/// let pat = r"///     \b///     (?<first>\p{Uppercase}\w*)  # always start with uppercase letter///     [\s--\n]+                   # whitespace should separate names///     (?: # middle name can be an initial!///         (?:(?<initial>\p{Uppercase})\.|(?<middle>\p{Uppercase}\w*))///         [\s--\n]+///     )?///     (?<last>\p{Uppercase}\w*)/// let re = RegexBuilder::new(pat)///     .ignore_whitespace(true)/// let caps = re.captures("Harry Potter").unwrap();/// assert_eq!("Harry", &caps["first"]);/// assert_eq!("Potter", &caps["last"]);/// let caps = re.captures("Harry J. Potter").unwrap();/// // Since a middle name/initial isn't required for an overall match,/// // we can't assume that 'initial' or 'middle' will be populated!/// assert_eq!(Some("J"), caps.name("initial").map(|m| m.as_str()));/// assert_eq!(None, caps.name("middle").map(|m| m.as_str()));/// let caps = re.captures("Harry James Potter").unwrap();/// assert_eq!(None, caps.name("initial").map(|m| m.as_str()));/// assert_eq!(Some("James"), caps.name("middle").map(|m| m.as_str()));/// This configures octal mode for the entire pattern./// Octal syntax is a little-known way of uttering Unicode codepoints/// in a pattern. For example, `a`, `\x61`, `\u0061` and `\141` are all/// equivalent patterns, where the last example shows octal syntax./// While supporting octal syntax isn't in and of itself a problem,/// it does make good error messages harder. That is, in PCRE based/// regex engines, syntax like `\1` invokes a backreference, which is/// explicitly unsupported this library. However, many users expect/// backreferences to be supported. Therefore, when octal support/// is disabled, the error message will explicitly mention that/// backreferences aren't supported./// // Normally this pattern would not compile, with an error message/// // about backreferences not being supported. But with octal mode/// // enabled, octal escape sequences work./// let re = RegexBuilder::new(r"\141")///     .octal(true)/// assert!(re.is_match("a"));/// Sets the approximate size limit, in bytes, of the compiled regex./// This roughly corresponds to the number of heap memory, in/// bytes, occupied by a single regex. If the regex would otherwise/// approximately exceed this limit, then compiling that regex will/// The main utility of a method like this is to avoid compiling/// regexes that use an unexpected amount of resources, such as/// time and memory. Even if the memory usage of a large regex is/// acceptable, its search time may not be. Namely, worst case time/// complexity for search is `O(m * n)`, where `m ~ len(pattern)` and/// `n ~ len(haystack)`. That is, search time depends, in part, on the/// size of the compiled regex. This means that putting a limit on the/// size of the regex limits how much a regex can impact search time./// For more information about regex size limits, see the section on/// [untrusted inputs](crate#untrusted-input) in the top-level crate/// The default for this is some reasonable number that permits most/// patterns to compile successfully./// # if !cfg!(target_pointer_width = "64") { return; } // see #1041/// // It may surprise you how big some seemingly small patterns can/// // be! Since \w is Unicode aware, this generates a regex that can/// // match approximately 140,000 distinct codepoints./// assert!(RegexBuilder::new(r"\w").size_limit(45_000).build().is_err());/// Set the approximate capacity, in bytes, of the cache of transitions/// used by the lazy DFA./// While the lazy DFA isn't always used, in tends to be the most/// commonly use regex engine in default configurations. It tends to/// adopt the performance profile of a fully build DFA, but without the/// downside of taking worst case exponential time to build./// The downside is that it needs to keep a cache of transitions and/// states that are built while running a search, and this cache/// can fill up. When it fills up, the cache will reset itself. Any/// previously generated states and transitions will then need to be/// re-generated. If this happens too many times, then this library/// will bail out of using the lazy DFA and switch to a different regex/// engine./// If your regex provokes this particular downside of the lazy DFA,/// then it may be beneficial to increase its cache capacity. This will/// potentially reduce the frequency of cache resetting (ideally to/// `0`). While it won't fix all potential performance problems with/// the lazy DFA, increasing the cache capacity does fix some./// There is no easy way to determine, a priori, whether increasing/// this cache capacity will help. In general, the larger your regex,/// the more cache it's likely to use. But that isn't an ironclad rule./// For example, a regex like `[01]*1[01]{N}` would normally produce a/// fully build DFA that is exponential in size with respect to `N`./// The lazy DFA will prevent exponential space blow-up, but it cache/// is likely to fill up, even when it's large and even for smallish/// values of `N`./// If you aren't sure whether this helps or not, it is sensible to/// set this to some arbitrarily large number in testing, such as/// `usize::MAX`. Namely, this represents the amount of capacity that/// *may* be used. It's probably not a good idea to use `usize::MAX` in/// production though, since it implies there are no controls on heap/// memory used by this library during a search. In effect, set it to/// whatever you're willing to allocate for a single regex search./// Set the nesting limit for this parser./// The nesting limit controls how deep the abstract syntax tree is/// allowed to be. If the AST exceeds the given limit (e.g., with too/// many nested groups), then an error is returned by the parser./// The purpose of this limit is to act as a heuristic to prevent stack/// overflow for consumers that do structural induction on an AST using/// explicit recursion. While this crate never does this (instead using/// constant stack space and moving the call stack to the heap), other/// crates may./// This limit is not checked until the entire AST is parsed./// Therefore, if callers want to put a limit on the amount of heap/// space used, then they should impose a limit on the length, in/// bytes, of the concrete pattern string. In particular, this is/// viable since this parser implementation will limit itself to heap/// space proportional to the length of the pattern string. See also/// the [untrusted inputs](crate#untrusted-input) section in the/// top-level crate documentation for more information about this./// Note that a nest limit of `0` will return a nest limit error for/// most patterns but not all. For example, a nest limit of `0` permits/// `a` but not `ab`, since `ab` requires an explicit concatenation,/// which results in a nest depth of `1`. In general, a nest limit is/// not something that manifests in an obvious way in the concrete/// syntax, therefore, it should not be used in a granular way./// assert!(RegexBuilder::new(r"a").nest_limit(0).build().is_ok());/// assert!(RegexBuilder::new(r"ab").nest_limit(0).build().is_err());RegexSetBuilder/// A configurable builder for a [`RegexSet`]./// This builder can be used to programmatically set flags such as/// `i` (case insensitive) and `x` (for verbose mode). This builder/// can also be used to configure things like the line terminator/// and a size limit on the compiled regular expression./// If the patterns are invalid or exceed the configured size limits,/// then an error will be returned when [`RegexSetBuilder::build`] is/// Compiles the patterns given to `RegexSetBuilder::new` with the/// If the patterns aren't valid regexes or if a configured size limit/// This configures Unicode mode for the all of the patterns./// using a [`bytes::RegexSet`](crate::bytes::RegexSet)./// use regex::RegexSetBuilder;/// let re = RegexSetBuilder::new([r"\w"])/// let re = RegexSetBuilder::new([r"s"])/// This configures whether to enable case insensitive matching for all/// of the patterns./// let re = RegexSetBuilder::new([r"foo(?-i:bar)quux"])/// This configures multi-line mode for all of the patterns./// * The [`RegexSetBuilder::line_terminator`] option changes `\n`/// above to any ASCII byte./// * The [`RegexSetBuilder::crlf`] option changes the line terminator/// to be either `\r` or `\n`, but never at the position between a `\r`/// let re = RegexSetBuilder::new([r"^foo$"])/// assert!(re.is_match("\nfoo\n"));/// let re = RegexSetBuilder::new([r"foo.bar"])/// assert!(re.is_match(hay));/// This configures CRLF mode for all of the patterns./// let re = RegexSetBuilder::new([r"^\n"])/// assert!(!re.is_match("\r\n"));/// let re = RegexSetBuilder::new([r"."])/// UTF-8, and it is not permitted for a [`RegexSet`] to match invalid/// [`bytes::RegexSet`](crate::bytes::RegexSet).)///     RegexSetBuilder::new([r"."])///         .line_terminator(0x80)///         .build()///         .is_err()///     RegexSetBuilder::new([r"a"])///         .is_ok()/// This configures swap-greed mode for all of the patterns./// Note that this is generally not useful for a `RegexSet` since a/// `RegexSet` can only report whether a pattern matches or not. Since/// greediness never impacts whether a match is found or not (only the/// offsets of the match), it follows that whether parts of a pattern/// are greedy or not doesn't matter for a `RegexSet`./// This configures verbose mode for all of the patterns./// let re = RegexSetBuilder::new([pat])/// assert!(re.is_match("Harry Potter"));/// assert!(re.is_match("Harry J. Potter"));/// assert!(re.is_match("Harry James Potter"));/// assert!(!re.is_match("harry J. Potter"));/// This configures octal mode for all of the patterns./// let re = RegexSetBuilder::new([r"\141"])///     RegexSetBuilder::new([r"\w"])///         .size_limit(45_000)/// assert!(RegexSetBuilder::new([r"a"]).nest_limit(0).build().is_ok());/// assert!(RegexSetBuilder::new([r"ab"]).nest_limit(0).build().is_err());/// Note that unlike the top-level `Regex` for searching `&str`, it/// is permitted to disable Unicode mode even if the resulting pattern/// could match invalid UTF-8. For example, `(?-u:.)` is not a valid/// pattern for a top-level `Regex`, but is valid for a `bytes::Regex`./// use regex::bytes::RegexBuilder;/// assert!(!re.is_match("δ".as_bytes()));/// assert!(!re.is_match("ſ".as_bytes()));/// Since this builder is for constructing a [`bytes::Regex`](Regex),/// one can disable Unicode mode even if it would match invalid UTF-8:/// assert!(re.is_match(b"\xFF"));/// assert!(re.is_match(b"FoObarQuUx"));/// assert!(!re.is_match(b"fooBARquux"));/// assert_eq!(Some(1..4), re.find(b"\nfoo\n").map(|m| m.range()));/// let hay = b"foo\nbar";/// assert_eq!(Some(&b"foo\nbar"[..]), re.find(hay).map(|m| m.as_bytes()));/// let hay = b"\r\nfoo\r\n";/// assert_eq!(Some(&b"foo"[..]), re.find(hay).map(|m| m.as_bytes()));/// let hay = b"\r\n\r\n";/// let hay = b"\x00foo\x00";/// assert!(re.is_match(b"\n"));/// assert!(!re.is_match(b"\x00"));/// This shows that building a regex will work even when the byte/// given is not ASCII. This is unlike the top-level `Regex` API where/// matching invalid UTF-8 is not allowed./// Note though that you must disable Unicode mode. This is required/// because Unicode mode requires matching one codepoint at a time,/// and there is no way to match a non-ASCII byte as if it were a/// codepoint.///     RegexBuilder::new(r".")///         .unicode(false)///         .is_ok(),/// assert_eq!(Some(&b"a"[..]), re.find(b"aaa").map(|m| m.as_bytes()));/// let caps = re.captures(b"Harry Potter").unwrap();/// assert_eq!(&b"Harry"[..], &caps["first"]);/// assert_eq!(&b"Potter"[..], &caps["last"]);/// let caps = re.captures(b"Harry J. Potter").unwrap();///     Some(&b"J"[..]),///     caps.name("initial").map(|m| m.as_bytes()),/// assert_eq!(None, caps.name("middle").map(|m| m.as_bytes()));/// let caps = re.captures(b"Harry James Potter").unwrap();/// assert_eq!(None, caps.name("initial").map(|m| m.as_bytes()));///     Some(&b"James"[..]),///     caps.name("middle").map(|m| m.as_bytes()),/// assert!(re.is_match(b"a"));/// Note that unlike the top-level `RegexSet` for searching `&str`,/// it is permitted to disable Unicode mode even if the resulting/// pattern could match invalid UTF-8. For example, `(?-u:.)` is not/// a valid pattern for a top-level `RegexSet`, but is valid for a/// use regex::bytes::RegexSetBuilder;/// Since this builder is for constructing a/// [`bytes::RegexSet`](RegexSet), one can disable Unicode mode even if/// it would match invalid UTF-8:/// assert!(re.is_match(b"\nfoo\n"));/// assert!(!re.is_match(b"\r\n"));/// This shows that building a regex will work even when the byte given/// is not ASCII. This is unlike the top-level `RegexSet` API where/// assert!(re.is_match(b"Harry Potter"));/// assert!(re.is_match(b"Harry J. Potter"));/// assert!(re.is_match(b"Harry James Potter"));/// assert!(!re.is_match(b"harry J. Potter"));// This module defines an internal builder that encapsulates all interaction// with meta::Regex construction, and then 4 public API builders that wrap// around it. The docs are essentially repeated on each of the 4 public// builders, with tweaks to the examples as needed.// The reason why there are so many builders is partially because of a misstep// in the initial API design: the builder constructor takes in the pattern// strings instead of using the `build` method to accept the pattern strings.// This means `new` has a different signature for each builder. It probably// would have been nicer to to use one builder with `fn new()`, and then add// `build(pat)` and `build_many(pats)` constructors.// The other reason is because I think the `bytes` module should probably// have its own builder type. That way, it is completely isolated from the// top-level API.// If I could do it again, I'd probably have a `regex::Builder` and a// `regex::bytes::Builder`. Each would have `build` and `build_set` (or// `build_many`) methods for constructing a single pattern `Regex` and a// multi-pattern `RegexSet`, respectively.regexset/*!
Search for regex matches in `&[u8]` haystacks.

This module provides a nearly identical API via [`Regex`] to the one found in
the top-level of this crate. There are two important differences:

1. Matching is done on `&[u8]` instead of `&str`. Additionally, `Vec<u8>`
is used where `String` would have been used in the top-level API.
2. Unicode support can be disabled even when disabling it would result in
matching invalid UTF-8 bytes.

# Example: match null terminated string

This shows how to find all null-terminated strings in a slice of bytes. This
works even if a C string contains invalid UTF-8.

```rust
use regex::bytes::Regex;

let re = Regex::new(r"(?-u)(?<cstr>[^\x00]+)\x00").unwrap();
let hay = b"foo\x00qu\xFFux\x00baz\x00";

// Extract all of the strings without the NUL terminator from each match.
// The unwrap is OK here since a match requires the `cstr` capture to match.
let cstrs: Vec<&[u8]> =
    re.captures_iter(hay)
      .map(|c| c.name("cstr").unwrap().as_bytes())
      .collect();
assert_eq!(cstrs, vec![&b"foo"[..], &b"qu\xFFux"[..], &b"baz"[..]]);
```

# Example: selectively enable Unicode support

This shows how to match an arbitrary byte pattern followed by a UTF-8 encoded
string (e.g., to extract a title from a Matroska file):

```rust
use regex::bytes::Regex;

let re = Regex::new(
    r"(?-u)\x7b\xa9(?:[\x80-\xfe]|[\x40-\xff].)(?u:(.*))"
).unwrap();
let hay = b"\x12\xd0\x3b\x5f\x7b\xa9\x85\xe2\x98\x83\x80\x98\x54\x76\x68\x65";

// Notice that despite the `.*` at the end, it will only match valid UTF-8
// because Unicode mode was enabled with the `u` flag. Without the `u` flag,
// the `.*` would match the rest of the bytes regardless of whether they were
// valid UTF-8.
let (_, [title]) = re.captures(hay).unwrap().extract();
assert_eq!(title, b"\xE2\x98\x83");
// We can UTF-8 decode the title now. And the unwrap here
// is correct because the existence of a match guarantees
// that `title` is valid UTF-8.
let title = std::str::from_utf8(title).unwrap();
assert_eq!(title, "☃");
```

In general, if the Unicode flag is enabled in a capture group and that capture
is part of the overall match, then the capture is *guaranteed* to be valid
UTF-8.

# Syntax

The supported syntax is pretty much the same as the syntax for Unicode
regular expressions with a few changes that make sense for matching arbitrary
bytes:

1. The `u` flag can be disabled even when disabling it might cause the regex to
match invalid UTF-8. When the `u` flag is disabled, the regex is said to be in
"ASCII compatible" mode.
2. In ASCII compatible mode, Unicode character classes are not allowed. Literal
Unicode scalar values outside of character classes are allowed.
3. In ASCII compatible mode, Perl character classes (`\w`, `\d` and `\s`)
revert to their typical ASCII definition. `\w` maps to `[[:word:]]`, `\d` maps
to `[[:digit:]]` and `\s` maps to `[[:space:]]`.
4. In ASCII compatible mode, word boundaries use the ASCII compatible `\w` to
determine whether a byte is a word byte or not.
5. Hexadecimal notation can be used to specify arbitrary bytes instead of
Unicode codepoints. For example, in ASCII compatible mode, `\xFF` matches the
literal byte `\xFF`, while in Unicode mode, `\xFF` is the Unicode codepoint
`U+00FF` that matches its UTF-8 encoding of `\xC3\xBF`. Similarly for octal
notation when enabled.
6. In ASCII compatible mode, `.` matches any *byte* except for `\n`. When the
`s` flag is additionally enabled, `.` matches any byte.

# Performance

In general, one should expect performance on `&[u8]` to be roughly similar to
performance on `&str`.
*//// A syntax error.CompiledTooBig/// The compiled program exceeded the set size/// limit. The argument is the size limit imposed by/// [`RegexBuilder::size_limit`](crate::RegexBuilder::size_limit). Even/// when not configured explicitly, it defaults to a reasonable limit./// If you're getting this error, it occurred because your regex has been/// compiled to an intermediate state that is too big. It is important to/// note that exceeding this limit does _not_ mean the regex is too big to/// _work_, but rather, the regex is big enough that it may wind up being/// surprisingly slow when used in a search. In other words, this error is/// meant to be a practical heuristic for avoiding a performance footgun,/// and especially so for the case where the regex pattern is coming from/// an untrusted source./// There are generally two ways to move forward if you hit this error./// The first is to find some way to use a smaller regex. The second is to/// increase the size limit via `RegexBuilder::size_limit`. However, if/// your regex pattern is not from a trusted source, then neither of these/// approaches may be appropriate. Instead, you'll have to determine just/// how big of a regex you want to allow./// An error that occurred during parsing or compiling a regular expression.from_meta_build_error// TODO: Remove this method entirely on the next breaking semver release.// We implement our own Debug implementation so that we show nicer syntax// errors when people use `Regex::new(...).unwrap()`. It's a little weird,// but the `Syntax` variant is already storing a `String` anyway, so we might// as well format it nicely.find_byte/// Searches for the given needle in the given haystack./// If the perf-literal feature is enabled, then this uses the super optimized/// memchr crate. Otherwise, it uses the naive byte-at-a-time implementation./// Escapes all regular expression meta characters in `pattern`./// The string returned may be safely used as a literal in a regular/*!
This crate provides routines for searching strings for matches of a [regular
expression] (aka "regex"). The regex syntax supported by this crate is similar
to other regex engines, but it lacks several features that are not known how to
implement efficiently. This includes, but is not limited to, look-around and
backreferences. In exchange, all regex searches in this crate have worst case
`O(m * n)` time complexity, where `m` is proportional to the size of the regex
and `n` is proportional to the size of the string being searched.

[regular expression]: https://en.wikipedia.org/wiki/Regular_expression

If you just want API documentation, then skip to the [`Regex`] type. Otherwise,
here's a quick example showing one way of parsing the output of a grep-like
program:

```rust
use regex::Regex;

let re = Regex::new(r"(?m)^([^:]+):([0-9]+):(.+)$").unwrap();
let hay = "\
path/to/foo:54:Blue Harvest
path/to/bar:90:Something, Something, Something, Dark Side
path/to/baz:3:It's a Trap!
";

let mut results = vec![];
for (_, [path, lineno, line]) in re.captures_iter(hay).map(|c| c.extract()) {
    results.push((path, lineno.parse::<u64>()?, line));
}
assert_eq!(results, vec![
    ("path/to/foo", 54, "Blue Harvest"),
    ("path/to/bar", 90, "Something, Something, Something, Dark Side"),
    ("path/to/baz", 3, "It's a Trap!"),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# Overview

The primary type in this crate is a [`Regex`]. Its most important methods are
as follows:

* [`Regex::new`] compiles a regex using the default configuration. A
[`RegexBuilder`] permits setting a non-default configuration. (For example,
case insensitive matching, verbose mode and others.)
* [`Regex::is_match`] reports whether a match exists in a particular haystack.
* [`Regex::find`] reports the byte offsets of a match in a haystack, if one
exists. [`Regex::find_iter`] returns an iterator over all such matches.
* [`Regex::captures`] returns a [`Captures`], which reports both the byte
offsets of a match in a haystack and the byte offsets of each matching capture
group from the regex in the haystack.
[`Regex::captures_iter`] returns an iterator over all such matches.

There is also a [`RegexSet`], which permits searching for multiple regex
patterns simultaneously in a single search. However, it currently only reports
which patterns match and *not* the byte offsets of a match.

Otherwise, this top-level crate documentation is organized as follows:

* [Usage](#usage) shows how to add the `regex` crate to your Rust project.
* [Examples](#examples) provides a limited selection of regex search examples.
* [Performance](#performance) provides a brief summary of how to optimize regex
searching speed.
* [Unicode](#unicode) discusses support for non-ASCII patterns.
* [Syntax](#syntax) enumerates the specific regex syntax supported by this
crate.
* [Untrusted input](#untrusted-input) discusses how this crate deals with regex
patterns or haystacks that are untrusted.
* [Crate features](#crate-features) documents the Cargo features that can be
enabled or disabled for this crate.
* [Other crates](#other-crates) links to other crates in the `regex` family.

# Usage

The `regex` crate is [on crates.io](https://crates.io/crates/regex) and can be
used by adding `regex` to your dependencies in your project's `Cargo.toml`.
Or more simply, just run `cargo add regex`.

Here is a complete example that creates a new Rust project, adds a dependency
on `regex`, creates the source code for a regex search and then runs the
program.

First, create the project in a new directory:

```text
$ mkdir regex-example
$ cd regex-example
$ cargo init
```

Second, add a dependency on `regex`:

```text
$ cargo add regex
```

Third, edit `src/main.rs`. Delete what's there and replace it with this:

```
use regex::Regex;

fn main() {
    let re = Regex::new(r"Hello (?<name>\w+)!").unwrap();
    let Some(caps) = re.captures("Hello Murphy!") else {
        println!("no match!");
        return;
    };
    println!("The name is: {}", &caps["name"]);
}
```

Fourth, run it with `cargo run`:

```text
$ cargo run
   Compiling memchr v2.5.0
   Compiling regex-syntax v0.7.1
   Compiling aho-corasick v1.0.1
   Compiling regex v1.8.1
   Compiling regex-example v0.1.0 (/tmp/regex-example)
    Finished dev [unoptimized + debuginfo] target(s) in 4.22s
     Running `target/debug/regex-example`
The name is: Murphy
```

The first time you run the program will show more output like above. But
subsequent runs shouldn't have to re-compile the dependencies.

# Examples

This section provides a few examples, in tutorial style, showing how to
search a haystack with a regex. There are more examples throughout the API
documentation.

Before starting though, it's worth defining a few terms:

* A **regex** is a Rust value whose type is `Regex`. We use `re` as a
variable name for a regex.
* A **pattern** is the string that is used to build a regex. We use `pat` as
a variable name for a pattern.
* A **haystack** is the string that is searched by a regex. We use `hay` as a
variable name for a haystack.

Sometimes the words "regex" and "pattern" are used interchangeably.

General use of regular expressions in this crate proceeds by compiling a
**pattern** into a **regex**, and then using that regex to search, split or
replace parts of a **haystack**.

### Example: find a middle initial

We'll start off with a very simple example: a regex that looks for a specific
name but uses a wildcard to match a middle initial. Our pattern serves as
something like a template that will match a particular name with *any* middle
initial.

```rust
use regex::Regex;

// We use 'unwrap()' here because it would be a bug in our program if the
// pattern failed to compile to a regex. Panicking in the presence of a bug
// is okay.
let re = Regex::new(r"Homer (.)\. Simpson").unwrap();
let hay = "Homer J. Simpson";
let Some(caps) = re.captures(hay) else { return };
assert_eq!("J", &caps[1]);
```

There are a few things worth noticing here in our first example:

* The `.` is a special pattern meta character that means "match any single
character except for new lines." (More precisely, in this crate, it means
"match any UTF-8 encoding of any Unicode scalar value other than `\n`.")
* We can match an actual `.` literally by escaping it, i.e., `\.`.
* We use Rust's [raw strings] to avoid needing to deal with escape sequences in
both the regex pattern syntax and in Rust's string literal syntax. If we didn't
use raw strings here, we would have had to use `\\.` to match a literal `.`
character. That is, `r"\."` and `"\\."` are equivalent patterns.
* We put our wildcard `.` instruction in parentheses. These parentheses have a
special meaning that says, "make whatever part of the haystack matches within
these parentheses available as a capturing group." After finding a match, we
access this capture group with `&caps[1]`.

[raw strings]: https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals

Otherwise, we execute a search using `re.captures(hay)` and return from our
function if no match occurred. We then reference the middle initial by asking
for the part of the haystack that matched the capture group indexed at `1`.
(The capture group at index 0 is implicit and always corresponds to the entire
match. In this case, that's `Homer J. Simpson`.)

### Example: named capture groups

Continuing from our middle initial example above, we can tweak the pattern
slightly to give a name to the group that matches the middle initial:

```rust
use regex::Regex;

// Note that (?P<middle>.) is a different way to spell the same thing.
let re = Regex::new(r"Homer (?<middle>.)\. Simpson").unwrap();
let hay = "Homer J. Simpson";
let Some(caps) = re.captures(hay) else { return };
assert_eq!("J", &caps["middle"]);
```

Giving a name to a group can be useful when there are multiple groups in
a pattern. It makes the code referring to those groups a bit easier to
understand.

### Example: validating a particular date format

This examples shows how to confirm whether a haystack, in its entirety, matches
a particular date format:

```rust
use regex::Regex;

let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
assert!(re.is_match("2010-03-14"));
```

Notice the use of the `^` and `$` anchors. In this crate, every regex search is
run with an implicit `(?s:.)*?` at the beginning of its pattern, which allows
the regex to match anywhere in a haystack. Anchors, as above, can be used to
ensure that the full haystack matches a pattern.

This crate is also Unicode aware by default, which means that `\d` might match
more than you might expect it to. For example:

```rust
use regex::Regex;

let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
assert!(re.is_match("𝟚𝟘𝟙𝟘-𝟘𝟛-𝟙𝟜"));
```

To only match an ASCII decimal digit, all of the following are equivalent:

* `[0-9]`
* `(?-u:\d)`
* `[[:digit:]]`
* `[\d&&\p{ascii}]`

### Example: finding dates in a haystack

In the previous example, we showed how one might validate that a haystack,
in its entirety, corresponded to a particular date format. But what if we wanted
to extract all things that look like dates in a specific format from a haystack?
To do this, we can use an iterator API to find all matches (notice that we've
removed the anchors and switched to looking for ASCII-only digits):

```rust
use regex::Regex;

let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
let dates: Vec<&str> = re.find_iter(hay).map(|m| m.as_str()).collect();
assert_eq!(dates, vec![
    "1865-04-14",
    "1881-07-02",
    "1901-09-06",
    "1963-11-22",
]);
```

We can also iterate over [`Captures`] values instead of [`Match`] values, and
that in turn permits accessing each component of the date via capturing groups:

```rust
use regex::Regex;

let re = Regex::new(r"(?<y>[0-9]{4})-(?<m>[0-9]{2})-(?<d>[0-9]{2})").unwrap();
let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
    // The unwraps are okay because every capture group must match if the whole
    // regex matches, and in this context, we know we have a match.
    //
    // Note that we use `caps.name("y").unwrap().as_str()` instead of
    // `&caps["y"]` because the lifetime of the former is the same as the
    // lifetime of `hay` above, but the lifetime of the latter is tied to the
    // lifetime of `caps` due to how the `Index` trait is defined.
    let year = caps.name("y").unwrap().as_str();
    let month = caps.name("m").unwrap().as_str();
    let day = caps.name("d").unwrap().as_str();
    (year, month, day)
}).collect();
assert_eq!(dates, vec![
    ("1865", "04", "14"),
    ("1881", "07", "02"),
    ("1901", "09", "06"),
    ("1963", "11", "22"),
]);
```

### Example: simpler capture group extraction

One can use [`Captures::extract`] to make the code from the previous example a
bit simpler in this case:

```rust
use regex::Regex;

let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
    let (_, [year, month, day]) = caps.extract();
    (year, month, day)
}).collect();
assert_eq!(dates, vec![
    ("1865", "04", "14"),
    ("1881", "07", "02"),
    ("1901", "09", "06"),
    ("1963", "11", "22"),
]);
```

`Captures::extract` works by ensuring that the number of matching groups match
the number of groups requested via the `[year, month, day]` syntax. If they do,
then the substrings for each corresponding capture group are automatically
returned in an appropriately sized array. Rust's syntax for pattern matching
arrays does the rest.

### Example: replacement with named capture groups

Building on the previous example, perhaps we'd like to rearrange the date
formats. This can be done by finding each match and replacing it with
something different. The [`Regex::replace_all`] routine provides a convenient
way to do this, including by supporting references to named groups in the
replacement string:

```rust
use regex::Regex;

let re = Regex::new(r"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})").unwrap();
let before = "1973-01-05, 1975-08-25 and 1980-10-18";
let after = re.replace_all(before, "$m/$d/$y");
assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
```

The replace methods are actually polymorphic in the replacement, which
provides more flexibility than is seen here. (See the documentation for
[`Regex::replace`] for more details.)

### Example: verbose mode

When your regex gets complicated, you might consider using something other
than regex. But if you stick with regex, you can use the `x` flag to enable
insignificant whitespace mode or "verbose mode." In this mode, whitespace
is treated as insignificant and one may write comments. This may make your
patterns easier to comprehend.

```rust
use regex::Regex;

let re = Regex::new(r"(?x)
  (?P<y>\d{4}) # the year, including all Unicode digits
  -
  (?P<m>\d{2}) # the month, including all Unicode digits
  -
  (?P<d>\d{2}) # the day, including all Unicode digits
").unwrap();

let before = "1973-01-05, 1975-08-25 and 1980-10-18";
let after = re.replace_all(before, "$m/$d/$y");
assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
```

If you wish to match against whitespace in this mode, you can still use `\s`,
`\n`, `\t`, etc. For escaping a single space character, you can escape it
directly with `\ `, use its hex character code `\x20` or temporarily disable
the `x` flag, e.g., `(?-x: )`.

### Example: match multiple regular expressions simultaneously

This demonstrates how to use a [`RegexSet`] to match multiple (possibly
overlapping) regexes in a single scan of a haystack:

```rust
use regex::RegexSet;

let set = RegexSet::new(&[
    r"\w+",
    r"\d+",
    r"\pL+",
    r"foo",
    r"bar",
    r"barfoo",
    r"foobar",
]).unwrap();

// Iterate over and collect all of the matches. Each match corresponds to the
// ID of the matching pattern.
let matches: Vec<_> = set.matches("foobar").into_iter().collect();
assert_eq!(matches, vec![0, 2, 3, 4, 6]);

// You can also test whether a particular regex matched:
let matches = set.matches("foobar");
assert!(!matches.matched(5));
assert!(matches.matched(6));
```

# Performance

This section briefly discusses a few concerns regarding the speed and resource
usage of regexes.

### Only ask for what you need

When running a search with a regex, there are generally three different types
of information one can ask for:

1. Does a regex match in a haystack?
2. Where does a regex match in a haystack?
3. Where do each of the capturing groups match in a haystack?

Generally speaking, this crate could provide a function to answer only #3,
which would subsume #1 and #2 automatically. However, it can be significantly
more expensive to compute the location of capturing group matches, so it's best
not to do it if you don't need to.

Therefore, only ask for what you need. For example, don't use [`Regex::find`]
if you only need to test if a regex matches a haystack. Use [`Regex::is_match`]
instead.

### Unicode can impact memory usage and search speed

This crate has first class support for Unicode and it is **enabled by default**.
In many cases, the extra memory required to support it will be negligible and
it typically won't impact search speed. But it can in some cases.

With respect to memory usage, the impact of Unicode principally manifests
through the use of Unicode character classes. Unicode character classes
tend to be quite large. For example, `\w` by default matches around 140,000
distinct codepoints. This requires additional memory, and tends to slow down
regex compilation. While a `\w` here and there is unlikely to be noticed,
writing `\w{100}` will for example result in quite a large regex by default.
Indeed, `\w` is considerably larger than its ASCII-only version, so if your
requirements are satisfied by ASCII, it's probably a good idea to stick to
ASCII classes. The ASCII-only version of `\w` can be spelled in a number of
ways. All of the following are equivalent:

* `[0-9A-Za-z_]`
* `(?-u:\w)`
* `[[:word:]]`
* `[\w&&\p{ascii}]`

With respect to search speed, Unicode tends to be handled pretty well, even when
using large Unicode character classes. However, some of the faster internal
regex engines cannot handle a Unicode aware word boundary assertion. So if you
don't need Unicode-aware word boundary assertions, you might consider using
`(?-u:\b)` instead of `\b`, where the former uses an ASCII-only definition of
a word character.

### Literals might accelerate searches

This crate tends to be quite good at recognizing literals in a regex pattern
and using them to accelerate a search. If it is at all possible to include
some kind of literal in your pattern, then it might make search substantially
faster. For example, in the regex `\w+@\w+`, the engine will look for
occurrences of `@` and then try a reverse match for `\w+` to find the start
position.

### Avoid re-compiling regexes, especially in a loop

It is an anti-pattern to compile the same pattern in a loop since regex
compilation is typically expensive. (It takes anywhere from a few microseconds
to a few **milliseconds** depending on the size of the pattern.) Not only is
compilation itself expensive, but this also prevents optimizations that reuse
allocations internally to the regex engine.

In Rust, it can sometimes be a pain to pass regexes around if they're used from
inside a helper function. Instead, we recommend using crates like [`once_cell`]
and [`lazy_static`] to ensure that patterns are compiled exactly once.

[`once_cell`]: https://crates.io/crates/once_cell
[`lazy_static`]: https://crates.io/crates/lazy_static

This example shows how to use `once_cell`:

```rust
use {
    once_cell::sync::Lazy,
    regex::Regex,
};

fn some_helper_function(haystack: &str) -> bool {
    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"...").unwrap());
    RE.is_match(haystack)
}

fn main() {
    assert!(some_helper_function("abc"));
    assert!(!some_helper_function("ac"));
}
```

Specifically, in this example, the regex will be compiled when it is used for
the first time. On subsequent uses, it will reuse the previously built `Regex`.
Notice how one can define the `Regex` locally to a specific function.

### Sharing a regex across threads can result in contention

While a single `Regex` can be freely used from multiple threads simultaneously,
there is a small synchronization cost that must be paid. Generally speaking,
one shouldn't expect to observe this unless the principal task in each thread
is searching with the regex *and* most searches are on short haystacks. In this
case, internal contention on shared resources can spike and increase latency,
which in turn may slow down each individual search.

One can work around this by cloning each `Regex` before sending it to another
thread. The cloned regexes will still share the same internal read-only portion
of its compiled state (it's reference counted), but each thread will get
optimized access to the mutable space that is used to run a search. In general,
there is no additional cost in memory to doing this. The only cost is the added
code complexity required to explicitly clone the regex. (If you share the same
`Regex` across multiple threads, each thread still gets its own mutable space,
but accessing that space is slower.)

# Unicode

This section discusses what kind of Unicode support this regex library has.
Before showing some examples, we'll summarize the relevant points:

* This crate almost fully implements "Basic Unicode Support" (Level 1) as
specified by the [Unicode Technical Standard #18][UTS18]. The full details
of what is supported are documented in [UNICODE.md] in the root of the regex
crate repository. There is virtually no suppo/*!
This crate provides routines for searching strings for matches of a [regular
expression] (aka "regex"). The regex syntax supported by this crate is similar
to other regex engines, but it lacks several features that are not known how to
implement efficiently. This includes, but is not limited to, look-around and
backreferences. In exchange, all regex searches in this crate have worst case
`O(m * n)` time complexity, where `m` is proportional to the size of the regex
and `n` is proportional to the size of the string being searched.

[regular expression]: https://en.wikipedia.org/wiki/Regular_expression

If you just want API documentation, then skip to the [`Regex`] type. Otherwise,
here's a quick example showing one way of parsing the output of a grep-like
program:

```rust
use regex::Regex;

let re = Regex::new(r"(?m)^([^:]+):([0-9]+):(.+)$").unwrap();
let hay = "\
path/to/foo:54:Blue Harvest
path/to/bar:90:Something, Something, Something, Dark Side
path/to/baz:3:It's a Trap!
";

let mut results = vec![];
for (_, [path, lineno, line]) in re.captures_iter(hay).map(|c| c.extract()) {
    results.push((path, lineno.parse::<u64>()?, line));
}
assert_eq!(results, vec![
    ("path/to/foo", 54, "Blue Harvest"),
    ("path/to/bar", 90, "Something, Something, Something, Dark Side"),
    ("path/to/baz", 3, "It's a Trap!"),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# Overview

The primary type in this crate is a [`Regex`]. Its most important methods are
as follows:

* [`Regex::new`] compiles a regex using the default configuration. A
[`RegexBuilder`] permits setting a non-default configuration. (For example,
case insensitive matching, verbose mode and others.)
* [`Regex::is_match`] reports whether a match exists in a particular haystack.
* [`Regex::find`] reports the byte offsets of a match in a haystack, if one
exists. [`Regex::find_iter`] returns an iterator over all such matches.
* [`Regex::captures`] returns a [`Captures`], which reports both the byte
offsets of a match in a haystack and the byte offsets of each matching capture
group from the regex in the haystack.
[`Regex::captures_iter`] returns an iterator over all such matches.

There is also a [`RegexSet`], which permits searching for multiple regex
patterns simultaneously in a single search. However, it currently only reports
which patterns match and *not* the byte offsets of a match.

Otherwise, this top-level crate documentation is organized as follows:

* [Usage](#usage) shows how to add the `regex` crate to your Rust project.
* [Examples](#examples) provides a limited selection of regex search examples.
* [Performance](#performance) provides a brief summary of how to optimize regex
searching speed.
* [Unicode](#unicode) discusses support for non-ASCII patterns.
* [Syntax](#syntax) enumerates the specific regex syntax supported by this
crate.
* [Untrusted input](#untrusted-input) discusses how this crate deals with regex
patterns or haystacks that are untrusted.
* [Crate features](#crate-features) documents the Cargo features that can be
enabled or disabled for this crate.
* [Other crates](#other-crates) links to other crates in the `regex` family.

# Usage

The `regex` crate is [on crates.io](https://crates.io/crates/regex) and can be
used by adding `regex` to your dependencies in your project's `Cargo.toml`.
Or more simply, just run `cargo add regex`.

Here is a complete example that creates a new Rust project, adds a dependency
on `regex`, creates the source code for a regex search and then runs the
program.

First, create the project in a new directory:

```text
$ mkdir regex-example
$ cd regex-example
$ cargo init
```

Second, add a dependency on `regex`:

```text
$ cargo add regex
```

Third, edit `src/main.rs`. Delete what's there and replace it with this:

```
use regex::Regex;

fn main() {
    let re = Regex::new(r"Hello (?<name>\w+)!").unwrap();
    let Some(caps) = re.captures("Hello Murphy!") else {
        println!("no match!");
        return;
    };
    println!("The name is: {}", &caps["name"]);
}
```

Fourth, run it with `cargo run`:

```text
$ cargo run
   Compiling memchr v2.5.0
   Compiling regex-syntax v0.7.1
   Compiling aho-corasick v1.0.1
   Compiling regex v1.8.1
   Compiling regex-example v0.1.0 (/tmp/regex-example)
    Finished dev [unoptimized + debuginfo] target(s) in 4.22s
     Running `target/debug/regex-example`
The name is: Murphy
```

The first time you run the program will show more output like above. But
subsequent runs shouldn't have to re-compile the dependencies.

# Examples

This section provides a few examples, in tutorial style, showing how to
search a haystack with a regex. There are more examples throughout the API
documentation.

Before starting though, it's worth defining a few terms:

* A **regex** is a Rust value whose type is `Regex`. We use `re` as a
variable name for a regex.
* A **pattern** is the string that is used to build a regex. We use `pat` as
a variable name for a pattern.
* A **haystack** is the string that is searched by a regex. We use `hay` as a
variable name for a haystack.

Sometimes the words "regex" and "pattern" are used interchangeably.

General use of regular expressions in this crate proceeds by compiling a
**pattern** into a **regex**, and then using that regex to search, split or
replace parts of a **haystack**.

### Example: find a middle initial

We'll start off with a very simple example: a regex that looks for a specific
name but uses a wildcard to match a middle initial. Our pattern serves as
something like a template that will match a particular name with *any* middle
initial.

```rust
use regex::Regex;

// We use 'unwrap()' here because it would be a bug in our program if the
// pattern failed to compile to a regex. Panicking in the presence of a bug
// is okay.
let re = Regex::new(r"Homer (.)\. Simpson").unwrap();
let hay = "Homer J. Simpson";
let Some(caps) = re.captures(hay) else { return };
assert_eq!("J", &caps[1]);
```

There are a few things worth noticing here in our first example:

* The `.` is a special pattern meta character that means "match any single
character except for new lines." (More precisely, in this crate, it means
"match any UTF-8 encoding of any Unicode scalar value other than `\n`.")
* We can match an actual `.` literally by escaping it, i.e., `\.`.
* We use Rust's [raw strings] to avoid needing to deal with escape sequences in
both the regex pattern syntax and in Rust's string literal syntax. If we didn't
use raw strings here, we would have had to use `\\.` to match a literal `.`
character. That is, `r"\."` and `"\\."` are equivalent patterns.
* We put our wildcard `.` instruction in parentheses. These parentheses have a
special meaning that says, "make whatever part of the haystack matches within
these parentheses available as a capturing group." After finding a match, we
access this capture group with `&caps[1]`.

[raw strings]: https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals

Otherwise, we execute a search using `re.captures(hay)` and return from our
function if no match occurred. We then reference the middle initial by asking
for the part of the haystack that matched the capture group indexed at `1`.
(The capture group at index 0 is implicit and always corresponds to the entire
match. In this case, that's `Homer J. Simpson`.)

### Example: named capture groups

Continuing from our middle initial example above, we can tweak the pattern
slightly to give a name to the group that matches the middle initial:

```rust
use regex::Regex;

// Note that (?P<middle>.) is a different way to spell the same thing.
let re = Regex::new(r"Homer (?<middle>.)\. Simpson").unwrap();
let hay = "Homer J. Simpson";
let Some(caps) = re.captures(hay) else { return };
assert_eq!("J", &caps["middle"]);
```

Giving a name to a group can be useful when there are multiple groups in
a pattern. It makes the code referring to those groups a bit easier to
understand.

### Example: validating a particular date format

This examples shows how to confirm whether a haystack, in its entirety, matches
a particular date format:

```rust
use regex::Regex;

let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
assert!(re.is_match("2010-03-14"));
```

Notice the use of the `^` and `$` anchors. In this crate, every regex search is
run with an implicit `(?s:.)*?` at the beginning of its pattern, which allows
the regex to match anywhere in a haystack. Anchors, as above, can be used to
ensure that the full haystack matches a pattern.

This crate is also Unicode aware by default, which means that `\d` might match
more than you might expect it to. For example:

```rust
use regex::Regex;

let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
assert!(re.is_match("𝟚𝟘𝟙𝟘-𝟘𝟛-𝟙𝟜"));
```

To only match an ASCII decimal digit, all of the following are equivalent:

* `[0-9]`
* `(?-u:\d)`
* `[[:digit:]]`
* `[\d&&\p{ascii}]`

### Example: finding dates in a haystack

In the previous example, we showed how one might validate that a haystack,
in its entirety, corresponded to a particular date format. But what if we wanted
to extract all things that look like dates in a specific format from a haystack?
To do this, we can use an iterator API to find all matches (notice that we've
removed the anchors and switched to looking for ASCII-only digits):

```rust
use regex::Regex;

let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
let dates: Vec<&str> = re.find_iter(hay).map(|m| m.as_str()).collect();
assert_eq!(dates, vec![
    "1865-04-14",
    "1881-07-02",
    "1901-09-06",
    "1963-11-22",
]);
```

We can also iterate over [`Captures`] values instead of [`Match`] values, and
that in turn permits accessing each component of the date via capturing groups:

```rust
use regex::Regex;

let re = Regex::new(r"(?<y>[0-9]{4})-(?<m>[0-9]{2})-(?<d>[0-9]{2})").unwrap();
let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
    // The unwraps are okay because every capture group must match if the whole
    // regex matches, and in this context, we know we have a match.
    //
    // Note that we use `caps.name("y").unwrap().as_str()` instead of
    // `&caps["y"]` because the lifetime of the former is the same as the
    // lifetime of `hay` above, but the lifetime of the latter is tied to the
    // lifetime of `caps` due to how the `Index` trait is defined.
    let year = caps.name("y").unwrap().as_str();
    let month = caps.name("m").unwrap().as_str();
    let day = caps.name("d").unwrap().as_str();
    (year, month, day)
}).collect();
assert_eq!(dates, vec![
    ("1865", "04", "14"),
    ("1881", "07", "02"),
    ("1901", "09", "06"),
    ("1963", "11", "22"),
]);
```

### Example: simpler capture group extraction

One can use [`Captures::extract`] to make the code from the previous example a
bit simpler in this case:

```rust
use regex::Regex;

let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
    let (_, [year, month, day]) = caps.extract();
    (year, month, day)
}).collect();
assert_eq!(dates, vec![
    ("1865", "04", "14"),
    ("1881", "07", "02"),
    ("1901", "09", "06"),
    ("1963", "11", "22"),
]);
```

`Captures::extract` works by ensuring that the number of matching groups match
the number of groups requested via the `[year, month, day]` syntax. If they do,
then the substrings for each corresponding capture group are automatically
returned in an appropriately sized array. Rust's syntax for pattern matching
arrays does the rest.

### Example: replacement with named capture groups

Building on the previous example, perhaps we'd like to rearrange the date
formats. This can be done by finding each match and replacing it with
something different. The [`Regex::replace_all`] routine provides a convenient
way to do this, including by supporting references to named groups in the
replacement string:

```rust
use regex::Regex;

let re = Regex::new(r"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})").unwrap();
let before = "1973-01-05, 1975-08-25 and 1980-10-18";
let after = re.replace_all(before, "$m/$d/$y");
assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
```

The replace methods are actually polymorphic in the replacement, which
provides more flexibility than is seen here. (See the documentation for
[`Regex::replace`] for more details.)

### Example: verbose mode

When your regex gets complicated, you might consider using something other
than regex. But if you stick with regex, you can use the `x` flag to enable
insignificant whitespace mode or "verbose mode." In this mode, whitespace
is treated as insignificant and one may write comments. This may make your
patterns easier to comprehend.

```rust
use regex::Regex;

let re = Regex::new(r"(?x)
  (?P<y>\d{4}) # the year, including all Unicode digits
  -
  (?P<m>\d{2}) # the month, including all Unicode digits
  -
  (?P<d>\d{2}) # the day, including all Unicode digits
").unwrap();

let before = "1973-01-05, 1975-08-25 and 1980-10-18";
let after = re.replace_all(before, "$m/$d/$y");
assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
```

If you wish to match against whitespace in this mode, you can still use `\s`,
`\n`, `\t`, etc. For escaping a single space character, you can escape it
directly with `\ `, use its hex character code `\x20` or temporarily disable
the `x` flag, e.g., `(?-x: )`.

### Example: match multiple regular expressions simultaneously

This demonstrates how to use a [`RegexSet`] to match multiple (possibly
overlapping) regexes in a single scan of a haystack:

```rust
use regex::RegexSet;

let set = RegexSet::new(&[
    r"\w+",
    r"\d+",
    r"\pL+",
    r"foo",
    r"bar",
    r"barfoo",
    r"foobar",
]).unwrap();

// Iterate over and collect all of the matches. Each match corresponds to the
// ID of the matching pattern.
let matches: Vec<_> = set.matches("foobar").into_iter().collect();
assert_eq!(matches, vec![0, 2, 3, 4, 6]);

// You can also test whether a particular regex matched:
let matches = set.matches("foobar");
assert!(!matches.matched(5));
assert!(matches.matched(6));
```

# Performance

This section briefly discusses a few concerns regarding the speed and resource
usage of regexes.

### Only ask for what you need

When running a search with a regex, there are generally three different types
of information one can ask for:

1. Does a regex match in a haystack?
2. Where does a regex match in a haystack?
3. Where do each of the capturing groups match in a haystack?

Generally speaking, this crate could provide a function to answer only #3,
which would subsume #1 and #2 automatically. However, it can be significantly
more expensive to compute the location of capturing group matches, so it's best
not to do it if you don't need to.

Therefore, only ask for what you need. For example, don't use [`Regex::find`]
if you only need to test if a regex matches a haystack. Use [`Regex::is_match`]
instead.

### Unicode can impact memory usage and search speed

This crate has first class support for Unicode and it is **enabled by default**.
In many cases, the extra memory required to support it will be negligible and
it typically won't impact search speed. But it can in some cases.

With respect to memory usage, the impact of Unicode principally manifests
through the use of Unicode character classes. Unicode character classes
tend to be quite large. For example, `\w` by default matches around 140,000
distinct codepoints. This requires additional memory, and tends to slow down
regex compilation. While a `\w` here and there is unlikely to be noticed,
writing `\w{100}` will for example result in quite a large regex by default.
Indeed, `\w` is considerably larger than its ASCII-only version, so if your
requirements are satisfied by ASCII, it's probably a good idea to stick to
ASCII classes. The ASCII-only version of `\w` can be spelled in a number of
ways. All of the following are equivalent:

* `[0-9A-Za-z_]`
* `(?-u:\w)`
* `[[:word:]]`
* `[\w&&\p{ascii}]`

With respect to search speed, Unicode tends to be handled pretty well, even when
using large Unicode character classes. However, some of the faster internal
regex engines cannot handle a Unicode aware word boundary assertion. So if you
don't need Unicode-aware word boundary assertions, you might consider using
`(?-u:\b)` instead of `\b`, where the former uses an ASCII-only definition of
a word character.

### Literals might accelerate searches

This crate tends to be quite good at recognizing literals in a regex pattern
and using them to accelerate a search. If it is at all possible to include
some kind of literal in your pattern, then it might make search substantially
faster. For example, in the regex `\w+@\w+`, the engine will look for
occurrences of `@` and then try a reverse match for `\w+` to find the start
position.

### Avoid re-compiling regexes, especially in a loop

It is an anti-pattern to compile the same pattern in a loop since regex
compilation is typically expensive. (It takes anywhere from a few microseconds
to a few **milliseconds** depending on the size of the pattern.) Not only is
compilation itself expensive, but this also prevents optimizations that reuse
allocations internally to the regex engine.

In Rust, it can sometimes be a pain to pass regexes around if they're used from
inside a helper function. Instead, we recommend using crates like [`once_cell`]
and [`lazy_static`] to ensure that patterns are compiled exactly once.

[`once_cell`]: https://crates.io/crates/once_cell
[`lazy_static`]: https://crates.io/crates/lazy_static

This example shows how to use `once_cell`:

```rust
use {
    once_cell::sync::Lazy,
    regex::Regex,
};

fn some_helper_function(haystack: &str) -> bool {
    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"...").unwrap());
    RE.is_match(haystack)
}

fn main() {
    assert!(some_helper_function("abc"));
    assert!(!some_helper_function("ac"));
}
```

Specifically, in this example, the regex will be compiled when it is used for
the first time. On subsequent uses, it will reuse the previously built `Regex`.
Notice how one can define the `Regex` locally to a specific function.

### Sharing a regex across threads can result in contention

While a single `Regex` can be freely used from multiple threads simultaneously,
there is a small synchronization cost that must be paid. Generally speaking,
one shouldn't expect to observe this unless the principal task in each thread
is searching with the regex *and* most searches are on short haystacks. In this
case, internal contention on shared resources can spike and increase latency,
which in turn may slow down each individual search.

One can work around this by cloning each `Regex` before sending it to another
thread. The cloned regexes will still share the same internal read-only portion
of its compiled state (it's reference counted), but each thread will get
optimized access to the mutable space that is used to run a search. In general,
there is no additional cost in memory to doing this. The only cost is the added
code complexity required to explicitly clone the regex. (If you share the same
`Regex` across multiple threads, each thread still gets its own mutable space,
but accessing that space is slower.)

# Unicode

This section discusses what kind of Unicode support this regex library has.
Before showing some examples, we'll summarize the relevant points:

* This crate almost fully implements "Basic Unicode Support" (Level 1) as
specified by the [Unicode Technical Standard #18][UTS18]. The full details
of what is supported are documented in [UNICODE.md] in the root of the regex
crate repository. There is virtually no support for "Extended Unicode Support"
(Level 2) from UTS#18.
* The top-level [`Regex`] runs searches *as if* iterating over each of the
codepoints in the haystack. That is, the fundamental atom of matching is a
single codepoint.
* [`bytes::Regex`], in contrast, permits disabling Unicode mode for part of all
of your pattern in all cases. When Unicode mode is disabled, then a search is
run *as if* iterating over each byte in the haystack. That is, the fundamental
atom of matching is a single byte. (A top-level `Regex` also permits disabling
Unicode and thus matching *as if* it were one byte at a time, but only when
doing so wouldn't permit matching invalid UTF-8.)
* When Unicode mode is enabled (the default), `.` will match an entire Unicode
scalar value, even when it is encoded using multiple bytes. When Unicode mode
is disabled (e.g., `(?-u:.)`), then `.` will match a single byte in all cases.
* The character classes `\w`, `\d` and `\s` are all Unicode-aware by default.
Use `(?-u:\w)`, `(?-u:\d)` and `(?-u:\s)` to get their ASCII-only definitions.
* Similarly, `\b` and `\B` use a Unicode definition of a "word" character.
To get ASCII-only word boundaries, use `(?-u:\b)` and `(?-u:\B)`. This also
applies to the special word boundary assertions. (That is, `\b{start}`,
`\b{end}`, `\b{start-half}`, `\b{end-half}`.)
* `^` and `$` are **not** Unicode-aware in multi-line mode. Namely, they only
recognize `\n` (assuming CRLF mode is not enabled) and not any of the other
forms of line terminators defined by Unicode.
* Case insensitive searching is Unicode-aware and uses simple case folding.
* Unicode general categories, scripts and many boolean properties are available
by default via the `\p{property name}` syntax.
* In all cases, matches are reported using byte offsets. Or more precisely,
UTF-8 code unit offsets. This permits constant time indexing and slicing of the
haystack.

[UTS18]: https://unicode.org/reports/tr18/
[UNICODE.md]: https://github.com/rust-lang/regex/blob/master/UNICODE.md

Patterns themselves are **only** interpreted as a sequence of Unicode scalar
values. This means you can use Unicode characters directly in your pattern:

```rust
use regex::Regex;

let re = Regex::new(r"(?i)Δ+").unwrap();
let m = re.find("ΔδΔ").unwrap();
assert_eq!((0, 6), (m.start(), m.end()));
// alternatively:
assert_eq!(0..6, m.range());
```

As noted above, Unicode general categories, scripts, script extensions, ages
and a smattering of boolean properties are available as character classes. For
example, you can match a sequence of numerals, Greek or Cherokee letters:

```rust
use regex::Regex;

let re = Regex::new(r"[\pN\p{Greek}\p{Cherokee}]+").unwrap();
let m = re.find("abcΔᎠβⅠᏴγδⅡxyz").unwrap();
assert_eq!(3..23, m.range());
```

While not specific to Unicode, this library also supports character class set
operations. Namely, one can nest character classes arbitrarily and perform set
operations on them. Those set operations are union (the default), intersection,
difference and symmetric difference. These set operations tend to be most
useful with Unicode character classes. For example, to match any codepoint
that is both in the `Greek` script and in the `Letter` general category:

```rust
use regex::Regex;

let re = Regex::new(r"[\p{Greek}&&\pL]+").unwrap();
let subs: Vec<&str> = re.find_iter("ΔδΔ𐅌ΔδΔ").map(|m| m.as_str()).collect();
assert_eq!(subs, vec!["ΔδΔ", "ΔδΔ"]);

// If we just matches on Greek, then all codepoints would match!
let re = Regex::new(r"\p{Greek}+").unwrap();
let subs: Vec<&str> = re.find_iter("ΔδΔ𐅌ΔδΔ").map(|m| m.as_str()).collect();
assert_eq!(subs, vec!["ΔδΔ𐅌ΔδΔ"]);
```

### Opt out of Unicode support

The [`bytes::Regex`] type that can be used to search `&[u8]` haystacks. By
default, haystacks are conventionally treated as UTF-8 just like it is with the
main `Regex` type. However, this behavior can be disabled by turning off the
`u` flag, even if doing so could result in matching invalid UTF-8. For example,
when the `u` flag is disabled, `.` will match any byte instead of any Unicode
scalar value.

Disabling the `u` flag is also possible with the standard `&str`-based `Regex`
type, but it is only allowed where the UTF-8 invariant is maintained. For
example, `(?-u:\w)` is an ASCII-only `\w` character class and is legal in an
`&str`-based `Regex`, but `(?-u:\W)` will attempt to match *any byte* that
isn't in `(?-u:\w)`, which in turn includes bytes that are invalid UTF-8.
Similarly, `(?-u:\xFF)` will attempt to match the raw byte `\xFF` (instead of
`U+00FF`), which is invalid UTF-8 and therefore is illegal in `&str`-based
regexes.

Finally, since Unicode support requires bundling large Unicode data
tables, this crate exposes knobs to disable the compilation of those
data tables, which can be useful for shrinking binary size and reducing
compilation times. For details on how to do that, see the section on [crate
features](#crate-features).

# Syntax

The syntax supported in this crate is documented below.

Note that the regular expression parser and abstract syntax are exposed in
a separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).

### Matching one character

<pre class="rust">
.             any character except new line (includes new line with s flag)
[0-9]         any ASCII digit
\d            digit (\p{Nd})
\D            not digit
\pX           Unicode character class identified by a one-letter name
\p{Greek}     Unicode character class (general category or script)
\PX           Negated Unicode character class identified by a one-letter name
\P{Greek}     negated Unicode character class (general category or script)
</pre>

### Character classes

<pre class="rust">
[xyz]         A character class matching either x, y or z (union).
[^xyz]        A character class matching any character except x, y and z.
[a-z]         A character class matching any character in range a-z.
[[:alpha:]]   ASCII character class ([A-Za-z])
[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])
[x[^xyz]]     Nested/grouping character class (matching any character except y and z)
[a-y&&xyz]    Intersection (matching x or y)
[0-9&&[^4]]   Subtraction using intersection and negation (matching 0-9 except 4)
[0-9--4]      Direct subtraction (matching 0-9 except 4)
[a-g~~b-h]    Symmetric difference (matching `a` and `h` only)
[\[\]]        Escaping in character classes (matching [ or ])
[a&&b]        An empty character class matching nothing
</pre>

Any named character class may appear inside a bracketed `[...]` character
class. For example, `[\p{Greek}[:digit:]]` matches any ASCII digit or any
codepoint in the `Greek` script. `[\p{Greek}&&\pL]` matches Greek letters.

Precedence in character classes, from most binding to least:

1. Ranges: `[a-cd]` == `[[a-c]d]`
2. Union: `[ab&&bc]` == `[[ab]&&[bc]]`
3. Intersection, difference, symmetric difference. All three have equivalent
precedence, and are evaluated in left-to-right order. For example,
`[\pL--\p{Greek}&&\p{Uppercase}]` == `[[\pL--\p{Greek}]&&\p{Uppercase}]`.
4. Negation: `[^a-z&&b]` == `[^[a-z&&b]]`.

### Composites

<pre class="rust">
xy    concatenation (x followed by y)
x|y   alternation (x or y, prefer x)
</pre>

This example shows how an alternation works, and what it means to prefer a
branch in the alternation over subsequent branches.

```
use regex::Regex;

let haystack = "samwise";
// If 'samwise' comes first in our alternation, then it is
// preferred as a match, even if the regex engine could
// technically detect that 'sam' led to a match earlier.
let re = Regex::new(r"samwise|sam").unwrap();
assert_eq!("samwise", re.find(haystack).unwrap().as_str());
// But if 'sam' comes first, then it will match instead.
// In this case, it is impossible for 'samwise' to match
// because 'sam' is a prefix of it.
let re = Regex::new(r"sam|samwise").unwrap();
assert_eq!("sam", re.find(haystack).unwrap().as_str());
```

### Repetitions

<pre class="rust">
x*        zero or more of x (greedy)
x+        one or more of x (greedy)
x?        zero or one of x (greedy)
x*?       zero or more of x (ungreedy/lazy)
x+?       one or more of x (ungreedy/lazy)
x??       zero or one of x (ungreedy/lazy)
x{n,m}    at least n x and at most m x (greedy)
x{n,}     at least n x (greedy)
x{n}      exactly n x
x{n,m}?   at least n x and at most m x (ungreedy/lazy)
x{n,}?    at least n x (ungreedy/lazy)
x{n}?     exactly n x
</pre>

### Empty matches

<pre class="rust">
^               the beginning of a haystack (or start-of-line with multi-line mode)
$               the end of a haystack (or end-of-line with multi-line mode)
\A              only the beginning of a haystack (even with multi-line mode enabled)
\z              only the end of a haystack (even with multi-line mode enabled)
\b              a Unicode word boundary (\w on one side and \W, \A, or \z on other)
\B              not a Unicode word boundary
\b{start}, \<   a Unicode start-of-word boundary (\W|\A on the left, \w on the right)
\b{end}, \>     a Unicode end-of-word boundary (\w on the left, \W|\z on the right))
\b{start-half}  half of a Unicode start-of-word boundary (\W|\A on the left)
\b{end-half}    half of a Unicode end-of-word boundary (\W|\z on the right)
</pre>

The empty regex is valid and matches the empty string. For example, the
empty regex matches `abc` at positions `0`, `1`, `2` and `3`. When using the
top-level [`Regex`] on `&str` haystacks, an empty match that splits a codepoint
is guaranteed to never be returned. However, such matches are permitted when
using a [`bytes::Regex`]. For example:

```rust
let re = regex::Regex::new(r"").unwrap();
let ranges: Vec<_> = re.find_iter("💩").map(|m| m.range()).collect();
assert_eq!(ranges, vec![0..0, 4..4]);

let re = regex::bytes::Regex::new(r"").unwrap();
let ranges: Vec<_> = re.find_iter("💩".as_bytes()).map(|m| m.range()).collect();
assert_eq!(ranges, vec![0..0, 1..1, 2..2, 3..3, 4..4]);
```

Note that an empty regex is distinct from a regex that can never match.
For example, the regex `[a&&b]` is a character class that represents the
intersection of `a` and `b`. That intersection is empty, which means the
character class is empty. Since nothing is in the empty set, `[a&&b]` matches
nothing, not even the empty string.

### Grouping and flags

<pre class="rust">
(exp)          numbered capture group (indexed by opening parenthesis)
(?P&lt;name&gt;exp)  named (also numbered) capture group (names must be alpha-numeric)
(?&lt;name&gt;exp)   named (also numbered) capture group (names must be alpha-numeric)
(?:exp)        non-capturing group
(?flags)       set flags within current group
(?flags:exp)   set flags for exp (non-capturing)
</pre>

Capture group names must be any sequence of alpha-numeric Unicode codepoints,
in addition to `.`, `_`, `[` and `]`. Names must start with either an `_` or
an alphabetic codepoint. Alphabetic codepoints correspond to the `Alphabetic`
Unicode property, while numeric codepoints correspond to the union of the
`Decimal_Number`, `Letter_Number` and `Other_Number` general categories.

Flags are each a single character. For example, `(?x)` sets the flag `x`
and `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at
the same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets
the `x` flag and clears the `y` flag.

All flags are by default disabled unless stated otherwise. They are:

<pre class="rust">
i     case-insensitive: letters match both upper and lower case
m     multi-line mode: ^ and $ match begin/end of line
s     allow . to match \n
R     enables CRLF mode: when multi-line mode is enabled, \r\n is used
U     swap the meaning of x* and x*?
u     Unicode support (enabled by default)
x     verbose mode, ignores whitespace and allow line comments (starting with `#`)
</pre>

Note that in verbose mode, whitespace is ignored everywhere, including within
character classes. To insert whitespace, use its escaped form or a hex literal.
For example, `\ ` or `\x20` for an ASCII space.

Flags can be toggled within a pattern. Here's an example that matches
case-insensitively for the first part but case-sensitively for the second part:

```rust
use regex::Regex;

let re = Regex::new(r"(?i)a+(?-i)b+").unwrap();
let m = re.find("AaAaAbbBBBb").unwrap();
assert_eq!(m.as_str(), "AaAaAbb");
```

Notice that the `a+` matches either `a` or `A`, but the `b+` only matches
`b`.

Multi-line mode means `^` and `$` no longer match just at the beginning/end of
the input, but also at the beginning/end of lines:

```
use regex::Regex;

let re = Regex::new(r"(?m)^line \d+").unwrap();
let m = re.find("line one\nline 2\n").unwrap();
assert_eq!(m.as_str(), "line 2");
```

Note that `^` matches after new lines, even at the end of input:

```
use regex::Regex;

let re = Regex::new(r"(?m)^").unwrap();
let m = re.find_iter("test\n").last().unwrap();
assert_eq!((m.start(), m.end()), (5, 5));
```

When both CRLF mode and multi-line mode are enabled, then `^` and `$` will
match either `\r` and `\n`, but never in the middle of a `\r\n`:

```
use regex::Regex;

let re = Regex::new(r"(?mR)^foo$").unwrap();
let m = re.find("\r\nfoo\r\n").unwrap();
assert_eq!(m.as_str(), "foo");
```

Unicode mode can also be selectively disabled, although only when the result
*would not* match invalid UTF-8. One good example of this is using an ASCII
word boundary instead of a Unicode word boundary, which might make some regex
searches run faster:

```rust
use regex::Regex;

let re = Regex::new(r"(?-u:\b).+(?-u:\b)").unwrap();
let m = re.find("$$abc$$").unwrap();
assert_eq!(m.as_str(), "abc");
```

### Escape sequences

Note that this includes all possible escape sequences, even ones that are
documented elsewhere.

<pre class="rust">
\*              literal *, applies to all ASCII except [0-9A-Za-z<>]
\a              bell (\x07)
\f              form feed (\x0C)
\t              horizontal tab
\n              new line
\r              carriage return
\v              vertical tab (\x0B)
\A              matches at the beginning of a haystack
\z              matches at the end of a haystack
\b              word boundary assertion
\B              negated word boundary assertion
\b{start}, \<   start-of-word boundary assertion
\b{end}, \>     end-of-word boundary assertion
\b{start-half}  half of a start-of-word boundary assertion
\b{end-half}    half of a end-of-word boundary assertion
\123            octal character code, up to three digits (when enabled)
\x7F            hex character code (exactly two digits)
\x{10FFFF}      any hex character code corresponding to a Unicode code point
\u007F          hex character code (exactly four digits)
\u{7F}          any hex character code corresponding to a Unicode code point
\U0000007F      hex character code (exactly eight digits)
\U{7F}          any hex character code corresponding to a Unicode code point
\p{Letter}      Unicode character class
\P{Letter}      negated Unicode character class
\d, \s, \w      Perl character class
\D, \S, \W      negated Perl character class
</pre>

### Perl character classes (Unicode friendly)

These classes are based on the definitions provided in
[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):

<pre class="rust">
\d     digit (\p{Nd})
\D     not digit
\s     whitespace (\p{White_Space})
\S     not whitespace
\w     word character (\p{Alphabetic} + \p{M} + \d + \p{Pc} + \p{Join_Control})
\W     not word character
</pre>

### ASCII character classes

These classes are based on the definitions provided in
[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):

<pre class="rust">
[[:alnum:]]    alphanumeric ([0-9A-Za-z])
[[:alpha:]]    alphabetic ([A-Za-z])
[[:ascii:]]    ASCII ([\x00-\x7F])
[[:blank:]]    blank ([\t ])
[[:cntrl:]]    control ([\x00-\x1F\x7F])
[[:digit:]]    digits ([0-9])
[[:graph:]]    graphical ([!-~])
[[:lower:]]    lower case ([a-z])
[[:print:]]    printable ([ -~])
[[:punct:]]    punctuation ([!-/:-@\[-`{-~])
[[:space:]]    whitespace ([\t\n\v\f\r ])
[[:upper:]]    upper case ([A-Z])
[[:word:]]     word characters ([0-9A-Za-z_])
[[:xdigit:]]   hex digit ([0-9A-Fa-f])
</pre>

# Untrusted input

This crate is meant to be able to run regex searches on untrusted haystacks
without fear of [ReDoS]. This crate also, to a certain extent, supports
untrusted patterns.

[ReDoS]: https://en.wikipedia.org/wiki/ReDoS

This crate differs from most (but not all) other regex engines in that it
doesn't use unbounded backtracking to run a regex search. In those cases,
one generally cannot use untrusted patterns *or* untrusted haystacks because
it can be very difficult to know whether a particular pattern will result in
catastrophic backtracking or not.

We'll first discuss how this crate deals with untrusted inputs and then wrap
it up with a realistic discussion about what practice really looks like.

### Panics

Outside of clearly documented cases, most APIs in this crate are intended to
never panic regardless of the inputs given to them. For example, `Regex::new`,
`Regex::is_match`, `Regex::find` and `Regex::captures` should never panic. That
is, it is an API promise that those APIs will never panic no matter what inputs
are given to them. With that said, regex engines are complicated beasts, and
providing a rock solid guarantee that these APIs literally never panic is
essentially equivalent to saying, "there are no bugs in this library." That is
a bold claim, and not really one that can be feasibly made with a straight
face.

Don't get the wrong impression here. This crate is extensively tested, not just
with unit and integration tests, but also via fuzz testing. For example, this
crate is part of the [OSS-fuzz project]. Panics should be incredibly rare, but
it is possible for bugs to exist, and thus possible for a panic to occur. If
you need a rock solid guarantee against panics, then you should wrap calls into
this library with [`std::panic::catch_unwind`].

It's also worth pointing out that this library will *generally* panic when
other regex engines would commit undefined behavior. When undefined behavior
occurs, your program might continue as if nothing bad has happened, but it also
might mean your program is open to the worst kinds of exploits. In contrast,
the worst thing a panic can do is a denial of service.

[OSS-fuzz project]: https://android.googlesource.com/platform/external/oss-fuzz/+/refs/tags/android-t-preview-1/projects/rust-regex/
[`std::panic::catch_unwind`]: https://doc.rust-lang.org/std/panic/fn.catch_unwind.html

### Untrusted patterns

The principal way this crate deals with them is by limiting their size by
default. The size limit can be configured via [`RegexBuilder::size_limit`]. The
idea of a size limit is that compiling a pattern into a `Regex` will fail if it
becomes "too big." Namely, while *most* resources consumed by compiling a regex
are approximately proportional (albeit with some high constant factors in some
cases, such as with Unicode character classes) to the length of the pattern
itself, there is one particular exception to this: counted repetitions. Namely,
this pattern:

```text
a{5}{5}{5}{5}{5}{5}
```

Is equivalent to this pattern:

```text
a{15625}
```

In both of these cases, the actual pattern string is quite small, but the
resulting `Regex` value is quite large. Indeed, as the first pattern shows,
it isn't enough to locally limit the size of each repetition because they can
be stacked in a way that results in exponential growth.

To provide a bit more context, a simplified view of regex compilation looks
like this:

* The pattern string is parsed into a structured representation called an AST.
Counted repetitions are not expanded and Unicode character classes are not
looked up in this stage. That is, the size of the AST is proportional to the
size of the pattern with "reasonable" constant factors. In other words, one
can reasonably limit the memory used by an AST by limiting the length of the
pattern string.
* The AST is translated into an HIR. Counted repetitions are still *not*
expanded at this stage, but Unicode character classes are embedded into the
HIR. The memory usage of a HIR is still proportional to the length of the
original pattern string, but the constant factors---mostly as a result of
Unicode character classes---can be quite high. Still though, the memory used by
an HIR can be reasonably limited by limiting the length of the pattern string.
* The HIR is compiled into a [Thompson NFA]. This is the stage at which
something like `\w{5}` is rewritten to `\w\w\w\w\w`. Thus, this is the stage
at which [`RegexBuilder::size_limit`] is enforced. If the NFA exceeds the
configured size, then this stage will fail.

[Thompson NFA]: https://en.wikipedia.org/wiki/Thompson%27s_construction

The size limit helps avoid two different kinds of exorbitant resource usage:

* It avoids permitting exponential memory usage based on the size of the
pattern string.
* It avoids long search times. This will be discussed in more detail in the
next section, but worst case search time *is* dependent on the size of the
regex. So keeping regexes limited to a reasonable size is also a way of keeping
search times reasonable.

Finally, it's worth pointing out that regex compilation is guaranteed to take
worst case `O(m)` time, where `m` is proportional to the size of regex. The
size of the regex here is *after* the counted repetitions have been expanded.

**Advice for those using untrusted regexes**: limit the pattern length to
something small and expand it as needed. Configure [`RegexBuilder::size_limit`]
to something small and then expand it as needed.

### Untrusted haystacks

The main way this crate guards against searches from taking a long time is by
using algorithms that guarantee a `O(m * n)` worst case time and space bound.
Namely:

* `m` is proportional to the size of the regex, where the size of the regex
includes the expansion of all counted repetitions. (See the previous section on
untrusted patterns.)
* `n` is proportional to the length, in bytes, of the haystack.

In other words, if you consider `m` to be a constant (for example, the regex
pattern is a literal in the source code), then the search can be said to run
in "linear time." Or equivalently, "linear time with respect to the size of the
haystack."

But the `m` factor here is important not to ignore. If a regex is
particularly big, the search times can get quite slow. This is why, in part,
[`RegexBuilder::size_limit`] exists.

**Advice for those searching untrusted haystacks**: As long as your regexes
are not enormous, you should expect to be able to search untrusted haystacks
without fear. If you aren't sure, you should benchmark it. Unlike backtracking
engines, if your regex is so big that it's likely to result in slow searches,
this is probably something you'll be able to observe regardless of what the
haystack is made up of.

### Iterating over matches

One thing that is perhaps easy to miss is that the worst case time
complexity bound of `O(m * n)` applies to methods like [`Regex::is_match`],
[`Regex::find`] and [`Regex::captures`]. It does **not** apply to
[`Regex::find_iter`] or [`Regex::captures_iter`]. Namely, since iterating over
all matches can execute many searches, and each search can scan the entire
haystack, the worst case time complexity for iterators is `O(m * n^2)`.

One example of where this occurs is when a pattern consists of an alternation,
where an earlier branch of the alternation requires scanning the entire
haystack only to discover that there is no match. It also requires a later
branch of the alternation to have matched at the beginning of the search. For
example, consider the pattern `.*[^A-Z]|[A-Z]` and the haystack `AAAAA`. The
first search will scan to the end looking for matches of `.*[^A-Z]` even though
a finite automata engine (as in this crate) knows that `[A-Z]` has already
matched the first character of the haystack. This is due to the greedy nature
of regex searching. That first search will report a match at the first `A` only
after scanning to the end to discover that no other match exists. The next
search then begins at the second `A` and the behavior repeats.

There is no way to avoid this. This means that if both patterns and haystacks
are untrusted and you're iterating over all matches, you're susceptible to
worst case quadratic time complexity. One possible way to mitigate this
is to drop down to the lower level `regex-automata` crate and use its
`meta::Regex` iterator APIs. There, you can configure the search to operate
in "earliest" mode by passing a `Input::new(haystack).earliest(true)` to
`meta::Regex::find_iter` (for example). By enabling this mode, you give up
the normal greedy match semantics of regex searches and instead ask the regex
engine to immediately stop as soon as a match has been found. Enabling this
mode will thus restore the worst case `O(m * n)` time complexity bound, but at
the cost of different semantics.

### Untrusted inputs in practice

While providing a `O(m * n)` worst case time bound on all searches goes a long
way toward preventing [ReDoS], that doesn't mean every search you can possibly
run will complete without burning CPU time. In general, there are a few ways
for the `m * n` time bound to still bite you:

* You are searching an exceptionally long haystack. No matter how you slice
it, a longer haystack will take more time to search. This crate may often make
very quick work of even long haystacks because of its literal optimizations,
but those aren't available for all regexes.
* Unicode character classes can cause searches to be quite slow in some cases.
This is especially true when they are combined with counted repetitions. While
the regex size limit above will protect you from the most egregious cases,
the default size limit still permits pretty big regexes that can execute more
slowly than one might expect.
* While routines like [`Regex::find`] and [`Regex::captures`] guarantee
worst case `O(m * n)` search time, routines like [`Regex::find_iter`] and
[`Regex::captures_iter`] actually have worst case `O(m * n^2)` search time.
This is because `find_iter` runs many searches, and each search takes worst
case `O(m * n)` time. Thus, iteration of all matches in a haystack has
worst case `O(m * n^2)`. A good example of a pattern that exhibits this is
`(?:A+){1000}|` or even `.*[^A-Z]|[A-Z]`.

In general, unstrusted haystacks are easier to stomach than untrusted patterns.
Untrusted patterns give a lot more control to the caller to impact the
performance of a search. In many cases, a regex search will actually execute in
average case `O(n)` time (i.e., not dependent on the size of the regex), but
this can't be guaranteed in general. Therefore, permitting untrusted patterns
means that your only line of defense is to put a limit on how big `m` (and
perhaps also `n`) can be in `O(m * n)`. `n` is limited by simply inspecting
the length of the haystack while `m` is limited by *both* applying a limit to
the length of the pattern *and* a limit on the compiled size of the regex via
[`RegexBuilder::size_limit`].

It bears repeating: if you're accepting untrusted patterns, it would be a good
idea to start with conservative limits on `m` and `n`, and then carefully
increase them as needed.

# Crate features

By default, this crate tries pretty hard to make regex matching both as fast
as possible and as correct as it can be. This means that there is a lot of
code dedicated to performance, the handling of Unicode data and the Unicode
data itself. Overall, this leads to more dependencies, larger binaries and
longer compile times. This trade off may not be appropriate in all cases, and
indeed, even when all Unicode and performance features are disabled, one is
still left with a perfectly serviceable regex engine that will work well in
many cases. (Note that code is not arbitrarily reducible, and for this reason,
the [`regex-lite`](https://docs.rs/regex-lite) crate exists to provide an even
more minimal experience by cutting out Unicode and performance, but still
maintaining the linear search time bound.)

This crate exposes a number of features for controlling that trade off. Some
of these features are strictly performance oriented, such that disabling them
won't result in a loss of functionality, but may result in worse performance.
Other features, such as the ones controlling the presence or absence of Unicode
data, can result in a loss of functionality. For example, if one disables the
`unicode-case` feature (described below), then compiling the regex `(?i)a`
will fail since Unicode case insensitivity is enabled by default. Instead,
callers must use `(?i-u)a` to disable Unicode case folding. Stated differently,
enabling or disabling any of the features below can only add or subtract from
the total set of valid regular expressions. Enabling or disabling a feature
will never modify the match semantics of a regular expression.

Most features below are enabled by default. Features that aren't enabled by
default are noted.

### Ecosystem features

* **std** -
  When enabled, this will cause `regex` to use the standard library. In terms
  of APIs, `std` causes error types to implement the `std::error::Error`
  trait. Enabling `std` will also result in performance optimizations,
  including SIMD and faster synchronization primitives. Notably, **disabling
  the `std` feature will result in the use of spin locks**. To use a regex
  engine without `std` and without spin locks, you'll need to drop down to
  the [`regex-automata`](https://docs.rs/regex-automata) crate.
* **logging** -
  When enabled, the `log` crate is used to emit messages about regex
  compilation and search strategies. This is **disabled by default**. This is
  typically only useful to someone working on this crate's internals, but might
  be useful if you're doing some rabbit hole performance hacking. Or if you're
  just interested in the kinds of decisions being made by the regex engine.

### Performance features

* **perf** -
  Enables all performance related features except for `perf-dfa-full`. This
  feature is enabled by default is intended to cover all reasonable features
  that improve performance, even if more are added in the future.
* **perf-dfa** -
  Enables the use of a lazy DFA for matching. The lazy DFA is used to compile
  portions of a regex to a very fast DFA on an as-needed basis. This can
  result in substantial speedups, usually by an order of magnitude on large
  haystacks. The lazy DFA does not bring in any new dependencies, but it can
  make compile times longer.
* **perf-dfa-full** -
  Enables the use of a full DFA for matching. Full DFAs are problematic because
  they have worst case `O(2^n)` construction time. For this reason, when this
  feature is enabled, full DFAs are only used for very small regexes and a
  very small space bound is used during determinization to avoid the DFA
  from blowing up. This feature is not enabled by default, even as part of
  `perf`, because it results in fairly sizeable increases in binary size and
  compilation time. It can result in faster search times, but they tend to be
  more modest and limited to non-Unicode regexes.
* **perf-onepass** -
  Enables the use of a one-pass DFA for extracting the positions of capture
  groups. This optimization applies to a subset of certain types of NFAs and
  represents the fastest engine in this crate for dealing with capture groups.
* **perf-backtrack** -
  Enables the use of a bounded backtracking algorithm for extracting the
  positions of capture groups. This usually sits between the slowest engine
  (the PikeVM) and the fastest engine (one-pass DFA) for extracting capture
  groups. It's used whenever the regex is not one-pass and is small enough.
* **perf-inline** -
  Enables the use of aggressive inlining inside match routines. This reduces
  the overhead of each match. The aggressive inlining, however, increases
  compile times and binary size.
* **perf-literal** -
  Enables the use of literal optimizations for speeding up matches. In some
  cases, literal optimizations can result in speedups of _several_ orders of
  magnitude. Disabling this drops the `aho-corasick` and `memchr` dependencies.
* **perf-cache** -
  This feature used to enable a faster internal cache at the cost of using
  additional dependencies, but this is no longer an option. A fast internal
  cache is now used unconditionally with no additional dependencies. This may
  change in the future.

### Unicode features

* **unicode** -
  Enables all Unicode features. This feature is enabled by default, and will
  always cover all Unicode features, even if more are added in the future.
* **unicode-age** -
  Provide the data for the
  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
  This makes it possible to use classes like `\p{Age:6.0}` to refer to all
  codepoints first introduced in Unicode 6.0
* **unicode-bool** -
  Provide the data for numerous Unicode boolean properties. The full list
  is not included here, but contains properties like `Alphabetic`, `Emoji`,
  `Lowercase`, `Math`, `Uppercase` and `White_Space`.
* **unicode-case** -
  Provide the data for case insensitive matching using
  [Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
* **unicode-gencat** -
  Provide the data for
  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
  This includes, but is not limited to, `Decimal_Number`, `Letter`,
  `Math_Symbol`, `Number` and `Punctuation`.
* **unicode-perl** -
  Provide the data for supporting the Unicode-aware Perl character classes,
  corresponding to `\w`, `\s` and `\d`. This is also necessary for using
  Unicode-aware word boundary assertions. Note that if this feature is
  disabled, the `\s` and `\d` character classes are still available if the
  `unicode-bool` and `unicode-gencat` features are enabled, respectively.
* **unicode-script** -
  Provide the data for
  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
  `Latin` and `Thai`.
* **unicode-segment** -
  Provide the data necessary to provide the properties used to implement the
  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
  This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
  `\p{sb=ATerm}`.

# Other crates

This crate has two required dependencies and several optional dependencies.
This section briefly describes them with the goal of raising awareness of how
different components of this crate may be used independently.

It is somewhat unusual for a regex engine to have dependencies, as most regex
libraries are self contained units with no dependencies other than a particular
environment's standard library. Indeed, for other similarly optimized regex
engines, most or all of the code in the dependencies of this crate would
normally just be unseparable or coupled parts of the crate itself. But since
Rust and its tooling ecosystem make the use of dependencies so easy, it made
sense to spend some effort de-coupling parts of this crate and making them
independently useful.

We only briefly describe each crate here.

* [`regex-lite`](https://docs.rs/regex-lite) is not a dependency of `regex`,
but rather, a standalone zero-dependency simpler version of `regex` that
prioritizes compile times and binary size. In exchange, it eschews Unicode
support and performance. Its match semantics are as identical as possible to
the `regex` crate, and for the things it supports, its APIs are identical to
the APIs in this crate. In other words, for a lot of use cases, it is a drop-in
replacement.
* [`regex-syntax`](https://docs.rs/regex-syntax) provides a regular expression
parser via `Ast` and `Hir` types. It also provides routines for extracting
literals from a pattern. Folks can use this crate to do analysis, or even to
build their own regex engine without having to worry about writing a parser.
* [`regex-automata`](https://docs.rs/regex-automata) provides the regex engines
themselves. One of the downsides of finite automata based regex engines is that
they often need multiple internal engines in order to have similar or better
performance than an unbounded backtracking engine in practice. `regex-automata`
in particular provides public APIs for a PikeVM, a bounded backtracker, a
one-pass DFA, a lazy DFA, a fully compiled DFA and a meta regex engine that
combines all them together. It also has native multi-pattern support and
provides a way to compile and serialize full DFAs such that they can be loaded
and searched in a no-std no-alloc environment. `regex-automata` itself doesn't
even have a required dependency on `regex-syntax`!
* [`memchr`](https://docs.rs/memchr) provides low level SIMD vectorized
routines for quickly finding the location of single bytes or even substrings
in a haystack. In other words, it provides fast `memchr` and `memmem` routines.
These are used by this crate in literal optimizations.
* [`aho-corasick`](https://docs.rs/aho-corasick) provides multi-substring
search. It also provides SIMD vectorized routines in the case where the number
of substrings to search for is relatively small. The `regex` crate also uses
this for literal optimizations.
*/SearchStepUtf8Patternlast_step_endRegexSearcherinto_searcheras_utf8_pattern/// A compiled regular expression for searching Unicode haystacks./// A `Regex` can be used to search haystacks, split haystacks into substrings/// or replace substrings in a haystack with a different substring. All/// searching is done with an implicit `(?s:.)*?` at the beginning and end of/// an pattern. To force an expression to match the whole string (or a prefix/// or a suffix), you must use an anchor like `^` or `$` (or `\A` and `\z`)./// Like the `Regex` type in the parent module, matches with this regex return/// byte offsets into the haystack. **Unlike** the parent `Regex` type, these/// byte offsets may not correspond to UTF-8 sequence boundaries since the/// regexes in this module can match arbitrary bytes./// The only methods that allocate new byte strings are the string replacement/// methods. All other methods (searching and splitting) return borrowed/// references into the haystack given./// Find the offsets of a US phone number:/// use regex::bytes::Regex;/// let re = Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}").unwrap();/// let m = re.find(b"phone: 111-222-3333").unwrap();/// assert_eq!(7..19, m.range());/// # Example: extracting capture groups/// A common way to use regexes is with capture groups. That is, instead of/// just looking for matches of an entire regex, parentheses are used to create/// groups that represent part of the match./// For example, consider a haystack with multiple lines, and each line has/// three whitespace delimited fields where the second field is expected to be/// a number and the third field a boolean. To make this convenient, we use/// the [`Captures::extract`] API to put the strings that match each group/// into a fixed size array:/// let hay = b"/// rabbit         54 true/// groundhog 2 true/// does not match/// fox   109    false/// let re = Regex::new(r"(?m)^\s*(\S+)\s+([0-9]+)\s+(true|false)\s*$").unwrap();/// let mut fields: Vec<(&[u8], i64, bool)> = vec![];/// for (_, [f1, f2, f3]) in re.captures_iter(hay).map(|caps| caps.extract()) {///     // These unwraps are OK because our pattern is written in a way where///     // all matches for f2 and f3 will be valid UTF-8.///     let f2 = std::str::from_utf8(f2).unwrap();///     let f3 = std::str::from_utf8(f3).unwrap();///     fields.push((f1, f2.parse()?, f3.parse()?));/// assert_eq!(fields, vec![///     (&b"rabbit"[..], 54, true),///     (&b"groundhog"[..], 2, true),///     (&b"fox"[..], 109, false),/// # Example: matching invalid UTF-8/// One of the reasons for searching `&[u8]` haystacks is that the `&[u8]`/// might not be valid UTF-8. Indeed, with a `bytes::Regex`, patterns that/// match invalid UTF-8 are explicitly allowed. Here's one example that looks/// for valid UTF-8 fields that might be separated by invalid UTF-8. In this/// case, we use `(?s-u:.)`, which matches any byte. Attempting to use it in a/// top-level `Regex` will result in the regex failing to compile. Notice also/// that we use `.` with Unicode mode enabled, in which case, only valid UTF-8/// is matched. In this way, we can build one pattern where some parts only/// match valid UTF-8 while other parts are more permissive./// // F0 9F 92 A9 is the UTF-8 encoding for a Pile of Poo./// let hay = b"\xFF\xFFfoo\xFF\xFF\xFF\xF0\x9F\x92\xA9\xFF";/// // An equivalent to '(?s-u:.)' is '(?-u:[\x00-\xFF])'./// let re = Regex::new(r"(?s)(?-u:.)*?(?<f1>.+)(?-u:.)*?(?<f2>.+)").unwrap();/// let caps = re.captures(hay).unwrap();/// assert_eq!(&caps["f1"], &b"foo"[..]);/// assert_eq!(&caps["f2"], "💩".as_bytes());/// Shows the original regular expression./// Attempts to parse a string into a regular expression/// Compiles a regular expression. Once compiled, it can be used repeatedly/// to search, split or replace substrings in a haystack./// Note that regex compilation tends to be a somewhat expensive process,/// and unlike higher level environments, compilation is not automatically/// cached for you. One should endeavor to compile a regex once and then/// reuse it. For example, it's a bad idea to compile the same regex/// repeatedly in a loop./// If an invalid pattern is given, then an error is returned./// An error is also returned if the pattern is valid, but would/// produce a regex that is bigger than the configured size limit via/// [`RegexBuilder::size_limit`]. (A reasonable size limit is enabled by/// default.)/// // An Invalid pattern because of an unclosed parenthesis/// assert!(Regex::new(r"foo(bar").is_err());/// // An invalid pattern because the regex would be too big/// // because Unicode tends to inflate things./// assert!(Regex::new(r"\w{1000}").is_err());/// // Disabling Unicode can make the regex much smaller,/// // potentially by up to or more than an order of magnitude./// assert!(Regex::new(r"(?-u:\w){1000}").is_ok());/// Returns true if and only if there is a match for the regex anywhere/// in the haystack given./// It is recommended to use this method if all you need to do is test/// whether a match exists, since the underlying matching engine may be/// able to do less work./// Test if some haystack contains at least one word with exactly 13/// Unicode word characters:/// let re = Regex::new(r"\b\w{13}\b").unwrap();/// let hay = b"I categorically deny having triskaidekaphobia.";/// This routine searches for the first match of this regex in the/// haystack given, and if found, returns a [`Match`]. The `Match`/// provides access to both the byte offsets of the match and the actual/// substring that matched./// Note that this should only be used if you want to find the entire/// match. If instead you just want to test the existence of a match,/// it's potentially faster to use `Regex::is_match(hay)` instead of/// `Regex::find(hay).is_some()`./// Find the first word with exactly 13 Unicode word characters:/// let mat = re.find(hay).unwrap();/// assert_eq!(2..15, mat.range());/// assert_eq!(b"categorically", mat.as_bytes());/// Returns an iterator that yields successive non-overlapping matches in/// the given haystack. The iterator yields values of type [`Match`]./// # Time complexity/// Note that since `find_iter` runs potentially many searches on the/// haystack and since each search has worst case `O(m * n)` time/// complexity, the overall worst case time complexity for iteration is/// `O(m * n^2)`./// Find every word with exactly 13 Unicode word characters:/// let hay = b"Retroactively relinquishing remunerations is reprehensible.";/// let matches: Vec<_> = re.find_iter(hay).map(|m| m.as_bytes()).collect();///     &b"Retroactively"[..],///     &b"relinquishing"[..],///     &b"remunerations"[..],///     &b"reprehensible"[..],/// This routine searches for the first match of this regex in the haystack/// given, and if found, returns not only the overall match but also the/// matches of each capture group in the regex. If no match is found, then/// Capture group `0` always corresponds to an implicit unnamed group that/// includes the entire match. If a match is found, this group is always/// present. Subsequent groups may be named and are numbered, starting/// at 1, by the order in which the opening parenthesis appears in the/// pattern. For example, in the pattern `(?<a>.(?<b>.))(?<c>.)`, `a`,/// `b` and `c` correspond to capture group indices `1`, `2` and `3`,/// You should only use `captures` if you need access to the capture group/// matches. Otherwise, [`Regex::find`] is generally faster for discovering/// just the overall match./// Say you have some haystack with movie names and their release years,/// like "'Citizen Kane' (1941)". It'd be nice if we could search for/// strings looking like that, while also extracting the movie name and its/// release year separately. The example below shows how to do that./// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();/// let hay = b"Not my favorite movie: 'Citizen Kane' (1941).";/// assert_eq!(caps.get(0).unwrap().as_bytes(), b"'Citizen Kane' (1941)");/// assert_eq!(caps.get(1).unwrap().as_bytes(), b"Citizen Kane");/// assert_eq!(caps.get(2).unwrap().as_bytes(), b"1941");/// // You can also access the groups by index using the Index notation./// // Note that this will panic on an invalid index. In this case, these/// // accesses are always correct because the overall regex will only/// // match when these capture groups match./// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");/// assert_eq!(&caps[1], b"Citizen Kane");/// assert_eq!(&caps[2], b"1941");/// Note that the full match is at capture group `0`. Each subsequent/// capture group is indexed by the order of its opening `(`./// We can make this example a bit clearer by using *named* capture groups:/// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>\d{4})\)").unwrap();/// assert_eq!(caps.name("title").unwrap().as_bytes(), b"Citizen Kane");/// assert_eq!(caps.name("year").unwrap().as_bytes(), b"1941");/// // You can also access the groups by name using the Index notation./// // Note that this will panic on an invalid group name. In this case,/// // these accesses are always correct because the overall regex will/// // only match when these capture groups match./// assert_eq!(&caps["title"], b"Citizen Kane");/// assert_eq!(&caps["year"], b"1941");/// Here we name the capture groups, which we can access with the `name`/// method or the `Index` notation with a `&str`. Note that the named/// capture groups are still accessible with `get` or the `Index` notation/// with a `usize`./// The `0`th capture group is always unnamed, so it must always be/// accessed with `get(0)` or `[0]`./// Finally, one other way to to get the matched substrings is with the/// [`Captures::extract`] API:/// let (full, [title, year]) = re.captures(hay).unwrap().extract();/// assert_eq!(full, b"'Citizen Kane' (1941)");/// assert_eq!(title, b"Citizen Kane");/// assert_eq!(year, b"1941");captures_iter/// the given haystack. The iterator yields values of type [`Captures`]./// This is the same as [`Regex::find_iter`], but instead of only providing/// access to the overall match, each value yield includes access to the/// matches of all capture groups in the regex. Reporting this extra match/// data is potentially costly, so callers should only use `captures_iter`/// over `find_iter` when they actually need access to the capture group/// Note that since `captures_iter` runs potentially many searches on the/// We can use this to find all movie titles and their release years in/// some haystack, where the movie is formatted like "'Title' (xxxx)":/// let re = Regex::new(r"'([^']+)'\s+\(([0-9]{4})\)").unwrap();/// let hay = b"'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";/// let mut movies = vec![];/// for (_, [title, year]) in re.captures_iter(hay).map(|c| c.extract()) {///     // OK because [0-9]{4} can only match valid UTF-8.///     let year = std::str::from_utf8(year).unwrap();///     movies.push((title, year.parse::<i64>()?));/// assert_eq!(movies, vec![///     (&b"Citizen Kane"[..], 1941),///     (&b"The Wizard of Oz"[..], 1939),///     (&b"M"[..], 1931),/// Or with named groups:/// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>[0-9]{4})\)").unwrap();/// let mut it = re.captures_iter(hay);/// let caps = it.next().unwrap();/// assert_eq!(&caps["title"], b"The Wizard of Oz");/// assert_eq!(&caps["year"], b"1939");/// assert_eq!(&caps["title"], b"M");/// assert_eq!(&caps["year"], b"1931");/// Returns an iterator of substrings of the haystack given, delimited by a/// match of the regex. Namely, each element of the iterator corresponds to/// a part of the haystack that *isn't* matched by the regular expression./// Since iterators over all matches requires running potentially many/// searches on the haystack, and since each search has worst case/// `O(m * n)` time complexity, the overall worst case time complexity for/// this routine is `O(m * n^2)`./// To split a string delimited by arbitrary amounts of spaces or tabs:/// let re = Regex::new(r"[ \t]+").unwrap();/// let hay = b"a b \t  c\td    e";/// let fields: Vec<&[u8]> = re.split(hay).collect();///     &b"a"[..], &b"b"[..], &b"c"[..], &b"d"[..], &b"e"[..],/// # Example: more cases/// let re = Regex::new(r" ").unwrap();/// let hay = b"Mary had a little lamb";/// let got: Vec<&[u8]> = re.split(hay).collect();/// assert_eq!(got, vec![///     &b"Mary"[..], &b"had"[..], &b"a"[..], &b"little"[..], &b"lamb"[..],/// let re = Regex::new(r"X").unwrap();/// let hay = b"";/// assert_eq!(got, vec![&b""[..]]);/// let hay = b"lionXXtigerXleopard";///     &b"lion"[..], &b""[..], &b"tiger"[..], &b"leopard"[..],/// let re = Regex::new(r"::").unwrap();/// let hay = b"lion::tiger::leopard";/// assert_eq!(got, vec![&b"lion"[..], &b"tiger"[..], &b"leopard"[..]]);/// If a haystack contains multiple contiguous matches, you will end up/// with empty spans yielded by the iterator:/// let hay = b"XXXXaXXbXc";///     &b""[..], &b""[..], &b""[..], &b""[..],///     &b"a"[..], &b""[..], &b"b"[..], &b"c"[..],/// let re = Regex::new(r"/").unwrap();/// let hay = b"(///)";/// assert_eq!(got, vec![&b"("[..], &b""[..], &b""[..], &b")"[..]]);/// Separators at the start or end of a haystack are neighbored by empty/// substring./// let re = Regex::new(r"0").unwrap();/// let hay = b"010";/// assert_eq!(got, vec![&b""[..], &b"1"[..], &b""[..]]);/// When the regex can match the empty string, it splits at every byte/// position in the haystack. This includes between all UTF-8 code units./// (The top-level [`Regex::split`](crate::Regex::split) will only split/// at valid UTF-8 boundaries.)/// let re = Regex::new(r"").unwrap();/// let hay = "☃".as_bytes();///     &[][..], &[b'\xE2'][..], &[b'\x98'][..], &[b'\x83'][..], &[][..],/// Contiguous separators (commonly shows up with whitespace), can lead to/// possibly surprising behavior. For example, this code is correct:/// let hay = b"    a  b c";/// It does *not* give you `["a", "b", "c"]`. For that behavior, you'd want/// to match contiguous space characters:/// let re = Regex::new(r" +").unwrap();/// // N.B. This does still include a leading empty span because ' +'/// // matches at the beginning of the haystack./// assert_eq!(got, vec![&b""[..], &b"a"[..], &b"b"[..], &b"c"[..]]);/// Returns an iterator of at most `limit` substrings of the haystack/// given, delimited by a match of the regex. (A `limit` of `0` will return/// no substrings.) Namely, each element of the iterator corresponds to a/// part of the haystack that *isn't* matched by the regular expression./// The remainder of the haystack that is not split will be the last/// element in the iterator./// Although note that the worst case time here has an upper bound given/// by the `limit` parameter./// Get the first two words in some haystack:/// let re = Regex::new(r"\W+").unwrap();/// let hay = b"Hey! How are you?";/// let fields: Vec<&[u8]> = re.splitn(hay, 3).collect();/// assert_eq!(fields, vec![&b"Hey"[..], &b"How"[..], &b"are you?"[..]]);/// # Examples: more cases/// let got: Vec<&[u8]> = re.splitn(hay, 3).collect();/// assert_eq!(got, vec![&b"Mary"[..], &b"had"[..], &b"a little lamb"[..]]);/// assert_eq!(got, vec![&b"lion"[..], &b""[..], &b"tigerXleopard"[..]]);/// let got: Vec<&[u8]> = re.splitn(hay, 2).collect();/// assert_eq!(got, vec![&b"lion"[..], &b"tiger::leopard"[..]]);/// let hay = b"abcXdef";/// let got: Vec<&[u8]> = re.splitn(hay, 1).collect();/// assert_eq!(got, vec![&b"abcXdef"[..]]);/// let hay = b"abcdef";/// assert_eq!(got, vec![&b"abcdef"[..]]);/// let got: Vec<&[u8]> = re.splitn(hay, 0).collect();/// assert!(got.is_empty());Replacer/// Replaces the leftmost-first match in the given haystack with the/// replacement provided. The replacement can be a regular string (where/// `$N` and `$name` are expanded to match capture groups) or a function/// that takes a [`Captures`] and returns the replaced string./// If no match is found, then the haystack is returned unchanged. In that/// case, this implementation will likely return a `Cow::Borrowed` value/// such that no allocation is performed./// When a `Cow::Borrowed` is returned, the value returned is guaranteed/// to be equivalent to the `haystack` given./// # Replacement string syntax/// All instances of `$ref` in the replacement string are replaced with/// the substring corresponding to the capture group identified by `ref`./// `ref` may be an integer corresponding to the index of the capture group/// (counted by order of opening parenthesis where `0` is the entire match)/// or it can be a name (consisting of letters, digits or underscores)/// corresponding to a named capture group./// If `ref` isn't a valid capture group (whether the name doesn't exist or/// isn't a valid index), then it is replaced with the empty string./// The longest possible name is used. For example, `$1a` looks up the/// capture group named `1a` and not the capture group at index `1`. To/// exert more precise control over the name, use braces, e.g., `${1}a`./// To write a literal `$` use `$$`./// Note that this function is polymorphic with respect to the replacement./// In typical usage, this can just be a normal string:/// let re = Regex::new(r"[^01]+").unwrap();/// assert_eq!(re.replace(b"1078910", b""), &b"1010"[..]);/// But anything satisfying the [`Replacer`] trait will work. For example,/// a closure of type `|&Captures| -> String` provides direct access to the/// captures corresponding to a match. This allows one to access capturing/// group matches easily:/// use regex::bytes::{Captures, Regex};/// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();/// let result = re.replace(b"Springsteen, Bruce", |caps: &Captures| {///     let mut buf = vec![];///     buf.extend_from_slice(&caps[2]);///     buf.push(b' ');///     buf.extend_from_slice(&caps[1]);/// assert_eq!(result, &b"Bruce Springsteen"[..]);/// But this is a bit cumbersome to use all the time. Instead, a simple/// syntax is supported (as described above) that expands `$name` into the/// corresponding capture group. Here's the last example, but using this/// expansion technique with named capture groups:/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();/// let result = re.replace(b"Springsteen, Bruce", b"$first $last");/// Note that using `$2` instead of `$first` or `$1` instead of `$last`/// would produce the same result. To write a literal `$` use `$$`./// Sometimes the replacement string requires use of curly braces to/// delineate a capture group replacement when it is adjacent to some other/// literal text. For example, if we wanted to join two words together with/// an underscore:/// let re = Regex::new(r"(?<first>\w+)\s+(?<second>\w+)").unwrap();/// let result = re.replace(b"deep fried", b"${first}_$second");/// assert_eq!(result, &b"deep_fried"[..]);/// Without the curly braces, the capture group name `first_` would be/// used, and since it doesn't exist, it would be replaced with the empty/// Finally, sometimes you just want to replace a literal string with no/// regard for capturing group expansion. This can be done by wrapping a/// string with [`NoExpand`]:/// use regex::bytes::{NoExpand, Regex};/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();/// let result = re.replace(b"Springsteen, Bruce", NoExpand(b"$2 $last"));/// assert_eq!(result, &b"$2 $last"[..]);/// Using `NoExpand` may also be faster, since the replacement string won't/// need to be parsed for the `$` syntax./// Replaces all non-overlapping matches in the haystack with the/// replacement provided. This is the same as calling `replacen` with/// `limit` set to `0`./// The documentation for [`Regex::replace`] goes into more detail about/// what kinds of replacement strings are supported./// If you need to write a replacement routine where any individual/// replacement might "fail," doing so with this API isn't really feasible/// because there's no way to stop the search process if a replacement/// fails. Instead, if you need this functionality, you should consider/// implementing your own replacement routine:/// fn replace_all<E>(///     re: &Regex,///     replacement: impl Fn(&Captures) -> Result<Vec<u8>, E>,/// ) -> Result<Vec<u8>, E> {///     let mut new = Vec::with_capacity(haystack.len());///     let mut last_match = 0;///     for caps in re.captures_iter(haystack) {///         let m = caps.get(0).unwrap();///         new.extend_from_slice(&haystack[last_match..m.start()]);///         new.extend_from_slice(&replacement(&caps)?);///         last_match = m.end();///     new.extend_from_slice(&haystack[last_match..]);///     Ok(new)/// // Let's replace each word with the number of bytes in that word./// // But if we see a word that is "too long," we'll give up./// let re = Regex::new(r"\w+").unwrap();/// let replacement = |caps: &Captures| -> Result<Vec<u8>, &'static str> {///     if caps[0].len() >= 5 {///         return Err("word too long");///     Ok(caps[0].len().to_string().into_bytes())///     Ok(b"2 3 3 3?".to_vec()),///     replace_all(&re, b"hi how are you?", &replacement),/// assert!(replace_all(&re, b"hi there", &replacement).is_err());/// This example shows how to flip the order of whitespace (excluding line/// terminators) delimited fields, and normalizes the whitespace that/// delimits the fields:/// let re = Regex::new(r"(?m)^(\S+)[\s--\r\n]+(\S+)$").unwrap();/// Greetings  1973/// Wild\t1973/// BornToRun\t\t\t\t1975/// Darkness                    1978/// TheRiver 1980/// let new = re.replace_all(hay, b"$2 $1");/// assert_eq!(new, &b"/// 1973 Greetings/// 1973 Wild/// 1975 BornToRun/// 1978 Darkness/// 1980 TheRiver/// "[..]);replacen/// Replaces at most `limit` non-overlapping matches in the haystack with/// the replacement provided. If `limit` is `0`, then all non-overlapping/// matches are replaced. That is, `Regex::replace_all(hay, rep)` is/// equivalent to `Regex::replacen(hay, 0, rep)`./// See the corresponding section in the docs for [`Regex::replace_all`]/// for tips on how to deal with a replacement routine that can fail./// delimits the fields. But we only do it for the first two matches./// let new = re.replacen(hay, 2, b"$2 $1");/// Core regular expression methods.shortest_match/// Returns the end byte offset of the first match in the haystack given./// This method may have the same performance characteristics as/// `is_match`. Behaviorlly, it doesn't just report whether it match/// occurs, but also the end offset for a match. In particular, the offset/// returned *may be shorter* than the proper end of the leftmost-first/// match that you would find via [`Regex::find`]./// Note that it is not guaranteed that this routine finds the shortest or/// "earliest" possible match. Instead, the main idea of this API is that/// it returns the offset at the point at which the internal regex engine/// has determined that a match has occurred. This may vary depending on/// which internal regex engine is used, and thus, the offset itself may/// change based on internal heuristics./// Typically, `a+` would match the entire first sequence of `a` in some/// haystack, but `shortest_match` *may* give up as soon as it sees the/// first `a`./// let re = Regex::new(r"a+").unwrap();/// let offset = re.shortest_match(b"aaaaa").unwrap();/// assert_eq!(offset, 1);shortest_match_at/// Returns the same as `shortest_match`, but starts the search at the/// given offset./// The significance of the starting point is that it takes the surrounding/// context into consideration. For example, the `\A` anchor can only match/// when `start == 0`./// If a match is found, the offset returned is relative to the beginning/// of the haystack, not the beginning of the search./// This panics when `start >= haystack.len() + 1`./// This example shows the significance of `start` by demonstrating how it/// can be used to permit look-around assertions in a regex to take the/// surrounding context into account./// let re = Regex::new(r"\bchew\b").unwrap();/// let hay = b"eschew";/// // We get a match here, but it's probably not intended./// assert_eq!(re.shortest_match(&hay[2..]), Some(4));/// // No match because the  assertions take the context into account./// assert_eq!(re.shortest_match_at(hay, 2), None);is_match_at/// Returns the same as [`Regex::is_match`], but starts the search at the/// context into consideration. For example, the `\A` anchor can only/// match when `start == 0`./// assert!(re.is_match(&hay[2..]));/// assert!(!re.is_match_at(hay, 2));/// Returns the same as [`Regex::find`], but starts the search at the given/// assert_eq!(re.find(&hay[2..]).map(|m| m.range()), Some(0..4));/// assert_eq!(re.find_at(hay, 2), None);captures_at/// Returns the same as [`Regex::captures`], but starts the search at the/// assert_eq!(&re.captures(&hay[2..]).unwrap()[0], b"chew");/// assert!(re.captures_at(hay, 2).is_none());captures_readCaptureLocations/// This is like [`Regex::captures`], but writes the byte offsets of each/// capture group match into the locations given./// A [`CaptureLocations`] stores the same byte offsets as a [`Captures`],/// but does *not* store a reference to the haystack. This makes its API/// a bit lower level and less convenient. But in exchange, callers/// may allocate their own `CaptureLocations` and reuse it for multiple/// searches. This may be helpful if allocating a `Captures` shows up in a/// profile as too costly./// To create a `CaptureLocations` value, use the/// [`Regex::capture_locations`] method./// This also returns the overall match if one was found. When a match is/// found, its offsets are also always stored in `locs` at index `0`./// let re = Regex::new(r"^([a-z]+)=(\S*)$").unwrap();/// let mut locs = re.capture_locations();/// assert!(re.captures_read(&mut locs, b"id=foo123").is_some());/// assert_eq!(Some((0, 9)), locs.get(0));/// assert_eq!(Some((0, 2)), locs.get(1));/// assert_eq!(Some((3, 9)), locs.get(2));captures_read_at/// Returns the same as [`Regex::captures_read`], but starts the search at/// the given offset./// assert!(re.captures_read(&mut locs, &hay[2..]).is_some());/// assert!(re.captures_read_at(&mut locs, hay, 2).is_none());read_captures_at/// An undocumented alias for `captures_read_at`./// The `regex-capi` crate previously used this routine, so to avoid/// breaking that crate, we continue to provide the name as an undocumented/// alias./// A group of advanced or "lower level" search methods. Some methods permit/// starting the search at a position greater than `0` in the haystack. Other/// methods permit reusing allocations, for example, when extracting the/// matches for capture groups./// Returns the original string of this regex./// let re = Regex::new(r"foo\w+bar").unwrap();/// assert_eq!(re.as_str(), r"foo\w+bar");capture_namesCaptureNames/// Returns an iterator over the capture names in this regex./// The iterator returned yields elements of type `Option<&str>`. That is,/// the iterator yields values for all capture groups, even ones that are/// unnamed. The order of the groups corresponds to the order of the group's/// corresponding opening parenthesis./// The first element of the iterator always yields the group corresponding/// to the overall match, and this group is always unnamed. Therefore, the/// iterator always yields at least one group./// This shows basic usage with a mix of named and unnamed capture groups:/// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();/// let mut names = re.capture_names();/// assert_eq!(names.next(), Some(None));/// assert_eq!(names.next(), Some(Some("a")));/// assert_eq!(names.next(), Some(Some("b")));/// // the '(?:.)' group is non-capturing and so doesn't appear here!/// assert_eq!(names.next(), Some(Some("c")));/// assert_eq!(names.next(), None);/// The iterator always yields at least one element, even for regexes with/// no capture groups and even for regexes that can never match:/// let re = Regex::new(r"[a&&b]").unwrap();captures_len/// Returns the number of captures groups in this regex./// This includes all named and unnamed groups, including the implicit/// unnamed group that is always present and corresponds to the entire/// Since the implicit unnamed group is always included in this length, the/// length returned is guaranteed to be greater than zero./// let re = Regex::new(r"foo").unwrap();/// assert_eq!(1, re.captures_len());/// let re = Regex::new(r"(foo)").unwrap();/// assert_eq!(2, re.captures_len());/// assert_eq!(5, re.captures_len());static_captures_len/// Returns the total number of capturing groups that appear in every/// possible match./// If the number of capture groups can vary depending on the match, then/// this returns `None`. That is, a value is only returned when the number/// of matching groups is invariant or "static."/// Note that like [`Regex::captures_len`], this **does** include the/// implicit capturing group corresponding to the entire match. Therefore,/// when a non-None value is returned, it is guaranteed to be at least `1`./// Stated differently, a return value of `Some(0)` is impossible./// This shows a few cases where a static number of capture groups is/// available and a few cases where it is not./// let len = |pattern| {///     Regex::new(pattern).map(|re| re.static_captures_len())/// assert_eq!(Some(1), len("a")?);/// assert_eq!(Some(2), len("(a)")?);/// assert_eq!(Some(2), len("(a)|(b)")?);/// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);/// assert_eq!(None, len("(a)|b")?);/// assert_eq!(None, len("a|(b)")?);/// assert_eq!(None, len("(b)*")?);/// assert_eq!(Some(2), len("(b)+")?);capture_locations/// Returns a fresh allocated set of capture locations that can/// be reused in multiple calls to [`Regex::captures_read`] or/// [`Regex::captures_read_at`]./// let re = Regex::new(r"(.)(.)(\w+)").unwrap();/// assert!(re.captures_read(&mut locs, b"Padron").is_some());/// assert_eq!(locs.get(0), Some((0, 6)));/// assert_eq!(locs.get(1), Some((0, 1)));/// assert_eq!(locs.get(2), Some((1, 2)));/// assert_eq!(locs.get(3), Some((2, 6)));/// An alias for `capture_locations` to preserve backward compatibility./// The `regex-capi` crate uses this method, so to avoid breaking that/// crate, we continue to export it as an undocumented API./// Auxiliary methods./// Represents a single match of a regex in a haystack./// A `Match` contains both the start and end byte offsets of the match and the/// actual substring corresponding to the range of those byte offsets. It is/// guaranteed that `start <= end`. When `start == end`, the match is empty./// Unlike the top-level `Match` type, this `Match` type is produced by APIs/// that search `&[u8]` haystacks. This means that the offsets in a `Match` can/// point to anywhere in the haystack, including in a place that splits the/// UTF-8 encoding of a Unicode scalar value./// The lifetime parameter `'h` refers to the lifetime of the matched of the/// haystack that this match was produced from./// # Numbering/// The byte offsets in a `Match` form a half-open interval. That is, the/// start of the range is inclusive and the end of the range is exclusive./// For example, given a haystack `abcFOOxyz` and a match of `FOO`, its byte/// offset range starts at `3` and ends at `6`. `3` corresponds to `F` and/// `6` corresponds to `x`, which is one past the end of the match. This/// corresponds to the same kind of slicing that Rust uses./// For more on why this was chosen over other schemes (aside from being/// consistent with how Rust the language works), see [this discussion] and/// [Dijkstra's note on a related topic][note]./// [this discussion]: https://github.com/rust-lang/regex/discussions/866/// [note]: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html/// This example shows the value of each of the methods on `Match` for a/// particular search./// let re = Regex::new(r"\p{Greek}+").unwrap();/// let hay = "Greek: αβγδ".as_bytes();/// let m = re.find(hay).unwrap();/// assert_eq!(7, m.start());/// assert_eq!(15, m.end());/// assert!(!m.is_empty());/// assert_eq!(8, m.len());/// assert_eq!(7..15, m.range());/// assert_eq!("αβγδ".as_bytes(), m.as_bytes());/// Returns the byte offset of the start of the match in the haystack. The/// start of the match corresponds to the position where the match begins/// and includes the first byte in the match./// It is guaranteed that `Match::start() <= Match::end()`./// Unlike the top-level `Match` type, the start offset may appear anywhere/// in the haystack. This includes between the code units of a UTF-8/// encoded Unicode scalar value./// Returns the byte offset of the end of the match in the haystack. The/// end of the match corresponds to the byte immediately following the last/// byte in the match. This means that `&slice[start..end]` works as one/// would expect./// Returns true if and only if this match has a length of zero./// Note that an empty match can only occur when the regex itself can/// match the empty string. Here are some examples of regexes that can/// all match the empty string: `^`, `^$`, `\b`, `a?`, `a*`, `a{0}`,/// `(foo|\d+|quux)?`./// Returns the length, in bytes, of this match./// Returns the range over the starting and ending byte offsets of the/// match in the haystack./// Returns the substring of the haystack that matched./// Creates a new match from the given haystack and byte offsets./// Represents the capture groups for a single match./// Capture groups refer to parts of a regex enclosed in parentheses. They/// can be optionally named. The purpose of capture groups is to be able to/// reference different parts of a match based on the original pattern. In/// essence, a `Captures` is a container of [`Match`] values for each group/// that participated in a regex match. Each `Match` can be looked up by either/// its capture group index or name (if it has one)./// For example, say you want to match the individual letters in a 5-letter/// word:/// (?<first>\w)(\w)(?:\w)\w(?<last>\w)/// This regex has 4 capture groups:/// * The group at index `0` corresponds to the overall match. It is always/// present in every match and never has a name./// * The group at index `1` with name `first` corresponding to the first/// letter./// * The group at index `2` with no name corresponding to the second letter./// * The group at index `3` with name `last` corresponding to the fifth and/// last letter./// Notice that `(?:\w)` was not listed above as a capture group despite it/// being enclosed in parentheses. That's because `(?:pattern)` is a special/// syntax that permits grouping but *without* capturing. The reason for not/// treating it as a capture is that tracking and reporting capture groups/// requires additional state that may lead to slower searches. So using as few/// capture groups as possible can help performance. (Although the difference/// in performance of a couple of capture groups is likely immaterial.)/// Values with this type are created by [`Regex::captures`] or/// [`Regex::captures_iter`]./// `'h` is the lifetime of the haystack that these captures were matched from./// let re = Regex::new(r"(?<first>\w)(\w)(?:\w)\w(?<last>\w)").unwrap();/// let caps = re.captures(b"toady").unwrap();/// assert_eq!(b"toady", &caps[0]);/// assert_eq!(b"t", &caps["first"]);/// assert_eq!(b"o", &caps[2]);/// assert_eq!(b"y", &caps["last"]);/// Returns the `Match` associated with the capture group at index `i`. If/// `i` does not correspond to a capture group, or if the capture group did/// not participate in the match, then `None` is returned./// When `i == 0`, this is guaranteed to return a non-`None` value./// Get the substring that matched with a default of an empty string if the/// group didn't participate in the match:/// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();/// let caps = re.captures(b"abc123").unwrap();/// let substr1 = caps.get(1).map_or(&b""[..], |m| m.as_bytes());/// let substr2 = caps.get(2).map_or(&b""[..], |m| m.as_bytes());/// assert_eq!(substr1, b"123");/// assert_eq!(substr2, b"");/// Returns the `Match` associated with the capture group named `name`. If/// `name` isn't a valid capture group or it refers to a group that didn't/// match, then `None` is returned./// Note that unlike `caps["name"]`, this returns a `Match` whose lifetime/// matches the lifetime of the haystack in this `Captures` value./// Conversely, the substring returned by `caps["name"]` has a lifetime/// of the `Captures` value, which is likely shorter than the lifetime of/// the haystack. In some cases, it may be necessary to use this method to/// access the matching substring instead of the `caps["name"]` notation./// let re = Regex::new(///     r"[a-z]+(?:(?<numbers>[0-9]+)|(?<letters>[A-Z]+))",/// let numbers = caps.name("numbers").map_or(&b""[..], |m| m.as_bytes());/// let letters = caps.name("letters").map_or(&b""[..], |m| m.as_bytes());/// assert_eq!(numbers, b"123");/// assert_eq!(letters, b"");/// This is a convenience routine for extracting the substrings/// corresponding to matching capture groups./// This returns a tuple where the first element corresponds to the full/// substring of the haystack that matched the regex. The second element is/// an array of substrings, with each corresponding to the substring that/// matched for a particular capture group./// This panics if the number of possible matching groups in this/// `Captures` value is not fixed to `N` in all circumstances./// More precisely, this routine only works when `N` is equivalent to/// [`Regex::static_captures_len`]./// Stated more plainly, if the number of matching capture groups in a/// regex can vary from match to match, then this function always panics./// For example, `(a)(b)|(c)` could produce two matching capture groups/// or one matching capture group for any given match. Therefore, one/// cannot use `extract` with such a pattern./// But a pattern like `(a)(b)|(c)(d)` can be used with `extract` because/// the number of capture groups in every match is always equivalent,/// even if the capture _indices_ in each match are not./// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();/// let hay = b"On 2010-03-14, I became a Tenneessee lamb.";/// let Some((full, [year, month, day])) =///     re.captures(hay).map(|caps| caps.extract()) else { return };/// assert_eq!(b"2010-03-14", full);/// assert_eq!(b"2010", year);/// assert_eq!(b"03", month);/// assert_eq!(b"14", day);/// # Example: iteration/// This example shows how to use this method when iterating over all/// `Captures` matches in a haystack./// let hay = b"1973-01-05, 1975-08-25 and 1980-10-18";/// let mut dates: Vec<(&[u8], &[u8], &[u8])> = vec![];/// for (_, [y, m, d]) in re.captures_iter(hay).map(|c| c.extract()) {///     dates.push((y, m, d));/// assert_eq!(dates, vec![///     (&b"1973"[..], &b"01"[..], &b"05"[..]),///     (&b"1975"[..], &b"08"[..], &b"25"[..]),///     (&b"1980"[..], &b"10"[..], &b"18"[..]),/// # Example: parsing different formats/// This API is particularly useful when you need to extract a particular/// value that might occur in a different format. Consider, for example,/// an identifier that might be in double quotes or single quotes:/// let re = Regex::new(r#"id:(?:"([^"]+)"|'([^']+)')"#).unwrap();/// let hay = br#"The first is id:"foo" and the second is id:'bar'."#;/// let mut ids = vec![];/// for (_, [id]) in re.captures_iter(hay).map(|c| c.extract()) {///     ids.push(id);/// assert_eq!(ids, vec![b"foo", b"bar"]);/// Expands all instances of `$ref` in `replacement` to the corresponding/// capture group, and writes them to the `dst` buffer given. A `ref` can/// be a capture group index or a name. If `ref` doesn't refer to a capture/// group that participated in the match, then it is replaced with the/// empty string./// # Format/// The format of the replacement string supports two different kinds of/// capture references: unbraced and braced./// For the unbraced format, the format supported is `$ref` where `name`/// can be any character in the class `[0-9A-Za-z_]`. `ref` is always/// the longest possible parse. So for example, `$1a` corresponds to the/// capture group named `1a` and not the capture group at index `1`. If/// `ref` matches `^[0-9]+$`, then it is treated as a capture group index/// itself and not a name./// For the braced format, the format supported is `${ref}` where `ref` can/// be any sequence of bytes except for `}`. If no closing brace occurs,/// then it is not considered a capture reference. As with the unbraced/// format, if `ref` matches `^[0-9]+$`, then it is treated as a capture/// group index and not a name./// The braced format is useful for exerting precise control over the name/// of the capture reference. For example, `${1}a` corresponds to the/// capture group reference `1` followed by the letter `a`, where as `$1a`/// (as mentioned above) corresponds to the capture group reference `1a`./// The braced format is also useful for expressing capture group names/// that use characters not supported by the unbraced format. For example,/// `${foo[bar].baz}` refers to the capture group named `foo[bar].baz`./// If a capture group reference is found and it does not refer to a valid/// capture group, then it will be replaced with the empty string./// To write a literal `$`, use `$$`.///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",/// let hay = b"On 14-03-2010, I became a Tenneessee lamb.";/// caps.expand(b"year=$year, month=$month, day=$day", &mut dst);/// assert_eq!(dst, b"year=2010, month=03, day=14");SubCaptureMatches/// Returns an iterator over all capture groups. This includes both/// matching and non-matching groups./// The iterator always yields at least one matching group: the first group/// (at index `0`) with no name. Subsequent groups are returned in the order/// of their opening parenthesis in the regex./// The elements yielded have type `Option<Match<'h>>`, where a non-`None`/// value is present if the capture group matches./// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();/// let caps = re.captures(b"AZ").unwrap();/// let mut it = caps.iter();/// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), Some(&b"AZ"[..]));/// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), Some(&b"A"[..]));/// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), None);/// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), Some(&b"Z"[..]));/// assert_eq!(it.next(), None);/// Returns the total number of capture groups. This includes both/// The length returned is always equivalent to the number of elements/// yielded by [`Captures::iter`]. Consequently, the length is always/// greater than zero since every `Captures` value always includes the/// match for the entire regex./// assert_eq!(caps.len(), 4);// The lifetime is written out to make it clear that the &str returned// does NOT have a lifetime equivalent to 'h./// Get a matching capture group's haystack substring by index./// The haystack substring returned can't outlive the `Captures` object if this/// method is used, because of how `Index` is defined (normally `a[i]` is part/// of `a` and can't outlive it). To work around this limitation, do that, use/// [`Captures::get`] instead./// `'h` is the lifetime of the matched haystack, but the lifetime of the/// `&str` returned by this implementation is the lifetime of the `Captures`/// value itself./// If there is no matching group at the given index./// Get a matching capture group's haystack substring by name./// [`Captures::name`] instead./// `'n` is the lifetime of the group name used to index the `Captures` value./// If there is no matching group at the given name./// A low level representation of the byte offsets of each capture group./// You can think of this as a lower level [`Captures`], where this type does/// not support named capturing groups directly and it does not borrow the/// haystack that these offsets were matched on./// Primarily, this type is useful when using the lower level `Regex` APIs such/// as [`Regex::captures_read`], which permits amortizing the allocation in/// which capture match offsets are stored./// In order to build a value of this type, you'll need to call the/// [`Regex::capture_locations`] method. The value returned can then be reused/// in subsequent searches for that regex. Using it for other regexes may/// result in a panic or otherwise incorrect results./// This example shows how to create and use `CaptureLocations` in a search./// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();/// let m = re.captures_read(&mut locs, b"Bruce Springsteen").unwrap();/// assert_eq!(0..17, m.range());/// assert_eq!(Some((0, 17)), locs.get(0));/// assert_eq!(Some((0, 5)), locs.get(1));/// assert_eq!(Some((6, 17)), locs.get(2));/// // Asking for an invalid capture group always returns None./// assert_eq!(None, locs.get(3));/// # // literals are too big for 32-bit usize: #1041/// # #[cfg(target_pointer_width = "64")]/// assert_eq!(None, locs.get(34973498648));/// assert_eq!(None, locs.get(9944060567225171988));Locations/// A type alias for `CaptureLocations` for backwards compatibility./// Previously, we exported `CaptureLocations` as `Locations` in an/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),/// we continue re-exporting the same undocumented API./// Returns the start and end byte offsets of the capture group at index/// `i`. This returns `None` if `i` is not a valid capture group or if the/// capture group did not match./// re.captures_read(&mut locs, b"Bruce Springsteen").unwrap();/// Returns the total number of capture groups (even if they didn't match)./// That is, the length returned is unaffected by the result of a search./// This is always at least `1` since every regex has at least `1`/// capturing group that corresponds to the entire match./// assert_eq!(3, locs.len());/// Notice that the length is always at least `1`, regardless of the regex:/// let locs = re.capture_locations();/// assert_eq!(1, locs.len());/// // [a&&b] is a regex that never matches anything./// An alias for the `get` method for backwards compatibility./// Previously, we exported `get` as `pos` in an undocumented API. To/// prevent breaking that code (e.g., in `regex-capi`), we continue/// re-exporting the same undocumented API.FindMatches/// An iterator over all non-overlapping matches in a haystack./// This iterator yields [`Match`] values. The iterator stops when no more/// matches can be found./// `'r` is the lifetime of the compiled regular expression and `'h` is the/// lifetime of the haystack./// This iterator is created by [`Regex::find_iter`]./// Note that since an iterator runs potentially many searches on the haystack/// and since each search has worst case `O(m * n)` time complexity, the/// overall worst case time complexity for iteration is `O(m * n^2)`.CapturesMatches/// An iterator over all non-overlapping capture matches in a haystack./// This iterator yields [`Captures`] values. The iterator stops when no more/// lifetime of the matched string./// This iterator is created by [`Regex::captures_iter`]./// An iterator over all substrings delimited by a regex match./// lifetime of the byte string being split./// This iterator is created by [`Regex::split`]./// An iterator over at most `N` substrings delimited by a regex match./// The last substring yielded by this iterator will be whatever remains after/// `N-1` splits./// This iterator is created by [`Regex::splitn`]./// by the `limit` parameter to [`Regex::splitn`].GroupInfoPatternNames/// An iterator over the names of all capture groups in a regex./// This iterator yields values of type `Option<&str>` in order of the opening/// capture group parenthesis in the regex pattern. `None` is yielded for/// groups with no name. The first element always corresponds to the implicit/// and unnamed group for the overall match./// `'r` is the lifetime of the compiled regular expression./// This iterator is created by [`Regex::capture_names`].CapturesPatternIter/// An iterator over all group matches in a [`Captures`] value./// This iterator yields values of type `Option<Match<'h>>`, where `'h` is the/// lifetime of the haystack that the matches are for. The order of elements/// yielded corresponds to the order of the opening parenthesis for the group/// in the regex pattern. `None` is yielded for groups that did not participate/// in the match./// The first element always corresponds to the implicit group for the overall/// match. Since this iterator is created by a [`Captures`] value, and a/// `Captures` value is only created when a match occurs, it follows that the/// first element yielded by this iterator is guaranteed to be non-`None`./// The lifetime `'c` corresponds to the lifetime of the `Captures` value that/// created this iterator, and the lifetime `'h` corresponds to the originally/// matched haystack.replace_append/// Appends possibly empty data to `dst` to replace the current match./// The current match is represented by `caps`, which is guaranteed to have/// a match at capture group `0`./// For example, a no-op replacement would be/// `dst.extend_from_slice(&caps[0])`.no_expansion/// Return a fixed unchanging replacement byte string./// When doing replacements, if access to [`Captures`] is not needed (e.g.,/// the replacement byte string does not need `$` expansion), then it can/// be beneficial to avoid finding sub-captures./// In general, this is called once for every call to a replacement routine/// such as [`Regex::replace_all`].ReplacerRef/// Returns a type that implements `Replacer`, but that borrows and wraps/// this `Replacer`./// This is useful when you want to take a generic `Replacer` (which might/// not be cloneable) and use it without consuming it, so it can be used/// more than once./// use regex::bytes::{Regex, Replacer};/// fn replace_all_twice<R: Replacer>(///     re: Regex,///     src: &[u8],///     mut rep: R,/// ) -> Vec<u8> {///     let dst = re.replace_all(src, rep.by_ref());///     let dst = re.replace_all(&dst, rep.by_ref());///     dst.into_owned()/// A trait for types that can be used to replace matches in a haystack./// In general, users of this crate shouldn't need to implement this trait,/// since implementations are already provided for `&[u8]` along with other/// variants of byte string types, as well as `FnMut(&Captures) -> Vec<u8>` (or/// any `FnMut(&Captures) -> T` where `T: AsRef<[u8]>`). Those cover most use/// cases, but callers can implement this trait directly if necessary./// This example shows a basic implementation of the `Replacer` trait. This can/// be done much more simply using the replacement byte string interpolation/// support (e.g., `$first $last`), but this approach avoids needing to parse/// the replacement byte string at all./// use regex::bytes::{Captures, Regex, Replacer};/// struct NameSwapper;/// impl Replacer for NameSwapper {///     fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {///         dst.extend_from_slice(&caps["first"]);///         dst.extend_from_slice(b" ");///         dst.extend_from_slice(&caps["last"]);/// let result = re.replace(b"Springsteen, Bruce", NameSwapper);/// A by-reference adaptor for a [`Replacer`]./// This permits reusing the same `Replacer` value in multiple calls to a/// replacement routine like [`Regex::replace_all`]./// This type is created by [`Replacer::by_ref`].NoExpand/// A helper type for forcing literal string replacement./// It can be used with routines like [`Regex::replace`] and/// [`Regex::replace_all`] to do a literal string replacement without expanding/// `$name` to their corresponding capture groups. This can be both convenient/// (to avoid escaping `$`, for example) and faster (since capture groups/// don't need to be found)./// `'s` is the lifetime of the literal string to use./// Quickly checks the given replacement string for whether interpolation/// should be done on it. It returns `None` if a `$` was found anywhere in the/// given string, which suggests interpolation needs to be done. But if there's/// no `$` anywhere, then interpolation definitely does not need to be done. In/// that case, the given string is returned as a borrowed `Cow`./// This is meant to be used to implement the `Replacer::no_expandsion` method/// in its various trait impls.test_match_propertiestest_empty_matchtest_debug_output_valid_utf8test_debug_output_invalid_utf8test_debug_output_various_unicodetest_debug_output_ascii_escapetest_debug_output_match_in_middle/// While this crate will handle Unicode strings (whether in the regular/// expression or in the haystack), all positions returned are **byte/// offsets**. Every byte offset is guaranteed to be at a Unicode code point/// boundary. That is, all offsets returned by the `Regex` API are guaranteed/// to be ranges that can slice a `&str` without panicking. If you want to/// relax this requirement, then you must search `&[u8]` haystacks with a/// [`bytes::Regex`](crate::bytes::Regex)./// The only methods that allocate new strings are the string replacement/// use regex::Regex;/// let m = re.find("phone: 111-222-3333").unwrap();/// let hay = "/// let mut fields: Vec<(&str, i64, bool)> = vec![];///     ("rabbit", 54, true),///     ("groundhog", 2, true),///     ("fox", 109, false),/// # Example: searching with the `Pattern` trait/// **Note**: This section requires that this crate is compiled with the/// `pattern` Cargo feature enabled, which **requires nightly Rust**./// Since `Regex` implements `Pattern` from the standard library, one can/// use regexes with methods defined on `&str`. For example, `is_match`,/// `find`, `find_iter` and `split` can, in some cases, be replaced with/// `str::contains`, `str::find`, `str::match_indices` and `str::split`./// Here are some examples:/// let re = Regex::new(r"\d+").unwrap();/// let hay = "a111b222c";/// assert!(hay.contains(&re));/// assert_eq!(hay.find(&re), Some(1));/// assert_eq!(hay.match_indices(&re).collect::<Vec<_>>(), vec![///     (1, "111"),///     (5, "222"),/// assert_eq!(hay.split(&re).collect::<Vec<_>>(), vec!["a", "b", "c"]);/// let hay = "I categorically deny having triskaidekaphobia.";/// assert_eq!("categorically", mat.as_str());/// let hay = "Retroactively relinquishing remunerations is reprehensible.";/// let matches: Vec<_> = re.find_iter(hay).map(|m| m.as_str()).collect();///     "Retroactively",///     "relinquishing",///     "remunerations",///     "reprehensible",/// substrings looking like that, while also extracting the movie name and/// its release year separately. The example below shows how to do that./// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";/// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");/// assert_eq!(caps.get(1).unwrap().as_str(), "Citizen Kane");/// assert_eq!(caps.get(2).unwrap().as_str(), "1941");/// assert_eq!(&caps[0], "'Citizen Kane' (1941)");/// assert_eq!(&caps[1], "Citizen Kane");/// assert_eq!(&caps[2], "1941");/// assert_eq!(caps.name("title").unwrap().as_str(), "Citizen Kane");/// assert_eq!(caps.name("year").unwrap().as_str(), "1941");/// assert_eq!(&caps["title"], "Citizen Kane");/// assert_eq!(&caps["year"], "1941");/// assert_eq!(full, "'Citizen Kane' (1941)");/// assert_eq!(title, "Citizen Kane");/// assert_eq!(year, "1941");/// let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";///     ("Citizen Kane", 1941),///     ("The Wizard of Oz", 1939),///     ("M", 1931),/// assert_eq!(&caps["title"], "The Wizard of Oz");/// assert_eq!(&caps["year"], "1939");/// assert_eq!(&caps["title"], "M");/// assert_eq!(&caps["year"], "1931");/// let hay = "a b \t  c\td    e";/// let fields: Vec<&str> = re.split(hay).collect();/// assert_eq!(fields, vec!["a", "b", "c", "d", "e"]);/// let hay = "Mary had a little lamb";/// let got: Vec<&str> = re.split(hay).collect();/// assert_eq!(got, vec!["Mary", "had", "a", "little", "lamb"]);/// let hay = "";/// assert_eq!(got, vec![""]);/// let hay = "lionXXtigerXleopard";/// assert_eq!(got, vec!["lion", "", "tiger", "leopard"]);/// let hay = "lion::tiger::leopard";/// assert_eq!(got, vec!["lion", "tiger", "leopard"]);/// let hay = "XXXXaXXbXc";/// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);/// let hay = "(///)";/// assert_eq!(got, vec!["(", "", "", ")"]);/// let hay = "010";/// assert_eq!(got, vec!["", "1", ""]);/// When the empty string is used as a regex, it splits at every valid/// UTF-8 boundary by default (which includes the beginning and end of the/// haystack):/// let hay = "rust";/// assert_eq!(got, vec!["", "r", "u", "s", "t", ""]);/// // Splitting by an empty string is UTF-8 aware by default!/// let hay = "☃";/// assert_eq!(got, vec!["", "☃", ""]);/// let hay = "    a  b c";/// assert_eq!(got, vec!["", "a", "b", "c"]);/// let hay = "Hey! How are you?";/// let fields: Vec<&str> = re.splitn(hay, 3).collect();/// assert_eq!(fields, vec!["Hey", "How", "are you?"]);/// let got: Vec<&str> = re.splitn(hay, 3).collect();/// assert_eq!(got, vec!["Mary", "had", "a little lamb"]);/// assert_eq!(got, vec!["lion", "", "tigerXleopard"]);/// let got: Vec<&str> = re.splitn(hay, 2).collect();/// assert_eq!(got, vec!["lion", "tiger::leopard"]);/// let hay = "abcXdef";/// let got: Vec<&str> = re.splitn(hay, 1).collect();/// assert_eq!(got, vec!["abcXdef"]);/// let hay = "abcdef";/// assert_eq!(got, vec!["abcdef"]);/// let got: Vec<&str> = re.splitn(hay, 0).collect();/// assert_eq!(re.replace("1078910", ""), "1010");/// use regex::{Captures, Regex};/// let result = re.replace("Springsteen, Bruce", |caps: &Captures| {///     format!("{} {}", &caps[2], &caps[1])/// assert_eq!(result, "Bruce Springsteen");/// let result = re.replace("Springsteen, Bruce", "$first $last");/// let result = re.replace("deep fried", "${first}_$second");/// assert_eq!(result, "deep_fried");/// use regex::{NoExpand, Regex};/// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));/// assert_eq!(result, "$2 $last");///     haystack: &str,///     replacement: impl Fn(&Captures) -> Result<String, E>,/// ) -> Result<String, E> {///     let mut new = String::with_capacity(haystack.len());///         new.push_str(&haystack[last_match..m.start()]);///         new.push_str(&replacement(&caps)?);///     new.push_str(&haystack[last_match..]);/// let replacement = |caps: &Captures| -> Result<String, &'static str> {///     Ok(caps[0].len().to_string())///     Ok("2 3 3 3?".to_string()),///     replace_all(&re, "hi how are you?", &replacement),/// assert!(replace_all(&re, "hi there", &replacement).is_err());/// let new = re.replace_all(hay, "$2 $1");/// assert_eq!(new, "/// ");/// let new = re.replacen(hay, 2, "$2 $1");/// let offset = re.shortest_match("aaaaa").unwrap();/// Returns the same as [`Regex::shortest_match`], but starts the search at/// let hay = "eschew";/// assert_eq!(&re.captures(&hay[2..]).unwrap()[0], "chew");/// This routine may panic if the given `CaptureLocations` was not created/// by this regex./// assert!(re.captures_read(&mut locs, "id=foo123").is_some());/// This routine may also panic if the given `CaptureLocations` was not/// created by this regex./// The returned locations can be used for any subsequent search for this/// particular regex. There is no guarantee that it is correct to use for/// other regexes, even if they have the same number of capture groups./// assert!(re.captures_read(&mut locs, "Padron").is_some());/// The `regex-capi` crate used this method, so to avoid breaking that/// Since this `Match` can only be produced by the top-level `Regex` APIs/// that only support searching UTF-8 encoded strings, the byte offsets for a/// `Match` are guaranteed to fall on valid UTF-8 codepoint boundaries. That/// is, slicing a `&str` with [`Match::range`] is guaranteed to never panic./// Values with this type are created by [`Regex::find`] or/// [`Regex::find_iter`]. Other APIs can create `Match` values too. For/// example, [`Captures::get`]./// let hay = "Greek: αβγδ";/// assert_eq!("αβγδ", m.as_str());/// This is guaranteed to fall on a valid UTF-8 codepoint boundary. That/// is, it will never be an offset that appears between the UTF-8 code/// units of a UTF-8 encoded Unicode scalar value. Consequently, it is/// always safe to slice the corresponding haystack using this offset./// It is always correct to slice the original haystack searched with this/// range. That is, because the offsets are guaranteed to fall on valid/// UTF-8 boundaries, the range returned is always valid./// let caps = re.captures("toady").unwrap();/// assert_eq!("toady", &caps[0]);/// assert_eq!("t", &caps["first"]);/// assert_eq!("o", &caps[2]);/// assert_eq!("y", &caps["last"]);/// let caps = re.captures("abc123").unwrap();/// let substr1 = caps.get(1).map_or("", |m| m.as_str());/// let substr2 = caps.get(2).map_or("", |m| m.as_str());/// assert_eq!(substr1, "123");/// assert_eq!(substr2, "");/// let numbers = caps.name("numbers").map_or("", |m| m.as_str());/// let letters = caps.name("letters").map_or("", |m| m.as_str());/// assert_eq!(numbers, "123");/// assert_eq!(letters, "");/// let hay = "On 2010-03-14, I became a Tenneessee lamb.";/// assert_eq!("2010-03-14", full);/// assert_eq!("2010", year);/// assert_eq!("03", month);/// assert_eq!("14", day);/// let hay = "1973-01-05, 1975-08-25 and 1980-10-18";/// let mut dates: Vec<(&str, &str, &str)> = vec![];///     ("1973", "01", "05"),///     ("1975", "08", "25"),///     ("1980", "10", "18"),/// let hay = r#"The first is id:"foo" and the second is id:'bar'."#;/// assert_eq!(ids, vec!["foo", "bar"]);/// let hay = "On 14-03-2010, I became a Tenneessee lamb.";/// let mut dst = String::new();/// caps.expand("year=$year, month=$month, day=$day", &mut dst);/// assert_eq!(dst, "year=2010, month=03, day=14");/// let caps = re.captures("AZ").unwrap();/// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("AZ"));/// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("A"));/// assert_eq!(it.next().unwrap().map(|m| m.as_str()), None);/// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("Z"));/// let m = re.captures_read(&mut locs, "Bruce Springsteen").unwrap();/// re.captures_read(&mut locs, "Bruce Springsteen").unwrap();/// The current match is represented by `caps`, which is guaranteed to/// have a match at capture group `0`./// For example, a no-op replacement would be `dst.push_str(&caps[0])`./// Return a fixed unchanging replacement string./// the replacement string does not need `$` expansion), then it can be/// beneficial to avoid finding sub-captures./// use regex::{Regex, Replacer};///     src: &str,/// ) -> String {/// since implementations are already provided for `&str` along with other/// variants of string types, as well as `FnMut(&Captures) -> String` (or any/// `FnMut(&Captures) -> T` where `T: AsRef<str>`). Those cover most use cases,/// but callers can implement this trait directly if necessary./// This example shows a basic implementation of  the `Replacer` trait. This/// can be done much more simply using the replacement string interpolation/// the replacement string at all./// use regex::{Captures, Regex, Replacer};///     fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {///         dst.push_str(&caps["first"]);///         dst.push_str(" ");///         dst.push_str(&caps["last"]);/// let result = re.replace("Springsteen, Bruce", NameSwapper);PatternSetPatternSetIter/// Match multiple, possibly overlapping, regexes in a single search./// A regex set corresponds to the union of zero or more regular expressions./// That is, a regex set will match a haystack when at least one of its/// constituent regexes matches. A regex set as its formulated here provides a/// touch more power: it will also report *which* regular expressions in the/// set match. Indeed, this is the key difference between regex sets and a/// single `Regex` with many alternates, since only one alternate can match at/// a time./// For example, consider regular expressions to match email addresses and/// domains: `[a-z]+@[a-z]+\.(com|org|net)` and `[a-z]+\.(com|org|net)`. If a/// regex set is constructed from those regexes, then searching the haystack/// `foo@example.com` will report both regexes as matching. Of course, one/// could accomplish this by compiling each regex on its own and doing two/// searches over the haystack. The key advantage of using a regex set is/// that it will report the matching regexes using a *single pass through the/// haystack*. If one has hundreds or thousands of regexes to match repeatedly/// (like a URL router for a complex web application or a user agent matcher),/// then a regex set *can* realize huge performance gains./// Unlike the top-level [`RegexSet`](crate::RegexSet), this `RegexSet`/// searches haystacks with type `&[u8]` instead of `&str`. Consequently, this/// `RegexSet` is permitted to match invalid UTF-8./// Regex sets are limited to answering the following two questions:/// 1. Does any regex in the set match?/// 2. If so, which regexes in the set match?/// As with the main [`Regex`][crate::bytes::Regex] type, it is cheaper to ask/// (1) instead of (2) since the matching engines can stop after the first/// match is found./// You cannot directly extract [`Match`][crate::bytes::Match] or/// [`Captures`][crate::bytes::Captures] objects from a regex set. If you need/// these operations, the recommended approach is to compile each pattern in/// the set independently and scan the exact same haystack a second time with/// those independently compiled patterns:/// use regex::bytes::{Regex, RegexSet};/// let patterns = ["foo", "bar"];/// // Both patterns will match different ranges of this string./// let hay = b"barfoo";/// // Compile a set matching any of our patterns./// let set = RegexSet::new(patterns).unwrap();/// // Compile each pattern independently./// let regexes: Vec<_> = set///     .patterns()///     .map(|pat| Regex::new(pat).unwrap())/// // Match against the whole set first and identify the individual/// // matching patterns./// let matches: Vec<&[u8]> = set///     .matches(hay)///     // Dereference the match index to get the corresponding///     // compiled pattern.///     .map(|index| &regexes[index])///     // To get match locations or any other info, we then have to search the///     // exact same haystack again, using our separately-compiled pattern.///     .map(|re| re.find(hay).unwrap().as_bytes())/// // Matches arrive in the order the constituent patterns were declared,/// // not the order they appear in the haystack./// assert_eq!(vec![&b"foo"[..], &b"bar"[..]], matches);/// A `RegexSet` has the same performance characteristics as `Regex`. Namely,/// search takes `O(m * n)` time, where `m` is proportional to the size of the/// regex set and `n` is proportional to the length of the haystack./// The `Default` trait is implemented for `RegexSet`. The default value/// is an empty set. An empty set can also be explicitly constructed via/// [`RegexSet::empty`]./// This shows how the above two regexes (for matching email addresses and/// domains) might work:/// use regex::bytes::RegexSet;/// let set = RegexSet::new(&[///     r"[a-z]+@[a-z]+\.(com|org|net)",///     r"[a-z]+\.(com|org|net)",/// // Ask whether any regexes in the set match./// assert!(set.is_match(b"foo@example.com"));/// // Identify which regexes in the set match./// let matches: Vec<_> = set.matches(b"foo@example.com").into_iter().collect();/// assert_eq!(vec![0, 1], matches);/// // Try again, but with a haystack that only matches one of the regexes./// let matches: Vec<_> = set.matches(b"example.com").into_iter().collect();/// assert_eq!(vec![1], matches);/// // Try again, but with a haystack that doesn't match any regex in the set./// let matches: Vec<_> = set.matches(b"example").into_iter().collect();/// assert!(matches.is_empty());/// Note that it would be possible to adapt the above example to using `Regex`/// with an expression like:/// (?P<email>[a-z]+@(?P<email_domain>[a-z]+[.](com|org|net)))|(?P<domain>[a-z]+[.](com|org|net))/// After a match, one could then inspect the capture groups to figure out/// which alternates matched. The problem is that it is hard to make this/// approach scale when there are many regexes since the overlap between each/// alternate isn't always obvious to reason about./// Create a new regex set with the given regular expressions./// This takes an iterator of `S`, where `S` is something that can produce/// a `&str`. If any of the strings in the iterator are not valid regular/// expressions, then an error is returned./// Create a new regex set from an iterator of strings:/// let set = RegexSet::new([r"\w+", r"\d+"]).unwrap();/// assert!(set.is_match(b"foo"));/// Create a new empty regex set./// An empty regex never matches anything./// This is a convenience function for `RegexSet::new([])`, but doesn't/// require one to specify the type of the input./// let set = RegexSet::empty();/// // an empty set matches nothing/// assert!(!set.is_match(b""));/// Returns true if and only if one of the regexes in this set matches/// the haystack given./// This method should be preferred if you only need to test whether any/// of the regexes in the set should match, but don't care about *which*/// regexes matched. This is because the underlying matching engine will/// quit immediately after seeing the first match instead of continuing to/// find all matches./// Note that as with searches using [`Regex`](crate::bytes::Regex), the/// expression is unanchored by default. That is, if the regex does not/// start with `^` or `\A`, or end with `$` or `\z`, then it is permitted/// to match anywhere in the haystack./// Tests whether a set matches somewhere in a haystack:/// assert!(!set.is_match("☃".as_bytes()));/// Returns true if and only if one of the regexes in this set matches the/// haystack given, with the search starting at the offset given./// This example shows the significance of `start`. Namely, consider a/// haystack `foobar` and a desire to execute a search starting at offset/// `3`. You could search a substring explicitly, but then the look-around/// assertions won't work correctly. Instead, you can use this method to/// specify the start position of a search./// let set = RegexSet::new([r"\bbar\b", r"(?m)^bar$"]).unwrap();/// let hay = b"foobar";/// assert!(set.is_match(&hay[3..]));/// assert!(!set.is_match_at(hay, 3));SetMatches/// Returns the set of regexes that match in the given haystack./// The set returned contains the index of each regex that matches in/// the given haystack. The index is in correspondence with the order of/// regular expressions given to `RegexSet`'s constructor./// The set can also be used to iterate over the matched indices. The order/// of iteration is always ascending with respect to the matching indices./// Tests which regular expressions match the given haystack:/// let set = RegexSet::new([///     r"\w+",///     r"\d+",///     r"\pL+",///     r"foo",///     r"bar",///     r"barfoo",///     r"foobar",/// let matches: Vec<_> = set.matches(b"foobar").into_iter().collect();/// assert_eq!(matches, vec![0, 2, 3, 4, 6]);/// // You can also test whether a particular regex matched:/// let matches = set.matches(b"foobar");/// assert!(!matches.matched(5));/// assert!(matches.matched(6));matches_at/// // We get matches here, but it's probably not intended./// let matches: Vec<_> = set.matches(&hay[3..]).into_iter().collect();/// assert_eq!(matches, vec![0, 1]);/// // No matches because the  assertions take the context into account./// let matches: Vec<_> = set.matches_at(hay, 3).into_iter().collect();/// assert_eq!(matches, vec![]);matches_read_at/// Returns the same as matches, but starts the search at the given/// offset and stores the matches into the slice given./// `matches` must have a length that is at least the number of regexes/// in this set./// This method returns true if and only if at least one member of/// `matches` is true after executing the set against `haystack`.read_matches_at/// An alias for `matches_read_at` to preserve backward compatibility./// Returns the total number of regexes in this set./// assert_eq!(0, RegexSet::empty().len());/// assert_eq!(1, RegexSet::new([r"[0-9]"]).unwrap().len());/// assert_eq!(2, RegexSet::new([r"[0-9]", r"[a-z]"]).unwrap().len());/// Returns `true` if this set contains no regexes./// assert!(RegexSet::empty().is_empty());/// assert!(!RegexSet::new([r"[0-9]"]).unwrap().is_empty());/// Returns the regex patterns that this regex set was constructed from./// This function can be used to determine the pattern for a match. The/// slice returned has exactly as many patterns givens to this regex set,/// and the order of the slice is the same as the order of the patterns/// provided to the set./// let matches: Vec<_> = set///     .matches(b"foobar")///     .map(|index| &set.patterns()[index])/// assert_eq!(matches, vec![r"\w+", r"\pL+", r"foo", r"bar", r"foobar"]);/// A set of matches returned by a regex set./// Values of this type are constructed by [`RegexSet::matches`].matched_any/// Whether this set contains any matches./// let matches = set.matches(b"foo@example.com");/// assert!(matches.matched_any());matched_all/// Whether all patterns in this set matched.///     r"^foo",///     r"[a-z]+\.com",/// let matches = set.matches(b"foo.example.com");/// assert!(matches.matched_all());/// Whether the regex at the given index matched./// The index for a regex is determined by its insertion order upon the/// initial construction of a `RegexSet`, starting at `0`./// If `index` is greater than or equal to the number of regexes in the/// original set that produced these matches. Equivalently, when `index`/// is greater than or equal to [`SetMatches::len`]./// let matches = set.matches(b"example.com");/// assert!(!matches.matched(0));/// assert!(matches.matched(1));/// The total number of regexes in the set that created these matches./// **WARNING:** This always returns the same value as [`RegexSet::len`]./// In particular, it does *not* return the number of elements yielded by/// [`SetMatches::iter`]. The only way to determine the total number of/// matched regexes is to iterate over them./// Notice that this method returns the total number of regexes in the/// original set, and *not* the total number of regexes that matched./// // Total number of patterns that matched./// assert_eq!(1, matches.iter().count());/// // Total number of patterns in the set./// assert_eq!(2, matches.len());SetMatchesIter/// Returns an iterator over the indices of the regexes that matched./// This will always produces matches in ascending order, where the index/// yielded corresponds to the index of the regex that matched with respect/// to its position when initially building the set.///     r"[0-9]",///     r"[a-z]",///     r"[A-Z]",///     r"\p{Greek}",/// let hay = "βa1".as_bytes();/// let matches: Vec<_> = set.matches(hay).iter().collect();/// assert_eq!(matches, vec![0, 1, 3]);/// Note that `SetMatches` also implemnets the `IntoIterator` trait, so/// this method is not always needed. For example:/// for index in set.matches(hay) {///     matches.push(index);SetMatchesIntoIterpatset/// An owned iterator over the set of matches from a regex set./// This will always produces matches in ascending order of index, where the/// index corresponds to the index of the regex that matched with respect to/// its position when initially building the set./// This iterator is created by calling `SetMatches::into_iter` via the/// `IntoIterator` trait. This is automatically done in `for` loops./// A borrowed iterator over the set of matches from a regex set./// The lifetime `'a` refers to the lifetime of the [`SetMatches`] value that/// created this iterator./// corresponds to the index of the regex that matched with respect to its/// position when initially building the set./// This iterator is created by the [`SetMatches::iter`] method./// As with the main [`Regex`][crate::Regex] type, it is cheaper to ask (1)/// instead of (2) since the matching engines can stop after the first match/// You cannot directly extract [`Match`][crate::Match] or/// [`Captures`][crate::Captures] objects from a regex set. If you need these/// operations, the recommended approach is to compile each pattern in the set/// independently and scan the exact same haystack a second time with those/// independently compiled patterns:/// use regex::{Regex, RegexSet};/// let hay = "barfoo";/// let matches: Vec<&str> = set///     .map(|re| re.find(hay).unwrap().as_str())/// assert_eq!(vec!["foo", "bar"], matches);/// use regex::RegexSet;/// assert!(set.is_match("foo@example.com"));/// let matches: Vec<_> = set.matches("foo@example.com").into_iter().collect();/// let matches: Vec<_> = set.matches("example.com").into_iter().collect();/// let matches: Vec<_> = set.matches("example").into_iter().collect();/// assert!(set.is_match("foo"));/// assert!(!set.is_match(""));/// Note that as with searches using [`Regex`](crate::Regex), the/// assert!(!set.is_match("☃"));/// let hay = "foobar";/// let matches: Vec<_> = set.matches("foobar").into_iter().collect();/// let matches = set.matches("foobar");///     .matches("foobar")/// let matches = set.matches("foo@example.com");/// let matches = set.matches("foo.example.com");/// let matches = set.matches("example.com");/// let hay = "βa1";wireDeserializeErrorAccelTy/// The base type used to represent a collection of accelerators./// While an `Accel` is represented as a fixed size array of bytes, a/// *collection* of `Accel`s (called `Accels`) is represented internally as a/// slice of u32. While it's a bit unnatural to do this and costs us a bit of/// fairly low-risk not-safe code, it lets us remove the need for a second type/// parameter in the definition of dense::DFA. (Which really wants everything/// to be a slice of u32.)ACCEL_TY_SIZE/// The size of the unit of representation for accelerators./// ACCEL_CAP *must* be a multiple of this size.ACCEL_LEN/// The maximum length in bytes that a single Accel can be. This is distinct/// from the capacity of an accelerator in that the length represents only the/// bytes that should be read.ACCEL_CAP/// The capacity of each accelerator, in bytes. We set this to 8 since it's a/// multiple of 4 (our ID size) and because it gives us a little wiggle room/// if we want to support more accel bytes in the future without a breaking/// This MUST be a multiple of ACCEL_TY_SIZE.find_fwd/// Search for between 1 and 3 needle bytes in the given haystack, starting the/// search at the given position. If `needles` has a length other than 1-3,/// then this panics.find_rev/// Search for between 1 and 3 needle bytes in the given haystack in reverse,/// starting the search at the given position. If `needles` has a length other/// than 1-3, then this panics.accels/// A length prefixed slice of contiguous accelerators. See the top comment/// in this module for more details on how we can jump from a DFA's state/// ID to an accelerator in this list./// The first 4 bytes always correspond to the number of accelerators/// that follow.Accels/// Represents the accelerators for all accelerated states in a dense DFA./// The `A` type parameter represents the type of the underlying bytes./// Generally, this is either `&[AccelTy]` or `Vec<AccelTy>`./// Create an empty sequence of accelerators for a DFA./// Add an accelerator to this sequence./// This adds to the accelerator to the end of the sequence and therefore/// should be done in correspondence with its state in the DFA./// This panics if this results in more accelerators than AccelTy::MAX./// Set the number of accelerators in this sequence, which is encoded in/// the first 4 bytes of the underlying bytes./// Deserialize a sequence of accelerators from the given bytes. If there/// was a problem deserializing, then an error is returned./// This is guaranteed to run in constant time. This does not guarantee/// that every accelerator in the returned collection is valid. Thus,/// accessing one may panic, or not-safe code that relies on accelerators/// being correct my result in UB./// Callers may check the validity of every accelerator with the `validate`/// Return an owned version of the accelerators./// Return a borrowed version of the accelerators./// Return the bytes representing the serialization of the accelerators./// Returns the memory usage, in bytes, of these accelerators./// The memory usage is computed based on the number of bytes used to/// represent all of the accelerators./// This does **not** include the stack size used by this value./// Return the bytes to search for corresponding to the accelerator in this/// sequence at index `i`. If no such accelerator exists, then this panics./// The significance of the index is that it should be in correspondence/// with the index of the corresponding DFA. That is, accelerated DFA/// states are stored contiguously in the DFA and have an ordering implied/// by their respective state IDs. The state's index in that sequence/// corresponds to the index of its corresponding accelerator./// Return the total number of accelerators in this sequence./// Return the accelerator in this sequence at index `i`. If no such/// accelerator exists, then this returns None./// See the docs for `needles` on the significance of the index.IterAccels/// Returns an iterator of accelerators in this sequence./// Writes these accelerators to the given byte buffer using the indicated/// endianness. If the given buffer is too small, then an error is/// returned. Upon success, the total number of bytes written is returned./// The number of bytes written is guaranteed to be a multiple of 8./// Validates that every accelerator in this collection can be successfully/// deserialized as a valid accelerator.write_to_len/// Returns the total number of bytes written by `write_to`./// The first byte is the length. Subsequent bytes are the accelerated/// Note that we make every accelerator 8 bytes as a slightly wasteful/// way of making sure alignment is always correct for state ID sizes of/// 1, 2, 4 and 8. This should be okay since accelerated states aren't/// particularly common, especially when Unicode is enabled./// Accel represents a structure for determining how to "accelerate" a DFA/// Namely, it contains zero or more bytes that must be seen in order for the/// DFA to leave the state it is associated with. In practice, the actual range/// is 1 to 3 bytes./// The purpose of acceleration is to identify states whose vast majority/// of transitions are just loops back to the same state. For example,/// in the regex `(?-u)^[^a]+b`, the corresponding DFA will have a state/// (corresponding to `[^a]+`) where all transitions *except* for `a` and/// `b` loop back to itself. Thus, this state can be "accelerated" by simply/// looking for the next occurrence of either `a` or `b` instead of explicitly/// following transitions. (In this case, `b` transitions to the next state/// where as `a` would transition to the dead state.)/// Returns an empty accel, where no bytes are accelerated./// Returns a verified accelerator derived from the beginning of the given/// If the slice is not long enough or contains invalid bytes for an/// accelerator, then this returns an error./// Returns a verified accelerator derived from raw bytes./// If the given bytes are invalid, then this returns an error./// Returns an accelerator derived from raw bytes./// This does not check whether the given bytes are valid. Invalid bytes/// cannot sacrifice memory safety, but may result in panics or silent/// logic bugs./// Attempts to add the given byte to this accelerator. If the accelerator/// is already full or thinks the byte is a poor accelerator, then this/// returns false. Otherwise, returns true./// If the given byte is already in this accelerator, then it panics./// Return the number of bytes in this accelerator./// Returns true if and only if there are no bytes in this accelerator./// Returns the slice of bytes to accelerate./// If this accelerator is empty, then this returns an empty slice./// Returns true if and only if this accelerator will accelerate the givenas_accel_tys/// Returns the accelerator bytes as an array of AccelTys.// This module defines some core types for dealing with accelerated DFA states.// Briefly, a DFA state can be "accelerated" if all of its transitions except// for a few loop back to itself. This directly implies that the only way out// of such a state is if a byte corresponding to one of those non-loopback// transitions is found. Such states are often found in simple repetitions in// non-Unicode regexes. For example, consider '(?-u)[^a]+a'. We can look at its// DFA with regex-cli://     $ regex-cli debug dense dfa -p '(?-u)[^a]+a' -BbC --no-table//     D 000000://     Q 000001://      *000002://     A 000003: \x00-` => 3, a => 8, b-\xFF => 3//     A 000004: \x00-` => 4, a => 7, b-\xFF => 4//       000005: \x00-` => 4, b-\xFF => 4//       000006: \x00-` => 3, a => 6, b-\xFF => 3//       000007: \x00-\xFF => 2, EOI => 2//       000008: \x00-\xFF => 2, EOI => 2// In particular, state 3 is accelerated (shown via the 'A' indicator) since// the only way to leave that state once entered is to see an 'a' byte. If// there is a long run of non-'a' bytes, then using something like 'memchr'// to find the next 'a' byte can be significantly faster than just using the// standard byte-at-a-time state machine.// Unfortunately, this optimization rarely applies when Unicode is enabled.// For example, patterns like '[^a]' don't actually match any byte that isn't// 'a', but rather, any UTF-8 encoding of a Unicode scalar value that isn't// 'a'. This makes the state machine much more complex---far beyond a single// state---and removes the ability to easily accelerate it. (Because if the// machine sees a non-UTF-8 sequence, then the machine won't match through it.)// In practice, we only consider accelerating states that have 3 or fewer// non-loop transitions. At a certain point, you get diminishing returns, but// also because that's what the memchr crate supports. The structures below// hard-code this assumption and provide (de)serialization APIs for use inside// a DFA.// And finally, note that there is some trickery involved in making it very// fast to not only check whether a state is accelerated at search time, but// also to access the bytes to search for to implement the acceleration itself.// dfa/special.rs provides more detail, but the short story is that all// accelerated states appear contiguously in a DFA. This means we can represent// the ID space of all accelerated DFA states with a single range. So given// a state ID, we can determine whether it's accelerated via//     min_accel_id <= id <= max_accel_id// And find its corresponding accelerator with://     accels.get((id - min_accel_id) / dfa_stride)HalfMatch/// Transitions from the current state to the next state, given the next/// byte of input./// Implementations must guarantee that the returned ID is always a valid/// ID when `current` refers to a valid ID. Moreover, the transition/// function must be defined for all possible values of `input`./// If the given ID does not refer to a valid state, then this routine/// may panic but it also may not panic and instead return an invalid ID./// However, if the caller provides an invalid ID then this must never/// sacrifice memory safety./// This shows a simplistic example for walking a DFA for a given haystack/// by using the `next_state` method./// use regex_automata::{dfa::{Automaton, dense}, Input};/// let dfa = dense::DFA::new(r"[a-z]+r")?;/// let haystack = "bar".as_bytes();/// // The start state is determined by inspecting the position and the/// // initial bytes of the haystack./// let mut state = dfa.start_state_forward(&Input::new(haystack))?;/// // Walk all the bytes in the haystack./// for &b in haystack {///     state = dfa.next_state(state, b);/// // Matches are always delayed by 1 byte, so we must explicitly walk the/// // special "EOI" transition at the end of the search./// state = dfa.next_eoi_state(state);/// assert!(dfa.is_match_state(state));next_state_unchecked/// Unlike [`Automaton::next_state`], implementations may implement this/// more efficiently by assuming that the `current` state ID is valid./// Typically, this manifests by eliding bounds checks./// Callers of this method must guarantee that `current` refers to a valid/// state ID. If `current` is not a valid state ID for this automaton, then/// calling this routine may result in undefined behavior./// If `current` is valid, then implementations must guarantee that the ID/// returned is valid for all possible values of `input`.next_eoi_state/// Transitions from the current state to the next state for the special/// EOI symbol./// ID when `current` refers to a valid ID./// This routine must be called at the end of every search in a correct/// implementation of search. Namely, DFAs in this crate delay matches/// by one byte in order to support look-around operators. Thus, after/// reaching the end of a haystack, a search implementation must follow one/// last EOI transition./// It is best to think of EOI as an additional symbol in the alphabet of/// a DFA that is distinct from every other symbol. That is, the alphabet/// of DFAs in this crate has a logical size of 257 instead of 256, where/// 256 corresponds to every possible inhabitant of `u8`. (In practice, the/// physical alphabet size may be smaller because of alphabet compression/// via equivalence classes, but EOI is always represented somehow in the/// alphabet.)/// This shows a simplistic example for walking a DFA for a given haystack,/// and then finishing the search with the final EOI transition./// // The unwrap is OK because we aren't requesting a start state for a/// // specific pattern./// // Matches are always delayed by 1 byte, so we must explicitly walk/// // the special "EOI" transition at the end of the search. Without this/// // final transition, the assert below will fail since the DFA will not/// // have entered a match state yet!StartError/// Return the ID of the start state for this DFA for the given starting/// Unlike typical DFA implementations, the start state for DFAs in this/// crate is dependent on a few different factors:/// * The [`Anchored`] mode of the search. Unanchored, anchored and/// anchored searches for a specific [`PatternID`] all use different start/// states./// * Whether a "look-behind" byte exists. For example, the `^` anchor/// matches if and only if there is no look-behind byte./// * The specific value of that look-behind byte. For example, a `(?m:^)`/// assertion only matches when there is either no look-behind byte, or/// when the look-behind byte is a line terminator./// The [starting configuration](start::Config) provides the above/// This routine can be used for either forward or reverse searches./// Although, as a convenience, if you have an [`Input`], then it may/// be more succinct to use [`Automaton::start_state_forward`] or/// [`Automaton::start_state_reverse`]. Note, for example, that the/// convenience routines return a [`MatchError`] on failure where as this/// routine returns a [`StartError`]./// This may return a [`StartError`] if the search needs to give up when/// determining the start state (for example, if it sees a "quit" byte)./// This can also return an error if the given configuration contains an/// unsupported [`Anchored`] configuration.start_state_forward/// Return the ID of the start state for this DFA when executing a forward/// This is a convenience routine for calling [`Automaton::start_state`]/// that converts the given [`Input`] to a [start/// configuration](start::Config). Additionally, if an error occurs, it is/// converted from a [`StartError`] to a [`MatchError`] using the offset/// information in the given [`Input`]./// This may return a [`MatchError`] if the search needs to give up/// when determining the start state (for example, if it sees a "quit"/// byte). This can also return an error if the given `Input` contains anstart_state_reverse/// Return the ID of the start state for this DFA when executing a reverseuniversal_start_state/// If this DFA has a universal starting state for the given anchor mode/// and the DFA supports universal starting states, then this returns that/// state's identifier./// A DFA is said to have a universal starting state when the starting/// state is invariant with respect to the haystack. Usually, the starting/// state is chosen depending on the bytes immediately surrounding the/// starting position of a search. However, the starting state only differs/// when one or more of the patterns in the DFA have look-around assertions/// in its prefix./// Stated differently, if none of the patterns in a DFA have look-around/// assertions in their prefix, then the DFA has a universal starting state/// and _may_ be returned by this method./// It is always correct for implementations to return `None`, and indeed,/// this is what the default implementation does. When this returns `None`,/// callers must use either `start_state_forward` or `start_state_reverse`/// to get the starting state./// # Use case/// There are a few reasons why one might want to use this:/// * If you know your regex patterns have no look-around assertions in/// their prefix, then calling this routine is likely cheaper and perhaps/// more semantically meaningful./// * When implementing prefilter support in a DFA regex implementation,/// it is necessary to re-compute the start state after a candidate/// is returned from the prefilter. However, this is only needed when/// there isn't a universal start state. When one exists, one can avoid/// re-computing the start state./// use regex_automata::{///     dfa::{Automaton, dense::DFA},///     Anchored,/// // There are no look-around assertions in the prefixes of any of the/// // patterns, so we get a universal start state./// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+$", "[A-Z]+"])?;/// assert!(dfa.universal_start_state(Anchored::No).is_some());/// assert!(dfa.universal_start_state(Anchored::Yes).is_some());/// // One of the patterns has a look-around assertion in its prefix,/// // so this means there is no longer a universal start state./// let dfa = DFA::new_many(&["[0-9]+", "^[a-z]+$", "[A-Z]+"])?;/// assert!(!dfa.universal_start_state(Anchored::No).is_some());/// assert!(!dfa.universal_start_state(Anchored::Yes).is_some());is_special_state/// Returns true if and only if the given identifier corresponds to a/// "special" state. A special state is one or more of the following:/// a dead state, a quit state, a match state, a start state or an/// accelerated state./// A correct implementation _may_ always return false for states that/// are either start states or accelerated states, since that information/// is only intended to be used for optimization purposes. Correct/// implementations must return true if the state is a dead, quit or match/// state. This is because search routines using this trait must be able/// to rely on `is_special_state` as an indicator that a state may need/// special treatment. (For example, when a search routine sees a dead/// state, it must terminate.)/// This routine permits search implementations to use a single branch to/// check whether a state needs special attention before executing the next/// transition. The example below shows how to do this./// This example shows how `is_special_state` can be used to implement a/// correct search routine with minimal branching. In particular, this/// search routine implements "leftmost" matching, which means that it/// doesn't immediately stop once a match is found. Instead, it continues/// until it reaches a dead state.///     dfa::{Automaton, dense},///     HalfMatch, MatchError, Input,///     dfa: &A,/// ) -> Result<Option<HalfMatch>, MatchError> {///     // The start state is determined by inspecting the position and the///     // initial bytes of the haystack. Note that start states can never///     // be match states (since DFAs in this crate delay matches by 1///     // byte), so we don't need to check if the start state is a match.///     let mut state = dfa.start_state_forward(&Input::new(haystack))?;///     let mut last_match = None;///     // Walk all the bytes in the haystack. We can quit early if we see///     // a dead or a quit state. The former means the automaton will///     // never transition to any other state. The latter means that the///     // automaton entered a condition in which its search failed.///     for (i, &b) in haystack.iter().enumerate() {///         state = dfa.next_state(state, b);///         if dfa.is_special_state(state) {///             if dfa.is_match_state(state) {///                 last_match = Some(HalfMatch::new(///                     dfa.match_pattern(state, 0),///                     i,///                 ));///             } else if dfa.is_dead_state(state) {///                 return Ok(last_match);///             } else if dfa.is_quit_state(state) {///                 // It is possible to enter into a quit state after///                 // observing a match has occurred. In that case, we///                 // should return the match instead of an error.///                 if last_match.is_some() {///                     return Ok(last_match);///                 return Err(MatchError::quit(b, i));///             // Implementors may also want to check for start or accel///             // states and handle them differently for performance///             // reasons. But it is not necessary for correctness.///     // Matches are always delayed by 1 byte, so we must explicitly walk///     // the special "EOI" transition at the end of the search.///     state = dfa.next_eoi_state(state);///     if dfa.is_match_state(state) {///         last_match = Some(HalfMatch::new(///             dfa.match_pattern(state, 0),///             haystack.len(),///         ));///     Ok(last_match)/// // We use a greedy '+' operator to show how the search doesn't just/// // stop once a match is detected. It continues extending the match./// // Using '[a-z]+?' would also work as expected and stop the search/// // early. Greediness is built into the automaton./// let dfa = dense::DFA::new(r"[a-z]+")?;/// let haystack = "123 foobar 4567".as_bytes();/// let mat = find(&dfa, haystack)?.unwrap();/// assert_eq!(mat.pattern().as_usize(), 0);/// assert_eq!(mat.offset(), 10);/// // Here's another example that tests our handling of the special EOI/// // transition. This will fail to find a match if we don't call/// // 'next_eoi_state' at the end of the search since the match isn't/// // found until the final byte in the haystack./// let dfa = dense::DFA::new(r"[0-9]{4}")?;/// assert_eq!(mat.offset(), 15);/// // And note that our search implementation above automatically works/// // with multi-DFAs. Namely, `dfa.match_pattern(match_state, 0)` selects/// // the appropriate pattern ID for us./// let dfa = dense::DFA::new_many(&[r"[a-z]+", r"[0-9]+"])?;/// assert_eq!(mat.pattern().as_usize(), 1);/// assert_eq!(mat.offset(), 3);/// let mat = find(&dfa, &haystack[3..])?.unwrap();/// assert_eq!(mat.offset(), 7);/// let mat = find(&dfa, &haystack[10..])?.unwrap();/// assert_eq!(mat.offset(), 5);is_dead_state/// Returns true if and only if the given identifier corresponds to a dead/// state. When a DFA enters a dead state, it is impossible to leave. That/// is, every transition on a dead state by definition leads back to the/// same dead state./// In practice, the dead state always corresponds to the identifier `0`./// Moreover, in practice, there is only one dead state./// The existence of a dead state is not strictly required in the classical/// model of finite state machines, where one generally only cares about/// the question of whether an input sequence matches or not. Dead states/// are not needed to answer that question, since one can immediately quit/// as soon as one enters a final or "match" state. However, we don't just/// care about matches but also care about the location of matches, and/// more specifically, care about semantics like "greedy" matching./// For example, given the pattern `a+` and the input `aaaz`, the dead/// state won't be entered until the state machine reaches `z` in the/// input, at which point, the search routine can quit. But without the/// dead state, the search routine wouldn't know when to quit. In a/// classical representation, the search routine would stop after seeing/// the first `a` (which is when the search would enter a match state). But/// this wouldn't implement "greedy" matching where `a+` matches as many/// `a`'s as possible./// See the example for [`Automaton::is_special_state`] for how to use this/// method correctly.is_quit_state/// Returns true if and only if the given identifier corresponds to a quit/// state. A quit state is like a dead state (it has no transitions other/// than to itself), except it indicates that the DFA failed to complete/// the search. When this occurs, callers can neither accept or reject that/// a match occurred./// In practice, the quit state always corresponds to the state immediately/// following the dead state. (Which is not usually represented by `1`,/// since state identifiers are pre-multiplied by the state machine's/// alphabet stride, and the alphabet stride varies between DFAs.)/// The typical way in which a quit state can occur is when heuristic/// support for Unicode word boundaries is enabled via the/// [`dense::Config::unicode_word_boundary`](crate::dfa::dense::Config::unicode_word_boundary)/// option. But other options, like the lower level/// [`dense::Config::quit`](crate::dfa::dense::Config::quit)/// configuration, can also result in a quit state being entered. The/// purpose of the quit state is to provide a way to execute a fast DFA/// in common cases while delegating to slower routines when the DFA quits./// The default search implementations provided by this crate will return a/// [`MatchError::quit`] error when a quit state is entered.is_match_state/// match state. A match state is also referred to as a "final" state and/// indicates that a match has been found./// If all you care about is whether a particular pattern matches in the/// input sequence, then a search routine can quit early as soon as the/// machine enters a match state. However, if you're looking for the/// standard "leftmost-first" match location, then search _must_ continue/// until either the end of the input or until the machine enters a dead/// state. (Since either condition implies that no other useful work can/// be done.) Namely, when looking for the location of a match, then/// search implementations should record the most recent location in/// which a match state was entered, but otherwise continue executing the/// search as normal. (The search may even leave the match state.) Once/// the termination condition is reached, the most recently recorded match/// location should be returned./// Finally, one additional power given to match states in this crate/// is that they are always associated with a specific pattern in order/// to support multi-DFAs. See [`Automaton::match_pattern`] for more/// details and an example for how to query the pattern associated with a/// particular match state.is_start_state/// Returns true only if the given identifier corresponds to a start/// state/// A start state is a state in which a DFA begins a search./// All searches begin in a start state. Moreover, since all matches are/// delayed by one byte, a start state can never be a match state./// The main role of a start state is, as mentioned, to be a starting/// point for a DFA. This starting point is determined via one of/// [`Automaton::start_state_forward`] or/// [`Automaton::start_state_reverse`], depending on whether one is doing/// a forward or a reverse search, respectively./// A secondary use of start states is for prefix acceleration. Namely,/// while executing a search, if one detects that you're in a start state,/// then it may be faster to look for the next match of a prefix of the/// pattern, if one exists. If a prefix exists and since all matches must/// begin with that prefix, then skipping ahead to occurrences of that/// prefix may be much faster than executing the DFA./// As mentioned in the documentation for/// [`is_special_state`](Automaton::is_special_state) implementations/// _may_ always return false, even if the given identifier is a start/// state. This is because knowing whether a state is a start state or not/// is not necessary for correctness and is only treated as a potential/// performance optimization. (For example, the implementations of this/// trait in this crate will only return true when the given identifier/// corresponds to a start state and when [specialization of start/// states](crate::dfa::dense::Config::specialize_start_states) was enabled/// during DFA construction. If start state specialization is disabled/// (which is the default), then this method will always return false.)/// This example shows how to implement your own search routine that does/// a prefix search whenever the search enters a start state./// Note that you do not need to implement your own search routine/// to make use of prefilters like this. The search routines/// provided by this crate already implement prefilter support via/// the [`Prefilter`](crate::util::prefilter::Prefilter) trait./// A prefilter can be added to your search configuration with/// [`dense::Config::prefilter`](crate::dfa::dense::Config::prefilter) for/// dense and sparse DFAs in this crate./// This example is meant to show how you might deal with prefilters in a/// simplified case if you are implementing your own search routine./// fn find_byte(slice: &[u8], at: usize, byte: u8) -> Option<usize> {///     // Would be faster to use the memchr crate, but this is still///     // faster than running through the DFA.///     slice[at..].iter().position(|&b| b == byte).map(|i| at + i)///     prefix_byte: Option<u8>,///     // See the Automaton::is_special_state example for similar code///     // with more comments.///     let mut pos = 0;///     while pos < haystack.len() {///         let b = haystack[pos];///         pos += 1;///                     pos - 1,///                 return Err(MatchError::quit(b, pos - 1));///             } else if dfa.is_start_state(state) {///                 // If we're in a start state and know all matches begin///                 // with a particular byte, then we can quickly skip to///                 // candidate matches without running the DFA through///                 // every byte inbetween.///                 if let Some(prefix_byte) = prefix_byte {///                     pos = match find_byte(haystack, pos, prefix_byte) {///                         Some(pos) => pos,///                         None => break,///                     };/// // In this example, it's obvious that all occurrences of our pattern/// // begin with 'Z', so we pass in 'Z'. Note also that we need to/// // enable start state specialization, or else it won't be possible to/// // detect start states during a search. ('is_start_state' would always/// // return false.)/// let dfa = dense::DFA::builder()///     .configure(dense::DFA::config().specialize_start_states(true))///     .build(r"Z[a-z]+")?;/// let haystack = "123 foobar Zbaz quux".as_bytes();/// let mat = find(&dfa, haystack, Some(b'Z'))?.unwrap();/// // But note that we don't need to pass in a prefix byte. If we don't,/// // then the search routine does no acceleration./// let mat = find(&dfa, haystack, None)?.unwrap();/// // However, if we pass an incorrect byte, then the prefix search will/// // result in incorrect results./// assert_eq!(find(&dfa, haystack, Some(b'X'))?, None);is_accel_state/// Returns true if and only if the given identifier corresponds to an/// An accelerated state is a special optimization/// trick implemented by this crate. Namely, if/// [`dense::Config::accelerate`](crate::dfa::dense::Config::accelerate) is/// enabled (and it is by default), then DFAs generated by this crate will/// tag states meeting certain characteristics as accelerated. States meet/// this criteria whenever most of their transitions are self-transitions./// That is, transitions that loop back to the same state. When a small/// number of transitions aren't self-transitions, then it follows that/// there are only a small number of bytes that can cause the DFA to leave/// that state. Thus, there is an opportunity to look for those bytes/// using more optimized routines rather than continuing to run through/// the DFA. This trick is similar to the prefilter idea described in/// the documentation of [`Automaton::is_start_state`] with two main/// 1. It is more limited since acceleration only applies to single bytes./// This means states are rarely accelerated when Unicode mode is enabled/// (which is enabled by default)./// 2. It can occur anywhere in the DFA, which increases optimization/// opportunities./// Like the prefilter idea, the main downside (and a possible reason to/// disable it) is that it can lead to worse performance in some cases./// Namely, if a state is accelerated for very common bytes, then the/// overhead of checking for acceleration and using the more optimized/// routines to look for those bytes can cause overall performance to be/// worse than if acceleration wasn't enabled at all./// A simple example of a regex that has an accelerated state is/// `(?-u)[^a]+a`. Namely, the `[^a]+` sub-expression gets compiled down/// into a single state where all transitions except for `a` loop back to/// itself, and where `a` is the only transition (other than the special/// EOI transition) that goes to some other state. Thus, this state can/// be accelerated and implemented more efficiently by calling an/// optimized routine like `memchr` with `a` as the needle. Notice that/// the `(?-u)` to disable Unicode is necessary here, as without it,/// `[^a]` will match any UTF-8 encoding of any Unicode scalar value other/// than `a`. This more complicated expression compiles down to many DFA/// states and the simple acceleration optimization is no longer available./// Typically, this routine is used to guard calls to/// [`Automaton::accelerator`], which returns the accelerated bytes for/// the specified state./// Returns the total number of patterns compiled into this DFA./// In the case of a DFA that contains no patterns, this must return `0`./// This example shows the pattern length for a DFA that never matches:/// use regex_automata::dfa::{Automaton, dense::DFA};/// let dfa: DFA<Vec<u32>> = DFA::never_match()?;/// assert_eq!(dfa.pattern_len(), 0);/// And another example for a DFA that matches at every position:/// let dfa: DFA<Vec<u32>> = DFA::always_match()?;/// assert_eq!(dfa.pattern_len(), 1);/// And finally, a DFA that was constructed from multiple patterns:/// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;/// assert_eq!(dfa.pattern_len(), 3);/// Returns the total number of patterns that match in this state./// If the given state is not a match state, then implementations may/// If the DFA was compiled with one pattern, then this must necessarily/// always return `1` for all match states./// Implementations must guarantee that [`Automaton::match_pattern`] can be/// called with indices up to (but not including) the length returned by/// this routine without panicking./// Implementations are permitted to panic if the provided state ID does/// not correspond to a match state./// This example shows a simple instance of implementing overlapping/// matches. In particular, it shows not only how to determine how many/// patterns have matched in a particular state, but also how to access/// which specific patterns have matched./// Notice that we must use/// [`MatchKind::All`](crate::MatchKind::All)/// when building the DFA. If we used/// [`MatchKind::LeftmostFirst`](crate::MatchKind::LeftmostFirst)/// instead, then the DFA would not be constructed in a way that/// supports overlapping matches. (It would only report a single pattern/// that matches at any particular point in time.)/// Another thing to take note of is the patterns used and the order in/// which the pattern IDs are reported. In the example below, pattern `3`/// is yielded first. Why? Because it corresponds to the match that/// appears first. Namely, the `@` symbol is part of `\S+` but not part/// of any of the other patterns. Since the `\S+` pattern has a match that/// starts to the left of any other pattern, its ID is returned before any/// # if cfg!(miri) { return Ok(()); } // miri takes too long/// use regex_automata::{dfa::{Automaton, dense}, Input, MatchKind};/// let dfa = dense::Builder::new()///     .configure(dense::Config::new().match_kind(MatchKind::All))///     .build_many(&[///         r"[[:word:]]+", r"[a-z]+", r"[A-Z]+", r"[[:^space:]]+",///     ])?;/// let haystack = "@bar".as_bytes();/// assert_eq!(dfa.match_len(state), 3);/// // The following calls are guaranteed to not panic since `match_len`/// // returned `3` above./// assert_eq!(dfa.match_pattern(state, 0).as_usize(), 3);/// assert_eq!(dfa.match_pattern(state, 1).as_usize(), 0);/// assert_eq!(dfa.match_pattern(state, 2).as_usize(), 1);/// Returns the pattern ID corresponding to the given match index in the/// given state./// See [`Automaton::match_len`] for an example of how to use this/// method correctly. Note that if you know your DFA is compiled with a/// single pattern, then this routine is never necessary since it will/// always return a pattern ID of `0` for an index of `0` when `id`/// corresponds to a match state./// Typically, this routine is used when implementing an overlapping/// search, as the example for `Automaton::match_len` does./// If the state ID is not a match state or if the match index is out/// of bounds for the given state, then this routine may either panic/// or produce an incorrect result. If the state ID is correct and the/// match index is correct, then this routine must always produce a validhas_empty/// Returns true if and only if this automaton can match the empty string./// When it returns false, all possible matches are guaranteed to have a/// non-zero length./// This is useful as cheap way to know whether code needs to handle the/// case of a zero length match. This is particularly important when UTF-8/// modes are enabled, as when UTF-8 mode is enabled, empty matches that/// split a codepoint must never be reported. This extra handling can/// sometimes be costly, and since regexes matching an empty string are/// somewhat rare, it can be beneficial to treat such regexes specially./// This example shows a few different DFAs and whether they match the/// empty string or not. Notice the empty string isn't merely a matter/// of a string of length literally `0`, but rather, whether a match can/// occur between specific pairs of bytes./// use regex_automata::{dfa::{dense::DFA, Automaton}, util::syntax};/// // The empty regex matches the empty string./// let dfa = DFA::new("")?;/// assert!(dfa.has_empty(), "empty matches empty");/// // The '+' repetition operator requires at least one match, and so/// // does not match the empty string./// let dfa = DFA::new("a+")?;/// assert!(!dfa.has_empty(), "+ does not match empty");/// // But the '*' repetition operator does./// let dfa = DFA::new("a*")?;/// assert!(dfa.has_empty(), "* does match empty");/// // And wrapping '+' in an operator that can match an empty string also/// // causes it to match the empty string too./// let dfa = DFA::new("(a+)*")?;/// assert!(dfa.has_empty(), "+ inside of * matches empty");/// // If a regex is just made of a look-around assertion, even if the/// // assertion requires some kind of non-empty string around it (such as/// // \b), then it is still treated as if it matches the empty string./// // Namely, if a match occurs of just a look-around assertion, then the/// // match returned is empty.///     .configure(DFA::config().unicode_word_boundary(true))///     .syntax(syntax::Config::new().utf8(false))///     .build(r"^$\A\z\b\B(?-u:\b\B)")?;/// assert!(dfa.has_empty(), "assertions match empty");/// // Even when an assertion is wrapped in a '+', it still matches the/// // empty string./// let dfa = DFA::new(r"^+")?;/// assert!(dfa.has_empty(), "+ of an assertion matches empty");/// // An alternation with even one branch that can match the empty string/// // is also said to match the empty string overall./// let dfa = DFA::new("foo|(bar)?|quux")?;/// assert!(dfa.has_empty(), "alternations can match empty");/// // An NFA that matches nothing does not match the empty string./// let dfa = DFA::new("[a&&b]")?;/// assert!(!dfa.has_empty(), "never matching means not matching empty");/// // But if it's wrapped in something that doesn't require a match at/// // all, then it can match the empty string!/// let dfa = DFA::new("[a&&b]*")?;/// assert!(dfa.has_empty(), "* on never-match still matches empty");/// // Since a '+' requires a match, using it on something that can never/// // match will itself produce a regex that can never match anything,/// // and thus does not match the empty string./// let dfa = DFA::new("[a&&b]+")?;/// assert!(!dfa.has_empty(), "+ on never-match still matches nothing");is_utf8/// Whether UTF-8 mode is enabled for this DFA or not./// When UTF-8 mode is enabled, all matches reported by a DFA are/// guaranteed to correspond to spans of valid UTF-8. This includes/// zero-width matches. For example, the DFA must guarantee that the empty/// regex will not match at the positions between code units in the UTF-8/// encoding of a single codepoint./// See [`thompson::Config::utf8`](crate::nfa::thompson::Config::utf8) for/// This example shows how UTF-8 mode can impact the match spans that may/// be reported in certain cases.///     dfa::{dense::DFA, Automaton},///     nfa::thompson,///     HalfMatch, Input,/// // UTF-8 mode is enabled by default./// let re = DFA::new("")?;/// assert!(re.is_utf8());/// let mut input = Input::new("☃");/// let got = re.try_search_fwd(&input)?;/// assert_eq!(Some(HalfMatch::must(0, 0)), got);/// // Even though an empty regex matches at 1..1, our next match is/// // 3..3 because 1..1 and 2..2 split the snowman codepoint (which is/// // three bytes long)./// input.set_start(1);/// assert_eq!(Some(HalfMatch::must(0, 3)), got);/// // But if we disable UTF-8, then we'll get matches at 1..1 and 2..2:/// let re = DFA::builder()///     .thompson(thompson::Config::new().utf8(false))///     .build("")?;/// assert!(!re.is_utf8());/// assert_eq!(Some(HalfMatch::must(0, 1)), got);/// input.set_start(2);/// assert_eq!(Some(HalfMatch::must(0, 2)), got);/// input.set_start(3);/// input.set_start(4);/// assert_eq!(None, got);is_always_start_anchored/// Returns true if and only if this DFA is limited to returning matches/// whose start position is `0`./// Note that if you're using DFAs provided by/// this crate, then this is _orthogonal_ to/// [`Config::start_kind`](crate::dfa::dense::Config::start_kind)./// This is useful in some cases because if a DFA is limited to producing/// matches that start at offset `0`, then a reverse search is never/// required for finding the start of a match./// use regex_automata::dfa::{dense::DFA, Automaton};/// // The empty regex matches anywhere/// assert!(!dfa.is_always_start_anchored(), "empty matches anywhere");/// // 'a' matches anywhere./// let dfa = DFA::new("a")?;/// assert!(!dfa.is_always_start_anchored(), "'a' matches anywhere");/// // '^' only matches at offset 0!/// let dfa = DFA::new("^a")?;/// assert!(dfa.is_always_start_anchored(), "'^a' matches only at 0");/// // But '(?m:^)' matches at 0 but at other offsets too./// let dfa = DFA::new("(?m:^)a")?;/// assert!(!dfa.is_always_start_anchored(), "'(?m:^)a' matches anywhere");/// Return a slice of bytes to accelerate for the given state, if possible./// If the given state has no accelerator, then an empty slice must be/// returned. If `Automaton::is_accel_state` returns true for the given ID,/// then this routine _must_ return a non-empty slice. But note that it is/// not required for an implementation of this trait to ever return `true`/// for `is_accel_state`, even if the state _could_ be accelerated. That/// is, acceleration is an optional optimization. But the return values of/// `is_accel_state` and `accelerator` must be in sync./// If the given ID is not a valid state ID for this automaton, then/// implementations may panic or produce incorrect results./// See [`Automaton::is_accel_state`] for more details on state/// By default, this method will always return an empty slice./// This example shows a contrived case in which we build a regex that we/// know is accelerated and extract the accelerator from a state.///     util::{primitives::StateID, syntax},///     // We disable Unicode everywhere and permit the regex to match///     // invalid UTF-8. e.g., [^abc] matches \xFF, which is not valid///     // UTF-8. If we left Unicode enabled, [^abc] would match any UTF-8///     // encoding of any Unicode scalar value except for 'a', 'b' or 'c'.///     // That translates to a much more complicated DFA, and also///     // inhibits the 'accelerator' optimization that we are trying to///     // demonstrate in this example.///     .syntax(syntax::Config::new().unicode(false).utf8(false))///     .build("[^abc]+a")?;/// // Here we just pluck out the state that we know is accelerated./// // While the stride calculations are something that can be relied/// // on by callers, the specific position of the accelerated state is/// // implementation defined./// // N.B. We get '3' by inspecting the state machine using 'regex-cli'./// // e.g., try `regex-cli debug dense dfa -p '[^abc]+a' -BbUC`./// let id = StateID::new(3 * dfa.stride()).unwrap();/// let accelerator = dfa.accelerator(id);/// // The `[^abc]+` sub-expression permits [a, b, c] to be accelerated./// assert_eq!(accelerator, &[b'a', b'b', b'c']);get_prefilter/// Returns the prefilter associated with a DFA, if one exists./// The default implementation of this trait always returns `None`. And/// indeed, it is always correct to return `None`./// For DFAs in this crate, a prefilter can be attached to a DFA via/// [`dense::Config::prefilter`](crate::dfa::dense::Config::prefilter)./// Do note that prefilters are not serialized by DFAs in this crate./// So if you deserialize a DFA that had a prefilter attached to it/// at serialization time, then it will not have a prefilter after/// deserialization.try_search_fwd/// Executes a forward search and returns the end position of the leftmost/// match that is found. If no match exists, then `None` is returned./// In particular, this method continues searching even after it enters/// a match state. The search only terminates once it has reached the/// end of the input or when it has entered a dead or quit state. Upon/// termination, the position of the last byte seen while still in a match/// state is returned./// This routine errors if the search could not complete. This can occur/// in a number of circumstances:/// * The configuration of the DFA may permit it to "quit" the search./// For example, setting quit bytes or enabling heuristic support for/// Unicode word boundaries. The default configuration does not enable any/// option that could result in the DFA quitting./// * When the provided `Input` configuration is not supported. For/// example, by providing an unsupported anchor mode./// When a search returns an error, callers cannot know whether a match/// exists or not./// # Notes for implementors/// Implementors of this trait are not required to implement any particular/// match semantics (such as leftmost-first), which are instead manifest in/// the DFA's transitions. But this search routine should behave as a/// general "leftmost" search./// In particular, this method must continue searching even after it enters/// a match state. The search should only terminate once it has reached/// the end of the input or when it has entered a dead or quit state. Upon/// Since this trait provides an implementation for this method by default,/// it's unlikely that one will need to implement this./// This example shows how to use this method with a/// [`dense::DFA`](crate::dfa::dense::DFA)./// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};/// let dfa = dense::DFA::new("foo[0-9]+")?;/// let expected = Some(HalfMatch::must(0, 8));/// assert_eq!(expected, dfa.try_search_fwd(&Input::new(b"foo12345"))?);/// // Even though a match is found after reading the first byte (`a`),/// // the leftmost first match semantics demand that we find the earliest/// // match that prefers earlier parts of the pattern over latter parts./// let dfa = dense::DFA::new("abc|a")?;/// let expected = Some(HalfMatch::must(0, 3));/// assert_eq!(expected, dfa.try_search_fwd(&Input::new(b"abc"))?);/// # Example: specific pattern search/// This example shows how to build a multi-DFA that permits searching for/// specific patterns.///     Anchored, HalfMatch, PatternID, Input,///     .configure(dense::Config::new().starts_for_each_pattern(true))///     .build_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;/// let haystack = "foo123".as_bytes();/// // Since we are using the default leftmost-first match and both/// // patterns match at the same starting position, only the first pattern/// // will be returned in this case when doing a search for any of the/// // patterns./// let expected = Some(HalfMatch::must(0, 6));/// let got = dfa.try_search_fwd(&Input::new(haystack))?;/// assert_eq!(expected, got);/// // But if we want to check whether some other pattern matches, then we/// // can provide its pattern ID./// let input = Input::new(haystack)///     .anchored(Anchored::Pattern(PatternID::must(1)));/// let expected = Some(HalfMatch::must(1, 6));/// let got = dfa.try_search_fwd(&input)?;/// # Example: specifying the bounds of a search/// This example shows how providing the bounds of a search can produce/// different results than simply sub-slicing the haystack./// // N.B. We disable Unicode here so that we use a simple ASCII word/// // boundary. Alternatively, we could enable heuristic support for/// // Unicode word boundaries./// let dfa = dense::DFA::new(r"(?-u)\b[0-9]{3}\b")?;/// let haystack = "foo123bar".as_bytes();/// // Since we sub-slice the haystack, the search doesn't know about the/// // larger context and assumes that `123` is surrounded by word/// // boundaries. And of course, the match position is reported relative/// // to the sub-slice as well, which means we get `3` instead of `6`./// let input = Input::new(&haystack[3..6]);/// // But if we provide the bounds of the search within the context of the/// // entire haystack, then the search can take the surrounding context/// // into account. (And if we did find a match, it would be reported/// // as a valid offset into `haystack` instead of its sub-slice.)/// let input = Input::new(haystack).range(3..6);/// let expected = None;try_search_rev/// Executes a reverse search and returns the start of the position of the/// leftmost match that is found. If no match exists, then `None` is/// [`dense::DFA`](crate::dfa::dense::DFA). In particular, this/// routine is principally useful when used in conjunction with the/// [`nfa::thompson::Config::reverse`](crate::nfa::thompson::Config::reverse)/// configuration. In general, it's unlikely to be correct to use/// both `try_search_fwd` and `try_search_rev` with the same DFA since/// any particular DFA will only support searching in one direction with/// respect to the pattern.///     .thompson(thompson::Config::new().reverse(true))///     .build("foo[0-9]+")?;/// let expected = Some(HalfMatch::must(0, 0));/// assert_eq!(expected, dfa.try_search_rev(&Input::new(b"foo12345"))?);/// // Even though a match is found after reading the last byte (`c`),///     .build("abc|c")?;/// assert_eq!(expected, dfa.try_search_rev(&Input::new(b"abc"))?);/// # Example: UTF-8 mode/// This examples demonstrates that UTF-8 mode applies to reverse/// DFAs. When UTF-8 mode is enabled in the underlying NFA, then all/// matches reported must correspond to valid UTF-8 spans. This includes/// prohibiting zero-width matches that split a codepoint./// UTF-8 mode is enabled by default. Notice below how the only zero-width/// matches reported are those at UTF-8 boundaries:///     HalfMatch, Input, MatchKind,///     .build(r"")?;/// // Run the reverse DFA to collect all matches.///     match dfa.try_search_rev(&input)? {///         Some(hm) => {///             matches.push(hm);///             if hm.offset() == 0 || input.end() == 0 {///                 break;///             } else if hm.offset() < input.end() {///                 input.set_end(hm.offset());///                 // This is only necessary to handle zero-width///                 // matches, which of course occur in this example.///                 // Without this, the search would never advance///                 // backwards beyond the initial match.///                 input.set_end(input.end() - 1);/// // No matches split a codepoint.///     HalfMatch::must(0, 3),///     HalfMatch::must(0, 0),/// Now let's look at the same example, but with UTF-8 mode on the/// original NFA disabled (which results in disabling UTF-8 mode on the/// DFA):///     .thompson(thompson::Config::new().reverse(true).utf8(false))///     HalfMatch::must(0, 2),///     HalfMatch::must(0, 1),try_search_overlapping_fwd/// Executes an overlapping forward search. Matches, if one exists, can be/// obtained via the [`OverlappingState::get_match`] method./// This routine is principally only useful when searching for multiple/// patterns on inputs where multiple patterns may match the same regions/// of text. In particular, callers must preserve the automaton's search/// state from prior calls so that the implementation knows where the last/// match occurred./// When using this routine to implement an iterator of overlapping/// matches, the `start` of the search should always be set to the end/// of the last match. If more patterns match at the previous location,/// then they will be immediately returned. (This is tracked by the given/// overlapping state.) Otherwise, the search continues at the starting/// position given./// If for some reason you want the search to forget about its previous/// state and restart the search at a particular position, then setting the/// state to [`OverlappingState::start`] will accomplish that./// This example shows how to run a basic overlapping search with a/// [`dense::DFA`](crate::dfa::dense::DFA). Notice that we build the/// automaton with a `MatchKind::All` configuration. Overlapping searches/// are unlikely to work as one would expect when using the default/// `MatchKind::LeftmostFirst` match semantics, since leftmost-first/// matching is fundamentally incompatible with overlapping searches./// Namely, overlapping searches need to report matches as they are seen,/// where as leftmost-first searches will continue searching even after a/// match has been observed in order to find the conventional end position/// of the match. More concretely, leftmost-first searches use dead states/// to terminate a search after a specific match can no longer be extended./// Overlapping searches instead do the opposite by continuing the search/// to find totally new matches (potentially of other patterns).///     dfa::{Automaton, OverlappingState, dense},///     .build_many(&[r"[[:word:]]+$", r"[[:^space:]]+$"])?;/// let haystack = "@foo";/// let expected = Some(HalfMatch::must(1, 4));/// dfa.try_search_overlapping_fwd(&Input::new(haystack), &mut state)?;/// assert_eq!(expected, state.get_match());/// // The first pattern also matches at the same position, so re-running/// // the search will yield another match. Notice also that the first/// // pattern is returned after the second. This is because the second/// // pattern begins its match before the first, is therefore an earlier/// // match and is thus reported first./// let expected = Some(HalfMatch::must(0, 4));try_search_overlapping_rev/// Executes a reverse overlapping forward search. Matches, if one exists,/// can be obtained via the [`OverlappingState::get_match`] method./// matches, the `start` of the search should remain invariant throughout/// iteration. The `OverlappingState` given to the search will keep track/// of the current position of the search. (This is because multiple/// matches may be reported at the same position, so only the search/// implementation itself knows when to advance the position.)///     dfa::{dense::DFA, Automaton, OverlappingState},///     .configure(DFA::config().match_kind(MatchKind::All))///     .build_many(&[r"", r"☃"])?;/// let input = Input::new("☃");///     dfa.try_search_overlapping_rev(&input, &mut state)?;///     match state.get_match() {///         Some(hm) => matches.push(hm),///     HalfMatch::must(1, 0),/// // Now *all* positions match, even within a codepoint,/// // because we lifted the requirement that matches/// // correspond to valid UTF-8 spans.try_which_overlapping_matches/// Writes the set of patterns that match anywhere in the given search/// configuration to `patset`. If multiple patterns match at the same/// position and the underlying DFA supports overlapping matches, then all/// matching patterns are written to the given set./// Unless all of the patterns in this DFA are anchored, then generally/// speaking, this will visit every byte in the haystack./// This search routine *does not* clear the pattern set. This gives some/// flexibility to the caller (e.g., running multiple searches with the/// same pattern set), but does make the API bug-prone if you're reusing/// the same pattern set for multiple searches but intended them to be/// independent./// If a pattern ID matched but the given `PatternSet` does not have/// sufficient capacity to store it, then it is not inserted and silently/// This example shows how to find all matching patterns in a haystack,/// even when some patterns match at the same position as other patterns.///     Input, MatchKind, PatternSet,/// let patterns = &[///     r"[[:word:]]+",///     r"[0-9]+",///     r"[[:alpha:]]+",///     .build_many(patterns)?;/// let mut patset = PatternSet::new(dfa.pattern_len());/// dfa.try_which_overlapping_matches(&input, &mut patset)?;/// let expected = vec![0, 2, 3, 4, 6];/// let got: Vec<usize> = patset.iter().map(|p| p.as_usize()).collect();/// A trait describing the interface of a deterministic finite automaton (DFA)./// The complexity of this trait probably means that it's unlikely for others/// to implement it. The primary purpose of the trait is to provide for a way/// of abstracting over different types of DFAs. In this crate, that means/// dense DFAs and sparse DFAs. (Dense DFAs are fast but memory hungry, where/// as sparse DFAs are slower but come with a smaller memory footprint. But/// they otherwise provide exactly equivalent expressive power.) For example, a/// [`dfa::regex::Regex`](crate::dfa::regex::Regex) is generic over this trait./// Normally, a DFA's execution model is very simple. You might have a single/// start state, zero or more final or "match" states and a function that/// transitions from one state to the next given the next byte of input./// Unfortunately, the interface described by this trait is significantly/// more complicated than this. The complexity has a number of different/// reasons, mostly motivated by performance, functionality or space savings:/// * A DFA can search for multiple patterns simultaneously. This/// means extra information is returned when a match occurs. Namely,/// a match is not just an offset, but an offset plus a pattern ID./// [`Automaton::pattern_len`] returns the number of patterns compiled into/// the DFA, [`Automaton::match_len`] returns the total number of patterns/// that match in a particular state and [`Automaton::match_pattern`] permits/// iterating over the patterns that match in a particular state./// * A DFA can have multiple start states, and the choice of which start/// state to use depends on the content of the string being searched and/// position of the search, as well as whether the search is an anchored/// search for a specific pattern in the DFA. Moreover, computing the start/// state also depends on whether you're doing a forward or a reverse search./// [`Automaton::start_state_forward`] and [`Automaton::start_state_reverse`]/// are used to compute the start state for forward and reverse searches,/// * All matches are delayed by one byte to support things like `$` and `\b`/// at the end of a pattern. Therefore, every use of a DFA is required to use/// [`Automaton::next_eoi_state`]/// at the end of the search to compute the final transition./// * For optimization reasons, some states are treated specially. Every/// state is either special or not, which can be determined via the/// [`Automaton::is_special_state`] method. If it's special, then the state/// must be at least one of a few possible types of states. (Note that some/// types can overlap, for example, a match state can also be an accel state./// But some types can't. If a state is a dead state, then it can never be any/// other type of state.) Those types are:///     * A dead state. A dead state means the DFA will never enter a match///     state. This can be queried via the [`Automaton::is_dead_state`] method.///     * A quit state. A quit state occurs if the DFA had to stop the search///     prematurely for some reason. This can be queried via the///     [`Automaton::is_quit_state`] method.///     * A match state. A match state occurs when a match is found. When a DFA///     enters a match state, the search may stop immediately (when looking///     for the earliest match), or it may continue to find the leftmost-first///     match. This can be queried via the [`Automaton::is_match_state`]///     method.///     * A start state. A start state is where a search begins. For every///     search, there is exactly one start state that is used, however, a///     DFA may contain many start states. When the search is in a start///     state, it may use a prefilter to quickly skip to candidate matches///     without executing the DFA on every byte. This can be queried via the///     [`Automaton::is_start_state`] method.///     * An accel state. An accel state is a state that is accelerated.///     That is, it is a state where _most_ of its transitions loop back to///     itself and only a small number of transitions lead to other states.///     This kind of state is said to be accelerated because a search routine///     can quickly look for the bytes leading out of the state instead of///     continuing to execute the DFA on each byte. This can be queried via the///     [`Automaton::is_accel_state`] method. And the bytes that lead out of///     the state can be queried via the [`Automaton::accelerator`] method./// There are a number of provided methods on this trait that implement/// efficient searching (for forwards and backwards) with a DFA using/// all of the above features of this trait. In particular, given the/// complexity of all these features, implementing a search routine in/// this trait can be a little subtle. With that said, it is possible to/// somewhat simplify the search routine. For example, handling accelerated/// states is strictly optional, since it is always correct to assume that/// `Automaton::is_accel_state` returns false. However, one complex part of/// writing a search routine using this trait is handling the 1-byte delay of a/// match. That is not optional./// have many start states, and which one is in use depends on several/// search-time factors.rev_eoi/// This is set to true when a reverse overlapping search has entered its/// EOI transitions./// This isn't used in a forward search because it knows to stop once the/// position exceeds the end of the search range. In a reverse search,/// since we use unsigned offsets, we don't "know" once we've gone past/// `0`. So the only way to detect it is with this extra flag. The reverse/// overlapping search knows to terminate specifically after it has/// reported all matches after following the EOI transition./// the last search call terminated in./// This type provides little introspection capabilities. The only thing a/// to use it to track state, and also ask whether a match has been found./// [`OverlappingState::start`] when starting a new search. Reusing state from/// a previous search may result in incorrect results./// Create a new overlapping state that begins at the start state of any/// A searches will clear this result automatically, such that if no/// match is found, this will correctly report `None`./// The quit byte that was found./// An error that occurs when a starting configuration's look-behind byte/// is in this DFA's quit set./// The anchored mode given that is unsupported.UnsupportedAnchored/// An error that occurs when the caller requests an anchored mode that/// isn't supported by the DFA./// An error that can occur when computing the start state for a search./// Computing a start state can fail for a few reasons, either based on/// incorrect configuration or even based on whether the look-behind byte/// triggers a quit state. Typically one does not need to handle this error/// if you're using [`Automaton::start_state_forward`] (or its reverse/// counterpart), as that routine automatically converts `StartError` to a/// [`MatchError`] for you./// This error may be returned by the [`Automaton::start_state`] routine./// This error implements the `std::error::Error` trait when the `std` feature/// is enabled./// This error is marked as non-exhaustive. New variants may be added in a/// semver compatible release.unsupported_anchoredskip_empty_utf8_splits_overlapping/// Runs the given overlapping `search` function (forwards or backwards) until/// a match is found whose offset does not split a codepoint./// This is *not* always correct to call. It should only be called when the DFA/// has UTF-8 mode enabled *and* it can produce zero-width matches. Calling/// this when both of those things aren't true might result in legitimate/// matches getting skipped./// Write a prefix "state" indicator for fmt::Debug impls./// states: dead states, quit states, accelerated states, start states and/// match states. It even accounts for the possible overlappings of different/// state types.object_safe// A basic test ensuring that our Automaton trait is object safe. (This is// the main reason why we don't define the search routines as generic over// Into<Input>.)determinizeMinimizerlookLookMatcherStartByteMapLABEL/// The label that is pre-pended to a serialized DFA./// The format version of dense regexes. This version gets incremented when a/// change occurs. A change may not necessarily be a breaking change, but the/// version does permit good error messages in the case where a breaking change/// is made.accelerate// As with other configuration types in this crate, we put all our knobs// in options so that we can distinguish between "default" and "not set."// This makes it possible to easily combine multiple configurations// without default values overwriting explicitly specified values. See the// 'overwrite' method.// For docs on the fields below, see the corresponding method setters.starts_for_each_patternunicode_word_boundaryquitsetspecialize_start_statesdeterminize_size_limit/// The configuration used for compiling a dense DFA./// As a convenience, [`DFA::config`] is an alias for [`Config::new`]. The/// advantage of the former is that it often lets you avoid importing the/// `Config` type directly./// A dense DFA configuration is a simple data object that is typically used/// with [`dense::Builder::configure`](self::Builder::configure)./// The default configuration guarantees that a search will never return/// a "quit" error, although it is possible for a search to fail if/// [`Config::starts_for_each_pattern`] wasn't enabled (which it is/// not by default) and an [`Anchored::Pattern`] mode is requested via/// [`Input`](crate::Input)./// Return a new default dense DFA compiler configuration./// Enable state acceleration./// When enabled, DFA construction will analyze each state to determine/// whether it is eligible for simple acceleration. Acceleration typically/// occurs when most of a state's transitions loop back to itself, leaving/// only a select few bytes that will exit the state. When this occurs,/// other routines like `memchr` can be used to look for those bytes which/// may be much faster than traversing the DFA./// Callers may elect to disable this if consistent performance is more/// desirable than variable performance. Namely, acceleration can sometimes/// make searching slower than it otherwise would be if the transitions/// that leave accelerated states are traversed frequently./// See [`Automaton::accelerator`] for an example./// Set a prefilter to be used whenever a start state is entered./// A [`Prefilter`] in this context is meant to accelerate searches by/// looking for literal prefixes that every match for the corresponding/// pattern (or patterns) must start with. Once a prefilter produces a/// match, the underlying search routine continues on to try and confirm/// the match./// Be warned that setting a prefilter does not guarantee that the search/// will be faster. While it's usually a good bet, if the prefilter/// produces a lot of false positive candidates (i.e., positions matched/// by the prefilter but not by the regex), then the overall result can/// be slower than if you had just executed the regex engine without any/// prefilters./// Note that unless [`Config::specialize_start_states`] has been/// explicitly set, then setting this will also enable (when `pre` is/// `Some`) or disable (when `pre` is `None`) start state specialization./// This occurs because without start state specialization, a prefilter/// is likely to be less effective. And without a prefilter, start state/// specialization is usually pointless./// **WARNING:** Note that prefilters are not preserved as part of/// serialization. Serializing a DFA will drop its prefilter./// By default no prefilter is set.///     util::prefilter::Prefilter,///     Input, HalfMatch, MatchKind,/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "bar"]);///     .configure(DFA::config().prefilter(pre))///     .build(r"(foo|bar)[a-z]+")?;/// let input = Input::new("foo1 barfox bar");///     Some(HalfMatch::must(0, 11)),///     re.try_search_fwd(&input)?,/// Be warned though that an incorrect prefilter can lead to incorrect/// results!/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "car"]);///     // No match reported even though there clearly is one!/// Minimize the DFA./// When enabled, the DFA built will be minimized such that it is as small/// Whether one enables minimization or not depends on the types of costs/// you're willing to pay and how much you care about its benefits. In/// particular, minimization has worst case `O(n*k*logn)` time and `O(k*n)`/// space, where `n` is the number of DFA states and `k` is the alphabet/// size. In practice, minimization can be quite costly in terms of both/// space and time, so it should only be done if you're willing to wait/// longer to produce a DFA. In general, you might want a minimal DFA in/// the following circumstances:/// 1. You would like to optimize for the size of the automaton. This can///    manifest in one of two ways. Firstly, if you're converting the///    DFA into Rust code (or a table embedded in the code), then a minimal///    DFA will translate into a corresponding reduction in code  size, and///    thus, also the final compiled binary size. Secondly, if you are///    building many DFAs and putting them on the heap, you'll be able to///    fit more if they are smaller. Note though that building a minimal///    DFA itself requires additional space; you only realize the space///    savings once the minimal DFA is constructed (at which point, the///    space used for minimization is freed)./// 2. You've observed that a smaller DFA results in faster match///    performance. Naively, this isn't guaranteed since there is no///    inherent difference between matching with a bigger-than-minimal///    DFA and a minimal DFA. However, a smaller DFA may make use of your///    CPU's cache more efficiently./// 3. You are trying to establish an equivalence between regular///    languages. The standard method for this is to build a minimal DFA///    for each language and then compare them. If the DFAs are equivalent///    (up to state renaming), then the languages are equivalent./// Typically, minimization only makes sense as an offline process. That/// is, one might minimize a DFA before serializing it to persistent/// storage. In practical terms, minimization can take around an order of/// magnitude more time than compiling the initial DFA via determinization./// This option is disabled by default./// The default is [`MatchKind::LeftmostFirst`], which corresponds to the/// match semantics of Perl-like regex engines. That is, when multiple/// patterns would match at the same leftmost position, the pattern that/// appears first in the concrete syntax is chosen./// Currently, the only other kind of match semantics supported is/// [`MatchKind::All`]. This corresponds to classical DFA construction/// where all possible matches are added to the DFA./// Typically, `All` is used when one wants to execute an overlapping/// search and `LeftmostFirst` otherwise. In particular, it rarely makes/// sense to use `All` with the various "leftmost" find routines, since the/// leftmost routines depend on the `LeftmostFirst` automata construction/// strategy. Specifically, `LeftmostFirst` adds dead states to the DFA/// as a way to terminate the search and report a match. `LeftmostFirst`/// also supports non-greedy matches using this strategy where as `All`/// does not./// # Example: overlapping search/// This example shows the typical use of `MatchKind::All`, which is to/// report overlapping matches.///     .build_many(&[r"\w+$", r"\S+$"])?;/// let input = Input::new("@foo");/// dfa.try_search_overlapping_fwd(&input, &mut state)?;/// # Example: reverse automaton to find start of match/// Another example for using `MatchKind::All` is for constructing a/// reverse automaton to find the start of a match. `All` semantics are/// used for this in order to find the longest possible match, which/// corresponds to the leftmost starting position./// Note that if you need the starting position then/// [`dfa::regex::Regex`](crate::dfa::regex::Regex) will handle this for/// you, so it's usually not necessary to do this yourself.///     dfa::{dense, Automaton, StartKind},///     nfa::thompson::NFA,///     Anchored, HalfMatch, Input, MatchKind,/// let haystack = "123foobar456".as_bytes();/// let pattern = r"[a-z]+r";/// let dfa_fwd = dense::DFA::new(pattern)?;/// let dfa_rev = dense::Builder::new()///     .thompson(NFA::config().reverse(true))///     .configure(dense::Config::new()///         // This isn't strictly necessary since both anchored and///         // unanchored searches are supported by default. But since///         // finding the start-of-match only requires anchored searches,///         // we can get rid of the unanchored configuration and possibly///         // slim down our DFA considerably.///         .start_kind(StartKind::Anchored)///         .match_kind(MatchKind::All)///     .build(pattern)?;/// let expected_fwd = HalfMatch::must(0, 9);/// let expected_rev = HalfMatch::must(0, 3);/// let got_fwd = dfa_fwd.try_search_fwd(&Input::new(haystack))?.unwrap();/// // Here we don't specify the pattern to search for since there's only/// // one pattern and we're doing a leftmost search. But if this were an/// // overlapping search, you'd need to specify the pattern that matched/// // in the forward direction. (Otherwise, you might wind up finding the/// // starting position of a match of some other pattern.) That in turn/// // requires building the reverse automaton with starts_for_each_pattern/// // enabled. Indeed, this is what Regex does internally.///     .range(..got_fwd.offset())///     .anchored(Anchored::Yes);/// let got_rev = dfa_rev.try_search_rev(&input)?.unwrap();/// assert_eq!(expected_fwd, got_fwd);/// assert_eq!(expected_rev, got_rev);/// The type of starting state configuration to use for a DFA./// By default, the starting state configuration is [`StartKind::Both`].///     dfa::{dense::DFA, Automaton, StartKind},///     Anchored, HalfMatch, Input,/// let haystack = "quux foo123";/// let expected = HalfMatch::must(0, 11);/// // By default, DFAs support both anchored and unanchored searches./// let dfa = DFA::new(r"[0-9]+")?;/// assert_eq!(Some(expected), dfa.try_search_fwd(&input)?);/// // But if we only need anchored searches, then we can build a DFA/// // that only supports anchored searches. This leads to a smaller DFA/// // (potentially significantly smaller in some cases), but a DFA that/// // will panic if you try to use it with an unanchored search.///     .configure(DFA::config().start_kind(StartKind::Anchored))///     .build(r"[0-9]+")?;///     .range(8..)/// Whether to compile a separate start state for each pattern in the/// When enabled, a separate **anchored** start state is added for each/// pattern in the DFA. When this start state is used, then the DFA will/// only search for matches for the pattern specified, even if there are/// other patterns in the DFA./// The main downside of this option is that it can potentially increase/// the size of the DFA and/or increase the time it takes to build the DFA./// There are a few reasons one might want to enable this (it's disabled/// by default):/// 1. When looking for the start of an overlapping match (using a/// reverse DFA), doing it correctly requires starting the reverse search/// using the starting state of the pattern that matched in the forward/// direction. Indeed, when building a [`Regex`](crate::dfa::regex::Regex),/// it will automatically enable this option when building the reverse DFA/// 2. When you want to use a DFA with multiple patterns to both search/// for matches of any pattern or to search for anchored matches of one/// particular pattern while using the same DFA. (Otherwise, you would need/// to compile a new DFA for each pattern.)/// 3. Since the start states added for each pattern are anchored, if you/// compile an unanchored DFA with one pattern while also enabling this/// option, then you can use the same DFA to perform anchored or unanchored/// searches. The latter you get with the standard search APIs. The former/// you get from the various `_at` search methods that allow you specify a/// pattern ID to search for./// By default this is disabled./// This example shows how to use this option to permit the same DFA to/// run both anchored and unanchored searches for a single pattern.///     dfa::{dense, Automaton},///     .build(r"foo[0-9]+")?;/// // Here's a normal unanchored search. Notice that we use 'None' for the/// // pattern ID. Since the DFA was built as an unanchored machine, it/// // use its default unanchored starting state./// // But now if we explicitly specify the pattern to search ('0' being/// // the only pattern in the DFA), then it will use the starting state/// // for that specific pattern which is always anchored. Since the/// // pattern doesn't have a match at the beginning of the haystack, we/// // find nothing.///     .anchored(Anchored::Pattern(PatternID::must(0)));/// assert_eq!(None, dfa.try_search_fwd(&input)?);/// // And finally, an anchored search is not the same as putting a '^' at/// // beginning of the pattern. An anchored search can only match at the/// // beginning of the *search*, which we can change:///     .anchored(Anchored::Pattern(PatternID::must(0)))///     .range(5..);/// Whether to attempt to shrink the size of the DFA's alphabet or not./// one is debugging a generated DFA./// When enabled, the DFA will use a map from all possible bytes to their/// corresponding equivalence class. Each equivalence class represents a/// set of bytes that does not discriminate between a match and a non-match/// in the DFA. For example, the pattern `[ab]+` has at least two/// equivalence classes: a set containing `a` and `b` and a set containing/// every byte except for `a` and `b`. `a` and `b` are in the same/// equivalence class because they never discriminate between a match and a/// non-match./// The advantage of this map is that the size of the transition table/// can be reduced drastically from `#states * 256 * sizeof(StateID)` to/// `#states * k * sizeof(StateID)` where `k` is the number of equivalence/// alphabet is used, DFA compilation becomes faster as well./// **WARNING:** This is only useful for debugging DFAs. Disabling this/// does not yield any speed advantages. Namely, even when this is/// Heuristically enable Unicode word boundaries./// When set, this will attempt to implement Unicode word boundaries as if/// they were ASCII word boundaries. This only works when the search input/// is ASCII only. If a non-ASCII byte is observed while searching, then a/// [`MatchError::quit`](crate::MatchError::quit) error is returned./// A possible alternative to enabling this option is to simply use an/// ASCII word boundary, e.g., via `(?-u:\b)`. The main reason to use this/// option is if you absolutely need Unicode support. This option lets one/// use a fast search implementation (a DFA) for some potentially very/// common cases, while providing the option to fall back to some other/// regex engine to handle the general case when an error is returned./// If the pattern provided has no Unicode word boundary in it, then this/// option has no effect. (That is, quitting on a non-ASCII byte only/// occurs when this option is enabled _and_ a Unicode word boundary is/// present in the pattern.)/// This is almost equivalent to setting all non-ASCII bytes to be quit/// bytes. The only difference is that this will cause non-ASCII bytes to/// be quit bytes _only_ when a Unicode word boundary is present in the/// When enabling this option, callers _must_ be prepared to handle/// a [`MatchError`](crate::MatchError) error during search./// When using a [`Regex`](crate::dfa::regex::Regex), this corresponds/// to using the `try_` suite of methods. Alternatively, if/// callers can guarantee that their input is ASCII only, then a/// [`MatchError::quit`](crate::MatchError::quit) error will never be/// returned while searching./// This example shows how to heuristically enable Unicode word boundaries/// in a pattern. It also shows what happens when a search comes across a/// non-ASCII byte.///     HalfMatch, Input, MatchError,///     .configure(dense::Config::new().unicode_word_boundary(true))///     .build(r"\b[0-9]+\b")?;/// // The match occurs before the search ever observes the snowman/// // character, so no error occurs./// let haystack = "foo 123  ☃".as_bytes();/// let expected = Some(HalfMatch::must(0, 7));/// // Notice that this search fails, even though the snowman character/// // occurs after the ending match offset. This is because search/// // routines read one byte past the end of the search to account for/// // look-around, and indeed, this is required here to determine whether/// // the trailing \b matches./// let haystack = "foo 123 ☃".as_bytes();/// let expected = MatchError::quit(0xE2, 8);/// let got = dfa.try_search_fwd(&Input::new(haystack));/// assert_eq!(Err(expected), got);/// // Another example is executing a search where the span of the haystack/// // we specify is all ASCII, but there is non-ASCII just before it. This/// // correctly also reports an error./// let input = Input::new("β123").range(2..);/// let expected = MatchError::quit(0xB2, 1);/// let got = dfa.try_search_fwd(&input);/// // And similarly for the trailing word boundary./// let input = Input::new("123β").range(..3);/// let expected = MatchError::quit(0xCE, 3);/// Add a "quit" byte to the DFA./// When a quit byte is seen during search time, then search will return/// a [`MatchError::quit`](crate::MatchError::quit) error indicating the/// offset at which the search stopped./// A quit byte will always overrule any other aspects of a regex. For/// example, if the `x` byte is added as a quit byte and the regex `\w` is/// used, then observing `x` will cause the search to quit immediately/// despite the fact that `x` is in the `\w` class./// This mechanism is primarily useful for heuristically enabling certain/// features like Unicode word boundaries in a DFA. Namely, if the input/// to search is ASCII, then a Unicode word boundary can be implemented/// via an ASCII word boundary with no change in semantics. Thus, a DFA/// can attempt to match a Unicode word boundary but give up as soon as it/// observes a non-ASCII byte. Indeed, if callers set all non-ASCII bytes/// to be quit bytes, then Unicode word boundaries will be permitted when/// building DFAs. Of course, callers should enable/// [`Config::unicode_word_boundary`] if they want this behavior instead./// (The advantage being that non-ASCII quit bytes will only be added if a/// Unicode word boundary is in the pattern.)/// When enabling this option, callers _must_ be prepared to handle a/// [`MatchError`](crate::MatchError) error during search. When using a/// [`Regex`](crate::dfa::regex::Regex), this corresponds to using the/// `try_` suite of methods./// By default, there are no quit bytes set./// This panics if heuristic Unicode word boundaries are enabled and any/// non-ASCII byte is removed from the set of quit bytes. Namely, enabling/// Unicode word boundaries requires setting every non-ASCII byte to a quit/// byte. So if the caller attempts to undo any of that, then this will/// This example shows how to cause a search to terminate if it sees a/// `\n` byte. This could be useful if, for example, you wanted to prevent/// a user supplied pattern from matching across a line boundary./// use regex_automata::{dfa::{Automaton, dense}, Input, MatchError};///     .configure(dense::Config::new().quit(b'\n', true))///     .build(r"foo\p{any}+bar")?;/// let haystack = "foo\nbar".as_bytes();/// // Normally this would produce a match, since \p{any} contains '\n'./// // But since we instructed the automaton to enter a quit state if a/// // '\n' is observed, this produces a match error instead./// let expected = MatchError::quit(b'\n', 3);/// let got = dfa.try_search_fwd(&Input::new(haystack)).unwrap_err();/// Enable specializing start states in the DFA./// When start states are specialized, an implementor of a search routine/// using a lazy DFA can tell when the search has entered a starting state./// When start states aren't specialized, then it is impossible to know/// whether the search has entered a start state./// Ideally, this option wouldn't need to exist and we could always/// specialize start states. The problem is that start states can be quite/// active. This in turn means that an efficient search routine is likely/// to ping-pong between a heavily optimized hot loop that handles most/// states and to a less optimized specialized handling of start states./// This causes branches to get heavily mispredicted and overall can/// materially decrease throughput. Therefore, specializing start states/// should only be enabled when it is needed./// Knowing whether a search is in a start state is typically useful when a/// prefilter is active for the search. A prefilter is typically only run/// when in a start state and a prefilter can greatly accelerate a search./// Therefore, the possible cost of specializing start states is worth it/// in this case. Otherwise, if you have no prefilter, there is likely no/// reason to specialize start states./// This is disabled by default, but note that it is automatically/// enabled (or disabled) if [`Config::prefilter`] is set. Namely, unless/// `specialize_start_states` has already been set, [`Config::prefilter`]/// will automatically enable or disable it based on whether a prefilter/// is present or not, respectively. This is done because a prefilter's/// effectiveness is rooted in being executed whenever the DFA is in a/// start state, and that's only possible to do when they are specialized./// Note that it is plausibly reasonable to _disable_ this option/// explicitly while _enabling_ a prefilter. In that case, a prefilter/// will still be run at the beginning of a search, but never again. This/// in theory could strike a good balance if you're in a situation where a/// prefilter is likely to produce many false positive candidates./// This example shows how to enable start state specialization and then/// shows how to check whether a state is a start state or not./// use regex_automata::{dfa::{Automaton, dense::DFA}, Input};///     .configure(DFA::config().specialize_start_states(true))///     .build(r"[a-z]+")?;/// let sid = dfa.start_state_forward(&Input::new(haystack))?;/// // The ID returned by 'start_state_forward' will always be tagged as/// // a start state when start state specialization is enabled./// assert!(dfa.is_special_state(sid));/// assert!(dfa.is_start_state(sid));/// Compare the above with the default DFA configuration where start states/// are _not_ specialized. In this case, the start state is not tagged at/// all:/// let dfa = DFA::new(r"[a-z]+")?;/// let haystack = "123 foobar 4567";/// // Start states are not special in the default configuration!/// assert!(!dfa.is_special_state(sid));/// assert!(!dfa.is_start_state(sid));/// Set a size limit on the total heap used by a DFA./// This size limit is expressed in bytes and is applied during/// determinization of an NFA into a DFA. If the DFA's heap usage, and only/// the DFA, exceeds this configured limit, then determinization is stopped/// and an error is returned./// This limit does not apply to auxiliary storage used during/// determinization that isn't part of the generated DFA./// This limit is only applied during determinization. Currently, there is/// no way to post-pone this check to after minimization if minimization/// was enabled./// The total limit on heap used during determinization is the sum of the/// DFA and determinization size limits./// The default is no limit./// This example shows a DFA that fails to build because of a configured/// size limit. This particular example also serves as a cautionary tale/// demonstrating just how big DFAs with large Unicode character classes/// can get./// use regex_automata::{dfa::{dense, Automaton}, Input};/// // 6MB isn't enough!/// dense::Builder::new()///     .configure(dense::Config::new().dfa_size_limit(Some(6_000_000)))///     .build(r"\w{20}")///     .unwrap_err();/// // ... but 7MB probably is!/// // (Note that DFA sizes aren't necessarily stable between releases.)///     .configure(dense::Config::new().dfa_size_limit(Some(7_000_000)))///     .build(r"\w{20}")?;/// let haystack = "A".repeat(20).into_bytes();/// assert!(dfa.try_search_fwd(&Input::new(&haystack))?.is_some());/// While one needs a little more than 6MB to represent `\w{20}`, it/// turns out that you only need a little more than 6KB to represent/// `(?-u:\w{20})`. So only use Unicode if you need it!/// As with [`Config::determinize_size_limit`], the size of a DFA is/// influenced by other factors, such as what start state configurations/// to support. For example, if you only need unanchored searches and not/// anchored searches, then configuring the DFA to only support unanchored/// searches can reduce its size. By default, DFAs support both unanchored/// and anchored searches./// use regex_automata::{dfa::{dense, Automaton, StartKind}, Input};/// // 3MB isn't enough!///         .dfa_size_limit(Some(3_000_000))///         .start_kind(StartKind::Unanchored)/// // ... but 4MB probably is!///         .dfa_size_limit(Some(4_000_000))/// Set a size limit on the total heap used by determinization./// determinization of an NFA into a DFA. If the heap used for auxiliary/// storage during determinization (memory that is not in the DFA but/// necessary for building the DFA) exceeds this configured limit, then/// determinization is stopped and an error is returned./// This limit does not apply to heap used by the DFA itself./// This example shows a DFA that fails to build because of a/// configured size limit on the amount of heap space used by/// determinization. This particular example complements the example for/// [`Config::dfa_size_limit`] by demonstrating that not only does Unicode/// potentially make DFAs themselves big, but it also results in more/// auxiliary storage during determinization. (Although, auxiliary storage/// is still not as much as the DFA itself.)/// # if !cfg!(target_pointer_width = "64") { return Ok(()); } // see #1039/// // 700KB isn't enough!///         .determinize_size_limit(Some(700_000))/// // ... but 800KB probably is!/// // (Note that auxiliary storage sizes aren't necessarily stable between/// // releases.)///         .determinize_size_limit(Some(800_000))/// Note that some parts of the configuration on a DFA can have a/// big impact on how big the DFA is, and thus, how much memory is/// used. For example, the default setting for [`Config::start_kind`] is/// [`StartKind::Both`]. But if you only need an anchored search, for/// example, then it can be much cheaper to build a DFA that only supports/// anchored searches. (Running an unanchored search with it would panic.)///     Anchored, Input,/// // 200KB isn't enough!///         .determinize_size_limit(Some(200_000))/// // ... but 300KB probably is!///         .determinize_size_limit(Some(300_000))/// let input = Input::new(&haystack).anchored(Anchored::Yes);/// assert!(dfa.try_search_fwd(&input)?.is_some());get_accelerate/// Returns whether this configuration has enabled simple state/// Returns the prefilter attached to this configuration, if any.get_minimize/// Returns whether this configuration has enabled the expensive process/// of minimizing a DFA.get_match_kind/// Returns the match semantics set in this configuration.get_starts/// Returns the starting state configuration for a DFA.get_starts_for_each_pattern/// Returns whether this configuration has enabled anchored starting states/// for every pattern in the DFA.get_byte_classes/// Returns whether this configuration has enabled byte classes or not./// This is typically a debugging oriented option, as disabling it confers/// no speed benefit.get_unicode_word_boundary/// Returns whether this configuration has enabled heuristic Unicode word/// boundary support. When enabled, it is possible for a search to returnget_quit/// Returns whether this configuration will instruct the DFA to enter a/// quit state whenever the given byte is seen during a search. When at/// least one byte has this enabled, it is possible for a search to returnget_specialize_start_states/// Returns whether this configuration will instruct the DFA to/// "specialize" start states. When enabled, the DFA will mark start states/// as "special" so that search routines using the DFA can detect when/// it's in a start state and do some kind of optimization (like run a/// prefilter).get_dfa_size_limit/// Returns the DFA size limit of this configuration if one was set./// The size limit is total number of bytes on the heap that a DFA is/// permitted to use. If the DFA exceeds this limit during construction,/// then construction is stopped and an error is returned.get_determinize_size_limit/// Returns the determinization size limit of this configuration if one/// was set. The size limit is total number of bytes on the heap that/// determinization is permitted to use. If determinization exceeds this/// limit during construction, then construction is stopped and an error is/// This is different from the DFA size limit in that this only applies to/// the auxiliary storage used during determinization. Once determinization/// is complete, this memory is freed./// The limit on the total heap memory used is the sum of the DFA and/// determinization size limits./// Overwrite the default configuration such that the options in `o` are/// always used. If an option in `o` is not set, then the corresponding/// option in `self` is used. If it's not set in `self` either, then it/// remains not set./// A builder for constructing a deterministic finite automaton from regular/// expressions./// This builder provides two main things:/// 1. It provides a few different `build` routines for actually constructing/// a DFA from different kinds of inputs. The most convenient is/// [`Builder::build`], which builds a DFA directly from a pattern string. The/// most flexible is [`Builder::build_from_nfa`], which builds a DFA straight/// from an NFA./// 2. The builder permits configuring a number of things./// [`Builder::configure`] is used with [`Config`] to configure aspects of/// the DFA and the construction process itself. [`Builder::syntax`] and/// [`Builder::thompson`] permit configuring the regex parser and Thompson NFA/// construction, respectively. The syntax and thompson configurations only/// apply when building from a pattern string./// This builder always constructs a *single* DFA. As such, this builder/// can only be used to construct regexes that either detect the presence/// of a match or find the end location of a match. A single DFA cannot/// produce both the start and end of a match. For that information, use a/// [`Regex`](crate::dfa::regex::Regex), which can be similarly configured/// using [`regex::Builder`](crate::dfa::regex::Builder). The main reason to/// use a DFA directly is if the end location of a match is enough for your use/// case. Namely, a `Regex` will construct two DFAs instead of one, since a/// second reverse DFA is needed to find the start of a match./// Note that if one wants to build a sparse DFA, you must first build a dense/// DFA and convert that to a sparse DFA. There is no way to build a sparse/// DFA without first building a dense DFA./// This example shows how to build a minimized DFA that completely disables/// Unicode. That is:/// * Things such as `\w`, `.` and `\b` are no longer Unicode-aware. `\w`///   and `\b` are ASCII-only while `.` matches any byte except for `\n`///   (instead of any UTF-8 encoding of a Unicode scalar value except for///   `\n`). Things that are Unicode only, such as `\pL`, are not allowed./// * The pattern itself is permitted to match invalid UTF-8. For example,///   things like `[^a]` that match any byte except for `a` are permitted.///     util::syntax,///     .configure(dense::Config::new().minimize(false))///     .build(r"foo[^b]ar.*")?;/// let haystack = b"\xFEfoo\xFFar\xE2\x98\xFF\n";/// let expected = Some(HalfMatch::must(0, 10));/// Create a new dense DFA builder with the default configuration.OwnedDFA/// Build a DFA from the given pattern./// If there was a problem parsing or compiling the pattern, then an errorbuild_many/// Build a DFA from the given patterns./// When matches are returned, the pattern ID corresponds to the index of/// the pattern in the slice given.build_from_nfa/// Build a DFA from the given NFA./// This example shows how to build a DFA if you already have an NFA in/// hand./// // This shows how to set non-default options for building an NFA./// let nfa = NFA::compiler()///     .configure(NFA::config().shrink(true))/// let dfa = dense::Builder::new().build_from_nfa(&nfa)?;/// Apply the given dense DFA configuration options to this builder./// Set the syntax configuration for this builder using/// [`syntax::Config`](crate::util::syntax::Config)./// This permits setting things like case insensitivity, Unicode and multi/// line mode./// These settings only apply when constructing a DFA directly from a/// Set the Thompson NFA configuration for this builder using/// [`nfa::thompson::Config`](crate::nfa::thompson::Config)./// This permits setting things like whether the DFA should match the regex/// in reverse or if additional time should be spent shrinking the size of/// the NFA./// A convenience alias for an owned DFA. We use this particular instantiation/// a lot in this crate, so it's worth giving it a name. This instantiation/// is commonly used for mutable APIs on the DFA while building it. The main/// reason for making DFAs generic is no_std support, and more generally,/// making it possible to load a DFA from an arbitrary slice of bytes.ttTransitionTable/// The transition table for this DFA. This includes the transitions/// themselves, along with the stride, number of states and the equivalence/// class mapping.StartTable/// The set of starting state identifiers for this DFA. The starting state/// IDs act as pointers into the transition table. The specific starting/// state chosen for each search is dependent on the context at which the/// search begins.msMatchStates/// The set of match states and the patterns that match for each/// corresponding match state./// This structure is technically only needed because of support for/// multi-regexes. Namely, multi-regexes require answering not just whether/// a match exists, but _which_ patterns match. So we need to store the/// matching pattern IDs for each match state. We do this even when there/// is only one pattern for the sake of simplicity. In practice, this uses/// up very little space for the case of one pattern./// Information about which states are "special." Special states are states/// that are dead, quit, matching, starting or accelerated. For more info,/// see the docs for `Special`./// The accelerators for this DFA./// If a state is accelerated, then there exist only a small number of/// bytes that can cause the DFA to leave the state. This permits searching/// to use optimized routines to find those specific bytes instead of using/// the transition table./// All accelerated states exist in a contiguous range in the DFA's/// transition table. See dfa/special.rs for more details on how states are/// arranged./// Any prefilter attached to this DFA./// Note that currently prefilters are not serialized. When deserializing/// a DFA from bytes, this is always set to `None`./// The set of "quit" bytes for this DFA./// This is only used when computing the start state for a particular/// position in a haystack. Namely, in the case where there is a quit/// byte immediately before the start of the search, this set needs to be/// explicitly consulted. In all other cases, quit bytes are detected by/// the DFA itself, by transitioning all quit bytes to a special "quit/// state."/// Various flags describing the behavior of this DFA./// A dense table-based deterministic finite automaton (DFA)./// All dense DFAs have one or more start states, zero or more match states/// and a transition table that maps the current state and the current byte/// of input to the next state. A DFA can use this information to implement/// fast searching. In particular, the use of a dense DFA generally makes the/// trade off that match speed is the most valuable characteristic, even if/// building the DFA may take significant time *and* space. (More concretely,/// building a DFA takes time and space that is exponential in the size of the/// pattern in the worst case.) As such, the processing of every byte of input/// is done with a small constant number of operations that does not vary with/// the pattern, its size or the size of the alphabet. If your needs don't line/// up with this trade off, then a dense DFA may not be an adequate solution to/// your problem./// In contrast, a [`sparse::DFA`] makes the opposite/// trade off: it uses less space but will execute a variable number of/// instructions per byte at match time, which makes it slower for matching./// (Note that space usage is still exponential in the size of the pattern in/// the worst case.)/// A DFA can be built using the default configuration via the/// [`DFA::new`] constructor. Otherwise, one can/// configure various aspects via [`dense::Builder`](Builder)./// A single DFA fundamentally supports the following operations:/// 1. Detection of a match./// 2. Location of the end of a match./// 3. In the case of a DFA with multiple patterns, which pattern matched is///    reported as well./// A notable absence from the above list of capabilities is the location of/// the *start* of a match. In order to provide both the start and end of/// a match, *two* DFAs are required. This functionality is provided by a/// [`Regex`](crate::dfa::regex::Regex)./// A `DFA` has one type parameter, `T`, which is used to represent state IDs,/// pattern IDs and accelerators. `T` is typically a `Vec<u32>` or a `&[u32]`./// # The `Automaton` trait/// This type implements the [`Automaton`] trait, which means it can be used/// for searching. For example:/// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};/// let dfa = DFA::new("foo[0-9]+")?;/// let expected = HalfMatch::must(0, 8);/// assert_eq!(Some(expected), dfa.try_search_fwd(&Input::new("foo12345"))?);/// Parse the given regular expression using a default configuration and/// return the corresponding DFA./// If you want a non-default configuration, then use the/// [`dense::Builder`](Builder) to set your own configuration./// let dfa = dense::DFA::new("foo[0-9]+bar")?;/// let expected = Some(HalfMatch::must(0, 11));/// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345bar"))?);new_many/// Parse the given regular expressions using a default configuration and/// return the corresponding multi-DFA./// let dfa = dense::DFA::new_many(&["[0-9]+", "[a-z]+"])?;/// let expected = Some(HalfMatch::must(1, 3));always_match/// Create a new DFA that matches every input./// let dfa = dense::DFA::always_match()?;/// assert_eq!(expected, dfa.try_search_fwd(&Input::new(""))?);/// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo"))?);never_match/// Create a new DFA that never matches any input./// let dfa = dense::DFA::never_match()?;/// assert_eq!(None, dfa.try_search_fwd(&Input::new(""))?);/// assert_eq!(None, dfa.try_search_fwd(&Input::new("foo"))?);/// Create an initial DFA with the given equivalence classes, pattern/// length and whether anchored starting states are enabled for each/// pattern. An initial DFA can be further mutated via determinization./// This is a convenience routine to avoid needing to import the [`Config`]/// type when customizing the construction of a dense DFA./// This is a convenience routine to avoid needing to import the/// [`Builder`] type in common cases./// Cheaply return a borrowed version of this dense DFA. Specifically,/// the DFA returned always uses `&[u32]` for its transition table./// Return an owned version of this sparse DFA. Specifically, the DFA/// returned always uses `Vec<u32>` for its transition table./// Effectively, this returns a dense DFA whose transition table lives on/// the heap./// Returns the starting state configuration for this DFA./// The default is [`StartKind::Both`], which means the DFA supports both/// unanchored and anchored searches. However, this can generally lead to/// bigger DFAs. Therefore, a DFA might be compiled with support for just/// unanchored or anchored searches. In that case, running a search with/// an unsupported configuration will panic.start_map/// Returns the start byte map used for computing the `Start` configuration/// at the beginning of a search./// Returns true only if this DFA has starting states for each pattern./// When a DFA has starting states for each pattern, then a search with the/// DFA can be configured to only look for anchored matches of a specific/// pattern. Specifically, APIs like [`Automaton::try_search_fwd`] can/// accept a non-None `pattern_id` if and only if this method returns true./// Otherwise, calling `try_search_fwd` will panic./// Note that if the DFA has no patterns, this always returns false./// Returns the equivalence classes that make up the alphabet for this DFA./// Unless [`Config::byte_classes`] was disabled, it is possible that/// multiple distinct bytes are grouped into the same equivalence class/// if it is impossible for them to discriminate between a match and a/// non-match. This has the effect of reducing the overall alphabet size/// and in turn potentially substantially reducing the size of the DFA's/// The downside of using equivalence classes like this is that every state/// transition will automatically use this map to convert an arbitrary/// byte to its corresponding equivalence class. In practice this has a/// negligible impact on performance./// Returns the total number of elements in the alphabet for this DFA./// That is, this returns the total number of transitions that each state/// in this DFA must have. Typically, a normal byte oriented DFA would/// always have an alphabet size of 256, corresponding to the number of/// unique values in a single byte. However, this implementation has two/// peculiarities that impact the alphabet length:/// * Every state has a special "EOI" transition that is only followed/// after the end of some haystack is reached. This EOI transition is/// necessary to account for one byte of look-ahead when implementing/// things like `\b` and `$`./// * Bytes are grouped into equivalence classes such that no two bytes in/// the same class can distinguish a match from a non-match. For example,/// in the regex `^[a-z]+$`, the ASCII bytes `a-z` could all be in the/// same equivalence class. This leads to a massive space savings./// Note though that the alphabet length does _not_ necessarily equal the/// total stride space taken up by a single DFA state in the transition/// table. Namely, for performance reasons, the stride is always the/// smallest power of two that is greater than or equal to the alphabet/// length. For this reason, [`DFA::stride`] or [`DFA::stride2`] are/// often more useful. The alphabet length is typically useful only for/// informational purposes./// Returns the total stride for every state in this DFA, expressed as the/// exponent of a power of 2. The stride is the amount of space each state/// takes up in the transition table, expressed as a number of transitions./// (Unused transitions map to dead states.)/// The stride of a DFA is always equivalent to the smallest power of 2/// that is greater than or equal to the DFA's alphabet length. This/// definition uses extra space, but permits faster translation between/// premultiplied state identifiers and contiguous indices (by using shifts/// instead of relying on integer division)./// For example, if the DFA's stride is 16 transitions, then its `stride2`/// is `4` since `2^4 = 16`./// The minimum `stride2` value is `1` (corresponding to a stride of `2`)/// while the maximum `stride2` value is `9` (corresponding to a stride of/// `512`). The maximum is not `8` since the maximum alphabet size is `257`/// when accounting for the special EOI transition. However, an alphabet/// length of that size is exceptionally rare since the alphabet is shrunk/// into equivalence classes./// Returns the total stride for every state in this DFA. This corresponds/// to the total number of transitions used by each state in this DFA's/// Please see [`DFA::stride2`] for more information. In particular, this/// returns the stride as the number of transitions, where as `stride2`/// returns it as the exponent of a power of 2./// Returns the memory usage, in bytes, of this DFA./// represent this DFA./// This does **not** include the stack size used up by this DFA. To/// compute that, use `std::mem::size_of::<dense::DFA>()`.to_sparse/// Convert this dense DFA to a sparse DFA./// If a `StateID` is too small to represent all states in the sparse/// DFA, then this returns an error. In most cases, if a dense DFA is/// constructable with `StateID` then a sparse DFA will be as well./// However, it is not guaranteed./// let dense = dense::DFA::new("foo[0-9]+")?;/// let sparse = dense.to_sparse()?;/// assert_eq!(expected, sparse.try_search_fwd(&Input::new("foo12345"))?);to_bytes_little_endian/// Serialize this DFA as raw bytes to a `Vec<u8>` in little endian/// format. Upon success, the `Vec<u8>` and the initial padding length are/// The written bytes are guaranteed to be deserialized correctly and/// without errors in a semver compatible release of this crate by a/// `DFA`'s deserialization APIs (assuming all other criteria for the/// deserialization APIs has been satisfied):/// * [`DFA::from_bytes`]/// * [`DFA::from_bytes_unchecked`]/// The padding returned is non-zero if the returned `Vec<u8>` starts at/// an address that does not have the same alignment as `u32`. The padding/// corresponds to the number of leading bytes written to the returned/// `Vec<u8>`./// This example shows how to serialize and deserialize a DFA:/// // Compile our original DFA./// let original_dfa = DFA::new("foo[0-9]+")?;/// // N.B. We use native endianness here to make the example work, but/// // using to_bytes_little_endian would work on a little endian target./// let (buf, _) = original_dfa.to_bytes_native_endian();/// // Even if buf has initial padding, DFA::from_bytes will automatically/// // ignore it./// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf)?.0;/// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);to_bytes_big_endian/// Serialize this DFA as raw bytes to a `Vec<u8>` in big endian/// // using to_bytes_big_endian would work on a big endian target.to_bytes_native_endian/// Serialize this DFA as raw bytes to a `Vec<u8>` in native endian/// Generally speaking, native endian format should only be used when/// you know that the target you're compiling the DFA for matches the/// endianness of the target on which you're compiling DFA. For example,/// if serialization and deserialization happen in the same process or on/// the same machine. Otherwise, when serializing a DFA for use in a/// portable environment, you'll almost certainly want to serialize _both_/// a little endian and a big endian version and then load the correct one/// based on the target's configuration./// The implementation of the public `to_bytes` serialization methods,/// which is generic over endianness.write_to_little_endian/// Serialize this DFA as raw bytes to the given slice, in little endian/// format. Upon success, the total number of bytes written to `dst` is/// Note that unlike the various `to_byte_*` routines, this does not write/// any padding. Callers are responsible for handling alignment correctly./// This returns an error if the given destination slice is not big enough/// to contain the full serialized DFA. If an error occurs, then nothing/// is written to `dst`./// This example shows how to serialize and deserialize a DFA without/// dynamic memory allocation./// // Create a 4KB buffer on the stack to store our serialized DFA. We/// // need to use a special type to force the alignment of our [u8; N]/// // array to be aligned to a 4 byte boundary. Otherwise, deserializing/// // the DFA may fail because of an alignment mismatch./// struct Aligned<B: ?Sized> {///     _align: [u32; 0],///     bytes: B,/// let mut buf = Aligned { _align: [], bytes: [0u8; 4 * (1<<10)] };/// // using write_to_little_endian would work on a little endian target./// let written = original_dfa.write_to_native_endian(&mut buf.bytes)?;/// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf.bytes[..written])?.0;write_to_big_endian/// Serialize this DFA as raw bytes to the given slice, in big endian/// // using write_to_big_endian would work on a big endian target.write_to_native_endian/// Serialize this DFA as raw bytes to the given slice, in native endian/// Return the total number of bytes required to serialize this DFA./// This is useful for determining the size of the buffer required to pass/// to one of the serialization routines:/// * [`DFA::write_to_little_endian`]/// * [`DFA::write_to_big_endian`]/// * [`DFA::write_to_native_endian`]/// Passing a buffer smaller than the size returned by this method will/// result in a serialization error. Serialization routines are guaranteed/// to succeed when the buffer is big enough./// This example shows how to dynamically allocate enough room to serialize/// a DFA./// let mut buf = vec![0; original_dfa.write_to_len()];/// // This is guaranteed to succeed, because the only serialization error/// // that can occur is when the provided buffer is too small. But/// // write_to_len guarantees a correct size./// let written = original_dfa.write_to_native_endian(&mut buf).unwrap();/// // But this is not guaranteed to succeed! In particular,/// // deserialization requires proper alignment for &[u32], but our buffer/// // was allocated as a &[u8] whose required alignment is smaller than/// // &[u32]. However, it's likely to work in practice because of how most/// // allocators work. So if you write code like this, make sure to either/// // handle the error correctly and/or run it under Miri since Miri will/// // likely provoke the error by returning Vec<u8> buffers with alignment/// // less than &[u32]./// let dfa: DFA<&[u32]> = match DFA::from_bytes(&buf[..written]) {///     // As mentioned above, it is legal for an error to be returned///     // here. It is quite difficult to get a Vec<u8> with a guaranteed///     // alignment equivalent to Vec<u32>.///     Err(_) => return Ok(()),///     Ok((dfa, _)) => dfa,/// Note that this example isn't actually guaranteed to work! In/// particular, if `buf` is not aligned to a 4-byte boundary, then the/// `DFA::from_bytes` call will fail. If you need this to work, then you/// either need to deal with adding some initial padding yourself, or use/// one of the `to_bytes` methods, which will do it for you./// Routines for converting a dense DFA to other representations, such as/// sparse DFAs or raw bytes suitable for persistent storage./// Safely deserialize a DFA with a specific state identifier/// representation. Upon success, this returns both the deserialized DFA/// and the number of bytes read from the given slice. Namely, the contents/// of the slice beyond the DFA are not read./// Deserializing a DFA using this routine will never allocate heap memory./// For safety purposes, the DFA's transition table will be verified such/// that every transition points to a valid state. If this verification is/// too costly, then a [`DFA::from_bytes_unchecked`] API is provided, which/// will always execute in constant time./// The bytes given must be generated by one of the serialization APIs/// of a `DFA` using a semver compatible release of this crate. Those/// include:/// * [`DFA::to_bytes_little_endian`]/// * [`DFA::to_bytes_big_endian`]/// * [`DFA::to_bytes_native_endian`]/// The `to_bytes` methods allocate and return a `Vec<u8>` for you, along/// with handling alignment correctly. The `write_to` methods do not/// allocate and write to an existing slice (which may be on the stack)./// Since deserialization always uses the native endianness of the target/// platform, the serialization API you use should match the endianness of/// the target platform. (It's often a good idea to generate serialized/// DFAs for both forms of endianness and then load the correct one based/// on endianness.)/// Generally speaking, it's easier to state the conditions in which an/// error is _not_ returned. All of the following must be true:/// * The bytes given must be produced by one of the serialization APIs///   on this DFA, as mentioned above./// * The endianness of the target platform matches the endianness used to///   serialized the provided DFA./// * The slice given must have the same alignment as `u32`./// If any of the above are not true, then an error will be returned./// This routine will never panic for any input./// This example shows how to serialize a DFA to raw bytes, deserialize it/// and then use it for searching./// let initial = DFA::new("foo[0-9]+")?;/// let (bytes, _) = initial.to_bytes_native_endian();/// let dfa: DFA<&[u32]> = DFA::from_bytes(&bytes)?.0;/// # Example: dealing with alignment and padding/// In the above example, we used the `to_bytes_native_endian` method to/// serialize a DFA, but we ignored part of its return value corresponding/// to padding added to the beginning of the serialized DFA. This is OK/// because deserialization will skip this initial padding. What matters/// is that the address immediately following the padding has an alignment/// that matches `u32`. That is, the following is an equivalent but/// alternative way to write the above example:/// // Serialization returns the number of leading padding bytes added to/// // the returned Vec<u8>./// let (bytes, pad) = initial.to_bytes_native_endian();/// let dfa: DFA<&[u32]> = DFA::from_bytes(&bytes[pad..])?.0;/// This padding is necessary because Rust's standard library does/// not expose any safe and robust way of creating a `Vec<u8>` with a/// guaranteed alignment other than 1. Now, in practice, the underlying/// allocator is likely to provide a `Vec<u8>` that meets our alignment/// requirements, which means `pad` is zero in practice most of the time./// The purpose of exposing the padding like this is flexibility for the/// caller. For example, if one wants to embed a serialized DFA into a/// compiled program, then it's important to guarantee that it starts at a/// `u32`-aligned address. The simplest way to do this is to discard the/// padding bytes and set it up so that the serialized DFA itself begins at/// a properly aligned address. We can show this in two parts. The first/// part is serializing the DFA to a file:/// use regex_automata::dfa::dense::DFA;/// let (bytes, pad) = dfa.to_bytes_big_endian();/// // Write the contents of the DFA *without* the initial padding./// std::fs::write("foo.bigendian.dfa", &bytes[pad..])?;/// // Do it again, but this time for little endian./// let (bytes, pad) = dfa.to_bytes_little_endian();/// std::fs::write("foo.littleendian.dfa", &bytes[pad..])?;/// And now the second part is embedding the DFA into the compiled program/// and deserializing it at runtime on first use. We use conditional/// compilation to choose the correct endianness.///     util::{lazy::Lazy, wire::AlignAs},/// // This crate provides its own "lazy" type, kind of like/// // lazy_static! or once_cell::sync::Lazy. But it works in no-alloc/// // no-std environments and let's us write this using completely/// // safe code./// static RE: Lazy<DFA<&'static [u32]>> = Lazy::new(|| {///     # const _: &str = stringify! {///     // This assignment is made possible (implicitly) via the///     // CoerceUnsized trait. This is what guarantees that our///     // bytes are stored in memory on a 4 byte boundary. You///     // *must* do this or something equivalent for correct///     // deserialization.///     static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {///         _align: [],///         #[cfg(target_endian = "big")]///         bytes: *include_bytes!("foo.bigendian.dfa"),///         #[cfg(target_endian = "little")]///         bytes: *include_bytes!("foo.littleendian.dfa"),///     # static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {///     #     _align: [],///     #     bytes: [],///     let (dfa, _) = DFA::from_bytes(&ALIGNED.bytes)///         .expect("serialized DFA should be valid");///     dfa/// let expected = Ok(Some(HalfMatch::must(0, 8)));/// assert_eq!(expected, RE.try_search_fwd(&Input::new("foo12345")));/// An alternative to [`util::lazy::Lazy`](crate::util::lazy::Lazy)/// is [`lazy_static`](https://crates.io/crates/lazy_static) or/// [`once_cell`](https://crates.io/crates/once_cell), which provide/// stronger guarantees (like the initialization function only being/// executed once). And `once_cell` in particular provides a more/// expressive API. But a `Lazy` value from this crate is likely just fine/// in most circumstances./// Note that regardless of which initialization method you use, you/// will still need to use the [`AlignAs`](crate::util::wire::AlignAs)/// trick above to force correct alignment, but this is safe to do and/// `from_bytes` will return an error if you get it wrong./// Deserialize a DFA with a specific state identifier representation in/// constant time by omitting the verification of the validity of the/// transition table and other data inside the DFA./// This is just like [`DFA::from_bytes`], except it can potentially return/// a DFA that exhibits undefined behavior if its transition table contains/// invalid state identifiers./// This routine is useful if you need to deserialize a DFA cheaply/// and cannot afford the transition table validation performed by/// `from_bytes`./// // SAFETY: This is guaranteed to be safe since the bytes given come/// // directly from a compatible serialization routine./// let dfa: DFA<&[u32]> = unsafe { DFA::from_bytes_unchecked(&bytes)?.0 };/// The implementation of the public `write_to` serialization methods,/// This is defined only for &[u32] to reduce binary size/compilation time.set_start_state/// Add a start state of this DFA.set_transition/// Set the given transition to this DFA. Both the `from` and `to` states/// must already exist.add_empty_state/// An empty state (a state where all transitions lead to a dead state)/// and return its identifier. The identifier returned is guaranteed to/// not point to any other existing state./// If adding a state would exceed `StateID::LIMIT`, then this returns an/// Swap the two states given in the transition table./// This routine does not do anything to check the correctness of this/// swap. Callers must ensure that other states pointing to id1 and id2 are/// updated appropriately./// Remap all of the state identifiers in this DFA according to the map/// function given. This includes all transitions and all starting stateremap_state/// Remap the transitions for the state given according to the function/// given. This applies the given map function to every transition in the/// given state and changes the transition in place to the result of the/// map function for that transition.truncate_states/// Truncate the states in this DFA to the given length./// truncation. Callers must ensure that other states pointing to truncated/// states are updated appropriately./// Minimize this DFA in place using Hopcroft's algorithm.set_pattern_map/// Updates the match state pattern ID map to use the one provided./// This is useful when it's convenient to manipulate matching states/// (and their corresponding pattern IDs) as a map. In particular, the/// representation used by a DFA for this map is not amenable to mutation,/// so if things need to be changed (like when shuffling states), it's/// often easier to work with the map form./// Find states that have a small number of non-loop transitions and mark/// them as candidates for acceleration during search./// Shuffle the states in this DFA so that starting states, match/// states and accelerated states are all contiguous./// See dfa/special.rs for more details.set_universal_starts/// Checks whether there are universal start states (both anchored and/// unanchored), and if so, sets the relevant fields to the start state/// IDs./// Universal start states occur precisely when the all patterns in the/// DFA have no look-around assertions in their prefix.// The following methods implement mutable routines on the internal// representation of a DFA. As such, we must fix the first type parameter to a// `Vec<u32>` since a generic `T: AsRef<[u32]>` does not permit mutation. We// can get away with this because these methods are internal to the crate and// are exclusively used during construction of the DFA./// Return the info about special states.special_mut/// Return the info about special states as a mutable borrow./// Returns the quit set (may be empty) used by this DFA./// Returns the flags for this DFA.StateIter/// Returns an iterator over all states in this DFA./// This iterator yields a tuple for each state. The first element of the/// tuple corresponds to a state's identifier, and the second element/// corresponds to the state itself (comprised of its transitions)./// Return the total number of states in this DFA. Every DFA has at least/// 1 state, even the empty DFA.pattern_id_slice/// Return an iterator over all pattern IDs for the given match state./// If the given state is not a match state, then this panics.match_pattern_len/// Return the total number of pattern IDs for the given match state./// Returns the total number of patterns matched by this DFA.pattern_map/// Returns a map from match state ID to a list of pattern IDs that match/// in that state.quit_id/// Returns the ID of the quit state for this DFA./// Convert the given state identifier to the state's index. The state's/// index corresponds to the position in which it appears in the transition/// table. When a DFA is NOT premultiplied, then a state's identifier is/// also its index. When a DFA is premultiplied, then a state's identifier/// is equal to `index * alphabet_len`. This routine reverses that./// Convert an index to a state (in the range 0..self.state_len()) to an/// actual state identifier./// This is useful when using a `Vec<T>` as an efficient map keyed by state/// to some other information (such as a remapped state ID).startsStartStateIter/// Return the table of state IDs for this DFA's start states.match_state_index/// Returns the index of the match state for the given ID. If the/// given ID does not correspond to a match state, then this may/// panic or produce an incorrect result.accelerator_index/// Returns the index of the accelerator state for the given ID. If the/// given ID does not correspond to an accelerator state, then this may/// Return the accelerators for this DFA./// Return this DFA's transition table as a slice.// A variety of generic internal methods for accessing DFA internals.// SAFETY: We assert that our implementation of each method is correct./// A contiguous region of memory representing the transition table in/// row-major order. The representation is dense. That is, every state/// has precisely the same number of transitions. The maximum number of/// transitions per state is 257 (256 for each possible byte value, plus 1/// for the special EOI transition). If a DFA has been instructed to use/// byte classes (the default), then the number of transitions is usually/// substantially fewer./// In practice, T is either `Vec<u32>` or `&[u32]`./// A set of equivalence classes, where a single equivalence class/// represents a set of bytes that never discriminate between a match/// and a non-match in the DFA. Each equivalence class corresponds to a/// single character in this DFA's alphabet, where the maximum number of/// characters is 257 (each possible value of a byte plus the special/// EOI transition). Consequently, the number of equivalence classes/// corresponds to the number of transitions for each DFA state. Note/// though that the *space* used by each DFA state in the transition table/// may be larger. The total space used by each DFA state is known as the/// stride./// The only time the number of equivalence classes is fewer than 257 is if/// the DFA's kind uses byte classes (which is the default). Equivalence/// classes should generally only be disabled when debugging, so that/// the transitions themselves aren't obscured. Disabling them has no/// other benefit, since the equivalence class map is always used while/// searching. In the vast majority of cases, the number of equivalence/// classes is substantially smaller than 257, particularly when large/// Unicode classes aren't used./// The stride of each DFA state, expressed as a power-of-two exponent./// The stride of a DFA corresponds to the total amount of space used by/// each DFA state in the transition table. This may be bigger than the/// size of a DFA's alphabet, since the stride is always the smallest/// power of two greater than or equal to the alphabet size./// While this wastes space, this avoids the need for integer division/// to convert between premultiplied state IDs and their corresponding/// indices. Instead, we can use simple bit-shifts./// See the docs for the `stride2` method for more details./// The transition table portion of a dense DFA./// The transition table is the core part of the DFA in that it describes how/// to move from one state to another based on the input sequence observed./// Deserialize a transition table starting at the beginning of `slice`./// Upon success, return the total number of bytes read along with the/// If there was a problem deserializing any part of the transition table,/// then this returns an error. Notably, if the given slice does not have/// the same alignment as `StateID`, then this will return an error (among/// other possible errors)./// This is guaranteed to execute in constant time./// This routine is not safe because it does not check the validity of the/// transition table itself. In particular, the transition table can be/// quite large, so checking its validity can be somewhat expensive. An/// invalid transition table is not safe because other code may rely on the/// transition table being correct (such as explicit bounds check elision)./// Therefore, an invalid transition table can lead to undefined behavior./// Callers that use this function must either pass on the safety invariant/// or guarantee that the bytes given contain a valid transition table./// This guarantee is upheld by the bytes written by `write_to`./// Create a minimal transition table with just two states: a dead state/// and a quit state. The alphabet length and stride of the transition/// table is determined by the given set of equivalence classes./// Set a transition in this table. Both the `from` and `to` states must/// already exist, otherwise this panics. `unit` should correspond to the/// transition out of `from` to set to `to`./// Add an empty state (a state where all transitions lead to a dead state)/// If adding a state would exhaust the state identifier space, then this/// returns an error./// Swap the two states given in this transition table./// Both id1 and id2 must point to valid states, otherwise this panics./// Truncate the states in this transition table to the given length./// Writes a serialized form of this transition table to the buffer given./// If the buffer is too small, then an error is returned. To determine/// how big the buffer must be, use `write_to_len`./// Returns the number of bytes the serialized form of this transition/// table will use./// Validates that every state ID in this transition table is valid./// That is, every state ID can be used to correctly index a state in this/// Converts this transition table to a borrowed value./// Converts this transition table to an owned value./// Return the state for the given ID. If the given ID is not valid, then/// this panics./// Returns an iterator over all states in this transition table./// Convert a state identifier to an index to a state (in the range/// 0..self.len())./// If the given ID is not valid, then this may panic or produce an/// incorrect index./// Convert an index to a state (in the range 0..self.len()) to an actual/// state identifier./// If the given index is not in the specified range, then this may panic/// or produce an incorrect state ID.next_state_id/// Returns the state ID for the state immediately following the one given./// This does not check whether the state ID returned is invalid. In fact,/// if the state ID given is the last state in this DFA, then the state ID/// returned is guaranteed to be invalid.prev_state_id/// Returns the state ID for the state immediately preceding the one given./// If the dead ID given (which is zero), then this panics./// Returns the table as a slice of state IDs./// Returns the total number of states in this transition table./// Note that a DFA always has at least two states: the dead and quit/// states. In particular, the dead state always has ID 0 and is/// correspondingly always the first state. The dead state is never a match/// Returns the total number of elements in the alphabet for this/// transition table. This is always less than or equal to `self.stride()`./// It is only equal when the alphabet length is a power of 2. Otherwise,/// it is always strictly less./// Returns true if and only if the given state ID is valid for this/// transition table. Validity in this context means that the given ID can/// be used as a valid offset with `self.stride()` to index this transition/// Return the memory usage, in bytes, of this transition table./// This does not include the size of a `TransitionTable` value itself.table_mut/// The initial start state IDs./// The first `2 * stride` (currently always 8) entries always correspond/// to the starts states for the entire DFA, with the first 4 entries being/// for unanchored searches and the second 4 entries being for anchored/// searches. To keep things simple, we always use 8 entries even if the/// `StartKind` is not both./// After that, there are `stride * patterns` state IDs, where `patterns`/// may be zero in the case of a DFA with no patterns or in the case where/// the DFA was built without enabling starting states for each pattern./// The starting state configuration supported. When 'both', both/// unanchored and anchored searches work. When 'unanchored', anchored/// searches panic. When 'anchored', unanchored searches panic./// The start state configuration for every possible byte./// The number of starting state IDs per pattern./// The total number of patterns for which starting states are encoded./// This is `None` for DFAs that were built without start states for each/// pattern. Thus, one cannot use this field to say how many patterns/// are in the DFA in all cases. It is specific to how many patterns are/// represented in this start table.universal_start_unanchored/// The universal starting state for unanchored searches. This is only/// present when the DFA supports unanchored searches and when all starting/// state IDs for an unanchored search are equivalent.universal_start_anchored/// The universal starting state for anchored searches. This is only/// present when the DFA supports anchored searches and when all starting/// state IDs for an anchored search are equivalent./// The set of all possible starting states in a DFA./// The set of starting states corresponds to the possible choices one can make/// in terms of starting a DFA. That is, before following the first transition,/// you first need to select the state that you start in./// Normally, a DFA converted from an NFA that has a single starting state/// would itself just have one starting state. However, our support for look/// around generally requires more starting states. The correct starting state/// is chosen based on certain properties of the position at which we begin/// our search./// Before listing those properties, we first must define two terms:/// * `haystack` - The bytes to execute the search. The search always starts///   at the beginning of `haystack` and ends before or at the end of///   `haystack`./// * `context` - The (possibly empty) bytes surrounding `haystack`. `haystack`///   must be contained within `context` such that `context` is at least as big///   as `haystack`./// This split is crucial for dealing with look-around. For example, consider/// the context `foobarbaz`, the haystack `bar` and the regex `^bar$`. This/// regex should _not_ match the haystack since `bar` does not appear at the/// beginning of the input. Similarly, the regex `\Bbar\B` should match the/// haystack because `bar` is not surrounded by word boundaries. But a search/// that does not take context into account would not permit `\B` to match/// since the beginning of any string matches a word boundary. Similarly, a/// search that does not take context into account when searching `^bar$` in/// the haystack `bar` would produce a match when it shouldn't./// Thus, it follows that the starting state is chosen based on the following/// criteria, derived from the position at which the search starts in the/// `context` (corresponding to the start of `haystack`):/// 1. If the search starts at the beginning of `context`, then the `Text`///    start state is used. (Since `^` corresponds to///    `hir::Anchor::Start`.)/// 2. If the search starts at a position immediately following a line///    terminator, then the `Line` start state is used. (Since `(?m:^)`///    corresponds to `hir::Anchor::StartLF`.)/// 3. If the search starts at a position immediately following a byte///    classified as a "word" character (`[_0-9a-zA-Z]`), then the `WordByte`///    start state is used. (Since `(?-u:\b)` corresponds to a word boundary.)/// 4. Otherwise, if the search starts at a position immediately following///    a byte that is not classified as a "word" character (`[^_0-9a-zA-Z]`),///    then the `NonWordByte` start state is used. (Since `(?-u:\B)`///    corresponds to a not-word-boundary.)/// (N.B. Unicode word boundaries are not supported by the DFA because they/// require multi-byte look-around and this is difficult to support in a DFA.)/// To further complicate things, we also support constructing individual/// anchored start states for each pattern in the DFA. (Which is required to/// implement overlapping regexes correctly, but is also generally useful.)/// Thus, when individual start states for each pattern are enabled, then the/// total number of start states represented is `4 + (4 * #patterns)`, where/// the 4 comes from each of the 4 possibilities above. The first 4 represents/// the starting states for the entire DFA, which support searching for/// multiple patterns simultaneously (possibly unanchored)./// If individual start states are disabled, then this will only store 4/// start states. Typically, individual start states are only enabled when/// constructing the reverse DFA for regex matching. But they are also useful/// for building DFAs that can search for a specific pattern or even to support/// both anchored and unanchored searches with the same DFA./// Note though that while the start table always has either `4` or/// `4 + (4 * #patterns)` starting state *ids*, the total number of states/// might be considerably smaller. That is, many of the IDs may be duplicative./// (For example, if a regex doesn't have a `\b` sub-pattern, then there's no/// reason to generate a unique starting state for handling word boundaries./// Similarly for start/end anchors.)dead/// Create a valid set of start states all pointing to the dead state./// When the corresponding DFA is constructed with start states for each/// pattern, then `patterns` should be the number of patterns. Otherwise,/// it should be zero./// If the total table size could exceed the allocatable limit, then this/// returns an error. In practice, this is unlikely to be able to occur,/// since it's likely that allocation would have failed long before it got/// to this point./// Deserialize a table of start state IDs starting at the beginning of/// `slice`. Upon success, return the total number of bytes read along with/// the table of starting state IDs./// If there was a problem deserializing any part of the starting IDs,/// starting state IDs themselves. In particular, the number of starting/// IDs can be of variable length, so it's possible that checking their/// validity cannot be done in constant time. An invalid starting state/// ID is not safe because other code may rely on the starting IDs being/// correct (such as explicit bounds check elision). Therefore, an invalid/// start ID can lead to undefined behavior./// or guarantee that the bytes given contain valid starting state IDs./// Writes a serialized form of this start table to the buffer given. If/// the buffer is too small, then an error is returned. To determine how/// big the buffer must be, use `write_to_len`./// Returns the number of bytes the serialized form of this start ID table/// will use./// Validates that every state ID in this start table is valid by checking/// it against the given transition table (which must be for the same DFA)./// That is, every state ID can be used to correctly index a state./// Converts this start list to a borrowed value./// Converts this start list to an owned value./// Return the start state for the given input and starting configuration./// This returns an error if the input configuration is not supported by/// this DFA. For example, requesting an unanchored search when the DFA was/// not built with unanchored starting states. Or asking for an anchored/// pattern search with an invalid pattern ID or on a DFA that was not/// built with start states for each pattern./// Returns an iterator over all start state IDs in this table./// Each item is a triple of: start state ID, the start state type and the/// pattern ID (if any)./// Return the memory usage, in bytes, of this start list./// This does not include the size of a `StartList` value itself./// Set the start state for the given index and pattern./// If the pattern ID or state ID are not valid, then this will panic./// Returns the table as a mutable slice of state IDs./// An iterator over start state IDs./// This iterator yields a triple of start state ID, the anchored mode and the/// start state type. If a pattern ID is relevant, then the anchored mode will/// contain it. Start states with an anchored mode containing a pattern ID will/// only occur when the DFA was compiled with start states for each pattern/// (which is disabled by default)./// Slices is a flattened sequence of pairs, where each pair points to a/// sub-slice of pattern_ids. The first element of the pair is an offset/// into pattern_ids and the second element of the pair is the number/// of 32-bit pattern IDs starting at that position. That is, each pair/// corresponds to a single DFA match state and its corresponding match/// IDs. The number of pairs always corresponds to the number of distinct/// DFA match states./// In practice, T is either Vec<u32> or &[u32].pattern_ids/// A flattened sequence of pattern IDs for each DFA match state. The only/// way to correctly read this sequence is indirectly via `slices`./// The total number of unique patterns represented by these match states./// This type represents that patterns that should be reported whenever a DFA/// enters a match state. This structure exists to support DFAs that search for/// matches for multiple regexes./// This structure relies on the fact that all match states in a DFA occur/// contiguously in the DFA's transition table. (See dfa/special.rs for a more/// detailed breakdown of the representation.) Namely, when a match occurs, we/// know its state ID. Since we know the start and end of the contiguous region/// of match states, we can use that to compute the position at which the match/// state occurs. That in turn is used as an offset into this structure.new_with_map/// Writes a serialized form of these match states to the buffer given. If/// Returns the number of bytes the serialized form of these match states/// Valides that the match state info is itself internally consistent and/// consistent with the recorded match state region in the given DFA.to_map/// Converts these match states back into their map form. This is useful/// when shuffling states, as the normal MatchStates representation is not/// amenable to easy state swapping. But with this map, to swap id1 and/// id2, all you need to do is:/// if let Some(pids) = map.remove(&id1) {///     map.insert(id2, pids);/// Once shuffling is done, use MatchStates::new to convert back./// Converts these match states to a borrowed value./// Converts these match states to an owned value.match_state_id/// Returns the match state ID given the match state index. (Where the/// first match state corresponds to index 0.)/// This panics if there is no match state at the given index.pattern_id/// Returns the pattern ID at the given match index for the given match/// The match state index is the state index minus the state index of the/// first match state in the DFA./// The match index is the index of the pattern ID for the given state./// The index must be less than `self.pattern_len(state_index)`./// Returns the number of patterns in the given match state./// Returns all of the pattern IDs for the given match state index./// Returns the pattern ID offset slice of u32 as a slice of PatternID./// Returns the total number of match states./// Returns the pattern ID slice of u32 as a slice of PatternID./// Return the memory usage, in bytes, of these match pairs./// Whether the DFA can match the empty string. When this is false, all/// matches returned by this DFA are guaranteed to have non-zero length./// Whether the DFA should only produce matches with spans that correspond/// to valid UTF-8. This also includes omitting any zero-width matches that/// split the UTF-8 encoding of a codepoint./// Whether the DFA is always anchored or not, regardless of `Input`/// configuration. This is useful for avoiding a reverse scan even when/// executing unanchored searches./// A common set of flags for both dense and sparse DFAs. This primarily/// centralizes the serialization format of these flags at a bitset.from_nfa/// Creates a set of flags for a DFA from an NFA./// N.B. This constructor was defined at the time of writing because all/// of the flags are derived directly from the NFA. If this changes in the/// future, we might be more thoughtful about how the `Flags` value is/// itself built./// Deserializes the flags from the given slice. On success, this also/// returns the number of bytes read from the slice./// Writes these flags to the given byte slice. If the buffer is too small,/// then an error is returned. To determine how big the buffer must be,/// use `write_to_len`./// Returns the number of bytes the serialized form of these flags/// An iterator over all states in a DFA./// `'a` corresponding to the lifetime of original DFA, `T` corresponds to/// the type of the transition table itself./// An immutable representation of a single DFA state./// `'a` correspondings to the lifetime of a DFA's transition table.StateTransitionIter/// Return an iterator over all transitions in this state. This yields/// a number of transitions equivalent to the alphabet length of the/// corresponding DFA./// Each transition is represented by a tuple. The first element is/// the input byte for that transition and the second element is the/// transitions itself.StateSparseTransitionIter/// Return an iterator over a sparse representation of the transitions in/// this state. Only non-dead transitions are returned./// The "sparse" representation in this case corresponds to a sequence of/// triples. The first two elements of the triple comprise an inclusive/// byte range while the last element corresponds to the transition taken/// for all bytes in the range./// This is somewhat more condensed than the classical sparse/// representation (where you have an element for every non-dead/// transition), but in practice, checking if a byte is in a range is very/// cheap and using ranges tends to conserve quite a bit more space./// Returns the identifier for this state./// Analyzes this state to determine whether it can be accelerated. If so,/// it returns an accelerator that contains at least one byte./// An iterator over all transitions in a single DFA state. This yields/// Each transition is represented by a tuple. The first element is the input/// byte for that transition and the second element is the transition itself./// An iterator over all non-DEAD transitions in a single DFA state using a/// sparse representation./// Each transition is represented by a triple. The first two elements of the/// triple comprise an inclusive byte range while the last element corresponds/// to the transition taken for all bytes in the range./// As a convenience, this always returns `alphabet::Unit` values of the same/// type. That is, you'll never get a (byte, EOI) or a (EOI, byte). Only (byte,/// byte) and (EOI, EOI) values are yielded.BuildErrorKind/// An error that occurred during the construction of a DFA./// This error does not provide many introspection capabilities. There are/// generally only two things you can do with it:/// * Obtain a human readable message via its `std::fmt::Display` impl./// * Access an underlying [`nfa::thompson::BuildError`](thompson::BuildError)/// type from its `source` method via the `std::error::Error` trait. This error/// only occurs when using convenience routines for building a DFA directly/// from a pattern string.is_size_limit_exceeded/// Returns true if and only if this error corresponds to an error with DFA/// construction that occurred because of exceeding a size limit./// While this can occur when size limits like [`Config::dfa_size_limit`]/// or [`Config::determinize_size_limit`] are exceeded, this can also occur/// when the number of states or patterns exceeds a hard-coded maximum./// (Where these maximums are derived based on the values representable by/// [`StateID`] and [`PatternID`].)/// This predicate is useful in contexts where you want to distinguish/// between errors related to something provided by an end user (for/// example, an invalid regex pattern) and errors related to configured/// heuristics. For example, building a DFA might be an optimization that/// you want to skip if construction fails because of an exceeded size/// limit, but where you want to bubble up an error if it fails for some/// other reason./// let err = dense::Builder::new()///         .determinize_size_limit(Some(100_000))/// // This error occurs because a size limit was exceeded./// // But things are otherwise valid./// assert!(err.is_size_limit_exceeded());///     .build(r"\bxyz\b")/// // This error occurs because a Unicode word boundary/// // was used without enabling heuristic support for it./// // So... not related to size limits./// assert!(!err.is_size_limit_exceeded());///     .build(r"(xyz")/// // This error occurs because the pattern is invalid./// An error that occurred while constructing an NFA as a precursor step/// before a DFA is compiled./// An error that occurred because an unsupported regex feature was used./// The message string describes which unsupported feature was used./// The primary regex feature that is unsupported by DFAs is the Unicode/// word boundary look-around assertion (`\b`). This can be worked around/// by either using an ASCII word boundary (`(?-u:\b)`) or by enabling/// Unicode word boundaries when building a DFA.TooManyStates/// An error that occurs if too many states are produced while building aTooManyStartStates/// An error that occurs if too many start states are needed while building/// This is a kind of oddball error that occurs when building a DFA with/// start states enabled for each pattern and enough patterns to cause/// the table of start states to overflow `usize`.TooManyMatchPatternIDs/// This is another oddball error that can occur if there are too many/// patterns spread out across too many match states.DFAExceededSizeLimit/// An error that occurs if the DFA got too big during determinization.DeterminizeExceededSizeLimit/// An error that occurs if auxiliary storage (not the DFA) used during/// determinization got too big./// The kind of error that occurred during the construction of a DFA./// Note that this error is non-exhaustive. Adding new variants is not/// considered a breaking change./// Return the kind of this error.unsupported_dfa_word_boundary_unicodetoo_many_statestoo_many_start_statestoo_many_match_pattern_idsdfa_exceeded_size_limitdeterminize_exceeded_size_limiterrors_with_unicode_word_boundaryroundtrip_never_matchroundtrip_always_matchheuristic_unicode_reverse// See the analogous test in src/hybrid/dfa.rs./*!
Types and routines specific to dense DFAs.

This module is the home of [`dense::DFA`](DFA).

This module also contains a [`dense::Builder`](Builder) and a
[`dense::Config`](Config) for building and configuring a dense DFA.
*/StateBuilderEmptyStateBuilderNFAsparse_setSparseSets/// A builder for configuring and running a DFA determinizer./// Create a new default config for a determinizer. The determinizer may be/// configured before calling `run`./// Run determinization on the given NFA and write the resulting DFA into/// the one given. The DFA given should be initialized but otherwise empty./// "Initialized" means that it is setup to handle the NFA's byte classes,/// number of patterns and whether to build start states for each pattern./// The match semantics to use for determinization./// MatchKind::All corresponds to the standard textbook construction./// All possible match states are represented in the DFA./// MatchKind::LeftmostFirst permits greediness and otherwise tries to/// simulate the match semantics of backtracking regex engines. Namely,/// only a subset of match states are built, and dead states are used to/// stop searches with an unanchored prefix./// The default is MatchKind::LeftmostFirst./// The set of bytes to use that will cause the DFA to enter a quit state,/// stop searching and return an error. By default, this is empty./// The limit, in bytes of the heap, that the DFA is permitted to use. This/// does not include the auxiliary heap storage used by determinization./// The limit, in bytes of the heap, that determinization itself is allowed/// to use. This does not include the size of the DFA being built./// The configuration used to initialize determinization./// The NFA we're converting into a DFA./// The DFA we're building.builder_states/// Each DFA state being built is defined as an *ordered* set of NFA/// states, along with some meta facts about the ordered set of NFA states./// This is never empty. The first state is always a dummy state such that/// a state id == 0 corresponds to a dead state. The second state is always/// the quit state./// Why do we have states in both a `Vec` and in a cache map below?/// Well, they serve two different roles based on access patterns./// `builder_states` is the canonical home of each state, and provides/// constant random access by a DFA state's ID. The cache map below, on/// the other hand, provides a quick way of searching for identical DFA/// states by using the DFA state as a key in the map. Of course, we use/// reference counting to avoid actually duplicating the state's data/// itself. (Although this has never been benchmarked.) Note that the cache/// map does not give us full minimization; it just lets us avoid some very/// obvious redundant states./// Note that the index into this Vec isn't quite the DFA's state ID./// Rather, it's just an index. To get the state ID, you have to multiply/// it by the DFA's stride. That's done by self.dfa.from_index. And the/// inverse is self.dfa.to_index./// Moreover, DFA states don't usually retain the IDs assigned to them/// by their position in this Vec. After determinization completes,/// states are shuffled around to support other optimizations. See the/// sibling 'special' module for more details on that. (The reason for/// mentioning this is that if you print out the DFA for debugging during/// determinization, and then print out the final DFA after it is fully/// built, then the state IDs likely won't match up.)StateMap/// A cache of DFA states that already exist and can be easily looked up/// via ordered sets of NFA states./// See `builder_states` docs for why we store states in two different/// ways.memory_usage_state/// The memory usage, in bytes, used by builder_states and cache. We track/// this as new states are added since states use a variable amount of/// heap. Tracking this as we add states makes it possible to compute the/// total amount of memory used by the determinizer in constant time.sparses/// A pair of sparse sets for tracking ordered sets of NFA state IDs./// These are reused throughout determinization. A bounded sparse set/// gives us constant time insertion, membership testing and clearing./// Scratch space for a stack of NFA states to visit, for depth first/// visiting without recursion.scratch_state_builder/// Scratch space for storing an ordered sequence of NFA states, for/// amortizing allocation. This is principally useful for when we avoid/// adding a new DFA state since it already exists. In order to detect this/// case though, we still need an ordered set of NFA state IDs. So we use/// this space to stage that ordered set before we know whether we need to/// create a new DFA state or not./// The actual implementation of determinization that converts an NFA to a DFA/// through powerset construction./// This determinizer roughly follows the typical powerset construction, where/// each DFA state is comprised of one or more NFA states. In the worst case,/// there is one DFA state for every possible combination of NFA states. In/// practice, this only happens in certain conditions, typically when there are/// bounded repetitions./// The main differences between this implementation and typical deteminization/// are that this implementation delays matches by one state and hackily makes/// look-around work. Comments below attempt to explain this./// The lifetime variable `'a` refers to the lifetime of the NFA or DFA,/// whichever is shorter./// A map from states to state identifiers. When using std, we use a standard/// hashmap, since it's a bit faster for this use case. (Other maps, like/// one's based on FNV, have not yet been benchmarked.)/// The main purpose of this map is to reuse states where possible. This won't/// fully minimize the DFA, but it works well in a lot of cases./// Build the DFA. If there was a problem constructing the DFA (e.g., if/// the chosen state identifier representation is too small), then an error/// Return the identifier for the next DFA state given an existing DFA/// state and an input byte. If the next DFA state already exists, then/// return its identifier from the cache. Otherwise, build the state, cache/// it and return its identifier./// This routine returns a boolean indicating whether a new state was/// built. If a new state is built, then the caller needs to add it to its/// frontier of uncompiled DFA states to compute transitions for.add_all_starts/// Compute the set of DFA start states and add their identifiers in/// 'dfa_state_ids' (no duplicates are added).add_start_group/// Add a group of start states for the given match pattern ID. Any new/// DFA states added are pushed on to 'dfa_state_ids'. (No duplicates are/// pushed.)/// When pattern_id is None, then this will compile a group of unanchored/// start states (if the DFA is unanchored). When the pattern_id is/// present, then this will compile a group of anchored start states that/// only match the given pattern./// This panics if `anchored` corresponds to an invalid pattern ID.add_one_start/// Add a new DFA start state corresponding to the given starting NFA/// state, and the starting search configuration. (The starting search/// configuration essentially tells us which look-behind assertions are/// true for this particular state.)/// The boolean returned indicates whether the state ID returned is a newly/// created state, or a previously cached state.maybe_add_state/// Adds the given state to the DFA being built depending on whether it/// already exists in this determinizer's cache./// If it does exist, then the memory used by 'state' is put back into the/// determinizer and the previously created state's ID is returned. (Along/// with 'false', indicating that no new state was added.)/// If it does not exist, then the state is added to the DFA being built/// and a fresh ID is allocated (if ID allocation fails, then an error is/// returned) and returned. (Along with 'true', indicating that a new state/// was added.)/// Add the given state to the DFA and make it available in the cache./// The state initially has no transitions. That is, it transitions to the/// dead state for all possible inputs, and transitions to the quit state/// for all quit bytes./// If adding the state would exceed the maximum value for StateID, then anget_state_builder/// Returns a state builder from this determinizer that might have existing/// capacity. This helps avoid allocs in cases where a state is built that/// turns out to already be cached./// Callers must put the state builder back with 'put_state_builder',/// otherwise the allocation reuse won't work.put_state_builder/// Puts the given state builder back into this determinizer for reuse./// Note that building a 'State' from a builder always creates a new/// alloc, so callers should always put the builder back./// Return the memory usage, in bytes, of this determinizer at the current/// point in time. This does not include memory used by the NFA or the/// dense DFA itself.in_transitions/// An implementation of Hopcroft's algorithm for minimizing DFAs./// The algorithm implemented here is mostly taken from Wikipedia:/// https://en.wikipedia.org/wiki/DFA_minimization#Hopcroft's_algorithm/// This code has had some light optimization attention paid to it,/// particularly in the form of reducing allocation as much as possible./// However, it is still generally slow. Future optimization work should/// probably focus on the bigger picture rather than micro-optimizations. For/// example:/// 1. Figure out how to more intelligently create initial partitions. That is,///    Hopcroft's algorithm starts by creating two partitions of DFA states///    that are known to NOT be equivalent: match states and non-match states.///    The algorithm proceeds by progressively refining these partitions into///    smaller partitions. If we could start with more partitions, then we///    could reduce the amount of work that Hopcroft's algorithm needs to do./// 2. For every partition that we visit, we find all incoming transitions to///    every state in the partition for *every* element in the alphabet. (This///    is why using byte classes can significantly decrease minimization times,///    since byte classes shrink the alphabet.) This is quite costly and there///    is perhaps some redundant work being performed depending on the specific///    states in the set. For example, we might be able to only visit some///    elements of the alphabet based on the transitions./// 3. Move parts of minimization into determinization. If minimization has///    fewer states to deal with, then it should run faster. A prime example///    of this might be large Unicode classes, which are generated in way that///    can create a lot of redundant states. (Some work has been done on this///    point during NFA compilation via the algorithm described in the///    "Incremental Construction of MinimalAcyclic Finite-State Automata"///    paper.)/// A set of states. A state set makes up a single partition in Hopcroft's/// It is represented by an ordered set of state identifiers. We use shared/// ownership so that a single state set can be in both the set of partitions/// and in the set of waiting sets simultaneously without an additional/// allocation. Generally, once a state set is built, it becomes immutable./// We use this representation because it avoids the overhead of more/// traditional set data structures (HashSet/BTreeSet), and also because/// computing intersection/subtraction on this representation is especially/// fast.find_waitingfind_incoming_toinitial_partitionsincoming_transitionsdeep_clone/// This is an alias for a state ID of zero. It has special significance/// because it always corresponds to the first state in a DFA, and the first/// state in a DFA is always "dead." That is, the dead state always has all/// of its transitions set to itself. Moreover, the dead state is used as a/// sentinel for various things. e.g., In search, reaching a dead state means/// that the search must stop.onepass/*!
A module for building and searching with deterministic finite automata (DFAs).

Like other modules in this crate, DFAs support a rich regex syntax with Unicode
features. DFAs also have extensive options for configuring the best space vs
time trade off for your use case and provides support for cheap deserialization
of automata for use in `no_std` environments.

If you're looking for lazy DFAs that build themselves incrementally during
search, then please see the top-level [`hybrid` module](crate::hybrid).

# Overview

This section gives a brief overview of the primary types in this module:

* A [`regex::Regex`] provides a way to search for matches of a regular
expression using DFAs. This includes iterating over matches with both the start
and end positions of each match.
* A [`dense::DFA`] provides low level access to a DFA that uses a dense
representation (uses lots of space, but fast searching).
* A [`sparse::DFA`] provides the same API as a `dense::DFA`, but uses a sparse
representation (uses less space, but slower searching).
* An [`Automaton`] trait that defines an interface that both dense and sparse
DFAs implement. (A `regex::Regex` is generic over this trait.)
* Both dense DFAs and sparse DFAs support serialization to raw bytes (e.g.,
[`dense::DFA::to_bytes_little_endian`]) and cheap deserialization (e.g.,
[`dense::DFA::from_bytes`]).

There is also a [`onepass`] module that provides a [one-pass
DFA](onepass::DFA). The unique advantage of this DFA is that, for the class
of regexes it can be built with, it supports reporting the spans of matching
capturing groups. It is the only DFA in this crate capable of such a thing.

# Example: basic regex searching

This example shows how to compile a regex using the default configuration
and then use it to find matches in a byte string:

```
use regex_automata::{Match, dfa::regex::Regex};

let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
let text = b"2018-12-24 2016-10-08";
let matches: Vec<Match> = re.find_iter(text).collect();
assert_eq!(matches, vec![
    Match::must(0, 0..10),
    Match::must(0, 11..21),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# Example: searching with regex sets

The DFAs in this module all fully support searching with multiple regexes
simultaneously. You can use this support with standard leftmost-first style
searching to find non-overlapping matches:

```
# if cfg!(miri) { return Ok(()); } // miri takes too long
use regex_automata::{Match, dfa::regex::Regex};

let re = Regex::new_many(&[r"\w+", r"\S+"])?;
let text = b"@foo bar";
let matches: Vec<Match> = re.find_iter(text).collect();
assert_eq!(matches, vec![
    Match::must(1, 0..4),
    Match::must(0, 5..8),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# Example: use sparse DFAs

By default, compiling a regex will use dense DFAs internally. This uses more
memory, but executes searches more quickly. If you can abide slower searches
(somewhere around 3-5x), then sparse DFAs might make more sense since they can
use significantly less space.

Using sparse DFAs is as easy as using `Regex::new_sparse` instead of
`Regex::new`:

```
use regex_automata::{Match, dfa::regex::Regex};

let re = Regex::new_sparse(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
let text = b"2018-12-24 2016-10-08";
let matches: Vec<Match> = re.find_iter(text).collect();
assert_eq!(matches, vec![
    Match::must(0, 0..10),
    Match::must(0, 11..21),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

If you already have dense DFAs for some reason, they can be converted to sparse
DFAs and used to build a new `Regex`. For example:

```
use regex_automata::{Match, dfa::regex::Regex};

let dense_re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
let sparse_re = Regex::builder().build_from_dfas(
    dense_re.forward().to_sparse()?,
    dense_re.reverse().to_sparse()?,
);
let text = b"2018-12-24 2016-10-08";
let matches: Vec<Match> = sparse_re.find_iter(text).collect();
assert_eq!(matches, vec![
    Match::must(0, 0..10),
    Match::must(0, 11..21),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# Example: deserialize a DFA

This shows how to first serialize a DFA into raw bytes, and then deserialize
those raw bytes back into a DFA. While this particular example is a
bit contrived, this same technique can be used in your program to
deserialize a DFA at start up time or by memory mapping a file.

```
use regex_automata::{Match, dfa::{dense, regex::Regex}};

let re1 = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
// serialize both the forward and reverse DFAs, see note below
let (fwd_bytes, fwd_pad) = re1.forward().to_bytes_native_endian();
let (rev_bytes, rev_pad) = re1.reverse().to_bytes_native_endian();
// now deserialize both---we need to specify the correct type!
let fwd: dense::DFA<&[u32]> = dense::DFA::from_bytes(&fwd_bytes[fwd_pad..])?.0;
let rev: dense::DFA<&[u32]> = dense::DFA::from_bytes(&rev_bytes[rev_pad..])?.0;
// finally, reconstruct our regex
let re2 = Regex::builder().build_from_dfas(fwd, rev);

// we can use it like normal
let text = b"2018-12-24 2016-10-08";
let matches: Vec<Match> = re2.find_iter(text).collect();
assert_eq!(matches, vec![
    Match::must(0, 0..10),
    Match::must(0, 11..21),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

There are a few points worth noting here:

* We need to extract the raw DFAs used by the regex and serialize those. You
can build the DFAs manually yourself using [`dense::Builder`], but using
the DFAs from a `Regex` guarantees that the DFAs are built correctly. (In
particular, a `Regex` constructs a reverse DFA for finding the starting
location of matches.)
* To convert the DFA to raw bytes, we use the `to_bytes_native_endian` method.
In practice, you'll want to use either [`dense::DFA::to_bytes_little_endian`]
or [`dense::DFA::to_bytes_big_endian`], depending on which platform you're
deserializing your DFA from. If you intend to deserialize on either platform,
then you'll need to serialize both and deserialize the right one depending on
your target's endianness.
* Safely deserializing a DFA requires verifying the raw bytes, particularly if
they are untrusted, since an invalid DFA could cause logical errors, panics
or even undefined behavior. This verification step requires visiting all of
the transitions in the DFA, which can be costly. If cheaper verification is
desired, then [`dense::DFA::from_bytes_unchecked`] is available that only does
verification that can be performed in constant time. However, one can only use
this routine if the caller can guarantee that the bytes provided encoded a
valid DFA.

The same process can be achieved with sparse DFAs as well:

```
use regex_automata::{Match, dfa::{sparse, regex::Regex}};

let re1 = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
// serialize both
let fwd_bytes = re1.forward().to_sparse()?.to_bytes_native_endian();
let rev_bytes = re1.reverse().to_sparse()?.to_bytes_native_endian();
// now deserialize both---we need to specify the correct type!
let fwd: sparse::DFA<&[u8]> = sparse::DFA::from_bytes(&fwd_bytes)?.0;
let rev: sparse::DFA<&[u8]> = sparse::DFA::from_bytes(&rev_bytes)?.0;
// finally, reconstruct our regex
let re2 = Regex::builder().build_from_dfas(fwd, rev);

// we can use it like normal
let text = b"2018-12-24 2016-10-08";
let matches: Vec<Match> = re2.find_iter(text).collect();
assert_eq!(matches, vec![
    Match::must(0, 0..10),
    Match::must(0, 11..21),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

Note that unlike dense DFAs, sparse DFAs have no alignment requirements.
Conversely, dense DFAs must be aligned to the same alignment as a
[`StateID`](crate::util::primitives::StateID).

# Support for `no_std` and `alloc`-only

This crate comes with `alloc` and `std` features that are enabled by default.
When the `alloc` or `std` features are enabled, the API of this module will
include the facilities necessary for compiling, serializing, deserializing
and searching with DFAs. When only the `alloc` feature is enabled, then
implementations of the `std::error::Error` trait are dropped, but everything
else generally remains the same. When both the `alloc` and `std` features are
disabled, the API of this module will shrink such that it only includes the
facilities necessary for deserializing and searching with DFAs.

The intended workflow for `no_std` environments is thus as follows:

* Write a program with the `alloc` or `std` features that compiles and
serializes a regular expression. You may need to serialize both little and big
endian versions of each DFA. (So that's 4 DFAs in total for each regex.)
* In your `no_std` environment, follow the examples above for deserializing
your previously serialized DFAs into regexes. You can then search with them as
you would any regex.

Deserialization can happen anywhere. For example, with bytes embedded into a
binary or with a file memory mapped at runtime.

The `regex-cli` command (found in the same repository as this crate) can be
used to serialize DFAs to files and generate Rust code to read them.

# Syntax

This module supports the same syntax as the `regex` crate, since they share the
same parser. You can find an exhaustive list of supported syntax in the
[documentation for the `regex` crate](https://docs.rs/regex/1/regex/#syntax).

There are two things that are not supported by the DFAs in this module:

* Capturing groups. The DFAs (and [`Regex`](regex::Regex)es built on top
of them) can only find the offsets of an entire match, but cannot resolve
the offsets of each capturing group. This is because DFAs do not have the
expressive power necessary.
* Unicode word boundaries. These present particularly difficult challenges for
DFA construction and would result in an explosion in the number of states.
One can enable [`dense::Config::unicode_word_boundary`] though, which provides
heuristic support for Unicode word boundaries that only works on ASCII text.
Otherwise, one can use `(?-u:\b)` for an ASCII word boundary, which will work
on any input.

There are no plans to lift either of these limitations.

Note that these restrictions are identical to the restrictions on lazy DFAs.

# Differences with general purpose regexes

The main goal of the [`regex`](https://docs.rs/regex) crate is to serve as a
general purpose regular expression engine. It aims to automatically balance low
compile times, fast search times and low memory usage, while also providing
a convenient API for users. In contrast, this module provides a lower level
regular expression interface based exclusively on DFAs that is a bit less
convenient while providing more explicit control over memory usage and search
times.

Here are some specific negative differences:

* **Compilation can take an exponential amount of time and space** in the size
of the regex pattern. While most patterns do not exhibit worst case exponential
time, such patterns do exist. For example, `[01]*1[01]{N}` will build a DFA
with approximately `2^(N+2)` states. For this reason, untrusted patterns should
not be compiled with this module. (In the future, the API may expose an option
to return an error if the DFA gets too big.)
* This module does not support sub-match extraction via capturing groups, which
can be achieved with the regex crate's "captures" API.
* While the regex crate doesn't necessarily sport fast compilation times,
the regexes in this module are almost universally slow to compile, especially
when they contain large Unicode character classes. For example, on my system,
compiling `\w{50}` takes about 1 second and almost 15MB of memory! (Compiling
a sparse regex takes about the same time but only uses about 1.2MB of
memory.) Conversely, compiling the same regex without Unicode support, e.g.,
`(?-u)\w{50}`, takes under 1 millisecond and about 15KB of memory. For this
reason, you should only use Unicode character classes if you absolutely need
them! (They are enabled by default though.)
* This module does not support Unicode word boundaries. ASCII word bondaries
may be used though by disabling Unicode or selectively doing so in the syntax,
e.g., `(?-u:\b)`. There is also an option to
[heuristically enable Unicode word boundaries](crate::dfa::dense::Config::unicode_word_boundary),
where the corresponding DFA will give up if any non-ASCII byte is seen.
* As a lower level API, this module does not do literal optimizations
automatically. Although it does provide hooks in its API to make use of the
[`Prefilter`](crate::util::prefilter::Prefilter) trait. Missing literal
optimizations means that searches may run much slower than what you're
accustomed to, although, it does provide more predictable and consistent
performance.
* There is no `&str` API like in the regex crate. In this module, all APIs
operate on `&[u8]`. By default, match indices are
guaranteed to fall on UTF-8 boundaries, unless either of
[`syntax::Config::utf8`](crate::util::syntax::Config::utf8) or
[`thompson::Config::utf8`](crate::nfa::thompson::Config::utf8) are disabled.

With some of the downsides out of the way, here are some positive differences:

* Both dense and sparse DFAs can be serialized to raw bytes, and then cheaply
deserialized. Deserialization can be done in constant time with the unchecked
APIs, since searching can be performed directly on the raw serialized bytes of
a DFA.
* This module was specifically designed so that the searching phase of a
DFA has minimal runtime requirements, and can therefore be used in `no_std`
environments. While `no_std` environments cannot compile regexes, they can
deserialize pre-compiled regexes.
* Since this module builds DFAs ahead of time, it will generally out-perform
the `regex` crate on equivalent tasks. The performance difference is likely
not large. However, because of a complex set of optimizations in the regex
crate (like literal optimizations), an accurate performance comparison may be
difficult to do.
* Sparse DFAs provide a way to build a DFA ahead of time that sacrifices search
performance a small amount, but uses much less storage space. Potentially even
less than what the regex crate uses.
* This module exposes DFAs directly, such as [`dense::DFA`] and
[`sparse::DFA`], which enables one to do less work in some cases. For example,
if you only need the end of a match and not the start of a match, then you can
use a DFA directly without building a `Regex`, which always requires a second
DFA to find the start of a match.
* This module provides more control over memory usage. Aside from choosing
between dense and sparse DFAs, one can also choose a smaller state identifier
representation to use less space. Also, one can enable DFA minimization
via [`dense::Config::minimize`], but it can increase compilation times
dramatically.
*/LookLookSetUnicodeWordBoundaryErrorNonMaxUsizeSparseSet/// The configuration used for building a [one-pass DFA](DFA)./// A one-pass DFA configuration is a simple data object that is typically used/// with [`Builder::configure`]. It can be cheaply cloned./// A default configuration can be created either with `Config::new`, or/// perhaps more conveniently, with [`DFA::config`]./// Return a new default one-pass DFA configuration./// [`MatchKind::All`]. This corresponds to "classical DFA" construction/// where all possible matches are visited./// When it comes to the one-pass DFA, it is rarer for preference order and/// "longest match" to actually disagree. Since if they did disagree, then/// the regex typically isn't one-pass. For example, searching `Samwise`/// for `Sam|Samwise` will report `Sam` for leftmost-first matching and/// `Samwise` for "longest match" or "all" matching. However, this regex is/// not one-pass if taken literally. The equivalent regex, `Sam(?:|wise)`/// is one-pass and `Sam|Samwise` may be optimized to it./// The other main difference is that "all" match semantics don't support/// non-greedy matches. "All" match semantics always try to match as much/// one-pass DFA./// You might want to enable this option when you want to both search for/// anchored matches of any pattern or to search for anchored matches of/// one particular pattern while using the same DFA. (Otherwise, you would/// need to compile a new DFA for each pattern.)/// This example shows how to build a multi-regex and then search for/// matches for a any of the patterns or matches for a specific pattern.///     dfa::onepass::DFA, Anchored, Input, Match, PatternID,///     .configure(DFA::config().starts_for_each_pattern(true))///     .build_many(&["[a-z]+", "[0-9]+"])?;/// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());/// let haystack = "123abc";/// // A normal multi-pattern search will show pattern 1 matches./// re.try_search(&mut cache, &input, &mut caps)?;/// assert_eq!(Some(Match::must(1, 0..3)), caps.get_match());/// // If we only want to report pattern 0 matches, then we'll get no/// // match here./// let input = input.anchored(Anchored::Pattern(PatternID::must(0)));/// assert_eq!(None, caps.get_match());/// one is debugging a one-pass DFA./// can be reduced drastically from (approximately) `#states * 256 */// sizeof(StateID)` to `#states * k * sizeof(StateID)` where `k` is the/// number of equivalence classes (rounded up to the nearest power of 2)./// As a result, total space usage can decrease substantially. Moreover,/// since a smaller alphabet is used, DFA compilation becomes faster as/// Set a size limit on the total heap used by a one-pass DFA./// construction of a one-pass DFA. If the DFA's heap usage exceeds/// this configured limit, then construction is stopped and an error is/// This example shows a one-pass DFA that fails to build because of/// a configured size limit. This particular example also serves as a/// cautionary tale demonstrating just how big DFAs with large Unicode/// character classes can get./// use regex_automata::{dfa::onepass::DFA, Match};/// DFA::builder()///     .configure(DFA::config().size_limit(Some(6_000_000)))///     .configure(DFA::config().size_limit(Some(7_000_000)))/// let haystack = "A".repeat(20);/// re.captures(&mut cache, &haystack, &mut caps);/// assert_eq!(Some(Match::must(0, 0..20)), caps.get_match());/// While one needs a little more than 3MB to represent `\w{20}`, it/// turns out that you only need a little more than 4KB to representget_size_limit/// A builder for a [one-pass DFA](DFA)./// This builder permits configuring options for the syntax of a pattern, the/// NFA construction and the DFA construction. This builder is different from a/// general purpose regex builder in that it permits fine grain configuration/// of the construction process. The trade off for this is complexity, and/// the possibility of setting a configuration that might not make sense. For/// example, there are two different UTF-8 modes:/// * [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) controls/// whether the pattern itself can contain sub-expressions that match invalid/// UTF-8./// * [`thompson::Config::utf8`] controls whether empty matches that split a/// Unicode codepoint are reported or not./// Generally speaking, callers will want to either enable all of these or/// disable all of these./// This example shows how to disable UTF-8 mode in the syntax and the NFA./// This is generally what you want for matching on arbitrary bytes.///     dfa::onepass::DFA,///     Match,///     .build(r"foo(?-u:[^b])ar.*")?;/// let haystack = b"foo\xFFarzz\xE2\x98\xFF\n";/// re.captures(&mut cache, haystack, &mut caps);/// // Notice that `(?-u:[^b])` matches invalid UTF-8,/// // but the subsequent `.*` does not! Disabling UTF-8/// // on the syntax permits this./// // N.B. This example does not show the impact of/// // disabling UTF-8 mode on a one-pass DFA Config,/// //  since that only impacts regexes that can/// // produce matches of length 0./// assert_eq!(Some(Match::must(0, 0..8)), caps.get_match());/// Create a new one-pass DFA builder with the default configuration./// Build a one-pass DFA from the given pattern./// Build a one-pass DFA from the given patterns./// use regex_automata::{dfa::onepass::DFA, nfa::thompson::NFA, Match};///     .build(r"[a-z0-9]+")?;/// let re = DFA::builder().build_from_nfa(nfa)?;/// re.captures(&mut cache, "foo123bar", &mut caps);/// assert_eq!(Some(Match::must(0, 0..9)), caps.get_match());/// Apply the given one-pass DFA configuration options to this builder./// These settings only apply when constructing a one-pass DFA directly/// from a pattern./// This permits setting things like whether additional time should be/// spent shrinking the size of the NFA.uncompiled_nfa_ids/// An unordered collection of NFA state IDs that we haven't yet tried to/// build into a DFA state yet./// This collection does not ultimately wind up including every NFA state/// ID. Instead, each ID represents a "start" state for a sub-graph of the/// NFA. The set of NFA states we then use to build a DFA state consists/// of that "start" state and all states reachable from it via epsilon/// transitions.nfa_to_dfa_id/// A map from NFA state ID to DFA state ID. This is useful for easily/// determining whether an NFA state has been used as a "starting" point/// to build a DFA state yet. If it hasn't, then it is mapped to DEAD,/// and since DEAD is specially added and never corresponds to any NFA/// state, it follows that a mapping to DEAD implies the NFA state has/// no corresponding DFA state yet.Epsilons/// A stack used to traverse the NFA states that make up a single DFA/// state. Traversal occurs until the stack is empty, and we only push to/// the stack when the state ID isn't in 'seen'. Actually, even more than/// that, if we try to push something on to this stack that is already in/// 'seen', then we bail out on construction completely, since it implies/// that the NFA is not one-pass./// The set of NFA states that we've visited via 'stack'./// Whether a match NFA state has been observed while constructing a/// one-pass DFA state. Once a match state is seen, assuming we are using/// leftmost-first match semantics, then we don't add any more transitions/// to the DFA state we're building./// The config passed to the builder./// This is duplicated in dfa.config./// The NFA we're building a one-pass DFA from./// This is duplicated in dfa.nfa./// The equivalence classes that make up the alphabet for this DFA>/// This is duplicated in dfa.classes.InternalBuilder/// An internal builder for encapsulating the state necessary to build a/// one-pass DFA. Typical use is just `InternalBuilder::new(..).build()`./// There is no separate pass for determining whether the NFA is one-pass or/// not. We just try to build the DFA. If during construction we discover that/// it is not one-pass, we bail out. This is likely to lead to some undesirable/// expense in some cases, so it might make sense to try an identify common/// patterns in the NFA that make it definitively not one-pass. That way, we/// can avoid ever trying to build a one-pass DFA in the first place. For/// example, '\w*\s' is not one-pass, and since '\w' is Unicode-aware by/// default, it's probably not a trivial cost to try and build a one-pass DFA/// for it and then fail./// Note that some (immutable) fields are duplicated here. For example, the/// 'nfa' and 'classes' fields are both in the 'DFA'. They are the same thing,/// but we duplicate them because it makes composition easier below. Otherwise,/// since the borrow checker can't see through method calls, the mutable borrow/// we use to mutate the DFA winds up preventing borrowing from any other part/// of the DFA, even though we aren't mutating those parts. We only do this/// because the duplication is cheap./// Create a new builder with an initial empty DFA./// Build the DFA from the NFA given to this builder. If the NFA is not/// one-pass, then return an error. An error may also be returned if a/// particular limit is exceeded. (Some limits, like the total heap memory/// used, are configurable. Others, like the total patterns or slots, are/// hard-coded based on representational limitations.)shuffle_states/// Shuffle all match states to the end of the transition table and set/// 'min_match_id' to the ID of the first such match state./// The point of this is to make it extremely cheap to determine whether/// a state is a match state or not. We need to check on this on every/// transition during a search, so it being cheap is important. This/// permits us to check it by simply comparing two state identifiers, as/// opposed to looking for the pattern ID in the state's `PatternEpsilons`./// (Which requires a memory load and some light arithmetic.)compile_transition/// Compile the given NFA transition into the DFA state given./// 'Epsilons' corresponds to any conditional epsilon transitions that need/// to be satisfied to follow this transition, and any slots that need to/// be saved if the transition is followed./// If this transition indicates that the NFA is not one-pass, then/// this returns an error. (This occurs, for example, if the DFA state/// already has a transition defined for the same input symbols as the/// given transition, *and* the result of the old and new transitions is/// different.)add_start_state/// Add a start state to the DFA corresponding to the given NFA starting/// state ID./// If adding a state would blow any limits (configured or hard-coded),/// then an error is returned./// If the starting state is an anchored state for a particular pattern,/// then callers must provide the pattern ID for that starting state./// Callers must also ensure that the first starting state added is the/// start state for all patterns, and then each anchored starting state for/// each pattern (if necessary) added in order. Otherwise, this panics.add_dfa_state_for_nfa_state/// Add a new DFA state corresponding to the given NFA state. If adding a/// state would blow any limits (configured or hard-coded), then an error/// is returned. If a DFA state already exists for the given NFA state,/// then that DFA state's ID is returned and no new states are added./// It is not expected that this routine is called for every NFA state./// Instead, an NFA state ID will usually correspond to the "start" state/// for a sub-graph of the NFA, where all states in the sub-graph are/// reachable via epsilon transitions (conditional or unconditional). That/// sub-graph of NFA states is ultimately what produces a single DFA state./// Unconditionally add a new empty DFA state. If adding it would exceed/// any limits (configured or hard-coded), then an error is returned. The/// ID of the new state is returned on success./// The added state is *not* a match state.stack_push/// Push the given NFA state ID and its corresponding epsilons (slots and/// conditional epsilon transitions) on to a stack for use in a depth first/// traversal of a sub-graph of the NFA./// If the given NFA state ID has already been pushed on to the stack, then/// it indicates the regex is not one-pass and this correspondingly returns/// The configuration provided by the caller./// The NFA used to build this DFA./// NOTE: We probably don't need to store the NFA here, but we use enough/// bits from it that it's convenient to do so. And there really isn't much/// cost to doing so either, since an NFA is reference counted internally./// The transition table. Given a state ID 's' and a byte of haystack 'b',/// the next state is `table[sid + classes[byte]]`./// The stride of this table (i.e., the number of columns) is always/// a power of 2, even if the alphabet length is smaller. This makes/// converting between state IDs and state indices very cheap./// Note that the stride always includes room for one extra "transition"/// that isn't actually a transition. It is a 'PatternEpsilons' that is/// used for match states only. Because of this, the maximum number of/// active columns in the transition table is 257, which means the maximum/// stride is 512 (the next power of 2 greater than or equal to 257)./// The DFA state IDs of the starting states./// `starts[0]` is always present and corresponds to the starting state/// when searching for matches of any pattern in the DFA./// `starts[i]` where i>0 corresponds to the starting state for the pattern/// ID 'i-1'. These starting states are optional.min_match_id/// Every state ID >= this value corresponds to a match state./// This is what a search uses to detect whether a state is a match state/// or not. It requires only a simple comparison instead of bit-unpacking/// the PatternEpsilons from every state./// The alphabet of this DFA, split into equivalence classes. Bytes in the/// same equivalence class can never discriminate between a match and a/// The number of elements in each state in the transition table. This may/// be less than the stride, since the stride is always a power of 2 and/// the alphabet length can be anything up to and including 256./// The number of columns in the transition table, expressed as a power of/// 2.pateps_offset/// The offset at which the PatternEpsilons for a match state is stored in/// PERF: One wonders whether it would be better to put this in a separate/// allocation, since only match states have a non-empty PatternEpsilons/// and the number of match states tends be dwarfed by the number of/// non-match states. So this would save '8*len(non_match_states)' for each/// DFA. The question is whether moving this to a different allocation will/// lead to a perf hit during searches. You might think dealing with match/// states is rare, but some regexes spend a lot of time in match states/// gobbling up input. But... match state handling is already somewhat/// expensive, so maybe this wouldn't do much? Either way, it's worth/// experimenting.explicit_slot_start/// The first explicit slot index. This refers to the first slot appearing/// immediately after the last implicit slot. It is always 'patterns.len()/// * 2'./// We record this because we only store the explicit slots in our DFA/// transition table that need to be saved. Implicit slots are handled/// automatically as part of the search./// A one-pass DFA for executing a subset of anchored regex searches while/// resolving capturing groups./// A one-pass DFA can be built from an NFA that is one-pass. An NFA is/// one-pass when there is never any ambiguity about how to continue a search./// For example, `a*a` is not one-pass becuase during a search, it's not/// possible to know whether to continue matching the `a*` or to move on to/// the single `a`. However, `a*b` is one-pass, because for every byte in the/// input, it's always clear when to move on from `a*` to `b`./// # Only anchored searches are supported/// In this crate, especially for DFAs, unanchored searches are implemented by/// treating the pattern as if it had a `(?s-u:.)*?` prefix. While the prefix/// is one-pass on its own, adding anything after it, e.g., `(?s-u:.)*?a` will/// make the overall pattern not one-pass. Why? Because the `(?s-u:.)` matches/// any byte, and there is therefore ambiguity as to when the prefix should/// stop matching and something else should start matching./// Therefore, one-pass DFAs do not support unanchored searches. In addition/// to many regexes simply not being one-pass, it implies that one-pass DFAs/// have limited utility. With that said, when a one-pass DFA can be used, it/// can potentially provide a dramatic speed up over alternatives like the/// [`BoundedBacktracker`](crate::nfa::thompson::backtrack::BoundedBacktracker)/// and the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM). In particular,/// a one-pass DFA is the only DFA capable of reporting the spans of matching/// capturing groups./// To clarify, when we say that unanchored searches are not supported, what/// that actually means is:/// * The high level routines, [`DFA::is_match`] and [`DFA::captures`], always/// do anchored searches./// * Since iterators are most useful in the context of unanchored searches,/// there is no `DFA::captures_iter` method./// * For lower level routines like [`DFA::try_search`], an error will be/// returned if the given [`Input`] is configured to do an unanchored search or/// search for an invalid pattern ID. (Note that an [`Input`] is configured to/// do an unanchored search by default, so just giving a `Input::new` is/// guaranteed to return an error.)/// # Other limitations/// In addition to the [configurable heap limit](Config::size_limit) and/// the requirement that a regex pattern be one-pass, there are some other/// limitations:/// * There is an internal limit on the total number of explicit capturing/// groups that appear across all patterns. It is somewhat small and there is/// no way to configure it. If your pattern(s) exceed this limit, then building/// a one-pass DFA will fail./// * If the number of patterns exceeds an internal unconfigurable limit, then/// building a one-pass DFA will fail. This limit is quite large and you're/// unlikely to hit it./// * If the total number of states exceeds an internal unconfigurable limit,/// then building a one-pass DFA will fail. This limit is quite large and/// you're unlikely to hit it./// # Other examples of regexes that aren't one-pass/// One particularly unfortunate example is that enabling Unicode can cause/// regexes that were one-pass to no longer be one-pass. Consider the regex/// `(?-u)\w*\s` for example. It is one-pass because there is exactly no/// overlap between the ASCII definitions of `\w` and `\s`. But `\w*\s`/// (i.e., with Unicode enabled) is *not* one-pass because `\w` and `\s` get/// translated to UTF-8 automatons. And while the *codepoints* in `\w` and `\s`/// do not overlap, the underlying UTF-8 encodings do. Indeed, because of the/// overlap between UTF-8 automata, the use of Unicode character classes will/// tend to vastly increase the likelihood of a regex not being one-pass./// # How does one know if a regex is one-pass or not?/// At the time of writing, the only way to know is to try and build a one-pass/// DFA. The one-pass property is checked while constructing the DFA./// This does mean that you might potentially waste some CPU cycles and memory/// by optimistically trying to build a one-pass DFA. But this is currently the/// only way. In the future, building a one-pass DFA might be able to use some/// heuristics to detect common violations of the one-pass property and bail/// more quickly./// Unlike a general DFA, a one-pass DFA has stricter bounds on its resource/// usage. Namely, construction of a one-pass DFA has a time and space/// complexity of `O(n)`, where `n ~ nfa.states().len()`. (A general DFA's time/// and space complexity is `O(2^n)`.) This smaller time bound is achieved/// because there is at most one DFA state created for each NFA state. If/// additional DFA states would be required, then the pattern is not one-pass/// and construction will fail./// Note though that currently, this DFA uses a fully dense representation./// This means that while its space complexity is no worse than an NFA, it may/// in practice use more memory because of higher constant factors. The reason/// for this trade off is two-fold. Firstly, a dense representation makes the/// search faster. Secondly, the bigger an NFA, the more unlikely it is to be/// one-pass. Therefore, most one-pass DFAs are usually pretty small./// This example shows that the one-pass DFA implements Unicode word boundaries/// correctly while simultaneously reporting spans for capturing groups that/// participate in a match. (This is the only DFA that implements full support/// for Unicode word boundaries.)/// use regex_automata::{dfa::onepass::DFA, Match, Span};/// let re = DFA::new(r"\b(?P<first>\w+)[[:space:]]+(?P<last>\w+)\b")?;/// re.captures(&mut cache, "Шерлок Холмс", &mut caps);/// assert_eq!(Some(Match::must(0, 0..23)), caps.get_match());/// assert_eq!(Some(Span::from(0..12)), caps.get_group_by_name("first"));/// assert_eq!(Some(Span::from(13..23)), caps.get_group_by_name("last"));/// Unlike other regex engines in this crate, this one does not provide/// iterator search functions. This is because a one-pass DFA only supports/// anchored searches, and so iterator functions are generally not applicable./// However, if you know that all of your matches are/// directly adjacent, then an iterator can be used. The/// [`util::iter::Searcher`](crate::util::iter::Searcher) type can be used for/// this purpose:///     util::iter::Searcher,///     Anchored, Input, Span,/// let re = DFA::new(r"\w(\d)\w")?;/// let (mut cache, caps) = (re.create_cache(), re.create_captures());/// let input = Input::new("a1zb2yc3x").anchored(Anchored::Yes);/// let mut it = Searcher::new(input).into_captures_iter(caps, |input, caps| {///     Ok(re.try_search(&mut cache, input, caps)?)/// }).infallible();/// let caps0 = it.next().unwrap();/// assert_eq!(Some(Span::from(1..2)), caps0.get_group(1));/// Parse the given regular expression using the default configuration and/// return the corresponding one-pass DFA./// If you want a non-default configuration, then use the [`Builder`] to/// set your own configuration./// let re = DFA::new("foo[0-9]+bar")?;/// re.captures(&mut cache, "foo12345barzzz", &mut caps);/// assert_eq!(Some(Match::must(0, 0..11)), caps.get_match());/// Like `new`, but parses multiple patterns into a single "multi regex."/// This similarly uses the default regex configuration./// let re = DFA::new_many(&["[a-z]+", "[0-9]+"])?;/// re.captures(&mut cache, "abc123", &mut caps);/// assert_eq!(Some(Match::must(0, 0..3)), caps.get_match());/// re.captures(&mut cache, "123abc", &mut caps);new_from_nfa/// Like `new`, but builds a one-pass DFA directly from an NFA. This is/// useful if you already have an NFA, or even if you hand-assembled the/// This shows how to hand assemble a regular expression via its HIR,/// compile an NFA from it and build a one-pass DFA from the NFA./// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};/// let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![///     ClassBytesRange::new(b'0', b'9'),///     ClassBytesRange::new(b'A', b'Z'),///     ClassBytesRange::new(b'_', b'_'),///     ClassBytesRange::new(b'a', b'z'),/// ])));/// let config = NFA::config().nfa_size_limit(Some(1_000));/// let nfa = NFA::compiler().configure(config).build_from_hir(&hir)?;/// let re = DFA::new_from_nfa(nfa)?;/// let expected = Some(Match::must(0, 0..1));/// re.captures(&mut cache, "A", &mut caps);/// assert_eq!(expected, caps.get_match());/// Create a new one-pass DFA that matches every input./// let dfa = DFA::always_match()?;/// let mut cache = dfa.create_cache();/// let mut caps = dfa.create_captures();/// let expected = Match::must(0, 0..0);/// dfa.captures(&mut cache, "", &mut caps);/// assert_eq!(Some(expected), caps.get_match());/// dfa.captures(&mut cache, "foo", &mut caps);/// Create a new one-pass DFA that never matches any input./// use regex_automata::dfa::onepass::DFA;/// let dfa = DFA::never_match()?;/// Return a default configuration for a DFA./// This is a convenience routine to avoid needing to import the `Config`/// type when customizing the construction of a DFA./// This example shows how to change the match semantics of this DFA from/// its default "leftmost first" to "all." When using "all," non-greediness/// doesn't apply and neither does preference order matching. Instead, the/// longest match possible is always returned. (Although, by construction,/// it's impossible for a one-pass DFA to have a different answer for/// "preference order" vs "longest match.")/// use regex_automata::{dfa::onepass::DFA, Match, MatchKind};///     .build(r"(abc)+?")?;/// let mut cache = re.create_cache();/// let mut caps = re.create_captures();/// re.captures(&mut cache, "abcabc", &mut caps);/// // Normally, the non-greedy repetition would give us a 0..3 match./// assert_eq!(Some(Match::must(0, 0..6)), caps.get_match());/// Return a builder for configuring the construction of a DFA./// This example shows how to use the builder to disable UTF-8 mode./// let expected = Some(Match::must(0, 0..8));create_captures/// Create a new empty set of capturing groups that is guaranteed to be/// valid for the search APIs on this DFA./// A `Captures` value created for a specific DFA cannot be used with any/// other DFA./// This is a convenience function for [`Captures::all`]. See the/// [`Captures`] documentation for an explanation of its alternative/// constructors that permit the DFA to do less work during a search, and/// thus might make it faster.create_cache/// Create a new cache for this DFA./// The cache returned should only be used for searches for this/// DFA. If you want to reuse the cache for another DFA, then you/// must call [`Cache::reset`] with that DFA (or, equivalently,/// [`DFA::reset_cache`]).reset_cache/// Reset the given cache such that it can be used for searching with the/// this DFA (and only this DFA)./// A cache reset permits reusing memory already allocated in this cache/// with a different DFA./// This shows how to re-purpose a cache for use with a different DFA./// let re1 = DFA::new(r"\w")?;/// let re2 = DFA::new(r"\W")?;/// let mut caps1 = re1.create_captures();/// let mut caps2 = re2.create_captures();/// let mut cache = re1.create_cache();///     Some(Match::must(0, 0..2)),///     { re1.captures(&mut cache, "Δ", &mut caps1); caps1.get_match() },/// // Using 'cache' with re2 is not allowed. It may result in panics or/// // incorrect results. In order to re-purpose the cache, we must reset/// // it with the one-pass DFA we'd like to use it with./// // Similarly, after this reset, using the cache with 're1' is also not/// // allowed./// re2.reset_cache(&mut cache);///     Some(Match::must(0, 0..3)),///     { re2.captures(&mut cache, "☃", &mut caps2); caps2.get_match() },/// Return the config for this one-pass DFA.get_nfa/// Returns a reference to the underlying NFA./// In the case of a DFA that contains no patterns, this returns `0`./// Returns the total number of states in this one-pass DFA./// Note that unlike dense or sparse DFAs, a one-pass DFA does not expose/// a low level DFA API. Therefore, this routine has little use other than/// being informational./// That is, this returns the total number of transitions that each/// state in this DFA must have. The maximum alphabet size is 256, which/// corresponds to each possible byte value./// The alphabet size may be less than 256 though, and unless/// [`Config::byte_classes`] is disabled, it is typically must less than/// 256. Namely, bytes are grouped into equivalence classes such that no/// two bytes in the same class can distinguish a match from a non-match./// For example, in the regex `^[a-z]+$`, the ASCII bytes `a-z` could/// all be in the same equivalence class. This leads to a massive space/// savings./// Note also that unlike dense or sparse DFAs, a one-pass DFA does/// not have a special end-of-input (EOI) transition. This is because/// a one-pass DFA handles look-around assertions explicitly (like the/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM)) and does not build/// them into the transitions of the DFA./// The stride of a DFA is always equivalent to the smallest power of/// 2 that is greater than or equal to the DFA's alphabet length. This/// definition uses extra space, but possibly permits faster translation/// between state identifiers and their corresponding offsets in this DFA's/// while the maximum `stride2` value is `9` (corresponding to a stride/// of `512`). The maximum in theory should be `8`, but because of some/// implementation quirks that may be relaxed in the future, it is one more/// than `8`. (Do note that a maximal stride is incredibly rare, as it/// would imply that there is almost no redundant in the regex pattern.)/// compute that, use `std::mem::size_of::<onepass::DFA>()`./// Executes an anchored leftmost forward search, and returns true if and/// only if this one-pass DFA matches the given haystack./// This routine may short circuit if it knows that scanning future/// input will never lead to a different result. In particular, if the/// underlying DFA enters a match state, then this routine will return/// `true` immediately without inspecting any future input. (Consider how/// this might make a difference given the regex `a+` on the haystack/// `aaaaaaaaaaaaaaa`. This routine can stop after it sees the first `a`,/// but routines like `find` need to continue searching because `+` is/// greedy by default.)/// The given `Input` is forcefully set to use [`Anchored::Yes`] if the/// given configuration was [`Anchored::No`] (which is the default)./// This routine panics if the search could not complete. This can occur/// in the following circumstances:/// example, by providing an unsupported anchor mode. Concretely,/// this occurs when using [`Anchored::Pattern`] without enabling/// [`Config::starts_for_each_pattern`]./// When a search panics, callers cannot know whether a match exists or/// Use [`DFA::try_search`] if you want to handle these panics as error/// values instead./// This shows basic usage:/// assert!(re.is_match(&mut cache, "foo12345bar"));/// assert!(!re.is_match(&mut cache, "foobar"));/// # Example: consistency with search APIs/// `is_match` is guaranteed to return `true` whenever `captures` returns/// a match. This includes searches that are executed entirely within a/// codepoint:/// use regex_automata::{dfa::onepass::DFA, Input};/// let re = DFA::new("a*")?;/// assert!(!re.is_match(&mut cache, Input::new("☃").span(1..2)));/// Notice that when UTF-8 mode is disabled, then the above reports a/// match because the restriction against zero-width matches that split a/// codepoint has been lifted:/// use regex_automata::{dfa::onepass::DFA, nfa::thompson::NFA, Input};///     .thompson(NFA::config().utf8(false))///     .build("a*")?;/// assert!(re.is_match(&mut cache, Input::new("☃").span(1..2)));/// Executes an anchored leftmost forward search, and returns a `Match` if/// and only if this one-pass DFA matches the given haystack./// This routine only includes the overall match span. To get access to the/// individual spans of each capturing group, use [`DFA::captures`]./// Leftmost first match semantics corresponds to the match with the/// smallest starting offset, but where the end offset is determined by/// preferring earlier branches in the original regular expression. For/// example, `Sam|Samwise` will match `Sam` in `Samwise`, but `Samwise|Sam`/// will match `Samwise` in `Samwise`./// Generally speaking, the "leftmost first" match is how most backtracking/// regular expressions tend to work. This is in contrast to POSIX-style/// regular expressions that yield "leftmost longest" matches. Namely,/// both `Sam|Samwise` and `Samwise|Sam` match `Samwise` when using/// leftmost longest semantics. (This crate does not currently support/// leftmost longest semantics.)/// let re = DFA::new("foo[0-9]+")?;/// let expected = Match::must(0, 0..8);/// assert_eq!(Some(expected), re.find(&mut cache, "foo12345"));/// // match that prefers earlier parts of the pattern over later parts./// let re = DFA::new("abc|a")?;/// let expected = Match::must(0, 0..3);/// assert_eq!(Some(expected), re.find(&mut cache, "abc"));/// Executes an anchored leftmost forward search and writes the spans/// of capturing groups that participated in a match into the provided/// [`Captures`] value. If no match was found, then [`Captures::is_match`]/// is guaranteed to return `false`./// This shows a simple example of a one-pass regex that extracts/// capturing group spans./// let re = DFA::new(///     // Notice that we use ASCII here. The corresponding Unicode regex///     // is sadly not one-pass.///     "(?P<first>[[:alpha:]]+)[[:space:]]+(?P<last>[[:alpha:]]+)",/// re.captures(&mut cache, "Bruce Springsteen", &mut caps);/// assert_eq!(Some(Match::must(0, 0..17)), caps.get_match());/// assert_eq!(Some(Span::from(0..5)), caps.get_group(1));/// assert_eq!(Some(Span::from(6..17)), caps.get_group_by_name("last"));try_search/// The differences with [`DFA::captures`] are:/// 1. This returns an error instead of panicking if the search fails./// 2. Accepts an `&Input` instead of a `Into<Input>`. This permits reusing/// the same input for multiple searches, which _may_ be important for/// latency./// 3. This does not automatically change the [`Anchored`] mode from `No`/// to `Yes`. Instead, if [`Input::anchored`] is `Anchored::No`, then an/// This example shows how to build a multi-regex that permits searching/// for specific patterns. Note that this is somewhat less useful than/// in other regex engines, since a one-pass DFA by definition has no/// ambiguity about which pattern can match at a position. That is, if it/// were possible for two different patterns to match at the same starting/// position, then the multi-regex would not be one-pass and construction/// would have failed./// Nevertheless, this can still be useful if you only care about matches/// for a specific pattern, and want the DFA to report "no match" even if/// some other pattern would have matched./// Note that in order to make use of this functionality,/// [`Config::starts_for_each_pattern`] must be enabled. It is disabled/// by default since it may result in higher memory usage./// use regex_automata::{dfa::onepass::DFA, Anchored, Input, Match};/// // one-pass DFAs fully support Unicode word boundaries!/// // A sad joke is that a Unicode aware regex like \w+\s is not one-pass./// // :-(/// let re = DFA::new(r"\b[0-9]{3}\b")?;/// let haystack = "foo123bar";/// // Since we sub-slice the haystack, the search doesn't know about/// // the larger context and assumes that `123` is surrounded by word/// // to the sub-slice as well, which means we get `0..3` instead of/// // `3..6`./// let expected = Some(Match::must(0, 0..3));/// let input = Input::new(&haystack[3..6]).anchored(Anchored::Yes);/// let input = Input::new(haystack).range(3..6).anchored(Anchored::Yes);try_search_slots/// `slots`, and returns the matching pattern ID. The contents of the/// slots for patterns other than the matching pattern are unspecified. If/// no match was found, then `None` is returned and the contents of all/// `slots` is unspecified./// This is like [`DFA::try_search`], but it accepts a raw slots slice/// instead of a `Captures` value. This is useful in contexts where you/// don't want or need to allocate a `Captures`./// It is legal to pass _any_ number of slots to this routine. If the regex/// engine would otherwise write a slot offset that doesn't fit in the/// provided slice, then it is simply skipped. In general though, there are/// usually three slice lengths you might want to use:/// * An empty slice, if you only care about which pattern matched./// * A slice with/// [`pattern_len() * 2`](crate::dfa::onepass::DFA::pattern_len)/// slots, if you only care about the overall match spans for each matching/// [`slot_len()`](crate::util::captures::GroupInfo::slot_len) slots, which/// permits recording match offsets for every capturing group in every/// This example shows how to find the overall match offsets in a/// multi-pattern search without allocating a `Captures` value. Indeed, we/// can put our slots right on the stack./// use regex_automata::{dfa::onepass::DFA, Anchored, Input, PatternID};/// let re = DFA::new_many(&[///     r"[a-zA-Z]+",/// ])?;/// let input = Input::new("123").anchored(Anchored::Yes);/// // We only care about the overall match offsets here, so we just/// // allocate two slots for each pattern. Each slot records the start/// // and end of the match./// let mut slots = [None; 4];/// let pid = re.try_search_slots(&mut cache, &input, &mut slots)?;/// assert_eq!(Some(PatternID::must(1)), pid);/// // The overall match offsets are always at 'pid * 2' and 'pid * 2 + 1'./// // See 'GroupInfo' for more details on the mapping between groups and/// // slot indices./// let slot_start = pid.unwrap().as_usize() * 2;/// let slot_end = slot_start + 1;/// assert_eq!(Some(0), slots[slot_start].map(|s| s.get()));/// assert_eq!(Some(3), slots[slot_end].map(|s| s.get()));try_search_slots_impsearch_imp/// Assumes 'sid' is a match state and looks for whether a match can/// be reported. If so, appropriate offsets are written to 'slots' and/// 'matched_pid' is set to the matching pattern ID./// Even when 'sid' is a match state, it's possible that a match won't/// be reported. For example, when the conditional epsilon transitions/// leading to the match state aren't satisfied at the given position in/// the haystack./// Returns the anchored start state for matching any pattern in this DFA.start_pattern/// Returns the anchored start state for matching the given pattern. If/// 'starts_for_each_pattern'/// was not enabled, then this returns an error. If the given pattern is/// not in this DFA, then `Ok(None)` is returned./// Returns the transition from the given state ID and byte of input. The/// transition includes the next state ID, the slots that should be saved/// and any conditional epsilon transitions that must be satisfied in order/// to take this transition./// Set the transition from the given state ID and byte of input to the/// transition given.SparseTransitionIter/// Return an iterator of "sparse" transitions for the given state ID./// "sparse" in this context means that consecutive transitions that are/// equivalent are returned as one group, and transitions to the DEAD state/// are ignored./// This winds up being useful for debug printing, since it's much terser/// to display runs of equivalent transitions than the transition for every/// possible byte value. Indeed, in practice, it's very common for runs/// of equivalent transitions to appear.pattern_epsilonsPatternEpsilons/// Return the pattern epsilons for the given state ID./// If the given state ID does not correspond to a match state ID, then the/// pattern epsilons returned is empty.set_pattern_epsilons/// Set the pattern epsilons for the given state ID./// Returns the state ID prior to the one given. This returns None if the/// given ID is the first DFA state.last_state_id/// Returns the state ID of the last state in this DFA's transition table./// "last" in this context means the last state to appear in memory, i.e.,/// the one with the greatest ID./// Move the transitions from 'id1' to 'id2' and vice versa./// WARNING: This does not update the rest of the transition table to have/// transitions to 'id1' changed to 'id2' and vice versa. This merely moves/// the states in memory./// Map all state IDs in this DFA (transition table + start states)/// according to the closure given./// An iterator over groups of consecutive equivalent transitions in a singleexplicit_slots/// Scratch space used to store slots during a search. Basically, we use/// the caller provided slots to store slots known when a match occurs./// But after a match occurs, we might continue a search but ultimately/// fail to extend the match. When continuing the search, we need some/// place to store candidate capture offsets without overwriting the slot/// offsets recorded for the most recently seen match.explicit_slot_len/// The number of slots in the caller-provided 'Captures' value for the/// current search. This is always at most 'explicit_slots.len()', but/// might be less than it, if the caller provided fewer slots to fill./// A cache represents mutable state that a one-pass [`DFA`] requires during a/// For a given one-pass DFA, its corresponding cache may be created either via/// [`DFA::create_cache`], or via [`Cache::new`]. They are equivalent in every/// way, except the former does not require explicitly importing `Cache`./// A particular `Cache` is coupled with the one-pass DFA from which it was/// created. It may only be used with that one-pass DFA. A cache and its/// allocations may be re-purposed via [`Cache::reset`], in which case, it can/// only be used with the new one-pass DFA (and not the old one)./// Create a new [`onepass::DFA`](DFA) cache./// A potentially more convenient routine to create a cache is/// [`DFA::create_cache`], as it does not require also importing the/// `Cache` type./// If you want to reuse the returned `Cache` with some other one-pass DFA,/// then you must call [`Cache::reset`] with the desired one-pass DFA./// Reset this cache such that it can be used for searching with a/// different [`onepass::DFA`](DFA)./// with a different one-pass DFA./// This shows how to re-purpose a cache for use with a different one-pass/// Returns the heap memory usage, in bytes, of this cache./// This does **not** include the stack size used up by this cache. To/// compute that, use `std::mem::size_of::<Cache>()`.setup_search/// Represents a single transition in a one-pass DFA./// The high 21 bits corresponds to the state ID. The bit following corresponds/// to the special "match wins" flag. The remaining low 42 bits corresponds to/// the transition epsilons, which contains the slots that should be saved when/// this transition is followed and the conditional epsilon transitions that/// must be satisfied in order to follow this transition.STATE_ID_BITSSTATE_ID_SHIFTSTATE_ID_LIMITMATCH_WINS_SHIFTINFO_MASK/// Return a new transition to the given state ID with the given epsilons./// Returns true if and only if this transition points to the DEAD state.match_wins/// Return whether this transition has a "match wins" property./// When a transition has this property, it means that if a match has been/// found and the search uses leftmost-first semantics, then that match/// should be returned immediately instead of continuing on./// The "match wins" name comes from RE2, which uses a pretty much/// identical mechanism for implementing leftmost-first semantics.state_id/// Return the "next" state ID that this transition points to.set_state_id/// Set the "next" state ID in this transition.epsilons/// Return the epsilons embedded in this transition./// A representation of a match state's pattern ID along with the epsilons for/// when a match occurs./// A match state in a one-pass DFA, unlike in a more general DFA, has exactly/// one pattern ID. If it had more, then the original NFA would not have been/// one-pass./// The "epsilons" part of this corresponds to what was found in the epsilon/// transitions between the transition taken in the last byte of input and the/// ultimate match state. This might include saving slots and/or conditional/// epsilon transitions that must be satisfied before one can report the match./// Technically, every state has room for a 'PatternEpsilons', but it is only/// ever non-empty for match states.PATTERN_ID_BITSPATTERN_ID_SHIFTPATTERN_ID_NONE// A sentinel value indicating that this is not a match state. We don't// use 0 since 0 is a valid pattern ID.PATTERN_ID_LIMITPATTERN_ID_MASKEPSILONS_MASK/// Return a new empty pattern epsilons that has no pattern ID and has no/// epsilons. This is suitable for non-match states./// Whether this pattern epsilons is empty or not. It's empty when it has/// no pattern ID and an empty epsilons./// Return the pattern ID in this pattern epsilons if one exists.pattern_id_unchecked/// Returns the pattern ID without checking whether it's valid. If this is/// called and there is no pattern ID in this `PatternEpsilons`, then this/// will likely produce an incorrect result or possibly even a panic or/// an overflow. But safety will not be violated./// This is useful when you know a particular state is a match state. If/// it's a match state, then it must have a pattern ID.set_pattern_id/// Return a new pattern epsilons with the given pattern ID, but the same/// epsilons./// Return the epsilons part of this pattern epsilons.set_epsilons/// Return a new pattern epsilons with the given epsilons, but the same/// pattern ID./// Epsilons represents all of the NFA epsilons transitions that went into a/// single transition in a single DFA state. In this case, it only represents/// the epsilon transitions that have some kind of non-consuming side effect:/// either the transition requires storing the current position of the search/// into a slot, or the transition is conditional and requires the current/// position in the input to satisfy an assertion before the transition may be/// taken./// This folds the cumulative effect of a group of NFA states (all connected/// by epsilon transitions) down into a single set of bits. While these bits/// can represent all possible conditional epsilon transitions, it only permits/// storing up to a somewhat small number of slots./// Epsilons is represented as a 42-bit integer. For example, it is packed into/// the lower 42 bits of a `Transition`. (Where the high 22 bits contains a/// `StateID` and a special "match wins" property.)SLOT_MASKSLOT_SHIFTLOOK_MASK/// Create a new empty epsilons. It has no slots and no assertions that/// need to be satisfied./// Returns true if this epsilons contains no slots and no assertions./// Returns the slot epsilon transitions.set_slots/// Set the slot epsilon transitions.looks/// Return the set of look-around assertions in these epsilon transitions.set_looks/// Set the look-around assertions on these epsilon transitions./// The set of epsilon transitions indicating that the current position in a/// search should be saved to a slot./// This *only* represents explicit slots. So for example, the pattern/// `[a-z]+([0-9]+)([a-z]+)` has:/// * 3 capturing groups, thus 6 slots./// * 1 implicit capturing group, thus 2 implicit slots./// * 2 explicit capturing groups, thus 4 explicit slots./// While implicit slots are represented by epsilon transitions in an NFA, we/// do not explicitly represent them here. Instead, implicit slots are assumed/// to be present and handled automatically in the search code. Therefore,/// that means we only need to represent explicit slots in our epsilon/// Its representation is a bit set. The bit 'i' is set if and only if there/// exists an explicit slot at index 'c', where 'c = (#patterns * 2) + i'. That/// is, the bit 'i' corresponds to the first explicit slot and the first/// explicit slot appears immediately following the last implicit slot. (If/// this is confusing, see `GroupInfo` for more details on how slots works.)/// A single `Slots` represents all the active slots in a sub-graph of an NFA,/// where all the states are connected by epsilon transitions. In effect, when/// traversing the one-pass DFA during a search, all slots set in a particular/// transition must be captured by recording the current search position./// The API of `Slots` requires the caller to handle the explicit slot offset./// That is, a `Slots` doesn't know where the explicit slots start for a/// particular NFA. Thus, if the callers see's the bit 'i' is set, then they/// need to do the arithmetic above to find 'c', which is the real actual slot/// index in the corresponding NFA./// Insert the slot at the given bit index./// Remove the slot at the given bit index./// Returns true if and only if this set contains no slots.SlotsIter/// Returns an iterator over all of the set bits in this set./// For the position `at` in the current haystack, copy it to/// `caller_explicit_slots` for all slots that are in this set./// Callers may pass a slice of any length. Slots in this set bigger than/// the length of the given explicit slots are simply skipped./// The slice *must* correspond only to the explicit slots and the first/// element of the slice must always correspond to the first explicit slot/// in the corresponding NFA./// An iterator over all of the bits set in a slot set./// This returns the bit index that is set, so callers may need to offset it/// to get the actual NFA slot index./// An error that occurred during the construction of a one-pass DFA./// * Access an underlying [`thompson::BuildError`] type from its `source`/// method via the `std::error::Error` trait. This error only occurs when using/// convenience routines for building a one-pass DFA directly from a patternTooManyPatternsUnsupportedLookExceededSizeLimitNotOnePass/// The kind of error that occurred during the construction of a one-pass DFA.too_many_patternsunsupported_lookexceeded_size_limitnot_one_passfail_conflicting_transitionfail_multiple_epsilonfail_multiple_matchmax_slots// This test is meant to build a one-pass regex with the maximum number of// possible slots.// NOTE: Remember that the slot limit only applies to explicit capturing// groups. Any number of implicit capturing groups is supported (up to the// maximum number of supported patterns), since implicit groups are handled// by the search loop itself.// This test ensures that the one-pass DFA works with all look-around// assertions that we expect it to work with.// The utility of this test is that each one-pass transition has a small// amount of space to store look-around assertions. Currently, there is// logic in the one-pass constructor to ensure there aren't more than ten// possible assertions. And indeed, there are only ten possible assertions// (at time of writing), so this is okay. But conceivably, more assertions// could be added. So we check that things at least work with what we// expect them to work with.is_one_pass// takes too long on miriis_not_one_passis_not_one_pass_bigger/*!
A DFA that can return spans for matching capturing groups.

This module is the home of a [one-pass DFA](DFA).

This module also contains a [`Builder`] and a [`Config`] for building and
configuring a one-pass DFA.
*/// A note on naming and credit:// As far as I know, Russ Cox came up with the practical vision and// implementation of a "one-pass regex engine." He mentions and describes it// briefly in the third article of his regexp article series:// https://swtch.com/~rsc/regexp/regexp3.html// Cox's implementation is in RE2, and the implementation below is most// heavily inspired by RE2's. The key thing they have in common is that// their transitions are defined over an alphabet of bytes. In contrast,// Go's regex engine also has a one-pass engine, but its transitions are// more firmly rooted on Unicode codepoints. The ideas are the same, but the// implementations are different.// RE2 tends to call this a "one-pass NFA." Here, we call it a "one-pass DFA."// They're both true in their own ways:// * The "one-pass" criterion is generally a property of the NFA itself. In// particular, it is said that an NFA is one-pass if, after each byte of input// during a search, there is at most one "VM thread" remaining to take for the// next byte of input. That is, there is never any ambiguity as to the path to// take through the NFA during a search.// * On the other hand, once a one-pass NFA has its representation converted// to something where a constant number of instructions is used for each byte// of input, the implementation looks a lot more like a DFA. It's technically// more powerful than a DFA since it has side effects (storing offsets inside// of slots activated by a transition), but it is far closer to a DFA than an// NFA simulation.// Thus, in this crate, we call it a one-pass DFA.define_regex_type// When the alloc feature is enabled, the regex type sets its A type parameter// to default to an owned dense DFA. But without alloc, we set no default. This// makes things a lot more convenient in the common case, since writing out the// DFA types is pretty annoying.// Since we have two different definitions but only want to write one doc// string, we use a macro to capture the doc and other attributes once and then// repeat them for each definition./// return the corresponding regex./// use regex_automata::{Match, dfa::regex::Regex};/// let re = Regex::new("foo[0-9]+bar")?;///     Some(Match::must(0, 3..14)),///     re.find(b"zzzfoo12345barzzz"),/// Like `new`, but parses multiple patterns into a single "regex set."/// let re = Regex::new_many(&["[a-z]+", "[0-9]+"])?;/// let mut it = re.find_iter(b"abc 1 foo 4567 0 quux");/// assert_eq!(Some(Match::must(0, 0..3)), it.next());/// assert_eq!(Some(Match::must(1, 4..5)), it.next());/// assert_eq!(Some(Match::must(0, 6..9)), it.next());/// assert_eq!(Some(Match::must(1, 10..14)), it.next());/// assert_eq!(Some(Match::must(1, 15..16)), it.next());/// assert_eq!(Some(Match::must(0, 17..21)), it.next());new_sparse/// Parse the given regular expression using the default configuration,/// except using sparse DFAs, and return the corresponding regex./// let re = Regex::new_sparse("foo[0-9]+bar")?;new_many_sparse/// Like `new`, but parses multiple patterns into a single "regex set"/// using sparse DFAs. This otherwise similarly uses the default regex/// let re = Regex::new_many_sparse(&["[a-z]+", "[0-9]+"])?;/// Return a builder for configuring the construction of a `Regex`./// This example shows how to use the builder to disable UTF-8 mode/// everywhere.///     dfa::regex::Regex, nfa::thompson, util::syntax, Match,/// let re = Regex::builder()/// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";/// let expected = Some(Match::must(0, 1..9));/// let got = re.find(haystack);/// Convenience routines for regex construction./// Returns true if and only if this regex matches the given haystack./// This routine may short circuit if it knows that scanning future input/// will never lead to a different result. In particular, if the underlying/// DFA enters a match state or a dead state, then this routine will return/// `true` or `false`, respectively, without inspecting any future input./// Use [`Regex::try_search`] if you want to handle these error conditions./// use regex_automata::dfa::regex::Regex;/// assert_eq!(true, re.is_match("foo12345bar"));/// assert_eq!(false, re.is_match("foobar"));/// Returns the start and end offset of the leftmost match. If no match/// exists, then `None` is returned./// // Greediness is applied appropriately./// let re = Regex::new("foo[0-9]+")?;/// assert_eq!(Some(Match::must(0, 3..11)), re.find("zzzfoo12345zzz"));/// // the default leftmost-first match semantics demand that we find the/// // earliest match that prefers earlier parts of the pattern over latter/// // parts./// let re = Regex::new("abc|a")?;/// assert_eq!(Some(Match::must(0, 0..3)), re.find("abc"));/// Returns an iterator over all non-overlapping leftmost matches in the/// given bytes. If no match exists, then the iterator yields no elements./// This corresponds to the "standard" regex search iterator./// If the search returns an error during iteration, then iteration/// panics. See [`Regex::find`] for the panic conditions./// Use [`Regex::try_search`] with/// [`util::iter::Searcher`](crate::util::iter::Searcher) if you want to/// handle these error conditions./// let text = "foo1 foo12 foo123";/// let matches: Vec<Match> = re.find_iter(text).collect();///     Match::must(0, 0..4),///     Match::must(0, 5..10),///     Match::must(0, 11..17),/// Standard search routines for finding and iterating over matches./// This is like [`Regex::find`] but with two differences:/// 1. It is not generic over `Into<Input>` and instead accepts a/// `&Input`. This permits reusing the same `Input` for multiple searches/// without needing to create a new one. This _may_ help with latency./// 2. It returns an error if the search could not complete where as/// [`Regex::find`] will panic./// Returns true if either the given input specifies an anchored search/// or if the underlying DFA is always anchored./// Lower level fallible search routines that permit controlling where the/// search starts and ends in a particular sequence./// Return the underlying DFA responsible for forward matching./// This is useful for accessing the underlying DFA and converting it to/// some other format or size. See the [`Builder::build_from_dfas`] docs/// for an example of where this might be useful./// Return the underlying DFA responsible for reverse matching./// Returns the total number of patterns matched by this regex./// let re = Regex::new_many(&[r"[a-z]+", r"[0-9]+", r"\w+"])?;/// assert_eq!(3, re.pattern_len());/// Non-search APIs for querying information about the regex and setting a/// An iterator over all non-overlapping matches for an infallible search./// The iterator yields a [`Match`] value until no more matches could be found./// If the underlying regex engine returns an error, then a panic occurs./// The type parameters are as follows:/// * `A` represents the type of the underlying DFA that implements the/// [`Automaton`] trait./// * `'h` represents the lifetime of the haystack being searched./// * `'r` represents the lifetime of the regex object itself./// This iterator can be created with the [`Regex::find_iter`] method./// A builder for a regex based on deterministic finite automatons./// NFA construction, the DFA construction and finally the regex searching/// itself. This builder is different from a general purpose regex builder in/// that it permits fine grain configuration of the construction process. The/// trade off for this is complexity, and the possibility of setting a/// configuration that might not make sense. For example, there are two/// different UTF-8 modes:/// * [`thompson::Config::utf8`](crate::nfa::thompson::Config::utf8) controls/// how the regex iterators themselves advance the starting position of the/// next search when a match with zero length is found./// Internally, building a regex requires building two DFAs, where one is/// responsible for finding the end of a match and the other is responsible/// for finding the start of a match. If you only need to detect whether/// something matched, or only the end of a match, then you should use a/// [`dense::Builder`] to construct a single DFA, which is cheaper than/// building two DFAs./// # Build methods/// This builder has a few "build" methods. In general, it's the result of/// combining the following parameters:/// * Building one or many regexes./// * Building a regex with dense or sparse DFAs./// The simplest "build" method is [`Builder::build`]. It accepts a single/// pattern and builds a dense DFA using `usize` for the state identifier/// The most general "build" method is [`Builder::build_many`], which permits/// building a regex that searches for multiple patterns simultaneously while/// using a specific state identifier representation./// The most flexible "build" method, but hardest to use, is/// [`Builder::build_from_dfas`]. This exposes the fact that a [`Regex`] is/// just a pair of DFAs, and this method allows you to specify those DFAs/// exactly./// This example shows how to disable UTF-8 mode in the syntax and the regex/// itself. This is generally what you want for matching on arbitrary bytes./// assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap().range()]);/// Create a new regex builder with the default configuration./// Build a regex from the given pattern.build_sparse/// Build a regex from the given pattern using sparse DFAs./// Build a regex from the given patterns.build_many_sparse/// Build a sparse regex from the given patterns.build_from_dfas/// Build a regex from its component forward and reverse DFAs./// This is useful when deserializing a regex from some arbitrary/// memory region. This is also useful for building regexes from other/// types of DFAs./// If you're building the DFAs from scratch instead of building new DFAs/// from other DFAs, then you'll need to make sure that the reverse DFA is/// configured correctly to match the intended semantics. Namely:/// * It should be anchored./// * It should use [`MatchKind::All`] semantics./// * It should match in reverse./// * Otherwise, its configuration should match the forward DFA./// If these conditions aren't satisfied, then the behavior of searches is/// Note that when using this constructor, no configuration is applied./// Since this routine provides the DFAs to the builder, there is no/// opportunity to apply other configuration options./// This example is a bit a contrived. The usual use of these methods/// would involve serializing `initial_re` somewhere and then deserializing/// it later to build a regex. But in this case, we do everything in/// memory./// let initial_re = Regex::new("foo[0-9]+")?;/// assert_eq!(true, initial_re.is_match(b"foo123"));/// let (fwd, rev) = (initial_re.forward(), initial_re.reverse());/// let re = Regex::builder().build_from_dfas(fwd, rev);/// assert_eq!(true, re.is_match(b"foo123"));/// This example shows how to build a `Regex` that uses sparse DFAs instead/// of dense DFAs without using one of the convenience `build_sparse`/// routines:/// let fwd = initial_re.forward().to_sparse()?;/// let rev = initial_re.reverse().to_sparse()?;/// Set the dense DFA compilation configuration for this builder using/// [`dense::Config`]./// This permits setting things like whether the underlying DFAs should/// be minimized./*!
A DFA-backed `Regex`.

This module provides [`Regex`], which is defined generically over the
[`Automaton`] trait. A `Regex` implements convenience routines you might have
come to expect, such as finding the start/end of a match and iterating over
all non-overlapping matches. This `Regex` type is limited in its capabilities
to what a DFA can provide. Therefore, APIs involving capturing groups, for
example, are not provided.

Internally, a `Regex` is composed of two DFAs. One is a "forward" DFA that
finds the end offset of a match, where as the other is a "reverse" DFA that
find the start offset of a match.

See the [parent module](crate::dfa) for examples.
*//// Return the power-of-2 exponent that yields the stride. The pertinent/// laws here are, where N=stride2: 2^N=stride and len(alphabet) <= stride./// It is expected that, after calling this, the underlying value will be/// left in an inconsistent state, since any other transitions pointing to,/// e.g., `id1` need to be updated to point to `id2`, since that's where/// `id1` moved to.idxmap/// A mapper from state index to state ID (and back)./// The reason why this exists is because state IDs are "premultiplied." That/// is, in order to get to the transitions for a particular state, one need/// only use the state ID as-is, instead of having to multiple it by transition/// table's stride./// `0`, `0+stride`, `0+2*stride`, `0+3*stride`, etc., instead of `0`, `1`,/// `2`, `3`, etc.find_fwd_impfind_rev_impfind_overlapping_fwdfind_overlapping_fwd_impfind_overlapping_revinit_fwdinit_reveoi_fwdeoi_revprefilter_restart/// Re-compute the starting state that a DFA should be in after finding a/// prefilter candidate match at the position `at`./// The function with the same name has a bit more docs in hybrid/search.rs.Transitions// When compared to a dense DFA, a sparse DFA *looks* a lot simpler// representation-wise. In reality, it is perhaps more complicated. Namely,// in a dense DFA, all information needs to be very cheaply accessible// using only state IDs. In a sparse DFA however, each state uses a// variable amount of space because each state encodes more information// than just its transitions. Each state also includes an accelerator if// one exists, along with the matching pattern IDs if the state is a match// That is, a lot of the complexity is pushed down into how each state// itself is represented./// A sparse deterministic finite automaton (DFA) with variable sized states./// In contrast to a [dense::DFA], a sparse DFA uses a more space efficient/// representation for its transitions. Consequently, sparse DFAs may use much/// less memory than dense DFAs, but this comes at a price. In particular,/// reading the more space efficient transitions takes more work, and/// consequently, searching using a sparse DFA is typically slower than a dense/// A sparse DFA can be built using the default configuration via the/// [`DFA::new`] constructor. Otherwise, one can configure various aspects of a/// dense DFA via [`dense::Builder`], and then convert a dense DFA to a sparse/// DFA using [`dense::DFA::to_sparse`]./// In general, a sparse DFA supports all the same search operations as a dense/// Making the choice between a dense and sparse DFA depends on your specific/// work load. If you can sacrifice a bit of search time performance, then a/// sparse DFA might be the best choice. In particular, while sparse DFAs are/// probably always slower than dense DFAs, you may find that they are easily/// fast enough for your purposes!/// A `DFA` has one type parameter, `T`, which is used to represent the parts/// of a sparse DFA. `T` is typically a `Vec<u8>` or a `&[u8]`./// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};/// return the corresponding sparse DFA./// [`dense::Builder`] to set your own configuration, and then call/// [`dense::DFA::to_sparse`] to create a sparse DFA./// use regex_automata::{dfa::{Automaton, sparse}, HalfMatch, Input};/// let dfa = sparse::DFA::new("foo[0-9]+bar")?;/// let dfa = sparse::DFA::new_many(&["[0-9]+", "[a-z]+"])?;///     dfa::{Automaton, sparse},/// let dfa = sparse::DFA::always_match()?;/// Create a new sparse DFA that never matches any input./// use regex_automata::{dfa::{Automaton, sparse}, Input};/// let dfa = sparse::DFA::never_match()?;from_dense/// The implementation for constructing a sparse DFA from a dense DFA./// Cheaply return a borrowed version of this sparse DFA. Specifically, the/// DFA returned always uses `&[u8]` for its transitions./// returned always uses `Vec<u8>` for its transitions./// Effectively, this returns a sparse DFA whose transitions live on the/// heap./// accept a [`Anchored::Pattern`] if and only if this method returns true./// Otherwise, an error will be returned./// Note that if the DFA is empty, this always returns false./// Unless [`dense::Config::byte_classes`] was disabled, it is possible/// that multiple distinct bytes are grouped into the same equivalence/// class if it is impossible for them to discriminate between a match and/// a non-match. This has the effect of reducing the overall alphabet size/// compute that, use `std::mem::size_of::<sparse::DFA>()`./// Note that unlike a [`dense::DFA`]'s serialization methods, this does/// not add any initial padding to the returned bytes. Padding isn't/// required for sparse DFAs since they have no alignment requirements./// let buf = original_dfa.to_bytes_native_endian();/// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf)?.0;/// // Create a 4KB buffer on the stack to store our serialized DFA./// let mut buf = [0u8; 4 * (1<<10)];/// let written = original_dfa.write_to_native_endian(&mut buf)?;/// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf[..written])?.0;/// result in a serialization error./// a sparse DFA./// Routines for converting a sparse DFA to other representations, such as raw/// bytes suitable for persistent storage./// Safely deserialize a sparse DFA with a specific state identifier/// For safety purposes, the DFA's transitions will be verified such that/// every transition points to a valid state. If this verification is too/// costly, then a [`DFA::from_bytes_unchecked`] API is provided, which/// The `to_bytes` methods allocate and return a `Vec<u8>` for you. The/// `write_to` methods do not allocate and write to an existing slice/// (which may be on the stack). Since deserialization always uses the/// native endianness of the target platform, the serialization API you use/// should match the endianness of the target platform. (It's often a good/// idea to generate serialized DFAs for both forms of endianness and then/// load the correct one based on endianness.)/// Note that unlike deserializing a [`dense::DFA`], deserializing a sparse/// DFA has no alignment requirements. That is, an alignment of `1` is/// let bytes = initial.to_bytes_native_endian();/// let dfa: DFA<&[u8]> = DFA::from_bytes(&bytes)?.0;/// # Example: loading a DFA from static memory/// One use case this library supports is the ability to serialize a/// DFA to disk and then use `include_bytes!` to store it in a compiled/// Rust program. Those bytes can then be cheaply deserialized into a/// `DFA` structure at runtime and used for searching without having to/// re-compile the DFA (which can be quite costly)./// We can show this in two parts. The first part is serializing the DFA to/// a file:/// use regex_automata::dfa::sparse::DFA;/// // Write a big endian serialized version of this DFA to a file./// let bytes = dfa.to_bytes_big_endian();/// std::fs::write("foo.bigendian.dfa", &bytes)?;/// let bytes = dfa.to_bytes_little_endian();/// std::fs::write("foo.littleendian.dfa", &bytes)?;/// compilation to choose the correct endianness. We do not need to employ/// any special tricks to ensure a proper alignment, since a sparse DFA has/// no alignment requirements.///     dfa::{Automaton, sparse::DFA},///     util::lazy::Lazy,/// static RE: Lazy<DFA<&'static [u8]>> = Lazy::new(|| {///     #[cfg(target_endian = "big")]///     static BYTES: &[u8] = include_bytes!("foo.bigendian.dfa");///     #[cfg(target_endian = "little")]///     static BYTES: &[u8] = include_bytes!("foo.littleendian.dfa");///     # static BYTES: &[u8] = b"";///     let (dfa, _) = DFA::from_bytes(BYTES)/// Alternatively, consider using/// [`lazy_static`](https://crates.io/crates/lazy_static)/// or/// [`once_cell`](https://crates.io/crates/once_cell),/// which will guarantee safety for you./// sparse transitions./// a DFA that exhibits undefined behavior if its transitions contains/// This routine is useful if you need to deserialize a DFA cheaply and/// cannot afford the transition validation performed by `from_bytes`./// This routine is not safe because it permits callers to provide/// arbitrary transitions with possibly incorrect state identifiers. While/// the various serialization routines will never return an incorrect/// DFA, there is no guarantee that the bytes provided here are correct./// While `from_bytes_unchecked` will still do several forms of basic/// validation, this routine does not check that the transitions themselves/// are correct. Given an incorrect transition table, it is possible for/// the search routines to access out-of-bounds memory because of explicit/// bounds check elision./// let dfa: DFA<&[u8]> = unsafe { DFA::from_bytes_unchecked(&bytes)?.0 };// This is marked as inline to help dramatically boost sparse searching,// which decodes each state it enters to follow the next transition./// The raw encoding of each state in this DFA./// Each state has the following information:/// * A set of transitions to subsequent states. Transitions to the dead///   state are omitted./// * If the state can be accelerated, then any additional accelerator///   information./// * If the state is a match state, then the state contains all pattern///   IDs that match when in that state./// To decode a state, use Transitions::state./// In practice, T is either Vec<u8> or &[u8]./// stride and is documented above./// The only time the number of equivalence classes is fewer than 257 is/// if the DFA's kind uses byte classes which is the default. Equivalence/// N.B. Equivalence classes aren't particularly useful in a sparse DFA/// in the current implementation, since equivalence classes generally tend/// to correspond to continuous ranges of bytes that map to the same/// transition. So in a sparse DFA, equivalence classes don't really lead/// to a space savings. In the future, it would be good to try and remove/// them from sparse DFAs entirely, but requires a bit of work since sparse/// DFAs are built from dense DFAs, which are in turn built on top of/// The total number of states in this DFA. Note that a DFA always has at/// least one state---the dead state---even the empty DFA. In particular,/// the dead state always has ID 0 and is correspondingly always the first/// state. The dead state is never a match state./// The transition table portion of a sparse DFA./// Unlike a typical dense table based DFA, states in a sparse transition/// table have variable size. That is, states with more transitions use more/// space than states with fewer transitions. This means that finding the next/// transition takes more work than with a dense DFA, but also typically uses/// much less space.Seen/// Converts these transitions to a borrowed value./// Converts these transitions to an owned value./// Return a convenient representation of the given state./// This panics if the state is invalid./// This is marked as inline to help dramatically boost sparse searching,/// which decodes each state it enters to follow the next transition. Other/// functions involved are also inlined, which should hopefully eliminate/// a lot of the extraneous decoding that is never needed just to follow/// the next transition.try_state/// Like `state`, but will return an error if the state encoding is/// invalid. This is useful for verifying states after deserialization,/// which is required for a safe deserialization API./// Note that this only verifies that this state is decodable and that/// all of its data is consistent. It does not verify that its state ID/// transitions point to valid states themselves, nor does it verify that/// every pattern ID is valid./// Return an iterator over all of the states in this DFA./// The iterator returned yields tuples, where the first element is the/// state ID and the second element is the state itself./// Returns the sparse transitions as raw bytes.id_len/// Returns the number of bytes represented by a single state ID./// Return the memory usage, in bytes, of these transitions./// This does not include the size of a `Transitions` value itself.StateMut/// Return a convenient mutable representation of the given state.sparse_mut/// Returns the sparse transitions as raw mutable bytes./// The initial start state IDs as a contiguous table of native endian/// encoded integers, represented by `S`./// In practice, T is either Vec<u8> or &[u8] and has no alignment/// See the eponymous type in the `dense` module for more details. This type/// is very similar to `dense::StartTable`, except that its underlying/// representation is `&[u8]` instead of `&[S]`. (The latter would require/// sparse DFAs to be aligned, which is explicitly something we do not require/// because we don't really need it.)from_dense_dfa/// Validates that every starting state ID in this table is valid./// That is, every starting state ID can be used to correctly decode a/// state in the DFA's sparse transitions./// Return the start state for the given index and pattern ID. If the/// pattern ID is None, then the corresponding start state for the entire/// DFA is returned. If the pattern ID is not None, then the corresponding/// starting state for the given pattern is returned. If this start table/// does not have individual starting states for each pattern, then this/// Return an iterator over all start IDs in this table./// Returns the total number of start state IDs in this table./// Returns the table as a raw slice of bytes./// This does not include the size of a `StartTable` value itself./// An iterator over all state state IDs in a sparse DFA./// An iterator over all states in a sparse DFA./// This iterator yields tuples, where the first element is the state ID and/// the second element is the state itself./// The identifier of this state./// Whether this is a match state or not.ntrans/// The number of transitions in this state.input_ranges/// Pairs of input ranges, where there is one pair for each transition./// Each pair specifies an inclusive start and end byte range for the/// corresponding transition./// Transitions to the next state. This slice contains native endian/// encoded state identifiers, with `S` as the representation. Thus, there/// are `ntrans * size_of::<S>()` bytes in this slice./// If this is a match state, then this contains the pattern IDs that match/// when the DFA is in this state./// This is a contiguous sequence of 32-bit native endian encoded integers./// An accelerator for this state, if present. If this state has no/// accelerator, then this is an empty slice. When non-empty, this slice/// has length at most 3 and corresponds to the exhaustive set of bytes/// that must be seen in order to transition out of this state./// A representation of a sparse DFA state that can be cheaply materialized/// from a state identifier./// Searches for the next transition given an input byte. If no such/// transition could be found, then a dead state is returned./// which decodes each state it enters to follow the next transition.next_eoi/// Returns the next state ID for the special EOI transition./// Returns the inclusive input byte range for the ith transition in thisnext_at/// Returns the next state for the ith transition in this state./// Returns the pattern ID for the given match index. If the match index/// is invalid, then this panics./// Returns the total number of pattern IDs for this state. This is always/// zero when `is_match` is false./// Return an accelerator for this state./// Write the raw representation of this state to the given buffer using/// the given endianness./// Return the total number of bytes that this state consumes in its/// encoded form./// A representation of a mutable sparse DFA state that can be cheaply/// materialized from a state identifier.set_next_at/// Sets the ith transition to the given state.// In order to validate everything, we not only need to make sure we// can decode every state, but that every transition in every state// points to a valid state. There are many duplicative transitions, so// we record state IDs that we've verified so that we don't redo the// decoding work.// Except, when in no_std mode, we don't have dynamic memory allocation// available to us, so we skip this optimization. It's not clear// whether doing something more clever is worth it just yet. If you're// profiling this code and need it to run faster, please file an issue.// OK, so we also use this to record the set of valid state IDs. Since// it is possible for a transition to point to an invalid state ID that// still (somehow) deserializes to a valid state. So we need to make// sure our transitions are limited to actually correct state IDs.// The problem is, I'm not sure how to do this verification step in// no-std no-alloc mode. I think we'd *have* to store the set of valid// state IDs in the DFA itself. For now, we don't do this verification// in no-std no-alloc mode. The worst thing that can happen is an// incorrect result. But no panics or memory safety problems should// result. Because we still do validate that the state itself is// "valid" in the sense that everything it points to actually exists.// ---AGheuristic_unicode_forward// See the analogous test in src/hybrid/dfa.rs and src/dfa/dense.rs./*!
Types and routines specific to sparse DFAs.

This module is the home of [`sparse::DFA`](DFA).

Unlike the [`dense`] module, this module does not contain a builder or
configuration specific for sparse DFAs. Instead, the intended way to build a
sparse DFA is either by using a default configuration with its constructor
[`sparse::DFA::new`](DFA::new), or by first configuring the construction of a
dense DFA with [`dense::Builder`] and then calling [`dense::DFA::to_sparse`].
For example, this configures a sparse DFA to do an overlapping search:

```
use regex_automata::{
    dfa::{Automaton, OverlappingState, dense},
    HalfMatch, Input, MatchKind,
};

let dense_re = dense::Builder::new()
    .configure(dense::Config::new().match_kind(MatchKind::All))
    .build(r"Samwise|Sam")?;
let sparse_re = dense_re.to_sparse()?;

// Setup our haystack and initial start state.
let input = Input::new("Samwise");
let mut state = OverlappingState::start();

// First, 'Sam' will match.
sparse_re.try_search_overlapping_fwd(&input, &mut state)?;
assert_eq!(Some(HalfMatch::must(0, 3)), state.get_match());

// And now 'Samwise' will match.
sparse_re.try_search_overlapping_fwd(&input, &mut state)?;
assert_eq!(Some(HalfMatch::must(0, 7)), state.get_match());
# Ok::<(), Box<dyn std::error::Error>>(())
```
*//*
/// A binary search routine specialized specifically to a sparse DFA state's
/// transitions. Specifically, the transitions are defined as a set of pairs
/// of input bytes that delineate an inclusive range of bytes. If the input
/// byte is in the range, then the corresponding transition is a match.
///
/// This binary search accepts a slice of these pairs and returns the position
/// of the matching pair (the ith transition), or None if no matching pair
/// could be found.
///
/// Note that this routine is not currently used since it was observed to
/// either decrease performance when searching ASCII, or did not provide enough
/// of a boost on non-ASCII haystacks to be worth it. However, we leave it here
/// for posterity in case we can find a way to use it.
///
/// In theory, we could use the standard library's search routine if we could
/// cast a `&[u8]` to a `&[(u8, u8)]`, but I don't believe this is currently
/// guaranteed to be safe and is thus UB (since I don't think the in-memory
/// representation of `(u8, u8)` has been nailed down). One could define a
/// repr(C) type, but the casting doesn't seem justified.
#[cfg_attr(feature = "perf-inline", inline(always))]
fn binary_search_ranges(ranges: &[u8], needle: u8) -> Option<usize> {
    debug_assert!(ranges.len() % 2 == 0, "ranges must have even length");
    debug_assert!(ranges.len() <= 512, "ranges should be short");

    let (mut left, mut right) = (0, ranges.len() / 2);
    while left < right {
        let mid = (left + right) / 2;
        let (b1, b2) = (ranges[mid * 2], ranges[mid * 2 + 1]);
        if needle < b1 {
            right = mid;
        } else if needle > b2 {
            left = mid + 1;
        } else {
            return Some(mid);
        }
    }
    None
}
*//// The identifier of the last special state in a DFA. A state is special/// if and only if its identifier is less than or equal to `max`./// The identifier of the quit state in a DFA. (There is no analogous field/// for the dead state since the dead state's ID is always zero, regardless/// of state ID size.)/// The identifier of the first match state.max_match/// The identifier of the last match state.min_accel/// The identifier of the first accelerated state.max_accel/// The identifier of the last accelerated state.min_start/// The identifier of the first start state.max_start/// The identifier of the last start state.// Special represents the identifiers in a DFA that correspond to "special"// states. If a state is one or more of the following, then it is considered// special:// * dead - A non-matching state where all outgoing transitions lead back to//   itself. There is only one of these, regardless of whether minimization//   has run. The dead state always has an ID of 0. i.e., It is always the//   first state in a DFA.// * quit - A state that is entered whenever a byte is seen that should cause//   a DFA to give up and stop searching. This results in a MatchError::quit//   error being returned at search time. The default configuration for a DFA//   has no quit bytes, which means this state is unreachable by default,//   although it is always present for reasons of implementation simplicity.//   This state is only reachable when the caller configures the DFA to quit//   on certain bytes. There is always exactly one of these states and it//   is always the second state. (Its actual ID depends on the size of the//   alphabet in dense DFAs, since state IDs are premultiplied in order to//   allow them to be used directly as indices into the transition table.)// * match - An accepting state, i.e., indicative of a match. There may be//   zero or more of these states.// * accelerated - A state where all of its outgoing transitions, except a//   few, loop back to itself. These states are candidates for acceleration//   via memchr during search. There may be zero or more of these states.// * start - A non-matching state that indicates where the automaton should//   start during a search. There is always at least one starting state and//   all are guaranteed to be non-match states. (A start state cannot be a//   match state because the DFAs in this crate delay all matches by one byte.//   So every search that finds a match must move through one transition to//   some other match state, even when searching an empty string.)// These are not mutually exclusive categories. Namely, the following// overlappings can occur:// * {dead, start} - If a DFA can never lead to a match and it is minimized,//   then it will typically compile to something where all starting IDs point//   to the DFA's dead state.// * {match, accelerated} - It is possible for a match state to have the//   majority of its transitions loop back to itself, which means it's//   possible for a match state to be accelerated.// * {start, accelerated} - Similarly, it is possible for a start state to be//   accelerated. Note that it is possible for an accelerated state to be//   neither a match or a start state. Also note that just because both match//   and start states overlap with accelerated states does not mean that//   match and start states overlap with each other. In fact, they are//   guaranteed not to overlap.// As a special mention, every DFA always has a dead and a quit state, even// though from the perspective of the DFA, they are equivalent. (Indeed,// minimization special cases them to ensure they don't get merged.) The// purpose of keeping them distinct is to use the quit state as a sentinel to// distguish between whether a search finished successfully without finding// anything or whether it gave up before finishing.// So the main problem we want to solve here is the *fast* detection of whether// a state is special or not. And we also want to do this while storing as// little extra data as possible. AND we want to be able to quickly determine// which categories a state falls into above if it is special.// We achieve this by essentially shuffling all special states to the beginning// of a DFA. That is, all special states appear before every other non-special// state. By representing special states this way, we can determine whether a// state is special or not by a single comparison, where special.max is the// identifier of the last special state in the DFA://     if current_state <= special.max://         ... do something with special state// The only thing left to do is to determine what kind of special state// it is. Because what we do next depends on that. Since special states// are typically rare, we can afford to do a bit more extra work, but we'd// still like this to be as fast as possible. The trick we employ here is to// continue shuffling states even within the special state range. Such that// one contiguous region corresponds to match states, another for start states// and then an overlapping range for accelerated states. At a high level, our// special state detection might look like this (for leftmost searching, where// we continue searching even after seeing a match)://     byte = input[offset]//     current_state = next_state(current_state, byte)//     offset += 1//         if current_state == 0://             # We can never leave a dead state, so this always marks the//             # end of our search.//             return last_match//         if current_state == special.quit_id://             # A quit state means we give up. If he DFA has no quit state,//             # then special.quit_id == 0 == dead, which is handled by the//             # conditional above.//             return Err(MatchError::quit { byte, offset: offset - 1 })//         if special.min_match <= current_state <= special.max_match://             last_match = Some(offset)//             if special.min_accel <= current_state <= special.max_accel://                 offset = accelerate(input, offset)//                 last_match = Some(offset)//         elif special.min_start <= current_state <= special.max_start://             offset = prefilter.find(input, offset)//         elif special.min_accel <= current_state <= special.max_accel://             offset = accelerate(input, offset)// There are some small details left out of the logic above. For example,// in order to accelerate a state, we need to know which bytes to search for.// This in turn implies some extra data we need to store in the DFA. To keep// things compact, we would ideally only store//     N = special.max_accel - special.min_accel + 1// items. But state IDs are premultiplied, which means they are not contiguous.// So in order to take a state ID and index an array of accelerated structures,// we need to do://     i = (state_id - special.min_accel) / stride// (N.B. 'stride' is always a power of 2, so the above can be implemented via// '(state_id - special.min_accel) >> stride2', where 'stride2' is x in// 2^x=stride.)// Moreover, some of these specialty categories may be empty. For example,// DFAs are not required to have any match states or any accelerated states.// In that case, the lower and upper bounds are both set to 0 (the dead state// ID) and the first `current_state == 0` check subsumes cases where the// ranges are empty.// Loop unrolling, if applicable, has also been left out of the logic above.// Graphically, the ranges look like this, where asterisks indicate ranges// that can be empty. Each 'x' is a state.//      quit//  dead|//     ||//     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx//     | |             |    | start |                       |//     | |-------------|    |-------|                       |//     |   match*   |          |    |                       |//     |            |          |    |                       |//     |            |----------|    |                       |//     |                accel*      |                       |//     |                            |                       |//     |----------------------------|------------------------//              special                   non-special*/// Creates a new set of special ranges for a DFA. All ranges are initially/// set to only contain the dead state. This is interpreted as an empty/// Remaps all of the special state identifiers using the function given./// Deserialize the given bytes into special state ranges. If the slice/// given is not big enough, then this returns an error. Similarly, if/// any of the expected invariants around special state ranges aren't/// upheld, an error is returned. Note that this does not guarantee that/// the information returned is correct./// Upon success, this returns the number of bytes read in addition to the/// special state IDs themselves./// Validate that the information describing special states satisfies/// all known invariants.validate_state_len/// Validate that the special state information is compatible with the/// given state len./// Write the IDs and ranges for special states to the given byte buffer./// The buffer given must have enough room to store all data, otherwise/// this will return an error. The number of bytes written is returned/// on success. The number of bytes written is guaranteed to be a multiple/// of 8.set_max/// Sets the maximum special state ID based on the current values. This/// should be used once all possible state IDs are set.set_no_special_start_states/// Sets the maximum special state ID such that starting states are not/// considered "special." This also marks the min/max starting states as/// DEAD such that 'is_start_state' always returns false, even if the state/// is actually a starting state./// This is useful when there is no prefilter set. It will avoid/// ping-ponging between the hot path in the DFA search code and the start/// state handling code, which is typically only useful for executing a/// Returns true if and only if the given state ID is a special state./// Returns true if and only if the given state ID is a dead state./// Returns true if and only if the given state ID is a quit state./// Returns true if and only if the given state ID is a match state./// Returns true if and only if the given state ID is an accel state./// Returns true if and only if the given state ID is a start state./// Returns the total number of match states for a dense table based DFA./// Returns true if and only if there is at least one match state.accel_len/// Returns the total number of accel states./// Returns true if and only if there is at least one accel state./// Returns true if and only if there is at least one start state./// Note that even if an unanchored search is requested, the pattern itself/// may still be anchored. For example, `^abc` will only match `abc` at the/// start of a haystack. This will remain true, even if the regex engine/// only supported unanchored searches./// The kind of anchored starting configurations to support in a DFA./// Fully compiled DFAs need to be explicitly configured as to which anchored/// starting configurations to support. The reason for not just supporting/// everything unconditionally is that it can use more resources (such as/// memory and build time). The downside of this is that if you try to execute/// a search using an [`Anchored`](crate::Anchored) mode that is not supported/// by the DFA, then the search will return an error.has_unanchoredhas_anchoredCacheErrorLazyStateIDLazyStateIDErrorNFAStateIDMIN_STATES/// The minimum number of states that a lazy DFA's cache size must support./// This is checked at time of construction to ensure that at least some small/// number of states can fit in the given capacity allotment. If we can't fit/// at least this number of states, then the thinking is that it's pretty/// senseless to use the lazy DFA. More to the point, parts of the code do/// assume that the cache can fit at least some small number of states.SENTINEL_STATES/// The number of "sentinel" states that get added to every lazy DFA./// These are special states indicating status conditions of a search: unknown,/// dead and quit. These states in particular also use zero NFA states, so/// their memory usage is quite small. This is relevant for computing the/// minimum memory needed for a lazy DFA cache.cache_capacity/// A hybrid NFA/DFA (also called a "lazy DFA") for regex searching./// A lazy DFA is a DFA that builds itself at search time. It otherwise has/// very similar characteristics as a [`dense::DFA`](crate::dfa::dense::DFA)./// Indeed, both support precisely the same regex features with precisely the/// same semantics./// Where as a `dense::DFA` must be completely built to handle any input before/// it may be used for search, a lazy DFA starts off effectively empty. During/// a search, a lazy DFA will build itself depending on whether it has already/// computed the next transition or not. If it has, then it looks a lot like/// a `dense::DFA` internally: it does a very fast table based access to find/// the next transition. Otherwise, if the state hasn't been computed, then it/// does determinization _for that specific transition_ to compute the next DFA/// The main selling point of a lazy DFA is that, in practice, it has/// the performance profile of a `dense::DFA` without the weakness of it/// taking worst case exponential time to build. Indeed, for each byte of/// input, the lazy DFA will construct as most one new DFA state. Thus, a/// lazy DFA achieves worst case `O(mn)` time for regex search (where `m ~/// pattern.len()` and `n ~ haystack.len()`)./// The main downsides of a lazy DFA are:/// 1. It requires mutable "cache" space during search. This is where the/// transition table, among other things, is stored./// 2. In pathological cases (e.g., if the cache is too small), it will run/// out of room and either require a bigger cache capacity or will repeatedly/// clear the cache and thus repeatedly regenerate DFA states. Overall, this/// will tend to be slower than a typical NFA simulation./// # Capabilities/// Like a `dense::DFA`, a single lazy DFA fundamentally supports the following/// operations:/// 3. In the case of a lazy DFA with multiple patterns, which pattern matched/// is reported as well./// a match, *two* lazy DFAs are required. This functionality is provided by a/// [`Regex`](crate::hybrid::regex::Regex)./// This shows how to build a lazy DFA with the default configuration and/// execute a search. Notice how, in contrast to a `dense::DFA`, we must create/// a cache and pass it to our search routine./// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};/// assert_eq!(expected, dfa.try_search_fwd(///     &mut cache, &Input::new("foo12345"))?,/// return the corresponding lazy DFA./// let dfa = DFA::new("foo[0-9]+bar")?;///     Some(expected),///     dfa.try_search_fwd(&mut cache, &Input::new("foo12345bar"))?,/// return the corresponding lazy multi-DFA./// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+"])?;/// let expected = HalfMatch::must(1, 3);/// Create a new lazy DFA that matches every input./// let expected = HalfMatch::must(0, 0);/// assert_eq!(Some(expected), dfa.try_search_fwd(///     &mut cache, &Input::new(""))?,///     &mut cache, &Input::new("foo"))?,/// Create a new lazy DFA that never matches any input./// use regex_automata::{hybrid::dfa::DFA, Input};/// assert_eq!(None, dfa.try_search_fwd(&mut cache, &Input::new(""))?);/// assert_eq!(None, dfa.try_search_fwd(&mut cache, &Input::new("foo"))?);/// Return a default configuration for a `DFA`./// type when customizing the construction of a lazy DFA./// This example shows how to build a lazy DFA that heuristically supports/// Unicode word boundaries./// use regex_automata::{hybrid::dfa::DFA, HalfMatch, MatchError, Input};///     .build(r"\b\w+\b")?;/// // Since our haystack is all ASCII, the DFA search sees then and knows/// // it is legal to interpret Unicode word boundaries as ASCII word/// // boundaries./// let input = Input::new("!!foo!!");/// let expected = HalfMatch::must(0, 5);/// assert_eq!(Some(expected), re.try_search_fwd(&mut cache, &input)?);/// // But if our haystack contains non-ASCII, then the search will fail/// // with an error./// let input = Input::new("!!βββ!!");/// let expected = MatchError::quit(b'\xCE', 2);/// assert_eq!(Err(expected), re.try_search_fwd(&mut cache, &input));/// everywhere for lazy DFAs./// use regex_automata::{hybrid::dfa::DFA, util::syntax, HalfMatch, Input};/// let input = Input::new(b"\xFEfoo\xFFarzz\xE2\x98\xFF\n");/// let expected = Some(HalfMatch::must(0, 9));/// let got = re.try_search_fwd(&mut cache, &input)?;/// Create a new cache for this lazy DFA./// lazy DFA. If you want to reuse the cache for another DFA, then/// you must call [`Cache::reset`] with that DFA (or, equivalently,/// this lazy DFA (and only this DFA)./// with a different lazy DFA./// Resetting a cache sets its "clear count" to 0. This is relevant if the/// lazy DFA has been configured to "give up" after it has cleared the/// cache a certain number of times./// Any lazy state ID generated by the cache prior to resetting it is/// invalid after the reset./// let dfa1 = DFA::new(r"\w")?;/// let dfa2 = DFA::new(r"\W")?;/// let mut cache = dfa1.create_cache();///     Some(HalfMatch::must(0, 2)),///     dfa1.try_search_fwd(&mut cache, &Input::new("Δ"))?,/// // Using 'cache' with dfa2 is not allowed. It may result in panics or/// // it with the DFA we'd like to use it with./// // Similarly, after this reset, using the cache with 'dfa1' is also not/// dfa2.reset_cache(&mut cache);///     Some(HalfMatch::must(0, 3)),///     dfa2.try_search_fwd(&mut cache, &Input::new("☃"))?,/// Returns the total number of patterns compiled into this lazy DFA./// use regex_automata::hybrid::dfa::DFA;/// Returns this lazy DFA's configuration./// faster than integer division./// Returns the total stride for every state in this lazy DFA. This/// corresponds to the total number of transitions used by each state in/// this DFA's transition table./// Returns the memory usage, in bytes, of this lazy DFA./// This does **not** include the stack size used up by this lazy DFA. To/// compute that, use `std::mem::size_of::<DFA>()`. This also does not/// include the size of the `Cache` used./// This also does not include any heap memory used by the NFA inside of/// this hybrid NFA/DFA. This is because the NFA's ownership is shared, and/// thus not owned by this hybrid NFA/DFA. More practically, several regex/// engines in this crate embed an NFA, and reporting the NFA's memory/// usage in all of them would likely result in reporting higher heap/// memory than is actually used./// * The configuration of the lazy DFA may permit it to "quit" the search./// option that could result in the lazy DFA quitting./// * The configuration of the lazy DFA may also permit it to "give up"/// on a search if it makes ineffective use of its transition table/// cache. The default configuration does not enable this by default,/// although it is typically a good idea to./// This example shows how to run a basic search./// let dfa = DFA::new("abc|a")?;/// let expected = HalfMatch::must(0, 3);///     &mut cache, &Input::new("abc"))?,/// This example shows how to build a lazy multi-DFA that permits searching/// for specific patterns.///     hybrid::dfa::DFA,/// let haystack = "foo123";/// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack))?;/// let got = dfa.try_search_fwd(&mut cache, &input)?;/// // Unicode word boundaries since our haystack is pure ASCII./// let dfa = DFA::new(r"(?-u)\b[0-9]{3}\b")?;/// let got = dfa.try_search_fwd(///     &mut cache,///     &Input::new(&haystack[3..6]),///     &Input::new(haystack).range(3..6),/// This routine is principally useful when used in/// conjunction with the/// configuration. In general, it's unlikely to be correct to use both/// `try_search_fwd` and `try_search_rev` with the same DFA since any/// particular DFA will only support searching in one direction with///     dfa.try_search_rev(&mut cache, &Input::new("foo12345"))?,/// assert_eq!(Some(expected), dfa.try_search_rev(///     match dfa.try_search_rev(&mut cache, &input)? {/// underlying NFA disabled:/// Executes an overlapping forward search and returns the end position of/// matches as they are found. If no match exists, then `None` is returned./// This example shows how to run a basic overlapping search. Notice/// that we build the automaton with a `MatchKind::All` configuration./// Overlapping searches are unlikely to work as one would expect when/// using the default `MatchKind::LeftmostFirst` match semantics, since/// leftmost-first matching is fundamentally incompatible with overlapping/// searches. Namely, overlapping searches need to report matches as they/// are seen, where as leftmost-first searches will continue searching even/// after a match has been observed in order to find the conventional end/// position of the match. More concretely, leftmost-first searches use/// dead states to terminate a search after a specific match can no longer/// be extended. Overlapping searches instead do the opposite by continuing/// the search to find totally new matches (potentially of other patterns).///     hybrid::dfa::{DFA, OverlappingState},/// dfa.try_search_overlapping_fwd(///     &mut cache, &Input::new(haystack), &mut state,/// Executes a reverse overlapping search and returns the start of the/// position of the leftmost match that is found. If no match exists, then///     dfa.try_search_overlapping_rev(&mut cache, &input, &mut state)?;///     r"\w+", r"\d+", r"\pL+", r"foo", r"bar", r"barfoo", r"foobar",/// dfa.try_which_overlapping_matches(&mut cache, &input, &mut patset)?;/// The given cache is used to either reuse pre-computed state/// transitions, or to store this newly computed transition for future/// reuse. Thus, this routine guarantees that it will never return a state/// ID that has an "unknown" tag./// # State identifier validity/// The only valid value for `current` is the lazy state ID returned/// by the most recent call to `next_state`, `next_state_untagged`,/// `next_state_untagged_unchecked`, `start_state_forward` or/// `state_state_reverse` for the given `cache`. Any state ID returned from/// prior calls to these routines (with the same `cache`) is considered/// invalid (even if it gives an appearance of working). State IDs returned/// from _any_ prior call for different `cache` values are also always/// invalid./// The returned ID is always a valid ID when `current` refers to a valid/// ID. Moreover, this routine is defined for all possible values of/// `input`./// These validity rules are not checked, even in debug mode. Callers are/// required to uphold these rules themselves./// Violating these state ID validity rules will not sacrifice memory/// safety, but _may_ produce an incorrect result or a panic./// may panic but it also may not panic and instead return an invalid or/// incorrect ID./// This shows a simplistic example for walking a lazy DFA for a given/// haystack by using the `next_state` method./// let dfa = DFA::new(r"[a-z]+r")?;/// let mut sid = dfa.start_state_forward(///     &mut cache, &Input::new(haystack),///     sid = dfa.next_state(&mut cache, sid, b)?;/// sid = dfa.next_eoi_state(&mut cache, sid)?;/// assert!(sid.is_match());next_state_untagged/// byte of input and a state ID that is not tagged./// The only reason to use this routine is performance. In particular, the/// `next_state` method needs to do some additional checks, among them is/// to account for identifiers to states that are not yet computed. In/// such a case, the transition is computed on the fly. However, if it is/// known that the `current` state ID is untagged, then these checks can be/// omitted./// Since this routine does not compute states on the fly, it does not/// modify the cache and thus cannot return an error. Consequently, `cache`/// does not need to be mutable and it is possible for this routine to/// return a state ID corresponding to the special "unknown" state. In/// this case, it is the caller's responsibility to use the prior state/// ID and `input` with `next_state` in order to force the computation of/// the unknown transition. Otherwise, trying to use the "unknown" state/// ID will just result in transitioning back to itself, and thus never/// terminating. (This is technically a special exemption to the state ID/// validity rules, but is permissible since this routine is guarateed to/// never mutate the given `cache`, and thus the identifier is guaranteed/// to remain valid.)/// See [`LazyStateID`] for more details on what it means for a state ID/// to be tagged. Also, see/// [`next_state_untagged_unchecked`](DFA::next_state_untagged_unchecked)/// for this same idea, but with bounds checks forcefully elided./// The only valid value for `current` is an **untagged** lazy/// state ID returned by the most recent call to `next_state`,/// `next_state_untagged`, `next_state_untagged_unchecked`,/// `start_state_forward` or `state_state_reverse` for the given `cache`./// Any state ID returned from prior calls to these routines (with the/// same `cache`) is considered invalid (even if it gives an appearance/// of working). State IDs returned from _any_ prior call for different/// `cache` values are also always invalid./// ID, although it may be tagged. Moreover, this routine is defined for/// all possible values of `input`./// Not all validity rules are checked, even in debug mode. Callers are/// haystack by using the `next_state_untagged` method where possible./// let mut at = 0;/// while at < haystack.len() {///     if sid.is_tagged() {///         sid = dfa.next_state(&mut cache, sid, haystack[at])?;///         let mut prev_sid = sid;///         // We attempt to chew through as much as we can while moving///         // through untagged state IDs. Thus, the transition function///         // does less work on average per byte. (Unrolling this loop///         // may help even more.)///         while at < haystack.len() {///             prev_sid = sid;///             sid = dfa.next_state_untagged(///                 &mut cache, sid, haystack[at],///             );///             at += 1;///             if sid.is_tagged() {///         // We must ensure that we never proceed to the next iteration///         // with an unknown state ID. If we don't account for this///         // case, then search isn't guaranteed to terminate since all///         // transitions on unknown states loop back to itself.///         if sid.is_unknown() {///             sid = dfa.next_state(///                 &mut cache, prev_sid, haystack[at - 1],///             )?;next_state_untagged_unchecked/// Transitions from the current state to the next state, eliding bounds/// checks, given the next byte of input and a state ID that is not tagged./// [`next_state_untagged`](DFA::next_state_untagged)/// for this same idea, but with memory safety guaranteed by retaining/// bounds checks./// state ID according to the rules described above. If `current` is not a/// valid state ID for this automaton, then calling this routine may result/// in undefined behavior./// If `current` is valid, then the ID returned is valid for all possible/// values of `input`./// implementation of search. Namely, lazy DFAs in this crate delay matches/// It is best to think of EOI as an additional symbol in the alphabet of a/// DFA that is distinct from every other symbol. That is, the alphabet of/// lazy DFAs in this crate has a logical size of 257 instead of 256, where/// ID./// Return the ID of the start state for this lazy DFA for the given/// starting configuration./// Although, as a convenience, if you have an [`Input`], then it/// may be more succinct to use [`DFA::start_state_forward`] or/// [`DFA::start_state_reverse`]. Note, for example, that the convenience/// routines return a [`MatchError`] on failure where as this routine/// returns a [`StartError`]./// determining the start state (for example, if it sees a "quit" byte/// or if the cache has become inefficient). This can also return an/// error if the given configuration contains an unsupported [`Anchored`]/// Return the ID of the start state for this lazy DFA when executing a/// forward search./// This is a convenience routine for calling [`DFA::start_state`] that/// converts the given [`Input`] to a [start configuration](start::Config)./// Additionally, if an error occurs, it is converted from a [`StartError`]/// to a [`MatchError`] using the offset information in the given/// [`Input`]./// This may return a [`MatchError`] if the search needs to give up when/// determining the start state (for example, if it sees a "quit" byte or/// if the cache has become inefficient). This can also return an error if/// the given `Input` contains an unsupported [`Anchored`] configuration./// reverse search./// If the lazy DFA was compiled with one pattern, then this must/// necessarily always return `1` for all match states./// A lazy DFA guarantees that [`DFA::match_pattern`] can be called with/// indices up to (but not including) the length returned by this routine/// without panicking./// If the given state is not a match state, then this may either panic/// or return an incorrect result./// Notice that we must use [`MatchKind::All`] when building the DFA. If we/// used [`MatchKind::LeftmostFirst`] instead, then the DFA would not be/// constructed in a way that supports overlapping matches. (It would only/// report a single pattern that matches at any particular point in time.)/// use regex_automata::{hybrid::dfa::DFA, Input, MatchKind};///         r"\w+", r"[a-z]+", r"[A-Z]+", r"\S+",/// assert_eq!(dfa.match_len(&mut cache, sid), 3);/// assert_eq!(dfa.match_pattern(&mut cache, sid, 0).as_usize(), 3);/// assert_eq!(dfa.match_pattern(&mut cache, sid, 1).as_usize(), 0);/// assert_eq!(dfa.match_pattern(&mut cache, sid, 2).as_usize(), 1);/// See [`DFA::match_len`] for an example of how to use this method/// correctly. Note that if you know your lazy DFA is configured with a/// search, as the example for `DFA::match_len` does./// match index is correct, then this routine always produces a valid// N.B. If you're looking to understand how determinization works, it// is probably simpler to first grok src/dfa/determinize.rs, since that// doesn't have the "laziness" component./// The transition table./// Given a `current` LazyStateID and an `input` byte, the next state can/// be computed via `trans[untagged(current) + equiv_class(input)]`. Notice/// that no multiplication is used. That's because state identifiers are/// "premultiplied."/// Note that the next state may be the "unknown" state. In this case, the/// next state is not known and determinization for `current` on `input`/// must be performed./// The starting states for this DFA./// These are computed lazily. Initially, these are all set to "unknown"/// lazy state IDs./// When 'starts_for_each_pattern' is disabled (the default), then the size/// of this is constrained to the possible starting configurations based/// on the search parameters. (At time of writing, that's 4.) However,/// when starting states for each pattern is enabled, then there are N/// additional groups of starting states, where each group reflects the/// different possible configurations and N is the number of patterns./// A sequence of NFA/DFA powerset states that have been computed for this/// lazy DFA. This sequence is indexable by untagged LazyStateIDs. (Every/// tagged LazyStateID can be used to index this sequence by converting it/// to its untagged form.)states_to_id/// A map from states to their corresponding IDs. This map may be accessed/// via the raw byte representation of a state, which means that a `State`/// does not need to be allocated to determine whether it already exists/// in this map. Indeed, the existence of such a state is what determines/// whether we allocate a new `State` or not./// The higher level idea here is that we do just enough determinization/// for a state to check whether we've already computed it. If we have,/// then we can save a little (albeit not much) work. The real savings is/// in memory usage. If we never checked for trivially duplicate states,/// then our memory usage would explode to unreasonable levels./// Sparse sets used to track which NFA states have been visited during/// various traversals./// Scratch space for traversing the NFA graph. (We use space on the heap/// instead of the call stack.)/// Scratch space for building a NFA/DFA powerset state. This is used to/// help amortize allocation since not every powerset state generated is/// added to the cache. In particular, if it already exists in the cache,/// then there is no need to allocate a new `State` for it.state_saverStateSaver/// A simple abstraction for handling the saving of at most a single state/// across a cache clearing. This is required for correctness. Namely, if/// adding a new state after clearing the cache fails, then the caller/// must retain the ability to continue using the state ID given. The/// state corresponding to the state ID is what we preserve across cache/// clearings./// The memory usage, in bytes, used by 'states' and 'states_to_id'. We/// track this as new states are added since states use a variable amount/// of heap. Tracking this as we add states makes it possible to compute/// the total amount of memory used by the determinizer in constant time.clear_count/// The number of times the cache has been cleared. When a minimum cache/// clear count is set, then the cache will return an error instead of/// clearing the cache if the count has been exceeded.bytes_searched/// The total number of bytes searched since the last time this cache was/// cleared, not including the current search./// This can be added to the length of the current search to get the true/// total number of bytes searched./// This is generally only non-zero when the/// `Cache::search_{start,update,finish}` APIs are used to track searchSearchProgress/// The progress of the current search./// This is only non-`None` when callers utlize the `Cache::search_start`,/// `Cache::search_update` and `Cache::search_finish` APIs./// The purpose of recording search progress is to be able to make a/// determination about the efficiency of the cache. Namely, by keeping/// track of the/// A cache represents a partially computed DFA./// A cache is the key component that differentiates a classical DFA and a/// hybrid NFA/DFA (also called a "lazy DFA"). Where a classical DFA builds a/// complete transition table that can handle all possible inputs, a hybrid/// NFA/DFA starts with an empty transition table and builds only the parts/// required during search. The parts that are built are stored in a cache. For/// this reason, a cache is a required parameter for nearly every operation on/// a [`DFA`]./// Caches can be created from their corresponding DFA via/// [`DFA::create_cache`]. A cache can only be used with either the DFA that/// created it, or the DFA that was most recently used to reset it with/// [`Cache::reset`]. Using a cache with any other DFA may result in panics/// or incorrect results./// Create a new cache for the given lazy DFA./// The cache returned should only be used for searches for the given DFA./// If you want to reuse the cache for another DFA, then you must call/// [`Cache::reset`] with that DFA./// Reset this cache such that it can be used for searching with the given/// lazy DFA (and only that DFA)./// cache.reset(&dfa2);search_start/// Initializes a new search starting at the given position./// If a previous search was unfinished, then it is finished automatically/// and a new search is begun./// Note that keeping track of search progress is _not necessary_/// for correct implementations of search using a lazy DFA. Keeping/// track of search progress is only necessary if you want the/// [`Config::minimum_bytes_per_state`] configuration knob to work.search_update/// Updates the current search to indicate that it has search to the/// No special care needs to be taken for reverse searches. Namely, the/// position given may be _less than_ the starting position of the search./// This panics if no search has been started by [`Cache::search_start`].search_finish/// Indicates that a search has finished at the given position.search_total_len/// Returns the total number of bytes that have been searched since this/// cache was last cleared./// This is useful for determining the efficiency of the cache. For/// example, the lazy DFA uses this value in conjunction with the/// [`Config::minimum_bytes_per_state`] knob to help determine whether it/// should quit searching./// This always returns `0` if search progress isn't being tracked. Note/// that the lazy DFA search routines in this crate always track search/// Returns the total number of times this cache has been cleared since it/// was either created or last reset./// This is useful for informational purposes or if you want to change/// search strategies based on the number of times the cache has been/// cleared./// Keeps track of the progress of the current search./// This is updated via the `Cache::search_{start,update,finish}` APIs to/// record how many bytes have been searched. This permits computing a/// heuristic that represents the efficiency of a cache, and thus helps inform/// whether the lazy DFA should give up or not./// Returns the length, in bytes, of this search so far./// This automatically handles the case of a reverse search, where `at`/// is likely to be less than `start`./// A type that groups methods that require the base NFA/DFA and writable/// access to the cache./// Creates a new 'Lazy' wrapper for a DFA and its corresponding cache.LazyRef/// Return an immutable view by downgrading a writable cache to a read-only/// cache.cache_next_state/// This is marked as 'inline(never)' to avoid bloating methods on 'DFA'/// like 'next_state' and 'next_eoi_state' that are called in critical/// areas. The idea is to let the optimizer focus on the other areas of/// those methods as the hot path./// Here's an example that justifies 'inline(never)'/// regex-cli find match hybrid \///   --cache-capacity 100000000 \///   -p '\pL{100}'///   all-codepoints-utf8-100x/// Where 'all-codepoints-utf8-100x' is the UTF-8 encoding of every/// codepoint, in sequence, repeated 100 times./// With 'inline(never)' hyperfine reports 1.1s per run. With/// 'inline(always)', hyperfine reports 1.23s. So that's a 10% improvement.cache_start_group/// Compute and cache the starting state for the given pattern ID (if/// present) and the starting configuration./// This panics if a pattern ID is given and the DFA isn't configured to/// build anchored start states for each pattern./// This will never return an unknown lazy state ID./// If caching this state would otherwise result in a cache that has been/// cleared too many times, then an error is returned.cache_start_one/// Compute and cache the starting state for the given NFA state ID and the/// starting configuration. The NFA state ID might be one of the following:/// 1) An unanchored start state to match any pattern./// 2) An anchored start state to match any pattern./// 3) An anchored start state for a particular pattern.add_builder_state/// Either add the given builder state to this cache, or return an ID to an/// equivalent state already in this cache./// In the case where no equivalent state exists, the idmap function given/// may be used to transform the identifier allocated. This is useful if/// the caller needs to tag the ID with additional information./// Allocate a new state ID and add the given state to this cache./// The idmap function given may be used to transform the identifier/// allocated. This is useful if the caller needs to tag the ID with/// additional information./// Allocate a new state ID.try_clear_cache/// Attempt to clear the cache used by this lazy DFA./// If clearing the cache exceeds the minimum number of required cache/// clearings, then this will return a cache error. In this case,/// callers should bubble this up as the cache can't be used until it is/// reset. Implementations of search should convert this error into a/// [`MatchError::gave_up`]./// If 'self.state_saver' is set to save a state, then this state is/// persisted through cache clearing. Otherwise, the cache is returned to/// its state after initialization with two exceptions: its clear count/// is incremented and some of its memory likely has additional capacity./// That is, clearing a cache does _not_ release memory./// Otherwise, any lazy state ID generated by the cache prior to resetting/// it is invalid after the reset./// Clears _and_ resets the cache. Resetting the cache means that no/// states are persisted and the clear count is reset to 0. No heap memory/// is released./// Note that the caller may reset a cache with a different DFA than what/// it was created from. In which case, the cache can now be used with the/// new DFA (and not the old DFA)./// Clear the cache used by this lazy DFA.init_cache/// Initialize this cache from emptiness to a place where it can be used/// for search./// This is called both at cache creation time and after the cache has been/// Primarily, this adds the three sentinel states and allocates some/// initial memory./// Save the state corresponding to the ID given such that the state/// persists through a cache clearing./// While the state may persist, the ID may not. In order to discover the/// new state ID, one must call 'saved_state_id' after a cache clearing.saved_state_id/// Returns the updated lazy state ID for a state that was persisted/// through a cache clearing./// It is only correct to call this routine when both a state has been/// saved and the cache has just been cleared. Otherwise, this panics.set_all_transitions/// Set all transitions on the state 'from' to 'to'./// Set the transition on 'from' for 'unit' to 'to'./// This panics if either 'from' or 'to' is invalid./// All unit values are OK./// Set the start ID for the given pattern ID (if given) and starting/// configuration to the ID given./// This panics if 'id' is not valid or if a pattern ID is given and/// 'starts_for_each_pattern' is not enabled./// Returns a state builder from this DFA that might have existing/// Puts the given state builder back into this DFA for reuse./// Note that building a 'State' from a builder always creates a new alloc,/// so callers should always put the builder back./// A type that groups methods that require the base NFA/DFA and read-onlyget_cached_start_id/// Return the ID of the start state for the given configuration./// If the start state has not yet been computed, then this returns an/// unknown lazy state ID.get_cached_state/// Return the cached NFA/DFA powerset state for the given ID./// This panics if the given ID does not address a valid state.is_sentinel/// Returns true if and only if the given ID corresponds to a "sentinel"/// A sentinel state is a state that signifies a special condition of/// search, and where every transition maps back to itself. See LazyStateID/// for more details. Note that start and match states are _not_ sentinels/// since they may otherwise be real states with non-trivial transitions./// The purposes of sentinel states is purely to indicate something. Their/// transitions are not meant to be followed.unknown_id/// Returns the ID of the unknown state for this lazy DFA.dead_id/// Returns the ID of the dead state for this lazy DFA./// Returns the ID of the quit state for this lazy DFA./// Returns true if and only if the given ID is valid./// An ID is valid if it is both a valid index into the transition table/// and is a multiple of the DFA's stride.state_fits_in_cache/// Returns true if adding the state given would fit in this cache.state_builder_fits_in_cache/// Returns true if adding the state to be built by the given builder would/// fit in this cache.memory_usage_for_one_more_state/// Returns the additional memory usage, in bytes, required to add one more/// state to this cache. The given size should be the heap size, in bytes,/// that would be used by the new state being added./// An empty state saver. In this case, no states (other than the special/// sentinel states) are preserved after clearing the cache.ToSave/// An ID of a state (and the state itself) that should be preserved after/// the lazy DFA's cache has been cleared. After clearing, the updated ID/// is stored in 'Saved' since it may have changed.Saved/// An ID that of a state that has been persisted through a lazy DFA/// cache clearing. The ID recorded here corresponds to an ID that was/// once marked as ToSave. The IDs are likely not equivalent even though/// the states they point to are./// A simple type that encapsulates the saving of a state ID through a cache/// clearing./// A state ID can be marked for saving with ToSave, while a state ID can be/// saved itself with Saved./// Create an empty state saver.take_to_save/// Replace this state saver with an empty saver, and if this saver is a/// request to save a state, return that request.take_saved/// saved state (or a request to save a state), return that state's ID./// The idea here is that a request to save a state isn't necessarily/// honored because it might not be needed. e.g., Some higher level code/// might request a state to be saved on the off chance that the cache gets/// cleared when a new state is added at a lower level. But if that new/// state is never added, then the cache is never cleared and the state and/// its ID remain unchanged.skip_cache_capacity_checkminimum_cache_clear_countminimum_bytes_per_state/// The configuration used for building a lazy DFA./// A lazy DFA configuration is a simple data object that is typically used/// with [`Builder::configure`]./// The default configuration guarantees that a search will never return a/// "gave up" or "quit" error, although it is possible for a search to fail/// if [`Config::starts_for_each_pattern`] wasn't enabled (which it is not by/// default) and an [`Anchored::Pattern`] mode is requested via [`Input`]./// Return a new default lazy DFA builder configuration./// where all possible matches are added to the lazy DFA./// strategy. Specifically, `LeftmostFirst` adds dead states to the/// lazy DFA as a way to terminate the search and report a match./// `LeftmostFirst` also supports non-greedy matches using this strategy/// where as `All` does not./// [`hybrid::regex::Regex`](crate::hybrid::regex::Regex) will handle this/// for you, so it's usually not necessary to do this yourself./// let input = Input::new("123foobar456");/// let dfa_fwd = DFA::new(pattern)?;/// let dfa_rev = DFA::builder()/// let mut cache_fwd = dfa_fwd.create_cache();/// let mut cache_rev = dfa_rev.create_cache();/// let got_fwd = dfa_fwd.try_search_fwd(&mut cache_fwd, &input)?.unwrap();/// // enabled./// let input = input/// let got_rev = dfa_rev.try_search_rev(&mut cache_rev, &input)?.unwrap();///     re.try_search_fwd(&mut cache, &input)?,/// lazy DFA./// pattern in the lazy DFA. When this start state is used, then the DFA/// will only search for matches for the pattern specified, even if there/// are other patterns in the DFA./// the size of the DFA and/or increase the time it takes to build the/// DFA at search time. However, since this is configuration for a lazy/// DFA, these states aren't actually built unless they're used. Enabling/// this isn't necessarily free, however, as it may result in higher cache/// 1. When looking for the start of an overlapping match (using a reverse/// DFA), doing it correctly requires starting the reverse search using the/// starting state of the pattern that matched in the forward direction./// Indeed, when building a [`Regex`](crate::hybrid::regex::Regex), it/// will automatically enable this option when building the reverse DFA/// This example shows how to use this option to permit the same lazy DFA/// to run both general searches for any pattern and anchored searches for/// a specific pattern.///     Anchored, HalfMatch, Input, PatternID,///     .build_many(&[r"[a-z0-9]{6}", r"[a-z][a-z0-9]{5}"])?;/// let haystack = "bar foo123";/// // Here's a normal unanchored search that looks for any pattern./// let expected = HalfMatch::must(0, 10);/// assert_eq!(Some(expected), dfa.try_search_fwd(&mut cache, &input)?);/// // We can also do a normal anchored search for any pattern. Since it's/// // an anchored search, we position the start of the search where we/// // know the match will begin./// let input = Input::new(haystack).range(4..);/// // Since we compiled anchored start states for each pattern, we can/// // also look for matches of other patterns explicitly, even if a/// // different pattern would have normally matched./// let expected = HalfMatch::must(1, 10);///     .range(4..)/// Whether to attempt to shrink the size of the lazy DFA's alphabet or/// one is debugging the lazy DFA./// When enabled, the lazy DFA will use a map from all possible bytes/// to their corresponding equivalence class. Each equivalence class/// represents a set of bytes that does not discriminate between a match/// and a non-match in the DFA. For example, the pattern `[ab]+` has at/// least two equivalence classes: a set containing `a` and `b` and a set/// containing every byte except for `a` and `b`. `a` and `b` are in the/// same equivalence classes because they never discriminate between a/// match and a non-match./// can be reduced drastically from `#states * 256 * sizeof(LazyStateID)`/// to `#states * k * sizeof(LazyStateID)` where `k` is the number of/// equivalence classes (rounded up to the nearest power of 2). As a/// result, total space usage can decrease substantially. Moreover, since a/// smaller alphabet is used, DFA compilation during search becomes faster/// as well since it will potentially be able to reuse a single transition/// for multiple bytes./// **WARNING:** This is only useful for debugging lazy DFAs. Disabling/// [`MatchError::quit`] error is returned./// When enabling this option, callers _must_ be prepared to/// handle a [`MatchError`] error during search. When using a/// [`Regex`](crate::hybrid::regex::Regex), this corresponds to using the/// `try_` suite of methods. Alternatively, if callers can guarantee that/// their input is ASCII only, then a [`MatchError::quit`] error will never/// be returned while searching./// let haystack = "foo 123  ☃";/// let haystack = "foo 123 ☃";/// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack));/// let got = dfa.try_search_fwd(&mut cache, &input);/// Add a "quit" byte to the lazy DFA./// When a quit byte is seen during search time, then search will return a/// [`MatchError::quit`] error indicating the offset at which the search/// stopped./// building lazy DFAs. Of course, callers should enable/// use regex_automata::{hybrid::dfa::DFA, MatchError, Input};///     .configure(DFA::config().quit(b'\n', true))/// let haystack = "foo\nbar";///     &Input::new(haystack),/// ).unwrap_err();/// Enable specializing start states in the lazy DFA./// let sid = dfa.start_state_forward(&mut cache, &Input::new(haystack))?;/// assert!(sid.is_tagged());/// assert!(sid.is_start());/// Compare the above with the default lazy DFA configuration where/// start states are _not_ specialized. In this case, the start state/// is not tagged and `sid.is_start()` returns false./// // Start states are not tagged in the default configuration!/// assert!(!sid.is_tagged());/// assert!(!sid.is_start());/// Sets the maximum amount of heap memory, in bytes, to allocate to the/// cache for use during a lazy DFA search. If the lazy DFA would otherwise/// use more heap memory, then, depending on other configuration knobs,/// either stop the search and return an error or clear the cache and/// continue the search./// The default cache capacity is some "reasonable" number that will/// accommodate most regular expressions. You may find that if you need/// to build a large DFA then it may be necessary to increase the cache/// Note that while building a lazy DFA will do a "minimum" check to ensure/// the capacity is big enough, this is more or less about correctness./// If the cache is bigger than the minimum but still "too small," then the/// lazy DFA could wind up spending a lot of time clearing the cache and/// recomputing transitions, thus negating the performance benefits of a/// lazy DFA. Thus, setting the cache capacity is mostly an experimental/// endeavor. For most common patterns, however, the default should be/// For more details on how the lazy DFA's cache is used, see the/// documentation for [`Cache`]./// This example shows what happens if the configured cache capacity is/// too small. In such cases, one can override the cache capacity to make/// it bigger. Alternatively, one might want to use less memory by setting/// a smaller cache capacity./// let pattern = r"\p{L}{1000}";/// // The default cache capacity is likely too small to deal with regexes/// // that are very large. Large repetitions of large Unicode character/// // classes are a common way to make very large regexes./// let _ = DFA::new(pattern).unwrap_err();/// // Bump up the capacity to something bigger.///     .configure(DFA::config().cache_capacity(100 * (1<<20))) // 100 MB/// let haystack = "ͰͲͶͿΆΈΉΊΌΎΏΑΒΓΔΕΖΗΘΙ".repeat(50);/// let expected = Some(HalfMatch::must(0, 2000));/// let got = dfa.try_search_fwd(&mut cache, &Input::new(&haystack))?;/// Configures construction of a lazy DFA to use the minimum cache capacity/// if the configured capacity is otherwise too small for the provided NFA./// This is useful if you never want lazy DFA construction to fail because/// of a capacity that is too small./// In general, this option is typically not a good idea. In particular,/// while a minimum cache capacity does permit the lazy DFA to function/// where it otherwise couldn't, it's plausible that it may not function/// well if it's constantly running out of room. In that case, the speed/// advantages of the lazy DFA may be negated. On the other hand, the/// "minimum" cache capacity computed may not be completely accurate and/// could actually be bigger than what is really necessary. Therefore, it/// is plausible that using the minimum cache capacity could still result/// in very good performance./// too small. In such cases, one could override the capacity explicitly./// An alternative, demonstrated here, let's us force construction to use/// the minimum cache capacity if the configured capacity is otherwise/// too small./// // Configure construction such it automatically selects the minimum/// // cache capacity if it would otherwise be too small.///     .configure(DFA::config().skip_cache_capacity_check(true))/// Configure a lazy DFA search to quit after a certain number of cache/// When a minimum is set, then a lazy DFA search will *possibly* "give/// up" after the minimum number of cache clearings has occurred. This is/// typically useful in scenarios where callers want to detect whether the/// lazy DFA search is "efficient" or not. If the cache is cleared too many/// times, this is a good indicator that it is not efficient, and thus, the/// caller may wish to use some other regex engine./// Note that the number of times a cache is cleared is a property of/// the cache itself. Thus, if a cache is used in a subsequent search/// with a similarly configured lazy DFA, then it could cause the/// search to "give up" if the cache needed to be cleared, depending/// on its internal count and configured minimum. The cache clear/// count can only be reset to `0` via [`DFA::reset_cache`] (or/// [`Regex::reset_cache`](crate::hybrid::regex::Regex::reset_cache) if/// you're using the `Regex` API)./// By default, no minimum is configured. Thus, a lazy DFA search will/// never give up due to cache clearings. If you do set this option, you/// might consider also setting [`Config::minimum_bytes_per_state`] in/// order for the lazy DFA to take efficiency into account before giving/// This example uses a somewhat pathological configuration to demonstrate/// the _possible_ behavior of cache clearing and how it might result/// in a search that returns an error./// It is important to note that the precise mechanics of how and when/// a cache gets cleared is an implementation detail./// use regex_automata::{hybrid::dfa::DFA, Input, MatchError, MatchErrorKind};/// // This is a carefully chosen regex. The idea is to pick one/// // that requires some decent number of states (hence the bounded/// // repetition). But we specifically choose to create a class with an/// // ASCII letter and a non-ASCII letter so that we can check that no new/// // states are created once the cache is full. Namely, if we fill up the/// // cache on a haystack of 'a's, then in order to match one 'β', a new/// // state will need to be created since a 'β' is encoded with multiple/// // bytes. Since there's no room for this state, the search should quit/// // at the very first position./// let pattern = r"[aβ]{100}";///     .configure(///         // Configure it so that we have the minimum cache capacity///         // possible. And that if any clearings occur, the search quits.///         DFA::config()///             .skip_cache_capacity_check(true)///             .cache_capacity(0)///             .minimum_cache_clear_count(Some(0)),/// // Our search will give up before reaching the end!/// let haystack = "a".repeat(101).into_bytes();/// let result = dfa.try_search_fwd(&mut cache, &Input::new(&haystack));/// assert!(matches!(///     *result.unwrap_err().kind(),///     MatchErrorKind::GaveUp { .. },/// // Now that we know the cache is full, if we search a haystack that we/// // know will require creating at least one new state, it should not/// // be able to make much progress./// let haystack = "β".repeat(101).into_bytes();/// // If we reset the cache, then we should be able to create more states/// // and make more progress with searching for betas./// cache.reset(&dfa);/// // ... switching back to ASCII still makes progress since it just needs/// // to set transitions on existing states!/// Configure a lazy DFA search to quit only when its efficiency drops/// below the given minimum./// The efficiency of the cache is determined by the number of DFA states/// compiled per byte of haystack searched. For example, if the efficiency/// is 2, then it means the lazy DFA is creating a new DFA state after/// searching approximately 2 bytes in a haystack. Generally speaking, 2/// is quite bad and it's likely that even a slower regex engine like the/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) would be faster./// This has no effect if [`Config::minimum_cache_clear_count`] is not set./// Namely, this option only kicks in when the cache has been cleared more/// than the minimum number. If no minimum is set, then the cache is simply/// cleared whenever it fills up and it is impossible for the lazy DFA to/// quit due to ineffective use of the cache./// In general, if one is setting [`Config::minimum_cache_clear_count`],/// then one should probably also set this knob as well. The reason is/// that the absolute number of times the cache is cleared is generally/// not a great predictor of efficiency. For example, if a new DFA state/// is created for every 1,000 bytes searched, then it wouldn't be hard/// for the cache to get cleared more than `N` times and then cause the/// lazy DFA to quit. But a new DFA state every 1,000 bytes is likely quite/// good from a performance perspective, and it's likely that the lazy/// DFA should continue searching, even if it requires clearing the cache/// occasionally./// Finally, note that if you're implementing your own lazy DFA search/// routine and also want this efficiency check to work correctly, then/// you'll need to use the following routines to record search progress:/// * Call [`Cache::search_start`] at the beginning of every search./// * Call [`Cache::search_update`] whenever [`DFA::next_state`] is/// * Call [`Cache::search_finish`] before completing a search. (It is/// not strictly necessary to call this when an error is returned, as/// `Cache::search_start` will automatically finish the previous search/// for you. But calling it where possible before returning helps improve/// the accuracy of how many bytes have actually been searched.)/// Returns the prefilter set in this configuration, if one at all./// Returns whether this configuration will instruct the lazy DFA to enter/// a quit state whenever the given byte is seen during a search. When at/// Returns whether this configuration will instruct the lazy DFA to/// "specialize" start states. When enabled, the lazy DFA will tag start/// states so that search routines using the lazy DFA can detect whenget_cache_capacity/// Returns the cache capacity set on this configuration.get_skip_cache_capacity_check/// Returns whether the cache capacity check should be skipped.get_minimum_cache_clear_count/// Returns, if set, the minimum number of times the cache must be cleared/// before a lazy DFA search can give up. When no minimum is set, then a/// search will never quit and will always clear the cache whenever it/// fills up.get_minimum_bytes_per_state/// Returns, if set, the minimum number of bytes per state that need to be/// processed in order for the lazy DFA to keep going. If the minimum falls/// below this number (and the cache has been cleared a minimum number of/// times), then the lazy DFA will return a "gave up" error.get_minimum_cache_capacity/// Returns the minimum lazy DFA cache capacity required for the given NFA./// The cache capacity required for a particular NFA may change without/// notice. Callers should not rely on it being stable./// This is useful for informational purposes, but can also be useful for/// other reasons. For example, if one wants to check the minimum cache/// capacity themselves or if one wants to set the capacity based on the/// minimum./// This may return an error if this configuration does not support all of/// the instructions used in the given NFA. For example, if the NFA has a/// Unicode word boundary but this configuration does not enable heuristic/// support for Unicode word boundaries.byte_classes_from_nfa/// Returns the byte class map used during search from the given NFA./// If byte classes are disabled on this configuration, then a map is/// returned that puts each byte in its own equivalent class.quit_set_from_nfa/// Return the quit set for this configuration and the given NFA./// This may return an error if the NFA is incompatible with this/// configuration's quit set. For example, if the NFA has a Unicode word/// boundary and the quit set doesn't include non-ASCII bytes./// A builder for constructing a lazy deterministic finite automaton from/// regular expressions./// As a convenience, [`DFA::builder`] is an alias for [`Builder::new`]. The/// `Builder` type directly./// This builder always constructs a *single* lazy DFA. As such, this builder/// [`Regex`](crate::hybrid::regex::Regex), which can be similarly configured/// using [`regex::Builder`](crate::hybrid::regex::Builder). The main reason/// to use a DFA directly is if the end location of a match is enough for your/// use case. Namely, a `Regex` will construct two lazy DFAs instead of one,/// since a second reverse DFA is needed to find the start of a match./// This example shows how to build a lazy DFA that uses a tiny cache capacity/// and completely disables Unicode. That is:///     .configure(DFA::config().cache_capacity(5_000))/// Create a new lazy DFA builder with the default configuration./// Build a lazy DFA from the given pattern./// Build a lazy DFA from the given patterns./// Note that this requires owning a `thompson::NFA`. While this may force/// you to clone the NFA, such a clone is not a deep clone. Namely, NFAs/// are defined internally to support shared ownership such that cloning is/// very cheap./// This example shows how to build a lazy DFA if you already have an NFA/// in hand./// let nfa = thompson::Compiler::new()///     .configure(thompson::Config::new().shrink(true))/// let dfa = DFA::builder().build_from_nfa(nfa)?;/// Apply the given lazy DFA configuration options to this builder./// These settings only apply when constructing a lazy DFA directly from a/// This is *not* always correct to call. It should only be called when the/// underlying NFA has UTF-8 mode enabled *and* it can produce zero-width/// matches. Calling this when both of those things aren't true might result/// in legitimate matches getting skipped.minimum_lazy_state_id/// Based on the minimum number of states required for a useful lazy DFA cache,/// this returns the minimum lazy state ID that must be representable./// It's not likely for this to have any impact 32-bit systems (or higher), but/// on 16-bit systems, the lazy state ID space is quite constrained and thus/// may be insufficient if our MIN_STATES value is (for some reason) too high.minimum_cache_capacity/// this returns a heuristic minimum number of bytes of heap space required./// This is a "heuristic" because the minimum it returns is likely bigger than/// the true minimum. Namely, it assumes that each powerset NFA/DFA state uses/// the maximum number of NFA states (all of them). This is likely bigger/// than what is required in practice. Computing the true minimum effectively/// requires determinization, which is probably too much work to do for a/// simple check like this./// One of the issues with this approach IMO is that it requires that this/// be in sync with the calculation above for computing how much heap memory/// the DFA cache uses. If we get it wrong, it's possible for example for the/// minimum to be smaller than the computed heap memory, and thus, it may be/// the case that we can't add the required minimum number of states. That in/// turn will make lazy DFA panic because we assume that we can add at least a/// minimum number of states./// Another approach would be to always allow the minimum number of states to/// be added to the lazy DFA cache, even if it exceeds the configured cache/// limit. This does mean that the limit isn't really a limit in all cases,/// which is unfortunate. But it does at least guarantee that the lazy DFA can/// always make progress, even if it is slow. (This approach is very similar to/// enabling the 'skip_cache_capacity_check' config knob, except it wouldn't/// rely on cache size calculation. Instead, it would just always permit a/// minimum number of states to be added.)// Tests that we handle heuristic Unicode word boundary support in reverse// DFAs in the specific case of contextual searches.// I wrote this test when I discovered a bug in how heuristic word// boundaries were handled. Namely, that the starting state selection// didn't consider the DFA's quit byte set when looking at the byte// immediately before the start of the search (or immediately after the// end of the search in the case of a reverse search). As a result, it was// possible for '\bfoo\b' to match 'β123' because the trailing \xB2 byte// in the 'β' codepoint would be treated as a non-word character. But of// course, this search should trigger the DFA to quit, since there is a// non-ASCII byte in consideration.// Thus, I fixed 'start_state_{forward,reverse}' to check the quit byte set// if it wasn't empty. The forward case is tested in the doc test for the// Config::unicode_word_boundary API. We test the reverse case here, which// is sufficiently niche that it doesn't really belong in a doc test./*!
Types and routines specific to lazy DFAs.

This module is the home of [`hybrid::dfa::DFA`](DFA).

This module also contains a [`hybrid::dfa::Builder`](Builder) and a
[`hybrid::dfa::Config`](Config) for configuring and building a lazy DFA.
*//// An error that occurs when initial construction of a lazy DFA fails./// A build error can occur when insufficient cache capacity is configured or/// if something about the NFA is unsupported. (For example, if one attempts/// to build a lazy DFA without heuristic Unicode support but with an NFA that/// contains a Unicode word boundary.)/// * Access an underlying/// [`nfa::thompson::BuildError`](crate::nfa::thompson::BuildError)/// only occurs when using convenience routines for building a lazy DFA/// directly from a pattern string.givenInsufficientCacheCapacityInsufficientStateIDCapacityinsufficient_cache_capacityinsufficient_state_id_capacity/// The underlying cache error that occurred./// An error that occurs when cache inefficiency has dropped below the/// configured heuristic thresholds./// Computing a start state can fail for a few reasons, either/// based on incorrect configuration or even based on whether/// the look-behind byte triggers a quit state. Typically/// one does not need to handle this error if you're using/// [`DFA::start_state_forward`](crate::hybrid::dfa::DFA::start_state_forward)/// (or its reverse counterpart), as that routine automatically converts/// `StartError` to a [`MatchError`](crate::MatchError) for you./// This error may be returned by the/// [`DFA::start_state`](crate::hybrid::dfa::DFA::start_state) routine./// An error that occurs when cache usage has become inefficient./// One of the weaknesses of a lazy DFA is that it may need to clear its/// cache repeatedly if it's not big enough. If this happens too much, then it/// can slow searching down significantly. A mitigation to this is to use/// heuristics to detect whether the cache is being used efficiently or not./// If not, then a lazy DFA can return a `CacheError`./// The default configuration of a lazy DFA in this crate is/// set such that a `CacheError` will never occur. Instead,/// callers must opt into this behavior with settings like/// [`dfa::Config::minimum_cache_clear_count`](crate::hybrid::dfa::Config::minimum_cache_clear_count)/// [`dfa::Config::minimum_bytes_per_state`](crate::hybrid::dfa::Config::minimum_bytes_per_state).too_many_cache_clearsbad_efficiency/// A state identifier specifically tailored for lazy DFAs./// A lazy state ID logically represents a pointer to a DFA state. In practice,/// by limiting the number of DFA states it can address, it reserves some/// bits of its representation to encode some additional information. That/// additional information is called a "tag." That tag is used to record/// whether the state it points to is an unknown, dead, quit, start or match/// When implementing a low level search routine with a lazy DFA, it is/// necessary to query the type of the current state to know what to do:/// * **Unknown** - The state has not yet been computed. The/// parameters used to get this state ID must be re-passed to/// [`DFA::next_state`](crate::hybrid::dfa::DFA::next_state), which will never/// return an unknown state ID./// * **Dead** - A dead state only has transitions to itself. It indicates that/// the search cannot do anything else and should stop with whatever result it/// * **Quit** - A quit state indicates that the automaton could not answer/// whether a match exists or not. Correct search implementations must return a/// [`MatchError::quit`](crate::MatchError::quit) when a DFA enters a quit/// * **Start** - A start state is a state in which a search can begin./// Lazy DFAs usually have more than one start state. Branching on/// this isn't required for correctness, but a common optimization is/// to run a prefilter when a search enters a start state. Note that/// start states are *not* tagged automatically, and one must enable the/// [`Config::specialize_start_states`](crate::hybrid::dfa::Config::specialize_start_states)/// setting for start states to be tagged. The reason for this is/// that a DFA search loop is usually written to execute a prefilter once it/// enters a start state. But if there is no prefilter, this handling can be/// quite diastrous as the DFA may ping-pong between the special handling code/// and a possible optimized hot path for handling untagged states. When start/// states aren't specialized, then they are untagged and remain in the hot/// path./// * **Match** - A match state indicates that a match has been found./// Depending on the semantics of your search implementation, it may either/// continue until the end of the haystack or a dead state, or it might quit/// and return the match immediately./// As an optimization, the [`is_tagged`](LazyStateID::is_tagged) predicate/// can be used to determine if a tag exists at all. This is useful to avoid/// branching on all of the above types for every byte searched./// This example shows how `LazyStateID` can be used to implement a correct/// search routine with minimal branching. In particular, this search routine/// implements "leftmost" matching, which means that it doesn't immediately/// stop once a match is found. Instead, it continues until it reaches a dead/// Notice also how a correct search implementation deals with/// [`CacheError`](crate::hybrid::CacheError)s returned by some of/// the lazy DFA routines. When a `CacheError` occurs, it returns/// [`MatchError::gave_up`](crate::MatchError::gave_up).///     hybrid::dfa::{Cache, DFA},/// fn find_leftmost_first(///     dfa: &DFA,///     cache: &mut Cache,///     let mut sid = dfa.start_state_forward(///         cache,///         &Input::new(haystack),///         sid = dfa///             .next_state(cache, sid, b)///             .map_err(|_| MatchError::gave_up(i))?;///         if sid.is_tagged() {///             if sid.is_match() {///                     dfa.match_pattern(cache, sid, 0),///             } else if sid.is_dead() {///             } else if sid.is_quit() {///             // Implementors may also want to check for start states and///             // handle them differently for performance reasons. But it is///             // not necessary for correctness. Note that in order to check///             // for start states, you'll need to enable the///             // 'specialize_start_states' config knob, otherwise start///             // states will not be tagged.///     sid = dfa///         .next_eoi_state(cache, sid)///         .map_err(|_| MatchError::gave_up(haystack.len()))?;///     if sid.is_match() {///             dfa.match_pattern(cache, sid, 0),/// // We use a greedy '+' operator to show how the search doesn't just stop/// // once a match is detected. It continues extending the match. Using/// // '[a-z]+?' would also work as expected and stop the search early./// // Greediness is built into the automaton./// let mat = find_leftmost_first(&dfa, &mut cache, haystack)?.unwrap();/// // Here's another example that tests our handling of the special/// // EOI transition. This will fail to find a match if we don't call/// // 'next_eoi_state' at the end of the search since the match isn't found/// // until the final byte in the haystack./// let dfa = DFA::new(r"[0-9]{4}")?;/// let dfa = DFA::new_many(&[r"[a-z]+", r"[0-9]+"])?;/// let mat = find_leftmost_first(&dfa, &mut cache, &haystack[3..])?.unwrap();/// let mat = find_leftmost_first(&dfa, &mut cache, &haystack[10..])?.unwrap();MAX_BITMASK_UNKNOWNMASK_DEADMASK_QUITMASK_STARTMASK_MATCH/// Create a new lazy state ID./// If the given identifier exceeds [`LazyStateID::MAX`], then this returns/// Create a new lazy state ID without checking whether the given value/// exceeds [`LazyStateID::MAX`]./// While this is unchecked, providing an incorrect value must neveras_usize_untagged/// Return this lazy state ID as an untagged `usize`./// If this lazy state ID is tagged, then the usize returned is the state/// ID without the tag. If the ID was not tagged, then the usize returned/// is equivalent to the state ID.as_usize_unchecked/// Return this lazy state ID as its raw internal `usize` value, which may/// be tagged (and thus greater than LazyStateID::MAX).to_unknownto_deadto_quitto_start/// Return this lazy state ID as a state ID that is tagged as a startto_match/// Return this lazy state ID as a lazy state ID that is tagged as a match/// Return true if and only if this lazy state ID is tagged./// When a lazy state ID is tagged, then one can conclude that it is one/// of a match, start, dead, quit or unknown state./// Return true if and only if this represents a lazy state ID that is/// "unknown." That is, the state has not yet been created. When a caller/// sees this state ID, it generally means that a state has to be computed/// in order to proceed./// Return true if and only if this represents a dead state. A dead state/// is a state that can never transition to any other state except the/// dead state. When a dead state is seen, it generally indicates that a/// search should stop./// Return true if and only if this represents a quit state. A quit state/// is a state that is representationally equivalent to a dead state,/// except it indicates the automaton has reached a point at which it can/// no longer determine whether a match exists or not. In general, this/// indicates an error during search and the caller must either pass this/// error up or use a different search technique./// Return true if and only if this lazy state ID has been tagged as a/// start state./// Note that if/// [`Config::specialize_start_states`](crate::hybrid::dfa::Config) is/// disabled (which is the default), then this will always return false/// since start states won't be tagged./// match state./// This error occurs when a lazy state ID could not be constructed./// This occurs when given an integer exceeding the maximum lazy state ID/// Returns the value that failed to constructed a lazy state ID./*!
A module for building and searching with lazy deterministic finite automata
(DFAs).

Like other modules in this crate, lazy DFAs support a rich regex syntax with
Unicode features. The key feature of a lazy DFA is that it builds itself
incrementally during search, and never uses more than a configured capacity of
memory. Thus, when searching with a lazy DFA, one must supply a mutable "cache"
in which the actual DFA's transition table is stored.

If you're looking for fully compiled DFAs, then please see the top-level
[`dfa` module](crate::dfa).

# Overview

This section gives a brief overview of the primary types in this module:

* A [`regex::Regex`] provides a way to search for matches of a regular
expression using lazy DFAs. This includes iterating over matches with both the
start and end positions of each match.
* A [`dfa::DFA`] provides direct low level access to a lazy DFA.

# Example: basic regex searching

This example shows how to compile a regex using the default configuration
and then use it to find matches in a byte string:

```
use regex_automata::{hybrid::regex::Regex, Match};

let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
let mut cache = re.create_cache();

let haystack = "2018-12-24 2016-10-08";
let matches: Vec<Match> = re.find_iter(&mut cache, haystack).collect();
assert_eq!(matches, vec![
    Match::must(0, 0..10),
    Match::must(0, 11..21),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# Example: searching with multiple regexes

The lazy DFAs in this module all fully support searching with multiple regexes
simultaneously. You can use this support with standard leftmost-first style
searching to find non-overlapping matches:

```
# if cfg!(miri) { return Ok(()); } // miri takes too long
use regex_automata::{hybrid::regex::Regex, Match};

let re = Regex::new_many(&[r"\w+", r"\S+"])?;
let mut cache = re.create_cache();

let haystack = "@foo bar";
let matches: Vec<Match> = re.find_iter(&mut cache, haystack).collect();
assert_eq!(matches, vec![
    Match::must(1, 0..4),
    Match::must(0, 5..8),
]);
# Ok::<(), Box<dyn std::error::Error>>(())
```

# When should I use this?

Generally speaking, if you can abide the use of mutable state during search,
and you don't need things like capturing groups or Unicode word boundary
support in non-ASCII text, then a lazy DFA is likely a robust choice with
respect to both search speed and memory usage. Note however that its speed
may be worse than a general purpose regex engine if you don't select a good
[prefilter](crate::util::prefilter).

If you know ahead of time that your pattern would result in a very large DFA
if it was fully compiled, it may be better to use an NFA simulation instead
of a lazy DFA. Either that, or increase the cache capacity of your lazy DFA
to something that is big enough to hold the state machine (likely through
experimentation). The issue here is that if the cache is too small, then it
could wind up being reset too frequently and this might decrease searching
speed significantly.

# Differences with fully compiled DFAs

A [`hybrid::regex::Regex`](crate::hybrid::regex::Regex) and a
[`dfa::regex::Regex`](crate::dfa::regex::Regex) both have the same capabilities
(and similarly for their underlying DFAs), but they achieve them through
different means. The main difference is that a hybrid or "lazy" regex builds
its DFA lazily during search, where as a fully compiled regex will build its
DFA at construction time. While building a DFA at search time might sound like
it's slow, it tends to work out where most bytes seen during a search will
reuse pre-built parts of the DFA and thus can be almost as fast as a fully
compiled DFA. The main downside is that searching requires mutable space to
store the DFA, and, in the worst case, a search can result in a new state being
created for each byte seen, which would make searching quite a bit slower.

A fully compiled DFA never has to worry about searches being slower once
it's built. (Aside from, say, the transition table being so large that it
is subject to harsh CPU cache effects.) However, of course, building a full
DFA can be quite time consuming and memory hungry. Particularly when large
Unicode character classes are used, which tend to translate into very large
DFAs.

A lazy DFA strikes a nice balance _in practice_, particularly in the
presence of Unicode mode, by only building what is needed. It avoids the
worst case exponential time complexity of DFA compilation by guaranteeing that
it will only build at most one state per byte searched. While the worst
case here can lead to a very high constant, it will never be exponential.

# Syntax

This module supports the same syntax as the `regex` crate, since they share the
same parser. You can find an exhaustive list of supported syntax in the
[documentation for the `regex` crate](https://docs.rs/regex/1/regex/#syntax).

There are two things that are not supported by the lazy DFAs in this module:

* Capturing groups. The DFAs (and [`Regex`](regex::Regex)es built on top
of them) can only find the offsets of an entire match, but cannot resolve
the offsets of each capturing group. This is because DFAs do not have the
expressive power necessary. Note that it is okay to build a lazy DFA from an
NFA that contains capture groups. The capture groups will simply be ignored.
* Unicode word boundaries. These present particularly difficult challenges for
DFA construction and would result in an explosion in the number of states.
One can enable [`dfa::Config::unicode_word_boundary`] though, which provides
heuristic support for Unicode word boundaries that only works on ASCII text.
Otherwise, one can use `(?-u:\b)` for an ASCII word boundary, which will work
on any input.

There are no plans to lift either of these limitations.

Note that these restrictions are identical to the restrictions on fully
compiled DFAs.
*//// The forward lazy DFA. This can only find the end of a match./// The reverse lazy DFA. This can only find the start of a match./// This is built with 'all' match semantics (instead of leftmost-first)/// so that it always finds the longest possible match (which corresponds/// to the leftmost starting position). It is also compiled as an anchored/// matcher and has 'starts_for_each_pattern' enabled. Including starting/// states for each pattern is necessary to ensure that we only look for/// matches of a pattern that matched in the forward direction. Otherwise,/// we might wind up finding the "leftmost" starting position of a totally/// different pattern!/// A regular expression that uses hybrid NFA/DFAs (also called "lazy DFAs")/// for searching./// A regular expression is comprised of two lazy DFAs, a "forward" DFA and a/// "reverse" DFA. The forward DFA is responsible for detecting the end of/// a match while the reverse DFA is responsible for detecting the start/// of a match. Thus, in order to find the bounds of any given match, a/// forward search must first be run followed by a reverse search. A match/// found by the forward DFA guarantees that the reverse DFA will also find/// a match./// Most of the search routines defined on this type will _panic_ when the/// underlying search fails. This might be because the DFA gave up because it/// saw a quit byte, whether configured explicitly or via heuristic Unicode/// word boundary support, although neither are enabled by default. It might/// also fail if the underlying DFA determines it isn't making effective use of/// the cache (which also never happens by default). Or it might fail because/// an invalid `Input` configuration is given, for example, with an unsupported/// [`Anchored`] mode./// If you need to handle these error cases instead of allowing them to trigger/// a panic, then the lower level [`Regex::try_search`] provides a fallible API/// that never panics./// `\n` byte, and handle the error returned. This could be useful if, for/// example, you wanted to prevent a user supplied pattern from matching/// across a line boundary./// use regex_automata::{hybrid::{dfa, regex::Regex}, Input, MatchError};///     .dfa(dfa::Config::new().quit(b'\n', true))/// let input = Input::new("foo\nbar");/// let got = re.try_search(&mut cache, &input).unwrap_err();/// use regex_automata::{hybrid::regex::Regex, Match};///     re.find(&mut cache, "zzzfoo12345barzzz"),/// let mut it = re.find_iter(&mut cache, "abc 1 foo 4567 0 quux");///     hybrid::regex::Regex, nfa::thompson, util::syntax, Match,/// let got = re.find(&mut cache, haystack);/// Create a new cache for this `Regex`./// `Regex`. If you want to reuse the cache for another `Regex`, then/// you must call [`Cache::reset`] with that `Regex` (or, equivalently,/// [`Regex::reset_cache`])./// this `Regex` (and only this `Regex`)./// with a different `Regex`./// `Regex` has been configured to "give up" after it has cleared the cache/// a certain number of times./// This shows how to re-purpose a cache for use with a different `Regex`./// let re1 = Regex::new(r"\w")?;/// let re2 = Regex::new(r"\W")?;///     re1.find(&mut cache, "Δ"),/// // it with the Regex we'd like to use it with.///     re2.find(&mut cache, "☃"),/// Convenience routines for regex and cache construction./// use regex_automata::hybrid::regex::Regex;/// use regex_automata::{Match, hybrid::regex::Regex};///     Some(Match::must(0, 3..11)),///     re.find(&mut cache, "zzzfoo12345zzz"),/// assert_eq!(Some(Match::must(0, 0..3)), re.find(&mut cache, "abc"));/// The above conditions also apply to the iterator returned as well. For/// example, if the lazy DFA gives up or quits during a search using this/// method, then a panic will occur during iteration./// Use [`Regex::try_search`] with [`util::iter::Searcher`](iter::Searcher)/// if you want to handle these error conditions./// let matches: Vec<Match> = re.find_iter(&mut cache, text).collect();/// Standard infallible search routines for finding and iterating over matches./// or if the underlying NFA is always anchored./// Lower level "search" primitives that accept a `&Input` for cheap reuse/// and return an error if one occurs instead of panicking./// Return the underlying lazy DFA responsible for forward matching./// This is useful for accessing the underlying lazy DFA and using it/// directly if the situation calls for it./// Return the underlying lazy DFA responsible for reverse matching./// * `'r` represents the lifetime of the regex object./// * `'c` represents the lifetime of the regex cache./// A cache represents a partially computed forward and reverse DFA./// a [`Regex`]./// Caches can be created from their corresponding `Regex` via/// [`Regex::create_cache`]. A cache can only be used with either the `Regex`/// that created it, or the `Regex` that was most recently used to reset it/// with [`Cache::reset`]. Using a cache with any other `Regex` may result in/// panics or incorrect results./// Create a new cache for the given `Regex`./// The cache returned should only be used for searches for the given/// `Regex`. If you want to reuse the cache for another `Regex`, then you/// must call [`Cache::reset`] with that `Regex`./// `Regex` (and only that `Regex`)./// cache.reset(&re2);/// Return a reference to the forward cache./// Return a reference to the reverse cache.forward_mut/// Return a mutable reference to the forward cache./// If you need mutable references to both the forward and reverse caches,/// then use [`Cache::as_parts_mut`].reverse_mut/// Return a mutable reference to the reverse cache.as_parts/// Return references to the forward and reverse caches, respectively.as_parts_mut/// Return mutable references to the forward and reverse caches,/// Returns the heap memory usage, in bytes, as a sum of the forward and/// reverse lazy DFA caches./// A builder for a regex based on a hybrid NFA/DFA./// NFA construction, the lazy DFA construction and finally the regex searching/// itself. This builder is different from a general purpose regex builder/// in that it permits fine grain configuration of the construction process./// The trade off for this is complexity, and the possibility of setting a/// * [`thompson::Config::utf8`] controls how the regex iterators themselves/// advance the starting position of the next search when a match with zero/// length is found./// Internally, building a regex requires building two hybrid NFA/DFAs,/// where one is responsible for finding the end of a match and the other is/// responsible for finding the start of a match. If you only need to detect/// whether something matched, or only the end of a match, then you should use/// a [`dfa::Builder`] to construct a single hybrid NFA/DFA, which is cheaper/// than building two of them./// Build a regex from its component forward and reverse hybrid NFA/DFAs./// This is useful when you've built a forward and reverse lazy DFA/// separately, and want to combine them into a single regex. Once build,/// the individual DFAs given can still be accessed via [`Regex::forward`]/// and [`Regex::reverse`]./// It is important that the reverse lazy DFA be compiled under the/// following conditions:/// This shows how to build individual lazy forward and reverse DFAs, and/// then combine them into a single `Regex`.///     hybrid::{dfa::DFA, regex::Regex},///     MatchKind,/// let fwd = DFA::new(r"foo[0-9]+")?;/// let rev = DFA::builder()/// assert_eq!(true, re.is_match(&mut cache, "foo123"));/// [`nfa::thompson::Config`](thompson::Config)./// Set the lazy DFA compilation configuration for this builder using/// [`dfa::Config`]./// This permits setting things like whether Unicode word boundaries should/// be heuristically supported or settings how the behavior of the cache./*!
A lazy DFA backed `Regex`.

This module provides a [`Regex`] backed by a lazy DFA. A `Regex` implements
convenience routines you might have come to expect, such as finding a match
and iterating over all non-overlapping matches. This `Regex` type is limited
in its capabilities to what a lazy DFA can provide. Therefore, APIs involving
capturing groups, for example, are not provided.

Internally, a `Regex` is composed of two DFAs. One is a "forward" DFA that
finds the end offset of a match, where as the other is a "reverse" DFA that
find the start offset of a match.

See the [parent module](crate::hybrid) for examples.
*//// It is always correct to call this, but not always necessary. Namely,/// whenever the DFA has a universal start state, the DFA can remain in the/// start state that it was in when it ran the prefilter. Why? Because in that/// case, there is only one start state./// When does a DFA have a universal start state? In precisely cases where/// it has no look-around assertions in its prefix. So for example, `\bfoo`/// does not have a universal start state because the start state depends on/// whether the byte immediately before the start position is a word byte or/// not. However, `foo\b` does have a universal start state because the word/// boundary does not appear in the pattern's prefix./// So... most cases don't need this, but when a pattern doesn't have a/// universal start state, then after a prefilter candidate has been found, the/// current state *must* be re-litigated as if computing the start state at the/// beginning of the search because it might change. That is, not all start/// states are created equal./// Why avoid it? Because while it's not super expensive, it isn't a trivial/// operation to compute the start state. It is much better to avoid it and/// just state in the current state if you know it to be correct.gave_up/// A convenience routine for constructing a "gave up" match error./*!
This crate exposes a variety of regex engines used by the `regex` crate.
It provides a vast, sprawling and "expert" level API to each regex engine.
The regex engines provided by this crate focus heavily on finite automata
implementations and specifically guarantee worst case `O(m * n)` time
complexity for all searches. (Where `m ~ len(regex)` and `n ~ len(haystack)`.)

The primary goal of this crate is to serve as an implementation detail for the
`regex` crate. A secondary goal is to make its internals available for use by
others.

# Table of contents

* [Should I be using this crate?](#should-i-be-using-this-crate) gives some
reasons for and against using this crate.
* [Examples](#examples) provides a small selection of things you can do with
this crate.
* [Available regex engines](#available-regex-engines) provides a hyperlinked
list of all regex engines in this crate.
* [API themes](#api-themes) discusses common elements used throughout this
crate.
* [Crate features](#crate-features) documents the extensive list of Cargo
features available.

# Should I be using this crate?

If you find yourself here because you just want to use regexes, then you should
first check out whether the [`regex` crate](https://docs.rs/regex) meets
your needs. It provides a streamlined and difficult-to-misuse API for regex
searching.

If you're here because there is something specific you want to do that can't
be easily done with `regex` crate, then you are perhaps in the right place.
It's most likely that the first stop you'll want to make is to explore the
[`meta` regex APIs](meta). Namely, the `regex` crate is just a light wrapper
over a [`meta::Regex`], so its API will probably be the easiest to transition
to. In contrast to the `regex` crate, the `meta::Regex` API supports more
search parameters and does multi-pattern searches. However, it isn't quite as
ergonomic.

Otherwise, the following is an inexhaustive list of reasons to use this crate:

* You want to analyze or use a [Thompson `NFA`](nfa::thompson::NFA) directly.
* You want more powerful multi-pattern search than what is provided by
`RegexSet` in the `regex` crate. All regex engines in this crate support
multi-pattern searches.
* You want to use one of the `regex` crate's internal engines directly because
of some interesting configuration that isn't possible via the `regex` crate.
For example, a [lazy DFA's configuration](hybrid::dfa::Config) exposes a
dizzying number of options for controlling its execution.
* You want to use the lower level search APIs. For example, both the [lazy
DFA](hybrid::dfa) and [fully compiled DFAs](dfa) support searching by exploring
the automaton one state at a time. This might be useful, for example, for
stream searches or searches of strings stored in non-contiguous in memory.
* You want to build a fully compiled DFA and then [use zero-copy
deserialization](dfa::dense::DFA::from_bytes) to load it into memory and use
it for searching. This use case is supported in core-only no-std/no-alloc
environments.
* You want to run [anchored searches](Input::anchored) without using the `^`
anchor in your regex pattern.
* You need to work-around contention issues with
sharing a regex across multiple threads. The
[`meta::Regex::search_with`](meta::Regex::search_with) API permits bypassing
any kind of synchronization at all by requiring the caller to provide the
mutable scratch spaced needed during a search.
* You want to build your own regex engine on top of the `regex` crate's
infrastructure.

# Examples

This section tries to identify a few interesting things you can do with this
crate and demonstrates them.

### Multi-pattern searches with capture groups

One of the more frustrating limitations of `RegexSet` in the `regex` crate
(at the time of writing) is that it doesn't report match positions. With this
crate, multi-pattern support was intentionally designed in from the beginning,
which means it works in all regex engines and even for capture groups as well.

This example shows how to search for matches of multiple regexes, where each
regex uses the same capture group names to parse different key-value formats.

```
use regex_automata::{meta::Regex, PatternID};

let re = Regex::new_many(&[
    r#"(?m)^(?<key>[[:word:]]+)=(?<val>[[:word:]]+)$"#,
    r#"(?m)^(?<key>[[:word:]]+)="(?<val>[^"]+)"$"#,
    r#"(?m)^(?<key>[[:word:]]+)='(?<val>[^']+)'$"#,
    r#"(?m)^(?<key>[[:word:]]+):\s*(?<val>[[:word:]]+)$"#,
])?;
let hay = r#"
best_album="Blow Your Face Out"
best_quote='"then as it was, then again it will be"'
best_year=1973
best_simpsons_episode: HOMR
"#;
let mut kvs = vec![];
for caps in re.captures_iter(hay) {
    // N.B. One could use capture indices '1' and '2' here
    // as well. Capture indices are local to each pattern.
    // (Just like names are.)
    let key = &hay[caps.get_group_by_name("key").unwrap()];
    let val = &hay[caps.get_group_by_name("val").unwrap()];
    kvs.push((key, val));
}
assert_eq!(kvs, vec![
    ("best_album", "Blow Your Face Out"),
    ("best_quote", "\"then as it was, then again it will be\""),
    ("best_year", "1973"),
    ("best_simpsons_episode", "HOMR"),
]);

# Ok::<(), Box<dyn std::error::Error>>(())
```

### Build a full DFA and walk it manually

One of the regex engines in this crate is a fully compiled DFA. It takes worst
case exponential time to build, but once built, it can be easily explored and
used for searches. Here's a simple example that uses its lower level APIs to
implement a simple anchored search by hand.

```
use regex_automata::{dfa::{Automaton, dense}, Input};

let dfa = dense::DFA::new(r"(?-u)\b[A-Z]\w+z\b")?;
let haystack = "Quartz";

// The start state is determined by inspecting the position and the
// initial bytes of the haystack.
let mut state = dfa.start_state_forward(&Input::new(haystack))?;
// Walk all the bytes in the haystack.
for &b in haystack.as_bytes().iter() {
    state = dfa.next_state(state, b);
}
// DFAs in this crate require an explicit
// end-of-input transition if a search reaches
// the end of a haystack.
state = dfa.next_eoi_state(state);
assert!(dfa.is_match_state(state));

# Ok::<(), Box<dyn std::error::Error>>(())
```

Or do the same with a lazy DFA that avoids exponential worst case compile time,
but requires mutable scratch space to lazily build the DFA during the search.

```
use regex_automata::{hybrid::dfa::DFA, Input};

let dfa = DFA::new(r"(?-u)\b[A-Z]\w+z\b")?;
let mut cache = dfa.create_cache();
let hay = "Quartz";

// The start state is determined by inspecting the position and the
// initial bytes of the haystack.
let mut state = dfa.start_state_forward(&mut cache, &Input::new(hay))?;
// Walk all the bytes in the haystack.
for &b in hay.as_bytes().iter() {
    state = dfa.next_state(&mut cache, state, b)?;
}
// DFAs in this crate require an explicit
// end-of-input transition if a search reaches
// the end of a haystack.
state = dfa.next_eoi_state(&mut cache, state)?;
assert!(state.is_match());

# Ok::<(), Box<dyn std::error::Error>>(())
```

### Find all overlapping matches

This example shows how to build a DFA and use it to find all possible matches,
including overlapping matches. A similar example will work with a lazy DFA as
well. This also works with multiple patterns and will report all matches at the
same position where multiple patterns match.

```
use regex_automata::{
    dfa::{dense, Automaton, OverlappingState},
    Input, MatchKind,
};

let dfa = dense::DFA::builder()
    .configure(dense::DFA::config().match_kind(MatchKind::All))
    .build(r"(?-u)\w{3,}")?;
let input = Input::new("homer marge bart lisa maggie");
let mut state = OverlappingState::start();

let mut matches = vec![];
while let Some(hm) = {
    dfa.try_search_overlapping_fwd(&input, &mut state)?;
    state.get_match()
} {
    matches.push(hm.offset());
}
assert_eq!(matches, vec![
    3, 4, 5,        // hom, home, homer
    9, 10, 11,      // mar, marg, marge
    15, 16,         // bar, bart
    20, 21,         // lis, lisa
    25, 26, 27, 28, // mag, magg, maggi, maggie
]);

# Ok::<(), Box<dyn std::error::Error>>(())
```

# Available regex engines

The following is a complete list of all regex engines provided by this crate,
along with a very brief description of it and why you might want to use it.

* [`dfa::regex::Regex`] is a regex engine that works on top of either
[dense](dfa::dense) or [sparse](dfa::sparse) fully compiled DFAs. You might
use a DFA if you need the fastest possible regex engine in this crate and can
afford the exorbitant memory usage usually required by DFAs. Low level APIs on
fully compiled DFAs are provided by the [`Automaton` trait](dfa::Automaton).
Fully compiled dense DFAs can handle all regexes except for searching a regex
with a Unicode word boundary on non-ASCII haystacks. A fully compiled DFA based
regex can only report the start and end of each match.
* [`hybrid::regex::Regex`] is a regex engine that works on top of a lazily
built DFA. Its performance profile is very similar to that of fully compiled
DFAs, but can be slower in some pathological cases. Fully compiled DFAs are
also amenable to more optimizations, such as state acceleration, that aren't
available in a lazy DFA. You might use this lazy DFA if you can't abide the
worst case exponential compile time of a full DFA, but still want the DFA
search performance in the vast majority of cases. A lazy DFA based regex can
only report the start and end of each match.
* [`dfa::onepass::DFA`] is a regex engine that is implemented as a DFA, but
can report the matches of each capture group in addition to the start and end
of each match. The catch is that it only works on a somewhat small subset of
regexes known as "one-pass." You'll want to use this for cases when you need
capture group matches and the regex is one-pass since it is likely to be faster
than any alternative. A one-pass DFA can handle all types of regexes, but does
have some reasonable limits on the number of capture groups it can handle.
* [`nfa::thompson::backtrack::BoundedBacktracker`] is a regex engine that uses
backtracking, but keeps track of the work it has done to avoid catastrophic
backtracking. Like the one-pass DFA, it provides the matches of each capture
group. It retains the `O(m * n)` worst case time bound. This tends to be slower
than the one-pass DFA regex engine, but faster than the PikeVM. It can handle
all types of regexes, but usually only works well with small haystacks and
small regexes due to the memory required to avoid redoing work.
* [`nfa::thompson::pikevm::PikeVM`] is a regex engine that can handle all
regexes, of all sizes and provides capture group matches. It tends to be a tool
of last resort because it is also usually the slowest regex engine.
* [`meta::Regex`] is the meta regex engine that combines *all* of the above
engines into one. The reason for this is that each of the engines above have
their own caveats such as, "only handles a subset of regexes" or "is generally
slow." The meta regex engine accounts for all of these caveats and composes
the engines in a way that attempts to mitigate each engine's weaknesses while
emphasizing its strengths. For example, it will attempt to run a lazy DFA even
if it might fail. In which case, it will restart the search with a likely
slower but more capable regex engine. The meta regex engine is what you should
default to. Use one of the above engines directly only if you have a specific
reason to.

# API themes

While each regex engine has its own APIs and configuration options, there are
some general themes followed by all of them.

### The `Input` abstraction

Most search routines in this crate accept anything that implements
`Into<Input>`. Both `&str` and `&[u8]` haystacks satisfy this constraint, which
means that things like `engine.search("foo")` will work as you would expect.

By virtue of accepting an `Into<Input>` though, callers can provide more than
just a haystack. Indeed, the [`Input`] type has more details, but briefly,
callers can use it to configure various aspects of the search:

* The span of the haystack to search via [`Input::span`] or [`Input::range`],
which might be a substring of the haystack.
* Whether to run an anchored search or not via [`Input::anchored`]. This
permits one to require matches to start at the same offset that the search
started.
* Whether to ask the regex engine to stop as soon as a match is seen via
[`Input::earliest`]. This can be used to find the offset of a match as soon
as it is known without waiting for the full leftmost-first match to be found.
This can also be used to avoid the worst case `O(m * n^2)` time complexity
of iteration.

Some lower level search routines accept an `&Input` for performance reasons.
In which case, `&Input::new("haystack")` can be used for a simple search.

### Error reporting

Most, but not all, regex engines in this crate can fail to execute a search.
When a search fails, callers cannot determine whether or not a match exists.
That is, the result is indeterminate.

Search failure, in all cases in this crate, is represented by a [`MatchError`].
Routines that can fail start with the `try_` prefix in their name. For example,
[`hybrid::regex::Regex::try_search`] can fail for a number of reasons.
Conversely, routines that either can't fail or can panic on failure lack the
`try_` prefix. For example, [`hybrid::regex::Regex::find`] will panic in
cases where [`hybrid::regex::Regex::try_search`] would return an error, and
[`meta::Regex::find`] will never panic. Therefore, callers need to pay close
attention to the panicking conditions in the documentation.

In most cases, the reasons that a search fails are either predictable or
configurable, albeit at some additional cost.

An example of predictable failure is
[`BoundedBacktracker::try_search`](nfa::thompson::backtrack::BoundedBacktracker::try_search).
Namely, it fails whenever the multiplication of the haystack, the regex and some
constant exceeds the
[configured visited capacity](nfa::thompson::backtrack::Config::visited_capacity).
Callers can predict the failure in terms of haystack length via the
[`BoundedBacktracker::max_haystack_len`](nfa::thompson::backtrack::BoundedBacktracker::max_haystack_len)
method. While this form of failure is technically avoidable by increasing the
visited capacity, it isn't practical to do so for all inputs because the
memory usage required for larger haystacks becomes impractically large. So in
practice, if one is using the bounded backtracker, you really do have to deal
with the failure.

An example of configurable failure happens when one enables heuristic support
for Unicode word boundaries in a DFA. Namely, since the DFAs in this crate
(except for the one-pass DFA) do not support Unicode word boundaries on
non-ASCII haystacks, building a DFA from an NFA that contains a Unicode word
boundary will itself fail. However, one can configure DFAs to still be built in
this case by
[configuring heuristic support for Unicode word boundaries](hybrid::dfa::Config::unicode_word_boundary).
If the NFA the DFA is built from contains a Unicode word boundary, then the
DFA will still be built, but special transitions will be added to every state
that cause the DFA to fail if any non-ASCII byte is seen. This failure happens
at search time and it requires the caller to opt into this.

There are other ways for regex engines to fail in this crate, but the above
two should represent the general theme of failures one can find. Dealing
with these failures is, in part, one the responsibilities of the [meta regex
engine](meta). Notice, for example, that the meta regex engine exposes an API
that never returns an error nor panics. It carefully manages all of the ways
in which the regex engines can fail and either avoids the predictable ones
entirely (e.g., the bounded backtracker) or reacts to configured failures by
falling back to a different engine (e.g., the lazy DFA quitting because it saw
a non-ASCII byte).

### Configuration and Builders

Most of the regex engines in this crate come with two types to facilitate
building the regex engine: a `Config` and a `Builder`. A `Config` is usually
specific to that particular regex engine, but other objects such as parsing and
NFA compilation have `Config` types too. A `Builder` is the thing responsible
for taking inputs (either pattern strings or already-parsed patterns or even
NFAs directly) and turning them into an actual regex engine that can be used
for searching.

The main reason why building a regex engine is a bit complicated is because
of the desire to permit composition with de-coupled components. For example,
you might want to [manually construct a Thompson NFA](nfa::thompson::Builder)
and then build a regex engine from it without ever using a regex parser
at all. On the other hand, you might also want to build a regex engine directly
from the concrete syntax. This demonstrates why regex engine construction is
so flexible: it needs to support not just convenient construction, but also
construction from parts built elsewhere.

This is also in turn why there are many different `Config` structs in this
crate. Let's look more closely at an example: [`hybrid::regex::Builder`]. It
accepts three different `Config` types for configuring construction of a lazy
DFA regex:

* [`hybrid::regex::Builder::syntax`] accepts a
[`util::syntax::Config`] for configuring the options found in the
[`regex-syntax`](regex_syntax) crate. For example, whether to match
case insensitively.
* [`hybrid::regex::Builder::thompson`] accepts a [`nfa::thompson::Config`] for
configuring construction of a [Thompson NFA](nfa::thompson::NFA). For example,
whether to build an NFA that matches the reverse language described by the
regex.
* [`hybrid::regex::Builder::dfa`] accept a [`hybrid::dfa::Config`] for
configuring construction of the pair of underlying lazy DFAs that make up the
lazy DFA regex engine. For example, changing the capacity of the cache used to
store the transition table.

The lazy DFA regex engine uses all three of those configuration objects for
methods like [`hybrid::regex::Builder::build`], which accepts a pattern
string containing the concrete syntax of your regex. It uses the syntax
configuration to parse it into an AST and translate it into an HIR. Then the
NFA configuration when compiling the HIR into an NFA. And then finally the DFA
configuration when lazily determinizing the NFA into a DFA.

Notice though that the builder also has a
[`hybrid::regex::Builder::build_from_dfas`] constructor. This permits callers
to build the underlying pair of lazy DFAs themselves (one for the forward
searching to find the end of a match and one for the reverse searching to find
the start of a match), and then build the regex engine from them. The lazy
DFAs, in turn, have their own builder that permits [construction directly from
a Thompson NFA](hybrid::dfa::Builder::build_from_nfa). Continuing down the
rabbit hole, a Thompson NFA has its own compiler that permits [construction
directly from an HIR](nfa::thompson::Compiler::build_from_hir). The lazy DFA
regex engine builder lets you follow this rabbit hole all the way down, but
also provides convenience routines that do it for you when you don't need
precise control over every component.

The [meta regex engine](meta) is a good example of something that utilizes the
full flexibility of these builders. It often needs not only precise control
over each component, but also shares them across multiple regex engines.
(Most sharing is done by internal reference accounting. For example, an
[`NFA`](nfa::thompson::NFA) is reference counted internally which makes cloning
cheap.)

### Size limits

Unlike the `regex` crate, the `regex-automata` crate specifically does not
enable any size limits by default. That means users of this crate need to
be quite careful when using untrusted patterns. Namely, because bounded
repetitions can grow exponentially by stacking them, it is possible to build a
very large internal regex object from just a small pattern string. For example,
the NFA built from the pattern `a{10}{10}{10}{10}{10}{10}{10}` is over 240MB.

There are multiple size limit options in this crate. If one or more size limits
are relevant for the object you're building, they will be configurable via
methods on a corresponding `Config` type.

# Crate features

This crate has a dizzying number of features. The main idea is to be able to
control how much stuff you pull in for your specific use case, since the full
crate is quite large and can dramatically increase compile times and binary
size.

The most barebones but useful configuration is to disable all default features
and enable only `dfa-search`. This will bring in just the DFA deserialization
and search routines without any dependency on `std` or `alloc`. This does
require generating and serializing a DFA, and then storing it somewhere, but
it permits regex searches in freestanding or embedded environments.

Because there are so many features, they are split into a few groups.

The default set of features is: `std`, `syntax`, `perf`, `unicode`, `meta`,
`nfa`, `dfa` and `hybrid`. Basically, the default is to enable everything
except for development related features like `logging`.

### Ecosystem features

* **std** - Enables use of the standard library. In terms of APIs, this usually
just means that error types implement the `std::error::Error` trait. Otherwise,
`std` sometimes enables the code to be faster, for example, using a `HashMap`
instead of a `BTreeMap`. (The `std` feature matters more for dependencies like
`aho-corasick` and `memchr`, where `std` is required to enable certain classes
of SIMD optimizations.) Enabling `std` automatically enables `alloc`.
* **alloc** - Enables use of the `alloc` library. This is required for most
APIs in this crate. The main exception is deserializing and searching with
fully compiled DFAs.
* **logging** - Adds a dependency on the `log` crate and makes this crate emit
log messages of varying degrees of utility. The log messages are especially
useful in trying to understand what the meta regex engine is doing.

### Performance features

* **perf** - Enables all of the below features.
* **perf-inline** - When enabled, `inline(always)` is used in (many) strategic
locations to help performance at the expense of longer compile times and
increased binary size.
* **perf-literal** - Enables all literal related optimizations.
    * **perf-literal-substring** - Enables all single substring literal
    optimizations. This includes adding a dependency on the `memchr` crate.
    * **perf-literal-multisubstring** - Enables all multiple substring literal
    optimizations. This includes adding a dependency on the `aho-corasick`
    crate.

### Unicode features

* **unicode** -
  Enables all Unicode features. This feature is enabled by default, and will
  always cover all Unicode features, even if more are added in the future.
* **unicode-age** -
  Provide the data for the
  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
  This makes it possible to use classes like `\p{Age:6.0}` to refer to all
  codepoints first introduced in Unicode 6.0
* **unicode-bool** -
  Provide the data for numerous Unicode boolean properties. The full list
  is not included here, but contains properties like `Alphabetic`, `Emoji`,
  `Lowercase`, `Math`, `Uppercase` and `White_Space`.
* **unicode-case** -
  Provide the data for case insensitive matching using
  [Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
* **unicode-gencat** -
  Provide the data for
  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
  This includes, but is not limited to, `Decimal_Number`, `Letter`,
  `Math_Symbol`, `Number` and `Punctuation`.
* **unicode-perl** -
  Provide the data for supporting the Unicode-aware Perl character classes,
  corresponding to `\w`, `\s` and `\d`. This is also necessary for using
  Unicode-aware word boundary assertions. Note that if this feature is
  disabled, the `\s` and `\d` character classes are still available if the
  `unicode-bool` and `unicode-gencat` features are enabled, respectively.
* **unicode-script** -
  Provide the data for
  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
  `Latin` and `Thai`.
* **unicode-segment** -
  Provide the data necessary to provide the properties used to implement the
  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
  This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
  `\p{sb=ATerm}`.
* **unicode-word-boundary** -
  Enables support for Unicode word boundaries, i.e., `\b`, in regexes. When
  this and `unicode-perl` are enabled, then data tables from `regex-syntax` are
  used to implement Unicode word boundaries. However, if `regex-syntax` isn't
  enabled as a dependency then one can still enable this feature. It will
  cause `regex-automata` to bundle its own data table that would otherwise be
  redundant with `regex-syntax`'s table.

### Regex engine features

* **syntax** - Enables a dependency on `regex-syntax`. This makes APIs
for building regex engines from pattern strings available. Without the
`regex-syntax` dependency, the only way to build a regex engine is generally
to deserialize a previously built DFA or to hand assemble an NFA using its
[builder API](nfa::thompson::Builder). Once you have an NFA, you can build any
of the regex engines in this crate. The `syntax` feature also enables `alloc`.
* **meta** - Enables the meta regex engine. This also enables the `syntax` and
`nfa-pikevm` features, as both are the minimal requirements needed. The meta
regex engine benefits from enabling any of the other regex engines and will
use them automatically when appropriate.
* **nfa** - Enables all NFA related features below.
    * **nfa-thompson** - Enables the Thompson NFA APIs. This enables `alloc`.
    * **nfa-pikevm** - Enables the PikeVM regex engine. This enables
    `nfa-thompson`.
    * **nfa-backtrack** - Enables the bounded backtracker regex engine. This
    enables `nfa-thompson`.
* **dfa** - Enables all DFA related features below.
    * **dfa-build** - Enables APIs for determinizing DFAs from NFAs. This
    enables `nfa-thompson` and `dfa-search`.
    * **dfa-search** - Enables APIs for searching with DFAs.
    * **dfa-onepass** - Enables the one-pass DFA API. This enables
    `nfa-thompson`.
* **hybrid** - Enables the hybrid NFA/DFA or "lazy DFA" regex engine. This
enables `alloc` and `nfa-thompson`.

*/// We are no_std.// All APIs need docs!// Some intra-doc links are broken when certain features are disabled, so we// only bleat about it when most (all?) features are enabled. But when we do,// we block the build. Links need to work.// Broken rustdoc links are very easy to come by when you start disabling// features. Namely, features tend to change imports, and imports change what's// available to link to.// Basically, we just don't support rustdoc for anything other than the maximal// feature configuration. Other configurations will work, they just won't be// perfect.// So here, we specifically allow them so we don't even get warned about them.// Kinda similar, but eliminating all of the dead code and unused import// warnings for every feature combo is a fool's errand. Instead, we just// suppress those, but still let them through in a common configuration when we// build most of everything.// This does actually suggest that when features are disabled, we are actually// compiling more code than we need to be. And this is perhaps not so great// because disabling features is usually done in order to reduce compile times// by reducing the amount of code one compiles... However, usually, most of the// time this dead code is a relatively small amount from the 'util' module.// But... I confess... There isn't a ton of visibility on this.// I'm happy to try to address this in a different way, but "let's annotate// every function in 'util' with some non-local combination of features" just// cannot be the way forward.// We generally want all types to impl Debug.// No clue why this thing is still unstable because it's pretty amazing. This// adds Cargo feature annotations to items in the rustdoc output. Which is// sadly hugely beneficial for this crate due to the number of features.hir/// An error that occurs when construction of a `Regex` fails./// A build error is generally a result of one of two possible failure/// modes. First is a parse or syntax error in the concrete syntax of a/// pattern. Second is that the construction of the underlying regex matcher/// fails, usually because it gets too big with respect to limits like/// [`Config::nfa_size_limit`](crate::meta::Config::nfa_size_limit)./// This error provides very little introspection capabilities. You can:/// * Ask for the [`PatternID`] of the pattern that caused an error, if one/// is available. This is available for things like syntax errors, but not for/// cases where build limits are exceeded./// * Ask for the underlying syntax error, but only if the error is a syntax/// * Ask for a human readable message corresponding to the underlying error./// * The `BuildError::source` method (from the `std::error::Error`/// trait implementation) may be used to query for an underlying error if one/// exists. There are no API guarantees about which error is returned./// When the `std` feature is enabled, this implements `std::error::Error`./// If it is known which pattern ID caused this build error to occur, then/// this method returns it./// Some errors are not associated with a particular pattern. However, any/// errors that occur as part of parsing a pattern are guaranteed to be/// associated with a pattern ID./// use regex_automata::{meta::Regex, PatternID};/// let err = Regex::new_many(&["a", "b", r"\p{Foo}", "c"]).unwrap_err();/// assert_eq!(Some(PatternID::must(2)), err.pattern());/// If this error occurred because the regex exceeded the configured size/// limit before being built, then this returns the configured size limit./// The limit returned is what was configured, and corresponds to the/// maximum amount of heap usage in bytes.syntax_error/// If this error corresponds to a syntax error, then a reference to it is/// returned by this method.RetryQuadraticErrorQuadraticRetryFailError/// An error that occurs when a search should be retried./// This retry error distinguishes between two different failure modes./// The first is one where potential quadratic behavior has been detected./// In this case, whatever optimization that led to this behavior should be/// stopped, and the next best strategy should be used./// The second indicates that the underlying regex engine has failed for some/// reason. This usually occurs because either a lazy DFA's cache has become/// ineffective or because a non-ASCII byte has been seen *and* a Unicode word/// boundary was used in one of the patterns. In this failure case, a different/// regex engine that won't fail in these ways (PikeVM, backtracker or the/// one-pass DFA) should be used./// This is an internal error only and should never bleed into the public/// API./// An error that occurs when potential quadratic behavior has been detected/// when applying either the "reverse suffix" or "reverse inner" optimizations./// When this error occurs, callers should abandon the "reverse" optimization/// and use a normal forward search./// An error that occurs when a regex engine "gives up" for some reason before/// finishing a search. Usually this occurs because of heuristic Unicode word/// boundary support or because of ineffective cache usage in the lazy DFA./// When this error occurs, callers should retry the regex search with a/// different regex engine./// Note that this has convenient `From` impls that will automatically/// convert a `MatchError` into this error. This works because the meta/// regex engine internals guarantee that errors like `HaystackTooLong` and/// `UnsupportedAnchored` will never occur. The only errors left are `Quit` and/// `GaveUp`, which both correspond to this "failure" error.hybrid_try_search_half_revhybrid_eoi_rev/*!
This module defines two bespoke reverse DFA searching routines. (One for the
lazy DFA and one for the fully compiled DFA.) These routines differ from the
usual ones by permitting the caller to specify a minimum starting position.
That is, the search will begin at `input.end()` and will usually stop at
`input.start()`, unless `min_start > input.start()`, in which case, the search
will stop at `min_start`.

In other words, this lets you say, "no, the search must not extend past this
point, even if it's within the bounds of the given `Input`." And if the search
*does* want to go past that point, it stops and returns a "may be quadratic"
error, which indicates that the caller should retry using some other technique.

These routines specifically exist to protect against quadratic behavior when
employing the "reverse suffix" and "reverse inner" optimizations. Without the
backstop these routines provide, it is possible for parts of the haystack to
get re-scanned over and over again. The backstop not only prevents this, but
*tells you when it is happening* so that you can change the strategy.

Why can't we just use the normal search routines? We could use the normal
search routines and just set the start bound on the provided `Input` to our
`min_start` position. The problem here is that it's impossible to distinguish
between "no match because we reached the end of input" and "determined there
was no match well before the end of input." The former case is what we care
about with respect to quadratic behavior. The latter case is totally fine.

Why don't we modify the normal search routines to report the position at which
the search stops? I considered this, and I still wonder if it is indeed the
right thing to do. However, I think the straight-forward thing to do there
would be to complicate the return type signature of almost every search routine
in this crate, which I really do not want to do. It therefore might make more
sense to provide a richer way for search routines to report meta data, but that
was beyond my bandwidth to work on at the time of writing.

See the 'opt/reverse-inner' and 'opt/reverse-suffix' benchmarks in rebar for a
real demonstration of how quadratic behavior is mitigated.
*/HirRegexInfoalternation_literals/// Pull out an alternation of literals from the given sequence of HIR/// There are numerous ways for this to fail. Generally, this only applies/// to regexes of the form 'foo|bar|baz|...|quux'. It can also fail if there/// are "too few" alternates, in which case, the regex engine is likely faster./// And currently, this only returns something when 'hirs.len() == 1'.reverse_innerstopat/*!
Provides a regex matcher that composes several other regex matchers
automatically.

This module is home to a meta [`Regex`], which provides a convenient high
level API for executing regular expressions in linear time.

# Comparison with the `regex` crate

A meta `Regex` is the implementation used directly by the `regex` crate.
Indeed, the `regex` crate API is essentially just a light wrapper over a meta
`Regex`. This means that if you need the full flexibility offered by this
API, then you should be able to switch to using this API directly without
any changes in match semantics or syntax. However, there are some API level
differences:

* The `regex` crate API returns match objects that include references to the
haystack itself, which in turn makes it easy to access the matching strings
without having to slice the haystack yourself. In contrast, a meta `Regex`
returns match objects that only have offsets in them.
* At time of writing, a meta `Regex` doesn't have some of the convenience
routines that the `regex` crate has, such as replacements. Note though that
[`Captures::interpolate_string`](crate::util::captures::Captures::interpolate_string)
will handle the replacement string interpolation for you.
* A meta `Regex` supports the [`Input`](crate::Input) abstraction, which
provides a way to configure a search in more ways than is supported by the
`regex` crate. For example, [`Input::anchored`](crate::Input::anchored) can
be used to run an anchored search, regardless of whether the pattern is itself
anchored with a `^`.
* A meta `Regex` supports multi-pattern searching everywhere.
Indeed, every [`Match`](crate::Match) returned by the search APIs
include a [`PatternID`](crate::PatternID) indicating which pattern
matched. In the single pattern case, all matches correspond to
[`PatternID::ZERO`](crate::PatternID::ZERO). In contrast, the `regex` crate
has distinct `Regex` and a `RegexSet` APIs. The former only supports a single
pattern, while the latter supports multiple patterns but cannot report the
offsets of a match.
* A meta `Regex` provides the explicit capability of bypassing its internal
memory pool for automatically acquiring mutable scratch space required by its
internal regex engines. Namely, a [`Cache`] can be explicitly provided to lower
level routines such as [`Regex::search_with`].

*/GroupInfoPoolGuardCachePoolCachePoolFn/// A type alias for our pool of meta::Cache that fixes the type parameters to/// what we use for the meta regex below.CachePoolGuard/// Same as above, but for the guard returned by a pool./// The type of the closure we use to create new caches. We need to spell out/// all of the marker traits or else we risk leaking !MARKER impls.RegexI/// The actual regex implementation./// A thread safe pool of caches./// For the higher level search APIs, a `Cache` is automatically plucked/// from this pool before running a search. The lower level `with` methods/// permit the caller to provide their own cache, thereby bypassing/// accesses to this pool./// Note that we put this outside the `Arc` so that cloning a `Regex`/// results in creating a fresh `CachePool`. This in turn permits callers/// to clone regexes into separate threads where each such regex gets/// the pool's "thread owner" optimization. Otherwise, if one shares the/// `Regex` directly, then the pool will go through a slower mutex path for/// all threads except for the "owner."/// A regex matcher that works by composing several other regex matchers/// In effect, a meta regex papers over a lot of the quirks or performance/// problems in each of the regex engines in this crate. Its goal is to provide/// an infallible and simple API that "just does the right thing" in the common/// A meta regex is the implementation of a `Regex` in the `regex` crate./// Indeed, the `regex` crate API is essentially just a light wrapper over/// this type. This includes the `regex` crate's `RegexSet` API!/// # Composition/// This is called a "meta" matcher precisely because it uses other regex/// matchers to provide a convenient high level regex API. Here are some/// examples of how other regex matchers are composed:/// * When calling [`Regex::captures`], instead of immediately/// running a slower but more capable regex engine like the/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM), the meta regex engine/// will usually first look for the bounds of a match with a higher throughput/// regex engine like a [lazy DFA](crate::hybrid). Only when a match is found/// is a slower engine like `PikeVM` used to find the matching span for each/// capture group./// * While higher throughout engines like the lazy DFA cannot handle/// Unicode word boundaries in general, they can still be used on pure ASCII/// haystacks by pretending that Unicode word boundaries are just plain ASCII/// word boundaries. However, if a haystack is not ASCII, the meta regex engine/// will automatically switch to a (possibly slower) regex engine that supports/// Unicode word boundaries in general./// * In some cases where a regex pattern is just a simple literal or a small/// set of literals, an actual regex engine won't be used at all. Instead,/// substring or multi-substring search algorithms will be employed./// There are many other forms of composition happening too, but the above/// should give a general idea. In particular, it may perhaps be surprising/// that *multiple* regex engines might get executed for a single search. That/// is, the decision of what regex engine to use is not _just_ based on the/// pattern, but also based on the dynamic execution of the search itself./// The primary reason for this composition is performance. The fundamental/// tension is that the faster engines tend to be less capable, and the more/// capable engines tend to be slower./// Note that the forms of composition that are allowed are determined by/// compile time crate features and configuration. For example, if the `hybrid`/// feature isn't enabled, or if [`Config::hybrid`] has been disabled, then the/// meta regex engine will never use a lazy DFA./// # Synchronization and cloning/// Most of the regex engines in this crate require some kind of mutable/// "scratch" space to read and write from while performing a search. Since/// a meta regex composes these regex engines, a meta regex also requires/// mutable scratch space. This scratch space is called a [`Cache`]./// Most regex engines _also_ usually have a read-only component, typically/// a [Thompson `NFA`](crate::nfa::thompson::NFA)./// In order to make the `Regex` API convenient, most of the routines hide/// the fact that a `Cache` is needed at all. To achieve this, a [memory/// pool](crate::util::pool::Pool) is used internally to retrieve `Cache`/// values in a thread safe way that also permits reuse. This in turn implies/// that every such search call requires some form of synchronization. Usually/// this synchronization is fast enough to not notice, but in some cases, it/// can be a bottleneck. This typically occurs when all of the following are/// true:/// * The same `Regex` is shared across multiple threads simultaneously,/// usually via a [`util::lazy::Lazy`](crate::util::lazy::Lazy) or something/// similar from the `once_cell` or `lazy_static` crates./// * The primary unit of work in each thread is a regex search./// * Searches are run on very short haystacks./// This particular case can lead to high contention on the pool used by a/// `Regex` internally, which can in turn increase latency to a noticeable/// effect. This cost can be mitigated in one of the following ways:/// * Use a distinct copy of a `Regex` in each thread, usually by cloning it./// Cloning a `Regex` _does not_ do a deep copy of its read-only component./// But it does lead to each `Regex` having its own memory pool, which in/// turn eliminates the problem of contention. In general, this technique should/// not result in any additional memory usage when compared to sharing the same/// `Regex` across multiple threads simultaneously./// * Use lower level APIs, like [`Regex::search_with`], which permit passing/// a `Cache` explicitly. In this case, it is up to you to determine how best/// to provide a `Cache`. For example, you might put a `Cache` in thread-local/// storage if your use case allows for it./// Overall, this is an issue that happens rarely in practice, but it can/// happen./// # Warning: spin-locks may be used in alloc-only mode/// When this crate is built without the `std` feature and the high level APIs/// on a `Regex` are used, then a spin-lock will be used to synchronize access/// to an internal pool of `Cache` values. This may be undesirable because/// a spin-lock is [effectively impossible to implement correctly in user/// space][spinlocks-are-bad]. That is, more concretely, the spin-lock could/// [spinlocks-are-bad]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html/// If one wants to avoid the use of spin-locks when the `std` feature is/// disabled, then you must use APIs that accept a `Cache` value explicitly./// For example, [`Regex::search_with`]./// use regex_automata::meta::Regex;/// let re = Regex::new(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$")?;/// assert!(re.is_match("2010-03-14"));/// This example shows how to use [`Input::anchored`] to run an anchored/// search, even when the regex pattern itself isn't anchored. An anchored/// search guarantees that if a match is found, then the start offset of the/// match corresponds to the offset at which the search was started./// use regex_automata::{meta::Regex, Anchored, Input, Match};/// let re = Regex::new(r"\bfoo\b")?;/// let input = Input::new("xx foo xx").range(3..).anchored(Anchored::Yes);/// // The offsets are in terms of the original haystack./// assert_eq!(Some(Match::must(0, 3..6)), re.find(input));/// // Notice that no match occurs here, because \b still takes the/// // surrounding context into account, even if it means looking back/// // before the start of your search./// let hay = "xxfoo xx";/// let input = Input::new(hay).range(2..).anchored(Anchored::Yes);/// assert_eq!(None, re.find(input));/// // Indeed, you cannot achieve the above by simply slicing the/// // haystack itself, since the regex engine can't see the/// // surrounding context. This is why 'Input' permits setting/// // the bounds of a search!/// let input = Input::new(&hay[2..]).anchored(Anchored::Yes);/// // WRONG!/// assert_eq!(Some(Match::must(0, 0..3)), re.find(input));/// # Example: earliest search/// This example shows how to use [`Input::earliest`] to run a search that/// might stop before finding the typical leftmost match./// let re = Regex::new(r"[a-z]{3}|b")?;/// let input = Input::new("abc").earliest(true);/// assert_eq!(Some(Match::must(0, 1..2)), re.find(input));/// // Note that "earliest" isn't really a match semantic unto itself./// // Instead, it is merely an instruction to whatever regex engine/// // gets used internally to quit as soon as it can. For example,/// // this regex uses a different search technique, and winds up/// // producing a different (but valid) match!/// let re = Regex::new(r"abc|b")?;/// # Example: change the line terminator/// This example shows how to enable multi-line mode by default and change/// the line terminator to the NUL byte:/// use regex_automata::{meta::Regex, util::syntax, Match};///     .syntax(syntax::Config::new().multi_line(true))///     .configure(Regex::config().line_terminator(b'\x00'))///     .build(r"^foo$")?;/// assert_eq!(Some(Match::must(0, 1..4)), re.find(hay));strat/// The core matching engine./// Why is this reference counted when RegexI is already wrapped in an Arc?/// Well, we need to capture this in a closure to our `Pool` below in order/// to create new `Cache` values when needed. So since it needs to be in/// two places, we make it reference counted./// We make `RegexI` itself reference counted too so that `Regex` itself/// stays extremely small and very cheap to clone./// Metadata about the regexes driving the strategy. The metadata is also/// usually stored inside the strategy too, but we put it here as well/// so that we can get quick access to it (without virtual calls) before/// executing the regex engine. For example, we use this metadata to/// detect a subset of cases where we know a match is impossible, and can/// thus avoid calling into the strategy at all./// Since `RegexInfo` is stored in multiple places, it is also reference/// counted./// The internal implementation of `Regex`, split out so that it can be wrapped/// in an `Arc`./// Builds a `Regex` from a single pattern string using the default/// If there was a problem parsing the pattern or a problem turning it into/// a regex matcher, then an error is returned./// If you want to change the configuration of a `Regex`, use a [`Builder`]/// with a [`Config`]./// use regex_automata::{meta::Regex, Match};/// let re = Regex::new(r"(?Rm)^foo$")?;/// assert_eq!(Some(Match::must(0, 2..5)), re.find(hay));/// Builds a `Regex` from many pattern strings using the default/// If there was a problem parsing any of the patterns or a problem turning/// them into a regex matcher, then an error is returned./// # Example: simple lexer/// This simplistic example leverages the multi-pattern support to build a/// simple little lexer. The pattern ID in the match tells you which regex/// matched, which in turn might be used to map back to the "type" of the/// token returned by the lexer./// let re = Regex::new_many(&[///     r"[[:space:]]",///     r"[A-Za-z0-9][A-Za-z0-9_]+",///     r"->",///     r".",/// let haystack = "fn is_boss(bruce: i32, springsteen: String) -> bool;";/// let matches: Vec<Match> = re.find_iter(haystack).collect();///     Match::must(1, 0..2),   // 'fn'///     Match::must(0, 2..3),   // ' '///     Match::must(1, 3..10),  // 'is_boss'///     Match::must(3, 10..11), // '('///     Match::must(1, 11..16), // 'bruce'///     Match::must(3, 16..17), // ':'///     Match::must(0, 17..18), // ' '///     Match::must(1, 18..21), // 'i32'///     Match::must(3, 21..22), // ','///     Match::must(0, 22..23), // ' '///     Match::must(1, 23..34), // 'springsteen'///     Match::must(3, 34..35), // ':'///     Match::must(0, 35..36), // ' '///     Match::must(1, 36..42), // 'String'///     Match::must(3, 42..43), // ')'///     Match::must(0, 43..44), // ' '///     Match::must(2, 44..46), // '->'///     Match::must(0, 46..47), // ' '///     Match::must(1, 47..51), // 'bool'///     Match::must(3, 51..52), // ';'/// One can write a lexer like the above using a regex like/// `(?P<space>[[:space:]])|(?P<ident>[A-Za-z0-9][A-Za-z0-9_]+)|...`,/// but then you need to ask whether capture group matched to determine/// which branch in the regex matched, and thus, which token the match/// corresponds to. In contrast, the above example includes the pattern ID/// in the match. There's no need to use capture groups at all./// # Example: finding the pattern that caused an error/// When a syntax error occurs, it is possible to ask which pattern/// caused the syntax error./// # Example: zero patterns is valid/// Building a regex with zero patterns results in a regex that never/// matches anything. Because this routine is generic, passing an empty/// slice usually requires a turbo-fish (or something else to help type/// inference)./// let re = Regex::new_many::<&str>(&[])?;/// assert_eq!(None, re.find(""));/// Return a default configuration for a `Regex`./// type when customizing the construction of a `Regex`./// # Example: lower the NFA size limit/// In some cases, the default size limit might be too big. The size limit/// can be lowered, which will prevent large regex patterns from compiling./// let result = Regex::builder()///     .configure(Regex::config().nfa_size_limit(Some(20 * (1<<10))))///     // Not even 20KB is enough to build a single large Unicode class!///     .build(r"\pL");/// Convenience constructors for a `Regex` using the default configuration./// will never lead to a different result. (Consider how this might make/// a difference given the regex `a+` on the haystack `aaaaaaaaaaaaaaa`./// This routine _may_ stop after it sees the first `a`, but routines like/// `find` need to continue searching because `+` is greedy by default.)/// assert!(re.is_match("foo12345bar"));/// assert!(!re.is_match("foobar"));/// `is_match` is guaranteed to return `true` whenever `find` returns a/// match. This includes searches that are executed entirely within a/// use regex_automata::{meta::Regex, Input};/// let re = Regex::new("a*")?;/// // This doesn't match because the default configuration bans empty/// // matches from splitting a codepoint./// assert!(!re.is_match(Input::new("☃").span(1..2)));/// assert_eq!(None, re.find(Input::new("☃").span(1..2)));/// use regex_automata::{meta::Regex, Input, Match};///     .configure(Regex::config().utf8_empty(false))/// assert!(re.is_match(Input::new("☃").span(1..2)));///     Some(Match::must(0, 1..1)),///     re.find(Input::new("☃").span(1..2)),/// A similar idea applies when using line anchors with CRLF mode enabled,/// which prevents them from matching between a `\r` and a `\n`./// let re = Regex::new(r"(?Rm:$)")?;/// assert!(!re.is_match(Input::new("\r\n").span(1..1)));/// // A regular line anchor, which only considers \n as a/// // line terminator, will match./// let re = Regex::new(r"(?m:$)")?;/// assert!(re.is_match(Input::new("\r\n").span(1..1)));/// Executes a leftmost search and returns the first match that is found,/// if one exists./// assert_eq!(Some(Match::must(0, 0..8)), re.find("foo12345"));/// Executes a leftmost forward search and writes the spans of capturing/// groups that participated in a match into the provided [`Captures`]/// value. If no match was found, then [`Captures::is_match`] is guaranteed/// to return `false`./// use regex_automata::{meta::Regex, Span};/// let re = Regex::new(r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$")?;/// re.captures("2010-03-14", &mut caps);/// assert!(caps.is_match());/// assert_eq!(Some(Span::from(0..4)), caps.get_group(1));/// assert_eq!(Some(Span::from(5..7)), caps.get_group(2));/// assert_eq!(Some(Span::from(8..10)), caps.get_group(3));/// Returns an iterator over all non-overlapping leftmost matches in/// the given haystack. If no match exists, then the iterator yields no/// let haystack = "foo1 foo12 foo123";/// Returns an iterator over all non-overlapping `Captures` values. If no/// match exists, then the iterator yields no elements./// This yields the same matches as [`Regex::find_iter`], but it includes/// the spans of all capturing groups that participate in each match./// **Tip:** See [`util::iter::Searcher`](crate::util::iter::Searcher) for/// how to correctly iterate over all matches in a haystack while avoiding/// the creation of a new `Captures` value for every match. (Which you are/// forced to do with an `Iterator`.)/// let re = Regex::new("foo(?P<numbers>[0-9]+)")?;/// let matches: Vec<Span> = re///     .captures_iter(haystack)///     // The unwrap is OK since 'numbers' matches if the pattern matches.///     .map(|caps| caps.get_group_by_name("numbers").unwrap())///     Span::from(3..4),///     Span::from(8..10),///     Span::from(14..17),/// Returns an iterator of spans of the haystack given, delimited by a/// let re = Regex::new(r"[ \t]+")?;/// let fields: Vec<&str> = re.split(hay).map(|span| &hay[span]).collect();/// let re = Regex::new(r" ")?;/// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();/// let re = Regex::new(r"X")?;/// let re = Regex::new(r"::")?;/// let re = Regex::new(r"/")?;/// spans./// let re = Regex::new(r"0")?;/// let re = Regex::new(r"")?;/// But note that UTF-8 mode for empty strings can be disabled, which will/// then result in a match at every byte offset in the haystack,/// including between every UTF-8 code unit./// let got: Vec<&[u8]> = re.split(hay).map(|sp| &hay[sp]).collect();///     // Writing byte string slices is just brutal. The problem is that///     // b"foo" has type &[u8; 3] instead of &[u8]./// let re = Regex::new(r" +")?;/// Returns an iterator of at most `limit` spans of the haystack given,/// delimited by a match of the regex. (A `limit` of `0` will return no/// spans.) Namely, each element of the iterator corresponds to a part/// of the haystack that *isn't* matched by the regular expression. The/// remainder of the haystack that is not split will be the last element in/// let fields: Vec<&str> =///     re.splitn(hay, 3).map(|span| &hay[span]).collect();/// let got: Vec<&str> = re.splitn(hay, 3).map(|sp| &hay[sp]).collect();/// let got: Vec<&str> = re.splitn(hay, 2).map(|sp| &hay[sp]).collect();/// let got: Vec<&str> = re.splitn(hay, 1).map(|sp| &hay[sp]).collect();/// let got: Vec<&str> = re.splitn(hay, 0).map(|sp| &hay[sp]).collect();/// High level convenience routines for using a regex to search a haystack./// This is like [`Regex::find`] but, but it accepts a concrete `&Input`/// instead of an `Into<Input>`./// let re = Regex::new(r"Samwise|Sam")?;/// let input = Input::new(///     "one of the chief characters, Samwise the Brave",/// assert_eq!(Some(Match::must(0, 29..36)), re.search(&input));search_half/// Returns the end offset of the leftmost match. If no match exists, then/// This is distinct from [`Regex::search`] in that it only returns the end/// of a match and not the start of the match. Depending on a variety of/// implementation details, this _may_ permit the regex engine to do less/// overall work. For example, if a DFA is being used to execute a search,/// then the start of a match usually requires running a separate DFA in/// reverse to the find the start of a match. If one only needs the end of/// a match, then the separate reverse scan to find the start of a match/// can be skipped. (Note that the reverse scan is avoided even when using/// `Regex::search` when possible, for example, in the case of an anchored/// search.)/// use regex_automata::{meta::Regex, Input, HalfMatch};/// assert_eq!(Some(HalfMatch::must(0, 36)), re.search_half(&input));search_captures/// This is like [`Regex::captures`], but it accepts a concrete `&Input`/// This example shows how to build a multi-pattern `Regex` that permits/// searching for specific patterns.///     meta::Regex,///     Anchored, Match, PatternID, Input,/// let re = Regex::new_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;/// let expected = Some(Match::must(0, 0..6));/// re.search_captures(&Input::new(haystack), &mut caps);/// let expected = Some(Match::must(1, 0..6));/// re.search_captures(&input, &mut caps);/// use regex_automata::{meta::Regex, Match, Input};/// let re = Regex::new(r"\b[0-9]{3}\b")?;search_slots/// groups that participated in a match into the provided `slots`, and/// returns the matching pattern ID. The contents of the slots for patterns/// other than the matching pattern are unspecified. If no match was found,/// then `None` is returned and the contents of `slots` is unspecified./// This is like [`Regex::search`], but it accepts a raw slots slice/// * A slice with [`pattern_len() * 2`](Regex::pattern_len) slots, if you/// only care about the overall match spans for each matching pattern./// use regex_automata::{meta::Regex, PatternID, Input};/// let input = Input::new("!@#123");/// let pid = re.search_slots(&input, &mut slots);/// assert_eq!(Some(3), slots[slot_start].map(|s| s.get()));/// assert_eq!(Some(6), slots[slot_end].map(|s| s.get()));which_overlapping_matches/// position and this `Regex` was configured with [`MatchKind::All`]/// semantics, then all matching patterns are written to the given set./// Unless all of the patterns in this `Regex` are anchored, then generally/// speaking, this will scan the entire haystack./// It is important that we configure the `Regex` with [`MatchKind::All`]/// semantics here, or else overlapping matches will not be reported./// use regex_automata::{meta::Regex, Input, MatchKind, PatternSet};///     .configure(Regex::config().match_kind(MatchKind::All))/// let mut patset = PatternSet::new(re.pattern_len());/// re.which_overlapping_matches(&input, &mut patset);/// Lower level search routines that give more control.search_with/// This is like [`Regex::search`], but requires the caller to/// explicitly pass a [`Cache`]./// # Why pass a `Cache` explicitly?/// Passing a `Cache` explicitly will bypass the use of an internal memory/// pool used by `Regex` to get a `Cache` for a search. The use of this/// pool can be slower in some cases when a `Regex` is used from multiple/// threads simultaneously. Typically, performance only becomes an issue/// when there is heavy contention, which in turn usually only occurs/// when each thread's primary unit of work is a regex search on a small///     Some(Match::must(0, 29..36)),///     re.search_with(&mut cache, &input),search_half_with/// This is like [`Regex::search_half`], but requires the caller to///     Some(HalfMatch::must(0, 36)),///     re.search_half_with(&mut cache, &input),search_captures_with/// This is like [`Regex::search_captures`], but requires the caller to/// re.search_captures_with(&mut cache, &Input::new(haystack), &mut caps);/// re.search_captures_with(&mut cache, &input, &mut caps);search_slots_with/// This is like [`Regex::search_slots`], but requires the caller to/// let pid = re.search_slots_with(&mut cache, &input, &mut slots);which_overlapping_matches_with/// This is like [`Regex::which_overlapping_matches`], but requires the/// caller to explicitly pass a [`Cache`]./// re.which_overlapping_matches_with(&mut cache, &input, &mut patset);/// Lower level search routines that give more control, and require the caller/// to provide an explicit [`Cache`] parameter./// Creates a new object for recording capture group offsets. This is used/// in search APIs like [`Regex::captures`] and [`Regex::search_captures`]./// This is a convenience routine for/// `Captures::all(re.group_info().clone())`. Callers may build other types/// of `Captures` values that record less information (and thus require/// less work from the regex engine) using [`Captures::matches`] and/// [`Captures::empty`]./// This shows some alternatives to [`Regex::create_captures`]:///     util::captures::Captures,///     Match, PatternID, Span,/// let re = Regex::new(r"(?<first>[A-Z][a-z]+) (?<last>[A-Z][a-z]+)")?;/// // This is equivalent to Regex::create_captures. It stores matching/// // offsets for all groups in the regex./// let mut all = Captures::all(re.group_info().clone());/// re.captures("Bruce Springsteen", &mut all);/// assert_eq!(Some(Match::must(0, 0..17)), all.get_match());/// assert_eq!(Some(Span::from(0..5)), all.get_group_by_name("first"));/// assert_eq!(Some(Span::from(6..17)), all.get_group_by_name("last"));/// // In this version, we only care about the implicit groups, which/// // means offsets for the explicit groups will be unavailable. It can/// // sometimes be faster to ask for fewer groups, since the underlying/// // regex engine needs to do less work to keep track of them./// let mut matches = Captures::matches(re.group_info().clone());/// re.captures("Bruce Springsteen", &mut matches);/// // We still get the overall match info./// assert_eq!(Some(Match::must(0, 0..17)), matches.get_match());/// // But now the explicit groups are unavailable./// assert_eq!(None, matches.get_group_by_name("first"));/// assert_eq!(None, matches.get_group_by_name("last"));/// // Finally, in this version, we don't ask to keep track of offsets for/// // *any* groups. All we get back is whether a match occurred, and if/// // so, the ID of the pattern that matched./// let mut empty = Captures::empty(re.group_info().clone());/// re.captures("Bruce Springsteen", &mut empty);/// // it's a match!/// assert!(empty.is_match());/// // for pattern ID 0/// assert_eq!(Some(PatternID::ZERO), empty.pattern());/// // Match offsets are unavailable./// assert_eq!(None, empty.get_match());/// // And of course, explicit groups are unavailable too./// assert_eq!(None, empty.get_group_by_name("first"));/// assert_eq!(None, empty.get_group_by_name("last"));/// Creates a new cache for use with lower level search APIs like/// [`Regex::search_with`]./// The cache returned should only be used for searches for this `Regex`./// If you want to reuse the cache for another `Regex`, then you must call/// [`Cache::reset`] with that `Regex`./// This is a convenience routine for [`Cache::new`]./// let re = Regex::new(r"(?-u)m\w+\s+m\w+")?;/// let input = Input::new("crazy janey and her mission man");///     Some(Match::must(0, 20..31)),/// Returns the total number of patterns in this regex./// The standard [`Regex::new`] constructor always results in a `Regex`/// with a single pattern, but [`Regex::new_many`] permits building a/// multi-pattern regex./// A `Regex` guarantees that the maximum possible `PatternID` returned in/// any match is `Regex::pattern_len() - 1`. In the case where the number/// of patterns is `0`, a match is impossible./// let re = Regex::new(r"(?m)^[a-z]$")?;/// assert_eq!(1, re.pattern_len());/// assert_eq!(0, re.pattern_len());/// let re = Regex::new_many(&["a", "b", "c"])?;/// Returns the total number of capturing groups./// This includes the implicit capturing group corresponding to the/// entire match. Therefore, the minimum value returned is `1`./// This shows a few patterns and how many capture groups they have.///     Regex::new(pattern).map(|re| re.captures_len())/// assert_eq!(1, len("a")?);/// assert_eq!(2, len("(a)")?);/// assert_eq!(3, len("(a)|(b)")?);/// assert_eq!(5, len("(a)(b)|(c)(d)")?);/// assert_eq!(2, len("(a)|b")?);/// assert_eq!(2, len("a|(b)")?);/// assert_eq!(2, len("(b)*")?);/// assert_eq!(2, len("(b)+")?);/// # Example: multiple patterns/// This routine also works for multiple patterns. The total number is/// the sum of the capture groups of each pattern./// let len = |patterns| {///     Regex::new_many(patterns).map(|re| re.captures_len())/// assert_eq!(2, len(&["a", "b"])?);/// assert_eq!(4, len(&["(a)", "(b)"])?);/// assert_eq!(6, len(&["(a)|(b)", "(c)|(d)"])?);/// assert_eq!(8, len(&["(a)(b)|(c)(d)", "(x)(y)"])?);/// assert_eq!(3, len(&["(a)", "b"])?);/// assert_eq!(3, len(&["a", "(b)"])?);/// assert_eq!(4, len(&["(a)", "(b)*"])?);/// assert_eq!(4, len(&["(a)+", "(b)+"])?);/// This property extends to regexes with multiple patterns as well. In/// order for their to be a static number of capture groups in this case,/// every pattern must have the same static number.///     Regex::new_many(patterns).map(|re| re.static_captures_len())/// assert_eq!(Some(1), len(&["a", "b"])?);/// assert_eq!(Some(2), len(&["(a)", "(b)"])?);/// assert_eq!(Some(2), len(&["(a)|(b)", "(c)|(d)"])?);/// assert_eq!(Some(3), len(&["(a)(b)|(c)(d)", "(x)(y)"])?);/// assert_eq!(None, len(&["(a)", "b"])?);/// assert_eq!(None, len(&["a", "(b)"])?);/// assert_eq!(None, len(&["(a)", "(b)*"])?);/// assert_eq!(Some(2), len(&["(a)+", "(b)+"])?);/// Return information about the capture groups in this `Regex`./// A `GroupInfo` is an immutable object that can be cheaply cloned. It/// is responsible for maintaining a mapping between the capture groups/// in the concrete syntax of zero or more regex patterns and their/// internal representation used by some of the regex matchers. It is also/// responsible for maintaining a mapping between the name of each group/// (if one exists) and its corresponding group index./// A `GroupInfo` is ultimately what is used to build a [`Captures`] value,/// which is some mutable space where group offsets are stored as a result/// of a search./// Returns the configuration object used to build this `Regex`./// If no configuration object was explicitly passed, then the/// configuration returned represents the default.is_accelerated/// Returns true if this regex has a high chance of being "accelerated."/// The precise meaning of "accelerated" is specifically left unspecified,/// but the general meaning is that the search is a high likelihood of/// running faster than a character-at-a-time loop inside a standard/// regex engine./// When a regex is accelerated, it is only a *probabilistic* claim. That/// is, just because the regex is believed to be accelerated, that doesn't/// mean it will definitely execute searches very fast. Similarly, if a/// regex is *not* accelerated, that is also a probabilistic claim. That/// is, a regex for which `is_accelerated` returns `false` could still run/// searches more quickly than a regex for which `is_accelerated` returns/// Whether a regex is marked as accelerated or not is dependent on/// implementations details that may change in a semver compatible release./// That is, a regex that is accelerated in a `x.y.1` release might not be/// accelerated in a `x.y.2` release./// Basically, the value of acceleration boils down to a hedge: a hodge/// podge of internal heuristics combine to make a probabilistic guess/// that this regex search may run "fast." The value in knowing this from/// a caller's perspective is that it may act as a signal that no further/// work should be done to accelerate a search. For example, a grep-like/// tool might try to do some extra work extracting literals from a regex/// to create its own heuristic acceleration strategies. But it might/// choose to defer to this crate's acceleration strategy if one exists./// This routine permits querying whether such a strategy is active for a/// particular regex./// // A simple literal is very likely to be accelerated./// let re = Regex::new(r"foo")?;/// assert!(re.is_accelerated());/// // A regex with no literals is likely to not be accelerated./// let re = Regex::new(r"\w")?;/// assert!(!re.is_accelerated());/// Return the total approximate heap memory, in bytes, used by this `Regex`./// Note that currently, there is no high level configuration for setting/// a limit on the specific value returned by this routine. Instead, the/// following routines can be used to control heap memory at a bit of a/// lower level:/// * [`Config::nfa_size_limit`] controls how big _any_ of the NFAs are/// allowed to be./// * [`Config::onepass_size_limit`] controls how big the one-pass DFA is/// * [`Config::hybrid_cache_capacity`] controls how much memory the lazy/// DFA is permitted to allocate to store its transition table./// * [`Config::dfa_size_limit`] controls how big a fully compiled DFA is/// * [`Config::dfa_state_limit`] controls the conditions under which the/// meta regex engine will even attempt to build a fully compiled DFA./// Various non-search routines for querying properties of a `Regex` and/// convenience routines for creating [`Captures`] and [`Cache`] values.RegexInfoIprops_unionis_anchored_start/// Returns true when the search is guaranteed to be anchored. That is,/// when a match is reported, its offset is guaranteed to correspond to/// the start of the search./// This includes returning true when `input` _isn't_ anchored but the/// underlying regex is.is_always_anchored_start/// Returns true when this regex is always anchored to the start of a/// search. And in particular, that regardless of an `Input` configuration,/// if any match is reported it must start at `0`.is_always_anchored_end/// Returns true when this regex is always anchored to the end of a/// if any match is reported it must end at the end of the haystack.is_impossible/// Returns true if and only if it is known that a match is impossible/// for the given input. This is useful for short-circuiting and avoiding/// running the regex engine if it's known no match can be reported./// Note that this doesn't necessarily detect every possible case. For/// example, when `pattern_len() == 0`, a match is impossible, but that/// case is so rare that it's fine to be handled by the regex engine/// itself. That is, it's not worth the cost of adding it here in order to/// make it a little faster. The reason is that this is called for every/// search. so there is some cost to adding checks here. Arguably, some of/// the checks that are here already probably shouldn't be here.../// An iterator over all non-overlapping matches./// * `'r` represents the lifetime of the `Regex` that produced this iterator./// Returns the `Regex` value that created this iterator./// Returns the current `Input` associated with this iterator./// The `start` position on the given `Input` may change during iteration,/// but all other values are guaranteed to remain invariant./// An iterator over all non-overlapping leftmost matches with their capturing/// groups./// The iterator yields a [`Captures`] value until no more matches could be/// This iterator can be created with the [`Regex::captures_iter`] method./// Yields all substrings delimited by a regular expression match./// The spans correspond to the offsets between matches./// This iterator can be created with the [`Regex::split`] method./// Yields at most `N` spans delimited by a regular expression match./// The spans correspond to the offsets between matches. The last span will be/// whatever remains after splitting./// This iterator can be created with the [`Regex::splitn`] method.capmatchespikevmPikeVMCachebacktrackBoundedBacktrackerCacheOnePassCacheHybridCacherevhybridReverseHybridCache/// Represents mutable scratch space used by regex engines during a search./// Most of the regex engines in this crate require some kind of/// mutable state in order to execute a search. This mutable state is/// explicitly separated from the core regex object (such as a/// [`thompson::NFA`](crate::nfa::thompson::NFA)) so that the read-only regex/// object can be shared across multiple threads simultaneously without any/// synchronization. Conversely, a `Cache` must either be duplicated if using/// the same `Regex` from multiple threads, or else there must be some kind of/// synchronization that guarantees exclusive access while it's in use by one/// A `Regex` attempts to do this synchronization for you by using a thread/// pool internally. Its size scales roughly with the number of simultaneous/// regex searches./// For cases where one does not want to rely on a `Regex`'s internal thread/// pool, lower level routines such as [`Regex::search_with`] are provided/// that permit callers to pass a `Cache` into the search routine explicitly./// General advice is that the thread pool is often more than good enough./// However, it may be possible to observe the effects of its latency,/// especially when searching many small haystacks from many threads/// simultaneously./// Creates a new `Cache` for use with this regex./// A cache reset permits potentially reusing memory already allocated in/// this cache with a different `Regex`.///     re1.search_with(&mut cache, &Input::new("Δ")),///     re2.search_with(&mut cache, &Input::new("☃")),utf8_emptyautoprewhich_capturesnfa_size_limitonepass_size_limithybrid_cache_capacitydfa_state_limit/// An object describing the configuration of a `Regex`./// This configuration only includes options for the/// non-syntax behavior of a `Regex`, and can be applied via the/// [`Builder::configure`] method. For configuring the syntax options, see/// [`util::syntax::Config`](crate::util::syntax::Config)./// In some cases, the default size limit might be too big. The size limit can/// be lowered, which will prevent large regex patterns from compiling./// Create a new configuration object for a `Regex`./// Set the match semantics for a `Regex`./// The default value is [`MatchKind::LeftmostFirst`]./// use regex_automata::{meta::Regex, Match, MatchKind};/// // By default, leftmost-first semantics are used, which/// // disambiguates matches at the same position by selecting/// // the one that corresponds earlier in the pattern./// let re = Regex::new("sam|samwise")?;/// assert_eq!(Some(Match::must(0, 0..3)), re.find("samwise"));/// // But with 'all' semantics, match priority is ignored/// // and all match states are included. When coupled with/// // a leftmost search, the search will report the last/// // possible match.///     .build("sam|samwise")?;/// assert_eq!(Some(Match::must(0, 0..7)), re.find("samwise"));/// // Beware that this can lead to skipping matches!/// // Usually 'all' is used for anchored reverse searches/// // only, or for overlapping searches./// assert_eq!(Some(Match::must(0, 4..11)), re.find("sam samwise"));/// Toggles whether empty matches are permitted to occur between the code/// units of a UTF-8 encoded codepoint./// This should generally be enabled when search a `&str` or anything that/// you otherwise know is valid UTF-8. It should be disabled in all other/// cases. Namely, if the haystack is not valid UTF-8 and this is enabled,/// then behavior is unspecified./// By default, this is enabled./// let re = Regex::new("")?;/// let got: Vec<Match> = re.find_iter("☃").collect();/// // Matches only occur at the beginning and end of the snowman.///     Match::must(0, 0..0),///     Match::must(0, 3..3),/// // Matches now occur at every position!///     Match::must(0, 1..1),///     Match::must(0, 2..2),/// Ok::<(), Box<dyn std::error::Error>>(())auto_prefilter/// Toggles whether automatic prefilter support is enabled./// If this is disabled and [`Config::prefilter`] is not set, then the/// meta regex engine will not use any prefilters. This can sometimes/// be beneficial in cases where you know (or have measured) that the/// prefilter leads to overall worse search performance.///     .configure(Regex::config().auto_prefilter(false))///     .build(r"Bruce \w+")?;/// let hay = "Hello Bruce Springsteen!";/// assert_eq!(Some(Match::must(0, 6..23)), re.find(hay));/// Overrides and sets the prefilter to use inside a `Regex`./// This permits one to forcefully set a prefilter in cases where the/// caller knows better than whatever the automatic prefilter logic is/// capable of./// By default, this is set to `None` and an automatic prefilter will be/// used if one could be built. (Assuming [`Config::auto_prefilter`] is/// enabled, which it is by default.)/// This example shows how to set your own prefilter. In the case of a/// pattern like `Bruce \w+`, the automatic prefilter is likely to be/// constructed in a way that it will look for occurrences of `Bruce `./// In most cases, this is the best choice. But in some cases, it may be/// the case that running `memchr` on `B` is the best choice. One can/// achieve that behavior by overriding the automatic prefilter logic/// and providing a prefilter that just matches `B`.///     Match, MatchKind,/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["B"])///     .expect("a prefilter");///     .configure(Regex::config().prefilter(Some(pre)))/// # Example: incorrect prefilters can lead to incorrect results!/// Be warned that setting an incorrect prefilter can lead to missed/// matches. So if you use this option, ensure your prefilter can _never_/// report false negatives. (A false positive is, on the other hand, quite/// okay and generally unavoidable.)/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["Z"])/// // Oops! No match found, but there should be one!/// assert_eq!(None, re.find(hay));/// Configures what kinds of groups are compiled as "capturing" in the/// underlying regex engine./// This is set to [`WhichCaptures::All`] by default. Callers may wish to/// use [`WhichCaptures::Implicit`] in cases where one wants avoid the/// overhead of capture states for explicit groups./// Note that another approach to avoiding the overhead of capture groups/// is by using non-capturing groups in the regex pattern. That is,/// `(?:a)` instead of `(a)`. This option is useful when you can't control/// the concrete syntax but know that you don't need the underlying capture/// states. For example, using `WhichCaptures::Implicit` will behave as if/// all explicit capturing groups in the pattern were non-capturing./// Setting this to `WhichCaptures::None` is usually not the right thing to/// do. When no capture states are compiled, some regex engines (such as/// the `PikeVM`) won't be able to report match offsets. This will manifest/// as no match being found./// This example demonstrates how the results of capture groups can change/// based on this option. First we show the default (all capture groups in/// the pattern are capturing):/// use regex_automata::{meta::Regex, Match, Span};/// let re = Regex::new(r"foo([0-9]+)bar")?;/// let hay = "foo123bar";/// re.captures(hay, &mut caps);/// assert_eq!(Some(Span::from(0..9)), caps.get_group(0));/// assert_eq!(Some(Span::from(3..6)), caps.get_group(1));/// And now we show the behavior when we only include implicit capture/// groups. In this case, we can only find the overall match span, but the/// spans of any other explicit group don't exist because they are treated/// as non-capturing. (In effect, when `WhichCaptures::Implicit` is used,/// there is no real point in using [`Regex::captures`] since it will never/// be able to report more information than [`Regex::find`].)///     nfa::thompson::WhichCaptures,///     Span,///     .configure(Regex::config().which_captures(WhichCaptures::Implicit))///     .build(r"foo([0-9]+)bar")?;/// assert_eq!(None, caps.get_group(1));/// Sets the size limit, in bytes, to enforce on the construction of every/// NFA build by the meta regex engine./// Setting it to `None` disables the limit. This is not recommended if/// you're compiling untrusted patterns./// Note that this limit is applied to _each_ NFA built, and if any of/// them exceed the limit, then construction will fail. This limit does/// _not_ correspond to the total memory used by all NFAs in the meta regex/// This defaults to some reasonable number that permits most reasonable/// // But notice that building such a regex with the exact same limit/// // can succeed depending on other aspects of the configuration. For/// // example, a single *forward* NFA will (at time of writing) fit into/// // the 20KB limit, but a *reverse* NFA of the same pattern will not./// // So if one configures a meta regex such that a reverse NFA is never/// // needed and thus never built, then the 20KB limit will be enough for/// // a pattern like \pL!///     .configure(Regex::config()///         .nfa_size_limit(Some(20 * (1<<10)))///         // The DFAs are the only thing that (currently) need a reverse///         // NFA. So if both are disabled, the meta regex engine will///         // skip building the reverse NFA. Note that this isn't an API///         // guarantee. A future semver compatible version may introduce///         // new use cases for a reverse NFA.///         .hybrid(false)///         .dfa(false)/// Sets the size limit, in bytes, for the one-pass DFA./// Setting it to `None` disables the limit. Disabling the limit is/// strongly discouraged when compiling untrusted patterns. Even if the/// patterns are trusted, it still may not be a good idea, since a one-pass/// DFA can use a lot of memory. With that said, as the size of a regex/// increases, the likelihood of it being one-pass likely decreases./// one-pass patterns./// This shows how to set the one-pass DFA size limit. Note that since/// a one-pass DFA is an optional component of the meta regex engine,/// this size limit only impacts what is built internally and will never/// determine whether a `Regex` itself fails to build.///     .configure(Regex::config().onepass_size_limit(Some(2 * (1<<20))))///     .build(r"\pL{5}");/// Set the cache capacity, in bytes, for the lazy DFA./// The cache capacity of the lazy DFA determines approximately how much/// heap memory it is allowed to use to store its state transitions. The/// state transitions are computed at search time, and if the cache fills/// up it, it is cleared. At this point, any previously generated state/// transitions are lost and are re-generated if they're needed again./// This sort of cache filling and clearing works quite well _so long as/// cache clearing happens infrequently_. If it happens too often, then the/// meta regex engine will stop using the lazy DFA and switch over to a/// In cases where the cache is cleared too often, it may be possible to/// give the cache more space and reduce (or eliminate) how often it is/// cleared. Similarly, sometimes a regex is so big that the lazy DFA isn't/// used at all if its cache capacity isn't big enough./// The capacity set here is a _limit_ on how much memory is used. The/// actual memory used is only allocated as it's needed./// Determining the right value for this is a little tricky and will likely/// required some profiling. Enabling the `logging` feature and setting the/// log level to `trace` will also tell you how often the cache is being///     .configure(Regex::config().hybrid_cache_capacity(20 * (1<<20)))/// Sets the size limit, in bytes, for heap memory used for a fully/// compiled DFA./// **NOTE:** If you increase this, you'll likely also need to increase/// [`Config::dfa_state_limit`]./// In contrast to the lazy DFA, building a full DFA requires computing/// all of its state transitions up front. This can be a very expensive/// process, and runs in worst case `2^n` time and space (where `n` is/// proportional to the size of the regex). However, a full DFA unlocks/// some additional optimization opportunities./// Because full DFAs can be so expensive, the default limits for them are/// incredibly small. Generally speaking, if your regex is moderately big/// or if you're using Unicode features (`\w` is Unicode-aware by default/// for example), then you can expect that the meta regex engine won't even/// attempt to build a DFA for it./// If this and [`Config::dfa_state_limit`] are set to `None`, then the/// meta regex will not use any sort of limits when deciding whether to/// build a DFA. This in turn makes construction of a `Regex` take/// worst case exponential time and space. Even short patterns can result/// in huge space blow ups. So it is strongly recommended to keep some kind/// of limit set!/// The default is set to a small number that permits some simple regexes/// to get compiled into DFAs in reasonable time.///     // 100MB is much bigger than the default.///         .dfa_size_limit(Some(100 * (1<<20)))///         // We don't care about size too much here, so just///         // remove the NFA state limit altogether.///         .dfa_state_limit(None))/// Sets a limit on the total number of NFA states, beyond which, a full/// DFA is not attempted to be compiled./// This limit works in concert with [`Config::dfa_size_limit`]. Namely,/// where as `Config::dfa_size_limit` is applied by attempting to construct/// a DFA, this limit is used to avoid the attempt in the first place. This/// is useful to avoid hefty initialization costs associated with building/// a DFA for cases where it is obvious the DFA will ultimately be too big./// By default, this is set to a very small number.///         // Sometimes the default state limit rejects DFAs even///         // if they would fit in the size limit. Here, we disable///         // the check on the number of NFA states and just rely on///         // the size limit.///     .build(r"(?-u)\w{30}");/// Whether to attempt to shrink the size of the alphabet for the regex/// pattern or not. When enabled, the alphabet is shrunk into a set of/// equivalence classes, where every byte in the same equivalence class/// cannot discriminate between a match or non-match./// does not yield any speed advantages. Indeed, disabling it can result/// in much higher memory usage. Disabling byte classes is useful for/// debugging the actual generated transitions because it lets one see the/// transitions defined on actual bytes instead of the equivalence classes./// one is debugging the meta regex engine's internals.///     .configure(Regex::config().byte_classes(false))/// let hay = "!!quux!!";/// assert_eq!(Some(Match::must(0, 2..6)), re.find(hay));/// Set the line terminator to be used by the `^` and `$` anchors in/// multi-line mode./// This option has no effect when CRLF mode is enabled. That is,/// regardless of this setting, `(?Rm:^)` and `(?Rm:$)` will always treat/// `\r` and `\n` as line terminators (and will never match between a `\r`/// and a `\n`)./// By default, `\n` is the line terminator./// **Warning**: This does not change the behavior of `.`. To do that,/// you'll need to configure the syntax option/// [`syntax::Config::line_terminator`](crate::util::syntax::Config::line_terminator)/// in addition to this. Otherwise, `.` will continue to match any/// character other than `\n`./// Toggle whether the hybrid NFA/DFA (also known as the "lazy DFA") should/// be available for use by the meta regex engine./// Enabling this does not necessarily mean that the lazy DFA will/// definitely be used. It just means that it will be _available_ for use/// if the meta regex engine thinks it will be useful./// When the `hybrid` crate feature is enabled, then this is enabled by/// default. Otherwise, if the crate feature is disabled, then this is/// always disabled, regardless of its setting by the caller./// Toggle whether a fully compiled DFA should be available for use by the/// meta regex engine./// Enabling this does not necessarily mean that a DFA will definitely be/// used. It just means that it will be _available_ for use if the meta/// regex engine thinks it will be useful./// When the `dfa-build` crate feature is enabled, then this is enabled by/// Toggle whether a one-pass DFA should be available for use by the meta/// Enabling this does not necessarily mean that a one-pass DFA will/// definitely be used. It just means that it will be _available_ for/// use if the meta regex engine thinks it will be useful. (Indeed, a/// one-pass DFA can only be used when the regex is one-pass. See the/// [`dfa::onepass`](crate::dfa::onepass) module for more details.)/// When the `dfa-onepass` crate feature is enabled, then this is enabled/// by default. Otherwise, if the crate feature is disabled, then this is/// Toggle whether a bounded backtracking regex engine should be available/// for use by the meta regex engine./// Enabling this does not necessarily mean that a bounded backtracker will/// When the `nfa-backtrack` crate feature is enabled, then this is enabled/// Returns the match kind on this configuration, as set by/// [`Config::match_kind`]./// If it was not explicitly set, then a default value is returned.get_utf8_empty/// Returns whether empty matches must fall on valid UTF-8 boundaries, as/// set by [`Config::utf8_empty`].get_auto_prefilter/// Returns whether automatic prefilters are enabled, as set by/// [`Config::auto_prefilter`]./// Returns a manually set prefilter, if one was set by/// [`Config::prefilter`].get_which_captures/// Returns the capture configuration, as set by/// [`Config::which_captures`].get_nfa_size_limit/// Returns NFA size limit, as set by [`Config::nfa_size_limit`].get_onepass_size_limit/// Returns one-pass DFA size limit, as set by/// [`Config::onepass_size_limit`].get_hybrid_cache_capacity/// Returns hybrid NFA/DFA cache capacity, as set by/// [`Config::hybrid_cache_capacity`]./// Returns DFA size limit, as set by [`Config::dfa_size_limit`].get_dfa_state_limit/// Returns DFA size limit in terms of the number of states in the NFA, as/// set by [`Config::dfa_state_limit`]./// Returns whether byte classes are enabled, as set by/// [`Config::byte_classes`].get_line_terminator/// Returns the line terminator for this configuration, as set by/// [`Config::line_terminator`].get_hybrid/// Returns whether the hybrid NFA/DFA regex engine may be used, as set by/// [`Config::hybrid`].get_dfa/// Returns whether the DFA regex engine may be used, as set by/// [`Config::dfa`].get_onepass/// Returns whether the one-pass DFA regex engine may be used, as set by/// [`Config::onepass`].get_backtrack/// Returns whether the bounded backtracking regex engine may be used, as/// set by [`Config::backtrack`].ParserBuilderTranslatorBuilder/// A builder for configuring and constructing a `Regex`./// The builder permits configuring two different aspects of a `Regex`:/// * [`Builder::configure`] will set high-level configuration options as/// described by a [`Config`]./// * [`Builder::syntax`] will set the syntax level configuration options/// as described by a [`util::syntax::Config`](crate::util::syntax::Config)./// This only applies when building a `Regex` from pattern strings./// Once configured, the builder can then be used to construct a `Regex` from/// one of 4 different inputs:/// * [`Builder::build`] creates a regex from a single pattern string./// * [`Builder::build_many`] creates a regex from many pattern strings./// * [`Builder::build_from_hir`] creates a regex from a/// [`regex-syntax::Hir`](Hir) expression./// * [`Builder::build_many_from_hir`] creates a regex from many/// [`regex-syntax::Hir`](Hir) expressions./// The latter two methods in particular provide a way to construct a fully/// feature regular expression matcher directly from an `Hir` expression/// without having to first convert it to a string. (This is in contrast to the/// top-level `regex` crate which intentionally provides no such API in order/// to avoid making `regex-syntax` a public dependency.)/// As a convenience, this builder may be created via [`Regex::builder`], which/// may help avoid an extra import./// This example shows how to enable multi-line mode by default and change the/// line terminator to the NUL byte:/// # Example: disable UTF-8 requirement/// By default, regex patterns are required to match UTF-8. This includes/// regex patterns that can produce matches of length zero. In the case of an/// empty match, by default, matches will not appear between the code units of/// a UTF-8 encoded codepoint./// However, it can be useful to disable this requirement, particularly if/// you're searching things like `&[u8]` that are not known to be valid UTF-8./// let mut builder = Regex::builder();/// // Disables the requirement that non-empty matches match UTF-8./// builder.syntax(syntax::Config::new().utf8(false));/// // Disables the requirement that empty matches match UTF-8 boundaries./// builder.configure(Regex::config().utf8_empty(false));/// // We can match raw bytes via \xZZ syntax, but we need to disable/// // Unicode mode to do that. We could disable it everywhere, or just/// // selectively, as shown here./// let re = builder.build(r"(?-u:\xFF)foo(?-u:\xFF)")?;/// let hay = b"\xFFfoo\xFF";/// assert_eq!(Some(Match::must(0, 0..5)), re.find(hay));/// // We can also match between code units./// let re = builder.build(r"")?;/// assert_eq!(re.find_iter(hay).collect::<Vec<Match>>(), vec![/// Creates a new builder for configuring and constructing a [`Regex`]./// Builds a `Regex` from a single pattern string./// This example shows how to configure syntax options.///     .syntax(syntax::Config::new().crlf(true).multi_line(true))/// Builds a `Regex` from many pattern strings./// let err = Regex::builder()///     .build_many(&["a", "b", r"\p{Foo}", "c"])///     .build_many::<&str>(&[])?;build_from_hir/// Builds a `Regex` directly from an `Hir` expression./// This is useful if you needed to parse a pattern string into an `Hir`/// for other reasons (such as analysis or transformations). This routine/// permits building a `Regex` directly from the `Hir` expression instead/// of first converting the `Hir` back to a pattern string./// When using this method, any options set via [`Builder::syntax`] are/// ignored. Namely, the syntax options only apply when parsing a pattern/// string, which isn't relevant here./// If there was a problem building the underlying regex matcher for the/// given `Hir`, then an error is returned./// This example shows how one can hand-construct an `Hir` expression and/// build a regex from it without doing any parsing at all./// use {///     regex_automata::{meta::Regex, Match},///     regex_syntax::hir::{Hir, Look},/// // (?Rm)^foo$/// let hir = Hir::concat(vec![///     Hir::look(Look::StartCRLF),///     Hir::literal("foo".as_bytes()),///     Hir::look(Look::EndCRLF),///     .build_from_hir(&hir)?;build_many_from_hir/// Builds a `Regex` directly from many `Hir` expressions./// This is useful if you needed to parse pattern strings into `Hir`/// expressions for other reasons (such as analysis or transformations)./// This routine permits building a `Regex` directly from the `Hir`/// expressions instead of first converting the `Hir` expressions back to/// pattern strings./// given `Hir` expressions, then an error is returned./// Note that unlike [`Builder::build_many`], this can only fail as a/// result of building the underlying matcher. In that case, there is/// no single `Hir` expression that can be isolated as a reason for the/// failure. So if this routine fails, it's not possible to determine which/// `Hir` expression caused the failure./// This example shows how one can hand-construct multiple `Hir`/// expressions and build a single regex from them without doing any/// parsing at all./// let hir1 = Hir::concat(vec![/// // (?Rm)^bar$/// let hir2 = Hir::concat(vec![///     Hir::literal("bar".as_bytes()),///     .build_many_from_hir(&[&hir1, &hir2])?;/// let hay = "\r\nfoo\r\nbar";/// let got: Vec<Match> = re.find_iter(hay).collect();///     Match::must(0, 2..5),///     Match::must(1, 7..10),/// Configure the behavior of a `Regex`./// This configuration controls non-syntax options related to the behavior/// of a `Regex`. This includes things like whether empty matches can split/// a codepoint, prefilters, line terminators and a long list of options/// for configuring which regex engines the meta regex engine will be able/// to use internally./// This example shows how to disable UTF-8 empty mode. This will permit/// empty matches to occur between the UTF-8 encoding of a codepoint./// Configure the syntax options when parsing a pattern string while/// building a `Regex`./// These options _only_ apply when [`Builder::build`] or [`Builder::build_many`]/// are used. The other build methods accept `Hir` values, which have/// already been parsed./// This example shows how to enable case insensitive mode.///     .syntax(syntax::Config::new().case_insensitive(true))///     .build(r"δ")?;/// assert_eq!(Some(Match::must(0, 0..2)), re.find(r"Δ"));regression_suffix_literal_count// I found this in the course of building out the benchmark suite for// rebar.HirKind/// Attempts to extract an "inner" prefilter from the given HIR expressions. If/// one was found, then a concatenation of the HIR expressions that precede it/// The idea here is that the prefilter returned can be used to find candidate/// matches. And then the HIR returned can be used to build a reverse regex/// matcher, which will find the start of the candidate match. Finally, the/// match still has to be confirmed with a normal anchored forward scan to find/// the end position of the match./// Note that this assumes leftmost-first match semantics, so callers must/// not call this otherwise./// Attempt to extract a prefilter from an HIR expression./// We do a little massaging here to do our best that the prefilter we get out/// of this is *probably* fast. Basically, the false positive rate has a much/// higher impact for things like the reverse inner optimization because more/// work needs to potentially be done for each candidate match.top_concat/// Looks for a "top level" HirKind::Concat item in the given HIR. This will/// try to return one even if it's embedded in a capturing group, but is/// otherwise pretty conservative in what is returned./// The HIR returned is a complete copy of the concat with all capturing/// groups removed. In effect, the concat returned is "flattened" with respect/// to capturing groups. This makes the detection logic above for prefixes/// a bit simpler, and it works because 1) capturing groups never influence/// whether a match occurs or not and 2) capturing groups are not used when/// doing the reverse inner search to find the start of the match./// Returns a copy of the given HIR but with all capturing groups removed./*!
A module dedicated to plucking inner literals out of a regex pattern, and
then constructing a prefilter for them. We also include a regex pattern
"prefix" that corresponds to the bits of the regex that need to match before
the literals do. The reverse inner optimization then proceeds by looking for
matches of the inner literal(s), and then doing a reverse search of the prefix
from the start of the literal match to find the overall start position of the
match.

The essential invariant we want to uphold here is that the literals we return
reflect a set where *at least* one of them must match in order for the overall
regex to match. We also need to maintain the invariant that the regex prefix
returned corresponds to the entirety of the regex up until the literals we
return.

This somewhat limits what we can do. That is, if we a regex like
`\w+(@!|%%)\w+`, then we can pluck the `{@!, %%}` out and build a prefilter
from it. Then we just need to compile `\w+` in reverse. No fuss no muss. But if
we have a regex like \d+@!|\w+%%`, then we get kind of stymied. Technically,
we could still extract `{@!, %%}`, and it is true that at least of them must
match. But then, what is our regex prefix? Again, in theory, that could be
`\d+|\w+`, but that's not quite right, because the `\d+` only matches when `@!`
matches, and `\w+` only matches when `%%` matches.

All of that is technically possible to do, but it seemingly requires a lot of
sophistication and machinery. Probably the way to tackle that is with some kind
of formalism and approach this problem more generally.

For now, the code below basically just looks for a top-level concatenation.
And if it can find one, it looks for literals in each of the direct child
sub-expressions of that concatenation. If some good ones are found, we return
those and a concatenation of the Hir expressions seen up to that point.
*/hybrid_try_search_half_fwdhybrid_eoi_fwd/*!
This module defines two bespoke forward DFA search routines. One for the lazy
DFA and one for the fully compiled DFA. These routines differ from the normal
ones by reporting the position at which the search terminates when a match
*isn't* found.

This position at which a search terminates is useful in contexts where the meta
regex engine runs optimizations that could go quadratic if we aren't careful.
Namely, a regex search *could* scan to the end of the haystack only to report a
non-match. If the caller doesn't know that the search scanned to the end of the
haystack, it might restart the search at the next literal candidate it finds
and repeat the process.

Providing the caller with the position at which the search stopped provides a
way for the caller to determine the point at which subsequent scans should not
pass. This is principally used in the "reverse inner" optimization, which works
like this:

1. Look for a match of an inner literal. Say, 'Z' in '\w+Z\d+'.
2. At the spot where 'Z' matches, do a reverse anchored search from there for
'\w+'.
3. If the reverse search matches, it corresponds to the start position of a
(possible) match. At this point, do a forward anchored search to find the end
position. If an end position is found, then we have a match and we know its
bounds.

If the forward anchored search in (3) searches the entire rest of the haystack
but reports a non-match, then a naive implementation of the above will continue
back at step 1 looking for more candidates. There might still be a match to be
found! It's possible. But we already scanned the whole haystack. So if we keep
repeating the process, then we might wind up taking quadratic time in the size
of the haystack, which is not great.

So if the forward anchored search in (3) reports the position at which it
stops, then we can detect whether quadratic behavior might be occurring in
steps (1) and (2). For (1), it occurs if the literal candidate found occurs
*before* the end of the previous search in (3), since that means we're now
going to look for another match in a place where the forward search has already
scanned. It is *correct* to do so, but our technique has become inefficient.
For (2), quadratic behavior occurs similarly when its reverse search extends
past the point where the previous forward search in (3) terminated. Indeed, to
implement (2), we use the sibling 'limited' module for ensuring our reverse
scan doesn't go further than we want.

See the 'opt/reverse-inner' benchmarks in rebar for a real demonstration of
how quadratic behavior is mitigated.
*//// A trait that represents a single meta strategy. Its main utility is in/// providing a way to do dynamic dispatch over a few choices./// Why dynamic dispatch? I actually don't have a super compelling reason, and/// importantly, I have not benchmarked it with the main alternative: an enum./// I went with dynamic dispatch initially because the regex engine search code/// really can't be inlined into caller code in most cases because it's just/// too big. In other words, it is already expected that every regex search/// will entail at least the cost of a function call./// I do wonder whether using enums would result in better codegen overall/// though. It's a worthwhile experiment to try. Probably the most interesting/// benchmark to run in such a case would be one with a high match count. That/// is, a benchmark to test the overall latency of a search call.from_prefixes/// Given a sequence of prefixes, attempt to return a full `Strategy` using/// just the prefixes./// Basically, this occurs when the prefixes given not just prefixes,/// but an enumeration of the entire language matched by the regular/// A number of other conditions need to be true too. For example, there/// can be only one pattern, the number of explicit capture groups is 0, no/// look-around assertions and so on./// Note that this ignores `Config::get_auto_prefilter` because if this/// returns something, then it isn't a prefilter but a matcher itself./// Therefore, it shouldn't suffer from the problems typical to prefilters/// (such as a high false positive rate).from_alternation_literals/// Attempts to extract an alternation of literals, and if it's deemed/// worth doing, returns an Aho-Corasick prefilter as a strategy./// And currently, this only returns something when 'hirs.len() == 1'. This/// could in theory do something if there are multiple HIRs where all of/// them are alternation of literals, but I haven't had the time to go down/// that path yet.// This is a little weird, but we don't actually care about the type parameter// here because we're selecting which underlying prefilter to use. So we just// define it on an arbitrary type.// This implements Strategy for anything that implements PrefilterI.// Note that this must only be used for regexes of length 1. Multi-regexes// don't work here. The prefilter interface only provides the span of a match// and not the pattern ID. (I did consider making it more expressive, but I// couldn't figure out how to tie everything together elegantly.) Thus, so long// as the regex only contains one pattern, we can simply assume that a match// corresponds to PatternID::ZERO. And indeed, that's what we do here.// In practice, since this impl is used to report matches directly and thus// completely bypasses the regex engine, we only wind up using this under the// following restrictions:// * There must be only one pattern. As explained above.// * The literal sequence must be finite and only contain exact literals.// * There must not be any look-around assertions. If there are, the literals// extracted might be exact, but a match doesn't necessarily imply an overall// match. As a trivial example, 'foo\bbar' does not match 'foobar'.// * The pattern must not have any explicit capturing groups. If it does, the// caller might expect them to be resolved. e.g., 'foo(bar)'.// So when all of those things are true, we use a prefilter directly as a// strategy.// In the case where the number of patterns is more than 1, we don't use this// but do use a special Aho-Corasick strategy if all of the regexes are just// simple literals or alternations of literals. (We also use the Aho-Corasick// strategy when len(patterns)==1 if the number of literals is large. In that// case, literal extraction gives up and will return an infinite set.)nfarevPikeVMBoundedBacktrackerOnePassHybridtry_search_mayfailsearch_nofailsearch_half_nofailsearch_slots_nofailis_match_nofailis_capture_search_neededReverseAnchoredtry_search_half_anchored_rev// Note that in this impl, we don't check that 'input.end() ==// input.haystack().len()'. In particular, when that condition is false, a// match is always impossible because we know that the regex is always anchored// at the end (or else 'ReverseAnchored' won't be built). We don't check that// here because the 'Regex' wrapper actually does that for us in all cases.// Thus, in this impl, we can actually assume that the end position in 'input'// is equivalent to the length of the haystack.ReverseSuffixtry_search_half_starttry_search_half_fwdtry_search_half_rev_limitedpreinnerReverseHybridReverseDFAReverseInnertry_search_fulltry_search_half_fwd_stopatcopy_match_to_slots/// Copies the offsets in the given match to the corresponding positions in/// `slots`./// In effect, this sets the slots corresponding to the implicit group for the/// pattern in the given match. If the indices for the corresponding slots do/// not exist, then no slots are set./// This is useful when the caller provides slots (or captures), but you use a/// regex engine that doesn't operate on slots (like a lazy DFA). This function/// lets you map the match you get back to the slots provided by the caller.PikeVMEngineBoundedBacktrackerEnginemax_haystack_lenOnePassEngineHybridEnginetry_search_half_revDFAEngineReverseHybridEngineReverseDFAEngine/*!
This module contains a boat load of wrappers around each of our internal regex
engines. They encapsulate a few things:

1. The wrappers manage the conditional existence of the regex engine. Namely,
the PikeVM is the only required regex engine. The rest are optional. These
wrappers present a uniform API regardless of which engines are available. And
availability might be determined by compile time features or by dynamic
configuration via `meta::Config`. Encapsulating the conditional compilation
features is in particular a huge simplification for the higher level code that
composes these engines.
2. The wrappers manage construction of each engine, including skipping it if
the engine is unavailable or configured to not be used.
3. The wrappers manage whether an engine *can* be used for a particular
search configuration. For example, `BoundedBacktracker::get` only returns a
backtracking engine when the haystack is bigger than the maximum supported
length. The wrappers also sometimes take a position on when an engine *ought*
to be used, but only in cases where the logic is extremely local to the engine
itself. Otherwise, things like "choose between the backtracker and the one-pass
DFA" are managed by the higher level meta strategy code.

There are also corresponding wrappers for the various `Cache` types for each
regex engine that needs them. If an engine is unavailable or not used, then a
cache for it will *not* actually be allocated.
*//*!
Provides non-deterministic finite automata (NFA) and regex engines that use
them.

While NFAs and DFAs (deterministic finite automata) have equivalent *theoretical*
power, their usage in practice tends to result in different engineering trade
offs. While this isn't meant to be a comprehensive treatment of the topic, here
are a few key trade offs that are, at minimum, true for this crate:

* NFAs tend to be represented sparsely where as DFAs are represented densely.
Sparse representations use less memory, but are slower to traverse. Conversely,
dense representations use more memory, but are faster to traverse. (Sometimes
these lines are blurred. For example, an `NFA` might choose to represent a
particular state in a dense fashion, and a DFA can be built using a sparse
representation via [`sparse::DFA`](crate::dfa::sparse::DFA).
* NFAs have espilon transitions and DFAs don't. In practice, this means that
handling a single byte in a haystack with an NFA at search time may require
visiting multiple NFA states. In a DFA, each byte only requires visiting
a single state. Stated differently, NFAs require a variable number of CPU
instructions to process one byte in a haystack where as a DFA uses a constant
number of CPU instructions to process one byte.
* NFAs are generally easier to amend with secondary storage. For example, the
[`thompson::pikevm::PikeVM`] uses an NFA to match, but also uses additional
memory beyond the model of a finite state machine to track offsets for matching
capturing groups. Conversely, the most a DFA can do is report the offset (and
pattern ID) at which a match occurred. This is generally why we also compile
DFAs in reverse, so that we can run them after finding the end of a match to
also find the start of a match.
* NFAs take worst case linear time to build, but DFAs take worst case
exponential time to build. The [hybrid NFA/DFA](crate::hybrid) mitigates this
challenge for DFAs in many practical cases.

There are likely other differences, but the bottom line is that NFAs tend to be
more memory efficient and give easier opportunities for increasing expressive
power, where as DFAs are faster to search with.

# Why only a Thompson NFA?

Currently, the only kind of NFA we support in this crate is a [Thompson
NFA](https://en.wikipedia.org/wiki/Thompson%27s_construction). This refers
to a specific construction algorithm that takes the syntax of a regex
pattern and converts it to an NFA. Specifically, it makes gratuitous use of
epsilon transitions in order to keep its structure simple. In exchange, its
construction time is linear in the size of the regex. A Thompson NFA also makes
the guarantee that given any state and a character in a haystack, there is at
most one transition defined for it. (Although there may be many epsilon
transitions.)

It possible that other types of NFAs will be added in the future, such as a
[Glushkov NFA](https://en.wikipedia.org/wiki/Glushkov%27s_construction_algorithm).
But currently, this crate only provides a Thompson NFA.
*/min_visited_capacity/// Returns the minimum visited capacity for the given haystack./// This function can be used as the argument to [`Config::visited_capacity`]/// in order to guarantee that a backtracking search for the given `input`/// won't return an error when using a [`BoundedBacktracker`] built from the/// given `NFA`./// This routine exists primarily as a way to test that the bounded backtracker/// works correctly when its capacity is set to the smallest possible amount./// Still, it may be useful in cases where you know you want to use the bounded/// backtracker for a specific input, and just need to know what visited/// capacity to provide to make it work./// Be warned that this number could be quite large as it is multiplicative in/// the size the given NFA and haystack.visited_capacity/// The configuration used for building a bounded backtracker./// A bounded backtracker configuration is a simple data object that is/// typically used with [`Builder::configure`]./// Return a new default regex configuration.///     nfa::thompson::backtrack::BoundedBacktracker,///     Input, Match, MatchKind,/// let re = BoundedBacktracker::builder()///     .configure(BoundedBacktracker::config().prefilter(pre))///     Some(Match::must(0, 5..11)),///     re.try_find(&mut cache, input)?,/// // No match reported even though there clearly is one!/// assert_eq!(None, re.try_find(&mut cache, input)?);/// Set the visited capacity used to bound backtracking./// The visited capacity represents the amount of heap memory (in bytes) to/// allocate toward tracking which parts of the backtracking search have/// been done before. The heap memory needed for any particular search is/// proportional to `haystack.len() * nfa.states().len()`, which an be/// quite large. Therefore, the bounded backtracker is typically only able/// to run on shorter haystacks./// For a given regex, increasing the visited capacity means that the/// maximum haystack length that can be searched is increased. The/// [`BoundedBacktracker::max_haystack_len`] method returns that maximum./// The default capacity is a reasonable but empirically chosen size./// As with other regex engines, Unicode is what tends to make the bounded/// backtracker less useful by making the maximum haystack length quite/// small. If necessary, increasing the visited capacity using this routine/// will increase the maximum haystack length at the cost of using more/// Note though that the specific maximum values here are not an API/// guarantee. The default visited capacity is subject to change and not/// covered by semver./// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;/// // Unicode inflates the size of the underlying NFA quite a bit, and/// // thus means that the backtracker can only handle smaller haystacks,/// // assuming that the visited capacity remains unchanged./// let re = BoundedBacktracker::new(r"\w+")?;/// assert!(re.max_haystack_len() <= 7_000);/// // But we can increase the visited capacity to handle bigger haystacks!///     .configure(BoundedBacktracker::config().visited_capacity(1<<20))///     .build(r"\w+")?;/// assert!(re.max_haystack_len() >= 25_000);/// assert!(re.max_haystack_len() <= 28_000);get_visited_capacity/// Returns the configured visited capacity./// Note that the actual capacity used may be slightly bigger than the/// configured capacity./// A builder for a bounded backtracker./// NFA construction and the `BoundedBacktracker` construction. This builder/// is different from a general purpose regex builder in that it permits fine/// grain configuration of the construction process. The trade off for this is/// complexity, and the possibility of setting a configuration that might not/// make sense. For example, there are two different UTF-8 modes:///     nfa::thompson::{self, backtrack::BoundedBacktracker},/// let expected = Some(Ok(Match::must(0, 1..9)));/// let got = re.try_find_iter(&mut cache, haystack).next();/// // disabling UTF-8 mode on a BoundedBacktracker Config, since that/// // only impacts regexes that can produce matches of/// // length 0./// assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap()?.range()]);/// Create a new BoundedBacktracker builder with its default configuration./// Build a `BoundedBacktracker` from the given pattern./// Build a `BoundedBacktracker` from the given patterns./// Build a `BoundedBacktracker` directly from its NFA./// Note that when using this method, any configuration that applies to the/// construction of the NFA itself will of course be ignored, since the NFA/// given here is already built./// Apply the given `BoundedBacktracker` configuration options to this/// These settings only apply when constructing a `BoundedBacktracker`/// directly from a pattern./// This permits setting things like if additional time should be spent/// shrinking the size of the NFA./// A backtracking regex engine that bounds its execution to avoid exponential/// blow-up./// This regex engine only implements leftmost-first match semantics and/// only supports leftmost searches. It effectively does the same thing as a/// [`PikeVM`](thompson::pikevm::PikeVM), but typically does it faster because/// it doesn't have to worry about copying capturing group spans for most NFA/// states. Instead, the backtracker can maintain one set of captures (provided/// by the caller) and never needs to copy them. In exchange, the backtracker/// bounds itself to ensure it doesn't exhibit worst case exponential time./// This results in the backtracker only being able to handle short haystacks/// given reasonable memory usage./// # Searches may return an error!/// By design, this backtracking regex engine is bounded. This bound is/// implemented by not visiting any combination of NFA state ID and position/// in a haystack more than once. Thus, the total memory required to bound/// backtracking is proportional to `haystack.len() * nfa.states().len()`./// This can obviously get quite large, since large haystacks aren't terribly/// uncommon. To avoid using exorbitant memory, the capacity is bounded by/// a fixed limit set via [`Config::visited_capacity`]. Thus, if the total/// capacity required for a particular regex and a haystack exceeds this/// capacity, then the search routine will return an error./// Unlike other regex engines that may return an error at search time (like/// the DFA or the hybrid NFA/DFA), there is no way to guarantee that a bounded/// backtracker will work for every haystack. Therefore, this regex engine/// _only_ exposes fallible search routines to avoid the footgun of panicking/// when running a search on a haystack that is too big./// If one wants to use the fallible search APIs without handling the/// error, the only way to guarantee an error won't occur from the/// haystack length is to ensure the haystack length does not exceed/// [`BoundedBacktracker::max_haystack_len`]./// # Example: Unicode word boundaries/// This example shows that the bounded backtracker implements Unicode word/// boundaries correctly by default./// use regex_automata::{nfa::thompson::backtrack::BoundedBacktracker, Match};/// let re = BoundedBacktracker::new(r"\b\w+\b")?;/// let mut it = re.try_find_iter(&mut cache, "Шерлок Холмс");/// assert_eq!(Some(Ok(Match::must(0, 0..12))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 13..23))), it.next());/// # Example: multiple regex patterns/// The bounded backtracker supports searching for multiple patterns/// simultaneously, just like other regex engines. Note though that because it/// uses a backtracking strategy, this regex engine is unlikely to scale well/// as more patterns are added. But then again, as more patterns are added, the/// maximum haystack length allowed will also shorten (assuming the visited/// capacity remains invariant)./// let re = BoundedBacktracker::new_many(&["[a-z]+", "[0-9]+"])?;/// let mut it = re.try_find_iter(&mut cache, "abc 1 foo 4567 0 quux");/// assert_eq!(Some(Ok(Match::must(0, 0..3))), it.next());/// assert_eq!(Some(Ok(Match::must(1, 4..5))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 6..9))), it.next());/// assert_eq!(Some(Ok(Match::must(1, 10..14))), it.next());/// assert_eq!(Some(Ok(Match::must(1, 15..16))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 17..21))), it.next());/// return the corresponding `BoundedBacktracker`./// let re = BoundedBacktracker::new("foo[0-9]+bar")?;///     Some(Ok(Match::must(0, 3..14))),///     re.try_find_iter(&mut cache, "zzzfoo12345barzzz").next(),/// compile an NFA from it and build a BoundedBacktracker from the NFA.///     nfa::thompson::{NFA, backtrack::BoundedBacktracker},/// let re = BoundedBacktracker::new_from_nfa(nfa)?;/// let expected = Some(Match::must(0, 3..4));/// re.try_captures(&mut cache, "!@#A#@!", &mut caps)?;/// Create a new `BoundedBacktracker` that matches every input./// let re = BoundedBacktracker::always_match()?;/// let expected = Some(Ok(Match::must(0, 0..0)));/// assert_eq!(expected, re.try_find_iter(&mut cache, "").next());/// assert_eq!(expected, re.try_find_iter(&mut cache, "foo").next());/// Create a new `BoundedBacktracker` that never matches any input./// let re = BoundedBacktracker::never_match()?;/// assert_eq!(None, re.try_find_iter(&mut cache, "").next());/// assert_eq!(None, re.try_find_iter(&mut cache, "foo").next());/// Return a default configuration for a `BoundedBacktracker`./// type when customizing the construction of a `BoundedBacktracker`./// This example shows how to disable UTF-8 mode. When UTF-8 mode is/// disabled, zero-width matches that split a codepoint are allowed./// Otherwise they are never reported./// In the code below, notice that `""` is permitted to match positions/// that split the encoding of a codepoint./// let haystack = "a☃z";/// let mut it = re.try_find_iter(&mut cache, haystack);/// assert_eq!(Some(Ok(Match::must(0, 0..0))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 1..1))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 2..2))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 3..3))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 4..4))), it.next());/// assert_eq!(Some(Ok(Match::must(0, 5..5))), it.next());/// Return a builder for configuring the construction of a/// `BoundedBacktracker`./// re.try_captures(&mut cache, haystack, &mut caps)?;/// Create a new cache for this regex./// regex. If you want to reuse the cache for another regex, then you/// must call [`Cache::reset`] with that regex (or, equivalently,/// [`BoundedBacktracker::reset_cache`])./// valid for the search APIs on this `BoundedBacktracker`./// A `Captures` value created for a specific `BoundedBacktracker` cannot/// be used with any other `BoundedBacktracker`./// constructors that permit the `BoundedBacktracker` to do less work/// during a search, and thus might make it faster./// this `BoundedBacktracker` (and only this `BoundedBacktracker`)./// with a different `BoundedBacktracker`./// This shows how to re-purpose a cache for use with a different/// let re1 = BoundedBacktracker::new(r"\w")?;/// let re2 = BoundedBacktracker::new(r"\W")?;///     Some(Ok(Match::must(0, 0..2))),///     re1.try_find_iter(&mut cache, "Δ").next(),/// // it with the BoundedBacktracker we'd like to use it with.///     Some(Ok(Match::must(0, 0..3))),///     re2.try_find_iter(&mut cache, "☃").next(),/// Returns the total number of patterns compiled into this/// In the case of a `BoundedBacktracker` that contains no patterns, this/// This example shows the pattern length for a `BoundedBacktracker` that/// never matches:/// assert_eq!(re.pattern_len(), 0);/// And another example for a `BoundedBacktracker` that matches at every/// position:/// assert_eq!(re.pattern_len(), 1);/// And finally, a `BoundedBacktracker` that was constructed from multiple/// let re = BoundedBacktracker::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;/// assert_eq!(re.pattern_len(), 3);/// Return the config for this `BoundedBacktracker`./// Returns the maximum haystack length supported by this backtracker./// This routine is a function of both [`Config::visited_capacity`] and the/// internal size of the backtracker's NFA./// This example shows how the maximum haystack length can vary depending/// on the size of the regex itself. Note though that the specific maximum/// values here are not an API guarantee. The default visited capacity is/// subject to change and not covered by semver.///     Match, MatchError,/// // If you're only using ASCII, you get a big budget./// let re = BoundedBacktracker::new(r"(?-u)\w+")?;/// assert_eq!(re.max_haystack_len(), 299_592);/// // Things work up to the max./// let mut haystack = "a".repeat(299_592);/// let expected = Some(Ok(Match::must(0, 0..299_592)));/// assert_eq!(expected, re.try_find_iter(&mut cache, &haystack).next());/// // But you'll get an error if you provide a haystack that's too big./// // Notice that we use the 'try_find_iter' routine instead, which/// // yields Result<Match, MatchError> instead of Match./// haystack.push('a');/// let expected = Some(Err(MatchError::haystack_too_long(299_593)));try_is_match/// In the case of a backtracking regex engine, and unlike most other/// regex engines in this crate, short circuiting isn't practical. However,/// this routine may still be faster because it instructs backtracking to/// not keep track of any capturing groups./// This routine only errors if the search could not complete. For this/// backtracking regex engine, this only occurs when the haystack length/// exceeds [`BoundedBacktracker::max_haystack_len`]./// When a search cannot complete, callers cannot know whether a match/// assert!(re.try_is_match(&mut cache, "foo12345bar")?);/// assert!(!re.try_is_match(&mut cache, "foobar")?);///     Input,/// let re = BoundedBacktracker::new("a*")?;/// assert!(!re.try_is_match(&mut cache, Input::new("☃").span(1..2))?);///     nfa::thompson::{backtrack::BoundedBacktracker, NFA},/// assert!(re.try_is_match(&mut cache, Input::new("☃").span(1..2))?);/// Executes a leftmost forward search and returns a `Match` if one exists./// This routine only includes the overall match span. To get/// access to the individual spans of each capturing group, use/// [`BoundedBacktracker::try_captures`]./// let re = BoundedBacktracker::new("foo[0-9]+")?;/// assert_eq!(Some(expected), re.try_find(&mut cache, "foo12345")?);try_captures/// let re = BoundedBacktracker::new(///     r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$",/// re.try_captures(&mut cache, "2010-03-14", &mut caps)?;TryFindMatches/// If the regex engine returns an error at any point, then the iterator/// will yield that error./// let result: Result<Vec<Match>, MatchError> = re///     .try_find_iter(&mut cache, text)/// let matches = result?;try_captures_iterTryCapturesMatches/// This yields the same matches as [`BoundedBacktracker::try_find_iter`],/// but it includes the spans of all capturing groups that participate in/// each match./// let re = BoundedBacktracker::new("foo(?P<numbers>[0-9]+)")?;/// let mut spans = vec![];/// for result in re.try_captures_iter(&mut cache, text) {///     let caps = result?;///     spans.push(caps.get_group_by_name("numbers").unwrap());/// assert_eq!(spans, vec![/// This is like [`BoundedBacktracker::try_captures`], but it accepts a/// concrete `&Input` instead of an `Into<Input>`./// This example shows how to build a multi bounded backtracker that/// permits searching for specific patterns.///     Anchored, Input, Match, PatternID,/// let re = BoundedBacktracker::new_many(&[///     "[a-z0-9]{6}",///     "[a-z][a-z0-9]{5}",/// re.try_search(&mut cache, &Input::new(haystack), &mut caps)?;///     Match, Input,/// let re = BoundedBacktracker::new(r"\b[0-9]{3}\b")?;/// re.try_search(&mut cache, &Input::new(&haystack[3..6]), &mut caps)?;/// re.try_search(///     &mut cache, &Input::new(haystack).range(3..6), &mut caps,/// then `None` is returned and the contents of all `slots` is unspecified./// This is like [`BoundedBacktracker::try_search`], but it accepts a raw/// slots slice instead of a `Captures` value. This is useful in contexts/// where you don't want or need to allocate a `Captures`./// [`pattern_len() * 2`](crate::nfa::thompson::NFA::pattern_len)///     PatternID, Input,/// This is the actual implementation of `try_search_slots_imp` that/// doesn't account for the special case when 1) the NFA has UTF-8 mode/// enabled, 2) the NFA can match the empty string and 3) the caller has/// provided an insufficient number of slots to record match offsets./// The implementation of standard leftmost backtracking search./// Capturing group spans are written to 'caps', but only if requested./// 'caps' can be one of three things: 1) totally empty, in which case, we/// only report the pattern that matched or 2) only has slots for recording/// the overall match offsets for any pattern or 3) has all slots available/// for recording the spans of any groups participating in a match./// Look for a match starting at `at` in `input` and write the matching/// pattern ID and group spans to `caps`. The search uses `start_id` as its/// starting state in the underlying NFA./// If no match was found, then the caller should increment `at` and try/// at the next position./// Execute a "step" in the backtracing algorithm./// A "step" is somewhat of a misnomer, because this routine keeps going/// until it either runs out of things to try or fins a match. In the/// former case, it may have pushed some things on to the backtracking/// stack, in which case, those will be tried next as part of the/// 'backtrack' routine above.// LAMENTATION: The actual backtracking search is implemented in about// 75 lines below. Yet this file is over 2,000 lines long. What have I// done?/// An iterator over all non-overlapping matches for a fallible search./// The iterator yields a `Result<Match, MatchError` value until no more/// matches could be found./// * `'r` represents the lifetime of the BoundedBacktracker./// * `'c` represents the lifetime of the BoundedBacktracker's cache./// This iterator can be created with the [`BoundedBacktracker::try_find_iter`]/// An iterator over all non-overlapping leftmost matches, with their capturing/// groups, for a fallible search./// The iterator yields a `Result<Captures, MatchError>` value until no more/// This iterator can be created with the/// [`BoundedBacktracker::try_captures_iter`] method./// Stack used on the heap for doing backtracking instead of the/// traditional recursive approach. We don't want recursion because then/// we're likely to hit a stack overflow for bigger regexes./// The set of (StateID, HaystackOffset) pairs that have been visited/// by the backtracker within a single search. If such a pair has been/// visited, then we avoid doing the work for that pair again. This is/// what "bounds" the backtracking and prevents it from having worst case/// exponential time./// A cache represents mutable state that a [`BoundedBacktracker`] requires/// during a search./// For a given [`BoundedBacktracker`], its corresponding cache may be created/// either via [`BoundedBacktracker::create_cache`], or via [`Cache::new`]./// They are equivalent in every way, except the former does not require/// explicitly importing `Cache`./// A particular `Cache` is coupled with the [`BoundedBacktracker`] from which/// it was created. It may only be used with that `BoundedBacktracker`. A cache/// and its allocations may be re-purposed via [`Cache::reset`], in which case,/// it can only be used with the new `BoundedBacktracker` (and not the old/// one)./// Create a new [`BoundedBacktracker`] cache./// [`BoundedBacktracker::create_cache`], as it does not require also/// importing the `Cache` type./// If you want to reuse the returned `Cache` with some other/// `BoundedBacktracker`, then you must call [`Cache::reset`] with the/// desired `BoundedBacktracker`./// Reset this cache such that it can be used for searching with different/// [`BoundedBacktracker`]./// Clears this cache. This should be called at the start of every search/// to ensure we start with a clean slate./// This also sets the length of the capturing groups used in the current/// search. This permits an optimization where by 'SlotTable::for_state'/// only returns the number of slots equivalent to the number of slots/// given in the 'Captures' value. This may be less than the total number/// of possible slots, e.g., when one only wants to track overall match/// offsets. This in turn permits less copying of capturing group spans/// in the BoundedBacktracker./// Look for a match starting at `sid` and the given position in theRestoreCapture/// Reset the given `slot` to the given `offset` (which might be `None`)./// This effectively gives a "scope" to capturing groups, such that an/// offset for a particular group only gets returned if the match goes/// through that capturing group. If backtracking ends up going down a/// different branch that results in a different offset (or perhaps none at/// all), then this "restore capture" frame will cause the offset to get/// reset./// Represents a stack frame on the heap while doing backtracking./// Instead of using explicit recursion for backtracking, we use a stack on/// the heap to keep track of things that we want to explore if the current/// backtracking branch turns out to not lead to a match./// The actual underlying bitset. Each element in the bitset corresponds/// to a particular (StateID, offset) pair. States correspond to the rows/// and the offsets correspond to the columns./// If our underlying NFA has N states and the haystack we're searching/// has M bytes, then we have N*(M+1) entries in our bitset table. The/// M+1 occurs because our matches are delayed by one byte (to support/// look-around), and so we need to handle the end position itself rather/// than stopping just before the end. (If there is no end position, then/// it's treated as "end-of-input," which is matched by things like '$'.)/// Given BITS=N*(M+1), we wind up with div_ceil(BITS, sizeof(usize))/// We use 'usize' to represent our blocks because it makes some of the/// arithmetic in 'insert' a bit nicer. For example, if we used 'u32' for/// our block, we'd either need to cast u32s to usizes or usizes to u32s./// The stride represents one plus length of the haystack we're searching/// (as described above). The stride must be initialized for each search./// A bitset that keeps track of whether a particular (StateID, offset) has/// been considered during backtracking. If it has already been visited, then/// backtracking skips it. This is what gives backtracking its "bound."/// The size of each block, in bits./// Create a new visited set for the given backtracker./// The set is ready to use, but must be setup at the beginning of each/// search by calling `setup_search`./// Insert the given (StateID, offset) pair into this set. If it already/// exists, then this is a no-op and it returns false. Otherwise this/// returns true./// Reset this visited set to work with the given bounded backtracker./// Setup this visited set to work for a search using the given NFA/// and input configuration. The NFA must be the same NFA used by the/// BoundedBacktracker given to Visited::reset. Failing to call this might/// result in panics or silently incorrect search behavior./// Return the heap memory usage, in bytes, of this visited set./// Integer division, but rounds up instead of down.max_haystack_len_overflow// This is a regression test for the maximum haystack length computation.// Previously, it assumed that the total capacity of the backtracker's// bitset would always be greater than the number of NFA states. But there// is of course no guarantee that this is true. This regression test// ensures that not only does `max_haystack_len` not panic, but that it// should return `0`./*!
An NFA backed bounded backtracker for executing regex searches with capturing
groups.

This module provides a [`BoundedBacktracker`] that works by simulating an NFA
using the classical backtracking algorithm with a twist: it avoids redoing
work that it has done before and thereby avoids worst case exponential time.
In exchange, it can only be used on "short" haystacks. Its advantage is that
is can be faster than the [`PikeVM`](thompson::pikevm::PikeVM) in many cases
because it does less book-keeping.
*/SparseTransitions/// The next state that this state should transition to./// An empty state whose only purpose is to forward the automaton to/// another state via an unconditional epsilon transition./// Unconditional epsilon transitions are quite useful during the/// construction of an NFA, as they permit the insertion of no-op/// placeholders that make it easier to compose NFA sub-graphs. When/// the Thompson NFA builder produces a final NFA, all unconditional/// epsilon transitions are removed, and state identifiers are remapped/// accordingly.ByteRange/// A state that only transitions to another state if the current input/// byte is in a particular range of bytes./// A state with possibly many transitions, represented in a sparse/// fashion. Transitions must be ordered lexicographically by input range/// and be non-overlapping. As such, this may only be used when every/// transition has equal priority. (In practice, this is only used for/// encoding large UTF-8 automata.) In contrast, a `Union` state has each/// alternate in order of priority. Priority is used to implement greedy/// matching and also alternations themselves, e.g., `abc|a` where `abc`/// has priority over `a`./// To clarify, it is possible to remove `Sparse` and represent all things/// that `Sparse` is used for via `Union`. But this creates a more bloated/// NFA with more epsilon transitions than is necessary in the special case/// of character classes./// A conditional epsilon transition satisfied via some sort of/// look-around./// The ID of the pattern that this capture was defined.group_index/// The capture group index that this capture state corresponds to./// The capture group index is always relative to its corresponding/// pattern. Therefore, in the presence of multiple patterns, both the/// pattern ID and the capture group index are required to uniquely/// identify a capturing group.CaptureStart/// An empty state that records the start of a capture location. This is an/// unconditional epsilon transition like `Empty`, except it can be used to/// record position information for a capture group when using the NFA forCaptureEnd/// An empty state that records the end of a capture location. This is analternates/// An alternation such that there exists an epsilon transition to all/// states in `alternates`, where matches found via earlier transitions/// are preferred over later transitions.UnionReverse/// states in `alternates`, where matches found via later transitions are/// preferred over earlier transitions./// This "reverse" state exists for convenience during compilation that/// permits easy construction of non-greedy combinations of NFA states. At/// the end of compilation, Union and UnionReverse states are merged into/// one Union type of state, where the latter has its epsilon transitions/// reversed to reflect the priority inversion./// The "convenience" here arises from the fact that as new states are/// added to the list of `alternates`, we would like that add operation/// to be amortized constant time. But if we used a `Union`, we'd need to/// prepend the state, which takes O(n) time. There are other approaches we/// could use to solve this, but this seems simple enough./// A state that cannot be transitioned out of. This is useful for cases/// where you want to prevent matching from occurring. For example, if your/// regex parser permits empty character classes, then one could choose a/// `Fail` state to represent it./// A match state. There is at most one such occurrence of this state in/// an NFA for each pattern compiled into the NFA. At time of writing, a/// match state is always produced for every pattern given, but in theory,/// if a pattern can never lead to a match, then the match state could be/// `pattern_id` refers to the ID of the pattern itself, which corresponds/// to the pattern's index (starting at 0)./// An intermediate NFA state used during construction./// During construction of an NFA, it is often convenient to work with states/// that are amenable to mutation and other carry more information than we/// otherwise need once an NFA has been built. This type represents those/// needs./// Once construction is finished, the builder will convert these states to a/// [`nfa::thompson::State`](crate::nfa::thompson::State). This conversion not/// only results in a simpler representation, but in some cases, entire classes/// of states are completely removed (such as [`State::Empty`]).goto/// If this state is an unconditional epsilon transition, then this returns/// the target of the transition./// Returns the heap memory usage, in bytes, of this state./// The ID of the pattern that we're currently building./// Callers are required to set (and unset) this by calling/// {start,finish}_pattern. Otherwise, most methods will panic./// A sequence of intermediate NFA states. Once a state is added to this/// sequence, it is assigned a state ID equivalent to its index. Once a/// state is added, it is still expected to be mutated, e.g., to set its/// transition to a state that didn't exist at the time it was added./// The starting states for each individual pattern. Starting at any/// of these states will result in only an anchored search for the/// corresponding pattern. The vec is indexed by pattern ID. When the NFA/// contains a single regex, then `start_pattern[0]` and `start_anchored`/// are always equivalent./// A map from pattern ID to capture group index to name. (If no name/// exists, then a None entry is present. Thus, all capturing groups are/// present in this mapping.)/// The outer vec is indexed by pattern ID, while the inner vec is indexed/// by capture index offset for the corresponding pattern./// The first capture group for each pattern is always unnamed and is thus/// always None.memory_states/// The combined memory used by each of the 'State's in 'states'. This/// only includes heap usage by each state, and not the size of the state/// itself. In other words, this tracks heap memory used that isn't/// captured via `size_of::<State>() * states.len()`./// Whether this NFA only matches UTF-8 and whether regex engines using/// this NFA for searching should report empty matches that split a/// Whether this NFA should be matched in reverse or not.look_matcher/// The matcher to use for look-around assertions./// A size limit to respect when building an NFA. If the total heap memory/// of the intermediate NFA states exceeds (or would exceed) this amount,/// An abstraction for building Thompson NFAs by hand./// A builder is what a [`thompson::Compiler`](crate::nfa::thompson::Compiler)/// uses internally to translate a regex's high-level intermediate/// representation into an [`NFA`]./// The primary function of this builder is to abstract away the internal/// representation of an NFA and make it difficult to produce NFAs are that/// internally invalid or inconsistent. This builder also provides a way to/// add "empty" states (which can be thought of as unconditional epsilon/// transitions), despite the fact that [`thompson::State`](nfa::State) does/// not have any "empty" representation. The advantage of "empty" states is/// that they make the code for constructing a Thompson NFA logically simpler./// Many of the routines on this builder may panic or return errors. Generally/// speaking, panics occur when an invalid sequence of method calls were made,/// where as an error occurs if things get too big. (Where "too big" might mean/// exhausting identifier space or using up too much heap memory in accordance/// with the configured [`size_limit`](Builder::set_size_limit).)/// # Overview/// ## Adding multiple patterns/// Each pattern you add to an NFA should correspond to a pair of/// [`Builder::start_pattern`] and [`Builder::finish_pattern`] calls, with/// calls inbetween that add NFA states for that pattern. NFA states may be/// added without first calling `start_pattern`, with the exception of adding/// capturing states./// ## Adding NFA states/// Here is a very brief overview of each of the methods that add NFA states./// Every method adds a single state./// * [`add_empty`](Builder::add_empty): Add a state with a single/// unconditional epsilon transition to another state./// * [`add_union`](Builder::add_union): Adds a state with unconditional/// epsilon transitions to two or more states, with earlier transitions/// preferred over later ones./// * [`add_union_reverse`](Builder::add_union_reverse): Adds a state with/// unconditional epsilon transitions to two or more states, with later/// transitions preferred over earlier ones./// * [`add_range`](Builder::add_range): Adds a state with a single transition/// to another state that can only be followed if the current input byte is/// within the range given./// * [`add_sparse`](Builder::add_sparse): Adds a state with two or more/// range transitions to other states, where a transition is only followed/// if the current input byte is within one of the ranges. All transitions/// in this state have equal priority, and the corresponding ranges must be/// non-overlapping./// * [`add_look`](Builder::add_look): Adds a state with a single *conditional*/// epsilon transition to another state, where the condition depends on a/// limited look-around property./// * [`add_capture_start`](Builder::add_capture_start): Adds a state with/// a single unconditional epsilon transition that also instructs an NFA/// simulation to record the current input position to a specific location in/// memory. This is intended to represent the starting location of a capturing/// group./// * [`add_capture_end`](Builder::add_capture_end): Adds a state with/// memory. This is intended to represent the ending location of a capturing/// * [`add_fail`](Builder::add_fail): Adds a state that never transitions to/// another state./// * [`add_match`](Builder::add_match): Add a state that indicates a match has/// been found for a particular pattern. A match state is a final state with/// no outgoing transitions./// ## Setting transitions between NFA states/// The [`Builder::patch`] method creates a transition from one state to the/// next. If the `from` state corresponds to a state that supports multiple/// outgoing transitions (such as "union"), then this adds the corresponding/// transition. Otherwise, it sets the single transition. (This routine panics/// if `from` corresponds to a state added by `add_sparse`, since sparse states/// need more specialized handling.)/// This annotated example shows how to hand construct the regex `[a-z]+`/// (without an unanchored prefix).///     nfa::thompson::{pikevm::PikeVM, Builder, Transition},///     util::primitives::StateID,/// // Before adding NFA states for our pattern, we need to tell the builder/// // that we are starting the pattern./// builder.start_pattern()?;/// // Since we use the Pike VM below for searching, we need to add capturing/// // states. If you're just going to build a DFA from the NFA, then capturing/// // states do not need to be added./// let start = builder.add_capture_start(StateID::ZERO, 0, None)?;/// let range = builder.add_range(Transition {///     // We don't know the state ID of the 'next' state yet, so we just fill///     // in a dummy 'ZERO' value.///     start: b'a', end: b'z', next: StateID::ZERO,/// // This state will point back to 'range', but also enable us to move ahead./// // That is, this implements the '+' repetition operator. We add 'range' and/// // then 'end' below to this alternation./// let alt = builder.add_union(vec![])?;/// // The final state before the match state, which serves to capture the/// // end location of the match./// let end = builder.add_capture_end(StateID::ZERO, 0)?;/// // The match state for our pattern./// let mat = builder.add_match()?;/// // Now we fill in the transitions between states./// builder.patch(start, range)?;/// builder.patch(range, alt)?;/// // If we added 'end' before 'range', then we'd implement non-greedy/// // matching, i.e., '+?'./// builder.patch(alt, range)?;/// builder.patch(alt, end)?;/// builder.patch(end, mat)?;/// // We must explicitly finish pattern and provide the starting state ID for/// // this particular pattern./// builder.finish_pattern(start)?;/// // Finally, when we build the NFA, we provide the anchored and unanchored/// // starting state IDs. Since we didn't bother with an unanchored prefix/// // here, we only support anchored searching. Thus, both starting states are/// // the same./// let nfa = builder.build(start, start)?;/// // Now build a Pike VM from our NFA, and use it for searching. This shows/// // how we can use a regex engine without ever worrying about syntax!/// let re = PikeVM::new_from_nfa(nfa)?;/// re.captures(&mut cache, "foo0", &mut caps);/// Create a new builder for hand-assembling NFAs./// Clear this builder./// Clearing removes all state associated with building an NFA, but does/// not reset configuration (such as size limits and whether the NFA/// should only match UTF-8). After clearing, the builder can be reused to/// assemble an entirely new NFA./// Assemble a [`NFA`] from the states added so far./// After building an NFA, more states may be added and `build` may be/// called again. To reuse a builder to produce an entirely new NFA from/// scratch, call the [`clear`](Builder::clear) method first./// `start_anchored` refers to the ID of the starting state that anchored/// searches should use. That is, searches who matches are limited to the/// starting position of the search./// `start_unanchored` refers to the ID of the starting state that/// unanchored searches should use. This permits searches to report matches/// that start after the beginning of the search. In cases where unanchored/// searches are not supported, the unanchored starting state ID must be/// the same as the anchored starting state ID./// This returns an error if there was a problem producing the final NFA./// In particular, this might include an error if the capturing groups/// added to this builder violate any of the invariants documented on/// [`GroupInfo`](crate::util::captures::GroupInfo)./// If `start_pattern` was called, then `finish_pattern` must be called/// before `build`, otherwise this panics./// This may panic for other invalid uses of a builder. For example, if/// a "start capture" state was added without a corresponding "end capture"/// Start the assembly of a pattern in this NFA./// Upon success, this returns the identifier for the new pattern./// Identifiers start at `0` and are incremented by 1 for each new pattern./// It is necessary to call this routine before adding capturing states./// Otherwise, any other NFA state may be added before starting a pattern./// If the pattern identifier space is exhausted, then this returns an/// If this is called while assembling another pattern (i.e., before/// `finish_pattern` is called), then this panics.finish_pattern/// Finish the assembly of a pattern in this NFA./// Identifiers start at `0` and are incremented by 1 for each new/// pattern. This is the same identifier returned by the corresponding/// `start_pattern` call./// Note that `start_pattern` and `finish_pattern` pairs cannot be/// interleaved or nested. A correct `finish_pattern` call _always_/// corresponds to the most recently called `start_pattern` routine./// This currently never returns an error, but this is subject to change./// If this is called without a corresponding `start_pattern` call, thencurrent_pattern_id/// Returns the pattern identifier of the current pattern./// If this doesn't occur after a `start_pattern` call and before the/// corresponding `finish_pattern` call, then this panics./// Returns the number of patterns added to this builder so far./// This only includes patterns that have had `finish_pattern` calledadd_empty/// Add an "empty" NFA state./// An "empty" NFA state is a state with a single unconditional epsilon/// transition to another NFA state. Such empty states are removed before/// building the final [`NFA`] (which has no such "empty" states), but they/// can be quite useful in the construction process of an NFA./// This returns an error if the state identifier space is exhausted, or if/// the configured heap size limit has been exceeded.add_union/// Add a "union" NFA state./// A "union" NFA state that contains zero or more unconditional epsilon/// transitions to other NFA states. The order of these transitions/// reflects a priority order where earlier transitions are preferred over/// later transitions./// Callers may provide an empty set of alternates to this method call, and/// then later add transitions via `patch`. At final build time, a "union"/// state with no alternates is converted to a "fail" state, and a "union"/// state with exactly one alternate is treated as if it were an "empty"add_union_reverse/// Add a "reverse union" NFA state./// A "reverse union" NFA state contains zero or more unconditional epsilon/// reflects a priority order where later transitions are preferred/// over earlier transitions. This is an inverted priority order when/// compared to `add_union`. This is useful, for example, for implementing/// non-greedy repetition operators./// then later add transitions via `patch`. At final build time, a "reverse/// union" state with no alternates is converted to a "fail" state, and a/// "reverse union" state with exactly one alternate is treated as if it/// were an "empty" state.add_range/// Add a "range" NFA state./// A "range" NFA state is a state with one outgoing transition to another/// state, where that transition may only be followed if the current input/// byte falls between a range of bytes given.add_sparse/// Add a "sparse" NFA state./// A "sparse" NFA state contains zero or more outgoing transitions, where/// the transition to be followed (if any) is chosen based on whether the/// current input byte falls in the range of one such transition. The/// transitions given *must* be non-overlapping and in ascending order. (A/// "sparse" state with no transitions is equivalent to a "fail" state.)/// A "sparse" state is like adding a "union" state and pointing it at a/// bunch of "range" states, except that the different alternates have/// equal priority./// Note that a "sparse" state is the only state that cannot be patched./// This is because a "sparse" state has many transitions, each of which/// may point to a different NFA state. Moreover, adding more such/// transitions requires more than just an NFA state ID to point to. It/// also requires a byte range. The `patch` routine does not support the/// additional information required. Therefore, callers must ensure that/// all outgoing transitions for this state are included when `add_sparse`/// is called. There is no way to add more later./// This routine _may_ panic if the transitions given overlap or are not/// in ascending order.add_look/// Add a "look" NFA state./// A "look" NFA state corresponds to a state with exactly one/// *conditional* epsilon transition to another NFA state. Namely, it/// represents one of a small set of simplistic look-around operators./// Callers may provide a "dummy" state ID (typically [`StateID::ZERO`]),/// and then change it later with [`patch`](Builder::patch).add_capture_start/// Add a "start capture" NFA state./// A "start capture" NFA state corresponds to a state with exactly one/// outgoing unconditional epsilon transition to another state. Unlike/// "empty" states, a "start capture" state also carries with it an/// instruction for saving the current position of input to a particular/// location in memory. NFA simulations, like the Pike VM, may use this/// information to report the match locations of capturing groups in a/// regex pattern./// If the corresponding capturing group has a name, then callers should/// include it here./// Note that unlike `start_pattern`/`finish_pattern`, capturing start and/// end states may be interleaved. Indeed, it is typical for many "start/// capture" NFA states to appear before the first "end capture" state./// the configured heap size limit has been exceeded or if the given/// capture index overflows `usize`./// While the above are the only conditions in which this routine can/// currently return an error, it is possible to call this method with an/// inputs that results in the final `build()` step failing to produce an/// NFA. For example, if one adds two distinct capturing groups with the/// same name, then that will result in `build()` failing with an error./// See the [`GroupInfo`](crate::util::captures::GroupInfo) type for/// more information on what qualifies as valid capturing groups./// This example shows that an error occurs when one tries to add multiple/// capturing groups with the same name to the same pattern.///     nfa::thompson::Builder,/// let name = Some(std::sync::Arc::from("foo"));/// // 0th capture group should always be unnamed./// // OK/// builder.add_capture_start(StateID::ZERO, 1, name.clone())?;/// // This is not OK, but 'add_capture_start' still succeeds. We don't/// // get an error until we call 'build' below. Without this call, the/// // call to 'build' below would succeed./// builder.add_capture_start(StateID::ZERO, 2, name.clone())?;/// // Finish our pattern so we can try to build the NFA./// let result = builder.build(start, start);/// However, adding multiple capturing groups with the same name to/// distinct patterns is okay:///     util::{///         captures::Captures,///         primitives::{PatternID, StateID},/// // Hand-compile the patterns '(?P<foo>[a-z])' and '(?P<foo>[A-Z])'./// // We compile them to support an unanchored search, which requires/// // adding an implicit '(?s-u:.)*?' prefix before adding either pattern./// let unanchored_prefix = builder.add_union_reverse(vec![])?;/// let any = builder.add_range(Transition {///     start: b'\x00', end: b'\xFF', next: StateID::ZERO,/// builder.patch(unanchored_prefix, any)?;/// builder.patch(any, unanchored_prefix)?;/// // Compile an alternation that permits matching multiple patterns./// builder.patch(unanchored_prefix, alt)?;/// // Compile '(?P<foo>[a-z]+)'./// let start0 = builder.add_capture_start(StateID::ZERO, 0, None)?;/// // N.B. 0th capture group must always be unnamed./// let foo_start0 = builder.add_capture_start(///     StateID::ZERO, 1, Some(Arc::from("foo")),/// let lowercase = builder.add_range(Transition {/// let foo_end0 = builder.add_capture_end(StateID::ZERO, 1)?;/// let end0 = builder.add_capture_end(StateID::ZERO, 0)?;/// let match0 = builder.add_match()?;/// builder.patch(start0, foo_start0)?;/// builder.patch(foo_start0, lowercase)?;/// builder.patch(lowercase, foo_end0)?;/// builder.patch(foo_end0, end0)?;/// builder.patch(end0, match0)?;/// builder.finish_pattern(start0)?;/// // Compile '(?P<foo>[A-Z]+)'./// let start1 = builder.add_capture_start(StateID::ZERO, 0, None)?;/// let foo_start1 = builder.add_capture_start(/// let uppercase = builder.add_range(Transition {///     start: b'A', end: b'Z', next: StateID::ZERO,/// let foo_end1 = builder.add_capture_end(StateID::ZERO, 1)?;/// let end1 = builder.add_capture_end(StateID::ZERO, 0)?;/// let match1 = builder.add_match()?;/// builder.patch(start1, foo_start1)?;/// builder.patch(foo_start1, uppercase)?;/// builder.patch(uppercase, foo_end1)?;/// builder.patch(foo_end1, end1)?;/// builder.patch(end1, match1)?;/// builder.finish_pattern(start1)?;/// // Now add the patterns to our alternation that we started above./// builder.patch(alt, start0)?;/// builder.patch(alt, start1)?;/// // Finally build the NFA. The first argument is the anchored starting/// // state (the pattern alternation) where as the second is the/// // unanchored starting state (the unanchored prefix)./// let nfa = builder.build(alt, unanchored_prefix)?;/// // Now build a Pike VM from our NFA and access the 'foo' capture/// // group regardless of which pattern matched, since it is defined/// // for both patterns./// let vm = PikeVM::new_from_nfa(nfa)?;/// let mut cache = vm.create_cache();/// let caps: Vec<Captures> =///     vm.captures_iter(&mut cache, "0123aAaAA").collect();/// assert_eq!(5, caps.len());/// assert_eq!(Some(PatternID::must(0)), caps[0].pattern());/// assert_eq!(Some(Span::from(4..5)), caps[0].get_group_by_name("foo"));/// assert_eq!(Some(PatternID::must(1)), caps[1].pattern());/// assert_eq!(Some(Span::from(5..6)), caps[1].get_group_by_name("foo"));/// assert_eq!(Some(PatternID::must(0)), caps[2].pattern());/// assert_eq!(Some(Span::from(6..7)), caps[2].get_group_by_name("foo"));/// assert_eq!(Some(PatternID::must(1)), caps[3].pattern());/// assert_eq!(Some(Span::from(7..8)), caps[3].get_group_by_name("foo"));/// assert_eq!(Some(PatternID::must(1)), caps[4].pattern());/// assert_eq!(Some(Span::from(8..9)), caps[4].get_group_by_name("foo"));add_capture_end/// Add a "end capture" NFA state./// A "end capture" NFA state corresponds to a state with exactly one/// "empty" states, a "end capture" state also carries with it anadd_fail/// Adds a "fail" NFA state./// A "fail" state is simply a state that has no outgoing transitions. It/// acts as a way to cause a search to stop without reporting a match./// For example, one way to represent an NFA with zero patterns is with a/// single "fail" state./// Adds a "match" NFA state./// A "match" state has no outgoing transitions (just like a "fail"/// state), but it has special significance in that if a search enters/// this state, then a match has been found. The match state that is added/// automatically has the current pattern ID associated with it. This is/// used to report the matching pattern ID at search time./// This must be called after a `start_pattern` call but before the/// corresponding `finish_pattern` call. Otherwise, it panics./// The common implementation of "add a state." It handles the common/// error cases of state ID exhausting (by owning state ID allocation) and/// whether the size limit has been exceeded./// Add a transition from one state to another./// This routine is called "patch" since it is very common to add the/// states you want, typically with "dummy" state ID transitions, and then/// "patch" in the real state IDs later. This is because you don't always/// know all of the necessary state IDs to add because they might not/// exist yet./// This may error if patching leads to an increase in heap usage beyond/// the configured size limit. Heap usage only grows when patching adds a/// new transition (as in the case of a "union" state)./// This panics if `from` corresponds to a "sparse" state. When "sparse"/// states are added, there is no way to patch them after-the-fact. (If you/// have a use case where this would be helpful, please file an issue. It/// will likely require a new API.)set_utf8/// Set whether the NFA produced by this builder should only match UTF-8./// This should be set when both of the following are true:/// 1. The caller guarantees that the NFA created by this build will only/// report non-empty matches with spans that are valid UTF-8./// 2. The caller desires regex engines using this NFA to avoid reporting/// empty matches with a span that splits a valid UTF-8 encoded codepoint./// Property (1) is not checked. Instead, this requires the caller to/// promise that it is true. Property (2) corresponds to the behavior of/// regex engines using the NFA created by this builder. Namely, there/// is no way in the NFA's graph itself to say that empty matches found/// by, for example, the regex `a*` will fall on valid UTF-8 boundaries./// Instead, this option is used to communicate the UTF-8 semantic to regex/// engines that will typically implement it as a post-processing step by/// filtering out empty matches that don't fall on UTF-8 boundaries./// If you're building an NFA from an HIR (and not using a/// [`thompson::Compiler`](crate::nfa::thompson::Compiler)), then you can/// use the [`syntax::Config::utf8`](crate::util::syntax::Config::utf8)/// option to guarantee that if the HIR detects a non-empty match, then it/// is guaranteed to be valid UTF-8./// Note that property (2) does *not* specify the behavior of executing/// a search on a haystack that is not valid UTF-8. Therefore, if you're/// *not* running this NFA on strings that are guaranteed to be valid/// UTF-8, you almost certainly do not want to enable this option./// Similarly, if you are running the NFA on strings that *are* guaranteed/// to be valid UTF-8, then you almost certainly want to enable this option/// unless you can guarantee that your NFA will never produce a zero-width/// It is disabled by default.get_utf8/// Returns whether UTF-8 mode is enabled for this builder./// See [`Builder::set_utf8`] for more details about what "UTF-8 mode" is./// Sets whether the NFA produced by this builder should be matched in/// reverse or not. Generally speaking, when enabled, the NFA produced/// should be matched by moving backwards through a haystack, from a higher/// memory address to a lower memory address./// See also [`NFA::is_reverse`] for more details./// This is disabled by default, which means NFAs are by default matched/// in the forward direction.get_reverse/// Returns whether reverse mode is enabled for this builder./// See [`Builder::set_reverse`] for more details about what "reverse mode"/// is.set_look_matcher/// Sets the look-around matcher that should be used for the resulting NFA./// A look-around matcher can be used to configure how look-around/// assertions are matched. For example, a matcher might carry/// configuration that changes the line terminator used for `(?m:^)` and/// `(?m:$)` assertions.get_look_matcher/// Returns the look-around matcher used for this builder./// If a matcher was not explicitly set, then `LookMatcher::default()` isset_size_limit/// Set the size limit on this builder./// Setting the size limit will also check whether the NFA built so far/// fits within the given size limit. If it doesn't, then an error is/// By default, there is no configured size limit./// Return the currently configured size limit./// By default, this returns `None`, which corresponds to no configured/// size limit./// Returns the heap memory usage, in bytes, used by the NFA states added/// so far./// Note that this is an approximation of how big the final NFA will be./// In practice, the final NFA will likely be a bit smaller because of/// its simpler state representation. (For example, using things like/// `Box<[StateID]>` instead of `Vec<StateID>`.)check_size_limitstate_has_small_size// This asserts that a builder state doesn't have its size changed. It is// *really* easy to accidentally increase the size, and thus potentially// dramatically increase the memory usage of NFA builder.// This assert doesn't mean we absolutely cannot increase the size of a// builder state. We can. It's just here to make sure we do it knowingly// and intentionally.// A builder state is unfortunately a little bigger than an NFA state,// since we really want to support adding things to a pre-existing state.// i.e., We use Vec<thing> instead of Box<[thing]>. So we end up using an// extra 8 bytes per state. Sad, but at least it gets freed once the NFA// is built.Utf8RangeUtf8Sequencesliteral_trieLiteralTrieUtf8BoundedMapUtf8SuffixKeyUtf8SuffixMaprange_trieRangeTrieunanchored_prefix/// The configuration used for a Thompson NFA compiler./// Return a new default Thompson NFA compiler configuration./// Whether to enable UTF-8 mode during search or not./// A regex engine is said to be in UTF-8 mode when it guarantees that/// all matches returned by it have spans consisting of only valid UTF-8./// That is, it is impossible for a match span to be returned that/// contains any invalid UTF-8./// UTF-8 mode generally consists of two things:/// 1. Whether the NFA's states are constructed such that all paths to a/// match state that consume at least one byte always correspond to valid/// 2. Whether all paths to a match state that do _not_ consume any bytes/// should always correspond to valid UTF-8 boundaries./// (1) is a guarantee made by whoever constructs the NFA./// If you're parsing a regex from its concrete syntax, then/// [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) can make/// this guarantee for you. It does it by returning an error if the regex/// pattern could every report a non-empty match span that contains invalid/// UTF-8. So long as `syntax::Config::utf8` mode is enabled and your regex/// successfully parses, then you're guaranteed that the corresponding NFA/// will only ever report non-empty match spans containing valid UTF-8./// (2) is a trickier guarantee because it cannot be enforced by the NFA/// state graph itself. Consider, for example, the regex `a*`. It matches/// the empty strings in `☃` at positions `0`, `1`, `2` and `3`, where/// positions `1` and `2` occur within the UTF-8 encoding of a codepoint,/// and thus correspond to invalid UTF-8 boundaries. Therefore, this/// guarantee must be made at a higher level than the NFA state graph/// itself. This crate deals with this case in each regex engine. Namely,/// when a zero-width match that splits a codepoint is found and UTF-8/// mode enabled, then it is ignored and the engine moves on looking for/// the next match./// Thus, UTF-8 mode is both a promise that the NFA built only reports/// non-empty matches that are valid UTF-8, and an *instruction* to regex/// engines that empty matches that split codepoints should be banned./// Because UTF-8 mode is fundamentally about avoiding invalid UTF-8 spans,/// it only makes sense to enable this option when you *know* your haystack/// is valid UTF-8. (For example, a `&str`.) Enabling UTF-8 mode and/// searching a haystack that contains invalid UTF-8 leads to **unspecified/// behavior**./// Therefore, it may make sense to enable `syntax::Config::utf8` while/// simultaneously *disabling* this option. That would ensure all non-empty/// match spans are valid UTF-8, but that empty match spans may still split/// a codepoint or match at other places that aren't valid UTF-8./// In general, this mode is only relevant if your regex can match the/// empty string. Most regexes don't.///     nfa::thompson::{self, pikevm::PikeVM},/// let re = PikeVM::new("")?;/// re.search(&mut cache, &input, &mut caps);/// assert_eq!(Some(Match::must(0, 0..0)), caps.get_match());/// assert_eq!(Some(Match::must(0, 3..3)), caps.get_match());/// let re = PikeVM::builder()/// assert_eq!(Some(Match::must(0, 1..1)), caps.get_match());/// assert_eq!(Some(Match::must(0, 2..2)), caps.get_match());/// Reverse the NFA./// A NFA reversal is performed by reversing all of the concatenated/// sub-expressions in the original pattern, recursively. (Look around/// operators are also inverted.) The resulting NFA can be used to match/// the pattern starting from the end of a string instead of the beginning/// of a string./// Reversing the NFA is useful for building a reverse DFA, which is most/// useful for finding the start of a match after its ending position has/// been found. NFA execution engines typically do not work on reverse/// NFAs. For example, currently, the Pike VM reports the starting location/// of matches without a reverse NFA./// Currently, enabling this setting requires disabling the/// [`captures`](Config::captures) setting. If both are enabled, then the/// compiler will return an error. It is expected that this limitation will/// be lifted in the future./// This example shows how to build a DFA from a reverse NFA, and then use/// the DFA to search backwards.///     dfa::{self, Automaton},///     nfa::thompson::{NFA, WhichCaptures},/// let dfa = dfa::dense::Builder::new()///     .thompson(NFA::config()///         .which_captures(WhichCaptures::None)///         .reverse(true)///     .build("baz[0-9]+")?;///     expected,///     dfa.try_search_rev(&Input::new("foobaz12345bar"))?,/// Sets an approximate size limit on the total heap used by the NFA being/// compiled./// This permits imposing constraints on the size of a compiled NFA. This/// may be useful in contexts where the regex pattern is untrusted and one/// wants to avoid using too much memory./// This size limit does not apply to auxiliary heap used during/// compilation that is not part of the built NFA./// Note that this size limit is applied during compilation in order for/// the limit to prevent too much heap from being used. However, the/// implementation may use an intermediate NFA representation that is/// otherwise slightly bigger than the final public form. Since the size/// limit may be applied to an intermediate representation, there is not/// necessarily a precise correspondence between the configured size limit/// and the heap usage of the final NFA./// There is no size limit by default./// This example demonstrates how Unicode mode can greatly increase the/// size of the NFA./// use regex_automata::nfa::thompson::NFA;/// // 400KB isn't enough!/// NFA::compiler()///     .configure(NFA::config().nfa_size_limit(Some(400_000)))/// // ... but 500KB probably is.///     .configure(NFA::config().nfa_size_limit(Some(500_000)))/// assert_eq!(nfa.pattern_len(), 1);/// Apply best effort heuristics to shrink the NFA at the expense of more/// time/memory./// Generally speaking, if one is using an NFA to compile a DFA, then the/// extra time used to shrink the NFA will be more than made up for during/// DFA construction (potentially by a lot). In other words, enabling this/// can substantially decrease the overall amount of time it takes to build/// A reason to keep this disabled is if you want to compile an NFA and/// start using it as quickly as possible without needing to build a DFA,/// and you don't mind using a bit of extra memory for the NFA. e.g., for/// an NFA simulation or for a lazy DFA./// NFA shrinking is currently most useful when compiling a reverse/// NFA with large Unicode character classes. In particular, it trades/// additional CPU time during NFA compilation in favor of generating fewer/// NFA states./// This is disabled by default because it can increase compile times/// quite a bit if you aren't building a full DFA./// This example shows that NFA shrinking can lead to substantial space/// savings in some cases. Notice that, as noted above, we build a reverse/// DFA and use a pattern with a large Unicode character class./// use regex_automata::nfa::thompson::{NFA, WhichCaptures};/// // Currently we have to disable captures when enabling reverse NFA./// let config = NFA::config()///     .which_captures(WhichCaptures::None)///     .reverse(true);/// let not_shrunk = NFA::compiler()///     .configure(config.clone().shrink(false))///     .build(r"\w")?;/// let shrunk = NFA::compiler()///     .configure(config.clone().shrink(true))/// // While a specific shrink factor is not guaranteed, the savings can be/// // considerable in some cases./// assert!(shrunk.states().len() * 2 < not_shrunk.states().len());/// Whether to include 'Capture' states in the NFA./// [`reverse`](Config::reverse) setting. If both are enabled, then the/// This example demonstrates that some regex engines, like the Pike VM,/// require capturing states to be present in the NFA to report match/// offsets./// (Note that since this method is deprecated, the example below uses/// [`Config::which_captures`] to disable capture states.)/// use regex_automata::nfa::thompson::{///     pikevm::PikeVM,///     NFA,///     WhichCaptures,///     .thompson(NFA::config().which_captures(WhichCaptures::None))/// assert!(re.is_match(&mut cache, "abc"));/// assert_eq!(None, re.find(&mut cache, "abc"));/// Configures what kinds of capture groups are compiled into/// [`State::Capture`](crate::nfa::thompson::State::Capture) states in a/// Thompson NFA./// Currently, using any option except for [`WhichCaptures::None`] requires/// disabling the [`reverse`](Config::reverse) setting. If both are/// enabled, then the compiler will return an error. It is expected that/// this limitation will be lifted in the future./// overhead of capture states for explicit groups. Usually this occurs/// when one wants to use the `PikeVM` only for determining the overall/// match. Otherwise, the `PikeVM` could use much more memory than is/// The same applies to the bounded backtracker:///     backtrack::BoundedBacktracker,/// assert!(re.try_is_match(&mut cache, "abc")?);/// assert_eq!(None, re.try_find(&mut cache, "abc")?);/// Sets the look-around matcher that should be used with this NFA./// A look-around matcher determines how to match look-around assertions./// In particular, some assertions are configurable. For example, the/// `(?m:^)` and `(?m:$)` assertions can have their line terminator changed/// from the default of `\n` to any other byte./// This shows how to change the line terminator for multi-line assertions.///     util::look::LookMatcher,/// let mut lookm = LookMatcher::new();/// lookm.set_line_terminator(b'\x00');///     .thompson(thompson::Config::new().look_matcher(lookm))///     .build(r"(?m)^[a-z]+$")?;/// // Multi-line assertions now use NUL as a terminator.///     Some(Match::must(0, 1..4)),///     re.find(&mut cache, b"\x00abc\x00"),/// // ... and \n is no longer recognized as a terminator.///     re.find(&mut cache, b"\nabc\n"),/// Whether to compile an unanchored prefix into this NFA./// This is enabled by default. It is made available for tests only to make/// it easier to unit test the output of the compiler./// Returns whether this configuration has enabled UTF-8 mode./// Returns whether this configuration has enabled reverse NFA compilation./// Return the configured NFA size limit, if it exists, in the number of/// bytes of heap used.get_shrink/// Return whether NFA shrinking is enabled.get_captures/// Return whether NFA compilation is configured to produce capture states./// Return what kinds of capture states will be compiled into an NFA./// Return the look-around matcher for this NFA.get_unanchored_prefix/// Return whether NFA compilation is configured to include an unanchored/// prefix./// This is always false when not in test mode./// All capture states, including those corresponding to both implicit and/// explicit capture groups, are included in the Thompson NFA./// Only capture states corresponding to implicit capture groups are/// included. Implicit capture groups appear in every pattern implicitly/// and correspond to the overall match of a pattern./// This is useful when one only cares about the overall match of a/// pattern. By excluding capture states from explicit capture groups,/// one might be able to reduce the memory usage of a multi-pattern regex/// substantially if it was otherwise written to have many explicit capture/// No capture states are compiled into the Thompson NFA./// This is useful when capture states are either not needed (for example,/// if one is only trying to build a DFA) or if they aren't supported (for/// example, a reverse NFA)./// A configuration indicating which kinds of/// [`State::Capture`](crate::nfa::thompson::State::Capture) states to include./// This configuration can be used with [`Config::which_captures`] to control/// which capture states are compiled into a Thompson NFA./// The default configuration is [`WhichCaptures::All`]./// Returns true if this configuration indicates that no capture states/// should be produced in an NFA./// Returns true if this configuration indicates that some capture states/// should be added to an NFA. Note that this might only include capture/// states for implicit capture groups./// A regex parser, used when compiling an NFA directly from a pattern/// The compiler configuration./// The builder for actually constructing an NFA. This provides a/// convenient abstraction for writing a compiler.utf8_stateUtf8State/// State used for compiling character classes to UTF-8 byte automata./// State is not retained between character class compilations. This just/// serves to amortize allocation to the extent possible.trie_state/// State used for arranging character classes in reverse into a trie.utf8_suffix/// State used for caching common suffixes when compiling reverse UTF-8/// automata (for Unicode character classes)./// A builder for compiling an NFA from a regex's high-level intermediate/// representation (HIR)./// This compiler provides a way to translate a parsed regex pattern into an/// NFA state graph. The NFA state graph can either be used directly to execute/// a search (e.g., with a Pike VM), or it can be further used to build a DFA./// This compiler provides APIs both for compiling regex patterns directly from/// their concrete syntax, or via a [`regex_syntax::hir::Hir`]./// This compiler has various options that may be configured via/// [`thompson::Config`](Config)./// Note that a compiler is not the same as a [`thompson::Builder`](Builder)./// A `Builder` provides a lower level API that is uncoupled from a regex/// pattern's concrete syntax or even its HIR. Instead, it permits stitching/// together an NFA by hand. See its docs for examples./// # Example: compilation from concrete syntax/// This shows how to compile an NFA from a pattern string while setting a size/// limit on how big the NFA is allowed to be (in terms of bytes of heap used).///     nfa::thompson::{NFA, pikevm::PikeVM},/// let nfa = NFA::compiler().configure(config).build(r"(?-u)\w")?;/// re.captures(&mut cache, "!@#A#@!", &mut caps);/// # Example: compilation from HIR/// This shows how to hand assemble a regular expression via its HIR, and then/// compile an NFA directly from it./// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};/// Create a new NFA builder with its default configuration./// Compile the given regular expression pattern into an NFA./// If there was a problem parsing the regex, then that error is returned./// Otherwise, if there was a problem building the NFA, then an error is/// returned. The only error that can occur is if the compiled regex would/// exceed the size limits configured on this builder, or if any part of/// the NFA would exceed the integer representations used. (For example,/// too many states might plausibly occur on a 16-bit target.)/// Compile the given regular expression patterns into a single NFA./// let nfa = NFA::compiler().configure(config).build_many(&[///     r"(?-u)\s",///     r"(?-u)\w",/// let expected = Some(Match::must(1, 1..2));/// re.captures(&mut cache, "!A! !A!", &mut caps);/// Compile the given high level intermediate representation of a regular/// expression into an NFA./// If there was a problem building the NFA, then an error is returned. The/// only error that can occur is if the compiled regex would exceed the/// size limits configured on this builder, or if any part of the NFA would/// exceed the integer representations used. (For example, too many states/// might plausibly occur on a 16-bit target.)/// Compile the given high level intermediate representations of regular/// expressions into a single NFA./// let hirs = &[///     Hir::class(Class::Bytes(ClassBytes::new(vec![///         ClassBytesRange::new(b'\t', b'\r'),///         ClassBytesRange::new(b' ', b' '),///     ]))),///         ClassBytesRange::new(b'0', b'9'),///         ClassBytesRange::new(b'A', b'Z'),///         ClassBytesRange::new(b'_', b'_'),///         ClassBytesRange::new(b'a', b'z'),/// let nfa = NFA::compiler().configure(config).build_many_from_hir(hirs)?;/// Apply the given NFA configuration options to this builder./// This syntax configuration only applies when an NFA is built directly/// from a pattern string. If an NFA is built from an HIR, then all syntax/// settings are ignored./// use regex_automata::{nfa::thompson::NFA, util::syntax};/// let syntax_config = syntax::Config::new().unicode(false);/// let nfa = NFA::compiler().syntax(syntax_config).build(r"\w")?;/// // If Unicode were enabled, the number of states would be much bigger./// assert!(nfa.states().len() < 15);/// Compile the sequence of HIR expressions given. Pattern IDs are/// allocated starting from 0, in correspondence with the slice given./// It is legal to provide an empty slice. In that case, the NFA returned/// has no patterns and will never match anything.ThompsonRef/// Compile an arbitrary HIR expression.c_concat/// Compile a concatenation of the sub-expressions yielded by the given/// iterator. If the iterator yields no elements, then this compiles down/// to an "empty" state that always matches./// If the compiler is in reverse mode, then the expressions given are/// automatically compiled in reverse.c_alt_slice/// Compile an alternation of the given HIR values./// This is like 'c_alt_iter', but it accepts a slice of HIR values instead/// of an iterator of compiled NFA subgraphs. The point of accepting a/// slice here is that it opens up some optimization opportunities. For/// example, if all of the HIR values are literals, then this routine might/// re-shuffle them to make NFA epsilon closures substantially faster.c_alt_iter/// Compile an alternation, where each element yielded by the given/// iterator represents an item in the alternation. If the iterator yields/// no elements, then this compiles down to a "fail" state./// In an alternation, expressions appearing earlier are "preferred" at/// match time over expressions appearing later. At least, this is true/// when using "leftmost first" match semantics. (If "leftmost longest" are/// ever added in the future, then this preference order of priority would/// not apply in that mode.)c_cap/// Compile the given capture sub-expression. `expr` should be the/// sub-expression contained inside the capture. If "capture" states are/// enabled, then they are added as appropriate./// This accepts the pieces of a capture instead of a `hir::Capture` so/// that it's easy to manufacture a "fake" group when necessary, e.g., for/// adding the entire pattern as if it were a group in order to create/// appropriate "capture" states in the NFA.c_repetitionRepetition/// Compile the given repetition expression. This handles all types of/// repetitions and greediness.c_bounded/// Compile the given expression such that it matches at least `min` times,/// but no more than `max` times./// When `greedy` is true, then the preference is for the expression to/// match as much as possible. Otherwise, it will match as little asc_at_least/// Compile the given expression such that it may be matched `n` or more/// times, where `n` can be any integer. (Although a particularly large/// integer is likely to run afoul of any configured size limits.)c_zero_or_one/// Compile the given expression such that it may be matched zero or one/// times.c_exactly/// Compile the given HIR expression exactly `n` times.c_byte_classClassBytes/// Compile the given byte oriented character class./// This uses "sparse" states to represent an alternation between ranges in/// this character class. We can use "sparse" states instead of stitching/// together a "union" state because all ranges in a character class have/// equal priority *and* are non-overlapping (thus, only one can match, so/// there's never a question of priority in the first place). This saves a/// fair bit of overhead when traversing an NFA./// This routine compiles an empty character class into a "fail" state.c_unicode_classClassUnicode/// Compile the given Unicode character class./// This routine specifically tries to use various types of compression,/// since UTF-8 automata of large classes can get quite large. The specific/// type of compression used depends on forward vs reverse compilation, and/// whether NFA shrinking is enabled or not./// Aside from repetitions causing lots of repeat group, this is like the/// single most expensive part of regex compilation. Therefore, a large part/// of the expense of compilation may be reduce by disabling Unicode in thec_unicode_class_reverse_with_suffix/// Compile the given Unicode character class in reverse with suffix/// caching./// This is a "quick" way to compile large Unicode classes into reverse/// UTF-8 automata while doing a small amount of compression on that/// automata by reusing common suffixes./// A more comprehensive compression scheme can be accomplished by using/// a range trie to efficiently sort a reverse sequence of UTF-8 byte/// rqanges, and then use Daciuk's algorithm via `Utf8Compiler`./// This is the technique used when "NFA shrinking" is disabled./// (This also tries to use "sparse" states where possible, just like/// `c_byte_class` does.)c_look/// Compile the given HIR look-around assertion to an NFA look-around/// assertion.c_literal/// Compile the given byte string to a concatenation of bytes.c_range/// Compile a "range" state with one transition that may only be followed/// if the input byte is in the (inclusive) range given./// Both the `start` and `end` locations point to the state created./// Callers will likely want to keep the `start`, but patch the `end` to/// point to some other state.c_empty/// Compile an "empty" state with one unconditional epsilon transition.c_fail/// Compile a "fail" state that can never have any outgoing transitions.// The below helpers are meant to be simple wrappers around the// corresponding Builder methods. For the most part, they let us write// 'self.add_foo()' instead of 'self.builder.borrow_mut().add_foo()', where// the latter is a mouthful. Some of the methods do inject a little bit// of extra logic. e.g., Flipping look-around operators when compiling in// reverse mode./// A value that represents the result of compiling a sub-expression of a/// regex's HIR. Specifically, this represents a sub-graph of the NFA that/// has an initial state at `start` and a final state at `end`.Utf8Compiler/// A UTF-8 compiler based on Daciuk's algorithm for compilining minimal DFAs/// from a lexicographically sorted sequence of strings in linear time./// The trick here is that any Unicode codepoint range can be converted to/// a sequence of byte ranges that form a UTF-8 automaton. Connecting them/// together via an alternation is trivial, and indeed, it works. However,/// there is a lot of redundant structure in many UTF-8 automatons. Since our/// UTF-8 ranges are in lexicographic order, we can use Daciuk's algorithm/// to build nearly minimal DFAs in linear time. (They are guaranteed to be/// minimal because we use a bounded cache of previously build DFA states.)/// The drawback is that this sadly doesn't work for reverse automata, since/// the ranges are no longer in lexicographic order. For that, we invented the/// range trie (which gets its own module). Once a range trie is built, we then/// use this same Utf8Compiler to build a reverse UTF-8 automaton./// The high level idea is described here:/// https://blog.burntsushi.net/transducers/#finite-state-machines-as-data-structures/// There is also another implementation of this in the `fst` crate.compileduncompiledUtf8NodeUtf8LastTransitioncompile_fromadd_suffixpop_freezepop_roottop_last_freezeset_last_transitions_bytes_sparses_looks_bin_unions_unions_caps_fails_matchcompile_unanchored_prefix// Test that building an unanchored NFA has an appropriate `(?s:.)*?`// prefix.compile_no_unanchored_prefix_with_start_anchorcompile_yes_unanchored_prefix_with_end_anchorcompile_yes_reverse_unanchored_prefix_with_start_anchorcompile_no_reverse_unanchored_prefix_with_end_anchorcompile_emptycompile_literalcompile_class_asciicompile_class_unicodecompile_repetitioncompile_groupcompile_alternationcompile_non_binary_union// This tests the use of a non-binary union, i.e., a state with more than// 2 unconditional epsilon transitions. The only place they tend to appear// is in reverse NFAs when shrinking is disabled. Otherwise, 'binary-union'// and 'sparse' tend to cover all other cases of alternation.compile_many_start_patternempty_class_bytes// This tests that our compiler can handle an empty character class. At the// time of writing, the regex parser forbids it, so the only way to test it// is to provide a hand written HIR.empty_class_unicode// Like empty_class_bytes, but for a Unicode class.compile_captures_allcompile_captures_implicitcompile_captures_none/*
This compiler below uses Thompson's construction algorithm. The compiler takes
a regex-syntax::Hir as input and emits an NFA graph as output. The NFA graph
is structured in a way that permits it to be executed by a virtual machine and
also used to efficiently build a DFA.

The compiler deals with a slightly expanded set of NFA states than what is
in a final NFA (as exhibited by builder::State and nfa::State). Notably a
compiler state includes an empty node that has exactly one unconditional
epsilon transition to the next state. In other words, it's a "goto" instruction
if one views Thompson's NFA as a set of bytecode instructions. These goto
instructions are removed in a subsequent phase before returning the NFA to the
caller. The purpose of these empty nodes is that they make the construction
algorithm substantially simpler to implement. We remove them before returning
to the caller because they can represent substantial overhead when traversing
the NFA graph (either while searching using the NFA directly or while building
a DFA).

In the future, it would be nice to provide a Glushkov compiler as well, as it
would work well as a bit-parallel NFA for smaller regexes. But the Thompson
construction is one I'm more familiar with and seems more straight-forward to
deal with when it comes to large Unicode character classes.

Internally, the compiler uses interior mutability to improve composition in the
face of the borrow checker. In particular, we'd really like to be able to write
things like this:

    self.c_concat(exprs.iter().map(|e| self.c(e)))

Which elegantly uses iterators to build up a sequence of compiled regex
sub-expressions and then hands it off to the concatenating compiler routine.
Without interior mutability, the borrow checker won't let us borrow `self`
mutably both inside and outside the closure at the same time.
*//// An error that can occurred during the construction of a thompson NFA./// * Access an underlying [`regex_syntax::Error`] type from its `source`/// convenience routines for building an NFA directly from a pattern string./// Otherwise, errors typically occur when a limit has been breeched. For/// example, if the total heap usage of the compiled NFA exceeds the limit/// set by [`Config::nfa_size_limit`](crate::nfa::thompson::Config), then/// building the NFA will fail./// An error that occurred while parsing a regular expression. Note that/// this error may be printed over multiple lines, and is generally/// intended to be end user readable on its own.GroupInfoError/// An error that occurs if the capturing groups provided to an NFA builder/// do not satisfy the documented invariants. For example, things like/// too many groups, missing groups, having the first (zeroth) group be/// named or duplicate group names within the same pattern./// An error that occurs when an NFA contains a Unicode word boundary, but/// where the crate was compiled without the necessary data for dealing/// with Unicode word boundaries./// The number of patterns given, which exceeds the limit./// The limit on the number of patterns./// An error that occurs if too many patterns were given to the NFA/// The minimum number of states that are desired, which exceeds the/// limit./// The limit on the number of states./// An error that occurs if too states are produced while building an NFA./// The configured limit, in bytes./// An error that occurs when NFA compilation exceeds a configured heap/// The invalid index that was given.InvalidCaptureIndex/// An error that occurs when an invalid capture group index is added to/// the NFA. An "invalid" index can be one that would otherwise overflow/// a `usize` on the current target.UnsupportedCaptures/// An error that occurs when one tries to build a reverse NFA with/// captures enabled. Currently, this isn't supported, but we probably/// should support it at some point./// The kind of error that occurred during the construction of a thompson NFA./// If this error occurred because the NFA exceeded the configured sizeinvalid_capture_indexunsupported_captures/// The set of trie states. Each state contains one or more chunks, where/// each chunk is a sparse set of transitions to other states. A leaf state/// is always a match state that contains only empty chunks (i.e., no/// transitions)./// Whether to add literals in reverse to the trie. Useful when building/// a reverse NFA automaton./// A trie that preserves leftmost-first match semantics./// This is a purpose-built data structure for optimizing 'lit1|lit2|..|litN'/// patterns. It can *only* handle alternations of literals, which makes it/// somewhat restricted in its scope, but literal alternations are fairly/// common./// At a 5,000 foot level, the main idea of this trie is make an alternation of/// literals look more like a DFA than an NFA via epsilon removal./// More precisely, the main issue is in how alternations are compiled into/// a Thompson NFA. Namely, each alternation gets a single NFA "union" state/// with an epsilon transition for every branch of the alternation pointing to/// an NFA state corresponding to the start of that branch. The main problem/// with this representation is the cost of computing an epsilon closure. Once/// you hit the alternation's start state, it acts as a sort of "clog" that/// requires you to traverse all of the epsilon transitions to compute the full/// While fixing such clogs in the general case is pretty tricky without going/// to a DFA (or perhaps a Glushkov NFA, but that comes with other problems)./// But at least in the case of an alternation of literals, we can convert/// that to a prefix trie without too much cost. In theory, that's all you/// really need to do: build the trie and then compile it to a Thompson NFA./// For example, if you have the pattern 'bar|baz|foo', then using a trie, it/// is transformed to something like 'b(a(r|z))|f'. This reduces the clog by/// reducing the number of epsilon transitions out of the alternation's start/// state from 3 to 2 (it actually gets down to 1 when you use a sparse state,/// which we do below). It's a small effect here, but when your alternation is/// huge, the savings is also huge./// And that is... essentially what a LiteralTrie does. But there is one/// hiccup. Consider a regex like 'sam|samwise'. How does a prefix trie compile/// that when leftmost-first semantics are used? If 'sam|samwise' was the/// entire regex, then you could just drop the 'samwise' branch entirely since/// it is impossible to match ('sam' will always take priority, and since it/// is a prefix of 'samwise', 'samwise' will never match). But what about the/// regex '\b(sam|samwise)\b'? In that case, you can't remove 'samwise' because/// it might match when 'sam' doesn't fall on a word boundary./// The main idea is that 'sam|samwise' can be translated to 'sam(?:|wise)',/// which is a precisely equivalent regex that also gets rid of the clog./// Another example is 'zapper|z|zap'. That gets translated to/// 'z(?:apper||ap)'./// We accomplish this by giving each state in the trie multiple "chunks" of/// transitions. Each chunk barrier represents a match. The idea is that once/// you know a match occurs, none of the transitions after the match can be/// re-ordered and mixed in with the transitions before the match. Otherwise,/// the match semantics could be changed./// See the 'State' data type for a bit more detail./// Future work:/// * In theory, it would be nice to generalize the idea of removing clogs and/// apply it to the NFA graph itself. Then this could in theory work for/// case insensitive alternations of literals, or even just alternations where/// each branch starts with a non-epsilon transition./// * Could we instead use the Aho-Corasick algorithm here? The aho-corasick/// crate deals with leftmost-first matches correctly, but I think this implies/// encoding failure transitions into a Thompson NFA somehow. Which seems fine,/// because failure transitions are just unconditional epsilon transitions?/// * Or perhaps even better, could we use an aho_corasick::AhoCorasick/// directly? At time of writing, 0.7 is the current version of the/// aho-corasick crate, and that definitely cannot be used as-is. But if we/// expose the underlying finite state machine API, then could we use it? That/// would be super. If we could figure that out, it might also lend itself to/// more general composition of finite state machines./// Create a new literal trie that adds literals in the forward direction./// Create a new literal trie that adds literals in reverse./// Add the given literal to this trie./// If the literal could not be added because the `StateID` space was/// exhausted, then an error is returned. If an error returns, the trie/// is in an unspecified state.get_or_add_state/// If the given transition is defined, then return the next state ID./// Otherwise, add the transition to `from` and point it to a new state./// If a new state ID could not be allocated, then an error is returned./// Compile this literal trie to the NFA builder given./// This forwards any errors that may occur while using the given builder.compile_to_hir/// Converts this trie to an equivalent HIR expression./// We don't actually use this, but it's useful for tests. In particular,/// it provides a (somewhat) human readable representation of the triecompile_state_to_hir/// The recursive implementation of 'to_hir'./// Notice how simple this is compared to 'compile' above. 'compile' could/// be similarly simple, but we opt to not use recursion in order to avoid/// overflowing the stack in the case of a longer literal.StateChunksIter/// The remaining chunks to visit for a trie state./// The transitions of the current chunk that we're iterating over. Since/// every trie state has at least one chunk, every frame is initialized/// with the first chunk's transitions ready to be consumed./// The NFA state IDs pointing to the start of each chunk compiled by/// this trie state. This ultimately gets converted to an NFA union once/// the entire trie state (and all of its children) have been compiled./// The order of these matters for leftmost-first match semantics, since/// earlier matches in the union are preferred over later ones./// The actual NFA transitions for a single chunk in a trie state. This/// gets converted to an NFA sparse state, and its corresponding NFA state/// ID should get added to 'union'./// An explicit stack frame used for traversing the trie without using/// recursion./// Each frame is tied to the traversal of a single trie state. The frame is/// dropped once the entire state (and all of its children) have been visited./// The "output" of compiling a state is the 'union' vector, which is turn/// converted to a NFA union state. Each branch of the union corresponds to a/// chunk in the trie state./// 'sparse' corresponds to the set of transitions for a particular chunk in a/// trie state. It is ultimately converted to an NFA sparse state. The 'sparse'/// field, after being converted to a sparse NFA state, is reused for any/// subsequent chunks in the trie state, if any exist./// Create a new stack frame for trie traversal. This initializes the/// 'transitions' iterator to the transitions for the first chunk, with the/// 'chunks' iterator being every chunk after the first one./// A state in a trie./// This uses a sparse representation. Since we don't use literal tries/// for searching, and ultimately (and compilation requires visiting every/// transition anyway), we use a sparse representation for transitions. This/// means we save on memory, at the expense of 'LiteralTrie::add' being perhaps/// a bit slower./// While 'transitions' is pretty standard as far as tries goes, the 'chunks'/// piece here is more unusual. In effect, 'chunks' defines a partitioning/// of 'transitions', where each chunk corresponds to a distinct set of/// transitions. The key invariant is that a transition in one chunk cannot/// be moved to another chunk. This is the secret sauce that preserve/// A new chunk is added whenever we mark a state as a match state. Once a/// new chunk is added, the old active chunk is frozen and is never mutated/// again. The new chunk becomes the active chunk, which is defined as/// '&transitions[chunks.last().map_or(0, |c| c.1)..]'. Thus, a state where/// 'chunks' is empty actually contains one chunk. Thus, every state contains/// at least one (possibly empty) chunk./// A "leaf" state is a state that has no outgoing transitions (so/// 'transitions' is empty). Note that there is no way for a leaf state to be a/// non-matching state. (Although while building the trie, within 'add', a leaf/// state may exist while not containing any matches. But this invariant is/// only broken within 'add'. Once 'add' returns, the invariant is upheld.)/// Mark this state as a match state and freeze the active chunk such that/// it can not be further mutated.is_leaf/// Returns true if and only if this state is a leaf state. That is, a/// state that has no outgoing transitions./// Returns an iterator over all of the chunks (including the currently/// active chunk) in this state. Since the active chunk is included, the/// iterator is guaranteed to always yield at least one chunk (although the/// chunk may be empty).active_chunk/// Returns the active chunk as a slice of transitions.active_chunk_start/// Returns the index into 'transitions' where the active chunk starts./// An iterator over all of the chunks in a state, including the active chunk./// This iterator is created by `State::chunks`. We name this iterator so that/// we can include it in the `Frame` type for non-recursive trie traversal./// A single transition in a trie to another state.zapmakerPRIME// Basic FNV-1a hash constants as described in:// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function/// The current version of this map. Only entries with matching versions/// are considered during lookups. If an entry is found with a mismatched/// version, then the map behaves as if the entry does not exist./// This makes it possible to clear the map by simply incrementing the/// version number instead of actually deallocating any storage./// The total number of entries this map can store.Utf8BoundedEntry/// The actual entries, keyed by hash. Collisions between different states/// result in the old state being dropped./// A bounded hash map where the key is a sequence of NFA transitions and the/// value is a pre-existing NFA state ID./// std's hashmap can be used for this, however, this map has two important/// advantages. Firstly, it has lower overhead. Secondly, it permits us to/// control our memory usage by limited the number of slots. In general, the/// cost here is that this map acts as a cache. That is, inserting a new entry/// may remove an old entry. We are okay with this, since it does not impact/// correctness in the cases where it is used. The only effect that dropping/// states from the cache has is that the resulting NFA generated may be bigger/// than it otherwise would be./// This improves benchmarks that compile large Unicode character classes,/// since it makes the generation of (almost) minimal UTF-8 automaton faster./// Specifically, one could observe the difference with std's hashmap via/// something like the following benchmark:///   hyperfine "regex-cli debug thompson -qr --captures none '\w{90} ecurB'"/// But to observe that difference, you'd have to modify the code to use/// std's hashmap./// It is quite possible that there is a better way to approach this problem./// For example, if there happens to be a very common state that collides with/// a lot of less frequent states, then we could wind up with very poor caching/// behavior. Alas, the effectiveness of this cache has not been measured./// Instead, ad hoc experiments suggest that it is "good enough." Additional/// smarts (such as an LRU eviction policy) have to be weighed against the/// amount of extra time they cost./// The version of the map used to produce this entry. If this entry's/// version does not match the current version of the map, then the map/// should behave as if this entry does not exist./// The key, which is a sorted sequence of non-overlapping NFA transitions./// The state ID corresponding to the state containing the transitions in/// this entry./// An entry in this map./// Create a new bounded map with the given capacity. The map will never/// grow beyond the given size./// Note that this does not allocate. Instead, callers must call `clear`/// before using this map. `clear` will allocate space if necessary./// This avoids the need to pay for the allocation of this map when/// compiling regexes that lack large Unicode character classes./// Clear this map of all entries, but permit the reuse of allocation/// if possible./// This must be called before the map can be used./// Return a hash of the given transitions./// Retrieve the cached state ID corresponding to the given key. The hash/// given must have been computed with `hash` using the same key value./// If there is no cached state with the given transitions, then None is/// Add a cached state to this map with the given key. Callers should/// ensure that `state_id` points to a state that contains precisely the/// NFA transitions given./// `hash` must have been computed using the `hash` method with the sameUtf8SuffixEntry/// A cache of suffixes used to modestly compress UTF-8 automata for large/// Unicode character classes./// A key that uniquely identifies an NFA state. It is a triple that represents/// a transition from one state for a particular byte range./// The key, which consists of a transition in a particular state./// The identifier that the transition in the key maps to./// Return a hash of the given transition./// If there is no cached state with the given key, then None is returned./// NFA transition given.// This module contains a couple simple and purpose built hash maps. The key// trade off they make is that they serve as caches rather than true maps. That// is, inserting a new entry may cause eviction of another entry. This gives// us two things. First, there's less overhead associated with inserts and// lookups. Secondly, it lets us control our memory usage.// These maps are used in some fairly hot code when generating NFA states for// large Unicode character classes.// Instead of exposing a rich hashmap entry API, we just permit the caller to// produce a hash of the key directly. The hash can then be reused for both// lookups and insertions at the cost of leaking abstraction a bit. But these// are for internal use only, so it's fine.// The Utf8BoundedMap is used for Daciuk's algorithm for constructing a// (almost) minimal DFA for large Unicode character classes in linear time.// (Daciuk's algorithm is always used when compiling forward NFAs. For reverse// NFAs, it's only used when the compiler is configured to 'shrink' the NFA,// since there's a bit more expense in the reverse direction.)// The Utf8SuffixMap is used when compiling large Unicode character classes for// reverse NFAs when 'shrink' is disabled. Specifically, it augments the naive// construction of UTF-8 automata by caching common suffixes. This doesn't// get the same space savings as Daciuk's algorithm, but it's basically as// fast as the naive approach and typically winds up using less memory (since// it generates smaller NFAs) despite the presence of the cache.// These maps effectively represent caching mechanisms for sparse and// byte-range NFA states, respectively. The former represents a single NFA// state with many transitions of equivalent priority while the latter// represents a single NFA state with a single transition. (Neither state ever// has or is an epsilon transition.) Thus, they have different key types. It's// likely we could make one generic map, but the machinery didn't seem worth// it. They are simple enough.DenseTransitions/*!
Defines a Thompson NFA and provides the [`PikeVM`](pikevm::PikeVM) and
[`BoundedBacktracker`](backtrack::BoundedBacktracker) regex engines.

A Thompson NFA (non-deterministic finite automaton) is arguably _the_ central
data type in this library. It is the result of what is commonly referred to as
"regex compilation." That is, turning a regex pattern from its concrete syntax
string into something that can run a search looks roughly like this:

* A `&str` is parsed into a [`regex-syntax::ast::Ast`](regex_syntax::ast::Ast).
* An `Ast` is translated into a [`regex-syntax::hir::Hir`](regex_syntax::hir::Hir).
* An `Hir` is compiled into a [`NFA`].
* The `NFA` is then used to build one of a few different regex engines:
  * An `NFA` is used directly in the `PikeVM` and `BoundedBacktracker` engines.
  * An `NFA` is used by a [hybrid NFA/DFA](crate::hybrid) to build out a DFA's
  transition table at search time.
  * An `NFA`, assuming it is one-pass, is used to build a full
  [one-pass DFA](crate::dfa::onepass) ahead of time.
  * An `NFA` is used to build a [full DFA](crate::dfa) ahead of time.

The [`meta`](crate::meta) regex engine makes all of these choices for you based
on various criteria. However, if you have a lower level use case, _you_ can
build any of the above regex engines and use them directly. But you must start
here by building an `NFA`.

# Details

It is perhaps worth expanding a bit more on what it means to go through the
`&str`->`Ast`->`Hir`->`NFA` process.

* Parsing a string into an `Ast` gives it a structured representation.
Crucially, the size and amount of work done in this step is proportional to the
size of the original string. No optimization or Unicode handling is done at
this point. This means that parsing into an `Ast` has very predictable costs.
Moreover, an `Ast` can be roundtripped back to its original pattern string as
written.
* Translating an `Ast` into an `Hir` is a process by which the structured
representation is simplified down to its most fundamental components.
Translation deals with flags such as case insensitivity by converting things
like `(?i:a)` to `[Aa]`. Translation is also where Unicode tables are consulted
to resolve things like `\p{Emoji}` and `\p{Greek}`. It also flattens each
character class, regardless of how deeply nested it is, into a single sequence
of non-overlapping ranges. All the various literal forms are thrown out in
favor of one common representation. Overall, the `Hir` is small enough to fit
into your head and makes analysis and other tasks much simpler.
* Compiling an `Hir` into an `NFA` formulates the regex into a finite state
machine whose transitions are defined over bytes. For example, an `Hir` might
have a Unicode character class corresponding to a sequence of ranges defined
in terms of `char`. Compilation is then responsible for turning those ranges
into a UTF-8 automaton. That is, an automaton that matches the UTF-8 encoding
of just the codepoints specified by those ranges. Otherwise, the main job of
an `NFA` is to serve as a byte-code of sorts for a virtual machine. It can be
seen as a sequence of instructions for how to match a regex.
*/// We make NFAs reference counted primarily for two reasons. First is that// the NFA type itself is quite large (at least 0.5KB), and so it makes// sense to put it on the heap by default anyway. Second is that, for Arc// specifically, this enables cheap clones. This tends to be useful because// several structures (the backtracker, the Pike VM, the hybrid NFA/DFA)// all want to hang on to an NFA for use during search time. We could// provide the NFA at search time via a function argument, but this makes// for an unnecessarily annoying API. Instead, we just let each structure// share ownership of the NFA. Using a deep clone would not be smart, since// the NFA can use quite a bit of heap space./// A byte oriented Thompson non-deterministic finite automaton (NFA)./// A Thompson NFA is a finite state machine that permits unconditional epsilon/// transitions, but guarantees that there exists at most one non-epsilon/// transition for each element in the alphabet for each state./// An NFA may be used directly for searching, for analysis or to build/// a deterministic finite automaton (DFA)./// # Cheap clones/// Since an NFA is a core data type in this crate that many other regex/// engines are based on top of, it is convenient to give ownership of an NFA/// to said regex engines. Because of this, an NFA uses reference counting/// internally. Therefore, it is cheap to clone and it is encouraged to do so./// Using an NFA for searching via the/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) provides the most amount/// of "power" of any regex engine in this crate. Namely, it supports the/// following in all cases:/// 2. Location of a match, including both the start and end offset, in a/// single pass of the haystack./// 3. Location of matching capturing groups./// 4. Handles multiple patterns, including (1)-(3) when multiple patterns are/// # Capturing Groups/// Groups refer to parenthesized expressions inside a regex pattern. They look/// like this, where `exp` is an arbitrary regex:/// * `(exp)` - An unnamed capturing group./// * `(?P<name>exp)` or `(?<name>exp)` - A named capturing group./// * `(?:exp)` - A non-capturing group./// * `(?i:exp)` - A non-capturing group that sets flags./// Only the first two forms are said to be _capturing_. Capturing/// means that the last position at which they match is reportable. The/// [`Captures`](crate::util::captures::Captures) type provides convenient/// access to the match positions of capturing groups, which includes looking/// up capturing groups by their name./// # Byte oriented/// This NFA is byte oriented, which means that all of its transitions are/// defined on bytes. In other words, the alphabet of an NFA consists of the/// 256 different byte values./// While DFAs nearly demand that they be byte oriented for performance/// reasons, an NFA could conceivably be *Unicode codepoint* oriented. Indeed,/// a previous version of this NFA supported both byte and codepoint oriented/// modes. A codepoint oriented mode can work because an NFA fundamentally uses/// a sparse representation of transitions, which works well with the large/// sparse space of Unicode codepoints./// Nevertheless, this NFA is only byte oriented. This choice is primarily/// driven by implementation simplicity, and also in part memory usage. In/// practice, performance between the two is roughly comparable. However,/// building a DFA (including a hybrid DFA) really wants a byte oriented NFA./// So if we do have a codepoint oriented NFA, then we also need to generate/// byte oriented NFA in order to build an hybrid NFA/DFA. Thus, by only/// generating byte oriented NFAs, we can produce one less NFA. In other words,/// if we made our NFA codepoint oriented, we'd need to *also* make it support/// a byte oriented mode, which is more complicated. But a byte oriented mode/// can support everything./// # Differences with DFAs/// At the theoretical level, the precise difference between an NFA and a DFA/// is that, in a DFA, for every state, an input symbol unambiguously refers/// to a single transition _and_ that an input symbol is required for each/// transition. At a practical level, this permits DFA implementations to be/// implemented at their core with a small constant number of CPU instructions/// for each byte of input searched. In practice, this makes them quite a bit/// faster than NFAs _in general_. Namely, in order to execute a search for any/// Thompson NFA, one needs to keep track of a _set_ of states, and execute/// the possible transitions on all of those states for each input symbol./// Overall, this results in much more overhead. To a first approximation, one/// can expect DFA searches to be about an order of magnitude faster./// So why use an NFA at all? The main advantage of an NFA is that it takes/// linear time (in the size of the pattern string after repetitions have been/// expanded) to build and linear memory usage. A DFA, on the other hand, may/// take exponential time and/or space to build. Even in non-pathological/// cases, DFAs often take quite a bit more memory than their NFA counterparts,/// _especially_ if large Unicode character classes are involved. Of course,/// an NFA also provides additional capabilities. For example, it can match/// Unicode word boundaries on non-ASCII text and resolve the positions of/// Note that a [`hybrid::regex::Regex`](crate::hybrid::regex::Regex) strikes a/// good balance between an NFA and a DFA. It avoids the exponential build time/// of a DFA while maintaining its fast search time. The downside of a hybrid/// NFA/DFA is that in some cases it can be slower at search time than the NFA./// (It also has less functionality than a pure NFA. It cannot handle Unicode/// word boundaries on non-ASCII text and cannot resolve capturing groups.)/// This shows how to build an NFA with the default configuration and execute a/// search using the Pike VM./// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};/// let re = PikeVM::new(r"foo[0-9]+")?;/// re.captures(&mut cache, b"foo12345", &mut caps);/// # Example: resolving capturing groups/// This example shows how to parse some simple dates and extract the/// components of each date via capturing groups.///     nfa::thompson::pikevm::PikeVM,/// let vm = PikeVM::new(r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})")?;/// let haystack = "2012-03-14, 2013-01-01 and 2014-07-05";/// let all: Vec<Captures> = vm.captures_iter(///     &mut cache, haystack.as_bytes()/// // There should be a total of 3 matches./// assert_eq!(3, all.len());/// // The year from the second match is '2013'./// let span = all[1].get_group_by_name("y").unwrap();/// assert_eq!("2013", &haystack[span]);/// This example shows that only the last match of a capturing group is/// reported, even if it had to match multiple times for an overall match/// to occur./// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};/// let re = PikeVM::new(r"([a-z]){4}")?;/// let haystack = b"quux";/// assert_eq!(Some(Span::from(3..4)), caps.get_group(1));/// build an NFA from it./// If you want a non-default configuration, then use the NFA/// [`Compiler`] with a [`Config`]./// build a multi-NFA from them./// let re = PikeVM::new_many(&["[0-9]+", "[a-z]+"])?;/// let expected = Some(Match::must(1, 0..3));/// re.captures(&mut cache, b"foo12345bar", &mut caps);/// Returns an NFA with a single regex pattern that always matches at every/// let re = PikeVM::new_from_nfa(NFA::always_match())?;/// let expected = Some(Match::must(0, 0..0));/// re.captures(&mut cache, b"", &mut caps);/// re.captures(&mut cache, b"foo", &mut caps);/// Returns an NFA that never matches at any position./// This is a convenience routine for creating an NFA with zero patterns./// use regex_automata::nfa::thompson::{NFA, pikevm::PikeVM};/// let re = PikeVM::new_from_nfa(NFA::never_match())?;/// assert!(!caps.is_match());/// Return a default configuration for an `NFA`./// type when customizing the construction of an NFA./// This example shows how to build an NFA with a small size limit that/// results in a compilation error for any regex that tries to use more/// heap memory than the configured limit./// let result = PikeVM::builder()///     .thompson(NFA::config().nfa_size_limit(Some(1_000)))///     // Remember, \w is Unicode-aware by default and thus huge.///     .build(r"\w+");/// Return a compiler for configuring the construction of an `NFA`./// [`Compiler`] type in common cases./// This example shows how to build an NFA that is permitted match invalid/// UTF-8. Without the additional syntax configuration here, compilation of/// `(?-u:.)` would fail because it is permitted to match invalid UTF-8.///     .build(r"[a-z]+(?-u:.)")?;/// let expected = Some(Match::must(0, 1..5));/// re.captures(&mut cache, b"\xFFabc\xFF", &mut caps);/// Returns an iterator over all pattern identifiers in this NFA./// Pattern IDs are allocated in sequential order starting from zero,/// where the order corresponds to the order of patterns provided to the/// [`NFA::new_many`] constructor./// use regex_automata::{nfa::thompson::NFA, PatternID};/// let nfa = NFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;/// let pids: Vec<PatternID> = nfa.patterns().collect();/// assert_eq!(pids, vec![/// Returns the total number of regex patterns in this NFA./// This may return zero if the NFA was constructed with no patterns. In/// this case, the NFA can never produce a match for any input./// This is guaranteed to be no bigger than [`PatternID::LIMIT`] because/// NFA construction will fail if too many patterns are added./// It is always true that `nfa.patterns().count() == nfa.pattern_len()`./// assert_eq!(3, nfa.pattern_len());/// let nfa = NFA::never_match();/// assert_eq!(0, nfa.pattern_len());/// let nfa = NFA::always_match();/// assert_eq!(1, nfa.pattern_len());start_anchored/// Return the state identifier of the initial anchored state of this NFA./// The returned identifier is guaranteed to be a valid index into the/// slice returned by [`NFA::states`], and is also a valid argument to/// [`NFA::state`]./// This example shows a somewhat contrived example where we can easily/// predict the anchored starting state./// use regex_automata::nfa::thompson::{NFA, State, WhichCaptures};///     .configure(NFA::config().which_captures(WhichCaptures::None))///     .build("a")?;/// let state = nfa.state(nfa.start_anchored());/// match *state {///     State::ByteRange { trans } => {///         assert_eq!(b'a', trans.start);///         assert_eq!(b'a', trans.end);///     _ => unreachable!("unexpected state"),start_unanchored/// Return the state identifier of the initial unanchored state of this/// This is equivalent to the identifier returned by/// [`NFA::start_anchored`] when the NFA has no unanchored starting state./// This example shows that the anchored and unanchored starting states/// are equivalent when an anchored NFA is built./// let nfa = NFA::new("^a")?;/// assert_eq!(nfa.start_anchored(), nfa.start_unanchored());/// Return the state identifier of the initial anchored state for the given/// pattern, or `None` if there is no pattern corresponding to the given/// If one uses the starting state for a particular pattern, then the only/// match that can be returned is for the corresponding pattern./// If the pattern doesn't exist in this NFA, then this returns an error./// This occurs when `pid.as_usize() >= nfa.pattern_len()`./// let nfa = NFA::new_many(&["^a", "^b"])?;/// // The anchored and unanchored states for the entire NFA are the same,/// // since all of the patterns are anchored./// // But the anchored starting states for each pattern are distinct,/// // because these starting states can only lead to matches for the/// // corresponding pattern./// let anchored = Some(nfa.start_anchored());/// assert_ne!(anchored, nfa.start_pattern(PatternID::must(0)));/// assert_ne!(anchored, nfa.start_pattern(PatternID::must(1)));/// // Requesting a pattern not in the NFA will result in None:/// assert_eq!(None, nfa.start_pattern(PatternID::must(2)));byte_class_set/// Get the byte class set for this NFA./// A byte class set is a partitioning of this NFA's alphabet into/// equivalence classes. Any two bytes in the same equivalence class are/// guaranteed to never discriminate between a match or a non-match. (The/// partitioning may not be minimal.)/// Byte classes are used internally by this crate when building DFAs./// Namely, among other optimizations, they enable a space optimization/// where the DFA's internal alphabet is defined over the equivalence/// classes of bytes instead of all possible byte values. The former is/// often quite a bit smaller than the latter, which permits the DFA to use/// less space for its transition table./// Get the byte classes for this NFA./// Byte classes represent a partitioning of this NFA's alphabet into/// This example shows how to query the class of various bytes./// let nfa = NFA::new("[a-z]+")?;/// let classes = nfa.byte_classes();/// // 'a' and 'z' are in the same class for this regex./// assert_eq!(classes.get(b'a'), classes.get(b'z'));/// // But 'a' and 'A' are not./// assert_ne!(classes.get(b'a'), classes.get(b'A'));/// Return a reference to the NFA state corresponding to the given ID./// This is a convenience routine for `nfa.states()[id]`./// This panics when the given identifier does not reference a valid state./// That is, when `id.as_usize() >= nfa.states().len()`./// The anchored state for a pattern will typically correspond to a/// capturing state for that pattern. (Although, this is not an API/// guarantee!)/// use regex_automata::{nfa::thompson::{NFA, State}, PatternID};/// let nfa = NFA::new("a")?;/// let state = nfa.state(nfa.start_pattern(PatternID::ZERO).unwrap());///     State::Capture { slot, .. } => {///         assert_eq!(0, slot.as_usize());/// Returns a slice of all states in this NFA./// The slice returned is indexed by `StateID`. This provides a convenient/// way to access states while following transitions among those states./// This demonstrates that disabling UTF-8 mode can shrink the size of the/// NFA considerably in some cases, especially when using Unicode character/// classes./// let nfa_unicode = NFA::new(r"\w")?;/// let nfa_ascii = NFA::new(r"(?-u)\w")?;/// // Yes, a factor of 45 difference. No lie./// assert!(40 * nfa_ascii.states().len() < nfa_unicode.states().len());/// Returns the capturing group info for this NFA./// The [`GroupInfo`] provides a way to map to and from capture index/// and capture name for each pattern. It also provides a mapping from/// each of the capturing groups in every pattern to their corresponding/// slot offsets encoded in [`State::Capture`] states./// Note that `GroupInfo` uses reference counting internally, such that/// cloning a `GroupInfo` is very cheap./// This example shows how to get a list of all capture group names for/// a particular pattern./// let nfa = NFA::new(r"(a)(?P<foo>b)(c)(d)(?P<bar>e)")?;/// // The first is the implicit group that is always unnammed. The next/// // 5 groups are the explicit groups found in the concrete syntax above./// let expected = vec![None, None, Some("foo"), None, None, Some("bar")];/// let got: Vec<Option<&str>> =///     nfa.group_info().pattern_names(PatternID::ZERO).collect();/// // Using an invalid pattern ID will result in nothing yielded./// let got = nfa.group_info().pattern_names(PatternID::must(999)).count();/// assert_eq!(0, got);has_capture/// Returns true if and only if this NFA has at least one/// [`Capture`](State::Capture) in its sequence of states./// This is useful as a way to perform a quick test before attempting/// something that does or does not require capture states. For example,/// some regex engines (like the PikeVM) require capture states in order to/// work at all./// This example shows a few different NFAs and whether they have captures/// // Obviously has capture states./// let nfa = NFA::new("(a)")?;/// assert!(nfa.has_capture());/// // Less obviously has capture states, because every pattern has at/// // least one anonymous capture group corresponding to the match for the/// // entire pattern./// // Other than hand building your own NFA, this is the only way to build/// // an NFA without capturing groups. In general, you should only do this/// // if you don't intend to use any of the NFA-oriented regex engines./// // Overall, capturing groups don't have many downsides. Although they/// // can add a bit of noise to simple NFAs, so it can be nice to disable/// // them for debugging purposes./// // Notice that 'has_capture' is false here even when we have an/// // explicit capture group in the pattern.///     .build("(a)")?;/// assert!(!nfa.has_capture());/// Returns true if and only if this NFA can match the empty string./// This example shows a few different NFAs and whether they match the/// let nfa = NFA::new("")?;/// assert!(nfa.has_empty(), "empty matches empty");/// let nfa = NFA::new("a+")?;/// assert!(!nfa.has_empty(), "+ does not match empty");/// let nfa = NFA::new("a*")?;/// assert!(nfa.has_empty(), "* does match empty");/// let nfa = NFA::new("(a+)*")?;/// assert!(nfa.has_empty(), "+ inside of * matches empty");/// assert!(nfa.has_empty(), "assertions match empty");/// let nfa = NFA::new(r"\b+")?;/// assert!(nfa.has_empty(), "+ of an assertion matches empty");/// let nfa = NFA::new("foo|(bar)?|quux")?;/// assert!(nfa.has_empty(), "alternations can match empty");/// let nfa = NFA::new("[a&&b]")?;/// assert!(!nfa.has_empty(), "never matching means not matching empty");/// let nfa = NFA::new("[a&&b]*")?;/// assert!(nfa.has_empty(), "* on never-match still matches empty");/// let nfa = NFA::new("[a&&b]+")?;/// assert!(!nfa.has_empty(), "+ on never-match still matches nothing");/// Whether UTF-8 mode is enabled for this NFA or not./// When UTF-8 mode is enabled, all matches reported by a regex engine/// derived from this NFA are guaranteed to correspond to spans of valid/// UTF-8. This includes zero-width matches. For example, the regex engine/// must guarantee that the empty regex will not match at the positions/// between code units in the UTF-8 encoding of a single codepoint./// See [`Config::utf8`] for more information./// Returns true when this NFA is meant to be matched in reverse./// Generally speaking, when this is true, it means the NFA is supposed to/// be used in conjunction with moving backwards through the haystack. That/// is, from a higher memory address to a lower memory address./// It is often the case that lower level routines dealing with an NFA/// don't need to care about whether it is "meant" to be matched in reverse/// or not. However, there are some specific cases where it matters. For/// example, the implementation of CRLF-aware `^` and `$` line anchors/// needs to know whether the search is in the forward or reverse/// direction. In the forward direction, neither `^` nor `$` should match/// when a `\r` has been seen previously and a `\n` is next. However, in/// the reverse direction, neither `^` nor `$` should match when a `\n`/// has been seen previously and a `\r` is next. This fundamentally changes/// how the state machine is constructed, and thus needs to be altered/// based on the direction of the search./// This is automatically set when using a [`Compiler`] with a configuration/// where [`Config::reverse`] is enabled. If you're building your own NFA/// by hand via a [`Builder`]/// Returns true if and only if all starting states for this NFA correspond/// to the beginning of an anchored search./// Typically, an NFA will have both an anchored and an unanchored starting/// state. Namely, because it tends to be useful to have both and the cost/// of having an unanchored starting state is almost zero (for an NFA)./// However, if all patterns in the NFA are themselves anchored, then even/// the unanchored starting state will correspond to an anchored search/// since the pattern doesn't permit anything else./// This example shows a few different scenarios where this method's/// return value varies./// // The unanchored starting state permits matching this pattern anywhere/// // in a haystack, instead of just at the beginning./// assert!(!nfa.is_always_start_anchored());/// // In this case, the pattern is itself anchored, so there is no way/// // to run an unanchored search./// assert!(nfa.is_always_start_anchored());/// // When multiline mode is enabled, '^' can match at the start of a line/// // in addition to the start of a haystack, so an unanchored search is/// // actually possible./// let nfa = NFA::new("(?m)^a")?;/// // Weird cases also work. A pattern is only considered anchored if all/// // matches may only occur at the start of a haystack./// let nfa = NFA::new("(^a)|a")?;/// // When multiple patterns are present, if they are all anchored, then/// // the NFA is always anchored too./// let nfa = NFA::new_many(&["^a", "^b", "^c"])?;/// // But if one pattern is unanchored, then the NFA must permit an/// // unanchored search./// let nfa = NFA::new_many(&["^a", "b", "^c"])?;/// Returns the look-around matcher associated with this NFA./// If the NFA was built using a [`Compiler`], then this matcher/// can be set via the [`Config::look_matcher`] configuration/// knob. Otherwise, if you've built an NFA by hand, it is set via/// [`Builder::set_look_matcher`].look_set_any/// Returns the union of all look-around assertions used throughout this/// NFA. When the returned set is empty, it implies that the NFA has no/// look-around assertions and thus zero conditional epsilon transitions./// This is useful in some cases enabling optimizations. It is not/// unusual, for example, for optimizations to be of the form, "for any/// regex with zero conditional epsilon transitions, do ..." where "..."/// is some kind of optimization./// This isn't only helpful for optimizations either. Sometimes look-around/// assertions are difficult to support. For example, many of the DFAs in/// this crate don't support Unicode word boundaries or handle them using/// heuristics. Handling that correctly typically requires some kind of/// cheap check of whether the NFA has a Unicode word boundary in the first/// This example shows how this routine varies based on the regex pattern:/// use regex_automata::{nfa::thompson::NFA, util::look::Look};/// // No look-around at all./// assert!(nfa.look_set_any().is_empty());/// // When multiple patterns are present, since this returns the union,/// // it will include look-around assertions that only appear in one/// // pattern./// let nfa = NFA::new_many(&["a", "b", "a^b", "c"])?;/// assert!(nfa.look_set_any().contains(Look::Start));/// // Some groups of assertions have various shortcuts. For example:/// let nfa = NFA::new(r"(?-u:\b)")?;/// assert!(nfa.look_set_any().contains_word());/// assert!(!nfa.look_set_any().contains_word_unicode());/// assert!(nfa.look_set_any().contains_word_ascii());look_set_prefix_any/// Returns the union of all prefix look-around assertions for every/// pattern in this NFA. When the returned set is empty, it implies none of/// the patterns require moving through a conditional epsilon transition/// before inspecting the first byte in the haystack./// This can be useful for determining what kinds of assertions need to be/// satisfied at the beginning of a search. For example, typically DFAs/// in this crate will build a distinct starting state for each possible/// starting configuration that might result in look-around assertions/// being satisfied differently. However, if the set returned here is/// empty, then you know that the start state is invariant because there/// are no conditional epsilon transitions to consider./// assert!(nfa.look_set_prefix_any().is_empty());/// // pattern. But it will only include assertions that are in the prefix/// // of a pattern. For example, this includes '^' but not '$' even though/// // '$' does appear./// let nfa = NFA::new_many(&["a", "b", "^ab$", "c"])?;/// assert!(nfa.look_set_prefix_any().contains(Look::Start));/// assert!(!nfa.look_set_prefix_any().contains(Look::End));/// Returns the memory usage, in bytes, of this NFA./// This does **not** include the stack size used up by this NFA. To/// compute that, use `std::mem::size_of::<NFA>()`./// This example shows that large Unicode character classes can use quite/// a bit of memory./// let nfa_ascii = NFA::new(r"(?-u:\w)")?;/// assert!(10 * nfa_ascii.memory_usage() < nfa_unicode.memory_usage());// FIXME: The `look_set_prefix_all` computation was not correct, and it// seemed a little tricky to fix it. Since I wasn't actually using it for// anything, I just decided to remove it in the run up to the regex 1.9// release. If you need this, please file an issue./*
    /// Returns the intersection of all prefix look-around assertions for every
    /// pattern in this NFA. When the returned set is empty, it implies at
    /// least one of the patterns does not require moving through a conditional
    /// epsilon transition before inspecting the first byte in the haystack.
    /// Conversely, when the set contains an assertion, it implies that every
    /// pattern in the NFA also contains that assertion in its prefix.
    ///
    /// This can be useful for determining what kinds of assertions need to be
    /// satisfied at the beginning of a search. For example, if you know that
    /// [`Look::Start`] is in the prefix intersection set returned here, then
    /// you know that all searches, regardless of input configuration, will be
    /// anchored.
    ///
    /// # Example
    ///
    /// This example shows how this routine varies based on the regex pattern:
    ///
    /// ```
    /// use regex_automata::{nfa::thompson::NFA, util::look::Look};
    ///
    /// // No look-around at all.
    /// let nfa = NFA::new("a")?;
    /// assert!(nfa.look_set_prefix_all().is_empty());
    ///
    /// // When multiple patterns are present, since this returns the
    /// // intersection, it will only include assertions present in every
    /// // prefix, and only the prefix.
    /// let nfa = NFA::new_many(&["^a$", "^b$", "$^ab$", "^c$"])?;
    /// assert!(nfa.look_set_prefix_all().contains(Look::Start));
    /// assert!(!nfa.look_set_prefix_all().contains(Look::End));
    ///
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    #[inline]
    pub fn look_set_prefix_all(&self) -> LookSet {
        self.0.look_set_prefix_all
    }
    *//// The state sequence. This sequence is guaranteed to be indexable by all/// starting state IDs, and it is also guaranteed to contain at most one/// `Match` state for each pattern compiled into this NFA. (A pattern may/// not have a corresponding `Match` state if a `Match` state is impossible/// to reach.)/// The anchored starting state of this NFA./// The unanchored starting state of this NFA./// Info about the capturing groups in this NFA. This is responsible for/// mapping groups to slots, mapping groups to names and names to groups./// A representation of equivalence classes over the transitions in this/// NFA. Two bytes in the same equivalence class must not discriminate/// between a match or a non-match. This map can be used to shrink the/// total size of a DFA's transition table with a small match-time cost./// Note that the NFA's transitions are *not* defined in terms of these/// equivalence classes. The NFA's transitions are defined on the original/// byte values. For the most part, this is because they wouldn't really/// help the NFA much since the NFA already uses a sparse representation/// to represent transitions. Byte classes are most effective in a dense/// This is generated from `byte_class_set`, and essentially represents the/// same thing but supports different access patterns. Namely, this permits/// looking up the equivalence class of a byte very cheaply./// Ideally we would just store this, but because of annoying code/// structure reasons, we keep both this and `byte_class_set` around for/// now. I think I would prefer that `byte_class_set` were computed in the/// `Builder`, but right now, we compute it as states are added to the/// `NFA`./// Whether this NFA has a `Capture` state anywhere./// When the empty string is in the language matched by this NFA./// Whether UTF-8 mode is enabled for this NFA. Briefly, this means that/// all non-empty matches produced by this NFA correspond to spans of valid/// UTF-8, and any empty matches produced by this NFA that split a UTF-8/// encoded codepoint should be filtered out by the corresponding regex/// Whether this NFA is meant to be matched in reverse or not./// The matcher to be used for look-around assertions./// The union of all look-around assertions that occur anywhere within/// this NFA. If this set is empty, then it means there are precisely zero/// conditional epsilon transitions in the NFA./// The union of all look-around assertions that occur as a zero-length/// prefix for any of the patterns in this NFA.memory_extra/*
    /// The intersection of all look-around assertions that occur as a
    /// zero-length prefix for any of the patterns in this NFA.
    look_set_prefix_all: LookSet,
    *//// Heap memory used indirectly by NFA states and other things (like the/// various capturing group representations above). Since each state/// might use a different amount of heap, we need to keep track of this/// incrementally./// The "inner" part of the NFA. We split this part out so that we can easily/// wrap it in an `Arc` above in the definition of `NFA`./// See builder.rs for the code that actually builds this type. This module/// does provide (internal) mutable methods for adding things to this/// NFA before finalizing it, but the high level construction process is/// controlled by the builder abstraction. (Which is complicated enough to/// get its own module.)into_nfa/// Runs any last finalization bits and turns this into a full NFA./// Add the given state to this NFA after allocating a fresh identifier for/// This panics if too many states are added such that a fresh identifier/// could not be created. (Currently, the only caller of this routine is/// a `Builder`, and it upholds this invariant.)set_starts/// Set the starting state identifiers for this NFA./// `start_anchored` and `start_unanchored` may be equivalent. When they/// are, then the NFA can only execute anchored searches. This might/// occur, for example, for patterns that are unconditionally anchored./// e.g., `^foo`./// Sets the UTF-8 mode of this NFA./// Sets the reverse mode of this NFA./// Sets the look-around assertion matcher for this NFA.set_captures/// Set the capturing groups for this NFA./// The given slice should contain the capturing groups for each pattern,/// The capturing groups in turn should correspond to the total number of/// capturing groups in the pattern, including the anonymous first capture/// group for each pattern. If a capturing group does have a name, then it/// should be provided as a Arc<str>./// This returns an error if a corresponding `GroupInfo` could not be/// built./// Remap the transitions in every state of this NFA using the given map./// The given map should be indexed according to state ID namespace used by/// the transitions of the states currently in this NFA./// This is particularly useful to the NFA builder, since it is convenient/// to add NFA states in order to produce their final IDs. Then, after all/// of the intermediate "empty" states (unconditional epsilon transitions)/// have been removed from the builder's representation, we can re-map all/// of the transitions in the states already added to their final IDs./// The transition from this state to the next./// A state with a single transition that can only be taken if the current/// input symbol is in a particular range of bytes./// A state with possibly many transitions represented in a sparse fashion./// Transitions are non-overlapping and ordered lexicographically by input/// In practice, this is used for encoding UTF-8 automata. Its presence is/// primarily an optimization that avoids many additional unconditional/// epsilon transitions (via [`Union`](State::Union) states), and thus/// decreases the overhead of traversing the NFA. This can improve both/// matching time and DFA construction time./// A dense representation of a state with multiple transitions./// The look-around assertion that must be satisfied before moving/// to `next`./// The state to transition to if the look-around assertion is/// satisfied./// look-around. Look-around is limited to anchor and word boundary/// assertions./// Look-around states are meant to be evaluated while performing epsilon/// closure (computing the set of states reachable from a particular state/// via only epsilon transitions). If the current position in the haystack/// satisfies the look-around assertion, then you're permitted to follow/// that epsilon transition./// An ordered sequence of unconditional epsilon transitions to other/// states. Transitions earlier in the sequence are preferred over/// transitions later in the sequence.alt1/// An unconditional epsilon transition to another NFA state. This/// is preferred over `alt2`.alt2/// An unconditional epsilon transition to another NFA state. Matches/// reported via this transition should only be reported if no matches/// were found by following `alt1`.BinaryUnion/// An alternation such that there exists precisely two unconditional/// epsilon transitions, where matches found via `alt1` are preferred over/// matches found via `alt2`./// This state exists as a common special case of Union where there are/// only two alternates. In this case, we don't need any allocations to/// represent the state. This saves a bit of memory and also saves an/// additional memory access when traversing the NFA./// The state to transition to, unconditionally./// The pattern ID that this capture belongs to./// The capture group index that this capture belongs to. Capture group/// indices are local to each pattern. For example, when capturing/// groups are enabled, every pattern has a capture group at index/// `0`./// The slot index for this capture. Every capturing group has two/// slots: one for the start haystack offset and one for the end/// haystack offset. Unlike capture group indices, slot indices are/// global across all patterns in this NFA. That is, each slot belongs/// to a single pattern, but there is only one slot at index `i`./// An empty state that records a capture location./// From the perspective of finite automata, this is precisely equivalent/// to an unconditional epsilon transition, but serves the purpose of/// instructing NFA simulations to record additional state when the finite/// state machine passes through this epsilon transition./// `slot` in this context refers to the specific capture group slot/// offset that is being recorded. Each capturing group has two slots/// corresponding to the start and end of the matching portion of that/// The pattern ID and capture group index are also included in this state/// in case they are useful. But mostly, all you'll need is `next` and/// `slot`./// regex parser permits empty character classes, then one could choose/// a `Fail` state to represent them. (An empty character class can be/// thought of as an empty set. Since nothing is in an empty set, they can/// never match anything.)/// The matching pattern ID./// A match state. There is at least one such occurrence of this state for/// each regex that can match that is in this NFA./// A state in an NFA./// In theory, it can help to conceptualize an `NFA` as a graph consisting of/// `State`s. Each `State` contains its complete set of outgoing transitions./// In practice, it can help to conceptualize an `NFA` as a sequence of/// instructions for a virtual machine. Each `State` says what to do and where/// to go next./// Strictly speaking, the practical interpretation is the most correct one,/// because of the [`Capture`](State::Capture) state. Namely, a `Capture`/// state always forwards execution to another state unconditionally. Its only/// purpose is to cause a side effect: the recording of the current input/// position at a particular location in memory. In this sense, an `NFA`/// has more power than a theoretical non-deterministic finite automaton./// For most uses of this crate, it is likely that one may never even need to/// be aware of this type at all. The main use cases for looking at `State`s/// directly are if you need to write your own search implementation or if you/// need to do some kind of analysis on the NFA.is_epsilon/// Returns true if and only if this state contains one or more epsilon/// In practice, a state has no outgoing transitions (like `Match`), has/// only non-epsilon transitions (like `ByteRange`) or has only epsilon/// transitions (like `Union`).///     nfa::thompson::{State, Transition},///     util::primitives::{PatternID, StateID, SmallIndex},/// // Capture states are epsilon transitions./// let state = State::Capture {///     next: StateID::ZERO,///     pattern_id: PatternID::ZERO,///     group_index: SmallIndex::ZERO,///     slot: SmallIndex::ZERO,/// assert!(state.is_epsilon());/// // ByteRange states are not./// let state = State::ByteRange {///     trans: Transition { start: b'a', end: b'z', next: StateID::ZERO },/// assert!(!state.is_epsilon());/// Returns the heap memory usage of this NFA state in bytes./// Remap the transitions in this state using the given map. Namely, the/// given map should be indexed according to the transitions currently/// This is used during the final phase of the NFA compiler, which turns/// its intermediate NFA into the final NFA./// The sorted sequence of non-overlapping transitions./// A sequence of transitions used to represent a sparse state./// This is the primary representation of a [`Sparse`](State::Sparse) state./// It corresponds to a sorted sequence of transitions with non-overlapping/// byte ranges. If the byte at the current position in the haystack matches/// one of the byte ranges, then the finite state machine should take the/// This follows the matching transition for a particular byte./// The matching transition is found by looking for a matching byte/// range (there is at most one) corresponding to the position `at` in/// `haystack`./// If `at >= haystack.len()`, then this returns `None`.matches_unit/// This follows the matching transition for any member of the alphabet./// `haystack`. If the given alphabet unit is [`EOI`](alphabet::Unit::eoi),/// then this always returns `None`.matches_byte/// The matching transition is found by looking for a matching byte range/// (there is at most one) corresponding to the byte given./// A dense representation of this state's transitions on the heap. This/// always has length 256./// A sequence of transitions used to represent a dense state./// This is the primary representation of a [`Dense`](State::Dense) state. It/// provides constant time matching. That is, given a byte in a haystack and/// a `DenseTransitions`, one can determine if the state matches in constant/// This is in contrast to `SparseTransitions`, whose time complexity is/// necessarily bigger than constant time. Also in contrast, `DenseTransitions`/// usually requires (much) more heap memory./// The matching transition is found by looking for a transition that/// doesn't correspond to `StateID::ZERO` for the byte `at` the given/// position in `haystack`./// If `at >= haystack.len()` or if the given alphabet unit is/// [`EOI`](alphabet::Unit::eoi), then this returns `None`./// doesn't correspond to `StateID::ZERO` for the given `byte`./// Returns an iterator over all transitions that don't point to/// `StateID::ZERO`./*
    /// The dense state optimization isn't currently enabled, so permit a
    /// little bit of dead code.
    pub(crate) fn from_sparse(sparse: &SparseTransitions) -> DenseTransitions {
        let mut dense = vec![StateID::ZERO; 256];
        for t in sparse.transitions.iter() {
            for b in t.start..=t.end {
                dense[usize::from(b)] = t.next;
            }
        }
        DenseTransitions { transitions: dense.into_boxed_slice() }
    }
    *//// The inclusive start of the byte range./// The inclusive end of the byte range./// The identifier of the state to transition to./// A single transition to another state./// This transition may only be followed if the current byte in the haystack/// falls in the inclusive range of bytes specified./// Returns true if the position `at` in `haystack` falls in this/// transition's range of bytes./// If `at >= haystack.len()`, then this returns `false`./// Returns true if the given alphabet unit falls in this transition's/// range of bytes. If the given unit is [`EOI`](alphabet::Unit::eoi), then/// this returns `false`./// Returns true if the given byte falls in this transition's range of/// We explicitly associate a lifetime with this iterator even though we/// don't actually borrow anything from the NFA. We do this for backward/// compatibility purposes. If we ever do need to borrow something from/// the NFA, then we can and just get rid of this marker without breaking/// the public API./// An iterator over all pattern IDs in an NFA./// This iterator is created by [`NFA::patterns`]./// The lifetime parameter `'a` refers to the lifetime of the NFA from which/// this pattern iterator was created.// This asserts that an NFA state doesn't have its size changed. It is// dramatically increase the memory usage of every NFA.// This assert doesn't mean we absolutely cannot increase the size of an// NFA state. We can. It's just here to make sure we do it knowingly and// intentionally.instrument/// A simple macro for conditionally executing instrumentation logic when/// the 'trace' log level is enabled. This is a compile-time no-op when the/// 'internal-instrument-pikevm' feature isn't enabled. The intent here is that/// this makes it easier to avoid doing extra work when instrumentation isn't/// This macro accepts a closure of type `|&mut Counters|`. The closure can/// then increment counters (or whatever) in accordance with what one wants/// to track./// The configuration used for building a [`PikeVM`]./// A PikeVM configuration is a simple data object that is typically used with/// [`Builder::configure`]. It can be cheaply cloned./// perhaps more conveniently, with [`PikeVM::config`]./// Return a new default PikeVM configuration./// where all possible matches are visited in the NFA by the `PikeVM`./// strategy. Specifically, `LeftmostFirst` results in the `PikeVM`/// simulating dead states as a way to terminate the search and report a/// match. `LeftmostFirst` also supports non-greedy matches using this/// strategy where as `All` does not.///     .configure(PikeVM::config().prefilter(pre))/// assert_eq!(Some(Match::must(0, 5..11)), re.find(&mut cache, input));/// assert_eq!(None, re.find(&mut cache, input));/// A builder for a `PikeVM`./// This builder permits configuring options for the syntax of a pattern,/// the NFA construction and the `PikeVM` construction. This builder is/// different from a general purpose regex builder in that it permits fine/// * [`util::syntax::Config::utf8`](crate::util::syntax::Config::utf8)/// controls whether the pattern itself can contain sub-expressions that match/// invalid UTF-8./// let got = re.find_iter(&mut cache, haystack).next();/// // disabling UTF-8 mode on a PikeVM Config, since that/// Create a new PikeVM builder with its default configuration./// Build a `PikeVM` from the given pattern./// Build a `PikeVM` from the given patterns./// Build a `PikeVM` directly from its NFA./// Apply the given `PikeVM` configuration options to this builder./// These settings only apply when constructing a PikeVM directly from a/// A virtual machine for executing regex searches with capturing groups./// # Infallible APIs/// Unlike most other regex engines in this crate, a `PikeVM` never returns an/// error at search time. It supports all [`Anchored`] configurations, never/// quits and works on haystacks of arbitrary length./// There are two caveats to mention though:/// * If an invalid pattern ID is given to a search via [`Anchored::Pattern`],/// then the PikeVM will report "no match." This is consistent with all other/// regex engines in this crate./// * When using [`PikeVM::which_overlapping_matches`] with a [`PatternSet`]/// that has insufficient capacity to store all valid pattern IDs, then if a/// match occurs for a `PatternID` that cannot be inserted, it is silently/// dropped as if it did not match./// # Advice/// The `PikeVM` is generally the most "powerful" regex engine in this crate./// "Powerful" in this context means that it can handle any regular expression/// that is parseable by `regex-syntax` and any size haystack. Regretably,/// the `PikeVM` is also simultaneously often the _slowest_ regex engine in/// practice. This results in an annoying situation where one generally tries/// to pick any other regex engine (or perhaps none at all) before being/// forced to fall back to a `PikeVM`./// For example, a common strategy for dealing with capturing groups is to/// actually look for the overall match of the regex using a faster regex/// engine, like a [lazy DFA](crate::hybrid::regex::Regex). Once the overall/// match is found, one can then run the `PikeVM` on just the match span to/// find the spans of the capturing groups. In this way, the faster regex/// engine does the majority of the work, while the `PikeVM` only lends its/// power in a more limited role./// Unfortunately, this isn't always possible because the faster regex engines/// don't support all of the regex features in `regex-syntax`. This notably/// includes (and is currently limited to) Unicode word boundaries. So if/// your pattern has Unicode word boundaries, you typically can't use a/// DFA-based regex engine at all (unless you [enable heuristic support for/// it](crate::hybrid::dfa::Config::unicode_word_boundary)). (The [one-pass/// DFA](crate::dfa::onepass::DFA) can handle Unicode word boundaries for/// anchored searches only, but in a cruel sort of joke, many Unicode features/// tend to result in making the regex _not_ one-pass.)/// This example shows that the `PikeVM` implements Unicode word boundaries/// correctly by default./// let re = PikeVM::new(r"\b\w+\b")?;/// let mut it = re.find_iter(&mut cache, "Шерлок Холмс");/// assert_eq!(Some(Match::must(0, 0..12)), it.next());/// assert_eq!(Some(Match::must(0, 13..23)), it.next());/// return the corresponding `PikeVM`./// let re = PikeVM::new("foo[0-9]+bar")?;///     re.find_iter(&mut cache, "zzzfoo12345barzzz").next(),/// let re = PikeVM::new_many(&["[a-z]+", "[0-9]+"])?;/// Like `new`, but builds a PikeVM directly from an NFA. This is useful/// if you already have an NFA, or even if you hand-assembled the NFA./// compile an NFA from it and build a PikeVM from the NFA./// Create a new `PikeVM` that matches every input./// let re = PikeVM::always_match()?;/// assert_eq!(Some(expected), re.find_iter(&mut cache, "").next());/// assert_eq!(Some(expected), re.find_iter(&mut cache, "foo").next());/// Create a new `PikeVM` that never matches any input./// use regex_automata::nfa::thompson::pikevm::PikeVM;/// let re = PikeVM::never_match()?;/// assert_eq!(None, re.find_iter(&mut cache, "").next());/// assert_eq!(None, re.find_iter(&mut cache, "foo").next());/// Return a default configuration for a `PikeVM`./// type when customizing the construction of a `PikeVM`./// use regex_automata::{nfa::thompson::{self, pikevm::PikeVM}, Match};/// let mut it = re.find_iter(&mut cache, haystack);/// assert_eq!(Some(Match::must(0, 0..0)), it.next());/// assert_eq!(Some(Match::must(0, 1..1)), it.next());/// assert_eq!(Some(Match::must(0, 2..2)), it.next());/// assert_eq!(Some(Match::must(0, 3..3)), it.next());/// assert_eq!(Some(Match::must(0, 4..4)), it.next());/// assert_eq!(Some(Match::must(0, 5..5)), it.next());/// Return a builder for configuring the construction of a `PikeVM`./// valid for the search APIs on this `PikeVM`./// A `Captures` value created for a specific `PikeVM` cannot be used with/// any other `PikeVM`./// constructors that permit the `PikeVM` to do less work during a search,/// and thus might make it faster./// Create a new cache for this `PikeVM`./// `PikeVM`. If you want to reuse the cache for another `PikeVM`, then/// you must call [`Cache::reset`] with that `PikeVM` (or, equivalently,/// [`PikeVM::reset_cache`])./// this `PikeVM` (and only this `PikeVM`)./// with a different `PikeVM`./// This shows how to re-purpose a cache for use with a different `PikeVM`./// let re1 = PikeVM::new(r"\w")?;/// let re2 = PikeVM::new(r"\W")?;///     re1.find_iter(&mut cache, "Δ").next(),/// // it with the PikeVM we'd like to use it with.///     re2.find_iter(&mut cache, "☃").next(),/// Returns the total number of patterns compiled into this `PikeVM`./// In the case of a `PikeVM` that contains no patterns, this returns `0`./// This example shows the pattern length for a `PikeVM` that never/// matches:/// And another example for a `PikeVM` that matches at every position:/// And finally, a `PikeVM` that was constructed from multiple patterns:/// let re = PikeVM::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;/// Return the config for this `PikeVM`./// Returns true if and only if this `PikeVM` matches the given haystack./// underlying NFA enters a match state, then this routine will return/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Input};/// let re = PikeVM::new("a*")?;/// use regex_automata::{nfa::thompson::{pikevm::PikeVM, NFA}, Input};/// individual spans of each capturing group, use [`PikeVM::captures`]./// let re = PikeVM::new("foo[0-9]+")?;/// let re = PikeVM::new("abc|a")?;/// let re = PikeVM::new(r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$")?;/// re.captures(&mut cache, "2010-03-14", &mut caps);/// This yields the same matches as [`PikeVM::find_iter`], but it includes/// let re = PikeVM::new("foo(?P<numbers>[0-9]+)")?;///     .captures_iter(&mut cache, text)/// This is like [`PikeVM::captures`], but it accepts a concrete `&Input`/// This example shows how to build a multi-PikeVM that permits searching/// let re = PikeVM::new_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;/// re.search(&mut cache, &Input::new(haystack), &mut caps);/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match, Input};/// let re = PikeVM::new(r"\b[0-9]{3}\b")?;/// re.search(&mut cache, &Input::new(&haystack[3..6]), &mut caps);/// This is like [`PikeVM::search`], but it accepts a raw slots slice/// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID, Input};/// let re = PikeVM::new_many(&[/// let pid = re.search_slots(&mut cache, &input, &mut slots);search_slots_imp/// This is the actual implementation of `search_slots_imp` that/// position and this `PikeVM` was configured with [`MatchKind::All`]/// Unless all of the patterns in this `PikeVM` are anchored, then/// generally speaking, this will visit every byte in the haystack.///     .configure(PikeVM::config().match_kind(MatchKind::All))/// re.which_overlapping_matches(&mut cache, &input, &mut patset);/// The implementation of standard leftmost search./// Capturing group spans are written to `slots`, but only if requested./// `slots` can be any length. Any slot in the NFA that is activated but/// which is out of bounds for the given `slots` is ignored.which_overlapping_imp/// The implementation for the 'which_overlapping_matches' API. Basically,/// we do a single scan through the entire haystack (unless our regex/// or search is anchored) and record every pattern that matched. In/// particular, when MatchKind::All is used, this supports overlapping/// matches. So if we have the regexes 'sam' and 'samwise', they will/// *both* be reported in the pattern set when searching the haystack/// 'samwise'.FollowEpsilonActiveStates/// Process the active states in 'curr' to find the states (written to/// 'next') we should process for the next byte in the haystack./// 'stack' is used to perform a depth first traversal of the NFA when/// computing an epsilon closure./// When a match is found, the slots for that match state (in 'curr') are/// copied to 'caps'. Moreover, once a match is seen, processing for 'curr'/// stops (unless the PikeVM was configured with MatchKind::All semantics).nexts_overlapping/// Like 'nexts', but for the overlapping case. This doesn't write any/// slots, and instead just writes which pattern matched in 'patset'.SlotTable/// Starting from 'sid', if the position 'at' in the 'input' haystack has a/// transition defined out of 'sid', then add the state transitioned to and/// its epsilon closure to the 'next' set of states to explore./// 'stack' is used by the epsilon closure computation to perform a depth/// first traversal of the NFA./// 'curr_slot_table' should be the table of slots for the current set of/// states being explored. If there is a transition out of 'sid', then/// sid's row in the slot table is used to perform the epsilon closure.epsilon_closure/// Compute the epsilon closure of 'sid', writing the closure into 'next'/// while copying slot values from 'curr_slots' into corresponding states/// in 'next'. 'curr_slots' should be the slot values corresponding to/// 'sid'./// The given 'stack' is used to perform a depth first traversal of the/// NFA by recursively following all epsilon transitions out of 'sid'./// Conditional epsilon transitions are followed if and only if they are/// satisfied for the position 'at' in the 'input' haystack./// While this routine may write to 'curr_slots', once it returns, any/// writes are undone and the original values (even if absent) are/// restored.epsilon_closure_explore/// Explore all of the epsilon transitions out of 'sid'. This is mostly/// split out from 'epsilon_closure' in order to clearly delineate/// the actual work of computing an epsilon closure from the stack/// book-keeping./// This will push any additional explorations needed on to 'stack'./// 'curr_slots' should refer to the slots for the currently active NFA/// state. That is, the current state we are stepping through. These/// slots are mutated in place as new 'Captures' states are traversed/// during epsilon closure, but the slots are restored to their original/// values once the full epsilon closure is completed. The ultimate use of/// 'curr_slots' is to copy them to the corresponding 'next_slots', so that/// the capturing group spans are forwarded from the currently active state/// to the next./// 'next' refers to the next set of active states. Computing an epsilon/// closure may increase the next set of active states./// 'input' refers to the caller's input configuration and 'at' refers to/// the current position in the haystack. These are used to check whether/// conditional epsilon transitions (like look-around) are satisfied at/// the current position. If they aren't, then the epsilon closure won't/// include them.start_config/// Return the starting configuration of a PikeVM search./// The "start config" is basically whether the search should be anchored/// or not and the NFA state ID at which to begin the search. The state ID/// returned always corresponds to an anchored starting state even when the/// search is unanchored. This is because the PikeVM search loop deals with/// unanchored searches with an explicit epsilon closure out of the start/// This routine accounts for both the caller's `Input` configuration/// and the pattern itself. For example, even if the caller asks for an/// unanchored search, if the pattern itself is anchored, then this will/// always return 'true' because implementing an unanchored search in that/// case would be incorrect./// Similarly, if the caller requests an anchored search for a particular/// pattern, then the starting state ID returned will reflect that./// If a pattern ID is given in the input configuration that is not in/// this regex, then `None` is returned./// An iterator over all non-overlapping matches for a particular search./// * `'r` represents the lifetime of the PikeVM./// * `'c` represents the lifetime of the PikeVM's cache./// This iterator can be created with the [`PikeVM::find_iter`] method./// groups, for a particular search./// This iterator can be created with the [`PikeVM::captures_iter`] method./// Stack used while computing epsilon closure. This effectively lets us/// move what is more naturally expressed through recursion to a stack/// on the heap./// The current active states being explored for the current byte in the/// The next set of states we're building that will be explored for the/// next byte in the haystack./// A cache represents mutable state that a [`PikeVM`] requires during a/// For a given [`PikeVM`], its corresponding cache may be created either via/// [`PikeVM::create_cache`], or via [`Cache::new`]. They are equivalent in/// every way, except the former does not require explicitly importing `Cache`./// A particular `Cache` is coupled with the [`PikeVM`] from which it/// was created. It may only be used with that `PikeVM`. A cache and its/// only be used with the new `PikeVM` (and not the old one)./// Create a new [`PikeVM`] cache./// [`PikeVM::create_cache`], as it does not require also importing the/// If you want to reuse the returned `Cache` with some other `PikeVM`,/// then you must call [`Cache::reset`] with the desired `PikeVM`./// different [`PikeVM`]./// in the PikeVM./// The set of active NFA states. This set preserves insertion order, which/// is critical for simulating the match semantics of backtracking regex/// engines.slot_table/// The slots for every NFA state, where each slot stores a (possibly/// absent) offset. Every capturing group has two slots. One for a start/// offset and one for an end offset./// A set of active states used to "simulate" the execution of an NFA via the/// PikeVM./// There are two sets of these used during NFA simulation. One set corresponds/// to the "current" set of states being traversed for the current position/// in a haystack. The other set corresponds to the "next" set of states being/// built, which will become the new "current" set for the next position in the/// haystack. These two sets correspond to CLIST and NLIST in Thompson's/// original paper regexes: https://dl.acm.org/doi/pdf/10.1145/363347.363387/// In addition to representing a set of NFA states, this also maintains slot/// values for each state. These slot values are what turn the NFA simulation/// into the "Pike VM." Namely, they track capturing group values for each/// state. During the computation of epsilon closure, we copy slot values from/// states in the "current" set to the "next" set. Eventually, once a match/// is found, the slot values for that match state are what we write to the/// caller provided 'Captures' value./// Create a new set of active states for the given PikeVM. The active/// states returned may only be used with the given PikeVM. (Use 'reset'/// to re-purpose the allocation for a different PikeVM.)/// Reset this set of active states such that it can be used with the given/// PikeVM (and only that PikeVM)./// Return the heap memory usage, in bytes, used by this set of active/// This does not include the stack size of this value./// Setup this set of active states for a new search. The given slot/// length should be the number of slots in a caller provided 'Captures'/// (and may be zero)./// The actual table of offsets.slots_per_state/// The number of slots per state, i.e., the table's stride or the length/// of each row.slots_for_captures/// current search. Setting this to 'slots_per_state' is always correct,/// but may be wasteful./// A table of slots, where each row represent a state in an NFA. Thus, the/// table has room for storing slots for every single state in an NFA./// This table is represented with a single contiguous allocation. In general,/// the notion of "capturing group" doesn't really exist at this level of/// abstraction, hence the name "slot" instead. (Indeed, every capturing group/// maps to a pair of slots, one for the start offset and one for the end/// offset.) Slots are indexed by the 'Captures' NFA state./// N.B. Not every state actually needs a row of slots. Namely, states that/// only have epsilon transitions currently never have anything written to/// their rows in this table. Thus, the table is somewhat wasteful in its heap/// usage. However, it is important to maintain fast random access by state/// ID, which means one giant table tends to work well. RE2 takes a different/// approach here and allocates each row as its own reference counted thing./// I explored such a strategy at one point here, but couldn't get it to work/// well using entirely safe code. (To the ambitious reader: I encourage you to/// re-litigate that experiment.) I very much wanted to stick to safe code, but/// could be convinced otherwise if there was a solid argument and the safety/// was encapsulated well./// Create a new slot table./// One should call 'reset' with the corresponding PikeVM before use./// Reset this slot table such that it can be used with the given PikeVM/// (and only that PikeVM)./// Return the heap memory usage, in bytes, used by this slot table./// Perform any per-search setup for this slot table./// In particular, this sets the length of the number of slots used in the/// 'Captures' given by the caller (if any at all). This number may be/// smaller than the total number of slots available, e.g., when the caller/// is only interested in tracking the overall match and not the spans of/// every matching capturing group. Only tracking the overall match can/// save a substantial amount of time copying capturing spans during afor_state/// Return a mutable slice of the slots for the given state./// Note that the length of the slice returned may be less than the total/// number of slots available for this state. In particular, the length/// always matches the number of slots indicated via 'setup_search'.all_absent/// Return a slice of slots of appropriate length where every slot offset/// is guaranteed to be absent. This is useful in cases where you need to/// compute an epsilon closure outside of the user supplied regex, and thus/// never want it to have any capturing slots set.Explore/// Explore the epsilon transitions from a state ID./// Represents a stack frame for use while computing an epsilon closure./// (An "epsilon closure" refers to the set of reachable NFA states from a/// single state without consuming any input. That is, the set of all epsilon/// transitions not only from that single state, but from every other state/// reachable by an epsilon transition as well. This is why it's called a/// "closure." Computing an epsilon closure is also done during DFA/// determinization! Compare and contrast the epsilon closure here in this/// PikeVM and the one used for determinization in crate::util::determinize.)/// Computing the epsilon closure in a Thompson NFA proceeds via a depth/// first traversal over all epsilon transitions from a particular state./// (A depth first traversal is important because it emulates the same priority/// of matches that is typically found in backtracking regex engines.) This/// depth first traversal is naturally expressed using recursion, but to avoid/// a call stack size proportional to the size of a regex, we put our stack on/// the heap instead./// This stack thus consists of call frames. The typical call frame is/// `Explore`, which instructs epsilon closure to explore the epsilon/// transitions from that state. (Subsequent epsilon transitions are then/// pushed on to the stack as more `Explore` frames.) If the state ID being/// explored has no epsilon transitions, then the capturing group slots are/// copied from the original state that sparked the epsilon closure (from the/// 'step' routine) to the state ID being explored. This way, capturing group/// slots are forwarded from the previous state to the next./// The other stack frame, `RestoreCaptures`, instructs the epsilon closure to/// set the position for a particular slot back to some particular offset. This/// frame is pushed when `Explore` sees a `Capture` transition. `Explore` will/// set the offset of the slot indicated in `Capture` to the current offset,/// and then push the old offset on to the stack as a `RestoreCapture` frame./// Thus, the new offset is only used until the epsilon closure reverts back to/// the `RestoreCapture` frame. In effect, this gives the `Capture` epsilon/// transition its "scope" to only states that come "after" it during depth/// first traversal./*!
An NFA backed Pike VM for executing regex searches with capturing groups.

This module provides a [`PikeVM`] that works by simulating an NFA and
resolving all spans of capturing groups that participate in a match.
*/FINAL/// There is only one final state in this trie. Every sequence of byte ranges/// added shares the same final state./// The root state of the trie./// The states in this trie. The first is always the shared final state./// The second is always the root state. Otherwise, there is no/// A free-list of states. When a range trie is cleared, all of its states/// are added to this list. Creating a new state reuses states from this/// list before allocating a new one.iter_stackNextIter/// A stack for traversing this trie to yield sequences of byte ranges in/// lexicographic order.iter_ranges/// A buffer that stores the current sequence during iteration.dupe_stackNextDupe/// A stack used for traversing the trie in order to (deeply) duplicate/// a state. States are recursively duplicated when ranges are split.insert_stackNextInsert/// A stack used for traversing the trie during insertion of a new/// sequence of byte ranges./// A range trie represents an ordered set of sequences of bytes./// A range trie accepts as input a sequence of byte ranges and merges/// them into the existing set such that the trie can produce a sorted/// non-overlapping sequence of byte ranges. The sequence emitted corresponds/// precisely to the sequence of bytes matched by the given keys, although the/// byte ranges themselves may be split at different boundaries./// The order complexity of this data structure seems difficult to analyze./// If the size of a byte is held as a constant, then insertion is clearly/// O(n) where n is the number of byte ranges in the input key. However, if/// k=256 is our alphabet size, then insertion could be O(k^2 * n). In/// particular it seems possible for pathological inputs to cause insertion/// to do a lot of work. However, for what we use this data structure for,/// there should be no pathological inputs since the ultimate source is always/// a sorted set of Unicode scalar value ranges./// Internally, this trie is setup like a finite state machine. Note though/// that it is acyclic./// A sorted sequence of non-overlapping transitions to other states. Each/// transition corresponds to a single range of bytes./// A single state in this trie./// The byte range./// The next state to transition to./// A transition is a single range of bytes. If a particular byte is in this/// range, then the corresponding machine may transition to the state pointed/// to by `next_id`./// Create a new empty range trie./// Clear this range trie such that it is empty. Clearing a range trie/// and reusing it can beneficial because this may reuse allocations./// Iterate over all of the sequences of byte ranges in this trie, and/// call the provided function for each sequence. Iteration occurs in/// Inserts a new sequence of ranges into this trie./// The sequence given must be non-empty and must not have a length/// exceeding 4./// Performs a deep clone of the given state and returns the duplicate's/// A "deep clone" in this context means that the state given along with/// recursively all states that it points to are copied. Once complete,/// the given state ID and the returned state ID share nothing./// This is useful during range trie insertion when a new range overlaps/// with an existing range that is bigger than the new one. The part/// of the existing range that does *not* overlap with the new one is/// duplicated so that adding the new range to the overlap doesn't disturb/// the non-overlapping portion./// There's one exception: if old_id is the final state, then it is not/// duplicated and the same final state is returned. This is because all/// final states in this trie are equivalent./// Adds the given transition to the given state./// Callers must ensure that all previous transitions in this state/// are lexicographically smaller than the given range.add_transition_at/// Like `add_transition`, except this inserts the transition just before/// the ith transition.set_transition_at/// Overwrites the transition at position i with the given transition./// Return an immutable borrow for the state with the given ID./// Return a mutable borrow for the state with the given ID./// Find the position at which the given range should be inserted in this/// The position returned is always in the inclusive range/// [0, transitions.len()]. If 'transitions.len()' is returned, then the/// given range overlaps with no other range in this state *and* is greater/// than all of them./// For all other possible positions, the given range either overlaps/// with the transition at that position or is otherwise less than it/// with no overlap (and is greater than the previous transition). In the/// former case, careful attention must be paid to inserting this range/// as a new transition. In the latter case, the range can be inserted as/// a new transition at the given position without disrupting any other/// Clear this state such that it has zero transitions.old_id/// The state we want to duplicate./// The ID of the new state that is a duplicate of old_id./// The next state to process during duplication.tidx/// The next state (and its corresponding transition) that we want to visit/// during iteration in lexicographic order./// The next state to begin inserting ranges. This state should be the/// state at which `ranges[0]` should be inserted./// The ranges to insert. We used a fixed-size array here to avoid an/// allocation./// The number of valid ranges in the above array./// The next state to process during insertion and any remaining ranges that we/// want to add for a particular sequence of ranges. The first such instance/// is always the root state along with all ranges given./// Create the next item to visit. The given state ID should correspond/// to the state at which the first range in the given slice should be/// inserted. The slice given must not be empty and it must be no longer/// than 4./// Push a new empty state to visit along with any remaining ranges that/// still need to be inserted. The ID of the new empty state is returned./// If ranges is empty, then no new state is created and FINAL is returned./// Return the ID of the state to visit./// Return the remaining ranges to insert.SplitRange/// Split represents a partitioning of two ranges into one or more ranges. This/// is the secret sauce that makes a range trie work, as it's what tells us/// how to deal with two overlapping but unequal ranges during insertion./// Essentially, either two ranges overlap or they don't. If they don't, then/// handling insertion is easy: just insert the new range into its/// lexicographically correct position. Since it does not overlap with anything/// else, no other transitions are impacted by the new range./// If they do overlap though, there are generally three possible cases to/// handle:/// 1. The part where the two ranges actually overlap. i.e., The intersection./// 2. The part of the existing range that is not in the new range./// 3. The part of the new range that is not in the old range./// (1) is guaranteed to always occur since all overlapping ranges have a/// non-empty intersection. If the two ranges are not equivalent, then at/// least one of (2) or (3) is guaranteed to occur as well. In some cases,/// e.g., `[0-4]` and `[4-9]`, all three cases will occur./// This `Split` type is responsible for providing (1), (2) and (3) for any/// possible pair of byte ranges./// As for insertion, for the overlap in (1), the remaining ranges to insert/// should be added by following the corresponding transition. However, this/// should only be done for the overlapping parts of the range. If there was/// a part of the existing range that was not in the new range, then that/// existing part must be split off from the transition and duplicated. The/// remaining parts of the overlap can then be added to using the new ranges/// without disturbing the existing range./// Handling the case for the part of a new range that is not in an existing/// range is seemingly easy. Just treat it as if it were a non-overlapping/// range. The problem here is that if this new non-overlapping range occurs/// after both (1) and (2), then it's possible that it can overlap with the/// next transition in the current state. If it does, then the whole process/// must be repeated!/// # Details of the 3 cases/// The following details the various cases that are implemented in code/// below. It's plausible that the number of cases is not actually minimal,/// but it's important for this code to remain at least somewhat readable./// Given [a,b] and [x,y], where a <= b, x <= y, b < 256 and y < 256, we define/// the follow distinct relationships where at least one must apply. The order/// of these matters, since multiple can match. The first to match applies.///   1. b < x <=> [a,b] < [x,y]///   2. y < a <=> [x,y] < [a,b]/// In the case of (1) and (2), these are the only cases where there is no/// overlap. Or otherwise, the intersection of [a,b] and [x,y] is empty. In/// order to compute the intersection, one can do [max(a,x), min(b,y)]. The/// intersection in all of the following cases is non-empty.///    3. a = x && b = y <=> [a,b] == [x,y]///    4. a = x && b < y <=> [x,y] right-extends [a,b]///    5. b = y && a > x <=> [x,y] left-extends [a,b]///    6. x = a && y < b <=> [a,b] right-extends [x,y]///    7. y = b && x > a <=> [a,b] left-extends [x,y]///    8. a > x && b < y <=> [x,y] covers [a,b]///    9. x > a && y < b <=> [a,b] covers [x,y]///   10. b = x && a < y <=> [a,b] is left-adjacent to [x,y]///   11. y = a && x < b <=> [x,y] is left-adjacent to [a,b]///   12. b > x && b < y <=> [a,b] left-overlaps [x,y]///   13. y > a && y < b <=> [x,y] left-overlaps [a,b]/// In cases 3-13, we can form rules that partition the ranges into a/// non-overlapping ordered sequence of ranges:///    3. [a,b]///    4. [a,b], [b+1,y]///    5. [x,a-1], [a,b]///    6. [x,y], [y+1,b]///    7. [a,x-1], [x,y]///    8. [x,a-1], [a,b], [b+1,y]///    9. [a,x-1], [x,y], [y+1,b]///   10. [a,b-1], [b,b], [b+1,y]///   11. [x,y-1], [y,y], [y+1,b]///   12. [a,x-1], [x,b], [b+1,y]///   13. [x,a-1], [a,y], [y+1,b]/// In the code below, we go a step further and identify each of the above/// outputs as belonging either to the overlap of the two ranges or to one/// of [a,b] or [x,y] exclusively./// A tagged range indicating how it was derived from a pair of ranges./// Create a partitioning of the given ranges./// If the given ranges have an empty intersection, then None is returned.parts1/// Create a new split with a single partition. This only occurs when two/// ranges are equivalent.parts2/// Create a new split with two partitions.parts3/// Create a new split with three partitions./// Return the partitions in this split as a slice./// Returns true if and only if the given ranges intersect.split_maybeno_splits// Arguably there should be more tests here, but in practice, this data// structure is well covered by the huge number of regex tests./*
I've called the primary data structure in this module a "range trie." As far
as I can tell, there is no prior art on a data structure like this, however,
it's likely someone somewhere has built something like it. Searching for
"range trie" turns up the paper "Range Tries for Scalable Address Lookup,"
but it does not appear relevant.

The range trie is just like a trie in that it is a special case of a
deterministic finite state machine. It has states and each state has a set
of transitions to other states. It is acyclic, and, like a normal trie,
it makes no attempt to reuse common suffixes among its elements. The key
difference between a normal trie and a range trie below is that a range trie
operates on *contiguous sequences* of bytes instead of singleton bytes.
One could say say that our alphabet is ranges of bytes instead of bytes
themselves, except a key part of range trie construction is splitting ranges
apart to ensure there is at most one transition that can be taken for any
byte in a given state.

I've tried to explain the details of how the range trie works below, so
for now, we are left with trying to understand what problem we're trying to
solve. Which is itself fairly involved!

At the highest level, here's what we want to do. We want to convert a
sequence of Unicode codepoints into a finite state machine whose transitions
are over *bytes* and *not* Unicode codepoints. We want this because it makes
said finite state machines much smaller and much faster to execute. As a
simple example, consider a byte oriented automaton for all Unicode scalar
values (0x00 through 0x10FFFF, not including surrogate codepoints):

    [00-7F]
    [C2-DF][80-BF]
    [E0-E0][A0-BF][80-BF]
    [E1-EC][80-BF][80-BF]
    [ED-ED][80-9F][80-BF]
    [EE-EF][80-BF][80-BF]
    [F0-F0][90-BF][80-BF][80-BF]
    [F1-F3][80-BF][80-BF][80-BF]
    [F4-F4][80-8F][80-BF][80-BF]

(These byte ranges are generated via the regex-syntax::utf8 module, which
was based on Russ Cox's code in RE2, which was in turn based on Ken
Thompson's implementation of the same idea in his Plan9 implementation of
grep.)

It should be fairly straight-forward to see how one could compile this into
a DFA. The sequences are sorted and non-overlapping. Essentially, you could
build a trie from this fairly easy. The problem comes when your initial
range (in this case, 0x00-0x10FFFF) isn't so nice. For example, the class
represented by '\w' contains only a tenth of the codepoints that
0x00-0x10FFFF contains, but if we were to write out the byte based ranges
as we did above, the list would stretch to 892 entries! This turns into
quite a large NFA with a few thousand states. Turning this beast into a DFA
takes quite a bit of time. We are thus left with trying to trim down the
number of states we produce as early as possible.

One approach (used by RE2 and still by the regex crate, at time of writing)
is to try to find common suffixes while building NFA states for the above
and reuse them. This is very cheap to do and one can control precisely how
much extra memory you want to use for the cache.

Another approach, however, is to reuse an algorithm for constructing a
*minimal* DFA from a sorted sequence of inputs. I don't want to go into
the full details here, but I explain it in more depth in my blog post on
FSTs[1]. Note that the algorithm was not invented by me, but was published
in paper by Daciuk et al. in 2000 called "Incremental Construction of
MinimalAcyclic Finite-State Automata." Like the suffix cache approach above,
it is also possible to control the amount of extra memory one uses, although
this usually comes with the cost of sacrificing true minimality. (But it's
typically close enough with a reasonably sized cache of states.)

The catch is that Daciuk's algorithm only works if you add your keys in
lexicographic ascending order. In our case, since we're dealing with ranges,
we also need the additional requirement that ranges are either equivalent
or do not overlap at all. For example, if one were given the following byte
ranges:

    [BC-BF][80-BF]
    [BC-BF][90-BF]

Then Daciuk's algorithm would not work, since there is nothing to handle the
fact that the ranges overlap. They would need to be split apart. Thankfully,
Thompson's algorithm for producing byte ranges for Unicode codepoint ranges
meets both of our requirements. (A proof for this eludes me, but it appears
true.)

... however, we would also like to be able to compile UTF-8 automata in
reverse. We want this because in order to find the starting location of a
match using a DFA, we need to run a second DFA---a reversed version of the
forward DFA---backwards to discover the match location. Unfortunately, if
we reverse our byte sequences for 0x00-0x10FFFF, we get sequences that are
can overlap, even if they are sorted:

    [00-7F]
    [80-BF][80-9F][ED-ED]
    [80-BF][80-BF][80-8F][F4-F4]
    [80-BF][80-BF][80-BF][F1-F3]
    [80-BF][80-BF][90-BF][F0-F0]
    [80-BF][80-BF][E1-EC]
    [80-BF][80-BF][EE-EF]
    [80-BF][A0-BF][E0-E0]
    [80-BF][C2-DF]

For example, '[80-BF][80-BF][EE-EF]' and '[80-BF][A0-BF][E0-E0]' have
overlapping ranges between '[80-BF]' and '[A0-BF]'. Thus, there is no
simple way to apply Daciuk's algorithm.

And thus, the range trie was born. The range trie's only purpose is to take
sequences of byte ranges like the ones above, collect them into a trie and then
spit them out in a sorted fashion with no overlapping ranges. For example,
0x00-0x10FFFF gets translated to:

    [0-7F]
    [80-BF][80-9F][80-8F][F1-F3]
    [80-BF][80-9F][80-8F][F4]
    [80-BF][80-9F][90-BF][F0]
    [80-BF][80-9F][90-BF][F1-F3]
    [80-BF][80-9F][E1-EC]
    [80-BF][80-9F][ED]
    [80-BF][80-9F][EE-EF]
    [80-BF][A0-BF][80-8F][F1-F3]
    [80-BF][A0-BF][80-8F][F4]
    [80-BF][A0-BF][90-BF][F0]
    [80-BF][A0-BF][90-BF][F1-F3]
    [80-BF][A0-BF][E0]
    [80-BF][A0-BF][E1-EC]
    [80-BF][A0-BF][EE-EF]
    [80-BF][C2-DF]

We've thus satisfied our requirements for running Daciuk's algorithm. All
sequences of ranges are sorted, and any corresponding ranges are either
exactly equivalent or non-overlapping.

In effect, a range trie is building a DFA from a sequence of arbitrary byte
ranges. But it uses an algorithm custom tailored to its input, so it is not as
costly as traditional DFA construction. While it is still quite a bit more
costly than the forward case (which only needs Daciuk's algorithm), it winds
up saving a substantial amount of time if one is doing a full DFA powerset
construction later by virtue of producing a much much smaller NFA.

[1] - https://blog.burntsushi.net/transducers/
[2] - https://www.mitpressjournals.org/doi/pdfplus/10.1162/089120100561601
*/UnitKind/// Unit represents a single unit of haystack for DFA based regex engines./// It is not expected for consumers of this crate to need to use this type/// unless they are implementing their own DFA. And even then, it's not/// required: implementors may use other techniques to handle haystack units./// Typically, a single unit of haystack for a DFA would be a single byte./// However, for the DFAs in this crate, matches are delayed by a single byte/// in order to handle look-ahead assertions (`\b`, `$` and `\z`). Thus, once/// we have consumed the haystack, we must run the DFA through one additional/// transition using a unit that indicates the haystack has ended./// There is no way to represent a sentinel with a `u8` since all possible/// values *may* be valid haystack units to a DFA, therefore this type/// explicitly adds room for a sentinel value./// The sentinel EOI value is always its own equivalence class and is/// ultimately represented by adding 1 to the maximum equivalence class value./// So for example, the regex `^[a-z]+$` might be split into the following/// equivalence classes:/// 0 => [\x00-`]/// 1 => [a-z]/// 2 => [{-\xFF]/// 3 => [EOI]/// Where EOI is the special sentinel value that is always in its own/// singleton equivalence class./// Represents a byte value, or more typically, an equivalence class/// represented as a byte value./// Represents the "end of input" sentinel. We regretably use a `u16`/// here since the maximum sentinel value is `256`. Thankfully, we don't/// actually store a `Unit` anywhere, so this extra space shouldn't be too/// bad./// Create a new haystack unit from a byte value./// All possible byte values are legal. However, when creating a haystack/// unit for a specific DFA, one should be careful to only construct units/// that are in that DFA's alphabet. Namely, one way to compact a DFA's/// in-memory representation is to collapse its transitions to a set of/// equivalence classes into a set of all possible byte values. If a DFA/// uses equivalence classes instead of byte values, then the byte given/// here should be the equivalence class.eoi/// Create a new "end of input" haystack unit./// The value given is the sentinel value used by this unit to represent/// the "end of input." The value should be the total number of equivalence/// classes in the corresponding alphabet. Its maximum value is `256`,/// which occurs when every byte is its own equivalence class./// This panics when `num_byte_equiv_classes` is greater than `256`./// If this unit is not an "end of input" sentinel, then returns its/// underlying byte value. Otherwise return `None`.as_eoi/// If this unit is an "end of input" sentinel, then return the underlying/// sentinel value that was given to [`Unit::eoi`]. Otherwise return/// Return this unit as a `usize`, regardless of whether it is a byte value/// or an "end of input" sentinel. In the latter case, the underlying/// sentinel value given to [`Unit::eoi`] is returned.is_byte/// Returns true if and only of this unit is a byte value equivalent to the/// byte given. This always returns false when this is an "end of input"/// sentinel.is_eoi/// Returns true when this unit represents an "end of input" sentinel.is_word_byte/// Returns true when this unit corresponds to an ASCII word byte./// This always returns false when this unit represents an "end of input"/// This is used in a DFA to reduce the size of the transition table. This can/// have a particularly large impact not only on the total size of a dense DFA,/// but also on compile times./// The essential idea here is that the alphabet of a DFA is shrunk from the/// usual 256 distinct byte values down to a set of equivalence classes. The/// guarantee you get is that any byte belonging to the same equivalence class/// can be treated as if it were any other byte in the same class, and the/// result of a search wouldn't change./// This example shows how to get byte classes from an/// [`NFA`](crate::nfa::thompson::NFA) and ask for the class of various bytes./// Deserializes a byte class map from the given slice. If the slice is of/// insufficient length or otherwise contains an impossible mapping, then/// an error is returned. Upon success, the number of bytes read along with/// the map are returned. The number of bytes read is always a multiple of/// 8./// Writes this byte class map to the given byte buffer. if the given/// buffer is too small, then an error is returned. Upon success, the total/// number of bytes written is returned. The number of bytes written is/// guaranteed to be a multiple of 8.get_by_unit/// Get the equivalence class for the given haystack unit and return the/// class as a `usize`./// Create a unit that represents the "end of input" sentinel based on the/// number of equivalence classes./// equal to the alphabet length, and the `stride2` returned here is the/// exponent applied to `2` to get the smallest power. This is done so that/// converting between premultiplied state IDs and indices can be done with/// shifts alone, which is much faster than integer division./// and each class contains either exactly one byte or corresponds to the/// singleton class containing the "end of input" sentinel.representativesByteClassRepresentatives/// Returns an iterator over a sequence of representative bytes from each/// equivalence class within the range of bytes given./// When the given range is unbounded on both sides, the iterator yields/// exactly N items, where N is equivalent to the number of equivalence/// classes. Each item is an arbitrary byte drawn from each equivalence/// class./// This is useful when one is determinizing an NFA and the NFA's alphabet/// hasn't been converted to equivalence classes. Picking an arbitrary byte/// from each equivalence class then permits a full exploration of the NFA/// instead of using every possible byte value and thus potentially saves/// quite a lot of redundant work./// This shows an example of what a complete sequence of representatives/// might look like from a real example./// use regex_automata::{nfa::thompson::NFA, util::alphabet::Unit};/// let reps: Vec<Unit> = classes.representatives(..).collect();/// // Note that the specific byte values yielded are not guaranteed!///     Unit::u8(b'\x00'),///     Unit::u8(b'a'),///     Unit::u8(b'{'),///     Unit::eoi(3),/// assert_eq!(expected, reps);/// Note though, that you can ask for an arbitrary range of bytes, and only/// representatives for that range will be returned:/// let reps: Vec<Unit> = classes.representatives(b'A'..=b'z').collect();///     Unit::u8(b'A'),/// This is useful when one needs to know the actual bytes that belong to/// an equivalence class. For example, conceptually speaking, accelerating/// a DFA state occurs when a state only has a few outgoing transitions./// But in reality, what is required is that there are only a small/// number of distinct bytes that can lead to an outgoing transition. The/// difference is that any one transition can correspond to an equivalence/// class which may contains many bytes. Therefore, DFA state acceleration/// considers the actual elements in each equivalence class of each/// outgoing transition./// This shows an example of how to get all of the elements in an/// let elements: Vec<Unit> = classes.elements(Unit::u8(1)).collect();/// let expected: Vec<Unit> = (b'a'..=b'z').map(Unit::u8).collect();/// assert_eq!(expected, elements);/// The last element in this iterator always corresponds to [`Unit::eoi`]./// This is created by the [`ByteClasses::iter`] method./// The lifetime `'a` refers to the lifetime of the byte classes that this/// iterator was created from.cur_byteend_bytelast_class/// An iterator over representative bytes from each equivalence class./// This is created by the [`ByteClasses::representatives`] method./// An iterator over all elements in an equivalence class./// This is created by the [`ByteClasses::elements`] method./// For example, in the regex `[ab]+`, the bytes `a` and `b` would be in the/// same equivalence class because it never matters whether an `a` or a `b` is/// seen, and no combination of `a`s and `b`s in the text can discriminate a/// Note though that this does not compute the minimal set of equivalence/// classes. For example, in the regex `[ac]+`, both `a` and `c` are in the/// same equivalence class for the same reason that `a` and `b` are in the/// same equivalence class in the aforementioned regex. However, in this/// implementation, `a` and `c` are put into distinct equivalence classes. The/// reason for this is implementation complexity. In the future, we should/// endeavor to compute the minimal equivalence classes since they can have a/// rather large impact on the size of the DFA. (Doing this will likely require/// rethinking how equivalence classes are computed, including changing the/// representation here, which is only able to group contiguous bytes into the/// same equivalence class.)/// Indicate the range of byte given (inclusive) can discriminate aadd_set/// Add the contiguous ranges in the set given to this byte class set./// Remove a byte from this set./// If the given byte is not in this set, then this is a no-op.contains_range/// Return true if and only if the given inclusive range of bytes is in/// this set.ByteSetIter/// Returns an iterator over all bytes in this set.ByteSetRangeIter/// Returns an iterator over all contiguous ranges of bytes in this set./// Return true if and only if this set is empty./// Deserializes a byte set from the given slice. If the slice is of/// incorrect length or is otherwise malformed, then an error is returned./// Upon success, the number of bytes read along with the set are returned./// The number of bytes read is always a multiple of 8./// Writes this byte set to the given byte buffer. If the given buffer is/// too small, then an error is returned. Upon success, the total number of/// bytes written is returned. The number of bytes written is guaranteed to/// be a multiple of 8./*!
This module provides APIs for dealing with the alphabets of finite state
machines.

There are two principal types in this module, [`ByteClasses`] and [`Unit`].
The former defines the alphabet of a finite state machine while the latter
represents an element of that alphabet.

To a first approximation, the alphabet of all automata in this crate is just
a `u8`. Namely, every distinct byte value. All 256 of them. In practice, this
can be quite wasteful when building a transition table for a DFA, since it
requires storing a state identifier for each element in the alphabet. Instead,
we collapse the alphabet of an automaton down into equivalence classes, where
every byte in the same equivalence class never discriminates between a match or
a non-match from any other byte in the same class. For example, in the regex
`[a-z]+`, then you could consider it having an alphabet consisting of two
equivalence classes: `a-z` and everything else. In terms of the transitions on
an automaton, it doesn't actually require representing every distinct byte.
Just the equivalence classes.

The downside of equivalence classes is that, of course, searching a haystack
deals with individual byte values. Those byte values need to be mapped to
their corresponding equivalence class. This is what `ByteClasses` does. In
practice, doing this for every state transition has negligible impact on modern
CPUs. Moreover, it helps make more efficient use of the CPU cache by (possibly
considerably) shrinking the size of the transition table.

One last hiccup concerns `Unit`. Namely, because of look-around and how the
DFAs in this crate work, we need to add a sentinel value to our alphabet
of equivalence classes that represents the "end" of a search. We call that
sentinel [`Unit::eoi`] or "end of input." Thus, a `Unit` is either an
equivalence class corresponding to a set of bytes, or it is a special "end of
input" sentinel.

In general, you should not expect to need either of these types unless you're
doing lower level shenanigans with DFAs, or even building your own DFAs.
(Although, you don't have to use these types to build your own DFAs of course.)
For example, if you're walking a DFA's state graph, it's probably useful to
make use of [`ByteClasses`] to visit each element in the DFA's alphabet instead
of just visiting every distinct `u8` value. The latter isn't necessarily wrong,
but it could be potentially very wasteful.
*//// The group info that these capture groups are coupled to. This is what/// gives the "convenience" of the `Captures` API. Namely, it provides the/// slot mapping and the name|-->index mapping for capture lookups by name./// The ID of the pattern that matched. Regex engines must set this to/// None when no match occurs./// The slot values, i.e., submatch offsets./// In theory, the smallest sequence of slots would be something like/// `max(groups(pattern) for pattern in regex) * 2`, but instead, we use/// `sum(groups(pattern) for pattern in regex) * 2`. Why?/// Well, the former could be used in theory, because we don't generally/// have any overlapping APIs that involve capturing groups. Therefore,/// there's technically never any need to have slots set for multiple/// patterns. However, this might change some day, in which case, we would/// need to have slots available./// The other reason is that during the execution of some regex engines,/// there exists a point in time where multiple slots for different/// patterns may be written to before knowing which pattern has matched./// Therefore, the regex engines themselves, in order to support multiple/// patterns correctly, must have all slots available. If `Captures`/// doesn't have all slots available, then regex engines can't write/// directly into the caller provided `Captures` and must instead write/// into some other storage and then copy the slots involved in the match/// at the end of the search./// So overall, at least as of the time of writing, it seems like the path/// of least resistance is to just require allocating all possible slots/// instead of the conceptual minimum. Another way to justify this is that/// the most common case is a single pattern, in which case, there is no/// inefficiency here since the 'max' and 'sum' calculations above are/// equivalent in that case./// N.B. The mapping from group index to slot is maintained by `GroupInfo`/// and is considered an API guarantee. See `GroupInfo` for more details on/// that mapping./// N.B. `Option<NonMaxUsize>` has the same size as a `usize`./// The span offsets of capturing groups after a match has been found./// This type represents the output of regex engines that can report the/// offsets at which capturing groups matches or "submatches" occur. For/// example, the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM). When a match/// occurs, it will at minimum contain the [`PatternID`] of the pattern that/// matched. Depending upon how it was constructed, it may also contain the/// start/end offsets of the entire match of the pattern and the start/end/// offsets of each capturing group that participated in the match./// Values of this type are always created for a specific [`GroupInfo`]. It is/// unspecified behavior to use a `Captures` value in a search with any regex/// engine that has a different `GroupInfo` than the one the `Captures` were/// created with./// # Constructors/// There are three constructors for this type that control what kind of/// information is available upon a match:/// * [`Captures::all`]: Will store overall pattern match offsets in addition/// to the offsets of capturing groups that participated in the match./// * [`Captures::matches`]: Will store only the overall pattern/// match offsets. The offsets of capturing groups (even ones that participated/// in the match) are not available./// * [`Captures::empty`]: Will only store the pattern ID that matched. No/// match offsets are available at all./// If you aren't sure which to choose, then pick the first one. The first one/// is what convenience routines like,/// [`PikeVM::create_captures`](crate::nfa::thompson::pikevm::PikeVM::create_captures),/// will use automatically./// The main difference between these choices is performance. Namely, if you/// ask for _less_ information, then the execution of regex search may be able/// to run more quickly./// It is worth pointing out that this type is not coupled to any one specific/// regex engine. Instead, its coupling is with [`GroupInfo`], which is the/// thing that is responsible for mapping capturing groups to "slot" offsets./// Slot offsets are indices into a single sequence of memory at which matching/// haystack offsets for the corresponding group are written by regex engines./// This example shows how to parse a simple date and extract the components of/// the date via capturing groups:/// # Example: named capturing groups/// This example is like the one above, but leverages the ability to name/// capturing groups in order to make the code a bit clearer:/// let re = PikeVM::new(r"^(?P<y>[0-9]{4})-(?P<m>[0-9]{2})-(?P<d>[0-9]{2})$")?;/// assert_eq!(Some(Span::from(0..4)), caps.get_group_by_name("y"));/// assert_eq!(Some(Span::from(5..7)), caps.get_group_by_name("m"));/// assert_eq!(Some(Span::from(8..10)), caps.get_group_by_name("d"));/// Create new storage for the offsets of all matching capturing groups./// This routine provides the most information for matches---namely, the/// spans of matching capturing groups---but also requires the regex search/// routines to do the most work./// It is unspecified behavior to use the returned `Captures` value in a/// search with a `GroupInfo` other than the one that is provided to this/// This example shows that all capturing groups---but only ones that/// participated in a match---are available to query after a match has/// been found:///     Span, Match,/// let re = PikeVM::new(///     r"^(?:(?P<lower>[a-z]+)|(?P<upper>[A-Z]+))(?P<digits>[0-9]+)$",/// let mut caps = Captures::all(re.get_nfa().group_info().clone());/// re.captures(&mut cache, "ABC123", &mut caps);/// // The 'lower' group didn't match, so it won't have any offsets./// assert_eq!(None, caps.get_group_by_name("lower"));/// assert_eq!(Some(Span::from(0..3)), caps.get_group_by_name("upper"));/// assert_eq!(Some(Span::from(3..6)), caps.get_group_by_name("digits"));/// Create new storage for only the full match spans of a pattern. This/// does not include any capturing group offsets./// This example shows that only overall match offsets are reported when/// this constructor is used. Accessing any capturing groups other than/// the 0th will always return `None`./// let mut caps = Captures::matches(re.get_nfa().group_info().clone());/// // We didn't ask for capturing group offsets, so they aren't available./// assert_eq!(None, caps.get_group_by_name("upper"));/// assert_eq!(None, caps.get_group_by_name("digits"));/// Create new storage for only tracking which pattern matched. No offsets/// are stored at all./// This example shows that only the pattern that matched can be accessed/// from a `Captures` value created via this constructor.///     PatternID,/// let re = PikeVM::new_many(&[r"[a-z]+", r"[A-Z]+"])?;/// let mut caps = Captures::empty(re.get_nfa().group_info().clone());/// re.captures(&mut cache, "aABCz", &mut caps);/// assert_eq!(Some(PatternID::must(0)), caps.pattern());/// // We didn't ask for any offsets, so they aren't available./// re.captures(&mut cache, &"aABCz"[1..], &mut caps);/// assert_eq!(Some(PatternID::must(1)), caps.pattern());/// Returns true if and only if this capturing group represents a match./// This is a convenience routine for `caps.pattern().is_some()`./// When using the PikeVM (for example), the lightest weight way of/// detecting whether a match exists is to create capturing groups that/// only track the ID of the pattern that match (if any):/// let re = PikeVM::new(r"[a-z]+")?;/// Returns the identifier of the pattern that matched when this/// capturing group represents a match. If no match was found, then this/// always returns `None`./// This returns a pattern ID in precisely the cases in which `is_match`/// returns `true`. Similarly, the pattern ID returned is always the/// same pattern ID found in the `Match` returned by `get_match`./// detecting which pattern matched is to create capturing groups that only/// track the ID of the pattern that match (if any):/// re.captures(&mut cache, "ABC", &mut caps);/// // Recall that offsets are only available when using a non-empty/// // Captures value. So even though a match occurred, this returns None!/// Returns the pattern ID and the span of the match, if one occurred./// This always returns `None` when `Captures` was created with/// [`Captures::empty`], even if a match was found./// If this routine returns a non-`None` value, then `is_match` is/// guaranteed to return `true` and `pattern` is also guaranteed to return/// a non-`None` value./// This example shows how to get the full match from a search:get_group/// Returns the span of a capturing group match corresponding to the group/// index given, only if both the overall pattern matched and the capturing/// group participated in that match./// This returns `None` if `index` is invalid. `index` is valid if and only/// if it's less than [`Captures::group_len`] for the matching pattern./// [`Captures::empty`], even if a match was found. This also always/// returns `None` for any `index > 0` when `Captures` was created with/// [`Captures::matches`]./// guaranteed to return `true`, `pattern` is guaranteed to return a/// non-`None` value and `get_match` is guaranteed to return a non-`None`/// By convention, the 0th capture group will always return the same/// span as the span returned by `get_match`. This is because the 0th/// capture group always corresponds to the entirety of the pattern's/// match. (It is similarly always unnamed because it is implicit.) This/// isn't necessarily true of all regex engines. For example, one can/// hand-compile a [`thompson::NFA`](crate::nfa::thompson::NFA) via a/// [`thompson::Builder`](crate::nfa::thompson::Builder), which isn't/// technically forced to make the 0th capturing group always correspond to/// the entire match./// This example shows how to get the capturing groups, by index, from a/// match:/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span, Match};/// let re = PikeVM::new(r"^(?P<first>\pL+)\s+(?P<last>\pL+)$")?;/// assert_eq!(Some(Span::from(6..17)), caps.get_group(2));/// // Looking for a non-existent capturing group will return None:/// assert_eq!(None, caps.get_group(3));/// # // literals are too big for 32-bit usize: #1039/// assert_eq!(None, caps.get_group(9944060567225171988));get_group_by_name/// name given, only if both the overall pattern matched and the capturing/// This returns `None` if `name` does not correspond to a valid capturing/// group for the pattern that matched./// This example shows how to get the capturing groups, by name, from a/// assert_eq!(Some(Span::from(0..5)), caps.get_group_by_name("first"));/// assert_eq!(None, caps.get_group_by_name("middle"));/// Returns an iterator of possible spans for every capturing group in the/// matching pattern./// If this `Captures` value does not correspond to a match, then the/// iterator returned yields no elements./// Note that the iterator returned yields elements of type `Option<Span>`./// A span is present if and only if it corresponds to a capturing group/// that participated in a match./// This example shows how to collect all capturing groups:///     // Matches first/last names, with an optional middle name.///     r"^(?P<first>\pL+)\s+(?:(?P<middle>\pL+)\s+)?(?P<last>\pL+)$",/// re.captures(&mut cache, "Harry James Potter", &mut caps);/// let groups: Vec<Option<Span>> = caps.iter().collect();/// assert_eq!(groups, vec![///     Some(Span::from(0..18)),///     Some(Span::from(0..5)),///     Some(Span::from(6..11)),///     Some(Span::from(12..18)),/// This example uses the same regex as the previous example, but with a/// haystack that omits the middle name. This results in a capturing group/// that is present in the elements yielded by the iterator but without a/// re.captures(&mut cache, "Harry Potter", &mut caps);///     Some(Span::from(0..12)),///     Some(Span::from(6..12)),group_len/// Return the total number of capturing groups for the matching pattern./// If this `Captures` value does not correspond to a match, then this/// always returns `0`./// This always returns the same number of elements yielded by/// [`Captures::iter`]. That is, the number includes capturing groups even/// if they don't participate in the match./// This example shows how to count the total number of capturing groups/// associated with a pattern. Notice that it includes groups that did not/// participate in a match (just like `Captures::iter` does)./// assert_eq!(4, caps.group_len());/// Returns a reference to the underlying group info on which these/// captures are based./// The difference between `GroupInfo` and `Captures` is that the former/// defines the structure of capturing groups where as the latter is what/// stores the actual match information. So where as `Captures` only gives/// you access to the current match, `GroupInfo` lets you query any/// information about all capturing groups, even ones for patterns that/// weren't involved in a match./// Note that a `GroupInfo` uses reference counting internally, so it may/// be cloned cheaply./// This example shows how to get all capturing group names from the/// underlying `GroupInfo`. Notice that we don't even need to run a/// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID};///     r"(?P<foo>a)",///     r"(a)(b)",///     r"ab",///     r"(?P<bar>a)(?P<quux>a)",///     r"(?P<foo>z)",/// let caps = re.create_captures();///     (PatternID::must(0), 0, None),///     (PatternID::must(0), 1, Some("foo")),///     (PatternID::must(1), 0, None),///     (PatternID::must(1), 1, None),///     (PatternID::must(1), 2, None),///     (PatternID::must(2), 0, None),///     (PatternID::must(3), 0, None),///     (PatternID::must(3), 1, Some("bar")),///     (PatternID::must(3), 2, Some("quux")),///     (PatternID::must(4), 0, None),///     (PatternID::must(4), 1, Some("foo")),/// // We could also just use 're.get_nfa().group_info()'./// let got: Vec<(PatternID, usize, Option<&str>)> =///     caps.group_info().all_names().collect();interpolate_string/// Interpolates the capture references in `replacement` with the/// corresponding substrings in `haystack` matched by each reference. The/// interpolated string is returned./// See the [`interpolate` module](interpolate) for documentation on the/// format of the replacement string./// This example shows how to use interpolation, and also shows how it/// can work with multi-pattern regexes.///     r"(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})",/// let replacement = "year=$year, month=$month, day=$day";/// // This matches the first pattern./// re.captures(&mut cache, hay, &mut caps);/// let result = caps.interpolate_string(hay, replacement);/// assert_eq!("year=2010, month=03, day=14", result);/// // And this matches the second pattern.interpolate_string_into/// interpolated string is written to `dst`./// caps.interpolate_string_into(hay, replacement, &mut dst);/// assert_eq!("year=2010, month=03, day=14", dst);interpolate_bytes/// interpolated byte string is returned./// let replacement = b"year=$year, month=$month, day=$day";/// let result = caps.interpolate_bytes(hay, replacement);/// assert_eq!(&b"year=2010, month=03, day=14"[..], result);interpolate_bytes_into/// interpolated byte string is written to `dst`./// caps.interpolate_bytes_into(hay, replacement, &mut dst);/// assert_eq!(&b"year=2010, month=03, day=14"[..], dst);/// corresponding to matching capture groups in the given `haystack`. The/// `haystack` should be the same substring used to find the match spans in/// this `Captures` value./// This is identical to [`Captures::extract_bytes`], except it works with/// `&str` instead of `&[u8]`./// This panics if the number of explicit matching groups in this/// `Captures` value is less than `N`. This also panics if this `Captures`/// value does not correspond to a match./// Note that this does *not* panic if the number of explicit matching/// groups is bigger than `N`. In that case, only the first `N` matching/// groups are extracted./// let re = PikeVM::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})")?;/// let (full, [year, month, day]) = caps.extract(hay);/// // We can also ask for fewer than all capture groups./// let (full, [year]) = caps.extract(hay);extract_bytes/// This is identical to [`Captures::extract`], except it works with/// `&[u8]` instead of `&str`./// let (full, [year, month, day]) = caps.extract_bytes(hay);/// let (full, [year]) = caps.extract_bytes(hay);/// Clear this `Captures` value./// After clearing, all slots inside this `Captures` value will be set to/// `None`. Similarly, any pattern ID that it was previously associated/// with (for a match) is erased./// It is not usually necessary to call this routine. Namely, a `Captures`/// value only provides high level access to the capturing groups of the/// pattern that matched, and only low level access to individual slots./// Thus, even if slots corresponding to groups that aren't associated/// with the matching pattern are set, then it won't impact the higher/// level APIs. Namely, higher level APIs like [`Captures::get_group`] will/// return `None` if no pattern ID is present, even if there are spans set/// in the underlying slots./// Thus, to "clear" a `Captures` value of a match, it is usually only/// necessary to call [`Captures::set_pattern`] with `None`./// This example shows what happens when a `Captures` value is cleared./// let slots: Vec<Option<usize>> =///     caps.slots().iter().map(|s| s.map(|x| x.get())).collect();/// // Note that the following ordering is considered an API guarantee./// assert_eq!(slots, vec![///     Some(0),///     Some(17),///     Some(5),///     Some(6),/// // Now clear the slots. Everything is gone and it is no longer a match./// caps.clear();/// Set the pattern on this `Captures` value./// When the pattern ID is `None`, then this `Captures` value does not/// correspond to a match (`is_match` will return `false`). Otherwise, it/// corresponds to a match./// This is useful in search implementations where you might want to/// initially call `set_pattern(None)` in order to avoid the cost of/// calling `clear()` if it turns out to not be necessary./// This example shows that `set_pattern` merely overwrites the pattern ID./// It does not actually change the underlying slot values./// assert!(caps.pattern().is_some());/// // Now set the pattern to None. Note that the slot values remain./// caps.set_pattern(None);/// assert!(!caps.pattern().is_some());/// Returns the underlying slots, where each slot stores a single offset./// Every matching capturing group generally corresponds to two slots: one/// slot for the starting position and another for the ending position./// Typically, either both are present or neither are. (The weasel word/// "typically" is used here because it really depends on the regex engine/// implementation. Every sensible regex engine likely adheres to this/// invariant, and every regex engine in this crate is sensible.)/// Generally speaking, callers should prefer to use higher level routines/// like [`Captures::get_match`] or [`Captures::get_group`]./// An important note here is that a regex engine may not reset all of the/// slots to `None` values when no match occurs, or even when a match of/// a different pattern occurs. But this depends on how the regex engine/// implementation deals with slots./// This example shows how to get the underlying slots from a regex match.///     util::primitives::{PatternID, NonMaxUsize},///     r"[a-z]+",/// re.captures(&mut cache, "123", &mut caps);/// // Note that the only guarantee we have here is that slots 2 and 3/// // are set to correct values. The contents of the first two slots are/// // unspecified since the 0th pattern did not match./// let expected = &[///     NonMaxUsize::new(0),///     NonMaxUsize::new(3),/// assert_eq!(expected, caps.slots());slots_mut/// Returns the underlying slots as a mutable slice, where each slot stores/// a single offset./// This tends to be most useful for regex engine implementations for/// writing offsets for matching capturing groups to slots./// See [`Captures::slots`] for more information about slots./// Lower level "slot" oriented APIs. One does not typically need to use these/// when executing a search. They are instead mostly intended for folks that/// are writing their own regex engine while reusing this `Captures` type.CapturesDebugMap/// A little helper type to provide a nice map-like debug representation for/// our capturing group spans./// An iterator over all capturing groups in a `Captures` value./// This iterator includes capturing groups that did not participate in a/// match. See the [`Captures::iter`] method documentation for more details/// and examples./// The lifetime parameter `'a` refers to the lifetime of the underlying/// `Captures` value.GroupInfoInner/// Represents information about capturing groups in a compiled regex./// The information encapsulated by this type consists of the following. For/// each pattern:/// * A map from every capture group name to its corresponding capture group/// * A map from every capture group index to its corresponding capture group/// * A map from capture group index to its corresponding slot index. A slot/// refers to one half of a capturing group. That is, a capture slot is either/// the start or end of a capturing group. A slot is usually the mechanism/// by which a regex engine records offsets for each capturing group during a/// A `GroupInfo` uses reference counting internally and is thus cheap to/// clone./// # Mapping from capture groups to slots/// One of the main responsibilities of a `GroupInfo` is to build a mapping/// from `(PatternID, u32)` (where the `u32` is a capture index) to something/// called a "slot." As mentioned above, a slot refers to one half of a/// capturing group. Both combined provide the start and end offsets of/// a capturing group that participated in a match./// **The mapping between group indices and slots is an API guarantee.** That/// is, the mapping won't change within a semver compatible release./// Slots exist primarily because this is a convenient mechanism by which/// regex engines report group offsets at search time. For example, the/// [`nfa::thompson::State::Capture`](crate::nfa::thompson::State::Capture)/// NFA state includes the slot index. When a regex engine transitions through/// this state, it will likely use the slot index to write the current haystack/// offset to some region of memory. When a match is found, those slots are/// then reported to the caller, typically via a convenient abstraction like a/// [`Captures`] value./// Because this crate provides first class support for multi-pattern regexes,/// and because of some performance related reasons, the mapping between/// capturing groups and slots is a little complex. However, in the case of a/// single pattern, the mapping can be described very simply: for all capture/// group indices `i`, its corresponding slots are at `i * 2` and `i * 2 + 1`./// Notice that the pattern ID isn't involved at all here, because it only/// applies to a single-pattern regex, it is therefore always `0`./// In the multi-pattern case, the mapping is a bit more complicated. To talk/// about it, we must define what we mean by "implicit" vs "explicit"/// capturing groups:/// * An **implicit** capturing group refers to the capturing group that is/// present for every pattern automatically, and corresponds to the overall/// match of a pattern. Every pattern has precisely one implicit capturing/// group. It is always unnamed and it always corresponds to the capture group/// index `0`./// * An **explicit** capturing group refers to any capturing group that/// appears in the concrete syntax of the pattern. (Or, if an NFA was hand/// built without any concrete syntax, it refers to any capturing group with an/// index greater than `0`.)/// Some examples:/// * `\w+` has one implicit capturing group and zero explicit capturing/// * `(\w+)` has one implicit group and one explicit group./// * `foo(\d+)(?:\pL+)(\d+)` has one implicit group and two explicit groups./// Turning back to the slot mapping, we can now state it as follows:/// * Given a pattern ID `pid`, the slots for its implicit group are always/// at `pid * 2` and `pid * 2 + 1`./// * Given a pattern ID `0`, the slots for its explicit groups start/// at `group_info.pattern_len() * 2`./// * Given a pattern ID `pid > 0`, the slots for its explicit groups start/// immediately following where the slots for the explicit groups of `pid - 1`/// end./// In particular, while there is a concrete formula one can use to determine/// where the slots for the implicit group of any pattern are, there is no/// general formula for determining where the slots for explicit capturing/// groups are. This is because each pattern can contain a different number/// of groups./// The intended way of getting the slots for a particular capturing group/// (whether implicit or explicit) is via the [`GroupInfo::slot`] or/// [`GroupInfo::slots`] method./// See below for a concrete example of how capturing groups get mapped to/// slots./// This example shows how to build a new `GroupInfo` and query it for/// use regex_automata::util::{captures::GroupInfo, primitives::PatternID};/// let info = GroupInfo::new(vec![///     vec![None, Some("foo")],///     vec![None],///     vec![None, None, None, Some("bar"), None],///     vec![None, None, Some("foo")],/// // The number of patterns being tracked./// assert_eq!(4, info.pattern_len());/// // We can query the number of groups for any pattern./// assert_eq!(2, info.group_len(PatternID::must(0)));/// assert_eq!(1, info.group_len(PatternID::must(1)));/// assert_eq!(5, info.group_len(PatternID::must(2)));/// assert_eq!(3, info.group_len(PatternID::must(3)));/// // An invalid pattern always has zero groups./// assert_eq!(0, info.group_len(PatternID::must(999)));/// // 2 slots per group/// assert_eq!(22, info.slot_len());/// // We can map a group index for a particular pattern to its name, if/// // one exists./// assert_eq!(Some("foo"), info.to_name(PatternID::must(3), 2));/// assert_eq!(None, info.to_name(PatternID::must(2), 4));/// // Or map a name to its group index./// assert_eq!(Some(1), info.to_index(PatternID::must(0), "foo"));/// assert_eq!(Some(2), info.to_index(PatternID::must(3), "foo"));/// # Example: mapping from capture groups to slots/// This example shows the specific mapping from capture group indices for/// each pattern to their corresponding slots. The slot values shown in this/// example are considered an API guarantee./// // We first show the slots for each pattern's implicit group./// assert_eq!(Some((0, 1)), info.slots(PatternID::must(0), 0));/// assert_eq!(Some((2, 3)), info.slots(PatternID::must(1), 0));/// assert_eq!(Some((4, 5)), info.slots(PatternID::must(2), 0));/// assert_eq!(Some((6, 7)), info.slots(PatternID::must(3), 0));/// // And now we show the slots for each pattern's explicit group./// assert_eq!(Some((8, 9)), info.slots(PatternID::must(0), 1));/// assert_eq!(Some((10, 11)), info.slots(PatternID::must(2), 1));/// assert_eq!(Some((12, 13)), info.slots(PatternID::must(2), 2));/// assert_eq!(Some((14, 15)), info.slots(PatternID::must(2), 3));/// assert_eq!(Some((16, 17)), info.slots(PatternID::must(2), 4));/// assert_eq!(Some((18, 19)), info.slots(PatternID::must(3), 1));/// assert_eq!(Some((20, 21)), info.slots(PatternID::must(3), 2));/// // Asking for the slots for an invalid pattern ID or even for an invalid/// // group index for a specific pattern will return None. So for example,/// // you're guaranteed to not get the slots for a different pattern than the/// // one requested./// assert_eq!(None, info.slots(PatternID::must(5), 0));/// assert_eq!(None, info.slots(PatternID::must(1), 1));/// Creates a new group info from a sequence of patterns, where each/// sequence of patterns yields a sequence of possible group names. The/// index of each pattern in the sequence corresponds to its `PatternID`,/// and the index of each group in each pattern's sequence corresponds to/// its corresponding group index./// While this constructor is very generic and therefore perhaps hard to/// chew on, an example of a valid concrete type that can be passed to/// this constructor is `Vec<Vec<Option<String>>>`. The outer `Vec`/// corresponds to the patterns, i.e., one `Vec<Option<String>>` per/// pattern. The inner `Vec` corresponds to the capturing groups for/// each pattern. The `Option<String>` corresponds to the name of the/// capturing group, if present./// It is legal to pass an empty iterator to this constructor. It will/// return an empty group info with zero slots. An empty group info is/// useful for cases where you have no patterns or for cases where slots/// aren't being used at all (e.g., for most DFAs in this crate)./// This constructor returns an error if the given capturing groups are/// invalid in some way. Those reasons include, but are not necessarily/// limited to:/// * Too many patterns (i.e., `PatternID` would overflow)./// * Too many capturing groups (e.g., `u32` would overflow)./// * A pattern is given that has no capturing groups. (All patterns must/// have at least an implicit capturing group at index `0`.)/// * The capturing group at index `0` has a name. It must be unnamed./// * There are duplicate capturing group names within the same pattern./// (Multiple capturing groups with the same name may exist, but they/// must be in different patterns.)/// An example below shows how to trigger some of the above error/// conditions./// use regex_automata::util::captures::GroupInfo;/// # Example: empty `GroupInfo`/// let info = GroupInfo::empty();/// // Everything is zero./// assert_eq!(0, info.pattern_len());/// assert_eq!(0, info.slot_len());/// # Example: error conditions/// This example shows how to provoke some of the ways in which building/// a `GroupInfo` can fail./// // Either the group info is empty, or all patterns must have at least/// // one capturing group./// assert!(GroupInfo::new(vec![///     vec![None, Some("a")], // ok///     vec![None], // ok///     vec![], // not ok/// ]).is_err());/// // Note that building an empty group info is OK./// assert!(GroupInfo::new(Vec::<Vec<Option<String>>>::new()).is_ok());/// // The first group in each pattern must correspond to an implicit/// // anonymous group. i.e., One that is not named. By convention, this/// // group corresponds to the overall match of a regex. Every other group/// // in a pattern is explicit and optional./// assert!(GroupInfo::new(vec![vec![Some("foo")]]).is_err());/// // There must not be duplicate group names within the same pattern.///     vec![None, Some("foo"), Some("foo")],/// // But duplicate names across distinct patterns is OK./// ]).is_ok());/// There are other ways for building a `GroupInfo` to fail but are/// difficult to show. For example, if the number of patterns given would/// overflow `PatternID`./// This creates an empty `GroupInfo`./// This is a convenience routine for calling `GroupInfo::new` with an/// iterator that yields no elements./// This example shows how to build a new empty `GroupInfo` and query it/// for information./// assert_eq!(0, info.all_group_len());/// Return the capture group index corresponding to the given name in the/// given pattern. If no such capture group name exists in the given/// pattern, then this returns `None`./// If the given pattern ID is invalid, then this returns `None`./// This also returns `None` for all inputs if these captures are empty/// (e.g., built from an empty [`GroupInfo`]). To check whether captures/// are present for a specific pattern, use [`GroupInfo::group_len`]./// This example shows how to find the capture index for the given pattern/// and group name./// Remember that capture indices are relative to the pattern, such that/// the same capture index value may refer to different capturing groups/// for distinct patterns./// let (pid0, pid1) = (PatternID::must(0), PatternID::must(1));/// let nfa = NFA::new_many(&[///     r"a(?P<quux>\w+)z(?P<foo>\s+)",///     r"a(?P<foo>\d+)z",/// let groups = nfa.group_info();/// assert_eq!(Some(2), groups.to_index(pid0, "foo"));/// // Recall that capture index 0 is always unnamed and refers to the/// // entire pattern. So the first capturing group present in the pattern/// // itself always starts at index 1./// assert_eq!(Some(1), groups.to_index(pid1, "foo"));/// // And if a name does not exist for a particular pattern, None is/// // returned./// assert!(groups.to_index(pid0, "quux").is_some());/// assert!(groups.to_index(pid1, "quux").is_none());/// Return the capture name for the given index and given pattern. If the/// corresponding group does not have a name, then this returns `None`./// If the pattern ID is invalid, then this returns `None`./// If the group index is invalid for the given pattern, then this returns/// `None`. A group `index` is valid for a pattern `pid` in an `nfa` if and/// only if `index < nfa.pattern_capture_len(pid)`./// This example shows how to find the capture group name for the given/// pattern and group index.///     r"a(?P<foo>\w+)z(\s+)x(\d+)",///     r"a(\d+)z(?P<foo>\s+)",/// assert_eq!(None, groups.to_name(pid0, 0));/// assert_eq!(Some("foo"), groups.to_name(pid0, 1));/// assert_eq!(None, groups.to_name(pid0, 2));/// assert_eq!(None, groups.to_name(pid0, 3));/// assert_eq!(None, groups.to_name(pid1, 0));/// assert_eq!(None, groups.to_name(pid1, 1));/// assert_eq!(Some("foo"), groups.to_name(pid1, 2));/// // '3' is not a valid capture index for the second pattern./// assert_eq!(None, groups.to_name(pid1, 3));pattern_names/// Return an iterator of all capture groups and their names (if present)/// for a particular pattern./// If the given pattern ID is invalid or if this `GroupInfo` is empty,/// then the iterator yields no elements./// The number of elements yielded by this iterator is always equal to/// the result of calling [`GroupInfo::group_len`] with the sameall_namesGroupInfoAllNames/// Return an iterator of all capture groups for all patterns supported by/// this `GroupInfo`. Each item yielded is a triple of the group's pattern/// ID, index in the pattern and the group's name, if present./// This example shows how to get a list of all capture groups found in/// one NFA, potentially spanning multiple patterns.///     r"a",///     r"(a)",///     (PatternID::must(2), 1, None),///     nfa.group_info().all_names().collect();/// Unlike other capturing group related routines, this routine doesn't/// panic even if captures aren't enabled on this NFA:///         r"(?P<foo>a)",///         r"a",///         r"(a)",/// // When captures aren't enabled, there's nothing to return./// assert_eq!(0, nfa.group_info().all_names().count());/// Returns the starting and ending slot corresponding to the given/// capturing group for the given pattern. The ending slot is always one/// more than the starting slot returned./// Note that this is like [`GroupInfo::slot`], except that it also returns/// the ending slot value for convenience./// If either the pattern ID or the capture index is invalid, then this/// returns None./// This example shows that the starting slots for the first capturing/// group of each pattern are distinct./// let nfa = NFA::new_many(&["a", "b"])?;///     nfa.group_info().slots(PatternID::must(0), 0),///     nfa.group_info().slots(PatternID::must(1), 0),/// // Also, the start and end slot values are never equivalent./// let (start, end) = nfa.group_info().slots(PatternID::ZERO, 0).unwrap();/// assert_ne!(start, end);/// Returns the starting slot corresponding to the given capturing group/// for the given pattern. The ending slot is always one more than the/// value returned.///     nfa.group_info().slot(PatternID::must(0), 0),///     nfa.group_info().slot(PatternID::must(1), 0),/// Returns the total number of patterns in this `GroupInfo`./// This may return zero if the `GroupInfo` was constructed with no/// `GroupInfo` construction will fail if too many patterns are added./// assert_eq!(3, nfa.group_info().pattern_len());/// assert_eq!(0, nfa.group_info().pattern_len());/// assert_eq!(1, nfa.group_info().pattern_len());/// Return the number of capture groups in a pattern./// If the pattern ID is invalid, then this returns `0`./// This example shows how the values returned by this routine may vary/// for different patterns and NFA configurations./// use regex_automata::{nfa::thompson::{NFA, WhichCaptures}, PatternID};/// let nfa = NFA::new(r"(a)(b)(c)")?;/// // There are 3 explicit groups in the pattern's concrete syntax and/// // 1 unnamed and implicit group spanning the entire pattern./// assert_eq!(4, nfa.group_info().group_len(PatternID::ZERO));/// let nfa = NFA::new(r"abc")?;/// // There is just the unnamed implicit group./// assert_eq!(1, nfa.group_info().group_len(PatternID::ZERO));///     .build(r"abc")?;/// // We disabled capturing groups, so there are none./// assert_eq!(0, nfa.group_info().group_len(PatternID::ZERO));///     .build(r"(a)(b)(c)")?;/// // We disabled capturing groups, so there are none, even if there are/// // explicit groups in the concrete syntax.all_group_len/// Return the total number of capture groups across all patterns./// This includes implicit groups that represent the entire match of a/// assert_eq!(4, nfa.group_info().all_group_len());/// assert_eq!(1, nfa.group_info().all_group_len());/// let nfa = NFA::new_many(&["(a)", "b", "(c)"])?;/// // Each pattern has one implicit groups, and two/// // patterns have one explicit group each./// assert_eq!(5, nfa.group_info().all_group_len());/// assert_eq!(0, nfa.group_info().all_group_len());slot_len/// Returns the total number of slots in this `GroupInfo` across all/// The total number of slots is always twice the total number of capturing/// groups, including both implicit and explicit groups./// This example shows the relationship between the number of capturing/// groups and slots./// // There are 11 total groups here./// // 2 slots per group gives us 11*2=22 slots.implicit_slot_len/// Returns the total number of slots for implicit capturing groups./// This is like [`GroupInfo::slot_len`], except it doesn't include the/// explicit slots for each pattern. Since there are always exactly 2/// implicit slots for each pattern, the number of implicit slots is always/// equal to twice the number of patterns./// groups, implicit slots and explicit slots./// let info = GroupInfo::new(vec![vec![None, Some("foo"), Some("bar")]])?;/// assert_eq!(6, info.slot_len());/// // 2 implicit slots per pattern gives us 2 implicit slots since there/// // is 1 pattern./// assert_eq!(2, info.implicit_slot_len());/// // 2 explicit capturing groups gives us 2*2=4 explicit slots./// assert_eq!(4, info.explicit_slot_len());/// Returns the total number of slots for explicit capturing groups./// implicit slots for each pattern. (There are always 2 implicit slots for/// each pattern.)/// For a non-empty `GroupInfo`, it is always the case that `slot_len` is/// strictly greater than `explicit_slot_len`. For an empty `GroupInfo`,/// both the total number of slots and the number of explicit slots is/// Returns the memory usage, in bytes, of this `GroupInfo`./// This does **not** include the stack size used up by this `GroupInfo`./// To compute that, use `std::mem::size_of::<GroupInfo>()`.CaptureNameMap/// A map from capture group name to its corresponding capture group index./// This type is actually wrapped inside a Vec indexed by pattern ID on a/// `GroupInfo`, since multiple patterns may have the same capture group name./// That is, each pattern gets its own namespace of capture group names./// Perhaps a more memory efficient representation would be/// HashMap<(PatternID, Arc<str>), usize>, but this makes it difficult to look/// up a capture index by name without producing a `Arc<str>`, which requires/// an allocation. To fix this, I think we'd need to define our own unsized/// type or something? Anyway, I didn't give this much thought since it/// probably doesn't matter much in the grand scheme of things. But it did/// stand out to me as mildly wasteful.slot_rangesname_to_indexindex_to_name/// The inner guts of `GroupInfo`. This type only exists so that it can/// be wrapped in an `Arc` to make `GroupInfo` reference counted.add_first_group/// This adds the first unnamed group for the given pattern ID. The given/// pattern ID must be zero if this is the first time this method is/// called, or must be exactly one more than the pattern ID supplied to the/// previous call to this method. (This method panics if this rule is/// violated.)/// This can be thought of as initializing the GroupInfo state for the/// given pattern and closing off the state for any previous pattern.add_explicit_group/// Add an explicit capturing group for the given pattern with the given/// index. If the group has a name, then that must be given as well./// Note that every capturing group except for the first or zeroth group is/// This returns an error if adding this group would result in overflowing/// slot indices or if a capturing group with the same name for this/// pattern has already been added.fixup_slot_ranges/// This corrects the slot ranges to account for the slots corresponding/// to the zeroth group of each pattern. That is, every slot range is/// offset by 'pattern_len() * 2', since each pattern uses two slots to/// represent the zeroth group./// Return the total number of patterns represented by this capture slot/// info./// Return the total number of capturing groups for the given pattern. If/// the given pattern isn't valid for this capture slot info, then 0 issmall_slot_len/// Return the total number of slots in this capture slot info as a/// "small index."GroupInfoErrorKind/// An error that may occur when building a `GroupInfo`./// Building a `GroupInfo` does a variety of checks to make sure the/// capturing groups satisfy a number of invariants. This includes, but is not/// limited to, ensuring that the first capturing group is unnamed and that/// there are no duplicate capture groups for a specific pattern./// This occurs when too many patterns have been added. i.e., It would/// otherwise overflow a `PatternID`./// The ID of the pattern that had too many groups./// The minimum number of groups that the caller has tried to add for/// a pattern.TooManyGroups/// This occurs when too many capturing groups have been added for a/// particular pattern./// The ID of the pattern that had no capturing groups.MissingGroups/// An error that occurs when a pattern has no capture groups. Either the/// group info must be empty, or all patterns must have at least one group/// (corresponding to the unnamed group for the entire pattern)./// The ID of the pattern that was found to have a named first/// capturing group.FirstMustBeUnnamed/// An error that occurs when one tries to provide a name for the capture/// group at index 0. This capturing group must currently always be/// unnamed./// The pattern in which the duplicate capture group name was found./// The duplicate name./// An error that occurs when duplicate capture group names for the same/// pattern are added./// NOTE: At time of writing, this error can never occur if you're using/// regex-syntax, since the parser itself will reject patterns with/// duplicate capture group names. This error can only occur when the/// builder is used to hand construct NFAs./// The kind of error that occurs when building a `GroupInfo` fails./// We keep this un-exported because it's not clear how useful it is to/// export it.too_many_groupsmissing_groupsfirst_must_be_unnamed/// An iterator over capturing groups and their names for a specific pattern./// This iterator is created by [`GroupInfo::pattern_names`]./// The lifetime parameter `'a` refers to the lifetime of the `GroupInfo`/// from which this iterator was created.pidscurrent_pid/// An iterator over capturing groups and their names for a `GroupInfo`./// This iterator is created by [`GroupInfo::all_names`]./*!
Provides types for dealing with capturing groups.

Capturing groups refer to sub-patterns of regexes that some regex engines can
report matching offsets for. For example, matching `[a-z]([0-9]+)` against
`a789` would give `a789` as the overall match (for the implicit capturing group
at index `0`) and `789` as the match for the capturing group `([0-9]+)` (an
explicit capturing group at index `1`).

Not all regex engines can report match offsets for capturing groups. Indeed,
to a first approximation, regex engines that can report capturing group offsets
tend to be quite a bit slower than regex engines that can't. This is because
tracking capturing groups at search time usually requires more "power" that
in turn adds overhead.

Other regex implementations might call capturing groups "submatches."

# Overview

The main types in this module are:

* [`Captures`] records the capturing group offsets found during a search. It
provides convenience routines for looking up capturing group offsets by either
index or name.
* [`GroupInfo`] records the mapping between capturing groups and "slots,"
where the latter are how capturing groups are recorded during a regex search.
This also keeps a mapping from capturing group name to index, and capture
group index to name. A `GroupInfo` is used by `Captures` internally to
provide a convenient API. It is unlikely that you'll use a `GroupInfo`
directly, but for example, if you've compiled an Thompson NFA, then you can use
[`thompson::NFA::group_info`](crate::nfa::thompson::NFA::group_info) to get its
underlying `GroupInfo`.
*/StateBuilderMatches/// Compute the set of all reachable NFA states, including the full epsilon/// closure, from a DFA state for a single unit of input. The set of reachable/// states is returned as a `StateBuilderNFA`. The `StateBuilderNFA` returned/// also includes any look-behind assertions satisfied by `unit`, in addition/// to whether it is a match state. For multi-pattern DFAs, the builder will/// also include the pattern IDs that match (in the order seen)./// `nfa` must be able to resolve any NFA state in `state` and any NFA state/// reachable via the epsilon closure of any NFA state in `state`. `sparses`/// must have capacity equivalent to `nfa.len()`./// `match_kind` should correspond to the match semantics implemented by the/// DFA being built. Generally speaking, for leftmost-first match semantics,/// states that appear after the first NFA match state will not be included in/// the `StateBuilderNFA` returned since they are impossible to visit./// `sparses` is used as scratch space for NFA traversal. Other than their/// capacity requirements (detailed above), there are no requirements on what's/// contained within them (if anything). Similarly, what's inside of them once/// this routine returns is unspecified./// `stack` must have length 0. It is used as scratch space for depth first/// traversal. After returning, it is guaranteed that `stack` will have length/// 0./// `state` corresponds to the current DFA state on which one wants to compute/// the transition for the input `unit`./// `empty_builder` corresponds to the builder allocation to use to produce a/// complete `StateBuilderNFA` state. If the state is not needed (or is already/// cached), then it can be cleared and reused without needing to create a new/// `State`. The `StateBuilderNFA` state returned is final and ready to be/// turned into a `State` if necessary./// Compute the epsilon closure for the given NFA state. The epsilon closure/// consists of all NFA state IDs, including `start_nfa_id`, that can be/// reached from `start_nfa_id` without consuming any input. These state IDs/// are written to `set` in the order they are visited, but only if they are/// not already in `set`. `start_nfa_id` must be a valid state ID for the NFA/// `look_have` consists of the satisfied assertions at the current/// position. For conditional look-around epsilon transitions, these are/// only followed if they are satisfied by `look_have`.add_nfa_states/// Add the NFA state IDs in the given `set` to the given DFA builder state./// The order in which states are added corresponds to the order in which they/// were added to `set`./// The DFA builder state given should already have its complete set of match/// pattern IDs added (if any) and any look-behind assertions (StartLF, Start/// and whether this state is being generated for a transition over a word byte/// when applicable) that are true immediately prior to transitioning into this/// state (via `builder.look_have()`). The match pattern IDs should correspond/// to matches that occurred on the previous transition, since all matches are/// delayed by one byte. The things that should _not_ be set are look-ahead/// assertions (EndLF, End and whether the next byte is a word byte or not)./// The builder state should also not have anything in `look_need` set, as this/// routine will compute that for you./// The given NFA should be able to resolve all identifiers in `set` to a/// particular NFA state. Additionally, `set` must have capacity equivalent/// to `nfa.len()`.set_lookbehind_from_start/// Sets the appropriate look-behind assertions on the given state based on/// this starting configuration./*!
This module contains types and routines for implementing determinization.

In this crate, there are at least two places where we implement
determinization: fully ahead-of-time compiled DFAs in the `dfa` module and
lazily compiled DFAs in the `hybrid` module. The stuff in this module
corresponds to the things that are in common between these implementations.

There are three broad things that our implementations of determinization have
in common, as defined by this module:

* The classification of start states. That is, whether we're dealing with
word boundaries, line boundaries, etc., is all the same. This also includes
the look-behind assertions that are satisfied by each starting state
classification.
* The representation of DFA states as sets of NFA states, including
convenience types for building these DFA states that are amenable to reusing
allocations.
* Routines for the "classical" parts of determinization: computing the
epsilon closure, tracking match states (with corresponding pattern IDs, since
we support multi-pattern finite automata) and, of course, computing the
transition function between states for units of input.

I did consider a couple of alternatives to this particular form of code reuse:

1. Don't do any code reuse. The problem here is that we *really* want both
forms of determinization to do exactly identical things when it comes to
their handling of NFA states. While our tests generally ensure this, the code
is tricky and large enough where not reusing code is a pretty big bummer.

2. Implement all of determinization once and make it generic over fully
compiled DFAs and lazily compiled DFAs. While I didn't actually try this
approach, my instinct is that it would be more complex than is needed here.
And the interface required would be pretty hairy. Instead, I think splitting
it into logical sub-components works better.
*//// A DFA state that, at its core, is represented by an ordered set of NFA/// This type is intended to be used only in NFA-to-DFA conversion via powerset/// It may be cheaply cloned and accessed safely from multiple threads/// This Borrow impl permits us to lookup any state in a map by its byte/// representation. This is particularly convenient when one has a StateBuilder/// and we want to see if a correspondingly equivalent state already exists. If/// one does exist, then we can reuse the allocation required by StateBuilder/// without having to convert it into a State first.is_from_wordis_half_crlflook_havelook_needmatch_pattern_idsiter_match_pattern_idsiter_nfa_state_ids/// For docs on these routines, see the internal Repr and ReprVec types below./// A state builder that represents an empty state./// This is a useful "initial condition" for state construction. It has no/// NFA state IDs, no assertions set and no pattern IDs. No allocations are/// made when new() is called. Its main use is for being converted into a/// builder that can capture assertions and pattern IDs.into_matches/// A state builder that collects assertions and pattern IDs./// When collecting pattern IDs is finished, this can be converted into a/// builder that collects NFA state IDs.set_is_from_wordset_is_half_crlfset_look_haveadd_match_pattern_idrepr_vecReprVecprev_nfa_state_id/// A state builder that collects some assertions and NFA state IDs./// When collecting NFA state IDs is finished, this can be used to build a/// `State` if necessary./// When dont with building a state (regardless of whether it got kept or not),/// it's usually a good idea to call `clear` to get an empty builder back so/// that it can be reused to build the next state.to_stateset_look_needadd_nfa_state_id/// Repr is a read-only view into the representation of a DFA state./// Primarily, a Repr is how we achieve DRY: we implement decoding the format/// in one place, and then use a Repr to implement the various methods on the/// public state types./// The format is as follows:/// The first three bytes correspond to bitsets./// Byte 0 is a bitset corresponding to miscellaneous flags associated with the/// state. Bit 0 is set to 1 if the state is a match state. Bit 1 is set to 1/// if the state has pattern IDs explicitly written to it. (This is a flag that/// is not meant to be set by determinization, but rather, is used as part of/// an internal space-saving optimization.) Bit 2 is set to 1 if the state was/// generated by a transition over a "word" byte. (Callers may not always set/// this. For example, if the NFA has no word boundary assertion, then needing/// to track whether a state came from a word byte or not is superfluous and/// wasteful.) Bit 3 is set to 1 if the state was generated by a transition/// from a `\r` (forward search) or a `\n` (reverse search) when CRLF mode is/// Bytes 1..5 correspond to the look-behind assertions that were satisfied/// by the transition that created this state. (Look-ahead assertions are not/// tracked as part of states. Instead, these are applied by re-computing the/// epsilon closure of a state when computing the transition function. See/// `next` in the parent module.)/// Bytes 5..9 correspond to the set of look-around assertions (including both/// look-behind and look-ahead) that appear somewhere in this state's set of/// NFA state IDs. This is used to determine whether this state's epsilon/// closure should be re-computed when computing the transition function./// Namely, look-around assertions are "just" conditional epsilon transitions,/// so if there are new assertions available when computing the transition/// function, we should only re-compute the epsilon closure if those new/// assertions are relevant to this particular state./// Bytes 9..13 correspond to a 32-bit native-endian encoded integer/// corresponding to the number of patterns encoded in this state. If the state/// is not a match state (byte 0 bit 0 is 0) or if it's only pattern ID is/// PatternID::ZERO, then no integer is encoded at this position. Instead, byte/// offset 3 is the position at which the first NFA state ID is encoded./// For a match state with at least one non-ZERO pattern ID, the next bytes/// correspond to a sequence of 32-bit native endian encoded integers that/// represent each pattern ID, in order, that this match state represents./// After the pattern IDs (if any), NFA state IDs are delta encoded as/// varints.[1] The first NFA state ID is encoded as itself, and each/// subsequent NFA state ID is encoded as the difference between itself and the/// previous NFA state ID./// [1] - https://developers.google.com/protocol-buffers/docs/encoding#varints/// Returns true if and only if this is a match state./// If callers have added pattern IDs to this state, then callers MUST set/// this state as a match state explicitly. However, as a special case,/// states that are marked as match states but with no pattern IDs, then/// the state is treated as if it had a single pattern ID equivalent to/// PatternID::ZERO.has_pattern_ids/// Returns true if and only if this state has had at least one pattern/// ID added to it./// This is an internal-only flag that permits the representation to save/// space in the common case of an NFA with one pattern in it. In that/// case, a match state can only ever have exactly one pattern ID:/// PatternID::ZERO. So there's no need to represent it./// Returns true if and only if this state is marked as having been created/// from a transition over a word byte. This is useful for checking whether/// a word boundary assertion is true or not, which requires look-behind/// (whether the current state came from a word byte or not) and look-ahead/// (whether the transition byte is a word byte or not)./// Since states with this set are distinct from states that don't have/// this set (even if they are otherwise equivalent), callers should not/// set this assertion unless the underlying NFA has at least one word/// boundary assertion somewhere. Otherwise, a superfluous number of states/// may be created./// Returns true if and only if this state is marked as being inside of a/// CRLF terminator. In the forward direction, this means the state was/// created after seeing a `\r`. In the reverse direction, this means the/// state was created after seeing a `\n`./// The set of look-behind assertions that were true in the transition that/// created this state./// Generally, this should be empty if 'look_need' is empty, since there is/// no reason to track which look-behind assertions are true if the state/// has no conditional epsilon transitions./// Satisfied look-ahead assertions are not tracked in states. Instead,/// these are re-computed on demand via epsilon closure when computing the/// transition function./// The set of look-around (both behind and ahead) assertions that appear/// at least once in this state's set of NFA states./// This is used to determine whether the epsilon closure needs to be/// re-computed when computing the transition function. Namely, if the/// state has no conditional epsilon transitions, then there is no need/// to re-compute the epsilon closure./// Returns the total number of match pattern IDs in this state./// If this state is not a match state, then this always returns 0./// Returns the pattern ID for this match state at the given index./// If the given index is greater than or equal to `match_len()` for this/// state, then this could panic or return incorrect results./// Returns a copy of all match pattern IDs in this state. If this state/// is not a match state, then this returns None./// Calls the given function on every pattern ID in this state./// Calls the given function on every NFA state ID in this state.pattern_offset_end/// Returns the offset into this state's representation where the pattern/// IDs end and the NFA state IDs begin.encoded_pattern_len/// Returns the total number of *encoded* pattern IDs in this state./// This may return 0 even when this is a match state, since the pattern/// ID `PatternID::ZERO` is not encoded when it's the only pattern ID in/// the match state (the overwhelming common case)./// ReprVec is a write-only view into the representation of a DFA state./// See Repr for more details on the purpose of this type and also the format./// Note that not all possible combinations of methods may be called. This is/// precisely what the various StateBuilder types encapsulate: they only/// permit valid combinations via Rust's linear typing.set_is_match/// Set this state as a match state./// This should not be exposed explicitly outside of this module. It is/// set automatically when a pattern ID is added.set_has_pattern_ids/// Set that this state has pattern IDs explicitly written to it./// This should not be exposed explicitly outside of this module. This is/// used internally as a space saving optimization. Namely, if the state/// is a match state but does not have any pattern IDs written to it,/// then it is automatically inferred to have a pattern ID of ZERO./// Set this state as being built from a transition over a word byte./// Setting this is only necessary when one needs to deal with word/// boundary assertions. Therefore, if the underlying NFA has no word/// boundary assertions, callers should not set this./// Set this state as having seen half of a CRLF terminator./// In the forward direction, this should be set when a `\r` has been seen./// In the reverse direction, this should be set when a `\n` has been seen./// Mutate the set of look-behind assertions that were true in the/// transition that created this state./// Mutate the set of look-around (both behind and ahead) assertions that/// appear at least once in this state's set of NFA states./// Add a pattern ID to this state. All match states must have at least/// one pattern ID associated with it./// Callers must never add duplicative pattern IDs./// The order in which patterns are added must correspond to the order/// in which patterns are reported as matches.close_match_pattern_ids/// Indicate that no more pattern IDs will be added to this state./// Once this is called, callers must not call it or 'add_match_pattern_id'/// This should not be exposed explicitly outside of this module. It/// should be called only when converting a StateBuilderMatches into a/// StateBuilderNFA./// Add an NFA state ID to this state. The order in which NFA states are/// added matters. It is the caller's responsibility to ensure that/// duplicate NFA state IDs are not added./// Return a read-only view of this state's representation.write_vari32/// Write a signed 32-bit integer using zig-zag encoding./// https://developers.google.com/protocol-buffers/docs/encoding#varintsread_vari32/// Read a signed 32-bit integer using zig-zag encoding. Also, return the/// number of bytes read.write_varu32/// Write an unsigned 32-bit integer as a varint. In essence, `n` is written/// as a sequence of bytes where all bytes except for the last one have the/// most significant bit set. The least significant 7 bits correspond to the/// actual bits of `n`. So in the worst case, a varint uses 5 bytes, but in/// very common cases, it uses fewer than 4.read_varu32/// Read an unsigned 32-bit varint. Also, return the number of bytes read./// Push a native-endian encoded `n` on to `dst`.dedup_state_idsdedup_pattern_ids/*!
This module defines a DFA state representation and builders for constructing
DFA states.

This representation is specifically for use in implementations of NFA-to-DFA
conversion via powerset construction. (Also called "determinization" in this
crate.)

The term "DFA state" is somewhat overloaded in this crate. In some cases, it
refers to the set of transitions over an alphabet for a particular state. In
other cases, it refers to a set of NFA states. The former is really about the
final representation of a state in a DFA's transition table, where as the
latter---what this module is focused on---is closer to an intermediate form
that is used to help eventually build the transition table.

This module exports four types. All four types represent the same idea: an
ordered set of NFA states. This ordered set represents the epsilon closure of a
particular NFA state, where the "epsilon closure" is the set of NFA states that
can be transitioned to without consuming any input. i.e., Follow all of the NFA
state's epsilon transitions. In addition, this implementation of DFA states
cares about two other things: the ordered set of pattern IDs corresponding
to the patterns that match if the state is a match state, and the set of
look-behind assertions that were true when the state was created.

The first, `State`, is a frozen representation of a state that cannot be
modified. It may be cheaply cloned without copying the state itself and can be
accessed safely from multiple threads simultaneously. This type is useful for
when one knows that the DFA state being constructed is distinct from any other
previously constructed states. Namely, powerset construction, in practice,
requires one to keep a cache of previously created DFA states. Otherwise,
the number of DFA states created in memory balloons to an impractically
large number. For this reason, equivalent states should endeavor to have an
equivalent byte-level representation. (In general, "equivalency" here means,
"equivalent assertions, pattern IDs and NFA state IDs." We do not require that
full DFA minimization be implemented here. This form of equivalency is only
surface deep and is more-or-less a practical necessity.)

The other three types represent different phases in the construction of a
DFA state. Internally, these three types (and `State`) all use the same
byte-oriented representation. That means one can use any of the builder types
to check whether the state it represents already exists or not. If it does,
then there is no need to freeze it into a `State` (which requires an alloc and
a copy). Here are the three types described succinctly:

* `StateBuilderEmpty` represents a state with no pattern IDs, no assertions
and no NFA states. Creating a `StateBuilderEmpty` performs no allocs. A
`StateBuilderEmpty` can only be used to query its underlying memory capacity,
or to convert into a builder for recording pattern IDs and/or assertions.

* `StateBuilderMatches` represents a state with zero or more pattern IDs, zero
or more satisfied assertions and zero NFA state IDs. A `StateBuilderMatches`
can only be used for adding pattern IDs and recording assertions.

* `StateBuilderNFA` represents a state with zero or more pattern IDs, zero or
more satisfied assertions and zero or more NFA state IDs. A `StateBuilderNFA`
can only be used for adding NFA state IDs and recording some assertions.

The expected flow here is to use the above builders to construct a candidate
DFA state to check if it already exists. If it does, then there's no need to
freeze it into a `State`. If it doesn't exist, then `StateBuilderNFA::to_state`
can be called to freeze the builder into an immutable `State`. In either
case, `clear` should be called on the builder to turn it back into a
`StateBuilderEmpty` that reuses the underlying memory.

The main purpose for splitting the builder into these distinct types is to
make it impossible to do things like adding a pattern ID after adding an NFA
state ID. Namely, this makes it simpler to use a space-and-time efficient
binary representation for the state. (The format is documented on the `Repr`
type below.) If we just used one type for everything, it would be possible for
callers to use an incorrect interleaving of calls and thus result in a corrupt
representation. I chose to use more type machinery to make this impossible to
do because 1) determinization is itself pretty complex and it wouldn't be too
hard to foul this up and 2) there isn't too much machinery involved and it's
well contained.

As an optimization, sometimes states won't have certain things set. For
example, if the underlying NFA has no word boundary assertions, then there is
no reason to set a state's look-behind assertion as to whether it was generated
from a word byte or not. Similarly, if a state has no NFA states corresponding
to look-around assertions, then there is no reason to set `look_have` to a
non-empty set. Finally, callers usually omit unconditional epsilon transitions
when adding NFA state IDs since they aren't discriminatory.

Finally, the binary representation used by these states is, thankfully, not
serialized anywhere. So any kind of change can be made with reckless abandon,
as long as everything in this module agrees.
*/skip_splits_fwdskip_splits_revskip_splits/*!
This module provides helper routines for dealing with zero-width matches.

The main problem being solved here is this:

1. The caller wants to search something that they know is valid UTF-8, such
as a Rust `&str`.
2. The regex used by the caller can match the empty string. For example, `a*`.
3. The caller should never get match offsets returned that occur within the
encoding of a UTF-8 codepoint. It is logically incorrect, and also means that,
e.g., slicing the `&str` at those offsets will lead to a panic.

So the question here is, how do we prevent the caller from getting match
offsets that split a codepoint? For example, strictly speaking, the regex `a*`
matches `☃` at the positions `[0, 0]`, `[1, 1]`, `[2, 2]` and `[3, 3]` since
the UTF-8 encoding of `☃` is `\xE2\x98\x83`. In particular, the `NFA` that
underlies all of the matching engines in this crate doesn't have anything in
its state graph that prevents matching between UTF-8 code units. Indeed, any
engine derived from the `NFA` will match at those positions by virtue of the
fact that the `NFA` is byte oriented. That is, its transitions are defined over
bytes and the matching engines work by proceeding one byte at a time.

(An alternative architecture would be to define the transitions in an `NFA`
over codepoints, or `char`. And then make the matching engines proceed by
decoding one codepoint at a time. This is a viable strategy, but it doesn't
work for DFA matching engines because designing a fast and memory efficient
transition table for an alphabet as large as Unicode is quite difficult. More
to the point, the top-level `regex` crate supports matching on arbitrary bytes
when Unicode mode is disabled and one is searching a `&[u8]`. So in that case,
you can't just limit yourself to decoding codepoints and matching those. You
really do need to be able to follow byte oriented transitions on the `NFA`.)

In an older version of the regex crate, we handled this case not in the regex
engine, but in the iterators over matches. Namely, since this case only arises
when the match is empty, we "just" incremented the next starting position
of the search by `N`, where `N` is the length of the codepoint encoded at
the current position. The alternative or more "natural" solution of just
incrementing by `1` would result in executing a search of `a*` on `☃` like
this:

* Start search at `0`.
* Found match at `[0, 0]`.
* Next start position is `0`.
* To avoid an infinite loop, since it's an empty match, increment by `1`.
* Start search at `1`.
* Found match at `[1, 1]`. Oops.

But if we instead incremented by `3` (the length in bytes of `☃`), then we get
the following:

* Start search at `0`.
* Found match at `[0, 0]`.
* Next start position is `0`.
* To avoid an infinite loop, since it's an empty match, increment by `3`.
* Start search at `3`.
* Found match at `[3, 3]`.

And we get the correct result. But does this technique work in all cases?
Crucially, it requires that a zero-width match that splits a codepoint never
occurs beyond the starting position of the search. Because if it did, merely
incrementing the start position by the number of bytes in the codepoint at
the current position wouldn't be enough. A zero-width match could just occur
anywhere. It turns out that it is _almost_ true. We can convince ourselves by
looking at all possible patterns that can match the empty string:

* Patterns like `a*`, `a{0}`, `(?:)`, `a|` and `|a` all unconditionally match
the empty string. That is, assuming there isn't an `a` at the current position,
they will all match the empty string at the start of a search. There is no way
to move past it because any other match would not be "leftmost."
* `^` only matches at the beginning of the haystack, where the start position
is `0`. Since we know we're searching valid UTF-8 (if it isn't valid UTF-8,
then this entire problem goes away because it implies your string type supports
invalid UTF-8 and thus must deal with offsets that not only split a codepoint
but occur in entirely invalid UTF-8 somehow), it follows that `^` never matches
between the code units of a codepoint because the start of a valid UTF-8 string
is never within the encoding of a codepoint.
* `$` basically the same logic as `^`, but for the end of a string. A valid
UTF-8 string can't have an incomplete codepoint at the end of it.
* `(?m:^)` follows similarly to `^`, but it can match immediately following
a `\n`. However, since a `\n` is always a codepoint itself and can never
appear within a codepoint, it follows that the position immediately following
a `\n` in a string that is valid UTF-8 is guaranteed to not be between the
code units of another codepoint. (One caveat here is that the line terminator
for multi-line anchors can now be changed to any arbitrary byte, including
things like `\x98` which might occur within a codepoint. However, this wasn't
supported by the old regex crate. If it was, it pose the same problems as
`(?-u:\B)`, as we'll discuss below.)
* `(?m:$)` a similar argument as for `(?m:^)`. The only difference is that a
`(?m:$)` matches just before a `\n`. But the same argument applies.
* `(?Rm:^)` and `(?Rm:$)` weren't supported by the old regex crate, but the
CRLF aware line anchors follow a similar argument as for `(?m:^)` and `(?m:$)`.
Namely, since they only ever match at a boundary where one side is either a
`\r` or a `\n`, neither of which can occur within a codepoint.
* `\b` only matches at positions where both sides are valid codepoints, so
this cannot split a codepoint.
* `\B`, like `\b`, also only matches at positions where both sides are valid
codepoints. So this cannot split a codepoint either.
* `(?-u:\b)` matches only at positions where at least one side of it is an ASCII
word byte. Since ASCII bytes cannot appear as code units in non-ASCII codepoints
(one of the many amazing qualities of UTF-8), it follows that this too cannot
split a codepoint.
* `(?-u:\B)` finally represents a problem. It can matches between *any* two
bytes that are either both word bytes or non-word bytes. Since code units like
`\xE2` and `\x98` (from the UTF-8 encoding of `☃`) are both non-word bytes,
`(?-u:\B)` will match at the position between them.

Thus, our approach of incrementing one codepoint at a time after seeing an
empty match is flawed because `(?-u:\B)` can result in an empty match that
splits a codepoint at a position past the starting point of a search. For
example, searching `(?-u:\B)` on `a☃` would produce the following matches: `[2,
2]`, `[3, 3]` and `[4, 4]`. The positions at `0` and `1` don't match because
they correspond to word boundaries since `a` is an ASCII word byte.

So what did the old regex crate do to avoid this? It banned `(?-u:\B)` from
regexes that could match `&str`. That might sound extreme, but a lot of other
things were banned too. For example, all of `(?-u:.)`, `(?-u:[^a])` and
`(?-u:\W)` can match invalid UTF-8 too, including individual code units with a
codepoint. The key difference is that those expressions could never produce an
empty match. That ban happens when translating an `Ast` to an `Hir`, because
that process that reason about whether an `Hir` can produce *non-empty* matches
at invalid UTF-8 boundaries. Bottom line though is that we side-stepped the
`(?-u:\B)` issue by banning it.

If banning `(?-u:\B)` were the only issue with the old regex crate's approach,
then I probably would have kept it. `\B` is rarely used, so it's not such a big
deal to have to work-around it. However, the problem with the above approach
is that it doesn't compose. The logic for avoiding splitting a codepoint only
lived in the iterator, which means if anyone wants to implement their own
iterator over regex matches, they have to deal with this extremely subtle edge
case to get full correctness.

Instead, in this crate, we take the approach of pushing this complexity down
to the lowest layers of each regex engine. The approach is pretty simple:

* If this corner case doesn't apply, don't do anything. (For example, if UTF-8
mode isn't enabled or if the regex cannot match the empty string.)
* If an empty match is reported, explicitly check if it splits a codepoint.
* If it doesn't, we're done, return the match.
* If it does, then ignore the match and re-run the search.
* Repeat the above process until the end of the haystack is reached or a match
is found that doesn't split a codepoint or isn't zero width.

And that's pretty much what this module provides. Every regex engine uses these
methods in their lowest level public APIs, but just above the layer where
their internal engine is used. That way, all regex engines can be arbitrarily
composed without worrying about handling this case, and iterators don't need to
handle it explicitly.

(It turns out that a new feature I added, support for changing the line
terminator in a regex to any arbitrary byte, also provokes the above problem.
Namely, the byte could be invalid UTF-8 or a UTF-8 continuation byte. So that
support would need to be limited or banned when UTF-8 mode is enabled, just
like we did for `(?-u:\B)`. But thankfully our more robust approach in this
crate handles that case just fine too.)
*//// Provides a convenient `Debug` implementation for a `u8`./// The `Debug` impl treats the byte as an ASCII, and emits a human readable/// representation of it. If the byte isn't ASCII, then it's emitted as a hex/// escape sequence.DebugHaystack/// Provides a convenient `Debug` implementation for `&[u8]`./// This generally works best when the bytes are presumed to be mostly UTF-8,/// but will work for anything. For any bytes that aren't UTF-8, they are/// emitted as hex escape sequences./*!
Provides convenience routines for escaping raw bytes.

Since this crate tends to deal with `&[u8]` everywhere and the default
`Debug` implementation just shows decimal integers, it makes debugging those
representations quite difficult. This module provides types that show `&[u8]`
as if it were a string, with invalid UTF-8 escaped into its byte-by-byte hex
representation.
*//*!
This module provides several integer oriented traits for converting between
both fixed size integers and integers whose size varies based on the target
(like `usize`).

The driving design principle of this module is to attempt to centralize as many
`as` casts as possible here. And in particular, we separate casts into two
buckets:

* Casts that we use for their truncating behavior. In this case, we use more
descriptive names, like `low_u32` and `high_u32`.
* Casts that we use for converting back-and-forth between `usize`. These
conversions are generally necessary because we often store indices in different
formats to save on memory, which requires converting to and from `usize`. In
this case, we very specifically do not want to overflow, and so the methods
defined here will panic if the `as` cast would be lossy in debug mode. (A
normal `as` cast will never panic!)

For `as` casts between raw pointers, we use `cast`, so `as` isn't needed there.

For regex engines, floating point is just never used, so we don't have to worry
about `as` casts for those.

Otherwise, this module pretty much covers all of our `as` needs except for one
thing: const contexts. There are a select few places in this crate where we
still need to use `as` because const functions on traits aren't stable yet.
If we wind up significantly expanding our const footprint in this crate, it
might be worth defining free functions to handle those cases. But at the time
of writing, that just seemed like too much ceremony. Instead, I comment each
such use of `as` in a const context with a "fixme" notice.

NOTE: for simplicity, we don't take target pointer width into account here for
`usize` conversions. Since we currently only panic in debug mode, skipping the
check when it can be proven it isn't needed at compile time doesn't really
matter. Now, if we wind up wanting to do as many checks as possible in release
mode, then we would want to skip those when we know the conversions are always
non-lossy.

NOTE: this module isn't an exhaustive API. For example, we still use things
like `u64::from` where possible, or even `usize::try_from()` for when we do
explicitly want to panic or when we want to return an error for overflow.
*//// Accepts a replacement string and interpolates capture references with their/// corresponding values./// `append` should be a function that appends the string value of a capture/// group at a particular index to the string given. If the capture group/// index is invalid, then nothing should be appended./// `name_to_index` should be a function that maps a capture group name to a/// capture group index. If the given name doesn't exist, then `None` should/// Finally, `dst` is where the final interpolated contents should be written./// If `replacement` contains no capture group references, then `dst` will be/// equivalent to `replacement`./// See the [module documentation](self) for details about the format/// use regex_automata::util::interpolate;/// interpolate::string(///     "foo $bar baz",///     |index, dst| {///         if index == 0 {///             dst.push_str("BAR");///     |name| {///         if name == "bar" {///             Some(0)///     &mut dst,/// assert_eq!("foo BAR baz", dst);/// Accepts a replacement byte string and interpolates capture references with/// their corresponding values./// `append` should be a function that appends the byte string value of a/// capture group at a particular index to the byte string given. If the/// capture group index is invalid, then nothing should be appended./// interpolate::bytes(///     b"foo $bar baz",///             dst.extend_from_slice(b"BAR");/// assert_eq!(&b"foo BAR baz"[..], dst);CaptureRef/// `CaptureRef` represents a reference to a capture group inside some text./// The reference is either a capture group name or a number./// It is also tagged with the position in the text following the/// capture reference./// A reference to a capture group in some text./// e.g., `$2`, `$foo`, `${foo}`.find_cap_ref/// Parses a possible reference to a capture group name in the given text,/// starting at the beginning of `replacement`./// If no such valid reference could be found, None is returned./// Note that this returns a "possible" reference because this routine doesn't/// know whether the reference is to a valid group or not. If it winds up not/// being a valid reference, then it should be replaced with the empty string.find_cap_ref_braced/// Looks for a braced reference, e.g., `${foo1}`. This assumes that an opening/// brace has been found at `i-1` in `rep`. This then looks for a closing/// brace and returns the capture reference within the brace.is_valid_cap_letter/// Returns true if and only if the given byte is allowed in a capture name/// written in non-brace form.find_cap_ref1find_cap_ref2find_cap_ref3find_cap_ref4find_cap_ref5find_cap_ref6// See https://github.com/rust-lang/regex/pull/585// for more on characters following numbersfind_cap_ref7find_cap_ref8find_cap_ref9find_cap_ref10find_cap_ref11find_cap_ref12find_cap_ref13find_cap_ref14find_cap_ref15find_cap_ref16find_cap_ref17find_cap_ref18find_cap_ref19find_cap_ref20find_cap_ref21find_cap_ref22find_cap_ref23find_cap_ref24find_cap_ref25find_cap_ref26interpinterp1interp2interp3interp4interp5interp6interp7interp8interp9interp10interp11interp12interp13interp14interp15// This is a funny case where a braced reference is never closed, but// within the unclosed braced reference, there is an unbraced reference.// In this case, the braced reference is just treated literally and the// unbraced reference is found./*!
Provides routines for interpolating capture group references.

That is, if a replacement string contains references like `$foo` or `${foo1}`,
then they are replaced with the corresponding capture values for the groups
named `foo` and `foo1`, respectively. Similarly, syntax like `$1` and `${1}`
is supported as well, with `1` corresponding to a capture group index and not
a name.

This module provides the free functions [`string`] and [`bytes`], which
interpolate Rust Unicode strings and byte strings, respectively.

# Format

These routines support two different kinds of capture references: unbraced and
braced.

For the unbraced format, the format supported is `$ref` where `name` can be
any character in the class `[0-9A-Za-z_]`. `ref` is always the longest
possible parse. So for example, `$1a` corresponds to the capture group named
`1a` and not the capture group at index `1`. If `ref` matches `^[0-9]+$`, then
it is treated as a capture group index itself and not a name.

For the braced format, the format supported is `${ref}` where `ref` can be any
sequence of bytes except for `}`. If no closing brace occurs, then it is not
considered a capture reference. As with the unbraced format, if `ref` matches
`^[0-9]+$`, then it is treated as a capture group index and not a name.

The braced format is useful for exerting precise control over the name of the
capture reference. For example, `${1}a` corresponds to the capture group
reference `1` followed by the letter `a`, where as `$1a` (as mentioned above)
corresponds to the capture group reference `1a`. The braced format is also
useful for expressing capture group names that use characters not supported by
the unbraced format. For example, `${foo[bar].baz}` refers to the capture group
named `foo[bar].baz`.

If a capture group reference is found and it does not refer to a valid capture
group, then it will be replaced with the empty string.

To write a literal `$`, use `$$`.

To be clear, and as exhibited via the type signatures in the routines in this
module, it is impossible for a replacement string to be invalid. A replacement
string may not have the intended semantics, but the interpolation procedure
itself can never fail.
*//// The input parameters to give to each regex engine call./// A searcher for creating iterators and performing lower level iteration./// This searcher encapsulates the logic required for finding all successive/// non-overlapping matches in a haystack. In theory, iteration would look/// something like this:/// 1. Setting the start position to `0`./// 2. Execute a regex search. If no match, end iteration./// 3. Report the match and set the start position to the end of the match./// 4. Go back to (2)./// And if this were indeed the case, it's likely that `Searcher` wouldn't/// exist. Unfortunately, because a regex may match the empty string, the above/// logic won't work for all possible regexes. Namely, if an empty match is/// found, then step (3) would set the start position of the search to the/// position it was at. Thus, iteration would never end./// Instead, a `Searcher` knows how to detect these cases and forcefully/// advance iteration in the case of an empty match that overlaps with a/// previous match./// If you know that your regex cannot match any empty string, then the simple/// algorithm described above will work correctly./// When possible, prefer the iterators defined on the regex engine you're/// using. This tries to abstract over the regex engine and is thus a bit more/// unwieldy to use./// In particular, a `Searcher` is not itself an iterator. Instead, it provides/// `advance` routines that permit moving the search along explicitly. It also/// provides various routines, like [`Searcher::into_matches_iter`], that/// accept a closure (representing how a regex engine executes a search) and/// returns a conventional iterator./// The lifetime parameters come from the [`Input`] type passed to/// [`Searcher::new`]:/// * `'h` is the lifetime of the underlying haystack./// # Searcher vs Iterator/// Why does a search type with "advance" APIs exist at all when we also have/// iterators? Unfortunately, the reasoning behind this split is a complex/// combination of the following things:/// 1. While many of the regex engines expose their own iterators, it is also/// nice to expose this lower level iteration helper because it permits callers/// to provide their own `Input` configuration. Moreover, a `Searcher` can work/// with _any_ regex engine instead of only the ones defined in this crate./// This way, everyone benefits from a shared iteration implementation./// 2. There are many different regex engines that, while they have the same/// match semantics, they have slightly different APIs. Iteration is just/// complex enough to want to share code, and so we need a way of abstracting/// over those different regex engines. While we could define a new trait that/// describes any regex engine search API, it would wind up looking very close/// to a closure. While there may still be reasons for the more generic trait/// to exist, for now and for the purposes of iteration, we use a closure./// Closures also provide a lot of easy flexibility at the call site, in that/// they permit the caller to borrow any kind of state they want for use during/// each search call./// 3. As a result of using closures, and because closures are anonymous types/// that cannot be named, it is difficult to encapsulate them without both/// costs to speed and added complexity to the public API. For example, in/// defining an iterator type like/// [`dfa::regex::FindMatches`](crate::dfa::regex::FindMatches),/// if we use a closure internally, it's not possible to name this type in the/// return type of the iterator constructor. Thus, the only way around it is/// to erase the type by boxing it and turning it into a `Box<dyn FnMut ...>`./// This boxed closure is unlikely to be inlined _and_ it infects the public/// API in subtle ways. Namely, unless you declare the closure as implementing/// `Send` and `Sync`, then the resulting iterator type won't implement it/// either. But there are practical issues with requiring the closure to/// implement `Send` and `Sync` that result in other API complexities that/// are beyond the scope of this already long exposition./// 4. Some regex engines expose more complex match information than just/// "which pattern matched" and "at what offsets." For example, the PikeVM/// exposes match spans for each capturing group that participated in the/// match. In such cases, it can be quite beneficial to reuse the capturing/// group allocation on subsequent searches. A proper iterator doesn't permit/// this API due to its interface, so it's useful to have something a bit lower/// level that permits callers to amortize allocations while also reusing a/// shared implementation of iteration. (See the documentation for/// [`Searcher::advance`] for an example of using the "advance" API with the/// PikeVM.)/// What this boils down to is that there are "advance" APIs which require/// handing a closure to it for every call, and there are also APIs to create/// iterators from a closure. The former are useful for _implementing_/// iterators or when you need more flexibility, while the latter are useful/// for conveniently writing custom iterators on-the-fly./// # Example: iterating with captures/// Several regex engines in this crate over convenient iterator APIs over/// [`Captures`] values. To do so, this requires allocating a new `Captures`/// value for each iteration step. This can perhaps be more costly than you/// might want. Instead of implementing your own iterator to avoid that/// cost (which can be a little subtle if you want to handle empty matches/// correctly), you can use this `Searcher` to do it for you:///     Input, Span,/// let mut searcher = Searcher::new(Input::new(haystack));/// while let Some(_) = searcher.advance(|input| {///     re.search(&mut cache, input, &mut caps);///     Ok(caps.get_match())/// }) {///     matches.push(caps.get_group_by_name("numbers").unwrap());/// Create a new fallible non-overlapping matches iterator./// The given `input` provides the parameters (including the haystack),/// while the `finder` represents a closure that calls the underlying regex/// engine. The closure may borrow any additional state that is needed,/// such as a prefilter scanner./// Returns the current `Input` used by this searcher./// The `Input` returned is generally equivalent to the one given to/// [`Searcher::new`], but its start position may be different to reflect/// the start of the next search to be executed.advance_half/// Return the next half match for an infallible search if one exists, and/// advance to the next position./// This is like `try_advance_half`, except errors are converted into/// If the given closure returns an error, then this panics. This is useful/// when you know your underlying regex engine has been configured to not/// This example shows how to use a `Searcher` to iterate over all matches/// when using a DFA, which only provides "half" matches./// let re = DFA::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;/// let input = Input::new("2010-03-14 2016-10-08 2020-10-22");/// let mut it = Searcher::new(input);/// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));/// let expected = Some(HalfMatch::must(0, 21));/// let expected = Some(HalfMatch::must(0, 32));/// This correctly moves iteration forward even when an empty match occurs:/// let re = DFA::new(r"a|")?;/// let input = Input::new("abba");/// let expected = Some(HalfMatch::must(0, 1));/// let expected = Some(HalfMatch::must(0, 2));/// Return the next match for an infallible search if one exists, and/// The search is advanced even in the presence of empty matches by/// forbidding empty matches from overlapping with any other match./// This is like `try_advance`, except errors are converted into panics./// when using a regex based on lazy DFAs:///     hybrid::regex::Regex,/// let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;/// let expected = Some(Match::must(0, 0..10));/// let got = it.advance(|input| re.try_search(&mut cache, input));/// let expected = Some(Match::must(0, 11..21));/// let expected = Some(Match::must(0, 22..32));/// This example shows the same as above, but with the PikeVM. This example/// is useful because it shows how to use this API even when the regex/// engine doesn't directly return a `Match`./// let re = PikeVM::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;/// let got = it.advance(|input| {/// // Note that if we wanted to extract capturing group spans, we could/// // do that here with 'caps'.try_advance_half/// Return the next half match for a fallible search if one exists, and/// This is like `advance_half`, except it permits callers to handle errors/// during iteration./// Return the next match for a fallible search if one exists, and advance/// to the next position./// This is like `advance`, except it permits callers to handle errorsinto_half_matches_iterTryHalfMatchesIter/// Given a closure that executes a single search, return an iterator over/// all successive non-overlapping half matches./// The iterator returned yields result values. If the underlying regex/// engine is configured to never return an error, consider calling/// [`TryHalfMatchesIter::infallible`] to convert errors into panics./// This example shows how to use a `Searcher` to create a proper/// iterator over half matches./// let mut it = Searcher::new(input).into_half_matches_iter(|input| {///     re.try_search_fwd(&mut cache, input)/// let expected = Some(Ok(HalfMatch::must(0, 10)));/// assert_eq!(expected, it.next());/// let expected = Some(Ok(HalfMatch::must(0, 21)));/// let expected = Some(Ok(HalfMatch::must(0, 32)));into_matches_iterTryMatchesIter/// all successive non-overlapping matches./// [`TryMatchesIter::infallible`] to convert errors into panics./// iterator over matches./// let mut it = Searcher::new(input).into_matches_iter(|input| {///     re.try_search(&mut cache, input)/// let expected = Some(Ok(Match::must(0, 0..10)));/// let expected = Some(Ok(Match::must(0, 11..21)));/// let expected = Some(Ok(Match::must(0, 22..32)));into_captures_iterTryCapturesIter/// all successive non-overlapping `Captures` values./// [`TryCapturesIter::infallible`] to convert errors into panics./// Unlike the other iterator constructors, this accepts an initial/// `Captures` value. This `Captures` value is reused for each search, and/// the iterator implementation clones it before returning it. The caller/// must provide this value because the iterator is purposely ignorant/// of the underlying regex engine and thus doesn't know how to create/// one itself. More to the point, a `Captures` value itself has a few/// different constructors, which change which kind of information is/// available to query in exchange for search performance./// This example shows how to use a `Searcher` to create a proper iterator/// over `Captures` values, which provides access to all capturing group/// spans for each match.///     r"(?P<y>[0-9]{4})-(?P<m>[0-9]{2})-(?P<d>[0-9]{2})",/// let haystack = "2010-03-14 2016-10-08 2020-10-22";/// let mut it = Searcher::new(input)///     .into_captures_iter(caps, |input, caps| {///         re.search(&mut cache, input, caps);/// let got = it.next().expect("first date")?;/// let year = got.get_group_by_name("y").expect("must match");/// assert_eq!("2010", &haystack[year]);/// let got = it.next().expect("second date")?;/// let month = got.get_group_by_name("m").expect("must match");/// assert_eq!("10", &haystack[month]);/// let got = it.next().expect("third date")?;/// let day = got.get_group_by_name("d").expect("must match");/// assert_eq!("22", &haystack[day]);/// assert!(it.next().is_none());handle_overlapping_empty_half_match/// Handles the special case of a match that begins where the previous/// match ended. Without this special handling, it'd be possible to get/// stuck where an empty match never results in forward progress. This/// also makes it more consistent with how presiding general purpose regex/// engines work./// the presiding behavior of most general purpose regex engines. The/// "intuitive sense" here is that we want to report NON-overlapping/// matches. So for example, given the regex 'a|(?:)' against the haystack/// 'a', without the special handling, you'd get the matches [0, 1) and [1,/// 1), where the latter overlaps with the end bounds of the former./// An iterator over all non-overlapping half matches for a fallible search./// The iterator yields a `Result<HalfMatch, MatchError>` value until no more/// * `F` represents the type of a closure that executes the search./// The lifetime parameters come from the [`Input`] type:/// This iterator is created by [`Searcher::into_half_matches_iter`].infallibleHalfMatchesIter/// Return an infallible version of this iterator./// Any item yielded that corresponds to an error results in a panic. This/// is useful if your underlying regex engine is configured in a way that/// it is guaranteed to never return an error./// Returns the current `Input` used by this iterator./// The `Input` returned is generally equivalent to the one used to/// construct this iterator, but its start position may be different to/// reflect the start of the next search to be executed./// An iterator over all non-overlapping half matches for an infallible search./// The iterator yields a [`HalfMatch`] value until no more matches could be/// This iterator is created by [`Searcher::into_half_matches_iter`] and/// then calling [`TryHalfMatchesIter::infallible`]./// The iterator yields a `Result<Match, MatchError>` value until no more/// This iterator is created by [`Searcher::into_matches_iter`].MatchesIter/// This iterator is created by [`Searcher::into_matches_iter`] and/// then calling [`TryMatchesIter::infallible`]./// An iterator over all non-overlapping captures for a fallible search./// This iterator is created by [`Searcher::into_captures_iter`].CapturesIter/// An iterator over all non-overlapping captures for an infallible search./// This iterator is created by [`Searcher::into_captures_iter`] and then/// calling [`TryCapturesIter::infallible`]./*!
Generic helpers for iteration of matches from a regex engine in a haystack.

The principle type in this module is a [`Searcher`]. A `Searcher` provides
its own lower level iterator-like API in addition to methods for constructing
types that implement `Iterator`. The documentation for `Searcher` explains a
bit more about why these different APIs exist.

Currently, this module supports iteration over any regex engine that works
with the [`HalfMatch`], [`Match`] or [`Captures`] types.
*//// A lazily initialized value that implements `Deref` for `T`./// A `Lazy` takes an initialization function and permits callers from any/// thread to access the result of that initialization function in a safe/// manner. In effect, this permits one-time initialization of global resources/// in a (possibly) multi-threaded program./// This type and its functionality are available even when neither the `alloc`/// nor the `std` features are enabled. In exchange, a `Lazy` does **not**/// guarantee that the given `create` function is called at most once. It/// might be called multiple times. Moreover, a call to `Lazy::get` (either/// explicitly or implicitly via `Lazy`'s `Deref` impl) may block until a `T`/// is available./// This is very similar to `lazy_static` or `once_cell`, except it doesn't/// guarantee that the initialization function will be run once and it works/// in no-alloc no-std environments. With that said, if you need stronger/// guarantees or a more flexible API, then it is recommended to use either/// `lazy_static` or `once_cell`./// # Warning: may use a spin lock/// When this crate is compiled _without_ the `alloc` feature, then this type/// may used a spin lock internally. This can have subtle effects that may/// be undesirable. See [Spinlocks Considered Harmful][spinharm] for a more/// thorough treatment of this topic./// [spinharm]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html/// This type is useful for creating regexes once, and then using them from/// multiple threads simultaneously without worrying about synchronization./// use regex_automata::{dfa::regex::Regex, util::lazy::Lazy, Match};/// static RE: Lazy<Regex> = Lazy::new(|| Regex::new("foo[0-9]+bar").unwrap());/// let expected = Some(Match::must(0, 3..14));/// assert_eq!(expected, RE.find(b"zzzfoo12345barzzz"));/// Create a new `Lazy` value that is initialized via the given function./// The `T` type is automatically inferred from the return type of the/// `create` function given./// Return a reference to the lazily initialized value./// This routine may block if another thread is initializing a `T`./// Note that given a `x` which has type `Lazy`, this must be called via/// `Lazy::get(x)` and not `x.get()`. This routine is defined this way/// because `Lazy` impls `Deref` with a target of `T`./// This panics if the `create` function inside this lazy value panics./// If the panic occurred in another thread, then this routine _may_ also/// panic (but is not guaranteed to do so).// This indicates to the compiler that this type can drop T. It's not// totally clear how the absence of this marker could lead to trouble,// but putting here doesn't have any downsides so we hedge until somone// can from the Unsafe Working Group can tell us definitively that we// don't need it.// See: https://github.com/BurntSushi/regex-automata/issues/30/// A non-std lazy initialized value./// This might run the initialization function more than once, but will/// never block./// I wish I could get these semantics into the non-alloc non-std Lazy/// type below, but I'm not sure how to do it. If you can do an alloc,/// then the implementation becomes very simple if you don't care about/// redundant work precisely because a pointer can be atomically swapped./// Perhaps making this approach work in the non-alloc non-std case/// requires asking the caller for a pointer? It would make the API less/// convenient I think.// SAFETY: So long as T and &T (and F and &F) can themselves be safely// shared among threads, so to can a Lazy<T, _>. Namely, the Lazy API only// permits accessing a &T and initialization is free of data races. So if T// is thread safe, then so to is Lazy<T, _>.// We specifically require that T: Send in order for Lazy<T> to be Sync.// Without that requirement, it's possible to send a T from one thread to// another via Lazy's destructor.// It's not clear whether we need F: Send+Sync for Lazy to be Sync. But// we're conservative for now and keep both./// Create a new alloc but non-std lazy value that is racily/// initialized. That is, the 'create' function may be called more than/// once./// Get the underlying lazy value. If it hasn't been initialized/// yet, then always attempt to initialize it (even if some other/// thread is initializing it) and atomically attach it to this lazy/// value before returning it./// If this lazy value has been initialized successfully, then return/// that value. Otherwise return None immediately. This never attempts/// to run initialization itself.assert_sendassert_syncassert_unwindassert_refunwindoibits// This is a regression test because we used to rely on the inferred Sync// impl for the Lazy type defined above (for 'alloc' mode). In the// inferred impl, it only requires that T: Sync for Lazy<T>: Sync. But// if we have that, we can actually make use of the fact that Lazy<T> drops// T to create a value on one thread and drop it on another. This *should*// require T: Send, but our missing bounds before let it sneak by.// Basically, this test should not compile, so we... comment it out. We// don't have a great way of testing compile-fail tests right now./*
    #[test]
    fn sync_not_send() {
        #[allow(dead_code)]
        fn inner<T: Sync + Default>() {
            let lazy = Lazy::new(move || T::default());
            std::thread::scope(|scope| {
                scope.spawn(|| {
                    Lazy::get(&lazy); // We create T in this thread
                });
            });
            // And drop in this thread.
            drop(lazy);
            // So we have send a !Send type over threads. (with some more
            // legwork, its possible to even sneak the value out of drop
            // through thread local)
        }
    }
    *//*!
A lazily initialized value for safe sharing between threads.

The principal type in this module is `Lazy`, which makes it easy to construct
values that are shared safely across multiple threads simultaneously.
*//// Match the beginning of text. Specifically, this matches at the starting/// position of the input./// Match the end of text. Specifically, this matches at the endingStartLF/// Match the beginning of a line or the beginning of text. Specifically,/// this matches at the starting position of the input, or at the position/// immediately following a `\n` character.EndLF/// Match the end of a line or the end of text. Specifically, this matches/// at the end position of the input, or at the position immediately/// preceding a `\n` character.StartCRLF/// immediately following either a `\r` or `\n` character, but never after/// a `\r` when a `\n` follows.EndCRLF/// preceding a `\r` or `\n` character, but never before a `\n` when a `\r`/// precedes it.WordAscii/// Match an ASCII-only word boundary. That is, this matches a position/// where the left adjacent character and right adjacent character/// correspond to a word and non-word or a non-word and word character.WordAsciiNegate/// Match an ASCII-only negation of a word boundary.WordUnicode/// Match a Unicode-aware word boundary. That is, this matches a positionWordUnicodeNegate/// Match a Unicode-aware negation of a word boundary.WordStartAscii/// Match the start of an ASCII-only word boundary. That is, this matches a/// position at either the beginning of the haystack or where the previous/// character is not a word character and the following character is a wordWordEndAscii/// Match the end of an ASCII-only word boundary. That is, this matches/// a position at either the end of the haystack or where the previous/// character is a word character and the following character is not a wordWordStartUnicode/// Match the start of a Unicode word boundary. That is, this matches aWordEndUnicode/// Match the end of a Unicode word boundary. That is, this matches a/// position at either the end of the haystack or where the previousWordStartHalfAscii/// Match the start half of an ASCII-only word boundary. That is, this/// matches a position at either the beginning of the haystack or where the/// previous character is not a word character.WordEndHalfAscii/// Match the end half of an ASCII-only word boundary. That is, this/// matches a position at either the end of the haystack or where the/// following character is not a word character.WordStartHalfUnicode/// Match the start half of a Unicode word boundary. That is, this matches/// a position at either the beginning of the haystack or where theWordEndHalfUnicode/// Match the end half of a Unicode word boundary. That is, this matches/// a position at either the end of the haystack or where the following/// character is not a word character./// A look-around assertion./// An assertion matches at a position between characters in a haystack./// Namely, it does not actually "consume" any input as most parts of a regular/// expression do. Assertions are a way of stating that some property must be/// true at a particular point during matching./// For example, `(?m)^[a-z]+$` is a pattern that:/// * Scans the haystack for a position at which `(?m:^)` is satisfied. That/// occurs at either the beginning of the haystack, or immediately following/// a `\n` character./// * Looks for one or more occurrences of `[a-z]`./// * Once `[a-z]+` has matched as much as it can, an overall match is only/// reported when `[a-z]+` stops just before a `\n`./// So in this case, `abc` and `\nabc\n` match, but `\nabc1\n` does not./// Assertions are also called "look-around," "look-behind" and "look-ahead."/// Specifically, some assertions are look-behind (like `^`), other assertions/// are look-ahead (like `$`) and yet other assertions are both look-ahead and/// look-behind (like `\b`)./// # Assertions in an NFA/// An assertion in a [`thompson::NFA`](crate::nfa::thompson::NFA) can be/// thought of as a conditional epsilon transition. That is, a matching engine/// like the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) only permits/// moving through conditional epsilon transitions when their condition/// is satisfied at whatever position the `PikeVM` is currently at in the/// How assertions are handled in a `DFA` is trickier, since a DFA does not/// have epsilon transitions at all. In this case, they are compiled into the/// automaton itself, at the expense of more states than what would be required/// without an assertion./// Flip the look-around assertion to its equivalent for reverse searches./// For example, `StartLF` gets translated to `EndLF`./// Some assertions, such as `WordUnicode`, remain the same since they/// match the same positions regardless of the direction of the search.as_repr/// Return the underlying representation of this look-around enumeration/// as an integer. Giving the return value to the [`Look::from_repr`]/// constructor is guaranteed to return the same look-around variant that/// one started with within a semver compatible release of this crate./// Given the underlying representation of a `Look` value, return the/// corresponding `Look` value if the representation is valid. Otherwise/// Returns a convenient single codepoint representation of this/// look-around assertion. Each assertion is guaranteed to be represented/// by a distinct character./// This is useful for succinctly representing a look-around assertion in/// human friendly but succinct output intended for a programmer working on/// regex internals./// The underlying representation this set is exposed to make it possible/// to store it somewhere efficiently. The representation is that/// of a bitset, where each assertion occupies bit `i` where/// `i = Look::as_repr()`./// Note that users of this internal representation must permit the full/// range of `u16` values to be represented. For example, even if the/// current implementation only makes use of the 10 least significant bits,/// it may use more bits in a future semver compatible release./// LookSet is a memory-efficient set of look-around assertions./// This is useful for efficiently tracking look-around assertions. For/// example, a [`thompson::NFA`](crate::nfa::thompson::NFA) provides properties/// that return `LookSet`s./// Create an empty set of look-around assertions./// Create a full set of look-around assertions./// This set contains all possible look-around assertions.singleton/// Create a look-around set containing the look-around assertion given./// This is a convenience routine for creating an empty set and inserting/// one look-around assertions./// Returns the total number of look-around assertions in this set./// Returns true if and only if this set is empty./// Returns true if and only if the given look-around assertion is in thiscontains_anchor/// Returns true if and only if this set contains any anchor assertions./// This includes both "start/end of haystack" and "start/end of line."contains_anchor_haystack/// Returns true if and only if this set contains any "start/end of/// haystack" anchors. This doesn't include "start/end of line" anchors.contains_anchor_line/// Returns true if and only if this set contains any "start/end of line"/// anchors. This doesn't include "start/end of haystack" anchors. This/// includes both `\n` line anchors and CRLF (`\r\n`) aware line anchors.contains_anchor_lf/// anchors that only treat `\n` as line terminators. This does not include/// haystack anchors or CRLF aware line anchors.contains_anchor_crlf/// anchors that are CRLF-aware. This doesn't include "start/end of/// haystack" or "start/end of line-feed" anchors.contains_word/// Returns true if and only if this set contains any word boundary or/// negated word boundary assertions. This include both Unicode and ASCII/// word boundaries.contains_word_unicode/// Returns true if and only if this set contains any Unicode word boundary/// or negated Unicode word boundary assertions.contains_word_ascii/// Returns true if and only if this set contains any ASCII word boundary/// or negated ASCII word boundary assertions.LookSetIter/// Returns an iterator over all of the look-around assertions in this set./// Return a new set that is equivalent to the original, but with the given/// assertion added to it. If the assertion is already in the set, then the/// returned set is equivalent to the original.set_insert/// Updates this set in place with the result of inserting the given/// assertion into this set./// assertion removed from it. If the assertion is not in the set, then theset_remove/// Updates this set in place with the result of removing the given/// assertion from this set./// Returns a new set that is the result of subtracting the given set fromset_subtract/// Updates this set in place with the result of subtracting the given set/// from this set./// Returns a new set that is the union of this and the one given.set_union/// Updates this set in place with the result of unioning it with the one/// Returns a new set that is the intersection of this and the one given.set_intersect/// Updates this set in place with the result of intersecting it with the/// one given.read_repr/// Return a `LookSet` from the slice given as a native endian 32-bit/// integer./// This panics if `slice.len() < 4`.write_repr/// Write a `LookSet` as a native endian 32-bit integer to the beginning/// of the slice given./// Checks that all assertions in this set can be matched./// Some assertions, such as Unicode word boundaries, require optional (but/// enabled by default) tables that may not be available. If there are/// assertions in this set that require tables that are not available, then/// this will return an error./// Specifically, this returns an error when the the/// `unicode-word-boundary` feature is _not_ enabled _and_ this set/// contains a Unicode word boundary assertion./// It can be useful to use this on the result of/// [`NFA::look_set_any`](crate::nfa::thompson::NFA::look_set_any)/// when building a matcher engine to ensure methods like/// [`LookMatcher::matches_set`] do not panic at search time./// An iterator over all look-around assertions in a [`LookSet`]./// This iterator is created by [`LookSet::iter`].lineterm/// A matcher for look-around assertions./// This matcher permits configuring aspects of how look-around assertions are/// matched./// A `LookMatcher` can change the line terminator used for matching multi-line/// anchors such as `(?m:^)` and `(?m:$)`./// Creates a new default matcher for look-around assertions.set_line_terminator/// Sets the line terminator for use with `(?m:^)` and `(?m:$)`./// Namely, instead of `^` matching after `\n` and `$` matching immediately/// before a `\n`, this will cause it to match after and before the byte/// It can occasionally be useful to use this to configure the line/// terminator to the NUL byte when searching binary data./// Note that this does not apply to CRLF-aware line anchors such as/// `(?Rm:^)` and `(?Rm:$)`. CRLF-aware line anchors are hard-coded to/// use `\r` and `\n`./// Returns the line terminator that was configured for this matcher./// If no line terminator was configured, then this returns `\n`./// Note that the line terminator should only be used for matching `(?m:^)`/// and `(?m:$)` assertions. It specifically should _not_ be used for/// matching the CRLF aware assertions `(?Rm:^)` and `(?Rm:$)`./// Returns true when the position `at` in `haystack` satisfies the given/// look-around assertion./// This panics when testing any Unicode word boundary assertion in this/// set and when the Unicode word data is not available. Specifically, this/// only occurs when the `unicode-word-boundary` feature is not enabled./// Since it's generally expected that this routine is called inside of/// a matching engine, callers should check the error condition when/// building the matching engine. If there is a Unicode word boundary/// in the matcher and the data isn't available, then the matcher should/// fail to build./// Callers can check the error condition with [`LookSet::available`]./// This also may panic when `at > haystack.len()`. Note that `at ==/// haystack.len()` is legal and guaranteed not to panic.matches_inline/// Like `matches`, but forcefully inlined.matches_set/// Returns true when _all_ of the assertions in the given set match at the/// given position in the haystack.matches_set_inline/// Like `LookSet::matches`, but forcefully inlined for perf.add_to_byteset/// Split up the given byte classes into equivalence classes in a way that/// is consistent with this look-around assertion./// Returns true when [`Look::Start`] is satisfied `at` the given position/// in `haystack`./// This may panic when `at > haystack.len()`. Note that `at ==/// Returns true when [`Look::End`] is satisfied `at` the given position inis_start_lf/// Returns true when [`Look::StartLF`] is satisfied `at` the givenis_end_lf/// Returns true when [`Look::EndLF`] is satisfied `at` the given positionis_start_crlf/// Returns true when [`Look::StartCRLF`] is satisfied `at` the givenis_end_crlf/// Returns true when [`Look::EndCRLF`] is satisfied `at` the givenis_word_ascii/// Returns true when [`Look::WordAscii`] is satisfied `at` the givenis_word_ascii_negate/// Returns true when [`Look::WordAsciiNegate`] is satisfied `at` the givenis_word_unicode/// Returns true when [`Look::WordUnicode`] is satisfied `at` the given/// This returns an error when Unicode word boundary tables/// are not available. Specifically, this only occurs when the/// `unicode-word-boundary` feature is not enabled.is_word_unicode_negate/// Returns true when [`Look::WordUnicodeNegate`] is satisfied `at` the/// given position in `haystack`.is_word_start_ascii/// Returns true when [`Look::WordStartAscii`] is satisfied `at` the givenis_word_end_ascii/// Returns true when [`Look::WordEndAscii`] is satisfied `at` the givenis_word_start_unicode/// Returns true when [`Look::WordStartUnicode`] is satisfied `at` theis_word_end_unicode/// Returns true when [`Look::WordEndUnicode`] is satisfied `at` theis_word_start_half_ascii/// Returns true when [`Look::WordStartHalfAscii`] is satisfied `at` theis_word_end_half_ascii/// Returns true when [`Look::WordEndHalfAscii`] is satisfied `at` theis_word_start_half_unicode/// Returns true when [`Look::WordStartHalfUnicode`] is satisfied `at` theis_word_end_half_unicode/// Returns true when [`Look::WordEndHalfUnicode`] is satisfied `at` the/// An error that occurs when the Unicode-aware `\w` class is unavailable./// This error can occur when the data tables necessary for the Unicode aware/// Perl character class `\w` are unavailable. The `\w` class is used to/// determine whether a codepoint is considered a word character or not when/// determining whether a Unicode aware `\b` (or `\B`) matches at a particular/// This error can only occur when the `unicode-word-boundary` feature is/// Returns an error if and only if Unicode word boundary data is/// unavailable.try_is_word_characteris_word_char/// A module that looks for word codepoints using regex-syntax's data tables.testlooklook_matches_start_linelook_matches_end_linelook_matches_start_textlook_matches_end_textlook_matches_word_unicodelook_matches_word_asciilook_matches_word_unicode_negatelook_matches_word_ascii_negatelook_matches_word_start_asciilook_matches_word_end_asciilook_matches_word_start_unicodelook_matches_word_end_unicodelook_matches_word_start_half_asciilook_matches_word_end_half_asciilook_matches_word_start_half_unicodelook_matches_word_end_half_unicodelook_setlook_set_iterlook_set_debug/*!
Types and routines for working with look-around assertions.

This module principally defines two types:

* [`Look`] enumerates all of the assertions supported by this crate.
* [`LookSet`] provides a way to efficiently store a set of [`Look`] values.
* [`LookMatcher`] provides routines for checking whether a `Look` or a
`LookSet` matches at a particular position in a haystack.
*/// LAMENTATION: Sadly, a lot of the API of `Look` and `LookSet` were basically// copied verbatim from the regex-syntax crate. I would have no problems using// the regex-syntax types and defining the matching routines (only found// in this crate) as free functions, except the `Look` and `LookSet` types// are used in lots of places. Including in places we expect to work when// regex-syntax is *not* enabled, such as in the definition of the NFA itself.// Thankfully the code we copy is pretty simple and there isn't much of it.// Otherwise, the rest of this module deals with *matching* the assertions,// which is not something that regex-syntax handles.// Below are FOUR different ways for checking whether whether a "word"// codepoint exists at a particular position in the haystack. The four// different approaches are, in order of preference:// 1. Parse '\w', convert to an NFA, convert to a fully compiled DFA on the// first call, and then use that DFA for all subsequent calls.// 2. Do UTF-8 decoding and use regex_syntax::is_word_character if available.// 3. Do UTF-8 decoding and use our own 'perl_word' table.// 4. Return an error.// The reason for all of these approaches is a combination of perf and// permitting one to build regex-automata without the Unicode data necessary// for handling Unicode-aware word boundaries. (In which case, '(?-u:\b)' would// still work.)// The DFA approach is the fastest, but it requires the regex parser, the// NFA compiler, the DFA builder and the DFA search runtime. That's a lot to// bring in, but if it's available, it's (probably) the best we can do.// Approaches (2) and (3) are effectively equivalent, but (2) reuses the// data in regex-syntax and avoids duplicating it in regex-automata.// Finally, (4) unconditionally returns an error since the requisite data isn't// available anywhere.// There are actually more approaches possible that we didn't implement. For// example, if the DFA builder is available but the syntax parser is not, we// could technically hand construct our own NFA from the 'perl_word' data// table. But to avoid some pretty hairy code duplication, we would in turn// need to pull the UTF-8 compiler out of the NFA compiler. Yikes.// A possibly more sensible alternative is to use a lazy DFA when the full// DFA builder isn't available...// Yet another choice would be to build the full DFA and then embed it into the// source. Then we'd only need to bring in the DFA search runtime, which is// considerably smaller than the DFA builder code. The problem here is that the// Debian people have spooked me[1] into avoiding cyclic dependencies. Namely,// we'd need to build regex-cli, which depends on regex-automata in order to// build some part of regex-automata. But to be honest, something like this has// to be allowed somehow? I just don't know what the right process is.// There are perhaps other choices as well. Why did I stop at these 4? Because// I wanted to preserve my sanity. I suspect I'll wind up adding the lazy DFA// approach eventually, as the benefits of the DFA approach are somewhat// compelling. The 'boundary-words-holmes' benchmark tests this. (Note that// the commands below no longer work. If necessary, we should re-capitulate// the benchmark from whole cloth in rebar.)//   $ regex-cli bench measure -f boundary-words-holmes -e pikevm > dfa.csv// Then I changed the code below so that the util/unicode_data/perl_word table// was used and re-ran the benchmark://   $ regex-cli bench measure -f boundary-words-holmes -e pikevm > table.csv// And compared them://   $ regex-cli bench diff dfa.csv table.csv//   benchmark                             engine                 dfa        table//   ---------                             ------                 ---        -----//   internal/count/boundary-words-holmes  regex/automata/pikevm  18.6 MB/s  12.9 MB/s// Which is a nice improvement.// UPDATE: It turns out that it takes approximately 22ms to build the reverse// DFA for \w. (And about 3ms for the forward DFA.) It's probably not much in// the grand scheme things, but that is a significant latency cost. So I'm not// sure that's a good idea. I then tried using a lazy DFA instead, and that// eliminated the overhead, but since the lazy DFA requires mutable working// memory, that requires introducing a 'Cache' for every simultaneous call.// I ended up deciding for now to just keep the "UTF-8 decode and check the// table." The DFA and lazy DFA approaches are still below, but commented out.// [1]: https://github.com/BurntSushi/ucd-generate/issues/11/*
/// A module that looks for word codepoints using lazy DFAs.
#[cfg(all(
    feature = "unicode-word-boundary",
    feature = "syntax",
    feature = "unicode-perl",
    feature = "hybrid"
))]
mod is_word_char {
    use alloc::vec::Vec;

    use crate::{
        hybrid::dfa::{Cache, DFA},
        nfa::thompson::NFA,
        util::{lazy::Lazy, pool::Pool, primitives::StateID},
        Anchored, Input,
    };

    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
        Ok(())
    }

    #[cfg_attr(feature = "perf-inline", inline(always))]
    pub(super) fn fwd(
        haystack: &[u8],
        mut at: usize,
    ) -> Result<bool, super::UnicodeWordBoundaryError> {
        static WORD: Lazy<DFA> = Lazy::new(|| DFA::new(r"\w").unwrap());
        static CACHE: Lazy<Pool<Cache>> =
            Lazy::new(|| Pool::new(|| WORD.create_cache()));
        let dfa = Lazy::get(&WORD);
        let mut cache = Lazy::get(&CACHE).get();
        let mut sid = dfa
            .start_state_forward(
                &mut cache,
                &Input::new("").anchored(Anchored::Yes),
            )
            .unwrap();
        while at < haystack.len() {
            let byte = haystack[at];
            sid = dfa.next_state(&mut cache, sid, byte).unwrap();
            at += 1;
            if sid.is_tagged() {
                if sid.is_match() {
                    return Ok(true);
                } else if sid.is_dead() {
                    return Ok(false);
                }
            }
        }
        Ok(dfa.next_eoi_state(&mut cache, sid).unwrap().is_match())
    }

    #[cfg_attr(feature = "perf-inline", inline(always))]
    pub(super) fn rev(
        haystack: &[u8],
        mut at: usize,
    ) -> Result<bool, super::UnicodeWordBoundaryError> {
        static WORD: Lazy<DFA> = Lazy::new(|| {
            DFA::builder()
                .thompson(NFA::config().reverse(true))
                .build(r"\w")
                .unwrap()
        });
        static CACHE: Lazy<Pool<Cache>> =
            Lazy::new(|| Pool::new(|| WORD.create_cache()));
        let dfa = Lazy::get(&WORD);
        let mut cache = Lazy::get(&CACHE).get();
        let mut sid = dfa
            .start_state_reverse(
                &mut cache,
                &Input::new("").anchored(Anchored::Yes),
            )
            .unwrap();
        while at > 0 {
            at -= 1;
            let byte = haystack[at];
            sid = dfa.next_state(&mut cache, sid, byte).unwrap();
            if sid.is_tagged() {
                if sid.is_match() {
                    return Ok(true);
                } else if sid.is_dead() {
                    return Ok(false);
                }
            }
        }
        Ok(dfa.next_eoi_state(&mut cache, sid).unwrap().is_match())
    }
}
*//*
/// A module that looks for word codepoints using fully compiled DFAs.
#[cfg(all(
    feature = "unicode-word-boundary",
    feature = "syntax",
    feature = "unicode-perl",
    feature = "dfa-build"
))]
mod is_word_char {
    use alloc::vec::Vec;

    use crate::{
        dfa::{dense::DFA, Automaton, StartKind},
        nfa::thompson::NFA,
        util::{lazy::Lazy, primitives::StateID},
        Anchored, Input,
    };

    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
        Ok(())
    }

    #[cfg_attr(feature = "perf-inline", inline(always))]
    pub(super) fn fwd(
        haystack: &[u8],
        mut at: usize,
    ) -> Result<bool, super::UnicodeWordBoundaryError> {
        static WORD: Lazy<(DFA<Vec<u32>>, StateID)> = Lazy::new(|| {
            let dfa = DFA::builder()
                .configure(DFA::config().start_kind(StartKind::Anchored))
                .build(r"\w")
                .unwrap();
            // OK because our regex has no look-around.
            let start_id = dfa.universal_start_state(Anchored::Yes).unwrap();
            (dfa, start_id)
        });
        let &(ref dfa, mut sid) = Lazy::get(&WORD);
        while at < haystack.len() {
            let byte = haystack[at];
            sid = dfa.next_state(sid, byte);
            at += 1;
            if dfa.is_special_state(sid) {
                if dfa.is_match_state(sid) {
                    return Ok(true);
                } else if dfa.is_dead_state(sid) {
                    return Ok(false);
                }
            }
        }
        Ok(dfa.is_match_state(dfa.next_eoi_state(sid)))
    }

    #[cfg_attr(feature = "perf-inline", inline(always))]
    pub(super) fn rev(
        haystack: &[u8],
        mut at: usize,
    ) -> Result<bool, super::UnicodeWordBoundaryError> {
        static WORD: Lazy<(DFA<Vec<u32>>, StateID)> = Lazy::new(|| {
            let dfa = DFA::builder()
                .configure(DFA::config().start_kind(StartKind::Anchored))
                // From ad hoc measurements, it looks like setting
                // shrink==false is slightly faster than shrink==true. I kind
                // of feel like this indicates that shrinking is probably a
                // failure, although it can help in some cases. Sigh.
                .thompson(NFA::config().reverse(true).shrink(false))
                .build(r"\w")
                .unwrap();
            // OK because our regex has no look-around.
            let start_id = dfa.universal_start_state(Anchored::Yes).unwrap();
            (dfa, start_id)
        });
        let &(ref dfa, mut sid) = Lazy::get(&WORD);
        while at > 0 {
            at -= 1;
            let byte = haystack[at];
            sid = dfa.next_state(sid, byte);
            if dfa.is_special_state(sid) {
                if dfa.is_match_state(sid) {
                    return Ok(true);
                } else if dfa.is_dead_state(sid) {
                    return Ok(false);
                }
            }
        }
        Ok(dfa.is_match_state(dfa.next_eoi_state(sid)))
    }
}
*//*!
This module defines simple wrapper routines for the memchr functions from the
`memchr` crate. Basically, when the `memchr` crate is available, we use it,
otherwise we use a naive implementation which is still pretty fast.
*/unicode_data/*!
A collection of modules that provide APIs that are useful across many regex
engines.

While one should explore the sub-modules directly to get a sense of what's
there, here are some highlights that tie the sub-modules to higher level
use cases:

* `alphabet` contains APIs that are useful if you're doing low level things
with the DFAs in this crate. For example, implementing determinization or
walking its state graph directly.
* `captures` contains APIs for dealing with capture group matches and their
mapping to "slots" used inside an NFA graph. This is also where you can find
iterators over capture group names.
* `escape` contains types for pretty-printing raw byte slices as strings.
* `iter` contains API helpers for writing regex iterators.
* `lazy` contains a no-std and no-alloc variant of `lazy_static!` and
`once_cell`.
* `look` contains APIs for matching and configuring look-around assertions.
* `pool` provides a way to reuse mutable memory allocated in a thread safe
manner.
* `prefilter` provides APIs for building prefilters and using them in searches.
* `primitives` are what you might use if you're doing lower level work on
automata, such as walking an NFA state graph.
* `syntax` provides some higher level convenience functions for interacting
with the `regex-syntax` crate.
* `wire` is useful if you're working with DFA serialization.
*//// A thread safe pool that works in an `alloc`-only context./// Getting a value out comes with a guard. When that guard is dropped, the/// value is automatically put back in the pool. The guard provides both a/// `Deref` and a `DerefMut` implementation for easy access to an underlying/// A `Pool` impls `Sync` when `T` is `Send` (even if `T` is not `Sync`). This/// is possible because a pool is guaranteed to provide a value to exactly one/// thread at any time./// Currently, a pool never contracts in size. Its size is proportional to the/// maximum number of simultaneous uses. This may change in the future./// A `Pool` is a particularly useful data structure for this crate because/// many of the regex engines require a mutable "cache" in order to execute/// a search. Since regexes themselves tend to be global, the problem is then:/// how do you get a mutable cache to execute a search? You could:/// 1. Use a `thread_local!`, which requires the standard library and requires/// that the regex pattern be statically known./// 2. Use a `Pool`./// 3. Make the cache an explicit dependency in your code and pass it around./// 4. Put the cache state in a `Mutex`, but this means only one search can/// execute at a time./// 5. Create a new cache for every search./// A `thread_local!` is perhaps the best choice if it works for your use case./// Putting the cache in a mutex or creating a new cache for every search are/// perhaps the worst choices. Of the remaining two choices, whether you use/// this `Pool` or thread through a cache explicitly in your code is a matter/// of taste and depends on your code architecture./// When this crate is compiled _without_ the `std` feature, then this type/// This example shows how to share a single hybrid regex among multiple/// threads, while also safely getting exclusive access to a hybrid's/// [`Cache`](crate::hybrid::regex::Cache) without preventing other searches/// from running while your thread uses the `Cache`.///     hybrid::regex::{Cache, Regex},///     util::{lazy::Lazy, pool::Pool},/// static RE: Lazy<Regex> =///     Lazy::new(|| Regex::new("foo[0-9]+bar").unwrap());/// static CACHE: Lazy<Pool<Cache>> =///     Lazy::new(|| Pool::new(|| RE.create_cache()));/// assert_eq!(expected, RE.find(&mut CACHE.get(), b"zzzfoo12345barzzz"));/// Create a new pool. The given closure is used to create values in/// the pool when necessary./// Get a value from the pool. The caller is guaranteed to have/// exclusive access to the given value. Namely, it is guaranteed that/// this will never return a value that was returned by another call to/// `get` but was not put back into the pool./// When the guard goes out of scope and its destructor is called, then/// it will automatically be put back into the pool. Alternatively,/// [`PoolGuard::put`] may be used to explicitly put it back in the pool/// without relying on its destructor./// Note that there is no guarantee provided about which value in the/// pool is returned. That is, calling get, dropping the guard (causing/// the value to go back into the pool) and then calling get again is/// *not* guaranteed to return the same value received in the first `get`/// call./// A guard that is returned when a caller requests a value from the pool./// The purpose of the guard is to use RAII to automatically put the value/// back in the pool once it's dropped./// Consumes this guard and puts it back into the pool./// This circumvents the guard's `Drop` implementation. This can be useful/// in circumstances where the automatic `Drop` results in poorer codegen,/// such as calling non-inlined functions./// An atomic counter used to allocate thread IDs./// We specifically start our counter at 3 so that we can use the values/// less than it as sentinels.THREAD_ID_UNOWNED/// A thread ID indicating that there is no owner. This is the initial/// state of a pool. Once a pool has an owner, there is no way to changeTHREAD_ID_INUSE/// A thread ID indicating that the special owner value is in use and not/// available. This state is useful for avoiding a case where the owner/// of a pool calls `get` before putting the result of a previous `get`/// call back into the pool.THREAD_ID_DROPPED/// This sentinel is used to indicate that a guard has already been dropped/// and should not be re-dropped. We use this because our drop code can be/// called outside of Drop and thus there could be a bug in the internal/// implementation that results in trying to put the same guard back into/// the same pool multiple times, and *that* could result in UB if we/// didn't mark the guard as already having been put back in the pool./// So this isn't strictly necessary, but this let's us define some/// routines as safe (like PoolGuard::put_imp) that we couldn't otherwiseMAX_POOL_STACKS/// The number of stacks we use inside of the pool. These are only used for/// non-owners. That is, these represent the "slow" path./// In the original implementation of this pool, we only used a single/// stack. While this might be okay for a couple threads, the prevalence of/// 32, 64 and even 128 core CPUs has made it untenable. The contention/// such an environment introduces when threads are doing a lot of searches/// on short haystacks (a not uncommon use case) is palpable and leads to/// huge slowdowns./// This constant reflects a change from using one stack to the number of/// stacks that this constant is set to. The stack for a particular thread/// is simply chosen by `thread_id % MAX_POOL_STACKS`. The idea behind/// this setup is that there should be a good chance that accesses to the/// pool will be distributed over several stacks instead of all of them/// converging to one./// This is not a particularly smart or dynamic strategy. Fixing this to a/// specific number has at least two downsides. First is that it will help,/// say, an 8 core CPU more than it will a 128 core CPU. (But, crucially,/// it will still help the 128 core case.) Second is that this may wind/// up being a little wasteful with respect to memory usage. Namely, if a/// regex is used on one thread and then moved to another thread, then it/// could result in creating a new copy of the data in the pool even though/// only one is actually needed./// And that memory usage bit is why this is set to 8 and not, say, 64./// Keeping it at 8 limits, to an extent, how much unnecessary memory can/// be allocated./// In an ideal world, we'd be able to have something like this:/// * Grow the number of stacks as the number of concurrent callers/// increases. I spent a little time trying this, but even just adding an/// atomic addition/subtraction for each pop/push for tracking concurrent/// callers led to a big perf hit. Since even more work would seemingly be/// required than just an addition/subtraction, I abandoned this approach./// * The maximum amount of memory used should scale with respect to the/// number of concurrent callers and *not* the total number of existing/// threads. This is primarily why the `thread_local` crate isn't used, as/// as some environments spin up a lot of threads. This led to multiple/// reports of extremely high memory usage (often described as memory/// leaks)./// * Even more ideally, the pool should contract in size. That is, it/// should grow with bursts and then shrink. But this is a pretty thorny/// issue to tackle and it might be better to just not./// * It would be nice to explore the use of, say, a lock-free stack/// instead of using a mutex to guard a `Vec` that is ultimately just/// treated as a stack. The main thing preventing me from exploring this/// is the ABA problem. The `crossbeam` crate has tools for dealing with/// this sort of problem (via its epoch based memory reclamation strategy),/// but I can't justify bringing in all of `crossbeam` as a dependency of/// `regex` for this./// See this issue for more context and discussion:/// https://github.com/rust-lang/regex/issues/934r" A thread local used to assign an ID to a thread."THREAD_IDCacheLine/// This puts each stack in the pool below into its own cache line. This is/// an absolutely critical optimization that tends to have the most impact/// in high contention workloads. Without forcing each mutex protected/// into its own cache line, high contention exacerbates the performance/// problem by causing "false sharing." By putting each mutex in its own/// cache-line, we avoid the false sharing problem and the affects of/// contention are greatly reduced./// A function to create more T values when stack is empty and a caller/// has requested a T.stacks/// Multiple stacks of T values to hand out. These are used when a Pool/// is accessed by a thread that didn't create it./// Conceptually this is `Mutex<Vec<Box<T>>>`, but sharded out to make/// it scale better under high contention work-loads. We index into/// this sequence via `thread_id % stacks.len()`./// The ID of the thread that owns this pool. The owner is the thread/// that makes the first call to 'get'. When the owner calls 'get', it/// gets 'owner_val' directly instead of returning a T from 'stack'./// See comments elsewhere for details, but this is intended to be an/// optimization for the common case that makes getting a T faster./// It is initialized to a value of zero (an impossible thread ID) as a/// sentinel to indicate that it is unowned.owner_val/// A value to return when the caller is in the same thread that/// first called `Pool::get`./// This is set to None when a Pool is first created, and set to Some/// once the first thread calls Pool::get./// A thread safe pool utilizing std-only features./// The main difference between this and the simplistic alloc-only pool is/// the use of std::sync::Mutex and an "owner thread" optimization that/// makes accesses by the owner of a pool faster than all other threads./// This makes the common case of running a regex within a single thread/// faster by avoiding mutex unlocking.// SAFETY: Since we want to use a Pool from multiple threads simultaneously// behind an Arc, we need for it to be Sync. In cases where T is sync,// Pool<T> would be Sync. However, since we use a Pool to store mutable// scratch space, we wind up using a T that has interior mutability and is// thus itself not Sync. So what we *really* want is for our Pool<T> to by// Sync even when T is not Sync (but is at least Send).// The only non-sync aspect of a Pool is its 'owner_val' field, which is// used to implement faster access to a pool value in the common case of// a pool being accessed in the same thread in which it was created. The// 'stack' field is also shared, but a Mutex<T> where T: Send is already// Sync. So we only need to worry about 'owner_val'.// The key is to guarantee that 'owner_val' can only ever be accessed from// one thread. In our implementation below, we guarantee this by only// returning the 'owner_val' when the ID of the current thread matches the// ID of the thread that first called 'Pool::get'. Since this can only ever// be one thread, it follows that only one thread can access 'owner_val' at// any point in time. Thus, it is safe to declare that Pool<T> is Sync when// T is Send.// If there is a way to achieve our performance goals using safe code, then// I would very much welcome a patch. As it stands, the implementation// below tries to balance safety with performance. The case where a Regex// is used from multiple threads simultaneously will suffer a bit since// getting a value out of the pool will require unlocking a mutex.// We require `F: Send + Sync` because we call `F` at any point on demand,// potentially from multiple threads simultaneously.// If T is UnwindSafe, then since we provide exclusive access to any// particular value in the pool, the pool should therefore also be// considered UnwindSafe.// We require `F: UnwindSafe + RefUnwindSafe` because we call `F` at any// point on demand, so it needs to be unwind safe on both dimensions for// the entire Pool to be unwind safe.// considered RefUnwindSafe./// Get a value from the pool. This may block if another thread is also/// attempting to retrieve a value from the pool.get_slow/// This is the "slow" version that goes through a mutex to pop an/// allocated value off a stack to return to the caller. (Or, if the/// stack is empty, a new value is created.)/// If the pool has no owner, then this will set the owner.put_value/// Puts a value back into the pool. Callers don't need to call this./// Once the guard that's returned by 'get' is dropped, it is put back/// into the pool automatically.guard_owned/// Create a guard that represents the special owned T.guard_stack/// Create a guard that contains a value from the pool's stack.guard_stack_transient/// Create a guard that contains a value from the pool's stack with an/// instruction to throw away the value instead of putting it back/// into the pool./// The pool that this guard is attached to./// This is Err when the guard represents the special "owned" value./// In which case, the value is retrieved from 'pool.owner_val'. And/// in the special case of `Err(THREAD_ID_DROPPED)`, it means the/// guard has been put back into the pool and should no longer be used./// When true, the value should be discarded instead of being pushed/// back into the pool. We tend to use this under high contention, and/// this allows us to avoid inflating the size of the pool. (Because/// under contention, we tend to create more values instead of waiting/// for access to a stack of existing values.)/// Return the underlying value./// Return the underlying value as a mutable borrow.put_imp/// Puts this guard back into the pool by only borrowing the guard as/// mutable. This should be called at most once.thread_owner_optimization// Tests that Pool implements the "single owner" optimization. That is, the// thread that first accesses the pool gets its own copy, while all other// threads get distinct copies.thread_owner_distinct// This tests that if the "owner" of a pool asks for two values, then it// gets two distinct values and not the same one. This test failed in the// course of developing the pool, which in turn resulted in UB because it// permitted getting aliasing &mut borrows to the same place in memory.thread_owner_sync// This tests that we can share a guard with another thread, mutate the// underlying value and everything works. This failed in the course of// developing a pool since the pool permitted 'get()' to return the same// value to the owner thread, even before the previous value was put back// into the pool. This in turn resulted in this test producing a data race.thread_owner_send_drop// This tests that if we move a PoolGuard that is owned by the current// thread to another thread and drop it, then the thread owner doesn't// change. During development of the pool, this test failed because the// PoolGuard assumed it was dropped in the same thread from which it was// created, and thus used the current thread's ID as the owner, which could// be different than the actual owner of the pool.// This module provides a relatively simple thread-safe pool of reusable// objects. For the most part, it's implemented by a stack represented by a// Mutex<Vec<T>>. It has one small trick: because unlocking a mutex is somewhat// costly, in the case where a pool is accessed by the first thread that tried// to get a value, we bypass the mutex. Here are some benchmarks showing the// difference.// 2022-10-15: These benchmarks are from the old regex crate and they aren't// easy to reproduce because some rely on older implementations of Pool that// are no longer around. I've left the results here for posterity, but any// enterprising individual should feel encouraged to re-litigate the way Pool// works. I am not at all certain it is the best approach.// 1) misc::anchored_literal_long_non_match    21 (18571 MB/s)// 2) misc::anchored_literal_long_non_match   107 (3644 MB/s)// 3) misc::anchored_literal_long_non_match    45 (8666 MB/s)// 4) misc::anchored_literal_long_non_match    19 (20526 MB/s)// (1) represents our baseline: the master branch at the time of writing when// using the 'thread_local' crate to implement the pool below.// (2) represents a naive pool implemented completely via Mutex<Vec<T>>. There// is no special trick for bypassing the mutex.// (3) is the same as (2), except it uses Mutex<Vec<Box<T>>>. It is twice as// fast because a Box<T> is much smaller than the T we use with a Pool in this// crate. So pushing and popping a Box<T> from a Vec is quite a bit faster// than for T.// (4) is the same as (3), but with the trick for bypassing the mutex in the// case of the first-to-get thread.// Why move off of thread_local? Even though (4) is a hair faster than (1)// above, this was not the main goal. The main goal was to move off of// thread_local and find a way to *simply* re-capture some of its speed for// regex's specific case. So again, why move off of it? The *primary* reason is// because of memory leaks. See https://github.com/rust-lang/regex/issues/362// for example. (Why do I want it to be simple? Well, I suppose what I mean is,// "use as much safe code as possible to minimize risk and be as sure as I can// be that it is correct.")// My guess is that the thread_local design is probably not appropriate for// regex since its memory usage scales to the number of active threads that// have used a regex, where as the pool below scales to the number of threads// that simultaneously use a regex. While neither case permits contraction,// since we own the pool data structure below, we can add contraction if a// clear use case pops up in the wild. More pressingly though, it seems that// there are at least some use case patterns where one might have many threads// sitting around that might have used a regex at one point. While thread_local// does try to reuse space previously used by a thread that has since stopped,// its maximal memory usage still scales with the total number of active// threads. In contrast, the pool below scales with the total number of threads// *simultaneously* using the pool. The hope is that this uses less memory// overall. And if it doesn't, we can hopefully tune it somehow.// It seems that these sort of conditions happen frequently// in FFI inside of other more "managed" languages. This was// mentioned in the issue linked above, and also mentioned here:// https://github.com/BurntSushi/rure-go/issues/3. And in particular, users// confirm that disabling the use of thread_local resolves the leak.// There were other weaker reasons for moving off of thread_local as well.// Namely, at the time, I was looking to reduce dependencies. And for something// like regex, maintenance can be simpler when we own the full dependency tree.// Note that I am not entirely happy with this pool. It has some subtle// implementation details and is overall still observable (even with the// thread owner optimization) in benchmarks. If someone wants to take a crack// at building something better, please file an issue. Even if it means a// different API. The API exposed by this pool is not the minimal thing that// something like a 'Regex' actually needs. It could adapt to, for example,// an API more like what is found in the 'thread_local' crate. However, we do// really need to support the no-std alloc-only context, or else the regex// crate wouldn't be able to support no-std alloc-only. However, I'm generally// okay with making the alloc-only context slower (as it is here), although I// do find it unfortunate./*!
A thread safe memory pool.

The principal type in this module is a [`Pool`]. It main use case is for
holding a thread safe collection of mutable scratch spaces (usually called
`Cache` in this crate) that regex engines need to execute a search. This then
permits sharing the same read-only regex object across multiple threads while
having a quick way of reusing scratch space in a thread safe way. This avoids
needing to re-create the scratch space for every search, which could wind up
being quite expensive.
*/acmax_needle_len/// A prefilter for accelerating regex searches./// If you already have your literals that you want to search with,/// then the vanilla [`Prefilter::new`] constructor is for you. But/// if you have an [`Hir`] value from the `regex-syntax` crate, then/// [`Prefilter::from_hir_prefix`] might be more convenient. Namely, it uses/// the [`regex-syntax::hir::literal`](regex_syntax::hir::literal) module to/// extract literal prefixes for you, optimize them and then select and build a/// prefilter matcher./// A prefilter must have **zero false negatives**. However, by its very/// nature, it may produce false positives. That is, a prefilter will never/// skip over a position in the haystack that corresponds to a match of the/// original regex pattern, but it *may* produce a match for a position/// in the haystack that does *not* correspond to a match of the original/// regex pattern. If you use either the [`Prefilter::from_hir_prefix`] or/// [`Prefilter::from_hirs_prefix`] constructors, then this guarantee is/// upheld for you automatically. This guarantee is not preserved if you use/// [`Prefilter::new`] though, since it is up to the caller to provide correct/// literal strings with respect to the original regex pattern./// It is an API guarantee that cloning a prefilter is cheap. That is, cloning/// it will not duplicate whatever heap memory is used to represent the/// underlying matcher./// This example shows how to attach a `Prefilter` to the/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) in order to accelerate/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["Bruce "])///     .configure(PikeVM::config().prefilter(Some(pre)))///     Some(Match::must(0, 6..23)),///     re.find(&mut cache, "Hello Bruce Springsteen!"),/// But note that if you get your prefilter incorrect, it could lead to an/// incorrect result!/// // This prefilter is wrong!/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["Patti "])/// // We find no match even though the regex does match./// Create a new prefilter from a sequence of needles and a corresponding/// match semantics./// This may return `None` for a variety of reasons, for example, if/// a suitable prefilter could not be constructed. That might occur/// if they are unavailable (e.g., the `perf-literal-substring` and/// `perf-literal-multisubstring` features aren't enabled), or it might/// occur because of heuristics or other artifacts of how the prefilter/// works./// Note that if you have an [`Hir`] expression, it may be more convenient/// to use [`Prefilter::from_hir_prefix`]. It will automatically handle the/// task of extracting prefix literals for you./// This example shows how match semantics can impact the matching/// algorithm used by the prefilter. For this reason, it is important to/// ensure that the match semantics given here are consistent with the/// match semantics intended for the regular expression that the literals/// were extracted from.///     util::{prefilter::Prefilter, syntax},///     MatchKind, Span,/// let hay = "Hello samwise";/// // With leftmost-first, we find 'samwise' here because it comes/// // before 'sam' in the sequence we give it../// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["samwise", "sam"])///     Some(Span::from(6..13)),///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),/// // Still with leftmost-first but with the literals reverse, now 'sam'/// // will match instead!/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["sam", "samwise"])///     Some(Span::from(6..9)),/// This turns a prefilter selection into a `Prefilter`. That is, in turns/// the enum given into a trait object.from_hir_prefix/// This attempts to extract prefixes from the given `Hir` expression for/// the given match semantics, and if possible, builds a prefilter for/// This example shows how to build a prefilter directly from an [`Hir`]/// expression, and use to find an occurrence of a prefix from the regex/// let hir = syntax::parse(r"(Bruce|Patti) \w+")?;/// let pre = Prefilter::from_hir_prefix(MatchKind::LeftmostFirst, &hir)/// let hay = "Hello Patti Scialfa!";from_hirs_prefix/// This attempts to extract prefixes from the given `Hir` expressions for/// Note that as of now, prefilters throw away information about which/// pattern each literal comes from. In other words, when a prefilter finds/// a match, there's no way to know which pattern (or patterns) it came/// from. Therefore, in order to confirm a match, you'll have to check all/// of the patterns by running the full regex engine./// This example shows how to build a prefilter directly from multiple/// `Hir` expressions expression, and use it to find an occurrence of a/// prefix from the regex patterns./// let hirs = syntax::parse_many(&[///     r"(Bruce|Patti) \w+",///     r"Mrs?\. Doubtfire",/// let pre = Prefilter::from_hirs_prefix(MatchKind::LeftmostFirst, &hirs)/// let hay = "Hello Mrs. Doubtfire";///     Some(Span::from(6..20)),/// Run this prefilter on `haystack[span.start..end]` and return a matching/// span if one exists./// The span returned is guaranteed to have a start position greater than/// or equal to the one given, and an end position less than or equal to/// the one given./// expression, and use it to find an occurrence of a prefix from the regex/// let hir = syntax::parse(r"Bruce \w+")?;/// Returns the span of a prefix of `haystack[span.start..span.end]` if/// the prefilter matches./// The span returned is guaranteed to have a start position equivalent to/// the one given, and an end position less than or equal to the one given./// pattern that begins at the start of a haystack only./// // Nothing is found here because 'Bruce' does/// // not occur at the beginning of our search.///     pre.prefix(hay.as_bytes(), Span::from(0..hay.len())),/// // But if we change where we start the search/// // to begin where 'Bruce ' begins, then a/// // match will be found.///     pre.prefix(hay.as_bytes(), Span::from(6..hay.len())),/// Returns the heap memory, in bytes, used by the underlying prefilter./// Return the length of the longest needle/// in this Prefilter/// Implementations might return true here if they believe themselves to/// be "fast." The concept of "fast" is deliberately left vague, but in/// practice this usually corresponds to whether it's believed that SIMD/// will be used./// Why do we care about this? Well, some prefilter tricks tend to come/// with their own bits of overhead, and so might only make sense if we/// know that a scan will be *much* faster than the regex engine itself./// Otherwise, the trick may not be worth doing. Whether something is/// "much" faster than the regex engine generally boils down to whether/// SIMD is used. (But not always. Even a SIMD matcher with a high false/// positive rate can become quite slow.)/// Even if this returns true, it is still possible for the prefilter to/// be "slow." Remember, prefilters are just heuristics. We can't really/// *know* a prefilter will be fast without actually trying the prefilter./// (Which of course we cannot afford to do.)/// be "fast." See [`Prefilter::is_fast`] for more details./// A trait for abstracting over prefilters. Basically, a prefilter is/// something that do an unanchored *and* an anchored search in a haystack/// within a given span./// This exists pretty much only so that we can use prefilters as a trait/// object (which is what `Prefilter` is). If we ever move off of trait objects/// and to an enum, then it's likely this trait could be removed./// A type that encapsulates the selection of a prefilter algorithm from a/// sequence of needles./// The existence of this type is a little tricky, because we don't (currently)/// use it for performing a search. Instead, we really only consume it by/// converting the underlying prefilter into a trait object, whether that be/// `dyn PrefilterI` or `dyn Strategy` (for the meta regex engine). In order/// to avoid re-copying the prefilter selection logic, we isolate it here, and/// then force anything downstream that wants to convert it to a trait object/// to do trivial case analysis on it./// One wonders whether we *should* use an enum instead of a trait object./// At time of writing, I chose trait objects based on instinct because 1) I/// knew I wasn't going to inline anything and 2) there would potentially be/// many different choices. However, as of time of writing, I haven't actually/// compared the trait object approach to the enum approach. That probably/// should be litigated, but I ran out of steam./// Note that if the `alloc` feature is disabled, then values of this type/// are (and should) never be constructed. Also, in practice, for any of the/// prefilters to be selected, you'll need at least one of the `perf-literal-*`/// features enabled./// Select what is believed to be the best prefilter algorithm for the/// match semantics and sequence of needles given./// This selection algorithm uses the needles as given without any/// modification. For example, if `[bar]` is given, then this doesn't/// try to select `memchr` for `b`. Instead, it would select `memmem`/// for `bar`. If callers would want `memchr` selected for `[bar]`, then/// callers should massages the literals themselves. That is, callers are/// responsible for heuristics surrounding which sequence of literals is/// best./// What this selection algorithm does is attempt to use the fastest/// prefilter that works for the literals given. So if `[a, b]`, is given,/// then `memchr2` is selected./// Of course, which prefilter is selected is also subject to what/// is available. For example, if `alloc` isn't enabled, then/// that limits which prefilters can be selected. Similarly, if/// `perf-literal-substring` isn't enabled, then nothing from the `memchr`/// crate can be returned./// Extracts all of the prefix literals from the given HIR expressions into a/// single `Seq`. The literals in the sequence are ordered with respect to the/// order of the given HIR expressions and consistent with the match semantics/// The sequence returned is "optimized." That is, they may be shrunk or even/// truncated according to heuristics with the intent of making them more/// useful as a prefilter. (Which translates to both using faster algorithms/// and minimizing the false positive rate.)/// Note that this erases any connection between the literals and which pattern/// (or patterns) they came from./// The match kind given must correspond to the match semantics of the regex/// that is represented by the HIRs given. The match semantics may change the/// literal sequence returned./// Like `prefixes`, but for all suffixes of all matches for the given HIRs./*!
Defines a prefilter for accelerating regex searches.

A prefilter can be created by building a [`Prefilter`] value.

A prefilter represents one of the most important optimizations available for
accelerating regex searches. The idea of a prefilter is to very quickly find
candidate locations in a haystack where a regex _could_ match. Once a candidate
is found, it is then intended for the regex engine to run at that position to
determine whether the candidate is a match or a false positive.

In the aforementioned description of the prefilter optimization also lay its
demise. Namely, if a prefilter has a high false positive rate and it produces
lots of candidates, then a prefilter can overall make a regex search slower.
It can run more slowly because more time is spent ping-ponging between the
prefilter search and the regex engine attempting to confirm each candidate as
a match. This ping-ponging has overhead that adds up, and is exacerbated by
a high false positive rate.

Nevertheless, the optimization is still generally worth performing in most
cases. Particularly given just how much throughput can be improved. (It is not
uncommon for prefilter optimizations to improve throughput by one or two orders
of magnitude.)

Typically a prefilter is used to find occurrences of literal prefixes from a
regex pattern, but this isn't required. A prefilter can be used to look for
suffixes or even inner literals.

Note that as of now, prefilters throw away information about which pattern
each literal comes from. In other words, when a prefilter finds a match,
there's no way to know which pattern (or patterns) it came from. Therefore,
in order to confirm a match, you'll have to check all of the patterns by
running the full regex engine.
*//// The actual Teddy searcher./// Technically, it's possible that Teddy doesn't actually get used, since/// Teddy does require its haystack to at least be of a certain size/// (usually around the size of whatever vector is being used, so ~16/// or ~32 bytes). For haystacks shorter than that, the implementation/// currently uses Rabin-Karp.anchored_ac/// When running an anchored search, the packed searcher can't handle it so/// we defer to Aho-Corasick itself. Kind of sad, but changing the packed/// searchers to support anchored search would be difficult at worst and/// annoying at best. Since packed searchers only apply to small numbers of/// literals, we content ourselves that this is not much of an added cost./// (That packed searchers only work with a small number of literals is/// also why we use a DFA here. Otherwise, the memory usage of a DFA would/// likely be unacceptable.)/// The length of the smallest literal we look for./// We use this as a heuristic to figure out whether this will be "fast" or/// not. Generally, the longer the better, because longer needles are more/// discriminating and thus reduce false positive rate./// A `usize` that can never be `usize::MAX`./// This is similar to `core::num::NonZeroUsize`, but instead of not permitting/// a zero value, this does not permit a max value./// This is useful in certain contexts where one wants to optimize the memory/// usage of things that contain match offsets. Namely, since Rust slices/// are guaranteed to never have a length exceeding `isize::MAX`, we can use/// `usize::MAX` as a sentinel to indicate that no match was found. Indeed,/// types like `Option<NonMaxUsize>` have exactly the same size in memory as a/// `usize`./// This type is defined to be `repr(transparent)` for/// `core::num::NonZeroUsize`, which is in turn defined to be/// `repr(transparent)` for `usize`./// Create a new `NonMaxUsize` from the given value./// This returns `None` only when the given value is equal to `usize::MAX`./// Return the underlying `usize` value. The returned value is guaranteed/// to not equal `usize::MAX`.// We provide our own Debug impl because seeing the internal repr can be quite// surprising if you aren't expecting it. e.g., 'NonMaxUsize(5)' vs just '5'./// it will always fit in a `usize`, `u32` and a `i32`./// The identifier of a regex pattern, represented by a [`SmallIndex`]./// The identifier for a pattern corresponds to its relative position among/// other patterns in a single finite state machine. Namely, when building/// a multi-pattern regex engine, one must supply a sequence of patterns to/// match. The position (starting at 0) of each pattern in that sequence/// represents its identifier. This identifier is in turn used to identify and/// report matches of that pattern in various APIs./// See the [`SmallIndex`] type for more information about what it means for/// a pattern ID to be a "small index."/// Note that this type is defined in the/// [`util::primitives`](crate::util::primitives) module, but it is also/// re-exported at the crate root due to how common it is./// The identifier of a finite automaton state, represented by a/// [`SmallIndex`]./// Most regex engines in this crate are built on top of finite automata. Each/// state in a finite automaton defines transitions from its state to another./// Those transitions point to other states via their identifiers, i.e., a/// `StateID`. Since finite automata tend to contain many transitions, it is/// much more memory efficient to define state IDs as small indices./// a state ID to be a "small index."r" Return the internal value as a i32`. This is guaranteed to"r" This error occurs when a value could not be constructed."/*!
Lower level primitive types that are useful in a variety of circumstances.

# Overview

This list represents the principle types in this module and briefly describes
when you might want to use them.

* [`PatternID`] - A type that represents the identifier of a regex pattern.
This is probably the most widely used type in this module (which is why it's
also re-exported in the crate root).
* [`StateID`] - A type the represents the identifier of a finite automaton
state. This is used for both NFAs and DFAs, with the notable exception of
the hybrid NFA/DFA. (The hybrid NFA/DFA uses a special purpose "lazy" state
identifier.)
* [`SmallIndex`] - The internal representation of both a `PatternID` and a
`StateID`. Its purpose is to serve as a type that can index memory without
being as big as a `usize` on 64-bit targets. The main idea behind this type
is that there are many things in regex engines that will, in practice, never
overflow a 32-bit integer. (For example, like the number of patterns in a regex
or the number of states in an NFA.) Thus, a `SmallIndex` can be used to index
memory without peppering `as` casts everywhere. Moreover, it forces callers
to handle errors in the case where, somehow, the value would otherwise overflow
either a 32-bit integer or a `usize` (e.g., on 16-bit targets).
* [`NonMaxUsize`] - Represents a `usize` that cannot be `usize::MAX`. As a
result, `Option<NonMaxUsize>` has the same size in memory as a `usize`. This
useful, for example, when representing the offsets of submatches since it
reduces memory usage by a factor of 2. It is a legal optimization since Rust
guarantees that slices never have a length that exceeds `isize::MAX`.
*//// The parameters for a regex search including the haystack to search./// It turns out that regex searches have a few parameters, and in most cases,/// those parameters have defaults that work in the vast majority of cases./// This `Input` type exists to make that common case seamnless while also/// providing an avenue for changing the parameters of a search. In particular,/// this type enables doing so without a combinatorial explosion of different/// methods and/or superfluous parameters in the common cases./// An `Input` permits configuring the following things:/// * Search only a substring of a haystack, while taking the broader context/// into account for resolving look-around assertions./// * Indicating whether to search for all patterns in a regex, or to/// only search for one pattern in particular./// * Whether to perform an anchored on unanchored search./// * Whether to report a match as early as possible./// All of these parameters, except for the haystack, have sensible default/// values. This means that the minimal search configuration is simply a call/// to [`Input::new`] with your haystack. Setting any other parameter is/// optional./// Moreover, for any `H` that implements `AsRef<[u8]>`, there exists a/// `From<H> for Input` implementation. This is useful because many of the/// search APIs in this crate accept an `Into<Input>`. This means you can/// provide string or byte strings to these routines directly, and they'll/// automatically get converted into an `Input` for you./// The lifetime parameter `'h` refers to the lifetime of the haystack./// # Organization/// The API of `Input` is split into a few different parts:/// * A builder-like API that transforms a `Input` by value. Examples:/// [`Input::span`] and [`Input::anchored`]./// * A setter API that permits mutating parameters in place. Examples:/// [`Input::set_span`] and [`Input::set_anchored`]./// * A getter API that permits retrieving any of the search parameters./// Examples: [`Input::get_span`] and [`Input::get_anchored`]./// * A few convenience getter routines that don't conform to the above naming/// pattern due to how common they are. Examples: [`Input::haystack`],/// [`Input::start`] and [`Input::end`]./// * Miscellaneous predicates and other helper routines that are useful/// in some contexts. Examples: [`Input::is_char_boundary`]./// A `Input` exposes so much because it is meant to be used by both callers of/// regex engines _and_ implementors of regex engines. A constraining factor is/// that regex engines should accept a `&Input` as its lowest level API, which/// means that implementors should only use the "getter" APIs of a `Input`./// the start bound is exactly one greater than the start bound./// Note that while `Input` is used for reverse searches in this crate, the/// `Input::is_done` predicate assumes a forward search. Because unsigned/// offsets are used internally, there is no way to tell from only the offsets/// whether a reverse search is done or not./// # Regex engine support/// Any regex engine accepting an `Input` must support at least the following/// things:/// * Searching a `&[u8]` for matches./// * Searching a substring of `&[u8]` for a match, such that any match/// reported must appear entirely within that substring./// * For a forwards search, a match should never be reported when/// [`Input::is_done`] returns true. (For reverse searches, termination should/// be handled outside of `Input`.)/// Supporting other aspects of an `Input` are optional, but regex engines/// should handle aspects they don't support gracefully. How this is done is/// generally up to the regex engine. This crate generally treats unsupported/// anchored modes as an error to report for example, but for simplicity, in/// the meta regex engine, trying to search with an invalid pattern ID just/// results in no match being reported./// This routine does not panic if the span given is not a valid range for/// this search's haystack. If this search is run with an invalid range,/// then the most likely outcome is that the actual search execution will/// match is reported or not. This is particularly relevant for look-around/// operators, which might take things outside of the span into account/// when determining whether they match./// // Look for 'at', but as a distinct word./// let re = PikeVM::new(r"\bat\b")?;/// // Our haystack contains 'at', but not as a distinct word./// let haystack = "batter";/// // A standard search finds nothing, as expected./// // But if we wanted to search starting at position '1', we might/// // slice the haystack. If we do this, it's impossible for the \b/// // anchors to take the surrounding context into account! And thus,/// // a match is produced./// let input = Input::new(&haystack[1..3]);/// assert_eq!(Some(Match::must(0, 0..2)), caps.get_match());/// // But if we specify the span of the search instead of slicing the/// // haystack, then the regex engine can "see" outside of the span/// // and resolve the anchors correctly./// let input = Input::new(haystack).span(1..3);/// This may seem a little ham-fisted, but this scenario tends to come up/// if some other regex engine found the match span and now you need to/// re-process that span to look for capturing groups. (e.g., Run a faster/// DFA first, find a match, then run the PikeVM on just the match span to/// resolve capturing groups.) In order to implement that sort of logic/// correctly, you need to set the span on the search instead of slicing/// the haystack directly./// The other advantage of using this routine to specify the bounds of the/// search is that the match offsets are still reported in terms of the/// original haystack. For example, the second search in the example above/// reported a match at position `0`, even though `at` starts at offset/// `1` because we sliced the haystack./// This routine does not panic if the range given is not a valid range for/// This also panics if the given range does not correspond to valid bounds/// in the haystack or the termination of a search./// use regex_automata::Input;/// When a search is anchored (so that's [`Anchored::Yes`] or/// [`Anchored::Pattern`]), a match must begin at the start of a search./// When a search is not anchored (that's [`Anchored::No`]), regex engines/// will behave as if the pattern started with a `(?s-u:.)*?`. This prefix/// permits a match to appear anywhere./// **WARNING:** this is subtly different than using a `^` at the start of/// your regex. A `^` forces a regex to match exclusively at the start of/// a haystack, regardless of where you begin your search. In contrast,/// anchoring a search will allow your regex to match anywhere in your/// haystack, but the match must start at the beginning of a search./// For example, consider the haystack `aba` and the following searches:/// 1. The regex `^a` is compiled with `Anchored::No` and searches `aba`///    starting at position `2`. Since `^` requires the match to start at///    the beginning of the haystack and `2 > 0`, no match is found./// 2. The regex `a` is compiled with `Anchored::Yes` and searches `aba`///    starting at position `2`. This reports a match at `[2, 3]` since///    the match starts where the search started. Since there is no `^`,///    there is no requirement for the match to start at the beginning of///    the haystack./// 3. The regex `a` is compiled with `Anchored::Yes` and searches `aba`///    starting at position `1`. Since `b` corresponds to position `1` and///    since the search is anchored, it finds no match. While the regex///    matches at other positions, configuring the search to be anchored///    requires that it only report a match that begins at the same offset///    as the beginning of the search./// 4. The regex `a` is compiled with `Anchored::No` and searches `aba`///    starting at position `1`. Since the search is not anchored and///    the regex does not start with `^`, the search executes as if there///    is a `(?s:.)*?` prefix that permits it to match anywhere. Thus, it///    reports a match at `[2, 3]`./// Note that the [`Anchored::Pattern`] mode is like `Anchored::Yes`,/// except it only reports matches for a particular pattern./// a pattern that begins with `^` (as described in the above warning/// message).///     Anchored, Match, Input,/// let haystack = "aba";/// let re = PikeVM::new(r"^a")?;/// let input = Input::new(haystack).span(2..3).anchored(Anchored::No);/// // No match is found because 2 is not the beginning of the haystack,/// // which is what ^ requires./// let re = PikeVM::new(r"a")?;/// let input = Input::new(haystack).span(2..3).anchored(Anchored::Yes);/// // An anchored search can still match anywhere in the haystack, it just/// // must begin at the start of the search which is '2' in this case./// assert_eq!(Some(Match::must(0, 2..3)), caps.get_match());/// let input = Input::new(haystack).span(1..3).anchored(Anchored::Yes);/// // No match is found since we start searching at offset 1 which/// // corresponds to 'b'. Since there is no '(?s:.)*?' prefix, no match/// // is found./// let input = Input::new(haystack).span(1..3).anchored(Anchored::No);/// // Since anchored=no, an implicit '(?s:.)*?' prefix was added to the/// // pattern. Even though the search starts at 'b', the 'match anything'/// // prefix allows the search to match 'a'./// let expected = Some(Match::must(0, 2..3));/// When running a non-overlapping search, an "earliest" search will return/// the match location as early as possible. For example, given a pattern/// of `foo[0-9]+` and a haystack of `foo12345`, a normal leftmost search/// will return `foo12345` as a match. But an "earliest" search for regex/// engines that support "earliest" semantics will return `foo1` as a/// match, since as soon as the first digit following `foo` is seen, it is/// known to have found a match./// Note that "earliest" semantics generally depend on the regex engine./// Different regex engines may determine there is a match at different/// points. So there is no guarantee that "earliest" matches will always/// return the same offsets for all regex engines. The "earliest" notion/// is really about when the particular regex engine determines there is/// a match rather than a consistent semantic unto itself. This is often/// useful for implementing "did a match occur or not" predicates, but/// sometimes the offset is useful as well./// normal searching./// // A normal search implements greediness like you expect./// let input = Input::new("foo12345");/// // When 'earliest' is enabled and the regex engine supports/// // it, the search will bail once it knows a match has been/// // found./// let input = Input::new("foo12345").earliest(true);/// assert_eq!(Some(Match::must(0, 0..4)), caps.get_match());/// This also panics if the given span does not correspond to valid bounds/// This panics if the span resulting from the new start position does not/// correspond to valid bounds in the haystack or the termination of a/// This panics if the span resulting from the new end position does not/// use regex_automata::{Anchored, Input, PatternID};/// let pid = PatternID::must(5);/// input.set_anchored(Anchored::Pattern(pid));/// assert_eq!(Anchored::Pattern(pid), input.get_anchored());/// When [`Input::is_done`] is `false`, this is guaranteed to return/// an offset that is less than or equal to [`Input::end`]. Otherwise,/// the offset is one greater than [`Input::end`]./// This is guaranteed to return an offset that is a valid exclusive end/// bound for this input's haystack./// When [`Input::is_done`] is `false`, the span returned is guaranteed/// to correspond to valid bounds for this input's haystack./// use regex_automata::{Input, Span};/// When [`Input::is_done`] is `false`, the range returned is guaranteed/// Return true if and only if this search can never return any other/// This occurs when the start position of this search is greater than the/// end position of the search./// Returns true if and only if the given offset in this search's haystack/// falls on a valid UTF-8 encoded codepoint boundary./// If the haystack is not valid UTF-8, then the behavior of this routine/// This shows where codepoint boundaries do and don't exist in valid/// assert!(input.is_char_boundary(0));/// assert!(!input.is_char_boundary(1));/// assert!(!input.is_char_boundary(2));/// assert!(input.is_char_boundary(3));/// assert!(!input.is_char_boundary(4));/// A representation of a span reported by a regex engine./// of this crate. Like a range, this implements `Index` for `[u8]` and `str`,/// and `IndexMut` for `[u8]`. For convenience, this also impls `From<Range>`,/// which means things like `Span::from(5..10)` work./// The offset of the match./// For forward searches, the offset is exclusive. For reverse searches,/// the offset is inclusive./// A representation of "half" of a match reported by a DFA./// This is called a "half" match because it only includes the end location (or/// start location for a reverse search) of a match. This corresponds to the/// information that a single DFA scan can report. Getting the other half of/// the match requires a second scan with a reversed DFA./// A half match also includes the pattern that matched. The pattern is/// identified by an ID, which corresponds to its position (starting from `0`)/// relative to other patterns used to construct the corresponding DFA. If only/// a single pattern is provided to the DFA, then all matches are guaranteed to/// have a pattern ID of `0`./// Create a new half match from a pattern ID and a byte offset./// This is like [`HalfMatch::new`], but accepts a `usize` instead of a/// originally inserted into the corresponding DFA. The first pattern has/// identifier `0`, and each subsequent pattern is `1`, `2` and so on./// The position of the match./// If this match was produced by a forward search, then the offset is/// exclusive. If this match was produced by a reverse search, then the/// offset is inclusive./// A representation of a match reported by a regex engine./// corresponding regex engine. If only a single pattern is provided, then all/// Every match reported by a regex engine guarantees that its span has its/// start offset as less than or equal to its end offset./// This shows how to create a match for the first pattern in a regex/// object using convenient range syntax./// use regex_automata::{Match, PatternID};/// This shows how to create a match for the third pattern in a regex/// use regex_automata::Match;/// originally inserted into the corresponding regex engine. The first/// pattern has identifier `0`, and each subsequent pattern is `1`, `2` and/// so on./// An empty match can only be returned when the regex itself can match/// the empty string./// The number of patterns set to 'true' in this set./// A map from PatternID to boolean of whether a pattern matches or not./// This should probably be a bitset, but it's probably unlikely to matter/// much in practice./// The main downside of this representation (and similarly for a bitset)/// is that iteration scales with the capacity of the set instead of/// the length of the set. This doesn't seem likely to be a problem in/// practice./// Another alternative is to just use a 'SparseSet' for this. It does use/// more memory (quite a bit more), but that seems fine I think compared/// to the memory being used by the regex engine. The real hiccup with/// it is that it yields pattern IDs in the order they were inserted./// Which is actually kind of nice, but at the time of writing, pattern/// IDs are yielded in ascending order in the regex crate RegexSet API./// If we did change to 'SparseSet', we could provide an additional/// 'iter_match_order' iterator, but keep the ascending order one for/// A set of `PatternID`s./// A set of pattern identifiers is useful for recording which patterns have/// matched a particular haystack. A pattern set _only_ includes pattern/// identifiers. It does not include offset information./// This shows basic usage of a set./// use regex_automata::{PatternID, PatternSet};/// let pid1 = PatternID::must(5);/// let pid2 = PatternID::must(8);/// // Create a new empty set./// let mut set = PatternSet::new(10);/// // Insert pattern IDs./// set.insert(pid1);/// set.insert(pid2);/// // Test membership./// assert!(set.contains(pid1));/// assert!(set.contains(pid2));/// // Get all members.///     vec![5, 8],///     set.iter().map(|p| p.as_usize()).collect::<Vec<usize>>(),/// // Clear the set./// set.clear();/// // Test that it is indeed empty./// Create a new set of pattern identifiers with the given capacity./// The given capacity typically corresponds to (at least) the number of/// patterns in a compiled regex object./// This panics if the given capacity exceeds [`PatternID::LIMIT`]. This is/// impossible if you use the `pattern_len()` method as defined on any of/// the regex engines in this crate. Namely, a regex will fail to build by/// returning an error if the number of patterns given to it exceeds the/// limit. Therefore, the number of patterns in a valid regex is always/// a correct capacity to provide here./// Clear this set such that it contains no pattern IDs./// Return true if and only if the given pattern identifier is in this set./// Insert the given pattern identifier into this set and return `true` if/// the given pattern ID was not previously in this set./// If the pattern identifier is already in this set, then this is a no-op./// Use [`PatternSet::try_insert`] for a fallible version of this routine./// This panics if this pattern set has insufficient capacity to/// store the given pattern ID.PatternSetInsertError/// This returns an error if this pattern set has insufficient capacity to/// Return true if and only if this set has no pattern identifiers in it./// Return true if and only if this set has the maximum number of pattern/// identifiers in the set. This occurs precisely when `PatternSet::len()/// == PatternSet::capacity()`./// This particular property is useful to test because it may allow one to/// stop a search earlier than you might otherwise. Namely, if a search is/// only reporting which patterns match a haystack and if you know all of/// the patterns match at a given point, then there's no new information/// that can be learned by continuing the search. (Because a pattern set/// does not keep track of offset information.)/// Returns the total number of pattern identifiers in this set./// Returns the total number of pattern identifiers that may be stored/// This is guaranteed to be less than or equal to [`PatternID::LIMIT`]./// Typically, the capacity of a pattern set matches the number of patterns/// in a regex object with which you are searching./// Returns an iterator over all pattern identifiers in this set./// The iterator yields pattern identifiers in ascending order, starting/// at zero./*
    // This is currently commented out because it is unused and it is unclear
    // whether it's useful or not. What's the harm in having it? When, if
    // we ever wanted to change our representation to a 'SparseSet', then
    // supporting this method would be a bit tricky. So in order to keep some
    // API evolution flexibility, we leave it out for now.

    /// Remove the given pattern identifier from this set.
    ///
    /// If the pattern identifier was not previously in this set, then this
    /// does not change the set and returns `false`.
    ///
    /// # Panics
    ///
    /// This panics if `pid` exceeds the capacity of this set.
    pub fn remove(&mut self, pid: PatternID) -> bool {
        if !self.which[pid] {
            return false;
        }
        self.len -= 1;
        self.which[pid] = false;
        true
    }
    *//// An error that occurs when a `PatternID` failed to insert into a/// `PatternSet`./// An insert fails when the given `PatternID` exceeds the configured capacity/// of the `PatternSet`./// This error is created by the [`PatternSet::try_insert`] routine./// An iterator over all pattern identifiers in a [`PatternSet`]./// The lifetime parameter `'a` refers to the lifetime of the pattern set being/// iterated over./// This iterator is created by the [`PatternSet::iter`] method./// after the start position of the search./// This search can return a match for any pattern in the regex./// Run an anchored search. This means that a match must begin at the/// start position of the search./// Run an anchored search for a specific pattern. This means that a match/// must be for the given pattern and must begin at the start position of/// the search./// This is *almost* a boolean option. That is, you can either do an unanchored/// search for any pattern in a regex, or you can do an anchored search for any/// pattern in a regex./// A third option exists that, assuming the regex engine supports it, permits/// you to do an anchored search for a specific pattern./// Note that there is no way to run an unanchored search for a specific/// pattern. If you need that, you'll need to build separate regexes for each/// If a regex engine does not support the anchored mode selected, then the/// regex engine will return an error. While any non-trivial regex engine/// should support at least one of the available anchored modes, there is no/// singular mode that is guaranteed to be universally supported. Some regex/// engines might only support unanchored searches (DFAs compiled without/// anchored starting states) and some regex engines might only support/// anchored searches (like the one-pass DFA)./// The specific error returned is a [`MatchError`] with a/// [`MatchErrorKind::UnsupportedAnchored`] kind. The kind includes the/// `Anchored` value given that is unsupported./// Note that regex engines should report "no match" if, for example, an/// `Anchored::Pattern` is provided with an invalid pattern ID _but_ where/// anchored searches for a specific pattern are supported. This is smooths out/// behavior such that it's possible to guarantee that an error never occurs/// based on how the regex engine is configured. All regex engines in this/// crate report "no match" when searching for an invalid pattern ID, but where/// searching for a valid pattern ID is otherwise supported./// This example shows how to use the various `Anchored` modes to run a/// search. We use the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM)/// because it supports all modes unconditionally. Some regex engines, like/// the [`onepass::DFA`](crate::dfa::onepass::DFA) cannot support unanchored///     r"Mrs. \w+",///     r"Miss \w+",///     r"Mr. \w+",///     r"Ms. \w+",/// let hay = "Hello Mr. Springsteen!";/// // The default is to do an unanchored search./// assert_eq!(Some(Match::must(2, 6..21)), re.find(&mut cache, hay));/// // Explicitly ask for an unanchored search. Same as above./// let input = Input::new(hay).anchored(Anchored::No);/// // Now try an anchored search. Since the match doesn't start at the/// // beginning of the haystack, no match is found!/// let input = Input::new(hay).anchored(Anchored::Yes);/// // We can try an anchored search again, but move the location of where/// // we start the search. Note that the offsets reported are still in/// // terms of the overall haystack and not relative to where we started/// // the search./// let input = Input::new(hay).anchored(Anchored::Yes).range(6..);/// assert_eq!(Some(Match::must(2, 6..21)), re.find(&mut cache, input));/// // Now try an anchored search for a specific pattern. We specifically/// // choose a pattern that we know doesn't match to prove that the search/// // only looks for the pattern we provide./// let input = Input::new(hay)///     .anchored(Anchored::Pattern(PatternID::must(1)))///     .range(6..);/// // But if we switch it to the pattern that we know matches, then we find/// // the match.///     .anchored(Anchored::Pattern(PatternID::must(2)))/// Returns true if and only if this anchor mode corresponds to any kind of/// anchored search./// This examples shows that both `Anchored::Yes` and `Anchored::Pattern`/// are considered anchored searches./// use regex_automata::{Anchored, PatternID};/// assert!(Anchored::Pattern(PatternID::ZERO).is_anchored());/// Returns the pattern ID associated with this configuration if it is an/// anchored search for a specific pattern. Otherwise `None` is returned./// assert_eq!(None, Anchored::No.pattern());/// assert_eq!(None, Anchored::Yes.pattern());/// assert_eq!(Some(pid), Anchored::Pattern(pid).pattern());/// Report all possible matches./// Report only the leftmost matches. When multiple leftmost matches exist,/// report the match corresponding to the part of the regex that appears/// first in the syntax.// There is prior art in RE2 that shows that we should be able to add// LeftmostLongest too. The tricky part of it is supporting ungreedy// repetitions. Instead of treating all NFA states as having equivalent// priority (as in 'All') or treating all NFA states as having distinct// priority based on order (as in 'LeftmostFirst'), we instead group NFA// states into sets, and treat members of each set as having equivalent// priority, but having greater priority than all following members// of different sets.// However, it's not clear whether it's really worth adding this. After// all, leftmost-longest can be emulated when using literals by using// leftmost-first and sorting the literals by length in descending order.// However, this won't work for arbitrary regexes. e.g., `\w|\w\w` will// always match `a` in `ab` when using leftmost-first, but leftmost-longest// would match `ab`./// The kind of match semantics to use for a regex pattern./// The default match kind is `LeftmostFirst`, and this corresponds to the/// match semantics used by most backtracking engines, such as Perl./// # Leftmost first or "preference order" match semantics/// Leftmost-first semantics determine which match to report when there are/// multiple paths through a regex that match at the same position. The tie is/// essentially broken by how a backtracker would behave. For example, consider/// running the regex `foofoofoo|foofoo|foo` on the haystack `foofoo`. In this/// case, both the `foofoo` and `foo` branches match at position `0`. So should/// the end of the match be `3` or `6`?/// A backtracker will conceptually work by trying `foofoofoo` and failing./// Then it will try `foofoo`, find the match and stop there. Thus, the/// leftmost-first match position is `6`. This is called "leftmost-first" or/// "preference order" because the order of the branches as written in the/// regex pattern is what determines how to break the tie./// (Note that leftmost-longest match semantics, which break ties by always/// taking the longest matching string, are not currently supported by this/// crate. These match semantics tend to be found in POSIX regex engines.)/// This example shows how leftmost-first semantics work, and how it even/// applies to multi-pattern regexes:///     r"foofoofoo",///     r"foofoo",/// let got: Vec<Match> = re.find_iter(&mut cache, "foofoo").collect();/// let expected = vec![Match::must(1, 0..6)];/// # All matches/// The `All` match semantics report any and all matches, and generally will/// attempt to match as much as possible. It doesn't respect any sort of match/// priority at all, so things like non-greedy matching don't work in this/// The fact that non-greedy matching doesn't work generally makes most forms/// of unanchored non-overlapping searches have unintuitive behavior. Namely,/// unanchored searches behave as if there is a `(?s-u:.)*?` prefix at the/// beginning of the pattern, which is specifically non-greedy. Since it will/// be treated as greedy in `All` match semantics, this generally means that/// it will first attempt to consume all of the haystack and is likely to wind/// up skipping matches./// Generally speaking, `All` should only be used in two circumstances:/// * When running an anchored search and there is a desire to match as much as/// possible. For example, when building a reverse regex matcher to find the/// start of a match after finding the end. In this case, the reverse search/// is anchored to the end of the match found by the forward search./// * When running overlapping searches. Since `All` encodes all possible/// matches, this is generally what you want for an overlapping search. If you/// try to use leftmost-first in an overlapping search, it is likely to produce/// counter-intuitive results since leftmost-first specifically excludes some/// matches from its underlying finite state machine./// This example demonstrates the counter-intuitive behavior of `All` semantics/// when using a standard leftmost unanchored search:///     .build("foo")?;/// let hay = "first foo second foo wat";/// let got: Vec<Match> = re.find_iter(&mut cache, hay).collect();/// // Notice that it completely skips the first 'foo'!/// let expected = vec![Match::must(0, 17..20)];/// This second example shows how `All` semantics are useful for an overlapping/// search. Note that we use lower level lazy DFA APIs here since the NFA/// engines only currently support a very limited form of overlapping search.///     // If we didn't set 'All' semantics here, then the regex would only///     // match 'foo' at offset 3 and nothing else. Why? Because the state///     // machine implements preference order and knows that the 'foofoo' and///     // 'foofoofoo' branches can never match since 'foo' will always match///     // when they match and take priority.///     .build(r"foo|foofoo|foofoofoo")?;/// let input = Input::new("foofoofoo");/// let mut got = vec![];///     re.try_search_overlapping_fwd(&mut cache, &input, &mut state)?;///     let m = match state.get_match() {///         Some(m) => m,///     got.push(m);///     HalfMatch::must(0, 6),///     HalfMatch::must(0, 9),continue_past_first_match/// An error indicating that a search stopped before reporting whether a/// match exists or not./// To be very clear, this error type implies that one cannot assume that no/// matches occur, since the search stopped before completing. That is, if/// you're looking for information about where a search determined that no/// match can occur, then this error type does *not* give you that. (Indeed, at/// the time of writing, if you need such a thing, you have to write your own/// search routine.)/// Normally, when one searches for something, the response is either an/// affirmative "it was found at this location" or a negative "not found at/// all." However, in some cases, a regex engine can be configured to stop its/// search before concluding whether a match exists or not. When this happens,/// it may be important for the caller to know why the regex engine gave up and/// where in the input it gave up at. This error type exposes the 'why' and the/// 'where.'/// For example, the DFAs provided by this library generally cannot correctly/// implement Unicode word boundaries. Instead, they provide an option to/// eagerly support them on ASCII text (since Unicode word boundaries are/// equivalent to ASCII word boundaries when searching ASCII text), but will/// "give up" if a non-ASCII byte is seen. In such cases, one is usually/// required to either report the failure to the caller (unergonomic) or/// otherwise fall back to some other regex engine (ergonomic, but potentially/// costly)./// More generally, some regex engines offer the ability for callers to specify/// certain bytes that will trigger the regex engine to automatically quit if/// they are seen./// Still yet, there may be other reasons for a failed match. For example,/// the hybrid DFA provided by this crate can be configured to give up if it/// believes that it is not efficient. This in turn permits callers to choose a/// (Note that DFAs are configured by default to never quit or give up in this/// fashion. For example, by default, a DFA will fail to build if the regex/// pattern contains a Unicode word boundary. One needs to opt into the "quit"/// behavior via options, like/// [`hybrid::dfa::Config::unicode_word_boundary`](crate::hybrid::dfa::Config::unicode_word_boundary).)/// There are a couple other ways a search/// can fail. For example, when using the/// with a haystack that is too long, or trying to run an unanchored search/// with a [one-pass DFA](crate::dfa::onepass)./// This is a more verbose version of the kind-specific constructors,/// e.g., `MatchError::quit`./// Create a new "quit" error. The given `byte` corresponds to the value/// that tripped a search's quit condition, and `offset` corresponds to the/// location in the haystack at which the search quit./// [`MatchErrorKind::Quit`] kind./// Create a new "gave up" error. The given `offset` corresponds to the/// location in the haystack at which the search gave up./// [`MatchErrorKind::GaveUp`] kind.haystack_too_long/// Create a new "haystack too long" error. The given `len` corresponds to/// the length of the haystack that was problematic./// [`MatchErrorKind::HaystackTooLong`] kind./// Create a new "unsupported anchored" error. This occurs when the caller/// requests a search with an anchor mode that is not supported by the/// [`MatchErrorKind::UnsupportedAnchored`] kind./// The "quit" byte that was observed that caused the search to stop./// The offset at which the quit byte was observed./// The search saw a "quit" byte at which it was instructed to stop/// The offset at which the search stopped. This corresponds to the/// position immediately following the last byte scanned.GaveUp/// The search, based on heuristics, determined that it would be better/// to stop, typically to provide the caller an opportunity to use an/// alternative regex engine./// Currently, the only way for this to occur is via the lazy DFA and/// only when it is configured to do so (it will not return this error by/// default)./// The length of the haystack that exceeded the limit.HaystackTooLong/// This error occurs if the haystack given to the regex engine was too/// long to be searched. This occurs, for example, with regex engines/// like the bounded backtracker that have a configurable fixed amount of/// capacity that is tied to the length of the haystack. Anything beyond/// that configured limit will result in an error at search time./// An error indicating that a particular type of anchored search was/// requested, but that the regex engine does not support it./// Note that this error should not be returned by a regex engine simply/// because the pattern ID is invalid (i.e., equal to or exceeds the number/// of patterns in the regex). In that case, the regex engine should report/// a non-match.match_error_size// We test that our 'MatchError' type is the size we expect. This isn't an// API guarantee, but if the size increases, we really want to make sure we// decide to do that intentionally. So this should be a speed bump. And in// general, we should not increase the size without a very good reason.// Why? Because low level search APIs return Result<.., MatchError>. When// MatchError gets bigger, so to does the Result type.// Now, when 'alloc' is enabled, we do box the error, which de-emphasizes// the importance of keeping a small error type. But without 'alloc', we// still want things to be small.match_error_kind_size// Same as above, but for the underlying match error kind.incorrect_asref_guard/*!
Types and routines that support the search APIs of most regex engines.

This sub-module isn't exposed directly, but rather, its contents are exported
at the crate root due to the universality of most of the types and routines in
this module.
*//// A pairse of sparse sets./// This is useful when one needs to compute NFA epsilon closures from a/// previous set of states derived from an epsilon closure. One set can be the/// starting states where as the other set can be the destination states after/// following the transitions for a particular byte of input./// There is no significance to 'set1' or 'set2'. They are both sparse sets of/// the same size./// The members of this struct are exposed so that callers may borrow 'set1'/// and 'set2' individually without being force to borrow both at the same/// Create a new pair of sparse sets where each set has the given capacity./// This panics if the capacity given is bigger than `StateID::LIMIT`./// Resizes these sparse sets to have the new capacity given./// The sets are automatically cleared./// Clear both sparse sets./// Swap set1 with set2./// Returns the memory usage, in bytes, used by this pair of sparse sets./// The number of elements currently in this set./// Dense contains the ids in the order in which they were inserted./// Sparse maps ids to their location in dense./// A state ID is in the set if and only if/// sparse[id] < len && id == dense[sparse[id]]./// Note that these are indices into 'dense'. It's a little weird to use/// StateID here, but we know our length can never exceed the bounds of/// StateID (enforced by 'resize') and StateID will be at most 4 bytes/// where as a usize is likely double that in most cases./// A sparse set used for representing ordered NFA states./// This supports constant time addition and membership testing. Clearing an/// entire set can also be done in constant time. Iteration yields elements/// in the order in which they were inserted./// The data structure is based on: https://research.swtch.com/sparse/// Note though that we don't actually use uninitialized memory. We generally/// reuse sparse sets, so the initial allocation cost is bareable. However, its/// other properties listed above are extremely useful./// Create a new sparse set with the given capacity./// Sparse sets have a fixed size and they cannot grow. Attempting to/// insert more distinct elements than the total capacity of the set will/// result in a panic./// Resizes this sparse set to have the new capacity given./// This set is automatically cleared./// Returns the capacity of this set./// The capacity represents a fixed limit on the number of distinct/// elements that are allowed in this set. The capacity cannot be changed./// Returns the number of elements in this set./// Insert the state ID value into this set and return true if the given/// state ID was not previously in this set./// This operation is idempotent. If the given value is already in this/// set, then this is a no-op./// If more than `capacity` ids are inserted, then this panics./// This is marked as inline(always) since the compiler won't inline it/// otherwise, and it's a fairly hot piece of code in DFA determinization./// Returns true if and only if this set contains the given value./// Clear this set such that it has no members.SparseSetIter/// Returns the heap memory usage, in bytes, used by this sparse set./// An iterator over all elements in a sparse set./// The lifetime `'a` refers to the lifetime of the set being iterated over./*!
This module defines a sparse set data structure. Its most interesting
properties are:

* They preserve insertion order.
* Set membership testing is done in constant time.
* Set insertion is done in constant time.
* Clearing the set is done in constant time.

The cost for doing this is that the capacity of the set needs to be known up
front, and the elements in the set are limited to state identifiers.

These sets are principally used when traversing an NFA state graph. This
happens at search time, for example, in the PikeVM. It also happens during DFA
determinization.
*/look_behind/// The configuration used to determine a DFA's start state for a search./// A DFA has a single starting state in the typical textbook description. That/// is, it corresponds to the set of all starting states for the NFA that built/// it, along with their espsilon closures. In this crate, however, DFAs have/// many possible start states due to a few factors:/// * DFAs support the ability to run either anchored or unanchored searches./// Each type of search needs its own start state. For example, an unanchored/// search requires starting at a state corresponding to a regex with a/// `(?s-u:.)*?` prefix, which will match through anything./// * DFAs also optionally support starting an anchored search for any one/// specific pattern. Each such pattern requires its own start state./// * If a look-behind assertion like `^` or `\b` is used in the regex, then/// the DFA will need to inspect a single byte immediately before the start of/// the search to choose the correct start state./// Indeed, this configuration precisely encapsulates all of the above factors./// The [`Config::anchored`] method sets which kind of anchored search to/// perform while the [`Config::look_behind`] method provides a way to set/// the byte that occurs immediately before the start of the search./// Generally speaking, this type is only useful when you want to run searches/// without using an [`Input`]. In particular, an `Input` wants a haystack/// slice, but callers may not have a contiguous sequence of bytes as a/// haystack in all cases. This type provides a lower level of control such/// that callers can provide their own anchored configuration and look-behind/// byte explicitly./// This shows basic usage that permits running a search with a DFA without/// using the `Input` abstraction.///     util::start,/// let dfa = dense::DFA::new(r"(?-u)\b\w+\b")?;/// let haystack = "quartz";/// let config = start::Config::new().anchored(Anchored::Yes);/// let mut state = dfa.start_state(&config)?;/// for &b in haystack.as_bytes().iter() {/// This example shows how to correctly run a search that doesn't begin at/// the start of a haystack. Notice how we set the look-behind byte, and as/// a result, the `\b` assertion does not match./// let config = start::Config::new()///     .anchored(Anchored::Yes)///     .look_behind(Some(b'q'));/// for &b in haystack.as_bytes().iter().skip(1) {/// // No match!/// assert!(!dfa.is_match_state(state));/// If we had instead not set a look-behind byte, then the DFA would assume/// that it was starting at the beginning of the haystack, and thus `\b` should/// match. This in turn would result in erroneously reporting a match:/// // Whoops, forgot the look-behind byte.../// // And now we get a match unexpectedly./// Create a new default start configuration./// The default is an unanchored search that starts at the beginning of thefrom_input_forward/// A convenience routine for building a start configuration from an/// [`Input`] for a forward search./// This automatically sets the look-behind byte to the byte immediately/// preceding the start of the search. If the start of the search is at/// offset `0`, then no look-behind byte is set.from_input_reverse/// [`Input`] for a reverse search./// following the end of the search. If the end of the search is at/// offset `haystack.len()`, then no look-behind byte is set./// Set the look-behind byte at the start of a search./// Unless the search is intended to logically start at the beginning of a/// haystack, this should _always_ be set to the byte immediately preceding/// the start of the search. If no look-behind byte is set, then the start/// configuration will assume it is at the beginning of the haystack. For/// example, the anchor `^` will match./// The default is that no look-behind byte is set./// Set the anchored mode of a search./// The default is an unanchored search.get_look_behind/// Return the look-behind byte in this configuration, if one exists./// Return the anchored mode in this configuration./// A map from every possible byte value to its corresponding starting/// This map is used in order to lookup the start configuration for a particular/// position in a haystack. This start configuration is then used in/// combination with things like the anchored mode and pattern ID to fully/// determine the start state./// Generally speaking, this map is only used for fully compiled DFAs and lazy/// DFAs. For NFAs (including the one-pass DFA), the start state is generally/// selected by virtue of traversing the NFA state graph. DFAs do the same/// thing, but at build time and not search time. (Well, technically the lazy/// DFA does it at search time, but it does enough work to cache the full/// result of the epsilon closure that the NFA engines tend to need to do.)/// Create a new map from byte values to their corresponding starting/// configurations. The map is determined, in part, by how look-around/// assertions are matched via the matcher given./// Return the starting configuration for the given look-behind byte./// If no look-behind exists, callers should use `Start::Text`./// Writes this map to the given byte buffer. if the given buffer is too/// small, then an error is returned. Upon success, the total number ofNonWordByte/// This occurs when the starting position is not any of the ones below.WordByte/// This occurs when the byte immediately preceding the start of the search/// is an ASCII word byte./// This occurs when the starting position of the search corresponds to the/// beginning of the haystack.LineLF/// is a line terminator. Specifically, `\n`.LineCR/// is a line terminator. Specifically, `\r`.CustomLineTerminator/// This occurs when a custom line terminator has been set via a/// `LookMatcher`, and when that line terminator is neither a `\r` or a/// `\n`./// If the custom line terminator is a word byte, then this start/// configuration is still selected. DFAs that implement word boundary/// assertions will likely need to check whether the custom line terminator/// is a word byte, in which case, it should behave as if the byte/// satisfies `\b` in addition to multi-line anchors./// Represents the six possible starting configurations of a DFA search./// The starting configuration is determined by inspecting the beginning/// of the haystack (up to 1 byte). Ultimately, this along with a pattern ID/// (if specified) and the type of search (anchored or not) is what selects the/// start state to use in a DFA./// As one example, if a DFA only supports unanchored searches and does not/// support anchored searches for each pattern, then it will have at most 6/// distinct start states. (Some start states may be reused if determinization/// can determine that they will be equivalent.) If the DFA supports both/// anchored and unanchored searches, then it will have a maximum of 12/// distinct start states. Finally, if the DFA also supports anchored searches/// for each pattern, then it can have up to `12 + (N * 6)` start states, where/// `N` is the number of patterns./// Handling each of these starting configurations in the context of DFA/// determinization can be *quite* tricky and subtle. But the code is small/// and can be found at `crate::util::determinize::set_lookbehind_from_start`./// Return the starting state corresponding to the given integer. If no/// starting state exists for the given integer, then None is returned./// Returns the total number of starting state configurations./// Return this starting configuration as `u8` integer. It is guaranteed to/// be less than `Start::len()`./// Return this starting configuration as a `usize` integer. It is/// guaranteed to be less than `Start::len()`.start_fwd_done_rangestart_rev_done_rangestart_fwdstart_rev/*!
Provides helpers for dealing with start state configurations in DFAs.
*//// A convenience routine for parsing a pattern into an HIR value with the/// default configuration./// This shows how to parse a pattern into an HIR value:/// use regex_automata::util::syntax;/// let hir = syntax::parse(r"([a-z]+)|([0-9]+)")?;/// assert_eq!(Some(1), hir.properties().static_explicit_captures_len());/// A convenience routine for parsing many patterns into HIR value with the/// This shows how to parse many patterns into an corresponding HIR values:///     regex_automata::util::syntax,///     regex_syntax::hir::Properties,///     r"([a-z]+)|([0-9]+)",///     r"foo(A-Z]+)bar",/// let props = Properties::union(hirs.iter().map(|h| h.properties()));/// assert_eq!(Some(1), props.static_explicit_captures_len());/// A convenience routine for parsing a pattern into an HIR value using a/// `Config`./// This shows how to parse a pattern into an HIR value with a non-default/// configuration:/// let hir = syntax::parse_with(///     r"^[a-z]+$",///     &syntax::Config::new().multi_line(true).crlf(true),/// assert!(hir.properties().look_set().contains_anchor_crlf());parse_many_with/// A convenience routine for parsing many patterns into HIR values using a/// This shows how to parse many patterns into an corresponding HIR values/// with a non-default configuration:///     r"\W",/// let config = syntax::Config::new().unicode(false).utf8(false);/// let hirs = syntax::parse_many_with(patterns, &config)?;/// assert!(!props.is_utf8());/// A common set of configuration options that apply to the syntax of a regex./// This represents a group of configuration options that specifically apply/// to how the concrete syntax of a regular expression is interpreted. In/// particular, they are generally forwarded to the/// [`ParserBuilder`](https://docs.rs/regex-syntax/*/regex_syntax/struct.ParserBuilder.html)/// in the/// [`regex-syntax`](https://docs.rs/regex-syntax)/// crate when building a regex from its concrete syntax directly./// These options are defined as a group since they apply to every regex engine/// in this crate. Instead of re-defining them on every engine's builder, they/// are instead provided here as one cohesive unit./// Return a new default syntax configuration./// Enable or disable the case insensitive flag by default./// When Unicode mode is enabled, case insensitivity is Unicode-aware./// Specifically, it will apply the "simple" case folding rules as/// specified by Unicode./// By default this is disabled. It may alternatively be selectively/// enabled in the regular expression itself via the `i` flag./// Enable or disable the multi-line matching flag by default./// When this is enabled, the `^` and `$` look-around assertions will/// match immediately after and immediately before a new line character,/// respectively. Note that the `\A` and `\z` look-around assertions are/// unaffected by this setting and always correspond to matching at the/// beginning and end of the input./// enabled in the regular expression itself via the `m` flag./// Enable or disable the "dot matches any character" flag by default./// When this is enabled, `.` will match any character. When it's disabled,/// then `.` will match any character except for a new line character./// Note that `.` is impacted by whether the "unicode" setting is enabled/// or not. When Unicode is enabled (the default), `.` will match any UTF-8/// encoding of any Unicode scalar value (sans a new line, depending on/// whether this "dot matches new line" option is enabled). When Unicode/// mode is disabled, `.` will match any byte instead. Because of this,/// when Unicode mode is disabled, `.` can only be used when the "allow/// invalid UTF-8" option is enabled, since `.` could otherwise match/// enabled in the regular expression itself via the `s` flag./// Enable or disable the "CRLF mode" flag by default./// enabled in the regular expression itself via the `R` flag./// When CRLF mode is enabled, the following happens:/// * Unless `dot_matches_new_line` is enabled, `.` will match any character/// except for `\r` and `\n`./// * When `multi_line` mode is enabled, `^` and `$` will treat `\r\n`,/// `\r` and `\n` as line terminators. And in particular, neither will/// match between a `\r` and a `\n`./// Sets the line terminator for use with `(?u-s:.)` and `(?-us:.)`./// Namely, instead of `.` (by default) matching everything except for `\n`,/// this will cause `.` to match everything except for the byte given./// If `.` is used in a context where Unicode mode is enabled and this byte/// isn't ASCII, then an error will be returned. When Unicode mode is/// disabled, then any byte is permitted, but will return an error if UTF-8/// mode is enabled and it is a non-ASCII byte./// In short, any ASCII value for a line terminator is always okay. But a/// non-ASCII byte might result in an error depending on whether Unicode/// mode or UTF-8 mode are enabled./// Note that if `R` mode is enabled then it always takes precedence and/// the line terminator will be treated as `\r` and `\n` simultaneously./// Note also that this *doesn't* impact the look-around assertions/// `(?m:^)` and `(?m:$)`. That's usually controlled by additional/// configuration in the regex engine itself./// Enable or disable the "swap greed" flag by default./// When this is enabled, `.*` (for example) will become ungreedy and `.*?`/// will become greedy./// enabled in the regular expression itself via the `U` flag./// Enable verbose mode in the regular expression./// When enabled, verbose mode permits insigificant whitespace in many/// places in the regular expression, as well as comments. Comments are/// started using `#` and continue until the end of the line./// By default, this is disabled. It may be selectively enabled in the/// regular expression by using the `x` flag regardless of this setting./// Enable or disable the Unicode flag (`u`) by default./// By default this is **enabled**. It may alternatively be selectively/// disabled in the regular expression itself via the `u` flag./// Note that unless "allow invalid UTF-8" is enabled (it's disabled by/// default), a regular expression will fail to parse if Unicode mode is/// disabled and a sub-expression could possibly match invalid UTF-8./// **WARNING**: Unicode mode can greatly increase the size of the compiled/// DFA, which can noticeably impact both memory usage and compilation/// time. This is especially noticeable if your regex contains character/// classes like `\w` that are impacted by whether Unicode is enabled or/// not. If Unicode is not necessary, you are encouraged to disable it./// When disabled, the builder will permit the construction of a regular/// expression that may match invalid UTF-8./// For example, when [`Config::unicode`] is disabled, then/// expressions like `[^a]` may match invalid UTF-8 since they can match/// any single byte that is not `a`. By default, these sub-expressions/// are disallowed to avoid returning offsets that split a UTF-8/// encoded codepoint. However, in cases where matching at arbitrary/// locations is desired, this option can be disabled to permit all such/// sub-expressions./// When enabled (the default), the builder is guaranteed to produce a/// regex that will only ever match valid UTF-8 (otherwise, the builder/// will return an error)./// Set the nesting limit used for the regular expression parser./// The nesting limit controls how deep the abstract syntax tree is allowed/// to be. If the AST exceeds the given limit (e.g., with too many nested/// groups), then an error is returned by the parser./// overflow when building a finite automaton from a regular expression's/// abstract syntax tree. In particular, construction currently uses/// recursion. In the future, the implementation may stop using recursion/// and this option will no longer be necessary./// This limit is not checked until the entire AST is parsed. Therefore,/// if callers want to put a limit on the amount of heap space used, then/// they should impose a limit on the length, in bytes, of the concrete/// pattern string. In particular, this is viable since the parser will/// limit itself to heap space proportional to the length of the pattern/// Note that a nest limit of `0` will return a nest limit error for most/// patterns but not all. For example, a nest limit of `0` permits `a` but/// not `ab`, since `ab` requires a concatenation AST item, which results/// in a nest depth of `1`. In general, a nest limit is not something that/// manifests in an obvious way in the concrete syntax, therefore, it/// should not be used in a granular way./// Whether to support octal syntax or not./// Octal syntax is a little-known way of uttering Unicode codepoints in/// a regular expression. For example, `a`, `\x61`, `\u0061` and/// `\141` are all equivalent regular expressions, where the last example/// shows octal syntax./// While supporting octal syntax isn't in and of itself a problem, it does/// make good error messages harder. That is, in PCRE based regex engines,/// syntax like `\1` invokes a backreference, which is explicitly/// unsupported in Rust's regex engine. However, many users expect it to/// be supported. Therefore, when octal support is disabled, the error/// message will explicitly mention that backreferences aren't supported./// Octal syntax is disabled by default./// Returns whether "unicode" mode is enabled.get_case_insensitive/// Returns whether "case insensitive" mode is enabled.get_multi_line/// Returns whether "multi line" mode is enabled.get_dot_matches_new_line/// Returns whether "dot matches new line" mode is enabled.get_crlf/// Returns whether "CRLF" mode is enabled./// Returns the line terminator in this syntax configuration.get_swap_greed/// Returns whether "swap greed" mode is enabled.get_ignore_whitespace/// Returns whether "ignore whitespace" mode is enabled./// Returns whether UTF-8 mode is enabled.get_nest_limit/// Returns the "nest limit" setting.get_octal/// Returns whether "octal" mode is enabled./// Applies this configuration to the given parser.apply_ast/// Applies this configuration to the given AST parser.apply_hir/// Applies this configuration to the given AST-to-HIR translator./*!
Utilities for dealing with the syntax of a regular expression.

This module currently only exposes a [`Config`] type that
itself represents a wrapper around the configuration for a
[`regex-syntax::ParserBuilder`](regex_syntax::ParserBuilder). The purpose of
this wrapper is to make configuring syntax options very similar to how other
configuration is done throughout this crate. Namely, instead of duplicating
syntax options across every builder (of which there are many), we instead
create small config objects like this one that can be passed around and
composed.
*/perl_word// This cfg should match the one in src/util/look.rs that uses perl_word.PERL_WORD// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY://   ucd-generate perl-word ucd-16.0.0 --chars// Unicode version: 16.0.0.// ucd-generate 0.3.1 is available on crates.io./// Returns true if and only if the given byte is considered a word character./// This only applies to ASCII./// This was copied from regex-syntax so that we can use it to determine the/// starting DFA state while searching without depending on regex-syntax. The/// definition is never going to change, so there's no maintenance/bit-rot/// hazard here./// Decodes the next UTF-8 encoded codepoint from the given byte slice./// If no valid encoding of a codepoint exists at the beginning of the given/// byte slice, then the first byte is returned instead./// This returns `None` if and only if `bytes` is empty./// This never panics./// *WARNING*: This is not designed for performance. If you're looking for a/// fast UTF-8 decoder, this is not it. If you feel like you need one in this/// crate, then please file an issue and discuss your use case.decode_last/// Decodes the last UTF-8 encoded codepoint from the given byte slice./// If no valid encoding of a codepoint exists at the end of the given byte/// slice, then the last byte is returned instead./// Given a UTF-8 leading byte, this returns the total number of code units/// in the following encoded codepoint./// If the given byte is not a valid UTF-8 leading byte, then this returns/// Returns true if and only if the given offset in the given bytes falls on a/// valid UTF-8 encoded codepoint boundary./// If `bytes` is not valid UTF-8, then the behavior of this routine isis_leading_or_invalid_byte/// Returns true if and only if the given byte is either a valid leading UTF-8/// byte, or is otherwise an invalid byte that can never appear anywhere in a/// valid UTF-8 sequence./*!
Utilities for dealing with UTF-8.

This module provides some UTF-8 related helper routines, including an
incremental decoder.
*//*
/// Returns the smallest possible index of the next valid UTF-8 sequence
/// starting after `i`.
///
/// For all inputs, including invalid UTF-8 and any value of `i`, the return
/// value is guaranteed to be greater than `i`. (If there is no value greater
/// than `i` that fits in `usize`, then this panics.)
///
/// Generally speaking, this should only be called on `text` when it is
/// permitted to assume that it is valid UTF-8 and where either `i >=
/// text.len()` or where `text[i]` is a leading byte of a UTF-8 sequence.
///
/// NOTE: This method was used in a previous conception of iterators where we
/// specifically tried to skip over empty matches that split a codepoint by
/// simply requiring that our next search begin at the beginning of codepoint.
/// But we ended up changing that technique to always advance by 1 byte and
/// then filter out matches that split a codepoint after-the-fact. Thus, we no
/// longer use this method. But I've kept it around in case we want to switch
/// back to this approach. Its guarantees are a little subtle, so I'd prefer
/// not to rebuild it from whole cloth.
pub(crate) fn next(text: &[u8], i: usize) -> usize {
    let b = match text.get(i) {
        None => return i.checked_add(1).unwrap(),
        Some(&b) => b,
    };
    // For cases where we see an invalid UTF-8 byte, there isn't much we can do
    // other than just start at the next byte.
    let inc = len(b).unwrap_or(1);
    i.checked_add(inc).unwrap()
}
*//// A zero-sized field indicating the alignment we want./// A possibly non-sized field containing a sequence of bytes.AlignAs/// A hack to align a smaller type `B` with a bigger type `T`./// The usual use of this is with `B = [u8]` and `T = u32`. That is,/// it permits aligning a sequence of bytes on a 4-byte boundary. This/// is useful in contexts where one wants to embed a serialized [dense/// DFA](crate::dfa::dense::DFA) into a Rust a program while guaranteeing the/// alignment required for the DFA./// See [`dense::DFA::from_bytes`](crate::dfa::dense::DFA::from_bytes) for an/// example of how to use this type./// The name of the thing that a buffer is too small for./// Currently, the only kind of serialization error is one that is/// committed by a caller: providing a destination buffer that is too/// small to fit the serialized object. This makes sense conceptually,/// since every valid inhabitant of a type should be serializable./// This is somewhat exposed in the public API of this crate. For example,/// the `to_bytes_{big,little}_endian` APIs return a `Vec<u8>` and are/// guaranteed to never panic or error. This is only possible because the/// implementation guarantees that it will allocate a `Vec<u8>` that is/// big enough./// In summary, if a new serialization error kind needs to be added, then/// it will need careful consideration./// An error that occurs when serializing an object from this crate./// Serialization, as used in this crate, universally refers to the process/// of transforming a structure (like a DFA) into a custom binary format/// represented by `&[u8]`. To this end, serialization is generally infallible./// However, it can fail when caller provided buffer sizes are too small. When/// that occurs, a serialization error is reported./// A `SerializeError` provides no introspection capabilities. Its only/// supported operation is conversion to a human readable error message./// This error type implements the `std::error::Error` trait only when the/// `std` feature is enabled. Otherwise, this type is defined in all/// configurations.buffer_too_smallDeserializeErrorKind/// An error that occurs when deserializing an object defined in this crate./// represented by `&[u8]`. Deserialization, then, refers to the process of/// cheaply converting this binary format back to the object's in-memory/// representation as defined in this crate. To the extent possible,/// deserialization will report this error whenever this process fails./// A `DeserializeError` provides no introspection capabilities. Its onlyInvalidUsizeEndianMismatchLabelMismatchArithmeticOverflowinvalid_usizeversion_mismatchendian_mismatchalignment_mismatchlabel_mismatcharithmetic_overflowpattern_id_errorstate_id_erroru32s_to_state_ids/// Safely converts a `&[u32]` to `&[StateID]` with zero cost.u32s_to_state_ids_mut/// Safely converts a `&mut [u32]` to `&mut [StateID]` with zero cost.u32s_to_pattern_ids/// Safely converts a `&[u32]` to `&[PatternID]` with zero cost./// Checks that the given slice has an alignment that matches `T`./// This is useful for checking that a slice has an appropriate alignment/// before casting it to a &[T]. Note though that alignment is not itself/// sufficient to perform the cast for any `T`.skip_initial_padding/// Reads a possibly empty amount of padding, up to 7 bytes, from the beginning/// of the given slice. All padding bytes must be NUL bytes./// This is useful because it can be theoretically necessary to pad the/// beginning of a serialized object with NUL bytes to ensure that it starts/// at a correctly aligned address. These padding bytes should come immediately/// before the label./// This returns the number of bytes read from the given slice.alloc_aligned_buffer/// Allocate a byte buffer of the given size, along with some initial padding/// such that `buf[padding..]` has the same alignment as `T`, where the/// alignment of `T` must be at most `8`. In particular, callers should treat/// the first N bytes (second return value) as padding bytes that must not be/// overwritten. In all cases, the following identity holds:/// let (buf, padding) = alloc_aligned_buffer::<StateID>(SIZE);/// assert_eq!(SIZE, buf[padding..].len());/// In practice, padding is often zero./// The requirement for `8` as a maximum here is somewhat arbitrary. In/// practice, we never need anything bigger in this crate, and so this function/// does some sanity asserts under the assumption of a max alignment of `8`.read_label/// Reads a NUL terminated label starting at the beginning of the given slice./// If a NUL terminated label could not be found, then an error is returned./// Similarly, if a label is found but doesn't match the expected label, then/// an error is returned./// Upon success, the total number of bytes read (including padding bytes) iswrite_label/// Writes the given label to the buffer as a NUL terminated string. The label/// given must not contain NUL, otherwise this will panic. Similarly, the label/// must not be longer than 255 bytes, otherwise this will panic./// Additional NUL bytes are written as necessary to ensure that the number of/// bytes written is always a multiple of 4./// Upon success, the total number of bytes written (including padding) iswrite_label_len/// Returns the total number of bytes (including padding) that would be written/// for the given label. This panics if the given label contains a NUL byte or/// is longer than 255 bytes. (The size restriction exists so that searching/// for a label during deserialization can be done in small bounded space.)read_endianness_check/// Reads the endianness check from the beginning of the given slice and/// confirms that the endianness of the serialized object matches the expected/// endianness. If the slice is too small or if the endianness check fails,/// this returns an error./// Upon success, the total number of bytes read is returned.write_endianness_check/// Writes 0xFEFF as an integer using the given endianness./// This is useful for writing into the header of a serialized object. It can/// be read during deserialization as a sanity check to ensure the proper/// endianness is used./// Upon success, the total number of bytes written is returned.write_endianness_check_len/// Returns the number of bytes written by the endianness check./// Reads a version number from the beginning of the given slice and confirms/// that is matches the expected version number given. If the slice is too/// small or if the version numbers aren't equivalent, this returns an error./// N.B. Currently, we require that the version number is exactly equivalent./// In the future, if we bump the version number without a semver bump, then/// we'll need to relax this a bit and support older versions./// Writes the given version number to the beginning of the given slice./// be read during deserialization as a sanity check to ensure that the library/// code supports the format of the serialized object.write_version_len/// Returns the number of bytes written by writing the version number.read_pattern_id/// Reads a pattern ID from the given slice. If the slice has insufficient/// length, then this panics. If the deserialized integer exceeds the pattern/// ID limit for the current target, then this returns an error./// Upon success, this also returns the number of bytes read.read_pattern_id_unchecked/// length, then this panics. Otherwise, the deserialized integer is assumed/// to be a valid pattern ID./// This also returns the number of bytes read.write_pattern_id/// Write the given pattern ID to the beginning of the given slice of bytes/// using the specified endianness. The given slice must have length at least/// `PatternID::SIZE`, or else this panics. Upon success, the total number of/// bytes written is returned.try_read_state_id/// Attempts to read a state ID from the given slice. If the slice has an/// insufficient number of bytes or if the state ID exceeds the limit for/// the current target, then this returns an error.read_state_id/// Reads a state ID from the given slice. If the slice has insufficient/// length, then this panics. If the deserialized integer exceeds the state ID/// limit for the current target, then this returns an error.read_state_id_unchecked/// to be a valid state ID.write_state_id/// Write the given state ID to the beginning of the given slice of bytes/// `StateID::SIZE`, or else this panics. Upon success, the total number oftry_read_u16_as_usize/// Try to read a u16 as a usize from the beginning of the given slice in/// native endian format. If the slice has fewer than 2 bytes or if the/// deserialized number cannot be represented by usize, then this returns an/// error. The error message will include the `what` description of what is/// being deserialized, for better error messages. `what` should be a noun in/// singular form.try_read_u32_as_usize/// Try to read a u32 as a usize from the beginning of the given slice in/// native endian format. If the slice has fewer than 4 bytes or if thetry_read_u16/// Try to read a u16 from the beginning of the given slice in native endian/// format. If the slice has fewer than 2 bytes, then this returns an error./// The error message will include the `what` description of what is being/// deserialized, for better error messages. `what` should be a noun intry_read_u32/// Try to read a u32 from the beginning of the given slice in native endian/// format. If the slice has fewer than 4 bytes, then this returns an error.try_read_u128/// Try to read a u128 from the beginning of the given slice in native endian/// format. If the slice has fewer than 16 bytes, then this returns an error./// Read a u16 from the beginning of the given slice in native endian format./// If the slice has fewer than 2 bytes, then this panics./// Marked as inline to speed up sparse searching which decodes integers from/// its automaton at search time./// Read a u32 from the beginning of the given slice in native endian format./// If the slice has fewer than 4 bytes, then this panics./// Read a u128 from the beginning of the given slice in native endian format./// If the slice has fewer than 16 bytes, then this panics.check_slice_len/// Checks that the given slice has some minimal length. If it's smaller than/// the bound given, then a "buffer too small" error is returned with `what`/// describing what the buffer represents./// Multiply the given numbers, and on overflow, return an error that includes/// 'what' in the error message./// This is useful when doing arithmetic with untrusted data./// Add the given numbers, and on overflow, return an error that includes/// Shift `a` left by `b`, and on overflow, return an error that includespadding_len/// Returns the number of additional bytes required to add to the given length/// in order to make the total length a multiple of 4. The return value is/// always less than 4./// Writes a u16 to the given destination buffer in a particular/// endianness. If the destination buffer has a length smaller than 2, then/// Writes a u32 to the given destination buffer in a particular/// endianness. If the destination buffer has a length smaller than 4, then/// Writes a u128 to the given destination buffer in a particular/// endianness. If the destination buffer has a length smaller than 16,/// A simple trait for writing code generic over endianness./// This is similar to what byteorder provides, but we only need a very small/// subset./// Little endian writing./// Big endian writing.NEbad_label_interior_nulbad_label_almost_too_longbad_label_too_long/*!
Types and routines that support the wire format of finite automata.

Currently, this module just exports a few error types and some small helpers
for deserializing [dense DFAs](crate::dfa::dense::DFA) using correct alignment.
*//*
A collection of helper functions, types and traits for serializing automata.

This crate defines its own bespoke serialization mechanism for some structures
provided in the public API, namely, DFAs. A bespoke mechanism was developed
primarily because structures like automata demand a specific binary format.
Attempting to encode their rich structure in an existing serialization
format is just not feasible. Moreover, the format for each structure is
generally designed such that deserialization is cheap. More specifically, that
deserialization can be done in constant time. (The idea being that you can
embed it into your binary or mmap it, and then use it immediately.)

In order to achieve this, the dense and sparse DFAs in this crate use an
in-memory representation that very closely corresponds to its binary serialized
form. This pervades and complicates everything, and in some cases, requires
dealing with alignment and reasoning about safety.

This technique does have major advantages. In particular, it permits doing
the potentially costly work of compiling a finite state machine in an offline
manner, and then loading it at runtime not only without having to re-compile
the regex, but even without the code required to do the compilation. This, for
example, permits one to use a pre-compiled DFA not only in environments without
Rust's standard library, but also in environments without a heap.

In the code below, whenever we insert some kind of padding, it's to enforce a
4-byte alignment, unless otherwise noted. Namely, u32 is the only state ID type
supported. (In a previous version of this library, DFAs were generic over the
state ID representation.)

Also, serialization generally requires the caller to specify endianness,
where as deserialization always assumes native endianness (otherwise cheap
deserialization would be impossible). This implies that serializing a structure
generally requires serializing both its big-endian and little-endian variants,
and then loading the correct one based on the target's endianness.
*//// The kind of error./// The original pattern that the parser generated the error from. Every/// span in an error is a valid range into this string./// The span of this error./// An error that occurred while parsing a regular expression into an abstract/// syntax tree./// Note that not all ASTs represents a valid regular expression. For example,/// an AST is constructed without error for `\p{Quux}`, but `Quux` is not a/// valid Unicode property name. That particular error is reported when/// translating an AST to the high-level intermediate representation (`HIR`)./// Return the type of this error./// The original pattern string in which this error occurred./// Every span reported by this error is reported in terms of this string./// Return the span at which this error occurred.auxiliary_span/// Return an auxiliary span. This span exists only for some errors that/// benefit from being able to point to two locations in the original/// regular expression. For example, "duplicate" errors will have the/// main error position set to the duplicate occurrence while its/// auxiliary span will be set to the initial occurrence.CaptureLimitExceeded/// The capturing group limit was exceeded./// Note that this represents a limit on the total number of capturing/// groups in a regex and not necessarily the number of nested capturing/// groups. That is, the nest limit can be low and it is still possible for/// this error to occur.ClassEscapeInvalid/// An invalid escape sequence was found in a character class set.ClassRangeInvalid/// An invalid character class range was found. An invalid range is any/// range where the start is greater than the end.ClassRangeLiteral/// An invalid range boundary was found in a character class. Range/// boundaries must be a single literal codepoint, but this error indicates/// that something else was found, such as a nested class.ClassUnclosed/// An opening `[` was found with no corresponding closing `]`.DecimalEmpty/// Note that this error variant is no longer used. Namely, a decimal/// number can only appear as a repetition quantifier. When the number/// in a repetition quantifier is empty, then it gets its own specialized/// error, `RepetitionCountDecimalEmpty`.DecimalInvalid/// An invalid decimal number was given where one was expected.EscapeHexEmpty/// A bracketed hex literal was empty.EscapeHexInvalid/// A bracketed hex literal did not correspond to a Unicode scalar value.EscapeHexInvalidDigit/// An invalid hexadecimal digit was found.EscapeUnexpectedEof/// EOF was found before an escape sequence was completed.EscapeUnrecognized/// An unrecognized escape sequence.FlagDanglingNegation/// A dangling negation was used when setting flags, e.g., `i-`./// The position of the original flag. The error position/// points to the duplicate flag.FlagDuplicate/// A flag was used twice, e.g., `i-i`./// The position of the original negation operator. The error position/// points to the duplicate negation operator.FlagRepeatedNegation/// The negation operator was used twice, e.g., `-i-s`.FlagUnexpectedEof/// Expected a flag but got EOF, e.g., `(?`.FlagUnrecognized/// Unrecognized flag, e.g., `a`./// The position of the initial occurrence of the capture name. The/// error position itself points to the duplicate occurrence.GroupNameDuplicate/// A duplicate capture name was found.GroupNameEmpty/// A capture group name is empty, e.g., `(?P<>abc)`.GroupNameInvalid/// An invalid character was seen for a capture group name. This includes/// errors where the first character is a digit (even though subsequent/// characters are allowed to be digits).GroupNameUnexpectedEof/// A closing `>` could not be found for a capture group name.GroupUnclosed/// An unclosed group, e.g., `(ab`./// The span of this error corresponds to the unclosed parenthesis.GroupUnopened/// An unopened group, e.g., `ab)`.NestLimitExceeded/// The nest limit was exceeded. The limit stored here is the limit/// configured in the parser.RepetitionCountInvalid/// The range provided in a counted repetition operator is invalid. The/// range is invalid if the start is greater than the end.RepetitionCountDecimalEmpty/// An opening `{` was not followed by a valid decimal value./// For example, `x{}` or `x{]}` would fail.RepetitionCountUnclosed/// An opening `{` was found with no corresponding closing `}`.RepetitionMissing/// A repetition operator was applied to a missing sub-expression. This/// occurs, for example, in the regex consisting of just a `*` or even/// `(?i)*`. It is, however, possible to create a repetition operating on/// an empty sub-expression. For example, `()*` is still considered valid.SpecialWordBoundaryUnclosed/// The special word boundary syntax, `\b{something}`, was used, but/// either EOF without `}` was seen, or an invalid character in the/// braces was seen.SpecialWordBoundaryUnrecognized/// `something` was not recognized as a valid word boundary kind.SpecialWordOrRepetitionUnexpectedEof/// The syntax `\b{` was observed, but afterwards the end of the pattern/// was observed without being able to tell whether it was meant to be a/// bounded repetition on the `\b` or the beginning of a special word/// boundary assertion.UnicodeClassInvalid/// The Unicode class is not valid. This typically occurs when a `\p` is/// followed by something other than a `{`.UnsupportedBackreference/// When octal support is disabled, this error is produced when an octal/// escape is used. The octal escape is assumed to be an invocation of/// a backreference, which is the common case.UnsupportedLookAround/// When syntax similar to PCRE's look-around is used, this error is/// returned. Some example syntaxes that are rejected include, but are/// not necessarily limited to, `(?=re)`, `(?!re)`, `(?<=re)` and/// `(?<!re)`. Note that all of these syntaxes are otherwise invalid; this/// error is used to improve the user experience./// The type of an error that occurred while building an AST./// This error type is marked as `non_exhaustive`. This means that adding a/// new variant is not considered a breaking change./// The start byte offset./// The end byte offset./// Span represents the position information of a single AST item./// All span positions are absolute byte offsets that can be used on the/// original regular expression that was parsed./// The absolute offset of this position, starting at `0` from the/// beginning of the regular expression pattern string./// The line number, starting at `1`./// The approximate column number, starting at `1`./// A single position in a regular expression./// A position encodes one half of a span, and include the byte offset, line/// number and column number./// Create a new span with the given positions./// Create a new span using the given position as the start and end.with_start/// Create a new span by replacing the starting the position with the onewith_end/// Create a new span by replacing the ending the position with the oneis_one_line/// Returns true if and only if this span occurs on a single line./// Returns true if and only if this span is empty. That is, it points to/// a single position in the concrete syntax of a regular expression./// Create a new position with the given information./// `offset` is the absolute offset of the position, starting at `0` from/// the beginning of the regular expression pattern string./// `line` is the line number, starting at `1`./// `column` is the approximate column number, starting at `1`.Ast/// The actual ast./// All comments found in the original regular expression.WithComments/// An abstract syntax tree for a singular expression along with comments/// Comments are not stored in the tree itself to avoid complexity. Each/// comment contains a span of precisely where it occurred in the original/// The span of this comment, including the beginning `#` and ending `\n`./// The comment text, starting with the first character following the `#`/// and ending with the last character preceding the `\n`./// A comment from a regular expression with an associated span./// A regular expression can only contain comments when the `x` flag is/// An empty regex that matches everything.SetFlags/// A set of flags, e.g., `(?is)`./// A single character literal, which includes escape sequences./// The "any character" class.Assertion/// A single zero-width assertion./// A single Unicode character class, e.g., `\pL` or `\p{Greek}`.ClassPerl/// A single perl character class, e.g., `\d` or `\W`.ClassBracketed/// A single bracketed character class set, which may contain zero or more/// character ranges and/or zero or more nested classes. e.g.,/// `[a-zA-Z\pL]`./// A repetition operator applied to an arbitrary regular expression./// A grouped regular expression.Alternation/// An alternation of regular expressions./// A concatenation of regular expressions./// An abstract syntax tree for a single regular expression./// An `Ast`'s `fmt::Display` implementation uses constant stack space and heap/// space proportional to the size of the `Ast`./// This type defines its own destructor that uses constant stack space and/// heap space proportional to the size of the `Ast`./// Create an "empty" AST item./// Create a "flags" AST item./// Create a "literal" AST item./// Create a "dot" AST item.assertion/// Create a "assertion" AST item.class_unicode/// Create a "Unicode class" AST item.class_perl/// Create a "Perl class" AST item.class_bracketed/// Create a "bracketed class" AST item.repetition/// Create a "repetition" AST item./// Create a "group" AST item.alternation/// Create a "alternation" AST item./// Create a "concat" AST item./// Return the span of this abstract syntax tree./// Return true if and only if this Ast is empty.has_subexprs/// Returns true if and only if this AST has any (including possibly empty)/// subexpressions./// Print a display representation of this Ast./// This does not preserve any of the original whitespace formatting that may/// have originally been present in the concrete syntax from which this Ast/// was generated./// This implementation uses constant stack space and heap space proportional/// to the size of the `Ast`./// The span of this alternation.asts/// The alternate regular expressions.into_ast/// Return this alternation as an AST./// If this alternation contains zero ASTs, then `Ast::empty` is returned./// If this alternation contains exactly 1 AST, then the corresponding AST/// is returned. Otherwise, `Ast::alternation` is returned./// The span of this concatenation./// The concatenation regular expressions./// Return this concatenation as an AST./// is returned. Otherwise, `Ast::concat` is returned./// The span of this literal.LiteralKind/// The kind of this literal./// The Unicode scalar value corresponding to this literal./// A single literal expression./// A literal corresponds to a single Unicode scalar value. Literals may be/// represented in their literal form, e.g., `a` or in their escaped form,/// e.g., `\x61`./// If this literal was written as a `\x` hex escape, then this returns/// the corresponding byte value. Otherwise, this returns `None`.Verbatim/// The literal is written verbatim, e.g., `a` or `☃`./// The literal is written as an escape because it is otherwise a special/// regex meta character, e.g., `\*` or `\[`.Superfluous/// The literal is written as an escape despite the fact that the escape is/// unnecessary, e.g., `\%` or `\/`./// The literal is written as an octal escape, e.g., `\141`.HexLiteralKindHexFixed/// The literal is written as a hex code with a fixed number of digits/// depending on the type of the escape, e.g., `\x61` or `\u0061` or/// `\U00000061`.HexBrace/// The literal is written as a hex code with a bracketed number of/// digits. The only restriction is that the bracketed hex code must refer/// to a valid Unicode scalar value.SpecialLiteralKind/// The literal is written as a specially recognized escape, e.g., `\f`/// or `\n`./// The kind of a single literal expression.Bell/// Bell, spelled `\a` (`\x07`).FormFeed/// Form feed, spelled `\f` (`\x0C`)./// Tab, spelled `\t` (`\x09`)./// Line feed, spelled `\n` (`\x0A`)./// Carriage return, spelled `\r` (`\x0D`).VerticalTab/// Vertical tab, spelled `\v` (`\x0B`)./// Space, spelled `\ ` (`\x20`). Note that this can only appear when/// parsing in verbose mode./// The type of a special literal./// A special literal is a special escape sequence recognized by the regex/// parser, e.g., `\f` or `\n`./// A `\x` prefix. When used without brackets, this form is limited to/// two digits.UnicodeShort/// A `\u` prefix. When used without brackets, this form is limited to/// four digits.UnicodeLong/// A `\U` prefix. When used without brackets, this form is limited to/// eight digits./// The type of a Unicode hex literal./// Note that all variants behave the same when used with brackets. They only/// differ when used without brackets in the number of hex digits that must/// follow./// The number of digits that must be used with this literal form when/// used without brackets. When used with brackets, there is no/// restriction on the number of digits./// The span of this class.ClassPerlKind/// The kind of Perl class.negated/// Whether the class is negated or not. e.g., `\d` is not negated but/// `\D` is./// A Perl character class./// Decimal numbers./// Whitespace./// Word characters./// The available Perl character classes.ClassAsciiKind/// The kind of ASCII class./// Whether the class is negated or not. e.g., `[[:alpha:]]` is not negated/// but `[[:^alpha:]]` is.ClassAscii/// An ASCII character class.Alnum/// `[0-9A-Za-z]`/// `[A-Za-z]`/// `[\x00-\x7F]`Blank/// `[ \t]`Cntrl/// `[\x00-\x1F\x7F]`/// `[0-9]`/// `[!-~]`/// `[a-z]`/// `[ -~]`/// `[!-/:-@\[-`{-~]`/// `[\t\n\v\f\r ]`/// `[A-Z]`/// `[0-9A-Za-z_]`Xdigit/// `[0-9A-Fa-f]`/// The available ASCII character classes./// Return the corresponding ClassAsciiKind variant for the given name./// The name given should correspond to the lowercase version of the/// variant name. e.g., `cntrl` is the name for `ClassAsciiKind::Cntrl`./// If no variant with the corresponding name exists, then `None` is/// Whether this class is negated or not./// Note: be careful when using this attribute. This specifically refers/// to whether the class is written as `\p` or `\P`, where the latter/// is `negated = true`. However, it also possible to write something like/// `\P{scx!=Katakana}` which is actually equivalent to/// `\p{scx=Katakana}` and is therefore not actually negated even though/// `negated = true` here. To test whether this class is truly negated/// or not, use the `is_negated` method.ClassUnicodeKind/// The kind of Unicode class./// A Unicode character class.is_negated/// Returns true if this class has been negated./// Note that this takes the Unicode op into account, if it's present./// e.g., `is_negated` for `\P{scx!=Katakana}` will return `false`.OneLetter/// A one letter abbreviated class, e.g., `\pN`./// A binary property, general category or script. The string may beClassUnicodeOpKind/// The type of Unicode op used to associate `name` with `value`./// The property name (which may be empty)./// The property value (which may be empty).NamedValue/// A property name and an associated value./// The available forms of Unicode character classes./// A property set to a specific value, e.g., `\p{scx=Katakana}`./// A property set to a specific value using a colon, e.g.,/// `\p{scx:Katakana}`.NotEqual/// A property that isn't a particular value, e.g., `\p{scx!=Katakana}`./// The type of op used in a Unicode character class./// Whether the op is an equality op or not./// Whether this class is negated or not. e.g., `[a]` is not negated but/// `[^a]` is.ClassSet/// The type of this set. A set is either a normal union of things, e.g.,/// `[abc]` or a result of applying set operations, e.g., `[\pL--c]`./// A bracketed character class, e.g., `[a-z0-9]`.ClassSetItem/// An item, which can be a single literal, range, nested character class/// or a union of items.ClassSetBinaryOp/// A single binary operation (i.e., &&, -- or ~~)./// A character class set./// This type corresponds to the internal structure of a bracketed character/// class. That is, every bracketed character is one of two types: a union of/// items (literals, ranges, other bracketed classes) or a tree of binary setClassSetUnion/// Build a set from a union./// Return the span of this character class set./// Return true if and only if this class set is empty./// An empty item./// Note that a bracketed character class cannot contain a single empty/// item. Empty items can appear when using one of the binary operators./// For example, `[&&]` is the intersection of two empty classes./// A single literal.ClassSetRange/// A range between two literals./// An ASCII character class, e.g., `[:alnum:]` or `[:punct:]`.Unicode/// A Unicode character class, e.g., `\pL` or `\p{Greek}`.Perl/// A perl character class, e.g., `\d` or `\W`.Bracketed/// A bracketed character class set, which may contain zero or more/// A union of items./// A single component of a character class set./// Return the span of this character class set item./// The span of this range./// The start of this range./// The end of this range./// A single character class range in a set./// Returns true if and only if this character class range is valid./// The only case where a range is invalid is if its start is greater than/// its end./// The span of the items in this operation. e.g., the `a-z0-9` in/// `[^a-z0-9]`/// The sequence of items that make up this union./// A union of items inside a character class set./// Push a new item in this union./// The ending position of this union's span is updated to the ending/// position of the span of the item given. If the union is empty, then/// the starting position of this union is set to the starting position/// of this item./// In other words, if you only use this method to add items to a union/// and you set the spans on each item correctly, then you should never/// need to adjust the span of the union directly.into_item/// Return this union as a character class set item./// If this union contains zero items, then an empty union is/// returned. If this concatenation contains exactly 1 item, then the/// corresponding item is returned. Otherwise, ClassSetItem::Union is/// The span of this operation. e.g., the `a-z--[h-p]` in `[a-z--h-p]`.ClassSetBinaryOpKind/// The type of this set operation.lhs/// The left hand side of the operation.rhs/// The right hand side of the operation./// A Unicode character class set operation./// The intersection of two sets, e.g., `\pN&&[a-z]`./// The difference of two sets, e.g., `\pN--[0-9]`./// The symmetric difference of two sets. The symmetric difference is the/// set of elements belonging to one but not both sets./// e.g., `[\pL~~[:ascii:]]`./// The type of a Unicode character class set operation./// Note that this doesn't explicitly represent union since there is no/// explicit union operator. Concatenation inside a character class corresponds/// to the union operation./// The span of this assertion.AssertionKind/// The assertion kind, e.g., `\b` or `^`.StartLine/// `^`EndLine/// `$`StartText/// `\A`EndText/// `\z`WordBoundary/// `\b`NotWordBoundary/// `\B`WordBoundaryStart/// `\b{start}`WordBoundaryEnd/// `\b{end}`WordBoundaryStartAngle/// `\<` (alias for `\b{start}`)WordBoundaryEndAngle/// `\>` (alias for `\b{end}`)WordBoundaryStartHalf/// `\b{start-half}`WordBoundaryEndHalf/// `\b{end-half}`/// An assertion kind./// The span of this operation.RepetitionOp/// The actual operation.greedy/// Whether this operation was applied greedily or not./// The regular expression under repetition./// A repetition operation applied to a regular expression./// The span of this operator. This includes things like `+`, `*?` and/// `{m,n}`.RepetitionKind/// The type of operation./// The repetition operator itself.ZeroOrOne/// `?`ZeroOrMore/// `*`OneOrMore/// `+`RepetitionRange/// `{m,n}`/// The kind of a repetition operator.Exactly/// `{m}`AtLeast/// `{m,}`/// A range repetition operator./// Returns true if and only if this repetition range is valid./// The only case where a repetition range is invalid is if it is bounded/// and its start is greater than its end./// The span of this group.GroupKind/// The kind of this group./// The regular expression in this group./// This includes both capturing and non-capturing groups. This does **not**/// include flag-only groups like `(?is)`, but does contain any group that/// contains a sub-expression, e.g., `(a)`, `(?P<name>a)`, `(?:a)` and/// `(?is:a)`./// If this group is non-capturing, then this returns the (possibly empty)/// set of flags. Otherwise, `None` is returned.is_capturing/// Returns true if and only if this group is capturing.capture_index/// Returns the capture index of this group, if this is a capturing group./// This returns a capture index precisely when `is_capturing` is `true`.CaptureIndex/// `(a)`starts_with_p/// True if the `?P<` syntax is used and false if the `?<` syntax is used.CaptureName/// The capture name./// `(?<name>a)` or `(?P<name>a)`NonCapturing/// `(?:a)` and `(?i:a)`/// The kind of a group./// The span of this capture name./// The capture index./// A capture name./// This corresponds to the name itself between the angle brackets in, e.g.,/// `(?P<foo>expr)`./// The span of these flags, including the grouping parentheses./// The actual sequence of flags./// A group of flags that is not applied to a particular regular expression./// The span of this group of flags.FlagsItem/// A sequence of flag items. Each item is either a flag or a negation/// operator./// A group of flags./// This corresponds only to the sequence of flags themselves, e.g., `is-u`./// Add the given item to this sequence of flags./// If the item was added successfully, then `None` is returned. If the/// given item is a duplicate, then `Some(i)` is returned, where/// `items[i].kind == item.kind`.flag_state/// Returns the state of the given flag in this set./// If the given flag is in the set but is negated, then `Some(false)` is/// If the given flag is in the set and is not negated, then `Some(true)`/// The span of this item.FlagsItemKind/// The kind of this item./// A single item in a group of flags.Negation/// A negation operator applied to all subsequent flags in the enclosing/// A single flag in a group./// The kind of an item in a group of flags.is_negation/// Returns true if and only if this item is a negation operator./// `i`/// `m`DotMatchesNewLine/// `s`SwapGreed/// `U`/// `u`/// `R`IgnoreWhitespace/// A single flag./// A custom `Drop` impl is used for `Ast` such that it uses constant stack/// space but heap space proportional to the depth of the `Ast`./// A custom `Drop` impl is used for `ClassSet` such that it uses constant/// stack space but heap space proportional to the depth of the `ClassSet`.no_stack_overflow_on_drop// We use a thread with an explicit stack size to test that our destructor// for Ast can handle arbitrarily sized expressions in constant stack// space. In case we run on a platform without threads (WASM?), we limit// this test to Windows/Unix.ast_size// This tests that our `Ast` has a reasonable size. This isn't a hard rule// and it can be increased if given a good enough reason. But this test// exists because the size of `Ast` was at one point over 200 bytes on a// 64-bit target. Wow./*!
Defines an abstract syntax for regular expressions.
*/is_escapeable_characteris_meta_character/// A primitive is an expression with no sub-expressions. This includes/// literals, assertions and non-set character classes. This representation/// is used as intermediate state in the parser./// This does not include ASCII character classes, since they can only appear/// within a set character class./// Return the span of this primitive./// Convert this primitive into a proper AST.into_class_set_itemParserI/// Convert this primitive into an item in a character class./// If this primitive is not a legal item (i.e., an assertion or a dot),/// then return an error.into_class_literal/// Convert this primitive into a literal in a character class. In/// particular, literals are the only valid items that can appear in/// If this primitive is not a legal item (i.e., a class, assertion or a/// dot), then return an error.is_hex/// Returns true if the given character is a hexadecimal digit.is_capture_char/// Returns true if the given character is a valid in a capture group name./// If `first` is true, then `c` is treated as the first character in the/// group name (which must be alphabetic or underscore).empty_min_range/// A builder for a regular expression parser./// This builder permits modifying configuration options for the parser./// Create a new parser builder with a default configuration./// Build a parser from this configuration with the given pattern./// overflow for consumers that do structural induction on an `Ast` using/// pattern string. In particular, this is viable since this parser/// implementation will limit itself to heap space proportional to the/// length of the pattern string./// not `ab`, since `ab` requires a concatenation, which results in a nest/// depth of `1`. In general, a nest limit is not something that manifests/// in an obvious way in the concrete syntax, therefore, it should not be/// used in a granular way./// syntax like `\0` invokes a backreference, which is explicitly/// When enabled, verbose mode permits insignificant whitespace in many/// Allow using `{,n}` as an equivalent to `{0,n}`./// When enabled, the parser accepts `{,n}` as valid syntax for `{0,n}`./// Most regular expression engines don't support the `{,n}` syntax, but/// some others do it, namely Python's `re` library./// The current position of the parser./// The current capture index./// The maximum number of open parens/brackets allowed. If the parser/// exceeds this number, then an error is returned./// Whether to support octal syntax or not. When `false`, the parser will/// return an error helpfully pointing out that backreferences are notinitial_ignore_whitespace/// The initial setting for `ignore_whitespace` as provided by/// `ParserBuilder`. It is used when resetting the parser's state./// Whether the parser supports `{,n}` repetitions as an equivalent to/// `{0,n}.`/// Whether whitespace should be ignored. When enabled, comments are/// also permitted./// A list of comments, in order of appearance.stack_groupGroupState/// A stack of grouped sub-expressions, including alternations.stack_classClassState/// A stack of nested character classes. This is only non-empty when/// parsing a class./// A sorted sequence of capture names. This is used to detect duplicate/// capture names and report an error if one is detected./// A scratch buffer used in various places. Mostly this is used to/// accumulate relevant characters from parts of a pattern./// A regular expression parser./// This parses a string representation of a regular expression into an/// abstract syntax tree. The size of the tree is proportional to the length/// of the regular expression pattern./// A `Parser` can be configured in more detail via a [`ParserBuilder`]./// The parser state/configuration./// The full regular expression provided by the user./// ParserI is the internal parser implementation./// We use this separate type so that we can carry the provided pattern string/// along with us. In particular, a `Parser` internal state is not tied to any/// one pattern, but `ParserI` is./// This type also lets us use `ParserI<&Parser>` in production code while/// retaining the convenience of `ParserI<Parser>` for tests, which sometimes/// work against the internal interface of the parser./// The concatenation immediately preceding the opening group./// The group that has been opened. Its sub-AST is always empty./// Whether this group has the `x` flag enabled or not./// This state is pushed whenever an opening group is found./// This state is pushed whenever a new alternation branch is found. If/// an alternation branch is found and this state is at the top of the/// stack, then this state should be modified to include the new/// alternation./// GroupState represents a single stack frame while parsing nested groups/// and alternations. Each frame records the state up to an opening parenthesis/// or a alternating bracket `|`./// The union of class items immediately preceding this class./// The class that has been opened. Typically this just corresponds/// to the `[`, but it can also include `[^` since `^` indicates/// negation of the class./// This state is pushed whenever an opening bracket is found./// The type of the operation, i.e., &&, -- or ~~./// The left-hand side of the operator.Op/// This state is pushed when a operator is seen. When popped, the stored/// set becomes the left hand side of the operator./// ClassState represents a single stack frame while parsing character classes./// Each frame records the state up to an intersection, difference, symmetric/// difference or nested class./// Note that a parser's character class stack is only non-empty when parsing/// a character class. In all other cases, it is empty./// Create a new parser with a default configuration./// The parser can be run with either the `parse` or `parse_with_comments`/// methods. The parse methods return an abstract syntax tree./// To set configuration options on the parser, use [`ParserBuilder`]./// Parse the regular expression into an abstract syntax tree.parse_with_comments/// Parse the regular expression and return an abstract syntax tree with/// all of the comments found in the pattern./// Reset the internal state of a parser./// This is called at the beginning of every parse. This prevents the/// parser from running with inconsistent state (say, if a previous/// invocation returned an error and the parser is reused)./// Build an internal parser from a parser configuration and a pattern./// Return a reference to the parser state./// Return a reference to the pattern being parsed./// Create a new error with the given span and error type./// Return the current offset of the parser./// The offset starts at `0` from the beginning of the regular expression/// pattern string./// Return the current line number of the parser./// The line number starts at `1`./// Return the current column of the parser./// The column number starts at `1` and is reset whenever a `\n` is seen.next_capture_index/// Return the next capturing index. Each subsequent call increments the/// internal index./// The span given should correspond to the location of the opening/// parenthesis./// If the capture limit is exceeded, then an error is returned.add_capture_name/// Adds the given capture name to this parser. If this capture name has/// already been used, then an error is returned./// Return whether the parser should ignore whitespace or not./// Return the character at the current position of the parser./// This panics if the current position does not point to a valid char.char_at/// Return the character at the given position./// This panics if the given position does not point to a valid char./// Bump the parser to the next Unicode scalar value./// If the end of the input has been reached, then `false` is returned.bump_if/// If the substring starting at the current position of the parser has/// the given prefix, then bump the parser to the character immediately/// following the prefix and return true. Otherwise, don't bump the parser/// and return false.is_lookaround_prefix/// Returns true if and only if the parser is positioned at a look-around/// prefix. The conditions under which this returns true must always/// correspond to a regular expression that would otherwise be consider/// This should only be called immediately after parsing the opening of/// a group or a set of flags.bump_and_bump_space/// Bump the parser, and if the `x` flag is enabled, bump through any/// subsequent spaces. Return true if and only if the parser is not at/// EOF.bump_space/// If the `x` flag is enabled (i.e., whitespace insensitivity with/// comments), then this will advance the parser through all whitespace/// and comments to the next non-whitespace non-comment byte./// If the `x` flag is disabled, then this is a no-op./// This should be used selectively throughout the parser where/// arbitrary whitespace is permitted when the `x` flag is enabled. For/// example, `{   5  , 6}` is equivalent to `{5,6}`./// Peek at the next character in the input without advancing the parser./// If the input has been exhausted, then this returns `None`.peek_space/// Like peek, but will ignore spaces when the parser is in whitespace/// insensitive mode./// Returns true if the next call to `bump` would return false./// Return the current position of the parser, which includes the offset,/// line and column./// Create a span at the current position of the parser. Both the start/// and end of the span are set.span_char/// Create a span that covers the current character.push_alternate/// Parse and push a single alternation on to the parser's internal stack./// If the top of the stack already has an alternation, then add to that/// instead of pushing a new one./// The concatenation given corresponds to a single alternation branch./// The concatenation returned starts the next branch and is empty./// This assumes the parser is currently positioned at `|` and will advance/// the parser to the character following `|`.push_or_add_alternation/// Pushes or adds the given branch of an alternation to the parser's/// internal stack of state./// Parse and push a group AST (and its parent concatenation) on to the/// parser's internal stack. Return a fresh concatenation corresponding/// to the group's sub-AST./// If a set of flags was found (with no group), then the concatenation/// is returned with that set of flags added./// This assumes that the parser is currently positioned on the opening/// parenthesis. It advances the parser to the character at the start/// of the sub-expression (or adjoining expression)./// If there was a problem parsing the start of the group, then an error/// Pop a group AST from the parser's internal stack and set the group's/// AST to the given concatenation. Return the concatenation containing/// the group./// This assumes that the parser is currently positioned on the closing/// parenthesis and advances the parser to the character following the `)`./// If no such group could be popped, then an unopened group error ispop_group_end/// Pop the last state from the parser's internal stack, if it exists, and/// add the given concatenation to it. There either must be no state or a/// single alternation item on the stack. Any other scenario produces an/// This assumes that the parser has advanced to the end.push_class_open/// Parse the opening of a character class and push the current class/// parsing context onto the parser's stack. This assumes that the parser/// is positioned at an opening `[`. The given union should correspond to/// the union of set items built up before seeing the `[`./// If there was a problem parsing the opening of the class, then an error/// is returned. Otherwise, a new union of set items for the class is/// returned (which may be populated with either a `]` or a `-`).pop_class/// Parse the end of a character class set and pop the character class/// parser stack. The union given corresponds to the last union built/// before seeing the closing `]`. The union returned corresponds to the/// parent character class set with the nested class added to it./// This assumes that the parser is positioned at a `]` and will advance/// the parser to the byte immediately following the `]`./// If the stack is empty after popping, then this returns the final/// "top-level" character class AST (where a "top-level" character class/// is one that is not nested inside any other character class)./// If there is no corresponding opening bracket on the parser's stack,unclosed_class_error/// Return an "unclosed class" error whose span points to the most/// recently opened class./// This should only be called while parsing a character class.push_class_op/// Push the current set of class items on to the class parser's stack as/// the left hand side of the given operator./// A fresh set union is returned, which should be used to build the right/// hand side of this operator.pop_class_op/// Pop a character class set from the character class parser stack. If the/// top of the stack is just an item (not an operation), then return the/// given set unchanged. If the top of the stack is an operation, then the/// given set will be used as the rhs of the operation on the top of the/// stack. In that case, the binary operation is returned as a set.parse_uncounted_repetition/// Parses an uncounted repetition operation. An uncounted repetition/// operator includes ?, * and +, but does not include the {m,n} syntax./// The given `kind` should correspond to the operator observed by the/// This assumes that the parser is currently positioned at the repetition/// operator and advances the parser to the first character after the/// operator. (Note that the operator may include a single additional `?`,/// which makes the operator ungreedy.)/// The caller should include the concatenation that is being built. The/// concatenation returned includes the repetition operator applied to the/// last expression in the given concatenation.parse_counted_repetition/// Parses a counted repetition operation. A counted repetition operator/// corresponds to the {m,n} syntax, and does not include the ?, * or +/// operators./// This assumes that the parser is currently positioned at the opening `{`/// and advances the parser to the first character after the operator./// (Note that the operator may include a single additional `?`, which/// makes the operator ungreedy.)parse_group/// Parse a group (which contains a sub-expression) or a set of flags./// If a group was found, then it is returned with an empty AST. If a set/// of flags is found, then that set is returned./// The parser should be positioned at the opening parenthesis./// This advances the parser to the character before the start of the/// sub-expression (in the case of a group) or to the closing parenthesis/// immediately following the set of flags./// If flags are given and incorrectly specified, then a corresponding/// If a capture name is given and it is incorrectly specified, then a/// corresponding error is returned.parse_capture_name/// Parses a capture group name. Assumes that the parser is positioned at/// the first character in the name following the opening `<` (and may/// possibly be EOF). This advances the parser to the first character/// following the closing `>`./// The caller must provide the capture index of the group for this name.parse_flags/// Parse a sequence of flags starting at the current character./// This advances the parser to the character immediately following the/// flags, which is guaranteed to be either `:` or `)`./// If any flags are duplicated, then an error is returned./// If the negation operator is used more than once, then an error is/// If no flags could be found or if the negation operation is not followed/// by any flags, then an error is returned./// Parse the current character as a flag. Do not advance the parser./// If the flag is not recognized, then an error is returned.parse_primitive/// Parse a primitive AST. e.g., A literal, non-set character class or/// This assumes that the parser expects a primitive at the current/// location. i.e., All other non-primitive cases have been handled./// For example, if the parser's position is at `|`, then `|` will be/// treated as a literal (e.g., inside a character class)./// This advances the parser to the first character immediately following/// the primitive.parse_escape/// Parse an escape sequence as a primitive AST./// This assumes the parser is positioned at the start of the escape/// sequence, i.e., `\`. It advances the parser to the first position/// immediately following the escape sequence.maybe_parse_special_word_boundary/// Attempt to parse a specialty word boundary. That is, `\b{start}`,/// `\b{end}`, `\b{start-half}` or `\b{end-half}`./// This is similar to `maybe_parse_ascii_class` in that, in most cases,/// if it fails it will just return `None` with no error. This is done/// because `\b{5}` is a valid expression and we want to let that be parsed/// by the existing counted repetition parsing code. (I thought about just/// invoking the counted repetition code from here, but it seemed a little/// ham-fisted.)/// Unlike `maybe_parse_ascii_class` though, this can return an error./// Namely, if we definitely know it isn't a counted repetition, then we/// return an error specific to the specialty word boundaries./// This assumes the parser is positioned at a `{` immediately following/// a `\b`. When `None` is returned, the parser is returned to the position/// at which it started: pointing at a `{`./// The position given should correspond to the start of the `\b`.parse_octal/// Parse an octal representation of a Unicode codepoint up to 3 digits/// long. This expects the parser to be positioned at the first octal/// digit and advances the parser to the first character immediately/// following the octal number. This also assumes that parsing octal/// escapes is enabled./// Assuming the preconditions are met, this routine can never fail./// Parse a hex representation of a Unicode codepoint. This handles both/// hex notations, i.e., `\xFF` and `\x{FFFF}`. This expects the parser to/// be positioned at the `x`, `u` or `U` prefix. The parser is advanced to/// the first character immediately following the hexadecimal literal.parse_hex_digits/// Parse an N-digit hex representation of a Unicode codepoint. This/// expects the parser to be positioned at the first digit and will advance/// the parser to the first character immediately following the escape/// sequence./// The number of digits given must be 2 (for `\xNN`), 4 (for `\uNNNN`)/// or 8 (for `\UNNNNNNNN`).parse_hex_brace/// Parse a hex representation of any Unicode scalar value. This expects/// the parser to be positioned at the opening brace `{` and will advance/// the parser to the first character following the closing brace `}`.parse_decimal/// Parse a decimal number into a u32 while trimming leading and trailing/// whitespace./// This expects the parser to be positioned at the first position where/// a decimal digit could occur. This will advance the parser to the byte/// immediately following the last contiguous decimal digit./// If no decimal digit could be found or if there was a problem parsing/// the complete set of digits into a u32, then an error is returned.parse_set_class/// Parse a standard character class consisting primarily of characters or/// character ranges, but can also contain nested character classes of/// any type (sans `.`)./// This assumes the parser is positioned at the opening `[`. If parsing/// is successful, then the parser is advanced to the position immediately/// following the closing `]`.parse_set_class_range/// Parse a single primitive item in a character class set. The item to/// be parsed can either be one of a simple literal character, a range/// between two simple literal characters or a "primitive" character/// class like \w or \p{Greek}./// If an invalid escape is found, or if a character class is found where/// a simple literal is expected (e.g., in a range), then an error isparse_set_class_item/// Parse a single item in a character class as a primitive, where the/// primitive either consists of a verbatim literal or a single escape/// This assumes the parser is positioned at the beginning of a primitive,/// and advances the parser to the first position after the primitive if/// Note that it is the caller's responsibility to report an error if an/// illegal primitive was parsed.parse_set_class_open/// Parses the opening of a character class set. This includes the opening/// bracket along with `^` if present to indicate negation. This also/// starts parsing the opening set of unioned items if applicable, since/// there are special rules applied to certain characters in the opening/// of a character class. For example, `[^]]` is the class of all/// characters not equal to `]`. (`]` would need to be escaped in any other/// position.) Similarly for `-`./// In all cases, the op inside the returned `ast::ClassBracketed` is an/// empty union. This empty union should be replaced with the actual item/// when it is popped from the parser's stack./// This assumes the parser is positioned at the opening `[` and advances/// the parser to the first non-special byte of the character class./// An error is returned if EOF is found.maybe_parse_ascii_class/// Attempt to parse an ASCII character class, e.g., `[:alnum:]`./// This assumes the parser is positioned at the opening `[`./// If no valid ASCII character class could be found, then this does not/// advance the parser and `None` is returned. Otherwise, the parser is/// advanced to the first byte following the closing `]` and the/// corresponding ASCII class is returned.parse_unicode_class/// Parse a Unicode class in either the single character notation, `\pN`/// or the multi-character bracketed notation, `\p{Greek}`. This assumes/// the parser is positioned at the `p` (or `P` for negation) and will/// advance the parser to the character immediately following the class./// Note that this does not check whether the class name is valid or not.parse_perl_class/// Parse a Perl character class, e.g., `\d` or `\W`. This assumes the/// parser is currently at a valid character class name and will be/// advanced to the character immediately following the class./// The parser that is checking the nest limit./// The current depth while walking an Ast.NestLimiter/// A type that traverses a fully parsed Ast and checks whether its depth/// exceeds the specified nesting limit. If it does, then an error is returned.increment_depthdecrement_depthvisit_previsit_postvisit_class_set_item_previsit_class_set_item_postvisit_class_set_binary_op_previsit_class_set_binary_op_postspecialize_err/// When the result is an error, transforms the ast::ErrorKind from the source/// Result into another one. This function is used to return clearer error/// messages when possible.// Our own assert_eq, which has slightly better formatting (but honestly// still kind of crappy).TestError// We create these errors to compare with real ast::Errors in the tests.// We define equality between TestError and ast::Error to disregard the// pattern string in ast::Error, which is annoying to provide in tests.parser_octalparser_empty_min_rangeparser_nest_limitparser_ignore_whitespacenspan/// Short alias for creating a new span.npos/// Short alias for creating a new position./// Create a new span from the given offset range. This assumes a single/// line and sets the columns based on the offsets. i.e., This only works/// out of the box for ASCII, which is fine for most tests./// Create a new span for the corresponding byte range in the given string./// Create a verbatim literal starting at the given position.meta_lit/// Create a meta literal starting at the given position.lit_with/// Create a verbatim literal with the given span./// Create a concatenation with the given range.concat_with/// Create a concatenation with the given span./// Create an alternation with the given span./// Create a capturing group with the given span.flag_set/// Create an ast::SetFlags./// The given pattern should be the full pattern string. The range given/// should correspond to the byte offsets where the flag set occurs./// If negated is true, then the set is interpreted as beginning with a/// negation.parse_nest_limitparse_commentsparse_holisticparse_ignore_whitespaceparse_newlinesparse_alternateparse_unsupported_lookaroundparse_primitive_non_escapeparse_unsupported_backreferenceparse_hex_twoparse_hex_fourparse_hex_eightregression_454_nest_too_big// This tests a bug fix where the nest limit checker wasn't decrementing// its depth during post-traversal, which causes long regexes to trip// the default limit too aggressively.regression_455_trailing_dash_ignore_whitespace// This tests that we treat a trailing `-` in a character class as a// literal `-` even when whitespace mode is enabled and there is whitespace// after the trailing `-`./*!
This module provides a regular expression parser.
*/PrinterBuilder/// A builder for constructing a printer./// Note that since a printer doesn't have any configuration knobs, this type/// remains unexported./// A printer for a regular expression abstract syntax tree./// A printer converts an abstract syntax tree (AST) to a regular expression/// pattern string. This particular printer uses constant stack space and heap/// space proportional to the size of the AST./// This printer will not necessarily preserve the original formatting of the/// regular expression pattern string. For example, all whitespace and comments/// Create a new printer./// Print the given `Ast` to the given writer. The writer must implement/// `fmt::Write`. Typical implementations of `fmt::Write` that can be used/// here are a `fmt::Formatter` (which is available in `fmt::Display`/// implementations) or a `&mut String`.wtrvisit_alternation_invisit_class_set_binary_op_infmt_group_prefmt_group_postfmt_repetitionfmt_repetition_rangefmt_literalfmt_assertionfmt_set_flagsfmt_class_bracketed_prefmt_class_bracketed_postfmt_class_set_binary_op_kindfmt_class_perlfmt_class_asciifmt_class_unicoderoundtrip_withprint_dotprint_concatprint_alternationprint_assertionprint_repetitionprint_flagsprint_groupprint_class/*!
This module provides a regular expression printer for `Ast`.
*//// The result of visiting an AST./// An error that visiting an AST might return./// All implementors of `Visitor` must provide a `finish` method, which/// yields the result of visiting the AST or an error./// This method is called before beginning traversal of the AST./// This method is called on an `Ast` before descending into child `Ast`/// nodes./// This method is called on an `Ast` after descending all of its child/// `Ast` nodes./// This method is called between child nodes of an/// [`Alternation`](ast::Alternation).visit_concat_in/// This method is called between child nodes of a concatenation./// This method is called on every [`ClassSetItem`](ast::ClassSetItem)/// before descending into child nodes./// after descending into child nodes./// This method is called on every/// [`ClassSetBinaryOp`](ast::ClassSetBinaryOp) before descending into/// child nodes./// [`ClassSetBinaryOp`](ast::ClassSetBinaryOp) after descending into child/// This method is called between the left hand and right hand child nodes/// of a [`ClassSetBinaryOp`](ast::ClassSetBinaryOp)./// A trait for visiting an abstract syntax tree (AST) in depth first order./// The principle aim of this trait is to enable callers to perform case/// analysis on an abstract syntax tree without necessarily using recursion./// In particular, this permits callers to do case analysis with constant stack/// usage, which can be important since the size of an abstract syntax tree/// may be proportional to end user input./// Typical usage of this trait involves providing an implementation and then/// running it using the [`visit`] function./// Note that the abstract syntax tree for a regular expression is quite/// complex. Unless you specifically need it, you might be able to use the much/// simpler [high-level intermediate representation](crate::hir::Hir) and its/// [corresponding `Visitor` trait](crate::hir::Visitor) instead./// Executes an implementation of `Visitor` in constant stack space./// This function will visit every node in the given `Ast` while calling the/// appropriate methods provided by the [`Visitor`] trait./// The primary use case for this method is when one wants to perform case/// analysis over an `Ast` without using a stack size proportional to the depth/// of the `Ast`. Namely, this method will instead use constant stack size, but/// will use heap space proportional to the size of the `Ast`. This may be/// desirable in cases where the size of `Ast` is proportional to end user/// If the visitor returns an error at any point, then visiting is stopped and/// the error is returned./// A stack of `Ast` nodes. This is roughly analogous to the call stack/// used in a typical recursive visitor.ClassInductClassFrame/// Similar to the `Ast` stack above, but is used only for character/// classes. In particular, character classes embed their own mini/// recursive syntax.HeapVisitor/// HeapVisitor visits every item in an `Ast` recursively using constant stack/// size and a heap size proportional to the size of the `Ast`./// A stack frame allocated just before descending into a repetition/// operator's child node./// A stack frame allocated just before descending into a group's child/// The child node we are currently visiting./// The remaining child nodes to visit (which may be empty)./// The stack frame used while visiting every child node of a concatenation/// of expressions./// The stack frame used while visiting every child node of an alternation/// Represents a single stack frame while performing structural induction over/// an `Ast`./// The stack frame used while visiting every child node of a union of/// character class items./// The stack frame used while a binary class operation.BinaryLHS/// A stack frame allocated just before descending into a binary operator's/// left hand child node.BinaryRHS/// right hand child node./// a character class./// A representation of the inductive step when performing structural induction/// over a character class./// Note that there is no analogous explicit type for the inductive step for/// `Ast` nodes because the inductive step is just an `Ast`. For character/// classes, the inductive step can produce one of two possible child nodes:/// an item or a binary operation. (An item cannot be a binary operation/// because that would imply binary operations can be unioned in the concrete/// syntax, which is not possible.)induct/// Build a stack frame for the given AST if one is needed (which occurs if/// and only if there are child nodes in the AST). Otherwise, return None./// If this visits a class, then the underlying visitor implementation may/// return an error which will be passed on here./// Pops the given frame. If the frame has an additional inductive step,/// then return it, otherwise return `None`.visit_classvisit_class_pre/// Call the appropriate `Visitor` methods given an inductive step.visit_class_postinduct_class/// Build a stack frame for the given class node if one is needed (which/// occurs if and only if there are child nodes). Otherwise, return None./// Perform the next inductive step on this frame and return the next/// child AST node to visit./// child class node to visit.from_bracketed/// A type that provides a human readable debug impl for arbitrary bytes./// but will work for anything./// N.B. This is copied nearly verbatim from regex-automata. Sigh.utf8_decode/// A simple binary sum type./// This is occasionally useful in an ad hoc fashion./// An error that occurred while translating concrete syntax into abstract/// syntax (AST)./// An error that occurred while translating abstract syntax into a high/// level intermediate representation (HIR)./// This error type encompasses any error that can be returned by this crate./// The original regex pattern in which the error occurred./// The error kind. It must impl fmt::Display./// The primary span of the error.aux_span/// An auxiliary and optional span, in case the error needs to point to/// two locations (e.g., when reporting a duplicate capture group name)./// A helper type for formatting nice error messages./// This type is responsible for reporting regex parse errors in a nice human/// readable format. Most of its complexity is from interspersing notational/// markers pointing out the position where an error occurred./// The original regex pattern string.line_number_width/// The total width that should be used for line numbers. The width is/// used for left padding the line numbers for alignment./// A value of `0` means line numbers should not be displayed. That is,/// the pattern is itself only one line.by_line/// All error spans that occur on a single line. This sequence always has/// length equivalent to the number of lines in `pattern`, where the index/// of the sequence represents a line number, starting at `0`. The spans/// in each line are sorted in ascending order./// All error spans that occur over one or more lines. That is, the start/// and end position of the span have different line numbers. The spans are/// sorted in ascending order./// This type represents an arbitrary number of error spans in a way that makes/// it convenient to notate the regex pattern. ("Notate" means "point out/// exactly where the error occurred in the regex pattern.")/// Technically, we can only ever have two spans given our current error/// structure. However, after toiling with a specific algorithm for handling/// two spans, it became obvious that an algorithm to handle an arbitrary/// number of spans was actually much simpler.from_formatter/// Build a sequence of spans from a formatter./// Add the given span to this sequence, putting it in the right place.notate/// Notate the pattern string with carents (`^`) pointing at each span/// location. This only applies to spans that occur within a single line.notate_line/// Return notes for the line indexed at `i` (zero-based). If there are no/// spans for the given line, then `None` is returned. Otherwise, an/// appropriately space padded string with correctly positioned `^` is/// returned, accounting for line numbers.left_pad_line_number/// Left pad the given line number with spaces such that it is aligned with/// other line numbers.line_number_padding/// Return the line number padding beginning at the start of each line of/// If the pattern is only one line, then this returns a fixed padding/// for visual indentation.repeat_charassert_panic_messageregression_464// See: https://github.com/rust-lang/regex/issues/464repetition_quantifier_expects_a_valid_decimal// See: https://github.com/rust-lang/regex/issues/545/// A sorted set of non-overlapping ranges.folded/// While not required at all for correctness, we keep track of whether an/// interval set has been case folded or not. This helps us avoid doing/// redundant work if, for example, a set has already been cased folded./// And note that whether a set is folded or not is preserved through/// all of the pairwise set operations. That is, if both interval sets/// have been case folded, then any of difference, union, intersection or/// symmetric difference all produce a case folded set./// Note that when this is true, it *must* be the case that the set is case/// folded. But when it's false, the set *may* be case folded. In other/// words, we only set this to true when we know it to be case, but we're/// okay with it being false if it would otherwise be costly to determine/// whether it should be true. This means code cannot assume that a false/// value necessarily indicates that the set is not case folded./// Bottom line: this is a performance optimization.IntervalSet// We implement PartialEq manually so that we don't consider the set's internal// 'folded' property to be part of its identity. The 'folded' property is// strictly an optimization./// Create a new set from a sequence of intervals. Each interval is/// specified as a pair of bounds, where both bounds are inclusive./// The given ranges do not need to be in any specific order, and ranges/// Add a new interval to this set.IntervalSetIter/// Return an iterator over all intervals in this set./// The iterator yields intervals in ascending order.intervals/// Return an immutable slice of intervals in this set./// The sequence returned is in canonical ordering.case_fold_simpleCaseFoldError/// Expand this interval set such that it contains all case folded/// characters. For example, if this class consists of the range `a-z`,/// then applying case folding will result in the class containing both the/// ranges `a-z` and `A-Z`./// This returns an error if the necessary case mapping data is not/// Union this set with the given set, in place./// Intersect this set with the given set, in place./// Subtract the given set from this set, in place./// Compute the symmetric difference of the two sets, in place./// This computes the symmetric difference of two interval sets. This/// removes all elements in this set that are also in the given set,/// but also adds all elements from the given set that aren't in this/// set. That is, the set will contain all elements in either set,/// but will not contain any elements that are in both sets./// Negate this interval set./// For all `x` where `x` is any element, if `x` was in this set, then it/// will not be in this set after negation./// Converts this set into a canonical ordering./// Returns true if and only if this class is in a canonical ordering./// An iterator over intervals./// Create a new interval./// Union the given overlapping range into this range./// If the two ranges aren't contiguous, then this returns `None`./// Intersect this range with the given range and return the result./// If the intersection is empty, then this returns `None`./// Subtract the given range from this range and return the resulting/// If subtraction would result in an empty range, then no ranges areis_contiguous/// Returns true if and only if the two ranges are contiguous. Two ranges/// are contiguous if and only if the ranges are either overlapping or/// adjacent.is_intersection_empty/// Returns true if and only if the intersection of this range and the/// other range is empty./// Returns true if and only if this range is a subset of the other range.decrement// This module contains an *internal* implementation of interval sets.// The primary invariant that interval sets guards is canonical ordering. That// is, every interval set contains an ordered sequence of intervals where// no two intervals are overlapping or adjacent. While this invariant is// occasionally broken within the implementation, it should be impossible for// callers to observe it.// Since case folding (as implemented below) breaks that invariant, we roll// that into this API even though it is a little out of place in an otherwise// generic interval set. (Hence the reason why the `unicode` module is imported// here.)// Some of the implementation complexity here is a result of me wanting to// preserve the sequential representation without using additional memory.// In many cases, we do use linear extra memory, but it is at most 2x and it// is amortized. If we relaxed the memory requirements, this implementation// could become much simpler. The extra memory is honestly probably OK, but// character classes (especially of the Unicode variety) can become quite// large, and it would be nice to keep regex compilation snappy even in debug// builds. (In the past, I have been careless with this area of code and it has// caused slow regex compilations in debug mode, so this isn't entirely// unwarranted.)// Tests on this are relegated to the public API of HIR in src/hir.rs.// Tests for interval sets are written in src/hir.rs against the public API.ExtractKindlimit_classlimit_repeatlimit_literal_lenlimit_totalExtractor/// Extracts prefix or suffix literal sequences from [`Hir`] expressions./// Literal extraction is based on the following observations:/// * Many regexes start with one or a small number of literals./// * Substring search for literals is often much faster (sometimes by an order/// of magnitude) than a regex search./// Thus, in many cases, one can search for literals to find candidate starting/// locations of a match, and then only run the full regex engine at each such/// location instead of over the full haystack./// The main downside of literal extraction is that it can wind up causing a/// search to be slower overall. For example, if there are many matches or if/// there are many candidates that don't ultimately lead to a match, then a/// lot of overhead will be spent in shuffing back-and-forth between substring/// search and the regex engine. This is the fundamental reason why literal/// optimizations for regex patterns is sometimes considered a "black art."/// # Look-around assertions/// Literal extraction treats all look-around assertions as-if they match every/// empty string. So for example, the regex `\bquux\b` will yield a sequence/// containing a single exact literal `quux`. However, not all occurrences/// of `quux` correspond to a match a of the regex. For example, `\bquux\b`/// does not match `ZquuxZ` anywhere because `quux` does not fall on a word/// boundary./// In effect, if your regex contains look-around assertions, then a match of/// an exact literal does not necessarily mean the regex overall matches. So/// you may still need to run the regex engine in such cases to confirm the/// The precise guarantee you get from a literal sequence is: if every literal/// in the sequence is exact and the original regex contains zero look-around/// assertions, then a preference-order multi-substring search of those/// literals will precisely match a preference-order search of the original/// regex./// This shows how to extract prefixes:/// use regex_syntax::{hir::literal::{Extractor, Literal, Seq}, parse};/// let hir = parse(r"(a|b|c)(x|y|z)[A-Z]+foo")?;/// let got = Extractor::new().extract(&hir);/// // All literals returned are "inexact" because none of them reach the/// // match state./// let expected = Seq::from_iter([///     Literal::inexact("ax"),///     Literal::inexact("ay"),///     Literal::inexact("az"),///     Literal::inexact("bx"),///     Literal::inexact("by"),///     Literal::inexact("bz"),///     Literal::inexact("cx"),///     Literal::inexact("cy"),///     Literal::inexact("cz"),/// This shows how to extract suffixes:/// use regex_syntax::{///     hir::literal::{Extractor, ExtractKind, Literal, Seq},///     parse,/// let hir = parse(r"foo|[A-Z]+bar")?;/// let got = Extractor::new().kind(ExtractKind::Suffix).extract(&hir);/// // Since 'foo' gets to a match state, it is considered exact. But 'bar'/// // does not because of the '[A-Z]+', and thus is marked inexact.///     Literal::exact("foo"),///     Literal::inexact("bar"),/// Create a new extractor with a default configuration./// The extractor can be optionally configured before calling/// [`Extractor::extract`] to get a literal sequence./// Execute the extractor and return a sequence of literals./// Set the kind of literal sequence to extract from an [`Hir`] expression./// The default is to extract prefixes, but suffixes can be selected/// instead. The contract for prefixes is that every match of the/// corresponding `Hir` must start with one of the literals in the sequence/// returned. Moreover, the _order_ of the sequence returned corresponds to/// the preference order./// Suffixes satisfy a similar contract in that every match of the/// corresponding `Hir` must end with one of the literals in the sequence/// returned. However, there is no guarantee that the literals are in/// preference order./// Remember that a sequence can be infinite. For example, unless the/// limits are configured to be impractically large, attempting to extract/// prefixes (or suffixes) for the pattern `[A-Z]` will return an infinite/// sequence. Generally speaking, if the sequence returned is infinite,/// then it is presumed to be unwise to do prefix (or suffix) optimizations/// for the pattern./// Configure a limit on the length of the sequence that is permitted for/// a character class. If a character class exceeds this limit, then the/// sequence returned for it is infinite./// This prevents classes like `[A-Z]` or `\pL` from getting turned into/// huge and likely unproductive sequences of literals./// This example shows how this limit can be lowered to decrease the tolerance/// for character classes being turned into literal sequences./// use regex_syntax::{hir::literal::{Extractor, Seq}, parse};/// let hir = parse(r"[0-9]")?;/// let expected = Seq::new([///     "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",/// // Now let's shrink the limit and see how that changes things./// let got = Extractor::new().limit_class(4).extract(&hir);/// let expected = Seq::infinite();/// Configure a limit on the total number of repetitions that is permitted/// before literal extraction is stopped./// This is useful for limiting things like `(abcde){50}`, or more/// insidiously, `(?:){1000000000}`. This limit prevents any one single/// repetition from adding too much to a literal sequence./// With this limit set, repetitions that exceed it will be stopped and any/// literals extracted up to that point will be made inexact./// This shows how to decrease the limit and compares it with the default./// let hir = parse(r"(abc){8}")?;/// let expected = Seq::new(["abcabcabcabcabcabcabcabc"]);/// let got = Extractor::new().limit_repeat(4).extract(&hir);///     Literal::inexact("abcabcabcabc"),/// Configure a limit on the maximum length of any literal in a sequence./// This is useful for limiting things like `(abcde){5}{5}{5}{5}`. While/// each repetition or literal in that regex is small, when all the/// repetitions are applied, one ends up with a literal of length `5^4 =/// 625`./// With this limit set, literals that exceed it will be made inexact and/// thus prevented from growing./// let hir = parse(r"(abc){2}{2}{2}")?;/// let got = Extractor::new().limit_literal_len(14).extract(&hir);///     Literal::inexact("abcabcabcabcab"),/// Configure a limit on the total number of literals that will be/// This is useful as a practical measure for avoiding the creation of/// large sequences of literals. While the extractor will automatically/// handle local creations of large sequences (for example, `[A-Z]` yields/// an infinite sequence by default), large sequences can be created/// through non-local means as well./// For example, `[ab]{3}{3}` would yield a sequence of length `512 = 2^9`/// despite each of the repetitions being small on their own. This limit/// thus represents a "catch all" for avoiding locally small sequences from/// combining into large sequences./// This example shows how reducing the limit will change the literal/// sequence returned./// let hir = parse(r"[ab]{2}{2}")?;///     "aaaa", "aaab", "aaba", "aabb",///     "abaa", "abab", "abba", "abbb",///     "baaa", "baab", "baba", "babb",///     "bbaa", "bbab", "bbba", "bbbb",/// // The default limit is not too big, but big enough to extract all/// // literals from '[ab]{2}{2}'. If we shrink the limit to less than 16,/// // then we'll get a truncated set. Notice that it returns a sequence of/// // length 4 even though our limit was 10. This is because the sequence/// // is difficult to increase without blowing the limit. Notice also/// // that every literal in the sequence is now inexact because they were/// // stripped of some suffix./// let got = Extractor::new().limit_total(10).extract(&hir);///     Literal::inexact("aa"),///     Literal::inexact("ab"),///     Literal::inexact("ba"),///     Literal::inexact("bb"),extract_concat/// Extract a sequence from the given concatenation. Sequences from each of/// the child HIR expressions are combined via cross product./// This short circuits once the cross product turns into a sequence/// containing only inexact literals.extract_alternation/// Extract a sequence from the given alternation./// This short circuits once the union turns into an infinite sequence.extract_repetition/// Extract a sequence of literals from the given repetition. We do our/// best, Some examples:///   'a*'    => [inexact(a), exact("")]///   'a*?'   => [exact(""), inexact(a)]///   'a+'    => [inexact(a)]///   'a{3}'  => [exact(aaa)]///   'a{3,5} => [inexact(aaa)]/// The key here really is making sure we get the 'inexact' vs 'exact'/// attributes correct on each of the literals we add. For example, the/// fact that 'a*' gives us an inexact 'a' and an exact empty string means/// that a regex like 'ab*c' will result in [inexact(ab), exact(ac)]/// literals being extracted, which might actually be a better prefilter/// than just 'a'.extract_class_unicode/// Convert the given Unicode class into a sequence of literals if the/// class is small enough. If the class is too big, return an infiniteextract_class_bytes/// Convert the given byte class into a sequence of literals if the class/// is small enough. If the class is too big, return an infinite sequence.class_over_limit_unicode/// Returns true if the given Unicode class exceeds the configured limits/// on this extractor.class_over_limit_bytes/// Returns true if the given byte class exceeds the configured limits on/// this extractor./// Compute the cross product of the two sequences if the result would be/// within configured limits. Otherwise, make `seq2` infinite and cross the/// infinite sequence with `seq1`./// Union the two sequences if the result would be within configured/// limits. Otherwise, make `seq2` infinite and union the infinite sequence/// with `seq1`.enforce_literal_len/// Applies the literal length limit to the given sequence. If none of the/// literals in the sequence exceed the limit, then this is a no-op./// Extracts only prefix literals from a regex./// Extracts only suffix literals from a regex./// Note that the sequence returned by suffix literals currently may/// not correctly represent leftmost-first or "preference" order match/// The kind of literals to extract from an [`Hir`] expression./// The default extraction kind is `Prefix`./// Returns true if this kind is the `Prefix` variant./// Returns true if this kind is the `Suffix` variant.literals/// The members of this seq./// When `None`, the seq represents all possible literals. That is, it/// prevents one from making assumptions about specific literals in the/// seq, and forces one to treat it as if any literal might be in the seq./// Note that `Some(vec![])` is valid and corresponds to the empty seq of/// literals, i.e., a regex that can never match. For example, `[a&&b]`./// It is distinct from `Some(vec![""])`, which corresponds to the seq/// containing an empty string, which matches at every position./// A sequence of literals./// A `Seq` is very much like a set in that it represents a union of its/// members. That is, it corresponds to a set of literals where at least one/// must match in order for a particular [`Hir`] expression to match. (Whether/// this corresponds to the entire `Hir` expression, a prefix of it or a suffix/// of it depends on how the `Seq` was extracted from the `Hir`.)/// It is also unlike a set in that multiple identical literals may appear,/// and that the order of the literals in the `Seq` matters. For example, if/// the sequence is `[sam, samwise]` and leftmost-first matching is used, then/// `samwise` can never match and the sequence is equivalent to `[sam]`./// # States of a sequence/// A `Seq` has a few different logical states to consider:/// * The sequence can represent "any" literal. When this happens, the set does/// not have a finite size. The purpose of this state is to inhibit callers/// from making assumptions about what literals are required in order to match/// a particular [`Hir`] expression. Generally speaking, when a set is in this/// state, literal optimizations are inhibited. A good example of a regex that/// will cause this sort of set to appear is `[A-Za-z]`. The character class/// is just too big (and also too narrow) to be usefully expanded into 52/// different literals. (Note that the decision for when a seq should become/// infinite is determined by the caller. A seq itself has no hard-coded/// limits.)/// * The sequence can be empty, in which case, it is an affirmative statement/// that there are no literals that can match the corresponding `Hir`./// Consequently, the `Hir` never matches any input. For example, `[a&&b]`./// * The sequence can be non-empty, in which case, at least one of the/// literals must match in order for the corresponding `Hir` to match./// This example shows how literal sequences can be simplified by stripping/// suffixes and minimizing while maintaining preference order./// use regex_syntax::hir::literal::{Literal, Seq};/// let mut seq = Seq::new(&[///     "farm",///     "appliance",///     "faraway",///     "apple",///     "fare",///     "gap",///     "applicant",///     "applaud",/// seq.keep_first_bytes(3);/// seq.minimize_by_preference();/// // Notice that 'far' comes before 'app', which matches the order in the/// // original sequence. This guarantees that leftmost-first semantics are/// // not altered by simplifying the set.///     Literal::inexact("far"),///     Literal::inexact("app"),///     Literal::exact("gap"),/// assert_eq!(expected, seq);/// Returns an empty sequence./// An empty sequence matches zero literals, and thus corresponds to a/// regex that itself can never match./// Returns a sequence of literals without a finite size and may contain/// any literal./// A sequence without finite size does not reveal anything about the/// characteristics of the literals in its set. There are no fixed prefixes/// or suffixes, nor are lower or upper bounds on the length of the literals/// in the set known./// This is useful to represent constructs in a regex that are "too big"/// to useful represent as a sequence of literals. For example, `[A-Za-z]`./// When sequences get too big, they lose their discriminating nature and/// are more likely to produce false positives, which in turn makes them/// less likely to speed up searches./// More pragmatically, for many regexes, enumerating all possible literals/// is itself not possible or might otherwise use too many resources. So/// constraining the size of sets during extraction is a practical trade/// off to make./// Returns a sequence containing a single literal./// Returns a sequence of exact literals from the given byte strings./// If this is a finite sequence, return its members as a slice of/// literals./// The slice returned may be empty, in which case, there are no literals/// that can match this sequence./// Push a literal to the end of this sequence./// If this sequence is not finite, then this is a no-op./// Similarly, if the most recently added item of this sequence is/// equivalent to the literal given, then it is not added. This reflects/// a `Seq`'s "set like" behavior, and represents a practical trade off./// Namely, there is never any need to have two adjacent and equivalent/// literals in the same sequence, _and_ it is easy to detect in somemake_inexact/// Make all of the literals in this sequence inexact./// This is a no-op if this sequence is not finite.make_infinite/// Converts this sequence to an infinite sequence./// This is a no-op if the sequence is already infinite.cross_forward/// Modify this sequence to contain the cross product between it and the/// sequence given./// The cross product only considers literals in this sequence that are/// exact. That is, inexact literals are not extended./// The literals are always drained from `other`, even if none are used./// This permits callers to reuse the sequence allocation elsewhere./// If this sequence is infinite, then this is a no-op, regardless of what/// `other` contains (and in this case, the literals are still drained from/// `other`). If `other` is infinite and this sequence is finite, then this/// is a no-op, unless this sequence contains a zero-length literal. In/// which case, the infiniteness of `other` infects this sequence, and this/// sequence is itself made infinite./// Like [`Seq::union`], this may attempt to deduplicate literals. See/// [`Seq::dedup`] for how deduplication deals with exact and inexact/// This example shows basic usage and how exact and inexact literals/// interact./// let mut seq1 = Seq::from_iter([/// let mut seq2 = Seq::from_iter([///     Literal::inexact("quux"),///     Literal::exact("baz"),/// seq1.cross_forward(&mut seq2);/// // The literals are pulled out of seq2./// assert_eq!(Some(0), seq2.len());///     Literal::inexact("fooquux"),///     Literal::exact("foobaz"),/// assert_eq!(expected, seq1);/// This example shows the behavior of when `other` is an infinite/// let mut seq2 = Seq::infinite();/// // When seq2 is infinite, cross product doesn't add anything, but/// // ensures all members of seq1 are inexact.///     Literal::inexact("foo"),/// This example is like the one above, but shows what happens when this/// sequence contains an empty string. In this case, an infinite `other`/// sequence infects this sequence (because the empty string means that/// there are no finite prefixes):///     Literal::exact(""), // inexact provokes same behavior/// // seq1 is now infinite!/// assert!(!seq1.is_finite());/// This example shows the behavior of this sequence is infinite./// let mut seq1 = Seq::infinite();/// // seq1 remains unchanged./// // Even though the literals in seq2 weren't used, it was still drained.cross_reverse/// Modify this sequence to contain the cross product between it and/// the sequence given, where the sequences are treated as suffixes/// instead of prefixes. Namely, the sequence `other` is *prepended*/// to `self` (as opposed to `other` being *appended* to `self` in/// [`Seq::cross_forward`])./// seq1.cross_reverse(&mut seq2);///     Literal::inexact("quuxfoo"),///     Literal::exact("bazfoo"),/// there are no finite suffixes):/// This example shows the behavior when this sequence is infinite.cross_preamble/// A helper function the corresponds to the subtle preamble for both/// `cross_forward` and `cross_reverse`. In effect, it handles the cases/// of infinite sequences for both `self` and `other`, as well as ensuring/// that literals from `other` are drained even if they aren't used./// Unions the `other` sequence into this one./// The literals are always drained out of the given `other` sequence,/// even if they are being unioned into an infinite sequence. This permits/// the caller to reuse the `other` sequence in another context./// Some literal deduping may be performed. If any deduping happens,/// any leftmost-first or "preference" order match semantics will be/// preserved./// This example shows basic usage./// use regex_syntax::hir::literal::Seq;/// let mut seq1 = Seq::new(&["foo", "bar"]);/// let mut seq2 = Seq::new(&["bar", "quux", "foo"]);/// seq1.union(&mut seq2);/// // Adjacent literals are deduped, but non-adjacent literals may not be./// assert_eq!(Seq::new(&["foo", "bar", "quux", "foo"]), seq1);/// This example shows that literals are drained from `other` even when/// they aren't necessarily used./// // Infinite sequences have no finite length./// assert_eq!(None, seq1.len());/// // seq1 is still infinite and seq2 has been drained.union_into_empty/// Unions the `other` sequence into this one by splice the `other`/// sequence at the position of the first zero-length literal./// This is useful for preserving preference order semantics when combining/// two literal sequences. For example, in the regex `(a||f)+foo`, the/// correct preference order prefix sequence is `[a, foo, f]`./// the caller to reuse the `other` sequence in another context. Note that/// the literals are drained even if no union is performed as well, i.e.,/// when this sequence does not contain a zero-length literal./// let mut seq1 = Seq::new(&["a", "", "f", ""]);/// let mut seq2 = Seq::new(&["foo"]);/// seq1.union_into_empty(&mut seq2);/// // 'foo' gets spliced into seq1 where the first empty string occurs./// assert_eq!(Seq::new(&["a", "foo", "f"]), seq1);/// // seq1 has no zero length literals, so no splicing happens./// assert_eq!(Seq::new(&["foo", "bar"]), seq1);/// // Even though no splicing happens, seq2 is still drained./// Deduplicate adjacent equivalent literals in this sequence./// If adjacent literals are equivalent strings but one is exact and the/// other inexact, the inexact literal is kept and the exact one is/// Deduping an infinite sequence is a no-op./// This example shows how literals that are duplicate byte strings but/// are not equivalent with respect to exactness are resolved./// let mut seq = Seq::from_iter([/// seq.dedup();/// assert_eq!(Seq::from_iter([Literal::inexact("foo")]), seq);/// Sorts this sequence of literals lexicographically./// Note that if, before sorting, if a literal that is a prefix of another/// literal appears after it, then after sorting, the sequence will not/// represent the same preference order match semantics. For example,/// sorting the sequence `[samwise, sam]` yields the sequence `[sam,/// samwise]`. Under preference order semantics, the latter sequence will/// never match `samwise` where as the first sequence can./// let mut seq = Seq::new(&["foo", "quux", "bar"]);/// seq.sort();/// assert_eq!(Seq::new(&["bar", "foo", "quux"]), seq);reverse_literals/// Reverses all of the literals in this sequence./// The order of the sequence itself is preserved./// let mut seq = Seq::new(&["oof", "rab"]);/// seq.reverse_literals();/// assert_eq!(Seq::new(&["foo", "bar"]), seq);minimize_by_preference/// Shrinks this seq to its minimal size while respecting the preference/// order of its literals./// While this routine will remove duplicate literals from this seq, it/// will also remove literals that can never match in a leftmost-first or/// "preference order" search. Similar to [`Seq::dedup`], if a literal is/// deduped, then the one that remains is made inexact./// This is a no-op on seqs that are empty or not finite./// This example shows the difference between `{sam, samwise}` and/// `{samwise, sam}`./// // If 'sam' comes before 'samwise' and a preference order search is/// // executed, then 'samwise' can never match./// let mut seq = Seq::new(&["sam", "samwise"]);/// assert_eq!(Seq::from_iter([Literal::inexact("sam")]), seq);/// // But if they are reversed, then it's possible for 'samwise' to match/// // since it is given higher preference./// let mut seq = Seq::new(&["samwise", "sam"]);/// assert_eq!(Seq::new(&["samwise", "sam"]), seq);/// This example shows that if an empty string is in this seq, then/// anything that comes after it can never match./// // An empty string is a prefix of all strings, so it automatically/// // inhibits any subsequent strings from matching./// let mut seq = Seq::new(&["foo", "bar", "", "quux", "fox"]);///     Literal::exact("bar"),///     Literal::inexact(""),/// // And of course, if it's at the beginning, then it makes it impossible/// // for anything else to match./// let mut seq = Seq::new(&["", "foo", "quux", "fox"]);/// assert_eq!(Seq::from_iter([Literal::inexact("")]), seq);keep_first_bytes/// Trims all literals in this seq such that only the first `len` bytes/// remain. If a literal has less than or equal to `len` bytes, then it/// remains unchanged. Otherwise, it is trimmed and made inexact./// let mut seq = Seq::new(&["a", "foo", "quux"]);/// seq.keep_first_bytes(2);///     Literal::exact("a"),///     Literal::inexact("fo"),///     Literal::inexact("qu"),keep_last_bytes/// Trims all literals in this seq such that only the last `len` bytes/// seq.keep_last_bytes(2);///     Literal::inexact("oo"),///     Literal::inexact("ux"),/// Returns true if this sequence is finite./// When false, this sequence is infinite and must be treated as if it/// contains every possible literal./// Returns true if and only if this sequence is finite and empty./// An empty sequence never matches anything. It can only be produced by/// literal extraction when the corresponding regex itself cannot match./// Returns the number of literals in this sequence if the sequence is/// finite. If the sequence is infinite, then `None` is returned.is_exact/// Returns true if and only if all literals in this sequence are exact./// This returns false if the sequence is infinite.is_inexact/// Returns true if and only if all literals in this sequence are inexact./// This returns true if the sequence is infinite.max_union_len/// Return the maximum length of the sequence that would result from/// unioning `self` with `other`. If either set is infinite, then thismax_cross_len/// Return the maximum length of the sequence that would result from the/// cross product of `self` with `other`. If either set is infinite, then/// this returns `None`.min_literal_len/// Returns the length of the shortest literal in this sequence./// If the sequence is infinite or empty, then this returns `None`.max_literal_len/// Returns the length of the longest literal in this sequence.longest_common_prefix/// Returns the longest common prefix from this seq./// If the seq matches any literal or other contains no literals, then/// there is no meaningful prefix and this returns `None`./// This shows some example seqs and their longest common prefix./// let seq = Seq::new(&["foo", "foobar", "fo"]);/// assert_eq!(Some(&b"fo"[..]), seq.longest_common_prefix());/// let seq = Seq::new(&["foo", "foo"]);/// assert_eq!(Some(&b"foo"[..]), seq.longest_common_prefix());/// let seq = Seq::new(&["foo", "bar"]);/// assert_eq!(Some(&b""[..]), seq.longest_common_prefix());/// let seq = Seq::new(&[""]);/// let seq = Seq::infinite();/// assert_eq!(None, seq.longest_common_prefix());/// let seq = Seq::empty();longest_common_suffix/// Returns the longest common suffix from this seq./// there is no meaningful suffix and this returns `None`./// This shows some example seqs and their longest common suffix./// let seq = Seq::new(&["oof", "raboof", "of"]);/// assert_eq!(Some(&b"of"[..]), seq.longest_common_suffix());/// assert_eq!(Some(&b"foo"[..]), seq.longest_common_suffix());/// assert_eq!(Some(&b""[..]), seq.longest_common_suffix());/// assert_eq!(None, seq.longest_common_suffix());optimize_for_prefix_by_preference/// Optimizes this seq while treating its literals as prefixes and/// respecting the preference order of its literals./// The specific way "optimization" works is meant to be an implementation/// detail, as it essentially represents a set of heuristics. The goal/// that optimization tries to accomplish is to make the literals in this/// set reflect inputs that will result in a more effective prefilter./// Principally by reducing the false positive rate of candidates found by/// the literals in this sequence. That is, when a match of a literal is/// found, we would like it to be a strong predictor of the overall match/// of the regex. If it isn't, then much time will be spent starting and/// stopping the prefilter search and attempting to confirm the match only/// to have it fail./// Some of those heuristics might be:/// * Identifying a common prefix from a larger sequence of literals, and/// shrinking the sequence down to that single common prefix./// * Rejecting the sequence entirely if it is believed to result in very/// high false positive rate. When this happens, the sequence is made/// infinite./// * Shrinking the sequence to a smaller number of literals representing/// prefixes, but not shrinking it so much as to make literals too short./// (A sequence with very short literals, of 1 or 2 bytes, will typically/// result in a higher false positive rate.)/// Optimization should only be run once extraction is complete. Namely,/// optimization may make assumptions that do not compose with other/// operations in the middle of extraction. For example, optimization will/// reduce `[E(sam), E(samwise)]` to `[E(sam)]`, but such a transformation/// is only valid if no other extraction will occur. If other extraction/// may occur, then the correct transformation would be to `[I(sam)]`./// The [`Seq::optimize_for_suffix_by_preference`] does the same thing, but/// for suffixes./// This shows how optimization might transform a sequence. Note that/// the specific behavior is not a documented guarantee. The heuristics/// used are an implementation detail and may change over time in semver/// compatible releases./// use regex_syntax::hir::literal::{Seq, Literal};///     "samantha",///     "sam",///     "samwise",///     "frodo",/// seq.optimize_for_prefix_by_preference();/// assert_eq!(Seq::from_iter([///     Literal::exact("samantha"),///     // Kept exact even though 'samwise' got pruned///     // because optimization assumes literal extraction///     // has finished.///     Literal::exact("sam"),///     Literal::exact("frodo"),/// ]), seq);/// # Example: optimization may make the sequence infinite/// If the heuristics deem that the sequence could cause a very high false/// positive rate, then it may make the sequence infinite, effectively/// disabling its use as a prefilter.///     // An empty string matches at every position,///     // thus rendering the prefilter completely///     // ineffective.///     "",/// assert!(!seq.is_finite());/// Do note that just because there is a `" "` in the sequence, that/// doesn't mean the sequence will always be made infinite after it is/// optimized. Namely, if the sequence is considered exact (any match/// corresponds to an overall match of the original regex), then any match/// is an overall match, and so the false positive rate is always `0`./// To demonstrate this, we remove `samwise` from our sequence. This/// results in no optimization happening and all literals remain exact./// Thus the entire sequence is exact, and it is kept as-is, even though/// one is an ASCII space:///     " ",/// assert!(seq.is_finite());optimize_for_suffix_by_preference/// Optimizes this seq while treating its literals as suffixes and/// Optimization should only be run once extraction is complete./// The [`Seq::optimize_for_prefix_by_preference`] does the same thing, but/// for prefixes. See its documentation for more explanation.optimize_by_preference/// A single literal extracted from an [`Hir`] expression./// A literal is composed of two things:/// * A sequence of bytes. No guarantees with respect to UTF-8 are provided./// In particular, even if the regex a literal is extracted from is UTF-8, the/// literal extracted may not be valid UTF-8. (For example, if an [`Extractor`]/// limit resulted in trimming a literal in a way that splits a codepoint.)/// * Whether the literal is "exact" or not. An "exact" literal means that it/// has not been trimmed, and may continue to be extended. If a literal is/// "exact" after visiting the entire `Hir` expression, then this implies that/// the literal leads to a match state. (Although it doesn't necessarily imply/// all occurrences of the literal correspond to a match of the regex, since/// literal extraction ignores look-around assertions.)/// Returns a new exact literal containing the bytes given.inexact/// Returns a new inexact literal containing the bytes given./// Returns the bytes in this literal./// Yields ownership of the bytes inside this literal./// Note that this throws away whether the literal is "exact" or not./// Returns the length of this literal in bytes./// Returns true if and only if this literal has zero bytes./// Returns true if and only if this literal is exact./// Marks this literal as inexact./// Inexact literals can never be extended. For example,/// [`Seq::cross_forward`] will not extend inexact literals./// Reverse the bytes in this literal./// Extend this literal with the literal given./// If this literal is inexact, then this is a no-op./// Trims this literal such that only the first `len` bytes remain. If/// this literal has fewer than `len` bytes, then it remains unchanged./// Otherwise, the literal is marked as inexact./// Trims this literal such that only the last `len` bytes remain. If this/// literal has fewer than `len` bytes, then it remains unchanged.is_poisonous/// Returns true if it is believe that this literal is likely to match very/// frequently, and is thus not a good candidate for a prefilter./// The states in this trie. The index of a state in this vector is its ID./// This vec indicates which states are match states. It always has/// the same length as `states` and is indexed by the same state ID./// A state with identifier `sid` is a match state if and only if/// `matches[sid].is_some()`. The option contains the index of the literal/// corresponding to the match. The index is offset by 1 so that it fits in/// a NonZeroUsize.next_literal_index/// The index to allocate to the next literal added to this trie. Starts at/// 1 and increments by 1 for every literal successfully added to the trie.PreferenceTrie/// A "preference" trie that rejects literals that will never match when/// executing a leftmost first or "preference" search./// For example, if 'sam' is inserted, then trying to insert 'samwise' will be/// rejected because 'samwise' can never match since 'sam' will always take/// priority. However, if 'samwise' is inserted first, then inserting 'sam'/// after it is accepted. In this case, either 'samwise' or 'sam' can match in/// a "preference" search./// Note that we only use this trie as a "set." That is, given a sequence of/// literals, we insert each one in order. An `insert` will reject a literal/// if a prefix of that literal already exists in the trie. Thus, to rebuild/// the "minimal" sequence, we simply only keep literals that were successfully/// inserted. (Since we don't need traversal, one wonders whether we can make/// some simplifications here, but I haven't given it a ton of thought and I've/// never seen this show up on a profile. Because of the heuristic limits/// imposed on literal extractions, the size of the inputs here is usually/// very small.)/// Sparse representation of the transitions out of this state. Transitions/// are sorted by byte. There is at most one such transition for any/// particular byte./// A single state in a trie. Uses a sparse representation for its transitions./// Minimizes the given sequence of literals while preserving preference/// order semantics./// When `keep_exact` is true, the exactness of every literal retained is/// kept. This is useful when dealing with a fully extracted `Seq` that/// only contains exact literals. In that case, we can keep all retained/// literals as exact because we know we'll never need to match anything/// after them and because any removed literals are guaranteed to never/// Returns `Ok` if the given byte string is accepted into this trie and/// `Err` otherwise. The index for the success case corresponds to the/// index of the literal added. The index for the error case corresponds to/// the index of the literal already in the trie that prevented the given/// byte string from being added. (Which implies it is a prefix of the one/// given.)/// In short, the byte string given is accepted into the trie if and only/// if it is possible for it to match when executing a preference order/// Returns the root state ID, and if it doesn't exist, creates it.create_state/// Creates a new empty state and returns its ID./// Returns the "rank" of the given byte./// The minimum rank value is `0` and the maximum rank value is `255`./// The rank of a byte is derived from a heuristic background distribution of/// relative frequencies of bytes. The heuristic says that lower the rank of a/// byte, the less likely that byte is to appear in any arbitrary haystack.I1anything// This tests patterns that contain something that defeats literal// detection, usually because it would blow some limit on the total number// of literals that can be returned.// The main idea is that when literal extraction sees something that// it knows will blow a limit, it replaces it with a marker that says// "any literal will match here." While not necessarily true, the// over-estimation is just fine for the purposes of literal extraction,// because the imprecision doesn't matter: too big is too big.// This is one of the trickier parts of literal extraction, since we need// to make sure all of our literal extraction operations correctly compose// with the markers.anything_small_limits// Like the 'anything' test, but it uses smaller limits in order to test// the logic for effectively aborting literal extraction when the seqs get// too big.odds_and_endsholmes// This tests a specific regex along with some heuristic steps to reduce// the sequences extracted. This is meant to roughly correspond to the// types of heuristics used to shrink literal sets in practice. (Shrinking// is done because you want to balance "spend too much work looking for// too many literals" and "spend too much work processing false positive// matches from short literals.")holmes_alt// This tests that we get some kind of literals extracted for a beefier// alternation with case insensitive mode enabled. At one point during// development, this returned nothing, and motivated some special case// code in Extractor::union to try and trim down the literal sequences// if the union would blow the limits set.crazy_repeats// See: https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8// See: CVE-2022-24713// We test this here to ensure literal extraction completes in reasonable// time and isn't materially impacted by these sorts of pathological// repeats.optimize/*!
Provides literal extraction from `Hir` expressions.

An [`Extractor`] pulls literals out of [`Hir`] expressions and returns a
[`Seq`] of [`Literal`]s.

The purpose of literal extraction is generally to provide avenues for
optimizing regex searches. The main idea is that substring searches can be an
order of magnitude faster than a regex search. Therefore, if one can execute
a substring search to find candidate match locations and only run the regex
search at those locations, then it is possible for huge improvements in
performance to be realized.

With that said, literal optimizations are generally a black art because even
though substring search is generally faster, if the number of candidates
produced is high, then it can create a lot of overhead by ping-ponging between
the substring search and the regex search.

Here are some heuristics that might be used to help increase the chances of
effective literal optimizations:

* Stick to small [`Seq`]s. If you search for too many literals, it's likely
to lead to substring search that is only a little faster than a regex search,
and thus the overhead of using literal optimizations in the first place might
make things slower overall.
* The literals in your [`Seq`] shouldn't be too short. In general, longer is
better. A sequence corresponding to single bytes that occur frequently in the
haystack, for example, is probably a bad literal optimization because it's
likely to produce many false positive candidates. Longer literals are less
likely to match, and thus probably produce fewer false positives.
* If it's possible to estimate the approximate frequency of each byte according
to some pre-computed background distribution, it is possible to compute a score
of how "good" a `Seq` is. If a `Seq` isn't good enough, you might consider
skipping the literal optimization and just use the regex engine.

(It should be noted that there are always pathological cases that can make
any kind of literal optimization be a net slower result. This is why it
might be a good idea to be conservative, or to even provide a means for
literal optimizations to be dynamically disabled if they are determined to be
ineffective according to some measure.)

You're encouraged to explore the methods on [`Seq`], which permit shrinking
the size of sequences in a preference-order preserving fashion.

Finally, note that it isn't strictly necessary to use an [`Extractor`]. Namely,
an `Extractor` only uses public APIs of the [`Seq`] and [`Literal`] types,
so it is possible to implement your own extractor. For example, for n-grams
or "inner" literals (i.e., not prefix or suffix literals). The `Extractor`
is mostly responsible for the case analysis over `Hir` expressions. Much of
the "trickier" parts are how to combine literal sequences, and that is all
implemented on [`Seq`].
*//// The original pattern that the translator's Ast was parsed from. Every/// The span of this error, derived from the Ast given to the translator./// An error that can occur while translating an `Ast` to a `Hir`.UnicodeNotAllowed/// This error occurs when a Unicode feature is used when Unicode/// support is disabled. For example `(?-u:\pL)` would trigger this error./// This error occurs when translating a pattern that could match a byte/// sequence that isn't UTF-8 and `utf8` was enabled.InvalidLineTerminator/// This error occurs when one uses a non-ASCII byte for a line terminator,/// but where Unicode mode is enabled and UTF-8 mode is disabled.UnicodePropertyNotFound/// This occurs when an unrecognized Unicode property name could not/// be found.UnicodePropertyValueNotFound/// This occurs when an unrecognized Unicode property value could notUnicodePerlClassNotFound/// This occurs when a Unicode-aware Perl character class (`\w`, `\s` or/// `\d`) could not be found. This can occur when the `unicode-perl`/// crate feature is not enabled.UnicodeCaseUnavailable/// This occurs when the Unicode simple case mapping tables are not/// available, and the regular expression required Unicode aware case/// insensitivity./// The type of an error that occurred while building an `Hir`./// The underlying HIR kind./// Analysis info about this HIR, computed during construction./// A high-level intermediate representation (HIR) for a regular expression./// An HIR value is a combination of a [`HirKind`] and a set of [`Properties`]./// An `HirKind` indicates what kind of regular expression it is (a literal,/// a repetition, a look-around assertion, etc.), where as a `Properties`/// describes various facts about the regular expression. For example, whether/// it matches UTF-8 or if it matches the empty string./// The HIR of a regular expression represents an intermediate step between/// its abstract syntax (a structured description of the concrete syntax) and/// an actual regex matcher. The purpose of HIR is to make regular expressions/// easier to analyze. In particular, the AST is much more complex than the/// HIR. For example, while an AST supports arbitrarily nested character/// classes, the HIR will flatten all nested classes into a single set. The HIR/// will also "compile away" every flag present in the concrete syntax. For/// example, users of HIR expressions never need to worry about case folding;/// it is handled automatically by the translator (e.g., by translating/// `(?i:A)` to `[aA]`)./// The specific type of an HIR expression can be accessed via its `kind`/// or `into_kind` methods. This extra level of indirection exists for two/// reasons:/// 1. Construction of an HIR expression *must* use the constructor methods on/// this `Hir` type instead of building the `HirKind` values directly. This/// permits construction to enforce invariants like "concatenations always/// consist of two or more sub-expressions."/// 2. Every HIR expression contains attributes that are defined inductively,/// and can be computed cheaply during the construction process. For example,/// one such attribute is whether the expression must match at the beginning of/// In particular, if you have an `HirKind` value, then there is intentionally/// no way to build an `Hir` value from it. You instead need to do case/// analysis on the `HirKind` value and build the `Hir` value using its smart/// constructors./// # UTF-8/// If the HIR was produced by a translator with/// [`TranslatorBuilder::utf8`](translate::TranslatorBuilder::utf8) enabled,/// then the HIR is guaranteed to match UTF-8 exclusively for all non-empty/// For empty matches, those can occur at any position. It is the/// responsibility of the regex engine to determine whether empty matches are/// permitted between the code units of a single codepoint./// # Stack space/// heap space proportional to the size of the HIR./// Also, an `Hir`'s `fmt::Display` implementation prints an HIR as a regular/// expression pattern string, and uses constant stack space and heap space/// proportional to the size of the `Hir`. The regex it prints is guaranteed to/// be _semantically_ equivalent to the original concrete syntax, but it may/// look very different. (And potentially not practically readable by a human.)/// An `Hir`'s `fmt::Debug` implementation currently does not use constant/// stack space. The implementation will also suppress some details (such as/// the `Properties` inlined into every `Hir` value to make it less noisy)./// Returns a reference to the underlying HIR kind.into_kind/// Consumes ownership of this HIR expression and returns its underlying/// `HirKind`./// Returns the properties computed for this `Hir`./// Splits this HIR into its constituent parts./// This is useful because `let Hir { kind, props } = hir;` does not work/// because of `Hir`'s custom `Drop` implementation./// Methods for accessing the underlying `HirKind` and `Properties`./// Returns an empty HIR expression./// An empty HIR expression always matches, including the empty string./// Returns an HIR expression that can never match anything. That is,/// the size of the set of strings in the language described by the HIR/// returned is `0`./// This is distinct from [`Hir::empty`] in that the empty string matches/// the HIR returned by `Hir::empty`. That is, the set of strings in the/// language describe described by `Hir::empty` is non-empty./// Note that currently, the HIR returned uses an empty character class to/// indicate that nothing can match. An equivalent expression that cannot/// match is an empty alternation, but all such "fail" expressions are/// normalized (via smart constructors) to empty character classes. This is/// because empty character classes can be spelled in the concrete syntax/// of a regex (e.g., `\P{any}` or `(?-u:[^\x00-\xFF])` or `[a&&b]`), but/// empty alternations cannot./// Creates a literal HIR expression./// This accepts anything that can be converted into a `Box<[u8]>`./// Note that there is no mechanism for storing a `char` or a `Box<str>`/// in an HIR. Everything is "just bytes." Whether a `Literal` (or/// any HIR node) matches valid UTF-8 exclusively can be queried via/// [`Properties::is_utf8`]./// This example shows that concatenations of `Literal` HIR values will/// automatically get flattened and combined together. So for example, even/// if you concat multiple `Literal` values that are themselves not valid/// UTF-8, they might add up to valid UTF-8. This also demonstrates just/// how "smart" Hir's smart constructors are./// use regex_syntax::hir::{Hir, HirKind, Literal};/// let literals = vec![///     Hir::literal([0xE2]),///     Hir::literal([0x98]),///     Hir::literal([0x83]),/// // Each literal, on its own, is invalid UTF-8./// assert!(literals.iter().all(|hir| !hir.properties().is_utf8()));/// let concat = Hir::concat(literals);/// // But the concatenation is valid UTF-8!/// assert!(concat.properties().is_utf8());/// // And also notice that the literals have been concatenated into a/// // single `Literal`, to the point where there is no explicit `Concat`!/// let expected = HirKind::Literal(Literal(Box::from("☃".as_bytes())));/// assert_eq!(&expected, concat.kind());/// # Example: building a literal from a `char`/// This example shows how to build a single `Hir` literal from a `char`/// value. Since a [`Literal`] is just bytes, we just need to UTF-8/// encode a `char` value:/// let ch = '☃';/// let got = Hir::literal(ch.encode_utf8(&mut [0; 4]).as_bytes());/// assert_eq!(&expected, got.kind());/// Creates a class HIR expression. The class may either be defined over/// ranges of Unicode codepoints or ranges of raw byte values./// Note that an empty class is permitted. An empty class is equivalent to/// `Hir::fail()`./// Creates a look-around assertion HIR expression./// Creates a repetition HIR expression./// Creates a capture HIR expression./// Note that there is no explicit HIR value for a non-capturing group./// Since a non-capturing group only exists to override precedence in the/// concrete syntax and since an HIR already does its own grouping based on/// what is parsed, there is no need to explicitly represent non-capturing/// groups in the HIR./// Returns the concatenation of the given expressions./// This attempts to flatten and simplify the concatenation as appropriate./// This shows a simple example of basic flattening of both concatenations/// and literals./// use regex_syntax::hir::Hir;///     Hir::concat(vec![///         Hir::literal([b'a']),///         Hir::literal([b'b']),///         Hir::literal([b'c']),///         Hir::literal([b'x']),///         Hir::literal([b'y']),///         Hir::literal([b'z']),/// let expected = Hir::literal("abcxyz".as_bytes());/// assert_eq!(expected, hir);/// Returns the alternation of the given expressions./// This flattens and simplifies the alternation as appropriate. This may/// include factoring out common prefixes or even rewriting the alternation/// as a character class./// Note that an empty alternation is equivalent to `Hir::fail()`. (It/// is not possible for one to write an empty alternation, or even an/// alternation with a single sub-expression, in the concrete syntax of a/// regex.)/// This is a simple example showing how an alternation might get/// simplified./// use regex_syntax::hir::{Hir, Class, ClassUnicode, ClassUnicodeRange};/// let hir = Hir::alternation(vec![///     Hir::literal([b'a']),///     Hir::literal([b'b']),///     Hir::literal([b'c']),///     Hir::literal([b'd']),///     Hir::literal([b'e']),///     Hir::literal([b'f']),/// let expected = Hir::class(Class::Unicode(ClassUnicode::new([///     ClassUnicodeRange::new('a', 'f'),/// And another example showing how common prefixes might get factored///         Hir::literal("abc".as_bytes()),///         Hir::class(Class::Unicode(ClassUnicode::new([///             ClassUnicodeRange::new('A', 'Z'),///         ]))),///             ClassUnicodeRange::new('a', 'z'),/// let expected = Hir::concat(vec![///     Hir::literal("abc".as_bytes()),///     Hir::alternation(vec![/// Note that these sorts of simplifications are not guaranteed./// Returns an HIR expression for `.`./// * [`Dot::AnyChar`] maps to `(?su-R:.)`./// * [`Dot::AnyByte`] maps to `(?s-Ru:.)`./// * [`Dot::AnyCharExceptLF`] maps to `(?u-Rs:.)`./// * [`Dot::AnyCharExceptCRLF`] maps to `(?Ru-s:.)`./// * [`Dot::AnyByteExceptLF`] maps to `(?-Rsu:.)`./// * [`Dot::AnyByteExceptCRLF`] maps to `(?R-su:.)`./// Note that this is a convenience routine for constructing the correct/// character class based on the value of `Dot`. There is no explicit "dot"/// HIR value. It is just an abbreviation for a common character class./// use regex_syntax::hir::{Hir, Dot, Class, ClassBytes, ClassBytesRange};/// let hir = Hir::dot(Dot::AnyByte);/// let expected = Hir::class(Class::Bytes(ClassBytes::new([///     ClassBytesRange::new(0x00, 0xFF),/// Smart constructors for HIR values./// These constructors are called "smart" because they do inductive work or/// simplifications. For example, calling `Hir::repetition` with a repetition/// like `a{0}` will actually return a `Hir` with a `HirKind::Empty` kind/// since it is equivalent to an empty regex. Another example is calling/// `Hir::concat(vec![expr])`. Instead of getting a `HirKind::Concat`, you'll/// just get back the original `expr` since it's precisely equivalent./// Smart constructors enable maintaining invariants about the HIR data type/// while also simulanteously keeping the representation as simple as possible./// The empty regular expression, which matches everything, including the/// A literalstring that matches exactly these bytes./// A single character class that matches any of the characters in the/// class. A class can either consist of Unicode scalar values as/// characters, or it can use bytes./// A class may be empty. In which case, it matches nothing./// A look-around assertion. A look-around match always has zero length./// A repetition operation applied to a sub-expression./// A capturing group, which contains a sub-expression./// A concatenation of expressions./// A concatenation matches only if each of its sub-expressions match one/// after the other./// Concatenations are guaranteed by `Hir`'s smart constructors to always/// have at least two sub-expressions./// An alternation of expressions./// An alternation matches only if at least one of its sub-expressions/// match. If multiple sub-expressions match, then the leftmost is/// preferred./// Alternations are guaranteed by `Hir`'s smart constructors to always/// The underlying kind of an arbitrary [`Hir`] expression./// An `HirKind` is principally useful for doing case analysis on the type/// of a regular expression. If you're looking to build new `Hir` values,/// then you _must_ use the smart constructors defined on `Hir`, like/// [`Hir::repetition`], to build new `Hir` values. The API intentionally does/// not expose any way of building an `Hir` directly from an `HirKind`./// Returns a slice of this kind's sub-expressions, if any./// Print a display representation of this Hir./// The result of this is a valid regular expression pattern string./// to the size of the `Hir`./// The high-level intermediate representation of a literal./// A literal corresponds to `0` or more bytes that should be matched/// literally. The smart constructors defined on `Hir` will automatically/// concatenate adjacent literals into one literal, and will even automatically/// replace empty literals with `Hir::empty()`./// Note that despite a literal being represented by a sequence of bytes, its/// `Debug` implementation will attempt to print it as a normal string. (That/// is, not a sequence of decimal numbers.)/// A set of characters represented by Unicode scalar values./// A set of characters represented by arbitrary bytes (one byte per/// The high-level intermediate representation of a character class./// A character class corresponds to a set of characters. A character is either/// defined by a Unicode scalar value or a byte./// A character class, regardless of its character type, is represented by a/// sequence of non-overlapping non-adjacent ranges of characters./// There are no guarantees about which class variant is used. Generally/// speaking, the Unicode variat is used whenever a class needs to contain/// non-ASCII Unicode scalar values. But the Unicode variant can be used even/// when Unicode mode is disabled. For example, at the time of writing, the/// regex `(?-u:a|\xc2\xa0)` will compile down to HIR for the Unicode class/// `[a\u00A0]` due to optimizations./// Note that `Bytes` variant may be produced even when it exclusively matches/// valid UTF-8. This is because a `Bytes` variant represents an intention by/// the author of the regular expression to disable Unicode mode, which in turn/// impacts the semantics of case insensitive matching. For example, `(?i)k`/// and `(?i-u)k` will not match the same set of strings./// Apply Unicode simple case folding to this character class, in place./// The character class will be expanded to include all simple case folded/// character variants./// If this is a byte oriented character class, then this will be limited/// to the ASCII ranges `A-Z` and `a-z`./// This routine panics when the case mapping data necessary for this/// routine to complete is unavailable. This occurs when the `unicode-case`/// feature is not enabled and the underlying class is Unicode oriented./// Callers should prefer using `try_case_fold_simple` instead, which will/// return an error instead of panicking.try_case_fold_simple/// This routine returns an error when the case mapping data necessary/// for this routine to complete is unavailable. This occurs when the/// `unicode-case` feature is not enabled and the underlying class is/// Unicode oriented./// Negate this character class in place./// After completion, this character class will contain precisely the/// characters that weren't previously in the class./// Returns true if and only if this character class will only ever match/// valid UTF-8./// A character class can match invalid UTF-8 only when the following/// conditions are met:/// 1. The translator was configured to permit generating an expression///    that can match invalid UTF-8. (By default, this is disabled.)/// 2. Unicode mode (via the `u` flag) was disabled either in the concrete///    syntax or in the parser builder. By default, Unicode mode is///    enabled./// Returns the length, in bytes, of the smallest string matched by this/// character class./// For non-empty byte oriented classes, this always returns `1`. For/// non-empty Unicode oriented classes, this can return `1`, `2`, `3` or/// `4`. For empty classes, `None` is returned. It is impossible for `0` to/// This example shows some examples of regexes and their corresponding/// minimum length, if any./// use regex_syntax::{hir::Properties, parse};/// // The empty string has a min length of 0./// let hir = parse(r"")?;/// assert_eq!(Some(0), hir.properties().minimum_len());/// // As do other types of regexes that only match the empty string./// let hir = parse(r"^$\b\B")?;/// // A regex that can match the empty string but match more is still 0./// let hir = parse(r"a*")?;/// // A regex that matches nothing has no minimum defined./// let hir = parse(r"[a&&b]")?;/// assert_eq!(None, hir.properties().minimum_len());/// // Character classes usually have a minimum length of 1./// let hir = parse(r"\w")?;/// assert_eq!(Some(1), hir.properties().minimum_len());/// // But sometimes Unicode classes might be bigger!/// let hir = parse(r"\p{Cyrillic}")?;/// assert_eq!(Some(2), hir.properties().minimum_len());maximum_len/// Returns the length, in bytes, of the longest string matched by this/// maximum length, if any./// // The empty string has a max length of 0./// assert_eq!(Some(0), hir.properties().maximum_len());/// // A regex that matches nothing has no maximum defined./// assert_eq!(None, hir.properties().maximum_len());/// // Bounded repeats work as you expect./// let hir = parse(r"x{2,10}")?;/// assert_eq!(Some(10), hir.properties().maximum_len());/// // An unbounded repeat means there is no maximum./// let hir = parse(r"x{2,}")?;/// // With Unicode enabled, \w can match up to 4 bytes!/// assert_eq!(Some(4), hir.properties().maximum_len());/// // Without Unicode enabled, \w matches at most 1 byte./// let hir = parse(r"(?-u)\w")?;/// assert_eq!(Some(1), hir.properties().maximum_len());/// Returns true if and only if this character class is empty. That is,/// it has no elements./// An empty character can never match anything, including an empty string./// If this class consists of exactly one element (whether a codepoint or a/// byte), then return it as a literal byte string./// If this class is empty or contains more than one element, then `None`ClassUnicodeRange/// Create a new class from a sequence of ranges./// may overlap. Ranges will automatically be sorted into a canonical/// non-overlapping order./// Create a new class with no ranges./// An empty class matches nothing. That is, it is equivalent to/// [`Hir::fail`]./// Add a new range to this set.ClassUnicodeIter/// Return an iterator over all ranges in this class./// The iterator yields ranges in ascending order./// Return the underlying ranges as a slice./// Expand this character class such that it contains all case folded/// characters, according to Unicode's "simple" mapping. For example, if/// this class consists of the range `a-z`, then applying case folding will/// result in the class containing both the ranges `a-z` and `A-Z`./// feature is not enabled./// `unicode-case` feature is not enabled./// Negate this character class./// For all `c` where `c` is a Unicode scalar value, if `c` was in this/// set, then it will not be in this set after negation./// Union this character class with the given character class, in place./// Intersect this character class with the given character class, in/// Subtract the given character class from this character class, in place./// Compute the symmetric difference of the given character classes, in/// This computes the symmetric difference of two character classes. This/// removes all elements in this class that are also in the given class,/// but all adds all elements from the given class that aren't in this/// class. That is, the class will contain all elements in either class,/// but will not contain any elements that are in both classes.is_ascii/// Returns true if and only if this character class will either match/// nothing or only ASCII bytes. Stated differently, this returns false/// if and only if this class contains a non-ASCII codepoint./// Returns `None` when the class is empty./// If this class consists of exactly one codepoint, then return it as/// a literal byte string./// If this class is empty or contains more than one codepoint, then `None`to_byte_class/// If this class consists of only ASCII ranges, then return its/// corresponding and equivalent byte class./// An iterator over all ranges in a Unicode character class./// The lifetime `'a` refers to the lifetime of the underlying class./// A single range of characters represented by Unicode scalar values./// The range is closed. That is, the start and end of the range are included/// in the range./// Apply simple case folding to this Unicode scalar value range./// Additional ranges are appended to the given vector. Canonical ordering/// is *not* maintained in the given vector./// Create a new Unicode scalar value range for a character class./// The returned range is always in a canonical form. That is, the range/// returned always satisfies the invariant that `start <= end`./// Return the start of this range./// The start of a range is always less than or equal to the end of the/// Return the end of this range./// The end of a range is always greater than or equal to the start of the/// Returns the number of codepoints in this range.ClassBytesRange/// A set of characters represented by arbitrary bytes./// Each byte corresponds to one character.ClassBytesIter/// Note that this only applies ASCII case folding, which is limited to the/// characters `a-z` and `A-Z`./// Negate this byte class./// For all `b` where `b` is a any byte, if `b` was in this set, then it/// Union this byte class with the given byte class, in place./// Intersect this byte class with the given byte class, in place./// Subtract the given byte class from this byte class, in place./// Compute the symmetric difference of the given byte classes, in place./// This computes the symmetric difference of two byte classes. This/// if and only if this class contains a non-ASCII byte./// If this class consists of exactly one byte, then return it as/// If this class is empty or contains more than one byte, then `None`to_unicode_class/// corresponding and equivalent Unicode class./// An iterator over all ranges in a byte character class./// A single range of characters represented by arbitrary bytes./// Apply simple case folding to this byte range. Only ASCII case mappings/// (for a-z) are applied./// Create a new byte range for a character class./// Returns the number of bytes in this range./// The high-level intermediate representation for a look-around assertion./// An assertion match is always zero-length. Also called an "empty match."/// The capture index of the capture./// The name of the capture, if it exists./// The expression inside the capturing group, which may be empty./// The high-level intermediate representation for a capturing group./// A capturing group always has an index and a child expression. It may/// also have a name associated with it (e.g., `(?P<foo>\w)`), but it's not/// Note that there is no explicit representation of a non-capturing group/// in a `Hir`. Instead, non-capturing grouping is handled automatically by/// the recursive structure of the `Hir` itself./// The minimum range of the repetition./// Note that special cases like `?`, `+` and `*` all get translated into/// the ranges `{0,1}`, `{1,}` and `{0,}`, respectively./// When `min` is zero, this expression can match the empty string/// regardless of what its sub-expression is./// The maximum range of the repetition./// Note that when `max` is `None`, `min` acts as a lower bound but where/// there is no upper bound. For something like `x{5}` where the min and/// max are equivalent, `min` will be set to `5` and `max` will be set to/// `Some(5)`./// Whether this repetition operator is greedy or not. A greedy operator/// will match as much as it can. A non-greedy operator will match as/// little as it can./// Typically, operators are greedy by default and are only non-greedy when/// a `?` suffix is used, e.g., `(expr)*` is greedy while `(expr)*?` is/// not. However, this can be inverted via the `U` "ungreedy" flag./// The expression being repeated./// The high-level intermediate representation of a repetition operator./// A repetition operator permits the repetition of an arbitrary/// sub-expression./// Returns a new repetition with the same `min`, `max` and `greedy`/// values, but with its sub-expression replaced with the one given./// Matches the UTF-8 encoding of any Unicode scalar value./// This is equivalent to `(?su:.)` and also `\p{any}`.AnyByte/// Matches any byte value./// This is equivalent to `(?s-u:.)` and also `(?-u:[\x00-\xFF])`.AnyCharExcept/// Matches the UTF-8 encoding of any Unicode scalar value except for the/// `char` given./// This is equivalent to using `(?u-s:.)` with the line terminator set/// to a particular ASCII byte. (Because of peculiarities in the regex/// engines, a line terminator must be a single byte. It follows that when/// UTF-8 mode is enabled, this single byte must also be a Unicode scalar/// value. That is, ti must be ASCII.)/// (This and `AnyCharExceptLF` both exist because of legacy reasons./// `AnyCharExceptLF` will be dropped in the next breaking change release.)AnyCharExceptLF/// Matches the UTF-8 encoding of any Unicode scalar value except for `\n`./// This is equivalent to `(?u-s:.)` and also `[\p{any}--\n]`.AnyCharExceptCRLF/// Matches the UTF-8 encoding of any Unicode scalar value except for `\r`/// This is equivalent to `(?uR-s:.)` and also `[\p{any}--\r\n]`.AnyByteExcept/// Matches any byte value except for the `u8` given./// This is equivalent to using `(?-us:.)` with the line terminator set/// (This and `AnyByteExceptLF` both exist because of legacy reasons./// `AnyByteExceptLF` will be dropped in the next breaking change release.)AnyByteExceptLF/// Matches any byte value except for `\n`./// This is equivalent to `(?-su:.)` and also `(?-u:[[\x00-\xFF]--\n])`.AnyByteExceptCRLF/// Matches any byte value except for `\r` and `\n`./// This is equivalent to `(?R-su:.)` and also `(?-u:[[\x00-\xFF]--\r\n])`./// A type describing the different flavors of `.`./// This type is meant to be used with [`Hir::dot`], which is a convenience/// routine for building HIR values derived from the `.` regex./// A custom `Drop` impl is used for `HirKind` such that it uses constant stack/// space but heap space proportional to the depth of the total `Hir`.PropertiesI/// A type that collects various properties of an HIR value./// Properties are always scalar values and represent meta data that is/// computed inductively on an HIR value. Properties are defined for all/// HIR values./// All methods on a `Properties` value take constant time and are meant to/// be cheap to call.look_set_prefixlook_set_suffixlook_set_suffix_anyexplicit_captures_lenstatic_explicit_captures_lenalternation_literal/// The property definition. It is split out so that we can box it, and/// there by make `Properties` use less stack size. This is kind-of important/// because every HIR value has a `Properties` attached to it./// This does have the unfortunate consequence that creating any HIR value/// always leads to at least one alloc for properties, but this is generally/// true anyway (for pretty much all HirKinds except for look-arounds)./// Returns the length (in bytes) of the smallest string matched by this/// HIR./// A return value of `0` is possible and occurs when the HIR can match an/// `None` is returned when there is no minimum length. This occurs in/// precisely the cases where the HIR matches nothing. i.e., The language/// the regex matches is empty. An example of such a regex is `\P{any}`./// Returns the length (in bytes) of the longest string matched by this/// A return value of `0` is possible and occurs when nothing longer than/// the empty string is in the language described by this HIR./// `None` is returned when there is no longest matching string. This/// occurs when the HIR matches nothing or when there is no upper bound on/// the length of matching strings. Example of such regexes are `\P{any}`/// (matches nothing) and `a+` (has no upper bound)./// Returns a set of all look-around assertions that appear at least once/// in this HIR value./// Returns a set of all look-around assertions that appear as a prefix for/// this HIR value. That is, the set returned corresponds to the set of/// assertions that must be passed before matching any bytes in a haystack./// For example, `hir.look_set_prefix().contains(Look::Start)` returns true/// if and only if the HIR is fully anchored at the start./// Returns a set of all look-around assertions that appear as a _possible_/// prefix for this HIR value. That is, the set returned corresponds to the/// set of assertions that _may_ be passed before matching any bytes in a/// For example, `hir.look_set_prefix_any().contains(Look::Start)` returns/// true if and only if it's possible for the regex to match through a/// anchored assertion before consuming any input./// Returns a set of all look-around assertions that appear as a suffix for/// assertions that must be passed in order to be considered a match after/// all other consuming HIR expressions./// For example, `hir.look_set_suffix().contains(Look::End)` returns true/// if and only if the HIR is fully anchored at the end./// suffix for this HIR value. That is, the set returned corresponds to the/// For example, `hir.look_set_suffix_any().contains(Look::End)` returns/// anchored assertion at the end of a match without consuming any input./// Return true if and only if the corresponding HIR will always match/// When this returns false, then it is possible for this HIR expression to/// match invalid UTF-8, including by matching between the code units of/// a single UTF-8 encoded codepoint./// Note that this returns true even when the corresponding HIR can match/// the empty string. Since an empty string can technically appear between/// UTF-8 code units, it is possible for a match to be reported that splits/// a codepoint which could in turn be considered matching invalid UTF-8./// However, it is generally assumed that such empty matches are handled/// specially by the search routine if it is absolutely required that/// matches not split a codepoint./// This code example shows the UTF-8 property of a variety of patterns./// use regex_syntax::{ParserBuilder, parse};/// // Examples of 'is_utf8() == true'./// assert!(parse(r"a")?.properties().is_utf8());/// assert!(parse(r"[^a]")?.properties().is_utf8());/// assert!(parse(r".")?.properties().is_utf8());/// assert!(parse(r"\W")?.properties().is_utf8());/// assert!(parse(r"\b")?.properties().is_utf8());/// assert!(parse(r"\B")?.properties().is_utf8());/// assert!(parse(r"(?-u)\b")?.properties().is_utf8());/// assert!(parse(r"(?-u)\B")?.properties().is_utf8());/// // Unicode mode is enabled by default, and in/// // that mode, all \x hex escapes are treated as/// // codepoints. So this actually matches the UTF-8/// // encoding of U+00FF./// assert!(parse(r"\xFF")?.properties().is_utf8());/// // Now we show examples of 'is_utf8() == false'./// // The only way to do this is to force the parser/// // to permit invalid UTF-8, otherwise all of these/// // would fail to parse!/// let parse = |pattern| {///     ParserBuilder::new().utf8(false).build().parse(pattern)/// assert!(!parse(r"(?-u)[^a]")?.properties().is_utf8());/// assert!(!parse(r"(?-u).")?.properties().is_utf8());/// assert!(!parse(r"(?-u)\W")?.properties().is_utf8());/// // Conversely to the equivalent example above,/// // when Unicode mode is disabled, \x hex escapes/// // are treated as their raw byte values./// assert!(!parse(r"(?-u)\xFF")?.properties().is_utf8());/// // Note that just because we disabled UTF-8 in the/// // parser doesn't mean we still can't use Unicode./// // It is enabled by default, so \xFF is still/// // equivalent to matching the UTF-8 encoding of/// // U+00FF by default./// // Even though we use raw bytes that individually/// // are not valid UTF-8, when combined together, the/// // overall expression *does* match valid UTF-8!/// assert!(parse(r"(?-u)\xE2\x98\x83")?.properties().is_utf8());/// Returns the total number of explicit capturing groups in the/// corresponding HIR./// Note that this does not include the implicit capturing group/// corresponding to the entire match that is typically included by regex/// This method will return `0` for `a` and `1` for `(a)`:/// use regex_syntax::parse;/// assert_eq!(0, parse("a")?.properties().explicit_captures_len());/// assert_eq!(1, parse("(a)")?.properties().explicit_captures_len());/// Returns the total number of explicit capturing groups that appear in/// every possible match./// corresponding to the entire match.///     parse(pattern).map(|h| {///         h.properties().static_explicit_captures_len()/// assert_eq!(Some(0), len("a")?);/// assert_eq!(Some(1), len("(a)")?);/// assert_eq!(Some(1), len("(a)|(b)")?);/// assert_eq!(Some(2), len("(a)(b)|(c)(d)")?);/// assert_eq!(Some(1), len("(b)+")?);is_literal/// Return true if and only if this HIR is a simple literal. This is/// only true when this HIR expression is either itself a `Literal` or a/// concatenation of only `Literal`s./// For example, `f` and `foo` are literals, but `f+`, `(foo)`, `foo()` and/// the empty string are not (even though they contain sub-expressions that/// are literals).is_alternation_literal/// Return true if and only if this HIR is either a simple literal or an/// alternation of simple literals. This is only/// true when this HIR expression is either itself a `Literal` or a/// concatenation of only `Literal`s or an alternation of only `Literal`s./// For example, `f`, `foo`, `a|b|c`, and `foo|bar|baz` are alternation/// literals, but `f+`, `(foo)`, `foo()`, and the empty pattern are not/// (even though that contain sub-expressions that are literals)./// Returns the total amount of heap memory usage, in bytes, used by this/// `Properties` value./// Returns a new set of properties that corresponds to the union of the/// iterator of properties given./// This is useful when one has multiple `Hir` expressions and wants/// to combine them into a single alternation without constructing the/// corresponding `Hir`. This routine provides a way of combining the/// properties of each `Hir` expression into one set of properties/// representing the union of those expressions./// # Example: union with HIRs that never match/// This example shows that unioning properties together with one that/// represents a regex that never matches will "poison" certain attributes,/// like the minimum and maximum lengths./// let hir1 = parse("ab?c?")?;/// assert_eq!(Some(1), hir1.properties().minimum_len());/// assert_eq!(Some(3), hir1.properties().maximum_len());/// let hir2 = parse(r"[a&&b]")?;/// assert_eq!(None, hir2.properties().minimum_len());/// assert_eq!(None, hir2.properties().maximum_len());/// let hir3 = parse(r"wxy?z?")?;/// assert_eq!(Some(2), hir3.properties().minimum_len());/// assert_eq!(Some(4), hir3.properties().maximum_len());/// let unioned = Properties::union([///		hir1.properties(),///		hir2.properties(),///		hir3.properties(),///	]);/// assert_eq!(None, unioned.minimum_len());/// assert_eq!(None, unioned.maximum_len());/// The maximum length can also be "poisoned" by a pattern that has no/// upper bound on the length of a match. The minimum length remains/// unaffected:/// let hir2 = parse(r"a+")?;/// assert_eq!(Some(1), hir2.properties().minimum_len());/// assert_eq!(Some(1), unioned.minimum_len());/// Create a new set of HIR properties for an empty regex./// Create a new set of HIR properties for a literal regex./// Create a new set of HIR properties for a character class./// Create a new set of HIR properties for a look-around assertion./// Create a new set of HIR properties for a repetition./// Create a new set of HIR properties for a capture./// Create a new set of HIR properties for a concatenation./// of a bitset, where each assertion occupies bit `i` where `i =/// Look::as_repr()`./// A set of look-around assertions./// example, an [`Hir`] provides properties that return `LookSet`s.class_chars/// Given a sequence of HIR values where each value corresponds to a Unicode/// class (or an all-ASCII byte class), return a single Unicode class/// corresponding to the union of the classes found.class_bytes/// Given a sequence of HIR values where each value corresponds to a byte class/// (or an all-ASCII Unicode class), return a single byte class corresponding/// to the union of the classes found.singleton_chars/// Given a sequence of HIR values where each value corresponds to a literal/// that is a single `char`, return that sequence of `char`s. Otherwise return/// None. No deduplication is done.singleton_bytes/// that is a single byte, return that sequence of bytes. Otherwise returnlift_common_prefix/// Looks for a common prefix in the list of alternation branches given. If one/// is found, then an equivalent but (hopefully) simplified Hir is returned./// Otherwise, the original given list of branches is returned unmodified./// This is not quite as good as it could be. Right now, it requires that/// all branches are 'Concat' expressions. It also doesn't do well with/// literals. For example, given 'foofoo|foobar', it will not refactor it to/// 'foo(?:foo|bar)' because literals are flattened into their own special/// concatenation. (One wonders if perhaps 'Literal' should be a single atom/// instead of a string of bytes because of this. Otherwise, handling the/// current representation in this routine will be pretty gnarly. Sigh.)uclassbclassurangesucasefolduunionuintersectudifferenceusymdifferenceunegatebrangesbcasefoldbunionbintersectbdifferencebsymdifferencebnegateclass_range_canonical_unicodeclass_range_canonical_bytesclass_canonicalize_unicodeclass_canonicalize_bytesclass_case_fold_unicodeclass_case_fold_bytesclass_negate_unicodeclass_negate_bytesclass_union_unicodeclass_union_bytesclass_intersect_unicodeclass_intersect_bytesclass_difference_unicodeclass_difference_bytesclass_symmetric_difference_unicodeclass_symmetric_difference_bytes// for Hir can handle arbitrarily sized expressions in constant stack/*!
Defines a high-level intermediate (HIR) representation for regular expressions.

The HIR is represented by the [`Hir`] type, and it principally constructed via
[translation](translate) from an [`Ast`](crate::ast::Ast). Alternatively, users
may use the smart constructors defined on `Hir` to build their own by hand. The
smart constructors simultaneously simplify and "optimize" the HIR, and are also
the same routines used by translation.

Most regex engines only have an HIR like this, and usually construct it
directly from the concrete syntax. This crate however first parses the
concrete syntax into an `Ast`, and only then creates the HIR from the `Ast`,
as mentioned above. It's done this way to facilitate better error reporting,
and to have a structured representation of a regex that faithfully represents
its concrete syntax. Namely, while an `Hir` value can be converted back to an
equivalent regex pattern string, it is unlikely to look like the original due
to its simplified structure.
*//// A printer for a regular expression's high-level intermediate/// A printer converts a high-level intermediate representation (HIR) to a/// regular expression pattern string. This particular printer uses constant/// stack space and heap space proportional to the size of the HIR./// Since this printer is only using the HIR, the pattern it prints will likely/// not resemble the original pattern at all. For example, a pattern like/// `\pL` will have its entire class written out./// The purpose of this printer is to provide a means to mutate an HIR and then/// build a regular expression from the result of that mutation. (A regex/// library could provide a constructor from this HIR explicitly, but that/// creates an unnecessary public coupling between the regex library and this/// specific HIR representation.)write_literal_charwrite_literal_bytewrite_literal_class_byteroundtrip_bytesprint_anchorprint_word_boundaryregression_repetition_concat// This is a regression test that stresses a peculiarity of how the HIR// is both constructed and printed. Namely, it is legal for a repetition// to directly contain a concatenation. This particular construct isn't// really possible to build from the concrete syntax directly, since you'd// be forced to put the concatenation into (at least) a non-capturing// group. Concurrently, the printer doesn't consider this case and just// kind of naively prints the child expression and tacks on the repetition// operator.// As a result, if you attached '+' to a 'concat(a, b)', the printer gives// you 'ab+', but clearly it really should be '(?:ab)+'.// This bug isn't easy to surface because most ways of building an HIR// come directly from the concrete syntax, and as mentioned above, it just// isn't possible to build this kind of HIR from the concrete syntax.// Nevertheless, this is definitely a bug.// See: https://github.com/rust-lang/regex/issues/731regression_repetition_alternation// Just like regression_repetition_concat, but with the repetition using// an alternation as a child expression instead.regression_alternation_concat// This regression test is very similar in flavor to// regression_repetition_concat in that the root of the issue lies in a// peculiarity of how the HIR is represented and how the printer writes it// out. Like the other regression, this one is also rooted in the fact that// you can't produce the peculiar HIR from the concrete syntax. Namely, you// just can't have a 'concat(a, alt(b, c))' because the 'alt' will normally// be in (at least) a non-capturing group. Why? Because the '|' has very// low precedence (lower that concatenation), and so something like 'ab|c'// is actually 'alt(ab, c)'.// See: https://github.com/rust-lang/regex/issues/516/*!
This module provides a regular expression printer for `Hir`.
*/ClassQuery/// A builder for constructing an AST->HIR translator./// Create a new translator builder with a default c onfiguration.Translator/// Build a translator using the current configuration./// When disabled, translation will permit the construction of a regular/// When enabled (the default), the translator is guaranteed to produce an/// expression that, for non-empty matches, will only ever produce spans/// that are entirely valid UTF-8 (otherwise, the translator will return an/// error)./// Perhaps surprisingly, when UTF-8 is enabled, an empty regex or even/// a negated ASCII word boundary (uttered as `(?-u:\B)` in the concrete/// syntax) will be allowed even though they can produce matches that split/// a UTF-8 encoded codepoint. This only applies to zero-width or "empty"/// matches, and it is expected that the regex engine itself must handle/// these cases if necessary (perhaps by suppressing any zero-width matches/// that split a codepoint)./// Enable or disable the case insensitive flag (`i`) by default./// Enable or disable the multi-line matching flag (`m`) by default./// Enable or disable the "dot matches any character" flag (`s`) by/// Enable or disable the CRLF mode flag (`R`) by default./// Enable or disable the "swap greed" flag (`U`) by default.HirFrame/// Our call stack, but on the heap./// The current flag settings./// Whether we're allowed to produce HIR that can match arbitrary bytes./// The line terminator to use for `.`./// A translator maps abstract syntax to a high level intermediate/// A translator may be benefit from reuse. That is, a translator can translate/// many abstract syntax trees./// A `Translator` can be configured in more detail via a/// [`TranslatorBuilder`]./// Create a new translator using the default configuration./// Translate the given abstract syntax tree (AST) into a high level/// intermediate representation (HIR)./// If there was a problem doing the translation, then an HIR-specific/// The original pattern string used to produce the `Ast` *must* also be/// provided. The translator does not use the pattern string during any/// correct translation, but is used for error reporting./// An arbitrary HIR expression. These get pushed whenever we hit a base/// case in the Ast. They get popped after an inductive (i.e., recursive)/// step is complete./// A literal that is being constructed, character by character, from the/// AST. We need this because the AST gives each individual character its/// own node. So as we see characters, we peek at the top-most HirFrame./// If it's a literal, then we add to it. Otherwise, we push a new literal./// When it comes time to pop it, we convert it to an Hir via Hir::literal./// A Unicode character class. This frame is mutated as we descend into/// the Ast of a character class (which is itself its own mini recursive/// A byte-oriented character class. This frame is mutated as we descend/// into the Ast of a character class (which is itself its own mini/// recursive structure)./// Byte character classes are created when Unicode mode (`u`) is disabled./// If `utf8` is enabled (the default), then a byte character is only/// permitted to match ASCII text./// This is pushed whenever a repetition is observed. After visiting every/// sub-expression in the repetition, the translator's stack is expected to/// have this sentinel at the top./// This sentinel only exists to stop other things (like flattening/// literals) from reaching across repetition operators.old_flags/// The old active flags when this group was opened./// If this group sets flags, then the new active flags are set to the/// result of merging the old flags with the flags introduced by this/// group. If the group doesn't set any flags, then this is simply/// equivalent to whatever flags were set when the group was opened./// When this group is popped, the active flags should be restored to/// the flags set here./// The "active" flags correspond to whatever flags are set in the/// Translator./// This is pushed on to the stack upon first seeing any kind of capture,/// indicated by parentheses (including non-capturing groups). It is popped/// upon leaving a group./// This is pushed whenever a concatenation is observed. After visiting/// every sub-expression in the concatenation, the translator's stack is/// popped until it sees a Concat frame./// This is pushed whenever an alternation is observed. After visiting/// every sub-expression in the alternation, the translator's stack is/// popped until it sees an Alternation frame.AlternationBranch/// This is pushed immediately before each sub-expression in an/// alternation. This separates the branches of an alternation on the/// stack and prevents literal flattening from reaching across alternation/// branches./// It is popped after each expression in a branch until an 'Alternation'/// frame is observed when doing a post visit on an alternation./// An HirFrame is a single stack frame, represented explicitly, which is/// created for each item in the Ast that we traverse./// Note that technically, this type doesn't represent our entire stack/// frame. In particular, the Ast visitor represents any state associated with/// traversing the Ast itself.unwrap_expr/// Assert that the current stack frame is an Hir expression and return it.unwrap_class_unicode/// Assert that the current stack frame is a Unicode class expression and/// return it.unwrap_class_bytes/// Assert that the current stack frame is a byte class expression andunwrap_repetition/// Assert that the current stack frame is a repetition sentinel. If it/// isn't, then panic.unwrap_group/// Assert that the current stack frame is a group indicator and return/// its corresponding flags (the flags that were active at the time the/// group was entered).unwrap_alternation_pipe/// Assert that the current stack frame is an alternation pipe sentinel. If/// it isn't, then panic.TranslatorI/// The internal implementation of a translator./// This type is responsible for carrying around the original pattern string,/// which is not tied to the internal state of a translator./// A TranslatorI exists for the time it takes to translate a single Ast./// Build a new internal translator./// Return a reference to the underlying translator./// Push the given frame on to the call stack.push_char/// Push the given literal char on to the call stack./// If the top-most element of the stack is a literal, then the char/// is appended to the end of that literal. Otherwise, a new literal/// containing just the given char is pushed to the top of the stack.push_byte/// Push the given literal byte on to the call stack./// If the top-most element of the stack is a literal, then the byte/// containing just the given byte is pushed to the top of the stack./// Pop the top of the call stack. If the call stack is empty, return None.pop_concat_expr/// Pop an HIR expression from the top of the stack for a concatenation./// This returns None if the stack is empty or when a concat frame is seen./// Otherwise, it panics if it could not find an HIR expression.pop_alt_expr/// Pop an HIR expression from the top of the stack for an alternation./// This returns None if the stack is empty or when an alternation frame is/// seen. Otherwise, it panics if it could not find an HIR expression./// Return a copy of the active flags./// Set the flags of this translator from the flags set in the given AST./// Then, return the old flags.ast_literal_to_scalar/// Convert an Ast literal to its scalar representation./// When Unicode mode is enabled, then this always succeeds and returns a/// `char` (Unicode scalar value)./// When Unicode mode is disabled, then a `char` will still be returned/// whenever possible. A byte is returned only when invalid UTF-8 is/// allowed and when the byte is not ASCII. Otherwise, a non-ASCII byte/// will result in an error when invalid UTF-8 is not allowed.case_fold_charhir_dothir_assertionhir_capturehir_repetitionhir_unicode_classhir_ascii_unicode_classhir_ascii_byte_classhir_perl_unicode_classhir_perl_byte_classconvert_unicode_class_error/// Converts the given Unicode specific error to an HIR translation error./// The span given should approximate the position at which an error would/// occur.unicode_fold_and_negatebytes_fold_and_negateclass_literal_byte/// Return a scalar byte value suitable for use as a literal in a byte// Note that `ignore_whitespace` is omitted here because it is handled// entirely in the parser./// A translator's representation of a regular expression's flags at any given/// moment in time./// Each flag can be in one of three states: absent, present but disabled or/// present but enabled.hir_ascii_class_bytesascii_classascii_class_as_chars// We create these errors to compare with real hir::Errors in the tests.// We define equality between TestError and hir::Error to disregard the// pattern string in hir::Error, which is annoying to provide in tests.t_errt_bytesprops_byteshir_lithir_blithir_capture_namehir_questhir_starhir_plushir_rangehir_althir_cathir_uclass_queryhir_uclass_perl_wordhir_ascii_uclasshir_ascii_bclasshir_uclasshir_bclasshir_case_foldhir_negateclass_case_foldclass_negatehir_unionhir_differencehir_lookliteral_case_insensitiveline_anchorscat_altcat_class_flattened// Tests the HIR transformation of things like '[a-z]|[A-Z]' into// '[A-Za-z]'. In other words, an alternation of just classes is always// equivalent to a single class corresponding to the union of the branches// in that class. (Unless some branches match invalid UTF-8 and others// match non-ASCII Unicode.)class_asciiclass_ascii_multipleclass_perl_unicodeclass_perl_asciiclass_unicode_gencatclass_unicode_scriptclass_unicode_ageclass_unicode_any_emptyclass_bracketed_unionclass_bracketed_nestedclass_bracketed_intersectclass_bracketed_intersect_negateclass_bracketed_differenceclass_bracketed_symmetric_differenceanalysis_is_utf8analysis_captures_lenanalysis_static_captures_lenanalysis_is_all_assertionsanalysis_look_set_prefix_anyanalysis_is_anchoredanalysis_is_any_anchoredanalysis_can_emptyanalysis_is_literalanalysis_is_alternation_literalsmart_repetition// This tests that the smart Hir::repetition constructors does some basic// simplifications.smart_concat// This tests that the smart Hir::concat constructor simplifies the given// exprs in a way we expect.smart_alternation// This tests that the smart Hir::alternation constructor simplifies the// given exprs in a way we expect.regression_alt_empty_concatregression_empty_altregression_singleton_altregression_fuzz_match// See: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=63168regression_fuzz_difference1// See: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=63155regression_fuzz_char_decrement1// See: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=63153/*!
Defines a translator that converts an `Ast` to an `Hir`.
*//// The result of visiting an HIR./// An error that visiting an HIR might return./// yields the result of visiting the HIR or an error./// This method is called before beginning traversal of the HIR./// This method is called on an `Hir` before descending into child `Hir`/// This method is called on an `Hir` after descending all of its child/// `Hir` nodes./// This method is called between child nodes of an alternation./// A trait for visiting the high-level IR (HIR) in depth first order./// analysis on a high-level intermediate representation of a regular/// expression without necessarily using recursion. In particular, this permits/// callers to do case analysis with constant stack usage, which can be/// important since the size of an HIR may be proportional to end user input./// This function will visit every node in the given `Hir` while calling/// analysis over an `Hir` without using a stack size proportional to the depth/// of the `Hir`. Namely, this method will instead use constant stack space,/// but will use heap space proportional to the size of the `Hir`. This may be/// desirable in cases where the size of `Hir` is proportional to end user/// A stack of `Hir` nodes. This is roughly analogous to the call stack/// HeapVisitor visits every item in an `Hir` recursively using constant stack/// size and a heap size proportional to the size of the `Hir`./// A stack frame allocated just before descending into a capture's child/// an `Hir`./// Build a stack frame for the given HIR if one is needed (which occurs if/// and only if there are child nodes in the HIR). Otherwise, return None./// child HIR node to visit.UnicodeWordErrorunicode_tables/// Escapes all regular expression meta characters in `text`.escape_into/// Escapes all meta characters in `text` and writes the result into `buf`./// This will append escape characters into the given buffer. The characters/// that are appended are safe to use as a literal in a regular expression./// Returns true if the given character has significance in a regex./// Generally speaking, these are the only characters which _must_ be escaped/// in order to match their literal meaning. For example, to match a literal/// `|`, one could write `\|`. Sometimes escaping isn't always necessary. For/// example, `-` is treated as a meta character because of its significance/// for writing ranges inside of character classes, but the regex `-` will/// match a literal `-` because `-` has no special meaning outside of character/// In order to determine whether a character may be escaped at all, the/// [`is_escapeable_character`] routine should be used. The difference between/// `is_meta_character` and `is_escapeable_character` is that the latter will/// return true for some characters that are _not_ meta characters. For/// example, `%` and `\%` both match a literal `%` in all contexts. In other/// words, `is_escapeable_character` includes "superfluous" escapes./// Note that the set of characters for which this function returns `true` or/// `false` is fixed and won't change in a semver compatible release. (In this/// case, "semver compatible release" actually refers to the `regex` crate/// itself, since reducing or expanding the set of meta characters would be a/// breaking change for not just `regex-syntax` but also `regex` itself.)/// use regex_syntax::is_meta_character;/// assert!(is_meta_character('?'));/// assert!(is_meta_character('-'));/// assert!(is_meta_character('&'));/// assert!(is_meta_character('#'));/// assert!(!is_meta_character('%'));/// assert!(!is_meta_character('/'));/// assert!(!is_meta_character('!'));/// assert!(!is_meta_character('"'));/// assert!(!is_meta_character('e'));/// Returns true if the given character can be escaped in a regex./// This returns true in all cases that `is_meta_character` returns true, but/// also returns true in some cases where `is_meta_character` returns false./// For example, `%` is not a meta character, but it is escapeable. That is,/// `%` and `\%` both match a literal `%` in all contexts./// The purpose of this routine is to provide knowledge about what characters/// may be escaped. Namely, most regex engines permit "superfluous" escapes/// where characters without any special significance may be escaped even/// though there is no actual _need_ to do so./// This will return false for some characters. For example, `e` is not/// escapeable. Therefore, `\e` will either result in a parse error (which is/// true today), or it could backwards compatibly evolve into a new construct/// with its own meaning. Indeed, that is the purpose of banning _some_/// superfluous escapes: it provides a way to evolve the syntax in a compatible/// manner./// use regex_syntax::is_escapeable_character;/// assert!(is_escapeable_character('?'));/// assert!(is_escapeable_character('-'));/// assert!(is_escapeable_character('&'));/// assert!(is_escapeable_character('#'));/// assert!(is_escapeable_character('%'));/// assert!(is_escapeable_character('/'));/// assert!(is_escapeable_character('!'));/// assert!(is_escapeable_character('"'));/// assert!(!is_escapeable_character('e'));is_word_character/// Returns true if and only if the given character is a Unicode word/// A Unicode word character is defined by/// [UTS#18 Annex C](https://unicode.org/reports/tr18/#Compatibility_Properties)./// In particular, a character/// is considered a word character if it is in either of the `Alphabetic` or/// `Join_Control` properties, or is in one of the `Decimal_Number`, `Mark`/// or `Connector_Punctuation` general categories./// If the `unicode-perl` feature is not enabled, then this function/// panics. For this reason, it is recommended that callers use/// [`try_is_word_character`] instead./// If the `unicode-perl` feature is not enabled, then this function always/// Returns true if and only if the given character is an ASCII word character./// An ASCII word character is defined by the following character class:/// `[_0-9a-zA-Z]`.escape_metaword_byteword_char/*!
This crate provides a robust regular expression parser.

This crate defines two primary types:

* [`Ast`](ast::Ast) is the abstract syntax of a regular expression.
  An abstract syntax corresponds to a *structured representation* of the
  concrete syntax of a regular expression, where the concrete syntax is the
  pattern string itself (e.g., `foo(bar)+`). Given some abstract syntax, it
  can be converted back to the original concrete syntax (modulo some details,
  like whitespace). To a first approximation, the abstract syntax is complex
  and difficult to analyze.
* [`Hir`](hir::Hir) is the high-level intermediate representation
  ("HIR" or "high-level IR" for short) of regular expression. It corresponds to
  an intermediate state of a regular expression that sits between the abstract
  syntax and the low level compiled opcodes that are eventually responsible for
  executing a regular expression search. Given some high-level IR, it is not
  possible to produce the original concrete syntax (although it is possible to
  produce an equivalent concrete syntax, but it will likely scarcely resemble
  the original pattern). To a first approximation, the high-level IR is simple
  and easy to analyze.

These two types come with conversion routines:

* An [`ast::parse::Parser`] converts concrete syntax (a `&str`) to an
[`Ast`](ast::Ast).
* A [`hir::translate::Translator`] converts an [`Ast`](ast::Ast) to a
[`Hir`](hir::Hir).

As a convenience, the above two conversion routines are combined into one via
the top-level [`Parser`] type. This `Parser` will first convert your pattern to
an `Ast` and then convert the `Ast` to an `Hir`. It's also exposed as top-level
[`parse`] free function.


# Example

This example shows how to parse a pattern string into its HIR:

```
use regex_syntax::{hir::Hir, parse};

let hir = parse("a|b")?;
assert_eq!(hir, Hir::alternation(vec![
    Hir::literal("a".as_bytes()),
    Hir::literal("b".as_bytes()),
]));
# Ok::<(), Box<dyn std::error::Error>>(())
```


# Concrete syntax supported

The concrete syntax is documented as part of the public API of the
[`regex` crate](https://docs.rs/regex/%2A/regex/#syntax).


# Input safety

A key feature of this library is that it is safe to use with end user facing
input. This plays a significant role in the internal implementation. In
particular:

1. Parsers provide a `nest_limit` option that permits callers to control how
   deeply nested a regular expression is allowed to be. This makes it possible
   to do case analysis over an `Ast` or an `Hir` using recursion without
   worrying about stack overflow.
2. Since relying on a particular stack size is brittle, this crate goes to
   great lengths to ensure that all interactions with both the `Ast` and the
   `Hir` do not use recursion. Namely, they use constant stack space and heap
   space proportional to the size of the original pattern string (in bytes).
   This includes the type's corresponding destructors. (One exception to this
   is literal extraction, but this will eventually get fixed.)


# Error reporting

The `Display` implementations on all `Error` types exposed in this library
provide nice human readable errors that are suitable for showing to end users
in a monospace font.


# Literal extraction

This crate provides limited support for [literal extraction from `Hir`
values](hir::literal). Be warned that literal extraction uses recursion, and
therefore, stack size proportional to the size of the `Hir`.

The purpose of literal extraction is to speed up searches. That is, if you
know a regular expression must match a prefix or suffix literal, then it is
often quicker to search for instances of that literal, and then confirm or deny
the match using the full regular expression engine. These optimizations are
done automatically in the `regex` crate.


# Crate features

An important feature provided by this crate is its Unicode support. This
includes things like case folding, boolean properties, general categories,
scripts and Unicode-aware support for the Perl classes `\w`, `\s` and `\d`.
However, a downside of this support is that it requires bundling several
Unicode data tables that are substantial in size.

A fair number of use cases do not require full Unicode support. For this
reason, this crate exposes a number of features to control which Unicode
data is available.

If a regular expression attempts to use a Unicode feature that is not available
because the corresponding crate feature was disabled, then translating that
regular expression to an `Hir` will return an error. (It is still possible
construct an `Ast` for such a regular expression, since Unicode data is not
used until translation to an `Hir`.) Stated differently, enabling or disabling
any of the features below can only add or subtract from the total set of valid
regular expressions. Enabling or disabling a feature will never modify the
match semantics of a regular expression.

The following features are available:

* **std** -
  Enables support for the standard library. This feature is enabled by default.
  When disabled, only `core` and `alloc` are used. Otherwise, enabling `std`
  generally just enables `std::error::Error` trait impls for the various error
  types.
* **unicode** -
  Enables all Unicode features. This feature is enabled by default, and will
  always cover all Unicode features, even if more are added in the future.
* **unicode-age** -
  Provide the data for the
  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
  This makes it possible to use classes like `\p{Age:6.0}` to refer to all
  codepoints first introduced in Unicode 6.0
* **unicode-bool** -
  Provide the data for numerous Unicode boolean properties. The full list
  is not included here, but contains properties like `Alphabetic`, `Emoji`,
  `Lowercase`, `Math`, `Uppercase` and `White_Space`.
* **unicode-case** -
  Provide the data for case insensitive matching using
  [Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
* **unicode-gencat** -
  Provide the data for
  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
  This includes, but is not limited to, `Decimal_Number`, `Letter`,
  `Math_Symbol`, `Number` and `Punctuation`.
* **unicode-perl** -
  Provide the data for supporting the Unicode-aware Perl character classes,
  corresponding to `\w`, `\s` and `\d`. This is also necessary for using
  Unicode-aware word boundary assertions. Note that if this feature is
  disabled, the `\s` and `\d` character classes are still available if the
  `unicode-bool` and `unicode-gencat` features are enabled, respectively.
* **unicode-script** -
  Provide the data for
  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
  `Latin` and `Thai`.
* **unicode-segment** -
  Provide the data necessary to provide the properties used to implement the
  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
  This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
  `\p{sb=ATerm}`.
* **arbitrary** -
  Enabling this feature introduces a public dependency on the
  [`arbitrary`](https://crates.io/crates/arbitrary)
  crate. Namely, it implements the `Arbitrary` trait from that crate for the
  [`Ast`](crate::ast::Ast) type. This feature is disabled by default.
*//// A convenience routine for parsing a regex using default options./// This is equivalent to `Parser::new().parse(pattern)`./// If you need to set non-default options, then use a [`ParserBuilder`]./// This routine returns an [`Hir`](hir::Hir) value. Namely, it automatically/// parses the pattern as an [`Ast`](ast::Ast) and then invokes the translator/// to convert the `Ast` into an `Hir`. If you need access to the `Ast`, then/// you should use a [`ast::parse::Parser`]./// This type combines the builder options for both the [AST/// `ParserBuilder`](ast::parse::ParserBuilder) and the [HIR/// `TranslatorBuilder`](hir::translate::TranslatorBuilder)./// This limit is not checked until the entire Ast is parsed. Therefore,/// Enable or disable the CRLF mode flag by default./// Note that unless `utf8` is disabled (it's enabled by default), a/// regular expression will fail to parse if Unicode mode is disabled and a/// sub-expression could possibly match invalid UTF-8./// A convenience parser for regular expressions./// This parser takes as input a regular expression pattern string (the/// "concrete syntax") and returns a high-level intermediate representation/// (the HIR) suitable for most types of analysis. In particular, this parser/// hides the intermediate state of producing an AST (the "abstract syntax")./// The AST is itself far more complex than the HIR, so this parser serves as a/// convenience for never having to deal with it at all./// If callers have more fine grained use cases that need an AST, then please/// see the [`ast::parse`] module./// The parser can be run with `parse` method. The parse method returns/// a high level intermediate representation of the given regular/// Parse the regular expression into a high level intermediate/// An inclusive range of codepoints from a generated file (hence the static/// lifetime).PropertyNotFoundPropertyValueNotFoundPerlClassNotFound// Not used when unicode-perl is enabled./// An error that occurs when dealing with Unicode./// We don't impl the Error trait here because these always get converted/// into other public errors. (This error type isn't exported.)/// An error that occurs when Unicode-aware simple case folding fails./// This error can occur when the case mapping tables necessary for Unicode/// aware case folding are unavailable. This only occurs when the/// `unicode-case` feature is disabled. (The feature is enabled by default.)/// Perl character class `\w` are unavailable. This only occurs when the/// `unicode-perl` feature is disabled. (The feature is enabled by default.)/// The simple case fold table. It's a sorted association list, where the/// keys are Unicode scalar values and the values are the corresponding/// equivalence class (not including the key) of the "simple" case folded/// Unicode scalar values./// The last codepoint that was used for a lookup./// The index to the entry in `table` corresponding to the smallest key `k`/// such that `k > k0`, where `k0` is the most recent key lookup. Note that/// in particular, `k0` may not be in the table!SimpleCaseFolder/// A state oriented traverser of the simple case folding table./// A case folder can be constructed via `SimpleCaseFolder::new()`, which will/// return an error if the underlying case folding table is unavailable./// After construction, it is expected that callers will use/// `SimpleCaseFolder::mapping` by calling it with codepoints in strictly/// increasing order. For example, calling it on `b` and then on `a` is illegal/// and will result in a panic./// The main idea of this type is that it tries hard to make mapping lookups/// fast by exploiting the structure of the underlying table, and the ordering/// assumption enables this./// Create a new simple case folder, returning an error if the underlying/// case folding table is unavailable./// Return the equivalence class of case folded codepoints for the given/// codepoint. The equivalence class returned never includes the codepoint/// given. If the given codepoint has no case folded codepoints (i.e.,/// no entry in the underlying case folding table), then this returns an/// empty slice./// This panics when called with a `c` that is less than or equal to the/// previous call. In other words, callers need to use this method with/// strictly increasing values of `c`.overlaps/// Returns true if and only if the given range overlaps with any region/// of the underlying case folding table. That is, when true, there exists/// at least one codepoint in the inclusive range `[start, end]` that has/// a non-trivial equivalence class of case folded codepoints. Conversely,/// when this returns false, all codepoints in the range `[start, end]`/// correspond to the trivial equivalence class of case folded codepoints,/// i.e., itself./// This is useful to call before iterating over the codepoints in the/// range and looking up the mapping for each. If you know none of the/// mappings will return anything, then you might be able to skip doing it/// This panics when `end < start`./// Returns the index at which `c` occurs in the simple case fold table. If/// `c` does not occur, then this returns an `i` such that `table[i-1].0 </// c` and `table[i].0 > c`./// Return a class corresponding to a Unicode binary property, named by/// a single letter./// Return a class corresponding to a Unicode binary property./// Note that, by special exception (see UTS#18, Section 1.2), both/// general category values and script values are permitted here as if/// they were a binary property./// A property name./// A property value.ByValue/// Return a class corresponding to all codepoints whose property/// (identified by `property_name`) corresponds to the given value/// (identified by `property_value`)./// A query for finding a character class defined by Unicode. This supports/// either use of a property name directly, or lookup by property value. The/// former generally refers to Binary properties (see UTS#44, Table 8), but/// as a special exception (see UTS#18, Section 1.2) both general categories/// (an enumeration) and scripts (a catalog) are supported as if each of their/// possible values were a binary property./// In all circumstances, property names and values are normalized and/// canonicalized. That is, `GC == gc == GeneralCategory == general_category`./// The lifetime `'a` refers to the shorter of the lifetimes of property name/// and property value.CanonicalClassQuerycanonical_binary/// The canonical binary property name.GeneralCategory/// The canonical general category name./// The canonical script name./// The canonical property name./// The canonical property value./// An arbitrary association between property and value, both of which/// have been canonicalized./// Note that by construction, the property name of ByValue will never/// be General_Category or Script. Those two cases are subsumed by the/// eponymous variants./// Like ClassQuery, but its parameters have been canonicalized. This also/// differentiates binary properties from flattened general categories and/// scripts./// Looks up a Unicode class given a query. If one doesn't exist, then/// Returns a Unicode aware class for \w./// This returns an error if the data is not available for \w.perl_space/// Returns a Unicode aware class for \s./// This returns an error if the data is not available for \s.perl_digit/// Returns a Unicode aware class for \d./// This returns an error if the data is not available for \d.hir_class/// Build a Unicode HIR class from a sequence of Unicode scalar value ranges./// Returns true only if the given codepoint is in the `\w` character class./// If the `unicode-perl` feature is not enabled, then this returns an error.PropertyValues/// A mapping of property values for a specific property./// The first element of each tuple is a normalized property value while the/// second element of each tuple is the corresponding canonical propertycanonical_gencatcanonical_scriptcanonical_prop/// Find the canonical property name for the given normalized property name./// If no such property exists, then `None` is returned./// The normalized property name must have been normalized according to/// UAX44 LM3, which can be done using `symbolic_name_normalize`./// If the property names data is not available, then an error is returned.canonical_value/// Find the canonical property value for the given normalized property/// The given property values should correspond to the values for the property/// under question, which can be found using `property_values`./// If no such property value exists, then `None` is returned./// The normalized property value must have been normalized according toproperty_values/// Return the table of property values for the given property name./// If the property values data is not available, then an error is returned.property_set// This is only used in some cases, but small enough to just let it be dead// instead of figuring out (and maintaining) the right set of features.ages/// Returns an iterator over Unicode Age sets. Each item corresponds to a set/// of codepoints that were added in a particular revision of Unicode. The/// iterator yields items in chronological order./// If the given age value isn't valid or if the data isn't available, then an/// error is returned instead.gencat/// Returns the Unicode HIR class corresponding to the given general category./// Name canonicalization is assumed to be performed by the caller./// If the given general category could not be found, or if the general/// category data is not available, then an error is returned./// Returns the Unicode HIR class corresponding to the given script./// If the given script could not be found, or if the script data is not/// available, then an error is returned.script_extension/// Returns the Unicode HIR class corresponding to the given script extension./// If the given script extension could not be found, or if the script data is/// not available, then an error is returned.bool_property/// Returns the Unicode HIR class corresponding to the given Unicode boolean/// If the given boolean property could not be found, or if the boolean/// property data is not available, then an error is returned.gcb/// Returns the Unicode HIR class corresponding to the given grapheme cluster/// break property./// If the given property could not be found, or if the corresponding data iswb/// Returns the Unicode HIR class corresponding to the given word breaksb/// Returns the Unicode HIR class corresponding to the given sentencesymbolic_name_normalize/// Like symbolic_name_normalize_bytes, but operates on a string.symbolic_name_normalize_bytes/// Normalize the given symbolic name in place according to UAX44-LM3./// A "symbolic name" typically corresponds to property names and property/// value aliases. Note, though, that it should not be applied to property/// string values./// The slice returned is guaranteed to be valid UTF-8 for all possible values/// of `slice`./// See: https://unicode.org/reports/tr44/#UAX44-LM3simple_fold_okcontains_case_mapsimple_fold_ksimple_fold_arange_containsregression_466sym_normalizevalid_utf8_symbolicBY_NAMEV10_0V12_1V13_0V14_0V15_0V15_1V1_1V2_0V2_1V3_0V3_1V3_2V4_1V5_1V5_2V6_1V6_2V6_3//   ucd-generate age ucd-16.0.0 --charsCASE_FOLDING_SIMPLE//   ucd-generate case-folding-simple ucd-16.0.0 --chars --all-pairsCASED_LETTERCLOSE_PUNCTUATIONCONNECTOR_PUNCTUATIONCURRENCY_SYMBOLDASH_PUNCTUATIONDECIMAL_NUMBERENCLOSING_MARKFINAL_PUNCTUATIONFORMATINITIAL_PUNCTUATIONLETTERLETTER_NUMBERLINE_SEPARATORLOWERCASE_LETTERMARKMATH_SYMBOLMODIFIER_LETTERMODIFIER_SYMBOLNONSPACING_MARKOPEN_PUNCTUATIONOTHEROTHER_LETTEROTHER_NUMBEROTHER_PUNCTUATIONOTHER_SYMBOLPARAGRAPH_SEPARATORPRIVATE_USEPUNCTUATIONSEPARATORSPACE_SEPARATORSPACING_MARKTITLECASE_LETTERUNASSIGNEDUPPERCASE_LETTER//   ucd-generate general-category ucd-16.0.0 --chars --exclude surrogateEXTENDLVLVTPREPENDREGIONAL_INDICATORSPACINGMARKZWJ//   ucd-generate grapheme-cluster-break ucd-16.0.0 --charscase_folding_simplegeneral_categorygrapheme_cluster_breakproperty_boolproperty_namessentence_break//   ucd-generate general-category ucd-16.0.0 --chars --include decimalnumberWHITE_SPACE//   ucd-generate property-bool ucd-16.0.0 --chars --include whitespaceASCII_HEX_DIGITALPHABETICBIDI_CONTROLBIDI_MIRROREDCASE_IGNORABLECASEDCHANGES_WHEN_CASEFOLDEDCHANGES_WHEN_CASEMAPPEDCHANGES_WHEN_LOWERCASEDCHANGES_WHEN_TITLECASEDCHANGES_WHEN_UPPERCASEDDASHDEFAULT_IGNORABLE_CODE_POINTDIACRITICEMOJI_COMPONENTEMOJI_MODIFIEREMOJI_MODIFIER_BASEEMOJI_PRESENTATIONEXTENDED_PICTOGRAPHICEXTENDERGRAPHEME_BASEGRAPHEME_EXTENDGRAPHEME_LINKHEX_DIGITHYPHENIDS_BINARY_OPERATORIDS_TRINARY_OPERATORIDS_UNARY_OPERATORID_COMPAT_MATH_CONTINUEID_COMPAT_MATH_STARTID_CONTINUEID_STARTIDEOGRAPHICINCBJOIN_CONTROLLOGICAL_ORDER_EXCEPTIONMATHMODIFIER_COMBINING_MARKNONCHARACTER_CODE_POINTOTHER_ALPHABETICOTHER_DEFAULT_IGNORABLE_CODE_POINTOTHER_GRAPHEME_EXTENDOTHER_ID_CONTINUEOTHER_ID_STARTOTHER_LOWERCASEOTHER_MATHOTHER_UPPERCASEPATTERN_SYNTAXPATTERN_WHITE_SPACEPREPENDED_CONCATENATION_MARKQUOTATION_MARKRADICALSENTENCE_TERMINALSOFT_DOTTEDTERMINAL_PUNCTUATIONUNIFIED_IDEOGRAPHUPPERCASEVARIATION_SELECTORXID_CONTINUEXID_START//   ucd-generate property-bool ucd-16.0.0 --charsPROPERTY_NAMES//   ucd-generate property-names ucd-16.0.0PROPERTY_VALUES//   ucd-generate property-values ucd-16.0.0 --include gc,script,scx,age,gcb,wb,sbADLAMAHOMANATOLIAN_HIEROGLYPHSARABICARMENIANAVESTANBALINESEBAMUMBASSA_VAHBATAKBENGALIBHAIKSUKIBOPOMOFOBRAHMIBRAILLEBUGINESEBUHIDCANADIAN_ABORIGINALCARIANCAUCASIAN_ALBANIANCHAKMACHAMCHEROKEECHORASMIANCOMMONCOPTICCUNEIFORMCYPRIOTCYPRO_MINOANCYRILLICDESERETDEVANAGARIDIVES_AKURUDOGRADUPLOYANEGYPTIAN_HIEROGLYPHSELBASANELYMAICETHIOPICGARAYGEORGIANGLAGOLITICGOTHICGRANTHAGREEKGUJARATIGUNJALA_GONDIGURMUKHIGURUNG_KHEMAHANHANGULHANIFI_ROHINGYAHANUNOOHATRANHEBREWHIRAGANAIMPERIAL_ARAMAICINHERITEDINSCRIPTIONAL_PAHLAVIINSCRIPTIONAL_PARTHIANJAVANESEKAITHIKANNADAKATAKANAKAWIKAYAH_LIKHAROSHTHIKHITAN_SMALL_SCRIPTKHMERKHOJKIKHUDAWADIKIRAT_RAILAOLATINLEPCHALIMBULINEAR_ALINEAR_BLISULYCIANLYDIANMAHAJANIMAKASARMALAYALAMMANDAICMANICHAEANMARCHENMASARAM_GONDIMEDEFAIDRINMEETEI_MAYEKMENDE_KIKAKUIMEROITIC_CURSIVEMEROITIC_HIEROGLYPHSMIAOMODIMONGOLIANMROMULTANIMYANMARNABATAEANNAG_MUNDARINANDINAGARINEW_TAI_LUENEWANKONUSHUNYIAKENG_PUACHUE_HMONGOGHAMOL_CHIKIOL_ONALOLD_HUNGARIANOLD_ITALICOLD_NORTH_ARABIANOLD_PERMICOLD_PERSIANOLD_SOGDIANOLD_SOUTH_ARABIANOLD_TURKICOLD_UYGHURORIYAOSAGEOSMANYAPAHAWH_HMONGPALMYRENEPAU_CIN_HAUPHAGS_PAPHOENICIANPSALTER_PAHLAVIREJANGRUNICSAMARITANSAURASHTRASHARADASHAVIANSIDDHAMSIGNWRITINGSINHALASOGDIANSORA_SOMPENGSOYOMBOSUNDANESESUNUWARSYLOTI_NAGRISYRIACTAGALOGTAGBANWATAI_LETAI_THAMTAI_VIETTAKRITAMILTANGSATANGUTTELUGUTHAANATHAITIBETANTIFINAGHTIRHUTATODHRITOTOTULU_TIGALARIUGARITICVAIVITHKUQIWANCHOWARANG_CITIYEZIDIYIZANABAZAR_SQUARE//   ucd-generate script ucd-16.0.0 --chars//   ucd-generate script-extension ucd-16.0.0 --charsATERMLOWERNUMERICOLETTERSCONTINUESTERMSEPUPPER//   ucd-generate sentence-break ucd-16.0.0 --charsALETTERDOUBLE_QUOTEEXTENDNUMLETHEBREW_LETTERMIDLETTERMIDNUMMIDNUMLETNEWLINESINGLE_QUOTEWSEGSPACE//   ucd-generate word-break ucd-16.0.0 --charsMAX_UTF8_BYTESUtf8Sequence/// One byte range./// Two successive byte ranges./// Three successive byte ranges./// Four successive byte ranges./// Utf8Sequence represents a sequence of byte ranges./// To match a Utf8Sequence, a candidate byte sequence must match each/// successive range./// For example, if there are two ranges, `[C2-DF][80-BF]`, then the byte/// sequence `\xDD\x61` would not match because `0x61 < 0x80`.from_encoded_range/// Creates a new UTF-8 sequence from the encoded bytes of a scalar value/// This assumes that `start` and `end` have the same length./// Returns the underlying sequence of byte ranges as a slice./// Returns the number of byte ranges in this sequence./// The length is guaranteed to be in the closed interval `[1, 4]`./// Reverses the ranges in this sequence./// For example, if this corresponds to the following sequence:/// [D0-D3][80-BF]/// Then after reversal, it will be/// [80-BF][D0-D3]/// This is useful when one is constructing a UTF-8 automaton to match/// character classes in reverse./// Returns true if and only if a prefix of `bytes` matches this sequence/// of byte ranges./// Start of byte range (inclusive)./// End of byte range (inclusive)./// A single inclusive range of UTF-8 bytes./// Returns true if and only if the given byte is in this range.range_stackScalarRange/// An iterator over ranges of matching UTF-8 byte sequences./// The iteration represents an alternation of comprehensive byte sequences/// that match precisely the set of UTF-8 encoded scalar values./// A byte sequence corresponds to one of the scalar values in the range given/// if and only if it completely matches exactly one of the sequences of byte/// ranges produced by this iterator./// Each sequence of byte ranges matches a unique set of bytes. That is, no two/// sequences will match the same bytes./// This shows how to match an arbitrary byte sequence against a range of/// scalar values./// use regex_syntax::utf8::{Utf8Sequences, Utf8Sequence};/// fn matches(seqs: &[Utf8Sequence], bytes: &[u8]) -> bool {///     for range in seqs {///         if range.matches(bytes) {///             return true;/// // Test the basic multilingual plane./// let seqs: Vec<_> = Utf8Sequences::new('\u{0}', '\u{FFFF}').collect();/// // UTF-8 encoding of 'a'./// assert!(matches(&seqs, &[0x61]));/// // UTF-8 encoding of '☃' (`\u{2603}`)./// assert!(matches(&seqs, &[0xE2, 0x98, 0x83]));/// // UTF-8 encoding of `\u{10348}` (outside the BMP)./// assert!(!matches(&seqs, &[0xF0, 0x90, 0x8D, 0x88]));/// // Tries to match against a UTF-8 encoding of a surrogate codepoint,/// // which is invalid UTF-8, and therefore fails, despite the fact that/// // the corresponding codepoint (0xD800) falls in the range given./// assert!(!matches(&seqs, &[0xED, 0xA0, 0x80]));/// // And fails against plain old invalid UTF-8./// assert!(!matches(&seqs, &[0xFF, 0xFF]));/// If this example seems circuitous, that's because it is! It's meant to be/// illustrative. In practice, you could just try to decode your byte sequence/// and compare it with the scalar value range directly. However, this is not/// always possible (for example, in a byte based automaton)./// Create a new iterator over UTF-8 byte ranges for the scalar value range/// reset resets the scalar value range./// Any existing state is cleared, but resources may be reused./// N.B. Benchmarks say that this method is dubious./// split splits this range if it overlaps with a surrogate codepoint./// Either or both ranges may be invalid./// is_valid returns true if and only if start <= end.as_ascii/// as_ascii returns this range as a Utf8Range if and only if all scalar/// values in this range can be encoded as a single byte./// is_ascii returns true if the range is ASCII only (i.e., takes a single/// byte to encode any scalar value)./// encode writes the UTF-8 encoding of the start and end of this range/// to the corresponding destination slices, and returns the number of/// bytes written./// The slices should have room for at least `MAX_UTF8_BYTES`.max_scalar_valuerutf8never_accepts_surrogate_codepointscodepoints_no_surrogatessingle_codepoint_one_sequenceencode_surrogate/*!
Converts ranges of Unicode scalar values to equivalent ranges of UTF-8 bytes.

This is sub-module is useful for constructing byte based automatons that need
to embed UTF-8 decoding. The most common use of this module is in conjunction
with the [`hir::ClassUnicodeRange`](crate::hir::ClassUnicodeRange) type.

See the documentation on the `Utf8Sequences` iterator for more details and
an example.

# Wait, what is this?

This is simplest to explain with an example. Let's say you wanted to test
whether a particular byte sequence was a Cyrillic character. One possible
scalar value range is `[0400-04FF]`. The set of allowed bytes for this
range can be expressed as a sequence of byte ranges:

```text
[D0-D3][80-BF]
```

This is simple enough: simply encode the boundaries, `0400` encodes to
`D0 80` and `04FF` encodes to `D3 BF`, and create ranges from each
corresponding pair of bytes: `D0` to `D3` and `80` to `BF`.

However, what if you wanted to add the Cyrillic Supplementary characters to
your range? Your range might then become `[0400-052F]`. The same procedure
as above doesn't quite work because `052F` encodes to `D4 AF`. The byte ranges
you'd get from the previous transformation would be `[D0-D4][80-AF]`. However,
this isn't quite correct because this range doesn't capture many characters,
for example, `04FF` (because its last byte, `BF` isn't in the range `80-AF`).

Instead, you need multiple sequences of byte ranges:

```text
[D0-D3][80-BF]  # matches codepoints 0400-04FF
[D4][80-AF]     # matches codepoints 0500-052F
```

This gets even more complicated if you want bigger ranges, particularly if
they naively contain surrogate codepoints. For example, the sequence of byte
ranges for the basic multilingual plane (`[0000-FFFF]`) look like this:

```text
[0-7F]
[C2-DF][80-BF]
[E0][A0-BF][80-BF]
[E1-EC][80-BF][80-BF]
[ED][80-9F][80-BF]
[EE-EF][80-BF][80-BF]
```

Note that the byte ranges above will *not* match any erroneous encoding of
UTF-8, including encodings of surrogate codepoints.

And, of course, for all of Unicode (`[000000-10FFFF]`):

```text
[0-7F]
[C2-DF][80-BF]
[E0][A0-BF][80-BF]
[E1-EC][80-BF][80-BF]
[ED][80-9F][80-BF]
[EE-EF][80-BF][80-BF]
[F0][90-BF][80-BF][80-BF]
[F1-F3][80-BF][80-BF][80-BF]
[F4][80-8F][80-BF][80-BF]
```

This module automates the process of creating these byte ranges from ranges of
Unicode scalar values.

# Lineage

I got the idea and general implementation strategy from Russ Cox in his
[article on regexps](https://web.archive.org/web/20160404141123/https://swtch.com/~rsc/regexp/regexp3.html) and RE2.
Russ Cox got it from Ken Thompson's `grep` (no source, folk lore?).
I also got the idea from
[Lucene](https://github.com/apache/lucene-solr/blob/ae93f4e7ac6a3908046391de35d4f50a0d3c59ca/lucene/core/src/java/org/apache/lucene/util/automaton/UTF32ToUTF8.java),
which uses it for executing automata on their term index.
*//// Apply a filter and write the result to the sink./// Reset the filter to encode an image with the given options./// A filter selection algorithm./// A filter that just encodes the actual byte value every time./// This method is recommended for images that are indexed or with low bit-depth./// A filter that picks the method with the smallest squared sum of deltas./// This option is recommended for most images.//! Image filter selection algorithms.ColorFormat/// Encode an RGBA image./// The main object, which does all of the encoding work./// Finish encoding an image, writing any delayed data./// Write a chunk with the given type and data./// Get access to the writer that this was built with./// Be careful, because you can easily corrupt the image with this method.sinking_chunk/// Make a new encoder, which writes to a given sink, with a custom filter./// This method also immediately writes the PNG headers to the sink./// Feed zero or more rows to the encoder./// Rows are specified in top-to-bottom and left-to-right order./// This method panics if you try to write data that doesn't fit into a/// whole number of rows./// Reset the encoder to encode another image with the given options./// There's a good chance that, before calling this method, you'll want to/// call `writer()` to get a mutable reference to the writer, and swap that/// out with a different writer. This method also writes the headers of the/// new image to the sink./// This currently doesn't change the compression level!//! The PNG encoder that no one asked for.//! The abstraction is pretty leaky, but it's simple enough that you can make//! cool things without much effort, such as this program, which creates a very//! blank image.//! use repng::Options;//! let mut png = Vec::new();//!     let mut encoder = Options::smallest(480, 360)//!         .build(&mut png)//!     let row = [255; 480 * 4];//!     for y in 0..360 {//!         encoder.write(&row).unwrap();//!     encoder.finish().unwrap();//! println!("{:?}", png);/// Specify the color palette for an indexed image./// The first 3 bytes specify the RGB value represented by index 0, the next 3/// bytes specify the RGB value represented by index 1, and so on./// Panics if the array's length isn't a multiple of 3, or if there are more/// than 256 palette entries.palette_alpha/// The same as `palette`, but with RGBA (4 bytes) instead of RGB (3 bytes)./// Specify the aspect ratio of the image./// Essentially, `x : y` is the ratio between image's width and its height./// Add some textual metadata to the image./// Short (one line) title or caption for image.Author/// Name of image's creator./// Description of image (possibly long)./// Copyright notice.CreationTime/// Time of original image creation.Software/// Software used to create the image.Disclaimer/// Legal disclaimer./// Warning of nature of content./// Device used to create the image./// Miscellaneous comment./// A custom keyword between 1 and 79 characters in length./// A metadata category./// Whether the keyword is valid./// - It must be at least 1 character long./// - It must be no more than 79 characters long./// - It must only use the characters in the ASCII range [32, 126]./// - It must not contain leading or trailing spaces./// - It must not contain consecutive spaces./// Get the keyword as a string.//! Add some metadata to the image./// A format encoding only the luminosity of each pixel./// Valid bit depths are 1, 2, 4, 8 and 16 bits./// A format encoding the red, green, then blue components of each pixel./// Valid bit depths are 8 and 16 bits./// A single-channel format encoding the index of each pixel in a palette./// If you use this format, you probably want to also use `meta::palette`/// or `meta::palette_alpha` before writing any image data, because/// otherwise, the decoder probably won't know what each index represents./// Valid bit depths are 1, 2, 4 and 8 bits.GrayA/// The same as Gray, but with an alpha channel added to the end./// The same as RGB, but with an alpha channel added to the end./// A color format, which specifies how the bytes represent the pixels./// The number of components in each pixel./// The compression level./// The number of bits in each channel./// The format of the image./// The size of the compressed data buffer./// This value determines the maximum size of an IDAT chunk./// Image properties and compression options.smallest/// Specifies an 8-bit RGBA image optimizing for image size.fastest/// Specifies an 8-bit RGBA image optimizing for encoding speed./// Make a new encoder with these options and the default filter./// To customize the filter as well, see `Encoder::new`./// The number of bytes occupied by a single row of the uncompressed image.HttpBody/// An asynchronous request body.Reusabler" A body with a total timeout."r" The timeout does not reset upon each chunk, but rather requires the whole"r" body be streamed before the deadline is reached."TotalTimeoutBodyReadTimeoutBody/// Returns a reference to the internal data of the `Body`./// `None` is returned, if the underlying data is a stream.reusable/// Wrap a [`HttpBody`] in a box inside `Body`./// # use reqwest::Body;/// # use futures_util;/// let content = "hello,world!".to_string();/// let body = Body::wrap(content);total_timeoutwith_read_timeoutResponseBodybox_errIntoBytesBody// We can't use `map_frame()` because that loses the hint data (for good reason).// But we aren't transforming the data.test_as_bytesbody_exact_length/*
impl From<hyper::Body> for Body {
    #[inline]
    fn from(body: hyper::Body) -> Body {
        Self {
            inner: Inner::Streaming {
                body: Box::pin(WrapHyper(body)),
            },
        }
    }
}
*/// ===== impl TotalTimeoutBody =====// ===== impl DataStream =====// ===== impl IntoBytesBody =====AcceptsRequestBuilderRequestConfigTotalTimeoutUnixSocketProviderUnnameableBoxedConnectorLayerBoxedConnectorServicegaiDnsResolverWithOverridesDynResolverinto_urltry_uriProxyMatcherredirectTowerRedirectPolicyIntoUrlBoxCloneSyncServiceLayerfollow_redirectFollowRedirectClientRef/// An asynchronous `Client` to make Requests with./// The Client has various configuration values to tweak, but the defaults/// are set to what is usually the most commonly desired value. To configure a/// `Client`, use `Client::builder()`./// The `Client` holds a connection pool internally, so it is advised that/// you create one and **reuse** it./// You do **not** have to wrap the `Client` in an [`Rc`] or [`Arc`] to **reuse** it,/// because it already uses an [`Arc`] internally./// [`Rc`]: std::rc::Rc/// A `ClientBuilder` can be used to create a `Client` with custom configuration.HttpVersionPrefHyperClientHyperServiceasync_impl// NOTE: When adding a new field, update `fmt::Debug for ClientBuilder`hostname_verificationcerts_verificationtls_sniconnection_verbosetcp_keepalivetcp_keepalive_intervaltcp_keepalive_retriesproxiesauto_sys_proxyredirect_policyPolicyretry_policyrefererroot_certstls_built_in_root_certstls_built_in_certs_webpkitls_built_in_certs_nativecrlsmin_tls_versionmax_tls_versiontls_infoconnector_layershttp_version_prefhickory_dnsdns_overridesdns_resolverunix_socket/// Constructs a new `ClientBuilder`./// This is the same as `Client::builder()`./// Returns a `Client` that uses this `ClientBuilder` configuration./// This method fails if a TLS backend cannot be initialized, or the resolver/// cannot load the system configuration.user_agent/// Sets the `User-Agent` header to be used by this client./// # async fn doc() -> Result<(), reqwest::Error> {/// // Name your user agent after your app?/// static APP_USER_AGENT: &str = concat!(///     env!("CARGO_PKG_NAME"),///     "/",///     env!("CARGO_PKG_VERSION"),/// let client = reqwest::Client::builder()///     .user_agent(APP_USER_AGENT)/// let res = client.get("https://www.rust-lang.org").send().await?;default_headers/// Sets the default headers for every request./// use reqwest::header;/// let mut headers = header::HeaderMap::new();/// headers.insert("X-MY-HEADER", header::HeaderValue::from_static("value"));/// // Consider marking security-sensitive headers with `set_sensitive`./// let mut auth_value = header::HeaderValue::from_static("secret");/// auth_value.set_sensitive(true);/// headers.insert(header::AUTHORIZATION, auth_value);/// // get a client builder///     .default_headers(headers)/// Enable auto gzip decompression by checking the `Content-Encoding` response header./// If auto gzip decompression is turned on:/// - When sending a request and if the request's headers do not already contain///   an `Accept-Encoding` **and** `Range` values, the `Accept-Encoding` header is set to `gzip`.///   The request body is **not** automatically compressed./// - When receiving a response, if its headers contain a `Content-Encoding` value of///   `gzip`, both `Content-Encoding` and `Content-Length` are removed from the///   headers' set. The response body is automatically decompressed./// If the `gzip` feature is turned on, the default option is enabled./// # Optional/// This requires the optional `gzip` feature to be enabledno_gzip/// Disable auto response body gzip decompression./// This method exists even if the optional `gzip` feature is not enabled./// This can be used to ensure a `Client` doesn't use gzip decompression/// even if another dependency were to enable the optional `gzip` feature.no_brotli/// Disable auto response body brotli decompression./// This method exists even if the optional `brotli` feature is not enabled./// This can be used to ensure a `Client` doesn't use brotli decompression/// even if another dependency were to enable the optional `brotli` feature.no_zstd/// Disable auto response body zstd decompression./// This method exists even if the optional `zstd` feature is not enabled./// This can be used to ensure a `Client` doesn't use zstd decompression/// even if another dependency were to enable the optional `zstd` feature.no_deflate/// Disable auto response body deflate decompression./// This method exists even if the optional `deflate` feature is not enabled./// This can be used to ensure a `Client` doesn't use deflate decompression/// even if another dependency were to enable the optional `deflate` feature./// Set a `RedirectPolicy` for this client./// Default will follow redirects up to a maximum of 10./// Enable or disable automatic setting of the `Referer` header./// Set a request retry policy./// Default behavior is to retry protocol NACKs.// XXX: accept an `impl retry::IntoPolicy` instead?/// Add a `Proxy` to the list of proxies the `Client` will use./// Adding a proxy will disable the automatic usage of the "system" proxy.no_proxy/// Clear all `Proxies`, so `Client` will use no proxy anymore./// To add a proxy exclusion list, use [crate::proxy::Proxy::no_proxy()]/// on all desired proxies instead./// This also disables the automatic usage of the "system" proxy./// Enables a total request timeout./// The timeout is applied from when the request starts connecting until the/// response body has finished. Also considered a total deadline./// Default is no timeout./// Enables a read timeout./// The timeout applies to each read operation, and resets after a/// successful read. This is more appropriate for detecting stalled/// connections when the size isn't known beforehand./// Set a timeout for only the connect phase of a `Client`./// This **requires** the futures be executed in a tokio runtime with/// a tokio timer enabled./// Set whether connections should emit verbose logs./// Enabling this option will emit [log][] messages at the `TRACE` level/// for read and write operations on connections./// [log]: https://crates.io/crates/log/// Send headers as title case instead of lowercase./// Set whether HTTP/1 connections will accept spaces between header/// names and the colon that follow them in responses./// Only use HTTP/1./// Allow HTTP/0.9 responsestcp_nodelay/// Set whether sockets have `TCP_NODELAY` enabled./// Bind to a local IP Address./// # fn doc() -> Result<(), reqwest::Error> {/// let local_addr = IpAddr::from([12, 4, 1, 8]);///     .local_address(local_addr)/// Bind connections only on the specified network interface./// This option is only available on the following operating systems:/// - Android/// - Linux,/// - macOS and macOS-like systems (iOS, tvOS, watchOS and visionOS)/// - Solaris and illumos/// On Android, Linux, and Fuchsia, this uses the/// [`SO_BINDTODEVICE`][man-7-socket] socket option. On macOS and macOS-like/// systems, Solaris, and illumos, this instead uses the [`IP_BOUND_IF` and/// `IPV6_BOUND_IF`][man-7p-ip] socket options (as appropriate)./// Note that connections will fail if the provided interface name is not a/// network interface that currently exists when a connection is established./// let interface = "lo";///     .interface(interface)/// [man-7-socket]: https://man7.org/linux/man-pages/man7/socket.7.html/// [man-7p-ip]: https://docs.oracle.com/cd/E86824_01/html/E54777/ip-7p.html/// Set that all sockets have `SO_KEEPALIVE` set with the supplied duration./// If `None`, the option will not be set./// Set that all sockets have `SO_KEEPALIVE` set with the supplied interval./// Set that all sockets have `SO_KEEPALIVE` set with the supplied retry count./// Set that all sockets have `TCP_USER_TIMEOUT` set with the supplied duration./// This option controls how long transmitted data may remain unacknowledged before/// the connection is force-closed./// Set that all connections will use this Unix socket./// If a request URI uses the `https` scheme, TLS will still be used over/// the Unix socket./// This option is not compatible with any of the TCP or Proxy options./// Setting this will ignore all those options previously set./// Likewise, DNS resolution will not be done on the domain name./// Add a custom root certificate./// This can be used to connect to a server that has a self-signed/// certificate for example./// This requires the optional `default-tls`, `native-tls`, or `rustls-tls(-...)`/// feature to be enabled.add_crl/// Add a certificate revocation list./// This requires the `rustls-tls(-...)` Cargo feature enabled.add_crls/// Add multiple certificate revocation lists./// Controls the use of built-in/preloaded certificates during certificate validation./// Defaults to `true` -- built-in system certs will be used./// # Bulk Option/// If this value is `true`, _all_ enabled system certs configured with Cargo/// features will be loaded./// You can set this to `false`, and enable only a specific source with/// individual methods. Do that will prevent other sources from being loaded/// even if their feature Cargo feature is enabled.tls_built_in_webpki_certs/// Sets whether to load webpki root certs with rustls./// If the feature is enabled, this value is `true` by default.tls_built_in_native_certs/// Sets whether to load native root certs with rustls./// This requires the optional `native-tls` or `rustls-tls(-...)` feature to be/// You should think very carefully before you use this method. If/// hostname verification is not used, any valid certificate for any/// site will be trusted for use from any other. This introduces a/// significant vulnerability to man-in-the-middle attacks./// You should think very carefully before using this method. If/// invalid certificates are trusted, *any* certificate for *any* site/// will be trusted for use. This includes expired certificates. This/// introduces significant vulnerabilities, and should only be used/// as a last resort./// Controls the use of TLS server name indication./// Set the minimum required TLS version for connections./// By default, the TLS backend's own default is used./// A value of `tls::Version::TLS_1_3` will cause an error with the/// `native-tls`/`default-tls` backend. This does not mean the version/// isn't supported, just that it can't be set as a minimum due to/// technical limitations./// Set the maximum allowed TLS version for connections./// By default, there's no maximum./// isn't supported, just that it can't be set as a maximum due to/// Cannot set a maximum outside the protocol versions supported by/// `rustls` with the `rustls-tls` backend.use_native_tls/// Force using the native TLS backend./// Since multiple TLS backends can be optionally enabled, this option will/// force the `native-tls` backend to be used for this `Client`./// This requires the optional `native-tls` feature to be enabled.use_rustls_tls/// Force using the Rustls TLS backend./// force the `rustls` backend to be used for this `Client`./// This requires the optional `rustls-tls(-...)` feature to be enabled.use_preconfigured_tls/// Use a preconfigured TLS backend./// If the passed `Any` argument is not a TLS backend that reqwest/// understands, the `ClientBuilder` will error when calling `build`./// This is an advanced option, and can be somewhat brittle. Usage requires/// keeping the preconfigured TLS argument version in sync with reqwest,/// since version mismatches will result in an "unknown" TLS backend./// If possible, it's preferable to use the methods on `ClientBuilder`/// to configure reqwest's TLS./// This requires one of the optional features `native-tls` or/// `rustls-tls(-...)` to be enabled./// Add TLS information as `TlsInfo` extension to responses./// Restrict the Client to be used with HTTPS only requests.no_trust_dnsno_hickory_dns/// Disables the hickory-dns async resolver./// This method exists even if the optional `hickory-dns` feature is not enabled./// This can be used to ensure a `Client` doesn't use the hickory-dns async resolver/// even if another dependency were to enable the optional `hickory-dns` feature./// Override DNS resolution for specific domains to a particular IP address./// Set the port to `0` to use the conventional port for the given scheme (e.g. 80 for http)./// Ports in the URL itself will always be used instead of the port in the overridden addr.resolve_to_addrs/// Override DNS resolution for specific domains to particular IP addresses./// Override the DNS resolver implementation./// Pass an `Arc` wrapping a type implementing `Resolve`./// Overrides for specific names passed to `resolve` and `resolve_to_addrs` will/// still be applied on top of this resolver.dns_resolver2IntoResolve/// This method will replace `dns_resolver` in the next breaking change.connector_layer/// Adds a new Tower [`Layer`](https://docs.rs/tower/latest/tower/trait.Layer.html) to the/// base connector [`Service`](https://docs.rs/tower/latest/tower/trait.Service.html) which/// is responsible for connection establishment./// Each subsequent invocation of this function will wrap previous layers./// If configured, the `connect_timeout` will be the outermost layer./// Example usage:/// # #[cfg(not(feature = "rustls-tls-no-provider"))]///                      // resolved to outermost layer, meaning while we are waiting on concurrency limit///                      .connect_timeout(Duration::from_millis(200))///                      // underneath the concurrency check, so only after concurrency limit lets us through///                      .connector_layer(tower::timeout::TimeoutLayer::new(Duration::from_millis(50)))///                      .connector_layer(tower::limit::concurrency::ConcurrencyLimitLayer::new(2))///                      .build()///                      .unwrap();// Higher-level options// Redirect options// Retry options// Proxy options// Timeout options// HTTP options// TCP options// Alt Transports// TLS options/// Constructs a new `Client`./// This method panics if a TLS backend cannot be initialized, or the resolver/// Use `Client::builder()` if you wish to handle the failure as an `Error`/// instead of panicking./// Creates a `ClientBuilder` to configure a `Client`./// This is the same as `ClientBuilder::new()`./// Convenience method to make a `GET` request to a URL./// This method fails whenever the supplied `Url` cannot be parsed./// Convenience method to make a `POST` request to a URL./// Convenience method to make a `PUT` request to a URL./// Convenience method to make a `PATCH` request to a URL./// Convenience method to make a `DELETE` request to a URL./// Convenience method to make a `HEAD` request to a URL./// Start building a `Request` with the `Method` and `Url`./// Returns a `RequestBuilder`, which will allow setting headers and/// the request body before sending./// Executes a `Request`./// A `Request` can be built manually with `Request::new()` or obtained/// from a RequestBuilder with `RequestBuilder::build()`./// You should prefer to use the `RequestBuilder` and/// `RequestBuilder::send()`./// This method fails if there was an error while sending request,/// redirect loop was detected or redirect limit was exhausted.execute_requestproxy_custom_headersfmt_fieldsLayeredServiceLayeredFutureproxies_maybe_http_authproxies_maybe_http_custom_headersredirect_policy_descPendingInnerPendingRequestread_timeout_futexecute_request_rejects_invalid_urls" https://github.com/seanmonstar/reqwest/issues/668"execute_request_rejects_invalid_hostnametest_future_sizeBytesCodecFramedReadStreamReader/// A response decompressor over a non-blocking stream of chunks./// The inner decoder may be constructed asynchronously.PeekableIoStreamIoStreamPeekableIoStreamReaderPlainText/// A `PlainText` decoder just returns the response content as is./// A `Gzip` decoder will uncompress the gzipped response content before returning it./// A decoder that doesn't have a value yet.DecoderType/// A future attempt to poll the response body for EOF so we know whether to use gzip or not.plain_text/// A plain text decoder./// This decoder will emit the underlying chunks as-is./// A gzip decoder./// This decoder will buffer and decompress chunks that are gzipped.detect_encoding/// Constructs a Decoder from a hyper request./// A decoder is just a wrapper around the hyper request that knows/// how to decode the content body of the request./// Uses the correct variant by inspecting the Content-Encoding header.poll_inner_should_be_emptyis_gzipis_brotliis_zstdis_deflate/*
    pub(super) fn none() -> Self {
        Accepts {
            #[cfg(feature = "gzip")]
            gzip: false,
            #[cfg(feature = "brotli")]
            brotli: false,
            #[cfg(feature = "zstd")]
            zstd: false,
            #[cfg(feature = "deflate")]
            deflate: false,
        }
    }
    */accepts_as_str// ===== impl Accepts =====h3_clienth3_quinnOpenStreamsH3Connectionmax_field_section_size/// Set the maximum HTTP/3 header size this client is willing to accept./// See [header size constraints] section of the specification for details./// [header size constraints]: https://www.rfc-editor.org/rfc/rfc9114.html#name-header-size-constraints/// Please see docs in [`Builder`] in [`h3`]./// [`Builder`]: https://docs.rs/h3/latest/h3/client/struct.Builder.html#method.max_field_section_sizesend_grease/// Enable whether to send HTTP/3 protocol grease on the connections./// Just like in HTTP/2, HTTP/3 also uses the concept of "grease"/// to prevent potential interoperability issues in the future./// In HTTP/3, the concept of grease is used to ensure that the protocol can evolve/// and accommodate future changes without breaking existing implementations./// [`Builder`]: https://docs.rs/h3/latest/h3/client/struct.Builder.html#method.send_greaseH3ClientConfig/// H3 Client ConfigH3Connectorremote_connect// Trait from hyper to implement DNS resolution for HTTP/3 client.H3Clientget_pooled_clientH3ResponseFutureConnectingLockInnerConnectingLock/// A lock that ensures only one HTTP/3 connection is established per host at a/// time. The lock is automatically released when dropped.ConnectingWaiter/// A waiter that allows subscribers to receive updates when a new connection is/// established or when the connection attempt fails. For example, when/// connection lock is dropped due to an error./// A connection attempt is already in progress./// You must subscribe to updates instead of initiating a new connection./// The connection lock has been acquired, allowing you to initiate a/// new connection./// Forget the lock and return corresponding Key/// Acquire a connecting lock. This is to ensure that we have only one HTTP3/// connection per host.try_poolidle_connsPoolConnection// This receives errors from polling h3 driver.RequestStreamsend_rxmime_guessMimeFormParts/// An async multipart/form-data request.PartMetadatabody_length/// A field in a multipart form.computed_headersPercentEncodingmimePartProps/// Creates a new async Form without any content./// Get the boundary that this form will use./// Add a data field with supplied name and value./// let form = reqwest::multipart::Form::new()///     .text("username", "seanmonstar")///     .text("password", "secret");/// Adds a file field./// The path will be used to try to guess the filename and mime./// # async fn run() -> std::io::Result<()> {///     .file("key", "/path/to/file").await?;/// Errors when the file cannot be opened./// Adds a customized Part.percent_encode_path_segment/// Configure this `Form` to percent-encode using the `path-segment` rules.percent_encode_attr_chars/// Configure this `Form` to percent-encode using the `attr-char` rules.percent_encode_noop/// Configure this `Form` to skip percent-encoding/// Consume this instance and transform into an instance of Body for use in a request./// Produce a stream of the bytes in this `Form`, consuming it.part_stream/// Generate a hyper::Body stream for a single Part instance of a Form request./// Makes a text parameter./// Makes a new parameter from arbitrary bytes./// Makes a new parameter from an arbitrary stream.stream_with_length/// Makes a new parameter from an arbitrary stream with a known length. This is particularly/// useful when adding something like file contents as a stream, where you can know the content/// length beforehand./// Makes a file parameter.mime_str/// Tries to set the mime of this part.// Re-export when mime 0.4 is available, with split MediaType/MediaRange./// Sets the filename, builder style./// Sets custom headers for the part.// If predictable, computes the length the request will have// The length should be predictable if only String and file fields have been added,// but not if a generic reader has been added;take_fields/// Take the fields vector of this instance, replacing with an empty vector.'fa'fbFRAGMENT_ENCODE_SET// https://url.spec.whatwg.org/#fragment-percent-encode-setPATH_ENCODE_SET// https://url.spec.whatwg.org/#path-percent-encode-setPATH_SEGMENT_ENCODE_SETATTR_CHAR_ENCODE_SET// https://tools.ietf.org/html/rfc8187#section-3.2.1AttrChargen_boundaryform_emptystream_to_endstream_to_end_with_headercorrect_content_lengthheader_percent_encoding//! multipart/form-data// ===== impl Form =====// ===== impl Part =====// ===== impl FormParts =====// ===== impl PartMetadata =====HttpRequest/// A request which can be executed with `Client::execute()`."RequestBuilder does nothing until you 'send' it"/// A builder to construct the properties of a `Request`./// To construct a `RequestBuilder`, refer to the `Client` documentation./// Constructs a new request./// Get the method./// Get a mutable reference to the method./// Get the url.url_mut/// Get a mutable reference to the url./// Get the headers./// Get a mutable reference to the headers./// Get the body./// Get a mutable reference to the body./// Get the extensions./// Get a mutable reference to the extensions./// Get the timeout.timeout_mut/// Get a mutable reference to the timeout./// Get the http version./// Get a mutable reference to the http version./// Attempt to clone the request./// `None` is returned if the request can not be cloned, i.e. if the body is a stream.pieces/// Assemble a builder starting from an existing `Client` and a `Request`./// Add a `Header` to this Request.header_sensitive/// Add a `Header` to this Request with ability to define if `header_value` is sensitive./// Add a set of Headers to the existing ones on this Request./// The headers will be merged in to any already set./// Enable HTTP basic authentication./// # use reqwest::Error;/// # async fn run() -> Result<(), Error> {/// let client = reqwest::Client::new();/// let resp = client.delete("http://httpbin.org/delete")///     .basic_auth("admin", Some("good password"))///     .send()bearer_auth/// Enable HTTP bearer authentication./// Set the request body./// Enables a request timeout./// response body has finished. It affects only this request and overrides/// the timeout configured using `ClientBuilder::timeout()`./// Modify the query string of the URL./// Modifies the URL of this request, adding the parameters provided./// This method appends and does not overwrite. This means that it can/// be called multiple times and that existing query parameters are not/// overwritten if the same key is used. The key will simply show up/// twice in the query string./// Calling `.query(&[("foo", "a"), ("foo", "b")])` gives `"foo=a&foo=b"`./// This method does not support serializing a single key-value/// pair. Instead of using `.query(("key", "val"))`, use a sequence, such/// as `.query(&[("key", "val")])`. It's also possible to serialize structs/// and maps into a key-value pair./// This method will fail if the object you provide cannot be serialized/// into a query string./// Set HTTP version/// Send a form body./// Sets the body to the url encoded serialization of the passed value,/// and also sets the `Content-Type: application/x-www-form-urlencoded`/// header./// let mut params = HashMap::new();/// params.insert("lang", "rust");/// let res = client.post("http://httpbin.org")///     .form(&params)/// This method fails if the passed value cannot be serialized into/// url encoded formatjson/// Send a JSON body./// This requires the optional `json` feature enabled./// Serialization can fail if `T`'s implementation of `Serialize` decides to/// fail, or if `T` contains a map with non-string keys.fetch_mode_no_cors// This was a shell only meant to help with rendered documentation.// However, docs.rs can now show the docs for the wasm platforms, so this// is no longer needed.// You should not otherwise depend on this function. It's deprecation// is just to nudge people to reduce breakage. It may be removed in a// future patch version./// Build a `Request`, which can be inspected, modified and executed with/// `Client::execute()`.build_split/// This is similar to [`RequestBuilder::build()`], but also returns the/// embedded `Client`./// Constructs the Request and sends it to the target URL, returning a/// future Response./// let response = reqwest::Client::new()///     .get("https://hyper.rs")/// Attempt to clone the RequestBuilder./// `None` is returned if the RequestBuilder can not be cloned,/// i.e. if the request body is a stream./// # fn run() -> Result<(), Error> {/// let builder = client.post("http://httpbin.org/post")///     .body("from a &str!");/// let clone = builder.try_clone();/// assert!(clone.is_some());fmt_request_fields/// Check the request URL for a "username:password" type authority, and if/// found, remove it from the URL and return it.add_query_appendadd_query_append_sameadd_query_structadd_query_maptest_replace_headersnormalize_empty_querytry_clone_reusabletry_clone_no_bodyconvert_url_authority_into_basic_authtest_basic_auth_sensitive_headertest_bearer_auth_sensitive_headertest_explicit_sensitive_headerconvert_from_http_requestset_http_request_versionbuilder_split_reassemble/*
    use {body, Method};
    use super::Client;
    use header::{Host, Headers, ContentType};
    use std::collections::HashMap;
    use serde_urlencoded;
    use serde_json;

    #[test]
    fn basic_get_request() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let r = client.get(some_url).unwrap().build();

        assert_eq!(r.method, Method::Get);
        assert_eq!(r.url.as_str(), some_url);
    }

    #[test]
    fn basic_head_request() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let r = client.head(some_url).unwrap().build();

        assert_eq!(r.method, Method::Head);
        assert_eq!(r.url.as_str(), some_url);
    }

    #[test]
    fn basic_post_request() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let r = client.post(some_url).unwrap().build();

        assert_eq!(r.method, Method::Post);
        assert_eq!(r.url.as_str(), some_url);
    }

    #[test]
    fn basic_put_request() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let r = client.put(some_url).unwrap().build();

        assert_eq!(r.method, Method::Put);
        assert_eq!(r.url.as_str(), some_url);
    }

    #[test]
    fn basic_patch_request() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let r = client.patch(some_url).unwrap().build();

        assert_eq!(r.method, Method::Patch);
        assert_eq!(r.url.as_str(), some_url);
    }

    #[test]
    fn basic_delete_request() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let r = client.delete(some_url).unwrap().build();

        assert_eq!(r.method, Method::Delete);
        assert_eq!(r.url.as_str(), some_url);
    }

    #[test]
    fn add_header() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();

        let header = Host {
            hostname: "google.com".to_string(),
            port: None,
        };

        // Add a copy of the header to the request builder
        let r = r.header(header.clone()).build();

        // then check it was actually added
        assert_eq!(r.headers.get::<Host>(), Some(&header));
    }

    #[test]
    fn add_headers() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();

        let header = Host {
            hostname: "google.com".to_string(),
            port: None,
        };

        let mut headers = Headers::new();
        headers.set(header);

        // Add a copy of the headers to the request builder
        let r = r.headers(headers.clone()).build();

        // then make sure they were added correctly
        assert_eq!(r.headers, headers);
    }

    #[test]
    fn add_headers_multi() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();

        let header = Host {
            hostname: "google.com".to_string(),
            port: None,
        };

        let mut headers = Headers::new();
        headers.set(header);

        // Add a copy of the headers to the request builder
        let r = r.headers(headers.clone()).build();

        // then make sure they were added correctly
        assert_eq!(r.headers, headers);
    }

    #[test]
    fn add_body() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();

        let body = "Some interesting content";

        let r = r.body(body).build();

        let buf = body::read_to_string(r.body.unwrap()).unwrap();

        assert_eq!(buf, body);
    }

    #[test]
    fn add_form() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();

        let mut form_data = HashMap::new();
        form_data.insert("foo", "bar");

        let r = r.form(&form_data).unwrap().build();

        // Make sure the content type was set
        assert_eq!(r.headers.get::<ContentType>(),
                   Some(&ContentType::form_url_encoded()));

        let buf = body::read_to_string(r.body.unwrap()).unwrap();

        let body_should_be = serde_urlencoded::to_string(&form_data).unwrap();
        assert_eq!(buf, body_should_be);
    }

    #[test]
    fn add_json() {
        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();

        let mut json_data = HashMap::new();
        json_data.insert("foo", "bar");

        let r = r.json(&json_data).unwrap().build();

        // Make sure the content type was set
        assert_eq!(r.headers.get::<ContentType>(), Some(&ContentType::json()));

        let buf = body::read_to_string(r.body.unwrap()).unwrap();

        let body_should_be = serde_json::to_string(&json_data).unwrap();
        assert_eq!(buf, body_should_be);
    }

    #[test]
    fn add_json_fail() {
        use serde::{Serialize, Serializer};
        use serde::ser::Error;
        struct MyStruct;
        impl Serialize for MyStruct {
            fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer
                {
                    Err(S::Error::custom("nope"))
                }
        }

        let client = Client::new().unwrap();
        let some_url = "https://google.com/";
        let mut r = client.post(some_url).unwrap();
        let json_data = MyStruct{};
        assert!(r.json(&json_data).unwrap_err().is_serialization());
    }
    */// Boxed to save space (11 words to 1 word), and it's not accessed// frequently internally./// A Response to a submitted `Request`./// Get the `StatusCode` of this `Response`./// Get the HTTP `Version` of this `Response`./// Get the `Headers` of this `Response`./// Get a mutable reference to the `Headers` of this `Response`./// Get the content length of the response, if it is known./// This value does not directly represents the value of the `Content-Length`/// header, but rather the size of the response's body. To read the header's/// value, please use the [`Response::headers`] method instead./// Reasons it may not be known:/// - The response does not include a body (e.g. it responds to a `HEAD`///   request)./// - The response is gzipped and automatically decoded (thus changing the///   actual decoded length)./// Get the final `Url` of this `Response`./// Get the remote address used to get this `Response`./// Get the full response text./// This method decodes the response body with BOM sniffing/// and with malformed sequences replaced with the/// [`char::REPLACEMENT_CHARACTER`]./// Encoding is determined from the `charset` parameter of `Content-Type` header,/// and defaults to `utf-8` if not presented./// Note that the BOM is stripped from the returned String./// If the `charset` feature is disabled the method will only attempt to decode the/// response as UTF-8, regardless of the given `Content-Type`/// # async fn run() -> Result<(), Box<dyn std::error::Error>> {/// let content = reqwest::get("http://httpbin.org/range/26")///     .await?///     .text()/// println!("text: {content:?}");/// Try to deserialize the response body as JSON./// # extern crate reqwest;/// # use serde::Deserialize;/// // This `derive` requires the `serde` dependency./// struct Ip {///     origin: String,/// let ip = reqwest::get("http://httpbin.org/ip")///     .json::<Ip>()/// println!("ip: {}", ip.origin);/// # fn main() { }/// This method fails whenever the response body is not in JSON format,/// or it cannot be properly deserialized to target type `T`. For more/// details please see [`serde_json::from_reader`]./// [`serde_json::from_reader`]: https://docs.serde.rs/serde_json/fn.from_reader.html/// Get the full response body as `Bytes`./// let bytes = reqwest::get("http://httpbin.org/ip")///     .bytes()/// println!("bytes: {bytes:?}");/// Stream a chunk of the response body./// When the response body has been exhausted, this will return `None`./// let mut res = reqwest::get("https://hyper.rs").await?;/// while let Some(chunk) = res.chunk().await? {///     println!("Chunk: {chunk:?}");error_for_status/// Turn a response into an error if the server returned an error./// # use reqwest::Response;/// fn on_response(res: Response) {///     match res.error_for_status() {///         Ok(_res) => (),///             // asserting a 400 as an example///             // it could be any status between 400...599///             assert_eq!(///                 err.status(),///                 Some(reqwest::StatusCode::BAD_REQUEST)error_for_status_ref/// Turn a reference to a response into an error if the server returned an error./// fn on_response(res: &Response) {///     match res.error_for_status_ref() {// The Response's body is an implementation detail.// You no longer need to get a reference to it, there are async methods// on the `Response` itself.// This method is just used by the blocking API.// body methods// util methods/// A `Response` can be piped as the `Body` of another request.// I'm not sure this conversion is that useful... People should be encouraged// to use `http::Response`, not `reqwest::Response`./// A `Response` can be converted into a `http::Response`.// It's supposed to be the inverse of the conversion above.ResponseBuilderExttest_from_http_response/// Consumes the response and returns a future for a possible HTTP upgrade./// The body of a `Request`./// In most cases, this is not needed directly, as the/// [`RequestBuilder.body`][builder] method uses `Into<Body>`, which allows/// passing many things (like a string or vector of bytes)./// [builder]: ./struct.RequestBuilder.html#method.body/// Instantiate a `Body` from a reader./// While allowing for many types to be used, these bodies do not have/// a way to reset to the beginning and be reused. This means that when/// encountering a 307 or 308 status code, instead of repeating the/// request at the new location, the `Response` will be returned with/// the redirect status code set./// # use reqwest::blocking::Body;/// # fn run() -> Result<(), Box<dyn std::error::Error>> {/// let file = File::open("national_secrets.txt")?;/// let body = Body::new(file);/// If you have a set of bytes, like `String` or `Vec<u8>`, using the/// `From` implementations for `Body` will store the data in a manner/// it can be reused./// let s = "A stringy body";/// let body = Body::from(s);/// Create a `Body` from a `Read` where the size is known in advance/// but the data should not be fully loaded into memory. This will/// set the `Content-Length` header and stream from the `Read`./// let file = File::open("a_large_file.txt")?;/// let file_size = file.metadata()?.len();/// let body = Body::sized(file, file_size);/// Returns the body as a byte slice if the body is already buffered in/// memory. For streamed requests this method returns `None`./// Converts streamed requests to their buffered equivalent and/// returns a reference to the buffer. If the request is already/// buffered, this has no effect./// Be aware that for large requests this method is expensive/// and may cause your program to run out of memory.into_asyncDebugLengthsend_future// A `Future` that may do blocking read calls.// As a `Future`, this integrates easily with `wait::timeout`.// useful for tests, but not publicly exposedClientHandle/// A `Client` to make Requests with./// use reqwest::blocking::Client;/// # fn run() -> Result<(), reqwest::Error> {/// let client = Client::new();/// let resp = client.get("http://httpbin.org/").send()?;/// #   drop(resp);/// A `ClientBuilder` can be used to create a `Client` with  custom configuration./// let client = reqwest::blocking::Client::builder()///     .timeout(Duration::from_secs(10))/// This method fails if TLS backend cannot be initialized, or the resolver/// This method panics if called from within an async runtime. See docs on/// [`reqwest::blocking`][crate::blocking] for details./// let res = client.get("https://www.rust-lang.org").send()?;/// # fn build_client() -> Result<(), reqwest::Error> {/// headers.insert(header::AUTHORIZATION, header::HeaderValue::from_static("secret"));/// - When receiving a response, if it's headers contain a `Content-Encoding` value that///   equals to `gzip`, both values `Content-Encoding` and `Content-Length` are removed from the/// Set a `redirect::Policy` for this client./// To add a proxy exclusion list, use [Proxy::no_proxy()]/// Set a timeout for connect, read and write operations of a `Client`./// Newline codepoints (\r and \n) will be transformed to spaces when///     .build().unwrap();/// Bind to an interface by `SO_BINDTODEVICE`./// The current default is `None` (option disabled)./// This allows connecting to a server that has a self-signed/// certificate for example. This **does not** replace the existing/// trusted store./// # use std::io::Read;/// # fn build_client() -> Result<(), Box<dyn std::error::Error>> {/// // read a local binary DER encoded certificate/// let der = std::fs::read("my-cert.der")?;/// // create a certificate/// let cert = reqwest::Certificate::from_der(&der)?;///     .add_root_certificate(cert)/// # drop(client);/// Pass an `Arc` wrapping a trait object implementing `Resolve`./// This method panics if TLS backend cannot be initialized, or the resolver/// This method also panics if called from within an async runtime. See docs/// on [`reqwest::blocking`][crate::blocking] for details./// This method fails whenever supplied `Url` cannot be parsed./// request body before sending./// or redirect limit was exhausted.InnerClientHandleOneshotResponseThreadSenderKeepCoreThreadAliveevent_loop_panicked/// Shortcut method to quickly make a *blocking* `GET` request./// **NOTE**: This function creates a new internal `Client` on each call,/// and so should not be used if making many requests. Create a/// [`Client`](./struct.Client.html) instead./// let body = reqwest::blocking::get("https://www.rust-lang.org")?///     .text()?;/// This function fails if:/// - the native TLS backend cannot be initialized,/// - the supplied `Url` cannot be parsed,/// - there was an error while sending request,/// - a redirect loop was detected,/// - the redirect limit was exhausted, or/// - the total download time exceeds 30 seconds.//! A blocking Client API.//! The blocking `Client` will block the current thread to execute, instead//! of returning futures that need to be executed on a runtime.//! Conversely, the functionality in `reqwest::blocking` must *not* be executed//! within an async runtime, or it will panic when attempting to block. If//! calling directly from an async function, consider using an async//! [`reqwest::Client`][crate::Client] instead. If the immediate context is only//! synchronous, but a transitive caller is async, consider changing that caller//! to use [`tokio::task::spawn_blocking`] around the calls that need to block.//! # Optional//! This requires the optional `blocking` feature to be enabled.//! # Making a GET request//! For a single request, you can use the [`get`] shortcut method.//! # use reqwest::{Error, Response};//! # fn run() -> Result<(), Error> {//! let body = reqwest::blocking::get("https://www.rust-lang.org")?//!     .text()?;//! println!("body = {body:?}");//! Additionally, the blocking [`Response`] struct implements Rust's//! `Read` trait, so many useful standard library and third party crates will//! have convenience methods that take a `Response` anywhere `T: Read` is//! acceptable.//! **NOTE**: If you plan to perform multiple requests, it is best to create a//! [`Client`] and reuse it, taking advantage of keep-alive connection pooling.//! # Making POST requests (or setting request bodies)//! There are several ways you can set the body of a request. The basic one is//! by using the `body()` method of a [`RequestBuilder`]. This lets you set the//! exact raw bytes of what the body should be. It accepts various types,//! including `String`, `Vec<u8>`, and `File`. If you wish to pass a custom//! Reader, you can use the `reqwest::blocking::Body::new()` constructor.//! # use reqwest::Error;//! let client = reqwest::blocking::Client::new();//! let res = client.post("http://httpbin.org/post")//!     .body("the exact body that is sent")//!     .send()?;//! ## And More//! Most features available to the asynchronous `Client` are also available,//! on the blocking `Client`, see those docs for more.multipart/// A multipart/form-data request./// Creates a new Form without any content./// let form = reqwest::blocking::multipart::Form::new()/// # fn run() -> std::io::Result<()> {///     .file("key", "/path/to/file")?;/// Produce a reader over the multipart form data./// Adds a generic reader./// Does not set filename or mime.reader_with_length/// Adds a generic reader with known length.active_readernext_readerread_to_end_with_lengthread_to_end_with_header//! To send a `multipart/form-data` body, a [`Form`] is built up, adding//! fields or customized [`Part`]s, and then calling the//! [`multipart`][builder] method on the `RequestBuilder`.//! use reqwest::blocking::multipart;//! # fn run() -> Result<(), Box<dyn std::error::Error>> {//! let form = multipart::Form::new()//!     // Adding just a simple text field...//!     .text("username", "seanmonstar")//!     // And a file...//!     .file("photo", "/path/to/photo.png")?;//! // Customize all the details of a Part if needed...//! let bio = multipart::Part::text("hallo peeps")//!     .file_name("bio.txt")//!     .mime_str("text/plain")?;//! // Add the custom part to our form...//! let form = form.part("biography", bio);//! // And finally, send the form//! let resp = client//!     .post("http://localhost:8080/user")//!     .multipart(form)//! [builder]: ../struct.RequestBuilder.html#method.multipart/// Attempts to clone the `Request`./// None is returned if a body is which can not be cloned. This can be because the body is a/// use reqwest::header::USER_AGENT;/// let client = reqwest::blocking::Client::new();/// let res = client.get("https://www.rust-lang.org")///     .header(USER_AGENT, "foo")///     .send()?;/// Add a `Header` to this Request with ability to define if header_value is sensitive./// use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT, CONTENT_TYPE};/// # use std::fs;/// fn construct_headers() -> HeaderMap {///     let mut headers = HeaderMap::new();///     headers.insert(USER_AGENT, HeaderValue::from_static("reqwest"));///     headers.insert(CONTENT_TYPE, HeaderValue::from_static("image/png"));///     headers/// let file = fs::File::open("much_beauty.png")?;/// let res = client.post("http://httpbin.org/post")///     .headers(construct_headers())///     .body(file)///     .bearer_auth("token")/// Using a string:///     .body("from a &str!")/// Using a `File`:/// let file = std::fs::File::open("from_a_file.txt")?;/// Using arbitrary bytes:/// // from bytes!/// let bytes: Vec<u8> = vec![1, 10, 100];///     .body(bytes)/// let res = client.get("http://httpbin.org")///     .query(&[("lang", "rust")])/// Sets the body to the JSON serialization of the passed value, and/// also sets the `Content-Type: application/json` header./// map.insert("lang", "rust");///     .json(&map)/// Constructs the Request and sends it the target URL, returning a Response./// Attempts to clone the `RequestBuilder`./// With a static body/// Without a body/// let builder = client.get("http://httpbin.org/get");/// With a non-cloneable body/// let builder = client.get("http://httpbin.org/get")///     .body(reqwest::blocking::Body::new(std::io::empty()));/// assert!(clone.is_none());basic_get_requestbasic_head_requestbasic_post_requestbasic_put_requestbasic_patch_requestbasic_delete_requestadd_headeradd_headersadd_headers_multiadd_bodyadd_formadd_jsonadd_json_failtest_request_cloning_thread_handle/// Checking for general status class:/// # #[cfg(feature = "json")]/// let resp = reqwest::blocking::get("http://httpbin.org/get")?;/// if resp.status().is_success() {///     println!("success!");/// } else if resp.status().is_server_error() {///     println!("server error!");///     println!("Something else happened. Status: {:?}", resp.status());/// Checking for specific status codes:/// use reqwest::StatusCode;/// let resp = client.post("http://httpbin.org/post")///     .body("possibly too large")/// match resp.status() {///     StatusCode::OK => println!("success!"),///     StatusCode::PAYLOAD_TOO_LARGE => {///         println!("Request payload is too large!");///     s => println!("Received response status: {s:?}"),/// Saving an etag when caching a file:/// use reqwest::header::ETAG;/// let mut resp = client.get("http://httpbin.org/cache").send()?;///     if let Some(etag) = resp.headers().get(ETAG) {///         std::fs::write("etag", etag.as_bytes());///     let mut file = std::fs::File::create("file")?;///     resp.copy_to(&mut file)?;/// let resp = reqwest::blocking::get("http://httpbin.org/redirect/1")?;/// assert_eq!(resp.url().as_str(), "http://httpbin.org/get");/// println!("httpbin.org address: {:?}", resp.remote_addr());/// Try and deserialize the response body as JSON using `serde`./// let json: Ip = reqwest::blocking::get("http://httpbin.org/ip")?.json()?;/// let bytes = reqwest::blocking::get("http://httpbin.org/ip")?.bytes()?;/// Get the response text./// and with malformed sequences replaced with the [`char::REPLACEMENT_CHARACTER`]./// let content = reqwest::blocking::get("http://httpbin.org/range/26")?.text()?;/// Copy the response body into a writer./// This function internally uses [`std::io::copy`] and hence will continuously read data from/// the body and then write it into writer in a streaming fashion until EOF is met./// On success, the total number of bytes that were copied to `writer` is returned./// [`std::io::copy`]: https://doc.rust-lang.org/std/io/fn.copy.html/// let mut resp = reqwest::blocking::get("http://httpbin.org/range/5")?;/// let mut buf: Vec<u8> = vec![];/// resp.copy_to(&mut buf)?;/// assert_eq!(b"abcde", buf.as_slice());/// let res = reqwest::blocking::get("http://httpbin.org/status/400")?///     .error_for_status();/// if let Err(err) = res {///     assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));/// let res = reqwest::blocking::get("http://httpbin.org/status/400")?;/// let res = res.error_for_status_ref();WaitedThreadWakerRequestConfigValue/// This trait is empty and is only used to associate a configuration key type with its/// corresponding value type./// RequestConfig carries a request-scoped configuration value.fmt_as_field/// format request config value as struct field./// We provide this API directly to avoid leak internal value to callers.'client'request/// Retrieve the value from the request-scoped configuration./// If the request specifies a value, use that value; otherwise, attempt to retrieve it from the current instance (typically a client instance)./// Retrieve the value from the request's Extensions./// Retrieve the mutable value from the request's Extensions.//! The `config` module provides a generic mechanism for loading and managing//! request-scoped configuration.//! # Design Overview//! This module is centered around two abstractions://! - The [`RequestConfigValue`] trait, used to associate a config key type with its value type.//! - The [`RequestConfig`] struct, which wraps an optional value of the type linked via [`RequestConfigValue`].//! Under the hood, the [`RequestConfig`] struct holds a single value for the associated config type.//! This value can be conveniently accessed, inserted, or mutated using [`http::Extensions`],//! enabling type-safe configuration storage and retrieval on a per-request basis.//! The key design benefit is the ability to store multiple config types—potentially even with the same//! value type (e.g., [`Duration`])—without code duplication or ambiguity. By leveraging trait association,//! each config key is distinct at the type level, while code for storage and access remains totally generic.//! Implement [`RequestConfigValue`] for any marker type you wish to use as a config key,//! specifying the associated value type. Then use [`RequestConfig<T>`] in [`Extensions`]//! to set or retrieve config values for each key type in a uniform way.// The following sections are all configuration types// provided by reqwets.// To add a new config:// 1. create a new struct for the config key like `RequestTimeout`.// 2. implement `RequestConfigValue` for the struct, the `Value` is the config value's type.MapRequestLayerTimeoutLayerBoxCloneSyncServiceServiceBuildernative_tls_connNativeTlsConnrustls_tls_connRustlsTlsConncast_to_internal_errorInterceptedConnectorService// base service, with or without an embedded timeoutWithLayers// at least one custom layer along with maybe an outer timeout layer// from `builder.connect_timeout()`new_default_tlsfrom_built_default_tlsnew_rustls_tlsset_verboseset_socks_resolverset_unix_socketsimple_timeout/// When there is a single timeout layer and no other layers,/// we embed it directly inside our base Service::call()./// This lets us avoid an extra `Box::pin` indirection layer/// since `tokio::time::Timeout` is `Unpin`/// If set, this always takes priority over TCP.DefaultTlstls_proxyRustlsTlsget_http_connectorconnect_socksconnect_with_maybe_proxyconnect_local_transport/// Connect over Unix Domain Socket (or Windows?).connect_via_proxywith_timeoutTlsInfoTlsInfoFactoryAsyncConnAsyncConnWithInfoBoxConnr" Note: the `is_proxy` member means *is plain text HTTP proxy*."r" This tells hyper whether the URI should be written in"r" * origin-form (`GET /just/a/path HTTP/1.1`), when `is_proxy == false`, or"r" * absolute-form (`GET http://foo.bar/and/a/path HTTP/1.1`), otherwise."is_proxyreqwest_uds_path/// A provider for Unix Domain Socket paths./// This trait is sealed. This allows us expand the support in the future/// by controlling who can implement the trait./// It's available in the docs to see what type may be passed in.// Some sealed things for UDSDnsResolveSocksProxyErrorSocksNoHostInUrlSocksLocalResolveSocksConnectVerbosenwrittenVectored// ===== TcpStream =====// ===== UnixStream =====set_cookies/// Store a set of Set-Cookie header values received from `url`cookies/// Get any Cookie values in the store for `url`CookieStore/// Actions for a persistent cookie store providing session support.cookie_crate/// A single HTTP cookie.cookie_storeJar/// A good default `CookieStore` implementation./// This is the implementation used when simply calling `cookie_store(true)`./// This type is exposed to allow creating one and filling it with some/// existing cookies more easily, before creating a `Client`./// For more advanced scenarios, such as needing to serialize the store or/// manipulate it between requests, you may refer to the/// [reqwest_cookie_store crate](https://crates.io/crates/reqwest_cookie_store).CookieParseError/// The name of the cookie./// The value of the cookie.http_only/// Returns true if the 'HttpOnly' directive is enabled.secure/// Returns true if the 'Secure' directive is enabled.same_site_lax/// Returns true if  'SameSite' directive is 'Lax'.same_site_strict/// Returns true if  'SameSite' directive is 'Strict'./// Returns the path directive of the cookie, if set./// Returns the domain directive of the cookie, if set.max_age/// Get the Max-Age information./// The cookie expiration time.extract_response_cookie_headersextract_response_cookies/// Error representing a parse failure of a 'Set-Cookie' header.add_cookie_str/// Add a cookie to this jar./// use reqwest::{cookie::Jar, Url};/// let cookie = "foo=bar; Domain=yolo.local";/// let url = "https://yolo.local".parse::<Url>().unwrap();/// let jar = Jar::default();/// jar.add_cookie_str(cookie, &url);/// // and now add to a `ClientBuilder`?CookieService/// A [`Service`] that adds cookie support to a lower-level [`Service`]./// Create a new [`CookieService`].//! HTTP Cookies// ===== impl Cookie =====// ===== impl Jar =====HyperGaiResolverhickory_resolverLookupIpStrategylookup_ipLookupIpIntoIterResolveErrorTokioResolver/// Since we might not have been called in the context of a/// Tokio Runtime in initialization, so we must delay the actual/// construction of the resolver.HickoryDnsResolver/// Wrapper around an `AsyncResolver`, which implements the `Resolve` trait.HickoryDnsSystemConfErrornew_resolver/// Create a new resolver with the default configuration,/// which reads from `/etc/resolve.conf`. The options are/// overridden to look up for both IPv4 and IPv6 addresses/// to work with "happy eyeballs" algorithm.//! DNS resolution via the [hickory-resolver](https://github.com/hickory-dns/hickory-dns) crate//! DNS resolutionHyperName/// Alias for an `Iterator` trait object over `SocketAddr`./// Alias for the `Future` type returned by a DNS resolver./// Performs DNS resolution on a `Name`./// The return type is a future containing an iterator of `SocketAddr`./// It differs from `tower_service::Service<Name>` in several ways:///  * It is assumed that `resolve` will always be ready to poll.///  * It does not need a mutable reference to `self`.///  * Since trait objects cannot make use of associated types, it requires///    wrapping the returned `Future` and its contained `Iterator` with `Box`./// Explicitly specified port in the URL will override any port in the resolved `SocketAddr`s./// Otherwise, port `0` will be replaced by the conventional port for the given scheme (e.g. 80 for http)./// Trait for customizing DNS resolution in reqwest./// A name that must be resolved to addresses.into_resolve/// A more general trait implemented for types implementing `Resolve`./// Unnameable, only exported to aid seeing what implements this./// View the name as a string.http_resolve/// Resolve an HTTP host and port, not just a domain name./// This does the same thing that hyper-util's HttpConnector does, before/// calling out to its underlying DNS resolver._ext/// A `Result` alias where the `Err` case is `reqwest::Error`./// The Errors that may occur when processing a `Request`./// Note: Errors may include the full URL used to make the `Request`. If the URL/// contains sensitive information (e.g. an API key as a query parameter), be/// sure to remove it ([`without_url`](Error::without_url))/// Returns a possible URL related to this error./// // displays last stop of a redirect loop/// let response = reqwest::get("http://site.with.redirect.loop").await;/// if let Err(e) = response {///     if e.is_redirect() {///         if let Some(final_stop) = e.url() {///             println!("redirect loop at {final_stop}");/// Returns a mutable reference to the URL related to this error/// This is useful if you need to remove sensitive information from the URL/// (e.g. an API key in the query), but do not want to remove the URL/// entirely.with_url/// Add a url related to this error (overwriting any existing)if_no_urlwithout_url/// Strip the related url from this error (if, for example, it contains/// sensitive information)is_builder/// Returns true if the error is from a type Builder.is_redirect/// Returns true if the error is from a `RedirectPolicy`.is_status/// Returns true if the error is from `Response::error_for_status`./// Returns true if the error is related to a timeout.is_request/// Returns true if the error is related to the request/// Returns true if the error is related to connectis_body/// Returns true if the error is related to the request or response bodyis_decode/// Returns true if the error is related to decoding the response's body/// Returns the status code, if the error was generated from a response.into_io/// Converts from external types to reqwest's/// internal equivalents./// Currently only is used for `tower::timeout::error::Elapsed`.status_codeurl_bad_schemeurl_invalid_uriif_wasmdecode_ioBadSchemetest_source_chainmem_size_ofroundtrip_io_errorfrom_unknown_io_error// io::Error helpers// internal Error "sources"IntoUrlSealed/// A trait to try to convert some type into a `Url`./// This trait is "sealed", such that only types within reqwest can/// implement it.// Besides parsing as a valid `Url`, the `Url` must be a valid// `http::Uri`, in that it makes sense to use in a network request.if_hyperinto_url_file_schemeinto_url_blob_scheme// Ignore `unused_crate_dependencies` warnings.// Used in many features that they're not worth making it optional.// universal mods// TODO: remove `if_hyper` if wasm has been migrated to new config system./// Shortcut method to quickly make a `GET` request./// See also the methods on the [`reqwest::Response`](./struct.Response.html)/// # async fn run() -> Result<(), reqwest::Error> {/// let body = reqwest::get("https://www.rust-lang.org").await?///     .text().await?;/// - native TLS backend cannot be initialized/// - supplied `Url` cannot be parsed/// - there was an error while sending request/// - redirect limit was exhausted_assert_impls//! # reqwest//! The `reqwest` crate provides a convenient, higher-level HTTP//! [`Client`][client].//! It handles many of the things that most people just expect an HTTP client//! to do for them.//! - Async and [blocking] Clients//! - Plain bodies, [JSON](#json), [urlencoded](#forms), [multipart]//! - Customizable [redirect policy](#redirect-policies)//! - HTTP [Proxies](#proxies)//! - Uses [TLS](#tls) by default//! - Cookies//! The [`reqwest::Client`][client] is asynchronous (requiring Tokio). For//! applications wishing  to only make a few HTTP requests, the//! [`reqwest::blocking`](blocking) API may be more convenient.//! Additional learning resources include://! - [The Rust Cookbook](https://rust-lang-nursery.github.io/rust-cookbook/web/clients.html)//! - [reqwest Repository Examples](https://github.com/seanmonstar/reqwest/tree/master/examples)//! ## Commercial Support//! For private advice, support, reviews, access to the maintainer, and the//! like, reach out for [commercial support][sponsor].//! ## Making a GET request//! For a single request, you can use the [`get`][get] shortcut method.//! # async fn run() -> Result<(), reqwest::Error> {//! let body = reqwest::get("https://www.rust-lang.org")//!     .await?//!     .text()//!     .await?;//! [`Client`][client] and reuse it, taking advantage of keep-alive connection//! pooling.//! ## Making POST requests (or setting request bodies)//! by using the `body()` method of a [`RequestBuilder`][builder]. This lets you set the//! including `String` and `Vec<u8>`. If you wish to pass a custom//! type, you can use the `reqwest::Body` constructors.//! # async fn run() -> Result<(), Error> {//! let client = reqwest::Client::new();//!     .send()//! ### Forms//! It's very common to want to send form data in a request body. This can be//! done with any type that can be serialized into form data.//! This can be an array of tuples, or a `HashMap`, or a custom type that//! implements [`Serialize`][serde].//! // This will POST a body of `foo=bar&baz=quux`//! let params = [("foo", "bar"), ("baz", "quux")];//!     .form(&params)//! ### JSON//! There is also a `json` method helper on the [`RequestBuilder`][builder] that works in//! a similar fashion the `form` method. It can take any value that can be//! serialized into JSON. The feature `json` is required.//! # use std::collections::HashMap;//! # #[cfg(feature = "json")]//! // This will POST a body of `{"lang":"rust","body":"json"}`//! let mut map = HashMap::new();//! map.insert("lang", "rust");//! map.insert("body", "json");//!     .json(&map)//! ## Redirect Policies//! By default, a `Client` will automatically handle HTTP redirects, having a//! maximum redirect chain of 10 hops. To customize this behavior, a//! [`redirect::Policy`][redirect] can be used with a `ClientBuilder`.//! ## Cookies//! The automatic storing and sending of session cookies can be enabled with//! the [`cookie_store`][ClientBuilder::cookie_store] method on `ClientBuilder`.//! ## Proxies//! **NOTE**: System proxies are enabled by default.//! System proxies look in environment variables to set HTTP or HTTPS proxies.//! `HTTP_PROXY` or `http_proxy` provide HTTP proxies for HTTP connections while//! `HTTPS_PROXY` or `https_proxy` provide HTTPS proxies for HTTPS connections.//! `ALL_PROXY` or `all_proxy` provide proxies for both HTTP and HTTPS connections.//! If both the all proxy and HTTP or HTTPS proxy variables are set the more specific//! HTTP or HTTPS proxies take precedence.//! These can be overwritten by adding a [`Proxy`] to `ClientBuilder`//! i.e. `let proxy = reqwest::Proxy::http("https://secure.example")?;`//! or disabled by calling `ClientBuilder::no_proxy()`.//! `socks` feature is required if you have configured socks proxy like this://! ```bash//! export https_proxy=socks5://127.0.0.1:1086//! ## TLS//! A `Client` will use transport layer security (TLS) by default to connect to//! HTTPS destinations.//! - Additional server certificates can be configured on a `ClientBuilder`//!   with the [`Certificate`] type.//! - Client certificates can be added to a `ClientBuilder` with the//!   [`Identity`] type.//! - Various parts of TLS can also be configured or even disabled on the//!   `ClientBuilder`.//! See more details in the [`tls`] module.//! ## WASM//! The Client implementation automatically switches to the WASM one when the target_arch is wasm32,//! the usage is basically the same as the async api. Some of the features are disabled in wasm//! : [`tls`], [`cookie`], [`blocking`], as well as various `ClientBuilder` methods such as `timeout()` and `connector_layer()`.//! TLS and cookies are provided through the browser environment, so reqwest can issue TLS requests with cookies,//! but has limited configuration.//! The following are a list of [Cargo features][cargo-features] that can be//! enabled or disabled://! - **http2** *(enabled by default)*: Enables HTTP/2 support.//! - **default-tls** *(enabled by default)*: Provides TLS support to connect//!   over HTTPS.//! - **native-tls**: Enables TLS functionality provided by `native-tls`.//! - **native-tls-vendored**: Enables the `vendored` feature of `native-tls`.//! - **native-tls-alpn**: Enables the `alpn` feature of `native-tls`.//! - **rustls-tls**: Enables TLS functionality provided by `rustls`.//!   Equivalent to `rustls-tls-webpki-roots`.//! - **rustls-tls-manual-roots**: Enables TLS functionality provided by `rustls`,//!   without setting any root certificates. Roots have to be specified manually.//! - **rustls-tls-webpki-roots**: Enables TLS functionality provided by `rustls`,//!   while using root certificates from the `webpki-roots` crate.//! - **rustls-tls-native-roots**: Enables TLS functionality provided by `rustls`,//!   while using root certificates from the `rustls-native-certs` crate.//! - **blocking**: Provides the [blocking][] client API.//! - **charset** *(enabled by default)*: Improved support for decoding text.//! - **cookies**: Provides cookie session support.//! - **gzip**: Provides response body gzip decompression.//! - **brotli**: Provides response body brotli decompression.//! - **zstd**: Provides response body zstd decompression.//! - **deflate**: Provides response body deflate decompression.//! - **json**: Provides serialization and deserialization for JSON bodies.//! - **multipart**: Provides functionality for multipart forms.//! - **stream**: Adds support for `futures::Stream`.//! - **socks**: Provides SOCKS5 proxy support.//! - **hickory-dns**: Enables a hickory-dns async resolver instead of default//!   threadpool using `getaddrinfo`.//! - **system-proxy** *(enabled by default)*: Use Windows and macOS system//!   proxy settings automatically.//! Some feature flags require additional opt-in by the application, by setting//! a `reqwest_unstable` flag.//! - **http3** *(unstable)*: Enables support for sending HTTP/3 requests.//! These features are unstable, and experimental. Details about them may be//! changed in patch releases.//! You can pass such a flag to the compiler via `.cargo/config`, or//! environment variables, such as://! RUSTFLAGS="--cfg reqwest_unstable" cargo build//! ## Sponsors//! Support this project by becoming a [sponsor][].//! [blocking]: ./blocking/index.html//! [client]: ./struct.Client.html//! [response]: ./struct.Response.html//! [get]: ./fn.get.html//! [builder]: ./struct.RequestBuilder.html//! [serde]: http://serde.rs//! [redirect]: crate::redirect//! [Proxy]: ./struct.Proxy.html//! [cargo-features]: https://doc.rust-lang.org/stable/cargo/reference/manifest.html#the-features-section//! [sponsor]: https://seanmonstar.com/sponsor/// Configuration of a proxy that a `Client` should pass requests to./// A `Proxy` has a couple pieces to it:/// - a URL of how to talk to the proxy/// - rules on what `Client` requests should be directed to the proxy/// For instance, let's look at `Proxy::http`:/// let proxy = reqwest::Proxy::http("https://secure.example")?;/// This proxy will intercept all HTTP requests, and make use of the proxy/// at `https://secure.example`. A request to `http://hyper.rs` will talk/// to your proxy. A request to `https://hyper.rs` will not./// Multiple `Proxy` rules can be configured for a `Client`. The `Client` will/// check each `Proxy` in the order it was added. This could mean that a/// `Proxy` added first with eager intercept rules, such as `Proxy::all`,/// would prevent a `Proxy` later in the list from ever working, so take care./// By enabling the `"socks"` feature it is possible to use a socks proxy:/// let proxy = reqwest::Proxy::http("socks5://192.168.1.1:9000")?;/// A configuration for filtering out requests that shouldn't be proxiedMatcher_maybe_has_http_authmaybe_has_http_custom_headers/// This is because of `reqwest::Proxy`'s design which allows configuring/// an explicit auth, besides what might have been in the URL (or Custom)./// Our own type, wrapping an `Intercept`, since we may have a few additional/// pieces attached thanks to `reqwest`s extra proxy configuration.into_proxyIntoProxy/// Trait used for converting into a proxy scheme. This trait supports/// parsing from a URL-like type, whilst also supporting proxy schemes/// built directly using the factory methods._implied_bounds// These bounds are accidentally leaked by the blanket impl of IntoProxy// for all types that implement IntoUrl. So, this function exists to detect// if we were to break those bounds for a user./// Proxy all HTTP traffic to the passed URL.///     .proxy(reqwest::Proxy::http("https://my.prox")?)/// Proxy all HTTPS traffic to the passed URL.///     .proxy(reqwest::Proxy::https("https://example.prox:4545")?)/// Proxy **all** traffic to the passed URL./// "All" refers to `https` and `http` URLs. Other schemes are not/// recognized by reqwest.///     .proxy(reqwest::Proxy::all("http://pro.xy")?)/// Provide a custom function to determine what traffic to proxy to where./// let target = reqwest::Url::parse("https://my.prox")?;///     .proxy(reqwest::Proxy::custom(move |url| {///         if url.host_str() == Some("hyper.rs") {///             Some(target.clone())///     }))/// Set the `Proxy-Authorization` header using Basic auth./// let proxy = reqwest::Proxy::https("http://localhost:1234")?///     .basic_auth("Aladdin", "open sesame");custom_http_auth/// Set the `Proxy-Authorization` header to a specified value./// # use reqwest::header::*;///     .custom_http_auth(HeaderValue::from_static("justletmeinalreadyplease"));/// Adds a Custom Headers to Proxy/// Adds custom headers to this Proxy/// headers.insert(USER_AGENT, "reqwest".parse().unwrap());///     .headers(headers);/// Adds a `No Proxy` exclusion list to this Proxy///     .no_proxy(reqwest::NoProxy::from_string("direct.tld, sub.direct2.tld"));into_matcher/*
    pub(crate) fn maybe_has_http_auth(&self) -> bool {
        match &self.intercept {
            Intercept::All(p) | Intercept::Http(p) => p.maybe_http_auth().is_some(),
            // Custom *may* match 'http', so assume so.
            Intercept::Custom(_) => true,
            Intercept::System(system) => system
                .get("http")
                .and_then(|s| s.maybe_http_auth())
                .is_some(),
            Intercept::Https(_) => false,
        }
    }

    pub(crate) fn http_basic_auth<D: Dst>(&self, uri: &D) -> Option<HeaderValue> {
        match &self.intercept {
            Intercept::All(p) | Intercept::Http(p) => p.maybe_http_auth().cloned(),
            Intercept::System(system) => system
                .get("http")
                .and_then(|s| s.maybe_http_auth().cloned()),
            Intercept::Custom(custom) => {
                custom.call(uri).and_then(|s| s.maybe_http_auth().cloned())
            }
            Intercept::Https(_) => None,
        }
    }
    */cache_maybe_has_http_authcache_maybe_has_http_custom_headers/// Returns a new no-proxy configuration based on environment variables (or `None` if no variables are set)/// see [self::NoProxy::from_string()] for the string format/// For example, if `"NO_PROXY=google.com, 192.168.1.0/24"` was set, all the following would match/// Return whether this matcher might provide HTTP (not s) auth./// This is very specific. If this proxy needs auth to be part of a Forward/// request (instead of a tunnel), this should return true./// If it's not sure, this should return true./// This is meant as a hint to allow skipping a more expensive check/// (calling `intercept()`) if it will never need auth when Forwarding.http_non_tunnel_basic_authhttp_non_tunnel_custom_headersurl_authintercepted_uritest_httptest_httpstest_alltest_customtest_standard_with_custom_auth_headertest_custom_with_custom_auth_headertest_maybe_has_http_authtest_socks_proxy_default_port// # Internals// This module is a couple pieces:// - The public builder API// - The internal built types that our Connector knows how to use.// The user creates a builder (`reqwest::Proxy`), and configures any extras.// Once that type is passed to the `ClientBuilder`, we convert it into the// built matcher types, making use of `hyper-util`'s matchers.// ===== Internal =====/*
impl ProxyScheme {
    fn maybe_http_auth(&self) -> Option<&HeaderValue> {
        match self {
            ProxyScheme::Http { auth, .. } | ProxyScheme::Https { auth, .. } => auth.as_ref(),
            #[cfg(feature = "socks")]
            _ => None,
        }
    }

    fn maybe_http_custom_headers(&self) -> Option<&HeaderMap> {
        match self {
            ProxyScheme::Http { misc, .. } | ProxyScheme::Https { misc, .. } => misc.as_ref(),
            #[cfg(feature = "socks")]
            _ => None,
        }
    }
}
*//*
impl ProxyScheme {
    /// Use a username and password when connecting to the proxy server
    fn with_basic_auth<T: Into<String>, U: Into<String>>(
        mut self,
        username: T,
        password: U,
    ) -> Self {
        self.set_basic_auth(username, password);
        self
    }

    fn set_basic_auth<T: Into<String>, U: Into<String>>(&mut self, username: T, password: U) {
        match *self {
            ProxyScheme::Http { ref mut auth, .. } => {
                let header = encode_basic_auth(&username.into(), &password.into());
                *auth = Some(header);
            }
            ProxyScheme::Https { ref mut auth, .. } => {
                let header = encode_basic_auth(&username.into(), &password.into());
                *auth = Some(header);
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks4 { .. } => {
                panic!("Socks4 is not supported for this method")
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks5 { ref mut auth, .. } => {
                *auth = Some((username.into(), password.into()));
            }
        }
    }

    fn set_custom_http_auth(&mut self, header_value: HeaderValue) {
        match *self {
            ProxyScheme::Http { ref mut auth, .. } => {
                *auth = Some(header_value);
            }
            ProxyScheme::Https { ref mut auth, .. } => {
                *auth = Some(header_value);
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks4 { .. } => {
                panic!("Socks4 is not supported for this method")
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks5 { .. } => {
                panic!("Socks5 is not supported for this method")
            }
        }
    }

    fn set_custom_headers(&mut self, headers: HeaderMap) {
        match *self {
            ProxyScheme::Http { ref mut misc, .. } => {
                misc.get_or_insert_with(HeaderMap::new).extend(headers)
            }
            ProxyScheme::Https { ref mut misc, .. } => {
                misc.get_or_insert_with(HeaderMap::new).extend(headers)
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks4 { .. } => {
                panic!("Socks4 is not supported for this method")
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks5 { .. } => {
                panic!("Socks5 is not supported for this method")
            }
        }
    }

    fn if_no_auth(mut self, update: &Option<HeaderValue>) -> Self {
        match self {
            ProxyScheme::Http { ref mut auth, .. } => {
                if auth.is_none() {
                    *auth = update.clone();
                }
            }
            ProxyScheme::Https { ref mut auth, .. } => {
                if auth.is_none() {
                    *auth = update.clone();
                }
            }
            #[cfg(feature = "socks")]
            ProxyScheme::Socks4 { .. } => {}
            #[cfg(feature = "socks")]
            ProxyScheme::Socks5 { .. } => {}
        }

        self
    }

    /// Convert a URL into a proxy scheme
    ///
    /// Supported schemes: HTTP, HTTPS, (SOCKS4, SOCKS5, SOCKS5H if `socks` feature is enabled).
    // Private for now...
    fn parse(url: Url) -> crate::Result<Self> {
        use url::Position;

        // Resolve URL to a host and port
        #[cfg(feature = "socks")]
        let to_addr = || {
            let addrs = url
                .socket_addrs(|| match url.scheme() {
                    "socks4" | "socks4a" | "socks5" | "socks5h" => Some(1080),
                    _ => None,
                })
                .map_err(crate::error::builder)?;
            addrs
                .into_iter()
                .next()
                .ok_or_else(|| crate::error::builder("unknown proxy scheme"))
        };

        let mut scheme = match url.scheme() {
            "http" => Self::http(&url[Position::BeforeHost..Position::AfterPort])?,
            "https" => Self::https(&url[Position::BeforeHost..Position::AfterPort])?,
            #[cfg(feature = "socks")]
            "socks4" => Self::socks4(to_addr()?)?,
            #[cfg(feature = "socks")]
            "socks4a" => Self::socks4a(to_addr()?)?,
            #[cfg(feature = "socks")]
            "socks5" => Self::socks5(to_addr()?)?,
            #[cfg(feature = "socks")]
            "socks5h" => Self::socks5h(to_addr()?)?,
            _ => return Err(crate::error::builder("unknown proxy scheme")),
        };

        if let Some(pwd) = url.password() {
            let decoded_username = percent_decode(url.username().as_bytes()).decode_utf8_lossy();
            let decoded_password = percent_decode(pwd.as_bytes()).decode_utf8_lossy();
            scheme = scheme.with_basic_auth(decoded_username, decoded_password);
        }

        Ok(scheme)
    }
}
*/TowerActionAttemptTowerAttemptTowerPolicyPolicyKind/// A type that controls the policy on how to handle the following of redirects./// The default value will catch redirect loops, and has a maximum of 10/// redirects it will follow in a chain before returning an error./// - `limited` can be used have the same as the default behavior, but adjust///   the allowed maximum redirect hops in a chain./// - `none` can be used to disable all redirect behavior./// - `custom` can be used to create a customized policy./// A type that holds information on the next request and previous requests/// in redirect chain.ActionKind/// An action to perform when a redirect status code is found./// Create a `Policy` with a maximum number of redirects./// An `Error` will be returned if the max is reached./// Create a `Policy` that does not follow any redirect./// Create a custom `Policy` using the passed function./// The default `Policy` handles a maximum loop/// chain, but the custom variant does not do that for you automatically./// The custom policy should have some way of handling those./// Information on the next request and previous requests can be found/// on the [`Attempt`] argument passed to the closure./// Actions can be conveniently created from methods on the/// [`Attempt`]./// # use reqwest::{Error, redirect};/// let custom = redirect::Policy::custom(|attempt| {///     if attempt.previous().len() > 5 {///         attempt.error("too many redirects")///     } else if attempt.url().host_str() == Some("example.domain") {///         // prevent redirects to 'example.domain'///         attempt.stop()///         attempt.follow()///     .redirect(custom)/// [`Attempt`]: struct.Attempt.html/// Apply this policy to a given [`Attempt`] to produce a [`Action`]./// This method can be used together with `Policy::custom()`/// to construct one `Policy` that wraps another.///     eprintln!("{}, Location: {:?}", attempt.status(), attempt.url());///     redirect::Policy::default().redirect(attempt)/// Get the type of redirect./// Get the next URL to redirect to./// Get the list of previous URLs that have already been requested in this chain.follow/// Returns an action meaning reqwest should follow the next URL./// Returns an action meaning reqwest should not follow the next URL./// The 30x response will be returned as the `Ok` result./// Returns an action failing the redirect with an error./// The `Error` will be returned for the result of the sent request.Followremove_sensitive_headersTooManyRedirectswith_refererwith_https_onlymake_refereron_requestclone_body// This is must implemented to make 307 and 308 redirects worktest_redirect_policy_limittest_redirect_policy_limit_to_0test_redirect_policy_customtest_remove_sensitive_headers//! Redirect Handling//! `redirect::Policy` can be used with a `ClientBuilder`.// pub(crate)ResponseUrl/// A builder method for the `http::response::Builder` type that allows the user to add a `Url`/// to the `http::Response`/// Extension trait for http::response::Builder objects/// Allows the user to add a `Url` to the http::Responsetest_response_builder_extbudgetBudgetTpsBudget//backoff: Backoff,classifierClassifiermax_retries_per_request/// Builder to configure retries/// Construct with [`for_host()`].retry_cnt/// The internal type that we convert the builder into, that implements/// tower::retry::Policy privately.for_host/// Create a retry builder with a request scope./// To provide a scope that isn't a closure, use the more general/// [`Builder::scoped()`]./// Create a retry policy that will never retry any request./// This is useful for disabling the `Client`s default behavior of retrying/// protocol nacks./// Create a scoped retry policy./// For a more convenient constructor, see [`for_host()`].no_budget/// Set no retry budget./// Sets that no budget will be enforced. This could also be considered/// to be an infinite budget./// This is NOT recommended. Disabling the budget can make your system more/// susceptible to retry storms.max_extra_load/// Sets the max extra load the budget will allow./// Think of the amount of requests your client generates, and how much/// load that puts on the server. This option configures as a percentage/// how much extra load is allowed via retries./// For example, if you send 1,000 requests per second, setting a maximum/// extra load value of `0.3` would allow 300 more requests per second/// in retries. A value of `2.5` would allow 2,500 more requests./// The `extra_percent` value must be within reasonable values for a/// percentage. This method will panic if it is less than `0.0`, or greater/// than `1000.0`./// Set the max retries allowed per request./// For each logical (initial) request, only retry up to `max` times./// This value is used in combination with a token budget that is applied/// to all requests. Even if the budget would allow more requests, this/// limit will prevent. Likewise, the budget may prevent retrying up to/// `max` times. This setting prevents a single request from consuming/// the entire budget./// Default is currently 2 retries.classify_fnReqRep/// Provide a classifier to determine if a request should be retried./// # fn with_builder(builder: reqwest::retry::Builder) -> reqwest::retry::Builder {/// builder.classify_fn(|req_rep| {///     match (req_rep.method(), req_rep.status()) {///         (&http::Method::GET, Some(http::StatusCode::SERVICE_UNAVAILABLE)) => {///             req_rep.retryable()///         _ => req_rep.success()Classifyinto_policy// pub fn max_replay_body// TODO? backoff futures...clone_requestis_retryable_errorapplies_toScopeFnUnscoped// I think scopes likely make the most sense being to hosts.// If that's the case, then it should probably be easiest to check for// the host. Perhaps also considering the ability to add more things// to scope off in the future...// For Future Whoever: making a blanket impl for any closure sounds nice,// but it causes inference issues at the call site. Every closure would// need to include `: ReqRep` in the arguments.// An alternative is to make things like `ScopeFn`. Slightly more annoying,// but also more forwards-compatible. :shrug:// sealed types and traits on purpose while exploring design spaceClassifyFn// An alternative is to make things like `ClassifyFn`. Slightly more// annoying, but also more forwards-compatible. :shrug:retryableis_protocol_nackProtocolNacks//! Retry requests//! A `Client` has the ability to retry requests, by sending additional copies//! to the server if a response is considered retryable.//! The [`Builder`] makes it easier to configure what requests to retry, along//! with including best practices by default, such as a retry budget.//! # Defaults//! The default retry behavior of a `Client` is to only retry requests where an//! error or low-level protocol NACK is encountered that is known to be safe to//! retry. Note however that providing a specific retry policy will override//! the default, and you will need to explicitly include that behavior.//! All policies default to including a retry budget that permits 20% extra//! requests to be sent.//! # Scoped//! A client's retry policy is scoped. That means that the policy doesn't//! apply to all requests, but only those within a user-defined scope.//! Since all policies include a budget by default, it doesn't make sense to//! apply it on _all_ requests. Rather, the retry history applied by a budget//! should likely only be applied to the same host.//! # Classifiers//! A retry policy needs to be configured with a classifier that determines//! if a request should be retried. Knowledge of the destination server's//! behavior is required to make a safe classifier. **Requests should not be//! retried** if the server cannot safely handle the same request twice, or if//! it causes side effects.//! Some common properties to check include if the request method is//! idempotent, or if the response status code indicates a transient error.//struct Backoff;// ===== internal ======HandshakeSignatureValidServerCertVerifiedWebPkiSupportedAlgorithmsParsedCertificateDigitallySignedStructTLSErrorPemObjectUnixTime/// Represents a X509 certificate revocation list./// Represents a server X509 certificate.ClientCert/// Represents a private key and X509 cert as a client certificate.Pkcs8certs/// Create a `Certificate` from a binary DER encoded certificate/// # fn cert() -> Result<(), Box<dyn std::error::Error>> {/// File::open("my_cert.der")?///     .read_to_end(&mut buf)?;/// let cert = reqwest::Certificate::from_der(&buf)?;/// # drop(cert);/// Create a `Certificate` from a PEM encoded certificate/// File::open("my_cert.pem")?/// let cert = reqwest::Certificate::from_pem(&buf)?;from_pem_bundle/// Create a collection of `Certificate`s from a PEM encoded certificate bundle./// Example byte sources may be `.crt`, `.cer` or `.pem` files./// File::open("ca-bundle.crt")?/// let certs = reqwest::Certificate::from_pem_bundle(&buf)?;/// # drop(certs);add_to_native_tlsadd_to_rustlsread_pem_certsfrom_pkcs12_der/// certificates that allow clients to build a chain to a trusted root./// The chain certificates should be in order from the leaf certificate towards the root./// # fn pkcs12() -> Result<(), Box<dyn std::error::Error>> {/// File::open("my-ident.pfx")?/// let pkcs12 = reqwest::Identity::from_pkcs12_der(&buf, "my-privkey-password")?;/// # drop(pkcs12);/// This requires the `native-tls` Cargo feature enabled./// The certificate chain should contain any intermediate certificates that should be sent to/// # fn pkcs8() -> Result<(), Box<dyn std::error::Error>> {/// let cert = fs::read("client.pem")?;/// let key = fs::read("key.pem")?;/// let pkcs8 = reqwest::Identity::from_pkcs8_pem(&cert, &key)?;/// # drop(pkcs8);/// Parses PEM encoded private key and certificate./// The input should contain a PEM encoded private key/// and at least one PEM encoded certificate./// Note: The private key must be in RSA, SEC1 Elliptic Curve or PKCS#8 format./// # fn pem() -> Result<(), Box<dyn std::error::Error>> {/// File::open("my-ident.pem")?/// let id = reqwest::Identity::from_pem(&buf)?;/// # drop(id);// Not sure here/// Parses a PEM encoded CRL./// # fn crl() -> Result<(), Box<dyn std::error::Error>> {/// File::open("my_crl.pem")?/// let crl = reqwest::tls::CertificateRevocationList::from_pem(&buf)?;/// # drop(crl);/// Creates a collection of `CertificateRevocationList`s from a PEM encoded CRL bundle./// Example byte sources may be `.crl` or `.pem` files./// # fn crls() -> Result<(), Box<dyn std::error::Error>> {/// File::open("crl-bundle.crl")?/// let crls = reqwest::tls::CertificateRevocationList::from_pem_bundle(&buf)?;/// # drop(crls);as_rustls_crlInnerVersion/// A TLS protocol version.Tls1_0Tls1_1Tls1_2Tls1_3TLS_1_0/// Version 1.0 of the TLS protocol.TLS_1_1/// Version 1.1 of the TLS protocol.TLS_1_2/// Version 1.2 of the TLS protocol.TLS_1_3/// Version 1.3 of the TLS protocol.to_native_tlsfrom_rustls// These could perhaps be From/TryFrom implementations, but those would be// part of the public API so let's be careful// This is the default and HTTP/3 feature does not use it so suppress it.BuiltNativeTlsRustlsBuiltRustlsUnknownPreconfiguredNoVerifierverify_tls12_signatureverify_tls13_signaturesupported_verify_schemesIgnoreHostname/// Hyper extension carrying extra TLS layer information./// Made available to clients on responses when `tls_info` is set./// Get the DER encoded leaf certificate of the peer.certificate_from_der_invalidcertificate_from_pem_invalididentity_from_pkcs12_der_invalididentity_from_pkcs8_pem_invalididentity_from_pem_invalididentity_from_pem_pkcs1_keycertificates_from_pem_bundlecrl_from_pemcrl_from_pem_bundle//! TLS configuration and types//! # Backends//! reqwest supports several TLS backends, enabled with Cargo features.//! ## default-tls//! reqwest will pick a TLS backend by default. This is true when the//! `default-tls` feature is enabled.//! While it currently uses `native-tls`, the feature set is designed to only//! enable configuration that is shared among available backends. This allows//! reqwest to change the default to `rustls` (or another) at some point in the//! future.//! <div class="warning">This feature is enabled by default, and takes//! precedence if any other crate enables it. This is true even if you declare//! `features = []`. You must set `default-features = false` instead.</div>//! Since Cargo features are additive, other crates in your dependency tree can//! cause the default backend to be enabled. If you wish to ensure your//! `Client` uses a specific backend, call the appropriate builder methods//! (such as [`use_rustls_tls()`][]).//! [`use_rustls_tls()`]: crate::ClientBuilder::use_rustls_tls()//! ## native-tls//! This backend uses the [native-tls][] crate. That will try to use the system//! TLS on Windows and Mac, and OpenSSL on Linux targets.//! Enabling the feature explicitly allows for `native-tls`-specific//! configuration options.//! [native-tls]: https://crates.io/crates/native-tls//! ## rustls-tls//! This backend uses the [rustls][] crate, a TLS library written in Rust.//! [rustls]: https://crates.io/crates/rustlsfast_randomreplace_headers/// doxMultipartForm/// MultipartForm holds a multipart/form-data body.to_js_value/// `None` is returned, if the underlying data is a multipart form.as_singlefrom_forminto_part/// into_part turns a regular body into the body of a multipart/form-data part.wasm_bindgen_test_configure// Use `js_namespace` here to bind `console.log(..)` instead of just// `log(..)`test_bodytest_body_js_static_strtest_body_js_stringtest_body_js_static_u8_slicetest_body_js_vec_u8// Can use new methods in web-sys when requiring v0.2.93.// > `init.method(m)` to `init.set_method(m)`// For now, ignore their deprecation.JSONUnwrapThrowExtAbortGuardfetch_with_requestjs_fetchmerge_headers// merge request headers with Client default_headers, prior to external http fetch/// Returns a 'Client' that uses this ClientBuilder configuration/// Sets the default headers for every requestdefault_headers_cloneuser_agent_header// ===== impl ClientBuilder =====AbortControllerAbortSignal/// TODOclear_timeoutpromise/// A guard that cancels a fetch request when dropped.FormDatato_form_dataappend_to_formtest_multipart_jsRequestCacheRequestCredentialscors/// None is returned if a body is which can not be cloned./// Calling `.query([("foo", "a"), ("foo", "b")])` gives `"foo=a&foo=b"`./// Set the request json/// Disable CORS on fetching the request./// # WASM/// This option is only effective with WebAssembly target./// The [request mode][mdn] will be set to 'no-cors'./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/Request/modefetch_credentials_same_origin/// Set fetch credentials to 'same-origin'/// The [request credentials][mdn] will be set to 'same-origin'./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/Request/credentialsfetch_credentials_include/// Set fetch credentials to 'include'/// The [request credentials][mdn] will be set to 'include'.fetch_credentials_omit/// Set fetch credentials to 'omit'/// The [request credentials][mdn] will be set to 'omit'.fetch_cache_default/// Set fetch cache mode to 'default'./// The [request cache][mdn] will be set to 'default'./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/Request/cachefetch_cache_no_store/// Set fetch cache mode to 'no-store'./// The [request cache][mdn] will be set to 'no-store'.fetch_cache_reload/// Set fetch cache mode to 'reload'./// The [request cache][mdn] will be set to 'reload'.fetch_cache_no_cache/// Set fetch cache mode to 'no-cache'./// The [request cache][mdn] will be set to 'no-cache'.fetch_cache_force_cache/// Set fetch cache mode to 'force-cache'./// The [request cache][mdn] will be set to 'force-cache'.fetch_cache_only_if_cached/// Set fetch cache mode to 'only-if-cached'./// The [request cache][mdn] will be set to 'only-if-cached'./// This method fails if there was an error while sending request./// `None` is returned if the RequestBuilder can not be cloned._abort/// Get the content-length of this response, if known./// - The server didn't send a `content-length` header./// - The response is compressed and automatically decoded (thus changing///   the actual decoded length)./// Get the response as bytesbytes_stream/// Convert the response into a `Stream` of `Bytes` from the body./* It might not be possible to detect this in JS?
    /// Get the HTTP `Version` of this `Response`.
    #[inline]
    pub fn version(&self) -> Version {
        self.http.version()
    }
    *//// Constant-time equals./// Constant-time less than./// Inputs are interpreted as big endian integers.//! Constant-time comparison helpers for [`ByteArray`]./// Array of bytes representing a scalar serialized as a big endian integer.generate_k/// Deterministically generate ephemeral scalar `k`./// Accepts the following parameters and inputs:/// - `x`: secret key/// - `n`: field modulus/// - `h`: hash/digest of input message: must be reduced modulo `n` in advance/// - `data`: additional associated data, e.g. CSRNG output used as added entropy/// HMAC key `K` (see RFC 6979 Section 3.2.c)/// Chaining value `V` (see RFC 6979 Section 3.2.c)HmacDrbg/// Internal implementation of `HMAC_DRBG` as described in NIST SP800-90A./// <https://csrc.nist.gov/publications/detail/sp/800-90a/rev-1/final>/// This is a HMAC-based deterministic random bit generator used compute a/// deterministic ephemeral scalar `k`./// Initialize `HMAC_DRBG`/// Write the next `HMAC_DRBG` output to the given byte slice.//! See also: the documentation for the [`generate_k`] function.//! use rfc6979::consts::U32;//! use sha2::{Digest, Sha256};//! // NIST P-256 field modulus//! const NIST_P256_MODULUS: [u8; 32] =//!     hex!("FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551");//! // Public key for RFC6979 NIST P256/SHA256 test case//! const RFC6979_KEY: [u8; 32] =//!     hex!("C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721");//! // Test message for RFC6979 NIST P256/SHA256 test case//! const RFC6979_MSG: &[u8; 6] = b"sample";//! // Expected K for RFC6979 NIST P256/SHA256 test case//! const RFC6979_EXPECTED_K: [u8; 32] =//!     hex!("A6E3C57DD01ABE90086538398355DD4C3B17AA873382B0F24D6129493D8AAD60");//! let h = Sha256::digest(RFC6979_MSG);//! let aad = b"";//! let k = rfc6979::generate_k::<Sha256, U32>(&RFC6979_KEY.into(), &NIST_P256_MODULUS.into(), &h, aad);//! assert_eq!(k.as_slice(), &RFC6979_EXPECTED_K);GrayAlphaBGRBGRAARGBABGRComponentBytes/// This is unsound. You can disable `as-bytes` feature, enable `bytemuck`, and use `bytemuck::cast_slice()` instead.assert_no_paddingshared_implGrbgray_agray_alphaGrayAlpha_v08Gray_v08/// Alpha Component/// Blue Component/// Green Component/// Red Component/// An `Alpha + Blue + Green + Red` pixel./// use rgb::Abgr;/// let pixel: Abgr<u8> = Abgr { a: 255, b: 0, g: 0, r: 0 };/// An `Alpha + Red + Green + Blue` pixel./// use rgb::Argb;/// let pixel: Argb<u8> = Argb { a: 255, r: 0, g: 0, b: 0 };/// A `Blue + Green + Red` pixel./// use rgb::Bgr;/// let pixel: Bgr<u8> = Bgr { b: 0, g: 0, r: 0 };/// A `Blue + Green + Red + Alpha` pixel./// use rgb::Bgra;/// let pixel: Bgra<u8> = Bgra { b: 0, g: 0, r: 0, a: 255 };/// Grayscale Component. This field will be renamed to `v`./// A `Grayscale` pixel (rgb crate v0.8)/// Reads the `.0` field/// This function isn't necessary, but it is forwards-compatible with the next major version of the RGB crate./// Exposes the `.0` field for writingwith_alpha/// Add alpha component to this pixel/// Value - the brightness component. May be luma or luminance./// A `Value (brightness) + Alpha` pixel (rgb crate v0.9)/// This pixel is commonly used for grayscale images./// Reads the `.v` field/// Exposes the `.v` field for writing/// Grayscale Component/// This field has been renamed to `.v`/// Alpha Component. This field has been renamed to `.a`./// A pixel for grayscale value + alpha components (rgb crate v0.8)/// Through a `Deref` hack it renames the fields from `.0` and `.1`/// to `.v` (value) and `.a` (alpha)/// A trick that allows using `.v` and `.a` on the old `GrayAlpha` type.swizzle/// A `Green + Red + Blue` pixel./// use rgb::Grb;/// let pixel: Grb<u8> = Grb { g: 0, r: 0, b: 0 };/// A `Red + Green + Blue` pixel./// use rgb::Rgb;/// let pixel: Rgb<u8> = Rgb { r: 0, g: 0, b: 0 };/// A `Red + Green + Blue + Alpha` pixel./// use rgb::Rgba;/// let pixel: Rgba<u8> = Rgba { r: 0, g: 0, b: 0, a: 255 };inherent_implsr" Alternatively, you can use struct literal syntax to"r" create the new pixel type:"r"```not_rust"r"```"new_bgrnew_grbnew_argbnew_bgranew_abgrbgra/// Renamed to `Bgra`bgr/// Renamed to `Bgr`abgr/// Renamed to `Abgr`argb/// Renamed to `Argb`grbGRB/// Renamed to `Grb`BGR8/// 8-bit BGRBGR16/// 16-bit BGR in machine's native endianBGRA8/// 8-bit BGRAABGR8/// 8-bit ABGR, alpha is first. 0 = transparent, 255 = opaque.ARGB8/// 8-bit ARGB, alpha is first. 0 = transparent, 255 = opaque.BGRA16ABGR16/// 16-bit ABGR in machine's native endian. 0 = transparent, 65535 = opaque.ARGB16/// 16-bit ARGB in machine's native endian. 0 = transparent, 65535 = opaque.GRB8/// 8-bit GRBGRAY8/// 8-bit grayGRAY16/// 16-bit gray in machine's native endianGRAYA8/// 8-bit gray with alpha in machine's native endianGRAYA16/// 16-bit gray with alpha in machine's native endian/// Copy `Gray` component out of the `GrayAlpha` structgray_mut/// Provide a mutable view of only `Gray` component (leaving out alpha)./// Create a new `GrayAlpha` with the new alpha value, but same gray valuemap_alpha/// Create a new `GrayAlpha` with a new alpha value created by the callback.map_gray/// Create new `GrayAlpha` with the same alpha value, but different `Gray` valueComponentMapmap_colorsColorComponentMapComponentSlice/// Assumes 255 is opaque/// Assumes 65535 is opaqueconvert_arrayas_pixelsPixelType/// Use [`::bytemuck::cast_slice()`] instead./// Reinterpret the slice as a read-only/shared slice of pixels./// Multiple consecutive elements in the slice are intepreted as a single pixel/// (depending on format, e.g. 3 for RGB, 4 for RGBA)./// Leftover elements are ignored if the slice isn't evenly divisible into pixels./// Use this method only when the type is known from context./// See also `FromSlice`.as_pixels_mut/// Use [`::bytemuck::cast_slice_mut()`] instead./// Reinterpret the slice as a mutable/exclusive slice of pixels./// Casts a slice of bytes into a slice of pixels, e.g. `[u8]` to `[RGB8]`./// See also `FromSlice`as_pixels_impl/// Reinterpert slice as RGB pixels/// Reinterpert slice as RGBA pixelsas_argb/// Reinterpert slice as alpha-first ARGB pixelsas_rgb_mut/// Reinterpert mutable slice as RGB pixelsas_rgba_mut/// Reinterpert mutable slice as RGBA pixelsas_argb_mut/// Reinterpert mutable slice as alpha-first ARGB pixelsas_gray/// Reinterpert mutable slice as grayscale pixelsas_gray_alpha/// Reinterpert mutable slice as grayscale pixels with alphaas_gray_mutas_gray_alpha_mutas_bgr/// Reinterpert slice as reverse-order BGR pixelsas_bgra/// Reinterpert slice as reverse-order BGRA pixelsas_abgr/// Reinterpert slice as reverse-order ABGR pixelsas_bgr_mut/// Reinterpert ntable slice as reverse-order BGR pixelsas_bgra_mut/// Reinterpert mutable slice as reverse-order alpha-last BGRA pixelsas_abgr_mut/// Reinterpert mutable slice as reverse-order alpha-first ABGR pixelsFromSlice/// Use [`::bytemuck::cast_slice()`] or [`::bytemuck::from_bytes()`] to convert/// Cast a slice of component values (bytes) as a slice of RGB/RGBA pixels/// If there's any incomplete pixel at the end of the slice it is ignored.from_items_to_structfrom_items_to_struct_mutrgb_impl_fromreorder_impl_fromargb_convertsconvertstuple_conversionimpl_struct_checkedimpl_struct_ops_opaqueimpl_struct_ops_alphaimpl_scalarr" `px - 1`"r" `px + 1`"r" `px * 1`"r" `px / 1`"r" `px + px`"r" `px * px`"r" `px - px`"WHITE_RGBBLACK_RGBRED_RGBGREEN_RGBBLUE_RGBWHITE_RGBABLACK_RGBARED_RGBAGREEN_RGBABLUE_RGBAtest_add_assigntest_sub_assigntest_multtest_mult_assign/// The components interpreted as an array, e.g. one `RGB` expands to 3 elements./// It's implemented for individual pixels as well as slices of pixels./// The components interpreted as a mutable array, e.g. one `RGB` expands to 3 elements./// If you get an error when calling this on an array, add `[..]`/// > use of unstable library feature 'array_methods'/// arr[..].as_mut_slice()/// Casting the struct to slices of its componentsDestPixelSrcComponentDestComponent/// Convenience function (equivalent of `self.iter().map().collect()`) for applying the same formula to every component./// Note that it returns the pixel directly, not an Interator./// Applying operation to every component/// use rgb::ComponentMap;/// # let pixel = rgb::RGB::new(0u8,0,0);/// let inverted = pixel.map(|c| 255 - c);/// // For simple math there are Add/Sub/Mul implementations:/// let halved = pixel.map(|c| c / 2);/// let doubled = pixel * 2;/// Convenience function for applying the same formula to every rgb/gray component, but skipping the alpha component.map_c/// Alias of `map_colors`/// Same as `ComponentMap`, but doesn't change the alpha channel (if there's any alpha)./// Convenience function for creating a new pixel/// Warning: The order of arguments is R,G,Bimpl_rgbimpl_rgb_to_alpha/// Takes exactly 3 elements from the iterator and creates a new instance./// Panics if there are fewer elements in the iterator.r" Iterate over color components (R, G, and B)"r" Convenience function for converting to RGBA"r" Convenience function for converting to RGBA with alpha channel of a different type than type of the pixels"new_alphagrb_testtest_fmtrgb_test/// The order of arguments is R,G,B,A/// Warning: The order of arguments is R,G,B,A/// let r = rgb::BGRA::<u8,u16>::zeroed();impl_rgbaimpl_alpha_convrgb_mut/// Provide a mutable view of only RGB components (leaving out alpha)./// Useful to change color without changing opacity.bgr_mut/// Takes exactly 4 elements from the iterator and creates a new instance./// Copy RGB components out of the RGBA struct/// Note: you can use `.into()` to convert between other types/// Copy RGB components out of the ARGB structr" Iterate over all components (length=4)"r" Copy RGB components out of the RGBA struct"r" Note: you can use `.into()` to convert between other types"r" Create new RGBA with the same alpha value, but different RGB values"map_rgbr" Create a new RGBA with the new alpha value, but same RGB values"r" Create a new RGBA with a new alpha value created by the callback."r" Allows changing of the type used for the alpha channel."r" Assumes 255 is opaque"r" Assumes 65535 is opaque"rgba_testbgra_test// std is required to run unit tests/// Re-export of the [`bytemuck` crate](https://lib.rs/bytemuck). [See docs](https://docs.rs/bytemuck)./// pixels to/from `&[u8]`./// traits for forward compatibility with the next major version of the crate/// BGR/BGRA alernative layouts & grayscale/// BGR might be useful for some Windows or OpenGL APIs.bytemuck_impl/// Renamed to `Rgb`/// Renamed to `Rgba`/// Incompatible replacement for the `GrayAlpha` type/// 8-bit RGB/// The colorspace is technically undefined, but generally sRGB is assumed./// 16-bit RGB in machine's native endian/// Be careful to perform byte-swapping when reading from files./// 8-bit RGBA, alpha is last. 0 = transparent, 255 = opaque.RGBA16/// 16-bit RGB in machine's native endian. 0 = transparent, 65535 = opaque./// Alpha is last.rgb_workssub_floatsrgba_works//! Basic struct for `RGB` and `RGBA` pixels. Packed, with red first, alpha last.//! This crate is intended to be the lowest common denominator for sharing `RGB`/`RGBA` bitmaps between other crates.//! The crate includes convenience functions for converting between the struct and bytes,//! and overloaded operators that work on all channels at once.//! This crate intentionally doesn't implement color management (due to complexity of the problem),//! but the structs can be parametrized to implement this if necessary. Other colorspaces are out of scope.//! # use rgb::*;//! let pixel = RGB8 {r:0, g:100, b:255};//! let pixel_rgba = pixel.alpha(255);//! let pixel = pixel_rgba.rgb();//! let pixels = vec![pixel; 100];//! use rgb::ComponentBytes; // Import byte conversion trait//! let bytes = pixels.as_bytes();//! use rgb::ComponentMap; // Import pixel map trait//! let half_bright = pixel.map(|channel| channel / 2);//! let doubled = half_bright * 2;//! # let _ = doubled;/// Read an environment variable and tell Cargo that we depend on it./// The name is static since we intend to only read a static set of environmentRING_SRCSSHA256_X86_64SHA512_X86_64SHA256_ARMV8SHA512_ARMV8RING_TEST_SRCSPREGENERATEDcpp_flagsASM_TARGETSAsmTarget// None means "any OS" or "any target". The first match in sequence order is// taken.oss/// Operating systems./// Architectures.perlasm_format/// The PerlAsm format name.use_nasmLINUX_ABI/// Operating systems that have the same ABI as Linux on every architecture/// mentioned in `ASM_TARGETS`.WIN32NNASMAPPLE_ABI/// Operating systems that have the same ABI as macOS on every architectureWINDOWSring_build_rs_mainpregenerate_asm_maingenerate_sources_and_preassemble/// Is this a debug build? This affects whether assertions might be enabled/// in the C code. For packaged builds, this should always be `false`.force_warnings_into_errors/// true: Force warnings to be treated as errors./// false: Use the default behavior (perhaps determined by `$CFLAGS`, etc.)build_c_codenew_buildbuild_libraryobj_pathconfigure_ccrun_command_with_argssources_for_archperlasm_src_dstsasm_srcsis_perlasmasm_pathperlasmjoin_components_with_forward_slashesget_perl_exeget_commandemit_rerun_if_changed// TODO: We should emit `cargo:rerun-if-changed-env` for the various// environment variables that affect the build.walk_dirgenerate_prefix_symbols_headers/// Creates the necessary header files for symbol renaming./// For simplicity, both non-Nasm- and Nasm- style headers are always/// generated, even though local non-packaged builds need only one of them.generate_prefix_symbols_headerprefix_all_symbols// Copyright 2015-2016 Brian Smith.// Permission to use, copy, modify, and/or distribute this software for any// purpose with or without fee is hereby granted, provided that the above// copyright notice and this permission notice appear in all copies.// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.//! Build the non-Rust components.// It seems like it would be a good idea to use `log!` for logging, but it// isn't worth having the external dependencies (one for the `log` crate, and// another for the concrete logging implementation). Instead we use `eprintln!`// to log everything to stderr.Overlappingctr32_encrypt_blocks_with_vpaes_key/// SAFETY:///   * The caller must ensure that if blocks > 0 then either `input` and///     `output` do not overlap at all, or input == output.add(n) for some///     (nonnegative) n.///   * if blocks > 0, The caller must ensure `input` points to `blocks` blocks///     and that `output` points to writable space for `blocks` blocks.///   * The caller must ensure that `vpaes_key` was initialized with///     `vpaes_set_encrypt_key`.///   * Upon returning, `blocks` blocks will have been read from `input` and///     written to `output`.// Copyright 2018-2024 Brian Smith.EncryptBlockEncryptCtr32KeyBytesencrypt_iv_xor_blockctr32_encrypt_withinBLOCK_LENBitLength/// nonce || big-endian counter.MAX_ROUNDS// Keep this in sync with AES_KEY in aes.h.// Keep this in sync with `AES_MAXNR` in aes.h.set_encrypt_key// SAFETY://  * The function `$name` must read `bits` bits from `user_key`; `bits` will//    always be a valid AES key length, i.e. a whole number of bytes.//  * `$name` must set `key.rounds` to the value expected by the corresponding//    encryption/decryption functions and return 0, or otherwise must return//    non-zero to indicate failure.//  * `$name` may inspect CPU features.// In BoringSSL, the C prototypes for these are in// crypto/fipsmodule/aes/internal.h.ctr32_encrypt_blocks///   * The caller must ensure that `$key` was initialized with the///     `set_encrypt_key!` invocation that `$name` requires.///   * The caller must ensure that fhe function `$name` satisfies the conditions///     for the `f` parameter to `ctr32_encrypt_blocks`.NonZero_size_t///   * `f` must not read more than `blocks` blocks from `input`.///   * `f` must write exactly `block` blocks to `output`.///   * In particular, `f` must handle blocks == 0 without reading from `input`///     or writing to `output`.///   * `f` must support the input overlapping with the output exactly or///     with any nonnegative offset `n` (i.e. `input == output.add(n)`);///     `f` does NOT need to support the cases where input < output.///   * `key` must have been initialized with the `set_encrypt_key!` invocation///      that corresponds to `f`.///   * `f` may inspect CPU features.intelAvxSsse3RequiredCpuFeaturesOptionalCpuFeaturesinner_less_safeoverlappingbbGetFeaturepolyfillunwrap_constbshwvpOverlappingPartialBlockPartialBlockHwVpFeaturesnew_maskAES_128_KEY_LENAES_256_KEY_LENAES_128AES_256increment_by_less_safe// `Counter` is `ffi::Counter` as its representation is dictated by its use in// the FFI./// The IV for a single block encryption./// Intentionally not `Clone` to ensure each is used only once.ZERO_BLOCKencrypt_block_using_encrypt_iv_xor_blockencrypt_iv_xor_block_using_encrypt_blockencrypt_iv_xor_block_using_ctr32testutiltest_aesconsume_keyTestCaseMAX_IN_OUT_LENtest_aes_gcm_counter_blocks_maxtest_aes_gcm_counter_blocks_max_minus_onetest_aes_gcm_counter_blocksaes_gcm_tests// These AES-GCM-specific tests are here instead of in `aes_gcm` because// `Counter`'s API isn't visible (enough) to aes_gcm.AsChunksMutseal_wholeopen_whole// Copyright 2015-2025 Brian Smith.IndexErrorAadInputTooLongErrorclmulavxmovbeseal_whole_vaes_clmul_avx2vclmulavx2open_whole_vaes_clmul_avx2sliceutiloverwrite_at_startusize_from_u64_saturatedaeshwclmulmovbevaesclmulavx2DynKeyVAesClMulAvx2AesHwClMulAvxMovbeAesHwClMulSimdnew_ssse3derive_gcm_key_valueCHUNK_BLOCKSUpdateBlockseal_whole_partialUpdateBlocksseal_stridedseal_finishopen_whole_partialopen_stridedopen_finish_MAX_INPUT_LEN_BOUNDED_BY_NIST// [NIST SP800-38D] Section 5.2.1.1. Note that [RFC 5116 Section 5.1] and// [RFC 5116 Section 5.2] have an off-by-one error in `P_MAX`.// [NIST SP800-38D]://    http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf// [RFC 5116 Section 5.1]: https://tools.ietf.org/html/rfc5116#section-5.1// [RFC 5116 Section 5.2]: https://tools.ietf.org/html/rfc5116#section-5.2aes_keygcm_keyGcmKeyInnerAlgorithmID/// An AEAD Algorithm./// The length of the key./// The length of a tag./// See also `MAX_TAG_LEN`.nonce_len/// The length of the nonces.'ioopen_withinderive_debug_via_id/// AES-128 in GCM mode with 128-bit tags and 96 bit nonces./// AES-256 in GCM mode with 128-bit tags and 96 bit nonces.aes_gcm_init_128aes_gcm_init_256aes_gcm_sealaes_gcm_open/// ChaCha20-Poly1305 as described in [RFC 8439]./// The keys are 256 bits long and the nonces are 96 bits long./// [RFC 8439]: https://tools.ietf.org/html/rfc8439chacha20_poly1305_init/// Copies |key| into |ctx_buf|.chacha20_poly1305_sealchacha20_poly1305_open// Copyright 2015-2021 Brian Smith.ChaCha20_ctr32chacha_core// Performs 20 rounds of ChaCha on `input`, storing the result in `output`.quarterround// Copyright 2021 Brian Smith.// Portions Copyright (c) 2014, Google Inc.// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */// Adapted from the public domain, estream code by D. Bernstein.// Adapted from the BoringSSL crypto/chacha/chacha.c.chacha20_ctr32_ffi// `unsafe { (N, C, InOut) => f }` means that the function `f` is safe to call// iff the in/out length is at least `N`, the CPU features `C` are available,// and the input type is `InOut`. If `f` supports overlapping input/output then// `InOut` should be `Overlapping<'_, u8>`; otherwise it should be `&mut [u8]`.MIN_LEN// Panics if `in_out.len() < MIN_LEN`. The caller should have guarded against// that so that the assertion gets optimized away.// Copyright 2016-2025 Brian Smith.ArraySplitMapencrypt_single_block_with_ctr_0// Encrypts `in_out` with the counter 0 and returns counter 1,// where the counter is derived from the nonce `nonce`.words_less_safe/// Counter || Nonce, all native endian.zero_one_less_safe// Nonce-reuse: the caller must only use the first counter (0) for at most// a single block.from_nonce_and_ctrinto_words_less_safe/// This is "less safe" because it hands off management of the counter toMAX_ALIGNMENT_AND_OFFSETMAX_ALIGNMENT_AND_OFFSET_SUBSETchacha20_test_defaultchacha20_test_fallback// Smoketest the fallback implementation.chacha20_test// Verifies the encryption is successful when done on overlapping buffers.// On some branches of the 32-bit x86 and ARM assembly code the in-place// operation fails in some situations where the input/output buffers are// not exactly overlapping. Such failures are dependent not only on the// degree of overlapping but also the length of the data. `encrypt_within`// works around that.chacha20_test_case_inner// Copyright 2016 Brian Smith.// Portions Copyright (c) 2016, Google Inc.check_input_lengthsdeclare_opendeclare_sealBmi2Sse41// Keep in sync with BoringSSL's `chacha20_poly1305_open_data` and// `chacha20_poly1305_seal_data`.// It isn't obvious whether the assembly code works for tags that aren't// 16-byte aligned. In practice it will always be 16-byte aligned because it// is embedded in a union where the other member of the union is 16-byte// aligned.u64_from_usizeintegrated_MAX_IN_OUT_LEN_BOUNDED_BY_RFC// https://tools.ietf.org/html/rfc8439#section-2.8seal_fallbackopen_fallback// Also used by chacha20_poly1305_openssh.poly1305_update_padded_16SealingKey/// A key for sealing packets./// Constructs a new `SealingKey`.seal_in_place/// Seals (encrypts and signs) a packet./// On input, `plaintext_in_ciphertext_out` must contain the unencrypted/// `packet_length||plaintext` where `plaintext` is the/// `padding_length||payload||random padding`. It will be overwritten by/// `encrypted_packet_length||ciphertext`, where `encrypted_packet_length`/// is encrypted with `K_1` and `ciphertext` is encrypted by `K_2`./// Panics if `plaintext_in_ciphertext_out.len() < PACKET_LENGTH_LEN`./// Panics if `plaintext_in_ciphertext_out` is longer than the maximum/// input size for ChaCha20-Poly1305. Note that this limit is much,/// much larger than SSH's 256KB maximum record size.OpeningKey/// A key for opening packets./// Constructs a new `OpeningKey`.decrypt_packet_lengthPACKET_LENGTH_LEN/// Returns the decrypted, but unauthenticated, packet length./// Importantly, the result won't be authenticated until `open_in_place` isopen_in_place/// Opens (authenticates and decrypts) a packet./// `ciphertext_in_plaintext_out` must be of the form/// `encrypted_packet_length||ciphertext` where `ciphertext` is the/// encrypted `plaintext`. When the function succeeds the ciphertext is/// replaced by the plaintext and the result is `Ok(plaintext)`, where/// `plaintext` is `&ciphertext_in_plaintext_out[PACKET_LENGTH_LEN..]`;/// otherwise the contents of `ciphertext_in_plaintext_out` are unspecified/// and must not be used.k_1k_2make_nonce/// The length of key./// The length in bytes of the `packet_length` field in a SSH packet./// The length in bytes of an authentication tag.//! The [chacha20-poly1305@openssh.com] AEAD-ish construct.//! This should only be used by SSH implementations. It has a similar, but//! different API from `ring::aead` because the construct cannot use the same//! API as `ring::aead` due to the way the construct handles the encrypted//! packet length.//! The concatenation of a and b is denoted `a||b`. `K_1` and `K_2` are defined//! in the [chacha20-poly1305@openssh.com] specification. `packet_length`,//! `padding_length`, `payload`, and `random padding` are defined in//! [RFC 4253]. The term `plaintext` is used as a shorthand for//! `padding_length||payload||random padding`.//! [chacha20-poly1305@openssh.com]://!    http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.chacha20poly1305?annotate=HEAD//! [RFC 4253]: https://tools.ietf.org/html/rfc4253// 32 bitsHTableXiAsChunksClMulh_tableupdate_blockMovbegcm_mul64_nohwgcm_polyval_nohwgmultwith_swapped_xi// Copyright (c) 2019, Google Inc.// Portions Copyright 2020-2024 Brian Smith.// This file is based on BoringSSL's gcm_nohw.c.// This file contains a implementation of GHASH based on the notes// in https://bearssl.org/constanttime.html#ghash-for-gcm and the reduction// algorithm described in// https://crypto.stanford.edu/RealWorldCrypto/slides/gueron.pdf.// Unlike the BearSSL notes, we use u128 in the 64-bit implementation.htable_new///  * The function `$name` must meet the contract of the `f` paramweter of///    `ghash()`.///   * `f` must read `len` bytes from `inp`; it may assume///     that `len` is a (non-zero) multiple of `BLOCK_LEN`.HtableHTABLE_LEN// The alignment is required by some assembly code, such as `ghash-ssse3-*`.// Copyright 2018 Brian Smith.NeonVAesClmul// Copyright 2018-2025 Brian Smith.FromByteLenaad_lenin_out_len_not_send/// Access to `inner` for the integrated AES-GCM implementations only.pre_finishUnboundKey/// Immutable keys for use in situations where `OpeningKey`/`SealingKey` and/// `NonceSequence` cannot reasonably be used./// Prefer to use `OpeningKey`/`SealingKey` and `NonceSequence` when practical./// Constructs a `LessSafeKey`.'in_outopen_in_place_separate_tag/// Like [open_in_place](Self::open_in_place), except the authentication tag is/// passed separately./// Like [`super::OpeningKey::open_in_place()`], except it accepts an/// arbitrary nonce./// `nonce` must be unique for every use of the key to open data./// Like [`super::OpeningKey::open_within()`], except it accepts anseal_in_place_append_tag/// Like [`super::SealingKey::seal_in_place_append_tag()`], except it/// accepts an arbitrary nonce./// `nonce` must be unique for every use of the key to seal data.seal_in_place_separate_tag/// Like `super::SealingKey::seal_in_place_separate_tag()`, except it/// The key's AEAD algorithm.fmt_debug/// A nonce for a single AEAD opening or sealing operation./// The user must ensure, for a particular key, that each nonce is unique./// `Nonce` intentionally doesn't implement `Clone` to ensure that each one is/// consumed at most once.try_assume_unique_for_key/// Constructs a `Nonce` with the given value, assuming that the value is/// unique for the lifetime of the key it is being used with./// Fails if `value` isn't `NONCE_LEN` bytes long.assume_unique_for_key/// All the AEADs we support use 96-bit nonces.BoundKeyNonceSequencenonce_sequence/// An AEAD key for authenticating and decrypting ("opening"), bound to a nonce/// Intentionally not `Clone` or `Copy` since cloning would allow duplication/// of the nonce sequence./// Authenticates and decrypts (“opens”) data in place./// `aad` is the additional authenticated data (AAD), if any./// On input, `in_out` must be the ciphertext followed by the tag. When/// `open_in_place()` returns `Ok(plaintext)`, the input ciphertext/// has been overwritten by the plaintext; `plaintext` will refer to the/// plaintext without the tag./// When `open_in_place()` returns `Err(..)`, `in_out` may have been/// overwritten in an unspecified way./// Authenticates and decrypts (“opens”) data in place, with a shift./// On input, `in_out[ciphertext_and_tag]` must be the ciphertext followed/// by the tag. When `open_within()` returns `Ok(plaintext)`, the plaintext/// will be at `in_out[0..plaintext.len()]`. In other words, the following/// two code fragments are equivalent for valid values of/// `ciphertext_and_tag`, except `open_within` will often be more efficient:/// ```skip/// let plaintext = key.open_within(aad, in_out, cipertext_and_tag)?;/// let ciphertext_and_tag_len = in_out[ciphertext_and_tag].len();/// in_out.copy_within(ciphertext_and_tag, 0);/// let plaintext = key.open_in_place(aad, &mut in_out[..ciphertext_and_tag_len])?;/// Similarly, `key.open_within(aad, in_out, 0..)` is equivalent to/// `key.open_in_place(aad, in_out)`.///  When `open_in_place()` returns `Err(..)`, `in_out` may have been/// The shifting feature is useful in the case where multiple packets are/// being reassembled in place. Consider this example where the peer has/// sent the message “Split stream reassembled in place” split into/// three sealed packets:/// ```ascii-art///                 Packet 1                  Packet 2                 Packet 3/// Input:  [Header][Ciphertext][Tag][Header][Ciphertext][Tag][Header][Ciphertext][Tag]///                      |         +--------------+                        |///               +------+   +-----+    +----------------------------------+///               v          v          v/// Output: [Plaintext][Plaintext][Plaintext]///        “Split stream reassembled in place”/// This reassembly can be accomplished with three calls to `open_within()`.//! Authenticated Encryption with Associated Data (AEAD).//! See [Authenticated encryption: relations among notions and analysis of the//! generic composition paradigm][AEAD] for an introduction to the concept of//! AEADs.//! [AEAD]: https://eprint.iacr.org/2000/025.pdf//! [`crypto.cipher.AEAD`]: https://golang.org/pkg/crypto/cipher/#AEADLenMismatchErrorin_out// Invariant: N != 0.// Invariant: `self.in_out.len() == N`.into_unwritten_output// Copyright 2024 Brian Smith.index_error// Invariant: self.src.start <= in_out.len().with_input_output_lensplit_first_chunk// Perhaps unlike `slice::split_first_chunk_mut`, this is biased,// performance-wise, against the case where `N > self.len()`, so callers// should be structured to avoid that.// If the result is `Err` then nothing was written to `self`; if anything// was written then the result will not be `Err`.cold_exhaustive_error// invariant: `self.in_out.len() < BLOCK_LEN`.poly1305_state_st// XXX/TODO(MSRV): change to `pub(super)`.fe1305x2precompbuf_used// TODO: Is 16 enough?// for alignment; only using 10update_internal// Portions Copyright (c) 2014, 2015, Google Inc.r0// Keep in sync with `poly1305_state_st` in poly1305.c// `input.len % BLOCK_LEN == 0` must be true for every call except the// final one.ffi_arm_neonffi_fallbackkey_and_nonce/// A Poly1305 key./// Implements the original, non-IETF padding semantics./// This is used by chacha20_poly1305_openssh and the standalone/// poly1305 test vectors.test_poly1305// Adapted from BoringSSL's crypto/poly1305/poly1305_test.cc.// TODO: enforce maximum input length./// A key for generating QUIC Header Protection masks.Okm/// Create a new header protection key./// `key_bytes` must be exactly `algorithm.key_len` bytes long./// Generate a new QUIC Header Protection mask./// `sample` must be exactly `self.algorithm().sample_len()` bytes long./// The key's algorithm.SAMPLE_LEN/// QUIC sample for new key masks/// A QUIC Header Protection Algorithm.sample_len/// The required sample length.CHACHA20/// AES-128./// AES-256.aes_init_128aes_init_256aes_new_mask/// ChaCha20.chacha20_initchacha20_new_mask//! QUIC Header Protection.//! See draft-ietf-quic-tls./// An AEAD key for encrypting and signing ("sealing"), bound to a nonce/// Encrypts and signs (“seals”) data in place, appending the tag to the/// resulting ciphertext./// `key.seal_in_place_append_tag(aad, in_out)` is equivalent to:/// key.seal_in_place_separate_tag(aad, in_out.as_mut())///     .map(|tag| in_out.extend(tag.as_ref()))/// Encrypts and signs (“seals”) data in place./// `aad` is the additional authenticated data (AAD), if any. This is/// authenticated but not encrypted. The type `A` could be a byte slice/// `&[u8]`, a byte array `[u8; N]` for some constant `N`, `Vec<u8>`, etc./// If there is no AAD then use `Aad::empty()`./// The plaintext is given as the input value of `in_out`. `seal_in_place()`/// will overwrite the plaintext with the ciphertext and return the tag./// For most protocols, the caller must append the tag to the ciphertext./// The tag will be `self.algorithm.tag_len()` bytes long.MAX_KEY_LEN/// An AEAD key without a designated role or nonce sequence./// Constructs a `UnboundKey`./// Fails if `key_bytes.len() != algorithm.key_len()`.less_safe_keyopening_keysealing_keyunbound_key/// Returns the next nonce in the sequence./// This may fail if "too many" nonces have been requested, where how many/// is too many is up to the implementation of `NonceSequence`. An/// implementation may that enforce a maximum number of records are/// sent/received under a key this way. Once `advance()` fails, it must/// fail for all subsequent calls./// A sequences of unique nonces./// A given `NonceSequence` must never return the same `Nonce` twice from/// `advance()`./// A simple counter is a reasonable (but probably not ideal) `NonceSequence`./// of the sequence./// Constructs a new key from the given `UnboundKey` and `NonceSequence`./// An AEAD key bound to a nonce sequence./// The additionally authenticated data (AAD) for an opening or sealing/// operation. This data is authenticated but is **not** encrypted./// The type `A` could be a byte slice `&[u8]`, a byte array `[u8; N]`/// for some constant `N`, `Vec<u8>`, etc./// Construct the `Aad` from the given bytes./// Construct an empty `Aad`.max_input_len/// A possibly valid authentication tag.// All the AEADs we support use 128-bit tags.MAX_TAG_LEN/// The maximum length of a tag for the algorithms in this module.chacha20_poly1305_openssh// Copyright 2015-2024 Brian Smith.curve25519x25519suite_bECDH_P256ECDH_P384/// A key agreement algorithm.derive_debug_via_fieldEphemeralPrivateKey/// An ephemeral private key for use (only) with `agree_ephemeral`. The/// signature of `agree_ephemeral` ensures that an `EphemeralPrivateKey` can be/// used for at most one key agreement./// Generate a new ephemeral private key for the given algorithm.compute_public_key/// Computes the public key from the private key./// The algorithm for the private key./// Do not use.bytes_for_test/// A public key for key agreement./// The algorithm for the public key.UnparsedPublicKey/// An unparsed, possibly malformed, public key for key agreement./// Constructs a new `UnparsedPublicKey`./// TODO: docagree_ephemeral/// Performs a key agreement with an ephemeral private key and the given public/// `my_private_key` is the ephemeral private key to use. Since it is moved, it/// will not be usable after calling `agree_ephemeral`, thus guaranteeing that/// the key is used for only one key agreement./// `peer_public_key` is the peer's public key. `agree_ephemeral` will return/// `Err(error_value)` if it does not match `my_private_key's` algorithm/curve./// `agree_ephemeral` verifies that it is encoded in the standard form for the/// algorithm and that the key is *valid*; see the algorithm's documentation for/// details on how keys are to be encoded and what constitutes a valid key for/// that algorithm./// After the key agreement is done, `agree_ephemeral` calls `kdf` with the raw/// key material from the key agreement operation and then returns what `kdf`agree_ephemeral_// Copyright 2015-2017 Brian Smith.//! Key Agreement: ECDH, including X25519.//! Note that this example uses X25519, but ECDH using NIST P-256/P-384 is done//! exactly the same way, just substituting//! `agreement::ECDH_P256`/`agreement::ECDH_P384` for `agreement::X25519`.//! use ring::{agreement, rand};//! let rng = rand::SystemRandom::new();//! let my_private_key = agreement::EphemeralPrivateKey::generate(&agreement::X25519, &rng)?;//! // Make `my_public_key` a byte slice containing my public key. In a real//! // application, this would be sent to the peer in an encoded protocol//! // message.//! let my_public_key = my_private_key.compute_public_key()?;//! let peer_public_key_bytes = {//!     // In a real application, the peer public key would be parsed out of a//!     // protocol message. Here we just generate one.//!     let peer_private_key =//!         agreement::EphemeralPrivateKey::generate(&agreement::X25519, &rng)?;//!     peer_private_key.compute_public_key()?//! let peer_public_key = agreement::UnparsedPublicKey::new(//!     &agreement::X25519,//!     peer_public_key_bytes);//! agreement::agree_ephemeral(//!     my_private_key,//!     &peer_public_key,//!     |_key_material| {//!         // In a real application, we'd apply a KDF to the key material and the//!         // public keys (as recommended in RFC 7748) and then derive session//!         // keys from the result. We omit all that here.//! # Ok::<(), ring::error::Unspecified>(())// The "NSA Guide" steps here are from from section 3.1, "Ephemeral Unified// Model."/// The modulus *m* that determines the size of `limbx`.BoxedLimbs/// All `BoxedLimbs<M>` are stored in the same number of limbs.// TODO: `derive(Clone)` after https://github.com/rust-lang/rust/issues/26925// is resolved or restrict `M: Clone`.from_be_bytes_padded_less_than// Copyright 2015-2023 Brian Smith.Unencodedunwrap_impossible_len_mismatch_errorElemOwnedModulusValuePublicModulusLeadingZerosStrippedn0// n0 * N == -1 (mod r).// r == 2**(N0::LIMBS_USED * LIMB_BITS) and LG_LITTLE_R == lg(r). This// ensures that we can do integer division by |r| by simply ignoring// `N0::LIMBS_USED` limbs. Similarly, we can calculate values modulo `r` by// just looking at the lowest `N0::LIMBS_USED` limbs. This is what makes// Montgomery multiplication efficient.// As shown in Algorithm 1 of "Fast Prime Field Elliptic Curve Cryptography// with 256 Bit Primes" by Shay Gueron and Vlad Krasnov, in the loop of a// multi-limb Montgomery multiplication of a * b (mod n), given the// unreduced product t == a * b, we repeatedly calculate://    t1 := t % r         |t1| is |t|'s lowest limb (see previous paragraph).//    t2 := t1*n0*n//    t3 := t + t2//    t := t3 / r         copy all limbs of |t3| except the lowest to |t|.// In the last step, it would only make sense to ignore the lowest limb of// |t3| if it were zero. The middle steps ensure that this is the case://                            t3 ==  0 (mod r)//                        t + t2 ==  0 (mod r)//                   t + t1*n0*n ==  0 (mod r)//                       t1*n0*n == -t (mod r)//                        t*n0*n == -t (mod r)//                          n0*n == -1 (mod r)//                            n0 == -1/n (mod r)// Thus, in each iteration of the loop, we multiply by the constant factor// n0, the negative inverse of n (mod r).// TODO(perf): Not all 32-bit platforms actually make use of n0[1]. For the// ones that don't, we could use a shorter `R` value and use faster `Limb`// calculations instead of double-precision `u64` calculations.OwnedModulus/// The modulus *m* for a ring ℤ/mℤ, along with the precomputed values needed/// for efficient Montgomery multiplication modulo *m*. The value must be odd/// and larger than 2. The larger-than-1 requirement is imposed, at least, by/// the modular inversion code.to_elemlen_bitsbe_bytescpu_featuresoneRalloc_zero// TODO: XXX Avoid duplication with `Modulus`.MAX_LIMBSMIN_LIMBSLIMB_BYTES// Also `value >= 3`./// `OwnedModulus`, without the overhead of Montgomery multiplication support.verify_less_than// Unlike most `[Limb]` we deal with, these are stored most significant// word first.PrivateExponentfrom_be_bytes_padded// `p` is the modulus for which the exponent is in the interval [1, `p` - 1).from_be_bytes_for_test_only// Create a `PrivateExponent` with a value that we do not support in// production use, to allow testing with additional test vectors.boxed_limbsmodulusvalueprivate_exponentAliasingSlices3limbs512LimbSliceError// When we need to create a new `Elem`, first we create a `Storage` and then// move its `limbs` into the new element. When we want to recylce an `Elem`'s// memory allocation, we convert it back into a `Storage`./// The number of Montgomery factors that need to be canceled out from/// `value` to get the actual value./// Elements of ℤ/mℤ for some modulus *m*.// Defaulting `E` to `Unencoded` is a convenience for callers from outside this// submodule. However, for maximum clarity, we always explicitly use// `Unencoded` within the `bigint` submodule.clone_intofrom_montgomery_amm/// Does a Montgomery reduction on `limbs` assuming they are Montgomery-encoded ('R') and assuming/// they are the same size as `m`, but perhaps not reduced mod `m`. The result will be/// fully reduced mod `m`./// WARNING: Takes a `Storage` as an in/out value.into_unencodedfill_be_bytesAFBFelem_mul_intoProductEncodingelem_mulelem_double// r *= 2.elem_reduced_once// TODO: This is currently unused, but we intend to eventually use this to// reduce elements (x mod q) mod p in the RSA CRT. If/when we do so, we// should update the testing so it is reflective of that usage, instead of// the old usage.Smallerelem_reducedRInverseelem_squaredelem_widenelem_add// TODO: Document why this works for all Montgomery factors.elem_sub// The value 1, Montgomery-encoded some number of times.newRR// Returns RR = = R**2 (mod n) where R = 2**r is the smallest power of// 2**LIMB_BITS such that R > m.// Even though the assembly on some 32-bit platforms works with 64-bit// values, using `LIMB_BITS` here, rather than `N0::LIMBS_USED * LIMB_BITS`,// is correct because R**2 will still be a multiple of the latter as// `N0::LIMBS_USED` is either one or two.newRRRRRRelem_exp_vartime/// Calculates base**exponent (mod m)./// The run time  is a function of the number of limbs in `m` and the bit/// length and Hamming Weight of `exponent`. The bounds on `m` are pretty/// obvious but the bounds on `exponent` are less obvious. Callers should/// document the bounds they place on the maximum value and maximum Hamming/// weight of `exponent`.// TODO: The test coverage needs to be expanded, e.g. test with the largest// accepted exponent and with the most common values of 65537 and 3.elem_exp_consttimeELEM_EXP_CONSTTIME_MAX_MODULUS_LIMBS// The maximum modulus size supported for `elem_exp_consttime` in normal// operation._LIMBS_PER_CHUNK_DIVIDES_ELEM_EXP_CONSTTIME_MAX_MODULUS_LIMBSWINDOW_BITSTABLE_ENTRIESSTORAGE_ENTRIESSTORAGE_LIMBSelem_exp_consttime_innerverify_inverses_consttime/// Verified a == b**-1 (mod m), i.e. a**-1 == b (mod m).elem_verify_equal_consttimeunwrap_impossible_limb_slice_error// Type-level representation of an arbitrary modulus.test_elem_exp_consttimetest_elem_mul// TODO: fn test_elem_exp_vartime() using// "src/rsa/bigint_elem_exp_vartime_tests.txt". See that file for details.// In the meantime, the function is tested indirectly via the RSA// verification and signing tests.test_elem_squaredtest_elem_reducedtest_elem_reduced_onceconsume_elemconsume_elem_uncheckedconsume_modulusassert_elem_eqinto_encoded//! Multi-precision integers.//! # Modular Arithmetic.//! Modular arithmetic is done in finite commutative rings ℤ/mℤ for some//! modulus *m*. We work in finite commutative rings instead of finite fields//! because the RSA public modulus *n* is not prime, which means ℤ/nℤ contains//! nonzero elements that have no multiplicative inverse, so ℤ/nℤ is not a//! finite field.//! In some calculations we need to deal with multiple rings at once. For//! example, RSA private key operations operate in the rings ℤ/nℤ, ℤ/pℤ, and//! ℤ/qℤ. Types and functions dealing with such rings are all parameterized//! over a type `M` to ensure that we don't wrongly mix up the math, e.g. by//! multiplying an element of ℤ/pℤ by an element of ℤ/qℤ modulo q. This follows//! the "unit" pattern described in [Static checking of units in Servo].//! `Elem` also uses the static unit checking pattern to statically track the//! Montgomery factors that need to be canceled out in each value using it's//! `E` parameter.//! [Static checking of units in Servo]://!     https://blog.mozilla.org/research/2014/06/23/static-checking-of-units-in-servo/LeakyLimbparse_digitlimbs_from_hex// TODO: this would be nicer as a trait, but currently traits don't support const functionsusize_from_u32_MAX_LIMBS_ADDRESSES_MEMORY_SAFETY_ISSUESbn_mul_mont_ffiLEN_MINLEN_MOD// Copyright 2024-2025 Brian Smith.with_non_dangling_non_null_pointers_ra/// The pointers passed to `f` will be valid and non-null, and will not/// be dangling, so they can be passed to C functions./// The first pointer, `r`, may be pointing to uninitialized memory for/// `expected_len` elements of type `T`, properly aligned and writable./// `f` must not read from `r` before writing to it./// The second & third pointers, `a` and `b`, point to `expected_len`/// values of type `T`, properly aligned./// `r`, `a`, and/or `b` may alias each other only in the following ways:/// `ptr::eq(r, a)`, `ptr::eq(r, b)`, and/or `ptr::eq(a, b)`; i.e. they/// will not be "overlapping."/// Implementations of this trait shouldn't override this defaultwith_potentially_dangling_non_null_pointers_ra/// If `expected_len == 0` then the pointers passed to `f` may be/// dangling pointers, which should not be passed to C functions. In all/// other respects, this works like/// `Self::with_non_dangling_non_null_pointers_rab`./// Implementations of this trait should implement this method and not/// `with_non_dangling_non_null_pointers_rab`. Users of this trait should/// use `with_non_dangling_non_null_pointers_rab` and not this.AliasingSlices2with_non_dangling_non_null_pointers_rab/// The pointers passed to `f` will all be non-null and properly aligned,/// and will not be dangling./// The first pointer, `r` points to potentially-uninitialized writable/// space for `expected_len` elements of type `T`. Accordingly, `f` must/// not read from `r` before writing to it./// initialized values of type `T`./// `r`, `a`, and/or `b` may alias each other, but only in the following/// ways: `ptr::eq(r, a)`, `ptr::eq(r, b)`, and/or `ptr::eq(a, b)`; theywith_potentially_dangling_non_null_pointers_rab// Copyright 2025 Brian Smith.montsqr_mont5AdxBmi1LeakyWindow_512_IS_LIMB_BITS_TIMES_8mul_mont5MIN_4Xmul_mont5_4xscatter5gather5// SAFETY: `power` must be less than 32.mul_mont_gather5_ammpower5_ammcheck_common// Helps the compiler will be able to hoist all of these checks out of the// loops in the caller. Try to help the compiler by doing the checks// consistently in each function and also by inlining this function and all the// callers.check_common_with_nAlignedStorageLIMBS_PER_CHUNK_LIMB_SIZE_DIVIDES_ALIGNMENTaligned_chunks_mut// The result will have every chunk aligned on a 64 byte boundary.// Some x86_64 assembly is written under the assumption that some of its// input data and/or temporary storage is aligned to `MOD_EXP_CTIME_ALIGN`// bytes, which was/is 64 in OpenSSL.// We use this in the non-X86-64 implementation of exponentiation as well,// with the hope of converging th two implementations into one.// Indicates that the element is not encoded; there is no *R* factor// that needs to be canceled out.// Indicates that the element is encoded; the value has one *R*// factor that needs to be canceled out.// Indicates the element is encoded three times; the value has three// *R* factors that need to be canceled out.// Indicates the element is encoded twice; the value has two *R*// factors that need to be canceled out.// Indicates the element is inversely encoded; the value has one// 1/*R* factor that needs to be canceled out.ReductionEncoding/// The encoding of the result of a reduction./// The encoding of the result of a multiplication.// XXX: Rust doesn't allow overlapping impls,// TODO (if/when Rust allows it):// impl<E1, E2: ReductionEncoding> ProductEncoding for//         (E1, E2) {//     type Output = <(E2, E1) as ProductEncoding>::Output;bssllimbs_mul_montlimbs_from_mont_in_place// `bigint` needs then when the `alloc` feature is enabled. `bn_mul_mont` above needs this when// we are using the platforms for which we don't have `bn_mul_mont` in assembly.prefixed_externprefixed_itemlimbs_mul_add_limblimbs_square_mont/// r = r**2test_mul_add_words// TODO: wasm// Copyright 2017-2025 Brian Smith.LIMBS_USEDprecalculated// Copyright 2015-2022 Brian Smith.limb_slice_error// The minimum number of limbs allowed for any `&[Limb]` operation.// TODO: Use `256 / LIMB_BITS` so that the limit is independent of limb size.// The maximum number of limbs allowed for any `&[Limb]` operation.LenMismatchlen_mismatchtoo_shorttoo_long// Copyright 2017-2023 Brian Smith.BoolMask// BoolMask is either `BoolMask::TRUE` or `BoolMask::FALSE`./// Returns true if `self` is `BoolMask::TRUE`; otherwise, returns false/// (`self` is `BoolMask::FALSE`).CompilerWordLeakyWord/// A native word that isn't secret./// `LeakyWord` supports `as` conversions to/from native types./// XXX: This isn't the native word size on targets where a pointer isn't the/// same size as a native word. TODO: Fix this.boolmaskleakyverify_slices_are_equal/// Returns `Ok(())` if `a == b` and `Err(error::Unspecified)` otherwise.xor_16xor_assignxor_assign_at_start/// XORs the first N bytes of `b` into `a`, where N is/// `core::cmp::min(a.len(), b.len())`.leak_in_testtest_constant_timeconstant_time_conditional_memcpyconstant_time_conditional_memxortest_bool_mask_bitwise_and_is_logical_and//! Building blocks./// A native word that may hold a secret./// XXX: Currently this is a type alias of `LeakyWord` so it doesn't enforce,/// except by convention, the prevention of leaks. This is a temporary state to/// support the refactorings that will/// XXX: Over time, we'll evolve Word into a newtype with an API that minimizes/// leaks and makes all leaks explicit, like so:/* TODO:
#[repr(transparent)]
pub(crate) struct Word(LeakyWord);

impl Word {
    pub fn leak_word(self) -> LeakyWord { self.0 }
}

impl From<LeakyWord> for Word {
    fn from(w: LeakyWord) -> Self {
        // TODO: Use a stronger `black_box`.
        Self(core::hint::black_box(w))
    }
}
*//// The length of something, in bits./// This can represent a bit length that isn't a whole number of bytes.from_byte_len/// Constructs a `BitLength` from the given length in bytes./// Fails if `bytes * 8` is too large for a `T`./// Constructs a `BitLength` from the given length in bits./// The number of bits this bit length represents, as the underlying type.half_rounded_upas_usize_bytes_rounded_up/// The bit length, rounded up to a whole number of bytes.try_sub_1// Lengths measured in bits, where all arithmetic is guaranteed not to// overflow._TEST_AS_USIZE_BYTES_ROUNDED_UP_EVEN_TEST_AS_USIZE_BYTES_ROUNDED_UP_ONE_BIT_HIGH_TEST_AS_USIZE_BYTES_ROUNDED_UP_SEVEN_BITS_HIGH//! Bit lengths./// An `int` returned from a foreign function containing **1** if the function/// was successful or **0** if an error occurred. This is the convention used by/// C code in `ring`.size_and_alignmentsemantics// Copyright 2015 Brian Smith.// Copyright 2016-2019 Brian Smith.//! C types.//! Avoid using the `libc` crate to get C types since `libc` doesn't support//! all the targets we need to support. It turns out that the few types we need//! are all uniformly defined on the platforms we care about. This will//! probably change if/when we support 16-bit platforms or platforms where//! `usize` and `uintptr_t` are different sizes.//! TODO(MSRV, feature(c_size_t)): Use `core::{ffi::c_size_t}`.//! TODO(MSRV-1.79): Use `NonZero<c_size_t>`.// Keep in sync with the checks in base.h that verify these assumptions.PMullCAPS_STATICcstrMIN_STATIC_FEATURES// $ rustc +1.61.0 --print cfg --target=aarch64-apple-ios | grep -E "neon|aes|sha|pmull"// target_feature="aes"// target_feature="neon"// target_feature="sha2"// $ rustc +1.61.0 --print cfg --target=aarch64-apple-darwin | grep -E "neon|aes|sha|pmull"// target_feature="sha3"// XXX/TODO(coverage)/TODO(size): aarch64-apple-darwin is statically guaranteed to have "sha3" but// other aarch64-apple-* targets require dynamic detection. Since we don't have test coverage for// the other targets yet, we wouldn't have a way of testing the dynamic detection if we statically// enabled `Sha512` for -darwin. So instead, temporarily, we statically ignore the static// availability of the feature on -darwin so that it runs the dynamic detection.FORCE_DYNAMIC_DETECTION_AARCH64_APPLE_TARGETS_EXPECTED_FEATURES// MSRV: Enforce 1.61.0 onaarch64-apple-*, in particular) prior to. Earlier// versions of Rust before did not report the AAarch64 CPU features correctly// for these targets. Cargo.toml specifies `rust-version` but versions before// Rust 1.56 don't know about it._AARCH64_APPLE_DARWIN_TARGETS_EXPECTED_FEATURES// Ensure we don't accidentally allow features statically beyond// `MIN_STATIC_FEATURES` so that dynamic detection is done uniformly for// all of these targets.detect_featuressha512_detection// Copyright 2016-2024 Brian Smith.// Work around a bug in LLVM/rustc where `-C target_cpu=cortex-a72`--// and `-C target_cpu=native` on Cortex-A72 Raspberry PI devices in// particular--enables crypto features even though not all Cortex-A72// CPUs have crypto features:// $ rustc --print cfg --target=aarch64-unknown-linux-gnu | grep feature// $ rustc --print cfg --target=aarch64-unknown-linux-gnu -C target_cpu=cortex-a72 | grep feature// target_feature="crc"// target_feature="pmuv3"// XXX/TODO(MSRV https://github.com/llvm/llvm-project/issues/90365): This// workaround is heavy-handed since it forces extra branches for devices that// have correctly-modeled feature sets, so it should be removed.// `uclibc` does not provide `getauxval` so just use static feature detection// for it.IsProcessorFeaturePresentPF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE_ASSUMED_POINTER_SIZE// TODO: Support ARM64_32; see// https://github.com/briansmith/ring/issues/1832#issuecomment-1892928147. This also requires// replacing all `cfg(target_pointer_width)` logic for non-pointer/reference things// (`N0`, `Limb`, `LimbMask`, `crypto_word_t` etc.)._ASSUMED_USIZE_SIZE_ASSUMED_REF_SIZE_ASSUMED_ENDIANNESS// To support big-endian, we'd need to make several changes as described in// https://github.com/briansmith/ring/issues/1832.abi_assumptionsimpl_get_featureFEATURESSTATIC_DETECTED// TODO(MSRV): There is no "pmull" feature listed from// `rustc --print cfg --target=aarch64-apple-darwin`. Originally ARMv8 tied// PMULL detection into AES detection, but later versions split it; see// https://developer.arm.com/downloads/-/exploration-tools/feature-names-for-a-profile// "Features introduced prior to 2020." Change this to use "pmull" when// that is supported.// "sha3" is overloaded for both SHA-3 and SHA-512.// TODO(MSRV): 32-bit ARM doesn't support any static feature detection yet.featureflags_AARCH64_HAS_NEON// uclibc: When linked statically, uclibc doesn't provide getauxval.// When linked dynamically, recent versions do provide it, but we// want to support older versions too. Assume that if uclibc is being// used, this is an embedded target where the user cares a lot about// minimizing code size and also that they know in advance exactly// what target features are supported, so rely only on static feature// detection._ASSUMES_SSE2// TOOD: Support targets that do not have SSE and SSE2 enabled, such as// x86_64-unknown-linux-none. See// https://github.com/briansmith/ring/issues/1793#issuecomment-1793243725,// https://github.com/briansmith/ring/issues/1832,// https://github.com/briansmith/ring/issues/1833.// Limited to x86_64-v2 features.// TODO: Add missing x86-64-v3 features if we find real-world use of x86-64-v3.// TODO: Add all features we use.cpuid_to_caps_and_set_c_flagsget_featureShaIntelCpu// Copyright 2016-2021 Brian Smith./// A witness indicating that CPU features have been detected and cached./// This is a zero-sized type so that it can be "stored" wherever convenient.new_after_feature_flags_written_and_synced_unchecked_FORCE_DYNAMIC_DETECTION_HONOREDtest_static_is_subset_of_dynamic// Generates an implementation of the Debug trait for a type that defers to the// Debug implementation for a given field.derive_debug_self_as_ref_hex_bytes// Generates an implementation of the Debug trait for a type that outputs the// hex encoding of the byte slice representation of the value.write_hex_tupleHexStrwrite_hex_bytes// Copyright 2018 Trent Clarke.test_file/// References a test input file.compile_time_assert_clonecompile_time_assert_copycompile_time_assert_eqcompile_time_assert_sendcompile_time_assert_syncFixedByteRandomFixedSliceRandomFixedSliceSequenceRandomDynStateState64As64State32As32// Invariant: When constructed with `new32` (resp. `new64`), `As32` (resp.// `As64`) is the active variant.// Invariant: The active variant never changes after initialization.new32new64sha1_block_data_ordersha256_block_data_ordersha512_block_data_order// Copyright 2015-2019 Brian Smith.majBlockLenOutputLenCHAINING_LENOUTPUT_LENCHAINING_WORDSW32// FIPS 180-4 4.1.1block_data_orderstep3rotl// Copyright 2016 Simon Sapin.Sha2BYTES_LENInputBytes// FIPS 180-4 {4.1.1, 4.1.2, 4.1.3}SIGMA_0// FIPS 180-4 {4.1.2, 4.1.3}SIGMA_1sigma_0sigma_1rotr// Commonality between SHA-1 and SHA-2 words.BIG_SIGMA_0BIG_SIGMA_1SMALL_SIGMA_0SMALL_SIGMA_1zero_w/// A SHA-2 input word.// FIPS 180-4 4.1.2// FIPS 180-4 {6.2.2} Step 1// FIPS 180-4 4.2.2// SHA-256// FIPS 180-4 4.1.3// FIPS 180-4 {6.4.2} Step 1// FIPS 180-4 4.2.3// SHA-384 and SHA-512// Copyright 2019-2025 Brian Smith.sha2_ffi/// `unsafe { T => f }` means it is safe to call `f` iff we can constructsha2_32_ffisha2_64_ffisha2_32block_data_order_32SHA256_BLOCK_LENsha2_64block_data_order_64SHA512_BLOCK_LEN// Copyright 2019-2024 Brian Smith.dynstatefinish_errorcompleted_bytes// Note that SHA-512 has a 128-bit input bit counter, but this// implementation only supports up to 2^64-1 input bits for all algorithms,// so a 64-bit counter is more than sufficient./// The context's algorithm.BlockContext/// Processes all the full blocks in `input`, returning the partial block/// at the end, which may be empty.MAX_BLOCK_LEN// On input, `block[..num_pending]` is the (possibly-empty) last *partial*// chunk of input. It *must* be partial; that is, it is required that// `num_pending < self.algorithm.block_len`.// `block` may be arbitrarily overwritten.InputTooLongPendingNotAPartialBlockinput_too_longpending_not_a_partial_block_innerpending_not_a_partial_block// TODO: More explicitly force 64-bit alignment for |pending|.num_pending// Invariant: `self.num_pending < self.block.algorithm.block_len`./// A context for multi-step (Init-Update-Finish) digest calculations./// use ring::digest;/// let one_shot = digest::digest(&digest::SHA384, b"hello, world");/// let mut ctx = digest::Context::new(&digest::SHA384);/// ctx.update(b"hello");/// ctx.update(b", ");/// ctx.update(b"world");/// let multi_part = ctx.finish();/// assert_eq!(&one_shot.as_ref(), &multi_part.as_ref());/// Constructs a new context./// Updates the digest with all the data in `data`./// Finalizes the digest calculation and returns the digest value./// `finish` consumes the context so it cannot be (mis-)used after `finish`/// has been called./// The algorithm that this context is using./// Returns the digest of `data` using the given digest algorithm./// A calculated digest value./// Use [`Self::as_ref`] to get the value as a `&[u8]`.compute_from/// The algorithm that was used to calculate the digest value.output_lenchaining_len/// `block_data_order` processes all the full blocks of data in `data`. It/// returns the number of bytes processed and the unprocessed data, which/// is guaranteed to be less than `block_len` bytes long./// A digest algorithm.SHA512_256/// The internal block length./// The size of the chaining value of the digest function, in bytes./// For non-truncated algorithms (SHA-1, SHA-256, SHA-512), this is equal/// to [`Self::output_len()`]. For truncated algorithms (e.g. SHA-384,/// SHA-512/256), this is equal to the length before truncation. This is/// mostly helpful for determining the size of an HMAC key that is/// appropriate for the digest algorithm./// The length of a finalized digest.SHA1_FOR_LEGACY_USE_ONLY/// SHA-1 as specified in [FIPS 180-4]. Deprecated./// [FIPS 180-4]: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf/// SHA-256 as specified in [FIPS 180-4]./// SHA-384 as specified in [FIPS 180-4]./// SHA-512 as specified in [FIPS 180-4]./// SHA-512/256 as specified in [FIPS 180-4]./// This is *not* the same as just truncating the output of SHA-512, as/// SHA-512/256 has its own initial state distinct from SHA-512's initialMAX_OUTPUT_LEN/// The maximum block length ([`Algorithm::block_len()`]) of all the algorithms/// in this module./// The maximum output length ([`Algorithm::output_len()`]) of all the/// algorithms in this module.MAX_CHAINING_LEN/// The maximum chaining length ([`Algorithm::chaining_len()`]) of all theSHA1_OUTPUT_LEN/// The length of the output of SHA-1, in bytes.SHA256_OUTPUT_LEN/// The length of the output of SHA-256, in bytes.SHA384_OUTPUT_LEN/// The length of the output of SHA-384, in bytes.SHA512_OUTPUT_LEN/// The length of the output of SHA-512, in bytes.SHA512_256_OUTPUT_LEN/// The length of the output of SHA-512/256, in bytes._512_1024// MAXlen_lenLenLen_64_128_160_256_384max_input_testsmax_input_testtoo_long_input_test_blocktoo_long_input_test_bytenearly_full_contextmax_input//! SHA-2 and the legacy SHA-1 digest algorithm.//! If all the data is available in a single contiguous slice then the `digest`//! function should be used. Otherwise, the digest can be calculated in//! multiple steps using `Context`.eddsa_digestED25519_PUBLIC_KEY_LENSigningKeyPairprivate_scalar// RFC 8032 Section 5.1.6 calls this *s*.private_prefix// RFC 8032 Section 5.1.6 calls this *prefix*.// RFC 8032 Section 5.1.5 calls this *A*./// An Ed25519 key pair, for signing.generate_pkcs8/// Generates a new key pair and returns the key pair serialized as a/// PKCS#8 document./// The PKCS#8 document will be a v2 `OneAsymmetricKey` with the public key,/// as described in [RFC 5958 Section 2]; see [RFC 8410 Section 10.3] for an/// example./// [RFC 5958 Section 2]: https://tools.ietf.org/html/rfc5958#section-2/// [RFC 8410 Section 10.3]: https://tools.ietf.org/html/rfc8410#section-10.3/// Constructs an Ed25519 key pair by parsing an unencrypted PKCS#8 v2/// Ed25519 private key./// `openssl genpkey -algorithm ED25519` generates PKCS# v1 keys, which/// require the use of `Ed25519KeyPair::from_pkcs8_maybe_unchecked()`/// instead of `Ed25519KeyPair::from_pkcs8()`./// The input must be in PKCS#8 v2 format, and in particular it must contain/// the public key in addition to the private key. `from_pkcs8()` will/// verify that the public key and the private key are consistent with each/// Some early implementations of PKCS#8 v2, including earlier versions of/// *ring* and other implementations, wrapped the public key in the wrong/// ASN.1 tags. Both that incorrect form and the standardized form are/// If you need to parse PKCS#8 v1 files (without the public key) then use/// `Ed25519KeyPair::from_pkcs8_maybe_unchecked()` instead.from_pkcs8_maybe_unchecked/// Constructs an Ed25519 key pair by parsing an unencrypted PKCS#8 v1 or v2/// `openssl genpkey -algorithm ED25519` generates PKCS# v1 keys./// It is recommended to use `Ed25519KeyPair::from_pkcs8()`, which accepts/// only PKCS#8 v2 files that contain the public key./// `from_pkcs8_maybe_unchecked()` parses PKCS#2 files exactly like/// `from_pkcs8()`. It also accepts v1 files. PKCS#8 v1 files do not contain/// the public key, so when a v1 file is parsed the public key will be/// computed from the private key, and there will be no consistency check/// between the public key and the private key./// PKCS#8 v2 files are parsed exactly like `Ed25519KeyPair::from_pkcs8()`.from_seed_and_public_key/// Constructs an Ed25519 key pair from the private key seed `seed` and its/// public key `public_key`./// It is recommended to use `Ed25519KeyPair::from_pkcs8()` instead./// The private and public keys will be verified to be consistent with each/// other. This helps avoid misuse of the key (e.g. accidentally swapping/// the private key and public key, or using the wrong private key for the/// public key). This also detects any corruption of the public or privatefrom_seed_unchecked/// Constructs a Ed25519 key pair from the private key seed `seed`./// It is recommended to use `Ed25519KeyPair::from_pkcs8()` instead. When/// that is not practical, it is recommended to use/// `Ed25519KeyPair::from_seed_and_public_key()` instead./// Since the public key is not given, the public key will be computed from/// the private key. It is not possible to detect misuse or corruption of/// the private key since the public key isn't given as input.from_seed_/// Returns the signature of the message `msg`.unwrap_pkcs8PREFIX_LENSEED_LENPKCS8_TEMPLATETemplate//! EdDSA Signatures./// Parameters for EdDSA signing and verification./// Verification of [Ed25519] signatures./// Ed25519 uses SHA-512 as the digest algorithm./// [Ed25519]: https://ed25519.cr.yp.to/VerificationAlgorithmx25519_ge_double_scalarmult_vartimeExtPointELEM_LENverification/// The length of an Ed25519 public key.MaskedScalarSCALAR_LENELEM_LIMBS// This is called `v` in the C code.// Elem<T>` is `fe` in curve25519/internal.h.// Elem<L> is `fe_loose` in curve25519/internal.h.// Keep this in sync with curve25519/internal.h.// An encoding of a curve point. If on Curve25519, it should be encoded as// described in Section 5 of [RFC 7748]. If on Edwards25519, it should be// encoded as described in section 5.1.2 of [RFC 8032].// [RFC 7748] https://tools.ietf.org/html/rfc7748#section-5// [RFC 8032] https://tools.ietf.org/html/rfc8032#section-5.1.2// Keep this in sync with `ge_p3` in curve25519/internal.h.from_scalarmult_base// Returns the result of multiplying the base point by the scalar in constant time.from_encoded_point_vartimeinto_encoded_point// Keep this in sync with `ge_p2` in curve25519/internal.h.new_at_infinityencode_pointhas_fe25519_adxx25519_fe_invertx25519_fe_isnegativex25519_fe_mul_tttx25519_fe_negx25519_fe_tobytesx25519_ge_frombytes_vartime//! Elliptic curve operations on the birationally equivalent curves Curve25519//! and Edwards25519.from_bytes_checked// Constructs a `Scalar` from `bytes`, failing if `bytes` encodes a scalar// that is not in the range [0, n).from_sha512_digest_reduced// Constructs a `Scalar` from `digest` reduced modulo n.from_bytes_maskedUnreducedScalarUNREDUCED_SCALAR_LENagreementCURVE25519/// X25519 (ECDH using Curve25519) as described in [RFC 7748]./// Everything is as described in RFC 7748. Key agreement will fail if the/// result of the X25519 operation is zero; see the notes on the/// "all-zero value" in [RFC 7748 section 6.1]./// [RFC 7748]: https://tools.ietf.org/html/rfc7748/// [RFC 7748 section 6.1]: https://tools.ietf.org/html/rfc7748#section-6.1x25519_check_private_key_bytesx25519_generate_private_keyx25519_public_from_privatex25519_ecdhELEM_AND_SCALAR_LENPrivateKeyPRIVATE_KEY_LENPUBLIC_KEY_LEN// An X25519 public key as an encoded Curve25519 point.SHARED_SECRET_LEN// An X25519 shared secret as an encoded Curve25519 point.test_x25519_public_from_private//! X25519 Key agreement.//! Elliptic curve operations and schemes using Curve25519.ELEM_MAX_BYTESSEED_MAX_BYTESbytes_less_safePUBLIC_KEY_MAX_LEN/// The maximum length, in bytes, of an encoded public key.suite_b_curver" Public keys are encoding in uncompressed form using the"r" Octet-String-to-Elliptic-Curve-Point algorithm in"r" [SEC 1: Elliptic Curve Cryptography, Version 2.0]. Public keys are"r" validated during key agreement according to"r" [NIST Special Publication 800-56A, revision 2] and Appendix B.3 of"r" the NSA's [Suite B Implementer's Guide to NIST SP 800-56A]."r" [SEC 1: Elliptic Curve Cryptography, Version 2.0]:"r"     http://www.secg.org/sec1-v2.pdf"r" [NIST Special Publication 800-56A, revision 2]:"r"     http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar2.pdf"r" [Suite B Implementer's Guide to NIST SP 800-56A]:"r"     https://github.com/briansmith/ring/blob/main/doc/ecdh.pdf"p256_check_private_key_bytesp256_generate_private_keyp256_public_from_privatep384_check_private_key_bytesp384_generate_private_keyp384_public_from_private"ECDH using the NSA Suite B""P-256 (secp256r1)""curve."p256_ecdh"P-384 (secp384r1)"p384_ecdhPrivateKeyOpsPublicKeyOpsSUPPORTED_SUITE_B_ALGSCommonOpstest_agreement_suite_b_ecdh_generate//! ECDH key agreement using the P-256 and P-384 curves.digest_scalar/// Calculate the digest of `msg` using the digest algorithm `digest_alg`. Then/// convert the digest to a scalar in the range [0, n) as described in/// NIST's FIPS 186-4 Section 4.2. Note that this is one of the few cases where/// a `Scalar` is allowed to have the value zero./// NIST's FIPS 186-4 4.2 says "When the length of the output of the hash/// function is greater than N (i.e., the bit length of q), then the leftmost N/// bits of the hash function output block shall be used in any calculation/// using the hash function output during the generation or verification of a/// digital signature."/// "Leftmost N bits" means "N most significant bits" because we interpret the/// digest as a bit-endian encoded integer./// The NSA guide instead vaguely suggests that we should convert the digest/// value to an integer and then reduce it mod `n`. However, real-world/// implementations (e.g. `digest_to_bn` in OpenSSL and `hashToInt` in Go) do/// what FIPS 186-4 says to do, not what the NSA guide suggests./// Why shifting the value right by at most one bit is sufficient: P-256's `n`/// has its 256th bit set; i.e. 2**255 < n < 2**256. Once we've truncated the/// digest to 256 bits and converted it to an integer, it will have a value/// less than 2**256. If the value is larger than `n` then shifting it one bit/// right will give a value less than 2**255, which is less than `n`. The/// analogous argument applies for P-384. However, it does *not* apply in/// general; for example, it doesn't apply to P-521.digest_bytes_scalardigest_scalar_// This is a separate function solely so that we can test specific digest// values like all-zero values and values larger than `n`.//! ECDSA Signatures using the P-256 and P-384 curves.private_scalar_opsPrivateScalarOpsprivate_key_opspkcs8_templateformat_rsScalarOps/// An ECDSA signing algorithm.ECDSA_P384_SHA384_FIXED_SIGNINGECDSA_P256_SHA256_ASN1_SIGNINGECDSA_P384_SHA384_ASN1_SIGNINGnonce_keyNonceRandomKey/// An ECDSA key pair, used for signing./// The PKCS#8 document will be a v1 `OneAsymmetricKey` with the public key/// included in the `ECPrivateKey` structure, as described in/// [RFC 5958 Section 2] and [RFC 5915]. The `ECPrivateKey` structure will/// not have a `parameters` field so the generated key is compatible with/// PKCS#11./// [RFC 5915]: https://tools.ietf.org/html/rfc5915/// Constructs an ECDSA key pair by parsing an unencrypted PKCS#8 v1/// id-ecPublicKey `ECPrivateKey` key./// The input must be in PKCS#8 v1 format. It must contain the public key in/// the `ECPrivateKey` structure; `from_pkcs8()` will verify that the public/// key and the private key are consistent with each other. The algorithm/// identifier must identify the curve by name; it must not use an/// "explicit" encoding of the curve. The `parameters` field of the/// `ECPrivateKey`, if present, must be the same named curve that is in the/// algorithm identifier in the PKCS#8 header.from_private_key_and_public_key/// Constructs an ECDSA key pair from the private key and public key bytes/// The private key must encoded as a big-endian fixed-length integer. For/// example, a P-256 private key must be 32 bytes prefixed with leading/// zeros as needed./// The public key is encoding in uncompressed form using the/// Octet-String-to-Elliptic-Curve-Point algorithm in/// [SEC 1: Elliptic Curve Cryptography, Version 2.0]./// This is intended for use by code that deserializes key pairs. It is/// recommended to use `EcdsaKeyPair::from_pkcs8()` (with a PKCS#8-encoded/// key) instead./// [SEC 1: Elliptic Curve Cryptography, Version 2.0]:///     http://www.secg.org/sec1-v2.pdf/// Returns the signature of the `message` using a random nonce generated by `rng`.sign_with_fixed_nonce_during_testsign_digest/// Returns the signature of message digest `h` using a "random" nonce/// generated by `rng`.message_digestNonceRandom/// Generates an ECDSA nonce in a way that attempts to protect against a faulty/// `SecureRandom`.fill_implformat_rs_fixedformat_rs_asn1/// Signing of fixed-length (PKCS#11 style) ECDSA signatures using the/// P-256 curve and SHA-256./// See "`ECDSA_*_FIXED` Details" in `ring::signature`'s module-level/// documentation for more details./// P-384 curve and SHA-384./// Signing of ASN.1 DER-encoded ECDSA signatures using the P-256 curve and/// SHA-256./// See "`ECDSA_*_ASN1` Details" in `ring::signature`'s module-level/// Signing of ASN.1 DER-encoded ECDSA signatures using the P-384 curve and/// SHA-384.EC_PUBLIC_KEY_P256_PKCS8_V1_TEMPLATEEC_PUBLIC_KEY_P384_PKCS8_V1_TEMPLATEsignature_ecdsa_sign_fixed_testsignature_ecdsa_sign_asn1_testverify_jacobian_point_is_on_the_curvePublicScalarOpssplit_rsEcdsaVerificationAlgorithm/// An ECDSA verification algorithm.ECDSA_P256_SHA256_ASN1ECDSA_P256_SHA256_FIXEDECDSA_P256_SHA384_ASN1ECDSA_P384_SHA256_ASN1ECDSA_P384_SHA384_ASN1ECDSA_P384_SHA384_FIXED/// This is intentionally not public.split_rs_fixedsplit_rs_asn1/// Verification of fixed-length (PKCS#11 style) ECDSA signatures using the/// Verification of ASN.1 DER-encoded ECDSA signatures using the P-256 curve/// and SHA-256./// *Not recommended*. Verification of ASN.1 DER-encoded ECDSA signatures using/// the P-256 curve and SHA-384./// In most situations, P-256 should be used only with SHA-256 and P-384/// should be used only with SHA-384. However, in some cases, particularly TLS/// on the web, it is necessary to support P-256 with SHA-384 for compatibility/// with widely-deployed implementations that do not follow these guidelines./// the P-384 curve and SHA-256./// Verification of ASN.1 DER-encoded ECDSA signatures using the P-384 curve/// and SHA-384.test_digest_based_test_vectorsNUM_LIMBSP256_NUM_LIMBSP384_NUM_LIMBSNumLimbs// XXX: pub/// The modulus *m* for the ring ℤ/mℤ for which this element is a value./// Elements of ℤ/mℤ for some modulus *m*. Elements are always fully reduced/// with respect to *m*; i.e. the 0 <= x < m for every value x.PublicElem// There's no need to convert `value` to the Montgomery domain since// 0 * R**2 (mod m) == 0, so neither the modulus nor the encoding are needed// as inputs for constructing a zero-valued element.EAEBmul_montERbinary_op// let r = f(a, b); return r;binary_op_assign// a := f(a, b);// let r = f(a); return r;unary_op_assign// a := f(a);unary_op_from_binary_op_assign// a := f(a, a);// Copyright 2017 Brian Smith.elem_sqr_mulelem_sqr_mul_accCOMMON_OPSPRIVATE_KEY_OPSp256_elem_inv_squaredp256_point_mul_base_implPUBLIC_KEY_OPSSCALAR_OPSPUBLIC_SCALAR_OPStwin_mul_nistz256point_mul_base_vartimePRIVATE_SCALAR_OPSp256_scalar_inv_to_montp256_mul_montp256_sqr_montp256_point_addp256_point_mulp256_scalar_mul_montp256_scalar_sqr_rep_montp256_point_mul_base_vartime_test// Copyright 2016-2023 Brian Smith.p384_elem_inv_squaredp384_point_mul_base_implp384_scalar_inv_to_montp384_elem_sqr_mont// [COMMON_OPS.num_limbs]p384_elem_mul_montp384_point_addp384_point_mulp384_scalar_mul_mont/// A field element, i.e. an element of ℤ/qℤ for the curve's field modulus/// *q*./// Represents the (prime) order *q* of the curve's prime field./// A scalar. Its value is in [0, n). Zero-valued scalars are forbidden in mostPublicScalar/// Represents the prime order *n* of the curve's group.// TODO: [Limb; elem::NumLimbs::MAX]num_limbscopsxyz// The coordinates are stored in a contiguous array, where the first// `ops.num_limbs` elements are the X coordinate, the next// `ops.num_limbs` elements are the Y coordinate, and the next// `ops.num_limbs` elements are the Z coordinate. This layout is dictated// by the requirements of the nistz256 code.// Must be -3 mod qelem_mul_mont// In all cases, `r`, `a`, and `b` may all alias each other.elem_sqr_mont/// Operations and values needed by all curve operations.elem_modulusscalar_modulus// The length of a field element, which is the same as the length of a// scalar, in bytes.n_limbs// Keep in sync with `CommonOps::len()`.elems_are_equalLimbMaskelem_unencodedelem_productelem_squareelem_verify_is_not_zeropoint_sumpoint_xpoint_ypoint_zrrelem_inv_squaredpoint_mul_base_implpoint_mul_impl// [3][num_limbs]// [num_limbs]point_add_jacobian_impl/// Operations on private keys, for ECDH and ECDSA signing.leak_limbspoint_mul_basepoint_mulelem_inverse_squared/// Operations and values needed by all operations on public keys (ECDH/// agreement and ECDSA verification).elem_parse// The serialized bytes are in big-endian order, zero-padded. The limbs// of `Elem` are in the native endianness, least significant limb to// most significant limb. Besides the parsing, conversion, this also// implements NIST SP 800-56A Step 2: "Verify that xQ and yQ are integers// in the interval [0, p-1] in the case that q is an odd prime p[.]"scalar_mul_mont// Operations used by both ECDSA signing and ECDSA verification. In general// these must be side-channel resistant.scalar_bytes_len// The (maximum) length of a scalar, not including any padding.scalar_productscalar_opspublic_key_opstwin_mulscalar_inv_to_mont_vartimeq_minus_n/// Operations on public scalars needed by ECDSA signature verification.scalar_as_elemelem_less_than_vartimeoneRR_mod_nscalar_inv_to_mont// 1 * R**2 (mod n). TOOD: Use One<RR>.to_mont/// Returns the modular inverse of `a` (mod `n`). Panics if `a` is zero.twin_mul_inefficient// XXX: Inefficient and unnecessarily depends on `PrivateKeyOps`. TODO: implement interleaved wNAF// multiplication.elem_reduced_to_scalar// This assumes n < q < 2*n.// Returns (`a` squared `squarings` times) * `b`.// Sets `acc` = (`acc` squared `squarings` times) * `b`.elem_parse_big_endian_fixed_consttimescalar_parse_big_endian_fixed_consttimescalar_parse_big_endian_variableAllowZeroscalar_parse_big_endian_partially_reduced_variable_consttimeparse_big_endian_fixed_consttimeZERO_SCALARq_minus_n_plus_n_equals_0_testp256_q_minus_n_plus_n_equals_0_testp384_q_minus_n_plus_n_equals_0_testp256_elem_add_testp384_elem_add_testelem_add_testp384_elem_sub_testelem_sub_testp384_elem_div_by_2_testelem_div_by_2_testp256_elem_neg_test// There is no `ecp_nistz256_neg` on other targets.p384_elem_neg_testelem_neg_testp256_elem_mul_testp384_elem_mul_testelem_mul_testp256_scalar_mul_testp384_scalar_mul_testscalar_mul_testp256_scalar_square_testscalar_square_testp256_scalar_inv_to_mont_zero_panic_testp384_scalar_inv_to_mont_zero_panic_testp256_point_sum_testp384_point_sum_testpoint_sum_testp256_point_sum_mixed_testpoint_sum_mixed_test// [ops.num_limbs*3]// [ops.num_limbs*2]p256_point_double_testp384_point_double_testpoint_double_testp256_point_mul_test/// TODO: We should be testing `point_mul` with points other than the generator.p384_point_mul_testp256_point_mul_serialized_testpoint_mul_serialized_testp256_point_mul_base_testp384_point_mul_base_testpoint_mul_base_testsassert_point_actual_equals_expectedTestPointconsume_jacobian_pointconsume_affine_pointconsume_point_elemconsume_pointassert_elems_are_equalassert_limbs_are_equalconsume_scalarconsume_scalar_mont// XXX: There's no `p256_sub` in *ring*; it's logic is inlined into// the point arithmetic functions. Thus, we can't test it.// XXX: There's no `p256_div_by_2` in *ring*; it's logic is inlined// into the point arithmetic functions. Thus, we can't test it.// XXX: There's no `p384_scalar_square_test()` because there's no dedicated// `p384_scalar_sqr_rep_mont()`.// XXX: There is no `nistz384_point_add_affine()`.verify_affine_point_is_on_the_curverandom_scalar/// Generates a random scalar in the range [1, n).generate_private_scalar_bytesprivate_key_as_scalar// The underlying X25519 and Ed25519 code uses an [u8; 32] to store the private// key. To make the ECDH and ECDSA code similar to that, we also store the// private key that way, which means we have to convert it to a Scalar whenever// we need to use it.check_scalar_big_endian_bytesscalar_from_big_endian_bytes// Parses a fixed-length (zero-padded) big-endian-encoded scalar in the range// [1, n). This is intended to be constant-time with respect to the actual// value *only if* the value is actually in range. In other words, this won't// leak anything about a valid value, but it might leak small amounts of// information about an invalid value (which constraint it failed).public_from_privateaffine_from_jacobianbig_endian_affine_from_jacobian//! Functionality shared by operations on private keys (ECC keygen and//! ECDSA signing).parse_uncompressed_point/// Parses a public key encoded in uncompressed form. The key is validated/// using the ECC Partial Public-Key Validation Routine from/// [NIST SP 800-56A, revision 2] Section 5.6.2.3.3, the NSA's/// "Suite B Implementer's Guide to NIST SP 800-56A," Appendix B.3, and the/// NSA's "Suite B Implementer's Guide to FIPS 186-3 (ECDSA)," Appendix A.3./// [NIST SP 800-56A, revision 2]:///     http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar2.pdfparse_uncompressed_point_testpublic_key_ops_from_curve_name//! Functionality shared by operations on public keys (ECDSA verification and//! ECDH agreement).// NIST SP 800-56A Step 3: "If q is an odd prime p, verify that// yQ**2 = xQ**3 + axQ + b in GF(p), where the arithmetic is performed modulo// p."// That is, verify that (x, y) is on the curve, which is true iif://     y**2 == x**3 + a*x + b (mod q)// Or, equivalently, but more efficiently://     y**2 == (x**2 + a)*x + b  (mod q)// Use `verify_affine_point_is_on_the_curve` instead of this function whenever// the affine coordinates are available or will become available. This function// should only be used then the affine coordinates are never calculated. See// the notes for `verify_affine_point_is_on_the_curve_scaled`.// The value `z**2` is returned on success because it is useful for ECDSA// verification.// This function also verifies that the point is not at infinity.verify_affine_point_is_on_the_curve_scaled// Handles the common logic of point-is-on-the-curve checks for both affine and// Jacobian cases.// When doing the check that the point is on the curve after a computation,// to avoid fault attacks or mitigate potential bugs, it is better for security// to use `verify_affine_point_is_on_the_curve` on the affine coordinates,// because it provides some protection against faults that occur in the// computation of the inverse of `z`. See the paper and presentation "Fault// Attacks on Projective-to-Affine Coordinates Conversion" by Diana Maimuţ,// Cédric Murdica, David Naccache, Mehdi Tibouchi. That presentation concluded// simply "Check the validity of the result after conversion to affine// coordinates." (It seems like a good idea to verify that// z_inv * z == 1 mod q too).// In the case of affine coordinates (x, y), `a_scaled` and `b_scaled` are// `a` and `b`, respectively. In the case of Jacobian coordinates (x, y, z),// the computation and comparison is the same, except `a_scaled` and `b_scaled`// are (z**4 * a) and (z**6 * b), respectively. Thus, performance is another// reason to prefer doing the check on the affine coordinates, as Jacobian// computation requires 3 extra multiplications and 2 extra squarings.// An example of a fault attack that isn't mitigated by a point-on-the-curve// check after multiplication is given in "Sign Change Fault Attacks On// Elliptic Curve Cryptosystems" by Johannes Blömer, Martin Otto, and// Jean-Pierre Seifert.key_pair_from_pkcs8key_pair_from_pkcs8_key_pair_from_bytes//! Elliptic curve operations on P-256 & P-384.public_key_lenelem_scalar_seed_lenCurveIDcheck_private_key_bytes// Precondition: `bytes` is the correct length.generate_private_keyCurve25519ELEM_MAX_BITSSCALAR_MAX_BYTESPKCS8_DOCUMENT_MAX_LEN/// The maximum length of a PKCS#8 documents generated by *ring* for ECC keys./// This is NOT the maximum length of a PKCS#8 document that can be consumed by/// `pkcs8::unwrap_key()`./// `40` is the length of the P-384 template. It is actually one byte shorter/// than the P-256 template, but the private key and the public key are much/// longer.imprecise_input_length/// Note that this might not actually be the (exact) length of the input,/// and its units might be lost. For example, it could be any of the///    * The length in bytes of the entire input.///    * The length in bytes of some *part* of the input.///    * A bit length.///    * A length in terms of "blocks" or other grouping of input values.///    * Some intermediate quantity that was used when checking the input///      length.///    * Some arbitrary value.EndOfInput/// An error parsing or validating a key./// The `Display` implementation will return a string that will help you better/// understand why a key was rejected change which errors are reported in which/// situations while minimizing the likelihood that any applications will be/// broken./// Here is an incomplete list of reasons a key may be unsupported:/// * Invalid or Inconsistent Components: A component of the key has an invalid///   value, or the mathematical relationship between two (or more) components///   required for a valid key does not hold./// * The encoding of the key is invalid. Perhaps the key isn't in the correct///   format; e.g. it may be Base64 ("PEM") encoded, in which case   the Base64///   encoding needs to be undone first./// * The encoding includes a versioning mechanism and that mechanism indicates///   that the key is encoded in a version of the encoding that isn't supported.///   This might happen for multi-prime RSA keys (keys with more than two///   private   prime factors), which aren't supported, for example./// * Too small or too Large: One of the primary components of the key is too///   small or two large. Too-small keys are rejected for security reasons. Some///   unnecessarily large keys are rejected for performance reasons.///  * Wrong algorithm: The key is not valid for the algorithm in which it was///    being used.///  * Unexpected errors: Report this as a bug.inconsistent_componentsinvalid_componentinvalid_encodingrng_failed// XXX: See the comment at the call site.public_key_is_missingtoo_largeversion_not_supportedwrong_algorithmprivate_modulus_len_not_multiple_of_512_bits//! Error reporting.key_rejectedunspecifiedlen_mismatch_errortoo_much_output_requestedTooMuchOutputRequestedErrorinto_unspecifiedimprecise_output_length/// An error with absolutely no details./// *ring* uses this unit type as the error type in most of its results/// because (a) usually the specific reasons for a failure are obvious or are/// not useful to know, and/or (b) providing more details about a failure might/// provide a dangerous side channel, and/or (c) it greatly simplifies the/// error handling logic./// `Result<T, ring::error::Unspecified>` is mostly equivalent to/// `Result<T, ()>`. However, `ring::error::Unspecified` implements/// [`std::error::Error`] and users of *ring* can implement/// `From<ring::error::Unspecified>` to map this to their own error types, as/// described in [“Error Handling” in the Rust Book]:/// use ring::rand::{self, SecureRandom};/// enum Error {///     CryptoError,/// #  #[cfg(feature = "alloc")]///     IOError(std::io::Error),///     // [...]/// impl From<ring::error::Unspecified> for Error {///     fn from(_: ring::error::Unspecified) -> Self { Error::CryptoError }/// fn eight_random_bytes() -> Result<[u8; 8], Error> {///     let rng = rand::SystemRandom::new();///     let mut bytes = [0; 8];///     // The `From<ring::error::Unspecified>` implementation above makes this///     // equivalent to///     // `rng.fill(&mut bytes).map_err(|_| Error::CryptoError)?`.///     rng.fill(&mut bytes)?;///     Ok(bytes)/// assert!(eight_random_bytes().is_ok());/// Experience with using and implementing other crypto libraries like has/// shown that sophisticated error reporting facilities often cause significant/// bugs themselves, both within the crypto library and within users of the/// crypto library. This approach attempts to minimize complexity in the hopes/// of avoiding such problems. In some cases, this approach may be too extreme,/// and it may be important for an operation to provide some details about the/// cause of a failure. Users of *ring* are encouraged to report such cases so/// that they can be addressed individually./// [`std::error::Error`]: https://doc.rust-lang.org/std/error/trait.Error.html/// [“Error Handling” in the Rust Book]:///     https://doc.rust-lang.org/book/first-edition/error-handling.html#the-from-trait// This is required for the implementation of `std::error::Error`./// An HKDF algorithm.hmac_algorithm/// The underlying HMAC algorithm.HKDF_SHA1_FOR_LEGACY_USE_ONLY/// HKDF using HMAC-SHA-1. Obsolete.HKDF_SHA256/// HKDF using HMAC-SHA-256.HKDF_SHA384/// HKDF using HMAC-SHA-384.HKDF_SHA512/// HKDF using HMAC-SHA-512./// A salt for HKDF operations./// Constructs a new `Salt` with the given value based on the given digest/// Constructing a `Salt` is relatively expensive so it is good to reuse a/// `Salt` object instead of re-constructing `Salt`s with the same value./// The [HKDF-Extract] operation./// [HKDF-Extract]: https://tools.ietf.org/html/rfc5869#section-2.2/// The algorithm used to derive this salt./// The length that `Prk::expand()` should expand its input to./// The length of the OKM (Output Keying Material) for a `Prk::expand()` call./// A HKDF PRK (pseudorandom key).new_less_safe/// Construct a new `Prk` directly with the given value./// Usually one can avoid using this. It is useful when the application/// intentionally wants to leak the PRK secret, e.g. to implement/// `SSLKEYLOGFILE` functionality./// The [HKDF-Expand] operation./// [HKDF-Expand]: https://tools.ietf.org/html/rfc5869#section-2.3/// Fails if (and only if) `len` is too large.prklen_cached/// An HKDF OKM (Output Keying Material)/// Intentionally not `Clone` or `Copy` as an OKM is generally only safe to/// use once./// The `OkmLength` given to `Prk::expand()`./// Fills `out` with the output of the HKDF-Expand operation for the given/// Fails if (and only if) the requested output length is larger than 255/// times the size of the digest algorithm's output. (This is the limit/// imposed by the HKDF specification due to the way HKDF's counter is/// constructed.)fill_okm//! HMAC-based Extract-and-Expand Key Derivation Function.//! HKDF is specified in [RFC 5869].//! [RFC 5869]: https://tools.ietf.org/html/rfc5869/// An HMAC algorithm.digest_algorithm/// The digest algorithm this HMAC algorithm is based on.HMAC_SHA1_FOR_LEGACY_USE_ONLY/// HMAC using SHA-1. Obsolete.HMAC_SHA256/// HMAC using SHA-256.HMAC_SHA384/// HMAC using SHA-384.HMAC_SHA512/// HMAC using SHA-512./// An HMAC tag./// For a given tag `t`, use `t.as_ref()` to get the tag value as a byte slice./// A key to use for HMAC signing./// Generate an HMAC signing key using the given digest algorithm with a/// random value generated from `rng`./// The key will be `digest_alg.output_len` bytes long, based on the/// recommendation in [RFC 2104 Section 3]./// [RFC 2104 Section 3]: https://tools.ietf.org/html/rfc2104#section-3/// Construct an HMAC signing key using the given digest algorithm and key/// `key_value` should be a value generated using a secure random number/// generator (e.g. the `key_value` output by/// `SealingKey::generate_serializable()`) or derived from a random key by/// a key derivation function (e.g. `ring::hkdf`). In particular,/// `key_value` shouldn't be a password./// As specified in RFC 2104, if `key_value` is shorter than the digest/// algorithm's block length (as returned by `digest::Algorithm::block_len()`,/// not the digest length returned by `digest::Algorithm::output_len()`) then/// it will be padded with zeros. Similarly, if it is longer than the block/// length then it will be compressed using the digest algorithm./// You should not use keys larger than the `digest_alg.block_len` because/// the truncation described above reduces their strength to only/// `digest_alg.output_len * 8` bits. Support for such keys is likely to be/// removed in a future version of *ring*./// The digest algorithm for the key.VerifyError/// A context for multi-step (Init-Update-Finish) HMAC signing./// Use `sign` for single-step HMAC signing./// Constructs a new HMAC signing context using the given digest algorithm/// and key./// Updates the HMAC with all the data in `data`. `update` may be called/// zero or more times until `finish` is called./// Finalizes the HMAC calculation and returns the HMAC value. `sign`/// consumes the context so it cannot be (mis-)used after `sign` has been/// It is generally not safe to implement HMAC verification by comparing/// the return value of `sign` to a tag. Use `verify` for verification/// Calculates the HMAC of `data` using the key `key` in one step./// Use `Context` to calculate HMACs where the input is in multiple parts./// It is generally not safe to implement HMAC verification by comparing the/// return value of `sign` to a tag. Use `verify` for verification instead./// Calculates the HMAC of `data` using the signing key `key`, and verifies/// whether the resultant value equals `tag`, in one step./// This is logically equivalent to, but more efficient than, constructing a/// `Key` with the same value as `key` and then using `verify`./// The verification will be done in constant time to prevent timing attacks.// Theoretically somebody could have calculated a valid tag with a gigantic// input that we do not support. If we were to support every theoretically// valid input length, for *every* digest algorithm, then we could argue// that hitting the input length limit implies a mismatch since nobody// could have calculated such a tag with the given input.Mismatchhmac_signing_key_coverage// Make sure that `Key::generate` and `verify_with_own_key` aren't// completely wacky.//! HMAC is specified in [RFC 2104].//! After a `Key` is constructed, it can be used for multiple signing or//! verification operations. Separating the construction of the key from the//! rest of the HMAC operation allows the per-key precomputation to be done//! only once, instead of it being done in every HMAC operation.//! Frequently all the data to be signed in a message is available in a single//! contiguous piece. In that case, the module-level `sign` function can be//! used. Otherwise, if the input is in multiple parts, `Context` should be//! # Examples://! ## Signing a value and verifying it wasn't tampered with//! use ring::{hmac, rand};//! let key = hmac::Key::generate(hmac::HMAC_SHA256, &rng)?;//! let msg = "hello, world";//! let tag = hmac::sign(&key, msg.as_bytes());//! // [We give access to the message to an untrusted party, and they give it//! // back to us. We need to verify they didn't tamper with it.]//! hmac::verify(&key, msg.as_bytes(), tag.as_ref())?;//! ## Using the one-shot API://! use ring::{digest, hmac, rand};//! use ring::rand::SecureRandom;//! // The sender generates a secure key value and signs the message with it.//! // Note that in a real protocol, a key agreement protocol would be used to//! // derive `key_value`.//! let key_value: [u8; digest::SHA256_OUTPUT_LEN] = rand::generate(&rng)?.expose();//! let s_key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref());//! let tag = hmac::sign(&s_key, msg.as_bytes());//! // The receiver (somehow!) knows the key value, and uses it to verify the//! // integrity of the message.//! let v_key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref());//! hmac::verify(&v_key, msg.as_bytes(), tag.as_ref())?;//! ## Using the multi-part API://! let parts = ["hello", ", ", "world"];//! let mut key_value: [u8; digest::SHA384_OUTPUT_LEN] = rand::generate(&rng)?.expose();//! let s_key = hmac::Key::new(hmac::HMAC_SHA384, key_value.as_ref());//! let mut s_ctx = hmac::Context::with_key(&s_key);//! for part in &parts {//!     s_ctx.update(part.as_bytes());//! let tag = s_ctx.sign();//! let v_key = hmac::Key::new(hmac::HMAC_SHA384, key_value.as_ref());//! let mut msg = Vec::<u8>::new();//!     msg.extend(part.as_bytes());//! hmac::verify(&v_key, &msg.as_ref(), tag.as_ref())?;//! [RFC 2104]: https://tools.ietf.org/html/rfc2104CONSTRUCTED|// 0x30ContextSpecific1ContextSpecificConstructed0ContextSpecificConstructed1ContextSpecificConstructed3// `impl From<Tag> for u8` but as a `const fn`.expect_tag_and_get_valueread_tag_and_get_valuebit_string_with_no_unused_bitsbit_string_tagged_with_no_unused_bits// TODO: investigate taking decoder as a reference to reduce generated code// size.nonnegative_integersmall_nonnegative_integer/// Parse as integer with a value in the in the range [0, 255], returning its/// numeric value. This is typically used for parsing version numbers.positive_integer/// Parses a positive DER integer, returning the big-endian-encoded value,/// sans any leading zero byte.with_iZERO_INTEGERGOOD_POSITIVE_INTEGERS_SMALLGOOD_POSITIVE_INTEGERS_LARGEBAD_NONNEGATIVE_INTEGERStest_small_nonnegative_integertest_positive_integer//! Building blocks for parsing DER-encoded ASN.1 structures.//! This module contains the foundational parts of an ASN.1 DER parser.write_positive_integerAccumulatorTooLongErrorwrite_tlv/// A serialized positive integer.big_endian_without_leading_zero/// Returns the value, ordered from significant byte to least significant/// byte, without any leading zeros. The result is guaranteed to be/// non-empty.big_endian_without_leading_zero_as_input/// Returns the first byte./// Will not panic because the value is guaranteed to have at least onetest_from_be_bytes//! Serialization and deserialization.LengthMeasurementrequested_capacityder_writerpositiveprefixeddeprecated_constant_time/// Traits that are designed to only be implemented internally in *ring*.// Usage:// use crate::sealed;// pub trait MyType: sealed::Sealed {//     // [...]// impl sealed::Sealed for MyType {}deprecated_test//! # Feature Flags//! <table>//! <tr><th>Feature//!     <th>Description//! <tr><td><code>alloc (default)</code>//!     <td>Enable features that require use of the heap, RSA in particular.//! <tr><td><code>less-safe-getrandom-custom-or-rdrand</code>//!     <td>Treat user-provided ("custom") and RDRAND-based <code>getrandom</code>//!         implementations as secure random number generators (see//!         <code>SecureRandom</code>). This feature only works with//!         <code>os = "none"</code> targets. See//!         <a href="https://docs.rs/getrandom/0.2.10/getrandom/macro.register_custom_getrandom.html">//!             <code>register_custom_getrandom</code>//!         </a> and <a href="https://docs.rs/getrandom/0.2.10/getrandom/#rdrand-on-x86">//!             RDRAND on x86//!         </a> for additional details.//! <tr><td><code>less-safe-getrandom-espidf</code>//!     <td>Treat getrandom as a secure random number generator (see//!         <code>SecureRandom</code>) on the esp-idf target. While the esp-idf//!         target does have hardware RNG, it is beyond the scope of ring to//!         ensure its configuration. This feature allows ring to build//!         on esp-idf despite the likelihood that RNG is not secure.//!         This feature only works with <code>os = espidf</code> targets.//!         See <a href="https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html">//! <tr><td><code>std</code>//!     <td>Enable features that use libstd, in particular//!         <code>std::error::Error</code> integration. Implies `alloc`.//! <tr><td><code>wasm32_unknown_unknown_js</code>//!     <td>When this feature is enabled, for the wasm32-unknown-unknown target,//!         Web APIs will be used to implement features like `ring::rand` that//!         require an operating environment of some kind. This has no effect//!         for any other target. This enables the `getrandom` crate's `js`//!         feature.//! </table>// When running mk/package.sh, don't actually build any code.ArrayFlatMap// XXX: Not correct for x32 ABIs.limbs_equal_limbs_consttimelimbs_less_than_limbsverify_limbs_less_than_limbs_leak_bitlimbs_less_than_limbs_vartimelimb_is_zerolimbs_are_zerolimbs_reject_even_leak_bit/// Leaks one bit of information (other than the lengths of the inputs):/// Whether the given limbs are even.verify_limbs_equal_1_leak_bitlimbs_minimal_bits/// Returns the number of bits in `a`.// This strives to be constant-time with respect to the values of all bits// except the most significant bit. This does not attempt to be constant-time// with respect to `a.len()` or the value of the result or the value of the// most significant bit (It's 1, unless the input is zero, in which case it's// zero.)limbs_reduce_once/// Equivalent to `if (r >= m) { r -= m; }`parse_big_endian_in_range_and_pad_consttime/// Parses `input` into `result`, verifies that the value is less than/// `max_exclusive`, and pads `result` with zeros to its length. If `allow_zero`/// is not `AllowZero::Yes`, zero values are rejected./// This attempts to be constant-time with respect to the actual value *only if*/// the value is actually in range. In other words, this won't leak anything/// about a valid value, but it might leak small amounts of information about an/// invalid value (which constraint it failed).parse_big_endian_and_pad_consttime/// Parses `input` into `result`, padding `result` with zeros to its length./// This attempts to be constant-time with respect to the value but not with/// respect to the length; it is assumed that the length is public knowledge.big_endian_from_limbsunstripped_be_bytes/// Returns an iterator of the big-endian encoding of `limbs`./// The number of bytes returned will be a multiple of `LIMB_BYTES`/// and thus may be padded with leading zeros.// Used in FFIfold_5_bit_windows/// Processes `limbs` as a sequence of 5-bit windows, folding the windows from/// most significant to least significant and returning the accumulated result./// The first window will be mapped by `init` to produce the initial value for/// the accumulator. Then `f` will be called to fold the accumulator and the/// next window until all windows are processed. When the input's bit length/// isn't divisible by 5, the window passed to `init` will be partial; all/// windows passed to `fold` will be full./// This is designed to avoid leaking the contents of `limbs` through side/// channels as long as `init` and `fold` are side-channel free./// Panics if `limbs` is empty.limbs_add_assign_modlimbs_double_mod// r *= 2 (mod m).limbs_negative_odd// *r = -a, assuming a is odd.LIMB_shrtest_limbs_are_evenZEROESNONZEROEStest_limbs_are_zerotest_limbs_equal_limbtest_parse_big_endian_and_pad_consttimetest_big_endian_from_limbs_same_lengthtest_big_endian_from_limbs_fewer_limbstest_limbs_minimal_bits// Copyright 2016 David Judd.//! Unsigned multi-precision integer arithmetic.//! Limbs ordered least-significant-limb to most-significant-limb. The bits//! limbs use the native endianness.DeriveErrorverify_error/// A PBKDF2 algorithm.PBKDF2_HMAC_SHA1/// PBKDF2 using HMAC-SHA1.PBKDF2_HMAC_SHA256/// PBKDF2 using HMAC-SHA256.PBKDF2_HMAC_SHA384/// PBKDF2 using HMAC-SHA384.PBKDF2_HMAC_SHA512/// PBKDF2 using HMAC-SHA512./// Fills `out` with the key derived using PBKDF2 with the given inputs./// Do not use `derive` as part of verifying a secret; use `verify` instead, to/// minimize the effectiveness of timing attacks./// `out.len()` must be no larger than the digest length * (2**32 - 1), per the/// PBKDF2 specification./// | Parameter   | RFC 2898 Section 5.2 Term/// |-------------|-------------------------------------------/// | digest_alg  | PRF (HMAC with the given digest algorithm)/// | iterations  | c (iteration count)/// | salt        | S (salt)/// | secret      | P (password)/// | out         | dk (derived key)/// | out.len()   | dkLen (derived key length)/// Panics if `out.len() > u32::MAX * digest_alg.output_len()`, where/// `digest_alg` is the underlying HMAC/digest algorithm./// Panics if `salt` is so astronomically gigantic that it isn't a valid input/// to the underlying digest function./// Panics if `secret` is so astronomically gigantic that it isn't a valid/// input to the underlying digest function.try_derivederive_blockSecretTooLongSaltTooLongTooMuchOutputRequestedsecret_too_longsalt_too_longPreviouslyDerivedEmptypreviously_derived_empty/// Verifies that a previously-derived (e.g., using `derive`) PBKDF2 value/// matches the PBKDF2 value derived from the other inputs./// The comparison is done in constant time to prevent timing attacks. The/// comparison will fail if `previously_derived` is empty (has a length of/// zero)./// | Parameter                  | RFC 2898 Section 5.2 Term/// |----------------------------|--------------------------------------------/// | digest_alg                 | PRF (HMAC with the given digest algorithm)./// | `iterations`               | c (iteration count)/// | `salt`                     | S (salt)/// | `secret`                   | P (password)/// | `previously_derived`       | dk (derived key)/// | `previously_derived.len()` | dkLen (derived key length)try_verify//! PBKDF2 derivation and verification.//! Use `derive` to derive PBKDF2 outputs. Use `verify` to verify secret//! against previously-derived outputs.//! PBKDF2 is specified in [RFC 2898 Section 5.2] with test vectors given in//! [RFC 6070]. See also [NIST Special Publication 800-132].//! [RFC 2898 Section 5.2]: https://tools.ietf.org/html/rfc2898#section-5.2//! [RFC 6070]: https://tools.ietf.org/html/rfc6070//! [NIST Special Publication 800-132]://!    http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf//! ## Password Database Example//! use ring::{digest, pbkdf2};//! use std::{collections::HashMap, num::NonZeroU32};//! static PBKDF2_ALG: pbkdf2::Algorithm = pbkdf2::PBKDF2_HMAC_SHA256;//! const CREDENTIAL_LEN: usize = digest::SHA256_OUTPUT_LEN;//! pub type Credential = [u8; CREDENTIAL_LEN];//! enum Error {//!     WrongUsernameOrPassword//! struct PasswordDatabase {//!     pbkdf2_iterations: NonZeroU32,//!     db_salt_component: [u8; 16],//!     // Normally this would be a persistent database.//!     storage: HashMap<String, Credential>,//! impl PasswordDatabase {//!     pub fn store_password(&mut self, username: &str, password: &str) {//!         let salt = self.salt(username);//!         let mut to_store: Credential = [0u8; CREDENTIAL_LEN];//!         pbkdf2::derive(PBKDF2_ALG, self.pbkdf2_iterations, &salt,//!                        password.as_bytes(), &mut to_store);//!         self.storage.insert(String::from(username), to_store);//!     pub fn verify_password(&self, username: &str, attempted_password: &str)//!                            -> Result<(), Error> {//!         match self.storage.get(username) {//!            Some(actual_password) => {//!                let salt = self.salt(username);//!                pbkdf2::verify(PBKDF2_ALG, self.pbkdf2_iterations, &salt,//!                               attempted_password.as_bytes(),//!                               actual_password)//!                     .map_err(|_| Error::WrongUsernameOrPassword)//!            },//!            None => Err(Error::WrongUsernameOrPassword)//!     // The salt should have a user-specific component so that an attacker//!     // cannot crack one password for multiple users in the database. It//!     // should have a database-unique component so that an attacker cannot//!     // crack the same user's password across databases in the unfortunate//!     // but common case that the user has used the same password for//!     // multiple systems.//!     fn salt(&self, username: &str) -> Vec<u8> {//!         let mut salt = Vec::with_capacity(self.db_salt_component.len() +//!                                           username.as_bytes().len());//!         salt.extend(self.db_salt_component.as_ref());//!         salt.extend(username.as_bytes());//!         salt//!     // Normally these parameters would be loaded from a configuration file.//!     let mut db = PasswordDatabase {//!         pbkdf2_iterations: NonZeroU32::new(100_000).unwrap(),//!         db_salt_component: [//!             // This value was generated from a secure PRNG.//!             0xd6, 0x26, 0x98, 0xda, 0xf4, 0xdc, 0x50, 0x52,//!             0x24, 0xf2, 0x27, 0xd1, 0xfe, 0x39, 0x01, 0x8a//!         ],//!         storage: HashMap::new(),//!     db.store_password("alice", "@74d7]404j|W}6u");//!     // An attempt to log in with the wrong password fails.//!     assert!(db.verify_password("alice", "wrong password").is_err());//!     // Normally there should be an expoentially-increasing delay between//!     // attempts to further protect against online attacks.//!     // An attempt to log in with the right password succeeds.//!     assert!(db.verify_password("alice", "@74d7]404j|W}6u").is_ok());accept_legacy_ed25519_public_key_tag/// Should the wrong public key ASN.1 tagging used by early implementations/// of PKCS#8 v2 (including earlier versions of *ring*) be accepted?PublicKeyOptionsV1OnlyV1OrV2V2Onlyalg_id_range// The range within `bytes` that holds the value (not including the tag and// length) for use in the PKCS#8 document's privateKeyAlgorithm field.curve_id_index// `bytes[alg_id_range][curve_id_index..]` contains the OID identifying the,// curve, including the tag and length.private_key_index// `bytes` will be split into two parts at `private_key_index`, where the// first part is written before the private key and the second part is// written after the private key. The public key is written after the second// part./// A template for constructing PKCS#8 documents./// Note that this only works for ECC.alg_id_valuealg_id_value_curve_oid/// Parses an unencrypted PKCS#8 private key, verifies that it is the right type/// of key, and returns the key value./// PKCS#8 is specified in [RFC 5958]./// [RFC 5958]: https://tools.ietf.org/html/rfc5958unwrap_key_/// `alg_id` must be the encoded value (not including the outermost `SEQUENCE`/// tag and length) of the `AlgorithmIdentifier` that identifies the key type./// The result will be an encoded `RSAPrivateKey` or `ECPrivateKey` or similar.unwrap_key__/// A generated PKCS#8 document.wrap_key_/// Formats a private key "prefix||private_key||middle||public_key" where/// `template` is "prefix||middle" split at position `private_key_index`.//! PKCS#8 is specified in [RFC 5958]./// A specialized version of `core::iter::FlatMap` for mapping over exact-sized/// iterators with a function that returns an array./// `ArrayFlatMap` differs from `FlatMap` in that `ArrayFlatMap` implements/// `ExactSizeIterator`. Since the result of `F` always has `LEN` elements, if/// `I` is an exact-sized iterator of length `inner_len` then we know the/// length of the flat-mapped result is `inner_len * LEN`. (The constructor/// verifies that this multiplication doesn't overflow `usize`.)/// Constructs an `ArrayFlatMap` wrapping the given iterator, using the/// given function/// Required for implementing `ExactSizeIterator`.test_array_flat_maptest_array_flat_map_len_overflow// Does ArrayFlatMap::new() handle overflow correctly?array_split_mapON// Copyright 2023 Brian Smith.// struct// struct with default constructor visibility./// Reduces boilerplate for defining error types where we want the compiler to/// optimize for the non-error path by assuming constructing an error is/// unlikely/cold code./// WARNING: Every struct/variant must contain some *non-constant* value so/// that the "invariant code" pass of the compiler doesn't recognize the/// constructor as being "invariant code" and optimizing it away;/// although such optimization would be nice to take advantage of, it/// seems to lose the `#[cold]` attribute./// Constructor functions ar marked `pub(super)` to ensure that instances can/// only be constructed from within the enclosing module (and its submodules)./// XXX: #[inline(never)] is required to avoid the (MIR?) optimizer inlining/// away the function call and losing the `#[cold]` attribute in the process./// We'd otherwise maybe prefer all constructors to be inline./// The type is defined in its own submodule `#mod_name` to hide the/// variant/struct constructor, ensuring instances are only constructed/// through the generated `$constructor` functions. The constructor methods/// work around the lack of the ability to mark an enum variant `#[cold]` and/// `#[inline(never)]`.// TODO(MSRV 1.64): Use `core::ffi::c_char`.// TODO(MSRV 1.64): Replace with `&core::ffi::CStr`.// SAFETY: Same as `CStr::from_bytes_with_nul_unchecked`.unwrap_const_from_bytes_with_nulconst_from_bytes_with_nul// TODO(MSRV 1.72): Replace with `CStr::from_bytes_with_nul`._EMPTY_UNTERMINATED// Bad._EMPTY_DOUBLE_TERMINATED_DOUBLE_NUL_LEADINGL_NUL_INTERNAL_NUL_UNTERMINATED_EMPTY_TERMINATED// Good._NONEMPTY_1_CHAR//! Work around lack of `core::ffi::CStr` prior to Rust 1.64, and the lack of//! `const fn` support for `CStr` in later versions./// An iterator that skips all leading zeros./// When the wrapped iterator is all zeros, then the last item is retained.test_leading_zeroes_stripped/// A ZST that can be added to any type to make the type `!Send`.// TODO(MSRV 1.76): Replace with `core::ptr::from_mut`.// TODO(MSRV 1.76): Replace with `core::ptr::from_ref`.as_chunksas_flattenedAsChunksIter// `&mut [[T; N]]` is implicitly convertable to `&[[T; N]]` but our types can't// do that.// TODO: `impl From<AsChunks<'a, T, {2*N}> for AsChunks<'a, T, N>`.as_chunks_mutas_flattened_mutCHUNK_LENAsChunksMutChunksMutIter// Argument moved from runtime argument to `const` argument so that// `CHUNK_LEN * N` is checked at compile time for overflow.split_at_checked// TODO(MSRV feature(split_at_checked)): Use `slice::split_at_checked`.// Note that the libcore version is implemented in terms of// `slice::split_at_unchecked()`, and `slice::split_at()` was changed to be// implemented in terms of `split_at_checked`. For now, we implement this in// terms of `split_at` and rely on the optimizer to eliminate the panic.split_first_chunk_mut// TODO(MSRV-1.77): Use `slice::split_first_chunk_mut`.// Permission is hereby granted, free of charge, to any// person obtaining a copy of this software and associated// documentation files (the "Software"), to deal in the// Software without restriction, including without// limitation the rights to use, copy, modify, merge,// publish, distribute, sublicense, and/or sell copies of// the Software, and to permit persons to whom the Software// is furnished to do so, subject to the following// conditions:// The above copyright notice and this permission notice// shall be included in all copies or substantial portions// of the Software.// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT// SHALL THE AUTHOR OR COPYRIGHT HOLDERS BE LIABLE FOR ANY// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER// DEALINGS IN THE SOFTWARE./// Replaces the first N elements of `a` with the first N elements of `b`, where/// N is `core::cmp::min(a.len(), b.len())`, leaving the rest unchanged.//! Utilities to make dealing with slices less tediuous.assert_iteratorassert_exact_size_iterator/// Asserts that `it` adheres to the `ExactSizeIterator` contract./// Polyfill for `Option::unwrap()` as a const fn; feature `const_option`./// https://github.com/rust-lang/rust/issues/67441./// TODO(MSRV): Replace this with `x.unwrap()`./// `T: Copy` avoids "constant functions cannot evaluate destructors."// Copyright 2022 Brian Smith./// const-capable `x.try_into().unwrap_or(usize::MAX)`cold_errorarray_flat_mapleading_zeros_skippednotsendtest_usize_from_u64_saturated//! Polyfills for functionality that will (hopefully) be added to Rust's//! standard library soon.core_name_and_version// Keep in sync with `core_name_and_version` in build.rs.// Keep in sync with `prefix` in build.rs.// Functions.// A `static` global variable.// A `static mut` global variable./// Fills `dest` with random bytes./// A secure random number generator.RandomlyConstructable/// A random value constructed from a `SecureRandom` that hasn't been exposed/// through any safe Rust interface./// Intentionally does not implement any traits other than `Sized`./// Expose the random value./// Generate the new random value using `rng`.as_mut_bytes// `Default::default()`// `AsMut<[u8]>::as_mut`/// A type that can be returned by `ring::rand::generate()`./// A secure random number generator where the random values come directly/// from the operating system./// "Directly from the operating system" here presently means "whatever the/// `getrandom` crate does" but that may change in the future. That roughly/// means calling libc's `getrandom` function or whatever is analogous to that;/// see the `getrandom` crate's documentation for more info./// A single `SystemRandom` may be shared across multiple threads safely./// `new()` is guaranteed to always succeed and to have low latency; it won't/// try to open or read from a file or do similar things. The first call to/// `fill()` may block a substantial amount of time since any and all/// initialization is deferred to it. Therefore, it may be a good idea to call/// `fill()` once at a non-latency-sensitive time to minimize latency for/// future calls./// Constructs a new `SystemRandom`.// Use the `getrandom` crate whenever it is using the environment's (operating// system's) CSPRNG. Avoid using it on targets where it uses the `rdrand`// implementation.//! Cryptographic pseudo-random number generation.//! *ring* functions that generate random bytes take a `&dyn SecureRandom`//! parameter to make it clear which functions are non-deterministic.KeyPairComponentsPublicExponentPublicKeyComponents/// RSA PKCS#1 1.5 signatures.PrivateCrtPrimeqInv/// An RSA key pair, used for signing./// Parses an unencrypted PKCS#8-encoded RSA private key./// This will generate a 2048-bit RSA private key of the correct form using/// OpenSSL's command line tool:///    openssl genpkey -algorithm RSA \///        -pkeyopt rsa_keygen_bits:2048 \///        -pkeyopt rsa_keygen_pubexp:65537 | \///      openssl pkcs8 -topk8 -nocrypt -outform der > rsa-2048-private-key.pk8/// This will generate a 3072-bit RSA private key of the correct form:///        -pkeyopt rsa_keygen_bits:3072 \///      openssl pkcs8 -topk8 -nocrypt -outform der > rsa-3072-private-key.pk8/// Often, keys generated for use in OpenSSL-based software are stored in/// the Base64 “PEM” format without the PKCS#8 wrapper. Such keys can be/// converted to binary PKCS#8 form using the OpenSSL command line tool like/// this:/// openssl pkcs8 -topk8 -nocrypt -outform der \///     -in rsa-2048-private-key.pem > rsa-2048-private-key.pk8/// Base64 (“PEM”) PKCS#8-encoded keys can be converted to the binary PKCS#8/// form like this:/// openssl pkcs8 -nocrypt -outform der \/// See [`Self::from_components`] for more details on how the input is/// validated./// See [RFC 5958] and [RFC 3447 Appendix A.1.2] for more details of the/// encoding of the key./// [NIST SP-800-56B rev. 1]:///     http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Br1.pdf/// [RFC 3447 Appendix A.1.2]:///     https://tools.ietf.org/html/rfc3447#appendix-A.1.2/// [RFC 5958]:///     https://tools.ietf.org/html/rfc5958/// Parses an RSA private key that is not inside a PKCS#8 wrapper./// The private key must be encoded as a binary DER-encoded ASN.1/// `RSAPrivateKey` as described in [RFC 3447 Appendix A.1.2]). In all other/// respects, this is just like `from_pkcs8()`. See the documentation for/// `from_pkcs8()` for more details./// It is recommended to use `from_pkcs8()` (with a PKCS#8-encoded key)/// See [`Self::from_components()`] for more details on how the input isfrom_der_reader/// Constructs an RSA private key from its big-endian-encoded components./// Only two-prime (not multi-prime) keys are supported. The public modulus/// (n) must be at least 2047 bits. The public modulus must be no larger/// than 4096 bits. It is recommended that the public modulus be exactly/// 2048 or 3072 bits. The public exponent must be at least 65537 and must/// be no more than 33 bits long./// The private key is validated according to [NIST SP-800-56B rev. 1]/// section 6.4.1.4.3, crt_pkv (Intended Exponent-Creation Method Unknown),/// with the following exceptions:/// * Section 6.4.1.2.1, Step 1: Neither a target security level nor an///   expected modulus length is provided as a parameter, so checks///   regarding these expectations are not done./// * Section 6.4.1.2.1, Step 3: Since neither the public key nor the///   expected modulus length is provided as a parameter, the consistency///   check between these values and the private key's value of n isn't///   done./// * Section 6.4.1.2.1, Step 5: No primality tests are done, both for///   performance reasons and to avoid any side channels that such tests///   would provide./// * Section 6.4.1.2.1, Step 6, and 6.4.1.4.3, Step 7:///   * *ring* has a slightly looser lower bound for the values of `p`///     and `q` than what the NIST document specifies. This looser lower///     bound matches what most other crypto libraries do. The check might///     be tightened to meet NIST's requirements in the future. Similarly,///     the check that `p` and `q` are not too close together is skipped///     currently, but may be added in the future.///   * The validity of the mathematical relationship of `dP`, `dQ`, `e`///     and `n` is verified only during signing. Some size checks of `d`,///     `dP` and `dQ` are performed at construction, but some NIST checks///     are skipped because they would be expensive and/or they would leak///     information through side channels. If a preemptive check of the///     consistency of `dP`, `dQ`, `e` and `n` with each other is///     necessary, that can be done by signing any message with the key///     pair.///   * `d` is not fully validated, neither at construction nor during///     signing. This is OK as far as *ring*'s usage of the key is///     concerned because *ring* never uses the value of `d` (*ring* always///     uses `p`, `q`, `dP` and `dQ` via the Chinese Remainder Theorem,///     instead). However, *ring*'s checks would not be sufficient for///     validating a key pair for use by some other system; that other///     system must check the value of `d` itself if `d` is to be used.from_components_/// Returns a reference to the public key."Use `public().modulus_len()`"public_modulus_len/// Returns the length in bytes of the key pair's public modulus./// A signature has the same length as the public modulus.oneRRPrivatePrimeoneRRR/// Constructs a `PrivateCrtPrime` from the private prime `p` and `dP` where/// dP == d % (p - 1)./// Computes the signature of `msg` and writes it into `signature`./// `msg` is digested using the digest algorithm from `padding_alg` and the/// digest is then padded using the padding algorithm from `padding_alg`./// The signature it written into `signature`; `signature`'s length must be/// exactly the length returned by `self::public().modulus_len()` or else/// an error will be returned. On failure, `signature` may contain/// intermediate results, but won't contain anything that would endanger the/// private key./// `rng` may be used to randomize the padding (e.g. for PSS)./// Many other crypto libraries have signing functions that takes a/// precomputed digest as input, instead of the message to digest. This/// function does *not* take a precomputed digest; instead, `sign`/// calculates the digest itself.private_exponentiate/// Returns base**d (mod n)./// This does not return or write any intermediate results into any buffers/// that are provided by the caller so that no intermediate state will be/// leaked that would endanger the private key./// Panics if `in_out` is not `self.public().modulus_len()`.test_rsakeypair_private_exponentiate// Type-level representations of the different moduli used in RSA signing, in// addition to `super::N`. See `super::bigint`'s modulue-level documentation./// The public key components./// The private exponent./// The first prime factor of `d`./// The second prime factor of `d`.dP/// `p`'s public Chinese Remainder Theorem exponent.dQ/// `q`'s public Chinese Remainder Theorem exponent./// `q**-1 mod p`./// RSA key pair components.PUBLIC_KEY_PUBLIC_MODULUS_MAX_LENVerificationdigestinfo_prefix/// PKCS#1 1.5 padding as described in [RFC 3447 Section 8.2]./// See "`RSA_PSS_*` Details\" in `ring::signature`'s module-level/// [RFC 3447 Section 8.2]: https://tools.ietf.org/html/rfc3447#section-8.2pkcs1_encode// Implement padding procedure per EMSA-PKCS1-v1_5,// https://tools.ietf.org/html/rfc3447#section-9.2. This is used by both// verification and signing so it needs to be able to handle moduli of the// minimum and maximum sizes for both operations.rsa_pkcs1_padding"PKCS#1 1.5 padding using SHA-1 for RSA signatures."RSA_PKCS1_SHA1_FOR_LEGACY_USE_ONLY// Intentionally not exposed except internally for signature verification. At a// minimum, we'd need to create test vectors for signing with it, which we// don't currently have. But, it's a bad idea to use SHA-1 anyway, so perhaps// we just won't ever expose it."PKCS#1 1.5 padding using SHA-256 for RSA signatures."RSA_PKCS1_SHA256"PKCS#1 1.5 padding using SHA-384 for RSA signatures."RSA_PKCS1_SHA384"PKCS#1 1.5 padding using SHA-512 for RSA signatures."RSA_PKCS1_SHA512pkcs1_digestinfo_prefixSHA1_PKCS1_DIGESTINFO_PREFIXSHA256_PKCS1_DIGESTINFO_PREFIXSHA384_PKCS1_DIGESTINFO_PREFIXSHA512_PKCS1_DIGESTINFO_PREFIXmgf1/// RSA PSS padding as described in [RFC 3447 Section 8.1]./// [RFC 3447 Section 8.1]: https://tools.ietf.org/html/rfc3447#section-8.1// TODO: Until we implement cargo-semver-checks// Implement padding procedure per EMSA-PSS,// https://tools.ietf.org/html/rfc3447#section-9.1.// RSASSA-PSS-VERIFY from https://tools.ietf.org/html/rfc3447#section-8.1.2// where steps 1, 2(a), and 2(b) have been done for us.em_lendb_lenps_lens_lenh_lentop_byte_maskPSSMetricspss_digestrsa_pss_padding"RSA PSS padding using SHA-256 for RSA signatures.\n\nSee
                 \"`RSA_PSS_*` Details\" in `ring::signature`'s module-level
                 documentation for more details."RSA_PSS_SHA256"RSA PSS padding using SHA-384 for RSA signatures.\n\nSee
                 \"`RSA_PSS_*` Details\" in `ring::signature`'s module-level
                 documentation for more details."RSA_PSS_SHA384"RSA PSS padding using SHA-512 for RSA signatures.\n\nSee
                 \"`RSA_PSS_*` Details\" in `ring::signature`'s module-level
                 documentation for more details."RSA_PSS_SHA512pkcs1pss// The digest algorithm used for digesting the message (and maybe for// other things)./// Common features of both RSA padding encoding and RSA padding verification./// An RSA signature encoding as described in [RFC 3447 Section 8]./// [RFC 3447 Section 8]: https://tools.ietf.org/html/rfc3447#section-8/// Verification of an RSA signature encoding as described in/// [RFC 3447 Section 8].// Masks `out` with the output of the mask-generating function MGF1 as// described in https://tools.ietf.org/html/rfc3447#appendix-B.2.1.test_pss_padding_verifytest_pss_padding_encode// Tests PSS encoding for various public modulus lengths./// The exponent `e` of an RSA public key.ALL_CONSTANTS_65537// This limit was chosen to bound the performance of the simple// exponentiation-by-squaring implementation in `elem_exp_vartime`. In// particular, it helps mitigate theoretical resource exhaustion attacks. 33// bits was chosen as the limit based on the recommendations in [1] and// [2]. Windows CryptoAPI (at least older versions) doesn't support values// larger than 32 bits [3], so it is unlikely that exponents larger than 32// bits are being used for anything Windows commonly does.// [1] https://www.imperialviolet.org/2012/03/16/rsae.html// [2] https://www.imperialviolet.org/2012/03/17/rsados.html// [3] https://msdn.microsoft.com/en-us/library/aa387685(VS.85).aspx/// The big-endian encoding of the exponent./// There are no leading zeros.test_public_exponent_constantsserialized/// An RSA Public Key.from_modulus_and_exponentmodulus_len/// The length, in bytes, of the public modulus./// The modulus length is rounded up to a whole number of bytes if its/// bit length isn't a multiple of 8./// `PublicKey` but without any superfluous allocations, optimized for one-shot/// RSA signature verification./// The public modulus./// The public exponent.exponentiate/// Calculates base**e (mod n), filling the first part of `out_buffer` with/// This is constant-time with respect to the value in `base` (only)./// The result will be a slice of the encoded bytes of the result within/// `out_buffer`, if successful.exponentiate_elem/// Calculates base**e (mod n)./// This is constant-time with respect to `base` only.// XXX: Refactor `signature::KeyPair` to get rid of this.fill_be_bytes_n/// Returns the big-endian representation of `elem` that is/// the same length as the minimal-length big-endian representation of/// the modulus `n`./// `n_bits` must be the bit length of the public modulus `n`./// The public modulus, encoded in big-endian bytes without leading zeros./// The public exponent, encoded in big-endian bytes without leading zeros./// RSA public key components./// `B` must implement `AsRef<[u8]>` like `&[u8]` or `Vec<u8>`./// The modulus (n) of an RSA public key./// The big-endian encoding of the modulus./// The length of the modulus in bits./*
impl core::fmt::Debug for PublicModulus {
    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> Result<(), ::core::fmt::Error> {
        self.value.fmt(fmt)
    }
}*/RsaParametersrsa_params"Verification of signatures using RSA keys of 1024-8192 bits,
             PKCS#1.5 padding, and SHA-1.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."r" Only available in `alloc` mode."RSA_PKCS1_1024_8192_SHA1_FOR_LEGACY_USE_ONLY"Verification of signatures using RSA keys of 2048-8192 bits,
             PKCS#1.5 padding, and SHA-1.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_2048_8192_SHA1_FOR_LEGACY_USE_ONLY"Verification of signatures using RSA keys of 1024-8192 bits,
             PKCS#1.5 padding, and SHA-256.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_1024_8192_SHA256_FOR_LEGACY_USE_ONLY"Verification of signatures using RSA keys of 2048-8192 bits,
             PKCS#1.5 padding, and SHA-256.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_2048_8192_SHA256"Verification of signatures using RSA keys of 2048-8192 bits,
             PKCS#1.5 padding, and SHA-384.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_2048_8192_SHA384"Verification of signatures using RSA keys of 2048-8192 bits,
             PKCS#1.5 padding, and SHA-512.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_2048_8192_SHA512"Verification of signatures using RSA keys of 1024-8192 bits,
             PKCS#1.5 padding, and SHA-512.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_1024_8192_SHA512_FOR_LEGACY_USE_ONLY"Verification of signatures using RSA keys of 3072-8192 bits,
             PKCS#1.5 padding, and SHA-384.\n\nSee \"`RSA_PKCS1_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PKCS1_3072_8192_SHA384"Verification of signatures using RSA keys of 2048-8192 bits,
             PSS padding, and SHA-256.\n\nSee \"`RSA_PSS_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PSS_2048_8192_SHA256"Verification of signatures using RSA keys of 2048-8192 bits,
             PSS padding, and SHA-384.\n\nSee \"`RSA_PSS_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PSS_2048_8192_SHA384"Verification of signatures using RSA keys of 2048-8192 bits,
             PSS padding, and SHA-512.\n\nSee \"`RSA_PSS_*` Details\" in
             `ring::signature`'s module-level documentation for more details."RSA_PSS_2048_8192_SHA512RsaPublicKeyComponents/// Verifies that `signature` is a valid signature of `message` using `self`/// as the public key. `params` determine what algorithm parameters/// (padding, digest algorithm, key length range, etc.) are used in the/// verification./// When the public key is in DER-encoded PKCS#1 ASN.1 format, it is/// recommended to use `ring::signature::verify()` with/// `ring::signature::RSA_PKCS1_*`, because `ring::signature::verify()`/// will handle the parsing in that case. Otherwise, this function can be used/// to pass in the raw bytes for the public key components as/// `untrusted::Input` arguments.// There are a small number of tests that test this directly, but the// test coverage for this function mostly depends on the test coverage for the// `signature::VerificationAlgorithm` implementation for `RsaParameters`. If we// change that, test coverage for `verify_rsa()` will need to be reconsidered.// (The NIST test vectors were originally in a form that was optimized for// testing `verify_rsa` directly, but the testing work for RSA PKCS#1// verification was done during the implementation of// `signature::VerificationAlgorithm`, before `verify_rsa` was factored out).verify_rsa_//! Verification of RSA signatures.// Maximum RSA modulus size supported for signature verification (in bytes).PRIVATE_KEY_PUBLIC_MODULUS_MAX_BITS// Keep in sync with the documentation comment for `KeyPair`.padding_algmin_bits/// Parameters for RSA verification.// Type-level representation of an RSA public modulus *n*. See// `super::bigint`'s modulue-level documentation.keypairkeypair_componentspublic_exponentpublic_key_componentspublic_modulus// *R* and *r* in Montgomery math refer to different things, so we always use// `R` to refer to *R* to avoid confusion, even when that's against the normal// naming conventions. Also the standard camelCase names are used for `KeyPair`// components.//! RSA./// A public key signature returned from a signing operation.// Panics if `value` is too long./// The type of the public key./// The public key for the key pair./// Key pairs for signing messages (private key and public key)./// The longest signature is an ASN.1 P-384 signature where *r* and *s* are of/// maximum length with the leading high bit set on each. Then each component/// will have a tag, a one-byte length, and a one-byte “I'm not negative”/// prefix, and the outer sequence will have a two-byte length./// Verify the signature `signature` of message `msg` with the public key/// `public_key`./// A signature verification algorithm./// An unparsed, possibly malformed, public key for signature verification./// Construct a new `UnparsedPublicKey`./// No validation of `bytes` is done until `verify()` is called./// Parses the public key and verifies `signature` is a valid signature of/// `message` using it./// See the [crate::signature] module-level documentation for examples.//! Public key signatures: signing and verification.//! Use the `verify` function to verify signatures, passing a reference to the//! algorithm that identifies the algorithm. See the documentation for `verify`//! for examples.//! For signature verification, this API treats each combination of parameters//! as a separate algorithm. For example, instead of having a single "RSA"//! algorithm with a verification function that takes a bunch of parameters,//! there are `RSA_PKCS1_2048_8192_SHA256`, `RSA_PKCS1_2048_8192_SHA384`, etc.,//! which encode sets of parameter choices into objects. This is designed to//! reduce the risks of algorithm agility and to provide consistency with ECDSA//! and EdDSA.//! Currently this module does not support digesting the message to be signed//! separately from the public key operation, as it is currently being//! optimized for Ed25519 and for the implementation of protocols that do not//! requiring signing large messages. An interface for efficiently supporting//! larger messages may be added later.//! # Algorithm Details//! ## `ECDSA_*_ASN1` Details: ASN.1-encoded ECDSA Signatures//! The signature is a ASN.1 DER-encoded `Ecdsa-Sig-Value` as described in//! [RFC 3279 Section 2.2.3]. This is the form of ECDSA signature used in//! X.509-related structures and in TLS's `ServerKeyExchange` messages.//! The public key is encoding in uncompressed form using the//! Octet-String-to-Elliptic-Curve-Point algorithm in//! [SEC 1: Elliptic Curve Cryptography, Version 2.0].//! During verification, the public key is validated using the ECC Partial//! Public-Key Validation Routine from Section 5.6.2.3.3 of//! [NIST Special Publication 800-56A, revision 2] and Appendix A.3 of the//! NSA's [Suite B implementer's guide to FIPS 186-3]. Note that, as explained//! in the NSA guide, ECC Partial Public-Key Validation is equivalent to ECC//! Full Public-Key Validation for prime-order curves like this one.//! ## `ECDSA_*_FIXED` Details: Fixed-length (PKCS#11-style) ECDSA Signatures//! The signature is *r*||*s*, where || denotes concatenation, and where both//! *r* and *s* are both big-endian-encoded values that are left-padded to the//! maximum length. A P-256 signature will be 64 bytes long (two 32-byte//! components) and a P-384 signature will be 96 bytes long (two 48-byte//! components). This is the form of ECDSA signature used PKCS#11 and DNSSEC.//! ## `RSA_PKCS1_*` Details: RSA PKCS#1 1.5 Signatures//! The signature is an RSASSA-PKCS1-v1_5 signature as described in//! [RFC 3447 Section 8.2].//! The public key is encoded as an ASN.1 `RSAPublicKey` as described in//! [RFC 3447 Appendix-A.1.1]. The public key modulus length, rounded *up* to//! the nearest (larger) multiple of 8 bits, must be in the range given in the//! name of the algorithm. The public exponent must be an odd integer of 2-33//! bits, inclusive.//! ## `RSA_PSS_*` Details: RSA PSS Signatures//! The signature is an RSASSA-PSS signature as described in//! [RFC 3447 Section 8.1].//! During verification, signatures will only be accepted if the MGF1 digest//! algorithm is the same as the message digest algorithm and if the salt//! length is the same length as the message digest. This matches the//! requirements in TLS 1.3 and other recent specifications.//! During signing, the message digest algorithm will be used as the MGF1//! digest algorithm. The salt will be the same length as the message digest.//! This matches the requirements in TLS 1.3 and other recent specifications.//! Additionally, the entire salt is randomly generated separately for each//! signature using the secure random number generator passed to `sign()`.//! [SEC 1: Elliptic Curve Cryptography, Version 2.0]://!     http://www.secg.org/sec1-v2.pdf//! [NIST Special Publication 800-56A, revision 2]://!     http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar2.pdf//! [Suite B implementer's guide to FIPS 186-3]://!     https://github.com/briansmith/ring/blob/main/doc/ecdsa.pdf//! [RFC 3279 Section 2.2.3]://!     https://tools.ietf.org/html/rfc3279#section-2.2.3//! [RFC 3447 Section 8.2]://!     https://tools.ietf.org/html/rfc3447#section-7.2//! [RFC 3447 Section 8.1]://!     https://tools.ietf.org/html/rfc3447#section-8.1//! [RFC 3447 Appendix-A.1.1]://!     https://tools.ietf.org/html/rfc3447#appendix-A.1.1//! ## Signing and verifying with Ed25519//! use ring::{//!     rand,//!     signature::{self, KeyPair},//! # fn main() -> Result<(), ring::error::Unspecified> {//! // Generate a key pair in PKCS#8 (v2) format.//! let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(&rng)?;//! // Normally the application would store the PKCS#8 file persistently. Later//! // it would read the PKCS#8 file from persistent storage to use it.//! let key_pair = signature::Ed25519KeyPair::from_pkcs8(pkcs8_bytes.as_ref())?;//! // Sign the message "hello, world".//! const MESSAGE: &[u8] = b"hello, world";//! let sig = key_pair.sign(MESSAGE);//! // Normally an application would extract the bytes of the signature and//! // send them in a protocol message to the peer(s). Here we just get the//! // public key key directly from the key pair.//! let peer_public_key_bytes = key_pair.public_key().as_ref();//! // Verify the signature of the message using the public key. Normally the//! // verifier of the message would parse the inputs to this code out of the//! // protocol message(s) sent by the signer.//! let peer_public_key =//!     signature::UnparsedPublicKey::new(&signature::ED25519, peer_public_key_bytes);//! peer_public_key.verify(MESSAGE, sig.as_ref())?;//! ## Signing and verifying with RSA (PKCS#1 1.5 padding)//! By default OpenSSL writes RSA public keys in SubjectPublicKeyInfo format,//! not RSAPublicKey format, and Base64-encodes them (“PEM” format).//! To convert the PEM SubjectPublicKeyInfo format (“BEGIN PUBLIC KEY”) to the//! binary RSAPublicKey format needed by `verify()`, use://! openssl rsa -pubin \//!             -in public_key.pem \//!             -inform PEM \//!             -RSAPublicKey_out \//!             -outform DER \//!             -out public_key.der//! To extract the RSAPublicKey-formatted public key from an ASN.1 (binary)//! DER-encoded RSAPrivateKey format private key file, use://! openssl rsa -in private_key.der \//!             -inform DER \//! use ring::{rand, rsa, signature};//! fn sign_and_verify_rsa(private_key_path: &std::path::Path,//!                        public_key_path: &std::path::Path)//!                        -> Result<(), MyError> {//! // Create an RSA keypair from the DER-encoded bytes. This example uses//! // a 2048-bit key, but larger keys are also supported.//! let private_key_der = read_file(private_key_path)?;//! let key_pair = rsa::KeyPair::from_der(&private_key_der)//!     .map_err(|_| MyError::BadPrivateKey)?;//! // Sign the message "hello, world", using PKCS#1 v1.5 padding and the//! // SHA256 digest algorithm.//! const MESSAGE: &'static [u8] = b"hello, world";//! let mut signature = vec![0; key_pair.public().modulus_len()];//! key_pair.sign(&signature::RSA_PKCS1_SHA256, &rng, MESSAGE, &mut signature)//!     .map_err(|_| MyError::OOM)?;//! let public_key =//!     signature::UnparsedPublicKey::new(&signature::RSA_PKCS1_2048_8192_SHA256,//!                                       read_file(public_key_path)?);//! public_key.verify(MESSAGE, &signature)//!     .map_err(|_| MyError::BadSignature)//! enum MyError {//! #  #[cfg(feature = "std")]//!    IO(std::io::Error),//!    BadPrivateKey,//!    OOM,//!    BadSignature,//! fn read_file(path: &std::path::Path) -> Result<Vec<u8>, MyError> {//!     use std::io::Read;//!     let mut file = std::fs::File::open(path).map_err(|e| MyError::IO(e))?;//!     let mut contents: Vec<u8> = Vec::new();//!     file.read_to_end(&mut contents).map_err(|e| MyError::IO(e))?;//!     Ok(contents)//! # #[cfg(not(feature = "std"))]//! # fn sign_and_verify_rsa(_private_key_path: &std::path::Path,//! #                        _public_key_path: &std::path::Path)//! #                        -> Result<(), ()> {//! #     Ok(())//! #     let private_key_path =//! #         std::path::Path::new("src/rsa/signature_rsa_example_private_key.der");//! #     let public_key_path =//! #         std::path::Path::new("src/rsa/signature_rsa_example_public_key.der");//! #     sign_and_verify_rsa(&private_key_path, &public_key_path).unwrap()test_from_byte_len_overflowbits_tests//! Integration tests for non-public APIs./// `compile_time_assert_clone::<T>();` fails to compile if `T` doesn't/// implement `Clone`./// `compile_time_assert_copy::<T>();` fails to compile if `T` doesn't/// implement `Copy`./// `compile_time_assert_eq::<T>();` fails to compile if `T` doesn't/// implement `Eq`./// `compile_time_assert_send::<T>();` fails to compile if `T` doesn't/// implement `Send`./// `compile_time_assert_sync::<T>();` fails to compile if `T` doesn't/// implement `Sync`./// A test case. A test case consists of a set of named attributes. Every/// attribute in the test case must be consumed exactly once; this helps catch/// typos and omissions./// Requires the `alloc` default feature to be enabled.consume_bool/// Maps the string "true" to true and the string "false" to false.consume_digest_alg/// Maps the strings "SHA1", "SHA256", "SHA384", and "SHA512" to digest/// algorithms, maps "SHA224" to `None`, and panics on other (erroneous)/// inputs. "SHA224" is mapped to None because *ring* intentionally does/// not support SHA224, but we need to consume test vectors from NIST that/// have SHA224 vectors in them.consume_bytes/// Returns the value of an attribute that is encoded as a sequence of an/// even number of hex digits, or as a double-quoted UTF-8 string. The/// empty (zero-length) value is represented as "".consume_optional_bytes/// Like `consume_bytes()` except it returns `None` if the test case/// doesn't have the attribute.consume_usize/// Returns the value of an attribute that is an integer, in decimal/// notation.consume_usize_bits/// notation, as a bit length.consume_string/// Returns the raw value of an attribute, without any unquoting or/// other interpretation.consume_optional_string/// Like `consume_string()` except it returns `None` if the test casetest_vector_file/// The name (path) of the file./// The contents of the file./// A test input file./// Parses test cases out of the given file, calling `f` on each vector until/// `f` fails or until all the test vectors have been read. `f` can indicate/// failure either by returning `Err()` or by panicking./// Decode an string of hex digits into a sequence of bytes. The input must/// have an even number of digits.from_hex_digitparse_test_case/// An implementation of `SecureRandom` that always fills the output slice/// with the given byte./// with the slice in `bytes`. The length of the slice given to `slice`/// must match exactly./// An implementation of `SecureRandom` where each slice in `bytes` is a/// test vector for one call to `fill()`. *Not thread-safe.*/// The first slice in `bytes` is the output for the first call to/// `fill()`, the second slice is the output for the second call to/// `fill()`, etc. The output slice passed to `fill()` must have exactly/// the length of the corresponding entry in `bytes`. `current` must be/// initialized to zero. `fill()` must be called exactly once for each/// entry in `bytes`./// Deterministic implementations of `ring::rand::SecureRandom`./// These implementations are particularly useful for testing implementations/// of randomized algorithms & protocols using known-answer-tests where the/// test vectors contain the random seed to use. They are also especially/// useful for some types of fuzzing.one_okone_errone_panicsfirst_errmiddle_errlast_errerr_onefirst_panicmiddle_paniclast_panicpanic_one//! Testing framework.//! Unlike the rest of *ring*, this testing framework uses panics pretty//! liberally. It was originally designed for internal use--it drives most of//! *ring*'s internal tests, and so it is optimized for getting *ring*'s tests//! written quickly at the expense of some usability. The documentation is//! lacking. The best way to learn it is to look at some examples. The digest//! tests are the most complicated because they use named sections. Other tests//! avoid named sections and so are easier to understand.//! ## Writing Tests//! Input files look like this://! # This is a comment.//! HMAC = SHA1//! Input = "My test data"//! Key = ""//! Output = 61afdecb95429ef494d61fdee15990cabf0826fc//! HMAC = SHA256//! Input = "Sample message for keylen<blocklen"//! Key = 000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F//! Output = A28CF43130EE696A98F14A37678B56BCFCBDD9E5CF69717FECF5480F0EBDF790//! Test cases are separated with blank lines. Note how the bytes of the `Key`//! attribute are specified as a quoted string in the first test case and as//! hex in the second test case; you can use whichever form is more convenient//! and you can mix and match within the same file. The empty sequence of bytes//! can only be represented with the quoted string form (`""`).//! Here's how you would consume the test data://! use ring::test;//! test::run(test::test_vector_file!("hmac_tests.txt"), |section, test_case| {//!     assert_eq!(section, ""); // This test doesn't use named sections.//!     let digest_alg = test_case.consume_digest_alg("HMAC");//!     let input = test_case.consume_bytes("Input");//!     let key = test_case.consume_bytes("Key");//!     let output = test_case.consume_bytes("Output");//!     // Do the actual testing here//! Note that `consume_digest_alg` automatically maps the string "SHA1" to a//! reference to `digest::SHA1_FOR_LEGACY_USE_ONLY`, "SHA256" to//! `digest::SHA256`, etc.//! ## Output When a Test Fails//! When a test case fails, the framework automatically prints out the test//! case. If the test case failed with a panic, then the backtrace of the panic//! will be printed too. For example, let's say the failing test case looks//! like this://! Curve = P-256//! a = 2b11cb945c8cf152ffa4c9c2b1c965b019b35d0b7626919ef0ae6cb9d232f8af//! b = 18905f76a53755c679fb732b7762251075ba95fc5fedb60179e730d418a9143c//! r = 18905f76a53755c679fb732b7762251075ba95fc5fedb60179e730d418a9143c//! If the test fails, this will be printed (if `$RUST_BACKTRACE` is `1`)://! src/example_tests.txt: Test panicked.//! thread 'example_test' panicked at 'Test failed.', src\testutil:206//! stack backtrace://!    0:     0x7ff654a05c7c - std::rt::lang_start::h61f4934e780b4dfc//!    1:     0x7ff654a04f32 - std::rt::lang_start::h61f4934e780b4dfc//!    2:     0x7ff6549f505d - std::panicking::rust_panic_with_hook::hfe203e3083c2b544//!    3:     0x7ff654a0825b - rust_begin_unwind//!    4:     0x7ff6549f63af - std::panicking::begin_panic_fmt::h484cd47786497f03//!    5:     0x7ff654a07e9b - rust_begin_unwind//!    6:     0x7ff654a0ae95 - core::panicking::panic_fmt::h257ceb0aa351d801//!    7:     0x7ff654a0b190 - core::panicking::panic::h4bb1497076d04ab9//!    8:     0x7ff65496dc41 - from_file<closure>//!                         at C:\Users\Example\example\<core macros>:4//!    9:     0x7ff65496d49c - example_test//!                         at C:\Users\Example\example\src\example.rs:652//!   10:     0x7ff6549d192a - test::stats::Summary::new::ha139494ed2e4e01f//!   11:     0x7ff6549d51a2 - test::stats::Summary::new::ha139494ed2e4e01f//!   12:     0x7ff654a0a911 - _rust_maybe_catch_panic//!   13:     0x7ff6549d56dd - test::stats::Summary::new::ha139494ed2e4e01f//!   14:     0x7ff654a03783 - std::sys::thread::Thread::new::h2b08da6cd2517f79//!   15:     0x7ff968518101 - BaseThreadInitThunk//! Notice that the output shows the name of the data file//! (`src/example_tests.txt`), the test inputs that led to the failure, and the//! stack trace to the line in the test code that panicked: entry 9 in the//! stack trace pointing to line 652 of the file `example.rs`.tokenizer_testsNS_XML_URI/// The <http://www.w3.org/XML/1998/namespace> URI.NS_XML_PREFIX/// The prefix 'xml', which is by definition bound to NS_XML_URINS_XMLNS_URI/// The <http://www.w3.org/2000/xmlns/> URI.XMLNS/// The string 'xmlns', which is used to declare new namespacesTextPos/// Position in text./// Position indicates a row/line and a column in the original text. Starting from 1:1./// Constructs a new `TextPos`./// An original data./// Required for `text_pos_at` methods.AttributeDataNamespaces/// An XML tree container./// A tree consists of [`Nodes`]./// There are no separate structs for each node type./// So you should check the current node type yourself via [`Node::node_type()`]./// There are only [5 types](enum.NodeType.html):/// Root, Element, PI, Comment and Text./// As you can see there are no XML declaration and CDATA types./// The XML declaration is basically skipped, since it doesn't contain any/// valuable information (we support only UTF-8 anyway)./// And CDATA will be converted into a Text node as is, without/// any preprocessing (you can read more about it/// [here](https://github.com/RazrFalcon/roxmltree/blob/master/docs/parsing.md))./// Also, the Text node data can be accessed from the text node itself or from/// the parent element via [`Node::text()`] or [`Node::tail()`]./// [`Nodes`]: struct.Node.html/// [`Node::node_type()`]: struct.Node.html#method.node_type/// [`Node::text()`]: struct.Node.html#method.text/// [`Node::tail()`]: struct.Node.html#method.tail/// Returns the root node./// let doc = roxmltree::Document::parse("<e/>").unwrap();/// assert!(doc.root().is_root());/// assert!(doc.root().first_child().unwrap().has_tag_name("e"));/// Returns the node of the tree with the given NodeId./// Note: NodeId::new(0) represents the root node/// let doc = roxmltree::Document::parse("\/// <p>///     text/// ").unwrap();/// use roxmltree::NodeId;/// assert_eq!(doc.get_node(NodeId::new(0)).unwrap(), doc.root());/// assert_eq!(doc.get_node(NodeId::new(1)), doc.descendants().find(|n| n.has_tag_name("p")));/// assert_eq!(doc.get_node(NodeId::new(2)), doc.descendants().find(|n| n.is_text()));/// assert_eq!(doc.get_node(NodeId::new(3)), None);root_element/// Returns the root element of the document./// Unlike `root`, will return a first element node./// The root element always exists./// let doc = roxmltree::Document::parse("<!-- comment --><e/>").unwrap();/// assert!(doc.root_element().has_tag_name("e"));descendantsDescendants/// Returns an iterator over document's descendant nodes./// Shorthand for `doc.root().descendants()`.text_pos_at/// Calculates `TextPos` in the original document from position in bytes./// **Note:** this operation is expensive./// use roxmltree::*;/// let doc = Document::parse("\/// <!-- comment -->/// <e/>"/// assert_eq!(doc.text_pos_at(10), TextPos::new(1, 11));/// assert_eq!(doc.text_pos_at(9999), TextPos::new(2, 5));input_text/// Returns the input text of the original document./// let doc = Document::parse("<e/>").unwrap();/// assert_eq!(doc.input_text(), "<e/>");NodeType/// The root node of the `Document`./// An element node./// Only an element can have a tag name and attributes./// A processing instruction./// A comment node./// A text node./// A list of supported node types.ShortRange/// A short range./// Just like Range, but only for `u32` and copyable.to_urange/// A node ID stored as `u32`./// An index into a `Tree`-internal `Vec`./// Note that this value should be used with care since `roxmltree` doesn't/// check that `NodeId` actually belongs to a selected `Document`./// So you can end up in a situation, when `NodeId` produced by one `Document`/// is used to select a node in another `Document`./// Construct a new `NodeId` from a `u32`./// Returns the `u32` representation of the `NodeId`.get_usize/// Returns the `usize` representation of the `NodeId`.NodeKindExpandedNameIndexedStringStoragenext_subtreeOwnedSharedString/// A raw slice of the input string./// A reference-counted string./// A string storage./// Used by text nodes and attributes values./// We try our best not to allocate strings, referencing the input string as much as possible./// But in some cases post-processing is necessary and we have to allocate them./// All owned, allocated strings are stored as `Arc<str>` or as `Rc<str>` on targets/// were `Arc` isn't available./// And unlike `Cow<&str>`, `StringStorage` is immutable and can be cheaply cloned./// Creates a new owned string from `&str` or `String`./// Returns a string slice.qname_leneq_len// includes any surrounding spaces/// An attribute./// Returns attribute's namespace URI./// let doc = roxmltree::Document::parse(///     "<e xmlns:n='http://www.w3.org' a='b' n:a='c'/>"/// assert_eq!(doc.root_element().attributes().nth(0).unwrap().namespace(), None);/// assert_eq!(doc.root_element().attributes().nth(1).unwrap().namespace(), Some("http://www.w3.org"));/// Returns attribute's name./// assert_eq!(doc.root_element().attributes().nth(0).unwrap().name(), "a");/// assert_eq!(doc.root_element().attributes().nth(1).unwrap().name(), "a");/// Returns attribute's value./// assert_eq!(doc.root_element().attributes().nth(0).unwrap().value(), "b");/// assert_eq!(doc.root_element().attributes().nth(1).unwrap().value(), "c");value_storage/// Returns attribute's value storage./// Useful when you need a more low-level access to an allocated string./// Returns attribute's position in bytes in the original document./// You can calculate a human-readable text position via [Document::text_pos_at]./// <e attr='value'/>///    ^/// [Document::text_pos_at]: struct.Document.html#method.text_pos_at/// Returns attribute's range in bytes in the original document./// <e n:attr='value'/>///    ^^^^^^^^^^^^^^range_qname/// Returns attribute's qname's range in bytes in the original document.///    ^^^^^^/// To reduce memory usage the qname length is limited by u16::MAX./// If the attribute exceeds that limit then the end of the returned range will be incorrect.range_value/// Returns attribute's value's range in bytes in the original document, excluding the surrounding quotes./// If the attribute's value is an empty string then the `start` and `end` of this `Range` are equal, and indicate the closing quote.///            ^^^^^/// To reduce memory usage the qname length is limited by u16::MAX,/// and the number of spaces around the equal sign is limited by u8::MAX./// If the attribute exceeds those limits then the start of the returned range will be incorrect./// A namespace./// Contains URI and *prefix* pair./// Returns namespace name/prefix.///     "<e xmlns:n='http://www.w3.org'/>"/// assert_eq!(doc.root_element().namespaces().nth(0).unwrap().name(), Some("n"));///     "<e xmlns='http://www.w3.org'/>"/// assert_eq!(doc.root_element().namespaces().nth(0).unwrap().name(), None);/// Returns namespace URI./// assert_eq!(doc.root_element().namespaces().nth(0).unwrap().uri(), "http://www.w3.org");// Deduplicated namespace values used throughout the documenttree_orderNamespaceIdx// Indices into the above in tree order as the document is parsedsorted_order// Indices into the above sorted by value used for deduplicationpush_nsnamespace_idxas_expanded_nameExpandedName/// An expanded name./// Contains an namespace URI and name pair./// Returns a namespace URI./// let doc = roxmltree::Document::parse("<e xmlns='http://www.w3.org'/>").unwrap();/// assert_eq!(doc.root_element().tag_name().namespace(), Some("http://www.w3.org"));/// Returns a local name./// assert_eq!(doc.root_element().tag_name().name(), "e");/// Create a new instance from static data./// use roxmltree::ExpandedName;/// const DAV_HREF: ExpandedName =///     ExpandedName::from_static("urn:ietf:params:xml:ns:caldav:", "calendar-data");/// Node's ID./// The tree containing the node./// Node's data./// A node in a document./// # Document Order/// The implementation of the `Ord` traits for `Node` is based on the concept of *document-order*./// In layman's terms, document-order is the order in which one would see each element if/// one opened a document in a text editor or web browser and scrolled down./// Document-order convention is followed in XPath, CSS Counters, and DOM selectors API/// to ensure consistent results from selection./// One difference in `roxmltree` is that there is the notion of more than one document/// in existence at a time. While Nodes within the same document are in document-order,/// Nodes in different documents will be grouped together, but not in any particular/// As an example, if we have a Document `a` with Nodes `[a0, a1, a2]` and a/// Document `b` with Nodes `[b0, b1]`, these Nodes in order could be either/// `[a0, a1, a2, b0, b1]` or `[b0, b1, a0, a1, a2]` and roxmltree makes no/// guarantee which it will be./// Document-order is defined here in the/// [W3C XPath Recommendation](https://www.w3.org/TR/xpath-3/#id-document-order)/// The use of document-order in DOM Selectors is described here in the/// [W3C Selectors API Level 1](https://www.w3.org/TR/selectors-api/#the-apis)node_type/// Returns node's type./// Checks that node is a root node.is_element/// Checks that node is an element node.is_pi/// Checks that node is a processing instruction node.is_comment/// Checks that node is a comment node./// Checks that node is a text node./// Returns node's document./// Returns node's tag name./// Returns an empty name with no namespace if the current node is not an element.has_tag_name/// Checks that node has a specified tag name./// assert!(doc.root_element().has_tag_name(("http://www.w3.org", "e")));/// assert!(!doc.root_element().has_tag_name("b"));/// assert!(!doc.root_element().has_tag_name(("http://www.w4.org", "e")));default_namespace/// Returns node's default namespace URI./// assert_eq!(doc.root_element().default_namespace(), Some("http://www.w3.org"));/// let doc = roxmltree::Document::parse("<e xmlns:n='http://www.w3.org'/>").unwrap();/// assert_eq!(doc.root_element().default_namespace(), None);lookup_prefix/// Returns a prefix for a given namespace URI./// assert_eq!(doc.root_element().lookup_prefix("http://www.w3.org"), Some("n"));/// let doc = roxmltree::Document::parse("<e xmlns:n=''/>").unwrap();/// assert_eq!(doc.root_element().lookup_prefix(""), Some("n"));lookup_namespace_uri/// Returns an URI for a given prefix./// assert_eq!(doc.root_element().lookup_namespace_uri(Some("n")), Some("http://www.w3.org"));/// assert_eq!(doc.root_element().lookup_namespace_uri(None), Some("http://www.w3.org"));/// Returns element's attribute value./// let doc = roxmltree::Document::parse("<e a='b'/>").unwrap();/// assert_eq!(doc.root_element().attribute("a"), Some("b"));/// assert_eq!(doc.root_element().attribute(("http://www.w3.org", "a")), Some("c"));attribute_node/// Returns element's attribute object./// The same as [`attribute()`], but returns the `Attribute` itself instead of a value string./// [`attribute()`]: struct.Node.html#method.attribute/// Checks that element has a specified attribute./// assert!(doc.root_element().has_attribute("a"));/// assert!(doc.root_element().has_attribute(("http://www.w3.org", "a")));/// assert!(!doc.root_element().has_attribute("b"));/// assert!(!doc.root_element().has_attribute(("http://www.w4.org", "a")));/// Returns element's attributes./// assert_eq!(doc.root_element().attributes().len(), 2);NamespaceIter/// Returns element's namespaces./// assert_eq!(doc.root_element().namespaces().len(), 1);/// Returns node's text./// - for an element will return a first text child/// - for a comment will return a self text/// - for a text node will return a self text/// assert_eq!(doc.root_element().text(),///            Some("\n    text\n"));/// assert_eq!(doc.root_element().first_child().unwrap().text(),/// assert_eq!(doc.root().first_child().unwrap().text(), Some(" comment "));text_storage/// Returns node's text storage./// Returns element's tail text./// <root>///     text1///     <p/>///     text2/// </root>/// let p = doc.descendants().find(|n| n.has_tag_name("p")).unwrap();/// assert_eq!(p.tail(), Some("\n    text2\n"));tail_storage/// Returns element's tail text storage./// Returns node as Processing Instruction./// Returns the parent of this node.parent_element/// Returns the parent element of this node./// Returns the previous sibling of this node.prev_sibling_element/// Returns the previous sibling element of this node./// Returns the next sibling of this node.next_sibling_element/// Returns the next sibling element of this node./// Returns the first child of this node.first_element_child/// Returns the first element child of this node./// Returns the last child of this node.last_element_child/// Returns the last element child of this node.has_siblings/// Returns true if this node has siblings./// Returns true if this node has children.AxisIter/// Returns an iterator over ancestor nodes starting at this node.prev_siblings/// Returns an iterator over previous sibling nodes starting at this node.next_siblings/// Returns an iterator over next sibling nodes starting at this node.first_children/// Returns an iterator over first children nodes starting at this node.last_children/// Returns an iterator over last children nodes starting at this node./// Returns an iterator over children nodes./// Returns an iterator over this node and its descendants./// Returns node's range in bytes in the original document./// Returns node's NodeId/// Iterator over a node's attributes/// Iterator over specified axis./// Iterator over children./// Iterator over a node and its descendants./// Iterator over the namespaces attached to a node./*!
Represent an [XML](https://www.w3.org/TR/xml/) document as a read-only tree.

The root point of the documentations is [`Document::parse`].

You can find more details in the [README] and the [parsing doc].

The tree structure itself is a heavily modified <https://github.com/causal-agent/ego-tree>
License: ISC.

[`Document::parse`]: struct.Document.html#method.parse
[README]: https://github.com/RazrFalcon/roxmltree/blob/master/README.md
[parsing doc]: https://github.com/RazrFalcon/roxmltree/blob/master/docs/parsing.md
*/StrSpanInvalidXmlPrefixUri/// The `xmlns:xml` attribute must have an <http://www.w3.org/XML/1998/namespace> URI.UnexpectedXmlUri/// Only the `xmlns:xml` attribute can have the <http://www.w3.org/XML/1998/namespace> URI.UnexpectedXmlnsUri/// The <http://www.w3.org/2000/xmlns/> URI must not be declared.InvalidElementNamePrefix/// `xmlns` can't be used as an element prefix.DuplicatedNamespace/// A namespace was already defined on this element.UnknownNamespace/// An unknown namespace./// Indicates that an element or an attribute has an unknown qualified name prefix./// The first value is a prefix.UnexpectedCloseTag/// Incorrect tree structure./// expected, actual, positionUnexpectedEntityCloseTag/// Entity value starts with a close tag./// ```xml/// <!DOCTYPE test [ <!ENTITY p '</p>'> ]>/// <root>&p;</root>UnknownEntityReference/// A reference to an entity that was not defined in the DTD.MalformedEntityReference/// A malformed entity reference./// A `&` character inside an attribute value or text indicates an entity reference./// Otherwise, the document is not well-formed.EntityReferenceLoop/// A possible entity reference loop./// The current depth limit is 10. The max number of references per reference is 255./// Attribute value cannot have a `<` character.DuplicatedAttribute/// An element has a duplicated attributes./// This also includes namespaces resolving./// So an element like this will lead to an error./// <e xmlns:n1='http://www.w3.org' xmlns:n2='http://www.w3.org' n1:a='b1' n2:a='b2'/>NoRootNode/// The XML document must have at least one element.UnclosedRootNode/// The root node was opened but never closed.UnexpectedDeclaration/// An XML document can have only one XML declaration/// and it must be at the start of the document.DtdDetected/// An XML with DTD detected./// This error will be emitted only when `ParsingOptions::allow_dtd` is set to `false`.NodesLimitReached/// Indicates that the [`ParsingOptions::nodes_limit`] was reached.AttributesLimitReached/// Indicates that too many attributes were parsed.NamespacesLimitReached/// Indicates that too many namespaces were parsed.InvalidName/// An invalid name.NonXmlChar/// A non-XML character has occurred./// Valid characters are: <https://www.w3.org/TR/xml/#char32>/// An invalid/unexpected character.InvalidChar2/// An unexpected string./// Contains what string was expected.InvalidExternalID/// An invalid ExternalID in the DTD.InvalidComment/// A comment cannot contain `--` or end with `-`.InvalidCharacterData/// A Character Data node contains an invalid data./// Currently, only `]]>` is not allowed.UnknownToken/// An unknown token.UnexpectedEndOfStream/// The steam ended earlier than we expected./// Should only appear on invalid input data./// A list of all possible errors./// Returns the error position.allow_dtd/// Allow DTD parsing./// When set to `false`, XML with DTD will cause an error./// Empty DTD block is not an error./// Currently, there is no option to simply skip DTD./// Mainly because you will get `UnknownEntityReference` error later anyway./// This flag is set to `false` by default for security reasons,/// but `roxmltree` still has checks for billion laughs attack,/// so this is just an extra security measure./// Default: falsenodes_limit/// Sets the maximum number of nodes to parse./// Useful when dealing with random input to limit memory usage./// Default: u32::MAX (no limit)ParsingOptions/// Parsing options.// Explicit for readability.// only used for feature "positions"TempAttributeData/// Parses the input XML string./// We do not support `&[u8]` or `Reader` because the input must be an already allocated/// UTF-8 string./// This is a shorthand for `Document::parse_with_options(data, ParsingOptions::default())`./// assert_eq!(doc.descendants().count(), 2); // root node + `e` element nodeparse_with_options/// Parses the input XML string using to selected options./// let opt = roxmltree::ParsingOptions::default();/// let doc = roxmltree::Document::parse_with_options("<e/>", opt).unwrap();Entityprefix_posTagNameSpannew_null/// References depth./// Number of references resolved by the root reference.LoopDetector/// An entity loop detector./// Limits:/// - Entities depth is 10./// - Maximum number of entity references per entity reference is 255./// Basically, if a text or an attribute has an entity reference and this reference/// has more than 10 nested references - this is an error./// This is useful for simple loops like:/// <!ENTITY a '&b;'>/// <!ENTITY b '&a;'>/// And, if a text or an attribute has an entity reference and it references more/// than 255 references - this is an error./// This is useful for cases like billion laughs attack, where depth can be pretty small,/// but the number of references is exponentially increasing:/// <!ENTITY lol "lol">/// <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">/// <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">/// <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">/// <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">inc_depthdec_depthinc_referencesnamespace_start_idxcurrent_attributesawaiting_subtreeparent_prefixesentitiesafter_textloop_detectorappend_nodeerr_pos_atXmlEventsprocess_attributeprocess_elementElementEndresolve_namespacesresolve_attributesprocess_textprocess_cdata// While the whole purpose of CDATA is to indicate to an XML library that this text// has to be stored as is, carriage return (`\r`) is still has to be replaced with `\n`.NextChunkparse_next_chunknormalize_attribute// https://www.w3.org/TR/REC-xml/#AVNormalizeis_normalization_required_normalize_attributeget_ns_idx_by_prefixgen_qname_stringCharToBytes/// Iterate over `char` by `u8`.push_rawpush_from_attrpush_from_text// Translate \r\n and any \r that is not followed by \n into a single \n character.// https://www.w3.org/TR/xml/#sec-line-endsis_xml_name_start/// Checks if the value is within the/// [NameStartChar](https://www.w3.org/TR/xml/#NT-NameStartChar) range.is_xml_name/// [NameChar](https://www.w3.org/TR/xml/#NT-NameChar) range.is_xml_char/// [Char](https://www.w3.org/TR/xml/#NT-Char) range.XmlCharExt/// Extension methods for XML-subset only operations.is_xml_space/// Checks if byte is a space./// `[ \r\n\t]`/// Checks if byte is within the ASCIIXmlByteExt/// A string slice./// Like `&str`, but also contains the position in the input XML/// from which it was parsed.from_substrslice_regionProcessingInstruction// <?target content?>// <!-- text -->EntityDeclaration// <!ENTITY ns_extend "http://test.com">ElementStart// <ns:elem// ns:attr="value"// Contains text between elements including whitespaces.// Basically everything between `>` and `<`.// Except `]]>`, which is not allowed and will lead to an error.Cdata// <![CDATA[text]]>/// Indicates `>`/// Indicates `</ns:name>`/// Indicates `/>`/// `ElementEnd` token.// document ::= prolog element Misc*parse_misc// Misc ::= Comment | PI | Sparse_declaration// XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'// We don't actually return a token for the XML declaration and only validate it.parse_comment// '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'parse_pi// PI       ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'// PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))parse_doctypeparse_doctype_start// doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' intSubset ']' S?)? '>'parse_external_id// ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteralparse_entity_decl// EntityDecl  ::= GEDecl | PEDecl// GEDecl      ::= '<!ENTITY' S Name S EntityDef S? '>'// PEDecl      ::= '<!ENTITY' S '%' S Name S PEDef S? '>'parse_entity_def// EntityDef   ::= EntityValue | (ExternalID NDataDecl?)// PEDef       ::= EntityValue | ExternalID// EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |  "'" ([^%&']//                             | PEReference | Reference)* "'"// ExternalID  ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral// NDataDecl   ::= S 'NDATA' S Nameconsume_declparse_element// element ::= EmptyElemTag | STag content ETag// '<' Name (S Attribute)* S? '>'// Attribute ::= Name Eq AttValueparse_content// content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*parse_cdata// CDSect  ::= CDStart CData CDEnd// CDStart ::= '<![CDATA['// CData   ::= (Char* - (Char* ']]>' Char*))// CDEnd   ::= ']]>'parse_close_element// '</' Name S? '>'/// An entity reference./// <https://www.w3.org/TR/xml/#NT-EntityRef>/// A character reference./// <https://www.w3.org/TR/xml/#NT-CharRef>/// Representation of the [Reference](https://www.w3.org/TR/xml/#NT-Reference) value.at_endcurr_bytecurr_byte_uncheckednext_byteconsume_bytetry_consume_byte// Unlike `consume_byte()` will not return any errors.skip_stringconsume_charsskip_charsslice_backslice_back_spanstarts_with_spaceconsume_spaces// Like `skip_spaces()`, but checks that first char is actually a space.try_consume_reference/// Consumes according to: <https://www.w3.org/TR/xml/#NT-Reference>consume_referenceconsume_name/// Consumes according to: <https://www.w3.org/TR/xml/#NT-Name>skip_name/// The same as `consume_name()`, but does not return a consumed name.consume_qname/// Consumes a qualified XML name and returns it./// Consumes according to: <https://www.w3.org/TR/xml-names/#ns-qualnames>consume_eqconsume_quotegen_text_pos/// Calculates a current absolute position./// This operation is very expensive. Use only for errors.gen_text_pos_from/// Calculates an absolute position at `pos`.calc_curr_rowcalc_curr_coltext_pos_1text_pos_2text_pos_3token_sizespan_sizeEntityDeclEventsCollectorcollect_tokenscdata_01cdata_02cdata_03cdata_04cdata_05cdata_06cdata_07cdata_08cdata_09cdata_err_01comment_01comment_02comment_03comment_04comment_05comment_06comment_07comment_08comment_09comment_10comment_11test_errcomment_err_01comment_err_02comment_err_03comment_err_04comment_err_05comment_err_06comment_err_07comment_err_08comment_err_09comment_err_10comment_err_11comment_err_12comment_err_13comment_err_14comment_err_15comment_err_16comment_err_17comment_err_18comment_err_19comment_err_20comment_err_21comment_err_22comment_err_23comment_err_24comment_err_25comment_err_26comment_err_27comment_err_28comment_err_29comment_err_30comment_err_31comment_err_32comment_err_33comment_err_34comment_err_35dtd_01dtd_02dtd_03dtd_04dtd_05dtd_06dtd_07dtd_08dtd_entity_01dtd_entity_02dtd_entity_03dtd_entity_04dtd_entity_05// TODO: NDATA will be ignoreddtd_entity_06// TODO: unsupported data will be ignoreddtd_entity_07// We do not support !ELEMENT DTD token and it will be skipped.// Previously, we were calling `Tokenizer::next` after the skip,// which is recursive and could cause a stack overflow when there are too many sequential// unsupported tokens.// This tests checks that the current code do not crash with stack overflow.dtd_err_01dtd_err_02dtd_err_03dtd_err_04dtd_err_05document_01document_02document_03document_05// BOMdocument_06document_07document_08document_09document_err_01// TODO: better errordocument_err_02document_err_03document_err_04document_err_05document_err_06element_01element_02element_03element_04element_06element_07element_08element_err_01element_err_02element_err_03element_err_04element_err_05element_err_06element_err_07element_err_08element_err_09element_err_10element_err_11element_err_12element_err_13element_err_14element_err_15element_err_16element_err_17element_err_18element_err_19attribute_01attribute_02attribute_03attribute_04attribute_05attribute_06attribute_07attribute_err_01attribute_err_02attribute_err_03attribute_err_04attribute_err_05attribute_err_06attribute_err_07pi_01pi_02pi_03pi_04pi_05pi_err_01declaration_01declaration_02declaration_03declaration_04declaration_05declaration_06declaration_07declaration_08declaration_09declaration_10declaration_err_01// Declaration with an invalid orderdeclaration_err_05declaration_err_06declaration_err_07declaration_err_08declaration_err_09declaration_err_10// XML declaration allowed only at the start of the document.declaration_err_11declaration_err_12// Duplicate.declaration_err_13declaration_err_14declaration_err_15declaration_err_16text_01text_02text_03// 欄 is EF A4 9D. And EF can be mistreated for UTF-8 BOM.text_04text_05text_06text_07text_err_01text_err_02// CDATA// Comments// DTD// Document// Elements// PIIoErrorKindzero_memory/// Sets all bytes of a String to 0fixes_newline/// Removes the \n from the read lineread_password/// Reads a password from STDINio_result/// Turns a C function return into an IO Resultread_password_from_stdin/// Reads a password from stdindisplay_on_tty/// Displays a prompt on the terminalread_password_with_reader/// Reads a password from anything that implements BufReadread_password_from_tty/// Reads a password from the terminalprompt_password_stdout/// Prompts for a password on STDOUT and reads it from STDINprompt_password_stderr/// Prompts for a password on STDERR and reads it from STDINmock_input_crlfmock_input_lfcan_read_from_redirected_input// Copyright 2014-2017 The Rpassword Developersfix_line_issuesprint_ttyprint_writersafe_stringSafeStringterm_origHiddenInputsafe_tcgetattr/// Reads a password from the TTYread_password_from_fd_with_hidden_input/// Reads a password from a given file descriptorread_password_from_bufreadprompt_password_from_bufread/// Prompts on the TTY and then reads a password from anything that implements BufReadprompt_password/// Prompts on the TTY and then reads a password from TTYcan_read_from_redirected_input_many_times//! This library makes it easy to read passwords in a console application on all platforms, Unix,//! Windows, WASM, etc.//! Here's how you can read a password://! let password = rpassword::read_password().unwrap();//! println!("Your password is {}", password);//! You can also prompt for a password://! let password = rpassword::prompt_password("Your password: ").unwrap();//! Finally, in unit tests, you might want to pass a `Cursor`, which implements `BufRead`. In that//! case, you can use `read_password_from_bufread` and `prompt_password_from_bufread`://! let mut mock_input = Cursor::new("my-password\n".as_bytes().to_owned());//! let password = rpassword::read_password_from_bufread(&mut mock_input).unwrap();//! let mut mock_output = Cursor::new(Vec::new());//! let password = rpassword::prompt_password_from_bufread(&mut mock_input, &mut mock_output, "Your password: ").unwrap();goodbyeGoodbyeREAL_PACKET// An RTCP packet from a packet dumptest_read_eoftest_bad_compoundtest_valid_packettest_cnametest_compound_packet_roundtripcompound_packet_testsource_descriptionCompoundPacket/// A CompoundPacket is a collection of RTCP packets transmitted as a single packet with/// the underlying protocol (for example UDP)./// To maximize the resolution of reception statistics, the first Packet in a CompoundPacket/// must always be either a SenderReport or a ReceiverReport.  This is true even if no data/// has been sent or received, in which case an empty ReceiverReport must be sent, and even/// if the only other RTCP packet in the compound packet is a Goodbye./// Next, a SourceDescription containing a CNAME item must be included in each CompoundPacket/// to identify the source and to begin associating media for purposes such as lip-sync./// Other RTCP packet types may follow in any order. Packet types may appear more than once.destination_ssrc/// destination_ssrc returns the synchronization sources associated with this/// CompoundPacket's reception report.marshal_sizemarshal_to/// Marshal encodes the CompoundPacket as binary./// Validate returns an error if this is not an RFC-compliant CompoundPacket.cname/// CNAME returns the CNAME that *must* be present in every CompoundPacketWrongMarshalSize/// Wrong marshal size.InvalidTotalLost/// Packet lost exceeds maximum amount of packets/// that can possibly be lost./// Packet contains an invalid header.EmptyCompound/// Packet contains empty compound.BadFirstPacket/// Invalid first packet in compound packets. First packet/// should either be a SenderReport packet or ReceiverReportMissingCname/// CNAME was not defined.PacketBeforeCname/// Packet was defined before CNAME.TooManyReports/// Too many reports.TooManyChunks/// Too many chunks.TooManySources/// Too many sources.PacketTooShort/// Packet received is too short./// Buffer is too short./// Wrong packet type.SdesTextTooLong/// SDES received is too long.SdesMissingType/// SDES type is missing.ReasonTooLong/// Reason is too long.BadVersion/// Invalid packet version.WrongPadding/// Invalid padding value.WrongFeedbackType/// Wrong feedback message type.WrongPayloadType/// Wrong payload type./// Header length is too small.SsrcMustBeZero/// Media ssrc was defined as zero.MissingRembIdentifier/// Missing REMB identifier.SsrcNumAndLengthMismatch/// SSRC number and length mismatches.InvalidSizeOrStartIndex/// Invalid size or start index.DeltaExceedLimit/// Delta exceeds limit.PacketStatusChunkLength/// Packet status chunk is not 2 bytes.InvalidBitrateWrongChunkTypeBadStructMemberTypeBadReadParameterInvalidBlockSizeDLRR_REPORT_LENGTHlast_rrdlrr/// DLRRReport encodes a single report inside a DLRRReportBlock.reports/// DLRRReportBlock encodes a DLRR Report Block as described in/// RFC 3611 section 4.5.///  0                   1                   2                   3///  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/// |     BT=5      |   reserved    |         block length          |/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+/// |                 SSRC_1 (ssrc of first receiver)               | sub-/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block/// |                         last RR (LRR)                         |   1/// |                   delay since last RR (DLRR)                  |/// |                 SSRC_2 (ssrc of second receiver)              | sub-/// :                               ...                             :   2xr_headerXRHeader/// destination_ssrc returns an array of ssrc values that this report block refers to./// marshal_to encodes the DLRRReportBlock in binary/// Unmarshal decodes the DLRRReportBlock from binarydecoded_packetencoded_packetextended_report_testprtrrtssrvmPacketReceiptTimesReportBlockDuplicateRLEReportBlockLossRLEReportBlockRLEReportBlockReceiverReferenceTimeReportBlockStatisticsSummaryReportBlockTTLorHopLimitTypeUnknownReportBlockVoIPMetricsReportBlockHEADER_LENGTHSSRC_LENGTHget_padding_sizeput_paddingXR_HEADER_LENGTHLossRLEDuplicateRLE// RFC 3611, section 4.1PacketReceiptTimes// RFC 3611, section 4.2ReceiverReferenceTime// RFC 3611, section 4.3DLRR// RFC 3611, section 4.4StatisticsSummary// RFC 3611, section 4.5VoIPMetrics// RFC 3611, section 4.6// RFC 3611, section 4.7/// BlockType specifies the type of report in a report block/// Extended Report block types from RFC 3611./// converts the Extended report block types into readable stringsTypeSpecificField/// TypeSpecificField as described in RFC 3611 section 4.5. In typical/// cases, users of ExtendedReports shouldn't need to access this,/// and should instead use the corresponding fields in the actual/// report blocks themselves.type_specific/// XRHeader defines the common fields that must appear at the start/// of each report block. In typical cases, users of ExtendedReports/// shouldn't need to access this. For locally-constructed report/// blocks, these values will not be accurate until the corresponding/// packet is marshaled./// marshal_to encodes the ExtendedReport in binary/// Unmarshal decodes the ExtendedReport from binary/// The ExtendedReport packet is an Implementation of RTCP Extended/// reports defined in RFC 3611. It is used to convey detailed/// information about an RTP stream. Each packet contains one or/// more report blocks, each of which conveys a different kind of/// |V=2|P|reserved |   PT=XR=207   |             length            |/// |                              ssrc                             |/// :                         report blocks                         :/// Header returns the Header associated with this packet./// destination_ssrc returns an array of ssrc values that this packet refers to.PRT_REPORT_BLOCK_MIN_LENGTH//not included in marshal/unmarshal//marshal/unmarshalbegin_seqend_seqreceipt_time/// PacketReceiptTimesReportBlock represents a Packet Receipt Times/// report block, as described in RFC 3611 section 4.3./// |     BT=3      | rsvd. |   t   |         block length          |/// |                        ssrc of source                         |/// |          begin_seq            |             end_seq           |/// |       Receipt time of packet begin_seq                        |/// |       Receipt time of packet (begin_seq + 1) mod 65536        |/// :                              ...                              :/// |       Receipt time of packet (end_seq - 1) mod 65536          |/// marshal_to encodes the PacketReceiptTimesReportBlock in binary/// Unmarshal decodes the PacketReceiptTimesReportBlock from binaryRLE_REPORT_BLOCK_MIN_LENGTHRunLengthBitVectorTerminatingNull/// ChunkType enumerates the three kinds of chunks described in RFC 3611 section 4.1./// Chunk as defined in RFC 3611, section 4.1. These represent information/// about packet losses and packet duplication. They have three representations:/// Run Length Chunk:///   0                   1///   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5///  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+///  |C|R|        run length         |/// Bit Vector Chunk:///  |C|        bit vector           |/// Terminating Null Chunk:///  |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0|chunk_type/// chunk_type returns the ChunkType that this Chunk represents/// run_type returns the run_type that this Chunk represents. It is/// only valid if ChunkType is RunLengthChunkType./// value returns the value represented in this Chunkis_loss_rle/// RleReportBlock defines the common structure used by both/// Loss RLE report blocks (RFC 3611 §4.1) and Duplicate RLE/// report blocks (RFC 3611 §4.2)./// |  BT = 1 or 2  | rsvd. |   t   |         block length          |/// |          chunk 1              |             chunk 2           |/// |          chunk n-1            |             chunk n           |/// LossRLEReportBlock is used to report information about packet/// losses, as described in RFC 3611, section 4.1/// make sure to set is_loss_rle = true/// DuplicateRLEReportBlock is used to report information about packet/// duplication, as described in RFC 3611, section 4.1/// make sure to set is_loss_rle = false/// marshal_to encodes the RLEReportBlock in binary/// Unmarshal decodes the RLEReportBlock from binaryRRT_REPORT_BLOCK_LENGTHntp_timestamp/// ReceiverReferenceTimeReportBlock encodes a Receiver Reference Time/// report block as described in RFC 3611 section 4.4./// |     BT=4      |   reserved    |       block length = 2        |/// |              NTP timestamp, most significant word             |/// |             NTP timestamp, least significant word             |/// marshal_to encodes the ReceiverReferenceTimeReportBlock in binary/// Unmarshal decodes the ReceiverReferenceTimeReportBlock from binarySSR_REPORT_BLOCK_LENGTHloss_reportsduplicate_reportsjitter_reportsttl_or_hop_limitdup_packetsmin_jittermax_jittermean_jitterdev_jittermin_ttl_or_hlmax_ttl_or_hlmean_ttl_or_hldev_ttl_or_hl/// StatisticsSummaryReportBlock encodes a Statistics Summary Report/// Block as described in RFC 3611, section 4.6./// |     BT=6      |L|D|J|ToH|rsvd.|       block length = 9        |/// |                        lost_packets                           |/// |                        dup_packets                            |/// |                         min_jitter                            |/// |                         max_jitter                            |/// |                         mean_jitter                           |/// |                         dev_jitter                            |/// | min_ttl_or_hl | max_ttl_or_hl |mean_ttl_or_hl | dev_ttl_or_hl |MissingIPv4IPv6/// TTLorHopLimitType encodes values for the ToH field in/// a StatisticsSummaryReportBlock/// marshal_to encodes the StatisticsSummaryReportBlock in binary/// Unmarshal decodes the StatisticsSummaryReportBlock from binary/// UnknownReportBlock is used to store bytes for any report block/// that has an unknown Report Block Type./// marshal_to encodes the UnknownReportBlock in binary/// Unmarshal decodes the UnknownReportBlock from binaryVM_REPORT_BLOCK_LENGTHdiscard_rateburst_densitygap_densityburst_durationgap_durationround_trip_delayend_system_delaysignal_levelnoise_levelrerlgminrfactorext_rfactormos_lqmos_cqrx_configjb_nominaljb_maximumjb_abs_max/// VoIPMetricsReportBlock encodes a VoIP Metrics Report Block as described/// in RFC 3611, section 4.7./// |     BT=7      |   reserved    |       block length = 8        |/// |   loss rate   | discard rate  | burst density |  gap density  |/// |       burst duration          |         gap duration          |/// |     round trip delay          |       end system delay        |/// | signal level  |  noise level  |     RERL      |     Gmin      |/// |   R factor    | ext. R factor |    MOS-LQ     |    MOS-CQ     |/// |   RX config   |   reserved    |          JB nominal           |/// |          JB maximum           |          JB abs max           |/// marshal_to encodes the VoIPMetricsReportBlock in binary/// Unmarshal decodes the VoIPMetricsReportBlock from binarytest_goodbye_unmarshaltest_goodbye_round_tripgoodbye_test/// The SSRC/CSRC identifiers that are no longer active/// Optional text indicating the reason for leaving, e.g., "camera malfunction" or "RTP loop detected"/// The Goodbye packet indicates that one or more sources are no longer active./// destination_ssrc returns an array of SSRC values that this packet refers to./// marshal_to encodes the packet in binary.// RFC 3550, 6.4.1SourceDescription// RFC 3550, 6.4.2// RFC 3550, 6.5ApplicationDefined// RFC 3550, 6.6TransportSpecificFeedback// RFC 3550, 6.7 (unimplemented)PayloadSpecificFeedback// RFC 4585, 6051// RFC 4585, 6.3// RFC 3611/// PacketType specifies the type of an RTCP packet/// RTCP packet types registered with IANA. See: https://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-4FORMAT_SLI/// Transport and Payload specific feedback messages overload the count field to act as a message type. those are listed hereFORMAT_PLIFORMAT_FIRFORMAT_TLNFORMAT_RRRFORMAT_REMBFORMAT_TCC/// Transport and Payload specific feedback messages overload the count field to act as a message type. those are listed here./// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01#page-5RTP_VERSIONVERSION_SHIFTVERSION_MASKPADDING_SHIFTPADDING_MASKCOUNT_SHIFTCOUNT_MASKCOUNT_MAXSDES_MAX_OCTET_COUNT/// If the padding bit is set, this individual RTCP packet contains/// some additional padding octets at the end which are not part of/// the control information but are included in the length field./// The number of reception reports, sources contained or FMT in this packet (depending on the Type)packet_type/// The RTCP packet type for this packet/// The length of this RTCP packet in 32-bit words minus one,/// including the header and any padding./// A Header is the common header shared by all RTCP packets/// Marshal encodes the Header in binary/// Unmarshal decodes the Header from binarytest_header_unmarshaltest_header_roundtripcompound_packetraw_packet//! Package rtcp implements encoding and decoding of RTCP packets according to RFCs 3550 and 5506.//! RTCP is a sister protocol of the Real-time Transport Protocol (RTP). Its basic functionality//! and packet structure is defined in RFC 3550. RTCP provides out-of-band statistics and control//! information for an RTP session. It partners with RTP in the delivery and packaging of multimedia data,//! but does not transport any media data itself.//! The primary function of RTCP is to provide feedback on the quality of service (QoS)//! in media distribution by periodically sending statistics information such as transmitted octet//! and packet counts, packet loss, packet delay variation, and round-trip delay time to participants//! in a streaming multimedia session. An application may use this information to control quality of//! service parameters, perhaps by limiting flow, or using a different codec.//! Decoding RTCP packets://!```nobuild//!     let pkt = rtcp::unmarshal(&rtcp_data).unwrap();//!     if let Some(e) = pkt//!          .as_any()//!          .downcast_ref::<PictureLossIndication>()//!      {//!     else if let Some(e) = packet//!          .downcast_ref::<Goodbye>(){}//!     ....//!```//! Encoding RTCP packets://!     let pkt = PictureLossIndication{//!         sender_ssrc: sender_ssrc,//!         media_ssrc: media_ssrc//!     let pli_data = pkt.marshal().unwrap();receiver_estimated_maximum_bitrateslice_loss_indicationrapid_resynchronization_request/// Packet represents an RTCP packet, a protocol used for out-of-band statistics and/// control information for an RTP session/// marshal takes an array of Packets and serializes them to a single buffer/// Unmarshal takes an entire udp datagram (which may consist of multiple RTCP packets) and/// returns the unmarshaled packets it contains./// If this is a reduced-size RTCP packet a feedback packet (Goodbye, SliceLossIndication, etc)/// will be returned. Otherwise, the underlying type of the returned packet will be/// CompoundPacket.unmarshaller/// unmarshaller is a factory which pulls the first RTCP packet from a bytestream,/// and returns it's parsed representation, and the amount of data that was processed.test_packet_unmarshaltest_packet_unmarshal_emptytest_packet_invalid_header_lengthtest_packet_unmarshal_firefoxtest_full_intra_request_unmarshaltest_full_intra_request_round_triptest_full_intra_request_unmarshal_headerfull_intra_request_test/// A FIREntry is a (ssrc, seqno) pair, as carried by FullIntraRequest.fir/// The FullIntraRequest packet is used to reliably request an Intra frame/// in a video stream.  See RFC 5104 Section 3.5.1.  This is not for loss/// recovery, which should use PictureLossIndication (PLI) instead.FIR_OFFSET/// Marshal encodes the FullIntraRequest/// Unmarshal decodes the FullIntraRequestpicture_loss_indication_testPLI_LENGTH/// SSRC of sender/// SSRC where the loss was experienced/// The PictureLossIndication packet informs the encoder about the loss of an undefined amount of coded video data belonging to one or more pictures/// Marshal encodes the PictureLossIndication in binary/// Unmarshal decodes the PictureLossIndication from binarytest_picture_loss_indication_unmarshaltest_picture_loss_indication_roundtriptest_picture_loss_indication_unmarshal_headerreceiver_estimated_maximum_bitrate_test/// Estimated maximum bitrate/// SSRC entries which this packet applies toReceiverEstimatedMaximumBitrate/// ReceiverEstimatedMaximumBitrate contains the receiver's estimated maximum bitrate./// * [draft-alvestrand-rmcat-remb-03]/// [draft-alvestrand-rmcat-remb-03]: https://tools.ietf.org/html/draft-alvestrand-rmcat-remb-03REMB_OFFSETBIT_UNITS/// Keep a table of powers to units for fast conversion./// String prints the REMB packet in a human-readable format./// Marshal serializes the packet and returns a byte slice./// Unmarshal reads a REMB packet from the given byte slice.test_receiver_estimated_maximum_bitrate_marshaltest_receiver_estimated_maximum_bitrate_unmarshaltest_receiver_estimated_maximum_bitrate_truncatetest_receiver_estimated_maximum_bitrate_overflowslice_loss_indication_testSLI_LENGTHSLI_OFFSET/// ID of first lost slice/// Number of lost slices/// ID of related pictureSliEntry/// SLIEntry represents a single entry to the SLI packet's/// list of lost slices./// SSRC of the media sourcesli_entriesSliceLossIndication/// The SliceLossIndication packet informs the encoder about the loss of a picture slice/// Marshal encodes the SliceLossIndication in binary/// Unmarshal decodes the SliceLossIndication from binarytest_slice_loss_indication_unmarshaltest_slice_loss_indication_roundtripRawPacket/// RawPacket represents an unparsed RTCP packet. It's returned by Unmarshal when/// a packet with an unknown type is encountered./// Marshal encodes the packet in binary./// Unmarshal decodes the packet from binary.test_raw_packet_roundtripreceiver_report_testRR_SSRC_OFFSETRR_REPORT_OFFSET/// The synchronization source identifier for the originator of this RR packet./// Zero or more reception report blocks depending on the number of other/// sources heard by this sender since the last report. Each reception report/// block conveys statistics on the reception of RTP packets from a/// single synchronization source.profile_extensions/// Extension contains additional, payload-specific information that needs to/// be reported regularly about the receiver./// A ReceiverReport (RR) packet provides reception quality feedback for an RTP stream/// Unmarshal decodes the ReceiverReport from binarytest_receiver_report_unmarshaltest_receiver_report_roundtripRECEPTION_REPORT_LENGTHFRACTION_LOST_OFFSETTOTAL_LOST_OFFSETLAST_SEQ_OFFSETJITTER_OFFSETLAST_SR_OFFSETDELAY_OFFSET/// The SSRC identifier of the source to which the information in this/// reception report block pertains./// The fraction of RTP data packets from source SSRC lost since the/// previous SR or RR packet was sent, expressed as a fixed point/// number with the binary point at the left edge of the field./// The total number of RTP data packets from source SSRC that have/// been lost since the beginning of reception./// The least significant 16 bits contain the highest sequence number received/// in an RTP data packet from source SSRC, and the most significant 16 bits extend/// that sequence number with the corresponding count of sequence number cycles./// An estimate of the statistical variance of the RTP data packet/// interarrival time, measured in timestamp units and expressed as an/// unsigned integer./// The middle 32 bits out of 64 in the NTP timestamp received as part of/// the most recent RTCP sender report (SR) packet from source SSRC. If no/// SR has been received yet, the field is set to zero./// The delay, expressed in units of 1/65536 seconds, between receiving the/// last SR packet from source SSRC and sending this reception report block./// If no SR packet has been received yet from SSRC, the field is set to zero./// A ReceptionReport block conveys statistics on the reception of RTP packets/// from a single synchronization source./// marshal_to encodes the ReceptionReport in binary/// unmarshal decodes the ReceptionReport from binarysender_report_testSR_HEADER_LENGTHSR_SSRC_OFFSETSR_REPORT_OFFSETSR_NTP_OFFSETNTP_TIME_LENGTHSR_RTP_OFFSETRTP_TIME_LENGTHSR_PACKET_COUNT_OFFSETSR_PACKET_COUNT_LENGTHSR_OCTET_COUNT_OFFSETSR_OCTET_COUNT_LENGTH/// The synchronization source identifier for the originator of this SR packet.ntp_time/// The wallclock time when this report was sent so that it may be used in/// combination with timestamps returned in reception reports from other/// receivers to measure round-trip propagation to those receivers.rtp_time/// Corresponds to the same time as the NTP timestamp (above), but in/// the same units and with the same random offset as the RTP/// timestamps in data packets. This correspondence may be used for/// intra- and inter-media synchronization for sources whose NTP/// timestamps are synchronized, and may be used by media-independent/// receivers to estimate the nominal RTP clock frequency./// The total number of RTP data packets transmitted by the sender/// since starting transmission up until the time this SR packet was/// The total number of payload octets (i.e., not including header or/// padding) transmitted in RTP data packets by the sender since/// starting transmission up until the time this SR packet was/// ProfileExtensions contains additional, payload-specific information that needs to/// be reported regularly about the sender./// A SenderReport (SR) packet provides reception quality feedback for an RTP stream/// Unmarshal decodes the SenderReport from binarytest_sender_report_unmarshaltest_sender_report_roundtripsource_description_testSDES_SOURCE_LENSDES_TYPE_LENSDES_TYPE_OFFSETSDES_OCTET_COUNT_LENSDES_OCTET_COUNT_OFFSETSDES_TEXT_OFFSETSdesTypeSdesEndSdesCname// end of SDES list                RFC 3550, 6.5SdesName// canonical name                  RFC 3550, 6.5.1SdesEmail// user name                       RFC 3550, 6.5.2SdesPhone// user's electronic mail address  RFC 3550, 6.5.3SdesLocation// user's phone number             RFC 3550, 6.5.4SdesTool// geographic user location        RFC 3550, 6.5.5SdesNote// name of application or tool     RFC 3550, 6.5.6SdesPrivate// notice about the source         RFC 3550, 6.5.7// private extensions              RFC 3550, 6.5.8  (not implemented)/// SDESType is the item type used in the RTCP SDES control packet./// RTP SDES item types registered with IANA. See: https://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-5/// The source (ssrc) or contributing source (csrc) identifier this packet describesSourceDescriptionItemSourceDescriptionChunk/// A SourceDescriptionChunk contains items describing a single RTP source/// Marshal encodes the SourceDescriptionChunk in binary/// Unmarshal decodes the SourceDescriptionChunk from binarysdes_type/// The type identifier for this item. eg, SDESCNAME for canonical name description./// Type zero or SDESEnd is interpreted as the end of an item list and cannot be used./// Text is a unicode text blob associated with the item. Its meaning varies based on the item's Type./// A SourceDescriptionItem is a part of a SourceDescription that describes a stream./// Marshal encodes the SourceDescriptionItem in binary/// Unmarshal decodes the SourceDescriptionItem from binary/// A SourceDescription (SDES) packet describes the sources in an RTP stream./// Marshal encodes the SourceDescription in binary/// Unmarshal decodes the SourceDescription from binarytest_source_description_unmarshaltest_source_description_roundtriprapid_resynchronization_request_testRRR_LENGTHRRR_HEADER_LENGTHRRR_MEDIA_OFFSETRapidResynchronizationRequest/// The RapidResynchronizationRequest packet informs the encoder about the loss of an undefined amount of coded video data belonging to one or more pictures/// Destination SSRC returns an array of SSRC values that this packet refers to./// Marshal encodes the RapidResynchronizationRequest in binary/// Unmarshal decodes the RapidResynchronizationRequest from binarytest_rapid_resynchronization_request_unmarshaltest_rapid_resynchronization_request_roundtriptransport_layer_cc_test/// 0                   1                   2                   3/// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1/// |V=2|P|  FMT=15 |    PT=205     |           length              |/// |                     SSRC of packet sender                     |/// |                      SSRC of media source                     |/// |      base sequence number     |      packet status count      |/// |                 reference time                | fb pkt. count |/// |          packet chunk         |         packet chunk          |/// .                                                               ./// |         packet chunk          |  recv delta   |  recv delta   |/// |           recv delta          |  recv delta   | zero padding  |// for packet status chunk/// type of packet status chunk/// * [draft-holmer-rmcat-transport-wide-cc-extensions-01, page 5]/// [draft-holmer-rmcat-transport-wide-cc-extensions-01, page 5]: https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01#page-5PacketNotReceived/// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01#section-3.1.1PacketReceivedSmallDeltaPacketReceivedLargeDeltaPacketReceivedWithoutDelta/// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01#page-7/// see Example 2: "packet received, w/o recv delta"/// type of packet status symbol and recv deltaOneBit/// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01#section-3.1.4TwoBit/// for status vector chunk/// PacketStatusChunk has two kinds:/// RunLengthChunk and StatusVectorChunk/// Marshal ..type_tcc/// T = TypeTCCRunLengthChunkpacket_status_symbol/// S: type of packet status/// kind: TypeTCCPacketNotReceived or...run_length/// run_length: count of S/// RunLengthChunk T=TypeTCCRunLengthChunk/// 0                   1/// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/// |T| S |       Run Length        |/// Unmarshal ..symbol_size/// TypeTCCSymbolSizeOneBit or TypeTCCSymbolSizeTwoBitsymbol_list/// when symbol_size = TypeTCCSymbolSizeOneBit, symbol_list is 14*1bit:/// TypeTCCSymbolListPacketReceived or TypeTCCSymbolListPacketNotReceived/// when symbol_size = TypeTCCSymbolSizeTwoBit, symbol_list is 7*2bit:/// TypeTCCPacketNotReceived TypeTCCPacketReceivedSmallDelta TypeTCCPacketReceivedLargeDelta or typePacketReserved/// StatusVectorChunk T=typeStatusVectorChunk/// |T|S|       symbol list         |type_tcc_packet/// us/// RecvDelta are represented as multiples of 250us/// small delta is 1 byte: [0，63.75]ms = [0, 63750]us = [0, 255]*250us/// big delta is 2 bytes: [-8192.0, 8191.75]ms = [-8192000, 8191750]us = [-32768, 32767]*250us/// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01#section-3.1.5BASE_SEQUENCE_NUMBER_OFFSET/// The offset after headerPACKET_STATUS_COUNT_OFFSETREFERENCE_TIME_OFFSETFB_PKT_COUNT_OFFSETPACKET_CHUNK_OFFSETTYPE_TCC_STATUS_VECTOR_CHUNK/// len of packet status chunkNUM_OF_BITS_OF_SYMBOL_SIZEPACKET_STATUS_CHUNK_LENGTH/// Transport wide sequence of rtp extensionpacket_status_count/// packet_status_countreference_time/// reference_timefb_pkt_count/// fb_pkt_countpacket_chunks/// packet_chunksrecv_deltas/// recv_deltas/// TransportLayerCC for sender-BWE// Notice: RFC is wrong: "packet received" (0) and "packet not received" (1)// if S == TYPE_TCCSYMBOL_SIZE_ONE_BIT, symbol list will be: TypeTCCPacketNotReceived TypeTCCPacketReceivedSmallDelta// if S == TYPE_TCCSYMBOL_SIZE_TWO_BIT, symbol list will be same as above:test_transport_layer_cc_run_length_chunk_unmarshaltest_transport_layer_cc_run_length_chunk_marshaltest_transport_layer_cc_status_vector_chunk_unmarshaltest_transport_layer_cc_status_vector_chunk_marshaltest_transport_layer_cc_recv_delta_unmarshaltest_transport_layer_cc_recv_delta_marshaltest_transport_layer_cc_unmarshal/// 0b10101111,0b11001101,0b00000000,0b00000101,/// 0b11111010,0b00010111,0b11111010,0b00010111,/// 0b01000011,0b00000011,0b00101111,0b10100000,/// 0b00000000,0b10011001,0b00000000,0b00000001,/// 0b00111101,0b11101000,0b00000010,0b00010111,/// 0b00100000,0b00000001,0b10010100,0b00000001,test_transport_layer_cc_marshaltransport_layer_nack_testPacketBitmap/// PacketBitmap shouldn't be used like a normal integral,/// so it's type is masked here. Access it with PacketList().packet_id/// ID of lost packets/// Bitmask of following lost packets/// NackPair is a wire-representation of a collection of/// Lost RTP packetshas_yielded_packet_idNackIteratorpacket_list/// PacketList returns a list of Nack'd packets that's referenced by a NackPair/// Create an iterator over all the packet sequence numbers expressed by this NACK pair.TLN_LENGTHNACK_OFFSETnacks// The TransportLayerNack packet informs the encoder about the loss of a transport packet/// * [RFC 4585 §6.2.1]/// [RFC 4585 §6.2.1]: https://tools.ietf.org/html/rfc4585#section-6.2.1/// returns the Header associated with this packet./// Unmarshal decodes the ReceptionReport from binarytest_transport_layer_nack_unmarshaltest_transport_layer_nack_roundtriptest_nack_pairtest_nack_pair_rangetest_transport_layer_nack_pair_generationtest_lost_packets_is_reset_when_crossing_16_bit_boundary/// This test case reproduced a bug in the implementation// returns the padding required to make the length a multiple of 4set_nbits_of_uint16// set_nbits_of_uint16 will truncate the value to size, left-shift to start_index position and setappend_nbits_to_uint32// appendBit32 will left-shift and append n bits of valget_nbits_from_byte// getNBit get n bits from 1 byte, begin with a positionget_24bits_from_bytes// get24BitFromBytes get 24bits from `[3]byte` slicetest_get_paddingtest_set_nbits_of_uint16// Copyright (c) 2015-2019 Doug Tangren// Permission is hereby granted, free of charge, to any person obtaining// a copy of this software and associated documentation files (the// "Software"), to deal in the Software without restriction, including// without limitation the rights to use, copy, modify, merge, publish,// distribute, sublicense, and/or sell copies of the Software, and to// permit persons to whom the Software is furnished to do so, subject to// the following conditions:// The above copyright notice and this permission notice shall be// included in all copies or substantial portions of the Software./// Normalizes the return of `read_line()` in the context of a CLI applicationsafe_vec/// Displays a message on the TTY/// Prints a message to a writer/// String that is zeroed when droppedStringVisitorsafe_string_serializationTestStructsafe_string_within_struct_serializationsafe_string_deserializationsafe_string_within_struct_deserializationSafeVec/// Vec that is zeroed when droppedread_leb128obuOBU_HAS_EXTENSION_BITOBU_TYPE_FRAMEOBU_TYPE_FRAME_HEADEROBU_TYPE_METADATAOBU_TYPE_SEQUENCE_HEADEROBU_TYPE_TEMPORAL_DELIMITEROBU_TYPE_TILE_GROUPOBU_TYPE_TILE_LISTOBU_EXTENSION_S1T1NEW_CODED_VIDEO_SEQUENCE_BITAv1Obuwith_extensionwithout_sizewith_payloadbuild_av1_frametest_packetize_one_obu_without_size_and_extensiontest_packetize_one_obu_without_size_with_extensionremoves_obu_size_field_without_extensionremoves_obu_size_field_with_extensiontest_omits_size_for_last_obu_when_three_obus_fits_into_the_packettest_use_size_for_all_obus_when_four_obus_fits_into_the_packettest_discards_temporal_delimiter_and_tile_list_obutest_split_two_obus_into_two_packet_force_split_obu_headertest_sets_n_bit_at_the_first_packet_of_a_key_frame_with_sequence_headertest_doesnt_set_n_bit_at_the_packets_of_a_key_frame_without_sequence_headertest_doesnt_set_n_bit_at_the_packets_of_a_delta_frametest_split_single_obu_into_two_packetstest_split_single_obu_into_many_packetstest_split_two_obus_into_two_packetsread_leb128_0read_leb128_5_byteencode_leb128decode_leb128leb128_sizeput_leb128BytesMutExtobu_has_extensionparse_obusOBU_HAS_SIZE_BITpacketizerget_aggregation_headerpacketizeAGGREGATION_HEADER_SIZEMAX_NUM_OBUS_TO_OMIT_SIZEPayloaderav1_testAv1Payloader/// Based on <https://chromium.googlesource.com/external/webrtc/+/4e513346ec56c829b3a6010664998469fc237b35/modules/rtp_rtcp/source/rtp_packetizer_av1.cc>/// Reference: <https://aomediacodec.github.io/av1-rtp-spec/#45-payload-structure>clone_toErrPayloadTooSmallForObuExtensionHeaderErrPayloadTooSmallForObuPayloadSizeOBU_TYPE_MASKOBU_TYPE_PADDINGextension_header/// size of the header and payload combined.Obu/// Parses the payload into series of OBUs./// Reference: https://aomediacodec.github.io/av1-spec/#obu-syntaxobu_has_sizeobu_typeshould_ignore_obu_type//! Based on https://chromium.googlesource.com/external/webrtc/+/4e513346ec56c829b3a6010664998469fc237b35/modules/rtp_rtcp/source/rtp_packetizer_av1.cc//! Reference: https://aomediacodec.github.io/av1-spec/#obu-syntax/// When there are 3 or less OBU (fragments) in a packet, size of the last one/// can be omitted.first_obu_indexnum_obu_elementsfirst_obu_offsetlast_obu_size/// Total size consumed by the packet.PacketMetadata/// Returns the scheme for how to aggregate or split the OBUs across RTP packets./// Reference: https://aomediacodec.github.io/av1-rtp-spec/#45-payload-structure///            https://aomediacodec.github.io/av1-rtp-spec/#5-packetization-rules/// Returns the aggregation header for the packet./// Reference: https://aomediacodec.github.io/av1-rtp-spec/#44-av1-aggregation-headeradditional_bytes_for_previous_obu_element/// Returns the number of additional bytes needed to store the previous OBU/// element if an additional OBU element is added to the packet.max_fragment_size/// Given |remaining_bytes| free bytes left in a packet, returns max size of an/// OBU fragment that can fit into the packet./// i.e. MaxFragmentSize + Leb128Size(MaxFragmentSize) <= remaining_bytes.//! Reference: https://aomediacodec.github.io/av1-rtp-spectest_g7xx_payloadg7xx_testG711PayloaderG7xxPayloader/// G711Payloader payloads G711 packetsG722Payloader/// G722Payloader payloads G722 packets/// Payload fragments an G7xx packet across one or more byte arraystest_h264_payloadtest_h264_packet_unmarshaltest_h264_partition_head_checker_is_partition_headtest_h264_payloader_payload_sps_and_pps_handling// Silence warning on `for i in 0..vec.len() { … }`:h264_testDepacketizersps_nalupps_naluH264Payloader/// H264Payloader payloads H264 packetsSTAPA_NALU_TYPEFUA_NALU_TYPEFUB_NALU_TYPESPS_NALU_TYPEPPS_NALU_TYPEAUD_NALU_TYPEFILLER_NALU_TYPEFUA_HEADER_SIZESTAPA_HEADER_SIZESTAPA_NALU_LENGTH_SIZENALU_TYPE_BITMASKNALU_REF_IDC_BITMASKFU_START_BITMASKFU_END_BITMASKOUTPUT_STAP_AHEADERANNEXB_NALUSTART_CODEnext_ind/// Payload fragments a H264 packet across one or more byte arraysis_avcfua_bufferH264Packet/// H264Packet represents the H264 header that is stored in the payload of an RTP Packetdepacketize/// depacketize parses the passed byte slice and stores the result in the H264Packet this method is called uponis_partition_head/// is_partition_head checks if this is the head of a packetized nalu stream.is_partition_tailtest_h265_nalu_headertest_h265_fu_headertest_h265_single_nalunit_packettest_h265_aggregation_packettest_h265_fragmentation_unit_packettest_h265_temporal_scalability_control_informationtest_h265_paci_packettest_h265_packettest_h265_packet_realh265_testANNEXB_3_NALUSTART_CODESING_PAYLOAD_HDRAGGR_PAYLOAD_HDRFRAG_PAYLOAD_HDRFU_HDR_IDR_SFU_HDR_IDR_MFU_HDR_IDR_EFU_HDR_P_SFU_HDR_P_MFU_HDR_P_EFU_HDR_B_SFU_HDR_B_MFU_HDR_B_ERTP_OUTBOUND_MTUH265FRAGMENTATION_UNIT_HEADER_SIZENAL_HEADER_SIZEVPSSPSPPSCRASEIIDRPFRBFRfor_idvps_naluHevcPayloaderH265NALU_HEADER_SIZE/// Network Abstraction Unit Header implementationH265NALU_AGGREGATION_PACKET_TYPE/// <https://datatracker.ietf.org/doc/html/rfc7798#section-4.4.2>H265NALU_FRAGMENTATION_UNIT_TYPE/// <https://datatracker.ietf.org/doc/html/rfc7798#section-4.4.3>H265NALU_PACI_PACKET_TYPE/// <https://datatracker.ietf.org/doc/html/rfc7798#section-4.4.4>H265NALUHeader/// H265NALUHeader is a H265 NAL Unit Header/// +---------------+---------------+/// |0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|/// |F|   Type    |  layer_id  | tid|/// +-------------+-----------------+/// * [RFC 7798 §1.1.4]/// [RFC 7798 §1.1.4]: https://tools.ietf.org/html/rfc7798#section-1.1.4/// f is the forbidden bit, should always be 0.nalu_type/// nalu_type of NAL Unit.is_type_vcl_unit/// is_type_vcl_unit returns whether or not the NAL Unit type is a VCL NAL unit.layer_id/// layer_id should always be 0 in non-3D HEVC context.tid/// tid is the temporal identifier of the NAL unit +1.is_aggregation_packet/// is_aggregation_packet returns whether or not the packet is an Aggregation packet.is_fragmentation_unit/// is_fragmentation_unit returns whether or not the packet is a Fragmentation Unit packet.is_paci_packet/// is_paci_packet returns whether or not the packet is a PACI packet.payload_header/// payload_header is the header of the H265 packet.donl/// donl is a 16-bit field, that may or may not be present./// payload of the fragmentation unit.might_need_donlH265SingleNALUnitPacket/// Single NAL Unit Packet implementation/// H265SingleNALUnitPacket represents a NALU packet, containing exactly one NAL unit.///     0                   1                   2                   3///    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1///   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+///   |           PayloadHdr          |      DONL (conditional)       |///   |                                                               |///   |                  NAL unit payload data                        |///   |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+///   |                               :...OPTIONAL RTP padding        |/// * [RFC 7798 §4.4.1]/// [RFC 7798 §4.4.1]: https://tools.ietf.org/html/rfc7798#section-4.4.1with_donl/// with_donl can be called to specify whether or not DONL might be parsed./// DONL may need to be parsed if `sprop-max-don-diff` is greater than 0 on the RTP stream./// depacketize parses the passed byte slice and stores the result in the H265SingleNALUnitPacket this method is called upon./// payload_header returns the NALU header of the packet./// donl returns the DONL of the packet./// payload returns the Fragmentation Unit packet payload.nal_unit_sizenal_unitH265AggregationUnitFirst/// Aggregation Packets implementation/// H265AggregationUnitFirst represent the First Aggregation Unit in an AP.///    0                   1                   2                   3///                   :       DONL (conditional)      |   NALU size   |///   |   NALU size   |                                               |///   +-+-+-+-+-+-+-+-+         NAL unit                              |///   |                               :///   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/// * [RFC 7798 §4.4.2]/// [RFC 7798 §4.4.2]: https://tools.ietf.org/html/rfc7798#section-4.4.2/// donl field, when present, specifies the value of the 16 least/// significant bits of the decoding order number of the aggregated NALnalu_size/// nalu_size represents the size, in bytes, of the nal_unit./// nal_unit payload.dondH265AggregationUnit/// H265AggregationUnit represent the an Aggregation Unit in an AP, which is not the first one.///                   : DOND (cond)   |          NALU size            |///   |                       NAL unit                                |/// dond field plus 1 specifies the difference between/// the decoding order number values of the current aggregated NAL unit/// and the preceding aggregated NAL unit in the same AP.first_unitother_unitsH265AggregationPacket/// H265AggregationPacket represents an Aggregation packet.///   0                   1                   2                   3///   |    PayloadHdr (Type=48)       |                               |///   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               |///   |             two or more aggregation units                     |/// depacketize parses the passed byte slice and stores the result in the H265AggregationPacket this method is called upon./// first_unit returns the first Aggregated Unit of the packet./// other_units returns the all the other Aggregated Unit of the packet (excluding the first one).H265FragmentationUnitHeader/// Fragmentation Unit implementation/// H265FragmentationUnitHeader is a H265 FU Header/// +---------------+/// |0|1|2|3|4|5|6|7|/// +-+-+-+-+-+-+-+-+/// |S|E|  fu_type   |/// s represents the start of a fragmented NAL unit./// e represents the end of a fragmented NAL unit.fu_type/// fu_type MUST be equal to the field Type of the fragmented NAL unit.fu_header/// fu_header is the header of the fragmentation unitH265FragmentationUnitPacket/// H265FragmentationUnitPacket represents a single Fragmentation Unit packet./// |    PayloadHdr (Type=49)       |   FU header   | DONL (cond)   |/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-|/// | DONL (cond)   |                                               |/// |-+-+-+-+-+-+-+-+                                               |/// |                         FU payload                            |/// |                                                               |/// |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/// |                               :...OPTIONAL RTP padding        |/// * [RFC 7798 §4.4.3]/// [RFC 7798 §4.4.3]: https://tools.ietf.org/html/rfc7798#section-4.4.3/// depacketize parses the passed byte slice and stores the result in the H265FragmentationUnitPacket this method is called upon./// fu_header returns the Fragmentation Unit Header of the packet.paci_header_fields/// Field which holds value for `A`, `cType`, `phssize`, `F0`, `F1`, `F2` and `Y` fields.phes/// phes is a header extension, of byte length `phssize`/// payload contains NAL units & optional paddingH265PACIPacket/// PACI implementation/// H265PACIPacket represents a single H265 PACI packet./// |    PayloadHdr (Type=50)       |A|   cType   | phssize |F0..2|Y|/// |        payload Header Extension Structure (phes)              |/// |=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=|/// |                  PACI payload: NAL unit                       |/// |                   . . .                                       |/// * [RFC 7798 §4.4.4]/// [RFC 7798 §4.4.4]: https://tools.ietf.org/html/rfc7798#section-4.4.4/// payload_header returns the NAL Unit Header./// a copies the F bit of the PACI payload NALU./// ctype copies the Type field of the PACI payload NALU.phs_size/// phs_size indicates the size of the phes field.f0/// f0 indicates the presence of a Temporal Scalability support extension in the phes./// f1 must be zero, reserved for future extensions./// f2 must be zero, reserved for future extensions./// y must be zero, reserved for future extensions./// phes contains header extensions. Its size is indicated by phssize./// payload is a single NALU or NALU-like struct, not including the first two octets (header).tsciH265TSCI/// tsci returns the Temporal Scalability Control Information extension, if present./// depacketize parses the passed byte slice and stores the result in the H265PACIPacket this method is called upon./// Temporal Scalability Control Information/// H265TSCI is a Temporal Scalability Control Information header extension./// * [RFC 7798 §4.5]/// [RFC 7798 §4.5]: https://tools.ietf.org/html/rfc7798#section-4.5tl0picidx/// tl0picidx see RFC7798 for more details.irap_pic_id/// irap_pic_id see RFC7798 for more details./// s see RFC7798 for more details./// e see RFC7798 for more details./// res see RFC7798 for more details.H265Payload/// H265 Payload EnumH265Packet/// Packet implementation/// H265Packet represents a H265 packet, stored in the payload of an RTP packet./// payload returns the populated payload./// Must be casted to one of:/// - H265SingleNALUnitPacket/// - H265FragmentationUnitPacket/// - H265AggregationPacket/// - H265PACIPacket/// depacketize parses the passed byte slice and stores the result in the H265Packet this method is called upong7xxopusopus_testOpusPayloaderOpusPacket/// OpusPacket represents the Opus header that is stored in the payload of an RTP Packettest_opus_unmarshaltest_opus_payloadtest_opus_is_partition_headvp8_testVP8_HEADER_SIZEenable_picture_idpicture_idVp8Payloader/// Vp8Payloader payloads VP8 packets/// Payload fragments a VP8 packet across one or more byte arrays/// Required Header/// extended controlbits present/// when set to 1 this frame can be discarded/// start of VP8 partition/// partition index/// Extended control bits/// 1 if PictureID is present/// 1 if tl0picidx is present/// 1 if tid is present/// 1 if KEYIDX is present/// Optional extension/// 8 or 16 bits, picture IDtl0_pic_idx/// 8 bits temporal level zero index/// 2 bits temporal layer index/// 1 bit layer sync bitkey_idx/// 5 bits temporal key frame indexVp8Packet/// Vp8Packet represents the VP8 header that is stored in the payload of an RTP Packet/// depacketize parses the passed byte slice and stores the result in the VP8Packet this method is called upon/// is_partition_head checks whether if this is a head of the VP8 partitiontest_vp8_unmarshaltest_vp8_payloadtest_vp8_payload_errortest_vp8_partition_head_checker_is_partition_headvp9_testVP9HEADER_SIZE/// Flexible mode 15 bit picture IDMAX_SPATIAL_LAYERSMAX_VP9REF_PICSInitialPictureIDFn/// InitialPictureIDFn is a function that returns random initial picture ID.initial_picture_id_fnVp9Payloader/// Vp9Payloader payloads VP9 packets/// Payload fragments an Vp9Payloader packet across one or more byte arrays/// picture ID is present/// inter-picture predicted frame./// layer indices present/// flexible mode/// start of frame. beginning of new vp9 frame/// end of frame/// scalability structure (SS) present/// Not a reference frame for upper spatial layers/// Recommended headers/// 7 or 16 bits, picture ID./// Conditionally recommended headers/// Temporal layer ID/// Switching up point/// Spatial layer ID/// Inter-layer dependency usedpdiff/// Conditionally required headers/// Reference index (F=1)/// Temporal layer zero index (F=0)/// Scalability structure headers/// N_S + 1 indicates the number of spatial layers present in the VP9 stream/// Each spatial layer's frame resolution present/// PG description present flag.ng/// N_G indicates the number of pictures in a Picture Group (PG)pgtid/// Temporal layer ID of pictures in a Picture Grouppgu/// Switching up point of pictures in a Picture Grouppgpdiff/// Reference indices of pictures in a Picture GroupVp9Packet/// Vp9Packet represents the VP9 header that is stored in the payload of an RTP Packet/// depacketize parses the passed byte slice and stores the result in the Vp9Packet this method is called upon/// is_partition_head checks whether if this is a head of the VP9 partitionparse_picture_id// Picture ID://      +-+-+-+-+-+-+-+-+// I:   |M| PICTURE ID  |   M:0 => picture id is 7 bits.//      +-+-+-+-+-+-+-+-+   M:1 => picture id is 15 bits.// M:   | EXTENDED PID  |parse_layer_infoparse_layer_info_common// Layer indices (flexible mode):// L:   |  T  |U|  S  |D|parse_layer_info_non_flexible_mode// Layer indices (non-flexible mode)://      |   tl0picidx   |parse_ref_indices// Reference indices://      +-+-+-+-+-+-+-+-+                P=1,F=1: At least one reference index// P,F: | P_DIFF      |N|  up to 3 times          has to be specified.//      +-+-+-+-+-+-+-+-+                    N=1: An additional P_DIFF follows//                                                current P_DIFF.parse_ssdata// Scalability structure (SS):// V:   | N_S |Y|G|-|-|-|//      +-+-+-+-+-+-+-+-+              -|// Y:   |     WIDTH     | (OPTIONAL)    .//      +               +               .//      |               | (OPTIONAL)    .//      +-+-+-+-+-+-+-+-+               . N_S + 1 times//      |     HEIGHT    | (OPTIONAL)    .// G:   |      N_G      | (OPTIONAL)//      +-+-+-+-+-+-+-+-+                           -|// N_G: |  T  |U| R |-|-| (OPTIONAL)                 .//      +-+-+-+-+-+-+-+-+              -|            . N_G times//      |    P_DIFF     | (OPTIONAL)    . R times    .//      +-+-+-+-+-+-+-+-+              -|           -|test_vp9_packet_unmarshaltest_vp9_payloader_payloadtest_vp9_partition_head_checker_is_partition_headErrHeaderSizeInsufficientErrHeaderSizeInsufficientForExtensionErrHeaderExtensionsNotEnabledErrHeaderExtensionNotFoundErrRfc8285oneByteHeaderIdrangeErrRfc8285oneByteHeaderSizeErrRfc8285twoByteHeaderIdrangeErrRfc8285twoByteHeaderSizeErrRfc3550headerIdrangeErrShortPacketErrNilPacketErrTooManyPDiffErrTooManySpatialLayersErrUnhandledNaluTypeErrH265CorruptedPacketErrInvalidH265PacketTypeHeaderExtensionPayloadNot32BitWordsAudioLevelOverflowPlayoutDelayOverflowPayloadIsNotLargeEnoughStapASizeLargerThanBufferNaluTypeIsNotHandledABS_SEND_TIME_RESOLUTIONtest_ntp_conversiontest_abs_send_time_extension_roundtriptest_abs_send_time_extension_estimateabs_send_time_extension_testABS_SEND_TIME_EXTENSION_SIZEAbsSendTimeExtension/// AbsSendTimeExtension is a extension payload format in/// http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time/// Unmarshal parses the passed byte slice and stores the result in the members./// MarshalSize returns the size of the AbsSendTimeExtension once marshaled./// MarshalTo serializes the members to buffer.estimate/// Estimate absolute send time according to the receive time./// Note that if the transmission delay is larger than 64 seconds, estimated time will be wrong./// NewAbsSendTimeExtension makes new AbsSendTimeExtension from time.Time.ntp2unixtest_audio_level_extension_too_smalltest_audio_level_extension_voice_truetest_audio_level_extension_voice_falsetest_audio_level_extension_level_overflowaudio_level_extension_testAUDIO_LEVEL_EXTENSION_SIZE// AUDIO_LEVEL_EXTENSION_SIZE One byte header sizevoiceAudioLevelExtension/// AudioLevelExtension is a extension payload format described in/// Implementation based on:/// https://chromium.googlesource.com/external/webrtc/+/e2a017725570ead5946a4ca8235af27470ca0df9/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.cc#49/// One byte format:/// |  ID   | len=0 |V| level       |/// Two byte format:/// |      ID       |     len=1     |V|    level    |    0 (pad)    |/// * [RFC 6464]/// [RFC 6464]: https://tools.ietf.org/html/rfc6464/// Unmarshal parses the passed byte slice and stores the result in the members/// MarshalSize returns the size of the AudioLevelExtension once marshaled./// MarshalTo serializes the members to bufferaudio_level_extensionplayout_delay_extensionvideo_orientation_extensionHeaderExtensionAbsSendTimeAudioLevelPlayoutDelayExtensionPlayoutDelayTransportCcVideoOrientationExtensionVideoOrientation/// A custom extension/// A generic RTP header extension.playout_delay_extension_testPLAYOUT_DELAY_EXTENSION_SIZEPLAYOUT_DELAY_MAX_VALUEmin_delay/// PlayoutDelayExtension is an extension payload format described in/// http://www.webrtc.org/experiments/rtp-hdrext/playout-delay/// |  ID   | len=2 |       MIN delay       |       MAX delay       |/// MarshalSize returns the size of the PlayoutDelayExtension once marshaled.test_playout_delay_extension_roundtriptest_playout_delay_value_overflowtransport_cc_extension_testTRANSPORT_CC_EXTENSION_SIZE// transport-wide sequencetransport_sequence/// TransportCCExtension is a extension payload format in/// https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions-01/// |       0xBE    |    0xDE       |           length=1            |/// |  ID   | L=1   |transport-wide sequence number | zero padding  |/// MarshalSize returns the size of the TransportCcExtension once marshaled./// Marshal serializes the members to buffertest_transport_cc_extension_too_smalltest_transport_cc_extensiontest_transport_cc_extension_extra_bytesvideo_orientation_extension_testVIDEO_ORIENTATION_EXTENSION_SIZE// One byte header sizeCameraDirectionVideoRotation/// Coordination of Video Orientation in RTP streams./// Coordination of Video Orientation consists in signaling of the current/// orientation of the image captured on the sender side to the receiver for/// appropriate rendering and displaying./// C = Camera: indicates the direction of the camera used for this video///     stream. It can be used by the MTSI client in receiver to e.g. display///     the received video differently depending on the source camera./// 0: Front-facing camera, facing the user. If camera direction is///    unknown by the sending MTSI client in the terminal then this is the///    default value used./// 1: Back-facing camera, facing away from the user./// F = Flip: indicates a horizontal (left-right flip) mirror operation on///     the video as sent on the link.///    0                   1///    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5///   |  ID   | len=0 |0 0 0 0 C F R R|Degree0Degree90Degree180Degree270test_video_orientation_extension_too_smalltest_video_orientation_extension_back_facing_cameratest_video_orientation_extension_flip_truetest_video_orientation_extension_degree_90test_video_orientation_extension_degree_180test_video_orientation_extension_degree_270EXTENSION_SHIFTEXTENSION_MASKEXTENSION_PROFILE_ONE_BYTEEXTENSION_PROFILE_TWO_BYTEEXTENSION_ID_RESERVEDCC_MASKMARKER_SHIFTMARKER_MASKPT_MASKSEQ_NUM_OFFSETSEQ_NUM_LENGTHTIMESTAMP_OFFSETTIMESTAMP_LENGTHSSRC_OFFSETCSRC_OFFSETCSRC_LENGTHcsrcextension_profileextensions_padding/// Header represents an RTP packet header/// NOTE: PayloadOffset is populated by Marshal/Unmarshal and should not be modified/// Unmarshal parses the passed byte slice and stores the result in the Header this method is called upon/// MarshalSize returns the size of the packet once marshaled./// Marshal serializes the header and writes to the buffer.get_extension_payload_lenset_extension/// SetExtension sets an RTP header extensionget_extension_ids/// returns an extension id arrayget_extension/// returns an RTP header extensiondel_extension/// Removes an RTP Header extensionpacket_test/// Packet represents an RTP Packet/// NOTE: Raw is populated by Marshal/Unmarshal and should not be modified/// MarshalTo serializes the packet and writes to the buffer./// getPadding Returns the padding required to make the length a multiple of 4test_extensiontest_paddingtest_packet_marshal_unmarshaltest_rfc_8285_one_byte_extensiontest_rfc_8285_one_byte_two_extension_of_two_bytestest_rfc_8285_one_byte_multiple_extensions_with_paddingtest_rfc_8285_one_byte_multiple_extensiontest_rfc_8285_two_byte_extensiontest_rfc8285_two_byte_multiple_extension_with_paddingtest_rfc8285_two_byte_multiple_extension_with_large_extensiontest_rfc8285_get_extension_returns_nil_when_extension_disabledtest_rfc8285_del_extensiontest_rfc8285_get_extension_idstest_rfc8285_get_extension_ids_return_empty_when_extension_disabledtest_rfc8285_del_extension_returns_error_when_extensions_disabledtest_rfc8285_one_byte_set_extension_should_enable_extension_when_addingtest_rfc8285_set_extension_should_set_correct_extension_profile_for_16_byte_extensiontest_rfc8285_set_extension_should_update_existing_extensiontest_rfc8285_one_byte_set_extension_should_error_when_invalid_id_providedtest_rfc8285_one_byte_extension_terminate_processing_when_reserved_id_encounteredtest_rfc8285_one_byte_set_extension_should_error_when_payload_too_largetest_rfc8285_two_bytes_set_extension_should_enable_extension_when_addingtest_rfc8285_two_byte_set_extension_should_update_existing_extensiontest_rfc8285_two_byte_set_extension_should_error_when_payload_too_largetest_rfc3550_set_extension_should_error_when_non_zerotest_rfc3550_set_extension_should_error_when_setting_non_zero_idCasestest_unmarshal_error_handlingtest_round_trippacketizer_test/// Payloader payloads a byte array for use as rtp.Packet payloadsenable_abs_send_timeskip_samplesPacketizer/// Packetizer packetizes a payload/// Checks if the packet is at the beginning of a partition.  This/// should return false if the result could not be determined, in/// which case the caller will detect timestamp discontinuities./// Checks if the packet is at the end of a partition.  This should/// return false if the result could not be determined./// Depacketizer depacketizes a RTP payload, removing any RTP specific data from the payload//TODO: SystemTime vs Instant?// non-monotonic clock vs monotonically non-decreasing clock/// FnTimeGen provides current SystemTimepayloadersequencerSequencerabs_send_timetime_gen//http://www.webrtc.org/experiments/rtp-hdrext/abs-send-timePacketizerImplnew_packetizer/// skip_samples causes a gap in sample count between Packetize requests so the/// RTP payloads produced have a gap in timestampstest_packetizertest_packetizer_abs_send_timetest_packetizer_timestamp_rollover_does_not_panicroll_over_count/// Sequencer generates sequential sequence numbers for building RTP packetsnew_random_sequencer/// NewRandomSequencer returns a new sequencer starting from a random sequence/// numbernew_fixed_sequencer/// NewFixedSequencer returns a new sequencer starting from a specific/// sequence numberSequencerImpl/// NextSequenceNumber increment and returns a new sequence number for/// building RTP packets/// RollOverCount returns the amount of times the 16bit sequence number/// has wrappedResampleErrorResampleResultResamplerConstructionErrorinterpolationinterpolator_avxAvxInterpolatorinterpolator_sseSseInterpolatormake_sincsWindowFunctionupdate_mask_from_buffersvalidate_buffersResamplerInterpolationParametersInterpolationTypeget_sinc_interpolated/// Make the scalar product between the waveform starting at `index` and the sinc of `subindex`.
/// Get sinc length
/// Check if sincs are empty
nbr_sincs/// Get number of sincs used for oversampling
SincInterpolator/// Functions for making the scalar product with a sinc
sincsScalarInterpolator/// A plain scalar interpolator
/// Calculate the scalar produt of an input wave and the selected sinc filter
/// Create a new ScalarInterpolator
/// Parameters are:
/// - `sinc_len`: Length of sinc functions.
/// - `oversampling_factor`: Number of intermediate sincs (oversampling factor).
/// - `f_cutoff`: Relative cutoff frequency.
/// - `window`: Window function to use.
nbr_channelslast_indexresample_ratioresample_ratio_originalmax_relative_ratioSincFixedIn/// An asynchronous resampler that accepts a fixed number of audio frames for input
/// and returns a variable number of frames.
/// The resampling is done by creating a number of intermediate points (defined by oversampling_factor)
/// by sinc interpolation. The new samples are then calculated by interpolating between these points.
/// The resampling ratio can be freely adjusted within the range specified to the constructor.
/// Adjusting the ratio does not recalculate the sinc functions used by the anti-aliasing filter.
/// This causes no issue when increasing the ratio (which slows down the output).
/// However when decreasing more than a few percent (or speeding up the output),
/// the filters can no longer suppress all aliasing and this may lead to some artefacts.
/// Higher maximum ratios require more memory to be allocated by [Resampler::output_buffer_allocate].
needed_input_sizecurrent_buffer_fillSincFixedOut/// An asynchronous resampler that return a fixed number of audio frames.
/// The number of input frames required is given by the
/// [input_frames_next](Resampler::input_frames_next) function.
/// However when decreasing more than a few percent (i.e. speeding up the output),
/// Higher maximum ratios require more memory to be allocated by
/// [input_buffer_allocate](Resampler::input_buffer_allocate) and an internal buffer.
make_interpolatorinterp_cubic/// Perform cubic polynomial interpolation to get value at x.
/// Input points are assumed to be at x = -1, 0, 1, 2
interp_lin/// Linear interpolation between two points at x=0 and x=1
validate_ratios/// Create a new SincFixedIn
/// - `resample_ratio`: Starting ratio between output and input sample rates, must be > 0.
/// - `max_resample_ratio_relative`: Maximum ratio that can be set with [Resampler::set_resample_ratio] relative to `resample_ratio`, must be >= 1.0. The minimum relative ratio is the reciprocal of the maximum. For example, with `max_resample_ratio_relative` of 10.0, the ratio can be set between `resample_ratio * 10.0` and `resample_ratio / 10.0`.
/// - `parameters`: Parameters for interpolation, see `InterpolationParameters`
/// - `chunk_size`: size of input data in frames
/// - `nbr_channels`: number of channels in input/output
new_with_interpolator/// Create a new SincFixedIn using an existing Interpolator
/// - `max_resample_ratio_relative`: Maximum ratio that can be set with [Resampler::set_resample_ratio] relative to `resample_ratio`, must be >= 1.0. The minimum relative ratio is the reciprocal of the maximum. For example, with `max_resample_ratio_relative` of 10.0, the ratio can be set between `resample_ratio` * 10.0 and `resample_ratio` / 10.0.
/// - `interpolation_type`: Parameters for interpolation, see `InterpolationParameters`
/// - `interpolator`:  The interpolator to use
/// - `chunk_size`: size of output data in frames
process_into_bufferoutput_frames_maxoutput_frames_nextinput_frames_maxinput_frames_nextset_resample_ratioset_resample_ratio_relative/// Create a new SincFixedOut
/// Create a new SincFixedOut using an existing Interpolator
asynchrotest_scalar_interpolator_64test_scalar_interpolator_32int_cubicint_lin_32int_cubic_32int_linmake_resampler_fimake_resampler_fi_32make_resampler_fi_skippedmake_resampler_fi_downsamplemake_resampler_fi_upsamplemake_resampler_fomake_resampler_fo_32make_resampler_fo_skippedmake_resampler_fo_downsamplemake_resampler_fo_upsampleCpuFeatureSse3/// x86 sse3 cpu feature.
/// x86_64 avx cpu feature.
Fma/// the fma cpu feature.
/// An identifier for a cpu feature.
is_detected/// Test if the given CPU feature is detected.
MissingCpuFeature/// Error raised when trying to use a CPU feature which is not supported.
InvalidSampleRateInvalidRelativeRatioInvalidRatio/// The error type returned when constructing [Resampler](crate::Resampler)
providedRatioOutOfBounds/// Error raised when [Resampler::set_resample_ratio](crate::Resampler::set_resample_ratio)
/// is called with a ratio outside the maximum range specified when
/// the resampler was constructed.
SyncNotAdjustable/// Error raised when calling [Resampler::set_resample_ratio](crate::Resampler::set_resample_ratio)
/// on a synchronous resampler.
WrongNumberOfInputChannels/// Error raised when the number of channels of the input buffer doesn't match expected.
WrongNumberOfOutputChannels/// Error raised when the number of channels of the output buffer doesn't match expected.
WrongNumberOfMaskChannels/// Error raised when the number of channels of the mask doesn't match expected.
WrongNumberOfInputFrames/// Error raised when the number of frames in a single channel doesn't match
/// the expected.
/// The error type used by `rubato`.
/// A result alias for the error type used by `rubato`.
get_nearest_times_2/// Get the two nearest time points for time t in format (index, subindex)
get_nearest_times_4/// Get the four nearest time points for time t in format (index, subindex).
get_nearest_time/// Get the nearest time point for time t in format (index, subindex).
get_nearest_2get_nearest_4get_nearest_4_negget_nearest_4_zeroget_nearest_single_mm256_castpd256_pd128_mm256_castps256_ps128_mm256_extractf128_pd_mm256_extractf128_ps_mm256_add_pd_mm256_fmadd_pd_mm256_loadu_pd_mm256_setzero_pd_mm_add_pd_mm_hadd_pd_mm_store_sd_mm256_fmadd_ps_mm256_loadu_ps_mm256_setzero_ps_mm_add_ps_mm_hadd_ps_mm_store_ss/// Collection of cpu features required for this interpolator.
pack_sincs/// Pack sincs into a vector.
/// This is unsafe because it uses target_enable dispatching. There are no
/// special requirements from the caller.
get_sinc_interpolated_unsafe/// Interpolate a sinc sample.
/// The caller must ensure that the various indexes are not out of bounds
/// in the collection of sincs.
AvxSample/// Trait governing what can be done with an AvxSample.
/// An AVX accelerated interpolator
/// Create a new AvxInterpolator
test_avx_interpolator_64test_avx_interpolator_32vadd_f32vaddq_f32vfmaq_f32vld1q_f32vmovq_n_f32vst1_f32vget_high_f32vget_low_f32vaddq_f64vfmaq_f64vld1q_f64vmovq_n_f64vst1q_f64NeonSample/// Trait governing what can be done with an NeonSample.
NeonInterpolator/// A SSE accelerated interpolator
/// Create a new NeonInterpolator
interpolator_neontest_neon_interpolator_64test_neon_interpolator_32_mm_loadu_pd_mm_mul_pd_mm_setzero_pd_mm_loadu_ps_mm_mul_ps_mm_setzero_psSseSample/// Trait governing what can be done with an SseSample.
/// Create a new SseInterpolator
test_sse_interpolator_64test_sse_interpolator_32// Logging wrapper macros to avoid cluttering the code with conditionals
synchroFftFixedInFftFixedInOutFftFixedOut/// Helper macro to define a dummy implementation of the sample trait if a
/// feature is not supported.
r" Dummy trait when not supported.
"r" Dummy impl of trait when not supported.
"sinc_len/// Length of the windowed sinc interpolation filter.
/// Higher values can allow a higher cut-off frequency leading to less high frequency roll-off
/// at the expense of higher cpu usage. 256 is a good starting point.
/// The value will be rounded up to the nearest multiple of 8.
f_cutoff/// Relative cutoff frequency of the sinc interpolation filter
/// (relative to the lowest one of fs_in/2 or fs_out/2). Start at 0.95, and increase if needed.
oversampling_factor/// The number of intermediate points to use for interpolation.
/// Higher values use more memory for storing the sinc filters.
/// Only the points actually needed are calculated during processing
/// so a larger number does not directly lead to higher cpu usage.
/// But keeping it down helps in keeping the sincs in the cpu cache. Start at 128.
/// Interpolation type, see `InterpolationType`
/// Window function to use.
/// A struct holding the parameters for interpolation.
/// For cubic interpolation, the four nearest intermediate points are calculated
/// using sinc interpolation.
/// Then a cubic polynomial is fitted to these points, and is then used to calculate the new sample value.
/// The computation time as about twice the one for linear interpolation,
/// but it requires much fewer intermediate points for a good result.
/// With linear interpolation the new sample value is calculated by linear interpolation
/// between the two nearest points.
/// This requires two intermediate points to be calculated using sinc interpolation,
/// and te output is a weighted average of these two.
/// This is relatively fast, but needs a large number of intermediate points to
/// push the resampling artefacts below the noise floor.
/// The Nearest mode doesn't do any interpolation, but simply picks the nearest intermediate point.
/// This is useful when the nearest point is actually the correct one, for example when upsampling by a factor 2,
/// like 48kHz->96kHz.
/// Then setting the oversampling_factor to 2, and using Nearest mode,
/// no unnecessary computations are performed and the result is the same as for synchronous resampling.
/// This also works for other ratios that can be expressed by a fraction. For 44.1kHz -> 48 kHz,
/// setting oversampling_factor to 160 gives the desired result (since 48kHz = 160/147 * 44.1kHz).
/// Interpolation methods that can be selected. For asynchronous interpolation where the
/// ratio between input and output sample rates can be any number, it's not possible to
/// pre-calculate all the needed interpolation filters.
/// Instead they have to be computed as needed, which becomes impractical since the
/// sincs are very expensive to generate in terms of cpu time.
/// It's more efficient to combine the sinc filters with some other interpolation technique.
/// Then sinc filters are used to provide a fixed number of interpolated points between input samples,
/// and then the new value is calculated by interpolation between those points.
/// This is a convenience wrapper for [process_into_buffer](Resampler::process_into_buffer)
/// that allocates the output buffer with each call. For realtime applications, use
/// [process_into_buffer](Resampler::process_into_buffer) with a buffer allocated by
/// [output_buffer_allocate](Resampler::output_buffer_allocate) instead of this function.
/// Resample a buffer of audio to a pre-allocated output buffer.
/// Use this in real-time applications where the unpredictable time required to allocate
/// memory from the heap can cause glitches. If this is not a problem, you may use
/// the [process](Resampler::process) method instead.
/// The input and output buffers are noninterleaved.
/// The input is a slice, where each element of the slice is itself referenceable
/// as a slice ([AsRef<\[T\]>](AsRef)) which contains the samples for a single channel.
/// Because [Vec<T>] implements [AsRef<\[T\]>](AsRef), the input may be [`Vec<Vec<T>>`](Vec).
/// The output data is a slice, where each element of the slice is a [Vec] which contains
/// the samples for a single channel. If the output channel vectors do not have sufficient
/// capacity for all output samples, they will be resized by this function. To avoid these
/// allocations during this function, allocate the output buffer with
/// [output_buffer_allocate](Resampler::output_buffer_allocate) before calling this function
/// and reuse the same buffer for each call.
/// The `active_channels_mask` is optional.
/// Any channel marked as inactive by a false value will be skipped during processing
/// and the corresponding output will be left unchanged.
/// If `None` is given, all channels will be considered active unless their length is 0.
input_buffer_allocate/// Convenience method for allocating an input buffer suitable for use with
/// [process_into_buffer](Resampler::process_into_buffer). The buffer's capacity
/// is big enough to prevent allocating additional heap memory before any call to
/// [process_into_buffer](Resampler::process_into_buffer) regardless of the current
/// resampling ratio.
/// Get the maximum number of input frames per channel the resampler could require
/// Get the number of frames per channel needed for the next call to
/// [process_into_buffer](Resampler::process_into_buffer) or [process](Resampler::process)
/// Get the maximum number of channels this Resampler is configured for
output_buffer_allocate/// Convenience method for allocating an output buffer suitable for use with
/// is big enough to prevent allocating additional heap memory during any call to
/// Get the max number of output frames per channel
/// Get the number of frames per channel that will be output from the next call to
/// Update the resample ratio
/// For asynchronous resamplers, the ratio must be within
/// `original / maximum` to `original * maximum`, where the original and maximum are the
/// resampling ratios that were provided to the constructor. Trying to set the ratio
/// outside these bounds will return [ResampleError::RatioOutOfBounds].
/// For synchronous resamplers, this will always return [ResampleError::SyncNotAdjustable].
/// Update the resample ratio as a factor relative to the original one
/// For asynchronous resamplers, the relative ratio must be within
/// `1 / maximum` to `maximum`, where maximum is the maximum
/// resampling ratio that was provided to the constructor. Trying to set the ratio
/// Higher ratios above 1.0 slow down the output and lower the pitch. Lower ratios
/// below 1.0 speed up the output and raise the pitch.
/// A resampler that us used to resample a chunk of audio to a new sample rate.
/// For asynchronous resamplers, the rate can be adjusted as required.
/// This trait is not object safe. If you need an object safe resampler,
/// use the [VecResampler] wrapper trait.
/// Refer to [Resampler::process]
/// Refer to [Resampler::process_into_buffer]
/// Refer to [Resampler::input_buffer_allocate]
/// Refer to [Resampler::input_frames_max]
/// Refer to [Resampler::input_frames_next]
/// Refer to [Resampler::nbr_channels]
/// Refer to [Resampler::output_buffer_allocate]
/// Refer to [Resampler::output_frames_max]
/// Refer to [Resampler::output_frames_next]
/// Refer to [Resampler::set_resample_ratio]
/// Refer to [Resampler::set_resample_ratio_relative]
VecResampler/// This is a helper trait that can be used when a [Resampler] must be object safe.
/// It differs from [Resampler] only by fixing the type of the input of `process()`
/// and `process_into_buffer` to `&[Vec<T>]`.
/// This allows it to be made into a trait object like this:
/// # use rubato::{FftFixedIn, VecResampler};
/// let boxed: Box<dyn VecResampler<f64>> = Box::new(FftFixedIn::<f64>::new(44100, 88200, 1024, 2, 2).unwrap());
/// Use this implementation as an example if you need to fix the input type to something else.
/// Helper to make a mask for the active channels based on which ones are empty.
boxed_resampler// This tests that a VecResampler can be boxed.
process_with_boxedimpl_sendtest_impl_send// This tests that all resamplers are Send.
//! An audio sample rate conversion library for Rust.
//! This library provides resamplers to process audio in chunks.
//! The ratio between input and output sample rates is completely free.
//! Implementations are available that accept a fixed length input
//! while returning a variable length output, and vice versa.
//! Rubato can be used in realtime applications without any allocation during
//! processing by preallocating a [Resampler] and using its
//! [input_buffer_allocate](Resampler::input_buffer_allocate) and
//! [output_buffer_allocate](Resampler::output_buffer_allocate) methods before
//! beginning processing. The [log feature](#log-enable-logging) feature should be disabled
//! for realtime use (it is disabled by default).
//! ### Input and output data format
//! Input and output data is stored non-interleaved.
//! The output data is stored in a vector of vectors, `Vec<Vec<f32>>` or `Vec<Vec<f64>>`.
//! The inner vectors (`Vec<f32>` or `Vec<f64>`) hold the sample values for one channel each.
//! The input data is similar, except that it allows the inner vectors to be `AsRef<[f32]>` or `AsRef<[f64]>`.
//! Normal vectors can be used since `Vec` implements the `AsRef` trait.
//! ### Asynchronous resampling
//! The resampling is based on band-limited interpolation using sinc
//! interpolation filters. The sinc interpolation upsamples by an adjustable factor,
//! and then the new sample points are calculated by interpolating between these points.
//! The resampling ratio can be updated at any time.
//! ### Synchronous resampling
//! Synchronous resampling is implemented via FFT. The data is FFT:ed, the spectrum modified,
//! and then inverse FFT:ed to get the resampled data.
//! This type of resampler is considerably faster but doesn't support changing the resampling ratio.
//! ### SIMD acceleration
//! #### Asynchronous resampling
//! The asynchronous resampler supports SIMD on x86_64 and on aarch64.
//! The SIMD capabilities of the CPU are determined at runtime.
//! If no supported SIMD instruction set is available, it falls back to a scalar implementation.
//! On x86_64 it will try to use AVX. If AVX isn't available, it will instead try SSE3.
//! On aarch64 (64-bit Arm) it will use Neon if available.
//! #### Synchronous resampling
//! The synchronous resamplers benefit from the SIMD support of the RustFFT library.
//! ### Cargo features
//! ##### `log`: Enable logging
//! This feature enables logging via the `log` crate. This is intended for debugging purposes.
//! Note that outputting logs allocates a [std::string::String] and most logging implementations involve various other system calls.
//! These calls may take some (unpredictable) time to return, during which the application is blocked.
//! This means that logging should be avoided if using this library in a realtime application.
//! ## Example
//! Resample a single chunk of a dummy audio file from 44100 to 48000 Hz.
//! See also the "fixedin64" example that can be used to process a file from disk.
//! use rubato::{Resampler, SincFixedIn, InterpolationType, InterpolationParameters, WindowFunction};
//! let params = InterpolationParameters {
//!     sinc_len: 256,
//!     f_cutoff: 0.95,
//!     interpolation: InterpolationType::Linear,
//!     oversampling_factor: 256,
//!     window: WindowFunction::BlackmanHarris2,
//! let mut resampler = SincFixedIn::<f64>::new(
//!     48000 as f64 / 44100 as f64,
//!     2.0,
//!     params,
//!     1024,
//!     2,
//! ).unwrap();
//! let waves_in = vec![vec![0.0f64; 1024];2];
//! let waves_out = resampler.process(&waves_in, None).unwrap();
//! ## Compatibility
//! The `rubato` crate requires rustc version 1.61 or newer.
//! ## Changelog
//! - v0.12.0
//!   - Always enable all simd acceleration (and remove the simd Cargo features).
//! - v0.11.0
//!   - New api to allow use in realtime applications.
//!   - Configurable adjust range of asynchronous resamplers.
//! - v0.10.1
//!   - Fix compiling with neon feature after changes in latest nightly.
//! - v0.10.0
//!   - Add an object-safe wrapper trait for Resampler.
//! - v0.9.0
//!   - Accept any AsRef<[T]> as input.
/// Calculate the sine of `self`.
/// Calculate the cosine of `self`.
CoerceFrom/// Coerce `value` into the current type.
/// Coercions are governed through the private `CoerceFrom` trait.
/// The trait governing a single sample.
/// There are two types which implements this trait so far:
/// * [f32]
/// * [f64]
coerce_from/// Perform a coercion from `value` into the current type.
/// The trait used to coerce a value infallibly from one type to another.
/// This is similar to doing `value as T` where `T` is a floating point type.
/// Loss of precision may happen during coercions if the coerced from value
/// doesn't fit fully within the target type.
make_window/// Helper function: sinc(x) = sin(pi*x)/(pi*x)
/// Helper function. Make a set of windowed sincs.  
fft_size_infft_size_outfilter_fifftscratch_fwscratch_invinput_foutput_foutput_bufFftResampler/// A helper for resampling a single chunk of data.
chunk_size_ininput_bufferssaved_framesresampler/// A synchronous resampler that needs a fixed number of audio frames for input
/// The resampling is done by FFT:ing the input data. The spectrum is then extended or
/// truncated as well as multiplied with an antialiasing filter
/// before it's inverse transformed to get the resampled waveforms.
chunk_size_outoutput_buffersframes_needed/// A synchronous resampler that needs a varying number of audio frames for input
/// and returns a fixed number of frames.
/// A synchronous resampler that accepts a fixed number of audio frames for input
validate_sample_ratesresample_unit/// Resample a small chunk
/// Create a new FftFixedInOut
/// - `sample_rate_input`: Input sample rate, must be > 0.
/// - `sample_rate_output`: Output sample rate, must be > 0.
/// - `chunk_size_in`: desired length of input data in frames, actual value may be different.
/// - `nbr_channels`: number of channels in input/output.
/// Update the resample ratio. This is not supported by this resampler and
/// always returns an [ResampleError::SyncNotAdjustable].
/// Update the resample ratio relative to the original one. This is not
/// supported by this resampler and always returns an [ResampleError::SyncNotAdjustable].
/// Create a new FftFixedOut
/// - `chunk_size_out`: length of output data in frames.
/// - `sub_chunks`: desired number of subchunks for processing, actual number may be different.
/// always returns [ResampleError::SyncNotAdjustable].
/// supported by this resampler and always returns [ResampleError::SyncNotAdjustable].
/// Create a new FftFixedIn
/// - `chunk_size_in`: length of input data in frames.
/// - `sub_chunks`: desired number of subchunks for processing, actual number used may be different.
make_resampler_fiomake_resampler_fio_skippedmake_resampler_fo_emptymake_resampler_fi_noallocmake_resampler_fi_emptymake_resampler_fio_unusualratiomake_resampler_fo_unusualratioBlackman/// Blackman. Intermediate rolloff and intermediate attenuation.
Blackman2/// Squared Blackman. Slower rolloff but better attenuation than Blackman.
BlackmanHarris/// Blackman-Harris. Slow rolloff but good attenuation.
BlackmanHarris2/// Squared Blackman-Harris. Slower rolloff but better attenuation than Blackman-Harris.
Hann/// Hann, fast rolloff but not very high attenuation
Hann2/// Squared Hann, slower rolloff and higher attenuation than simple Hann
/// Different window functions that can be used to window the sinc function.
blackman_harris/// Helper function. Standard Blackman-Harris window
blackman/// Helper function. Standard Blackman window
hann/// Standard Hann window
/// Make the selected window function
test_blackman_harristest_blackmantest_blackman2test_hannEscapePolicy/// escape absolutely nothing (dangerous)Basics/// only escape the most necessary thingsBasicsUnicode/// escape basics and non-ascii characters/// Escape reserved symbols.ReservedUnicode/// Escape reserved symbols and non-ascii charactersEverything/// Escape everything that some INI implementations assume/// Policies for escaping logicescape_basicsescape_reservedescape_unicodeshould_escape/// Given a character this returns true if it should be escaped as/// per this policy or false if not.escape_str// Escape non-INI characters// Common escape sequences: https://en.wikipedia.org/wiki/INI_file#Escape_characters// * `\\` \ (a single backslash, escaping the escape character)// * `\0` Null character// * `\a` Bell/Alert/Audible// * `\b` Backspace, Bell character for some applications// * `\t` Tab character// * `\r` Carriage return// * `\n` Line feed// * `\;` Semicolon// * `\#` Number sign// * `\=` Equals sign// * `\:` Colon// * `\x????` Unicode character with hexadecimal code point corresponding to ????enabled_quote/// Allow quote (`"` or `'`) in value/// For example/// ```ini/// [Section]/// Key1="Quoted value"/// Key2='Single Quote' with extra value/// In this example, Value of `Key1` is `Quoted value`,/// and value of `Key2` is `Single Quote with extra value`/// if `enabled_quote` is set to `true`.enabled_escape/// Interpret `\` as an escape character/// Key1=C:\Windows/// If `enabled_escape` is true, then the value of `Key` will become `C:Windows` (`\W` equals to `W`).ParseOption/// Parsing configurationSystemDefault/// System-dependent line separator/// On UNIX system, uses "\n"/// On Windows system, uses "\r\n"/// Uses "\n" as new line separator/// Uses "\r\n" as new line separator/// Newline styleDEFAULT_LINE_SEPARATOR/// String representationescape_policy/// Policies about how to escape charactersline_separatorWriteOption/// Writing configurationr" Internal storage of section's key"SectionKeyr" Internal storage of property's key"PropertyKeyproperty_get_keyproperty_insert_keysection_keySectionSetter/// A setter which could be used to set key-value pair in a specified section/// Set (replace) key-value pair in this section (all with the same name)/// Delete the first entry in this section with `key`/// Get the entry in this section with `key`/// Properties type (key-value pairs)/// Create an instance/// Get the number of the properties/// Check if properties has 0 elements/// Get an iterator of the properties/// Return true if property exist/// Insert (key, value) pair by replace/// Append key with (key, value) pair/// Get the first value associate with the key/// Get all values associate with the key/// Remove the property with the first value of the key/// Remove the property with all values with the same keySectionVacantEntry/// A view into a vacant entry in a `Ini`/// Insert one new sectionSectionOccupiedEntry/// A view into a occupied entry in a `Ini`/// Into the first internal mutable properties/// Append a new sectionSectionEntry/// A view into an `Ini`, which may either be vacant or occupied./// Ensures a value is in the entry by inserting the default if empty, and returns a mutable reference to the value in the entry./// Ensures a value is in the entry by inserting the result of the default function if empty, and returns a mutable reference to the value in the entry./// Ini structwith_section/// Set with a specified section, `None` is for the general sectionwith_general_section/// Set with general section, a simple wrapper of `with_section(None::<String>)`general_section/// Get the immmutable general sectiongeneral_section_mut/// Get the mutable general section/// Get a immutable section/// Get a mutable sectionsection_all/// Get all sections immutable with the same keysection_all_mut/// Get all sections mutable with the same key/// Get the entry/// Clear all entries/// Iterate with sectionsset_to/// Set key-value to a sectionget_from/// Get the first value from the sections with key/// use ini::Ini;/// let input = "[sec]\nabc = def\n";/// let ini = Ini::load_from_str(input).unwrap();/// assert_eq!(ini.get_from(Some("sec"), "abc"), Some("def"));get_from_or/// Get the first value from the sections with key, return the default value if it does not exist/// let input = "[sec]\n";/// assert_eq!(ini.get_from_or(Some("sec"), "key", "default"), "default");get_from_mut/// Get the first mutable value from the sections with key/// Delete the first section with key, return the properties if it existsdelete_from/// Delete the key from the section, return the value if key exists or None/// Total sections count/// Check if object coutains no section/// Write to a filewrite_to_file_policywrite_to_file_opt/// Write to a file with options/// Write to a writerwrite_to_policywrite_to_opt/// Write to a writer with optionsload_from_str/// Load from a stringload_from_str_noescape/// Load from a string, but do not interpret '\' as an escape characterload_from_str_opt/// Load from a string with optionsread_from/// Load from a readerread_from_noescape/// Load from a reader, but do not interpret '\' as an escape characterread_from_opt/// Load from a reader with options/// Load from a fileload_from_file_noescape/// Load from a file, but do not interpret '\' as an escape characterload_from_file_opt/// Load from a file with optionsSectionIter/// Iterator for traversing sectionsSectionIterMut/// Immutable iterate though sections/// Mutable iterate though sections// Ini parser/// Parse error/// Error while parsing an INI document// Create a parserparse_whitespace/// Consume all the white space until the end of the line or a tabparse_whitespace_except_line_break/// Consume all the white space except line break/// Parse the whole INI inputparse_str_untilparse_sectionparse_valparse_str_until_eoltemp_dirproperty_replaceproperty_get_vecproperty_removeload_from_str_with_valid_inputload_from_str_without_ending_newlineinline_comment_not_supportedinline_commentsharp_commentstring_multilinestring_commentstring_singlestring_includes_quotestring_single_multilinestring_single_commentload_from_str_with_valid_empty_inputload_from_str_with_crlfload_from_str_with_crload_from_file_with_bomload_from_file_without_bomget_with_non_static_keypartial_quoting_doublepartial_quoting_singleparse_without_quotepreserve_order_sectionpreserve_order_propertypreserve_order_property_in_sectionpreserve_order_writewrite_line_separatorduplicate_sectionsfix_issue63fix_issue64invalid_codepoint// The MIT License (MIT)// Copyright (c) 2014 Y. T. CHUNG// Permission is hereby granted, free of charge, to any person obtaining a copy of// this software and associated documentation files (the "Software"), to deal in// the Software without restriction, including without limitation the rights to// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of// the Software, and to permit persons to whom the Software is furnished to do so,// subject to the following conditions:// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.//! Ini parser for Rust//! use ini::Ini;//! let mut conf = Ini::new();//! conf.with_section(Some("User"))//!     .set("name", "Raspberry树莓")//!     .set("value", "Pi");//! conf.with_section(Some("Library"))//!     .set("name", "Sun Yat-sen U")//!     .set("location", "Guangzhou=world");//! conf.write_to_file("conf.ini").unwrap();//! let i = Ini::load_from_file("conf.ini").unwrap();//! for (sec, prop) in i.iter() {//!     println!("Section: {:?}", sec);//!     for (k, v) in prop.iter() {//!         println!("{}:{}", k, v);// ------------------------------------------------------------------------------/// The number of ::-separated elements in the original name./// Representation of a demangled symbol name./// De-mangles a Rust symbol into a more readable version/// All Rust symbols by default are mangled as they contain characters that/// cannot be represented in all object files. The mangling mechanism is similar/// to C++'s, but Rust has a few specifics to handle items like lifetimes in/// symbols./// This function will take a **mangled** symbol and return a value. When printed,/// the de-mangled version will be written. If the symbol does not look like/// a mangled symbol, the original value will be written instead./// use rustc_demangle::demangle;/// assert_eq!(demangle("_ZN4testE").to_string(), "test");/// assert_eq!(demangle("_ZN3foo3barE").to_string(), "foo::bar");/// assert_eq!(demangle("foo").to_string(), "foo");// All Rust symbols are in theory lists of "::"-separated identifiers. Some// assemblers, however, can't handle these characters in symbol names. To get// around this, we use C++-style mangling. The mangling method is:// 1. Prefix the symbol with "_ZN"// 2. For each element of the path, emit the length plus the element// 3. End the path with "E"// For example, "_ZN4testE" => "test" and "_ZN3foo3barE" => "foo::bar".// We're the ones printing our backtraces, so we can't rely on anything else to// demangle our symbols. It's *much* nicer to look at demangled symbols, so// this function is implemented to give us nice pretty output.// Note that this demangler isn't quite as fancy as it could be. We have lots// of other information in our symbols like hashes, version, type information,// etc. Additionally, this doesn't handle glue symbols at all.is_rust_hash// Rust hashes are hex digits with an `h` prepended.t_nohashok_errdemangle_dollarsdemangle_many_dollarsdemangle_osxdemangle_windowsdemangle_elements_beginning_with_underscoredemangle_trait_implsdemangle_without_hashdemangle_without_hash_edgecasesdemangle_thinltodemangle_llvm_ir_branch_labelsdemangle_ignores_suffix_that_doesnt_look_like_a_symboldont_panicinvalid_no_chophandle_assoc_typeshandle_bangdemangle_utf8_identsdemangle_issue_60925assert_contains// HACK(eddyb) helper macros for tests.assert_ends_withDemangleStyleLegacyTryDemangleError/// Error returned from the `try_demangle` function below when demangling fails./// The same as `demangle`, except return an `Err` if the string does not appear/// to be a Rust symbol, rather than "demangling" the given string as a no-op./// extern crate rustc_demangle;/// let not_a_rust_symbol = "la la la";/// // The `try_demangle` function will reject strings which are not Rust symbols./// assert!(rustc_demangle::try_demangle(not_a_rust_symbol).is_err());/// // While `demangle` will just pass the non-symbol through as a no-op./// assert_eq!(rustc_demangle::demangle(not_a_rust_symbol).as_str(), not_a_rust_symbol);/// Returns the underlying string that's being demangled.is_symbol_likeis_ascii_alphanumeric// Copied from the documentation of `char::is_ascii_alphanumeric`is_ascii_punctuation// Copied from the documentation of `char::is_ascii_punctuation`// Maximum size of the symbol that we'll print.SizeLimitExhaustedSizeLimitedFmtAdapterlimit_recursionlimit_output//! Demangle Rust compiler symbol names.//! This crate provides a `demangle` function which will return a `Demangle`//! sentinel value that can be used to learn about the demangled version of a//! symbol name. The demangled representation will be the same as the original//! if it doesn't look like a mangled symbol name.//! `Demangle` can be formatted with the `Display` trait. The alternate//! modifier (`#`) can be used to format the symbol name without the//! trailing hash value.//! use rustc_demangle::demangle;//! assert_eq!(demangle("_ZN4testE").to_string(), "test");//! assert_eq!(demangle("_ZN3foo3barE").to_string(), "foo::bar");//! assert_eq!(demangle("foo").to_string(), "foo");//! // With hash//! assert_eq!(format!("{}", demangle("_ZN3foo17h05af221e174051e9E")), "foo::h05af221e174051e9");//! // Without hash//! assert_eq!(format!("{:#}", demangle("_ZN3foo17h05af221e174051e9E")), "foo");MAX_DEPTH// Maximum recursion depth when parsing symbols before we just bail out saying// "this symbol is invalid"/// Symbol doesn't match the expected `v0` grammar.RecursedTooDeep/// Parsing the symbol crossed the recursion limit (see `MAX_DEPTH`)./// ASCII part of the identifier./// Punycode insertion codes for Unicode codepoints, if any.SMALL_PUNYCODE_LENtry_small_punycode_decode/// Attempt to decode punycode on the stack (allocation-free),/// and pass the char slice to the closure, if successful./// This supports up to `SMALL_PUNYCODE_LEN` characters.punycode_decode/// Decode punycode as insertion positions and characters/// and pass them to the closure, which can return `Err(())`/// to stop the decoding process.nibblesHexNibbles/// Sequence of lowercase hexadecimal nibbles (`0-9a-f`), used by leaf consts.try_parse_uint/// Decode an integer value (with the "most significant nibble" first),/// returning `None` if it can't fit in an `u64`.// FIXME(eddyb) should this "just" use `u128` instead?try_parse_str_chars/// Decode a UTF-8 byte sequence (with each byte using a pair of nibbles)/// into individual `char`s, returning `None` for invalid UTF-8.basic_typepush_depthpop_deptheathex_nibblesdigit_10digit_62integer_62opt_integer_62disambiguatorbackref/// The input parser to demangle from, or `Err` if any (parse) error was/// encountered (in order to disallow further likely-incorrect demangling)./// See also the documentation on the `invalid!` and `parse!` macros below./// The output formatter to demangle to, or `None` while skipping printing.bound_lifetime_depth/// Cumulative number of lifetimes bound by `for<...>` binders ('G'),/// anywhere "around" the current entity (e.g. type) being demangled./// This value is not tracked while skipping printing, as it'd be unused./// See also the documentation on the `Printer::in_binder` method./// Snippet to print when the error is initially encountered./// Mark the parser as errored (with `ParseError::Invalid`), print the/// appropriate message (see `ParseError::message`) and return early./// Call a parser method (if the parser hasn't errored yet),/// and mark the parser as errored if it returns `Err`./// If the parser errored, before or now, this returns early,/// from the current function, after printing either:/// * for a new error, the appropriate message (see `ParseError::message`)/// * for an earlier error, only `?` -  this allows callers to keep printing///   the approximate syntax of the path/type/const, despite having errors,///   e.g. `Vec<[(A, ?); ?]>` instead of `Vec<[(A, ?`/// Eat the given character from the parser,/// returning `false` if the parser errored.skipping_printing/// Skip printing (i.e. `self.out` will be `None`) for the duration of the/// given closure. This should not change parsing behavior, only disable the/// output, but there may be optimizations (such as not traversing backrefs).print_backref/// Print the target of a backref, using the given closure./// When printing is being skipped, the backref will only be parsed,/// ignoring the backref's target completely./// Output the given value to `self.out` (using `fmt::Display` formatting),/// if printing isn't being skipped.print_quoted_escaped_chars/// Output the given `char`s (escaped using `char::escape_debug`), with the/// whole sequence wrapped in quotes, for either a `char` or `&str` literal,print_lifetime_from_index/// Print the lifetime according to the previously decoded index./// An index of `0` always refers to `'_`, but starting with `1`,/// indices refer to late-bound lifetimes introduced by a binder.in_binder/// Optionally enter a binder ('G') for late-bound lifetimes,/// printing e.g. `for<'a, 'b> ` before calling the closure,/// and make those lifetimes visible to it (via depth level).print_sep_list/// Print list elements using the given closure and separator,/// until the end of the list ('E') is found, or the parser errors./// Returns the number of elements printed.print_generic_argprint_typeprint_path_maybe_open_generics/// A trait in a trait object may have some "existential projections"/// (i.e. associated type bindings) after it, which should be printed/// in the `<...>` of the trait, e.g. `dyn Trait<T, U, Assoc=X>`./// To this end, this method will keep the `<...>` of an 'I' path/// open, by omitting the `>`, and return `Ok(true)` in that case.print_dyn_traitprint_const_uintprint_const_str_literalt_nohash_typet_constt_const_suffixeddemangle_crate_with_leading_digitdemangle_crate_with_zero_disambiguatordemangle_closuredemangle_dyn_traitdemangle_const_generics_previewdemangle_min_const_genericsdemangle_const_strdemangle_const_ref_str// NOTE(eddyb) this uses the same strings as `demangle_const_str` and should// be kept in sync with it - while a macro could be used to generate both// `str` and `&str` tests, from a single list of strings, this seems clearer.demangle_const_refdemangle_const_arraydemangle_const_tupledemangle_const_adtdemangle_exponential_explosiondemangle_extra_suffixdemangling_limitsrecursion_limit_leaksrecursion_limit_backref_free_bypassprint_patFxHasher/// Type alias for a hashmap using the `fx` hash algorithm./// A speedy hash algorithm for use within rustc. The hashmap in liballoc/// by default uses SipHash which isn't quite as speedy as we want. In the/// compiler we're not really worried about DOS attempts, so we use a fast/// non-cryptographic hash./// This is the same as the algorithm used by Firefox -- which is a homespun/// one not based on any widely-known algorithm -- though modified to produce/// 64-bit hash values instead of 32-bit hash values. It consistently/// out-performs an FNV-based hash within rustc itself -- the collision rate is/// similar or slightly worse than FNV, but the speed of the hash function/// itself is much higher because it works on up to 8 bytes at a time.add_to_hash//! Fast, non-cryptographic hash used by rustc and Firefox.//! use rustc_hash::FxHashMap;//! let mut map: FxHashMap<u32, u32> = FxHashMap::default();//! map.insert(22, 44);//! # fn main() { }seeded_state/// Type alias for a hash map that uses the Fx hashing algorithm./// Type alias for a hash set that uses the Fx hashing algorithm.FxSeededStateFxHashMapSeedFxHashSetSeed/// The current implementation is a fast polynomial hash with a single/// bit rotation as a finishing step designed by Orson Peters.// One might view a polynomial hash//    m[0] * k    + m[1] * k^2  + m[2] * k^3  + ...// as a multilinear hash with keystream k[..]//    m[0] * k[0] + m[1] * k[1] + m[2] * k[2] + ...// where keystream k just happens to be generated using a multiplicative// congruential pseudorandom number generator (MCG). For that reason we chose a// constant that was found to be good for a MCG in://     "Computationally Easy, Spectrally Good Multipliers for Congruential//     Pseudorandom Number Generators" by Guy Steele and Sebastiano Vigna./// Creates a `fx` hasher with a given seed./// Creates a default `fx` hasher.SEED1// Nothing special, digits of pi.SEED2PREVENT_TRIVIAL_ZERO_COLLAPSEmultiply_mixhash_bytes/// A wyhash-inspired non-collision-resistant hash for strings/slices designed/// by Orson Peters, with a focus on small strings and small codesize./// The 64-bit version of this hash passes the SMHasher3 test suite on the full/// 64-bit output, that is, f(hash_bytes(b) ^ f(seed)) for some good avalanching/// permutation f() passed all tests with zero failures. When using the 32-bit/// version of multiply_mix this hash has a few non-catastrophic failures where/// there are a handful more collisions than an optimal hash would give./// We don't bother avalanching here as we'll feed this hash into a/// multiplication after which we take the high bits, which avalanches for us./// An implementation of [`BuildHasher`] that produces [`FxHasher`]s./// use rustc_hash::FxBuildHasher;/// assert_ne!(FxBuildHasher.hash_one(1), FxBuildHasher.hash_one(2));// Avoid relying on any `Hash` implementations in the standard library.with_seed_actually_different//! A speedy, non-cryptographic hashing algorithm used by `rustc`.FxHashMapRandFxRandomState/// Type alias for a hashmap using the `fx` hash algorithm with [`FxRandomState`].FxHashSetRand/// `FxRandomState` is an alternative state for `HashMap` types./// A particular instance `FxRandomState` will create the same instances of/// [`Hasher`], but the hashers created by two different `FxRandomState`/// instances are unlikely to produce the same result for the same values./// Constructs a new `FxRandomState` that is initialized with random seed.cloned_random_states_are_equalrandom_states_are_differentrandom_states_are_different_cross_thread/// Type alias for a hashmap using the `fx` hash algorithm with [`FxSeededState`]./// [`FxSeededState`] is an alternative state for `HashMap` types, allowing to use [`FxHasher`] with a set seed./// use rustc_hash::FxSeededState;/// let mut map = HashMap::with_hasher(FxSeededState::with_seed(12));/// map.insert(15, 610);/// assert_eq!(map[&15], 610);/// Constructs a new `FxSeededState` that is initialized with a `seed`.cloned_seeded_states_are_equalsame_seed_produces_same_hasherdifferent_states_are_differentZeroChars/// Expected 1 char, but 0 were found.MoreThanOneChar/// Expected 1 char, but more than 1 were found.LoneSlash/// Escaped '\' character without continuation.InvalidEscape/// Invalid escape character (e.g. '\z').BareCarriageReturn/// Raw '\r' encountered.BareCarriageReturnInRawString/// Raw '\r' encountered in raw string.EscapeOnlyChar/// Unescaped character that was expected to be escaped (e.g. raw '\t').TooShortHexEscape/// Numeric character escape is too short (e.g. '\x1').InvalidCharInHexEscape/// Invalid character in numeric escape (e.g. '\xz')OutOfRangeHexEscape/// Character code in numeric escape is non-ascii (e.g. '\xFF').NoBraceInUnicodeEscape/// '\u' not followed by '{'.InvalidCharInUnicodeEscape/// Non-hexadecimal value in '\u{..}'.EmptyUnicodeEscape/// '\u{}'UnclosedUnicodeEscape/// No closing brace in '\u{..}', e.g. '\u{12'.LeadingUnderscoreUnicodeEscape/// '\u{_12}'OverlongUnicodeEscape/// More than 6 characters in '\u{..}', e.g. '\u{10FFFF_FF}'LoneSurrogateUnicodeEscape/// Invalid in-bound unicode character code, e.g. '\u{DFFF}'.OutOfRangeUnicodeEscape/// Out of bounds unicode character code, e.g. '\u{FFFFFF}'.UnicodeEscapeInByte/// Unicode escape code in byte literal.NonAsciiCharInByte/// Non-ascii character in byte literal, byte string literal, or raw byte string literal.NulInCStr/// `\0` in a C string literal.UnskippedWhitespaceWarning/// After a line ending with '\', the next line contains whitespace/// characters that are not skipped.MultipleSkippedLinesWarning/// After a line ending with '\', multiple lines are skipped./// Errors and warnings that can occur during string, char, and byte unescaping./// Mostly relating to malformed escape sequences, but also a few other problems./// Returns true for actual errors, as opposed to warnings.check_raw_str/// Check a raw string literal for validity/// Takes the contents of a raw string literal (without quotes)/// and produces a sequence of characters or errors,/// which are returned by invoking `callback`./// NOTE: Does no escaping, but produces errors for bare carriage return ('\r').check_raw_byte_str/// Check a raw byte string literal for validity/// Takes the contents of a raw byte string literal (without quotes)/// and produces a sequence of bytes or errors,check_raw_c_str/// Check a raw C string literal for validity/// Takes the contents of a raw C string literal (without quotes)RawUnit/// Unit type of the implementing string type (`char` for string, `u8` for byte string)char2raw_unit/// Converts chars to the unit type of the literal typecheck_raw/// Takes the contents of a raw literal (without quotes)/// and produces a sequence of `Result<Self::RawUnit, EscapeError>`/// which are returned via `callback`.CheckRaw/// Trait for checking raw string literals for validitychar2byte/// Turn an ascii char into a byteunescape_char/// Unescape a char literal/// Takes the contents of a char literal (without quotes),/// and returns an unescaped char or an error.unescape_byte/// Unescape a byte literal/// Takes the contents of a byte literal (without quotes),/// and returns an unescaped byte or an error.unescape_str/// Unescape a string literal/// Takes the contents of a string literal (without quotes)/// and produces a sequence of escaped characters or errors,unescape_byte_str/// Unescape a byte string literal/// Takes the contents of a byte string literal (without quotes)/// and produces a sequence of escaped bytes or errors,unescape_c_strMixedUnit/// Unescape a C string literal/// Takes the contents of a C string literal (without quotes)/// and produces a sequence of escaped MixedUnits or errors,/// Used for ASCII chars (written directly or via `\x00`..`\x7f` escapes)/// and Unicode chars (written directly or via `\u` escapes)./// For example, if '¥' appears in a string it is represented here as/// `MixedUnit::Char('¥')`, and it will be appended to the relevant byte/// string as the two-byte UTF-8 sequence `[0xc2, 0xa5]`HighByte/// Used for high bytes (`\x80`..`\xff`)./// For example, if `\xa5` appears in a string it is represented here as/// `MixedUnit::HighByte(0xa5)`, and it will be appended to the relevant/// byte string as the single byte `0xa5`./// Enum representing either a char or a byte/// Used for mixed utf8 string literals, i.e. those that allow both unicode/// chars and high bytes.ZERO_RESULT/// Result of unescaping the zero char ('\0')nonzero_byte2unit/// Converts non-zero bytes to the unit typechar2unit/// Converts chars to the unit typehex2unit/// Converts the byte of a hex escape to the unit typeunicode2unit/// Converts the result of a unicode escape to the unit typeunescape_single/// Unescape a single unit (single quote syntax)unescape_1/// Unescape the first unit of a string (double quoted syntax)/// and produces a sequence of `Result<Self::Unit, EscapeError>`Unescape/// Trait for unescaping escape sequences in stringssimple_escape/// Interpret a non-nul ASCII escape/// Parses the character of an ASCII escape (except nul) without the leading backslash.// single use in Unescape::unescape_1hex_escape/// Interpret a hexadecimal escape/// Parses the two hexadecimal characters of a hexadecimal escape without the leading r"\x".unicode_escape/// Interpret a unicode escape/// Parse the braces with hexadecimal characters (and underscores) part of a unicode escape./// This r"{...}" normally comes after r"\u" and cannot start with an underscore.skip_ascii_whitespace/// Interpret a string continuation escape (https://doc.rust-lang.org/reference/expressions/literal-expr.html#string-continuation-escapes)/// Skip ASCII whitespace, except for the formfeed character/// (see [this issue](https://github.com/rust-lang/rust/issues/136600))./// Warns on unescaped newline and following non-ASCII whitespace.// single use in Unescape::unescape/// `'a'`/// `b'a'`/// `"hello"`RawStr/// `r"hello"`/// `b"hello"`RawByteStr/// `br"hello"`/// `c"hello"`RawCStr/// `cr"hello"`/// Enum of the different kinds of literalin_double_quotesprefix_norawcheck_for_errors/// Check a literal only for errors/// Takes the contents of a literal (without quotes)/// and produces a sequence of only errors,/// which are returned by invoking `error_callback`./// NB Does not produce any output other than errors//! Utilities for validating (raw) string, char, and byte literals and//! turning escape sequences into the values they represent.test_unescape_char_badtest_unescape_char_goodtest_unescape_str_warntest_unescape_str_goodtest_unescape_byte_badtest_unescape_byte_goodtest_unescape_byte_str_goodtest_unescape_raw_strtest_unescape_raw_byte_str// Convenience re-export to allow version comparison without needing to add// semver crate./// Development release channel/// Nightly release channel/// Beta release channel/// Stable release channel/// Release channel of the compiler.// fields must be ordered major, minor for comparison to be correct/// Major version/// Minor version// TODO: expose micro version hereLlvmVersion/// LLVM version/// LLVM's version numbering scheme is not semver compatible until version 4.0/// rustc [just prints the major and minor versions], so other parts of the version are not included./// [just prints the major and minor versions]: https://github.com/rust-lang/rust/blob/b5c9e2448c9ace53ad5c11585803894651b18b0a/compiler/rustc_codegen_llvm/src/llvm_util.rs#L173-L178LlvmVersionParseError/// Version of the compilercommit_hash/// Git short hash of the build of the compiler/// Commit date of the compilerbuild_date/// Build date of the compiler; this was removed between Rust 1.0.0 and 1.1.0./// Release channel of the compiler/// Host target triple of the compilershort_version_string/// Short version string of the compilerllvm_version/// Version of LLVM used by the compilerVersionMeta/// Rustc version plus metadata like git short hash and build date.for_command/// Returns the version metadata for `cmd`, which should be a `rustc` command./// Returns the `rustc` SemVer version./// Returns the `rustc` SemVer version and additional metadata/// like the git short hash and build date.version_meta_for/// Parses a "rustc -vV" output string and returns/// the SemVer version and additional metadataexpect_key_or_unknownexpect_key/// An error occurred in parsing a version component as an integerComponentMustNotHaveLeadingZeros/// A version component must not have leading zerosComponentMustNotHaveSign/// A version component has a signMinorVersionMustBeZeroAfter4/// Minor version component must be zero on LLVM versions later than 4.0MinorVersionRequiredBefore4/// Minor version component is required on LLVM versions earlier than 4.0TooManyComponents/// Too many components/// LLVM Version Parse ErrorCouldNotExecuteCommand/// An error occurred while trying to find the `rustc` to run./// stdout output from the command/// stderr output from the commandCommandError/// Error output from the command that was run./// The output of `rustc -vV` was not valid utf-8.UnexpectedVersionFormat/// The output of `rustc -vV` was not in the expected format.SemVerError/// An error occurred in parsing the semver.UnknownPreReleaseTag/// The pre-release tag is unknown.LlvmVersionError/// An error occurred in parsing a `LlvmVersion`./// The error type for this crate./// The result type for this crate.// Copyright 2016 rustc-version-rs developers//! Simple library for getting the version information of a `rustc`//! compiler.//! This can be used by build scripts or other tools dealing with Rust sources//! to make decisions based on the version of the compiler.//! It calls `$RUSTC --version -v` and parses the output, falling//! back to `rustc` if `$RUSTC` is not set.//! // This could be a cargo build script//! use rustc_version::{version, version_meta, Channel, Version};//! // Assert we haven't travelled back in time//! assert!(version().unwrap().major >= 1);//! // Set cfg flags depending on release channel//! match version_meta().unwrap().channel {//!     Channel::Stable => {//!         println!("cargo:rustc-cfg=RUSTC_IS_STABLE");//!     Channel::Beta => {//!         println!("cargo:rustc-cfg=RUSTC_IS_BETA");//!     Channel::Nightly => {//!         println!("cargo:rustc-cfg=RUSTC_IS_NIGHTLY");//!     Channel::Dev => {//!         println!("cargo:rustc-cfg=RUSTC_IS_DEV");//! // Check for a minimum version//! if version().unwrap() >= Version::parse("1.4.0").unwrap() {//!     println!("cargo:rustc-cfg=compiler_has_important_bugfix");MIN_RUSTCarray_utilsfft_error_inplacefft_error_outofplaceFftDirectioninner_fftinner_fft_multiplierBluesteinsAlgorithm/// Implementation of Bluestein's Algorithm
/// This algorithm computes an arbitrary-sized FFT in O(nlogn) time. It does this by converting this size-N FFT into a
/// size-M FFT where M >= 2N - 1.
/// The choice of M is very important for the performance of Bluestein's Algorithm. The most obvious choice is the next-largest
/// power of two -- but if there's a smaller/faster FFT size that satisfies the `>= 2N - 1` requirement, that will significantly
/// improve this algorithm's overall performance.
/// ~~~
/// // Computes a forward FFT of size 1201, using Bluestein's Algorithm
/// use rustfft::algorithm::BluesteinsAlgorithm;
/// use rustfft::{Fft, FftPlanner};
/// use rustfft::num_complex::Complex;
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 1201];
/// // We need to find an inner FFT whose size is greater than 1201*2 - 1.
/// // The size 2401 (7^4) satisfies this requirement, while also being relatively fast.
/// let mut planner = FftPlanner::new();
/// let inner_fft = planner.plan_fft_forward(2401);
/// let fft = BluesteinsAlgorithm::new(1201, inner_fft);
/// fft.process(&mut buffer);
/// Bluesteins's Algorithm is relatively expensive compared to other FFT algorithms. Benchmarking shows that it is up to
/// an order of magnitude slower than similar composite sizes. In the example size above of 1201, benchmarking shows
/// that it takes 5x more time to compute than computing a FFT of size 1200 via a step of MixedRadix.
/// Creates a FFT instance which will process inputs/outputs of size `len`. `inner_fft.len()` must be >= `len * 2 - 1`
/// Note that this constructor is quite expensive to run; This algorithm must compute a FFT using `inner_fft` within the
/// constructor. This further underlines the fact that Bluesteins Algorithm is more expensive to run than other
/// FFT algorithms
/// Panics if `inner_fft.len() < len * 2 - 1`.
perform_fft_inplaceperform_fft_out_of_placeboilerplate_fftprocess_outofplace_with_scratchget_inplace_scratch_lenget_outofplace_scratch_lenfft_directionDftcheck_fft_algorithmtest_bluesteins_scalartest_bluesteins_with_lengthunit_testsDoubleBufLoadStoreboilerplate_fft_butterflyButterfly1Butterfly2perform_fft_butterflyperform_fft_stridedperform_fft_contiguoustwiddleButterfly3direction_ofButterfly4twiddle1twiddle2Butterfly5// refusing to inline this code reduces code size, and doesn't hurt performance
butterfly3Butterfly6twiddle3Butterfly7root2Butterfly8twiddle4Butterfly9twiddle5Butterfly11twiddle6Butterfly13butterfly8Butterfly16twiddle7twiddle8Butterfly17twiddle9Butterfly19twiddle10twiddle11Butterfly23butterfly9Butterfly27twiddle12twiddle13twiddle14Butterfly29twiddle15Butterfly31butterfly16Butterfly32test_butterfly_func//the tests for all butterflies will be identical except for the identifiers used and size
//so it's ideal for a macro
test_butterfly2test_butterfly3test_butterfly4test_butterfly5test_butterfly6test_butterfly7test_butterfly8test_butterfly9test_butterfly11test_butterfly13test_butterfly16test_butterfly17test_butterfly19test_butterfly23test_butterfly27test_butterfly29test_butterfly31test_butterfly32/// Naive O(n^2 ) Discrete Fourier Transform implementation
/// This implementation is primarily used to test other FFT algorithms.
/// // Computes a naive DFT of size 123
/// use rustfft::algorithm::Dft;
/// use rustfft::{Fft, FftDirection};
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 123];
/// let dft = Dft::new(123, FftDirection::Forward);
/// dft.process(&mut buffer);
/// Preallocates necessary arrays and precomputes necessary data to efficiently compute Dft
boilerplate_fft_oopcompare_vectorsrandom_signaldfttest_matches_dfttest_dft_correct/// Returns true if our `dft` function calculates the given output from the
/// given input, and if rustfft's Dft struct does the same
test_dft_known_len_2test_dft_known_len_3test_dft_known_len_4test_dft_known_len_6StrengthReducedUsizewidth_size_fftheight_size_fftreduced_widthreduced_width_plus_oneinplace_scratch_lenoutofplace_scratch_lenGoodThomasAlgorithm/// Implementation of the [Good-Thomas Algorithm (AKA Prime Factor Algorithm)](https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm)
/// This algorithm factors a size n FFT into n1 * n2, where GCD(n1, n2) == 1
/// Conceptually, this algorithm is very similar to the Mixed-Radix, except because GCD(n1, n2) == 1 we can do some
/// number theory trickery to reduce the number of floating-point multiplications and additions. Additionally, It can
/// be faster than Mixed-Radix at sizes below 10,000 or so.
/// // Computes a forward FFT of size 1200, using the Good-Thomas Algorithm
/// use rustfft::algorithm::GoodThomasAlgorithm;
/// use rustfft::num_traits::Zero;
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 1200];
/// // we need to find an n1 and n2 such that n1 * n2 == 1200 and GCD(n1, n2) == 1
/// // n1 = 48 and n2 = 25 satisfies this
/// let inner_fft_n1 = planner.plan_fft_forward(48);
/// let inner_fft_n2 = planner.plan_fft_forward(25);
/// // the good-thomas FFT length will be inner_fft_n1.len() * inner_fft_n2.len() = 1200
/// let fft = GoodThomasAlgorithm::new(inner_fft_n1, inner_fft_n2);
/// Creates a FFT instance which will process inputs/outputs of size `width_fft.len() * height_fft.len()`
/// `GCD(width_fft.len(), height_fft.len())` must be equal to 1
reindex_inputreindex_outputinput_output_mapGoodThomasAlgorithmSmall/// Implementation of the Good-Thomas Algorithm, specialized for smaller input sizes
/// Conceptually, this algorithm is very similar to MixedRadix, except because GCD(n1, n2) == 1 we can do some
/// number theory trickery to reduce the number of floating point operations. It typically performs
/// better than MixedRadixSmall, especially at the smallest sizes.
/// // Computes a forward FFT of size 56 using GoodThomasAlgorithmSmall
/// use rustfft::algorithm::GoodThomasAlgorithmSmall;
/// use rustfft::algorithm::butterflies::{Butterfly7, Butterfly8};
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 56];
/// // we need to find an n1 and n2 such that n1 * n2 == 56 and GCD(n1, n2) == 1
/// // n1 = 7 and n2 = 8 satisfies this
/// let inner_fft_n1 = Arc::new(Butterfly7::new(FftDirection::Forward));
/// let inner_fft_n2 = Arc::new(Butterfly8::new(FftDirection::Forward));
/// // the good-thomas FFT length will be inner_fft_n1.len() * inner_fft_n2.len() = 56
/// let fft = GoodThomasAlgorithmSmall::new(inner_fft_n1, inner_fft_n2);
BigScratchAlgorithmtest_good_thomastest_good_thomas_smalltest_good_thomas_with_lengthstest_good_thomas_small_with_lengthstest_output_mappingtest_good_thomas_inner_scratch// Verify that the Good-Thomas algorithm correctly provides scratch space to inner FFTs
MixedRadix/// Implementation of the Mixed-Radix FFT algorithm
/// This algorithm factors a size n FFT into n1 * n2, computes several inner FFTs of size n1 and n2, then combines the
/// results to get the final answer
/// // Computes a forward FFT of size 1200, using the Mixed-Radix Algorithm
/// use rustfft::algorithm::MixedRadix;
/// // we need to find an n1 and n2 such that n1 * n2 == 1200
/// // n1 = 30 and n2 = 40 satisfies this
/// let inner_fft_n1 = planner.plan_fft_forward(30);
/// let inner_fft_n2 = planner.plan_fft_forward(40);
/// // the mixed radix FFT length will be inner_fft_n1.len() * inner_fft_n2.len() = 1200
/// let fft = MixedRadix::new(inner_fft_n1, inner_fft_n2);
MixedRadixSmall/// Implementation of the Mixed-Radix FFT algorithm, specialized for smaller input sizes
/// // Computes a forward FFT of size 40 using MixedRadixSmall
/// use rustfft::algorithm::MixedRadixSmall;
/// use rustfft::algorithm::butterflies::{Butterfly5, Butterfly8};
/// let len = 40;
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; len];
/// // we need to find an n1 and n2 such that n1 * n2 == 40
/// // n1 = 5 and n2 = 8 satisfies this
/// let inner_fft_n1 = Arc::new(Butterfly5::new(FftDirection::Forward));
/// // the mixed radix FFT length will be inner_fft_n1.len() * inner_fft_n2.len() = 40
/// let fft = MixedRadixSmall::new(inner_fft_n1, inner_fft_n2);
test_mixed_radixtest_mixed_radix_smalltest_mixed_radix_with_lengthstest_mixed_radix_small_with_lengthstest_mixed_radix_inner_scratch// Verify that the mixed radix algorithm correctly provides scratch space to inner FFTs
bluesteins_algorithmgood_thomas_algorithmmixed_radixraders_algorithmradix3radix4butterflies/// Hardcoded size-specfic FFT algorithms
RadersAlgorithmRadix3bitreversed_transposeRadix4math_utilsinner_fft_dataprimitive_rootprimitive_root_inverse/// Implementation of Rader's Algorithm
/// This algorithm computes a prime-sized FFT in O(nlogn) time. It does this by converting this size-N FFT into a
/// size-(N - 1) FFT, which is guaranteed to be composite.
/// The worst case for this algorithm is when (N - 1) is 2 * prime, resulting in a
/// [Cunningham Chain](https://en.wikipedia.org/wiki/Cunningham_chain)
/// // Computes a forward FFT of size 1201 (prime number), using Rader's Algorithm
/// use rustfft::algorithm::RadersAlgorithm;
/// // plan a FFT of size n - 1 = 1200
/// let inner_fft = planner.plan_fft_forward(1200);
/// let fft = RadersAlgorithm::new(inner_fft);
/// Rader's Algorithm is relatively expensive compared to other FFT algorithms. Benchmarking shows that it is up to
/// that it takes 2.5x more time to compute than a FFT of size 1200.
/// Creates a FFT instance which will process inputs/outputs of size `inner_fft.len() + 1`.
/// constructor. This further underlines the fact that Rader's Algorithm is more expensive to run than other
/// Panics if `inner_fft.len() + 1` is not a prime number.
test_raderstest_raders_with_lengthbase_fftbase_len/// FFT algorithm optimized for power-of-three sizes
/// // Computes a forward FFT of size 2187
/// use rustfft::algorithm::Radix3;
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 2187];
/// let fft = Radix3::new(2187, FftDirection::Forward);
/// Preallocates necessary arrays and precomputes necessary data to efficiently compute the power-of-three FFT
// Preparing for radix 3 is similar to a transpose, where the column index is bit reversed.
// Use a lookup table to avoid repeating the slow bit reverse operations.
// Unrolling the outer loop by a factor 4 helps speed things up.
compute_logarithm// computes `n` such that `base ^ n == value`. Returns `None` if `value` is not a perfect power of `base`, otherwise returns `Some(n)`
// Sort of like reversing bits in radix4. We're not actually reversing bits, but the algorithm is exactly the same.
// Radix4's bit reversal does divisions by 4, multiplications by 4, and modulo 4 - all of which are easily represented by bit manipulation.
// As a result, it can be thought of as a bit reversal. But really, the "bit reversal"-ness of it is a special case of a more general "remainder reversal"
// IE, it's repeatedly taking the remainder of dividing by N, and building a new number where those remainders are reversed.
// So this algorithm does all the things that bit reversal does, but replaces the multiplications by 4 with multiplications by 3, etc, and ends up with the same conceptual result as a bit reversal.
butterfly_3test_radix3test_3adix3_with_length/// FFT algorithm optimized for power-of-two sizes
/// // Computes a forward FFT of size 4096
/// use rustfft::algorithm::Radix4;
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 4096];
/// let fft = Radix4::new(4096, FftDirection::Forward);
/// Preallocates necessary arrays and precomputes necessary data to efficiently compute the power-of-two FFT
// Preparing for radix 4 is similar to a transpose, where the column index is bit reversed.
// Reverse bits of value, in pairs.
// For 8 bits: abcdefgh -> ghefcdab
butterfly_4test_radix4test_radix4_with_lengthtranspose_small/// Given an array of size width * height, representing a flattened 2D array,
/// transpose the rows and columns of that 2D array into the output
/// benchmarking shows that loop tiling isn't effective for small arrays (in the range of 50x50 or smaller)
workaround_transmuteworkaround_transmute_muttest_transposeiter_chunks// Loop over exact chunks of the provided buffer. Very similar in semantics to ChunksExactMut, but generates smaller code and requires no modulo operations
// Returns Ok() if every element ended up in a chunk, Err() if there was a remainder
iter_chunks_zipped// Loop over exact zipped chunks of the 2 provided buffers. Very similar in semantics to ChunksExactMut.zip(ChunksExactMut), but generates smaller code and requires no modulo operations
// Returns Ok() if every element of both buffers ended up in a chunk, Err() if there was a remainder
avx32_utilsavx_vectorAvxArrayAvxArrayMutAvxVectorAvxVector128AvxVector256Rotation90boilerplate_fft_simd_butterfly// Safety: This macro will call `self::perform_fft_f32()` which probably has a #[target_feature(enable = "...")] annotation on it.
// Calling functions with that annotation is unsafe, because it doesn't actually check if the CPU has the required features.
// Callers of this macro must guarantee that users can't even obtain an instance of $struct_name if their CPU doesn't have the required CPU features.
boilerplate_fft_simd_butterfly_with_scratch// Safety: This macro will call `self::column_butterflies_and_transpose and self::row_butterflies()` which probably has a #[target_feature(enable = "...")] annotation on it.
gen_butterfly_twiddles_interleaved_columnsgen_butterfly_twiddles_separated_columns_phantom_tButterfly5Avxis_supported_by_cpunew_with_avxperform_fft_f32Butterfly7Avxtwiddle_lo_4twiddle_lo_9twiddle_lo_3twiddle_lo_8twiddle_lo_2Butterfly11Avxtwiddles_butterfly4Butterfly8Avxtwiddles_butterfly3Butterfly9AvxButterfly12AvxButterfly16AvxButterfly24Avxtwiddles_butterfly9Butterfly27AvxButterfly32AvxButterfly36AvxButterfly48Avxtwiddles_butterfly9_loButterfly54AvxButterfly64AvxButterfly72Avxtwiddles_butterfly16Butterfly128Avxcolumn_butterflies_and_transposerow_butterfliestwiddles_butterfly32Butterfly256AvxButterfly512Avxtest_avx_butterflytest_avx_butterfly5test_avx_butterfly7test_avx_butterfly8test_avx_butterfly9test_avx_butterfly11test_avx_butterfly12test_avx_butterfly16test_avx_butterfly24test_avx_butterfly27test_avx_butterfly32test_avx_butterfly36test_avx_butterfly48test_avx_butterfly54test_avx_butterfly64test_avx_butterfly72test_avx_butterfly128test_avx_butterfly256test_avx_butterfly512transpose_4x4_f32// Treat the input like the rows of a 4x4 array, and transpose said rows to the columns
transpose_4x6_to_6x4_f32// Treat the input like the rows of a 4x8 array, and transpose it to a 8x4 array, where each array of 4 is one set of 4 columns
// The assumption here is that it's very likely that the caller wants to do some more AVX operations on the columns of the transposed array, so the output is arranged to make that more convenient
// The second array only has two columns of valid data. TODO: make them __m128 instead
transpose_8x4_to_4x8_f32// Treat the input like the rows of a 8x4 array, and transpose it to a 4x8 array
transpose_9x3_to_3x9_emptycolumn1_f32// Treat the input like the rows of a 9x3 array, and transpose it to a 3x9 array.
// our parameters are technically 10 columns, not 9 -- we're going to discard the second element of row0
transpose_9x4_to_4x9_emptycolumn1_f32// Treat the input like the rows of a 9x4 array, and transpose it to a 4x9 array.
transpose_9x6_to_6x9_emptycolumn1_f32transpose_12x4_to_4x12_f32// Treat the input like the rows of a 12x4 array, and transpose it to a 4x12 array
// The assumption here is that the caller wants to do some more AVX operations on the columns of the transposed array, so the output is arranged to make that more convenient
transpose_12x6_to_6x12_f32// Treat the input like the rows of a 12x6 array, and transpose it to a 6x12 array
transpose_8x8_f32// Treat the input like the rows of a 8x8 array, and transpose said rows to the columns
avx64_utils// Safety: This macro will call `self::column_butterflies_and_transpose()` and `self::row_butterflies()` which probably has a #[target_feature(enable = "...")] annotation on it.
Butterfly5Avx64perform_fft_f64Butterfly7Avx64Butterfly11Avx64Butterfly8Avx64Butterfly9Avx64Butterfly12Avx64Butterfly16Avx64Butterfly18Avx64Butterfly24Avx64Butterfly27Avx64Butterfly32Avx64Butterfly36Avx64Butterfly64Avx64Butterfly128Avx64Butterfly256Avx64Butterfly512Avx64test_avx_butterfly5_f64test_avx_butterfly7_f64test_avx_mixedradix8_f64test_avx_mixedradix9_f64test_avx_mixedradix11_f64test_avx_mixedradix12_f64test_avx_mixedradix16_f64test_avx_mixedradix18_f64test_avx_mixedradix24_f64test_avx_mixedradix27_f64test_avx_mixedradix32_f64test_avx_mixedradix36_f64test_avx_mixedradix64_f64test_avx_mixedradix128_f64test_avx_mixedradix256_f64test_avx_mixedradix512_f64transpose_2x2_f64// Treat the input like the rows of a 2x2 array, and transpose said rows to the columns
transpose_4x2_to_2x4_f64// Treat the input like the rows of a 4x2 array, and transpose it to a 2x4 array
transpose_3x3_f64// Treat the input like the rows of a 3x3 array, and transpose it
transpose_3x4_to_4x3_f64// Treat the input like the rows of a 3x4 array, and transpose it to a 4x3 array
transpose_3x6_to_6x3_f64// Treat the input like the rows of a 3x6 array, and transpose it to a 6x3 array
// The assumption here is that caller wants to do some more AVX operations on the columns of the transposed array, so the output is arranged to make that more convenient
transpose_9x3_to_3x9_f64// Treat the input like the rows of a 9x3 array, and transpose it to a 3x9 array
transpose_4x4_f64transpose_6x6_f64// Treat the input like the rows of a 6x6 array, and transpose said rows to the columns
transpose_6x4_to_4x6_f64// Treat the input like the rows of a 6x4 array, and transpose said rows to the columns
transpose_8x4_to_4x8_f64CommonSimdDataAvxNumVectorTypecommon_dataBluesteinsAvx/// This algorithm computes an arbitrary-sized FFT in O(nlogn) time. It does this by converting this size n FFT into a
/// size M where M >= 2N - 1. The most obvious choice for M is a power of two, although that isn't a requirement.
/// It requires a large scratch space, so it's probably inconvenient to use as an inner FFT to other algorithms.
/// Bluestein's Algorithm is relatively expensive compared to other FFT algorithms. Benchmarking shows that it is up to
/// an order of magnitude slower than similar composite sizes.
boilerplate_avx_fft_commondatamul_complex_conjugated/// Pairwise multiply the complex numbers in `left` with the complex numbers in `right`.
/// This is exactly the same as `mul_complex` in `AvxVector`, but this implementation also conjugates the `left` input before multiplying
/// Preallocates necessary arrays and precomputes necessary data to efficiently compute the FFT
/// Returns Ok() if this machine has the required instruction sets, Err() if some instruction sets are missing
prepare_bluesteins// Do the necessary setup for bluestein's algorithm: copy the data to the inner buffers, apply some twiddle factors, zero out the rest of the inner buffer
finalize_bluesteins// Do the necessary finalization for bluestein's algorithm: Conjugate the inner FFT buffer, apply some twiddle factors, zero out the rest of the inner buffer
pairwise_complex_multiply_conjugated// compute buffer[i] = buffer[i].conj() * multiplier[i] pairwise complex multiplication for each element.
test_bluesteins_avx_f32test_bluesteins_avx_f64test_bluesteins_avx_with_lengthboilerplate_mixedradixmixedradix_gen_datamixedradix_column_butterfliesmixedradix_transposeMixedRadix2xnAvxperform_column_butterfliesr" Preallocates necessary arrays and precomputes necessary data to efficiently compute the FFT
"r" Returns Ok() if this machine has the required instruction sets, Err() if some instruction sets are missing
"MixedRadix3xnAvxMixedRadix4xnAvxtwiddles_butterfly5MixedRadix5xnAvxMixedRadix6xnAvxtwiddles_butterfly7MixedRadix7xnAvxMixedRadix8xnAvxMixedRadix9xnAvxtwiddles_butterfly11MixedRadix11xnAvxMixedRadix12xnAvxMixedRadix16xnAvxtest_avx_mixed_radixtest_mixedradix_2xn_avx_f32test_mixedradix_2xn_avx_f64test_mixedradix_3xn_avx_f32test_mixedradix_3xn_avx_f64test_mixedradix_4xn_avx_f32test_mixedradix_4xn_avx_f64test_mixedradix_5xn_avx_f32test_mixedradix_5xn_avx_f64test_mixedradix_6xn_avx_f32test_mixedradix_6xn_avx_f64test_mixedradix_7xn_avx_f32test_mixedradix_7xn_avx_f64test_mixedradix_8xn_avx_f32test_mixedradix_8xn_avx_f64test_mixedradix_9xn_avx_f32test_mixedradix_9xn_avx_f64test_mixedradix_11xn_avx_f32test_mixedradix_11xn_avx_f64test_mixedradix_12xn_avx_f32test_mixedradix_12xn_avx_f64test_mixedradix_16xn_avx_f32test_mixedradix_16xn_avx_f64PartialFactorsfft_cacheFftCachewrap_fftMixedRadixBaseButterflyBase// The base will be a butterfly algorithm
RadersBase// The base will be an instance of Rader's Algorithm. That will require its own plan for the internal FFT, which we'll handle separately
BluesteinsBase// The base will be an instance of Bluestein's Algorithm. That will require its own plan for the internal FFT, which we'll handle separately.
// First usize is the base length, second usize is the inner FFT length
CacheBase// The "base" is a FFT instance we already have cached
radixes// product of base and radixes
// stored from innermost to outermost
MixedRadixPlan/// repreesnts a FFT plan, stored as a base FFT and a stack of MixedRadix*xn on top of it.
butterflypush_radixpush_radix_powerinternal_plannerAvxPlannerInternalAPIFftPlannerAvx/// The AVX FFT planner creates new FFT algorithm instances which take advantage of the AVX instruction set.
/// Creating an instance of `FftPlannerAvx` requires the `avx` and `fma` instructions to be available on the current machine, and it requires RustFFT's
///  `avx` feature flag to be set. A few algorithms will use `avx2` if it's available, but it isn't required.
/// For the time being, AVX acceleration is black box, and AVX accelerated algorithms are not available without a planner. This may change in the future.
/// // Perform a forward Fft of size 1234, accelerated by AVX
/// use rustfft::{FftPlannerAvx, num_complex::Complex};
/// // If FftPlannerAvx::new() returns Ok(), we'll know AVX algorithms are available
/// // on this machine, and that RustFFT was compiled with the `avx` feature flag
/// if let Ok(mut planner) = FftPlannerAvx::new() {
///     let fft = planner.plan_fft_forward(1234);
///     let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 1234];
///     fft.process(&mut buffer);
///     // The FFT instance returned by the planner has the type `Arc<dyn Fft<T>>`,
///     // where T is the numeric type, ie f32 or f64, so it's cheap to clone
///     let fft_clone = Arc::clone(&fft);
/// If you plan on creating multiple FFT instances, it is recommended to re-use the same planner for all of them. This
/// is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing
/// setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created
/// by a different planner)
/// Each FFT instance owns [`Arc`s](std::sync::Arc) to its internal data, rather than borrowing it from the planner, so it's perfectly
/// safe to drop the planner after creating Fft instances.
/// Constructs a new `FftPlannerAvx` instance.
/// Returns `Ok(planner_instance)` if we're compiling for X86_64, AVX support was enabled in feature flags, and the current CPU supports the `avx` and `fma` CPU features.
/// Returns `Err(())` if AVX support is not available.
plan_fft/// Returns a `Fft` instance which uses AVX instructions to compute FFTs of size `len`.
/// If the provided `direction` is `FftDirection::Forward`, the returned instance will compute forward FFTs. If it's `FftDirection::Inverse`, it will compute inverse FFTs.
/// If this is called multiple times, the planner will attempt to re-use internal data between calls, reducing memory usage and FFT initialization time.
/// Returns a `Fft` instance which uses AVX instructions to compute forward FFTs of size `len`.
/// Returns a `Fft` instance which uses AVX instructions to compute inverse FFTs of size `len.
debug_plan_fft/// Returns a FFT plan without constructing it
plan_and_construct_fftAvxPlannerInternalplan_mixed_radix_baseis_butterflyconstruct_butterfly//-------------------------------------------------------------------
// f32-specific planning stuff
// f64-specific planning stuff
// Given a length, return a plan for how this FFT should be computed
replan_with_cache// Takes a plan and an algorithm cache, and replaces steps of the plan with cached steps, if possible
plan_power12_power6// given a set of factors, compute how many iterations of 12xn and 16xn we should plan for. Returns (k, j) for 12^k and 6^j
plan_mixed_radixconstruct_plan// Constructs and returns a FFT instance from a FFT plan.
// If the base is a butterfly, it will call the provided `construct_butterfly_fn` to do so.
// If constructing the base requires constructing an inner FFT (IE bluetein's or rader's algorithm), it will call the provided `inner_fft_fn` to construct it
plan_bluesteins// Plan and return the inner size to be used with Bluestein's Algorithm
// Calls `filter_fn` on result candidates, giving the caller the opportunity to reject certain sizes
// type-agnostic planning stuff
test_plan_zero_avx// We don't need to actually compute anything for a FFT size of zero, but we do need to verify that it doesn't explode
divisorVectorizedMultiplyMod// This struct wraps the necessary data to compute (a * b) % divisor, where b and divisor are determined at runtime but rarely change, and a changes on every call.
// It's written using AVX2 instructions and assumes the input a are 64-bit integers, and has a restriction that each a, b, and divisor must be 31-bit numbers or smaller.
mul_rem// Input: 4 unsigned 64-bit numbers, each less than 2^30
// Output: (x * multiplier) % divisor for each x in input
input_index_multiplierinput_index_initoutput_index_mappingRadersAvx2/// Implementation of Rader's Algorithm, using AVX2 instructions.
/// This algorithm computes a prime-sized FFT in O(nlogn) time. It does this by converting this size n FFT into a
/// size (n - 1) which is guaranteed to be composite.
/// The worst case for this algorithm is when (n - 1) is 2 * prime, resulting in a
/// Returns Ok(instance) if this machine has the required instruction sets ("avx", "fma", and "avx2"), Err() if some instruction sets are missing
/// Panics if `inner_fft_len() + 1` is not a prime number.
prepare_raders// Do the necessary setup for rader's algorithm: Reorder the inputs into the output buffer, gather a sum of all inputs. Return the first input, and the aum of all inputs
finalize_raders// Do the necessary finalization for rader's algorithm: Reorder the inputs into the output buffer, conjugating the input as we go, and add the first input value to every output value
boilerplate_avx_ffttest_raders_avx_f32test_raders_avx_f64SCALAR_PER_VECTORCOMPLEX_PER_VECTOR// useful constants
half_root2// an entire vector filled with 0.5.sqrt()
// Basic operations that map directly to 1-2 AVX intrinsics
fmaddfnmaddfmaddsubfmsubaddswap_complex_components// More basic operations that end up being implemented in 1-2 intrinsics, but unlike the ones above, these have higher-level meaning than just arithmetic
/// Swap each real number with its corresponding imaginary number
duplicate_complex_components/// first return is the reals duplicated into the imaginaries, second return is the imaginaries duplicated into the reals
reverse_complex_elements/// Reverse the order of complex numbers in the vector, so that the last is the first and the first is the last
unpacklo_complex/// Copies the even elements of rows[1] into the corresponding odd elements of rows[0] and returns the result.
unpackhi_complex/// Copies the odd elements of rows[0] into the corresponding even elements of rows[1] and returns the result.
unpack_complexbroadcast_twiddle/// Fill a vector by computing a twiddle factor and repeating it across the whole vector
make_rotation90/// create a Rotator90 instance to rotate complex numbers either 90 or 270 degrees, based on the value of `inverse`
make_mixedradix_twiddle_chunk/// Generates a chunk of twiddle factors starting at (X,Y) and incrementing X `COMPLEX_PER_VECTOR` times.
/// The result will be [twiddle(x*y, len), twiddle((x+1)*y, len), twiddle((x+2)*y, len), ...] for as many complex numbers fit in a vector
transpose2_packed/// Packed transposes. Used by mixed radix. These all take a NxC array, where C is COMPLEX_PER_VECTOR, and transpose it to a CxN array.
/// But they also pack the result into as few vectors as possible, with the goal of writing the transposed data out contiguously.
transpose3_packedtranspose4_packedtranspose5_packedtranspose6_packedtranspose7_packedtranspose8_packedtranspose9_packedtranspose11_packedtranspose12_packedtranspose16_packedmul_complexcolumn_butterfly2column_butterfly3column_butterfly4column_butterfly4_negaterow3// A niche variant of column_butterfly4 that negates row 3 before performing the FFT. It's able to roll it into existing instructions, so the negation is free
column_butterfly5column_butterfly7column_butterfly8column_butterfly11column_butterfly16/// A SIMD vector of complex numbers, stored with the real values and imaginary values interleaved.
/// Implemented for __m128, __m128d, __m256, __m256d, but these all require the AVX instruction set.
/// The goal of this trait is to reduce code duplication by letting code be generic over the vector type
HalfVectorFullVectorScalarTypebroadcast_complex_elements/// Fill a vector by repeating the provided complex number as many times as possible
hadd_complex/// Adds all complex elements from this vector horizontally
load_complex// loads/stores of complex numbers
store_complexgather_complex_avx2_index32// Gather 4 complex numbers (for f32) or 2 complex numbers (for f64) using 4 i32 indexes (for index32) or 4 i64 indexes (for index64).
// For f32, there should be 1 index per complex. For f64, there should be 2 indexes, each duplicated
// (So to load the complex<f64> at index 5 and 7, the index vector should contain 5,5,7,7. this api sucks but it's internal so whatever.)
gather_complex_avx2_index64load_partial1_complex// loads/stores of partial vectors of complex numbers. When loading, empty elements are zeroed
// unimplemented!() if Self::COMPLEX_PER_VECTOR is not greater than the partial count
load_partial2_complexload_partial3_complexstore_partial1_complexstore_partial2_complexstore_partial3_complexcolumn_butterfly6column_butterfly9column_butterfly12/// A 256-bit SIMD vector of complex numbers, stored with the real values and imaginary values interleaved.
/// Implemented for __m256, __m256d
/// This trait implements things specific to 256-types, like splitting a 256 vector into 128 vectors
/// For compiler-placation reasons, all interactions/awareness the scalar type go here
lo_rotationgather32_complex_avx2// Gather 2 complex numbers (for f32) or 1 complex number (for f64) using 2 i32 indexes (for gather32) or 2 i64 indexes (for gather64).
// (So to load the complex<f64> at index 5, the index vector should contain 5,5. this api sucks but it's internal so whatever.)
gather64_complex_avx2/// A 128-bit SIMD vector of complex numbers, stored with the real values and imaginary values interleaved.
/// Implemented for __m128, __m128d, but these are all oriented around AVX, so don't call methods on these from a SSE-only context
/// This trait implements things specific to 128-types, like merging 2 128 vectors into a 256 vector
apply_butterfly8_twiddle1apply_butterfly8_twiddle3input_ptr// some avx operations need bespoke one-off things that don't fit into the methods above, so we should provide an escape hatch for them
output_ptrcolumn_butterfly16_loadfn// A custom butterfly-16 function that calls a lambda to load/store data instead of taking an array
// This is particularly useful for butterfly 16, because the whole problem doesn't fit into registers, and the compiler isn't smart enough to only load data when it's needed
// So the version that takes an array ends up loading data and immediately re-storing it on the stack. By lazily loading and storing exactly when we need to, we can avoid some data reshuffling
column_butterfly32_loadfn// A custom butterfly-32 function that calls a lambda to load/store data instead of taking an array
// This is particularly useful for butterfly 32, because the whole problem doesn't fit into registers, and the compiler isn't smart enough to only load data when it's needed
/// Multiply the complex numbers in `left` by the complex numbers in `right`.
pairwise_complex_mul_assign_conjugatedpairwise_complex_mul_conjugated// compute output[i] = input[i].conj() * multiplier[i] pairwise complex multiplication for each element.
// Data that most (non-butterfly) SIMD FFT algorithms share
// Algorithms aren't required to use this struct, but it allows for a lot of reduction in code duplication
avx32_butterfliesavx64_butterfliesavx_bluesteinsavx_mixed_radixavx_radersavx_planner/// Generic floating point number, implemented for f32 and f64
// Prints an error raised by an in-place FFT algorithm's `process_inplace` method
// Marked cold and inline never to keep all formatting code out of the many monomorphized process_inplace methods
forward_cacheinverse_cachecontains_fft/// Individual FFT algorithms
planFftPlannerScalar/// The FFT size that this algorithm can process
/// A trait that allows FFT algorithms to report their expected input/output size
Inverse/// Represents a FFT direction, IE a forward FFT or an inverse FFT
opposite_direction/// Returns the opposite direction of `self`.
///  - If `self` is `FftDirection::Forward`, returns `FftDirection::Inverse`
///  - If `self` is `FftDirection::Inverse`, returns `FftDirection::Forward`
/// Returns FftDirection::Forward if this instance computes forward FFTs, or FftDirection::Inverse for inverse FFTs
/// A trait that allows FFT algorithms to report whether they compute forward FFTs or inverse FFTs
/// Computes a FFT in-place.
/// Convenience method that allocates a `Vec` with the required scratch space and calls `self.process_with_scratch`.
/// If you want to re-use that allocation across multiple FFT computations, consider calling `process_with_scratch` instead.
/// This method panics if:
/// - `buffer.len() % self.len() > 0`
/// - `buffer.len() < self.len()`
/// Divides `buffer` into chunks of size `self.len()`, and computes a FFT on each chunk.
/// Uses the `scratch` buffer as scratch space, so the contents of `scratch` should be considered garbage
/// after calling.
/// - `scratch.len() < self.get_inplace_scratch_len()`
/// Divides `input` and `output` into chunks of size `self.len()`, and computes a FFT on each chunk.
/// This method uses both the `input` buffer and `scratch` buffer as scratch space, so the contents of both should be
/// considered garbage after calling.
/// This is a more niche way of computing a FFT. It's useful to avoid a `copy_from_slice()` if you need the output
/// in a different buffer than the input for some reason. This happens frequently in RustFFT internals, but is probably
/// less common among RustFFT users.
/// For many FFT sizes, `self.get_outofplace_scratch_len()` returns 0
/// - `output.len() != input.len()`
/// - `input.len() % self.len() > 0`
/// - `input.len() < self.len()`
/// - `scratch.len() < self.get_outofplace_scratch_len()`
/// Returns the size of the scratch buffer required by `process_with_scratch`
/// For most FFT sizes, this method will return `self.len()`. For a few small sizes it will return 0, and for some special FFT sizes
/// (Sizes that require the use of Bluestein's Algorithm), this may return a scratch size larger than `self.len()`.
/// The returned value may change from one version of RustFFT to the next.
/// Returns the size of the scratch buffer required by `process_outofplace_with_scratch`
/// For most FFT sizes, this method will return 0. For some special FFT sizes
/// Trait for algorithms that compute FFTs.
/// This trait has a few methods for computing FFTs. Its most conveinent method is [`process(slice)`](crate::Fft::process).
/// It takes in a slice of `Complex<T>` and computes a FFT on that slice, in-place. It may copy the data over to internal scratch buffers
/// if that speeds up the computation, but the output will always end up in the same slice as the input.
// Algorithms implemented to use AVX instructions. Only compiled on x86_64, and only compiled if the "avx" feature flag is set.
sse// Algorithms implemented to use SSE4.1 instructions. Only compiled on x86_64, and only compiled if the "sse" feature flag is set.
sse_plannerFftPlannerSseFftPlannerNeon/// The Neon FFT planner creates new FFT algorithm instances using a mix of scalar and Neon accelerated algorithms.
/// It is supported when using the 64-bit AArch64 instruction set.
/// RustFFT has several FFT algorithms available. For a given FFT size, the `FftPlannerNeon` decides which of the
/// available FFT algorithms to use and then initializes them.
/// // Perform a forward Fft of size 1234
/// use rustfft::{FftPlannerNeon, num_complex::Complex};
/// if let Ok(mut planner) = FftPlannerNeon::new() {
///   let fft = planner.plan_fft_forward(1234);
///   let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 1234];
///   fft.process(&mut buffer);
///   // The FFT instance returned by the planner has the type `Arc<dyn Fft<T>>`,
///   // where T is the numeric type, ie f32 or f64, so it's cheap to clone
///   let fft_clone = Arc::clone(&fft);
/// If you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This
/// Creates a new `FftPlannerNeon` instance.
/// Returns `Ok(planner_instance)` if this machine has the required instruction sets.
/// Returns `Err(())` if some instruction sets are missing.
/// Returns a `Fft` instance which uses Neon instructions to compute FFTs of size `len`.
/// Returns a `Fft` instance which uses Neon instructions to compute forward FFTs of size `len`.
/// Returns a `Fft` instance which uses Neon instructions to compute inverse FFTs of size `len.
neon_planner// If we're not on AArch64, or if the "neon" feature was disabled, keep a stub implementation around that has the same API, but does nothing
// That way, users can write code using the Neon planner and compile it on any platform
FftPlannerWasmSimd/// The WASM FFT planner creates new FFT algorithm instances using a mix of scalar and WASM SIMD accelerated algorithms.
/// It is supported when using fairly recent browser versions as outlined in [the WebAssembly roadmap](https://webassembly.org/roadmap/).
/// RustFFT has several FFT algorithms available. For a given FFT size, `FftPlannerWasmSimd` decides which of the
/// use rustfft::{FftPlannerWasmSimd, num_complex::Complex};
/// if let Ok(mut planner) = FftPlannerWasmSimd::new() {
/// Creates a new `FftPlannerWasmSimd` instance.
/// Returns a `Fft` instance which uses WebAssembly SIMD instructions to compute FFTs of size `len`.
/// Returns a `Fft` instance which uses WebAssembly SIMD instructions to compute forward FFTs of size `len`.
/// Returns a `Fft` instance which uses WebAssembly SIMD instructions to compute inverse FFTs of size `len.
wasm_simd_plannerwasm_simd// If we're not compiling to WebAssembly, or if the "wasm_simd" feature was disabled, keep a stub implementation around that has the same API, but does nothing
// That way, users can write code using the WASM planner and compile it on any platform
//! RustFFT is a high-performance FFT library written in pure Rust.
//! On X86_64, RustFFT supports the AVX instruction set for increased performance. No special code is needed to activate AVX:
//! Simply plan a FFT using the FftPlanner on a machine that supports the `avx` and `fma` CPU features, and RustFFT
//! will automatically switch to faster AVX-accelerated algorithms.
//! For machines that do not have AVX, RustFFT also supports the SSE4.1 instruction set.
//! As for AVX, this is enabled automatically when using the FftPlanner.
//! Additionally, there is automatic support for the Neon instruction set on AArch64,
//! and support for WASM SIMD when compiling for WASM targets.
//! ### Usage
//! The recommended way to use RustFFT is to create a [`FftPlanner`](crate::FftPlanner) instance and then call its
//! [`plan_fft`](crate::FftPlanner::plan_fft) method. This method will automatically choose which FFT algorithms are best
//! for a given size and initialize the required buffers and precomputed data.
//! // Perform a forward FFT of size 1234
//! use rustfft::{FftPlanner, num_complex::Complex};
//! let mut planner = FftPlanner::new();
//! let fft = planner.plan_fft_forward(1234);
//! let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 1234];
//! fft.process(&mut buffer);
//! The planner returns trait objects of the [`Fft`](crate::Fft) trait, allowing for FFT sizes that aren't known
//! until runtime.
//! RustFFT also exposes individual FFT algorithms. For example, if you know beforehand that you need a power-of-two FFT, you can
//! avoid the overhead of the planner and trait object by directly creating instances of the [`Radix4`](crate::algorithm::Radix4) algorithm:
//! // Computes a forward FFT of size 4096
//! use rustfft::{Fft, FftDirection, num_complex::Complex, algorithm::Radix4};
//! let fft = Radix4::new(4096, FftDirection::Forward);
//! let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 4096];
//! For the vast majority of situations, simply using the [`FftPlanner`](crate::FftPlanner) will be enough, but
//! advanced users may have better insight than the planner into which algorithms are best for a specific size. See the
//! [`algorithm`](crate::algorithm) module for a complete list of scalar algorithms implemented by RustFFT.
//! Users should beware, however, that bypassing the planner will disable all AVX, SSE, Neon, and WASM SIMD optimizations.
//! ### Feature Flags
//! * `avx` (Enabled by default)
//!     On x86_64, the `avx` feature enables compilation of AVX-accelerated code. Enabling it greatly improves performance if the
//!     client CPU supports AVX and FMA, while disabling it reduces compile time and binary size.
//!     On every platform besides x86_64, this feature does nothing, and RustFFT will behave like it's not set.
//! * `sse` (Enabled by default)
//!     On x86_64, the `sse` feature enables compilation of SSE4.1-accelerated code. Enabling it improves performance
//!     if the client CPU supports SSE4.1, while disabling it reduces compile time and binary size. If AVX is also
//!     supported and its feature flag is enabled, RustFFT will use AVX instead of SSE4.1.
//! * `neon` (Enabled by default)
//!     On AArch64 (64-bit ARM) the `neon` feature enables compilation of Neon-accelerated code. Enabling it improves
//!     performance, while disabling it reduces compile time and binary size.
//!     On every platform besides AArch64, this feature does nothing, and RustFFT will behave like it's not set.
//! * `wasm_simd` (Disabled by default)
//!     On the WASM platform, this feature enables compilation of WASM SIMD accelerated code.
//!     To execute binaries compiled with `wasm_simd`, you need a [target browser or runtime which supports `fixed-width SIMD`](https://webassembly.org/roadmap/).
//!     If you run your SIMD accelerated code on an unsupported platform, WebAssembly will specify a [trap](https://webassembly.github.io/spec/core/intro/overview.html#trap) leading to immediate execution cancelation.
//!     On every platform besides WASM, this feature does nothing and RustFFT will behave like it is not set.
//! ### Normalization
//! RustFFT does not normalize outputs. Callers must manually normalize the results by scaling each element by
//! `1/len().sqrt()`. Multiple normalization steps can be merged into one via pairwise multiplication, so when
//! doing a forward FFT followed by an inverse callers can normalize once by scaling each element by `1/len()`
//! ### Output Order
//! Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.
//! ### AVX Performance Tips
//! In any FFT computation, the time required to compute a FFT of size N relies heavily on the [prime factorization](https://en.wikipedia.org/wiki/Integer_factorization) of N.
//! If N's prime factors are all very small, computing a FFT of size N will be fast, and it'll be slow if N has large prime
//! factors, or if N is a prime number.
//! In most FFT libraries (Including RustFFT when using non-AVX code), power-of-two FFT sizes are the fastest, and users see a steep
//! falloff in performance when using non-power-of-two sizes. Thankfully, RustFFT using AVX acceleration is not quite as restrictive:
//! - Any FFT whose size is of the form `2^n * 3^m` can be considered the "fastest" in RustFFT.
//! - Any FFT whose prime factors are all 11 or smaller will also be very fast, but the fewer the factors of 2 and 3 the slower it will be.
//!     For example, computing a FFT of size 13552 `(2^4*7*11*11)` is takes 12% longer to compute than 13824 `(2^9 * 3^3)`,
//!     and computing a FFT of size 2541 `(3*7*11*11)` takes 65% longer to compute than 2592 `(2^5 * 3^4)`
//! - Any other FFT size will be noticeably slower. A considerable amount of effort has been put into making these FFT sizes as fast as
//!     they can be, but some FFT sizes just take more work than others. For example, computing a FFT of size 5183 `(71 * 73)` takes about
//!     5x longer than computing a FFT of size 5184 `(2^6 * 3^4)`.
//! In most cases, even prime-sized FFTs will be fast enough for your application. In the example of 5183 above, even that "slow" FFT
//! only takes a few tens of microseconds to compute.
//! Some applications of the FFT allow for choosing an arbitrary FFT size (In many applications the size is pre-determined by whatever you're computing).
//! If your application supports choosing your own size, our advice is still to start by trying the size that's most convenient to your application.
//! If that's too slow, see if you can find a nearby size whose prime factors are all 11 or smaller, and you can expect a 2x-5x speedup.
//! If that's still too slow, find a nearby size whose prime factors are all 2 or 3, and you can expect a 1.1x-1.5x speedup.
modular_exponent/// computes base^exponent % modulo using the standard exponentiation by squaring algorithm
distinct_prime_factors/// return all of the prime factors of n, but omit duplicate prime factors
PrimeFactorother_factorspower_twopower_threetotal_factor_countdistinct_factor_countPrimeFactorsget_productget_total_factor_countget_distinct_factor_countget_power_of_twoget_power_of_threeget_other_factorsis_power_of_threeremove_factors// Divides the number by the given prime factor. Returns None if the resulting number is one.
partition_factors// Splits this set of prime factors into two different sets so that the products of the two sets are as close as possible
power2power3power5power7power11get_power2get_power3get_power5get_power7get_power11product_power2power3test_modular_exponenttest_primitive_roottest_distinct_prime_factorsassert_internally_consistenttest_prime_factorstest_partition_factorstest_remove_factorstest_partial_factorstest_partial_factors_divide_byneon_commonneon_vectorneon_butterfliesneon_prime_butterfliesneon_radix4neon_utilsassert_f32assert_f64NeonArrayMutboilerplate_fft_neon_f32_butterflyboilerplate_fft_neon_f64_butterflyboilerplate_fft_neon_common_butterflyNeonF32Butterfly1//   _            _________  _     _ _
//  / |          |___ /___ \| |__ (_) |_
//  | |   _____    |_ \ __) | '_ \| | __|
//  | |  |_____|  ___) / __/| |_) | | |_
//  |_|          |____/_____|_.__/|_|\__|
perform_parallel_fft_contiguousNeonF64Butterfly1//   _             __   _  _   _     _ _
//  / |           / /_ | || | | |__ (_) |_
//  | |   _____  | '_ \| || |_| '_ \| | __|
//  | |  |_____| | (_) |__   _| |_) | | |_
//  |_|           \___/   |_| |_.__/|_|\__|
NeonF32Butterfly2//   ____            _________  _     _ _
//  |___ \          |___ /___ \| |__ (_) |_
//    __) |  _____    |_ \ __) | '_ \| | __|
//   / __/  |_____|  ___) / __/| |_) | | |_
//  |_____|         |____/_____|_.__/|_|\__|
perform_fft_direct// length 2 fft of x, given as [x0, x1]
// result is [X0, X1]
perform_parallel_fft_direct// dual length 2 fft of x and y, given as [x0, x1], [y0, y1]
// result is [X0, Y0], [X1, Y1]
parallel_fft2_interleaved_f32// double lenth 2 fft of a and b, given as [x0, y0], [x1, y1]
parallel_fft2_contiguous_f32// double lenth 2 fft of a and b, given as [x0, x1], [y0, y1]
solo_fft2_f32NeonF64Butterfly2//   ____             __   _  _   _     _ _
//  |___ \           / /_ | || | | |__ (_) |_
//    __) |  _____  | '_ \| || |_| '_ \| | __|
//   / __/  |_____| | (_) |__   _| |_) | | |_
//  |_____|          \___/   |_| |_.__/|_|\__|
solo_fft2_f64Rotate90F32twiddle1retwiddle1imNeonF32Butterfly3//   _____            _________  _     _ _
//  |___ /           |___ /___ \| |__ (_) |_
//    |_ \    _____    |_ \ __) | '_ \| | __|
//   ___) |  |_____|  ___) / __/| |_) | | |_
//  |____/           |____/_____|_.__/|_|\__|
// length 3 fft of a, given as [x0, 0.0], [x1, x2]
// result is [X0, Z], [X1, X2]
// The value Z should be discarded.
// length 3 dual fft of a, given as (x0, y0), (x1, y1), (x2, y2).
// result is [(X0, Y0), (X1, Y1), (X2, Y2)]
Rotate90F64NeonF64Butterfly3//   _____             __   _  _   _     _ _
//  |___ /            / /_ | || | | |__ (_) |_
//    |_ \    _____  | '_ \| || |_| '_ \| | __|
//   ___) |  |_____| | (_) |__   _| |_) | | |_
//  |____/            \___/   |_| |_.__/|_|\__|
// length 3 fft of x, given as x0, x1, x2.
// result is [X0, X1, X2]
NeonF32Butterfly4//   _  _             _________  _     _ _
//  | || |           |___ /___ \| |__ (_) |_
//  | || |_   _____    |_ \ __) | '_ \| | __|
//  |__   _| |_____|  ___) / __/| |_) | | |_
//     |_|           |____/_____|_.__/|_|\__|
// length 4 fft of a, given as [x0, x1], [x2, x3]
// result is [[X0, X1], [X2, X3]]
NeonF64Butterfly4//   _  _              __   _  _   _     _ _
//  | || |            / /_ | || | | |__ (_) |_
//  | || |_   _____  | '_ \| || |_| '_ \| | __|
//  |__   _| |_____| | (_) |__   _| |_) | | |_
//     |_|            \___/   |_| |_.__/|_|\__|
twiddle12retwiddle21retwiddle12imtwiddle21imtwiddle2retwiddle2imNeonF32Butterfly5//   ____             _________  _     _ _
//  | ___|           |___ /___ \| |__ (_) |_
//  |___ \    _____    |_ \ __) | '_ \| | __|
// length 5 fft of a, given as [x0, x0], [x1, x2], [x3, x4].
// result is [[X0, Z], [X1, X2], [X3, X4]]
// Note that Z should not be used.
// length 5 dual fft of x and y, given as (x0, y0), (x1, y1) ... (x4, y4).
// result is [(X0, Y0), (X1, Y1) ... (X2, Y2)]
NeonF64Butterfly5//   ____              __   _  _   _     _ _
//  | ___|            / /_ | || | | |__ (_) |_
//  |___ \    _____  | '_ \| || |_| '_ \| | __|
// length 5 fft of x, given as x0, x1, x2, x3, x4.
// result is [X0, X1, X2, X3, X4]
bf3NeonF32Butterfly6//    __             _________  _     _ _
//   / /_           |___ /___ \| |__ (_) |_
//  | '_ \   _____    |_ \ __) | '_ \| | __|
//  | (_) | |_____|  ___) / __/| |_) | | |_
//   \___/          |____/_____|_.__/|_|\__|
NeonF64Butterfly6//    __              __   _  _   _     _ _
//   / /_            / /_ | || | | |__ (_) |_
//  | '_ \   _____  | '_ \| || |_| '_ \| | __|
//  | (_) | |_____| | (_) |__   _| |_) | | |_
//   \___/           \___/   |_| |_.__/|_|\__|
root2_dualbf4NeonF32Butterfly8//    ___            _________  _     _ _
//   ( _ )          |___ /___ \| |__ (_) |_
//   / _ \   _____    |_ \ __) | '_ \| | __|
NeonF64Butterfly8//    ___             __   _  _   _     _ _
//   ( _ )           / /_ | || | | |__ (_) |_
//   / _ \   _____  | '_ \| || |_| '_ \| | __|
NeonF32Butterfly9//   / _ \          |___ /___ \| |__ (_) |_
//  | (_) |  _____    |_ \ __) | '_ \| | __|
//   \__, | |_____|  ___) / __/| |_) | | |_
//     /_/          |____/_____|_.__/|_|\__|
NeonF64Butterfly9//   / _ \           / /_ | || | | |__ (_) |_
//  | (_) |  _____  | '_ \| || |_| '_ \| | __|
//   \__, | |_____| | (_) |__   _| |_) | | |_
//     /_/           \___/   |_| |_.__/|_|\__|
bf5NeonF32Butterfly10//   _  ___            _________  _     _ _
//  / |/ _ \          |___ /___ \| |__ (_) |_
//  | | | | |  _____    |_ \ __) | '_ \| | __|
//  | | |_| | |_____|  ___) / __/| |_) | | |_
//  |_|\___/          |____/_____|_.__/|_|\__|
bf2NeonF64Butterfly10//   _  ___             __   _  _   _     _ _
//  / |/ _ \           / /_ | || | | |__ (_) |_
//  | | | | |  _____  | '_ \| || |_| '_ \| | __|
//  | | |_| | |_____| | (_) |__   _| |_) | | |_
//  |_|\___/           \___/   |_| |_.__/|_|\__|
NeonF32Butterfly12//   _ ____            _________  _     _ _
//  / |___ \          |___ /___ \| |__ (_) |_
//  | | __) |  _____    |_ \ __) | '_ \| | __|
//  | |/ __/  |_____|  ___) / __/| |_) | | |_
//  |_|_____|         |____/_____|_.__/|_|\__|
NeonF64Butterfly12//   _ ____             __   _  _   _     _ _
//  / |___ \           / /_ | || | | |__ (_) |_
//  | | __) |  _____  | '_ \| || |_| '_ \| | __|
//  | |/ __/  |_____| | (_) |__   _| |_) | | |_
//  |_|_____|          \___/   |_| |_.__/|_|\__|
NeonF32Butterfly15//  / | ___|          |___ /___ \| |__ (_) |_
//  | |___ \   _____    |_ \ __) | '_ \| | __|
//  | |___) | |_____|  ___) / __/| |_) | | |_
//  |_|____/          |____/_____|_.__/|_|\__|
NeonF64Butterfly15//  / | ___|           / /_ | || | | |__ (_) |_
//  | |___ \   _____  | '_ \| || |_| '_ \| | __|
//  | |___) | |_____| | (_) |__   _| |_) | | |_
//  |_|____/           \___/   |_| |_.__/|_|\__|
bf8twiddle01twiddle23twiddle01conjtwiddle23conjtwiddle1ctwiddle2ctwiddle3cNeonF32Butterfly16//   _  __             _________  _     _ _
//  / |/ /_           |___ /___ \| |__ (_) |_
//  | | '_ \   _____    |_ \ __) | '_ \| | __|
//  | | (_) | |_____|  ___) / __/| |_) | | |_
NeonF64Butterfly16//   _  __              __   _  _   _     _ _
//  / |/ /_            / /_ | || | | |__ (_) |_
//  | | '_ \   _____  | '_ \| || |_| '_ \| | __|
//  | | (_) | |_____| | (_) |__   _| |_) | | |_
twiddle45twiddle67twiddle45conjtwiddle67conjtwiddle4ctwiddle5ctwiddle6ctwiddle7cNeonF32Butterfly32//   _________            _________  _     _ _
//  |___ /___ \          |___ /___ \| |__ (_) |_
//    |_ \ __) |  _____    |_ \ __) | '_ \| | __|
//   ___) / __/  |_____|  ___) / __/| |_) | | |_
//  |____/_____|         |____/_____|_.__/|_|\__|
NeonF64Butterfly32//   _________             __   _  _   _     _ _
//  |___ /___ \           / /_ | || | | |__ (_) |_
//    |_ \ __) |  _____  | '_ \| || |_| '_ \| | __|
//   ___) / __/  |_____| | (_) |__   _| |_) | | |_
//  |____/_____|          \___/   |_| |_.__/|_|\__|
test_butterfly_32_functest_butterfly_64_functest_solo_fft2_32test_parallel_fft2_32calc_sum// Calculate the sum of an expression consisting of just plus and minus, like `value = a + b - c + d`.
// The expression is rewritten to `value = a + (b - (c - d))` (note the flipped sign on d).
// After this the `$add` and `$sub` functions are used to make the calculation.
// For f32 using `_mm_add_ps` and `_mm_sub_ps`, the expression `value = a + b - c + d` becomes:
// ```let value = _mm_add_ps(a, _mm_sub_ps(b, _mm_sub_ps(c, d)));```
// Only plus and minus are supported, and all the terms must be plain scalar variables.
// Using array indices, like `value = temp[0] + temp[1]` is not supported.
calc_f32// Calculate the sum of an expression consisting of just plus and minus, like a + b - c + d
calc_f64// Helper function to assert we have the right float type
interleave_complex_f32// Shuffle elements to interleave two contiguous sets of f32, from an array of simd vectors to a new array of simd vectors
separate_interleaved_complex_f32// This statement:
// ```
// let values = separate_interleaved_complex_f32!(input, {0, 2, 4});
// is equivalent to:
// let values = [
//    extract_lo_lo_f32(input[0], input[1]),
//    extract_lo_lo_f32(input[2], input[3]),
//    extract_lo_lo_f32(input[4], input[5]),
//    extract_hi_hi_f32(input[0], input[1]),
//    extract_hi_hi_f32(input[2], input[3]),
//    extract_hi_hi_f32(input[4], input[5]),
// ];
boilerplate_fft_neon_ooptest_calc_f32test_calc_f64/* Not used now, but maybe later for the mixed radixes etc
macro_rules! boilerplate_sse_fft {
    ($struct_name:ident, $len_fn:expr, $inplace_scratch_len_fn:expr, $out_of_place_scratch_len_fn:expr) => {
        impl<T: FftNum> Fft<T> for $struct_name<T> {
            fn process_outofplace_with_scratch(
                &self,
                input: &mut [Complex<T>],
                output: &mut [Complex<T>],
                scratch: &mut [Complex<T>],
            ) {
                if self.len() == 0 {
                    return;
                }

                let required_scratch = self.get_outofplace_scratch_len();
                if scratch.len() < required_scratch
                    || input.len() < self.len()
                    || output.len() != input.len()
                {
                    // We want to trigger a panic, but we want to avoid doing it in this function to reduce code size, so call a function marked cold and inline(never) that will do it for us
                    fft_error_outofplace(
                        self.len(),
                        input.len(),
                        output.len(),
                        self.get_outofplace_scratch_len(),
                        scratch.len(),
                    );
                    return; // Unreachable, because fft_error_outofplace asserts, but it helps codegen to put it here
                }

                let scratch = &mut scratch[..required_scratch];
                let result = array_utils::iter_chunks_zipped(
                    input,
                    output,
                    self.len(),
                    |in_chunk, out_chunk| {
                        self.perform_fft_out_of_place(in_chunk, out_chunk, scratch)
                    },
                );

                if result.is_err() {
                    // We want to trigger a panic, because the buffer sizes weren't cleanly divisible by the FFT size,
                    // but we want to avoid doing it in this function to reduce code size, so call a function marked cold and inline(never) that will do it for us
                    fft_error_outofplace(
                        self.len(),
                        input.len(),
                        output.len(),
                        self.get_outofplace_scratch_len(),
                        scratch.len(),
                    );
                }
            }
            fn process_with_scratch(&self, buffer: &mut [Complex<T>], scratch: &mut [Complex<T>]) {
                if self.len() == 0 {
                    return;
                }

                let required_scratch = self.get_inplace_scratch_len();
                if scratch.len() < required_scratch || buffer.len() < self.len() {
                    // We want to trigger a panic, but we want to avoid doing it in this function to reduce code size, so call a function marked cold and inline(never) that will do it for us
                    fft_error_inplace(
                        self.len(),
                        buffer.len(),
                        self.get_inplace_scratch_len(),
                        scratch.len(),
                    );
                    return; // Unreachable, because fft_error_inplace asserts, but it helps codegen to put it here
                }

                let scratch = &mut scratch[..required_scratch];
                let result = array_utils::iter_chunks(buffer, self.len(), |chunk| {
                    self.perform_fft_inplace(chunk, scratch)
                });

                if result.is_err() {
                    // We want to trigger a panic, because the buffer sizes weren't cleanly divisible by the FFT size,
                    // but we want to avoid doing it in this function to reduce code size, so call a function marked cold and inline(never) that will do it for us
                    fft_error_inplace(
                        self.len(),
                        buffer.len(),
                        self.get_inplace_scratch_len(),
                        scratch.len(),
                    );
                }
            }
            #[inline(always)]
            fn get_inplace_scratch_len(&self) -> usize {
                $inplace_scratch_len_fn(self)
            }
            #[inline(always)]
            fn get_outofplace_scratch_len(&self) -> usize {
                $out_of_place_scratch_len_fn(self)
            }
        }
        impl<T: FftNum> Length for $struct_name<T> {
            #[inline(always)]
            fn len(&self) -> usize {
                $len_fn(self)
            }
        }
        impl<T: FftNum> Direction for $struct_name<T> {
            #[inline(always)]
            fn fft_direction(&self) -> FftDirection {
                self.direction
            }
        }
    };
}
*/MIN_RADIX4_BITSMAX_RADER_PRIME_FACTOR// smallest size to consider radix 4 an option is 2^6 = 64
MIN_BLUESTEIN_MIXED_RADIX_LEN// don't use Raders if the inner fft length has prime factor larger than this
Recipeleft_fftright_fftButterfly10Butterfly12Butterfly15// only use mixed radix for the inner fft of Bluestein if length is larger than this
/// A Recipe is a structure that describes the design of a FFT, without actually creating it.
/// It is used as a middle step in the planning process.
algorithm_cacherecipe_cache/// Returns `Ok(planner_instance)` if we're compiling for AArch64 and NEON support was enabled in feature flags.
/// Returns `Err(())` if NEON support is not available.
/// Returns a `Fft` instance which uses Neon instructions to compute forward FFTs of size `len`
design_fft_for_len// Make a recipe for a length
build_fft// Create the fft from a recipe, take from cache if possible
build_new_fft// Create a new fft from a recipe
design_fft_with_factorsdesign_mixed_radixdesign_butterfly_algorithm// Returns Some(instance) if we have a butterfly available for this size. Returns None if there is no butterfly available for this size
design_primeis_mixedradixis_mixedradixsmallis_goodthomassmallis_radersis_bluesteinstest_plan_neon_trivialtest_plan_neon_largepoweroftwotest_plan_neon_butterfliestest_plan_neon_mixedradixtest_plan_neon_mixedradixsmalltest_plan_neon_goodthomasbutterflytest_plan_neon_bluestein_vs_radertest_neon_fft_cachetest_neon_recipe_cachetwiddle3retwiddle3imNeonF32Butterfly7// Auto-generated prime length butterflies
// The code here is mostly autogenerated by the python script tools/gen_sse_butterflies.py, and then translated from SSE to Neon.
// The algorithm is derived directly from the definition of the DFT, by eliminating any repeated calculations.
// See the comments in src/algorithm/butterflies.rs for a detailed description.
// The script generates the code for performing a single f64 fft, as well as dual f32 fft.
// It also generates the code for reading and writing the input and output.
// The single 32-bit ffts reuse the dual ffts.
//   _____           _________  _     _ _
//  |___  |         |___ /___ \| |__ (_) |_
//     / /   _____    |_ \ __) | '_ \| | __|
//    / /   |_____|  ___) / __/| |_) | | |_
//   /_/            |____/_____|_.__/|_|\__|
NeonF64Butterfly7//   _____            __   _  _   _     _ _
//  |___  |          / /_ | || | | |__ (_) |_
//     / /   _____  | '_ \| || |_| '_ \| | __|
//    / /   |_____| | (_) |__   _| |_) | | |_
//   /_/             \___/   |_| |_.__/|_|\__|
twiddle4retwiddle4imtwiddle5retwiddle5imNeonF32Butterfly11//   _ _           _________  _     _ _
//  / / |         |___ /___ \| |__ (_) |_
//  | | |  _____    |_ \ __) | '_ \| | __|
//  | | | |_____|  ___) / __/| |_) | | |_
//  |_|_|         |____/_____|_.__/|_|\__|
NeonF64Butterfly11//   _ _            __   _  _   _     _ _
//  / / |          / /_ | || | | |__ (_) |_
//  | | |  _____  | '_ \| || |_| '_ \| | __|
//  | | | |_____| | (_) |__   _| |_) | | |_
//  |_|_|          \___/   |_| |_.__/|_|\__|
twiddle6retwiddle6imNeonF32Butterfly13//   _ _____           _________  _     _ _
//  / |___ /          |___ /___ \| |__ (_) |_
//  | | |_ \   _____    |_ \ __) | '_ \| | __|
NeonF64Butterfly13//   _ _____            __   _  _   _     _ _
//  / |___ /           / /_ | || | | |__ (_) |_
//  | | |_ \   _____  | '_ \| || |_| '_ \| | __|
twiddle7retwiddle7imtwiddle8retwiddle8imNeonF32Butterfly17//  / |___  |         |___ /___ \| |__ (_) |_
//  | |  / /   _____    |_ \ __) | '_ \| | __|
//  | | / /   |_____|  ___) / __/| |_) | | |_
//  |_|/_/            |____/_____|_.__/|_|\__|
NeonF64Butterfly17//  / |___  |          / /_ | || | | |__ (_) |_
//  | |  / /   _____  | '_ \| || |_| '_ \| | __|
//  | | / /   |_____| | (_) |__   _| |_) | | |_
//  |_|/_/             \___/   |_| |_.__/|_|\__|
twiddle9retwiddle9imNeonF32Butterfly19//  | | (_) |  _____    |_ \ __) | '_ \| | __|
//  | |\__, | |_____|  ___) / __/| |_) | | |_
//  |_|  /_/          |____/_____|_.__/|_|\__|
NeonF64Butterfly19//  | | (_) |  _____  | '_ \| || |_| '_ \| | __|
//  | |\__, | |_____| | (_) |__   _| |_) | | |_
//  |_|  /_/           \___/   |_| |_.__/|_|\__|
twiddle10retwiddle10imtwiddle11retwiddle11imNeonF32Butterfly23//   ____  _____           _________  _     _ _
//  |___ \|___ /          |___ /___ \| |__ (_) |_
//    __) | |_ \   _____    |_ \ __) | '_ \| | __|
//   / __/ ___) | |_____|  ___) / __/| |_) | | |_
//  |_____|____/          |____/_____|_.__/|_|\__|
NeonF64Butterfly23//   ____  _____            __   _  _   _     _ _
//  |___ \|___ /           / /_ | || | | |__ (_) |_
//    __) | |_ \   _____  | '_ \| || |_| '_ \| | __|
//   / __/ ___) | |_____| | (_) |__   _| |_) | | |_
//  |_____|____/           \___/   |_| |_.__/|_|\__|
twiddle13retwiddle13imtwiddle14retwiddle14imNeonF32Butterfly29//   ____   ___            _________  _     _ _
//  |___ \ / _ \          |___ /___ \| |__ (_) |_
//    __) | (_) |  _____    |_ \ __) | '_ \| | __|
//   / __/ \__, | |_____|  ___) / __/| |_) | | |_
//  |_____|  /_/          |____/_____|_.__/|_|\__|
NeonF64Butterfly29//   ____   ___             __   _  _   _     _ _
//  |___ \ / _ \           / /_ | || | | |__ (_) |_
//    __) | (_) |  _____  | '_ \| || |_| '_ \| | __|
//   / __/ \__, | |_____| | (_) |__   _| |_) | | |_
//  |_____|  /_/           \___/   |_| |_.__/|_|\__|
twiddle15retwiddle15imNeonF32Butterfly31//   _____ _           _________  _     _ _
//  |___ // |         |___ /___ \| |__ (_) |_
//    |_ \| |  _____    |_ \ __) | '_ \| | __|
//   ___) | | |_____|  ___) / __/| |_) | | |_
//  |____/|_|         |____/_____|_.__/|_|\__|
NeonF64Butterfly31//   _____ _            __   _  _   _     _ _
//  |___ // |          / /_ | || | | |__ (_) |_
//    |_ \| |  _____  | '_ \| || |_| '_ \| | __|
//   ___) | | |_____| | (_) |__   _| |_) | | |_
//  |____/|_|          \___/   |_| |_.__/|_|\__|
//   _____ _____ ____ _____ ____
//  |_   _| ____/ ___|_   _/ ___|
//    | | |  _| \___ \ | | \___ \
//    | | | |___ ___) || |  ___) |
//    |_| |_____|____/ |_| |____/
NeonArrayUSE_BUTTERFLY32_FROM/// FFT algorithm optimized for power-of-two sizes, Neon accelerated version.
/// This is designed to be used via a Planner, and not created directly.
Neon32ButterflyLen1Len2Len4Len8Len16Len32// Use length 32 butterfly starting from this length
Neon64ButterflyNeon32Radix4//#[target_feature(enable = "neon")]
butterfly_4_32Neon64Radix4butterfly_4_64test_neon_radix4_64test_neon_radix4_64_with_lengthtest_neon_radix4_32test_neon_radix4_32_with_lengthsign_hifloat32x2_t//sign_lo: float32x4_t,
sign_both//  __  __       _   _               _________  _     _ _
// |  \/  | __ _| |_| |__           |___ /___ \| |__ (_) |_
// | |\/| |/ _` | __| '_ \   _____    |_ \ __) | '_ \| | __|
// | |  | | (_| | |_| | | | |_____|  ___) / __/| |_) | | |_
// |_|  |_|\__,_|\__|_| |_|         |____/_____|_.__/|_|\__|
rotate_hirotate_both// There doesn't seem to be any need for rotating just the first element, but let's keep the code just in case
//#[inline(always)]
//pub unsafe fn rotate_lo(&self, values: __m128) -> __m128 {
//    let temp = _mm_shuffle_ps(values, values, 0xE1);
//    _mm_xor_ps(temp, self.sign_lo)
//}
extract_lo_lo_f32// Pack low (1st) complex
// left: r1.re, r1.im, r2.re, r2.im
// right: l1.re, l1.im, l2.re, l2.im
// --> r1.re, r1.im, l1.re, l1.im
extract_hi_hi_f32// Pack high (2nd) complex
// --> r2.re, r2.im, l2.re, l2.im
extract_lo_hi_f32// Pack low (1st) and high (2nd) complex
// --> r1.re, r1.im, l2.re, l2.im
extract_hi_lo_f32// Pack  high (2nd) and low (1st) complex
// --> r2.re, r2.im, l1.re, l1.im
reverse_complex_elements_f32// Reverse complex
// values: a.re, a.im, b.re, b.im
// --> b.re, b.im, a.re, a.im
reverse_complex_and_negate_hi_f32// Reverse complex and then negate hi complex
// --> b.re, b.im, -a.re, -a.im
duplicate_lo_f32// Invert sign of high (2nd) complex
// -->  a.re, a.im, -b.re, -b.im
//pub unsafe fn negate_hi_f32(values: float32x4_t) -> float32x4_t {
//    vcombine_f32(vget_low_f32(values), vneg_f32(vget_high_f32(values)))
// Duplicate low (1st) complex
// --> a.re, a.im, a.re, a.im
duplicate_hi_f32// Duplicate high (2nd) complex
// --> b.re, b.im, b.re, b.im
transpose_complex_2x2_f32// transpose a 2x2 complex matrix given as [x0, x1], [x2, x3]
// result is [x0, x2], [x1, x3]
mul_complex_f32// Complex multiplication.
// Each input contains two complex values, which are multiplied in parallel.
//  __  __       _   _                __   _  _   _     _ _
// |  \/  | __ _| |_| |__            / /_ | || | | |__ (_) |_
// | |\/| |/ _` | __| '_ \   _____  | '_ \| || |_| '_ \| | __|
// | |  | | (_| | |_| | | | |_____| | (_) |__   _| |_) | | |_
// |_|  |_|\__,_|\__|_| |_|          \___/   |_| |_.__/|_|\__|
mul_complex_f64test_mul_complex_f64test_mul_complex_f32test_packread_complex_to_array// Read these indexes from an NeonArray and build an array of simd vectors.
// Takes a name of a vector to read from, and a list of indexes to read.
// let values = read_complex_to_array!(input, {0, 1, 2, 3});
//     input.load_complex(0),
//     input.load_complex(1),
//     input.load_complex(2),
//     input.load_complex(3),
read_partial1_complex_to_array// Read these indexes from an NeonArray and build an array or partially filled simd vectors.
// let values = read_partial1_complex_to_array!(input, {0, 1, 2, 3});
//     input.load1_complex(0),
//     input.load1_complex(1),
//     input.load1_complex(2),
//     input.load1_complex(3),
write_complex_to_array// Write these indexes of an array of simd vectors to the same indexes of an NeonArray.
// Takes a name of a vector to read from, one to write to, and a list of indexes.
// let values = write_complex_to_array!(input, output, {0, 1, 2, 3});
//     output.store_complex(input[0], 0),
//     output.store_complex(input[1], 1),
//     output.store_complex(input[2], 2),
//     output.store_complex(input[3], 3),
write_partial_lo_complex_to_array// Write the low half of these indexes of an array of simd vectors to the same indexes of an NeonArray.
// let values = write_partial_lo_complex_to_array!(input, output, {0, 1, 2, 3});
//     output.store_partial_lo_complex(input[0], 0),
//     output.store_partial_lo_complex(input[1], 1),
//     output.store_partial_lo_complex(input[2], 2),
//     output.store_partial_lo_complex(input[3], 3),
write_complex_to_array_strided// Write these indexes of an array of simd vectors to the same indexes, multiplied by a stride, of an NeonArray.
// Takes a name of a vector to read from, one to write to, an integer stride, and a list of indexes.
// let values = write_complex_to_array_separate!(input, output, {0, 1, 2, 3});
//     output.store_complex(input[1], 2),
//     output.store_complex(input[2], 4),
//     output.store_complex(input[3], 6),
NeonNum// Load complex numbers from the array to fill a Neon vector.
// Load a single complex number from the array into a Neon vector, setting the unused elements to zero.
load1_complex// Load a single complex number from the array, and copy it to all elements of a Neon vector.
// A trait to handle reading from an array of complex floats into Neon vectors.
// Neon works with 128-bit vectors, meaning a vector can hold two complex f32,
// or a single complex f64.
// Store all complex numbers from a Neon vector to the array.
store_partial_lo_complex// Store the low complex number from a Neon vector to the array.
store_partial_hi_complex// Store the high complex number from a Neon vector to the array.
// A trait to handle writing to an array of complex floats from Neon vectors.
test_load_f64test_store_f64ChosenFftPlannerSseWasmSimd// todo: If we add NEON, avx-512 etc support, add more enum variants for them here
chosen_planner/// The FFT planner creates new FFT algorithm instances.
/// RustFFT has several FFT algorithms available. For a given FFT size, the `FftPlanner` decides which of the
/// use rustfft::{FftPlanner, num_complex::Complex};
/// let fft = planner.plan_fft_forward(1234);
/// let mut buffer = vec![Complex{ re: 0.0f32, im: 0.0f32 }; 1234];
/// // The FFT instance returned by the planner has the type `Arc<dyn Fft<T>>`,
/// // where T is the numeric type, ie f32 or f64, so it's cheap to clone
/// let fft_clone = Arc::clone(&fft);
/// In the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set.
/// If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.
/// If you'd prefer not to compute a FFT at all if a certain SIMD instruction set isn't available, or otherwise specify your own custom fallback, RustFFT exposes dedicated planners for each instruction set:
///  - [`FftPlannerAvx`](crate::FftPlannerAvx)
///  - [`FftPlannerSse`](crate::FftPlannerSse)
///  - [`FftPlannerNeon`](crate::FftPlannerNeon)
///  - [`FftPlannerWasmSimd`](crate::FftPlannerWasmSimd)
/// If you'd prefer to opt out of SIMD algorithms, consider creating a [`FftPlannerScalar`](crate::FftPlannerScalar) instead.
/// Creates a new `FftPlanner` instance.
/// Returns a `Fft` instance which computes FFTs of size `len`.
/// Returns a `Fft` instance which computes forward FFTs of size `len`
/// Returns a `Fft` instance which computes inverse FFTs of size `len`
MIN_RADIX3_FACTORS// smallest size to consider radix 4 an option is 2^5 = 32
// smallest number of factors of 3 to consider radix 4 an option is 3^4=81. any smaller and we want to use butterflies directly.
/// The Scalar FFT planner creates new FFT algorithm instances using non-SIMD algorithms.
/// RustFFT has several FFT algorithms available. For a given FFT size, the `FftPlannerScalar` decides which of the
/// Use `FftPlannerScalar` instead of [`FftPlanner`](crate::FftPlanner) or [`FftPlannerAvx`](crate::FftPlannerAvx) when you want to explicitly opt out of using any SIMD-accelerated algorithms.
/// use rustfft::{FftPlannerScalar, num_complex::Complex};
/// let mut planner = FftPlannerScalar::new();
/// Creates a new `FftPlannerScalar` instance.
test_plan_scalar_trivialtest_plan_scalar_largepoweroftwotest_plan_scalar_butterfliestest_plan_scalar_mixedradixtest_plan_scalar_mixedradixsmalltest_plan_scalar_goodthomasbutterflytest_plan_scalar_bluestein_vs_radertest_scalar_fft_cachetest_scalar_recipe_cachetest_plan_zero_scalartest_impl_fft_planner_send// This test is not designed to be run, only to compile.
// We cannot make it #[test] since there is a generic parameter.
sse_commonsse_vectorsse_butterfliessse_prime_butterfliessse_radix4sse_utilsSseArrayMutboilerplate_fft_sse_f32_butterflyboilerplate_fft_sse_f64_butterflyboilerplate_fft_sse_common_butterflySseF32Butterfly1perform_parallel_fft_butterflyperform_fft_butterfly_multiperform_oop_fft_butterfly_multiSseF64Butterfly1SseF32Butterfly2SseF64Butterfly2SseF32Butterfly3SseF64Butterfly3SseF32Butterfly4SseF64Butterfly4SseF32Butterfly5SseF64Butterfly5SseF32Butterfly6SseF64Butterfly6SseF32Butterfly8SseF64Butterfly8SseF32Butterfly9SseF64Butterfly9SseF32Butterfly10SseF64Butterfly10SseF32Butterfly12SseF64Butterfly12SseF32Butterfly15SseF64Butterfly15SseF32Butterfly16SseF64Butterfly16SseF32Butterfly32SseF64Butterfly32test_ssef32_butterfly1test_ssef32_butterfly2test_ssef32_butterfly3test_ssef32_butterfly4test_ssef32_butterfly5test_ssef32_butterfly6test_ssef32_butterfly8test_ssef32_butterfly9test_ssef32_butterfly10test_ssef32_butterfly12test_ssef32_butterfly15test_ssef32_butterfly16test_ssef32_butterfly32test_ssef64_butterfly1test_ssef64_butterfly2test_ssef64_butterfly3test_ssef64_butterfly4test_ssef64_butterfly5test_ssef64_butterfly6test_ssef64_butterfly8test_ssef64_butterfly9test_ssef64_butterfly10test_ssef64_butterfly12test_ssef64_butterfly15test_ssef64_butterfly16test_ssef64_butterfly32test_parallel_fft4_32boilerplate_fft_sse_oop/// The SSE FFT planner creates new FFT algorithm instances using a mix of scalar and SSE accelerated algorithms.
/// It requires at least SSE4.1, which is available on all reasonably recent x86_64 cpus.
/// RustFFT has several FFT algorithms available. For a given FFT size, the `FftPlannerSse` decides which of the
/// use rustfft::{FftPlannerSse, num_complex::Complex};
/// if let Ok(mut planner) = FftPlannerSse::new() {
/// Creates a new `FftPlannerSse` instance.
/// Returns `Ok(planner_instance)` if we're compiling for X86_64, SSE support was enabled in feature flags, and the current CPU supports the `sse4.1` CPU feature.
/// Returns `Err(())` if SSE support is not available.
/// Returns a `Fft` instance which uses SSE4.1 instructions to compute FFTs of size `len`.
/// Returns a `Fft` instance which uses SSE4.1 instructions to compute forward FFTs of size `len`
/// Returns a `Fft` instance which uses SSE4.1 instructions to compute inverse FFTs of size `len.
test_plan_sse_trivialtest_plan_sse_largepoweroftwotest_plan_sse_butterfliestest_plan_sse_mixedradixtest_plan_sse_mixedradixsmalltest_plan_sse_goodthomasbutterflytest_plan_sse_bluestein_vs_radertest_sse_fft_cachetest_sse_recipe_cacheSseF32Butterfly7// The code here is mostly autogenerated by the python script tools/gen_sse_butterflies.py
SseF64Butterfly7SseF32Butterfly11SseF64Butterfly11SseF32Butterfly13SseF64Butterfly13SseF32Butterfly17SseF64Butterfly17SseF32Butterfly19SseF64Butterfly19SseF32Butterfly23SseF64Butterfly23SseF32Butterfly29SseF64Butterfly29SseF32Butterfly31SseF64Butterfly31test_ssef32_butterfly7test_ssef32_butterfly11test_ssef32_butterfly13test_ssef32_butterfly17test_ssef32_butterfly19test_ssef32_butterfly23test_ssef32_butterfly29test_ssef32_butterfly31test_ssef64_butterfly7test_ssef64_butterfly11test_ssef64_butterfly13test_ssef64_butterfly17test_ssef64_butterfly19test_ssef64_butterfly23test_ssef64_butterfly29test_ssef64_butterfly31SseArray/// FFT algorithm optimized for power-of-two sizes, SSE accelerated version.
Sse32ButterflySse64ButterflySse32Radix4Sse64Radix4test_sse_radix4_64test_sse_radix4_64_with_lengthtest_sse_radix4_32test_sse_radix4_32_with_length//sign_lo: __m128,
negate_hi_f32// Read these indexes from an SseArray and build an array of simd vectors.
// Read these indexes from an SseArray and build an array or partially filled simd vectors.
// Write these indexes of an array of simd vectors to the same indexes of an SseArray.
// Write the low half of these indexes of an array of simd vectors to the same indexes of an SseArray.
// Write these indexes of an array of simd vectors to the same indexes, multiplied by a stride, of an SseArray.
SseNum// A trait to hold the BVectorType and COMPLEX_PER_VECTOR associated data
// Load complex numbers from the array to fill a SSE vector.
// Load a single complex number from the array into a SSE vector, setting the unused elements to zero.
// Load a single complex number from the array, and copy it to all elements of a SSE vector.
// A trait to handle reading from an array of complex floats into SSE vectors.
// SSE works with 128-bit vectors, meaning a vector can hold two complex f32,
// Store all complex numbers from a SSE vector to the array.
// Store the low complex number from a SSE vector to the array.
// Store the high complex number from a SSE vector to the array.
// A trait to handle writing to an array of complex floats from SSE vectors.
RNG_SEED/// The seed for the random number generator used to generate
/// random signals. It's defined here so that we have deterministic
/// tests
transppose_diagnosticinplace_scratchoutofplace_scratch// A fake FFT algorithm that requests much more scratch than it needs. You can use this as an inner FFT to other algorithms to test their scratch-supplying logic
StrengthReducedU128StrengthReducedU64fill_bluesteins_twiddlesrotate_90test_rotatewasm_simd_commonwasm_simd_vectorwasm_simd_butterflieswasm_simd_prime_butterflieswasm_simd_radix4wasm_simd_utilsWasmSimdArrayMutboilerplate_fft_wasm_simd_f32_butterflyboilerplate_fft_wasm_simd_f64_butterflyboilerplate_fft_wasm_simd_common_butterflyWasmSimdF32Butterfly1WasmSimdF64Butterfly1WasmSimdF32Butterfly2WasmSimdF64Butterfly2WasmSimdF32Butterfly3WasmSimdF64Butterfly3WasmSimdF32Butterfly4WasmSimdF64Butterfly4WasmSimdF32Butterfly5WasmSimdF64Butterfly5WasmSimdF32Butterfly6WasmSimdF64Butterfly6WasmSimdF32Butterfly8WasmSimdF64Butterfly8WasmSimdF32Butterfly9WasmSimdF64Butterfly9WasmSimdF32Butterfly10WasmSimdF64Butterfly10WasmSimdF32Butterfly12WasmSimdF64Butterfly12WasmSimdF32Butterfly15WasmSimdF64Butterfly15WasmSimdF32Butterfly16WasmSimdF64Butterfly16WasmSimdF32Butterfly32WasmSimdF64Butterfly32/// Calculate the sum of an expression consisting of just plus and minus, like `value = a + b - c + d`.
/// The expression is rewritten to `value = a + (b - (c - d))` (note the flipped sign on d).
/// After this the `$add` and `$sub` functions are used to make the calculation.
/// For f32 using `f32x4_add` and `f32x4_sub`, the expression `value = a + b - c + d` becomes:
/// let value = f32x4_add(a, f32x4_sub(b, f32x4_sub(c, d)));
/// Only plus and minus are supported, and all the terms must be plain scalar variables.
/// Using array indices, like `value = temp[0] + temp[1]` is not supported.
/// Calculate the sum of an expression consisting of just plus and minus, like a + b - c + d
/// Helper function to assert we have the right float type
/// Shuffle elements to interleave two contiguous sets of f32, from an array of simd vectors to a new array of simd vectors
/// This statement:
/// let values = separate_interleaved_complex_f32!(input, {0, 2, 4});
/// is equivalent to:
/// let values = [
///    extract_lo_lo_f32(input[0], input[1]),
///    extract_lo_lo_f32(input[2], input[3]),
///    extract_lo_lo_f32(input[4], input[5]),
///    extract_hi_hi_f32(input[0], input[1]),
///    extract_hi_hi_f32(input[2], input[3]),
///    extract_hi_hi_f32(input[4], input[5]),
/// ];
boilerplate_fft_wasm_simd_oop/// WASM SIMD is supported when using fairly recent browser versions as outlined in [the WebAssembly roadmap](https://webassembly.org/roadmap/).
/// Returns `Ok(planner_instance)` if we're compiling for the WASM target and WASM SIMD was enabled in feature flags.
/// Returns `Err(())` if WASM SIMD support is not available.
/// Returns Some(instance) if we have a butterfly available for this size. Returns None if there is no butterfly available for this size
/// Auto-generated prime length butterflies
/// The code here is mostly autogenerated by the python script tools/gen_sse_butterflies.py, and then translated from SSE to WASM SIMD.
/// The algorithm is derived directly from the definition of the DFT, by eliminating any repeated calculations.
/// See the comments in src/algorithm/butterflies.rs for a detailed description.
/// The script generates the code for performing a single f64 fft, as well as dual f32 fft.
/// It also generates the code for reading and writing the input and output.
/// The single 32-bit ffts reuse the dual ffts.
WasmSimdF32Butterfly7WasmSimdF64Butterfly7WasmSimdF32Butterfly11WasmSimdF64Butterfly11WasmSimdF32Butterfly13WasmSimdF64Butterfly13WasmSimdF32Butterfly17WasmSimdF64Butterfly17WasmSimdF32Butterfly19WasmSimdF64Butterfly19WasmSimdF32Butterfly23WasmSimdF64Butterfly23WasmSimdF32Butterfly29WasmSimdF64Butterfly29WasmSimdF32Butterfly31WasmSimdF64Butterfly31WasmSimdArray/// FFT algorithm optimized for power-of-two sizes, WasmSimd accelerated version.
WasmSimd32ButterflyWasmSimd64ButterflyWasmSimd32Radix4WasmSimd64Radix4test_wasm_simd_radix4_64test_wasm_simd_radix4_64_with_lengthtest_wasm_simd_radix4_32test_wasm_simd_radix4_32_with_length/// Utility functions to rotate complex numbers by 90 degrees
/// Pack low (1st) complex
/// left: l1.re, l1.im, l2.re, l2.im
/// right: r1.re, r1.im, r2.re, r2.im
/// --> l1.re, l1.im, r1.re, r1.im
/// Pack high (2nd) complex
/// --> l2.re, l2.im, r2.re, r2.im
/// Pack low (1st) and high (2nd) complex
/// --> l1.re, l1.im, r2.re, r2.im
/// Pack high (2nd) and low (1st) complex
/// left: r1.re, r1.im, r2.re, r2.im
/// right: l1.re, l1.im, l2.re, l2.im
/// --> r2.re, r2.im, l1.re, l1.im
/// Reverse complex
/// values: a.re, a.im, b.re, b.im
/// --> b.re, b.im, a.re, a.im
/// Reverse complex and then negate hi complex
/// --> b.re, b.im, -a.re, -a.im
/// Duplicate low (1st) complex
/// --> a.re, a.im, a.re, a.im
/// Duplicate high (2nd) complex
/// --> b.re, b.im, b.re, b.im
/// transpose a 2x2 complex matrix given as [x0, x1], [x2, x3]
/// result is [x0, x2], [x1, x3]
/// Complex multiplication.
/// Each input contains two complex values, which are multiplied in parallel.
/// Utility functions to rotate complex pointers by 90 degrees
test_positive_rotation_f32test_negative_rotation_f32test_negative_rotation_f64test_positive_rotation_f64test_reverse_complex_number_f32/// Read these indexes from an WasmSimdArray and build an array of simd vectors.
/// Takes a name of a vector to read from, and a list of indexes to read.
/// let values = read_complex_to_array!(input, {0, 1, 2, 3});
///     input.load_complex(0),
///     input.load_complex(1),
///     input.load_complex(2),
///     input.load_complex(3),
/// Read these indexes from an WasmSimdArray and build an array or partially filled simd vectors.
/// let values = read_partial1_complex_to_array!(input, {0, 1, 2, 3});
///     input.load1_complex(0),
///     input.load1_complex(1),
///     input.load1_complex(2),
///     input.load1_complex(3),
/// Write these indexes of an array of simd vectors to the same indexes of an WasmSimdArray.
/// Takes a name of a vector to read from, one to write to, and a list of indexes.
/// let values = write_complex_to_array!(input, output, {0, 1, 2, 3});
///     output.store_complex(input[0], 0),
///     output.store_complex(input[1], 1),
///     output.store_complex(input[2], 2),
///     output.store_complex(input[3], 3),
/// Write the low half of these indexes of an array of simd vectors to the same indexes of an WasmSimdArray.
/// let values = write_partial_lo_complex_to_array!(input, output, {0, 1, 2, 3});
///     output.store_partial_lo_complex(input[0], 0),
///     output.store_partial_lo_complex(input[1], 1),
///     output.store_partial_lo_complex(input[2], 2),
///     output.store_partial_lo_complex(input[3], 3),
/// Write these indexes of an array of simd vectors to the same indexes, multiplied by a stride, of an WasmSimdArray.
/// Takes a name of a vector to read from, one to write to, an integer stride, and a list of indexes.
/// let values = write_complex_to_array_separate!(input, output, {0, 1, 2, 3});
///     output.store_complex(input[1], 2),
///     output.store_complex(input[2], 4),
///     output.store_complex(input[3], 6),
WasmSimdNum/// Load complex numbers from the array to fill a WASM SIMD vector.
/// Load a single complex number from the array into a WASM SIMD vector, setting the unused elements to zero.
/// Load a single complex number from the array, and copy it to all elements of a WASM SIMD vector.
/// A trait to handle reading from an array of complex floats into WASM SIMD vectors.
/// WASM works with 128-bit vectors, meaning a vector can hold two complex f32,
/// or a single complex f64.
/// Store all complex numbers from a WASM SIMD vector to the array.
/// Store the low complex number from a WASM SIMD vector to the array.
/// Store the high complex number from a WASM SIMD vector to the array.
/// A trait to handle writing to an array of complex floats from WASM SIMD vectors.
/// Read an entire slice as a big-endian value./// Returns the value as `u64`. This function checks for integer overflows, and returns a/// `Result::Err` value if the value is too big.be_var_u64/// Read the entire slice as a big endian unsigned integer, up to 8 bytesle_var_u64/// Read the entire slice as a little endian unsigned integer, up to 8 bytesparse_hex_to_u64/// Read a slice as a big-endian value.upgrade_error/// Apply combinator, automatically converts between errors if the underlying type supports it/// Create a combinator that returns the provided value, and input unchangedflat_take/// Return a closure that takes `len` bytes from input, and applies `parser`.flat_takec/// Take `len` bytes from `input`, and apply `parser`.cond_else/// Helper macro for nom parsers: run first parser if condition is true, else second parseralign_n2/// Align input value to the next multiple of n bytes/// Valid only if n is a power of 2align32/// Align input value to the next multiple of 4 bytestest_be_var_u64test_flat_taketest_flat_take_strtest_cond_elsetest_align32dbg_dmp_rest/// Dump the remaining bytes to stderr, formatted as hexHexU8/// Wrapper for printing value as u8 hex dataHexU16/// Wrapper for printing value as u16 hex data/// Wrapper for printing slice as hex datadebug_print_hexu8debug_print_hexu16debug_print_hexslice//! Helper functions and structures for debugging purpose// re-exports//! # Rusticata-macros//! Helper macros for the [rusticata](https://github.com/rusticata) project.//! This crate contains some additions to [nom](https://github.com/Geal/nom).//! For example, the [`combinator::cond_else`] function allows to apply the first parser if the//! condition is true, and the second if the condition is false://! # use nom::IResult;//! # use nom::combinator::map;//! # use nom::number::streaming::*;//! use rusticata_macros::combinator::cond_else;//! # fn parser(s:&[u8]) {//! let r: IResult<_, _, ()> = cond_else(//!         || s.len() > 1,//!         be_u16,//!         map(be_u8, u16::from)//!     )(s);//! See the documentation for more details and examples.// entry// entry with display// entry with display and debug/// Helper macro for newtypes: declare associated constants and implement Display trait/// Helper macro for nom parsers: raise error if the condition is true/// This macro is used when using custom errorserror_if/// This macro is used when using `ErrorKind`/// Helper macro for nom parsers: raise error if input is not empty/// Deprecated - use `nom::eof`parse_uint24/// Read 3 bytes as an unsigned integer/// Combination and flat_map! and take! as first combinator/// Apply combinator, trying to "upgrade" error to next error type (using the `Into` or `From`/// traits).upgrade_error_to/// Nom combinator that returns the given expression unchangedtest_error_iftest_newtype_enumtest_q//! Helper macros//named!(parse_hex4<&[u8], u64>, parse_hex_to_u64!(4));/// Type of serialization error/// Try to serialize object/// Common trait for structures serialization//! Common traitsOUTLINE_PATH/// The directory for out-of-line (“outline”) libraries.link_in_librustix_outline/// Link in the desired version of librustix_outline_{arch}.a, containing the/// outline assembly code for making syscalls.use_thumb_mode/// `PROC_SUPER_MAGIC`—The magic number for the procfs filesystem./// `NFS_SUPER_MAGIC`—The magic number for the NFS filesystem.LibcFdlibc_off_tc_strno_fdborrowed_fdowned_fdsyscall_retnonnegative_retret_infallibleret_c_intret_u32ret_usizesyscall_ret_usizesyscall_ret_u32ret_off_tret_pid_tret_owned_fd/// Convert a `c_int` returned from a libc function to an `OwnedFd`, if valid./// The caller must ensure that this is the return value of a libc function/// which returns an owned file descriptor.ret_discarded_fdret_discarded_char_ptrsyscall_ret_owned_fd/// Convert a `c_long` returned from `syscall` to an `OwnedFd`, if valid./// The caller must ensure that this is the return value of a `syscall` callsend_recv_len/// Convert the buffer-length argument value of a `send` or `recv` call.ret_send_recv/// Convert the return value of a `send` or `recv` call.msg_iov_len/// Convert the value to the `msg_iovlen` field of a `msghdr` struct.msg_control_len/// Convert the value to a `socklen_t`./// Convert the value to a `size_t`.//! Libc call arguments and return values are often things like `c_int`,//! `c_uint`, or libc-specific pointer types. This module provides functions//! for converting between rustix's types and libc types.libc_ino_tStatStatVfslibc_readdirlibc_dir/// The `libc` `DIR` pointer.any_errors/// Have we seen any errors in this iteration?/// `DIR*`/// Construct a `Dir` that reads entries from the given directory/// file descriptor._read_from/// `rewinddir(self)`/// `readdir(self)`, where `None` means the end of the directory./// `fstat(self)`/// `fstatfs(self)`/// `fstatvfs(self)`/// `fchdir(self)`/// `Dir` implements `Send` but not `Sync`, because we use `readdir` which is/// not guaranteed to be thread-safe. Users can wrap this in a `Mutex` if they/// need `Sync`, which is effectively what'd need to do to implement `Sync`/// ourselves.d_fileno/// `struct dirent`/// Returns the file name of this directory entry./// Returns the type of this directory entry./// Return the inode number of this directory entry.d_namlen__d_paddinglibc_dirent/// libc's OpenBSD `dirent` has a private field so we can't construct it/// directly, so we declare it ourselves to make all fields accessible.check_dirent_layout/// We have our own copy of OpenBSD's dirent; check that the layout/// minimally matches libc's.dir_iterator_handles_io_errorsCreateFlags/// `inotify_init1(flags)`—Creates a new inotify object./// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file/// descriptor from being implicitly passed across `exec` boundaries.WatchFlags/// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify/// This registers or updates a watch for the filesystem path `path`/// and returns a watch descriptor corresponding to this watch./// Note: Due to the existence of hardlinks, providing two/// different paths to this method may result in it returning/// the same watch descriptor. An application should keep track of this/// externally to avoid logic errors.inotify_remove_watch/// `inotify_rm_watch(self, wd)`—Removes a watch from this inotify/// The watch descriptor provided should have previously been returned/// by [`inotify_add_watch`] and not previously have been removed.//! inotify support for working with inotifiessyscallslibc_fallocatelibc_posix_fadviselibc_posix_fallocatelibc_fstatlibc_fstatatlibc_ftruncatelibc_lseeklibc_fstatfslibc_statfslibc_fstatvfslibc_statvfsLibcTimespecFlockOperationMemfdFlagsSealFlagsStatVfsMountFlagsCopyfileFlagsResolveFlagsStatxStatxFlagslibc_openatXattrFlagsopenat_via_syscall/// Use a direct syscall (via libc) for `openat`./// This is only currently necessary as a workaround for old glibc; see below.getdents_uninit/// At present, `libc` only has `renameat2` defined for glibc. On other/// ABIs, `RenameFlags` has no flags defined, and we use plain `renameat`.statatstatat_oldaccessatutimensat_oldchmodatchownatfadvisefcntl_get_sealsfcntl_add_sealsfcntl_lockfstat_oldlibc_statvfs_to_statvfsfutimens_oldSYS_OPENAT2oflagSIZEOF_OPEN_HOWstatx_to_stat/// Convert from a Linux `statx` value to rustix's `Stat`./// mips64' `struct stat64` in libc has private fields, and `stx_blocks`stat64_to_stat/// Convert from a Linux `stat64` value to rustix's `Stat`./// mips64' `struct stat64` in libc has private fields, and `st_blocks` has/// type `i64`.weak_or_syscallis_statx_availablecopyfile_state_get_copiedgetpathfcntl_rdadvisefcntl_fullfsynctimes_to_attrlistAttrlist/// Convert `times` from a `futimens`/`utimensat` argument into `setattrlist`/// arguments.Attrgroup/// Support type for `Attrlist`.bitmapcountcommonattrvolattrdirattrfileattrforkattr/// Attribute list for use with `setattrlist`.MountFlagsArgUnmountFlags//! libc syscalls supporting `rustix::fs`.from_raw_modeRawMode/// Construct a `Mode` from the mode bits of the `st_mode` field of a/// `Stat`.as_raw_mode/// Construct an `st_mode` value from `Stat`./// Support conversions from raw mode values to `Mode`./// use rustix::fs::{Mode, RawMode};/// assert_eq!(Mode::from(0o700), Mode::RWXU);/// Support conversions from `Mode to raw mode values./// assert_eq!(RawMode::from(Mode::RWXU), 0o700);ACLSTATXATTR/// `S_IFREG`/// `S_IFDIR`/// `S_IFLNK`/// `S_IFIFO`// TODO: Use WASI's `S_IFIFO`./// `S_IFSOCK`// TODO: Use WASI's `S_IFSOCK`./// `S_IFCHR`/// `S_IFBLK`/// An unknown filesystem object./// `S_IF*` constants for use with [`mknodat`] and [`Stat`]'s `st_mode` field./// [`mknodat`]: crate::fs::mknodat/// [`Stat`]: crate::fs::Stat/// Construct a `FileType` from the `S_IFMT` bits of the `st_mode` field of/// a `Stat`.from_dirent_d_type/// Construct a `FileType` from the `d_type` field of a `c::dirent`./// `POSIX_FADV_NORMAL`/// `POSIX_FADV_SEQUENTIAL`/// `POSIX_FADV_RANDOM`NoReuse/// `POSIX_FADV_NOREUSE`/// `POSIX_FADV_WILLNEED`/// `POSIX_FADV_DONTNEED`/// `POSIX_FADV_*` constants for use with [`fadvise`]./// [`fadvise`]: crate::fs::fadvise/// `LOCK_SH`/// `LOCK_EX`/// `LOCK_UN`NonBlockingLockShared/// `LOCK_SH | LOCK_NB`NonBlockingLockExclusive/// `LOCK_EX | LOCK_NB`NonBlockingUnlock/// `LOCK_UN | LOCK_NB`/// `LOCK_*` constants for use with [`flock`] and [`fcntl_lock`]./// [`flock`]: crate::fs::flock/// [`fcntl_lock`]: crate::fs::fcntl_lock/// `struct stat` for use with [`statat`] and [`fstat`]./// [`statat`]: crate::fs::statat/// [`fstat`]: crate::fs::fstat// On 32-bit, Linux's `struct stat64` has a 32-bit `st_mtime` and friends, so// we use our own struct, populated from `statx` where possible, to avoid the// y2038 bug./// `struct statfs` for use with [`statfs`] and [`fstatfs`]./// [`statfs`]: crate::fs::statfs/// [`fstatfs`]: crate::fs::fstatfs/// `struct statvfs` for use with [`statvfs`] and [`fstatvfs`]./// [`statvfs`]: crate::fs::statvfs/// [`fstatvfs`]: crate::fs::fstatvfs/// `struct statx` for use with [`statx`]./// [`statx`]: crate::fs::statx// Use the glibc `struct statx`.StatxTimestamp/// `struct statx_timestamp` for use with [`Statx`].// Use the glibc `struct statx_timestamp`.__statx_pad2// Non-glibc ABIs don't currently declare a `struct statx`, so we declare it// ourselves.// Non-glibc ABIs don't currently declare a `struct statx_timestamp`, so we// declare it ourselves./// `mode_t`/// `dev_t`FsWord/// `__fsword_t`// s390x uses `u32` for `statfs` entries, even though `__fsword_t` is `u64`./// `copyfile_state_t`—State for use with [`fcopyfile`]./// [`fcopyfile`]: crate::fs::fcopyfile/// `epoll_create1(flags)`—Creates a new `Epoll`.epoll_add/// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an/// `Epoll`./// If `epoll_del` is not called on the I/O source passed into this function/// before the I/O source is `close`d, then the `epoll` will act as if the I/O/// source is still registered with it. This can lead to spurious events being/// returned from `epoll_wait`. If a file descriptor is an/// `Arc<dyn SystemResource>`, then `epoll` can be thought to maintain a/// `Weak<dyn SystemResource>` to the file descriptor.epoll_mod/// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in/// this `Epoll`./// This sets the events of interest with `target` to `events`.epoll_del/// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in/// `epoll_wait(self, events, timeout)`—Waits for registered events of/// interest./// For each event of interest, an element is written to `events`. On/// success, this returns the number of written elements./// An iterator over the `Event`s in an `EventVec`.event_flags// Match the layout of `c::epoll_event`. We just use a `u64` instead of// the full union./// A record of an event that occurred./// A vector of `Event`s, plus context for interpreting them./// Constructs an `EventVec` with memory for `capacity` `Event`s./// Returns the current `Event` capacity of this `EventVec`./// Reserves enough memory for at least `additional` more `Event`s./// Reserves enough memory for exactly `additional` more `Event`s./// Clears all the `Events` out of this `EventVec`./// Shrinks the capacity of this `EventVec` as much as possible./// Returns an iterator over the `Event`s in this `EventVec`./// Returns the number of `Event`s logically contained in this `EventVec`./// Tests whether this `EventVec` is logically empty.//! epoll support.//! This is an experiment, and it isn't yet clear whether epoll is the right//! level of abstraction at which to introduce safety. But it works fairly well//! in simple examples 🙂.//! # #![cfg_attr(io_lifetimes_use_std, feature(io_safety))]//! # #[cfg(feature = "net")]//! use io_lifetimes::AsFd;//! use rustix::io::{epoll, ioctl_fionbio, read, write};//! use rustix::net::{//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, Protocol, SocketAddrV4,//!     SocketType,//! use std::os::unix::io::AsRawFd;//! // Create a socket and listen on it.//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;//! bind_v4(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?;//! listen(&listen_sock, 1)?;//! // Create an epoll object. Using `Owning` here means the epoll object will//! // take ownership of the file descriptors registered with it.//! let epoll = epoll::epoll_create(epoll::CreateFlags::CLOEXEC)?;//! // Register the socket with the epoll object.//! epoll::epoll_add(&epoll, &listen_sock, 1, epoll::EventFlags::IN)?;//! // Keep track of the sockets we've opened.//! let mut next_id = 2;//! let mut sockets = HashMap::new();//! // Process events.//! let mut event_list = epoll::EventVec::with_capacity(4);//!     epoll::epoll_wait(&epoll, &mut event_list, -1)?;//!     for (_event_flags, target) in &event_list {//!         if target == 1 {//!             // Accept a new connection, set it to non-blocking, and//!             // register to be notified when it's ready to write to.//!             let conn_sock = accept(&listen_sock)?;//!             ioctl_fionbio(&conn_sock, true)?;//!             epoll::epoll_add(//!                 &epoll,//!                 &conn_sock,//!                 next_id,//!                 epoll::EventFlags::OUT | epoll::EventFlags::ET,//!             )?;//!             // Keep track of the socket.//!             sockets.insert(next_id, conn_sock);//!             next_id += 1;//!             // Write a message to the stream and then unregister it.//!             let target = sockets.remove(&target).unwrap();//!             write(&target, b"hello\n")?;//!             let _ = epoll::epoll_del(&epoll, &target)?;//! # #[cfg(not(feature = "net"))]/// The error type for `rustix` APIs./// This is similar to `std::io::Error`, but only holds an OS error code,/// and no extra error value./// `EACCES`ADDRINUSE/// `EADDRINUSE`ADDRNOTAVAIL/// `EADDRNOTAVAIL`/// `EADV`AFNOSUPPORT/// `EAFNOSUPPORT`AGAIN/// `EAGAIN`ALREADY/// `EALREADY`AUTH/// `EAUTH`BADE/// `EBADE`BADF/// `EBADF`BADFD/// `EBADFD`BADMSG/// `EBADMSG`BADR/// `EBADR`BADRPC/// `EBADRPC`BADRQC/// `EBADRQC`BADSLT/// `EBADSLT`BFONT/// `EBFONT`BUSY/// `EBUSY`CANCELED/// `ECANCELED`CAPMODE/// `ECAPMODE`CHILD/// `ECHILD`CHRNG/// `ECHRNG`COMM/// `ECOMM`CONNABORTED/// `ECONNABORTED`CONNREFUSED/// `ECONNREFUSED`CONNRESET/// `ECONNRESET`DEADLK/// `EDEADLK`DEADLOCK/// `EDEADLOCK`DESTADDRREQ/// `EDESTADDRREQ`DISCON/// `EDISCON`/// `EDOM`DOOFUS/// `EDOOFUS`DOTDOT/// `EDOTDOT`DQUOT/// `EDQUOT`EXIST/// `EEXIST`FAULT/// `EFAULT`FBIG/// `EFBIG`FTYPE/// `EFTYPE`HOSTDOWN/// `EHOSTDOWN`HOSTUNREACH/// `EHOSTUNREACH`HWPOISON/// `EHWPOISON`IDRM/// `EIDRM`ILSEQ/// `EILSEQ`INPROGRESS/// `EINPROGRESS`INTR/// `EINTR`/// For a convenient way to retry system calls that exit with `INTR`, use/// [`retry_on_intr`]./// [`retry_on_intr`]: crate::io::retry_on_intrINVAL/// `EINVAL`INVALIDPROCTABLE/// `EINVALIDPROCTABLE`INVALIDPROVIDER/// `EINVALIDPROVIDER`/// `EIO`ISCONN/// `EISCONN`/// `EISDIR`ISNAM/// `EISNAM`KEYEXPIRED/// `EKEYEXPIRED`KEYREJECTED/// `EKEYREJECTED`KEYREVOKED/// `EKEYREVOKED`L2HLT/// `EL2HLT`L2NSYNC/// `EL2NSYNC`L3HLT/// `EL3HLT`L3RST/// `EL3RST`LIBACC/// `ELIBACC`LIBBAD/// `ELIBBAD`LIBEXEC/// `ELIBEXEC`LIBMAX/// `ELIBMAX`LIBSCN/// `ELIBSCN`LNRNG/// `ELNRNG`LOOP/// `ELOOP`MEDIUMTYPE/// `EMEDIUMTYPE`MFILE/// `EMFILE`MLINK/// `EMLINK`MSGSIZE/// `EMSGSIZE`MULTIHOP/// `EMULTIHOP`NAMETOOLONG/// `ENAMETOOLONG`NAVAIL/// `ENAVAIL`NEEDAUTH/// `ENEEDAUTH`NETDOWN/// `ENETDOWN`NETRESET/// `ENETRESET`NETUNREACH/// `ENETUNREACH`NFILE/// `ENFILE`NOANO/// `ENOANO`/// `ENOATTR`NOBUFS/// `ENOBUFS`NOCSI/// `ENOCSI`NODATA/// `ENODATA`NODEV/// `ENODEV`NOENT/// `ENOENT`NOEXEC/// `ENOEXEC`NOKEY/// `ENOKEY`NOLCK/// `ENOLCK`NOLINK/// `ENOLINK`NOMEDIUM/// `ENOMEDIUM`NOMEM/// `ENOMEM`NOMORE/// `ENOMORE`NOMSG/// `ENOMSG`NONET/// `ENONET`NOPKG/// `ENOPKG`NOPROTOOPT/// `ENOPROTOOPT`NOSPC/// `ENOSPC`NOSR/// `ENOSR`/// `ENOSTR`NOSYS/// `ENOSYS`NOTBLK/// `ENOTBLK`NOTCAPABLE/// `ENOTCAPABLE`NOTCONN/// `ENOTCONN`NOTDIR/// `ENOTDIR`NOTEMPTY/// `ENOTEMPTY`NOTNAM/// `ENOTNAM`NOTRECOVERABLE/// `ENOTRECOVERABLE`NOTSOCK/// `ENOTSOCK`NOTSUP/// `ENOTSUP`NOTTY/// `ENOTTY`NOTUNIQ/// `ENOTUNIQ`NXIO/// `ENXIO`OPNOTSUPP/// `EOPNOTSUPP`OVERFLOW/// `EOVERFLOW`OWNERDEAD/// `EOWNERDEAD`PERM/// `EPERM`PFNOSUPPORT/// `EPFNOSUPPORT`/// `EPIPE`PROCLIM/// `EPROCLIM`PROCUNAVAIL/// `EPROCUNAVAIL`PROGMISMATCH/// `EPROGMISMATCH`PROGUNAVAIL/// `EPROGUNAVAIL`PROTO/// `EPROTO`PROTONOSUPPORT/// `EPROTONOSUPPORT`PROTOTYPE/// `EPROTOTYPE`PROVIDERFAILEDINIT/// `EPROVIDERFAILEDINIT`/// `ERANGE`REFUSED/// `EREFUSED`REMCHG/// `EREMCHG`REMOTE/// `EREMOTE`REMOTEIO/// `EREMOTEIO`RESTART/// `ERESTART`RFKILL/// `ERFKILL`ROFS/// `EROFS`RPCMISMATCH/// `ERPCMISMATCH`SHUTDOWN/// `ESHUTDOWN`SOCKTNOSUPPORT/// `ESOCKTNOSUPPORT`SPIPE/// `ESPIPE`SRCH/// `ESRCH`SRMNT/// `ESRMNT`STALE/// `ESTALE`STRPIPE/// `ESTRPIPE`/// `ETIME`TIMEDOUT/// `ETIMEDOUT`TOOBIG/// `E2BIG`TOOMANYREFS/// `ETOOMANYREFS`TXTBSY/// `ETXTBSY`UCLEAN/// `EUCLEAN`UNATCH/// `EUNATCH`USERS/// `EUSERS`WOULDBLOCK/// `EWOULDBLOCK`XDEV/// `EXDEV`XFULL/// `EXFULL`from_io_error/// Extract an `Errno` value from a `std::io::Error`./// This isn't a `From` conversion because it's expected to be relatively/// uncommon./// Extract the raw OS error number from this error.from_raw_os_error/// Construct an `Errno` from a raw OS error number.//! The `rustix` `Errno` type.//! This type holds an OS error code, which conceptually corresponds to an//! `errno` value.//! The following is derived from Rust's//! library/std/src/sys/unix/io.rs//! dca3f1b786efd27be3b325ed1e01e247aa589c3b.io_slicepoll_fd/// `struct pollfd`—File descriptor and flags for use with [`poll`]./// [`poll`]: crate::io::poll/// Constructs a new `PollFd` holding `fd` and `events`.set_fd/// Sets the contained file descriptor to `fd`.clear_revents/// Clears the ready events./// This is the same as `new`, but can be used to avoid borrowing the/// `BorrowedFd`, which can be tricky in situations where the `BorrowedFd`/// is a temporary./// Returns the ready events.libc_preadlibc_pwritelibc_preadvlibc_pwritevlibc_preadv2libc_pwritev2DupFlagsIoSliceRawReadWriteFlagsSpliceFlagsoptional_as_mut_ptr/// At present, `libc` only has `preadv2` defined for glibc. On other/// ABIs, use `c::syscall`./// At present, `libc` only has `pwritev2` defined for glibc. On otherREAD_LIMIT// The maximum read limit on most POSIX-like systems is `SSIZE_MAX`, with the// manual page quoting that if the count of bytes to read is greater than// `SSIZE_MAX` the result is “unspecified”.// On macOS, however, apparently the 64-bit libc is either buggy or// intentionally showing odd behavior by rejecting any read with a size larger// than or equal to `INT_MAX`. To handle both of these the read size is capped// on both platforms.max_iovioctl_blksszgetioctl_blkpbszgetioctl_fionreadioctl_fionbioioctl_ficlone// Sparc lacks `FICLONE`.ext4_ioc_resize_fsis_read_writefcntl_dupfd_cloexecioctl_fioclexioctl_tiocexclioctl_tiocnxcl//! libc syscalls supporting `rustix::io`.// These functions are derived from Rust's library/std/src/sys/unix/fd.rs at// revision 326ef470a8b379a180d6dc4bbef08990698a737a./// `PIPE_BUF`—The maximum size of a write to a pipe guaranteed to be atomic._lifetime/// A buffer type used with `vmsplice`./// It is guaranteed to be ABI compatible with the iovec type on Unix platforms/// and `WSABUF` on Windows. Unlike `IoSlice` and `IoSliceMut` it is/// semantically like a raw pointer, and therefore can be shared or mutated as/// Creates a new `IoSlice` wrapping a byte slice./// Creates a new `IoSlice` wrapping a mutable byte slice.//! Windows system calls in the `io` module.// Re-export the `Socket` traits so that users can implement them./// A version of [`as_raw_fd`] for use with Winsock2 API./// [`as_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.as_raw_fd/// A version of [`AsRawFd`] for use with Winsock2 API./// [`AsRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsRawFd.html/// A version of [`into_raw_fd`] for use with Winsock2 API./// [`into_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.into_raw_fd/// A version of [`IntoRawFd`] for use with Winsock2 API./// [`IntoRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.IntoRawFd.html/// A version of [`from_raw_fd`] for use with Winsock2 API./// See the [safety requirements] for [`from_raw_fd`]./// [safety requirements]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#safety/// A version of [`FromRawFd`] for use with Winsock2 API./// [`FromRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html/// An `as_fd` function for Winsock2, where a `Fd` is a `Socket`./// A version of [`AsFd`] for use with Winsock2 API./// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsFd.html//! `io_lifetimes` types for Windows assuming that Fd is Socket.//! We can make this assumption since `rustix` supports only `rustix::net` onio_uringIoringEnterFlagsIoringRegisterOpio_uring_setupio_uring_registerio_uring_enter//! libc syscalls supporting `rustix::io_uring`.libc_mmapMremapFlagsMprotectFlagsMsyncFlagsMlockFlagsUserfaultfdFlags/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working/// with memory pointed to by raw pointers is unsafe./// `mremap` is primarily unsafe due to the `old_address` parameter, as/// anything working with memory pointed to by raw pointers is unsafe.mremap_fixed/// `mremap_fixed` is primarily unsafe due to the `old_address` and/// `new_address` parameters, as anything working with memory pointed to by raw/// pointers is unsafe./// `mlock` operates on raw pointers and may round out to the nearest pagemlock_with/// `mlock_with` operates on raw pointers and may round out to the nearest page/// `munlock` operates on raw pointers and may round out to the nearest pageuserfaultfd//! libc syscalls supporting `rustix::mm`./// `POSIX_MADV_NORMAL`/// `POSIX_MADV_SEQUENTIAL`/// `POSIX_MADV_RANDOM`/// `POSIX_MADV_WILLNEED`/// `POSIX_MADV_DONTNEED`LinuxDontNeed/// `MADV_DONTNEED`// `MADV_DONTNEED` has the same value as `POSIX_MADV_DONTNEED`. We don't// have a separate `posix_madvise` from `madvise`, so we expose a special// value which we special-case.LinuxFree/// `MADV_FREE`LinuxRemove/// `MADV_REMOVE`LinuxDontFork/// `MADV_DONTFORK`LinuxDoFork/// `MADV_DOFORK`LinuxHwPoison/// `MADV_HWPOISON`LinuxSoftOffline/// `MADV_SOFT_OFFLINE`LinuxMergeable/// `MADV_MERGEABLE`LinuxUnmergeable/// `MADV_UNMERGEABLE`LinuxHugepage/// `MADV_HUGEPAGE` (since Linux 2.6.38)LinuxNoHugepage/// `MADV_NOHUGEPAGE` (since Linux 2.6.38)LinuxDontDump/// `MADV_DONTDUMP` (since Linux 3.4)LinuxDoDump/// `MADV_DODUMP` (since Linux 3.4)LinuxWipeOnFork/// `MADV_WIPEONFORK` (since Linux 4.14)LinuxKeepOnFork/// `MADV_KEEPONFORK` (since Linux 4.14)LinuxCold/// `MADV_COLD` (since Linux 5.4)LinuxPageOut/// `MADV_PAGEOUT` (since Linux 5.4)LinuxPopulateRead/// `MADV_POPULATE_READ` (since Linux 5.14)LinuxPopulateWrite/// `MADV_POPULATE_WRITE` (since Linux 5.14)LinuxDontneedLocked/// `MADV_DONTNEED_LOCKED` (since Linux 5.18)/// `POSIX_MADV_*` constants for use with [`madvise`]./// [`madvise`]: crate::mm::madvise// On Windows we emulate selected libc-compatible interfaces. On non-Windows,// we just use libc here, since this is the libc backend.if_glibc_is_less_than_2_25/// If the host libc is glibc, return `true` if it is less than version 2.25./// To restate and clarify, this function returning true does not mean the libc/// is glibc just that if it is glibc, it is less than version 2.25./// For now, this function is only available on Linux, but if it ends up being/// used beyond that, this could be changed to e.g. `#[cfg(unix)]`.//! The libc backend.//! On most platforms, this uses the `libc` crate to make system calls. On//! Windows, this uses the Winsock2 API in `windows-sys`, which can be adapted//! to have a very `libc`-like interface.// Every FFI call requires an unsafe block, and there are a lot of FFI// calls. For now, set this to allow for the libc backend.// Lots of libc types vary between platforms, so we often need a `.into()` on// one platform where it's redundant on another./// `struct sockaddr_un`/// Construct a new Unix-domain address from a filesystem path.new_abstract_name/// Construct a new abstract Unix-domain address from a byte slice./// For a filesystem path address, return the path.abstract_name/// For an abstract address, return the identifier.SocketAddrStorage/// `struct sockaddr_storage` as a raw struct.offsetof_sun_path/// Return the offset of the `sun_path` field of `sockaddr_un`.//! Socket address utilities./// The windows `sockaddr_in6` type is a union with accessor functions which/// are not `const fn`. Define our own layout-compatible version so that we/// can transmute in and out of it.in_addr_s_addr// TODO: With Rust 1.55, we can use the above `in_addr_s_addr` definition that// uses a const-fn transmute.in_addr_new// TODO: With Rust 1.55, we can use the above `in_addr_new` definition thatin6_addr_s6_addr// TODO: With Rust 1.55, we can use the above `in6_addr_s6_addr` definition// that uses a const-fn transmute.in6_addr_new// TODO: With Rust 1.55, we can use the above `in6_addr_new` definition thatsockaddr_in6_sin6_scope_id// TODO: With Rust 1.55, we can use the above `sockaddr_in6_sin6_scope_id`// definition that uses a const-fn transmute.sockaddr_in6_new// TODO: With Rust 1.55, we can use the above `sockaddr_in6_new` definitionread_sockaddrsend_recvwrite_sockaddrencode_sockaddr_v4encode_sockaddr_v6RecvAncillaryBufferSendAncillaryBufferwith_recv_msghdr/// Create a message header intended to receive a datagram.with_noaddr_msghdr/// Create a message header intended to send without an address.with_v4_msghdr/// Create a message header intended to send with an IPv4 address.with_v6_msghdr/// Create a message header intended to send with an IPv6 address.with_unix_msghdr/// Create a message header intended to send with a Unix address.//! Utilities for dealing with message headers.//! These take closures rather than returning a `c::msghdr` directly because//! the message headers may reference stack-local data.sa_lensockaddr_header// This must match the header of `sockaddr`.read_ss_familyinitialize_family_to_unspec/// Set the `ss_family` field of a socket address to `AF_UNSPEC`, so that we/// can test for `AF_UNSPEC` to test whether it was stored to.maybe_read_sockaddr_osread_sockaddr_osinner_read_sockaddr_osRecvMsgReturnRecvFlagsSendFlagsSocketFlagssendto_v4sendto_v6sendto_unixsocket_withbind_v4bind_v6bind_unixconnect_v4connect_v6connect_unixsendmsg_noaddrsendmsg_v4sendmsg_v6sendmsg_unixacceptfromacceptfrom_with/// Darwin lacks `accept4`, but does have `accept`. We define/// `SocketFlags` to have no flags, so we can discard it here.DURATION_ZERO// TODO: With Rust 1.53 we can use `Duration::ZERO` instead.get_socket_typeset_socket_reuseaddrset_socket_broadcastget_socket_broadcastset_socket_lingerget_socket_lingerset_socket_passcredget_socket_passcredset_socket_timeoutget_socket_timeoutgetsockopt_nosigpipesetsockopt_nosigpipeget_socket_errorset_socket_keepaliveget_socket_keepaliveset_socket_recv_buffer_sizeget_socket_recv_buffer_sizeset_socket_send_buffer_sizeget_socket_send_buffer_sizeset_ip_ttlget_ip_ttlset_ipv6_v6onlyget_ipv6_v6onlyset_ip_multicast_loopget_ip_multicast_loopset_ip_multicast_ttlget_ip_multicast_ttlset_ipv6_multicast_loopget_ipv6_multicast_loopset_ipv6_multicast_hopsget_ipv6_multicast_hopsset_ip_add_membershipset_ipv6_add_membershipset_ip_drop_membershipset_ipv6_drop_membershipget_ipv6_unicast_hopsset_ipv6_unicast_hopsset_tcp_nodelayget_tcp_nodelayto_imrto_imr_addrto_ipv6mrto_ipv6mr_multiaddrto_ipv6mr_interfaceRawSocketBool// `getsockopt` and `setsockopt` represent boolean values as integers.SocketBool// Wrap `RawSocketBool` in a newtype to discourage misuse.from_bool// Convert from a `bool` to a `SocketBool`.// Convert from a `SocketBool` to a `bool`.//! libc syscalls supporting `rustix::net`.RawSocketType/// A type for holding raw integer socket types./// `SOCK_*` constants for use with [`socket`]./// [`socket`]: crate::net::socket/// `SOCK_STREAM`DGRAM/// `SOCK_DGRAM`SEQPACKET/// `SOCK_SEQPACKET`/// `SOCK_RAW`RDM/// `SOCK_RDM`/// Constructs a `SocketType` from a raw integer./// Returns the raw integer for this `SocketType`.RawAddressFamily/// A type for holding raw integer address families./// `AF_*` constants.UNSPEC/// `AF_UNSPEC`INET/// `AF_INET`INET6/// `AF_INET6`NETLINK/// `AF_NETLINK`UNIX/// `AF_UNIX`, aka `AF_LOCAL`AX25/// `AF_AX25`IPX/// `AF_IPX`APPLETALK/// `AF_APPLETALK`NETROM/// `AF_NETROM`BRIDGE/// `AF_BRIDGE`ATMPVC/// `AF_ATMPVC`/// `AF_X25`ROSE/// `AF_ROSE`DECnet/// `AF_DECnet`NETBEUI/// `AF_NETBEUI`/// `AF_SECURITY`/// `AF_KEY`PACKET/// `AF_PACKET`ASH/// `AF_ASH`ECONET/// `AF_ECONET`ATMSVC/// `AF_ATMSVC`RDS/// `AF_RDS`SNA/// `AF_SNA`IRDA/// `AF_IRDA`PPPOX/// `AF_PPPOX`WANPIPE/// `AF_WANPIPE`LLC/// `AF_LLC`CAN/// `AF_CAN`TIPC/// `AF_TIPC`BLUETOOTH/// `AF_BLUETOOTH`IUCV/// `AF_IUCV`RXRPC/// `AF_RXRPC`ISDN/// `AF_ISDN`PHONET/// `AF_PHONET`IEEE802154/// `AF_IEEE802154`/// Constructs a `AddressFamily` from a raw integer./// Returns the raw integer for this `AddressFamily`.RawProtocol/// A type for holding raw integer protocols./// `IPPROTO_*` constants for use with [`socket`] and [`socket_with`]./// [`socket_with`]: crate::net::socket_with/// `IPPROTO_IP`ICMP/// `IPPROTO_ICMP`IGMP/// `IPPROTO_IGMP`IPIP/// `IPPROTO_IPIP`TCP/// `IPPROTO_TCP`EGP/// `IPPROTO_EGP`PUP/// `IPPROTO_PUP`UDP/// `IPPROTO_UDP`IDP/// `IPPROTO_IDP`/// `IPPROTO_TP`DCCP/// `IPPROTO_DCCP`IPV6/// `IPPROTO_IPV6`RSVP/// `IPPROTO_RSVP`GRE/// `IPPROTO_GRE`/// `IPPROTO_ESP`/// `IPPROTO_AH`MTP/// `IPPROTO_MTP`BEETPH/// `IPPROTO_BEETPH`ENCAP/// `IPPROTO_ENCAP`PIM/// `IPPROTO_PIM`COMP/// `IPPROTO_COMP`SCTP/// `IPPROTO_SCTP`UDPLITE/// `IPPROTO_UDPLITE`MPLS/// `IPPROTO_MPLS`/// `IPPROTO_RAW`MPTCP/// `IPPROTO_MPTCP`FRAGMENT/// `IPPROTO_FRAGMENT`ICMPV6/// `IPPROTO_ICMPV6`MH/// `IPPROTO_MH`ROUTING/// `IPPROTO_ROUTING`/// Constructs a `Protocol` from a raw integer./// Returns the raw integer for this `Protocol`./// `SHUT_RD`—Disable further read operations./// `SHUT_WR`—Disable further write operations./// `SHUT_RDWR`—Disable further read and write operations./// `SHUT_*` constants for use with [`shutdown`]./// [`shutdown`]: crate::net::shutdown/// `SO_RCVTIMEO`—Timeout for receiving./// `SO_SNDTIMEO`—Timeout for sending./// Timeout identifier for use with [`set_socket_timeout`] and/// [`get_socket_timeout`]./// [`set_socket_timeout`]: crate::net::sockopt::set_socket_timeout./// [`get_socket_timeout`]: crate::net::sockopt::get_socket_timeout.write_sockaddr_v4write_sockaddr_v6write_sockaddr_unix//! The BSD sockets API requires us to read the `ss_family` field before//! we can interpret the rest of a `sockaddr` produced by the kernel.libc_rlimitLIBC_RLIM_INFINITYlibc_getrlimitlibc_setrlimit// `prlimit64` wasn't supported in glibc until 2.13.libc_prlimitreadwrite_pv64weakcallreadwrite_pv// macOS added preadv and pwritev in version 11.0readwrite_pv64v2// glibc added `preadv64v2` and `pwritev64v2` in version 2.26.//! Automatically enable “large file” support features.// `getauxval` wasn't supported in glibc until 2.16.clock_ticks_per_secondlinux_hwcaplinux_execfnRawCpuSet//! Rust implementation of the `CPU_*` macro API.SysinfoWaitIdWaitidOptionsWaitidStatusPidfdFlagsCpuidMembarrierCommandMembarrierQueryRlimitRawUnameRawNonZeroPidRawPidWaitOptionsmembarrier_querymembarriermembarrier_cpugetpriority_usergetpriority_pgrpgetpriority_processsetpriority_usersetpriority_pgrpsetpriority_processrlimit_from_libc/// Convert a Rust [`Rlimit`] to a C `libc_rlimit`.rlimit_to_libc/// Convert a C `libc_rlimit` to a Rust `Rlimit`._waitpid_waitid_all_waitid_pid_waitid_pidfdcvt_waitid_status/// Convert a `siginfo_t` to a `WaitidStatus`./// The caller must ensure that `status` is initialized and that `waitid`/// returned successfully.exit_groupkill_processkill_process_groupkill_current_process_grouptest_kill_processtest_kill_process_grouptest_kill_current_process_grouppidfd_openioctl_tiocsctty//! libc syscalls supporting `rustix::process`./// `sysinfo`/// `MEMBARRIER_CMD_GLOBAL`GlobalExpedited/// `MEMBARRIER_CMD_GLOBAL_EXPEDITED`RegisterGlobalExpedited/// `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED`PrivateExpedited/// `MEMBARRIER_CMD_PRIVATE_EXPEDITED`RegisterPrivateExpedited/// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED`PrivateExpeditedSyncCore/// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE`RegisterPrivateExpeditedSyncCore/// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE`PrivateExpeditedRseq/// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)RegisterPrivateExpeditedRseq/// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)/// A command for use with [`membarrier`] and [`membarrier_cpu`]./// For `MEMBARRIER_CMD_QUERY`, see [`membarrier_query`]./// [`membarrier`]: crate::process::membarrier/// [`membarrier_cpu`]: crate::process::membarrier_cpu/// [`membarrier_query`]: crate::process::membarrier_query/// `RLIMIT_CPU`Fsize/// `RLIMIT_FSIZE`/// `RLIMIT_DATA`/// `RLIMIT_STACK`/// `RLIMIT_CORE`Rss/// `RLIMIT_RSS`Nproc/// `RLIMIT_NPROC`Nofile/// `RLIMIT_NOFILE`Memlock/// `RLIMIT_MEMLOCK`/// `RLIMIT_AS`Locks/// `RLIMIT_LOCKS`Sigpending/// `RLIMIT_SIGPENDING`Msgqueue/// `RLIMIT_MSGQUEUE`Nice/// `RLIMIT_NICE`Rtprio/// `RLIMIT_RTPRIO`Rttime/// `RLIMIT_RTTIME`/// A resource value for use with [`getrlimit`], [`setrlimit`], and/// [`prlimit`]./// [`getrlimit`]: crate::process::getrlimit/// [`setrlimit`]: crate::process::setrlimit/// [`prlimit`]: crate::process::prlimit/// `SIGHUP`/// `SIGINT`/// `SIGQUIT`/// `SIGILL`/// `SIGTRAP`/// `SIGABRT`, aka `SIGIOT`/// `SIGBUS`/// `SIGFPE`/// `SIGKILL`/// `SIGUSR1`/// `SIGSEGV`/// `SIGUSR2`/// `SIGPIPE`/// `SIGALRM`/// `SIGTERM`Stkflt/// `SIGSTKFLT`/// `SIGCHLD`/// `SIGCONT`/// `SIGSTOP`/// `SIGTSTP`/// `SIGTTIN`/// `SIGTTOU`/// `SIGURG`/// `SIGXCPU`/// `SIGXFSZ`/// `SIGVTALRM`/// `SIGPROF`/// `SIGWINCH`/// `SIGIO`, aka `SIGPOLL`/// `SIGPWR`/// `SIGSYS`, aka `SIGUNUSED`Emt/// `SIGEMT`/// `SIGINFO`Thr/// `SIGTHR`Librt/// `SIGLIBRT`/// A signal number for use with [`kill_process`], [`kill_process_group`],/// and [`kill_current_process_group`]./// [`kill_process`]: crate::process::kill_process/// [`kill_process_group`]: crate::process::kill_process_group/// [`kill_current_process_group`]: crate::process::kill_current_process_group/// Convert a raw signal number into a `Signal`, if possible.EXIT_SIGNALED_SIGABRT/// A process identifier as a raw integer./// A non-zero process identifier as a raw non-zero integer.RawGid/// A group identifier as a raw integer.RawUid/// A user identifier as a raw integer.RawCpuid/// A CPU identifier as a raw integer.RawIdraw_cpu_set_newOpenptFlagsSMALL_PATH_BUFFER_SIZEopenptioctl_tiocgptpeer//! libc syscalls supporting `rustix::pty`.GetRandomFlags//! libc syscalls supporting `rustix::rand`.OptionalActionsQueueSelectorSpeedtcgetattr2Termios2tcsetattr2tcsetwinsizetcgetwinsize//! libc syscalls supporting `rustix::termios`.//! # Safety//! See the `rustix::backend::syscalls` module documentation for details./// `TCSANOW`—Make the change immediately./// `TCSADRAIN`—Make the change after all output has been transmitted./// `TCSAFLUSH`—Discard any pending input and then make the change/// after all output has been transmitted./// `TCSA*` values for use with [`tcsetattr`]./// [`tcsetattr`]: crate::termios::tcsetattrIFlush/// `TCIFLUSH`—Flush data received but not read.OFlush/// `TCOFLUSH`—Flush data written but not transmitted.IOFlush/// `TCIOFLUSH`—`IFlush` and `OFlush` combined./// `TC*` values for use with [`tcflush`]./// [`tcflush`]: crate::termios::tcflushOOff/// `TCOOFF`—Suspend output.OOn/// `TCOON`—Restart suspended output.IOff/// `TCIOFF`—Transmits a STOP byte.IOn/// `TCION`—Transmits a START byte./// `TC*` values for use with [`tcflow`]./// [`tcflow`]: crate::termios::tcflow/// `struct termios` for use with [`tcgetattr`] and [`tcsetattr`]./// [`tcgetattr`]: crate::termios::tcgetattr/// `struct termios2` for use with [`tcgetattr2`] and [`tcsetattr2`]./// [`tcgetattr2`]: crate::termios::tcgetattr2/// [`tcsetattr2`]: crate::termios::tcsetattr2/// `struct winsize` for use with [`tcgetwinsize`]./// [`tcgetwinsize`]: crate::termios::tcgetwinsizeTcflag/// `tcflag_t`—A type for the flags fields of [`Termios`]./// `speed_t`—A return type for [`cfsetspeed`] and similar./// [`cfsetspeed`]: crate::termios::cfsetspeed/// `VINTR`/// `VQUIT`/// `VERASE`/// `VKILL`/// `VEOF`/// `VTIME`/// `VMIN`/// `VSWTC`/// `VSTART`/// `VSTOP`/// `VSUSP`/// `VEOL`/// `VREPRINT`/// `VDISCARD`/// `VWERASE`/// `VLNEXT`/// `VEOL2`/// `IGNBRK`/// `BRKINT`/// `IGNPAR`/// `PARMRK`/// `INPCK`/// `ISTRIP`/// `INLCR`/// `IGNCR`/// `ICRNL`/// `IUCLC`/// `IXON`/// `IXANY`/// `IXOFF`/// `IMAXBEL`/// `IUTF8`/// `OPOST`/// `OLCUC`/// `ONLCR`/// `OCRNL`/// `ONOCR`/// `ONLRET`/// `OFILL`/// `OFDEL`/// `NLDLY`/// `NL0`/// `NL1`/// `CRDLY`/// `CR0`/// `CR1`/// `CR2`/// `CR3`/// `TABDLY`/// `TAB0`/// `TAB1`/// `TAB2`/// `TAB3`/// `BSDLY`/// `BS0`/// `BS1`/// `FFDLY`/// `FF0`/// `FF1`/// `VTDLY`/// `VT0`/// `VT1`/// `B0`/// `B50`/// `B75`/// `B110`/// `B134`/// `B150`/// `B200`/// `B300`/// `B600`/// `B1200`/// `B1800`/// `B2400`/// `B4800`/// `B9600`/// `B19200`/// `B38400`/// `B57600`/// `B115200`/// `B230400`/// `B460800`/// `B500000`/// `B576000`/// `B921600`/// `B1000000`/// `B1152000`/// `B1500000`/// `B2000000`/// `B2500000`/// `B3000000`/// `B3500000`/// `B4000000`/// `BOTHER`/// `CSIZE`/// `CS5`/// `CS6`/// `CS7`/// `CS8`/// `CSTOPB`/// `CREAD`/// `PARENB`/// `PARODD`/// `HUPCL`/// `CLOCAL`/// `ISIG`/// `ICANON`—A flag for the `c_lflag` field of [`Termios`] indicating/// canonical mode./// `ECHO`/// `ECHOE`/// `ECHOK`/// `ECHONL`/// `NOFLSH`/// `TOSTOP`/// `IEXTEN`/// `EXTA`/// `EXTB`/// `CBAUD`/// `CBAUDEX`/// `CIBAUD`// glibc on powerpc lacks a definition for `CIBAUD`, even though the Linux// headers and Musl on powerpc both have one. So define it manually./// `CMSPAR`/// `CRTSCTS`/// `XCASE`/// `ECHOCTL`/// `ECHOPRT`/// `ECHOKE`/// `FLUSHO`/// `PENDIN`/// `EXTPROC`/// `XTABS`NanosleepRelativeResultclock_nanosleep_relativeclock_nanosleep_relative_oldclock_nanosleep_absoluteclock_nanosleep_absolute_oldnanosleep_oldUnshareFlagscapgetcapsetsetuid_threadsetresuid_threadsetgid_threadsetresgid_thread//! libc syscalls supporting `rustix::thread`.LibcItimerspecDynamicClockIdclock_getres_oldclock_gettime_oldclock_gettime_dynamicclock_gettime_dynamic_oldclock_settime_oldtimerfd_settime_oldtimerfd_gettime_old//! libc syscalls supporting `rustix::time`./// `struct timespec`/// Seconds.Nsecs/// Nanoseconds. Must be less than 1_000_000_000./// A type for the `tv_sec` field of [`Timespec`]./// A type for the `tv_nsec` field of [`Timespec`]./// On most platforms, `LibcTimespec` is just `Timespec`./// On 32-bit glibc platforms, `timespec` has anonymous padding fields, which/// Rust doesn't support yet (see `unnamed_fields`), so we define our own/// struct with explicit padding, with bidirectional `From` impls./// `CLOCK_REALTIME`/// `CLOCK_MONOTONIC`Uptime/// `CLOCK_UPTIME`ProcessCPUTime/// `CLOCK_PROCESS_CPUTIME_ID`ThreadCPUTime/// `CLOCK_THREAD_CPUTIME_ID`RealtimeCoarse/// `CLOCK_REALTIME_COARSE`MonotonicCoarse/// `CLOCK_MONOTONIC_COARSE`MonotonicRaw/// `CLOCK_MONOTONIC_RAW`/// `CLOCK_*` constants for use with [`clock_gettime`]./// These constants are always supported at runtime, so `clock_gettime` never/// has to fail with `INVAL` due to an unsupported clock. See/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not/// all of them are always supported./// [`clock_gettime`]: crate::time::clock_gettime/// `ClockId` values that are always supported at runtime./// Linux dynamic clocks.RealtimeAlarm/// `CLOCK_REALTIME_ALARM`, available on Linux >= 3.0Tai/// `CLOCK_TAI`, available on Linux >= 3.10Boottime/// `CLOCK_BOOTTIME`, available on Linux >= 2.6.39BoottimeAlarm/// `CLOCK_BOOTTIME_ALARM`, available on Linux >= 2.6.39/// `CLOCK_*` constants for use with [`clock_gettime_dynamic`]./// These constants may be unsupported at runtime, depending on the OS version,/// and `clock_gettime_dynamic` may fail with `INVAL`. See [`ClockId`] for/// clocks which are always supported at runtime./// [`clock_gettime_dynamic`]: crate::time::clock_gettime_dynamic/// `struct itimerspec` for use with [`timerfd_gettime`] and/// [`timerfd_settime`]./// [`timerfd_gettime`]: crate::time::timerfd_gettime/// [`timerfd_settime`]: crate::time::timerfd_settime/// On most platforms, `LibcItimerspec` is just `Itimerspec`./// On 32-bit glibc platforms, `LibcTimespec` differs from `Timespec`, so we/// define our own struct, with bidirectional `From` impls./// `CLOCK_REALTIME`—A clock that tells the “real” time./// This is a clock that tells the amount of time elapsed since the/// Unix epoch, 1970-01-01T00:00:00Z. The clock is externally settable, so/// it is not monotonic. Successive reads may see decreasing times, so it/// isn't reliable for measuring durations./// `CLOCK_MONOTONIC`—A clock that tells an abstract time./// Unlike `Realtime`, this clock is not based on a fixed known epoch, so/// individual times aren't meaningful. However, since it isn't settable,/// it is reliable for measuring durations./// This clock does not advance while the system is suspended; see/// `Boottime` for a clock that does./// `CLOCK_BOOTTIME`—Like `Monotonic`, but advances while suspended./// This clock is similar to `Monotonic`, but does advance while the system/// is suspended./// `CLOCK_REALTIME_ALARM`—Like `Realtime`, but wakes a suspended system./// This clock is like `Realtime`, but can wake up a suspended system./// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability./// `CLOCK_BOOTTIME_ALARM`—Like `Boottime`, but wakes a suspended system./// This clock is like `Boottime`, but can wake up a suspended system./// `CLOCK_*` constants for use with [`timerfd_create`]./// [`timerfd_create`]: crate::time::timerfd_create// Define the basic C types. With Rust 1.64, we can use these from `core::ffi`.// windows-sys declares these constants as u16. For better compatibility// with Unix-family APIs, redeclare them as u32.ADDRESS_FAMILYADDRINFOAIPV6_MREQIP_MREQLINGERSD_BOTHSD_RECEIVESD_SENDSOCKADDR_STORAGEWSAEACCESWSAEADDRINUSEWSAEADDRNOTAVAILWSAEAFNOSUPPORTWSAEALREADYWSAEBADFWSAECONNABORTEDWSAECONNREFUSEDWSAECONNRESETWSAEDESTADDRREQWSAEDISCONEDISCONWSAEDQUOTWSAEFAULTWSAEHOSTDOWNWSAEHOSTUNREACHWSAEINPROGRESSWSAEINTRWSAEINVALIDPROCTABLEEINVALIDPROCTABLEWSAEINVALIDPROVIDEREINVALIDPROVIDERWSAEISCONNWSAELOOPWSAEMFILEWSAEMSGSIZEWSAENAMETOOLONGWSAENETDOWNWSAENETRESETWSAENETUNREACHWSAENOBUFSWSAENOMOREENOMOREWSAENOPROTOOPTWSAENOTCONNWSAENOTEMPTYWSAEOPNOTSUPPWSAEPFNOSUPPORTWSAEPROCLIMWSAEPROTONOSUPPORTWSAEPROVIDERFAILEDINITEPROVIDERFAILEDINITWSAEREFUSEDEREFUSEDWSAEREMOTEWSAESHUTDOWNWSAESOCKTNOSUPPORTWSAESTALEWSAETIMEDOUTWSAETOOMANYREFSWSAEUSERSWSAEWOULDBLOCKWSA_E_CANCELLED// Include the contents of `WinSock`, renaming as needed to match POSIX.// Use `WSA_E_CANCELLED` for `ECANCELED` instead of `WSAECANCELLED`, because// `WSAECANCELLED` will be removed in the future.// <https://docs.microsoft.com/en-us/windows/win32/api/ws2spi/nc-ws2spi-lpnsplookupserviceend#remarks>//! Adapt the Winsock2 API to resemble a POSIX-style libc API.ArgRegFromAsmRetRegSyscallNumberToAsmsyscall0_readonlysyscall1syscall1_readonlysyscall1_noreturnsyscall2syscall2_readonlysyscall3syscall3_readonlysyscall4syscall4_readonlysyscall5syscall5_readonlysyscall6syscall6_readonly//! aarch64 Linux system calls.//! arm Linux system calls.syscall7_readonly//! mipsel Linux system calls.//! On mipsel, Linux indicates success or failure using `$a3` rather//! than by returning a negative error code as most other architectures do.//! Mips-family platforms have a special calling convention for `__NR_pipe`,//! however we use `__NR_pipe2` instead to avoid having to implement it.//! mips64el Linux system calls.//! On mips64el, Linux indicates success or failure using `$a3` (`$7`) rather//! Inline asm for making system calls.//! Compilers should really have intrinsics for making system calls. They're//! much like regular calls, with custom calling conventions, and calling//! conventions are otherwise the compiler's job. But for now, use inline asm.//! The calling conventions for Linux syscalls are [documented here].//! [documented here]: https://man7.org/linux/man-pages/man2/syscall.2.html//! powerpc64le Linux system calls.//! On powerpc64le, Linux indicates success or failure using `cr0.SO` rather//! than by returning a negative error code as most other architectures do. In//! theory we could immediately translate this into a `Result`, and it'd save a//! few branches. And in theory we could have specialized sequences for use//! with syscalls that are known to never fail. However, those would require//! more extensive changes in rustix's platform-independent code. For now, we//! check the flag and negate the error value to make PowerPC64 look like other//! architectures.//! riscv64 Linux system calls.//! arm Linux system calls, using thumb-mode.//! In thumb-mode, r7 is the frame pointer and is not permitted to be used in//! an inline asm operand, so we have to use a different register and copy it//! into r7 inside the inline asm.vdso_wrappersSyscallTypeindirect_syscall0indirect_syscall1indirect_syscall1_noreturnindirect_syscall2indirect_syscall3indirect_syscall4indirect_syscall5indirect_syscall6//! 32-bit x86 Linux system calls.//! There are two forms; `indirect_*` which take a callee, which allow calling//! through the vDSO when possible, and plain forms, which use the `int 0x80`//! instruction.//! Most `rustix` syscalls use the vsyscall mechanism rather than going using//! `int 0x80` sequences, as vsyscall is much faster.//! Syscalls made with `int 0x80` preserve the flags register, while syscalls//! made using vsyscall do not.//! x86-64 Linux system calls.// When inline asm is available, use it. Otherwise, use out-of-line asm. These// functions always use the machine's syscall instruction, even when it isn't// the fastest option available.// On most architectures, the architecture syscall instruction is fast, so use// it directly.// Macros for invoking system calls.// These factor out://  - Calling `nr` on the syscall number to convert it into `SyscallNumber`.//  - Calling `.into()` on each of the arguments to convert them into `ArgReg`.//  - Qualifying the `syscall*` and `__NR_*` identifiers.//  - Counting the number of arguments.syscall_readonly/// Like `syscall`, but adds the `readonly` attribute to the inline asm, which/// indicates that the syscall does not mutate any memory.//! Architecture-specific syscall code.//! `rustix` has inline assembly sequences using `asm!`, but that requires//! Rust 1.59, so it also has out-of-line ("outline") assembly sequences in .s//! files. And 32-bit x86 is special (see comments below).//! This module also has a `choose` submodule which chooses a scheme and is//! what most of the `rustix` syscalls use.//! This contains the inline `asm` statements performing the syscall//! instructions and FFI declarations declaring the out-of-line ("outline")//! syscall instructions.// We'll use as many arguments as syscalls need.// This would be the code for always using `int 0x80` on 32-bit x86.//#[cfg(target_arch = "x86")]//pub(in crate::backend) use self::asm as choose;nr_last// For these architectures, pass the `nr` argument last.//! Declare functions defined in out-of-line ("outline") asm files.//! Kernel calling conventions differ from userspace calling conventions, so we//! also define inline function wrappers which reorder the arguments so that//! they match with the kernel convention as closely as possible, to minimize//! the amount of out-of-line code we need.//! This is needed in order to support our MSRV of 1.48, which doesn't support//! inline asm. When using newer Rust versions, inline asm code is used instead//! and these outline libraries are unused.rustix_syscall0_nr_lastrustix_syscall1_nr_lastrustix_syscall1_noreturn_nr_lastrustix_syscall2_nr_lastrustix_syscall3_nr_lastrustix_syscall4_nr_lastrustix_syscall5_nr_lastrustix_syscall6_nr_lastrustix_syscall7_nr_lastsyscall0syscall7// Then we define the `_readonly` versions of the wrappers. We don't have// separate `_readonly` implementations, so these can just be aliases to// their non-`_readonly` counterparts.//! Syscall wrappers for platforms which pass the syscall number specially.//! Rustix aims to minimize the amount of assembly code it needs. To that end,//! this code reorders syscall arguments as close as feasible to the actual//! syscall convention before calling the assembly functions.//! Many architectures use a convention where the syscall number is passed in a//! special register, with the regular syscall arguments passed in either the//! same or similar registers as the platform C convention. This code//! approximates that order by passing the regular syscall arguments first, and//! the syscall number last. That way, the outline assembly code typically just//! needs to move the syscall number to its special register, and leave the//! other arguments mostly as they are.// First we declare the actual assembly routines with `*_nr_last` names and// reordered arguments. If the signatures or calling conventions are ever// changed, the symbol names should also be updated accordingly, to avoid// collisions with other versions of this crate.// We don't define `_readonly` versions of these because we have no way to tell// Rust that calls to our outline assembly are readonly.// Then we define inline wrapper functions that do the reordering."fastcall"rustix_syscall0_nr_last_fastcallrustix_syscall1_nr_last_fastcallrustix_syscall1_noreturn_nr_last_fastcallrustix_syscall2_nr_last_fastcallrustix_syscall3_nr_last_fastcallrustix_syscall4_nr_last_fastcallrustix_syscall5_nr_last_fastcallrustix_syscall6_nr_last_fastcallrustix_indirect_syscall0_nr_last_fastcallrustix_indirect_syscall1_nr_last_fastcallrustix_indirect_syscall1_noreturn_nr_last_fastcallrustix_indirect_syscall2_nr_last_fastcallrustix_indirect_syscall3_nr_last_fastcallrustix_indirect_syscall4_nr_last_fastcallrustix_indirect_syscall5_nr_last_fastcallrustix_indirect_syscall6_nr_last_fastcall//! Syscall wrappers for 32-bit x86.//! This module is similar to the `nr_last` module, except specialized for//! 32-bit x86.//! The syscall convention passes all arguments in registers. The closest we//! can easily get to that from Rust is to use the fastcall convention which//! passes the first two arguments in `ecx` and `edx`, which are the second//! and third Linux syscall arguments. To line them up, this function passes//! the second and third syscall argument as the first and second argument to//! the outline assembly, followed by the first syscall argument, and then the//! rest of the syscall arguments. The assembly code still has to do some work,//! but at least we can get up to two arguments into the right place for it.// First we declare the actual assembly routines with `*_nr_last_fastcall`// names and reordered arguments. If the signatures or calling conventions are// ever changed, the symbol names should also be updated accordingly, to avoid// x86 prefers to route all syscalls through the vDSO, though this isn't// always possible, so it also has a special form for doing the dispatch.//! Adapt the Linux API to resemble a POSIX-style libc API.//! The linux_raw backend doesn't use actual libc; this just defines certain//! types that are convenient to have defined.try_decode_u64decode_c_uint_infallibledecode_usize_infallibletry_decode_c_inttry_decode_c_uinttry_decode_raw_fdtry_decode_usizetry_decode_voidtry_decode_void_starArgNumber/// Pass a zero, or null, argument./// Pass the `mem::size_of` of a type.pass_usize/// Pass an arbitrary `usize` value./// For passing pointers, use `void_star` or other functions which take a raw/// pointer instead of casting to `usize`, so that provenance is preserved./// Pass a borrowed file-descriptor argument./// Pass a raw file-descriptor argument. Most users should use [`ArgReg::from`]/// instead, to preserve I/O safety as long as possible./// `fd` must be a valid open file descriptor./// Deliberately pass `-1` to a file-descriptor argument, for system calls/// like `mmap` where this indicates the argument is omitted.slice_just_addrslice_just_addr_mutopt_mut/// Convert an optional mutable reference into a `usize` for passing to a/// syscall./// Convert a `c_int` into an `ArgReg`./// Be sure to use `raw_fd` to pass `RawFd` values./// Convert a `c_uint` into an `ArgReg`.loff_t_from_u64oflags_bitsoflags_for_open_how/// Convert an `OFlags` into a `u64` for use in the `open_how` struct./// Convert a `Resource` into a syscall argument.negative_pid/// Convert a `usize` returned from a syscall that effectively returns `()` on/// success./// The caller must ensure that this is the return value of a syscall which/// just returns 0 on success./// Convert a `usize` returned from a syscall that effectively always returns/// `()`./// always returns `()`./// Convert a `usize` returned from a syscall that effectively returns a/// `c_int` on success.ret_c_uint/// `c_uint` on success.ret_u64/// Convert a `usize` returned from a syscall that effectively returns a `u64`/// on success./// `usize` on success.ret_usize_infallible/// Convert a `usize` returned from a syscall that effectively always/// returns a `usize`./// This function must only be used with return values from infallible/// syscalls.ret_c_uint_infallible/// Convert a `c_uint` returned from a syscall that effectively always/// returns a `c_uint`./// Convert a `usize` returned from a syscall that effectively returns an/// `OwnedFd` on success./// returns an owned file descriptor./// Convert the return value of `dup2` and `dup3`./// When these functions succeed, they return the same value as their second/// argument, so we don't construct a new `OwnedFd`./// returns a file descriptor.ret_void_star/// `*mut c_void` on success.//! Convert values to [`ArgReg`] and from [`RetReg`].//! System call arguments and return values are all communicated with inline//! asm and FFI as `*mut Opaque`. To protect these raw pointers from escaping//! or being accidentally misused as they travel through the code, we wrap//! them in [`ArgReg`] and [`RetReg`] structs. This file provides `From`//! implementations and explicit conversion functions for converting values//! into and out of these wrapper structs.//! Some of this code is `unsafe` in order to work with raw file descriptors,//! and some is `unsafe` to interpret the values in a `RetReg`./// The `OwnedFd` that we read directory entries from./// Should we rewind the stream on the next iteration?/// The buffer for `linux_dirent64` entries./// Where we are in the buffer.read_morer" `IN_*` for use with [`inotify_init`]."r" [`inotify_init`]: crate::fs::inotify::inotify_init"r" `IN_CLOEXEC`"r" `IN_NONBLOCK`"r" `IN*` for use with [`inotify_add_watch`]."r" [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch"r" `IN_ACCESS`"r" `IN_ATTRIB`"r" `IN_CLOSE_NOWRITE`"r" `IN_CLOSE_WRITE`"r" `IN_CREATE `"r" `IN_DELETE`"r" `IN_DELETE_SELF`"r" `IN_MODIFY`"r" `IN_MOVE_SELF`"r" `IN_MOVED_FROM`"r" `IN_MOVED_TO`"r" `IN_OPEN`"r" `IN_CLOSE`"r" `IN_MOVE`"r" `IN_ALL_EVENTS`"r" `IN_DONT_FOLLOW`"r" `IN_EXCL_UNLINK`"r" `IN_MASK_ADD`"r" `IN_MASK_CREATE`"MASK_CREATEr" `IN_ONESHOT`"r" `IN_ONLYDIR`"/// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify._seekstatfs_to_statvfsfcntl_getleasefcntl_getownfcntl_getsigfcntl_getpipe_szfcntl_setpipe_szgetdents_utimensat//! linux_raw syscalls supporting `rustix::fs`.//! See the `rustix::backend` module documentation for details.r" `*_OK` constants for use with [`accessat`]."r" [`accessat`]: fn.accessat.html"r" `R_OK`"READ_OKr" `W_OK`"WRITE_OKr" `X_OK`"EXEC_OKr" `F_OK`"r" `AT_*` constants for use with [`openat`], [`statat`], and other `*at`"r" functions."r" [`openat`]: crate::fs::openat"r" [`statat`]: crate::fs::statat"r" `AT_REMOVEDIR`"REMOVEDIRr" `AT_SYMLINK_FOLLOW`"SYMLINK_FOLLOWr" `AT_SYMLINK_NOFOLLOW`"SYMLINK_NOFOLLOWr" `AT_EMPTY_PATH`"EMPTY_PATHr" `AT_EACCESS`"EACCESSr" `AT_STATX_SYNC_AS_STAT`"STATX_SYNC_AS_STATr" `AT_STATX_FORCE_SYNC`"STATX_FORCE_SYNCr" `AT_STATX_DONT_SYNC`"STATX_DONT_SYNCr" `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`]."r" [`chmodat`]: crate::fs::chmodat"r" [`fchmod`]: crate::fs::fchmod"r" `S_IRWXU`"RWXUr" `S_IRUSR`"RUSRr" `S_IWUSR`"WUSRr" `S_IXUSR`"XUSRr" `S_IRWXG`"RWXGr" `S_IRGRP`"RGRPr" `S_IWGRP`"WGRPr" `S_IXGRP`"XGRPr" `S_IRWXO`"RWXOr" `S_IROTH`"ROTHr" `S_IWOTH`"WOTHr" `S_IXOTH`"XOTHr" `S_ISUID`"SUIDr" `S_ISGID`"SGIDr" `S_ISVTX`"SVTX/// Support conversions from `Mode` to raw mode values.r" `O_*` constants for use with [`openat`]."r" `O_ACCMODE`"ACCMODEr" Similar to `ACCMODE`, but just includes the read/write flags, and"r" no other flags."r" Some implementations include `O_PATH` in `O_ACCMODE`, when"r" sometimes we really just want the read/write bits. Caution is"r" indicated, as the presence of `O_PATH` may mean that the read/write"r" bits don't have their usual meaning."RWMODEr" `O_APPEND`"APPENDr" `O_CREAT`"r" `O_DIRECTORY`"r" `O_DSYNC`. Linux 2.6.32 only supports `O_SYNC`."DSYNCr" `O_EXCL`"EXCLr" `O_FSYNC`. Linux 2.6.32 only supports `O_SYNC`."r" `O_NOFOLLOW`"NOFOLLOWr" `O_NONBLOCK`"r" `O_RDONLY`"RDONLYr" `O_WRONLY`"WRONLYr" `O_RDWR`"r" `O_NOCTTY`"NOCTTYr" `O_RSYNC`. Linux 2.6.32 only supports `O_SYNC`."RSYNCr" `O_SYNC`"SYNCr" `O_TRUNC`"TRUNCr" `O_PATH`"r" `O_CLOEXEC`"r" `O_TMPFILE`"TMPFILEr" `O_NOATIME`"NOATIMEr" `O_DIRECT`"r" `RESOLVE_*` constants for use with [`openat2`]."r" [`openat2`]: crate::fs::openat2"r" `RESOLVE_NO_XDEV`"r" `RESOLVE_NO_MAGICLINKS`"NO_MAGICLINKSr" `RESOLVE_NO_SYMLINKS`"NO_SYMLINKSr" `RESOLVE_BENEATH`"BENEATHr" `RESOLVE_IN_ROOT`"IN_ROOTr" `RESOLVE_CACHED` (since Linux 5.12)"r" `RENAME_*` constants for use with [`renameat_with`]."r" [`renameat_with`]: crate::fs::renameat_with"r" `RENAME_EXCHANGE`"EXCHANGEr" `RENAME_NOREPLACE`"NOREPLACEr" `RENAME_WHITEOUT`"WHITEOUTr" `MFD_*` constants for use with [`memfd_create`]."r" [`memfd_create`]: crate::fs::memfd_create"r" `MFD_CLOEXEC`"r" `MFD_ALLOW_SEALING`"ALLOW_SEALINGr" `MFD_HUGETLB` (since Linux 4.14)"HUGETLBr" `MFD_HUGE_64KB`"HUGE_64KBr" `MFD_HUGE_512JB`"HUGE_512KBr" `MFD_HUGE_1MB`"HUGE_1MBr" `MFD_HUGE_2MB`"HUGE_2MBr" `MFD_HUGE_8MB`"HUGE_8MBr" `MFD_HUGE_16MB`"HUGE_16MBr" `MFD_HUGE_32MB`"HUGE_32MBr" `MFD_HUGE_256MB`"HUGE_256MBr" `MFD_HUGE_512MB`"HUGE_512MBr" `MFD_HUGE_1GB`"HUGE_1GBr" `MFD_HUGE_2GB`"HUGE_2GBr" `MFD_HUGE_16GB`"HUGE_16GBr" `F_SEAL_*` constants for use with [`fcntl_add_seals`] and"r" [`fcntl_get_seals`]."r" [`fcntl_add_seals`]: crate::fs::fcntl_add_seals"r" [`fcntl_get_seals`]: crate::fs::fcntl_get_seals"r" `F_SEAL_SEAL`."SEALr" `F_SEAL_SHRINK`."SHRINKr" `F_SEAL_GROW`."GROWr" `F_SEAL_WRITE`."r" `F_SEAL_FUTURE_WRITE` (since Linux 5.1)"FUTURE_WRITEr" `STATX_*` constants for use with [`statx`]."r" [`statx`]: crate::fs::statx"r" `STATX_TYPE`"r" `STATX_MODE`"MODEr" `STATX_NLINK`"NLINKr" `STATX_UID`"r" `STATX_GID`"GIDr" `STATX_ATIME`"ATIMEr" `STATX_MTIME`"MTIMEr" `STATX_CTIME`"r" `STATX_INO`"INOr" `STATX_SIZE`"r" `STATX_BLOCKS`"BLOCKSr" `STATX_BASIC_STATS`"BASIC_STATSr" `STATX_BTIME`"BTIMEr" `STATX_MNT_ID` (since Linux 5.8)"MNT_IDr" `STATX_ALL`"r" `FALLOC_FL_*` constants for use with [`fallocate`]."r" [`fallocate`]: crate::fs::fallocate"r" `FALLOC_FL_KEEP_SIZE`"KEEP_SIZEr" `FALLOC_FL_PUNCH_HOLE`"PUNCH_HOLEr" `FALLOC_FL_NO_HIDE_STALE`"NO_HIDE_STALEr" `FALLOC_FL_COLLAPSE_RANGE`"COLLAPSE_RANGEr" `FALLOC_FL_ZERO_RANGE`"ZERO_RANGEr" `FALLOC_FL_INSERT_RANGE`"INSERT_RANGEr" `FALLOC_FL_UNSHARE_RANGE`"UNSHARE_RANGEr" `ST_*` constants for use with [`StatVfs`]."r" `ST_MANDLOCK`"MANDLOCKr" `ST_NOATIME`"r" `ST_NODEV`"r" `ST_NODIRATIME`"NODIRATIMEr" `ST_NOEXEC`"r" `ST_NOSUID`"NOSUIDr" `ST_RDONLY`"r" `ST_RELATIME`"RELATIMEr" `ST_SYNCHRONOUS`"SYNCHRONOUS// Within the kernel the dev_t is 32-bit, but userspace uses a 64-bit field.r" `MS_*` constants for use with [`mount`]."r" [`mount`]: crate::fs::mount"MountFlagsr" `MS_BIND`"BINDr" `MS_DIRSYNC`"DIRSYNCr" `MS_LAZYTIME`"LAZYTIMEr" `MS_MANDLOCK`"PERMIT_MANDATORY_FILE_LOCKINGr" `MS_NOATIME`"r" `MS_NODEV`"r" `MS_NODIRATIME`"r" `MS_NOEXEC`"r" `MS_NOSUID`"r" `MS_RDONLY`"r" `MS_REC`"RECr" `MS_RELATIME`"r" `MS_SILENT`"SILENTr" `MS_STRICTATIME`"STRICTATIMEr" `MS_SYNCHRONOUS`"r" `MS_NOSYMFOLLOW`"NOSYMFOLLOWr" `MS_*` constants for use with [`change_mount`]."r" [`change_mount`]: crate::fs::mount::change_mount"MountPropagationFlagsr" `MS_SHARED`"SHAREDr" `MS_PRIVATE`"r" `MS_SLAVE`"SLAVEr" `MS_UNBINDABLE`"UNBINDABLEInternalMountFlagsREMOUNTr" `MNT_*` constants for use with [`unmount`]."r" [`unmount`]: crate::fs::mount::unmount"r" `MNT_FORCE`"r" `MNT_DETACH`"DETACHr" `MNT_EXPIRE`"EXPIREr" `UMOUNT_NOFOLLOW`"r" `EPOLL_*` for use with [`Epoll::new`]."r" `EPOLL_CLOEXEC`"r" `EPOLL*` for use with [`Epoll::add`]."r" `EPOLLIN`"r" `EPOLLOUT`"r" `EPOLLPRI`"r" `EPOLLERR`"r" `EPOLLHUP`"r" `EPOLLRDNORM`"RDNORMr" `EPOLLRDBAND`"RDBANDr" `EPOLLWRNORM`"WRNORMr" `EPOLLWRBAND`"r" `EPOLLMSG`"r" `EPOLLRDHUP`"RDHUPr" `EPOLLET`"ETr" `EPOLLONESHOT`"r" `EPOLLWAKEUP`"WAKEUPr" `EPOLLEXCLUSIVE`"EXCLUSIVE/// This registers interest in any of the events set in `events` occurring/// on the file descriptor associated with `data`./// This also returns the owning `Data`.// Match the layout of `linux_raw_sys::general::epoll_event`. We just use a// `u64` instead of the full union.RetNumber// Linux returns negated error codes, and we leave them in negated form, so// error codes are in `-4095..0`./// Convert from a C `errno` value (which is positive) to an `Errno`./// Check for an error from the result of a syscall which encodes a/// `c::c_int` on success./// `c::c_uint` on success./// Check for an error from the result of a syscall which encodes a `usize` on/// `u64` on success./// Check for an error from the result of a syscall which encodes a file/// descriptor on success./// This must only be used with syscalls which return file descriptors on/// Check for an error from the result of a syscall which encodes no value on/// success. On success, return the unconsumed `raw` value./// This must only be used with syscalls which return no value on success./// Return the contained `usize` value./// Return the contained `c_int` value./// `EINTR`./// [`retry_on_intr`]: io::retry_on_intr// On Linux, `ENOTSUP` has the same value as `EOPNOTSUPP`.//! Linux uses error codes in `-4095..0`; we use rustc attributes to describe//! this restricted range of values./// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.new>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.advance>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.as_slice>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.new>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.advance>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.as_slice>/// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.as_slice_mut>r" `POLL*` flags for use with [`poll`]."r" [`poll`]: crate::io::poll"r" `POLLIN`"r" `POLLPRI`"r" `POLLOUT`"r" `POLLRDNORM`"r" `POLLWRNORM`"r" `POLLRDBAND`"r" `POLLWRBAND`"r" `POLLERR`"r" `POLLHUP`"r" `POLLNVAL`"r" `POLLRDHUP`"/// The maximum number of buffers that can be passed into a vectored I/O system/// call on the current platform.//! linux_raw syscalls supporting `rustix::io`.r" `FD_*` constants for use with [`fcntl_getfd`] and [`fcntl_setfd`]."r" [`fcntl_getfd`]: crate::io::fcntl_getfd"r" [`fcntl_setfd`]: crate::io::fcntl_setfd"r" `FD_CLOEXEC`"r" `RWF_*` constants for use with [`preadv2`] and [`pwritev2`]."r" [`preadv2`]: crate::io::preadv2"r" [`pwritev2`]: crate::io::pwritev"r" `RWF_DSYNC` (since Linux 4.7)"r" `RWF_HIPRI` (since Linux 4.6)"HIPRIr" `RWF_SYNC` (since Linux 4.7)"r" `RWF_NOWAIT` (since Linux 4.14)"NOWAITr" `RWF_APPEND` (since Linux 4.16)"r" `SPLICE_F_*` constants for use with [`splice`] and [`vmsplice`]."r" `SPLICE_F_MOVE`"r" `SPLICE_F_NONBLOCK`"r" `SPLICE_F_MORE`"MOREr" `SPLICE_F_GIFT`"GIFTr" `O_*` constants for use with [`dup2`]."r" [`dup2`]: crate::io::dup2"r" `O_*` constants for use with [`pipe_with`]."r" [`pipe_with`]: crate::io::pipe_with"r" `EFD_*` flags for use with [`eventfd`]."r" [`eventfd`]: crate::io::eventfd"r" `EFD_CLOEXEC`"r" `EFD_NONBLOCK`"r" `EFD_SEMAPHORE`"//! linux_raw syscalls supporting `rustix::io_uring`./// `munmap` is primarily unsafe due to the `addr` parameter, as anything/// working with memory pointed to by raw pointers is unsafe./// `MADV_FREE` (since Linux 4.5)/// On Linux, this is mapped to `POSIX_MADV_NORMAL` because/// Linux's `MADV_DONTNEED` differs from `POSIX_MADV_DONTNEED`. See/// `LinuxDontNeed` for the Linux behavior.// The linux_raw backend doesn't use actual libc, so we define selected// libc-like definitions in a module called `c`.//! The linux_raw backend.//! This makes Linux syscalls directly, without going through libc.//! These files performs raw system calls, and sometimes passes them//! uninitialized memory buffers. The signatures in this file are currently//! manually maintained and must correspond with the signatures of the actual//! Linux syscalls.//! Some of this could be auto-generated from the Linux header file//! <linux/syscalls.h>, but we often need more information than it provides,//! such as which pointers are array slices, out parameters, or in-out//! parameters, which integers are owned or borrowed file descriptors, etc.//! This file uses `CStr::from_bytes_with_nul_unchecked` on a string it knows//! to be NUL-terminated./// Read the `ss_family` field from a socket address returned from the OS./// `storage` must point to a valid socket address returned from the OS./// Read a socket address encoded in a platform-specific format./// `storage` must point to valid socket address storage./// Read a socket address returned from the OS.x86_sysSocketArgset_socket_timeout_old/// Same as `set_socket_timeout` but uses `timeval` instead of/// `__kernel_timespec` and `_OLD` constants instead of `_NEW`.get_socket_timeout_old/// Same as `get_socket_timeout` but uses `timeval` instead ofduration_from_linux/// Convert a C `timespec` to a Rust `Option<Duration>`.duration_from_linux_old/// Like `duration_from_linux` but uses Linux's old 32-bit `timeval`.duration_to_linux/// Convert a Rust `Option<Duration>` to a C `timespec`.duration_to_linux_old/// Like `duration_to_linux` but uses Linux's old 32-bit `timeval`.//! linux_raw syscalls supporting `rustix::net`.ETHERNET/// `IPPROTO_ETHERNET`check_raw_pointerexe_phdrsexe_phdrs_slicesysinfo_ehdr/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations,/// so if we don't see it, this function returns a null pointer.CLOCK_TICKS_PER_SECONDHWCAPHWCAP2SYSINFO_EHDRPHDRPHNUMEXECFNinit_from_proc_self_auxv/// On non-Mustang platforms, we read the aux vector from /proc/self/auxv.init_from_auxv_file/// Process auxv entries from the open file `auxv`.init_from_auxp/// Process auxv entries from the auxv array pointed to by `auxp`./// This must be passed a pointer to an auxv array./// The buffer contains `Elf_aux_t` elements, though it need not be aligned;/// function uses `read_unaligned` to read from it.check_interpreter_base/// Check that `base` is a valid pointer to the program interpreter./// `base` is some value we got from a `AT_BASE` aux record somewhere,/// which hopefully holds the value of the program interpreter in memory. Do a/// series of checks to be as sure as we can that it's safe to use.check_vdso_base/// Check that `base` is a valid pointer to the kernel-provided vDSO./// `base` is some value we got from a `AT_SYSINFO_EHDR` aux record somewhere,/// which hopefully holds the value of the kernel-provided vDSO in memory. Do acheck_elf_base/// Check that `base` is a valid pointer to an ELF image.//! Linux auxv support.//! This uses raw pointers to locate and read the kernel-provided auxv array.// ELF ABI//! Linux auxv support, using libc.// On Mustang, origin is in control of program startup and can access the// incoming aux values on the stack.// With "use-libc-auxv" enabled, use libc's `getauxval`.// Otherwise, we read aux values from /proc/self/auxv.SyncConstPtr/// A const pointer to `T` that implements [`Sync`]./// Creates a `SyncConstPointer` from a raw pointer./// Behavior is undefined if `ptr` is actually not/// safe to share across threads./// On mustang, we export a function to be called during initialization, and/// passed a pointer to the original environment variable block set up by the/// OS.init_from_envp/// This must be passed a pointer to the environment variable buffer/// provided by the kernel, which is followed in memory by the auxv array.//! Linux auxv support, for Mustang.getrlimit_old/// The old 32-bit-only `getrlimit` syscall, for when we lack the new/// `prlimit64`.setrlimit_old/// The old 32-bit-only `setrlimit` syscall, for when we lack the newrlimit_from_linux/// Convert a Rust [`Rlimit`] to a C `rlimit64`.rlimit_to_linux/// Convert a C `rlimit64` to a Rust `Rlimit`.rlimit_from_linux_old/// Like `rlimit_from_linux` but uses Linux's old 32-bit `rlimit`.rlimit_to_linux_old/// Like `rlimit_to_linux` but uses Linux's old 32-bit `rlimit`.//! linux_raw syscalls supporting `rustix::process`.Rtmin/// `SIGRTMIN`/// `EXIT_SUCCESS`/// `EXIT_FAILURE`/// The status value of a child terminated with a [`Signal::Abort`] signal.SiginfoExt/// Return the exit status or signal number recorded in a `siginfo_t`./// `si_signo` must equal `SIGCHLD` (as it is guaranteed to do after a/// `waitid` call).// The functions replacing the C macros use the same names as in libc.DecInt//! linux_raw syscalls supporting `rustix::pty`.//! linux_raw syscalls supporting `rustix::rand`.to_asm/// Convert `self` to a `usize` ready to be passed to a syscall/// machine instruction./// This should be used immediately before the syscall instruction, and/// the returned value shouldn't be used for any other purpose.from_asm/// Convert `raw` from a value produced by a syscall machine instruction/// into a `Self`./// This should be used immediately after the syscall instruction, and/// the operand value shouldn't be used for any other purpose./// To preserve provenance, syscall arguments and return values are passed as/// pointer types. They need a type to point to, so we define a custom private/// type, to prevent it from being used for anything else.// Argument numbers.// Return value numbers./// Syscall arguments use register-sized types. We use a newtype to/// discourage accidental misuse of the raw integer values./// This type doesn't implement `Clone` or `Copy`; it should be used exactly/// once. And it has a lifetime to ensure that it doesn't outlive any resources/// it might be pointing to./// Syscall return values use register-sized types. We use a newtype todecode_usizedecode_raw_fddecode_c_intdecode_c_uintdecode_void_stardecode_u64decode_voiddecode_error_codeis_nonzerois_in_range/// Encode a system call argument as an `ArgReg`./// Encode a system call number (a `__NR_*` constant) as a `SyscallNumber`.// Implement for those same types, but no others./// Seal our various traits using the technique documented [here]./// [here]: https://rust-lang.github.io/api-guidelines/future-proofing.html//! Encapsulation for system call arguments and return values.//! The inline-asm and outline-asm code paths do some amount of reordering//! of arguments; to ensure that we don't accidentally misroute an argument//! or return value, we use distinct types for each argument index and//! return value.//! The `ToAsm` and `FromAsm` traits are unsafe to use; they should only be//! used by the syscall code which executes actual syscall machine//! instructions.ret_errorHowSigactionSiginfoSigsetoptional_as_ptrUserDescset_thread_areaarm_set_tlsset_fsset_tid_addressset_thread_nametkillsigtimedwait_old//! linux_raw syscalls supporting `rustix::runtime`./// For use with [`set_thread_area`]./// [`set_thread_area`]: crate::runtime::set_thread_areastartup_tls_infoStartupTlsInfo/// The base address of the TLS segment.mem_size/// The size of the memory region./// The size beyond which all memory is zero-initialized./// The required alignment for the TLS segment./// The requested minimum size for stacks./// The values returned from [`startup_tls_info`]./// [`startup_tls_info`]: crate::runtime::startup_tls_info//! TLS utilities.//! This file contains code that reads the raw phdr array pointed to by the//! kernel-provided AUXV values.//! linux_raw syscalls supporting `rustix::termios`.FutexOperation/// `FUTEX_WAIT`/// `FUTEX_WAKE`/// `FUTEX_FD`Requeue/// `FUTEX_REQUEUE`CmpRequeue/// `FUTEX_CMP_REQUEUE`WakeOp/// `FUTEX_WAKE_OP`LockPi/// `FUTEX_LOCK_PI`UnlockPi/// `FUTEX_UNLOCK_PI`TrylockPi/// `FUTEX_TRYLOCK_PI`WaitBitset/// `FUTEX_WAIT_BITSET`/// `FUTEX_*` operations for use with [`futex`]./// [`futex`]: crate::thread::futexFutexFlags// TODO: This could be de-multiplexed.futex_old//! linux_raw syscalls supporting `rustix::thread`.__kernel_old_itimerspec// `clock_gettime` has special optimizations via the vDSO.//! linux_raw syscalls supporting `rustix::time`.r" `TFD_*` flags for use with [`timerfd_create`]."r" [`timerfd_create`]: crate::time::timerfd_create"r" `TFD_NONBLOCK`"r" `TFD_CLOEXEC`"r" `TFD_TIMER_*` flags for use with [`timerfd_settime`]."r" [`timerfd_settime`]: crate::time::timerfd_settime"r" `TFD_TIMER_ABSTIME`"ABSTIMEr" `TFD_TIMER_CANCEL_ON_SET`"CANCEL_ON_SETload_addr// Load informationload_endpv_offset// the end of the `PT_LOAD` segment// Symbol tablesymstringsnbucketversym// Version tableverdef// recorded paddr - recorded vaddr//nchain: u32,Vdsoelf_hash// Straight from the ELF specification.init_from_sysinfo_ehdr/// Create a `Vdso` value by parsing the vDSO at the `sysinfo_ehdr` address./// Parse the vDSO./// Returns `None` if the vDSO can't be located or if it doesn't conform/// to our expectations.match_version/// Check the version for a symbol./// The raw pointers inside `self` must be valid./// Look up a symbol in the vDSO.base_plus/// Add the given address to the vDSO base address.addr_from_elf/// Translate an ELF-address-space address into a usable virtual address.//! Parse the Linux vDSO.//! The following code is transliterated from//! tools/testing/selftests/vDSO/parse_vdso.c in Linux 5.11, which is licensed//! with Creative Commons Zero License, version 1.0,//! available at <https://creativecommons.org/publicdomain/zero/1.0/legalcode>//! Parsing the vDSO involves a lot of raw pointer manipulation. This//! implementation follows Linux's reference implementation, and adds several//! additional safety checks.vdso// With the indirect call, it isn't meaningful to do a separate// `_readonly` optimization.x86_via_vdsoClockGettimeType/// The underlying syscall functions are only called from asm, using the/// special syscall calling convention to pass arguments and return values,/// which the signature here doesn't reflect.init_clock_gettime/// Initialize `CLOCK_GETTIME` and return its value.init_syscall/// Initialize `SYSCALL` and return its value./// `AtomicPtr` can't hold a `fn` pointer, so we use a `*` pointer to this/// placeholder type, and cast it as needed.CLOCK_GETTIMErustix_clock_gettime_via_syscall_rustix_clock_gettime_via_syscall_rustix_clock_gettime_via_syscall_oldnakedrustix_int_0x80/// A symbol pointing to an `int 0x80` instruction. This “function” is only/// called from assembly, and only with the x86 syscall calling convention,/// so its signature here is not its true signature.minimal_init//! Implement syscalls using the vDSO.//! <https://man7.org/linux/man-pages/man7/vdso.7.html>//! Similar to syscalls.rs, this file performs raw system calls, and sometimes//! passes them uninitialized memory buffers. This file also calls vDSO// The outline version of the `rustix_int_0x80` above.const_assert/// A simple `assert` macro that works in `const fn`, for use until the/// standard `assert` macro works in `const fn`./// TODO: With Rust 1.58 we can replace this with just `assert!`.test_const_asserttest_const_assert_in_const_fn/// A macro for [`CStr`] literals./// This can make passing string literals to rustix APIs more efficient, since/// most underlying system calls with string arguments expect NUL-terminated/// strings, and passing strings to rustix as `CStr`s means that rustix doesn't/// need to copy them into a separate buffer to NUL-terminate them./// [`CStr`]: crate::ffi::CStr/// # #[cfg(feature = "fs")]/// # fn main() -> rustix::io::Result<()> {/// use rustix::cstr;/// use rustix::fs::{cwd, statat, AtFlags};/// let metadata = statat(cwd(), cstr!("test.txt"), AtFlags::empty())?;/// # #[cfg(not(feature = "fs"))]test_cstrtest_invalid_cstrtest_invalid_empty_cstr// If we have std, use it.//! Utilities related to FFI bindings./// `statfs`—Queries filesystem metadata./// Compared to [`statvfs`], this function often provides more information,/// though it's less portable.///  - [Linux]/// [Linux]: https://man7.org/linux/man-pages/man2/statfs.2.html/// `statvfs`—Queries filesystem metadata, POSIX version./// Compared to [`statfs`], this function often provides less information,/// but it is more portable. But even so, filesystems are very diverse and not/// all the fields are meaningful for every filesystem. And `f_fsid` doesn't/// seem to have a clear meaning anywhere.///  - [POSIX]/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/statvfs.html/// [Linux]: https://man7.org/linux/man-pages/man2/statvfs.2.html//! POSIX-style filesystem functions which operate on bare paths./// `UTIME_NOW` for use with [`utimensat`]./// [`utimensat`]: crate::fs::utimensat/// `UTIME_OMIT` for use with [`utimensat`]./// `openat(dirfd, path, oflags, mode)`—Opens a file./// POSIX guarantees that `openat` will use the lowest unused file descriptor,/// however it is not safe in general to rely on this, as file descriptors may/// be unexpectedly allocated on other threads or in libraries./// The `Mode` argument is only significant when creating a file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/openat.html/// [Linux]: https://man7.org/linux/man-pages/man2/openat.2.html/// `readlinkat(fd, path)`—Reads the contents of a symlink./// If `reuse` is non-empty, reuse its buffer to store the result if possible./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlinkat.html/// [Linux]: https://man7.org/linux/man-pages/man2/readlinkat.2.html_readlinkat/// `mkdirat(fd, path, mode)`—Creates a directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdirat.html/// [Linux]: https://man7.org/linux/man-pages/man2/mkdirat.2.htmlPFdQFd/// `linkat(old_dirfd, old_path, new_dirfd, new_path, flags)`—Creates a hard/// link./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/linkat.html/// [Linux]: https://man7.org/linux/man-pages/man2/linkat.2.html/// `unlinkat(fd, path, flags)`—Unlinks a file or remove a directory./// With the [`REMOVEDIR`] flag, this removes a directory. This is in place/// of a `rmdirat` function./// [`REMOVEDIR`]: AtFlags::REMOVEDIR/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlinkat.html/// [Linux]: https://man7.org/linux/man-pages/man2/unlinkat.2.html/// `renameat(old_dirfd, old_path, new_dirfd, new_path)`—Renames a file or/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/renameat.html/// [Linux]: https://man7.org/linux/man-pages/man2/renameat.2.htmlrenameat_with/// `renameat2(old_dirfd, old_path, new_dirfd, new_path, flags)`—Renames a/// file or directory./// [Linux]: https://man7.org/linux/man-pages/man2/renameat2.2.html/// `symlinkat(old_path, new_dirfd, new_path)`—Creates a symlink./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/symlinkat.html/// [Linux]: https://man7.org/linux/man-pages/man2/symlinkat.2.html/// `fstatat(dirfd, path, flags)`—Queries metadata for a file or directory./// [`Mode::from_raw_mode`] and [`FileType::from_raw_mode`] may be used to/// interpret the `st_mode` field./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstatat.html/// [Linux]: https://man7.org/linux/man-pages/man2/fstatat.2.html/// [`Mode::from_raw_mode`]: crate::fs::Mode::from_raw_mode/// [`FileType::from_raw_mode`]: crate::fs::FileType::from_raw_mode/// `faccessat(dirfd, path, access, flags)`—Tests permissions for a file or/// On Linux before 5.8, this function uses the `faccessat` system call which/// doesn't support any flags. This function emulates support for the/// [`AtFlags::EACCESS`] flag by checking whether the uid and gid of the/// process match the effective uid and gid, in which case the `EACCESS` flag/// can be ignored. In Linux 5.8 and beyond `faccessat2` is used, which/// supports flags./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/faccessat.html/// [Linux]: https://man7.org/linux/man-pages/man2/faccessat.2.html/// `utimensat(dirfd, path, times, flags)`—Sets file or directory timestamps./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimensat.html/// [Linux]: https://man7.org/linux/man-pages/man2/utimensat.2.html/// `fchmodat(dirfd, path, mode, 0)`—Sets file or directory permissions./// See `fchmodat_with` for a version that does take flags./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmodat.html/// [Linux]: https://man7.org/linux/man-pages/man2/fchmodat.2.htmlchmodat_with/// `fchmodat(dirfd, path, mode, flags)`—Sets file or directory permissions./// Platform support for flags varies widely, for example on Linux/// [`AtFlags::SYMLINK_NOFOLLOW`] is not implemented and therefore/// [`io::Errno::OPNOTSUPP`] will be returned./// `mknodat(dirfd, path, mode, dev)`—Creates special or normal files./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mknodat.html/// [Linux]: https://man7.org/linux/man-pages/man2/mknodat.2.html/// `fchownat(dirfd, path, owner, group, flags)`—Sets file or directory/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchownat.html/// [Linux]: https://man7.org/linux/man-pages/man2/fchownat.2.html//! POSIX-style `*at` functions.//! The `dirfd` argument to these functions may be a file descriptor for a//! directory, or the special value returned by [`cwd`].//! [`cwd`]: crate::fs::cwd::cwd//! Filesystem API constants, translated into `bitflags` constants.InFdOutFd/// `copy_file_range(fd_in, off_in, fd_out, off_out, len, 0)`—Copies data/// from one file to another./// [Linux]: https://man7.org/linux/man-pages/man2/copy_file_range.2.html/// `AT_FDCWD`—Returns a handle representing the current working directory./// This returns a file descriptor which refers to the process current/// directory which can be used as the directory argument in `*at`/// functions such as [`openat`]./// [`openat`]: crate::fs::openat/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/fcntl.h.html//! The `cwd` function, representing the current working directory.//! This file uses `AT_FDCWD`, which is a raw file descriptor, but which is//! always valid.//! `Dir` and `DirEntry`./// `posix_fadvise(fd, offset, len, advice)`—Declares an expected access/// pattern for a file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_fadvise.html/// [Linux]: https://man7.org/linux/man-pages/man2/posix_fadvise.2.html// These `fcntl` functions like in the `io` module because they're not specific// to files, directories, or memfd objects. We re-export them here in the `fs`// module because the other the `fcntl` functions are here./// `fcntl(fd, F_GETFL)`—Returns a file descriptor's access mode and status./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html/// [Linux]: https://man7.org/linux/man-pages/man2/fcntl.2.html/// `fcntl(fd, F_SETFL, flags)`—Sets a file descriptor's status./// `fcntl(fd, F_GET_SEALS)`/// `fcntl(fd, F_ADD_SEALS)`/// `fcntl(fd, F_SETLK)`—Acquire or release an `fcntl`-style lock./// This function doesn't currently have an offset or len; it currently always/// sets the `l_len` field to 0, which is a special case that means the entire/// file should be locked./// Unlike `flock`-style locks, `fcntl`-style locks are process-associated,/// meaning that they don't guard against being acquired by two threads in/// the same process.//! The Unix `fcntl` function is effectively lots of different functions//! hidden behind a single dynamic dispatch interface. In order to provide//! a type-safe API, rustix makes them all separate functions so that they//! can have dedicated static type signatures./// `fcntl(fd, F_RDADVISE, radvisory { offset, len })`///  - [Apple]/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fcntl.2.html/// `fcntl(fd, F_FULLFSYNC)`/// `copyfile_state_t`ToFd/// `fcopyfile(from, to, state, flags)`/// The `state` operand must be allocated with `copyfile_state_alloc` and not/// yet freed with `copyfile_state_free`./// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/fcopyfile.3.html/// `copyfile_state_alloc()`/// `copyfile_state_free(state)`/// `copyfile_state_get(state, COPYFILE_STATE_COPIED)`/// `copyfile_state_get(state, flags, dst)`last_access/// The timestamp of the last access to a filesystem object./// The timestamp of the last modification of a filesystem object./// Timestamps used by [`utimensat`] and [`futimens`]./// [`futimens`]: crate::fs::futimens// This is `repr(C)` and specifically laid out to match the representation used// by `utimensat` and `futimens`, which expect 2-element arrays of timestamps./// The filesystem magic number for procfs./// See [the `fstatfs` manual page] for more information./// [the `fstatfs` manual page]: https://man7.org/linux/man-pages/man2/fstatfs.2.html#DESCRIPTION/// The filesystem magic number for NFS./// `lseek(fd, offset, whence)`—Repositions a file descriptor within a file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/lseek.html/// [Linux]: https://man7.org/linux/man-pages/man2/lseek.2.html/// `lseek(fd, 0, SEEK_CUR)`—Returns the current position within a file./// Return the current position of the file descriptor. This is a subset of/// the functionality of `seek`, but this interface makes it easier for users/// to declare their intent not to mutate any state./// `fchmod(fd)`—Sets open file or directory permissions./// This implementation does not support `O_PATH` file descriptors, even on/// platforms where the host libc emulates it./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmod.html/// [Linux]: https://man7.org/linux/man-pages/man2/fchmod.2.html/// `fchown(fd)`—Sets open file or directory ownership./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchown.html/// [Linux]: https://man7.org/linux/man-pages/man2/fchown.2.html/// `fstat(fd)`—Queries metadata for an open file or directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstat.html/// [Linux]: https://man7.org/linux/man-pages/man2/fstat.2.html/// [`Mode::from_raw_mode`]: Mode::from_raw_mode/// `fstatfs(fd)`—Queries filesystem statistics for an open file or directory./// Compared to [`fstatvfs`], this function often provides more information,/// [Linux]: https://man7.org/linux/man-pages/man2/fstatfs.2.html/// `fstatvfs(fd)`—Queries filesystem statistics for an open file or/// directory, POSIX version./// Compared to [`fstatfs`], this function often provides less information,/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstatvfs.html/// [Linux]: https://man7.org/linux/man-pages/man2/fstatvfs.2.html/// `futimens(fd, times)`—Sets timestamps for an open file or directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/futimens.html/// `fallocate(fd, mode, offset, len)`—Adjusts file allocation./// This is a more general form of `posix_fallocate`, adding a `mode` argument/// which modifies the behavior. On platforms which only support/// `posix_fallocate` and not the more general form, no `FallocateFlags` values/// are defined so it will always be empty.///  - [Linux `fallocate`]///  - [Linux `posix_fallocate`]/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_fallocate.html/// [Linux `fallocate`]: https://man7.org/linux/man-pages/man2/fallocate.2.html/// [Linux `posix_fallocate`]: https://man7.org/linux/man-pages/man3/posix_fallocate.3.html// not implemented in libc for netbsd yetis_file_read_write/// `fcntl(fd, F_GETFL) & O_ACCMODE`/// Returns a pair of booleans indicating whether the file descriptor is/// readable and/or writable, respectively. This is only reliable on files; for/// example, it doesn't reflect whether sockets have been shut down; for/// general I/O handle support, use [`io::is_read_write`]._is_file_read_write/// `fsync(fd)`—Ensures that file data and metadata is written to the/// underlying storage device./// On iOS and macOS this isn't sufficient to ensure that data has reached/// persistent storage; use [`fcntl_fullfsync`] to ensure that./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html/// [Linux]: https://man7.org/linux/man-pages/man2/fsync.2.html/// [`fcntl_fullfsync`]: https://docs.rs/rustix/*/x86_64-apple-darwin/rustix/fs/fn.fcntl_fullfsync.html/// `fdatasync(fd)`—Ensures that file data is written to the underlying/// storage device./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fdatasync.html/// [Linux]: https://man7.org/linux/man-pages/man2/fdatasync.2.html/// `ftruncate(fd, length)`—Sets the length of a file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html/// [Linux]: https://man7.org/linux/man-pages/man2/ftruncate.2.html/// `flock(fd, operation)`—Acquire or release an advisory lock on an open file./// [Linux]: https://man7.org/linux/man-pages/man2/flock.2.html/// `syncfs(fd)`—Flush cached filesystem data./// [Linux]: https://man7.org/linux/man-pages/man2/syncfs.2.html//! Functions which operate on file descriptors./// `S_IF*` constants./// `fcntl(fd, F_GETPATH)`/// `makedev(maj, min)`/// [Linux]: https://man7.org/linux/man-pages/man3/makedev.3.html/// `minor(dev)`/// [Linux]: https://man7.org/linux/man-pages/man3/minor.3.html/// `major(dev)`/// [Linux]: https://man7.org/linux/man-pages/man3/major.3.html/// `memfd_create(path, flags)`///  - [glibc]///  - [FreeBSD]/// [Linux]: https://man7.org/linux/man-pages/man2/memfd_create.2.html/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Memory_002dmapped-I_002fO.html#index-memfd_005fcreate/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?memfd_createraw_dirxattrRawDirRawDirEntry/// Re-export types common to POSIX-ish platforms.//! Filesystem operations./// `mount(source, target, filesystemtype, mountflags, data)`/// [Linux]: https://man7.org/linux/man-pages/man2/mount.2.html/// `mount(NULL, target, NULL, MS_REMOUNT | mountflags, data)`bind_mount/// `mount(source, target, NULL, MS_BIND, NULL)`recursive_bind_mount/// `mount(source, target, NULL, MS_BIND | MS_REC, NULL)`change_mount/// `mount(NULL, target, NULL, mountflags, NULL)`move_mount/// `mount(source, target, NULL, MS_MOVE, NULL)`/// `umount2(target, flags)`/// [Linux]: https://man7.org/linux/man-pages/man2/umount.2.html//! Linux `mount`./// `openat2(dirfd, path, OpenHow { oflags, mode, resolve }, sizeof(OpenHow))`/// [Linux]: https://man7.org/linux/man-pages/man2/openat2.2.html/// A directory iterator implemented with getdents./// Note: This implementation does not handle growing the buffer. If this/// functionality is necessary, you'll need to drop the current iterator,/// resize the buffer, and then re-create the iterator. The iterator is/// guaranteed to continue where it left off provided the file descriptor isn't/// changed. See the example in [`RawDir::new`]./// Create a new iterator from the given file descriptor and buffer./// Note: the buffer size may be trimmed to accommodate alignment/// ## Simple but non-portable/// These examples are non-portable, because file systems may not have a/// maximum file name length. If you can make assumptions that bound/// this length, then these examples may suffice./// Using the heap:/// # // The `notrust` above can be removed when we can depend on Rust 1.60./// # use std::mem::MaybeUninit;/// # use rustix::fs::{cwd, Mode, OFlags, openat, RawDir};/// let fd = openat(///     cwd(),///     ".",///     OFlags::RDONLY | OFlags::DIRECTORY | OFlags::CLOEXEC,///     Mode::empty(),/// let mut buf = Vec::with_capacity(8192);/// let mut iter = RawDir::new(fd, buf.spare_capacity_mut());/// while let Some(entry) = iter.next() {///     dbg!(&entry);/// Using the stack:/// let mut buf = [MaybeUninit::uninit(); 2048];/// let mut iter = RawDir::new(fd, &mut buf);/// ## Portable/// Heap allocated growing buffer for supporting directory entries with/// arbitrarily large file names:/// # use rustix::io::Errno;/// 'read: loop {///     'resize: {///         let mut iter = RawDir::new(&fd, buf.spare_capacity_mut());///         while let Some(entry) = iter.next() {///             let entry = match entry {///                 Err(Errno::INVAL) => break 'resize,///                 r => r.unwrap(),///             };///             dbg!(&entry);///         break 'read;///     let new_capacity = buf.capacity() * 2;///     buf.reserve(new_capacity);inode_numbernext_entry_cookie/// A raw directory entry, similar to `std::fs::DirEntry`./// Unlike the std version, this may represent the `.` or `..` entries./// Returns the inode number of this directory entry./// Returns the seek cookie to the next directory entry./// Identical to [`Iterator::next`] except that [`Iterator::Item`] borrows/// from self./// Note: this interface will be broken to implement a stdlib iterator API/// with GAT support once one becomes available.is_buffer_empty/// Returns true if the internal buffer is empty and will be refilled when/// calling [`next`]./// [`next`]: Self::next//! `RawDir` and `RawDirEntry`./// `sendfile(out_fd, in_fd, offset, count)`/// [Linux]: https://man7.org/linux/man-pages/man2/sendfile.2.html_statx/// `statx(dirfd, path, flags, mask, statxbuf)`/// This function returns [`io::Errno::NOSYS`] if `statx` is not available on/// the platform, such as Linux before 4.11. This also includes older Docker/// versions where the actual syscall fails with different error codes; rustix/// handles this and translates them into `NOSYS`./// [Linux]: https://man7.org/linux/man-pages/man2/statx.2.htmlSTATX_STATE// Linux kernel prior to 4.11 old versions of Docker don't support `statx`.// We store the availability in a global to avoid unnecessary syscalls.// 0: Unknown// 1: Not available// 2: Availablestatx_init/// The first `statx` call. We don't know if `statx` is available yet.statx_error_nosys/// The first `statx` call failed with `NOSYS` (or something we're treating/// like `NOSYS`).statx_error_perm/// The first `statx` call failed with `PERM`.//! Linux `statx`./// `sync`—Flush cached filesystem data for all filesystems./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sync.html/// [Linux]: https://man7.org/linux/man-pages/man2/sync.2.htmlr" `XATTR_*` constants for use with [`setxattr`], and other `*setxattr`"r" `XATTR_CREATE`"r" `XATTR_REPLACE`"/// `getxattr(path, name, value.as_ptr(), value.len())`—Get extended/// filesystem attributes./// [Linux]: https://man7.org/linux/man-pages/man2/getxattr.2.html/// `lgetxattr(path, name, value.as_ptr(), value.len())`—Get extended/// filesystem attributes, without following symlinks in the last path/// component./// [Linux]: https://man7.org/linux/man-pages/man2/lgetxattr.2.html/// `fgetxattr(fd, name, value.as_ptr(), value.len())`—Get extended/// filesystem attributes on an open file descriptor./// [Linux]: https://man7.org/linux/man-pages/man2/fgetxattr.2.html/// `setxattr(path, name, value.as_ptr(), value.len(), flags)`—Set extended/// [Linux]: https://man7.org/linux/man-pages/man2/setxattr.2.html/// [Linux]: https://man7.org/linux/man-pages/man2/lsetxattr.2.html/// `fsetxattr(fd, name, value.as_ptr(), value.len(), flags)`—Set extended/// [Linux]: https://man7.org/linux/man-pages/man2/fsetxattr.2.html/// `listxattr(path, list.as_ptr(), list.len())`—List extended filesystem/// attributes./// [Linux]: https://man7.org/linux/man-pages/man2/listxattr.2.html/// `llistxattr(path, list.as_ptr(), list.len())`—List extended filesystem/// attributes, without following symlinks in the last path component./// [Linux]: https://man7.org/linux/man-pages/man2/llistxattr.2.html/// `flistxattr(fd, list.as_ptr(), list.len())`—List extended filesystem/// attributes on an open file descriptor./// [Linux]: https://man7.org/linux/man-pages/man2/flistxattr.2.html/// `removexattr(path, name)`—Remove an extended filesystem attribute./// [Linux]: https://man7.org/linux/man-pages/man2/removexattr.2.html/// `lremovexattr(path, name)`—Remove an extended filesystem attribute,/// without following symlinks in the last path component./// [Linux]: https://man7.org/linux/man-pages/man2/lremovexattr.2.html/// `fremovexattr(fd, name)`—Remove an extended filesystem attribute on an/// open file descriptor./// [Linux]: https://man7.org/linux/man-pages/man2/fremovexattr.2.html/// `close(raw_fd)`—Closes a `RawFd` directly./// Most users won't need to use this, as `OwnedFd` automatically closes its/// file descriptor on `Drop`./// This function does not return a `Result`, as it is the [responsibility] of/// filesystem designers to not return errors from `close`. Users who chose to/// use NFS or similar filesystems should take care to monitor for problems/// externally./// [responsibility]: https://lwn.net/Articles/576518////  - [Beej's Guide to Network Programming]///  - [Winsock2]///  - [NetBSD]///  - [OpenBSD]///  - [DragonFly BSD]///  - [illumos]/// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#close-and-shutdownget-outta-my-face/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html/// [Linux]: https://man7.org/linux/man-pages/man2/close.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/close.2.html#//apple_ref/doc/man/2/close/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-closesocket/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=close&sektion=2/// [NetBSD]: https://man.netbsd.org/close.2/// [OpenBSD]: https://man.openbsd.org/close.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=close&section=2/// [illumos]: https://illumos.org/man/2/close/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Opening-and-Closing-Files.html#index-close/// This function takes a `RawFd`, which must be valid before the call, and is/// not valid after the call.//! The unsafe `close` for raw file descriptors.//! Operating on raw file descriptors is unsafe./// `dup(fd)`—Creates a new `OwnedFd` instance that shares the same/// underlying [file description] as `fd`./// This function does not set the `O_CLOEXEC` flag. To do a `dup` that does/// set `O_CLOEXEC`, use [`fcntl_dupfd_cloexec`]./// POSIX guarantees that `dup` will use the lowest unused file descriptor,/// [file description]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_258/// [`fcntl_dupfd_cloexec`]: crate::io::fcntl_dupfd_cloexec/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html/// [Linux]: https://man7.org/linux/man-pages/man2/dup.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/dup.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=dup&sektion=2/// [NetBSD]: https://man.netbsd.org/dup.2/// [OpenBSD]: https://man.openbsd.org/dup.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=dup&section=2/// [illumos]: https://illumos.org/man/2/dup/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Duplicating-Descriptors.html/// `dup2(fd, new)`—Changes the [file description] of a file descriptor./// `dup2` conceptually closes `new` and then sets the file description for/// `new` to be the same as the one for `fd`. This is a very unusual operation,/// and should only be used on file descriptors where you know how `new` will/// be subsequently used./// This function does not set the `O_CLOEXEC` flag. To do a `dup2` that does/// set `O_CLOEXEC`, use [`dup3`] with [`DupFlags::CLOEXEC`] on platforms which/// support it, or [`fcntl_dupfd_cloexec`]/// For `dup2` to stdin, stdout, and stderr, see [`io::dup2_stdin`],/// [`io::dup2_stdout`], and [`io::dup2_stderr`]./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup2.html/// [Linux]: https://man7.org/linux/man-pages/man2/dup2.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/dup2.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=dup2&sektion=2/// [NetBSD]: https://man.netbsd.org/dup2.2/// [OpenBSD]: https://man.openbsd.org/dup2.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=dup2&section=2/// `dup3(fd, new, flags)`—Changes the [file description] of a file/// descriptor, with flags./// `dup3` is the same as [`dup2`] but adds an additional flags operand, and it/// fails in the case that `fd` and `new` have the same file descriptor value./// This additional difference is the reason this function isn't named/// `dup2_with`./// [Linux]: https://man7.org/linux/man-pages/man2/dup3.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=dup3&sektion=3/// [NetBSD]: https://man.netbsd.org/dup3.2/// [OpenBSD]: https://man.openbsd.org/dup3.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=dup3&section=3//! Functions which duplicate file descriptors./// A specialized [`Result`] type for `rustix` APIs./// `errno`—An error code./// The error type for `rustix` APIs. This is similar to `std::io::Error`, but/// only holds an OS error code, and no extra error value./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/errno.html/// [Linux]: https://man7.org/linux/man-pages/man3/errno.3.html/// [Winsock2]: https://learn.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?errno/// [NetBSD]: https://man.netbsd.org/errno.2/// [OpenBSD]: https://man.openbsd.org/errno.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=errno&section=2/// [illumos]: https://illumos.org/man/3C/errno/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html/// Shorthand for `std::io::Error::from(self).kind()`.retry_on_intr/// Call `f` until it either succeeds or fails other than [`Errno::INTR`].//! The `Errno` type, which is a minimal wrapper around an error code.//! We define the error constants as individual `const`s instead of an//! enum because we may not know about all of the host's error values//! and we don't want unrecognized values to create UB./// `eventfd(initval, flags)`—Creates a file descriptor for event/// [Linux]: https://man7.org/linux/man-pages/man2/eventfd.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?eventfd/// [illumos]: https://illumos.org/man/3C/eventfd/// `fcntl(fd, F_GETFD)`—Returns a file descriptor's flags./// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=fcntl&sektion=2/// [NetBSD]: https://man.netbsd.org/fcntl.2/// [OpenBSD]: https://man.openbsd.org/fcntl.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=fcntl&section=2/// [illumos]: https://illumos.org/man/2/fcntl/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Control-Operations.html#index-fcntl-function/// `fcntl(fd, F_SETFD, flags)`—Sets a file descriptor's flags./// `fcntl(fd, F_DUPFD_CLOEXEC)`—Creates a new `OwnedFd` instance, with value/// at least `min`, that has `O_CLOEXEC` set and that shares the same/// POSIX guarantees that `F_DUPFD_CLOEXEC` will use the lowest unused file/// descriptor which is at least `min`, however it is not safe in general to/// rely on this, as file descriptors may be unexpectedly allocated on other/// threads or in libraries.//! `fcntl` functions which are not specific to files or directories live//! in the [`io`] module instead.//! [`io`]: crate::io// `RawFd`, `AsRawFd`, etc.// `OwnedFd`, `AsFd`, etc.//! library/std/src/os/fd/mod.rs at revision//! fa68e73e9947be8ffc5b3b46d899e4953a44e7e9.//! Owned and borrowed Unix-like file descriptors.// libstd/os/raw/mod.rs assures me that every libstd-supported platform has a// 32-bit c_int. Below is -2, in two's complement, but that only works out// because c_int is 32 bits./// The resource pointed to by `fd` must remain open for the duration of/// Creates a new `OwnedFd` instance that shares the same underlying file handle/// as the existing `OwnedFd` instance./// The resource pointed to by `fd` must be open and suitable for assuming/// ownership. The resource must not require any cleanup other than `close`./// Borrows the file descriptor./// # #![feature(io_safety)]/// # #[cfg(target_os = "wasi")]/// # use std::os::wasi::io::{AsFd, BorrowedFd};/// # #[cfg(unix)]/// # use std::os::unix::io::{AsFd, BorrowedFd};/// # #[cfg(any(unix, target_os = "wasi"))]/// let borrowed_fd: BorrowedFd<'_> = f.as_fd();/// A trait to borrow the file descriptor from an underlying object./// This is only available on unix platforms and must be imported in order to/// call the method. Windows platforms have a corresponding `AsHandle` and/// `AsSocket` set of traits.//! library/std/src/os/fd/owned.rs at revision/// Raw file descriptors./// Extracts the raw file descriptor./// This function is typically used to **borrow** an owned file descriptor./// When used in this way, this method does **not** pass ownership of the/// raw file descriptor to the caller, and the file descriptor is only/// guaranteed to be valid while the original object has not yet been/// However, borrowing is not strictly required. See [`AsFd::as_fd`]/// for an API which strictly borrows a file descriptor./// use std::os::unix::io::{AsRawFd, RawFd};/// #[cfg(target_os = "wasi")]/// use std::os::wasi::io::{AsRawFd, RawFd};/// // `raw_fd` is only valid as long as `f` exists./// let raw_fd: RawFd = f.as_raw_fd();/// A trait to extract the raw file descriptor from an underlying object./// This is only available on unix and WASI platforms and must be imported in/// order to call the method. Windows platforms have a corresponding/// `AsRawHandle` and `AsRawSocket` set of traits./// Constructs a new instance of `Self` from the given raw file/// This function is typically used to **consume ownership** of the/// specified file descriptor. When used in this way, the returned object/// will take responsibility for closing it when the object goes out of/// scope./// However, consuming ownership is not strictly required. Use a/// [`From<OwnedFd>::from`] implementation for an API which strictly/// consumes ownership./// The `fd` passed in must be a valid an open file descriptor./// use std::os::unix::io::{FromRawFd, IntoRawFd, RawFd};/// use std::os::wasi::io::{FromRawFd, IntoRawFd, RawFd};/// let raw_fd: RawFd = f.into_raw_fd();/// // SAFETY: no other functions should call `from_raw_fd`, so there/// // is only one owner for the file descriptor./// let f = unsafe { File::from_raw_fd(raw_fd) };/// A trait to express the ability to construct an object from a raw file/// Consumes this object, returning the raw underlying file descriptor./// This function is typically used to **transfer ownership** of the underlying/// file descriptor to the caller. When used in this way, callers are then the unique/// owners of the file descriptor and must close it once it's no longer needed./// However, transferring ownership is not strictly required. Use a/// [`Into<OwnedFd>::into`] implementation for an API which strictly/// transfers ownership./// use std::os::unix::io::{IntoRawFd, RawFd};/// use std::os::wasi::io::{IntoRawFd, RawFd};/// A trait to express the ability to consume an object and acquire ownership of/// its raw file descriptor.//! library/std/src/os/fd/raw.rs at revision//! Raw Unix-like file descriptors./// `ioctl(fd, TIOCEXCL)`—Enables exclusive mode on a terminal./// [Linux]: https://man7.org/linux/man-pages/man4/tty_ioctl.4.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=tty&sektion=4/// [NetBSD]: https://man.netbsd.org/tty.4/// [OpenBSD]: https://man.openbsd.org/tty.4/// `ioctl(fd, TIOCNXCL)`—Disables exclusive mode on a terminal./// `ioctl(fd, FIONBIO, &value)`—Enables or disables non-blocking mode./// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/winsock/winsock-ioctls#unix-ioctl-codes/// [NetBSD]: https://man.netbsd.org/ioctl.2#GENERIC%20IOCTLS/// [OpenBSD]: https://man.openbsd.org/ioctl.2#GENERIC_IOCTLS/// `ioctl(fd, FIONREAD)`—Returns the number of bytes ready to be read./// The result of this function gets silently coerced into a C `int`/// by the OS, so it may contain a wrapped value./// [Linux]: https://man7.org/linux/man-pages/man2/ioctl_tty.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=ioctl&sektion=2#GENERIC%09IOCTLS/// `ioctl(fd, BLKSSZGET)`—Returns the logical block size of a block device./// This is mentioned in the [Linux `openat` manual page]./// [Linux `openat` manual page]: https://man7.org/linux/man-pages/man2/openat.2.html/// `ioctl(fd, BLKPBSZGET)`—Returns the physical block size of a block device.SrcFd/// `ioctl(fd, FICLONE, src_fd)`—Share data between open files./// This ioctl is not available on Sparc platforms/// [Linux]: https://man7.org/linux/man-pages/man2/ioctl_ficlone.2.html/// `ioctl(fd, EXT4_IOC_RESIZE_FS, blocks)`—Resize ext4 filesystem on fd.//! The Unix `ioctl` function is effectively lots of different functions/// readable and/or writable, respectively./// Unlike [`is_file_read_write`], this correctly detects whether sockets/// have been shutdown, partially or completely./// [`is_file_read_write`]: crate::fs::is_file_read_write//! The [`is_read_write`] function.//! [`is_read_write`]: https://docs.rs/rustix/*/rustix/io/fn.is_read_write.htmlkevent_t// The layout varies between BSDs and macOS./// A `kqueue` event./// Create a new `Event`./// Get the event flags for this event./// Get the user data for this event./// Get the filter of this event.EVFILT_USER_FLAGS/// Bottom 24 bits of a u32./// A read filter./// A write filter./// An empty filter.vnode/// The file descriptor we looked for events in.VnodeEvents/// The flags for this event.Vnode/// A VNode filter./// The process ID we waited on.ProcessEventsProc/// A process filter./// The signal number we waited on./// The number of times the signal has been/// received since the last call to kevent./// A signal filter./// The identifier for this event./// The duration for this event./// A timer filter.UserFlagsuser_flagsUserDefinedFlags/// The user-defined flags for this event./// A user filter./// This filter is unknown./// Passing this into `Event::new()` will result in a panic./// The possible filters for a `kqueue`./// User-defined flags./// Only the lower 24 bits are used in this struct./// Create a new `UserDefinedFlags` from a `u32`./// Get the underlying `u32`./// `kqueue()`—Create a new `kqueue` file descriptor./// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/kqueue.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2/// [OpenBSD]: https://man.openbsd.org/kqueue.2/// [NetBSD]: https://man.netbsd.org/kqueue.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=kqueue&section=2/// `kevent(kqueue, changelist, eventlist, timeout)`—Wait for events on a/// `kqueue`./// Note: in order to receive events, make sure to allocate capacity in the/// eventlist! Otherwise, the function will return immediately./// The file descriptors referred to by the `Event` structs must be valid for/// the lifetime of the `kqueue` file descriptor./// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/kevent.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=kevent&sektion=2/// [OpenBSD]: https://man.openbsd.org/kevent.2/// [NetBSD]: https://man.netbsd.org/kevent.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=kevent&section=2//! An API for interfacing with `kqueue`.seek_fromstdio//! I/O operations./// `PIPE_BUF`—The maximum length at which writes to a pipe are atomic./// [Linux]: https://man7.org/linux/man-pages/man7/pipe.7.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html/// `pipe()`—Creates a pipe./// This function creates a pipe and returns two file descriptors, for the/// reading and writing ends of the pipe, respectively./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.html/// [Linux]: https://man7.org/linux/man-pages/man2/pipe.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/pipe.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=pipe&sektion=2/// [NetBSD]: https://man.netbsd.org/pipe.2/// [OpenBSD]: https://man.openbsd.org/pipe.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=pipe&section=2/// [illumos]: https://illumos.org/man/2/pipe/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Creating-a-Pipe.html/// `pipe2(flags)`—Creates a pipe, with flags./// [Linux]: https://man7.org/linux/man-pages/man2/pipe2.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=pipe2&sektion=2/// [NetBSD]: https://man.netbsd.org/pipe2.2/// [OpenBSD]: https://man.openbsd.org/pipe2.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=pipe2&section=2/// [illumos]: https://illumos.org/man/2/pipe2FdInFdOut/// `splice(fd_in, off_in, fd_out, off_out, len, flags)`—Transfer data between/// a file and a pipe./// This function transfers up to `len` bytes of data from the file descriptor/// `fd_in` to the file descriptor `fd_out`, where one of the file descriptors/// must refer to a pipe./// `off_*` must be `None` if the corresponding fd refers to a pipe./// Otherwise its value points to the starting offset to the file,/// from which the data is read/written./// on success the number of bytes read/written is added to the offset./// passing `None` causes the read/write to start from the file offset,/// and the file offset is adjusted appropriately./// [Linux]: https://man7.org/linux/man-pages/man2/splice.2.htmlPipeFd/// `vmsplice(fd, bufs, flags)`—Transfer data between memory and a pipe./// If `fd` is the write end of the pipe,/// the function maps the memory pointer at by `bufs` to the pipe./// If `fd` is the read end of the pipe,/// the function writes data from the pipe to said memory./// If the memory must not be mutated (such as when `bufs` were originally/// immutable slices), it is up to the caller to ensure that the write end of/// the pipe is placed in `fd`./// Additionally if `SpliceFlags::GIFT` is set, the caller must also ensure/// that the contents of `bufs` in never modified following the call,/// and that all of the pointers in `bufs` are page aligned,/// and the lengths are multiples of a page size in bytes./// [Linux]: https://man7.org/linux/man-pages/man2/vmsplice.2.html//! `pipe` and related APIs.//! `vmsplice` is an unsafe function./// `poll(self.fds, timeout)`/// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/slightly-advanced-techniques.html#poll/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/poll.html/// [Linux]: https://man7.org/linux/man-pages/man2/poll.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/poll.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsapoll/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=poll&sektion=2/// [NetBSD]: https://man.netbsd.org/poll.2/// [OpenBSD]: https://man.openbsd.org/poll.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=poll&section=2/// [illumos]: https://illumos.org/man/2/poll/// The structure representing a port event./// Get the events associated with this event./// Get the event source associated with this event./// Get the userdata associated with this event./// `port_create()`—Creates a new port.///  - [OpenSolaris]/// [OpenSolaris]: https://www.unix.com/man-page/opensolaris/3C/port_create//// [illumos]: https://illumos.org/man/3C/port_createport_associate_fd/// `port_associate(_, PORT_SOURCE_FD, _, _, _)`—Associates a file descriptor/// with a port./// Any `object`s passed into the `port` must be valid for the lifetime of the/// `port`. Logically, `port` keeps a borrowed reference to the `object` until/// it is removed via `port_dissociate_fd`./// [OpenSolaris]: https://www.unix.com/man-page/opensolaris/3C/port_associate//// [illumos]: https://illumos.org/man/3C/port_associateport_dissociate_fd/// `port_dissociate(_, PORT_SOURCE_FD, _)`—Dissociates a file descriptor from/// a port./// The file descriptor passed into this function must have been previously/// associated with the port via [`port_associate_fd`]./// [OpenSolaris]: https://www.unix.com/man-page/opensolaris/3C/port_dissociate/// [illumos]: https://illumos.org/man/3C/port_dissociate/// `port_get(port, timeout)`—Gets an event from a port./// [OpenSolaris]: https://www.unix.com/man-page/opensolaris/3C/port_get//// [illumos]: https://illumos.org/man/3C/port_get/// `port_getn(port, events, min_events, timeout)`—Gets multiple events from a/// port./// [OpenSolaris]: https://www.unix.com/man-page/opensolaris/3C/port_getn//// [illumos]: https://illumos.org/man/3C/port_getn/// `port_send(port, events, userdata)`—Sends an event to a port./// [OpenSolaris]: https://www.unix.com/man-page/opensolaris/3C/port_send//// [illumos]: https://illumos.org/man/3C/port_send//! Solaris/illumos event ports.PROC_ROOT_INO/// Linux's procfs always uses inode 1 for its root directory.// Identify an entry within "/proc", to determine which anomalies to check for.check_proc_entry/// Check a subdirectory of "/proc" for anomalies.check_proc_entry_with_stat/// Check a subdirectory of "/proc" for anomalies, using the provided `Stat`.check_proc_rootcheck_proc_subdircheck_proc_filecheck_proc_nonrootcheck_procfs/// Check that `file` is opened on a `procfs` filesystem.is_mountpoint/// Check whether the given directory handle is a mount point.proc_opendirat/// Open a directory in `/proc`, mapping all errors to `io::Errno::NOTSUP`./// Returns a handle to Linux's `/proc` directory./// This ensures that `/proc` is procfs, that nothing is mounted on top of it,/// and that it looks normal. It also returns the `Stat` of `/proc`./// [Linux]: https://man7.org/linux/man-pages/man5/proc.5.htmlproc_self/// Returns a handle to Linux's `/proc/self` directory./// This ensures that `/proc/self` is procfs, that nothing is mounted on top of/// it, and that it looks normal. It also returns the `Stat` of `/proc/self`.proc_self_fd/// Returns a handle to Linux's `/proc/self/fd` directory./// This ensures that `/proc/self/fd` is `procfs`, that nothing is mounted on/// top of it, and that it looks normal.StaticFdnew_static_fdproc_self_fdinfo/// Returns a handle to Linux's `/proc/self/fdinfo` directory./// This ensures that `/proc/self/fdinfo` is `procfs`, that nothing is mounted/// on top of it, and that it looks normal. It also returns the `Stat` of/// `/proc/self/fd`.proc_self_fdinfo_fd/// Returns a handle to a Linux `/proc/self/fdinfo/<fd>` file./// This ensures that `/proc/self/fdinfo/<fd>` is `procfs`, that nothing is/// mounted on top of it, and that it looks normal._proc_self_fdinfoproc_self_pagemap/// Returns a handle to a Linux `/proc/self/pagemap` file./// This ensures that `/proc/self/pagemap` is `procfs`, that nothing is///  - [Linux pagemap]/// [Linux pagemap]: https://www.kernel.org/doc/Documentation/vm/pagemap.txtproc_self_maps/// Returns a handle to a Linux `/proc/self/maps` file./// This ensures that `/proc/self/maps` is `procfs`, that nothing isproc_self_status/// Returns a handle to a Linux `/proc/self/status` file./// This ensures that `/proc/self/status` is `procfs`, that nothing isproc_self_file/// Open a file under `/proc/self`.open_and_check_file/// Open a procfs file within in `dir` and check it for bind mounts.//! Utilities for working with `/proc`, where Linux's `procfs` is typically//! mounted. `/proc` serves as an adjunct to Linux's main syscall surface area,//! providing additional features with an awkward interface.//! This module does a considerable amount of work to determine whether `/proc`//! is mounted, with actual `procfs`, and without any additional mount points//! on top of the paths we open.//! Why all the effort to detect bind mount points? People are doing all kinds//! of things with Linux containers these days, with many different privilege//! schemes, and we want to avoid making any unnecessary assumptions. Rustix//! and its users will sometimes use procfs *implicitly* (when Linux gives them//! no better options), in ways that aren't obvious from their public APIs.//! These filesystem accesses might not be visible to someone auditing the main//! code of an application for places which may be influenced by the filesystem//! namespace. So with the checking here, they may fail, but they won't be able//! to succeed with bogus results./// `read(fd, buf)`—Reads from a stream./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html/// [Linux]: https://man7.org/linux/man-pages/man2/read.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/read.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=read&sektion=2/// [NetBSD]: https://man.netbsd.org/read.2/// [OpenBSD]: https://man.openbsd.org/read.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=read&section=2/// [illumos]: https://illumos.org/man/2/read/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/I_002fO-Primitives.html#index-reading-from-a-file-descriptor/// `write(fd, buf)`—Writes to a stream./// [Linux]: https://man7.org/linux/man-pages/man2/write.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/write.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=write&sektion=2/// [NetBSD]: https://man.netbsd.org/write.2/// [OpenBSD]: https://man.openbsd.org/write.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=write&section=2/// [illumos]: https://illumos.org/man/2/write/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/I_002fO-Primitives.html#index-writing-to-a-file-descriptor/// `pread(fd, buf, offset)`—Reads from a file at a given position./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pread.html/// [Linux]: https://man7.org/linux/man-pages/man2/pread.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/pread.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=pread&sektion=2/// [NetBSD]: https://man.netbsd.org/pread.2/// [OpenBSD]: https://man.openbsd.org/pread.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=pread&section=2/// [illumos]: https://illumos.org/man/2/pread/// `pwrite(fd, bufs)`—Writes to a file at a given position./// Contrary to POSIX, on many popular platforms including Linux and FreeBSD,/// if the file is opened in append mode, this ignores the offset appends the/// data to the end of the file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pwrite.html/// [Linux]: https://man7.org/linux/man-pages/man2/pwrite.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/pwrite.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=pwrite&sektion=2/// [NetBSD]: https://man.netbsd.org/pwrite.2/// [OpenBSD]: https://man.openbsd.org/pwrite.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=pwrite&section=2/// [illumos]: https://illumos.org/man/2/pwrite/// `readv(fd, bufs)`—Reads from a stream into multiple buffers./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/readv.html/// [Linux]: https://man7.org/linux/man-pages/man2/readv.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/readv.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=readv&sektion=2/// [NetBSD]: https://man.netbsd.org/readv.2/// [OpenBSD]: https://man.openbsd.org/readv.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=readv&section=2/// [illumos]: https://illumos.org/man/2/readv/// `writev(fd, bufs)`—Writes to a stream from multiple buffers./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/writev.html/// [Linux]: https://man7.org/linux/man-pages/man2/writev.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/writev.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=writev&sektion=2/// [NetBSD]: https://man.netbsd.org/writev.2/// [OpenBSD]: https://man.openbsd.org/writev.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=writev&section=2/// [illumos]: https://illumos.org/man/2/writev/// `preadv(fd, bufs, offset)`—Reads from a file at a given position into/// multiple buffers./// [Linux]: https://man7.org/linux/man-pages/man2/preadv.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=preadv&sektion=2/// [NetBSD]: https://man.netbsd.org/preadv.2/// [OpenBSD]: https://man.openbsd.org/preadv.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=preadv&section=2/// [illumos]: https://illumos.org/man/2/preadv/// `pwritev(fd, bufs, offset)`—Writes to a file at a given position from/// [Linux]: https://man7.org/linux/man-pages/man2/pwritev.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=pwritev&sektion=2/// [NetBSD]: https://man.netbsd.org/pwritev.2/// [OpenBSD]: https://man.openbsd.org/pwritev.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=pwritev&section=2/// [illumos]: https://illumos.org/man/2/pwritev/// `preadv2(fd, bufs, offset, flags)`—Reads data, with several options./// An `offset` of `u64::MAX` means to use and update the current file offset./// [Linux]: https://man7.org/linux/man-pages/man2/preadv2.2.html/// `pwritev2(fd, bufs, offset, flags)`—Writes data, with several options./// [Linux]: https://man7.org/linux/man-pages/man2/pwritev2.2.html//! `read` and `write`, optionally positioned, optionally vectored/// Sets the offset to the provided number of bytes./// Sets the offset to the size of this object plus the specified number of/// It is possible to seek beyond the end of an object, but it's an error/// to seek before byte 0./// Sets the offset to the current position plus the specified number of/// Sets the offset to the current position plus the specified number of bytes,/// plus the distance to the next byte which is not in a hole./// If the offset is in a hole at the end of the file, the seek will produce/// an `NXIO` error./// plus the distance to the next byte which is in a hole./// If there is no hole past the offset, it will be set to the end of the file/// i.e. there is an implicit hole at the end of any file./// Enumeration of possible methods to seek within an I/O object./// It is used by the [`Seek`] trait./// [`Seek`]: std::io::Seek//! library/std/src/io/mod.rs at revision/// `STDIN_FILENO`—Standard input, borrowed./// In `std`-using configurations, this is a safe function, because the/// standard library already assumes that the stdin file descriptor is always/// valid. In `no_std` configurations, it is `unsafe`./// This function allows reading directly from stdin without coordinating/// with the buffering performed by [`std::io::Stdin`], so it could cause/// corrupted input./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/stdin.html/// [Linux]: https://man7.org/linux/man-pages/man3/stdin.3.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=stdin&sektion=4/// [NetBSD]: https://man.netbsd.org/stdin.4/// [OpenBSD]: https://man.openbsd.org/stdin.4/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=stdin&section=4/// [illumos]: https://illumos.org/man/4FS/stdin/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Standard-Streams.html#index-stdintake_stdin/// `STDIN_FILENO`—Standard input, owned./// This is similar to [`stdin`], however it returns an `OwnedFd` which closes/// standard input when it is dropped./// Safe `std`-using Rust code is permitted to assume that the stdin file/// descriptor is always valid. This function returns an `OwnedFd` which will/// close the stdin file descriptor when dropped./// This has the same hazards as [`stdin`]./// `STDOUT_FILENO`—Standard output, borrowed./// standard library already assumes that the stdout file descriptor is always/// This function allows reading directly from stdout without coordinating/// with the buffering performed by [`std::io::Stdout`], so it could cause/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/stdout.html/// [Linux]: https://man7.org/linux/man-pages/man3/stdout.3.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=stdout&sektion=4/// [NetBSD]: https://man.netbsd.org/stdout.4/// [OpenBSD]: https://man.openbsd.org/stdout.4/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=stdout&section=4/// [illumos]: https://illumos.org/man/4FS/stdout/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Standard-Streams.html#index-stdouttake_stdout/// `STDOUT_FILENO`—Standard output, owned./// This is similar to [`stdout`], however it returns an `OwnedFd` which closes/// standard output when it is dropped./// Safe `std`-using Rust code is permitted to assume that the stdout file/// close the stdout file descriptor when dropped./// This has the same hazards as [`stdout`]./// `STDERR_FILENO`—Standard error, borrowed./// standard library already assumes that the stderr file descriptor is always/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/stderr.html/// [Linux]: https://man7.org/linux/man-pages/man3/stderr.3.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=stderr&sektion=4/// [NetBSD]: https://man.netbsd.org/stderr.4/// [OpenBSD]: https://man.openbsd.org/stderr.4/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=stderr&section=4/// [illumos]: https://illumos.org/man/4FS/stderr/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Standard-Streams.html#index-stderrtake_stderr/// `STDERR_FILENO`—Standard error, owned./// This is similar to [`stderr`], however it returns an `OwnedFd` which closes/// Safe std-using Rust code is permitted to assume that the stderr file/// close the stderr file descriptor when dropped./// # Other hazards/// This has the same hazards as [`stderr`]./// And, when the `OwnedFd` is dropped, subsequent newly created file/// descriptors may unknowingly reuse the stderr file descriptor number, which/// may break common assumptions, so it should typically only be dropped at the/// end of a program when no more file descriptors will be created.raw_stdin/// `STDIN_FILENO`—Standard input, raw./// This is similar to [`stdin`], however it returns a `RawFd`.raw_stdout/// `STDOUT_FILENO`—Standard output, raw./// This is similar to [`stdout`], however it returns a `RawFd`.raw_stderr/// `STDERR_FILENO`—Standard error, raw./// This is similar to [`stderr`], however it returns a `RawFd`.dup2_stdin/// Utility function to safely `dup2` over stdin (fd 0).dup2_stdout/// Utility function to safely `dup2` over stdout (fd 1).dup2_stderr/// Utility function to safely `dup2` over stderr (fd 2).//! Functions returning the stdio file descriptors.//! These access the file descriptors by absolute index value, and nothing//! prevents them from being closed and reused. They should only be used in//! `main` or other situations where one is in control of the process'//! stdio streams./// `io_uring_setup(entries, params)`—Setup a context for performing/// asynchronous I/O./// [Linux]: https://man.archlinux.org/man/io_uring_setup.2.en/// `io_uring_register(fd, opcode, arg, nr_args)`—Register files or user/// buffers for asynchronous I/O./// io_uring operates on raw pointers and raw file descriptors. Users are/// responsible for ensuring that memory and resources are only accessed in/// valid ways./// [Linux]: https://man.archlinux.org/man/io_uring_register.2.en/// `io_uring_enter(fd, to_submit, min_complete, flags, arg, size)`—Initiate/// and/or complete asynchronous I/O./// [Linux]: https://man.archlinux.org/man/io_uring_enter.2.enRegisterBuffers/// `IORING_REGISTER_BUFFERS`UnregisterBuffers/// `IORING_UNREGISTER_BUFFERS`RegisterFiles/// `IORING_REGISTER_FILES`UnregisterFiles/// `IORING_UNREGISTER_FILES`RegisterEventfd/// `IORING_REGISTER_EVENTFD`UnregisterEventfd/// `IORING_UNREGISTER_EVENTFD`RegisterFilesUpdate/// `IORING_REGISTER_FILES_UPDATE`RegisterEventfdAsync/// `IORING_REGISTER_EVENTFD_ASYNC`RegisterProbe/// `IORING_REGISTER_PROBE`RegisterPersonality/// `IORING_REGISTER_PERSONALITY`UnregisterPersonality/// `IORING_UNREGISTER_PERSONALITY`RegisterRestrictions/// `IORING_REGISTER_RESTRICTIONS`RegisterEnableRings/// `IORING_REGISTER_ENABLE_RINGS`RegisterBuffers2/// `IORING_REGISTER_BUFFERS2`RegisterBuffersUpdate/// `IORING_REGISTER_BUFFERS_UPDATE`RegisterFiles2/// `IORING_REGISTER_FILES2`RegisterFilesSkip/// `IORING_REGISTER_FILES_SKIP`RegisterFilesUpdate2/// `IORING_REGISTER_FILES_UPDATE2`RegisterIowqAff/// `IORING_REGISTER_IOWQ_AFF`UnregisterIowqAff/// `IORING_UNREGISTER_IOWQ_AFF`RegisterIowqMaxWorkers/// `IORING_REGISTER_IOWQ_MAX_WORKERS`RegisterRingFds/// `IORING_REGISTER_RING_FDS`UnregisterRingFds/// `IORING_UNREGISTER_RING_FDS`RegisterPbufRing/// `IORING_REGISTER_PBUF_RING`UnregisterPbufRing/// `IORING_UNREGISTER_PBUF_RING`RegisterSyncCancel/// `IORING_REGISTER_SYNC_CANCEL`RegisterFileAllocRange/// `IORING_REGISTER_FILE_ALLOC_RANGE`/// `IORING_REGISTER_*` and `IORING_UNREGISTER_*` constants for use with/// [`io_uring_register`].IoringOp/// `IORING_OP_NOP`/// `IORING_OP_ACCEPT`AsyncCancel/// `IORING_OP_ASYNC_CANCEL`/// `IORING_OP_CLOSE`/// `IORING_OP_CONNECT`EpollCtl/// `IORING_OP_EPOLL_CTL`Fadvise/// `IORING_OP_FADVISE`Fallocate/// `IORING_OP_FALLOCATE`FilesUpdate/// `IORING_OP_FILES_UPDATE`Fsync/// `IORING_OP_FSYNC`Linkat/// `IORING_OP_LINKAT`LinkTimeout/// `IORING_OP_LINK_TIMEOUT`Madvise/// `IORING_OP_MADVISE`Mkdirat/// `IORING_OP_MKDIRAT`Openat/// `IORING_OP_OPENAT`Openat2/// `IORING_OP_OPENAT2`PollAdd/// `IORING_OP_POLL_ADD`PollRemove/// `IORING_OP_POLL_REMOVE`ProvideBuffers/// `IORING_OP_PROVIDE_BUFFERS`/// `IORING_OP_READ`Readv/// `IORING_OP_READV`ReadFixed/// `IORING_OP_READ_FIXED`/// `IORING_OP_RECV`Recvmsg/// `IORING_OP_RECVMSG`RemoveBuffers/// `IORING_OP_REMOVE_BUFFERS`Renameat/// `IORING_OP_RENAMEAT`/// `IORING_OP_SEND`Sendmsg/// `IORING_OP_SENDMSG`/// `IORING_OP_SHUTDOWN`/// `IORING_OP_SPLICE`/// `IORING_OP_STATX`Symlinkat/// `IORING_OP_SYMLINKAT`SyncFileRange/// `IORING_OP_SYNC_FILE_RANGE`/// `IORING_OP_TEE`/// `IORING_OP_TIMEOUT`TimeoutRemove/// `IORING_OP_TIMEOUT_REMOVE`Unlinkat/// `IORING_OP_UNLINKAT`/// `IORING_OP_WRITE`Writev/// `IORING_OP_WRITEV`WriteFixed/// `IORING_OP_WRITE_FIXED`MsgRing/// `IORING_OP_MSG_RING`Fsetxattr/// `IORING_OP_FSETXATTR`Setxattr/// `IORING_OP_SETXATTR`Fgetxattr/// `IORING_OP_FGETXATTR`Getxattr/// `IORING_OP_GETXATTR`/// `IORING_OP_SOCKET`UringCmd/// `IORING_OP_URING_CMD`SendZc/// `IORING_OP_SEND_ZC`SendmsgZc/// `IORING_OP_SENDMSG_ZC`/// `IORING_OP_*` constants for use with [`io_uring_sqe`].IoringRestrictionOpRegisterOp/// `IORING_RESTRICTION_REGISTER_OP`SqeFlagsAllowed/// `IORING_RESTRICTION_SQE_FLAGS_ALLOWED`SqeFlagsRequired/// `IORING_RESTRICTION_SQE_FLAGS_REQUIRED`SqeOp/// `IORING_RESTRICTION_SQE_OP`/// `IORING_RESTRICTION_*` constants for use with [`io_uring_restriction`].IoringMsgringCmds/// `IORING_MSG_DATA`SendFd/// `IORING_MSG_SEND_FD`/// `IORING_MSG_*` constants which represent commands for use with/// [`IoringOp::MsgRing`], (`seq.addr`)// Re-export these as `u64`, which is the `offset` type in `rustix::io::mmap`.io_uring_register_files_skip/// `IORING_NOTIF_USAGE_ZC_COPIED` (since Linux 6.2)__pad32__pad16/// The pointer value.io_uring_ptr/// A pointer in the io_uring API./// `io_uring`'s native API represents pointers as `u64` values. In order to/// preserve strict-provenance, use a `*mut c_void`. On platforms where/// pointers are narrower than 64 bits, this requires additional padding.io_uring_user_data/// An arbitrary `u64`./// A pointer./// User data in the io_uring API./// `io_uring`'s native API represents `user_data` fields as `u64` values. In/// order to preserve strict-provenance, use a union which allows users to/// optionally store pointers./// Return the `u64` value./// Create a `Self` from a `u64` value./// Return the `ptr` pointer value./// Create a `Self` from a pointer value.IoringSqeFlagsioprio_unionoff_or_addr2off_or_addr2_unionaddr_or_splice_off_inaddr_or_splice_off_in_unionlen_unionop_flagsop_flags_unionbuf_unionsplice_fd_in_or_file_indexsplice_fd_in_or_file_index_unionaddr3_or_cmdaddr3_or_cmd_union/// An io_uring Submission Queue Entry.recv_flagsIoringRecvFlagssend_flagsIoringSendFlagsIoringAcceptFlagsIoringPollFlagsaddr3_structcmd_op_structmsgring_cmdIoringFsyncFlags/// `msg_flags` is split into `send_flags` and `recv_flags`.IoringTimeoutFlagsIoringAsyncCancelFlagsIoringMsgringFlagsIoringCqeFlags/// An io_uring Completion Queue Entry.register_or_sqe_op_or_sqe_flagsregister_or_sqe_op_or_sqe_flags_unionIoringSetupFlagsIoringFeatureFlagsIoringOpFlagsIoringRsrcFlagsRecvmsgOutFlags/// An [`OFlags`] value represented as a `u64`./// [`OFlags`]: crate::fs::OFlags/// A [`Mode`] value represented as a `u64`./// [`Mode`]: crate::fs::Mode3_usizeio_uring_layouts/// Check that our custom structs and unions have the same layout as the/// kernel's versions.//! Linux [io_uring].//! This API is very low-level. The main adaptations it makes from the raw//! Linux io_uring API are the use of appropriately-sized `bitflags`, `enum`,//! `Result`, `OwnedFd`, `AsFd`, `RawFd`, and `*mut c_void` in place of plain//! integers.//! For a higher-level API built on top of this, see the [rustix-uring] crate.//! io_uring operates on raw pointers and raw file descriptors. Rustix does not//! attempt to provide a safe API for these, because the abstraction level is//! too low for this to be practical. Safety should be introduced in//! higher-level abstraction layers.//!  - [Linux]//!  - [io_uring header]//! [Linux]: https://man.archlinux.org/man/io_uring.7.en//! [io_uring]: https://en.wikipedia.org/wiki/Io_uring//! [io_uring header]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/io_uring.h//! [rustix-uring]: https://crates.io/crates/rustix-uring// Internal utilities.// Pick the backend implementation to use./// Export the `*Fd` types and traits that are used in rustix's public API./// Users can use this to avoid needing to import anything else to use the same/// versions of these types and traits.// The public API modules.//! `rustix` provides efficient memory-safe and [I/O-safe] wrappers to//! POSIX-like, Unix-like, Linux, and Winsock2 syscall-like APIs, with//! configurable backends.//! With rustix, you can write code like this://! # fn read(sock: std::net::TcpStream, buf: &mut [u8]) -> std::io::Result<()> {//! # use rustix::net::RecvFlags;//! let nread: usize = rustix::net::recv(&sock, buf, RecvFlags::PEEK)?;//! # let _ = nread;//! instead of like this://! # #[cfg(target_os = "wasi")]//! # use std::os::wasi::io::AsRawFd;//! # use windows_sys::Win32::Networking::WinSock as libc;//! # use std::os::windows::io::AsRawSocket;//! # const MSG_PEEK: i32 = libc::MSG_PEEK;//! let nread: usize = unsafe {//!     #[cfg(any(unix, target_os = "wasi"))]//!     let raw = sock.as_raw_fd();//!     #[cfg(windows)]//!     let raw = sock.as_raw_socket();//!     match libc::recv(//!         raw as _,//!         buf.as_mut_ptr().cast(),//!         buf.len().try_into().unwrap_or(i32::MAX as _),//!         MSG_PEEK,//!     ) {//!         -1 => return Err(std::io::Error::last_os_error()),//!         nread => nread as usize,//! rustix's APIs perform the following tasks://!  - Error values are translated to [`Result`]s.//!  - Buffers are passed as Rust slices.//!  - Out-parameters are presented as return values.//!  - Path arguments use [`Arg`], so they accept any string type.//!  - File descriptors are passed and returned via [`AsFd`] and [`OwnedFd`]//!    instead of bare integers, ensuring I/O safety.//!  - Constants use `enum`s and [`bitflags`] types.//!  - Multiplexed functions (eg. `fcntl`, `ioctl`, etc.) are de-multiplexed.//!  - Variadic functions (eg. `openat`, etc.) are presented as non-variadic.//!  - Functions that return strings automatically allocate sufficient memory//!    and retry the syscall as needed to determine the needed length.//!  - Functions and types which need `l` prefixes or `64` suffixes to enable//!    large-file support (LFS) are used automatically. File sizes and offsets//!    are always presented as `u64` and `i64`.//!  - Behaviors that depend on the sizes of C types like `long` are hidden.//!  - In some places, more human-friendly and less historical-accident names//!    are used (and documentation aliases are used so that the original names//!    can still be searched for).//!  - Provide y2038 compatibility, on platforms which support this.//!  - Correct selected platform bugs, such as behavioral differences when//!    running under seccomp.//! Things they don't do include://!  - Detecting whether functions are supported at runtime, except in specific//!    cases where new interfaces need to be detected to support y2038 and LFS.//!  - Hiding significant differences between platforms.//!  - Restricting ambient authorities.//!  - Imposing sandboxing features such as filesystem path or network address//!    sandboxing.//! See [`cap-std`], [`system-interface`], and [`io-streams`] for libraries//! which do hide significant differences between platforms, and [`cap-std`]//! which does perform sandboxing and restricts ambient authorities.//! [`cap-std`]: https://crates.io/crates/cap-std//! [`system-interface`]: https://crates.io/crates/system-interface//! [`io-streams`]: https://crates.io/crates/io-streams//! [`bitflags`]: https://crates.io/crates/bitflags//! [`AsFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsFd.html//! [`OwnedFd`]: https://doc.rust-lang.org/stable/std/os/fd/struct.OwnedFd.html//! [I/O-safe]: https://github.com/rust-lang/rfcs/blob/master/text/3128-io-safety.md//! [`Result`]: https://doc.rust-lang.org/stable/std/result/enum.Result.html//! [`Arg`]: https://docs.rs/rustix/*/rustix/path/trait.Arg.html// Clamp depends on Rust 1.50 which is newer than our MSRV.// It is common in linux and libc APIs for types to vary between platforms.// Redox and WASI have enough differences that it isn't worth// precisely conditionallizing all the `use`s for them.// On the release branch, don't worry about unused-import warnings.// We have some internal interdependencies in the API features, so for now,// for API features that aren't enabled, declare them as `pub(crate)` so// that they're not public, but still available for internal use./// `posix_madvise(addr, len, advice)`—Declares an expected access pattern/// for a memory-mapped file./// `addr` must be a valid pointer to memory that is appropriate to/// call `posix_madvise` on. Some forms of `advice` may mutate the memory/// or evoke a variety of side-effects on the mapping and/or the file.///  - [Linux `madvise`]///  - [Linux `posix_madvise`]/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_madvise.html/// [Linux `madvise`]: https://man7.org/linux/man-pages/man2/madvise.2.html/// [Linux `posix_madvise`]: https://man7.org/linux/man-pages/man3/posix_madvise.3.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/madvise.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=madvise&sektion=2/// [NetBSD]: https://man.netbsd.org/madvise.2/// [OpenBSD]: https://man.openbsd.org/madvise.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=madvise&section=2/// [illumos]: https://illumos.org/man/3C/madvise/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Memory_002dmapped-I_002fO.html#index-madvise//! The `madvise` function.//! `madvise` operates on a raw pointer. Some forms of `madvise` may//! mutate the memory or have other side effects./// `mmap(ptr, len, prot, flags, fd, offset)`—Create a file-backed memory/// mapping./// For anonymous mappings (`MAP_ANON`/`MAP_ANONYMOUS`), see/// [`mmap_anonymous`]./// Raw pointers and lots of special semantics./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mmap.html/// [Linux]: https://man7.org/linux/man-pages/man2/mmap.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/mmap.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=mmap&sektion=2/// [NetBSD]: https://man.netbsd.org/mmap.2/// [OpenBSD]: https://man.openbsd.org/mmap.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=mmap&section=2/// [illumos]: https://illumos.org/man/2/mmap/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Memory_002dmapped-I_002fO.html#index-mmap/// `mmap(ptr, len, prot, MAP_ANONYMOUS | flags, -1, 0)`—Create an anonymous/// memory mapping./// For file-backed mappings, see [`mmap`]./// `munmap(ptr, len)`—Remove a memory mapping./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/munmap.html/// [Linux]: https://man7.org/linux/man-pages/man2/munmap.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/munmap.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=munmap&sektion=2/// [NetBSD]: https://man.netbsd.org/munmap.2/// [OpenBSD]: https://man.openbsd.org/munmap.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=munmap&section=2/// [illumos]: https://illumos.org/man/2/munmap/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Memory_002dmapped-I_002fO.html#index-munmap/// `mremap(old_address, old_size, new_size, flags)`—Resize, modify,/// and/or move a memory mapping./// For moving a mapping to a fixed address (`MREMAP_FIXED`), see/// [`mremap_fixed`]./// [Linux]: https://man7.org/linux/man-pages/man2/mremap.2.html/// `mremap(old_address, old_size, new_size, MREMAP_FIXED | flags)`—Resize,/// modify, and/or move a memory mapping to a specific address./// For `mremap` without moving to a specific address, see [`mremap`]./// `mprotect(ptr, len, flags)`—Change the protection flags of a region of/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mprotect.html/// [Linux]: https://man7.org/linux/man-pages/man2/mprotect.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/mprotect.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=mprotect&sektion=2/// [NetBSD]: https://man.netbsd.org/mprotect.2/// [OpenBSD]: https://man.openbsd.org/mprotect.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=mprotect&section=2/// [illumos]: https://illumos.org/man/2/mprotect/// `mlock(ptr, len)`—Lock memory into RAM./// This function operates on raw pointers, but it should only be used on/// memory which the caller owns. Technically, locking memory shouldn't violate/// any invariants, but since unlocking it can violate invariants, this/// function is also unsafe for symmetry./// Some implementations implicitly round the memory region out to the nearest/// page boundaries, so this function may lock more memory than explicitly/// requested if the memory isn't page-aligned./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mlock.html/// [Linux]: https://man7.org/linux/man-pages/man2/mlock.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/mlock.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=mlock&sektion=2/// [NetBSD]: https://man.netbsd.org/mlock.2/// [OpenBSD]: https://man.openbsd.org/mlock.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=mlock&section=2/// [illumos]: https://illumos.org/man/3C/mlock/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Page-Lock-Functions.html#index-mlock/// `mlock2(ptr, len, flags)`—Lock memory into RAM, with flags./// `mlock_with` is the same as [`mlock`] but adds an additional flags operand./// [Linux]: https://man7.org/linux/man-pages/man2/mlock2.2.html/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Page-Lock-Functions.html#index-mlock2/// `munlock(ptr, len)`—Unlock memory./// memory which the caller owns, to avoid compromising the `mlock` invariants/// of other unrelated code in the process./// page boundaries, so this function may unlock more memory than explicitly/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/munlock.html/// [Linux]: https://man7.org/linux/man-pages/man2/munlock.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/munlock.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=munlock&sektion=2/// [NetBSD]: https://man.netbsd.org/munlock.2/// [OpenBSD]: https://man.openbsd.org/munlock.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=munlock&section=2/// [illumos]: https://illumos.org/man/3C/munlock/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Page-Lock-Functions.html#index-munlock//! The `mmap` API.//! `mmap` and related functions manipulate raw pointers and have special//! semantics and are wildly unsafe.//! Memory map operations./// `msync(addr, len, flags)`—Synchronizes a memory-mapping with its backing/// call `msync` on. Some forms of `msync` may mutate the memory/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/msync.html/// [Linux]: https://man7.org/linux/man-pages/man2/msync.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/msync.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=msync&sektion=2/// [NetBSD]: https://man.netbsd.org/msync.2/// [OpenBSD]: https://man.openbsd.org/msync.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=msync&section=2/// [illumos]: https://illumos.org/man/3C/msync/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Memory_002dmapped-I_002fO.html#index-msync//! The `msync` function.//! `msync` operates on a raw pointer. Some forms of `msync` may mutate the//! memory or have other side effects./// `userfaultfd(flags)`/// The call itself is safe, but the returned file descriptor lets users/// observe and manipulate process memory in magical ways.///  - [Linux userfaultfd]/// [Linux]: https://man7.org/linux/man-pages/man2/userfaultfd.2.html/// [Linux userfaultfd]: https://www.kernel.org/doc/Documentation/vm/userfaultfd.txt//! The Linux `userfaultfd` API.//! Calling `userfaultfd` is safe, but the returned file descriptor lets users//! observe and manipulate process memory in magical ways./// An IPv4 socket address./// An IPv6 socket address./// An internet socket address, either IPv4 or IPv6./// Internet socket addresses consist of an [IP address], a 16-bit port number, as well/// as possibly some version-dependent additional information. See [`SocketAddrV4`]'s and/// [`SocketAddrV6`]'s respective documentation for more details./// The size of a `SocketAddr` instance may vary depending on the target operating/// system./// [IP address]: IpAddr/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};/// let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);/// assert_eq!("127.0.0.1:8080".parse(), Ok(socket));/// assert_eq!(socket.port(), 8080);/// assert_eq!(socket.is_ipv4(), true);/// IPv4 socket addresses consist of an [`IPv4` address] and a 16-bit port number, as/// stated in [IETF RFC 793]./// See [`SocketAddr`] for a type encompassing both IPv4 and IPv6 socket addresses./// The size of a `SocketAddrV4` struct may vary depending on the target operating/// system. Do not assume that this type has the same memory layout as the underlying/// system representation./// [IETF RFC 793]: https://tools.ietf.org/html/rfc793/// [`IPv4` address]: Ipv4Addr/// use std::net::{Ipv4Addr, SocketAddrV4};/// let socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);/// assert_eq!(socket.ip(), &Ipv4Addr::new(127, 0, 0, 1));/// IPv6 socket addresses consist of an [`IPv6` address], a 16-bit port number, as well/// as fields containing the traffic class, the flow label, and a scope identifier/// (see [IETF RFC 2553, Section 3.3] for more details)./// The size of a `SocketAddrV6` struct may vary depending on the target operating/// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3/// [`IPv6` address]: Ipv6Addr/// use std::net::{Ipv6Addr, SocketAddrV6};/// let socket = SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0);/// assert_eq!("[2001:db8::1]:8080".parse(), Ok(socket));/// assert_eq!(socket.ip(), &Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));/// Creates a new socket address from an [IP address] and a port number./// assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));/// Changes the IP address associated with this socket address./// let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);/// socket.set_ip(IpAddr::V4(Ipv4Addr::new(10, 10, 0, 1)));/// assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(10, 10, 0, 1)));/// Returns the port number associated with this socket address./// Changes the port number associated with this socket address./// socket.set_port(1025);/// assert_eq!(socket.port(), 1025);is_ipv4/// Returns [`true`] if the [IP address] in this `SocketAddr` is an/// [`IPv4` address], and [`false`] otherwise./// [`IPv4` address]: IpAddr::V4/// assert_eq!(socket.is_ipv6(), false);is_ipv6/// [`IPv6` address], and [`false`] otherwise./// [`IPv6` address]: IpAddr::V6/// use std::net::{IpAddr, Ipv6Addr, SocketAddr};/// let socket = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 65535, 0, 1)), 8080);/// assert_eq!(socket.is_ipv4(), false);/// assert_eq!(socket.is_ipv6(), true);/// Creates a new socket address from an [`IPv4` address] and a port number./// use std::net::{SocketAddrV4, Ipv4Addr};/// let mut socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);/// socket.set_ip(Ipv4Addr::new(192, 168, 0, 1));/// assert_eq!(socket.ip(), &Ipv4Addr::new(192, 168, 0, 1));/// socket.set_port(4242);/// assert_eq!(socket.port(), 4242);/// Creates a new socket address from an [`IPv6` address], a 16-bit port number,/// and the `flowinfo` and `scope_id` fields./// For more information on the meaning and layout of the `flowinfo` and `scope_id`/// parameters, see [IETF RFC 2553, Section 3.3]./// use std::net::{SocketAddrV6, Ipv6Addr};/// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);/// assert_eq!(socket.ip(), &Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));/// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);/// socket.set_ip(Ipv6Addr::new(76, 45, 0, 0, 0, 0, 0, 0));/// assert_eq!(socket.ip(), &Ipv6Addr::new(76, 45, 0, 0, 0, 0, 0, 0));/// This information corresponds to the `sin6_flowinfo` field in C's `netinet/in.h`,/// as specified in [IETF RFC 2553, Section 3.3]./// It combines information about the flow label and the traffic class as specified/// in [IETF RFC 2460], respectively [Section 6] and [Section 7]./// [IETF RFC 2460]: https://tools.ietf.org/html/rfc2460/// [Section 6]: https://tools.ietf.org/html/rfc2460#section-6/// [Section 7]: https://tools.ietf.org/html/rfc2460#section-7/// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 10, 0);/// assert_eq!(socket.flowinfo(), 10);set_flowinfo/// Changes the flow information associated with this socket address./// See [`SocketAddrV6::flowinfo`]'s documentation for more details./// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 10, 0);/// socket.set_flowinfo(56);/// assert_eq!(socket.flowinfo(), 56);/// This information corresponds to the `sin6_scope_id` field in C's `netinet/in.h`,/// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 78);/// assert_eq!(socket.scope_id(), 78);set_scope_id/// Changes the scope ID associated with this socket address./// See [`SocketAddrV6::scope_id`]'s documentation for more details./// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 78);/// socket.set_scope_id(42);/// assert_eq!(socket.scope_id(), 42);/// Converts a [`SocketAddrV4`] into a [`SocketAddr::V4`]./// Converts a [`SocketAddrV6`] into a [`SocketAddr::V6`]./// Converts a tuple struct (Into<[`IpAddr`]>, `u16`) into a [`SocketAddr`]./// This conversion creates a [`SocketAddr::V4`] for an [`IpAddr::V4`]/// and creates a [`SocketAddr::V6`] for an [`IpAddr::V6`]./// `u16` is treated as port of the newly created [`SocketAddr`].//! library/std/src/net/socket_addr.rs at revision//! bd20fc1fd657b32f7aa1d70d8723f04c87f21606.//! All code in this file is licensed MIT or Apache 2.0 at your option.//! This defines `SocketAddr`, `SocketAddrV4`, and `SocketAddrV6` in a//! platform-independent way. It is not the native representation./// An IPv4 address./// An IPv6 address./// An IP address, either IPv4 or IPv6./// This enum can contain either an [`Ipv4Addr`] or an [`Ipv6Addr`], see their/// respective documentation for more details./// let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));/// let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));/// assert_eq!("127.0.0.1".parse(), Ok(localhost_v4));/// assert_eq!("::1".parse(), Ok(localhost_v6));/// assert_eq!(localhost_v4.is_ipv6(), false);/// assert_eq!(localhost_v4.is_ipv4(), true);/// IPv4 addresses are defined as 32-bit integers in [IETF RFC 791]./// They are usually represented as four octets./// See [`IpAddr`] for a type encompassing both IPv4 and IPv6 addresses./// [IETF RFC 791]: https://tools.ietf.org/html/rfc791/// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal/// notation, divided by `.` (this is called "dot-decimal notation")./// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which/// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]./// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1/// let localhost = Ipv4Addr::new(127, 0, 0, 1);/// assert_eq!("127.0.0.1".parse(), Ok(localhost));/// assert_eq!(localhost.is_loopback(), true);/// assert!("012.004.002.000".parse::<Ipv4Addr>().is_err()); // all octets are in octal/// assert!("0000000.0.0.0".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal/// assert!("0xcb.0x0.0x71.0x00".parse::<Ipv4Addr>().is_err()); // all octets are in hex/// IPv6 addresses are defined as 128-bit integers in [IETF RFC 4291]./// They are usually represented as eight 16-bit segments./// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291/// # Embedding IPv4 Addresses/// To assist in the transition from IPv4 to IPv6 two types of IPv6 addresses that embed an IPv4 address were defined:/// IPv4-compatible and IPv4-mapped addresses. Of these IPv4-compatible addresses have been officially deprecated./// Both types of addresses are not assigned any special meaning by this implementation,/// other than what the relevant standards prescribe. This means that an address like `::ffff:127.0.0.1`,/// while representing an IPv4 loopback address, is not itself an IPv6 loopback address; only `::1` is./// To handle these so called "IPv4-in-IPv6" addresses, they have to first be converted to their canonical IPv4 address./// ### IPv4-Compatible IPv6 Addresses/// IPv4-compatible IPv6 addresses are defined in [IETF RFC 4291 Section 2.5.5.1], and have been officially deprecated./// The RFC describes the format of an "IPv4-Compatible IPv6 address" as follows:/// |                80 bits               | 16 |      32 bits        |/// +--------------------------------------+--------------------------+/// |0000..............................0000|0000|    IPv4 address     |/// +--------------------------------------+----+---------------------+/// So `::a.b.c.d` would be an IPv4-compatible IPv6 address representing the IPv4 address `a.b.c.d`./// To convert from an IPv4 address to an IPv4-compatible IPv6 address, use [`Ipv4Addr::to_ipv6_compatible`]./// Use [`Ipv6Addr::to_ipv4`] to convert an IPv4-compatible IPv6 address to the canonical IPv4 address./// [IETF RFC 4291 Section 2.5.5.1]: https://datatracker.ietf.org/doc/html/rfc4291#section-2.5.5.1/// ### IPv4-Mapped IPv6 Addresses/// IPv4-mapped IPv6 addresses are defined in [IETF RFC 4291 Section 2.5.5.2]./// The RFC describes the format of an "IPv4-Mapped IPv6 address" as follows:/// |0000..............................0000|FFFF|    IPv4 address     |/// So `::ffff:a.b.c.d` would be an IPv4-mapped IPv6 address representing the IPv4 address `a.b.c.d`./// To convert from an IPv4 address to an IPv4-mapped IPv6 address, use [`Ipv4Addr::to_ipv6_mapped`]./// Use [`Ipv6Addr::to_ipv4`] to convert an IPv4-mapped IPv6 address to the canonical IPv4 address./// Note that this will also convert the IPv6 loopback address `::1` to `0.0.0.1`. Use/// [`Ipv6Addr::to_ipv4_mapped`] to avoid this./// [IETF RFC 4291 Section 2.5.5.2]: https://datatracker.ietf.org/doc/html/rfc4291#section-2.5.5.2/// `Ipv6Addr` provides a [`FromStr`] implementation. There are many ways to represent/// an IPv6 address in text, but in general, each segments is written in hexadecimal/// notation, and segments are separated by `:`. For more information, see/// [IETF RFC 5952]./// [IETF RFC 5952]: https://tools.ietf.org/html/rfc5952/// let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);/// assert_eq!("::1".parse(), Ok(localhost));Ipv6MulticastScopeInterfaceLocal/// Interface-Local scope.LinkLocal/// Link-Local scope.RealmLocal/// Realm-Local scope.AdminLocal/// Admin-Local scope.SiteLocal/// Site-Local scope.OrganizationLocal/// Organization-Local scope./// Global scope./// Scope of an [IPv6 multicast address] as defined in [IETF RFC 7346 section 2]./// # Stability Guarantees/// Not all possible values for a multicast scope have been assigned./// Future RFCs may introduce new scopes, which will be added as variants to this enum;/// because of this the enum is marked as `#[non_exhaustive]`./// #![feature(ip)]/// use std::net::Ipv6MulticastScope::*;/// // An IPv6 multicast address with global scope (`ff0e::`)./// let address = Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0);/// // Will print "Global scope"./// match address.multicast_scope() {///     Some(InterfaceLocal) => println!("Interface-Local scope"),///     Some(LinkLocal) => println!("Link-Local scope"),///     Some(RealmLocal) => println!("Realm-Local scope"),///     Some(AdminLocal) => println!("Admin-Local scope"),///     Some(SiteLocal) => println!("Site-Local scope"),///     Some(OrganizationLocal) => println!("Organization-Local scope"),///     Some(Global) => println!("Global scope"),///     Some(_) => println!("Unknown scope"),///     None => println!("Not a multicast address!")/// [IPv6 multicast address]: Ipv6Addr/// [IETF RFC 7346 section 2]: https://tools.ietf.org/html/rfc7346#section-2/// Returns [`true`] for the special 'unspecified' address./// See the documentation for [`Ipv4Addr::is_unspecified()`] and/// [`Ipv6Addr::is_unspecified()`] for more details./// assert_eq!(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)).is_unspecified(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)).is_unspecified(), true);/// Returns [`true`] if this is a loopback address./// See the documentation for [`Ipv4Addr::is_loopback()`] and/// [`Ipv6Addr::is_loopback()`] for more details./// assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).is_loopback(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1)).is_loopback(), true);/// Returns [`true`] if the address appears to be globally routable./// See the documentation for [`Ipv4Addr::is_global()`] and/// [`Ipv6Addr::is_global()`] for more details./// assert_eq!(IpAddr::V4(Ipv4Addr::new(80, 9, 12, 3)).is_global(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1)).is_global(), true);/// Returns [`true`] if this is a multicast address./// See the documentation for [`Ipv4Addr::is_multicast()`] and/// [`Ipv6Addr::is_multicast()`] for more details./// assert_eq!(IpAddr::V4(Ipv4Addr::new(224, 254, 0, 0)).is_multicast(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0)).is_multicast(), true);is_documentation/// Returns [`true`] if this address is in a range designated for documentation./// See the documentation for [`Ipv4Addr::is_documentation()`] and/// [`Ipv6Addr::is_documentation()`] for more details./// assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_documentation(), true);///     IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_documentation(),is_benchmarking/// Returns [`true`] if this address is in a range designated for benchmarking./// See the documentation for [`Ipv4Addr::is_benchmarking()`] and/// [`Ipv6Addr::is_benchmarking()`] for more details./// assert_eq!(IpAddr::V4(Ipv4Addr::new(198, 19, 255, 255)).is_benchmarking(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0x2, 0, 0, 0, 0, 0, 0)).is_benchmarking(), true);/// Returns [`true`] if this address is an [`IPv4` address], and [`false`]/// assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv4(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv4(), false);/// Returns [`true`] if this address is an [`IPv6` address], and [`false`]/// assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv6(), false);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv6(), true);"this returns the result of the operation, \
                  without modifying the original"/// Converts this address to an `IpAddr::V4` if it is an IPv4-mapped IPv6 addresses, otherwise it/// return `self` as-is./// assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).to_canonical().is_loopback(), true);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).is_loopback(), false);/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).to_canonical().is_loopback(), true);/// Creates a new IPv4 address from four eight-bit octets./// The result will represent the IP address `a`.`b`.`c`.`d`./// let addr = Ipv4Addr::new(127, 0, 0, 1);LOCALHOST/// An IPv4 address with the address pointing to localhost: `127.0.0.1`/// let addr = Ipv4Addr::LOCALHOST;/// assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));/// An IPv4 address representing an unspecified address: `0.0.0.0`/// This corresponds to the constant `INADDR_ANY` in other languages./// let addr = Ipv4Addr::UNSPECIFIED;/// assert_eq!(addr, Ipv4Addr::new(0, 0, 0, 0));BROADCAST/// An IPv4 address representing the broadcast address: `255.255.255.255`/// let addr = Ipv4Addr::BROADCAST;/// assert_eq!(addr, Ipv4Addr::new(255, 255, 255, 255));/// Returns the four eight-bit integers that make up this address./// assert_eq!(addr.octets(), [127, 0, 0, 1]);/// Returns [`true`] for the special 'unspecified' address (`0.0.0.0`)./// This property is defined in _UNIX Network Programming, Second Edition_,/// W. Richard Stevens, p. 891; see also [ip7]./// [ip7]: https://man7.org/linux/man-pages/man7/ip.7.html/// assert_eq!(Ipv4Addr::new(0, 0, 0, 0).is_unspecified(), true);/// assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_unspecified(), false);/// Returns [`true`] if this is a loopback address (`127.0.0.0/8`)./// This property is defined by [IETF RFC 1122]./// [IETF RFC 1122]: https://tools.ietf.org/html/rfc1122/// assert_eq!(Ipv4Addr::new(127, 0, 0, 1).is_loopback(), true);/// assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_loopback(), false);/// Returns [`true`] if this is a private address./// The private address ranges are defined in [IETF RFC 1918] and include:///  - `10.0.0.0/8`///  - `172.16.0.0/12`///  - `192.168.0.0/16`/// [IETF RFC 1918]: https://tools.ietf.org/html/rfc1918/// assert_eq!(Ipv4Addr::new(10, 0, 0, 1).is_private(), true);/// assert_eq!(Ipv4Addr::new(10, 10, 10, 10).is_private(), true);/// assert_eq!(Ipv4Addr::new(172, 16, 10, 10).is_private(), true);/// assert_eq!(Ipv4Addr::new(172, 29, 45, 14).is_private(), true);/// assert_eq!(Ipv4Addr::new(172, 32, 0, 2).is_private(), false);/// assert_eq!(Ipv4Addr::new(192, 168, 0, 2).is_private(), true);/// assert_eq!(Ipv4Addr::new(192, 169, 0, 2).is_private(), false);/// Returns [`true`] if the address is link-local (`169.254.0.0/16`)./// This property is defined by [IETF RFC 3927]./// [IETF RFC 3927]: https://tools.ietf.org/html/rfc3927/// assert_eq!(Ipv4Addr::new(169, 254, 0, 0).is_link_local(), true);/// assert_eq!(Ipv4Addr::new(169, 254, 10, 65).is_link_local(), true);/// assert_eq!(Ipv4Addr::new(16, 89, 10, 65).is_link_local(), false);/// Returns [`true`] if the address appears to be globally reachable/// as specified by the [IANA IPv4 Special-Purpose Address Registry]./// Whether or not an address is practically reachable will depend on your network configuration./// Most IPv4 addresses are globally reachable;/// unless they are specifically defined as *not* globally reachable./// Non-exhaustive list of notable addresses that are not globally reachable:/// - The [unspecified address] ([`is_unspecified`](Ipv4Addr::is_unspecified))/// - Addresses reserved for private use ([`is_private`](Ipv4Addr::is_private))/// - Addresses in the shared address space ([`is_shared`](Ipv4Addr::is_shared))/// - Loopback addresses ([`is_loopback`](Ipv4Addr::is_loopback))/// - Link-local addresses ([`is_link_local`](Ipv4Addr::is_link_local))/// - Addresses reserved for documentation ([`is_documentation`](Ipv4Addr::is_documentation))/// - Addresses reserved for benchmarking ([`is_benchmarking`](Ipv4Addr::is_benchmarking))/// - Reserved addresses ([`is_reserved`](Ipv4Addr::is_reserved))/// - The [broadcast address] ([`is_broadcast`](Ipv4Addr::is_broadcast))/// For the complete overview of which addresses are globally reachable, see the table at the [IANA IPv4 Special-Purpose Address Registry]./// [IANA IPv4 Special-Purpose Address Registry]: https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml/// [unspecified address]: Ipv4Addr::UNSPECIFIED/// [broadcast address]: Ipv4Addr::BROADCAST/// // Most IPv4 addresses are globally reachable:/// assert_eq!(Ipv4Addr::new(80, 9, 12, 3).is_global(), true);/// // However some addresses have been assigned a special meaning/// // that makes them not globally reachable. Some examples are:/// // The unspecified address (`0.0.0.0`)/// assert_eq!(Ipv4Addr::UNSPECIFIED.is_global(), false);/// // Addresses reserved for private use (`10.0.0.0/8`, `172.16.0.0/12`, 192.168.0.0/16)/// assert_eq!(Ipv4Addr::new(10, 254, 0, 0).is_global(), false);/// assert_eq!(Ipv4Addr::new(192, 168, 10, 65).is_global(), false);/// assert_eq!(Ipv4Addr::new(172, 16, 10, 65).is_global(), false);/// // Addresses in the shared address space (`100.64.0.0/10`)/// assert_eq!(Ipv4Addr::new(100, 100, 0, 0).is_global(), false);/// // The loopback addresses (`127.0.0.0/8`)/// assert_eq!(Ipv4Addr::LOCALHOST.is_global(), false);/// // Link-local addresses (`169.254.0.0/16`)/// assert_eq!(Ipv4Addr::new(169, 254, 45, 1).is_global(), false);/// // Addresses reserved for documentation (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`)/// assert_eq!(Ipv4Addr::new(192, 0, 2, 255).is_global(), false);/// assert_eq!(Ipv4Addr::new(198, 51, 100, 65).is_global(), false);/// assert_eq!(Ipv4Addr::new(203, 0, 113, 6).is_global(), false);/// // Addresses reserved for benchmarking (`198.18.0.0/15`)/// assert_eq!(Ipv4Addr::new(198, 18, 0, 0).is_global(), false);/// // Reserved addresses (`240.0.0.0/4`)/// assert_eq!(Ipv4Addr::new(250, 10, 20, 30).is_global(), false);/// // The broadcast address (`255.255.255.255`)/// assert_eq!(Ipv4Addr::BROADCAST.is_global(), false);/// // For a complete overview see the IANA IPv4 Special-Purpose Address Registry.is_shared/// Returns [`true`] if this address is part of the Shared Address Space defined in/// [IETF RFC 6598] (`100.64.0.0/10`)./// [IETF RFC 6598]: https://tools.ietf.org/html/rfc6598/// assert_eq!(Ipv4Addr::new(100, 64, 0, 0).is_shared(), true);/// assert_eq!(Ipv4Addr::new(100, 127, 255, 255).is_shared(), true);/// assert_eq!(Ipv4Addr::new(100, 128, 0, 0).is_shared(), false);/// Returns [`true`] if this address part of the `198.18.0.0/15` range, which is reserved for/// network devices benchmarking. This range is defined in [IETF RFC 2544] as `192.18.0.0`/// through `198.19.255.255` but [errata 423] corrects it to `198.18.0.0/15`./// [IETF RFC 2544]: https://tools.ietf.org/html/rfc2544/// [errata 423]: https://www.rfc-editor.org/errata/eid423/// assert_eq!(Ipv4Addr::new(198, 17, 255, 255).is_benchmarking(), false);/// assert_eq!(Ipv4Addr::new(198, 18, 0, 0).is_benchmarking(), true);/// assert_eq!(Ipv4Addr::new(198, 19, 255, 255).is_benchmarking(), true);/// assert_eq!(Ipv4Addr::new(198, 20, 0, 0).is_benchmarking(), false);/// Returns [`true`] if this address is reserved by IANA for future use. [IETF RFC 1112]/// defines the block of reserved addresses as `240.0.0.0/4`. This range normally includes the/// broadcast address `255.255.255.255`, but this implementation explicitly excludes it, since/// it is obviously not reserved for future use./// [IETF RFC 1112]: https://tools.ietf.org/html/rfc1112/// As IANA assigns new addresses, this method will be/// updated. This may result in non-reserved addresses being/// treated as reserved in code that relies on an outdated version/// assert_eq!(Ipv4Addr::new(240, 0, 0, 0).is_reserved(), true);/// assert_eq!(Ipv4Addr::new(255, 255, 255, 254).is_reserved(), true);/// assert_eq!(Ipv4Addr::new(239, 255, 255, 255).is_reserved(), false);/// // The broadcast address is not considered as reserved for future use by this implementation/// assert_eq!(Ipv4Addr::new(255, 255, 255, 255).is_reserved(), false);/// Returns [`true`] if this is a multicast address (`224.0.0.0/4`)./// Multicast addresses have a most significant octet between `224` and `239`,/// and is defined by [IETF RFC 5771]./// [IETF RFC 5771]: https://tools.ietf.org/html/rfc5771/// assert_eq!(Ipv4Addr::new(224, 254, 0, 0).is_multicast(), true);/// assert_eq!(Ipv4Addr::new(236, 168, 10, 65).is_multicast(), true);/// assert_eq!(Ipv4Addr::new(172, 16, 10, 65).is_multicast(), false);/// Returns [`true`] if this is a broadcast address (`255.255.255.255`)./// A broadcast address has all octets set to `255` as defined in [IETF RFC 919]./// [IETF RFC 919]: https://tools.ietf.org/html/rfc919/// assert_eq!(Ipv4Addr::new(255, 255, 255, 255).is_broadcast(), true);/// assert_eq!(Ipv4Addr::new(236, 168, 10, 65).is_broadcast(), false);/// This is defined in [IETF RFC 5737]:/// - `192.0.2.0/24` (TEST-NET-1)/// - `198.51.100.0/24` (TEST-NET-2)/// - `203.0.113.0/24` (TEST-NET-3)/// [IETF RFC 5737]: https://tools.ietf.org/html/rfc5737/// assert_eq!(Ipv4Addr::new(192, 0, 2, 255).is_documentation(), true);/// assert_eq!(Ipv4Addr::new(198, 51, 100, 65).is_documentation(), true);/// assert_eq!(Ipv4Addr::new(203, 0, 113, 6).is_documentation(), true);/// assert_eq!(Ipv4Addr::new(193, 34, 17, 19).is_documentation(), false);to_ipv6_compatible/// Converts this address to an [IPv4-compatible] [`IPv6` address]./// `a.b.c.d` becomes `::a.b.c.d`/// Note that IPv4-compatible addresses have been officially deprecated./// If you don't explicitly need an IPv4-compatible address for legacy reasons, consider using `to_ipv6_mapped` instead./// [IPv4-compatible]: Ipv6Addr#ipv4-compatible-ipv6-addresses///     Ipv4Addr::new(192, 0, 2, 255).to_ipv6_compatible(),///     Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0xc000, 0x2ff)to_ipv6_mapped/// Converts this address to an [IPv4-mapped] [`IPv6` address]./// `a.b.c.d` becomes `::ffff:a.b.c.d`/// [IPv4-mapped]: Ipv6Addr#ipv4-mapped-ipv6-addresses/// assert_eq!(Ipv4Addr::new(192, 0, 2, 255).to_ipv6_mapped(),///            Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x2ff));/// Copies this address to a new `IpAddr::V4`./// use std::net::{IpAddr, Ipv4Addr};///     IpAddr::V4(addr),///     IpAddr::from(addr)/// Copies this address to a new `IpAddr::V6`./// use std::net::{IpAddr, Ipv6Addr};/// let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);///     IpAddr::V6(addr),/// Converts an `Ipv4Addr` into a host byte order `u32`./// let addr = Ipv4Addr::new(0x12, 0x34, 0x56, 0x78);/// assert_eq!(0x12345678, u32::from(addr));/// Converts a host byte order `u32` into an `Ipv4Addr`./// let addr = Ipv4Addr::from(0x12345678);/// assert_eq!(Ipv4Addr::new(0x12, 0x34, 0x56, 0x78), addr);/// Creates an `Ipv4Addr` from a four element byte array./// let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);/// assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);/// Creates an `IpAddr::V4` from a four element byte array./// let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);/// assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);/// Creates a new IPv6 address from eight 16-bit segments./// The result will represent the IP address `a:b:c:d:e:f:g:h`./// An IPv6 address representing localhost: `::1`./// This corresponds to constant `IN6ADDR_LOOPBACK_INIT` or `in6addr_loopback` in other/// languages./// let addr = Ipv6Addr::LOCALHOST;/// assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));/// An IPv6 address representing the unspecified address: `::`/// This corresponds to constant `IN6ADDR_ANY_INIT` or `in6addr_any` in other languages./// let addr = Ipv6Addr::UNSPECIFIED;/// assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));/// Returns the eight 16-bit segments that make up this address./// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).segments(),///            [0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff]);/// Returns [`true`] for the special 'unspecified' address (`::`)./// This property is defined in [IETF RFC 4291]./// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unspecified(), false);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).is_unspecified(), true);/// Returns [`true`] if this is the [loopback address] (`::1`),/// as defined in [IETF RFC 4291 section 2.5.3]./// Contrary to IPv4, in IPv6 there is only one loopback address./// [loopback address]: Ipv6Addr::LOCALHOST/// [IETF RFC 4291 section 2.5.3]: https://tools.ietf.org/html/rfc4291#section-2.5.3/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_loopback(), false);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_loopback(), true);/// as specified by the [IANA IPv6 Special-Purpose Address Registry]./// Most IPv6 addresses are globally reachable;/// - The [unspecified address] ([`is_unspecified`](Ipv6Addr::is_unspecified))/// - The [loopback address] ([`is_loopback`](Ipv6Addr::is_loopback))/// - IPv4-mapped addresses/// - Addresses reserved for benchmarking/// - Addresses reserved for documentation ([`is_documentation`](Ipv6Addr::is_documentation))/// - Unique local addresses ([`is_unique_local`](Ipv6Addr::is_unique_local))/// - Unicast addresses with link-local scope ([`is_unicast_link_local`](Ipv6Addr::is_unicast_link_local))/// For the complete overview of which addresses are globally reachable, see the table at the [IANA IPv6 Special-Purpose Address Registry]./// Note that an address having global scope is not the same as being globally reachable,/// and there is no direct relation between the two concepts: There exist addresses with global scope/// that are not globally reachable (for example unique local addresses),/// and addresses that are globally reachable without having global scope/// (multicast addresses with non-global scope)./// [IANA IPv6 Special-Purpose Address Registry]: https://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry.xhtml/// [unspecified address]: Ipv6Addr::UNSPECIFIED/// // Most IPv6 addresses are globally reachable:/// assert_eq!(Ipv6Addr::new(0x26, 0, 0x1c9, 0, 0, 0xafc8, 0x10, 0x1).is_global(), true);/// // The unspecified address (`::`)/// assert_eq!(Ipv6Addr::UNSPECIFIED.is_global(), false);/// // The loopback address (`::1`)/// assert_eq!(Ipv6Addr::LOCALHOST.is_global(), false);/// // IPv4-mapped addresses (`::ffff:0:0/96`)/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_global(), false);/// // Addresses reserved for benchmarking (`2001:2::/48`)/// assert_eq!(Ipv6Addr::new(0x2001, 2, 0, 0, 0, 0, 0, 1,).is_global(), false);/// // Addresses reserved for documentation (`2001:db8::/32`)/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1).is_global(), false);/// // Unique local addresses (`fc00::/7`)/// assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 1).is_global(), false);/// // Unicast addresses with link-local scope (`fe80::/10`)/// assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 1).is_global(), false);/// // For a complete overview see the IANA IPv6 Special-Purpose Address Registry.is_unique_local/// Returns [`true`] if this is a unique local address (`fc00::/7`)./// This property is defined in [IETF RFC 4193]./// [IETF RFC 4193]: https://tools.ietf.org/html/rfc4193/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(), false);/// assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);is_unicast/// Returns [`true`] if this is a unicast address, as defined by [IETF RFC 4291]./// Any address that is not a [multicast address] (`ff00::/8`) is unicast./// [multicast address]: Ipv6Addr::is_multicast/// // The unspecified and loopback addresses are unicast./// assert_eq!(Ipv6Addr::UNSPECIFIED.is_unicast(), true);/// assert_eq!(Ipv6Addr::LOCALHOST.is_unicast(), true);/// // Any address that is not a multicast address (`ff00::/8`) is unicast./// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast(), true);/// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_unicast(), false);is_unicast_link_local/// Returns `true` if the address is a unicast address with link-local scope,/// as defined in [RFC 4291]./// A unicast address has link-local scope if it has the prefix `fe80::/10`, as per [RFC 4291 section 2.4]./// Note that this encompasses more addresses than those defined in [RFC 4291 section 2.5.6],/// which describes "Link-Local IPv6 Unicast Addresses" as having the following stricter format:/// | 10 bits  |         54 bits         |          64 bits           |/// +----------+-------------------------+----------------------------+/// |1111111010|           0             |       interface ID         |/// So while currently the only addresses with link-local scope an application will encounter are all in `fe80::/64`,/// this might change in the future with the publication of new standards. More addresses in `fe80::/10` could be allocated,/// and those addresses will have link-local scope./// Also note that while [RFC 4291 section 2.5.3] mentions about the [loopback address] (`::1`) that "it is treated as having Link-Local scope",/// this does not mean that the loopback address actually has link-local scope and this method will return `false` on it./// [RFC 4291]: https://tools.ietf.org/html/rfc4291/// [RFC 4291 section 2.4]: https://tools.ietf.org/html/rfc4291#section-2.4/// [RFC 4291 section 2.5.3]: https://tools.ietf.org/html/rfc4291#section-2.5.3/// [RFC 4291 section 2.5.6]: https://tools.ietf.org/html/rfc4291#section-2.5.6/// // The loopback address (`::1`) does not actually have link-local scope./// assert_eq!(Ipv6Addr::LOCALHOST.is_unicast_link_local(), false);/// // Only addresses in `fe80::/10` have link-local scope./// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), false);/// assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);/// // Addresses outside the stricter `fe80::/64` also have link-local scope./// assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0).is_unicast_link_local(), true);/// assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);/// Returns [`true`] if this is an address reserved for documentation/// (`2001:db8::/32`)./// This property is defined in [IETF RFC 3849]./// [IETF RFC 3849]: https://tools.ietf.org/html/rfc3849/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(), false);/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_documentation(), true);/// Returns [`true`] if this is an address reserved for benchmarking (`2001:2::/48`)./// This property is defined in [IETF RFC 5180], where it is mistakenly specified as covering the range `2001:0200::/48`./// This is corrected in [IETF RFC Errata 1752] to `2001:0002::/48`./// [IETF RFC 5180]: https://tools.ietf.org/html/rfc5180/// [IETF RFC Errata 1752]: https://www.rfc-editor.org/errata_search.php?eid=1752/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc613, 0x0).is_benchmarking(), false);/// assert_eq!(Ipv6Addr::new(0x2001, 0x2, 0, 0, 0, 0, 0, 0).is_benchmarking(), true);is_unicast_global/// Returns [`true`] if the address is a globally routable unicast address./// The following return false:/// - the loopback address/// - the link-local addresses/// - unique local addresses/// - the unspecified address/// - the address range reserved for documentation/// This method returns [`true`] for site-local addresses as per [RFC 4291 section 2.5.7]/// ```no_rust/// The special behavior of [the site-local unicast] prefix defined in [RFC3513] must no longer/// be supported in new implementations (i.e., new implementations must treat this prefix as/// Global Unicast)./// [RFC 4291 section 2.5.7]: https://tools.ietf.org/html/rfc4291#section-2.5.7/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(), true);multicast_scope/// Returns the address's multicast scope if the address is multicast./// use std::net::{Ipv6Addr, Ipv6MulticastScope};///     Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0).multicast_scope(),///     Some(Ipv6MulticastScope::Global)/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);/// Returns [`true`] if this is a multicast address (`ff00::/8`)./// This property is defined by [IETF RFC 4291]./// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_multicast(), true);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_multicast(), false);to_ipv4_mapped/// Converts this address to an [`IPv4` address] if it's an [IPv4-mapped] address,/// as defined in [IETF RFC 4291 section 2.5.5.2], otherwise returns [`None`]./// `::ffff:a.b.c.d` becomes `a.b.c.d`./// All addresses *not* starting with `::ffff` will return `None`./// [IPv4-mapped]: Ipv6Addr/// [IETF RFC 4291 section 2.5.5.2]: https://tools.ietf.org/html/rfc4291#section-2.5.5.2/// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4_mapped(), None);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4_mapped(),///            Some(Ipv4Addr::new(192, 10, 2, 255)));/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4_mapped(), None);to_ipv4/// Converts this address to an [`IPv4` address] if it is either/// an [IPv4-compatible] address as defined in [IETF RFC 4291 section 2.5.5.1],/// or an [IPv4-mapped] address as defined in [IETF RFC 4291 section 2.5.5.2],/// otherwise returns [`None`]./// Note that this will return an [`IPv4` address] for the IPv6 loopback address `::1`. Use/// `::a.b.c.d` and `::ffff:a.b.c.d` become `a.b.c.d`. `::1` becomes `0.0.0.1`./// All addresses *not* starting with either all zeroes or `::ffff` will return `None`./// [IETF RFC 4291 section 2.5.5.1]: https://tools.ietf.org/html/rfc4291#section-2.5.5.1/// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4(), None);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4(),/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4(),///            Some(Ipv4Addr::new(0, 0, 0, 1)));/// Converts this address to an `IpAddr::V4` if it is an IPv4-mapped addresses, otherwise it/// returns self wrapped in an `IpAddr::V6`./// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).is_loopback(), false);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).to_canonical().is_loopback(), true);/// Returns the sixteen eight-bit integers the IPv6 address consists of./// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),///            [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);/// Convert an `Ipv6Addr` into a host byte order `u128`./// let addr = Ipv6Addr::new(///     0x1020, 0x3040, 0x5060, 0x7080,///     0x90A0, 0xB0C0, 0xD0E0, 0xF00D,/// assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));/// Convert a host byte order `u128` into an `Ipv6Addr`./// let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);///     Ipv6Addr::new(///         0x1020, 0x3040, 0x5060, 0x7080,///         0x90A0, 0xB0C0, 0xD0E0, 0xF00D,///     addr);/// Creates an `Ipv6Addr` from a sixteen element byte array./// let addr = Ipv6Addr::from([///     25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,///     17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,///         0x1918, 0x1716,///         0x1514, 0x1312,///         0x1110, 0x0f0e,///         0x0d0c, 0x0b0a///     addr/// Creates an `Ipv6Addr` from an eight element 16-bit array.///     525u16, 524u16, 523u16, 522u16,///     521u16, 520u16, 519u16, 518u16,///         0x20d, 0x20c,///         0x20b, 0x20a,///         0x209, 0x208,///         0x207, 0x206/// Creates an `IpAddr::V6` from a sixteen element byte array./// let addr = IpAddr::from([///     IpAddr::V6(Ipv6Addr::new(///     )),/// Creates an `IpAddr::V6` from an eight element 16-bit array.//! library/std/src/net/ip_addr.rs at revision//! This defines `IpAddr`, `Ipv4Addr`, and `Ipv6Addr`. Ideally, these should be//! defined in `core`. See [RFC 2832].//! [RFC 2832]: https://github.com/rust-lang/rfcs/pull/2832socket_addr_anywsawsa_cleanupwsa_startup//! Network-related operations.//! On Windows, one must call [`wsa_startup`] in the process before calling any//! of these APIs. [`wsa_cleanup`] may be used in the process if these APIs are//! no longer needed.//! [`wsa_startup`]: https://docs.rs/rustix/*/x86_64-pc-windows-msvc/rustix/net/fn.wsa_startup.html//! [`wsa_cleanup`]: https://docs.rs/rustix/*/x86_64-pc-windows-msvc/rustix/net/fn.wsa_cleanup.html/// `recv(fd, buf, flags)`—Reads data from a socket./// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#sendrecv/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/recv.html/// [Linux]: https://man7.org/linux/man-pages/man2/recv.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/recv.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-recv/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2/// [NetBSD]: https://man.netbsd.org/recv.2/// [OpenBSD]: https://man.openbsd.org/recv.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=recv&section=2/// [illumos]: https://illumos.org/man/3SOCKET/recv/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Receiving-Data.html/// `send(fd, buf, flags)`—Writes data to a socket./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/send.html/// [Linux]: https://man7.org/linux/man-pages/man2/send.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/send.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2/// [NetBSD]: https://man.netbsd.org/send.2/// [OpenBSD]: https://man.openbsd.org/send.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=send&section=2/// [illumos]: https://illumos.org/man/3SOCKET/send/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Sending-Data.html/// `recvfrom(fd, buf, flags, addr, len)`—Reads data from a socket and/// returns the sender address./// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#sendtorecv/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html/// [Linux]: https://man7.org/linux/man-pages/man2/recvfrom.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/recvfrom.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-recvfrom/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=recvfrom&sektion=2/// [NetBSD]: https://man.netbsd.org/recvfrom.2/// [OpenBSD]: https://man.openbsd.org/recvfrom.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=recvfrom&section=2/// [illumos]: https://illumos.org/man/3SOCKET/recvfrom/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Receiving-Datagrams.html/// `sendto(fd, buf, flags, addr)`—Writes data to a socket to a specific IP/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html/// [Linux]: https://man7.org/linux/man-pages/man2/sendto.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/sendto.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=sendto&sektion=2/// [NetBSD]: https://man.netbsd.org/sendto.2/// [OpenBSD]: https://man.openbsd.org/sendto.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=sendto&section=2/// [illumos]: https://illumos.org/man/3SOCKET/sendto/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Sending-Datagrams.html_sendtosendto_any/// `sendto(fd, buf, flags, addr)`—Writes data to a socket to a specific_sendto_any/// `sendto(fd, buf, flags, addr, sizeof(struct sockaddr_in))`—Writes data to/// a socket to a specific IPv4 address./// `sendto(fd, buf, flags, addr, sizeof(struct sockaddr_in6))`—Writes data/// to a socket to a specific IPv6 address./// `sendto(fd, buf, flags, addr, sizeof(struct sockaddr_un))`—Writes data to/// a socket to a specific Unix-domain socket address.//! `recv` and `send`, and variants.// Base Rules// Combo Rules/// Macro for defining the amount of space used by CMSGs.__cmsg_spaceSendAncillaryMessage/// Send file descriptors./// Ancillary message for [`sendmsg_noaddr`], [`sendmsg_v4`], [`sendmsg_v6`],/// [`sendmsg_unix`], and [`sendmsg_any`]./// Get the maximum size of an ancillary message./// This can be helpful in determining the size of the buffer you allocate.RecvAncillaryMessageAncillaryIter/// Received file descriptors./// Ancillary message for [`recvmsg`]./// Raw byte buffer for messages./// The amount of the buffer that is used./// Phantom data for lifetime of `&'slice [BorrowedFd<'fd>]`./// Buffer for sending ancillary messages./// Create a new, empty `SendAncillaryBuffer` from a raw byte buffer.as_control_ptr/// Returns a pointer to the message data./// Returns the length of the message data./// Delete all messages from the buffer./// Add an ancillary message to the buffer./// Returns `true` if the message was added successfully.push_ancillary/// Pushes an ancillary message to the buffer./// The portion of the buffer we've read from already./// Buffer for receiving ancillary messages./// Create a new, empty `RecvAncillaryBuffer` from a raw byte buffer./// Set the length of the message data./// The buffer must be filled with valid message data.AncillaryDrain/// Drain all messages from the buffer./// Inner iterator over messages./// Increment the number of messages we've read./// Decrement the total length./// An iterator that drains messages from a `RecvAncillaryBuffer`.cvt_msg/// A closure that converts a message into a `RecvAncillaryMessage`./// `sendmsg(msghdr)`—Sends a message on a socket./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html/// [Linux]: https://man7.org/linux/man-pages/man2/sendmsg.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/sendmsg.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=sendmsg&sektion=2/// [NetBSD]: https://man.netbsd.org/sendmsg.2/// [OpenBSD]: https://man.openbsd.org/sendmsg.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=sendmsg&section=2/// [illumos]: https://illumos.org/man/3SOCKET/sendmsg/// `sendmsg(msghdr)`—Sends a message on a socket to a specific IPv4 address./// `sendmsg(msghdr)`—Sends a message on a socket to a specific IPv6 address./// `sendmsg(msghdr)`—Sends a message on a socket to a specific Unix-domainsendmsg_any/// `sendmsg(msghdr)`—Sends a message on a socket to a specific address./// `recvmsg(msghdr)`—Receives a message from a socket./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html/// [Linux]: https://man7.org/linux/man-pages/man2/recvmsg.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/recvmsg.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=recvmsg&sektion=2/// [NetBSD]: https://man.netbsd.org/recvmsg.2/// [OpenBSD]: https://man.openbsd.org/recvmsg.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=recvmsg&section=2/// [illumos]: https://illumos.org/man/3SOCKET/recvmsg/// The number of bytes received./// The flags received./// The address of the socket we received from, if any./// The result of a successful [`recvmsg`] call./// The data we're iterating over./// The raw data we're removing./// An iterator over data in an ancillary buffer./// Create a new iterator over data in an ancillary buffer./// The buffer must contain valid ancillary data./// The message header we're using to iterator over the messages./// The current pointer to the next message header to return./// This has a lifetime of `'buf`./// Capture the original lifetime of the buffer./// An iterator over the messages in an ancillary buffer./// Create a new iterator over messages from a byte buffer.//! [`recvmsg`], [`sendmsg_noaddr`], and related functions.AcceptFlags/// Compatibility alias for `SocketFlags`. Use `SocketFlags` instead of this./// `socket(domain, type_, protocol)`—Creates a socket./// POSIX guarantees that `socket` will use the lowest unused file descriptor,/// To pass extra flags such as [`SocketFlags::CLOEXEC`], use [`socket_with`]./// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#socket/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html/// [Linux]: https://man7.org/linux/man-pages/man2/socket.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/socket.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-socket/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2/// [NetBSD]: https://man.netbsd.org/socket.2/// [OpenBSD]: https://man.openbsd.org/socket.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=socket&section=2/// [illumos]: https://illumos.org/man/3SOCKET/socket/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Creating-a-Socket.html/// `socket_with(domain, type_ | flags, protocol)`—Creates a socket, with/// `socket_with` is the same as [`socket`] but adds an additional flags/// operand./// `bind(sockfd, addr)`—Binds a socket to an IP address./// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#bind/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html/// [Linux]: https://man7.org/linux/man-pages/man2/bind.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/bind.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-bind/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2/// [NetBSD]: https://man.netbsd.org/bind.2/// [OpenBSD]: https://man.openbsd.org/bind.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=bind&section=2/// [illumos]: https://illumos.org/man/3SOCKET/bind/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Setting-Address.html_bindbind_any/// `bind(sockfd, addr)`—Binds a socket to an address._bind_any/// `bind(sockfd, addr, sizeof(struct sockaddr_in))`—Binds a socket to an/// `bind(sockfd, addr, sizeof(struct sockaddr_in6))`—Binds a socket to an/// IPv6 address./// `bind(sockfd, addr, sizeof(struct sockaddr_un))`—Binds a socket to a/// Unix-domain address./// `connect(sockfd, addr)`—Initiates a connection to an IP address./// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#connect/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html/// [Linux]: https://man7.org/linux/man-pages/man2/connect.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/connect.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=connect&sektion=2/// [NetBSD]: https://man.netbsd.org/connect.2/// [OpenBSD]: https://man.openbsd.org/connect.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=connect&section=2/// [illumos]: https://illumos.org/man/3SOCKET/connect/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Connecting.html_connectconnect_any/// `connect(sockfd, addr)`—Initiates a connection._connect_any/// `connect(sockfd, addr, sizeof(struct sockaddr_in))`—Initiates a/// connection to an IPv4 address./// `connect(sockfd, addr, sizeof(struct sockaddr_in6))`—Initiates a/// connection to an IPv6 address./// `connect(sockfd, addr, sizeof(struct sockaddr_un))`—Initiates a/// connection to a Unix-domain address./// `listen(fd, backlog)`—Enables listening for incoming connections./// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#listen/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html/// [Linux]: https://man7.org/linux/man-pages/man2/listen.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/listen.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2/// [NetBSD]: https://man.netbsd.org/listen.2/// [OpenBSD]: https://man.openbsd.org/listen.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=listen&section=2/// [illumos]: https://illumos.org/man/3SOCKET/listen/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Listening.html/// `accept(fd, NULL, NULL)`—Accepts an incoming connection./// Use [`acceptfrom`] to retrieve the peer address./// POSIX guarantees that `accept` will use the lowest unused file descriptor,/// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#acceptthank-you-for-calling-port-3490./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html/// [Linux]: https://man7.org/linux/man-pages/man2/accept.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/accept.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2/// [NetBSD]: https://man.netbsd.org/accept.2/// [OpenBSD]: https://man.openbsd.org/accept.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=accept&section=2/// [illumos]: https://illumos.org/man/3SOCKET/accept/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Accepting-Connections.html/// `accept4(fd, NULL, NULL, flags)`—Accepts an incoming connection, with/// Use [`acceptfrom_with`] to retrieve the peer address./// Even though POSIX guarantees that this will use the lowest unused file/// descriptor, it is not safe in general to rely on this, as file descriptors/// may be unexpectedly allocated on other threads or in libraries./// `accept_with` is the same as [`accept`] but adds an additional flags/// [Linux]: https://man7.org/linux/man-pages/man2/accept4.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=accept4&sektion=2/// [NetBSD]: https://man.netbsd.org/accept4.2/// [OpenBSD]: https://man.openbsd.org/accept4.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=accept4&section=2/// [illumos]: https://illumos.org/man/3SOCKET/accept4/// `accept(fd, &addr, &len)`—Accepts an incoming connection and returns the/// peer address./// Use [`accept`] if the peer address isn't needed./// `accept4(fd, &addr, &len, flags)`—Accepts an incoming connection and/// returns the peer address, with flags./// Use [`accept_with`] if the peer address isn't needed./// `acceptfrom_with` is the same as [`acceptfrom`] but adds an additional/// flags operand./// `shutdown(fd, how)`—Closes the read and/or write sides of a stream./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html/// [Linux]: https://man7.org/linux/man-pages/man2/shutdown.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/shutdown.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-shutdown/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2/// [NetBSD]: https://man.netbsd.org/shutdown.2/// [OpenBSD]: https://man.openbsd.org/shutdown.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=shutdown&section=2/// [illumos]: https://illumos.org/man/3SOCKET/shutdown/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Closing-a-Socket.html/// `getsockname(fd, addr, len)`—Returns the address a socket is bound to./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html/// [Linux]: https://man7.org/linux/man-pages/man2/getsockname.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getsockname.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getsockname/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getsockname&sektion=2/// [NetBSD]: https://man.netbsd.org/getsockname.2/// [OpenBSD]: https://man.openbsd.org/getsockname.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=getsockname&section=2/// [illumos]: https://illumos.org/man/3SOCKET/getsockname/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Reading-Address.html/// `getpeername(fd, addr, len)`—Returns the address a socket is connected/// [Beej's Guide to Network Programming]: https://beej.us/guide/bgnet/html/split/system-calls-or-bust.html#getpeernamewho-are-you/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html/// [Linux]: https://man7.org/linux/man-pages/man2/getpeername.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getpeername.2.html/// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getpeername/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2/// [NetBSD]: https://man.netbsd.org/getpeername.2/// [OpenBSD]: https://man.openbsd.org/getpeername.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=getpeername&section=2/// [illumos]: https://illumos.org/man/3SOCKET/getpeername/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Who-is-Connected.html/// `struct sockaddr_in`/// `struct sockaddr_in6`/// `struct sockaddr_storage` as a Rust enum.address_family/// Return the address family of this socket address./// Writes a platform-specific encoding of this socket address to/// the memory pointed to by `storage`, and returns the number of/// bytes used./// `storage` must point to valid memory for encoding the socket/// Reads a platform-specific encoding of a socket address from/// the memory pointed to by `storage`, which uses `len` bytes./// `storage` must point to valid memory for decoding a socket//! A socket address for any kind of socket.//! This is similar to [`std::net::SocketAddr`], but also supports Unix-domain//! socket addresses.//! The `read` and `write` functions allow decoding and encoding from and to//! OS-specific socket address representations in memory./// `socketpair(domain, type_ | accept_flags, protocol)`/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/socketpair.html/// [Linux]: https://man7.org/linux/man-pages/man2/socketpair.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/socketpair.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=socketpair&sektion=2/// [NetBSD]: https://man.netbsd.org/socketpair.2/// [OpenBSD]: https://man.openbsd.org/socketpair.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=socketpair&section=2/// [illumos]: https://illumos.org/man/3SOCKET/socketpair/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Socket-Pairs.html/// `getsockopt(fd, SOL_SOCKET, SO_TYPE)`—Returns the type of a socket.///  - [POSIX `getsockopt`]///  - [POSIX `sys/socket.h`]///  - [Linux `getsockopt`]///  - [Linux `socket`]///  - [Winsock2 `getsockopt`]///  - [Winsock2 `SOL_SOCKET` options]///  - [glibc `getsockopt`]///  - [glibc `SOL_SOCKET` Options]/// [POSIX `getsockopt`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockopt.html/// [POSIX `sys/socket.h`]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_socket.h.html/// [Linux `getsockopt`]: https://man7.org/linux/man-pages/man2/getsockopt.2.html/// [Linux `socket`]: https://man7.org/linux/man-pages/man7/socket.7.html/// [Winsock2 `getsockopt`]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getsockopt/// [Winsock2 `SOL_SOCKET` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/sol-socket-socket-options/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getsockopt.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getsockopt&sektion=2/// [NetBSD]: https://man.netbsd.org/getsockopt.2/// [OpenBSD]: https://man.openbsd.org/getsockopt.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=getsockopt&section=2/// [illumos]: https://illumos.org/man/3SOCKET/getsockopt/// [glibc `getsockopt`]: https://www.gnu.org/software/libc/manual/html_node/Socket-Option-Functions.html/// [glibc `SOL_SOCKET` options]: https://www.gnu.org/software/libc/manual/html_node/Socket_002dLevel-Options.html/// `setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, value)`///  - [POSIX `setsockopt`]///  - [Linux `setsockopt`]///  - [Winsock2 `setsockopt`]///  - [glibc `setsockopt`]/// [POSIX `setsockopt`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsockopt.html/// [Linux `setsockopt`]: https://man7.org/linux/man-pages/man2/setsockopt.2.html/// [Winsock2 `setsockopt`]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-setsockopt/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setsockopt.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=setsockopt&sektion=2/// [NetBSD]: https://man.netbsd.org/setsockopt.2/// [OpenBSD]: https://man.openbsd.org/setsockopt.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=setsockopt&section=2/// [illumos]: https://illumos.org/man/3SOCKET/setsockopt/// [glibc `setsockopt`]: https://www.gnu.org/software/libc/manual/html_node/Socket-Option-Functions.html/// `setsockopt(fd, SOL_SOCKET, SO_BROADCAST, broadcast)`/// `getsockopt(fd, SOL_SOCKET, SO_BROADCAST)`/// `setsockopt(fd, SOL_SOCKET, SO_LINGER, linger)`/// `getsockopt(fd, SOL_SOCKET, SO_LINGER)`/// `setsockopt(fd, SOL_SOCKET, SO_PASSCRED, passcred)`/// `getsockopt(fd, SOL_SOCKET, SO_PASSCRED)`/// `setsockopt(fd, SOL_SOCKET, id, timeout)`—Set the sending or receiving/// timeout./// `getsockopt(fd, SOL_SOCKET, id)`—Get the sending or receiving timeout./// `getsockopt(fd, SOL_SOCKET, SO_ERROR)`/// `getsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE)`/// `setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, val)`/// `setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, keepalive)`/// `getsockopt(fd, SOL_SOCKET, SO_KEEPALIVE)`/// `setsockopt(fd, SOL_SOCKET, SO_RCVBUF, size)`/// `getsockopt(fd, SOL_SOCKET, SO_RCVBUF)`/// `setsockopt(fd, SOL_SOCKET, SO_SNDBUF, size)`/// `getsockopt(fd, SOL_SOCKET, SO_SNDBUF)`/// `setsockopt(fd, IPPROTO_IP, IP_TTL, ttl)`///  - [POSIX `netinet/in.h`]///  - [Linux `ip`]///  - [Winsock2 `IPPROTO_IP` options]///  - [Apple `setsockopt`]///  - [Apple `ip`]///  - [FreeBSD `setsockopt`]///  - [FreeBSD `ip`]///  - [NetBSD `setsockopt`]///  - [NetBSD `ip`]///  - [OpenBSD `setsockopt`]///  - [OpenBSD `ip`]///  - [DragonFly BSD `setsockopt`]///  - [DragonFly BSD `ip`]///  - [illumos `setsockopt`]///  - [illumos `ip`]/// [Linux `ip`]: https://man7.org/linux/man-pages/man7/ip.7.html/// [Winsock2 `IPPROTO_IP` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options/// [Apple `setsockopt`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setsockopt.2.html/// [Apple `ip`]: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/man/man4/ip.4.auto.html/// [FreeBSD `setsockopt`]: https://man.freebsd.org/cgi/man.cgi?query=setsockopt&sektion=2/// [FreeBSD `ip`]: https://man.freebsd.org/cgi/man.cgi?query=ip&sektion=4/// [NetBSD `setsockopt`]: https://man.netbsd.org/setsockopt.2/// [NetBSD `ip`]: https://man.netbsd.org/ip.4/// [OpenBSD `setsockopt`]: https://man.openbsd.org/setsockopt.2/// [OpenBSD `ip`]: https://man.openbsd.org/ip.4/// [DragonFly BSD `setsockopt`]: https://man.dragonflybsd.org/?command=setsockopt&section=2/// [DragonFly BSD `ip`]: https://man.dragonflybsd.org/?command=ip&section=4/// [illumos `setsockopt`]: https://illumos.org/man/3SOCKET/setsockopt/// [illumos `ip`]: https://illumos.org/man/4P/ip/// `getsockopt(fd, IPPROTO_IP, IP_TTL)`///  - [Apple `getsockopt`]///  - [FreeBSD `getsockopt`]///  - [NetBSD `getsockopt`]///  - [OpenBSD `getsockopt`]///  - [DragonFly BSD `getsockopt`]///  - [illumos `getsockopt`]/// [POSIX `netinet/in.h`]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_in.h.html/// `setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, only_v6)`///  - [Linux `ipv6`]///  - [Winsock2 `IPPROTO_IPV6` options]///  - [Apple `ip6`]///  - [FreeBSD `ip6`]///  - [NetBSD `ip6`]///  - [OpenBSD `ip6`]///  - [DragonFly BSD `ip6`]///  - [illumos `ip6`]/// [Linux `ipv6`]: https://man7.org/linux/man-pages/man7/ipv6.7.html/// [Winsock2 `IPPROTO_IPV6` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ipv6-socket-options/// [Apple `ip6`]: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/man/man4/ip6.4.auto.html/// [FreeBSD `ip6`]: https://man.freebsd.org/cgi/man.cgi?query=ip6&sektion=4/// [NetBSD `ip6`]: https://man.netbsd.org/ip6.4/// [OpenBSD `ip6`]: https://man.openbsd.org/ip6.4/// [DragonFly BSD `ip6`]: https://man.dragonflybsd.org/?command=ip6&section=4/// [illumos `ip6`]: https://illumos.org/man/4P/ip6/// `getsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY)`/// [Apple `getsockopt`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getsockopt.2.html/// [FreeBSD `getsockopt`]: https://man.freebsd.org/cgi/man.cgi?query=getsockopt&sektion=2/// [NetBSD `getsockopt`]: https://man.netbsd.org/getsockopt.2/// [OpenBSD `getsockopt`]: https://man.openbsd.org/getsockopt.2/// [DragonFly BSD `getsockopt`]: https://man.dragonflybsd.org/?command=getsockopt&section=2/// [illumos `getsockopt`]: https://illumos.org/man/3SOCKET/getsockopt/// `setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, multicast_loop)`/// `getsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP)`/// `setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, multicast_ttl)`/// `getsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, multicast_loop)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, multicast_hops)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, unicast_hops)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS)`/// `setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, multiaddr, interface)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, multiaddr, interface)`/// `IPV6_ADD_MEMBERSHIP` is the same as `IPV6_JOIN_GROUP` in POSIX./// `setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, multiaddr, interface)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, multiaddr, interface)`/// `IPV6_DROP_MEMBERSHIP` is the same as `IPV6_LEAVE_GROUP` in POSIX./// `setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, nodelay)`///  - [POSIX `netinet/tcp.h`]///  - [Linux `tcp`]///  - [Winsock2 `IPPROTO_TCP` options]///  - [Apple `tcp`]///  - [FreeBSD `tcp`]///  - [NetBSD `tcp`]///  - [OpenBSD `tcp`]///  - [DragonFly BSD `tcp`]///  - [illumos `tcp`]/// [POSIX `netinet/tcp.h`]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_tcp.h.html/// [Linux `tcp`]: https://man7.org/linux/man-pages/man7/tcp.7.html/// [Winsock2 `IPPROTO_TCP` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-tcp-socket-options/// [Apple `tcp`]: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/man/man4/tcp.4.auto.html/// [FreeBSD `tcp`]: https://man.freebsd.org/cgi/man.cgi?query=tcp&sektion=4/// [NetBSD `tcp`]: https://man.netbsd.org/tcp.4/// [OpenBSD `tcp`]: https://man.openbsd.org/tcp.4/// [DragonFly BSD `tcp`]: https://man.dragonflybsd.org/?command=tcp&section=4/// [illumos `tcp`]: https://illumos.org/man/4P/tcp/// `getsockopt(fd, IPPROTO_TCP, TCP_NODELAY)`//! `getsockopt` and `setsockopt` functions.//! In the rustix API, there is a separate function for each option, so that//! it can be given an option-specific type signature.WSACleanup/// `WSAStartup()`—Initialize process-wide Windows support for sockets./// On Windows, it's necessary to initialize the sockets subsystem before/// using sockets APIs. The function performs the necessary initialization./// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsastartup/// `WSACleanup()`—Clean up process-wide Windows support for sockets./// In a program where `init` is called, if sockets are no longer necessary,/// this function releases associated resources./// [Winsock2]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsacleanup/// `sysconf(_SC_PAGESIZE)`—Returns the process' page size./// Also known as `getpagesize`.///  - [Linux `sysconf`]///  - [Linux `getpagesize`]/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html/// [Linux `sysconf`]: https://man7.org/linux/man-pages/man3/sysconf.3.html/// [Linux `getpagesize`]: https://man7.org/linux/man-pages/man2/getpagesize.2.html/// `sysconf(_SC_CLK_TCK)`—Returns the process' clock ticks per second./// [Linux]: https://man7.org/linux/man-pages/man3/sysconf.3.html/// `(getauxval(AT_HWCAP), getauxval(AT_HWCAP2)`—Returns the Linux "hwcap"/// Return the Linux `AT_HWCAP` and `AT_HWCAP2` values passed to the/// current process. Returns 0 for each value if it is not available./// [Linux]: https://man7.org/linux/man-pages/man3/getauxval.3.html/// `getauxval(AT_EXECFN)`—Returns the Linux "execfn" string./// Return the string that Linux has recorded as the filesystem path to the/// executable. Returns an empty string if the string is not available./// Initialize process-wide state./// This must be passed a pointer to the original environment variable block/// set up by the OS at process startup, and it must be called before any/// other rustix functions are called.//! rustix's `init` function.//! On mustang, or on any non-glibc non-musl platform, the `init` function must//! be called before any other function in this module. It is unsafe because it//! operates on raw pointers.//! Process parameters.//! These values correspond to `sysconf` in POSIX, and the auxv array in Linux.//! Despite the POSIX name “sysconf”, these aren't *system* configuration//! parameters; they're *process* configuration parameters, as they may differ//! between different processes on the same system./// Returns a view of this string as a string slice./// Returns a potentially-lossy rendering of this string as a `Cow<'_,/// str>`.as_cow_c_str/// Returns a view of this string as a maybe-owned [`CStr`].into_c_str/// Consumes `self` and returns a view of this string as a maybe-owned/// [`CStr`].into_with_c_str/// Runs a closure with `self` passed in as a `&CStr`./// A trait for passing path arguments./// This is similar to [`AsRef`]`<`[`Path`]`>`, but is implemented for more/// kinds of strings and can convert into more kinds of strings./// # #[cfg(any(feature = "fs", feature = "net"))]/// use rustix::ffi::CStr;/// use rustix::io;/// use rustix::path::Arg;/// pub fn touch<P: Arg>(path: P) -> io::Result<()> {///     let path = path.into_c_str()?;///     _touch(&path)/// fn _touch(path: &CStr) -> io::Result<()> {///     // implementation goes here/// Users can then call `touch("foo")`, `touch(cstr!("foo"))`,/// `touch(Path::new("foo"))`, or many other things./// [`AsRef`]: std::convert::AsRefwith_c_str/// Runs a closure with `bytes` passed in as a `&CStr`.with_c_str_slow_path/// The slow path which handles any length. In theory OS's only support up/// to `PATH_MAX`, but we let the OS enforce that.//! Convenient and efficient string argument passing.//! This module defines the `Arg` trait and implements it for several common//! string types. This allows users to pass any of these string types directly//! to rustix APIs with string arguments, and it allows rustix to implement//! NUL-termination without the need for copying where possible.// 20 `u8`s is enough to hold the decimal ASCII representation of any// `u64`, and we add one for a NUL terminator for `as_c_str`./// Format an integer into a decimal `Path` component, without constructing a/// temporary `PathBuf` or `String`./// This is used for opening paths such as `/proc/self/fd/<fd>` on Linux./// use rustix::path::DecInt;///     format!("hello {}", DecInt::new(9876).as_ref().display()),///     "hello 9876"/// Construct a new path component from an integer./// Construct a new path component from a file descriptor./// Return the raw byte buffer as a `&str`.as_c_str/// Return the raw byte buffer as a `&CStr`./// Return the raw byte buffer.DecIntWriter//! Efficient decimal integer formatting.//! This uses `CStr::from_bytes_with_nul_unchecked` and//! `str::from_utf8_unchecked`on the buffer that it filled itself.//! Filesystem path operations./// `chdir(path)`—Change the current working directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html/// [Linux]: https://man7.org/linux/man-pages/man2/chdir.2.html/// `fchdir(fd)`—Change the current working directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchdir.html/// [Linux]: https://man7.org/linux/man-pages/man2/fchdir.2.html/// `getcwd()`—Return the current working directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getcwd.html/// [Linux]: https://man7.org/linux/man-pages/man3/getcwd.3.html_getcwd/// `chroot(path)`—Change the process root directory./// [Linux]: https://man7.org/linux/man-pages/man2/chroot.2.html/// `EXIT_SUCCESS` for use with [`exit`]./// [`exit`]: std::process::exit/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdlib.h.html/// [Linux]: https://man7.org/linux/man-pages/man3/exit.3.html/// `EXIT_FAILURE` for use with [`exit`]./// The exit status used by a process terminated with a [`Signal::Abort`]/// [Linux]: https://tldp.org/LDP/abs/html/exitcodes.html/// [`Signal::Abort`]: crate::process::Signal::Abort/// The raw integer value of a Unix user ID./// The raw integer value of a Unix group ID./// The raw integer value of a Unix process ID./// `uid_t`—A Unix user ID./// `gid_t`—A Unix group ID./// `pid_t`—A non-zero Unix process ID./// This is a pid, and not a pidfd. It is not a file descriptor, and the/// process it refers to could disappear at any time and be replaced by/// another, unrelated, process./// A Linux CPU ID./// A `Uid` corresponding to the root user (uid 0)./// Converts a `RawUid` into a `Uid`./// `raw` must be the value of a valid Unix user ID./// Converts a `Uid` into a `RawUid`./// Test whether this uid represents the root user (uid 0)./// A `Gid` corresponding to the root group (gid 0)./// Converts a `RawGid` into a `Gid`./// `raw` must be the value of a valid Unix group ID./// Converts a `Gid` into a `RawGid`./// Test whether this gid represents the root group (gid 0)./// A `Pid` corresponding to the init process (pid 1)./// Converts a `RawPid` into a `Pid`./// `raw` must be the value of a valid Unix process ID, or zero.from_raw_nonzero/// Converts a known non-zero `RawPid` into a `Pid`./// `raw` must be the value of a valid Unix process ID. It must not be/// zero.from_child/// Creates a `Pid` holding the ID of the given child process.as_raw_nonzero/// Converts a `Pid` into a `RawNonZeroPid`./// Converts an `Option<Pid>` into a `RawPid`.is_init/// Test whether this pid represents the init process (pid 0)./// Converts a `RawCpuid` into a `Cpuid`./// `raw` must be the value of a valid Linux CPU ID./// Converts a `Cpuid` into a `RawCpuid`./// `getuid()`—Returns the process' real user ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getuid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getuid.2.html/// `geteuid()`—Returns the process' effective user ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/geteuid.html/// [Linux]: https://man7.org/linux/man-pages/man2/geteuid.2.html/// `getgid()`—Returns the process' real group ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getgid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getgid.2.html/// `getegid()`—Returns the process' effective group ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getegid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getegid.2.html/// `getpid()`—Returns the process' ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getpid.2.html/// `getppid()`—Returns the parent process' ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getppid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getppid.2.html/// `getpgid(pid)`—Returns the process group ID of the given process./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getpgid.2.html/// `setpgid(pid, pgid)`—Sets the process group ID of the given process./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setpgid.html/// [Linux]: https://man7.org/linux/man-pages/man2/setpgid.2.html/// `getpgrp()`—Returns the process' group ID./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgrp.html/// [Linux]: https://man7.org/linux/man-pages/man2/getpgrp.2.html/// `getsid(pid)`—Get the session ID of the given process./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsid.html/// [Linux]: https://man7.org/linux/man-pages/man2/getsid.2.html/// `setsid()`—Create a new session./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsid.html/// [Linux]: https://man7.org/linux/man-pages/man2/setsid.2.html/// `getgroups()`—Return a list of the current user's groups./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getgroups.html/// [Linux]: https://man7.org/linux/man-pages/man2/getgroups.2.htmltranslate_fchown_args// Return the raw value of the IDs. In case of `None` it returns `u32::MAX`// since it has the same bit pattern as `-1` indicating no change to the// owner/group ID.//! Unix user, group, and process identifiers.//! The `Uid`, `Gid`, and `Pid` types can be constructed from raw integers,//! which is marked unsafe because actual OS's assign special meaning to some//! integer values./// `ioctl(fd, TIOCSCTTY, 0)`—Sets the controlling terminal for the processs./// `kill(pid, sig)`—Sends a signal to a process./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html/// [Linux]: https://man7.org/linux/man-pages/man2/kill.2.html/// `kill(-pid, sig)`—Sends a signal to all processes in a process group./// If `pid` is 1, this sends a signal to all processes the current process/// has permission to send signals to, except process `1`, possibly other/// system-specific processes, and on some systems, the current process./// `kill(0, sig)`—Sends a signal to all processes in the current process/// `kill(pid, 0)`—Check validity of pid and permissions to send signals to/// the process, without actually sending any signals./// `kill(-pid, 0)`—Check validity of pid and permissions to send signals to/// all processes in the process group, without actually sending any signals./// `kill(0, 0)`—Check validity of pid and permissions to send signals to the/// all processes in the current process group, without actually sending any/// signals.r" A result from [`membarrier_query`]."r" These flags correspond to values of [`MembarrierCommand`] which are"r" supported in the OS."r" `MEMBARRIER_CMD_GLOBAL` (also known as `MEMBARRIER_CMD_SHARED`)"r" `MEMBARRIER_CMD_GLOBAL_EXPEDITED`"GLOBAL_EXPEDITEDr" `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED`"REGISTER_GLOBAL_EXPEDITEDr" `MEMBARRIER_CMD_PRIVATE_EXPEDITED`"PRIVATE_EXPEDITEDr" `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED`"REGISTER_PRIVATE_EXPEDITEDr" `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE`"PRIVATE_EXPEDITED_SYNC_COREr" `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE`"REGISTER_PRIVATE_EXPEDITED_SYNC_COREr" `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)"PRIVATE_EXPEDITED_RSEQr" `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)"REGISTER_PRIVATE_EXPEDITED_RSEQcontains_command/// Test whether this query result contains the given command./// `membarrier(MEMBARRIER_CMD_QUERY, 0, 0)`—Query the supported `membarrier`/// commands./// This function doesn't return a `Result` because it always succeeds; if/// the underlying OS doesn't support the `membarrier` syscall, it returns/// an empty `MembarrierQuery` value./// [Linux]: https://man7.org/linux/man-pages/man2/membarrier.2.html/// `membarrier(cmd, 0, 0)`—Perform a memory barrier./// `membarrier(cmd, MEMBARRIER_CMD_FLAG_CPU, cpu)`—Perform a memory barrier/// with a specific CPU.//! The Linux `membarrier` syscall.//! This file defines an enum and a bitflags type that represent the same//! set of values and are kept in sync.// WASI doesn't have get[gpu]id.// WASI doesn't have [gs]etpriority.// WASI doesn't have uname.// WASI doesn't have umask.//! Process-associated operations.r" `PIDFD_*` flags for use with [`pidfd_open`]."r" [`pidfd_open`]: crate::process::pidfd_open"r" `PIDFD_NONBLOCK`."/// `syscall(SYS_pidfd_open, pid, flags)`—Creates a file descriptor for/// a process./// [Linux]: https://man7.org/linux/man-pages/man2/pidfd_open.2.htmlprctl_1argprctl_2argsprctl_3argsprctl_get_at_arg2_optionalprctl_get_at_arg2parent_process_death_signal/// Get the current value of the parent process death signal.///  - [Linux: `prctl(PR_GET_PDEATHSIG,...)`]///  - [FreeBSD: `procctl(PROC_PDEATHSIG_STATUS,...)`]/// [Linux: `prctl(PR_GET_PDEATHSIG,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_PDEATHSIG_STATUS,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2set_parent_process_death_signal/// Set the parent-death signal of the calling process.///  - [Linux: `prctl(PR_SET_PDEATHSIG,...)`]///  - [FreeBSD: `procctl(PROC_PDEATHSIG_CTL,...)`]/// [Linux: `prctl(PR_SET_PDEATHSIG,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_PDEATHSIG_CTL,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2SUID_DUMP_DISABLESUID_DUMP_USERSUID_DUMP_ROOTDumpableBehaviorNotDumpable/// Not dumpable.Dumpable/// Dumpable.DumpableReadableOnlyByRoot/// Dumpable but only readable by root./// `SUID_DUMP_*` values for use with [`dumpable_behavior`] and/// [`set_dumpable_behavior`].dumpable_behavior/// Get the current state of the calling process's `dumpable` attribute.///  - [`prctl(PR_GET_DUMPABLE,...)`]/// [`prctl(PR_GET_DUMPABLE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_dumpable_behavior/// Set the state of the `dumpable` attribute, which determines whether the/// process can be traced and whether core dumps are produced for the calling/// process upon delivery of a signal whose default behavior is to produce a/// core dump./// A similar function with the same name is available on FreeBSD (as part of/// the `procctl` interface), but it has an extra argument which allows to/// select a process other then the current process.///  - [`prctl(PR_SET_DUMPABLE,...)`]/// [`prctl(PR_SET_DUMPABLE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlr" `PR_UNALIGN_*` flags for use with [`unaligned_access_control`] and"UnalignedAccessControlr" Silently fix up unaligned user accesses."NO_PRINTr" Generate a [`Signal::Bus`] signal on unaligned user access."unaligned_access_control/// Get unaligned access control bits.///  - [`prctl(PR_GET_UNALIGN,...)`]/// [`prctl(PR_GET_UNALIGN,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_unaligned_access_control/// Set unaligned access control bits.///  - [`prctl(PR_SET_UNALIGN,...)`]/// [`prctl(PR_SET_UNALIGN,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlr" `PR_FPEMU_*` flags for use with [`floating_point_emulation_control`]"r" and [`set_floating_point_emulation_control`]."FloatingPointEmulationControlr" Silently emulate floating point operations accesses."r" Don't emulate floating point operations, send a [`Signal::Fpe`]"r" signal instead."floating_point_emulation_control/// Get floating point emulation control bits.///  - [`prctl(PR_GET_FPEMU,...)`]/// [`prctl(PR_GET_FPEMU,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_floating_point_emulation_control/// Set floating point emulation control bits.///  - [`prctl(PR_SET_FPEMU,...)`]/// [`prctl(PR_SET_FPEMU,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlr" Zero means floating point exceptions are disabled."FloatingPointExceptionModer" Async non-recoverable exception mode."NONRECOVr" Async recoverable exception mode."r" Precise exception mode."PRECISEr" Use FPEXC for floating point exception enables."SW_ENABLEr" Floating point divide by zero."r" Floating point overflow."OVFr" Floating point underflow."UNDr" Floating point inexact result."r" Floating point invalid operation."INVfloating_point_exception_mode/// Get floating point exception mode.///  - [`prctl(PR_GET_FPEXC,...)`]/// [`prctl(PR_GET_FPEXC,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_floating_point_exception_mode/// Set floating point exception mode.///  - [`prctl(PR_SET_FPEXC,...)`]/// [`prctl(PR_SET_FPEXC,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlTimingMethodStatistical/// Normal, traditional, statistical process timing.TimeStamp/// Accurate timestamp based process timing./// `PR_TIMING_*` values for use with [`timing_method`] and/// [`set_timing_method`].timing_method/// Get which process timing method is currently in use.///  - [`prctl(PR_GET_TIMING,...)`]/// [`prctl(PR_GET_TIMING,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_timing_method/// Set whether to use (normal, traditional) statistical process timing or/// accurate timestamp-based process timing.///  - [`prctl(PR_SET_TIMING,...)`]/// [`prctl(PR_SET_TIMING,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlEndianMode/// Big endian mode./// True little endian mode.PowerPCLittle/// `PowerPC` pseudo little endian./// `PR_ENDIAN_*` values for use with [`endian_mode`].endian_mode/// Get the endianness of the calling process.///  - [`prctl(PR_GET_ENDIAN,...)`]/// [`prctl(PR_GET_ENDIAN,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_endian_mode/// Set the endianness of the calling process.///  - [`prctl(PR_SET_ENDIAN,...)`]/// Please ensure the conditions necessary to safely call this function,/// as detailed in the references above./// [`prctl(PR_SET_ENDIAN,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlTimeStampCounterReadability/// Allow the use of the timestamp counter.RaiseSIGSEGV/// Throw a [`Signal::Segv`] signal instead of reading the TSC./// `PR_TSC_*` values for use with [`time_stamp_counter_readability`] and/// [`set_time_stamp_counter_readability`].time_stamp_counter_readability/// Get the state of the flag determining if the timestamp counter can be read.///  - [`prctl(PR_GET_TSC,...)`]/// [`prctl(PR_GET_TSC,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_time_stamp_counter_readability/// Set the state of the flag determining if the timestamp counter can be read/// by the process.///  - [`prctl(PR_SET_TSC,...)`]/// [`prctl(PR_SET_TSC,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlconfigure_performance_counters/// Enable or disable all performance counters attached to the calling process.///  - [`prctl(PR_TASK_PERF_EVENTS_ENABLE,...)`]///  - [`prctl(PR_TASK_PERF_EVENTS_DISABLE,...)`]/// [`prctl(PR_TASK_PERF_EVENTS_ENABLE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [`prctl(PR_TASK_PERF_EVENTS_DISABLE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlMachineCheckMemoryCorruptionKillPolicyLate/// Late kill policy./// Early kill policy./// System-wide default policy./// `PR_MCE_KILL_*` values for use with/// [`machine_check_memory_corruption_kill_policy`] and/// [`set_machine_check_memory_corruption_kill_policy`].machine_check_memory_corruption_kill_policy/// Get the current per-process machine check kill policy.///  - [`prctl(PR_MCE_KILL_GET,...)`]/// [`prctl(PR_MCE_KILL_GET,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_machine_check_memory_corruption_kill_policy/// Set the machine check memory corruption kill policy for the calling thread.///  - [`prctl(PR_MCE_KILL,...)`]/// [`prctl(PR_MCE_KILL,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlVirtualMemoryMapAddressCodeStart/// Set the address above which the program text can run.CodeEnd/// Set the address below which the program text can run.DataStart/// Set the address above which initialized and uninitialized (bss) data/// are placed./// Set the address below which initialized and uninitialized (bss) dataStackStart/// Set the start address of the stack.BrkStart/// Set the address above which the program heap can be expanded with `brk`BrkCurrent/// Set the current `brk` value.ArgStart/// Set the address above which the program command line is placed.ArgEnd/// Set the address below which the program command line is placed.EnvironmentStart/// Set the address above which the program environment is placed.EnvironmentEnd/// Set the address below which the program environment is placed./// `PR_SET_MM_*` values for use with [`set_virtual_memory_map_address`].set_virtual_memory_map_address/// Modify certain kernel memory map descriptor addresses of the calling///  - [`prctl(PR_SET_MM,...)`]/// [`prctl(PR_SET_MM,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_executable_file/// Supersede the `/proc/pid/exe` symbolic link with a new one pointing to a/// new executable file.///  - [`prctl(PR_SET_MM,PR_SET_MM_EXE_FILE,...)`]/// [`prctl(PR_SET_MM,PR_SET_MM_EXE_FILE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_auxiliary_vector/// Set a new auxiliary vector.///  - [`prctl(PR_SET_MM,PR_SET_MM_AUXV,...)`]/// [`prctl(PR_SET_MM,PR_SET_MM_AUXV,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlvirtual_memory_map_config_struct_size/// Get the size of the [`PrctlMmMap`] the kernel expects.///  - [`prctl(PR_SET_MM,PR_SET_MM_MAP_SIZE,...)`]/// [`prctl(PR_SET_MM,PR_SET_MM_MAP_SIZE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Code section start address./// Code section end address./// Data section start address./// Data section end address./// `brk` start address./// `brk` current address./// Stack start address./// Program command line start address./// Program command line end address./// Program environment start address./// Program environment end address./// Auxiliary vector start address./// Auxiliary vector size./// File descriptor of executable file that was used to create thisPrctlMmMap/// This structure provides new memory descriptor map which mostly modifies/// `/proc/pid/stat[m]` output for a task./// This mostly done in a sake of checkpoint/restore functionality.configure_virtual_memory_map/// Provides one-shot access to all the addresses by passing in a/// [`PrctlMmMap`].///  - [`prctl(PR_SET_MM,PR_SET_MM_MAP,...)`]/// [`prctl(PR_SET_MM,PR_SET_MM_MAP,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlPTracer/// None./// Disable `ptrace` restrictions for the calling process.ProcessID/// Specific process./// Process ptracer.set_ptracer/// Declare that the ptracer process can `ptrace` the calling process as if it/// were a direct process ancestor.///  - [`prctl(PR_SET_PTRACER,...)`]/// [`prctl(PR_SET_PTRACER,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlchild_subreaper/// Get the `child subreaper` setting of the calling process.///  - [`prctl(PR_GET_CHILD_SUBREAPER,...)`]/// [`prctl(PR_GET_CHILD_SUBREAPER,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Set the `child subreaper` attribute of the calling process.///  - [`prctl(PR_SET_CHILD_SUBREAPER,...)`]/// [`prctl(PR_SET_CHILD_SUBREAPER,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlFloatingPointModeFloatingPointRegisters/// 64-bit floating point registers.FloatingPointEmulation/// Enable emulation of 32-bit floating-point mode./// `PR_FP_MODE_*` values for use with [`floating_point_mode`] and/// [`set_floating_point_mode`].floating_point_mode/// Get the current floating point mode.///  - [`prctl(PR_GET_FP_MODE,...)`]/// [`prctl(PR_GET_FP_MODE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_floating_point_mode/// Allow control of the floating point mode from user space.///  - [`prctl(PR_SET_FP_MODE,...)`]/// [`prctl(PR_SET_FP_MODE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlSpeculationFeatureSpeculativeStoreBypass/// Set the state of the speculative store bypass misfeature.IndirectBranchSpeculation/// Set the state of the indirect branch speculation misfeature.FlushL1DCacheOnContextSwitchOutOfTask/// Flush L1D Cache on context switch out of the task./// `PR_SPEC_*` values for use with [`speculative_feature_state`] and/// [`control_speculative_feature`].r" `PR_SPEC_*` flags for use with [`control_speculative_feature`]."SpeculationFeatureControlr" The speculation feature is enabled, mitigation is disabled."ENABLEr" The speculation feature is disabled, mitigation is enabled."DISABLEr" The speculation feature is disabled, mitigation is enabled, and it cannot be undone."FORCE_DISABLEr" The speculation feature is disabled, mitigation is enabled, and the state will be cleared on `execve`."DISABLE_NOEXECr" Zero means the processors are not vulnerable."SpeculationFeatureStater" Mitigation can be controlled per thread by `PR_SET_SPECULATION_CTRL`."PRCTLspeculative_feature_state/// Get the state of the speculation misfeature.///  - [`prctl(PR_GET_SPECULATION_CTRL,...)`]/// [`prctl(PR_GET_SPECULATION_CTRL,...)`]: https://www.kernel.org/doc/html/v5.18/userspace-api/spec_ctrl.htmlcontrol_speculative_feature/// Sets the state of the speculation misfeature.///  - [`prctl(PR_SET_SPECULATION_CTRL,...)`]/// [`prctl(PR_SET_SPECULATION_CTRL,...)`]: https://www.kernel.org/doc/html/v5.18/userspace-api/spec_ctrl.htmlis_io_flusher/// Get the `IO_FLUSHER` state of the caller.///  - [`prctl(PR_GET_IO_FLUSHER,...)`]/// [`prctl(PR_GET_IO_FLUSHER,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlconfigure_io_flusher_behavior/// Put the process in the `IO_FLUSHER` state, allowing it to make progress/// when allocating memory.///  - [`prctl(PR_SET_IO_FLUSHER,...)`]/// [`prctl(PR_SET_IO_FLUSHER,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlr" `PR_PAC_AP*`."PointerAuthenticationKeysr" Instruction authentication key `A`."INSTRUCTION_AUTHENTICATION_KEY_Ar" Instruction authentication key `B`."INSTRUCTION_AUTHENTICATION_KEY_Br" Data authentication key `A`."DATA_AUTHENTICATION_KEY_Ar" Data authentication key `B`."DATA_AUTHENTICATION_KEY_Br" Generic authentication `A` key."GENERIC_AUTHENTICATION_KEY_Aenabled_pointer_authentication_keys/// Get enabled pointer authentication keys.///  - [`prctl(PR_PAC_GET_ENABLED_KEYS,...)`]/// [`prctl(PR_PAC_GET_ENABLED_KEYS,...)`]: https://www.kernel.org/doc/html/v5.18/arm64/pointer-authentication.htmlconfigure_pointer_authentication_keys/// Set enabled pointer authentication keys.///  - [`prctl(PR_PAC_SET_ENABLED_KEYS,...)`]/// [`prctl(PR_PAC_SET_ENABLED_KEYS,...)`]: https://www.kernel.org/doc/html/v5.18/arm64/pointer-authentication.htmlset_virtual_memory_region_name/// Set the name for a virtual memory region.///  - [`prctl(PR_SET_VMA,PR_SET_VMA_ANON_NAME,...)`]/// [`prctl(PR_SET_VMA,PR_SET_VMA_ANON_NAME,...)`]: https://lwn.net/Articles/867818///! Bindings for the Linux `prctl` system call.//! There are similarities (but also differences) with FreeBSD's `procctl`//! system call, whose interface is located in the `procctl.rs` file.// Helper functions.// PR_GET_PDEATHSIG/PR_SET_PDEATHSIG// PR_GET_DUMPABLE/PR_SET_DUMPABLE// PR_GET_UNALIGN/PR_SET_UNALIGN// PR_GET_FPEMU/PR_SET_FPEMU// PR_GET_FPEXC/PR_SET_FPEXC// PR_GET_TIMING/PR_SET_TIMING// PR_GET_ENDIAN/PR_SET_ENDIAN// PR_GET_TSC/PR_SET_TSC// PR_TASK_PERF_EVENTS_DISABLE/PR_TASK_PERF_EVENTS_ENABLE// PR_MCE_KILL_GET/PR_MCE_KILL// PR_SET_MM// PR_SET_PTRACER// PR_GET_CHILD_SUBREAPER/PR_SET_CHILD_SUBREAPER// PR_GET_FP_MODE/PR_SET_FP_MODE// PR_GET_SPECULATION_CTRL/PR_SET_SPECULATION_CTRL// PR_GET_IO_FLUSHER/PR_SET_IO_FLUSHER// PR_PAC_GET_ENABLED_KEYS/PR_PAC_SET_ENABLED_KEYS// PR_SET_VMA/// `nice(inc)`—Adjust the scheduling priority of the current process./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/nice.html/// [Linux]: https://man7.org/linux/man-pages/man2/nice.2.html/// `getpriority(PRIO_USER, uid)`—Get the scheduling priority of the given/// user./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpriority.html/// [Linux]: https://man7.org/linux/man-pages/man2/getpriority.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setpriority.2.html/// `getpriority(PRIO_PGRP, gid)`—Get the scheduling priority of the given/// process group./// A `pgid` of `None` means the process group of the calling process./// `getpriority(PRIO_PROCESS, pid)`—Get the scheduling priority of the given/// A `pid` of `None` means the calling process./// `setpriority(PRIO_USER, uid)`—Get the scheduling priority of the given/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setpriority.html/// [Linux]: https://man7.org/linux/man-pages/man2/setpriority.2.html/// `setpriority(PRIO_PGRP, pgid)`—Get the scheduling priority of the given/// `setpriority(PRIO_PROCESS, pid)`—Get the scheduling priority of the givenIdType/// Process id.Pgid/// Process group id./// Subset of `idtype_t` C enum, with only the values allowed by `procctl`.ProcSelector/// A process selector for use with the `procctl` interface./// `None` represents the current process. `Some((IdType::Pid, pid))`/// represents the process with pid `pid`. `Some((IdType::Pgid, pgid))`/// represents the control processes belonging to the process group with id/// `pgid`.proc_selector_to_rawprocctl_setprocctl_get_optionalNotDumpableExecPreserved/// Not dumpable, and this behaviour is preserved across `execve` calls./// `PROC_TRACE_CTL_*`./// Set the state of the `dumpable` attribute for the process indicated by/// `idtype` and `id`. This determines whether the process can be traced and/// whether core dumps are produced for the process upon delivery of a signal/// whose default behavior is to produce a core dump./// This is similar to `set_dumpable_behavior` on Linux, with the exception/// that on FreeBSD there is an extra argument `process`. When `process` is set/// to `None`, the operation is performed for the current process, like on/// Linux.///  - [FreeBSD `procctl(PROC_TRACE_CTL,...)`]/// [FreeBSD `procctl(PROC_TRACE_CTL,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2TracingStatusNotTraceble/// Tracing is disabled for the process.Tracable/// Tracing is not disabled for the process, but not debugger/tracer is/// attached.BeingTraced/// The process is being traced by the process whose pid is stored in the/// first component of this variant./// Tracing status as returned by [`trace_status`].trace_status/// Get the tracing status of the process indicated by `idtype` and `id`.///  - [FreeBSD `procctl(PROC_TRACE_STATUS,...)`]/// [FreeBSD `procctl(PROC_TRACE_STATUS,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2set_reaper_status/// Acquire or release the reaper status of the calling process.///  - [FreeBSD: `procctl(PROC_REAP_ACQUIRE/RELEASE,...)`]/// [FreeBSD: `procctl(PROC_REAP_ACQUIRE/RELEASE,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2rs_flagsrs_childrenrs_descendantsrs_reaperrs_pidrs_pad0procctl_reaper_statusReaperStatusFlags/// The flags./// The number of children of the reaper among the descendants./// The total number of descendants of the reaper(s), not counting/// descendants of the reaper in the subtree.reaper/// The pid of the reaper for the specified process id./// The pid of one reaper child if there are any descendants.ReaperStatus/// Reaper status as returned by [`get_reaper_status`].get_reaper_status/// Get information about the reaper of the specified process (or the process/// itself if it is a reaper).///  - [FreeBSD: `procctl(PROC_REAP_STATUS,...)`]/// [FreeBSD: `procctl(PROC_REAP_STATUS,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2pi_pidpi_subtreepi_flagspi_pad0procctl_reaper_pidinforp_countrp_pad0rp_pidsprocctl_reaper_pidsPidInfoFlags/// The flags of the process./// The pid of the process.subtree/// The pid of the child of the reaper which is the (grand-..)parent of thePidInfo/// A child process of a reaper.get_reaper_pids/// Get the list of descendants of the specified reaper process.///  - [FreeBSD: `procctl(PROC_REAP_GETPIDS,...)`]/// [FreeBSD: `procctl(PROC_REAP_GETPIDS,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2rk_sigrk_flagsrk_subtreerk_killedrk_fpidrk_pad0procctl_reaper_killkilled/// The number of processes that were signalled.first_failed/// The pid of the first process that wasn't successfully signalled.KillResultreaper_kill/// Deliver a signal to some subset of///  - [FreeBSD: `procctl(PROC_REAP_KILL,...)`]/// [FreeBSD: `procctl(PROC_REAP_KILL,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2TrapCapBehavior/// Disable the [`Signal::Trap`] signal delivery on capability mode accessEnable/// Enable the [`Signal::Trap`] signal delivery on capability mode access/// `PROC_TRAPCAP_CTL_*`.set_trap_cap_behavior/// Set the current value of the capability mode violation trapping behavior./// If this behavior is enabled, the kernel would deliver a [`Signal::Trap`]/// signal on any return from a system call that would result in a/// [`io::Errno::NOTCAPABLE`]` or [`io::Errno::CAPMODE`] error./// This behavior is inherited by the children of the process and is kept/// across `execve` calls.///  - [FreeBSD: `procctl(PROC_TRAPCAP_CTL,...)`]/// [FreeBSD: `procctl(PROC_TRAPCAP_CTL,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2trap_cap_behavior/// Get the current value of the capability mode violation trapping behavior.///  - [FreeBSD: `procctl(PROC_TRAPCAP_STATUS,...)`]/// [FreeBSD: `procctl(PROC_TRAPCAP_STATUS,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2/// Enable the `no_new_privs` mode that ignores SUID and SGID bits/// on `execve` in the specified process and its future descendants./// This is similar to `set_no_new_privs` on Linux, with the exception/// that on FreeBSD there is no argument `no_new_privs` argument as it's/// only possible to enable this mode and there's no going back.///  - [Linux: `prctl(PR_SET_NO_NEW_PRIVS,...)`]///  - [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_CTL,...)`]/// [Linux: `prctl(PR_SET_NO_NEW_PRIVS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_CTL,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2no_new_privs/// Check the `no_new_privs` mode of the specified process.///  - [Linux: `prctl(PR_GET_NO_NEW_PRIVS,...)`]///  - [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_STATUS,...)`]/// [Linux: `prctl(PR_GET_NO_NEW_PRIVS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_STATUS,...)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2//! Bindings for the FreeBSD `procctl` system call.//! There are similarities (but also differences) with Linux's `prctl` system//! call, whose interface is located in the `prctl.rs` file.// PROC_PDEATHSIG_STATUS/PROC_PDEATHSIG_CTL// PROC_TRACE_CTL// PROC_TRACE_STATUS// PROC_REAP_*// PROC_TRAPCAP_STATUS/PROC_TRAPCAP_CTL// PROC_NO_NEW_PRIVS_STATUS/PROC_NO_NEW_PRIVS_CTL/// Current effective, “soft”, limit./// Maximum, “hard”, value that `current` may be dynamically increased to./// `struct rlimit`—Current and maximum values used in [`getrlimit`],/// [`setrlimit`], and [`prlimit`]./// `getrlimit(resource)`—Get a process resource limit value./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getrlimit.html/// [Linux]: https://man7.org/linux/man-pages/man2/getrlimit.2.html/// `setrlimit(resource, new)`—Set a process resource limit value./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setrlimit.html/// [Linux]: https://man7.org/linux/man-pages/man2/setrlimit.2.html/// `prlimit(pid, resource, new)`—Get and set a process resource limit value./// [Linux]: https://man7.org/linux/man-pages/man2/prlimit.2.html/// `CpuSet` represents a bit-mask of CPUs./// `CpuSet`s are used by [`sched_setaffinity`] and [`sched_getaffinity`], for/// [Linux]: https://man7.org/linux/man-pages/man3/CPU_SET.3.html/// [`sched_setaffinity`]: crate::process::sched_setaffinity/// [`sched_getaffinity`]: crate::process::sched_getaffinityMAX_CPU/// The maximum number of CPU in `CpuSet`./// Create a new and empty `CpuSet`./// Test to see if a CPU is in the `CpuSet`./// `field` is the CPU id to test./// Add a CPU to `CpuSet`./// `field` is the CPU id to add./// Remove a CPU from `CpuSet`./// `field` is the CPU id to remove./// Count the number of CPUs set in the `CpuSet`./// Zeroes the `CpuSet`./// `sched_setaffinity(pid, cpuset)`—Set a thread's CPU affinity mask./// `pid` is the thread ID to update. If pid is `None`, then the current thread/// The `CpuSet` argument specifies the set of CPUs on which the thread will/// be eligible to run./// [Linux]: https://man7.org/linux/man-pages/man2/sched_setaffinity.2.html/// `sched_getaffinity(pid)`—Get a thread's CPU affinity mask./// `pid` is the thread ID to check. If pid is `None`, then the current thread/// is checked./// Returns the set of CPUs on which the thread is eligible to run./// [Linux]: https://man7.org/linux/man-pages/man2/sched_getaffinity.2.html/// `sched_yield()`—Hints to the OS that other processes should run./// This function always succeeds./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_yield.html/// [Linux]: https://man7.org/linux/man-pages/man2/sched_yield.2.htmlUname/// `uname()`—Returns high-level information about the runtime OS and/// hardware./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/uname.html/// [Linux]: https://man7.org/linux/man-pages/man2/uname.2.html/// `struct utsname`—Return type for [`uname`]./// `sysname`—Operating system release name/// `nodename`—Name with vague meaning/// This is intended to be a network name, however it's unable to convey/// information about hosts that have multiple names, or any information/// about where the names are visible./// `release`—Operating system release version string/// `version`—Operating system build identifiers/// `machine`—Hardware architecture identifier/// `domainname`—NIS or YP domain identifier/// `sysinfo()`—Returns status information about the runtime OS./// `sethostname(name)`—Sets the system host name./// [Linux]: https://man7.org/linux/man-pages/man2/sethostname.2.html//! Uname and other system-level functions.//! This function converts from `struct utsname` fields provided from the//! kernel into `&str` references, which assumes that they're NUL-terminated./// `umask(mask)`—Set the process file creation mask./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/umask.html/// [Linux]: https://man7.org/linux/man-pages/man2/umask.2.html//! Umask support.r" Options for modifying the behavior of wait/waitpid"r" Return immediately if no child has exited."r" Return if a child has stopped (but not traced via [`ptrace`])"r" [`ptrace`]: https://man7.org/linux/man-pages/man2/ptrace.2.html"UNTRACEDr" Return if a stopped child has been resumed by delivery of"r" [`Signal::Cont`]."CONTINUEDr" Options for modifying the behavior of waitid"r" [`Signal::Cont`]"r" Wait for processed that have exited."EXITEDr" Keep processed in a waitable state."r" Wait for processes that have been stopped."STOPPED/// The status of a child process after calling [`wait`]/[`waitpid`]./// Creates a `WaitStatus` out of an integer./// Converts a `WaitStatus` into its raw representation as an integer./// Returns whether the process is currently stopped./// Returns whether the process has exited normally./// Returns whether the process was terminated by a signal./// Returns whether the process has continued from a job control stop.stopping_signal/// Returns the number of the signal that stopped the process,/// if the process was stopped by a signal./// Returns the exit status number returned by the process,/// if it exited normally.terminating_signal/// Returns the number of the signal that terminated the process,/// if the process was terminated by a signal./// The status of a process after calling [`waitid`].trapped/// Returns whether the process is currently trapped./// Returns whether the process was terminated by a signal/// and did not create a core file.dumped/// and did create a core file.trapping_signal/// Returns the number of the signal that trapped the process,/// if the process was trapped by a signal./// Returns a reference to the raw platform-specific `siginfo_t` struct./// Wait on all processes./// Wait for a specific process ID.PidFd/// Wait for a specific process file descriptor.// TODO(notgull): Once this crate has the concept of PGIDs, add a WaitId::Pgid/// The identifier to wait on in a call to [`waitid`]./// `waitpid(pid, waitopts)`—Wait for a specific process to change state./// If the pid is `None`, the call will wait for any child process whose/// process group id matches that of the calling process./// If the pid is equal to `RawPid::MAX`, the call will wait for any child/// Otherwise if the `wrapping_neg` of pid is less than pid, the call will wait/// for any child process with a group ID equal to the `wrapping_neg` of `pid`./// Otherwise, the call will wait for the child process with the given pid./// On Success, returns the status of the selected process./// If `NOHANG` was specified in the options, and the selected child process/// didn't change state, returns `None`./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html/// [Linux]: https://man7.org/linux/man-pages/man2/waitpid.2.html/// `wait(waitopts)`—Wait for any of the children of calling process to/// change state./// On success, returns the pid of the child process whose state changed, and/// the status of said process./// `waitid(_, _, _, opts)`—Wait for the specified child process to change/// `posix_openpt(flags)`—Open a pseudoterminal device./// On Linux, an additional `CLOEXEC` flag value may be passed to request the/// close-on-exec flag be set./// On Linux, if the system has no free pseudoterminals available, the/// underlying system call fails with [`io::Errno::NOSPC`], however this rustix/// function translates that to [`io::Errno::AGAIN`], so that the linux_raw and/// libc backends have the same behavior./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_openpt.html/// [Linux]: https://man7.org/linux/man-pages/man3/posix_openpt.3.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/posix_openpt.3.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=posix_openpt&sektion=2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=posix_openpt&section=3/// [NetBSD]: https://man.netbsd.org/posix_openpt.3/// [OpenBSD]: https://man.openbsd.org/posix_openpt/// [illumos]: https://illumos.org/man/3C/posix_openpt/// `ptsname(fd)`—Return the name of a pseudoterminal./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/ptsname.html/// [Linux]: https://man7.org/linux/man-pages/man3/ptsname.3.html/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Allocation.html#index-ptsname/// `unlockpt(fd)`—Unlock a pseudoterminal./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlockpt.html/// [Linux]: https://man7.org/linux/man-pages/man3/unlockpt.3.html/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Allocation.html#index-unlockpt/// `grantpt(fd)`—Grant access to the user side of a pseudoterminal./// On Linux, calling this function has no effect, as the kernel is expected to/// grant the appropriate access. On all other platorms, this function has/// unspecified behavior if the calling process has a `SIGCHLD` signal handler/// installed./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/grantpt.html/// [Linux]: https://man7.org/linux/man-pages/man3/grantpt.3.html/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Allocation.html#index-grantpt/// `ioctl(fd, TIOCGPTPEER)`—Open the user side of a pseduoterminal./// This function is currently only implemented on Linux.//! Pseudoterminal operations.//! For the `openpty` and `login_tty` functions, see the//! [rustix-openpty crate].//! [rustix-openpty crate]: https://crates.io/crates/rustix-openpty/// `GRND_*` constants for use with `getrandom`./// `getrandom(buf, flags)`—Reads a sequence of random bytes./// This is a very low-level API which may be difficult to use correctly. Most/// users should prefer to use [`getrandom`] or [`rand`] APIs instead./// [`getrandom`]: https://crates.io/crates/getrandom/// [`rand`]: https://crates.io/crates/rand/// [Linux]: https://man7.org/linux/man-pages/man2/getrandom.2.html//! Random-related operations./// `sigaction`/// `stack_t`/// `sigset_t`/// `siginfo_t`/// `SIG_BLOCK`UNBLOCK/// `SIG_UNBLOCK`SETMASK/// `SIG_SETMASK`/// `SIG_*` constants for use with [`sigprocmask`]./// `prctl(PR_SET_FS, data)`—Set the x86_64 `fs` register./// This is a very low-level feature for implementing threading libraries./// See the references links above./// Set the x86_64 thread ID address./// `prctl(PR_SET_NAME, name)`/// [Linux]: https://man7.org/linux/man-pages/man2/prctl.2.html/// `syscall(SYS_exit, status)`—Exit the current thread./// Exit all the threads in the current process' thread group./// This is equivalent to `_exit` and `_Exit` in libc./// This does not all any `__cxa_atexit`, `atexit`, or any other destructors./// Most programs should use [`std::process::exit`] instead of calling this///  - [POSIX `_Exit`]///  - [Linux `exit_group`]///  - [Linux `_Exit`]/// [POSIX `_Exit`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/_Exit.html/// [Linux `exit_group`]: https://man7.org/linux/man-pages/man2/exit_group.2.html/// [Linux `_Exit`]: https://man7.org/linux/man-pages/man2/_Exit.2.html/// Return fields from the main executable segment headers ("phdrs") relevant/// to initializing TLS provided to the program at startup./// `(getauxval(AT_PHDR), getauxval(AT_PHNUM))`—Returns the address and/// number of ELF segment headers for the main executable./// `fork()`—Creates a new process by duplicating the calling process./// On success, the pid of the child process is returned in the parent, and/// `None` is returned in the child./// Unlike its POSIX and libc counterparts, this `fork` does not invoke any/// handlers (such as those registered with `pthread_atfork`)./// The program environment in the child after a `fork` and before an `execve`/// is very special. All code that executes in this environment must avoid:///  - Acquiring any other locks that are held in other threads on the parent///    at the time of the `fork`, as the child only contains one thread, and///    attempting to acquire such locks will deadlock (though this is [not///    considered unsafe]).///  - Performing any dynamic allocation using the global allocator, since///    global allocators may use locks to ensure thread safety, and their locks///    may not be released in the child process, so attempts to allocate may///    deadlock (as described in the previous point).///  - Accessing any external state which the parent assumes it has exclusive///    access to, such as a file protected by a file lock, as this could///    corrupt the external state.///  - Accessing any random-number-generator state inherited from the parent,///    as the parent may have the same state and generate the same random///    numbers, which may violate security invariants.///  - Accessing any thread runtime state, since this function does not update///    the thread id in the thread runtime, so thread runtime functions could///    cause undefined behavior.///  - Accessing any memory shared with the parent, such as a [`MAP_SHARED`]///    mapping, even with anonymous or [`memfd_create`] mappings, as this could///  - Calling any C function which isn't known to be [async-signal-safe], as///    that could cause undefined behavior. The extent to which this also///    applies to Rust functions is unclear at this time./// The child must avoid accessing any memory shared with the parent in a/// way that invokes undefined behavior. It must avoid accessing any threading/// runtime functions in a way that invokes undefined behavior. And it must/// avoid invoking any undefined behavior through any function that is not/// guaranteed to be async-signal-safe./// # Literary interlude/// > Do not jump on ancient uncles./// > Do not yell at average mice./// > Do not wear a broom to breakfast./// > Do not ask a snake’s advice./// > Do not bathe in chocolate pudding./// > Do not talk to bearded bears./// > Do not smoke cigars on sofas./// > Do not dance on velvet chairs./// > Do not take a whale to visit/// > Russell’s mother’s cousin’s yacht./// > And whatever else you do do/// > It is better you/// > Do not./// - “Rules”, by Karla Kuskin/// [`MAP_SHARED`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mmap.html/// [not considered unsafe]: https://doc.rust-lang.org/reference/behavior-not-considered-unsafe.html#deadlocks/// [`memfd_create`]: https://man7.org/linux/man-pages/man2/memfd_create.2.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html/// [Linux]: https://man7.org/linux/man-pages/man2/fork.2.html/// [async-signal-safe]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04_03/// `execveat(dirfd, path.as_c_str(), argv, envp, flags)`—Execute a new/// command using the current process./// The `argv` and `envp` pointers must point to NUL-terminated arrays, and/// their contents must be pointers to NUL-terminated byte arrays./// [Linux]: https://man7.org/linux/man-pages/man2/execveat.2.html/// `execve(path.as_c_str(), argv, envp)`—Execute a new command using the/// current process./// [Linux]: https://man7.org/linux/man-pages/man2/execve.2.html/// `sigaction(signal, &new, &old)`—Modify or query a signal handler./// You're on your own. And on top of all the troubles with signal handlers,/// this implementation is highly experimental. Even further, it differs from/// the libc `sigaction` in several non-obvious and unsafe ways./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigaction.html/// [Linux]: https://man7.org/linux/man-pages/man2/sigaction.2.html/// `sigaltstack(new, old)`—Modify or query a signal stack./// this implementation is highly experimental./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigaltstack.html/// [Linux]: https://man7.org/linux/man-pages/man2/sigaltstack.2.html/// `tkill(tid, sig)`—Send a signal to a thread./// this implementation is highly experimental. The warning about the hazard/// of recycled thread ID's applies./// [Linux]: https://man7.org/linux/man-pages/man2/tkill.2.html/// `sigprocmask(how, set, oldset)`—Adjust the process signal mask./// the libc `sigprocmask` in several non-obvious and unsafe ways.///  - [Linux `sigprocmask`]///  - [Linux `pthread_sigmask`]/// [Linux `sigprocmask`]: https://man7.org/linux/man-pages/man2/sigprocmask.2.html/// [Linux `pthread_sigmask`]: https://man7.org/linux/man-pages/man3/pthread_sigmask.3.html/// `sigwait(set)`—Wait for signals./// If code elsewhere in the process is depending on delivery of a signal to/// prevent it from executing some code, this could cause it to miss that/// signal and execute that code./// [Linux]: https://man7.org/linux/man-pages/man3/sigwait.3.html/// `sigwait(set)`—Wait for signals, returning a [`Siginfo`]./// [Linux]: https://man7.org/linux/man-pages/man2/sigwaitinfo.2.html/// `sigtimedwait(set)`—Wait for signals, optionally with a timeout./// [Linux]: https://man7.org/linux/man-pages/man2/sigtimedwait.2.html//! Low-level implementation details for libc-like runtime libraries such as//! [origin].//! Do not use the functions in this module unless you've read all of their//! code, *and* you know all the relevant internal implementation details of//! any libc in the process they'll be used.//! These functions are for implementing thread-local storage (TLS), managing//! threads, loaded libraries, and other process-wide resources. Most of//! `rustix` doesn't care about what other libraries are linked into the//! program or what they're doing, but the features in this module generally//! can only be used by one entity within a process.//! The API for these functions is not stable, and this module is//! `doc(hidden)`.//! [origin]: https://github.com/sunfishcode/mustang/tree/main/origin//! This module is intended to be used for implementing a runtime library such//! as libc. Use of these features for any other purpose is likely to create//! serious problems./// `cfgetospeed(termios)`/// `cfgetispeed(termios)`/// `cfmakeraw(termios)`/// `cfsetospeed(termios, speed)`/// `cfsetispeed(termios, speed)`/// `cfsetspeed(termios, speed)`speed_value/// Translate from a `Speed` code to a speed value `u32`./// let speed = rustix::termios::speed_value(rustix::termios::B57600);/// assert_eq!(speed, Some(57600));cftty//! Terminal I/O stream operations./// `tcgetattr(fd)`—Get terminal attributes./// Also known as the `TCGETS` operation with `ioctl`.///  - [POSIX `tcgetattr`]///  - [Linux `ioctl_tty`]///  - [Linux `termios`]/// [POSIX `tcgetattr`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetattr.html/// [Linux `ioctl_tty`]: https://man7.org/linux/man-pages/man4/tty_ioctl.4.html/// [Linux `termios`]: https://man7.org/linux/man-pages/man3/termios.3.html/// `tcgetattr2(fd)`—Get terminal attributes./// Also known as the `TCGETS2` operation with `ioctl`./// `tcgetwinsize(fd)`—Get the current terminal window size./// Also known as the `TIOCGWINSZ` operation with `ioctl`./// `tcgetpgrp(fd)`—Get the terminal foreground process group./// Also known as the `TIOCGPGRP` operation with `ioctl`./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetpgrp.html/// [Linux]: https://man7.org/linux/man-pages/man3/tcgetpgrp.3.html/// `tcsetpgrp(fd, pid)`—Set the terminal foreground process group./// Also known as the `TIOCSPGRP` operation with `ioctl`./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsetpgrp.html/// [Linux]: https://man7.org/linux/man-pages/man3/tcsetpgrp.3.html/// `tcsetattr(fd)`—Set terminal attributes./// Also known as the `TCSETS` operation with `ioctl`.///  - [POSIX `tcsetattr`]/// [POSIX `tcsetattr`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsetattr.html/// `tcsetattr2(fd)`—Set terminal attributes./// Also known as the `TCSETS2` operation with `ioctl`./// `tcsendbreak(fd, 0)`—Transmit zero-valued bits./// Also known as the `TCSBRK` operation with `ioctl`, with a duration of 0./// This function always uses an effective duration parameter of zero. For the/// equivalent of a `tcsendbreak` with a non-zero duration parameter, use/// `tcdrain`.///  - [POSIX `tcsendbreak`]/// [POSIX `tcsendbreak`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsendbreak.html/// `tcdrain(fd, duration)`—Wait until all pending output has been written.///  - [POSIX `tcdrain`]/// [POSIX `tcsetattr`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcdrain.html/// `tcflush(fd, queue_selector)`—Wait until all pending output has been/// written.///  - [POSIX `tcflush`]/// [POSIX `tcflush`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcflush.html/// `tcflow(fd, action)`—Suspend or resume transmission or reception.///  - [POSIX `tcflow`]/// [POSIX `tcflow`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcflow.html/// `tcgetsid(fd)`—Return the session ID of the current session with `fd` as/// its controlling terminal./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetsid.html/// [Linux]: https://man7.org/linux/man-pages/man3/tcgetsid.3.html/// `tcsetwinsize(fd)`—Set the current terminal window size./// Also known as the `TIOCSWINSZ` operation with `ioctl`./// `isatty(fd)`—Tests whether a file descriptor refers to a terminal./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/isatty.html/// [Linux]: https://man7.org/linux/man-pages/man3/isatty.3.html/// `ttyname_r(fd)`/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/ttyname.html/// [Linux]: https://man7.org/linux/man-pages/man3/ttyname.3.html_ttyname//! Functions which operate on file descriptors which might be terminals./// `clock_nanosleep(id, 0, request, remain)`—Sleeps for a duration on a/// given clock./// This is `clock_nanosleep` specialized for the case of a relative sleep/// interval. See [`clock_nanosleep_absolute`] for absolute intervals./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_nanosleep.html/// [Linux]: https://man7.org/linux/man-pages/man2/clock_nanosleep.2.html/// `clock_nanosleep(id, TIMER_ABSTIME, request, NULL)`—Sleeps until an/// absolute time on a given clock./// This is `clock_nanosleep` specialized for the case of an absolute sleep/// interval. See [`clock_nanosleep_relative`] for relative intervals./// `nanosleep(request, remain)`—Sleeps for a duration./// This effectively uses the system monotonic clock./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/nanosleep.html/// [Linux]: https://man7.org/linux/man-pages/man2/nanosleep.2.html/// The sleep completed normally./// The sleep was interrupted, the remaining time is returned./// An invalid time value was provided./// A return type for `nanosleep` and `clock_nanosleep_relative`./// `futex(uaddr, op, val, utime, uaddr2, val3)`///  - [Linux `futex` system call]///  - [Linux `futex` feature]/// This is a very low-level feature for implementing synchronization/// primitives. See the references links above./// [Linux `futex` system call]: https://man7.org/linux/man-pages/man2/futex.2.html/// [Linux `futex` feature]: https://man7.org/linux/man-pages/man7/futex.7.html//! Linux `futex`.//! Futex is a very low-level mechanism for implementing concurrency//! primitives./// `gettid()`—Returns the thread ID./// This returns the OS thread ID, which is not necessarily the same as the/// `rust::thread::Thread::id` or the pthread ID./// [Linux]: https://man7.org/linux/man-pages/man2/gettid.2.htmlset_thread_uid/// `setuid(uid)`/// This is not the setxid you are looking for... POSIX requires xids to be/// process granular, but on Linux they are per-thread. Thus, this call only/// changes the xid for the current *thread*, not the entire process even/// though that is in violation of the POSIX standard./// For details on this distinction, see the C library vs. kernel differences/// in the [manual page][linux_notes]. This call implements the kernel/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setuid.html/// [Linux]: https://man7.org/linux/man-pages/man2/setuid.2.html/// [linux_notes]: https://man7.org/linux/man-pages/man2/setuid.2.html#NOTESset_thread_res_uid/// `setresuid(ruid, euid, suid)`/// This is not the setresxid you are looking for... POSIX requires xids to be/// in the [manual page][linux_notes] and the notes in [`set_thread_uid`]. This/// call implements the kernel behavior./// [Linux]: https://man7.org/linux/man-pages/man2/setresuid.2.html/// [linux_notes]: https://man7.org/linux/man-pages/man2/setresuid.2.html#NOTESset_thread_gid/// `setgid(gid)`/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setgid.html/// [Linux]: https://man7.org/linux/man-pages/man2/setgid.2.html/// [linux_notes]: https://man7.org/linux/man-pages/man2/setgid.2.html#NOTESset_thread_res_gid/// `setresgid(rgid, egid, sgid)`/// in the [manual page][linux_notes] and the notes in [`set_thread_gid`]. This/// [Linux]: https://man7.org/linux/man-pages/man2/setresgid.2.html/// [linux_notes]: https://man7.org/linux/man-pages/man2/setresgid.2.html#NOTESCapabilityFlags/// `__user_cap_data_struct.effective`/// `__user_cap_data_struct.permitted`/// `__user_cap_data_struct.inheritable`CapabilitySets/// `__user_cap_data_struct`/// `capget(_LINUX_CAPABILITY_VERSION_3, pid)`/// [Linux]: https://man7.org/linux/man-pages/man2/capget.2.htmlset_capabilities/// `capset(_LINUX_CAPABILITY_VERSION_3, pid, effective, permitted,/// inheritable)`libcap//! Thread-associated operations.get_keep_capabilities/// Get the current state of the calling thread's `keep capabilities` flag.///  - [`prctl(PR_GET_KEEPCAPS,...)`]/// [`prctl(PR_GET_KEEPCAPS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_keep_capabilities/// Set the state of the calling thread's `keep capabilities` flag.///  - [`prctl(PR_SET_KEEPCAPS,...)`]/// [`prctl(PR_SET_KEEPCAPS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Get the name of the calling thread.///  - [`prctl(PR_GET_NAME,...)`]/// [`prctl(PR_GET_NAME,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Set the name of the calling thread.///  - [`prctl(PR_SET_NAME,...)`]/// [`prctl(PR_SET_NAME,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlSecureComputingMode/// Secure computing is not in use./// Use hard-coded filter./// Use user-supplied filter./// `SECCOMP_MODE_*`.set_secure_computing_mode/// Set the secure computing mode for the calling thread, to limit the/// available system calls.///  - [`prctl(PR_SET_SECCOMP,...)`]/// [`prctl(PR_SET_SECCOMP,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlChangeOwnership/// In a system with the `_POSIX_CHOWN_RESTRICTED` option defined, this/// overrides the restriction of changing file ownership and groupDACOverride/// Override all DAC access, including ACL execute access if `_POSIX_ACL`/// is defined. Excluding DAC access covered by/// [`Capability::LinuxImmutable`].DACReadSearch/// Overrides all DAC restrictions regarding read and search on files and/// directories, including ACL restrictions if `_POSIX_ACL` is defined./// Excluding DAC access covered by [`Capability::LinuxImmutable`].FileOwner/// Overrides all restrictions about allowed operations on files, where/// file owner ID must be equal to the user ID, except where/// [`Capability::FileSetID`] is applicable. It doesn't override MAC/// and DAC restrictions.FileSetID/// Overrides the following restrictions that the effective user ID shall/// match the file owner ID when setting the `S_ISUID` and `S_ISGID`/// bits on that file; that the effective group ID (or one of the/// supplementary group IDs) shall match the file owner ID when setting the/// `S_ISGID` bit on that file; that the `S_ISUID` and `S_ISGID` bits are/// cleared on successful return from `chown` (not implemented)./// Overrides the restriction that the real or effective user ID of a/// process sending a signal must match the real or effective user ID/// of the process receiving the signal.SetGroupID/// Allows `setgid` manipulation. Allows `setgroups`. Allows forged gids on/// socket credentials passing.SetUserID/// Allows `set*uid` manipulation (including fsuid). Allows forged pids onSetPermittedCapabilities/// Without VFS support for capabilities:///  - Transfer any capability in your permitted set to any pid.///  - remove any capability in your permitted set from any pid. With VFS///    support for capabilities (neither of above, but)///  - Add any capability from current's capability bounding set to the///    current process' inheritable set.///  - Allow taking bits out of capability bounding set.///  - Allow modification of the securebits for a process.LinuxImmutable/// Allow modification of `S_IMMUTABLE` and `S_APPEND` file attributes.NetBindService/// Allows binding to TCP/UDP sockets below 1024. Allows binding to ATM/// VCIs below 32.NetBroadcast/// Allow broadcasting, listen to multicast.NetAdmin/// Allow interface configuration. Allow administration of IP firewall,/// masquerading and accounting. Allow setting debug option on sockets./// Allow modification of routing tables. Allow setting arbitrary/// process / process group ownership on sockets. Allow binding to any/// address for transparent proxying (also via [`Capability::NetRaw`])./// Allow setting TOS (type of service). Allow setting promiscuous/// mode. Allow clearing driver statistics. Allow multicasting. Allow/// read/write of device-specific registers. Allow activation of ATM/// control sockets.NetRaw/// Allow use of `RAW` sockets. Allow use of `PACKET` sockets. Allow/// binding to any address for transparent proxying (also via/// [`Capability::NetAdmin`]).IPCLock/// Allow locking of shared memory segments. Allow mlock and mlockall/// (which doesn't really have anything to do with IPC).IPCOwner/// Override IPC ownership checks.SystemModule/// Insert and remove kernel modules - modify kernel without limit.SystemRawIO/// Allow ioperm/iopl access. Allow sending USB messages to any device via/// `/dev/bus/usb`.SystemChangeRoot/// Allow use of `chroot`.SystemProcessTrace/// Allow `ptrace` of any process.SystemProcessAccounting/// Allow configuration of process accounting.SystemAdmin/// Allow configuration of the secure attention key. Allow administration/// of the random device. Allow examination and configuration of disk/// quotas. Allow setting the domainname. Allow setting the hostname./// Allow `mount` and `umount`, setting up new smb connection./// Allow some autofs root ioctls. Allow nfsservctl. Allow/// `VM86_REQUEST_IRQ`. Allow to read/write pci config on alpha. Allow/// `irix_prctl` on mips (setstacksize). Allow flushing all cache on/// m68k (`sys_cacheflush`). Allow removing semaphores. Used instead of/// [`Capability::ChangeOwnership`] to "chown" IPC message queues,/// semaphores and shared memory. Allow locking/unlocking of shared/// memory segment. Allow turning swap on/off. Allow forged pids on/// socket credentials passing. Allow setting readahead and/// flushing buffers on block devices. Allow setting geometry in floppy/// driver. Allow turning DMA on/off in `xd` driver. Allow/// administration of md devices (mostly the above, but some/// extra ioctls). Allow tuning the ide driver. Allow access to the nvram/// device. Allow administration of `apm_bios`, serial and bttv (TV)/// device. Allow manufacturer commands in isdn CAPI support driver./// Allow reading non-standardized portions of pci configuration space./// Allow DDI debug ioctl on sbpcd driver. Allow setting up serial ports./// Allow sending raw qic-117 commands. Allow enabling/disabling tagged/// queuing on SCSI controllers and sending arbitrary SCSI commands./// Allow setting encryption key on loopback filesystem. Allow setting/// zone reclaim policy. Allow everything under/// [`Capability::BerkeleyPacketFilters`] and/// [`Capability::PerformanceMonitoring`] for backward compatibility.SystemBoot/// Allow use of `reboot`.SystemNice/// Allow raising priority and setting priority on other (different UID)/// processes. Allow use of FIFO and round-robin (realtime) scheduling/// on own processes and setting the scheduling algorithm used by/// another process. Allow setting cpu affinity on other processes./// Allow setting realtime ioprio class. Allow setting ioprio class on/// other processes.SystemResource/// Override resource limits. Set resource limits. Override quota limits./// Override reserved space on ext2 filesystem. Modify data journaling/// mode on ext3 filesystem (uses journaling resources). NOTE: ext2/// honors fsuid when checking for resource overrides, so you can/// override using fsuid too. Override size restrictions on IPC message/// queues. Allow more than 64hz interrupts from the real-time clock./// Override max number of consoles on console allocation. Override max/// number of keymaps. Control memory reclaim behavior./// Allow manipulation of system clock. Allow `irix_stime` on mips. Allow/// setting the real-time clock.SystemTTYConfig/// Allow configuration of tty devices. Allow `vhangup` of tty.MakeNode/// Allow the privileged aspects of `mknod`.Lease/// Allow taking of leases on files.AuditWrite/// Allow writing the audit log via unicast netlink socket.AuditControl/// Allow configuration of audit via unicast netlink socket.SetFileCapabilities/// Set or remove capabilities on files. Map `uid=0` into a child userMACOverride/// Override MAC access. The base kernel enforces no MAC policy. An LSM may/// enforce a MAC policy, and if it does and it chooses to implement/// capability based overrides of that policy, this is the capability/// it should use to do so.MACAdmin/// Allow MAC configuration or state changes. The base kernel requires no/// MAC configuration. An LSM may enforce a MAC policy, and if it does/// and it chooses to implement capability based/// checks on modifications to that policy or the data required to maintain/// it, this is the capability it should use to do so.SystemLog/// Allow configuring the kernel's `syslog` (`printk` behaviour).WakeAlarm/// Allow triggering something that will wake the system.BlockSuspend/// Allow preventing system suspends.AuditRead/// Allow reading the audit log via multicast netlink socket.PerformanceMonitoring/// Allow system performance and observability privileged operations using/// `perf_events`, `i915_perf` and other kernel subsystems.BerkeleyPacketFilters/// This capability allows the following BPF operations:///  - Creating all types of BPF maps///  - Advanced verifier features///     - Indirect variable access///     - Bounded loops///     - BPF to BPF function calls///     - Scalar precision tracking///     - Larger complexity limits///     - Dead code elimination///     - And potentially other features///  - Loading BPF Type Format (BTF) data///  - Retrieve `xlated` and JITed code of BPF programs///  - Use `bpf_spin_lock` helper/// [`Capability::PerformanceMonitoring`] relaxes the verifier checks/// further:///  - BPF progs can use of pointer-to-integer conversions///  - speculation attack hardening measures are bypassed///  - `bpf_probe_read` to read arbitrary kernel memory is allowed///  - `bpf_trace_printk` to print kernel memory is allowed/// [`Capability::SystemAdmin`] is required to use bpf_probe_write_user./// [`Capability::SystemAdmin`] is required to iterate system wide loaded/// programs, maps, links, BTFs and convert their IDs to file descriptors./// [`Capability::PerformanceMonitoring`] and/// [`Capability::BerkeleyPacketFilters`] are required to load tracing/// programs. [`Capability::NetAdmin`] and/// [`Capability::BerkeleyPacketFilters`] are required to load/// networking programs.CheckpointRestore/// Allow checkpoint/restore related operations. Allow PID selection during/// `clone3`. Allow writing to `ns_last_pid`./// Linux per-thread capability.capability_is_in_bounding_set/// Check if the specified capability is in the calling thread's capability/// bounding set.///  - [`prctl(PR_CAPBSET_READ,...)`]/// [`prctl(PR_CAPBSET_READ,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlremove_capability_from_bounding_set/// If the calling thread has the [`Capability::SetPermittedCapabilities`]/// capability within its user namespace, then drop the specified capability/// from the thread's capability bounding set.///  - [`prctl(PR_CAPBSET_DROP,...)`]/// [`prctl(PR_CAPBSET_DROP,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlcapabilities_secure_bitsCapabilitiesSecureBits/// Get the `securebits` flags of the calling thread.///  - [`prctl(PR_GET_SECUREBITS,...)`]/// [`prctl(PR_GET_SECUREBITS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_capabilities_secure_bits/// Set the `securebits` flags of the calling thread.///  - [`prctl(PR_SET_SECUREBITS,...)`]/// [`prctl(PR_SET_SECUREBITS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlcurrent_timer_slack/// Get the `current` timer slack value of the calling thread.///  - [`prctl(PR_GET_TIMERSLACK,...)`]/// [`prctl(PR_GET_TIMERSLACK,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_current_timer_slack/// Sets the `current` timer slack value for the calling thread.///  - [`prctl(PR_SET_TIMERSLACK,...)`]/// [`prctl(PR_SET_TIMERSLACK,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Get the value of the `no_new_privs` attribute for the calling thread.///  - [`prctl(PR_GET_NO_NEW_PRIVS,...)`]/// [`prctl(PR_GET_NO_NEW_PRIVS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Set the calling thread's `no_new_privs` attribute.///  - [`prctl(PR_SET_NO_NEW_PRIVS,...)`]/// [`prctl(PR_SET_NO_NEW_PRIVS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlget_clear_child_tid_address/// Get the `clear_child_tid` address set by `set_tid_address`/// and `clone`'s `CLONE_CHILD_CLEARTID` flag.///  - [`prctl(PR_GET_TID_ADDRESS,...)`]/// [`prctl(PR_GET_TID_ADDRESS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmltransparent_huge_pages_are_disabled/// Get the current setting of the `THP disable` flag for the calling thread.///  - [`prctl(PR_GET_THP_DISABLE,...)`]/// [`prctl(PR_GET_THP_DISABLE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmldisable_transparent_huge_pages/// Set the state of the `THP disable` flag for the calling thread.///  - [`prctl(PR_SET_THP_DISABLE,...)`]/// [`prctl(PR_SET_THP_DISABLE,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlcapability_is_in_ambient_set/// Check if the specified capability is in the ambient set.///  - [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_IS_SET,...)`]/// [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_IS_SET,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlclear_ambient_capability_set/// Remove all capabilities from the ambient set.///  - [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_CLEAR_ALL,...)`]/// [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_CLEAR_ALL,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlconfigure_capability_in_ambient_set/// Add or remove the specified capability to the ambient set.///  - [`prctl(PR_CAP_AMBIENT,...)`]/// [`prctl(PR_CAP_AMBIENT,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlvector_length_in_bytes/// Vector length in bytes.vector_length_inherited_across_execve/// Vector length inherited across `execve`.SVEVectorLengthConfig/// Scalable Vector Extension vector length configuration.sve_vector_length_configuration/// Get the thread's current SVE vector length configuration.///  - [`prctl(PR_SVE_GET_VL,...)`]/// [`prctl(PR_SVE_GET_VL,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_sve_vector_length_configuration/// Configure the thread's vector length of Scalable Vector Extension.///  - [`prctl(PR_SVE_SET_VL,...)`]/// [`prctl(PR_SVE_SET_VL,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlreset_pointer_authentication_keys/// Securely reset the thread's pointer authentication keys to fresh random/// values generated by the kernel.///  - [`prctl(PR_PAC_RESET_KEYS,...)`]/// [`prctl(PR_PAC_RESET_KEYS,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlcurrent_tagged_address_modeTaggedAddressMode/// Get the current tagged address mode for the calling thread.///  - [`prctl(PR_GET_TAGGED_ADDR_CTRL,...)`]/// [`prctl(PR_GET_TAGGED_ADDR_CTRL,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlset_current_tagged_address_mode/// Controls support for passing tagged user-space addresses to the kernel.///  - [`prctl(PR_SET_TAGGED_ADDR_CTRL,...)`]/// [`prctl(PR_SET_TAGGED_ADDR_CTRL,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmldisable_syscall_user_dispatch/// Disable Syscall User Dispatch mechanism.///  - [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_OFF,...)`]/// [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_OFF,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Allow system calls to be executed./// Block system calls from executing.SysCallUserDispatchFastSwitch/// System calls are allowed to execute./// System calls are blocked from executing./// Value of the fast switch flag controlling system calls user dispatch/// mechanism without the need to issue a syscall.enable_syscall_user_dispatch/// Enable Syscall User Dispatch mechanism.///  - [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_ON,...)`]/// [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_ON,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlCoreSchedulingScope/// Operation will be performed for the thread.ThreadGroup/// Operation will be performed for all tasks in the task group of theProcessGroup/// Operation will be performed for all processes in the process group./// `PR_SCHED_CORE_SCOPE_*`.core_scheduling_cookie/// Get core scheduling cookie of a process.///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_GET,...)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_GET,...)`]: https://www.kernel.org/doc/html/v5.18/admin-guide/hw-vuln/core-scheduling.htmlcreate_core_scheduling_cookie/// Create unique core scheduling cookie.///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_CREATE,...)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_CREATE,...)`]: https://www.kernel.org/doc/html/v5.18/admin-guide/hw-vuln/core-scheduling.htmlpush_core_scheduling_cookie/// Push core scheduling cookie to a process.///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_TO,...)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_TO,...)`]: https://www.kernel.org/doc/html/v5.18/admin-guide/hw-vuln/core-scheduling.htmlpull_core_scheduling_cookie/// Pull core scheduling cookie from a process.///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_FROM,...)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_FROM,...)`]: https://www.kernel.org/doc/html/v5.18/admin-guide/hw-vuln/core-scheduling.html//! Linux `prctl` wrappers.//! Rustix wraps variadic/dynamic-dispatch functions like `prctl` in//! type-safe wrappers.//! The inner `prctl` calls are dynamically typed and must be called//! correctly.// PR_GET_KEEPCAPS/PR_SET_KEEPCAPS// PR_GET_NAME/PR_SET_NAME// PR_GET_SECCOMP/PR_SET_SECCOMP//const PR_GET_SECCOMP: c_int = 21;/*
/// Get the secure computing mode of the calling thread.
///
/// If the caller is not in secure computing mode, this returns
/// [`SecureComputingMode::Disabled`]. If the caller is in strict secure
/// computing mode, then this call will cause a [`Signal::Kill`] signal to be
/// sent to the process. If the caller is in filter mode, and this system call
/// is allowed by the seccomp filters, it returns
/// [`SecureComputingMode::Filter`]; otherwise, the process is killed with
/// a [`Signal::Kill`] signal.
///
/// Since Linux 3.8, the Seccomp field of the `/proc/[pid]/status` file
/// provides a method of obtaining the same information, without the risk that
/// the process is killed; see [the `proc` manual page].
///
/// # References
///  - [`prctl(PR_GET_SECCOMP,...)`]
///
/// [`prctl(PR_GET_SECCOMP,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html
/// [the `proc` manual page]: https://man7.org/linux/man-pages/man5/proc.5.html
#[inline]
pub fn secure_computing_mode() -> io::Result<SecureComputingMode> {
    unsafe { prctl_1arg(PR_GET_SECCOMP) }.and_then(TryInto::try_into)
}
*/// PR_CAPBSET_READ/PR_CAPBSET_DROP// PR_GET_SECUREBITS/PR_SET_SECUREBITS// PR_GET_TIMERSLACK/PR_SET_TIMERSLACK// PR_GET_NO_NEW_PRIVS/PR_SET_NO_NEW_PRIVS// PR_GET_TID_ADDRESS// PR_GET_THP_DISABLE/PR_SET_THP_DISABLE// PR_CAP_AMBIENT// PR_SVE_GET_VL/PR_SVE_SET_VL// PR_PAC_RESET_KEYS// PR_GET_TAGGED_ADDR_CTRL/PR_SET_TAGGED_ADDR_CTRL// PR_SET_SYSCALL_USER_DISPATCH// PR_SCHED_CORELinkNameSpaceType/// Time name space./// Mount name space.ControlGroup/// Control group (CGroup) name space.HostNameAndNISDomainName/// `Host name` and `NIS domain name` (UTS) name space.InterProcessCommunication/// Inter-process communication (IPC) name space./// User name space./// Process ID name space./// Network name space./// Type of name space referred to by a link.move_into_link_name_space/// Reassociate the calling thread with the namespace associated with link/// `fd` must refer to one of the magic links in a `/proc/[pid]/ns/` directory,/// or a bind mount to such a link./// [Linux]: https://man7.org/linux/man-pages/man2/setns.2.htmlmove_into_thread_name_spacesThreadNameSpaceType/// Atomically move the calling thread into one or more of the same namespaces/// as the thread referred to by `fd`./// `fd` must refer to a thread ID. See: `pidfd_open` and `clone`./// `unshare(flags)`—Disassociate parts of the current thread's execution/// context with other threads./// [Linux]: https://man7.org/linux/man-pages/man2/unshare.2.html/// `clockid_t`/// `clock_getres(id)`—Returns the resolution of a clock./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html/// [Linux]: https://man7.org/linux/man-pages/man2/clock_getres.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=clock_getres&sektion=2/// [NetBSD]: https://man.netbsd.org/clock_getres.2/// [OpenBSD]: https://man.openbsd.org/clock_getres.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=clock_getres&section=2/// [illumos]: https://illumos.org/man/3C/clock_getres/// `clock_gettime(id)`—Returns the current value of a clock./// This function uses `ClockId` which only contains clocks which are known to/// always be supported at runtime, allowing this function to be infallible./// For a greater set of clocks and dynamic clock support, see/// [`clock_gettime_dynamic`]./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_gettime.html/// [Linux]: https://man7.org/linux/man-pages/man2/clock_gettime.2.html/// [illumos]: https://illumos.org/man/3C/clock_gettime/// Like [`clock_gettime`] but with support for dynamic clocks./// `clock_settime(id, timespec)`—Sets the current value of a settable clock./// This fails with [`io::Errno::INVAL`] if the clock is not settable, and/// [`io::Errno::ACCESS`] if the current process does not have permission to/// set it./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_settime.html/// [Linux]: https://man7.org/linux/man-pages/man2/clock_settime.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=clock_settime&sektion=2/// [NetBSD]: https://man.netbsd.org/clock_settime.2/// [OpenBSD]: https://man.openbsd.org/clock_settime.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=clock_settime&section=2/// [illumos]: https://illumos.org/man/3C/clock_settime// TODO: Convert WASI'S clock APIs to use handles rather than ambient clock// identifiers, update `wasi-libc`, and then add support in `rustix`.//! Time-related operations./// `timerfd_create(clockid, flags)`—Create a timer./// [Linux]: https://man7.org/linux/man-pages/man2/timerfd_create.2.html/// `timerfd_settime(clockid, flags, new_value)`—Set the time on a timer./// [Linux]: https://man7.org/linux/man-pages/man2/timerfd_settime.2.html/// `timerfd_gettime(clockid, flags)`—Query a timer./// [Linux]: https://man7.org/linux/man-pages/man2/timerfd_gettime.2.html/// Convert a `&T` into a `*const T` without using an `as`./// Convert a `&mut T` into a `*mut T` without using an `as`./// Convert an `Option<&T>` into a possibly-null `*const T`./// Convert an `Option<&mut T>` into a possibly-null `*mut T`./// Convert a `*mut c_void` to a `*mut T`, checking that it is not null,/// misaligned, or pointing to a region of memory that wraps around the address/// space.// Cold because it should only happen during first-time initialization./// A combination of `weakcall` and `syscall`. Use the libc function if it's/// available, and fall back to `libc::syscall` otherwise.// Implementation derived from `weak` in Rust's// library/std/src/sys/unix/weak.rs at revision// fd0cb0cdc21dd9c06025277d772108f8d42cb25f.// Ideally we should update to a newer version which doesn't need `dlsym`,// however that depends on the `extern_weak` feature which is currrently// unstable.//! Support for "weak linkage" to symbols on Unix//! Some I/O operations we do in libstd require newer versions of OSes but we//! need to maintain binary compatibility with older releases for now. In order//! to use the new functionality when available we use this module for//! detection.//! One option to use here is weak linkage, but that is unfortunately only//! really workable on Linux. Hence, use dlsym to get the symbol value at//! runtime. This is also done for compatibility with older versions of glibc,//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes//! that we've been dynamically linked to the library the symbol comes from,//! but that is currently always the case for things like libpthread/libc.//! A long time ago this used weak linkage for the `__pthread_get_minstack`//! symbol, but that caused Debian to detect an unnecessarily strict versioned//! dependency on libc6 (#23628).// There are a variety of `#[cfg]`s controlling which targets are involved in// each instance of `weak!` and `syscall!`. Rather than trying to unify all of// that, we'll just allow that some unix targets don't use this module at all.ASM_PATH/// The directory for inline asm.use_static_assertions// Import everything from libc, but we'll add some stuff and override some// things below.// TODO: Upstream these.// TODO: Remove once https://github.com/rust-lang/libc/pull/3377 is merged and released.// It is defined as 0 in libc under 64-bit platforms, but is automatically set by kernel.// https://github.com/torvalds/linux/blob/v6.7/fs/open.c#L1458-L1459// Gated under `_LARGEFILE_SOURCE` but automatically set by the kernel.// https://github.com/illumos/illumos-gate/blob/fb2cb638e5604b214d8ea8d4f01ad2e77b437c17/usr/src/ucbhead/sys/fcntl.h#L64// On PowerPC, the regular `termios` has the `termios2` fields and there is no// `termios2`. linux-raw-sys has aliases `termios2` to `termios` to cover this// difference, but we still need to manually import it since `libc` doesn't// have this.// TODO: AIX has `stat64x`, `fstat64x`, `lstat64x`, and `stat64xat`; add them// to the upstream libc crate and implement rustix's `statat` etc. with them.// macOS added `preadv` and `pwritev` in version 11.0.// On non-glibc, assume we don't have `pwritev2`/`preadv2` in libc and use// `c::syscall` instead.//! Libc and supplemental types and constants.// Automatically enable “large file” support (LFS) features./// `epoll_create1(flags)`—Creates a new epoll object.EventData/// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an epoll/// This registers interest in any of the events set in `events` occurring on/// the file descriptor associated with `data`./// If [`delete`] is not called on the I/O source passed into this function/// returned from [`wait`]. If a file descriptor is an/// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in a/// given epoll object./// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in a/// Use `Copied` to copy the struct, since `Event` is `packed` on some/// platforms, and it's common for users to directly destructure it, which/// would lead to errors about forming references to packed fields./// Which specific event(s) occurred./// User data./// A 64-bit integer value.sixty_four_bit_pointerSixtyFourBitPointer/// A `*mut c_void` which preserves pointer provenance, extended to be/// 64-bit so that if we read the value as a `u64` union field, we don't/// get uninitialized memory./// Data associated with an [`Event`]. This can either be a 64-bit integer/// value or a pointer which preserves pointer provenance.new_u64/// Construct a new value containing a `u64`.new_ptr/// Construct a new value containing a `*mut c_void`./// Return the value as a `u64`./// If the stored value was a pointer, the pointer is zero-extended to a/// Return the value as a `*mut c_void`./// If the stored value was a `u64`, the least-significant bits of the/// `u64` are returned as a pointer value./// Constructs an `EventVec` from raw pointer, length, and capacity./// This function calls [`Vec::from_raw_parts`] with its arguments./// [`Vec::from_raw_parts`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_raw_partstest_epoll_layouts//! Linux `epoll` support.//! use rustix::event::epoll;//! use rustix::fd::AsFd;//! use rustix::io::{ioctl_fionbio, read, write};//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, SocketAddrV4, SocketType,//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, None)?;//! let epoll = epoll::create(epoll::CreateFlags::CLOEXEC)?;//! epoll::add(//!     &epoll,//!     &listen_sock,//!     epoll::EventData::new_u64(1),//!     epoll::EventFlags::IN,//! let mut next_id = epoll::EventData::new_u64(2);//!     epoll::wait(&epoll, &mut event_list, -1)?;//!     for event in &event_list {//!         let target = event.data;//!         if target.u64() == 1 {//!             epoll::add(//!             next_id = epoll::EventData::new_u64(next_id.u64() + 1);//!             let _ = epoll::delete(&epoll, &target)?;/// [`poll`]: crate::event::poll//! libc syscalls supporting `rustix::event`.//! Windows system calls in the `event` module./// Take ownership of `fd` and construct a `Dir` that reads entries from/// the given directory file descriptor./// Borrow `fd` and construct a `Dir` that reads entries from the given/// directory file descriptor./// This registers or updates a watch for the filesystem path `path` and/// returns a watch descriptor corresponding to this watch./// Note: Due to the existence of hardlinks, providing two different paths to/// this method may result in it returning the same watch descriptor. An/// application should keep track of this externally to avoid logic errors./// `inotify_rm_watch(self, wd)`—Removes a watch from this inotify./// The watch descriptor provided should have previously been returned by/// [`inotify_add_watch`] and not previously have been removed.RawOpcode// TODO: Fix linux-raw-sys to define ioctl codes for sparc.ugidCWDopen_via_syscall/// Use a direct syscall (via libc) for `open`.// for `st_[amc]time` u64->i64 transitionfcntl_nocachefcntl_global_nocachetest_sizes/// `Mode`./// Construct an `st_mode` value from a `Mode`./// Construct an `st_mode` value from a `FileType`.bitcast// s390x uses `u32` for `statfs` entries on glibc, even though `__fsword_t` is// `u64`.// s390x uses `u64` for `statfs` entries on musl./// The error type for `rustix` APIs. This is similar to [`std::io::Error`],/// but only holds an OS error code, and no extra error value.///  - [Winsock]/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2/// [`std::io::Error`]: ResultIoctlOutputMAX_IOVioctl_readonlyfcntl_dupfd/// Locks all pages mapped into the address space of the calling process./// This includes the pages of the code, data, and stack segment, as well as/// shared libraries, user space kernel data, shared memory, and memory-mapped/// files. All mapped pages are guaranteed to be resident in RAM when the call/// returns successfully; the pages are guaranteed to stay in RAM until later/// Unlocks all pages mapped into the address space of the calling process./// `MADV_HUGEPAGE`/// `MADV_NOHUGEPAGE`maybe_polyfill/// A version of [`as_raw_fd`] for use with Winsock API./// A version of [`AsRawFd`] for use with Winsock API./// A version of [`into_raw_fd`] for use with Winsock API./// A version of [`IntoRawFd`] for use with Winsock API./// A version of [`from_raw_fd`] for use with Winsock API./// A version of [`FromRawFd`] for use with Winsock API./// An `as_fd` function for Winsock, where a `Fd` is a `Socket`./// A version of [`AsFd`] for use with Winsock API.// for deprecated mount functions in "fs"// Private modules used by multiple public modules.shm//! Windows, this uses the Winsock API in `windows-sys`, which can be adapted// The minimum value required by POSIX.fsopenFsOpenFlagsfsmountFsMountFlagsMountAttrFlagsMoveMountFlagsopen_treeOpenTreeFlagsfspickFsPickFlagsfsconfig_set_flagfsconfig_set_stringfsconfig_set_binaryfsconfig_set_fdfsconfig_set_pathfsconfig_set_path_emptyfsconfig_createfsconfig_reconfigureFsConfigCmdSetFlag/// `FSCONFIG_SET_FLAG`SetString/// `FSCONFIG_SET_STRING`SetBinary/// `FSCONFIG_SET_BINARY`SetPath/// `FSCONFIG_SET_PATH`SetPathEmpty/// `FSCONFIG_SET_PATH_EMPTY`SetFd/// `FSCONFIG_SET_FD`/// `FSCONFIG_CMD_CREATE`/// `FSCONFIG_CMD_RECONFIGURE`/// `FSCONFIG_*` constants for use with the `fsconfig` syscall.netdeviceencode_sockaddr_xdpSocketAddrXdpwith_xdp_msghdrzero_msghdr/// Create a zero-initialized message header struct value.SockaddrXdpFlags/// Read an optional socket address returned from the OS.//! The BSD sockets API requires us to read the `ss_family` field before we can//! interpret the rest of a `sockaddr` produced by the kernel.XdpMmapOffsetsXdpOptionsFlagsXdpRingOffsetXdpStatisticsXdpUmemRegUCredgetsockopt_rawsetsockopt_rawget_socket_reuseaddrget_socket_nosigpipeset_socket_nosigpipeget_socket_domainget_socket_acceptconn// Apple platforms declare the constant, but do not actually implement it.set_socket_oobinlineget_socket_oobinlineset_socket_reuseportget_socket_reuseportset_socket_reuseport_lbget_socket_reuseport_lbget_socket_protocolget_socket_cookieget_socket_incoming_cpuset_socket_incoming_cpuset_ip_add_membership_with_ifindexset_ip_add_source_membershipset_ip_drop_source_membershipset_ip_drop_membership_with_ifindexset_ip_tosget_ip_tosset_ip_recvtosget_ip_recvtosset_ipv6_recvtclassget_ipv6_recvtclassset_ip_freebindget_ip_freebindset_ipv6_freebindget_ipv6_freebindget_ip_original_dstget_ipv6_original_dstset_ipv6_tclassget_ipv6_tclassset_tcp_keepcntget_tcp_keepcntset_tcp_keepidleget_tcp_keepidleset_tcp_keepintvlget_tcp_keepintvlget_tcp_user_timeoutset_tcp_quickackget_tcp_quickackset_tcp_congestionget_tcp_congestionset_tcp_thin_linear_timeoutsget_tcp_thin_linear_timeoutsset_tcp_corkget_tcp_corkget_socket_peercredset_xdp_umem_regset_xdp_umem_fill_ring_sizeset_xdp_umem_completion_ring_sizeset_xdp_tx_ring_sizeset_xdp_rx_ring_sizeget_xdp_mmap_offsetsget_xdp_statisticsget_xdp_optionsto_ip_mreqto_ip_mreqnto_imr_sourceduration_to_secs/// Convert to seconds, rounding up if necessary.//! libc syscalls supporting `rustix::net::sockopt`.sendto_xdpbind_xdpconnect_unspecsendmsg_xdpwrite_sockaddr_xdplinux_minsigstksz//! libc syscalls for PIDsoption_as_mut_ptr/// A buffer type for use with [`vmsplice`]./// [`vmsplice`]: crate::pipe::vmsplicetest_typesPidfdGetfdFlags// The `membarrier` syscall has a third argument, but it's only used when// the `flags` argument is `MEMBARRIER_CMD_FLAG_CPU`./// Convert a Rust [`Rlimit`] to a C `c::rlimit`./// Convert a C `c::rlimit` to a Rust `Rlimit`.waitpgid_waitid_pgidpidfd_send_signalpidfd_getfd// "nto" has `RLIMIT_RSS`, but it has the same value as `RLIMIT_AS`.ShmOFlagsRebootCommandset_speedset_output_speedset_input_speedsetgroups_thread/// The interval of an interval timer./// Time remaining in the current interval./// This is a clock that tells the amount of time elapsed since the Unix/// epoch, 1970-01-01T00:00:00Z. The clock is externally settable, so it is/// not monotonic. Successive reads may see decreasing times, so it isn't/// reliable for measuring durations.//! Adapt the Winsock API to resemble a POSIX-style libc API.//! mipsisa32r6el Linux system calls.//! On mipsisa32r6el, Linux indicates success or failure using `$a3` rather//! mipsisa64r6el Linux system calls.//! On mipsisa64r6el, Linux indicates success or failure using `$a3` (`$7`)//! rather than by returning a negative error code as most other architectures//! do.//! Note that MIPS R6 inline assembly currently doesn't differ from MIPS,//! because no explicit call of R6-only or R2-only instructions exist here.// These functions always use the machine's syscall instruction, even when it// isn't the fastest option available.syscall_always_asm// Macro to invoke a syscall that always uses direct assembly, rather than the// vDSO. Useful when still finding the vDSO.// Import the kernel's `uid_t` and `gid_t` if they're 32-bit.// Cast away bindgen's `enum` type to make these consistent with the other// `setsockopt`/`getsockopt` level values.// Convert the signal constants from `u32` to `c_int`.reboot_symbols// Bindgen infers `u32` for many of these macro types which meant to be// used with `c_int` in the C APIs, so cast them to `c_int`.try_decode_errordecode_c_int_infallible// When the deprecated "fs" aliases are removed, we can remove the "fs"// here too./// Convert a `usize` returned from a syscall that doesn't return on success./// doesn't return on success.ret_c_int_infallible/// Convert a `c_int` returned from a syscall that effectively always/// returns a `c_int`.//! or being accidentally misused as they travel through the code, we wrap them//! in [`ArgReg`] and [`RetReg`] structs. This file provides `From`r" `EPOLL_*` for use with [`new`]."r" `EPOLL*` for use with [`add`]."r" [`poll`]: crate::event::poll"//! linux_raw syscalls supporting `rustix::event`.r" [`eventfd`]: crate::event::eventfd"r" `IN_CREATE`"accessat_noflagsr" `AT_NO_AUTOMOUNT`"NO_AUTOMOUNTr" On some platforms, `PATH` may be included in `ACCMODE`, when"r" indicated, as the presence of `PATH` may mean that the read/write"r" `O_DSYNC`."r" `O_FSYNC`."r" This is not equal to `RDONLY | WRONLY`. It's a distinct flag."r" `O_RSYNC`."r" `O_LARGEFILE`"r" Note that rustix and/or libc will automatically set this flag when appropriate on"r" `open(2)` and friends, thus typical users do not need to care about it."r" It will may be reported in return of `fcntl_getfl`, though."LARGEFILEr" `MFD_NOEXEC_SEAL` (since Linux 6.3)"NOEXEC_SEALr" `MFD_EXEC` (since Linux 6.3)"EXECr" `MFD_HUGE_512KB`"r" `STATX_DIOALIGN` (since Linux 6.1)"DIOALIGN/// Check for an error from the result of a syscall which does not return on/// This must only be used with syscalls which do not return on success./// Return the contained `c_uint` value.r" `PROT_*` flags for use with [`mmap`]."r" For `PROT_NONE`, use `ProtFlags::empty()`."r" [`mmap`]: crate::mm::mmap"r" `PROT_READ`"r" `PROT_WRITE`"r" `PROT_EXEC`"r" `PROT_*` flags for use with [`mprotect`]."r" For `PROT_NONE`, use `MprotectFlags::empty()`."r" [`mprotect`]: crate::mm::mprotect"r" `PROT_GROWSUP`"GROWSUPr" `PROT_GROWSDOWN`"GROWSDOWNr" `PROT_SEM`"SEMr" `MAP_*` flags for use with [`mmap`]."r" For `MAP_ANONYMOUS` (aka `MAP_ANON`), see [`mmap_anonymous`]."r" [`mmap_anonymous`]: crates::mm::mmap_anonymous"r" `MAP_SHARED`"r" `MAP_SHARED_VALIDATE` (since Linux 4.15)"SHARED_VALIDATEr" `MAP_PRIVATE`"r" `MAP_DENYWRITE`"DENYWRITEr" `MAP_FIXED`"FIXEDr" `MAP_FIXED_NOREPLACE` (since Linux 4.17)"FIXED_NOREPLACEr" `MAP_GROWSDOWN`"r" `MAP_HUGETLB`"r" `MAP_HUGE_2MB` (since Linux 3.8)"r" `MAP_HUGE_1GB` (since Linux 3.8)"r" `MAP_LOCKED`"r" `MAP_NORESERVE`"NORESERVEr" `MAP_POPULATE`"POPULATEr" `MAP_STACK`"STACKr" `MAP_SYNC` (since Linux 4.15)"r" `MAP_UNINITIALIZED`"r" `MREMAP_*` flags for use with [`mremap`]."r" For `MREMAP_FIXED`, see [`mremap_fixed`]."r" [`mremap`]: crate::mm::mremap"r" [`mremap_fixed`]: crate::mm::mremap_fixed"r" `MREMAP_MAYMOVE`"MAYMOVEr" `MREMAP_DONTUNMAP` (since Linux 5.7)"DONTUNMAPr" `MS_*` flags for use with [`msync`]."r" [`msync`]: crate::mm::msync"r" `MS_SYNC`—Requests an update and waits for it to complete."r" `MS_ASYNC`—Specifies that an update be scheduled, but the call"r" returns immediately."r" `MS_INVALIDATE`—Asks to invalidate other mappings of the same"r" file (so that they can be updated with the fresh values just"r" written)."INVALIDATEr" `MLOCK_*` flags for use with [`mlock_with`]."r" [`mlock_with`]: crate::mm::mlock_with"r" `MLOCK_ONFAULT`"ONFAULT/// On Linux, this is mapped to `POSIX_MADV_NORMAL` because Linux's/// `MADV_DONTNEED` differs from `POSIX_MADV_DONTNEED`. See `LinuxDontNeed`/// for the Linux behavior.r" `O_*` flags for use with [`userfaultfd`]."r" [`userfaultfd`]: crate::mm::userfaultfd"r" `MCL_*` flags for use with [`mlockall`]."r" [`mlockall`]: crate::mm::mlockall"r" Used together with `MCL_CURRENT`, `MCL_FUTURE`, or both. Mark all"r" current (with `MCL_CURRENT`) or future (with `MCL_FUTURE`) mappings"r" to lock pages when they are faulted in. When used with"r" `MCL_CURRENT`, all present pages are locked, but `mlockall` will"r" not fault in non-present pages. When used with `MCL_FUTURE`, all"r" future mappings will be marked to lock pages when they are faulted"r" in, but they will not be populated by the lock when the mapping is"r" created. `MCL_ONFAULT` must be used with either `MCL_CURRENT` or"r" `MCL_FUTURE` or both."r" Lock all pages which will become mapped into the address space of"r" the process in the future. These could be, for instance, new pages"r" required by a growing heap and stack as well as new memory-mapped"r" files or shared memory regions."FUTUREr" Lock all pages which are currently mapped into the address space of"r" the process."//! linux_raw syscalls supporting `rustix::mount`.r" [`mount`]: crate::mount::mount"r" [`unmount`]: crate::mount::unmount"r" `MS_*` constants for use with [`mount_change`]."r" [`mount_change`]: crate::mount::mount_change"/// Create a message header intended to send with an XDP address.r" `MSG_*` flags for use with [`send`], [`send_to`], and related"r" [`send`]: crate::net::send"r" [`sendto`]: crate::net::sendto"r" `MSG_CONFIRM`"CONFIRMr" `MSG_DONTROUTE`"r" `MSG_DONTWAIT`"r" `MSG_EOT`"EOTr" `MSG_MORE`"r" `MSG_NOSIGNAL`"NOSIGNALr" `MSG_OOB`"r" `MSG_*` flags for use with [`recv`], [`recvfrom`], and related"r" [`recv`]: crate::net::recv"r" [`recvfrom`]: crate::net::recvfrom"r" `MSG_CMSG_CLOEXEC`"CMSG_CLOEXECr" `MSG_ERRQUEUE`"ERRQUEUEr" `MSG_PEEK`"r" `MSG_TRUNC`"r" `MSG_WAITALL`"WAITALL/// Same as `set_socket_timeout` but uses `__kernel_old_timeval` instead of/// `__kernel_sock_timeval` and `_OLD` constants instead of `_NEW`./// Same as `get_socket_timeout` but uses `__kernel_old_timeval` instead ofduration_from_linux_sock_timeval/// Convert a `__linux_sock_timeval` to a Rust `Option<Duration>`.duration_from_linux_old_timeval/// Like `duration_from_linux` but uses Linux's old 32-bit/// `__kernel_old_timeval`.duration_to_linux_sock_timeval/// Convert a Rust `Option<Duration>` to a `__kernel_sock_timeval`.duration_to_linux_old_timeval/// Like `duration_to_linux` but uses Linux's old 32-bit//! linux_raw syscalls supporting `rustix::net::sockopt`.linux_secure/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations, so/// if we don't see it, this function returns a null pointer./// And, this function returns a null pointer, rather than panicking, if the/// auxv records can't be read.PHENTRANDOMpr_get_auxv_static/// Use Linux >= 6.4's `PR_GET_AUXV` to read the aux records, into a provided/// statically-sized buffer. Return:///  - `Ok(...)` if the buffer is big enough.///  - `Err(Ok(len))` if we need a buffer of length `len`.///  - `Err(Err(err))` if we failed with `err`.pr_get_auxv_dynamic/// Use Linux >= 6.4's `PR_GET_AUXV` to read the aux records, using a provided/// statically-sized buffer if possible, or a dynamically allocated buffer/// otherwise. Return:///  - Ok(...) on success.///  - Err(err) on failure.init_auxv/// Read the auxv records and initialize the various static variables. Panic/// if an error is encountered.maybe_init_auxv/// Like `init_auxv`, but don't panic if an error is encountered. The caller/// must be prepared for initialization to be skipped.init_auxv_impl/// If we don't have "use-explicitly-provided-auxv" or "use-libc-auxv", we/// read the aux vector via the `prctl` `PR_GET_AUXV`, with a fallback to/// /proc/self/auxv for kernels that don't support `PR_GET_AUXV`.init_from_aux_iterAuxPointer// Read auxv records from an array in memory.AuxFile// Read auxv records from a file.// This implementation does lots of `read`s and it isn't amazing, but// hopefully we won't use it often.// Aux reading utilities// Initialize `EXECFN` to a valid `CStr` pointer so that we don't need to check// for null on every `execfn` call.// Use `dangling` so that we can always treat it like an empty slice./// When "use-explicitly-provided-auxv" is enabled, we export a function to be/// called during initialization, and passed a pointer to the original/// environment variable block set up by the OS.//! Linux auxv `init` function, for "use-explicitly-provided-auxv" mode.// `getauxval` wasn't supported in glibc until 2.16. Also this lets us use// `*mut` as the return type to preserve strict provenance.// With the "runtime" feature, go ahead and depend on `getauxval` existing so// that we never fail.// Declare `sysconf` ourselves so that we don't depend on all of libc just for// this.// With "use-explicitly-provided-auxv" enabled, we expect to be initialized// with an explicit `rustix::param::init` call.//! linux_raw syscalls for PIDs//! linux_raw syscalls supporting `rustix::pipe`.r" [`pipe_with`]: crate::pipe::pipe_with"r" `SPLICE_F_*` constants for use with [`splice`], [`vmsplice`], and"r" [`tee`]."//! linux_raw syscalls supporting modules that use `prctl`.// `sched_getcpu` has special optimizations via the vDSO on some architectures./// This should be used immediately before the syscall instruction, and the/// returned value shouldn't be used for any other purpose./// This should be used immediately after the syscall instruction, and the/// operand value shouldn't be used for any other purpose.//! The inline-asm code paths do some amount of reordering of arguments; to//! ensure that we don't accidentally misroute an argument or return value, we//! use distinct types for each argument index and return value.option_as_ptrglobal_asm_DYNAMIC/// Declare the `_DYNAMIC` symbol so that we can compare its address with/// the static address in the `PT_DYNAMIC` header to learn our offset. Use/// a weak symbol because `_DYNAMIC` is not always present.// Rust has `extern_weak` but it isn't stable, so use a `global_asm`.SHM_DIRget_shm_namer" `O_*` constants for use with [`shm_open`]."r" [`shm_open`]: crate:shm::shm_open"//! linux_raw syscalls supporting `rustix::system`.procfsControlModesInputModesLocalModesOutputModesSpecialCodeIndex/// A wrapper around a conceptual `cfsetspeed` which handles an arbitrary/// integer speed value./// A wrapper around a conceptual `cfsetospeed` which handles an arbitrary/// A wrapper around a conceptual `cfsetispeed` which handles an arbitraryr" `FUTEX_*` flags for use with [`futex`]."r" [`futex`]: crate::thread::futex"r" `FUTEX_PRIVATE_FLAG`"r" `FUTEX_CLOCK_REALTIME`"//! linux_raw syscalls for UIDs and GIDs/// Returns `None` if the vDSO can't be located or if it doesn't conform to/// our expectations.GetcpuTypeinit_getcpu/// Initialize `GETCPU` and return its value.GETCPUrustix_getcpu_via_syscall// Ensure that the source and destination types are both primitive integer// types and the same size, and then bitcast.bitflags_bits/// Return a [`bitcast`] of the value of `$x.bits()`, where `$x` is a/// `bitflags` type.//! The `bitcast` and `bitflags_bits` macros.split_init/// Split an uninitialized byte slice into initialized and uninitialized parts./// At least `init` bytes must be initialized.//! Utilities to help with buffering.check_type/// Check that the size and alignment of a type match the `sys` bindings.check_renamed_type/// The same as `check_type`, but for unions and anonymous structs we've/// renamed to avoid having types like `bindgen_ty_1` in the API.check_struct_field/// Check that the field of a struct has the same offset as the corresponding/// field in the `sys` bindings.check_struct_renamed_field/// The same as `check_struct_field`, but for unions and anonymous structs/// we've renamed to avoid having types like `bindgen_ty_1` in the API.check_renamed_struct_renamed_field/// The same as `check_struct_renamed_field`, but for when both the struct and/// a field are renamed.check_struct/// For the common case of no renaming, check all fields of a struct.//! Macros for checking that types have the same layout as other types./// `CLOCK_REALTIME_ALARM`/// `CLOCK_BOOTTIME`/// On FreeBSD, use [`Self::Uptime`], as `CLOCK_BOOTTIME` is an alias for/// `CLOCK_UPTIME`./// [`Self::Uptime`]: https://docs.rs/rustix/*/x86_64-unknown-freebsd/rustix/time/enum.ClockId.html#variant.Uptime/// `CLOCK_BOOTTIME_ALARM`/// use rustix::fs::{statat, AtFlags, CWD};/// let metadata = statat(CWD, cstr!("Cargo.toml"), AtFlags::empty())?;/// A `kqueue` event for use with [`kevent`]./// Get the raw data for this event.//! Event operations./// `pause()`/// The POSIX `pause` interface returns an error code, but the only thing/// `pause` does is sleep until interrupted by a signal, so it always/// returns the same thing with the same error code, so in rustix, the/// return value is omitted./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pause.html/// [Linux]: https://man7.org/linux/man-pages/man2/pause.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/pause.3.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=pause&sektion=3/// [NetBSD]: https://man.netbsd.org/pause.3/// [OpenBSD]: https://man.openbsd.org/pause.3/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=pause&section=3/// [illumos]: https://illumos.org/man/2/pause/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsapoll/// `port_dissociate(_, PORT_SOURCE_FD, _)`—Dissociates a file descriptor/// from a port./// `open(path, oflags, mode)`—Opens a file./// POSIX guarantees that `open` will use the lowest unused file descriptor,/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html/// [Linux]: https://man7.org/linux/man-pages/man2/open.2.html/// `chmod(path, mode)`—Sets file or directory permissions./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/chmod.html/// [Linux]: https://man7.org/linux/man-pages/man2/chmod.2.html/// `stat(path)`—Queries metadata for a file or directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/stat.html/// [Linux]: https://man7.org/linux/man-pages/man2/stat.2.html/// `lstat(path)`—Queries metadata for a file or directory, without following/// symlinks./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/lstat.html/// [Linux]: https://man7.org/linux/man-pages/man2/lstat.2.html/// `readlink(path)`—Reads the contents of a symlink./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html/// [Linux]: https://man7.org/linux/man-pages/man2/readlink.2.html_readlink/// `rename(old_path, new_path)`—Renames a file or directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/rename.html/// [Linux]: https://man7.org/linux/man-pages/man2/rename.2.html/// `unlink(path)`—Unlinks a file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlink.html/// [Linux]: https://man7.org/linux/man-pages/man2/unlink.2.html/// `rmdir(path)`—Removes a directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/rmdir.html/// [Linux]: https://man7.org/linux/man-pages/man2/rmdir.2.html/// `link(old_path, new_path)`—Creates a hard link./// POSIX leaves it implementation-defined whether `link` follows a symlink in/// `old_path`, or creates a new link to the symbolic link itself. On platforms/// which have it, [`linkat`] avoids this problem since it has an [`AtFlags`]/// parameter and the [`AtFlags::SYMLINK_FOLLOW`] flag determines whether/// symlinks should be followed./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/link.html/// [Linux]: https://man7.org/linux/man-pages/man2/link.2.html/// [`linkat`]: crate::fs::linkat/// [`AtFlags`]: crate::fs::AtFlags/// [`AtFlags::SYMLINK_FOLLOW`]: crate::fs::AtFlags::SYMLINK_FOLLOW/// `symlink(old_path, new_path)`—Creates a symlink./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html/// [Linux]: https://man7.org/linux/man-pages/man2/symlink.2.html/// `mkdir(path, mode)`—Creates a directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdir.html/// [Linux]: https://man7.org/linux/man-pages/man2/mkdir.2.html/// `access(path, access)`—Tests permissions for a file or directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/access.html/// [Linux]: https://man7.org/linux/man-pages/man2/access.2.html/// Compared to [`statfs`], this function often provides less information, but/// it is more portable. But even so, filesystems are very diverse and not all/// the fields are meaningful for every filesystem. And `f_fsid` doesn't seem/// to have a clear meaning anywhere./// `chown(path, owner, group)`—Sets open file or directory ownership./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/chown.html/// [Linux]: https://man7.org/linux/man-pages/man2/chown.2.html/// If `reuse` already has available capacity, reuse it if possible.readlinkat_raw/// `readlinkat(fd, path)`—Reads the contents of a symlink, without/// allocating./// This is the "raw" version which avoids allocating, but which is/// significantly trickier to use; most users should use plain [`readlinkat`]./// This version writes bytes into the buffer and returns two slices, one/// containing the written bytes, and one containing the remaining/// uninitialized space. If the number of written bytes is equal to the length/// of the buffer, it means the buffer wasn't big enough to hold the full/// string, and callers should try again with a bigger buffer._readlinkat_raw/// With the [`REMOVEDIR`] flag, this removes a directory. This is in place of/// a `rmdirat` function.//! directory, or the special value [`CWD`].//! [`cwd`]: crate::fs::CWD/// `AT_FDCWD`—A handle representing the current working directory./// This is a file descriptor which refers to the process current directory/// which can be used as the directory argument in `*at` functions such as/// [`openat`].// SAFETY: `AT_FDCWD` is a reserved value that is never dynamically// allocated, so it'll remain valid for the duration of `'static`./// Return the value of [`CWD`].// These `fcntl` functions live in the `io` module because they're not specific/// meaning that they don't guard against being acquired by two threads in the/// same process.//! The Unix `fcntl` function is effectively lots of different functions hidden//! behind a single dynamic dispatch interface. In order to provide a type-safe//! API, rustix makes them all separate functions so that they can have//! dedicated static type signatures./// `fcntl(fd, F_NOCACHE, value)`—Turn data caching off or on for a file/// See [this mailing list post] for additional information about the meanings/// of `F_NOCACHE` and `F_GLOBAL_NOCACHE`./// [this mailing list post]: https://lists.apple.com/archives/filesystem-dev/2007/Sep/msg00010.html/// See also [`fcntl_global_nocache`]./// `fcntl(fd, F_GLOBAL_NOCACHE, value)`—Turn data caching off or on for all/// file descriptors./// See also [`fcntl_nocache`]./// `fchmod(fd, mode)`—Sets open file or directory permissions./// This implementation does not support [`OFlags::PATH`] file descriptors,/// even on platforms where the host libc emulates it./// `fchown(fd, owner, group)`—Sets open file or directory ownership.FicloneIS_MUTATINGOPCODEoutput_from_ptrr" `FS_*` constants for use with [`ioctl_getflags`][crate::io::ioctl::ioctl_getflags]."IFlagsr" `FS_APPEND_FL`"r" `FS_COMPR_FL`"r" `FS_DIRSYNC_FL`"r" `FS_IMMUTABLE_FL`"r" `FS_JOURNAL_DATA_FL`"JOURNALINGr" `FS_NOATIME_FL`"r" `FS_NOCOW_FL`"NOCOWr" `FS_NODUMP_FL`"NODUMPr" `FS_NOTAIL_FL`"NOTAILr" `FS_PROJINHERIT_FL`"PROJECT_INHERITr" `FS_SECRM_FL`"SECURE_REMOVALr" `FS_SYNC_FL`"r" `FS_TOPDIR_FL`"TOPDIRr" `FS_UNRM_FL`"UNRMioctl_getflags/// `ioctl(fd, FS_IOC_GETFLAGS)`—Returns the [inode flags] attributes/// [inode flags]: https://man7.org/linux/man-pages/man2/ioctl_iflags.2.htmlioctl_setflags/// `ioctl(fd, FS_IOC_SETFLAGS)`—Modify the [inode flags] attributes//! Filesystem-oriented `ioctl` functions./// `memfd_create(name, flags)`// Haiku needs <https://github.com/rust-lang/rust/pull/112371>/// Return the value of the `st_atime` field, casted to the correct type./// Return the value of the `st_mtime` field, casted to the correct type./// Return the value of the `st_ctime` field, casted to the correct type.StatExt/// Extension trait for accessing timestamp fields of `Stat`./// Rustix's `Stat` type on some platforms has unsigned `st_mtime`,/// `st_atime`, and `st_ctime` fields. This is incorrect, as Unix defines/// these fields to be signed, with negative values representing dates before/// the Unix epoch. Until the next semver bump, these unsigned fields are/// deprecated, and this trait provides accessors which return their values/// as signed integers.mount_remountmount_bindmount_recursive_bindmount_changemount_move//! These have been moved to a new `rustix::mount` module./// # use rustix::fs::{CWD, Mode, OFlags, openat, RawDir};/// # use rustix::cstr;///     CWD,///     cstr!("."),/// # // The `notrust` above can be removed when we can depend on Rust 1.65./// A raw directory entry, similar to [`std::fs::DirEntry`]./// bytes, plus the distance to the next byte which is not in a hole./// If the offset is in a hole at the end of the file, the seek will fail/// with [`Errno::NXIO`]./// [`Errno::NXIO`]: crate::io::Errno::NXIO/// bytes, plus the distance to the next byte which is in a hole./// If there is no hole past the offset, it will be set to the end of the/// file i.e. there is an implicit hole at the end of any file./// It is used by the [`seek`] function./// This is similar to [`std::io::SeekFrom`], however it adds platform-specific/// seek options./// [`seek`]: crate::fs::seek/// # use rustix::fs::{AtFlags, StatxFlags};/// # use rustix::fd::BorrowedFd;/// /// Try to determine if the provided path is a mount root. Will return/// /// `Ok(None)` if the kernel is not new enough to support `statx` or/// /// [`libc::STATX_ATTR_MOUNT_ROOT`]./// fn is_mountpoint(root: BorrowedFd<'_>, path: &Path) -> io::Result<Option<bool>> {///     use rustix::fs::{AtFlags, StatxFlags};///     let mountroot_flag = libc::STATX_ATTR_MOUNT_ROOT as u64;///     match rustix::fs::statx(///         root,///         path,///         AtFlags::NO_AUTOMOUNT | AtFlags::SYMLINK_NOFOLLOW,///         StatxFlags::empty(),///     ) {///         Ok(r) => {///             let present = (r.stx_attributes_mask & mountroot_flag) > 0;///             Ok(present.then(|| r.stx_attributes & mountroot_flag > 0))///         Err(e) if e == rustix::io::Errno::NOSYS => Ok(None),///         Err(e) => Err(e.into()),// Linux kernel prior to 4.11 and old versions of Docker don't support// `statx`. We store the availability in a global to avoid unnecessary// syscalls.statx_error/// The first `statx` call failed. We can get a variety of error codes/// from seccomp configs or faulty FUSE drivers, so we don't trust/// `ENOSYS` or `EPERM` to tell us whether statx is available./// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-closesocket/// For `dup2` to stdin, stdout, and stderr, see [`stdio::dup2_stdin`],/// [`stdio::dup2_stdout`], and [`stdio::dup2_stderr`]./// [`stdio::dup2_stdin`]: https://docs.rs/rustix/*/rustix/stdio/fn.dup2_stdin.html/// [`stdio::dup2_stdout`]: https://docs.rs/rustix/*/rustix/stdio/fn.dup2_stdout.html/// [`stdio::dup2_stderr`]: https://docs.rs/rustix/*/rustix/stdio/fn.dup2_stderr.html//! We define the error constants as individual `const`s instead of an enum//! because we may not know about all of the host's error values and we don't//! want unrecognized values to create undefined behavior.//! `fcntl` functions which are not specific to files or directories live in//! the [`io`] module instead./// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/winsock/winsock-ioctls#unix-ioctl-codes/// The result of this function gets silently coerced into a C `int` by the OS,/// so it may contain a wrapped value.//! The Unix `ioctl` function is effectively lots of different functions hidden//! Some ioctls, such as those related to filesystems, terminals, and//! processes, live in other top-level API modules.//! If you're looking for [`SeekFrom`], that's in the [`fs`] module.//! [`SeekFrom`]: https://docs.rs/rustix/*/rustix/fs/enum.SeekFrom.html//! [`fs`]: https://docs.rs/rustix/*/rustix/fs/index.html// Declare `IoSlice` and `IoSliceMut`./// This is equivalent to [`read`], except that it can read into uninitialized/// memory. It returns the slice that was initialized by this function and the/// slice that remains uninitialized.pread_uninit/// This is equivalent to [`pread`], except that it can read into uninitializedEpollEventDataEpollEventFlags// Export types used in io_uring APIs.// Declare the `c_char` type for use with entries that take pointers// to C strings. Define it as unsigned or signed according to the platform// so that we match what Rust's `CStr` uses.// When we can update to linux-raw-sys 0.5, we can remove this, as its// `c_char` type will declare this./// The C `char` type.addr_len_struct// TODO: Rename this to include `addr_len` when we have a semver bump?/// This does not derive `Copy` or `Clone` because the `big_cqe` field is not/// automatically copyable.compose_opcode// `IOC_VOID`// `IOC_OUT` ("out" is from the perspective of the kernel)// `IOC_IN`IOCPARAM_MASK//! `ioctl` opcode behavior for BSD platforms./// Compose an opcode from its component parts.GROUP_BITSNUM_SHIFTGROUP_SHIFTSIZE_SHIFTDIR_SHIFTNUM_MASKGROUP_MASKSIZE_MASKDIR_MASKSIZE_BITSDIR_BITScheck_known_opcodes//! `ioctl` opcode behavior for Linux platforms./// Perform an `ioctl` call./// `ioctl` was originally intended to act as a way of modifying the behavior/// of files, but has since been adopted as a general purpose system call for/// making calls into the kernel. In addition to the default calls exposed by/// generic file descriptors, many drivers expose their own `ioctl` calls for/// controlling their behavior, some of which are proprietary./// This crate exposes many other `ioctl` interfaces with safe and idiomatic/// wrappers, like [`ioctl_fionbio`] and [`ioctl_fionread`]. It is recommended/// to use those instead of this function, as they are safer and more/// idiomatic. For other cases, implement the [`Ioctl`] API and pass it to this/// See documentation for [`Ioctl`] for more information./// [`ioctl_fionbio`]: crate::io::ioctl_fionbio/// [`ioctl_fionread`]: crate::io::ioctl_fionread/// While [`Ioctl`] takes much of the unsafety out of `ioctl` calls, it is/// still unsafe to call this code with arbitrary device drivers, as it is up/// to the device driver to implement the `ioctl` call correctly. It is on the/// onus of the protocol between the user and the driver to ensure that the/// `ioctl` call is safe to make.///  - [Solaris]/// [Linux]: https://man7.org/linux/man-pages/man2/ioctl.2.html/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-ioctlsocket/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=ioctl&sektion=2/// [NetBSD]: https://man.netbsd.org/ioctl.2/// [OpenBSD]: https://man.openbsd.org/ioctl.2/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/ioctl.2.html/// [Solaris]: https://docs.oracle.com/cd/E23824_01/html/821-1463/ioctl-2.html/// [illumos]: https://illumos.org/man/2/ioctl_ioctl_ioctl_readonly/// The type of the output data./// Given a pointer, one should be able to construct an instance of this/// The opcode used by this `ioctl` command./// There are different types of opcode depending on the operation. See/// documentation for the [`Opcode`] struct for more information./// Does the `ioctl` mutate any data in the userspace?/// If the `ioctl` call does not mutate any data in the userspace, then/// making this `false` enables optimizations that can make the call/// faster. When in doubt, set this to `true`./// This should only be set to `false` if the `ioctl` call does not mutate/// any data in the userspace. Undefined behavior may occur if this is set/// to `false` when it should be `true`./// Get a pointer to the data to be passed to the `ioctl` command./// See trait-level documentation for more information./// Cast the output data to the correct type./// The `extract_output` value must be the resulting value after a/// successful `ioctl` call, and `out` is the direct return value of an/// `ioctl` call that did not fail. In this case `extract_output` is the/// pointer that was passed to the `ioctl` call./// A trait defining the properties of an `ioctl` command./// Objects implementing this trait can be passed to [`ioctl`] to make an/// `ioctl` call. The contents of the object represent the inputs to the/// `ioctl` call. The inputs must be convertible to a pointer through the/// `as_ptr` method. In most cases, this involves either casting a number to a/// pointer, or creating a pointer to the actual data. The latter case is/// necessary for `ioctl` calls that modify userspace data./// This trait is unsafe to implement because it is impossible to guarantee/// that the `ioctl` call is safe. The `ioctl` call may be proprietary, or it/// may be unsafe to call in certain circumstances./// By implementing this trait, you guarantee that:/// - The `ioctl` call expects the input provided by `as_ptr` and produces the///   output as indicated by `output`./// - That `output_from_ptr` can safely take the pointer from `as_ptr` and cast///   it to the correct type, *only* after the `ioctl` call./// - That `OPCODE` uniquely identifies the `ioctl` call./// - That, for whatever platforms you are targeting, the `ioctl` call is safe///   to make./// - If `IS_MUTATING` is false, that no userspace data will be modified by the///   `ioctl` call./// The raw opcode./// The opcode used by an `Ioctl`./// Create a new old `Opcode` from a raw opcode./// Rather than being a composition of several attributes, old opcodes are/// just numbers. In general most drivers follow stricter conventions, but/// older drivers may still use this strategy./// Create a new opcode from a direction, group, number, and size./// This corresponds to the C macro `_IOC(direction, group, number, size)`/// Create a new non-mutating opcode from a group, a number, and the type/// of data./// This corresponds to the C macro `_IO(group, number)` when `T` is zero/// sized./// Create a new reading opcode from a group, a number and the type of/// This corresponds to the C macro `_IOR(group, number, T)`./// Create a new writing opcode from a group, a number and the type of/// This corresponds to the C macro `_IOW(group, number, T)`./// Create a new reading and writing opcode from a group, a number and the/// type of data./// This corresponds to the C macro `_IOWR(group, number, T)`./// Get the raw opcode./// None of the above./// Read data from the kernel./// Write data to the kernel./// Read and write data to the kernel./// The direction that an `ioctl` is going./// Note that this is relative to userspace. `Read` means reading data from the/// kernel, and write means the kernel writing data to userspace./// The type used by the `ioctl` to signify the output._RawOpcode/// The type used by the `ioctl` to signify the command.// Under raw Linux, this is an `unsigned int`.//! Unsafe `ioctl` API.//! Unix systems expose a number of `ioctl`'s. `ioctl`s have been adopted as a//! general purpose system call for making calls into the kernel. In addition//! to the wide variety of system calls that are included by default in the//! kernel, many drivers expose their own `ioctl`'s for controlling their//! behavior, some of which are proprietary. Therefore it is impossible to make//! a safe interface for every `ioctl` call, as they all have wildly varying//! semantics.//! This module provides an unsafe interface to write your own `ioctl` API. To//! start, create a type that implements [`Ioctl`]. Then, pass it to [`ioctl`]//! to make the `ioctl` call._opcode/// The opcode./// Implements an `ioctl` with no real arguments.CompileTimeOpcode/// Create a new no-argument `ioctl` object./// - `Opcode` must provide a valid opcode./// The output data./// Implements the traditional “getter” pattern for `ioctl`s./// Some `ioctl`s just read data into the userspace. As this is a popular/// pattern this structure implements it./// Create a new getter-style `ioctl` object./// - For this opcode, `Output` must be the type that the kernel expects to///   write into./// The input data./// Implements the pattern for `ioctl`s where a pointer argument is given to/// the `ioctl`./// The opcode must be read-only./// Create a new pointer setter-style `ioctl` object./// - For this opcode, `Input` must be the type that the kernel expects to///   get./// Reference to input/output data./// Implements an “updater” pattern for `ioctl`s./// The ioctl takes a reference to a struct that it reads its input from,/// then writes output to the same struct./// Create a new pointer updater-style `ioctl` object./// - For this opcode, `Value` must be the type that the kernel expects to/// Trait for something that provides an `ioctl` opcode at compile time.BadOpcode/// Provides a bad opcode at compile time.NUM/// Provides a read code at compile time./// This corresponds to the C macro `_IOR(GROUP, NUM, Data)`./// Provides a write code at compile time./// This corresponds to the C macro `_IOW(GROUP, NUM, Data)`./// Provides a read/write code at compile time./// This corresponds to the C macro `_IOWR(GROUP, NUM, Data)`./// Provides a `None` code at compile time./// This corresponds to the C macro `_IO(GROUP, NUM)` when `Data` is zero//! Implements typical patterns for `ioctl` usage.// Use `static_assertions` macros if we have them, or a polyfill otherwise.// Polyfill for `std` in `no_std` builds.check_types// linux_raw: Weak symbols are used by the use-libc-auxv feature for// glibc 2.15 support.// libc: Weak symbols are used to call various functions available in some// versions of libc and not others.// Temporarily provide some mount functions for use in the fs module for// backwards compatibility.//! POSIX-like, Unix-like, Linux, and Winsock syscall-like APIs, with//!  - Constants use `enum`s and [`bitflags`] types, and enable [support for//!    externally defined flags].//! [support for externally defined flags]: https://docs.rs/bitflags/*/bitflags/#externally-defined-flags// It is common in Linux and libc APIs for types to vary between platforms.// Redox and WASI have enough differences that it isn't worth precisely// conditionalizing all the `use`s for them. Similar for if we don't have// "all-apis".//! Polyfill of parts of the standard library for `no_std` builds.//! All code in this subtree is derived from the standard library and licensed//! MIT or Apache 2.0 at your option.//! This implementation is used when `std` is not available and polyfills the//! necessary items from `std`. When the `std` feature is specified (so the//! standard library is available), the file `src/polyfill/std` is used//! instead, which just imports the respective items from `std`.// Export the types and traits for the public API.//! This module is supported on Unix platforms and WASI, which both use a//! similar file descriptor system for referencing OS resources./// This has a lifetime parameter to tie it to the lifetime of something that owns the file/// descriptor. For the duration of that lifetime, it is guaranteed that nobody will close the file/// This closes the file descriptor on drop. It is guaranteed that nobody else will close the file/// [ownership][io-safety]. The resource must not require any cleanup other than `close`./// [io-safety]: io#io-safety//! 334a54cd83191f38ad8046ed94c45de735c86c65./// The `fd` passed in must be an [owned file descriptor][io-safety];/// in particular, it must be open./// Raw SOCKETs./// Extracts the raw socket./// This function is typically used to **borrow** an owned socket./// raw socket to the caller, and the socket is only guaranteed/// to be valid while the original object has not yet been destroyed./// However, borrowing is not strictly required. See [`AsSocket::as_socket`]/// for an API which strictly borrows a socket./// Extracts raw sockets./// Constructs a new I/O object from the specified raw socket./// This function is typically used to **consume ownership** of the socket/// given, passing responsibility for closing the socket to the returned/// object. When used in this way, the returned object/// `From<OwnedSocket>::from` implementation for an API which strictly/// The `socket` passed in must:///   - be a valid an open socket,///   - be a socket that may be freed via [`closesocket`]./// [`closesocket`]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-closesocket/// Creates I/O objects from raw sockets./// Consumes this object, returning the raw underlying socket./// socket to the caller. When used in this way, callers are then the unique/// owners of the socket and must close it once it's no longer needed./// `Into<OwnedSocket>::into` implementation for an API which strictly/// its raw `SOCKET`.//! library/std/src/os/windows/io/raw.rs//! at revision//! 4f9b394c8a24803e57ba892fa00e539742ebafc0.LibcSocket/// `INVALID_SOCKET`.// This is -2, in two's complement. -1 is `INVALID_SOCKET`./// Borrows the socket./// A trait to borrow the socket from an underlying object.//! library/std/src/os/windows/io/socket.rs//! library/std/src/os/windows/raw.rs,//! library/std/src/os/windows/io/raw.rs and// Change  to use `std::os::fd` when MSRV becomes 1.66 or higher.//! Imports from `std` that would be polyfilled for `no_std` builds (see//! `src/polyfill/no_std`).//! This implementation is used when `std` is available and just imports the//! necessary items from `std`. For `no_std` builds, the file//! `src/polyfill/no_std` is used instead, which doesn't depend on the standard/// `addr` must be a valid pointer to memory that is appropriate to call/// `posix_madvise` on. Some forms of `advice` may mutate the memory or evoke a/// variety of side-effects on the mapping and/or the file.hugetlb_with_size_log2/// Under the hood it computes/// `MAP_HUGETLB | (huge_page_size_log2 << MAP_HUGE_SHIFT)`./// `huge_page_size_log2` denotes logarithm of huge page size to use and/// should be between 16 and 63 (inclusive)./// use rustix::mm::MapFlags;/// let f = MapFlags::hugetlb_with_size_log2(30).unwrap();/// assert_eq!(f, MapFlags::HUGETLB | MapFlags::HUGE_1GB);/// `mremap(old_address, old_size, new_size, flags)`—Resize, modify, and/or/// move a memory mapping./// requested if the memory isn't page-aligned. Other implementations fail if/// the memory isn't page-aligned./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/mlockall.html/// [Linux]: https://man7.org/linux/man-pages/man2/mlockall.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=mlockall&sektion=2/// [NetBSD]: https://man.netbsd.org/mlockall.2/// [OpenBSD]: https://man.openbsd.org/mlockall.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=mlockall&section=2/// [illumos]: https://illumos.org/man/3C/mlockall/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Page-Lock-Functions.html#index-mlockall/// This function is aware of all the memory pages in the process, as if it/// were a debugger. It unlocks all the pages, which could potentially/// compromise security assumptions made by code about memory it has/// encapsulated./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/munlockall.html/// [Linux]: https://man7.org/linux/man-pages/man2/munlockall.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=munlockall&sektion=2/// [NetBSD]: https://man.netbsd.org/munlockall.2/// [OpenBSD]: https://man.openbsd.org/munlockall.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=munlockall&section=2/// [illumos]: https://illumos.org/man/3C/munlockall/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Page-Lock-Functions.html#index-munlockall/// `msync` on. Some forms of `msync` may mutate the memory or evoke a variety/// of side-effects on the mapping and/or the file./// `fsopen(fs_name, flags)`///  - [Unfinished draft]/// [Unfinished draft]: https://github.com/sunfishcode/linux-mount-api-documentation/blob/main/fsopen.md/// `fsmount(fs_fd, flags, attr_flags)`/// [Unfinished draft]: https://github.com/sunfishcode/linux-mount-api-documentation/blob/main/fsmount.md/// `move_mount(from_dfd, from_pathname, to_dfd, to_pathname, flags)`/// This is not the same as `mount` with the `MS_MOVE` flag. If you want to/// use that, use [`mount_move`] instead./// [`mount_move`]: crate::mount::mount_move/// [Unfinished draft]: https://github.com/sunfishcode/linux-mount-api-documentation/blob/main/move_mount.md/// `open_tree(dfd, filename, flags)`/// [Unfinished draft]: https://github.com/sunfishcode/linux-mount-api-documentation/blob/main/open_tree.md/// `fspick(dfd, path, flags)`/// [Unfinished draft]: https://github.com/sunfishcode/linux-mount-api-documentation/blob/main/fspick.md/// `fsconfig(fs_fd, FSCONFIG_SET_FLAG, key, NULL, 0)`/// [Unfinished draft]: https://github.com/sunfishcode/linux-mount-api-documentation/blob/main/fsconfig.md/// `fsconfig(fs_fd, FSCONFIG_SET_STRING, key, value, 0)`/// `fsconfig(fs_fd, FSCONFIG_SET_BINARY, key, value, value.len())`/// `fsconfig(fs_fd, FSCONFIG_SET_PATH, key, path, fd)`/// `fsconfig(fs_fd, FSCONFIG_SET_PATH_EMPTY, key, "", fd)`/// `fsconfig(fs_fd, FSCONFIG_SET_FD, key, NULL, fd)`/// `fsconfig(fs_fd, FSCONFIG_CMD_CREATE, key, NULL, 0)`/// `fsconfig(fs_fd, FSCONFIG_CMD_RECONFIGURE, key, NULL, 0)`//! `fsopen` and related functions in Linux's `mount` API.//! Linux `mount` API.// The `mount` module includes the `mount` function and related// functions which were originally defined in `rustix::fs` but are// now replaced by deprecated aliases. After the next semver bump,// we can remove the aliases and all the `#[cfg(feature = "mount")]`// here and in src/backend/*/mount.// The `fsopen` module includes `fsopen` and related functions.option_into_with_c_str/// `mount2(source, target, filesystemtype, mountflags, data)`/// This is same as the [`mount`], except it adds support for/// the source, target, and data being omitted, and the data/// is passed as a `CStr` rather than a `path::Arg`./// This is not the same as the `move_mount` syscall. If you want to use that,/// use [`move_mount`] instead./// [`move_mount`]: crate::mount::move_mount/// `ioctl(fd, SIOCGIFINDEX, ifreq)`—Returns the interface index for a given/// See the [module-level documentation] for information about `fd` usage./// [module-level documentation]: self/// [Linux]: https://man7.org/linux/man-pages/man7/netdevice.7.html/// `ioctl(fd, SIOCGIFNAME, ifreq)`—Returns the interface name for a giventest_name_to_indextest_index_to_name//! Low-level Linux network device access//! The methods in this module take a socket's file descriptor to communicate//! with the kernel in their ioctl call://! - glibc uses an `AF_UNIX`, `AF_INET`, or `AF_INET6` socket.//! The address family itself does not matter and glibc tries the next address//! family if socket creation with one fails.//! - Android (bionic) uses an `AF_INET` socket.//! - Both create the socket with `SOCK_DGRAM|SOCK_CLOEXEC` type/flag.//! - The [man-pages] specify, that the ioctl calls "can be used on any//!   socket's file descriptor regardless of the//! family or type".//! - [Linux]//! [man-pages]: https://man7.org/linux/man-pages/man7/netdevice.7.html//! [Linux]: https://man7.org/linux/man-pages/man7/netdevice.7.html/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-recvrecv_uninit/// This is equivalent to [`recv`], except that it can read into uninitialized/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-recvfromrecvfrom_uninit/// This is equivalent to [`recvfrom`], except that it can read into/// uninitialized memory. It returns the slice that was initialized by this/// function and the slice that remains uninitialized./// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto/// `sendto(fd, buf, flags, addr, sizeof(struct sockaddr_xdp))`—Writes data/// to a socket to a specific XDP address.//! `recv`, `send`, and variants.addr_of/// Macro for defining the amount of space to allocate in a buffer for use with/// [`RecvAncillaryBuffer::new`] and [`SendAncillaryBuffer::new`]./// Allocate a buffer for a single file descriptor:/// # use rustix::cmsg_space;/// let mut space = [0; rustix::cmsg_space!(ScmRights(1))];/// Allocate a buffer for credentials:/// # #[cfg(linux_kernel)]/// let mut space = [0; rustix::cmsg_space!(ScmCredentials(1))];/// Allocate a buffer for two file descriptors and credentials:/// let mut space = [0; rustix::cmsg_space!(ScmRights(2), ScmCredentials(1))];cmsg_aligned_space/// Like `cmsg_space`, but doesn't add padding for `cmsghdr` alignment.__cmsg_aligned_space/// Send process credentials./// Ancillary message for [`sendmsg`], [`sendmsg_v4`], [`sendmsg_v6`],/// Received process credentials./// Buffer for sending ancillary messages with [`sendmsg`], [`sendmsg_v4`],/// [`sendmsg_v6`], [`sendmsg_unix`], and [`sendmsg_any`]./// Use the [`push`] function to add messages to send./// [`push`]: SendAncillaryBuffer::push/// The buffer size may be computed with [`cmsg_space`], or it may be/// zero for an empty buffer, however in that case, consider `default()`/// instead, or even using [`send`] instead of `sendmsg`./// # use rustix::net::SendAncillaryBuffer;/// let mut cmsg_buffer = SendAncillaryBuffer::new(&mut space);/// [`send`]: crate::net::send/// Buffer for receiving ancillary messages with [`recvmsg`]./// Use the [`drain`] function to iterate over the received messages./// [`drain`]: RecvAncillaryBuffer::drain/// instead, or even using [`recv`] instead of `recvmsg`./// # use rustix::net::RecvAncillaryBuffer;/// let mut cmsg_buffer = RecvAncillaryBuffer::new(&mut space);/// [`recv`]: crate::net::recvalign_for_cmsghdr/// Return a slice of `buffer` starting at the first `cmsghdr` alignmentread_and_length/// An iterator that drains messages from a [`RecvAncillaryBuffer`]./// Create an iterator for control messages that were received without/// [`RecvAncillaryBuffer`]./// The buffer must contain valid message data (or be empty)./// A closure that converts a message into a [`RecvAncillaryMessage`]./// `sendmsg(msghdr)`—Sends a message on a socket to a specific XDP address./// The message header we're using to iterate over the messages.//! [`recvmsg`], [`sendmsg`], and related functions./// To pass extra flags such as [`SocketFlags::CLOEXEC`] or/// [`SocketFlags::NONBLOCK`], use [`socket_with`]./// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-socket/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-bind/// `bind(sockfd, addr, sizeof(struct sockaddr_un))`—Binds a socket to a XDP/// On Windows, a non-blocking socket returns [`Errno::WOULDBLOCK`] if the/// connection cannot be completed immediately, rather than/// `Errno::INPROGRESS`./// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect/// [`Errno::WOULDBLOCK`]: io::Errno::WOULDBLOCK/// `connect(sockfd, {.sa_family = AF_UNSPEC}, sizeof(struct sockaddr))`/// — Dissolve the socket's association./// On UDP sockets, BSD platforms report [`Errno::AFNOSUPPORT`] or/// [`Errno::INVAL`] even if the disconnect was successful./// [`Errno::AFNOSUPPORT`]: io::Errno::AFNOSUPPORT/// [`Errno::INVAL`]: io::Errno::INVAL/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-shutdown/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getsockname/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getpeernameXdp/// `struct sockaddr_xdp`//! socket addresses on Unix./// `socketpair(domain, type_ | accept_flags, protocol)`—Create a pair of/// sockets that are connected to each other./// See the [module-level documentation] for more./// [module-level documentation]: self#references-for-get_socket_-and-set_socket_-functions/// `setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, value)`—Set whether local/// addresses may be reused in `bind`./// `getsockopt(fd, SOL_SOCKET, SO_REUSEADDR)`/// `setsockopt(fd, SOL_SOCKET, SO_BROADCAST, value)`/// `setsockopt(fd, SOL_SOCKET, SO_LINGER, value)`/// `setsockopt(fd, SOL_SOCKET, SO_PASSCRED, value)`/// `setsockopt(fd, SOL_SOCKET, id, value)`—Set the sending or receiving/// `setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, value)`/// `setsockopt(fd, SOL_SOCKET, SO_RCVBUF, value)`/// `setsockopt(fd, SOL_SOCKET, SO_SNDBUF, value)`/// `getsockopt(fd, SOL_SOCKET, SO_DOMAIN)`/// `getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN)`/// `setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, value)`/// `getsockopt(fd, SOL_SOCKET, SO_OOBINLINE)`/// `setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, value)`/// `getsockopt(fd, SOL_SOCKET, SO_REUSEPORT)`/// `getsockopt(fd, SOL_SOCKET, SO_PROTOCOL)`/// `getsockopt(fd, SOL_SOCKET, SO_COOKIE)`/// `getsockopt(fd, SOL_SOCKET, SO_INCOMING_CPU)`/// `setsockopt(fd, SOL_SOCKET, SO_INCOMING_CPU, value)`/// `setsockopt(fd, IPPROTO_IP, IP_TTL, value)`/// [module-level documentation]: self#references-for-get_ip_-and-set_ip_-functions/// `setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, value)`/// [module-level documentation]: self#references-for-get_ipv6_-and-set_ipv6_-functions/// `setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, value)`/// `setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, value)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, value)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, value)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, value)`/// This is similar to [`set_ip_add_membership`] but always sets `ifindex`/// value to zero./// `setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, multiaddr, address,/// ifindex)`/// This is similar to [`set_ip_add_membership_with_ifindex`] but additionally/// allows a `ifindex` value to be given./// `setsockopt(fd, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, value)`/// `setsockopt(fd, IPPROTO_IP, IP_DROP_SOURCE_MEMBERSHIP, value)`/// This is similar to [`set_ip_drop_membership`] but always sets `ifindex`/// This is similar to [`set_ip_drop_membership_with_ifindex`] but additionally/// `setsockopt(fd, IPPROTO_IP, IP_TOS, value)`/// `getsockopt(fd, IPPROTO_IP, IP_TOS)`/// `setsockopt(fd, IPPROTO_IP, IP_RECVTOS, value)`/// `getsockopt(fd, IPPROTO_IP, IP_RECVTOS)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_RECVTCLASS, value)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_RECVTCLASS)`/// `setsockopt(fd, IPPROTO_IP, IP_FREEBIND, value)`/// `getsockopt(fd, IPPROTO_IP, IP_FREEBIND)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_FREEBIND, value)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_FREEBIND)`/// `getsockopt(fd, IPPROTO_IP, SO_ORIGINAL_DST)`/// Even though this corresponnds to a `SO_*` constant, it is an `IPPROTO_IP`/// `getsockopt(fd, IPPROTO_IPV6, IP6T_SO_ORIGINAL_DST)`/// Even though this corresponnds to a `IP6T_*` constant, it is an/// `IPPROTO_IPV6` option./// `setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, value)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS)`/// `setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, value)`/// [module-level documentation]: self#references-for-get_tcp_-and-set_tcp_-functions/// `setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT)`/// `setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, value)`/// `TCP_KEEPALIVE` on Apple platforms./// `getsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE)`/// `setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL)`/// `setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT)`/// `setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_QUICKACK)`/// `setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_CONGESTION)`/// `setsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS)`/// `setsockopt(fd, IPPROTO_TCP, TCP_CORK, value)`/// `getsockopt(fd, IPPROTO_TCP, TCP_CORK)`/// Get credentials of Unix domain socket peer process///  - [Linux `unix`]/// [Linux `unix`]: https://man7.org/linux/man-pages/man7/unix.7.html/// `setsockopt(fd, SOL_XDP, XDP_UMEM_REG, value)`/// On kernel versions only supporting v1, the flags are ignored.///   - [Linux]/// [Linux]: https://www.kernel.org/doc/html/next/networking/af_xdp.html#xdp-umem-reg-setsockopt/// `setsockopt(fd, SOL_XDP, XDP_UMEM_FILL_RING, value)`/// [Linux]: https://www.kernel.org/doc/html/next/networking/af_xdp.html#xdp-rx-tx-umem-fill-umem-completion-ring-setsockopts/// `setsockopt(fd, SOL_XDP, XDP_UMEM_COMPLETION_RING, value)`/// `setsockopt(fd, SOL_XDP, XDP_TX_RING, value)`/// `setsockopt(fd, SOL_XDP, XDP_RX_RING, value)`/// `getsockopt(fd, SOL_XDP, XDP_MMAP_OFFSETS)`/// [Linux]: https://www.kernel.org/doc/html/next/networking/af_xdp.html/// `getsockopt(fd, SOL_XDP, XDP_STATISTICS)`/// [Linux]: https://www.kernel.org/doc/html/next/networking/af_xdp.html#xdp-statistics-getsockopt/// `getsockopt(fd, SOL_XDP, XDP_OPTIONS)`/// [Linux]: https://www.kernel.org/doc/html/next/networking/af_xdp.html#xdp-options-getsockopt//! In the rustix API, there is a separate function for each option, so that it//! can be given an option-specific type signature.//! # References for all `get_*` functions://!  - [POSIX `getsockopt`]//!  - [Linux `getsockopt`]//!  - [Winsock `getsockopt`]//!  - [Apple `getsockopt`]//!  - [FreeBSD `getsockopt`]//!  - [NetBSD `getsockopt`]//!  - [OpenBSD `getsockopt`]//!  - [DragonFly BSD `getsockopt`]//!  - [illumos `getsockopt`]//!  - [glibc `getsockopt`]//! [POSIX `getsockopt`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockopt.html//! [Linux `getsockopt`]: https://man7.org/linux/man-pages/man2/getsockopt.2.html//! [Winsock `getsockopt`]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getsockopt//! [Apple `getsockopt`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getsockopt.2.html//! [FreeBSD `getsockopt`]: https://man.freebsd.org/cgi/man.cgi?query=getsockopt&sektion=2//! [NetBSD `getsockopt`]: https://man.netbsd.org/getsockopt.2//! [OpenBSD `getsockopt`]: https://man.openbsd.org/getsockopt.2//! [DragonFly BSD `getsockopt`]: https://man.dragonflybsd.org/?command=getsockopt&section=2//! [illumos `getsockopt`]: https://illumos.org/man/3SOCKET/getsockopt//! [glibc `getsockopt`]: https://www.gnu.org/software/libc/manual/html_node/Socket-Option-Functions.html//! # References for all `set_*` functions://!  - [POSIX `setsockopt`]//!  - [Linux `setsockopt`]//!  - [Winsock `setsockopt`]//!  - [Apple `setsockopt`]//!  - [FreeBSD `setsockopt`]//!  - [NetBSD `setsockopt`]//!  - [OpenBSD `setsockopt`]//!  - [DragonFly BSD `setsockopt`]//!  - [illumos `setsockopt`]//!  - [glibc `setsockopt`]//! [POSIX `setsockopt`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsockopt.html//! [Linux `setsockopt`]: https://man7.org/linux/man-pages/man2/setsockopt.2.html//! [Winsock `setsockopt`]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-setsockopt//! [Apple `setsockopt`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setsockopt.2.html//! [FreeBSD `setsockopt`]: https://man.freebsd.org/cgi/man.cgi?query=setsockopt&sektion=2//! [NetBSD `setsockopt`]: https://man.netbsd.org/setsockopt.2//! [OpenBSD `setsockopt`]: https://man.openbsd.org/setsockopt.2//! [DragonFly BSD `setsockopt`]: https://man.dragonflybsd.org/?command=setsockopt&section=2//! [illumos `setsockopt`]: https://illumos.org/man/3SOCKET/setsockopt//! [glibc `setsockopt`]: https://www.gnu.org/software/libc/manual/html_node/Socket-Option-Functions.html//! # References for `get_socket_*` and `set_socket_*` functions://!  - [References for all `get_*` functions]//!  - [References for all `set_*` functions]//!  - [POSIX `sys/socket.h`]//!  - [Linux `socket`]//!  - [Winsock `SOL_SOCKET` options]//!  - [glibc `SOL_SOCKET` Options]//! [POSIX `sys/socket.h`]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_socket.h.html//! [Linux `socket`]: https://man7.org/linux/man-pages/man7/socket.7.html//! [Winsock `SOL_SOCKET` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/sol-socket-socket-options//! [glibc `SOL_SOCKET` options]: https://www.gnu.org/software/libc/manual/html_node/Socket_002dLevel-Options.html//! # References for `get_ip_*` and `set_ip_*` functions://!  - [POSIX `netinet/in.h`]//!  - [Linux `ip`]//!  - [Winsock `IPPROTO_IP` options]//!  - [Apple `ip`]//!  - [FreeBSD `ip`]//!  - [NetBSD `ip`]//!  - [OpenBSD `ip`]//!  - [DragonFly BSD `ip`]//!  - [illumos `ip`]//! [POSIX `netinet/in.h`]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_in.h.html//! [Linux `ip`]: https://man7.org/linux/man-pages/man7/ip.7.html//! [Winsock `IPPROTO_IP` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options//! [Apple `ip`]: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/man/man4/ip.4.auto.html//! [FreeBSD `ip`]: https://man.freebsd.org/cgi/man.cgi?query=ip&sektion=4//! [NetBSD `ip`]: https://man.netbsd.org/ip.4//! [OpenBSD `ip`]: https://man.openbsd.org/ip.4//! [DragonFly BSD `ip`]: https://man.dragonflybsd.org/?command=ip&section=4//! [illumos `ip`]: https://illumos.org/man/4P/ip//! # References for `get_ipv6_*` and `set_ipv6_*` functions://!  - [Linux `ipv6`]//!  - [Winsock `IPPROTO_IPV6` options]//!  - [Apple `ip6`]//!  - [FreeBSD `ip6`]//!  - [NetBSD `ip6`]//!  - [OpenBSD `ip6`]//!  - [DragonFly BSD `ip6`]//!  - [illumos `ip6`]//! [Linux `ipv6`]: https://man7.org/linux/man-pages/man7/ipv6.7.html//! [Winsock `IPPROTO_IPV6` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ipv6-socket-options//! [Apple `ip6`]: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/man/man4/ip6.4.auto.html//! [FreeBSD `ip6`]: https://man.freebsd.org/cgi/man.cgi?query=ip6&sektion=4//! [NetBSD `ip6`]: https://man.netbsd.org/ip6.4//! [OpenBSD `ip6`]: https://man.openbsd.org/ip6.4//! [DragonFly BSD `ip6`]: https://man.dragonflybsd.org/?command=ip6&section=4//! [illumos `ip6`]: https://illumos.org/man/4P/ip6//! # References for `get_tcp_*` and `set_tcp_*` functions://!  - [POSIX `netinet/tcp.h`]//!  - [Linux `tcp`]//!  - [Winsock `IPPROTO_TCP` options]//!  - [Apple `tcp`]//!  - [FreeBSD `tcp`]//!  - [NetBSD `tcp`]//!  - [OpenBSD `tcp`]//!  - [DragonFly BSD `tcp`]//!  - [illumos `tcp`]//! [POSIX `netinet/tcp.h`]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_tcp.h.html//! [Linux `tcp`]: https://man7.org/linux/man-pages/man7/tcp.7.html//! [Winsock `IPPROTO_TCP` options]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-tcp-socket-options//! [Apple `tcp`]: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/man/man4/tcp.4.auto.html//! [FreeBSD `tcp`]: https://man.freebsd.org/cgi/man.cgi?query=tcp&sektion=4//! [NetBSD `tcp`]: https://man.netbsd.org/tcp.4//! [OpenBSD `tcp`]: https://man.openbsd.org/tcp.4//! [DragonFly BSD `tcp`]: https://man.dragonflybsd.org/?command=tcp&section=4//! [illumos `tcp`]: https://illumos.org/man/4P/tcp//! [References for all `get_*` functions]: #references-for-all-get_-functions//! [References for all `set_*` functions]: #references-for-all-set_-functions/// [`socket`]: crate::net::socket()/// `AF_*` constants for use with [`socket`], [`socket_with`], and/// [`socketpair`]./// [`socketpair`]: crate::net::socketpair()/// [Linux]: https://man7.org/linux/man-pages/man7/ip.7.html/// [Linux]: https://man7.org/linux/man-pages/man7/ipv6.7.html/// [Linux]: https://man7.org/linux/man-pages/man7/netlink.7.html/// [Linux]: https://man7.org/linux/man-pages/man7/packet.7.htmlXDP/// `AF_XDP`new_raw_protocol/// `IPPROTO_*` and other constants for use with [`socket`], [`socket_with`],/// and [`socketpair`] when a nondefault value is desired. See the [`ipproto`],/// [`sysproto`], and [`netlink`] modules for possible values./// For the default values, such as `IPPROTO_IP` or `NETLINK_ROUTE`, pass/// `None` as the `protocol` argument in these functions.ipproto/// `IPPROTO_*` constants./// For `IPPROTO_IP`, pass `None` as the `protocol` argument.sysproto/// `SYSPROTO_*` constants.UNUSED/// `NETLINK_UNUSED`USERSOCK/// `NETLINK_USERSOCK`FIREWALL/// `NETLINK_FIREWALL`SOCK_DIAG/// `NETLINK_SOCK_DIAG`NFLOG/// `NETLINK_NFLOG`XFRM/// `NETLINK_XFRM`SELINUX/// `NETLINK_SELINUX`ISCSI/// `NETLINK_ISCSI`AUDIT/// `NETLINK_AUDIT`FIB_LOOKUP/// `NETLINK_FIB_LOOKUP`CONNECTOR/// `NETLINK_CONNECTOR`NETFILTER/// `NETLINK_NETFILTER`IP6_FW/// `NETLINK_IP6_FW`DNRTMSG/// `NETLINK_DNRTMSG`KOBJECT_UEVENT/// `NETLINK_KOBJECT_UEVENT`GENERIC/// `NETLINK_GENERIC`// This is defined on FreeBSD too, but it has the value 0, so it doesn't// fit in or `NonZeroU32`. It's unclear whether FreeBSD intends// `NETLINK_GENERIC` to be the default when Linux has `NETLINK_ROUTE`// as the default.SCSITRANSPORT/// `NETLINK_SCSITRANSPORT`ECRYPTFS/// `NETLINK_ECRYPTFS`RDMA/// `NETLINK_RDMA`/// `NETLINK_CRYPTO`INET_DIAG/// `NETLINK_INET_DIAG`ADD_MEMBERSHIP/// `NETLINK_ADD_MEMBERSHIP`DROP_MEMBERSHIP/// `NETLINK_DROP_MEMBERSHIP`PKTINFO/// `NETLINK_PKTINFO`BROADCAST_ERROR/// `NETLINK_BROADCAST_ERROR`NO_ENOBUFS/// `NETLINK_NO_ENOBUFS`RX_RING/// `NETLINK_RX_RING`TX_RING/// `NETLINK_TX_RING`LISTEN_ALL_NSID/// `NETLINK_LISTEN_ALL_NSID`LIST_MEMBERSHIPS/// `NETLINK_LIST_MEMBERSHIPS`CAP_ACK/// `NETLINK_CAP_ACK`EXT_ACK/// `NETLINK_EXT_ACK`GET_STRICT_CHK/// `NETLINK_GET_STRICT_CHK`/// `NETLINK_*` constants./// For `NETLINK_ROUTE`, pass `None` as the `protocol` argument./// `ETH_P_LOOP`/// `ETH_P_PUP`PUPAT/// `ETH_P_PUPAT`TSN/// `ETH_P_TSN`ERSPAN2/// `ETH_P_ERSPAN2`/// `ETH_P_IP`/// `ETH_P_X25`ARP/// `ETH_P_ARP`BPQ/// `ETH_P_BPQ`IEEEPUP/// `ETH_P_IEEEPUP`IEEEPUPAT/// `ETH_P_IEEEPUPAT`BATMAN/// `ETH_P_BATMAN`DEC/// `ETH_P_DEC`DNA_DL/// `ETH_P_DNA_DL`DNA_RC/// `ETH_P_DNA_RC`DNA_RT/// `ETH_P_DNA_RT`LAT/// `ETH_P_LAT`DIAG/// `ETH_P_DIAG`CUST/// `ETH_P_CUST`SCA/// `ETH_P_SCA`TEB/// `ETH_P_TEB`RARP/// `ETH_P_RARP`ATALK/// `ETH_P_ATALK`AARP/// `ETH_P_AARP`P_8021Q/// `ETH_P_8021Q`ERSPAN/// `ETH_P_ERSPAN`/// `ETH_P_IPX`/// `ETH_P_IPV6`PAUSE/// `ETH_P_PAUSE`SLOW/// `ETH_P_SLOW`WCCP/// `ETH_P_WCCP`MPLS_UC/// `ETH_P_MPLS_UC`MPLS_MC/// `ETH_P_MPLS_MC`ATMMPOA/// `ETH_P_ATMMPOA`PPP_DISC/// `ETH_P_PPP_DISC`PPP_SES/// `ETH_P_PPP_SES`LINK_CTL/// `ETH_P_LINK_CTL`ATMFATE/// `ETH_P_ATMFATE`PAE/// `ETH_P_PAE`PROFINET/// `ETH_P_PROFINET`REALTEK/// `ETH_P_REALTEK`AOE/// `ETH_P_AOE`ETHERCAT/// `ETH_P_ETHERCAT`P_8021AD/// `ETH_P_8021AD`P_802_EX1/// `ETH_P_802_EX1`PREAUTH/// `ETH_P_PREAUTH`/// `ETH_P_TIPC`LLDP/// `ETH_P_LLDP`MRP/// `ETH_P_MRP`MACSEC/// `ETH_P_MACSEC`P_8021AH/// `ETH_P_8021AH`MVRP/// `ETH_P_MVRP`P_1588/// `ETH_P_1588`NCSI/// `ETH_P_NCSI`PRP/// `ETH_P_PRP`CFM/// `ETH_P_CFM`FCOE/// `ETH_P_FCOE`IBOE/// `ETH_P_IBOE`TDLS/// `ETH_P_TDLS`FIP/// `ETH_P_FIP`P_80221/// `ETH_P_80221`HSR/// `ETH_P_HSR`NSH/// `ETH_P_NSH`/// `ETH_P_LOOPBACK`QINQ1/// `ETH_P_QINQ1`QINQ2/// `ETH_P_QINQ2`QINQ3/// `ETH_P_QINQ3`EDSA/// `ETH_P_EDSA`DSA_8021Q/// `ETH_P_DSA_8021Q`DSA_A5PSW/// `ETH_P_DSA_A5PSW`IFE/// `ETH_P_IFE`/// `ETH_P_AF_IUCV`P_802_3_MIN/// `ETH_P_802_3_MIN`P_802_3/// `ETH_P_802_3`/// `ETH_P_AX25`/// `ETH_P_ALL`P_802_2/// `ETH_P_802_2`SNAP/// `ETH_P_SNAP`DDCMP/// `ETH_P_DDCMP`WAN_PPP/// `ETH_P_WAN_PPP`PPP_MP/// `ETH_P_PPP_MP`LOCALTALK/// `ETH_P_LOCALTALK`/// `ETH_P_CAN`CANFD/// `ETH_P_CANFD`CANXL/// `ETH_P_CANXL`PPPTALK/// `ETH_P_PPPTALK`TR_802_2/// `ETH_P_TR_802_2`MOBITEX/// `ETH_P_MOBITEX`/// `ETH_P_CONTROL`/// `ETH_P_IRDA`/// `ETH_P_ECONET`HDLC/// `ETH_P_HDLC`ARCNET/// `ETH_P_ARCNET`/// `ETH_P_DSA`/// `ETH_P_TRAILER`/// `ETH_P_PHONET`/// `ETH_P_IEEE802154`CAIF/// `ETH_P_CAIF`XDSA/// `ETH_P_XDSA`MAP/// `ETH_P_MAP`MCTP/// `ETH_P_MCTP`/// `ETH_P_*` constants.// These are translated into 16-bit big-endian form because that's what the// [`AddressFamily::PACKET`] address family [expects].// [expects]: https://man7.org/linux/man-pages/man7/packet.7.htmlr" `SOCK_*` constants for use with [`socket_with`], [`accept_with`] and"r" [`acceptfrom_with`]."r" [`socket_with`]: crate::net::socket_with"r" [`accept_with`]: crate::net::accept_with"r" [`acceptfrom_with`]: crate::net::acceptfrom_with"r" `SOCK_NONBLOCK`"r" `SOCK_CLOEXEC`"r" `XDP_OPTIONS_*` constants returned by [`get_xdp_options`]."r" [`get_xdp_options`]: crate::net::sockopt::get_xdp_options"r" `XDP_OPTIONS_ZEROCOPY`"r" `XDP_*` constants for use in [`SockaddrXdp`]."r" `XDP_SHARED_UMEM`"r" `XDP_COPY`"r" `XDP_USE_NEED_WAKEUP`"r" `XDP_USE_SG`"// Constant needs to be cast because bindgen does generate a u32 but the struct// expects a u16. https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L15-L44r" `XDP_RING_*` constants for use in fill and/or Tx ring."XdpRingFlagsr" `XDP_RING_NEED_WAKEUP`"r" `XDP_UMEM_*` constants for use in [`XdpUmemReg`]."XdpUmemRegFlagsr" `XDP_UMEM_UNALIGNED_CHUNK_FLAG`"/// Interface index./// Queue ID./// Shared UMEM file descriptor./// A XDP socket address./// Used to bind to XDP socket./// Not ABI compatible with `struct sockaddr_xdp`// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L38-L44/// Construct a new XDP address./// Return flags./// Set flags.interface_index/// Return interface index.set_interface_index/// Set interface index.queue_id/// Return queue ID.set_queue_id/// Set queue ID.shared_umem_fd/// Return shared UMEM file descriptor.set_shared_umem_fd/// Set shared UMEM file descriptor./// Producer offset./// Consumer offset./// Descriptors offset./// Flags offset./// Is `None` if the kernel version (<5.4) does not yet support flags./// XDP ring offset./// Used to mmap rings from kernel./// Not ABI compatible with `struct xdp_ring_offset`.// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L49-L54/// Rx ring offsets./// Tx ring offsets./// Fill ring offsets./// Completion ring offsets./// XDP mmap offsets./// Not ABI compatible with `struct xdp_mmap_offsets`// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L56-L61/// Start address of UMEM./// Umem length in bytes./// Chunk size in bytes./// Headroom in bytes./// Requires kernel version 5.4./// XDP umem registration./// `struct xdp_umem_reg`// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L73-L79/// Rx dropped./// Rx invalid descriptors./// Tx invalid descriptors./// Rx ring full./// Is `None` if the kernel version (<5.9) does not yet support flags./// Rx fill ring empty descriptors./// Tx ring empty descriptors./// XDP statistics./// Not ABI compatible with `struct xdp_statistics`// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L81-L88XdpOptions/// XDP options./// Requires kernel version 5.3./// `struct xdp_options`// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L90-L92/// Offset from the start of the UMEM./// Length of packet in bytes.XdpDescOptions/// Options.XdpDesc/// XDP rx/tx frame descriptor./// `struct xdp_desc`// https://github.com/torvalds/linux/blob/v6.6/include/uapi/linux/if_xdp.h#L109-L113r" `XDP_*` constants for use in [`XdpDesc`]."r" Requires kernel version 6.6."r" `XDP_PKT_CONTD`"/// Offset for mmapping rx ring./// Offset for mmapping tx ring./// Offset for mmapping fill ring./// Offset for mmapping completion ring./// Offset used to shift the [`XdpDesc`] addr to the right to extract the/// address offset in unaligned mode./// Mask used to binary `and` the [`XdpDesc`] addr to extract the address/// without the offset carried in the upper 16 bits of the address in/// unaligned mode./// `AF_XDP` related types and constants./// Process ID of peer/// User ID of peer/// Group ID of peer/// UNIX credentials of socket peer, for use with [`get_socket_peercred`]/// [`SendAncillaryMessage::ScmCredentials`] and/// [`RecvAncillaryMessage::ScmCredentials`]./// [`get_socket_peercred`]: crate::net::sockopt::get_socket_peercred/// [`SendAncillaryMessage::ScmCredentials`]: crate::net::SendAncillaryMessage::ScmCredentials/// [`RecvAncillaryMessage::ScmCredentials`]: crate::net::RecvAncillaryMessage::ScmCredentials//! Types and constants for `rustix::net`./// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsastartup/// [Winsock]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsacleanup/// `getauxval(AT_MINSIGSTKSZ)`—Returns the Linux "minsigstksz" data./// Return the Linux `AT_MINSIGSTKSZ` value passed to the current process./// Returns 0 if it is not available.//! When "use-explicitly-provided-auxv" is enabled, the `init` function must be//! called before any other function in this module. It is unsafe because it/// Returns a potentially-lossy rendering of this string as a/// `Cow<'_, str>`./// Runs a closure on `arg` where `A` is mapped to a `&CStr`/// The slow path which handles any length. In theory OS's only support up to/// `PATH_MAX`, but we let the OS enforce that./// Returns `Some` for positive `RawPid`s. Otherwise, returns `None`./// This is safe because a `Pid` is a number without any guarantees for the/// kernel. Non-child `Pid`s are always racy for any syscalls, but can only/// cause logic errors. If you want race-free access to or control of/// non-child processes, please consider other mechanisms like [pidfd] on/// [pidfd]: https://man7.org/linux/man-pages/man2/pidfd_open.2.htmlfrom_raw_unchecked/// Converts a known positive `RawPid` into a `Pid`./// The caller must guarantee `raw` is positive./// Converts a `Pid` into a `NonZeroI32`./// Test whether this pid represents the init process (pid 1).//! The `Pid` type./// `splice(fd_in, off_in, fd_out, off_out, len, flags)`—Transfer data/// between a file and a pipe./// `off_*` must be `None` if the corresponding fd refers to a pipe. Otherwise/// its value points to the starting offset to the file, from which the data is/// read/written. On success, the number of bytes read/written is added to the/// Passing `None` causes the read/write to start from the file offset, and the/// file offset is adjusted appropriately./// If `fd` is the write end of the pipe, the function maps the memory pointer/// at by `bufs` to the pipe./// If `fd` is the read end of the pipe, the function writes data from the pipe/// to said memory./// that the contents of `bufs` in never modified following the call, and that/// all of the pointers in `bufs` are page aligned, and the lengths are/// multiples of a page size in bytes./// `tee(fd_in, fd_out, len, flags)`—Copy data between pipes without/// consuming it./// This reads up to `len` bytes from `in_fd` without consuming them, and/// writes them to `out_fd`./// [Linux]: https://man7.org/linux/man-pages/man2/tee.2.htmlfcntl_getpipe_size/// `fnctl(fd, F_GETPIPE_SZ)`—Return the buffer capacity of a pipe.fcntl_setpipe_size/// `fnctl(fd, F_SETPIPE_SZ)`—Set the buffer capacity of a pipe.r" `PR_PAC_APIAKEY`—Instruction authentication key `A`."r" `PR_PAC_APIBKEY`—Instruction authentication key `B`."r" `PR_PAC_APDAKEY`—Data authentication key `A`."r" `PR_PAC_APDBKEY`—Data authentication key `B`."r" `PR_PAC_APGAKEY`—Generic authentication `A` key."//! Helper functions for `prctl` syscalls./// `getCWD`—Return the current working directory./// `ioctl(fd, TIOCSCTTY, 0)`—Sets the controlling terminal for the process.Tiocsctty//! Process-oriented `ioctl`s.//! This module invokes `ioctl`s./// If `pid` is 1, this sends a signal to all processes the current process has/// permission to send signals to, except process `1`, possibly other/// This function doesn't return a `Result` because it always succeeds; if the/// underlying OS doesn't support the `membarrier` syscall, it returns an empty/// `MembarrierQuery` value./// `syscall(SYS_pidfd_open, pid, flags)`—Creates a file descriptor for a/// `syscall(SYS_pidfd_send_signal, pidfd, sig, NULL, 0)`—Send a signal to a/// process specified by a file descriptor./// [Linux]: https://man7.org/linux/man-pages/man2/pidfd_send_signal.2.htmlForeignRawFd/// Raw file descriptor in another process./// A distinct type alias is used here to inform the user that normal file/// descriptors from the calling process should not be used. The provided file/// descriptor is used by the kernel as the index into the file descriptor/// table of an entirely different process.r" All flags are reserved for future use."/// `syscall(SYS_pidfd_getfd, pidfd, flags)`—Obtain a duplicate of another/// process' file descriptor./// This function is generally safe for the calling process, but it can impact/// the target process in unexpected ways. If you want to ensure that Rust I/O/// safety assumptions continue to hold in the target process, then the target/// process must have communicated the file description number to the calling/// process from a value of a type that implements `AsRawFd`, and the target/// process must not drop that value until after the calling process has/// returned from `pidfd_getfd`./// When `pidfd_getfd` is used to debug the target, or the target is not a Rust/// application, or `pidfd_getfd` is used in any other way, then extra care/// should be taken to avoid unexpected behaviour or crashes./// For further details, see the references above./// [Linux]: https://man7.org/linux/man-pages/man2/pidfd_getfd.2.html//! The [`pidfd_getfd`] function and supporting types./// Get the current state of the calling process' `dumpable` attribute.r" [`set_unaligned_access_control`]."/// Please ensure the conditions necessary to safely call this function, as/// detailed in the references above.r" The speculation feature is disabled, mitigation is enabled, and it"r" cannot be undone."r" The speculation feature is disabled, mitigation is enabled, and the"r" state will be cleared on `execve`."r" Mitigation can be controlled per thread by"r" `PR_SET_SPECULATION_CTRL`."/// Enable the `no_new_privs` mode that ignores SUID and SGID bits on `execve`/// in the specified process and its future descendants./// This is similar to `set_no_new_privs` on Linux, with the exception that on/// FreeBSD there is no argument `no_new_privs` argument as it's only possible/// to enable this mode and there's no going back./// The `CpuSet` argument specifies the set of CPUs on which the thread will be/// eligible to run./// `sched_getcpu()`—Get the CPU that the current thread is currently on./// [Linux]: https://man7.org/linux/man-pages/man2/sched_getcpu.2.html/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=sched_getcpu&section=2// FreeBSD added `sched_getcpu` in 13.0.r" Options for modifying the behavior of [`wait`]/[`waitpid`]."r" Options for modifying the behavior of [`waitid`]."/// Returns the number of the signal that stopped the process, if the/// process was stopped by a signal./// Returns the exit status number returned by the process, if it exited/// normally./// Returns the number of the signal that terminated the process, if the/// process was terminated by a signal./// Returns whether the process was terminated by a signal and did not/// create a core file./// Returns whether the process was terminated by a signal and did create a/// core file./// Returns the number of the signal that trapped the process, if the/// process was trapped by a signal./// Wait for a specific process group ID, or the calling process' group ID./// # Bugs/// This function does not currently support waiting for given process group/// (the < 0 case of `waitpid`); to do that, currently the [`waitpgid`] or/// [`waitid`] function must be used./// This function does not currently support waiting for any process (the/// `-1` case of `waitpid`); to do that, currently the [`wait`] function must/// `waitpid(-pgid, waitopts)`—Wait for a process in a specific process group/// to change state./// The call will wait for any child process with the given pgid./// If `NOHANG` was specified in the options, and no selected child process/// changed state, returns `None`.check_proc_symlink//! mounted.//! `/proc` serves as an adjunct to Linux's main syscall surface area,/// unspecified behavior if the calling process has a [`Signal::Child`] signal/// handler installed./// [`Signal::Child`]: crate::process::Signal::ChildTiocgptpeer/// This is identical to [`getrandom`], except that it can read into/// `prctl(PR_SET_FS, data)`—Set the x86-64 `fs` register./// Set the x86-64 thread ID address./// This does not call any `__cxa_atexit`, `atexit`, or any other destructors./// `EXIT_SUCCESS` for use with [`exit_group`]./// `EXIT_FAILURE` for use with [`exit_group`]./// `addr` will always be non-null, even when the TLS data is absent, so that/// the `addr` and `file_size` parameters are suitable for creating a slice/// with `slice::from_raw_parts`./// `(getauxval(AT_PHDR), getauxval(AT_PHENT), getauxval(AT_PHNUM))`—Returns/// the address, ELF segment header size, and number of ELF segment headers for/// the main executable./// `getauxval(AT_ENTRY)`—Returns the address of the program entrypoint./// Most code interested in the program entrypoint address should instead use a/// symbol reference to `_start`. That will be properly PC-relative or/// relocated if needed, and will come with appropriate pointer type and/// pointer provenance./// This function is intended only for use in code that implements those/// relocations, to compute the ASLR offset. It has type `usize`, so it doesn't/// carry any provenance, and it shouldn't be used to dereference memory./// `getauxval(AT_RANDOM)`—Returns the address of 16 pseudorandom bytes./// These bytes are for use by libc. For anything else, use the `rand` crate.///  - And more./// guaranteed to be async-signal-safe. But, what does async-signal-safe even/// mean in a Rust program? This documentation does not have all the answers./// So you're on your own. And on top of all the troubles with `fork` in/// general, this wrapper implementation is highly experimental./// Regular Unix `fork` doesn't tell the child its own PID because it assumes/// the child can just do `getpid`. That's true, but it's more fun if it/// doesn't have to./// `sigpending()`—Query the pending signals.///  - [Linux `sigpending`]/// [Linux `sigpending`]: https://man7.org/linux/man-pages/man2/sigpending.2.html/// `sigsuspend(set)`—Suspend the calling thread and wait for signals.///  - [Linux `sigsuspend`]/// [Linux `sigsuspend`]: https://man7.org/linux/man-pages/man2/sigsuspend.2.html/// `sigwaitinfo(set)`—Wait for signals, returning a [`Siginfo`]./// `getauxval(AT_SECURE)`—Returns the Linux “secure execution” mode./// Return a boolean value indicating whether “secure execution” mode was/// requested, due to the process having elevated privileges. This includes/// whether the `AT_SECURE` AUX value is set, and whether the initial real UID/// and GID differ from the initial effective UID and GID./// The meaning of “secure execution” mode is beyond the scope of this/// comment./// `brk(addr)`—Change the location of the “program break”./// This is not identical to `brk` in libc. libc `brk` may have bookkeeping/// that needs to be kept up to date that this doesn't keep up to date, so/// don't use it unless you are implementing libc./// `__SIGRTMIN`—The start of the realtime signal range./// This is the raw `SIGRTMIN` value from the OS, which is not the same as the/// `SIGRTMIN` macro provided by libc. Don't use this unless you are/// implementing libc./// `__SIGRTMAX`—The last of the realtime signal range./// This is the raw `SIGRTMAX` value from the OS, which is not the same as the/// `SIGRTMAX` macro provided by libc. Don't use this unless you are//! Experimental low-level implementation details for libc-like runtime//! libraries such as [Origin].//! code. They don't always behave the same way as functions with similar names//! in `libc`. Sometimes information about the differences is included in the//! Linux documentation under “C library/kernel differences” sections. And, if//! there is a libc in the process, these functions may have surprising//! interactions with it.//! [Origin]: https://github.com/sunfishcode/origin#readme/// `shm_open(name, oflags, mode)`—Opens a shared memory object./// For portability, `name` should begin with a slash, contain no other/// slashes, and be no longer than an implementation-defined limit (255 on/// Linux)./// Exactly one of [`ShmOFlags::RDONLY`] and [`ShmOFlags::RDWR`] should be/// passed. The file descriptor will be opened with `FD_CLOEXEC` set./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/shm_open.html/// [Linux]: https://man7.org/linux/man-pages/man3/shm_open.3.html/// `shm_unlink(name)`—Unlinks a shared memory object./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/shm_unlink.html/// [Linux]: https://man7.org/linux/man-pages/man3/shm_unlink.3.html//! POSIX shared memoryassert_eq_align//! Workarounds for Rust 1.63 where some things in the `static_assertions`//! crate do things that don't work in const contexts. We want to call them in//! const contexts in Rust versions where that's supported so that problems are//! caught at compile time, and fall back to dynamic asserts in Rust 1.63./// In `no_std` configurations, the stdin file descriptor can be closed,/// potentially on other threads, in which case the file descriptor index/// value could be dynamically reused for other purposes, potentially on/// different threads./// This function allows writing directly to stdout without coordinating/// corrupted output./// In `no_std` configurations, the stdout file descriptor can be closed,/// In `no_std` configurations, the stderr file descriptor can be closed,/// For `gethostname()`, use [`Uname::nodename`] on the result./// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/uname.3.html/// [NetBSD]: https://man.netbsd.org/uname.3/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=uname&sektion=3/// [OpenBSD]: https://man.openbsd.org/uname.3/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=uname&section=3/// [illumos]: https://illumos.org/man/2/uname/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Platform-Type.html/// This corresponds to the `gethostname` value.CadOff/// Disables the Ctrl-Alt-Del keystroke./// When disabled, the keystroke will send a [`Signal::Int`] to pid 1./// [`Signal::Int`]: crate::process::Signal::IntCadOn/// Enables the Ctrl-Alt-Del keystroke./// When enabled, the keystroke will trigger a [`Restart`]./// [`Restart`]: Self::RestartHalt/// Prints the message "System halted" and halts the systemKexec/// Execute a kernel that has been loaded earlier with [`kexec_load`]./// [`kexec_load`]: https://man7.org/linux/man-pages/man2/kexec_load.2.html/// Prints the message "Power down.", stops the system, and tries to remove/// all powerRestart/// Prints the message "Restarting system." and triggers a restartSwSuspend/// Hibernate the system by suspending to disk/// Reboot command for use with [`reboot`]./// `reboot`—Reboot the system or enable/disable Ctrl-Alt-Del/// The reboot syscall, despite the name, can actually do much more than/// reboot./// Among other things, it can:/// - Restart, Halt, Power Off, and Suspend the system/// - Enable and disable the Ctrl-Alt-Del keystroke/// - Execute other kernels/// - Terminate init inside PID namespaces/// It is highly recommended to carefully read the kernel documentation before/// - [Linux]/// [Linux]: https://man7.org/linux/man-pages/man2/reboot.2.html/// `init_module`—Load a kernel module/// [Linux]: https://man7.org/linux/man-pages/man2/init_module.2.html/// `finit_module`—Load a kernel module from a file descriptor/// [Linux]: https://man7.org/linux/man-pages/man2/finit_module.2.html/// `delete_module`—Unload a kernel module/// [Linux]: https://man7.org/linux/man-pages/man2/delete_module.2.html//! Terminal-related `ioctl` functions.//! This API automatically supports setting arbitrary I/O speeds, on any//! platform that supports them, including Linux and the BSDs.//! The [`speed`] module contains various predefined speed constants which//! are more likely to be portable, however any `u32` value can be passed to//! [`Termios::set_input_speed`], and it will simply fail if the speed is not//! supported by the platform./// Also known as the `TCGETS` (or `TCGETS2` on Linux) operation with `ioctl`./// On Linux, if `fd` is a pseudo-terminal, the underlying system call here can/// return a pid of 0, which rustix's `Pid` type doesn't support. So rustix/// instead handles this case by failing with [`io::Errno::OPNOTSUPP`] if the/// pid is 0./// Also known as the `TCSETS` (or `TCSETS2 on Linux) operation with `ioctl`./// This transmits zero-valued bits for at least 0.25 seconds./// This function does not have a `duration` parameter, and always uses the/// implementation-defined value, which transmits for at least 0.25 seconds./// Also known as the `TCSBRK` operation with `ioctl`, with a duration/// parameter of 0.input_modes/// How is input interpreted?output_modes/// How is output translated?control_modes/// Low-level configuration flags.local_modes/// High-level configuration flags./// Line discipline.special_codesSpecialCodes/// How are various special control codes handled?// On PowerPC, this field comes after `c_cc`.input_speed/// See the `input_speed` and `set_input_seed` functions./// On Linux and BSDs, this is the arbitrary integer speed value. On all/// other platforms, this is the encoded speed value.output_speed/// See the `output_speed` and `set_output_seed` functions./// On Linux and BSDs, this is the integer speed value. On all other/// platforms, this is the encoded speed value./// `cfmakeraw(self)`—Set a `Termios` value to the settings for “raw” mode./// In raw mode, input is available a byte at a time, echoing is disabled,/// and special terminal input and output codes are disabled./// Return the input communication speed./// Unlike the `c_ispeed` field in glibc and others, this returns the/// integer value of the speed, rather than the `B*` encoded constant/// Return the output communication speed./// Unlike the `c_ospeed` field in glibc and others, this returns the/// arbitrary integer value of the speed, rather than the `B*` encoded/// constant value./// Set the input and output communication speeds./// Unlike the `c_ispeed` and `c_ospeed` fields in glibc and others, this/// takes the arbitrary integer value of the speed, rather than the `B*`/// encoded constant value. Not all implementations support all integer/// values; use the constants in the [`speed`] module for likely-supported/// speeds./// Set the input communication speed./// Unlike the `c_ispeed` field in glibc and others, this takes the/// constant value. Not all implementations support all integer values; use/// the constants in the [`speed`] module for known-supported speeds./// On some platforms, changing the input speed changes the output speed/// to the same speed./// Set the output communication speed./// Unlike the `c_ospeed` field in glibc and others, this takes the/// On some platforms, changing the output speed changes the input speed/// Translate from a `c::speed_t` code to an arbitrary integer speed value/// On BSD platforms, integer speed values are already the same as their/// encoded values, and on Linux platforms, we use `TCGETS2`/`TCSETS2`/// and the `c_ispeed`/`c_ospeed`` fields, except that on Linux on/// PowerPC on QEMU, `TCGETS2`/`TCSETS2` don't set `c_ispeed`/`c_ospeed`./// Translate from an arbitrary `u32` arbitrary integer speed value to a/// `c::speed_t` code./// Speeds for use with [`Termios::set_input_speed`] and/// [`Termios::set_output_speed`]./// Unlike in some platforms' libc APIs, these always have the same numerical/// value as their names; for example, `B50` has the value `50`, and so on./// Consequently, it's not necessary to use them. They are provided here/// because they help identify speeds which are likely to be supported, on/// platforms which don't support arbitrary speeds./// An array indexed by [`SpecialCodeIndex`] indicating the current values/// of various special control codes./// Indices for use with [`Termios::special_codes`].termios_layoutstermios_legacytermios_bsdtermios_speed_encodingtermios_ioctl_contiguitytermios_cibaud/// This is not the setxid you are looking for… POSIX requires xids to be/// This is not the setresxid you are looking for… POSIX requires xids to beset_thread_groups/// `setgroups(groups)`-Sets the supplementary group IDs for the calling/// This is not the `setgroups` you are looking for… POSIX requires gids to be/// changes the gids for the current *thread*, not the entire process even/// [Linux]: https://man7.org/linux/man-pages/man2/setgroups.2.html/// [linux_notes]: https://man7.org/linux/man-pages/man2/setgroups.2.html#NOTESr" `CAP_*` constants."r" `CAP_CHOWN`"CHOWNr" `CAP_DAC_OVERRIDE`"DAC_OVERRIDEr" `CAP_DAC_READ_SEARCH`"DAC_READ_SEARCHr" `CAP_FOWNER`"FOWNERr" `CAP_FSETID`"FSETIDr" `CAP_KILL`"KILLr" `CAP_SETGID`"SETGIDr" `CAP_SETUID`"SETUIDr" `CAP_SETPCAP`"SETPCAPr" `CAP_LINUX_IMMUTABLE`"LINUX_IMMUTABLEr" `CAP_NET_BIND_SERVICE`"NET_BIND_SERVICEr" `CAP_NET_BROADCAST`"NET_BROADCASTr" `CAP_NET_ADMIN`"NET_ADMINr" `CAP_NET_RAW`"NET_RAWr" `CAP_IPC_LOCK`"IPC_LOCKr" `CAP_IPC_OWNER`"IPC_OWNERr" `CAP_SYS_MODULE`"SYS_MODULEr" `CAP_SYS_RAWIO`"SYS_RAWIOr" `CAP_SYS_CHROOT`"SYS_CHROOTr" `CAP_SYS_PTRACE`"SYS_PTRACEr" `CAP_SYS_PACCT`"SYS_PACCTr" `CAP_SYS_ADMIN`"SYS_ADMINr" `CAP_SYS_BOOT`"SYS_BOOTr" `CAP_SYS_NICE`"SYS_NICEr" `CAP_SYS_RESOURCE`"SYS_RESOURCEr" `CAP_SYS_TIME`"SYS_TIMEr" `CAP_SYS_TTY_CONFIG`"SYS_TTY_CONFIGr" `CAP_MKNOD`"MKNODr" `CAP_LEASE`"LEASEr" `CAP_AUDIT_WRITE`"AUDIT_WRITEr" `CAP_AUDIT_CONTROL`"AUDIT_CONTROLr" `CAP_SETFCAP`"SETFCAPr" `CAP_MAC_OVERRIDE`"MAC_OVERRIDEr" `CAP_MAC_ADMIN`"MAC_ADMINr" `CAP_SYSLOG`"SYSLOGr" `CAP_WAKE_ALARM`"WAKE_ALARMr" `CAP_BLOCK_SUSPEND`"BLOCK_SUSPENDr" `CAP_AUDIT_READ`"AUDIT_READr" `CAP_PERFMON`"PERFMONr" `CAP_BPF`"BPFr" `CAP_CHECKPOINT_RESTORE`"CHECKPOINT_RESTORE/// Unlike `pthread_setname_np`, this function silently truncates the name to/// 16 bytes, as the Linux syscall does./// process sending a signal must match the real or effective user ID of/// the process receiving the signal./// [`Capability::SystemAdmin`] is required to iterate system-wide loaded/// programs, maps, links, and BTFs, and convert their IDs to file/// descriptors.r" `SECBIT_*`."r" If this bit is set, then the kernel does not grant capabilities"r" when a `set-user-ID-root` program is executed, or when a process"r" with an effective or real UID of 0 calls `execve`."NO_ROOTr" Set [`NO_ROOT`] irreversibly."NO_ROOT_LOCKEDr" Setting this flag stops the kernel from adjusting the process'"r" permitted, effective, and ambient capability sets when the thread's"r" effective and filesystem UIDs are switched between zero and nonzero"r" values."NO_SETUID_FIXUPr" Set [`NO_SETUID_FIXUP`] irreversibly."NO_SETUID_FIXUP_LOCKEDr" Setting this flag allows a thread that has one or more 0 UIDs to"r" retain capabilities in its permitted set when it switches all of"r" its UIDs to nonzero values."KEEP_CAPSr" Set [`KEEP_CAPS`] irreversibly."KEEP_CAPS_LOCKEDr" Setting this flag disallows raising ambient capabilities via the"r" `prctl`'s `PR_CAP_AMBIENT_RAISE` operation."NO_CAP_AMBIENT_RAISEr" Set [`NO_CAP_AMBIENT_RAISE`] irreversibly."NO_CAP_AMBIENT_RAISE_LOCKEDr" Zero means addresses that are passed for the purpose of being"r" dereferenced by the kernel must be untagged."r" Addresses that are passed for the purpose of being dereferenced by"r" the kernel may be tagged."ENABLEDr" Synchronous tag check fault mode."TCF_SYNCr" Asynchronous tag check fault mode."TCF_ASYNC/*
/// Get the secure computing mode of the calling thread.
///
/// If the caller is not in secure computing mode, this returns
/// [`SecureComputingMode::Disabled`]. If the caller is in strict secure
/// computing mode, then this call will cause a [`Signal::Kill`] signal to be
/// sent to the process. If the caller is in filter mode, and this system call
/// is allowed by the seccomp filters, it returns
/// [`SecureComputingMode::Filter`]; otherwise, the process is killed with a
/// [`Signal::Kill`] signal.
///
/// Since Linux 3.8, the Seccomp field of the `/proc/[pid]/status` file
/// provides a method of obtaining the same information, without the risk that
/// the process is killed; see [the `proc` manual page].
///
/// # References
///  - [`prctl(PR_GET_SECCOMP,...)`]
///
/// [`prctl(PR_GET_SECCOMP,...)`]: https://man7.org/linux/man-pages/man2/prctl.2.html
/// [the `proc` manual page]: https://man7.org/linux/man-pages/man5/proc.5.html
#[inline]
pub fn secure_computing_mode() -> io::Result<SecureComputingMode> {
    unsafe { prctl_1arg(PR_GET_SECCOMP) }.and_then(TryInto::try_into)
}
*/r" Thread name space type."r" Time name space."r" Mount name space."MOUNTr" Control group (CGroup) name space."CONTROL_GROUPr" `Host name` and `NIS domain name` (UTS) name space."HOST_NAME_AND_NIS_DOMAIN_NAMEr" Inter-process communication (IPC) name space."INTER_PROCESS_COMMUNICATIONr" User name space."r" Process ID name space."PROCESS_IDr" Network name space."r" `CLONE_*` for use with [`unshare`]."r" `CLONE_FILES`."FILESr" `CLONE_FS`."r" `CLONE_NEWCGROUP`."NEWCGROUPr" `CLONE_NEWIPC`."NEWIPCr" `CLONE_NEWNET`."NEWNETr" `CLONE_NEWNS`."NEWNSr" `CLONE_NEWPID`."NEWPIDr" `CLONE_NEWTIME`."NEWTIMEr" `CLONE_NEWUSER`."NEWUSERr" `CLONE_NEWUTS`"NEWUTSr" `CLONE_SYSVSEM`."SYSVSEM//! `Timespec` and related types, which are used by multiple public API//! modules.// Return the raw value of the IDs. In case of `None` it returns `!0` since it// has the same bit pattern as `-1` indicating no change to the owner/group ID.//! User and Group ID types.default_array/// Create an array value containing all default values, inferring the type.default_union/// Create a union value containing a default value in one of its arms./// The field names a union field which must have the same size as the union//! Miscellaneous minor utilities.// To avoid having the `linux_raw` backend depend on the libc crate, just// declare the few things we need in a module called `libc` so that `fetch`// uses it.// however that depends on the `extern_weak` feature which is currentlyhas_lower_upper_exp_for_non_zero// `O_LARGEFILE` can be automatically set by the kernel on Linux:// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/open.c?h=v6.13#n1423>// so libc implementations may leave it undefined or defined to zero.// <https://github.com/illumos/illumos-gate/blob/fb2cb638e5604b214d8ea8d4f01ad2e77b437c17/usr/src/ucbhead/sys/fcntl.h#L64>// `termios2`, so we define aliases.// And PowerPC doesn't define `CIBAUD`, but it does define `IBSHIFT`, so we can// compute `CIBAUD` ourselves.// Rust's libc crate lacks statx for Non-glibc targets.// FreeBSD added `timerfd_*` in FreeBSD 14. NetBSD added then in NetBSD 10.// <https://code.illumos.org/plugins/gitiles/illumos-gate/+/refs/heads/master/usr/src/uts/common/sys/timerfd.h#34>// <https://nxr.netbsd.org/xref/src/sys/sys/timerfd.h#44>// illumos and NetBSD timerfd support.// Submitted upstream in <https://github.com/rust-lang/libc/pull/4333>.FdSetElement// WASI uses a count + array instead of a bitvector.port_getn_query/// `seekdir(self, offset)`/// This function is only available on 64-bit platforms because it's/// implemented using [`libc::seekdir`] which only supports offsets that/// fit in a `c_long`./// [`libc::seekdir`]: https://docs.rs/libc/*/arm-unknown-linux-gnueabihf/libc/fn.seekdir.html/// `Dir` is `Send` and `Sync`, because even though it contains internal/// state, all methods that modify the state require a `mut &self` and/// can therefore not be called concurrently. Calling them from different/// threads sequentially is fine./// Returns the “offset” of this directory entry. This is not a true/// numerical offset but an opaque cookie that identifies a position in the/// given stream.//! inotify support for working with inotify objects.// TODO: Remove the unsafe blocks. libc 0.2.171 removed `unsafe` from several// of these functions. Eventually we should depend on that version and remove// the `unsafe` blocks in the code, but for now, disable that warning so that// we're compatible with older libc versions./// Attribute list for use with [`setattrlist`].fix_negative_stat_nsecs/// See [`crate::timespec::fix_negative_nsec`] for details.// Solaris doesn't support `flock` and doesn't define `LOCK_SH` etc., but we// reuse this `FlockOperation` enum for `fcntl_lock`, so on Solaris we use// our own made-up integer values.st_spare// NetBSD's `st_mtime_nsec` is named `st_mtimensec` so we declare our own// `Stat` so that we can be consistent with other platforms.Fsid/// `fsid_t` for use with [`StatFs`]./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/errno.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Error-Codes.htmltry_closeIoringRegisterFlagsio_uring_register_with// Re-export `AsSocket` etc. too, as users can't implement `AsFd` etc. on// Windows due to them having blanket impls on Windows, so users must// implement `AsSocket` etc./// [`as_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsRawFd.html#tymethod.as_raw_fd/// [`into_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.IntoRawFd.html#tymethod.into_raw_fd/// An `as_fd` function for Winsock, where an `Fd` is a `Socket`.fsconfig_create_exclCreateExclusive/// `FSCONFIG_CMD_CREATE_EXCL` (since Linux 6.6)SocketAddrLen/// Construct a new unnamed address./// The kernel will assign an abstract Unix-domain address to the socket/// when you call [`bind`][crate::net::bind]. You can inspect the assigned/// name with [`getsockname`][crate::net::getsockname]./// [Linux]: https://www.man7.org/linux/man-pages/man7/unix.7.htmlpath_with_termination/// If the `sun_path` field is not NUL-terminated, terminate it./// SAFETY: The input `bytes` must not contain any NULs./// For a filesystem path address, return the path as a byte sequence,/// excluding the NUL terminator./// `true` if the socket address is unnamed./// `struct sockaddr_storage`/// This type is guaranteed to be large enough to hold any encoded socket/// Return a socket addr storage initialized to all zero bytes. The/// `sa_family` is set to [`AddressFamily::UNSPEC`]./// Return the `sa_family` of this socket address.clear_family/// Clear the `sa_family` of this socket address to/// [`AddressFamily::UNSPEC`].SocketAddrArgSocketAddrBuf/// If `f` dereferences the pointers in the `msghdr`, it must do so only within/// the bounds indicated by the associated lengths in the `msghdr`./// And, if `f` returns `Ok`, it must have updated the `msg_controllen` field/// of the `msghdr` to indicate how many bytes it initialized.noaddr_msghdr/// The returned `msghdr` will contain raw pointers to the memory/// referenced by `iov` and `control`.with_msghdr/// Create a message header intended to send with the specified address./// This creates a `c::msghdr` and calls a function `f` on it. The `msghdr`'s/// raw pointers may point to temporaries, so this function should avoid/// storing the pointers anywhere that would outlive the function call.//! Wrappers for netdevice ioctls.SocketAddrNetlinkSocketAddrXdpFlagsread_sa_family/// Read the `sa_family` field from a socket address returned from the OS.read_sun_path0/// Read the first byte of the `sun_path` field, assuming we have an `AF_UNIX`/// socket address.sockaddr_nonempty/// Check if a socket address returned from the OS is considered non-empty./// `storage` must point to a least an initialized `sockaddr_header`./// Set the `sa_family` field of a socket address to `AF_UNSPEC`, so that weread_sockaddr_v4read_sockaddr_v6read_sockaddr_unixread_sockaddr_xdpread_sockaddr_netlink//! The BSD sockets API requires us to read the `sa_family` field before we canIpv4PathMtuDiscoveryIpv6PathMtuDiscoveryTxTimeFlagssocket_reuseaddrsocket_broadcastsocket_lingersocket_passcredsocket_timeoutsocket_nosigpipesocket_errorsocket_keepaliveset_socket_recv_buffer_size_forcesocket_recv_buffer_sizeset_socket_send_buffer_size_forcesocket_send_buffer_sizesocket_domainsocket_acceptconnsocket_oobinlinesocket_reuseportsocket_reuseport_lbsocket_protocolsocket_cookiesocket_incoming_cpuip_ttlipv6_v6onlyip_mtuipv6_mtuset_ip_mtu_discoverip_mtu_discoverset_ipv6_mtu_discoveripv6_mtu_discoverset_ip_multicast_ifip_multicast_ifset_ip_multicast_if_with_ifindexset_ipv6_multicast_ifipv6_multicast_ifip_multicast_loopip_multicast_ttlipv6_multicast_loopipv6_multicast_hopsipv6_unicast_hopsip_tosip_recvtosipv6_recvtclassip_freebindipv6_freebindip_original_dstipv6_original_dstipv6_tclasstcp_keepcnttcp_keepidletcp_keepintvltcp_quickacktcp_congestiontcp_thin_linear_timeoutstcp_corksocket_peercredset_txtimeget_txtimefrom_in_addr// On Windows, this should use `BOOL`, however windows-sys moved its `BOOL`// from `windows_sys::Win32::Foundation::BOOL` to `windows_sys::core::BOOL`// in windows-sys 0.60, and we'd preferMMsgHdrReturnFlagssendmsg_addr/// Darwin lacks `accept4`, but does have `accept`. We define `SocketFlags` to/// have no flags, so we can discard it here.WaitIdOptionsWaitIdStatus/// Convert a `siginfo_t` to a `WaitIdStatus`.fcntl_getlk// <https://github.com/rust-lang/libc/pull/4212>tcgetattr_fallback/// Implement `tcgetattr` using the old `TCGETS` ioctl.tcsetattr_fallback/// Implement `tcsetattr` using the old `TCSETS` ioctl.//! Types for the `termios` module.// We don't want to use `tcflag_t` directly so we don't expose libc// publicly. Redox uses `u32`, apple uses `c_ulong`, everything else// seems to use `c_uint`.WakeBitset/// `FUTEX_WAKE_BITSET`WaitRequeuePi/// `FUTEX_WAIT_REQUEUE_PI`CmpRequeuePi/// `FUTEX_CMP_REQUEUE_PI`LockPi2/// `FUTEX_LOCK_PI2`/// `FUTEX_*` operations for use with the futex syscall wrappers.WAITERS/// `FUTEX_WAITERS`OWNER_DIED/// `FUTEX_OWNER_DIED`as_libc_timespec_mut_ptras_libc_timespec_ptrfutex_val2/// The raw pointers must point to valid aligned memory.futex_timeoutfutex_old_timespecWaitvFlags/// [`membarrier`]: crate::thread::membarrier/// [`membarrier_cpu`]: crate::thread::membarrier_cpu/// [`membarrier_query`]: crate::thread::membarrier_queryfix_negative_timespec_nsecs/// See [`crate::timespec::fix_negative_nsecs`] for details.as_libc_itimerspec_ptras_libc_itimerspec_mut_ptr// windows-sys declares these constants as `u16`. For better compatibility with// Unix-family APIs, redeclare them as `i32`.// Windows doesn't have `timespec`, just `timeval`. Rustix only uses `timespec`// in its public API. So define one, and we'll convert it internally.//! MIPS-family platforms have a special calling convention for `__NR_pipe`,//! MIPS R6 inline assembly currently doesn't differ from MIPS, because no//! explicit call of R6-only or R2-only instructions exist here.//! powerpc Linux system calls.//! On powerpc, Linux indicates success or failure using `cr0.SO` rather//! check the flag and negate the error value to make PowerPC look like other//! s390x Linux system calls.opt_ref/// Convert an optional immutable reference into a `usize` for passing to ar" `EPOLL_*` for use with [`epoll::create`]."r" [`epoll::create`]: crate::event::epoll::create"r" `EPOLL*` for use with [`epoll::add`]."r" [`epoll::add`]: crate::event::epoll::add"// In the linux_raw backend here, we don't use `libc::seekdir` and don't// have this limitation, but it's a goal of rustix to support the same API// on both the linux_raw and libc backends.r" `IN_*` for use with [`inotify::init`]."r" [`inotify::init`]: crate::fs::inotify::init"r" `IN*` for use with [`inotify::add_watch`]."r" [`inotify::add_watch`]: crate::fs::inotify::add_watch"r" `IN*` for use with [`inotify::Reader`]."r" [`inotify::Reader`]: crate::fs::inotify::InotifyReader"ReadFlagsr" `IN_IGNORED`"r" `IN_ISDIR`"r" `IN_Q_OVERFLOW`"QUEUE_OVERFLOWr" `IN_UNMOUNT`"r" `O_DSYNC`"r" `O_FSYNC`"r" `O_RSYNC`"r" Rustix and/or libc will automatically set this flag when"r" appropriate in the [`rustix::fs::open`] family of functions, so"r" typical users do not need to care about it. It may be reported in"r" the return of `fcntl_getfl`, though."r" `O_ASYNC`, `FASYNC`"r" This flag can't be used with the [`rustix::fs::open`] family of"r" functions, use [`rustix::fs::fcntl_setfl`] instead."r" `F_SEAL_SEAL`"r" `F_SEAL_SHRINK`"r" `F_SEAL_GROW`"r" `F_SEAL_WRITE`"r" `F_SEAL_EXEC` (since Linux 6.3)"// Within the kernel the `dev_t` is 32-bit, but userspace uses a 64-bit field.// Re-export the maybe-polyfill `core::os::fd`.//! uninitialized memory buffers. The signatures in this module are currently// SAFETY: Bindgen adds a union with a raw pointer for alignment but it's never// used. `sockaddr_storage` is just a bunch of bytes and it doesn't hold// pointers.// SAFETY: Same as with `Send`.r" `MSG_*` flags for use with [`send`], [`sendto`], and related"r" `MSG_EOR`"EORr" `MSG_*` flags returned from [`recvmsg`], in the `flags` field of"r" [`RecvMsg`]"r" [`recvmsg`]: crate::net::recvmsg"r" [`RecvMsg`]: crate::net::RecvMsg"r" `MSG_CTRUNC`"CTRUNCsocket_timeout_old/// Like `duration_from_linux_sock_timeval` but uses Linux's old 32-bit/// Like `duration_to_linux_sock_timeval` but uses Linux's old 32-bit/// Use Linux ≥ 6.4's [`PR_GET_AUXV`] to read the aux records, into a provided///  - `Ok(…)` if the buffer is big enough.///  [`PR_GET_AUXV`]: https://www.man7.org/linux/man-pages/man2/PR_GET_AUXV.2const.html/// Use Linux ≥ 6.4's [`PR_GET_AUXV`] to read the aux records, using a/// provided statically-sized buffer if possible, or a dynamically allocated/// buffer otherwise. Return:///  - Ok(…) on success.r" [`splice`]: crate::pipe::splice"r" [`vmsplice`]: crate::pipe::splice"r" [`tee`]: crate::pipe::tee"test_libc_correspondenceKernelSigSetKernelSigactionkernel_forkkernel_sigaltstackkernel_sigprocmaskkernel_sigpendingkernel_sigsuspendkernel_sigwaitkernel_sigwaitinfokernel_sigtimedwaitkernel_brkr" `O_*` constants for use with [`shm::open`]."r" [`shm::open`]: crate:shm::open"/// Seconds since boot/// 1, 5, and 15 minute load averages/// Total usable main memory size/// Available memory size/// Amount of shared memory/// Memory used by buffers/// Total swap space size/// Swap space still available/// Number of current processes/// Total high memory size/// Available high memory size/// Memory unit size in bytes// We don't want to use `tcflag_t` directly so we don't expose linux_raw_sys// publicly. It appears to be `c_ulong `on SPARC and `c_uint` everywhere else.// `sched_getcpu` on platforms without a vDSO entry for it.ElfHashEntry//nchain: ElfHashEntry,/// Straight from the ELF specification…and then tweaked slightly, in order to/// avoid a few clang warnings./// (And then translated to Rust).check_sym/// Check to see if the symbol is the one we're looking for.test_vdso// Disable on MIPS since QEMU on MIPS doesn't provide a vDSO.//! tools/testing/selftests/vDSO/parse_vdso.c in Linux 6.13, which is licensed//! It also incorporates the patch at://! <https://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git/commit/tools/testing/selftests/vDSO?h=next&id=01587d80b04f29747b6fd6d766c3bfa632f14eb0>,//! with changes to fix the pointer arithmetic on s390x.clock_gettime_via_syscall_clock_gettime_via_syscall_clock_gettime_via_syscall_oldgetcpu_via_syscallrustix_x86_int_0x80/// A symbol pointing to an x86 `int 0x80` instruction. This “function”/// is only called from assembly, and only with the x86 syscall calling/// convention, so its signature here is not its true signature./// This extern block and the `global_asm!` below can be replaced with/// `#[naked]` if it's stabilized.// This uses `.weak` so that it doesn't conflict if multiple versions of rustix// are linked in in non-lto builds, and `.ifndef` so that it doesn't conflict// if multiple versions of rustix are linked in in lto builds./// A memory buffer that may be uninitialized./// There are three types that implement the `Buffer` trait, and the type you/// use determines the return type of the functions that use it:/// | If you pass a…           | You get back a… |/// | ------------------------ | --------------- |/// | `&mut [u8]`              | `usize`, indicating the number of elements initialized. |/// | `&mut [MaybeUninit<u8>]` | `(&mut [u8], &mut [MaybeUninit<u8>])`, holding the initialized and uninitialized subslices. |/// | [`SpareCapacity`]        | `usize`, indicating the number of elements initialized. And the `Vec` is extended. |/// Passing a `&mut [u8]`:/// # use rustix::io::read;/// # fn example(fd: rustix::fd::BorrowedFd) -> rustix::io::Result<()> {/// let mut buf = [0_u8; 64];/// let nread = read(fd, &mut buf)?;/// // `nread` is the number of bytes read./// Passing a `&mut [MaybeUninit<u8>]`:/// let mut buf = [MaybeUninit::<u8>::uninit(); 64];/// let (init, uninit) = read(fd, &mut buf)?;/// // `init` is a `&mut [u8]` with the initialized bytes./// // `uninit` is a `&mut [MaybeUninit<u8>]` with the remaining bytes./// Passing a [`SpareCapacity`], via the [`spare_capacity`] helper function:/// # use rustix::buffer::spare_capacity;/// let mut buf = Vec::with_capacity(64);/// let nread = read(fd, spare_capacity(&mut buf))?;/// // Also, `buf.len()` is now `nread` elements longer than it was before./// # Guide to error messages/// Sometimes code using `Buffer` can encounter non-obvious error messages./// Here are some we've encountered, along with ways to fix them./// If you see errors like/// "cannot move out of `self` which is behind a mutable reference"/// "move occurs because `x` has type `&mut [u8]`, which does not implement the `Copy` trait",/// replace `x` with `&mut *x`. See `error_buffer_wrapper` in/// examples/buffer_errors.rs./// "type annotations needed"/// "cannot infer type of the type parameter `Buf` declared on the function `read`",/// you may need to change a `&mut []` to `&mut [0_u8; 0]`. See/// `error_empty_slice` in examples/buffer_errors.rs./// "the trait bound `[MaybeUninit<u8>; 1]: Buffer<u8>` is not satisfied",/// add a `&mut` to pass the array by reference instead of by value. See/// `error_array_by_value` in examples/buffer_errors.rs./// "cannot move out of `x`, a captured variable in an `FnMut` closure",/// try replacing `x` with `&mut *x`, or, if that doesn't work, try moving a/// `let` into the closure body. See `error_retry_closure` and/// `error_retry_indirect_closure` in examples/buffer_errors.rs./// "captured variable cannot escape `FnMut` closure body",/// use an explicit loop instead of `retry_on_intr`, assuming you're using/// that. See `error_retry_closure_uninit` in examples/buffer_errors.rs.// Implement `Buffer` for all the types that implement `Sealed`.SpareCapacityparts_mut// `Vec` implements `DerefMut` to `&mut [T]`, however it doesn't get// auto-derefed in a `impl Buffer<u8>`, so we add this `impl` so that our users// don't have to add an extra `*` in these situations./// A type that implements [`Buffer`] by appending to a `Vec`, up to its/// To use this, use the [`spare_capacity`] function./// Because this uses the capacity, and never reallocates, the `Vec` should/// have some non-empty spare capacity./// Construct an [`SpareCapacity`], which implements [`Buffer`]./// This wraps a `Vec` and uses the spare capacity of the `Vec` as the buffer/// to receive data in, automatically calling `set_len` on the `Vec` to set the/// length to include the received elements./// This uses the existing capacity, and never allocates, so the `Vec` should/// have some non-empty spare capacity!/// # fn test(input: rustix::fd::BorrowedFd) -> rustix::io::Result<()> {/// use rustix::buffer::spare_capacity;/// use rustix::io::{read, Errno};/// let mut buf = Vec::with_capacity(1024);/// match read(input, spare_capacity(&mut buf)) {///     Ok(0) => { /* end of stream */ }///     Ok(n) => { /* `buf` is now `n` bytes longer */ }///     Err(Errno::INTR) => { /* `buf` is unmodified */ }///         return Err(e);/// The mutated `Vec` reflects the number of bytes read. We also return/// this number, and a value of 0 indicates the end of the stream has/// been reached./// The result of the process operation./// Return a pointer and length for this buffer./// The length is the number of elements of type `T`, not a number of/// It's tempting to have this return `&mut [MaybeUninit<T>]` instead,/// however that would require this function to be `unsafe`, because/// callers could use the `&mut [MaybeUninit<T>]` slice to set elements/// to `MaybeUninit::<T>::uninit()`, which would be a problem if `Self`/// is `&mut [T]` or similar./// Convert a finished buffer pointer into its result./// At least `len` elements of the buffer must now be initialized.test_compilationtest_slicetest_slice_uninittest_spare_capacity//! Utilities for functions that return data via buffers.check_renamed_struct_field/// The same as `check_struct_field`, but for when the struct is renamed/// but the field is not.check_renamed_struct/// For the case of renaming, check all fields of a struct./// On FreeBSD, this is an alias for [`Self::Boottime`]./// On OpenBSD, this differs from `Self::Boottime`; it only advances when/// the system is not suspended./// `CLOCK_TAI`, available on Linux ≥ 3.10/// In Rust ≥ 1.77, users can use [C-string literals] instead of this macro./// [C-string literals]: https://blog.rust-lang.org/2024/03/21/Rust-1.77.0.html#c-string-literals/// Use the [`epoll::CreateFlags::CLOEXEC`] flag to prevent the resulting file/// [Linux]: https://man7.org/linux/man-pages/man2/epoll_create.2.html/// [illumos]: https://www.illumos.org/man/3C/epoll_createEpollFd/// This registers interest in any of the events set in `event_flags` occurring/// `close`ing a file descriptor does not necessarily unregister interest which/// can lead to spurious events being returned from [`epoll::wait`]. If a file/// descriptor is an `Arc<dyn SystemResource>`, then `epoll` can be thought to/// maintain a `Weak<dyn SystemResource>` to the file descriptor. Check the/// [faq] for details./// [Linux]: https://man7.org/linux/man-pages/man2/epoll_ctl.2.html/// [illumos]: https://www.illumos.org/man/3C/epoll_ctl/// [faq]: https://man7.org/linux/man-pages/man7/epoll.7.html#:~:text=Will%20closing%20a%20file%20descriptor%20cause%20it%20to%20be%20removed%20from%20all%0A%20%20%20%20%20%20%20%20%20%20epoll%20interest%20lists%3F/// For each event of interest, an element is written to `events`./// Linux versions older than 5.11 (those that don't support `epoll_pwait2`)/// don't support timeouts greater than `c_int::MAX` milliseconds; if an/// unsupported timeout is passed, this function fails with/// [`io::Errno::INVAL`]. Enable the "linux_5_11" feature to enable the full/// range of timeouts./// [Linux]: https://man7.org/linux/man-pages/man2/epoll_wait.2.html/// [illumos]: https://www.illumos.org/man/3C/epoll_wait/// Data associated with an [`epoll::Event`]. This can either be a 64-bit/// integer value or a pointer which preserves pointer provenance.//! use rustix::buffer::spare_capacity;//!     accept, bind, listen, socket, AddressFamily, Ipv4Addr, SocketAddrV4, SocketType,//! bind(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?;//! let mut event_list = Vec::with_capacity(4);//!     epoll::wait(&epoll, spare_capacity(&mut event_list), None)?;//!     for event in event_list.drain(..) {/// Bottom 24 bits of a `u32`./// The number of times the signal has been received since the last/// call to kevent.kevent_timespec/// If an unsupported timeout is passed, this function fails with/// [`io::Errno::INVAL`]./// This is a wrapper around [`kevent_timespec`] which takes a `Duration`/// instead of a `Timespec` for the timemout value. `Timespec` has a signed/// `i64` seconds field; if converting `Duration` to `Timespec` overflows,/// `None` is passed as the timeout instead, such such a large timeout would/// be effectively infinite in practice./// `pause()`—Sleep until interrupted by a signal./// `pause` does is sleep until interrupted by a signal. If it were exposed in/// the API here it would always return `Errno::INTR`, so for simplicity the/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/pause.html/// `poll(self.fds, timeout)`—Wait for events on lists of file descriptors./// Some platforms (those that don't support `ppoll`) don't support timeouts/// greater than `c_int::MAX` milliseconds; if an unsupported timeout is/// passed, this function fails with [`io::Errno::INVAL`]./// On macOS, `poll` doesn't work on fds for /dev/tty or /dev/null, however/// [`select`] is available and does work on these fds./// [`select`]: crate::event::select()/// This function does not use the [`Buffer`] trait because the `fds` list is/// both an input and output buffer./// [`Buffer`]: crate::buffer::Buffer/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/poll.htmlassociate_fd/// it is removed via [`dissociate_fd`].dissociate_fd/// associated with the port via [`associate_fd`].getn/// `port_getn(port, events, min_events, timeout)`—Gets multiple events from/// If `events` is empty, this does nothing and returns immediately./// To query the number of events without retrieving any, use [`getn_query`].getn_query/// `port_getn(port, NULL, 0, NULL)`—Queries the number of events/// available from a port./// To retrieve the events, use [`getn`].//! # fn test() -> std::io::Result<()> {//! use rustix::event::port;//! use rustix::stdio::stdout;//! let some_fd = stdout();//! let some_userdata = 7 as *mut _;//! // Create a port.//! let port = port::create()?;//! // Associate `some_fd` with the port.//!     port::associate_fd(&port, some_fd, port::PollFlags::IN, some_userdata)?;//! // Get a single event.//! let event = port::get(&port, None)?;//! assert_eq!(event.userdata(), some_userdata);/// Storage element type for use with [`select`]./// `select(nfds, readfds, writefds, exceptfds, timeout)`—Wait for events on/// sets of file descriptors./// `readfds`, `writefds`, `exceptfds` must point to arrays of `FdSetElement`/// containing at least `nfds.div_ceil(size_of::<FdSetElement>())` elements./// This `select` wrapper differs from POSIX in that `nfds` is not limited to/// `FD_SETSIZE`. Instead of using the fixed-sized `fd_set` type, this function/// takes raw pointers to arrays of `fd_set_num_elements(max_fd + 1, num_fds)`,/// where `max_fd` is the maximum value of any fd that will be inserted into/// the set, and `num_fds` is the maximum number of fds that will be inserted/// into the set./// In particular, on Apple platforms, this function behaves as if/// `_DARWIN_UNLIMITED_SELECT` were predefined./// On illumos, this function is not defined because the `select` function on/// this platform always has an `FD_SETSIZE` limitation, following POSIX. This/// platform's documentation recommends using [`poll`] instead./// [`fd_set_insert`], [`fd_set_remove`], and [`FdSetIter`] are provided for/// setting, clearing, and iterating with sets./// [`poll`]: crate::event::poll()/// All fds in all the sets must correspond to open file descriptors./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/select.html/// [Linux]: https://man7.org/linux/man-pages/man2/select.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/select.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=select&sektion=2/// [NetBSD]: https://man.netbsd.org/select.2/// [OpenBSD]: https://man.openbsd.org/select.2/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=select&section=2/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-select/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Waiting-for-I_002fO.html#index-selectfd_set_insert/// Set `fd` in the set pointed to by `fds`.fd_set_remove/// Clear `fd` in the set pointed to by `fds`.fd_set_bound/// Compute the minimum `nfds` value needed for the set pointed to by `fds`.fd_set_num_elements/// Compute the number of `FdSetElement`s needed to hold a set which can/// contain up to `set_count` file descriptors with values less than `nfds`.fd_set_num_elements_for_bitvector/// `fd_set_num_elements` implementation on platforms with bitvectorFdSetIter/// An iterator over the fds in a set./// Construct a `FdSetIter` for the given set.//! The `select` function.//! `select` is unsafe due to I/O safety./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/chmod.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/stat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/lstat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/readlink.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/rename.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/unlink.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/rmdir.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/link.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/symlink.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mkdir.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/access.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/statvfs.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/chown.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/openat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/readlinkat.html/// This is the "raw" version which avoids allocating, but which truncates the/// string if it doesn't fit in the provided buffer, and doesn't NUL-terminate/// the string./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mkdirat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/linkat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/unlinkat.html/// See [`renameat_with`] to pass additional flags./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/renameat.html/// `renameat_with` is the same as [`renameat`] but adds an additional/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/symlinkat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fstatat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/faccessat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/utimensat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fchmodat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mknodat.html/// `mkfifoat(dirfd, path, mode)`—Make a FIFO special file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mkfifoat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fchownat.html//! directory, the special value [`CWD`], or the special value [`ABS`].//! [`CWD`]: crate::fs::CWD//! [`ABS`]: crate::fs::ABSis_file/// Returns `true` if this `FileType` is a regular file./// Returns `true` if this `FileType` is a directory./// Returns `true` if this `FileType` is a symlink.is_fifo/// Returns `true` if this `FileType` is a fifo.is_socket/// Returns `true` if this `FileType` is a socket.is_char_device/// Returns `true` if this `FileType` is a character device.is_block_device/// Returns `true` if this `FileType` is a block device.test_layouts/// If `len` is `None`, the advice extends to the end of the file./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_fadvise.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=posix_fadvise&sektion=2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fcntl.html/// `fcntl(fd, F_GET_SEALS)`—Return the seals for `fd`'s inode./// `fcntl(fd, F_ADD_SEALS)`—Add seals to `fd`'s inode./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/lseek.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fchmod.html/// [`OFlags::PATH`]: crate::fs::OFlags::PATH/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fchown.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fstat.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fstatvfs.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/futimens.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_fallocate.html// not implemented in libc for NetBSD yet/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fsync.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fdatasync.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/ftruncate.html/// [`inotify::add_watch`] and not previously have been removed./// An inotify event iterator implemented with the read syscall./// See the [`RawDir`] API for more details and usage examples as this API is/// based on it./// [`RawDir`]: crate::fs::raw_dir::RawDir/// An inotify event./// Returns the watch for which this event occurs./// Returns a description of the events./// Returns the unique cookie associating related events./// Returns the file name of this event, if any./// Read the next inotify event./// This is similar to [`Iterator::next`] except that it doesn't return an/// `Option`, because the stream doesn't have an ending. It always returns/// events or errors./// If there are no events in the buffer and none ready to be read:///  - If the file descriptor was opened with///    [`inotify::CreateFlags::NONBLOCK`], this will fail with///    [`Errno::AGAIN`].///  - Otherwise this will block until at least one event is ready or an///    error occurs./// calling [`next`]. This is useful to avoid further blocking reads.//! use rustix::fs::inotify;//! use rustix::io;//! use std::mem::MaybeUninit;//! # fn test() -> io::Result<()> {//! // Create an inotify object. In this example, we use `NONBLOCK` so that the//! // reader fails with `WOULDBLOCK` when no events are ready. Otherwise it//! // will block until at least one event is ready.//! let inotify = inotify::init(inotify::CreateFlags::NONBLOCK)?;//! // Add a directory to watch.//! inotify::add_watch(//!     &inotify,//!     "/path/to/some/directory/to/watch",//!     inotify::WatchFlags::ALL_EVENTS,//! // Generate some events in the watched directory…//! // Loop over pending events.//! let mut buf = [MaybeUninit::uninit(); 512];//! let mut iter = inotify::Reader::new(inotify, &mut buf);//!     let entry = match iter.next() {//!         // Stop iterating if there are no more events for now.//!         Err(io::Errno::WOULDBLOCK) => break,//!         Err(e) => return Err(e),//!         Ok(entry) => entry,//!     // Use `entry`…/// This ioctl is not available on SPARC platforms.r" `FS_*` constants for use with [`ioctl_getflags`]."r" [`ioctl_getflags`]: crate::fs::ioctl::ioctl_getflags"/// `makedev(maj, min)`—Compute a device ID from a given major and minor ID./// `minor(dev)`—Compute the minor ID of a given device ID./// `major(dev)`—Compute the major ID of a given device ID./// `memfd_create(name, flags)`—Create an anonymous file./// For a higher-level API to this functionality, see the [memfd] crate./// [memfd]: https://crates.io/crates/memfd/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Memory_002dmapped-I_002fO.html#index-memfd_005fcreate/// `openat2(dirfd, path, OpenHow { oflags, mode, resolve }, sizeof(OpenHow))`—/// Opens a file with more options./// # // The `ignore` above can be removed when we can depend on Rust 1.65./// `sendfile(out_fd, in_fd, offset, count)`—Transfer data between file/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/fcntl.h.htmlABS/// `-EBADF`—A handle that requires paths to be absolute./// This is a file descriptor which refers to no directory, which can be used/// as the directory argument in `*at` functions such as [`openat`], which/// causes them to fail with [`BADF`] if the accompanying path is not absolute./// This corresponds to the undocumented by commonly used convention of/// passing `-EBADF` as the `dirfd` argument, which is ignored if the path is/// absolute, and evokes an `EBADF` error otherwise./// [`BADF`]: crate::io::Errno::BADF// SAFETY: This `-EBADF` convention is commonly used, such as in lxc, so OS's// aren't going to break it.test_cwdtest_abs//! The `CWD` and `ABS` constants, representing the current working directory//! and absolute-only paths, respectively.//! always valid, and `-EBADF`, which is an undocumented by commonly used//! convention of passing a value which will always fail if the accompanying//! path isn't absolute.StatxAttributesr" `STATX_ATTR_*` flags for use with [`Statx`]."r" `STATX_ATTR_COMPRESSED`"r" `STATX_ATTR_IMMUTABLE`"r" `STATX_ATTR_APPEND`"r" `STATX_ATTR_NODUMP`"r" `STATX_ATTR_ENCRYPTED`"ENCRYPTEDr" `STATX_ATTR_AUTOMOUNT`"AUTOMOUNTr" `STATX_ATTR_MOUNT_ROOT`"MOUNT_ROOTr" `STATX_ATTR_VERITY`"VERITYr" `STATX_ATTR_DAX`"DAX/// `statx(dirfd, path, flags, mask, statxbuf)`—Extended `stat`./// /// [`StatxAttributes::MOUNT_ROOT`].///     use rustix::fs::{AtFlags, StatxAttributes, StatxFlags};///             let present = r.stx_attributes_mask.contains(StatxAttributes::MOUNT_ROOT);///             Ok(present.then(|| r.stx_attributes.contains(StatxAttributes::MOUNT_ROOT)))///         Err(rustix::io::Errno::NOSYS) => Ok(None),/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sync.html/// `getxattr(path, name, value)`—Get extended filesystem attributes./// For a higher-level API to xattr functionality, see the [xattr] crate./// [xattr]: https://crates.io/crates/xattr/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getxattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fgetxattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setxattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fsetxattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/listxattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/flistxattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/removexattr.2.html/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fremovexattr.2.html//! Extended attribute functions./// Most users won't need to use this, as [`OwnedFd`] automatically closes its/// [`OwnedFd`]: crate::fd::OwnedFd/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/close.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Opening-and-Closing-Files.html#index-close/// [file description]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap03.html#tag_03_258/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/dup.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Duplicating-Descriptors.html/// support it, or [`fcntl_dupfd_cloexec`]./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/dup2.html/// [`stdio::dup2_stdin`]: crate::stdio::dup2_stdin/// [`stdio::dup2_stdout`]: crate::stdio::dup2_stdout/// [`stdio::dup2_stderr`]: crate::stdio::dup2_stderr/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Control-Operations.html#index-fcntl-function/// `ioctl(fd, FIOCLEX, NULL)`—Set the close-on-exec flag./// This is similar to `fcntl(fd, F_SETFD, FD_CLOEXEC)`, except that it avoids/// clearing any other flags that might be set./// Linux: Note that `ioctl` can not be used on `OFlags::PATH` fileioctl_fionclex/// `ioctl(fd, FIONCLEX, NULL)`—Remove the close-on-exec flag./// This is similar to `fcntl_setfd(fd, FdFlags::empty())`, except that it avoids//! If you're looking for [`SeekFrom`], it's in the [`fs`] module.//! [`SeekFrom`]: crate::fs::SeekFrom//! [`fs`]: crate::fs/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/read.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/I_002fO-Primitives.html#index-reading-from-a-file-descriptor/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/write.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/I_002fO-Primitives.html#index-writing-to-a-file-descriptor/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/pread.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/I_002fO-Primitives.html#index-pread64/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/pwrite.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/I_002fO-Primitives.html#index-pwrite64/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/readv.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Scatter_002dGather.html#index-readv/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/writev.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Scatter_002dGather.html#index-writev/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Scatter_002dGather.html#index-preadv64/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Scatter_002dGather.html#index-preadv64v2/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Scatter_002dGather.html#index-pwritev64v2//! `read` and `write`, optionally positioned, optionally vectored.IncompleteArrayField/// This represents an incomplete array field at the end of a struct./// This is called `__IncompleteArrayField` in bindgen bindings.UnionField/// This represents a toplevel union field./// This is called `__BindgenUnionField` in bindgen bindings.//! Local versions of types that bindgen would use.bindgen_typeskernel_sigsetSocketAddrOpaqueFutexWaitWaitFlagsFutexWaitFlagsWaitPtrFutexWaitPtrFutexWaitvFlags/// `msghdr`/// If [`IoringSetupFlags::ATTACH_WQ`] is set, the `wq_fd` field of/// `io_uring_params` must be an open file descriptor./// [Linux]: https://www.man7.org/linux/man-pages/man2/io_uring_setup.2.html/// To pass flags, use [`io_uring_register_with`]./// [Linux]: https://www.man7.org/linux/man-pages/man2/io_uring_register.2.html/// `io_uring_register_with(fd, opcode, flags, arg, nr_args)`—Register files or/// user buffers for asynchronous I/O./// `io_uring_enter(fd, to_submit, min_complete, flags, 0, 0)`—Initiate/// This version has no `arg` argument. To pass:///  - a signal mask, use [`io_uring_enter_sigmask`].///  - an [`io_uring_getevents_arg`], use [`io_uring_enter_arg`] (aka///    `io_uring_enter2`)./// And, `flags` must not have [`IoringEnterFlags::EXT_ARG`] or/// [`IoringEnterFlags::EXT_ARG_REG`] set./// [Linux]: https://www.man7.org/linux/man-pages/man2/io_uring_enter.2.htmlio_uring_enter_sigmask/// `io_uring_enter(fd, to_submit, min_complete, flags, sigmask,/// sizeof(*sigmask))`— Initiate and/or complete asynchronous I/O, with a/// signal mask./// And, the `KernelSigSet` referred to by `arg` must not contain any signal/// numbers reserved by libc.io_uring_enter_arg/// `io_uring_enter2(fd, to_submit, min_complete, flags, arg, sizeof(*arg))`—/// Initiate and/or complete asynchronous I/O, with a signal mask and a/// And, `flags` must have [`IoringEnterFlags::EXT_ARG`] set, and must not have/// And, the `KernelSigSet` pointed to by the `io_uring_getenvets_arg` referred/// to by `arg` must not contain any signal numbers reserved by libc.RegisterPbufStatus/// `IORING_REGISTER_PBUF_STATUS` (since Linux 6.8)RegisterNapi/// `IORING_REGISTER_NAPI` (since Linux 6.9)UnregisterNapi/// `IORING_UNREGISTER_NAPI` (since Linux 6.9)RegisterClock/// `IORING_REGISTER_CLOCK` (since Linux 6.12)RegisterCloneBuffers/// `IORING_REGISTER_CLONE_BUFFERS ` (since Linux 6.12)RegisterSendMsgRing/// `IORING_REGISTER_SEND_MSG_RING` (since Linux 6.12)RegisterResizeRings/// `IORING_REGISTER_RESIZE_RINGS`(since Linux 6.13)ReadMultishot/// `IORING_OP_READ_MULTISHOT` (since Linux 6.7)Waitid/// `IORING_OP_WAITID` (since Linux 6.5)/// `IORING_OP_FUTEX_WAIT` (since Linux 6.7)FutexWake/// `IORING_OP_FUTEX_WAKE` (since Linux 6.7)FutexWaitv/// `IORING_OP_FUTEX_WAITV` (since Linux 6.7)FixedFdInstall/// `IORING_OP_FIXED_FD_INSTALL` (since Linux 6.8)Ftruncate/// `IORING_OP_FTRUNCATE` (since Linux 6.9)/// `IORING_OP_BIND` (since Linux 6.11)/// `IORING_OP_LISTEN` (since Linux 6.11)// SAFETY: `IORING_REGISTER_FILES_SKIP` is a reserved value that is never// dynamically allocated, so it'll remain valid for the duration of// `'static`./// Construct a null `io_uring_ptr`./// Construct a new `io_uring_ptr`./// Create a zero-initialized `Self`.splice_fd_in_or_file_index_or_addr_lensplice_fd_in_or_file_index_or_addr_len_unionIoringUringCmdFlagsIoringFixedFdFlagsbuf_ring_tail_structbuf_ring_bufs_structunion_fieldtail_or_bufs_structtail_or_bufstest_io_uring_register_files_skip//! [Linux]: https://www.man7.org/linux/man-pages/man7/io_uring.7.html//! [io_uring header]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/io_uring.h?h=v6.13// TODO: Uncomment this when we support `IoringRegisterOp::CQWAIT_REG`./*
/// `io_uring_enter2(fd, to_submit, min_complete, flags, offset,
/// sizeof(io_uring_reg_wait))`— Initiate and/or complete asynchronous I/O,
/// using a previously registered `io_uring_reg_wait`.
///
/// `offset` is an offset into an area of wait regions previously registered
/// with [`io_uring_register`] using the [`IoringRegisterOp::CQWAIT_REG`]
/// operation.
///
/// # Safety
///
/// io_uring operates on raw pointers and raw file descriptors. Users are
/// responsible for ensuring that memory and resources are only accessed in
/// valid ways.
///
/// And, `flags` must have [`IoringEnterFlags::EXT_ARG_REG`] set, and must not
/// have [`IoringEnterFlags::EXT_ARG`] set.
///
/// # References
///  - [Linux]
///
/// [Linux]: https://www.man7.org/linux/man-pages/man2/io_uring_enter.2.html
#[doc(alias = "io_uring_enter")]
#[doc(alias = "io_uring_enter2")]
#[inline]
pub unsafe fn io_uring_enter_reg_wait<Fd: AsFd>(
    fd: Fd,
    to_submit: u32,
    min_complete: u32,
    flags: IoringEnterFlags,
    reg_wait: usize,
) -> io::Result<u32> {
    debug_assert!(!flags.contains(IoringEnterFlags::EXT_ARG));
    debug_assert!(flags.contains(IoringEnterFlags::EXT_ARG_REG));

    backend::io_uring::syscalls::io_uring_enter(
        fd.as_fd(),
        to_submit,
        min_complete,
        flags,
        reg_wait as *mut c_void,
        size_of::<io_uring_reg_wait>(),
    )
}
*/// `IOC_OUT` (“out” is from the perspective of the kernel)// `IOC_IN` (“in” is from the perspective of the kernel)/// While [`Ioctl`] takes much of the unsafety out of `ioctl` calls, callers/// must still ensure that the opcode value, operand type, and data access/// correctly reflect what's in the device driver servicing the call. `ioctl`/// calls form a protocol between the userspace `ioctl` callers and the device/// drivers in the kernel, and safety depends on both sides agreeing and/// upholding the expectations of the other./// And, `ioctl` calls can read and write arbitrary memory and have arbitrary/// side effects. Callers must ensure that any memory accesses and side effects/// are compatible with Rust language invariants./// Get the opcode used by this `ioctl` command./// documentation for [`opcode`] for more information.///  - The `ioctl` call expects the input provided by `as_ptr` and produces the///    output as indicated by `output`.///  - That `output_from_ptr` can safely take the pointer from `as_ptr` and///    cast it to the correct type, *only* after the `ioctl` call.///  - That the return value of `opcode` uniquely identifies the `ioctl` call.///  - That, for whatever platforms you are targeting, the `ioctl` call is safe///    to make.///  - If `IS_MUTATING` is false, that no userspace data will be modified by///    the `ioctl` call./// Create a new opcode from a group, a number, that uses no data./// This corresponds to the C macro `_IO(group, number)`./// Const functions for computing opcode values./// Linux's headers define macros such as `_IO`, `_IOR`, `_IOW`, and `_IOWR`/// for defining ioctl values in a structured way that encode whether they/// are reading and/or writing, and other information about the ioctl. The/// functions in this module correspond to those macros./// If you're writing a driver and defining your own ioctl numbers, it's/// recommended to use these functions to compute them./// The direction is relative to userspace: `Read` means reading data from the/// kernel, and `Write` means the kernel writing data to userspace._Opcodetest_opcode_funcs/// To compute a value for the `OPCODE` argument, see the functions in the/// [`opcode`] module./// [`opcode`]: crate::ioctl::opcode///  - `OPCODE` must provide a valid opcode./// pattern, this structure implements it.///  - For this opcode, `Output` must be the type that the kernel expects///    to write into.///  - For this opcode, `Input` must be the type that the kernel expects to///    get.///  - For this opcode, `Value` must be the type that the kernel expects to/// The value to pass in./// For strict provenance preservation, this is a pointer.IntegerSetter/// Implements an `ioctl` that passes an integer into the `ioctl`.new_usize/// Create a new integer `Ioctl` helper containing a `usize`.///  - For this opcode, it must expect an integer.///  - The integer is in the valid range for this opcode.new_pointer/// Create a new integer `Ioctl` helper containing a `*mut c_void`./// `kernel_sigset_t`—A set of signal numbers, as used by some syscalls./// This is similar to `libc::sigset_t`, but with only enough space for the/// signals currently known to be used by the kernel. libc implementations/// reserve extra space so that if Linux defines new signals in the future/// they can add support without breaking their dynamic linking ABI. Rustix/// doesn't support a dynamic linking ABI, so if we need to increase the/// size of `KernelSigSet` in the future, we can do so./// It's also the case that the last time Linux changed the size of its/// `kernel_sigset_t` was when it added support for POSIX.1b signals in 1999./// `KernelSigSet` is guaranteed to have a subset of the layout of/// `libc::sigset_t`./// libc implementations typically also reserve some signal values for internal/// use. In a process that contains a libc, some unsafe functions invoke/// undefined behavior if passed a `KernelSigSet` that contains one of the/// signals that the libc reserves./// Create a new empty `KernelSigSet`./// Create a new `KernelSigSet` with all signals set./// This includes signals which are typically reserved for libc./// Remove all signals./// Insert a signal./// Insert all signals./// Remove a signal./// Test whether a given signal is present.KERNEL_SIGRTMAXKERNEL_SIGRTMINtest_assumptionssigs/// A bunch of signals for testing.libc_sigs/// A bunch of non-reserved signals for testing.test_ops_plaintest_libc_layout_compatibility// io_uring libraries assume that libc's `sigset_t` matches the layout// of the Linux kernel's `kernel_sigset_t`. Test that rustix's layout// matches as well.//! The [`KernelSigSet`] type./// This module exports the types and traits from [`std::os::fd`], or polyills/// on Rust < 1.66 or on Windows./// On Windows, the polyfill consists of aliases of the socket types and/// traits, For example, [`OwnedSocket`] is aliased to `OwnedFd`, and so on,/// and there are blanket impls for `AsFd` etc. that map to `AsSocket` impls./// These blanket impls suffice for using the traits, however not for/// implementing them, so this module also exports `AsSocket` and the other/// traits as-is so that users can implement them if needed./// [`OwnedSocket`]: https://doc.rust-lang.org/stable/std/os/windows/io/struct.OwnedSocket.html//! let (nread, _received) = rustix::net::recv(&sock, buf, RecvFlags::PEEK)?;//! let nread = unsafe {//!  - Use `timespec` for timestamps and timeouts instead of `timeval` and//!    `c_int` milliseconds.//! [`bitflags`]: bitflags//! [`AsFd`]: crate::fd::AsFd//! [`OwnedFd`]: crate::fd::OwnedFd//! [`Arg`]: path::Arg//! [support for externally defined flags]: bitflags#externally-defined-flags// This clippy lint gets too many false positives.// Until `unnecessary_transmutes` is recognized by our MSRV, don't warn about// it being unrecognized.// Until `cast_signed` and `cast_unsigned` are supported by our MSRV, don't// warn about transmutes that could be changed to them.// wasip2 conditionally gates stdlib APIs such as `OsStrExt`.// <https://github.com/rust-lang/rust/issues/130323>/// This type does not have a [`ToOwned`][crate::borrow::ToOwned]/// implementation. Calling `.to_owned()` on a variable of this type will call/// it on `&BorrowedFd` and use `Clone::clone()` like `ToOwned` does for all/// types implementing `Clone`. The result will be descriptor borrowed under/// the same lifetime./// To obtain an [`OwnedFd`], you can use [`BorrowedFd::try_clone_to_owned`]/// instead, but this is not supported on all platforms./// You can use [`AsFd::as_fd`] to obtain a [`BorrowedFd`]./// Returns a `BorrowedFd` holding the given raw file descriptor.///   - be an [owned socket][io-safety]; in particular, it must be open./// Returns a `BorrowedSocket` holding the given raw socket.// Change to use `std::os::fd` when MSRV becomes Rust 1.66 or higher./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_madvise.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Memory_002dmapped-I_002fO.html#index-madvise/// If `ptr` is not null, it must be aligned to the applicable page size, and/// the range of memory starting at `ptr` and extending for `len` bytes,/// rounded up to the applicable page size, must be valid to mutate using/// `ptr`'s provenance./// If there exist any Rust references referring to the memory region, or if/// you subsequently create a Rust reference referring to the resulting region,/// it is your responsibility to ensure that the Rust reference invariants are/// preserved, including ensuring that the memory is not mutated in a way that/// a Rust reference would not expect./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mmap.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Memory_002dmapped-I_002fO.html#index-mmap/// rounded up to the applicable page size, must be valid to mutate with/// `ptr` must be aligned to the applicable page size, and the range of memory/// starting at `ptr` and extending for `len` bytes, rounded up to the/// applicable page size, must be valid to mutate with `ptr`'s provenance. And/// there must be no Rust references referring to that memory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/munmap.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Memory_002dmapped-I_002fO.html#index-munmap/// `old_address` must be aligned to the applicable page size, and the range of/// memory starting at `old_address` and extending for `old_size` bytes,/// `old_address`'s provenance. If `MremapFlags::MAY_MOVE` is set in `flags`,/// there must be no Rust references referring to that the memory./// If `new_size` is less than `old_size`, than there must be no Rust/// references referring to the memory starting at offset `new_size` and ending/// at `old_size`./// `old_address` and `new_address` must be aligned to the applicable page/// size, the range of memory starting at `old_address` and extending for/// `old_size` bytes, rounded up to the applicable page size, must be valid to/// mutate with `old_address`'s provenance, and the range of memory starting at/// `new_address` and extending for `new_size` bytes, rounded up to the/// applicable page size, must be valid to mutate with `new_address`'s/// provenance./// There must be no Rust references referring to either of those memory/// regions./// The range of memory starting at `ptr` and extending for `len` bytes,/// rounded up to the applicable page size, must be valid to read with `ptr`'s/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mprotect.html/// See [`mlock_with`] to pass additional flags./// The range of memory starting at `ptr`, rounded down to the applicable page/// boundary, and extending for `len` bytes, rounded up to the applicable page/// size, must be valid to read with `ptr`'s provenance./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mlock.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Page-Lock-Functions.html#index-mlock/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Page-Lock-Functions.html#index-mlock2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/munlock.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Page-Lock-Functions.html#index-munlock/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mlockall.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Page-Lock-Functions.html#index-mlockall/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/munlockall.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Page-Lock-Functions.html#index-munlockall/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/msync.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Memory_002dmapped-I_002fO.html#index-msync/// `userfaultfd(flags)`—Create userspace page-fault handler.AuxFdfsconfig_create_exclusive/// `fsconfig(fs_fd, FSCONFIG_CMD_CREATE_EXCL, key, NULL, 0)`/// This function was added in Linux 6.6.mount_bind_recursive/// Opaque type equivalent to `sockaddr` in C./// This is always used behind a raw pointer that is cast from a pointer to a/// `sockaddr`-compatible C type, and then cast back to a `sockaddr` pointer to/// be passed to a system call./// A type for the length of a socket address./// This type will always be big enough to hold any socket address, but never/// bigger than `usize`.with_sockaddr/// Call a closure with the pointer and length to the corresponding C type./// The memory pointed to by the pointer of size length is guaranteed to be/// valid only for the duration of the call./// The API uses a closure so that:///  - The libc types are not exposed in the rustix API.///  - Types like `SocketAddrUnix` that contain their corresponding C type///    can pass it directly without a copy.///  - Other socket types can construct their C-compatible struct on the///    stack and call the closure with a pointer to it./// For `f` to use its pointer argument, it'll contain an `unsafe` block./// The caller of `with_sockaddr` here is responsible for ensuring that the/// safety condition for that `unsafe` block is satisfied by the guarantee/// that `with_sockaddr` here provides./// Convert to `SocketAddrAny`./// Encode an address into a `SocketAddrStorage`./// Returns the number of bytes that were written./// For a safe interface to this functionality, use [`as_any`]./// [`as_any`]: Self::as_any/// `storage` must be valid to write up to `size_of<SocketAddrStorage>()`/// bytes to./// A trait abstracting over the types that can be passed as a `sockaddr`./// Implementers of this trait must ensure that `with_sockaddr` calls `f` with/// a pointer that is readable for the passed length, and points to data that/// is a valid socket address for the system calls that accept `sockaddr` as a/// const pointer.call_with_sockaddr/// Helper for implementing `SocketAddrArg::with_sockaddr`./// This calls `f` with a pointer to an object it has a reference to, with the/// and the length of that object, so they'll be valid for the duration of the// SAFETY: This just forwards to the inner `SocketAddrArg` implementations.// SAFETY: `with_sockaddr` calls `f` using `call_with_sockaddr`, which handles// calling `f` with the needed preconditions.//! Types for implementers of socket address types or code that is generic over//! address types.//! The concrete address types and [`SocketAddrAny`] are in//! [the parent module][`super`]./// See also [`index_to_name_inlined`] which does not require `alloc` feature.index_to_name_inlinedInlinedName/// The inlined interface name./// Returns the str representation of the inlined name./// Returns the bytes representation of the inlined name.test_index_to_name_inlined//!  - glibc uses an `AF_UNIX`, `AF_INET`, or `AF_INET6` socket. The address//!    family itself does not matter and glibc tries the next address family if//!    socket creation with one fails.//!  - Android (bionic) uses an `AF_INET` socket.//!  - Both create the socket with `SOCK_DGRAM|SOCK_CLOEXEC` type/flag.//!  - The [manual pages] specify that the ioctl calls “can be used on any//!    socket's file descriptor regardless of the family or type”.//! [manual pages]: https://man7.org/linux/man-pages/man7/netdevice.7.html/// In addition to the `Buffer::Output` return value, this also returns the/// number of bytes received before any truncation due to the/// [`RecvFlags::TRUNC`] flag./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/recv.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Receiving-Data.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/send.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Sending-Data.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/recvfrom.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Receiving-Datagrams.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sendto.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Sending-Datagrams.html/// let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];/// # let _: &[MaybeUninit<u8>] = space.as_slice();/// let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmCredentials(1))];/// let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(2), ScmCredentials(1))];/// Helper function for [`cmsg_space`]./// Helper function for [`cmsg_aligned_space`]./// Transmission time, in nanoseconds. The value will be interpreted by/// whichever clock was configured on the socket with [`set_txtime`]./// [`set_txtime`]: crate::net::sockopt::set_txtime/// Ancillary message for [`sendmsg`] and [`sendmsg_addr`]./// This can be used to determine the size of the buffer to allocate for a/// [`SendAncillaryBuffer::new`] with one message./// Buffer for sending ancillary messages with [`sendmsg`] and/// [`sendmsg_addr`]./// An ABI-compatible wrapper for `mmsghdr`, for sending multiple messages with/// [sendmmsg]./// Constructs a new message with no destination address.new_with_addr/// Constructs a new message to a specific address./// This requires a `SocketAddrAny` instead of using `impl SocketAddrArg`;/// to obtain a `SocketAddrAny`, use [`SocketAddrArg::as_any`]./// Returns the number of bytes sent. This will return 0 until after a/// successful call to [sendmmsg]./// This function is for use on connected sockets, as it doesn't have a way to/// specify an address. See [`sendmsg_addr`] to send messages on unconnected/// sockets./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sendmsg.html/// `sendmmsg(msghdr)`—Sends multiple messages on a socket./// [Linux]: https://man7.org/linux/man-pages/man2/sendmmsg.2.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/recvmsg.html/// When `RecvFlags::TRUNC` is in use, this may be greater than the length/// of the buffer, as it reflects the number of bytes received before/// truncation into the buffer.AllowedMsgBufType/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/socket.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Creating-a-Socket.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/bind.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Setting-Address.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/connect.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Connecting.html/// `connect(sockfd, {.sa_family = AF_UNSPEC}, sizeof(struct sockaddr))`—/// Dissolve the socket's association./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/listen.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Listening.html/// See [`accept_with`] to pass additional flags./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/accept.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Accepting-Connections.html/// See [`acceptfrom_with`] to pass additional flags./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/shutdown.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Closing-a-Socket.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getsockname.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Reading-Address.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getpeername.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Who-is-Connected.html/// Temporary buffer for creating a `SocketAddrAny` from a syscall that writes/// to a `sockaddr_t` and `socklen_t`/// Unlike `SocketAddrAny`, this does not maintain the invariant that `len`/// bytes are initialized./// Convert the buffer into [`SocketAddrAny`]./// A valid address must have been written into `self.storage` and its/// length written into `self.len`.into_any_option/// Convert the buffer into [`Option<SocketAddrAny>`]./// This returns `None` if `len` is zero or other platform-specific/// conditions define the address as empty./// Either valid address must have been written into `self.storage` and its/// length written into `self.len`, or `self.len` must have been set to 0.//  - `len` is at least `size_of::<backend::c::sa_family_t>()`//  - `len` is at most `size_of::<SocketAddrStorage>()`//  - The first `len` bytes of `storage` are initialized./// A type that can hold any kind of socket address, as a safe abstraction for/// `sockaddr_storage`./// Socket addresses can be converted to `SocketAddrAny` via the [`From`] and/// [`Into`] traits. `SocketAddrAny` can be converted back to a specific socket/// address type with [`TryFrom`] and [`TryInto`]. These implementations return/// [`Errno::AFNOSUPPORT`] if the address family does not match the requested/// Creates a socket address from `storage`, which is initialized for `len`/// if `len` is smaller than the sockaddr header or larger than/// `SocketAddrStorage`.///  - `storage` must contain a valid socket address.///  - `len` bytes must be initialized./// Creates a socket address from reading from `ptr`, which points at `len`/// initialized bytes.///  - `ptr` must be a pointer to memory containing a valid socket address./// Gets the initialized part of the storage as bytes./// Gets the address family of this socket address./// Returns a raw pointer to the sockaddr./// Returns a raw mutable pointer to the sockaddr./// Returns the length of the encoded sockaddr.// This just forwards to another `partial_cmp`.// SAFETY: `with_sockaddr` calls `f` with a pointer to its own storage./// Convert if the address is an IPv4 or IPv6 address./// Returns `Err(Errno::AFNOSUPPORT)` if the address family is not IPv4 or/// Convert if the address is an IPv4 address./// Returns `Err(Errno::AFNOSUPPORT)` if the address family is not IPv4./// Convert if the address is an IPv6 address./// Returns `Err(Errno::AFNOSUPPORT)` if the address family is not IPv6./// Convert if the address is a Unix socket address./// Returns `Err(Errno::AFNOSUPPORT)` if the address family is not Unix.any_read//! The [`SocketAddrAny`] type and related utilities./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/socketpair.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Socket-Pairs.html/// [`socket_timeout`].RawIpv4PathMtuDiscovery/// A type for holding raw integer IPv4 Path MTU Discovery options./// IPv4 Path MTU Discovery option values (`IP_PMTUDISC_*`) for use with/// [`set_ip_mtu_discover`] and [`ip_mtu_discover`]./// - [Linux INET header]/// [Linux INET header]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/in.h?h=v6.14#n135DONT/// `IP_PMTUDISC_DONT`WANT/// `IP_PMTUDISC_WANT`DO/// `IP_PMTUDISC_DO`PROBE/// `IP_PMTUDISC_PROBE`/// `IP_PMTUDISC_INTERFACE`OMIT/// `IP_PMTUDISC_OMIT`/// Constructs an option from a raw integer./// Returns the raw integer for this option.RawIpv6PathMtuDiscovery/// A type for holding raw integer IPv6 Path MTU Discovery options./// IPv6 Path MTU Discovery option values (`IPV6_PMTUDISC_*`) for use with/// [`set_ipv6_mtu_discover`] and [`ipv6_mtu_discover`]./// - [Linux INET6 header]/// [Linux INET6 header]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/in6.h?h=v6.14#n185/// `IPV6_PMTUDISC_DONT`/// `IPV6_PMTUDISC_WANT`/// `IPV6_PMTUDISC_DO`/// `IPV6_PMTUDISC_PROBE`/// `IPV6_PMTUDISC_INTERFACE`/// `IPV6_PMTUDISC_OMIT`/// `setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, value)`/// `setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, value)`/// `getsockopt(fd, IPPROTO_IP, IP_MTU)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_MTU)`/// `setsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER, value)`/// `getsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_MTU_DISCOVER, value)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_MTU_DISCOVER)`/// `setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, value)`/// `setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, multiaddr, address,/// This is similar to [`set_ip_multicast_if`] but additionally allows an/// `ifindex` value to be given./// `getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF)`/// `setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, value)`/// `getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF)`/// This is similar to [`set_ip_add_membership`] but always sets the `ifindex`/// value to zero. See [`set_ip_add_membership_with_ifindex`] instead to also/// give the `ifindex` value./// This is similar to [`set_ip_add_membership`] but additionally allows an/// Even though this corresponds to a `SO_*` constant, it is an `IPPROTO_IP`/// Even though this corresponds to a `IP6T_*` constant, it is an/// `getsockopt(fd, SOL_SOCKET, SO_PEERCRED)`—Get credentials of Unix domain/// socket peer process.//! # References for all getter functions://! [POSIX `getsockopt`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getsockopt.html//! [glibc `getsockopt`]: https://sourceware.org/glibc/manual/latest/html_node/Socket-Option-Functions.html//! [POSIX `setsockopt`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setsockopt.html//! [glibc `setsockopt`]: https://sourceware.org/glibc/manual/latest/html_node/Socket-Option-Functions.html//!  - [References for all getter functions]//! [POSIX `sys/socket.h`]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/sys_socket.h.html//! [glibc `SOL_SOCKET` options]: https://sourceware.org/glibc/manual/latest/html_node/Socket_002dLevel-Options.html//! [POSIX `netinet/in.h`]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/netinet_in.h.html//! [Apple `ip`]: https://github.com/apple-oss-distributions/xnu/blob/main/bsd/man/man4/ip.4//! [Apple `ip6`]: https://github.com/apple-oss-distributions/xnu/blob/main/bsd/man/man4/ip6.4//! [POSIX `netinet/tcp.h`]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/netinet_tcp.h.html//! [Apple `tcp`]: https://github.com/apple-oss-distributions/xnu/blob/main/bsd/man/man4/tcp.4//! [References for all getter functions]: #references-for-all-getter-functionsVSOCK/// `AF_VSOCK`/// and [`socketpair`] when a nondefault value is desired./// See the [`ipproto`], [`sysproto`], and [`netlink`] modules for possible// `NETLINK_GENERIC` to be the default when Linux has `NETLINK_ROUTE` as// the default./// Port ID/// Multicast groups mask/// A Netlink socket address./// Used to bind to a Netlink socket./// Not ABI compatible with `struct sockaddr_nl`/// Construct a netlink address/// Return port id.set_pid/// Set port id./// Return multicast groups mask.set_groups/// Set multicast groups mask.// SAFETY: `with_sockaddr` calls `f` using `call_with_sockaddr`, which// handles calling `f` with the needed preconditions.r" `XDP_*` constants for use in [`SocketAddrXdp`]."// Constant needs to be cast because bindgen does generate a `u32` but the// struct expects a `u16`.// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n15>/// Not ABI compatible with `struct sockaddr_xdp`./// To add a shared UMEM file descriptor, use/// [`SocketAddrXdpWithSharedUmem`].// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n48>/// XDP address.SocketAddrXdpWithSharedUmem/// An XDP socket address with a shared UMEM file descriptor./// This implements `SocketAddrArg` so that it can be passed to [`bind`]./// [`bind`]: crate::net::bind// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n59>// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n66>/// `AF_XDP` TX metadata length/// Requires kernel version 6.8.// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n79>// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n92>// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n101>// <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_xdp.h?h=v6.13#n154>/// [`get_socket_peercred`]: crate::net::sockopt::socket_peercrednot_implementedmemory_allocation/// Memory-allocation functions are out of scope for rustix./// It is possible to implement `malloc`, `free`, and similar functions in/// Rust, however rustix itself is focused on syscall-like functions. This/// module contains an incomplete list of such functions./// There are several allocator implementations for Rust; one of them is/// [dlmalloc]. For a rustix-based implementation, see [rustix-dlmalloc]./// Another allocator implementation is [talc]./// [dlmalloc]: https://crates.io/crates/dlmalloc/// [talc]: https://crates.io/crates/talc/// [rustix-dlmalloc]: https://crates.io/crates/rustix-dlmalloclibc_internals/// Functions which need access to libc internals are out of scope for rustix./// Most Rust programs have a libc present, and when a libc is present, it/// expects to be the only thing in the process that can do certain operations./// For example, there can be only one `atexit` list in a process, only one/// `pthread_atfork` list in a process, only one implementation of pthreads in/// a process, and so on, and libc expects to own the one of each of those/// things. And libc implementations may expect to be involved in signal/// handling. So, these functions are believed to be out of scope for rustix./// This module contains an incomplete list of such functions./// It would be possible to make a rust library which provides safe or/// ergonomic wrappers around these libc functions, however that is out of/// scope for rustix itself./// If you would like to write a Rust program which does not use a libc, and/// which does provide APIs for some of these functions, [Eyra] and [origin]/// are two libraries which may be useful, and which provide public interfaces/// for some of this functionality./// If you are otherwise writing Rust code which you know will not share a/// process with a libc, perhaps because you are writing a libc or similar/// yourself, rustix's codebase does include experimental implementations of/// the primitives needed to implement most of these functions./// [Eyra]: https://github.com/sunfishcode/eyra?tab=readme-ov-file#eyra/// [origin]: https://github.com/sunfishcode/origin?tab=readme-ov-file#origin/// See [rustix-openpty](https://crates.io/crates/rustix-openpty)./// See [`std::io::IsTerminal`]./// For Rust < 1.70, see [is-terminal]. For a rustix-based implementation,/// see [rustix-is-terminal]./// [`std::io::IsTerminal`]: std::io::IsTerminal/// [is-terminal]: https://crates.io/crates/is-terminal/// [rustix-is-terminal]: https://crates.io/crates/rustix-is-terminalhigher_level/// Functions which provide higher-level functionality are out of scope for/// rustix./// These functions are provided by typical libc implementations, but are/// higher-level than the simple syscall-like functions that rustix focuses on./// They could be implemented as a separate library built on top of rustix,/// rather than being part of rustix itself. This module contains an incomplete/// list of such functions./// Functions which don't seem possible to even call from Rust with current/// language features, even with `unsafe`.yet/// These functions are not yet implemented in rustix, but probably could be./// These are functions that users have asked about, and which probably are in/// scope for rustix, but are not yet implemented. This module contains an/// incomplete list of such functions./// For now, use `rustix::process::uname().nodename()` instead./// See also the [module comment](self).quite_yet/// These functions are not quite yet finished in rustix./// Rustix's codebase includes experimental implementations of these functions,/// however they are not yet publicly exposed because their API might need more/// work and/or they don't yet have a libc backend implementation yet./// See [#1314] for more information, and please leave comments if there are/// specific functions you're interested in./// [#1314]: https://github.com/bytecodealliance/rustix/issues/1314//! Documentation about unimplemented functions.//! This module contains documentation for several functions that rustix does//! not implement, either because they are out of scope, or because they are//! could probably be implemented but are not yet./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sysconf.html/// set up by the OS at process startup, and it must be called before any other/// rustix functions are called.//! NUL-termination without the need for copying or dynamic allocation where//! possible./// Enough to hold an {u,i}64 and NUL terminator.U64_MAX_STR_LEN/// Maximum length of a formatted [`u64`].I64_MAX_STR_LEN/// Maximum length of a formatted [`i64`].as_unsignedeq_zerodiv_mod_10impl_unsignedimpl_signed/// An integer that can be used by [`DecInt::new`]./// Return the raw byte buffer including the NUL byte.dec_int/// On Linux, `Pid` values are also used to identify threads./// Returns `Some` for positive values, and `None` for zero values./// Passing a negative number doesn't invoke undefined behavior, but it/// may cause unexpected behavior./// The caller must guarantee `raw` is non-zero.as_raw_pid/// Converts a `Pid` into a `RawPid`./// This is the same as `self.as_raw_nonzero().get()`./// Test whether this pid represents the init process ([`Pid::INIT`]).test_ctorstest_specials/// See [`pipe_with`] to pass additional flags./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/pipe.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Creating-a-Pipe.html/// `pipe_with` is the same as [`pipe`] but adds an additional flags operand.r" `PR_PAC_AP*`"/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/chdir.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fchdir.html/// `getcwd`—Return the current working directory./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getcwd.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/stdlib.h.html/// The exit status used by a process terminated with a [`Signal::ABORT`]/// [`Signal::ABORT`]: crate::process::Signal::ABORT/// `fcntl(fd, F_GETLK)`—Get the first lock that blocks the lock description/// pointed to by the argument `lock`. If no such lock is found, then `None` is/// If `lock.typ` is set to `FlockType::Unlocked`, the returned value/error is/// not explicitly defined, as per POSIX, and will depend on the underlying/// platform implementation./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getuid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getuid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getuid/// [NetBSD]: https://man.netbsd.org/getuid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/geteuid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=geteuid&sektion=2/// [illumos]: https://www.illumos.org/man/2/geteuid/// [NetBSD]: https://man.netbsd.org/geteuid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getgid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getgid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getgid/// [NetBSD]: https://man.netbsd.org/getgid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getegid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getegid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getegid/// [NetBSD]: https://man.netbsd.org/getegid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getpid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getpid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getpid/// [NetBSD]: https://man.netbsd.org/getpid.2/// This will return `None` if the current process has no parent (or no parent/// accessible in the current PID namespace), such as if the current process is/// the init process ([`Pid::INIT`])./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getppid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getppid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getppid/// [NetBSD]: https://man.netbsd.org/getppid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getpgid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getpgid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getpgid/// [NetBSD]: https://man.netbsd.org/getpgid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setpgid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=setpgid&sektion=2/// [illumos]: https://www.illumos.org/man/2/setpgid/// [NetBSD]: https://man.netbsd.org/setpgid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getpgrp.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getpgrp&sektion=2/// [illumos]: https://www.illumos.org/man/2/getpgrp/// [NetBSD]: https://man.netbsd.org/getpgrp.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getsid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getsid&sektion=2/// [illumos]: https://www.illumos.org/man/2/getsid/// [NetBSD]: https://man.netbsd.org/getsid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setsid.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=setsid&sektion=2/// [illumos]: https://www.illumos.org/man/2/setsid/// [NetBSD]: https://man.netbsd.org/setsid.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getgroups.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=getgroups&sektion=2/// [NetBSD]: https://man.netbsd.org/getgroups.2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/kill.html/// If `pid` is [`Pid::INIT`], this sends a signal to all processes the current/// process has permission to send signals to, except process `Pid::INIT`,/// possibly other system-specific processes, and on some systems, the currentr" `PIDFD_NONBLOCK`"/// `pivot_root(new_root, put_old)`—Change the root mount./// [Linux]: https://man7.org/linux/man-pages/man2/pivot_root.2.html///  - [Linux: `prctl(PR_GET_PDEATHSIG,…)`]///  - [FreeBSD: `procctl(PROC_PDEATHSIG_STATUS,…)`]/// [Linux: `prctl(PR_GET_PDEATHSIG,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_PDEATHSIG_STATUS,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [Linux: `prctl(PR_SET_PDEATHSIG,…)`]///  - [FreeBSD: `procctl(PROC_PDEATHSIG_CTL,…)`]/// [Linux: `prctl(PR_SET_PDEATHSIG,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_PDEATHSIG_CTL,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [`prctl(PR_GET_DUMPABLE,…)`]/// [`prctl(PR_GET_DUMPABLE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Set the state of the `dumpable` attribute./// This attribute determines whether the process can be traced and whether/// core dumps are produced for the calling process upon delivery of a signal///  - [`prctl(PR_SET_DUMPABLE,…)`]/// [`prctl(PR_SET_DUMPABLE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_UNALIGN,…)`]/// [`prctl(PR_GET_UNALIGN,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_UNALIGN,…)`]/// [`prctl(PR_SET_UNALIGN,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_FPEMU,…)`]/// [`prctl(PR_GET_FPEMU,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_FPEMU,…)`]/// [`prctl(PR_SET_FPEMU,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_FPEXC,…)`]/// [`prctl(PR_GET_FPEXC,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_FPEXC,…)`]/// [`prctl(PR_SET_FPEXC,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_TIMING,…)`]/// [`prctl(PR_GET_TIMING,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_TIMING,…)`]/// [`prctl(PR_SET_TIMING,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_ENDIAN,…)`]/// [`prctl(PR_GET_ENDIAN,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_ENDIAN,…)`]/// [`prctl(PR_SET_ENDIAN,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// Throw a [`Signal::SEGV`] signal instead of reading the TSC.///  - [`prctl(PR_GET_TSC,…)`]/// [`prctl(PR_GET_TSC,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_TSC,…)`]/// [`prctl(PR_SET_TSC,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_TASK_PERF_EVENTS_ENABLE,…)`]///  - [`prctl(PR_TASK_PERF_EVENTS_DISABLE,…)`]/// [`prctl(PR_TASK_PERF_EVENTS_ENABLE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [`prctl(PR_TASK_PERF_EVENTS_DISABLE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_MCE_KILL_GET,…)`]/// [`prctl(PR_MCE_KILL_GET,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_MCE_KILL,…)`]/// [`prctl(PR_MCE_KILL,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_MM,…)`]/// [`prctl(PR_SET_MM,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_MM,PR_SET_MM_EXE_FILE,…)`]/// [`prctl(PR_SET_MM,PR_SET_MM_EXE_FILE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_MM,PR_SET_MM_AUXV,…)`]/// [`prctl(PR_SET_MM,PR_SET_MM_AUXV,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_MM,PR_SET_MM_MAP_SIZE,…)`]/// [`prctl(PR_SET_MM,PR_SET_MM_MAP_SIZE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_MM,PR_SET_MM_MAP,…)`]/// [`prctl(PR_SET_MM,PR_SET_MM_MAP,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_PTRACER,…)`]/// [`prctl(PR_SET_PTRACER,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_CHILD_SUBREAPER,…)`]/// [`prctl(PR_GET_CHILD_SUBREAPER,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_CHILD_SUBREAPER,…)`]/// [`prctl(PR_SET_CHILD_SUBREAPER,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_FP_MODE,…)`]/// [`prctl(PR_GET_FP_MODE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_FP_MODE,…)`]/// [`prctl(PR_SET_FP_MODE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.htmlr" [`control_speculative_feature`]."///  - [`prctl(PR_GET_SPECULATION_CTRL,…)`]/// [`prctl(PR_GET_SPECULATION_CTRL,…)`]: https://www.kernel.org/doc/html/v6.13/userspace-api/spec_ctrl.html///  - [`prctl(PR_SET_SPECULATION_CTRL,…)`]/// [`prctl(PR_SET_SPECULATION_CTRL,…)`]: https://www.kernel.org/doc/html/v6.13/userspace-api/spec_ctrl.html///  - [`prctl(PR_GET_IO_FLUSHER,…)`]/// [`prctl(PR_GET_IO_FLUSHER,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_IO_FLUSHER,…)`]/// [`prctl(PR_SET_IO_FLUSHER,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_PAC_GET_ENABLED_KEYS,…)`]/// [`prctl(PR_PAC_GET_ENABLED_KEYS,…)`]: https://www.kernel.org/doc/html/v6.13/arch/arm64/pointer-authentication.html///  - [`prctl(PR_PAC_SET_ENABLED_KEYS,…)`]/// [`prctl(PR_PAC_SET_ENABLED_KEYS,…)`]: https://www.kernel.org/doc/html/v6.13/arch/arm64/pointer-authentication.html///  - [`prctl(PR_SET_VMA,PR_SET_VMA_ANON_NAME,…)`]/// [`prctl(PR_SET_VMA,PR_SET_VMA_ANON_NAME,…)`]: https://lwn.net/Articles/867818//// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/nice.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getpriority.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setpriority.html/// `PROC_TRACE_CTL_*`/// `idtype` and `id`./// This determines whether the process can be traced and whether core dumps/// are produced for the process upon delivery of a signal whose default/// behavior is to produce a core dump.///  - [FreeBSD `procctl(PROC_TRACE_CTL,…)`]/// [FreeBSD `procctl(PROC_TRACE_CTL,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [FreeBSD `procctl(PROC_TRACE_STATUS,…)`]/// [FreeBSD `procctl(PROC_TRACE_STATUS,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [FreeBSD: `procctl(PROC_REAP_ACQUIRE/RELEASE,…)`]/// [FreeBSD: `procctl(PROC_REAP_ACQUIRE/RELEASE,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [FreeBSD: `procctl(PROC_REAP_STATUS,…)`]/// [FreeBSD: `procctl(PROC_REAP_STATUS,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2/// The pid of the child of the reaper which is the (grand-…)parent of the///  - [FreeBSD: `procctl(PROC_REAP_GETPIDS,…)`]/// [FreeBSD: `procctl(PROC_REAP_GETPIDS,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2/// Deliver a signal to some subset of the descendants of the reaper.///  - [FreeBSD: `procctl(PROC_REAP_KILL,…)`]/// [FreeBSD: `procctl(PROC_REAP_KILL,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2/// `PROC_TRAPCAP_CTL_*`/// [`io::Errno::NOTCAPABLE`] or [`io::Errno::CAPMODE`] error.///  - [FreeBSD: `procctl(PROC_TRAPCAP_CTL,…)`]/// [FreeBSD: `procctl(PROC_TRAPCAP_CTL,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [FreeBSD: `procctl(PROC_TRAPCAP_STATUS,…)`]/// [FreeBSD: `procctl(PROC_TRAPCAP_STATUS,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [Linux: `prctl(PR_SET_NO_NEW_PRIVS,…)`]///  - [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_CTL,…)`]/// [Linux: `prctl(PR_SET_NO_NEW_PRIVS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_CTL,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2///  - [Linux: `prctl(PR_GET_NO_NEW_PRIVS,…)`]///  - [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_STATUS,…)`]/// [Linux: `prctl(PR_GET_NO_NEW_PRIVS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [FreeBSD: `procctl(PROC_NO_NEW_PRIVS_STATUS,…)`]: https://man.freebsd.org/cgi/man.cgi?query=procctl&sektion=2/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/getrlimit.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setrlimit.html/// Starting offset for lock/// Number of bytes to lock/// PID of process blocking our lock. If set to `None`, it refers to the/// current processFlockType/// Type of lockoffset_typeFlockOffsetType/// Offset type of lock/// File lock data structure used in [`fcntl_getlk`]./// [`fcntl_getlk`]: crate::process::fcntl_getlk()ReadLock/// `F_RDLCK`WriteLock/// `F_WRLCK`/// `F_UNLCK`/// `F_*LCK` constants for use with [`fcntl_getlk`]./// `F_SEEK_SET`/// `F_SEEK_CUR`/// `F_SEEK_END`/// `F_SEEK*` constants for use with [`fcntl_getlk`].//! Types for use with [`rustix::process`] functions.//! [`rustix::process`]: crate::process/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/umask.htmlr" Return if a child has stopped (but not traced via [`ptrace`])."r" [`Signal::Cont`]: crate::process::Signal::Cont"// SAFETY: `siginfo_t` does contain some raw pointers, such as the `si_ptr`// and the `si_addr` fields, however it's up to users to use those correctly.raw_signo/// Return the raw `si_signo` value returned from `waitid`.raw_errno/// Return the raw `si_errno` value returned from `waitid`./// Return the raw `si_code` value returned from `waitid`.// This is disabled on NetBSD because the libc crate's `si_status()`// implementation doesn't appear to match what's in NetBSD's headers and we// don't get a meaningful value returned.// TODO: Report this upstream./// process group id matches that of the calling process. Otherwise, the call/// will wait for the child process with the given pid./// To wait for a given process group (the `< -1` case of `waitpid`), use/// [`waitpgid`] or [`waitid`]. To wait for any process (the `-1` case of/// `waitpid`), use [`wait`]./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/wait.html//! Wait for processes to change state.//! This code needs to implement `Send` and `Sync` for `WaitIdStatus` because//! the linux-raw-sys bindings generate a type that doesn't do so/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_openpt.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/ptsname.html/// [illumos]: https://www.illumos.org/man/3C/ptsname/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Allocation.html#index-ptsname/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/unlockpt.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Allocation.html#index-unlockpt/// grant the appropriate access. On all other platforms, this function has/// unspecified behavior if the calling process has a [`Signal::CHILD`] signal/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/grantpt.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Allocation.html#index-grantpt/// [`Signal::CHILD`]: crate::process::Signal::CHILD/// `ioctl(fd, TIOCGPTPEER)`—Open the user side of a pseudoterminal./// This function is implemented using a system call, and not the/// [vDSO mechanism] introduced in Linux 6.11. See [#1185] for details./// [vDSO mechanism]: https://lwn.net/Articles/983186//// [#1185]: https://github.com/bytecodealliance/rustix/issues/1185//! Wrappers for `getrandom`.KernelSighandlerKernelSigactionFlagsKernelSigrestore/// `kernel_sigaction`/// On some architectures, the `sa_restorer` field is omitted./// This type does not have the same layout as `libc::sigaction`./// `__sigrestore_t`/// This type differs from `libc::sigrestore_t`, but can be transmuted to it./// `__kernel_sighandler_t`/// This type differs from `libc::sighandler_t`, but can be transmuted to it.kernel_sig_ign/// Return a special “ignore” signal handler for ignoring signals./// This isn't the `SIG_IGN` value itself; it's a function that returns the/// `SIG_IGN` value./// If you're looking for `kernel_sig_dfl`; use [`KERNEL_SIG_DFL`].KERNEL_SIG_DFL/// A special “default” signal handler representing the default behavior/// for handling a signal./// If you're looking for `KERNEL_SIG_IGN`; use [`kernel_sig_ign`]./// This type is guaranteed to have the same layout as `libc::stack_t`./// If we want to expose this in public APIs, we should encapsulate the/// `linux_raw_sys` type./// This type is guaranteed to have the same layout as `libc::siginfo_t`./// `SIG_*` constants for use with [`kernel_sigprocmask`]./// [POSIX `_Exit`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/_Exit.html/// On success, `Fork::ParentOf` containing the pid of the child process is/// returned in the parent, and `Fork::Child` containing the pid of the child/// process is returned in the child./// — “Rules”, by Karla Kuskin/// [`MAP_SHARED`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/mmap.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fork.html/// [async-signal-safe]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/V2_chap02.html#tag_15_04_03/// This is returned in the child process after a `fork`. It holds the PID/// of the child.ParentOf/// This is returned in the parent process after a `fork`. It holds the PID/// Taking raw-pointers-to-raw-pointers is convenient for c-scape, but we/// should think about potentially a more Rust-idiomatic API if this is ever/// made public./// `sigaction(signal, &new, &old)`—Modify and/or query a signal handler./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sigaction.html/// `sigaltstack(new, old)`—Modify and/or query a signal stack./// The memory region described by `new` must readable and writable and larger/// than the platform minimum signal stack size, and must have a guard region/// that conforms to the platform conventions for stack guard regions. The/// flags in `new` must be valid. This function does not diagnose all the/// errors that libc `sigaltstack` functions are documented as diagnosing./// While the memory region pointed to by `new` is registered as a signal/// stack, it must remain readable and writable, and must not be mutated in/// any way other than by having a signal handler run in it, and must not be/// the referent of a Rust reference from outside the signal handler./// If code elsewhere in the program is depending on signal handlers being run/// on a particular stack, this could break that code's assumptions. And if the/// caller is depending on signal handlers being run on the stack specified in/// the call, its assumptions could be broken by code elsewhere in the program/// There are probably things out there that assume that all alternate signal/// stack registration goes through libc, and this does not go through libc./// There may be further safety hazards not yet documented here./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sigaltstack.html/// Causing an individual thread to abruptly terminate without involving the/// process' thread runtime (such as the libpthread or the libc) evokes/// Also, this is not `tgkill`, so the warning about the hazard of recycled/// thread IDs applies./// `rt_sigprocmask(how, set, oldset)`—Adjust the process signal mask./// If this is ever exposed publicly, we should think about whether it should/// mask out signals reserved by libc./// If there is a libc in the process, the `set` must not contain any signal/// reserved by the libc./// If code elsewhere in the program is depending on delivery of a signal for/// any reason, for example to prevent it from executing some code, this could/// cause it to miss that signal, and for example execute that code. And if the/// caller is depending on delivery of a signal for any reason, its assumptions/// could be broken by code elsewhere in the program calling this function.///  - [Linux `rt_sigprocmask`]/// [Linux `rt_sigprocmask`]: https://man7.org/linux/man-pages/man2/rt_sigprocmask.2.html/// be made to fail if given signals reserved by libc./// don't use it unless you know your code won't share a process with a libc/// (perhaps because you yourself are implementing a libc)./// `SIGRTMIN`—The start of the raw OS “real-time” signal range./// `SIGRTMIN` macro provided by libc. Don't use this unless you know your code/// won't share a process with a libc (perhaps because you yourself are/// implementing a libc)./// `SIGRTMAX`—The last of the raw OS “real-time” signal range./// `SIGRTMAX` macro provided by libc. Don't use this unless you know your codetest_layouts_matching_libctest_layouts_matching_kernel//! ⚠ These are not normal functions. ⚠//!  - Some of the functions in this module cannot be used in a process which//!    also has a libc present. This can be true even for functions that have//!    the same name as a libc function that Rust code can use. Such functions//!    are not marked `unsafe` (unless they are unsafe for other reasons), even//!    though they invoke Undefined Behavior if called in a process which has a//!    libc present.//!  - Some of the functions in this module don't behave exactly the same way//!    as functions in libc with similar names. Sometimes information about the//!    differences is included in the Linux documentation under “C//!    library/kernel differences” sections. But not always.//!  - The safety requirements of the functions in this module are not fully//!    documented.//!  - The API for these functions is not considered stable, and this module is//!    `doc(hidden)`.//! ⚠ Caution is indicated. ⚠//! All that said, there are some functions in this module would could//! potentially be stabilized and moved to other modules. See also the//! documentation for specific functions in the [`not_implemented`] module, and//! the discussion in [#1314].//! [`not_implemented`]: crate::not_implemented//! [#1314]: https://github.com/bytecodealliance/rustix/issues/1314/// Exactly one of [`shm::OFlags::RDONLY`] and [`shm::OFlags::RDWR`] should be/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/shm_open.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/shm_unlink.html//! use rustix::fs::{ftruncate, Mode};//! use rustix::mm::{mmap, MapFlags, ProtFlags};//! use rustix::{io, shm};//! use std::mem::size_of;//! use std::ptr::null_mut;//! # fn example() -> io::Result<()> {//! // A type describing the data to be shared.//! #[repr(C)]//! struct MyBufferType {//!     // …//! // Create the shared memory object.//! let shm_path = "/rustix-shm-example";//! let fd = shm::open(//!     shm_path,//!     shm::OFlags::CREATE | shm::OFlags::EXCL | shm::OFlags::RDWR,//!     Mode::RUSR | Mode::WUSR,//! // Resize the shared memory object to the size of our data.//! ftruncate(&fd, size_of::<MyBufferType>() as u64)?;//! // Map the shared memory object into our address space.//! // SAFETY: We're creating a new mapping that's independent of any existing//! // memory allocations. There are interesting things to say about *using*//! // `ptr`, but that's for another safety comment.//! let ptr = unsafe {//!     mmap(//!         null_mut(),//!         size_of::<MyBufferType>(),//!         ProtFlags::READ | ProtFlags::WRITE,//!         MapFlags::SHARED,//!         &fd,//!         0,//!     )?//! // Use `ptr`…//! // Remove the shared memory object name.//! shm::unlink(shm_path)?;/// A signal number for use with [`kill_process`], [`kill_process_group`], and/// [`kill_current_process_group`]./// For additional constructors such as [`Signal::rt_min`]/// (aka `libc::SIGRTMIN`), [`Signal::rt_max`] (aka `libc::SIGRTMAX`),/// [`Signal::rt`] (aka `|n| libc::SIGRTMIN() + n`), [`Signal::from_raw`], and/// [`Signal::from_raw_nonzero`], see [rustix-libc-wrappers]./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/signal.h.html/// [Linux]: https://man7.org/linux/man-pages/man7/signal.7.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Standard-Signals.html/// [`Signal::rt_min`]: https://docs.rs/rustix-libc-wrappers/*/rustix_libc_wrappers/trait.SignalExt.html#tymethod.rt_min/// [`Signal::rt_max`]: https://docs.rs/rustix-libc-wrappers/*/rustix_libc_wrappers/trait.SignalExt.html#tymethod.rt_max/// [`Signal::rt`]: https://docs.rs/rustix-libc-wrappers/*/rustix_libc_wrappers/trait.SignalExt.html#tymethod.rt/// [`Signal::from_raw`]: https://docs.rs/rustix-libc-wrappers/*/rustix_libc_wrappers/trait.SignalExt.html#tymethod.from_raw/// [`Signal::from_raw_nonzero`]: https://docs.rs/rustix-libc-wrappers/*/rustix_libc_wrappers/trait.SignalExt.html#tymethod.from_raw_nonzero/// [rustix-libc-wrappers]: https://docs.rs/rustix-libc-wrappersQUITILLTRAPBUSFPEUSR1SEGVUSR2ALARMTERMSTKFLTCONTSTOPURGVTALARMPROFWINCHSYS// SAFETY: The libc-defined signal values are all non-zero./// Convert a `Signal` to a raw signal number./// To convert to a `NonZeroI32`, use [`Signal::as_raw_nonzero`]./// Convert a `Signal` to a raw non-zero signal number./// Convert a raw signal number into a `Signal` without checks./// For a safe checked version, see [`Signal::from_raw`] in/// [rustix-libc-wrappers]./// `sig` must be a valid and non-zero signal number./// And, if `sig` is a signal number reserved by the libc, such as a value/// from the libc [`SIGRTMIN`] to the libc [`SIGRTMAX`], inclusive, then/// the resulting `Signal` must not be used to send, consume, or block any/// signals or alter any signal handlers./// [`SIGRTMIN`]: https://docs.rs/libc/*/libc/fn.SIGRTMIN.html/// [`SIGRTMAX`]: https://docs.rs/libc/*/libc/fn.SIGRTMAX.htmlfrom_raw_nonzero_unchecked/// Convert a raw non-zero signal number into a `Signal` without checks./// For a safe checked version, see [`Signal::from_raw_nonzero`] in/// `sig` must be a valid signal number./// from [`SIGRTMIN`] to [`SIGRTMAX`] inclusive, then the resulting/// `Signal` must not be used to send, consume, or block any signals or/// alter any signal handlers.from_named_raw/// Convert a raw named signal number into a `Signal`./// If the given signal number corresponds to one of the named constant/// signal values, such as [`Signal::HUP`] or [`Signal::INT`], return the/// `Signal` value. Otherwise return `None`./// Signals in the range `SIGRTMIN` through `SIGRTMAX` are not supported by/// this function. For a constructor that does recognize those values, see/// [`Signal::from_raw`] in [rustix-libc-wrappers].from_named_raw_nonzero/// Convert a raw non-zero named signal number into a `Signal`./// If the given signal number corresponds to one of the constant signal/// values, such as [`Signal::HUP`] or [`Signal::INT`], return the/// [`Signal::from_raw_nonzero`] in [rustix-libc-wrappers].test_basicstest_named//! Signal numbers.//! Some signal numbers are reserved by the libc.//! [`Signal::from_raw_unchecked`] and [`Signal::from_raw_nonzero_unchecked`]//! allow constructing `Signal` values with arbitrary values. Users must avoid//! using reserved values to send, consume, or block any signals or alter any//! See the individual functions' safety comments for more details./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/stdin.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Standard-Streams.html#index-stdin/// In `no_std` configurations, the process' stdin file descriptor can be/// closed, potentially on other threads, in which case the file descriptor/// index number (`STDIN_FILENO`) could be dynamically reused for other/// purposes, potentially on different threads./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/stdout.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Standard-Streams.html#index-stdout/// In `no_std` configurations, the process' stdout file descriptor can be/// index number (`STDOUT_FILENO`) could be dynamically reused for other/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/stderr.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Standard-Streams.html#index-stderr/// In `no_std` configurations, the process' stderr file descriptor can be/// index number (`STDERR_FILENO`) could be dynamically reused for other//! Some of the functions in this module can cause the process' stdio file//! descriptors to be closed, which breaks the assumption made in Rust's std//! that these file descriptors are always open.//! And in no-std mode, some of the functions in this module similarly assume//! that the process' stdio file descriptors are open, which we don't take as//! given in no-std mode because we don't have std also making that assumption./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/uname.html/// [glibc]: https://sourceware.org/glibc/manual/latest/html_node/Platform-Type.html/// `sysname`—Operating system release name./// `nodename`—Name with vague meaning./// `release`—Operating system release version string./// `version`—Operating system build identifiers./// `machine`—Hardware architecture identifier./// `domainname`—NIS or YP domain identifier./// `setdomain(name)`—Sets the system NIS domain name./// [Linux]: https://man7.org/linux/man-pages/man2/setdomainname.2.html/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=setdomainname&sektion=3/// When disabled, the keystroke will send a [`Signal::INT`] to/// [`Pid::INIT`]./// [`Signal::INT`]: crate::process::Signal::INT/// [`Pid::INIT`]: crate::process::Pid::INIT/// `reboot`—Reboot the system or enable/disable Ctrl-Alt-Del.///  - Restart, Halt, Power Off, and Suspend the system///  - Enable and disable the Ctrl-Alt-Del keystroke///  - Execute other kernels///  - Terminate init inside PID namespaces/// `init_module`—Load a kernel module./// `finit_module`—Load a kernel module from a file descriptor./// `delete_module`—Unload a kernel module.test_sysinfo_layouts/// In exclusive mode, subsequent unprivileged `open` calls on the terminal/// device fail with [`io::Errno::BUSY`].//! The [`speed`] module contains various predefined speed constants which are//! more likely to be portable, however any `u32` value can be passed to//! [`Termios::set_speed`], [`Termios::set_input_speed`], and//! [`Termios::set_output_speed`], and they will simply fail if the speed is//! not supported by the platform or the device./// On Linux, this uses `TCGETS2`. If that fails in a way that indicates that/// the host doesn't support it, this falls back to the old `TCGETS`, manually/// initializes the fields that `TCGETS` doesn't initialize, and fails with/// `io::Errno::RANGE` if the input or output speeds cannot be supported./// [POSIX `tcgetattr`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcgetattr.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcgetpgrp.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcsetpgrp.html/// Also known as the `TCSETS` (or `TCSETS2` on Linux) operation with `ioctl`./// On Linux, this uses `TCSETS2`. If that fails in a way that indicates that/// the host doesn't support it, this falls back to the old `TCSETS`, and fails/// with `io::Errno::RANGE` if the input or output speeds cannot be supported./// [POSIX `tcsetattr`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcsetattr.html/// [POSIX `tcsendbreak`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcsendbreak.html/// [POSIX `tcsetattr`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcdrain.html/// [POSIX `tcflush`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcflush.html/// [POSIX `tcflow`]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcflow.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/tcgetsid.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/isatty.html/// `ttyname_r(fd)`—Returns the name of the tty open on `fd`./// On Linux, this function depends on procfs being mounted on /proc./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/ttyname.html/// On some platforms, changing the input speed changes the output speed to/// the same speed./// On some platforms, changing the output speed changes the input speed to/// encoded values./// On Linux on PowerPC, `TCGETS`/`TCSETS` support the `c_ispeed` and/// `c_ospeed` fields./// On Linux on architectures other than PowerPC, `TCGETS`/`TCSETS` don't/// support the `c_ispeed` and `c_ospeed` fields, so we have to fall back/// to `TCGETS2`/`TCSETS2` to support them./// Speeds for use with [`Termios::set_speed`], [`Termios::set_input_speed`],/// and [`Termios::set_output_speed`]./// platforms and devices which don't support arbitrary speeds./// An array indexed by [`SpecialCodeIndex`] indicating the current values of/// various special control codes.SpecialCode/// A newtype for pretty printing./// `VSWTCH`/// `VDSUSP`/// `VSTATUS`/// `VERASE2`/// The number of rows the terminal has./// The number of columns the terminal has./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/clock_nanosleep.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/nanosleep.html/// `syscall(SYS_futex, uaddr, FUTEX_WAIT, val, timeout, NULL, 0)`/// primitives. See the references links./// `syscall(SYS_futex, uaddr, FUTEX_WAKE, val, NULL, NULL, 0)`/// `syscall(SYS_futex, uaddr, FUTEX_FD, val, NULL, NULL, 0)`requeue/// `syscall(SYS_futex, uaddr, FUTEX_REQUEUE, val, val2, uaddr2, 0)`cmp_requeue/// `syscall(SYS_futex, uaddr, FUTEX_CMP_REQUEUE, val, val2, uaddr2, val3)`/// `FUTEX_OP_SET`: `uaddr2 = oparg;`/// `FUTEX_OP_ADD`: `uaddr2 += oparg;`/// `FUTEX_OP_OR`: `uaddr2 |= oparg;`AndN/// `FUTEX_OP_ANDN`: `uaddr2 &= ~oparg;`XOr/// `FUTEX_OP_XOR`: `uaddr2 ^= oparg;`SetShift/// `FUTEX_OP_SET | FUTEX_OP_ARG_SHIFT`: `uaddr2 = (oparg << 1);`AddShift/// `FUTEX_OP_ADD | FUTEX_OP_ARG_SHIFT`: `uaddr2 += (oparg << 1);`OrShift/// `FUTEX_OP_OR | FUTEX_OP_ARG_SHIFT`: `uaddr2 |= (oparg << 1);`AndNShift/// `FUTEX_OP_ANDN | FUTEX_OP_ARG_SHIFT`: `uaddr2 &= !(oparg << 1);`XOrShift/// `FUTEX_OP_XOR | FUTEX_OP_ARG_SHIFT`: `uaddr2 ^= (oparg << 1);`/// `FUTEX_OP_*` operations for use with [`wake_op`].WakeOpCmp/// `FUTEX_OP_CMP_EQ`: `if oldval == cmparg { wake(); }`/// `FUTEX_OP_CMP_EQ`: `if oldval != cmparg { wake(); }`/// `FUTEX_OP_CMP_EQ`: `if oldval < cmparg { wake(); }`/// `FUTEX_OP_CMP_EQ`: `if oldval <= cmparg { wake(); }`/// `FUTEX_OP_CMP_EQ`: `if oldval > cmparg { wake(); }`/// `FUTEX_OP_CMP_EQ`: `if oldval >= cmparg { wake(); }`/// `FUTEX_OP_CMP_*` operations for use with [`wake_op`].wake_op/// `syscall(SYS_futex, uaddr, FUTEX_WAKE_OP, val, val2, uaddr2, val3)`lock_pi/// `syscall(SYS_futex, uaddr, FUTEX_LOCK_PI, 0, timeout, NULL, 0)`unlock_pi/// `syscall(SYS_futex, uaddr, FUTEX_UNLOCK_PI, 0, NULL, NULL, 0)`trylock_pi/// `syscall(SYS_futex, uaddr, FUTEX_TRYLOCK_PI, 0, NULL, NULL, 0)`wait_bitset/// `syscall(SYS_futex, uaddr, FUTEX_WAIT_BITSET, val, timeout, NULL, val3)`wake_bitset/// `syscall(SYS_futex, uaddr, FUTEX_WAKE_BITSET, val, NULL, NULL, val3)`wait_requeue_pi/// `syscall(SYS_futex, uaddr, FUTEX_WAIT_REQUEUE_PI, val, timeout, uaddr2, 0)`cmp_requeue_pi/// `syscall(SYS_futex, uaddr, FUTEX_CMP_REQUEUE_PI, 1, val2, uaddr2, val3)`lock_pi2/// `syscall(SYS_futex, uaddr, FUTEX_LOCK_PI2, 0, timeout, NULL, 0)`/// A pointer in the [`Wait`] struct./// Construct a new `WaitPtr` holding the given raw pointer value./// The expected value./// The address to wait for./// The type and size of futex to perform./// Reserved for future use./// For use with [`waitv`]./// Construct a zero-initialized `Wait`.waitv/// `futex_waitv(waiters.as_ptr(), waiters.len(), flags, timeout, clockd)`—/// Wait on an array of futexes, wake on any./// This requires Linux ≥ 5.16./// [Linux]: https://www.kernel.org/doc/html/latest/userspace-api/futex2.html//! Futex is a very low-level mechanism for implementing concurrency primitives//! such as mutexes, rwlocks, and condvars. For a higher-level API that//! provides those abstractions, see [rustix-futex-sync].//! use rustix::thread::futex;//! use std::sync::atomic::AtomicU32;//! # fn test(futex: &AtomicU32) -> rustix::io::Result<()> {//! // Wake up one waiter.//! futex::wake(futex, futex::Flags::PRIVATE, 1)?;//!  - [Linux `futex` system call]//!  - [Linux `futex` feature]//! [Linux `futex` system call]: https://man7.org/linux/man-pages/man2/futex.2.html//! [Linux `futex` feature]: https://man7.org/linux/man-pages/man7/futex.7.html//! [rustix-futex-sync]: https://crates.io/crates/rustix-futex-sync/// Rust's `std::thread::Thread::id` or the pthread ID./// This function always does a system call. To avoid this overhead, ask the/// thread runtime for the ID instead, for example using [`libc::gettid`] or/// [`origin::thread::current_id`]./// [`libc::gettid`]: https://docs.rs/libc/*/libc/fn.gettid.html/// [`origin::thread::current_id`]: https://docs.rs/origin/*/origin/thread/fn.current_id.html/// `setuid(uid)`—Sets the effective user ID of the calling thread./// This is not the `setuid` you are looking for… POSIX requires uids to be/// changes the uid for the current *thread*, not the entire process even/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setuid.html/// `setresuid(ruid, euid, suid)`—Sets the real, effective, and saved user ID/// of the calling thread./// This is not the `setresuid` you are looking for… POSIX requires uids to be/// `setgid(gid)`—Sets the effective group ID of the current thread./// This is not the `setgid` you are looking for… POSIX requires gids to be/// changes the gid for the current *thread*, not the entire process even/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/setgid.html/// `setresgid(rgid, egid, sgid)`—Sets the real, effective, and saved group/// ID of the current thread./// This is not the `setresgid` you are looking for… POSIX requires gids to be/// `setgroups(groups)`—Sets the supplementary group IDs for the calling//! CPU and thread identifiers.//! The `Cpuid`, type can be constructed from raw integers, which is marked//! unsafe because actual OS's assign special meaning to some integer values.CapabilitySet/// Previous name of `CapabilitySet`.// #[expect(deprecated, reason = "CapabilityFlags is deprecated")]///  - [`prctl(PR_GET_KEEPCAPS,…)`]/// [`prctl(PR_GET_KEEPCAPS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_KEEPCAPS,…)`]/// [`prctl(PR_SET_KEEPCAPS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_NAME,…)`]/// [`prctl(PR_GET_NAME,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_NAME,…)`]/// [`prctl(PR_SET_NAME,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// `SECCOMP_MODE_*`secure_computing_mode/// Get the secure computing mode of the calling thread./// If the caller is not in secure computing mode, this returns/// [`SecureComputingMode::Disabled`]. If the caller is in strict secure/// computing mode, then this call will cause a [`Signal::KILL`] signal to be/// sent to the process. If the caller is in filter mode, and this system call/// is allowed by the seccomp filters, it returns/// [`SecureComputingMode::Filter`]; otherwise, the process is killed with a/// [`Signal::KILL`] signal./// Since Linux 3.8, the Seccomp field of the `/proc/[pid]/status` file/// provides a method of obtaining the same information, without the risk that/// the process is killed; see [the `proc` manual page].///  - [`prctl(PR_GET_SECCOMP,…)`]/// [`Signal::KILL`]: crate::signal::Signal::KILL/// [`prctl(PR_GET_SECCOMP,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [the `proc` manual page]: https://man7.org/linux/man-pages/man5/proc.5.html///  - [`prctl(PR_SET_SECCOMP,…)`]/// [`prctl(PR_SET_SECCOMP,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// [`Capability::FileSetID`] is applicable. It doesn't override MAC and/// DAC restrictions./// match the file owner ID when setting the `S_ISUID` and `S_ISGID` bits/// on that file; that the effective group ID (or one of the supplementary/// group IDs) shall match the file owner ID when setting the `S_ISGID` bit/// on that file; that the `S_ISUID` and `S_ISGID` bits are cleared on/// successful return from `chown` (not implemented)./// capability based overrides of that policy, this is the capability it/// should use to do so./// MAC configuration. An LSM may enforce a MAC policy, and if it does and/// it chooses to implement capability based checks on modifications to/// that policy or the data required to maintain it, this is the capability/// [`Capability::SystemAdmin`] is required to use `bpf_probe_write_user`.as_capability_setCompatCapability/// Compatibility trait to keep existing code that uses the deprecated [`Capability`] type working./// This trait and its methods are sealed. It must not be used downstream.///  - [`prctl(PR_CAPBSET_READ,…)`]/// [`prctl(PR_CAPBSET_READ,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_CAPBSET_DROP,…)`]/// [`prctl(PR_CAPBSET_DROP,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_SECUREBITS,…)`]/// [`prctl(PR_GET_SECUREBITS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_SECUREBITS,…)`]/// [`prctl(PR_SET_SECUREBITS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_TIMERSLACK,…)`]/// [`prctl(PR_GET_TIMERSLACK,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_TIMERSLACK,…)`]/// [`prctl(PR_SET_TIMERSLACK,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_NO_NEW_PRIVS,…)`]/// [`prctl(PR_GET_NO_NEW_PRIVS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_NO_NEW_PRIVS,…)`]/// [`prctl(PR_SET_NO_NEW_PRIVS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_TID_ADDRESS,…)`]/// [`prctl(PR_GET_TID_ADDRESS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_THP_DISABLE,…)`]/// [`prctl(PR_GET_THP_DISABLE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_THP_DISABLE,…)`]/// [`prctl(PR_SET_THP_DISABLE,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_IS_SET,…)`]/// [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_IS_SET,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_CLEAR_ALL,…)`]/// [`prctl(PR_CAP_AMBIENT,PR_CAP_AMBIENT_CLEAR_ALL,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_CAP_AMBIENT,…)`]/// [`prctl(PR_CAP_AMBIENT,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SVE_GET_VL,…)`]/// [`prctl(PR_SVE_GET_VL,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SVE_SET_VL,…)`]/// [`prctl(PR_SVE_SET_VL,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_PAC_RESET_KEYS,…)`]/// [`prctl(PR_PAC_RESET_KEYS,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_GET_TAGGED_ADDR_CTRL,…)`]/// [`prctl(PR_GET_TAGGED_ADDR_CTRL,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_TAGGED_ADDR_CTRL,…)`]/// [`prctl(PR_SET_TAGGED_ADDR_CTRL,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_OFF,…)`]/// [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_OFF,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html///  - [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_ON,…)`]/// [`prctl(PR_SET_SYSCALL_USER_DISPATCH,PR_SYS_DISPATCH_ON,…)`]: https://man7.org/linux/man-pages/man2/prctl.2.html/// `PR_SCHED_CORE_SCOPE_*`///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_GET,…)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_GET,…)`]: https://www.kernel.org/doc/html/v6.13/admin-guide/hw-vuln/core-scheduling.html///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_CREATE,…)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_CREATE,…)`]: https://www.kernel.org/doc/html/v6.13/admin-guide/hw-vuln/core-scheduling.html///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_TO,…)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_TO,…)`]: https://www.kernel.org/doc/html/v6.13/admin-guide/hw-vuln/core-scheduling.html///  - [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_FROM,…)`]/// [`prctl(PR_SCHED_CORE,PR_SCHED_CORE_SHARE_FROM,…)`]: https://www.kernel.org/doc/html/v6.13/admin-guide/hw-vuln/core-scheduling.html//! Rustix wraps variadic/dynamic-dispatch functions like `prctl` in type-safe//! wrappers.//! The inner `prctl` calls are dynamically typed and must be called correctly./// [`sched_setaffinity`]: crate::thread::sched_setaffinity/// [`sched_getaffinity`]: crate::thread::sched_getaffinity/// [Linux]: https://man7.org/linux/man-pages/man3/sched_getcpu.3.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sched_yield.html/// `unshare(flags)`—Deprecated in favor of [`unshare_unsafe`]./// This function should be unsafe; see the safety comment on `unshare_unsafe`.unshare_unsafe/// When using `UnshareFlags::FILES`, this function can cause one thread to be/// unable to use file descriptors created on a different thread. Callers must/// ensure that threads never observe file descriptors from unshared tables.//! Thread-specific namespace functions.//! The `unshare` function can cause threads to use different file descriptor tables./// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/clock_getres.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/clock_gettime.html/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/clock_settime.html/// Interval between times./// Value of the time./// For a higher-level API to timerfd functionality, see the [timerfd] crate./// [timerfd]: https://crates.io/crates/timerfd/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=timerfd_create&sektion=2/// [illumos]: https://illumos.org/man/3C/timerfd_create/// [NetBSD]: https://man.netbsd.org/timerfd_create.2/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=timerfd_settime&sektion=2/// [illumos]: https://illumos.org/man/3C/timerfd_settime/// [NetBSD]: https://man.netbsd.org/timerfd_settime.2/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=timerfd_gettime&sektion=2/// [illumos]: https://illumos.org/man/3C/timerfd_gettime/// [NetBSD]: https://man.netbsd.org/timerfd_gettime.2/// When passed to [`rustix::fs::utimensat`], this field may instead be/// assigned the values [`UTIME_NOW`] or [`UTIME_OMIT`]./// [`UTIME_NOW`]: crate::fs::UTIME_NOW/// [`UTIME_OMIT`]: crate::fs::UTIME_OMIT/// [`rustix::fs::utimensat`]: crate::fs::utimensat/// `struct timespec`—A quantity of time in seconds plus nanoseconds./// Checked `Timespec` addition. Returns `None` if overflow occurred./// If `0 <= .tv_nsec < 1_000_000_000` doesn't hold, this function may/// panic or return unexpected results./// use rustix::event::Timespec;///     Timespec {///         tv_sec: 1,///         tv_nsec: 2///     .checked_add(Timespec {///         tv_sec: 30,///         tv_nsec: 40///     Some(Timespec {///         tv_sec: 31,///         tv_nsec: 42///         tv_sec: 0,///         tv_nsec: 999_999_999///         tv_nsec: 1///         tv_sec: i64::MAX,/// Checked `Timespec` subtraction. Returns `None` if overflow occurred.///     .checked_sub(Timespec {///         tv_sec: i64::MIN,///         tv_nsec: 0as_c_int_millis/// Convert from `Timespec` to `c::c_int` milliseconds, rounded up.option_as_libc_timespec_ptrtimespec_layouts// Test that our workarounds are not needed.test_against_kernel_timespec// Test that `Timespec` matches Linux's `__kernel_timespec`./// `raw` must be the value of a valid Unix user ID, and not `-1`./// Test whether this uid represents the root user ([`Uid::ROOT`])./// `raw` must be the value of a valid Unix group ID, and not `-1`./// Test whether this gid represents the root group ([`Gid::ROOT`]).//! This build script allows us to enable the `read_buf` language feature only//! for Rust Nightly.//! See the comment in lib.rs to understand why we need this.BsDebug/// Alternative implementation of `fmt::Debug` for byte slice./// This struct wraps `&[u8]` just to override `fmt::Debug`./// `BsDebug` is not a part of public API of bytes crate.EchModeALL_KEY_EXCHANGE_ALGORITHMStime_providerTimeProviderConfigSide/// A [builder] for [`ServerConfig`] or [`ClientConfig`] values./// To get one of these, call [`ServerConfig::builder()`] or [`ClientConfig::builder()`]./// To build a config, you must make at least two decisions (in order):/// - How should this client or server verify certificates provided by its peer?/// - What certificates should this client or server present to its peer?/// For settings besides these, see the fields of [`ServerConfig`] and [`ClientConfig`]./// The usual choice for protocol primitives is to call/// [`ClientConfig::builder`]/[`ServerConfig::builder`]/// which will use rustls' default cryptographic provider and safe defaults for ciphersuites and/// supported protocol versions./// # #[cfg(feature = "aws_lc_rs")] {/// # rustls::crypto::aws_lc_rs::default_provider().install_default();/// use rustls::{ClientConfig, ServerConfig};/// ClientConfig::builder()/// //  .../// ServerConfig::builder()/// You may also override the choice of protocol versions:/// # use rustls::ServerConfig;/// ServerConfig::builder_with_protocol_versions(&[&rustls::version::TLS13])/// Overriding the default cryptographic provider introduces a `Result` that must be unwrapped,/// because the config builder checks for consistency of the choices made. For instance, it's an error to/// configure only TLS 1.2 cipher suites while specifying that TLS 1.3 should be the only supported protocol/// If you configure a smaller set of protocol primitives than the default, you may get a smaller binary,/// since the code for the unused ones can be optimized away at link time./// After choosing protocol primitives, you must choose (a) how to verify certificates and (b) what certificates/// (if any) to send to the peer. The methods to do this are specific to whether you're building a ClientConfig/// or a ServerConfig, as tracked by the [`ConfigSide`] type parameter on the various impls of ConfigBuilder./// # ClientConfig certificate configuration/// For a client, _certificate verification_ must be configured either by calling one of:///  - [`ConfigBuilder::with_root_certificates`] or///  - [`ConfigBuilder::dangerous()`] and [`DangerousClientConfigBuilder::with_custom_certificate_verifier`]/// Next, _certificate sending_ (also known as "client authentication", "mutual TLS", or "mTLS") must be configured/// or disabled using one of:/// - [`ConfigBuilder::with_no_client_auth`] - to not send client authentication (most common)/// - [`ConfigBuilder::with_client_auth_cert`] - to always send a specific certificate/// - [`ConfigBuilder::with_client_cert_resolver`] - to send a certificate chosen dynamically/// # use rustls::ClientConfig;/// # let root_certs = rustls::RootCertStore::empty();///     .with_root_certificates(root_certs)///     .with_no_client_auth();/// # ServerConfig certificate configuration/// For a server, _certificate verification_ must be configured by calling one of:/// - [`ConfigBuilder::with_no_client_auth`] - to not require client authentication (most common)/// - [`ConfigBuilder::with_client_cert_verifier`] - to use a custom verifier/// Next, _certificate sending_ must be configured by calling one of:/// - [`ConfigBuilder::with_single_cert`] - to send a specific certificate/// - [`ConfigBuilder::with_single_cert_with_ocsp`] - to send a specific certificate, plus stapled OCSP/// - [`ConfigBuilder::with_cert_resolver`] - to send a certificate chosen dynamically/// # let certs = vec![];/// # let private_key = pki_types::PrivateKeyDer::from(/// #    pki_types::PrivatePkcs8KeyDer::from(vec![])/// # );///     .with_no_client_auth()///     .with_single_cert(certs, private_key)///     .expect("bad certificate/key");/// # Types/// ConfigBuilder uses the [typestate] pattern to ensure at compile time that each required/// configuration item is provided exactly once. This is tracked in the `State` type parameter,/// which can have these values:/// - [`WantsVersions`]/// - [`WantsVerifier`]/// - [`WantsClientCert`]/// - [`WantsServerCert`]/// The other type parameter is `Side`, which is either `ServerConfig` or `ClientConfig`/// depending on whether the ConfigBuilder was built with [`ServerConfig::builder()`] or/// [`ClientConfig::builder()`]./// You won't need to write out either of these type parameters explicitly. If you write a/// correct chain of configuration calls they will be used automatically. If you write an/// incorrect chain of configuration calls you will get an error message from the compiler/// mentioning some of these types./// Additionally, ServerConfig and ClientConfig carry a private field containing a/// [`CryptoProvider`], from [`ClientConfig::builder_with_provider()`] or/// [`ServerConfig::builder_with_provider()`]. This determines which cryptographic backend/// is used. The default is [the process-default provider](`CryptoProvider::get_default`)./// [builder]: https://rust-unofficial.github.io/patterns/patterns/creational/builder.html/// [typestate]: http://cliffle.com/blog/rust-typestate//// [`ServerConfig`]: crate::ServerConfig/// [`ServerConfig::builder`]: crate::ServerConfig::builder/// [`ClientConfig`]: crate::ClientConfig/// [`ClientConfig::builder()`]: crate::ClientConfig::builder()/// [`ServerConfig::builder()`]: crate::ServerConfig::builder()/// [`ClientConfig::builder_with_provider()`]: crate::ClientConfig::builder_with_provider()/// [`ServerConfig::builder_with_provider()`]: crate::ServerConfig::builder_with_provider()/// [`ConfigBuilder<ClientConfig, WantsVerifier>`]: struct.ConfigBuilder.html#impl-3/// [`ConfigBuilder<ServerConfig, WantsVerifier>`]: struct.ConfigBuilder.html#impl-6/// [`WantsClientCert`]: crate::client::WantsClientCert/// [`WantsServerCert`]: crate::server::WantsServerCert/// [`CryptoProvider::get_default`]: crate::crypto::CryptoProvider::get_default/// [`DangerousClientConfigBuilder::with_custom_certificate_verifier`]: crate::client::danger::DangerousClientConfigBuilder::with_custom_certificate_verifiercrypto_provider/// Return the crypto provider used to construct this builder.WantsVersions/// Config builder state where the caller must supply TLS protocol versions./// For more information, see the [`ConfigBuilder`] documentation.with_safe_default_protocol_versions/// Accept the default protocol versions: both TLS1.2 and TLS1.3 are enabled.with_protocol_versionsSupportedProtocolVersion/// Use a specific set of protocol versions.EnabledVersionsclient_ech_mode/// Config builder state where the caller must supply a verifier./// Helper trait to abstract [`ConfigBuilder`] over building a [`ClientConfig`] or [`ServerConfig`].MessagePayloadrequire_handshake_msg/// For a Message $m, and a HandshakePayload enum member $payload_type,/// return Ok(payload) if $m is both a handshake message and one that/// has the given $payload_type.  If not, return Err(rustls::Error) quoting/// $handshake_type as the expected handshake type.require_handshake_msg_move/// Like require_handshake_msg, but moves the payload out of $m.inappropriate_messageinappropriate_handshake_messageclient_connResumptionResolvesClientCerthandykey_logNoKeyLogSingleCertAndKeyTLS13with_ech/// Enable Encrypted Client Hello (ECH) in the given mode./// This implicitly selects TLS 1.3 as the only supported protocol version to meet the/// requirement to support ECH./// The `ClientConfig` that will be produced by this builder will be specific to the provided/// [`crate::client::EchConfig`] and may not be appropriate for all connections made by the program./// In this case the configuration should only be shared by connections intended for domains/// that offer the provided [`crate::client::EchConfig`] in their DNS zone./// Choose how to verify server certificates./// Using this function does not configure revocation.  If you wish to/// configure revocation, instead use:/// ```diff/// - .with_root_certificates(root_store)/// + .with_webpki_verifier(/// +   WebPkiServerVerifier::builder_with_provider(root_store, crypto_provider)/// +   .with_crls(...)/// +   .build()?/// + )with_webpki_verifier/// Choose how to verify server certificates using a webpki verifier./// See [`webpki::WebPkiServerVerifier::builder`] and/// [`webpki::WebPkiServerVerifier::builder_with_provider`] for more information.dangerousDangerousClientConfigBuilder/// Access configuration options whose use is dangerous and requires/// extra care./// The underlying ClientConfigBuilder/// Accessor for dangerous configuration options.with_custom_certificate_verifier/// Set a custom certificate verifier./// Container for unsafe APIsverifier/// A config builder state where the caller needs to supply whether and how to provide a client/// certificate.with_client_auth_cert/// Sets a single certificate chain and matching private key for use/// in client authentication./// `cert_chain` is a vector of DER-encoded certificates./// `key_der` is a DER-encoded private key as PKCS#1, PKCS#8, or SEC1. The/// `aws-lc-rs` and `ring` [`CryptoProvider`][crate::CryptoProvider]s support/// all three encodings, but other `CryptoProviders` may not./// This function fails if `key_der` is invalid.with_no_client_auth/// Do not support client auth.with_client_cert_resolver/// Sets a custom [`ResolvesClientCert`].NoClientSessionStorageEchStatuscommon_stateCommonStateConnectionCoreUnbufferedConnectionCommonSupportedKxGroupKernelConnectionNamedGroupClientExtensionProtocolNamepersistExtractedSecretsSupportedCipherSuiteDefaultTimeProviderunbufferedEncryptErrorTransmitTlsDataKeyLogset_kx_hint/// Remember what `NamedGroup` the given server chose.kx_hint/// This should return the value most recently passed to `set_kx_hint`/// for the given `server_name`./// If `None` is returned, the caller chooses the first configured group,/// and an extra round trip might happen if that choice is unsatisfactory/// to the server.set_tls12_sessionTls12ClientSessionValue/// Remember a TLS1.2 session./// At most one of these can be remembered at a time, per `server_name`.tls12_session/// Get the most recently saved TLS1.2 session for `server_name` provided to `set_tls12_session`.remove_tls12_session/// Remove and forget any saved TLS1.2 session for `server_name`.insert_tls13_ticketTls13ClientSessionValue/// Remember a TLS1.3 ticket that might be retrieved later from `take_tls13_ticket`, allowing/// resumption of this session./// This can be called multiple times for a given session, allowing multiple independent tickets/// to be valid at once.  The number of times this is called is controlled by the server, so/// implementations of this trait should apply a reasonable bound of how many items are storedtake_tls13_ticket/// Return a TLS1.3 ticket previously provided to `add_tls13_ticket`./// Implementations of this trait must return each value provided to `add_tls13_ticket` _at most once_.ClientSessionStore/// A trait for the ability to store client session data, so that sessions/// can be resumed in future connections./// Generally all data in this interface should be treated as/// **highly sensitive**, containing enough key material to break all security/// of the corresponding session./// `set_`, `insert_`, `remove_` and `take_` operations are mutating; this isn't/// expressed in the type system to allow implementations freedom in/// how to achieve interior mutability.  `Mutex` is a common choice./// Resolve a client certificate chain/private key to use as the client's/// `root_hint_subjects` is an optional list of certificate authority/// subject distinguished names that the client can use to help/// decide on a client certificate the server is likely to accept. If/// the list is empty, the client should send whatever certificate it/// has. The hints are expected to be DER-encoded X.500 distinguished names,/// per [RFC 5280 A.1]. See [`DistinguishedName`] for more information/// on decoding with external crates like `x509-parser`./// `sigschemes` is the list of the [`SignatureScheme`]s the server/// Return `None` to continue the handshake without any client/// authentication.  The server may reject the handshake later/// if it requires authentication./// [RFC 5280 A.1]: https://www.rfc-editor.org/rfc/rfc5280#appendix-A.1only_raw_public_keys/// Return true if the client only supports raw public keys./// See [RFC 7250](https://www.rfc-editor.org/rfc/rfc7250).has_certs/// Return true if any certificates at all are available./// A trait for the ability to choose a certificate chain and/// private key for the purposes of client authentication.alpn_protocols/// Which ALPN protocols we include in our client hello./// If empty, no ALPN extension is sent.resumption/// How and when the client can resume a previous session./// # Sharing `resumption` between `ClientConfig`s/// In a program using many `ClientConfig`s it may improve resumption rates/// (which has a significant impact on connection performance) if those/// configs share a single `Resumption`./// However, resumption is only allowed between two `ClientConfig`s if their/// `client_auth_cert_resolver` (ie, potential client authentication credentials)/// and `verifier` (ie, server certificate verification settings) are/// the same (according to `Arc::ptr_eq`)./// To illustrate, imagine two `ClientConfig`s `A` and `B`.  `A` fully validates/// the server certificate, `B` does not.  If `A` and `B` shared a resumption store,/// it would be possible for a session originated by `B` to be inserted into the/// store, and then resumed by `A`.  This would give a false impression to the user/// of `A` that the server certificate is fully validated./// The maximum size of plaintext input to be emitted in a single TLS record./// A value of None is equivalent to the [TLS maximum] of 16 kB./// rustls enforces an arbitrary minimum of 32 bytes for this field./// Out of range values are reported as errors from [ClientConnection::new]./// Setting this value to a little less than the TCP MSS may improve latency/// for stream-y workloads./// [TLS maximum]: https://datatracker.ietf.org/doc/html/rfc8446#section-5.1/// [ClientConnection::new]: crate::client::ClientConnection::newclient_auth_cert_resolver/// How to decide what client auth certificate/keys to use.enable_sni/// Whether to send the Server Name Indication (SNI) extension/// during the client handshake./// The default is true./// How to output key material for debugging.  The default/// does nothing.enable_secret_extraction/// Allows traffic secrets to be extracted after the handshake,/// e.g. for kTLS setup.enable_early_data/// Whether to send data on the first flight ("early data") in/// TLS 1.3 handshakes.require_ems/// If set to `true`, requires the server to support the extended/// master secret extraction method defined in [RFC 7627]./// The default is `true` if the `fips` crate feature is enabled,/// It must be set to `true` to meet FIPS requirement mentioned in section/// **D.Q Transition of the TLS 1.2 KDF to Support the Extended Master/// Secret** from [FIPS 140-3 IG.pdf]./// [RFC 7627]: https://datatracker.ietf.org/doc/html/rfc7627/// [FIPS 140-3 IG.pdf]: https://csrc.nist.gov/csrc/media/Projects/cryptographic-module-validation-program/documents/fips%20140-3/FIPS%20140-3%20IG.pdf/// Provides the current system time/// Source of randomness and other crypto./// Supported versions, in no particular order.  The default/// is all supported versions./// How to verify the server certificate chain.cert_decompressorsCertDecompressor/// How to decompress the server's certificate chain./// If this is non-empty, the [RFC8779] certificate compression/// extension is offered, and any compressed certificates are/// transparently decompressed during the handshake./// This only applies to TLS1.3 connections.  It is ignored for/// TLS1.2 connections./// [RFC8779]: https://datatracker.ietf.org/doc/rfc8879/cert_compressorsCertCompressor/// How to compress the client's certificate chain./// If a server supports this extension, and advertises support/// for one of the compression algorithms included here, the/// client certificate will be compressed according to [RFC8779].cert_compression_cacheCompressionCache/// Caching for compressed certificates./// This is optional: [`compress::CompressionCache::Disabled`] gives/// a cache that does no caching.ech_mode/// How to offer Encrypted Client Hello (ECH). The default is to not offer ECH./// Common configuration for (typically) all connections made by a program./// Making one of these is cheap, though one of the inputs may be expensive: gathering trust roots/// from the operating system to add to the [`RootCertStore`] passed to `with_root_certificates()`/// (the rustls-native-certs crate is often used for this) may take on the order of a few hundred/// milliseconds./// These must be created via the [`ClientConfig::builder()`] or [`ClientConfig::builder_with_provider()`]/// Note that using [`ConfigBuilder<ClientConfig, WantsVersions>::with_ech()`] will produce a common/// configuration specific to the provided [`crate::client::EchConfig`] that may not be appropriate/// for all connections made by the program. In this case the configuration should only be shared/// by connections intended for domains that offer the provided [`crate::client::EchConfig`] in/// their DNS zone./// # Defaults/// * [`ClientConfig::max_fragment_size`]: the default is `None` (meaning 16kB)./// * [`ClientConfig::resumption`]: supports resumption with up to 256 server names, using session///   ids or tickets, with a max of eight tickets per server./// * [`ClientConfig::alpn_protocols`]: the default is empty -- no ALPN protocol is negotiated./// * [`ClientConfig::key_log`]: key material is not logged./// * [`ClientConfig::cert_decompressors`]: depends on the crate features, see [`compress::default_cert_decompressors()`]./// * [`ClientConfig::cert_compressors`]: depends on the crate features, see [`compress::default_cert_compressors()`]./// * [`ClientConfig::cert_compression_cache`]: caches the most recently used 4 compressions/// [`RootCertStore`]: crate::RootCertStore/// Create a builder for a client configuration with/// [the process-default `CryptoProvider`][CryptoProvider#using-the-per-process-default-cryptoprovider]/// and safe protocol version defaults.builder_with_protocol_versions/// and the provided protocol versions./// Panics if/// - the supported versions are not compatible with the provider (eg.///   the combination of ciphersuites supported by the provider and supported///   versions lead to zero cipher suites being usable),/// - if a `CryptoProvider` cannot be resolved using a combination of///   the crate features and process default.builder_with_provider/// Create a builder for a client configuration with a specific [`CryptoProvider`]./// This will use the provider's configured ciphersuites. You must additionally choose/// which protocol versions to enable, using `with_protocol_versions` or/// `with_safe_default_protocol_versions` and handling the `Result` in case a protocol/// version is not supported by the provider's ciphersuites.builder_with_details/// Create a builder for a client configuration with no default implementation details./// This API must be used by `no_std` users./// You must provide a specific [`TimeProvider`]./// You must provide a specific [`CryptoProvider`].fips/// Return true if connections made with this `ClientConfig` will/// operate in FIPS mode./// This is different from [`CryptoProvider::fips()`]: [`CryptoProvider::fips()`]/// is concerned only with cryptography, whereas this _also_ covers TLS-level/// configuration that NIST recommends, as well as ECH HPKE suites if applicable./// Return the crypto provider used to construct this client configuration.DangerousClientConfigsupports_version/// We support a given TLS version if it's quoted in the configured/// versions *and* at least one ciphersuite for this version is/// also configured.supports_protocolfind_cipher_suitefind_kx_groupcurrent_time/// How we store session data or tickets. The default is to use an in-memory/// [super::handy::ClientSessionMemoryCache].tls12_resumptionTls12Resumption/// What mechanism is used for resuming a TLS 1.2 session./// Configuration for how/when a client is allowed to resume a previous session.in_memory_sessions/// Create a new `Resumption` that stores data for the given number of sessions in memory./// This is the default `Resumption` choice, and enables resuming a TLS 1.2 session with/// a session id or RFC 5077 ticket./// Use a custom [`ClientSessionStore`] implementation to store sessions./// By default, enables resuming a TLS 1.2 session with a session id or RFC 5077 ticket./// Disable all use of session resumption./// Configure whether TLS 1.2 sessions may be resumed, and by what mechanism./// This is meaningless if you've disabled resumption entirely, which is the case in `no-std`/// Create an in-memory session store resumption with up to 256 server names, allowing/// a TLS 1.2 session to resume with a session id or RFC 5077 ticket./// Disable 1.2 resumption.SessionIdOnly/// Support 1.2 resumption using session ids only.SessionIdOrTickets/// Support 1.2 resumption using session ids or RFC 5077 tickets./// See[^1] for why you might like to disable RFC 5077 by instead choosing the `SessionIdOnly`/// option. Note that TLS 1.3 tickets do not have those issues./// [^1]: <https://words.filippo.io/we-need-to-talk-about-session-tickets/>/// What mechanisms to support for resuming a TLS 1.2 session./// The underlying ClientConfigset_certificate_verifier/// Overrides the default `ServerCertVerifier` with something else.EarlyDataStateAcceptedAcceptedFinishedRejectedEarlyDatais_acceptedrejectedcheck_write_optClientConnectionDataConnectionCommonsessClientConnectionWriteEarlyData/// Stub that implements io::Write and dispatches to `write_early_data`./// How many bytes you may send.  Writes will become short/// once this reaches zero.check_write/// This represents a single TLS client connection./// Make a new ClientConnection.  `config` controls how/// we behave in the TLS protocol, `name` is the/// name of the server we want to talk to.new_with_alpn/// Make a new ClientConnection with custom ALPN protocols.early_data/// Returns an `io::Write` implementer you can write bytes to/// to send TLS1.3 early data (a.k.a. "0-RTT data") to the server./// This returns None in many circumstances when the capability to/// send early data is not available, including but not limited to:/// - The server hasn't been talked to previously./// - The server does not support resumption./// - The server does not support early data./// - The resumption data for the server has expired./// The server specifies a maximum amount of early data.  You can/// learn this limit through the returned object, and writes through/// it will process only this many bytes./// The server can choose not to accept any sent early data --/// in this case the data is lost but the connection continues.  You/// can tell this happened using `is_early_data_accepted`.is_early_data_accepted/// Returns True if the server signalled it will process early data./// If you sent early data and this returns false at the end of the/// handshake then the server will not process the data.  This/// is not an error, but you may wish to resend the data.dangerous_extract_secrets/// Extract secrets, so they can be used when configuring kTLS, for example./// Should be used with care as it exposes secret key material.ech_status/// Return the connection's Encrypted Client Hello (ECH) status.tls13_tickets_received/// Returns the number of TLS1.3 tickets that have been received./// Return true if the connection was made with a `ClientConfig` that is FIPS compatible./// This is different from [`crate::crypto::CryptoProvider::fips()`]:/// it is concerned only with cryptography, whereas this _also_ covers TLS-levelfor_clientUnbufferedClientConnection/// Unbuffered version of `ClientConnection`/// See the [`crate::unbuffered`] module docs for more details/// Make a new ClientConnection. `config` controls how we behave in the TLS protocol, `name` is/// the name of the server we want to talk to./// Make a new UnbufferedClientConnection with custom ALPN protocols."dangerous_extract_secrets() does not support session tickets or \
                    key updates, use dangerous_into_kernel_connection() instead"dangerous_into_kernel_connection/// Extract secrets and a [`KernelConnection`] object./// This allows you use rustls to manage keys and then manage encryption and/// decryption yourself (e.g. for kTLS)./// See the [`crate::kernel`] documentations for details on prerequisites/// for calling this method.may_encrypt_early_dataMayEncryptEarlyData/// returns an adapter that allows encrypting early (RTT-0) data before transmitting the/// already encoded TLS data/// IF allowed by the protocol/// Allows encrypting early (RTT-0) dataEarlyDataError/// Encrypts `application_data` into the `outgoing_tls` buffer/// returns the number of bytes that were written into `outgoing_tls`, or an error if/// the provided buffer was too small. In the error case, `outgoing_tls` is not modifiedExceededAllowedEarlyData/// Cannot encrypt more early data due to imposed limits/// Encryption error/// Errors that may arise when encrypting early (RTT-0) data/// State associated with a client connection.SideDataCertificateChainServerExtensioncert_chainocsp_responseServerCertDetailssent_extensionsextension_order_seedoffered_cert_compressionClientHelloDetailsserver_sent_unsolicited_extensionsClientAuthDetailsauth_context_tls13/// Send an empty `Certificate` and no `CertificateVerify`.certkeysigner/// Send a non-empty `Certificate` and a `CertificateVerify`.EchConfigListBytesTLS_EMPTY_RENEGOTIATION_INFO_SCSVtls13hpkeEncapsulatedSecretHpkeHpkePublicKeyHpkeSealerHpkeSuitehash_hsHandshakeHashHandshakeHashBufferPayloadU16HpkeKemClientHelloPayloadEchConfigContentsEchConfigPayloadEncryptedClientHelloEncryptedClientHelloOuterHandshakeMessagePayloadHandshakePayloadHelloRetryRequestHpkeKeyConfigHpkeSymmetricCipherSuitePresharedKeyBinderPresharedKeyOfferServerHelloPayloadServerNamePayloadRetrievedkey_scheduleKeyScheduleEarlyKeyScheduleHandshakeStartserver_ech_hrr_confirmation_secretEncryptedClientHelloErrorPeerIncompatiblePeerMisbehavedTls13CipherSuiteEchConfig/// ECH is enabled and the ClientHello will be encrypted based on the providedEchGreaseConfigGrease/// No ECH configuration is available but the client should act as though it were./// This is an anti-ossification measure, sometimes referred to as "GREASE"[^0]./// [^0]: <https://www.rfc-editor.org/rfc/rfc8701>/// Controls how Encrypted Client Hello (ECH) is used in a client handshake./// Returns true if the ECH mode will use a FIPS approved HPKE suite./// The selected EchConfig./// An HPKE instance corresponding to a suite from the `config` we have selected as/// a compatible choice./// Configuration for performing encrypted client hello./// Note: differs from the protocol-encoded EchConfig (`EchConfigMsg`)./// Construct an EchConfig by selecting a ECH config from the provided bytes that is compatible/// with one of the given HPKE suites./// The config list bytes should be sourced from a DNS-over-HTTPS lookup resolving the `HTTPS`/// resource record for the host name of the server you wish to connect via ECH,/// and extracting the ECH configuration from the `ech` parameter. The extracted bytes should/// be base64 decoded to yield the `EchConfigListBytes` you provide to rustls./// One of the provided ECH configurations must be compatible with the HPKE provider's supported/// suites or an error will be returned./// See the [`ech-client.rs`] example for a complete example of fetching ECH configs from DNS./// [`ech-client.rs`]: https://github.com/rustls/rustls/blob/main/examples/src/bin/ech-client.rshpke_info/// Compute the HPKE `SetupBaseS` `info` parameter for this ECH configuration./// See <https://datatracker.ietf.org/doc/html/draft-ietf-tls-esni-17#section-6.1>.placeholder_key/// Configuration for GREASE Encrypted Client Hello./// Construct a GREASE ECH configuration./// This configuration is used when the client wishes to offer ECH to prevent ossification,/// but doesn't have a real ECH configuration to use for the remote server. In this case/// a placeholder or "GREASE"[^0] extension is used./// Returns an error if the HPKE provider does not support the given suite.grease_ext/// Build a GREASE ECH extension based on the placeholder configuration./// See <https://datatracker.ietf.org/doc/html/draft-ietf-tls-esni-18#name-grease-ech> forNotOffered/// ECH was not offered - it is a normal TLS handshake./// GREASE ECH was sent. This is not considered offering ECH.Offered/// ECH was offered but we do not yet know whether the offer was accepted or rejected./// ECH was offered and the server accepted./// ECH was offered and the server rejected./// An enum representing ECH offer status.outer_name// The public DNS name from the ECH configuration we've chosen - this is included as the SNI// value for the "outer" client hello. It can only be a DnsName, not an IP address.early_data_key_schedule// If we're resuming in the inner hello, this is the early key schedule to use for encrypting// early data if the ECH offer is accepted.inner_hello_random// A random value we use for the inner hello.inner_hello_transcript// A transcript buffer maintained for the inner hello. Once ECH is confirmed we switch to// using this transcript for the handshake.secure_random// A source of secure random data.// An HPKE sealer context that can be used for encrypting ECH data.config_id// The ID of the ECH configuration we've chosen - this is included in the outer ECH extension.inner_name// The private server name we'll use for the inner protected hello.// The advertised maximum name length from the ECH configuration we've chosen - this is used// for padding calculations.// A supported symmetric cipher suite from the ECH configuration we've chosen - this is// included in the outer ECH extension.// A secret encapsulated to the public key of the remote server. This is included in the// outer ECH extension for non-retry outer hello messages.// Whether the inner client hello should contain a server name indication (SNI) extension.// The extensions sent in the inner hello.EchState/// Contextual data for a TLS client handshake that has offered encrypted client hello (ECH).ech_hello/// Construct a ClientHelloPayload offering ECH./// An outer hello, with a protected inner hello for the `inner_name` will be returned, and the/// ECH context will be updated to reflect the inner hello that was offered./// If `retry_req` is `Some`, then the outer hello will be constructed for a hello retry request./// If `resuming` is `Some`, then the inner hello will be constructed for a resumption handshake.confirm_acceptanceEchAccepted/// Confirm whether an ECH offer was accepted based on examining the server hello.confirm_hrr_acceptancetranscript_hrr_update/// Update the ECH context inner hello transcript based on a received hello retry request message./// This will start the in-progress transcript using the given `hash`, convert it into an HRR/// buffer, and then add the hello retry message `m`.encode_inner_hello// 5.1 "Encoding the ClientHelloInner"grease_psk// See https://datatracker.ietf.org/doc/html/draft-ietf-tls-esni-18#name-grease-pskserver_hello_confhello_retry_request_confech_conf_messagetranscript/// Returned from EchState::check_acceptance when the server has accepted the ECH offer./// Holds the state required to continue the handshake with the inner hello from the ECH offer.fatal_alert_required/// An implementer of `ClientSessionStore` which does nothing.limited_cacheMAX_TLS13_TICKETS_PER_SERVERtls12// Zero or one TLS1.2 sessions.// Up to MAX_TLS13_TICKETS_PER_SERVER TLS1.3 tickets, oldest first.ServerDataserversLimitedCacheClientSessionMemoryCache/// An implementer of `ClientSessionStore` that stores everything/// in memory./// It enforces a limit on the number of entries to bound memory usage./// Make a new ClientSessionMemoryCache.  `size` is the/// maximum number of stored sessions.FailResolveClientCertAlwaysResolvesClientRawPublicKeys/// An exemplar `ResolvesClientCert` implementation that always resolves to a single/// [RFC 7250] raw public key./// [RFC 7250]: https://tools.ietf.org/html/rfc7250/// Create a new `AlwaysResolvesClientRawPublicKeys` instance./// Returns true if the resolver is ready to present an identity./// Even though the function is called `has_certs`, it returns true/// although only an RPK (Raw Public Key) is available, not an actual certificate.macro_rules_attributetest_noclientsessionstorage_does_nothingDummyServerCertVerifierDummyResolvesClientCertbs_debugechHandshakeKindKxStateConnectionRandomsActiveKeyExchangeKeyExchangeAlgorithmCertificateTypeECPointFormatPskKeyExchangeModeCertificateStatusRequestClientSessionTicketHasServerExtensionsKeyShareEntrySupportedProtocolVersionsNextStateNextStateOrErrorClientContextfind_sessionClientSessionValuestart_handshakeClientHelloInputtranscript_buffer// The key schedule for sending early data.// If the server accepts the PSK used for early data then// this is used to compute the rest of the key schedule.// Otherwise, it is thrown away.// If this is `None` then we do not support early data.offered_key_shareech_stateExpectServerHelloextra_extsExpectServerHelloOrHelloRetryRequestresumingusing_emssent_tls13_fake_ccsprev_ech_extemit_client_hello_for_retry/// Emits the initial ClientHello or a ClientHello in response to/// a HelloRetryRequest./// `retryreq` and `suite` are `None` if this is the initial/// ClientHello.prepare_resumption/// Prepares `exts` and `cx` with TLS 1.2 or TLS 1.3 session/// resumption./// - `suite` is `None` if this is the initial ClientHello, or///   `Some` if we're retrying in response to///   a HelloRetryRequest./// This function will push onto `exts` to/// (a) request a new ticket if we don't have one,/// (b) send our TLS 1.2 ticket after retrieving an 1.2 session,/// (c) send a request for 1.3 early data if allowed and/// (d) send a 1.3 preshared key if we have one./// It returns the TLS 1.3 PSKs, if any, for further processing.process_alpn_protocolprocess_server_cert_type_extensionprocess_client_cert_type_extensioninto_expect_server_hellohandle_hello_retry_requestprocess_cert_type_extensionTls13Tls12ClientSessionCommoncompatible_configlow_quality_integer_hashHelloRetryExtensionOutboundOpaqueMessageMessageEncrypterOkmBlockPayloadU8ECCurveTypeEcParametersServerEcdhParamsServerKeyExchangeParamsServerKeyExchangePayloadPlainMessagederive_traffic_ivderive_traffic_keytest_no_session_ticket_request_on_tls_1_3/// Tests that session_ticket(35) extension/// is not sent if the client does not support TLS 1.2.test_no_renegotiation_scsv_on_tls_1_3test_client_does_not_offer_sha1test_client_rejects_hrr_with_varied_session_idtest_client_rejects_no_extended_master_secret_extension_when_require_ems_or_fipscas_extension_in_client_hello_if_server_verifier_requests_ittest_client_with_custom_verifier_can_accept_ecdsa_sha1_signatures/// Regression test for <https://github.com/seanmonstar/reqwest/issues/2191>seen_sha1_signatureExpectSha1EcdsaVerifiertest_client_requiring_rpk_rejects_server_that_only_offers_x509_id_by_omissiontest_client_requiring_rpk_rejects_server_that_only_offers_x509_idtest_client_requiring_rpk_rejects_server_that_only_demands_x509_by_omissiontest_client_requiring_rpk_rejects_server_that_only_demands_x509test_client_requiring_rpk_accepts_rpk_serverclient_requiring_rpk_receives_server_eeclient_config_for_rpkclient_certified_keyclient_keyx25519_providerServerVerifierWithAuthorityNamesroot_hint_subjectsServerVerifierRequiringRpkrequires_raw_public_keysserver_handshake_secretFakeServerCryptoserver_handshake_encrypterwill_logclient_hello_sent_for_configserver_helloCompleteServerHelloHandlingConnectionTrafficSecretsKernelContextKernelStateInvalidMessageccsChangeCipherSpecPayloadClientDhParamsClientEcdhParamsClientKeyExchangeParamsNewSessionTicketPayloadNewSessionTicketPayloadTls13PartiallyExtractedSecretsConnectionSecretsTls12CipherSuiteresuming_sessionrandomshandle_server_hellomay_send_cert_statusmust_issue_new_ticketExpectCertificateserver_cert_chainExpectCertificateStatusOrServerKxExpectCertificateStatusserver_certExpectServerKxemit_certificateemit_client_kxemit_certverifyemit_ccsemit_finishedkx_paramskx_sigServerKxDetailsserver_kxExpectServerDoneOrCertReq// --- Either a CertificateRequest, or a ServerHelloDone. ---// Existence of the CertificateRequest tells us the server is asking for// client auth.  Otherwise we go straight to ServerHelloDone.ExpectCertificateRequestExpectServerDonesecretscert_verifiedsig_verifiedExpectNewTicketticketExpectCcs// -- Waiting for their CCS --ExpectFinishedsave_session// -- Waiting for their finished --handle_decrypt_error// we could not decrypt the encrypted handshake message with session resumption// this might mean that the ticket was invalid for some reason, so we remove it// from the store to restart a session from scratch_cert_verified_sig_verified_fin_verifiedFinishedMessageVerifiedExpectTraffic// -- Traffic transit state --extract_secretsinto_external_stateupdate_secretshandle_new_session_ticketHandshakeFlightTls13KeyUpdateRequestCERTIFICATE_MAX_SIZE_LIMITCertificatePayloadTls13PresharedKeyIdentityKeyScheduleHandshakeKeySchedulePreHandshakeKeyScheduleTrafficResumptionSecretconstruct_client_verify_messageconstruct_server_verify_messageALLOWED_PLAINTEXT_EXTS// Extensions we expect in plaintext in the ServerHello.DISALLOWED_TLS13_EXTS// Only the intersection of things we offer, and those disallowed// in TLS1.3/// `early_data_key_schedule` is `Some` if we sent the/// "early_data" extension to the server.KeyExchangeChoiceWhole/// Decide between `our_key_share` or `our_key_share.hybrid_component()`/// based on the selection of the server expressed in `their_key_share`.validate_server_helloinitial_key_sharefill_in_psk_binder/// This implements the horrifying TLS1.3 hack where PSK binders have a/// data dependency on the message they are contained within.derive_early_traffic_secretemit_fake_ccsvalidate_encrypted_extensionsExpectEncryptedExtensionsech_retry_configsExpectCertificateOrCompressedCertificateOrCertReqExpectCertificateOrCompressedCertificateExpectCertificateOrCertReq// TLS1.3 version of CertificateRequest handling.  We then move to expecting the server// Certificate. Unfortunately the CertificateRequest type changed in an annoying way// in TLS1.3.ExpectCompressedCertificatemessage_already_in_transcriptExpectCertificateVerify// --- TLS1.3 CertificateVerify ---emit_compressed_certificate_tls13emit_certificate_tls13emit_certverify_tls13emit_finished_tls13emit_end_of_early_data_tls13session_storage// -- Traffic transit state (TLS1.3) --// In this state we can be sent tickets, key updates,// and application data.handle_new_ticket_implhandle_new_ticket_tls13handle_key_updatesend_key_update_requestExpectQuicTrafficAlertMessagePayloadfragmenterMessageFragmenterOutboundChunksOutboundPlainMessagePreEncryptActionInsufficientSizeErrorvecbufChunkVecBuffernegotiated_versionhandshake_kindkx_statealpn_protocolaligned_handshakemay_send_application_datamay_receive_application_dataearly_trafficsent_fatal_alerthas_sent_close_notify/// If we signaled end of stream.has_received_close_notify/// If the peer has signaled end of stream.has_seen_eofmessage_fragmenterreceived_plaintextsendable_tlsqueued_key_update_message/// Protocol whose key schedule should be used. Unused for TLS < 1.3.Quictemper_countersTemperCountersrefresh_traffic_keys_pending/// Connection state common to both client and server connections.wants_write/// Returns true if the caller should call [`Connection::write_tls`] as soon as possible./// [`Connection::write_tls`]: crate::Connection::write_tls/// Returns true if the connection is currently performing the TLS handshake./// During this time plaintext written to the connection is buffered in memory. After/// [`Connection::process_new_packets()`] has been called, this might start to return `false`/// while the final handshake packets still need to be extracted from the connection's buffers./// [`Connection::process_new_packets()`]: crate::Connection::process_new_packets/// Retrieves the certificate chain or the raw public key used by the peer to authenticate./// The order of the certificate chain is as it appears in the TLS/// protocol: the first certificate relates to the peer, the/// second certifies the first, the third certifies the second, and/// When using raw public keys, the first and only element is the raw public key./// This is made available for both full and resumed handshakes./// For clients, this is the certificate chain or the raw public key of the server./// For servers, this is the certificate chain or the raw public key of the client,/// if client authentication was completed./// The return value is None until this value is available./// Note: the return type of the 'certificate', when using raw public keys is `CertificateDer<'static>`/// even though this should technically be a `SubjectPublicKeyInfoDer<'static>`./// This choice simplifies the API and ensures backwards compatibility./// Retrieves the protocol agreed with the peer via ALPN./// A return value of `None` after handshake completion/// means no protocol was agreed (because no protocols/// were offered or accepted by the peer).negotiated_cipher_suite/// Retrieves the ciphersuite agreed with the peer./// This returns None until the ciphersuite is agreed.negotiated_key_exchange_group/// Retrieves the key exchange group agreed with the peer./// This function may return `None` depending on the state of the connection,/// the type of handshake, and the protocol version./// If [`CommonState::is_handshaking()`] is true this function will return `None`./// Similarly, if the [`CommonState::handshake_kind()`] is [`HandshakeKind::Resumed`]/// and the [`CommonState::protocol_version()`] is TLS 1.2, then no key exchange will have/// occurred and this function will return `None`./// Retrieves the protocol version agreed with the peer./// This returns `None` until the version is agreed./// Which kind of handshake was performed./// This tells you whether the handshake was a resumption or not./// This will return `None` before it is known which sort of/// handshake occurred.is_tls13process_main_protocolwrite_plaintextcheck_aligned_handshake// Changing the keys must not span any fragmented handshake// messages.  Otherwise the defragmented messages will have// been protected with two different record layer protections,// which is illegal.  Not mentioned in RFC.send_msg_encrypt/// Fragment `m`, encrypt the fragments, and then queue/// the encrypted fragments for sending.send_appdata_encrypt/// Like send_msg_encrypt, but operate on an appdata directly.send_single_fragmentsend_plain_non_bufferingstart_outgoing_traffic/// Mark the connection as ready to send application data./// Also flush `sendable_plaintext` if it is `Some`.start_traffic/// Mark the connection as ready to send and receive application data.flush_plaintext/// Send any buffered plaintext.  Plaintext is buffered if/// written during handshake.queue_tls_message// Put m into sendable_tls for writing.perhaps_write_key_update/// Send a raw TLS message, fragmenting it if needed.take_received_plaintextstart_encryption_tls12missing_extensionsend_warning_alertprocess_alertsend_cert_verify_error_alertsend_fatal_alertsend_close_notify/// Queues a `close_notify` warning alert to be sent in the next/// [`Connection::write_tls`] call.  This informs the peer that the/// connection is being closed./// Does nothing if any `close_notify` or fatal alert was already sent.eager_send_close_notifysend_warning_alert_no_logcheck_required_sizewrite_fragmentsset_max_fragment_sizeget_alpn_protocolwants_read/// Returns true if the caller should call [`Connection::read_tls`] as soon/// If there is pending plaintext data to read with [`Connection::reader`],/// this returns false.  If your application respects this mechanism,/// only one full TLS message will be buffered by rustls./// [`Connection::reader`]: crate::Connection::reader/// [`Connection::read_tls`]: crate::Connection::read_tlscurrent_io_stateIoStateis_quicshould_update_keyenqueue_key_update_notificationreceived_tls13_change_cipher_specbuffer_plaintext/// Send plaintext application data, fragmenting and/// encrypting it as it goes out./// If internal buffers are too small, this function will not accept/// all the data.send_early_plaintextsend_plain/// Encrypt and send some plaintext `data`.  `limit` controls/// whether the per-connection buffer limits apply./// Returns the number of bytes written from `data`: this might/// be less than `data.len()` if buffer limits were exceeded./// A full handshake./// This is the typical TLS connection initiation process when resumption is/// not yet unavailable, and the initial `ClientHello` was accepted by the server.FullWithHelloRetryRequest/// A full TLS1.3 handshake, with an extra round-trip for a `HelloRetryRequest`./// The server can respond with a `HelloRetryRequest` if the initial `ClientHello`/// is unacceptable for several reasons, the most likely if no supported key/// shares were offered by the client./// A resumed handshake./// Resumed handshakes involve fewer round trips and less cryptography than/// full ones, but can only happen when the peers have previously done a full/// handshake together, and then remember data about it./// Describes which sort of handshake happened.tls_bytes_to_writeplaintext_bytes_to_readpeer_has_closed/// Values of this structure are returned from [`Connection::process_new_packets`]/// and tell the caller the current I/O state of the TLS connection./// [`Connection::process_new_packets`]: crate::Connection::process_new_packets/// How many bytes could be written by [`Connection::write_tls`] if called/// right now.  A non-zero value implies [`CommonState::wants_write`]./// How many plaintext bytes could be obtained via [`std::io::Read`]/// without further I/O./// True if the peer has sent us a close_notify alert.  This is/// the TLS mechanism to securely half-close a TLS connection,/// and signifies that the peer will not send any further data/// on this connection./// This is also signalled via returning `Ok(0)` from/// [`std::io::Read`], after all the received bytes have been/// retrieved.sendable_plaintext/// Buffered plaintext. This is `Some` if any plaintext was written during handshake and `None`/// A client initiates the connection./// A server waits for a client to connect./// Side of the connection.allowed_warning_alertsallowed_renegotiation_requestsallowed_key_update_requestsallowed_middlebox_ccs/// Tracking technically-allowed protocol actions/// that we limit to avoid denial-of-service vectors.received_warning_alertreceived_renegotiation_requestreceived_key_update_requestHandshakeFlightHandshakeFlightTls12DEFAULT_RECEIVED_PLAINTEXT_LIMITDEFAULT_BUFFER_LIMITCertificateCompressionAlgorithmPayloadU24CompressedCertificatePayloaddefault_cert_decompressors/// Returns the supported `CertDecompressor` implementations enabled/// by crate features.DecompressionFailed/// Decompress `input`, writing the result to `output`./// `output` is sized to match the declared length of the decompressed data./// `Err(DecompressionFailed)` should be returned if decompression produces more, or fewer/// bytes than fit in `output`, or if the `input` is in any way malformed./// Which algorithm this decompressor handles./// An available certificate decompression algorithm.default_cert_compressors/// Returns the supported `CertCompressor` implementations enabledCompressionFailed/// Compress `input`, returning the result./// `input` is consumed by this function so (if the underlying implementation/// supports it) the compression can be performed in-place./// `level` is a hint as to how much effort to expend on the compression./// `Err(CompressionFailed)` may be returned for any reason./// Which algorithm this compressor handles./// An available certificate compression algorithm./// This compression is happening interactively during a handshake./// Implementations may wish to choose a conservative compression level.Amortized/// The compression may be amortized over many connections./// Implementations may wish to choose an aggressive compression level./// A hint for how many resources to dedicate to a compression./// A content-less error for when `CertDecompressor::decompress` fails./// A content-less error for when `CertCompressor::compress` fails./// No caching happens, and compression happens each time using/// `CompressionLevel::Interactive`.CompressionCacheInner/// Compressions are stored in an LRU cache./// An LRU cache for compressions./// The prospect of being able to reuse a given compression for many connections/// means we can afford to spend more time on that compression (by passing/// `CompressionLevel::Amortized` to the compressor)./// Maximum size of underlying storage.CompressionCacheEntry/// LRU-order entries./// First is least-used, last is most-used./// Innards of an enabled CompressionCache./// You cannot make one of these directly. Use [`CompressionCache::new`]./// Make a `CompressionCache` that stores up to `size` compressed/// certificate messages.compression_for/// Return a `CompressionCacheEntry`, which is an owning/// wrapper for a `CompressedCertificatePayload`./// `compressor` is the compression function we have negotiated./// `original` is the uncompressed certificate message.compression_for_impluncached_compression/// Compress `original` using `compressor` at `Interactive` level.// cache key is algorithm + original:// cache value is compression result:compressed_cert_payload//! Certificate compression and decompression support//! This crate supports compression and decompression everywhere//! certificates are used, in accordance with [RFC8879][rfc8879].//! Note that this is only supported for TLS1.3 connections.//! # Getting started//! Build this crate with the `brotli` and/or `zlib` crate features.  This//! adds dependencies on these crates.  They are used by default if enabled.//! We especially recommend `brotli` as it has the widest deployment so far.//! # Custom compression/decompression implementations//! 1. Implement the [`CertCompressor`] and/or [`CertDecompressor`] traits//! 2. Provide those to://!   - [`ClientConfig::cert_compressors`][cc_cc] or [`ServerConfig::cert_compressors`][sc_cc].//!   - [`ClientConfig::cert_decompressors`][cc_cd] or [`ServerConfig::cert_decompressors`][sc_cd].//! These are used in these circumstances://! | Peer | Client authentication | Server authentication |//! | ---- | --------------------- | --------------------- |//! | *Client* | [`ClientConfig::cert_compressors`][cc_cc] | [`ClientConfig::cert_decompressors`][cc_cd] |//! | *Server* | [`ServerConfig::cert_decompressors`][sc_cd] | [`ServerConfig::cert_compressors`][sc_cc] |//! [rfc8879]: https://datatracker.ietf.org/doc/html/rfc8879//! [cc_cc]: crate::ClientConfig::cert_compressors//! [sc_cc]: crate::ServerConfig::cert_compressors//! [cc_cd]: crate::ClientConfig::cert_decompressors//! [sc_cd]: crate::ServerConfig::cert_decompressors/// A kernel connection./// This does not directly wrap a kernel connection, rather it gives you the/// minimal interfaces you need to implement a well-behaved TLS connection on/// top of kTLS./// See the [`crate::kernel`] module docs for more details.update_tx_secret/// Update the traffic secret used for encrypting messages sent to the peer./// Returns the new traffic secret and initial sequence number to use./// In order to use the new secret you should send a TLS 1.3 key update to/// the peer and then use the new traffic secrets to encrypt any future/// messages./// Note that it is only possible to update the traffic secrets on a TLS 1.3/// connection. Attempting to do so on a non-TLS 1.3 connection will result/// in an error.update_rx_secret/// Update the traffic secret used for decrypting messages received from the/// peer./// You should call this method once you receive a TLS 1.3 key update message/// from the peer./// Handle a `new_session_ticket` message from the peer./// This will register the session ticket within with rustls so that it can/// be used to establish future TLS connections./// # Getting the right payload/// This method expects to be passed the inner payload of the handshake/// message. This means that you will need to parse the header of the/// handshake message in order to determine the correct payload to pass in./// The message format is described in [RFC 8446 section 4][0]. `payload`/// should not include the `msg_type` or `length` fields./// Code to parse out the payload should look something like this/// use rustls::{ContentType, HandshakeType};/// use rustls::kernel::KernelConnection;/// use rustls::client::ClientConnectionData;/// # fn doctest(conn: &mut KernelConnection<ClientConnectionData>, typ: ContentType, message: &[u8]) -> Result<(), rustls::Error> {/// let conn: &mut KernelConnection<ClientConnectionData> = // .../// #   conn;/// let typ: ContentType = // .../// #   typ;/// let mut message: &[u8] = // .../// #   message;/// // Processing for other messages not included in this example/// assert_eq!(typ, ContentType::Handshake);/// // There may be multiple handshake payloads within a single handshake message./// while !message.is_empty() {///     let (typ, len, rest) = match message {///         &[typ, a, b, c, ref rest @ ..] => (///             HandshakeType::from(typ),///             u32::from_be_bytes([0, a, b, c]) as usize,///             rest///         _ => panic!("error handling not included in this example")///     // Processing for other messages not included in this example.///     assert_eq!(typ, HandshakeType::NewSessionTicket);///     assert!(rest.len() >= len, "invalid handshake message");///     let (payload, rest) = rest.split_at(len);///     message = rest;///     conn.handle_new_session_ticket(payload)?;/// This method will return an error if:/// - This connection is not a TLS 1.3 connection (in TLS 1.2 session tickets///   are sent as part of the handshake)./// - The provided payload is not a valid `new_session_ticket` payload or has///   extra unparsed trailing data./// - An error occurs while the connection updates the session ticket store./// [0]: https://datatracker.ietf.org/doc/html/rfc8446#section-4/// Update the traffic secret for the specified direction on the connection./// Handle a new session ticket./// This will only ever be called for client connections, as [`KernelConnection`]/// only exposes the relevant API for client connections.Receive//! Kernel connection API.//! This module gives you the bare minimum you need to implement a TLS connection//! that does its own encryption and decryption while still using rustls to manage//! connection secrets and session tickets. It is intended for use cases like kTLS//! where you want to use rustls to establish the connection but want to use//! something else to do the encryption/decryption after that.//! There are only two things that [`KernelConnection`] is able to do://! 1. Compute new traffic secrets when a key update occurs.//! 2. Save received session tickets sent by a server peer.//! That's it. Everything else you will need to implement yourself.//! # Entry Point//! The entry points into this API are//! [`UnbufferedClientConnection::dangerous_into_kernel_connection`][client-into]//! [`UnbufferedServerConnection::dangerous_into_kernel_connection`][server-into].//! In order to actually create an [`KernelConnection`] all of the following//! must be true://! - the connection must have completed its handshake,//! - the connection must have no buffered TLS data waiting to be sent, and,//! - the config used to create the connection must have `enable_extract_secrets`//!   set to true.//! This sounds fairly complicated to achieve at first glance. However, if you//! drive an unbuffered connection through the handshake until it returns//! [`WriteTraffic`] then it will end up in an appropriate state to convert//! into an external connection.//! [client-into]: crate::client::UnbufferedClientConnection::dangerous_into_kernel_connection//! [server-into]: crate::server::UnbufferedServerConnection::dangerous_into_kernel_connection//! [`WriteTraffic`]: crate::unbuffered::ConnectionState::WriteTraffic//! # Cipher Suite Confidentiality Limits//! Some cipher suites (notably AES-GCM) have vulnerabilities where they are no//! longer secure once a certain number of messages have been sent. Normally,//! rustls tracks how many messages have been written or read and will//! automatically either refresh keys or emit an error when approaching the//! confidentiality limit of the cipher suite.//! [`KernelConnection`] has no way to track this. It is the responsibility//! of the user of the API to track approximately how many messages have been//! sent and either refresh the traffic keys or abort the connection before the//! confidentiality limit is reached.//! You can find the current confidentiality limit by looking at//! [`CipherSuiteCommon::confidentiality_limit`] for the cipher suite selected//! by the connection.//! [`CipherSuiteCommon::confidentiality_limit`]: crate::CipherSuiteCommon::confidentiality_limit//! [`KernelConnection`]: crate::kernel::KernelConnectiondeframerDeframerSliceBufferServerConnectionDataprocess_tls_recordsUnbufferedStatus/// Processes the TLS records in `incoming_tls` buffer until a new [`UnbufferedStatus`] isprocess_tls_records_commonConnectionState/// Number of bytes to discard/// After the `state` field of this object has been handled, `discard` bytes must be/// removed from the *front* of the `incoming_tls` buffer that was passed to/// the [`UnbufferedConnectionCommon::process_tls_records`] call that returned this object./// This discard operation MUST happen *before*/// [`UnbufferedConnectionCommon::process_tls_records`] is called again./// The current state of the handshake process/// This value MUST be handled prior to calling/// [`UnbufferedConnectionCommon::process_tls_records`] again. See the documentation on the/// variants of [`ConnectionState`] for more details./// The current status of the `UnbufferedConnection*`ReadTraffic/// One, or more, application data records are available/// See [`ReadTraffic`] for more details on how to use the enclosed object to access/// the received data./// Connection has been cleanly closed by the peer./// This state is encountered at most once by each connection -- it is/// "edge" triggered, rather than "level" triggered./// It delimits the data received from the peer, meaning you can be sure you/// have received all the data the peer sent./// No further application data will be received from the peer, so no further/// `ReadTraffic` states will be produced./// However, it is possible to _send_ further application data via `WriteTraffic`/// states, or close the connection cleanly by calling/// [`WriteTraffic::queue_close_notify()`]./// Connection has been cleanly closed by both us and the peer./// This is a terminal state.  No other states will be produced for thisReadEarlyData/// One, or more, early (RTT-0) data records are availableEncodeTlsData/// A Handshake record is ready for encoding/// Call [`EncodeTlsData::encode`] on the enclosed object, providing an `outgoing_tls`/// buffer to store the encoding/// Previously encoded handshake records need to be transmitted/// Transmit the contents of the `outgoing_tls` buffer that was passed to previous/// [`EncodeTlsData::encode`] calls to the peer./// After transmitting the contents, call [`TransmitTlsData::done`] on the enclosed object./// The transmitted contents MUST not be sent to the peer more than once so they SHOULD be/// discarded at this point./// At some stages of the handshake process, it's possible to send application-data alongside/// handshake records. Call [`TransmitTlsData::may_encrypt_app_data`] on the enclosed/// object to probe if that's allowed.BlockedHandshake/// More TLS data is needed to continue with the handshake/// Request more data from the peer and append the contents to the `incoming_tls` buffer that/// was passed to [`UnbufferedConnectionCommon::process_tls_records`].WriteTraffic/// The handshake process has been completed./// [`WriteTraffic::encrypt`] can be called on the enclosed object to encrypt application/// data into an `outgoing_tls` buffer. Similarly, [`WriteTraffic::queue_close_notify`] can/// be used to encrypt a close_notify alert message into a buffer to signal the peer that the/// connection is being closed. Data written into `outgoing_buffer` by either method MAY be/// transmitted to the peer during this state./// Once this state has been reached, data MAY be requested from the peer and appended to an/// `incoming_tls` buffer that will be passed to a future/// [`UnbufferedConnectionCommon::process_tls_records`] invocation. When enough data has been/// appended to `incoming_tls`, [`UnbufferedConnectionCommon::process_tls_records`] will yield/// the [`ConnectionState::ReadTraffic`] state./// The state of the [`UnbufferedConnectionCommon`] object// for forwards compatibility; to support caller-side certificate verification_incoming_tls// for forwards compatibility; to support in-place decryption in the future// owner of the latest chunk obtained in `next_record`, as borrowed by// `AppDataRecord`/// Application data is availablenext_recordAppDataRecord/// Decrypts and returns the next available app-data record// TODO deprecate in favor of `Iterator` implementation, which requires in-place decryptionpeek_len/// Returns the payload size of the next app-data record *without* decrypting it/// Returns `None` if there are no more app-data records/// Early application-data is available./// decrypts and returns the next available app-data record/// returns the payload size of the next app-data record *without* decrypting it/// returns `None` if there are no more app-data records/// Number of additional bytes to discard/// This number MUST be added to the value of [`UnbufferedStatus.discard`] *prior* to the/// discard operation. See [`UnbufferedStatus.discard`] for more details/// The payload of the app-data record/// A decrypted application-data record/// Allows encrypting app-data/// Returns the number of bytes that were written into `outgoing_tls`, or an error if/// the provided buffer is too small. In the error case, `outgoing_tls` is not modifiedqueue_close_notify/// Encrypts a close_notify warning alert in `outgoing_tls`refresh_traffic_keys/// Arranges for a TLS1.3 `key_update` to be sent./// This consumes the `WriteTraffic` state:  to actually send the message,/// call [`UnbufferedConnectionCommon::process_tls_records`] again which will/// return a `ConnectionState::EncodeTlsData` that emits the `key_update`/// See [`ConnectionCommon::refresh_traffic_keys()`] for full documentation,/// including why you might call this and in what circumstances it will fail./// [`ConnectionCommon::refresh_traffic_keys()`]: crate::ConnectionCommon::refresh_traffic_keys/// A handshake record must be encodedEncodeError/// Encodes a handshake record into the `outgoing_tls` buffer/// Previously encoded TLS data must be transmitted/// Signals that the previously encoded TLS data has been transmittedmay_encrypt_app_data/// Returns an adapter that allows encrypting application data/// If allowed at this stage of the handshake processInsufficientSize/// Provided buffer was too smallAlreadyEncoded/// The handshake record has already been encoded; do not call `encode` again/// Errors that may arise when encoding a handshake recordEncryptExhausted/// Encrypter has been exhausted/// Errors that may arise when encrypting application datarequired_size/// buffer must be at least this size//! Unbuffered connection APIDeframerIterBufferProgressDeframerVecBufferDelocatorLocatorHandshakeDeframerInboundPlainMessageDecrypted// pub so that it can be re-exported from the crate root/// A client connectionServerConnection/// A server connection/// A client or server connection.read_tls/// Read TLS content from `rd`./// See [`ConnectionCommon::read_tls()`] for more information.write_tls/// Writes TLS messages to `wr`./// See [`ConnectionCommon::write_tls()`] for more information./// Returns an object that allows reading plaintext./// Returns an object that allows writing plaintext.process_new_packets/// Processes any new packets read by a previous call to [`Connection::read_tls`]./// See [`ConnectionCommon::process_new_packets()`] for more information./// Derives key material from the agreed connection secrets./// See [`ConnectionCommon::export_keying_material()`] for more information.complete_io/// This function uses `io` to complete any outstanding IO for this connection./// See [`ConnectionCommon::complete_io()`] for more information.set_buffer_limit/// Sets a limit on the internal buffers/// See [`ConnectionCommon::set_buffer_limit()`] for more information./// Sends a TLS1.3 `key_update` message to refresh a connection's keys/// See [`ConnectionCommon::refresh_traffic_keys()`] for more information./// A structure that implements [`std::io::Read`] for reading plaintext.check_no_bytes_state/// Check the connection's state if no bytes are available for reading.into_first_chunk/// Obtain a chunk of plaintext data received from the peer over this TLS connection./// This method consumes `self` so that it can return a slice whose lifetime is bounded by/// the [`ConnectionCommon`] that created this `Reader`./// Obtain plaintext data received from the peer over this TLS connection./// If the peer closes the TLS session cleanly, this returns `Ok(0)`  once all/// the pending data has been read. No further data can be received on that/// connection, so the underlying TCP connection should be half-closed too./// If the peer closes the TLS session uncleanly (a TCP EOF without sending a/// `close_notify` alert) this function returns a `std::io::Error` of type/// `ErrorKind::UnexpectedEof` once any pending data has been read./// Note that support for `close_notify` varies in peer TLS libraries: many do not/// support it and uncleanly close the TCP connection (this might be/// vulnerable to truncation attacks depending on the application protocol)./// This means applications using rustls must both handle EOF/// from this function, *and* unexpected EOF of the underlying TCP connection./// If there are no bytes to read, this returns `Err(ErrorKind::WouldBlock.into())`./// You may learn the number of bytes available at any time by inspecting/// the return of [`Connection::process_new_packets`]./// This reads the same data as [`Reader::read()`], but returns a reference instead of/// copying the data./// The caller should call [`Reader::consume()`] afterward to advance the buffer./// See [`Reader::into_first_chunk()`] for a version of this function that returns a/// buffer with a longer lifetime.UNEXPECTED_EOF_MESSAGEPlaintextSink/// A structure that implements [`std::io::Write`] for writing plaintext./// Create a new Writer./// This is not an external interface.  Get one of these objects/// from [`Connection::writer`]./// Send the plaintext `buf` to the peer, encrypting/// and authenticating it.  Once this function succeeds/// you should call [`Connection::write_tls`] which will output the/// corresponding TLS records./// This function buffers plaintext sent before the/// TLS handshake completes, and sends it as soon/// as it can.  See [`ConnectionCommon::set_buffer_limit`] to control/// the size of this buffer./// Internal trait implemented by the [`ServerConnection`]/[`ClientConnection`]/// allowing them to be the subject of a [`Writer`]./// [`ServerConnection`]: crate::ServerConnection/// [`ClientConnection`]: crate::ClientConnectiondeframer_buffer/// Interface shared by client and server connections./// Processes any new packets read by a previous call to/// [`Connection::read_tls`]./// Errors from this function relate to TLS protocol errors, and/// are fatal to the connection.  Future calls after an error will do/// no new work and will return the same error. After an error is/// received from [`process_new_packets`], you should not call [`read_tls`]/// any more (it will fill up buffers to no purpose). However, you/// may call the other methods on the connection, including `write`,/// `send_close_notify`, and `write_tls`. Most likely you will want to/// call `write_tls` to send any alerts queued by the error and then/// close the underlying connection./// Success from this function comes with some sundry state data/// about the connection./// [`read_tls`]: Connection::read_tls/// [`process_new_packets`]: Connection::process_new_packets/// This function fills in `output` with `output.len()` bytes of key/// material derived from the master session secret using `label`/// and `context` for diversification. Ownership of the buffer is taken/// by the function and returned via the Ok result to ensure no key/// material leaks if the function fails./// See RFC5705 for more details on what this does and is for./// For TLS1.3 connections, this function does not use the/// "early" exporter at any point./// This function fails if called prior to the handshake completing;/// check with [`CommonState::is_handshaking`] first./// This function fails if `output.len()` is zero./// Sets a limit on the internal buffers used to buffer/// unsent plaintext (prior to completing the TLS handshake)/// and unsent TLS records.  This limit acts only on application/// data written through [`Connection::writer`]./// By default the limit is 64KB.  The limit can be set/// at any time, even if the current buffer use is higher./// [`None`] means no limit applies, and will mean that written/// data is buffered without bound -- it is up to the application/// to appropriately schedule its plaintext and TLS writes to bound/// memory usage./// For illustration: `Some(1)` means a limit of one byte applies:/// [`Connection::writer`] will accept only one byte, encrypt it and/// add a TLS header.  Once this is sent via [`Connection::write_tls`],/// another byte may be sent./// # Internal write-direction buffering/// rustls has two buffers whose size are bounded by this setting:/// ## Buffering of unsent plaintext data prior to handshake completion/// Calls to [`Connection::writer`] before or during the handshake/// are buffered (up to the limit specified here).  Once the/// handshake completes this data is encrypted and the resulting/// TLS records are added to the outgoing buffer./// ## Buffering of outgoing TLS records/// This buffer is used to store TLS records that rustls needs to/// send to the peer.  It is used in these two circumstances:/// - by [`Connection::process_new_packets`] when a handshake or alert///   TLS record needs to be sent./// - by [`Connection::writer`] post-handshake: the plaintext is///   encrypted and the resulting TLS record is buffered./// This buffer is emptied by [`Connection::write_tls`]./// [`Connection::writer`]: crate::Connection::writer/// Sends a TLS1.3 `key_update` message to refresh a connection's keys./// This call refreshes our encryption keys. Once the peer receives the message,/// it refreshes _its_ encryption and decryption keys and sends a response./// Once we receive that response, we refresh our decryption keys to match./// At the end of this process, keys in both directions have been refreshed./// Note that this process does not happen synchronously: this call just/// arranges that the `key_update` message will be included in the next/// `write_tls` output./// This fails with `Error::HandshakeNotComplete` if called before the initial/// handshake is complete, or if a version prior to TLS1.3 is negotiated./// # Usage advice/// Note that other implementations (including rustls) may enforce limits on/// the number of `key_update` messages allowed on a given connection to prevent/// denial of service.  Therefore, this should be called sparingly./// rustls implicitly and automatically refreshes traffic keys when needed/// according to the selected cipher suite's cryptographic constraints.  There/// is therefore no need to call this manually to avoid cryptographic keys/// "wearing out"./// The main reason to call this manually is to roll keys when it is known/// a connection will be idle for a long period./// This function uses `io` to complete any outstanding IO for/// this connection./// This is a convenience function which solely uses other parts/// of the public API./// What this means depends on the connection  state:/// - If the connection [`is_handshaking`], then IO is performed until///   the handshake is complete./// - Otherwise, if [`wants_write`] is true, [`write_tls`] is invoked///   until it is all written./// - Otherwise, if [`wants_read`] is true, [`read_tls`] is invoked///   once./// The return value is the number of bytes read from and written/// to `io`, respectively./// This function will block if `io` blocks./// Errors from TLS record handling (i.e., from [`process_new_packets`])/// are wrapped in an `io::ErrorKind::InvalidData`-kind error./// [`is_handshaking`]: CommonState::is_handshaking/// [`wants_read`]: CommonState::wants_read/// [`wants_write`]: CommonState::wants_write/// [`write_tls`]: ConnectionCommon::write_tls/// [`read_tls`]: ConnectionCommon::read_tls/// [`process_new_packets`]: ConnectionCommon::process_new_packetsfirst_handshake_message/// Extract the first handshake message./// This is a shortcut to the `process_new_packets()` -> `process_msg()` ->/// `process_handshake_messages()` path, specialized for the first handshake message./// Read TLS content from `rd` into the internal buffer./// Due to the internal buffering, `rd` can supply TLS messages in arbitrary-sized chunks (like/// a socket or pipe might)./// You should call [`process_new_packets()`] each time a call to this function succeeds in order/// to empty the incoming TLS data buffer./// This function returns `Ok(0)` when the underlying `rd` does so. This typically happens when/// a socket is cleanly closed, or a file is at EOF. Errors may result from the IO done through/// `rd`; additionally, errors of `ErrorKind::Other` are emitted to signal backpressure:/// * In order to empty the incoming TLS data buffer, you should call [`process_new_packets()`]///   each time a call to this function succeeds./// * In order to empty the incoming plaintext data buffer, you should empty it through///   the [`reader()`] after the call to [`process_new_packets()`]./// This function also returns `Ok(0)` once a `close_notify` alert has been successfully/// received.  No additional data is ever read in this state./// [`process_new_packets()`]: ConnectionCommon::process_new_packets/// [`reader()`]: ConnectionCommon::reader/// On success, this function returns `Ok(n)` where `n` is a number of bytes written to `wr`/// (after encoding and encryption)./// After this function returns, the connection buffer may not yet be fully flushed. The/// [`CommonState::wants_write`] function can be used to check if the output buffer is empty.emitted_peer_closed_state/// Interface shared by unbuffered client and server connections.hs_deframerseen_consecutive_empty_fragments/// We limit consecutive empty fragments to avoid a route for the peer to send/// us significant but fruitless traffic.deframe/// Pull a message out of the deframer and send any messages that need to be sent as a result.take_handshake_messageprocess_more_inputhandle_deframe_errorprocess_msgmaybe_refresh_traffic_keys/// Trigger a `refresh_traffic_keys` if required by `CommonState`./// Data specific to the peer's side (client or server).InboundUnborrowedMessage/// An InboundPlainMessage which does not borrow its payload, but/// references a range that can later be borrowed.unborrowALLOWED_CONSECUTIVE_EMPTY_FRAGMENTS_MAX/// cf. BoringSSL's `kMaxEmptyRecords`/// <https://github.com/google/boringssl/blob/dec5989b793c56ad4dd32173bd2d8595ca78b398/ssl/tls_record.cc#L124-L128>aws_lc_rsAsBigEndianCurve25519SeedBinEcPrivateKeyBinunspecified_errHpkeOpenerHpkePrivateKeyHkdfExpanderHkdfPrkExtractHkdfUsingHmacHpkeAeadHpkeKdfALL_SUPPORTED_SUITES/// Default [RFC 9180] Hybrid Public Key Encryption (HPKE) suites supported by aws-lc-rs cryptography.DH_KEM_P256_HKDF_SHA256_AES_128HpkeAwsLcRs/// HPKE suite using ECDH P-256 for agreement, HKDF SHA-256 for key derivation, and AEAD AES-128-GCM/// for symmetric encryption.DH_KEM_P256_HKDF_SHA256_AES_256/// HPKE suite using ECDH P-256 for agreement, HKDF SHA-256 for key derivation and AEAD AES-256-GCMDH_KEM_P256_HKDF_SHA256_CHACHA20_POLY1305CHACHA_KEY_LEN/// HPKE suite using ECDH P-256 for agreement, HKDF SHA-256 for key derivation, and AEAD/// CHACHA20-POLY-1305 for symmetric encryption.DH_KEM_P384_HKDF_SHA384_AES_128/// HPKE suite using ECDH P-384 for agreement, HKDF SHA-384 for key derivation, and AEAD AES-128-GCMDH_KEM_P384_HKDF_SHA384_AES_256/// HPKE suite using ECDH P-384 for agreement, HKDF SHA-384 for key derivation, and AEAD AES-256-GCMDH_KEM_P384_HKDF_SHA384_CHACHA20_POLY1305/// HPKE suite using ECDH P-384 for agreement, HKDF SHA-384 for key derivation, and AEADDH_KEM_P521_HKDF_SHA512_AES_128/// HPKE suite using ECDH P-521 for agreement, HKDF SHA-512 for key derivation, and AEAD AES-128-GCMDH_KEM_P521_HKDF_SHA512_AES_256/// HPKE suite using ECDH P-521 for agreement, HKDF SHA-512 for key derivation, and AEAD AES-256-GCMDH_KEM_P521_HKDF_SHA512_CHACHA20_POLY1305/// HPKE suite using ECDH P-521 for agreement, HKDF SHA-512 for key derivation, and AEADDH_KEM_X25519_HKDF_SHA256_AES_128/// HPKE suite using ECDH X25519 for agreement, HKDF SHA-256 for key derivation, and AEAD AES-128-GCMDH_KEM_X25519_HKDF_SHA256_AES_256/// HPKE suite using ECDH X25519 for agreement, HKDF SHA-256 for key derivation, and AEAD AES-256-GCMDH_KEM_X25519_HKDF_SHA256_CHACHA20_POLY1305/// HPKE suite using ECDH X25519 for agreement, HKDF SHA-256 for key derivation, and AEADdh_kemKDF_SIZEDhKem/// `HpkeAwsLcRs` holds the concrete instantiations of the algorithms specified by the [HpkeSuite].KemSharedSecretKeySchedule/// See [RFC 9180 §5.1 "Creating the Encryption Context"][0]./// [0]: https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1key_schedule_labeled_expandsetup_sealersetup_openergenerate_key_pairSealer/// Adapts a [KeySchedule] and [AeadKey] for the role of a [HpkeSealer]./// See [RFC 9180 §5.1.1 "Encryption to a Public Key"][0]./// [0]: https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1.1test_only_new/// A **test only** constructor that uses a pre-specified ephemeral agreement private key/// instead of one that is randomly generated.Opener/// Adapts a [KeySchedule] and [AeadKey] for the role of a [HpkeOpener].agreement_algorithmkey_generator/// A Diffie-Hellman (DH) based Key Encapsulation Mechanism (KEM)./// See [RFC 9180 §4.1 "DH-Based KEM (DHKEM)"][0]./// [0]: https://www.rfc-editor.org/rfc/rfc9180.html#section-4.1encaptest_only_encap/// A test-only encap operation that uses a fixed `test_only_ske` instead of generating/// one randomly.encap_impldecapextract_and_expandDH_KEM_P256_HKDF_SHA256DH_KEM_P384_HKDF_SHA384DH_KEM_P521_HKDF_SHA512DH_KEM_X25519_HKDF_SHA256generate_p_curve_key_pair/// Generate a NIST P-256, P-384 or P-512 key pair expressed as a raw big-endian fixed-length/// We must disambiguate the [`AsBigEndian`] trait in-use and this function uses/// [`AsBigEndian<EcPrivateKeyBin>`], which does not support [`agreement::X25519`]./// For generating X25519 keys see [`generate_x25519_key_pair`].generate_x25519_key_pair/// Generate a X25519 key pair expressed as a raw big-endian fixed-length/// [`AsBigEndian<Curve25519SeedBin>`], which only supports [`agreement::X25519`]./// For generating P-256, P-384 and P-512 keys see [`generate_p_curve_key_pair`].base_nonce/// KeySchedule holds the derived AEAD key, base nonce, and seq number/// common to both a [Sealer] and [Opener].compute_nonce/// See [RFC 9180 §5.2 "Encryption and Decryption"][0]./// [0]: https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2increment_seq_numlabeled_extract_for_expandLabeledSuiteId/// See [RFC 9180 §4 "Cryptographic Dependencies"][0]./// [0]: https://www.rfc-editor.org/rfc/rfc9180.html#section-4labeled_extract_for_prklabeled_expandPskIdHashInfoHashSecretBaseNonceEaePrk/// Label describes the possible labels for use with [labeled_extract_for_expand] and [labeled_expand].Kem/// LabeledSuiteId describes the possible suite ID values for use with [labeled_extract_for_expand] and/// [labeled_expand]./// The suite ID encoding depends on the context of use. In the general HPKE context,/// we use a "HPKE" prefix and encode the entire ciphersuite. In the KEM context we use a/// "KEM" prefix and only encode the KEM ID./// See the bottom of [RFC 9180 §4](https://www.rfc-editor.org/rfc/rfc9180.html#section-4)/// A newtype wrapper for an unbound AEAD key.KDF_LEN/// A newtype wrapper for a DH KEM shared secret.key_rejected_err// The `cipher::chacha::KEY_LEN` const is not exported, so we copy it here:// https://github.com/aws/aws-lc-rs/blob/0186ef7bb1a4d7e140bae8074a9871f49afedf1b/aws-lc-rs/src/cipher/chacha.rs#L13RING_HKDF_HMAC_SHA256RING_HKDF_HMAC_SHA384RING_HKDF_HMAC_SHA512test_fips// Ensure all supported suites are available to test.check_test_vectors/// Confirm open/seal operations work using the test vectors from [RFC 9180 Appendix A]./// [RFC 9180 Appendix A]: https://www.rfc-editor.org/rfc/rfc9180#TestVectorssetup_test_sealerTestHpkeTEST_SUITESkem_idkdf_idaead_idpk_rmsk_rmsk_emencryptionsTestEncryptionptctapplicablelookup_suiterfc_tests// aws-lc-rs has a -- roughly -- ring-compatible API, so we just reuse all that// glue here.  The shared files should always use `super::ring_like` to access a// ring-compatible crate, and `super::ring_shim` to bridge the gaps where they are// small.webpki_algsKeyProviderGetRandomFailed/// Hybrid public key encryption (HPKE)./// Post-quantum secure algorithms./// Using software keys for authentication."../ring/hash.rs""../ring/hmac.rs""../ring/kx.rs"kx"../ring/quic.rs"ticketer/// A `CryptoProvider` backed by aws-lc-rs.default_kx_groupsAwsLcRsload_private_keyDEFAULT_CIPHER_SUITES/// The cipher suite configuration that an application should use by default./// This will be [`ALL_CIPHER_SUITES`] sans any supported cipher suites that/// shouldn't be enabled by most applications.ALL_CIPHER_SUITES/// A list of all the cipher suites supported by the rustls aws-lc-rs provider.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256TLS13_AES_128_GCM_SHA256TLS13_AES_256_GCM_SHA384TLS13_CHACHA20_POLY1305_SHA256/// All defined cipher suites supported by aws-lc-rs appear in this module.SUPPORTED_SIG_ALGS/// A `WebPkiSupportedAlgorithms` value that reflects webpki's capabilities when/// compiled against aws-lc-rs.SECP256R1MLKEM768SECP256R1MLKEM768X25519MLKEM768kx_group/// All defined key exchange groups supported by aws-lc-rs appear in this module./// [`ALL_KX_GROUPS`] is provided as an array of all of these values./// [`DEFAULT_KX_GROUPS`] is provided as an array of this provider's defaults.DEFAULT_KX_GROUPS/// A list of the default key exchange groups supported by this provider./// This does not contain MLKEM768; by default MLKEM768 is only offered/// in hybrid with X25519.ALL_KX_GROUPS/// A list of all the key exchange groups supported by this provider.Ticketerring_shim/// Compatibility shims between ring 0.16.x and 0.17.x API/// Are we in FIPS mode?default_suites_are_fipsdefault_suitesINVALID_KEY_SHARECompletedKeyExchangeffdhe_groupsFfdheGroupclassicalpost_quantum/// A generalization of hybrid key exchange.start_and_completeffdhe_groupusable_for_versioncombined_pub_keyActiveHybridhybrid_component/// Allow the classical computation to be offered and selected separately.complete_hybrid_componentclassical_share_len/// Length of classical key share.post_quantum_client_share_len/// Length of post-quantum key share sent by clientpost_quantum_server_share_len/// Length of post-quantum key share sent by serverpost_quantum_first/// Whether the post-quantum element comes first in shares and secrets./// For dismal and unprincipled reasons, SECP256R1MLKEM768 has the/// classical element first, while X25519MLKEM768 has it second.split_received_client_sharesplit_received_server_share/// Return the PQ and classical component of a key share.kemMlKem768decaps_keyAlgorithmIdDecapsulationKeyencaps_key_bytes// The received 'peer_pub_key' is actually the ML-KEM ciphertext,// which when decapsulated with our `decaps_key` produces the shared// secret.mlkem/// This is the [X25519MLKEM768] key exchange./// [X25519MLKEM768]: <https://datatracker.ietf.org/doc/draft-ietf-tls-ecdhe-mlkem/>/// This is the [SECP256R1MLKEM768] key exchange./// [SECP256R1MLKEM768]: <https://datatracker.ietf.org/doc/draft-ietf-tls-ecdhe-mlkem/>/// This is the [MLKEM] key exchange./// [MLKEM]: https://datatracker.ietf.org/doc/draft-connolly-tls-mlkem-key-agreementX25519_LENSECP256R1_LENMLKEM768_CIPHERTEXT_LENMLKEM768_ENCAP_LENSubjectPublicKeyInfoDeralg_idpublic_key_to_spkiany_supported_type/// Parse `der` as any supported key encoding/type, returning/// the first which works.any_ecdsa_type/// Parse `der` as any ECDSA key type, returning the first which works./// Both SEC1 (PEM section starting with 'BEGIN EC PRIVATE KEY') and PKCS8/// (PEM section starting with 'BEGIN PRIVATE KEY') encodings are supported.any_eddsa_type/// Parse `der` as any EdDSA key type, returning the first which works./// Note that, at the time of writing, Ed25519 does not have wide support/// in browsers.  It is also not supported by the WebPKI, because the/// CA/Browser Forum Baseline Requirements do not support it for publicly/// trusted certificates.RsaSigningKey/// A `SigningKey` for RSA-PKCS1 or RSA-PSS./// This is used by the test suite, so it must be `pub`, but it isn't part of/// the public, stable, API.ALL_RSA_SCHEMES/// Make a new `RsaSigningKey` from a DER encoding, in either/// PKCS#1 or PKCS#8 format.choose_schemeRsaSignerEcdsaSigningKey/// A SigningKey that uses exactly one TLS-level SignatureScheme/// and one ring-level signature::SigningAlgorithm./// Compare this to RsaSigningKey, which for a particular key is/// willing to sign with several algorithms.  This is quite poor/// cryptography practice, but is necessary because a given RSA key/// is expected to work in TLS1.2 (PKCS#1 signatures) and TLS1.3/// (PSS signatures) -- nobody is willing to obtain certificates for/// different protocol versions./// Currently this is only implemented for ECDSA keys./// Make a new `ECDSASigningKey` from a DER encoding in PKCS#8 or SEC1/// format, expecting a key usable with precisely the given signature/// scheme.EcdsaSignerEd25519SigningKey/// Currently this is only implemented for Ed25519 keys./// Make a new `Ed25519SigningKey` from a DER encoding in PKCS#8 format,/// expecting a key usable with precisely the given signature scheme.Ed25519SignerPrivatePkcs1KeyDerPrivateSec1KeyDercan_load_ecdsa_nistp256_pkcs8can_load_ecdsa_nistp256_sec1can_sign_ecdsa_nistp256can_load_ecdsa_nistp384_pkcs8can_load_ecdsa_nistp384_sec1can_sign_ecdsa_nistp384can_load_ecdsa_nistp521_pkcs8can_load_ecdsa_nistp521_sec1can_sign_ecdsa_nistp521can_load_eddsa_pkcs8can_sign_eddsacan_load_rsa2048_pkcs8can_load_rsa2048_pkcs1can_sign_rsa2048cannot_load_invalid_pkcs8_encodingbench_rsa2048_pkcs1_sha256bench_rsa2048_pss_sha256bench_eddsabench_ecdsa_p256_sha256bench_ecdsa_p384_sha384bench_ecdsa_p521_sha512bench_load_and_validate_rsa2048bench_load_and_validate_rsa4096bench_load_and_validate_p256bench_load_and_validate_p384bench_load_and_validate_p521bench_load_and_validate_eddsaSAMPLE_TLS13_MESSAGEAES_CBC_IV_LENDecryptionContextPaddedBlockDecryptingKeyPaddedBlockEncryptingKeyUnboundCipherKeytry_split_atProducesTickets/// A concrete, safe ticket creation mechanism./// Make the recommended `Ticketer`.  This produces tickets/// with a 12 hour life and randomly generated keys./// The `Ticketer` uses the [RFC 5077 §4] "Recommended Ticket Construction",/// using AES 256 for encryption and HMAC-SHA256 for ciphertext authentication./// [RFC 5077 §4]: https://www.rfc-editor.org/rfc/rfc5077#section-4MakeMutexmake_ticket_generatoraes_encrypt_keyaes_decrypt_keyhmac_keykey_namemaximum_ciphertext_lenRfc5077Ticketer/// An RFC 5077 "Recommended Ticket Construction" implementation of a [`Ticketer`]./// Encrypt `message` and return the ciphertext.basic_pairwise_testrefuses_decrypt_before_encryptrefuses_decrypt_larger_than_largest_encryptionticketrotator_switching_testticketrotator_remains_usable_over_temporary_ticketer_creation_failureticketswitcher_switching_testticketswitcher_recover_testrfc5077ticketer_is_debug_and_producesticketsfail_generatortls_prfInboundOpaqueMessageKeyBlockShapeMessageDecrypterTls12AeadAlgorithmmake_tls12_aadPrfMAX_FRAGMENT_LENPrefixedPayloadCipherSuiteCommonTLS12/// The TLS1.2 ciphersuite TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256./// The TLS1.2 ciphersuite TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256/// The TLS1.2 ciphersuite TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256/// The TLS1.2 ciphersuite TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384/// The TLS1.2 ciphersuite TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256/// The TLS1.2 ciphersuite TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384TLS12_ECDSA_SCHEMESTLS12_RSA_SCHEMESAES128_GCMGcmAlgorithmAES256_GCMdecrypterencrypterkey_block_shapeextract_keysTlsRecordSealingKeyGcmMessageEncrypter/// A `MessageEncrypter` for AES-GCM AEAD ciphersuites. TLS 1.2 only.dec_keyTlsRecordOpeningKeydec_saltGcmMessageDecrypter/// A `MessageDecrypter` for AES-GCM AEAD ciphersuites.  TLS1.2 only.GCM_EXPLICIT_NONCE_LENGCM_OVERHEADencrypted_payload_lenenc_offsetChaCha20Poly1305MessageEncrypter/// The RFC7905/RFC7539 ChaCha20Poly1305 construction./// This implementation does the AAD construction required in TLS1.2./// TLS1.3 uses `TLS13MessageEncrypter`.dec_offsetChaCha20Poly1305MessageDecrypter/// TLS1.3 uses `TLS13MessageDecrypter`.CHACHAPOLY1305_OVERHEADgcm_ivTls12Prffor_secretfor_key_exchangeTls13AeadAlgorithmmake_tls13_aadOutputLengthError/// The TLS1.3 ciphersuite TLS_CHACHA20_POLY1305_SHA256TLS13_CHACHA20_POLY1305_SHA256_INTERNAL/// The TLS1.3 ciphersuite TLS_AES_256_GCM_SHA384/// The TLS1.3 ciphersuite TLS_AES_128_GCM_SHA256TLS13_AES_128_GCM_SHA256_INTERNALAeadAlgorithmChacha20Poly1305AeadAes256GcmAeadAes128GcmAead// common encrypter/decrypter/key_len items for above Tls13AeadAlgorithm impls// using aead::TlsRecordSealingKey// using aead::TlsRecordOpeningKeyAeadMessageEncrypterAeadMessageDecrypterAwsLcHkdfextract_from_zero_ikmextract_from_secretexpander_for_okmhmac_signAwsLcHkdfExpanderexpand_sliceexpand_blockBorrowedPayload/// Build a `MessageEncrypter` for the given key/iv./// Build a `MessageDecrypter` for the given key/iv./// The length of key in bytes required by `encrypter()` and `decrypter()`./// Convert the key material from `key`/`iv`, into a `ConnectionTrafficSecrets` item./// May return [`UnsupportedOperationError`] if the AEAD algorithm is not a supported/// variant of `ConnectionTrafficSecrets`./// Return `true` if this is backed by a FIPS-approved implementation./// Factory trait for building `MessageEncrypter` and `MessageDecrypter` for a TLS1.3 cipher suite./// Build a `MessageEncrypter` for the given key/iv and extra key block (which can be used for/// improving explicit nonce size security, if needed)./// The length of `key` is set by [`KeyBlockShape::enc_key_len`]./// The length of `iv` is set by [`KeyBlockShape::fixed_iv_len`]./// The length of `extra` is set by [`KeyBlockShape::explicit_nonce_len`]./// Return a `KeyBlockShape` that defines how large the `key_block` is and how it/// is split up prior to calling `encrypter()`, `decrypter()` and/or `extract_keys()`./// Factory trait for building `MessageEncrypter` and `MessageDecrypter` for a TLS1.2 cipher suite./// An error indicating that the AEAD algorithm does not support the requested operation.enc_key_len/// How long keys are./// `enc_key_length` terminology is from the standard ([RFC5246 A.6])./// [RFC5246 A.6]: <https://www.rfc-editor.org/rfc/rfc5246#appendix-A.6>fixed_iv_len/// How long the fixed part of the 'IV' is./// `fixed_iv_length` terminology is from the standard ([RFC5246 A.6])./// This isn't usually an IV, but we continue the/// terminology misuse to match the standard.explicit_nonce_len/// This is a non-standard extension which extends the/// key block to provide an initial explicit nonce offset,/// in a deterministic and safe way.  GCM needs this,/// chacha20poly1305 works this way by design./// How a TLS1.2 `key_block` is partitioned./// Note: ciphersuites with non-zero `mac_key_length` are  not currently supported./// Decrypt the given TLS message `msg`, using the sequence number/// `seq` which can be used to derive a unique [`Nonce`]./// Objects with this trait can decrypt TLS messages./// Encrypt the given TLS message `msg`, using the sequence number/// Return the length of the ciphertext that results from encrypting plaintext of/// length `payload_len`/// Objects with this trait can encrypt TLS messages./// A write or read IV./// Create a new `Iv` from a byte array, of precisely `NONCE_LEN` bytes./// Create a new `Iv` from a byte slice, of precisely `NONCE_LEN` bytes./// A nonce.  This is unique for all messages on a connection./// Combine an `Iv` and sequence number to produce a unique nonce./// This is `iv ^ seq` where `seq` is encoded as a 96-bit big-endian integer./// Size of TLS nonces (incorrectly termed "IV" in standard) for all supported ciphersuites/// (AES-GCM, Chacha20Poly1305)/// Returns a TLS1.3 `additional_data` encoding./// See RFC8446 s5.2 for the `additional_data` definition.TLS12_AAD_SIZE/// Returns a TLS1.2 `additional_data` encoding./// See RFC5246 s6.2.3.3 for the `additional_data` definition./// A key for an AEAD algorithm./// This is a value type for a byte string up to `AeadKey::MAX_LEN` bytes in length./// Largest possible AEAD key in the ciphersuites we support.InvalidMessageEncrypter/// A `MessageEncrypter` which doesn't work.InvalidMessageDecrypter/// A `MessageDecrypter` which doesn't work./// Start an incremental hash computation./// Return the output of this hash function with input `data`./// The length in bytes of this hash function's output./// Which hash function this is, eg, `HashAlgorithm::SHA256`./// Describes a single cryptographic hash function./// This interface can do both one-shot and incremental hashing, using/// [`Hash::hash()`] and [`Hash::start()`] respectively./// A hash output, stored as a value./// Build a `hash::Output` from a slice of no more than `Output::MAX_LEN` bytes./// Maximum supported hash output size: supports up to SHA512.fork_finish/// Finish the computation, returning the resulting output./// The computation remains valid, and more data can be added later with/// [`Context::update()`]./// Compare with [`Context::finish()`] which consumes the computation/// and prevents any further data being added.  This can be more efficient/// because it avoids a hash context copy to apply Merkle-Damgård padding/// (if required)./// Fork the computation, producing another context that has the/// same prefix as this one./// Terminate and finish the computation, returning the resulting output./// Further data cannot be added after this, because the context is consumed./// Compare [`Context::fork_finish()`]./// Add `data` to computation./// How to incrementally compute a hash./// Prepare to use `key` as a HMAC key.hash_output_len/// Give the length of the underlying hash function.  In RFC2104 terminology this is `L`./// A concrete HMAC implementation, for a single cryptographic hash function./// You should have one object that implements this trait for HMAC-SHA256, another/// for HMAC-SHA384, etc./// A HMAC tag, stored as a value./// Build a tag by copying a byte slice./// The slice can be up to [`Tag::MAX_LEN`] bytes in length./// Maximum supported HMAC tag size: supports up to SHA512./// Calculates a tag over `data` -- a slice of byte slices.sign_concat/// Calculates a tag over the concatenation of `first`, the items in `middle`, and `last`./// Returns the length of the tag returned by a computation using/// this key./// A HMAC key that is ready for use./// The algorithm used is implicit in the `Hmac` object that produced the key./// The choice of HPKE key encapsulation mechanism./// The choice of HPKE symmetric cipher suite./// This combines a choice of authenticated encryption with additional data (AEAD) algorithm/// and a key derivation function (KDF)./// An HPKE suite, specifying a key encapsulation mechanism and a symmetric cipher suite./// Seal the provided `plaintext` to the recipient public key `pub_key` with application supplied/// `info`, and additional data `aad`./// Returns ciphertext that can be used with [Self::open] by the recipient to recover plaintext/// using the same `info` and `aad` and the private key corresponding to `pub_key`. RFC 9180/// refers to `pub_key` as `pkR`./// Set up a sealer context for the receiver public key `pub_key` with application supplied `info`./// Returns both an encapsulated ciphertext and a sealer context that can be used to seal/// messages to the recipient. RFC 9180 refers to `pub_key` as `pkR`./// Open the provided `ciphertext` using the encapsulated secret `enc`, with application/// supplied `info`, and additional data `aad`./// Returns plaintext if  the `info` and `aad` match those used with [Self::seal], and/// decryption with `secret_key` succeeds. RFC 9180 refers to `secret_key` as `skR`./// Set up an opener context for the secret key `secret_key` with application supplied `info`./// Returns an opener context that can be used to open sealed messages encrypted to the/// public key corresponding to `secret_key`. RFC 9180 refers to `secret_key` as `skR`./// Generate a new public key and private key pair compatible with this HPKE instance./// Key pairs should be encoded as raw big endian fixed length integers sized based/// on the suite's DH KEM algorithm./// Return whether the HPKE instance is FIPS compatible./// Return the [HpkeSuite] that this HPKE instance supports./// An HPKE instance that can be used for base-mode single-shot encryption and decryption./// Seal the provided `plaintext` with additional data `aad`, returning/// ciphertext./// An HPKE sealer context./// This is a stateful object that can be used to seal messages for receipt by/// a receiver./// Open the provided `ciphertext` with additional data `aad`, returning plaintext./// An HPKE opener context./// This is a stateful object that can be used to open sealed messages sealed/// by a sender./// An HPKE public key./// An HPKE private key./// Return the private key bytes./// A HPKE public key./// A HPKE private key.HpkeKeyPair/// An HPKE key pair, made of a matching public and private key./// An encapsulated secret returned from setting up a sender or receiver context.verify_tls13_signature_with_raw_key/// *ring* based CryptoProvider./// TLS message encryption/decryption interfaces./// Hashing interfaces./// HMAC interfaces./// Cryptography specific to TLS1.2./// Cryptography specific to TLS1.3./// Hybrid public key encryption (RFC 9180).// Message signing interfaces. Re-exported under rustls::sign. Kept crate-internal here to// avoid having two import paths to the same types./// List of supported ciphersuites, in preference order -- the first element/// is the highest priority./// The `SupportedCipherSuite` type carries both configuration and implementation./// A valid `CryptoProvider` must ensure that all cipher suites are accompanied by at least/// one matching key exchange group in [`CryptoProvider::kx_groups`].kx_groups/// List of supported key exchange groups, in preference order -- the/// first element is the highest priority./// The first element in this list is the _default key share algorithm_,/// and in TLS1.3 a key share for it is sent in the client hello./// The `SupportedKxGroup` type carries both configuration and implementation.signature_verification_algorithms/// List of signature verification algorithms for use with webpki./// These are used for both certificate chain verification and handshake signature verification./// This is called by [`ConfigBuilder::with_root_certificates()`],/// [`server::WebPkiClientVerifier::builder_with_provider()`] and/// [`client::WebPkiServerVerifier::builder_with_provider()`]./// Source of cryptographically secure random numbers.key_provider/// Provider for loading private [`SigningKey`]s from [`PrivateKeyDer`]./// Controls core cryptography used by rustls./// This crate comes with two built-in options, provided as/// `CryptoProvider` structures:/// - [`crypto::aws_lc_rs::default_provider`]: (behind the `aws_lc_rs` crate feature,///   which is enabled by default).  This provider uses the [aws-lc-rs](https://github.com/aws/aws-lc-rs)///   crate.  The `fips` crate feature makes this option use FIPS140-3-approved cryptography./// - [`crypto::ring::default_provider`]: (behind the `ring` crate feature, which///   is optional).  This provider uses the [*ring*](https://github.com/briansmith/ring)///   crate./// This structure provides defaults. Everything in it can be overridden at/// runtime by replacing field values as needed./// # Using the per-process default `CryptoProvider`/// There is the concept of an implicit default provider, configured at run-time once in/// a given process./// It is used for functions like [`ClientConfig::builder()`] and [`ServerConfig::builder()`]./// The intention is that an application can specify the [`CryptoProvider`] they wish to use/// once, and have that apply to the variety of places where their application does TLS/// (which may be wrapped inside other libraries)./// They should do this by calling [`CryptoProvider::install_default()`] early on./// To achieve this goal:/// - _libraries_ should use [`ClientConfig::builder()`]/[`ServerConfig::builder()`]///   or otherwise rely on the [`CryptoProvider::get_default()`] provider./// - _applications_ should call [`CryptoProvider::install_default()`] early///   in their `fn main()`. If _applications_ uses a custom provider based on the one built-in,///   they can activate the `custom-provider` feature to ensure its usage./// # Using a specific `CryptoProvider`/// Supply the provider when constructing your [`ClientConfig`] or [`ServerConfig`]:/// - [`ClientConfig::builder_with_provider()`]/// - [`ServerConfig::builder_with_provider()`]/// When creating and configuring a webpki-backed client or server certificate verifier, a choice of/// provider is also needed to start the configuration process:/// - [`client::WebPkiServerVerifier::builder_with_provider()`]/// - [`server::WebPkiClientVerifier::builder_with_provider()`]/// If you install a custom provider and want to avoid any accidental use of a built-in provider, the feature/// `custom-provider` can be activated to ensure your custom provider is used everywhere/// and not a built-in one. This will disable any implicit use of a built-in provider./// # Making a custom `CryptoProvider`/// Your goal will be to populate an instance of this `CryptoProvider` struct./// ## Which elements are required?/// There is no requirement that the individual elements ([`SupportedCipherSuite`], [`SupportedKxGroup`],/// [`SigningKey`], etc.) come from the same crate.  It is allowed and expected that uninteresting/// elements would be delegated back to one of the default providers (statically) or a parent/// provider (dynamically)./// For example, if we want to make a provider that just overrides key loading in the config builder/// API (with [`ConfigBuilder::with_single_cert`], etc.), it might look like this:/// # mod fictious_hsm_api { pub fn load_private_key(key_der: pki_types::PrivateKeyDer<'static>) -> ! { unreachable!(); } }/// use rustls::crypto::aws_lc_rs;/// pub fn provider() -> rustls::crypto::CryptoProvider {///   rustls::crypto::CryptoProvider{///     key_provider: &HsmKeyLoader,///     ..aws_lc_rs::default_provider()/// struct HsmKeyLoader;/// impl rustls::crypto::KeyProvider for HsmKeyLoader {///     fn load_private_key(&self, key_der: pki_types::PrivateKeyDer<'static>) -> Result<Arc<dyn rustls::sign::SigningKey>, rustls::Error> {///          fictious_hsm_api::load_private_key(key_der)/// ## References to the individual elements/// The elements are documented separately:/// - **Random** - see [`crypto::SecureRandom::fill()`]./// - **Cipher suites** - see [`SupportedCipherSuite`], [`Tls12CipherSuite`], and///   [`Tls13CipherSuite`]./// - **Key exchange groups** - see [`crypto::SupportedKxGroup`]./// - **Signature verification algorithms** - see [`crypto::WebPkiSupportedAlgorithms`]./// - **Authentication key loading** - see [`crypto::KeyProvider::load_private_key()`] and///   [`sign::SigningKey`]./// # Example code/// See custom [`provider-example/`] for a full client and server example that uses/// cryptography from the [`RustCrypto`] and [`dalek-cryptography`] projects./// $ cargo run --example client | head -3/// Current ciphersuite: TLS13_CHACHA20_POLY1305_SHA256/// HTTP/1.1 200 OK/// Content-Type: text/html; charset=utf-8/// Content-Length: 19899/// [`provider-example/`]: https://github.com/rustls/rustls/tree/main/provider-example//// [`RustCrypto`]: https://github.com/RustCrypto/// [`dalek-cryptography`]: https://github.com/dalek-cryptography/// # FIPS-approved cryptography/// The `fips` crate feature enables use of the `aws-lc-rs` crate in FIPS mode./// You can verify the configuration at runtime by checking/// [`ServerConfig::fips()`]/[`ClientConfig::fips()`] return `true`.install_default/// Sets this `CryptoProvider` as the default for this process./// This can be called successfully at most once in any process execution./// Call this early in your process to configure which provider is used for/// the provider.  The configuration should happen before any use of/// [`ClientConfig::builder()`] or [`ServerConfig::builder()`]./// Returns the default `CryptoProvider` for this process./// This will be `None` if no default has been set yet.get_default_or_install_from_crate_features/// An internal function that:/// - gets the pre-installed default, or/// - installs one `from_crate_features()`, or else/// - panics about the need to call [`CryptoProvider::install_default()`]from_crate_features/// Returns a provider named unambiguously by rustls crate features./// This function returns `None` if the crate features are ambiguous (ie, specify two/// providers), or specify no providers, or the feature `custom-provider` is activated./// In all cases the application should explicitly specify the provider to use/// with [`CryptoProvider::install_default`]./// Returns `true` if this `CryptoProvider` is operating in FIPS mode./// This covers only the cryptographic parts of FIPS approval.  There are/// also TLS protocol-level recommendations made by NIST.  You should/// prefer to call [`ClientConfig::fips()`] or [`ServerConfig::fips()`]/// which take these into account./// Fill the given buffer with random bytes./// The bytes must be sourced from a cryptographically secure random number/// generator seeded with good quality, secret entropy./// This is used for all randomness required by rustls, but not necessarily/// randomness required by the underlying cryptography library.  For example:/// [`SupportedKxGroup::start()`] requires random material to generate/// an ephemeral key exchange key, but this is not included in the interface with/// rustls: it is assumed that the cryptography library provides for this itself./// A source of cryptographically secure randomness./// Decode and validate a private signing key from `key_der`./// This is used by [`ConfigBuilder::with_client_auth_cert()`], [`ConfigBuilder::with_single_cert()`],/// and [`ConfigBuilder::with_single_cert_with_ocsp()`].  The key types and formats supported by this/// function directly defines the key types and formats supported in those APIs./// Return an error if the key type encoding is not supported, or if the key fails validation./// If this returns `true`, that must be the case for all possible key types/// supported by [`KeyProvider::load_private_key()`]./// A mechanism for loading private [`SigningKey`]s from [`PrivateKeyDer`]./// This trait is intended to be used with private key material that is sourced from DER,/// such as a private-key that may be present on-disk. It is not intended to be used with/// keys held in hardware security modules (HSMs) or physical tokens. For these use-cases/// see the Rustls manual section on [customizing private key usage]./// [customizing private key usage]: <https://docs.rs/rustls/latest/rustls/manual/_03_howto/index.html#customising-private-key-usage>/// Start a key exchange./// This will prepare an ephemeral secret key in the supported group, and a corresponding/// public key. The key exchange can be completed by calling [ActiveKeyExchange#complete]/// or discarded./// This can fail if the random source fails during ephemeral key generation./// Start and complete a key exchange, in one operation./// The default implementation for this calls `start()` and then calls/// `complete()` on the result.  This is suitable for Diffie-Hellman-like/// key exchange algorithms, where there is not a data dependency between/// our key share (named "pub_key" in this API) and the peer's (`peer_pub_key`)./// If there is such a data dependency (like key encapsulation mechanisms), this/// function should be implemented./// FFDHE group the `SupportedKxGroup` operates in./// Return `None` if this group is not a FFDHE one./// The default implementation calls `FfdheGroup::from_named_group`: this function/// is extremely linker-unfriendly so it is recommended all key exchange implementers/// provide this function./// `rustls::ffdhe_groups` contains suitable values to return from this,/// for example [`rustls::ffdhe_groups::FFDHE2048`][crate::ffdhe_groups::FFDHE2048]./// Named group the SupportedKxGroup operates in./// If the `NamedGroup` enum does not have a name for the algorithm you are implementing,/// you can use [`NamedGroup::Unknown`]./// Return `true` if this should be offered/selected with the given version./// The default implementation returns true for all versions./// A supported key exchange group./// This type carries both configuration and implementation. Specifically,/// it has a TLS-level name expressed using the [`NamedGroup`] enum, and/// a function which produces a [`ActiveKeyExchange`]./// Compare with [`NamedGroup`], which carries solely a protocol identifier./// Completes the key exchange, given the peer's public key./// This method must return an error if `peer_pub_key` is invalid: either/// mis-encoded, or an invalid public key (such as, but not limited to, being/// in a small order subgroup)./// If the key exchange algorithm is FFDHE, the result must be left-padded with zeros,/// as required by [RFC 8446](https://www.rfc-editor.org/rfc/rfc8446#section-7.4.1)/// (see [`complete_for_tls_version()`](Self::complete_for_tls_version) for more details)./// The shared secret is returned as a [`SharedSecret`] which can be constructed/// from a `&[u8]`./// This consumes and so terminates the [`ActiveKeyExchange`].complete_for_tls_version/// Completes the key exchange for the given TLS version, given the peer's public key./// Note that finite-field Diffie–Hellman key exchange has different requirements for the derived/// shared secret in TLS 1.2 and TLS 1.3 (ECDHE key exchange is the same in TLS 1.2 and TLS 1.3):/// In TLS 1.2, the calculated secret is required to be stripped of leading zeros/// [(RFC 5246)](https://www.rfc-editor.org/rfc/rfc5246#section-8.1.2)./// In TLS 1.3, the calculated secret is required to be padded with leading zeros to be the same/// byte-length as the group modulus [(RFC 8446)](https://www.rfc-editor.org/rfc/rfc8446#section-7.4.1)./// The default implementation of this method delegates to [`complete()`](Self::complete) assuming it is/// implemented for TLS 1.3 (i.e., for FFDHE KX, removes padding as needed). Implementers of this trait/// are encouraged to just implement [`complete()`](Self::complete) assuming TLS 1.3, and let the default/// implementation of this method handle TLS 1.2-specific requirements./// For hybrid key exchanges, returns the [`NamedGroup`] and key share/// for the classical half of this key exchange./// There is no requirement for a hybrid scheme (or any other!) to implement/// `hybrid_component()`. It only enables an optimization; described below./// "Hybrid" means a key exchange algorithm which is constructed from two/// (or more) independent component algorithms. Usually one is post-quantum-secure,/// and the other is "classical".  See/// <https://datatracker.ietf.org/doc/draft-ietf-tls-hybrid-design/11/>/// Rustls always sends a presumptive key share in its `ClientHello`, using/// (absent any other information) the first item in [`CryptoProvider::kx_groups`]./// If the server accepts the client's selection, it can complete the handshake/// using that key share.  If not, the server sends a `HelloRetryRequest` instructing/// the client to send a different key share instead./// This request costs an extra round trip, and wastes the key exchange computation/// (in [`SupportedKxGroup::start()`]) the client already did.  We would/// like to avoid those wastes if possible./// It is early days for post-quantum-secure hybrid key exchange deployment./// This means (commonly) continuing to offer both the hybrid and classical/// key exchanges, so the handshake can be completed without a `HelloRetryRequest`/// for servers that support the offered hybrid or classical schemes./// Implementing `hybrid_component()` enables two optimizations:/// 1. Sending both the hybrid and classical key shares in the `ClientHello`./// 2. Performing the classical key exchange setup only once.  This is important///    because the classical key exchange setup is relatively expensive.///    This optimization is permitted and described in///    <https://www.ietf.org/archive/id/draft-ietf-tls-hybrid-design-11.html#section-3.2>/// Both of these only happen if the classical algorithm appears separately in/// the client's [`CryptoProvider::kx_groups`], and if the hybrid algorithm appears/// first in that list./// This function is only called by rustls for clients.  It is called when/// constructing the initial `ClientHello`.  rustls follows these steps:/// 1. If the return value is `None`, nothing further happens./// 2. If the given [`NamedGroup`] does not appear in///    [`CryptoProvider::kx_groups`], nothing further happens./// 3. The given key share is added to the `ClientHello`, after the hybrid entry./// Then, one of three things may happen when the server replies to the `ClientHello`:/// 1. The server sends a `HelloRetryRequest`.  Everything is thrown away and///    we start again./// 2. The server agrees to our hybrid key exchange: rustls calls///    [`ActiveKeyExchange::complete()`] consuming `self`./// 3. The server agrees to our classical key exchange: rustls calls///    [`ActiveKeyExchange::complete_hybrid_component()`] which///    discards the hybrid key data, and completes just the classical key exchange./// Completes the classical component of the key exchange, given the peer's public key./// This is only called if `hybrid_component` returns `Some(_)`./// See the documentation on [`Self::hybrid_component()`] for explanation./// Return the public key being used./// For ECDHE, the encoding required is defined in/// [RFC8446 section 4.2.8.2](https://www.rfc-editor.org/rfc/rfc8446#section-4.2.8.2)./// For FFDHE, the encoding required is defined in/// [RFC8446 section 4.2.8.1](https://www.rfc-editor.org/rfc/rfc8446#section-4.2.8.1)./// FFDHE group the `ActiveKeyExchange` is operating in./// Return the group being used./// An in-progress key exchange originating from a [`SupportedKxGroup`]./// Which group was used./// Our key share (sometimes a public key)./// The computed shared secret./// The result from [`SupportedKxGroup::start_and_complete()`]./// The result from [`ActiveKeyExchange::complete`] or [`ActiveKeyExchange::complete_hybrid_component`]./// Returns the shared secret as a slice of bytes.strip_leading_zeros/// Removes leading zeros from `secret_bytes()` by adjusting the `offset`./// This function does not re-allocate.PROCESS_DEFAULT_PROVIDERstatic_defaulttest_shared_secret_strip_leading_zeros// Only used for TLS 1.2 prf test, and aws-lc-rs HPKE suites./// The IANA "TLS Supported Groups" name of the group/// The corresponding ring agreement::Algorithmfips_allowed/// Whether the algorithm is allowed by FIPS/// `SupportedKxGroup::fips()` is true if and only if the algorithm is allowed,/// _and_ the implementation is FIPS-validated.pub_key_validator/// aws-lc-rs 1.9 and later accepts more formats of public keys than/// just uncompressed./// That is not compatible with TLS:/// - TLS1.3 outlaws other encodings,/// - TLS1.2 negotiates other encodings (we only offer uncompressed), and///   defaults to uncompressed if negotiation is not done./// This function should return `true` if the basic shape of its argument/// is consistent with an uncompressed point encoding.  It does not need/// to verify that the point is on the curve (if the curve requires that/// for security); aws-lc-rs/ring must do that.KxGroup/// A key-exchange group supported by *ring*./// Ephemeral ECDH on curve25519 (see RFC7748)/// Ephemeral ECDH on secp256r1 (aka NIST-P256)/// Ephemeral ECDH on secp384r1 (aka NIST-P384)uncompressed_pointKeyExchange/// An in-progress key exchange.  This has the algorithm,/// our private key, and our public key.kxgroup_fmt_yields_name/// A `CryptoProvider` backed by the [*ring*] crate./// [*ring*]: https://github.com/briansmith/ring/// Default crypto provider./// A list of all the cipher suites supported by the rustls *ring* provider./// All defined cipher suites supported by *ring* appear in this module./// compiled against *ring*./// All defined key exchange groups supported by *ring* appear in this module./// Encrypts or decrypts a packet's payload/// Computes unique nonces for each packet/// Confidentiality limit (see [`quic::PacketKey::confidentiality_limit`])/// Integrity limit (see [`quic::PacketKey::integrity_limit`])/// Decrypt a QUIC packet/// Takes the packet `header`, which is used as the additional authenticated data, and the/// `payload`, which includes the authentication tag./// If the return value is `Ok`, the decrypted payload can be found in `payload`, up to the/// length found in the return value./// Tag length for the underlying AEAD algorithmpacket_algheader_algKeyBuilderpacket_keyheader_protection_keyaead_key_lendbgtest_short_packetshort_packet_header_protectionkey_update_test_vectorshort_packet_header_protection_v2initial_test_vector_v2wrap_concat_in_sequencewrap_in_octet_stringconvert_sec1_to_pkcs8/// Convert a SEC1 encoding to PKCS8, and ask ring to parse it.  This/// can be removed once <https://github.com/briansmith/ring/pull/1456>/// (or equivalent) is landed.PKCS8_PREFIX_ECDSA_NISTP256// This is (line-by-line):// - INTEGER Version = 0// - SEQUENCE (privateKeyAlgorithm)//   - id-ecPublicKey OID//   - prime256v1 OIDPKCS8_PREFIX_ECDSA_NISTP384//   - secp384r1 OID/// The encryption mechanism used is Chacha20Poly1305./// Tracks the largest ciphertext produced by `encrypt`, and/// uses it to early-reject `decrypt` queries that are too long./// Accepting excessively long ciphertexts means a "Partitioning/// Oracle Attack" (see <https://eprint.iacr.org/2020/1491.pdf>)/// can be more efficient, though also note that these are thought/// to be cryptographically hard if the key is full-entropy (as it/// is here).AeadTicketer/// This is a `ProducesTickets` implementation which uses/// any *ring* `aead::Algorithm` to encrypt and authentication/// the ticket payload.  It does not enforce any lifetime/// constraint./// Decrypt `ciphertext` and recover the original message.TICKETER_AEADaeadticketer_is_debug_and_producesticketsPrfUsingHmacTls13MessageEncrypterTls13MessageDecrypterRingHkdfRingHkdfExpanderInconsistentKeysResolvesServerCert/// Choose a `SignatureScheme` from those offered./// Expresses the choice by returning something that implements `Signer`,/// using the chosen scheme./// Get the RFC 5280-compliant SubjectPublicKeyInfo (SPKI) of this [`SigningKey`] if available./// What kind of key we have./// An abstract signing key./// This interface is used by rustls to use a private signing key/// for authentication.  This includes server and client authentication./// Objects of this type are always used within Rustls as/// `Arc<dyn SigningKey>`. There are no concrete public structs in Rustls/// that implement this trait./// There are two main ways to get a signing key:///  - [`KeyProvider::load_private_key()`], or///  - some other method outside of the `KeyProvider` extension trait,///    for instance:///    - [`crypto::ring::sign::any_ecdsa_type()`]///    - [`crypto::ring::sign::any_eddsa_type()`]///    - [`crypto::ring::sign::any_supported_type()`]///    - [`crypto::aws_lc_rs::sign::any_ecdsa_type()`]///    - [`crypto::aws_lc_rs::sign::any_eddsa_type()`]///    - [`crypto::aws_lc_rs::sign::any_supported_type()`]/// The `KeyProvider` method `load_private_key()` is called under the hood by/// [`ConfigBuilder::with_single_cert()`],/// [`ConfigBuilder::with_client_auth_cert()`], and/// [`ConfigBuilder::with_single_cert_with_ocsp()`]./// A signing key created outside of the `KeyProvider` extension trait can be used/// to create a [`CertifiedKey`], which in turn can be used to create a/// [`ResolvesServerCertUsingSni`]. Alternately, a `CertifiedKey` can be returned from a/// custom implementation of the [`ResolvesServerCert`] or [`ResolvesClientCert`] traits./// [`KeyProvider::load_private_key()`]: crate::crypto::KeyProvider::load_private_key/// [`ConfigBuilder::with_single_cert()`]: crate::ConfigBuilder::with_single_cert/// [`ConfigBuilder::with_single_cert_with_ocsp()`]: crate::ConfigBuilder::with_single_cert_with_ocsp/// [`ConfigBuilder::with_client_auth_cert()`]: crate::ConfigBuilder::with_client_auth_cert/// [`crypto::ring::sign::any_ecdsa_type()`]: crate::crypto::ring::sign::any_ecdsa_type/// [`crypto::ring::sign::any_eddsa_type()`]: crate::crypto::ring::sign::any_eddsa_type/// [`crypto::ring::sign::any_supported_type()`]: crate::crypto::ring::sign::any_supported_type/// [`crypto::aws_lc_rs::sign::any_ecdsa_type()`]: crate::crypto::aws_lc_rs::sign::any_ecdsa_type/// [`crypto::aws_lc_rs::sign::any_eddsa_type()`]: crate::crypto::aws_lc_rs::sign::any_eddsa_type/// [`crypto::aws_lc_rs::sign::any_supported_type()`]: crate::crypto::aws_lc_rs::sign::any_supported_type/// [`ResolvesServerCertUsingSni`]: crate::server::ResolvesServerCertUsingSni/// [`ResolvesServerCert`]: crate::server::ResolvesServerCert/// [`ResolvesClientCert`]: crate::client::ResolvesClientCert/// Signs `message` using the selected scheme./// `message` is not hashed; the implementer must hash it using the hash function/// implicit in [`Self::scheme()`]./// The returned signature format is also defined by [`Self::scheme()`]./// Reveals which scheme will be used when you call [`Self::sign()`]./// A thing that can sign a message./// Server certificate resolver which always resolves to the same certificate and key./// For use with [`ConfigBuilder::with_cert_resolver()`]./// [`ConfigBuilder::with_cert_resolver()`]: crate::ConfigBuilder::with_cert_resolver/// The certificate chain or raw public key./// The certified key./// An optional OCSP response from the certificate issuer,/// attesting to its continued validity./// A packaged-together certificate chain, matching `SigningKey` and/// optional stapled OCSP response./// Note: this struct is also used to represent an [RFC 7250] raw public key,/// when the client/server is configured to use raw public keys instead of/// certificates./// Create a new `CertifiedKey` from a certificate chain and DER-encoded private key./// Attempt to parse the private key with the given [`CryptoProvider`]'s [`KeyProvider`] and/// verify that it matches the public key in the first certificate of the `cert_chain`/// [`KeyProvider`]: crate::crypto::KeyProvider/// Make a new CertifiedKey, with the given chain and key./// The cert chain must not be empty. The first certificate in the chain/// must be the end-entity certificate.keys_match/// Verify the consistency of this [`CertifiedKey`]'s public and private keys./// This is done by performing a comparison of SubjectPublicKeyInfo bytes.end_entity_cert/// The end-entity certificate./// Implements [`Prf`] using a [`hmac::Hmac`]./// Computes `PRF(secret, label, seed)` using the secret from a completed key exchange./// Completes the given key exchange, and then uses the resulting shared secret/// to compute the PRF, writing the result into `output`./// The caller guarantees that `label`, `seed` are non-empty. The caller makes no/// guarantees about the contents of `peer_pub_key`. It must be validated by/// [`ActiveKeyExchange::complete`]./// Computes `PRF(secret, label, seed)`, writing the result into `output`./// The caller guarantees that `secret`, `label`, and `seed` are non-empty./// An instantiation of the TLS1.2 PRF with a specific, implicit hash function./// See the definition in [RFC5246 section 5](https://www.rfc-editor.org/rfc/rfc5246#section-5)./// See [`PrfUsingHmac`] as a route to implementing this trait with just/// an implementation of [`hmac::Hmac`].// nb: crypto::aws_lc_rs provider doesn't provide (or need) hmac,// so cannot be used for this test.check_sha256check_sha512check_sha384// Below known answer tests come from https://mailarchive.ietf.org/arch/msg/tls/fzVCzk-z3FShgGJ6DOXqM1ydxms/HkdfExpanderUsingHmac/// Implementation of `HkdfExpander` via `hmac::Key`.expand_unchecked/// Implementation of `Hkdf` (and thence `HkdfExpander`) via `hmac::Hmac`.extract_prk_from_secret/// `HKDF-Expand(PRK, info, L)` into a slice./// Where:/// - `PRK` is the implicit key material represented by this instance./// - `L` is `output.len()`./// - `info` is a slice of byte slices, which should be processed sequentially///   (or concatenated if that is not possible)./// Returns `Err(OutputLengthError)` if `L` is larger than `255 * HashLen`./// Otherwise, writes to `output`./// `HKDF-Expand(PRK, info, L=HashLen)` returned as a value./// - `L := HashLen`./// This is infallible, because by definition `OkmBlock` is always exactly/// `HashLen` bytes long./// Return what `HashLen` is for this instance./// This must be no larger than [`OkmBlock::MAX_LEN`]./// Implementation of `HKDF-Expand` with an implicitly stored and immutable `PRK`./// `HKDF-Extract(salt, 0_HashLen)`/// `0_HashLen` is a string of `HashLen` zero bytes./// A `salt` of `None` should be treated as a sequence of `HashLen` zero bytes./// `HKDF-Extract(salt, secret)`extract_from_kx_shared_secret/// `HKDF-Extract(salt, shared_secret)` where `shared_secret` is the result of a key exchange./// Custom implementations should complete the key exchange by calling/// `kx.complete(peer_pub_key)` and then using this as the input keying material to/// `HKDF-Extract`./// Build a `HkdfExpander` using `okm` as the secret PRK./// Signs `message` using `key` viewed as a HMAC key./// This should use the same hash function as the HKDF functions in this/// See [RFC2104](https://datatracker.ietf.org/doc/html/rfc2104) for the/// definition of HMAC./// A HKDF implementation oriented to the needs of TLS1.3./// See [RFC5869](https://datatracker.ietf.org/doc/html/rfc5869) for the terminology/// used in this definition./// You can use [`HkdfUsingHmac`] which implements this trait on top of an implementation/// of [`hmac::Hmac`]./// In most cases you should prefer [`Hkdf::extract_from_secret`] and using the/// returned [HkdfExpander] instead of handling the PRK directly./// An extended HKDF implementation that supports directly extracting a pseudo-random key (PRK)./// The base [`Hkdf`] trait is tailored to the needs of TLS 1.3, where all extracted PRKs/// are expanded as-is, and so can be safely encapsulated without exposing the caller/// to the key material./// In other contexts (for example, hybrid public key encryption (HPKE)) it may be necessary/// to use the extracted PRK directly for purposes other than an immediate expansion./// This trait can be implemented to offer this functionality when it is required./// `HKDF-Expand(PRK, info, L)` to construct any type from a byte array./// - `L := N`; N is the size of the byte array./// This is infallible, because the set of types (and therefore their length) is known/// Output key material from HKDF, as a value type./// Build a single OKM block by copying a byte slice./// The slice can be up to [`OkmBlock::MAX_LEN`] bytes in length./// An error type used for `HkdfExpander::expand_slice` when/// the slice exceeds the maximum HKDF output length.test_case_1/// Test cases from appendix A in the RFC, minus cases requiring SHA1.test_case_2test_case_3test_salt_not_providedtest_output_length_boundsenum_builderr" The `AlertDescription` TLS protocol enum.  Values in this enum are taken"r" from the various RFCs covering TLS, and are listed by IANA."r" The `Unknown` item is used when processing unrecognised ordinals."UnknownCAMissingExtensionCertificateUnobtainableUnrecognisedNameBadCertificateStatusResponseBadCertificateHashValueUnknownPSKIdentityNoApplicationProtocolEncryptedClientHelloRequiredto_arrayr" The `HandshakeType` TLS protocol enum.  Values in this enum are taken"NewSessionTicketEndOfEarlyDataEncryptedExtensionsCertificateURLCertificateStatusKeyUpdateCompressedCertificateMessageHashr" The `ContentType` TLS protocol enum.  Values in this enum are taken"Heartbeatr" The `ProtocolVersion` TLS protocol enum.  Values in this enum are taken"SSLv2SSLv3TLSv1_0TLSv1_1TLSv1_2TLSv1_3DTLSv1_0DTLSv1_2DTLSv1_3r" The `CipherSuite` TLS protocol enum.  Values in this enum are taken"TLS_NULL_WITH_NULL_NULLTLS_PSK_WITH_AES_128_GCM_SHA256TLS_PSK_WITH_AES_256_GCM_SHA384TLS13_AES_128_CCM_SHA256TLS13_AES_128_CCM_8_SHA256TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHATLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHATLS_ECDHE_RSA_WITH_AES_128_CBC_SHATLS_ECDHE_RSA_WITH_AES_256_CBC_SHATLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384TLS_RSA_WITH_NULL_MD5TLS_RSA_WITH_NULL_SHATLS_RSA_EXPORT_WITH_RC4_40_MD5TLS_RSA_WITH_RC4_128_MD5TLS_RSA_WITH_RC4_128_SHATLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5TLS_RSA_WITH_IDEA_CBC_SHATLS_RSA_EXPORT_WITH_DES40_CBC_SHATLS_RSA_WITH_DES_CBC_SHATLS_RSA_WITH_3DES_EDE_CBC_SHATLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHATLS_DH_DSS_WITH_DES_CBC_SHATLS_DH_DSS_WITH_3DES_EDE_CBC_SHATLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHATLS_DH_RSA_WITH_DES_CBC_SHATLS_DH_RSA_WITH_3DES_EDE_CBC_SHATLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHATLS_DHE_DSS_WITH_DES_CBC_SHATLS_DHE_DSS_WITH_3DES_EDE_CBC_SHATLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHATLS_DHE_RSA_WITH_DES_CBC_SHATLS_DHE_RSA_WITH_3DES_EDE_CBC_SHATLS_DH_anon_EXPORT_WITH_RC4_40_MD5TLS_DH_anon_WITH_RC4_128_MD5TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHATLS_DH_anon_WITH_DES_CBC_SHATLS_DH_anon_WITH_3DES_EDE_CBC_SHASSL_FORTEZZA_KEA_WITH_NULL_SHASSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHATLS_KRB5_WITH_DES_CBC_SHA_or_SSL_FORTEZZA_KEA_WITH_RC4_128_SHATLS_KRB5_WITH_3DES_EDE_CBC_SHATLS_KRB5_WITH_RC4_128_SHATLS_KRB5_WITH_IDEA_CBC_SHATLS_KRB5_WITH_DES_CBC_MD5TLS_KRB5_WITH_3DES_EDE_CBC_MD5TLS_KRB5_WITH_RC4_128_MD5TLS_KRB5_WITH_IDEA_CBC_MD5TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHATLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHATLS_KRB5_EXPORT_WITH_RC4_40_SHATLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5TLS_KRB5_EXPORT_WITH_RC4_40_MD5TLS_PSK_WITH_NULL_SHATLS_DHE_PSK_WITH_NULL_SHATLS_RSA_PSK_WITH_NULL_SHATLS_RSA_WITH_AES_128_CBC_SHATLS_DH_DSS_WITH_AES_128_CBC_SHATLS_DH_RSA_WITH_AES_128_CBC_SHATLS_DHE_DSS_WITH_AES_128_CBC_SHATLS_DHE_RSA_WITH_AES_128_CBC_SHATLS_DH_anon_WITH_AES_128_CBC_SHATLS_RSA_WITH_AES_256_CBC_SHATLS_DH_DSS_WITH_AES_256_CBC_SHATLS_DH_RSA_WITH_AES_256_CBC_SHATLS_DHE_DSS_WITH_AES_256_CBC_SHATLS_DHE_RSA_WITH_AES_256_CBC_SHATLS_DH_anon_WITH_AES_256_CBC_SHATLS_RSA_WITH_NULL_SHA256TLS_RSA_WITH_AES_128_CBC_SHA256TLS_RSA_WITH_AES_256_CBC_SHA256TLS_DH_DSS_WITH_AES_128_CBC_SHA256TLS_DH_RSA_WITH_AES_128_CBC_SHA256TLS_DHE_DSS_WITH_AES_128_CBC_SHA256TLS_RSA_WITH_CAMELLIA_128_CBC_SHATLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHATLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHATLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHATLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHATLS_DH_anon_WITH_CAMELLIA_128_CBC_SHATLS_ECDH_ECDSA_WITH_NULL_SHA_draftTLS_ECDH_ECDSA_WITH_RC4_128_SHA_draftTLS_ECDH_ECDSA_WITH_DES_CBC_SHA_draftTLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA_draftTLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA_draftTLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA_draftTLS_ECDH_ECNRA_WITH_DES_CBC_SHA_draftTLS_ECDH_ECNRA_WITH_3DES_EDE_CBC_SHA_draftTLS_ECMQV_ECDSA_NULL_SHA_draftTLS_ECMQV_ECDSA_WITH_RC4_128_SHA_draftTLS_ECMQV_ECDSA_WITH_DES_CBC_SHA_draftTLS_ECMQV_ECDSA_WITH_3DES_EDE_CBC_SHA_draftTLS_ECMQV_ECNRA_NULL_SHA_draftTLS_ECMQV_ECNRA_WITH_RC4_128_SHA_draftTLS_ECMQV_ECNRA_WITH_DES_CBC_SHA_draftTLS_ECMQV_ECNRA_WITH_3DES_EDE_CBC_SHA_draftTLS_ECDH_anon_NULL_WITH_SHA_draftTLS_ECDH_anon_WITH_RC4_128_SHA_draftTLS_ECDH_anon_WITH_DES_CBC_SHA_draftTLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA_draftTLS_ECDH_anon_EXPORT_WITH_DES40_CBC_SHA_draftTLS_ECDH_anon_EXPORT_WITH_RC4_40_SHA_draftTLS_RSA_EXPORT1024_WITH_RC4_56_MD5TLS_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5TLS_RSA_EXPORT1024_WITH_DES_CBC_SHATLS_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHATLS_RSA_EXPORT1024_WITH_RC4_56_SHATLS_DHE_DSS_EXPORT1024_WITH_RC4_56_SHATLS_DHE_DSS_WITH_RC4_128_SHATLS_DHE_RSA_WITH_AES_128_CBC_SHA256TLS_DH_DSS_WITH_AES_256_CBC_SHA256TLS_DH_RSA_WITH_AES_256_CBC_SHA256TLS_DHE_DSS_WITH_AES_256_CBC_SHA256TLS_DHE_RSA_WITH_AES_256_CBC_SHA256TLS_DH_anon_WITH_AES_128_CBC_SHA256TLS_DH_anon_WITH_AES_256_CBC_SHA256TLS_DHE_DSS_WITH_3DES_EDE_CBC_RMDTLS_DHE_DSS_WITH_AES_128_CBC_RMDTLS_DHE_DSS_WITH_AES_256_CBC_RMDTLS_DHE_RSA_WITH_3DES_EDE_CBC_RMDTLS_DHE_RSA_WITH_AES_128_CBC_RMDTLS_DHE_RSA_WITH_AES_256_CBC_RMDTLS_RSA_WITH_3DES_EDE_CBC_RMDTLS_RSA_WITH_AES_128_CBC_RMDTLS_RSA_WITH_AES_256_CBC_RMDTLS_GOSTR341094_WITH_28147_CNT_IMITTLS_GOSTR341001_WITH_28147_CNT_IMITTLS_GOSTR341094_WITH_NULL_GOSTR3411TLS_GOSTR341001_WITH_NULL_GOSTR3411TLS_RSA_WITH_CAMELLIA_256_CBC_SHATLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHATLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHATLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHATLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHATLS_DH_anon_WITH_CAMELLIA_256_CBC_SHATLS_PSK_WITH_RC4_128_SHATLS_PSK_WITH_3DES_EDE_CBC_SHATLS_PSK_WITH_AES_128_CBC_SHATLS_PSK_WITH_AES_256_CBC_SHATLS_DHE_PSK_WITH_RC4_128_SHATLS_DHE_PSK_WITH_3DES_EDE_CBC_SHATLS_DHE_PSK_WITH_AES_128_CBC_SHATLS_DHE_PSK_WITH_AES_256_CBC_SHATLS_RSA_PSK_WITH_RC4_128_SHATLS_RSA_PSK_WITH_3DES_EDE_CBC_SHATLS_RSA_PSK_WITH_AES_128_CBC_SHATLS_RSA_PSK_WITH_AES_256_CBC_SHATLS_RSA_WITH_SEED_CBC_SHATLS_DH_DSS_WITH_SEED_CBC_SHATLS_DH_RSA_WITH_SEED_CBC_SHATLS_DHE_DSS_WITH_SEED_CBC_SHATLS_DHE_RSA_WITH_SEED_CBC_SHATLS_DH_anon_WITH_SEED_CBC_SHATLS_RSA_WITH_AES_128_GCM_SHA256TLS_RSA_WITH_AES_256_GCM_SHA384TLS_DHE_RSA_WITH_AES_128_GCM_SHA256TLS_DHE_RSA_WITH_AES_256_GCM_SHA384TLS_DH_RSA_WITH_AES_128_GCM_SHA256TLS_DH_RSA_WITH_AES_256_GCM_SHA384TLS_DHE_DSS_WITH_AES_128_GCM_SHA256TLS_DHE_DSS_WITH_AES_256_GCM_SHA384TLS_DH_DSS_WITH_AES_128_GCM_SHA256TLS_DH_DSS_WITH_AES_256_GCM_SHA384TLS_DH_anon_WITH_AES_128_GCM_SHA256TLS_DH_anon_WITH_AES_256_GCM_SHA384TLS_DHE_PSK_WITH_AES_128_GCM_SHA256TLS_DHE_PSK_WITH_AES_256_GCM_SHA384TLS_RSA_PSK_WITH_AES_128_GCM_SHA256TLS_RSA_PSK_WITH_AES_256_GCM_SHA384TLS_PSK_WITH_AES_128_CBC_SHA256TLS_PSK_WITH_AES_256_CBC_SHA384TLS_PSK_WITH_NULL_SHA256TLS_PSK_WITH_NULL_SHA384TLS_DHE_PSK_WITH_AES_128_CBC_SHA256TLS_DHE_PSK_WITH_AES_256_CBC_SHA384TLS_DHE_PSK_WITH_NULL_SHA256TLS_DHE_PSK_WITH_NULL_SHA384TLS_RSA_PSK_WITH_AES_128_CBC_SHA256TLS_RSA_PSK_WITH_AES_256_CBC_SHA384TLS_RSA_PSK_WITH_NULL_SHA256TLS_RSA_PSK_WITH_NULL_SHA384TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256TLS_ECDH_ECDSA_WITH_NULL_SHATLS_ECDH_ECDSA_WITH_RC4_128_SHATLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHATLS_ECDH_ECDSA_WITH_AES_128_CBC_SHATLS_ECDH_ECDSA_WITH_AES_256_CBC_SHATLS_ECDHE_ECDSA_WITH_NULL_SHATLS_ECDHE_ECDSA_WITH_RC4_128_SHATLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHATLS_ECDH_RSA_WITH_NULL_SHATLS_ECDH_RSA_WITH_RC4_128_SHATLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHATLS_ECDH_RSA_WITH_AES_128_CBC_SHATLS_ECDH_RSA_WITH_AES_256_CBC_SHATLS_ECDHE_RSA_WITH_NULL_SHATLS_ECDHE_RSA_WITH_RC4_128_SHATLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHATLS_ECDH_anon_WITH_NULL_SHATLS_ECDH_anon_WITH_RC4_128_SHATLS_ECDH_anon_WITH_3DES_EDE_CBC_SHATLS_ECDH_anon_WITH_AES_128_CBC_SHATLS_ECDH_anon_WITH_AES_256_CBC_SHATLS_SRP_SHA_WITH_3DES_EDE_CBC_SHATLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHATLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHATLS_SRP_SHA_WITH_AES_128_CBC_SHATLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHATLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHATLS_SRP_SHA_WITH_AES_256_CBC_SHATLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHATLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHATLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384TLS_ECDHE_PSK_WITH_RC4_128_SHATLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHATLS_ECDHE_PSK_WITH_AES_128_CBC_SHATLS_ECDHE_PSK_WITH_AES_256_CBC_SHATLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384TLS_ECDHE_PSK_WITH_NULL_SHATLS_ECDHE_PSK_WITH_NULL_SHA256TLS_ECDHE_PSK_WITH_NULL_SHA384TLS_RSA_WITH_ARIA_128_CBC_SHA256TLS_RSA_WITH_ARIA_256_CBC_SHA384TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384TLS_DH_anon_WITH_ARIA_128_CBC_SHA256TLS_DH_anon_WITH_ARIA_256_CBC_SHA384TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384TLS_RSA_WITH_ARIA_128_GCM_SHA256TLS_RSA_WITH_ARIA_256_GCM_SHA384TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384TLS_DH_anon_WITH_ARIA_128_GCM_SHA256TLS_DH_anon_WITH_ARIA_256_GCM_SHA384TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384TLS_PSK_WITH_ARIA_128_CBC_SHA256TLS_PSK_WITH_ARIA_256_CBC_SHA384TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384TLS_PSK_WITH_ARIA_128_GCM_SHA256TLS_PSK_WITH_ARIA_256_GCM_SHA384TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384TLS_RSA_WITH_AES_128_CCMTLS_RSA_WITH_AES_256_CCMTLS_DHE_RSA_WITH_AES_128_CCMTLS_DHE_RSA_WITH_AES_256_CCMTLS_RSA_WITH_AES_128_CCM_8TLS_RSA_WITH_AES_256_CCM_8TLS_DHE_RSA_WITH_AES_128_CCM_8TLS_DHE_RSA_WITH_AES_256_CCM_8TLS_PSK_WITH_AES_128_CCMTLS_PSK_WITH_AES_256_CCMTLS_DHE_PSK_WITH_AES_128_CCMTLS_DHE_PSK_WITH_AES_256_CCMTLS_PSK_WITH_AES_128_CCM_8TLS_PSK_WITH_AES_256_CCM_8TLS_PSK_DHE_WITH_AES_128_CCM_8TLS_PSK_DHE_WITH_AES_256_CCM_8TLS_ECDHE_ECDSA_WITH_AES_128_CCMTLS_ECDHE_ECDSA_WITH_AES_256_CCMTLS_ECDHE_ECDSA_WITH_AES_128_CCM_8TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256TLS_PSK_WITH_CHACHA20_POLY1305_SHA256TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256SSL_RSA_FIPS_WITH_DES_CBC_SHASSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHAr" The `SignatureScheme` TLS protocol enum.  Values in this enum are taken"RSA_PKCS1_SHA1ECDSA_SHA1_LegacyECDSA_NISTP256_SHA256ECDSA_NISTP384_SHA384ECDSA_NISTP521_SHA512supported_in_tls13/// Whether a particular `SignatureScheme` is allowed for TLS protocol signatures/// in TLS1.3./// This prevents (eg) RSA_PKCS1_SHA256 being offered or accepted, even if our/// verifier supports it for other protocol versions./// See RFC8446 s4.2.3: <https://datatracker.ietf.org/doc/html/rfc8446#section-4.2.3>/// This is a denylist so that newly-allocated `SignatureScheme`s values are/// allowed in TLS1.3 by default.r" The `SignatureAlgorithm` TLS protocol enum.  Values in this enum are taken"ECDSAr#" The "TLS Certificate Compression Algorithm IDs" TLS protocol enum."#r" Values in this enum are taken from [RFC8879]."r" [RFC8879]: https://www.rfc-editor.org/rfc/rfc8879.html#section-7.3"BrotliZstdr" The `CertificateType` enum sent in the cert_type extensions."r" Values in this enum are taken from the various RFCs covering TLS, and are listed by IANA."r" [RFC 6091 Section 5]: <https://datatracker.ietf.org/doc/html/rfc6091#section-5>"r" [RFC 7250 Section 7]: <https://datatracker.ietf.org/doc/html/rfc7250#section-7>"RawPublicKeyr" The type of Encrypted Client Hello (`EchClientHelloType`)."r" Specified in [draft-ietf-tls-esni Section 5]."r" [draft-ietf-tls-esni Section 5]: <https://www.ietf.org/archive/id/draft-ietf-tls-esni-18.html#section-5>"EchClientHelloTypeClientHelloOuterClientHelloInnertest_enum8test_enum16test_enumstls13_signature_restrictionsexpect_types/// Which types we expectedgot_type/// What type we receivedInappropriateMessage/// We received a TLS message that isn't valid right now./// `expect_types` lists the message types we can expect right now./// `got_type` is the type we found.  This error is typically/// caused by a buggy TLS stack (the peer or this one), a broken/// network, or an attack./// Which handshake type we expected/// What handshake type we receivedInappropriateHandshakeMessage/// We received a TLS handshake message that isn't valid right now./// `expect_types` lists the handshake message types we can expect/// right now.  `got_type` is the type we found.InvalidEncryptedClientHello/// An error occurred while handling Encrypted Client Hello (ECH)./// The peer sent us a TLS message with invalid contents.NoCertificatesPresented/// The peer didn't give us any certificates.UnsupportedNameType/// The certificate verifier doesn't support the given type of name./// We couldn't decrypt a message.  This is invariably fatal./// We couldn't encrypt a message because it was larger than the allowed message size./// This should never happen if the application is using valid record sizes./// The peer doesn't support a protocol version/feature we require./// The parameter gives a hint as to what version/feature it is./// The peer deviated from the standard TLS protocol./// The parameter gives a hint where.AlertReceived/// We received a fatal alert.  This means the peer is unhappy.CertificateErrorInvalidCertificate/// We saw an invalid certificate./// The contained error is from the certificate validation traitCertRevocationListErrorInvalidCertRevocationList/// A provided certificate revocation list (CRL) was invalid./// A catch-all error for unlikely errors.FailedToGetCurrentTime/// We failed to figure out what time it currently is.FailedToGetRandomBytes/// We failed to acquire random bytes from the system.HandshakeNotComplete/// This function doesn't work until the TLS handshake/// is complete.PeerSentOversizedRecord/// The peer sent an oversized record/fragment./// An incoming connection did not support any known application protocol.BadMaxFragmentSize/// The `max_fragment_size` value supplied in configuration was too small,/// or too large./// Specific failure cases from [`keys_match`] or a [`crate::crypto::signer::SigningKey`] that cannot produce a corresponding public key./// [`keys_match`]: crate::crypto::signer::CertifiedKey::keys_match/// Any other error./// This variant should only be used when the error is not better described by a more/// specific variant. For example, if a custom crypto provider returns a/// provider specific error./// Enums holding this variant will never compare equal to each other./// rustls reports protocol errors using this type.KeyMismatch/// The public key returned by the [`SigningKey`] does not match the public key information in the certificate./// [`SigningKey`]: crate::crypto::signer::SigningKey/// The [`SigningKey`] cannot produce its corresponding public key.CertificatePayloadTooLarge/// A certificate payload exceeded rustls's 64KB limitHandshakePayloadTooLarge/// An advertised message was larger then expected.InvalidCcs/// The peer sent us a syntactically incorrect ChangeCipherSpec payload.InvalidContentType/// An unknown content type was encountered during message decoding.InvalidCertificateStatusType/// A peer sent an invalid certificate status typeInvalidCertRequest/// Context was incorrectly attached to a certificate request during a handshake.InvalidDhParams/// A peer's DH params could not be decodedInvalidEmptyPayload/// A message was zero-length when its record kind forbids it.InvalidKeyUpdate/// A peer sent an unexpected key update request./// A peer's server name could not be decoded/// A TLS message payload was larger then allowed by the specification.MessageTooShort/// Message is shorter than the expected length/// Missing data for the named handshake payload valueMissingKeyExchange/// A peer did not advertise its supported key exchange groups.NoSignatureSchemes/// A peer sent an empty list of signature schemes/// Trailing data found for the named handshake payload value/// A peer sent an unexpected message type.UnknownProtocolVersion/// An unknown TLS protocol was encountered during message decoding.UnsupportedCompression/// A peer sent a non-null compression method.UnsupportedCurveType/// A peer sent an unknown elliptic curve type.UnsupportedKeyExchangeAlgorithm/// A peer sent an unsupported key exchange algorithm.EmptyTicketValue/// A server sent an empty ticketIllegalEmptyList/// A peer sent an empty list of items, but a non-empty list is required./// The argument names the context.IllegalEmptyValue/// A peer sent an empty value, but a non-empty value is required./// A corrupt TLS message payload that resulted in an error.AttemptedDowngradeToTls12WhenTls13IsSupportedBadCertChainExtensionsDisallowedEncryptedExtensionDuplicateClientHelloExtensionsDuplicateEncryptedExtensionsDuplicateHelloRetryRequestExtensionsDuplicateNewSessionTicketExtensionsDuplicateServerHelloExtensionsDuplicateServerNameTypesEarlyDataAttemptedInSecondClientHelloEarlyDataExtensionWithoutResumptionEarlyDataOfferedWithVariedCipherSuiteHandshakeHashVariedAfterRetryIllegalHelloRetryRequestWithEmptyCookieIllegalHelloRetryRequestWithNoChangesIllegalHelloRetryRequestWithOfferedGroupIllegalHelloRetryRequestWithUnofferedCipherSuiteIllegalHelloRetryRequestWithUnofferedNamedGroupIllegalHelloRetryRequestWithUnsupportedVersionIllegalHelloRetryRequestWithWrongSessionIdIllegalHelloRetryRequestWithInvalidEchIllegalMiddleboxChangeCipherSpecIllegalTlsInnerPlaintextIncorrectBinderInvalidCertCompressionInvalidMaxEarlyDataSizeInvalidKeyShareKeyEpochWithPendingFragmentKeyUpdateReceivedInQuicConnectionMessageInterleavedWithHandshakeMessageMissingBinderInPskExtensionMissingKeyShareMissingPskModesExtensionMissingQuicTransportParametersOfferedDuplicateCertificateCompressionsOfferedDuplicateKeySharesOfferedEarlyDataWithOldProtocolVersionOfferedEmptyApplicationProtocolOfferedIncorrectCompressionsPskExtensionMustBeLastPskExtensionWithMismatchedIdsAndBindersRefusedToFollowHelloRetryRequestRejectedEarlyDataInterleavedWithHandshakeMessageResumptionAttemptedWithVariedEmsResumptionOfferedWithVariedCipherSuiteResumptionOfferedWithVariedEmsResumptionOfferedWithIncompatibleCipherSuiteSelectedDifferentCipherSuiteAfterRetrySelectedInvalidPskSelectedTls12UsingTls13VersionExtensionSelectedUnofferedApplicationProtocolSelectedUnofferedCertCompressionSelectedUnofferedCipherSuiteSelectedUnofferedCompressionSelectedUnofferedKxGroupSelectedUnofferedPskSelectedUnusableCipherSuiteForVersionServerEchoedCompatibilitySessionIdServerHelloMustOfferUncompressedEcPointsServerNameDifferedOnRetryServerNameMustContainOneHostNameSignedKxWithWrongAlgorithmSignedHandshakeWithUnadvertisedSigSchemeTooManyEmptyFragmentsTooManyKeyUpdateRequestsTooManyRenegotiationRequestsTooManyWarningAlertsReceivedTooMuchEarlyDataReceivedUnexpectedCleartextExtensionUnsolicitedCertExtensionUnsolicitedEncryptedExtensionUnsolicitedSctListUnsolicitedServerHelloExtensionWrongGroupForKeyShareUnsolicitedEchExtension/// The set of cases where we failed to make a connection because we thought/// the peer was misbehaving./// This is `non_exhaustive`: we might add or stop using items here in minor/// versions.  We also don't document what they mean.  Generally a user of/// rustls shouldn't vary its behaviour on these error codes, and there is/// nothing it can do to improve matters./// Please file a bug against rustls if you see `Error::PeerMisbehaved` in/// the wild.EcPointsExtensionRequiredExtendedMasterSecretExtensionRequiredIncorrectCertificateTypeExtensionKeyShareExtensionRequiredNamedGroupsExtensionRequiredNoCertificateRequestSignatureSchemesInCommonNoCipherSuitesInCommonNoEcPointFormatsInCommonNoKxGroupsInCommonNoSignatureSchemesInCommonNullCompressionRequiredServerDoesNotSupportTls12Or13ServerSentHelloRetryRequestWithUnknownExtensionServerTlsVersionIsDisabledByOurConfigSignatureAlgorithmsExtensionRequiredSupportedVersionsExtensionRequiredTls12NotOfferedTls12NotOfferedOrEnabledTls13RequiredForQuicUncompressedEcPointsRequiredUnsolicitedCertificateTypeExtensionServerRejectedEncryptedClientHello/// The set of cases where we failed to make a connection because a peer/// doesn't support a TLS version/feature we require./// versions.BadEncoding/// The certificate is not correctly encoded./// The current time is after the `notAfter` time in the certificate./// The validation time./// The `notAfter` time of the certificate.ExpiredContext/// This variant is semantically the same as `Expired`, but includes/// extra data to improve error reports.NotValidYet/// The current time is before the `notBefore` time in the certificate./// The `notBefore` time of the certificate.NotValidYetContext/// This variant is semantically the same as `NotValidYet`, but includes/// The certificate has been revoked.UnhandledCriticalExtension/// The certificate contains an extension marked critical, but it was/// not processed by the certificate validator.UnknownIssuer/// The certificate chain is not issued by a known root certificate.UnknownRevocationStatus/// The certificate's revocation status could not be determined.ExpiredRevocationList/// The certificate's revocation status could not be determined, because the CRL is expired./// The nextUpdate time of the CRL.ExpiredRevocationListContext/// This variant is semantically the same as `ExpiredRevocationList`, but includesBadSignature/// A certificate is not correctly signed by the key of its alleged/// A signature inside a certificate or on a handshake was made with an unsupported algorithm.NotValidForName/// The subject names in an end-entity certificate do not include/// the expected name./// Expected server name.presented/// The names presented in the end entity certificate./// These are the subject names as present in the leaf certificate and may contain DNS names/// with or without a wildcard label as well as IP address names.NotValidForNameContext/// This variant is semantically the same as `NotValidForName`, but includesInvalidPurpose/// The certificate is being used for a different purpose than allowed.ExtendedKeyPurpose/// Extended key purpose that was required by the application./// Extended key purposes that were presented in the peer's certificate.InvalidPurposeContext/// This variant is semantically the same as `InvalidPurpose`, but includesApplicationVerificationFailure/// The certificate is valid, but the handshake is rejected for other/// reasons./// This can be used by custom verifiers to expose the underlying error/// (where they are not better described by the more specific errors/// above)./// It is also used by the default verifier in case its error is/// not covered by the above common cases./// The ways in which certificate validators can express errors./// Note that the rustls TLS protocol code interprets specifically these/// error codes to send specific TLS alerts.  Therefore, if a/// custom certificate validator uses incorrect errors the library as/// a whole will send alerts that do not match the standard (this is usually/// a minor issue, but could be misleading).// The following mapping are heavily referenced in:// * [OpenSSL Implementation](https://github.com/openssl/openssl/blob/45bb98bfa223efd3258f445ad443f878011450f0/ssl/statem/statem_lib.c#L1434)// * [BoringSSL Implementation](https://github.com/google/boringssl/blob/583c60bd4bf76d61b2634a58bcda99a92de106cb/ssl/ssl_x509.cc#L1323)/// Client authentication/// Server authentication/// Other EKU values/// Represented here as a `Vec<usize>` for human readability./// Extended Key Usage (EKU) purpose values./// These are usually represented as OID values in the certificate's extension (if present), but/// we represent the values that are most relevant to rustls as named enum variants.for_values/// The CRL had a bad signature from its issuer./// The CRL had an unsupported signature from its issuer.InvalidCrlNumber/// The CRL contained an invalid CRL number.InvalidRevokedCertSerialNumber/// The CRL contained a revoked certificate with an invalid serial number.IssuerInvalidForCrl/// The CRL issuer does not specify the cRLSign key usage./// The CRL is invalid for some other reason./// The CRL is not correctly encoded.UnsupportedCrlVersion/// The CRL is not a v2 X.509 CRL.UnsupportedCriticalExtension/// The CRL, or a revoked certificate in the CRL, contained an unsupported critical extension.UnsupportedDeltaCrl/// The CRL is an unsupported delta CRL, containing only changes relative to another CRL.UnsupportedIndirectCrl/// The CRL is an unsupported indirect CRL, containing revoked certificates issued by a CA/// other than the issuer of the CRL.UnsupportedRevocationReason/// The CRL contained a revoked certificate with an unsupported revocation reason./// See RFC 5280 Section 5.3.1[^1] for a list of supported revocation reasons./// [^1]: <https://www.rfc-editor.org/rfc/rfc5280#section-5.3.1>/// The ways in which a certificate revocation list (CRL) can be invalid.InvalidConfigList/// The provided ECH configuration list was invalid.NoCompatibleConfig/// No compatible ECH configuration.SniRequired/// The client configuration has server name indication (SNI) disabled./// An error that occurred while handling Encrypted Client Hello (ECH)./// Any other error that cannot be expressed by a more specific [`Error`] variant./// For example, an `OtherError` could be produced by a custom crypto provider/// exposing a provider specific error./// Enums holding this type will never compare equal to each other.other_errorcertificate_error_equalitycrl_error_equalityother_error_equalityrand_error_mappingtime_error_mappingclient_auth_enabled/// Early stage buffering of handshake payloads./// Before we know the hash algorithm to use to verify the handshake, we just buffer the messages./// During the handshake, we may restart the transcript due to a HelloRetryRequest, reverting/// from the `HandshakeHash` to a `HandshakeHashBuffer` again.set_client_auth_enabled/// We might be doing client auth, so need to keep a full/// log of the handshake.add_message/// Hash/buffer a handshake message./// Hash or buffer a byte slice.hash_given/// Get the hash value if we were to hash `extra` too.start_hash/// We now know what hash function the verify_data will use./// buffer for client-auth./// This deals with keeping a running hash of the handshake/// payloads.  This is computed by buffering initially.  Once/// we know what hash function we need to use we switch to/// incremental hashing./// For client auth, we also need to buffer all the messages./// This is disabled in cases where client auth is not possible.abandon_client_auth/// We decided not to do client auth after all, so discard/// the transcript./// Hash/buffer an encoded handshake message./// Get the hash value if we were to hash `extra` too,/// using hash function `hash`.into_hrr_bufferrollup_for_hrr/// Take the current hash value, and encapsulate it in a/// 'handshake_hash' handshake message.  Start this hash/// again, with that message at the front.current_hash/// Get the current hash value.take_handshake_buf/// Takes this object's buffer containing all handshake messages/// so far.  This method only works once; it resets the buffer/// to empty./// The hashing algorithmhashes_correctlyhashes_message_typesbuffers_correctlyabandonclones_correctly/// Log the given `secret`.  `client_random` is provided for/// session identification.  `label` describes precisely what/// `secret` means:/// - `CLIENT_RANDOM`: `secret` is the master secret for a TLSv1.2 session./// - `CLIENT_EARLY_TRAFFIC_SECRET`: `secret` encrypts early data///   transmitted by a client/// - `SERVER_HANDSHAKE_TRAFFIC_SECRET`: `secret` encrypts///   handshake messages from the server during a TLSv1.3 handshake./// - `CLIENT_HANDSHAKE_TRAFFIC_SECRET`: `secret` encrypts///   handshake messages from the client during a TLSv1.3 handshake./// - `SERVER_TRAFFIC_SECRET_0`: `secret` encrypts post-handshake data///   from the server in a TLSv1.3 session./// - `CLIENT_TRAFFIC_SECRET_0`: `secret` encrypts post-handshake data///   from the client in a TLSv1.3 session./// - `EXPORTER_SECRET`: `secret` is the post-handshake exporter secret///   in a TLSv1.3 session./// These strings are selected to match the NSS key log format:/// <https://nss-crypto.org/reference/security/nss/legacy/key_log_format/index.html>/// Indicates whether the secret with label `label` will be logged./// If `will_log` returns true then `log` will be called with the secret./// Otherwise, `log` will not be called for the secret. This is a/// performance optimization./// This trait represents the ability to do something useful/// with key material, such as logging it to a file for debugging./// Naturally, secrets passed over the interface are *extremely*/// sensitive and can break the security of past, present and/// future sessions./// You'll likely want some interior mutability in your/// implementation to make this useful./// See [`KeyLogFile`] that implements the standard/// `SSLKEYLOGFILE` environment variable behaviour./// KeyLog that does exactly nothing.KeyLogFileInner// Internal mutable state for KeyLogFile/// [`KeyLog`] implementation that opens a file whose name is/// given by the `SSLKEYLOGFILE` environment variable, and writes/// keys into it./// If `SSLKEYLOGFILE` is not set, this does nothing./// If such a file cannot be opened, or cannot be written then/// this does nothing but logs errors at warning-level./// Makes a new `KeyLogFile`.  The environment variable is/// inspected and the named file is opened during this call.test_env_var_is_not_settest_env_var_cannot_be_openedtest_env_var_cannot_be_written// This `extern crate` plus the `#![no_std]` attribute changes the default prelude from// `std::prelude` to `core::prelude`. That forces one to _explicitly_ import (`use`) everything that// is in `std::prelude` but not in `core::prelude`. This helps maintain no-std support as even// developers that are not interested in, or aware of, no-std support and / or that never run// `cargo build --no-default-features` locally will get errors when they rely on `std::prelude` API.// log for logging (optional).test_macros/// This internal `sync` module aliases the `Arc` implementation to allow downstream forks/// of rustls targeting architectures without atomic pointers to replace the implementation/// with another implementation such as `portable_atomic_util::Arc` in one central location./// Crypto provider interface.verifybenchkey_log_fileEchVersionServerSessionValue/// Low-level TLS message parsing and encoding functions.fuzz_deframerfuzzing/// Internal classes that are used in integration tests./// The contents of this section DO NOT form part of the stable interface./// Unbuffered connection API/// This is an alternative to the [`crate::ConnectionCommon`] API that does not internally buffer/// TLS nor plaintext data. Instead those buffers are managed by the API user so they have/// control over when and how to allocate, resize and dispose of them./// This API is lower level than the `ConnectionCommon` API and is built around a state machine/// interface where the API user must handle each state to advance and complete the/// handshake process./// Like the `ConnectionCommon` API, no IO happens internally so all IO must be handled by the API/// user. Unlike the `ConnectionCommon` API, this API does not make use of the [`std::io::Read`] and/// [`std::io::Write`] traits so it's usable in no-std context./// The entry points into this API are [`crate::client::UnbufferedClientConnection::new`],/// [`crate::server::UnbufferedServerConnection::new`] and/// [`unbuffered::UnbufferedConnectionCommon::process_tls_records`]. The state machine API is/// documented in [`unbuffered::ConnectionState`]./// [`unbuffered-client`] and [`unbuffered-server`] are examples that fully exercise the API in/// std, non-async context./// [`unbuffered-client`]: https://github.com/rustls/rustls/blob/main/examples/src/bin/unbuffered-client.rs/// [`unbuffered-server`]: https://github.com/rustls/rustls/blob/main/examples/src/bin/unbuffered-server.rs// The public interface is:StreamOwnedTicketRotatorTicketSwitcher// < XXX: incorrect feature gateALL_VERSIONSDEFAULT_VERSIONS/// Dangerous configuration that should be audited and used with extreme care.ServerCertVerifierBuilderverify_server_cert_signed_by_trust_anchorverify_server_name/// Items for use in a client.server_connWantsServerCertResolvesServerCertUsingSniServerSessionMemoryCacheAlwaysResolvesServerRawPublicKeysNoServerSessionStorageStoresServerSessionsUnbufferedServerConnectionAcceptedAlertAcceptorNoClientAuthClientCertVerifierBuilderClientCertVerified/// Items for use in a server./// All defined protocol versions appear in this module./// ALL_VERSIONS is a provided as an array of all of these values./// Re-exports the contents of the [rustls-pki-types](https://docs.rs/rustls-pki-types) crate for easy access/// Message signing interfaces./// APIs for implementing QUIC TLS/// APIs for implementing TLS tickets/// This is the rustls manual./// APIs abstracting over locking primitives./// Polyfills for features that are not yet stabilized or available with current MSRV.//! # Rustls - a modern TLS library//! Rustls is a TLS library that aims to provide a good level of cryptographic security,//! requires no configuration to achieve that security, and provides no unsafe features or//! obsolete cryptography by default.//! Rustls implements TLS1.2 and TLS1.3 for both clients and servers. See [the full//! list of protocol features](manual::_04_features).//! ### Platform support//! While Rustls itself is platform independent, by default it uses [`aws-lc-rs`] for implementing//! the cryptography in TLS.  See [the aws-lc-rs FAQ][aws-lc-rs-platforms-faq] for more details of the//! platform/architecture support constraints in aws-lc-rs.//! [`ring`] is also available via the `ring` crate feature: see//! [the supported `ring` target platforms][ring-target-platforms].//! By providing a custom instance of the [`crypto::CryptoProvider`] struct, you//! can replace all cryptography dependencies of rustls.  This is a route to being portable//! to a wider set of architectures and environments, or compliance requirements.  See the//! [`crypto::CryptoProvider`] documentation for more details.//! Specifying `default-features = false` when depending on rustls will remove the implicit//! dependency on aws-lc-rs.//! Rustls requires Rust 1.71 or later. It has an optional dependency on zlib-rs which requires 1.75 or later.//! [ring-target-platforms]: https://github.com/briansmith/ring/blob/2e8363b433fa3b3962c877d9ed2e9145612f3160/include/ring-core/target.h#L18-L64//! [`crypto::CryptoProvider`]: crate::crypto::CryptoProvider//! [`ring`]: https://crates.io/crates/ring//! [aws-lc-rs-platforms-faq]: https://aws.github.io/aws-lc-rs/faq.html#can-i-run-aws-lc-rs-on-x-platform-or-architecture//! [`aws-lc-rs`]: https://crates.io/crates/aws-lc-rs//! ### Cryptography providers//! Since Rustls 0.22 it has been possible to choose the provider of the cryptographic primitives//! that Rustls uses. This may be appealing if you have specific platform, compliance or feature//! requirements that aren't met by the default provider, [`aws-lc-rs`].//! Users that wish to customize the provider in use can do so when constructing `ClientConfig`//! and `ServerConfig` instances using the `with_crypto_provider` method on the respective config//! builder types. See the [`crypto::CryptoProvider`] documentation for more details.//! #### Built-in providers//! Rustls ships with two built-in providers controlled by associated crate features://!   * [`aws-lc-rs`] - enabled by default, available with the `aws_lc_rs` crate feature enabled.//!   * [`ring`] - available with the `ring` crate feature enabled.//! See the documentation for [`crypto::CryptoProvider`] for details on how providers are//! selected.//! #### Third-party providers//! The community has also started developing third-party providers for Rustls://!   * [`boring-rustls-provider`] - a work-in-progress provider that uses [`boringssl`] for//!     cryptography.//!   * [`rustls-graviola`] - a provider that uses [`graviola`] for cryptography.//!   * [`rustls-mbedtls-provider`] - a provider that uses [`mbedtls`] for cryptography.//!   * [`rustls-openssl`] - a provider that uses [OpenSSL] for cryptography.//!   * [`rustls-rustcrypto`] - an experimental provider that uses the crypto primitives//!     from [`RustCrypto`] for cryptography.//!   * [`rustls-symcrypt`] - a provider that uses Microsoft's [SymCrypt] library.//!   * [`rustls-wolfcrypt-provider`] - a work-in-progress provider that uses [`wolfCrypt`] for cryptography.//! [`rustls-graviola`]: https://crates.io/crates/rustls-graviola//! [`graviola`]: https://github.com/ctz/graviola//! [`rustls-mbedtls-provider`]: https://github.com/fortanix/rustls-mbedtls-provider//! [`mbedtls`]: https://github.com/Mbed-TLS/mbedtls//! [`rustls-openssl`]: https://github.com/tofay/rustls-openssl//! [OpenSSL]: https://openssl-library.org///! [`rustls-symcrypt`]: https://github.com/microsoft/rustls-symcrypt//! [SymCrypt]: https://github.com/microsoft/SymCrypt//! [`boring-rustls-provider`]: https://github.com/janrueth/boring-rustls-provider//! [`boringssl`]: https://github.com/google/boringssl//! [`rustls-rustcrypto`]: https://github.com/RustCrypto/rustls-rustcrypto//! [`RustCrypto`]: https://github.com/RustCrypto//! [`rustls-wolfcrypt-provider`]: https://github.com/wolfSSL/rustls-wolfcrypt-provider//! [`wolfCrypt`]: https://www.wolfssl.com/products/wolfcrypt//! #### Custom provider//! We also provide a simple example of writing your own provider in the [custom provider example].//! This example implements a minimal provider using parts of the [`RustCrypto`] ecosystem.//! See the [Making a custom CryptoProvider] section of the documentation for more information//! on this topic.//! [custom provider example]: https://github.com/rustls/rustls/tree/main/provider-example///! [Making a custom CryptoProvider]: https://docs.rs/rustls/latest/rustls/crypto/struct.CryptoProvider.html#making-a-custom-cryptoprovider//! ## Design overview//! Rustls is a low-level library. If your goal is to make HTTPS connections you may prefer//! to use a library built on top of Rustls like [hyper] or [ureq].//! [hyper]: https://crates.io/crates/hyper//! [ureq]: https://crates.io/crates/ureq//! ### Rustls does not take care of network IO//! It doesn't make or accept TCP connections, or do DNS, or read or write files.//! Our [examples] directory contains demos that show how to handle I/O using the//! [`stream::Stream`] helper, as well as more complex asynchronous I/O using [`mio`].//! If you're already using Tokio for an async runtime you may prefer to use [`tokio-rustls`] instead//! of interacting with rustls directly.//! [examples]: https://github.com/rustls/rustls/tree/main/examples//! [`tokio-rustls`]: https://github.com/rustls/tokio-rustls//! ### Rustls provides encrypted pipes//! These are the [`ServerConnection`] and [`ClientConnection`] types.  You supply raw TLS traffic//! on the left (via the [`read_tls()`] and [`write_tls()`] methods) and then read/write the//! plaintext on the right://! [`read_tls()`]: Connection::read_tls//! [`write_tls()`]: Connection::read_tls//!          TLS                                   Plaintext//!          ===                                   =========//!     read_tls()      +-----------------------+      reader() as io::Read//!                     |                       |//!           +--------->   ClientConnection    +--------->//!                     |          or           |//!           <---------+   ServerConnection    <---------+//!     write_tls()     +-----------------------+      writer() as io::Write//! ### Rustls takes care of server certificate verification//! You do not need to provide anything other than a set of root certificates to trust.//! Certificate verification cannot be turned off or disabled in the main API.//! ## Getting started//! This is the minimum you need to do to make a TLS client connection.//! First we load some root certificates.  These are used to authenticate the server.//! The simplest way is to depend on the [`webpki_roots`] crate which contains//! the Mozilla set of root certificates.//! # #[cfg(feature = "aws-lc-rs")] {//! let root_store = rustls::RootCertStore::from_iter(//!     webpki_roots::TLS_SERVER_ROOTS//!         .iter()//!         .cloned(),//! [`webpki_roots`]: https://crates.io/crates/webpki-roots//! Next, we make a `ClientConfig`.  You're likely to make one of these per process,//! and use it for all connections made by that process.//! # #[cfg(feature = "aws_lc_rs")] {//! # let root_store: rustls::RootCertStore = panic!();//! let config = rustls::ClientConfig::builder()//!     .with_root_certificates(root_store)//!     .with_no_client_auth();//! Now we can make a connection.  You need to provide the server's hostname so we//! know what to expect to find in the server's certificate.//! # use rustls;//! # use webpki;//! # rustls::crypto::aws_lc_rs::default_provider().install_default();//! # let root_store = rustls::RootCertStore::from_iter(//! #  webpki_roots::TLS_SERVER_ROOTS//! #      .iter()//! #      .cloned(),//! # let config = rustls::ClientConfig::builder()//! #     .with_root_certificates(root_store)//! #     .with_no_client_auth();//! let rc_config = Arc::new(config);//! let example_com = "example.com".try_into().unwrap();//! let mut client = rustls::ClientConnection::new(rc_config, example_com);//! Now you should do appropriate IO for the `client` object.  If `client.wants_read()` yields//! true, you should call `client.read_tls()` when the underlying connection has data.//! Likewise, if `client.wants_write()` yields true, you should call `client.write_tls()`//! when the underlying connection is able to send data.  You should continue doing this//! as long as the connection is valid.//! The return types of `read_tls()` and `write_tls()` only tell you if the IO worked.  No//! parsing or processing of the TLS messages is done.  After each `read_tls()` you should//! therefore call `client.process_new_packets()` which parses and processes the messages.//! Any error returned from `process_new_packets` is fatal to the connection, and will tell you//! why.  For example, if the server's certificate is expired `process_new_packets` will//! return `Err(InvalidCertificate(Expired))`.  From this point on,//! `process_new_packets` will not do any new work and will return that error continually.//! You can extract newly received data by calling `client.reader()` (which implements the//! `io::Read` trait).  You can send data to the peer by calling `client.writer()` (which//! implements `io::Write` trait).  Note that `client.writer().write()` buffers data you//! send if the TLS connection is not yet established: this is useful for writing (say) a//! HTTP request, but this is buffered so avoid large amounts of data.//! The following code uses a fictional socket IO API for illustration, and does not handle//! errors.//! # let mut client = rustls::ClientConnection::new(panic!(), panic!()).unwrap();//! # struct Socket { }//! # impl Socket {//! #   fn ready_for_write(&self) -> bool { false }//! #   fn ready_for_read(&self) -> bool { false }//! #   fn wait_for_something_to_happen(&self) { }//! # use std::io::{Read, Write, Result};//! # impl Read for Socket {//! #   fn read(&mut self, buf: &mut [u8]) -> Result<usize> { panic!() }//! # impl Write for Socket {//! #   fn write(&mut self, buf: &[u8]) -> Result<usize> { panic!() }//! #   fn flush(&mut self) -> Result<()> { panic!() }//! # fn connect(_address: &str, _port: u16) -> Socket {//! #   panic!();//! use rustls::Connection;//! client.writer().write(b"GET / HTTP/1.0\r\n\r\n").unwrap();//! let mut socket = connect("example.com", 443);//!   if client.wants_read() && socket.ready_for_read() {//!     client.read_tls(&mut socket).unwrap();//!     client.process_new_packets().unwrap();//!     let mut plaintext = Vec::new();//!     client.reader().read_to_end(&mut plaintext).unwrap();//!     io::stdout().write(&plaintext).unwrap();//!   if client.wants_write() && socket.ready_for_write() {//!     client.write_tls(&mut socket).unwrap();//!   socket.wait_for_something_to_happen();//! You can find several client and server examples of varying complexity in the [examples]//! directory, including [`tlsserver-mio`](https://github.com/rustls/rustls/blob/main/examples/src/bin/tlsserver-mio.rs)//! and [`tlsclient-mio`](https://github.com/rustls/rustls/blob/main/examples/src/bin/tlsclient-mio.rs)//! \- full worked examples using [`mio`].//! [`mio`]: https://docs.rs/mio/latest/mio///! # Manual//! The [rustls manual](crate::manual) explains design decisions and includes how-to guidance.//! Here's a list of what features are exposed by the rustls crate and what//! they mean.//! - `std` (enabled by default): enable the high-level (buffered) Connection API and other functionality//!   which relies on the `std` library.//! - `aws_lc_rs` (enabled by default): makes the rustls crate depend on the [`aws-lc-rs`] crate.//!   Use `rustls::crypto::aws_lc_rs::default_provider().install_default()` to//!   use it as the default `CryptoProvider`, or provide it explicitly//!   when making a `ClientConfig` or `ServerConfig`.//!   Note that aws-lc-rs has additional build-time dependencies like cmake.//!   See [the documentation](https://aws.github.io/aws-lc-rs/requirements/index.html) for details.//! - `ring`: makes the rustls crate depend on the *ring* crate for cryptography.//!   Use `rustls::crypto::ring::default_provider().install_default()` to//! - `fips`: enable support for FIPS140-3-approved cryptography, via the [`aws-lc-rs`] crate.//!   This feature enables the `aws_lc_rs` crate feature, which makes the rustls crate depend//!   on [aws-lc-rs](https://github.com/aws/aws-lc-rs).  It also changes the default//!   for [`ServerConfig::require_ems`] and [`ClientConfig::require_ems`].//!   See [manual::_06_fips] for more details.//! - `prefer-post-quantum` (enabled by default): for the [`aws-lc-rs`]-backed provider,//!   prioritizes post-quantum secure key exchange by default (using X25519MLKEM768).//!   This feature merely alters the order of `rustls::crypto::aws_lc_rs::DEFAULT_KX_GROUPS`.//!   See [the manual][x25519mlkem768-manual] for more details.//! - `custom-provider`: disables implicit use of built-in providers (`aws-lc-rs` or `ring`). This forces//!   applications to manually install one, for instance, when using a custom `CryptoProvider`.//! - `tls12` (enabled by default): enable support for TLS version 1.2. Note that, due to the//!   additive nature of Cargo features and because it is enabled by default, other crates//!   in your dependency graph could re-enable it for your application. If you want to disable//!   TLS 1.2 for security reasons, consider explicitly enabling TLS 1.3 only in the config//!   builder API.//! - `logging` (enabled by default): make the rustls crate depend on the `log` crate.//!   rustls outputs interesting protocol-level messages at `trace!` and `debug!` level,//!   and protocol-level errors at `warn!` and `error!` level.  The log messages do not//!   contain secret key data, and so are safe to archive without affecting session security.//! - `read_buf`: when building with Rust Nightly, adds support for the unstable//!   `std::io::ReadBuf` and related APIs. This reduces costs from initializing//!   buffers. Will do nothing on non-Nightly releases.//! - `brotli`: uses the `brotli` crate for RFC8879 certificate compression support.//! - `zlib`: uses the `zlib-rs` crate for RFC8879 certificate compression support.//! [x25519mlkem768-manual]: manual::_05_defaults#about-the-post-quantum-secure-key-exchange-x25519mlkem768// Require docs for public APIs, deny unsafe code, etc.// Relax these clippy lints:// - ptr_arg: this triggers on references to type aliases that are Vec//   underneath.// - too_many_arguments: some things just need a lot of state, wrapping it//   doesn't necessarily make it easier to follow what's going on// - new_ret_no_self: we sometimes return `Arc<Self>`, which seems fine// - single_component_path_imports: our top-level `use log` import causes//   a false positive, https://github.com/rust-lang/rust-clippy/issues/5210// - new_without_default: for internal constructors, the indirection is not//   helpful// Enable documentation for all features on docs.rs// Enable coverage() attr for nightly coverage builds, see// <https://github.com/rust-lang/rust/issues/84605>// (`coverage_nightly` is a cfg set by `cargo-llvm-cov`)// XXX: Because of https://github.com/rust-lang/rust/issues/54726, we cannot// write `#![rustversion::attr(nightly, feature(read_buf))]` here. Instead,// build.rs set `read_buf` for (only) Rust Nightly to get the same effect.// All the other conditional logic in the crate could use// `#[rustversion::nightly]` instead of `#[cfg(read_buf)]`; `#[cfg(read_buf)]`// is used to avoid needing `rustversion` to be compiled twice during// cross-compiling.oldest// first item is the oldest key/// A HashMap-alike, which never gets larger than a specified/// capacity, and evicts the oldest insertion to maintain this./// The requested capacity may be rounded up by the underlying/// collections.  This implementation uses all the allocated/// This is inefficient: it stores keys twice.get_or_insert_default_and_edit/// Create a new LimitedCache with the given rough capacity.test_updates_existing_itemtest_evicts_oldest_itemtest_evicts_second_oldest_item_if_first_removedtest_evicts_after_second_oldest_item_removedtest_removes_all_itemstest_inserts_many_itemstest_get_or_insert_default_and_edit_evicts_old_items_to_meet_capacitytest_get_or_insert_default_and_edit_edits_existing_itemstd_lock/// A wrapper around [`std::sync::Mutex`]./// Acquires the mutex, blocking the current thread until it is able to do so./// This will return `None` in the case the mutex is poisoned./*!

## Rationale for defaults

### Why is AES-256 preferred over AES-128?

This is a trade-off between:

1. classical security level: searching a 2^128 key space is as implausible as 2^256.
2. post-quantum security level: the difference is more meaningful, and AES-256 seems like the conservative choice.
3. performance: AES-256 is around 40% slower than AES-128, though hardware acceleration typically narrows this gap.

The choice is frankly quite marginal.

### Why is AES-GCM preferred over chacha20-poly1305?

Hardware support for accelerating AES-GCM is widespread, and hardware-accelerated AES-GCM
is quicker than un-accelerated chacha20-poly1305.

However, if you know your application will run on a platform without that, you should
_definitely_ change the default order to prefer chacha20-poly1305: both the performance and
the implementation security will be improved.  We think this is an uncommon case.

### Why is x25519 preferred for key exchange over nistp256?

Both provide roughly the same classical security level, but x25519 has better performance and
it's _much_ more likely that both peers will have good quality implementations.

### About the post-quantum-secure key exchange `X25519MLKEM768`

[`X25519MLKEM768`] -- a hybrid[^1], post-quantum-secure[^2] key exchange
algorithm -- is available when using the aws-lc-rs provider.

The `prefer-post-quantum` crate feature makes `X25519MLKEM768` the
highest-priority key exchange algorithm.  Otherwise, it is available but
not highest-priority.

[X25519MLKEM768] is pre-standardization, but is now widely deployed,
for example, by [Chrome] and [Cloudflare].

You may see unexpected connection failures (such as [tldr.fail])
-- [please report these to us][interop-bug].

The two components of this key exchange are well regarded:
X25519 alone is already used by default by rustls, and tends to have
higher quality implementations than other elliptic curves.
ML-KEM-768 was standardized by NIST in [FIPS203].

[`MLKEM768`] is available separately, but is not currently enabled
by default out of conservatism.

[^1]: meaning: a construction that runs a classical and post-quantum
      key exchange, and uses the output of both together.  This is a hedge
      against the post-quantum half being broken.

[^2]: a "post-quantum-secure" algorithm is one posited to be invulnerable
      to attack using a cryptographically-relevant quantum computer.  In contrast,
      classical algorithms would be broken by such a computer.  Note that such computers
      do not currently exist, and may never exist, but current traffic could be captured
      now and attacked later.

[X25519MLKEM768]: <https://datatracker.ietf.org/doc/draft-ietf-tls-ecdhe-mlkem/>
[`X25519MLKEM768`]: crate::crypto::aws_lc_rs::kx_group::X25519MLKEM768
[`MLKEM768`]: crate::crypto::aws_lc_rs::kx_group::MLKEM768
[FIPS203]: <https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.203.pdf>
[Chrome]: <https://security.googleblog.com/2024/09/a-new-path-for-kyber-on-web.html>
[Cloudflare]: <https://blog.cloudflare.com/pq-2024/#ml-kem-768-and-x25519>
[interop-bug]: <https://github.com/rustls/rustls/issues/new?assignees=&labels=&projects=&template=bug_report.md&title=>
[tldr.fail]: <https://tldr.fail/>

*//*!

The below list reflects the support provided with the default crate features.
Items marked with an asterisk `*` can be extended or altered via public
APIs ([`CryptoProvider`] for example).

[`CryptoProvider`]: crate::crypto::CryptoProvider

## Current features

* TLS1.2 and TLS1.3
* ECDSA, Ed25519 or RSA server authentication by clients `*`
* ECDSA, Ed25519[^1] or RSA server authentication by servers `*`
* Forward secrecy using ECDHE; with curve25519, nistp256 or nistp384 curves `*`
* Post-quantum hybrid key exchange with [X25519MLKEM768](https://datatracker.ietf.org/doc/draft-ietf-tls-ecdhe-mlkem/) [^2] `*`
* AES128-GCM and AES256-GCM bulk encryption, with safe nonces `*`
* ChaCha20-Poly1305 bulk encryption ([RFC7905](https://tools.ietf.org/html/rfc7905)) `*`
* ALPN support
* SNI support
* Tunable fragment size to make TLS messages match size of underlying transport
* Optional use of vectored IO to minimise system calls
* TLS1.2 session resumption
* TLS1.2 resumption via tickets ([RFC5077](https://tools.ietf.org/html/rfc5077))
* TLS1.3 resumption via tickets or session storage
* TLS1.3 0-RTT data
* Server and optional client authentication
* Extended master secret support ([RFC7627](https://tools.ietf.org/html/rfc7627))
* Exporters ([RFC5705](https://tools.ietf.org/html/rfc5705))
* OCSP stapling by servers
* [RFC7250](https://tools.ietf.org/html/rfc7250) raw public keys for TLS1.3
* [RFC8879](https://tools.ietf.org/html/rfc8879) certificate compression by clients
  and servers `*`
* Client-side Encrypted client hello (ECH)
   ([draft-ietf-tls-esni](https://datatracker.ietf.org/doc/draft-ietf-tls-esni/)).

[^1]: Note that, at the time of writing, Ed25519 does not have wide support
      in browsers.  It is also not supported by the WebPKI, because the
      CA/Browser Forum Baseline Requirements do not support it for publicly
      trusted certificates.
[^2]: See [the documentation][crate::manual::_05_defaults#about-the-post-quantum-secure-key-exchange-x25519mlkem768]

## Non-features

For reasons explained in the other sections of this manual, rustls does not
and will not support:

* SSL1, SSL2, SSL3, TLS1 or TLS1.1
* RC4
* DES or triple DES
* EXPORT ciphersuites
* MAC-then-encrypt ciphersuites
* Ciphersuites without forward secrecy
* Renegotiation
* Kerberos
* TLS 1.2 protocol compression
* Discrete-log Diffie-Hellman `*`
* Automatic protocol version downgrade
* Using CA certificates directly to authenticate a server/client (often called "self-signed
  certificates"). _Rustls' default certificate verifier does not support using a trust anchor as
  both a CA certificate and an end-entity certificate in order to limit complexity and risk in
  path building. While dangerous, all authentication can be turned off if required --
  see the [example code](https://github.com/rustls/rustls/blob/v/0.23.23/examples/src/bin/tlsclient-mio.rs#L338)_ `*`

### About "custom extensions"

OpenSSL allows an application to add arbitrary TLS extensions (via
the `SSL_CTX_add_custom_ext` function and associated APIs).  We don't
support this, with the following rationale:

Such an API is limited to extensions that are quite narrow in scope:
they cannot change the meaning of standard messages, or introduce new
messages, or make any changes to the connection's cryptography.

However, there is no reasonable way to technically limit that API to
that set of extensions.  That makes the API pretty unsafe (in the
TLS and cryptography sense, not memory safety sense).  This could
cause security or interop failures.

Instead, we suggest that potential users of that API consider:

- whether their use can fit in standard extensions such as ALPN,
  or [ALPS][alps][^3].
- if not, whether they can fit in a more general extension, and define
  and standardize that in the [IETF TLSWG][tlswg].

Note the above is not a guarantee or offer that rustls will implement
any specific extensions that are standardized by the IETF TLSWG.
It is a non-goal of this project to implement absolutely everything.

For experimentation and pre-standardization testing, we suggest
forking rustls.

See also: [Go's position on such an API][golang].

[alps]: https://datatracker.ietf.org/doc/html/draft-vvv-tls-alps
[golang]: https://github.com/golang/go/issues/51497
[tlswg]: https://datatracker.ietf.org/wg/tls/charter/
[^3]: rustls does not currently implement ALPS, but it is something we
  would consider once standardised and deployed.
*//*! # Using rustls with FIPS-approved cryptography

To use FIPS-approved cryptography with rustls, you should take
these actions:

## 1. Enable the `fips` crate feature for rustls.

Use:

```toml
rustls = { version = "0.23", features = [ "fips" ] }
```

## 2. Use the FIPS `CryptoProvider`

This is [`default_fips_provider()`]:

```rust,ignore
rustls::crypto::default_fips_provider()
    .install_default()
    .expect("default provider already set elsewhere");
```

This snippet makes use of the process-default provider,
and that assumes all your uses of rustls use that.
See [`CryptoProvider`] documentation for other ways to
specify which `CryptoProvider` to use.

## 3. Validate the FIPS status of your `ClientConfig`/`ServerConfig` at run-time

See [`ClientConfig::fips()`] or [`ServerConfig::fips()`].

You could, for example:

```rust,ignore
# let client_config = unreachable!();
assert!(client_config.fips());
```

But maybe your application has an error handling
or health-check strategy better than panicking.

# aws-lc-rs FIPS approval status

This is covered by [FIPS 140-3 certificate #4816][cert-4816].
See [the security policy][policy-4816] for precisely which
environments and functions this certificate covers.

Later releases of aws-lc-rs may be covered by later certificates,
or be pending certification.

For the most up-to-date details see the latest documentation
for the [`aws-lc-fips-sys`] crate.

[`aws-lc-fips-sys`]: https://crates.io/crates/aws-lc-fips-sys
[`default_fips_provider()`]: crate::crypto::default_fips_provider
[`CryptoProvider`]: crate::crypto::CryptoProvider
[`ClientConfig::fips()`]: crate::client::ClientConfig::fips
[`ServerConfig::fips()`]: crate::server::ServerConfig::fips
[cert-4816]: https://csrc.nist.gov/projects/cryptographic-module-validation-program/certificate/4816
[policy-4816]: https://csrc.nist.gov/CSRC/media/projects/cryptographic-module-validation-program/documents/security-policies/140sp4816.pdf
*//*! # Customising private key usage

By default rustls supports PKCS#8-format[^1] RSA or ECDSA keys, plus PKCS#1-format RSA keys.

However, if your private key resides in a HSM, or in another process, or perhaps
another machine, rustls has some extension points to support this:

The main trait you must implement is [`sign::SigningKey`][signing_key]. The primary method here
is [`choose_scheme()`][choose_scheme] where you are given a set of [`SignatureScheme`s][sig_scheme] the client says
it supports: you must choose one (or return `None` -- this aborts the handshake). Having
done that, you return an implementation of the [`sign::Signer`][signer] trait.
The [`sign()`][sign_method] performs the signature and returns it.

(Unfortunately this is currently designed for keys with low latency access, like in a
PKCS#11 provider, Microsoft CryptoAPI, etc. so is blocking rather than asynchronous.
It's a TODO to make these and other extension points async.)

Once you have these two pieces, configuring a server to use them involves, briefly:

- packaging your [`sign::SigningKey`][signing_key] with the matching certificate chain into a [`sign::CertifiedKey`][certified_key]
- making a [`ResolvesServerCertUsingSni`][cert_using_sni] and feeding in your [`sign::CertifiedKey`][certified_key] for all SNI hostnames you want to use it for,
- setting that as your `ServerConfig`'s [`cert_resolver`][cert_resolver]

For a complete example of implementing a custom [`sign::SigningKey`][signing_key] and
[`sign::Signer`][signer] see the [`signer` module in the `rustls-cng` crate][rustls-cng-signer].

[signing_key]: crate::crypto::signer::SigningKey
[choose_scheme]: crate::crypto::signer::SigningKey::choose_scheme
[sig_scheme]: crate::SignatureScheme
[signer]: crate::crypto::signer::Signer
[sign_method]: crate::crypto::signer::Signer::sign
[certified_key]: crate::crypto::signer::CertifiedKey
[cert_using_sni]: crate::server::ResolvesServerCertUsingSni
[cert_resolver]: crate::ServerConfig::cert_resolver
[rustls-cng-signer]: https://github.com/rustls/rustls-cng/blob/dev/src/signer.rs

[^1]: For PKCS#8 it does not support password encryption -- there's not a meaningful threat
      model addressed by this, and the encryption supported is typically extremely poor.

# Unexpected EOF

TLS has a `close_notify` mechanism to prevent truncation attacks[^2].
According to the TLS RFCs, each party is required to send a `close_notify` message before
closing the write side of the connection. However, some implementations don't send it.
So long as the application layer protocol (for instance HTTP/2) has message length framing
and can reject truncated messages, this is not a security problem.

Rustls treats an EOF without `close_notify` as an error of type `std::io::Error` with
`ErrorKind::UnexpectedEof`. In some situations it's appropriate for the application to handle
this error the same way it would handle a normal EOF (a read returning `Ok(0)`). In particular
if `UnexpectedEof` occurs on an idle connection it is appropriate to treat it the same way as a
clean shutdown. And if an application always uses messages with length framing (in other words,
messages are never delimited by the close of the TCP connection), it can unconditionally
ignore `UnexpectedEof` errors from rustls.

[^2]: <https://datatracker.ietf.org/doc/html/rfc8446#section-6.1>

# Debugging

If you encounter a bug with Rustls it can be helpful to collect up as much diagnostic
information as possible.

## Collecting logs

If your bug reproduces with one of the [Rustls examples] you can use the
[`RUST_LOG`] environment variable to increase the log verbosity. If you're using
your own application, you may need to configure it with a logging backend
like `env_logger`.

Consider reproducing your bug with `RUST_LOG=rustls=trace` and sharing the result
in a [GitHub gist].

[Rustls examples]: https://github.com/rustls/rustls/tree/main/examples
[`RUST_LOG`]: https://docs.rs/env_logger/latest/env_logger/#enabling-logging
[`env_logger`]: https://docs.rs/env_logger/
[GitHub gist]: https://docs.github.com/en/get-started/writing-on-github/editing-and-sharing-content-with-gists/creating-gists

## Taking a packet capture

When logs aren't enough taking a packet capture ("pcap") is another helpful tool.
The details of how to accomplish this vary by operating system/context.

### tcpdump

As one example, on Linux using [`tcpdump`] is often easiest.

If you know the IP address of the remote server your bug demonstrates with you
could take a short packet capture with this command (after replacing
`XX.XX.XX.XX` with the correct IP address):

```bash
sudo tcpdump -i any tcp and dst host XX.XX.XX.XX -C5 -w rustls.pcap
```

The `-i any` captures on any network interface. The `tcp and dst host XX.XX.XX.XX`
portion target the capture to TCP traffic to the specified IP address. The `-C5`
argument limits the capture to at most 5MB. Lastly the `-w` argument writes the
capture to `rustls.pcap`.

Another approach is to use `tcp and port XXXX` instead of `tcp and dst host XX.XX.XX.XX`
to capture all traffic to a specific port instead of a specific host server.

[`tcpdump`]: https://www.redhat.com/en/blog/introduction-using-tcpdump-linux-command-line

### SSLKEYLOGFILE

If the bug you are reporting happens after data is encrypted you may also wish to
share the secret keys required to decrypt the post-handshake traffic.

If you're using one of the [Rustls examples] you can set the `SSLKEYLOGFILE` environment
variable to a path where secrets will be written. E.g. `SSLKEYLOGFILE=rustls.pcap.keys`.

If you're using your own application you may need to customize the Rustls `ClientConfig`
or `ServerConfig`'s `key_log` setting like the example applications do.

With the file from `SSLKEYLOGFILE` it is possible to use [Wireshark] or another tool to
decrypt the post-handshake messages, following [these instructions][curl-sslkeylogfile].

Remember this allows plaintext decryption and should only be done in testing contexts
where no sensitive data (API keys, etc) are being shared.

[Wireshark]: https://www.wireshark.org/download.html
[curl-sslkeylogfile]: https://everything.curl.dev/usingcurl/tls/sslkeylogfile.html
*//*! # A review of TLS Implementation Vulnerabilities

An important part of engineering involves studying and learning from the mistakes of the past.
It would be tremendously unfortunate to spend effort re-discovering and re-fixing the same
vulnerabilities that were discovered in the past.

## Memory safety

Being written entirely in the safe-subset of Rust immediately offers us freedom from the entire
class of memory safety vulnerabilities.  There are too many to exhaustively list, and there will
certainly be more in the future.

Examples:

- Heartbleed [CVE-2014-0160](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-0160) (OpenSSL)
- Memory corruption in ASN.1 decoder [CVE-2016-2108](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-2108) (OpenSSL)
- Buffer overflow in read_server_hello [CVE-2014-3466](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-3466) (GnuTLS)

## `goto fail`

This is the name of a vulnerability in Apple Secure Transport [CVE-2014-1266](https://nvd.nist.gov/vuln/detail/CVE-2014-1266).
This boiled down to the following code, which validates the server's signature on the key exchange:

```c
    if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0)
        goto fail;
    if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)
        goto fail;
>       goto fail;
    if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
        goto fail;
```

The marked line was duplicated, likely accidentally during a merge.  This meant
the remaining part of the function (including the actual signature validation)
was unconditionally skipped.

Ultimately the one countermeasure to this type of bug is basic testing: that a
valid signature returns success, and that an invalid one does not.  rustls
has such testing, but this is really table stakes for security code.

Further than this, though, we could consider that the *lack* of an error from
this function is a poor indicator that the signature was valid.  rustls, instead,
has zero-size and non-copyable types that indicate a particular signature validation
has been performed.  These types can be thought of as *capabilities* originated only
by designated signature verification functions -- such functions can then be a focus
of manual code review.  Like capabilities, values of these types are otherwise unforgeable,
and are communicable only by Rust's move semantics.

Values of these types are threaded through the protocol state machine, leading to terminal
states that look like:

```ignore
struct ExpectTraffic {
   (...)
    _cert_verified: verify::ServerCertVerified,
    _sig_verified: verify::HandshakeSignatureValid,
    _fin_verified: verify::FinishedMessageVerified,
}
```

Since this state requires a value of these types, it will be a compile-time error to
reach that state without performing the requisite security-critical operations.

This approach is not infallible, but it has zero runtime cost.

## State machine attacks: EarlyCCS and SMACK/SKIP/FREAK

EarlyCCS [CVE-2014-0224](https://nvd.nist.gov/vuln/detail/CVE-2014-0224) was a vulnerability in OpenSSL
found in 2014.  The TLS `ChangeCipherSpec` message would be processed at inappropriate times, leading
to data being encrypted with the wrong keys (specifically, keys which were not secret).  This resulted
from OpenSSL taking a *reactive* strategy to incoming messages ("when I get a message X, I should do Y")
which allows it to diverge from the proper state machine under attacker control.

[SMACK](https://mitls.org/pages/attacks/SMACK) is a similar suite of vulnerabilities found in JSSE,
CyaSSL, OpenSSL, Mono and axTLS.  "SKIP-TLS" demonstrated that some implementations allowed handshake
messages (and in one case, the entire handshake!) to be skipped leading to breaks in security.  "FREAK"
found that some implementations incorrectly allowed export-only state transitions (i.e., transitions that
were only valid when an export ciphersuite was in use).

rustls represents its protocol state machine carefully to avoid these defects.  We model the handshake,
CCS and application data subprotocols in the same single state machine.  Each state in this machine is
represented with a single struct, and transitions are modelled as functions that consume the current state
plus one TLS message[^1] and return a struct representing the next state.  These functions fully validate
the message type before further operations.

A sample sequence for a full TLSv1.2 handshake by a client looks like:

- `hs::ExpectServerHello` (Note: ClientHello is logically sent before this state); transition to `tls12::ExpectCertificate`
- `tls12::ExpectCertificate`; transition to `tls12::ExpectServerKX`
- `tls12::ExpectServerKX`; transition to `tls12::ExpectServerDoneOrCertReq`
- `tls12::ExpectServerDoneOrCertReq`; delegates to `tls12::ExpectCertificateRequest` or `tls12::ExpectServerDone` depending on incoming message.
  - `tls12::ExpectServerDone`; transition to `tls12::ExpectCCS`
- `tls12::ExpectCCS`; transition to `tls12::ExpectFinished`
- `tls12::ExpectFinished`; transition to `tls12::ExpectTraffic`
- `tls12::ExpectTraffic`; terminal state; transitions to `tls12::ExpectTraffic`

In the future we plan to formally prove that all possible transitions modelled in this system of types
are correct with respect to the standard(s).  At the moment we rely merely on exhaustive testing.

[^1]: a logical TLS message: post-decryption, post-fragmentation.


*/"implvulns.rs"_01_impl_vulnerabilities/// This section discusses vulnerabilities in other TLS implementations, theorising their/// root cause and how we aim to avoid them in rustls."tlsvulns.rs"_02_tls_vulnerabilities/// This section discusses vulnerabilities and design errors in the TLS protocol."howto.rs"_03_howto/// This section collects together goal-oriented documentation."features.rs"_04_features/// This section documents rustls itself: what protocol features are and are not implemented."defaults.rs"_05_defaults/// This section provides rationale for the defaults in rustls."fips.rs"_06_fips/// This section provides guidance on using rustls with FIPS-approved cryptography./*!

This documentation primarily aims to explain design decisions taken in rustls.

It does this from a few aspects: how rustls attempts to avoid construction errors
that occurred in other TLS libraries, how rustls attempts to avoid past TLS
protocol vulnerabilities, and assorted advice for achieving common tasks with rustls.
*//*! # A review of protocol vulnerabilities

## CBC MAC-then-encrypt ciphersuites

Back in 2000 [Bellare and Namprempre](https://eprint.iacr.org/2000/025) discussed how to make authenticated
encryption by composing separate encryption and authentication primitives.  That paper included this table:

| Composition Method | Privacy | | | Integrity | |
|--------------------|---------|-|-|-----------|-|
|| IND-CPA | IND-CCA | NM-CPA | INT-PTXT | INT-CTXT |
| Encrypt-and-MAC | insecure | insecure | insecure | secure | insecure |
| MAC-then-encrypt | secure | insecure | insecure | secure | insecure |
| Encrypt-then-MAC | secure | secure | secure | secure | secure |

One may assume from this fairly clear result that encrypt-and-MAC and MAC-then-encrypt compositions would be quickly abandoned
in favour of the remaining proven-secure option.  But that didn't happen, not in TLSv1.1 (2006) nor in TLSv1.2 (2008).  Worse,
both RFCs included incorrect advice on countermeasures for implementers, suggesting that the flaw was "not believed to be large
enough to be exploitable".

[Lucky 13](http://www.isg.rhul.ac.uk/tls/Lucky13.html) (2013) exploited this flaw and affected all implementations, including
those written [after discovery](https://aws.amazon.com/blogs/security/s2n-and-lucky-13/). OpenSSL even had a
[memory safety vulnerability in the fix for Lucky 13](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-2107), which
gives a flavour of the kind of complexity required to remove the side channel.

rustls does not implement CBC MAC-then-encrypt ciphersuites for these reasons.  TLSv1.3 removed support for these
ciphersuites in 2018.

There are some further rejected options worth mentioning: [RFC7366](https://tools.ietf.org/html/rfc7366) defines
Encrypt-then-MAC for TLS, but unfortunately cannot be negotiated without also supporting MAC-then-encrypt
(clients cannot express "I offer CBC, but only EtM and not MtE").

## RSA PKCS#1 encryption

"RSA key exchange" in TLS involves the client choosing a large random value and encrypting it using the server's
public key.  This has two overall problems:

1. It provides no _forward secrecy_: later compromise of the server's private key breaks confidentiality of
   *all* past sessions using that key.  This is a crucial property in the presence of software that is often
   [poor at keeping a secret](http://heartbleed.com/).
2. The padding used in practice in TLS ("PKCS#1", or fully "RSAES-PKCS1-v1_5") has been known to be broken since
   [1998](http://archiv.infsec.ethz.ch/education/fs08/secsem/bleichenbacher98.pdf).

In a similar pattern to the MAC-then-encrypt problem discussed above, TLSv1.0 (1999), TLSv1.1 (2006) and TLSv1.2 (2008)
continued to specify use of PKCS#1 encryption, again with incrementally more complex and incorrect advice on countermeasures.

[ROBOT](https://robotattack.org/) (2018) showed that implementations were still vulnerable to these attacks twenty years later.
[The Marvin Attack](https://people.redhat.com/~hkario/marvin/) (2023) demonstrated the same a further five years later.

rustls does not support RSA key exchange.  TLSv1.3 also removed support.

## BEAST

[BEAST](https://vnhacker.blogspot.com/2011/09/beast.html) ([CVE-2011-3389](https://nvd.nist.gov/vuln/detail/CVE-2011-3389))
was demonstrated in 2011 by Thai Duong and Juliano Rizzo,
and was another vulnerability in CBC-based ciphersuites in SSLv3.0 and TLSv1.0.  CBC mode is vulnerable to adaptive
chosen-plaintext attacks if the IV is predictable.  In the case of these protocol versions, the IV was the previous
block of ciphertext (as if the entire TLS session was one CBC ciphertext, albeit revealed incrementally).  This was
obviously predictable, since it was published on the wire.

OpenSSL contained a countermeasure for this problem from 2002 onwards: it encrypts an empty message before each real
one, so that the IV used in the real message is unpredictable.  This was turned off by default due to bugs in IE6.

TLSv1.1 fix this vulnerability, but not any of the other deficiencies of CBC mode (see above).

rustls does not support these ciphersuites.

## CRIME

In 2002 [John Kelsey](https://www.iacr.org/cryptodb/archive/2002/FSE/3091/3091.pdf) discussed the length side channel
as applied to compression of combined secret and attacker-chosen strings.

Compression continued to be an option in TLSv1.1 (2006) and in TLSv1.2 (2008).  Support in libraries was widespread.

[CRIME](https://en.wikipedia.org/wiki/CRIME) ([CVE-2012-4929](https://nvd.nist.gov/vuln/detail/CVE-2012-4929))
was demonstrated in 2012, again by Thai Duong and Juliano Rizzo.  It attacked several protocols offering transparent
compression of application data, allowing quick adaptive chosen-plaintext attacks against secret values like cookies.

rustls does not implement compression.  TLSv1.3 also removed support.

## Logjam / FREAK

Way back when SSL was first being born, circa 1995, the US government considered cryptography a munition requiring
export control.  SSL contained specific ciphersuites with dramatically small key sizes that were not subject
to export control.  These controls were dropped in 2000.

Since the "export-grade" ciphersuites no longer fulfilled any purpose, and because they were actively harmful to users,
one may have expected software support to disappear quickly. This did not happen.

In 2015 [the FREAK attack](https://mitls.org/pages/attacks/SMACK#freak) ([CVE-2015-0204](https://nvd.nist.gov/vuln/detail/CVE-2015-0204))
and [the Logjam attack](https://weakdh.org/) ([CVE-2015-4000](https://nvd.nist.gov/vuln/detail/CVE-2015-4000)) both
demonstrated total breaks of security in the presence of servers that accepted export ciphersuites.  FREAK factored
512-bit RSA keys, while Logjam optimised solving discrete logs in the 512-bit group used by many different servers.

Naturally, rustls does not implement any of these ciphersuites.

## SWEET32

Block ciphers are vulnerable to birthday attacks, where the probability of repeating a block increases dramatically
once a particular key has been used for many blocks.  For block ciphers with 64-bit blocks, this becomes probable
once a given key encrypts the order of 32GB of data.

[Sweet32](https://sweet32.info/) ([CVE-2016-2183](https://nvd.nist.gov/vuln/detail/CVE-2016-2183)) attacked this fact
in the context of TLS support for 3DES, breaking confidentiality by analysing a large amount of attacker-induced traffic
in one session.

rustls does not support any 64-bit block ciphers.

## DROWN

[DROWN](https://drownattack.com/) ([CVE-2016-0800](https://nvd.nist.gov/vuln/detail/CVE-2016-0800)) is a cross-protocol
attack that breaks the security of TLSv1.2 and earlier (when used with RSA key exchange) by using SSLv2.  It is required
that the server uses the same key for both protocol versions.

rustls naturally does not support SSLv2, but most importantly does not support RSA key exchange for TLSv1.2.

## Poodle

[POODLE](https://cdn1.vox-cdn.com/uploads/chorus_asset/file/2354994/ssl-poodle.0.pdf) ([CVE-2014-3566](https://nvd.nist.gov/vuln/detail/CVE-2014-3566))
is an attack against CBC mode ciphersuites in SSLv3.  This was possible in most cases because some clients willingly
downgraded to SSLv3 after failed handshakes for later versions.

rustls does not support CBC mode ciphersuites, or SSLv3.  Note that rustls does not need to implement `TLS_FALLBACK_SCSV`
introduced as a countermeasure because it contains no ability to downgrade from TLS 1.2 to earlier protocol versions,
and TLS 1.3 has protocol-level downgrade protection based on the [ServerHello server random value](https://www.rfc-editor.org/rfc/rfc8446#section-4.1.3).

## GCM nonces

[RFC5288](https://tools.ietf.org/html/rfc5288) introduced GCM-based ciphersuites for use in TLS.  Unfortunately
the design was poor; it reused design for an unrelated security setting proposed in RFC5116.

GCM is a typical nonce-based AEAD: it requires a unique (but not necessarily unpredictable) 96-bit nonce for each encryption
with a given key.  The design specified by RFC5288 left two-thirds of the nonce construction up to implementations:

- wasting 8 bytes per TLS ciphertext,
- meaning correct operation cannot be tested for (e.g., in protocol-level test vectors).

There were no trade-offs here: TLS has a 64-bit sequence number that is not allowed to wrap and would make an ideal nonce.

As a result, a [2016 study](https://eprint.iacr.org/2016/475.pdf) found:

- implementations from IBM, A10 and Citrix used randomly-chosen nonces, which are unlikely to be unique over long connections,
- an implementation from Radware used the same nonce for the first two messages.

rustls uses a counter from a random starting point for GCM nonces.  TLSv1.3 and the Chacha20-Poly1305 TLSv1.2 ciphersuite
standardise this method.

## Renegotiation

In 2009 Marsh Ray and Steve Dispensa [discovered](https://kryptera.se/Renegotiating%20TLS.pdf) that the renegotiation
feature of all versions of TLS allows a MitM to splice a request of their choice onto the front of the client's real HTTP
request.  A countermeasure was proposed and widely implemented to bind renegotiations to their previous negotiations;
unfortunately this was insufficient.

rustls does not support renegotiation in TLSv1.2.  TLSv1.3 also no longer supports renegotiation.

## 3SHAKE

[3SHAKE](https://www.mitls.org/pages/attacks/3SHAKE) (2014) described a complex attack that broke the "Secure Renegotiation" extension
introduced as a countermeasure to the previous protocol flaw.

rustls does not support renegotiation for TLSv1.2 connections, or RSA key exchange, and both are required for this attack
to work.  rustls implements the "Extended Master Secret" (RFC7627) extension for TLSv1.2 which was standardised as a countermeasure.

TLSv1.3 no longer supports renegotiation and RSA key exchange.  It also effectively incorporates the improvements made in RFC7627.

## KCI

[This vulnerability](https://kcitls.org/) makes use of TLS ciphersuites (those offering static DH) which were standardised
yet not widely used. However, they were implemented by libraries, and as a result enabled for various clients.  It coupled
this with misconfigured certificates (on services including facebook.com) which allowed their misuse to MitM connections.

rustls does not support static DH/EC-DH ciphersuites.  We assert that it is misissuance to sign an EC certificate
with the keyUsage extension allowing both signatures and key exchange.  That it isn't is probably a failure
of CAB Forum baseline requirements.
*//// An externally length'd payload/// An arbitrary, unknown-content, u24-length-prefixed payloadMaybeEmpty/// An arbitrary, unknown-content, u16-length-prefixed payload/// The `C` type parameter controls whether decoded values may/// be empty./// An arbitrary, unknown-content, u8-length-prefixed payload/// `C` controls the minimum length accepted when decoding.// Format an iterator of u8 into a hex string/// The underlying buffer storing the readers content/// Stores the current reading position for the buffer/// Wrapper over a slice of bytes that allows reading chunks from/// with the current position state held using a cursor./// A new reader for a sub section of the buffer can be created/// using the `sub` function or a section of a certain length can/// be obtained using the `take` function/// Creates a new Reader of the provided `bytes` slice with/// the initial cursor position of zero./// Attempts to create a new Reader on a sub section of this/// readers bytes by taking a slice of the provided `length`/// will return None if there is not enough bytes/// Borrows a slice of all the remaining bytes/// that appear after the cursor position./// Moves the cursor to the end of the buffer length./// Attempts to borrow a slice of bytes from the current/// cursor position of `length` if there is not enough/// bytes remaining after the cursor to take the length/// then None is returned instead.any_left/// Used to check whether the reader has any content left/// after the cursor (cursor has not reached end of buffer)expect_empty/// Returns the cursor position which is also the number/// of bytes that have been read from the buffer./// Returns the number of bytes that are still able to be/// read (The number of remaining takes)/// Function for encoding itself by appending itself to/// the provided vec of bytes./// Function for decoding itself from the provided reader/// will return Some if the decoding was successful or/// None if it was not./// Convenience function for encoding the implementation/// into a vec and returning it/// Function for wrapping a call to the read function in/// a Reader for the slice of bytes provided/// Returns `Err(InvalidMessage::ExcessData(_))` if/// `Self::read` does not read the entirety of `bytes`./// Trait for implementing encoding and decoding functionality/// on something.// Make a distinct type for u24, even though it's a u32 underneathTlsListElement/// Implement `Codec` for lists of elements that implement `TlsListElement`./// `TlsListElement` provides the size of the length prefix for the list.SIZE_LENListLength/// A trait for types that can be encoded and decoded in a list./// This trait is used to implement `Codec` for `Vec<T>`. Lists in the TLS wire format are/// prefixed with a length, the size of which depends on the type of the list elements./// As such, the `Codec` implementation for `Vec<T>` requires an implementation of this trait/// for its element type `T`.empty_error/// U8 but non-empty/// U16, perhaps empty/// U16 but non-empty/// U24 with imposed upper bound/// The length of the length prefix for a list./// The types that appear in lists are limited to three kinds of length prefixes:/// 1, 2, and 3 bytes. For the latter kind, we require a `TlsListElement` implementer/// to specify a maximum length and error if the actual length is larger.len_offsetsize_lenLengthPrefixedBuffer/// Tracks encoding a length-delimited structure in a single pass./// Inserts a dummy length into `buf`, and remembers where it went./// After this, the body of the length-delimited structure should be appended to `LengthPrefixedBuffer::buf`./// The length header is corrected in `LengthPrefixedBuffer::drop`./// Goes back and corrects the length previously inserted at the start of the structure.interrupted_length_prefixed_buffer_leaves_maximum_lengthMAX_WIRE_SIZE/// Conversion from a slice within a larger buffer into/// a `Range` offset within.locatefully_contains/// Conversion from a `Range` offset to the original slice.slice_from_rangelocatorCoalescer/// Reordering the underlying buffer based on ranges.delocatorprocessed/// Prefix of the buffer that has been processed so far./// `processed` may exceed `discard`, that means we have parsed/// some buffer, but are still using it.  This happens due to/// in-place decryption of incoming records, and in-place/// reassembly of handshake messages./// 0 <= processed <= len/// Prefix of the buffer that can be removed./// If `discard` exceeds `processed`, that means we are ignoring/// data without processing it./// 0 <= discard <= len/// Accounting structure tracking progress in parsing a single buffer.add_discardadd_processedtake_discard/// Buffer of data read from the socket, in the process of being parsed into messages./// For buffer size management, checkout out the [`DeframerVecBuffer::prepare_read()`] method./// What size prefix of `buf` is used./// Discard `taken` bytes from the start of our buffer.filled_mut/// Read some bytes from `rd`, and add them to the buffer.prepare_read/// Resize the internal `buf` if necessary for reading more bytes./// Append `bytes` to the end of this buffer./// Return a `Range` saying where it went.// a fully initialized buffer that will be deframed// number of bytes to discard from the front of `buf` at a later time/// A borrowed version of [`DeframerVecBuffer`] that tracks discard operationsqueue_discard/// Tracks a pending discard operation of `num_bytes`pending_discardFragmentSpan/// Spans covering individual handshake payloads, in order of receipt.outer_discard/// Discard value, tracking the rightmost extent of the last message/// in `spans`.input_message/// Accepts a message into the deframer./// `containing_buffer` allows mapping the message payload to its position/// in the input buffer, and thereby avoid retaining a borrow on the input/// That is required because our processing of handshake messages requires/// them to be contiguous (and avoiding that would mean supporting gather-based/// parsing in a large number of places, including `core`, `webpki`, and the/// `CryptoProvider` interface).  `coalesce()` arranges for that to happen, but/// to do so it needs to move the fragments together in the original buffer./// This would not be possible if the messages were borrowing from that buffer./// `outer_discard` is the rightmost extent of the original message./// Returns a `BufferProgress` that skips over unprocessed handshake data.has_message_ready/// Do we have a message ready? ie, would `iter().next()` return `Some`?/// Do we have any message data, partial or otherwise?/// We are "aligned" if there is no partial fragment of a handshakeHandshakeIter/// Iterate over the complete messages./// Coalesce the handshake portions of the given buffer,/// This does nothing if there is nothing to do./// In a normal TLS stream, handshake messages need not be contiguous./// For example, each handshake message could be delivered in its own/// outer TLS message.  This would mean the handshake messages are/// separated by the outer TLS message headers, and likely also/// separated by encryption overhead (any explicit nonce in front,/// any padding and authentication tag afterwards)./// For a toy example of one handshake message in two fragments, and:/// - the letter `h` for handshake header octets/// - the letter `H` for handshake payload octets/// - the letter `x` for octets in the buffer ignored by this code,/// the buffer and `spans` data structure could look like:/// 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9/// x x x x x h h h h H H H x x x x x H H H H H H x x x///           '------------'          '----------'///            |                               |/// spans = [ { bounds = (5, 12),              |///              size = Some(9), .. },         |///                                 { bounds = (17, 23), .. } ]/// In this case, `requires_coalesce` returns `Some(0)`.  Then/// `coalesce_one` moves the second range leftwards:///                         '----------'///                          ^        '----------'///                          |         v///                          '--<---<--'///                 copy_within(from = (17, 23),///                             to = (12, 18))/// Leaving the buffer and spans:/// x x x x x h h h h H H H H H H H H H x x x x x x x x///           '------------------------'///            |/// spans = [ { bounds = (5, 18), size = Some(9), .. } ]coalesce_one/// Within `containing_buffer`, move `span[index+1]` to be contiguous/// with `span[index]`.requires_coalesce/// We require coalescing if any span except the last is not complete./// Returns an index into `spans` for the first non-complete span:/// this will never be the last item.containing_bufferDissectHandshakeIter/// version taken from containing message./// size of the handshake message body (excluding header)/// `None` means the size is unknown, because `bounds` is not/// large enough to encompass a whole header./// bounds of the handshake message, including header/// A `FragmentSpan` is "complete" if its size is known, and its/// bounds exactly encompasses one handshake message.HANDSHAKE_HEADER_LENMAX_HANDSHAKE_SIZE/// TLS allows for handshake messages of up to 16MB.  We/// restrict that to 64KB to limit potential for denial-of-coalesce_rejects_excess_size_messageiter_only_returns_full_messageshandshake_flightHEADER_SIZEread_opaque_message_header/// A deframer of TLS wire messages./// Returns `Some(Ok(_))` containing each `InboundOpaqueMessage` deframed/// Returns `None` if no further messages can be deframed from the/// buffer.  More data is required for further progress./// Returns `Some(Err(_))` if the peer is not talking TLS, but some/// other protocol.  The caller should abort the connection, because/// the deframer cannot recover./// Call `bytes_consumed()` to learn how many bytes the iterator has/// processed from the front of the original buffer.  This is only updated/// when a message is successfully deframed (ie. `Some(Ok(_))` is returned)./// Make a new `DeframerIter`/// How many bytes were processed successfully from the front/// of the buffer passed to `new()`?iterator_empty_before_header_receivediterate_one_messageiterate_two_messagesiterator_invalid_protocol_version_rejectediterator_invalid_content_type_rejectediterator_excess_message_length_rejectediterator_zero_message_length_rejectediterator_over_many_messagesexercise_fuzz_deframerr" The `HashAlgorithm` TLS protocol enum.  Values in this enum are taken"r" The `ClientCertificateType` TLS protocol enum.  Values in this enum are taken"RSASignDSSSignRSAFixedDHDSSFixedDHRSAEphemeralDHDSSEphemeralDHFortezzaDMSECDSASignRSAFixedECDHECDSAFixedECDHr" The `Compression` TLS protocol enum.  Values in this enum are taken"LSZr" The `AlertLevel` TLS protocol enum.  Values in this enum are taken"r" The `HeartbeatMessageType` TLS protocol enum.  Values in this enum are taken"HeartbeatMessageTyper" The `ExtensionType` TLS protocol enum.  Values in this enum are taken"MaxFragmentLengthClientCertificateUrlTrustedCAKeysTruncatedHMACStatusRequestUserMappingClientAuthzServerAuthzEllipticCurvesECPointFormatsSRPUseSRTPALProtocolNegotiationSCTServerCertificateTypeExtendedMasterSecretCompressCertificateSessionTicketPreSharedKeySupportedVersionsPSKKeyExchangeModesTicketEarlyDataInfoCertificateAuthoritiesOIDFiltersPostHandshakeAuthSignatureAlgorithmsCertKeyShareNextProtocolNegotiationChannelIdTransportParametersDraftEncryptedClientHelloOuterExtensionsech_compress/// Returns true if the extension type can be compressed in an "inner" client hello for ECH./// This function should only return true for extension types where the inner hello and outer/// hello extensions values will always be identical. Extensions that may be identical/// sometimes (e.g. server name, cert compression methods), but not always, SHOULD NOT be/// compressed./// See [draft-ietf-esni-18 §5](https://datatracker.ietf.org/doc/html/draft-ietf-tls-esni-18#section-5)/// and [draft-ietf-esni-18 §10.5](https://datatracker.ietf.org/doc/html/draft-ietf-tls-esni-18#section-10.5)r" The `ServerNameType` TLS protocol enum.  Values in this enum are taken"ServerNameTypeHostNamer" The `NamedCurve` TLS protocol enum.  Values in this enum are taken"r" This enum is used for recognizing elliptic curve parameters advertised"r" by a peer during a TLS handshake. It is **not** a list of curves that"r" Rustls supports. See [`crate::crypto::ring::kx_group`] for the list of supported"r" elliptic curve groups."sect163k1sect163r1sect163r2sect193r1sect193r2sect233k1sect233r1sect239k1sect283k1sect283r1sect409k1sect409r1sect571k1sect571r1secp160k1secp160r1secp160r2secp192k1secp192r1secp224k1secp224r1secp256k1secp256r1secp384r1secp521r1brainpoolp256r1brainpoolp384r1brainpoolp512r1arbitrary_explicit_prime_curvesarbitrary_explicit_char2_curvesr" The `NamedGroup` TLS protocol enum.  Values in this enum are taken"FFDHE2048FFDHE3072FFDHE4096FFDHE6144FFDHE8192MLKEM512MLKEM1024secp256r1MLKEM768key_exchange_algorithm/// Return the key exchange algorithm associated with this `NamedGroup`r" The `ECPointFormat` TLS protocol enum.  Values in this enum are taken"ANSIX962CompressedPrimeANSIX962CompressedChar2r" The `HeartbeatMode` TLS protocol enum.  Values in this enum are taken"HeartbeatModePeerAllowedToSendPeerNotAllowedToSendr" The `ECCurveType` TLS protocol enum.  Values in this enum are taken"ExplicitPrimeExplicitChar2r" The `PskKeyExchangeMode` TLS protocol enum.  Values in this enum are taken"PSK_KEPSK_DHE_KEr" The `KeyUpdateRequest` TLS protocol enum.  Values in this enum are taken"UpdateNotRequestedUpdateRequestedr" The `CertificateStatusType` TLS protocol enum.  Values in this enum are taken"CertificateStatusTyper" The Key Encapsulation Mechanism (`Kem`) type for HPKE operations."r" Listed by IANA, as specified in [RFC 9180 Section 7.1]"r" [RFC 9180 Section 7.1]: <https://datatracker.ietf.org/doc/html/rfc9180#kemid-values>"DHKEM_P256_HKDF_SHA256DHKEM_P384_HKDF_SHA384DHKEM_P521_HKDF_SHA512DHKEM_X25519_HKDF_SHA256DHKEM_X448_HKDF_SHA512r" The Key Derivation Function (`Kdf`) type for HPKE operations."r" Listed by IANA, as specified in [RFC 9180 Section 7.2]"r" [RFC 9180 Section 7.2]: <https://datatracker.ietf.org/doc/html/rfc9180#name-key-derivation-functions-kd>"// TODO(XXX): revisit the default configuration. This is just what Cloudflare ships right now.r" The Authenticated Encryption with Associated Data (`Aead`) type for HPKE operations."r" Listed by IANA, as specified in [RFC 9180 Section 7.3]"r" [RFC 9180 Section 7.3]: <https://datatracker.ietf.org/doc/html/rfc9180#name-authenticated-encryption-wi>"CHACHA20_POLY_1305EXPORT_ONLY/// Returns the length of the tag for the AEAD algorithm, or none if the AEAD is EXPORT_ONLY.r" The Encrypted Client Hello protocol version (`EchVersion`)."r" Specified in [draft-ietf-tls-esni Section 4]."r" TODO(XXX): Update reference once RFC is published."r" [draft-ietf-tls-esni Section 4]: <https://www.ietf.org/archive/id/draft-ietf-tls-esni-17.html#section-4>"get8get16// These tests are intended to provide coverage and// check panic-safety of relatively unused values./// Parameters of an FFDHE group, with Big-endian byte orderfrom_named_group/// Return the `FfdheGroup` corresponding to the provided `NamedGroup`/// if it is indeed an FFDHE groupnamed_group/// Return the `NamedGroup` for the `FfdheGroup` if it represents one.from_params_trimming_leading_zeros/// Construct an `FfdheGroup` from the given `p` and `g`, trimming any potential leading zeros./// FFDHE2048 group defined in [RFC 7919 Appendix A.1]/// [RFC 7919 Appendix A.1]: https://datatracker.ietf.org/doc/html/rfc7919#appendix-A.1/// FFDHE3072 group defined in [RFC 7919 Appendix A.2]/// [RFC 7919 Appendix A.2]: https://datatracker.ietf.org/doc/html/rfc7919#appendix-A.2/// FFDHE4096 group defined in [RFC 7919 Appendix A.3]/// [RFC 7919 Appendix A.3]: https://datatracker.ietf.org/doc/html/rfc7919#appendix-A.3/// FFDHE6144 group defined in [RFC 7919 Appendix A.4]/// [RFC 7919 Appendix A.4]: https://datatracker.ietf.org/doc/html/rfc7919#appendix-A.4/// FFDHE8192 group defined in [RFC 7919 Appendix A.5]/// [RFC 7919 Appendix A.5]: https://datatracker.ietf.org/doc/html/rfc7919#appendix-A.5named_group_ffdhe_group_roundtrip//! This module contains parameters for FFDHE named groups as defined//! in [RFC 7919 Appendix A](https://datatracker.ietf.org/doc/html/rfc7919#appendix-A).PACKET_OVERHEADMAX_FRAGMENT_SIZEfragment_message/// Take `msg` and fragment it into new messages with the same type and version./// Each returned message size is no more than `max_frag`./// Return an iterator across those messages./// Payloads are borrowed from `msg`.fragment_payload/// Take `payload` and fragment it into new messages with given type and version./// Payloads are borrowed from `payload`./// Set the maximum fragment size that will be produced./// This includes overhead. A `max_fragment_size` of 10 will produce TLS fragments/// up to 10 bytes long./// A `max_fragment_size` of `None` sets the highest allowable fragment size./// Returns BadMaxFragmentSize if the size is smaller than 32 or larger than 16389./// An iterator over borrowed fragments of a payloadmsg_eqnon_fragmentfragment_multiple_sliceswrap_in_sequencewrapped_payload/// Create a newtype wrapper around a given type./// This is used to create newtypes for the various TLS message types which is used to wrap/// the `PayloadU8` or `PayloadU16` types. This is typically used for types where we don't need/// anything other than access to the underlying bytes.HELLO_RETRY_REQUEST_RANDOMZERO_RANDOMUnknownExtension/// RFC8422: `ECPointFormat ec_point_format_list<1..2^8-1>`/// RFC8422: `NamedCurve named_curve_list<2..2^16-1>`/// RFC8446: `SignatureScheme supported_signature_algorithms<2..2^16-2>;`SingleDnsName/// A successfully decoded value:/// A DNS name which was actually an IP address/// A successfully decoded, but syntactically-invalid value./// RFC6066: `ServerName server_name_list<1..2^16-1>`/// Simplified encoding/decoding for a `ServerName` extension payload to/from `DnsName`/// This is possible because:/// - the spec (RFC6066) disallows multiple names for a given name type/// - name types other than ServerNameType::HostName are not defined, and they and///   any data that follows them cannot be skipped over.HostNamePayloadr" RFC7301: `opaque ProtocolName<1..2^8-1>;`"/// RFC7301: `ProtocolName protocol_name_list<2..2^16-1>`SingleProtocolName/// RFC7301 encodes a single protocol name as `Vec<ProtocolName>`/// RFC8446: `opaque key_exchange<1..2^16-1>;`// --- TLS 1.3 Key shares ---/// RFC8446: `opaque identity<1..2^16-1>;`obfuscated_ticket_age// --- TLS 1.3 PresharedKey offers ---/// RFC8446: `PskIdentity identities<7..2^16-1>;`r" RFC8446: `opaque PskBinderEntry<32..255>;`"/// RFC8446: `PskBinderEntry binders<33..2^16-1>;`binders/// Make a new one with one entry.ResponderId// --- RFC6066 certificate status request ---/// RFC6066: `ResponderID responder_id_list<0..2^16-1>;`responder_idsOcspCertificateStatusRequestOcspbuild_ocsp/// RFC8446: `PskKeyExchangeMode ke_modes<1..255>;`/// RFC8446: `KeyShareEntry client_shares<0..2^16-1>;`/// The body of the `SupportedVersions` extension when it appears in a/// `ClientHello`/// This is documented as a preference-order vector, but we (as a server)/// ignore the preference of the client./// RFC8446: `ProtocolVersion versions<2..254>;`/// Return true if `filter` returns true for any enabled version.LIST_LENGTH/// RFC7250: `CertificateType client_certificate_types<1..2^8-1>;`/// Ditto `CertificateType server_certificate_types<1..2^8-1>;`/// RFC8879: `CertificateCompressionAlgorithm algorithms<2..2^8-2>;`EcPointFormatsNamedGroupsProtocolsPresharedKeyModesPresharedKeyExtendedMasterSecretRequestServerCertTypesClientCertTypesCertificateCompressionAlgorithmsAuthorityNamesext_typetrim_hostname_trailing_dot_for_sniOfferServerNameAckSessionTicketAckExtendedMasterSecretAckCertificateStatusAckServerCertTypeClientCertTypeServerEncryptedClientHellomake_empty_renegotiation_infoclient_versionech_inner_encodingpayload_encodehas_duplicate_extension/// Returns true if there is more than one extension of a givenfind_extensionsni_extensionsigalgs_extensionnamedgroups_extensionecpoints_extensionserver_certificate_extensionclient_certificate_extensionalpn_extensionquic_params_extensionticket_extensionversions_extensionkeyshare_extensionhas_keyshare_extension_with_duplicatescheck_psk_ext_is_lastpsk_modespsk_mode_offeredset_psk_binderems_support_offeredearly_data_extension_offeredcertificate_compression_extensionhas_certificate_compression_extension_with_duplicatescertificate_authorities_extension/// RFC8446: `CipherSuite cipher_suites<2..2^16-2>;`/// RFC5246: `CompressionMethod compression_methods<1..2^8-1>;`/// draft-ietf-tls-esni-17: `ExtensionType OuterExtensions<2..254>;`EchHelloRetryRequestlegacy_versionhas_unknown_extensionrequested_key_share_group// minus version and random, which have already been read.key_sharepsk_indexems_support_acked/// TLS has a 16MB size limit on any handshake message,/// plus a 16MB limit on any given certificate./// We contract that to 64KB to limit the amount of memory allocation/// that is directly controllable by the peer.CertificateExtensioncert_statusCertificateEntryany_entry_has_duplicate_extensionany_entry_has_unknown_extensionany_entry_has_extensionend_entity_ocspinto_certificate_chainDHE/// Diffie-Hellman Key exchange (with only known parameters as defined in [RFC 7919])./// [RFC 7919]: https://datatracker.ietf.org/doc/html/rfc7919ECDHE/// Key exchange performed via elliptic curve Diffie-Hellman./// Describes supported key exchange mechanisms.curve_type// We don't support arbitrary curves.  It's a terrible// idea and unnecessary attack surface.  Please,// get a grip./// Decode a key exchange message given the key_exchange `algo`KxDecodeEcdh/// RFC4492: `opaque point <1..2^8-1>;`/// RFC5246: `opaque dh_Yc<1..2^16-1>;`curve_paramsdh_p/// RFC5246: `opaque dh_p<1..2^16-1>;`dh_g/// RFC5246: `opaque dh_g<1..2^16-1>;`dh_Ys/// RFC5246: `opaque dh_Ys<1..2^16-1>;`ServerDhParamsas_ffdhe_groupdssunwrap_given_kxaserver_cert_typeclient_cert_typeserver_ech_extension/// RFC5246: `ClientCertificateType certificate_types<1..2^8-1>;`r" A `DistinguishedName` is a `Vec<u8>` wrapped in internal types."r" It contains the DER or BER encoded [`Subject` field from RFC 5280](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6)"r" for a single certificate. The Subject field is [encoded as an RFC 5280 `Name`](https://datatracker.ietf.org/doc/html/rfc5280#page-116)."r" It can be decoded using [x509-parser's FromDer trait](https://docs.rs/x509-parser/latest/x509_parser/prelude/trait.FromDer.html)."r" for name in distinguished_names {"r"     use x509_parser::prelude::FromDer;"r#"     println!("{}", x509_parser::x509::X509Name::from_der(&name.0)?.1);"#r" The TLS encoding is defined in RFC5246: `opaque DistinguishedName<1..2^16-1>;`"/// Create a [`DistinguishedName`] after prepending its outer SEQUENCE encoding./// This can be decoded using [x509-parser's FromDer trait](https://docs.rs/x509-parser/latest/x509_parser/prelude/trait.FromDer.html)./// use x509_parser::prelude::FromDer;/// println!("{}", x509_parser::x509::X509Name::from_der(dn.as_ref())?.1);/// RFC8446: `DistinguishedName authorities<3..2^16-1>;` however,/// RFC5246: `DistinguishedName certificate_authorities<0..2^16-1>;`certtypessigschemescanamesCertificateRequestPayloadCertReqExtensionCertificateRequestPayloadTls13authorities_extensionlifetime_hint// Tickets can be large (KB), so we deserialise this straight// into an Arc, so it can be passed directly into the client's// session object without copying.// -- NewSessionTicket --NewSessionTicketExtension// -- NewSessionTicket electric boogaloo --age_addmax_early_data_size/// Only supports OCSPuncompressed_lenas_borrowedCertificateTls13CertificateRequestTls13NewSessionTicketTls13wire_handshake_typeencoding_for_binder_signingtotal_binder_lengthbuild_handshake_hash/// draft-ietf-tls-esni-24: `HpkeSymmetricCipherSuite cipher_suites<4..2^16-4>;`/// draft-ietf-tls-esni-24: `opaque HpkePublicKey<1..2^16-1>;`symmetric_cipher_suiteskey_configpublic_nameEchConfigExtensionhas_unknown_mandatory_extension/// Returns true if there is at least one mandatory unsupported extension./// A recognized V18 ECH configuration./// An unknown version ECH configuration./// An encrypted client hello (ECH) config./// A `ECHClientHello` with type [EchClientHelloType::ClientHelloOuter]./// An empty `ECHClientHello` with type [EchClientHelloType::ClientHelloInner]./// This variant has no payload./// Representation of the `ECHClientHello` client extension specified in/// [draft-ietf-tls-esni Section 5]./// [draft-ietf-tls-esni Section 5]: <https://www.ietf.org/archive/id/draft-ietf-tls-esni-18.html#section-5>/// The cipher suite used to encrypt ClientHelloInner. Must match a value from/// ECHConfigContents.cipher_suites list./// The ECHConfigContents.key_config.config_id for the chosen ECHConfig./// The HPKE encapsulated key, used by servers to decrypt the corresponding payload field./// This field is empty in a ClientHelloOuter sent in response to a HelloRetryRequest./// The serialized and encrypted ClientHelloInner structure, encrypted using HPKE./// Representation of the ECHClientHello extension with type outer specified inretry_configs/// Representation of the ECHEncryptedExtensions extension specified in/// Standard RFC 8446 encoding.EchConfirmation/// Encoding for ECH confirmation.to_compressEchInnerHello/// Encoding for ECH inner client hello./// The method of encoding to use for a handshake message./// In some cases a handshake message may be encoded differently depending on the purpose/// the encoded message is being used for. For example, a [ServerHelloPayload] may be encoded/// with the last 8 bytes of the random zeroed out when being encoded for ECH confirmation.has_duplicatestest_ech_config_dupe_extstest_ech_config_mandatory_extsconfig_template// -- EncryptedExtensions (TLS1.3 only) --// -- RFC6066 certificate status types// -- RFC8879 compressed certificatesrejects_short_randomreads_randomdebug_randomrejects_truncated_session_idrejects_session_id_with_bad_lengthsession_id_with_different_lengths_are_unequalaccepts_short_session_idaccepts_empty_session_iddebug_session_idcan_round_trip_unknown_client_extrefuses_client_ext_with_unparsed_bytesrefuses_server_ext_with_unparsed_bytesrefuses_certificate_ext_with_unparsed_bytesrefuses_certificate_req_ext_with_unparsed_bytesrefuses_helloreq_ext_with_unparsed_bytesrefuses_new_session_ticket_ext_with_unparsed_bytescan_round_trip_single_snican_round_trip_mixed_case_snisingle_hostname_returns_none_for_other_sni_name_typesrejects_truncated_snirejects_empty_sni_extensionrejects_duplicate_names_in_sni_extensioncan_round_trip_psk_identitycan_round_trip_psk_offercan_round_trip_cert_status_req_for_ocspcan_round_trip_cert_status_req_for_othercan_round_trip_multi_protocan_round_trip_single_protocan_print_all_client_extensionscan_clone_all_client_extensionsclient_has_duplicate_extensions_workstest_truncated_psk_offertest_truncated_client_hello_is_detectedtest_truncated_client_extension_is_detectedclient_sni_extensionclient_sigalgs_extensionclient_namedgroups_extensionclient_ecpoints_extensionclient_alpn_extensionclient_client_certificate_extensionclient_server_certificate_extensionclient_quic_params_extensionclient_versions_extensionclient_keyshare_extensionclient_pskclient_psk_modestest_client_extension_gettertest_truncated_hello_retry_extension_is_detectedhello_retry_requested_key_share_grouphello_retry_cookiehello_retry_supported_versionstest_hello_retry_extension_gettertest_truncated_server_extension_is_detectedtest_server_extension_getterserver_key_shareserver_psk_indexserver_ecpoints_extensionserver_supported_versionsserver_client_certificate_type_extensionserver_server_certificate_type_extensioncert_entry_ocsp_responsetest_cert_extension_gettercan_print_all_server_extensionscan_clone_all_server_extensionscan_round_trip_all_tls12_handshake_payloadscan_into_owned_all_tls12_handshake_payloadscan_detect_truncation_of_all_tls12_handshake_payloadscan_round_trip_all_tls13_handshake_payloadscan_into_owned_all_tls13_handshake_payloadscan_detect_truncation_of_all_tls13_handshake_payloadsput_u24cannot_read_message_hash_from_networkcannot_decode_huge_certificatecan_decode_server_hello_from_api_devicecheck_apple_comwrapped_dn_encodingsample_hello_retry_requestsample_client_hello_payloadsample_server_hello_payloadall_tls12_handshake_payloadsall_tls13_handshake_payloadssample_certificate_payload_tls13sample_compressed_certificatesample_ecdhe_server_key_exchange_payloadsample_dhe_server_key_exchange_payloadsample_unknown_server_key_exchange_payloadsample_certificate_request_payloadsample_certificate_request_payload_tls13sample_new_session_ticket_payloadsample_new_session_ticket_payload_tls13sample_encrypted_extensionssample_certificate_status/// A macro which defines an enum type./// A TLS frame, named TLSPlaintext in the standard./// This inbound type borrows its encrypted payload from a buffer elsewhere./// It is used for joining and is consumed by decryption./// Construct a new `InboundOpaqueMessage` from constituent fields./// `payload` is borrowed.into_plain_message/// Force conversion into a plaintext message./// This should only be used for messages that are known to be in plaintext. Otherwise, the/// `InboundOpaqueMessage` should be decrypted into a `PlainMessage` using a `MessageDecrypter`.into_plain_message_range/// `range` restricts the resulting message: this function panics if it is out of range for/// the underlying message payload.into_tls13_unpadded_message/// For TLS1.3 (only), checks the length msg.payload is valid and removes the padding./// Returns an error if the message (pre-unpadding) is too long, or the padding is invalid,/// or the message (post-unpadding) is too long./// A TLS frame, named `TLSPlaintext` in the standard./// This inbound type borrows its decrypted payload from the original buffer./// It results from decryption.is_valid_ccs/// Returns true if the payload is a CCS message./// We passthrough ChangeCipherSpec messages in the deframer without decrypting them./// Note: this is prior to the record layer, so is unencrypted. See/// third paragraph of section 5 in RFC8446.unpad_tls13_payload/// Decode a TLS1.3 `TLSInnerPlaintext` encoding./// `p` is a message payload, immediately post-decryption.  This function/// removes zero padding bytes, until a non-zero byte is encountered which is/// the content type, which is returned.  See RFC8446 s5.2./// ContentType(0) is returned if the message payload is empty or all zeroes.// one handshake message, parsed// (potentially) multiple handshake messages, unparsed/// A decrypted TLS frame/// This type owns all memory for its interior parts. It can be decrypted from an OpaqueMessage/// or encrypted into an OpaqueMessage, and it is also used for joining and fragmenting.into_unencrypted_opaqueborrow_inboundborrow_outbound/// A message with decoded payloadis_handshake_typebuild_alertbuild_key_update_notifybuild_key_update_requestinto_wire_bytes/// Parses a plaintext message into a well-typed [`Message`]./// A [`PlainMessage`] must contain plaintext content. Encrypted content should be stored in an/// [`InboundOpaqueMessage`] and decrypted before being stored into a [`PlainMessage`].TooShortForHeaderTooShortForLength/// Content type, version and size.MAX_PAYLOAD/// Maximum message payload size./// That's 2^14 payload bytes and a 2KB allowance for ciphertext overheads./// Maximum on-the-wire message size./// This outbound type borrows its "to be encrypted" payload from the "user"./// It is used for fragmenting and is consumed by encryption.to_unencrypted_opaque/// A single byte slice. Contrary to `Multiple`, this uses a single pointer indirection/// A collection of chunks (byte slices)/// and cursors to single out a fragmented range of bytes./// OutboundChunks assumes that start <= end/// A collection of borrowed plaintext slices./// Warning: OutboundChunks does not guarantee that the simplest variant is used./// Multiple can hold non fragmented or empty payloads./// Create a payload from a slice of byte slices./// If fragmented the cursors are added by default: start = 0, end = length/// Create a payload with a single empty slice/// Flatten the slice of byte slices to an owned vector of bytescopy_to_vec/// Append all bytes to a vector/// Split self in two, around an index/// Works similarly to `split_at` in the core library, except it doesn't panic if out of bound/// Returns true if the payload is empty/// Returns the cumulative length of all chunks/// This outbound type owns all memory for its interior parts./// It results from encryption and is used for io write./// Construct a new `OpaqueMessage` from constituent fields./// `body` is moved into the `payload` field./// Construct by decoding from a [`Reader`]./// `MessageError` allows callers to distinguish between valid prefixes (might/// become valid if we read more data) and invalid data./// `OutboundOpaqueMessage` should be decrypted into a `PlainMessage` using a `MessageDecrypter`.extend_from_chunkssplit_at_with_single_slicesplit_at_with_multiple_slicessplit_out_of_boundsempty_slices_mixedexhaustive_splittingtest_read_fuzz_corpuscan_read_safari_client_hello_with_ip_address_in_sni_extensionalert_is_not_handshakeconstruct_all_typesdebug_payloadinto_wire_formatmessage_testsmoketest//! <https://langsec.org> cat says://!  ___ _   _ _    _      ___ ___ ___ ___   ___ _  _ ___ _____ ___ ___  _  _//! | __| | | | |  | |    | _ \ __/ __/ _ \ / __| \| |_ _|_   _|_ _/ _ \| \| |//! | _|| |_| | |__| |__  |   / _| (_| (_) | (_ | .` || |  | |  | | (_) | .` |//! |_|  \___/|____|____| |_|_\___\___\___/ \___|_|\_|___| |_| |___\___/|_|\_|//!                      .__....._             _.....__,//!                        .": o :':         ;': o :".//!                        `. `-' .'.       .'. `-' .'//!                          `---'             `---'//!                _...----...      ...   ...      ...----..._//!             .-'__..-""'----    `.  `"`  .'    ----'""-..__`-.//!            '.-'   _.--"""'       `-._.-'       '"""--._   `-.`//!            '  .-"'                  :                  `"-.  `//!              '   `.              _.'"'._              .'   `//!                    `.       ,.-'"       "'-.,       .'//!                      `.                           .'//!                        `-._                   _.-'//!                            `"'--...___...--'"`//!  ___ ___ ___ ___  ___ ___   ___ ___  ___   ___ ___ ___ ___ ___ _  _  ___//! | _ ) __| __/ _ \| _ \ __| | _ \ _ \/ _ \ / __| __/ __/ __|_ _| \| |/ __|//! | _ \ _|| _| (_) |   / _|  |  _/   / (_) | (__| _|\__ \__ \| || .` | (_ |//! |___/___|_| \___/|_|_\___| |_| |_|_\\___/ \___|___|___/___/___|_|\_|\___|//! <https://langsec.org/ForWantOfANail-h2hc2014.pdf>retrieved_athas_expiredquic_paramsrewind_epoch/// Test only: rewind epoch by `delta` seconds._private_set_max_early_data_size/// Test only: replace `max_early_data_size` with `new`set_quic_paramsextended_mslifetime_secsclient_credsMAX_TICKET_LIFETIMEMAX_FRESHNESS_SKEW_MS/// This is the maximum allowed skew between server and client clocks, over/// the maximum ticket lifetime period.  This encompasses TCP retransmission/// times in case packet loss occurs when the client sends the ClientHello/// or receives the NewSessionTicket, _and_ actual clock skew over this period.client_cert_chaincreation_time_secage_obfuscation_offsetfreshness// --- Server types ---set_extended_ms_usedset_freshnessis_freshserversessionvalue_is_debug// for UnixTime::nowserversessionvalue_no_sniserversessionvalue_with_cert/// Non-panicking `let (nonce, ciphertext) = ciphertext.split_at(...)`.// TODO(XXX): remove once MSRV reaches 1.80// Complicated conditional compilation guards elided/// This module contains optional APIs for implementing QUIC TLS.hkdf_expand_labelhkdf_expand_label_aead_keyhkdf_expand_label_blockDirectionalKeys/// A QUIC client or server connection.quic_transport_parameters/// Return the TLS-encoded transport parameters for the session's peer./// See [`ConnectionCommon::quic_transport_parameters()`] for more details.zero_rtt_keys/// Compute the keys for encrypting/decrypting 0-RTT packets, if availableread_hs/// Consume unencrypted TLS handshake data./// Handshake data obtained from separate encryption levels should be supplied in separate calls.write_hs/// Emit unencrypted TLS handshake data./// When this returns `Some(_)`, the new keys must be used for future handshake data./// Emit the TLS description code of a fatal alert, if one has arisen./// Check after `read_hs` returns `Err(_)`./// A QUIC client connection./// Make a new QUIC ClientConnection./// This differs from `ClientConnection::new()` in that it takes an extra `params` argument,/// which contains the TLS-encoded transport parameters to send./// Make a new QUIC ClientConnection with custom ALPN protocols./// A QUIC server connection./// Make a new QUIC ServerConnection./// This differs from `ServerConnection::new()` in that it takes an extra `params` argument,reject_early_data/// Explicitly discard early data, notifying the client/// Useful if invariants encoded in `received_resumption_data()` cannot be respected./// Must be called while `is_handshaking` is true./// Retrieves the server name, if any, used to select the certificate and/// This returns `None` until some time after the client's server name indication/// (SNI) extension value is processed during the handshake. It will never be/// `None` when the connection is ready to send or process application data,/// unless the client does not support SNI./// This is useful for application protocols that need to enforce that the/// server name matches an application layer protocol hostname. For/// example, HTTP/1.1 servers commonly expect the `Host:` header field of/// every request on a connection to match the hostname in the SNI extension/// when the client provides the SNI extension./// The server name is also used to match sessions during session resumption./// A shared interface for QUIC connections./// While the transport parameters are technically available prior to the/// completion of the handshake, they cannot be fully trusted until the/// handshake completes, and reliance on them should be minimized./// However, any tampering with the parameters will cause the handshake/// to fail./// QUIC transport parameters received from the peer during the handshakehs_queueearly_secreths_secretstraffic_secretsreturned_traffic_keys/// Whether keys derived from traffic_secrets have been passed to the QUIC implementation/// Secret used to encrypt packets transmitted by the client/// Secret used to encrypt packets transmitted by the server/// Cipher suite used with these secrets/// Secrets used to encrypt/decrypt trafficnext_packet_keysPacketKeySet/// Derive the next set of packet keyslocal_remote/// Encrypts or decrypts a packet's headers/// Encrypts or decrypts the payload of a packet/// Keys used to communicate in a single direction/// All AEADs we support have 16-byte tags./// Authentication tag from an AEAD seal operation./// Produce a `PacketKey` encrypter/decrypter for this suite./// `suite` is the entire suite this `Algorithm` appeared in./// `key` and `iv` is the key material to use./// Produce a `HeaderProtectionKey` encrypter/decrypter for this suite./// `key` is the key material, which is `aead_key_len()` bytes in length./// The length in bytes of keys for this Algorithm./// This controls the size of `AeadKey`s presented to `packet_key()` and `header_protection_key()`./// Whether this algorithm is FIPS-approved./// How a `Tls13CipherSuite` generates `PacketKey`s and `HeaderProtectionKey`s./// Adds QUIC Header Protection./// `sample` must contain the sample of encrypted payload; see/// [Header Protection Sample]./// `first` must reference the first byte of the header, referred to as/// `packet[0]` in [Header Protection Application]./// `packet_number` must reference the Packet Number field; this is/// `packet[pn_offset:pn_offset+pn_length]` in [Header Protection Application]./// Returns an error without modifying anything if `sample` is not/// the correct length (see [Header Protection Sample] and [`Self::sample_len()`]),/// or `packet_number` is longer than allowed (see [Packet Number Encoding and Decoding])./// Otherwise, `first` and `packet_number` will have the header protection added./// [Header Protection Application]: https://datatracker.ietf.org/doc/html/rfc9001#section-5.4.1/// [Header Protection Sample]: https://datatracker.ietf.org/doc/html/rfc9001#section-5.4.2/// [Packet Number Encoding and Decoding]: https://datatracker.ietf.org/doc/html/rfc9000#section-17.1/// Removes QUIC Header Protection./// or `packet_number` is longer than allowed (see/// [Packet Number Encoding and Decoding])./// Otherwise, `first` and `packet_number` will have the header protection removed./// Expected sample length for the key's algorithm/// A QUIC header protection key/// Encrypt a QUIC packet/// Takes a `packet_number`, used to derive the nonce; the packet `header`, which is used as/// the additional authenticated data; and the `payload`. The authentication tag is returned if/// encryption succeeds./// Fails if and only if the payload is longer than allowed by the cipher suite's AEAD algorithm./// Number of QUIC messages that can be safely encrypted with a single key of this type./// Once a `MessageEncrypter` produced for this suite has encrypted more than/// `confidentiality_limit` messages, an attacker gains an advantage in distinguishing it/// from an ideal pseudorandom permutation (PRP)./// This is to be set on the assumption that messages are maximally sized --/// 2 ** 16. For non-QUIC TCP connections see [`CipherSuiteCommon::confidentiality_limit`][csc-limit]./// [csc-limit]: crate::crypto::CipherSuiteCommon::confidentiality_limit/// Number of QUIC messages that can be safely decrypted with a single key of this type/// Once a `MessageDecrypter` produced for this suite has failed to decrypt `integrity_limit`/// messages, an attacker gains an advantage in forging messages./// This is not relevant for TLS over TCP (which is also implemented in this crate)/// because a single failed decryption is fatal to the connection./// However, this quantity is used by QUIC./// Keys to encrypt or decrypt the payload of a packet/// Encrypts outgoing packets/// Decrypts incoming packets/// Packet protection keys for bidirectional 1-RTT communication/// Derive packet keys/// Derive header protection keys/// The TLS 1.3 ciphersuite used to derive keys./// The QUIC key generation algorithm used to derive keys./// Produces QUIC initial keys from a TLS 1.3 ciphersuite and a QUIC key generation algorithm./// Produce a set of initial keys given the connection ID, side and version/// Complete set of keys used to communicate with the peer/// Construct keys for use with initial packets/// Header and packet keys for the handshake space/// Keys for the handshake space/// Header and packet keys for 1-RTT data/// Secrets to derive updated keys fromOneRtt/// Keys for 1-RTT data/// Key material for use in QUIC packet spaces/// QUIC uses 4 different sets of keys (and progressive key updates for long-running connections):/// * Initial: these can be created from [`Keys::initial()`]/// * 0-RTT keys: can be retrieved from [`ConnectionCommon::zero_rtt_keys()`]/// * Handshake: these are returned from [`ConnectionCommon::write_hs()`] after `ClientHello` and///   `ServerHello` messages have been exchanged/// * 1-RTT keys: these are returned from [`ConnectionCommon::write_hs()`] after the handshake is done/// Once the 1-RTT keys have been exchanged, either side may initiate a key update. Progressive/// update keys can be obtained from the [`Secrets`] returned in [`KeyChange::OneRtt`]. Note that/// only packet keys are updated by key updates; header protection keys remain the same.V1Draft/// Draft versions 29, 30, 31 and 32/// First stable RFC/// Anti-ossification variant of V1/// QUIC protocol version/// Governs version-specific behavior in the TLS layerinitial_saltpacket_key_label/// Key derivation label for packet keys.packet_iv_label/// Key derivation label for packet "IV"s.header_key_label/// Key derivation for header keys.key_update_labelrandom_vec/// Make a [`Vec<u8>`] of the given size containing random material.random_u32/// Return a uniformly random [`u32`].random_u16/// Return a uniformly random [`u16`]./// Random material generation failed.//! The single place where we generate random material for our own use.DirectionState/// No keying material.Prepared/// Keying material present, but not yet in use./// Keying material in use.message_encryptermessage_decrypterwrite_seq_maxwrite_seqread_seqhas_decryptedencrypt_statedecrypt_statetrial_decryption_len// Message encrypted with other keys may be encountered, so failures// should be swallowed by the caller.  This struct tracks the amount// of message size this is allowed for./// Record layer that tracks decryption and encryption keys./// Create new record layer with no keys.decrypt_incoming/// Decrypt a TLS message./// `encr` is a decoded message allegedly received from the peer./// If it can be decrypted, its decryption is returned.  Otherwise,encrypt_outgoing/// Encrypt a TLS message./// `plain` is a TLS message we'd like to send.  This function/// panics if the requisite keying material hasn't been established yet.prepare_message_encrypter/// Prepare to use the given `MessageEncrypter` for future message encryption./// It is not used until you call `start_encrypting`.prepare_message_decrypter/// Prepare to use the given `MessageDecrypter` for future message decryption./// It is not used until you call `start_decrypting`.start_encrypting/// Start using the `MessageEncrypter` previously provided to the previous/// call to `prepare_message_encrypter`.start_decrypting/// Start using the `MessageDecrypter` previously provided to the previous/// call to `prepare_message_decrypter`.set_message_encrypter/// Set and start using the given `MessageEncrypter` for future outgoing/// message encryption.set_message_decrypter/// Set and start using the given `MessageDecrypter` for future incoming/// message decryption.set_message_decrypter_with_trial_decryption/// message decryption, and enable "trial decryption" mode for when TLS1.3/// 0-RTT is attempted but rejected by the server.finish_trial_decryptionnext_pre_encrypt_actionpre_encrypt_action/// Return a remedial action when we are near to encrypting too many messages./// `add` is added to the current sequence number.  `add` as `0` means/// "the next message processed by `encrypt_outgoing`"is_encrypting/// Return true if we have ever decrypted a message. This is used in place/// of checking the read_seq since that will be reset on key updates.encrypted_lendoing_trial_decryptionwant_close_before_decrypt/// Whether the peer appears to be getting close to encrypting too many messages with this key.plaintext/// The decrypted message./// Result of decryption./// No action is needed before calling `encrypt_outgoing`RefreshOrClose/// A `key_update` request should be sent ASAP./// If that is not possible (for example, the connection is TLS1.2), a `close_notify`/// alert should be sent instead.Refuse/// Do not call `encrypt_outgoing` further, it will panic rather than/// over-use the key.SEQ_SOFT_LIMITSEQ_HARD_LIMITtest_has_decryptedwith_client_cert_verifier/// Choose how to verify client certificates./// Disable client authentication./// A config builder state where the caller must supply how to provide a server certificate to/// the connecting peer./// Sets a single certificate chain and matching private key.  This/// certificate and key is used for all subsequent connections,/// irrespective of things like SNI hostname./// Note that the end-entity certificate must have the/// [Subject Alternative Name](https://tools.ietf.org/html/rfc6125#section-4.1)/// extension to describe, e.g., the valid DNS name. The `commonName` field is/// disregarded./// This function fails if `key_der` is invalid, or if the/// `SubjectPublicKeyInfo` from the private key does not match the public/// key for the end-entity certificate from the `cert_chain`.with_single_cert_with_ocsp/// Sets a single certificate chain, matching private key and optional OCSP/// response.  This certificate and key is used for all/// subsequent connections, irrespective of things like SNI hostname./// `ocsp` is a DER-encoded OCSP response.  Ignored if zero length.with_cert_resolver/// Sets a custom [`ResolvesServerCert`].ActiveCertifiedKey/// ActiveCertifiedKey wraps [`sign::CertifiedKey`] and tracks OSCP state in a single handshake.from_certified_keyget_cert/// Get the certificate chain/// Get the signing keyget_ocsp/// Something which never stores sessions.can_cache/// An implementer of `StoresServerSessions` that stores everything/// in memory.  If enforces a limit on the number of stored sessions/// to bound memory usage./// Make a new ServerSessionMemoryCache.  `size` is the maximum/// number of stored sessions, and may be rounded-up for/// efficiency.test_serversessionmemorycache_accepts_puttest_serversessionmemorycache_persists_puttest_serversessionmemorycache_overwrites_puttest_serversessionmemorycache_drops_to_maintain_size_invariantNeverProducesTickets/// Something which never produces tickets./// An exemplar `ResolvesServerCert` implementation that always resolves to a single/// Create a new `AlwaysResolvesServerRawPublicKeys` instance./// Something that resolves do different cert chains/keys based/// on client-supplied server name (via SNI)./// Create a new and empty (i.e., knows no certificates) resolver./// Add a new `sign::CertifiedKey` to be used for the given SNI `name`./// This function fails if `name` is not a valid DNS name, or if/// it's not valid for the supplied certificate, or if the certificate/// chain is syntactically faulty.test_resolvesservercertusingsni_requires_snitest_resolvesservercertusingsni_handles_unknown_namesni_resolvertest_noserversessionstorage_drops_puttest_noserversessionstorage_denies_getstest_noserversessionstorage_denies_takestest_neverproducestickets_does_nothingServerContextcan_resume// extensions to reply withsend_ticketExtensionProcessingprocess_commonprocess_tls12validate_server_cert_type_extensionvalidate_client_cert_type_extensionHandshakeHashOrBufferdone_retrysend_ticketsExpectClientHellowith_certified_key/// Continues handling of a `ClientHello` message once config and certificate are available.choose_suite_and_kx_groupprocess_client_hello/// Configuration-independent validation of a `ClientHello` message./// This represents the first part of the `ClientHello` handling, where we do all validation that/// doesn't depend on a `ServerConfig` being available and extract everything needed to build a/// [`ClientHello`] value for a [`ResolvesServerCert`]./// Note that this will modify `data.sni` even if config or certificate resolution fail./// Store session secrets encoded in `value` against `key`,/// overwrites any existing value against `key`.  Returns `true`/// if the value was stored./// Find a value with the given `key`.  Return it, or None/// if it doesn't exist./// Find a value with the given `key`.  Return it and delete it;/// or None if it doesn't exist./// Whether the store can cache another session. This is used to indicate to clients/// whether their session can be resumed; the implementation is not required to remember/// a session even if it returns `true` here./// A trait for the ability to store server session data./// The keys and values are opaque./// Inserted keys are randomly chosen by the library and have/// no internal structure (in other words, you may rely on all/// bits being uniformly random).  Queried keys are untrusted data./// Both the keys and values should be treated as/// **highly sensitive data**, containing enough key material/// to break all security of the corresponding sessions./// Implementations can be lossy (in other words, forgetting/// key/value pairs) without any negative security consequences./// However, note that `take` **must** reliably delete a returned/// value.  If it does not, there may be security consequences./// `put` and `take` are mutating operations; this isn't expressed/// in the type system to allow implementations freedom in/// how to achieve interior mutability.  `Mutex` is a common/// Returns true if this implementation will encrypt/decrypt/// tickets.  Should return false if this is a dummy/// implementation: the server will not send the SessionTicket/// extension and will not call the other functions./// Returns the lifetime in seconds of tickets produced now./// The lifetime is provided as a hint to clients that the/// ticket will not be useful after the given time./// This lifetime must be implemented by key rolling and/// erasure, *not* by storing a lifetime in the ticket./// The objective is to limit damage to forward secrecy caused/// by tickets, not just limiting their lifetime./// Encrypt and authenticate `plain`, returning the resulting/// ticket.  Return None if `plain` cannot be encrypted for/// some reason: an empty ticket will be sent and the connection/// will continue./// Decrypt `cipher`, validating its authenticity protection/// and recovering the plaintext.  `cipher` is fully attacker/// controlled, so this decryption must be side-channel free,/// panic-proof, and otherwise bullet-proof.  If the decryption/// fails, return None./// A trait for the ability to encrypt and decrypt tickets./// Choose a certificate chain and matching key given simplified/// ClientHello information./// Return `None` to abort the handshake./// Return true when the server only supports raw public keys./// How to choose a certificate chain and signing key for use/// in server authentication./// This is suitable when selecting a certificate does not require/// I/O or when the application is using blocking I/O anyhow./// For applications that use async I/O and need to do I/O to choose/// a certificate (for instance, fetching a certificate from a data store),/// the [`Acceptor`] interface is more suitable.server_cert_typesclient_cert_typescertificate_authorities/// The [certificate_authorities] extension, if it was sent by the client./// [certificate_authorities]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.2.4named_groups/// A struct representing the received Client Hello/// Get the server name indicator./// Returns `None` if the client did not supply a SNI./// Get the compatible signature schemes./// Returns standard-specified default if the client omitted this extension./// Get the ALPN protocol identifiers submitted by the client./// Returns `None` if the client did not include an ALPN extension./// Application Layer Protocol Negotiation (ALPN) is a TLS extension that lets a client/// submit a set of identifiers that each a represent an application-layer protocol./// The server will then pick its preferred protocol from the set submitted by the client./// Each identifier is represented as a byte array, although common values are often ASCII-encoded./// See the official RFC-7301 specifications at <https://datatracker.ietf.org/doc/html/rfc7301>/// for more information on ALPN./// For example, a HTTP client might specify "http/1.1" and/or "h2". Other well-known values/// are listed in the at IANA registry at/// <https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids>./// The server can specify supported ALPN protocols by setting [`ServerConfig::alpn_protocols`]./// During the handshake, the server will select the first protocol configured that the client supports./// Get cipher suites./// Get the server certificate types offered in the ClientHello./// Returns `None` if the client did not include a certificate type extension./// Get the client certificate types offered in the ClientHello./// Get the [certificate_authorities] extension sent by the client./// Returns `None` if the client did not send this extension./// Get the [`named_groups`] extension sent by the client./// This means different things in different versions of TLS:/// Originally it was introduced as the "[`elliptic_curves`]" extension for TLS1.2./// It described the elliptic curves supported by a client for all purposes: key/// exchange, signature verification (for server authentication), and signing (for/// client auth).  Later [RFC7919] extended this to include FFDHE "named groups",/// but FFDHE groups in this context only relate to key exchange./// In TLS1.3 it was renamed to "[`named_groups`]" and now describes all types/// of key exchange mechanisms, and does not relate at all to elliptic curves/// used for signatures./// [`elliptic_curves`]: https://datatracker.ietf.org/doc/html/rfc4492#section-5.1.1/// [RFC7919]: https://datatracker.ietf.org/doc/html/rfc7919#section-2/// [`named_groups`]:https://datatracker.ietf.org/doc/html/rfc8446#section-4.2.7ignore_client_order/// Ignore the client's ciphersuite order. Instead,/// choose the top ciphersuite in the server list/// which is supported by the client./// Out of range values are reported as errors from [ServerConnection::new]./// [ServerConnection::new]: crate::server::ServerConnection::new/// How to store client sessions./// See [ServerConfig#sharing-resumption-storage-between-serverconfigs]/// for a warning related to this field./// How to produce tickets.cert_resolver/// How to choose a server cert and key. This is usually set by/// [ConfigBuilder::with_single_cert] or [ConfigBuilder::with_cert_resolver]./// For async applications, see also [Acceptor]./// Protocol names we support, most preferred first./// If empty we don't do ALPN at all./// Supported protocol versions, in no particular order./// The default is all supported versions./// How to verify client certificates./// Amount of early data to accept for sessions created by/// this config.  Specify 0 to disable early data.  The/// default is 0./// Read the early data via [`ServerConnection::early_data`]./// The units for this are _both_ plaintext bytes, _and_ ciphertext/// bytes, depending on whether the server accepts a client's early_data/// or not.  It is therefore recommended to include some slop in/// this value to account for the unknown amount of ciphertext/// expansion in the latter case.send_half_rtt_data/// Whether the server should send "0.5RTT" data.  This means the server/// sends data after its first flight of handshake messages, without/// waiting for the client to complete the handshake./// This can improve TTFB latency for either server-speaks-first protocols,/// or client-speaks-first protocols when paired with "0RTT" data.  This/// comes at the cost of a subtle weakening of the normal handshake/// integrity guarantees that TLS provides.  Note that the initial/// `ClientHello` is indirectly authenticated because it is included/// in the transcript used to derive the keys used to encrypt the data./// This only applies to TLS1.3 connections.  TLS1.2 connections cannot/// do this optimisation and this setting is ignored for them.  It is/// also ignored for TLS1.3 connections that even attempt client/// authentication./// This defaults to false.  This means the first application data/// sent by the server comes after receiving and validating the client's/// handshake up to the `Finished` message.  This is the safest option.send_tls13_tickets/// How many TLS1.3 tickets to send immediately after a successful/// handshake./// Because TLS1.3 tickets are single-use, this allows/// a client to perform multiple resumptions./// The default is 2./// If this is 0, no tickets are sent and clients will not be able to/// do any resumption./// If set to `true`, requires the client to support the extended/// The default is `true` if the "fips" crate feature is enabled,/// How to compress the server's certificate chain./// If a client supports this extension, and advertises support/// server certificate will be compressed according to [RFC8779]./// How to decompress the clients's certificate chain./// extension is offered when requesting client authentication,/// and any compressed certificates are transparently decompressed/// during the handshake./// Common configuration for a set of server sessions./// from the operating system to add to the [`RootCertStore`] passed to a `ClientCertVerifier`/// builder may take on the order of a few hundred milliseconds./// These must be created via the [`ServerConfig::builder()`] or [`ServerConfig::builder_with_provider()`]/// * [`ServerConfig::max_fragment_size`]: the default is `None` (meaning 16kB)./// * [`ServerConfig::session_storage`]: if the `std` feature is enabled, the default stores 256///   sessions in memory. If the `std` feature is not enabled, the default is to not store any///   sessions. In a no-std context, by enabling the `hashbrown` feature you may provide your///   own `session_storage` using [`ServerSessionMemoryCache`] and a `crate::lock::MakeMutex`///   implementation./// * [`ServerConfig::alpn_protocols`]: the default is empty -- no ALPN protocol is negotiated./// * [`ServerConfig::key_log`]: key material is not logged./// * [`ServerConfig::send_tls13_tickets`]: 2 tickets are sent./// * [`ServerConfig::cert_compressors`]: depends on the crate features, see [`compress::default_cert_compressors()`]./// * [`ServerConfig::cert_compression_cache`]: caches the most recently used 4 compressions/// * [`ServerConfig::cert_decompressors`]: depends on the crate features, see [`compress::default_cert_decompressors()`]./// # Sharing resumption storage between `ServerConfig`s/// In a program using many `ServerConfig`s it may improve resumption rates/// configs share [`ServerConfig::session_storage`] or [`ServerConfig::ticketer`]./// However, caution is needed: other fields influence the security of a session/// and resumption between them can be surprising.  If sharing/// [`ServerConfig::session_storage`] or [`ServerConfig::ticketer`] between two/// `ServerConfig`s, you should also evaluate the following fields and ensure/// they are equivalent:/// * `ServerConfig::verifier` -- client authentication requirements,/// * [`ServerConfig::cert_resolver`] -- server identities./// To illustrate, imagine two `ServerConfig`s `A` and `B`.  `A` requires/// client authentication, `B` does not.  If `A` and `B` shared a resumption store,/// it would be possible for a session originated by `B` (that is, an unauthenticated client)/// to be inserted into the store, and then resumed by `A`.  This would give a false/// impression to the user of `A` that the client was authenticated.  This is possible/// whether the resumption is performed statefully (via [`ServerConfig::session_storage`])/// or statelessly (via [`ServerConfig::ticketer`])./// _Unlike_ `ClientConfig`, rustls does not enforce any policy here./// [`ServerSessionMemoryCache`]: crate::server::handy::ServerSessionMemoryCache/// Create a builder for a server configuration with/// Create a builder for a server configuration with a specific [`CryptoProvider`]./// Create a builder for a server configuration with no default implementation details./// Return `true` if connections made with this `ServerConfig` will/// configuration that NIST recommends.Accepting/// Allows reading of early data in resumed TLS1.3 connections./// "Early data" is also known as "0-RTT data"./// This structure implements [`std::io::Read`]./// This represents a single TLS server connection./// Send TLS-protected data to the peer using the `io::Write` trait implementation./// Read data from the peer using the `io::Read` trait implementation./// Make a new ServerConnection.  `config` controls how/// we behave in the TLS protocol.received_resumption_data/// Application-controlled portion of the resumption ticket supplied by the client, if any./// Recovered from the prior session's `set_resumption_data`. Integrity is guaranteed by rustls./// Returns `Some` if and only if a valid resumption ticket has been received from the client.set_resumption_data/// Set the resumption data to embed in future resumption tickets supplied to the client./// Defaults to the empty byte string. Must be less than 2^15 bytes to allow room for other/// data. Should be called while `is_handshaking` returns true to ensure all transmitted/// resumption tickets are affected./// Integrity will be assured by rustls, but the data will be visible to the client. If secrecy/// from the client is desired, encrypt the data separately./// Returns an `io::Read` implementer you can read bytes from that are/// received from a client as TLS1.3 0RTT/"early" data, during the handshake./// This returns `None` in many circumstances, such as :/// - Early data is disabled if [`ServerConfig::max_early_data_size`] is zero (the default)./// - The session negotiated with the client is not TLS1.3./// - The client just doesn't support early data./// - The connection doesn't resume an existing session./// - The client hasn't sent a full ClientHello yet./// Return true if the connection was made with a `ServerConfig` that is FIPS compatible./// Handle a server-side connection before configuration is available./// `Acceptor` allows the caller to choose a [`ServerConfig`] after reading/// the [`super::ClientHello`] of an incoming connection. This is useful for servers/// that choose different certificates or cipher suites based on the/// characteristics of the `ClientHello`. In particular it is useful for/// servers that need to do some I/O to load a certificate and its private key/// and don't want to use the blocking interface provided by/// [`super::ResolvesServerCert`]./// Create an Acceptor with [`Acceptor::default()`]./// # fn choose_server_config(/// #     _: rustls::server::ClientHello,/// # ) -> std::sync::Arc<rustls::ServerConfig> {/// #     unimplemented!();/// # #[allow(unused_variables)]/// use rustls::server::{Acceptor, ServerConfig};/// let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();///     let mut stream = stream.unwrap();///     let mut acceptor = Acceptor::default();///     let accepted = loop {///         acceptor.read_tls(&mut stream).unwrap();///         if let Some(accepted) = acceptor.accept().unwrap() {///             break accepted;///     // For some user-defined choose_server_config:///     let config = choose_server_config(accepted.client_hello());///     let conn = accepted///         .into_connection(config)///     // Proceed with handling the ServerConnection./// Return an empty Acceptor, ready to receive bytes from a new client connection./// Returns an error if this `Acceptor` has already yielded an [`Accepted`]. For more details,/// refer to [`Connection::read_tls()`]./// [`Connection::read_tls()`]: crate::Connection::read_tls/// Check if a `ClientHello` message has been received./// Returns `Ok(None)` if the complete `ClientHello` has not yet been received./// Do more I/O and then call this function again./// Returns `Ok(Some(accepted))` if the connection has been accepted. Call/// `accepted.into_connection()` to continue. Do not call this function again./// Returns `Err((err, alert))` if an error occurred. If an alert is returned, the/// application should call `alert.write()` to send the alert to the client. It should/// not call `accept()` again./// Represents a TLS alert resulting from handling the client's `ClientHello` message./// When [`Acceptor::accept()`] returns an error, it yields an `AcceptedAlert` such that the/// application can communicate failure to the client via [`AcceptedAlert::write()`]./// Send the alert to the client./// To account for short writes this function should be called repeatedly until it/// returns `Ok(0)` or an error./// This function will invoke the writer until the buffer is empty./// Unbuffered version of `ServerConnection`/// Make a new ServerConnection. `config` controls how we behave in the TLS protocol./// Extract secrets and an [`KernelConnection`] object.pop_early_datapeek_early_datasig_schemes/// Represents a `ClientHello` message received through the [`Acceptor`]./// Contains the state required to resume the connection through [`Accepted::into_connection()`]./// Get the [`ClientHello`] for this connection.into_connection/// Convert the [`Accepted`] into a [`ServerConnection`]./// Takes the state returned from [`Acceptor::accept()`] as well as the [`ServerConfig`] and/// [`sign::CertifiedKey`] that should be used for the session. Returns an error if/// configuration-dependent validation of the received `ClientHello` message fails.client_hello_payloadwas_acceptedwas_rejectedfor_serverget_sni_strresumption_data/// State associated with a server connection.test_read_in_new_state// these branches not reachable externally, unless something else goes wrong.null_compression_requiredserver_ignores_sni_with_ip_addressserver_rejects_sni_with_illegal_dns_nametest_process_client_hellotest_server_rejects_no_extended_master_secret_extension_when_require_ems_or_fipsserver_picks_ffdhe_group_when_clienthello_has_no_ffdhe_group_in_groups_extserver_picks_ffdhe_group_when_clienthello_has_no_groups_extserver_accepts_client_with_no_ecpoints_extension_and_only_ffdhe_cipher_suitesserver_chooses_ffdhe_group_for_client_hellotest_server_requiring_rpk_client_rejects_x509_clienttest_rpk_only_server_rejects_x509_only_clientserver_config_for_rpkserver_certified_keyserver_keyffdhe_providerFAKE_FFDHE_GROUPFakeFfdheGroupActiveFakeFfdheTLS12_DHE_RSA_WITH_AES_128_GCM_SHA256minimal_client_helloCompleteClientHelloHandlinghandle_client_hellostart_resumptionemit_server_helloemit_cert_statusemit_server_kxemit_certificate_reqemit_server_hello_done// --- Process client's Certificate for client auth ---client_certExpectClientKx// --- Process client's KeyExchange ---// --- Process client's certificate proof ---// --- Process client's ChangeCipherSpec ---get_server_connection_value_tls12// --- Process client's Finished ---emit_ticket// --- Process traffic ---KeyScheduleTrafficWithClientFinishedPendingEarlyDataDecisionRequestedButRejectedcheck_binderattempt_tls13_ticket_decryptionemit_hello_retry_requestdecide_if_early_data_allowedemit_encrypted_extensionsemit_certificate_req_tls13emit_certificate_verify_tls13skip_data_leftExpectAndSkipRejectedEarlyDataExpectEarlyDataget_server_session_value// --- Process (any number of) early ApplicationData messages,//     followed by a terminating handshake EndOfEarlyData message ---/// Our TLS connectionsock/// The underlying transport, like a socket/// This type implements `io::Read` and `io::Write`, encapsulating/// a Connection `C` and an underlying transport `T`, such as a socket./// This allows you to use a rustls Connection like a normal stream./// Make a new Stream using the Connection `conn` and socket-like object/// `sock`.  This does not fail and does no IO.complete_prior_io/// If we're handshaking, complete all the IO for that./// If we have data to write, write it all.// Implements `BufRead::fill_buf` but with more flexible lifetimes, so StreamOwned can reuse it/// Our connection/// and owning a Connection `C` and an underlying blocking transport/// `T`, such as a socket./// Make a new StreamOwned taking the Connection `conn` and socket-like/// object `sock`.  This does not fail and does no IO./// This is the same as `Stream::new` except `conn` and `sock` are/// moved into the StreamOwned./// Get a reference to the underlying socket/// Get a mutable reference to the underlying socket/// Extract the `conn` and `sock` parts from the `StreamOwned`as_streamstream_can_be_created_for_connection_and_tcpstreamstreamowned_can_be_created_for_client_and_tcpstreamstreamowned_can_be_created_for_server_and_tcpstream/// The TLS enumeration naming this cipher suite.hash_provider/// Which hash function the suite uses./// Number of TCP-TLS messages that can be safely encrypted with a single key of this type/// each is 2<sup>14</sup> bytes. It **does not** consider confidentiality limits for/// QUIC connections - see the [`quic::KeyBuilder.confidentiality_limit`] field for/// this context./// For AES-GCM implementations, this should be set to 2<sup>24</sup> to limit attack/// probability to one in 2<sup>60</sup>.  See [AEBounds] (Table 1) and [draft-irtf-aead-limits-08]:/// >>> p = 2 ** -60/// >>> L = (2 ** 14 // 16) + 1/// >>> qlim = (math.sqrt(p) * (2 ** (129 // 2)) - 1) / (L + 1)/// >>> print(int(qlim).bit_length())/// [AEBounds]: https://eprint.iacr.org/2024/051.pdf/// [draft-irtf-aead-limits-08]: https://www.ietf.org/archive/id/draft-irtf-cfrg-aead-limits-08.html#section-5.1.1/// For chacha20-poly1305 implementations, this should be set to `u64::MAX`:/// see <https://www.ietf.org/archive/id/draft-irtf-cfrg-aead-limits-08.html#section-5.2.1>/// Common state for cipher suites (both for TLS 1.2 and TLS 1.3)/// This means all the constituent parts that do cryptography return `true` for `fips()`./// A TLS 1.2 cipher suite/// A TLS 1.3 cipher suite/// A cipher suite supported by rustls./// This type carries both configuration and implementation. Compare with/// [`CipherSuite`], which carries solely a cipher suite identifier./// The cipher suite's identifier/// The hash function the ciphersuite uses./// Return the inner `Tls13CipherSuite` for this suite, if it is a TLS1.3 suite./// Return supported protocol version for the cipher suite.usable_for_signature_algorithm/// Return true if this suite is usable for a key only offering `sig_alg`/// signatures.  This resolves to true for all TLS1.3 suites.usable_for_protocol/// Return true if this suite is usable for the given [`Protocol`]./// All cipher suites are usable for TCP-TLS.  Only TLS1.3 suites/// with `Tls13CipherSuite::quic` provided are usable for QUIC.key_exchange_algorithms/// Return the list of `KeyExchangeAlgorithm`s supported by this cipher suite./// TLS 1.3 cipher suites support both ECDHE and DHE key exchange, but TLS 1.2 suites/// support one or the other.usable_for_kx_algorithm/// Say if the given `KeyExchangeAlgorithm` is supported by this cipher suite./// TLS 1.3 cipher suites support all key exchange types, but TLS 1.2 suites/// support only one.compatible_sigscheme_for_suites/// Return true if `sigscheme` is usable by any of the given suites./// sequence number and secrets for the "tx" (transmit) direction/// sequence number and secrets for the "rx" (receive) direction/// Secrets for transmitting/receiving data over a TLS session./// After performing a handshake with rustls, these secrets can be extracted/// to configure kTLS for a socket, and have the kernel take over encryption/// and/or decryption./// secrets for the "tx" (transmit) direction/// secrets for the "rx" (receive) direction/// [ExtractedSecrets] minus the sequence numbers/// AEAD Key/// Initialization vector/// Secrets for the AES_128_GCM AEAD algorithm/// Secrets for the AES_256_GCM AEAD algorithm/// Secrets for the CHACHA20_POLY1305 AEAD algorithm/// Secrets used to encrypt/decrypt data in a TLS session./// These can be used to configure kTLS for a socket in one direction./// The only other piece of information needed is the sequence number,/// which is in [ExtractedSecrets].test_scs_is_debugtest_can_resume_totest_for_each_provider/// Instantiate the given test functions once for each built-in provider./// The selected provider module is bound as `provider`; you can rely on this/// having the union of the items common to the `crypto::ring` and/// `crypto::aws_lc_rs` modules.test_each_provider//! Macros used for unit testing.next_switch_timeTicketSwitcherState/// A ticketer that has a 'current' sub-ticketer and a single/// 'previous' ticketer.  It creates a new ticketer every so/// often, demoting the current ticketer./// Creates a new `TicketSwitcher`, which rotates through sub-ticketers/// based on the passage of time./// `lifetime` is in seconds, and is how long the current ticketer/// is used to generate new tickets.  Tickets are accepted for no/// longer than twice this duration.  `generator` produces a new/// `ProducesTickets` implementation.maybe_roll/// If it's time, demote the `current` ticketer to `previous` (so it/// does no new encryptions but can do decryption) and use next for a/// new `current` ticketer./// Calling this regularly will ensure timely key erasure.  Otherwise,/// key erasure will be delayed until the next encrypt/decrypt call./// For efficiency, this is also responsible for locking the state mutex/// and returning the mutexguard.TicketRotatorState/// Creates a new `TicketRotator`, which rotates through sub-ticketers/// does no new encryptions but can do decryption) and replace it/// with a new one./// For efficiency, this is also responsible for locking the state rwlock/// and returning it for read./// Returns the current wall time./// This is not required to be monotonic./// Return `None` if unable to retrieve the time./// An object that provides the current time./// This is used to, for example, check if a certificate has expired during/// certificate validation, or to check the age of a ticket./// Default `TimeProvider` implementation that uses `std`//! The library's source of time./// Common cipher suite fields.prf_provider/// How to compute the TLS1.2 PRF for the suite's hash function./// If you have a TLS1.2 PRF implementation, you should directly implement the [`crypto::tls12::Prf`] trait./// If not, you can implement the [`crypto::hmac::Hmac`] trait (and associated), and then use/// [`crypto::tls12::PrfUsingHmac`]./// How to exchange/agree keys./// In TLS1.2, the key exchange method (eg, Elliptic Curve Diffie-Hellman with Ephemeral keys -- ECDHE)/// is baked into the cipher suite, but the details to achieve it are negotiated separately./// This controls how protocol messages (like the `ClientKeyExchange` message) are interpreted/// once this cipher suite has been negotiated./// How to sign messages for authentication./// This is a set of [`SignatureScheme`]s that are usable once this cipher suite has been/// negotiated./// The precise scheme used is then chosen from this set by the selected authentication key.aead_alg/// How to produce a [`MessageDecrypter`] or [`MessageEncrypter`]/// from raw key material./// A TLS 1.2 cipher suite supported by rustls.resolve_sig_schemes/// Resolve the set of supported [`SignatureScheme`]s from the/// offered signature schemes.  If we return an empty/// set, the handshake terminates./// TLS1.2 per-connection keying materialfrom_key_exchangenew_resumemake_cipher_pairMessageCipherPair/// Make a `MessageCipherPair` based on the given supported ciphersuite `self.suite`,/// and the session's `secrets`.make_key_blockmake_verify_dataclient_verify_dataserver_verify_dataEmsRandoms/// This is guaranteed to return a non-empty slice.join_randomsdecode_kx_paramsDOWNGRADE_SENTINELserver_ecdhe_remaining_bytesclient_ecdhe_invalidSecretKindResumptionPskBinderKeyClientEarlyTrafficSecretClientHandshakeTrafficSecretServerHandshakeTrafficSecretClientApplicationTrafficSecretServerApplicationTrafficSecretExporterMasterSecretResumptionMasterSecretDerivedSecretServerEchConfirmationSecretServerEchHrrConfirmationSecret/// The kinds of secret we can extract from `KeySchedule`.log_label/// This is the TLS1.3 key schedule.  It stores the current secret and/// the type of hash.  This isn't used directly; but only through the/// typestates.ks/// The "early secret" stage of the key schedule WITH a PSK./// This is only useful when you need to use one of the binder/// keys, the "client_early_traffic_secret", or/// "early_exporter_master_secret"./// See [`KeySchedulePreHandshake`] for more information.client_early_traffic_secret/// Computes the `client_early_traffic_secret` and writes it/// to `common`./// `hs_hash` is `Transcript-Hash(ClientHello)`./// Derive-Secret(., "c e traffic", ClientHello)///               = client_early_traffic_secretresumption_psk_binder_key_and_sign_verify_data/// The "early secret" stage of the key schedule./// Call [`KeySchedulePreHandshake::new`] to create it without/// a PSK, or use [`From<KeyScheduleEarly>`] to create it with/// a PSK.///          0///          v/// PSK -> HKDF-Extract = Early Secret///          +-----> Derive-Secret(., "ext binder" | "res binder", "")///          |                     = binder_key///          +-----> Derive-Secret(., "c e traffic", ClientHello)///          |                     = client_early_traffic_secret///          +-----> Derive-Secret(., "e exp master", ClientHello)///          |                     = early_exporter_master_secret///    Derive-Secret(., "derived", "")/// Creates a key schedule without a PSK.into_handshake/// `shared_secret` is the "(EC)DHE" secret input to/// "HKDF-Extract":/// (EC)DHE -> HKDF-Extract = Handshake Secret/// Creates a key schedule with a PSK./// KeySchedule during handshake./// Created by [`KeySchedulePreHandshake`].derive_client_handshake_secretsderive_server_handshake_secretsserver_ech_confirmation_secretclient_handshake_traffic_secretserver_handshake_traffic_secretsign_server_finishset_handshake_encrypterset_handshake_decrypterinto_traffic_with_client_finished_pendinginto_pre_finished_client_trafficKeyScheduleClientBeforeFinishedtrafficinto_traffichandshake_client_traffic_secret/// KeySchedule during traffic stage, retaining the ability to calculate the client's/// finished verify_data. The traffic stage key schedule can be extracted from it/// through signing the client finished hash.update_decryptersign_client_finishcurrent_client_traffic_secretcurrent_server_traffic_secretcurrent_exporter_secret/// KeySchedule during traffic stage.  All traffic & exporter keys are guaranteed/// to be available.update_encrypter_and_notifyrequest_key_update_and_update_encrypternext_application_traffic_secretrefresh_traffic_secretexpand_secretkstresumption_master_secretderive_ticket_pskset_encrypterset_decrypterderive_decrypternew_with_empty_secretinput_empty/// Input the empty secret./// RFC 8446: "If a given secret is not available, then the/// 0-value consisting of a string of Hash.length bytes set/// to zeros is used."input_secret/// Input the given secret./// Derive a secret of given `kind`, using current handshake hash `hs_hash`./// More specifically///    Derive-Secret(., "derived", Messages)/// where `hs_hash` is `Messages`.derive_logged_secretderive_for_empty_hash/// Derive a secret of given `kind` using the hash of the empty string/// for the handshake hash./// More specifically:/// Derive-Secret(., Label, "")/// where `kind` is `Label`./// Useful only for the following `SecretKind`s:/// - `SecretKind::ExternalPskBinderKey`/// - `SecretKind::ResumptionPSKBinderKey`/// - `SecretKind::DerivedSecret`sign_finish/// Sign the finished message consisting of `hs_hash` using a current/// traffic secret./// See RFC 8446 section 4.4.4.sign_verify_data/// Sign the finished message consisting of `hs_hash` using the key material/// `base_key`.derive_next/// Derive the next application traffic secret, returning it./// Derive the PSK to use given a resumption_master_secret and/// ticket_nonce./// [HKDF-Expand-Label] where the output is an AEAD key./// [HKDF-Expand-Label]: <https://www.rfc-editor.org/rfc/rfc8446#section-7.1>/// [HKDF-Expand-Label] where the output is an IV./// [HKDF-Expand-Label] where the output length is a compile-time constant, and therefore/// it is infallible./// [HKDF-Expand-Label] where the output is one block in size.hkdf_expand_label_slice/// [HKDF-Expand-Label] where the output is a slice./// This can fail because HKDF-Expand is limited in its maximum output length.hkdf_expand_label_innerassert_traffic_secretseal_zeroes//! Key schedule maintenance for TLS1.3// We express the state of a contained KeySchedule using these// typestates.  This means we can write code that cannot accidentally// (e.g.) encrypt application data using a KeySchedule solely constructed// with an empty or trivial secret, or extract the wrong kind of secrets// at a given point.hkdf_provider/// How to complete HKDF with the suite's hash function./// If you have a HKDF implementation, you should directly implement the `crypto::tls13::Hkdf`/// trait (and associated)./// [`crypto::tls13::HkdfUsingHmac`]./// How to produce a [MessageDecrypter] or [MessageEncrypter]/// [MessageDecrypter]: crate::crypto::cipher::MessageDecrypter/// [MessageEncrypter]: crate::crypto::cipher::MessageEncrypter/// How to create QUIC header and record protection algorithms/// for this suite./// Provide `None` to opt out of QUIC support for this suite.  It will/// not be offered in QUIC handshakes./// A TLS 1.3 cipher suite supported by rustls.can_resume_from/// Can a session using suite self resume from suite prev?quic_suite/// Returns a `quic::Suite` for the ciphersuite, if supported.VerifyMessage/// Constructs the signature message specified in section 4.4.3 of RFC8446.MAX_VERIFY_MSGSERVER_CONSTANTCLIENT_CONSTANTprefix_used/// How many bytes have been consumed in the first chunk./// Invariant: zero if `chunks.is_empty()`/// Invariant: 0 <= `prefix_used` < `chunks[0].len()`/// The total upper limit (in bytes) of this object./// This is a byte buffer that is built from a deque of byte vectors./// This avoids extra copies when appending a new byte vector,/// at the expense of more complexity when reading out./// Sets the upper limit on how many bytes this/// object can store./// Setting a lower limit than the currently stored/// data is not an error./// A [`None`] limit is interpreted as no limit./// If we're empty/// How many bytes we're storingapply_limit/// For a proposed append of `len` bytes, how many/// bytes should we actually append to adhere to the/// currently set `limit`?/// Take and append the given `bytes`./// Take one of the chunks from this object./// This function returns `None` if the object `is_empty`./// Inspect the first chunk from this object.append_limited_copy/// Append a copy of `bytes`, perhaps a prefix if/// we're near the limit./// Read data out of this object, writing it into `buf`/// and returning how many bytes were written there.consume_first_chunk/// Read data out of this object, passing it `wr`/// Returns the first contiguous chunk of data, or None if empty.short_append_copy_with_limitread_byte_by_byteevery_possible_chunk_interleaving/// Zero-sized marker type representing verification of a signature./// Make a `HandshakeSignatureValid`/// Zero-sized marker type representing verification of a server cert chain./// Make a `ServerCertVerified`/// Zero-sized marker type representing verification of a client cert chain./// Make a `ClientCertVerified`/// Verify the end-entity certificate `end_entity` is valid for the/// hostname `dns_name` and chains to at least one trust anchor./// `intermediates` contains all certificates other than `end_entity` that/// were sent as part of the server's [Certificate] message. It is in the/// same order that the server sent them and may be empty./// Note that none of the certificates have been parsed yet, so it is the responsibility of/// the implementer to handle invalid data. It is recommended that the implementer returns/// [`Error::InvalidCertificate(CertificateError::BadEncoding)`] when these cases are encountered./// [Certificate]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.2/// Verify a signature allegedly by the given server certificate./// `message` is not hashed, and needs hashing during the verification./// The signature and algorithm are within `dss`.  `cert` contains the/// public key to use./// `cert` has already been validated by [`ServerCertVerifier::verify_server_cert`]./// If and only if the signature is valid, return `Ok(HandshakeSignatureValid)`./// Otherwise, return an error -- rustls will send an alert and abort the/// This method is only called for TLS1.2 handshakes.  Note that, in TLS1.2,/// SignatureSchemes such as `SignatureScheme::ECDSA_NISTP256_SHA256` are not/// in fact bound to the specific curve implied in their name./// This method is only called for TLS1.3 handshakes./// This method is very similar to `verify_tls12_signature`: but note the/// tighter ECDSA SignatureScheme semantics -- e.g. `SignatureScheme::ECDSA_NISTP256_SHA256`/// must only validate signatures using public keys on the right curve --/// rustls does not enforce this requirement for you./// Return the list of SignatureSchemes that this verifier will handle,/// in `verify_tls12_signature` and `verify_tls13_signature` calls./// This should be in priority order, with the most preferred first./// Returns whether this verifier requires raw public keys as defined/// in [RFC 7250](https://tools.ietf.org/html/rfc7250)./// Return the [`DistinguishedName`]s of certificate authorities that this verifier trusts./// If specified, will be sent as the [`certificate_authorities`] extension in ClientHello./// Note that this is only applicable to TLS 1.3./// [`certificate_authorities`]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.2.4/// Something that can verify a server certificate chain, and verify/// signatures made by certificates.offer_client_auth/// Returns `true` to enable the server to request a client certificate and/// `false` to skip requesting a client certificate. Defaults to `true`.client_auth_mandatory/// Return `true` to require a client certificate and `false` to make/// client authentication optional./// Defaults to `self.offer_client_auth()`./// Returns the [`DistinguishedName`] [subjects] that the server will hint to clients to/// identify acceptable authentication trust anchors./// These hint values help the client pick a client certificate it believes the server will/// accept. The hints must be DER-encoded X.500 distinguished names, per [RFC 5280 A.1]. They/// are sent in the [`certificate_authorities`] extension of a [`CertificateRequest`] message/// when [ClientCertVerifier::offer_client_auth] is true. When an empty list is sent the client/// should always provide a client certificate if it has one./// Generally this list should contain the [`DistinguishedName`] of each root trust/// anchor in the root cert store that the server is configured to use for authenticating/// presented client certificates./// In some circumstances this list may be customized to include [`DistinguishedName`] entries/// that do not correspond to a trust anchor in the server's root cert store. For example,/// the server may be configured to trust a root CA that cross-signed an issuer certificate/// that the client considers a trust anchor. From the server's perspective the cross-signed/// certificate is an intermediate, and not present in the server's root cert store. The client/// may have the cross-signed certificate configured as a trust anchor, and be unaware of the/// root CA that cross-signed it. If the server's hints list only contained the subjects of the/// server's root store the client would consider a client certificate issued by the cross-signed/// issuer unacceptable, since its subject was not hinted. To avoid this circumstance the server/// should customize the hints list to include the subject of the cross-signed issuer in addition/// to the subjects from the root cert store./// [subjects]: https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6/// [`CertificateRequest`]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.3.2/// Verify the end-entity certificate `end_entity` is valid, acceptable,/// and chains to at least one of the trust anchors trusted by/// this verifier./// `intermediates` contains the intermediate certificates the/// client sent along with the end-entity certificate; it is in the same/// order that the peer sent them and may be empty./// an [InvalidCertificate] error with the [BadEncoding] variant when these cases are encountered./// [InvalidCertificate]: Error#variant.InvalidCertificate/// [BadEncoding]: crate::CertificateError#variant.BadEncoding/// Verify a signature allegedly by the given client certificate./// `cert` has already been validated by [`ClientCertVerifier::verify_client_cert`]./// This method is very similar to `verify_tls12_signature`, but note the/// tighter ECDSA SignatureScheme semantics in TLS 1.3. For example,/// `SignatureScheme::ECDSA_NISTP256_SHA256`/// Something that can verify a client certificate chain/// Turns off client authentication./// In contrast to using/// `WebPkiClientVerifier::builder(roots).allow_unauthenticated().build()`, the `NoClientAuth`/// `ClientCertVerifier` will not offer client authentication at all, vs offering but not/// requiring it./// The [`SignatureScheme`] used to produce the signature./// This type combines a [`SignatureScheme`] and a signature payload produced with that scheme./// Get the signature.assertions_are_debug// Marker types.  These are used to bind the fact some verification// (certificate chain or handshake signature) has taken place into// protocol states.  We use this to have the compiler check that there// are no 'goto fail'-style elisions of important checks before we// reach the traffic stage.// These types are public, but cannot be directly constructed.  This// means their origins can be precisely determined by looking// for their `assertion` constructors.reddit_certgithub_certarstechnica_certservo_certtwitter_certwikipedia_certgoogle_certhn_certstackoverflow_certduckduckgo_certrustlang_certwapo_certverify_once//! This program does benchmarking of the functions in verify.rs,//! that do certificate chain validation and signature verification.//! This uses captured certificate chains for a selection of websites,//! saved in `testdata/cert-{SITE}.{I}.der`.//! To update that data://! - delete all `testdata/cert-*.der`.//! - run the `admin/capture-certdata` script.//! - update the verification timestamp near the bottom of this file//!   to the current time.//! - where a website's chain length changed, reflect that in the list//!   of certificate files below.//! This does not need to be done regularly; because the verification//! time is fixed, it only needs doing if a root certificate is//! distrusted./// The TLS enumeration naming this version./// A TLS protocol version supported by rustls./// All possible instances of this class are provided by the library in/// the [`ALL_VERSIONS`] array, as well as individually as [`TLS12`]/// and [`TLS13`]./// TLS1.2/// TLS1.3/// A list of all the protocol versions supported by rustls./// The version configuration that an application should use by default./// This will be [`ALL_VERSIONS`] for now, but gives space in the future/// to remove a version from here and require users to opt-in to olderTrustAnchoranchor_from_trusted_certpki_error/// The list of roots./// A container for root certificates able to provide a root-of-trust/// for connection authentication./// Make a new, empty `RootCertStore`.add_parsable_certificates/// Parse the given DER-encoded certificates and add all that can be parsed/// in a best-effort fashion./// This is because large collections of root certificates often/// include ancient or syntactically invalid certificates./// Returns the number of certificates added, and the number that were ignored./// Add a single DER-encoded certificate to the store./// This is suitable for a small set of root certificates that are expected to parse/// successfully. For large collections of roots (for example from a system store) it/// is expected that some of them might not be valid according to the rules rustls/// implements. As long as a relatively limited number of certificates are affected,/// this should not be a cause for concern. Use [`RootCertStore::add_parsable_certificates`]/// in order to add as many valid roots as possible and to understand how many certificates/// have been diagnosed as malformed.subjects/// Return the DER encoded [`DistinguishedName`] of each trust anchor subject in the root/// cert store./// Each [`DistinguishedName`] will be a DER-encoded X.500 distinguished name, per/// [RFC 5280 A.1], including the outer `SEQUENCE`./// Return true if there are no certificates./// Say how many certificates are in the container.root_cert_store_debugCertRevocationListExpirationPolicyRevocationCheckDepthUnknownStatusPolicyparse_crlsrevocation_check_depthunknown_revocation_policyrevocation_expiration_policyanon_policyAnonymousClientPolicysupported_algs/// A builder for configuring a `webpki` client certificate verifier./// For more information, see the [`WebPkiClientVerifier`] documentation.clear_root_hint_subjects/// Clear the list of trust anchor hint subjects./// By default, the client cert verifier will use the subjects provided by the root cert/// store configured for client authentication. Calling this function will remove these/// hint subjects, indicating the client should make a free choice of which certificate/// to send./// See [`ClientCertVerifier::root_hint_subjects`] for more information on/// circumstances where you may want to clear the default hint subjects.add_root_hint_subjects/// Add additional [`DistinguishedName`]s to the list of trust anchor hint subjects./// store configured for client authentication. Calling this function will add to these/// existing hint subjects. Calling this function with empty `subjects` will have no/// circumstances where you may want to override the default hint subjects.with_crls/// Verify the revocation state of presented client certificates against the provided/// certificate revocation lists (CRLs). Calling `with_crls` multiple times appends the/// given CRLs to the existing collection./// By default all certificates in the verified chain built from the presented client/// certificate to a trust anchor will have their revocation status checked. Calling/// [`only_check_end_entity_revocation`][Self::only_check_end_entity_revocation] will/// change this behavior to only check the end entity client certificate./// By default if a certificate's revocation status can not be determined using the/// configured CRLs, it will be treated as an error. Calling/// [`allow_unknown_revocation_status`][Self::allow_unknown_revocation_status] will change/// this behavior to allow unknown revocation status.only_check_end_entity_revocation/// Only check the end entity certificate revocation status when using CRLs./// If CRLs are provided using [`with_crls`][Self::with_crls] only check the end entity/// certificate's revocation status. Overrides the default behavior of checking revocation/// status for each certificate in the verified chain built to a trust anchor/// (excluding the trust anchor itself)./// If no CRLs are provided then this setting has no effect. Neither the end entity certificate/// or any intermediates will have revocation status checked.allow_unauthenticated/// Allow unauthenticated clients to connect./// Clients that offer a client certificate issued by a trusted root, and clients that offer no/// client certificate will be allowed to connect.allow_unknown_revocation_status/// Allow unknown certificate revocation status when using CRLs./// If CRLs are provided with [`with_crls`][Self::with_crls] and it isn't possible to/// determine the revocation status of a certificate, do not treat it as an error condition./// Overrides the default behavior where unknown revocation status is considered an error./// If no CRLs are provided then this setting has no effect as revocation status checks/// are not performed.enforce_revocation_expiration/// Enforce the CRL nextUpdate field (i.e. expiration)/// If CRLs are provided with [`with_crls`][Self::with_crls] and the verification time is/// beyond the time in the CRL nextUpdate field, it is expired and treated as an error condition./// Overrides the default behavior where expired CRLs are not treated as an error condition./// Build a client certificate verifier. The built verifier will be used for the server to offer/// client certificate authentication, to control how offered client certificates are validated,/// and to determine what to do with anonymous clients that do not respond to the client/// certificate authentication offer with a client certificate./// If `with_signature_verification_algorithms` was not called on the builder, a default set of/// signature verification algorithms is used, controlled by the selected [`CryptoProvider`]./// Once built, the provided `Arc<dyn ClientCertVerifier>` can be used with a Rustls/// [`ServerConfig`] to configure client certificate validation using/// [`with_client_cert_verifier`][ConfigBuilder<ClientConfig, WantsVerifier>::with_client_cert_verifier]./// This function will return a [`VerifierBuilderError`] if:/// 1. No trust anchors have been provided./// 2. DER encoded CRLs have been provided that can not be parsed successfully.anonymous_policy/// A client certificate verifier that uses the `webpki` crate[^1] to perform client certificate/// It must be created via the [`WebPkiClientVerifier::builder()`] or/// [`WebPkiClientVerifier::builder_with_provider()`] functions./// Once built, the provided `Arc<dyn ClientCertVerifier>` can be used with a Rustls [`ServerConfig`]/// to configure client certificate validation using [`with_client_cert_verifier`][ConfigBuilder<ClientConfig, WantsVerifier>::with_client_cert_verifier]./// To require all clients present a client certificate issued by a trusted CA:/// # #[cfg(any(feature = "ring", feature = "aws_lc_rs"))] {/// # use rustls::RootCertStore;/// # use rustls::server::WebPkiClientVerifier;/// # let roots = RootCertStore::empty();/// let client_verifier = WebPkiClientVerifier::builder(roots.into())///   .build()/// Or, to allow clients presenting a client certificate authenticated by a trusted CA, or/// anonymous clients that present no client certificate:///   .allow_unauthenticated()/// If you wish to disable advertising client authentication:/// let client_verifier = WebPkiClientVerifier::no_client_auth();/// You can also configure the client verifier to check for certificate revocation with/// client certificate revocation lists (CRLs):/// # use rustls::server::{WebPkiClientVerifier};/// # let crls = Vec::new();///   .with_crls(crls)/// [^1]: <https://github.com/rustls/webpki>/// Create a builder for the `webpki` client certificate verifier configuration using/// the [process-default `CryptoProvider`][CryptoProvider#using-the-per-process-default-cryptoprovider]./// Client certificate authentication will be offered by the server, and client certificates/// will be verified using the trust anchors found in the provided `roots`. If you/// wish to disable client authentication use [`WebPkiClientVerifier::no_client_auth()`] instead./// Use [`Self::builder_with_provider`] if you wish to specify an explicit provider./// For more information, see the [`ClientCertVerifierBuilder`] documentation./// a specified [`CryptoProvider`]./// wish to disable client authentication use [WebPkiClientVerifier::no_client_auth()] instead./// The cryptography used comes from the specified [`CryptoProvider`].no_client_auth/// Create a new `WebPkiClientVerifier` that disables client authentication. The server will/// not offer client authentication and anonymous clients will be accepted./// This is in contrast to using `WebPkiClientVerifier::builder().allow_unauthenticated().build()`,/// which will produce a verifier that will offer client authentication, but not require it./// Construct a new `WebpkiClientVerifier`./// * `roots` is a list of trust anchors to use for certificate validation./// * `root_hint_subjects` is a list of distinguished names to use for hinting acceptable///   certificate authority subjects to a client./// * `crls` is a `Vec` of owned certificate revocation lists (CRLs) to use for///   client certificate validation./// * `revocation_check_depth` controls which certificates have their revocation status checked///   when `crls` are provided./// * `unknown_revocation_policy` controls how certificates with an unknown revocation status///   are handled when `crls` are provided./// * `anonymous_policy` controls whether client authentication is required, or if anonymous///   clients can connect./// * `supported_algs` specifies which signature verification algorithms should be used./// Clients that do not present a client certificate are allowed.Deny/// Clients that do not present a client certificate are denied./// Controls how the [WebPkiClientVerifier] handles anonymous clients.load_crlstest_crlsload_rootstest_rootstest_client_verifier_no_authtest_client_verifier_required_authtest_client_verifier_optional_authtest_client_verifier_without_crls_required_authtest_client_verifier_without_crls_opptional_authtest_with_invalid_crlstest_with_crls_multiple_callstest_client_verifier_with_crls_required_auth_implicittest_client_verifier_with_crls_optional_authtest_client_verifier_ee_onlytest_client_verifier_allow_unknowntest_client_verifier_enforce_expirationtest_builder_no_rootsInvalidNameContextOwnedCertRevocationListclient_verifierserver_verifier// Conditionally exported from crate.NoRootAnchors/// No root trust anchors were provided.InvalidCrl/// A provided CRL could not be parsed./// An error that can occur when building a certificate verifier.crl_errorpki_crl_errorscrl_error_from_webpkiverify_server_cert_signed_by_trust_anchor_impl/// A builder for configuring a `webpki` server certificate verifier./// For more information, see the [`WebPkiServerVerifier`] documentation./// Build a server certificate verifier, allowing control over the root certificates to use as/// trust anchors, and to control how server certificate revocation checking is performed./// signature verification algorithms is used, controlled by the selected [`crypto::CryptoProvider`]./// Once built, the provided `Arc<dyn ServerCertVerifier>` can be used with a Rustls/// Default `ServerCertVerifier`, see the trait impl for more information./// Create a builder for the `webpki` server certificate verifier configuration using/// Server certificates will be verified using the trust anchors found in the provided `roots`./// For more information, see the [`ServerCertVerifierBuilder`] documentation.new_without_revocation/// Short-cut for creating a `WebPkiServerVerifier` that does not perform certificate revocation/// checking, avoiding the need to use a builder./// Constructs a new `WebPkiServerVerifier`./// * `roots` is the set of trust anchors to trust for issuing server certs./// * `crls` are a vec of owned certificate revocation lists (CRLs) to use for/// * `supported` is the set of supported algorithms that will be used for///   certificate verification and TLS handshake signature verification./// Will verify the certificate is valid in the following ways:/// - Signed by a trusted `RootCertStore` CA/// - Not Expired/// - Valid for DNS entry/// - Valid revocation status (if applicable)./// Depending on the verifier's configuration revocation status checking may be performed for/// each certificate in the chain to a root CA (excluding the root itself), or only the/// end entity certificate. Similarly, unknown revocation status may be treated as an error/// or allowed based on configuration.test_server_verifier_ee_onlytest_server_verifier_allow_unknowntest_server_verifier_allow_unknown_ee_onlytest_server_verifier_enforce_expirationSignatureVerificationAlgorithm/// Verify that the end-entity certificate `end_entity` is a valid server cert/// and chains to at least one of the trust anchors in the `roots` [RootCertStore]./// This function is primarily useful when building a custom certificate verifier. It/// performs **no revocation checking**. Implementers must handle this themselves,/// along with checking that the server certificate is valid for the subject name/// being used (see [`verify_server_name`])./// were sent as part of the server's `Certificate` message. It is in the/// Verify that the `end_entity` has an alternative name matching the `server_name`./// Note: this only verifies the name and should be used in conjunction with more verification/// like [verify_server_cert_signed_by_trust_anchor]/// A list of all supported signature verification algorithms./// Used for verifying certificate chains./// The order of this list is not significant./// A mapping from TLS `SignatureScheme`s to matching webpki signature verification algorithms./// This is one (`SignatureScheme`) to many ([`SignatureVerificationAlgorithm`]) because/// (depending on the protocol version) there is not necessary a 1-to-1 mapping./// For TLS1.2, all `SignatureVerificationAlgorithm`s are tried in sequence./// For TLS1.3, only the first is tried./// The supported schemes in this mapping is communicated to the peer and the order is significant./// The first mapping is our highest preference./// Describes which `webpki` signature verification algorithms are supported and/// how they map to TLS [`SignatureScheme`]s.supported_schemes/// Return all the `scheme` items in `mapping`, maintaining order.convert_scheme/// Return the first item in `mapping` that matches `scheme`./// Return `true` if all cryptography is FIPS-approved.EndEntityCert/// Wrapper around internal representation of a parsed certificate./// This is used in order to avoid parsing twice when specifying custom verification/// Get the parsed certificate's SubjectPublicKeyInfo (SPKI)/// Verify a message signature using the `cert` public key and any supported scheme./// This function verifies the `dss` signature over `message` using the subject public key from/// `cert`. Since TLS 1.2 doesn't provide enough information to map the `dss.scheme` into a single/// [`SignatureVerificationAlgorithm`], this function will map to several candidates and try each in/// succession until one succeeds or we exhaust all candidates./// See [WebPkiSupportedAlgorithms::mapping] for more information./// Verify a message signature using the `cert` public key and the first TLS 1.3 compatible/// supported scheme./// `cert`. Unlike [verify_tls12_signature], this function only tries the first matching scheme. See/// [WebPkiSupportedAlgorithms::mapping] for more information./// Verify a message signature using a raw public key and the first TLS 1.3 compatibleRevocationOptions/// `revocation` controls how revocation checking is performed, if at all./// This function exists to be used by [`verify_server_cert_signed_by_trust_anchor`],/// and differs only in providing a `Option<webpki::RevocationOptions>` argument. We/// can't include this argument in `verify_server_cert_signed_by_trust_anchor` because/// it will leak the webpki types into Rustls' public API.certificate_debugwebpki_supported_algorithms_is_debug/// Prepend stuff to `bytes` to put it in a DER SEQUENCE./// Prepend stuff to `bytes_a` + `bytes_b` to put it in a DER SEQUENCE.wrap_in_bit_string/// Prepend stuff to `bytes` to put it in a DER BIT STRING./// Prepend stuff to `bytes` to put it in a DER OCTET STRING.asn1_wrapDER_SEQUENCE_TAGDER_BIT_STRING_TAGDER_OCTET_STRING_TAGtest_smalltest_mediumtest_largetest_hugetest_gigantictest_ludicroustest_wrap_in_bit_string// Additional x509/asn1 functions to those provided in webpki/ring.load_native_certs/// Load root certificates found in the platform's native certificate store./// ## Environment Variables/// | Env. Var.      | Description                                                                           |/// |----------------|---------------------------------------------------------------------------------------|/// | SSL_CERT_FILE  | File containing an arbitrary number of certificates in PEM format.                    |/// | SSL_CERT_DIR   | Directory utilizing the hierarchy and naming convention used by OpenSSL's [c_rehash]. |/// If **either** (or **both**) are set, certificates are only loaded from/// the locations specified via environment variables and not the platform-/// native certificate store./// ## Certificate Validity/// All certificates are expected to be in PEM format. A file may contain/// multiple certificates./// MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw/// CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg/// R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00/// MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT/// ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw/// EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW/// +1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9/// ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T/// AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI/// zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW/// tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1/// /q4AaOeMSQ+2b1tbFfLn/// MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5/// MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g/// Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG/// A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg/// Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl/// ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j/// QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr/// ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr/// BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM/// YyRIHN8wfdVoOw==/// For reasons of compatibility, an attempt is made to skip invalid sections/// of a certificate file but this means it's also possible for a malformed/// certificate to be skipped./// If a certificate isn't loaded, and no error is reported, check if:/// 1. the certificate is in PEM format (see example above)/// 2. *BEGIN CERTIFICATE* line starts with exactly five hyphens (`'-'`)/// 3. *END CERTIFICATE* line ends with exactly five hyphens (`'-'`)/// 4. there is a line break after the certificate./// This function fails in a platform-specific way, expressed in a `std::io::Error`./// This function can be expensive: on some platforms it involves loading/// and parsing a ~300KB disk file.  It's therefore prudent to call/// this sparingly./// [c_rehash]: https://www.openssl.org/docs/manmaster/man1/c_rehash.html/// Any certificates that were successfully loaded./// Any errors encountered while loading certificates./// Results from trying to load certificates from the platform's native store./// Return the found certificates if no error occurred, otherwise panic.pem_errorCertPaths/// Certificate paths from `SSL_CERT_FILE` and/or `SSL_CERT_DIR`./// Load certificates from the paths./// If both are `None`, return `Ok(None)`./// If `self.file` is `Some`, it is always used, so it must be a path to an existing,/// accessible file from which certificates can be loaded successfully. While parsing,/// the rustls-pki-types PEM parser will ignore parts of the file which are/// not considered part of a certificate. Certificates which are not in the right/// format (PEM) or are otherwise corrupted may get ignored silently./// If `self.dir` is defined, a directory must exist at this path, and all/// [hash files](`is_hash_file_name()`) contained in it must be loaded successfully,/// subject to the rules outlined above for `self.file`. The directory is not/// scanned recursively and may be empty.load_pem_certs_from_dir/// Load certificate from certificate directory (what OpenSSL calls CAdir)/// This directory can contain other files and directories. CAfile tends/// to be in here too. To avoid loading something twice or something that/// isn't a valid certificate, we limit ourselves to loading those files/// that have a hash-based file name matching the pattern used by OpenSSL./// The hash is not verified, however.load_pem_certsis_hash_file_name/// Check if this is a hash-based file name for a certificate/// According to the [c_rehash man page][]:/// > The links created are of the form HHHHHHHH.D, where each H is a hexadecimal/// > character and D is a single decimal digit./// `c_rehash` generates lower-case hex digits but this is not clearly documented./// Because of this, and because it could lead to issues on case-insensitive file/// systems, upper-case hex digits are accepted too./// [c_rehash man page]: https://www.openssl.org/docs/manmaster/man1/c_rehash.htmlvalid_hash_file_nameinvalid_hash_file_namededuplicationmalformed_file_from_envfrom_env_missing_filefrom_env_missing_dirfrom_env_with_non_regular_and_empty_filefrom_env_bad_dir_permsfrom_env_bad_file_permstest_cert_paths_bad_perms//! rustls-native-certs allows rustls to use the platform's native certificate//! store when operating as a TLS client.//! It provides a single function [`load_native_certs()`], which returns a//! collection of certificates found by reading the platform-native//! certificate store.//! If the SSL_CERT_FILE environment variable is set, certificates (in PEM//! format) are read from that file instead.//! If you want to load these certificates into a `rustls::RootCertStore`,//! you'll likely want to do something like this://! let mut roots = rustls::RootCertStore::empty();//! for cert in rustls_native_certs::load_native_certs().expect("could not load platform certs") {//!     roots.add(cert).unwrap();trust_settingsTrustSettingsTrustSettingsForCertificateValidUsesusable_for_rustlsPKIX_SERVER_AUTHECDSA_P256/// AlgorithmIdentifier for `id-ecPublicKey` with named curve `secp256r1`./// This is:/// # ecPublicKey/// OBJECT_IDENTIFIER { 1.2.840.10045.2.1 }/// # secp256r1/// OBJECT_IDENTIFIER { 1.2.840.10045.3.1.7 }ECDSA_P384/// AlgorithmIdentifier for `id-ecPublicKey` with named curve `secp384r1`./// # secp384r1/// OBJECT_IDENTIFIER { 1.3.132.0.34 }ECDSA_P521/// AlgorithmIdentifier for `id-ecPublicKey` with named curve `secp521r1`./// # secp521r1/// OBJECT_IDENTIFIER { 1.3.132.0.35 }ECDSA_SHA256/// AlgorithmIdentifier for `ecdsa-with-SHA256`./// # ecdsa-with-SHA256/// OBJECT_IDENTIFIER { 1.2.840.10045.4.3.2 }ECDSA_SHA384/// AlgorithmIdentifier for `ecdsa-with-SHA384`./// # ecdsa-with-SHA384/// OBJECT_IDENTIFIER { 1.2.840.10045.4.3.3 }ECDSA_SHA512/// AlgorithmIdentifier for `ecdsa-with-SHA512`./// # ecdsa-with-SHA512/// OBJECT_IDENTIFIER { 1.2.840.10045.4.3.4 }/// AlgorithmIdentifier for `rsaEncryption`./// # rsaEncryption/// OBJECT_IDENTIFIER { 1.2.840.113549.1.1.1 }/// NULL {}/// AlgorithmIdentifier for `sha256WithRSAEncryption`./// # sha256WithRSAEncryption/// OBJECT_IDENTIFIER { 1.2.840.113549.1.1.11 }/// AlgorithmIdentifier for `sha384WithRSAEncryption`./// # sha384WithRSAEncryption/// OBJECT_IDENTIFIER { 1.2.840.113549.1.1.12 }/// AlgorithmIdentifier for `sha512WithRSAEncryption`./// # sha512WithRSAEncryption/// OBJECT_IDENTIFIER { 1.2.840.113549.1.1.13 }/// AlgorithmIdentifier for `rsassaPss` with:/// - hashAlgorithm: sha256/// - maskGenAlgorithm: mgf1 with sha256/// - saltLength: 32/// # rsassa-pss/// OBJECT_IDENTIFIER { 1.2.840.113549.1.1.10 }/// SEQUENCE {///   # hashAlgorithm:///   [0] {///     SEQUENCE {///       # sha256///       OBJECT_IDENTIFIER { 2.16.840.1.101.3.4.2.1 }///       NULL {}///   # maskGenAlgorithm:///   [1] {///       # mgf1///       OBJECT_IDENTIFIER { 1.2.840.113549.1.1.8 }///       SEQUENCE {///         # sha256///         OBJECT_IDENTIFIER { 2.16.840.1.101.3.4.2.1 }///         NULL {}///   # saltLength:///   [2] {///     INTEGER { 32 }/// See <https://datatracker.ietf.org/doc/html/rfc4055#section-3.1> for/// the meaning of the context-specific tags./// - hashAlgorithm: sha384/// - maskGenAlgorithm: mgf1 with sha384/// - saltLength: 48///       # sha384///       OBJECT_IDENTIFIER { 2.16.840.1.101.3.4.2.2 }///         # sha384///         OBJECT_IDENTIFIER { 2.16.840.1.101.3.4.2.2 }///     INTEGER { 48 }/// - hashAlgorithm: sha512/// - maskGenAlgorithm: mgf1 with sha512/// - saltLength: 64///       # sha512///       OBJECT_IDENTIFIER { 2.16.840.1.101.3.4.2.3 }///         # sha512///         OBJECT_IDENTIFIER { 2.16.840.1.101.3.4.2.3 }///     INTEGER { 64 }/// AlgorithmIdentifier for `ED25519`./// # ed25519/// OBJECT_IDENTIFIER { 1.3.101.112 }/// A DER encoding of the PKIX AlgorithmIdentifier type:/// ```ASN.1/// AlgorithmIdentifier  ::=  SEQUENCE  {///     algorithm               OBJECT IDENTIFIER,///     parameters              ANY DEFINED BY algorithm OPTIONAL  }///                                -- contains a value of the type///                                -- registered for use with the///                                -- algorithm object identifier value/// (from <https://www.rfc-editor.org/rfc/rfc5280#section-4.1.1.2>)/// The outer sequence encoding is *not included*, so this is the DER encoding/// of an OID for `algorithm` plus the `parameters` value./// For example, this is the `rsaEncryption` algorithm (but prefer to use the constant/// [`RSA_ENCRYPTION`] instead):/// let rsa_encryption = rustls_pki_types::AlgorithmIdentifier::from_slice(///     &[///         // algorithm: 1.2.840.113549.1.1.1///         0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,///         // parameters: NULL///         0x05, 0x00/// assert_eq!(rustls_pki_types::alg_id::RSA_ENCRYPTION, rsa_encryption);/// Common values for this type are provided in this module./// Makes a new `AlgorithmIdentifier` from a static octet slice./// This does not validate the contents of the slice.//! The PKIX [`AlgorithmIdentifier`] type, and common values.//! If you need to use an [`AlgorithmIdentifier`] not defined here,//! you can define it locally.// See src/data/README.md.decode_secret/// Decode base64 `input`, writing the result into `output`./// `input` is treated as secret, so efforts are made to avoid/// leaking its value via side channels, such as timing,/// memory accesses, and execution trace./// The following is deemed non-secret information:/// - Appearance of whitespace in `input`/// - Erroneous characters in `input` (indeed, the first illegal///   character is quoted in the error type)/// - The length of `input`/// - The length of `output`/// Returns the prefix of `output` that was written to.decode_public/// `input` is treated as public information, so its value may/// be leaked via side channels.decoded_length/// Provide an upper limit on how much space could be required/// to decode a base64 encoding of len `base64_len`.CodePoint/// Given character is not valid in base64 alphabet.PrematurePadding/// A padding character (`=`) appeared outside the final/// block of 4 characters.InvalidTrailingPadding/// The padding characters at the end of the input were invalid./// Not enough space in output buffer./// Use `decoded_length` to get an upper bound.WHITESPACE/// Side-channel rules:/// - code paths that produce `CodePoint(n)` must not make///   `n` observable via a side channel./// - other code paths -- whitespace, padding or invalid -- need not,///   these are not considered secret conditions.u8_in_range/// Returns 0xff if `a` in `lo..=hi`./// lo..=hi must not be 0..=255.  Callers in this file have constant/// `lo` and `hi`, and this function is private to this file.u8_less_than/// Returns 0xff if a < b, 0 otherwise.u8_equals/// Returns 0xff if a == b, 0 otherwise.u8_nonzero/// Returns 0xff if a != 0, 0 otherwise.u8_broadcast8/// Broadcasts the top bit of `x`/// In other words, if the top bit of `x` is set,/// returns 0xff else 0x00.u8_broadcast16decode_errorscheck_modelscodepoint_decode_secret_does_not_branch_or_index_on_secret_inputdecode_bothPemObjectFilter/// Low-level PEM decoding APIs./// These APIs allow decoding PEM format in an iterator, which means you/// can load multiple different types of PEM section from a file in a single/// pass.InvalidDnsNameErrorPkcs1/// An RSA private key/// A Sec1 private key/// A PKCS#8 private key/// A DER-encoded X.509 private key, in one of several formats/// See variant inner types for more detailed information./// This can load several types of PEM-encoded private key, and then reveal/// which types were found:/// # #[cfg(all(feature = "alloc", feature = "std"))] {/// use rustls_pki_types::{PrivateKeyDer, pem::PemObject};/// // load from a PEM file/// let pkcs8 = PrivateKeyDer::from_pem_file("tests/data/nistp256key.pkcs8.pem").unwrap();/// let pkcs1 = PrivateKeyDer::from_pem_file("tests/data/rsa1024.pkcs1.pem").unwrap();/// let sec1 = PrivateKeyDer::from_pem_file("tests/data/nistp256key.pem").unwrap();/// assert!(matches!(pkcs8, PrivateKeyDer::Pkcs8(_)));/// assert!(matches!(pkcs1, PrivateKeyDer::Pkcs1(_)));/// assert!(matches!(sec1, PrivateKeyDer::Sec1(_)));clone_key/// Clone the private key to a `'static` valuesecret_der/// Yield the DER-encoded bytes of the private keyINVALID_KEY_DER_ERR/// A DER-encoded plaintext RSA private key; as specified in PKCS#1/RFC 3447/// RSA private keys are identified in PEM context as `RSA PRIVATE KEY` and when stored in a/// file usually use a `.pem` or `.key` extension./// use rustls_pki_types::{PrivatePkcs1KeyDer, pem::PemObject};/// PrivatePkcs1KeyDer::from_pem_file("tests/data/rsa1024.pkcs1.pem").unwrap();/// // or from a PEM byte slice.../// # let byte_slice = include_bytes!("../tests/data/rsa1024.pkcs1.pem");/// PrivatePkcs1KeyDer::from_pem_slice(byte_slice).unwrap();secret_pkcs1_der/// A Sec1-encoded plaintext private key; as specified in RFC 5915/// Sec1 private keys are identified in PEM context as `EC PRIVATE KEY` and when stored in a/// file usually use a `.pem` or `.key` extension. For more on PEM files, refer to the crate/// use rustls_pki_types::{PrivateSec1KeyDer, pem::PemObject};/// PrivateSec1KeyDer::from_pem_file("tests/data/nistp256key.pem").unwrap();/// # let byte_slice = include_bytes!("../tests/data/nistp256key.pem");/// PrivateSec1KeyDer::from_pem_slice(byte_slice).unwrap();secret_sec1_der/// A DER-encoded plaintext private key; as specified in PKCS#8/RFC 5958/// PKCS#8 private keys are identified in PEM context as `PRIVATE KEY` and when stored in a/// use rustls_pki_types::{PrivatePkcs8KeyDer, pem::PemObject};/// PrivatePkcs8KeyDer::from_pem_file("tests/data/nistp256key.pkcs8.pem").unwrap();/// PrivatePkcs8KeyDer::from_pem_file("tests/data/rsa1024.pkcs8.pem").unwrap();/// # let byte_slice = include_bytes!("../tests/data/nistp256key.pkcs8.pem");/// PrivatePkcs8KeyDer::from_pem_slice(byte_slice).unwrap();secret_pkcs8_der/// Value of the `subject` field of the trust anchor/// Value of the `subjectPublicKeyInfo` field of the trust anchor/// Value of DER-encoded `NameConstraints`, containing name constraints to the trust anchor, if any/// A trust anchor (a.k.a. root CA)/// Traditionally, certificate verification libraries have represented trust anchors as full X.509/// root certificates. However, those certificates contain a lot more data than is needed for/// verifying certificates. The [`TrustAnchor`] representation allows an application to store/// just the essential elements of trust anchors./// The most common way to get one of these is to call [`rustls_webpki::anchor_from_trusted_cert()`]./// [`rustls_webpki::anchor_from_trusted_cert()`]: https://docs.rs/rustls-webpki/latest/webpki/fn.anchor_from_trusted_cert.html/// Yield a `'static` lifetime of the `TrustAnchor` by allocating owned `Der` variants/// A Certificate Revocation List; as specified in RFC 5280/// Certificate revocation lists are identified in PEM context as `X509 CRL` and when stored in a/// file usually use a `.crl` extension. For more on PEM files, refer to the crate documentation./// use rustls_pki_types::{CertificateRevocationListDer, pem::PemObject};/// // load several from a PEM file/// let crls: Vec<_> = CertificateRevocationListDer::pem_file_iter("tests/data/crl.pem")/// assert!(crls.len() >= 1);/// // or one from a PEM byte slice.../// # let byte_slice = include_bytes!("../tests/data/crl.pem");/// CertificateRevocationListDer::from_pem_slice(byte_slice).unwrap();/// // or several from a PEM byte slice/// let crls: Vec<_> = CertificateRevocationListDer::pem_slice_iter(byte_slice)/// A Certificate Signing Request; as specified in RFC 2986/// Certificate signing requests are identified in PEM context as `CERTIFICATE REQUEST` and when stored in a/// file usually use a `.csr` extension. For more on PEM files, refer to the crate documentation./// use rustls_pki_types::{CertificateSigningRequestDer, pem::PemObject};/// CertificateSigningRequestDer::from_pem_file("tests/data/csr.pem").unwrap();/// # let byte_slice = include_bytes!("../tests/data/csr.pem");/// CertificateSigningRequestDer::from_pem_slice(byte_slice).unwrap();/// A DER-encoded X.509 certificate; as specified in RFC 5280/// Certificates are identified in PEM context as `CERTIFICATE` and when stored in a/// file usually use a `.pem`, `.cer` or `.crt` extension. For more on PEM files, refer to the/// crate documentation./// use rustls_pki_types::{CertificateDer, pem::PemObject};/// let certs: Vec<_> = CertificateDer::pem_file_iter("tests/data/certificate.chain.pem")/// assert_eq!(certs.len(), 3);/// # let byte_slice = include_bytes!("../tests/data/certificate.chain.pem");/// CertificateDer::from_pem_slice(byte_slice).unwrap();/// let certs: Vec<_> = CertificateDer::pem_slice_iter(byte_slice)/// A const constructor to create a `CertificateDer` from a slice of DER./// Converts this certificate into its owned variant, unfreezing borrowed content (if any)/// A DER-encoded SubjectPublicKeyInfo (SPKI), as specified in RFC 5280./// Public keys are identified in PEM context as a `PUBLIC KEY`./// use rustls_pki_types::{SubjectPublicKeyInfoDer, pem::PemObject};/// SubjectPublicKeyInfoDer::from_pem_file("tests/data/spki.pem").unwrap();/// # let byte_slice = include_bytes!("../tests/data/spki.pem");/// SubjectPublicKeyInfoDer::from_pem_slice(byte_slice).unwrap();/// Converts this SubjectPublicKeyInfo into its owned variant, unfreezing borrowed content (if any)BytesInner/// A TLS-encoded Encrypted Client Hello (ECH) configuration list (`ECHConfigList`); as specified in/// [draft-ietf-tls-esni-18 §4](https://datatracker.ietf.org/doc/html/draft-ietf-tls-esni-18#section-4)/// Converts this config into its owned variant, unfreezing borrowed content (if any)config_and_key_from_iter/// Convert an iterator over PEM items into an `EchConfigListBytes` and private key./// This handles the "ECHConfig file" format specified in/// <https://www.ietf.org/archive/id/draft-farrell-tls-pemesni-05.html#name-echconfig-file>/// Use it like:/// # use rustls_pki_types::{EchConfigListBytes, pem::PemObject};/// let (config, key) = EchConfigListBytes::config_and_key_from_iter(///     PemObject::pem_file_iter("tests/data/ech.pem").unwrap()/// Verify a signature./// `public_key` is the `subjectPublicKey` value from a `SubjectPublicKeyInfo` encoding/// and is untrusted.  The key's `subjectPublicKeyInfo` matches the [`AlgorithmIdentifier`]/// returned by `public_key_alg_id()`./// `message` is the data over which the signature was allegedly computed./// It is not hashed; implementations of this trait function must do hashing/// if that is required by the algorithm they implement./// `signature` is the signature allegedly over `message`./// Return `Ok(())` only if `signature` is a valid signature on `message`./// Return `Err(InvalidSignature)` if the signature is invalid, including if the `public_key`/// encoding is invalid.  There is no need or opportunity to produce errors/// that are more specific than this.public_key_alg_id/// Return the `AlgorithmIdentifier` that must equal a public key's/// `subjectPublicKeyInfo` value for this `SignatureVerificationAlgorithm`/// to be used for signature verification.signature_alg_id/// Return the `AlgorithmIdentifier` that must equal the `signatureAlgorithm` value/// on the data to be verified for this `SignatureVerificationAlgorithm` to be used/// for signature verification./// An abstract signature verification algorithm./// One of these is needed per supported pair of public key type (identified/// with `public_key_alg_id()`) and `signatureAlgorithm` (identified with/// `signature_alg_id()`).  Note that both of these `AlgorithmIdentifier`s include/// the parameters encoding, so separate `SignatureVerificationAlgorithm`s are needed/// for each possible public key or signature parameters./// Debug implementations should list the public key algorithm identifier and/// signature algorithm identifier in human friendly form (i.e. not encoded bytes),/// along with the name of the implementing library (to distinguish different/// implementations of the same algorithms)./// A detail-less error when a signature is not valid./// A timestamp, tracking the number of non-leap seconds since the Unix epoch./// The Unix epoch is defined January 1, 1970 00:00:00 UTC./// The current time, as a `UnixTime`since_unix_epoch/// Convert a `Duration` since the start of 1970 to a `UnixTime`/// The `duration` must be relative to the Unix epoch./// Number of seconds since the Unix epoch/// DER-encoded data, either owned or borrowed/// This wrapper type is used to represent DER-encoded data in a way that is agnostic to whether/// the data is owned (by a `Vec<u8>`) or borrowed (by a `&[u8]`). Support for the owned/// variant is only available when the `alloc` feature is enabled./// A const constructor to create a `Der` from a borrowed sliceder_debugalg_id_debugbytes_inner_equality//! This crate provides types for representing X.509 certificates, keys and other types as//! commonly used in the rustls ecosystem. It is intended to be used by crates that need to work//! with such X.509 types, such as [rustls](https://crates.io/crates/rustls),//! [rustls-webpki](https://crates.io/crates/rustls-webpki),//! [rustls-pemfile](https://crates.io/crates/rustls-pemfile), and others.//! Some of these crates used to define their own trivial wrappers around DER-encoded bytes.//! However, in order to avoid inconvenient dependency edges, these were all disconnected. By//! using a common low-level crate of types with long-term stable API, we hope to avoid the//! downsides of unnecessary dependency edges while providing good interoperability between crates.//! ## DER and PEM//! Many of the types defined in this crate represent DER-encoded data. DER is a binary encoding of//! the ASN.1 format commonly used in web PKI specifications. It is a binary encoding, so it is//! relatively compact when stored in memory. However, as a binary format, it is not very easy to//! work with for humans and in contexts where binary data is inconvenient. For this reason,//! many tools and protocols use a ASCII-based encoding of DER, called PEM. In addition to the//! base64-encoded DER, PEM objects are delimited by header and footer lines which indicate the type//! of object contained in the PEM blob.//! Types here can be created from://! - DER using (for example) [`PrivatePkcs8KeyDer::from()`].//! - PEM using (for example) [`pem::PemObject::from_pem_slice()`].//! The [`pem::PemObject`] trait contains the full selection of ways to construct//! these types from PEM encodings.  That includes ways to open and read from a file,//! from a slice, or from an `std::io` stream.//! There is also a lower-level API that allows a given PEM file to be fully consumed//! in one pass, even if it contains different data types: see the implementation of//! the [`pem::PemObject`] trait on the `(pem::SectionKind, Vec<u8>)` tuple.//! ## Creating new certificates and keys//! This crate does not provide any functionality for creating new certificates or keys. However,//! the [rcgen](https://docs.rs/rcgen) crate can be used to create new certificates and keys.//! ## Cloning private keys//! This crate intentionally **does not** implement `Clone` on private key types in//! order to minimize the exposure of private key data in memory.//! If you want to extend the lifetime of a `PrivateKeyDer<'_>`, consider [`PrivateKeyDer::clone_key()`].//! Alternatively  since these types are immutable, consider wrapping the `PrivateKeyDer<'_>` in a [`Rc`]//! or an [`Arc`].//! [`Rc`]: https://doc.rust-lang.org/std/rc/struct.Rc.html//! [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.html//! [`PrivateKeyDer::clone_key()`]: https://docs.rs/rustls-pki-types/latest/rustls_pki_types/enum.PrivateKeyDer.html#method.clone_key//! ## Target `wasm32-unknown-unknown` with the `web` feature//! [`std::time::SystemTime`](https://doc.rust-lang.org/std/time/struct.SystemTime.html)//! is unavailable in `wasm32-unknown-unknown` targets, so calls to//! [`UnixTime::now()`](https://docs.rs/rustls-pki-types/latest/rustls_pki_types/struct.UnixTime.html#method.now),//! otherwise enabled by the [`std`](https://docs.rs/crate/rustls-pki-types/latest/features#std) feature,//! require building instead with the [`web`](https://docs.rs/crate/rustls-pki-types/latest/features#web)//! feature. It gets time by calling [`Date.now()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now)//! in the browser.from_pem_slice/// Decode the first section of this type from PEM contained in/// a byte slice./// [`Error::NoItemsFound`] is returned if no such items are found.pem_slice_iter/// Iterate over all sections of this type from PEM contained infrom_pem_file/// Decode the first section of this type from the PEM contents of the named file.pem_file_iterReadIter/// Iterate over all sections of this type from the PEM contents of the named file./// This reports errors in two phases:/// - errors opening the file are reported from this function directly,/// - errors reading from the file are reported from the returned iterator,from_pem_reader/// Decode the first section of this type from PEM read from an [`io::Read`].pem_reader_iter/// Iterate over all sections of this type from PEM present in an [`io::Read`]./// Conversion from a PEM [`SectionKind`] and body data./// This inspects `kind`, and if it matches this type's PEM section kind,/// converts `der` into this type./// Items that can be decoded from PEM data.rd/// Extract and return all PEM sections by reading `rd`./// Create a new iterator./// Iterator over all PEM sections in a `&[u8]` slice./// Returns the rest of the unparsed data./// This is the slice immediately following the most/// recently returned item from `next()`./// Extract and decode the next supported PEM section from `input`/// - `Ok(None)` is returned if there is no PEM section to read from `input`/// - Syntax errors and decoding errors produce a `Err(...)`/// - Otherwise each decoded section is returned with a `Ok(Some((..., remainder)))` where///   `remainder` is the part of the `input` that follows the returned section/// Extract and decode the next supported PEM section from `rd`./// - Ok(None) is returned if there is no PEM section read from `rd`./// - Underlying IO errors produce a `Err(...)`/// - Otherwise each decoded section is returned with a `Ok(Some(...))`/// A DER-encoded x509 certificate./// Appears as "CERTIFICATE" in PEM files./// A DER-encoded Subject Public Key Info; as specified in RFC 7468./// Appears as "PUBLIC KEY" in PEM files.RsaPrivateKey/// A DER-encoded plaintext RSA private key; as specified in PKCS #1/RFC 3447/// Appears as "RSA PRIVATE KEY" in PEM files./// A DER-encoded plaintext private key; as specified in PKCS #8/RFC 5958/// Appears as "EC PRIVATE KEY" in PEM files.Crl/// Appears as "X509 CRL" in PEM files./// Appears as "CERTIFICATE REQUEST" in PEM files.EchConfigList/// An EchConfigList structure, as specified in/// <https://www.ietf.org/archive/id/draft-farrell-tls-pemesni-05.html>./// Appears as "ECHCONFIG" in PEM files./// A single recognised section in a PEM file.end_marker/// the expected "END marker" line that was not foundMissingSectionEnd/// a section is missing its "END marker" line/// line that contains the syntax errorIllegalSectionStart/// syntax error found in the line that starts a new sectionBase64Decode/// base64 decode error/// I/O errors, from APIs that accept `std::io` types.NoItemsFound/// No items found of desired type/// Errors that may arise when parsing the contents of a PEM fileread_until_newline// Ported from https://github.com/rust-lang/rust/blob/91cfcb021935853caa06698b759c293c09d1e96a/library/std/src/io/mod.rs#L1990 and// modified to look for our accepted newlines./// The server is identified by a DNS name.  The name/// is sent in the TLS Server Name Indication (SNI)/// The server is identified by an IP address. SNI is not/// done./// Encodes ways a client can know the expected name of the server./// This currently covers knowing the DNS name of the server, but/// will be extended in the future to supporting privacy-preserving names/// for the server ("ECH").  For this reason this enum is `non_exhaustive`./// # Making one/// If you have a DNS name as a `&str`, this type implements `TryFrom<&str>`,/// so you can do:/// # use rustls_pki_types::ServerName;/// ServerName::try_from("example.com").expect("invalid DNS name");/// If you have an owned `String`, you can use `TryFrom` directly:/// let name = "example.com".to_string();/// ServerName::try_from(name).expect("invalid DNS name");/// which will yield a `ServerName<'static>` if successful./// or, alternatively.../// let x: ServerName = "example.com".try_into().expect("invalid DNS name");/// Produce an owned `ServerName` from this (potentially borrowed) `ServerName`./// Return the string representation of this `ServerName`./// In the case of a `ServerName::DnsName` instance, this function returns a borrowed `str`./// For a `ServerName::IpAddress` instance it returns an allocated `String`./// Attempt to make a ServerName from a string by parsing as a DNS name or IP address.DnsNameInner/// A type which encapsulates a string (borrowed or owned) that is a syntactically valid DNS name./// Produce a borrowed `DnsName` from this owned `DnsName`.to_lowercase_owned/// Copy this object to produce an owned `DnsName`, smashing the case to lowercase/// in one operation./// Produce an owned `DnsName` from this (potentially borrowed) `DnsName`.try_from_string/// Produces a borrowed [`DnsName`] from a borrowed [`str`]./// The provided input could not be parsed because/// it is not a syntactically-valid DNS Name./// An Ipv4 address./// An Ipv6 address./// `no_std` implementation of `std::net::IpAddr`./// Note: because we intend to replace this type with `core::net::IpAddr` as soon as it is/// stabilized, the identity of this type should not be considered semver-stable. However, the/// attached interfaces are stable; they form a subset of those provided by `core::net::IpAddr`./// `no_std` implementation of `std::net::Ipv4Addr`./// Note: because we intend to replace this type with `core::net::Ipv4Addr` as soon as it is/// attached interfaces are stable; they form a subset of those provided by `core::net::Ipv4Addr`./// `no_std` implementation of `std::net::Ipv6Addr`./// Note: because we intend to replace this type with `core::net::Ipv6Addr` as soon as it is/// attached interfaces are stable; they form a subset of those provided by `core::net::Ipv6Addr`.// Parsing as ASCII, so can use byte array./// Run a parser, and restore the pre-parse state if it fails.AddrKind/// Run a parser, but fail if the entire input wasn't consumed./// Doesn't run atomically.peek_char/// Peek the next character from the input/// Read the next character from the input/// Read the next character from the input if it matches the target.read_separator/// Helper for reading separators in an indexed loop. Reads the separator/// character iff index > 0, then runs the parser. When used in a loop,/// the separator character will only be read on index > 0 (see/// read_ipv4_addr for an example)ReadNumberHelper// Read a number off the front of the input in the given radix, stopping// at the first non-digit character or eof. Fails if the number has more// digits than max_digits or if there is no number./// Read an IPv4 address./// Read an IPv6 Address.impl_helper// Adapted from core, 2023-11-23// https://github.com/rust-lang/rust/blob/fc13ca6d70f7381513c22443fc5aaee1d151ea45/library/core/src/net/parser.rs#L34/// Failure to parse an IP addressTESTStest_validationerror_is_debugerror_is_displaydns_name_is_debugdns_name_traitstry_from_ascii_rejects_bad_utf8ipv4_addressIPV4_ADDRESSESparse_ipv4_address_testipv6_addressIPV6_ADDRESSESparse_ipv6_address_testtry_from_ascii_ip_address_testtry_from_ascii_str_ip_address_test//! DNS name validation according to RFC1035, but with underscores allowed.JNIErrorJValueAttachGuardJavaVMjava_vm/// Returns a handle to the current process' JVM./// Returns a reference to the current app's [Context]./// [Context]: <https://developer.android.com/reference/android/content/Context>class_loader/// Returns a reference to the class returned by the current JVM's `getClassLoader` call./// A layer to access the Android runtime which is hosting the current/// application process./// Generally this trait should be implemented in your Rust app component's FFI/// initialization layer.GlobalContextinit_with_env/// Initialize given a typical Android NDK [`JNIEnv`] and [`JObject`] context./// This method will setup and store an environment locally. This is useful if nothing else in your/// application needs to access the Android runtime.init_hosted/// *Deprecated*: This is the original method name for [`init_with_env`] and is functionallyinit_with_runtime/// Initialize with a runtime that can dynamically serve references to/// the JVM, context, and class loader./// This is the most flexible option, and is useful for advanced use cases./// This function will never panic.init_external/// *Deprecated*: This is the original method name for [`init_with_runtime`] and is functionallyinit_with_refs/// Initialize with references to the JVM, context, and class loader./// This is useful when you're already interacting with `jni-rs` wrapped objects and want to use/// global references to objects for efficiency./// pub fn android_init(raw_env: *mut c_void, raw_context: *mut c_void) -> Result<(), jni::errors::Error> {///     let mut env = unsafe { jni::JNIEnv::from_raw(raw_env as *mut jni::sys::JNIEnv).unwrap() };///     let context = unsafe { JObject::from_raw(raw_context as jni::sys::jobject) };///     let loader = env.call_method(&context, "getClassLoader", "()Ljava/lang/ClassLoader;", &[])?;///     rustls_platform_verifier::android::init_with_refs(///         env.get_java_vm()?,///         env.new_global_ref(context)?,///         env.new_global_ref(JObject::try_from(loader)?)?,/// Wrapper for JNI errors that will log and clear exceptions/// It should generally be preferred to `jni::errors::Error`LocalContextload_class/// Load a class from the application class loader/// This should be used instead of `JNIEnv::find_class` to ensure all classes/// in the application can be found.application_context/// Borrow the `applicationContext` from the Android application/// <https://developer.android.com/reference/android/app/Application>/// Borrow the Android application context and execute the closure/// `with_context, ensuring locals are properly freed and exceptions/// are cleared.CachedClass/// Loads and caches a class on first use/// Creates a lazily initialized class reference to the class with `name`./// Gets the cached class reference, loaded on first use//! On Android, initialization must be done before any verification is attempted.//! Some manual setup is required outside of cargo to use this crate on Android. In order to use//! Android’s certificate verifier, the crate needs to call into the JVM. A small Kotlin component//! must be included in your app’s build to support rustls-platform-verifier.//! See the [crate's Android section][crate#android] for more details.//! // A typical entrypoint signature for obtaining the necessary pointers//! pub fn android_init(raw_env: *mut c_void, raw_context: *mut c_void) -> Result<(), jni::errors::Error> {//!     let mut env = unsafe { JNIEnv::from_raw(raw_env as *mut jni::sys::JNIEnv).unwrap() };//!     let context = unsafe { JObject::from_raw(raw_context as jni::sys::jobject) };//!     rustls_platform_verifier::android::init_with_env(&mut env, context)?;/// Fixures and data to support testing the server/// certificate verifier.with_platform_verifier/// Configures the `ClientConfig` with the platform verifier./// use rustls::ClientConfig;/// use rustls_platform_verifier::BuilderVerifierExt;/// let config = ClientConfig::builder()///     .with_platform_verifier()BuilderVerifierExt/// Extension trait to help configure [`ClientConfig`]s with the platform verifier./// Build a [`ClientConfig`] with the platform verifier and the default `CryptoProvider`./// use rustls_platform_verifier::ConfigVerifierExt;/// let config = ClientConfig::with_platform_verifier();ConfigVerifierExt/// Extension trait to help build a [`ClientConfig`] with the platform verifier.jstringANDROID_INITSUCCESS_MARKER/// A marker that the Kotlin test runner looks for to determine/// if a set of integration tests passed or not.run_android_test"Java_org_rustls_platformverifier_CertificateVerifierTests_mockTests"export_namerustls_platform_verifier_mock_test_suite"Java_org_rustls_platformverifier_CertificateVerifierTests_verifyMockRootUsage"rustls_platform_verifier_verify_mock_root_usage"Java_org_rustls_platformverifier_CertificateVerifierTests_realWorldTests"rustls_platform_verifier_real_world_test_suite//! Tests which run inside the context of a Android device, typically an emulator.//! Note: These tests run inside the same application context, so they share the same mock test//! store. This will remain non-problematic as long as roots are different enough (for the use case) and//! real roots are never removed from the store.//! It is intentional that the tests run sequentially, as dropping a `Verifier` will reset its mock//! root store.//! A module to prevent dead-code warnings all over//! the `tests` module due to the weird combination of//! feature flags and `--all-features`. These test case//! lists are only used via the FFI.//! Thin wrappers ontop the existing test suites that allow them to be ran//! in the context of a platform-native environment as required by the verifier implementation.verification_real_worldverification_mockreference_id/// The name of the server we're connecting to./// The certificates presented by the TLS server, in the same order.stapled_ocsp/// The stapled OCSP response given to us by Rustls, if any.verification_time/// The time to use as the current time for verification.expected_result/// An error that should be present inside an expected `CertificateError::Other` variant./// Set this if the error being tested uses `CertificateError::Other` and not statically known/// variants in [TlsError]assert_cert_error_eq/// Return a fixed [`pki_types::UnixTime`] for certificate validation purposes./// We fix the "now" value used for certificate validation to a fixed point in time at which/// we know the test certificates are valid. This must be updated if the mock certificates/// are regenerated.test_providerEkuErrormock_root_test_casesno_errorROOT1ROOT1_INT1ROOT1_INT1_EXAMPLE_COM_GOODROOT1_INT1_LOCALHOST_IPV4_GOODROOT1_INT1_LOCALHOST_IPV6_GOODEXAMPLE_COMLOCALHOST_IPV4LOCALHOST_IPV6verification_without_mock_roottest_verification_without_mock_rootvalid_no_stapling_dnsvalid_no_stapling_ipv4valid_no_stapling_ipv6valid_stapled_good_dnsvalid_stapled_good_ipv4valid_stapled_good_ipv6ee_only_dnsee_only_ipv4ee_only_ipv6domain_mismatch_dnsdomain_mismatch_ipv4domain_mismatch_ipv6wrong_eku_dnswrong_eku_ipv4wrong_eku_ipv6// Note: Android does not currently support IP address hosts, so these tests are disabled for// Android.// Verifies that our test trust anchor(s) are not trusted when `Verifier::new()`// is used.test_with_mock_rootOnlyExtra/// Test with only extra roots, without loading the platform trust store./// We want to keep things reproducible given the background-managed nature of trust roots on platforms.ExtraAndPlatform/// Test with loading the extra roots and the platform trust store./// Right now, not all platforms are supported.//! Tests of certificate verification that require our own test CA to be//! trusted.//! # Re-generating the test data//! `cd src/tests/verification_mock && go run ca.go`//! # Repeatability and Self-containedness//! These tests are only supported on platforms where we have implemented the//! ability to trust a CA (only) for the duration of a test, without modifying//! the operating system's trust store--i.e. without affecting the security of//! any parts of the system outside of these tests. See the `#![cfg(...)]`//! immediately below to see which platforms run these tests.VALID_AWS_AMAZON_COM_CHAIN// This is the certificate chain presented by one server for// `aws.amazon.com` when this test was updated 2025-08-13.// Use this to template view the certificate using OpenSSL:// ```sh// openssl x509 -inform der -text -in aws_amazon_com_valid_1.crt | less// You can update these cert files with `examples/update-certs.rs`valid_aws_chain_names/// Returns a list of names valid for [VALID_AWS_AMAZON_COM_CHAIN], in a format/// expected by `CertificateError::NotValidForContext`.AWS_AMAZON_COMVALID_UNRELATED_DOMAIN// Domain names for which `VALID_AWS_AMAZON_COM_CHAIN` isn't valid.VALID_UNRELATED_SUBDOMAINLETSENCRYPT_ORGVALID_LETSENCRYPT_ORG_CHAINreal_world_test_casesreal_world_testaws_amazon_com_validaws_amazon_com_valid_no_stapled_aws_amazon_com_validunrelated_domain_invalidunrelated_chain_not_valid_for_my_1password_comletsencrypt// Prefer to staple the OCSP response for the end-entity certificate for// performance and repeatability.//! Certificate verification tests that use real-world certificates and the//! "real" (non-mock) Rustls configuration returned.//! These tests are written to reduce the time-bomb nature of testing with//! real certificates, which expire and/or can be revoked over time. For//! example, rather than connecting to the TLS server over the network,//! these tests operate on a locally-cached copy of the certificates//! downloaded at a point in time. However, there are some inherent//! limitations of what we can do when using real-world certificates. We//! accept that the benefit of having these tests outweigh this downside.//! If we encounter cases where these tests are flaky we'll spend additional//! effort//! * If these certificates are ever revoked then it is possible that, even if//!   with the measures mentioned in the next paragraphs, the operating system//!   might learn of the revocation externally and cause the tests to fail.//! * Some operating systems, Windows in particular, download the set of//!   trusted roots dynamically as-needed. If there is a failure during that//!   fetching then the trust anchors for these certificates might not be//!   trusted by the operating system's root store.//! XXX: These tests should be using a stapled OCSP responses so that the//! (operating-system-based) verifier doesn't try to fetch an OCSP//! response or CRL certificate. However, until we can fix the validation//! at a specific point in time, we can't do this, as the OCSP responses//! will generally expire within a matter of days of being produced. Also,//! we'd need to upgrade to a version of Rustls that supports passing in//! stapled OCSP responses for each certificate in the chain. Most certificate//! verifiers that do fetching of OCSP responses will "fail open"; that is, if//! a networking error causes the fetch of the OCSP response to fail, then//! they will continue roughly as though they received a "Good" response.//! Thus we don't expect these tests to be flaky w.r.t. that, except for//! potentially poor performance.JavaStrlog_server_certALLOWED_EKUSCERT_VERIFIER_CLASSBYTE_ARRAY_CLASS// Find the `ByteArray (Uint8 [])` class.STRING_CLASSVerifierStatusUnknownCertInvalidExtension// Note: Keep these in sync with the Kotlin enum.AUTH_TYPE// Android's certificate verifier ignores this outright and this is considered the// official recommendation. See https://bugs.chromium.org/p/chromium/issues/detail?id=627154.test_only_root_ca_override/// Testing only: The root CA certificate to trust./// A TLS certificate verifier that utilizes the Android platform verifier./// Creates a new instance of a TLS certificate verifier that utilizes the/// Android certificate facilities.new_with_fake_root/// Creates a test-only TLS certificate verifier which trusts our fake root CA cert.verify_certificateextract_result_infoCFDatekCFAbsoluteTimeIntervalSince1970SecPolicySecTrustinvalid_certificateerrSecCertificateRevokederrSecCreateChainFailederrSecHostNameMismatcherrSecInvalidExtendedKeyUsagesystem_time_to_cfdateextra_roots/// Extra trust anchors to add to the verifier above and beyond those provided by/// the system-provided trust stores./// A TLS certificate verifier that utilizes the Apple platform certificate facilities./// Creates a new instance of a TLS certificate verifier that utilizes the Apple certificate/// facilities.new_with_extra_roots/// facilities with the addition of extra root certificates to trust./// See [Verifier::new] for the external requirements the verifier needs.others/// An EKU was invalid for the use case of verifying a server certificate./// This error is used primarily for tests.// not used by windows verifier// Log the certificate we are verifying so that we can try and find what may be wrong with it// if we need to debug a user's situation.// We use a `OnceCell` so we only need// to try loading native root certs once per verifier.// We currently keep one set of certificates per-verifier so that// locking and unlocking the application will pull fresh root// certificates from disk, picking up on any changes// that might have been made since./// A TLS certificate verifier that uses the system's root store and WebPKI./// Creates a new verifier whose certificate validation is provided by/// WebPKI, using root certificates provided by the platform./// WebPKI, using root certificates provided by the platform and augmented by/// the provided extra root certificates.// test_root is only used in testsmap_webpki_errorsCERT_E_CN_NO_MATCHCERT_E_EXPIREDCERT_E_INVALID_NAMECERT_E_UNTRUSTEDROOTCERT_E_WRONG_USAGECRYPT_E_REVOKEDCryptographyCertAddEncodedCertificateToStoreCertCloseStoreCertCreateCertificateChainEngineCertFreeCertificateChainCertFreeCertificateChainEngineCertFreeCertificateContextCertGetCertificateChainCertOpenStoreCertSetCertificateContextPropertyCertVerifyCertificateChainPolicyHTTPSPolicyCallbackDataAUTHTYPE_SERVERCERT_CHAIN_CACHE_END_CERTCERT_CHAIN_CONTEXTCERT_CHAIN_ENGINE_CONFIGCERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGSCERT_CHAIN_POLICY_PARACERT_CHAIN_POLICY_SSLCERT_CHAIN_POLICY_STATUSCERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUTCERT_CHAIN_REVOCATION_CHECK_END_CERTCERT_CONTEXTCERT_OCSP_RESPONSE_PROP_IDCERT_SET_PROPERTY_IGNORE_PERSIST_ERROR_FLAGCERT_STORE_ADD_ALWAYSCERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAGCERT_STORE_PROV_MEMORYCERT_STRONG_SIGN_PARACERT_TRUST_IS_PARTIAL_CHAINCERT_USAGE_MATCHCRYPT_INTEGER_BLOBCTL_USAGEUSAGE_MATCH_TYPE_ANDX509_ASN_ENCODINGcbSizeRequestedUsageRequestedIssuancePolicydwUrlRetrievalTimeoutfCheckRevocationFreshnessTimedwRevocationFreshnessTime// BOOLpftCacheResyncpStrongSignPara// XXX: `pStrongSignPara` and `dwStrongSignFlags` might or might not be defined on the current system. It started// being available in Windows 8. See https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/ns-wincrypt-cert_chain_paradwStrongSignFlagsCERT_CHAIN_PARA// The `windows-sys` definition for `CERT_CHAIN_PARA` does not take old OS versions// into account so we define it ourselves for better (hypothetical) OS backwards compat.// In the future a compile-time size assertion can be added against the upstream type to help stay in sync.zeroed_with_sizeZeroedWithSize// SAFETY: see method implementationCertChainverify_chain_policy/// A representation of a certificate./// The `CertificateStore` must be opened with the correct flags to ensure the/// certificate may outlive it; see the `CertificateStore` documentation./// Sets the specified property of this certificate context./// `prop_data` must be a valid pointer for the property type.// HCERTENGINECONTEXTCertEngine// SAFETY: We know no other threads is mutating the `CertEngine`, because it would require `unsafe`.// Across the FFI, `CertGetCertificateChain` don't mutate it either.// SAFETY: All methods of `CertEngine`, including `Drop`, are safe to be called from other// threads, because all contained resources are owned by Windows and we only maintain reference counted handles to them.// HCERTSTORE// In production code, this is always `None`.// During tests, we set this to `Some` as the tests use a// custom verification engine that only uses specific roots.CertificateStore/// An in-memory Windows certificate store./// `CertificateStore` creates `Certificate` objects that may outlive the/// `CertificateStore`. This is only safe to do if the certificate store is/// constructed with `CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG`./// Creates a new, in-memory certificate store./// Adds the provided certificate to the store./// The certificate must be encoded as ASN.1 DER./// Errors if the certificate was malformed and couldn't be added.new_chain_inEnginePtr// `windows-sys` >= 0.60// `windows-sys` 0.52-0.59/// An abstraction trait over the different ways various `windows-sys` versions represent/// the type of `HCERTCHAINENGINE`.call_with_last_error/// A TLS certificate verifier that utilizes the Windows certificate facilities./// Windows certificate facilities./// Windows certificate facilities and augmented by the provided extra root certificates./// Verifies a certificate and its chain for the specified `server`./// Return `Ok(())` if the certificate was valid./// Returns a zeroed structure with its structure size (`cbSize`) field set to the correct value./// A trait to represent an object that can be safely created with all zero values/// and have a size assigned to it./// This has the same safety requirements as [std::mem::zeroed].//! `Verifier` implementation for Windows targets.//! The design of the rustls-native-certs crate for Windows doesn't work//! completely enough. In general it is hard to emulate enough of what//! Windows does to be compatible with all users' configurations, especially//! when corporate MitM proxies or custom CAs or complex trust policies are//! used. Instead, delegate to Windows's own certificate validation engine//! This implementation was modeled on://! * Chromium's [cert_verify_proc_win.cc] and [x509_util_win.cc]//! * Golang's [root_windows.go]//! * [Microsoft's Documentation] and [Microsoft's Example]//! [cert_verify_proc_win.cc]: <https://chromium.googlesource.com/chromium/src/net/+/refs/heads/main/cert/cert_verify_proc_win.cc>//! [x509_util_win.cc]: <https://chromium.googlesource.com/chromium/src/net/+/refs/heads/main/cert/x509_util_win.cc>//! [root_windows.go]: <https://github.com/golang/go/blob/master/src/crypto/x509/root_windows.go>//! [Microsoft's Documentation]: <https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-certgetcertificatechain>//! [Microsoft's Example]: <https://docs.microsoft.com/en-us/windows/win32/seccrypto/example-c-program-creating-a-certificate-chain>DerTypeIdsigned_dataINVALID_SIGNATURE_FOR_RSA_KEYOK_IF_POINT_COMPRESSION_SUPPORTEDOK_IF_RSA_AVAILABLESUPPORTED_ALGORITHMS_IN_TESTSUNSUPPORTED_ECDSA_SHA512_SIGNATUREUNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEYtest_file_bytestest_verify_signed_datatest_verify_signed_data_signature_outer// XXX: This is testing code that isn't even in this module.test_parse_spki_bad_outer// XXX: This is testing code that is not even in this module.test_ecdsa_prime256v1_sha512_spki_params_null// XXX: We should have a variant of this test with a SHA-256 digest that gives// `Error::UnsupportedSignatureAlgorithmForPublicKey`.test_ecdsa_prime256v1_sha512_unused_bits_signaturetest_ecdsa_prime256v1_sha512_using_ecdh_keytest_ecdsa_prime256v1_sha512_using_ecmqv_keytest_ecdsa_prime256v1_sha512_using_rsa_algorithmtest_ecdsa_prime256v1_sha512_wrong_signature_format// `Error::InvalidSignatureForPublicKey`.test_ecdsa_prime256v1_sha512// Differs from Chromium because we don't support P-256 with SHA-512.test_ecdsa_secp384r1_sha256_corrupted_datatest_ecdsa_secp384r1_sha256test_ecdsa_using_rsa_keytest_rsa_pkcs1_sha1_bad_key_der_lengthtest_rsa_pkcs1_sha1_bad_key_der_nulltest_rsa_pkcs1_sha1_key_params_absenttest_rsa_pkcs1_sha1_using_pss_key_no_paramstest_rsa_pkcs1_sha1_wrong_algorithmtest_rsa_pkcs1_sha1test_rsa_pkcs1_sha256// XXX: RSA PKCS#1 with SHA-1 is a supported algorithm, but we only accept// 2048-8192 bit keys, and this test file is using a 1024 bit key. Thus,// our results differ from Chromium's. TODO: this means we need a 2048+ bit// version of this test.test_rsa_pkcs1_sha256_key_encoded_bertest_rsa_pkcs1_sha256_spki_non_null_paramstest_rsa_pkcs1_sha256_using_ecdsa_algorithmtest_rsa_pkcs1_sha256_using_id_ea_rsatest_rsa_pss_sha1_salt20_using_pss_key_no_params// Chromium's PSS test are for parameter combinations we don't support.test_rsa_pss_sha1_salt20_using_pss_key_with_null_paramstest_rsa_pss_sha1_salt20test_rsa_pss_sha1_wrong_salttest_rsa_pss_sha256_mgf1_sha512_salt33test_rsa_pss_sha256_salt10_using_pss_key_with_paramstest_rsa_pss_sha256_salt10_using_pss_key_with_wrong_paramstest_rsa_pss_sha256_salt10test_rsa_pss_sha256_salt32// Our PSS tests that should work.test_rsa_pss_sha384_salt48test_rsa_pss_sha512_salt64test_rsa_pss_sha256_salt32_corrupted_datatest_rsa_pss_sha384_salt48_corrupted_datatest_rsa_pss_sha512_salt64_corrupted_datatest_rsa_using_ec_keytest_rsa2048_pkcs1_sha512test_ecdsa_prime256v1_sha256test_ecdsa_prime256v1_sha256_compressedtest_ecdsa_prime256v1_sha256_spki_inside_spkiTestSignedDataparse_test_signed_dataread_pem_section// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.// TODO: The expected results need to be modified for SHA-1 deprecation.// XXX: Some of the BadDer tests should have better error codes, maybe?try_fips_modeverification_algAwsLcRsAlgorithm/// A `SignatureVerificationAlgorithm` implemented using aws-lc-rs.ECDSA_P256_SHA256/// ECDSA signatures using the P-256 curve and SHA-256.ECDSA_P256_SHA384/// ECDSA signatures using the P-256 curve and SHA-384. Deprecated.ECDSA_P384_SHA256/// ECDSA signatures using the P-384 curve and SHA-256. Deprecated.ECDSA_P384_SHA384/// ECDSA signatures using the P-384 curve and SHA-384.ECDSA_P521_SHA256/// ECDSA signatures using the P-521 curve and SHA-256.ECDSA_P521_SHA384/// ECDSA signatures using the P-521 curve and SHA-384.ECDSA_P521_SHA512/// ECDSA signatures using the P-521 curve and SHA-512./// RSA PKCS#1 1.5 signatures using SHA-256 for keys of 2048-8192 bits./// RSA PKCS#1 1.5 signatures using SHA-384 for keys of 2048-8192 bits./// RSA PKCS#1 1.5 signatures using SHA-512 for keys of 2048-8192 bits.RSA_PKCS1_2048_8192_SHA256_ABSENT_PARAMS/// RSA PKCS#1 1.5 signatures using SHA-256 for keys of 2048-8192 bits,/// with illegally absent AlgorithmIdentifier parameters./// RFC4055 says on sha256WithRSAEncryption and company:/// >   When any of these four object identifiers appears within an/// >   AlgorithmIdentifier, the parameters MUST be NULL.  Implementations/// >   MUST accept the parameters being absent as well as present./// This algorithm covers the absent case, [`RSA_PKCS1_2048_8192_SHA256`] covers/// the present case.RSA_PKCS1_2048_8192_SHA384_ABSENT_PARAMS/// RSA PKCS#1 1.5 signatures using SHA-384 for keys of 2048-8192 bits,/// This algorithm covers the absent case, [`RSA_PKCS1_2048_8192_SHA384`] coversRSA_PKCS1_2048_8192_SHA512_ABSENT_PARAMS/// RSA PKCS#1 1.5 signatures using SHA-512 for keys of 2048-8192 bits,/// This algorithm covers the absent case, [`RSA_PKCS1_2048_8192_SHA512`] covers/// RSA PKCS#1 1.5 signatures using SHA-384 for keys of 3072-8192 bits.RSA_PSS_2048_8192_SHA256_LEGACY_KEY/// RSA PSS signatures using SHA-256 for keys of 2048-8192 bits and of/// type rsaEncryption; see [RFC 4055 Section 1.2]./// [RFC 4055 Section 1.2]: https://tools.ietf.org/html/rfc4055#section-1.2RSA_PSS_2048_8192_SHA384_LEGACY_KEY/// RSA PSS signatures using SHA-384 for keys of 2048-8192 bits and ofRSA_PSS_2048_8192_SHA512_LEGACY_KEY/// RSA PSS signatures using SHA-512 for keys of 2048-8192 bits and of/// ED25519 signatures according to RFC 8410"alg_tests.rs"alg_tests// nb. aws-lc-rs has an API that is broadly compatible with *ring*,// so this is very similar to ring_algs.rs.DerIteratorpublic_values_eqSignedDataNameIteratorWildcardDnsNameRefDistributionPointNameremember_extensionset_extension_oncevaliditybasic_constraintskey_usage// key usage (KU) extension (if any). When validating certificate revocation lists (CRLs) this// field will be consulted to determine if the cert is allowed to sign CRLs. For cert validation// this field is ignored (for more detail see in `verify_cert.rs` and// `check_issuer_independent_properties`).ekusubject_alt_name/// A parsed X509 certificate.valid_dns_names/// Returns a list of valid DNS names provided in the subject alternative names extension/// This function must not be used to implement custom DNS name verification./// Checking that a certificate is valid for a given subject name should always be done with/// [EndEntityCert::verify_is_valid_for_subject_name]./// [EndEntityCert::verify_is_valid_for_subject_name]: crate::EndEntityCert::verify_is_valid_for_subject_name/// Raw DER encoded certificate serial number./// Raw DER encoded certificate issuer./// Raw DER encoded certificate subject./// Get the RFC 5280-compliant [`SubjectPublicKeyInfoDer`] (SPKI) of this [`Cert`]./// Returns an iterator over the certificate's cRLDistributionPoints extension values, if any./// Raw DER encoded representation of the certificate.version3// mozilla::pkix supports v1, v2, v3, and v4, including both the implicit// (correct) and explicit (incorrect) encoding of v1. We allow only v3.lenient_certificate_serial_numberremember_cert_extension/// distributionPoint describes the location of CRL information.BitStringFlags/// reasons holds a bit flag set of certificate revocation reasons associated with the/// CRL distribution point.crl_issuer/// when the CRL issuer is not the certificate issuer, crl_issuer identifies the issuer of the/// CRL./// A certificate revocation list (CRL) distribution point, describing a source of/// CRL information for a given certificate as described in RFC 5280 section 4.2.3.13[^1]./// [^1]: <https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.13>/// Return the distribution point names (if any).TYPE_IDtest_serial_read// Note: cert::parse_cert is crate-local visibility, and EndEntityCert doesn't expose the//       inner Cert, or the serial number. As a result we test that the raw serial value//       is read correctly here instead of in tests/integration.rs.test_spki_readtest_crl_distribution_point_netflixtest_crl_distribution_point_with_reasonstest_crl_distribution_point_with_crl_issuertest_crl_distribution_point_bad_dertest_crl_distribution_point_only_reasonstest_crl_distribution_point_name_relative_to_issuertest_crl_distribution_point_unknown_name_tagtest_crl_distribution_point_multiplePathNodeBorrowedCertRevocationListBorrowedRevokedCertOwnedRevokedCertstatus_policyexpiration_policyRevocationOptionsBuilder/// Builds a RevocationOptions instance to control how revocation checking is performed.CrlsRequired/// Create a builder that will perform revocation checking using the provided certificate/// revocation lists (CRLs). At least one CRL must be provided./// Use [RevocationOptionsBuilder::build] to create a [RevocationOptions] instance./// By default revocation checking will be performed on both the end-entity (leaf) certificate/// and intermediate certificates. This can be customized using the/// [RevocationOptionsBuilder::with_depth] method./// By default revocation checking will fail if the revocation status of a certificate cannot/// be determined. This can be customized using the/// [RevocationOptionsBuilder::with_status_policy] method./// By default revocation checking will *not* fail if the verification time is beyond the time/// in the CRL nextUpdate field. This can be customized using the/// [RevocationOptionsBuilder::with_expiration_policy] method.with_depth/// Customize the depth at which revocation checking will be performed, controlling/// whether only the end-entity (leaf) certificate in the chain to a trust anchor will/// have its revocation status checked, or whether the intermediate certificates will as well.with_status_policy/// Customize whether unknown revocation status is an error, or permitted.with_expiration_policy/// Customize whether the CRL nextUpdate field (i.e. expiration) is enforced./// Construct a [RevocationOptions] instance based on the builder's configuration./// Describes how revocation checking is performed, if at all. Can be constructed with a/// [RevocationOptionsBuilder] instance.CertNotRevokedKeyUsageMode// DigitalSignature = 0,// ContentCommitment = 1,// KeyEncipherment = 2,// DataEncipherment = 3,// KeyAgreement = 4,// CertSign = 5,// EncipherOnly = 7,// DecipherOnly = 8,// https://www.rfc-editor.org/rfc/rfc5280#section-4.2.1.3crl_signature_err// When verifying CRL signed data we want to disambiguate the context of possible errors by mapping// them to CRL specific variants that a consumer can use to tell the issue was with the CRL's// signature, not a certificate.EndEntity/// Only check the end entity (leaf) certificate's revocation status./// Check the revocation status of the end entity (leaf) and all intermediates./// Describes how much of a certificate chain is checked for revocation status./// Treat unknown revocation status permissively, acting as if the certificate were/// not revoked./// Treat unknown revocation status as an error condition, yielding/// [Error::UnknownRevocationStatus]./// Describes how to handle the case where a certificate's revocation status is unknown.Enforce/// Enforce the verification time is before the time in the nextUpdate field./// Treats an expired CRL as an error condition yielding [Error::CrlExpired]./// Ignore the CRL nextUpdate field./// Describes how to handle the nextUpdate field of the CRL (i.e. expiration).// Zero-sized marker type representing positive assertion that revocation status was checked// for a certificate and the result was that the certificate is not revoked.// Construct a CertNotRevoked marker./// An opaque error indicating the caller must provide at least one CRL when building a/// [RevocationOptions] instance.test_revocation_opts_builder// redundant clone, clone_on_copy allowed to verify derived traits.// Copyright 2023 Daniel McCarney./// An owned representation of a CRL./// A borrowed representation of a CRL./// A RFC 5280[^1] profile Certificate Revocation List (CRL)./// May be either an owned, or a borrowed representation./// [^1]: <https://www.rfc-editor.org/rfc/rfc5280#section-5>/// Return the DER encoded issuer of the CRL./// Return the DER encoded issuing distribution point of the CRL, if any.find_serial/// Try to find a revoked certificate in the CRL by DER encoded serial number. This/// may yield an error if the CRL has malformed revoked certificates.authoritative/// Returns true if the CRL can be considered authoritative for the given certificate./// A CRL is considered authoritative for a certificate when:///   * The certificate issuer matches the CRL issuer and,///     * The certificate has no CRL distribution points, and the CRL has no issuing distribution///       point extension.///     * Or, the certificate has no CRL distribution points, but the the CRL has an issuing///       distribution point extension with a scope that includes the certificate.///     * Or, the certificate has CRL distribution points, and the CRL has an issuing///       distribution point extension with a scope that includes the certificate, and at least///       one distribution point full name is a URI type general name that can also be found in///       the CRL issuing distribution point full name general name sequence.///     * Or, the certificate has CRL distribution points, and the CRL has no issuing///       distribution point extension./// In all other circumstances the CRL is not considered authoritative./// Verify the CRL signature using the issuer certificate and a list of supported signature/// verification algorithms, consuming signature operations from the [`Budget`].check_expiration/// Checks the verification time is before the time in the CRL nextUpdate field./// A map of the revoked certificates contained in then CRL, keyed by the DER encoding/// of the revoked cert's serial number.OwnedSignedData/// Owned representation of a RFC 5280[^1] profile Certificate Revocation List (CRL)./// Try to parse the given bytes as a RFC 5280[^1] profile Certificate Revocation List (CRL)./// Webpki does not support:///   * CRL versions other than version 2.///   * CRLs missing the next update field.///   * CRLs missing certificate revocation list extensions.///   * Delta CRLs.///   * CRLs larger than (2^32)-1 bytes in size./// See [BorrowedCertRevocationList::from_der] for more details./// A `SignedData` structure that can be passed to `verify_signed_data`./// Identifies the entity that has signed and issued this/// An optional CRL extension that identifies the CRL distribution point and scope for the CRL./// List of certificates revoked by the issuer in this CRL./// Borrowed representation of a RFC 5280[^1] profile Certificate Revocation List (CRL)./// Convert the CRL to an [`OwnedCertRevocationList`]. This may error if any of the revoked/// certificates in the CRL are malformed or contain unsupported features.only_contains_user_certsonly_contains_ca_certsonly_some_reasonsindirect_crlonly_contains_attribute_certsIssuingDistributionPointauthoritative_for/// Returns true if the CRL can be considered authoritative for the given certificate. We make/// this determination using the certificate and CRL issuers, and the distribution point names/// that may be present in extensions found on both./// We consider the CRL authoritative for the certificate if the CRL issuing distribution point/// has a scope that could include the cert and if the cert has CRL distribution points, that/// at least one CRL DP has a valid distribution point full name where one of the general names/// is a Uniform Resource Identifier (URI) general name that can also be found in the CRL/// issuing distribution point./// We do not consider:/// * Distribution point names relative to an issuer./// * General names of a type other than URI./// * Malformed names or invalid IDP or CRL DP extensions.uri_name_in_common/// Serial number of the revoked certificate./// Identifies the reason for the certificate revocation. When absent, the revocation reason/// is assumed to be RevocationReason::Unspecified. For consistency with other extensions/// and to ensure only one revocation reason extension may be present we maintain this field/// as optional instead of defaulting to unspecified./// Provides the date on which it is known or suspected that the private key was compromised or/// that the certificate otherwise became invalid. This date may be earlier than the revocation/// date which is the date at which the CA processed the revocation./// Owned representation of a RFC 5280[^1] profile Certificate Revocation List (CRL) revoked/// certificate entry./// Only available when the "alloc" feature is enabled./// Convert the owned representation of this revoked cert to a borrowed version./// Borrowed representation of a RFC 5280[^1] profile Certificate Revocation List (CRL) revoked/// Construct an owned representation of the revoked certificate./// Unspecified should not be used, and is instead assumed by the absence of a RevocationReason// 7 is not used./// RemoveFromCrl only appears in delta CRLs that are unsupported./// Return an iterator over all possible [RevocationReason] variants.// RFC 5280 §5.3.1.end_entityPartialPathparse_issuing_distribution_point_exttest_issuing_distribution_point_only_user_certstest_issuing_distribution_point_only_ca_certstest_issuing_distribution_point_indirecttest_issuing_distribution_only_attribute_certstest_issuing_distribution_only_some_reasonstest_issuing_distribution_invalid_booltest_issuing_distribution_explicit_false_booltest_issuing_distribution_unknown_tagtest_issuing_distribution_invalid_nametest_issuing_distribution_relative_nametest_issuing_distribution_no_namerevocation_reasonstest_derived_traitstest_enum_conversionstest_crl_authoritative_issuer_mismatchtest_crl_authoritative_no_idp_no_cert_dptest_crl_expiredtest_crl_not_expiredtest_construct_owned_crl/// [`DerIterator`] will consume all of the bytes in `input` reading values of type `T`./// Parse a value of type `Self` from the given DER-encoded input.// Copied (and extended) from ring's src/der.rs// XXX: narrowing conversion.expect_tag_and_get_value_limitednested_limitedexpect_tagread_tag_and_get_value_limited/// Prepend `bytes` with the given ASN.1 [`Tag`] and appropriately encoded length byte(s)./// Useful for "adding back" ASN.1 bytes to parsed content.TWO_BYTE_DER_SIZE// Long-form DER encoded lengths of two bytes can express lengths up to the following limit.// The upstream ring::io::der::read_tag_and_get_value() function limits itself to up to two byte// long-form DER lengths, and so this limit represents the maximum length that was possible to// read before the introduction of the read_tag_and_get_value_limited function.MAX_DER_SIZE// The maximum size of a DER value that Webpki can support reading.// Webpki limits itself to four byte long-form DER lengths, and so this limit represents// the maximum size tagged DER value that can be read for any purpose.HIGH_TAG_RANGE_START// DER Tag identifiers have two forms:// * Low tag number form (for tags values in the range [0..30]// * High tag number form (for tag values in the range [31..]// We only support low tag number form.SHORT_FORM_LEN_MAX// DER length octets have two forms:// * Short form: 1 octet supporting lengths between 0 and 127.// * Long definite form: 2 to 127 octets, number of octets encoded into first octet.LONG_FORM_LEN_ONE_BYTE// Leading octet for long definite form DER length expressed in second byte.LONG_FORM_LEN_ONE_BYTE_MAX// Maximum size that can be expressed in a one byte long form len.LONG_FORM_LEN_TWO_BYTES// Leading octet for long definite form DER length expressed in subsequent two bytes.LONG_FORM_LEN_TWO_BYTES_MAX// Maximum size that can be expressed in a two byte long form len.LONG_FORM_LEN_THREE_BYTES// Leading octet for long definite form DER length expressed in subsequent three bytes.LONG_FORM_LEN_THREE_BYTES_MAX// Maximum size that can be expressed in a three byte long form len.LONG_FORM_LEN_FOUR_BYTES// Leading octet for long definite form DER length expressed in subsequent four bytes.LONG_FORM_LEN_FOUR_BYTES_MAX// Maximum size that can be expressed in a four byte long form der len.nested_of_mutraw_bitsbit_string_flags// ASN.1 BIT STRING fields for sets of flags are encoded in DER with some peculiar details related// to padding. Notably this means we expect an indicator of the number of bits of padding, and then// the actual bit values. See this Stack Overflow discussion[0], and ITU X690-0207[1] Section 8.6// and Section 11.2 for more information.// [0]: https://security.stackexchange.com/a/10396// [1]: https://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdfend_of_input_err// Like mozilla::pkix, we accept the nonconformant explicit encoding of// the default value (false) for compatibility with real-world certificates.test_asn1_wraptest_optional_booleantest_bit_string_with_no_unused_bitsbytes_readerread_tag_and_get_value_default_limitread_tag_and_get_value_limited_high_formread_tag_and_get_value_limited_non_canonicalread_tag_and_get_value_limited_limitsEXAMPLE_TAG// infallible.der_encode_length// test code.misencoded_bit_string_flagsvalid_bit_string_flagsverify_dns_namesverify_ip_address_namesVerifiedPath/// An end-entity certificate./// Server certificate processing in a TLS connection consists of several/// steps. All of these steps are necessary:/// * [`EndEntityCert::verify_for_usage()`]: Verify that the peer's certificate///   is valid for the current usage scenario. For server authentication, use///   [`KeyUsage::server_auth()`]./// * [`EndEntityCert::verify_is_valid_for_subject_name()`]: Verify that the server's///   certificate is valid for the host or IP address that is being connected to./// * [`EndEntityCert::verify_signature()`]: Verify that the signature of server's///   `ServerKeyExchange` message is valid for the server's certificate./// Client certificate processing in a TLS connection consists of analogous///   is valid for the current usage scenario. For client authentication, use///   [`KeyUsage::client_auth()`]./// * [`EndEntityCert::verify_signature()`]: Verify that the signature of client's///   `CertificateVerify` message is valid using the public key from the///   client's certificate./// Although it would be less error-prone to combine all these steps into a/// single function call, some significant optimizations are possible if the/// three steps are processed separately (in parallel). It does not matter much/// which order the steps are done in, but **all of these steps must completed/// before application data is sent and before received application data is/// processed**. The [`TryFrom`] conversion from `&CertificateDer<'_>` is an/// inexpensive operation and is deterministic, so if these tasks are done in/// multiple threads, it is probably best to just create multiple [`EndEntityCert`]/// instances for the same DER-encoded ASN.1 certificate bytes./// Parse the ASN.1 DER-encoded X.509 encoding of the certificate/// `cert_der`.verify_for_usage/// Verifies that the end-entity certificate is valid for use against the/// specified Extended Key Usage (EKU)./// * `supported_sig_algs` is the list of signature algorithms that are///   trusted for use in certificate signatures; the end-entity certificate's///   public key is not validated against this list./// * `trust_anchors` is the list of root CAs to trust in the built path./// * `intermediate_certs` is the sequence of intermediate certificates that///   a peer sent for the purpose of path building./// * `time` is the time for which the validation is effective (usually the///   current time)./// * `usage` is the intended usage of the certificate, indicating what kind///   of usage we're verifying the certificate for./// * `crls` is the list of certificate revocation lists to check///   the certificate against./// * `verify_path` is an optional verification function for path candidates./// If successful, yields a `VerifiedPath` type that can be used to inspect a verified chain/// of certificates that leads from the `end_entity` to one of the `self.trust_anchors`./// `verify_path` will only be called for potentially verified paths, that is, paths that/// have been verified up to the trust anchor. As such, `verify_path()` cannot be used to/// verify a path that doesn't satisfy the constraints listed above; it can only be used to/// reject a path that does satisfy the aforementioned constraints. If `verify_path` returns/// an error, path building will continue in order to try other options.verify_is_valid_for_subject_name/// Verifies that the certificate is valid for the given Subject Name./// Verifies the signature `signature` of message `msg` using the/// certificate's public key./// `signature_alg` is the algorithm to use to/// verify the signature; the certificate's public key is verified to be/// compatible with this algorithm./// For TLS 1.2, `signature` corresponds to TLS's/// `DigitallySigned.signature` and `signature_alg` corresponds to TLS's/// `DigitallySigned.algorithm` of TLS type `SignatureAndHashAlgorithm`. In/// TLS 1.2 a single `SignatureAndHashAlgorithm` may map to multiple/// `SignatureVerificationAlgorithm`s. For example, a TLS 1.2/// `SignatureAndHashAlgorithm` of (ECDSA, SHA-256) may map to any or all/// of {`ECDSA_P256_SHA256`, `ECDSA_P384_SHA256`}, depending on how the TLS/// implementation is configured./// For current TLS 1.3 drafts, `signature_alg` corresponds to TLS's/// `algorithm` fields of type `SignatureScheme`. There is (currently) a/// one-to-one correspondence between TLS 1.3's `SignatureScheme` and/// `SignatureVerificationAlgorithm`.RCGEN_SIGNATURE_ALGprintable_string_common_name// This test reproduces https://github.com/rustls/webpki/issues/167 --- an// end-entity cert where the common name is a `PrintableString` rather than// a `UTF8String` cannot iterate over its subject alternative names.empty_sequence_common_name// end-entity cert where the common name is an empty SEQUENCE.expect_dns_nameRequiredEkuNotFoundContextBadDer/// The encoding of some ASN.1 DER-encoded item is invalid.BadDerTime/// The encoding of an ASN.1 DER-encoded time is invalid.CaUsedAsEndEntity/// A CA certificate is being used as an end-entity certificate./// The notAfter time of the certificate.CertExpired/// The certificate is expired; i.e. the time it is being validated for is/// later than the certificate's notAfter time.CertNotValidForName/// The certificate is not valid for the name it is being validated for./// The notBefore time of the certificate.CertNotValidYet/// The certificate is not valid yet; i.e. the time it is being validated/// for is earlier than the certificate's notBefore time.CertRevoked/// The certificate, or one of its issuers, has been revoked.CrlExpired/// The CRL is expired; i.e. the verification time is not before the time/// in the CRL nextUpdate field.EndEntityUsedAsCa/// An end-entity certificate is being used as a CA certificate.ExtensionValueInvalid/// An X.509 extension is invalid.InvalidCertValidity/// The certificate validity period (notBefore, notAfter) is invalid; e.g./// the notAfter time is earlier than the notBefore time./// A CRL number extension was invalid:///  - it was mis-encoded///  - it was negative///  - it was too longInvalidNetworkMaskConstraint/// A iPAddress name constraint was invalid:/// - it had a sparse network mask (ie, cannot be written in CIDR form)./// - it was too long or shortInvalidSerialNumber/// A serial number was invalid:///  - it was misencodedInvalidCrlSignatureForPublicKey/// The CRL signature is invalid for the issuer's public key.InvalidSignatureForPublicKey/// The signature is invalid for the given public key./// A CRL was signed by an issuer that has a KeyUsage bitstring that does not include/// the cRLSign key usage bit.MalformedDnsIdentifier/// A presented or reference DNS identifier was malformed, potentially/// containing invalid characters or invalid labels.MalformedExtensions/// The certificate extensions are malformed./// In particular, webpki requires the DNS name(s) be in the subjectAltName/// extension as required by the CA/Browser Forum Baseline Requirements/// and as recommended by RFC6125.MalformedNameConstraint/// A name constraint was malformed, potentially containing invalid characters or/// invalid labels.MaximumNameConstraintComparisonsExceeded/// The maximum number of name constraint comparisons has been reached.MaximumPathBuildCallsExceeded/// The maximum number of internal path building calls has been reached. Path complexity is too great.MaximumPathDepthExceeded/// The path search was terminated because it became too deep.MaximumSignatureChecksExceeded/// The maximum number of signature checks has been reached. Path complexity is too great.NameConstraintViolation/// The certificate violates one or more name constraints.PathLenConstraintViolated/// The certificate violates one or more path length constraints.RequiredEkuNotFound/// The certificate is not valid for the Extended Key Usage for which it is/// being validated.SignatureAlgorithmMismatch/// The algorithm in the TBSCertificate "signature" field of a certificate/// does not match the algorithm in the signature of the certificate./// Trailing data was found while parsing DER-encoded input for the named type./// A valid issuer for the certificate could not be found.UnsupportedCertVersion/// The certificate is not a v3 X.509 certificate./// This error may be also reported if the certificate version field/// is malformed./// The certificate contains an unsupported critical extension.UnsupportedCrlIssuingDistributionPoint/// The CRL contains an issuing distribution point with no distribution point name,/// or a distribution point name relative to an issuer./// The RFC 5280 web PKI profile mandates only version 2 be used. See section/// 5.1.2.1 for more information./// This error may also be reported if the CRL version field is malformed./// The CRL is an unsupported "delta" CRL./// The CRL contains unsupported "indirect" entries./// The `ServerName` contained an unsupported type of value./// The revocation reason is not in the set of supported revocation reasons.UnsupportedRevocationReasonsPartitioning/// The CRL is partitioned by revocation reasons.UnsupportedCrlSignatureAlgorithm/// The signature algorithm for a signature over a CRL is not in the set of supported/// signature algorithms given./// The signature algorithm for a signature is not in the set of supportedUnsupportedCrlSignatureAlgorithmForPublicKey/// The CRL signature's algorithm does not match the algorithm of the issuer/// public key it is being validated for. This may be because the public key/// algorithm's OID isn't recognized (e.g. DSA), or the public key/// algorithm's parameters don't match the supported parameters for that/// algorithm (e.g. ECC keys for unsupported curves), or the public key/// algorithm and the signature algorithm simply don't match (e.g./// verifying an RSA signature with an ECC public key).UnsupportedSignatureAlgorithmForPublicKey/// The signature's algorithm does not match the algorithm of the public/// key it is being validated for. This may be because the public key/// An error that occurs during certificate validation or name validation.most_specific// Compare the Error with the new error by rank, returning the higher rank of the two as// the most specific error.// Return a numeric indication of how specific the error is, where an error with a higher rank// is considered more useful to an end user than an error with a lower rank. This is used by// Error::most_specific to compare two errors in order to return which is more specific.// We won't exceed u32 errors./// Returns true for errors that should be considered fatal during path building. Errors of/// this class should halt any further path building and be returned immediately./// Additional context for the `CertNotValidForName` error variant./// The contents of this type depend on whether the `alloc` feature is enabled.CertificateExtensionsCertificateTbsCertificateCertRevocationListExtensionCommonNameInnerCommonNameOuterTrustAnchorV1TrustAnchorV1TbsCertificateRevokedCertificateRevokedCertificateExtensionRevokedCertEntryring_algsrpk_entitytrust_anchorRawPublicKeyEntity/// Signature verification algorithm implementations using the *ring* crypto library.ALL_VERIFICATION_ALGS/// An array of all the verification algorithms exported by this crate./// This will be empty if the crate is built without the `ring` and `aws-lc-rs` features.//! webpki: Web PKI X.509 Certificate Validation.//! See `EndEntityCert`'s documentation for a description of the certificate//! processing steps necessary for a TLS connection.//! | Feature | Description |//! | ------- | ----------- |//! | `alloc` | Enable features that require use of the heap. Currently all RSA signature algorithms require this feature. |//! | `std` | Enable features that require libstd. Implies `alloc`. |//! | `ring` | Enable use of the *ring* crate for cryptography. |//! | `aws-lc-rs` | Enable use of the aws-lc-rs crate for cryptography. Previously this feature was named `aws_lc_rs`. |RingAlgorithm/// A `SignatureVerificationAlgorithm` implemented using *ring*./// A Raw Public Key, used for connections using raw public keys as specified/// in [RFC 7250](https://www.rfc-editor.org/rfc/rfc7250)./// Parse the ASN.1 DER-encoded SPKI encoding of the raw public key `spki`./// Since we are parsing a raw public key, we first strip the outer sequence tag./// Verifies the signature `signature` of message `msg` using a raw public key,/// supporting RFC 7250./// For more information on `signature_alg` and `signature` see the documentation for [`crate::end_entity::EndEntityCert::verify_signature`].test_ee_read_for_rpktest_spki_read_for_rpk/// The signed data. This would be `tbsCertificate` in the case of an X.509/// certificate, `tbsResponseData` in the case of an OCSP response, `tbsCertList`/// in the case of a CRL, and the data nested in the `digitally-signed` construct for/// TLS 1.2 signed data./// The value of the `AlgorithmIdentifier`. This would be/// `signatureAlgorithm` in the case of an X.509 certificate, OCSP/// response or CRL. This would have to be synthesized in the case of TLS 1.2/// signed data, since TLS does not identify algorithms by ASN.1 OIDs./// The value of the signature. This would be `signature` in an X.509/// certificate, OCSP response or CRL. This would be the value of/// `DigitallySigned.signature` for TLS 1.2 signed data./// X.509 certificates and related items that are signed are almost always/// encoded in the format "tbs||signatureAlgorithm||signature". This structure/// captures this pattern as an owned data type./// Return a borrowed [`SignedData`] from the owned representation./// captures this pattern./// Parses the concatenation of "tbs||signatureAlgorithm||signature" that/// is common in the X.509 certificate and OCSP response syntaxes./// X.509 Certificates (RFC 5280) look like this:/// Certificate (SEQUENCE) {///     tbsCertificate TBSCertificate,///     signatureAlgorithm AlgorithmIdentifier,///     signatureValue BIT STRING/// OCSP responses (RFC 6960) look like this:/// BasicOCSPResponse {///     tbsResponseData ResponseData,///     signature BIT STRING,///     certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL/// Note that this function does NOT parse the outermost `SEQUENCE` or the/// `certs` value./// The return value's first component is the contents of/// `tbsCertificate`/`tbsResponseData`; the second component is a `SignedData`/// structure that can be passed to `verify_signed_data`./// The provided size_limit will enforce the largest possible outermost `SEQUENCE` this/// function will read./// Convert the borrowed signed data to an [`OwnedSignedData`].verify_signed_data/// Verify `signed_data` using the public key in the DER-encoded/// SubjectPublicKeyInfo `spki` using one of the algorithms in/// `supported_algorithms`./// The algorithm is chosen based on the algorithm information encoded in the/// algorithm identifiers in `public_key` and `signed_data.algorithm`. The/// ordering of the algorithms in `supported_algorithms` does not really matter,/// but generally more common algorithms should go first, as it is scanned/// linearly for matches.algorithm_id_value// Parse the public key into an algorithm OID, an optional curve OID, and the// key value. The caller needs to check whether these match the// `PublicKeyAlgorithm` for the `SignatureVerificationAlgorithm` that is matched when// parsing the signature./// A reference to a DNS Name presented by a server that may include a wildcard./// A `WildcardDnsNameRef` is guaranteed to be syntactically valid. The validity rules/// are specified in [RFC 5280 Section 7.2], except that underscores are also/// allowed./// Additionally, while [RFC6125 Section 4.1] says that a wildcard label may be of the form/// `<x>*<y>.<DNSID>`, where `<x>` and/or `<y>` may be empty, we follow a stricter policy common/// to most validation libraries (e.g. NSS) and only accept wildcard labels that are exactly `*`./// [RFC 5280 Section 7.2]: https://tools.ietf.org/html/rfc5280#section-7.2/// [RFC 6125 Section 4.1]: https://www.rfc-editor.org/rfc/rfc6125#section-4.1try_from_ascii/// Constructs a `WildcardDnsNameRef` from the given input if the input is a/// syntactically-valid DNS name./// Yields a reference to the DNS name as a `&str`.presented_id_matches_reference_idIdRole// We assume that both presented_dns_id and reference_dns_id are encoded in// such a way that US-ASCII (7-bit) characters are encoded in one byte and no// encoding of a non-US-ASCII character contains a code point in the range// 0-127. For example, UTF-8 is OK but UTF-16 is not.// RFC6125 says that a wildcard label may be of the form <x>*<y>.<DNSID>, where// <x> and/or <y> may be empty. However, NSS requires <y> to be empty, and we// follow NSS's stricter policy by accepting wildcards only of the form// <x>*.<DNSID>, where <x> may be empty.// An relative presented DNS ID matches both an absolute reference ID and a// relative reference ID. Absolute presented DNS IDs are not supported://      Presented ID   Reference ID  Result//      -------------------------------------//      example.com    example.com   Match//      example.com.   example.com   Mismatch//      example.com    example.com.  Match//      example.com.   example.com.  Mismatch// There are more subtleties documented inline in the code.// Name constraints ///////////////////////////////////////////////////////////// This is all RFC 5280 has to say about dNSName constraints://     DNS name restrictions are expressed as host.example.com.  Any DNS//     name that can be constructed by simply adding zero or more labels to//     the left-hand side of the name satisfies the name constraint.  For//     example, www.host.example.com would satisfy the constraint but//     host1.example.com would not.// This lack of specificity has lead to a lot of uncertainty regarding// subdomain matching. In particular, the following questions have been// raised and answered://     Q: Does a presented identifier equal (case insensitive) to the name//        constraint match the constraint? For example, does the presented//        ID "host.example.com" match a "host.example.com" constraint?//     A: Yes. RFC5280 says "by simply adding zero or more labels" and this//        is the case of adding zero labels.//     Q: When the name constraint does not start with ".", do subdomain//        presented identifiers match it? For example, does the presented//        ID "www.host.example.com" match a "host.example.com" constraint?//        is the case of adding more than zero labels. The example is the//        one from RFC 5280.//     Q: When the name constraint does not start with ".", does a//        non-subdomain prefix match it? For example, does "bigfoo.bar.com"//        match "foo.bar.com"? [4]//     A: No. We interpret RFC 5280's language of "adding zero or more labels"//        to mean that whole labels must be prefixed.//     (Note that the above three scenarios are the same as the RFC 6265//     domain matching rules [0].)//     Q: Is a name constraint that starts with "." valid, and if so, what//        semantics does it have? For example, does a presented ID of//        "www.example.com" match a constraint of ".example.com"? Does a//        presented ID of "example.com" match a constraint of ".example.com"?//     A: This implementation, NSS[1], and SChannel[2] all support a//        leading ".", but OpenSSL[3] does not yet. Amongst the//        implementations that support it, a leading "." is legal and means//        the same thing as when the "." is omitted, EXCEPT that a//        presented identifier equal (case insensitive) to the name//        constraint is not matched; i.e. presented dNSName identifiers//        must be subdomains. Some CAs in Mozilla's CA program (e.g. HARICA)//        have name constraints with the leading "." in their root//        certificates. The name constraints imposed on DCISS by Mozilla also//        have the it, so supporting this is a requirement for backward//        compatibility, even if it is not yet standardized. So, for example, a//        presented ID of "www.example.com" matches a constraint of//        ".example.com" but a presented ID of "example.com" does not.//     Q: Is there a way to prevent subdomain matches?//     A: Yes.//        Some people have proposed that dNSName constraints that do not//        start with a "." should be restricted to exact (case insensitive)//        matches. However, such a change of semantics from what RFC5280//        specifies would be a non-backward-compatible change in the case of//        permittedSubtrees constraints, and it would be a security issue for//        excludedSubtrees constraints.//        However, it can be done with a combination of permittedSubtrees and//        excludedSubtrees, e.g. "example.com" in permittedSubtrees and//        ".example.com" in excludedSubtrees.//     Q: Are name constraints allowed to be specified as absolute names?//        For example, does a presented ID of "example.com" match a name//        constraint of "example.com." and vice versa.//     A: Absolute names are not supported as presented IDs or name//        constraints. Only reference IDs may be absolute.//     Q: Is "" a valid dNSName constraint? If so, what does it mean?//     A: Yes. Any valid presented dNSName can be formed "by simply adding zero//        or more labels to the left-hand side" of "". In particular, an//        excludedSubtrees dNSName constraint of "" forbids all dNSNames.//     Q: Is "." a valid dNSName constraint? If so, what does it mean?//     A: No, because absolute names are not allowed (see above).// [0] RFC 6265 (Cookies) Domain Matching rules://     http://tools.ietf.org/html/rfc6265#section-5.1.3// [1] NSS source code://     https://mxr.mozilla.org/nss/source/lib/certdb/genname.c?rev=2a7348f013cb#1209// [2] Description of SChannel's behavior from Microsoft://     http://www.imc.org/ietf-pkix/mail-archive/msg04668.html// [3] Proposal to add such support to OpenSSL://     http://www.mail-archive.com/openssl-dev%40openssl.org/msg36204.html//     https://rt.openssl.org/Ticket/Display.html?id=3562// [4] Feedback on the lack of clarify in the definition that never got//     incorporated into the spec://     https://www.ietf.org/mail-archive/web/pkix/current/msg21192.htmlascii_lowerWildcardsPresentedNameConstraintis_valid_dns_id// https://tools.ietf.org/html/rfc5280#section-4.2.1.6://   When the subjectAltName extension contains a domain name system//   label, the domain name MUST be stored in the dNSName (an IA5String).//   The name MUST be in the "preferred name syntax", as specified by//   Section 3.5 of [RFC1034] and as modified by Section 2.1 of//   [RFC1123].// https://bugzilla.mozilla.org/show_bug.cgi?id=1136616: As an exception to the// requirement above, underscores are also allowed in names for compatibility.PRESENTED_MATCHES_REFERENCEpresented_matches_reference_testPRESENTED_MATCHES_CONSTRAINT// (presented_name, constraint, expected_matches)presented_matches_constraint_test// Copyright 2015-2020 Brian Smith.// https://tools.ietf.org/html/rfc5280#section-4.2.1.6 says://   When the subjectAltName extension contains an iPAddress, the address//   MUST be stored in the octet string in "network byte order", as//   specified in [RFC791].  The least significant bit (LSB) of each octet//   is the LSB of the corresponding byte in the network address.  For IP//   version 4, as specified in [RFC791], the octet string MUST contain//   exactly four octets.  For IP version 6, as specified in//   [RFC2460], the octet string MUST contain exactly sixteen octets.presented_id_matches_constraint// https://tools.ietf.org/html/rfc5280#section-4.2.1.10 says://     For IPv4 addresses, the iPAddress field of GeneralName MUST contain//     eight (8) octets, encoded in the style of RFC 4632 (CIDR) to represent//     an address range [RFC4632].  For IPv6 addresses, the iPAddress field//     MUST contain 32 octets similarly encoded.  For example, a name//     constraint for "class C" subnet 192.0.2.0 is represented as the//     octets C0 00 02 00 FF FF FF 00, representing the CIDR notation//     192.0.2.0/24 (mask 255.255.255.0).presented_id_matches_constraint_ipv4_testpresented_id_matches_constraint_ipv6_testtest_presented_id_matches_reference_idpresented_id_matches_constraint_rejects_incorrect_length_arguments// (presented_address, constraint_address, constraint_mask, expected_result)alloc_testsdns_namecheck_name_constraints// https://tools.ietf.org/html/rfc5280#section-4.2.1.10check_presented_id_conforms_to_constraintsSubtreesPermittedSubtreesExcludedSubtreesUniformResourceIdentifier// The value is the `tag & ~(der::CONTEXT_SPECIFIC | der::CONSTRUCTED)` so// that the name constraint checking matches tags regardless of whether// those bits are set.// It is *not* valid to derive `Eq`, `PartialEq, etc. for this type. In// particular, for the types of `GeneralName`s that we don't understand, we// don't even store the value. Also, the meaning of a `GeneralName` in a name// constraint is different than the meaning of the identically-represented// `GeneralName` in other contexts.IpAddrSlicedebug_namesname_iter_end_after_error// Copyright 2022 Rafael Fernández López.time_from_ymdhms_utcdays_before_year_since_unix_epochUNIX_EPOCH_YEARdays_before_year_addays_in_febDAYS_BEFORE_UNIX_EPOCH_AD/// All the days up to and including 1969, plus the 477 leap days since AD began/// (calculated in Gregorian rules).test_days_before_unix_epochtest_days_before_year_since_unix_epochtest_days_in_monthtest_time_from_ymdhms_utc//! Conversions into the library's time type./// Interprets the given pre-validated DER-encoded certificate as a `TrustAnchor`./// This function extracts the components of a trust anchor (see [RFC 5280 6.1.1]) from/// an X.509 certificate obtained from a source trusted to have appropriately validated/// the subject name, public key, and name constraints in the certificate, for example your/// operating system's trust store./// No additional checks on the content of the certificate, including whether it is self-signed,/// or has a basic constraints extension indicating the `cA` boolean is true, will be performed./// [RFC 5280 6.2] notes:/// > Implementations that use self-signed certificates to specify trust/// > anchor information are free to process or ignore such information./// This function is intended for users constructing `TrustAnchor`'s from existing trust stores/// that express trust anchors as X.509 certificates. It should **not** be used to treat an/// end-entity certificate as a `TrustAnchor` in an effort to validate the same end-entity/// certificate during path building. Webpki has no support for self-signed certificates./// [RFC 5280 6.1.1]: <https://datatracker.ietf.org/doc/html/rfc5280#section-6.1.1>/// [RFC 5280 6.2]: <https://www.rfc-editor.org/rfc/rfc5280#section-6.2>extract_trust_anchor_from_v1_cert_der/// Parses a v1 certificate directly into a TrustAnchor.supported_sig_algstrust_anchorsintermediate_certsrevocationChainOptions// Use `'a` for lifetimes that we don't care about, `'p` for lifetimes that become a part of// the `VerifiedPath`.build_chain_innercheck_signed_chainIntermediatesanchor/// Path from end-entity certificate to trust anchor that's been verified./// See [`EndEntityCert::verify_for_usage()`] for more details on what verification entails.intermediate_certificatesIntermediateIterator/// Yields a (double-ended) iterator over the intermediate certificates in this path./// Yields the end-entity certificate for this path./// Yields the trust anchor for this path./// Invariant: all of these `Option`s are `Some`./// Iterator over a path's intermediate certificates./// Implements [`DoubleEndedIterator`] so it can be traversed in both directions.MAX_SUB_CA_COUNTcheck_signed_chain_name_constraintssignaturesbuild_chain_callsname_constraint_comparisonsconsume_signatureconsume_build_chain_callconsume_name_constraint_comparisoncheck_issuer_independent_properties// https://tools.ietf.org/html/rfc5280#section-4.1.2.5check_basic_constraints// https://tools.ietf.org/html/rfc5280#section-4.2.1.9/// The required ExtendedKeyUsage./// The ExtendedKeyUsage OIDs present in the certificate./// Additional context for the `RequiredEkuNotFoundContext` error variant.EkuListDebug/// The expected key usage of a certificate./// This type represents the expected key usage of an end entity certificate. Although for most/// kinds of certificates the extended key usage extension is optional (and so certificates/// not carrying a particular value in the EKU extension are acceptable). If the extension/// is present, the certificate MUST only be used for one of the purposes indicated./// <https://www.rfc-editor.org/rfc/rfc5280#section-4.2.1.12>/// Construct a new [`KeyUsage`] as appropriate for server certificate authentication./// As specified in <https://www.rfc-editor.org/rfc/rfc5280#section-4.2.1.12>, this does not require the certificate to specify the eKU extension./// Construct a new [`KeyUsage`] as appropriate for client certificate authentication./// As specified in <>, this does not require the certificate to specify the eKU extension./// Construct a new [`KeyUsage`] requiring a certificate to support the specified OID.required_if_present/// Construct a new [`KeyUsage`] requiring a certificate to support the specified OID, if the certificate has EKUs.oid_values/// Yield the OID values of the required extended key usage.SERVER_AUTH_REPR/// Human-readable representation of the server authentication OID.CLIENT_AUTH_REPR/// Human-readable representation of the client authentication OID.KeyPurposeId/// The certificate must contain the specified [`KeyPurposeId`] as EKU.RequiredIfPresent/// If the certificate has EKUs, then the specified [`KeyPurposeId`] must be included./// Extended Key Usage (EKU) of a certificate.// https://tools.ietf.org/html/rfc5280#section-4.2.1.12key_purpose_id_equalsoid_value/// An OID value indicating an Extended Key Usage (EKU) key purpose./// Construct a new [`KeyPurposeId`]./// `oid` is the OBJECT IDENTIFIER in bytes.EKU_SERVER_AUTH// id-kp-serverAuth   OBJECT IDENTIFIER ::= { id-kp 1 }EKU_CLIENT_AUTH// id-kp-clientAuth   OBJECT IDENTIFIER ::= { id-kp 2 }OidDecoderloop_while_non_fatal_error/// Intermediate certificates, in order from end-entity to trust anchor./// Invariant: all values below `used` are `Some`./// The number of `Some` values in `intermediates`./// The next `Cert` passed to `push()` will be placed at `intermediates[used]`./// If this value is 0, the path contains only the end-entity certificate./// A path for consideration in path building./// This represents a partial path because it does not yet contain the trust anchor. It stores/// the end-entity certificates, and an array of intermediate certificates./// Current head of the path./// Get the certificate at index `idx` in the path.// `idx` must be in the range `0..=self.used`; `idx` 0 thus yields the `end_entity`,// while subsequent indexes yield the intermediate at `self.intermediates[idx - 1]`./// The path we're iterating./// The index of the current node in the path (input for `path.get()`)./// The [`Cert`] at `index`.PathIterissuer_paramsmake_end_entitymake_issueroid_decodingeku_fail_emptyeku_key_purpose_idtest_too_many_signaturestest_too_many_path_callslongest_allowed_pathpath_too_longname_constraint_budgettest_reject_candidate_pathbuild_and_verify_degenerate_chainChainTrustAnchorNotInChainInChainbuild_and_verify_linear_chainbuild_linear_chainIntermediateChainlast_issuer// id-pkix            OBJECT IDENTIFIER ::= { 1 3 6 1 5 5 7 }// id-kp              OBJECT IDENTIFIER ::= { id-pkix 3 }NameRelativeToCrlIssuer/// The distribution point name is a relative distinguished name, relative to the CRL issuer./// The distribution point name is a sequence of [GeneralName] items./// A certificate revocation list (CRL) distribution point name, describing a source ofOopsClippyparse_wordsQualifiersfrom_identinsert_constconstfntry_cfgtry_attrSinceparse_nightlyparse_stableparse_sinceparse_beforeparse_notparse_anyparse_allparse_comma_separatedIterImpl// https://github.com/rust-lang/rust-clippy/issues/8539RUSTVERSIONbetasince//! [![github]](https://github.com/dtolnay/rustversion)&ensp;[![crates-io]](https://crates.io/crates/rustversion)&ensp;[![docs-rs]](https://docs.rs/rustversion)//! This crate provides macros for conditional compilation according to rustc//! compiler version, analogous to [`#[cfg(...)]`][cfg] and//! [`#[cfg_attr(...)]`][cfg_attr].//! [cfg]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute//! [cfg_attr]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute//! # Selectors//! - <p style="margin-left:50px;text-indent:-50px">//!   <b><code>#[rustversion::stable]</code></b>//!   —<br>//!   True on any stable compiler.//!   </p>//!   <b><code>#[rustversion::stable(1.34)]</code></b>//!   True on exactly the specified stable compiler.//!   <b><code>#[rustversion::beta]</code></b>//!   True on any beta compiler.//!   <b><code>#[rustversion::nightly]</code></b>//!   True on any nightly compiler or dev build.//!   <b><code>#[rustversion::nightly(2019-01-01)]</code></b>//!   True on exactly one nightly.//!   <b><code>#[rustversion::since(1.34)]</code></b>//!   True on that stable release and any later compiler, including beta and//!   nightly.//!   <b><code>#[rustversion::since(2019-01-01)]</code></b>//!   True on that nightly and all newer ones.//!   <b><code>#[rustversion::before(</code></b><i>version or date</i><b><code>)]</code></b>//!   Negative of <i>#[rustversion::since(...)]</i>.//!   <b><code>#[rustversion::not(</code></b><i>selector</i><b><code>)]</code></b>//!   Negative of any selector; for example <i>#[rustversion::not(nightly)]</i>.//!   <b><code>#[rustversion::any(</code></b><i>selectors...</i><b><code>)]</code></b>//!   True if any of the comma-separated selectors is true; for example//!   <i>#[rustversion::any(stable, beta)]</i>.//!   <b><code>#[rustversion::all(</code></b><i>selectors...</i><b><code>)]</code></b>//!   True if all of the comma-separated selectors are true; for example//!   <i>#[rustversion::all(since(1.31), before(1.34))]</i>.//!   <b><code>#[rustversion::attr(</code></b><i>selector</i><b><code>, </code></b><i>attribute</i><b><code>)]</code></b>//!   For conditional inclusion of attributes; analogous to//!   <code>cfg_attr</code>.//! # Use cases//! Providing additional trait impls as types are stabilized in the standard library//! without breaking compatibility with older compilers; in this case Pin\<P\>//! stabilized in [Rust 1.33][pin]://! [pin]: https://blog.rust-lang.org/2019/02/28/Rust-1.33.0.html#pinning//! # trait MyTrait {}//! #[rustversion::since(1.33)]//! impl<P: MyTrait> MyTrait for Pin<P> {//! Similar but for language features; the ability to control alignment greater than//! 1 of packed structs was stabilized in [Rust 1.33][packed].//! [packed]: https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1330-2019-02-28//! #[rustversion::attr(before(1.33), repr(packed))]//! #[rustversion::attr(since(1.33), repr(packed(2)))]//! struct Six(i16, i32);//!     println!("{}", std::mem::align_of::<Six>());//! Augmenting code with `const` as const impls are stabilized in the standard//! library. This use of `const` as an attribute is recognized as a special case//! by the rustversion::attr macro.//! #[rustversion::attr(since(1.32), const)]//! fn duration_as_days(dur: Duration) -> u64 {//!     dur.as_secs() / 60 / 60 / 24// Timestamp of 2016-03-01 00:00:00 in UTC.BASE_YEARBASE_MONTHCYCLE// Days between leap days.DAYS_BY_MONTHtry_todayparse_optional_punctparse_optional_keywordparse_literalparse_optional_paren/// Safe API for formatting floating point numbers to text./// let mut buffer = ryu::Buffer::new();/// let printed = buffer.format_finite(1.234);/// assert_eq!(printed, "1.234");/// Print a floating point number into this buffer and return a reference to/// its string representation within the buffer./// # Special cases/// This function formats NaN as the string "NaN", positive infinity as/// "inf", and negative infinity as "-inf" to match std::fmt./// If your input is known to be finite, you may get better performance by/// calling the `format_finite` method instead of `format` to avoid the/// checks for special cases.format_finite/// This function **does not** check for NaN or infinity. If the input/// number is not a finite float, the printed representation will be some/// correctly formatted but unspecified numerical value./// Please check [`is_finite`] yourself before calling this function, or/// check [`is_nan`] and [`is_infinite`] and handle those cases yourself./// [`is_finite`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_finite/// [`is_nan`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_nan/// [`is_infinite`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_infinite/// A floating point number, f32 or f64, that can be written into a/// [`ryu::Buffer`][Buffer]./// This trait is sealed and cannot be implemented for types outside of the/// `ryu` crate.is_nonfiniteformat_nonfinitewrite_to_ryu_bufferdecimal_length9// Returns the number of decimal digits in v, which must not contain more than 9// digits.log2_pow5// Returns e == 0 ? 1 : [log_2(5^e)]; requires 0 <= e <= 3528./* or u32 -> u32 */pow5bits// Returns e == 0 ? 1 : ceil(log_2(5^e)); requires 0 <= e <= 3528.ceil_log2_pow5log10_pow2// Returns floor(log_10(2^e)); requires 0 <= e <= 1650.log10_pow5// Returns floor(log_10(5^e)); requires 0 <= e <= 2620.// Translated from C to Rust. The original C code can be found at// https://github.com/ulfjack/ryu and carries the following license:// Copyright 2018 Ulf Adams// The contents of this file may be used under the terms of the Apache License,// Version 2.0.//    (See accompanying file LICENSE-Apache or copy at//     http://www.apache.org/licenses/LICENSE-2.0)// Alternatively, the contents of this file may be used under the terms of// the Boost Software License, Version 1.0.//    (See accompanying file LICENSE-Boost or copy at//     https://www.boost.org/LICENSE_1_0.txt)// Unless required by applicable law or agreed to in writing, this software// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY// KIND, either express or implied.d2s_full_tableDOUBLE_POW5_INV_SPLITDOUBLE_POW5_SPLITd2s_intrinsicsdiv10div100div5mul_shift_all_64multiple_of_power_of_2multiple_of_power_of_5DOUBLE_MANTISSA_BITSDOUBLE_EXPONENT_BITSDOUBLE_BIASDOUBLE_POW5_INV_BITCOUNTDOUBLE_POW5_BITCOUNTdecimal_length17// Decimal exponent's range is -324 to 308// inclusive, and can fit in i16 if needed.FloatingDecimal64// A floating decimal representing m * 10^e.d2dDOUBLE_POW5_INV_TABLE_SIZEDOUBLE_POW5_TABLE_SIZEpow5_factor// Returns true if value is divisible by 5^p.// Returns true if value is divisible by 2^p.mul_shift_64DOUBLE_POW5_INV_SPLIT2POW5_INV_OFFSETSDOUBLE_POW5_SPLIT2POW5_OFFSETSDOUBLE_POW5_TABLEcompute_pow5// Computes 5^i in the form required by Ryū.compute_inv_pow5// Computes 5^-i in the form required by Ryū.DIGIT_TABLE// A table of all two-digit numbers. This is used to speed up decimal digit// generation by copying pairs of digits into the final output.f2s_intrinsicsmul_pow5_div_pow2mul_pow5_inv_div_pow2multiple_of_power_of_2_32multiple_of_power_of_5_32FLOAT_MANTISSA_BITSFLOAT_EXPONENT_BITSFLOAT_BIASFLOAT_POW5_BITCOUNTFLOAT_POW5_INV_BITCOUNT// Decimal exponent's range is -45 to 38FloatingDecimal32f2dd2spow5factor_32mul_shift_32// It seems to be slightly faster to avoid uint128_t here, although the// generated code for uint128_t looks slightly nicer.digit_tablef2sprettyformat32format64/// Unsafe functions that mirror the API of the C implementation of Ryū.//! [![github]](https://github.com/dtolnay/ryu)&ensp;[![crates-io]](https://crates.io/crates/ryu)&ensp;[![docs-rs]](https://docs.rs/ryu)//! Pure Rust implementation of Ryū, an algorithm to quickly convert floating//! point numbers to decimal strings.//! The PLDI'18 paper [*Ryū: fast float-to-string conversion*][paper] by Ulf//! Adams includes a complete correctness proof of the algorithm. The paper is//! available under the creative commons CC-BY-SA license.//! This Rust implementation is a line-by-line port of Ulf Adams' implementation//! in C, [https://github.com/ulfjack/ryu][upstream].//! [paper]: https://dl.acm.org/citation.cfm?id=3192369//! [upstream]: https://github.com/ulfjack/ryu//!     let mut buffer = ryu::Buffer::new();//!     let printed = buffer.format(1.234);//!     assert_eq!(printed, "1.234");//! ![performance](https://raw.githubusercontent.com/dtolnay/ryu/master/performance.png)//! You can run upstream's benchmarks with://! $ git clone https://github.com/ulfjack/ryu c-ryu//! $ cd c-ryu//! $ bazel run -c opt //ryu/benchmark//! And the same benchmark against our implementation with://! $ git clone https://github.com/dtolnay/ryu rust-ryu//! $ cd rust-ryu//! $ cargo run --example upstream_benchmark --release//! These benchmarks measure the average time to print a 32-bit float and average//! time to print a 64-bit float, where the inputs are distributed as uniform random//! bit patterns 32 and 64 bits wide.//! The upstream C code, the unsafe direct Rust port, and the safe pretty Rust API//! all perform the same, taking around 21 nanoseconds to format a 32-bit float and//! 31 nanoseconds to format a 64-bit float.//! There is also a Rust-specific benchmark comparing this implementation to the//! standard library which you can run with://! $ cargo bench//! The benchmark shows Ryū approximately 2-5x faster than the standard library//! across a range of f32 and f64 inputs. Measurements are in nanoseconds per//! iteration; smaller is better.//! ## Formatting//! This library tends to produce more human-readable output than the standard//! library's to\_string, which never uses scientific notation. Here are two//! examples://! - *ryu:* 1.23e40, *std:* 12300000000000000000000000000000000000000//! - *ryu:* 1.23e-40, *std:* 0.000000000000000000000000000000000000000123//! Both libraries print short decimals such as 0.0000123 without scientific//! notation.MalformedInputwrite_exponent3write_exponent2write_mantissa_longwrite_mantissa/// Print f64 to the given buffer and return number of bytes written./// At most 24 bytes will be written./// ## Special cases/// The `result` pointer argument must point to sufficiently many writable bytes/// to hold Ryū's representation of `f`./// use std::{mem::MaybeUninit, slice, str};/// let f = 1.234f64;///     let mut buffer = [MaybeUninit::<u8>::uninit(); 24];///     let len = ryu::raw::format64(f, buffer.as_mut_ptr() as *mut u8);///     let slice = slice::from_raw_parts(buffer.as_ptr() as *const u8, len);///     let print = str::from_utf8_unchecked(slice);///     assert_eq!(print, "1.234");/// Print f32 to the given buffer and return number of bytes written./// At most 16 bytes will be written./// [`is_finite`]: https://doc.rust-lang.org/std/primitive.f32.html#method.is_finite/// [`is_nan`]: https://doc.rust-lang.org/std/primitive.f32.html#method.is_nan/// [`is_infinite`]: https://doc.rust-lang.org/std/primitive.f32.html#method.is_infinite/// let f = 1.234f32;///     let mut buffer = [MaybeUninit::<u8>::uninit(); 16];///     let len = ryu::raw::format32(f, buffer.as_mut_ptr() as *mut u8);no_panicDOUBLE_EXPONENT_BIASfloor_log2s2dFLOAT_EXPONENT_BIASs2f/// A handle to a file that can be tested for equality with other handles./// If two files are the same, then any two handles of those files will compare/// equal. If two files are not the same, then any two handles of those files/// will compare not-equal./// A handle consumes an open file resource as long as it exists./// Equality is determined by comparing inode numbers on Unix and a combination/// of identifier, volume serial, and file size on Windows. Note that it's/// possible for comparing two handles to produce a false positive on some/// platforms. Namely, two handles can compare equal even if the two handles/// *don't* point to the same file. Check the [source] for specific/// implementation details./// [source]: https://github.com/BurntSushi/same-file/tree/master/src/// Construct a handle from a path./// Note that the underlying [`File`] is opened in read-only mode on all/// [`File`]: https://doc.rust-lang.org/std/fs/struct.File.html/// This method will return an [`io::Error`] if the path cannot/// be opened, or the file's metadata cannot be obtained./// The most common reasons for this are: the path does not/// exist, or there were not enough permissions./// Check that two paths are not the same file:/// use same_file::Handle;/// let source = Handle::from_path("./source")?;/// let target = Handle::from_path("./target")?;/// assert_ne!(source, target, "The files are the same.");/// #     try_main().unwrap();/// Construct a handle from a file./// This method will return an [`io::Error`] if the metadata for/// the given [`File`] cannot be obtained./// Check that two files are not in fact the same file:/// let source = File::open("./source")?;/// let target = File::open("./target")?;///     Handle::from_file(source)?,///     Handle::from_file(target)?,///     "The files are the same."/// Construct a handle from stdin./// This method will return an [`io::Error`] if stdin cannot/// be opened due to any I/O-related reason./// let stdin = Handle::stdin()?;/// let stdout = Handle::stdout()?;/// let stderr = Handle::stderr()?;/// if stdin == stdout {///     println!("stdin == stdout");/// if stdin == stderr {///     println!("stdin == stderr");/// if stdout == stderr {///     println!("stdout == stderr");/// The output differs depending on the platform./// On Linux:/// $ ./example/// stdin == stdout/// stdin == stderr/// stdout == stderr/// $ ./example > result/// $ cat result/// $ ./example > result 2>&1/// Windows:/// > example/// > example > result 2>&1/// > type result/// Construct a handle from stdout./// This method will return an [`io::Error`] if stdout cannot/// See the example for [`stdin()`]./// [`stdin()`]: #method.stdin/// Construct a handle from stderr./// This method will return an [`io::Error`] if stderr cannotas_file/// Return a reference to the underlying file./// Ensure that the target file is not the same as the source one,/// and copy the data to it:/// let source = File::open("source")?;/// let target = File::create("target")?;/// let source_handle = Handle::from_file(source)?;/// let mut target_handle = Handle::from_file(target)?;/// assert_ne!(source_handle, target_handle, "The files are the same.");/// let mut source = source_handle.as_file();/// let target = target_handle.as_file_mut();/// // data copy is simplified for the purposes of the example/// source.read_to_end(&mut buffer)?;/// target.write_all(&buffer)?;/// #    try_main().unwrap();as_file_mut/// Return a mutable reference to the underlying file./// See the example for [`as_file()`]./// [`as_file()`]: #method.as_file/// Return the underlying device number of this handle./// Note that this only works on unix platforms./// Return the underlying inode number of this handle.is_same_file/// Returns true if the two file paths may correspond to the same file./// Note that it's possible for this to produce a false positive on some/// platforms. Namely, this can return true even if the two file paths *don't*/// resolve to the same file./// This function will return an [`io::Error`] if any of the two paths cannot/// be opened. The most common reasons for this are: the path does not exist,/// or there were not enough permissions./// use same_file::is_same_file;/// assert!(is_same_file("./foo", "././foo").unwrap_or(false));/// Create an error from a format!-like syntax./// A simple wrapper for creating a temporary directory that is/// automatically deleted when it's dropped./// We use this in lieu of tempfile because tempfile brings in too many/// dependencies./// Create a new empty temporary directory under the system's/// configured temporary directory./// Return the underlying path to this temporary directory.tmpdirsoft_link_dirsoft_link_filesame_file_trivialsame_dir_trivialnot_same_file_trivialnot_same_dir_trivialsame_file_hardsame_file_softsame_dir_soft// These tests are rather uninteresting. The really interesting tests// would stress the edge cases. On Unix, this might be comparing two files// on different mount points with the same inode number. On Windows, this// might be comparing two files whose file indices are the same on file// systems where such things aren't guaranteed to be unique.// Alas, I don't know how to create those environmental conditions. ---AG/*!
This crate provides a safe and simple **cross platform** way to determine
whether two file paths refer to the same file or directory.

Most uses of this crate should be limited to the top-level [`is_same_file`]
function, which takes two file paths and returns true if they refer to the
same file or directory:

```rust,no_run
# use std::error::Error;
use same_file::is_same_file;

# fn try_main() -> Result<(), Box<Error>> {
assert!(is_same_file("/bin/sh", "/usr/bin/sh")?);
#    Ok(())
# }
#
# fn main() {
#    try_main().unwrap();
# }
```

Additionally, this crate provides a [`Handle`] type that permits a more efficient
equality check depending on your access pattern. For example, if one wanted to
check whether any path in a list of paths corresponded to the process' stdout
handle, then one could build a handle once for stdout. The equality check for
each file in the list then only requires one stat call instead of two. The code
might look like this:

```rust,no_run
# use std::error::Error;
use same_file::Handle;

# fn try_main() -> Result<(), Box<Error>> {
let candidates = &[
    "examples/is_same_file.rs",
    "examples/is_stderr.rs",
    "examples/stderr",
];
let stdout_handle = Handle::stdout()?;
for candidate in candidates {
    let handle = Handle::from_path(candidate)?;
    if stdout_handle == handle {
        println!("{:?} is stdout!", candidate);
    } else {
        println!("{:?} is NOT stdout!", candidate);
    }
}
#    Ok(())
# }
#
# fn main() {
#     try_main().unwrap();
# }
```

See [`examples/is_stderr.rs`] for a runnable example and compare the output of:

- `cargo run --example is_stderr 2> examples/stderr` and
- `cargo run --example is_stderr`.

[`is_same_file`]: fn.is_same_file.html
[`Handle`]: struct.Handle.html
[`examples/is_stderr.rs`]: https://github.com/BurntSushi/same-file/blob/master/examples/is_same_file.rs

*/is_std// If is_std is true, then we don't drop the corresponding File since it// will close the handle.ERROR_MESSAGE// This implementation is to allow same-file to be compiled on// unsupported platforms in case it was incidentally included// as a transitive, unused dependencywinapi_utilwinutilHandleKind/// Used when opening a file or acquiring ownership of a file.HandleRef/// Used for stdio.from_std_handlefrom_infoInformation// For correctness, it is critical that both file handles remain open while// their attributes are checked for equality. In particular, the file index// numbers on a Windows stat object are not guaranteed to remain stable over// time.// See the docs and remarks on MSDN:// https://msdn.microsoft.com/en-us/library/windows/desktop/aa363788(v=vs.85).aspx// It gets worse. It appears that the index numbers are not always// guaranteed to be unique. Namely, ReFS uses 128 bit numbers for unique// identifiers. This requires a distinct syscall to get `FILE_ID_INFO`// documented here:// https://msdn.microsoft.com/en-us/library/windows/desktop/hh802691(v=vs.85).aspx// It seems straight-forward enough to modify this code to use// `FILE_ID_INFO` when available (minimum Windows Server 2012), but I don't// have access to such Windows machines.// Two notes.// 1. Java's NIO uses the approach implemented here and appears to ignore//    `FILE_ID_INFO` altogether. So Java's NIO and this code are//    susceptible to bugs when running on a file system where//    `nFileIndex{Low,High}` are not unique.// 2. LLVM has a bug where they fetch the id of a file and continue to use//    it even after the handle has been closed, so that uniqueness is no//    longer guaranteed (when `nFileIndex{Low,High}` are unique).//    bug report: http://lists.llvm.org/pipermail/llvm-bugs/2014-December/037218.html// All said and done, checking whether two files are the same on Windows// seems quite tricky. Moreover, even if the code is technically incorrect,// it seems like the chances of actually observing incorrect behavior are// extremely small. Nevertheless, we mitigate this by checking size too.// In the case where this code is erroneous, two files will be reported// as equivalent when they are in fact distinct. This will cause the loop// detection code to report a false positive, which will prevent descending// into the offending directory. As far as failure modes goes, this isn't// that bad.ConverterTypeSincBestQualitySincMediumQualitySincFastestZeroOrderHold/// A converter type used to distinguish the interpolation function used by libsamplerate./// Has a great impact on quality and performance./// Create a new `ConverterType` enum from the corresponding integer./// Return a human-readable name for this type of converter./// Return the human-readable description for this type of converter.create_converter_type_from_intNoErrorMallocFailedBadDataBadDataPtrNoPrivateBadSrcRatioBadProcPtrShiftBitsFilterLenBadConverterBadChannelCountSincBadBufferLenSizeIncompatibilityBadPrivPtrBadSincStateDataOverlapBadCallbackBadModeNullCallbackNoVariableRatioSincPrepareDataBadLenBadInternalStateMaxError/// Return the human-readable description for this error.error_from_code_and_interror_descriptionconverter_typesanity_test/// Perform a simple samplerate conversion of a large chunk of audio./// This calls `src_simple` of libsamplerate which is not suitable for streamed audio. Use the/// `Samplerate` struct instead for this./// The length of `input` must be `input_frame_count * channels`./// The length of result `Vec<f32>` should be `input_frames * to_rate + (from_rate - 1)) / from_rate`/// use samplerate::{convert, ConverterType};/// // Generate a 880Hz sine wave for 1 second in 44100Hz with one channel./// let freq = std::f32::consts::PI * 880f32 / 44100f32;/// let mut input: Vec<f32> = (0..44100).map(|i| (freq * i as f32).sin()).collect();/// // Resample the input from 44100Hz to 48000Hz./// let resampled = convert(44100, 48000, 1, ConverterType::SincBestQuality, &input).unwrap();/// assert_eq!(resampled.len(), 48000);/// Returns the version of `libsamplerate` used by this crate as a string.correct_versionfrom_rateto_rateSamplerate/// A samplerate converter. This is a wrapper around libsamplerate's `SRC_STATE` which also/// stores the source and target samplerates./// use samplerate::{Samplerate, ConverterType};/// // Instanciate a new converter./// let mut converter = Samplerate::new(ConverterType::SincBestQuality, 44100, 48000, 1).unwrap();/// let resampled = converter.process_last(&input).unwrap();/// Create a new samplerate converter with the given rates and channels./// Reset the internal converter's state./// Retrieve the currently used source samplerate./// Retrieve the currently used target samplerate.set_from_rate/// Change the source samplerate.set_to_rate/// Change the target samplerate./// Calculate the ratio (target samplerate divided by source samplerate)./// Retrieve the number of channels used._process/// Perform a samplerate conversion on a block of data (use `process_last` if it is the last one)/// If the number of channels used was not `1` (Mono), the samples are expected to be stored/// interleaved.process_last/// Perform a samplerate conversion on last block of given input data./// Might panic if the underlying `src_clone` method from libsamplerate returns an error.samplerate_new_channels_errorsamplerate_new_channels_correctsamplerate_clonesamplerate_conversionsimple_resamplescoped_thread_local/// The macro. See the module level documentation for the description and examples.ScopedKey/// Type representing a thread local storage key corresponding to a reference/// to the type parameter `T`./// Keys are statically allocated and can contain a reference to an instance of/// type `T` scoped to a particular lifetime. Keys provides two methods, `set`/// and `with`, both of which currently use closures to control the scope of/// their contents./// Inserts a value into this scoped thread local storage slot for a/// duration of a closure./// While `f` is running, the value `t` will be returned by `get` unless/// this function is called recursively inside of `f`./// Upon return, this function will restore the previous value, if any/// was available./// extern crate scoped_tls;/// scoped_thread_local!(static FOO: u32);/// FOO.set(&100, || {///     let val = FOO.with(|v| *v);///     assert_eq!(val, 100);///     // set can be called recursively///     FOO.set(&101, || {///     // Recursive calls restore the previous value./// Gets a value out of this scoped variable./// This function takes a closure which receives the value of this/// This function will panic if `set` has not previously been called./// FOO.with(|slot| {///     // work with `slot`/// # drop(slot);/// Test whether this TLS key has been `set` for the current thread.FOOcell_allowedscope_item_allowedpanic_resetsattrs_allowed//! Scoped thread-local storage//! This module provides the ability to generate *scoped* thread-local//! variables. In this sense, scoped indicates that thread local storage//! actually stores a reference to a value, and this reference is only placed//! in storage for a scoped amount of time.//! There are no restrictions on what types can be placed into a scoped//! variable, but all scoped variables are initialized to the equivalent of//! null. Scoped thread local storage is useful when a value is present for a known//! period of time and it is not required to relinquish ownership of the//! contents.//! extern crate scoped_tls;//! scoped_thread_local!(static FOO: u32);//! // Initially each scoped slot is empty.//! assert!(!FOO.is_set());//! // When inserting a value, the value is only in place for the duration//! // of the closure specified.//! FOO.set(&1, || {//!     FOO.with(|slot| {//!         assert_eq!(*slot, 1);/// Return `true` if the guard’s associated code should run/// (in the context where this method is called)./// Controls in which cases the associated code should be run/// Always run on scope exit./// “Always” run: on regular exit from a scope or on unwinding from a panic./// Can not run on abort, process exit, and other catastrophic events where/// destructors don’t run.OnUnwind/// Run on scope exit through unwinding./// Requires crate feature `use_std`.OnSuccess/// Run on regular scope exit, when not unwinding./// Macro to create a `ScopeGuard` (always run)./// The macro takes statements, which are the body of a closure/// that will run when the scope is exited.defer_on_success/// Macro to create a `ScopeGuard` (run on successful scope exit).defer_on_unwind/// Macro to create a `ScopeGuard` (run on unwinding from panic).// fn(S) -> S is used, so that the S is not taken into account for auto traits./// `ScopeGuard` is a scope guard that may own a protected value./// If you place a guard in a local variable, the closure can/// run regardless how you leave the scope — through regular return or panic/// (except if panic or other code aborts; so as long as destructors run)./// It is run only once./// The `S` parameter for [`Strategy`](trait.Strategy.html) determines if/// the closure actually runs./// The guard's closure will be called with the held value in the destructor./// The `ScopeGuard` implements `Deref` so that you can access the inner value./// Create a `ScopeGuard` that owns `v` (accessible through deref) and calls/// `dropfn` when its destructor runs./// The `Strategy` decides whether the scope guard's closure should run./// “Defuse” the guard and extract the value without calling the closure./// extern crate scopeguard;/// use scopeguard::{guard, ScopeGuard};/// fn conditional() -> bool { true }///     let mut guard = guard(Vec::new(), |mut v| v.clear());///     guard.push(1);///     if conditional() {///         // a condition maybe makes us decide to///         // “defuse” the guard and get back its inner parts///         let value = ScopeGuard::into_inner(guard);///         // guard still exists in this branch/// Create a new `ScopeGuard` owning `v` and with deferred closure `dropfn`.guard_on_successguard_on_unwind/// For performance reasons, or to emulate “only run guard on unwind” in/// no-std environments, we can also use the default guard and simply manually/// defuse it at the end of scope like the following example. (The performance/// reason would be if the [`OnUnwind`]'s call to [std::thread::panicking()] is/// an issue.)/// use scopeguard::ScopeGuard;///     let guard = scopeguard::guard((), |_| {});///     // rest of the code here///     // we reached the end of scope without unwinding - defuse it///     ScopeGuard::into_inner(guard);// ScopeGuard can be Sync even if F isn't because the closure is// not accessible from references.// The guard does not store any instance of S, so it is also irrelevant.test_defertest_defer_success_1test_defer_success_2test_defer_unwind_1test_defer_unwind_2test_only_dropped_by_closure_when_runtest_dropped_once_when_not_run//! A scope guard will run a given closure when it goes out of scope,//! even if the code between panics.//! (as long as panic doesn't abort)//! ## Hello World//! This example creates a scope guard with an example function://! extern crate scopeguard;//! fn f() {//!     let _guard = scopeguard::guard((), |_| {//!         println!("Hello Scope Exit!");//!     // rest of the code here.//!     // Here, at the end of `_guard`'s scope, the guard's closure is called.//!     // It is also called if we exit this scope through unwinding instead.//! #    f();//! ## `defer!`//! Use the `defer` macro to run an operation at scope exit,//! either regular scope exit or during unwinding from a panic.//! #[macro_use(defer)] extern crate scopeguard;//! use std::cell::Cell;//!     // use a cell to observe drops during and after the scope guard is active//!     let drop_counter = Cell::new(0);//!         // Create a scope guard using `defer!` for the current scope//!         defer! {//!             drop_counter.set(1 + drop_counter.get());//!         // Do regular operations here in the meantime.//!         // Just before scope exit: it hasn't run yet.//!         assert_eq!(drop_counter.get(), 0);//!         // The following scope end is where the defer closure is called//!     assert_eq!(drop_counter.get(), 1);//! ## Scope Guard with Value//! If the scope guard closure needs to access an outer value that is also//! mutated outside of the scope guard, then you may want to use the scope guard//! with a value. The guard works like a smart pointer, so the inner value can//! be accessed by reference or by mutable reference.//! ### 1. The guard owns a file//! In this example, the scope guard owns a file and ensures pending writes are//! synced at scope exit.//! use std::fs::*;//! use std::io::{self, Write};//! # // Mock file so that we don't actually write a file//! # struct MockFile;//! # impl MockFile {//! #     fn create(_s: &str) -> io::Result<Self> { Ok(MockFile) }//! #     fn write_all(&self, _b: &[u8]) -> io::Result<()> { Ok(()) }//! #     fn sync_all(&self) -> io::Result<()> { Ok(()) }//! # use self::MockFile as File;//! fn try_main() -> io::Result<()> {//!     let f = File::create("newfile.txt")?;//!     let mut file = scopeguard::guard(f, |f| {//!         // ensure we flush file at return or panic//!         let _ = f.sync_all();//!     // Access the file through the scope guard itself//!     file.write_all(b"test me\n").map(|_| ())//!     try_main().unwrap();//! ### 2. The guard restores an invariant on scope exit//! use std::mem::ManuallyDrop;//! // This function, just for this example, takes the first element//! // and inserts it into the assumed sorted tail of the vector.//! // For optimization purposes we temporarily violate an invariant of the//! // Vec, that it owns all of its elements.//! // The safe approach is to use swap, which means two writes to memory,//! // the optimization is to use a “hole” which uses only one write of memory//! // for each position it moves.//! // We *must* use a scope guard to run this code safely. We//! // are running arbitrary user code (comparison operators) that may panic.//! // The scope guard ensures we restore the invariant after successful//! // exit or during unwinding from panic.//! fn insertion_sort_first<T>(v: &mut Vec<T>)//!     where T: PartialOrd//!     struct Hole<'a, T: 'a> {//!         v: &'a mut Vec<T>,//!         index: usize,//!         value: ManuallyDrop<T>,//!         // Create a moved-from location in the vector, a “hole”.//!         let value = ptr::read(&v[0]);//!         let mut hole = Hole { v: v, index: 0, value: ManuallyDrop::new(value) };//!         // Use a scope guard with a value.//!         // At scope exit, plug the hole so that the vector is fully//!         // initialized again.//!         // The scope guard owns the hole, but we can access it through the guard.//!         let mut hole_guard = scopeguard::guard(hole, |hole| {//!             // plug the hole in the vector with the value that was // taken out//!             let index = hole.index;//!             ptr::copy_nonoverlapping(&*hole.value, &mut hole.v[index], 1);//!         // run algorithm that moves the hole in the vector here//!         // move the hole until it's in a sorted position//!         for i in 1..hole_guard.v.len() {//!             if *hole_guard.value >= hole_guard.v[i] {//!                 // move the element back and the hole forward//!                 let index = hole_guard.index;//!                 hole_guard.v.swap(index, index + 1);//!                 hole_guard.index += 1;//!             } else {//!         // When the scope exits here, the Vec becomes whole again!//!     let string = String::from;//!     let mut data = vec![string("c"), string("a"), string("b"), string("d")];//!     insertion_sort_first(&mut data);//!     assert_eq!(data, vec!["a", "b", "c", "d"]);//! # Crate Features//!   + Enabled by default. Enables the `OnUnwind` and `OnSuccess` strategies.//!   + Disable to use `no_std`.//! # Rust Version//! This version of the crate requires Rust 1.20 or later.//! The scopeguard 1.x release series will use a carefully considered version//! upgrade policy, where in a later 1.x version, we will raise the minimumreexportscsd_frameWindowManagerCapabilitiesPathBuilderPixmapMutStrokeSkiaResultBUTTON_SIZE/// The size of the button on the header bar in logical points.BUTTON_MARGINBUTTON_SPACINGbuttons_left// Sorted by order vec of buttons for the left and right sidesbuttons_rightlayout_configButtonsButtonLayoutarrange/// Rearrange the buttons with the new width.find_button/// Find the coordinate of the button.update_wm_capabilitiesupdate_buttonsright_buttons_start_xleft_buttons_end_xparse_button_layoutparse_button_layout_sideget_default_buttons_layout/// The button offset into the header bar canvas.ButtonKind/// The kind of the button.center_xcenter_yend_xprefer_dark/// Query system to see if dark theming should be preferred.get_button_layout_config/// Query system configuration for buttons layout./// Should be updated to use standard xdg-desktop-portal specs once available/// https://github.com/flatpak/xdg-desktop-portal/pull/996//! System configuration.PixmapPaintObjectIdwl_shmwl_subsurfaceWlSubsurfacewl_surfaceWlSurfaceDecorationsFrameFrameActionFrameClickcompositorCompositorStateSurfaceDataWaylandSurfaceSlotPoolShmsubcompositorSubcompositorStateSubsurfaceDatawl_typedColorThemeBORDER_SIZECORNER_RADIUSRESIZE_HANDLE_CORNER_SIZEVISIBLE_BORDER_SIZEDecorationPartsMouseStateShadowTitleTextWlTyped/// XXX this is not result, so `must_use` when needed.base_surface/// The base surface used to create the window./// Subcompositor to create/drop subsurfaces ondemand.queue_handle/// Queue handle to perform object creation./// The drawable decorations, `None` when hidden./// Memory pool to allocate the buffers for the decorations./// Whether the frame should be redrawn.should_sync/// Whether the drawing should be synced with the main surface./// Scale factor used for the surface./// Wether the frame is resizable.wm_capabilitiestitle_textAdwaitaFrame/// A simple set of decorationsFrameConfig/// Update the current frame config.precise_locationredraw_innerupdate_stateset_hiddensubtract_bordersadd_borderson_clickset_scaling_factorclick_point_movedclick_point_left/// The configuration for the [`AdwaitaFrame`] frame./// Create the new configuration with the given `theme`./// This is equivalent of calling `FrameConfig::new(ColorTheme::auto())`./// For details see [`ColorTheme::auto`]./// This is equivalent of calling `FrameConfig::new(ColorTheme::light())`./// For details see [`ColorTheme::light`]./// This is equivalent of calling `FrameConfig::new(ColorTheme::dark())`./// For details see [`ColorTheme::dark`].draw_headerbardraw_headerbar_bgrounded_headerbar_shapeget_margin_h_lp// returns horizontal margin, logical pointsRESIZE_HANDLE_SIZE/// The decoration's 'parts'.// XXX keep in sync with `Self;:new`.// Order is important. The lower the number, the earlier the part gets drawn.// Because the header can overlap other parts, we draw it last.hide_borders// These unwraps are guaranteed to succeed because the affected options are filled above// and then never emptied afterwards.side_heightfind_surfacesubsurfacesurface_rect/// Positioned relative to the main surface.input_rect/// Positioned relative to the local surface, aka. `surface_rect`./// `None` if it fully covers `surface_rect`.ResizeEdgeDOUBLE_CLICK_DURATION/// Time to register the next click as a double click./// The value is the same as the default in gtk4./// The surface local location inside the surface.last_normal_click/// The instant of the last click./// The state of the mouse input inside the decorations frame./// The normal click on decorations frame was made.alternate_click/// Alternative click on decorations frame was made./// The mouse moved inside the decorations frame./// The mouse left the decorations frame.PixmapRefPremultipliedColorU8SHADOW_SIZE// These values were generated from a screenshot of an libadwaita window using a script.// For more details see: https://github.com/PolyMeilex/sctk-adwaita/pull/43SHADOW_PARAMS_ACTIVESHADOW_PARAMS_INACTIVERenderedShadowside_drawedges_drawpixmapCachedPartpart_cacherendered// (scale, active) -> RenderedShadowShader// https://gitlab.gnome.org/GNOME/gtk/-/blob/1bf88f1d81043fd99740e2f91e56ade7ede7303b/gtk/gtkwindow.c#L165// https://gitlab.gnome.org/GNOME/gtk/-/blob/1bf88f1d81043fd99740e2f91e56ade7ede7303b/gtk/gtkwindow.c#L166inactive/// The color theme to use with the decorations frame./// Automatically choose between light & dark themes based on:/// * dbus org.freedesktop.portal.Settings///   <https://flatpak.github.io/xdg-desktop-portal/#gdbus-interface-org-freedesktop-portal-Settings>/// Predefined light variant, which aims to replecate Adwaita theme./// Predefined dark variant, which aims to replecate Adwaita-dark theme.headerbarbutton_idlebutton_hoverbutton_iconborder_colorfont_color/// The color map for various decorcation parts.headerbar_paintbutton_idle_paintbutton_hover_paintbutton_icon_paintborder_paintfont_preferenceFontPreferenceCANTARELLoriginal_px_sizeAbGlyphTitleTextupdate_scaleupdate_titleupdate_color/// Render returning the new `Pixmap`./// Simple single-line glyph layout.parse_font/// Parse the memmapped system font or fallback to built-in cantarell.font_file_matching/// Font-config without dynamically linked dependencies//! Title renderer using ab_glyph.//! Requires no dynamically linked dependencies.//! Can fallback to a embedded Cantarell-Regular.ttf font (SIL Open Font Licence v1.1)//! if the system font doesn't work.titlebar_font/// Query system for which font to use for window titles.//! System font configuration.crossfontGlyphKeyRasterizeRasterizedGlyphfont_keyFontKeyMetricsrasterizerCrossfontTitleTextupdate_metricsrerendercalc_widthDumbTitleTextpt_sizefrom_name_style_size/// Parse config string like `Cantarell 12`, `Cantarell Bold 11`, `Noto Serif CJK HK Bold 12`.pref_from_multi_name_variant_sizepref_from_name_variant_sizepref_from_name_sizepref_from_namepref_from_multi_name_styleab_glyph_renderer/// Information describes the "i=" field which provides textual information
/// about the session.
network_typeConnectionInformation/// ConnectionInformation defines the representation for the "c=" field
/// containing connection data.
/// Address describes a structured address token from within the "c=" field.
bandwidth_type/// Bandwidth describes an optional field which denotes the proposed bandwidth
/// to be used by the session or media.
/// EncryptionKey describes the "k=" which conveys encryption key information.
/// Attribute describes the "a=" field which represents the primary means for
/// extending SDP.
/// new constructs a new attribute
is_ice_candidate/// is_ice_candidate returns true if the attribute key equals "candidate".
CANONICAL_MARSHAL_SDPtest_unmarshal_marshaltest_marshalBASE_SDPSESSION_INFORMATION_SDPSESSION_INFORMATION_SDPLFONLY// https://tools.ietf.org/html/rfc4566#section-5// Parsers SHOULD be tolerant and also accept records terminated// with a single newline character.SESSION_INFORMATION_SDPEXTRA_CRLF// Other SDP parsers (e.g. one in VLC media player) allow// empty lines.URI_SDPEMAIL_ADDRESS_SDPPHONE_NUMBER_SDPSESSION_CONNECTION_INFORMATION_SDPSESSION_BANDWIDTH_SDPTIMING_SDPREPEAT_TIMES_SDP// Short hand time notation is converted into NTP timestamp format in// seconds. Because of that unittest comparisons will fail as the same time// will be expressed in different units.REPEAT_TIMES_SDPEXPECTEDREPEAT_TIMES_OVERFLOW_SDPREPEAT_TIMES_SDPEXTRA_CRLFTIME_ZONES_SDP// The expected value looks a bit different for the same reason as mentioned// above regarding RepeatTimes.TIME_ZONES_SDPEXPECTEDTIME_ZONES_SDP2TIME_ZONES_SDP2EXTRA_CRLFSESSION_ENCRYPTION_KEY_SDPSESSION_ENCRYPTION_KEY_SDPEXTRA_CRLFSESSION_ATTRIBUTES_SDPMEDIA_NAME_SDPMEDIA_NAME_SDPEXTRA_CRLFMEDIA_TITLE_SDPMEDIA_CONNECTION_INFORMATION_SDPMEDIA_CONNECTION_INFORMATION_SDPEXTRA_CRLFMEDIA_DESCRIPTION_OUT_OF_ORDER_SDPMEDIA_DESCRIPTION_OUT_OF_ORDER_SDPACTUALMEDIA_BANDWIDTH_SDPMEDIA_TRANSPORT_BANDWIDTH_SDPMEDIA_ENCRYPTION_KEY_SDPMEDIA_ENCRYPTION_KEY_SDPEXTRA_CRLFMEDIA_ATTRIBUTES_SDPCANONICAL_UNMARSHAL_SDPtest_unmarshal_repeat_timestest_unmarshal_repeat_times_overflowtest_unmarshal_time_zonestest_unmarshal_non_nil_address// SessionInformationSDPCROnly = "v=0\r" +// 	"o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5\r" +// 	"s=SDP Seminar\r"// 	"i=A Seminar on the session description protocol\r" +// 	"t=3034423619 3042462419\r"extmapEXT_MAP_VALUE_TRANSPORT_CC_KEY/// Constants for extmap keyEXT_MAP_VALUE_TRANSPORT_CC_URIext_map_urimedia_nameMediaName/// `m=<media> <port>/<number of ports> <proto> <fmt> ...`/// <https://tools.ietf.org/html/rfc4566#section-5.14>media_title/// `i=<session description>`/// <https://tools.ietf.org/html/rfc4566#section-5.4>connection_information/// `c=<nettype> <addrtype> <connection-address>`/// <https://tools.ietf.org/html/rfc4566#section-5.7>/// `b=<bwtype>:<bandwidth>`/// <https://tools.ietf.org/html/rfc4566#section-5.8>encryption_key/// `k=<method>`/// `k=<method>:<encryption key>`/// <https://tools.ietf.org/html/rfc4566#section-5.12>/// Attributes are the primary means for extending SDP.  Attributes may/// be defined to be used as "session-level" attributes, "media-level"/// attributes, or both.MediaDescription/// MediaDescription represents a media type./// * [RFC 4566 §5.14]/// [RFC 4566 §5.14]: https://tools.ietf.org/html/rfc4566#section-5.14/// Returns whether an attribute exists/// attribute returns the value of an attribute and if it existsnew_jsep_media_description/// new_jsep_media_description creates a new MediaName with/// some settings that are required by the JSEP spec.with_property_attribute/// with_property_attribute adds a property attribute 'a=key' to the media descriptionwith_value_attribute/// with_value_attribute adds a value attribute 'a=key:value' to the media descriptionwith_fingerprint/// with_fingerprint adds a fingerprint to the media descriptionwith_ice_credentials/// with_ice_credentials adds ICE credentials to the media description/// with_codec adds codec information to the media descriptionwith_media_source/// with_media_source adds media source information to the media descriptionwith_candidate/// with_candidate adds an ICE candidate to the media description/// Deprecated: use WithICECandidate insteadwith_extmapExtMapwith_transport_cc_extmap/// with_transport_cc_extmap adds an extmap to the media descriptionRangedPort/// RangedPort supports special format for the media field "m=" port value. If/// it may be necessary to specify multiple transport ports, the protocol allows/// to write it as: `<port>/<number of ports>` where number of ports is a an/// offsetting range.protos/// MediaName describes the "m=" field storage structure.test_attribute_missingtest_attribute_present_with_no_valuetest_attribute_present_with_valuedescription_testATTR_KEY_CANDIDATE/// Constants for SDP attributes used in JSEPATTR_KEY_END_OF_CANDIDATESATTR_KEY_IDENTITYATTR_KEY_GROUPATTR_KEY_SSRCATTR_KEY_SSRCGROUPATTR_KEY_MSIDATTR_KEY_MSID_SEMANTICATTR_KEY_CONNECTION_SETUPATTR_KEY_MIDATTR_KEY_ICELITEATTR_KEY_RTCPMUXATTR_KEY_RTCPRSIZEATTR_KEY_INACTIVEATTR_KEY_RECV_ONLYATTR_KEY_SEND_ONLYATTR_KEY_SEND_RECVATTR_KEY_EXT_MAPATTR_KEY_EXTMAP_ALLOW_MIXEDATTR_KEY_MAX_MESSAGE_SIZESEMANTIC_TOKEN_LIP_SYNCHRONIZATION/// Constants for semantic tokens used in JSEPSEMANTIC_TOKEN_FLOW_IDENTIFICATIONSEMANTIC_TOKEN_FORWARD_ERROR_CORRECTIONSEMANTIC_TOKEN_WEBRTC_MEDIA_STREAMS/// Version describes the value provided by the "v=" field which gives/// the version of the Session Description Protocol.session_versionunicast_address/// Origin defines the structure for the "o=" field which provides the/// originator of the session plus a session identifier and version number.SessionName/// SessionName describes a structured representations for the "s=" field/// and is the textual session name./// EmailAddress describes a structured representations for the "e=" line/// which specifies email contact information for the person responsible for/// the conference.PhoneNumber/// PhoneNumber describes a structured representations for the "p=" line/// specify phone contact information for the person responsible for the/// conference.adjustment_time/// TimeZone defines the structured object for "z=" line which describes/// repeated sessions scheduling.timingTiming/// `t=<start-time> <stop-time>`/// <https://tools.ietf.org/html/rfc4566#section-5.9>repeat_timesRepeatTime/// `r=<repeat interval> <active duration> <offsets from start-time>`/// <https://tools.ietf.org/html/rfc4566#section-5.10>TimeDescription/// TimeDescription describes "t=", "r=" fields of the session description/// which are used to specify the start and stop times for a session as well as/// repeat intervals and durations for the scheduled session.stop_time/// Timing defines the "t=" field's structured representation for the start and/// stop times./// RepeatTime describes the "r=" fields of the session description which/// represents the intervals and durations for repeated scheduled sessions./// `v=0`/// <https://tools.ietf.org/html/rfc4566#section-5.1>/// `o=<username> <sess-id> <sess-version> <nettype> <addrtype> <unicast-address>`/// <https://tools.ietf.org/html/rfc4566#section-5.2>session_name/// `s=<session name>`/// <https://tools.ietf.org/html/rfc4566#section-5.3>session_information/// `u=<uri>`/// <https://tools.ietf.org/html/rfc4566#section-5.5>email_address/// `e=<email-address>`/// <https://tools.ietf.org/html/rfc4566#section-5.6>phone_number/// `p=<phone-number>`time_descriptionstime_zones/// `z=<adjustment time> <offset> <adjustment time> <offset> ...`/// <https://tools.ietf.org/html/rfc4566#section-5.11>/// `a=<attribute>`/// `a=<attribute>:<value>`/// <https://tools.ietf.org/html/rfc4566#section-5.13>media_descriptionsSessionDescription/// SessionDescription is a a well-defined format for conveying sufficient/// information to discover and participate in a multimedia session.new_jsep_session_description/// API to match draft-ietf-rtcweb-jsep/// Move to webrtc or its own package?/// NewJSEPSessionDescription creates a new SessionDescription with/// WithPropertyAttribute adds a property attribute 'a=key' to the session description/// WithValueAttribute adds a value attribute 'a=key:value' to the session description/// WithFingerprint adds a fingerprint to the session descriptionwith_media/// WithMedia adds a media description to the session descriptionbuild_codec_mapget_codec_for_payload_type/// get_codec_for_payload_type scans the SessionDescription for the given payload type and returns the codecget_payload_type_for_codec/// get_payload_type_for_codec scans the SessionDescription for a codec that matches the provided codec/// as closely as possible and returns its payload type/// Attribute returns the value of an attribute and if it exists/// Marshal takes a SDP struct to text/// <https://tools.ietf.org/html/rfc4566#section-5>/// Session description///    v=  (protocol version)///    o=  (originator and session identifier)///    s=  (session name)///    i=* (session information)///    u=* (URI of description)///    e=* (email address)///    p=* (phone number)///    c=* (connection information -- not required if included in///         all media)///    b=* (zero or more bandwidth information lines)///    One or more time descriptions ("t=" and "r=" lines; see below)///    z=* (time zone adjustments)///    k=* (encryption key)///    a=* (zero or more session attribute lines)///    Zero or more media descriptions/// Time description///    t=  (time the session is active)///    r=* (zero or more repeat times)/// Media description, if present///    m=  (media name and transport address)///    i=* (media title)///    c=* (connection information -- optional if included at///         session level)///    a=* (zero or more media attribute lines)/// Unmarshal is the primary function that deserializes the session description/// message and stores it inside of a structured SessionDescription object./// The States Transition Table describes the computation flow between functions/// (namely s1, s2, s3, ...) for a parsing procedure that complies with the/// specifications laid out by the rfc4566#section-5 as well as by JavaScript/// Session Establishment Protocol draft. Links:///     <https://tools.ietf.org/html/rfc4566#section-5>///     <https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-24>/// In order to generate the following state table and draw subsequent/// deterministic finite-state automota ("DFA") the following regex was used to/// derive the DFA:///    vosi?u?e?p?c?b*(tr*)+z?k?a*(mi?c?b*k?a*)*/// possible place and state to exit:///                    **   * * *  ** * * * *///                    99   1 1 1  11 1 1 1 1///                         3 1 1  26 5 5 4 4/// Please pay close attention to the `k`, and `a` parsing states. In the table/// below in order to distinguish between the states belonging to the media/// description as opposed to the session description, the states are marked/// with an asterisk ("a*", "k*")./// +--------+----+-------+----+-----+----+-----+---+----+----+---+---+-----+---+---+----+---+----+/// | STATES | a* | a*,k* | a  | a,k | b  | b,c | e | i  | m  | o | p | r,t | s | t | u  | v | z  |/// |   s1   |    |       |    |     |    |     |   |    |    |   |   |     |   |   |    | 2 |    |/// |   s2   |    |       |    |     |    |     |   |    |    | 3 |   |     |   |   |    |   |    |/// |   s3   |    |       |    |     |    |     |   |    |    |   |   |     | 4 |   |    |   |    |/// |   s4   |    |       |    |     |    |   5 | 6 |  7 |    |   | 8 |     |   | 9 | 10 |   |    |/// |   s5   |    |       |    |     |  5 |     |   |    |    |   |   |     |   | 9 |    |   |    |/// |   s6   |    |       |    |     |    |   5 |   |    |    |   | 8 |     |   | 9 |    |   |    |/// |   s7   |    |       |    |     |    |   5 | 6 |    |    |   | 8 |     |   | 9 | 10 |   |    |/// |   s8   |    |       |    |     |    |   5 |   |    |    |   |   |     |   | 9 |    |   |    |/// |   s9   |    |       |    |  11 |    |     |   |    | 12 |   |   |   9 |   |   |    |   | 13 |/// |   s10  |    |       |    |     |    |   5 | 6 |    |    |   | 8 |     |   | 9 |    |   |    |/// |   s11  |    |       | 11 |     |    |     |   |    | 12 |   |   |     |   |   |    |   |    |/// |   s12  |    |    14 |    |     |    |  15 |   | 16 | 12 |   |   |     |   |   |    |   |    |/// |   s13  |    |       |    |  11 |    |     |   |    | 12 |   |   |     |   |   |    |   |    |/// |   s14  | 14 |       |    |     |    |     |   |    | 12 |   |   |     |   |   |    |   |    |/// |   s15  |    |    14 |    |     | 15 |     |   |    | 12 |   |   |     |   |   |    |   |    |/// |   s16  |    |    14 |    |     |    |  15 |   |    | 12 |   |   |     |   |   |    |   |    |/// Reset cleans the SessionDescription, and sets all fields back to their default valuess12s13s14s15unmarshal_protocol_versionunmarshal_originunmarshal_session_nameunmarshal_session_informationunmarshal_uriunmarshal_emailunmarshal_phoneunmarshal_session_connection_informationunmarshal_connection_informationunmarshal_session_bandwidthunmarshal_bandwidthunmarshal_timingunmarshal_repeat_timesunmarshal_time_zonesunmarshal_session_encryption_keyunmarshal_session_attributeunmarshal_media_descriptionunmarshal_media_titleunmarshal_media_connection_informationunmarshal_media_bandwidthunmarshal_media_encryption_keyunmarshal_media_attributeparse_time_unitstest_new_directiontest_direction_stringdirection_testSendRecv/// Direction::SendRecv is for bidirectional communication
SendOnly/// Direction::SendOnly is for outgoing communication
RecvOnly/// Direction::RecvOnly is for incoming communication
/// Direction::Inactive is for no communication
/// Direction is a marker for transmission direction of an endpoint
DIRECTION_SEND_RECV_STRDIRECTION_SEND_ONLY_STRDIRECTION_RECV_ONLY_STRDIRECTION_INACTIVE_STRDIRECTION_UNSPECIFIED_STR/// new defines a procedure for creating a new direction from a raw string.
SubstringMissingWhitespaceMissingColonPayloadTypeNotFoundSdpInvalidSyntaxSdpInvalidValueSdpEmptyTimeDescriptionParseUrlParseExtMapEND_LINEATTRIBUTE_KEYEXAMPLE_ATTR_EXTMAP1EXAMPLE_ATTR_EXTMAP2FAILING_ATTR_EXTMAP1FAILING_ATTR_EXTMAP2test_extmaptest_transport_cc_extmapextmap_testDEF_EXT_MAP_VALUE_ABS_SEND_TIME/// Default ext valuesDEF_EXT_MAP_VALUE_TRANSPORT_CCDEF_EXT_MAP_VALUE_SDES_MIDDEF_EXT_MAP_VALUE_SDES_RTP_STREAM_IDABS_SEND_TIME_URISDES_MID_URISDES_RTP_STREAM_ID_URISDES_REPAIR_RTP_STREAM_ID_URIAUDIO_LEVEL_URIVIDEO_ORIENTATION_URIext_attr/// ExtMap represents the activation of a single RTP header extension/// converts this object to an Attribute/// unmarshal creates an Extmap from a string/// marshal creates a string from an ExtMapStateFnTyperead_typewrite_key_valuewrite_key_slice_of_valuesutil_testConnectionRole/// ConnectionRoleActive indicates the endpoint will initiate an outgoing connection./// ConnectionRolePassive indicates the endpoint will accept an incoming connection.Actpass/// ConnectionRoleActpass indicates the endpoint is willing to accept an incoming connection or to initiate an outgoing connection.Holdconn/// ConnectionRoleHoldconn indicates the endpoint does not want the connection to be established for the time being./// ConnectionRole indicates which of the end points should initiate the connection establishmentCONNECTION_ROLE_ACTIVE_STRCONNECTION_ROLE_PASSIVE_STRCONNECTION_ROLE_ACTPASS_STRCONNECTION_ROLE_HOLDCONN_STRnew_session_id/// https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-26#section-5.2.1/// Session ID is recommended to be constructed by generating a 64-bit/// quantity with the highest bit set to zero and the remaining 63-bits/// being cryptographically random.encoding_parametersfmtp// Codec represents a codecparse_rtpmapparse_fmtpparse_rtcp_fbmerge_codecsequivalent_fmtpcodecs_matchget_test_session_descriptiontest_get_payload_type_for_vp8test_get_codec_for_payload_typetest_new_session_id/// Result type with `sec1` crate's [`Error`] type./// Cryptographic errors./// These can be used by EC implementations to signal that a key is/// invalid for cryptographic reasons. This means the document parsed/// correctly, but one of the values contained within was invalid, e.g./// a number expected to be a prime was not a prime./// PKCS#8 errors.PointEncoding/// Errors relating to the `Elliptic-Curve-Point-to-Octet-String` or/// `Octet-String-to-Elliptic-Curve-Point` encodings./// Version errorsDecodeEcPrivateKeyEncodeEcPrivateKey/// Algorithm [`ObjectIdentifier`] for elliptic curve public key cryptography/// (`id-ecPublicKey`).//! When the `serde` feature of this crate is enabled, the [`EncodedPoint`]//! type receives impls of [`serde::Serialize`] and [`serde::Deserialize`].//! Additionally, when both the `alloc` and `serde` features are enabled, the//! serializers/deserializers will autodetect if a "human friendly" textual//! encoding is being used, and if so encode the points as hexadecimal./// Elliptic curve named by a particular OID./// > namedCurve identifies all the required values for a particular/// > set of elliptic curve domain parameters to be represented by an/// > object identifier./// Elliptic curve parameters as described in/// [RFC5480 Section 2.1.1](https://datatracker.ietf.org/doc/html/rfc5480#section-2.1.1):/// ECParameters ::= CHOICE {///   namedCurve         OBJECT IDENTIFIER///   -- implicitCurve   NULL///   -- specifiedCurve  SpecifiedECDomain///   -- implicitCurve and specifiedCurve MUST NOT be used in PKIX.///   -- Details for SpecifiedECDomain can be found in [X9.62].///   -- Any future additions to this CHOICE should be coordinated///   -- with ANSI X9./// Obtain the `namedCurve` OID.U66/// Size of a compressed point for the given elliptic curve when encoded/// using the SEC1 `Elliptic-Curve-Point-to-Octet-String` algorithm/// (including leading `0x02` or `0x03` tag byte)./// Size of an uncompressed point for the given elliptic curve when encoded/// (including leading `0x04` tag byte).UntaggedPointSize/// Size of an untagged point for given elliptic curve, i.e. size of two/// serialized base field elements./// Trait for supported modulus sizes which precomputes the typenums for/// various point encodings so they don't need to be included as bounds.// TODO(tarcieri): replace this all with const generic expressions.impl_modulus_size/// SEC1 encoded curve point./// This type is an enum over the compressed and uncompressed encodings,/// useful for cases where either encoding can be supported, or conversions/// between the two forms./// Decode elliptic curve point (compressed or uncompressed) from thefrom_untagged_bytes/// Decode elliptic curve point from raw uncompressed coordinates, i.e./// encoded as the concatenated `x || y` coordinates with no leading SEC1/// tag byte (which would otherwise be `0x04` for an uncompressed point).from_affine_coordinates/// Encode an elliptic curve point from big endian serialized coordinates/// (with optional point compression)/// Return [`EncodedPoint`] representing the additive identity/// (a.k.a. point at infinity)/// Get the length of the encoded point in bytes/// Get byte slice containing the serialized [`EncodedPoint`]./// Get boxed byte slice containing the serialized [`EncodedPoint`]is_compact/// Is this [`EncodedPoint`] compact?is_compressed/// Is this [`EncodedPoint`] compressed?/// Is this [`EncodedPoint`] the additive identity? (a.k.a. point at infinity)/// Compress this [`EncodedPoint`], returning a new [`EncodedPoint`]./// Get the SEC1 tag for this [`EncodedPoint`]/// Get the [`Coordinates`] for this [`EncodedPoint`]./// Get the x-coordinate for this [`EncodedPoint`]./// Returns `None` if this point is the identity point./// Get the y-coordinate for this [`EncodedPoint`]./// Returns `None` if this point is compressed or the identity point./// Decode a SEC1-encoded point from hexadecimal./// Identity point (a.k.a. point at infinity)Compact/// Compact curve point/// Is the y-coordinate odd?/// Compressed curve point/// Uncompressed curve point/// Enum representing the coordinates of either compressed or uncompressed/// SEC1-encoded elliptic curve points./// Get the tag octet needed to encode this set of [`Coordinates`]/// Identity point (`0x00`)CompressedEvenY/// Compressed point with even y-coordinate (`0x02`)CompressedOddY/// Compressed point with odd y-coordinate (`0x03`)/// Uncompressed point (`0x04`)/// Compact point (`0x05`)/// Tag byte used by the `Elliptic-Curve-Point-to-Octet-String` encoding./// Parse a tag value from a byte/// Is this point compact?/// Is this point compressed?message_len/// Compute the expected total message length for a message prefixed/// with this tag (including the tag byte), given the field element size/// (in bytes) for a particular elliptic curve.compress_y/// Compress the given y-coordinate, returning a `Tag::Compressed*` valueIDENTITY_BYTES/// Identity pointUNCOMPRESSED_BYTES/// Example uncompressed pointCOMPRESSED_BYTES/// Example compressed point: `UNCOMPRESSED_BYTES` after point compressiondecode_compressed_pointdecode_uncompressed_pointdecode_identitydecode_invalid_tagdecode_truncated_pointfrom_untagged_point//! Support for the SEC1 `Elliptic-Curve-Point-to-Octet-String` and//! `Octet-String-to-Elliptic-Curve-Point` encoding algorithms.//! Described in [SEC1: Elliptic Curve Cryptography] (Version 2.0) section 2.3.3 (p.10).//! [SEC1: Elliptic Curve Cryptography]: https://www.secg.org/sec1-v2.pdf/// `ECPrivateKey` version./// From [RFC5913 Section 3]:/// > version specifies the syntax version number of the elliptic curve/// > private key structure.  For this version of the document, it SHALL/// > be set to ecPrivkeyVer1, which is of type INTEGER and whose value/// > is one (1)./// [RFC5915 Section 3]: https://datatracker.ietf.org/doc/html/rfc5915#section-3EC_PARAMETERS_TAG/// Context-specific tag number for the elliptic curve parameters./// Elliptic curve parameters./// SEC1 elliptic curve private key./// Described in [SEC1: Elliptic Curve Cryptography (Version 2.0)]/// Appendix C.4 (p.108) and also [RFC5915 Section 3]:/// ECPrivateKey ::= SEQUENCE {///   version        INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),///   privateKey     OCTET STRING,///   parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,///   publicKey  [1] BIT STRING OPTIONAL/// When encoded as PEM (text), keys in this format begin with the following:/// [SEC1: Elliptic Curve Cryptography (Version 2.0)]: https://www.secg.org/sec1-v2.pdfcontext_specific_parameterscontext_specific_public_key//! SEC1 elliptic curve private key support.//! Support for ASN.1 DER-encoded elliptic curve private keys as described in//! SEC1: Elliptic Curve Cryptography (Version 2.0) Appendix C.4 (p.108):/// Deserialize SEC1 private key from ASN.1 DER-encoded data/// Deserialize SEC1-encoded private key from PEM./// Keys in this format begin with the following:read_sec1_der_file/// Load SEC1 private key from an ASN.1 DER-encoded file on the localread_sec1_pem_file/// Load SEC1 private key from a PEM-encoded file on the local filesystem./// Parse an [`EcPrivateKey`] from a SEC1-encoded document./// Serialize a [`SecretDocument`] containing a SEC1-encoded private key./// Serialize this private key as PEM-encoded SEC1 with the given [`LineEnding`]./// To use the OS's native line endings, pass `Default::default()`.write_sec1_der_file/// Write ASN.1 DER-encoded SEC1 private key to the given path.write_sec1_pem_file/// Serialize a [`EcPrivateKey`] to a SEC1 encoded document.//! Traits for parsing objects from SEC1 encoded documentsBuildMetadataPrereleaseUnexpectedCharUnexpectedCharAfterExpectedCommaFoundLeadingZeroEmptySegmentWildcardNotTheOnlyComparatorUnexpectedAfterWildcardExcessiveComparatorsQuotedCharmatches_reqmatches_comparatormatches_implmatches_exactmatches_greatermatches_lessmatches_tildematches_caretpre_is_compatiblePTR_BYTESTAIL_BYTES// If pointers are already 8 bytes or bigger, then 0. If pointers are smaller// than 8 bytes, then Identifier will contain a byte array to raise its size up// to 8 bytes total.// SAFETY: string must be ASCII and not contain \0 bytes.is_empty_or_inlineptr_to_repr// We use heap pointers that are 2-byte aligned, meaning they have an// insignificant 0 in the least significant bit. We take advantage of that// unneeded bit to rotate a 1 into the most significant bit to make the repr// distinguishable from ASCII bytes.repr_to_ptr// Shift out the 1 previously placed into the most significant bit of the least// significant byte. Shift in a low 0 bit to reconstruct the original 2-byte// aligned pointer.repr_to_ptr_mutinline_len// Compute the length of the inline string, assuming the argument is in short// string representation. Short strings are stored as 1 to 8 nonzero ASCII// bytes, followed by \0 padding for the remaining bytes.// SAFETY: the identifier must indeed be in the inline representation.inline_as_str// SAFETY: repr must be in the inline representation, i.e. at least 1 and at// most 8 nonzero ASCII bytes padded on the end with \0 bytes.// Decode varint. Varints consist of between one and eight base-128 digits, each// of which is stored in a byte with most significant bit set. Adjacent to the// varint in memory there is guaranteed to be at least 9 ASCII bytes, each of// which has an unset most significant bit.// SAFETY: ptr must be one of our own heap allocations, with the varint header// already written.ptr_as_str// SAFETY: repr must be in the heap allocated representation, with varint header// and string contents already written.bytes_for_varint// Number of base-128 digits required for the varint representation of a length.// This module implements Identifier, a short-optimized string allowed to// contain only the ASCII characters hyphen, dot, 0-9, A-Z, a-z.// As of mid-2021, the distribution of pre-release lengths on crates.io is://     length  count         length  count         length  count//        0  355929            11      81            24       2//        1     208            12      48            25       6//        2     236            13      55            26      10//        3    1909            14      25            27       4//        4    1284            15      15            28       1//        5    1742            16      35            30       1//        6    3440            17       9            31       5//        7    5624            18       6            32       1//        8    1321            19      12            36       2//        9     179            20       2            37     379//       10      65            23      11// and the distribution of build metadata lengths is://        0  364445             8    7725            18       1//        1      72             9      16            19       1//        2       7            10      85            20       1//        3      28            11      17            22       4//        4       9            12      10            26       1//        5      68            13       9            27       1//        6      73            14      10            40       5//        7      53            15       6// Therefore it really behooves us to be able to use the entire 8 bytes of a// pointer for inline storage. For both pre-release and build metadata there are// vastly more strings with length exactly 8 bytes than the sum over all lengths// longer than 8 bytes.// To differentiate the inline representation from the heap allocated long// representation, we'll allocate heap pointers with 2-byte alignment so that// they are guaranteed to have an unset least significant bit. Then in the repr// we store for pointers, we rotate a 1 into the most significant bit of the// most significant byte, which is never set for an ASCII byte.// Inline repr://     0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx// Heap allocated repr://     1ppppppp pppppppp pppppppp pppppppp pppppppp pppppppp pppppppp pppppppp 0//     ^ most significant bit   least significant bit of orig ptr, rotated out ^// Since the most significant bit doubles as a sign bit for the similarly sized// signed integer type, the CPU has an efficient instruction for inspecting it,// meaning we can differentiate between an inline repr and a heap allocated repr// in one instruction. Effectively an inline repr always looks like a positive// i64 while a heap allocated repr always looks like a negative i64.// For the inline repr, we store \0 padding on the end of the stored characters,// and thus the string length is readily determined efficiently by a cttz (count// trailing zeros) or bsf (bit scan forward) instruction.// For the heap allocated repr, the length is encoded as a base-128 varint at// the head of the allocation.// Empty strings are stored as an all-1 bit pattern, corresponding to -1i64.// Consequently the all-0 bit pattern is never a legal representation in any// repr, leaving it available as a niche for downstream code. For example this// allows size_of::<Version>() == size_of::<Option<Version>>().backport// https://github.com/rust-lang/rust-clippy/issues/7324/// **SemVer version** as defined by <https://semver.org>./// - The major, minor, and patch numbers may be any integer 0 through u64::MAX.///   When representing a SemVer version as a string, each number is written as///   a base 10 integer. For example, `1.0.119`./// - Leading zeros are forbidden in those positions. For example `1.01.00` is///   invalid as a SemVer version./// - The pre-release identifier, if present, must conform to the syntax///   documented for [`Prerelease`]./// - The build metadata, if present, must conform to the syntax documented for///   [`BuildMetadata`]./// - Whitespace is not allowed anywhere in the version./// # Total ordering/// Given any two SemVer versions, one is less than, greater than, or equal to/// the other. Versions may be compared against one another using Rust's usual/// comparison operators./// - The major, minor, and patch number are compared numerically from left to/// right, lexicographically ordered as a 3-tuple of integers. So for example/// version `1.5.0` is less than version `1.19.0`, despite the fact that/// "1.19.0" &lt; "1.5.0" as ASCIIbetically compared strings and 1.19 &lt; 1.5/// as real numbers./// - When major, minor, and patch are equal, a pre-release version is///   considered less than the ordinary release:&ensp;version `1.0.0-alpha.1` is///   less than version `1.0.0`./// - Two pre-releases of the same major, minor, patch are compared by///   lexicographic ordering of dot-separated components of the pre-release///   string.///   - Identifiers consisting of only digits are compared///     numerically:&ensp;`1.0.0-pre.8` is less than `1.0.0-pre.12`.///   - Identifiers that contain a letter or hyphen are compared in ASCII sort///     order:&ensp;`1.0.0-pre12` is less than `1.0.0-pre8`.///   - Any numeric identifier is always less than any non-numeric///     identifier:&ensp;`1.0.0-pre.1` is less than `1.0.0-pre.x`./// Example:&ensp;`1.0.0-alpha`&ensp;&lt;&ensp;`1.0.0-alpha.1`&ensp;&lt;&ensp;`1.0.0-alpha.beta`&ensp;&lt;&ensp;`1.0.0-beta`&ensp;&lt;&ensp;`1.0.0-beta.2`&ensp;&lt;&ensp;`1.0.0-beta.11`&ensp;&lt;&ensp;`1.0.0-rc.1`&ensp;&lt;&ensp;`1.0.0`comparators/// **SemVer version requirement** describing the intersection of some version/// comparators, such as `>=1.2.3, <1.8`./// - Either `*` (meaning "any"), or one or more comma-separated comparators./// - A [`Comparator`] is an operator ([`Op`]) and a partial version, separated///   by optional whitespace. For example `>=1.0.0` or `>=1.0`./// - Build metadata is syntactically permitted on the partial versions, but is///   completely ignored, as it's never relevant to whether any comparator///   matches a particular version./// - Whitespace is permitted around commas and around operators. Whitespace is///   not permitted within a partial version, i.e. anywhere between the major///   version number and its minor, patch, pre-release, or build metadata./// Patch is only allowed if minor is Some./// Non-empty pre-release is only allowed if patch is Some./// A pair of comparison operator and partial version, such as `>=1.2`. Forms/// one piece of a VersionReq.GreaterEqTildeCaretWildcard/// SemVer comparison operator: `=`, `>`, `>=`, `<`, `<=`, `~`, `^`, `*`./// # Op::Exact/// - &ensp;**`=I.J.K`**&emsp;&mdash;&emsp;exactly the version I.J.K/// - &ensp;**`=I.J`**&emsp;&mdash;&emsp;equivalent to `>=I.J.0, <I.(J+1).0`/// - &ensp;**`=I`**&emsp;&mdash;&emsp;equivalent to `>=I.0.0, <(I+1).0.0`/// # Op::Greater/// - &ensp;**`>I.J.K`**/// - &ensp;**`>I.J`**&emsp;&mdash;&emsp;equivalent to `>=I.(J+1).0`/// - &ensp;**`>I`**&emsp;&mdash;&emsp;equivalent to `>=(I+1).0.0`/// # Op::GreaterEq/// - &ensp;**`>=I.J.K`**/// - &ensp;**`>=I.J`**&emsp;&mdash;&emsp;equivalent to `>=I.J.0`/// - &ensp;**`>=I`**&emsp;&mdash;&emsp;equivalent to `>=I.0.0`/// # Op::Less/// - &ensp;**`<I.J.K`**/// - &ensp;**`<I.J`**&emsp;&mdash;&emsp;equivalent to `<I.J.0`/// - &ensp;**`<I`**&emsp;&mdash;&emsp;equivalent to `<I.0.0`/// # Op::LessEq/// - &ensp;**`<=I.J.K`**/// - &ensp;**`<=I.J`**&emsp;&mdash;&emsp;equivalent to `<I.(J+1).0`/// - &ensp;**`<=I`**&emsp;&mdash;&emsp;equivalent to `<(I+1).0.0`/// # Op::Tilde&emsp;("patch" updates)/// *Tilde requirements allow the **patch** part of the semver version (the third number) to increase.*/// - &ensp;**`~I.J.K`**&emsp;&mdash;&emsp;equivalent to `>=I.J.K, <I.(J+1).0`/// - &ensp;**`~I.J`**&emsp;&mdash;&emsp;equivalent to `=I.J`/// - &ensp;**`~I`**&emsp;&mdash;&emsp;equivalent to `=I`/// # Op::Caret&emsp;("compatible" updates)/// *Caret requirements allow parts that are **right of the first nonzero** part of the semver version to increase.*/// - &ensp;**`^I.J.K`**&ensp;(for I\>0)&emsp;&mdash;&emsp;equivalent to `>=I.J.K, <(I+1).0.0`/// - &ensp;**`^0.J.K`**&ensp;(for J\>0)&emsp;&mdash;&emsp;equivalent to `>=0.J.K, <0.(J+1).0`/// - &ensp;**`^0.0.K`**&emsp;&mdash;&emsp;equivalent to `=0.0.K`/// - &ensp;**`^I.J`**&ensp;(for I\>0 or J\>0)&emsp;&mdash;&emsp;equivalent to `^I.J.0`/// - &ensp;**`^0.0`**&emsp;&mdash;&emsp;equivalent to `=0.0`/// - &ensp;**`^I`**&emsp;&mdash;&emsp;equivalent to `=I`/// # Op::Wildcard/// - &ensp;**`I.J.*`**&emsp;&mdash;&emsp;equivalent to `=I.J`/// - &ensp;**`I.*`**&ensp;or&ensp;**`I.*.*`**&emsp;&mdash;&emsp;equivalent to `=I`/// Optional pre-release identifier on a version string. This comes after `-` in/// a SemVer version, like `1.0.0-alpha.1`/// Some real world pre-release idioms drawn from crates.io:/// - **[mio]** <code>0.7.0-<b>alpha.1</b></code> &mdash; the most common style///   for numbering pre-releases./// - **[pest]** <code>1.0.0-<b>beta.8</b></code>,&ensp;<code>1.0.0-<b>rc.0</b></code>///   &mdash; this crate makes a distinction between betas and release///   candidates./// - **[sassers]** <code>0.11.0-<b>shitshow</b></code> &mdash; ???./// - **[atomic-utils]** <code>0.0.0-<b>reserved</b></code> &mdash; a squatted///   crate name./// [mio]: https://crates.io/crates/mio/// [pest]: https://crates.io/crates/pest/// [atomic-utils]: https://crates.io/crates/atomic-utils/// [sassers]: https://crates.io/crates/sassers/// *Tip:* Be aware that if you are planning to number your own pre-releases,/// you should prefer to separate the numeric part from any non-numeric/// identifiers by using a dot in between. That is, prefer pre-releases/// `alpha.1`, `alpha.2`, etc rather than `alpha1`, `alpha2` etc. The SemVer/// spec's rule for pre-release precedence has special treatment of numeric/// components in the pre-release string, but only if there are no non-digit/// characters in the same dot-separated component. So you'd have `alpha.2` &lt;/// `alpha.11` as intended, but `alpha11` &lt; `alpha2`./// Pre-release strings are a series of dot separated identifiers immediately/// following the patch version. Identifiers must comprise only ASCII/// alphanumerics and hyphens: `0-9`, `A-Z`, `a-z`, `-`. Identifiers must not be/// empty. Numeric identifiers must not include leading zeros./// Pre-releases have a total order defined by the SemVer spec. It uses/// lexicographic ordering of dot-separated components. Identifiers consisting/// of only digits are compared numerically. Otherwise, identifiers are compared/// in ASCII sort order. Any numeric identifier is always less than any/// non-numeric identifier./// Example:&ensp;`alpha`&ensp;&lt;&ensp;`alpha.85`&ensp;&lt;&ensp;`alpha.90`&ensp;&lt;&ensp;`alpha.200`&ensp;&lt;&ensp;`alpha.0a`&ensp;&lt;&ensp;`alpha.1a0`&ensp;&lt;&ensp;`alpha.a`&ensp;&lt;&ensp;`beta`/// Optional build metadata identifier. This comes after `+` in a SemVer/// version, as in `0.8.1+zstd.1.5.0`./// Some real world build metadata idioms drawn from crates.io:/// - **[libgit2-sys]** <code>0.12.20+<b>1.1.0</b></code> &mdash; for this///   crate, the build metadata indicates the version of the C libgit2 library///   that the Rust crate is built against./// - **[mashup]** <code>0.1.13+<b>deprecated</b></code> &mdash; just the word///   "deprecated" for a crate that has been superseded by another. Eventually///   people will take notice of this in Cargo's build output where it lists the///   crates being compiled./// - **[google-bigquery2]** <code>2.0.4+<b>20210327</b></code> &mdash; this///   library is automatically generated from an official API schema, and the///   build metadata indicates the date on which that schema was last captured./// - **[fbthrift-git]** <code>0.0.6+<b>c7fcc0e</b></code> &mdash; this crate is///   published from snapshots of a big company monorepo. In monorepo///   development, there is no concept of versions, and all downstream code is///   just updated atomically in the same commit that breaking changes to a///   library are landed. Therefore for crates.io purposes, every published///   version must be assumed to be incompatible with the previous. The build///   metadata provides the source control hash of the snapshotted code./// [libgit2-sys]: https://crates.io/crates/libgit2-sys/// [mashup]: https://crates.io/crates/mashup/// [google-bigquery2]: https://crates.io/crates/google-bigquery2/// [fbthrift-git]: https://crates.io/crates/fbthrift-git/// Build metadata is a series of dot separated identifiers immediately/// following the patch or pre-release version. Identifiers must comprise only/// ASCII alphanumerics and hyphens: `0-9`, `A-Z`, `a-z`, `-`. Identifiers must/// not be empty. Leading zeros *are* allowed, unlike any other place in the/// SemVer grammar./// Build metadata is ignored in evaluating `VersionReq`; it plays no role in/// whether a `Version` matches any one of the comparison operators./// However for comparing build metadatas among one another, they do have a/// total order which is determined by lexicographic ordering of dot-separated/// components. Identifiers consisting of only digits are compared numerically./// Otherwise, identifiers are compared in ASCII sort order. Any numeric/// identifier is always less than any non-numeric identifier./// Example:&ensp;`demo`&ensp;&lt;&ensp;`demo.85`&ensp;&lt;&ensp;`demo.90`&ensp;&lt;&ensp;`demo.090`&ensp;&lt;&ensp;`demo.200`&ensp;&lt;&ensp;`demo.1a0`&ensp;&lt;&ensp;`demo.a`&ensp;&lt;&ensp;`memo`/// Create `Version` with an empty pre-release and build metadata./// Equivalent to:/// # use semver::{BuildMetadata, Prerelease, Version};/// # const fn new(major: u64, minor: u64, patch: u64) -> Version {/// Version {///     major,///     minor,///     patch,///     pre: Prerelease::EMPTY,///     build: BuildMetadata::EMPTY,/// Create `Version` by parsing from string representation./// Possible reasons for the parse to fail include:/// - `1.0` &mdash; too few numeric components. A SemVer version must have///   exactly three. If you are looking at something that has fewer than///   three numbers in it, it's possible it is a `VersionReq` instead (with///   an implicit default `^` comparison operator)./// - `1.0.01` &mdash; a numeric component has a leading zero./// - `1.0.unknown` &mdash; unexpected character in one of the components./// - `1.0.0-` or `1.0.0+` &mdash; the pre-release or build metadata are///   indicated present but empty./// - `1.0.0-alpha_123` &mdash; pre-release or build metadata have something///   outside the allowed characters, which are `0-9`, `A-Z`, `a-z`, `-`,///   and `.` (dot)./// - `23456789999999999999.0.0` &mdash; overflow of a u64.cmp_precedence/// Compare the major, minor, patch, and pre-release value of two versions,/// disregarding build metadata. Versions that differ only in build metadata/// are considered equal. This comparison is what the SemVer spec refers to/// as "precedence"./// use semver::Version;/// let mut versions = [///     "1.20.0+c144a98".parse::<Version>().unwrap(),///     "1.20.0".parse().unwrap(),///     "1.0.0".parse().unwrap(),///     "1.0.0-alpha".parse().unwrap(),///     "1.20.0+bc17664".parse().unwrap(),/// // This is a stable sort, so it preserves the relative order of equal/// // elements. The three 1.20.0 versions differ only in build metadata so/// // they are not reordered relative to one another./// versions.sort_by(Version::cmp_precedence);/// assert_eq!(versions, [///     "1.20.0+c144a98".parse().unwrap(),/// // Totally order the versions, including comparing the build metadata./// versions.sort();STAR/// A `VersionReq` with no constraint on the version numbers it matches./// Equivalent to `VersionReq::parse("*").unwrap()`./// In terms of comparators this is equivalent to `>=0.0.0`./// Counterintuitively a `*` VersionReq does not match every possible/// version number. In particular, in order for *any* `VersionReq` to match/// a pre-release version, the `VersionReq` must contain at least one/// `Comparator` that has an explicit major, minor, and patch version/// identical to the pre-release being matched, and that has a nonempty/// pre-release component. Since `*` is not written with an explicit major,/// minor, and patch version, and does not contain a nonempty pre-release/// component, it does not match any pre-release versions.// rustc <1.39/// Create `VersionReq` by parsing from string representation./// - `>a.b` &mdash; unexpected characters in the partial version./// - `@1.0.0` &mdash; unrecognized comparison operator./// - `^1.0.0, ` &mdash; unexpected end of input./// - `>=1.0 <2.0` &mdash; missing comma between comparators./// - `*.*` &mdash; unsupported wildcard syntax./// Evaluate whether the given `Version` satisfies the version requirement/// described by `self`./// The default VersionReq is the same as [`VersionReq::STAR`].//! [![github]](https://github.com/dtolnay/semver)&ensp;[![crates-io]](https://crates.io/crates/semver)&ensp;[![docs-rs]](https://docs.rs/semver)//! A parser and evaluator for Cargo's flavor of Semantic Versioning.//! Semantic Versioning (see <https://semver.org>) is a guideline for how//! version numbers are assigned and incremented. It is widely followed within//! the Cargo/crates.io ecosystem for Rust.//! use semver::{BuildMetadata, Prerelease, Version, VersionReq};//!     let req = VersionReq::parse(">=1.2.3, <1.8.0").unwrap();//!     // Check whether this requirement matches version 1.2.3-alpha.1 (no)//!     let version = Version {//!         major: 1,//!         minor: 2,//!         patch: 3,//!         pre: Prerelease::new("alpha.1").unwrap(),//!         build: BuildMetadata::EMPTY,//!     assert!(!req.matches(&version));//!     // Check whether it matches 1.3.0 (yes it does)//!     let version = Version::parse("1.3.0").unwrap();//!     assert!(req.matches(&version));//! # Scope of this crate//! Besides Cargo, several other package ecosystems and package managers for//! other languages also use SemVer:&ensp;RubyGems/Bundler for Ruby, npm for//! JavaScript, Composer for PHP, CocoaPods for Objective-C...//! The `semver` crate is specifically intended to implement Cargo's//! interpretation of Semantic Versioning.//! Where the various tools differ in their interpretation or implementation of//! the spec, this crate follows the implementation choices made by Cargo. If//! you are operating on version numbers from some other package ecosystem, you//! will want to use a different semver library which is appropriate to that//! The extent of Cargo's SemVer support is documented in the *[Specifying//! Dependencies]* chapter of the Cargo reference.//! [Specifying Dependencies]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html/// Error parsing a SemVer version or version requirement.///     let err = Version::parse("1.q.r").unwrap_err();///     // "unexpected character 'q' while parsing minor version number"///     eprintln!("{}", err);numeric_identifierwildcardprerelease_identifierbuild_identifiercomparatorversion_reqbytebufByteBufVisitor// does anybody need this?/// Wraps a `&[u8]` in order to serialize in an efficient way. Does not support/// # #[macro_use] extern crate serde_derive;/// use serde::bytes::Bytes;/// struct Packet<'a> {///     destination: IpAddr,///     payload: Bytes<'a>,/// Wrap an existing `&[u8]`./// Wraps a `Vec<u8>` in order to serialize and deserialize in an efficient/// use serde::bytes::ByteBuf;/// struct Packet {///     payload: ByteBuf,/// Construct a new, empty `ByteBuf`./// Construct a new, empty `ByteBuf` with the specified capacity./// Wrap existing bytes in a `ByteBuf`./// This type implements the `serde::de::Visitor` trait for a `ByteBuf`.escape_bytestringEscapeDefault//! Wrapper types to enable optimized handling of `&[u8]` and `Vec<u8>`.//! Without specialization, Rust forces us to treat `&[u8]` just like any other//! slice and `Vec<u8>` just like any other vector. In reality this particular//! slice and vector can often be serialized and deserialized in a more//! efficient, compact representation in many formats.//! When working with such a format, you can opt into specialized handling of//! `&[u8]` by wrapping it in `bytes::Bytes` and `Vec<u8>` by wrapping it in//! `bytes::ByteBuf`.//! Rust support for specialization is being tracked in//! [rust-lang/rust#31844][specialization]. Once it lands in the stable compiler//! we will be deprecating these wrapper types in favor of optimizing `&[u8]`//! and `Vec<u8>` out of the box.//! [specialization]: https://github.com/rust-lang/rust/issues/31844MapVisitorEnumVisitor/// Used from generated code to buffer the contents of the Deserializer when/// deserializing untagged enums and internally tagged enums./// Not public API. Use serde-value instead.unexpectedContentVisitorvisit_i8visit_i16visit_i32visit_u8visit_u16visit_f32visit_newtype_structTagOrContent/// This is the type of the map keys in an internally tagged enum./// Not public API.TagOrContentVisitorTaggedContent/// Used by generated code to deserialize an internally tagged enum.TaggedContentVisitor/// Visitor for the content of an internally tagged enum with the given tagTagOrContentField/// Used by generated code to deserialize an adjacently tagged enum.TagOrContentFieldVisitorContentDeserializer/// Not public APIforward_to_deserializeforward_to_deserialize_helperforward_to_deserialize_method__Vdeserialize_seq_fixed_sizedeserialize_struct_field/// Used when deserializing an internally tagged enum because the content will/// be used exactly once./// private API, don't useEnumDeserializerVariantDeserializervisit_variant_seedvisit_newtype_seedvisit_tuplevisit_structVariantVisitorvisit_seedvisit_key_seedvisit_value_seedContentRefDeserializer/// Used when deserializing an untagged enum because the content may need to be/// used more than once.EnumRefDeserializerVariantRefDeserializerSeqRefDeserializerMapRefDeserializerValueDeserializervariant_nameInternallyTaggedUnitVisitor/// Visitor for deserializing an internally tagged unit variant.UntaggedUnitVisitor/// Visitor for deserializing an untagged unit variant.// This module is doc(hidden) and nothing here should be used outside of// generated code.// We will iterate on the implementation for a few releases and only have to// worry about backward compatibility for the `untagged` and `tag` attributes// rather than for this entire mechanism.// This issue is tracking making some of this stuff public:// https://github.com/serde-rs/serde/issues/741/// returns the smallest finite number this type can represent/// returns the largest finite number this type can represent/// Converts the value of `self` to an `isize`./// Converts the value of `self` to an `i8`./// Converts the value of `self` to an `i16`./// Converts the value of `self` to an `i32`./// Converts the value of `self` to an `i64`./// Converts the value of `self` to a `usize`./// Converts the value of `self` to an `u8`./// Converts the value of `self` to an `u16`./// Converts the value of `self` to an `u32`./// Converts the value of `self` to an `u64`./// Converts the value of `self` to an `f32`./// Converts the value of `self` to an `f64`.// Extracted from https://github.com/rust-num/num.// Rust 1.5 is unhappy that this private module is undocumented.UnitVisitor/// A visitor that produces a `()`.BoolVisitor/// A visitor that produces a `bool`.impl_deserialize_num_methodimpl_deserialize_numCharVisitorOptionVisitorPhantomDataVisitor/// A visitor that produces a `PhantomData`.seq_implr" A visitor that produces a sequence."BinaryHeapVisitorr" Construct a new sequence visitor."BTreeSetVisitorLinkedListVisitorHashSetVisitorVecVisitorVecDequeVisitorr" Construct a tuple visitor."TupleVisitor1r" Construct a `TupleVisitor*<T>`."TupleVisitor2TupleVisitor3TupleVisitor4TupleVisitor5TupleVisitor6TupleVisitor7TupleVisitor8TupleVisitor9TupleVisitor10TupleVisitor11TupleVisitor12TupleVisitor13TupleVisitor14TupleVisitor15TupleVisitor16map_implr" A visitor that produces a map."BTreeMapVisitorr" Construct a `MapVisitor*<T>`."HashMapVisitorPathBufVisitorOsStringKindOSSTR_VARIANTSOsStringVisitor// This is a cleaned-up version of the impl generated by://     #[derive(Deserialize)]//     #[serde(deny_unknown_fields)]//     struct Duration {//         secs: u64,//         nanos: u32,// Similar to://     struct Range {//         start: u64,//         end: u32,/// A target for deserializers that want to ignore data. Implements/// Deserialize and silently eats data given to it.//! This module contains `Deserialize` and `Visitor` implementations.// Helpers used by generated code. Not public API./// Raised when there is general error when deserializing a type./// The message should not be capitalized and should not end with a period./// # use serde::de::{Deserialize, Deserializer, Error};/// # struct IpAddr;/// # impl FromStr for IpAddr {/// #     type Err = String;/// #     fn from_str(_: &str) -> Result<Self, String> { unimplemented!() }/// impl Deserialize for IpAddr {///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>///         where D: Deserializer///         let s = try!(String::deserialize(deserializer));///         s.parse().map_err(Error::custom)Expected/// Raised when a `Deserialize` receives a type different from what it was/// expecting./// The `unexp` argument provides information about what type was received./// This is the type that was present in the input file or other source data/// of the Deserializer./// The `exp` argument provides information about what type was being/// expected. This is the type that is written in the program./// For example if we try to deserialize a String out of a JSON file/// containing an integer, the unexpected type is the integer and the/// expected type is the string./// Raised when a `Deserialize` receives a value of the right type but that/// is wrong for some other reason./// The `unexp` argument provides information about what value was received./// This is the value that was present in the input file or other source/// data of the Deserializer./// The `exp` argument provides information about what value was being/// For example if we try to deserialize a String out of some binary data/// that is not valid UTF-8, the unexpected value is the bytes and the/// expected value is a string.invalid_length/// Raised when deserializing a sequence or map and the input data contains/// too many or too few elements./// The `len` argument is the number of elements encountered. The sequence/// or map may have expected more arguments or fewer arguments./// The `exp` argument provides information about what data was being/// expected. For example `exp` might say that a tuple of size 6 wasunknown_variant/// Raised when a `Deserialize` enum type received a variant with an/// unrecognized name.unknown_field/// Raised when a `Deserialize` struct type received a field with anmissing_field/// Raised when a `Deserialize` struct type expected to receive a required/// field with a particular name but that field was not present in theduplicate_field/// Raised when a `Deserialize` struct type received more than one of the/// same field./// The `Error` trait allows `Deserialize` implementations to create descriptive/// error messages belonging to the `Deserializer` against which they are/// currently running./// Every `Deserializer` declares an `Error` type that encompasses both/// general-purpose deserialization errors as well as errors specific to the/// particular deserialization format. For example the `Error` type of/// `serde_json` can represent errors like an invalid JSON escape sequence or an/// unterminated string literal, in addition to the error cases that are part of/// this trait./// Most deserializers should only need to provide the `Error::custom` method/// and inherit the default behavior for the other methods./// The input contained a boolean value that was not expected./// The input contained an unsigned integer `u8`, `u16`, `u32` or `u64` that/// was not expected./// The input contained a signed integer `i8`, `i16`, `i32` or `i64` that/// The input contained a floating point `f32` or `f64` that was not/// The input contained a `char` that was not expected./// The input contained a `&str` or `String` that was not expected./// The input contained a `&[u8]` or `Vec<u8>` that was not expected./// The input contained a unit `()` that was not expected./// The input contained an `Option<T>` that was not expected.NewtypeStruct/// The input contained a newtype struct that was not expected./// The input contained a sequence that was not expected./// The input contained a map that was not expected./// The input contained an enum that was not expected.UnitVariant/// The input contained a unit variant that was not expected.NewtypeVariant/// The input contained a newtype variant that was not expected.TupleVariant/// The input contained a tuple variant that was not expected.StructVariant/// The input contained a struct variant that was not expected./// A message stating what uncategorized thing the input contained that was/// not expected./// The message should be a noun or noun phrase, not capitalized and without/// a period. An example message is "unoriginal superhero"./// `Unexpected` represents an unexpected invocation of any one of the `Visitor`/// This is used as an argument to the `invalid_type`, `invalid_value`, and/// `invalid_length` methods of the `Error` trait to build error messages./// # use serde::de::{Error, Unexpected, Visitor};/// # struct Example;/// # impl Visitor for Example {/// # type Value = ();/// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>///     where E: Error///     Err(Error::invalid_type(Unexpected::Bool(v), &self))/// # fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {/// #     write!(formatter, "definitely not a boolean")/// Format an explanation of what data was being expected. Same signature as/// the `Display` and `Debug` traits./// `Expected` represents an explanation of what data a `Visitor` was expecting/// to receive./// `invalid_length` methods of the `Error` trait to build error messages. The/// message should be a noun or noun phrase that completes the sentence "This/// Visitor expects to receive ...", for example the message could be "an/// integer between 0 and 64". The message should not be capitalized and should/// not end with a period./// Within the context of a `Visitor` implementation, the `Visitor` itself/// (`&self`) is an implementation of this trait./// Outside of a `Visitor`, `&"..."` can be used./// # use serde::de::{Error, Unexpected};/// # fn example<E: Error>() -> Result<(), E> {/// # let v = true;/// return Err(Error::invalid_type(Unexpected::Bool(v), &"a negative integer"));/// Deserialize this value from the given Serde deserializer./// See the [Implementing `Deserialize`][impl-deserialize] section of the/// manual for more information about how to implement this method./// [impl-deserialize]: https://serde.rs/impl-deserialize.html/// A **data structure** that can be deserialized from any data format supported/// by Serde./// Serde provides `Deserialize` implementations for many Rust primitive and/// standard library types. The complete list is [here][de]. All of these can/// be deserialized using Serde out of the box./// Additionally, Serde provides a procedural macro called `serde_derive` to/// automatically generate `Deserialize` implementations for structs and enums/// in your program. See the [codegen section of the manual][codegen] for how to/// use this./// In rare cases it may be necessary to implement `Deserialize` manually for/// some type in your program. See the [Implementing/// `Deserialize`][impl-deserialize] section of the manual for more about this./// Third-party crates may provide `Deserialize` implementations for types that/// they expose. For example the `linked-hash-map` crate provides a/// `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate/// provides an implementation of `Deserialize` for it./// [de]: https://docs.serde.rs/serde/de/index.html/// [codegen]: https://serde.rs/codegen.html/// The type produced by using this seed./// Equivalent to the more common `Deserialize::deserialize` method, except/// with some initial piece of data (the seed) passed in./// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you/// ever find yourself looking for a way to pass data into a `Deserialize` impl,/// this trait is the way to do it./// As one example of stateful deserialization consider deserializing a JSON/// array into an existing buffer. Using the `Deserialize` trait we could/// deserialize a JSON array into a `Vec<T>` but it would be a freshly allocated/// `Vec<T>`; there is no way for `Deserialize` to reuse a previously allocated/// buffer. Using `DeserializeSeed` instead makes this possible as in the/// example code below./// The canonical API for stateless deserialization looks like this:/// # enum Error {}/// fn func<T: Deserialize>() -> Result<T, Error>/// # { unimplemented!() }/// Adjusting an API like this to support stateful deserialization is a matter/// of accepting a seed as input:/// # use serde::de::DeserializeSeed;/// fn func_seed<T: DeserializeSeed>(seed: T) -> Result<T::Value, Error>/// #     let _ = seed;/// #     unimplemented!()/// In practice the majority of deserialization is stateless. An API expecting a/// seed can be appeased by passing `std::marker::PhantomData` as a seed in the/// case of stateless deserialization./// Suppose we have JSON that looks like `[[1, 2], [3, 4, 5], [6]]` and we need/// to deserialize it into a flat representation like `vec![1, 2, 3, 4, 5, 6]`./// Allocating a brand new `Vec<T>` for each subarray would be slow. Instead we/// would like to allocate a single `Vec<T>` and then deserialize each subarray/// into it. This requires stateful deserialization using the `DeserializeSeed`/// # use serde::de::{Deserialize, DeserializeSeed, Deserializer, Visitor, SeqVisitor};/// // A DeserializeSeed implementation that uses stateful deserialization to/// // append array elements onto the end of an existing vector. The preexisting/// // state ("seed") in this case is the Vec<T>. The `deserialize` method of/// // `ExtendVec` will be traversing the inner arrays of the JSON input and/// // appending each integer into the existing Vec./// struct ExtendVec<'a, T: 'a>(&'a mut Vec<T>);/// impl<'a, T> DeserializeSeed for ExtendVec<'a, T>///     where T: Deserialize///     // The return type of the `deserialize` method. This implementation///     // appends onto an existing vector but does not create any new data///     // structure, so the return type is ().///     type Value = ();///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>///         // Visitor implementation that will walk an inner array of the JSON///         // input.///         struct ExtendVecVisitor<'a, T: 'a>(&'a mut Vec<T>);///         impl<'a, T> Visitor for ExtendVecVisitor<'a, T>///             where T: Deserialize///         {///             type Value = ();///             fn visit_seq<V>(self, mut visitor: V) -> Result<(), V::Error>///                 where V: SeqVisitor///             {///                 // Visit each element in the inner array and push it onto///                 // the existing vector.///                 while let Some(elem) = visitor.visit()? {///                     self.0.push(elem);/// #           fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {/// #               write!(formatter, "an array of integers")/// #           }///         deserializer.deserialize_seq(ExtendVecVisitor(self.0))/// // Visitor implementation that will walk the outer array of the JSON input./// struct FlattenedVecVisitor<T>(PhantomData<T>);/// impl<T> Visitor for FlattenedVecVisitor<T>///     // This Visitor constructs a single Vec<T> to hold the flattened///     // contents of the inner arrays.///     type Value = Vec<T>;///     fn visit_seq<V>(self, mut visitor: V) -> Result<Vec<T>, V::Error>///         where V: SeqVisitor///         // Create a single Vec to hold the flattened contents.///         let mut vec = Vec::new();///         // Each iteration through this loop is one inner array.///         while let Some(()) = visitor.visit_seed(ExtendVec(&mut vec))? {///             // Nothing to do; inner array has been appended into `vec`.///         // Return the finished vec.///         Ok(vec)/// #   fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {/// #       write!(formatter, "an array of arrays")/// # fn example<D: Deserializer>(deserializer: D) -> Result<(), D::Error> {/// let visitor = FlattenedVecVisitor(PhantomData);/// let flattened: Vec<u64> = deserializer.deserialize_seq(visitor)?;/// # let _ = flattened;/// The error type that can be returned if some error occurs during/// Require the `Deserializer` to figure out how to drive the visitor based/// on what data type is in the input./// When implementing `Deserialize`, you should avoid relying on/// `Deserializer::deserialize` unless you need to be told by the/// Deserializer what type is in the input. Know that relying on/// `Deserializer::deserialize` means your data type will be able to/// deserialize from self-describing formats only, ruling out Bincode and/// many others./// Hint that the `Deserialize` type is expecting a `bool` value./// Hint that the `Deserialize` type is expecting a `u8` value./// Hint that the `Deserialize` type is expecting a `u16` value./// Hint that the `Deserialize` type is expecting a `u32` value./// Hint that the `Deserialize` type is expecting a `u64` value./// Hint that the `Deserialize` type is expecting an `i8` value./// Hint that the `Deserialize` type is expecting an `i16` value./// Hint that the `Deserialize` type is expecting an `i32` value./// Hint that the `Deserialize` type is expecting an `i64` value./// Hint that the `Deserialize` type is expecting a `f32` value./// Hint that the `Deserialize` type is expecting a `f64` value./// Hint that the `Deserialize` type is expecting a `char` value./// Hint that the `Deserialize` type is expecting a string value and does/// not benefit from taking ownership of buffered data owned by the/// `Deserializer`./// If the `Visitor` would benefit from taking ownership of `String` data,/// indiciate this to the `Deserializer` by using `deserialize_string`/// Hint that the `Deserialize` type is expecting a string value and would/// benefit from taking ownership of buffered data owned by the/// If the `Visitor` would not benefit from taking ownership of `String`/// data, indicate that to the `Deserializer` by using `deserialize_str`/// Hint that the `Deserialize` type is expecting a byte array and does not/// If the `Visitor` would benefit from taking ownership of `Vec<u8>` data,/// indicate this to the `Deserializer` by using `deserialize_byte_buf`/// Hint that the `Deserialize` type is expecting a byte array and would/// If the `Visitor` would not benefit from taking ownership of `Vec<u8>`/// data, indicate that to the `Deserializer` by using `deserialize_bytes`/// Hint that the `Deserialize` type is expecting an optional value./// This allows deserializers that encode an optional value as a nullable/// value to convert the null value into `None` and a regular value into/// `Some(value)`./// Hint that the `Deserialize` type is expecting a unit value./// Hint that the `Deserialize` type is expecting a unit struct with a/// particular name./// Hint that the `Deserialize` type is expecting a newtype struct with a/// Hint that the `Deserialize` type is expecting a sequence of values./// Hint that the `Deserialize` type is expecting a sequence of values and/// knows how many values there are without looking at the serialized data./// Hint that the `Deserialize` type is expecting a tuple value with a/// particular number of elements./// Hint that the `Deserialize` type is expecting a tuple struct with a/// particular name and number of fields./// Hint that the `Deserialize` type is expecting a map of key-value pairs./// Hint that the `Deserialize` type is expecting a struct with a particular/// name and fields./// Hint that the `Deserialize` type is expecting the name of a struct/// Hint that the `Deserialize` type is expecting an enum value with a/// particular name and possible variants./// Hint that the `Deserialize` type needs to deserialize a value whose type/// doesn't matter because it is ignored./// Deserializers for non-self-describing formats may not support this mode./// A **data format** that can deserialize any data structure supported by/// Serde./// The role of this trait is to define the deserialization half of the Serde/// data model, which is a way to categorize every Rust data type into one of 28/// possible types. Each method of the `Serializer` trait corresponds to one of/// the types of the data model./// Implementations of `Deserialize` map themselves into this data model by/// passing to the `Deserializer` a `Visitor` implementation that can receive/// these various types./// The types that make up the Serde data model are:///  - 12 primitive types:///    - bool///    - i8, i16, i32, i64///    - u8, u16, u32, u64///    - f32, f64///    - char///  - string///  - byte array - [u8]///  - option///    - either none or some value///  - unit///    - unit is the type of () in Rust///  - unit_struct///    - for example `struct Unit` or `PhantomData<T>`///  - unit_variant///    - the `E::A` and `E::B` in `enum E { A, B }`///  - newtype_struct///    - for example `struct Millimeters(u8)`///  - newtype_variant///    - the `E::N` in `enum E { N(u8) }`///  - seq///    - a dynamically sized sequence of values, for example `Vec<T>` or///      `HashSet<T>`///  - seq_fixed_size///    - a statically sized sequence of values for which the size will be known///      at deserialization time without looking at the serialized data, for///      example `[u64; 10]`///  - tuple///    - for example `(u8,)` or `(String, u64, Vec<T>)`///  - tuple_struct///    - for example `struct Rgb(u8, u8, u8)`///  - tuple_variant///    - the `E::T` in `enum E { T(u8, u8) }`///  - map///    - for example `BTreeMap<K, V>`///  - struct///    - a key-value pairing in which the keys will be known at deserialization///      time without looking at the serialized data, for example `struct S { r:///      u8, g: u8, b: u8 }`///  - struct_variant///    - the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`/// The `Deserializer` trait supports two entry point styles which enables/// different kinds of deserialization./// 1. The `deserialize` method. Self-describing data formats like JSON are able///    to look at the serialized data and tell what it represents. For example///    the JSON deserializer may see an opening curly brace (`{`) and know that///    it is seeing a map. If the data format supports///    `Deserializer::deserialize`, it will drive the Visitor using whatever///    type it sees in the input. JSON uses this approach when deserializing///    `serde_json::Value` which is an enum that can represent any JSON///    document. Without knowing what is in a JSON document, we can deserialize///    it to `serde_json::Value` by going through `Deserializer::deserialize`./// 2. The various `deserialize_*` methods. Non-self-describing formats like///    Bincode need to be told what is in the input in order to deserialize it.///    The `deserialize_*` methods are hints to the deserializer for how to///    interpret the next piece of input. Non-self-describing formats are not///    able to deserialize something like `serde_json::Value` which relies on///    `Deserializer::deserialize`./// `Deserializer::deserialize` unless you need to be told by the Deserializer/// what type is in the input. Know that relying on `Deserializer::deserialize`/// means your data type will be able to deserialize from self-describing/// formats only, ruling out Bincode and many others./// The value produced by this visitor./// Format a message stating what data this Visitor expects to receive./// This is used in error messages. The message should complete the sentence/// "This Visitor expects to receive ...", for example the message could be/// "an integer between 0 and 64". The message should not be capitalized and/// should not end with a period./// # struct S { max: usize }/// # impl serde::de::Visitor for S {/// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {///     write!(formatter, "an integer between 0 and {}", self.max)/// Deserialize a `bool` into a `Value`./// Deserialize an `i8` into a `Value`./// Deserialize an `i16` into a `Value`./// Deserialize an `i32` into a `Value`./// Deserialize an `i64` into a `Value`./// Deserialize a `u8` into a `Value`./// Deserialize a `u16` into a `Value`./// Deserialize a `u32` into a `Value`./// Deserialize a `u64` into a `Value`./// Deserialize a `f32` into a `Value`./// Deserialize a `f64` into a `Value`./// Deserialize a `char` into a `Value`./// Deserialize a `&str` into a `Value`./// This method allows the `Deserializer` to avoid a copy by retaining/// ownership of any buffered data. `Deserialize` implementations that do/// not benefit from taking ownership of `String` data should indicate that/// to the deserializer by using `Deserializer::deserialize_str` rather than/// `Deserializer::deserialize_string`./// It is never correct to implement `visit_string` without implementing/// `visit_str`. Implement neither, both, or just `visit_str`./// Deserialize a `String` into a `Value`./// This method allows the `Visitor` to avoid a copy by taking ownership of/// a string created by the `Deserializer`. `Deserialize` implementations/// that benefit from taking ownership of `String` data should indicate that/// to the deserializer by using `Deserializer::deserialize_string` rather/// than `Deserializer::deserialize_str`, although not every deserializer/// will honor such a request./// The default implementation forwards to `visit_str` and then drops the/// Deserialize a `()` into a `Value`./// Deserialize an absent optional `Value`./// Deserialize a present optional `Value`./// Deserialize `Value` as a newtype struct./// Deserialize `Value` as a sequence of elements./// Deserialize `Value` as a key-value map./// Deserialize `Value` as an enum./// Deserialize a `&[u8]` into a `Value`./// not benefit from taking ownership of `Vec<u8>` data should indicate that/// to the deserializer by using `Deserializer::deserialize_bytes` rather/// than `Deserializer::deserialize_byte_buf`./// It is never correct to implement `visit_byte_buf` without implementing/// `visit_bytes`. Implement neither, both, or just `visit_bytes`./// Deserialize a `Vec<u8>` into a `Value`./// a byte buffer created by the `Deserializer`. `Deserialize`/// implementations that benefit from taking ownership of `Vec<u8>` data/// should indicate that to the deserializer by using/// `Deserializer::deserialize_byte_buf` rather than/// `Deserializer::deserialize_bytes`, although not every deserializer will/// honor such a request./// The default implementation forwards to `visit_bytes` and then drops the/// This trait represents a visitor that walks through a deserializer./// /// A visitor that deserializes a long string - a string containing at least/// /// some minimum number of bytes./// struct LongString {///     min: usize,/// impl Visitor for LongString {///     type Value = String;///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {///         write!(formatter, "a string containing at least {} bytes", self.min)///     fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>///         where E: Error///         if s.len() >= self.min {///             Ok(s.to_owned())///             Err(Error::invalid_value(Unexpected::Str(s), &self))/// This returns `Ok(Some(value))` for the next value in the sequence, or/// `Ok(None)` if there are no more remaining items./// `Deserialize` implementations should typically use `SeqVisitor::visit`/// This method exists as a convenience for `Deserialize` implementations./// `SeqVisitor` implementations should not override the default behavior./// Return the lower and upper bound of items remaining in the sequence./// `SeqVisitor` visits each item in a sequence./// This is a trait that a `Deserializer` passes to a `Visitor` implementation,/// which deserializes each item in a sequence./// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`/// if there are no more remaining entries./// `Deserialize` implementations should typically use/// `MapVisitor::visit_key` or `MapVisitor::visit` instead./// This returns a `Ok(value)` for the next value in the map./// `MapVisitor::visit_value` instead./// This returns `Ok(Some((key, value)))` for the next (key-value) pair in/// the map, or `Ok(None)` if there are no more remaining items./// `MapVisitor` implementations should override the default behavior if a/// more efficient implementation is possible./// `Deserialize` implementations should typically use `MapVisitor::visit`visit_key/// `MapVisitor` implementations should not override the default behavior.visit_value/// `MapVisitor` visits each item in a sequence./// This is a trait that a `Deserializer` passes to a `Visitor` implementation.V_/// The `Visitor` that will be used to deserialize the content of the enum/// `visit_variant` is called to identify which variant to deserialize./// `EnumVisitor::visit_variant` instead.visit_variant/// `EnumVisitor` implementations should not override the default behavior./// `EnumVisitor` is a visitor that is created by the `Deserializer` and passed/// to the `Deserialize` in order to identify which variant of an enum to/// deserialize./// deserialization. Must match the error type of our `EnumVisitor`./// Called when deserializing a variant with no values./// If the data contains a different type of variant, the following/// `invalid_type` error should be constructed:/// fn visit_unit(self) -> Result<(), Self::Error> {///     // What the data actually contained; suppose it is a tuple variant.///     let unexp = Unexpected::TupleVariant;///     Err(de::Error::invalid_type(unexp, &"unit variant"))/// Called when deserializing a variant with a single value./// `VariantVisitor::visit_newtype` instead./// fn visit_newtype_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>///     where T: de::DeserializeSeed///     // What the data actually contained; suppose it is a unit variant.///     let unexp = Unexpected::UnitVariant;///     Err(de::Error::invalid_type(unexp, &"newtype variant"))visit_newtype/// `VariantVisitor` implementations should not override the default/// Called when deserializing a tuple-like variant./// The `len` is the number of fields expected in the tuple variant./// fn visit_tuple<V>(self,///                   _len: usize,///                   _visitor: V) -> Result<V::Value, Self::Error>///     where V: Visitor///     Err(Error::invalid_type(unexp, &"tuple variant"))/// Called when deserializing a struct-like variant./// The `fields` are the names of the fields of the struct variant./// fn visit_struct<V>(self,///                    _fields: &'static [&'static str],///                    _visitor: V) -> Result<V::Value, Self::Error>///     Err(Error::invalid_type(unexp, &"struct variant"))/// `VariantVisitor` is a visitor that is created by the `Deserializer` and/// passed to the `Deserialize` to deserialize the content of a particular enum/// Used in error messages./// - expected `a`/// - expected `a` or `b`/// - expected one of `a`, `b`, `c`/// The slice of names must not be empty.//! Generic data structure deserialization framework.//! The two most important traits in this module are `Deserialize` and//! `Deserializer`.//!  - **A type that implements `Deserialize` is a data structure** that can be//!    deserialized from any data format supported by Serde, and conversely//!  - **A type that implements `Deserializer` is a data format** that can//!    deserialize any data structure supported by Serde.//! # The Deserialize trait//! Serde provides `Deserialize` implementations for many Rust primitive and//! standard library types. The complete list is below. All of these can be//! deserialized using Serde out of the box.//! Additionally, Serde provides a procedural macro called `serde_derive` to//! automatically generate `Deserialize` implementations for structs and enums//! in your program. See the [codegen section of the manual][codegen] for how to//! use this.//! In rare cases it may be necessary to implement `Deserialize` manually for//! some type in your program. See the [Implementing//! `Deserialize`][impl-deserialize] section of the manual for more about this.//! Third-party crates may provide `Deserialize` implementations for types that//! they expose. For example the `linked-hash-map` crate provides a//! `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate//! provides an implementation of `Deserialize` for it.//! # The Deserializer trait//! `Deserializer` implementations are provided by third-party crates, for//! example [`serde_json`][serde_json], [`serde_yaml`][serde_yaml] and//! [`bincode`][bincode].//! A partial list of well-maintained formats is given on the [Serde//! website][data-formats].//! # Implementations of Deserialize provided by Serde//! This is a slightly different set of types than what is supported for//! serialization. Some types can be serialized by Serde but not deserialized.//! One example is `&str`.//!  - **Primitive types**://!    - bool//!    - isize, i8, i16, i32, i64//!    - usize, u8, u16, u32, u64//!    - f32, f64//!    - char//!  - **Compound types**://!    - [T; 0] through [T; 32]//!    - tuples up to size 16//!  - **Common standard library types**://!    - String//!    - Option\<T\>//!    - Result\<T, E\>//!    - PhantomData\<T\>//!  - **Wrapper types**://!    - Box\<T\>//!    - Box\<[T]\>//!    - Box\<str\>//!    - Rc\<T\>//!    - Arc\<T\>//!    - Cow\<'a, T\>//!    - Cell\<T\>//!    - RefCell\<T\>//!    - Mutex\<T\>//!    - RwLock\<T\>//!  - **Collection types**://!    - BTreeMap\<K, V\>//!    - BTreeSet\<T\>//!    - BinaryHeap\<T\>//!    - HashMap\<K, V, H\>//!    - HashSet\<T, H\>//!    - LinkedList\<T\>//!    - VecDeque\<T\>//!    - Vec\<T\>//!    - EnumSet\<T\> (unstable)//!  - **Miscellaneous standard library types**://!    - Duration//!    - Path//!    - PathBuf//!    - NonZero\<T\> (unstable)//!  - **Net types**://!    - IpAddr//!    - Ipv4Addr//!    - Ipv6Addr//!    - SocketAddr//!    - SocketAddrV4//!    - SocketAddrV6//! [codegen]: https://serde.rs/codegen.html//! [impl-deserialize]: https://serde.rs/impl-deserialize.html//! [serde_json]: https://github.com/serde-rs/json//! [serde_yaml]: https://github.com/dtolnay/serde-yaml//! [bincode]: https://github.com/TyOverby/bincode//! [data-formats]: https://serde.rs/#data-formats/// If the missing field is of type `Option<T>` then treat is as `None`,/// otherwise it is an error./// This represents all the possible errors that can occur using the `ValueDeserializer`./// The actual deserializer type./// Convert this value into a deserializer./// This trait converts primitive types into a deserializer./// A helper deserializer that deserializes a `()`.primitive_deserializerr" A helper deserializer that deserializes a number."BoolDeserializerI8DeserializerI16DeserializerI32DeserializerI64DeserializerIsizeDeserializerU8DeserializerU16DeserializerU64DeserializerUsizeDeserializerF32DeserializerF64DeserializerCharDeserializerU32Deserializer/// A helper deserializer that deserializes a number.StrDeserializer/// A helper deserializer that deserializes a `&str`.StringDeserializer/// A helper deserializer that deserializes a `String`.CowStrDeserializer/// A helper deserializer that deserializes a sequence./// Construct a new `SeqDeserializer<I>`./// Check for remaining elements after passing a `SeqDeserializer` to/// `Visitor::visit_seq`.ExpectedInSeqSeqVisitorDeserializer/// A helper deserializer that deserializes a sequence using a `SeqVisitor`./// Construct a new `SeqVisitorDeserializer<V_, E>`./// A helper deserializer that deserializes a map./// Construct a new `MapDeserializer<I, K, V, E>`./// Check for remaining elements after passing a `MapDeserializer` to/// `Visitor::visit_map`.next_pairTKPairDeserializer// Used in the `impl SeqVisitor for MapDeserializer` to visit the map as a// sequence of pairs.PairVisitorExpectedInMapMapVisitorDeserializer/// A helper deserializer that deserializes a map using a `MapVisitor`./// Construct a new `MapVisitorDeserializer<V_, E>`.BytesDeserializer/// A helper deserializer that deserializes a `&[u8]`.ByteBufDeserializer/// A helper deserializer that deserializes a `Vec<u8>`.unit_only/// Avoid having to restate the generic types on `MapDeserializer`. The/// `Iterator::Item` contains enough information to figure out K and V.//! This module supports deserializing from primitives with the `ValueDeserializer` trait./// The description should not contain newlines or sentence-ending/// punctuation, to facilitate embedding in larger user-facing/// strings./// The lower-level cause of this error, if any./// A stand-in for `std::error::Error`, which requires no allocation.//! A stand-in for `std::error`LineColIterator/// Iterator over a byte stream that tracks the current position's line and column./// Construct a new `LineColIterator<Iter>`./// Report the current line inside the iterator./// Report the current column inside the iterator./// Gets a reference to the underlying iterator./// Gets a mutable reference to the underlying iterator./// Unwraps this `LineColIterator`, returning the underlying iterator./// peeks at the next value//! Module that contains helper iterators.// Generated code uses these to support no_std. Not public API.//! Serde is a framework for ***ser***ializing and ***de***serializing Rust data//! structures efficiently and generically.//! The Serde ecosystem consists of data structures that know how to serialize//! and deserialize themselves along with data formats that know how to//! serialize and deserialize other things. Serde provides the layer by which//! these two groups interact with each other, allowing any supported data//! structure to be serialized and deserialized using any supported data format.//! See the Serde website https://serde.rs/ for additional documentation and//! usage examples.//! ### Design//! Where many other languages rely on runtime reflection for serializing data,//! Serde is instead built on Rust's powerful trait system. A data structure//! that knows how to serialize and deserialize itself is one that implements//! Serde's `Serialize` and `Deserialize` traits (or uses Serde's code//! generation to automatically derive implementations at compile time). This//! avoids any overhead of reflection or runtime type information. In fact in//! many situations the interaction between data structure and data format can//! be completely optimized away by the Rust compiler, leaving Serde//! serialization to perform roughly the same speed as a handwritten serializer//! for the specific selection of data structure and data format.//! ### Data formats//! The following is a partial list of data formats that have been implemented//! for Serde by the community.//! - [JSON](https://github.com/serde-rs/json), the ubiquitous JavaScript Object//!   Notation used by many HTTP APIs.//! - [Bincode](https://github.com/TyOverby/bincode), a compact binary format//!   used for IPC within the Servo rendering engine.//! - [CBOR](https://github.com/pyfisch/cbor), a Concise Binary Object//!   Representation designed for small message size without the need for//!   version negotiation.//! - [YAML](https://github.com/dtolnay/serde-yaml), a popular human-friendly//!   configuration language that ain't markup language.//! - [MessagePack](https://github.com/3Hren/msgpack-rust), an efficient binary//!   format that resembles a compact JSON.//! - [TOML](https://github.com/alexcrichton/toml-rs), a minimal configuration//!   format used by [Cargo](http://doc.crates.io/manifest.html).//! - [Pickle](https://github.com/birkenfeld/serde-pickle), a format common in//!   the Python world.//! - [Hjson](https://github.com/laktak/hjson-rust), a variant of JSON designed//!   to be readable and writable by humans.//! - [BSON](https://github.com/zonyitoo/bson-rs), the data storage and network//!   transfer format used by MongoDB.//! - [URL](https://github.com/nox/serde_urlencoded), the x-www-form-urlencoded//! - [XML](https://github.com/serde-rs/xml), the flexible machine-friendly W3C//!   standard. *(deserialization only)*//! - [Envy](https://github.com/softprops/envy), a way to deserialize//!   environment variables into Rust structs. *(deserialization only)*//! - [Redis](https://github.com/OneSignal/serde-redis), deserialize values from//!   Redis when using [redis-rs](https://crates.io/crates/redis).//!   *(deserialization only)*// Super explicit first paragraph because this shows up at the top level and// trips up people who are just looking for basic Serialize / Deserialize// documentation./// Helper macro when implementing the `Deserializer` part of a new data format/// for Serde./// Some `Deserializer` implementations for self-describing formats do not care/// what hint the `Visitor` gives them, they just want to blindly call the/// `Visitor` method corresponding to the data they can tell is in the input./// This requires repetitive implementations of all the `Deserializer` trait/// # #[macro_use] extern crate serde;/// # use serde::de::{value, Deserializer, Visitor};/// # pub struct MyDeserializer;/// # impl Deserializer for MyDeserializer {/// #     type Error = value::Error;/// #     fn deserialize<V>(self, _: V) -> Result<V::Value, Self::Error>/// #         where V: Visitor/// #     { unimplemented!() }/// #[inline]/// fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>///     self.deserialize(visitor)/// #     forward_to_deserialize! {/// #         u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option/// #         seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct/// #         tuple_struct struct struct_field tuple enum ignored_any/// The `forward_to_deserialize!` macro implements these simple forwarding/// methods so that they forward directly to `Deserializer::deserialize`. You/// can choose which methods to forward./// impl Deserializer for MyDeserializer {/// #   type Error = value::Error;///     fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>///         where V: Visitor///         /* ... *//// #       let _ = visitor;///     forward_to_deserialize! {///         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option///         seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct///         tuple_struct struct struct_field tuple enum ignored_anyserialize_display_bounded_length/// Seralize the `$value` that implements Display as a string,/// when that string is statically known to never have more than/// a constant `$MAX_LEN` bytes./// Panics if the Display impl tries to write more than `$MAX_LEN` bytes.// Not exportedSerializeTupleVariantAsMapValueSerializeStructVariantAsMapValueUnitStructSeqFixedSizeTupleStructserialize_seq_fixed_sizevariant_indeximpl_visitvoid/// Helper type for implementing a `Serializer` that does not support/// serializing one of the compound types./// This type cannot be instantiated, but implements every one of the traits/// corresponding to the `Serializer` compound types: `SerializeSeq`,/// `SerializeTuple`, `SerializeTupleStruct`, `SerializeTupleVariant`,/// `SerializeMap`, `SerializeStruct`, and `SerializeStructVariant`./// impl Serializer for MySerializer {///     type Ok = ();///     type Error = Error;///     type SerializeSeq = Impossible<(), Error>;///     /* other associated types *////     /// This data format does not support serializing sequences.///     fn serialize_seq(self,///                      len: Option<usize>)///                      -> Result<Self::SerializeSeq, Error> {///         // Given Impossible cannot be instantiated, the only///         // thing we can do here is to return an error.///         Err(...)///     /* other Serializer methods *///! This module contains `Impossible` serializer and its implementations./// Raised when a `Serialize` implementation encounters a general error/// while serializing a type./// For example, a filesystem `Path` may refuse to serialize itself if it/// contains invalid UTF-8 data./// # use serde::ser::{Serialize, Serializer, Error};/// # struct Path;/// # impl Path { fn to_str(&self) -> Option<&str> { unimplemented!() } }/// impl Serialize for Path {///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>///         where S: Serializer///         match self.to_str() {///             Some(s) => s.serialize(serializer),///             None => Err(Error::custom("path contains invalid UTF-8 characters")),/// Trait used by `Serialize` implementations to generically construct errors/// belonging to the `Serializer` against which they are currently running./// Serialize this value into the given Serde serializer./// See the [Implementing `Serialize`][impl-serialize] section of the manual/// for more information about how to implement this method./// [impl-serialize]: https://serde.rs/impl-serialize.html/// A **data structure** that can be serialized into any data format supported/// Serde provides `Serialize` implementations for many Rust primitive and/// standard library types. The complete list is [here][ser]. All of these can/// be serialized using Serde out of the box./// automatically generate `Serialize` implementations for structs and enums in/// your program. See the [codegen section of the manual][codegen] for how to/// In rare cases it may be necessary to implement `Serialize` manually for some/// type in your program. See the [Implementing `Serialize`][impl-serialize]/// section of the manual for more about this./// Third-party crates may provide `Serialize` implementations for types that/// `LinkedHashMap<K, V>` type that is serializable by Serde because the crate/// provides an implementation of `Serialize` for it./// [ser]: https://docs.serde.rs/serde/ser/index.html/// The output type produced by this `Serializer` during successful/// serialization. Most serializers that produce text or binary output/// should set `Ok = ()` and serialize into an `io::Write` or buffer/// contained within the `Serializer` instance. Serializers that build/// in-memory data structures may be simplified by using `Ok` to propagate/// the data structure around./// The error type when some error occurs during serialization./// Type returned from `serialize_seq` and `serialize_seq_fixed_size` for/// serializing the content of the sequence./// Type returned from `serialize_tuple` for serializing the content of the/// tuple./// Type returned from `serialize_tuple_struct` for serializing the content/// of the tuple struct./// Type returned from `serialize_tuple_variant` for serializing the content/// of the tuple variant./// Type returned from `serialize_map` for serializing the content of the/// map./// Type returned from `serialize_struct` for serializing the content of the/// struct./// Type returned from `serialize_struct_variant` for serializing the/// content of the struct variant./// Serialize a `bool` value./// Serialize an `i8` value./// If the format does not differentiate between `i8` and `i64`, a/// reasonable implementation would be to cast the value to `i64` and/// forward to `serialize_i64`./// Serialize an `i16` value./// If the format does not differentiate between `i16` and `i64`, a/// Serialize an `i32` value./// If the format does not differentiate between `i32` and `i64`, a/// Serialize an `i64` value./// Serialize a `u8` value./// If the format does not differentiate between `u8` and `u64`, a/// reasonable implementation would be to cast the value to `u64` and/// forward to `serialize_u64`./// Serialize a `u16` value./// If the format does not differentiate between `u16` and `u64`, a/// Serialize a `u32` value./// If the format does not differentiate between `u32` and `u64`, a/// Serialize a `u64` value./// Serialize an `f32` value./// If the format does not differentiate between `f32` and `f64`, a/// reasonable implementation would be to cast the value to `f64` and/// forward to `serialize_f64`./// Serialize an `f64` value./// Serialize a character./// If the format does not support characters, it is reasonable to serialize/// it as a single element `str` or a `u32`./// Serialize a `&str`./// Serialize a chunk of raw byte data./// Enables serializers to serialize byte slices more compactly or more/// efficiently than other types of slices. If no efficient implementation/// is available, a reasonable implementation would be to forward to/// `serialize_seq`. If forwarded, the implementation looks usually just/// let mut seq = self.serialize_seq(Some(value.len()))?;/// for b in value {///     seq.serialize_element(b)?;/// seq.end()/// Serialize a `None` value./// Serialize a `Some(T)` value./// Serialize a `()` value./// Serialize a unit struct like `struct Unit` or `PhantomData<T>`./// A reasonable implementation would be to forward to `serialize_unit`./// Serialize a unit variant like `E::A` in `enum E { A, B }`./// The `name` is the name of the enum, the `variant_index` is the index of/// this variant within the enum, and the `variant` is the name of the/// match *self {///     E::A => serializer.serialize_unit_variant("E", 0, "A"),///     E::B => serializer.serialize_unit_variant("E", 1, "B"),/// Serialize a newtype struct like `struct Millimeters(u8)`./// Serializers are encouraged to treat newtype structs as insignificant/// wrappers around the data they contain. A reasonable implementation would/// be to forward to `value.serialize(self)`./// serializer.serialize_newtype_struct("Millimeters", &self.0)/// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`./// variant. The `value` is the data contained within this newtype variant.///     E::N(ref n) => serializer.serialize_newtype_variant("E", 0, "N", n),/// Begin to serialize a dynamically sized sequence. This call must be/// followed by zero or more calls to `serialize_element`, then a call to/// `end`./// The argument is the number of elements in the sequence, which may or may/// not be computable before the sequence is iterated. Some serializers only/// support sequences whose length is known up front./// let mut seq = serializer.serialize_seq(Some(self.len()))?;/// for element in self {///     seq.serialize_element(element)?;/// Begin to serialize a statically sized sequence whose length will be/// known at deserialization time without looking at the serialized data./// This call must be followed by zero or more calls to `serialize_element`,/// then a call to `end`./// let mut seq = serializer.serialize_seq_fixed_size(self.len())?;/// Begin to serialize a tuple. This call must be followed by zero or more/// calls to `serialize_element`, then a call to `end`./// let mut tup = serializer.serialize_tuple(3)?;/// tup.serialize_element(&self.0)?;/// tup.serialize_element(&self.1)?;/// tup.serialize_element(&self.2)?;/// tup.end()/// Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This/// call must be followed by zero or more calls to `serialize_field`, then a/// call to `end`./// The `name` is the name of the tuple struct and the `len` is the number/// of data fields that will be serialized./// let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;/// ts.serialize_field(&self.0)?;/// ts.serialize_field(&self.1)?;/// ts.serialize_field(&self.2)?;/// ts.end()/// Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8)/// }`. This call must be followed by zero or more calls to/// `serialize_field`, then a call to `end`./// this variant within the enum, the `variant` is the name of the variant,/// and the `len` is the number of data fields that will be serialized.///     E::T(ref a, ref b) => {///         let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;///         tv.serialize_field(a)?;///         tv.serialize_field(b)?;///         tv.end()/// Begin to serialize a map. This call must be followed by zero or more/// calls to `serialize_key` and `serialize_value`, then a call to `end`./// The argument is the number of elements in the map, which may or may not/// be computable before the map is iterated. Some serializers only support/// maps whose length is known up front./// let mut map = serializer.serialize_map(Some(self.len()))?;/// for (k, v) in self {///     map.serialize_entry(k, v)?;/// map.end()/// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`./// This call must be followed by zero or more calls to `serialize_field`,/// The `name` is the name of the struct and the `len` is the number of/// data fields that will be serialized./// let mut struc = serializer.serialize_struct("Rgb", 3)?;/// struc.serialize_field("r", &self.r)?;/// struc.serialize_field("g", &self.g)?;/// struc.serialize_field("b", &self.b)?;/// struc.end()/// Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8,/// g: u8, b: u8 } }`. This call must be followed by zero or more calls to///     E::S { ref r, ref g, ref b } => {///         let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;///         sv.serialize_field("r", r)?;///         sv.serialize_field("g", g)?;///         sv.serialize_field("b", b)?;///         sv.end()collect_seq/// Collect an iterator as a sequence./// The default implementation serializes each item yielded by the iterator/// using `Self::SerializeSeq`. Implementors should not need to overridecollect_map/// Collect an iterator as a map./// The default implementation serializes each pair yielded by the iterator/// using `Self::SerializeMap`. Implementors should not need to overridecollect_str/// Serialize a string produced by an implementation of `Display`./// The default implementation builds a heap-allocated `String` and/// delegates to `serialize_str`. Serializers are encouraged to provide a/// more efficient implementation if possible./// # use serde::{Serialize, Serializer};/// # struct DateTime;/// # impl DateTime {/// #     fn naive_local(&self) -> () { () }/// #     fn offset(&self) -> () { () }/// impl Serialize for DateTime {///         serializer.collect_str(&format_args!("{:?}{:?}",///                                              self.naive_local(),///                                              self.offset()))/// A **data format** that can serialize any data structure supported by Serde./// The role of this trait is to define the serialization half of the Serde data/// model, which is a way to categorize every Rust data structure into one of 28/// Implementations of `Serialize` map themselves into this data model by/// invoking exactly one of the `Serializer` methods./// Many Serde serializers produce text or binary data as output, for example/// JSON or Bincode. This is not a requirement of the `Serializer` trait, and/// there are serializers that do not produce text or binary output. One example/// is the `serde_json::value::Serializer` (distinct from the main `serde_json`/// serializer) that produces a `serde_json::Value` data structure in memory as/// Must match the `Ok` type of our `Serializer`./// Must match the `Error` type of our `Serializer`./// Serialize a sequence element./// Finish serializing a sequence./// Returned from `Serializer::serialize_seq` and/// `Serializer::serialize_seq_fixed_size`./// Serialize a tuple element./// Finish serializing a tuple./// Returned from `Serializer::serialize_tuple`./// Serialize a tuple struct field./// Finish serializing a tuple struct./// Returned from `Serializer::serialize_tuple_struct`./// Serialize a tuple variant field./// Finish serializing a tuple variant./// Returned from `Serializer::serialize_tuple_variant`./// Serialize a map key./// Serialize a map value./// Serialize a map entry consisting of a key and a value./// Some `Serialize` types are not able to hold a key and value in memory at/// the same time so `SerializeMap` implementations are required to support/// `serialize_key` and `serialize_value` individually. The/// `serialize_entry` method allows serializers to optimize for the case/// where key and value are both available. `Serialize` implementations are/// encouraged to use `serialize_entry` if possible./// The default implementation delegates to `serialize_key` and/// `serialize_value`. This is appropriate for serializers that do not care/// about performance or are not able to optimize `serialize_entry` any/// better than this./// Finish serializing a map./// Returned from `Serializer::serialize_map`./// Serialize a struct field./// Finish serializing a struct./// Returned from `Serializer::serialize_struct`./// Serialize a struct variant field./// Finish serializing a struct variant./// Returned from `Serializer::serialize_struct_variant`.len_hintLenHintiterator_len_hint//! Generic data structure serialization framework.//! The two most important traits in this module are `Serialize` and//! `Serializer`.//!  - **A type that implements `Serialize` is a data structure** that can be//!    serialized to any data format supported by Serde, and conversely//!  - **A type that implements `Serializer` is a data format** that can//!    serialize any data structure supported by Serde.//! # The Serialize trait//! Serde provides `Serialize` implementations for many Rust primitive and//! serialized using Serde out of the box.//! automatically generate `Serialize` implementations for structs and enums in//! your program. See the [codegen section of the manual][codegen] for how to//! In rare cases it may be necessary to implement `Serialize` manually for some//! type in your program. See the [Implementing `Serialize`][impl-serialize]//! section of the manual for more about this.//! Third-party crates may provide `Serialize` implementations for types that//! `LinkedHashMap<K, V>` type that is serializable by Serde because the crate//! provides an implementation of `Serialize` for it.//! # The Serializer trait//! `Serializer` implementations are provided by third-party crates, for example//! [`serde_json`][serde_json], [`serde_yaml`][serde_yaml] and//! # Implementations of Serialize provided by Serde//!    - str//!    - &T and &mut T//!    - [T]//!    - Range\<T\>//! [impl-serialize]: https://serde.rs/impl-serialize.htmlserialize_tagged_newtypetype_identvariant_identTaggedSerializerbad_type// FIXME: use this from_utf8_unchecked, since we know it can never failPattern_White_Space_tablebsearch_range_tablePattern_White_Space//! Private utility functions// The rustc-cfg strings below are *not* public API. Please let us know by// opening a GitHub issue if your build environment requires some way to enable// these cfgs other than by executing our build script.crate_root/// An efficient way of discarding data from a deserializer./// Think of this like `serde_json::Value` in that it can be deserialized from/// any type, except that it does not store any information about the data that/// gets deserialized./// ```edition2021/// use serde::de::{///     self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,/// /// A seed that can be used to deserialize only the `n`th element of a sequence/// /// while efficiently discarding elements of any type before or after index `n`./// /// For example to deserialize only the element at index 3:/// /// ```/// /// NthElement::new(3).deserialize(deserializer)/// pub struct NthElement<T> {///     n: usize,/// impl<T> NthElement<T> {///     pub fn new(n: usize) -> Self {///         NthElement {///             n: n,///             marker: PhantomData,/// impl<'de, T> Visitor<'de> for NthElement<T>///     T: Deserialize<'de>,///     type Value = T;///         write!(///             formatter,///             "a sequence in which we care about element {}",///             self.n///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>///         A: SeqAccess<'de>,///         // Skip over the first `n` elements.///         for i in 0..self.n {///             // It is an error if the sequence ends before we get to element `n`.///             if seq.next_element::<IgnoredAny>()?.is_none() {///                 return Err(de::Error::invalid_length(i, &self));///         // Deserialize the one we care about.///         let nth = match seq.next_element()? {///             Some(nth) => nth,///             None => {///                 return Err(de::Error::invalid_length(self.n, &self));///         // Skip over any remaining elements in the sequence after `n`.///         while let Some(IgnoredAny) = seq.next_element()? {///             // ignore///         Ok(nth)/// impl<'de, T> DeserializeSeed<'de> for NthElement<T>///         D: Deserializer<'de>,///         deserializer.deserialize_seq(self)/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>/// #     D: Deserializer<'de>,/// // Deserialize only the sequence element at index 3 from this deserializer./// // The element at index 3 is required to be a string. Elements before and/// // after index 3 are allowed to be of any type./// let s: String = NthElement::new(3).deserialize(deserializer)?;InPlaceSeednum_selfnum_as_selfnum_as_copysign_selfint_to_intint_to_uintuint_to_selfnum_128StringInPlaceVisitorStrVisitorvisit_borrowed_bytesCStringVisitorforwarded_impl__private_visit_untagged_option// The Some variant's repr is opaque, so we can't play cute tricks with its// tag to have deserialize_in_place build the content in place unconditionally.// FIXME: investigate whether branching on the old value being Some to// deserialize_in_place the value is profitable (probably data-dependent?)nop_reserve// Dummy impl of reserveArrayInPlaceVisitor// Does not require T: Deserialize<'de>.tuple_impl_bodyparse_ip_implvariant_identifierparse_socket_implPathVisitor// If this were outside of the serde crate, it would just use://    #[derive(Deserialize)]//    #[serde(variant_identifier)]/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting/// `Weak<T>` has a reference count of 0 and cannot be upgraded./// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rcArcWeakbox_forwarded_impl//     struct Range<Idx> {//         start: Idx,//         end: Idx,//    #[serde(field_identifier, rename_all = "lowercase")]RangeVisitor//     struct RangeFrom<Idx> {RangeFromVisitor//     struct RangeTo<Idx> {RangeToVisitoratomic_implFromStrVisitorignored_anystd_errordeclare_error_trait/// # use serde::de::{self, Unexpected, Visitor};/// # impl<'de> Visitor<'de> for Example {/// #     type Value = ();/// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {/// #         write!(formatter, "definitely not a boolean")///     E: de::Error,///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))/// # use serde::de::{self, Unexpected};/// # fn example<E>() -> Result<(), E>/// #     E: de::Error,/// #     let v = true;/// return Err(de::Error::invalid_type(///     Unexpected::Bool(v),///     &"a negative integer",/// Deserializes a value into `self` from the given Deserializer./// The purpose of this method is to allow the deserializer to reuse/// resources and avoid copies. As such, if this method returns an error,/// `self` will be in an indeterminate state where some parts of the struct/// have been overwritten. Although whatever state that is will be/// memory-safe./// This is generally useful when repeatedly deserializing values that/// are processed one at a time, where the value of `self` doesn't matter/// when the next deserialization occurs./// If you manually implement this, your recursive deserializations should/// use `deserialize_in_place`./// This method is stable and an official public API, but hidden from the/// documentation because it is almost never what newbies are looking for./// Showing it in rustdoc would cause it to be featured more prominently/// than it deserves./// standard library types. The complete list is [here][crate::de]. All of these/// can be deserialized using Serde out of the box./// in your program. See the [derive section of the manual][derive] for how to/// [derive]: https://serde.rs/derive.html/// # Lifetime/// The `'de` lifetime of this trait is the lifetime of data that may be/// borrowed by `Self` when deserialized. See the page [Understanding/// deserializer lifetimes] for a more detailed explanation of these lifetimes./// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html/// A data structure that can be deserialized without borrowing any data from/// the deserializer./// This is primarily useful for trait bounds on functions. For example a/// `from_str` function may be able to deserialize a data structure that borrows/// from the input string, but a `from_reader` function may only deserialize/// owned data./// # use serde::de::{Deserialize, DeserializeOwned};/// # use std::io::{Read, Result};/// # trait Ignore {/// fn from_str<'a, T>(s: &'a str) -> Result<T>///     T: Deserialize<'a>;/// fn from_reader<R, T>(rdr: R) -> Result<T>///     R: Read,///     T: DeserializeOwned;/// The relationship between `Deserialize` and `DeserializeOwned` in trait/// bounds is explained in more detail on the page [Understanding deserializer/// lifetimes]./// fn func<'de, T: Deserialize<'de>>() -> Result<T, Error>/// fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>/// borrowed by `Self::Value` when deserialized. See the page [Understanding/// use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};/// impl<'de, 'a, T> DeserializeSeed<'de> for ExtendVec<'a, T>///         impl<'de, 'a, T> Visitor<'de> for ExtendVecVisitor<'a, T>///         where///             T: Deserialize<'de>,///             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {///                 write!(formatter, "an array of integers")///             fn visit_seq<A>(self, mut seq: A) -> Result<(), A::Error>///             where///                 A: SeqAccess<'de>,///                 // Decrease the number of reallocations if there are many elements///                 if let Some(size_hint) = seq.size_hint() {///                     self.0.reserve(size_hint);///                 while let Some(elem) = seq.next_element()? {/// impl<'de, T> Visitor<'de> for FlattenedVecVisitor<T>///         write!(formatter, "an array of arrays")///     fn visit_seq<A>(self, mut seq: A) -> Result<Vec<T>, A::Error>///         while let Some(()) = seq.next_element_seed(ExtendVec(&mut vec))? {/// `Deserializer::deserialize_any` unless you need to be told by the/// `Deserializer::deserialize_any` means your data type will be able to/// deserialize from self-describing formats only, ruling out Postcard and/// Hint that the `Deserialize` type is expecting an `i128` value./// The default behavior unconditionally returns an error./// Hint that the `Deserialize` type is expecting an `u128` value./// indicate this to the `Deserializer` by using `deserialize_string`/// field or the discriminant of an enum variant./// Determine whether `Deserialize` implementations should expect to/// deserialize their human-readable form./// Some types have a human-readable form that may be somewhat expensive to/// construct, as well as a binary form that is compact and efficient./// Generally text-based formats like JSON and YAML will prefer to use the/// human-readable one and binary formats like Postcard will prefer the/// compact one./// # struct Timestamp;/// # impl Timestamp {/// #     const EPOCH: Timestamp = Timestamp;/// # impl FromStr for Timestamp {/// #     fn from_str(_: &str) -> Result<Self, Self::Err> {/// # struct Duration;/// # impl Duration {/// #     fn seconds(_: u64) -> Self { unimplemented!() }/// # impl Add<Duration> for Timestamp {/// #     type Output = Timestamp;/// #     fn add(self, _: Duration) -> Self::Output {/// use serde::de::{self, Deserialize, Deserializer};/// impl<'de> Deserialize<'de> for Timestamp {///         if deserializer.is_human_readable() {///             // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".///             let s = String::deserialize(deserializer)?;///             Timestamp::from_str(&s).map_err(de::Error::custom)///             // Deserialize from a compact binary representation, seconds since///             // the Unix epoch.///             let n = u64::deserialize(deserializer)?;///             Ok(Timestamp::EPOCH + Duration::seconds(n))/// The default implementation of this method returns `true`. Data formats/// may override this to `false` to request a compact form for types that/// support one. Note that modifying this method to change a format from/// human-readable to compact or vice versa should be regarded as a breaking/// change, as a value serialized in human-readable mode is not required to/// deserialize from the same data in compact mode.__deserialize_content_v1/// The role of this trait is to define the deserialization half of the [Serde/// data model], which is a way to categorize every Rust data type into one of/// 29 possible types. Each method of the `Deserializer` trait corresponds to one/// of the types of the data model.///  - **14 primitive types**///    - i8, i16, i32, i64, i128///    - u8, u16, u32, u64, u128///  - **string**///    - UTF-8 bytes with a length and no null terminator.///    - When serializing, all strings are handled equally. When deserializing,///      there are three flavors of strings: transient, owned, and borrowed.///  - **byte array** - \[u8\]///    - Similar to strings, during deserialization byte arrays can be///      transient, owned, or borrowed.///  - **option**///    - Either none or some value.///  - **unit**///    - The type of `()` in Rust. It represents an anonymous value containing///      no data.///  - **unit_struct**///    - For example `struct Unit` or `PhantomData<T>`. It represents a named///      value containing no data.///  - **unit_variant**///    - For example the `E::A` and `E::B` in `enum E { A, B }`.///  - **newtype_struct**///    - For example `struct Millimeters(u8)`.///  - **newtype_variant**///    - For example the `E::N` in `enum E { N(u8) }`.///  - **seq**///    - A variably sized heterogeneous sequence of values, for example `Vec<T>`///      or `HashSet<T>`. When serializing, the length may or may not be known///      before iterating through all the data. When deserializing, the length///      is determined by looking at the serialized data.///  - **tuple**///    - A statically sized heterogeneous sequence of values for which the///      length will be known at deserialization time without looking at the///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or///      `[u64; 10]`.///  - **tuple_struct**///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.///  - **tuple_variant**///    - For example the `E::T` in `enum E { T(u8, u8) }`.///  - **map**///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.///  - **struct**///    - A heterogeneous key-value pairing in which the keys are strings and///      will be known at deserialization time without looking at the serialized///      data, for example `struct S { r: u8, g: u8, b: u8 }`.///  - **struct_variant**///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`./// 1. The `deserialize_any` method. Self-describing data formats like JSON are///    able to look at the serialized data and tell what it represents. For///    example the JSON deserializer may see an opening curly brace (`{`) and///    know that it is seeing a map. If the data format supports///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever///    it to `serde_json::Value` by going through///    `Deserializer::deserialize_any`.///    Postcard need to be told what is in the input in order to deserialize it./// deserialize from self-describing formats only, ruling out Postcard and many/// others./// [Serde data model]: https://serde.rs/data-model.html/// borrowed from the input when deserializing. See the page [Understanding/// # Example implementation/// The [example data format] presented on the website contains example code for/// a basic JSON `Deserializer`./// [example data format]: https://serde.rs/data-format.html/// # struct S {/// #     max: usize,/// # impl<'de> serde::de::Visitor<'de> for S {/// The input contains a boolean./// The default implementation fails with a type error./// The input contains an `i8`./// The default implementation forwards to [`visit_i64`]./// [`visit_i64`]: #method.visit_i64/// The input contains an `i16`./// The input contains an `i32`./// The input contains an `i64`./// The input contains a `i128`./// The input contains a `u8`./// The default implementation forwards to [`visit_u64`]./// [`visit_u64`]: #method.visit_u64/// The input contains a `u16`./// The input contains a `u32`./// The input contains a `u64`./// The input contains a `u128`./// The input contains an `f32`./// The default implementation forwards to [`visit_f64`]./// [`visit_f64`]: #method.visit_f64/// The input contains an `f64`./// The input contains a `char`./// The default implementation forwards to [`visit_str`] as a one-character/// [`visit_str`]: #method.visit_str/// The input contains a string. The lifetime of the string is ephemeral and/// it may be destroyed after this method returns./// The input contains a string that lives at least as long as the/// This enables zero-copy deserialization of strings in some formats. For/// example JSON input containing the JSON string `"borrowed"` can be/// deserialized with zero copying into a `&'a str` as long as the input/// data outlives `'a`./// The default implementation forwards to `visit_str`./// The input contains a string and ownership of the string is being given/// to the `Visitor`./// The input contains a byte array. The lifetime of the byte array is/// ephemeral and it may be destroyed after this method returns./// The input contains a byte array that lives at least as long as the/// This enables zero-copy deserialization of bytes in some formats. For/// example Postcard data containing bytes can be deserialized with zero/// copying into a `&'a [u8]` as long as the input data outlives `'a`./// The default implementation forwards to `visit_bytes`./// The input contains a byte array and ownership of the byte array is being/// given to the `Visitor`./// The input contains an optional that is absent./// The input contains an optional that is present./// The input contains a unit `()`./// The input contains a newtype struct./// The content of the newtype struct may be read from the given/// The input contains a sequence of elements./// The input contains a key-value map./// The input contains an enum.// Used when deserializing a flattened Option field. Not public API./// The `'de` lifetime of this trait is the requirement for lifetime of data/// that may be borrowed by `Self::Value`. See the page [Understanding/// impl<'de> Visitor<'de> for LongString {///         E: de::Error,///             Err(de::Error::invalid_value(Unexpected::Str(s), &self))/// `SeqAccess::next_element` instead./// `SeqAccess` implementations should not override the default behavior./// Returns the number of elements remaining in the sequence, if known./// Provides a `Visitor` access to each element of a sequence in the input./// borrowed by deserialized sequence elements. See the page [Understanding/// The [example data format] presented on the website demonstrates an/// implementation of `SeqAccess` for a basic JSON data format./// `MapAccess::next_key` or `MapAccess::next_entry` instead./// `MapAccess::next_value` instead./// Calling `next_value_seed` before `next_key_seed` is incorrect and is/// allowed to panic or return bogus results.next_entry_seed/// `MapAccess` implementations should override the default behavior if a/// `MapAccess::next_entry` instead./// `MapAccess` implementations should not override the default behavior./// Calling `next_value` before `next_key` is incorrect and is allowed to/// panic or return bogus results./// Returns the number of entries remaining in the map, if known./// Provides a `Visitor` access to each entry of a map in the input./// borrowed by deserialized map entries. See the page [Understanding/// implementation of `MapAccess` for a basic JSON data format./// `variant` is called to identify which variant to deserialize./// `Deserialize` implementations should typically use `EnumAccess::variant`/// `EnumAccess` implementations should not override the default behavior./// Provides a `Visitor` access to the data of an enum in the input./// `EnumAccess` is created by the `Deserializer` and passed to the/// `Visitor` in order to identify which variant of an enum to deserialize./// borrowed by the deserialized enum variant. See the page [Understanding/// implementation of `EnumAccess` for a basic JSON data format./// deserialization. Must match the error type of our `EnumAccess`./// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};/// # struct X;/// # impl<'de> VariantAccess<'de> for X {/// fn unit_variant(self) -> Result<(), Self::Error> {/// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>/// #     where/// #         T: DeserializeSeed<'de>,/// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>/// #         V: Visitor<'de>,/// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>/// `VariantAccess::newtype_variant` instead./// #     fn unit_variant(self) -> Result<(), Self::Error> {/// fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>///     T: DeserializeSeed<'de>,/// `VariantAccess` implementations should not override the default/// fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>///     V: Visitor<'de>,///     Err(de::Error::invalid_type(unexp, &"tuple variant"))/// fn struct_variant<V>(///     self,///     _fields: &'static [&'static str],///     _visitor: V,/// ) -> Result<V::Value, Self::Error>///     Err(de::Error::invalid_type(unexp, &"struct variant"))/// `VariantAccess` is a visitor that is created by the `Deserializer` and/// implementation of `VariantAccess` for a basic JSON data format./// The type of the deserializer being converted into./// Converts an existing value into a `Deserializer` from which other values can/// be deserialized./// borrowed from the resulting `Deserializer`. See the page [Understanding/// use serde::de::{value, Deserialize, IntoDeserializer};/// use serde_derive::Deserialize;/// use std::str::FromStr;/// enum Setting {///     On,///     Off,/// impl FromStr for Setting {///     type Err = value::Error;///     fn from_str(s: &str) -> Result<Self, Self::Err> {///         Self::deserialize(s.into_deserializer())WithDecimalPoint//! The two most important traits in this module are [`Deserialize`] and//! [`Deserializer`].//! Serde provides [`Deserialize`] implementations for many Rust primitive and//! Additionally, Serde provides a procedural macro called [`serde_derive`] to//! automatically generate [`Deserialize`] implementations for structs and enums//! in your program. See the [derive section of the manual] for how to use this.//! In rare cases it may be necessary to implement [`Deserialize`] manually for//! some type in your program. See the [Implementing `Deserialize`] section of//! the manual for more about this.//! Third-party crates may provide [`Deserialize`] implementations for types//! that they expose. For example the [`linked-hash-map`] crate provides a//! [`LinkedHashMap<K, V>`] type that is deserializable by Serde because the//! crate provides an implementation of [`Deserialize`] for it.//! [`Deserializer`] implementations are provided by third-party crates, for//! example [`serde_json`], [`serde_yaml`] and [`postcard`].//! website][data formats].//! One example is `OsStr`.//!    - i8, i16, i32, i64, i128, isize//!    - u8, u16, u32, u64, u128, usize//!    - \[T; 0\] through \[T; 32\]//!    - Box\<\[T\]\>//!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*//!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*//!  - **Zero-copy types**://!    - &str//!    - &\[u8\]//!  - **FFI types**://!    - CString//!    - Box\<CStr\>//!    - OsString//!    - SystemTime//!    - RangeInclusive\<T\>//!    - Bound\<T\>//!    - num::NonZero*//!    - `!` *(unstable)*//! [Implementing `Deserialize`]: https://serde.rs/impl-deserialize.html//! [`Deserialize`]: crate::Deserialize//! [`Deserializer`]: crate::Deserializer//! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html//! [`postcard`]: https://github.com/jamesmunns/postcard//! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map//! [`serde_derive`]: https://crates.io/crates/serde_derive//! [`serde_json`]: https://github.com/serde-rs/json//! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml//! [derive section of the manual]: https://serde.rs/derive.html//! [data formats]: https://serde.rs/#data-formatsimpl_copy_clone// For structs that contain a PhantomData. We do not want the trait// bound `E: Clone` inferred by derive(Clone)./// A minimal representation of all possible errors that can occur using the/// `IntoDeserializer` trait./// A deserializer holding a `()`.NeverDeserializer/// A deserializer that cannot be instantiated./// A deserializer holding a `u32`./// A deserializer holding a `&str`./// A deserializer holding a `&str` with a lifetime tied to another/// deserializer./// Create a new borrowed deserializer from the given string./// A deserializer holding a `String`./// A deserializer holding a `Cow<str>`./// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`]./// Create a new deserializer from the given bytes.BorrowedBytesDeserializer/// A deserializer holding a `&[u8]` with a lifetime tied to another/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`]./// Create a new borrowed deserializer from the given borrowed bytes./// A deserializer that iterates over a sequence./// Construct a new `SeqDeserializer<I, E>`.SeqAccessDeserializer/// A deserializer holding a `SeqAccess`./// Construct a new `SeqAccessDeserializer<A>`./// A deserializer that iterates over a map./// Construct a new `MapDeserializer<I, E>`.// Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`.// Used in the `impl SeqAccess for MapDeserializer` to visit the map as aMapAccessDeserializer/// A deserializer holding a `MapAccess`./// Construct a new `MapAccessDeserializer<A>`.MapAsEnumEnumAccessDeserializer/// A deserializer holding an `EnumAccess`./// Construct a new `EnumAccessDeserializer<A>`.map_as_enumSeedTupleVariantSeedStructVariant//! Building blocks for deserializing basic values using the `IntoDeserializer`//! trait.//! ```edition2021//! use serde::de::{value, Deserialize, IntoDeserializer};//! use serde_derive::Deserialize;//! use std::str::FromStr;//! enum Setting {//!     On,//!     Off,//! impl FromStr for Setting {//!     type Err = value::Error;//!     fn from_str(s: &str) -> Result<Self, Self::Err> {//!         Self::deserialize(s.into_deserializer())// clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704// clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768// not available in our oldest supported compiler// https://github.com/rust-lang/rust-clippy/issues/8772// integer and float ser/de requires these sorts of casts// things are often more readable this way// correctly used// not practical// preference// false positive// noisy__require_serde_not_serde_core//! The `serde_core` crate contains Serde's trait definitions with **no support//! for #\[derive()\]**.//! In crates that derive an implementation of `Serialize` or `Deserialize`, you//! must depend on the [`serde`] crate, not `serde_core`.//! In crates that handwrite implementations of Serde traits, or only use them//! as trait bounds, depending on `serde_core` is permitted. But `serde`//! re-exports all of these traits and can be used for this use case too. If in//! doubt, disregard `serde_core` and always use `serde`.//! Crates that depend on `serde_core` instead of `serde` are able to compile in//! parallel with `serde_derive` even when `serde`'s "derive" feature is turned on,//! as shown in the following build timings.//! <tr><td align="center">When <code>serde_json</code> depends on <code>serde</code></td></tr>//! <tr><td><img src="https://github.com/user-attachments/assets/78dc179c-6ab1-4059-928c-1474b0d9d0bb"></td></tr>//! <tr><td align="center">When <code>serde_json</code> depends on <code>serde_core</code></td></tr>//! <tr><td><img src="https://github.com/user-attachments/assets/6b6cff5e-3e45-4ac7-9db1-d99ee8b9f5f7"></td></tr>// Serde types in rustdoc of other crates get linked to here.// Support using Serde without the standard library!// Show which crate feature enables conditionally compiled APIs in documentation.// Unstable functionality only if the user asks for it. For tracking and// discussion of these features please refer to this issue://    https://github.com/serde-rs/serde/issues/812// Ignored clippy and clippy_pedantic lints// Restrictions// Rustc lints.// This case must be after the previous one./// Some [`Deserializer`] implementations for self-describing formats do not/// care what hint the [`Visitor`] gives them, they just want to blindly call/// the [`Visitor`] method corresponding to the data they can tell is in the/// input. This requires repetitive implementations of all the [`Deserializer`]/// # use serde::forward_to_deserialize_any;/// # struct MyDeserializer;/// # impl<'de> Deserializer<'de> for MyDeserializer {/// #     fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>/// #     {///     self.deserialize_any(visitor)/// #     forward_to_deserialize_any! {/// #         i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string/// #         bytes byte_buf option unit unit_struct newtype_struct seq tuple/// #         tuple_struct map struct enum identifier ignored_any/// The `forward_to_deserialize_any!` macro implements these simple forwarding/// methods so that they forward directly to [`Deserializer::deserialize_any`]./// You can choose which methods to forward./// impl<'de> Deserializer<'de> for MyDeserializer {///     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>///         V: Visitor<'de>,///     forward_to_deserialize_any! {///         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string///         bytes byte_buf option unit unit_struct newtype_struct seq tuple///         tuple_struct map struct enum identifier ignored_any/// The macro assumes the convention that your `Deserializer` lifetime parameter/// is called `'de` and that the `Visitor` type parameters on each method are/// called `V`. A different type parameter and a different lifetime can be/// specified explicitly if necessary./// # struct MyDeserializer<V>(PhantomData<V>);/// # impl<'q, V> Deserializer<'q> for MyDeserializer<V> {/// #     fn deserialize_any<W>(self, visitor: W) -> Result<W::Value, Self::Error>/// #         W: Visitor<'q>,/// forward_to_deserialize_any! {///     <W: Visitor<'q>>///     bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string///     bytes byte_buf option unit unit_struct newtype_struct seq tuple///     tuple_struct map struct enum identifier ignored_any/// [`Deserializer`]: crate::Deserializer/// [`Visitor`]: crate::de::Visitor/// [`Deserializer::deserialize_any`]: crate::Deserializer::deserialize_anyforward_to_deserialize_any_methodforward_to_deserialize_any_helper// Used from generated code to buffer the contents of the Deserializer when// deserializing untagged enums and internally tagged enums.// Not public API. Use serde-value instead.// Obsoleted by format-specific buffer types (https://github.com/serde-rs/serde/pull/2912).__private_serialize__serialize_unimplemented__serialize_unimplemented_method__serialize_unimplemented_helper// Used only by Serde doc tests. Not public API.// FIXME: #[cfg(doctest)] once https://github.com/rust-lang/rust/issues/67295 is fixed./// A DeserializeSeed helper for implementing deserialize_in_place Visitors./// Wraps a mutable reference and calls deserialize_in_place on it.from_bounds// The generated code calls this like://     let value = &_serde::__private::from_utf8_lossy(bytes);//     Err(_serde::de::Error::unknown_variant(value, VARIANTS))// so it is okay for the return type to be different from the std case as long// as the above works.fmt_primitives/// use serde::ser::Serialize;/// use serde_derive::Serialize;/// use std::fmt::{self, Display};/// #[serde(rename_all = "kebab-case")]/// pub enum MessageType {///     StartRequest,///     EndRequest,/// impl Display for MessageType {///         self.serialize(f)primitive_impl// Does not require T: Serialize./// This impl requires the [`"rc"`] Cargo feature of Serde.nonzero_integers/// Serialize a value that implements `Display` as a string, when that string is/// statically known to never have more than a constant `MAX_LEN` bytes./// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.format_u8test_format_u8/// corresponding to the [`Serializer`] compound types: [`SerializeSeq`],/// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],/// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`]./// # use serde::ser::{Serializer, Impossible};/// # use serde_core::__private::doc::Error;/// # struct MySerializer;/// #         stringify! {/// #         };/// #     serde_core::__serialize_unimplemented! {/// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some/// #         unit unit_struct unit_variant newtype_struct newtype_variant/// #         tuple tuple_struct tuple_variant map struct struct_variant/// [`Serializer`]: crate::Serializer/// [`SerializeSeq`]: crate::ser::SerializeSeq/// [`SerializeTuple`]: crate::ser::SerializeTuple/// [`SerializeTupleStruct`]: crate::ser::SerializeTupleStruct/// [`SerializeTupleVariant`]: crate::ser::SerializeTupleVariant/// [`SerializeMap`]: crate::ser::SerializeMap/// [`SerializeStruct`]: crate::ser::SerializeStruct/// [`SerializeStructVariant`]: crate::ser::SerializeStructVariant/// See the [Implementing `Serialize`] section of the manual for more/// information about how to implement this method./// use serde::ser::{Serialize, SerializeStruct, Serializer};/// struct Person {///     age: u8,///     phones: Vec<String>,/// // This is what #[derive(Serialize)] would generate./// impl Serialize for Person {///         S: Serializer,///         let mut s = serializer.serialize_struct("Person", 3)?;///         s.serialize_field("name", &self.name)?;///         s.serialize_field("age", &self.age)?;///         s.serialize_field("phones", &self.phones)?;///         s.end()/// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html/// standard library types. The complete list is [here][crate::ser]. All of/// these can be serialized using Serde out of the box./// Additionally, Serde provides a procedural macro called [`serde_derive`] to/// your program. See the [derive section of the manual] for how to use this./// type in your program. See the [Implementing `Serialize`] section of the/// manual for more about this./// they expose. For example the [`linked-hash-map`] crate provides a/// [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate/// [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html/// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map/// [`serde_derive`]: https://crates.io/crates/serde_derive/// [derive section of the manual]: https://serde.rs/derive.html/// should set `Ok = ()` and serialize into an [`io::Write`] or buffer/// Type returned from [`serialize_seq`] for serializing the content of the/// [`serialize_seq`]: #tymethod.serialize_seq/// Type returned from [`serialize_tuple`] for serializing the content of/// the tuple./// [`serialize_tuple`]: #tymethod.serialize_tuple/// Type returned from [`serialize_tuple_struct`] for serializing the/// content of the tuple struct./// [`serialize_tuple_struct`]: #tymethod.serialize_tuple_struct/// Type returned from [`serialize_tuple_variant`] for serializing the/// content of the tuple variant./// [`serialize_tuple_variant`]: #tymethod.serialize_tuple_variant/// Type returned from [`serialize_map`] for serializing the content of the/// [`serialize_map`]: #tymethod.serialize_map/// Type returned from [`serialize_struct`] for serializing the content of/// the struct./// [`serialize_struct`]: #tymethod.serialize_struct/// Type returned from [`serialize_struct_variant`] for serializing the/// [`serialize_struct_variant`]: #tymethod.serialize_struct_variant/// # use serde::Serializer;/// # serde_core::__private_serialize!();/// impl Serialize for bool {///         serializer.serialize_bool(*self)/// impl Serialize for i8 {///         serializer.serialize_i8(*self)/// impl Serialize for i16 {///         serializer.serialize_i16(*self)/// impl Serialize for i32 {///         serializer.serialize_i32(*self)/// impl Serialize for i64 {///         serializer.serialize_i64(*self)/// Serialize an `i128` value./// impl Serialize for i128 {///         serializer.serialize_i128(*self)/// impl Serialize for u8 {///         serializer.serialize_u8(*self)/// impl Serialize for u16 {///         serializer.serialize_u16(*self)/// impl Serialize for u32 {///         serializer.serialize_u32(*self)/// impl Serialize for u64 {///         serializer.serialize_u64(*self)/// Serialize a `u128` value./// impl Serialize for u128 {///         serializer.serialize_u128(*self)/// impl Serialize for f32 {///         serializer.serialize_f32(*self)/// impl Serialize for f64 {///         serializer.serialize_f64(*self)/// impl Serialize for char {///         serializer.serialize_char(*self)/// impl Serialize for str {///         serializer.serialize_str(self)/// # use serde::ser::{Serializer, SerializeSeq};/// # impl Serializer for MySerializer {/// #     type Ok = ();/// #     type Error = Error;/// fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {///     let mut seq = self.serialize_seq(Some(v.len()))?;///     for b in v {///         seq.serialize_element(b)?;///     seq.end()/// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str none some/// #         seq tuple tuple_struct tuple_variant map struct struct_variant/// Serialize a [`None`] value./// # enum Option<T> {/// #     Some(T),/// #     None,/// # use self::Option::{Some, None};/// impl<T> Serialize for Option<T>///     T: Serialize,///         match *self {///             Some(ref value) => serializer.serialize_some(value),///             None => serializer.serialize_none(),/// [`None`]: core::option::Option::None/// Serialize a [`Some(T)`] value./// [`Some(T)`]: core::option::Option::Some/// impl Serialize for () {///         serializer.serialize_unit()/// use serde::{Serialize, Serializer};/// struct Nothing;/// impl Serialize for Nothing {///         serializer.serialize_unit_struct("Nothing")/// impl Serialize for E {///             E::A => serializer.serialize_unit_variant("E", 0, "A"),///             E::B => serializer.serialize_unit_variant("E", 1, "B"),/// struct Millimeters(u8);/// impl Serialize for Millimeters {///         serializer.serialize_newtype_struct("Millimeters", &self.0)///     M(String),///     N(u8),///             E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),///             E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),/// Begin to serialize a variably sized sequence. This call must be/// # struct Vec<T>(PhantomData<T>);/// # impl<T> Vec<T> {/// #     fn len(&self) -> usize {/// # impl<'a, T> IntoIterator for &'a Vec<T> {/// #     type Item = &'a T;/// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;/// #     fn into_iter(self) -> Self::IntoIter {/// use serde::ser::{Serialize, SerializeSeq, Serializer};/// impl<T> Serialize for Vec<T>///         let mut seq = serializer.serialize_seq(Some(self.len()))?;///         for element in self {///             seq.serialize_element(element)?;///         seq.end()/// use serde::ser::{Serialize, SerializeTuple, Serializer};/// # mod fool {/// #     trait Serialize {}/// impl<A, B, C> Serialize for (A, B, C)/// #     {}/// # struct Tuple3<A, B, C>(A, B, C);/// # impl<A, B, C> Serialize for Tuple3<A, B, C>///     A: Serialize,///     B: Serialize,///     C: Serialize,///         let mut tup = serializer.serialize_tuple(3)?;///         tup.serialize_element(&self.0)?;///         tup.serialize_element(&self.1)?;///         tup.serialize_element(&self.2)?;///         tup.end()/// const VRAM_SIZE: usize = 386;/// struct Vram([u16; VRAM_SIZE]);/// impl Serialize for Vram {///         let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;///         for element in &self.0[..] {/// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};/// struct Rgb(u8, u8, u8);/// impl Serialize for Rgb {///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;///         ts.serialize_field(&self.0)?;///         ts.serialize_field(&self.1)?;///         ts.serialize_field(&self.2)?;///         ts.end()/// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};///     T(u8, u8),///     U(String, u32, u32),///             E::T(ref a, ref b) => {///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;///                 tv.serialize_field(a)?;///                 tv.serialize_field(b)?;///                 tv.end()///             E::U(ref a, ref b, ref c) => {///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;///                 tv.serialize_field(c)?;/// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);/// # impl<K, V> HashMap<K, V> {/// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {/// #     type Item = (&'a K, &'a V);/// #     type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)>>;/// use serde::ser::{Serialize, SerializeMap, Serializer};/// impl<K, V> Serialize for HashMap<K, V>///     K: Serialize,///     V: Serialize,///         let mut map = serializer.serialize_map(Some(self.len()))?;///         for (k, v) in self {///             map.serialize_entry(k, v)?;///         map.end()/// data fields that will be serialized. `len` does not include fields/// which are skipped with [`SerializeStruct::skip_field`]./// struct Rgb {///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;///         rgb.serialize_field("r", &self.r)?;///         rgb.serialize_field("g", &self.g)?;///         rgb.serialize_field("b", &self.b)?;///         rgb.end()/// `len` does not include fields which are skipped with/// [`SerializeStructVariant::skip_field`]./// use serde::ser::{Serialize, SerializeStructVariant, Serializer};///     S { r: u8, g: u8, b: u8 },///             E::S {///                 ref r,///                 ref g,///                 ref b,///             } => {///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;///                 sv.serialize_field("r", r)?;///                 sv.serialize_field("g", g)?;///                 sv.serialize_field("b", b)?;///                 sv.end()/// using [`serialize_seq`]. Implementors should not need to override this/// struct SecretlyOneHigher {///     data: Vec<i32>,/// impl Serialize for SecretlyOneHigher {///         serializer.collect_seq(self.data.iter().map(|x| x + 1))/// using [`serialize_map`]. Implementors should not need to override this/// use std::collections::BTreeSet;/// struct MapToUnit {///     keys: BTreeSet<i32>,/// // Serializes as a map in which the values are all unit./// impl Serialize for MapToUnit {///         serializer.collect_map(self.keys.iter().map(|k| (k, ())))/// The default implementation builds a heap-allocated [`String`] and/// delegates to [`serialize_str`]. Serializers are encouraged to provide a///         serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset()))/// [`serialize_str`]: Self::serialize_str/// Serializers that use `no_std` are required to provide an implementation/// of this method. If no more sensible behavior is possible, the/// implementation is expected to return an error./// Determine whether `Serialize` implementations should serialize in/// human-readable form./// #     fn seconds_since_epoch(&self) -> u64 { unimplemented!() }/// # impl Display for Timestamp {/// impl Serialize for Timestamp {///         if serializer.is_human_readable() {///             // Serialize to a human-readable string "2015-05-15T17:01:00Z".///             self.to_string().serialize(serializer)///             // Serialize to a compact binary representation.///             self.seconds_since_epoch().serialize(serializer)/// The role of this trait is to define the serialization half of the [Serde/// data model], which is a way to categorize every Rust data structure into one/// of 29 possible types. Each method of the `Serializer` trait corresponds to/// one of the types of the data model.///    - A variably sized heterogeneous sequence of values, for example///      `Vec<T>` or `HashSet<T>`. When serializing, the length may or may not///      be known before iterating through all the data. When deserializing,///      the length is determined by looking at the serialized data.///      will be known at deserialization time without looking at the///      serialized data, for example `struct S { r: u8, g: u8, b: u8 }`./// JSON or Postcard. This is not a requirement of the `Serializer` trait, and/// a basic JSON `Serializer`./// Returned from `Serializer::serialize_seq`./// # Example use/// implementation of `SerializeSeq` for a basic JSON data format./// # struct Array<T>(PhantomData<T>);/// # impl<T> Array<T> {/// # impl<'a, T> IntoIterator for &'a Array<T> {/// impl<T> Serialize for [T; 16]/// # impl<T> Serialize for Array<T>///         let mut seq = serializer.serialize_tuple(16)?;/// implementation of `SerializeTuple` for a basic JSON data format./// implementation of `SerializeTupleStruct` for a basic JSON data format./// implementation of `SerializeTupleVariant` for a basic JSON data format./// If possible, `Serialize` implementations are encouraged to use/// `serialize_entry` instead as it may be implemented more efficiently in/// some formats compared to a pair of calls to `serialize_key` and/// `serialize_value`./// Calling `serialize_value` before `serialize_key` is incorrect and is/// allowed to panic or produce bogus results./// Some [`Serialize`] types are not able to hold a key and value in memory/// at the same time so `SerializeMap` implementations are required to/// support [`serialize_key`] and [`serialize_value`] individually. The/// where key and value are both available. [`Serialize`] implementations/// are encouraged to use `serialize_entry` if possible./// The default implementation delegates to [`serialize_key`] and/// [`serialize_value`]. This is appropriate for serializers that do not/// care about performance or are not able to optimize `serialize_entry` any/// [`Serialize`]: crate::Serialize/// [`serialize_key`]: Self::serialize_key/// [`serialize_value`]: Self::serialize_value/// implementation of `SerializeMap` for a basic JSON data format./// Indicate that a struct field has been skipped./// The default implementation does nothing./// implementation of `SerializeStruct` for a basic JSON data format./// Indicate that a struct variant field has been skipped./// implementation of `SerializeStructVariant` for a basic JSON data format.//! The two most important traits in this module are [`Serialize`] and//! [`Serializer`].//! Serde provides [`Serialize`] implementations for many Rust primitive and//! automatically generate [`Serialize`] implementations for structs and enums//! In rare cases it may be necessary to implement [`Serialize`] manually for//! some type in your program. See the [Implementing `Serialize`] section of the//! manual for more about this.//! Third-party crates may provide [`Serialize`] implementations for types that//! they expose. For example the [`linked-hash-map`] crate provides a//! [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate//! provides an implementation of [`Serialize`] for it.//! [`Serializer`] implementations are provided by third-party crates, for//!    - \[T\]//!    - CStr//!    - OsStr//! [Implementing `Serialize`]: https://serde.rs/impl-serialize.html//! [`Serialize`]: crate::Serialize//! [`Serializer`]: crate::Serializer/// The underlying cause of this error, if any./// Either a re-export of std::error::Error or a new identical trait, depending/// on whether Serde's "std" feature is enabled./// Serde's error traits [`serde::ser::Error`] and [`serde::de::Error`] require/// [`std::error::Error`] as a supertrait, but only when Serde is built with/// "std" enabled. Data formats that don't care about no\_std support should/// generally provide their error types with a `std::error::Error` impl/// directly:/// struct MySerError {...}/// impl serde::ser::Error for MySerError {...}/// impl std::fmt::Display for MySerError {...}/// // We don't support no_std!/// impl std::error::Error for MySerError {}/// Data formats that *do* support no\_std may either have a "std" feature of/// their own:/// [features]/// std = ["serde/std"]/// #[cfg(feature = "std")]/// ... or else provide the std Error impl unconditionally via Serde's/// re-export:/// impl serde::ser::StdError for MySerError {}"
This macro has no effect on any version of Serde released in the past 2 years.
It was used long ago in crates that needed to support Rustc older than 1.26.0,
or Emscripten targets older than 1.40.0, which did not yet have 128-bit integer
support. These days Serde requires a Rust compiler newer than that so 128-bit
integers are always supported.
"r" A facade around all the types we need from the `std`, `core`, and `alloc`"r" crates. This avoids elaborate import wrangling having to happen in every"FmtWritetri__private228serde_core_privateinteger128// Re-export #[derive(Serialize, Deserialize)].// The reason re-exporting is not enabled by default is that disabling it would// be annoying for crates that provide handwritten impls or data formats. They// would need to disable default features and then explicitly re-enable std./// Derive macro available if serde is built with `features = ["derive"]`.//! See the Serde website <https://serde.rs> for additional documentation and//! ## Design//! Serde's `Serialize` and `Deserialize` traits (or uses Serde's derive//! attribute to automatically generate implementations at compile time). This//! serialization to perform the same speed as a handwritten serializer for the//! specific selection of data structure and data format.//! ## Data formats//! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.//! - [CBOR], a Concise Binary Object Representation designed for small message//!   size without the need for version negotiation.//! - [YAML], a self-proclaimed human-friendly configuration language that ain't//!   markup language.//! - [MessagePack], an efficient binary format that resembles a compact JSON.//! - [TOML], a minimal configuration format used by [Cargo].//! - [Pickle], a format common in the Python world.//! - [RON], a Rusty Object Notation.//! - [BSON], the data storage and network transfer format used by MongoDB.//! - [Avro], a binary format used within Apache Hadoop, with support for schema//!   definition.//! - [JSON5], a superset of JSON including some productions from ES5.//! - [URL] query strings, in the x-www-form-urlencoded format.//! - [Starlark], the format used for describing build targets by the Bazel and//!   Buck build systems. *(serialization only)*//! - [Envy], a way to deserialize environment variables into Rust structs.//! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into//!   Rust structs. *(deserialization only)*//! - [S-expressions], the textual representation of code and data used by the//!   Lisp language family.//! - [D-Bus]'s binary wire format.//! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy//!   serialization format.//! - [Bencode], a simple binary format used in the BitTorrent protocol.//! - [Token streams], for processing Rust procedural macro input.//! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to//!   and from DynamoDB.//! - [Hjson], a syntax extension to JSON designed around human reading and//!   editing. *(deserialization only)*//! - [CSV], Comma-separated values is a tabular text file format.//! [JSON]: https://github.com/serde-rs/json//! [Postcard]: https://github.com/jamesmunns/postcard//! [CBOR]: https://github.com/enarx/ciborium//! [YAML]: https://github.com/dtolnay/serde-yaml//! [MessagePack]: https://github.com/3Hren/msgpack-rust//! [TOML]: https://docs.rs/toml//! [Pickle]: https://github.com/birkenfeld/serde-pickle//! [RON]: https://github.com/ron-rs/ron//! [BSON]: https://github.com/mongodb/bson-rust//! [Avro]: https://docs.rs/apache-avro//! [JSON5]: https://github.com/callum-oakley/json5-rs//! [URL]: https://docs.rs/serde_qs//! [Starlark]: https://github.com/dtolnay/serde-starlark//! [Envy]: https://github.com/softprops/envy//! [Envy Store]: https://github.com/softprops/envy-store//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html//! [S-expressions]: https://github.com/rotty/lexpr-rs//! [D-Bus]: https://docs.rs/zvariant//! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers//! [Bencode]: https://github.com/P3KI/bendy//! [Token streams]: https://github.com/oxidecomputer/serde_tokenstream//! [DynamoDB Items]: https://docs.rs/serde_dynamo//! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb//! [Hjson]: https://github.com/Canop/deser-hjson//! [CSV]: https://docs.rs/csvcontent_as_strTagContentOtherFieldTagContentOtherFieldVisitorborrow_cow_strborrow_cow_bytescontent_clonecontent_unexpected/// Serves as a seed for deserializing a key of internally tagged enum./// Cannot capture externally tagged enums, `i128` and `u128`./// Captures map or sequence from the original deserializer and searches/// a tag in it (in case of sequence, tag is the first element of sequence)./// Visitor for the content of an internally tagged enum with the given/// tag name./// Name of the tag field of the adjacently tagged enum/// Name of the content field of the adjacently tagged enum/// Used by generated code to deserialize an adjacently tagged enum when/// ignoring unrelated fields is allowed.deserialize_integerdeserialize_floatvisit_content_seqvisit_content_map/// Used when deserializing an internally tagged enum because the content/// will be used exactly once.visit_content_seq_refvisit_content_map_ref/// Used when deserializing an untagged enum because the content may need/// to be used more than once.PairRefDeserializerPairRefVisitor// This module is private and nothing here should be used outside ofIdentifierDeserializer// Like `IntoDeserializer` but also implemented for `&[u8]`. This is used for// the newtype fallthrough case of `field_identifier`.//    #[serde(field_identifier)]//    enum F {//        A,//        B,//        Other(String), // deserialized using IdentifierDeserializerFlatMapDeserializerdeserialize_otherforward_to_deserialize_otherpending_contentFlatMapAccessFlatStructAccessflat_map_take_entry/// Claims one key-value pair from a FlatMapDeserializer's field buffer if the/// field name matches any of the recognized ones.fields_enumAdjacentlyTaggedEnumVariantSeedAdjacentlyTaggedEnumVariantVisitor/// Used to check that serde(getter) attributes return the expected type.FlatMapSerializerFlatMapSerializeMapFlatMapSerializeStructFlatMapSerializeTupleVariantAsMapValueFlatMapSerializeStructVariantAsMapValueAdjacentlyTaggedEnumVariantCannotSerializeVariant// Error when Serialize for a non_exhaustive remote enum encounters a variant// that is not recognized.r" Raised when there is general error when deserializing a type."r" The message should not be capitalized and should not end with a period."r" ```edition2021"r" # struct IpAddr;"r" # impl FromStr for IpAddr {"r" #     type Err = String;"r" #     fn from_str(_: &str) -> Result<Self, String> {"r" #         unimplemented!()"r" use serde::de::{self, Deserialize, Deserializer};"r" impl<'de> Deserialize<'de> for IpAddr {"r"     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>"r"     where"r"         D: Deserializer<'de>,"r"     {"r"         let s = String::deserialize(deserializer)?;"r"         s.parse().map_err(de::Error::custom)"r" Raised when a `Deserialize` receives a type different from what it was"r" expecting."r" The `unexp` argument provides information about what type was received."r" This is the type that was present in the input file or other source data"r" of the Deserializer."r" The `exp` argument provides information about what type was being"r" expected. This is the type that is written in the program."r" For example if we try to deserialize a String out of a JSON file"r" containing an integer, the unexpected type is the integer and the"r" expected type is the string."r" Raised when a `Deserialize` receives a value of the right type but that"r" is wrong for some other reason."r" The `unexp` argument provides information about what value was received."r" This is the value that was present in the input file or other source"r" data of the Deserializer."r" The `exp` argument provides information about what value was being"r" For example if we try to deserialize a String out of some binary data"r" that is not valid UTF-8, the unexpected value is the bytes and the"r" expected value is a string."r" Raised when deserializing a sequence or map and the input data contains"r" too many or too few elements."r" The `len` argument is the number of elements encountered. The sequence"r" or map may have expected more arguments or fewer arguments."r" The `exp` argument provides information about what data was being"r" expected. For example `exp` might say that a tuple of size 6 was"r" expected."r" Raised when a `Deserialize` enum type received a variant with an"r" unrecognized name."r" Raised when a `Deserialize` struct type received a field with an"r" Raised when a `Deserialize` struct type expected to receive a required"r" field with a particular name but that field was not present in the"r" input."r" Raised when a `Deserialize` struct type received more than one of the"r" same field."r" The `Error` trait allows `Deserialize` implementations to create descriptive"r" error messages belonging to the `Deserializer` against which they are"r" currently running."r" Every `Deserializer` declares an `Error` type that encompasses both"r" general-purpose deserialization errors as well as errors specific to the"r" particular deserialization format. For example the `Error` type of"r" `serde_json` can represent errors like an invalid JSON escape sequence or an"r" unterminated string literal, in addition to the error cases that are part of"r" this trait."r" Most deserializers should only need to provide the `Error::custom` method"r" and inherit the default behavior for the other methods."r" # Example implementation"r" The [example data format] presented on the website shows an error"r" type appropriate for a basic JSON data format."r" [example data format]: https://serde.rs/data-format.html""A deserializer holding""a `bool`.""an `i8`.""an `i16`.""an `i32`.""an `i64`.""an `i128`."I128Deserializer"an `isize`.""a `u8`.""a `u16`.""a `u64`.""a `u128`."U128Deserializer"a `usize`.""an `f32`.""an `f64`.""a `char`."010203040506070809r" Used when a [`Serialize`] implementation encounters any error"r" while serializing a type."r" The message should not be capitalized and should not end with a"r" period."r" For example, a filesystem [`Path`] may refuse to serialize"r" itself if it contains invalid UTF-8 data."r" # struct Path;"r" # impl Path {"r" #     fn to_str(&self) -> Option<&str> {"r" use serde::ser::{self, Serialize, Serializer};"r" impl Serialize for Path {"r"     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>"r"         S: Serializer,"r"         match self.to_str() {"r"             Some(s) => serializer.serialize_str(s),"r#"             None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),"#r" [`Path`]: std::path::Path"r" [`Serialize`]: crate::Serialize"r" Trait used by `Serialize` implementations to generically construct"r" errors belonging to the `Serializer` against which they are"// Remove the default from every type parameter because in the generated impls// they look like associated types: "error: associated type bindings are not// allowed here".with_where_predicates_from_variants// Puts the given bound on any generic type parameters that are used in fields// for which filter returns true.// For example, the following struct needs the bound `A: Serialize, B:// Serialize`.//     struct S<'b, A, B: 'b, C> {//         a: A,//         b: Option<&'b B>//         #[serde(skip_serializing)]//         c: C,with_self_boundwith_lifetime_boundtype_of_itemenum_adjacentlyenum_externallyenum_internallyenum_untaggedfield_iFieldWithAliasesStmts/// Generates `Deserialize::deserialize` body for an `enum Enum {...}`deserialize_homogeneous_enumprepare_enum_variant_enum/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(tag, content)]` attributes//! Deserialization for adjacently tagged enums://! #[serde(tag = "...", content = "...")]//! enum Enum {}expr_is_missingunwrap_to_variant_closurewrap_deserialize_field_withwrap_deserialize_withStructFormTupleForm/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` without additional attributesdeserialize_externally_tagged_variantwrap_deserialize_variant_withdeserialize_externally_tagged_newtype_variant//! Deserialization for externally tagged enums:effective_style/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(tag)]` attributedeserialize_internally_tagged_variant// Generates significant part of the visit_seq and visit_map bodies of visitors// for the variants of internally tagged enum.//! Deserialization for internally tagged enums://! #[serde(tag = "...")]/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(untagged)]` attribute// Also used by adjacently tagged enumsdeserialize_newtype_variant// Also used by internally tagged enums// Implicitly (via `generate_variant`) used by adjacently tagged enums//! Deserialization for untagged enums://! #[serde(untagged)]deserialize_custom// Generates `Deserialize::deserialize` body for an enum with// `serde(field_identifier)` or `serde(variant_identifier)` attribute.deserialize_generated//! Deserialization of struct field identifiers and enum variant identifiers by//! way of a Rust enum.has_flatten/// Generates `Deserialize::deserialize` body for a `struct Struct {...}`deserialize_field_identifier/// Generates enum and its `Deserialize` implementation that represents each/// non-skipped field of the struct/// Generates `Deserialize::deserialize` body for a `struct Tuple(...);` including `struct Newtype(T);`/// Generates `Deserialize::deserialize` body for a `struct Unit;`allow_deprecatedreplace_receiverCtxtDerivepretendexpand_derive_deserializepreconditionprecondition_sizedprecondition_no_de_lifetime/// Name of the type the `derive` is on.this_type/// Path to the type the impl is for. Either a single `Ident` for local/// types (does not include generic parameters) or `some::remote::Path` for/// remote types.this_value/// Same as `this_type` but using `::<T>` for generic parameters for use in/// expression position./// Generics including any explicit and inferred bounds for the impl.BorrowedLifetimes/// Lifetimes borrowed from the deserializer. These will become bounds on/// the `'de` lifetime of the deserializer.has_getter/// At least one field has a serde(getter) attribute, implying that the/// remote type has a private field./// Type has a repr(packed) attribute./// Type name to use in error messages and `&'static str` arguments to/// various Deserializer methods.generics_with_de_lifetimeDeImplGenericsDeTypeGenericsTypeGenerics/// Split the data structure's generics into the pieces to use for its/// `Deserialize` impl, augmented with an additional `'de` lifetime for use/// as the `Deserialize` trait's lifetime.build_generics// All the generics in the input, plus a bound `T: Deserialize` for each generic// field type that will be deserialized by us, plus a bound `T: Default` for// each generic field type that will be set to a default value.needs_deserialize_bound// Fields with a `skip_deserializing` or `deserialize_with` attribute, or which// belong to a variant with a `skip_deserializing` or `deserialize_with`// attribute, are not deserialized by us so we do not generate a bound. Fields// with a `bound` attribute specify their own bound so we do not generate one.// All other fields may need a `T: Deserialize` bound where T is the type of the// field.requires_default// Fields with a `default` attribute (not `default=...`), and fields with a// `skip_deserializing` attribute that do not also have `default=...`.de_lifetimede_lifetime_paramborrowed_lifetimes// The union of lifetimes borrowed by each field of the container.// These turn into bounds on the `'de` lifetime of the Deserialize impl. If// lifetimes `'a` and `'b` are borrowed but `'c` is not, the impl is://     impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for S<'a, 'b, 'c>// If any borrowed lifetime is `'static`, then `'de: 'static` would be redundant// and we use plain `'static` instead of `'de`.deserialize_bodydeserialize_in_place_bodydeserialize_transparent/// Generates `Deserialize::deserialize` body for a type with `#[serde(transparent)]` attribute/// Generates `Deserialize::deserialize` body for a type with `#[serde(from)]` attributedeserialize_try_from/// Generates `Deserialize::deserialize` body for a type with `#[serde(try_from)]` attributeExternallyTagged/// Contains a variant nameUntaggedInternallyTagged/// This function wraps the expression in `#[serde(deserialize_with = "...")]`/// in a trait to prevent it from accessing the internal `Deserialize` state.// Generates closure that converts single input parameter to the final value.expr_is_missing_seq/// True if there is any field with a `#[serde(flatten)]` attribute, other than/// fields which are skipped.de_type_generics_to_tokensshould_allow_deprecated/// Determine if an `#[allow(deprecated)]` should be added to the derived impl./// This should happen if the derive input or an enum variant it contains has/// one of:///   - `#[deprecated]`///   - `#[allow(deprecated)]`contains_deprecated/// Check whether the given attributes contains one of:wrap_in_const/// Tokens that can be used as an expression./// Tokens that can be used inside a block. The surrounding curly braces are/// not part of these tokens.quote_exprquote_block/// Interpolate a fragment in place of an expression. This involves surrounding/// Block fragments in curly braces./// Interpolate a fragment as the statements of a block./// Interpolate a fragment as the value part of a `match` expression. This/// involves putting a comma after expressions and curly braces around blocks./// The struct or enum name (without generics)./// Attributes on the structure, parsed for Serde./// The contents of the struct or enum./// Any generics on the struct or enum./// Original input./// A source data structure annotated with `#[derive(Serialize)]` and/or `#[derive(Deserialize)]`,/// parsed into an internal representation./// The fields of a struct or enum./// Analogous to `syn::Data`./// A variant of an enum./// A field of a struct./// Named fields./// Many unnamed fields./// One unnamed field./// No fields./// Convert the raw Syn ast into a parsed container object, collecting errors in `cx`.//! A Serde ast, parsed from the Syn ast and ready to generate Rust code.MultiNameRenameRuleset_optset_if_noneget_with_tokensBoolAttrset_truefirst_dup_tokensVecAttrRenameAllRules/// Returns a new `RenameAllRules` with the individual rules of `self` and/// `other_rules` joined by `RenameRules::or`.deny_unknown_fieldsrename_all_rulesrename_all_fields_rulesser_boundde_boundtype_fromtype_try_fromtype_intoserde_path/// Error message generated when type can't be deserialized/// Represents struct or enum attribute information./// The default./// ```json/// {"variant1": {"key1": "value1", "key2": "value2"}}/// `#[serde(tag = "type")]`/// {"type": "variant1", "key1": "value1", "key2": "value2"}Adjacent/// `#[serde(tag = "t", content = "c")]`/// {"t": "variant1", "c": {"key1": "value1", "key2": "value2"}}/// `#[serde(untagged)]`/// {"key1": "value1", "key2": "value2"}/// Styles of representing an enum./// It does not./// This enum represents the fields of a struct. All of the variants must be/// unit variants, except possibly one which is annotated with/// `#[serde(other)]` and is a newtype variant./// This enum represents the variants of an enum. All of the variants must/// be unit variants./// Whether this enum represents the fields of a struct or the variants of an/// Extract out the `#[serde(...)]` attributes from an item.custom_serde_path/// Error message generated when type can't be deserialized./// If `None`, default message will be useddecide_tagdecide_identifierskip_deserializingskip_serializingserialize_withdeserialize_withBorrowAttributeuntagged/// Represents variant attribute informationrename_by_rulesskip_serializing_if/// Represents field attribute information/// Field must always be specified because it does not have a default./// The default is given by `std::default::Default::default()`./// The default is given by this function./// Represents the default to use for a field when deserializing./// Extract out the `#[serde(...)]` attributes from a struct field.mark_transparentSerAndDeget_ser_and_deget_renamesget_multiple_renamesget_where_predicatesget_lit_strget_lit_str2parse_lit_into_pathparse_lit_into_expr_pathparse_lit_into_whereparse_lit_into_typarse_lit_into_lifetimes// Parses a string literal like "'a + 'b + 'c" containing a nonempty list of// lifetimes separated by `+`.is_implicitly_borrowedis_implicitly_borrowed_referenceis_cow// Whether the type looks like it might be `std::borrow::Cow<T>` where elem="T".// This can have false negatives and false positives.// False negative://     use std::borrow::Cow as Pig;//     struct S<'a> {//         #[serde(borrow)]//         pig: Pig<'a, str>,// False positive://     type str = [i16];//         cow: Cow<'a, str>,is_optionis_reference// Whether the type looks like it might be `&T` where elem="T". This can have// false negatives and false positives.//     type Yarn = str;//         r: &'a Yarn,//         r: &'a str,is_primitive_typeis_primitive_pathborrowable_lifetimes// All lifetimes that this type could borrow from a Deserializer.// For example a type `S<'a, 'b>` could borrow `'a` and `'b`. On the other hand// a type `for<'a> fn(&'a str)` could not borrow `'a` from the Deserializer.// This is used when there is an explicit or implicit `#[serde(borrow)]`// attribute on the field so there must be at least one borrowable lifetime.collect_lifetimescollect_lifetimes_from_tokens// This module handles parsing of `#[serde(...)]` attributes. The entrypoints// are `attr::Container::from_ast`, `attr::Variant::from_ast`, and// `attr::Field::from_ast`. Each returns an instance of the corresponding// struct. Note that none of them return a Result. Unrecognized, malformed, or// duplicated attributes result in a span_err but otherwise are ignored. The// user will see errors simultaneously for all bad attributes in the crate// rather than just the first./// Don't apply a default rename rule./// Rename direct children to "lowercase" style./// Rename direct children to "UPPERCASE" style.PascalCase/// Rename direct children to "PascalCase" style, as typically used for/// enum variants./// Rename direct children to "camelCase" style./// Rename direct children to "snake_case" style, as commonly used for/// fields.ScreamingSnakeCase/// Rename direct children to "SCREAMING_SNAKE_CASE" style, as commonly/// used for constants./// Rename direct children to "kebab-case" style.ScreamingKebabCase/// Rename direct children to "SCREAMING-KEBAB-CASE" style./// The different possible ways to change case of fields in a struct, or variants in an enum.RENAME_RULESapply_to_variant/// Apply a renaming rule to an enum variant, returning the version expected in the source.apply_to_field/// Apply a renaming rule to a struct field, returning the version expected in the source./// Returns the `RenameRule` if it is not `None`, `rule_b` otherwise.rename_variantsrename_fields//! Code to convert the Rust-styled field/variant (e.g. `my_field`, `MyType`) to the//! case of the source (e.g. `my-field`, `MY_FIELD`).// Cross-cutting checks that require looking at more than a single attrs object.// Simpler checks should happen when parsing and building the attrs.check_default_on_tuple// If some field of a tuple struct is marked #[serde(default)] then all fields// after it must also be marked with that attribute, or the struct must have a// container-level serde(default) attribute. A field's default value is only// used for tuple fields if the sequence is exhausted at that point; that means// all subsequent fields will fail to deserialize if they don't have their own// default.check_remote_generic// Remote derive definition type must have either all of the generics of the// remote type://     #[serde(remote = "Generic")]//     struct Generic<T> {…}// or none of them, i.e. defining impls for one concrete instantiation of the// remote type only://     #[serde(remote = "Generic<T>")]//     struct ConcreteDef {…}check_getter// Getters are only allowed inside structs (not enums) with the `remote`// attribute.check_flatten// Flattening has some restrictions we can test.check_flatten_fieldcheck_identifier// The `other` attribute must be used at most once and it must be the last// variant of an enum.// Inside a `variant_identifier` all variants must be unit variants. Inside a// `field_identifier` all but possibly one variant must be unit variants. The// last variant may be a newtype variant which is an implicit "other" case.check_variant_skip_attrs// Skip-(de)serializing attributes are not allowed on variants marked// (de)serialize_with.check_internal_tag_field_name_conflict// The tag of an internally-tagged struct variant must not be the same as either// one of its fields, as this would result in duplicate keys in the serialized// output and/or ambiguity in the to-be-deserialized input.check_adjacent_tag_conflict// In the case of adjacently-tagged enums, the type and the contents tag must// differ, for the same reason.check_transparent// Enums and unit structs cannot be transparent.member_messageallow_transparentcheck_from_and_try_from// The contents will be set to `None` during checking. This is so that checking can be// enforced./// A type to collect errors together and format them./// Dropping this object will cause a panic. It must be consumed using `check`./// References can be shared since this type uses run-time exclusive mut checking./// Create a new context object./// This object contains no errors, but will still trigger a panic if it is not `check`ed.error_spanned_by/// Add an error to the context object with a tokenenizable object./// The object is used for spanning in error messages.syn_error/// Add one of Syn's parse errors./// Consume this object, producing a formatted error string if there are errors.ctxtserialize_renameddeserialize_renameddeserialize_aliasesserialize_name/// Return the container name for the container when serializing.deserialize_name/// Return the container name for the container when deserializing.visit_type_mut_implvisit_type_path_mut_implvisit_expr_path_mut_implvisit_path_arguments_mutvisit_return_type_mutvisit_type_param_bound_mutvisit_generics_mutvisit_data_mut// Everything below is simply traversing the syntax tree.respan_tokenBORROWBOUNDCONTENTCRATEDENY_UNKNOWN_FIELDSDESERIALIZEDESERIALIZE_WITHEXPECTINGFIELD_IDENTIFIERFLATTENGETTERINTONON_EXHAUSTIVERENAMERENAME_ALLRENAME_ALL_FIELDSREPRSERDESERIALIZESERIALIZE_WITHSKIP_DESERIALIZINGSKIP_SERIALIZINGSKIP_SERIALIZING_IFTRANSPARENTTRY_FROMUNTAGGEDVARIANT_IDENTIFIERWITH// clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054// clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575// clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797// clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984derive_serializederive_deserialize//! This crate provides Serde's two derive macros.//! # struct S;//! Please refer to [https://serde.rs/derive.html] for how to set this up.//! [https://serde.rs/derive.html]: https://serde.rs/derive.html// Ignored clippy lints// Ignored clippy_pedantic lintspretend_used// Suppress dead_code warnings that would otherwise appear when using a remote// derive. Other than this pretend code, a struct annotated with remote derive// never has its fields referenced and an enum annotated with remote derive// never has its variants constructed.//     warning: field is never used: `i`//      --> src/main.rs:4:20//       |//     4 | struct StructDef { i: i32 }//       |                    ^^^^^^//     warning: variant is never constructed: `V`//      --> src/main.rs:8:16//     8 | enum EnumDef { V }//       |                ^pretend_fields_used// For structs with named fields, expands to://     match None::<&T> {//         Some(T { a: __v0, b: __v1 }) => {}//         _ => {}// For packed structs on sufficiently new rustc, expands to://         Some(__v @ T { a: _, b: _ }) => {//             let _ = addr_of!(__v.a);//             let _ = addr_of!(__v.b);// For packed structs on older rustc, we assume Sized and !Drop, and expand to://     match None::<T> {// For enums, expands to the following but only including struct variants://         Some(T::A { a: __v0 }) => {}//         Some(T::B { b: __v0 }) => {}pretend_fields_used_structpretend_fields_used_struct_packedpretend_fields_used_enumpretend_variants_used// Expands to one of these per enum variant://     match None {//         Some((__v0, __v1,)) => {//             let _ = E::V { a: __v0, b: __v1 };expand_derive_serializeself_var/// Variable holding the value being serialized. Either `self` for local/// types or `__self` for remote types./// Type has a `serde(remote = "...")` attribute./// various Serializer methods.// All the generics in the input, plus a bound `T: Serialize` for each generic// field type that will be serialized by us.needs_serialize_bound// Fields with a `skip_serializing` or `serialize_with` attribute, or which// belong to a variant with a `skip_serializing` or `serialize_with` attribute,// are not serialized by us so we do not generate a bound. Fields with a `bound`// attribute specify their own bound so we do not generate one. All other fields// may need a `T: Serialize` bound where T is the type of the field.serialize_bodyserialize_transparentserialize_struct_tag_fieldStructTraitserialize_struct_as_structserialize_struct_as_mapserialize_enumserialize_variantserialize_externally_tagged_variantserialize_internally_tagged_variantserialize_adjacently_tagged_variantserialize_untagged_variantserialize_struct_variant_with_flattenserialize_tuple_struct_visitorTupleTraitserialize_struct_visitorwrap_serialize_field_withwrap_serialize_variant_withwrap_serialize_withmut_if// Serialization of an empty struct results in code like://     let mut __serde_state = serializer.serialize_struct("S", 0)?;//     _serde::ser::SerializeStruct::end(__serde_state)// where we want to omit the `mut` to avoid a warning.get_memberIoReadIteratorReadSliceReadStrReadstr_bufremaining_depth/// A structure that deserializes JSON into Rust values./// Create a JSON deserializer from one of the possible serde_json input/// sources./// Typically it is more convenient to use one of these methods instead:///   - Deserializer::from_str///   - Deserializer::from_bytes///   - Deserializer::from_iter///   - Deserializer::from_reader/// Creates a JSON deserializer from a `std::iter::Iterator`./// Creates a JSON deserializer from an `io::Read`./// Creates a JSON deserializer from a `&[u8]`./// Creates a JSON deserializer from a `&str`./// The `Deserializer::end` method should be called after a value has been fully deserialized./// This allows the `Deserializer` to validate that the input stream is at the end or that it/// only has trailing whitespace.StreamDeserializer/// Turn a JSON deserializer into an iterator over values of type T.peek_or_nulleat_charnext_char_or_null/// Error caused by a byte from next_char().peek_error/// Error caused by a byte from peek()./// Consume whitespace until the next non-whitespace character./// Return `Ok(true)` if EOF was encountered in the process and `Ok(false)` otherwise.parse_integerparse_long_integerparse_exponentparse_exponent_overflow// This cold code should not be inlined into the middle of the hot// exponent-parsing loop above.visit_f64_from_partsparse_object_colonend_mapPOW10/// Parses a `null` as a None, and any other values as a `Some(...)`./// Parses a newtype struct as the underlying value./// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight/// value, a `[..]`, or a `{..}`./// Parses a JSON string as bytes. Note that this function does not/// check whether the bytes represent valid unicode code points./// The JSON specification requires that strings only contain valid/// unicode characters. To deal with non-conforming JSON, you may use/// this function, which attempts to parse a string without checking/// whether the bytes represent valid unicode code points./// Escape sequences are processed as usual, and for `\uXXXX` escapes /// it is still checked if the hex number represents a valid unicode/// code point./// # Example usage/// You can use this to parse JSON strings containing non-unicode bytes:/// let bytes = serde::bytes::ByteBuf::from(b"some raw bytes: \xe5\x00\xe5".to_vec());/// let parsed = serde_json::from_slice(  b"\"some raw bytes: \xe5\x00\xe5\"").unwrap();/// assert_eq!(bytes, parsed);/// `\u` escape sequences with invalid unicode code points still fail to parse:/// let json = "\"invalid unicode surrogate: \\uD801\"";/// let parsed: Result<serde::bytes::ByteBuf, _> = serde_json::from_str(json);/// assert!(parsed.is_err(), "{} should not parse: {:?}", json, parsed);UnitVariantVisitor/// Iterator that deserializes a stream into multiple JSON values./// A stream deserializer can be created from any JSON deserializer using the/// `Deserializer::into_iter` method./// extern crate serde_json;/// use serde_json::{Deserializer, Value};///     let data = "1 2 {\"k\": 3}";///     let stream = Deserializer::from_str(data).into_iter::<Value>();///     for value in stream {///         println!("{}", value.unwrap());/// Create a JSON stream deserializer from one of the possible serde_json/// input sources.///   - Deserializer::from_str(...).into_iter()///   - Deserializer::from_bytes(...).into_iter()///   - Deserializer::from_iter(...).into_iter()///   - Deserializer::from_reader(...).into_iter()from_trait/// Deserialize an instance of type `T` from an iterator over bytes of JSON./// This conversion can fail if the structure of the Value does not match the/// structure expected by `T`, for example if `T` is a struct type but the Value/// contains something other than a JSON map. It can also fail if the structure/// is correct but `T`'s implementation of `Deserialize` decides that something/// is wrong with the data, for example required struct fields are missing from/// the JSON map or some number is too big to fit in the expected primitive/// Deserialize an instance of type `T` from an IO stream of JSON./// Deserialize an instance of type `T` from bytes of JSON text./// Deserialize an instance of type `T` from a string of JSON text.//! Deserialize JSON data to a Rust data structure./// This `Box` allows us to keep the size of `Error` as small as possible. A/// larger `Error` type was substantially slower due to all the functions/// that pass around `Result<T, Error>`./// This type represents all possible errors that can occur when serializing or/// deserializing JSON data./// Alias for a `Result` with the error type `serde_json::Error`./// One-based line number at which the error was detected./// Characters in the first line of the input (before the first newline/// character) are in line 1./// One-based column number at which the error was detected./// The first character in the input and any characters immediately/// following a newline character are in column 1./// Note that errors may occur in column 0, for example if a read from an IO/// stream fails immediately following a previously read newline character.Category/// Categorizes the cause of this error./// - `Category::Io` - failure to read or write bytes on an IO stream/// - `Category::Syntax` - input that is not syntactically valid JSON/// - `Category::Data` - input data that is semantically incorrect/// - `Category::Eof` - unexpected end of the input datais_io/// Returns true if this error was caused by a failure to read or write/// bytes on an IO stream.is_syntax/// Returns true if this error was caused by input that was not/// syntactically valid JSON./// Returns true if this error was caused by input data that was/// semantically incorrect./// For example, JSON containing a number is semantically incorrect when the/// type being deserialized into holds a String./// Returns true if this error was caused by prematurely reaching the end of/// Callers that process streaming input may be interested in retrying the/// deserialization once more data is available./// The error was caused by a failure to read or write bytes on an IO/// The error was caused by input that was not syntactically valid JSON./// The error was caused by input data that was semantically incorrect./// The error was caused by prematurely reaching the end of the input data./// Categorizes the cause of a `serde_json::Error`./// Catchall for syntax error messages/// Some IO error occurred while serializing or deserializing.EofWhileParsingList/// EOF while parsing a list.EofWhileParsingObject/// EOF while parsing an object.EofWhileParsingString/// EOF while parsing a string.EofWhileParsingValue/// EOF while parsing a JSON value.ExpectedColon/// Expected this character to be a `':'`.ExpectedListCommaOrEnd/// Expected this character to be either a `','` or a `]`.ExpectedObjectCommaOrEnd/// Expected this character to be either a `','` or a `}`.ExpectedSomeIdent/// Expected to parse either a `true`, `false`, or a `null`.ExpectedSomeValue/// Expected this character to start a JSON value.ExpectedSomeString/// Expected this character to start a JSON string./// Invalid hex escape code./// Invalid number.NumberOutOfRange/// Number is bigger than the maximum value of its type.InvalidUnicodeCodePoint/// Invalid unicode code point.KeyMustBeAString/// Object key is not a string.LoneLeadingSurrogateInHexEscape/// Lone leading surrogate in hex escape.TrailingCharacters/// JSON has non-whitespace trailing characters after the value.UnexpectedEndOfHexEscape/// Unexpected end of hex excape.RecursionLimitExceeded/// Encountered nesting of JSON maps and arrays more than 128 layers deep.// Not public API. Should be pub(crate).fix_position// Remove two layers of verbosity from the debug representation. Humans often// end up seeing this representation because it is what unwrap() shows.//! When serializing or deserializing JSON goes wrong.to_string_prettyto_vec_prettyto_writer_pretty//! # Serde JSON//! JSON is a ubiquitous open-standard format that uses human-readable text to//! transmit data objects consisting of key-value pairs.//! ```json,ignore//!   "name": "John Doe",//!   "age": 43,//!   "address": {//!     "street": "10 Downing Street",//!     "city": "London"//!   },//!   "phones": [//!     "+44 1234567",//!     "+44 2345678"//!   ]//! There are three common ways that you might find yourself needing to work//! with JSON data in Rust.//!  - **As text data.** An unprocessed string of JSON data that you receive on//!    an HTTP endpoint, read from a file, or prepare to send to a remote//!    server.//!  - **As an untyped or loosely typed representation.** Maybe you want to//!    check that some JSON data is valid before passing it on, but without//!    knowing the structure of what it contains. Or you want to do very basic//!    manipulations like add a level of nesting.//!  - **As a strongly typed Rust data structure.** When you expect all or most//!    of your data to conform to a particular structure and want to get real//!    work done without JSON's loosey-goosey nature tripping you up.//! Serde JSON provides efficient, flexible, safe ways of converting data//! between each of these representations.//! # JSON to the Value enum//! Any valid JSON data can be manipulated in the following recursive enum//! representation. This data structure is [`serde_json::Value`][value].//! # use serde_json::{Number, Map};//! # #[allow(dead_code)]//! enum Value {//!     Null,//!     Bool(bool),//!     Number(Number),//!     String(String),//!     Array(Vec<Value>),//!     Object(Map<String, Value>),//! A string of JSON data can be parsed into a `serde_json::Value` by the//! [`serde_json::from_str`][from_str] function. There is also//! [`from_slice`][from_slice] for parsing from a byte slice &[u8],//! [`from_iter`][from_iter] for parsing from an iterator of bytes, and//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or//! a TCP stream.//! # extern crate serde_json;//! # use serde_json::Error;//! # pub fn example() -> Result<(), Error> {//! use serde_json::Value;//! let data = r#" { "name": "John Doe", "age": 43, ... } "#;//! let v: Value = serde_json::from_str(data)?;//! println!("Please call {} at the number {}", v["name"], v["phones"][0]);//! The `Value` representation is sufficient for very basic tasks but is brittle//! and tedious to work with. Error handling is verbose to implement correctly,//! for example imagine trying to detect the presence of unrecognized fields in//! the input data. The compiler is powerless to help you when you make a//! mistake, for example imagine typoing `v["name"]` as `v["nmae"]` in one of//! the dozens of places it is used in your code.//! # JSON to strongly typed data structures//! Serde provides a powerful way of mapping JSON data into Rust data structures//! largely automatically.//! # #[macro_use] extern crate serde_derive;//! struct Person {//!     name: String,//!     age: u8,//!     address: Address,//!     phones: Vec<String>,//! struct Address {//!     street: String,//!     city: String,//! let p: Person = serde_json::from_str(data)?;//! println!("Please call {} at the number {}", p.name, p.phones[0]);//! This is the same `serde_json::from_str` function as before, but this time we//! assign the return value to a variable of type `Person` so Serde JSON will//! automatically interpret the input data as a `Person` and produce informative//! error messages if the layout does not conform to what a `Person` is expected//! to look like.//! Any type that implements Serde's `Deserialize` trait can be deserialized//! this way. This includes built-in Rust standard library types like `Vec<T>`//! and `HashMap<K, V>`, as well as any structs or enums annotated with//! `#[derive(Deserialize)]`.//! Once we have `p` of type `Person`, our IDE and the Rust compiler can help us//! use it correctly like they do for any other Rust code. The IDE can//! autocomplete field names to prevent typos, which was impossible in the//! `serde_json::Value` representation. And the Rust compiler can check that//! when we write `p.phones[0]`, then `p.phones` is guaranteed to be a//! `Vec<String>` so indexing into it makes sense and produces a `String`.//! # Constructing JSON//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`//! objects with very natural JSON syntax. In order to use this macro,//! `serde_json` needs to be imported with the `#[macro_use]` attribute.//! extern crate serde_json;//!     // The type of `john` is `serde_json::Value`//!     let john = json!({//!       "name": "John Doe",//!       "age": 43,//!       "phones": [//!         "+44 1234567",//!         "+44 2345678"//!       ]//!     println!("first phone number: {}", john["phones"][0]);//!     // Convert to a string of JSON and print it out//!     println!("{}", john.to_string());//! The `Value::to_string()` function converts a `serde_json::Value` into a//! `String` of JSON text.//! One neat thing about the `json!` macro is that variables and expressions can//! be interpolated directly into the JSON value as you are building it. Serde//! will check at compile time that the value you are interpolating is able to//! be represented as JSON.//! # #[macro_use] extern crate serde_json;//! # fn random_phone() -> u16 { 0 }//! let full_name = "John Doe";//! let age_last_year = 42;//! // The type of `john` is `serde_json::Value`//! let john = json!({//!   "name": full_name,//!   "age": age_last_year + 1,//!     format!("+44 {}", random_phone())//! # let _ = john;//! This is amazingly convenient but we have the problem we had before with//! `Value` which is that the IDE and Rust compiler cannot help us if we get it//! wrong. Serde JSON provides a better way of serializing strongly-typed data//! structures into JSON text.//! # Serializing data structures//! A data structure can be converted to a JSON string by//! [`serde_json::to_string`][to_string]. There is also//! [`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and//! [`serde_json::to_writer`][to_writer] which serializes to any `io::Write`//! such as a File or a TCP stream.//! # pub fn example() -> Result<String, Error> {//! let address = Address {//!     street: "10 Downing Street".to_owned(),//!     city: "London".to_owned(),//! let j = serde_json::to_string(&address)?;//! # Ok(j) }//! Any type that implements Serde's `Serialize` trait can be serialized this//! way. This includes built-in Rust standard library types like `Vec<T>` and//! `HashMap<K, V>`, as well as any structs or enums annotated with//! `#[derive(Serialize)]`.//! [value]: https://docs.serde.rs/serde_json/value/enum.Value.html//! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html//! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html//! [from_iter]: https://docs.serde.rs/serde_json/de/fn.from_iter.html//! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html//! [to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html//! [to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html//! [to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html//! [macro]: https://docs.serde.rs/serde_json/macro.json.html// Because of "JavaScript"... fixed in Manishearth/rust-clippy#1071// Whitelisted clippy_pedantic lints// Hide distracting implementation details from the generated rustdoc./// Construct a `serde_json::Value` from a JSON literal./// # #[macro_use] extern crate serde_json;/// let value = json!({///     "code": 200,///     "success": true,///     "payload": {///         "features": [///             "serde",///             "json"/// Variables or expressions can be interpolated into the JSON literal. Any type/// interpolated into an array element or object value must implement Serde's/// `Serialize` trait, while any type interpolated into a object key must/// implement `Into<String>`. If the `Serialize` implementation of the/// interpolated type decides to fail, or if the interpolated type contains a/// map with non-string keys, the `json!` macro will panic./// let code = 200;/// let features = vec!["serde", "json"];///    "code": code,///    "success": code == 200,///    "payload": {///        features[0]: features[1]/// Trailing commas are allowed inside both arrays and objects./// let value = json!([///     "notice",///     "the",///     "trailing",///     "comma -->",json_internal//////////////////////////////////////////////////////////////////////////// TT muncher for parsing the inside of an array [...]. Produces a vec![...]// of the elements.// Must be invoked as: json_internal!(@array [] $($tt)*)// Done with trailing comma.// Done without trailing comma.// Next element is `null`.// Next element is `true`.// Next element is `false`.// Next element is an array.// Next element is a map.// Next element is an expression followed by comma.// Last element is an expression with no trailing comma.// Comma after the most recent element.// TT muncher for parsing the inside of an object {...}. Each entry is// inserted into the given map variable.// Must be invoked as: json_internal!(@object $map () ($($tt)*) ($($tt)*))// We require two copies of the input tokens so that we can match on one// copy and trigger errors on the other copy.// Done.// Insert the current entry followed by trailing comma.// Insert the last entry without trailing comma.// Next value is `null`.// Next value is `true`.// Next value is `false`.// Next value is an array.// Next value is a map.// Next value is an expression followed by comma.// Last value is an expression with no trailing comma.// Missing value for last entry. Trigger a reasonable error message.// Missing colon and value for last entry. Trigger a reasonable error// message.// Misplaced colon. Trigger a reasonable error message.// Found a comma inside a key. Trigger a reasonable error message.// Key is fully parenthesized. This avoids clippy double_parens false// positives because the parenthesization may be necessary here.// Munch a token into the current key.// The main implementation.// Must be invoked as: json_internal!($($json)+)// Any Serialize type: numbers, strings, struct literals, variables etc.// Must be below every other rule.// Rocket relies on this because they export their own `json!` with a different// doc comment than ours, and various Rust bugs prevent them from calling our// `json!` from their `json!` so they call `json_internal!` directly. Check with// @SergioBenitez before making breaking changes to this macro.// Changes are fine as long as `json_internal!` does not call any new helper// macros and can still be invoked as `json_internal!($($json)+)`.MapImpl/// Represents a JSON key/value type./// Makes a new empty Map./// Makes a new empty Map with the given initial capacity./// Clears the map, removing all values./// The key may be any borrowed form of the map's key type, but the ordering/// on the borrowed form *must* match the ordering on the key type./// If the map did not have this key present, `None` is returned./// types that can be `==` without being identical./// Gets an iterator over the entries of the map./// Gets a mutable iterator over the entries of the map./// Gets an iterator over the keys of the map./// Gets an iterator over the values of the map./// Access an element of this map. Panics if the given key is not present in the/// # use serde_json::Value;/// # let val = &Value::String("".to_owned());/// # let _ =/// match *val {///     Value::String(ref s) => Some(s.as_str()),///     Value::Array(ref arr) => arr[0].as_str(),///     Value::Object(ref map) => map["type"].as_str(),///     _ => None,/// Mutably access an element of this map. Panics if the given key is not/// present in the map./// # let mut map = serde_json::Map::new();/// # map.insert("key".to_owned(), serde_json::Value::Null);/// map["key"] = json!("value");/// A vacant Entry./// An occupied Entry./// This enum is constructed from the [`entry`] method on [`Map`]./// [`entry`]: struct.Map.html#method.entry/// [`BTreeMap`]: struct.Map.htmlvacantVacantEntryImpl/// A vacant Entry. It is part of the [`Entry`] enum.OccupiedEntryImpl/// An occupied Entry. It is part of the [`Entry`] enum./// let mut map = serde_json::Map::new();/// assert_eq!(map.entry("serde").key(), &"serde");/// Ensures a value is in the entry by inserting the default if empty, and/// returns a mutable reference to the value in the entry./// map.entry("serde").or_insert(json!(12));/// assert_eq!(map["serde"], 12);/// function if empty, and returns a mutable reference to the value in the/// map.entry("serde").or_insert_with(|| json!("hoho"));/// assert_eq!(map["serde"], "hoho".to_owned());/// through the VacantEntry./// use serde_json::map::Entry;/// match map.entry("serde") {///     Entry::Vacant(vacant) => {///         assert_eq!(vacant.key(), &"serde");///     Entry::Occupied(_) => unimplemented!(),/// Sets the value of the entry with the VacantEntry's key, and returns a/// mutable reference to it.///         vacant.insert(json!("hoho"));/// map.insert("serde".to_owned(), json!(12));///     Entry::Occupied(occupied) => {///         assert_eq!(occupied.key(), &"serde");///     Entry::Vacant(_) => unimplemented!(),///         assert_eq!(occupied.get(), 12);/// map.insert("serde".to_owned(), json!([1, 2, 3]));///     Entry::Occupied(mut occupied) => {///         occupied.get_mut().as_array_mut().unwrap().push(json!(4));/// assert_eq!(map["serde"].as_array().unwrap().len(), 4);/// Converts the entry into a mutable reference to its value.///         occupied.into_mut().as_array_mut().unwrap().push(json!(4));/// Sets the value of the entry with the `OccupiedEntry`'s key, and returns/// the entry's old value.///         assert_eq!(occupied.insert(json!(13)), 12);///         assert_eq!(occupied.get(), 13);/// Takes the value of the entry out of the map, and returns it.///         assert_eq!(occupied.remove(), 12);/// An iterator over a serde_json::Map's entries.IterMutImpl/// A mutable iterator over a serde_json::Map's entries.IntoIterImpl/// An owning iterator over a serde_json::Map's entries.KeysImpl/// An iterator over a serde_json::Map's keys.ValuesImpl/// An iterator over a serde_json::Map's values.//! A map of String to serde_json::Value.//! By default the map is backed by a BTreeMap. Enable the `preserve_order`//! feature of serde_json to use LinkedHashMap instead./// Represents a JSON number, whether integer or floating point.PosIntNegInt/// Always less than zero./// Always finite.// "N" is a prefix of "NegInt"... this is a false positive.// https://github.com/Manishearth/rust-clippy/issues/1241is_i64/// Returns `true` if the number can be represented as `i64`.is_u64/// Returns `true` if the number can be represented as `u64`.is_f64/// Returns `true` if the number can be represented as `f64`./// Returns the number represented as `i64` if possible, or else `None`./// Returns the number represented as `u64` if possible, or else `None`./// Returns the number represented as `f64` if possible, or else `None`./// Converts a finite `f64` to a `Number`. Infinite or NaN values are not JSONfrom_signedfrom_unsigned/// Only valid after a call to peek(). Discards the peeked byte./// Position of the most recent call to next()./// The most recent call was probably next() and not peek(), but this method/// should try to return a sensible result if the most recent call was/// actually peek() because we don't always know./// Only called in case of an error, so performance is not important.peek_position/// Position of the most recent call to peek()./// The most recent call was probably peek() and not next(), but this method/// actually next() because we don't always know.parse_str/// Assumes the previous byte was a quotation mark. Parses a JSON-escaped/// string until the next quotation mark using the given scratch space if/// necessary. The scratch space is initially empty.parse_str_raw/// This function returns the raw bytes in the string with escape sequences/// expanded but without performing unicode validation./// Trait used by the deserializer for iterating over input. This is manually/// "specialized" for iterating over &[u8]. Once feature(specialization) is/// stable we can use actual specialization./// `serde_json`./// Temporary storage of peeked byte./// JSON input source that reads from an iterator of bytes./// JSON input source that reads from a std::io input stream./// Index of the *next* byte that will be returned by next() or peek()./// JSON input source that reads from a slice of bytes.// This is more efficient than other iterators because peek() can be read-only// and we can compute line/col position only if an error happens./// JSON input source that reads from a UTF-8 string.// Able to elide UTF-8 checks by assuming that the input is valid UTF-8.// Prevent users from implementing the Read trait./// Create a JSON input source to read from an iterator of bytes.parse_str_bytes/// Create a JSON input source to read from a std::io input stream./// Create a JSON input source to read from a slice of bytes.position_of_index/// The big optimization here over IteratorRead is that if the string/// contains no backslash escape sequences, the returned &str is a slice of/// the raw JSON data so we avoid copying into the scratch space./// Create a JSON input source to read from a UTF-8 string.CTQU// control character \x00...\x1F// quote \x22// backslash \x5CESCAPE// Lookup table of bytes that must be escaped. A value of true at index i means// that byte i requires an escape sequence in the input.next_or_eof/// Parses a JSON escape sequence and appends it into the scratch space. Assumes/// the previous byte read was a backslash.decode_hex_escape// allow unescapedCompactFormatter/// A structure for serializing Rust values into JSON./// Creates a new JSON serializer./// Creates a new JSON pretty print serializer.PrettyFormatterwith_formatter/// Creates a new JSON visitor whose output will be written to the writer/// Unwrap the `Writer` from the `Serializer`./// Serialize newtypes without an object wrapper.MapKeySerializerkey_must_be_a_stringCharEscape/// An escaped quote `"`ReverseSolidus/// An escaped reverse solidus `\`Solidus/// An escaped solidus `/`/// An escaped backspace character (usually escaped as `\b`)/// An escaped form feed character (usually escaped as `\f`)/// An escaped line feed character (usually escaped as `\n`)/// An escaped carriage return character (usually escaped as `\r`)/// An escaped tab character (usually escaped as `\t`)AsciiControl/// An escaped ASCII plane control character (usually escaped as/// `\u00XX` where `XX` are two hex characters)/// Represents a character escape code in a type-safe manner.from_escape_tablewrite_null/// Writes a `null` value to the specified writer./// Writes a `true` or `false` value to the specified writer./// Writes an integer value like `-123` to the specified writer./// Writes an integer value like `123` to the specified writer./// Writes a floating point value like `-31.26e+12` to the specified writer.begin_string/// Called before each series of `write_string_fragment` and/// `write_char_escape`.  Writes a `"` to the specified writer.end_string/// Called after each series of `write_string_fragment` andwrite_string_fragment/// Writes a string fragment that doesn't need any escaping to the/// specified writer.write_char_escape/// Writes a character escape code to the specified writer.begin_array/// Called before every array.  Writes a `[` to the specifiedend_array/// Called after every array.  Writes a `]` to the specifiedbegin_array_value/// Called before every array value.  Writes a `,` if needed to/// the specified writer.end_array_value/// Called after every array value.begin_object/// Called before every object.  Writes a `{` to the specifiedend_object/// Called after every object.  Writes a `}` to the specifiedbegin_object_key/// Called before every object key.end_object_key/// Called after every object key.  A `:` should be written to the/// specified writer by either this method or/// `begin_object_value`.begin_object_value/// Called before every object value.  A `:` should be written to/// the specified writer by either this method or/// `end_object_key`.end_object_value/// Called after every object value./// This trait abstracts away serializing the JSON control characters, which allows the user to/// optionally pretty print the JSON output./// This structure compacts a JSON value with no extra whitespace.current_indent/// This structure pretty prints a JSON value to make it human readable./// Construct a pretty printer formatter that defaults to using two spaces for indentation./// Construct a pretty printer formatter that uses the `indent` string for indentation.format_escaped_strformat_escaped_str_contents// \x08NN// \x09// \x0A// \x0C// \x0D// \x22// \x5C// Lookup table of escape sequences. A value of b'x' at index i means that byte// i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped.format_escaped_char/// Serialize the given data structure as JSON into the IO stream./// Serialize the given data structure as pretty-printed JSON into the IO/// Serialize the given data structure as a JSON byte vector./// Serialize the given data structure as a pretty-printed JSON byte vector./// Serialize the given data structure as a String of JSON./// Serialize the given data structure as a pretty-printed String of JSON.//! Serialize a Rust data structure into JSON data.// \x00...\x1F except the ones above/// Represents a JSON null value./// Represents a JSON boolean./// Represents a JSON string./// Represents a JSON array./// Represents a JSON object./// Represents any valid JSON value.parse_index/// Index into a JSON array or map. A string index can be used to access a/// value in a map, and a usize index can be used to access an element of an/// Returns `None` if the type of `self` does not match the type of the/// index, for example if the index is a string and `self` is an array or a/// number. Also returns `None` if the given key does not exist in the map/// or the given index is not within the bounds of the array./// let object = json!({ "A": 65, "B": 66, "C": 67 });/// assert_eq!(*object.get("A").unwrap(), json!(65));/// let array = json!([ "A", "B", "C" ]);/// assert_eq!(*array.get(2).unwrap(), json!("C"));/// assert_eq!(array.get("A"), None);/// Square brackets can also be used to index into a value in a more concise/// way. This returns `Value::Null` in cases where `get` would have returned/// let object = json!({///     "A": ["a", "á", "à"],///     "B": ["b", "b́"],///     "C": ["c", "ć", "ć̣", "ḉ"],/// assert_eq!(object["B"][0], json!("b"));/// assert_eq!(object["D"], json!(null));/// assert_eq!(object[0]["x"]["y"]["z"], json!(null));/// Mutably index into a JSON array or map. A string index can be used to/// access a value in a map, and a usize index can be used to access an/// element of an array./// let mut object = json!({ "A": 65, "B": 66, "C": 67 });/// *object.get_mut("A").unwrap() = json!(69);/// let mut array = json!([ "A", "B", "C" ]);/// *array.get_mut(2).unwrap() = json!("D");/// Returns true if the `Value` is an Object. Returns false otherwise./// If the `Value` is an Object, returns the associated Map.as_object_mut/// If the `Value` is an Object, returns the associated mutable Map./// Returns true if the `Value` is an Array. Returns false otherwise./// If the `Value` is an Array, returns the associated vector.as_array_mut/// If the `Value` is an Array, returns the associated mutable vector./// Returns true if the `Value` is a String. Returns false otherwise./// If the `Value` is a String, returns the associated str./// Returns true if the `Value` is a Number. Returns false otherwise./// Returns true if the `Value` is a number that can be represented by i64./// Returns true if the `Value` is a number that can be represented by u64./// Returns true if the `Value` is a number that can be represented by f64./// If the `Value` is a number, represent it as i64 if possible./// If the `Value` is a number, represent it as u64 if possible./// If the `Value` is a number, represent it as f64 if possible.is_boolean/// Returns true if the `Value` is a Boolean. Returns false otherwise./// If the `Value` is a Boolean, returns the associated bool./// Returns true if the `Value` is a Null. Returns false otherwise./// If the `Value` is a Null, returns ()./// Looks up a value by a JSON Pointer./// JSON Pointer defines a string syntax for identifying a specific value/// within a JavaScript Object Notation (JSON) document./// A Pointer is a Unicode string with the reference tokens separated by `/`./// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The/// addressed value is returned and if there is no such value `None` is/// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901)./// let data = json!({///     "x": {///         "y": ["z", "zz"]/// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));/// assert_eq!(data.pointer("/a/b/c"), None);pointer_mut/// Looks up a value by a JSON Pointer and returns a mutable reference to/// that value./// # Example of Use///     let s = r#"{"x": 1.0, "y": 2.0}"#;///     let mut value: Value = serde_json::from_str(s).unwrap();///     // Check value using read-only pointer///     assert_eq!(value.pointer("/x"), Some(&1.0.into()));///     // Change value with direct assignment///     *value.pointer_mut("/x").unwrap() = 1.5.into();///     // Check that new value was written///     assert_eq!(value.pointer("/x"), Some(&1.5.into()));///     // "Steal" ownership of a value. Can replace with any valid Value.///     let old_x = value.pointer_mut("/x").map(|x| mem::replace(x, Value::Null)).unwrap();///     assert_eq!(old_x, 1.5);///     assert_eq!(value.pointer("/x").unwrap(), &Value::Null);/// The default value is `Value::Null`./// This is useful for handling omitted `Value` fields when deserializing./// struct Settings {///     level: i32,///     #[serde(default)]///     extras: Value,/// # pub fn try_main() -> Result<(), serde_json::Error> {/// let data = r#" { "level": 42 } "#;/// let s: Settings = serde_json::from_str(data)?;/// assert_eq!(s.level, 42);/// assert_eq!(s.extras, Value::Null);/// # fn main() { try_main().unwrap() }index_into/// Return None if the key is not already in the array or object.index_into_mutindex_or_insert/// Panic if array index out of bounds. If key is not already in the object,/// insert it with a value of null. Panic if Value is a type that cannot be/// indexed into, except if Value is null then it can be treated as an empty/// A type that can be used to index into a `serde_json::Value`. See the `get`/// and `get_mut` methods of `Value`.// Prevent users from implementing the Index trait./// Used in panic messages./// Index into a `serde_json::Value` using the syntax `value[0]` or/// `value["k"]`./// Returns `Value::Null` if the type of `self` does not match the type of/// the index, for example if the index is a string and `self` is an array/// or a number. Also returns `Value::Null` if the given key does not exist/// in the map or the given index is not within the bounds of the array./// For retrieving deeply nested values, you should have a look at the/// `Value::pointer` method./// assert_eq!(data["x"]["y"], json!(["z", "zz"]));/// assert_eq!(data["x"]["y"][0], json!("z"));/// assert_eq!(data["a"], json!(null)); // returns null for undefined values/// assert_eq!(data["a"]["b"], json!(null)); // does not panic// The usual semantics of Index is to panic on invalid indexing.// That said, the usual semantics are for things like Vec and BTreeMap which// have different use cases than Value. If you are working with a Vec, you know// that you are working with a Vec and you can get the len of the Vec and make// sure your indices are within bounds. The Value use cases are more// loosey-goosey. You got some JSON from an endpoint and you want to pull values// out of it. Outside of this Index impl, you already have the option of using// value.as_array() and working with the Vec directly, or matching on// Value::Array and getting the Vec directly. The Index impl means you can skip// that and index directly into the thing using a concise syntax. You don't have// to check the type, you don't have to check the len, it is all about what you// expect the Value to look like.// Basically the use cases that would be well served by panicking here are// better served by using one of the other approaches: get and get_mut,// as_array, or match. The value of this impl is that it adds a way of working// with Value that is not well served by the existing approaches: concise and// careless and sometimes that is exactly what you want./// Write into a `serde_json::Value` using the syntax `value[0] = ...` or/// `value["k"] = ...`./// If the index is a number, the value must be an array of length bigger/// than the index. Indexing into a value that is not an array or an array/// that is too small will panic./// If the index is a string, the value must be an object or null which is/// treated like an empty object. If the key is not already present in the/// object, it will be inserted with a value of null. Indexing into a value/// that is neither an object nor null will panic./// let mut data = json!({ "x": 0 });/// // replace an existing key/// data["x"] = json!(1);/// // insert a new key/// data["y"] = json!([false, false, false]);/// // replace an array value/// data["y"][0] = json!(true);/// // inserted a deeply nested key/// data["a"]["b"]["c"]["d"] = json!(true);/// println!("{}", data);partialeq_numeric/// Convert 32-bit floating point number to `Value`/// let f: f32 = 13.37;/// let x: Value = f.into();/// Convert 64-bit floating point number to `Value`/// let f: f64 = 13.37;/// Convert boolean to `Value`/// let b = false;/// let x: Value = b.into();/// Convert `String` to `Value`/// let s: String = "lorem".to_string();/// let x: Value = s.into();/// Convert string slice to `Value`/// let s: &str = "lorem";/// Convert copy-on-write string to `Value`/// let s: Cow<str> = Cow::Borrowed("lorem");/// let s: Cow<str> = Cow::Owned("lorem".to_string());/// Convert map (with string keys) to `Value`/// use serde_json::{Map, Value};/// let mut m = Map::new();/// m.insert("Lorem".to_string(), "ipsum".into());/// let x: Value = m.into();/// Convert a `Vec` to `Value`/// let v = vec!["lorem", "ipsum", "dolor"];/// let x: Value = v.into();/// Convert a slice to `Value`/// let v: &[&str] = &["lorem", "ipsum", "dolor"];/// Convert an iteratable type to a `Value`/// let v = std::iter::repeat(42).take(5);/// let x: Value = v.collect();/// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];/// let x: Value = v.into_iter().collect();/// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);WriterFormatter/// Display a JSON value as a string./// let json = json!({ "city": "London", "street": "10 Downing Street" });/// // Compact format:/// // {"city":"London","street":"10 Downing Street"}/// let compact = format!("{}", json);/// assert_eq!(compact,///     "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");/// // Pretty format:/// // {/// //   "city": "London",/// //   "street": "10 Downing Street"/// let pretty = format!("{:#}", json);/// assert_eq!(pretty,///     "{\n  \"city\": \"London\",\n  \"street\": \"10 Downing Street\"\n}");SerializeVec/// Convert a `T` into `serde_json::Value` which is an enum that can represent/// any valid JSON data./// This conversion can fail if `T`'s implementation of `Serialize` decides to/// let val = serde_json::to_value("s").unwrap();/// assert_eq!(val, Value::String("s".to_owned()));// Taking by value is more friendly to iterator adapters, option and result// consumers, etc. See https://github.com/serde-rs/json/pull/149./// Interpret a `serde_json::Value` as an instance of type `T`.to_json/// Represent `self` as a `serde_json::Value`. Note that `Value` is not a/// JSON string. If you need a string, use `serde_json::to_string` instead./// This conversion can fail if `T`'s implementation of `Serialize` decides/// to fail, or if `T` contains a map with non-string keys.ToJson/// Representation of any serializable data as a `serde_json::Value`.//! The Value enum, a loosely typed way of representing any valid JSON value.Fused///   - Deserializer::from_slice/// Reader-based deserializers do not support deserializing borrowed types/// like `&str`, since the `std::io::Read` trait has no non-copying methods/// -- everything it does involves copying bytes out of the data source.ParserNumber/// Returns the first non-whitespace byte without consuming it, or `None` if/// EOF is encountered.peek_invalid_type'anydeserialize_numberdo_deserialize_i128do_deserialize_u128scan_integer128f64_from_partsparse_decimal_overflowparse_any_signed_numberparse_any_numberignore_valueignore_integerignore_decimalignore_exponentif_checking_recursion_limitcheck_recursion/// Parses a JSON string as bytes. Note that this function does not check/// whether the bytes represent a valid UTF-8 string./// The relevant part of the JSON specification is Section 8.2 of [RFC/// 7159]:/// > When all the strings represented in a JSON text are composed entirely/// > of Unicode characters (however escaped), then that JSON text is/// > interoperable in the sense that all software implementations that/// > parse it will agree on the contents of names and of string values in/// > objects and arrays./// > However, the ABNF in this specification allows member names and string/// > values to contain bit sequences that cannot encode Unicode characters;/// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances/// > of this have been observed, for example, when a library truncates a/// > UTF-16 string without checking whether the truncation split a/// > surrogate pair.  The behavior of software that receives JSON texts/// > containing such values is unpredictable; for example, implementations/// > might return different values for the length of a string value or even/// > suffer fatal runtime exceptions./// [RFC 7159]: https://tools.ietf.org/html/rfc7159/// The behavior of serde_json is specified to fail on non-UTF-8 strings/// when deserializing into Rust UTF-8 string types such as String, and/// succeed with non-UTF-8 bytes when deserializing using this method./// Escape sequences are processed as usual, and for `\uXXXX` escapes it is/// still checked if the hex number represents a valid Unicode code point./// You can use this to parse JSON strings containing invalid UTF-8 bytes,/// or unpaired surrogates./// use serde_bytes::ByteBuf;/// fn look_at_bytes() -> Result<(), serde_json::Error> {///     let json_data = b"\"some bytes: \xe5\x00\xe5\"";///     let bytes: ByteBuf = serde_json::from_slice(json_data)?;///     assert_eq!(b'\xe5', bytes[12]);///     assert_eq!(b'\0', bytes[13]);///     assert_eq!(b'\xe5', bytes[14]);/// # look_at_bytes().unwrap();/// Backslash escape sequences like `\n` are still interpreted and required/// to be valid. `\u` escape sequences are required to represent a valid/// Unicode code point or lone surrogate.///     let json_data = b"\"lone surrogate: \\uD801\"";///     let expected = b"lone surrogate: \xED\xA0\x81";///     assert_eq!(expected, bytes.as_slice());/// # look_at_bytes();UnitVariantAccessMapKey/// Only deserialize from this after peeking a '"' byte! Otherwise it may/// deserialize invalid JSON successfully.deserialize_numeric_key/// The data can consist of any JSON value. Values need to be a self-delineating value e.g./// arrays, objects, or strings, or be followed by whitespace or a self-delineating value.///     let data = "{\"k\": 3}1\"cool\"\"stuff\" 3{}  [0, 1, 2]";///   - Deserializer::from_slice(...).into_iter()/// Returns the number of bytes so far deserialized into a successful `T`./// If a stream deserializer returns an EOF error, new data can be joined to/// `old_data[stream.byte_offset()..]` to try again./// let data = b"[0] [1] [";/// let de = serde_json::Deserializer::from_slice(data);/// let mut stream = de.into_iter::<Vec<i32>>();/// assert_eq!(0, stream.byte_offset());/// println!("{:?}", stream.next()); // [0]/// assert_eq!(3, stream.byte_offset());/// println!("{:?}", stream.next()); // [1]/// assert_eq!(7, stream.byte_offset());/// println!("{:?}", stream.next()); // error/// assert_eq!(8, stream.byte_offset());/// // If err.is_eof(), can join the remaining data to new data and continue./// let remaining = &data[stream.byte_offset()..];/// *Note:* In the future this method may be changed to return the number of/// bytes so far deserialized into a successful T *or* syntactically valid/// JSON skipped over due to a type error. See [serde-rs/json#70] for an/// example illustrating this./// [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70peek_end_of_value/// Deserialize an instance of type `T` from an I/O stream of JSON./// The content of the I/O stream is deserialized directly from the stream/// without being buffered in memory by serde_json./// When reading from a source against which short reads are not efficient, such/// as a [`File`], you will want to apply your own buffering because serde_json/// will not buffer the input. See [`std::io::BufReader`]./// It is expected that the input stream ends after the deserialized object./// If the stream does not end, such as in the case of a persistent socket connection,/// this function will not return. It is possible instead to deserialize from a prefix of an input/// stream without looking for EOF by managing your own [`Deserializer`]./// Note that counter to intuition, this function is usually slower than/// reading a file completely into memory and then applying [`from_str`]/// or [`from_slice`] on it. See [issue #160]./// [`std::io::BufReader`]: https://doc.rust-lang.org/std/io/struct.BufReader.html/// [`from_str`]: ./fn.from_str.html/// [`from_slice`]: ./fn.from_slice.html/// [issue #160]: https://github.com/serde-rs/json/issues/160/// Reading the contents of a file./// #[derive(Deserialize, Debug)]/// struct User {///     fingerprint: String,///     location: String,/// fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<dyn Error>> {///     // Open the file in read-only mode with buffer.///     let file = File::open(path)?;///     let reader = BufReader::new(file);///     // Read the JSON contents of the file as an instance of `User`.///     let u = serde_json::from_reader(reader)?;///     // Return the `User`.///     Ok(u)/// # fn fake_main() {///     let u = read_user_from_file("test.json").unwrap();///     println!("{:#?}", u);/// Reading from a persistent socket connection./// fn read_user_from_stream(tcp_stream: TcpStream) -> Result<User, Box<dyn Error>> {///     let mut de = serde_json::Deserializer::from_reader(tcp_stream);///     let u = User::deserialize(&mut de)?;///     let listener = TcpListener::bind("127.0.0.1:4000").unwrap();///     for stream in listener.incoming() {///         println!("{:#?}", read_user_from_stream(stream.unwrap()));/// This conversion can fail if the structure of the input does not match the/// structure expected by `T`, for example if `T` is a struct type but the input///     // The type of `j` is `&[u8]`///     let j = b"///             \"fingerprint\": \"0xF9BA143B95FF6D82\",///             \"location\": \"Menlo Park, CA\"///         }";///     let u: User = serde_json::from_slice(j).unwrap();///     // The type of `j` is `&str`///     let j = "///     let u: User = serde_json::from_str(j).unwrap();/// Note that errors may occur in column 0, for example if a read from an/// I/O stream fails immediately following a previously read newline/// - `Category::Io` - failure to read or write bytes on an I/O stream/// bytes on an I/O stream.io_error_kind/// The kind reported by the underlying standard library I/O error, if this/// error was caused by a failure to read or write bytes on an I/O stream./// use std::io::{self, ErrorKind, Read};/// use std::process;/// struct ReaderThatWillTimeOut<'a>(&'a [u8]);/// impl<'a> Read for ReaderThatWillTimeOut<'a> {///     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {///         if self.0.is_empty() {///             Err(io::Error::new(ErrorKind::TimedOut, "timed out"))///             self.0.read(buf)///     let reader = ReaderThatWillTimeOut(br#" {"k": "#);///     let _: Value = match serde_json::from_reader(reader) {///         Ok(value) => value,///         Err(error) => {///             if error.io_error_kind() == Some(ErrorKind::TimedOut) {///                 // Maybe this application needs to retry certain kinds of errors.///                 # return;///                 eprintln!("error: {}", error);///                 process::exit(1);/// The error was caused by a failure to read or write bytes on an I/O/// Convert a `serde_json::Error` into an `io::Error`./// JSON syntax and data errors are turned into `InvalidData` I/O errors./// EOF errors are turned into `UnexpectedEof` I/O errors./// enum MyError {///     Io(io::Error),///     Json(serde_json::Error),/// impl From<serde_json::Error> for MyError {///     fn from(err: serde_json::Error) -> MyError {///         use serde_json::error::Category;///         match err.classify() {///             Category::Io => {///                 MyError::Io(err.into())///             Category::Syntax | Category::Data | Category::Eof => {///                 MyError::Json(err)/// Some I/O error occurred while serializing or deserializing./// Expected this character to be either a `','` or a `']'`./// Expected this character to be either a `','` or a `'}'`.ExpectedDoubleQuote/// Expected this character to be a `"`.ControlCharacterWhileParsingString/// Control character found while parsing a string.ExpectedNumericKey/// Contents of key were supposed to be a number.FloatKeyMustBeFinite/// Object key is a non-finite float value.TrailingComma/// JSON has a comma after the last value in an array or map./// Unexpected end of hex escape.// Update `eager_json` crate when this function changes.JsonUnexpected// Parse our own error message that looks like "{} at line {} column {}" to work// around erased-serde round-tripping the error through de::Error::custom.parse_line_colstarts_with_digit// I/O errors can never occur in no-std mode. All our no-std I/O implementations// are infallible.//! Reimplements core logic and types from `std::io` in an `alloc`-friendly//! fashion.//! A tiny, `no_std`-friendly facade around `std::io`.//! Reexports types from `std` when available; otherwise reimplements and//! provides some of the core logic.//! The main reason that `std::io` hasn't found itself reexported as part of//! the `core` crate is the `std::io::{Read, Write}` traits' reliance on//! `std::io::Error`, which may contain internally a heap-allocated `Box<Error>`//! and/or now relying on OS-specific `std::backtrace::Backtrace`./// Index of the current line. Characters in the first line of the input/// (before the first newline character) are in line 1./// Index of the current column. The first character in the input and any/// characters immediately following a newline character are in column 1./// The column is 0 immediately after a newline character has been read.start_of_line/// Byte offset of the start of the current line. This is the sum of lengths/// of all previous lines. Keeping track of things this way allows efficient/// computation of the current line, column, and byte offset while only/// updating one of the counters in `next()` in the common case.bhcompsmall_powersfast_path/// Convert mantissa to exact value for a non-base2 power./// Returns the resulting float and if the value can be represented exactly.multiply_exponent_extended/// Multiply the floating-point by the exponent./// Multiply by pre-calculated powers of the base, modify the extended-/// float, and return if new value and if the value can be represented/// accurately./// Create a precise native float using an intermediate extended-precision float./// Return the float approximation and if the value can be accurately/// represented with mantissa bits of precision.fallback_path/// Fallback path when the fast path does not work./// Uses the moderate path, if applicable, otherwise, uses the slow path// Adapted from https://github.com/Alexhuszagh/rust-lexical.//! Algorithms to efficiently convert strings to floats.// FAST// MODERATE// FALLBACKbignum/// Max digits is the maximum number of digits plus one.b_extendedbh_extended/// Custom round-nearest, tie-event algorithm for bhcomp.large_atof/// Calculate the mantissa for a big integer with a positive exponent.small_atof/// Calculate the mantissa for a big integer with a negative exponent./// This invokes the comparison with `b+h`./// Calculate the exact value of the float./// Note: fraction must not have trailing zeros.//! Compare the mantissa to the halfway representation of the float.//! Compares the actual significant digits of the mantissa to the//! theoretical digits from `b+h`, scaled into the proper range.// MANTISSA// FLOAT OPS// BHCOMP/// Internal storage for the Bigint, in little-endian order.//! Big integer type definition.cached_float80// Pre-calculated mantissa for the powers.// Pre-calculated binary exponents for the powers.ExtendedFloatArray/// Precalculated powers that uses two-separate arrays for memory-efficiency.get_extended_floatModeratePathPowers/// Precalculated powers of base N for the moderate path.get_powers/// Get cached powers.ModeratePathCache/// Cached powers as a trait for a floating-point type.//! Cached powers trait for extended-precision floats.// MODERATE PATH POWERS// CACHED EXTENDED POWERSBASE10_SMALL_EXPONENTBASE10_LARGE_EXPONENT/// Get powers from base.//! of compounded error.// BASE10to_digit// Convert u8 to digit.//! Helpers to convert and add digits from characters.FloatErrorsnearest_error_is_accurate/// Check if the error is accurate with a round-nearest rounding scheme.//! Estimate the error in an 80-bit approximation of a float.//! This estimates the error in a floating-point representation.//! found here: <https://golang.org/src/strconv/atof.go>// Calculate the scientific notation exponent without overflow.// For example, 0.1 would be -1, and 10 would be 1 in base 10.mantissa_exponent// Calculate the mantissa exponent without overflow.// Remove the number of digits that contributed to the mantissa past// the dot, and add the number of truncated digits from the mantissa,// to calculate the scaling factor for the mantissa from a raw exponent.//! Utilities to calculate exponents.// EXPONENT CALCULATIONimul/// Multiply in-place, as if by `a*b`./// The result is not normalized.round_to_native/// Lossy round float-point number to native mantissa boundaries.from_float/// Create extended float from native float.into_float/// Convert into default-rounded, lower-precision native float.into_downward_float/// Convert into downward-rounded, lower-precision native float.// OPERATIONS// ROUND// INTO// Import ExtendedFloat from native float.// Export extended-precision float to native float.// The extended-precision float must be in native float representation,// with overflow/underflow appropriately handled.// FROM FLOAT// INTO FLOATlarge_powers32large_powers64//! Precalculated large powers for limbs.POW5_1/// Large powers (`&[u32]`) for base5 operations.POW5_2POW5_3POW5_4POW5_5POW5_6POW5_7POW5_8POW5_9POW5_10POW5_11POW5_12POW5_13POW5_14595POW5//! Precalculated large powers for 32-bit limbs./// Large powers (`&[u64]`) for base5 operations.//! Precalculated large powers for 64-bit limbs.large_powers// 32-BIT LIMBPOW5_LIMBPOW10_LIMB// 64-BIT LIMBas_limb/// Cast to limb type.as_wide/// Cast to wide type.split_u64/// Split u64 into limbs, in little-endian order.hi64_1/// Get the hi64 bits from a 1-limb slice.hi64_2/// Get the hi64 bits from a 2-limb slice.hi64_3/// Get the hi64 bits from a 3-limb slice./// High-level exporter to extract the high 64 bits from a little-endian slice.Hi64/// Trait to export the high 64-bits from a little-endian slice.iadd/// AddAssign two small integers and return if overflow happens./// Subtract two small integers and return the resulting value and if overflow happens.isub/// SubAssign two small integers and return if overflow happens./// Multiply two small integers (with carry) (and return if overflow happens).// ADDITION// SUBTRACTION// MULTIPLICATIONiadd_impl/// ADDITION/// Implied AddAssign implementation for adding a small integer to bigint./// Allows us to choose a start-index in x to store, to allow incrementing/// from a non-zero start./// AddAssign small integer to bigint.isub_impl/// SubAssign small integer to bigint./// Does not do overflowing subtraction./// MulAssign small integer to bigint./// Mul small integer to bigint.imul_pow5/// MulAssign by a power.ishl_bits/// Shift-left bits inside a buffer./// Assumes `n < Limb::BITS`, IE, internally shifting bits.ishl_limbs/// Shift-left `n` digits inside a buffer./// Assumes `n` is not 0.ishl/// Normalize the container by popping any leading zeros.// MULTIPLICATIION// BIT LENGTH// SHL/// Check if x is less than y.greater_equal/// Check if x is greater than or equal to y./// Implied AddAssign implementation for bigints./// Allows us to choose a start-index in x to store, so we can avoid/// padding the buffer with zeros when not needed, optimized for vectors./// AddAssign bigint to bigint./// SubAssign bigint to bigint.KARATSUBA_CUTOFF/// Number of digits to bottom-out to asymptotically slow algorithms./// Karatsuba tends to out-perform long-multiplication at ~320-640 bits,/// so we go halfway, while Newton division tends to out-perform/// Algorithm D at ~1024 bits. We can toggle this for optimal performance.karatsuba_split/// Split two buffers into halfway, into (lo, hi).karatsuba_mul/// Karatsuba multiplication algorithm with roughly equal input sizes./// Assumes `y.len() >= x.len()`.karatsuba_uneven_mul/// Karatsuba multiplication algorithm where y is substantially larger than x.karatsuba_mul_fwd/// Forwarder to the proper Karatsuba algorithm./// MulAssign bigint to bigint.// RELATIVE OPERATORS/// Get access to the underlying data/// Compare self to y./// Get the high 64-bits from the bigint and if there are remaining bits./// Returns usize::max_value() if the value overflows,/// IE, if `self.data().len() > usize::max_value() / 8`./// Create new big integer from u64.iadd_smallimul_smallimul_pow2/// Multiply by a power of 2./// Multiply by a power of 5.imul_pow10/// MulAssign by a power of 10./// Shift-left the entire buffer n bits.// DATA// RELATIVE OPERATIONS// INTEGER CONVERSIONS// SHIFTS/// Traits for shared operations for big integers./// None of these are implemented using normal traits, since these/// are very expensive operations, and we want to deliberately/// and explicitly use these functions.//! Building-blocks for arbitrary-precision math.//! These algorithms assume little-endian order for the large integer//! buffers, so for a `vec![0, 1, 2, 3]`, `3` is the most significant limb,//! and `0` is the least significant limb.// ALIASES//  or 64-bit numbers instead.//      aarch64 (Requires `UMULH` and `MUL` to capture high and low bits).//      powerpc64 (Requires `MULHDU` and `MULLD` to capture high and low bits).//      sparc64 (`UMUL` only supported double-word arguments).// SPLIT// HI64// NONZERO// Scalar-to-scalar operations, for building-blocks for arbitrary-precision// operations.// scalar// Large-to-small operations, to modify a big integer from a native scalar.// small// Large-to-large operations, to modify a big integer from a native scalar.// large// TRAITS// MODULESparse_concise_floatparse_truncated_float// The code in this module is derived from the `lexical` crate by @Alexhuszagh// which the author condensed into this minimal subset for use in serde_json.// For the serde_json use case we care more about reliably round tripping all// possible floating point values than about parsing any arbitrarily long string// of digits with perfect accuracy, as the latter would take a high cost in// compile time and performance.// Dual licensed as MIT and Apache 2.0 just like the rest of serde_json, but// copyright Alexander Huszagh.F32_POW10/// Precalculated values of radix**i for i in range [0, arr.len()-1]./// Each value can be **exactly** represented as that type.F64_POW10/// Type that can be converted to primitive with `as`.as_primitive_implas_cast/// a primitive via the `AsPrimitive` trait.AsCastas_cast_impl/// Numerical type trait.number_impl/// Defines a trait that supports integral operations.HIMASK/// Mask to extract the high bits from the integer.LOMASK/// Mask to extract the low bits from the integer./// Full size of the integer, in bits./// Half size of the integer, in bits.Mantissa/// Type trait for the mantissa type./// Unsigned type of the same size./// Literal zero.INFINITY_BITS/// Positive infinity as bits./// Bias of the exponentDEFAULT_SHIFT/// Default number of bits to shift (or 64 - mantissa size - 1).exponent_limit/// Get min and max exponent limits (exact) from radix.mantissa_limit/// Get the number of digits that can be shifted from exponent to mantissa.pow10/// Returns true if the float is a NaN or Infinite.is_inf/// Returns true if the float is infinite.next_positive/// Get next greater float for a positive float./// Value must be >= 0.0 and < INFINITY.round_positive_even/// Round a positive number to even./// Get exact exponent limit for radix./// Parse float for which the entire integer and fraction parts fit into a 64/// bit mantissa./// Precondition: The integer must not have leading zeros.// PARSERSinternal_n_mask/// Calculate a bitwise mask with `n` 1 bits starting at the `bit` position.round_nearest// Shift right N-bytes and round to the nearest.// Return if we are above halfway and if we are halfway.tie_even// Tie rounded floating point to event.// Shift right N-bytes and round nearest, tie-to-even.// Floating-point arithmetic uses round to nearest, ties to even,// which rounds to the nearest value, if the value is halfway in between,// round to an even value.round_toward// Shift right N-bytes and round towards a direction.// Return if we have any truncated bytes.downard// Round down.round_downward// Shift right N-bytes and round toward zero.// Floating-point arithmetic defines round toward zero, which rounds// towards positive zero.round_to_float// Shift the ExtendedFloat fraction to the fraction bits in a native float.avoid_overflow// Avoid overflow for large values, shift left as needed.// Shift until a 1-bit is in the hidden bit, if the mantissa is not 0.// Round an extended-precision float to a native float representation.// NEAREST ROUNDING// DIRECTED ROUNDING// ROUND TO FLOAT// AVOID OVERFLOW/UNDERFLOW// ROUND TO NATIVE// Shift extended-precision float right `shift` bytes.// Accepts when the shift is the same as the type size, and// sets the value to 0.// Shift extended-precision float left `shift` bytes.//! Bit-shift helpers.POW5_32// 32 BITPOW10_32POW5_64// 64 BITPOW10_64//! Pre-computed small powers.// https://github.com/rust-lang/rust-clippy/issues/12133// Deserializer::from_str, into_iter// we support older compilers// We only use our own error type; no need for From conversions provided by the// standard library's try! macro. This reduces lines of LLVM IR by 4%.//! ```json//!     "name": "John Doe",//!     "age": 43,//!     "address": {//!         "street": "10 Downing Street",//!         "city": "London"//!     "phones": [//!    manipulations like insert a key in a particular spot.//! # Operating on untyped JSON values//! [`serde_json::from_str`][from_str] function. There is also [`from_slice`]//! for parsing from a byte slice `&[u8]` and [`from_reader`] for parsing from//! any `io::Read` like a File or a TCP stream.//! use serde_json::{Result, Value};//! fn untyped_example() -> Result<()> {//!     // Some JSON input data as a &str. Maybe this comes from the user.//!     let data = r#"//!             "name": "John Doe",//!             "age": 43,//!             "phones": [//!                 "+44 1234567",//!                 "+44 2345678"//!             ]//!         }"#;//!     // Parse the string of data into serde_json::Value.//!     let v: Value = serde_json::from_str(data)?;//!     // Access parts of the data by indexing with square brackets.//!     println!("Please call {} at the number {}", v["name"], v["phones"][0]);//! #     untyped_example().unwrap();//! The result of square bracket indexing like `v["name"]` is a borrow of the//! data at that index, so the type is `&Value`. A JSON map can be indexed with//! string keys, while a JSON array can be indexed with integer keys. If the//! type of the data is not right for the type with which it is being indexed,//! or if a map does not contain the key being indexed, or if the index into a//! vector is out of bounds, the returned element is `Value::Null`.//! When a `Value` is printed, it is printed as a JSON string. So in the code//! above, the output looks like `Please call "John Doe" at the number "+44//! 1234567"`. The quotation marks appear because `v["name"]` is a `&Value`//! containing a JSON string and its JSON representation is `"John Doe"`.//! Printing as a plain string without quotation marks involves converting from//! a JSON string to a Rust string with [`as_str()`] or avoiding the use of//! `Value` as described in the following section.//! [`as_str()`]: crate::Value::as_str//! The `Value` representation is sufficient for very basic tasks but can be//! tedious to work with for anything more significant. Error handling is//! verbose to implement correctly, for example imagine trying to detect the//! presence of unrecognized fields in the input data. The compiler is powerless//! to help you when you make a mistake, for example imagine typoing `v["name"]`//! as `v["nmae"]` in one of the dozens of places it is used in your code.//! # Parsing JSON as strongly typed data structures//! use serde::{Deserialize, Serialize};//! use serde_json::Result;//! fn typed_example() -> Result<()> {//!     // Parse the string of data into a Person object. This is exactly the//!     // same function as the one that produced serde_json::Value above, but//!     // now we are asking it for a Person as output.//!     let p: Person = serde_json::from_str(data)?;//!     // Do things just like with any other Rust data structure.//!     println!("Please call {} at the number {}", p.name, p.phones[0]);//! #     typed_example().unwrap();//! assign the return value to a variable of type `Person` so Serde will//! # Constructing JSON values//! objects with very natural JSON syntax.//! use serde_json::json;//!         "name": "John Doe",//!         "age": 43,//!         "phones": [//!             "+44 1234567",//!             "+44 2345678"//!         ]//! # use serde_json::json;//!     "name": full_name,//!     "age": age_last_year + 1,//!         format!("+44 {}", random_phone())//! This is amazingly convenient, but we have the problem we had before with//! `Value`: the IDE and Rust compiler cannot help us if we get it wrong. Serde//! JSON provides a better way of serializing strongly-typed data structures//! into JSON text.//! # Creating JSON by serializing data structures//! fn print_an_address() -> Result<()> {//!     // Some data structure.//!     let address = Address {//!         street: "10 Downing Street".to_owned(),//!         city: "London".to_owned(),//!     // Serialize it to a JSON string.//!     let j = serde_json::to_string(&address)?;//!     // Print, write to a file, or send to an HTTP server.//!     println!("{}", j);//! #     print_an_address().unwrap();//! As long as there is a memory allocator, it is possible to use serde_json//! without the rest of the Rust standard library. Disable the default "std"//! feature and enable the "alloc" feature://! serde_json = { version = "1.0", default-features = false, features = ["alloc"] }//! For JSON support in Serde without a memory allocator, please see the//! [`serde-json-core`] crate.//! [value]: crate::value::Value//! [from_str]: crate::de::from_str//! [from_slice]: crate::de::from_slice//! [from_reader]: crate::de::from_reader//! [to_string]: crate::ser::to_string//! [to_vec]: crate::ser::to_vec//! [to_writer]: crate::ser::to_writer//! [macro]: crate::json//! [`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-core/// # use serde_json::json;///         ],///         "homepage": null///     "code": code,///     "success": code == 200,///         features[0]: features[1]// Unexpected token after most recent element.// Current entry followed by unexpected token.// Refuse to absorb colon token into key expression.json_internal_vec// The json_internal macro above cannot invoke vec directly because it uses// local_inner_macros. A vec invocation there would resolve to $crate::vec.// Instead invoke vec here outside of local_inner_macros.json_unexpectedjson_expect_expr_comma/// Returns the key-value pair matching the given key./// value is returned./// If serde_json's "preserve_order" is enabled, `.remove(key)` is/// equivalent to [`.swap_remove(key)`][Self::swap_remove], replacing this/// entry's position with the last element. If you need to preserve the/// relative order of the keys in the map, use/// key was previously in the map./// If serde_json's "preserve_order" is enabled, `.remove_entry(key)` is/// equivalent to [`.swap_remove_entry(key)`][Self::swap_remove_entry],/// replacing this entry's position with the last element. If you need to/// preserve the relative order of the keys in the map, use/// [`.shift_remove_entry(key)`][Self::shift_remove_entry] instead./// Moves all elements from other into self, leaving other empty./// Gets an iterator over mutable values of the map./// In other words, remove all pairs `(k, v)` such that `f(&k, &mut v)`/// returns `false`.// clippy bug: https://github.com/rust-lang/rust-clippy/issues/7655/// match val {///     Value::String(s) => Some(s.as_str()),///     Value::Array(arr) => arr[0].as_str(),///     Value::Object(map) => map["type"].as_str(),/// [`Map`]: struct.Map.html/// map.entry("serde")///     .and_modify(|e| *e = json!("rust"))///     .or_insert(json!("cpp"));/// assert_eq!(map["serde"], "cpp");/// assert_eq!(map["serde"], "rust");ValuesMutImpl/// A mutable iterator over a serde_json::Map's values.//! By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`//! feature of serde_json to use [`IndexMap`] instead.//! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html//! [`IndexMap`]: https://docs.rs/indexmap/*/indexmap/map/struct.IndexMap.html// Implementing Eq is fine since any float values are always finite./// Returns true if the `Number` is an integer between `i64::MIN` and/// `i64::MAX`./// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to/// return the integer value./// let big = i64::MAX as u64 + 10;/// let v = json!({ "a": 64, "b": big, "c": 256.0 });/// assert!(v["a"].is_i64());/// // Greater than i64::MAX./// assert!(!v["b"].is_i64());/// // Numbers with a decimal point are not considered integers./// assert!(!v["c"].is_i64());/// Returns true if the `Number` is an integer between zero and `u64::MAX`./// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to/// let v = json!({ "a": 64, "b": -64, "c": 256.0 });/// assert!(v["a"].is_u64());/// // Negative integer./// assert!(!v["b"].is_u64());/// assert!(!v["c"].is_u64());/// Returns true if the `Number` can be represented by f64./// For any Number on which `is_f64` returns true, `as_f64` is guaranteed to/// return the floating point value./// Currently this function returns true if and only if both `is_i64` and/// `is_u64` return false but this is not a guarantee in the future./// let v = json!({ "a": 256.0, "b": 64, "c": -64 });/// assert!(v["a"].is_f64());/// // Integers./// assert!(!v["b"].is_f64());/// assert!(!v["c"].is_f64());/// If the `Number` is an integer, represent it as i64 if possible. Returns/// None otherwise./// assert_eq!(v["a"].as_i64(), Some(64));/// assert_eq!(v["b"].as_i64(), None);/// assert_eq!(v["c"].as_i64(), None);/// If the `Number` is an integer, represent it as u64 if possible. Returns/// assert_eq!(v["a"].as_u64(), Some(64));/// assert_eq!(v["b"].as_u64(), None);/// assert_eq!(v["c"].as_u64(), None);/// Represents the number as f64 if possible. Returns None otherwise./// assert_eq!(v["a"].as_f64(), Some(256.0));/// assert_eq!(v["b"].as_f64(), Some(64.0));/// assert_eq!(v["c"].as_f64(), Some(-64.0));/// # use std::f64;/// # use serde_json::Number;/// assert!(Number::from_f64(256.0).is_some());/// assert!(Number::from_f64(f64::NAN).is_none());impl_from_unsignedimpl_from_signed/// Reference to a range of bytes encompassing a single valid JSON value in the/// A `RawValue` can be used to defer parsing parts of a payload until later,/// or to avoid parsing it at all in the case that part of the payload just/// needs to be transferred verbatim into a different output object./// When serializing, a value of this type will retain its original formatting/// and will not be minified or pretty-printed./// `RawValue` is only available if serde\_json is built with the `"raw_value"`/// feature./// serde_json = { version = "1.0", features = ["raw_value"] }/// use serde::{Deserialize, Serialize};/// use serde_json::{Result, value::RawValue};/// struct Input<'a> {///     code: u32,///     #[serde(borrow)]///     payload: &'a RawValue,/// struct Output<'a> {///     info: (u32, &'a RawValue),/// // Efficiently rearrange JSON input containing separate "code" and "payload"/// // keys into a single "info" key holding an array of code and payload./// // This could be done equivalently using serde_json::Value as the type for/// // payload, but &RawValue will perform better because it does not require/// // memory allocation. The correct range of bytes is borrowed from the input/// // data and pasted verbatim into the output./// fn rearrange(input: &str) -> Result<String> {///     let input: Input = serde_json::from_str(input)?;///     let output = Output {///         info: (input.code, input.payload),///     serde_json::to_string(&output)///     let out = rearrange(r#" {"code": 200, "payload": {}} "#)?;///     assert_eq!(out, r#"{"info":[200,{}]}"#);/// # Ownership/// The typical usage of `RawValue` will be in the borrowed form:/// # use serde_json::value::RawValue;/// struct SomeStruct<'a> {///     raw_value: &'a RawValue,/// The borrowed form is suitable when deserializing through/// [`serde_json::from_str`] and [`serde_json::from_slice`] which support/// borrowing from the input data without memory allocation./// When deserializing through [`serde_json::from_reader`] you will need to use/// the boxed form of `RawValue` instead. This is almost as efficient but/// involves buffering the raw value from the I/O stream into memory./// [`serde_json::from_str`]: ../fn.from_str.html/// [`serde_json::from_slice`]: ../fn.from_slice.html/// [`serde_json::from_reader`]: ../fn.from_reader.html/// struct SomeStruct {///     raw_value: Box<RawValue>,from_borrowed/// Convert an owned `String` of JSON data to an owned `RawValue`./// This function is equivalent to `serde_json::from_str::<Box<RawValue>>`/// except that we avoid an allocation and memcpy if both of the following/// are true:/// - the input has no leading or trailing whitespace, and/// - the input has capacity equal to its length./// Access the JSON text underlying a raw value./// struct Response<'a> {/// fn process(input: &str) -> Result<()> {///     let response: Response = serde_json::from_str(input)?;///     let payload = response.payload.get();///     if payload.starts_with('{') {///         // handle a payload which is a JSON map///         // handle any other type///     process(r#" {"code": 200, "payload": {}} "#)?;/// Convert a `T` into a boxed `RawValue`./// // Upstream crate/// # #[derive(Serialize)]/// pub struct Thing {///     foo: String,///     bar: Option<String>,///     extra_data: Box<RawValue>,/// // Local crate/// use serde::Serialize;/// use serde_json::value::{to_raw_value, RawValue};/// struct MyExtraData {///     b: u32,/// let my_thing = Thing {///     foo: "FooVal".into(),///     bar: None,///     extra_data: to_raw_value(&MyExtraData { a: 1, b: 2 }).unwrap(),/// # assert_eq!(/// #     serde_json::to_value(my_thing).unwrap(),/// #     serde_json::json!({/// #         "foo": "FooVal",/// #         "bar": null,/// #         "extra_data": { "a": 1, "b": 2 }/// #     })/// use std::collections::BTreeMap;/// // The keys in this map are vectors, not strings./// let mut map = BTreeMap::new();/// map.insert(vec![32, 64], "x86");/// println!("{}", serde_json::value::to_raw_value(&map).unwrap_err());TOKENReferenceFromStringBoxedFromStringRawKeyDeserializerOwnedRawDeserializerBorrowedRawDeserializer/// Offset from the beginning of the input to the next byte that would be/// returned by next() or peek().ignore_str/// string until the next quotation mark but discards the data./// Assumes the previous byte was a hex escape sequence ('\u') in a string./// Parses next hexadecimal sequence.should_early_return_if_failed/// Whether StreamDeserializer::next needs to check the failed flag. True/// for IoRead, false for StrRead and SliceRead which can track failure by/// truncating their input slice to avoid the extra check on every nextset_failed/// Mark a persistent failure of StreamDeserializer, either by setting the/// flag or by truncating the input data./// "specialized" for iterating over `&[u8]`. Once feature(specialization) is/// The big optimization here over IoRead is that if the string contains no/// backslash escape sequences, the returned &str is a slice of the raw JSON/// data so we avoid copying into the scratch space./// Marker for whether StreamDeserializer can implement FusedIterator.peek_or_eofignore_escape/// Parses a JSON escape sequence and discards the value. Assumes the previous/// byte read was a backslash.HEXdecode_hex_valfloat_key_must_be_finitewrite_number_str/// Writes a number that has already been rendered to a string.write_byte_array/// Writes the representation of a byte array. Formatters can choose whether/// to represent bytes as a JSON array of integers (the default), or some/// JSON string encoding like hex or base64.write_raw_fragment/// Writes a raw JSON fragment that doesn't need any escaping to theUU__/// Serialize the given data structure as JSON into the I/O stream./// Serialization guarantees it only feeds valid UTF-8 sequences to the writer./// Serialize the given data structure as pretty-printed JSON into the I/Ovisit_arrayvisit_objectdeserialize_value_ref_numbervisit_array_refvisit_object_refMapKeyDeserializerKeyClassifierKeyClassBorrowedCowStrDeserializer/// Convert 32-bit floating point number to `Value::Number`, or/// `Value::Null` if infinite or NaN./// Convert 64-bit floating point number to `Value::Number`, or/// Convert boolean to `Value::Bool`./// Convert `String` to `Value::String`./// Convert string slice to `Value::String`./// Convert copy-on-write string to `Value::String`./// Convert `Number` to `Value::Number`./// use serde_json::{Number, Value};/// let n = Number::from(7);/// let x: Value = n.into();/// Convert map (with string keys) to `Value::Object`./// Convert a `Vec` to `Value::Array`./// Convert a slice to `Value::Array`./// Create a `Value::Array` by collecting an iterator of array elements./// Create a `Value::Object` by collecting an iterator of key-value pairs./// let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];/// Convert `()` to `Value::Null`./// let u = ();/// let x: Value = u.into();/// A type that can be used to index into a `serde_json::Value`./// The [`get`] and [`get_mut`] methods of `Value` accept any type that/// implements `Index`, as does the [square-bracket indexing operator]. This/// trait is implemented for strings which are used as the index into a JSON/// map, and for `usize` which is used as the index into a JSON array./// [`get`]: ../enum.Value.html#method.get/// [`get_mut`]: ../enum.Value.html#method.get_mut/// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E/// let data = json!({ "inner": [1, 2, 3] });/// // Data is a JSON map so it can be indexed with a string./// let inner = &data["inner"];/// // Inner is a JSON array so it can be indexed with an integer./// let first = &inner[0];/// assert_eq!(first, 1);/// let v = json!(null);/// let v = json!(true);/// let v = json!(12.5);/// let v = json!("a string");/// let v = json!(["an", "array"]);/// By default the map is backed by a BTreeMap. Enable the `preserve_order`/// feature of serde_json to use IndexMap instead, which preserves/// entries in the order they are inserted into the map. In particular, this/// allows JSON data to be deserialized into a Value and serialized to a/// string while retaining the order of map keys in the input./// let v = json!({ "an": "object" });/// See the [`serde_json::value` module documentation](self) for usage examples./// For any Value on which `is_object` returns true, `as_object` and/// `as_object_mut` are guaranteed to return the map representation of the/// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });/// assert!(obj.is_object());/// assert!(obj["a"].is_object());/// // array, not an object/// assert!(!obj["b"].is_object());/// If the `Value` is an Object, returns the associated Map. Returns None/// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });/// // The length of `{"nested": true}` is 1 entry./// assert_eq!(v["a"].as_object().unwrap().len(), 1);/// // The array `["an", "array"]` is not an object./// assert_eq!(v["b"].as_object(), None);/// let mut v = json!({ "a": { "nested": true } });/// v["a"].as_object_mut().unwrap().clear();/// assert_eq!(v, json!({ "a": {} }));/// For any Value on which `is_array` returns true, `as_array` and/// `as_array_mut` are guaranteed to return the vector representing the/// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });/// assert!(obj["a"].is_array());/// // an object, not an array/// assert!(!obj["b"].is_array());/// If the `Value` is an Array, returns the associated vector. Returns None/// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });/// // The length of `["an", "array"]` is 2 elements./// assert_eq!(v["a"].as_array().unwrap().len(), 2);/// // The object `{"an": "object"}` is not an array./// assert_eq!(v["b"].as_array(), None);/// let mut v = json!({ "a": ["an", "array"] });/// v["a"].as_array_mut().unwrap().clear();/// assert_eq!(v, json!({ "a": [] }));/// For any Value on which `is_string` returns true, `as_str` is guaranteed/// to return the string slice./// let v = json!({ "a": "some string", "b": false });/// assert!(v["a"].is_string());/// // The boolean `false` is not a string./// assert!(!v["b"].is_string());/// If the `Value` is a String, returns the associated str. Returns None/// assert_eq!(v["a"].as_str(), Some("some string"));/// assert_eq!(v["b"].as_str(), None);/// // JSON values are printed in JSON representation, so strings are in quotes./// //    The value is: "some string"/// println!("The value is: {}", v["a"]);/// // Rust strings are printed without quotes./// //    The value is: some string/// println!("The value is: {}", v["a"].as_str().unwrap());/// let v = json!({ "a": 1, "b": "2" });/// assert!(v["a"].is_number());/// // The string `"2"` is a string, not a number./// assert!(!v["b"].is_number());as_number/// If the `Value` is a Number, returns the associated [`Number`]. Returns/// # use serde_json::{json, Number};/// let v = json!({ "a": 1, "b": 2.2, "c": -3, "d": "4" });/// assert_eq!(v["a"].as_number(), Some(&Number::from(1u64)));/// assert_eq!(v["b"].as_number(), Some(&Number::from_f64(2.2).unwrap()));/// assert_eq!(v["c"].as_number(), Some(&Number::from(-3i64)));/// // The string `"4"` is not a number./// assert_eq!(v["d"].as_number(), None);/// Returns true if the `Value` is an integer between `i64::MIN` and/// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to/// let big = i64::max_value() as u64 + 10;/// Returns true if the `Value` is an integer between zero and `u64::MAX`./// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to/// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to/// If the `Value` is an integer, represent it as i64 if possible. Returns/// If the `Value` is an integer, represent it as u64 if possible. Returns/// If the `Value` is a number, represent it as f64 if possible. Returns/// For any Value on which `is_boolean` returns true, `as_bool` is/// guaranteed to return the boolean value./// let v = json!({ "a": false, "b": "false" });/// assert!(v["a"].is_boolean());/// // The string `"false"` is a string, not a boolean./// assert!(!v["b"].is_boolean());/// If the `Value` is a Boolean, returns the associated bool. Returns None/// assert_eq!(v["a"].as_bool(), Some(false));/// assert_eq!(v["b"].as_bool(), None);/// For any Value on which `is_null` returns true, `as_null` is guaranteed/// to return `Some(())`./// let v = json!({ "a": null, "b": false });/// assert!(v["a"].is_null());/// // The boolean `false` is not null./// assert!(!v["b"].is_null());/// If the `Value` is a Null, returns (). Returns None otherwise./// assert_eq!(v["a"].as_null(), Some(()));/// assert_eq!(v["b"].as_null(), None);///     // Or change the value only if it exists///     value.pointer_mut("/x").map(|v| *v = 1.5.into());///     let old_x = value.pointer_mut("/x").map(Value::take).unwrap();/// Takes the value out of the `Value`, leaving a `Null` in its place./// let mut v = json!({ "x": "y" });/// assert_eq!(v["x"].take(), json!("y"));/// assert_eq!(v, json!({ "x": null }));/// # fn try_main() -> Result<(), serde_json::Error> {/// # try_main().unwrap()/// use serde_json::json;/// fn compare_json_values() -> Result<(), Box<dyn Error>> {///     let u = User {///         fingerprint: "0xF9BA143B95FF6D82".to_owned(),///         location: "Menlo Park, CA".to_owned(),///     // The type of `expected` is `serde_json::Value`///     let expected = json!({///         "fingerprint": "0xF9BA143B95FF6D82",///         "location": "Menlo Park, CA",///     let v = serde_json::to_value(u).unwrap();///     assert_eq!(v, expected);/// # compare_json_values().unwrap();///     // The keys in this map are vectors, not strings.///     let mut map = BTreeMap::new();///     map.insert(vec![32, 64], "x86");///     println!("{}", serde_json::to_value(map).unwrap_err());///     // The type of `j` is `serde_json::Value`///     let j = json!({///         "location": "Menlo Park, CA"///     let u: User = serde_json::from_value(j).unwrap();//! [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` and//! use serde_json::{json, Value, Error};//! fn untyped_example() -> Result<(), Error> {//! # untyped_example().unwrap();eq_i64eq_u64eq_f32eq_f64eq_booleq_str/// Serializer whose output is a `Value`./// This is the serializer that backs [`serde_json::to_value`][crate::to_value]./// Unlike the main serde_json serializer which goes from some serializable/// value of type `T` to JSON text, this one goes from `T` to/// `serde_json::Value`./// The `to_value` function is implementable as:/// use serde_json::{Error, Value};/// pub fn to_value<T>(input: T) -> Result<Value, Error>///     input.serialize(serde_json::value::Serializer)//! [![github]](https://github.com/dtolnay/serde-repr)&ensp;[![crates-io]](https://crates.io/crates/serde_repr)&ensp;[![docs-rs]](https://docs.rs/serde_repr)//! Derive `Serialize` and `Deserialize` that delegates to the underlying repr//! of a C-like enum.//! use serde_repr::{Serialize_repr, Deserialize_repr};//! #[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug)]//! enum SmallPrime {//!     Two = 2,//!     Three = 3,//!     Five = 5,//!     Seven = 7,//! fn main() -> serde_json::Result<()> {//!     let j = serde_json::to_string(&SmallPrime::Seven)?;//!     assert_eq!(j, "7");//!     let p: SmallPrime = serde_json::from_str("2")?;//!     assert_eq!(p, SmallPrime::Two);default_variantVariantAttrsparse_serde_attris_spannedEND_FIELDSTART_FIELDVALUE_FIELD__unstable//! A [serde]-compatible spanned Value//! This allows capturing the location, in bytes, for a value in the original parsed document for//! compatible deserializers.//! [serde]: https://serde.rs/// Makes rustc abort compilation if there are any unsafe blocks in the crate.// Presence of this annotation is picked up by tools such as cargo-geiger// and lets them ensure that there is indeed no unsafe code as opposed to// something they couldn't detect (e.g. unsafe added via macro expansion, etc).// Currently serde itself doesn't have a spanned type, so we map our `Spanned`// to a special value in the serde data model. Namely one with these special// fields/struct names.// In general, supported deserializers should catch this and not literally emit// these strings but rather emit `Spanned` as they're intended./// Byte range/// The spanned value./// A spanned value, indicating the range at which it is defined in the source./// Create a spanned value encompassing the given byte range./// Transposing a `Spanned<Enum<T>>` into `Enum<Spanned<T>>`:/// use serde::de::{Deserialize, Deserializer};/// use serde_untagged::UntaggedEnumVisitor;/// use toml::Spanned;/// pub enum Dependency {///     Simple(Spanned<String>),///     Detailed(Spanned<DetailedDependency>),/// impl<'de> Deserialize<'de> for Dependency {///         enum DependencyKind {///             Simple(String),///             Detailed(DetailedDependency),///         impl<'de> Deserialize<'de> for DependencyKind {///             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>///                 D: Deserializer<'de>,///                 UntaggedEnumVisitor::new()///                     .expecting(///                         "a version string like \"0.9.8\" or a \///                             detailed dependency like { version = \"0.9.8\" }",///                     )///                     .string(|value| Ok(DependencyKind::Simple(value.to_owned())))///                     .map(|value| value.deserialize().map(DependencyKind::Detailed))///                     .deserialize(deserializer)///         let spanned: Spanned<DependencyKind> = Deserialize::deserialize(deserializer)?;///         let range = spanned.span();///         Ok(match spanned.into_inner() {///             DependencyKind::Simple(simple) => Dependency::Simple(Spanned::new(range, simple)),///             DependencyKind::Detailed(detailed) => Dependency::Detailed(Spanned::new(range, detailed)),/// # type DetailedDependency = std::collections::BTreeMap<String, String>;/// Consumes the spanned value and returns the contained value./// Returns a reference to the contained value./// Returns a mutable reference to the contained value.UrlEncodedParsede_Error/// Deserializes a `application/x-www-form-urlencoded` value from a `&[u8]`./// let meal = vec![///     ("bread".to_owned(), "baguette".to_owned()),///     ("cheese".to_owned(), "comté".to_owned()),///     ("meat".to_owned(), "ham".to_owned()),///     ("fat".to_owned(), "butter".to_owned()),///     serde_urlencoded::from_bytes::<Vec<(String, String)>>(///         b"bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"),///     Ok(meal));/// Deserializes a `application/x-www-form-urlencoded` value from a `&str`.///     serde_urlencoded::from_str::<Vec<(String, String)>>(///         "bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"),/// Convenience function that reads all bytes from `reader` and deserializes/// them with `from_bytes`.PartIterator/// A deserializer for the `application/x-www-form-urlencoded` format./// * Supported top-level outputs are structs, maps and sequences of pairs,///   with or without a given length./// * Main `deserialize` methods defers to `deserialize_map`./// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size`///   defers to `deserialize`./// Returns a new `Deserializer`.forward_parsed_valueValueEnumAccessUnitOnlyVariantAccess//! Deserialization support for the `application/x-www-form-urlencoded` format.//! `x-www-form-urlencoded` meets SerdeKeySinkserialize_static_strserialize_stringUrlEncodedSerializerUrlEncodedTarget/// Serializes a value into a `application/x-www-form-urlencoded` `String` buffer./// let meal = &[///     ("bread", "baguette"),///     ("cheese", "comté"),///     ("meat", "ham"),///     ("fat", "butter"),///     serde_urlencoded::to_string(meal),///     Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned()));urlencoder'output/// A serializer for the `application/x-www-form-urlencoded` format./// * Supported top-level inputs are structs, maps and sequences of pairs,/// * Supported keys and values are integers, bytes (if convertible to strings),///   unit structs and unit variants./// * Newtype structs defer to their inner values./// Returns a new `Serializer`./// Errors returned during serializing to `application/x-www-form-urlencoded`./// The lower-level cause of this error, in the case of a `Utf8` error./// The lower-level source of this error, in the case of a `Utf8` error./// Sequence serializer.TupleSerializer/// Tuple serializer./// Mostly used for arrays.TupleStructSerializer/// Tuple struct serializer./// Never instantiated, tuple structs are not supported.TupleVariantSerializer/// Tuple variant serializer./// Never instantiated, tuple variants are not supported.MapSerializer/// Map serializer.StructSerializer/// Struct serializer.StructVariantSerializer/// Struct variant serializer./// Never instantiated, struct variants are not supported./// Returns an error./// Returns `Ok`./// Serializes the inner value, ignoring the newtype name./// Serializes the given value./// Serialize a sequence, given length (if any) is ignored./// Serializes a map, given length is ignored./// Serializes a struct, given length is ignored.top_levelno_key//! Serialization support for the `application/x-www-form-urlencoded` format.PartSerializerValueSink'targetPairStatePairSerializerWaitingForKeyWaitingForValuenot_doneunsupported_pairserialize_integerserialize_floatingSerialPortSettingsTTYPort/// A convenience type alias for the system's native serial port type./// A convenience function for opening a native serial port./// The argument must be one that's understood by the target operating system to identify a serial/// port. On Unix systems, it should be a path to a TTY device file. On Windows, it should be the/// name of a COM port./// This function returns an error if the device could not be opened and initialized:/// * `NoDevice` if the device could not be opened. This could indicate that the device is///   already in use./// * `InvalidInput` if `port` is not a valid device name./// * `Io` for any other error while opening or initializing the device./// Provide a system-specific string that identifies a serial port:/// let port = serial::open("/dev/ttyUSB0").unwrap();/// Hard-coding the device name dimishes the cross-platform utility of `serial::open()`. To/// preserve cross-platform functionality, device names should come from external sources:/// for arg in env::args_os().skip(1) {///     let port = serial::open(&arg).unwrap();/// A module that exports traits that are useful to have in scope./// It is intended to be glob imported:/// use serial_core::prelude::*;/// A type for results generated by interacting with serial ports./// The `Err` type is hard-wired to [`serial_core::Error`](struct.Error.html)./// The device is not available./// This could indicate that the device is in use by another process or was disconnected while/// performing I/O./// A parameter was incorrect./// An I/O error occured./// The type of I/O error is determined by the inner `io::ErrorKind`./// Categories of errors that can occur when interacting with serial ports./// This list is intended to grow over time and it is not recommended to exhaustively match against/// An error type for serial port operations./// Returns the corresponding `ErrorKind` for this error.Baud110/// 110 baud.Baud300/// 300 baud.Baud600/// 600 baud.Baud1200/// 1200 baud.Baud2400/// 2400 baud.Baud4800/// 4800 baud.Baud9600/// 9600 baud.Baud19200/// 19,200 baud.Baud38400/// 38,400 baud.Baud57600/// 57,600 baud.Baud115200/// 115,200 baud.BaudOther/// Non-standard baud rates./// `BaudOther` can be used to set non-standard baud rates by setting its member to be the/// desired baud rate./// serial_core::BaudOther(4_000_000); // 4,000,000 baud/// Non-standard baud rates may not be supported on all systems./// Serial port baud rates./// ## Portability/// The `BaudRate` variants with numeric suffixes, e.g., `Baud9600`, indicate standard baud rates/// that are widely-supported on many systems. While non-standard baud rates can be set with/// `BaudOther`, their behavior is system-dependent. Some systems may not support arbitrary baud/// rates. Using the standard baud rates is more likely to result in portable applications.from_speed/// Creates a `BaudRate` for a particular speed./// This function can be used to select a `BaudRate` variant from an integer containing the/// # use serial_core::BaudRate;/// assert_eq!(BaudRate::Baud9600, BaudRate::from_speed(9600));/// assert_eq!(BaudRate::Baud115200, BaudRate::from_speed(115200));/// assert_eq!(BaudRate::BaudOther(4000000), BaudRate::from_speed(4000000));/// Returns the baud rate as an integer./// assert_eq!(9600, BaudRate::Baud9600.speed());/// assert_eq!(115200, BaudRate::Baud115200.speed());/// assert_eq!(4000000, BaudRate::BaudOther(4000000).speed());Bits5/// 5 bits per character.Bits6/// 6 bits per character.Bits7/// 7 bits per character.Bits8/// 8 bits per character./// Number of bits per character.ParityNone/// No parity bit.ParityOdd/// Parity bit sets odd number of 1 bits.ParityEven/// Parity bit sets even number of 1 bits./// Parity checking modes./// When parity checking is enabled (`ParityOdd` or `ParityEven`) an extra bit is transmitted with/// each character. The value of the parity bit is arranged so that the number of 1 bits in the/// character (including the parity bit) is an even number (`ParityEven`) or an odd number/// (`ParityOdd`)./// Parity checking is disabled by setting `ParityNone`, in which case parity bits are not/// transmitted.Stop1/// One stop bit.Stop2/// Two stop bits./// Number of stop bits./// Stop bits are transmitted after every character.FlowNone/// No flow control.FlowSoftware/// Flow control using XON/XOFF bytes.FlowHardware/// Flow control using RTS/CTS signals./// Flow control modes./// A type that implements the settings for the serial port device./// The `Settings` type is used to retrieve and modify the serial port's settings. This type/// should own any native structures used to manipulate the device's settings, but it should/// not cause any changes in the underlying hardware until written to the device with/// `write_settings()`.read_settings/// Returns the device's current settings./// This function attempts to read the current settings from the hardware. The hardware's/// current settings may not match the settings that were most recently written to the hardware/// with `write_settings()`./// This function returns an error if the settings could not be read from the underlying/// hardware:/// * `NoDevice` if the device was disconnected./// * `Io` for any other type of I/O error.write_settings/// Applies new settings to the serial device./// This function attempts to apply all settings to the serial device. Some settings may not be/// supported by the underlying hardware, in which case the result is dependent on the/// implementation. A successful return value does not guarantee that all settings were/// appliied successfully. To check which settings were applied by a successful write,/// applications should use the `read_settings()` method to obtain the latest configuration/// state from the device./// This function returns an error if the settings could not be applied to the underlying/// * `InvalidInput` if a setting is not compatible with the underlying hardware./// Returns the current timeout./// Sets the timeout for future I/O operations.set_rts/// Sets the state of the RTS (Request To Send) control signal./// Setting a value of `true` asserts the RTS control signal. `false` clears the signal./// This function returns an error if the RTS control signal could not be set to the desired/// state on the underlying hardware:set_dtr/// Sets the state of the DTR (Data Terminal Ready) control signal./// Setting a value of `true` asserts the DTR control signal. `false` clears the signal./// This function returns an error if the DTR control signal could not be set to the desiredread_cts/// Reads the state of the CTS (Clear To Send) control signal./// This function returns a boolean that indicates whether the CTS control signal is asserted./// This function returns an error if the state of the CTS control signal could not be read/// from the underlying hardware:read_dsr/// Reads the state of the DSR (Data Set Ready) control signal./// This function returns a boolean that indicates whether the DSR control signal is asserted./// This function returns an error if the state of the DSR control signal could not be readread_ri/// Reads the state of the RI (Ring Indicator) control signal./// This function returns a boolean that indicates whether the RI control signal is asserted./// This function returns an error if the state of the RI control signal could not be read from/// the underlying hardware:/// Reads the state of the CD (Carrier Detect) control signal./// This function returns a boolean that indicates whether the CD control signal is asserted./// This function returns an error if the state of the CD control signal could not be read fromSerialDevice/// A trait for implementing serial devices./// This trait is meant to be used to implement new serial port devices. To use a serial port/// device, the [`SerialPort`](trait.SerialPort.html) trait should be used instead. Any type that/// implements the `SerialDevice` trait will automatically implement the `SerialPort` trait as/// To implement a new serial port device, it's necessary to define a type that can manipulate the/// serial port device's settings (baud rate, parity mode, etc). This type is defined by the/// `Settings` associated type. The current settings should be determined by reading from the/// hardware or operating system for every call to `read_settings()`. The settings can then be/// manipulated in memory before being commited to the device with `write_settings()`./// Types that implement `SerialDevice` must also implement `std::io::Read` and `std::io::Write`./// The `read()` and `write()` operations of these traits should honor the timeout that has been/// set with the most recent successful call to `set_timeout()`. This timeout value should also be/// accessible by calling the `timeout()` method./// A serial port device should also provide access to some basic control signals: RTS, DTR, CTS,/// DSR, RI, and CD. The values for the control signals are represented as boolean values, with/// `true` indicating the the control signal is active./// Lastly, types that implement `SerialDevice` should release any acquired resources when dropped./// Configures a serial port device./// Alter the serial port's configuration./// This method expects a function, which takes a mutable reference to the serial port's/// configuration settings. The serial port's current settings, read from the device, are/// yielded to the provided function. After the function returns, any changes made to the/// settings object will be written back to the device./// This function returns an error if the `setup` function returns an error or if there was an/// error while reading or writing the device's configuration settings:/// * Any error returned by the `setup` function./// The following is a function that toggles a serial port's settings between one and two stop/// bits:/// fn toggle_stop_bits<T: SerialPort>(port: &mut T) -> serial_core::Result<()> {///     port.reconfigure(&|settings| {///         let stop_bits = match settings.stop_bits() {///             Some(serial_core::Stop1)        => serial_core::Stop2,///             Some(serial_core::Stop2) | None => serial_core::Stop1,///         settings.set_stop_bits(stop_bits);/// A trait for serial port devices./// Serial port input and output is implemented through the `std::io::Read` and `std::io::Write`/// traits. A timeout can be set with the `set_timeout()` method and applies to all subsequent I/O/// The `SerialPort` trait exposes several common control signals. Each control signal is/// represented as a boolean, where `true` indicates that the signal is asserted./// The serial port will be closed when the value is dropped.baud_rate/// Returns the current baud rate./// This function returns `None` if the baud rate could not be determined. This may occur if/// the hardware is in an uninitialized state. Setting a baud rate with `set_baud_rate()`/// should initialize the baud rate to a supported value./// Returns the character size./// This function returns `None` if the character size could not be determined. This may occur/// if the hardware is in an uninitialized state or is using a non-standard character size./// Setting a baud rate with `set_char_size()` should initialize the character size to a/// supported value./// Returns the parity-checking mode./// This function returns `None` if the parity mode could not be determined. This may occur if/// the hardware is in an uninitialized state or is using a non-standard parity mode. Setting/// a parity mode with `set_parity()` should initialize the parity mode to a supported value./// Returns the number of stop bits./// This function returns `None` if the number of stop bits could not be determined. This may/// occur if the hardware is in an uninitialized state or is using an unsupported stop bit/// configuration. Setting the number of stop bits with `set_stop-bits()` should initialize the/// stop bits to a supported value./// Returns the flow control mode./// This function returns `None` if the flow control mode could not be determined. This may/// occur if the hardware is in an uninitialized state or is using an unsupported flow control/// mode. Setting a flow control mode with `set_flow_control()` should initialize the flow/// control mode to a supported value./// Sets the baud rate./// If the implementation does not support the requested baud rate, this function may return an/// `InvalidInput` error. Even if the baud rate is accepted by `set_baud_rate()`, it may not be/// supported by the underlying hardware./// Sets the character size./// Sets the parity-checking mode./// Sets the number of stop bits./// Sets the flow control mode./// A trait for objects that implement serial port configurations./// Baud rate./// Character size./// Parity checking mode./// Flow control mode./// A device-indepenent implementation of serial port settings.default_port_settingsport_settings_manipulates_baud_rateport_settings_manipulates_char_sizeport_settings_manipulates_parityport_settings_manipulates_stop_bitsport_settings_manipulates_flow_controlTMPBUF_SZ// the rest of this module is borrowed from libstd//! Serial port implementation for Unix operating systems.wait_read_fdwait_write_fdwait_fddo_poll/// A TTY-based serial port implementation./// The port will be closed when the value is dropped./// Opens a TTY device as a serial port./// `path` should be the path to a TTY device, e.g., `/dev/ttyS0`./// serial_unix::TTYPort::open(Path::new("/dev/ttyS0")).unwrap();set_pinread_pinTTYSettings/// Serial port settings for TTY devices.default_settingstty_settings_sets_baud_ratetty_settings_overwrites_baud_ratetty_settings_sets_char_sizetty_settings_overwrites_char_sizetty_settings_sets_parity_eventty_settings_sets_parity_oddtty_settings_sets_parity_nonetty_settings_sets_stop_bits_1tty_settings_sets_stop_bits_2tty_settings_sets_flow_control_softwaretty_settings_sets_flow_control_hardwaretty_settings_sets_flow_control_none// Per rustc target feature docs for `aarch64-unknown-linux-gnu` and// `aarch64-apple-darwin` platforms, the `sha2` target feature enables// SHA-1 as well:// > Enable SHA1 and SHA256 support.//! SHA-1 `aarch64` backend.round0aschelduleround0bsha1_first_addsha1msg1sha1msg2sha1_first_halfsha1_digest_round_x4sha1rnds4csha1rnds4psha1rnds4mrounds4schedule_rounds4sha1_digest_block_u32shani_cpuid//! SHA-1 `x86`/`x86_64` backendSha1Core/// SHA-1 compression functionSTATE_LEN/// Core SHA-1 hasher state./// SHA-1 hasher state.//! Pure Rust implementation of the [SHA-1][1] cryptographic hash algorithm//! with optional hardware-specific optimizations.//! # 🚨 Warning: Cryptographically Broken! 🚨//! The SHA-1 hash function should be considered cryptographically broken and//! unsuitable for further use in any security critical capacity, as it is//! [practically vulnerable to chosen-prefix collisions][2].//! We provide this crate for legacy interoperability purposes only.//! use sha1::{Sha1, Digest};//! // create a Sha1 object//! let mut hasher = Sha1::new();//! // which in this case is equivalent to [u8; 20]//! assert_eq!(result[..], hex!("2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"));//! Also see [RustCrypto/hashes][3] readme.//! # Note for users of `sha1 v0.6`//! This crate has been transferred to the RustCrypto organization and uses//! implementation previously published as the `sha-1` crate. The previous//! zero dependencies version is now published as the [`sha1_smol`] crate.//! [1]: https://en.wikipedia.org/wiki/SHA-1//! [2]: https://sha-mbles.github.io///! [3]: https://github.com/RustCrypto/hashes//! [`sha1_smol`]: https://github.com/mitsuhiko/sha1-smol/State256State512K32/// Constants necessary for SHA-256 family of digests.K32X4K64/// Constants necessary for SHA-512 family of digests.K64X2H256_224H256_256H512_224H512_256H512_384H512_512compress256compress512Sha256VarCore/// Core block-level SHA-256 hasher with variable output size./// Supports initialization only for 28 and 32 byte output sizes,/// i.e. 224 and 256 bits respectively.Sha512VarCore/// Core block-level SHA-512 hasher with variable output size./// Supports initialization only for 28, 32, 48, and 64 byte output sizes,/// i.e. 224, 256, 384, and 512 bits respectively.OidSha256OidSha384OidSha512OidSha224OidSha512_224OidSha512_256/// SHA-224 hasher./// SHA-256 hasher.Sha512_224/// SHA-512/224 hasher.Sha512_256/// SHA-512/256 hasher./// SHA-384 hasher./// SHA-512 hasher.//! An implementation of the [SHA-2][1] cryptographic hash algorithms.//! There are 6 standard algorithms specified in the SHA-2 standard: [`Sha224`],//! [`Sha256`], [`Sha512_224`], [`Sha512_256`], [`Sha384`], and [`Sha512`].//! Algorithmically, there are only 2 core algorithms: SHA-256 and SHA-512.//! All other algorithms are just applications of these with different initial//! hash values, and truncated to different digest bit lengths. The first two//! algorithms in the list are based on SHA-256, while the last four are based//! on SHA-512.//! use sha2::{Sha256, Sha512, Digest};//! // create a Sha256 object//! let mut hasher = Sha256::new();//! // write input message//! // read hash digest and consume hasher//! assert_eq!(result[..], hex!("//!     b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9//! ")[..]);//! // same for Sha512//! let mut hasher = Sha512::new();//!     309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f//!     989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f//! [1]: https://en.wikipedia.org/wiki/SHA-2sha256_compressvsha256hq_u32vsha256h2q_u32vsha256su0q_u32vsha256su1q_u32//! SHA-256 `aarch64` backend.// Implementation adapted from mbedtls.// TODO: stdarch intrinsics: RustCrypto/hashes#257// TODO remove these polyfills once SHA2 intrinsics landroundaroundbsha256loadsha256swapsha256msg1sha256msg2sha256_digest_round_x2sha256_digest_block_u32/// Process a block with the SHA-256 algorithm.// we use unaligned loads with `__m128i` pointers//! SHA-256 `x86`/`x86_64` backend/// Raw SHA-256 compression function./// This is a low-level "hazmat" API which provides direct access to the core/// functionality of SHA-256.sha512_compressvsha512hq_u64uint64x2_tvsha512h2q_u64vsha512su0q_u64vsha512su1q_u64// TODO remove these polyfills once SHA3 intrinsics landsha512load/// Not an intrinsic, but works like an unaligned load.sha512_schedule_x2/// Performs 2 rounds of the SHA-512 message schedule update.sha512_digest_round/// Performs one round of the SHA-512 message block digest.sha512_digest_block_u64/// Process a block with the SHA-512 algorithm.sha512_compress_x86_64_avx2sha512_compress_x86_64_avxload_data_avxMsgScheduleload_data_avx2RoundStatesrounds_0_63_avxrounds_0_63_avx2rounds_64_79process_second_blocksha_roundaccumulate_statefn_sha512_update_xsha512_update_x_avxsha512_update_x_avx2cast_msSHA512_BLOCK_WORDS_NUMcast_rsSHA512_ROUNDS_NUMSHA512_HASH_WORDS_NUMSHA512_BLOCK_BYTE_LENSHA512_HASH_BYTE_LEN//! SHA-512 `x86`/`x86_64` backend/// Raw SHA-512 compression function./// functionality of SHA-512.ShadowConstgen_constConstValShadowGenConstTypenew_boolOptStrCiTypeGithubGitlab// Jenkins,// Travis,format_descriptionwell_knownRfc2822Rfc3339UtcOffsetnow_date_timeoffset_datetimelocal_nowtimestamp_2_utchuman_formattest_source_date_epochtest_local_now_human_formattest_timestamp_2_utcdep_source_replacefilter_cargo_treeSdResultSystemEnvBUILD_OSRUST_VERSIONRUST_CHANNELCARGO_VERSIONCARGO_TREEBUILD_TARGETBUILD_TARGET_ARCHCARGO_MANIFEST_DIRPKG_VERSIONPKG_DESCRIPTIONPKG_VERSION_MAJORPKG_VERSION_MINORPKG_VERSION_PATCHPKG_VERSION_PREpath_existsDEP_REPLACE_NONEDEP_REPLACE_PATHDEP_REPLACE_GITDEP_REPLACE_REGISTRYfilter_dep_source/// filter cargo tree dependencies source/// Why do this?/// Sometimes, the private registry or private git url that our cargo relies on will carry this information/// with the cargo tree command output we use. In order to protect the privacy of dependence, we need to shield it./// This can protect us from the security issues we rely on environmental information./// I think it is very necessary.So we need to do fuzzy replacement of dependent output./// for examples:/// - dep by git: shadow-rs = { git = "https://github.com/baoyachi/shadow-rs", branch="master" }/// - dep by registry: shadow-rs = { version = "0.5.23",registry="private-crates" }/// - dep by path: shadow-rs = { path = "/Users/baoyachi/shadow-rs" }///  before exec: cargo tree output by difference dependencies source:/// - git: └── shadow-rs v0.5.23 (https://github.com/baoyachi/shadow-rs?branch=master#eb712990)/// - registry: └── shadow-rs v0.5.23 (registry ssh://git@github.com/baoyachi/shadow-rs.git)/// - path: └── shadow-rs v0.5.23 ((/Users/baoyachi/shadow-rs))/// after filter dependencies source/// - git: └── shadow-rs v0.5.23 (* git)/// - registry: └── shadow-rs v0.5.23 (* registry)/// - path: └── shadow-rs v0.5.23 (* path)new_system_envProjectPROJECT_NAMEBUILD_TIMEBUILD_TIME_2822BUILD_TIME_3339BUILD_RUST_CHANNELbuild_timenew_projecttest_filter_dep_source_nonetest_filter_dep_source_multitest_filter_dep_source_pathtest_filter_dep_source_registrytest_filter_dep_source_git_httpstest_filter_dep_source_git_httptest_filter_dep_source_gittest_filter_dep_windows_path// const CARGO_METADATA: ShadowConst = "CARGO_METADATA";ShadowErrorVERSION_BRANCH_CONSTVERSION_TAG_CONSTCLAP_VERSION_BRANCH_CONSTCLAP_VERSION_TAG_CONSTCLAP_LONG_VERSION_BRANCH_CONSTCLAP_LONG_VERSION_TAG_CONSTVERSION_CONST_DESCCLAP_VERSION_CONST_DESCCLAP_LONG_VERSION_CONST_DESCversion_branch_constversion_tag_constclap_version_branch_constclap_version_tag_constclap_long_version_branch_constclap_long_version_tag_constBUILD_CONST_VERSIONBUILD_CONST_CLAP_LONG_VERSIONtest_version_fnciBRANCHLAST_TAGSHORT_COMMITCOMMIT_HASHCOMMIT_DATECOMMIT_DATE_2822COMMIT_DATE_3339COMMIT_AUTHORCOMMIT_EMAILGIT_CLEANGIT_STATUS_FILEci_typeGitupdate_strupdate_boolinit_git2git2_dirty_stage//use git2 crates git repository 'dirty or stage' status files.ci_branch_tagnew_gitgit2Errorgit_repogit2_current_branchgit2_mod/// get current repository git branch./// When current repository exists git folder./// It's use default feature.This function try use [git2] crates get current branch./// If not use git2 feature,then try use [Command] to get./// get current repository git tag./// I's use [Command] to get.git_clean/// Check current git Repository status without nothing(dirty or stage)/// if nothing,It means clean:true. On the contrary, it is 'dirty':false/// List current git Repository statue(dirty or stage) contain file changed/// Refer to the 'cargo fix' result output when git statue(dirty or stage) changed./// Example output:`   * examples/builtin_fn.rs (dirty)`command_current_tag/// Command exec git current tagcommand_last_tag/// git describe --tags --abbrev=0 HEAD/// Command exec git last tagcommand_git_clean/// git clean:git status --porcelain/// check repository git status is cleancommand_git_status_file/// check git repository 'dirty or stage' status files./// git dirty:git status  --porcelain | grep '^\sM.' |awk '{print $2}'/// git stage:git status --porcelain --untracked-files=all | grep '^[A|M|D|R]'|awk '{print $2}'command_current_branch/// Command exec git current branchfilter_git_dirty_stageget_std_envtest_gittest_current_branchtest_command_last_tag/// Get current project build mode./// It's very useful. Debug mode is usually used for debugging information./// For example, log printing, environment variable switch./// The default value is `true`./// If we compile with `cargo build --release`. It's return value is `false`.std_envSHADOW_RS/// Add a mod in project with `$build_mod`./// You can use `shadow!(build_shadow)`. Then shadow-rs can help you add a mod with name `build_shadow`./// Next, use mod with name `build_shadow`,and also use const like:`build_shadow::BRANCH`./// Normally, you just config `shadow!(build)`.It looks more concise./// It's shadow-rs Initialization entry./// In build.rs `main()` function call for this function./// fn main() -> shadow_rs::SdResult<()> {///    shadow_rs::new()new_deny/// It's shadow-rs Initialization entry, If deny const is configured, constants will not be generated.///    let mut deny = BTreeSet::new();///    deny.insert(shadow_rs::CARGO_TREE);///    shadow_rs::new_deny(deny)new_hook/// It's shadow-rs Initialization entry with add custom hook.///    shadow_rs::new_hook(append_write_const)/// fn append_write_const(mut file: &File) -> SdResult<()> {///    let foo: &str = r#"pub const foo: &str = "foo";"#;///    writeln!(file, "{}", foo)?;/// get std::env:varsdeny_consttry_ci/// try get current ci envfilter_denycargo_rerun_if_env_changedcargo_rerun_env_injectwrite_constgen_versiongen_build_intest_build_deny//! `shadow-rs` :build-time information stored in your rust project.(binary,lib,cdylib,dylib)//! It's allows you to recall properties of the build process and environment at runtime, including://! `Cargo.toml` project version//! * Dependency information//! * The Git commit that produced the build artifact (binary)//! * What version of the rust toolchain was used in compilation//! * The build variant, e.g. `debug` or `release`//! * (And more)//! You can use this tool to check in production exactly where a binary came from and how it was built.//! # Full Examples//! * Check out the [example_shadow](https://github.com/baoyachi/shadow-rs/tree/master/example_shadow) for a simple demonstration of how `shadow-rs` might be used to provide build-time information at run-time.//! * Check out the [example_shadow_hook](https://github.com/baoyachi/shadow-rs/tree/master/example_shadow_hook) for a simple demonstration of how `shadow-rs` might be used to provide build-time information at run-time,and add custom hook.//! ## Built in function//! * Check out the [examples](https://github.com/baoyachi/shadow-rs/tree/master/examples) for a simple demonstration of how `shadow-rs` might be used to provide build in function.//! pub const PKG_VERSION :&str = "1.3.8-beta3";//! pub const PKG_VERSION_MAJOR :&str = "1";//! pub const PKG_VERSION_MINOR :&str = "3";//! pub const PKG_VERSION_PATCH :&str = "8";//! pub const PKG_VERSION_PRE :&str = "beta3";//! pub const RUST_VERSION :&str = "rustc 1.45.0 (5c1f21c3b 2020-07-13)";//! pub const BUILD_RUST_CHANNEL :&str = "debug";//! pub const COMMIT_AUTHOR :&str = "baoyachi";//! pub const BUILD_TIME :&str = "2020-08-16 13:48:52";//! pub const BUILD_TIME_2822 :&str = "Thu, 24 Jun 2021 21:44:14 +0800";//! pub const BUILD_TIME_3339 :&str = "2021-06-24T15:53:55+08:00";//! pub const COMMIT_DATE :&str = "2021-08-04 12:34:03 +00:00";//! pub const COMMIT_DATE_2822 :&str = "Thu, 24 Jun 2021 21:44:14 +0800";//! pub const COMMIT_DATE_3339 :&str = "2021-06-24T21:44:14.473058+08:00";//! pub const COMMIT_EMAIL :&str = "xxx@gmail.com";//! pub const PROJECT_NAME :&str = "shadow-rs";//! pub const RUST_CHANNEL :&str = "stable-x86_64-apple-darwin (default)";//! pub const BRANCH :&str = "master";//! pub const CARGO_LOCK :&str = r#"//! ├── chrono v0.4.19//! │   ├── libc v0.2.80//! │   ├── num-integer v0.1.44//! │   │   └── num-traits v0.2.14//! │   │       [build-dependencies]//! │   │       └── autocfg v1.0.1//! │   ├── num-traits v0.2.14 (*)//! │   └── time v0.1.44//! │       └── libc v0.2.80//! └── git2 v0.13.12//! ├── log v0.4.11//! │   └── cfg-if v0.1.10//! └── url v2.2.0//! ├── form_urlencoded v1.0.0//! │   └── percent-encoding v2.1.0//! └── percent-encoding v2.1.0"#;//! pub const CARGO_VERSION :&str = "cargo 1.45.0 (744bd1fbb 2020-06-15)";//! pub const BUILD_OS :&str = "macos-x86_64";//! pub const COMMIT_HASH :&str = "386741540d73c194a3028b96b92fdeb53ca2788a";//! pub const GIT_CLEAN :bool = true;//! pub const GIT_STATUS_FILE :&str = "* src/lib.rs (dirty)";//! # Setup Guide//! ### 1) Modify `Cargo.toml` fields//! Modify your `Cargo.toml` like so://! [package]//! build = "build.rs"//! shadow-rs = "{latest version}"//! ### 2) Create `build.rs` file//! Now in the root of your project (same directory as `Cargo.toml`) add a file `build.rs`://! fn main() -> shadow_rs::SdResult<()> {//!    shadow_rs::new()//! ### 3) Integrate Shadow//! In your rust file (e.g. `*.rs`)://! use shadow_rs::shadow;//! shadow!(build);//! **Notice that the `shadow!` macro is provided the identifier `build`.  You can now use this identifier to access build-time information.**//! ### 4) Done. Use Shadow.//! Then you can use const that's shadow build it(main.rs).//! The `build` mod just we use `shadow!(build)` generated.//! fn main(){//!    println!("debug:{}", shadow_rs::is_debug()); // check if this is a debug build. e.g 'true/false'//!    println!("branch:{}", shadow_rs::branch()); // get current project branch. e.g 'master/develop'//!    println!("tag:{}", shadow_rs::tag()); // get current project tag. e.g 'v1.3.5'//!    println!("git_clean:{}", shadow_rs::git_clean()); // get current project clean. e.g 'true/false'//!    println!("git_status_file:{}", shadow_rs::git_status_file()); // get current project statue file. e.g '  * examples/builtin_fn.rs (dirty)'//!    println!("{}",build::VERSION); //print version const//!    println!("{}",build::CLAP_LONG_VERSION); //print CLAP_LONG_VERSION const//!    println!("{}",build::BRANCH); //master//!    println!("{}",build::SHORT_COMMIT);//8405e28e//!    println!("{}",build::COMMIT_HASH);//8405e28e64080a09525a6cf1b07c22fcaf71a5c5//!    println!("{}",build::COMMIT_DATE);//2021-08-04 12:34:03 +00:00//!    println!("{}",build::COMMIT_AUTHOR);//baoyachi//!    println!("{}",build::COMMIT_EMAIL);//xxx@gmail.com//!    println!("{}",build::BUILD_OS);//macos-x86_64//!    println!("{}",build::RUST_VERSION);//rustc 1.45.0 (5c1f21c3b 2020-07-13)//!    println!("{}",build::RUST_CHANNEL);//stable-x86_64-apple-darwin (default)//!    println!("{}",build::CARGO_VERSION);//cargo 1.45.0 (744bd1fbb 2020-06-15)//!    println!("{}",build::PKG_VERSION);//0.3.13//!    println!("{}",build::CARGO_TREE); //like command:cargo tree//!    println!("{}",build::CARGO_MANIFEST_DIR); // /User/baoyachi/shadow-rs/ |//!    println!("{}",build::PROJECT_NAME);//shadow-rs//!    println!("{}",build::BUILD_TIME);//2020-08-16 14:50:25//!    println!("{}",build::BUILD_RUST_CHANNEL);//debug//!    println!("{}",build::GIT_CLEAN);//false//!    println!("{}",build::GIT_STATUS_FILE);//* src/lib.rs (dirty)//! ## Clap example//! And you can also use `shadow-rs` with [`clap`](https://github.com/baoyachi/shadow-rs/blob/master/example_shadow/src/main.rs).//! [The shadow-rs document](https://github.com/baoyachi/shadow-rs).RefCountPack/// The maximum number of threads which can access the slab./// This value (rounded to a power of two) determines the number of shards/// in the slab. If a thread is created, accesses the slab, and then terminates,/// its shard may be reused and thus does not count against the maximum/// number of threads once the thread has terminated.MAX_PAGES/// The maximum number of pages in each shard in the slab./// This value, in combination with `INITIAL_PAGE_SIZE`, determines how many/// bits of each index are used to represent page addresses.INITIAL_PAGE_SIZE/// The size of the first page in each shard./// When a page in a shard has been filled with values, a new page/// will be allocated that is twice as large as the previous page. Thus, the/// second page will be twice this size, and the third will be four times/// this size, and so on./// Note that page sizes must be powers of two. If this value is not a power/// of two, it will be rounded to the next power of two.RESERVED_BITS/// Sets a number of high-order bits in each index which are reserved from/// user code./// Note that these bits are taken from the generation counter; if the page/// address and thread IDs are configured to use a large number of bits,/// reserving additional bits will decrease the period of the generation/// counter. These should thus be used relatively sparingly, to ensure that/// generation counters are able to effectively prevent the ABA problem./// Configuration parameters which can be overridden to tune the behavior of a slab.USED_BITSINITIAL_SZMAX_SHARDSADDR_INDEX_SHIFTDebugConfigunpack_addrunpack_tidTidunpack_genCfgPrivate/// Default slab configuration values._cfgnext_pow2validates_max_refscustom_page_sz// === impl DefaultConfig ===/// Clear all data in `self`, retaining the allocated capacithy./// Trait implemented by types which can be cleared in place, retaining any/// allocated memory./// This is essentially a generalization of methods on standard library/// collection types, including as [`Vec::clear`], [`String::clear`], and/// [`HashMap::clear`]. These methods drop all data stored in the collection,/// but retain the collection's heap allocation for future use. Types such as/// `BTreeMap`, whose `clear` methods drops allocations, should not/// When implemented for types which do not own a heap allocation, `Clear`/// should reset the type in place if possible. If the type has an empty state/// or stores `Option`s, those values should be reset to the empty state. For/// "plain old data" types, which hold no pointers to other data and do not have/// an empty or initial state, it's okay for a `Clear` implementation to be a/// no-op. In that case, it essentially serves as a marker indicating that the/// type may be reused to store new data./// [`Vec::clear`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.clear/// [`String::clear`]: https://doc.rust-lang.org/stable/std/string/struct.String.html#method.clear/// [`HashMap::clear`]: https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html#method.clear// This module exists only to provide a separate page for the implementation//! Notes on `sharded-slab`'s implementation and design.//! # Design//! The sharded slab's design is strongly inspired by the ideas presented by//! Leijen, Zorn, and de Moura in [Mimalloc: Free List Sharding in//! Action][mimalloc]. In this report, the authors present a novel design for a//! memory allocator based on a concept of _free list sharding_.//! Memory allocators must keep track of what memory regions are not currently//! allocated ("free") in order to provide them to future allocation requests.//! The term [_free list_][freelist] refers to a technique for performing this//! bookkeeping, where each free block stores a pointer to the next free block,//! forming a linked list. The memory allocator keeps a pointer to the most//! recently freed block, the _head_ of the free list. To allocate more memory,//! the allocator pops from the free list by setting the head pointer to the//! next free block of the current head block, and returning the previous head.//! To deallocate a block, the block is pushed to the free list by setting its//! first word to the current head pointer, and the head pointer is set to point//! to the deallocated block. Most implementations of slab allocators backed by//! arrays or vectors use a similar technique, where pointers are replaced by//! indices into the backing array.//! When allocations and deallocations can occur concurrently across threads,//! they must synchronize accesses to the free list; either by putting the//! entire allocator state inside of a lock, or by using atomic operations to//! treat the free list as a lock-free structure (such as a [Treiber stack]). In//! both cases, there is a significant performance cost — even when the free//! list is lock-free, it is likely that a noticeable amount of time will be//! spent in compare-and-swap loops. Ideally, the global synchronzation point//! created by the single global free list could be avoided as much as possible.//! The approach presented by Leijen, Zorn, and de Moura is to introduce//! sharding and thus increase the granularity of synchronization significantly.//! In mimalloc, the heap is _sharded_ so that each thread has its own//! thread-local heap. Objects are always allocated from the local heap of the//! thread where the allocation is performed. Because allocations are always//! done from a thread's local heap, they need not be synchronized.//! However, since objects can move between threads before being deallocated,//! _deallocations_ may still occur concurrently. Therefore, Leijen et al.//! introduce a concept of _local_ and _global_ free lists. When an object is//! deallocated on the same thread it was originally allocated on, it is placed//! on the local free list; if it is deallocated on another thread, it goes on//! the global free list for the heap of the thread from which it originated. To//! allocate, the local free list is used first; if it is empty, the entire//! global free list is popped onto the local free list. Since the local free//! list is only ever accessed by the thread it belongs to, it does not require//! synchronization at all, and because the global free list is popped from//! infrequently, the cost of synchronization has a reduced impact. A majority//! of allocations can occur without any synchronization at all; and//! deallocations only require synchronization when an object has left its//! parent thread (a relatively uncommon case).//! [mimalloc]: https://www.microsoft.com/en-us/research/uploads/prod/2019/06/mimalloc-tr-v1.pdf//! [freelist]: https://en.wikipedia.org/wiki/Free_list//! [Treiber stack]: https://en.wikipedia.org/wiki/Treiber_stack//! A slab is represented as an array of [`MAX_THREADS`] _shards_. A shard//! consists of a vector of one or more _pages_ plus associated metadata.//! Finally, a page consists of an array of _slots_, head indices for the local//! and remote free lists.//! ┌─────────────┐//! │ shard 1     │//! │             │    ┌─────────────┐        ┌────────┐//! │ pages───────┼───▶│ page 1      │        │        │//! ├─────────────┤    ├─────────────┤  ┌────▶│  next──┼─┐//! │ shard 2     │    │ page 2      │  │     ├────────┤ │//! ├─────────────┤    │             │  │     │XXXXXXXX│ │//! │ shard 3     │    │ local_head──┼──┘     ├────────┤ │//! └─────────────┘    │ remote_head─┼──┐     │        │◀┘//!       ...          ├─────────────┤  │     │  next──┼─┐//! ┌─────────────┐    │ page 3      │  │     ├────────┤ │//! │ shard n     │    └─────────────┘  │     │XXXXXXXX│ │//! └─────────────┘          ...        │     ├────────┤ │//!                    ┌─────────────┐  │     │XXXXXXXX│ │//!                    │ page n      │  │     ├────────┤ │//!                    └─────────────┘  │     │        │◀┘//!                                     └────▶│  next──┼───▶  ...//!                                           ├────────┤//!                                           │XXXXXXXX│//!                                           └────────┘//! The size of the first page in a shard is always a power of two, and every//! subsequent page added after the first is twice as large as the page that//! preceeds it.//! pg.//! ┌───┐   ┌─┬─┐//! │ 0 │───▶ │ │//! ├───┤   ├─┼─┼─┬─┐//! │ 1 │───▶ │ │ │ │//! ├───┤   ├─┼─┼─┼─┼─┬─┬─┬─┐//! │ 2 │───▶ │ │ │ │ │ │ │ │//! ├───┤   ├─┼─┼─┼─┼─┼─┼─┼─┼─┬─┬─┬─┬─┬─┬─┬─┐//! │ 3 │───▶ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │//! └───┘   └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘//! When searching for a free slot, the smallest page is searched first, and if//! it is full, the search proceeds to the next page until either a free slot is//! found or all available pages have been searched. If all available pages have//! been searched and the maximum number of pages has not yet been reached, a//! new page is then allocated.//! Since every page is twice as large as the previous page, and all page sizes//! are powers of two, we can determine the page index that contains a given//! address by shifting the address down by the smallest page size and//! looking at how many twos places necessary to represent that number,//! telling us what power of two page size it fits inside of. We can//! determine the number of twos places by counting the number of leading//! zeros (unused twos places) in the number's binary representation, and//! subtracting that count from the total number of bits in a word.//! The formula for determining the page number that contains an offset is thus://! WIDTH - ((offset + INITIAL_PAGE_SIZE) >> INDEX_SHIFT).leading_zeros()//! where `WIDTH` is the number of bits in a `usize`, and `INDEX_SHIFT` is//! INITIAL_PAGE_SIZE.trailing_zeros() + 1;//! [`MAX_THREADS`]: https://docs.rs/sharded-slab/latest/sharded_slab/trait.Config.html#associatedconstant.MAX_THREADSUniqueIter/// An exclusive fused iterator over the items in a [`Slab`](crate::Slab)./// A sharded slab./// See the [crate-level documentation](crate) for details on using this type./// A handle that allows access to an occupied entry in a [`Slab`]./// While the guard exists, it indicates to the slab that the item the guard/// references is currently being accessed. If the item is removed from the slab/// while a guard exists, the removal will be deferred until all guards areInitGuard/// A handle to a vacant entry in a [`Slab`]./// `VacantEntry` allows constructing values with the key that they will be/// assigned to./// # use sharded_slab::Slab;/// let mut slab = Slab::new();/// let hello = {///     let entry = slab.vacant_entry().unwrap();///     let key = entry.key();///     entry.insert((key, "hello"));///     key/// assert_eq!(hello, slab.get(hello).unwrap().0);/// assert_eq!("hello", slab.get(hello).unwrap().1);OwnedEntry/// An owned reference to an occupied entry in a [`Slab`]./// while the guard exists, the  removal will be deferred until all guards are/// Unlike [`Entry`], which borrows the slab, an `OwnedEntry` clones the [`Arc`]/// around the slab. Therefore, it keeps the slab from being dropped until all/// such guards have been dropped. This means that an `OwnedEntry` may be held for/// an arbitrary lifetime./// let slab: Arc<Slab<&'static str>> = Arc::new(Slab::new());/// let key = slab.insert("hello world").unwrap();/// // Look up the created key, returning an `OwnedEntry`./// let value = slab.clone().get_owned(key).unwrap();/// // Now, the original `Arc` clone of the slab may be dropped, but the/// // returned `OwnedEntry` can still access the value./// assert_eq!(value, "hello world");/// Unlike [`Entry`], an `OwnedEntry` may be stored in a struct which must live/// for the `'static` lifetime:/// use sharded_slab::OwnedEntry;/// pub struct MyStruct {///     entry: OwnedEntry<&'static str>,///     // ... other fields .../// // Suppose this is some arbitrary function which requires a value that/// // lives for the 'static lifetime.../// fn function_requiring_static<T: 'static>(t: &T) {///     // ... do something extremely important and interesting .../// let entry = slab.clone().get_owned(key).unwrap();/// let my_struct = MyStruct {///     entry,/// // We can use `my_struct` anywhere where it is required to have the/// // `'static` lifetime:/// function_requiring_static(&my_struct);/// `OwnedEntry`s may be sent between threads:/// use std::{thread, sync::Arc};///     assert_eq!(value, "hello world");/// [`get`]: Slab::get/// [`Arc`]: std::sync::Arc/// Returns a new slab with the default configuration parameters.new_with_config/// Returns a new slab with the provided configuration parameters./// The number of bits in each index which are used by the slab./// If other data is packed into the `usize` indices returned by/// [`Slab::insert`], user code is free to use any bits higher than the/// `USED_BITS`-th bit freely./// This is determined by the [`Config`] type that configures the slab's/// parameters. By default, all bits are used; this can be changed by/// overriding the [`Config::RESERVED_BITS`][res] constant./// [res]: crate::Config#RESERVED_BITS/// Inserts a value into the slab, returning the integer index at which that/// value was inserted. This index can then be used to access the entry./// If this function returns `None`, then the shard for the current thread/// is full and no items can be added until some are removed, or the maximum/// number of shards has been reached./// let slab = Slab::new();/// assert_eq!(slab.get(key).unwrap(), "hello world");/// Return a handle to a vacant entry allowing for further manipulation./// This function is useful when creating values that must contain their/// slab index. The returned [`VacantEntry`] reserves a slot in the slab and/// is able to return the index of the entry./// Remove the value at the given index in the slab, returning `true` if a/// value was removed./// Unlike [`take`], this method does _not_ block the current thread until/// the value can be removed. Instead, if another thread is currently/// accessing that value, this marks it to be removed by that thread when it/// finishes accessing the value./// let slab = sharded_slab::Slab::new();/// // Remove the item from the slab./// assert!(slab.remove(key));/// // Now, the slot is empty./// assert!(!slab.contains(key));/// let slab = Arc::new(sharded_slab::Slab::new());/// let slab2 = slab.clone();/// let thread2 = std::thread::spawn(move || {///     // Depending on when this thread begins executing, the item may///     // or may not have already been removed...///     if let Some(item) = slab2.get(key) {///         assert_eq!(item, "hello world");/// // The item will be removed by thread2 when it finishes accessing it./// thread2.join().unwrap();/// [`take`]: Slab::take/// Removes the value associated with the given key from the slab, returning/// If the slab does not contain a value for that key, `None` is returned/// If the value associated with the given key is currently being/// accessed by another thread, this method will block the current thread/// until the item is no longer accessed. If this is not desired, use/// [`remove`] instead./// **Note**: This method blocks the calling thread by spinning until the/// currently outstanding references are released. Spinning for long periods/// of time can result in high CPU time and power consumption. Therefore,/// `take` should only be called when other references to the slot are/// expected to be dropped soon (e.g., when all accesses are relatively/// short)./// // Remove the item from the slab, returning it./// assert_eq!(slab.take(key), Some("hello world"));/// // The item will only be removed when the other thread finishes/// // accessing it./// [`remove`]: Slab::remove/// Return a reference to the value associated with the given key./// If the slab does not contain a value for the given key, or if the/// maximum number of concurrent references to the slot has been reached,/// `None` is returned instead./// assert!(slab.get(12345).is_none());/// Return an owned reference to the value at the given index./// If the slab does not contain a value for the given key, `None` is/// returned instead./// Unlike [`get`], which borrows the slab, this method _clones_ the [`Arc`]/// around the slab. This means that the returned [`OwnedEntry`] can be held/// for an arbitrary lifetime. However,  this method requires that the slab/// itself be wrapped in an `Arc`./// [`OwnedEntry`]s may be sent between threads:/// Returns `true` if the slab contains a value for the given key./// assert!(slab.contains(key));/// slab.take(key).unwrap();unique_iter/// Returns an iterator over all the items in the slab./// Because this iterator exclusively borrows the slab (i.e. it holds an/// `&mut Slab<T>`), elements will not be added or removed while the/// iteration is in progress./// Returns the key used to access the guard./// Insert a value in the entry./// To get the integer index at which this value will be inserted, use/// [`key`] prior to calling `insert`./// [`key`]: VacantEntry::key/// Return the integer index at which this entry will be inserted./// A value stored in this entry will be associated with this key./// # use sharded_slab::*;/// Returns the key used to access this guard/// The number of bits occupied by this type when packed into a usize./// This must be provided to determine the number of bits into which to pack/// The type packed on the less significant side of this type./// If this type is packed into the least significant bit of a usize, this/// should be `()`, which occupies no bytes./// This is used to calculate the shift amount for packing this value./// A number consisting of `Self::LEN` 1 bits, starting at the least/// significant bit./// This is the higest value this type can represent. This number is shifted/// left by `Self::SHIFT` bits to calculate this type's `MASK`./// This is computed automatically based on `Self::LEN`./// The number of bits to shift a number to pack it into a usize with other/// This is caculated automatically based on the `LEN` and `SHIFT` constants/// of the previous value./// The mask to extract only this type from a packed `usize`./// This is calculated by shifting `Self::BITS` left by `Self::SHIFT`.from_packed// ====== provided by each implementation =================================// ====== calculated automatically ========================================//! A lock-free concurrent slab.//! Slabs provide pre-allocated storage for many instances of a single data//! type. When a large number of values of a single type are required,//! this can be more efficient than allocating each item individually. Since the//! allocated items are the same size, memory fragmentation is reduced, and//! creating and removing new items can be very cheap.//! This crate implements a lock-free concurrent slab, indexed by `usize`s.//! First, add this to your `Cargo.toml`://! sharded-slab = "0.1.1"//! This crate provides two  types, [`Slab`] and [`Pool`], which provide//! slightly different APIs for using a sharded slab.//! [`Slab`] implements a slab for _storing_ small types, sharing them between//! threads, and accessing them by index. New entries are allocated by//! [inserting] data, moving it in by value. Similarly, entries may be//! deallocated by [taking] from the slab, moving the value out. This API is//! similar to a `Vec<Option<T>>`, but allowing lock-free concurrent insertion//! and removal.//! In contrast, the [`Pool`] type provides an [object pool] style API for//! _reusing storage_. Rather than constructing values and moving them into the//! pool, as with [`Slab`], [allocating an entry][create] from the pool takes a//! closure that's provided with a mutable reference to initialize the entry in//! place. When entries are deallocated, they are [cleared] in place. Types//! which own a heap allocation can be cleared by dropping any _data_ they//! store, but retaining any previously-allocated capacity. This means that a//! [`Pool`] may be used to reuse a set of existing heap allocations, reducing//! allocator load.//! [inserting]: Slab::insert//! [taking]: Slab::take//! [create]: Pool::create//! [cleared]: Clear//! [object pool]: https://en.wikipedia.org/wiki/Object_pool_pattern//! Inserting an item into the slab, returning an index://! # use sharded_slab::Slab;//! let slab = Slab::new();//! let key = slab.insert("hello world").unwrap();//! assert_eq!(slab.get(key).unwrap(), "hello world");//! To share a slab across threads, it may be wrapped in an `Arc`://! let slab = Arc::new(Slab::new());//! let slab2 = slab.clone();//! let thread2 = std::thread::spawn(move || {//!     let key = slab2.insert("hello from thread two").unwrap();//!     assert_eq!(slab2.get(key).unwrap(), "hello from thread two");//!     key//! let key1 = slab.insert("hello from thread one").unwrap();//! assert_eq!(slab.get(key1).unwrap(), "hello from thread one");//! // Wait for thread 2 to complete.//! let key2 = thread2.join().unwrap();//! // The item inserted by thread 2 remains in the slab.//! assert_eq!(slab.get(key2).unwrap(), "hello from thread two");//! If items in the slab must be mutated, a `Mutex` or `RwLock` may be used for//! each item, providing granular locking of items rather than of the slab://! use std::sync::{Arc, Mutex};//! let key = slab.insert(Mutex::new(String::from("hello world"))).unwrap();//!     let hello = slab2.get(key).expect("item missing");//!     let mut hello = hello.lock().expect("mutex poisoned");//!     *hello = String::from("hello everyone!");//! thread2.join().unwrap();//! let hello = slab.get(key).expect("item missing");//! let mut hello = hello.lock().expect("mutex poisoned");//! assert_eq!(hello.as_str(), "hello everyone!");//! # Configuration//! For performance reasons, several values used by the slab are calculated as//! constants. In order to allow users to tune the slab's parameters, we provide//! a [`Config`] trait which defines these parameters as associated `consts`.//! The `Slab` type is generic over a `C: Config` parameter.//! [`Config`]: trait.Config.html//! # Comparison with Similar Crates//! - [`slab`]: Carl Lerche's `slab` crate provides a slab implementation with a//!   similar API, implemented by storing all data in a single vector.//!   Unlike `sharded_slab`, inserting and removing elements from the slab//!   requires  mutable access. This means that if the slab is accessed//!   concurrently by multiple threads, it is necessary for it to be protected//!   by a `Mutex` or `RwLock`. Items may not be inserted or removed (or//!   accessed, if a `Mutex` is used) concurrently, even when they are//!   unrelated. In many cases, the lock can become a significant bottleneck. On//!   the other hand, this crate allows separate indices in the slab to be//!   accessed, inserted, and removed concurrently without requiring a global//!   lock. Therefore, when the slab is shared across multiple threads, this//!   crate offers significantly better performance than `slab`.//!   However, the lock free slab introduces some additional constant-factor//!   overhead. This means that in use-cases where a slab is _not_ shared by//!   multiple threads and locking is not required, this crate will likely offer//!   slightly worse performance.//!   In summary: `sharded-slab` offers significantly improved performance in//!   concurrent use-cases, while `slab` should be preferred in single-threaded//!   use-cases.//! [`slab`]: https://crates.io/crates/loom//! # Safety and Correctness//! Most implementations of lock-free data structures in Rust require some//! amount of unsafe code, and this crate is not an exception. In order to catch//! potential bugs in this unsafe code, we make use of [`loom`], a//! permutation-testing tool for concurrent Rust programs. All `unsafe` blocks//! this crate occur in accesses to `loom` `UnsafeCell`s. This means that when//! those accesses occur in this crate's tests, `loom` will assert that they are//! valid under the C11 memory model across multiple permutations of concurrent//! executions of those tests.//! In order to guard against the [ABA problem][aba], this crate makes use of//! _generational indices_. Each slot in the slab tracks a generation counter//! which is incremented every time a value is inserted into that slot, and the//! indices returned by [`Slab::insert`] include the generation of the slot when//! the value was inserted, packed into the high-order bits of the index. This//! ensures that if a value is inserted, removed,  and a new value is inserted//! into the same slot in the slab, the key returned by the first call to//! `insert` will not map to the new value.//! Since a fixed number of bits are set aside to use for storing the generation//! counter, the counter will wrap  around after being incremented a number of//! times. To avoid situations where a returned index lives long enough to see the//! generation counter wrap around to the same value, it is good to be fairly//! generous when configuring the allocation of index bits.//! [`loom`]: https://crates.io/crates/loom//! [aba]: https://en.wikipedia.org/wiki/ABA_problem//! [`Slab::insert`]: struct.Slab.html#method.insert//! These graphs were produced by [benchmarks] of the sharded slab implementation,//! using the [`criterion`] crate.//! The first shows the results of a benchmark where an increasing number of//! items are inserted and then removed into a slab concurrently by five//! threads. It compares the performance of the sharded slab implementation//! with a `RwLock<slab::Slab>`://! <img width="1124" alt="Screen Shot 2019-10-01 at 5 09 49 PM" src="https://user-images.githubusercontent.com/2796466/66078398-cd6c9f80-e516-11e9-9923-0ed6292e8498.png">//! The second graph shows the results of a benchmark where an increasing//! number of items are inserted and then removed by a _single_ thread. It//! compares the performance of the sharded slab implementation with an//! `RwLock<slab::Slab>` and a `mut slab::Slab`.//! <img width="925" alt="Screen Shot 2019-10-01 at 5 13 45 PM" src="https://user-images.githubusercontent.com/2796466/66078469-f0974f00-e516-11e9-95b5-f65f0aa7e494.png">//! These benchmarks demonstrate that, while the sharded approach introduces//! a small constant-factor overhead, it offers significantly better//! performance across concurrent accesses.//! [benchmarks]: https://github.com/hawkw/sharded-slab/blob/master/benches/bench.rs//! [`criterion`]: https://crates.io/crates/criterion//! # Implementation Notes//! See [this page](crate::implementation) for details on this crate's design//! and implementation.// === impl Entry ===// === impl VacantEntry ===// === impl OwnedEntry ===// === pack ===test_printlndebug_assert_eq_in_drop/// A page address encodes the location of a slot within a shard (the page/// number and offset within that page) as a single linear value.FreeList/// Index of the first slot on the local free listTransferStack/// The remote free list/// Slots freed from a remote thread are pushed onto this list.// Total size of the page.// If the head index of the local or remote free list is greater than the size of the// page, then that free list is emtpy. If the head of both free lists is greater than `size`// then there are no slots left in that page.prev_sz/// Return the head of the freelist/// If there is space on the local list, it returns the head of the local list. Otherwise, it/// pops all the slots from the global list and returns the head of that list/// *Note*: The local list's head is reset when setting the new state in the slot pointed to be/// `head` returned from this functionis_unallocated/// Returns `true` if storage is currently allocated for this page, `false`with_slotmake_ref// Need this function separately, as we need to pass a function pointer to `filter_map` and// `Slot::value` just returns a `&T`, specifically a `&Option<T>` for this impl./// Allocates storage for the page's slots.mark_clear/// The offset of the next item on the free list./// The data stored in the slot.curr_lifecycleLifecycleLifecycleGenMarkedRemoving/// Use all the remaining bits in the word for the generation counter, minus/// any bits reserved by the user.set_nextmark_release/// Marks this slot to be released, returning `true` if the slot can be/// mutated *now* and `false` otherwise./// This method checks if there are any references to this slot. If there _are_ valid/// references, it just marks them for modification and returns and the next thread calling/// either `clear_storage` or `remove_value` will try and modify the storagerelease_with/// Mutates this slot./// This method spins until no references to this slot are left, and calls the mutator/// Initialize a slot/// This method initializes and sets up the state for a slot. When being used in `Pool`, we/// only need to ensure that the `Slot` is in the right `state, while when being used in a/// `Slab` we want to insert a value into it, as the memory is not initialized// Slot methods which should work across all trait bounds/// Insert a value into a slot/// We first initialize the state and then insert the pased in value into the slot.try_remove_value/// Tries to remove the value in the slot, returning `true` if the value was/// This method tries to remove the value in the slot. If there are existing references, then/// the slot is marked for removal and the next thread calling either this method or/// `remove_value` will do the work instead.remove_value// Slot impl which _needs_ an `Option` for self.item, this is for `Slab` to use.try_clear_storage/// Try to clear this slot's storage/// If there are references to this slot, then we mark this slot for clearing and let the last/// thread do the work for us.clear_storage/// Clear this slot's storage/// This method blocks until all references have been dropped and clears the storage.// These impls are specific to `Pool`/// Releases the guard, returning `true` if the slot should be cleared./// This dereferences a raw pointer to the slot. The caller is responsible/// for ensuring that the `Guard` does not outlive the slab that contains/// the pointed slot. Failure to do so means this pointer may dangle./// Returns a borrowed reference to the slot./// Returns a borrowed reference to the slot's value.MARKEDREMOVINGPRESENTdecr/// for ensuring that the `InitGuard` does not outlive the slab that/// contains the pointed slot. Failure to do so means this pointer may/// dangle./// Returns a mutably borrowed reference to the slot's value./// It's safe to reference the slot mutably, though, because creating an/// `InitGuard` ensures there are no outstanding immutable references./// Downgrades the guard to an immutable guardrelease2exponential_backoff// === impl Generation ===// === impl Guard ===// === impl Lifecycle ===// === impl RefCount ===// === impl LifecycleGen ===// === helpers ===pop_all/// A lock-free concurrent object pool./// Slabs provide pre-allocated storage for many instances of a single type. But, when working with/// heap allocated objects, the advantages of a slab are lost, as the memory allocated for the/// object is freed when the object is removed from the slab. With a pool, we can instead reuse/// this memory for objects being added to the pool in the future, therefore reducing memory/// fragmentation and avoiding additional allocations./// This type implements a lock-free concurrent pool, indexed by `usize`s. The items stored in this/// type need to implement [`Clear`] and `Default`./// The `Pool` type shares similar semantics to [`Slab`] when it comes to sharing across threads/// and storing mutable shared data. The biggest difference is there are no [`Slab::insert`] and/// [`Slab::take`] analouges for the `Pool` type. Instead new items are added to the pool by using/// the [`Pool::create`] method, and marked for clearing by the [`Pool::clear`] method./// Add an entry to the pool, returning an index:/// # use sharded_slab::Pool;/// let pool: Pool<String> = Pool::new();/// let key = pool.create_with(|item| item.push_str("hello world")).unwrap();/// assert_eq!(pool.get(key).unwrap(), String::from("hello world"));/// Create a new pooled item, returning a guard that allows mutable access:/// let mut guard = pool.create().unwrap();/// let key = guard.key();/// guard.push_str("hello world");/// drop(guard); // release the guard, allowing immutable access./// Pool entries can be cleared by calling [`Pool::clear`]. This marks the entry to/// be cleared when the guards referencing to it are dropped./// // Mark this entry to be cleared./// pool.clear(key);/// // The cleared entry is no longer available in the pool/// assert!(pool.get(key).is_none());/// # Configuration/// Both `Pool` and [`Slab`] share the same configuration mechanism. See [crate level documentation][config-doc]/// [`Slab::take`]: crate::Slab::take/// [`Slab::insert`]: crate::Slab::insert/// [`Pool::create`]: Pool::create/// [`Pool::clear`]: Pool::clear/// [config-doc]: crate#configuration/// [`Clear`]: crate::Clear/// [`Slab`]: crate::Slab/// A guard that allows access to an object in a pool./// While the guard exists, it indicates to the pool that the item the guard references is/// currently being accessed. If the item is removed from the pool while the guard exists, the/// removal will be deferred until all guards are dropped./// A guard that allows exclusive mutable access to an object in a pool./// While the guard exists, it indicates to the pool that the item the guard/// references is currently being accessed. If the item is removed from the pool/// while a guard exists, the removal will be deferred until the guard is/// dropped. The slot cannot be accessed by other threads while it is accessed/// mutably.OwnedRef/// An owned guard that allows shared immutable access to an object in a pool./// Unlike [`Ref`], which borrows the pool, an `OwnedRef` clones the `Arc`/// around the pool. Therefore, it keeps the pool from being dropped until all/// such guards have been dropped. This means that an `OwnedRef` may be held for/// let pool: Arc<Pool<String>> = Arc::new(Pool::new());/// // Look up the created `Key`, returning an `OwnedRef`./// let value = pool.clone().get_owned(key).unwrap();/// // Now, the original `Arc` clone of the pool may be dropped, but the/// // returned `OwnedRef` can still access the value./// assert_eq!(value, String::from("hello world"));/// Unlike [`Ref`], an `OwnedRef` may be stored in a struct which must live/// use sharded_slab::pool::OwnedRef;///     pool_ref: OwnedRef<String>,/// let pool_ref = pool.clone().get_owned(key).unwrap();///     pool_ref,/// `OwnedRef`s may be sent between threads:///     assert_eq!(value, String::from("hello world"));/// [`Ref`]: crate::pool::RefOwnedRefMut/// An owned guard that allows exclusive, mutable access to an object in a pool./// An `OwnedRefMut<T>` functions more or less identically to an owned/// `Box<T>`: it can be passed to functions, stored in structure fields, and/// borrowed mutably or immutably, and can be owned for arbitrary lifetimes./// The difference is that, unlike a `Box<T>`, the memory allocation for the/// `T` lives in the `Pool`; when an `OwnedRefMut` is created, it may reuse/// memory that was allocated for a previous pooled object that has been/// cleared. Additionally, the `OwnedRefMut` may be [downgraded] to an/// [`OwnedRef`] which may be shared freely, essentially turning the `Box`/// into an `Arc`./// This is returned by [`Pool::create_owned`]./// while the guard exists, theremoval will be deferred until all guards are/// Unlike [`RefMut`], which borrows the pool, an `OwnedRefMut` clones the `Arc`/// such guards have been dropped. This means that an `OwnedRefMut` may be held for/// // Create a new pooled item, returning an owned guard that allows mutable/// // access to the new item./// let mut item = pool.clone().create_owned().unwrap();/// // Return a key that allows indexing the created item once the guard/// // has been dropped./// let key = item.key();/// // Mutate the item./// item.push_str("Hello");/// // Drop the guard, releasing mutable access to the new item./// drop(item);/// /// Other threads may now (immutably) access the item using the returned key.///    assert_eq!(pool.get(key).unwrap(), String::from("Hello"));/// // Create a new item, returning an owned, mutable guard./// let mut value = pool.clone().create_owned().unwrap();/// // returned `OwnedRefMut` can still access the value./// drop(pool);/// value.push_str("hello world");/// Unlike [`RefMut`], an `OwnedRefMut` may be stored in a struct which must live/// use sharded_slab::pool::OwnedRefMut;///     pool_ref: OwnedRefMut<String>,/// // Create a new item, returning a mutable owned reference./// let pool_ref = pool.clone().create_owned().unwrap();/// `OwnedRefMut`s may be sent between threads:/// let key = value.key();///     value.push_str("hello world");/// // Once the `OwnedRefMut` has been dropped by the other thread, we may/// // now access the value immutably on this thread./// Downgrading from a mutable to an immutable reference:/// // Downgrade the mutable owned ref to an immutable owned ref./// let value = value.downgrade();/// // Once the `OwnedRefMut` has been downgraded, other threads may/// // immutably access the pooled value:///     assert_eq!(pool.get(key).unwrap(), String::from("hello world"));/// // This thread can still access the pooled value through the/// // immutable owned ref:/// [`Pool::create_owned`]: crate::Pool::create_owned/// [`RefMut`]: crate::pool::RefMut/// [`OwnedRefMut`]: crate::pool::OwnedRefMut/// [downgraded]: crate::pool::OwnedRefMut::downgrade/// Returns a new `Pool` with the default configuration parameters./// Returns a new `Pool` with the provided configuration parameters./// The number of bits in each index which are used by the pool./// [`Pool::create`], user code is free to use any bits higher than the/// This is determined by the [`Config`] type that configures the pool's/// [`Config`]: trait.Config.html/// [res]: trait.Config.html#associatedconstant.RESERVED_BITS/// [`Slab::insert`]: struct.Slab.html#method.insert/// Creates a new object in the pool, returning an [`RefMut`] guard that/// may be used to mutate the new object./// If this function returns `None`, then the shard for the current thread is full and no items/// can be added until some are removed, or the maximum number of shards has been reached./// // Create a new pooled item, returning a guard that allows mutable/// let mut item = pool.create().unwrap();create_owned/// Creates a new object in the pool, returning an [`OwnedRefMut`] guard that/// Unlike [`create`], which borrows the pool, this method _clones_ the `Arc`/// around the pool if a value exists for the given key. This means that the/// returned [`OwnedRefMut`] can be held for an arbitrary lifetime. However,/// this method requires that the pool itself be wrapped in an `Arc`./// [`create`]: Pool::create/// [`OwnedRef`]: crate::pool::OwnedRef/// Creates a new object in the pool with the provided initializer,/// returning a key that may be used to access the new object./// // Create a new pooled item, returning its integer key./// let key = pool.create_with(|s| s.push_str("Hello")).unwrap();/// /// Other threads may now (immutably) access the item using the key./// Return a borrowed reference to the value associated with the given key./// If the pool does not contain a value for the given key, `None` is returned instead./// assert!(pool.get(12345).is_none());/// Return an owned reference to the value associated with the given key./// If the pool does not contain a value for the given key, `None` is/// Unlike [`get`], which borrows the pool, this method _clones_ the `Arc`/// returned [`OwnedRef`] can be held for an arbitrary lifetime. However,/// [`get`]: Pool::get/// Remove the value using the storage associated with the given key from the pool, returning/// `true` if the value was removed./// This method does _not_ block the current thread until the value can be/// cleared. Instead, if another thread is currently accessing that value, this marks it to be/// cleared by that thread when it is done accessing that value./// // Check out an item from the pool./// item.push_str("hello world");/// let key = pool.create_with(|item| item.push_str("Hello world!")).unwrap();/// // Clearing a key that doesn't exist in the `Pool` will return `false`/// assert_eq!(pool.clear(key + 69420), false);/// // Clearing a key that does exist returns `true`/// assert!(pool.clear(key));/// // Clearing a key that has previously been cleared will return `false`/// assert_eq!(pool.clear(key), false);/// [`clear`]: #method.clear/// Downgrades the mutable guard to an immutable guard, allowing access to/// the pooled value from other threads./// # use std::{sync::Arc, thread};/// let pool = Arc::new(Pool::<String>::new());/// let mut guard_mut = pool.clone().create_owned().unwrap();/// let key = guard_mut.key();/// guard_mut.push_str("Hello");/// // The pooled string is currently borrowed mutably, so other threads/// // may not access it./// let pool2 = pool.clone();///     assert!(pool2.get(key).is_none())/// // Downgrade the guard to an immutable reference./// let guard = guard_mut.downgrade();/// // Now, other threads may also access the pooled value.///     let guard = pool2.get(key)///         .expect("the item may now be referenced by other threads");///     assert_eq!(guard, String::from("Hello"));/// // We can still access the value immutably through the downgraded guard./// assert_eq!(guard, String::from("Hello"));/// Downgrades the owned mutable guard to an owned immutable guard, allowing/// access to the pooled value from other threads.//! A lock-free concurrent object pool.//! See the [`Pool` type's documentation][pool] for details on the object pool API and how//! it differs from the [`Slab`] API.//! [pool]: ../struct.Pool.html//! [`Slab`]: ../struct.Slab.html// === impl Ref ===// === impl GuardMut ===// === impl OwnedRef ===// === impl OwnedRefMut ===/// The shard's parent thread ID./// The local free list for each page./// These are only ever accessed from this shard's thread, so they are/// stored separately from the shared state for the page that can be/// accessed concurrently, to minimize false sharing./// The shared state for each page in this shard./// This consists of the page's metadata (size, previous size), remote free/// list, and a pointer to the actual array backing that page.// ┌─────────────┐      ┌────────┐// │ page 1      │      │        │// ├─────────────┤ ┌───▶│  next──┼─┐// │ page 2      │ │    ├────────┤ │// │             │ │    │XXXXXXXX│ │// │ local_free──┼─┘    ├────────┤ │// │ global_free─┼─┐    │        │◀┘// ├─────────────┤ └───▶│  next──┼─┐// │   page 3    │      ├────────┤ │// └─────────────┘      │XXXXXXXX│ │//       ...            ├────────┤ │// ┌─────────────┐      │XXXXXXXX│ │// │ page n      │      ├────────┤ │// └─────────────┘      │        │◀┘//                      │  next──┼───▶//                      ├────────┤//                      │XXXXXXXX│//                      └────────┘//                         ...take_local/// Remove an item on the shard's local thread.take_remote/// Remove an item, while on a different thread from the shard's local thread.remove_localremove_remotemark_clear_localmark_clear_remoteclear_after_releaseclear_localclear_remote// === impl Shard ===// === impl Array ===// === impl Ptr ===// === Iterators ===/// Track allocations, detecting leaks/// Track a value for leaks/// Get a reference to the value/// Get a mutable reference to the value/// Stop tracking the value for leaksCustomConfig// We should repeat actions several times to detect invalid lifecycle changes.slab_eqinsert_remove/// Calls `insert(); remove()` multiple times to detect invalid releasing./// Initially, it revealed bugs in the `Slot::release_with()` implementation.double_get/// Calls `get()` multiple times to detect invalid ref counting./// Initially, it revealed bugs in the `Slot::get()` implementation.//! Ensures that a custom config behaves as the default config, until limits are reached.//! Prevents regression after #80.is_droppedis_clearedassert_clearassert_not_clearDontDropMedont_dropconcurrent_create_with_clearracy_clearclear_local_and_reusecreate_mut_guard_prevents_accesscreate_mut_guardcreate_mut_guard_2create_mut_guard_downgradecreate_mut_guard_downgrade_clearcreate_mut_downgrade_during_clearownedref_send_out_of_localownedrefs_outlive_poolownedref_ping_pongownedref_drop_from_other_threadscreate_owned_mut_guardcreate_owned_mut_guard_sendcreate_owned_mut_guard_2create_owned_mut_guard_downgradecreate_owned_mut_guard_downgrade_then_clearcreate_owned_mut_downgrade_during_clearcreate_mut_downgrade_during_clear_by_other_theadracy_takeracy_take_localconcurrent_insert_taketake_remote_and_reusestore_when_freeTinierConfigconcurrent_remove_remote_and_reuseSetDroppedAssertDroppedassert_droppedremove_remote_during_insertmax_refsTinyConfiglocal_removelocal_takefree_list_reusevacant_entry_2vacant_entry_removeowned_entry_send_out_of_localowned_entrys_outlive_slabowned_entry_ping_pongowned_entry_drop_from_other_threadscustom_configRemoveRandomRemoveExistent// keyTakeRandom// seedTakeExistentGetExistentaction_kind_strategy// Use `IndexMap` to preserve determinism.prev_value/// Stores active entries (added and not yet removed).get_anyremove_anyused_bitsapply_actionTestCaseError//! This module contains property-based tests against the public API://! * API never panics.//! * Active entries cannot be overridden until removed.//! * The slab doesn't produce overlapping keys.//! * The slab doesn't leave "lost" keys.//! * `get()`, `get_owned`, and `contains()` are consistent.//! * `RESERVED_BITS` are actually not used.//! The test is supposed to be deterministic, so it doesn't spawn real threads//! and uses `tid::with()` to override the TID for the current thread./// Uniquely identifies a thread.REGISTRY/// Returns true if the local thread ID was accessed while unwinding.// Reusing thread IDs doesn't work under loom, since this `Drop` impl results in// an access to a `loom` lazy_static while the test is shutting down, which// panics. T_T// Just skip TID reuse and use loom's lazy_static macro to ensure we have a// clean initial TID on every iteration, instead.// === impl Tid ===// === impl Registration ===/// An error returned when shell parsing fails./// Within a delimiter./// After backslash, but before starting word./// Within an unquoted word.UnquotedBackslash/// After backslash in an unquoted word.SingleQuoted/// Within a single quoted word.DoubleQuoted/// Within a double quoted word.DoubleQuotedBackslash/// After backslash inside a double quoted word./// Inside a comment./// Splits command line into separate arguments, in much the same way Unix shell/// would, but without many of expansion the shell would perform./// The split functionality is compatible with behaviour of Unix shell, but with/// word expansions limited to quote removal, and without special token/// recognition rules for operators./// The result is exactly the same as one obtained from Unix shell as long as/// those unsupported features are not present in input: no operators, no/// variable assignments, no tilde expansion, no parameter expansion, no command/// substitution, no arithmetic expansion, no pathname expansion./// In case those unsupported shell features are present, the syntax that/// introduce them is interpreted literally./// When input contains unmatched quote, an error is returned./// # Compatibility with other implementations/// It should be fully compatible with g_shell_parse_argv from GLib, except that/// in GLib it is an error not to have any words after tokenization./// It is also very close to shlex.split available in Python standard library,/// when used in POSIX mode with support for comments. Though, shlex/// implementation diverges from POSIX, and from implementation contained herein/// in three aspects. First, it doesn't support line continuations./// Second, inside double quotes, the backslash characters retains its special/// meaning as an escape character only when followed by \\ or \", whereas POSIX/// specifies that it should retain its special meaning when followed by: $, \`,/// \", \\, or a newline. Third, it treats carriage return as one of delimiters./// Building an executable using compiler obtained from CC environment variable/// and compiler flags from both CFLAGS and CPPFLAGS. Similar to default build/// rule for C used in GNU Make:/// use std::env::var;/// let cc = var("CC").unwrap_or_else(|_| "cc".to_owned());/// let cflags_str = var("CFLAGS").unwrap_or_else(|_| String::new());/// let cflags = shell_words::split(&cflags_str).expect("failed to parse CFLAGS");/// let cppflags_str = var("CPPFLAGS").unwrap_or_else(|_| String::new());/// let cppflags = shell_words::split(&cppflags_str).expect("failed to parse CPPFLAGS");/// Command::new(cc)///     .args(cflags)///     .args(cppflags)///     .args(&["-c", "a.c", "-o", "a.out"])///     .expect("failed to start subprocess")///     .wait()///     .expect("failed to wait for subprocess");EscapeStyle/// No escaping./// Wrap in single quotes./// Single quotes combined with backslash.escape_style/// Determines escaping style to use./// Escapes special characters in a string, so that it will retain its literal/// meaning when used as a part of command in Unix shell./// It tries to avoid introducing any unnecessary quotes or escape characters,/// but specifics regarding quoting style are left unspecified./// Joins arguments into a single command line suitable for execution in Unix/// shell./// Each argument is quoted using [`quote`] to preserve its literal meaning when/// parsed by Unix shell./// Note: This function is essentially an inverse of [`split`]./// Logging executed commands in format that can be easily copied and pasted/// into an actual shell:/// fn execute(args: &[&str]) {///     use std::process::Command;///     println!("Executing: {}", shell_words::join(args));///     Command::new(&args[0])///         .args(&args[1..])///         .spawn()///         .expect("failed to start subprocess")///         .wait()///         .expect("failed to wait for subprocess");/// execute(&["python", "-c", "print('Hello world!')"]);/// [`quote`]: fn.quote.html/// [`split`]: fn.split.htmlsplit_oksplit_emptysplit_initial_whitespace_is_removedsplit_trailing_whitespace_is_removedsplit_carriage_return_is_not_specialsplit_single_quotessplit_double_quotessplit_unquotedsplit_trailing_backslashsplit_errorssplit_commentstest_quotejoin_followed_by_split_is_identity// Copyright 2018 Tomasz Miąsko// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE>// or the MIT license <LICENSE-MIT>, at your option.//! Process command line according to parsing rules of Unix shell as specified//! in [Shell Command Language in POSIX.1-2008][posix-shell].//! [posix-shell]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.htmlQuoteErrorin_iterline_no/// The number of newlines read so far, plus one./// An input string is erroneous if it ends while inside a quotation or right after an/// unescaped backslash.  Since Iterator does not have a mechanism to return an error, if that/// happens, Shlex just throws out the last token, ends the iteration, and sets 'had_error' to/// true; best to check it after you're done iterating./// An iterator that takes an input byte string and splits it into the words using the same syntax as/// the POSIX shell.parse_wordparse_doubleparse_single/// Convenience function that consumes the whole byte string at once.  Returns None if the input was/// erroneous.allow_nul// TODO: more optionsQuoter/// A more configurable interface to quote strings.  If you only want the default settings you can/// use the convenience functions [`try_quote`] and [`try_join`]./// The string equivalent is [`shlex::Quoter`]./// Create a new [`Quoter`] with default settings./// Set whether to allow [nul bytes](quoting_warning#nul-bytes).  By default they are not/// allowed and will result in an error of [`QuoteError::Nul`]./// Convenience function that consumes an iterable of words and turns it into a single byte string,/// quoting words when necessary. Consecutive words will be separated by a single space./// Given a single word, return a byte string suitable to encode it as a shell argument./// If given valid UTF-8, this will never produce invalid UTF-8. This is because it only/// ever inserts valid ASCII characters before or after existing ASCII characters (or/// returns two single quotes if the input was an empty string). It will never modify a/// multibyte UTF-8 character.QuotingStrategy/// No quotes and no backslash escapes.  (If backslash escapes would be necessary, we use a/// different strategy instead.)/// Single quoted./// Double quotes, potentially with backslash escapes.// TODO: add $'xxx' and "$(printf 'xxx')" stylesunquoted_ok/// Is this ASCII byte okay to emit unquoted?unquoted_ok_fast/// Optimized version of `unquoted_ok`.single_quoted_ok/// Is this ASCII byte okay to emit in single quotes?double_quoted_ok/// Is this ASCII byte okay to emit in double quotes?quoting_strategy/// Given an input, return a quoting strategy that can cover some prefix of the string, along with/// the size of that prefix./// Precondition: input size is nonzero.  (Empty strings are handled by the caller.)/// Postcondition: returned size is nonzero.append_quoted_chunk/// Uses default settings except that nul bytes are passed through, which [may be/// dangerous](quoting_warning#nul-bytes), leading to this function being deprecated./// Equivalent to [`Quoter::new().allow_nul(true).join(words).unwrap()`](Quoter)./// (That configuration never returns `Err`, so this function does not panic.)/// The string equivalent is [shlex::join]./// Uses default settings.  The only error that can be returned is [`QuoteError::Nul`]./// Equivalent to [`Quoter::new().join(words)`](Quoter)./// The string equivalent is [shlex::try_join]./// Given a single word, return a string suitable to encode it as a shell argument./// Equivalent to [`Quoter::new().allow_nul(true).quote(in_bytes).unwrap()`](Quoter)./// The string equivalent is [shlex::quote].try_quote/// Equivalent to [`Quoter::new().quote(in_bytes)`](Quoter)./// The string equivalent is [shlex::try_quote].INVALID_UTF8_SINGLEQUOTEDtest_invalid_utf8SPLIT_TEST_ITEMStest_lineno// Copyright 2015 Nicholas Allegra (comex).// Licensed under the Apache License, Version 2.0 <https://www.apache.org/licenses/LICENSE-2.0> or// the MIT license <https://opensource.org/licenses/MIT>, at your option. This file may not be//! [`Shlex`] and friends for byte strings.//! This is used internally by the [outer module](crate), and may be more//! convenient if you are working with byte slices (`[u8]`) or types that are//! wrappers around bytes, such as [`OsStr`](std::ffi::OsStr)://! #[cfg(unix)] {//!     use shlex::bytes::quote;//!     use std::ffi::OsStr;//!     use std::os::unix::ffi::OsStrExt;//!     // `\x80` is invalid in UTF-8.//!     let os_str = OsStr::from_bytes(b"a\x80b c");//!     assert_eq!(quote(os_str.as_bytes()), &b"'a\x80b c'"[..]);//! (On Windows, `OsStr` uses 16 bit wide characters so this will not work.)/// An iterator that takes an input string and splits it into the words using the same syntax as/// See [`bytes::Shlex`]./// Convenience function that consumes the whole string at once.  Returns None if the input was/// The input contained a nul byte.  In most cases, shells fundamentally [cannot handle strings/// containing nul bytes](quoting_warning#nul-bytes), no matter how they are quoted.  But if/// you're sure you can handle nul bytes, you can call `allow_nul(true)` on the `Quoter` to let/// them pass through./// Errors from [`Quoter::quote`], [`Quoter::join`], etc. (and their [`bytes`] counterparts)./// By default, the only error that can be returned is [`QuoteError::Nul`].  If you call/// `allow_nul(true)`, then no errors can be returned at all.  Any error variants added in the/// future will not be enabled by default; they will be enabled through corresponding non-default/// [`Quoter`] options./// ...In theory.  In the unlikely event that additional classes of inputs are discovered that,/// like nul bytes, are fundamentally unsafe to quote even for non-interactive shells, the risk/// will be mitigated by adding corresponding [`QuoteError`] variants that *are* enabled by/// The bytes equivalent is [`bytes::Quoter`]./// Convenience function that consumes an iterable of words and turns it into a single string,/// The bytes equivalent is [bytes::join]./// The bytes equivalent is [bytes::try_join]./// Equivalent to [`Quoter::new().allow_nul(true).quote(in_str).unwrap()`](Quoter)./// The bytes equivalent is [bytes::quote]./// Equivalent to [`Quoter::new().quote(in_str)`](Quoter)./// The bytes equivalent is [bytes::try_quote].test_fallible//! Parse strings like, and escape strings for, POSIX shells.//! Same idea as (but implementation not directly based on) the Python shlex module.//! Disabling the `std` feature (which is enabled by default) will allow the crate to work in//! `no_std` environments, where the `alloc` crate, and a global allocator, are available.//! ## <span style="color:red">Warning</span>//! The [`try_quote`]/[`try_join`] family of APIs does not quote control characters (because they//! cannot be quoted portably).//! This is fully safe in noninteractive contexts, like shell scripts and `sh -c` arguments (or//! even scripts `source`d from interactive shells).//! But if you are quoting for human consumption, you should keep in mind that ugly inputs produce//! ugly outputs (which may not be copy-pastable).//! And if by chance you are piping the output of [`try_quote`]/[`try_join`] directly to the stdin//! of an interactive shell, you should stop, because control characters can lead to arbitrary//! command injection.//! For more information, and for information about more minor issues, please see [quoting_warning].//! This crate's quoting functionality tries to be compatible with **any POSIX-compatible shell**;//! it's tested against `bash`, `zsh`, `dash`, Busybox `ash`, and `mksh`, plus `fish` (which is not//! POSIX-compatible but close enough).//! It also aims to be compatible with Python `shlex` and C `wordexp`.add_shutdown_hook/// Adds a callback function to be called on exit// Assigned in unsafe block/// Calls the specified callback function on exittest_add_shutdown_hook_should_workget_in_the_bowl//! Provides access to shutdown hooks//! Currently, only adding new hooks is supported.//! An unspecified future release will have a collection of hooks and have the ability to remove themYIELD_EVERYMAX_GUARDSReadGuardHalfLockWriteGuard// We conceptually contain an instance of T// The actual data as a pointer.// The generation of the data. Influences which slot of the lock counter we use.// How many active locks are there?write_mutex// Mutex for the writers; only one writer.update_seenwrite_barrier//! The half-lock structure//! We need a way to protect the structure with configured hooks ‒ a signal may happen in arbitrary//! thread and needs to read them while another thread might be manipulating the structure.//! Under ordinary circumstances we would be happy to just use `Mutex<HashMap<c_int, _>>`. However,//! as we use it in the signal handler, we are severely limited in what we can or can't use. So we//! choose to implement kind of spin-look thing with atomics.//! In the reader it is always simply locked and then unlocked, making sure it doesn't disappear//! while in use.//! The writer has a separate mutex (that prevents other writers; this is used outside of the//! signal handler), makes a copy of the data and swaps an atomic pointer to the data structure.//! But it waits until everything is unlocked (no signal handler has the old data) for dropping the//! old instance. There's a generation trick to make sure that new signal locks another instance.//! The downside is, this is an active spin lock at the writer end. However, we assume than://! * Signals are one time setup before we actually have threads. We just need to make *sure* we//!   are safe even if this is not true.//! * Signals are rare, happening at the same time as the write even rarer.//! * Signals are short, as there is mostly nothing allowed inside them anyway.//! * Our tool box is severely limited.//! Therefore this is hopefully reasonable trade-off.//! The whole code uses SeqCst conservatively. Atomics are not used because of performance here and//! are the minor price around signals anyway. But the comments state which orderings should be//! enough in practice in case someone wants to get inspired (but do make your own check through//! them anyway).half_lock// Once::new is now a const-fn. But it is not stable in all the rustc versions we want to supportActionId/// An ID of registered action./// This is returned by all the registration routines and can be used to remove the action later on/// with a call to [`unregister`].// This should be dyn Fn(...), but we want to support Rust 1.26.0 and that one doesn't allow dyn// We use BTreeMap here, because we want to run the actions in the order they were inserted.// This works, because the ActionIds are assigned in an increasing order.SignalData/// The data structure describing what needs to be run for each signal.race_fallback/// A fallback to fight/minimize a race condition during signal initialization./// See the comment inside [`register_unchecked_impl`].GlobalData/// Lazy-initiated data structure with our global variables./// Used inside a structure to cut down on boilerplate code to lazy-initialize stuff. We don't dare/// use anything fancy like lazy-static or once-cell, since we are not sure they are/// async-signal-safe in their access. Our code uses the [Once], but only on the write end outside/// of signal handler. The handler assumes it has already been initialized.GLOBAL_DATAGLOBAL_INIT/// List of forbidden signals./// Some signals are impossible to replace according to POSIX and some are so special that this/// library refuses to handle them (eg. SIGSEGV). The routines panic in case registering one of/// these signals is attempted./// See [`register`].FORBIDDEN_IMPL/// Registers an arbitrary action for the given signal./// This makes sure there's a signal handler for the given signal. It then adds the action to the/// ones called each time the signal is delivered. If multiple actions are set for the same signal,/// all are called, in the order of registration./// If there was a previous signal handler for the given signal, it is chained ‒ it will be called/// as part of this library's signal handler, before any actions set through this function./// On success, the function returns an ID that can be used to remove the action again with/// [`unregister`]./// If the signal is one of (see [`FORBIDDEN`]):/// * `SIGKILL`/// * `SIGSTOP`/// * `SIGILL`/// * `SIGFPE`/// * `SIGSEGV`/// The first two are not possible to override (and the underlying C functions simply ignore all/// requests to do so, which smells of possible bugs, or return errors). The rest can be set, but/// generally needs very special handling to do so correctly (direct manipulation of the/// application's address space, `longjmp` and similar). Unless you know very well what you're/// doing, you'll shoot yourself into the foot and this library won't help you with that./// Since the library manipulates signals using the low-level C functions, all these can return/// errors. Generally, the errors mean something like the specified signal does not exist on the/// given platform ‒ after a program is debugged and tested on a given OS, it should never return/// However, if an error *is* returned, there are no guarantees if the given action was registered/// This function is unsafe, because the `action` is run inside a signal handler. The set of/// functions allowed to be called from within is very limited (they are called async-signal-safe/// functions by POSIX). These specifically do *not* contain mutexes and memory/// allocation/deallocation. They *do* contain routines to terminate the program, to further/// manipulate signals (by the low-level functions, not by this library) and to read and write file/// descriptors. Calling program's own functions consisting only of these is OK, as is manipulating/// program's variables ‒ however, as the action can be called on any thread that does not have the/// given signal masked (by default no signal is masked on any thread), and mutexes are a no-go,/// this is harder than it looks like at first./// As panicking from within a signal handler would be a panic across FFI boundary (which is/// undefined behavior), the passed handler must not panic./// If you find these limitations hard to satisfy, choose from the helper functions in the/// [signal-hook](https://docs.rs/signal-hook) crate ‒ these provide safe interface to use some/// common signal handling patters./// # Race condition/// Upon registering the first hook for a given signal into this library, there's a short race/// condition under the following circumstances:/// * The program already has a signal handler installed for this particular signal (through some///   other library, possibly)./// * Concurrently, some other thread installs a different signal handler while it is being///   installed by this library./// * At the same time, the signal is delivered./// Under such conditions signal-hook might wrongly "chain" to the older signal handler for a short/// while (until the registration is fully complete)./// Note that the exact conditions of the race condition might change in future versions of the/// library. The recommended way to avoid it is to register signals before starting any additional/// threads, or at least not to register signals concurrently./// Alternatively, make sure all signals are handled through this library./// Even when it is possible to repeatedly install and remove actions during the lifetime of a/// program, the installation and removal is considered a slow operation and should not be done/// very often. Also, there's limited (though huge) amount of distinct IDs (they are `u128`)./// extern crate signal_hook_registry;/// use std::io::Error;///     let signal = unsafe {///         signal_hook_registry::register(signal_hook::consts::SIGTERM, || process::abort())///     }?;///     // Stuff here...///     signal_hook_registry::unregister(signal); // Not really necessary.register_sigaction/// Register a signal action./// This acts in the same way as [`register`], including the drawbacks, panics and performance/// characteristics. The only difference is the provided action accepts a [`siginfo_t`] argument,/// providing information about the received signal./// See the details of [`register`].register_sigaction_implregister_signal_unchecked/// Register a signal action without checking for forbidden signals./// This acts in the same way as [`register_unchecked`], including the drawbacks, panics and/// performance characteristics. The only difference is the provided action doesn't accept a/// [`siginfo_t`] argument.register_unchecked/// This acts the same way as [`register_sigaction`], but without checking for the [`FORBIDDEN`]/// signals. All the signals passed are registered and it is up to the caller to make some sense of/// Note that you really need to know what you're doing if you change eg. the `SIGSEGV` signal/// handler. Generally, you don't want to do that. But unlike the other functions here, this/// function still allows you to do it.register_unchecked_impl/// Removes a previously installed action./// This function does nothing if the action was already removed. It returns true if it was removed/// and false if the action wasn't found./// It can unregister all the actions installed by [`register`] as well as the ones from downstream/// crates (like [`signal-hook`](https://docs.rs/signal-hook))./// This does *not* currently return the default/previous signal handler if the last action for a/// signal was just unregistered. That means that if you replaced for example `SIGTERM` and then/// removed the action, the program will effectively ignore `SIGTERM` signals from now on, not/// terminate on them as is the default action. This is OK if you remove it as part of a shutdown,/// but it is not recommended to remove termination actions during the normal runtime of/// application (unless the desired effect is to create something that can be terminated only by/// SIGKILL).unregister_signal// We keep this one here for strict backwards compatibility, but the API is kind of bad. One can// delete actions that don't belong to them, which is kind of against the whole idea of not// breaking stuff for others.panic_forbiddenforbidden_raw/// Registering the forbidden signals is allowed in the _unchecked version.// Clippy, you're wrong. Because it changes the return value.signal_without_pidsignal_with_pidregister_unregister/// Check that registration works as expected and that unregister tells if it did or not.//! Backend of the [signal-hook] crate.//! The [signal-hook] crate tries to provide an API to the unix signals, which are a global//! resource. Therefore, it is desirable an application contains just one version of the crate//! which manages this global resource. But that makes it impossible to make breaking changes in//! the API.//! Therefore, this crate provides very minimal and low level API to the signals that is unlikely//! to have to change, while there may be multiple versions of the [signal-hook] that all use this//! low-level API to provide different versions of the high level APIs.//! It is also possible some other crates might want to build a completely different API. This//! split allows these crates to still reuse the same low-level routines in this crate instead of//! going to the (much more dangerous) unix calls.//! # What this crate provides//! The only thing this crate does is multiplexing the signals. An application or library can add//! or remove callbacks and have multiple callbacks for the same signal.//! It handles dispatching the callbacks and managing them in a way that uses only the//! [async-signal-safe] functions inside the signal handler. Note that the callbacks are still run//! inside the signal handler, so it is up to the caller to ensure they are also//! [async-signal-safe].//! # What this is for//! This is a building block for other libraries creating reasonable abstractions on top of//! signals. The [signal-hook] is the generally preferred way if you need to handle signals in your//! application and provides several safe patterns of doing so.//! # Rust version compatibility//! Currently builds on 1.26.0 an newer and this is very unlikely to change. However, tests//! require dependencies that don't build there, so tests need newer Rust version (they are run on//! stable).//! # Portability//! This crate includes a limited support for Windows, based on `signal`/`raise` in the CRT.//! There are differences in both API and behavior://! - Due to lack of `siginfo_t`, we don't provide `register_sigaction` or `register_unchecked`.//! - Due to lack of signal blocking, there's a race condition.//!   After the call to `signal`, there's a moment where we miss a signal.//!   That means when you register a handler, there may be a signal which invokes//!   neither the default handler or the handler you register.//! - Handlers registered by `signal` in Windows are cleared on first signal.//!   To match behavior in other platforms, we re-register the handler each time the handler is//!   called, but there's a moment where we miss a handler.//!   That means when you receive two signals in a row, there may be a signal which invokes//!   the default handler, nevertheless you certainly have registered the handler.//! [signal-hook]: https://docs.rs/signal-hook//! [async-signal-safe]: http://www.man7.org/linux/man-pages/man7/signal-safety.7.html// # Internal workings// This uses a form of RCU. There's an atomic pointer to the current action descriptors (in the// form of IndependentArcSwap, to be able to track what, if any, signal handlers still use the// version). A signal handler takes a copy of the pointer and calls all the relevant actions.// Modifications to that are protected by a mutex, to avoid juggling multiple signal handlers at// once (eg. not calling sigaction concurrently). This should not be a problem, because modifying// the signal actions should be initialization only anyway. To avoid all allocations and also// deallocations inside the signal handler, after replacing the pointer, the modification routine// needs to busy-wait for the reference count on the old pointer to drop to 1 and take ownership ‒// that way the one deallocating is the modification routine, outside of the signal handler./// A result with the `signature` crate's [`Error`] type./// Prevent from being instantiated as `Error {}` when the `std` feature/// Signature errors./// This type is deliberately opaque as to avoid sidechannel leakage which/// could potentially be used recover signing private keys or forge signatures/// (e.g. [BB'06])./// When the `std` feature is enabled, it impls [`std::error::Error`] and/// supports an optional [`std::error::Error::source`], which can be used by/// things like remote signers (e.g. HSM, KMS) to report I/O or auth errors./// [BB'06]: https://en.wikipedia.org/wiki/Daniel_Bleichenbacher/// Create a new error with no associated source//! Signature error types/// Attempt to sign the given message digest, returning a digital signature/// on success, or an error if something went wrong./// The `prehash` parameter should be the output of a secure cryptographic/// hash function./// This API takes a `prehash` byte slice as there can potentially be many/// compatible lengths for the message digest for a given concrete signature/// Allowed lengths are algorithm-dependent and up to a particular/// implementation to decide./// Sign the provided message prehash, returning a digital signature./// Sign the provided message prehash using the provided external randomness source, returning a digital signature./// Use `Self` to verify that the provided signature for a given message/// `prehash` is authentic./// Returns `Error` if it is inauthentic or some other error occurred, or/// otherwise returns `Ok(())`./// # ⚠️ Security Warning/// If `prehash` is something other than the output of a cryptographically/// secure hash function, an attacker can potentially forge signatures by/// solving a system of linear equations./// Verify the provided message prehash using `Self` (e.g. a public key)//! Hazardous Materials: low-level APIs which can be insecure if misused.//! The traits in this module are not generally recommended, and should only be//! used in special cases where they are specifically needed.//! Using them incorrectly can introduce security vulnerabilities. Please//! carefully read the documentation before attempting to use them.//! To use them, enable the `hazmat-preview` crate feature. Note that this//! feature is semi-unstable and not subject to regular 1.x SemVer guarantees.//! However, any breaking changes will be accompanied with a minor version bump./// Verifying key type for this keypair./// Get the verifying key which can verify signatures produced by the/// signing key portion of this keypair./// Signing keypair with an associated verifying key./// This represents a type which holds both a signing key and a verifying key.//! Signing keypairs.//! This crate provides a common set of traits for signing and verifying//! digital signatures intended to be implemented by libraries which produce//! or contain implementations of digital signature algorithms, and used by//! libraries which want to produce or verify digital signatures while//! generically supporting any compatible backend.//! ## Goals//! The traits provided by this crate were designed with the following goals//! in mind://! - Provide an easy-to-use, misuse resistant API optimized for consumers//!   (as opposed to implementers) of its traits.//! - Support common type-safe wrappers around "bag-of-bytes" representations//!   which can be directly parsed from or written to the "wire".//! - Expose a trait/object-safe API where signers/verifiers spanning multiple//!   homogeneous provider implementations can be seamlessly leveraged together//!   in the same logical "keyring" so long as they operate on the same//!   underlying signature type.//! - Allow one provider type to potentially implement support (including//!   being generic over) several signature types.//! - Keep signature algorithm customizations / "knobs" out-of-band from the//!   signing/verification APIs, ideally pushing such concerns into the type//!   system so that algorithm mismatches are caught as type errors.//! - Opaque error type which minimizes information leaked from cryptographic//!   failures, as "rich" error types in these scenarios are often a source//!   of sidechannel information for attackers (e.g. [BB'06])//! [BB'06]: https://en.wikipedia.org/wiki/Daniel_Bleichenbacher//! To accomplish the above goals, the [`Signer`] and [`Verifier`] traits//! provided by this are generic over a [`Signature`] return value, and use//! generic parameters rather than associated types. Notably, they use such//! a parameter for the return value, allowing it to be inferred by the type//! checker based on the desired signature type.//! The [`Signature`] trait is bounded on `AsRef<[u8]>`, enforcing that//! signature types are thin wrappers around a "bag-of-bytes"//! serialization. Inspiration for this approach comes from the Ed25519//! signature system, which was based on the observation that past//! systems were not prescriptive about how signatures should be represented//! on-the-wire, and that lead to a proliferation of different wire formats//! and confusion about which ones should be used. This crate aims to provide//! similar simplicity by minimizing the number of steps involved to obtain//! a serializable signature.//! ## Alternatives considered//! This crate is based on over two years of exploration of how to encapsulate//! digital signature systems in the most flexible, developer-friendly way.//! During that time many design alternatives were explored, tradeoffs//! compared, and ultimately the provided API was selected.//! The tradeoffs made in this API have all been to improve simplicity,//! ergonomics, type safety, and flexibility for *consumers* of the traits.//! At times, this has come at a cost to implementers. Below are some concerns//! we are cognizant of which were considered in the design of the API://! - "Bag-of-bytes" serialization precludes signature providers from using//!   their own internal representation of a signature, which can be helpful//!   for many reasons (e.g. advanced signature system features like batch//!   verification). Alternatively each provider could define its own signature//!   type, using a marker trait to identify the particular signature algorithm,//!   have `From` impls for converting to/from `[u8; N]`, and a marker trait//!   for identifying a specific signature algorithm.//! - Associated types, rather than generic parameters of traits, could allow//!   more customization of the types used by a particular signature system,//!   e.g. using custom error types.//! It may still make sense to continue to explore the above tradeoffs, but//! with a *new* set of traits which are intended to be implementor-friendly,//! rather than consumer friendly. The existing [`Signer`] and [`Verifier`]//! traits could have blanket impls for the "provider-friendly" traits.//! However, as noted above this is a design space easily explored after//! stabilizing the consumer-oriented traits, and thus we consider these//! more important.//! That said, below are some caveats of trying to design such traits, and//! why we haven't actively pursued them://! - Generics in the return position are already used to select which trait//!   impl to use, i.e. for a particular signature algorithm/system. Avoiding//!   a unified, concrete signature type adds another dimension to complexity//!   and compiler errors, and in our experience makes them unsuitable for this//!   sort of API. We believe such an API is the natural one for signature//!   systems, reflecting the natural way they are written absent a trait.//! - Associated types preclude multiple (or generic) implementations of the//!   same trait. These parameters are common in signature systems, notably//!   ones which support different digest algorithms.//! - Digital signatures are almost always larger than the present 32-entry//!   trait impl limitation on array types, which complicates trait signatures//!   for these types (particularly things like `From` or `Borrow` bounds).//!   This may be more interesting to explore after const generics.//! ## Unstable features//! Despite being post-1.0, this crate includes a number of off-by-default//! unstable features named `*-preview`, each of which depends on a pre-1.0//! These features are considered exempt from SemVer. See the//! [SemVer policy](#semver-policy) above for more information.//! The following unstable features are presently supported://! - `derive-preview`: for implementers of signature systems using//!   [`DigestSigner`] and [`DigestVerifier`], the `derive-preview` feature//!   can be used to derive [`Signer`] and [`Verifier`] traits which prehash//!   the input message using the [`PrehashSignature::Digest`] algorithm for//!   a given [`Signature`] type. When the `derive-preview` feature is enabled//!   import the proc macros with `use signature::{Signer, Verifier}` and then//!   add a `derive(Signer)` or `derive(Verifier)` attribute to the given//!   digest signer/verifier type. Enabling this feature also enables `digest`//!   support (see immediately below).//! - `digest-preview`: enables the [`DigestSigner`] and [`DigestVerifier`]//!   traits which are based on the [`Digest`] trait from the [`digest`] crate.//!   These traits are used for representing signature systems based on the//!   [Fiat-Shamir heuristic] which compute a random challenge value to sign//!   by computing a cryptographically secure digest of the input message.//! - `rand-preview`: enables the [`RandomizedSigner`] trait for signature//!   systems which rely on a cryptographically secure random number generator//!   for security.//! NOTE: the [`async-signature`] crate contains experimental `async` support//! for [`Signer`] and [`DigestSigner`].//! [`async-signature`]: https://docs.rs/async-signature//! [`digest`]: https://docs.rs/digest///! [`Digest`]: https://docs.rs/digest/latest/digest/trait.Digest.html//! [Fiat-Shamir heuristic]: https://en.wikipedia.org/wiki/Fiat%E2%80%93Shamir_heuristic/// Parse a signature from its byte representation/// Borrow a byte slice representing the serialized form of this signature/// Trait impl'd by concrete types that represent digital signatures./// Signature types *must* (as mandated by the `AsRef<[u8]>` bound) be a thin/// wrapper around the "bag-of-bytes" serialized form of a signature which can/// be directly parsed from or written to the "wire"./// Inspiration for this approach comes from the Ed25519 signature system,/// which adopted it based on the observation that past signature systems/// were not prescriptive about how signatures should be represented/// on-the-wire, and that lead to a proliferation of different wire formats and/// confusion about which ones should be used./// The [`Signature`] trait aims to provide similar simplicity by minimizing/// the number of steps involved to obtain a serializable signature and/// ideally ensuring there is one signature type for any given signature system/// shared by all "provider" crates./// For signature systems which require a more advanced internal representation/// (e.g. involving decoded scalars or decompressed elliptic curve points) it's/// recommended that "provider" libraries maintain their own internal signature/// type and use `From` bounds to provide automatic conversions.//! Signature traits/// Sign the given message and return a digital signature/// Attempt to sign the given message, returning a digital signature on/// success, or an error if something went wrong./// The main intended use case for signing errors is when communicating/// with external signers, e.g. cloud KMS, HSMs, or other hardware tokens./// Sign the provided message bytestring using `Self` (e.g. a cryptographic key/// or connection to an HSM), returning a digital signature./// Sign the given message, update the state, and return a digital signature/// Attempt to sign the given message, updating the state, and returning a/// digital signature on success, or an error if something went wrong./// Signing can fail, e.g., if the number of time periods allowed by the/// current key is exceeded.SignerMut/// Sign the provided message bytestring using `&mut Self` (e.g., an evolving/// cryptographic key), returning a digital signature.// Blanket impl of SignerMut for all Signer types//! Traits for generating digital signatures/// bytestring is authentic./// Returns `Error` if it is inauthentic, or otherwise returns `()`./// Verify the provided message bytestring using `Self` (e.g. a public key)//! Trait for verifying digital signatures/// Byte representation of a signature./// Encode signature as its byte representation./// Encode signature as a byte vector./// Get the length of this signature when encoded./// Support for decoding/encoding signatures as bytes.//! Encoding support./// Source of the error (if applicable).from_source/// Create a new error with an associated source./// **NOTE:** The "source" should **NOT** be used to propagate cryptographic/// errors e.g. signature parsing or verification errors. The intended use/// cases are for propagating errors related to external signers, e.g./// communication/authentication errors with HSMs, KMS, etc.prehash_signature//! provided by this are generic over a signature value, and use generic//! parameters rather than associated types. Notably, they use such a parameter//! for the return value, allowing it to be inferred by the type checker based//! on the desired signature type.//! This crate is based on many years of exploration of how to encapsulate//!   verification).//! - Associated types preclude multiple implementations of the same trait.//!   These parameters are common in signature systems, notably ones which//!   support different serializations of a signature (e.g. raw vs ASN.1).//!   trait impl limitation on array types, which complicates bounds//! Despite being post-1.0, this crate includes off-by-default unstable//! optional features, each of which depends on a pre-1.0//! - `digest`: enables the [`DigestSigner`] and [`DigestVerifier`]//! - `rand_core`: enables the [`RandomizedSigner`] trait for signature/// For intra-doc link resolution./// Preferred `Digest` algorithm to use when computing this signature type./// Marker trait for `Signature` types computable as `𝐒(𝐇(𝒎))`/// i.e. ones which prehash a message to be signed as `𝐇(𝒎)`/// - `𝐒`: signature algorithm/// - `𝐇`: hash (a.k.a. digest) function/// - `𝒎`: message/// This approach is relatively common in signature schemes based on the/// [Fiat-Shamir heuristic]./// For signature types that implement this trait, when the `derive` crate/// feature is enabled a custom derive for [`Signer`] is available for any/// types that impl [`DigestSigner`], and likewise for deriving [`Verifier`] for/// types which impl [`DigestVerifier`]./// [Fiat-Shamir heuristic]: https://en.wikipedia.org/wiki/Fiat%E2%80%93Shamir_heuristic//! `PrehashSignature` trait./// Sign the given message, update the state, and return a digital signature./// Sign the provided message bytestring using `&mut Self` (e.g. an evolving/// cryptographic key such as a stateful hash-based signature), returning a/// digital signature./// Blanket impl of [`SignerMut`] for all [`Signer`] types./// Sign the given prehashed message [`Digest`], returning a signature./// Panics in the event of a signing error./// Attempt to sign the given prehashed message [`Digest`], returning a/// Sign the given prehashed message [`Digest`] using `Self`./// This trait is primarily intended for signature algorithms based on the/// [Fiat-Shamir heuristic], a method for converting an interactive/// challenge/response-based proof-of-knowledge protocol into an offline/// digital signature through the use of a random oracle, i.e. a digest/// The security of such protocols critically rests upon the inability of/// an attacker to solve for the output of the random oracle, as generally/// otherwise such signature algorithms are a system of linear equations and/// therefore doing so would allow the attacker to trivially forge signatures./// To prevent misuse which would potentially allow this to be possible, this/// API accepts a [`Digest`] instance, rather than a raw digest value.sign_with_rng/// Sign the given message using the provided external randomness source.sign_digest_with_rng/// Sign the given prehashed message `Digest`, returning a signature./// Attempt to sign the given prehashed message `Digest`, returning a/// Combination of [`DigestSigner`] and [`RandomizedSigner`] with support for/// computing a signature over a digest which requires entropy from an RNG./// Verify the signature against the given [`Digest`] output./// Verify the provided signature for the given prehashed message [`Digest`]/// is authentic.Adler32HashAdler32Impget_imp/// Resolves update implementation if CPU supports avx2 instructions.get_imp_innerNMAXCHUNK_SIZEupdate_impupdate_chunk_blockreduce_add_blocksreduce_addget_weightsassert_sum_eq/// Resolves update implementation if CPU supports avx512f and avx512bw instructions.avx512_MM_SHUFFLE__m512ireduce_add_256/// Resolves update implementation if CPU supports sse2 instructions.maddubsget_weight_loget_weight_hi/// Resolves update implementation if CPU supports ssse3 instructions./// Resolves update implementation if CPU supports simd128 instructions./// An adler32 hash generator type./// Constructs a new `Adler32`./// Potential overhead here due to runtime feature detection although in testing on 100k/// and 10k random byte arrays it was not really noticeable./// use simd_adler32::Adler32;/// Constructs a new `Adler32` using existing checksum./// let mut adler = Adler32::from_checksum(0xdeadbeaf);/// Computes hash for supplied data and stores results in internal state./// Returns the hash value for the values written so far./// Despite its name, the method does not reset the hasher’s internal state. Additional/// writes will continue from the current value. If you need to start a fresh hash/// value, you will have to use `reset`./// Resets the internal state./// Compute Adler-32 hash on `Adler32Hash` type./// * `hash` - A Adler-32 hash-able type./// use simd_adler32::adler32;/// let hash = adler32(b"Adler-32");/// println!("{}", hash); // 800813569/// Feeds this value into `Adler32`./// A Adler-32 hash-able type./// Compute Adler-32 hash on reader until EOF./// use simd_adler32::read::adler32;/// let mut reader = Cursor::new(b"Hello there");/// let hash = adler32(&mut reader).unwrap();/// println!("{}", hash) // 800813569//! Reader-based hashing.//! use simd_adler32::read::adler32;//! let mut reader = Cursor::new(b"Hello there");//! let hash = adler32(&mut reader).unwrap();//! println!("{}", hash) // 800813569/// Compute Adler-32 hash on buf reader until EOF./// use std::io::{Cursor, BufReader};/// use simd_adler32::bufread::adler32;/// let mut reader = BufReader::new(reader);//! BufRead-based hashing.//! Separate `BufRead` trait implemented to allow for custom buffer size optimization.//! use std::io::{Cursor, BufReader};//! use simd_adler32::bufread::adler32;//! let mut reader = BufReader::new(reader);test_from_checksum//! # simd-adler32//! A SIMD-accelerated Adler-32 hash algorithm implementation.//! - No dependencies//! - Support `no_std` (with `default-features = false`)//! - Runtime CPU feature detection (when `std` enabled)//! - Blazing fast performance on as many targets as possible (currently only x86 and x86_64)//! - Default to scalar implementation when simd not available//! ## Quick start//! > Cargo.toml//! simd-adler32 = "*"//! > example.rs//! use simd_adler32::Adler32;//! let mut adler = Adler32::new();//! adler.write(b"rust is pretty cool, man");//! let hash = adler.finish();//! println!("{}", hash);//! // 1921255656//! ## Feature flags//! * `std` - Enabled by default//! Enables std support, see [CPU Feature Detection](#cpu-feature-detection) for runtime//! detection support.//! * `nightly`//! Enables nightly features required for avx512 support.//! * `const-generics` - Enabled by default//! Enables const-generics support allowing for user-defined array hashing by value.  See//! [`Adler32Hash`] for details.//! ## Support//! **CPU Features**//! | impl | arch             | feature |//! | ---- | ---------------- | ------- |//! | ✅   | `x86`, `x86_64`  | avx512  |//! | ✅   | `x86`, `x86_64`  | avx2    |//! | ✅   | `x86`, `x86_64`  | ssse3   |//! | ✅   | `x86`, `x86_64`  | sse2    |//! | 🚧   | `arm`, `aarch64` | neon    |//! |      | `wasm32`         | simd128 |//! **MSRV** `1.36.0`\*\*//! Minimum supported rust version is tested before a new version is published. [**] Feature//! `const-generics` needs to disabled to build on rustc versions `<1.51` which can be done//! by updating your dependency definition to the following.//! ## CPU Feature Detection//! simd-adler32 supports both runtime and compile time CPU feature detection using the//! `std::is_x86_feature_detected` macro when the `Adler32` struct is instantiated with//! the `new` fn.  //! Without `std` feature enabled simd-adler32 falls back to compile time feature detection//! using `target-feature` or `target-cpu` flags supplied to rustc. See [https://rust-lang.github.io/packed_simd/perf-guide/target-feature/rustflags.html](https://rust-lang.github.io/packed_simd/perf-guide/target-feature/rustflags.html)//! for more information.//! Feature detection tries to use the fastest supported feature first.tests128Sip13Rounds/// An implementation of SipHash 1-3./// See: <https://131002.net/siphash/>Sip24RoundsSipHasher24/// An implementation of SipHash 2-4.SipHasher/// SipHash is a general-purpose hashing function: it runs at a good/// speed (competitive with Spooky and City) and permits strong _keyed_/// hashing. This lets you key your hashtables from a strong RNG, such as/// [`rand::os::OsRng`](https://doc.rust-lang.org/rand/rand/os/struct.OsRng.html)./// Although the SipHash algorithm is considered to be generally strong,/// it is not intended for cryptographic purposes. As such, all/// cryptographic uses of this implementation are _strongly discouraged_.// how many bytes we've processed// hash Statentail// unprocessed bytes le// how many bytes in tail are validSip// v0, v2 and v1, v3 show up in pairs in the algorithm,// and simd implementations of SipHash will use vectors// of v02 and v13. By placing them in this order in the struct,// the compiler can pick up on just a few simd optimizations by itself.load_int_le/// Load an integer of the desired type from a byte stream, in LE order. Uses/// `copy_nonoverlapping` to let the compiler generate the most efficient way/// to load it from a possibly unaligned address./// Unsafe because: unchecked indexing at `i..i+size_of(int_ty)`u8to64_le/// Load an u64 using up to 7 bytes of a byte slice./// Unsafe because: unchecked indexing at start..start+len/// Creates a new `SipHasher` with the two initial keys set to 0./// Creates a `SipHasher` that is keyed off the provided keys./// Get the keys used by this hasher/// Creates a new `SipHasher13` with the two initial keys set to 0./// Creates a `SipHasher13` that is keyed off the provided keys./// Creates a new `SipHasher24` with the two initial keys set to 0./// Creates a `SipHasher24` that is keyed off the provided keys.short_write// Specialized write function that is only valid for buffers with len <= 8.// It's used to force inlining of write_u8 and write_usize, those would normally be inlined// except for composite types (that includes slices and str hashing because of delimiter).// Without this extra push the compiler is very reluctant to inline delimiter writes,// degrading performance substantially for the most common use cases.// see short_write comment for explanation/// Creates a `Hasher<S>` with the two initial keys set to 0.c_roundsd_rounds//! An implementation of SipHash./// A 128-bit (2x64) hash output/// An implementation of SipHash128 1-3./// An implementation of SipHash128 2-4.finish128/// Return a 128-bit hash/// Convert into a 16-bytes vector//! An implementation of SipHash with a 128-bit output.// Hash just the bytes of the slice, without length prefixtest_siphash_1_3test_siphash_2_4test_hash_usizetest_hash_idempotenttest_hash_no_bytes_dropped_64test_hash_no_bytes_dropped_32test_hash_no_concat_aliastest_siphash128_1_3test_siphash128_2_4/// See: <https://www.aumasson.jp/siphash/siphash.pdf>/// Loads an integer of the desired type from a byte stream, in LE order. Uses/// Loads a u64 using up to 7 bytes of a byte slice. It looks clumsy but the/// `copy_nonoverlapping` calls that occur (via `load_int_le!`) all have fixed/// sizes and avoid calling `memcpy`, which is good for speed.new_with_key/// Creates a `SipHasher` from a 16 byte key./// Get the key used by this hasher as a 16 byte vector/// Hash a byte array - This is the easiest and safest way to use SipHash./// Creates a `SipHasher13` from a 16 byte key./// Creates a `SipHasher24` from a 16 byte key.// A specialized write function for values with size <= 8.// The hashing of multi-byte integers depends on endianness. E.g.:// - little-endian: `write_u32(0xDDCCBBAA)` == `write([0xAA, 0xBB, 0xCC, 0xDD])`// - big-endian:    `write_u32(0xDDCCBBAA)` == `write([0xDD, 0xCC, 0xBB, 0xAA])`// This function does the right thing for little-endian hardware. On// big-endian hardware `x` must be byte-swapped first to give the right// behaviour. After any byte-swapping, the input must be zero-extended to// 64-bits. The caller is responsible for the byte-swapping and// zero-extension./// Convert into a `u128`/// Convert into `(u64, u64)`test_hash_simpletest_hash_incrementaltest_siphash128_idempotenttest_siphash128_simpletest_siphash128_incrementalvacant_list_brokenfirst_vacant_index// Building `Slab` from pairs (usize, T).// Chunk of memory// Number of Filled elements currently in the slab// Offset of the next available slot in the slab. Set to the slab's// capacity when the slab is full./// Pre-allocated storage for a uniform data type/// See the [module documentation] for more details./// [module documentation]: index.html/// A handle to a vacant entry in a `Slab`./// # use slab::*;///     let entry = slab.vacant_entry();/// assert_eq!(hello, slab[hello].0);/// assert_eq!("hello", slab[hello].1);/// A consuming iterator over the values stored in a `Slab`/// An iterator over the values stored in the `Slab`/// A mutable iterator over the values stored in the `Slab`/// A draining iterator for `Slab`/// Construct a new, empty `Slab`./// The function does not allocate and the returned slab will have no/// capacity until `insert` is called or capacity is explicitly reserved./// This is `const fn` on Rust 1.39+./// let slab: Slab<i32> = Slab::new();/// Construct a new, empty `Slab` with the specified capacity./// The returned slab will be able to store exactly `capacity` without/// reallocating. If `capacity` is 0, the slab will not allocate./// It is important to note that this function does not specify the *length*/// of the returned slab, but only the capacity. For an explanation of the/// difference between length and capacity, see [Capacity and/// reallocation](index.html#capacity-and-reallocation)./// let mut slab = Slab::with_capacity(10);/// // The slab contains no values, even though it has capacity for more/// assert_eq!(slab.len(), 0);/// // These are all done without reallocating.../// for i in 0..10 {///     slab.insert(i);/// // ...but this may make the slab reallocate/// slab.insert(11);/// Return the number of values the slab can store without reallocating./// let slab: Slab<i32> = Slab::with_capacity(10);/// assert_eq!(slab.capacity(), 10);/// Reserve capacity for at least `additional` more values to be stored/// without allocating./// `reserve` does nothing if the slab already has sufficient capacity for/// `additional` more values. If more capacity is required, a new segment of/// memory will be allocated and all existing values will be copied into it./// As such, if the slab is already very large, a call to `reserve` can end/// up being expensive./// The slab may reserve more than `additional` extra space in order to/// avoid frequent reallocations. Use `reserve_exact` instead to guarantee/// that only the requested space is allocated./// Panics if the new capacity exceeds `isize::MAX` bytes./// slab.insert("hello");/// slab.reserve(10);/// assert!(slab.capacity() >= 11);/// Reserve the minimum capacity required to store exactly `additional`/// more values./// `reserve_exact` does nothing if the slab already has sufficient capacity/// for `additional` more values. If more capacity is required, a new segment/// of memory will be allocated and all existing values will be copied into/// it.  As such, if the slab is already very large, a call to `reserve` can/// end up being expensive./// Note that the allocator may give the slab more space than it requests./// Therefore capacity can not be relied upon to be precisely minimal./// Prefer `reserve` if future insertions are expected./// slab.reserve_exact(10);/// Shrink the capacity of the slab as much as possible without invalidating keys./// Because values cannot be moved to a different index, the slab cannot/// shrink past any stored values./// It will drop down as close as possible to the length but the allocator may/// still inform the underlying vector that there is space for a few more elements./// This function can take O(n) time even when the capacity cannot be reduced/// or the allocation is shrunk in place. Repeated calls run in O(1) though./// for i in 0..3 {/// slab.shrink_to_fit();/// assert!(slab.capacity() >= 3 && slab.capacity() < 10);/// The slab cannot shrink past the last present value even if previous/// values are removed:/// for i in 0..4 {/// slab.remove(0);/// slab.remove(3);recreate_vacant_list/// Iterate through all entries to recreate and repair the vacant list./// self.len must be correct and is not modified./// Reduce the capacity as much as possible, changing the key for elements when necessary./// To allow updating references to the elements which must be moved to a new key,/// this function takes a closure which is called before moving each element./// The second and third parameters to the closure are the current key and/// new key respectively./// In case changing the key for one element turns out not to be possible,/// the move can be cancelled by returning `false` from the closure./// In that case no further attempts at relocating elements is made./// If the closure unwinds, the slab will be left in a consistent state,/// but the value that the closure panicked on might be removed./// let a = slab.insert('a');/// slab.insert('b');/// slab.insert('c');/// slab.remove(a);/// slab.compact(|&mut value, from, to| {///     assert_eq!((value, from, to), ('c', 2, 0));/// assert!(slab.capacity() >= 2 && slab.capacity() < 10);/// The value is not moved when the closure returns `Err`:/// let mut slab = Slab::with_capacity(100);/// let b = slab.insert('b');/// slab.compact(|&mut value, from, to| false);/// assert_eq!(slab.iter().next(), Some((b, &'b')));/// Clear the slab of all values./// slab.clear();/// assert!(slab.is_empty());/// Return the number of stored values./// assert_eq!(3, slab.len());/// Return `true` if there are no values stored in the slab./// slab.insert(1);/// assert!(!slab.is_empty());/// Return an iterator over the slab./// This function should generally be **avoided** as it is not efficient./// Iterators must iterate over every slot in the slab even if it is/// vacant. As such, a slab with a capacity of 1 million but only one/// stored value must still iterate the million slots./// let mut iterator = slab.iter();/// assert_eq!(iterator.next(), Some((0, &0)));/// assert_eq!(iterator.next(), Some((1, &1)));/// assert_eq!(iterator.next(), Some((2, &2)));/// assert_eq!(iterator.next(), None);/// Return an iterator that allows modifying each value./// let key1 = slab.insert(0);/// let key2 = slab.insert(1);/// for (key, val) in slab.iter_mut() {///     if key == key1 {///         *val += 2;/// assert_eq!(slab[key1], 2);/// assert_eq!(slab[key2], 1);/// If the given key is not associated with a value, then `None` is/// let key = slab.insert("hello");/// assert_eq!(slab.get(key), Some(&"hello"));/// assert_eq!(slab.get(123), None);/// Return a mutable reference to the value associated with the given key./// *slab.get_mut(key).unwrap() = "world";/// assert_eq!(slab[key], "world");/// assert_eq!(slab.get_mut(123), None);get2_mut/// Return two mutable references to the values associated with the two/// given keys simultaneously./// If any one of the given keys is not associated with a value, then `None`/// This function can be used to get two mutable references out of one slab,/// so that you can manipulate both of them at the same time, eg. swap them./// This function will panic if `key1` and `key2` are the same./// let key1 = slab.insert(1);/// let key2 = slab.insert(2);/// let (value1, value2) = slab.get2_mut(key1, key2).unwrap();/// mem::swap(value1, value2);/// Return a reference to the value associated with the given key without/// performing bounds checking./// For a safe alternative see [`get`](Slab::get)./// This function should be used with care./// The key must be within bounds./// let key = slab.insert(2);///     assert_eq!(slab.get_unchecked(key), &2);/// Return a mutable reference to the value associated with the given key/// without performing bounds checking./// For a safe alternative see [`get_mut`](Slab::get_mut).///     let val = slab.get_unchecked_mut(key);///     *val = 13;/// assert_eq!(slab[key], 13);get2_unchecked_mut/// given keys simultaneously without performing bounds checking and safety/// condition checking./// For a safe alternative see [`get2_mut`](Slab::get2_mut)./// - Both keys must be within bounds./// - The condition `key1 != key2` must hold./// let (value1, value2) = unsafe { slab.get2_unchecked_mut(key1, key2) };key_of/// Get the key for an element in the slab./// The reference must point to an element owned by the slab./// Otherwise this function will panic./// This is a constant-time operation because the key can be calculated/// from the reference with pointer arithmetic./// This function will panic if the reference does not point to an element/// of the slab./// let key = slab.insert(String::from("foo"));/// let value = &slab[key];/// assert_eq!(slab.key_of(value), key);/// Values are not compared, so passing a reference to a different location/// will result in a panic:/// let key = slab.insert(0);/// let bad = &0;/// slab.key_of(bad); // this will panic/// Insert a value in the slab, returning key assigned to the value./// The returned key can later be used to retrieve or remove the value using indexed/// lookup and `remove`. Additional capacity is allocated if needed. See/// [Capacity and reallocation](index.html#capacity-and-reallocation)./// Panics if the new storage in the vector exceeds `isize::MAX` bytes./// assert_eq!(slab[key], "hello");/// Returns the key of the next vacant entry./// This function returns the key of the vacant entry which  will be used/// for the next insertion. This is equivalent to/// `slab.vacant_entry().key()`, but it doesn't require mutable access./// assert_eq!(slab.vacant_key(), 0);/// slab.insert(0);/// assert_eq!(slab.vacant_key(), 1);/// slab key. The returned `VacantEntry` reserves a slot in the slab and is/// able to query the associated key.insert_attry_remove/// Tries to remove the value associated with the given key,/// returning the value if the key existed./// The key is then released and may be associated with future stored/// let hello = slab.insert("hello");/// assert_eq!(slab.try_remove(hello), Some("hello"));/// assert!(!slab.contains(hello));/// Remove and return the value associated with the given key./// Panics if `key` is not associated with a value./// assert_eq!(slab.remove(hello), "hello");/// Return `true` if a value is associated with the given key./// assert!(slab.contains(hello));/// slab.remove(hello);/// Retain only the elements specified by the predicate./// In other words, remove all elements `e` such that `f(usize, &mut e)`/// returns false. This method operates in place and preserves the key/// associated with the retained values./// let k1 = slab.insert(0);/// let k2 = slab.insert(1);/// let k3 = slab.insert(2);/// slab.retain(|key, val| key == k1 || *val == 1);/// assert!(slab.contains(k1));/// assert!(slab.contains(k2));/// assert!(!slab.contains(k3));/// assert_eq!(2, slab.len());/// Return a draining iterator that removes all elements from the slab and/// yields the removed items./// Note: Elements are removed even if the iterator is only partially/// consumed or not consumed at all./// let _ = slab.insert(0);/// let _ = slab.insert(1);/// let _ = slab.insert(2);///     let mut drain = slab.drain();///     assert_eq!(Some(0), drain.next());///     assert_eq!(Some(1), drain.next());///     assert_eq!(Some(2), drain.next());///     assert_eq!(None, drain.next());/// Create a slab from an iterator of key-value pairs./// If the iterator produces duplicate keys, the previous value is replaced with the later one./// The keys does not need to be sorted beforehand, and this function always/// takes O(n) time./// Note that the returned slab will use space proportional to the largest key,/// so don't use `Slab` with untrusted keys./// let vec = vec![(2,'a'), (6,'b'), (7,'c')];/// let slab = vec.into_iter().collect::<Slab<char>>();/// assert_eq!(slab.len(), 3);/// assert!(slab.capacity() >= 8);/// assert_eq!(slab[2], 'a');/// With duplicate and unsorted keys:/// let vec = vec![(20,'a'), (10,'b'), (11,'c'), (10,'d')];/// assert_eq!(slab[10], 'd');/// Insert a value in the entry, returning a mutable reference to the value./// To get the key associated with the value, use `key` prior to calling/// `insert`./// Return the key associated with this entry.//! Pre-allocated storage for a uniform data type.//! `Slab` provides pre-allocated storage for a single data type. If many values//! of a single type are being allocated, it can be more efficient to//! pre-allocate the necessary storage. Since the size of the type is uniform,//! memory fragmentation can be avoided. Storing, clearing, and lookup//! operations become very cheap.//! While `Slab` may look like other Rust collections, it is not intended to be//! used as a general purpose collection. The primary difference between `Slab`//! and `Vec` is that `Slab` returns the key when storing the value.//! It is important to note that keys may be reused. In other words, once a//! value associated with a given key is removed from a slab, that key may be//! returned from future calls to `insert`.//! Basic storing and retrieval.//! # use slab::*;//! let mut slab = Slab::new();//! let hello = slab.insert("hello");//! let world = slab.insert("world");//! assert_eq!(slab[hello], "hello");//! assert_eq!(slab[world], "world");//! slab[world] = "earth";//! assert_eq!(slab[world], "earth");//! Sometimes it is useful to be able to associate the key with the value being//! inserted in the slab. This can be done with the `vacant_entry` API as such://! let hello = {//!     let entry = slab.vacant_entry();//!     let key = entry.key();//!     entry.insert((key, "hello"));//! assert_eq!(hello, slab[hello].0);//! assert_eq!("hello", slab[hello].1);//! It is generally a good idea to specify the desired capacity of a slab at//! creation time. Note that `Slab` will grow the internal capacity when//! attempting to insert a new value once the existing capacity has been reached.//! To avoid this, add a check.//! let mut slab = Slab::with_capacity(1024);//! // ... use the slab//! if slab.len() == slab.capacity() {//!     panic!("slab full");//! slab.insert("the slab is not at capacity yet");//! # Capacity and reallocation//! The capacity of a slab is the amount of space allocated for any future//! values that will be inserted in the slab. This is not to be confused with//! the *length* of the slab, which specifies the number of actual values//! currently being inserted. If a slab's length is equal to its capacity, the//! next value inserted into the slab will require growing the slab by//! reallocating.//! For example, a slab with capacity 10 and length 0 would be an empty slab//! with space for 10 more stored values. Storing 10 or fewer elements into the//! slab will not change its capacity or cause reallocation to occur. However,//! if the slab length is increased to 11 (due to another `insert`), it will//! have to reallocate, which can be slow. For this reason, it is recommended to//! use [`Slab::with_capacity`] whenever possible to specify how many values the//! slab is expected to store.//! `Slab` is backed by a `Vec` of slots. Each slot is either occupied or//! vacant. `Slab` maintains a stack of vacant slots using a linked list. To//! find a vacant slot, the stack is popped. When a slot is released, it is//! pushed onto the stack.//! If there are no more available slots in the stack, then `Vec::reserve(1)` is//! called and a new slot is created.//! [`Slab::with_capacity`]: struct.Slab.html#with_capacity// ===== VacantEntry =====// ===== IntoIter =====// ===== Iter =====// ===== IterMut =====// ===== Drain =====SlabVisitor// MaybeUninit is only used on nightly at the moment.
UnwrapUncheckedDefaultKeySlotUnionnext_free// Storage inside a slot or metadata for the freelist when vacant.
// Even = vacant, odd = occupied.
// A slot, which represents storage for a value and a current version.
// Can be occupied or vacant.
SlotContent// Safe API to read a slot.
SlotContentMutOccupiedMutVacantMut// Is this slot occupied?
free_head_k/// Slot map, storage with stable unique keys.
/// See [crate documentation](crate) for more details.
/// Constructs a new, empty [`SlotMap`].
/// # use slotmap::*;
/// let mut sm: SlotMap<_, i32> = SlotMap::new();
/// Creates an empty [`SlotMap`] with the given capacity.
/// The slot map will not reallocate until it holds at least `capacity`
/// let mut sm: SlotMap<_, i32> = SlotMap::with_capacity(10);
/// Constructs a new, empty [`SlotMap`] with a custom key type.
/// new_key_type! {
///     struct PositionKey;
/// let mut positions: SlotMap<PositionKey, i32> = SlotMap::with_key();
with_capacity_and_key/// Creates an empty [`SlotMap`] with the given capacity and a custom key
/// type.
///     struct MessageKey;
/// let mut messages = SlotMap::with_capacity_and_key(3);
/// let welcome: MessageKey = messages.insert("Welcome");
/// let good_day = messages.insert("Good day");
/// let hello = messages.insert("Hello");
/// Returns the number of elements in the slot map.
/// let mut sm = SlotMap::with_capacity(10);
/// sm.insert("len() counts actual elements, not capacity");
/// let key = sm.insert("removed elements don't count either");
/// sm.remove(key);
/// assert_eq!(sm.len(), 1);
/// Returns if the slot map is empty.
/// let mut sm = SlotMap::new();
/// let key = sm.insert("dummy");
/// assert_eq!(sm.is_empty(), false);
/// assert_eq!(sm.is_empty(), true);
/// Returns the number of elements the [`SlotMap`] can hold without
/// reallocating.
/// let sm: SlotMap<_, f64> = SlotMap::with_capacity(10);
/// assert_eq!(sm.capacity(), 10);
/// Reserves capacity for at least `additional` more elements to be inserted
/// in the [`SlotMap`]. The collection may reserve more space to avoid
/// frequent reallocations.
/// Panics if the new allocation size overflows [`usize`].
/// sm.insert("foo");
/// sm.reserve(32);
/// assert!(sm.capacity() >= 33);
/// Returns [`true`] if the slot map contains `key`.
/// let key = sm.insert(42);
/// assert_eq!(sm.contains_key(key), true);
/// assert_eq!(sm.contains_key(key), false);
/// Inserts a value into the slot map. Returns a unique key that can be used
/// to access this value.
/// Panics if the number of elements in the slot map equals
/// 2<sup>32</sup> - 2.
/// assert_eq!(sm[key], 42);
/// Inserts a value given by `f` into the slot map. The key where the
/// value will be stored is passed into `f`. This is useful to store values
/// that contain their own key.
/// let key = sm.insert_with_key(|k| (k, 20));
/// assert_eq!(sm[key], (key, 20));
try_insert_with_key/// If `f` returns `Err`, this method returns the error. The slotmap is untouched.
/// let key = sm.try_insert_with_key::<_, ()>(|k| Ok((k, 20))).unwrap();
/// sm.try_insert_with_key::<_, ()>(|k| Err(())).unwrap_err();
remove_from_slot// Helper function to remove a value from a slot. Safe iff the slot is
// occupied. Returns the value removed.
/// Removes a key from the slot map, returning the value at the key if the
/// key was not previously removed.
/// assert_eq!(sm.remove(key), Some(42));
/// assert_eq!(sm.remove(key), None);
/// Retains only the elements specified by the predicate.
/// In other words, remove all key-value pairs `(k, v)` such that
/// `f(k, &mut v)` returns false. This method invalidates any removed keys.
/// This function must iterate over all slots, empty or not. In the face of
/// many deleted elements it can be inefficient.
/// let k1 = sm.insert(0);
/// let k2 = sm.insert(1);
/// let k3 = sm.insert(2);
/// sm.retain(|key, val| key == k1 || *val == 1);
/// assert!(sm.contains_key(k1));
/// assert!(sm.contains_key(k2));
/// assert!(!sm.contains_key(k3));
/// assert_eq!(2, sm.len());
/// Clears the slot map. Keeps the allocated memory for reuse.
/// for i in 0..10 {
///     sm.insert(i);
/// assert_eq!(sm.len(), 10);
/// sm.clear();
/// assert_eq!(sm.len(), 0);
/// Clears the slot map, returning all key-value pairs in arbitrary order as
/// an iterator. Keeps the allocated memory for reuse.
/// When the iterator is dropped all elements in the slot map are removed,
/// even if the iterator was not fully consumed. If the iterator is not
/// dropped (using e.g. [`std::mem::forget`]), only the elements that were
/// iterated over are removed.
/// let k = sm.insert(0);
/// let v: Vec<_> = sm.drain().collect();
/// assert_eq!(v, vec![(k, 0)]);
/// Returns a reference to the value corresponding to the key.
/// let key = sm.insert("bar");
/// assert_eq!(sm.get(key), Some(&"bar"));
/// assert_eq!(sm.get(key), None);
/// Returns a reference to the value corresponding to the key without
/// version or bounds checking.
/// This should only be used if `contains_key(key)` is true. Otherwise it is
/// potentially unsafe.
/// assert_eq!(unsafe { sm.get_unchecked(key) }, &"bar");
/// // sm.get_unchecked(key) is now dangerous!
/// Returns a mutable reference to the value corresponding to the key.
/// let key = sm.insert(3.5);
/// if let Some(x) = sm.get_mut(key) {
///     *x += 3.0;
/// assert_eq!(sm[key], 6.5);
/// Returns a mutable reference to the value corresponding to the key
/// without version or bounds checking.
/// let key = sm.insert("foo");
/// unsafe { *sm.get_unchecked_mut(key) = "bar" };
/// assert_eq!(sm[key], "bar");
/// // sm.get_unchecked_mut(key) is now dangerous!
/// Returns mutable references to the values corresponding to the given
/// keys. All keys must be valid and disjoint, otherwise None is returned.
/// Requires at least stable Rust version 1.51.
/// let ka = sm.insert("butter");
/// let kb = sm.insert("apples");
/// let kc = sm.insert("charlie");
/// sm.remove(kc); // Make key c invalid.
/// assert_eq!(sm.get_disjoint_mut([ka, kb, kc]), None); // Has invalid key.
/// assert_eq!(sm.get_disjoint_mut([ka, ka]), None); // Not disjoint.
/// let [a, b] = sm.get_disjoint_mut([ka, kb]).unwrap();
/// std::mem::swap(a, b);
/// assert_eq!(sm[ka], "apples");
/// assert_eq!(sm[kb], "butter");
/// keys. All keys must be valid and disjoint.
/// This should only be used if `contains_key(key)` is true for every given
/// key and no two keys are equal. Otherwise it is potentially unsafe.
/// let [a, b] = unsafe { sm.get_disjoint_unchecked_mut([ka, kb]) };
/// An iterator visiting all key-value pairs in arbitrary order. The
/// iterator element type is `(K, &'a V)`.
/// let k0 = sm.insert(0);
/// let k1 = sm.insert(1);
/// let k2 = sm.insert(2);
/// for (k, v) in sm.iter() {
///     println!("key: {:?}, val: {}", k, v);
/// An iterator visiting all key-value pairs in arbitrary order, with
/// mutable references to the values. The iterator element type is
/// `(K, &'a mut V)`.
/// let k0 = sm.insert(10);
/// let k1 = sm.insert(20);
/// let k2 = sm.insert(30);
/// for (k, v) in sm.iter_mut() {
///     if k != k1 {
///         *v *= -1;
/// assert_eq!(sm[k0], -10);
/// assert_eq!(sm[k1], 20);
/// assert_eq!(sm[k2], -30);
/// An iterator visiting all keys in arbitrary order. The iterator element
/// type is `K`.
/// # use std::collections::HashSet;
/// let keys: HashSet<_> = sm.keys().collect();
/// let check: HashSet<_> = vec![k0, k1, k2].into_iter().collect();
/// assert_eq!(keys, check);
/// An iterator visiting all values in arbitrary order. The iterator element
/// type is `&'a V`.
/// let values: HashSet<_> = sm.values().collect();
/// let check: HashSet<_> = vec![&10, &20, &30].into_iter().collect();
/// assert_eq!(values, check);
/// An iterator visiting all values mutably in arbitrary order. The iterator
/// element type is `&'a mut V`.
/// sm.insert(1);
/// sm.insert(2);
/// sm.insert(3);
/// sm.values_mut().for_each(|n| { *n *= 3 });
/// let values: HashSet<_> = sm.into_iter().map(|(_k, v)| v).collect();
/// let check: HashSet<_> = vec![3, 6, 9].into_iter().collect();
sm// Iterators.
/// A draining iterator for [`SlotMap`].
/// This iterator is created by [`SlotMap::drain`].
num_left/// An iterator that moves key-value pairs out of a [`SlotMap`].
/// This iterator is created by calling the `into_iter` method on [`SlotMap`],
/// provided by the [`IntoIterator`] trait.
/// An iterator over the key-value pairs in a [`SlotMap`].
/// This iterator is created by [`SlotMap::iter`].
/// A mutable iterator over the key-value pairs in a [`SlotMap`].
/// This iterator is created by [`SlotMap::iter_mut`].
/// An iterator over the keys in a [`SlotMap`].
/// This iterator is created by [`SlotMap::keys`].
/// An iterator over the values in a [`SlotMap`].
/// This iterator is created by [`SlotMap::values`].
/// A mutable iterator over the values in a [`SlotMap`].
/// This iterator is created by [`SlotMap::values_mut`].
CountDrop// Needed because assigning to non-Copy union is unsafe in stable but not in nightly.
//! Contains the slot map implementation.
idx_or_free// An index when occupied, the next free slot otherwise.
// A slot, which represents storage for an index and a current version.
DenseSlotMap/// Dense slot map, storage with stable unique keys.
/// Construct a new, empty [`DenseSlotMap`].
/// let mut sm: DenseSlotMap<_, i32> = DenseSlotMap::new();
/// Creates an empty [`DenseSlotMap`] with the given capacity.
/// let mut sm: DenseSlotMap<_, i32> = DenseSlotMap::with_capacity(10);
/// Constructs a new, empty [`DenseSlotMap`] with a custom key type.
/// let mut positions: DenseSlotMap<PositionKey, i32> = DenseSlotMap::with_key();
/// Creates an empty [`DenseSlotMap`] with the given capacity and a custom key
/// let mut messages = DenseSlotMap::with_capacity_and_key(3);
/// let mut sm = DenseSlotMap::with_capacity(10);
/// let mut sm = DenseSlotMap::new();
/// Returns the number of elements the [`DenseSlotMap`] can hold without
/// let sm: DenseSlotMap<_, f64> = DenseSlotMap::with_capacity(10);
/// in the [`DenseSlotMap`]. The collection may reserve more space to
/// avoid frequent reallocations.
free_slot// Helper function to add a slot to the freelist. Returns the index that
// was stored in the slot.
// Helper function to remove a value from a slot and make the slot free.
// Returns the value removed.
/// Clears the slot map, returning all key-value pairs in arbitrary order
/// as an iterator. Keeps the allocated memory for reuse.
/// keys. All keys must be valid and disjoint, otherwise [`None`] is
/// let mut it = sm.iter();
/// type is K.
/// A draining iterator for [`DenseSlotMap`].
/// This iterator is created by [`DenseSlotMap::drain`].
inner_keysinner_values/// An iterator that moves key-value pairs out of a [`DenseSlotMap`].
/// This iterator is created by calling the `into_iter` method on [`DenseSlotMap`],
/// An iterator over the key-value pairs in a [`DenseSlotMap`].
/// This iterator is created by [`DenseSlotMap::iter`].
/// A mutable iterator over the key-value pairs in a [`DenseSlotMap`].
/// This iterator is created by [`DenseSlotMap::iter_mut`].
/// An iterator over the keys in a [`DenseSlotMap`].
/// This iterator is created by [`DenseSlotMap::keys`].
/// An iterator over the values in a [`DenseSlotMap`].
/// This iterator is created by [`DenseSlotMap::values`].
/// A mutable iterator over the values in a [`DenseSlotMap`].
/// This iterator is created by [`DenseSlotMap::values_mut`].
//! Contains the dense slot map implementation.
other_endFreeListEntry// Metadata to maintain the freelist.
HopSlotMap/// Hop slot map, storage with stable unique keys.
/// Constructs a new, empty [`HopSlotMap`].
/// let mut sm: HopSlotMap<_, i32> = HopSlotMap::new();
/// Creates an empty [`HopSlotMap`] with the given capacity.
/// let mut sm: HopSlotMap<_, i32> = HopSlotMap::with_capacity(10);
/// Constructs a new, empty [`HopSlotMap`] with a custom key type.
/// let mut positions: HopSlotMap<PositionKey, i32> = HopSlotMap::with_key();
/// Creates an empty [`HopSlotMap`] with the given capacity and a custom key
/// let mut messages = HopSlotMap::with_capacity_and_key(3);
/// let mut sm = HopSlotMap::with_capacity(10);
/// let mut sm = HopSlotMap::new();
/// Returns the number of elements the [`HopSlotMap`] can hold without
/// let sm: HopSlotMap<_, f64> = HopSlotMap::with_capacity(10);
/// in the [`HopSlotMap`]. The collection may reserve more space to
/// Inserts a value into the slot map. Returns a unique key that can be
/// used to access this value.
// Helper function to make using the freelist painless.
// For that same ergonomy it uses u32, not usize as index.
// Safe iff idx is a valid index and the slot at that index is vacant.
/// dangerous undefined behavior.
/// A draining iterator for [`HopSlotMap`].
/// This iterator is created by [`HopSlotMap::drain`].
/// An iterator that moves key-value pairs out of a [`HopSlotMap`].
/// This iterator is created by calling the `into_iter` method on [`HopSlotMap`],
/// An iterator over the key-value pairs in a [`HopSlotMap`].
/// This iterator is created by [`HopSlotMap::iter`].
/// A mutable iterator over the key-value pairs in a [`HopSlotMap`].
/// This iterator is created by [`HopSlotMap::iter_mut`].
/// An iterator over the keys in a [`HopSlotMap`].
/// This iterator is created by [`HopSlotMap::keys`].
/// An iterator over the values in a [`HopSlotMap`].
/// This iterator is created by [`HopSlotMap::values`].
/// A mutable iterator over the values in a [`HopSlotMap`].
/// This iterator is created by [`HopSlotMap::values_mut`].
//! Contains the faster iteration, slower insertion/removal slot map
//! implementation.
//! This data structure is essentially the same as a regular [`SlotMap`], but
//! maintains extra information when inserting/removing elements that allows it
//! to 'hop over' vacant slots during iteration, making it potentially much
//! faster for iteration.
//! The trade-off is that compared to a regular [`SlotMap`] insertion/removal is
//! roughly twice as slow. Random indexing has identical performance for both.
//! [`SlotMap`]: crate::SlotMap
"slotmap"// So our macros can refer to these.
SecondaryMapSlottable// Keep Slottable for backwards compatibility, but warn about deprecation
// and hide from documentation.
/// The actual data stored in a [`Key`].
/// This implements [`Ord`](std::cmp::Ord) so keys can be stored in e.g.
/// [`BTreeMap`](std::collections::BTreeMap), but the order of keys is
/// unspecified.
as_ffi/// Returns the key data as a 64-bit integer. No guarantees about its value
/// are made other than that passing it to [`from_ffi`](Self::from_ffi)
/// will return a key equal to the original.
/// With this you can easily pass slot map keys as opaque handles to foreign
/// code. After you get them back you can confidently use them in your slot
/// map without worrying about unsafe behavior as you would with passing and
/// receiving back references or pointers.
/// This is not a substitute for proper serialization, use [`serde`] for
/// that. If you are not doing FFI, you almost surely do not need this
/// function.
/// [`serde`]: crate#serialization-through-serde-no_std-support-and-unstable-features
from_ffi/// Iff `value` is a value received from `k.as_ffi()`, returns a key equal
/// to `k`. Otherwise the behavior is safe but unspecified.
/// Creates a new key that is always invalid and distinct from any non-null
/// key. A null key can only be created through this method (or default
/// initialization of keys made with [`new_key_type!`], which calls this
/// method).
/// A null key is always invalid, but an invalid key (that is, a key that
/// has been removed from the slot map) does not become a null key. A null
/// is safe to use with any safe method of any slot map instance.
/// let k = sm.insert(42);
/// let nk = DefaultKey::null();
/// assert!(nk.is_null());
/// assert!(k != nk);
/// assert_eq!(sm.get(nk), None);
/// Checks if a key is null. There is only a single null key, that is
/// `a.is_null() && b.is_null()` implies `a == b`.
/// new_key_type! { struct MyKey; }
/// let a = MyKey::null();
/// let b = MyKey::default();
/// assert_eq!(a, b);
/// assert!(a.is_null());
/// Gets the [`KeyData`] stored in this key.
/// let dk = DefaultKey::null();
/// let mk = MyKey::null();
/// assert_eq!(dk.data(), mk.data());
/// Key used to access stored values in a slot map.
/// Do not use a key from one slot map in another. The behavior is safe but
/// non-sensical (and might panic in case of out-of-bounds).
/// To prevent this, it is suggested to have a unique key type for each slot
/// map. You can create new key types using [`new_key_type!`], which makes a
/// new type identical to [`DefaultKey`], just with a different name.
/// This trait is intended to be a thin wrapper around [`KeyData`], and all
/// methods must behave exactly as if we're operating on a [`KeyData`] directly.
/// The internal unsafe code relies on this, therefore this trait is `unsafe` to
/// implement. It is strongly suggested to simply use [`new_key_type!`] instead
/// of implementing this trait yourself.
/// A helper macro to create new key types. If you use a new key type for each
/// slot map you create you can entirely prevent using the wrong key on the
/// wrong slot map.
/// The type constructed by this macro is defined exactly as [`DefaultKey`],
/// but is a distinct type for the type checker and does not implicitly convert.
/// # extern crate slotmap;
///     // A private key type.
///     struct RocketKey;
///     // A public key type with a doc comment.
///     /// Key for the user slot map.
///     pub struct UserKey;
///     let mut users = SlotMap::with_key();
///     let mut rockets = SlotMap::with_key();
///     let bob: UserKey = users.insert("bobby");
///     let apollo: RocketKey = rockets.insert("apollo");
///     // Now this is a type error because rockets.get expects an RocketKey:
///     // rockets.get(bob);
///     // If for some reason you do end up needing to convert (e.g. storing
///     // keys of multiple slot maps in the same data structure without
///     // boxing), you can use KeyData as an intermediate representation. This
///     // does mean that once again you are responsible for not using the wrong
///     // key on the wrong slot map.
///     let keys = vec![bob.data(), apollo.data()];
///     println!("{} likes rocket {}",
///              users[keys[0].into()], rockets[keys[1].into()]);
r" The default slot map key type.
"macro_expansion// Intentionally no `use super::*;` because we want to test macro expansion
// in the *users* scope, which might not have that.
check_is_older_versioniters_cloneable//! # slotmap
//! This library provides a container with persistent unique keys to access
//! stored values, [`SlotMap`]. Upon insertion a key is returned that can be
//! used to later access or remove the values. Insertion, removal and access all
//! take O(1) time with low overhead. Great for storing collections of objects
//! that need stable, safe references but have no clear ownership otherwise,
//! such as game entities or graph nodes.
//! The difference between a [`BTreeMap`] or [`HashMap`] and a slot map is
//! that the slot map generates and returns the key when inserting a value. A
//! key is always unique and will only refer to the value that was inserted.
//! A slot map's main purpose is to simply own things in a safe and efficient
//! manner.
//! You can also create (multiple) secondary maps that can map the keys returned
//! by [`SlotMap`] to other values, to associate arbitrary data with objects
//! stored in slot maps, without hashing required - it's direct indexing under
//! the hood.
//! The minimum required stable Rust version for this crate is 1.49.
//! # use slotmap::*;
//! let mut sm = SlotMap::new();
//! let foo = sm.insert("foo");  // Key generated on insert.
//! let bar = sm.insert("bar");
//! assert_eq!(sm[foo], "foo");
//! assert_eq!(sm[bar], "bar");
//! sm.remove(bar);
//! let reuse = sm.insert("reuse");  // Space from bar reused.
//! assert_eq!(sm.contains_key(bar), false);  // After deletion a key stays invalid.
//! let mut sec = SecondaryMap::new();
//! sec.insert(foo, "noun");  // We provide the key for secondary maps.
//! sec.insert(reuse, "verb");
//! for (key, val) in sm {
//!     println!("{} is a {}", val, sec[key]);
//! # Serialization through [`serde`], [`no_std`] support and unstable features
//! Both keys and the slot maps have full (de)seralization support through
//! the [`serde`] library. A key remains valid for a slot map even after one or
//! both have been serialized and deserialized! This makes storing or
//! transferring complicated referential structures and graphs a breeze. Care has
//! been taken such that deserializing keys and slot maps from untrusted sources
//! is safe. If you wish to use these features you must enable the `serde`
//! feature flag for `slotmap` in your `Cargo.toml`.
//! ```text
//! slotmap = { version = "1.0", features = ["serde"] }
//! This crate also supports [`no_std`] environments, but does require the
//! [`alloc`] crate to be available. To enable this you have to disable the
//! `std` feature that is enabled by default:
//! slotmap = { version = "1.0", default-features = false }
//! Unfortunately [`SparseSecondaryMap`] is not available in [`no_std`], because
//! it relies on [`HashMap`]. Finally the `unstable` feature can be defined to
//! enable the parts of `slotmap` that only work on nightly Rust.
//! # Why not index a [`Vec`], or use [`slab`], [`stable-vec`], etc?
//! Those solutions either can not reclaim memory from deleted elements or
//! suffer from the ABA problem. The keys returned by `slotmap` are versioned.
//! This means that once a key is removed, it stays removed, even if the
//! physical storage inside the slotmap is reused for new elements. The key is a
//! permanently unique<sup>*</sup> reference to the inserted value. Despite
//! supporting versioning, a [`SlotMap`] is often not (much) slower than the
//! alternative, by internally using carefully checked unsafe code. Finally,
//! `slotmap` simply has a lot of features that make your life easy.
//! # Performance characteristics and implementation details
//! Insertion, access and deletion is all O(1) with low overhead by storing the
//! elements inside a [`Vec`]. Unlike references or indices into a vector,
//! unless you remove a key it is never invalidated. Behind the scenes each
//! slot in the vector is a `(value, version)` tuple. After insertion the
//! returned key also contains a version. Only when the stored version and
//! version in a key match is a key valid. This allows us to reuse space in the
//! vector after deletion without letting removed keys point to spurious new
//! elements. <sup>*</sup>After 2<sup>31</sup> deletions and insertions to the
//! same underlying slot the version wraps around and such a spurious reference
//! could potentially occur. It is incredibly unlikely however, and in all
//! circumstances is the behavior safe. A slot map can hold up to
//! 2<sup>32</sup> - 2 elements at a time.
//! The memory usage for each slot in [`SlotMap`] is `4 + max(sizeof(T), 4)`
//! rounded up to the alignment of `T`. Similarly it is `4 + max(sizeof(T), 12)`
//! for [`HopSlotMap`]. [`DenseSlotMap`] has an overhead of 8 bytes per element
//! and 8 bytes per slot.
//! # Choosing [`SlotMap`], [`HopSlotMap`] or [`DenseSlotMap`]
//! A [`SlotMap`] is the fastest for most operations, except iteration. It can
//! never shrink the size of its underlying storage, because it must remember
//! for each storage slot what the latest stored version was, even if the slot
//! is empty now. This means that iteration can be slow as it must iterate over
//! potentially a lot of empty slots.
//! [`HopSlotMap`] solves this by maintaining more information on
//! insertion/removal, allowing it to iterate only over filled slots by 'hopping
//! over' contiguous blocks of vacant slots. This can give it significantly
//! better iteration speed.  If you expect to iterate over all elements in a
//! [`SlotMap`] a lot, and potentially have a lot of deleted elements, choose
//! [`HopSlotMap`]. The downside is that insertion and removal is roughly twice
//! as slow. Random access is the same speed for both.
//! [`DenseSlotMap`] goes even further and stores all elements on a contiguous
//! block of memory. It uses two indirections per random access; the slots
//! contain indices used to access the contiguous memory. This means random
//! access is slower than both [`SlotMap`] and [`HopSlotMap`], but iteration is
//! significantly faster, as fast as a normal [`Vec`].
//! # Choosing [`SecondaryMap`] or [`SparseSecondaryMap`]
//! You want to associate extra data with objects stored in a slot map, so you
//! use (multiple) secondary maps to map keys to that data.
//! A [`SecondaryMap`] is simply a [`Vec`] of slots like slot map is, and
//! essentially provides all the same guarantees as [`SlotMap`] does for its
//! operations (with the exception that you provide the keys as produced by the
//! primary slot map). This does mean that even if you associate data to only
//! a single element from the primary slot map, you could need and have to
//! initialize as much memory as the original.
//! A [`SparseSecondaryMap`] is like a [`HashMap`] from keys to objects, however
//! it automatically removes outdated keys for slots that had their space
//! reused. You should use this variant if you expect to store some associated
//! data for only a small portion of the primary slot map.
//! # Custom key types
//! If you have multiple slot maps it's an error to use the key of one slot map
//! on another slot map. The result is safe, but unspecified, and can not be
//! detected at runtime, so it can lead to a hard to find bug.
//! To prevent this, slot maps allow you to specify what the type is of the key
//! they return. You can construct new key types using the [`new_key_type!`]
//! macro. The resulting type behaves exactly like [`DefaultKey`], but is a
//! distinct type. So instead of simply using `SlotMap<DefaultKey, Player>` you
//! would use:
//! # #[derive(Copy, Clone)]
//! # struct Player;
//! new_key_type! { struct PlayerKey; }
//! let sm: SlotMap<PlayerKey, Player> = SlotMap::with_key();
//! You can write code generic over any key type using the [`Key`] trait.
//! [`Vec`]: std::vec::Vec
//! [`BTreeMap`]: std::collections::BTreeMap
//! [`HashMap`]: std::collections::HashMap
//! [`serde`]: https://github.com/serde-rs/serde
//! [`slab`]: https://crates.io/crates/slab
//! [`stable-vec`]: https://crates.io/crates/stable-vec
//! [`no_std`]: https://doc.rust-lang.org/1.7.0/book/no-stdlib.html
is_older_version// This representation works because we don't have to store the versions
// of removed elements.
new_occupiednew_vacant/// Secondary map, associate data with previously stored elements in a slot map.
/// A [`SecondaryMap`] allows you to efficiently store additional information
/// for each element in a slot map. You can have multiple secondary maps per
/// slot map, but not multiple slot maps per secondary map. It is safe but
/// unspecified behavior if you use keys from multiple different slot maps in
/// the same [`SecondaryMap`].
/// A [`SecondaryMap`] does not leak memory even if you never remove elements.
/// In return, when you remove a key from the primary slot map, after any insert
/// the space associated with the removed element may be reclaimed. Don't expect
/// the values associated with a removed key to stick around after an insertion
/// has happened!
/// Finally a note on memory complexity, the [`SecondaryMap`] can use memory for
/// each slot in the primary slot map, and has to iterate over every slot during
/// iteration, regardless of whether you have inserted an associative value at
/// that key or not. If you have some property that you only expect to set for a
/// minority of keys, use a [`SparseSecondaryMap`](crate::SparseSecondaryMap),
/// which is backed by a [`HashMap`](std::collections::HashMap).
/// Example usage:
/// let mut players = SlotMap::new();
/// let mut health = SecondaryMap::new();
/// let mut ammo = SecondaryMap::new();
/// let alice = players.insert("alice");
/// let bob = players.insert("bob");
/// for p in players.keys() {
///     health.insert(p, 100);
///     ammo.insert(p, 30);
/// // Alice attacks Bob with all her ammo!
/// health[bob] -= ammo[alice] * 3;
/// ammo[alice] = 0;
/// Constructs a new, empty [`SecondaryMap`].
/// let mut sec: SecondaryMap<DefaultKey, i32> = SecondaryMap::new();
/// Creates an empty [`SecondaryMap`] with the given capacity of slots.
/// The secondary map will not reallocate until it holds at least `capacity`
/// slots. Even inserting a single key-value pair might require as many
/// slots as the slot map the key comes from, so it's recommended to match
/// the capacity of a secondary map to its corresponding slot map.
/// let mut sec: SecondaryMap<DefaultKey, i32> = SecondaryMap::with_capacity(sm.capacity());
/// Returns the number of elements in the secondary map.
/// let k = sm.insert(4);
/// let mut squared = SecondaryMap::new();
/// assert_eq!(squared.len(), 0);
/// squared.insert(k, 16);
/// assert_eq!(squared.len(), 1);
/// Returns if the secondary map is empty.
/// assert!(sec.is_empty());
/// Returns the number of elements the [`SecondaryMap`] can hold without
/// let mut sec: SecondaryMap<DefaultKey, i32> = SecondaryMap::with_capacity(10);
/// assert!(sec.capacity() >= 10);
/// Sets the capacity of the [`SecondaryMap`] to `new_capacity`, if it is
/// bigger than the current capacity.
/// It is recommended to set the capacity of a [`SecondaryMap`] to the
/// capacity of its corresponding slot map before inserting many new
/// elements to prevent frequent reallocations. The collection may reserve
/// more space than requested.
/// sec.set_capacity(1000);
/// assert!(sec.capacity() >= 1000);
/// Returns [`true`] if the secondary map contains `key`.
/// assert!(!squared.contains_key(k));
/// assert!(squared.contains_key(k));
/// Inserts a value into the secondary map at the given `key`. Can silently
/// fail and return `None` if `key` was removed from the originating slot
/// map.
/// Returns [`None`] if this key was not present in the map, the old value
/// assert_eq!(squared.insert(k, 0), None);
/// assert_eq!(squared.insert(k, 4), Some(0));
/// // You don't have to use insert if the key is already in the secondary map.
/// squared[k] *= squared[k];
/// assert_eq!(squared[k], 16);
/// Removes a key from the secondary map, returning the value at the key if
/// the key was not previously removed. If `key` was removed from the
/// originating slot map, its corresponding entry in the secondary map may
/// or may not already be removed.
/// squared.remove(k);
/// // It's not necessary to remove keys deleted from the primary slot map, they
/// // get deleted automatically when their slots are reused on a subsequent insert.
/// sm.remove(k); // Remove k from the slot map, making an empty slot.
/// let new_k = sm.insert(2); // Since sm only has one empty slot, this reuses it.
/// assert!(!squared.contains_key(new_k)); // Space reuse does not mean equal keys.
/// assert!(squared.contains_key(k)); // Slot has not been reused in squared yet.
/// squared.insert(new_k, 4);
/// assert!(!squared.contains_key(k)); // Old key is no longer available.
/// let mut sec = SecondaryMap::new();
/// let k1 = sm.insert(0); sec.insert(k1, 10);
/// let k2 = sm.insert(1); sec.insert(k2, 11);
/// let k3 = sm.insert(2); sec.insert(k3, 12);
/// sec.retain(|key, val| key == k1 || *val == 11);
/// assert!(sec.contains_key(k1));
/// assert!(sec.contains_key(k2));
/// assert!(!sec.contains_key(k3));
/// assert_eq!(sec.len(), 2);
/// Clears the secondary map. Keeps the allocated memory for reuse.
///     sec.insert(sm.insert(i), i);
/// assert_eq!(sec.len(), 10);
/// sec.clear();
/// assert_eq!(sec.len(), 0);
/// # use std::iter::FromIterator;
/// sec.insert(k, 1);
/// let v: Vec<_> = sec.drain().collect();
/// assert_eq!(v, vec![(k, 1)]);
/// sec.insert(key, "bar");
/// assert_eq!(sec.get(key), Some(&"bar"));
/// sec.remove(key);
/// assert_eq!(sec.get(key), None);
/// assert_eq!(unsafe { sec.get_unchecked(key) }, &"bar");
/// // sec.get_unchecked(key) is now dangerous!
/// let key = sm.insert("test");
/// sec.insert(key, 3.5);
/// if let Some(x) = sec.get_mut(key) {
/// assert_eq!(sec[key], 6.5);
/// unsafe { *sec.get_unchecked_mut(key) = "baz" };
/// assert_eq!(sec[key], "baz");
/// // sec.get_unchecked_mut(key) is now dangerous!
/// let ka = sm.insert(()); sec.insert(ka, "butter");
/// let kb = sm.insert(()); sec.insert(kb, "apples");
/// let kc = sm.insert(()); sec.insert(kc, "charlie");
/// sec.remove(kc); // Make key c invalid.
/// assert_eq!(sec.get_disjoint_mut([ka, kb, kc]), None); // Has invalid key.
/// assert_eq!(sec.get_disjoint_mut([ka, ka]), None); // Not disjoint.
/// let [a, b] = sec.get_disjoint_mut([ka, kb]).unwrap();
/// assert_eq!(sec[ka], "apples");
/// assert_eq!(sec[kb], "butter");
/// let [a, b] = unsafe { sec.get_disjoint_unchecked_mut([ka, kb]) };
/// let k0 = sm.insert(0); sec.insert(k0, 10);
/// let k1 = sm.insert(1); sec.insert(k1, 11);
/// let k2 = sm.insert(2); sec.insert(k2, 12);
/// let k0 = sm.insert(1); sec.insert(k0, 10);
/// let k1 = sm.insert(2); sec.insert(k1, 20);
/// let k2 = sm.insert(3); sec.insert(k2, 30);
/// for (k, v) in sec.iter_mut() {
/// assert_eq!(sec[k0], -10);
/// assert_eq!(sec[k1], 20);
/// assert_eq!(sec[k2], -30);
/// let keys: HashSet<_> = sec.keys().collect();
/// let values: HashSet<_> = sec.values().collect();
/// sec.insert(sm.insert(1), 10);
/// sec.insert(sm.insert(2), 20);
/// sec.insert(sm.insert(3), 30);
/// sec.values_mut().for_each(|n| { *n *= 3 });
/// let values: HashSet<_> = sec.into_iter().map(|(_k, v)| v).collect();
/// let check: HashSet<_> = vec![30, 60, 90].into_iter().collect();
/// Gets the given key's corresponding [`Entry`] in the map for in-place
/// manipulation. May return [`None`] if the key was removed from the
/// originating slot map.
/// let k = sm.insert(1);
/// let v = sec.entry(k).unwrap().or_insert(10);
/// assert_eq!(*v, 10);
/// A view into a occupied entry in a [`SecondaryMap`]. It is part of the
/// [`Entry`] enum.
/// A view into a vacant entry in a [`SecondaryMap`]. It is part of the
/// An occupied entry.
/// A vacant entry.
/// A view into a single entry in a [`SecondaryMap`], which may either be
/// vacant or occupied.
/// This `enum` is constructed using [`SecondaryMap::entry`].
/// Ensures a value is in the entry by inserting the default if empty, and
/// returns a mutable reference to the value in the entry.
/// let k = sm.insert("poneyland");
/// *sec.entry(k).unwrap().or_insert(1) *= 2;
/// assert_eq!(sec[k], 20);
/// Ensures a value is in the entry by inserting the result of the default
/// function if empty, and returns a mutable reference to the value in the
/// entry.
/// let v = sec.entry(k).unwrap().or_insert_with(|| "foobar".to_string());
/// assert_eq!(v, &"foobar");
/// Returns this entry's key.
/// let mut sec: SecondaryMap<_, ()> = SecondaryMap::new();
/// let entry = sec.entry(k).unwrap();
/// assert_eq!(entry.key(), k);
/// Provides in-place mutable access to an occupied entry before any
/// potential inserts into the map.
/// sec.insert(k, 0);
/// sec.entry(k).unwrap().and_modify(|x| *x = 1);
/// assert_eq!(sec[k], 1)
/// Ensures a value is in the entry by inserting the default value if empty,
/// and returns a mutable reference to the value in the entry.
/// let mut sec: SecondaryMap<_, Option<i32>> = SecondaryMap::new();
/// sec.entry(k).unwrap().or_default();
/// assert_eq!(sec[k], None)
/// sec.insert(k, 10);
/// assert_eq!(sec.entry(k).unwrap().key(), k);
/// Removes the entry from the slot map and returns the key and value.
/// # use slotmap::secondary::Entry;
/// let foo = sm.insert("foo");
/// sec.entry(foo).unwrap().or_insert("bar");
/// if let Some(Entry::Occupied(o)) = sec.entry(foo) {
///     assert_eq!(o.remove_entry(), (foo, "bar"));
/// assert_eq!(sec.contains_key(foo), false);
/// Gets a reference to the value in the entry.
/// if let Entry::Occupied(o) = sec.entry(k).unwrap() {
///     assert_eq!(*o.get(), 10);
/// Gets a mutable reference to the value in the entry.
/// If you need a reference to the [`OccupiedEntry`] which may outlive the
/// destruction of the [`Entry`] value, see [`into_mut`].
/// if let Entry::Occupied(mut o) = sec.entry(k).unwrap() {
///     *o.get_mut() = 20;
/// [`into_mut`]: Self::into_mut
/// Converts the [`OccupiedEntry`] into a mutable reference to the value in
/// the entry with a lifetime bound to the map itself.
/// If you need multiple references to the [`OccupiedEntry`], see
/// [`get_mut`].
/// let r;
///     r = o.into_mut(); // v outlives the entry.
/// } else {
///     r = sm.get_mut(k).unwrap();
/// *r = 1;
/// assert_eq!((sm[k], sec[k]), (0, 1));
/// [`get_mut`]: Self::get_mut
/// Sets the value of the entry, and returns the entry's old value.
///     let v = o.insert(20);
///     assert_eq!(v, 10);
///     assert_eq!(*o.get(), 20);
/// Takes the value out of the entry, and returns it.
///     assert_eq!(o.remove(), 10);
///     assert_eq!(sec.contains_key(k), false);
/// Gets the key that would be used when inserting a value through the
/// [`VacantEntry`].
/// if let Entry::Vacant(v) = sec.entry(k).unwrap() {
///     assert_eq!(v.key(), k);
/// Sets the value of the entry with the [`VacantEntry`]'s key, and returns
/// a mutable reference to it.
///     let new_val = v.insert(3);
///     assert_eq!(new_val, &mut 3);
/// A draining iterator for [`SecondaryMap`].
/// This iterator is created by [`SecondaryMap::drain`].
/// An iterator that moves key-value pairs out of a [`SecondaryMap`].
/// This iterator is created by calling the `into_iter` method on [`SecondaryMap`],
/// An iterator over the key-value pairs in a [`SecondaryMap`].
/// This iterator is created by [`SecondaryMap::iter`].
/// A mutable iterator over the key-value pairs in a [`SecondaryMap`].
/// This iterator is created by [`SecondaryMap::iter_mut`].
/// An iterator over the keys in a [`SecondaryMap`].
/// This iterator is created by [`SecondaryMap::keys`].
/// An iterator over the values in a [`SecondaryMap`].
/// This iterator is created by [`SecondaryMap::values`].
/// A mutable iterator over the values in a [`SecondaryMap`].
/// This iterator is created by [`SecondaryMap::values_mut`].
//! Contains the secondary map implementation.
SparseSecondaryMap/// Sparse secondary map, associate data with previously stored elements in a
/// slot map.
/// A [`SparseSecondaryMap`] allows you to efficiently store additional
/// information for each element in a slot map. You can have multiple secondary
/// maps per slot map, but not multiple slot maps per secondary map. It is safe
/// but unspecified behavior if you use keys from multiple different slot maps
/// in the same [`SparseSecondaryMap`].
/// A [`SparseSecondaryMap`] does not leak memory even if you never remove
/// elements. In return, when you remove a key from the primary slot map, after
/// any insert the space associated with the removed element may be reclaimed.
/// Don't expect the values associated with a removed key to stick around after
/// an insertion has happened!
/// Unlike [`SecondaryMap`], the [`SparseSecondaryMap`] is backed by a
/// [`HashMap`]. This means its access times are higher, but it uses less memory
/// and iterates faster if there are only a few elements of the slot map in the
/// secondary map. If most or all of the elements in a slot map are also found
/// in the secondary map, use a [`SecondaryMap`] instead.
/// The current implementation of [`SparseSecondaryMap`] requires [`std`] and is
/// thus not available in `no_std` environments.
/// [`SecondaryMap`]: crate::SecondaryMap
/// [`HashMap`]: std::collections::HashMap
/// let mut health = SparseSecondaryMap::new();
/// let mut ammo = SparseSecondaryMap::new();
/// Constructs a new, empty [`SparseSecondaryMap`].
/// let mut sec: SparseSecondaryMap<DefaultKey, i32> = SparseSecondaryMap::new();
/// Creates an empty [`SparseSecondaryMap`] with the given capacity of slots.
/// slots.
/// let mut sec: SparseSecondaryMap<DefaultKey, i32> =
///     SparseSecondaryMap::with_capacity(sm.capacity());
/// Creates an empty [`SparseSecondaryMap`] which will use the given hash
/// builder to hash keys.
/// # use std::collections::hash_map::RandomState;
/// let mut sec: SparseSecondaryMap<DefaultKey, i32, _> =
///     SparseSecondaryMap::with_hasher(RandomState::new());
/// Creates an empty [`SparseSecondaryMap`] with the given capacity of slots,
/// using `hash_builder` to hash the keys.
///     SparseSecondaryMap::with_capacity_and_hasher(10, RandomState::new());
/// let mut squared = SparseSecondaryMap::new();
/// Returns the number of elements the [`SparseSecondaryMap`] can hold without
/// let mut sec: SparseSecondaryMap<DefaultKey, i32> = SparseSecondaryMap::with_capacity(10);
/// Reserves capacity for at least `additional` more slots in the
/// [`SparseSecondaryMap`]. The collection may reserve more space to avoid
/// sec.reserve(10);
/// Tries to reserve capacity for at least `additional` more slots in the
/// [`SparseSecondaryMap`].  The collection may reserve more space to avoid
/// sec.try_reserve(10).unwrap();
/// fail if `key` was removed from the originating slot map.
/// let mut sec = SparseSecondaryMap::new();
/// assert_eq!(2, sec.len());
/// for (k, v) in sec.iter() {
/// A view into a occupied entry in a [`SparseSecondaryMap`]. It is part of the
/// A view into a vacant entry in a [`SparseSecondaryMap`]. It is part of the
/// A view into a single entry in a [`SparseSecondaryMap`], which may either be
/// This `enum` is constructed using [`SparseSecondaryMap::entry`].
/// let mut sec: SparseSecondaryMap<_, ()> = SparseSecondaryMap::new();
/// let mut sec: SparseSecondaryMap<_, Option<i32>> = SparseSecondaryMap::new();
/// # use slotmap::sparse_secondary::Entry;
/// A draining iterator for [`SparseSecondaryMap`].
/// This iterator is created by [`SparseSecondaryMap::drain`].
/// An iterator that moves key-value pairs out of a [`SparseSecondaryMap`].
/// This iterator is created by calling the `into_iter` method on [`SparseSecondaryMap`],
/// An iterator over the key-value pairs in a [`SparseSecondaryMap`].
/// This iterator is created by [`SparseSecondaryMap::iter`].
/// A mutable iterator over the key-value pairs in a [`SparseSecondaryMap`].
/// This iterator is created by [`SparseSecondaryMap::iter_mut`].
/// An iterator over the keys in a [`SparseSecondaryMap`].
/// This iterator is created by [`SparseSecondaryMap::keys`].
/// An iterator over the values in a [`SparseSecondaryMap`].
/// This iterator is created by [`SparseSecondaryMap::values`].
/// A mutable iterator over the values in a [`SparseSecondaryMap`].
/// This iterator is created by [`SparseSecondaryMap::values_mut`].
// Serialization with serde.
custom_hasherdisjoint//! Contains the sparse secondary map implementation.
/// Internal stable replacement for !.
/// Returns if a is an older version than b, taking into account wrapping of
/// versions.
unwrap_unchecked_// Extra underscore because unwrap_unchecked is planned to be added to the stdlib.
/// An unwrapper that checks on debug, doesn't check on release.
/// UB if unwrapped on release mode when unwrap would panic.
LayoutErr// count helper: transform any expression into 1/// Creates a [`SmallVec`] containing the arguments./// `smallvec!` allows `SmallVec`s to be defined with the same syntax as array expressions./// There are two forms of this macro:/// - Create a [`SmallVec`] containing a given list of elements:/// # use smallvec::{smallvec, SmallVec};/// let v: SmallVec<[_; 128]> = smallvec![1, 2, 3];/// assert_eq!(v[0], 1);/// assert_eq!(v[1], 2);/// assert_eq!(v[2], 3);/// - Create a [`SmallVec`] from a given element and size:/// let v: SmallVec<[_; 0x8000]> = smallvec![1; 3];/// assert_eq!(v, SmallVec::from_buf([1, 1, 1]));/// Note that unlike array expressions this syntax supports all elements/// which implement [`Clone`] and the number of elements doesn't have to be/// a constant./// This will use `clone` to duplicate an expression, so one should be careful/// using this with types having a nonstandard `Clone` implementation. For/// example, `smallvec![Rc::new(1); 5]` will create a vector of five references/// to the same boxed integer value, not five references pointing to independently/// boxed integers./// Creates an inline [`SmallVec`] containing the arguments. This macro is enabled by the feature `const_new`./// `smallvec_inline!` allows `SmallVec`s to be defined with the same syntax as array expressions in `const` contexts./// The inline storage `A` will always be an array of the size specified by the arguments./// # use smallvec::{smallvec_inline, SmallVec};/// const V: SmallVec<[i32; 3]> = smallvec_inline![1, 2, 3];/// assert_eq!(V[0], 1);/// assert_eq!(V[1], 2);/// assert_eq!(V[2], 3);/// const V: SmallVec<[i32; 3]> = smallvec_inline![1; 3];/// assert_eq!(V, SmallVec::from_buf([1, 1, 1]));/// Note that the behavior mimics that of array expressions, in contrast to [`smallvec`]./// Extends a collection from a slice of its element typeExtendFromSlice/// Trait to be implemented by a collection that can be extended from a slice/// use smallvec::{ExtendFromSlice, SmallVec};/// fn initialize<V: ExtendFromSlice<u8>>(v: &mut V) {///     v.extend_from_slice(b"Test!");/// let mut vec = Vec::new();/// initialize(&mut vec);/// assert_eq!(&vec, b"Test!");/// let mut small_vec = SmallVec::<[u8; 8]>::new();/// initialize(&mut small_vec);/// assert_eq!(&small_vec as &[_], b"Test!");CollectionAllocErr/// Overflow `usize::MAX` or other error during size computation/// The layout that was passed to the allocatorAllocErr/// The allocator return an error/// Error type for APIs with fallible heap allocationlayout_array/// FIXME: use `Layout::array` when we require a Rust version where it’s stable/// <https://github.com/rust-lang/rust/issues/55724>/// An iterator that removes the items from a `SmallVec` and yields them by value./// Returned from [`SmallVec::drain`][1]./// [1]: struct.SmallVec.html#method.drainSmallVecDatafrom_constConstNonNullinline_mutfrom_inlineinto_inlineheap_mutfrom_heap// The capacity field is used to determine which of the storage variants is active:// If capacity <= Self::inline_capacity() then the inline variant is used and capacity holds the current length of the vector (number of elements actually in use).// If capacity > Self::inline_capacity() then the heap variant is used and capacity holds the size of the memory allocation./// A `Vec`-like container that can store a small number of elements inline./// `SmallVec` acts like a vector, but can store a limited amount of data inline within the/// `SmallVec` struct rather than in a separate allocation.  If the data exceeds this limit, the/// `SmallVec` will "spill" its data onto the heap, allocating a new buffer to hold it./// The amount of data that a `SmallVec` can store inline depends on its backing store. The backing/// store can be any type that implements the `Array` trait; usually it is a small fixed-sized/// array.  For example a `SmallVec<[u64; 8]>` can hold up to eight 64-bit integers inline./// use smallvec::SmallVec;/// let mut v = SmallVec::<[u8; 4]>::new(); // initialize an empty vector/// // The vector can hold up to 4 items without spilling onto the heap./// v.extend(0..4);/// assert_eq!(v.len(), 4);/// assert!(!v.spilled());/// // Pushing another element will force the buffer to spill:/// v.push(4);/// assert!(v.spilled());/// Construct an empty vector/// Construct an empty vector with enough capacity pre-allocated to store at least `n`/// Will create a heap allocation only if `n` is larger than the inline capacity./// # use smallvec::SmallVec;/// let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(100);/// assert!(v.capacity() >= 100);/// Construct a new `SmallVec` from a `Vec<A::Item>`./// Elements will be copied to the inline buffer if `vec.capacity() <= Self::inline_capacity()`./// let vec = vec![1, 2, 3, 4, 5];/// let small_vec: SmallVec<[_; 3]> = SmallVec::from_vec(vec);/// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);/// Constructs a new `SmallVec` on the stack from an `A` without/// copying elements./// let buf = [1, 2, 3, 4, 5];/// let small_vec: SmallVec<_> = SmallVec::from_buf(buf);from_buf_and_len/// copying elements. Also sets the length, which must be less or/// equal to the size of `buf`./// let buf = [1, 2, 3, 4, 5, 0, 0, 0];/// let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);from_buf_and_len_unchecked/// copying elements. Also sets the length. The user is responsible/// for ensuring that `len <= A::size()`./// let small_vec: SmallVec<_> = unsafe {///     SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), 5)inline_capacity/// The maximum number of elements this vector can hold inlineinline_size/// The number of elements stored in the vector/// Returns `true` if the vector is empty/// The number of items the vector can hold without reallocating/// Returns a tuple with (data ptr, len, capacity)/// Useful to get all `SmallVec` properties with a single check of the current storage variant.triple_mut/// Returns a tuple with (data ptr, len ptr, capacity)spilled/// Returns `true` if the data has spilled into a separate heap-allocated buffer./// Creates a draining iterator that removes the specified range in the vector/// and yields the removed items./// Note 1: The element range is removed even if the iterator is only/// partially consumed or not consumed at all./// Note 2: It is unspecified how many elements are removed from the vector/// Panics if the starting point is greater than the end point or if/// Moves all the elements of `other` into `self`, leaving `other` empty./// # use smallvec::{SmallVec, smallvec};/// let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];/// let mut v1: SmallVec<[u8; 32]> = smallvec![4, 5, 6];/// v0.append(&mut v1);/// assert_eq!(*v0, [1, 2, 3, 4, 5, 6]);/// assert_eq!(*v1, []);/// Re-allocate to set the capacity to `max(new_cap, inline_size())`./// Panics if `new_cap` is less than the vector's length/// or if the capacity computation overflows `usize`./// Reserve capacity for `additional` more elements to be inserted./// May reserve more space to avoid frequent reallocations./// Panics if the capacity computation overflows `usize`.reserve_one_unchecked/// Internal method used to grow in push() and insert(), where we know already we have to grow./// Reserve the minimum capacity for `additional` more elements to be inserted./// Shrink the capacity of the vector as much as possible./// When possible, this will move data from an external heap buffer to the vector's inline/// Shorten the vector, keeping the first `len` elements and dropping the rest./// If `len` is greater than or equal to the vector's current length, this has no/// This does not re-allocate.  If you want the vector's capacity to shrink, call/// `shrink_to_fit` after truncating./// Extracts a slice containing the entire vector./// Equivalent to `&s[..]`./// Extracts a mutable slice of the entire vector./// Equivalent to `&mut s[..]`./// Remove the element at position `index`, replacing it with the last element./// This does not preserve ordering, but is O(1)./// Panics if `index` is out of bounds./// Remove all elements from the vector./// Remove and return the element at position `index`, shifting all elements after it to the/// Insert an element at position `index`, shifting all elements after it to the right./// Panics if `index > len`.insert_many/// Insert multiple elements at position `index`, shifting all following elements toward the/// back./// Convert a `SmallVec` to a `Vec`, without reallocating if the `SmallVec` has already spilled onto/// Converts a `SmallVec` into a `Box<[T]>` without reallocating if the `SmallVec` has already spilled/// onto the heap./// Note that this will drop any excess capacity./// Convert the `SmallVec` into an `A` if possible. Otherwise return `Err(Self)`./// This method returns `Err(Self)` if the `SmallVec` is too short (and the `A` contains uninitialized elements),/// or if the `SmallVec` is too long (and all the elements were spilled to the heap).retain_mut/// This method is identical in behaviour to [`retain`]; it is included only/// to maintain api-compatibility with `std::Vec`, where the methods are/// separate for historical reasons./// Removes consecutive duplicate elements./// Removes consecutive duplicate elements using the given equality relation.dedup_by_key/// Removes consecutive elements that map to the same key./// Resizes the `SmallVec` in-place so that `len` is equal to `new_len`./// If `new_len` is greater than `len`, the `SmallVec` is extended by the difference, with each/// additional slot filled with the result of calling the closure `f`. The return values from `f`/// will end up in the `SmallVec` in the order they have been generated./// If `new_len` is less than `len`, the `SmallVec` is simply truncated./// This method uses a closure to create new values on every push. If you'd rather `Clone` a given/// value, use `resize`. If you want to use the `Default` trait to generate values, you can pass/// `Default::default()` as the second argument./// Added for `std::vec::Vec` compatibility (added in Rust 1.33.0)/// let mut vec : SmallVec<[_; 4]> = smallvec![1, 2, 3];/// vec.resize_with(5, Default::default);/// assert_eq!(&*vec, &[1, 2, 3, 0, 0]);/// let mut vec : SmallVec<[_; 4]> = smallvec![];/// let mut p = 1;/// vec.resize_with(4, || { p *= 2; p });/// assert_eq!(&*vec, &[2, 4, 8, 16]);/// Creates a `SmallVec` directly from the raw components of another/// `SmallVec`./// This is highly unsafe, due to the number of invariants that aren't/// checked:/// * `ptr` needs to have been previously allocated via `SmallVec` for its///   spilled storage (at least, it's highly likely to be incorrect if it///   wasn't)./// * `ptr`'s `A::Item` type needs to be the same size and alignment that///   it was allocated with/// * `length` needs to be less than or equal to `capacity`./// * `capacity` needs to be the capacity that the pointer was allocated///   with./// Violating these may cause problems like corrupting the allocator's/// internal data structures./// Additionally, `capacity` must be greater than the amount of inline/// storage `A` has; that is, the new `SmallVec` must need to spill over/// into heap allocated storage. This condition is asserted against./// The ownership of `ptr` is effectively transferred to the/// `SmallVec` which may then deallocate, reallocate or change the/// contents of memory pointed to by the pointer at will. Ensure/// that nothing else uses the pointer after calling this///     let mut v: SmallVec<[_; 1]> = smallvec![1, 2, 3];///     // Pull out the important parts of `v`.///     let p = v.as_mut_ptr();///     let len = v.len();///     let cap = v.capacity();///     let spilled = v.spilled();///         // Forget all about `v`. The heap allocation that stored the///         // three values won't be deallocated.///         mem::forget(v);///         // Overwrite memory with [4, 5, 6].///         // This is only safe if `spilled` is true! Otherwise, we are///         // writing into the old `SmallVec`'s inline storage on the///         // stack.///         assert!(spilled);///         for i in 0..len {///             ptr::write(p.add(i), 4 + i);///         // Put everything back together into a SmallVec with a different///         // amount of inline storage, but which is still less than `cap`.///         let rebuilt = SmallVec::<[_; 2]>::from_raw_parts(p, len, cap);///         assert_eq!(&*rebuilt, &[4, 5, 6]);/// Returns a raw pointer to the vector's buffer./// Returns a raw mutable pointer to the vector's buffer./// Copy the elements from a slice into a new `SmallVec`./// For slices of `Copy` types, this is more efficient than `SmallVec::from(slice)`.insert_from_slice/// Copy elements from a slice into the vector at position `index`, shifting any following/// elements toward the back./// For slices of `Copy` types, this is more efficient than `insert`./// For slices of `Copy` types, this is more efficient than `extend`./// Resizes the vector so that its length is equal to `len`./// If `len` is less than the current length, the vector simply truncated./// If `len` is greater than the current length, `value` is appended to the/// vector until its length equals `len`./// Creates a `SmallVec` with `n` copies of `elem`./// let v = SmallVec::<[char; 128]>::from_elem('d', 2);/// assert_eq!(v, SmallVec::from_buf(['d', 'd']));/// An iterator that consumes a `SmallVec` and yields its items by value./// Returned from [`SmallVec::into_iter`][1]./// [1]: struct.SmallVec.html#method.into_iter/// The type of the array's elements./// Returns the number of items the array can hold./// Types that can be used as the backing store for a [`SmallVec`].local_lenSetLenOnDrop/// Set the length of the vec when the `SetLenOnDrop` value goes out of scope./// Copied from <https://github.com/rust-lang/rust/pull/36355>increment_len/// This is a `const` version of [`SmallVec::new`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays./// The array passed as an argument is moved to be an inline version of `SmallVec`./// This is a `const` version of [`SmallVec::from_buf`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays.from_const_with_len_unchecked/// Constructs a new `SmallVec` on the stack from an array without/// for ensuring that `len <= N`./// This is a `const` version of [`SmallVec::from_buf_and_len_unchecked`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays.to_smallvec/// Construct a new `SmallVec` from a slice.ToSmallVec/// Convenience trait for constructing a `SmallVec`// Immutable counterpart for `NonNull<T>`.//! Small vectors in various sizes. These store a certain number of elements inline, and fall back//! to the heap for larger allocations.  This can be a useful optimization for improving cache//! locality and reducing allocator traffic for workloads that fit within the inline buffer.//! ## `no_std` support//! By default, `smallvec` does not depend on `std`.  However, the optional//! `write` feature implements the `std::io::Write` trait for vectors of `u8`.//! When this feature is enabled, `smallvec` depends on `std`.//! ## Optional features//! ### `serde`//! When this optional dependency is enabled, `SmallVec` implements the `serde::Serialize` and//! `serde::Deserialize` traits.//! ### `write`//! When this feature is enabled, `SmallVec<[u8; _]>` implements the `std::io::Write` trait.//! This feature is not compatible with `#![no_std]` programs.//! ### `union`//! **This feature requires Rust 1.49.**//! When the `union` feature is enabled `smallvec` will track its state (inline or spilled)//! without the use of an enum tag, reducing the size of the `smallvec` by one machine word.//! This means that there is potentially no space overhead compared to `Vec`.//! Note that `smallvec` can still be larger than `Vec` if the inline buffer is larger than two//! machine words.//! To use this feature add `features = ["union"]` in the `smallvec` section of Cargo.toml.//! Note that this feature requires Rust 1.49.//! Tracking issue: [rust-lang/rust#55149](https://github.com/rust-lang/rust/issues/55149)//! ### `const_generics`//! **This feature requires Rust 1.51.**//! When this feature is enabled, `SmallVec` works with any arrays of any size, not just a fixed//! list of sizes.//! ### `const_new`//! This feature exposes the functions [`SmallVec::new_const`], [`SmallVec::from_const`], and [`smallvec_inline`] which enables the `SmallVec` to be initialized from a const context.//! For details, see the//! [Rust Reference](https://doc.rust-lang.org/reference/const_eval.html#const-functions).//! ### `drain_filter`//! **This feature is unstable.** It may change to match the unstable `drain_filter` method in libstd.//! Enables the `drain_filter` method, which produces an iterator that calls a user-provided//! closure to determine which elements of the vector to remove and yield from the iterator.//! ### `drain_keep_rest`//! **This feature is unstable.** It may change to match the unstable `drain_keep_rest` method in libstd.//! Enables the `DrainFilter::keep_rest` method.//! ### `specialization`//! **This feature is unstable and requires a nightly build of the Rust toolchain.**//! When this feature is enabled, `SmallVec::from(slice)` has improved performance for slices//! of `Copy` types.  (Without this feature, you can use `SmallVec::from_slice` to get optimal//! performance for `Copy` types.)//! Tracking issue: [rust-lang/rust#31844](https://github.com/rust-lang/rust/issues/31844)//! ### `may_dangle`//! This feature makes the Rust compiler less strict about use of vectors that contain borrowed//! references. For details, see the//! [Rustonomicon](https://doc.rust-lang.org/1.42.0/nomicon/dropck.html#an-escape-hatch).//! Tracking issue: [rust-lang/rust#34761](https://github.com/rust-lang/rust/issues/34761)SpecFromspec_from//! Implementations that require `default fn`.test_inlinetest_spilltest_double_spillissue_4// https://github.com/servo/rust-smallvec/issues/4issue_5// https://github.com/servo/rust-smallvec/issues/5drain_revdrain_forgetinto_iter_revinto_iter_droptest_capacitytest_insert_manyMockHintItertest_insert_many_short_hinttest_insert_many_long_hintPanicOnDoubleDropBadIter/// Claims to yield `hint` items, but actually yields `count`, then panics.panic_early_at_startpanic_early_in_middlepanic_early_at_endpanic_late_at_startpanic_late_at_endinsert_many_panic// https://github.com/servo/rust-smallvec/issues/96test_invalid_growdrain_overflowtest_insert_from_slicetest_extend_from_slicetest_drop_panic_smallvectest_as_reftest_as_muttest_exact_size_iteratortest_into_iter_as_slicetest_into_iter_clonetest_into_iter_clone_partially_consumed_iteratortest_into_iter_clone_empty_smallvecshrink_to_fit_unspilltest_into_vectest_from_vectest_deduptest_resizegrow_to_shrinkresumable_extend// #139grow_spilled_same_sizeconst_genericsconst_new_innerconst_new_inline_sizedconst_new_inline_argsconst_new_with_lenempty_macrozero_size_itemstest_insert_many_overflowmax_dont_panic/// This assortment of tests, in combination with miri, verifies we handle UB on fishy arguments/// given to SmallVec. Draining and extending the allocation are fairly well-tested earlier, but/// `smallvec.insert(usize::MAX, val)` once slipped by!/// All code that indexes into SmallVecs should be tested with such "trivially wrong" args.max_removemax_swap_removetest_insert_out_of_bounds// We heap allocate all these strings so that double frees will show up under valgrind.globalsBindErrorGlobalListxdgactivationxdg_activation_token_v1xdg_activation_v1GlobalErrorProvidesBoundGlobalapp_id/// App_id of the application requesting the token, if applicableseat_and_serial/// Seat and serial of the window requesting the token, if applicable./// *Warning*: Many compositors will issue invalid tokens for requests without/// recent serials. There is no way to detect this from the client-side./// Surface of the window requesting the token, if applicable./// *Warning*: Many compositors will issue invalid tokens for requests from/// unfocused surfaces. There is no way to detect this from the client-side.RequestData/// Minimal implementation of [`RequestDataExt`]./// Use a custom type implementing [`RequestDataExt`] to store more data with a token request/// e.g. to identify which request produced which token.RequestDataExt/// Data attached to a token request/// Data type used for requesting activation tokens/// A token was issued for a previous request with `data`.ActivationHandler/// Handler for xdg-activationxdg_activationXdgActivationV1ActivationState/// State for xdg-activation/// Bind the `xdg-activation` global/// Activate a surface with the provided token.XdgActivationTokenV1/// Request a token for surface activation./// To attach custom data to the request implement [`RequestDataExt`] on a custom type/// and use [`Self::request_token_with_data`] instead.request_token_with_data/// Request a token for surface activation with user data./// To use this method you need to provide [`delegate_activation`] with your custom type./// E.g. `delegate_activation!(SimpleWindow, MyRequestData);`bound_globaldelegate_activationwl_callbackwl_compositorwl_outputwl_regionWEnumOutputDataOutputHandlerOutputStateScaleWatcherHandlescale_factor_changed/// The surface has either been moved into or out of an output and the output has a different scale factor.transform_changed/// The surface has either been moved into or out of an output and the output has different transform./// A frame callback has been completed./// Frame callbacks are used to avoid updating surfaces that are not currently visible.  If a/// frame callback is requested prior to committing a surface, the client should avoid drawing/// to that surface until the callback completes.  See the/// [`WlSurface::frame`](wl_surface::WlSurface::frame) request for more details./// This function will be called if you request a frame callback by passing the surface itself/// as the userdata (`surface.frame(&queue, &surface)`); you can also implement [`Dispatch`]/// for other values to more easily dispatch rendering for specific surface types.surface_enterWlOutput/// The surface has entered an output.surface_leave/// The surface has left an output.CompositorHandlersurface_dataSurfaceDataExtWlCompositorAPI_VERSION_MAX/// The maximum API version for WlCompositor that this object will bind.// Note: if bumping this version number, check if the changes to the wayland XML cause an API// break in the rust interfaces.  If it does, be sure to remove other ProvidesBoundGlobal// impls; if it does not, consider adding one for the previous (compatible) version.create_surface_with_data/// The scale factor of the output with the highest scale factor.parent_surface/// Parent surface used when creating subsurfaces./// For top-level surfaces this is always `None`.SurfaceDataInner/// The inner mutable storage./// Data associated with a [`WlSurface`](wl_surface::WlSurface)./// Create a new surface that initially reports the given scale factor and parent./// The suggest transform for the surface./// The parent surface used for this surface./// The surface is `Some` for primarily for subsurfaces,/// since they must have a parent surface./// The outputs the surface is currently inside./// The transform of the given surface./// A handle to the OutputInfo callback that dispatches scale updates./// An owned [`WlSurface`](wl_surface::WlSurface)./// This destroys the surface on drop.delegate_compositordispatch_surface_state_updatesWlRegion/// A trivial wrapper around a [`WlRegion`][wl_region::WlRegion]./// This destroys the region on drop.RegionDataWlCallbackdata_device_managerdata_offerDataDeviceOfferwl_data_deviceWlDataDevicewl_data_offerWlDataOfferDataOfferDataDataOfferHandlerDragOfferSelectionOfferDataDeviceManagerState/// The data device pointer has entered a surface at the provided location/// The drag and drop pointer has left the surface and the session ends./// The offer will be destroyed unless it was previously dropped./// In the case of a dropped offer, the client must destroy it manually after it is finished./// Drag and Drop motion./// Advertises a new selection.drop_performed/// Drop performed./// After the next data offer action event, data may be able to be received, unless the action is "ask".// Introduces a new data offer// ASHLEY left out because the data offer will be introduced to the user once the type is known// either through the enter method or the selection method.// fn data_offer(//     &mut self,//     conn: &Connection,//     qh: &QueueHandle<Self>,//     data_device: DataDevice,//     offer: WlDataOffer,// );DataDeviceHandler/// Handler trait for DataDevice events./// The functions defined in this trait are called as DataDevice events are received from the compositor.DataDeviceDataDeviceDataunset_selection/// Unset the selection of the provided data device as a response to the event with with provided serial./// The seat associated with this device.DataDeviceInner/// Get the seat associated with this data device.drag_offer/// Get the active dnd offer if it exists.selection_offer/// Get the active selection offer if it exists./// the active dnd offer and its data/// the active selection offer and its dataundetermined_offers/// the active undetermined offers and their datawl_data_device_managerDndActionReadPipesource_actions/// Called to advertise the available DnD Actions as set by the source./// Called to advertise the action selected by the compositor after matching/// the source/destination side actions. Only one action or none will be/// selected in the actions sent by the compositor. This may be called/// multiple times during a DnD operation. The most recent DndAction is the/// only valid one./// At the time of a `drop` event on the data device, this action must be/// used except in the case of an ask action. In the case that the last/// action received is `ask`, the destination asks the user for their/// preference, then calls set_actions & accept each one last time. Finally,/// the destination may then request data to be sent and finishing the data/// offer/// Handler trait for DataOffer events./// The functions defined in this trait are called as DataOffer events are received from the compositor.DataOfferErrorInvalidReceive/// An error that may occur when working with data offers./// the wl_data offer if it exists/// the serial for this data offer's enter event/// the surface that this DnD is active on/// the x position on the surface/// the y position on this surface/// the timestamp a motion event was received in millisecond granularity/// the advertised drag actions/// the compositor selected drag action/// whether or not the drag has been dropped/// whether or not the drag has leftwith_mime_types/// Inspect the mime types available on the given offer.set_actions/// Set the accepted and preferred drag and drop actions./// This request determines the final result of the drag-and-drop operation./// If the end result is that no action is accepted, the drag source will receive wl_data_source.cancelled./// Receive data with the given mime type./// This request may happen multiple times for different mime types, both before and after wl_data_device.drop./// Drag-and-drop destination clients may preemptively fetch data or examine it more closely to determine acceptance.accept_mime_type/// Accept the given mime type, or None to reject the offer./// In version 2, this request is used for feedback, but doesn't affect the final result of the drag-and-drop operation./// In version 3, this request determines the final result of the drag-and-drop operation./// Destroy the data offer./// Retrieve a reference to the inner wl_data_offer./// the wl_data offerDataDeviceOfferInnerpush_mime_typeset_source_actionset_selected_actionto_selection_offerinit_undetermined_offerto_dnd_offeras_drag_offeras_selection_offerofferDragUndeterminedOfferUndetermined/// Request to receive the data of a given mime type./// You can do this several times, as a reaction to motion of/// the dnd cursor, or to inspect the data in order to choose your/// response./// Note that you should *not* read the contents right away in a/// blocking way, as you may deadlock your application doing so./// At least make sure you flush your events to the server before/// doing so./// Fails if too many file descriptors were already open and a pipe/// could not be created.receive_to_fd/// Receive data to the write end of a raw file descriptor. If you have the read end, you can read from it./// The provided file destructor must be a valid FD for writing, and will be closed/// once the contents are written.wl_data_sourceWlDataSourceWritePipeDataSourceDatadata_source_dataDataSourceDataExtaccept_mime/// This may be called multiple times, once for each accepted mime type from the destination, if any./// The client has requested the data for this source to be sent./// Send the data, then close the fd./// The data source is no longer valid/// Cleanup & destroy this resourcednd_dropped/// A drop was performed./// The data source will be used and should not be destroyed yetdnd_finished/// The drag and drop finished./// The data source may be destroyed./// An action was selected by the compositor.DataSourceHandler/// Handler trait for DataSource events./// The functions defined in this trait are called as DataSource events are received from the compositor.CopyPasteSource/// Set the selection of the provided data device as a response to the event with with provided serial.DragSourcestart_drag/// Start a normal drag and drop operation./// This can be used for both intra-client DnD or inter-client Dnd./// The drag is cancelled when the DragSource is dropped.start_internal_drag/// Start an internal drag and drop operation./// This will pass a NULL source, and the client is expected to handle data passing internally./// Only Enter, Leave, & Motion events will be sent to the client/// Set the actions that this drag source supports./// This can only be done once, and must be done before the drag is started./// Retrieve a reference to the inner wl_data_source.WlDataDeviceManagerdata_sourcemanagercreate_copy_paste_source/// creates a data source for copy pastecreate_drag_and_drop_source/// creates a data source for drag and dropcreate_data_source/// creates a data sourceget_data_device/// create a new data device for a given seatdelegate_data_device/// If the `calloop` cargo feature is enabled, this can be used/// as an `EventSource` in a calloop event loop.GlobalProxywl_bufferlinux_dmabufzv1zwp_linux_buffer_params_v1zwp_linux_dmabuf_feedback_v1TrancheFlagszwp_linux_dmabuf_v1/// `dev_t` value for preferred target device. May be scan-out or/// renderer device./// Flags for tranche/// Indices of formats in the format tableDmabufFeedbackTranche/// A preference tranche of dmabuf formats/// Fourcc format/// Modifier, or `DRM_FORMAT_MOD_INVALID` for implict modifierDmabufFormat/// A single dmabuf format/modifier pair// Must have correct representation to be able to mmap format tableformat_tablemain_devicetranchesDmabufFeedback/// Description of supported and preferred dmabuf formats/// Format/modifier pairs/// `dev_t` value for main device. Buffers must be importable from main device./// Tranches in descending order of preferencepending_trancheDmabufFeedbackDataDmaBufferDatazwp_linux_dmabufZwpLinuxDmabufV1DmabufState/// A handler for [`zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1`]/// Bind `zwp_linux_dmabuf_v1` global version 3 or 4, if it exists./// This does not fail if the global does not exist./// Only populated in version `<4`/// On version `4`, use [`DmabufState::get_surface_feedback`]./// Supported protocol version, if anycreate_paramsDmabufParamsZwpLinuxBufferParamsV1/// Create a params object for constructing a buffer/// Errors if `zwp_linux_dmabuf_v1` does not exist or has unsupported/// version. An application can then fallback to using `shm` buffers.get_default_feedbackZwpLinuxDmabufFeedbackV1/// Get default dmabuf feedback. Requires version `4`./// On version `3`, use [`DmabufState::modifiers`].get_surface_feedback/// Get default dmabuf feedback for given surface. Requires version `4`.dmabuf_statedmabuf_feedback/// Server has sent dmabuf feedback information. This may be received multiple/// times by a `ZwpLinuxDmabufFeedbackV1` object.WlBuffer/// `wl_buffer` associated with `params` has been created successfully./// Failed to create `wl_buffer` for `params`./// Compositor has released a `wl_buffer` created through [`DmabufParams`].DmabufHandler/// Builder for a dmabuf backed buffer/// Add a plane/// In version `4`, it is a protocol error if `format`/`modifier` pair wasn't/// advertised as supported./// `modifier` should be the same for all planes. It is a protocol error in version `5` if/// they differ./// Create buffer./// [`DmabufHandler::created`] or [`DmabufHandler::failed`] will be invoked when the/// operation succeeds or fails.create_immed/// Create buffer immediately./// On failure buffer is invalid, and server may raise protocol error or/// send [`DmabufHandler::failed`].delegate_dmabufMissingGlobal/// A compositor global was not availableInvalidVersion/// A compositor global was available, but did not support the given minimum version/// An error that may occur when creating objects using a global.with_min_versionAPI_COMPAT_VERSION/// A trait implemented by types that provide access to capability globals./// The returned global must be fully compatible with the provided `API_COMPAT_VERSION` generic/// argument.  For example:/// - A global that binds to `wl_compositor` with maximum version 4 could implement/// `ProvidesBoundGlobal<WlCompositor, 4>`, `ProvidesBoundGlobal<WlCompositor, 3>`,/// `ProvidesBoundGlobal<WlCompositor, 2>`, and `ProvidesBoundGlobal<WlCompositor, 1>` because/// versions 2-4 only add additional requests to the `wl_surface` API./// - A global that binds to `wl_compositor` with maximum version 5 may only implement/// `ProvidesBoundGlobal<WlCompositor, 5>` because version 5 makes using `wl_surface::attach` with/// a nonzero offset a protocol error.  A caller who is only aware of the version 4 API risks/// causing these protocol errors if it uses surfaces created by such a global./// Changes that cause compatibility breaks include:/// - Adding a new event to the global or to any object created by the global./// - Adding a new requirement to an existing request./// The resulting global may have a version lower than `API_COMPAT_VERSION` if, at runtime, the/// compositor does not support the new version.  Clients should either be prepared to handle/// earlier versions of the protocol or use [`ProvidesBoundGlobal::with_min_version`] to produce an/// error in this case./// It is permitted to implement `ProvidesBoundGlobal` for versions that are higher than the/// maximum version you bind.  When rustc gains the ability to constrain const parameters with/// integer bounds (`where API_COMPAT_VERSION >= 5`), implementations of this trait should be/// provided by specifying a lower bound for the compat version in order to avoid requiring version/// updates be done in lock-step./// A struct used as the UserData field for globals bound by SCTK./// This is used instead of `()` to allow multiple `Dispatch` impls on the same object.//    missing_docs, // Commented out for now so the project isn't all yellow.protocols_wlr/// Re-exports of some crates, for convenience.dmabufprimary_selectionsession_lockxdg_outputzxdg_output_manager_v1ZxdgOutputManagerV1zxdg_output_v1ProvidesRegistryStateRegistryHandleroutput_statenew_output/// A new output has been advertised.update_output/// An existing output has changed.output_destroyed/// An output is no longer advertised./// The info passed to this function was the state of the output before destruction./// Simplified event handler for [`wl_output::WlOutput`]./// See [`OutputState`].ScaleWatcherFnOutputInner/// A handler for delegating [`wl_output::WlOutput`](wayland_client::protocol::wl_output::WlOutput)./// When implementing [`ProvidesRegistryState`],/// [`registry_handlers!`](crate::registry_handlers) may be used to delegate all/// output events to an instance of this type. It will internally store the internal state of all/// outputs and allow querying them via the `OutputState::outputs` and `OutputState::info` methods./// use smithay_client_toolkit::output::{OutputHandler,OutputState};/// use smithay_client_toolkit::registry::{ProvidesRegistryState,RegistryHandler};/// # use smithay_client_toolkit::registry::RegistryState;/// use smithay_client_toolkit::{registry_handlers,delegate_output, delegate_registry};/// use wayland_client::{Connection,QueueHandle,protocol::wl_output};/// struct ExampleState {/// #    registry_state: RegistryState,///     // The state is usually kept as an attribute of the application state.///     output_state: OutputState,/// // When using `OutputState`, an implementation of `OutputHandler` should be supplied:/// impl OutputHandler for ExampleState {///      // Custom implementation handling output events here .../// #    fn output_state(&mut self) -> &mut OutputState {/// #        &mut self.output_state/// #    }/// #    fn new_output(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_output::WlOutput) {/// #    fn update_output(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_output::WlOutput) {/// #    fn output_destroyed(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_output::WlOutput) {/// // Delegating to the registry is required to use `OutputState`./// delegate_registry!(ExampleState);/// delegate_output!(ExampleState);/// impl ProvidesRegistryState for ExampleState {/// #    fn registry(&mut self) -> &mut RegistryState {/// #        &mut self.registry_state///     registry_handlers!(OutputState);ZxdgOutputV1/// Returns an iterator over all outputs./// Returns information about an output./// This may be none if the output has been destroyed or the compositor has not sent information about the/// output yet.add_scale_watchersetup/// Get the output scale factor./// Get the output transform.with_output_info/// Access the underlying [`OutputInfo`]./// Reentrant calls within the `callback` will deadlock./// Number of pixels of this mode in format `(width, height)`/// for example `(1920, 1080)`/// Refresh rate for this mode./// The refresh rate is specified in terms of millihertz (mHz). To convert approximately to Hertz,/// divide the value by 1000./// This value could be zero if an output has no correct refresh rate, such as a virtual output./// Whether this is the current mode for this output./// Per the Wayland protocol, non-current modes are deprecated and clients should not rely on deprecated/// modes./// Whether this is the preferred mode for this output./// The id of the output./// This corresponds to the global `name` of the wl_output./// The model name of this output as advertised by the server./// The make name of this output as advertised by the server./// Location of the top-left corner of this output in compositor space./// Note that the compositor may decide to always report (0,0) if it decides clients are not allowed to/// know this information.physical_size/// Physical dimensions of this output, in millimeters./// This value may be set to (0, 0) if a physical size does not make sense for the output (e.g. projectors/// and virtual outputs)./// The subpixel layout for this output./// The current transformation applied to this output/// You can pre-render your buffers taking this information into account and advertising it via/// `wl_buffer.set_transform` for better performance./// The scaling factor of this output/// Any buffer whose scaling factor does not match the one of the output it is displayed on will be/// rescaled accordingly./// For example, a buffer of scaling factor 1 will be doubled in size if the output scaling factor is 2./// `wl_surface.set_buffer_scale` so you may advertise a higher detail image./// Possible modes for an output.logical_position/// Logical position in global compositor spacelogical_size/// Logical size in global compositor space/// The name of the this output as advertised by the surface./// Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do not assume that the name is a/// reflection of an underlying DRM connector, X11 connection, etc./// Compositors are not required to provide a name for the output and the value may be [`None`]./// The name will be [`None`] if the compositor does not support version 4 of the wl-output protocol or/// version 2 of the zxdg-output-v1 protocol./// The description of this output as advertised by the server/// The description is a UTF-8 string with no convention defined for its contents. The description is not/// guaranteed to be unique among all wl_output globals. Examples might include 'Foocorp 11" Display' or/// 'Virtual X11 output via :1'./// Compositors are not required to provide a description of the output and the value may be [`None`]./// The value will be [`None`] if the compositor does not support version 4 of the wl-output/// protocol, version 2 of the zxdg-output-v1 protocol./// Information about an output.delegate_outputnew_globalremove_global/// The name of the wl_output global.just_created/// Whether this output was just created and has not an event yet.current_infopending_infopending_wlpending_xdgzwp_primary_selection_device_v1ZwpPrimarySelectionDeviceV1zwp_primary_selection_offer_v1ZwpPrimarySelectionOfferV1PrimarySelectionOfferPrimarySelectionOfferDataPrimarySelectionManagerState/// The new selection is received./// The given primary selection device could be used to identify [`PrimarySelectionDevice`].PrimarySelectionDeviceHandlerPrimarySelectionDevice/// Remove the currently active selection./// The passed `serial` is the serial of the input event.PrimarySelectionDeviceData/// Get the underlying data.PrimarySelectionDeviceDataInner/// The user data associated with the [`ZwpPrimarySelectionDeviceV1`]./// The seat used to create this primary selection device./// The active selection offer./// The offer is valid until either `NULL` or new selection is received via the/// `selection` event.pending_offer/// The offer we've got in `offer` event, but not finished it in `selection`.zwp_primary_selection_device_manager_v1ZwpPrimarySelectionDeviceManagerV1zwp_primary_selection_source_v1ZwpPrimarySelectionSourceV1PrimarySelectionSourceprimary_selection_manager/// The underlying wayland object.create_selection_source/// Create a primary selection source.get_selection_device/// Get the primary selection data device for the given seat.delegate_primary_selection/// Wrapper around the [`ZwpPrimarySelectionOfferV1`]./// You can call this function several times./// Request to receive the data of a given mime type, writen to `writefd`.mimes/// The data associated with the [`ZwpPrimarySelectionOfferV1`].PrimarySelectionSourceHandler/// Handler trait for `PrimarySelectionSource` events./// Wrapper around the [`ZwpPrimarySelectionSourceV1`]./// Set the selection on the given [`PrimarySelectionDevice`].GlobalListContents/// Called when a new global has been advertised by the compositor./// The provided registry handle may be used to bind the global.  This is not called during/// initial enumeration of globals. It is primarily useful for multi-instance globals such as/// `wl_output` and `wl_seat`./// Called when a global has been destroyed by the compositor./// A trait implemented by modular parts of a smithay's client toolkit and protocol delegates that may be used/// to receive notification of a global being created or destroyed./// Delegates that choose to implement this trait may be used in [`registry_handlers`] which/// automatically notifies delegates about the creation and destruction of globals./// [`registry_handlers`]: crate::registry_handlers/// Note that in order to delegate registry handling to a type which implements this trait, your `D` data type/// must implement [`ProvidesRegistryState`].RegistryState/// Returns a mutable reference to the registry state.runtime_add_global/// This is not called during initial global enumeration.runtime_remove_global/// Trait which asserts a data type may provide a mutable reference to the registry state./// Typically this trait will be required by delegates or [`RegistryHandler`] implementations which need/// to access the registry utilities provided by Smithay's client toolkit./// State object associated with the registry handling for smithay's client toolkit./// This object provides utilities to cache bound globals that are needed by multiple modules./// Creates a new registry handle./// This type may be used to bind globals as they are advertised./// Returns an iterator over all globals./// This list may change if the compositor adds or removes globals after initial/// No guarantees are provided about the ordering of the globals in this iterator.globals_by_interface/// Returns an iterator over all globals implementing the given interface./// This may be more efficient than searching [Self::globals].bind_one/// Binds a global, returning a new object associated with the global./// This should not be used to bind globals that have multiple instances such as `wl_output`;/// use [Self::bind_all] instead.bind_specific/// This binds a specific object by its name as provided by the [RegistryHandler::new_global]bind_all/// Binds all globals with a given interface.delegate_registry/// Delegates the handling of [`wl_registry`]./// Anything which implements [`RegistryHandler`] may be used in the delegate./// use smithay_client_toolkit::{///     delegate_registry, delegate_shm, registry_handlers,///     shm::{ShmHandler, Shm},/// struct ExampleApp {///     shm_state: Shm,/// // Here is the implementation of wl_shm to compile:/// delegate_shm!(ExampleApp);/// impl ShmHandler for ExampleApp {///     fn shm_state(&mut self) -> &mut Shm {///         &mut self.shm_stateNotPresent/// The requested global was not present after a complete enumeration./// The cached global./// A helper for storing a bound global./// This helper is intended to simplify the implementation of [RegistryHandler] for state objects/// that cache a bound global.MAX_VERSIONSimpleGlobaldelegate_simpleregistry_handlers/// A helper macro for implementing [`ProvidesRegistryState`]./// See [`delegate_registry`] for an example.//! Utilities for binding globals with [`wl_registry`] in delegates.//! This module is based around the [`RegistryHandler`] trait and [`RegistryState`].//! [`RegistryState`] provides an interface to bind globals regularly, creating an object with each new//! instantiation or caching bound globals to prevent duplicate object instances from being created. Binding//! a global regularly is accomplished through [`RegistryState::bind_one`].//! The [`delegate_registry`](crate::delegate_registry) macro is used to implement handling for [`wl_registry`].//! ## Sample implementation of [`RegistryHandler`]//! use smithay_client_toolkit::reexports::client::{//!     Connection, Dispatch, QueueHandle,//!     delegate_dispatch,//!     globals::GlobalList,//!     protocol::wl_output,//! use smithay_client_toolkit::registry::{//!     GlobalProxy, ProvidesRegistryState, RegistryHandler, RegistryState,//! struct ExampleApp {//!     /// The registry state is needed to use the global abstractions.//!     registry_state: RegistryState,//!     /// This is a type we want to delegate global handling to.//!     delegate_that_wants_registry: Delegate,//! /// The delegate a global should be provided to.//! struct Delegate {//!     outputs: Vec<wl_output::WlOutput>,//! // When implementing RegistryHandler, you must be able to dispatch any type you could bind using the registry state.//! impl<D> RegistryHandler<D> for Delegate//!     // In order to bind a global, you must statically assert the global may be handled with the data type.//!     D: Dispatch<wl_output::WlOutput, ()>//!         // ProvidesRegistryState provides a function to access the RegistryState within the impl.//!         + ProvidesRegistryState//!         // We need some way to access our part of the application's state.  This uses AsMut,//!         // but you may prefer to create your own trait to avoid making .as_mut() ambiguous.//!         + AsMut<Delegate>//!         + 'static,//!   /// New global added after initial enumeration.//!    fn new_global(//!        data: &mut D,//!        conn: &Connection,//!        qh: &QueueHandle<D>,//!        name: u32,//!        interface: &str,//!        version: u32,//!    ) {//!         if interface == "wl_output" {//!             // Bind `wl_output` with newest version from 1 to 4 the compositor supports//!             let output = data.registry().bind_specific(qh, name, 1..=4, ()).unwrap();//!             data.as_mut().outputs.push(output);//!         // You could either handle errors here or when attempting to use the interface.  Most//!         // Wayland protocols are optional, so if your application can function without a//!         // protocol it should try to do so; the From impl of GlobalProxy is written to make//!         // this straightforward.Keysymwl_keyboardRepeatDataRepeatedKeySeatErrorSeatHandlerSeatState/// Seat error.InvalidKeymap/// The specified keymap (RMLVO) is not valid./// Error when creating a keyboard.get_keyboardRMLVOWlKeyboardKeyboardDataKeyboardHandler/// Creates a keyboard from a seat./// This keyboard implementation uses libxkbcommon for the keymap./// Typically the compositor will provide a keymap, but you may specify your own keymap using the `rmlvo`/// This will return [`SeatError::UnsupportedCapability`] if the seat does not support a keyboard.get_keyboard_with_dataKeyboardDataExt/// Wrapper around a libxkbcommon keymap/// Get keymap as string in text format. The keymap should always be valid./// The keyboard has entered a surface./// When called, you may assume the specified surface has keyboard focus./// When a keyboard enters a surface, the `raw` and `keysym` fields indicate which keys are currently/// pressed./// The keyboard has left a surface./// When called, keyboard focus leaves the specified surface./// All currently held down keys are released when this event occurs.press_key/// A key has been pressed on the keyboard./// The key will repeat if there is no other press event afterwards or the key is released.release_key/// A key has been released./// This stops the key from being repeated if the key is the last key which was pressed./// Keyboard modifiers have been updated./// This happens when one of the modifier keys, such as "Shift", "Control" or "Alt" is pressed or/// released.update_repeat_infoRepeatInfo/// The keyboard has updated the rate and delay between repeating key inputs./// This function does nothing by default but is provided if a repeat mechanism outside of calloop is\update_keymap/// Keyboard keymap has been updated./// `keymap.as_string()` can be used get the keymap as a string. It cannot be exposed directly/// as an `xkbcommon::xkb::Keymap` due to the fact xkbcommon uses non-thread-safe reference/// counting. But can be used to create an independent `Keymap`./// This is called after the default handler for keymap changes and does nothing by default./// Handler trait for keyboard input./// The functions defined in this trait are called as keyboard events are received from the compositor./// The number of repetitions per second that should occur./// Delay (in milliseconds) between a key press and the start of repetition./// Keys will be repeated at the specified rate and delay./// Keys should not be repeated./// The rate at which a pressed key is repeated./// Time at which the keypress occurred./// The raw value of the key./// The interpreted symbol of the key./// This corresponds to one of the assoiated values on the [`Keysym`] type./// UTF-8 interpretation of the entered text./// This will always be [`None`] on release events./// Data associated with a key press or release event./// The "control" key/// The "alt" key/// The "shift" key/// The "Caps lock" key/// The "logo" key/// Also known as the "windows" or "super" key on a keyboard.num_lock/// The "Num lock" key/// The state of keyboard modifiers/// Each field of this indicates whether a specified modifier is active./// Depending on the modifier, the modifier key may currently be pressed or toggled./// The rules file to use/// The keyboard model by which to interpret keycodes and LEDs/// A comma separated list of layouts (languages) to include in the keymap/// A comma separated list of variants, one per layout, which may modify or/// augment the respective layout in various ways/// A comma separated list of options, through which the user specifies/// non-layout related preferences, like which key combinations are/// used for switching layouts, or which key is the Compose key./// The RMLVO description of a keymap/// All fields are optional, and the system default/// will be used if set to `None`.xkb_contextuser_specified_rmlvo/// If the user manually specified the RMLVO to use.xkb_statexkb_composerepeat_datadelegate_keyboard// SAFETY: The state does not share state with any other rust types.// SAFETY: The state is guarded by a mutex since libxkbcommon has no internal synchronization.from_rmlvoinit_composekeyboard_datakeyboard_data_mut/// The type of the user defined state/// Whether this is the first event of the repeat sequence.RepeatCallbackcurrent_repeatrepeat_infoloop_handlerepeat_tokenget_keyboard_with_repeat/// This function returns an [`EventSource`] that indicates when a key press is going to repeat./// [`EventSource`]: calloop::EventSourceget_keyboard_with_repeat_with_datawl_pointerwl_touchcursor_shapewp_cursor_shape_device_v1WpCursorShapeDeviceV1wp_cursor_shape_manager_v1WpCursorShapeManagerV1pointer_constraintsrelative_pointerCursorShapeManagerPointerDataPointerDataExtPointerHandlerThemeSpecThemedPointerThemesTouchDataTouchDataExtTouchHandlerUnsupportedCapability/// The capability is not supported.DeadObject/// The seat is dead.seatsSeatInner// (name, seat)cursor_shape_manager_stateCursorShapeManagerStateSeatData/// Returns an iterator over all the seats.SeatInfo/// Returns information about a seat./// This will return [`None`] if the seat is dead.get_pointerWlPointer/// Creates a pointer from a seat./// This will return [`SeatError::UnsupportedCapability`] if the seat does not support a pointer.get_pointer_with_themeWlShm/// Creates a pointer from a seat with the provided theme./// This will use [`CursorShapeManager`] under the hood when it's available.get_pointer_with_dataget_pointer_with_theme_and_data/// Creates a pointer from a seat with the provided theme and data.get_touchWlTouch/// Creates a touch handle from a seat./// This will return [`SeatError::UnsupportedCapability`] if the seat does not support touch.get_touch_with_dataseat_statenew_seat/// A new seat has been created./// This function only indicates that a seat has been created, you will need to wait for [`new_capability`](SeatHandler::new_capability)/// to be called before creating any keyboards,new_capability/// A new capability is available on the seat./// This allows you to create the corresponding object related to the capability.remove_capability/// A capability has been removed from the seat./// If an object has been created from the capability, it should be destroyed.remove_seat/// A seat has been removed./// The seat is destroyed and all capability objects created from it are invalid./// The name of the seat.has_keyboard/// Does the seat support a keyboard.has_pointer/// Does the seat support a pointer.has_touch/// Does the seat support touch input./// Description of a seat.delegate_seatcursor_shape_managerfrom_existingget_shape_devicecursor_icon_to_shapeCursorThemeCursorIconParseError/* From linux/input-event-codes.h - the buttons usually used by mice *//// The fourth non-scroll button, which is often used as "back" in web browsers./// The fifth non-scroll button, which is often used as "forward" in web browsers./// See also [`BTN_EXTRA`]./// See also [`BTN_SIDE`]./// The scroll measured in pixels.discrete/// The scroll measured in steps./// Note: this might always be zero if the scrolling is due to a touchpad or other continuous/// The scroll was stopped./// Generally this is encountered when hardware indicates the end of some continuous scrolling.AxisScroll/// Describes a scroll along one axis/// Returns true if there was no movement along this axis.PointerEventKindPointerEvent/// A single pointer event.PressAxisSourceAxispointer_frame/// One or more pointer events are available./// Multiple related events may be grouped together in a single frame.  Some examples:/// - A drag that terminates outside the surface may send the Release and Leave events as one frame/// - Movement from one surface to another may send the Enter and Leave events in one framePointerDataInner/// The seat associated with this pointer.latest_enter_serial/// Serial from the latest [`PointerEventKind::Enter`] event.latest_button_serial/// Serial from the latest button [`PointerEventKind::Press`] and/// [`PointerEventKind::Release`] events.pointer_datadelegate_pointer/// Surface the pointer most recently entered/// Position relative to the surface/// List of pending events.  Only used for version >= 5.latest_enter/// The serial of the latest enter event for the pointerlatest_btn/// The serial of the latest button event for the pointerthemes/// The underlying wl_pointer./// The surface owned by the cursor to present the icon.shape_device_surface_data/// Pointer themeingPointerThemeError/// Set the cursor to the given [`CursorIcon`]./// The cursor icon should be reloaded on every [`PointerEventKind::Enter`] event.set_cursor_legacy/// The legacy method of loading the cursor from the system cursor/// theme instead of relying on compositor to set the cursor.hide_cursor/// Hide the cursor by providing empty surface for it./// The cursor should be hidden on every [`PointerEventKind::Enter`] event./// The [`WlPointer`] associated with this [`ThemedPointer`]./// The associated [`WlSurface`] with this [`ThemedPointer`]./// Name of the cursor theme./// Base size of the cursor names./// Note this size assumes a scale factor of 1. Cursor image sizes may be multiplied by the base size/// for HiDPI outputs./// Use this specific theme with the given base size./// Use the system provided theme/// In this case SCTK will read the `XCURSOR_THEME` and/// `XCURSOR_SIZE` environment variables to figure out the/// theme to use./// Specifies which cursor theme should be used by the theme manager./// An invalid ObjectId was used./// A global error occurred.CursorNotFound/// The requested cursor was not found.MissingEnterSerial/// There has been no enter event yet for the pointer./// An error indicating that the cursor was not found.// Scale -> CursorThemezwp_confined_pointer_v1zwp_locked_pointer_v1zwp_pointer_constraints_v1ZwpPointerConstraintsV1PointerConstraintsState/// Bind `zwp_pointer_constraints_v1` global, if it existsconfine_pointerZwpConfinedPointerV1PointerConstraintData/// Request that the compositor confine the pointer to a region/// It is a protocol error to call when a constraint already exists for a pointer on the seat.lock_pointerZwpLockedPointerV1/// Request that the compositor lock the pointer in placeconfined/// Pointer confinement activated by compositorunconfined/// Pointer confinement deactivated by compositor/// For `Oneshot` constraints, it will not be reactivated./// Pointer lock activated by compositor/// Pointer lock deactivated by compositorPointerConstraintsHandlerdelegate_pointer_constraintszwp_relative_pointer_manager_v1zwp_relative_pointer_v1relative_pointer_managerZwpRelativePointerManagerV1RelativePointerState/// Bind `zwp_relative_pointer_manager_v1` global, if it existsget_relative_pointerZwpRelativePointerV1RelativePointerData/// (x, y) motion vectordelta_unaccel/// Unaccelerated (x, y) motion vector/// Timestamp in microsecondsRelativeMotionEventrelative_pointer_motionRelativePointerHandlerdelegate_relative_pointerTouchEventTouchDataInner/// Create the new touch data associated with the given seat./// Get the associated seat from the data.latest_down_serial/// Serial from the latest touch down event.active_touch_pointslatest_down/// The serial of the latest touch down eventdelegate_touchtouch_data/// New touch point./// Indicates a new touch point has appeared on the surface, starting a touch sequence. The ID/// associated with this event identifies this touch point for devices with multi-touch and/// will be referenced in future events./// The associated touch ID ceases to be valid after the touch up event with the associated ID/// and may be reused for other touch points after that./// Coordinates are surface-local./// End of touch sequence./// Touch point motion./// Touch point shape change./// The shape of a touch point is approximated by an ellipse through the major and minor axis/// length. Major always represents the larger of the two axis and is orthogonal to minor./// The dimensions are specified in surface-local coordinates and the locations reported by/// other events always report the center of the ellipse./// Touch point shape orientation./// The orientation describes the clockwise angle of a touch point's major axis to the positive/// surface y-axis and is normalized to the -180° to +180° range./// Cancel active touch sequence./// This indicates that the compositor has cancelled the active touch sequence, for example due/// to detection of a touch gesture.process_framed_event/// Process a single frame-buffered touch event.ext_session_lock_manager_v1ext_session_lock_surface_v1ext_session_lock_v1SessionLockSessionLockDataSessionLockHandlerSessionLockStateSessionLockSurfaceSessionLockSurfaceConfigureSessionLockSurfaceDataExtSessionLockManagerV1ExtSessionLockV1ExtSessionLockSurfaceV1/// The session lock is active, and the client may create lock surfaces./// Session lock is not active and should be destroyed./// This may be sent immediately if the compositor denys the requires to create a lock,/// or may be sent some time after `lock`./// Compositor has requested size for surface./// Handler trait for session lock protocol.session_lock_surfaceSessionLockSurfaceInnerfrom_ext_session_lock_surfaceSessionLockInner/// A session lock/// Once a lock is created, you must wait for either a `locked` or `finished` event before/// destroying this object.  If you get a `locked` event, you must explicitly call `unlock` prior/// to dropping this object.from_ext_session_lockcreate_lock_surfacesession_lock_manager/// A handler for [`ext_session_lock_manager_v1::ExtSessionLockManagerV1`]delegate_session_lockwlr_layer/// An unsupported operation, often due to the version of the protocol./// The underlying [`WlSurface`](wl_surface::WlSurface).set_input_regionset_buffer_transformset_buffer_scale/// Commits pending surface state./// On commit, the pending double buffered state from the surface, including role dependent state is/// # Initial commit/// In many protocol extensions, the concept of an initial commit is used. A initial commit provides the/// initial state of a surface to the compositor. For example with the [xdg shell](xdg),/// creating a window requires an initial commit./// # Protocol Errors/// If the commit is the initial commit, no buffers must have been attached to the surface. This rule/// applies whether attaching the buffer was done using [`WaylandSurface::attach`] or under the hood in/// via window system integration in graphics APIs such as Vulkan (using `vkQueuePresentKHR`) and EGL/// (using `eglSwapBuffers`).// TODO: Damage (Buffer and Surface-local)// TODO: Frame (a nice helper for this could exist)./// Functionality shared by all [`wl_surface::WlSurface`] backed shell role objects.//! # Shell abstractions//! A shell describes a set of wayland protocol extensions which define the capabilities of a surface and how//! the surface is displayed.//! ## Cross desktop group (XDG) shell//! The XDG shell describes the semantics of desktop application windows.//! The XDG shell defines two types of surfaces://! - [`Window`] - An application window[^window].//! - [`Popup`] - A child surface positioned relative to a window.//! ### Why use the XDG shell//! The XDG shell is the primary protocol through which application windows are created. You can be near//! certain every desktop compositor will implement this shell so that applications may create windows.//! See the [XDG shell module documentation] for more information about creating application windows.//! ## Layer shell//! The layer shell is a protocol which allows the creation of "layers". A layer refers to a surface rendered//! at some specific z-depth relative to other layers. A layer may also be anchored to some edge and corner of//! the screen.//! The layer shell defines one type of surface: the [`wlr_layer::LayerSurface`].//! There is no guarantee that the layer shell will be available in every compositor.//! ### Why use the layer shell//! The layer shell may be used to implement many desktop shell components, such as backgrounds, docks and//! launchers.//! [^window]: The XDG shell protocol actually refers to a window as a toplevel surface, but we use the more//! familiar term "window" for the sake of clarity.//! [XDG shell module documentation]: self::xdg//! [`Window`]: self::xdg::window::Window//! [`Popup`]: self::xdg::popup::Popup//! [`Layer`]: self::layer::LayerSurfacelayer_shellzwlr_layer_shell_v1zwlr_layer_surface_v1LayerShellLayerShellHandlerLayerSurfaceLayerSurfaceConfigureLayerSurfaceDataZwlrLayerShellV1// Layer shell has only added requests and enum variants in versions 2-4, so its client-facing API// is still compatible.ZwlrLayerSurfaceV1xdg_popupXdgPopupwlr_layer_shell/// Binds the wlr layer shell global, `zwlr_layer_shell_v1`./// This function will return [`Err`] if the `zwlr_layer_shell_v1` global is not available.create_layer_surface/// The layer surface has been closed./// When this requested is called, the layer surface is no longer shown and all handles of the [`LayerSurface`]/// should be dropped./// Apply a suggested surface change./// When this function is called, the compositor is requesting the layer surfaces's size or state to change./// Handler for operations on a [`LayerSurface`]LayerSurfaceInnerfrom_wlr_surfaceget_popupAnchorset_exclusive_zoneset_keyboard_interactivityKeyboardInteractivityset_layerSurfaceKind// Double buffered stateWlr/// No keyboard focus is possible./// This is the default value for all newly created layer shells./// Request exclusive keyboard focus if the layer is above shell surfaces./// For [`Layer::Top`] and [`Layer::Overlay`], the seat will always give exclusive access to the layer/// which has this interactivity mode set./// This setting is intended for applications that need to ensure they receive all keyboard events, such/// as a lock screen or a password prompt./// The compositor should focus and unfocus this surface by the user in an implementation specific manner./// Compositors may use their normal mechanisms to manage keyboard focus between layers and regular/// desktop surfaces./// This setting is intended for applications which allow keyboard interaction.  /// The z-depth of a layer./// These values indicate which order in which layer surfaces are rendered.UnknownLayer/// Error when converting a [`zwlr_layer_shell_v1::Layer`] to a [`Layer`]r" Specifies which edges and corners a layer should be placed at in the anchor rectangle."r" A combination of two orthogonal edges will cause the layer's anchor point to be the intersection of"r" the edges. For example [`Anchor::TOP`] and [`Anchor::LEFT`] will result in an anchor point in the top"r" left of the anchor rectangle."r" Top edge of the anchor rectangle."r" The bottom edge of the anchor rectangle."r" The left edge of the anchor rectangle."r" The right edge of the anchor rectangle."/// The compositor suggested new size of the layer in surface-local coordinates./// The size is a hint, meaning the new size can be ignored. A smaller size could be picked to satisfy/// some aspect ratio or resize in steps. If the size is smaller than suggested and the layer surface is/// anchored to two opposite anchors then the layer surface will be centered on that axis./// If the width is zero, you may choose any width you want. If the height is zero, you may choose any/// height you want./// A layer surface configure./// A configure describes a compositor request to resize the layer surface or change it's state.layer_surfacedelegate_layer/// The size of the header bar./// The size of the border.TOP_BORDERRIGHT_BORDERBOTTOM_BORDERLEFT_BORDERBTN_ICON_COLORBTN_HOVER_BGPRIMARY_COLOR_ACTIVEPRIMARY_COLOR_INACTIVE/// The parent surface./// The latest window state./// The wm capabilities./// Whether the frame is resizable./// Whether the frame is waiting for redraw.mouse_location/// The location of the mouse.mouse_coordsrender_dataFrameRenderData/// The frame rendering data. When `None` the frame is hidden./// Whether the frame should sync with the parent./// This should happen in reaction to scale or resize changes./// The active scale factor of the frame./// The frame queue handle./// The memory pool to use for drawing./// The subcompositor.UIButton/// Buttons state.FallbackFrame/// The default ugly frame.supported_buttonspart_index_for_surfacedraw_buttonsdraw_buttondraw_iconFramePart/// The header subsurface./// Inner state to simplify dropping./// The surface used for the frame part./// The surface used for this part./// The width of the Frame part in logical pixels./// The height of the Frame part in logical pixels./// The position for the subsurface./// The location doesn't belong to the frame./// Header bar./// Top border./// Top right corner./// Right border./// Bottom right corner./// Bottom border./// Bottom left corner./// Left border./// Top left corner./// One of the buttons./// The location inside the/// The minimize button, the left most./// The maximize button, in the middle./// The close botton, the right most./// The frame button.//! The default fallback frame which is intended to show some very basic derocations.decorationzxdg_toplevel_decoration_v1zxdg_decoration_manager_v1xdg_positionerxdg_surfacexdg_toplevelxdg_wm_baseWindowInnerDecorationModeWindowConfigureWindowDataWindowDecorationsfallback_frameXdgWmBasexdg_decoration_managerZxdgDecorationManagerV1XdgShell/// The xdg shell globals./// The maximum API version for XdgWmBase that this object will bind./// Binds the xdg shell global, `xdg_wm_base`./// If available, the `zxdg_decoration_manager_v1` global will be bound to allow server side decorations/// for windows./// This function will return [`Err`] if the `xdg_wm_base` global is not available."Dropping all window handles will destroy the window"XdgSurfaceXdgToplevelZxdgToplevelDecorationV1/// Creates a new, unmapped window./// # Protocol errors/// If the surface already has a role object, the compositor will raise a protocol error./// A surface is considered to have a role object if some other type of surface was created using the/// surface. For example, creating a window, popup, layer or subsurface all assign a role object to a/// surface./// This function takes ownership of the surface./// For more info related to creating windows, see [`the module documentation`](self).XdgPositioner/// A trivial wrapper for an [`xdg_positioner::XdgPositioner`]./// This wrapper calls [`destroy`][xdg_positioner::XdgPositioner::destroy] on the contained/// positioner when it is dropped.PositionerDataXdgShellSurface/// A surface role for functionality common in desktop-like surfaces./// Creates an [`XdgShellSurface`]./// This function is generally intended to be called in a higher level abstraction, such as/// [`XdgShell::create_window`]./// The created [`XdgShellSurface`] will destroy the underlying [`XdgSurface`] or [`WlSurface`] when/// dropped. Higher level abstractions are responsible for ensuring the destruction order of protocol/// objects is correct. Since this function consumes the [`WlSurface`], it may be accessed using/// [`XdgShellSurface::wl_surface`]./// surface. For example, creating a window, popup, layer, subsurface or some other type of surface object/// all assign a role object to a surface./// [`XdgSurface`]: xdg_surface::XdgSurface/// [`WlSurface`]: wl_surface::WlSurface/// The underlying [`XdgSurface`](xdg_surface::XdgSurface).set_window_geometrydelegate_xdg_shell// Version 5 adds the wm_capabilities event, which is a break// TODO: ExamplesPopupInnerPopupDatapending_positionpending_dimensionspending_tokenconfigure_statePopupHandler/// Create a new popup./// This creates the popup and sends the initial commit.  You must wait for/// [`PopupHandler::configure`] to commit contents to the surface./// Create a new popup from an existing surface./// If you do not specify a parent surface, you must configure the parent using an alternate/// function such as [`LayerSurface::get_popup`] prior to committing the surface, or you will/// get an `invalid_popup_parent` protocol error./// [`LayerSurface::get_popup`]: wayland_protocols_wlr::layer_shell::v1::client::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1::get_popupxdg_shell_surface/// Get a new handle to the Popup/// This returns `None` if the popup has been destroyed./// (x,y) relative to parent surface window geometryConfigureKindPopupConfigure/// Initial configure for this popupReactive/// The configure is due to an xdg_positioner with set_reactive requestedReposition/// The configure is due to a reposition request with this tokenSTATE_NEWSTATE_CONFIGUREDSTATE_REPOSITION_ACK/// The popup has been configured./// The popup was dismissed by the compositor and should be destroyed.delegate_xdg_popupWmCapabilitiestoplevel_decorationpending_configure// XDG decorationrequest_close/// Request to close a window./// This request does not destroy the window. You must drop all [`Window`] handles to destroy the window./// This request may be sent either by the compositor or by some other mechanism (such as client side decorations)./// When this function is called, the compositor is requesting the window's size or state to change./// Internally this function is called when the underlying `xdg_surface` is configured. Any extension/// protocols that interface with xdg-shell are able to be notified that the surface's configure sequence/// is complete by using this function./// # Double buffering/// Configure events in Wayland are considered to be double buffered and the state of the window does not/// change until committed./// Handler for toplevel operations on a [`Window`]./// The window should draw client side decorations./// The server will draw window decorations./// Decoration mode of a window./// The compositor suggested new size of the window in window geometry coordinates./// If this value is [`None`], you may set the size of the window as you wish.suggested_bounds/// Compositor suggested maximum bounds for a window./// This may be used to ensure a window is not created in a way where it will not fit./// If xdg-shell is version 3 or lower, this will always be [`None`].decoration_mode/// The compositor set decoration mode of the window./// This will always be [`DecorationMode::Client`] if server side decorations are not enabled or/// The current state of the window./// For more see [`WindowState`] documentation on the flag values./// The capabilities supported by the compositor./// For more see [`WindowManagerCapabilities`] documentation on the flag values./// A window configure./// A configure describes a compositor request to resize the window or change it's state./// Is [`WindowState::MAXIMIZED`] state is set.is_fullscreen/// Is [`WindowState::FULLSCREEN`] state is set.is_resizing/// Is [`WindowState::RESIZING`] state is set./// Is [`WindowState::TILED`] state is set.is_activated/// Is [`WindowState::ACTIVATED`] state is set.is_tiled_left/// Is [`WindowState::TILED_LEFT`] state is set.is_tiled_right/// Is [`WindowState::TILED_RIGHT`] state is set.is_tiled_top/// Is [`WindowState::TILED_TOP`] state is set.is_tiled_bottom/// Is [`WindowState::TILED_BOTTOM`] state is set.ServerDefault/// The window should use the decoration mode the server asks for./// The server may ask the client to render with or without client side decorations. If server side/// decorations are not available, client side decorations are drawn instead.RequestServer/// The window should request server side decorations./// The server may ignore this request and ask the client to render with client side decorations. If/// server side decorations are not available, client side decorations are drawn instead.RequestClient/// The window should request client side decorations./// The server may ignore this request and render server side decorations. If server side decorations are/// not available, client side decorations are drawn.ClientOnly/// The window should always draw it's own client side decorations./// The window should use server side decorations or draw any client side decorations./// Decorations a window is created with.from_xdg_toplevelfrom_xdg_surfacefrom_toplevel_decorationset_app_idunset_maximizedunset_fullscreenrequest_decoration_mode/// Requests the window should use the specified decoration mode./// A mode of [`None`] indicates that the window does not care what type of decorations are used./// The compositor will respond with a [`configure`](WindowHandler::configure). The configure will/// indicate whether the window's decoration mode has changed./// # Configure loops/// You should avoid sending multiple decoration mode requests to ensure you do not enter a configure loop.set_min_sizeset_max_size/// The maximum size of the window may not be smaller than the minimum size./// Returns the underlying xdg toplevel wrapped by this window.// Double buffered window state// Otherdelegate_xdg_window//! XDG shell windows.shm_stateShmHandler/// Returns the formats supported in memory pools.CreatePoolError/// The wl_shm global is not bound./// Error while allocating the shared memory./// An error that may occur when creating a pool.delegate_shm/// Delegates the handling of [`wl_shm`] to some [`Shm`]./// This macro requires two things, the type that will delegate to [`Shm`] and a closure specifying how/// to obtain the state object./// use smithay_client_toolkit::shm::{ShmHandler, Shm};/// use smithay_client_toolkit::delegate_shm;///     /// The state object that will be our delegate.///     shm: Shm,/// // Use the macro to delegate wl_shm to Shm./// // You must implement the ShmHandler trait to provide a way to access the Shm from your data type.///         &mut self.shmRawPoolPoolErrorInUseOverlapBufferSlotMultiPool/// This pool manages buffers associated with keys./// Only one buffer can be attributed to a given key./// Resizes the memory pool, notifying the server the pool has changed in size./// The wl_shm protocol only allows the pool to be made bigger. If the new size is smaller than the/// current size of the pool, this function will do nothing./// Removes the buffer with the given key from the pool and rearranges the others./// Insert a buffer into the pool./// The parameters are:/// - `width`: the width of this buffer (in pixels)/// - `height`: the height of this buffer (in pixels)/// - `stride`: distance (in bytes) between the beginning of a row and the next one/// - `key`: a borrowed form of the stored key type/// - `format`: the encoding format of the pixels./// Retreives the buffer associated with the given key./// Returns the buffer associated with the given key and its offset (usize) in the mempool./// The offset can be used to determine whether or not a buffer was moved in the mempool/// and by consequence if it should be damaged partially or fully.get_at/// Retreives the buffer at the given index./// Calcule the offet and size of a buffer based on its stride.dyn_resize/// Resizes the pool and appends a new buffer.BufferObjectData//! A pool implementation which automatically manage buffers.//! This pool is built on the [`RawPool`].//! The [`MultiPool`] takes a key which is used to identify buffers and tries to return the buffer associated to the key//! if possible. If no buffer in the pool is associated to the key, it will create a new one.//!     QueueHandle,//!     protocol::wl_surface::WlSurface,//!     protocol::wl_shm::Format,//! use smithay_client_toolkit::shm::multi::MultiPool;//! struct WlFoo {//!     // The surface we'll draw on and the index of buffer associated to it//!     surface: (WlSurface, usize),//!     pool: MultiPool<(WlSurface, usize)>//! impl WlFoo {//!     fn draw(&mut self, qh: &QueueHandle<WlFoo>) {//!         let surface = &self.surface.0;//!         // We'll increment "i" until the pool can create a new buffer//!         // if there's no buffer associated with our surface and "i" or if//!         // a buffer with the obuffer associated with our surface and "i" is free for use.//!         // There's no limit to the amount of buffers we can allocate to our surface but since//!         // shm buffers are released fairly fast, it's unlikely we'll need more than double buffering.//!         for i in 0..2 {//!             self.surface.1 = i;//!             if let Ok((offset, buffer, slice)) = self.pool.create_buffer(//!                 100,//!                 100 * 4,//!                 &self.surface,//!                 Format::Argb8888,//!             ) {//!                 /*//!                     insert drawing code here//!                 *///!                 surface.attach(Some(buffer), 0, 0);//!                 surface.commit();//!                 // We exit the function after the draw.//!         /*//!             If there's no buffer available we can for example request a frame callback//!             and trigger a redraw when it fires.//!             (not shown in this example)//!         *///! fn draw(slice: &mut [u8]) {//!     todo!()wl_shm_poolWlShmPoolmem_file/// A raw handler for file backed shared memory pools./// This type of pool will create the SHM memory pool and provide a way to resize the pool./// This pool does not release buffers. If you need this, use one of the higher level pools./// Returns a reference to the underlying shared memory file using the memmap2 crate./// Returns the size of the mempool/// Create a new buffer to this pool./// - `offset`: the offset (in bytes) from the beginning of the pool at which this buffer starts./// - `width` and `height`: the width and height of the buffer in pixels./// - `stride`: distance (in bytes) between the beginning of a row and the next one./// The encoding format of the pixels must be supported by the compositor or else a protocol error is/// risen. You can ensure the format is supported by listening to [`Shm::formats`](crate::shm::Shm::formats)./// Note this function only creates the wl_buffer object, you will need to write to the pixels using the/// [`io::Write`] implementation or [`RawPool::mmap`].create_buffer_raw/// This is identical to [Self::create_buffer], but allows using a custom [ObjectData]/// implementation instead of relying on the [Dispatch] interface./// Returns the pool object used to communicate with the server.create_shm_fdcreate_memfdShmPoolData//! A raw shared memory pool handler.//! This is intended as a safe building block for higher level shared memory pool abstractions and is not//! encouraged for most library users.CreateBufferError/// Slot creation error.PoolMismatch/// Pool mismatch.SlotTooSmall/// Slot size mismatchActivateSlotErrorAlreadyActive/// Buffer was already activeFreelistEntrySlotInner/// A chunk of memory allocated from a [SlotPool]/// Retaining this object is only required if you wish to resize or change the buffer's format/// without changing the contents of the backing memory.active_buffersall_refs/// Count of all "real" references to this slot.  This includes all Slot objects and any/// BufferData object that is not in the DEAD state.  When this reaches zero, the memory for/// this slot will return to the free_list.  It is not possible for it to reach zero and have a/// Slot or Buffer referring to it./// A wrapper around a [`wl_buffer::WlBuffer`] which has been allocated via a [SlotPool]./// When this object is dropped, the buffer will be destroyed immediately if it is not active, or/// upon the server's release if it is.BufferData/// ObjectData for the WlBuffer/// Buffer is counted in active_buffers list; will return to INACTIVE on Release.INACTIVE/// Buffer is not counted in active_buffers list, but also has not been destroyed.DESTROY_ON_RELEASE/// Buffer is counted in active_buffers list; will move to DEAD on Release/// Buffer has been destroyedRELEASE_SET/// Value that is ORed on buffer release to transition to the next stateDESTROY_SET/// Value that is ORed on buffer destroy to transition to the next staterecord_death/// Call after successfully transitioning the state to DEAD// These constants define the value of BufferData::state, since AtomicEnum does not exist./// Create a new buffer in a new slot./// This returns the buffer and the canvas.  The parameters are:/// - `format`: the encoding format of the pixels. Using a format that was not///   advertised to the `wl_shm` global by the server is a protocol error and will///   terminate your connection./// The [Slot] for this buffer will have exactly the size required for the data.  It can be/// accessed via [Buffer::slot] to create additional buffers that point to the same data.  This/// is required if you wish to change formats, buffer dimensions, or attach a canvas to/// multiple surfaces./// For more control over sizing, use [Self::new_slot] and [Self::create_buffer_in].canvasCanvasKey/// Get the bytes corresponding to a given slot or buffer if drawing to the slot is permitted./// Returns `None` if there are active buffers in the slot or if the slot does not correspond/// to this pool./// Returns the size, in bytes, of this pool./// This is an optimization; the pool automatically resizes when you allocate new slots.new_slot/// Create a new slot with the given size in bytes.raw_data_mut/// Get the bytes corresponding to a given slot./// Note: prefer using [Self::canvas], which will prevent drawing to a buffer that has not been/// released by the server./// Returns an empty buffer if the slot does not belong to this pool.create_buffer_in/// Create a new buffer corresponding to a slot.///   terminate your connection'pool/// A helper trait for [SlotPool::canvas].has_active_buffers/// Return true if there are buffers referencing this slot whose contents are being accessed/// by the server./// Returns the size, in bytes, of this slot./// Get the bytes corresponding to a given slot if drawing to the slot is permitted.attach_to/// Attach a buffer to a surface./// This marks the slot as active until the server releases the buffer, which will happen/// automatically assuming the surface is committed without attaching a different buffer./// Note: if you need to ensure that [`canvas()`](Buffer::canvas) calls never return data that/// could be attached to a surface in a multi-threaded client, make this call while you have/// exclusive access to the corresponding [`SlotPool`]./// Get the inner buffer./// Get the bytes corresponding to this buffer if drawing is permitted./// This may be smaller than the canvas associated with the slot./// Get the slot corresponding to this buffer./// Manually mark a buffer as active./// An active buffer prevents drawing on its slot until a Release event is received or until/// manually deactivated./// Manually mark a buffer as inactive./// This should be used when the buffer was manually marked as active or when a buffer was/// attached to a surface but not committed.  Calling this function on a buffer that was/// committed to a surface risks making the surface contents undefined.//! A pool implementation based on buffer slotswl_subcompositorWlSubcompositorcreate_subsurfacesubsurface_from_surface/// The surface used when creating this subsurface./// The data assoctiated with the subsurface./// Get the surface used when creating the given subsurface.delegate_subcompositor/// To use this method you need to provide [`delegate_activation`][crate::delegate_activation] with your custom type./// Data associated with a [`WlSurface`]./// An owned [`WlSurface`].foreign_toplevel_listext_foreign_toplevel_handle_v1ext_foreign_toplevel_list_v1/// Title/// App id/// Identifier to check if two toplevel handles refer to same toplevelForeignToplevelInfo/// Information about a toplevel.ForeignToplevelInnerForeignToplevelDataExtForeignToplevelListV1toplevelsExtForeignToplevelHandleV1ForeignToplevelList/// Returns list of toplevels./// Returns information about a toplevel./// This may be none if the toplevel has been destroyed or the compositor has not sent/// information about the toplevel yet.foreign_toplevel_list_statenew_toplevel/// A new toplevel has been opened.update_toplevel/// An existing toplevel has changed.toplevel_closed/// A toplevel has closed.ForeignToplevelListHandler/// Handler trait for foreign toplevel list protocol.delegate_foreign_toplevel_list///   `ProvidesBoundGlobal<WlCompositor, 4>`, `ProvidesBoundGlobal<WlCompositor, 3>`,///   `ProvidesBoundGlobal<WlCompositor, 2>`, and `ProvidesBoundGlobal<WlCompositor, 1>` because///   versions 2-4 only add additional requests to the `wl_surface` API.///   `ProvidesBoundGlobal<WlCompositor, 5>` because version 5 makes using `wl_surface::attach` with///   a nonzero offset a protocol error.  A caller who is only aware of the version 4 API risks///   causing these protocol errors if it uses surfaces created by such a global.protocols_experimentalprotocols_misc// keep existing usage/// A handler for delegating [`wl_output::WlOutput`].wp_presentationwp_presentation_feedbackclk_idPresentTimepresentationWpPresentationPresentationTimeState/// Bind `wp_presentation` global, if it existsWpPresentationFeedbackPresentationTimeData/// Request feedback for current submission to surface.presentation_time_state/// Content update displayed to user at indicated timediscarded/// Content update not displayedPresentationTimeHandlersync_outputsdelegate_presentation_timefrom_bound/// Construct an instance from an already bound proxy./// Useful when a [`ProvidesBoundGlobal`] implementation is needed./// See [`delegate_registry`][crate::delegate_registry] for an example.text_inputzv3zwp_text_input_v3ChangeCauseContentHintContentPurposezwp_input_method_v2ZwpInputMethodV2zwp_input_method_manager_v2ZwpInputMethodManagerV2InputMethodManager/// Bind `zwp_input_method_v2` global, if it existsget_input_methodInputMethodInputMethodData/// Request a new input zwp_input_method_v2 object associated with a given/// seat.InputMethodHandlerinput_methodset_preedit_stringcommit_stringdelete_surrounding_textInputMethodDataInner/// Create the new input method data associated with the given seat.InputMethodEventStateSurroundingTextcontent_purposecontent_hinttext_change_cause/// Stores incoming interface state.surrounding_textNegotiatingCapabilities/// State machine for determining the capabilities of a text inputwith_activewith_surrounding_textwith_content_typewith_donedelegate_input_methodinput_method_dataInputMethodDataExthandle_donehandle_unavailabledelegate_dispatchassert_is_manager_delegateassert_is_delegatetest_valid_assignment//! Implementation of the `input-method-unstable-v2` protocol.//! This protocol allows applications to act as input methods for compositors.//! ### Implementation status//! Currently only the input-method object is supported. No keyboard grab, no popup surface.xx_input_method_v1XxInputMethodV1xx_input_popup_positioner_v1XxInputPopupPositionerV1xx_input_popup_surface_v2XxInputPopupSurfaceV2xx_input_method_manager_v2XxInputMethodManagerV2/// Bind the input_method global, if it exists/// Request a new input_method object associated with a givenget_positionerPopupPositioner/// A trivial wrapper for an [`XxInputPopupPositionerV1`]./// This wrapper calls [`destroy`][XxInputPopupPositionerV1::destroy] on the contained/// Only the start index is not on the boundary/// Only the end index is not on the boundary/// Both the start and end indices are not on boundaries/// Can't set the preedit string due to cursor index not on UTF-8 code point boundaryget_input_popup_surfacepopupsPopupState/// The position of the anchor relative to top-left corner of the popup/// serial == None means there is no configure sequence open and attempts to change state must be ignored.repositioned/// The repositioned token from the last sequence/// Server-provided popup state/// Creates an uninitialized copy ready to fill inreset_on_done/// Returns a copy after resetting the fields as required by the protocol on input_method.done.// Bytes relative to the beginning of the text. Must fall on code point boundaries./// A weak reference to the input method to which this appliesPopupDataInner// For mutability. Data is immutable./// Data reachable from XxInputPopupSurfaceV2outstanding_reposition_token/// Mutable data reachable from XxInputPopupSurfaceV2/// Creates a new, uninitialized stateupdate_repositioned/// Returns the newly received token if it's plausibly valid.delegate_input_method_v3/*fn handle_popup_configure(
        &self,
        connection: &Connection,
        qh: &QueueHandle<Self>,
        input_method: &XxInputPopupSurfaceV2,
        state: PopupConfigure,
    );*/input_method_v3assert_is_popup_delegateassert_is_positioner_delegate/*! This implements support for the experimental xx-input-method-v2 protocol.
 * That protocol will hopefully become -v3 without changing the API at some point.
 *//// This keyboard only sends key repeats if they are issued by the compositor./// See wl_keyboard version 10.repeat_key/// A key has been previously pressed and is now repeating./// This is only called on supporting compositors.RawModifiersdepressed/// State of keyboard modifiers, in raw form sent by compositor./// This event is deprecated and will be sent only by older compositors.value120/// High-resolution wheel scroll information, with each multiple of 120 representing one logical scroll step.relative_directionAxisRelativeDirection/// Relative directional information of the entity causing the axis motion./// Combines the magnitudes and stop status of events if the direction hasn't changed in between.DestroyOnDropPooltry_mainshell_outputcheck_statusSmolStr/// A `SmolStr` is a string type that has the following properties:/// * `size_of::<SmolStr>() == 24` (therefor `== size_of::<String>()` on 64 bit platforms)/// * `Clone` is `O(1)`/// * Strings are stack-allocated if they are:///     * Up to 23 bytes long///     * Longer than 23 bytes, but substrings of `WS` (see below). Such strings consist///     solely of consecutive newlines, followed by consecutive spaces/// * If a string does not satisfy the aforementioned conditions, it is heap-allocated/// * Additionally, a `SmolStr` can be explicitely created from a `&'static str` without allocation/// Unlike `String`, however, `SmolStr` is immutable. The primary use case for/// `SmolStr` is a good enough default storage for tokens of typical programming/// languages. Strings consisting of a series of newlines, followed by a series of/// whitespace are a typical pattern in computer programs because of indentation./// Note that a specialized interner might be a better solution for some use cases./// `WS`: A string of 32 newlines followed by 128 spaces."Use `new_inline` instead"new_inline_from_asciinew_inline/// Constructs inline variant of `SmolStr`./// Panics if `text.len() > 23`./// Constructs a `SmolStr` from a statically allocated string./// This never allocates.is_heap_allocatedfrom_char_iterbuild_from_str_iterINLINE_CAPN_NEWLINESN_SPACESWSInlineSize_V0_V1_V2_V3_V4_V5_V6_V7_V8_V9_V10_V11_V12_V13_V14_V15_V16_V17_V18_V19_V20_V21_V22_V23transmute_from_u8new_on_stack/// This function tries to create a new Repr::Inline or Repr::Static/// If it isn't possible, this function returns Noneto_smolstrToSmolStr/// Convert value to [`SmolStr`] using [`fmt::Display`], potentially without allocating./// Almost identical to [`ToString`], but converts to `SmolStr` instead."this returns a new SmolStr without modifying the original"to_lowercase_smolstr/// Returns the lowercase equivalent of this string slice as a new [`SmolStr`],/// potentially without allocating./// See [`str::to_lowercase`].to_uppercase_smolstr/// Returns the uppercase equivalent of this string slice as a new [`SmolStr`],/// See [`str::to_uppercase`].to_ascii_lowercase_smolstr/// Returns the ASCII lowercase equivalent of this string slice as a new [`SmolStr`],/// See [`str::to_ascii_lowercase`].to_ascii_uppercase_smolstr/// Returns the ASCII uppercase equivalent of this string slice as a new [`SmolStr`],/// See [`str::to_ascii_uppercase`].replace_smolstr/// Replaces all matches of a &str with another &str returning a new [`SmolStr`],/// See [`str::replace`].// TODO: Use `Pattern` when stable.replacen_smolstr/// Replaces first N matches of a &str with another &str returning a new [`SmolStr`],/// See [`str::replacen`]./// [`str`] methods producing [`SmolStr`]s./// No downstream impls allowed.format_smolstr/// Formats arguments to a [`SmolStr`], potentially without allocating./// See [`alloc::format!`] or [`format_args!`] for syntax documentation.// https://github.com/serde-rs/serde/blob/629802f2abfd1a54a6072992888fea7ca5bc209f/serde/src/private/de.rs#L56-L125NetInt/// Macro to implement `fmt::Debug` for a type, printing the constant names/// rather than a number./// Note this is used in the `sys` module and thus must be defined before/// defining the modules."sys/unix.rs"/// Specification of the communication domain for a socket./// This is a newtype wrapper around an integer which provides a nicer API in/// addition to an injection point for documentation. Convenience constructors/// such as `Domain::ipv4`, `Domain::ipv6`, etc, are provided to avoid reaching/// into libc for various constants./// This type is freely interconvertible with C's `int` type, however, if a raw/// value needs to be provided./// Domain for IPv4 communication, corresponding to `AF_INET`./// Domain for IPv6 communication, corresponding to `AF_INET6`./// Specification of communication semantics on a socket./// such as `Type::stream`, `Type::dgram`, etc, are provided to avoid reaching/// Type corresponding to `SOCK_STREAM`./// Used for protocols such as TCP.dgram/// Type corresponding to `SOCK_DGRAM`./// Used for protocols such as UDP.seqpacket/// Type corresponding to `SOCK_SEQPACKET`./// Type corresponding to `SOCK_RAW`./// Protocol specification used for creating sockets via `Socket::new`./// addition to an injection point for documentation.icmpv4/// Protocol corresponding to `ICMPv4`.icmpv6/// Protocol corresponding to `ICMPv6`./// Protocol corresponding to `TCP`./// Protocol corresponding to `UDP`.htonntoh//! Utilities for handling sockets//! This crate is sort of an evolution of the `net2` crate after seeing the//! issues on it over time. The intention of this crate is to provide as direct//! as possible access to the system's functionality for sockets as possible. No//! extra fluff (e.g. multiple syscalls or builders) provided in this crate. As//! a result using this crate can be a little wordy, but it should give you//! maximal flexibility over configuration of sockets.//! use std::net::SocketAddr;//! use socket2::{Socket, Domain, Type};//! // create a TCP listener bound to two addresses//! let socket = Socket::new(Domain::ipv6(), Type::stream(), None).unwrap();//! socket.bind(&"[::1]:12345".parse::<SocketAddr>().unwrap().into()).unwrap();//! socket.set_only_v6(false);//! socket.listen(128).unwrap();//! let listener = socket.into_tcp_listener();/// The address of a socket./// `SockAddr`s may be constructed directly to and from the standard library/// `SocketAddr`, `SocketAddrV4`, and `SocketAddrV6` types./// Constructs a `SockAddr` from its raw components.as_inet/// Returns this address as a `SocketAddrV4` if it is in the `AF_INET`as_inet6/// Returns this address as a `SocketAddrV6` if it is in the `AF_INET6`as_std/// Returns this address as a `SocketAddr` if it is in the `AF_INET`/// or `AF_INET6` family, otherwise returns `None`./// Returns this address's family./// Returns the size of this address in bytes./// Returns a raw pointer to the address.inetinet6// The `sys` module most have access to the socket./// Newtype, owned, wrapper around a system socket./// This type simply wraps an instance of a file descriptor (`c_int`) on Unix/// and an instance of `SOCKET` on Windows. This is the main type exported by/// this crate and is intended to mirror the raw semantics of sockets on/// platforms as closely as possible. Almost all methods correspond to/// precisely one libc or OS API call which is essentially just a "Rustic/// translation" of what's below./// use socket2::{Socket, Domain, Type, SockAddr};/// // create a TCP listener bound to two addresses/// let socket = Socket::new(Domain::ipv4(), Type::stream(), None).unwrap();/// socket.bind(&"127.0.0.1:12345".parse::<SocketAddr>().unwrap().into()).unwrap();/// socket.bind(&"127.0.0.1:12346".parse::<SocketAddr>().unwrap().into()).unwrap();/// socket.listen(128).unwrap();/// let listener = socket.into_tcp_listener();/// Creates a new socket ready to be configured./// This function corresponds to `socket(2)` and simply creates a new/// socket, no other configuration is done and further functions must be/// invoked to configure this socket.into_tcp_stream/// Consumes this `Socket`, converting it to a `TcpStream`.into_tcp_listener/// Consumes this `Socket`, converting it to a `TcpListener`.into_udp_socket/// Consumes this `Socket`, converting it to a `UdpSocket`./// Initiate a connection on this socket to the specified address./// This function directly corresponds to the connect(2) function on Windows/// and Unix./// An error will be returned if `listen` or `connect` has already been/// called on this builder./// Initiate a connection on this socket to the specified address, only/// only waiting for a certain period of time for the connection to be/// established./// Unlike many other methods on `Socket`, this does *not* correspond to a/// single C function. It sets the socket to nonblocking mode, connects via/// connect(2), and then waits for the connection to complete with poll(2)/// on Unix and select on Windows. When the connection is complete, the/// socket is set back to blocking mode. On Unix, this will loop over/// `EINTR` errors./// The nonblocking state of the socket is overridden by this function -/// it will be returned in blocking mode on success, and in an indeterminate/// state on failure./// If the connection request times out, it may still be processing in the/// background - a second call to `connect` or `connect_timeout` may fail./// Binds this socket to the specified address./// This function directly corresponds to the bind(2) function on Windows/// Mark a socket as ready to accept incoming connection requests using/// accept()/// This function directly corresponds to the listen(2) function on Windows/// Accept a new incoming connection from this listener./// This function will block the calling thread until a new connection is/// established. When established, the corresponding `Socket` and the/// remote peer's address will be returned./// Creates a new independently owned handle to the underlying socket./// The returned `TcpStream` is a reference to the same stream that this/// object references. Both handles will read and write the same stream of/// data, and options set on one stream will be propagated to the other/// Moves this TCP stream into or out of nonblocking mode./// On Unix this corresponds to calling fcntl, and on Windows this/// corresponds to calling ioctlsocket./// portions to return immediately with an appropriate value./// The [`connect`] method will connect this socket to a remote address. This/// method will fail if the socket is not connected./// [`connect`]: #method.connectrecv_with_flags/// Identical to [`recv`] but allows for specification of arbitrary flags to the underlying/// `recv` call./// [`recv`]: #method.recvrecv_out_of_band/// Receives out-of-band (OOB) data on the socket from the remote address to/// which it is connected by setting the `MSG_OOB` flag for this call./// For more information, see [`recv`], [`out_of_band_inline`]./// [`out_of_band_inline`]: #method.out_of_band_inline/// Receives data on the socket from the remote adress to which it is/// `MSG_PEEK` as a flag to the underlying `recv` system call.recv_from_with_flags/// Identical to [`recv_from`] but allows for specification of arbitrary flags to the underlying/// `recvfrom` call./// [`recv_from`]: #method.recv_from/// Receives data from the socket, without removing it from the queue./// `MSG_PEEK` as a flag to the underlying `recvfrom` system call./// On success, returns the number of bytes peeked and the address from/// Sends data on the socket to a connected peer./// This is typically used on TCP sockets or datagram sockets which have/// been connected./// On success returns the number of bytes that were sent.send_with_flags/// Identical to [`send`] but allows for specification of arbitrary flags to the underlying/// `send` call./// [`send`]: #method.sendsend_out_of_band/// Sends out-of-band (OOB) data on the socket to connected peer/// by setting the `MSG_OOB` flag for this call./// For more information, see [`send`], [`out_of_band_inline`]./// This is typically used on UDP or datagram-oriented sockets. On success/// returns the number of bytes that were sent.send_to_with_flags/// Identical to [`send_to`] but allows for specification of arbitrary flags to the underlying/// `sendto` call./// [`send_to`]: #method.send_to/// Gets the value of the `TCP_MAXSEG` option on this socket./// The `TCP_MAXSEG` option denotes the TCP Maximum Segment/// Size and is only available on TCP sockets.set_mss/// Sets the value of the `TCP_MAXSEG` option on this socket./// Gets the value for the `SO_MARK` option on this socket./// This value gets the socket mark field for each packet sent through/// this socket./// This function is only available on Linux and requires the/// `CAP_NET_ADMIN` capability.set_mark/// Sets the value for the `SO_MARK` option on this socket./// This value sets the socket mark field for each packet sent through/// this socket. Changing the mark can be used for mark-based routing/// without netfilter or for packet filtering./// Gets the value for the `SO_BINDTODEVICE` option on this socket./// This value gets the socket binded device's interface name.bind_device/// Sets the value for the `SO_BINDTODEVICE` option on this socket./// If a socket is bound to an interface, only packets received from that/// particular interface are processed by the socket. Note that this only/// works for some socket types, particularly `AF_INET` sockets./// If `interface` is `None` or an empty string it removes the binding.unicast_hops_v6/// Gets the value of the `IPV6_UNICAST_HOPS` option for this socket./// Specifies the hop limit for ipv6 unicast packetsset_unicast_hops_v6/// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket./// Gets the value of the `IPV6_V6ONLY` option for this socket./// For more information about this option, see [`set_only_v6`][link]./// [link]: #method.set_only_v6set_only_v6/// Sets the value for the `IPV6_V6ONLY` option on this socket./// If this is set to `true` then the socket is restricted to sending and/// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications/// can bind the same port at the same time./// If this is set to `false` then the socket can be used to send and/// receive packets from an IPv4-mapped IPv6 address./// Returns the read timeout of this socket./// If the timeout is `None`, then `read` calls will block indefinitely.set_read_timeout/// Sets the read timeout to the timeout specified./// If the value specified is `None`, then `read` calls will block/// indefinitely. It is an error to pass the zero `Duration` to this/// Returns the write timeout of this socket./// If the timeout is `None`, then `write` calls will block indefinitely.set_write_timeout/// Sets the write timeout to the timeout specified./// If the value specified is `None`, then `write` calls will blockmulticast_hops_v6/// Gets the value of the `IPV6_MULTICAST_HOPS` option for this socket/// [`set_multicast_hops_v6`][link]./// [link]: #method.set_multicast_hops_v6set_multicast_hops_v6/// Sets the value of the `IPV6_MULTICAST_HOPS` option for this socket/// Indicates the number of "routers" multicast packets will transit formulticast_if_v4/// Gets the value of the `IP_MULTICAST_IF` option for this socket./// [`set_multicast_if_v4`][link]./// [link]: #method.set_multicast_if_v4/// Returns the interface to use for routing multicast packets.set_multicast_if_v4/// Sets the value of the `IP_MULTICAST_IF` option for this socket./// Specifies the interface to use for routing multicast packets.multicast_if_v6/// Gets the value of the `IPV6_MULTICAST_IF` option for this socket./// [`set_multicast_if_v6`][link]./// [link]: #method.set_multicast_if_v6set_multicast_if_v6/// Sets the value of the `IPV6_MULTICAST_IF` option for this socket./// Specifies the interface to use for routing multicast packets. Unlike ipv4, this/// is generally required in ipv6 contexts where network routing prefixes may/// overlap./// Reads the linger duration for this socket by getting the SO_LINGER/// optionset_linger/// Sets the linger duration of this socket by setting the SO_LINGER option/// Check the `SO_REUSEADDR` option on this socket./// Set value for the `SO_REUSEADDR` option on this socket./// This indicates that futher calls to `bind` may allow reuse of local/// addresses. For IPv4 sockets this means that a socket may bind even when/// there's a socket already listening on this port./// Gets the value of the `SO_RCVBUF` option on this socket./// [`set_recv_buffer_size`][link]./// [link]: #method.set_recv_buffer_size/// Sets the value of the `SO_RCVBUF` option on this socket./// Changes the size of the operating system's receive buffer associated/// with the socket./// Gets the value of the `SO_SNDBUF` option on this socket./// For more information about this option, see [`set_send_buffer`][link]./// [link]: #method.set_send_buffer/// Sets the value of the `SO_SNDBUF` option on this socket./// Changes the size of the operating system's send buffer associated with/// the socket.keepalive/// Returns whether keepalive messages are enabled on this socket, and if so/// the duration of time between them./// For more information about this option, see [`set_keepalive`][link]./// [link]: #method.set_keepalive/// Sets whether keepalive messages are enabled to be sent on this socket./// On Unix, this option will set the `SO_KEEPALIVE` as well as the/// `TCP_KEEPALIVE` or `TCP_KEEPIDLE` option (depending on your platform)./// On Windows, this will set the `SIO_KEEPALIVE_VALS` option./// If `None` is specified then keepalive messages are disabled, otherwise/// the duration specified will be the time to remain idle before sending a/// TCP keepalive probe./// Some platforms specify this value in seconds, so sub-second/// specifications may be omitted.out_of_band_inline/// Returns the value of the `SO_OOBINLINE` flag of the underlying socket./// For more information about this option, see [`set_out_of_band_inline`][link]./// [link]: #method.set_out_of_band_inlineset_out_of_band_inline/// Sets the `SO_OOBINLINE` flag of the underlying socket./// as per RFC6093, TCP sockets using the Urgent mechanism/// are encouraged to set this flag./// If this flag is not set, the `MSG_OOB` flag is needed/// while `recv`ing to aquire the out-of-band data.reuse_port/// Check the value of the `SO_REUSEPORT` option on this socket./// This function is only available on Unix when the `reuseport` feature isset_reuse_port/// Set value for the `SO_REUSEPORT` option on this socket./// This indicates that further calls to `bind` may allow reuse of local// ================================================connect_timeout_unrouteableconnect_timeout_unboundconnect_timeout_validout_of_band_send_recv// Used in `Domain`.// Used in `Type`.// Used in `Protocol`.KEEPALIVE_OPTION/// Domain for Unix socket communication, corresponding to `AF_UNIX`./// Domain for low-level packet interface, corresponding to `AF_PACKET`./// Unix only API.non_blocking/// Set `SOCK_NONBLOCK` on the `Type`./// This function is only available on Android, DragonFlyBSD, FreeBSD,/// Linux, NetBSD and OpenBSD./// Set `SOCK_CLOEXEC` on the `Type`.cvt_rdur2timevaltimeval2durto_s_addrfrom_s_addrto_in6_addrlinger2durdur2lingertest_iptest_out_of_band_inlinein6addrws2ipdefSIO_KEEPALIVE_VALSonoffkeepalivetimekeepaliveintervaldur2msms2durin_addr_S_undomain_fmt_debugtype_fmt_debugprotocol_fmt_debugdoit/// Macro to convert from one network type to another.sockrefInterfaceIndexOrAddress/// addition to an injection point for documentation. Convenience constants such/// as [`Domain::IPV4`], [`Domain::IPV6`], etc, are provided to avoid reachingIPV4/// Returns the correct domain for `address`./// as [`Type::STREAM`], [`Type::DGRAM`], etc, are provided to avoid reachingICMPV4/// Flags for incoming messages./// Flags provide additional information about incoming messages.is_truncated/// Check if the message contains a truncated datagram./// This flag is only used for datagram-based sockets,/// not for stream sockets./// On Unix this corresponds to the `MSG_TRUNC` flag./// On Windows this corresponds to the `WSAEMSGSIZE` error code.MaybeUninitSlice/// A version of [`IoSliceMut`] that allows the buffer to be uninitialised./// [`IoSliceMut`]: std::io::IoSliceMut/// Creates a new `MaybeUninitSlice` wrapping a byte slice./// Panics on Windows if the slice is larger than 4GB./// Configures a socket's TCP keepalive parameters./// See [`Socket::set_tcp_keepalive`]./// Returns a new, empty set of TCP keepalive parameters./// Set the amount of time after which TCP keepalive probes will be sent on/// idle connections./// This will set `TCP_KEEPALIVE` on macOS and iOS, and/// `TCP_KEEPIDLE` on all other Unix operating systems, except/// OpenBSD and Haiku which don't support any way to set this/// option. On Windows, this sets the value of the `tcp_keepalive`/// struct's `keepalivetime` field./// Set the value of the `TCP_KEEPINTVL` option. On Windows, this sets the/// value of the `tcp_keepalive` struct's `keepaliveinterval` field./// Sets the time interval between TCP keepalive probes.with_retries/// Set the value of the `TCP_KEEPCNT` option./// Set the maximum number of TCP keepalive probes that will be sent before/// dropping a connection, if TCP keepalive is enabled on this socket.// Copyright 2015 The Rust Project Developers.//! Utilities for creating and using sockets.//! The goal of this crate is to create and use a socket using advanced//! configuration options (those that are not available in the types in the//! standard library) without using any unsafe code.//! This crate provides as direct as possible access to the system's//! functionality for sockets, this means little effort to provide//! cross-platform utilities. It is up to the user to know how to use sockets//! when using this crate. *If you don't know how to create a socket using//! libc/system calls then this crate is not for you*. Most, if not all,//! functions directly relate to the equivalent system call with no error//! handling applied, so no handling errors such as [`EINTR`]. As a result using//! this crate can be a little wordy, but it should give you maximal flexibility//! over configuration of sockets.//! [`EINTR`]: std::io::ErrorKind::Interrupted//! use std::net::{SocketAddr, TcpListener};//! // Create a TCP listener bound to two addresses.//! let socket = Socket::new(Domain::IPV6, Type::STREAM, None)?;//! socket.set_only_v6(false)?;//! let address: SocketAddr = "[::1]:12345".parse().unwrap();//! socket.bind(&address.into())?;//! socket.listen(128)?;//! let listener: TcpListener = socket.into();//! # drop(listener);//! This crate has a single feature `all`, which enables all functions even ones//! that are not available on all OSs.// Show required OS/features on docs.rs./// [`SocketAddr`], [`SocketAddrV4`], and [`SocketAddrV6`] types./// Create a `SockAddr` from the underlying storage and its length./// Caller must ensure that the address family and length match the type of/// storage address. For example if `storage.ss_family` is set to `AF_INET`/// the `storage` must be initialised as `sockaddr_in`, setting the content/// and length appropriately./// use socket2::{SockAddr, Socket, Domain, Type};/// let socket = Socket::new(Domain::IPV4, Type::STREAM, None)?;/// // Initialise a `SocketAddr` byte calling `getsockname(2)`./// let mut addr_storage: libc::sockaddr_storage = unsafe { mem::zeroed() };/// let mut len = mem::size_of_val(&addr_storage) as libc::socklen_t;/// // The `getsockname(2)` system call will intiliase `storage` for/// // us, setting `len` to the correct length.///     libc::getsockname(///         socket.as_raw_fd(),///         (&mut addr_storage as *mut libc::sockaddr_storage).cast(),///         &mut len,/// if res == -1 {///     return Err(io::Error::last_os_error());/// let address = unsafe { SockAddr::new(addr_storage, len) };/// # drop(address);/// Initialise a `SockAddr` by calling the function `init`./// The type of the address storage and length passed to the function `init`/// is OS/architecture specific./// The address is zeroed before `init` is called and is thus valid to/// dereference and read from. The length initialised to the maximum length/// of the storage./// let (_, address) = unsafe {///     SockAddr::init(|addr_storage, len| {///         // The `getsockname(2)` system call will intiliase `storage` for///         // us, setting `len` to the correct length.///         if libc::getsockname(socket.as_raw_fd(), addr_storage.cast(), len) == -1 {///             Err(io::Error::last_os_error())/// }?;as_storage_ptr/// Returns a raw pointer to the address storage./// Returns this address as a `SocketAddr` if it is in the `AF_INET` (IPv4)/// or `AF_INET6` (IPv6) family, otherwise returns `None`.as_socket_ipv4/// Returns this address as a [`SocketAddrV4`] if it is in the `AF_INET`as_socket_ipv6/// Returns this address as a [`SocketAddrV6`] if it is in the `AF_INET6`/// Owned wrapper around a system socket./// ## Converting to and from other types/// This type can be freely converted into the network primitives provided by/// the standard library, such as [`TcpStream`] or [`UdpSocket`], using the/// [`From`] trait, see the example below./// [`UdpSocket`]: std::net::UdpSocket/// Some methods that set options on `Socket` require two system calls to set/// there options without overwriting previously set options. We do this by/// first getting the current settings, applying the desired changes and than/// updating the settings. This means that the operation is **not** atomic. This/// can lead to a data race when two threads are changing options in parallel./// use socket2::{Socket, Domain, Type};/// let address: SocketAddr = "[::1]:12345".parse().unwrap();/// let address = address.into();/// socket.bind(&address)?;/// socket.listen(128)?;/// let listener: TcpListener = socket.into();/// # drop(listener);/// Store a `TcpStream` internally to take advantage of its niche optimizations on Unix platforms./// The caller must ensure `raw` is a valid file descriptor/socket. NOTE:/// this should really be marked `unsafe`, but this being an internal/// function, often passed as mapping function, it's makes it very/// inconvenient to mark it as `unsafe`./// Creates a new socket and sets common flags./// This function corresponds to `socket(2)` on Unix and `WSASocketW` on/// On Unix-like systems, the close-on-exec flag is set on the new socket./// Additionally, on Apple platforms `SOCK_NOSIGPIPE` is set. On Windows,/// the socket is made non-inheritable./// [`Socket::new_raw`] can be used if you don't want these flags to be set./// Windows and simply creates a new socket, no other configuration is done./// Creates a pair of sockets which are connected to each other./// This function corresponds to `socketpair(2)`./// This function sets the same flags as in done for [`Socket::new`],/// [`Socket::pair_raw`] can be used if you don't want to set those flags.pair_raw/// This function directly corresponds to the `bind(2)` function on Windows/// This function directly corresponds to the `connect(2)` function on/// Windows and Unix./// When using a non-blocking connect (by setting the socket into/// non-blocking mode before calling this function), socket option can't be/// set *while connecting*. This will cause errors on Windows. Socket/// options can be safely set before and after connecting the socket./// The non-blocking state of the socket is overridden by this function -/// [`Socket::accept()`]./// This function directly corresponds to the `listen(2)` function on/// This function uses `accept4(2)` on platforms that support it and/// `accept(2)` platforms that do not./// [`Socket::accept_raw`] can be used if you don't want to set those flags.accept_raw/// This function directly corresponds to the `accept(2)` function on/// Returns the socket address of the local half of this socket./// Depending on the OS this may return an error if the socket is not/// [bound]./// [bound]: Socket::bind/// Returns the socket address of the remote peer of this socket./// This returns an error if the socket is not [`connect`ed]./// [`connect`ed]: Socket::connectr#type/// Returns the [`Type`] of this socket by checking the `SO_TYPE` option on/// On Unix this uses `F_DUPFD_CLOEXEC` and thus sets the `FD_CLOEXEC` on/// the returned socket./// On Windows this uses `WSA_FLAG_NO_HANDLE_INHERIT` setting inheriting to/// On Windows this can **not** be used function cannot be used on a/// QOS-enabled socket, see/// <https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsaduplicatesocketw>./// On Unix this corresponds to calling `fcntl` (un)setting `O_NONBLOCK`./// On Windows this corresponds to calling `ioctlsocket` (un)setting/// `FIONBIO`./// The [`connect`] method will connect this socket to a remote address./// This method might fail if the socket is not connected./// [`connect`]: Socket::connect/// Normally casting a `&mut [u8]` to `&mut [MaybeUninit<u8>]` would be/// unsound, as that allows us to write uninitialised bytes to the buffer./// However this implementation promises to not write uninitialised bytes to/// the `buf`fer and passes it directly to `recv(2)` system call. This/// promise ensures that this function can be called using a `buf`fer of/// type `&mut [u8]`./// Note that the [`io::Read::read`] implementation calls this function with/// a `buf`fer of type `&mut [u8]`, allowing initialised buffers to be used/// without using `unsafe`./// [`recv`]: Socket::recv/// [`out_of_band_inline`]: Socket::out_of_band_inline/// Identical to [`recv`] but allows for specification of arbitrary flags to/// the underlying `recv` call.recv_vectored/// connected. Unlike [`recv`] this allows passing multiple buffers./// In addition to the number of bytes read, this function returns the flags/// for the received message. See [`RecvFlags`] for more information about/// the returned flags./// Normally casting a `IoSliceMut` to `MaybeUninitSlice` would be unsound,/// as that allows us to write uninitialised bytes to the buffer. However/// this implementation promises to not write uninitialised bytes to the/// `bufs` and passes it directly to `recvmsg(2)` system call. This promise/// ensures that this function can be called using `bufs` of type `&mut/// [IoSliceMut]`./// Note that the [`io::Read::read_vectored`] implementation calls this/// function with `buf`s of type `&mut [IoSliceMut]`, allowing initialised/// buffers to be used without using `unsafe`.recv_vectored_with_flags/// Identical to [`recv_vectored`] but allows for specification of arbitrary/// flags to the underlying `recvmsg`/`WSARecv` call./// [`recv_vectored`]: Socket::recv_vectored/// `recv_from_vectored` makes the same safety guarantees regarding `bufs`/// as [`recv_vectored`]./// `peek` makes the same safety guarantees regarding the `buf`fer as/// [`recv`]./// `recv_from` makes the same safety guarantees regarding the `buf`fer as/// Identical to [`recv_from`] but allows for specification of arbitrary/// flags to the underlying `recvfrom` call./// [`recv_from`]: Socket::recv_fromrecv_from_vectored/// Receives data from the socket. Returns the amount of bytes read, the/// [`RecvFlags`] and the remote address from the data is coming. Unlike/// [`recv_from`] this allows passing multiple buffers.recv_from_vectored_with_flags/// Identical to [`recv_from_vectored`] but allows for specification of/// arbitrary flags to the underlying `recvmsg`/`WSARecvFrom` call./// [`recv_from_vectored`]: Socket::recv_from_vectored/// `peek_from` makes the same safety guarantees regarding the `buf`fer as/// # Note: Datagram Sockets/// For datagram sockets, the behavior of this method when `buf` is smaller than/// the datagram at the head of the receive queue differs between Windows and/// Unix-like platforms (Linux, macOS, BSDs, etc: colloquially termed "*nix")./// On *nix platforms, the datagram is truncated to the length of `buf`./// On Windows, an error corresponding to `WSAEMSGSIZE` will be returned./// For consistency between platforms, be sure to provide a sufficiently large buffer to avoid/// truncation; the exact size required depends on the underlying protocol./// If you just want to know the sender of the data, try [`peek_sender`]./// [`peek_sender`]: Socket::peek_senderpeek_sender/// Retrieve the sender for the data at the head of the receive queue./// This is equivalent to calling [`peek_from`] with a zero-sized buffer,/// but suppresses the `WSAEMSGSIZE` error on Windows./// [`peek_from`]: Socket::peek_fromsend_vectored/// Send data to the connected peer. Returns the amount of bytes written.send_vectored_with_flags/// Identical to [`send_vectored`] but allows for specification of arbitrary/// flags to the underlying `sendmsg`/`WSASend` call./// [`send_vectored`]: Socket::send_vectored/// This is typically used on UDP or datagram-oriented sockets./// Identical to [`send_to`] but allows for specification of arbitrary flags/// to the underlying `sendto` call./// [`send_to`]: Socket::send_tosend_to_vectored/// Send data to a peer listening on `addr`. Returns the amount of bytessend_to_vectored_with_flags/// Identical to [`send_to_vectored`] but allows for specification of/// arbitrary flags to the underlying `sendmsg`/`WSASendTo` call./// [`send_to_vectored`]: Socket::send_to_vectoredset_common_type/// Set `SOCK_CLOEXEC` and `NO_HANDLE_INHERIT` on the `ty`pe on platforms that/// support it.set_common_flags/// Set `FD_CLOEXEC` and `NOSIGPIPE` on the `socket` for platforms that need it./// An interface index./// An address assigned to an interface./// A local interface specified by its index or an address assigned to it./// `Index(0)` and `Address(Ipv4Addr::UNSPECIFIED)` are equivalent and indicate/// that an appropriate interface should be selected by the system./// Get the value of the `SO_BROADCAST` option for this socket./// For more information about this option, see [`set_broadcast`]./// [`set_broadcast`]: Socket::set_broadcast/// Set the value of the `SO_BROADCAST` option for this socket./// Get the value of the `SO_KEEPALIVE` option on this socket./// For more information about this option, see [`set_keepalive`]./// [`set_keepalive`]: Socket::set_keepalive/// Set value for the `SO_KEEPALIVE` option on this socket./// Enable sending of keep-alive messages on connection-oriented sockets./// Get the value of the `SO_LINGER` option on this socket./// For more information about this option, see [`set_linger`]./// [`set_linger`]: Socket::set_linger/// Set value for the `SO_LINGER` option on this socket./// If `linger` is not `None`, a close(2) or shutdown(2) will not return/// until all queued messages for the socket have been successfully sent or/// the linger timeout has been reached. Otherwise, the call returns/// immediately and the closing is done in the background. When the socket/// is closed as part of exit(2), it always lingers in the background./// On most OSs the duration only has a precision of seconds and will be/// silently truncated./// On Apple platforms (e.g. macOS, iOS, etc) this uses `SO_LINGER_SEC`./// Get value for the `SO_OOBINLINE` option on this socket./// For more information about this option, see [`set_out_of_band_inline`]./// [`set_out_of_band_inline`]: Socket::set_out_of_band_inline/// Set value for the `SO_OOBINLINE` option on this socket./// If this option is enabled, out-of-band data is directly placed into the/// receive data stream. Otherwise, out-of-band data is passed only when the/// `MSG_OOB` flag is set during receiving. As per RFC6093, TCP sockets/// using the Urgent mechanism are encouraged to set this flag./// Get value for the `SO_RCVBUF` option on this socket./// For more information about this option, see [`set_recv_buffer_size`]./// [`set_recv_buffer_size`]: Socket::set_recv_buffer_size/// Set value for the `SO_RCVBUF` option on this socket./// Get value for the `SO_RCVTIMEO` option on this socket./// If the returned timeout is `None`, then `read` and `recv` calls will/// block indefinitely./// Set value for the `SO_RCVTIMEO` option on this socket./// If `timeout` is `None`, then `read` and `recv` calls will block/// Get the value of the `SO_REUSEADDR` option on this socket./// For more information about this option, see [`set_reuse_address`]./// [`set_reuse_address`]: Socket::set_reuse_address/// Get the value of the `SO_SNDBUF` option on this socket./// For more information about this option, see [`set_send_buffer_size`]./// [`set_send_buffer_size`]: Socket::set_send_buffer_size/// Set value for the `SO_SNDBUF` option on this socket./// Get value for the `SO_SNDTIMEO` option on this socket./// If the returned timeout is `None`, then `write` and `send` calls will/// Set value for the `SO_SNDTIMEO` option on this socket./// If `timeout` is `None`, then `write` and `send` calls will block/// Socket options get/set using `SOL_SOCKET`./// Additional documentation can be found in documentation of the OS./// * Linux: <https://man7.org/linux/man-pages/man7/socket.7.html>/// * Windows: <https://docs.microsoft.com/en-us/windows/win32/winsock/sol-socket-socket-options>from_lingerinto_lingerheader_included/// Get the value of the `IP_HDRINCL` option on this socket./// For more information about this option, see [`set_header_included`]./// [`set_header_included`]: Socket::set_header_includedset_header_included/// Set the value of the `IP_HDRINCL` option on this socket./// If enabled, the user supplies an IP header in front of the user data./// Valid only for [`SOCK_RAW`] sockets; see [raw(7)] for more information./// When this flag is enabled, the values set by `IP_OPTIONS`, [`IP_TTL`],/// and [`IP_TOS`] are ignored./// [`SOCK_RAW`]: Type::RAW/// [raw(7)]: https://man7.org/linux/man-pages/man7/raw.7.html/// [`IP_TTL`]: Socket::set_ttl/// [`IP_TOS`]: Socket::set_tosip_transparent/// Get the value of the `IP_TRANSPARENT` option on this socket./// For more information about this option, see [`set_ip_transparent`]./// [`set_ip_transparent`]: Socket::set_ip_transparentset_ip_transparent/// Set the value of the `IP_TRANSPARENT` option on this socket./// Setting this boolean option enables transparent proxying/// on this socket.  This socket option allows the calling/// application to bind to a nonlocal IP address and operate/// both as a client and a server with the foreign address as/// the local endpoint.  NOTE: this requires that routing be/// set up in a way that packets going to the foreign address/// are routed through the TProxy box (i.e., the system/// hosting the application that employs the IP_TRANSPARENT/// socket option).  Enabling this socket option requires/// superuser privileges (the `CAP_NET_ADMIN` capability)./// TProxy redirection with the iptables TPROXY target also/// requires that this option be set on the redirected socket./// Join a multicast group using `IP_ADD_MEMBERSHIP` option on this socket./// multicast group. If it's [`Ipv4Addr::UNSPECIFIED`] (`INADDR_ANY`) then/// an appropriate interface is chosen by the system./// Leave a multicast group using `IP_DROP_MEMBERSHIP` option on this socket./// For more information about this option, see [`join_multicast_v4`]./// [`join_multicast_v4`]: Socket::join_multicast_v4join_multicast_v4_n/// The address must be a valid multicast address, and `interface` specifies/// the local interface with which the system should join the multicast/// group. See [`InterfaceIndexOrAddress`].leave_multicast_v4_n/// For more information about this option, see [`join_multicast_v4_n`]./// [`join_multicast_v4_n`]: Socket::join_multicast_v4_njoin_ssm_v4/// Join a multicast SSM channel using `IP_ADD_SOURCE_MEMBERSHIP` option on this socket./// This function specifies a new multicast channel for this socket to join./// The group must be a valid SSM group address, the source must be the address of the sender/// and `interface` is the address of the local interface with which the system should join theleave_ssm_v4/// Leave a multicast group using `IP_DROP_SOURCE_MEMBERSHIP` option on this socket./// For more information about this option, see [`join_ssm_v4`]./// [`join_ssm_v4`]: Socket::join_ssm_v4/// Get the value of the `IP_MULTICAST_IF` option for this socket./// For more information about this option, see [`set_multicast_if_v4`]./// [`set_multicast_if_v4`]: Socket::set_multicast_if_v4/// Set the value of the `IP_MULTICAST_IF` option for this socket./// Get the value of the `IP_MULTICAST_LOOP` option for this socket./// For more information about this option, see [`set_multicast_loop_v4`]./// [`set_multicast_loop_v4`]: Socket::set_multicast_loop_v4/// Set the value of the `IP_MULTICAST_LOOP` option for this socket./// Get the value of the `IP_MULTICAST_TTL` option for this socket./// For more information about this option, see [`set_multicast_ttl_v4`]./// [`set_multicast_ttl_v4`]: Socket::set_multicast_ttl_v4/// Set the value of the `IP_MULTICAST_TTL` option for this socket./// Get the value of the `IP_TTL` option for this socket./// For more information about this option, see [`set_ttl`]./// [`set_ttl`]: Socket::set_ttl/// Set the value of the `IP_TTL` option for this socket.set_tos/// Set the value of the `IP_TOS` option for this socket./// This value sets the type-of-service field that is used in every packet/// sent from this socket./// NOTE: <https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options>/// documents that not all versions of windows support `IP_TOS`./// Get the value of the `IP_TOS` option for this socket./// For more information about this option, see [`set_tos`]./// [`set_tos`]: Socket::set_tosset_recv_tos/// Set the value of the `IP_RECVTOS` option for this socket./// If enabled, the IP_TOS ancillary message is passed with/// incoming packets. It contains a byte which specifies the/// Type of Service/Precedence field of the packet header.recv_tos/// Get the value of the `IP_RECVTOS` option for this socket./// For more information about this option, see [`set_recv_tos`]./// [`set_recv_tos`]: Socket::set_recv_tos/// Socket options for IPv4 sockets, get/set using `IPPROTO_IP`./// * Linux: <https://man7.org/linux/man-pages/man7/ip.7.html>/// * Windows: <https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options>/// Join a multicast group using `IPV6_ADD_MEMBERSHIP` option on this socket./// Some OSs use `IPV6_JOIN_GROUP` for this option./// Leave a multicast group using `IPV6_DROP_MEMBERSHIP` option on this socket./// Some OSs use `IPV6_LEAVE_GROUP` for this option./// For more information about this option, see [`join_multicast_v6`]./// [`join_multicast_v6`]: Socket::join_multicast_v6/// Get the value of the `IPV6_MULTICAST_HOPS` option for this socket/// For more information about this option, see [`set_multicast_hops_v6`]./// [`set_multicast_hops_v6`]: Socket::set_multicast_hops_v6/// Set the value of the `IPV6_MULTICAST_HOPS` option for this socket/// Get the value of the `IPV6_MULTICAST_IF` option for this socket./// For more information about this option, see [`set_multicast_if_v6`]./// [`set_multicast_if_v6`]: Socket::set_multicast_if_v6/// Set the value of the `IPV6_MULTICAST_IF` option for this socket./// Specifies the interface to use for routing multicast packets. Unlike/// ipv4, this is generally required in ipv6 contexts where network routing/// prefixes may overlap./// Get the value of the `IPV6_MULTICAST_LOOP` option for this socket./// For more information about this option, see [`set_multicast_loop_v6`]./// [`set_multicast_loop_v6`]: Socket::set_multicast_loop_v6/// Set the value of the `IPV6_MULTICAST_LOOP` option for this socket./// Get the value of the `IPV6_UNICAST_HOPS` option for this socket./// Set the value for the `IPV6_UNICAST_HOPS` option on this socket./// Get the value of the `IPV6_V6ONLY` option for this socket./// For more information about this option, see [`set_only_v6`]./// [`set_only_v6`]: Socket::set_only_v6/// Set the value for the `IPV6_V6ONLY` option on this socket./// Socket options for IPv6 sockets, get/set using `IPPROTO_IPV6`./// * Linux: <https://man7.org/linux/man-pages/man7/ipv6.7.html>/// * Windows: <https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ipv6-socket-options>keepalive_time/// Get the value of the `TCP_KEEPIDLE` option on this socket./// This returns the value of `TCP_KEEPALIVE` on macOS and iOS and `TCP_KEEPIDLE` on all other/// supported Unix operating systems.keepalive_interval/// Get the value of the `TCP_KEEPINTVL` option on this socket./// For more information about this option, see [`set_tcp_keepalive`]./// [`set_tcp_keepalive`]: Socket::set_tcp_keepalivekeepalive_retries/// Get the value of the `TCP_KEEPCNT` option on this socket.set_tcp_keepalive/// Set parameters configuring TCP keepalive probes for this socket./// The supported parameters depend on the operating system, and are/// configured using the [`TcpKeepalive`] struct. At a minimum, all systems/// support configuring the [keepalive time]: the time after which the OS/// will start sending keepalive messages on an idle connection./// [keepalive time]: TcpKeepalive::with_time/// * This will enable `SO_KEEPALIVE` on this socket, if it is not already///   enabled./// * On some platforms, such as Windows, any keepalive parameters *not*///   configured by the `TcpKeepalive` struct passed to this function may be///   overwritten with their default values. Therefore, this function should///   either only be called once per socket, or the same parameters should///   be passed every time it is called./// use socket2::{Socket, TcpKeepalive, Domain, Type};/// let keepalive = TcpKeepalive::new()///     .with_time(Duration::from_secs(4));///     // Depending on the target operating system, we may also be able to///     // configure the keepalive probe interval and/or the number of///     // retries here as well./// socket.set_tcp_keepalive(&keepalive)?;/// Get the value of the `TCP_NODELAY` option on this socket./// For more information about this option, see [`set_nodelay`]./// [`set_nodelay`]: Socket::set_nodelay/// Set the value of the `TCP_NODELAY` option on this socket./// Socket options for TCP sockets, get/set using `IPPROTO_TCP`./// * Linux: <https://man7.org/linux/man-pages/man7/tcp.7.html>/// * Windows: <https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-tcp-socket-options>/// Because this is a reference we don't own the `Socket`, however `Socket`/// closes itself when dropped, so we use `ManuallyDrop` to prevent it from/// closing itself./// Because we don't own the socket we need to ensure the socket remains/// open while we have a "reference" to it, the lifetime `'s` ensures this./// A reference to a [`Socket`] that can be used to configure socket types other/// than the `Socket` type itself./// This allows for example a [`TcpStream`], found in the standard library, to/// be configured using all the additional methods found in the [`Socket`] API./// `SockRef` can be created from any socket type that implements [`AsRawFd`]/// (Unix) or [`AsRawSocket`] (Windows) using the [`From`] implementation, but/// the caller must ensure the file descriptor/socket is a valid.// Don't use intra-doc links because they won't build on every platform./// [`AsRawFd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.AsRawFd.html/// [`AsRawSocket`]: https://doc.rust-lang.org/stable/std/os/windows/io/trait.AsRawSocket.html/// Below is an example of converting a [`TcpStream`] into a [`SockRef`]./// use std::net::{TcpStream, SocketAddr};/// use socket2::SockRef;/// // Create `TcpStream` from the standard library./// let address: SocketAddr = "127.0.0.1:1234".parse()?;/// # let b1 = std::sync::Arc::new(std::sync::Barrier::new(2));/// # let b2 = b1.clone();/// # let handle = std::thread::spawn(move || {/// #    let listener = std::net::TcpListener::bind(address).unwrap();/// #    b2.wait();/// #    let (stream, _) = listener.accept().unwrap();/// #    std::thread::sleep(std::time::Duration::from_millis(10));/// #    drop(stream);/// # b1.wait();/// // Create a `SockRef`erence to the stream./// let socket_ref = SockRef::from(&stream);/// // Use `Socket::set_nodelay` on the stream./// socket_ref.set_nodelay(true)?;/// drop(socket_ref);/// assert_eq!(stream.nodelay()?, true);/// Below is an example of **incorrect usage** of `SockRef::from`, which is/// currently possible (but not intended and will be fixed in future versions)./// /// THIS USAGE IS NOT VALID!/// let socket_ref = SockRef::from(&123);/// // The above line is overseen possibility when using `SockRef::from`, it/// // uses the `RawFd` (on Unix), which is a type alias for `c_int`/`i32`,/// // which implements `AsRawFd`. However it may be clear that this usage is/// // invalid as it doesn't guarantee that `123` is a valid file descriptor./// // Using `Socket::set_nodelay` now will call it on a file descriptor we/// // don't own! We don't even not if the file descriptor is valid or a socket./// # DO_NOT_COMPILE/// The caller must ensure `S` is actually a socket./// On Windows, a corresponding `From<&impl AsRawSocket>` implementation exists.// Used in `SockAddr`.// Used in `RecvFlags`.Ipv6Mreq// Used in `Socket`.IpMreqIpMreqSource// See this type in the Windows file.KEEPALIVE_TIMEMAX_BUF_LEN/// Maximum size of a buffer passed to system call like `recv` and `send`.IovLen/// Domain for low-level VSOCK interface, corresponding to `AF_VSOCK`.nonblocking_cloexecis_end_of_record/// Check if the message terminates a record./// Not all socket types support the notion of records./// For socket types that do support it (such as [`SEQPACKET`][Type::SEQPACKET]),/// a record is terminated by sending a message with the end-of-record flag set./// On Unix this corresponds to the MSG_EOR flag.is_out_of_band/// Check if the message contains out-of-band data./// This is useful for protocols where you receive out-of-band data/// mixed in with the normal data stream./// On Unix this corresponds to the MSG_OOB flag./// Unix-only API./// Constructs a `SockAddr` with the family `AF_UNIX` and the provided path./// # Failure/// Returns an error if the path is longer than `SUN_LEN`.// TODO: replace with `unsafe_op_in_unsafe_fn` once stable./// Constructs a `SockAddr` with the family `AF_VSOCK` and the provided CID/port./// This function can never fail. In a future version of this library it will be made/// infallible.vsock_address/// Returns this address VSOCK CID/port if it is in the `AF_VSOCK` family,/// otherwise return `None`.socket_from_rawsocket_as_rawsocket_into_rawpoll_connect// TODO: use clamp from std lib, stable since 1.50./// Returns the (bytes received, sending address len, `RecvFlags`).timeout_opt/// Wrapper around `getsockopt` to deal with platform specific timeouts.from_timevalset_timeout_opt/// Wrapper around `setsockopt` to deal with platform specific timeouts.into_timevalinto_secsfcntl_add/// Add `flag` to the current set flags of `F_GETFD`.fcntl_remove/// Remove `flag` to the current set flags of `F_GETFD`./// Caller must ensure `T` is the correct type for `opt` and `val`.to_in_addrfrom_in6_addrto_mreqn/// This function directly corresponds to the `accept4(2)` function./// established. When established, the corresponding `Socket` and the remote/// peer's address will be returned._accept4/// Sets `CLOEXEC` on the socket./// On supported platforms you can use [`Type::cloexec`]._set_cloexec/// For more information about this option, see [`set_mss`]./// [`set_mss`]: crate::Socket::set_mss/// The `TCP_MAXSEG` option denotes the TCP Maximum Segment Size and is only/// available on TCP sockets.is_listener/// Returns `true` if `listen(2)` was called on this socket by checking the/// `SO_ACCEPTCONN` option on this socket./// Returns the [`Domain`] of this socket by checking the `SO_DOMAIN` option/// on this socket./// Returns the [`Protocol`] of this socket by checking the `SO_PROTOCOL`/// option on this socket./// On Linux this function requires the `CAP_NET_ADMIN` capability./// Get the value of the `TCP_CORK` option on this socket./// For more information about this option, see [`set_cork`]./// [`set_cork`]: Socket::set_corkset_cork/// Set the value of the `TCP_CORK` option on this socket./// If set, don't send out partial frames. All queued partial frames are/// sent when the option is cleared again. There is a 200 millisecond ceiling on/// the time for which output is corked by `TCP_CORK`. If this ceiling is reached,/// then queued data is automatically transmitted.quickack/// Get the value of the `TCP_QUICKACK` option on this socket./// For more information about this option, see [`set_quickack`]./// [`set_quickack`]: Socket::set_quickackset_quickack/// Set the value of the `TCP_QUICKACK` option on this socket./// If set, acks are sent immediately, rather than delayed if needed in accordance to normal/// TCP operation. This flag is not permanent, it only enables a switch to or from quickack mode./// Subsequent operation of the TCP protocol will once again enter/leave quickack mode depending on/// internal protocol processing and factors such as delayed ack timeouts occurring and data transfer.thin_linear_timeouts/// Get the value of the `TCP_THIN_LINEAR_TIMEOUTS` option on this socket./// For more information about this option, see [`set_thin_linear_timeouts`]./// [`set_thin_linear_timeouts`]: Socket::set_thin_linear_timeoutsset_thin_linear_timeouts/// Set the value of the `TCP_THIN_LINEAR_TIMEOUTS` option on this socket./// If set, the kernel will dynamically detect a thin-stream connection if there are less than four packets in flight./// With less than four packets in flight the normal TCP fast retransmission will not be effective./// The kernel will modify the retransmission to avoid the very high latencies that thin stream suffer because of exponential backoff.cpu_affinity/// Get the value of the `SO_INCOMING_CPU` option on this socket./// For more information about this option, see [`set_cpu_affinity`]./// [`set_cpu_affinity`]: crate::Socket::set_cpu_affinityset_cpu_affinity/// Set value for the `SO_INCOMING_CPU` option on this socket./// Sets the CPU affinity of the socket./// Get the value of the `SO_REUSEPORT` option on this socket./// For more information about this option, see [`set_reuse_port`]./// [`set_reuse_port`]: crate::Socket::set_reuse_portfreebind/// Get the value of the `IP_FREEBIND` option on this socket./// For more information about this option, see [`set_freebind`]./// [`set_freebind`]: crate::Socket::set_freebindset_freebind/// Set value for the `IP_FREEBIND` option on this socket./// If enabled, this boolean option allows binding to an IP address that is/// nonlocal or does not (yet) exist.  This permits listening on a socket,/// without requiring the underlying network interface or the specified/// dynamic IP address to be up at the time that the application is trying/// to bind to it.freebind_ipv6/// Get the value of the `IPV6_FREEBIND` option on this socket./// This is an IPv6 counterpart of `IP_FREEBIND` socket option on/// Android/Linux. For more information about this option, see/// [`set_freebind`].set_freebind_ipv6/// Set value for the `IPV6_FREEBIND` option on this socket./// use socket2::{Domain, Socket, Type};/// use std::io::{self, Error, ErrorKind};/// fn enable_freebind(socket: &Socket) -> io::Result<()> {///     match socket.domain()? {///         Domain::IPV4 => socket.set_freebind(true)?,///         Domain::IPV6 => socket.set_freebind_ipv6(true)?,///         _ => return Err(Error::new(ErrorKind::Other, "unsupported domain")),/// # fn main() -> io::Result<()> {/// #     let socket = Socket::new(Domain::IPV6, Type::STREAM, None)?;/// #     enable_freebind(&socket)/// Copies data between a `file` and this socket using the `sendfile(2)`/// system call. Because this copying is done within the kernel,/// `sendfile()` is more efficient than the combination of `read(2)` and/// `write(2)`, which would require transferring data to and from user/// Different OSs support different kinds of `file`s, see the OS/// documentation for what kind of files are supported. Generally *regular*/// files are supported by all OSs./// The `offset` is the absolute offset into the `file` to use as starting/// Depending on the OS this function *may* change the offset of `file`. For/// the best results reset the offset of the file before using it again./// The `length` determines how many bytes to send, where a length of `None`/// means it will try to send all bytes._sendfile/// Set the value of the `TCP_USER_TIMEOUT` option on this socket./// If set, this specifies the maximum amount of time that transmitted data may remain/// unacknowledged or buffered data may remain untransmitted before TCP will forcibly close the/// corresponding connection./// Setting `timeout` to `None` or a zero duration causes the system default timeouts to/// be used. If `timeout` in milliseconds is larger than `c_uint::MAX`, the timeout is clamped/// to `c_uint::MAX`. For example, when `c_uint` is a 32-bit value, this limits the timeout to/// approximately 49.71 days./// Get the value of the `TCP_USER_TIMEOUT` option on this socket./// For more information about this option, see [`set_tcp_user_timeout`]./// [`set_tcp_user_timeout`]: Socket::set_tcp_user_timeoutattach_filter/// Attach Berkeley Packet Filter(BPF) on this socket./// BPF allows a user-space program to attach a filter onto any socket/// and allow or disallow certain types of data to come through the socket./// For more information about this option, see [filter](https://www.kernel.org/doc/html/v5.12/networking/filter.html)detach_filter/// Detach Berkeley Packet Filter(BPF) from this socket./// For more information about this option, see [`attach_filter`]in_addr_convertionin6_addr_convertionmstcpipWSABUF/// Fake MSG_TRUNC flag for the [`RecvFlags`] struct./// The flag is enabled when a `WSARecv[From]` call returns `WSAEMSGSIZE`. The/// value of the flag is defined by us.SOCKADDR_IN6_LHws2tcpipIP_MREQ_SOURCE/// Type used in set/getsockopt to retrieve the `TCP_NODELAY` option./// NOTE: <https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getsockopt>/// documents that options such as `TCP_NODELAY` and `SO_KEEPALIVE` expect a/// `BOOL` (alias for `c_int`, 4 bytes), however in practice this turns out to/// be false (or misleading) as a `BOOLEAN` (`c_uchar`, 1 byte) is returned by/// `getsockopt`.NO_INHERIT/// Our custom flag to set `WSA_FLAG_NO_HANDLE_INHERIT` on socket creation./// Trying to mimic `Type::cloexec` on windows.no_inherit/// Set `WSA_FLAG_NO_HANDLE_INHERIT` on the socket._no_inherit// Last bit./// Windows only API.from_msinto_ms/// Caller must ensure `T` is the correct type for `level` and `optname`./// Sets `HANDLE_FLAG_INHERIT` using `SetHandleInformation`._set_no_inheritman_links// Links to all OSs.// Links to Unix-like OSs.// Links to Windows only.// Internals.// List for Unix-like OSs.// List for Window (so just Windows)./// Link to online documentation for (almost) all supported OSs./// Type corresponding to `SOCK_DCCP`./// Used for the DCCP protocol./// Protocol corresponding to `MPTCP`./// Protocol corresponding to `DCCP`./// Protocol corresponding to `SCTP`./// Protocol corresponding to `UDPLITE`._lifetimes'addr'bufs'control/// Configuration of a `sendmsg(2)` system call./// This wraps `msghdr` on Unix and `WSAMSG` on Windows. Also see [`MsgHdrMut`]/// for the variant used by `recvmsg(2)`./// Create a new `MsgHdr` with all empty/zero fields./// Set the address (name) of the message./// Corresponds to setting `msg_name` and `msg_namelen` on Unix and `name`/// and `namelen` on Windows.with_buffers/// Set the buffer(s) of the message./// Corresponds to setting `msg_iov` and `msg_iovlen` on Unix and `lpBuffers`/// and `dwBufferCount` on Windows.with_control/// Set the control buffer of the message./// Corresponds to setting `msg_control` and `msg_controllen` on Unix and/// `Control` on Windows./// Set the flags of the message./// Corresponds to setting `msg_flags` on Unix and `dwFlags` on Windows.MsgHdrMut/// Configuration of a `recvmsg(2)` system call./// This wraps `msghdr` on Unix and `WSAMSG` on Windows. Also see [`MsgHdr`] for/// the variant used by `sendmsg(2)`./// Create a new `MsgHdrMut` with all empty/zero fields./// Set the mutable address (name) of the message./// Set the mutable buffer(s) of the message./// Set the mutable control buffer of the message./// Returns the flags of the message./// Gets the length of the control buffer./// Can be used to determine how much, if any, of the control buffer was filled by `recvmsg`./// Corresponds to `msg_controllen` on Unix and `Control.len` on Windows.///     SockAddr::try_init(|addr_storage, len| {/// Set the length of the address./// Caller must ensure that the address up to `length` bytes are properly/// initialised./// Returns this address's `Domain`.as_storage/// Retuns the address as the storage./// Returns true if this address is in the `AF_INET` (IPv4) family, false otherwise./// Returns true if this address is in the `AF_INET6` (IPv6) family, falseis_unix/// Returns true if this address is of a unix socket (for local interprocess communication),/// i.e. it is from the `AF_UNIX` family, false otherwise./// Returns the initialised storage bytes.ipv4_eqipv4_hashipv6_eqipv6_hashipv4_ipv6_eqipv4_ipv6_hash// allow a0 == a0 check/// their options without overwriting previously set options. We do this by/// first getting the current settings, applying the desired changes, and then/// // create a TCP listener/// let socket = Socket::new(Domain::IPV6, Type::STREAM, None)?;/// On Cygwin, a Unix domain socket connect blocks until the server accepts/// it. If the behavior is not expected, try [`Socket::set_no_peercred`]/// (Cygwin only).// Socket::set_no_peercred/// This function directly corresponds to the `getsockname(2)` function on/// This function directly corresponds to the `getpeername(2)` function on/// Returns true if this socket is set to nonblocking mode, false otherwise./// On Unix this corresponds to calling `fcntl` returning the value of/// `O_NONBLOCK`./// On Windows it is not possible retrieve the nonblocking mode status./// Moves this socket into or out of nonblocking mode./// Receive a message from a socket using a message structure./// This is not supported on Windows as calling `WSARecvMsg` (the `recvmsg`/// equivalent) is not straight forward on Windows. See/// <https://github.com/microsoft/Windows-classic-samples/blob/7cbd99ac1d2b4a0beffbaba29ea63d024ceff700/Samples/Win7Samples/netds/winsock/recvmsg/rmmc.cpp>/// for an example (in C++)./// [`send`]: Socket::send/// Send a message on a socket using a message structure.passcred/// Get value for the `SO_PASSCRED` option on this socket./// For more information about this option, see [`set_passcred`]./// [`set_passcred`]: Socket::set_passcredset_passcred/// Set value for the `SO_PASSCRED` option on this socket./// If this option is enabled, enables the receiving of the `SCM_CREDENTIALS`/// control messages."Use `Socket::header_included_v4` instead"/// This method is deprecated, use [`crate::Socket::header_included_v4`].header_included_v4"Use `Socket::set_header_included_v4` instead"/// This method is deprecated, use [`crate::Socket::set_header_included_v4`].set_header_included_v4multicast_all_v4/// Get the value of the `IP_MULTICAST_ALL` option for this socket./// For more information about this option, see [`set_multicast_all_v4`]./// [`set_multicast_all_v4`]: Socket::set_multicast_all_v4set_multicast_all_v4/// Set the value of the `IP_MULTICAST_ALL` option for this socket./// This option can be used to modify the delivery policy of/// multicast messages.  The argument is a boolean/// (defaults to true).  If set to true, the socket will receive/// messages from all the groups that have been joined/// globally on the whole system.  Otherwise, it will deliver/// messages only from the groups that have been explicitly/// joined (for example via the `IP_ADD_MEMBERSHIP` option) on/// this particular socket./// If enabled, the `IP_TOS` ancillary message is passed withheader_included_v6set_header_included_v6/// When this flag is enabled, the values set by `IP_OPTIONS` are ignored.multicast_all_v6/// Get the value of the `IPV6_MULTICAST_ALL` option for this socket./// For more information about this option, see [`set_multicast_all_v6`]./// [`set_multicast_all_v6`]: Socket::set_multicast_all_v6set_multicast_all_v6/// Set the value of the `IPV6_MULTICAST_ALL` option for this socket./// joined (for example via the `IPV6_ADD_MEMBERSHIP` option) onrecv_tclass_v6/// Get the value of the `IPV6_RECVTCLASS` option for this socket./// For more information about this option, see [`set_recv_tclass_v6`]./// [`set_recv_tclass_v6`]: Socket::set_recv_tclass_v6set_recv_tclass_v6/// Set the value of the `IPV6_RECVTCLASS` option for this socket./// If enabled, the `IPV6_TCLASS` ancillary message is passed with incoming/// packets. It contains a byte which specifies the traffic class field of/// the packet header.recv_hoplimit_v6/// Get the value of the `IPV6_RECVHOPLIMIT` option for this socket./// For more information about this option, see [`set_recv_hoplimit_v6`]./// [`set_recv_hoplimit_v6`]: Socket::set_recv_hoplimit_v6set_recv_hoplimit_v6/// Set the value of the `IPV6_RECVHOPLIMIT` option for this socket./// The received hop limit is returned as ancillary data by recvmsg()/// only if the application has enabled the IPV6_RECVHOPLIMIT socket/// option:original_dst/// Get the value for the `SO_ORIGINAL_DST` option on this socket.original_dst_ipv6/// Get the value for the `IP6T_SO_ORIGINAL_DST` option on this socket./// `SockRef` can be created from any socket type that implements [`AsFd`]/// (Unix) or [`AsSocket`] (Windows) using the [`From`] implementation./// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.AsFd.html/// [`AsSocket`]: https://doc.rust-lang.org/stable/std/os/windows/io/trait.AsSocket.html/// On Windows, a corresponding `From<&impl AsSocket>` implementation exists.// TCP_CA_NAME_MAX isn't defined in user space include files(not in libc)/// Not all socket types support the notion of records. For socket types/// that do support it (such as [`SEQPACKET`]), a record is terminated by/// sending a message with the end-of-record flag set./// On Unix this corresponds to the `MSG_EOR` flag./// [`SEQPACKET`]: Type::SEQPACKET/// On Unix this corresponds to the `MSG_OOB` flag.is_confirm/// Check if the confirm flag is set./// This is used by SocketCAN to indicate a frame was sent via the/// socket it is received on. This flag can be interpreted as a/// 'transmission confirmation'./// On Unix this corresponds to the `MSG_CONFIRM` flag.is_dontroute/// Check if the don't route flag is set./// This is used by SocketCAN to indicate a frame was created/// on the local host./// On Unix this corresponds to the `MSG_DONTROUTE` flag.offset_of_path/// Returns the offset of the `sun_path` member of the passed unix socket address.unix_sockaddr// Used in `MsgHdr`.set_msghdr_nameset_msghdr_iov// IovLen type can be `usize`.set_msghdr_controlset_msghdr_flagsmsghdr_flagsmsghdr_control_lenas_vsock_address/// Returns true if this address is an unnamed address from the `AF_UNIX` family (for local/// interprocess communication), false otherwise.as_sockaddr_un/// Returns the underlying `sockaddr_un` object if this addres is from the `AF_UNIX` family,/// otherwise returns `None`./// Get the length of the path bytes of the address, not including the terminating or initial/// (for abstract names) null byte./// Should not be called on unnamed addresses./// Get a u8 slice for the bytes of the pathname or abstract name.as_unix/// Returns this address as Unix `SocketAddr` if it is an `AF_UNIX` pathname/// address, otherwise returns `None`.as_pathname/// Returns this address as a `Path` reference if it is an `AF_UNIX`/// pathname address, otherwise returns `None`.as_abstract_namespace/// Returns this address as a slice of bytes representing an abstract address if it is an/// `AF_UNIX` abstract address, otherwise returns `None`./// Abstract addresses are a Linux extension, so this method returns `None` on all non-Linuxfcntl_get/// Get the flags using `cmd`./// This value contains the original destination IPv6 address of the connection/// redirected using `ip6tables` `REDIRECT` or `TPROXY`./// [`set_cork`]: crate::Socket::set_cork/// [`set_quickack`]: crate::Socket::set_quickack/// [`set_thin_linear_timeouts`]: crate::Socket::set_thin_linear_timeouts/// [`set_tcp_user_timeout`]: crate::Socket::set_tcp_user_timeout/// [`attach_filter`]: crate::Socket::attach_filter/// Gets the value for the `SO_COOKIE` option on this socket./// The socket cookie is a unique, kernel-managed identifier tied to each socket./// Therefore, there is no corresponding `set` helper./// For more information about this option, see [Linux patch](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5daab9db7b65df87da26fd8cfa695fb9546a1ddb)tclass_v6/// Get the value of the `IPV6_TCLASS` option for this socket./// For more information about this option, see [`set_tclass_v6`]./// [`set_tclass_v6`]: crate::Socket::set_tclass_v6set_tclass_v6/// Set the value of the `IPV6_TCLASS` option for this socket./// Specifies the traffic class field that is used in every packets/// Get the value of the `TCP_CONGESTION` option for this socket./// For more information about this option, see [`set_tcp_congestion`]./// [`set_tcp_congestion`]: crate::Socket::set_tcp_congestion/// Set the value of the `TCP_CONGESTION` option for this socket./// Specifies the TCP congestion control algorithm to use for this socket./// The value must be a valid TCP congestion control algorithm name of the/// platform. For example, Linux may supports "reno", "cubic".set_dccp_service/// Set value for the `DCCP_SOCKOPT_SERVICE` option on this socket./// Sets the DCCP service. The specification mandates use of service codes./// If this socket option is not set, the socket will fall back to 0 (which/// means that no meaningful service code is present). On active sockets/// this is set before [`connect`]. On passive sockets up to 32 service/// codes can be set before calling [`bind`]/// [`connect`]: crate::Socket::connect/// [`bind`]: crate::Socket::binddccp_service/// Get the value of the `DCCP_SOCKOPT_SERVICE` option on this socket./// For more information about this option see [`set_dccp_service`]/// [`set_dccp_service`]: crate::Socket::set_dccp_serviceset_dccp_ccid/// Set value for the `DCCP_SOCKOPT_CCID` option on this socket./// This option sets both the TX and RX CCIDs at the same time.dccp_tx_ccid/// Get the value of the `DCCP_SOCKOPT_TX_CCID` option on this socket./// For more information about this option see [`set_dccp_ccid`]./// [`set_dccp_ccid`]: crate::Socket::set_dccp_cciddccp_xx_ccid/// Get the value of the `DCCP_SOCKOPT_RX_CCID` option on this socket.set_dccp_server_timewait/// Set value for the `DCCP_SOCKOPT_SERVER_TIMEWAIT` option on this socket./// Enables a listening socket to hold timewait state when closing the/// connection. This option must be set after `accept` returns.dccp_server_timewait/// Get the value of the `DCCP_SOCKOPT_SERVER_TIMEWAIT` option on this socket./// For more information see [`set_dccp_server_timewait`]/// [`set_dccp_server_timewait`]: crate::Socket::set_dccp_server_timewaitset_dccp_send_cscov/// Set value for the `DCCP_SOCKOPT_SEND_CSCOV` option on this socket./// Both this option and `DCCP_SOCKOPT_RECV_CSCOV` are used for setting the/// partial checksum coverage. The default is that checksums always cover/// the entire packet and that only fully covered application data is/// accepted by the receiver. Hence, when using this feature on the sender,/// it must be enabled at the receiver too, with suitable choice of CsCov.dccp_send_cscov/// Get the value of the `DCCP_SOCKOPT_SEND_CSCOV` option on this socket./// For more information on this option see [`set_dccp_send_cscov`]./// [`set_dccp_send_cscov`]: crate::Socket::set_dccp_send_cscovset_dccp_recv_cscov/// Set the value of the `DCCP_SOCKOPT_RECV_CSCOV` option on this socket./// This option is only useful when combined with [`set_dccp_send_cscov`].dccp_recv_cscov/// Get the value of the `DCCP_SOCKOPT_RECV_CSCOV` option on this socket./// For more information on this option see [`set_dccp_recv_cscov`]./// [`set_dccp_recv_cscov`]: crate::Socket::set_dccp_recv_cscovset_dccp_qpolicy_txqlen/// Set value for the `DCCP_SOCKOPT_QPOLICY_TXQLEN` option on this socket./// This option sets the maximum length of the output queue. A zero value is/// interpreted as unbounded queue length.dccp_qpolicy_txqlen/// Get the value of the `DCCP_SOCKOPT_QPOLICY_TXQLEN` on this socket./// For more information on this option see [`set_dccp_qpolicy_txqlen`]./// [`set_dccp_qpolicy_txqlen`]: crate::Socket::set_dccp_qpolicy_txqlendccp_available_ccidsCcidEndpoints/// Get the value of the `DCCP_SOCKOPT_AVAILABLE_CCIDS` option on this socket./// Returns the list of CCIDs supported by the endpoint./// The parameter `N` is used to get the maximum number of supported/// endpoints. The [documentation] recommends a minimum of four at the time/// of writing./// [documentation]: https://www.kernel.org/doc/html/latest/networking/dccp.htmldccp_cur_mps/// Get the value of the `DCCP_SOCKOPT_GET_CUR_MPS` option on this socket./// This option retrieves the current maximum packet size (application/// payload size) in bytes.endpoints/// See [`Socket::dccp_available_ccids`].SO_PROTOCOL_INFOW// NOTE: `optname` is actually `i32`, but all constants are `u32`./// Returns the [`Protocol`] of this socket by checking the `SO_PROTOCOL_INFOW`/// [`Protocol`]: crate::Protocol/// Base64 as defined in RFC 4648 §4OriginalNoPadding/// Base64 as defined in RFC 4648 §4 but without paddingUrlSafe/// Base64 as defined in RFC 4648 §5UrlSafeNoPadding/// Base64 as defined in RFC 4648 §5 but without padding/// Supported variants of Base64 encoding/decoding/// Encodes a byte sequence as a Base64 string using the given variant./// Decodes a Base64 string into a byte sequence using the given variant./// Fails if the decoded length overflows/// or if `b64` contains invalid characters.//! Libsodium Base64 encoding/decoding helper functionsaead_module/// `is_available` returns true if the current CPU supports aes256gcm and false otherwise./// WARNING: You must call [init](crate::init) before calling this function; if you do not/// `is_available` will always return false even if the runtime supports aes256gcm.randombytesrandombytes_intor" Number of bytes in a `Key`."KEYBYTESr" Number of bytes in a `Nonce`."NONCEBYTESr" Number of bytes in an authentication `Tag`."TAGBYTESnew_typer" `Key` for symmetric authenticated encryption with additional data."r" When a `Key` goes out of scope its contents will"r" be zeroed out"newtype_clonenewtype_traitsr" Allows a user to access the byte contents of an object as a slice."r" WARNING: it might be tempting to do comparisons on objects"r" by using `x[a..b] == y[a..b]`. This will open up for timing attacks"r" when comparing for example authenticator tags. Because of this only"r" use the comparison functions exposed by the sodiumoxide API."r" by using `x[..b] == y[..b]`. This will open up for timing attacks"r" by using `x[a..] == y[a..]`. This will open up for timing attacks"r" by using `x[] == y[]`. This will open up for timing attacks"newtype_from_slicer" `from_slice()` creates an object from a byte slice"r" This function will fail and return `None` if the length of"r" the byte-slice isn't equal to the length of the object"r" `Nonce` for symmetric authenticated encryption with additional data."public_newtype_traitsr" `increment_le()` treats the nonce as an unsigned little-endian number and"r" returns an incremented version of it."r" WARNING: this method does not check for arithmetic overflow. It is the callers"r" responsibility to ensure that any given nonce value is only used once."r" If the caller does not do that the cryptographic primitives in sodiumoxide"r" will not uphold any security guarantees (i.e. they will break)"increment_ler" `increment_le_inplace()` treats the nonce as an unsigned little-endian number"r" and increments it."r" will not uphold any security guarantees."increment_le_inplacer" Authentication `Tag` for symmetric authenticated encryption with additional data in"r" detached mode."r" `gen_key()` randomly generates a secret key"r" THREAD SAFETY: `gen_key()` is thread-safe provided that you have"r" called `sodiumoxide::init()` once before using any other function"r" from sodiumoxide."gen_keyr" `seal()` encrypts and authenticates a message `m` together with optional plaintext data `ad`"r" using a secret key `k` and a nonce `n`. It returns a ciphertext `c`."r" `seal_detached()` encrypts and authenticates a message `m` together with optional plaintext data"r" `ad` using a secret key `k` and a nonce `n`."r" `m` is encrypted in place, so after this function returns it will contain the ciphertext."r" The detached authentication tag is returned by value."seal_detachedr" `open()` verifies and decrypts a ciphertext `c` together with optional plaintext data `ad`"r" using a secret key `k` and a nonce `n`."r" It returns a plaintext `Ok(m)`."r" If the ciphertext fails verification, `open()` returns `Err(())`."r" `open_detached()` verifies and decrypts a ciphertext `c` toghether with optional plaintext data"r" `ad` and and authentication tag `tag`, using a secret key `k` and a nonce `n`."r" `c` is decrypted in place, so if this function is successful it will contain the plaintext."r" If the ciphertext fails verification, `open_detached()` returns `Err(())`,"r" and the ciphertext is not modified."open_detachedgen_random_noncetest_seal_opentest_seal_open_tampertest_seal_open_detachedtest_seal_open_detached_tampertest_seal_open_detached_sametest_mtest_vector_1aes_impl/// The Aes256Gcm struct encapsulates the crypto_aead_aes256gcm_* family of/// functions in a way that ensures safe usage of the API at runtime/// without incurring a per function call cost./// Returns an `Ok` of [Aes256Gcm](self::Aes256Gcm) if the runtime/// supports AES and an `Err(_)` if it does not./// You must call [init](crate::init) before calling this function. Failure/// to do so will result in `Err(_)` being returned even if the runtime/// hardware supports AES.gen_initial_nonce/// `gen_initial_nonce` randomly generates an initial nonce/// WARNING: AES nonces are short enough that the probability of collision between two randomly/// generated nonces is nonnegligible and repeated nonce use will totally destroy the security/// of this scheme. Use [increment_le]( aes_impl::Nonce::increment_le) or/// [increment_le_inplace]( aes_impl::Nonce::increment_le_inplace) to increment a local nonce./// If you are operating in a multi threaded or distributed environment you must use a shared/// atomic counter protocol instead./// THREAD SAFETY: `gen_initial_nonce` is thread-safe provided that you have called/// [init](crate::init) once before using any other function from sodiumoxide./// `gen_key()` randomly generates a secret key/// THREAD SAFETY: `gen_key()` is thread-safe provided that you have/// called `sodiumoxide::init()` once before using any other function/// from sodiumoxide./// `open()` verifies and decrypts a ciphertext `c` together with optional plaintext data `ad`/// using a secret key `k` and a nonce `n`./// It returns a plaintext `Ok(m)`./// If the ciphertext fails verification, `open()` returns `Err(())`./// `open_detached()` verifies and decrypts a ciphertext `c` toghether with optional plaintext data/// `ad` and and authentication tag `tag`, using a secret key `k` and a nonce `n`./// `c` is decrypted in place, so if this function is successful it will contain the plaintext./// If the ciphertext fails verification, `open_detached()` returns `Err(())`,/// and the ciphertext is not modified./// `seal()` encrypts and authenticates a message `m` together with optional plaintext data `ad`/// using a secret key `k` and a nonce `n`. It returns a ciphertext `c`./// `seal_detached()` encrypts and authenticates a message `m` together with optional plaintext data/// `ad` using a secret key `k` and a nonce `n`./// `m` is encrypted in place, so after this function returns it will contain the ciphertext./// The detached authentication tag is returned by value.test_is_availableaes_api//! WARNING: Despite being the most popular AEAD construction due to its use in//! TLS, safely using AES-GCM in a different context is tricky. No more than//! ~ 350 GB of input data should be encrypted with a given key. This is for//! ~ 16 KB messages - actual figures vary according to message sizes.//! In addition, nonces are short and repeated nonces would totally destroy the//! security of this scheme. Nonces should thus come from atomic counters,//! which can be difficult to set up in a distributed environment.//! Unless you absolutely need AES-GCM, use the//! [default AEAD export](crate::crypto::aead)//! instead - it doesn't have any of these limitations. Or, if you don't need//! to authenticate additional data, just stick to [secretbox](crate::crypto::secretbox).//! AES primitives will not be made available unless your runtime CPU//! is x86/x86_64 with support for the AES-NI instruction set and the CLMUL//! instruction (Westmere and beyond).//! The original ChaCha20-Poly1305 construction can safely encrypt a pratically//! unlimited number of messages with the same key, without any practical limit//! to the size of a message (up to ~ 2^64 bytes).test_vector_2test_vector_3test_vector_4// Test vectors 2, 3, 4 sources are retrieved from libressl test files// https://fossies.org/linux/libressl/tests/aeadtests.txt//! The IETF variant of the ChaCha20-Poly1305 construction can safely encrypt a//! practically unlimited number of messages, but individual messages cannot//! exceed 64*(2^32)-64 bytes (approximatively 256 GB).xchacha20poly1305_ietfaead_macrosaes256gcmchacha20poly1305_ietf//! Authenticated Encryption with Additional Data//! This operation://! - Encrypts a message with a key and a nonce to keep it confidential//! - Computes an authentication tag. This tag is used to make sure that the message,//!   as well as optional, non-confidential (non-encrypted) data, haven't been tampered with.//! # Selected primitive//! `seal()`, `seal_detached()`, `open()` and `open_detached()` are currently//! an implementation of `chacha20poly1305_ietf`, i.e. the IETF construction defined in//! <https://tools.ietf.org/html/rfc7539>.//! # Example (combined mode)//! use sodiumoxide::crypto::aead;//! let k = aead::gen_key();//! let n = aead::gen_nonce();//! let m = b"Some plaintext";//! let ad = b"Some additional data";//! let c = aead::seal(m, Some(ad), &n, &k);//! let m2 = aead::open(&c, Some(ad), &n, &k).unwrap();//! assert_eq!(&m[..], &m2[..]);//! # Example (detached mode)//! let mut m = [0x41, 0x42, 0x43, 0x44];//! let m2 = m.clone();//! let t = aead::seal_detached(&mut m, Some(ad), &n, &k);//! aead::open_detached(&mut m, Some(ad), &t, &n, &k).unwrap();//! assert_eq!(m, m2);gen_nonce/// `gen_nonce` randomly generates a nonce/// THREAD SAFETY: `gen_nonce()` is thread-safe provided that you havetest_nonce_length//! The XChaCha20-Poly1305 construction can safely encrypt a practically//! to the size of the message (up to ~ 2^64 bytes).//! As an alternative to counters, its large nonce size (192-bit) allows random//! nonces to be safely used//! For this reason, and if interoperability with other libraries is not a//! concern, this is the recommended AEAD construction.auth_moduleauth_state/// Macro for defining streaming authenticator tag computation types and functions./// $state_name - The authenticator state type.///               SAFETY NOTE: This needs to be a type that does not define a `Drop`///               implementation, otherwise undefined behaviour will occur./// $init_name - A function `f(s: *mut $state_name, k: *u8, klen: size_t)` that initializes///              a state with a key./// $update_name - A function `f(s: *mut $state_name, m: *u8, mlen: size_t)` that updates///                a state with a message chunk./// $final_name - A function `f(s: *mut $state_name, t: *u8)` that computes an authenticator tag of length $tagbytes from a $state_name./// $tagbytes   - The number of bytes in an authenticator tag.r" Number of bytes in a `Tag`."r" Authentication `Key`"r" When a `Key` goes out of scope its contents"r" will be zeroed out"r" Authentication `Tag`"r" The tag implements the traits `PartialEq` and `Eq` using constant-time"r" comparison functions. See `sodiumoxide::utils::memcmp`"r" `gen_key()` randomly generates a key for authentication"r" `authenticate()` authenticates a message `m` using a secret key `k`."r" The function returns an authenticator tag."r" `verify()` returns `true` if `tag` is a correct authenticator of message `m`"r" under a secret key `k`. Otherwise it returns false."test_auth_verifytest_auth_verify_tampertest_serialisationr" Authentication `State`"r" State for multi-part (streaming) authenticator tag (HMAC) computation."r" When a `State` goes out of scope its contents will be zeroed out."r" NOTE: the streaming interface takes variable length keys, as opposed to the"r" simple interface which takes a fixed length key. The streaming interface also does not"r" define its own `Key` type, instead using slices for its `init()` method."r" The caller of the functions is responsible for zeroing out the key after it's been used"r" (in contrast to the simple interface which defines a `Drop` implementation for `Key`)."r" NOTE: these functions are specific to `libsodium` and do not exist in `NaCl`."r" `init()` initializes an authentication structure using a secret key 'k'."r" `update()` can be called more than once in order to compute the authenticator"r" from sequential chunks of the message."r" `finalize()` finalizes the authenticator computation and returns a `Tag`. `finalize`"r" consumes the `State` so that it cannot be accidentally reused."test_auth_eq_auth_statetest_auth_eq_auth_state_chunkedtest_stest_vector_state_1//! `HMAC-SHA-256` `HMAC-SHA-256` is conjectured to meet the standard notion of//! unforgeability.//! `HMAC-SHA-512` `HMAC-SHA-512` is conjectured to meet the standard notion of//! `HMAC-SHA-512-256`, i.e., the first 256 bits of//! `HMAC-SHA-512`.  `HMAC-SHA-512-256` is conjectured to meet the standard notion//! of unforgeability.hmacsha512256auth_macrosauth_state_macroshmacsha256hmacsha512//! Secret-key authentication//! # Security model//! The `authenticate()` function, viewed as a function of the//! message for a uniform random key, is designed to meet the standard//! notion of unforgeability. This means that an attacker cannot find//! authenticators for any messages not authenticated by the sender, even if//! the attacker has adaptively influenced the messages authenticated by the//! sender. For a formal definition see, e.g., Section 2.4 of Bellare,//! Kilian, and Rogaway, "The security of the cipher block chaining message//! authentication code," Journal of Computer and System Sciences 61 (2000),//! 362–399; <http://www-cse.ucsd.edu/~mihir/papers/cbc.html>.//! `NaCl` does not make any promises regarding "strong" unforgeability;//! perhaps one valid authenticator can be converted into another valid//! authenticator for the same message. `NaCl` also does not make any promises//! regarding "truncated unforgeability."//! `authenticate()` is currently an implementation of//! `HMAC-SHA-512-256`, i.e., the first 256 bits of `HMAC-SHA-512`.//! `HMAC-SHA-512-256` is conjectured to meet the standard notion of//! # Alternate primitives//! `NaCl` supports the following secret-key authentication functions://! -----------------------------------------------------------------//! |`crypto_auth`               |primitive          |BYTES|KEYBYTES|//! |----------------------------|-------------------|-----|--------|//! |`crypto_auth_hmacsha256`    |`HMAC_SHA-256`     |32   |32      |//! |`crypto_auth_hmacsha512256` |`HMAC_SHA-512-256` |32   |32      |//! |`crypto_auth_hmacsha512`    |`HMAC_SHA-512`     |64   |32      |//! # Example (simple interface)//! use sodiumoxide::crypto::auth;//! let key = auth::gen_key();//! let data_to_authenticate = b"some data";//! let tag = auth::authenticate(data_to_authenticate, &key);//! assert!(auth::verify(&tag, data_to_authenticate, &key));//! # Example (streaming interface)//! use sodiumoxide::randombytes;//! let key = randombytes::randombytes(123);//! let data_part_1 = b"some data";//! let data_part_2 = b"some other data";//! let mut state = auth::State::init(&key);//! state.update(data_part_1);//! state.update(data_part_2);//! let tag1 = state.finalize();//! let data_2_part_1 = b"some datasome ";//! let data_2_part_2 = b"other data";//! state.update(data_2_part_1);//! state.update(data_2_part_2);//! let tag2 = state.finalize();//! assert_eq!(tag1, tag2);SEEDBYTES/// Number of bytes in a `Seed`.PUBLICKEYBYTES/// Number of bytes in a `PublicKey`.SECRETKEYBYTES/// Number of bytes in a `SecretKey`./// Number of bytes in a `Nonce`.PRECOMPUTEDKEYBYTES/// Number of bytes in a `PrecomputedKey`.MACBYTES/// Number of bytes in the authenticator tag of an encrypted message/// i.e. the number of bytes by which the ciphertext is larger than the/// plaintext.r" `Seed` that can be used for keypair generation"r" The `Seed` is used by `keypair_from_seed()` to generate"r" a secret and public authenticated encryption key."r" When a `Seed` goes out of scope its contents"r" `SecretKey` for asymmetric authenticated encryption"r" When a `SecretKey` goes out of scope its contents"r" `PublicKey` for asymmetric authenticated encryption"/// `public_key()` computes the corresponding public key for a given secret keyr" Authentication `Tag` for the detached encryption mode"r" In the combined mode, the tag occupies the first MACBYTES bytes of the ciphertext."r" `Nonce` for asymmetric authenticated encryption"gen_keypair/// `gen_keypair()` randomly generates a secret key and a corresponding public key./// THREAD SAFETY: `gen_keypair()` is thread-safe provided that you havekeypair_from_seed/// `key_pair_from_seed()` deterministically derives a key pair from a single key seed (crypto_box_SEEDBYTES bytes)./// THREAD SAFETY: `key_pair_from_seed()` is thread-safe provided that you have/// `gen_nonce()` randomly generates a nonce/// `seal()` encrypts and authenticates a message `m` using the senders secret key `sk`,/// the receivers public key `pk` and a nonce `n`. It returns a ciphertext `c`./// `seal_detached()` encrypts and authenticates a message `m` using the senders secret key `sk`,/// the receivers public key `pk` and a nonce `n`. `m` is encrypted in place, so after this/// function returns it will contain the ciphertext. The detached authentication tag is returned by/// `open()` verifies and decrypts a ciphertext `c` using the receiver's secret key `sk`,/// the senders public key `pk`, and a nonce `n`. It returns a plaintext `Ok(m)`./// `open_detached()` verifies and decrypts a ciphertext `c` using the receiver's secret key `sk`,/// the senders public key `pk`, and a nonce `n`. `c` is decrypted in place, so if this function is/// successful it will contain the plaintext. If the ciphertext fails verification,/// `open_detached()` returns `Err(())`, and the ciphertext is not modified.r" Applications that send several messages to the same receiver can gain speed by"r" splitting `seal()` into two steps, `precompute()` and `seal_precomputed()`."r" Similarly, applications that receive several messages from the same sender can gain"r" speed by splitting `open()` into two steps, `precompute()` and `open_precomputed()`."r" When a `PrecomputedKey` goes out of scope its contents will be zeroed out"PrecomputedKeyprecompute/// `precompute()` computes an intermediate key that can be used by `seal_precomputed()`/// and `open_precomputed()`seal_precomputed/// `seal_precomputed()` encrypts and authenticates a message `m` using a precomputed key `k`,/// and a nonce `n`. It returns a ciphertext `c`.seal_detached_precomputed/// `seal_detached_precomputed()` encrypts and authenticates a message `m` using a precomputed key/// `k` and a nonce `n`. `m` is encrypted in place, so after this function returns it will contain/// the ciphertext. The detached authentication tag is returned by value.open_precomputed/// `open_precomputed()` verifies and decrypts a ciphertext `c` using a precomputed/// key `k` and a nonce `n`. It returns a plaintext `Ok(m)`./// If the ciphertext fails verification, `open_precomputed()` returns `Err(())`.open_detached_precomputed/// `open_detached_precomputed()` verifies and decrypts a ciphertext `c` using a precomputed key/// `k` and a nonce `n`. `c` is decrypted in place, so if this function is successful it will/// contain the plaintext. If the ciphertext fails verification, `open_detached()` returns/// `Err(())`, and the ciphertext is not modified.test_seal_open_precomputedtest_seal_open_precomputed_tampertest_seal_open_seedtest_seal_open_seed_tampertest_seal_combined_then_open_detachedtest_seal_detached_then_open_combinedtest_open_detached_failure_does_not_modifytest_seal_open_detached_precomputedtest_seal_combined_then_open_detached_precomputedtest_seal_detached_precomputed_then_open_combinedtest_seal_open_detached_precomputed_tampertest_open_detached_precomputed_failure_does_not_modifytest_public_key//! `crypto_box_curve25519xsalsa20poly1305` , a particular//! combination of Curve25519, Salsa20, and Poly1305 specified in//! [Cryptography in `NaCl`](http://nacl.cr.yp.to/valid.html).//! This function is conjectured to meet the standard notions of privacy and//! third-party unforgeability.curve25519xsalsa20poly1305//! Public-key authenticated encryption//! The `seal()` function is designed to meet the standard notions of privacy and//! third-party unforgeability for a public-key authenticated-encryption scheme//! using nonces. For formal definitions see, e.g., Jee Hea An, "Authenticated//! encryption in the public-key setting: security notions and analyses,"//! <http://eprint.iacr.org/2001/079>.//! Distinct messages between the same {sender, receiver} set are required//! to have distinct nonces. For example, the lexicographically smaller//! public key can use nonce 1 for its first message to the other key, nonce//! 3 for its second message, nonce 5 for its third message, etc., while the//! lexicographically larger public key uses nonce 2 for its first message//! to the other key, nonce 4 for its second message, nonce 6 for its third//! message, etc. Nonces are long enough that randomly generated nonces have//! negligible risk of collision.//! There is no harm in having the same nonce for different messages if the//! {sender, receiver} sets are different. This is true even if the sets//! overlap. For example, a sender can use the same nonce for two different//! messages if the messages are sent to two different public keys.//! The `seal()` function is not meant to provide non-repudiation. On the//! contrary: the `seal()` function guarantees repudiability. A receiver//! can freely modify a boxed message, and therefore cannot convince third//! parties that this particular message came from the sender. The sender//! and receiver are nevertheless protected against forgeries by other//! parties. In the terminology of//! <http://groups.google.com/group/sci.crypt/msg/ec5c18b23b11d82c>,//! crypto_box uses "public-key authenticators" rather than "public-key//! signatures."//! Users who want public verifiability (or receiver-assisted public//! verifiability) should instead use signatures (or signcryption).//! Signature support is a high priority for `NaCl`; a signature API will be//! described in subsequent `NaCl` documentation.//! `seal()` is `crypto_box_curve25519xsalsa20poly1305` , a particular//! use sodiumoxide::crypto::box_;//! let (ourpk, oursk) = box_::gen_keypair();//! // normally theirpk is sent by the other party//! let (theirpk, theirsk) = box_::gen_keypair();//! let nonce = box_::gen_nonce();//! let plaintext = b"some data";//! let ciphertext = box_::seal(plaintext, &nonce, &theirpk, &oursk);//! let their_plaintext = box_::open(&ciphertext, &nonce, &ourpk, &theirsk).unwrap();//! assert!(plaintext == &their_plaintext[..]);//! # Example (precomputation interface)//! let our_precomputed_key = box_::precompute(&theirpk, &oursk);//! let plaintext = b"plaintext";//! let ciphertext = box_::seal_precomputed(plaintext, &nonce, &our_precomputed_key);//! // this will be identical to our_precomputed_key//! let their_precomputed_key = box_::precompute(&ourpk, &theirsk);//! let their_plaintext = box_::open_precomputed(&ciphertext, &nonce,//!                                              &their_precomputed_key).unwrap();/// Digest-structure/// This structure contains a fixed sized array as a buffer and a length to/// represent dynamic sized digest outputs./// Allows a user to access the byte contents of an object as a slice./// WARNING: it might be tempting to do comparisons on objects/// by using `x[a..b] == y[a..b]`. This will open up for timing attacks/// when comparing for example authenticator tags. Because of this only/// use the comparison functions exposed by the sodiumoxide API./// by using `x[..b] == y[..b]`. This will open up for timing attacks/// by using `x[a..] == y[a..]`. This will open up for timing attacks/// by using `x[] == y[]`. This will open up for timing attacksDIGEST_MIN/// Minimium of allowed bytes in a `Digest`DIGEST_MAX/// Maximum of allowed bytes in a `Digest`KEY_MIN/// Minimium of allowed bytes in a key/// Maximum of allowed bytes in a key/// `State` contains the state for multi-part (streaming) hash computations. This allows the caller/// to process a message as a sequence of multiple chunks./// `new` constructs and initializes a new `State` with the given parameters./// `out_len` specifies the resulting hash size./// Only values in the interval [`DIGEST_MIN`, `DIGEST_MAX`] are allowed./// If omitted, a minimum recommended output size is used which makes it/// practically impossible for two messages to produce the same fingerprint./// `key` is an optional parameter, which when given,/// a custom key can be used for the computation of the hash./// The size of the key must be in the interval [`KEY_MIN`, `KEY_MAX`]./// `update` updates the `State` with `data`. `update` can be called multiple times in order/// to compute the hash from sequential chunks of the message./// `finalize` finalizes the state and returns the digest value. `finalize` consumes the/// `State` so that it cannot be accidentally reused./// `hash` computes a fingerprint of `data`.unwrap_out_lentest_blake2b_vectorstest_digest_equaltest_digest_not_equal//! `GenericHash`.hash_modulehash_macros//! Hashing//! The `hash()` function is designed to be usable as a strong//! component of DSA, RSA-PSS, key derivation, hash-based//! message-authentication codes, hash-based ciphers, and various other//! common applications.  "Strong" means that the security of these//! applications, when instantiated with `hash()`, is the same//! as the security of the applications against generic attacks. In//! particular, the `hash()` function is designed to make//! finding collisions difficult.//! `hash()` is currently an implementation of `SHA-512`.//! There has been considerable degradation of public confidence in the//! security conjectures for many hash functions, including `SHA-512`.//! However, for the moment, there do not appear to be alternatives that//! inspire satisfactory levels of confidence. One can hope that NIST's//! SHA-3 competition will improve the situation.//! `NaCl` supports the following hash functions://! -----------------------------------------//! |`crypto_hash`        |primitive |BYTES |//! |---------------------|----------|------|//! |`crypto_hash_sha256` |`SHA-256` |32    |//! |`crypto_hash_sha512` |`SHA-512` |64    |//! use sodiumoxide::crypto::hash;//! let data_to_hash = b"some data";//! let digest = hash::hash(data_to_hash);//! let mut hash_state = hash::State::new();//! hash_state.update(b"some ");//! hash_state.update(b"data!");//! let digest = hash_state.finalize();r" Number of bytes in a `Digest`."DIGESTBYTESr" Block size of the hash function."BLOCKBYTESr" Digest-structure"r" `hash` hashes a message `m`. It returns a hash `h`."r" `State` contains the state for multi-part (streaming) hash computations. This allows the caller"r" to process a message as a sequence of multiple chunks."r" `new` constructs and initializes a new `State`."r" `update` updates the `State` with `data`. `update` can be called multiple times in order"r" to compute the hash from sequential chunks of the message."r" `finalize` finalizes the state and returns the digest value. `finalize` consumes the"r" `State` so that it cannot be accidentally reused."test_hash_multiparttest_nist_vectortest_vectors_nist_shorttest_vectors_nist_longtest_hash_state_emptytest_hash_state_multi_parts//! `SHA-256`.//! security conjectures for many hash functions, including `SHA-256`.//! `SHA-512`./// Number of bytes in a `Key`.CONTEXTBYTES/// Number of bytes in a `Context`BYTES_MIN/// Minimum number of bytes in a subkey.BYTES_MAX/// Maximum number of bytes in a subkey.r" `Key` for key derivation."/// `gen_key()` randomly generates a key for key derivation.derive_from_key/// `derive_from_key` derives the subkey_id-th subkey from the master key `key` and the context `ctx`/// Fails if the length of subkey is not within the bounds given by `BYTES_MIN` and `BYTES_MAX`.test_gen_keytest_keysize_out_of_bounds//! `blake2b` is the current default key derivation scheme of `libsodium`.blake2b//! Key derivation//! Multiple secret subkeys can be derived from a single master key. Given the master key and a key//! identifier, a subkey can be deterministically computed. However, given a subkey, an attacker//! cannot compute the master key nor any other subkeys.//! This API was introduced in libsodium 1.0.12//! use sodiumoxide::crypto::kdf;//! use sodiumoxide::crypto::secretbox;//! const CONTEXT: [u8; 8] = *b"Examples";//! let key = kdf::gen_key();//! let mut key1 = secretbox::Key([0; secretbox::KEYBYTES]);//! kdf::derive_from_key(&mut key1.0[..], 1, CONTEXT, &key).unwrap();//! let mut key2 = secretbox::Key([0; secretbox::KEYBYTES]);//! kdf::derive_from_key(&mut key2.0[..], 2, CONTEXT, &key).unwrap();//! let mut key3 = secretbox::Key([0; secretbox::KEYBYTES]);//! kdf::derive_from_key(&mut key3.0[..], 3, CONTEXT, &key).unwrap();x25519blake2b//! Key exchange//! Using the key exchange API, two parties can securely compute a set of shared keys using their//! peer's public key and their own secret key.//! This API was introduced in libsodium 1.0.12.//! use sodiumoxide::crypto::kx;//! // client-side//! let (client_pk, client_sk) = kx::gen_keypair();//! // server-side//! let (server_pk, server_sk) = kx::gen_keypair();//! // client and server exchanges client_pk and server_pk//! // client deduces the two session keys rx1 and tx1//! let (rx1, tx1) = match kx::client_session_keys(&client_pk, &client_sk, &server_pk) {//!     Ok((rx, tx)) => (rx, tx),//!     Err(()) => panic!("bad server signature"),//! // server performs the same operation//! let (rx2, tx2) = match kx::server_session_keys(&server_pk, &server_sk, &client_pk) {//!     Err(()) => panic!("bad client signature"),//! assert!(rx1==tx2);//! assert!(rx2==tx1);SESSIONKEYBYTES/// Number of bytes in a `SessionKey`.r" `PublicKey` for key exchanges."r" `SecretKey` for key exchanges."r" When a `SecretKey` goes out of scope its contents will be zeroed out"r" The `Seed` is used by `keypair_from_seed()` to generate a secret and"r" public signature key."r" When a `Seed` goes out of scope its content will be zeroed out"r" `SessionKey` is returned by `client_session_keys` and `server_session_keys` and is the"r" exchanged secret between the client and server."SessionKey/// `gen_keypair()` randomly generates a secret key and a corresponding public/// `keypair_from_seed()` computes a secret key and a corresponding public key/// from a `Seed`.server_session_keys/// `server_session_keys()` computes a pair of shared keys (rx and tx) using the server's public/// key `server_pk`, the server's secret key `server_sk` and the client's public key `client_pk`./// If the client's public key is acceptable, it returns the two shared keys, the first for `rx`/// and the second for `tx`. Otherwise, it returns `None`.client_session_keys/// `client_session_keys()` computes a pair of shared keys (rx and tx) using the client's public/// key `client_pk`, the client's secret key `client_sk` and the server's public key `server_pk`./// If the server's public key is acceptable, it returns the two shared keys, the first for `rx`test_kxtest_kx_non_acceptable_keys//! `x25519blake2b` is the current default key exchange scheme of `libsodium`./// The `Nonce` trait allows for generic construction/// from an array of bytes, e.g. to generically create random nonces./// `gen_random_nonce()` randomly generates a nonce for symmetric encryption/// THREAD SAFETY: `gen_random_nonce()` is thread-safe provided that you have/// NOTE: When using primitives with short nonces (e.g. salsa20, salsa208, salsa2012)/// do not use random nonces since the probability of nonce-collision is not negligible"../auth/auth_macros.rs"//! Secret-key One-time authentication//! The `authenticate()` function, viewed as a function//! of the message for a uniform random key, is designed to meet the//! standard notion of unforgeability after a single message. After the//! sender authenticates one message, an attacker cannot find authenticators//! for any other messages.//! The sender must not use `authenticate()` to authenticate more than one message//! under the same key. Authenticators for two messages under the same key should//! be expected to reveal enough information to allow forgeries of authenticators//! on other messages.//! `authenticate()` is `crypto_onetimeauth_poly1305`, an authenticator specified//! in [Cryptography in `NaCl`](http://nacl.cr.yp.to/valid.html), Section 9. This//! authenticator is proven to meet the standard notion of unforgeability after a//! single message.//! use sodiumoxide::crypto::onetimeauth;//! let key = onetimeauth::gen_key();//! let tag = onetimeauth::authenticate(data_to_authenticate, &key);//! assert!(onetimeauth::verify(&tag, data_to_authenticate, &key));//! `crypto_onetimeauth_poly1305`, an authenticator specifiedargon2_moduler" Number of bytes in a `Salt`."SALTBYTESr" Number of bytes in a `HashedPassword`."HASHEDPASSWORDBYTESr" All `HashedPasswords` start with this string."STRPREFIXr" Safe base line for `OpsLimit` for interactive password hashing."OPSLIMIT_INTERACTIVEOpsLimitr" Safe base line for `MemLimit` for interactive password hashing."MEMLIMIT_INTERACTIVEMemLimitr" `OpsLimit` for moderately sensitive data."OPSLIMIT_MODERATEr" `MemLimit` for moderately sensitive data."MEMLIMIT_MODERATEr" `OpsLimit` for highly sensitive data."OPSLIMIT_SENSITIVEr" `MemLimit` for highly sensitive data."MEMLIMIT_SENSITIVEr" Variant id for the Argon2i13 algorithm"r" `OpsLimit` represents the maximum number of computations to perform when"r" using the functions in this module."r" A high `OpsLimit` will make the functions"r" require more CPU cycles"r" `MemLimit` represents the maximum amount of RAM that the functions in this"r" module will use, in bytes."r" It is highly recommended to allow the functions to use"r" at least 16 megabytes."r" `Salt` used for password hashing"r" `HashedPassword`is a password verifier generated from a password"r" A `HashedPassword` is zero-terminated, includes only ASCII characters and can"r" be conveniently stored into SQL databases and other data stores. No"r" additional information has to be stored in order to verify the password."HashedPasswordr" `gen_salt()` randomly generates a new `Salt` for key derivation"r" THREAD SAFETY: `gen_salt()` is thread-safe provided that you have called"r" `sodiumoxide::init()` once before using any other function from sodiumoxide."gen_saltr" The `derive_key()` function derives a key from a password and a `Salt`"r" The computed key is stored into key."r" `opslimit` represents a maximum amount of computations to perform. Raising"r" this number will make the function require more CPU cycles to compute a key."r" `memlimit` is the maximum amount of RAM that the function will use, in"r" bytes. It is highly recommended to allow the function to use at least 16"r" megabytes."r" For interactive, online operations, `OPSLIMIT_INTERACTIVE` and"r" `MEMLIMIT_INTERACTIVE` provide a safe base line for these two"r" parameters. However, using higher values may improve security."r" For highly sensitive data, `OPSLIMIT_SENSITIVE` and `MEMLIMIT_SENSITIVE` can"r" be used as an alternative. But with these parameters, deriving a key takes"r" more than 10 seconds on a 2.8 Ghz Core i7 CPU and requires up to 1 gigabyte"r" of dedicated RAM."r" The salt should be unpredictable. `gen_salt()` is the easiest way to create a `Salt`."r" Keep in mind that in order to produce the same key from the same password,"r" the same salt, and the same values for opslimit and memlimit have to be"r" used."r" The function returns `Ok(key)` on success and `Err(())` if the computation didn't"r" complete, usually because the operating system refused to allocate the"r" amount of requested memory."derive_keyr" The `pwhash()` returns a `HashedPassword` which"r" includes:"r" - the result of a memory-hard, CPU-intensive hash function applied to the password"r"   `passwd`"r" - the automatically generated salt used for the"r"   previous computation"r" - the other parameters required to verify the password: opslimit and memlimit"r" `OPSLIMIT_INTERACTIVE` and `MEMLIMIT_INTERACTIVE` are safe baseline"r" values to use for `opslimit` and `memlimit`."r" The function returns `Ok(hashed_password)` on success and `Err(())` if it didn't complete"r" successfully"pwhashr" `pwhash_verify()` verifies that the password `str_` is a valid password"r" verification string (as generated by `pwhash()`) for `passwd`"r" It returns `true` if the verification succeeds, and `false` on error."pwhash_verifyrun_derive_key_test/// Helper function to allow for testing derive_key with different configurationsto_hashed_password/// Converts a str into a hashed password structtest_pwhash_verifytest_pwhash_verify_tampertest_derive_01test_derive_02test_derive_03test_derive_04test_derive_05test_derive_06test_derive_07test_derive_08test_derive_09test_derive_10test_verify_1test_verify_2test_verify_3test_verify_4test_hash_1test_hash_2test_hash_3//! Argon2 summarizes the state of the art in the design of memory-hard functions.//! It aims at the highest memory filling rate and effective use of multiple//! computing units, while still providing defense against tradeoff attacks.//! It prevents ASICs from having a significant advantage over software//! Argon2i uses data-independent memory access, which is preferred for//! password hashing and password-based key derivation. Argon2i is//! invulnerable to side-channel timing attacks but weaker against//! Time-memory Tradeoff (TMTO) attacks.  If you are unsure which//! Argon2 variant to use, use Argon2id, not this module.//! Note: libsodium provides a limited version of the Argon2 function. The salt//! parameter is fixed at 128 bits and the parallelism parameter is fixed to 1.test_verify_5test_verify_6//! Argon2id provides a hybrid implementation, selecting the best features//! of Argon2i (with resistance to side-channel attackes) and Argon2d (with//! resistance to time-memory tradeoff (TMTO) attacks).  If you are unsure//! of which Argon2 variant to use, use this one.scryptsalsa208sha256argon2_macrosargon2i13argon2id13//! Password Hashing//! Secret keys used to encrypt or sign confidential data have to be chosen from//! a very large keyspace. However, passwords are usually short, human-generated//! strings, making dictionary attacks practical.//! The pwhash operation derives a secret key of any size from a password and a//! salt.//! - The generated key has the size defined by the application, no matter what//!   the password length is.//! - The same password hashed with same parameters will//!   always produce the same key.//! - The same password hashed with different salts//!   will produce different keys.//! - The function deriving a key from a password//!   and a salt is CPU intensive and intentionally requires a fair amount of//!   memory. Therefore, it mitigates brute-force attacks by requiring a//!   significant effort to verify each password.//! Common use cases://! - Protecting an on-disk secret key with a password,//! - Password storage, or rather: storing what it takes to verify a password//!   without having to store the actual password.//! # Example (key derivation)//! use sodiumoxide::crypto::pwhash;//! let passwd = b"Correct Horse Battery Staple";//! let salt = pwhash::gen_salt();//! let mut k = secretbox::Key([0; secretbox::KEYBYTES]);//!     let secretbox::Key(ref mut kb) = k;//!     pwhash::derive_key(kb, passwd, &salt,//!                        pwhash::OPSLIMIT_INTERACTIVE,//!                        pwhash::MEMLIMIT_INTERACTIVE).unwrap();//! # Example (password hashing)//! let pwh = pwhash::pwhash(passwd,//!                          pwhash::OPSLIMIT_INTERACTIVE,//!                          pwhash::MEMLIMIT_INTERACTIVE).unwrap();//! let pwh_bytes = pwh.as_ref();//! //store pwh_bytes somewhere//! # Example (password verification)//! // in reality we want to load the password hash from somewhere//! // and we might want to create a `HashedPassword` from it using//! // `HashedPassword::from_slice(pwhash_bytes).unwrap()`//! assert!(pwhash::pwhash_verify(&pwh, passwd));/// Number of bytes in a `Salt`./// Number of bytes in a `HashedPassword`./// All `HashedPasswords` start with this string./// Safe base line for `OpsLimit` for interactive password hashing./// Safe base line for `MemLimit` for interactive password hashing./// `OpsLimit` for highly sensitive data./// `MemLimit` for highly sensitive data./// `OpsLimit` represents the maximum number of computations to perform when/// using the functions in this module./// A high `OpsLimit` will make the functions/// require more CPU cycles/// `MemLimit` represents the maximum amount of RAM that the functions in this/// module will use, in bytes./// It is highly recommended to allow the functions to use/// at least 16 megabytes./// `gen_salt()` randombly generates a new `Salt` for key derivation/// THREAD SAFETY: `gen_salt()` is thread-safe provided that you have called/// `sodiumoxide::init()` once before using any other function from sodiumoxide./// The `derive_key()` function derives a key from a password and a `Salt`/// The computed key is stored into key./// `opslimit` represents a maximum amount of computations to perform. Raising/// this number will make the function require more CPU cycles to compute a key./// `memlimit` is the maximum amount of RAM that the function will use, in/// bytes. It is highly recommended to allow the function to use at least 16/// megabytes./// For interactive, online operations, `OPSLIMIT_INTERACTIVE` and/// `MEMLIMIT_INTERACTIVE` provide a safe base line for these two/// parameters. However, using higher values may improve security./// For highly sensitive data, `OPSLIMIT_SENSITIVE` and `MEMLIMIT_SENSITIVE` can/// be used as an alternative. But with these parameters, deriving a key takes/// more than 10 seconds on a 2.8 Ghz Core i7 CPU and requires up to 1 gigabyte/// of dedicated RAM./// The salt should be unpredictable. `gen_salt()` is the easiest way to create a `Salt`./// Keep in mind that in order to produce the same key from the same password,/// the same salt, and the same values for opslimit and memlimit have to be/// The function returns `Ok(key)` on success and `Err(())` if the computation didn't/// complete, usually because the operating system refused to allocate the/// amount of requested memory.derive_key_interactive/// `derive_key_interactive()` is a shortcut function for `derive_key()` with/// interactive limits (i.e. using `derive_key()` with `OPSLIMIT_INTERACTIVE`/// and `MEMLIMIT_INTERACTIVE`)derive_key_sensitive/// `derive_key_sensitive()` is a shortcut function for `derive_key()` with/// sensitive limits (i.e. using `derive_key()` with `OPSLIMIT_SENSITIVE`/// and `MEMLIMIT_SENSITIVE`)/// The `pwhash()` returns a `HashedPassword` which/// includes:/// - the result of a memory-hard, CPU-intensive hash function applied to the password///   `passwd`/// - the automatically generated salt used for the///   previous computation/// - the other parameters required to verify the password: opslimit and memlimit/// `OPSLIMIT_INTERACTIVE` and `MEMLIMIT_INTERACTIVE` are safe baseline/// values to use for `opslimit` and `memlimit`./// The function returns `Ok(hashed_password)` on success and `Err(())` if it didn't complete/// successfullypwhash_interactive/// `pwhash_interactive()` is a shortcut function for `pwhash()` with/// interactive limits (i.e. using `pwhash()` with `OPSLIMIT_INTERACTIVE`pwhash_sensitive/// `pwhash_sensitive()` is a shortcut function for `pwhash()` with/// sensitive limits (i.e. using `pwhash()` with `OPSLIMIT_SENSITIVE`/// `pwhash_verify()` verifies that the password `str_` is a valid password/// verification string (as generated by `pwhash()`) for `passwd`/// It returns `true` if the verification succeeds, and `false` on error.test_derive_key//! `crypto_pwhash_scryptsalsa208sha256`, a particular combination of Scrypt, Salsa20/8//! and SHA-256GROUPELEMENTBYTES/// Number of bytes in a `GroupElement`.SCALARBYTES/// Number of bytes in a `Scalar`.r" `Scalar` value (integer in byte representation)"r" `GroupElement`"GroupElementscalarmult/// `scalarmult()` multiplies a group element `p`/// by an integer `n`. It returns the resulting group element `Ok(q)`./// If the the `GroupElement` is all zero, `scalarmult()` returns `Err(())` since/// the resulting `GroupElement` would be all zero, no matter the `Scalar`.scalarmult_base/// `scalarmult_base()` computes the scalar product of a standard/// group element and an integer `n`. It returns the resulting/// group element `q`/test_all_zero//! `crypto_scalarmult_curve25519` specified in//! [Cryptography in `NaCl`](http://nacl.cr.yp.to/valid.html), Sections 2, 3, and 4.//! This function is conjectured to be strong. For background see Bernstein,//! "Curve25519: new Diffie-Hellman speed records," Lecture Notes in Computer//! Science 3958 (2006), 207–228, <http://cr.yp.to/papers.html#curve25519>.//! Scalar multiplication//! # Representation of group elements//! The correspondence between strings and group elements depends on the primitive//! implemented by `scalarmult()`. The correspondence is not necessarily//! injective in either direction, but it is compatible with scalar multiplication//! in the group. The correspondence does not necessarily include all group//! elements, but it does include all strings; i.e., every string represents at//! least one group element.//! # Representation of integers//! The correspondence between strings and integers also depends on the primitive//! implemented by `scalarmult()`. Every string represents at least one integer.//! `scalarmult` is designed to be strong as a component of various well-known//! "hashed Diffie–Hellman" applications. In particular, it is designed to make the//! "computational Diffie–Hellman" problem (CDH) difficult with respect to the//! standard base.//! `scalarmult` is also designed to make CDH difficult with respect to other//! nontrivial bases. In particular, if a represented group element has small//! order, then it is annihilated by all represented scalars. This feature allows//! protocols to avoid validating membership in the subgroup generated by the//! `NaCl` does not make any promises regarding the "decisional Diffie–Hellman"//! problem (DDH), the "static Diffie–Hellman" problem (SDH), etc. Users are//! responsible for hashing group elements.//! `scalarmult` is the function `crypto_scalarmult_curve25519` specified inSEALBYTES/// Number of additional bytes in a ciphertext compared to the corresponding/// The `seal()` function encrypts a message `m` for a recipient whose public key/// is `pk`. It returns the ciphertext whose length is `SEALBYTES + m.len()`./// The function creates a new key pair for each message, and attaches the public/// key to the ciphertext. The secret key is overwritten and is not accessible/// after this function returns./// The `open()` function decrypts the ciphertext `c` using the key pair `(pk, sk)`/// and returns the decrypted message./// Key pairs are compatible with other/// `crypto::box_::curve25519xsalsa20poly1305` operations and can be created/// using `crypto::box::gen_keypair()`./// This function doesn't require passing the public key of the sender, as the/// ciphertext already includes this information./// If decryption fails it returns `Err(())`.//! A particular combination of `Curve25519`, `Blake2B`, `XSalsa20` and `Poly1305`.curve25519blake2bxsalsa20poly1305//! Sealed Boxes//! # Purpose//! Sealed boxes are designed to anonymously send messages to a recipient given//! its public key.//! Only the recipient can decrypt these messages, using its private key. While//! the recipient can verify the integrity of the message, it cannot verify the//! identity of the sender.//! A message is encrypted using an ephemeral key pair, whose secret part is//! destroyed right after the encryption process.//! Without knowing the secret key used for a given message, the sender cannot//! decrypt its own message later. And without additional data, a message//! cannot be correlated with the identity of its sender.//! Sealed boxes leverage the `crypto_box` construction (X25519, XSalsa20-Poly1305).//! The format of a sealed box is//! ephemeral_pk || box(m, recipient_pk, ephemeral_sk,//!                     nonce=blake2b(ephemeral_pk, recipient_pk))xsalsa20poly1305//! Secret-key authenticated encryption//! authenticity for a secret-key authenticated-encryption scheme using nonces. For//! formal definitions see, e.g., Bellare and Namprempre, "Authenticated//! encryption: relations among notions and analysis of the generic composition//! paradigm," Lecture Notes in Computer Science 1976 (2000), 531–545,//! <http://www-cse.ucsd.edu/~mihir/papers/oem.html>.//! Note that the length is not hidden. Note also that it is the caller's//! responsibility to ensure the uniqueness of nonces—for example, by using//! nonce 1 for the first message, nonce 2 for the second message, etc.//! Nonces are long enough that randomly generated nonces have negligible//! risk of collision.//! `seal()` is `crypto_secretbox_xsalsa20poly1305`, a particular//! combination of Salsa20 and Poly1305 specified in//! authenticity.//! let key = secretbox::gen_key();//! let nonce = secretbox::gen_nonce();//! let ciphertext = secretbox::seal(plaintext, &nonce, &key);//! let their_plaintext = secretbox::open(&ciphertext, &nonce, &key).unwrap();/// Number of bytes in `Key`.r" `Key` for symmetric authenticated encryption"r" `Nonce` for symmetric authenticated encryption"/// `seal()` encrypts and authenticates a message `m` using a secret key `k` and a/// nonce `n`.  It returns a ciphertext `c`./// `seal_detached()` encrypts and authenticates a message `m` using a secret key `k` and a nonce/// `n`.  `m` is encrypted in place, so after this function returns it will contain the ciphertext./// `open()` verifies and decrypts a ciphertext `c` using a secret key `k` and a nonce `n`./// `open_detached()` verifies and decrypts a ciphertext `c` and and authentication tag `tag`,/// using a secret key `k` and a nonce `n`. `c` is decrypted in place, so if this function is//! `crypto_secretbox_xsalsa20poly1305`, a particularxchacha20poly1305secretstream_macros//! Stream encryption/file encryption//! This high-level API encrypts a sequence of messages, or a single message split into an arbitrary//! number of chunks, using a secret key, with the following properties://! * Messages cannot be truncated, removed, reordered, duplicated or modified without this being//!   detected by the decryption functions.//! * The same sequence encrypted twice will produce different ciphertexts.//! * An authentication tag is added to each encrypted message: stream corruption will be detected//!   early, without having to read the stream until the end.//! * Each message can include additional data (ex: timestamp, protocol version) in the computation//!   of the authentication tag.//! * Messages can have different sizes.//! * There are no practical limits to the total length of the stream,//!   or to the total number of individual messages.//! * Ratcheting: at any point in the stream, it is possible to "forget" the key used to encrypt//!   the previous messages, and switch to a new key.//! This API can be used to securely send an ordered sequence of messages to a peer.//! Since the length of the stream is not limited, it can also be used to encrypt files//! regardless of their size.//! It transparently generates nonces and automatically handles key rotation.//! The `crypto_secretstream_*()` API was introduced in libsodium 1.0.14.//! use sodiumoxide::crypto::secretstream::{gen_key, Stream, Tag};//! let msg1 = "some message 1";//! let msg2 = "other message";//! let msg3 = "final message";//! // initialize encrypt secret stream//! let key = gen_key();//! let (mut enc_stream, header) = Stream::init_push(&key).unwrap();//! // encrypt first message, tagging it as message.//! let ciphertext1 = enc_stream.push(msg1.as_bytes(), None, Tag::Message).unwrap();//! // encrypt second message, tagging it as push.//! let ciphertext2 = enc_stream.push(msg2.as_bytes(), None, Tag::Push).unwrap();//! // encrypt third message, tagging it as final.//! let ciphertext3 = enc_stream.push(msg3.as_bytes(), None, Tag::Final).unwrap();//! // initialize decrypt secret stream//! let mut dec_stream = Stream::init_pull(&header, &key).unwrap();//! // decrypt first message.//! assert!(!dec_stream.is_finalized());//! let (decrypted1, tag1) = dec_stream.pull(&ciphertext1, None).unwrap();//! assert_eq!(tag1, Tag::Message);//! assert_eq!(msg1.as_bytes(), &decrypted1[..]);//! // decrypt second message.//! let (decrypted2, tag2) = dec_stream.pull(&ciphertext2, None).unwrap();//! assert_eq!(tag2, Tag::Push);//! assert_eq!(msg2.as_bytes(), &decrypted2[..]);//! // decrypt last message.//! let (decrypted3, tag3) = dec_stream.pull(&ciphertext3, None).unwrap();//! assert_eq!(tag3, Tag::Final);//! assert_eq!(msg3.as_bytes(), &decrypted3[..]);//! // dec_stream is now finalized.//! assert!(dec_stream.is_finalized());stream_moduler" Returns the maximum length of an individual message."messagebytes_maxr" Number of bytes in a `Header`."r" An encrypted stream starts with a short header, whose size is HEADERBYTES"r" bytes. That header must be sent/stored before the sequence of encrypted"r" messages, as it is required to decrypt the stream."HEADERBYTESr" Number of added bytes. The ciphertext length is guaranteed to always be"r" message length + ABYTES."ABYTESr" Tag message: the most common tag, that doesn't add any information about the"r" nature of the message."TAG_MESSAGEr" Tag push: indicates that the message marks the end of a set of messages, but"r" not the end of the stream."r" For example, a huge JSON string sent as multiple chunks can use this tag to"r" indicate to the application that the string is complete and that it can be"r" decoded. But the stream itself is not closed, and more data may follow."TAG_PUSHr#" Tag rekey: "forget" the key used to encrypt this message and the previous"#r" ones, and derive a new secret key."TAG_REKEYr" Tag final: indicates that the message marks the end of the stream and erases"r" the secret key used to encrypt the previous sequence."TAG_FINALr" A tag is encrypted and attached to each message before the authentication"r" code is generated over all data. A typical encrypted stream simply attaches"r" `0` as a tag to all messages, except the last one which is tagged as"r" `Tag::Final`. When decrypting the tag is retrieved and may be used."r" Message, the most common tag, that doesn't add any information about the"r" Push: indicates that the message marks the end of a set of messages, but"r" For example, a huge JSON string sent as multiple chunks can use this tag"r" to indicate to the application that the string is complete and that it"r" can be decoded. But the stream itself is not closed, and more data may"r" follow."r#" Rekey: "forget" the key used to encrypt this message and the previous"#Rekeyr" Final: indicates that the message marks the end of the stream and erases"r" Returns the corresponding `Tag` given a `u8`, else `Err(())`."r" `Key` for symmetric authenticated encryption."r" When a `Key` goes out of scope its contents will be overwritten in"r" memory."r" An encrypted stream starts with a short header, whose size is HEADERBYTES bytes."r" That header must be sent/stored before the sequence of encrypted messages,"r" as it is required to decrypt the stream."r" `Stream` contains the state for multi-part (streaming) computations. This"r" allows the caller to process encryption of a sequence of multiple messages."StreamModer" Explicit rekeying. This updates the internal state of the `Stream<Pull>`,"r" and should only be called in a synchronized manner with how the"r" corresponding `Stream` called it when encrypting the stream. Returns"r" `Err(())` if the stream was already finalized, else `Ok(())`."rekeyr" Returns true if the stream is finalized."is_finalizedr" Returns true if the stream is not finalized."is_not_finalizedr" Initializes an `Stream` using a provided `key`. Returns the"r" `Stream` object and a `Header`, which is needed by the recipient to"r" initialize a corresponding `Stream<Pull>`. The `key` will not be needed be"r" required for any subsequent authenticated encryption operations."r" If you would like to securely generate a key and initialize an"r" `Stream` at the same time see the `new` method."r" Network protocols can leverage the key exchange API in order to get a"r" shared key that can be used to encrypt streams. Similarly, file"r" encryption applications can use the password hashing API to get a key"r" that can be used with the functions below."init_pushr" All data (including optional fields) is authenticated. Encrypts a"r" message `m` and its `tag`. Optionally includes additional data `ad`,"r" which is not encrypted."r" The encrypted message is written to the `out` vector, overwriting any existing data there."push_to_vecpush_checkpush_implr" Create a ciphertext for an empty message with the `TAG_FINAL` added"r" to signal the end of the stream. Since the `Stream` is not usable"r" after this point, this method consumes the `Stream`."r" Initializes a `Stream<Pull>` given a secret `Key` and a `Header`. The key"r" will not be required any more for subsequent operations. `Err(())` is"r" returned if the header is invalid."init_pullr" Verifies that `c` is a valid ciphertext with a correct authentication tag"r" given the internal state of the `Stream` (ciphertext streams cannot be"r" decrypted out of order for this reason). Also may validate the optional"r" unencrypted additional data `ad` using the authentication tag attached to"r" `c`. Finally decrypts the ciphertext and tag, and checks the tag"r" validity."r" If any authentication fails, the stream has already been finalized, or if"r" the tag byte for some reason does not correspond to a valid `Tag`,"r" returns `Err(())`. Otherwise returns the plaintext and the tag."r" Applications will typically use a `while stream.is_not_finalized()`"r" loop to authenticate and decrypt a stream of messages."r" The decrypted message is written to the `out` vector, overwriting any existing data there."pull_to_vecpull_checkpull_implr" The trait that distinguishes between the pull and push modes of a Stream."r" Represents the push mode of a Stream."r" Represents the pull mode of a Stream."decrypt_too_short_ciphertextpush_pullpush_pull_with_adpush_pull_with_rekeypush_pull_with_explicit_rekeypush_pull_with_recycled_veccannot_pull_after_finalizationcannot_push_after_finalizationcannot_rekey_after_finalizationfinalize_with_adtag_from_u8// NOTE: it is impossible to allocate enough memory for `msg` below without// overflowing the stack. Further, from all the research I've done and what// I know it seems impossible with Rust's type model to mock a call to `len`// and none of the mocking libraries seem to privde a workaround. Therefore// we cannot test en/decrypting plain/ciphertexts that exceed the ~275GB// maximum.//! `crypto_secretstream_xchacha20poly1305`siphash24//! A lot of applications and programming language implementations have been//! recently found to be vulnerable to denial-of-service attacks when a hash//! function with weak security guarantees, like Murmurhash 3, was used to//! construct a hash table.//! In order to address this, Sodium provides the `shorthash()` function.//! This very fast hash functions outputs short, but unpredictable//! (without knowing the secret key) values suitable for picking a list in//! a hash table for a given key.//! `shorthash()` is currently an implementation of `SipHash-2-4` as specified in//! [`SipHash`: a fast short-input PRF](https://131002.net/siphash/)//! use sodiumoxide::crypto::shorthash;//! let key = shorthash::gen_key();//! let digest = shorthash::shorthash(data_to_hash, &key);/// Number of bytes in a `Digest`.r" `Digest` structure"r" `Key`"r" When a `Key` goes out of scope its contents will be zeroed out."/// `gen_key()` randomly generates a key for shorthashshorthash/// `shorthash` hashes a message `m` under a key `k`. It/// returns a hash `h`.//! `SipHash-2-4`SIGNATUREBYTES/// Number of bytes in a `Signature`.r" a secret and public signature key."r" `SecretKey` for signatures"r" `PublicKey` for signatures"/// `sign()` signs a message `m` using the signer's secret key `sk`./// `sign()` returns the resulting signed message `sm`./// `verify()` verifies the signature in `sm` using the signer's public key `pk`./// `verify()` returns the message `Ok(m)`./// If the signature fails verification, `verify()` returns `Err(())`.sign_detached/// `sign_detached()` signs a message `m` using the signer's secret key `sk`./// `sign_detached()` returns the resulting signature `sig`.verify_detached/// `verify_detached()` verifies the signature in `sig` against the message `m`/// and the signer's public key `pk`./// `verify_detached()` returns true if the signature is valid, false otherwise./// State for multi-part (streaming) computation of signature./// `init()` initialize a streaming signing state./// `update()` can be called more than once in order to compute the digest/// from sequential chunks of the message./// `finalize()` finalizes the hashing computation and returns a `Signature`.// Moves self becuase libsodium says the state should not be used// anymore after final()./// `verify` verifies the signature in `sm` using the signer's public key `pk`.// Impl Default becuase `State` does have a sensible default: State::init()to_curve25519_pk/// Converts a ed25519 [PublicKey]  into a curve25519 [box_::PublicKey]to_curve25519_sk/// Converts an ed25519 [SecretKey] into a curve25519 [box_::SecretKey]test_sk_to_pktest_sign_verifytest_sign_verify_tampertest_sign_verify_detachedtest_sign_verify_detached_tampertest_sign_verify_seedtest_sign_verify_tamper_seedtest_vectors_detachedtest_streaming_signtest_streaming_empty_signtest_streaming_vectorstest_streaming_copytest_streaming_defaulttest_streaming_formattest_chunks_signtest_convert_keys//! `ed25519`, a signature scheme specified in//! [Ed25519](http://ed25519.cr.yp.to/). This function is conjectured to meet the//! standard notion of unforgeability for a public-key signature scheme under//! chosen-message attacks.//! Public-key signatures//! The [`sign()`](ed25519/fn.sign.html) function is designed to meet the standard//! notion of unforgeability for a public-key signature scheme under//! [`crypto::sign::sign`](ed25519/fn.sign.html) is `ed25519`, a signature scheme specified in//! ----------------------------------------------------------------------------------//! |`crypto_sign`                         | PUBLICKEYBYTES | SECRETKEYBYTES | BYTES |//! |--------------------------------------|----------------|----------------|-------|//! |`crypto_sign_ed25519`                 | 32             | 64             | 64    |//! |`crypto_sign_edwards25519sha512batch` | 32             | 64             | 64    |//! `crypto_sign_edwards25519sha512batch` is a prototype. It has been replaced with//! Ed25519 and is only kept here for compatibility reasons.//! use sodiumoxide::crypto::sign;//! let (pk, sk) = sign::gen_keypair();//! let data_to_sign = b"some data";//! let signed_data = sign::sign(data_to_sign, &sk);//! let verified_data = sign::verify(&signed_data, &pk).unwrap();//! assert!(data_to_sign == &verified_data[..]);//! # Example (detached signatures)//! let signature = sign::sign_detached(data_to_sign, &sk);//! assert!(sign::verify_detached(&signature, data_to_sign, &pk));r" `Key` for symmetric encryption"r" `Nonce` for symmetric encryption"r" `gen_key()` randomly generates a key for symmetric encryption"r" `stream()` produces a `len`-byte stream `c` as a function of a"r" secret key `k` and a nonce `n`."r" `stream_xor()` encrypts a message `m` using a secret key `k` and a nonce `n`."r" The `stream_xor()` function returns the ciphertext `c`."r" `stream_xor()` guarantees that the ciphertext has the same length as the plaintext,"r" and is the plaintext xor the output of `stream()`."r" Consequently `stream_xor()` can also be used to decrypt."stream_xorr" `stream_xor_inplace()` encrypts a message `m` using a secret key `k` and a nonce `n`."r" The `stream_xor_inplace()` function encrypts the message in place."r" `stream_xor_inplace()` guarantees that the ciphertext has the same length as"r" the plaintext, and is the plaintext xor the output of `stream_inplace()`."r" Consequently `stream_xor_inplace()` can also be used to decrypt."stream_xor_inplacer" `stream_xor_ic()` encrypts a message `m` using a secret key `k` and a nonce `n`,"r" it is similar to `stream_xor()` but allows the caller to set the value of the initial"r" block counter `ic`."stream_xor_icr" `stream_xor_ic_inplace()` encrypts a message `m` using a secret key `k` and a nonce `n`,"r" it is similar to `stream_xor_inplace()` but allows the caller to set the value of the initial"r" The `stream_xor_ic_inplace()` function encrypts the message in place."r" `stream_xor_ic_inplace()` guarantees that the ciphertext has the same length as"r" Consequently `stream_xor_ic_inplace()` can also be used to decrypt."stream_xor_ic_inplacetest_encrypt_decrypttest_stream_xortest_stream_xor_inplacetest_stream_xor_ic_sametest_stream_xor_ic_inplace//! `crypto_stream_chacha20` (Chacha20)xsalsa20stream_macrossalsa20xchacha20//! Secret-key encryption//! Generally speaking [`crypto::secretstream`](../secretstream/index.html) provides a more//! straightforward API for authenticated encryption with associated data//! (AEAD) and should be used when this is desired. By contrast, the `stream`//! module is more appropriate for use cases such as when a variable-length//! pseudorandom function is needed. [`crypto::secretstream`](../secretstream/index.html)//! also guarantees messages cannot be truncated, removed, reordered, duplicated, or modified,//! among other useful guarantees. See the module documentation for more information.//! # Security Model//! The `stream()` function, viewed as a function of the nonce for a//! uniform random key, is designed to meet the standard notion of//! unpredictability ("PRF"). For a formal definition see, e.g., Section 2.3//! of Bellare, Kilian, and Rogaway, "The security of the cipher block//! chaining message authentication code," Journal of Computer and System//! Sciences 61 (2000), 362–399;//! <http://www-cse.ucsd.edu/~mihir/papers/cbc.html>.//! This means that an attacker cannot distinguish this function from a//! uniform random function. Consequently, if a series of messages is//! encrypted by `stream_xor()` with a different nonce for each message,//! the ciphertexts are indistinguishable from uniform random strings of the//! same length.//! `NaCl` does not make any promises regarding the resistance of `stream()` to//! "related-key attacks." It is the caller's responsibility to use proper//! key-derivation functions.//! `stream()` is `crypto_stream_xsalsa20`, a particular cipher specified in//! [Cryptography in `NaCl`](http://nacl.cr.yp.to/valid.html), Section 7.//! This cipher is conjectured to meet the standard notion of//! unpredictability.//! NaCl supports the following secret-key encryption functions://! --------------------------------------------------------------//! |`crypto_stream`           |primitive   |KEYBYTES |NONCEBYTES|//! |--------------------------|------------|---------|----------|//! |`crypto_stream_chacha20`  |Chacha20/20 |32       |8         |//! |`crypto_stream_salsa20`   |Salsa20/20  |32       |8         |//! |`crypto_stream_xsalsa20`  |XSalsa20/20 |32       |24        |//! |`crypto_stream_xchacha20` |XChacha20/20|32       |24        |//! Beware that several of these primitives have 8-byte nonces. For those//! primitives it is no longer true that randomly generated nonces have negligible//! risk of collision. Callers who are unable to count 1, 2, 3..., and who insist//! on using these primitives, are advised to use a randomly derived key for each//! message.//! # Example (keystream generation)//! use sodiumoxide::crypto::stream;//! let key = stream::gen_key();//! let nonce = stream::gen_nonce();//! let keystream = stream::stream(128, &nonce, &key); // generate 128 bytes of keystream//! # Example (encryption)//! let ciphertext = stream::stream_xor(plaintext, &nonce, &key);//! let their_plaintext = stream::stream_xor(&ciphertext, &nonce, &key);//! assert_eq!(plaintext, &their_plaintext[..]);//! # Example (in place encryption)//! let plaintext = &mut [0, 1, 2, 3];//! // encrypt the plaintext//! stream::stream_xor_inplace(plaintext, &nonce, &key);//! // decrypt the plaintext//! assert_eq!(plaintext, &mut [0, 1, 2, 3]);//! `crypto_stream_salsa20` (Salsa20/20), a particular cipher specified in//! [Cryptography in `NaCl`](http://nacl.cr.yp.to/valid.html), Section 7.  This//! cipher is conjectured to meet the standard notion of unpredictability.//! `xchacha20`. The same construction as `xsalsa20` but using//! `chacha20` instead of `salsa20` as the underlying stream cipher.//! `crypto_stream_xsalsa20`, a particular cipher specified inverify_16/// `verify_16()` returns `true` if `x[0]`, `x[1]`, ..., `x[15]` are the/// same as `y[0]`, `y[1]`, ..., `y[15]`. Otherwise it returns `false`./// This function is safe to use for secrets `x[0]`, `x[1]`, ..., `x[15]`,/// `y[0]`, `y[1]`, ..., `y[15]`. The time taken by `verify_16` is independent/// of the contents of `x[0]`, `x[1]`, ..., `x[15]`, `y[0]`, `y[1]`, ..., `y[15]`./// In contrast, the standard C comparison function `memcmp(x,y,16)` takes time/// that depends on the longest matching prefix of `x` and `y`, often allowing easy/// timing attacks.verify_32/// `verify_32()` returns true if `x[0]`, `x[1]`, ..., `x[31]` are the/// same as `y[0]`, `y[1]`, ..., `y[31]`. Otherwise it returns `false`./// This function is safe to use for secrets `x[0]`, `x[1]`, ..., `x[31]`,/// `y[0]`, `y[1]`, ..., `y[31]`. The time taken by `verify_32` is independent/// of the contents of `x[0]`, `x[1]`, ..., `x[31]`, `y[0]`, `y[1]`, ..., `y[31]`./// In contrast, the standard C comparison function `memcmp(x,y,32)` takes timeverify_64/// `verify_64()` returns true if `x[0]`, `x[1]`, ..., `x[63]` are the/// same as `y[0]`, `y[1]`, ..., `y[63]`. Otherwise it returns `false`./// This function is safe to use for secrets `x[0]`, `x[1]`, ..., `x[63]`,/// `y[0]`, `y[1]`, ..., `y[63]`. The time taken by `verify_64` is independent/// of the contents of `x[0]`, `x[1]`, ..., `x[63]`, `y[0]`, `y[1]`, ..., `y[63]`./// In contrast, the standard C comparison function `memcmp(x,y,64)` takes timetest_verify_16test_verify_32test_verify_64//! Constant-time comparison of fixed-size vecs/// Encodes byte sequence into a hexadecimal string./// Panics if `2 * bin.len() + 1` overflows./// Parses a hexadecimal string into a byte sequence./// Fails if `hex.len()` is not even or/// if `hex` contains characters not in [0-9a-fA-F].//! Libsodium hexadecimal encoding/decoding helper functions"sodiumoxide"/// `init()` initializes the sodium library and chooses faster versions of/// the primitives if possible. `init()` also makes the random number generation/// functions (`gen_key`, `gen_keypair`, `gen_nonce`, `randombytes`, `randombytes_into`)/// thread-safe/// `init()` returns `Ok` if initialization succeeded and `Err` if it failed.newtype_macrosgenerichashonetimeauthsealedboxsecretboxsecretstream/// Cryptographic functions//! Rust bindings to the [sodium library](https://github.com/jedisct1/libsodium).//! Sodium is a portable implementation of Dan Bernsteins [`NaCl`: Networking and//! Cryptography library](http://nacl.cr.yp.to)//! For most users, if you want public-key (asymmetric) cryptography you should use//! the functions in [`crypto::box_`](crypto/box_/index.html) for encryption/decryption.//! If you want secret-key (symmetric) cryptography you should be using the//! functions in [`crypto::secretbox`](crypto/secretbox/index.html) for encryption/decryption.//! For public-key signatures you should use the functions in//! [`crypto::sign`](crypto/sign/index.html) for signature creation and verification.//! Unless you know what you're doing you most certainly don't want to use the//! functions in [`crypto::scalarmult`](crypto/scalarmult/index.html),//! [`crypto::stream`](crypto/stream/index.html), [`crypto::auth`](crypto/auth/index.html) and//! [`crypto::onetimeauth`](crypto/onetimeauth/index.html).//! ## Thread Safety//! All functions in this library are thread-safe provided that the [`init()`](fn.init.html)//! function has been called during program execution.//! If [`init()`](fn.init.html) hasn't been called then all functions except the random-number//! generation functions and the key-generation functions are thread-safe.//! # Public-key cryptography//!  [`crypto::box_`](crypto/box_/index.html)//!  [`crypto::sign`](crypto/sign/index.html)//! # Sealed boxes//!  [`crypto::sealedbox`](crypto/sealedbox/index.html)//! # Secret-key cryptography//!  [`crypto::secretbox`](crypto/secretbox/index.html)//!  [`crypto::secretstream`](crypto/secretstream/index.html)//!  [`crypto::stream`](crypto/stream/index.html)//!  [`crypto::auth`](crypto/auth/index.html)//!  [`crypto::onetimeauth`](crypto/onetimeauth/index.html)//! # Low-level functions//!  [`crypto::hash`](crypto/hash/index.html)//!  [`crypto::kdf`](crypto/kdf/index.html)//!  [`crypto::verify`](crypto/verify/index.html)//!  [`crypto::shorthash`](crypto/shorthash/index.html)// Remove this after https://github.com/sodiumoxide/sodiumoxide/issues/221 is done/// Macro used for generating newtypes of byte-arrays/// Generating secret datatypes, e.g. keys/// new_type! {///     /// This is some documentation for our type///     secret Key(KEYBYTES);/// Generating public datatypes, e.g. public keys///     public PublicKey(PUBLICKEYBYTES);/// Generating nonce types///     nonce Nonce(NONCEBYTES);/// The `pad()` function adds padding data to a buffer buf whose original size is `unpadded_buflen`/// in order to extend its total length to a multiple of blocksize./// The function returns `Err(())` if the padded buffer length would exceed `max_buflen`, or if the/// block size is 0. It returns a result containing the new padded length upon success./// The `unpad()` function computes the original, unpadded length of a message previously padded/// using [`pad()`]. The original length is returned upon success.test_on_block_boundarytest_pad_and_unpad_with_good_lengthtest_on_bad_length//! Cryptographic padding routines//! Most modern cryptographic constructions disclose message lengths. The ciphertext for a given//! message will always have the same length, or add a constant number of bytes to it. For most//! applications, this is not an issue. But in some specific situations, such as interactive remote//! shells, hiding the length may be desirable. Padding can be used for that purpose.//! Algorithm These functions use the ISO/IEC 7816-4 padding algorithm. It supports arbitrary block//! sizes, ensures that the padding data are checked for computing the unpadded length, and is more//! resistant to some classes of attacks than other standard padding algorithms.//! Notes Padding should be applied prior to encryption, and removed after decryption. Usage of//! padding in order to hide the length of a password is not recommended. A client willing to send a//! password to a server should hash it instead (even with a single iteration of the hash function).//! This ensures that the length of the transmitted data is constant, and that the server doesn't//! effortlessly get a copy of the password. Applications may eventually leak the unpadded length//! via side channels, but the sodium_pad() and sodium_unpad() functions themselves try to minimize//! side channels for a given length & <block size mask> value./// The number of seed bytes to use for the deterministic RNG functions/// [`randombytes_buf_deterministic()`] and/// [`randombytes_buf_deterministic_into()`]/// `randombytes()` randomly generates size bytes of data./// THREAD SAFETY: `randombytes()` is thread-safe provided that you have/// `randombytes_into()` fills a buffer `buf` with random data./// THREAD SAFETY: `randombytes_into()` is thread-safe provided that you have/// `randombytes_uniform()` returns an unpredictable value between 0 and/// `upper_bound` (excluded). It guarantees a uniform distribution of the/// possible output values even when `upper_bound` is not a power of 2. Note/// that an `upper_bound` < 2 leaves only a  single element to be chosen, namelyr" `Seed` bytes for the deterministic random functions"/// WARNING: you should only use this function for testing purposes or a *known good* use case/// in which it is acceptable to rely on the secrecy of the seed passed to/// `randombytes_buf_deterministic`. The function is (as its name suggests) entirely deterministic/// given knowledge of the seed. It does not incorporate entropy of any form and should almost/// never be used for cryptographic purposes. If you need to generate a deterministic stream of/// cryptographic quality pseudo random data you're better suited using a stream cipher directly/// e.g. one of the stream ciphers exposed in [`sodiumoxide::crypto::stream`](::crypto::stream) or/// the higher level [`secretstream`](::crypto::secretstream) API./// The `randombytes_buf_deterministic` function stores size bytes into buf indistinguishable from/// random bytes without knowing seed. For a given seed, this function will always output the same/// sequence; size can be up to 2^38 (256 GB)./// Seed is [`SEEDBYTES`] bytes long./// This function is mainly useful for writing tests, and was introduced in libsodium 1.0.12. Under/// the hood, it uses the ChaCha20 stream cipher. Up to 256 GB can be produced with a single seed.randombytes_buf_deterministic_into/// WARNING: using this function in a cryptographic setting is dangerous. Read the full/// documentation of [`randombytes_buf_deterministic()`] before proceeding./// A counterpart to [`randombytes_buf_deterministic()`] that/// fills `buf` with `buf.len()` bytes instead of returning a value.test_randombytes_uniform_0test_randombytes_uniform_1test_randombytes_uniform_7test_randombytes_buf_deterministictest_randombytes_buf_deterministic_intotest_randombytes_buf_deterministic_unique_given_seed//! Cryptographic random number generation.rmp_serde// Encodes then decodes `value` using JSONmemzero/// `memzero()` tries to effectively zero out the data in `x` even if/// optimizations are being applied to the code./// `memcmp()` returns true if `x[0]`, `x[1]`, ..., `x[len-1]` are the/// same as `y[0]`, `y[1]`, ..., `y[len-1]`. Otherwise it returns `false`./// This function is safe to use for secrets `x[0]`, `x[1]`, ..., `x[len-1]`,/// `y[0]`, `y[1]`, ..., `y[len-1]`. The time taken by `memcmp` is independent/// of the contents of `x[0]`, `x[1]`, ..., `x[len-1]`, `y[0]`, `y[1]`, ..., `y[len-1]`./// In contrast, the standard C comparison function `memcmp(x,y,len)` takes time/// `mlock()` locks memory given region which can help avoiding swapping the/// sensitive memory region to disk./// Operating system might limit the amount of memory a process can `mlock()`./// This function can fail if `mlock()` fails to lock the memory./// `munlock()` unlocks memory region./// `munlock()` overwrites the region with zeros before unlocking it, so it/// doesn't have to be done before calling this function./// `increment_le()` treats `x` as an unsigned little-endian number and increments it in/// constant time./// WARNING: this method does not check for arithmetic overflow. When used for incrementing/// nonces it is the caller's responsibility to ensure that any given nonce value/// is used only once./// If the caller does not do that the cryptographic primitives in sodiumoxide/// will not uphold any security guarantees (i.e. they may break)add_le/// `add_le()` treats `x` and `y` as unsigned little-endian numbers and adds `y` to `x`/// modulo 2^(8*len) in constant time./// `add_le()` will return Err<()> if the length of `x` is not equal to the length of `y`./// WARNING: When used for incrementing nonces it is the caller's responsibility to ensure/// that any given nonce value is used only once.test_memcmptest_increment_le_zerotest_increment_le_vectorstest_increment_le_overflowtest_add_le_zerotest_add_le_vectorstest_add_le_overflowtest_add_le_different_lengthstest_mlock_munlocktest_mlock_fail//! Libsodium utility functions/// `version_string()` returns the version string from libsodium./// `version_major()` returns the major version from libsodium./// `version_minor()` returns the minor version from libsodium.test_version_string//! Libsodium version functionsbackend_interfaceInitErrorSoftBufferErrormake_dispatch/// A macro for creating the enum used to statically dispatch to the platform-specific implementation.ContextDispatchX11DisplayImplWaylandDisplayImplkmsKmsDisplayImplKmsContextInterfaceSurfaceDispatchX11ImplWaylandImplKmsImplBufferDispatchSurfaceInterfaceBufferImplpresent_with_damageBufferInterface//! Implements `buffer_interface::*` traits for enums dispatching to backends// XXX empty enum with generic bound is invalid?/// Get the inner window handle./// Resize the internal buffer to the given width and height./// Get a mutable reference to the buffer./// Fetch the buffer from the window.//! Interface implemented by backendskCGBitmapByteOrder32LittlekCGImageAlphaNoneSkipFirstkCGRenderingIntentDefaultCGColorSpacedata_providerCGDataProviderCGImageAnyObjectNSAutoresizingMaskOptionsMainThreadBoundobjc2_quartz_corekCAGravityTopLeftCALayerCATransactionSendCGColorSpace_displayCGImpl// TODO(madsmtm): Expose this in `objc2_app_kit`.// SAFETY: `CGColorSpace` is immutable, and can freely be shared between threads.CtrlDeviceSwResultExt/// The underlying raw device file descriptor./// Holds a reference to the display./// The display implementation./// The connectors to use./// The CRTC to render to./// The dumb buffer we're using as a buffer./// Window handle that we are keeping around./// All the necessary types for the Drm/Kms backend.SharedBuffer/// The involved set of buffers.first_is_front/// Whether to use the first buffer or the second buffer as the front buffer./// The mapping of the dump buffer.front_fb/// The framebuffer object of the current front buffer.crtc_handle/// The CRTC handle./// This is used to change the front buffer./// The current size.front_age/// Age of the front buffer.back_age/// Age of the back buffer._window/// Window reference./// The buffer implementation./// The frame buffer./// The dumb buffer./// The age of this buffer./// The combined frame buffer and dumb buffer./// Create a new KMS backend./*
    fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
        // TODO: Implement this!
    }
    *//// Create a new buffer set./// Get the size of this buffer.//! Backend for DRM/KMS for raw rendering directly to the screen.//! This strategy uses dumb buffers for rendering.size_unalignedOrbitalMapThreadSafeWindowHandleOrbitalImplwindow_fd// Read the current width and sizecreate_memfileget_pool_size// Round size to use for pool for given dimensions, rounding up to power of 2qhWaylandBuffermapped_mutregistry_queue_initevent_queue/// The object that owns the display handle./// This has to be dropped *after* the `conn` field, because the `conn` field implicitly borrows/// The pointer to the window object./// This has to be dropped *after* the `surface` field, because the `surface` field implicitly/// borrows this.BorrowStackOffscreenCanvasOffscreenCanvasRenderingContext2dNoDisplayHandleNoWindowHandleWebDisplayImpl/// Display implementation for the web platform./// This just caches the document to prevent having to query it every time./// The handle and context to the canvas that we're drawing to./// The buffer that we're drawing to.buffer_presented/// Buffer has been presented./// The current canvas width/height./// The underlying window handle./// The underlying display handle.WebImpl/// Holding canvas and context for [`HtmlCanvasElement`] or [`OffscreenCanvas`],/// since they have different types.from_canvasfrom_offscreen_canvasresolve_ctx/// De-duplicates the error handling between `HtmlCanvasElement` and `OffscreenCanvas`./// Resize the canvas to the given dimensions./// Creates a new instance of this struct, using the provided [`HtmlCanvasElement`]./// - If the canvas was already controlled by an `OffscreenCanvas`./// - If a another context then "2d" was already created for this canvas./// Creates a new instance of this struct, using the provided [`OffscreenCanvas`]./// If a another context then "2d" was already created for this canvas.SurfaceExtWeb/// Extension methods for the Wasm target on [`Surface`](crate::Surface).get_image_dataput_image_data// NOTE: suppress the lint because we mirror `CanvasRenderingContext2D.putImageData()`, and// this is just an internal API used by this module only, so it's not too relevant./// Push the buffer to the canvas.//! Implementation of software buffering for web targets.ZERO_QUADdcbitmap/// The window handle./// The device context for the window./// The buffer used to hold the image./// The handle for the window./// This should be kept alive in order to keep `window` valid./// The display handle./// We don't use this, but other code might.Win32Impl/// The handle to a window for software buffering.bmi_headerbmi_colorsBitmapInfo/// The Win32-compatible bitmap information./// Create a new `Win32Impl` from a `Win32WindowHandle`./// The channel for sending commands./// Allocator for device contexts./// Device contexts can only be allocated or freed on the thread that originated them./// So we spawn a thread specifically for allocating and freeing device contexts./// This is the interface to that thread./// Get the global instance of the allocator.send_command/// Send a command to the allocator thread.get_dc/// Get the device context for a window./// Allocate a new device context./// Deallocate a device context./// Release a device context./// The window to provide a device context for./// Send back the device context.GetDc/// Call `GetDc` to get the device context for the provided window./// The DC to be compatible with.Allocate/// Allocate a new device context using `GetCompatibleDc`.Deallocate/// The device context to release./// The window that owns this device context./// Release a window-associated device context./// Commands to be sent to the allocator./// Handle this command./// This should be called on the allocator thread.//! Implementation of software buffering for Windows.//! This module converts the input buffer into a bitmap and then stretches it to the window.posix_shmSequenceNumberImageOrderVisualClassVisualidxcb_ffi/// The handle to the XCB connection.is_shm_available/// SHM extension is available.supported_visuals/// All visuals using softbuffer's pixel representation/// The generic display where the `connection` field comes from./// Without `&mut`, the underlying connection cannot be closed without other unsafe behavior./// With `&mut`, the connection can be dropped without us knowing about it. Therefore, we/// cannot provide `&mut` access to this field./// Create a new `X11DisplayImpl`./// X display this window belongs to./// The window to draw to.gcGcontext/// The graphics context to use when drawing./// The depth (bits per pixel) of the drawing context./// The visual ID of the drawing context./// The buffer we draw to./// The current buffer width/height./// Keep the window alive./// The handle to an X11 drawing context.ShmBuffer/// A buffer implemented using shared memory to prevent unnecessary copying.Wire/// A normal buffer that we send over the wire./// The buffer that is being drawn to.segShmSegmentSeg/// The shared memory segment, paired with its ID.done_processing/// A cookie indicating that the shared memory segment is ready to be used./// We can't soundly read from or write to the SHM segment until the X server is done processing the/// `shm::PutImage` request. However, the X server handles requests in order, which means that, if/// we send a very small request after the `shm::PutImage` request, then the X server will have to/// process that request before it can process the `shm::PutImage` request. Therefore, we can use/// the reply to that small request to determine when the `shm::PutImage` request is done./// In this case, we use `GetInputFocus` since it is a very small request./// We store the sequence number instead of the `Cookie` since we cannot hold a self-referential/// reference to the `connection` field./// Create a new `X11Impl` from a `HasWindowHandle`./// Push the buffer to the window.PushBufferError/// Resize the buffer to the given size.finish_wait/// Finish waiting for an ongoing `shm::PutImage` request, if there is one./// Get a reference to the buffer./// `finish_wait()` must be called in between `shm::PutImage` requests and this function.alloc_segment/// Allocate a new `ShmSegment` of the given size./// Get the SHM buffer as a reference./// `finish_wait()` must be called before this function is./// Get the SHM buffer as a mutable reference./// Associate an SHM segment with the server.begin_wait/// Begin waiting for the SHM processing to finish./// Wait for the SHM processing to finish.// SAFETY: We respect Rust's mutability rules for the inner allocation./// Create a new `ShmSegment` with the given size./// Get this shared memory segment as a reference./// One must ensure that no other processes are writing to this memory./// Get this shared memory segment as a mutable reference./// One must ensure that no other processes are reading from or writing to this memory./// Set the size of the buffer for this shared memory segment./// Get the size of the buffer for this shared memory segment./// Get the size of this shared memory segment.create_shm_id/// Create a shared memory identifier./// Test to see if SHM is available./// Collect all visuals that use softbuffer's pixel format/// We encountered an X11 error.XidExhausted/// We exhausted the XID space./// A system error occurred while creating the shared memory segment./// An error that can occur when pushing a buffer to the window.PushResultExt/// Convenient wrapper to cast errors into PushBufferError./// Get the length that a slice needs to be to hold a buffer of the given dimensions.//! Implementation of software buffering for X11.//! This module converts the input buffer into an XImage and then sends it over the wire to be//! drawn by the X server. The SHM extension is used if available./// A [`raw-window-handle`] error occurred./// [`raw-window-handle`]: raw_window_handlehuman_readable_display_platform_name/// The platform name of the display that was passed into [`Context::new`]./// This is a human-readable string that describes the platform of the display that was/// passed into [`Context::new`]. The value is not guaranteed to be stable and this/// exists for debugging purposes only./// [`Context::new`]: crate::Context::new/// The [`RawDisplayHandle`] that was passed into [`Context::new`]./// [`RawDisplayHandle`]: raw_window_handle::RawDisplayHandleUnsupportedDisplayPlatform/// The [`RawDisplayHandle`] passed into [`Context::new`] is not supported by this crate.human_readable_window_platform_name/// The platform name of the window that was passed into [`Surface::new`]./// This is a human-readable string that describes the platform of the window that was/// passed into [`Surface::new`]. The value is not guaranteed to be stable and this/// [`Surface::new`]: crate::Surface::new/// The platform name of the display used by the [`Context`]./// It is possible for a window to be created on a different type of display than the/// display that was passed into [`Context::new`]. This is a human-readable string that/// describes the platform of the display that was passed into [`Context::new`]. The value/// is not guaranteed to be stable and this exists for debugging purposes only./// [`Context`]: crate::Context/// The [`RawWindowHandle`] that was passed into [`Surface::new`]./// [`RawWindowHandle`]: raw_window_handle::RawWindowHandleUnsupportedWindowPlatform/// The [`RawWindowHandle`] passed into [`Surface::new`] is not supported by this crate.IncompleteWindowHandle/// The [`RawWindowHandle`] passed into [`Surface::new`] is missing necessary fields.IncompleteDisplayHandle/// The [`RawDisplayHandle`] passed into [`Context::new`] is missing necessary fields./// The width that was out of range./// The height that was out of range.SizeOutOfRange/// The provided size is outside of the range supported by the backend./// The damage rect that was out of range.DamageOutOfRange/// The provided damage rect is outside of the range supported by the backend./// A platform-specific backend error occurred./// The first field provides a human-readable description of the error. The second field/// provides the actual error that occurred. Note that the second field is, under the hood,/// a private wrapper around the actual error, preventing the user from downcasting to the/// actual error type./// This function is unimplemented on this platform./// A sum type of all of the errors that can occur during the operation of this crate./// Failed to initialize./// Cannot initialize this handle on this platform./// Simple unit error type used to bubble up rejected platforms.swbuf_err/// Convenient wrapper to cast errors into SoftBufferError./// A wrapper around a library error./// This prevents `x11-dl` and `x11rb` from becoming public dependencies, since users cannot downcast/// to this type.backend_dispatchcontext_impl/// The inner static dispatch object./// This is Send+Sync IFF D is Send+Sync./// An instance of this struct contains the platform-specific data that must be managed in order to/// write to a window on that platform./// Creates a new instance of this struct, using the provided display./// x coordinate of top left corner/// y coordinate of top left corner/// width/// height/// A rectangular region of the buffer coordinate space.surface_impl/// This is boxed so that `Surface` is the same size on every platform./// A surface for drawing to a window with software buffers./// Creates a new surface for the context for the provided window./// Get a reference to the underlying window handle./// Set the size of the buffer that will be returned by [`Surface::buffer_mut`]./// If the size of the buffer does not match the size of the window, the buffer is drawn/// in the upper-left corner of the window. It is recommended in most production use cases/// to have the buffer fill the entire window. Use your windowing library to find the size/// of the window./// Copies the window contents into a buffer./// ## Platform Dependent Behavior/// - On X11, the window must be visible./// - On macOS, Redox and Wayland, this function is unimplemented./// - On Web, this will fail if the content was supplied by///   a different origin depending on the sites CORS rules./// Return a [`Buffer`] that the next frame should be rendered into. The size must/// be set with [`Surface::resize`] first. The initial contents of the buffer may be zeroed, or/// may contain a previous frame. Call [`Buffer::age`] to determine this./// - On DRM/KMS, there is no reliable and sound way to wait for the page flip to happen from within///   `softbuffer`. Therefore it is the responsibility of the user to wait for the page flip before///   sending another frame.buffer_impl/// A buffer that can be written to by the CPU and presented to the window./// This derefs to a `[u32]`, which depending on the backend may be a mapping into shared memory/// accessible to the display server, so presentation doesn't require any (client-side) copying./// This trusts the display server not to mutate the buffer, which could otherwise be unsound./// # Data representation/// The format of the buffer is as follows. There is one `u32` in the buffer for each pixel in/// the area to draw. The first entry is the upper-left most pixel. The second is one to the right/// etc. (Row-major top to bottom left to right one `u32` per pixel). Within each `u32` the highest/// order 8 bits are to be set to 0. The next highest order 8 bits are the red channel, then the/// green channel, and then the blue channel in the lowest-order 8 bits. See the examples for/// one way to build this format using bitwise operations./// --------/// Pixel format (`u32`):/// 00000000RRRRRRRRGGGGGGGGBBBBBBBB/// 0: Bit is 0/// R: Red channel/// G: Green channel/// B: Blue channel/// # Platform dependent behavior/// No-copy presentation is currently supported on:/// - Wayland/// - X, when XShm is available/// - Win32/// - Orbital, when buffer size matches window size/// Currently [`Buffer::present`] must block copying image data on:/// - Web/// - macOS/// Is age is the number of frames ago this buffer was last presented. So if the value is/// `1`, it is the same as the last frame, and if it is `2`, it is the same as the frame/// before that (for backends using double buffering). If the value is `0`, it is a new/// buffer that has unspecified contents./// This can be used to update only a portion of the buffer./// Presents buffer to the window./// ## Wayland/// On Wayland, calling this function may send requests to the underlying `wl_surface`. The/// graphics context may issue `wl_surface.attach`, `wl_surface.damage`, `wl_surface.damage_buffer`/// and `wl_surface.commit` requests when presenting the buffer./// If the caller wishes to synchronize other surface/window changes, such requests must be sent to the/// Wayland compositor before calling this function./// Presents buffer to the window, with damage regions./// Supported on:/// Otherwise this is equivalent to [`Self::present`]./// There is no display handle./// There is no window handle.window_handle_type_namedisplay_handle_type_name__assert_send/// Takes a mutable reference to a container and a function deriving a/// reference into it, and stores both, making it possible to get back the/// reference to the container once the other reference is no longer needed./// This should be consistent with stacked borrow rules, and miri seems to/// accept it at least in simple cases.member_mutinto_containerunion_damage/// Calculates the smallest `Rect` necessary to represent all damaged `Rect`s.test_borrowstack_slice_int// Not needed on all platformsRelaxStrategySpinBarrierState/// A primitive that synchronizes the execution of multiple threads./// use spin;/// let mut handles = Vec::with_capacity(10);/// let barrier = Arc::new(spin::Barrier::new(10));///     let c = barrier.clone();///     // The same messages will be printed together.///     // You will NOT see any interleaving.///     handles.push(thread::spawn(move|| {///         c.wait();/// // Wait for other threads to finish./// for handle in handles {///     handle.join().unwrap();// The inner state of a double barrier/// A `BarrierWaitResult` is returned by [`wait`] when all threads in the [`Barrier`]/// have rendezvoused./// [`wait`]: struct.Barrier.html#method.wait/// [`Barrier`]: struct.Barrier.html/// let barrier = spin::Barrier::new(1);/// let barrier_wait_result = barrier.wait();/// Blocks the current thread until all threads have rendezvoused here./// Barriers are re-usable after all threads have rendezvoused once, and can/// be used continuously./// A single (arbitrary) thread will receive a [`BarrierWaitResult`] that/// returns `true` from [`is_leader`] when returning from this function, and/// all other threads will receive a result that will return `false` from/// [`is_leader`]./// [`BarrierWaitResult`]: struct.BarrierWaitResult.html/// [`is_leader`]: struct.BarrierWaitResult.html#method.is_leader/// Creates a new barrier that can block a given number of threads./// A barrier will block `n`-1 threads which call [`wait`] and then wake up/// all threads at once when the `n`th thread calls [`wait`]. A Barrier created/// with n = 0 will behave identically to one created with n = 1./// [`wait`]: #method.wait/// let barrier = spin::Barrier::new(10);/// Returns whether this thread from [`wait`] is the "leader thread"./// Only one thread will have `true` returned from their result, all other/// threads will have `false` returned./// println!("{:?}", barrier_wait_result.is_leader());use_barriertest_barrier//! Synchronization primitive allowing multiple threads to synchronize the//! beginning of some computation.//! Implementation adapted from the 'Barrier' type of the standard library. See://! <https://doc.rust-lang.org/std/sync/struct.Barrier.html>//! Copyright 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/// This type is a thread-safe `Lazy`, and can be used in statics./// use spin::Lazy;// We never create a `&F` from a `&Lazy<T, F>` so it is fine// to not impl `Sync` for `F`// we do create a `&mut Option<F>` in `force`, but this is// properly synchronized, so it only happens once// so it also does not contribute to this impl./// Retrieves a mutable pointer to the inner data./// This is especially useful when interfacing with low level code or FFI where the caller/// explicitly knows that it has exclusive access to the inner data. Note that reading from/// this pointer is UB until initialized or directly written to./// returns a reference to result. This is equivalent//! Synchronization primitives for lazy evaluation.//! Implementation adapted from the `SyncLazy` type of the standard library. See://! <https://doc.rust-lang.org/std/lazy/struct.SyncLazy.html>relax/// A primitive that synchronizes the execution of multiple threads. See [`barrier::Barrier`] for documentation./// A note for advanced users: this alias exists to avoid subtle type inference errors due to the default relax/// strategy type parameter. If you need a non-default relax strategy, use the fully-qualified path./// A value which is initialized on the first access. See [`lazy::Lazy`] for documentation./// A primitive that synchronizes the execution of multiple threads. See [`mutex::Mutex`] for documentation./// A primitive that provides lazy one-time initialization. See [`once::Once`] for documentation./// A lock that provides data access to either one writer or many readers. See [`rwlock::RwLock`] for documentation.RwLockUpgradableGuard/// A guard that provides immutable data access but can be upgraded to [`RwLockWriteGuard`]. See/// [`rwlock::RwLockUpgradableGuard`] for documentation./// A guard that provides mutable data access. See [`rwlock::RwLockWriteGuard`] for documentation./// A lock that provides mutually exclusive data access (compatible with [`lock_api`](https://crates.io/crates/lock_api))./// A guard that provides mutable data access (compatible with [`lock_api`](https://crates.io/crates/lock_api))./// A lock that provides data access to either one writer or many readers (compatible with [`lock_api`](https://crates.io/crates/lock_api))./// A guard that provides immutable data access (compatible with [`lock_api`](https://crates.io/crates/lock_api))./// A guard that provides immutable data access but can be upgraded to [`RwLockWriteGuard`] (compatible with [`lock_api`](https://crates.io/crates/lock_api))./// Spin synchronisation primitives, but compatible with [`lock_api`](https://crates.io/crates/lock_api).//! This crate provides [spin-based](https://en.wikipedia.org/wiki/Spinlock) versions of the//! primitives in `std::sync` and `std::lazy`. Because synchronization is done through spinning,//! the primitives are suitable for use in `no_std` environments.//! - `Mutex`, `RwLock`, `Once`/`SyncOnceCell`, and `SyncLazy` equivalents//! - Support for `no_std` environments//! - [`lock_api`](https://crates.io/crates/lock_api) compatibility//! - Upgradeable `RwLock` guards//! - Guards can be sent and shared between threads//! - Guard leaking//! - Ticket locks//! - Different strategies for dealing with contention//! # Relationship with `std::sync`//! While `spin` is not a drop-in replacement for `std::sync` (and//! [should not be considered as such](https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html))//! an effort is made to keep this crate reasonably consistent with `std::sync`.//! Many of the types defined in this crate have 'additional capabilities' when compared to `std::sync`://! - Because spinning does not depend on the thread-driven model of `std::sync`, guards ([`MutexGuard`],//!   [`RwLockReadGuard`], [`RwLockWriteGuard`], etc.) may be sent and shared between threads.//! - [`RwLockUpgradableGuard`] supports being upgraded into a [`RwLockWriteGuard`].//! - Guards support [leaking](https://doc.rust-lang.org/nomicon/leaking.html).//! - [`Once`] owns the value returned by its `call_once` initializer.//! - [`RwLock`] supports counting readers and writers.//! Conversely, the types in this crate do not have some of the features `std::sync` has://! - Locks do not track [panic poisoning](https://doc.rust-lang.org/nomicon/poisoning.html).//! The crate comes with a few feature flags that you may wish to use.//! - `lock_api` enables support for [`lock_api`](https://crates.io/crates/lock_api)//! - `ticket_mutex` uses a ticket lock for the implementation of `Mutex`//! - `fair_mutex` enables a fairer implementation of `Mutex` that uses eventual fairness to avoid//!   starvation//! - `std` enables support for thread yielding instead of spinning// Avoid confusing inference errors by aliasing away the relax strategy parameter. Users that need to use a different// relax strategy can do so by accessing the types through their fully-qualified path. This is a little bit horrible// but sadly adding a default type parameter is *still* a breaking change in Rust (for understandable reasons).// The lowest bit of `lock` is used to indicate whether the mutex is locked or not. The rest of the bits are used to// store the number of starving threads.STARVEDSTARVATION_SPINS/// Number chosen by fair roll of the dice, adjust as needed./// A [spin lock](https://en.m.wikipedia.org/wiki/Spinlock) providing mutually exclusive access to data, but with a fairer/// let lock = spin::mutex::FairMutex::<_>::new(0);/// // Modify the data/// *lock.lock() = 2;/// // Read the data/// let answer = *lock.lock();/// assert_eq!(answer, 2);/// # Thread safety example/// use std::sync::{Arc, Barrier};/// let thread_count = 1000;/// let spin_mutex = Arc::new(spin::mutex::FairMutex::<_>::new(0));/// // We use a barrier to ensure the readout happens after all writing/// let barrier = Arc::new(Barrier::new(thread_count + 1));/// for _ in (0..thread_count) {///     let my_barrier = barrier.clone();///     let my_lock = spin_mutex.clone();///         let mut guard = my_lock.lock();///         *guard += 1;///         // Release the lock to prevent a deadlock///         drop(guard);///         my_barrier.wait();/// barrier.wait();/// let answer = { *spin_mutex.lock() };/// assert_eq!(answer, thread_count);/// A guard that provides mutable data access./// When the guard falls out of scope it will release the lock.Starvation/// A handle that indicates that we have been trying to acquire the lock for a while./// This handle is used to prevent starvation.LockRejectReason/// The lock was rejected due to the lock being held by another thread.Starved/// The lock was rejected due to starvation./// Indicates whether a lock was rejected due to the lock being held by another thread or due to starvation.// Same unsafe impls as `std::sync::Mutex`/// Creates a new [`FairMutex`] wrapping the supplied data./// use spin::mutex::FairMutex;/// static MUTEX: FairMutex<()> = FairMutex::<_>::new(());/// fn demo() {///     let lock = MUTEX.lock();///     // do something with lock///     drop(lock);/// Consumes this [`FairMutex`] and unwraps the underlying data./// let lock = spin::mutex::FairMutex::<_>::new(42);/// assert_eq!(42, lock.into_inner());/// Returns a mutable pointer to the underlying data./// This is mostly meant to be used for applications which require manual unlocking, but where/// storing both the lock and the pointer to the inner data gets inefficient.///     core::mem::forget(lock.lock());///     assert_eq!(lock.as_mut_ptr().read(), 42);///     lock.as_mut_ptr().write(58);///     lock.force_unlock();/// assert_eq!(*lock.lock(), 58);/// Locks the [`FairMutex`] and returns a guard that permits access to the inner data./// The returned value may be dereferenced for data access/// and the lock will be dropped when the guard falls out of scope.///     let mut data = lock.lock();///     // The lock is now locked and the data can be accessed///     *data += 1;///     // The lock is implicitly dropped at the end of the scope/// Returns `true` if the lock is currently held./// This function provides no synchronization guarantees and so its result should be considered 'out of date'/// the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic./// Force unlock this [`FairMutex`]./// This is *extremely* unsafe if the lock is not held by the current/// thread. However, this can be useful in some instances for exposing the/// lock to FFI that doesn't know how to deal with RAII./// Try to lock this [`FairMutex`], returning a lock guard if successful./// let maybe_guard = lock.try_lock();/// assert!(maybe_guard.is_some());/// // `maybe_guard` is still held, so the second call fails/// let maybe_guard2 = lock.try_lock();/// assert!(maybe_guard2.is_none());try_lock_starver/// Tries to lock this [`FairMutex`] and returns a result that indicates whether the lock was/// rejected due to a starver or not.starve/// Indicates that the current user has been waiting for the lock for a while/// and that the lock should yield to this thread over a newly arriving thread./// // Lock the mutex to simulate it being used by another user./// let guard1 = lock.lock();/// // Try to lock the mutex./// let guard2 = lock.try_lock();/// assert!(guard2.is_none());/// // Wait for a while./// wait_for_a_while();/// // We are now starved, indicate as such./// let starve = lock.starve();/// // Once the lock is released, another user trying to lock it will/// // fail./// let guard3 = lock.try_lock();/// assert!(guard3.is_none());/// // However, we will be able to lock it./// let guard4 = starve.try_lock();/// assert!(guard4.is_ok());/// # fn wait_for_a_while() {}/// Since this call borrows the [`FairMutex`] mutably, and a mutable reference is guaranteed to be exclusive in/// Rust, no actual locking needs to take place -- the mutable borrow statically guarantees no locks exist. As/// such, this is a 'zero-cost' operation./// let mut lock = spin::mutex::FairMutex::<_>::new(0);/// *lock.get_mut() = 10;/// assert_eq!(*lock.lock(), 10);/// Leak the lock guard, yielding a mutable reference to the underlying data./// Note that this function will permanently lock the original [`FairMutex`]./// let mylock = spin::mutex::FairMutex::<_>::new(0);/// let data: &mut i32 = spin::mutex::FairMutexGuard::leak(mylock.lock());/// *data = 1;/// assert_eq!(*data, 1);/// The dropping of the MutexGuard will release the lock it was created from.try_lock_fair/// Attempts the lock the mutex if we are the only starving user./// This allows another user to lock the mutex if they are starving as well./// Attempts to lock the mutex./// If the lock is currently held by another thread, this will return `None`./// Locks the mutex.test_mutex_force_lock//! A spinning mutex with a fairer unlock algorithm.//! This mutex is similar to the `SpinMutex` in that it uses spinning to avoid//! context switches. However, it uses a fairer unlock algorithm that avoids//! starvation of threads that are waiting for the lock.SpinMutex/// A [spin lock](https://en.m.wikipedia.org/wiki/Spinlock) providing mutually exclusive access to data./// let lock = spin::mutex::SpinMutex::<_>::new(0);/// let spin_mutex = Arc::new(spin::mutex::SpinMutex::<_>::new(0));/// # let mut ts = Vec::new();/// # let t =/// # ts.push(t);/// # for t in ts {/// #     t.join().unwrap();SpinMutexGuard/// Creates a new [`SpinMutex`] wrapping the supplied data./// use spin::mutex::SpinMutex;/// static MUTEX: SpinMutex<()> = SpinMutex::<_>::new(());/// Consumes this [`SpinMutex`] and unwraps the underlying data./// let lock = spin::mutex::SpinMutex::<_>::new(42);/// Locks the [`SpinMutex`] and returns a guard that permits access to the inner data./// Force unlock this [`SpinMutex`]./// Try to lock this [`SpinMutex`], returning a lock guard if successful./// Since this call borrows the [`SpinMutex`] mutably, and a mutable reference is guaranteed to be exclusive in/// let mut lock = spin::mutex::SpinMutex::<_>::new(0);/// Note that this function will permanently lock the original [`SpinMutex`]./// let mylock = spin::mutex::SpinMutex::<_>::new(0);/// let data: &mut i32 = spin::mutex::SpinMutexGuard::leak(mylock.lock());//! A naïve spinning mutex.//! Waiting threads hammer an atomic variable until it becomes available. Best-case latency is low, but worst-case//! latency is theoretically infinite.next_ticketnext_servingTicketMutex/// A spin-based [ticket lock](https://en.wikipedia.org/wiki/Ticket_lock) providing mutually exclusive access to data./// A ticket lock is analogous to a queue management system for lock requests. When a thread tries to take a lock, it/// is assigned a 'ticket'. It then spins until its ticket becomes next in line. When the lock guard is released, the/// next ticket will be processed./// Ticket locks significantly reduce the worse-case performance of locking at the cost of slightly higher average-time/// overhead./// let lock = spin::mutex::TicketMutex::<_>::new(0);/// let spin_mutex = Arc::new(spin::mutex::TicketMutex::<_>::new(0));TicketMutexGuard/// A guard that protects some data./// When the guard is dropped, the next ticket will be processed./// Creates a new [`TicketMutex`] wrapping the supplied data./// use spin::mutex::TicketMutex;/// static MUTEX: TicketMutex<()> = TicketMutex::<_>::new(());/// Consumes this [`TicketMutex`] and unwraps the underlying data./// let lock = spin::mutex::TicketMutex::<_>::new(42);/// Returns a mutable pointer to the underying data./// Locks the [`TicketMutex`] and returns a guard that permits access to the inner data./// The returned data may be dereferenced for data access/// Force unlock this [`TicketMutex`], by serving the next ticket./// Try to lock this [`TicketMutex`], returning a lock guard if successful./// Since this call borrows the [`TicketMutex`] mutably, and a mutable reference is guaranteed to be exclusive in/// let mut lock = spin::mutex::TicketMutex::<_>::new(0);/// Note that this function will permanently lock the original [`TicketMutex`]./// let mylock = spin::mutex::TicketMutex::<_>::new(0);/// let data: &mut i32 = spin::mutex::TicketMutexGuard::leak(mylock.lock());//! A ticket-based mutex.//! Waiting threads take a 'ticket' from the lock in the order they arrive and gain access to the lock when their//! ticket is next in the queue. Best-case latency is slightly worse than a regular spinning mutex, but worse-case//! latency is infinitely better. Waiting threads simply need to wait for all threads that come before them in the//! queue to finish.InnerMutexInnerMutexGuard/// A spin-based lock providing mutually exclusive access to data./// The implementation uses either a ticket mutex or a regular spin mutex depending on whether the `spin_mutex` or/// `ticket_mutex` feature flag is enabled./// let lock = spin::Mutex::new(0);/// let spin_mutex = Arc::new(spin::Mutex::new(0));/// A generic guard that will protect some data access and/// uses either a ticket lock or a normal spin mutex./// For more info see [`TicketMutexGuard`] or [`SpinMutexGuard`]./// [`TicketMutexGuard`]: ./struct.TicketMutexGuard.html/// [`SpinMutexGuard`]: ./struct.SpinMutexGuard.html/// Creates a new [`Mutex`] wrapping the supplied data./// use spin::Mutex;/// static MUTEX: Mutex<()> = Mutex::new(());/// Consumes this [`Mutex`] and unwraps the underlying data./// let lock = spin::Mutex::new(42);/// Locks the [`Mutex`] and returns a guard that permits access to the inner data./// Force unlock this [`Mutex`]./// Try to lock this [`Mutex`], returning a lock guard if successful./// Since this call borrows the [`Mutex`] mutably, and a mutable reference is guaranteed to be exclusive in Rust,/// no actual locking needs to take place -- the mutable borrow statically guarantees no locks exist. As such,/// this is a 'zero-cost' operation./// let mut lock = spin::Mutex::new(0);/// Note that this function will permanently lock the original [`Mutex`]./// let mylock = spin::Mutex::new(0);/// let data: &mut i32 = spin::MutexGuard::leak(mylock.lock());//! Locks that have the same behaviour as a mutex.//! The [`Mutex`] in the root of the crate, can be configured using the `ticket_mutex` feature.//! If it's enabled, [`TicketMutex`] and [`TicketMutexGuard`] will be re-exported as [`Mutex`]//! and [`MutexGuard`], otherwise the [`SpinMutex`] and guard will be re-exported.//! `ticket_mutex` is disabled by default.//! [`Mutex`]: ../struct.Mutex.html//! [`MutexGuard`]: ../struct.MutexGuard.html//! [`TicketMutex`]: ./struct.TicketMutex.html//! [`TicketMutexGuard`]: ./struct.TicketMutexGuard.html//! [`SpinMutex`]: ./struct.SpinMutex.html//! [`SpinMutexGuard`]: ./struct.SpinMutexGuard.htmlAtomicStatus/// A primitive that provides lazy one-time initialization./// Unlike its `std::sync` equivalent, this is generalized such that the closure returns a/// value to be stored by the [`Once`] (`std::sync::Once` can be trivially emulated with/// `Once`)./// Because [`Once::new`] is `const`, this primitive may be used to safely initialize statics./// static START: spin::Once = spin::Once::new();// Same unsafe impls as `std::sync::RwLock`, because this also allows for// concurrent reads.// SAFETY: This structure has an invariant, namely that the inner atomic u8 must *always* have// a value for which there exists a valid Status. This means that users of this API must only// be allowed to load and store `Status`es.Panicked// Four states that a Once can be in, encoded into the lower bits of `status` in// the Once structure.// Construct a status from an inner u8 integer.// For this to be safe, the inner number must have a valid corresponding enum variant./// has run and completed (it may not be the closure specified). The/// returned pointer will point to the result from the closure that was/// run./// This function will panic if the [`Once`] previously panicked while attempting/// to initialize. This is similar to the poisoning behaviour of `std::sync`'s/// static INIT: spin::Once<usize> = spin::Once::new();///     *INIT.call_once(expensive_computation)try_call_once/// This method is similar to `call_once`, but allows the given closure to/// fail, and lets the `Once` in a uninitialized state if it does./// When this function returns without error, it is guaranteed that some/// initialization has run and completed (it may not be the closure/// specified). The returned reference will point to the result from the/// closure that was run./// fn get_cached_val() -> Result<usize, String> {///     INIT.try_call_once(expensive_fallible_computation).map(|x| *x)/// fn expensive_fallible_computation() -> Result<usize, String> {/// # Ok(2)try_call_once_slow/// Spins until the [`Once`] contains a value./// Note that in releases prior to `0.7`, this function had the behaviour of [`Once::poll`]./// Like [`Once::get`], but will spin if the [`Once`] is in the process of being/// initialized. If initialization has not even begun, `None` will be returned./// Note that in releases prior to `0.7`, this function was named `wait`./// Initialization constant of [`Once`]./// Creates a new [`Once`]./// Creates a new initialized [`Once`]./// Retrieve a pointer to the inner data./// While this method itself is safe, accessing the pointer before the [`Once`] has been/// initialized is UB, unless this method has already been written to from a pointer coming/// from this method.force_get/// Get a reference to the initialized instance. Must only be called once COMPLETE.force_get_mutforce_into_inner/// Returns a reference to the inner value if the [`Once`] has been initialized./// Returns a reference to the inner value on the unchecked assumption that the  [`Once`] has been initialized./// This is *extremely* unsafe if the `Once` has not already been initialized because a reference to uninitialized/// memory will be returned, immediately triggering undefined behaviour (even if the reference goes unused)./// However, this can be useful in some instances for exposing the `Once` to FFI or when the overhead of atomically/// checking initialization is unacceptable and the `Once` has already been initialized./// Returns a mutable reference to the inner value if the [`Once`] has been initialized./// Because this method requires a mutable reference to the [`Once`], no synchronization/// overhead is required to access the inner value. In effect, it is zero-cost.get_mut_unchecked/// Returns a mutable reference to the inner value/// Returns a the inner value if the [`Once`] has been initialized./// Because this method requires ownership of the [`Once`], no synchronization overhead/// is required to access the inner value. In effect, it is zero-cost./// Returns a the inner value if the [`Once`] has been initialized.  /// memory will be returned, immediately triggering undefined behaviour (even if the reference goes unused)/// This can be useful, if `Once` has already been initialized, and you want to bypass an/// option check./// Checks whether the value has been initialized./// This is done using [`Acquire`](core::sync::atomic::Ordering::Acquire) ordering, and/// therefore it is safe to access the value directly via/// [`get_unchecked`](Self::get_unchecked) if this returns true.smoke_once_valueget_no_waitinit_constantCALLEDDropTesttry_call_once_errdrop_occurs_and_skip_uninit_drop// This is sort of two test cases, but if we write them as separate test methods// they can be executed concurrently and then fail some small fraction of thecall_once_test//! Synchronization primitives for one-time evaluation./// Perform the relaxing operation during a period of contention./// A trait implemented by spinning relax strategies./// A strategy that rapidly spins while informing the CPU that it should power down non-essential components via/// [`core::hint::spin_loop`]./// Note that spinning is a 'dumb' strategy and most schedulers cannot correctly differentiate it from useful work,/// thereby misallocating even more CPU time to the spinning process. This is known as/// ['priority inversion'](https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html)./// If you see signs that priority inversion is occurring, consider switching to [`Yield`] or, even better, not using a/// spinlock at all and opting for a proper scheduler-aware lock. Remember also that different targets, operating/// systems, schedulers, and even the same scheduler with different workloads will exhibit different behaviour. Just/// because priority inversion isn't occurring in your tests does not mean that it will not occur. Use a scheduler-/// aware lock if at all possible./// A strategy that rapidly spins, without telling the CPU to do any powering down./// You almost certainly do not want to use this. Use [`Spin`] instead. It exists for completeness and for targets/// that, for some reason, miscompile or do not support spin hint intrinsics despite attempting to generate code for/// them (i.e: this is a workaround for possible compiler bugs).//! Strategies that determine the behaviour of locks when encountering contention./// A lock that provides data access to either one writer or many readers./// This lock behaves in a similar manner to its namesake `std::sync::RwLock` but uses/// spinning for synchronisation instead. Unlike its namespace, this lock does not/// track lock poisoning./// required that `T` satisfies `Send` to be shared across tasks and `Sync` to/// An [`RwLockUpgradableGuard`](RwLockUpgradableGuard) can be upgraded to a/// writable guard through the [`RwLockUpgradableGuard::upgrade`](RwLockUpgradableGuard::upgrade)/// [`RwLockUpgradableGuard::try_upgrade`](RwLockUpgradableGuard::try_upgrade) functions./// Writable or upgradeable guards can be downgraded through their respective `downgrade`/// Based on Facebook's/// [`folly/RWSpinLock.h`](https://github.com/facebook/folly/blob/a0394d84f2d5c3e50ebfd0566f9d3acb52cfab5a/folly/synchronization/RWSpinLock.h)./// This implementation is unfair to writers - if the lock always has readers, then no writers will/// ever get a chance. Using an upgradeable lock guard can *somewhat* alleviate this issue as no/// new readers are allowed when an upgradeable guard is held, but upgradeable guards can be taken/// when there are existing readers. However if the lock is that highly contended and writes are/// crucial then this implementation may be a poor choice./// let lock = spin::RwLock::new(5);READERUPGRADEDWRITER/// A guard that provides immutable data access./// When the guard falls out of scope it will decrement the read count,/// potentially releasing the lock./// A guard that provides immutable data access but can be upgraded to [`RwLockWriteGuard`]./// No writers or other upgradeable guards can exist while this is in scope. New reader/// creation is prevented (to alleviate writer starvation) but there may be existing readers/// when the lock is acquired.// Same unsafe impls as `std::sync::RwLock`/// Creates a new spinlock wrapping the supplied data./// May be used statically:/// static RW_LOCK: spin::RwLock<()> = spin::RwLock::new(());///     let lock = RW_LOCK.read();/// While this is safe, writing to the data is undefined behavior unless the current thread has/// acquired a write lock, and reading requires either a read or write lock./// let lock = spin::RwLock::new(42);///     core::mem::forget(lock.write());///     lock.force_write_unlock();/// assert_eq!(*lock.read(), 58);/// Locks this rwlock with shared read access, blocking the current thread/// this method returns. This method does not provide any guarantees with/// respect to the ordering of whether contentious readers or writers will/// acquire the lock first./// let mylock = spin::RwLock::new(0);///     let mut data = mylock.read();///     // The lock is now locked and the data can be read///     println!("{}", *data);///     // The lock is dropped/// Lock this rwlock with exclusive write access, blocking the current/// Returns an RAII guard which will drop the write access of this rwlock///     let mut data = mylock.write();///     // The lock is now locked and the data can be writtenupgradeable_read/// Obtain a readable lock guard that can later be upgraded to a writable lock guard./// Upgrades can be done through the [`RwLockUpgradableGuard::upgrade`](RwLockUpgradableGuard::upgrade) method.acquire_reader// Acquire a read lock, returning the new lock value./// Attempt to acquire this lock with shared read access./// This function will never block and will return immediately if `read`/// would otherwise succeed. Returns `Some` of an RAII guard which will/// release the shared access of this thread when dropped, or `None` if the/// access could not be granted. This method does not provide any/// guarantees with respect to the ordering of whether contentious readers///     match mylock.try_read() {///         Some(data) => {///             // The lock is now locked and the data can be read///             println!("{}", *data);///             // The lock is dropped///         None => (), // no cigarreader_count/// Return the number of readers that currently hold the lock (including upgradable readers).writer_count/// Return the number of writers that currently hold the lock./// Because [`RwLock`] guarantees exclusive mutable access, this function may only return either `0` or `1`.force_read_decrement/// Force decrement the reader count./// This is *extremely* unsafe if there are outstanding `RwLockReadGuard`s/// live, or if called more times than `read` has been called, but can be/// useful in FFI contexts where the caller doesn't know how to deal with/// RAII. The underlying atomic operation uses `Ordering::Release`.force_write_unlock/// Force unlock exclusive write access./// This is *extremely* unsafe if there are outstanding `RwLockWriteGuard`s/// live, or if called when there are current readers, but can be useful in/// FFI contexts where the caller doesn't know how to deal with RAII. The/// underlying atomic operation uses `Ordering::Release`.try_write_internal/// Attempt to lock this rwlock with exclusive write access./// This function does not ever block, and it will return `None` if a call/// to `write` would otherwise block. If successful, an RAII guard is///     match mylock.try_write() {///         Some(mut data) => {///             // The lock is now locked and the data can be written///             *data += 1;///             // The lock is implicitly droppedtry_upgradeable_read/// Tries to obtain an upgradeable lock guard./// let mut lock = spin::RwLock::new(0);/// assert_eq!(*lock.read(), 10);'rwlock/// Leak the lock guard, yielding a reference to the underlying data./// Note that this function will permanently lock the original lock for all but reading locks./// let data: &i32 = spin::RwLockReadGuard::leak(mylock.read());/// assert_eq!(*data, 0);/// Upgrades an upgradeable lock guard to a writable lock guard./// let upgradeable = mylock.upgradeable_read(); // Readable, but not yet writable/// let writable = upgradeable.upgrade();try_upgrade_internal/// Tries to upgrade an upgradeable lock guard to a writable lock guard./// match upgradeable.try_upgrade() {///     Ok(writable) => /* upgrade successful - use writable lock guard */ (),///     Err(upgradeable) => /* upgrade unsuccessful */ (),/// Downgrades the upgradeable lock guard to a readable, shared lock guard. Cannot fail and is guaranteed not to spin./// let mylock = spin::RwLock::new(1);/// let upgradeable = mylock.upgradeable_read();/// assert!(mylock.try_read().is_none());/// assert_eq!(*upgradeable, 1);/// let readable = upgradeable.downgrade(); // This is guaranteed not to spin/// assert!(mylock.try_read().is_some());/// assert_eq!(*readable, 1);/// Note that this function will permanently lock the original lock./// let data: &i32 = spin::RwLockUpgradableGuard::leak(mylock.upgradeable_read());/// Downgrades the writable lock guard to a readable, shared lock guard. Cannot fail and is guaranteed not to spin./// let mut writable = mylock.write();/// *writable = 1;/// let readable = writable.downgrade(); // This is guaranteed not to spin/// # let readable_2 = mylock.try_read().unwrap();downgrade_to_upgradeable/// Downgrades the writable lock guard to an upgradable, shared lock guard. Cannot fail and is guaranteed not to spin./// let readable = writable.downgrade_to_upgradeable(); // This is guaranteed not to spin/// let data: &mut i32 = spin::RwLockWriteGuard::leak(mylock.write());test_rw_access_in_unwindtest_rw_try_readtest_force_read_decrementtest_force_write_unlocktest_upgrade_downgrade// TODO: needs RNG//#[test]//fn frob() {//    static R: RwLock = RwLock::new();//    const N: usize = 10;//    const M: usize = 1000;//    let (tx, rx) = channel::<()>();//    for _ in 0..N {//        let tx = tx.clone();//        thread::spawn(move|| {//            let mut rng = rand::thread_rng();//            for _ in 0..M {//                if rng.gen_weighted_bool(N) {//                    drop(R.write());//                } else {//                    drop(R.read());//            drop(tx);//        });//    drop(tx);//    let _ = rx.recv();//    unsafe { R.destroy(); }//! A lock that provides data access to either one writer or many readers./// Algorithm OID, i.e. the `algorithm` field in the `AlgorithmIdentifier`/// ASN.1 schema./// Algorithm `parameters`./// X.509 `AlgorithmIdentifier` as defined in [RFC 5280 Section 4.1.1.2].///      algorithm               OBJECT IDENTIFIER,///      parameters              ANY DEFINED BY algorithm OPTIONAL  }/// [RFC 5280 Section 4.1.1.2]: https://tools.ietf.org/html/rfc5280#section-4.1.1.2/// `AlgorithmIdentifier` reference which has `AnyRef` parameters.AlgorithmIdentifierWithOid/// `AlgorithmIdentifier` with `ObjectIdentifier` parameters./// `AlgorithmIdentifier` reference which has `Any` parameters.assert_algorithm_oid/// Assert the `algorithm` OID is an expected value.assert_parameters_oid/// Assert `parameters` is an OID and has the expected value.assert_oids/// Assert the values of the `algorithm` and `parameters` OIDs.parameters_any/// Get the `parameters` field as an [`AnyRef`]./// Returns an error if `parameters` are `None`.parameters_oid/// Get the `parameters` field as an [`ObjectIdentifier`]./// Returns an error if it is absent or not an OID.oids/// Convert to a pair of [`ObjectIdentifier`]s./// This method is helpful for decomposing in match statements. Note in/// particular that `NULL` parameters are treated the same as missing/// Returns an error if parameters are present but not an OID.//! X.509 `AlgorithmIdentifier`/// Result type with `spki` crate's [`Error`] type.AlgorithmParametersMissing/// Algorithm parameters are missing./// Malformed cryptographic key contained in a SPKI document./// in [`SubjectPublicKeyInfo::subject_public_key`][`crate::SubjectPublicKeyInfo::subject_public_key`]./// Unrecognized OID value found in e.g. a SPKI `AlgorithmIdentifier`./// Unknown algorithm OID./// Size of a SHA-256 SPKI fingerprint in bytes.FingerprintBytes/// Raw bytes of a SPKI fingerprint i.e. SHA-256 digest of/// `SubjectPublicKeyInfo`'s DER encoding./// See [RFC7469 § 2.1.1] for more information./// [RFC7469 § 2.1.1]: https://datatracker.ietf.org/doc/html/rfc7469#section-2.1.1/// In-progress digest being computed from streaming DER./// Writer newtype which accepts DER being serialized on-the-fly and computes a/// hash of the contents./// Create a new fingerprint builder./// Finish computing a fingerprint, returning the computed digest.//! SPKI fingerprint support.SubjectPublicKeyInfoOwnedDynSignatureAlgorithmIdentifier//! The following example demonstrates how to use an OID as the `parameters`//! of an [`AlgorithmIdentifier`].//! Borrow the [`ObjectIdentifier`] first then use [`der::AnyRef::from`] or `.into()`://! use spki::{AlgorithmIdentifier, ObjectIdentifier};//! let alg_oid = "1.2.840.10045.2.1".parse::<ObjectIdentifier>().unwrap();//! let params_oid = "1.2.840.10045.3.1.7".parse::<ObjectIdentifier>().unwrap();//! let alg_id = AlgorithmIdentifier {//!     oid: alg_oid,//!     parameters: Some(params_oid)/// [`SubjectPublicKeyInfo`] with [`AnyRef`] algorithm parameters, and [`BitStringRef`] params./// [`SubjectPublicKeyInfo`] with [`Any`] algorithm parameters, and [`BitString`] params./// X.509 [`AlgorithmIdentifier`] for the public key type/// Public key data/// X.509 `SubjectPublicKeyInfo` (SPKI) as defined in [RFC 5280 § 4.1.2.7]./// ASN.1 structure containing an [`AlgorithmIdentifier`] and public key/// data in an algorithm specific format.///    SubjectPublicKeyInfo  ::=  SEQUENCE  {///         algorithm            AlgorithmIdentifier,///         subjectPublicKey     BIT STRING  }/// [RFC 5280 § 4.1.2.7]: https://tools.ietf.org/html/rfc5280#section-4.1.2.7// TODO: replace FixedTag with FixedTag<TAG = { Tag::BitString }> once// https://github.com/rust-lang/rust/issues/92827 is fixed/// Create a [`SubjectPublicKeyInfoOwned`] from any object that implements/// [`EncodePublicKey`].//! X.509 `SubjectPublicKeyInfo`from_public_key_der/// Deserialize object from ASN.1 DER-encoded [`SubjectPublicKeyInfo`]from_public_key_pem/// Deserialize PEM-encoded [`SubjectPublicKeyInfo`].read_public_key_der_file/// Load public key object from an ASN.1 DER-encoded file on the localread_public_key_pem_file/// Load public key object from a PEM-encoded file on the local filesystem./// Parse a public key object from an encoded SPKI document./// Serialize a [`Document`] containing a SPKI-encoded public key.to_public_key_pem/// Serialize this public key as PEM-encoded SPKI with the given [`LineEnding`].write_public_key_der_file/// Write ASN.1 DER-encoded public key to the given pathwrite_public_key_pem_file/// Serialize a public key object to a SPKI-encoded document./// Algorithm parameters./// `AlgorithmIdentifier` for this structure./// Returns `AlgorithmIdentifier` associated with the structure./// This is useful for e.g. keys for digital signature algorithms./// `AlgorithmIdentifier` for the corresponding singature system./// Returns `AlgorithmIdentifier` associated with the signature system./// Unlike AssociatedAlgorithmIdentifier this is intended to be implemented for public and/or/// private keys.signature_algorithm_identifier/// `BitString` encoding for this signature./// Returns the `BitString` encoding of the signature./// X.509 and CSR structures require signatures to be BitString encoded.//! Traits for encoding/decoding SPKI public keys.assert_cfg/// Asserts that a given configuration is set./// A project will simply fail to compile if the given configuration is not set./// # #[macro_use] extern crate static_assertions; fn main() {}/// // We're not masochists/// # #[cfg(not(target_pointer_width = "16"))] // Just in case/// assert_cfg!(not(target_pointer_width = "16"));/// If a project does not support a set of configurations, you may want to/// report why. There is the option of providing a compile error message string:/// # #[cfg(any(unix, windows))]/// assert_cfg!(any(unix, windows), "There is only support for Unix or Windows");/// // User needs to specify a database back-end/// # #[cfg(target_pointer_width = "0")] // Impossible/// assert_cfg!(all(not(all(feature = "mysql", feature = "mongodb")),///                 any(    feature = "mysql", feature = "mongodb")),///             "Must exclusively use MySQL or MongoDB as database back-end");/// Some configurations are impossible. For example, we can't be compiling for/// both macOS _and_ Windows simultaneously:/// assert_cfg!(all(target_os = "macos",///                 target_os = "windows"),///             "No, that's not how it works! ಠ_ಠ");/// Asserts that types are equal in alignment./// This is useful when ensuring that pointer arithmetic is done correctly, or/// when [FFI] requires a type to have the same alignment as some foreign type./// A `usize` has the same alignment as any pointer type:/// assert_eq_align!(usize, *const u8, *mut u8);/// The following passes because `[i32; 4]` has the same alignment as `i32`:/// assert_eq_align!([i32; 4], i32);/// The following example fails to compile because `i32x4` explicitly has 4/// times the alignment as `[i32; 4]`:/// #[repr(align(16))]/// struct i32x4([i32; 4]);/// assert_eq_align!(i32x4, [i32; 4]);/// [FFI]: https://en.wikipedia.org/wiki/Foreign_function_interface/// Asserts that types are equal in size./// When performing operations such as pointer casts or dealing with [`usize`]/// versus [`u64`] versus [`u32`], the size of your types matter. That is where/// this macro comes into play./// # Alternatives/// There also exists [`assert_eq_size_val`](macro.assert_eq_size_val.html) and/// [`assert_eq_size_ptr`](macro.assert_eq_size_ptr.html). Instead of specifying/// types to compare, values' sizes can be directly compared against each other./// These three types, despite being very different, all have the same size:/// assert_eq_size!([u8; 4], (u16, u16), u32);/// The following example fails to compile because `u32` has 4 times the size of/// `u8`:/// assert_eq_size!(u32, u8);/// [`u64`]: https://doc.rust-lang.org/std/primitive.u64.html/// [`u32`]: https://doc.rust-lang.org/std/primitive.u32.htmlassert_eq_size_ptr/// Asserts that values pointed to are equal in size./// This especially is useful for when coercing pointers between different types/// and ensuring the underlying values are the same size./// fn operation(x: &(u32, u32), y: &[u16; 4]) {///     assert_eq_size_ptr!(x, y);/// The following example fails to compile because byte arrays of different/// lengths have different sizes:/// # #[macro_use] extern crate static_assertions;/// static BYTES: &[u8; 4] = &[///     /* ... *////     # 0; 4/// static TABLE: &[u8; 16] = &[///     # 0; 16/// assert_eq_size_ptr!(BYTES, TABLE);assert_eq_size_val/// Asserts that values are equal in size./// This macro doesn't consume its arguments and thus works for/// non-[`Clone`]able values./// struct Byte(u8);/// let x = 10u8;/// let y = Byte(42); // Works for non-cloneable types/// assert_eq_size_val!(x, y);/// assert_eq_size_val!(x, y, 0u8);/// Even though both values are 0, they are of types with different sizes:/// assert_eq_size_val!(0u8, 0u32);/// [`Clone`]: https://doc.rust-lang.org/std/clone/trait.Clone.htmlassert_fields/// Asserts that the type has the given fields./// One common use case is when types have fields defined multiple times as a/// result of `#[cfg]`. This can be an issue when exposing a public API./// pub struct Ty {///     pub val1: u8,///     #[cfg(not(windows))]///     pub val1: usize,///     pub val2: u32,///     #[cfg(not(unix))]///     pub val2: usize,/// // Always have `val2` regardless of OS/// assert_fields!(Ty: val2);/// This macro even works with `enum` variants:/// enum Data {///     Val {///         id: i32,///         name: String,///         bytes: [u8; 128],///     Ptr(*const u8),/// assert_fields!(Data::Val: id, bytes);/// The following example fails to compile because [`Range`] does not have a field named `middle`:/// assert_fields!(Range<u32>: middle);/// [`Range`]: https://doc.rust-lang.org/std/ops/struct.Range.htmlassert_impl_one/// Asserts that the type implements exactly one in a set of traits./// Related:/// - [`assert_impl_any!`]/// - [`assert_impl_all!`]/// - [`assert_not_impl_all!`]/// - [`assert_not_impl_any!`]/// Given some type `Foo`, it is expected to implement either `Snap`, `Crackle`,/// or `Pop`:/// # use static_assertions::assert_impl_one; fn main() {}/// trait Snap {}/// trait Crackle {}/// trait Pop {}/// assert_impl_one!(Foo: Snap, Crackle, Pop);/// If _only_ `Crackle` is implemented, the assertion passes:/// # struct Foo;/// # trait Snap {}/// # trait Crackle {}/// # trait Pop {}/// impl Crackle for Foo {}/// If `Snap` or `Pop` is _also_ implemented, the assertion fails:/// # impl Crackle for Foo {}/// impl Pop for Foo {}/// [`assert_impl_any!`]:     macro.assert_impl_any.html/// [`assert_impl_all!`]:     macro.assert_impl_all.html/// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html/// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html/// Asserts that the type implements _all_ of the given traits./// See [`assert_not_impl_all!`] for achieving the opposite effect./// This can be used to ensure types implement auto traits such as [`Send`] and/// [`Sync`], as well as traits with [blanket `impl`s][blanket]./// assert_impl_all!(u32: Copy, Send);/// assert_impl_all!(&str: Into<String>);/// The following example fails to compile because raw pointers do not implement/// [`Send`] since they cannot be moved between threads safely:/// assert_impl_all!(*const u8: Send);/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html/// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methodsassert_impl_any/// Asserts that the type implements _any_ of the given traits./// See [`assert_not_impl_any!`] for achieving the opposite effect./// `u8` cannot be converted from `u16`, but it can be converted into `u16`:/// assert_impl_any!(u8: From<u16>, Into<u16>);/// The unit type cannot be converted from `u8` or `u16`, but it does implement/// [`Send`]:/// assert_impl_any!((): From<u8>, From<u16>, Send);/// [`Send`] or [`Sync`] since they cannot be moved or shared between threads/// safely:/// assert_impl_any!(*const u8: Send, Sync);assert_not_impl_all/// Asserts that the type does **not** implement _all_ of the given traits./// This can be used to ensure types do not implement auto traits such as/// [`Send`] and [`Sync`], as well as traits with [blanket `impl`s][blanket]./// Note that the combination of all provided traits is required to not be/// implemented. If you want to check that none of multiple traits are/// implemented you should invoke [`assert_not_impl_any!`] instead./// Although `u32` implements `From<u16>`, it does not implement `Into<usize>`:/// assert_not_impl_all!(u32: From<u16>, Into<usize>);/// The following example fails to compile since `u32` can be converted into/// assert_not_impl_all!(u32: Into<u64>);/// The following compiles because [`Cell`] is not both [`Sync`] _and_ [`Send`]:/// assert_not_impl_all!(Cell<u32>: Sync, Send);/// But it is [`Send`], so this fails to compile:/// # std::cell::Cell;/// assert_not_impl_all!(Cell<u32>: Send);/// Asserts that the type does **not** implement _any_ of the given traits./// This macro causes a compilation failure if any of the provided individual/// traits are implemented for the type. If you want to check that a combination/// of traits is not implemented you should invoke [`assert_not_impl_all!`]/// instead. For single traits both macros behave the same./// If `u32` were to implement `Into` conversions for `usize` _and_ for `u8`,/// the following would fail to compile:/// assert_not_impl_any!(u32: Into<usize>, Into<u8>);/// This is also good for simple one-off cases:/// assert_not_impl_any!(&'static mut u8: Copy);/// `u64` even though it can not be converted into a `u16`:/// assert_not_impl_any!(u32: Into<u64>, Into<u16>);assert_obj_safe// FIXME: Link below is required to render in index/// Asserts that the traits support dynamic dispatch/// ([object-safety](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#object-safety-is-required-for-trait-objects))./// This is useful for when changes are made to a trait that accidentally/// prevent it from being used as an [object]. Such a case would be adding a/// generic method and forgetting to add `where Self: Sized` after it. If left/// unnoticed, that mistake will affect crate users and break both forward and/// backward compatibility./// When exposing a public API, it's important that traits that could previously/// use dynamic dispatch can still do so in future compatible crate versions./// trait MySafeTrait {///     fn foo(&self) -> u32;/// assert_obj_safe!(std::fmt::Write, MySafeTrait);/// Works with traits that are not in the calling module:/// mod inner {///     pub trait BasicTrait {///         fn bar(&self);///     assert_obj_safe!(BasicTrait);/// assert_obj_safe!(inner::BasicTrait);/// The following example fails to compile because raw pointers cannot be sent///  between threads safely:/// assert_impl!(*const u8, Send);/// The following example fails to compile because generics without/// `where Self: Sized` are not allowed in [object-safe][object] trait methods:/// trait MyUnsafeTrait {///     fn baz<T>(&self) -> T;/// assert_obj_safe!(MyUnsafeTrait);/// When we fix that, the previous code will compile:///     fn baz<T>(&self) -> T where Self: Sized;/// [object]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html#object-safety-is-required-for-trait-objectsassert_trait_sub_all/// Asserts that the trait is a child of all of the other traits./// - [`assert_trait_super_all!`]/// All types that implement [`Copy`] must implement [`Clone`]:/// assert_trait_sub_all!(Copy: Clone);/// All types that implement [`Ord`] must implement [`PartialEq`], [`Eq`], and/// [`PartialOrd`]:/// assert_trait_sub_all!(Ord: PartialEq, Eq, PartialOrd);/// The following example fails to compile because [`Eq`] is not required for/// assert_trait_sub_all!(PartialOrd: Eq);/// [`assert_trait_super_all!`]: macro.assert_trait_super_all.html/// [`Copy`]:       https://doc.rust-lang.org/std/marker/trait.Copy.html/// [`Clone`]:      https://doc.rust-lang.org/std/clone/trait.Clone.html/// [`Ord`]:        https://doc.rust-lang.org/std/cmp/trait.Ord.html/// [`PartialOrd`]: https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html/// [`Eq`]:         https://doc.rust-lang.org/std/cmp/trait.Eq.html/// [`PartialEq`]:  https://doc.rust-lang.org/std/cmp/trait.PartialEq.htmlassert_trait_super_all/// Asserts that the trait is a parent of all of the other traits./// - [`assert_trait_sub_all!`]/// With this, traits `A` and `B` can both be tested to require [`Copy`] on a/// single line:/// # use static_assertions::assert_trait_super_all;/// trait A: Copy {}/// trait B: Copy {}/// assert_trait_super_all!(Copy: A, B);/// Otherwise, each sub-trait would require its own call to/// [`assert_trait_sub_all!`]:/// # trait A: Copy {}/// # trait B: Copy {}/// assert_trait_sub_all!(A: Copy);/// assert_trait_sub_all!(B: Copy);/// The following example fails to compile because trait `C` does not require/// [`Copy`]:/// trait C {}/// assert_trait_super_all!(Copy: A, B, C);/// [`assert_trait_sub_all!`]: macro.assert_trait_sub_all.html/// [`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html/// Asserts that _all_ types in a list are equal to each other./// Often times, type aliases are used to express usage semantics via naming. In/// some cases, the underlying type may differ based on platform. However, other/// types like [`c_float`] will always alias the same type./// use std::os::raw::c_float;/// assert_type_eq_all!(c_float, f32);/// This macro can also be used to compare types that involve lifetimes! Just/// use `'static` in that case:/// type Buf<'a> = &'a [u8];/// assert_type_eq_all!(Buf<'static>, &'static [u8]);/// The following example fails to compile because `String` and `str` do not/// refer to the same type:/// assert_type_eq_all!(String, str);/// This should also work the other way around, regardless of [`Deref`]/// assert_type_eq_all!(str, String);/// [`c_float`]: https://doc.rust-lang.org/std/os/raw/type.c_float.html/// [`Deref`]: https://doc.rust-lang.org/std/ops/trait.Deref.htmlassert_type_ne_all/// Asserts that _all_ types are **not** equal to each other./// Rust has all sorts of slices, but they represent different types of data:/// assert_type_ne_all!([u8], [u16], str);/// The following example fails to compile because [`c_uchar`] is a type alias/// for [`u8`]:/// use std::os::raw::c_uchar;/// assert_type_ne_all!(c_uchar, u8, u32);/// [`c_uchar`]: https://doc.rust-lang.org/std/os/raw/type.c_uchar.html/// [`u8`]: https://doc.rust-lang.org/std/primitive.u8.html/// Asserts that constant expressions evaluate to `true`./// Constant expressions can be ensured to have certain properties via this/// macro If the expression evaluates to `false`, the file will fail to compile./// This is synonymous to [`static_assert` in C++][static_assert]./// There also exists [`const_assert_eq`](macro.const_assert_eq.html) for/// validating whether a sequence of expressions are equal to one another./// A common use case is to guarantee properties about a constant value that's/// generated via meta-programming./// const VALUE: i32 = // .../// # 3;/// const_assert!(VALUE >= 2);/// Inputs are type-checked as booleans:/// const_assert!(!0);/// Despite this being a macro, we see this produces a type error:///   | const_assert!(!0);///   |               ^^ expected bool, found integral variable///   = note: expected type `bool`///              found type `{integer}`/// The following fails to compile because multiplying by 5 does not have an/// identity property:/// const_assert!(5 * 5 == 5);/// [static_assert]: http://en.cppreference.com/w/cpp/language/static_assert/// Asserts that constants are equal in value./// This works as a shorthand for `const_assert!(a == b)`:/// const TWO: usize = 2;/// const_assert_eq!(TWO * TWO, TWO + TWO);/// Just because 2 × 2 = 2 + 2 doesn't mean it holds true for other numbers:/// const_assert_eq!(4 + 4, 4 * 4);/// Asserts that constants are **not** equal in value./// This works as a shorthand for `const_assert!(a != b)`:/// const NUM: usize = 32;/// const_assert_ne!(NUM * NUM, 64);/// The following example fails to compile because 2 is magic and 2 × 2 = 2 + 2:/// const_assert_ne!(2 + 2, 2 * 2);assert_implassert_traitassert_type//! [![Banner](https://raw.githubusercontent.com/nvzqz/static-assertions-rs/assets/Banner.png)](https://github.com/nvzqz/static-assertions-rs)//! <div align="center">//!     <a href="https://crates.io/crates/static_assertions">//!         <img src="https://img.shields.io/crates/d/static_assertions.svg" alt="Downloads">//!     </a>//!     <a href="https://travis-ci.org/nvzqz/static-assertions-rs">//!         <img src="https://travis-ci.org/nvzqz/static-assertions-rs.svg?branch=master" alt="Build Status">//!     <img src="https://img.shields.io/badge/rustc-^1.37.0-blue.svg" alt="rustc ^1.37.0">//!     <br><br>//! Assertions to ensure correct assumptions about constants, types, and more.//! _All_ checks provided by this crate are performed at [compile-time]. This//! allows for finding errors quickly and early when it comes to ensuring//! certain features or aspects of a codebase. These macros are especially//! important when exposing a public API that requires types to be the same size//! or implement certain traits.//! This crate is available [on crates.io][crate] and can be used by adding the//! following to your project's [`Cargo.toml`]://! static_assertions = "1.1.0"//! and this to your crate root (`main.rs` or `lib.rs`)://! extern crate static_assertions;//! When using [Rust 2018 edition][2018], the following shorthand can help if//! having `#[macro_use]` is undesirable.//! extern crate static_assertions as sa;//! sa::const_assert!(true);//! Very thorough examples are provided in the docs for//! [each individual macro](#macros). Failure case examples are also documented.//! # Changes//! See [`CHANGELOG.md`](https://github.com/nvzqz/static-assertions-rs/blob/master/CHANGELOG.md)//! for an exhaustive list of what has changed from one version to another.//! # Donate//! This project is made freely available (as in free beer), but unfortunately//! not all beer is free! So, if you would like to buy me a beer (or coffee or//! *more*), then consider supporting my work that's benefited your project//! and thousands of others.//! <a href="https://www.patreon.com/nvzqz">//!     <img src="https://c5.patreon.com/external/logo/become_a_patron_button.png" alt="Become a Patron!" height="35">//! </a>//! <a href="https://www.paypal.me/nvzqz">//!     <img src="https://buymecoffee.intm.org/img/button-paypal-white.png" alt="Buy me a coffee" height="35">//! [Rust 1.37]: https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html//! [2018]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html#rust-2018//! [crate]: https://crates.io/crates/static_assertions//! [compile-time]: https://en.wikipedia.org/wiki/Compile_time//! [`Cargo.toml`]: https://doc.rust-lang.org/cargo/reference/manifest.htmllong_divisionlong_multiplicationmultiplierStrengthReducedU8/// Implements unsigned division and modulo via mutiplication and shifts.
/// Creating a an instance of this struct is more expensive than a single division, but if the division is repeated,
/// this version will be several times faster than naive division.
/// Creates a new divisor instance.
/// If possible, avoid calling new() from an inner loop: The intended usage is to create an instance of this struct outside the loop, and use it for divison and remainders inside the loop.
/// # Panics:
/// 
/// Panics if `divisor` is 0
/// Simultaneous truncated integer division and modulus.
/// Returns `(quotient, remainder)`.
/// Retrieve the value used to create this struct
strength_reduced_u16// small types prefer to do work in the intermediate type
strength_reduced_u32strength_reduced_u64multiplier_himultiplier_lor" Implements unsigned division and modulo via mutiplication and shifts.
"r" Creating a an instance of this struct is more expensive than a single division, but if the division is repeated,
"r" this version will be several times faster than naive division.
"StrengthReducedU16r" Creates a new divisor instance.
"r" If possible, avoid calling new() from an inner loop: The intended usage is to create an instance of this struct outside the loop, and use it for divison and remainders inside the loop.
"r" # Panics:
"r" 
"r" Panics if `divisor` is 0
"r" Simultaneous truncated integer division and modulus.
"r" Returns `(quotient, remainder)`.
"r" Retrieve the value used to create this struct
"// We just hardcoded u8 and u128 since they will never be a usize. for the rest, we have macros, so we can reuse the same code for usize
StrengthReducedU32reduction_testtest_strength_reduced_u8test_strength_reduced_u16test_strength_reduced_u32test_strength_reduced_u64test_strength_reduced_usizetest_strength_reduced_u128//! `strength_reduce` implements integer division and modulo via "arithmetic strength reduction"
//! Modern processors can do multiplication and shifts much faster than division, and "arithmetic strength reduction" is an algorithm to transform divisions into multiplications and shifts.
//! Compilers already perform this optimization for divisors that are known at compile time; this library enables this optimization for divisors that are only known at runtime.
//! Benchmarking shows a 5-10x speedup or integer division and modulo operations.
//! # Example:
//! use strength_reduce::StrengthReducedU64;
//! let mut my_array: Vec<u64> = (0..500).collect();
//! let divisor = 3;
//! let modulo = 14;
//! // slow naive division and modulo
//! for element in &mut my_array {
//!     *element = (*element / divisor) % modulo;
//! // fast strength-reduced division and modulo
//! let reduced_divisor = StrengthReducedU64::new(divisor);
//! let reduced_modulo = StrengthReducedU64::new(modulo);
//!     *element = (*element / reduced_divisor) % reduced_modulo;
//! This library is intended for hot loops like the example above, where a division is repeated many times in a loop with the divisor remaining unchanged. 
//! There is a setup cost associated with creating stength-reduced division instances, so using strength-reduced division for 1-2 divisions is not worth the setup cost.
//! The break-even point differs by use-case, but is typically low: Benchmarking has shown that takes 3 to 4 repeated divisions with the same StengthReduced## instance to be worth it.
//! `strength_reduce` is `#![no_std]`
//! The optimizations that this library provides are inherently dependent on architecture, compiler, and platform,
//! so test before you use. 
U32_MAXdivide_128_by_64_preshifted// divides a 128-bit number by a 64-bit divisor, returning the quotient as a 64-bit number
// assumes that the divisor and numerator have both already been bit-shifted so that divisor.leading_zeros() == 0
divide_128_by_64_preshifted_reduced// assumes that the divisor and numerator have both already been bit-shifted to maximize the number of bits in divisor_hi
// divisor_hi should be the upper 32 bits, and divisor_lo should be the lower 32 bits
divide_128// divides a 128-bit number by a 128-bit divisor
divide_128_by_64_helper// divides a 128-bit number by a 64-bit divisor, returning the quotient as a 64-bit number. Panics if the quotient doesn't fit in a 64-bit number
divide_128_by_32_helper// Same as divide_128_by_64_into_64, but optimized for scenarios where the divisor fits in a u32. Still panics if the quotient doesn't fit in a u64
normalize_sliceis_slice_greater// subtract b from a, and store the result in a
divide_128_max_by_64divide_256_max_by_32divide_256_max_by_128test_divide_128_by_64test_divisor_128test_max_256multiply_256_by_128_upperbits// multiply the 256-bit number 'a' by the 128-bit number 'b' and return the uppermost 128 bits of the product
// ripped directly from num-biguint's long multiplication algorithm (mac3, mac_with_carry, adc), but with fixed-size arrays instead of slices
multiply_256_by_64_helperlong_multiply// compute product += a * b
impl_displayimpl_approx_32impl_approx_64FiniteF32/// An immutable, finite `f32`./// Unlike `f32`, implements `Ord`, `PartialOrd` and `Hash`./// Creates a finite `f32`./// Returns `None` for NaN and infinity./// Creates a finite `f32` without checking the value./// `n` must be finite./// Returns the value as a primitive type.FiniteF64/// An immutable, finite `f64`./// Unlike `f64`, implements `Ord`, `PartialOrd` and `Hash`./// Creates a finite `f64`./// Creates a finite `f64` without checking the value.PositiveF32/// An immutable, finite `f32` that is known to be >= 0./// A `PositiveF32` value initialized with zero./// Creates a new `PositiveF32` if the given value is >= 0./// Returns `None` for negative, NaN and infinity./// Creates a new `PositiveF32` without checking the value./// `n` must be finite and >= 0.get_finite/// Returns the value as a `FiniteF32`.PositiveF64/// An immutable, finite `f64` that is known to be >= 0./// A `PositiveF64` value initialized with zero./// Creates a new `PositiveF64` if the given value is >= 0./// Creates a new `PositiveF64` without checking the value./// Returns the value as a `FiniteF64`.NonZeroPositiveF32/// An immutable, finite `f32` that is known to be > 0./// Creates a new `NonZeroPositiveF32` if the given value is > 0./// Returns `None` for negative, zero, NaN and infinity./// Creates a new `NonZeroPositiveF32` without checking the value./// `n` must be finite and > 0.NonZeroPositiveF64/// An immutable, finite `f64` that is known to be > 0./// Creates a new `NonZeroPositiveF64` if the given value is > 0./// Creates a new `NonZeroPositiveF64` without checking the value.NormalizedF32/// An immutable, finite `f32` in a 0..=1 range./// A `NormalizedF32` value initialized with zero./// A `NormalizedF32` value initialized with one./// Creates a `NormalizedF32` if the given value is in a 0..=1 range./// Creates a new `NormalizedF32` without checking the value./// `n` must be in 0..=1 range.new_clamped/// Creates a `NormalizedF32` clamping the given value to a 0..=1 range./// Returns zero in case of NaN or infinity.new_u8/// Creates a `NormalizedF32` by dividing the given value by 255.new_u16/// Creates a `NormalizedF64` by dividing the given value by 65535./// Returns the value as a `u8`./// Returns the value as a `u16`.NormalizedF64/// An immutable, finite `f64` in a 0..=1 range./// A `NormalizedF64` value initialized with zero./// A `NormalizedF64` value initialized with one./// Creates a `NormalizedF64` if the given value is in a 0..=1 range./// Creates a new `NormalizedF64` without checking the value./// Creates a `NormalizedF64` clamping the given value to a 0..=1 range./// Creates a `NormalizedF64` by dividing the given value by 255.clamp_f32clamp_f64finite_f32positive_f32positive_f64norm_f32clamped_norm_f32norm_f64clamped_norm_f64/*!
A collection of bounded numeric types.

Includes:

- [`FiniteF32`]
- [`FiniteF64`]
- [`NonZeroPositiveF32`]
- [`NonZeroPositiveF64`]
- [`PositiveF32`]
- [`PositiveF64`]
- [`NormalizedF32`]
- [`NormalizedF64`]

Unlike `f32`/`f64`, all float types implement `Ord`, `PartialOrd` and `Hash`,
since it's guaranteed that they all are finite.
*/StrSimErrorDifferentLengthArgsHammingResultElem1Elem2generic_hamming/// Calculates the number of positions in the two sequences where the elements/// differ. Returns an error if the sequences have different lengths.hamming/// Calculates the number of positions in the two strings where the characters/// differ. Returns an error if the strings have different lengths./// use strsim::{hamming, StrSimError::DifferentLengthArgs};/// assert_eq!(Ok(3), hamming("hamming", "hammers"));/// assert_eq!(Err(DifferentLengthArgs), hamming("hamming", "ham"));generic_jaro/// Calculates the Jaro similarity between two sequences. The returned value/// is between 0.0 and 1.0 (higher value means more similar).StringWrapperjaro/// Calculates the Jaro similarity between two strings. The returned value/// use strsim::jaro;/// assert!((0.392 - jaro("Friedrich Nietzsche", "Jean-Paul Sartre")).abs() <///         0.001);generic_jaro_winkler/// Like Jaro but gives a boost to sequences that have a common prefix.jaro_winkler/// Like Jaro but gives a boost to strings that have a common prefix./// use strsim::jaro_winkler;/// assert!((0.911 - jaro_winkler("cheeseburger", "cheese fries")).abs() <generic_levenshtein/// Calculates the minimum number of insertions, deletions, and substitutions/// required to change one sequence into the other./// use strsim::generic_levenshtein;/// assert_eq!(3, generic_levenshtein(&[1,2,3], &[1,2,3,4,5,6]));/// required to change one string into the other./// use strsim::levenshtein;/// assert_eq!(3, levenshtein("kitten", "sitting"));normalized_levenshtein/// Calculates a normalized score of the Levenshtein algorithm between 0.0 and/// 1.0 (inclusive), where 1.0 means the strings are the same./// use strsim::normalized_levenshtein;/// assert!((normalized_levenshtein("kitten", "sitting") - 0.57142).abs() < 0.00001);/// assert!((normalized_levenshtein("", "") - 1.0).abs() < 0.00001);/// assert!(normalized_levenshtein("", "second").abs() < 0.00001);/// assert!(normalized_levenshtein("first", "").abs() < 0.00001);/// assert!((normalized_levenshtein("string", "string") - 1.0).abs() < 0.00001);osa_distance/// Like Levenshtein but allows for adjacent transpositions. Each substring can/// only be edited once./// use strsim::osa_distance;/// assert_eq!(3, osa_distance("ab", "bca"));flat_index/* Returns the final index for a value in a single vector that represents a fixed
   2d grid */generic_damerau_levenshtein/// Like optimal string alignment, but substrings can be edited an unlimited/// number of times, and the triangle inequality holds./// use strsim::generic_damerau_levenshtein;/// assert_eq!(2, generic_damerau_levenshtein(&[1,2], &[2,3,1]));damerau_levenshtein/// use strsim::damerau_levenshtein;/// assert_eq!(2, damerau_levenshtein("ab", "bca"));normalized_damerau_levenshtein/// Calculates a normalized score of the Damerau–Levenshtein algorithm between/// 0.0 and 1.0 (inclusive), where 1.0 means the strings are the same./// use strsim::normalized_damerau_levenshtein;/// assert!((normalized_damerau_levenshtein("levenshtein", "löwenbräu") - 0.27272).abs() < 0.00001);/// assert!((normalized_damerau_levenshtein("", "") - 1.0).abs() < 0.00001);/// assert!(normalized_damerau_levenshtein("", "flower").abs() < 0.00001);/// assert!(normalized_damerau_levenshtein("tree", "").abs() < 0.00001);/// assert!((normalized_damerau_levenshtein("sunglasses", "sunglasses") - 1.0).abs() < 0.00001);bigrams/// Returns an Iterator of char tuples.sorensen_dice/// Calculates a Sørensen-Dice similarity distance using bigrams./// See http://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient./// use strsim::sorensen_dice;/// assert_eq!(1.0, sorensen_dice("", ""));/// assert_eq!(0.0, sorensen_dice("", "a"));/// assert_eq!(0.0, sorensen_dice("french", "quebec"));/// assert_eq!(1.0, sorensen_dice("ferris", "ferris"));/// assert_eq!(0.8888888888888888, sorensen_dice("feris", "ferris"));bigrams_iteratorassert_hamming_disthamming_emptyhamming_samehamming_numbershamming_diffhamming_diff_multibytehamming_unequal_lengthhamming_namesjaro_both_emptyjaro_first_emptyjaro_second_emptyjaro_samejaro_multibytejaro_diff_shortjaro_diff_one_characterjaro_same_one_charactergeneric_jaro_diffjaro_diff_one_and_twojaro_diff_two_and_onejaro_diff_no_transpositionjaro_diff_with_transpositionjaro_namesjaro_winkler_both_emptyjaro_winkler_first_emptyjaro_winkler_second_emptyjaro_winkler_samejaro_winkler_multibytejaro_winkler_diff_shortjaro_winkler_diff_one_characterjaro_winkler_same_one_characterjaro_winkler_diff_no_transpositionjaro_winkler_diff_with_transpositionjaro_winkler_namesjaro_winkler_long_prefixjaro_winkler_more_namesjaro_winkler_length_of_onejaro_winkler_very_long_prefixlevenshtein_emptylevenshtein_samelevenshtein_diff_shortlevenshtein_diff_with_spacelevenshtein_diff_multibytelevenshtein_diff_longerlevenshtein_first_emptylevenshtein_second_emptynormalized_levenshtein_diff_shortnormalized_levenshtein_for_empty_stringsnormalized_levenshtein_first_emptynormalized_levenshtein_second_emptynormalized_levenshtein_identical_stringsosa_distance_emptyosa_distance_sameosa_distance_first_emptyosa_distance_second_emptyosa_distance_diffosa_distance_diff_shortosa_distance_diff_reversedosa_distance_diff_multibyteosa_distance_diff_unequal_lengthosa_distance_diff_unequal_length_reversedosa_distance_diff_comediansosa_distance_many_transpositionsosa_distance_diff_longerosa_distance_beginning_transpositionosa_distance_end_transpositionosa_distance_restricted_editdamerau_levenshtein_emptydamerau_levenshtein_samedamerau_levenshtein_first_emptydamerau_levenshtein_second_emptydamerau_levenshtein_diffdamerau_levenshtein_diff_shortdamerau_levenshtein_diff_reverseddamerau_levenshtein_diff_multibytedamerau_levenshtein_diff_unequal_lengthdamerau_levenshtein_diff_unequal_length_reverseddamerau_levenshtein_diff_comediansdamerau_levenshtein_many_transpositionsdamerau_levenshtein_diff_longerdamerau_levenshtein_beginning_transpositiondamerau_levenshtein_end_transpositiondamerau_levenshtein_unrestricted_editnormalized_damerau_levenshtein_diff_shortnormalized_damerau_levenshtein_for_empty_stringsnormalized_damerau_levenshtein_first_emptynormalized_damerau_levenshtein_second_emptynormalized_damerau_levenshtein_identical_stringssorensen_dice_all//! This library implements string similarity metrics.// these casts are sometimes needed. They restrict the length of input iterators// but there isn't really any way around this except for always working with// 128 bit types// todo https://github.com/rapidfuzz/strsim-rs/issues/59/// assert!((0.866 - jaro_winkler("cheeseburger", "cheese fries")).abs() </* Returns the final index for a value in a single vector that represents a fixed
2d grid */RowIdGrowingHashmapMapElemCharGrowingHashmapChar/// specialized hashmap to store user provided types/// this implementation relies on a couple of base assumptions in order to simplify the implementation/// - the hashmap does not have an upper limit of included items/// - the default value for the `ValueType` can be used as a dummy value to indicate an empty cell/// - elements can't be removed/// - only allocates memory on first write access.///   This improves performance for hashmaps that are never written to/// lookup key inside the hashmap using a similar collision resolution/// strategy to `CPython` and `Ruby`extended_asciiHybridGrowingHashmapChardamerau_levenshtein_impl/// See <https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient>.assert_delta/// use strsim::hamming;/// match hamming("hamming", "hammers") {///     Ok(distance) => assert_eq!(3, distance),///     Err(why) => panic!("{:?}", why)VariantNotFound/// The ParseError enum is a collection of all the possible reasons/// an enum can fail to parse from a string./// This trait designates that an `Enum` can be iterated over. It can/// be auto generated using `strum_macros` on your behalf./// # extern crate strum;/// # #[macro_use] extern crate strum_macros;/// # use std::fmt::Debug;/// // You need to bring the type into scope to use it!!!/// use strum::IntoEnumIterator;/// #[derive(EnumIter,Debug)]///         Red,///         Green { range:usize },///         Blue(usize),///         Yellow,/// // Iterate over the items in an enum and perform some function on them./// fn generic_iterator<E, F>(pred: F)///     E: IntoEnumIterator,///     F: Fn(E),///     for e in E::iter() {///         pred(e)///     generic_iterator::<Color, _>(|color| println!("{:?}", color));get_detailed_messageget_serializationsEnumMessage/// Associates additional pieces of information with an Enum. This can be/// autoimplemented by deriving `EnumMessage` and annotating your variants with/// `#[strum(message="...")]./// use strum::EnumMessage;/// #[derive(PartialEq, Eq, Debug, EnumMessage)]/// enum Pet {///     #[strum(message="I have a dog")]///     #[strum(detailed_message="My dog's name is Spots")]///     Dog,///     #[strum(message="I don't have a cat")]///     Cat,///     let my_pet = Pet::Dog;///     assert_eq!("I have a dog", my_pet.get_message().unwrap());EnumProperty/// EnumProperty is a trait that makes it possible to store additional information/// with enum variants. This trait is designed to be used with the macro of the same/// name in the `strum_macros` crate. Currently, the only string literals are supported/// in attributes, the other methods will be implemented as additional attribute types/// become stabilized./// use strum::EnumProperty;/// #[derive(PartialEq, Eq, Debug, EnumProperty)]/// enum Class {///     #[strum(props(Teacher="Ms.Frizzle", Room="201"))]///     History,///     #[strum(props(Teacher="Mr.Smith"))]///     #[strum(props(Room="103"))]///     Mathematics,///     #[strum(props(Time="2:30"))]///     Science,///     let history = Class::History;///     assert_eq!("Ms.Frizzle", history.get_str("Teacher").unwrap());as_staticAsStaticRef/// A cheap reference-to-reference conversion. Used to convert a value to a/// reference value with `'static` lifetime within generic code./// #[deprecated(since="0.13.0", note="please use `#[derive(IntoStaticStr)]` instead")]EnumCount/// A trait for capturing the number of variants in Enum. This trait can be autoderived by/// `strum_macros`.VARIANTS/// Names of the variants of this enumVariantNames/// A trait for retrieving the names of each variant in Enum. This trait can/// be autoderived by `strum_macros`.//! # Strum//! [![Build Status](https://travis-ci.org/Peternator7/strum.svg?branch=master)](https://travis-ci.org/Peternator7/strum)//! [![Latest Version](https://img.shields.io/crates/v/strum.svg)](https://crates.io/crates/strum)//! [![Rust Documentation](https://docs.rs/strum/badge.svg)](https://docs.rs/strum)//! Strum is a set of macros and traits for working with//! enums and strings easier in Rust.//! The full version of the README can be found on [Github](https://github.com/Peternator7/strum).//! # Including Strum in Your Project//! Import strum and strum_macros into your project by adding the following lines to your//! Cargo.toml. Strum_macros contains the macros needed to derive all the traits in Strum.//! strum = "0.18.0"//! strum_macros = "0.18.0"//! And add these lines to the root of your project, either lib.rs or main.rs.//! // Strum contains all the trait definitions//! extern crate strum;//! extern crate strum_macros;//! # Strum Macros//! Strum has implemented the following macros://! | Macro | Description |//! | --- | ----------- |//! | [EnumString] | Converts strings to enum variants based on their name |//! | [Display] | Converts enum variants to strings |//! | [AsRefStr] | Converts enum variants to `&'static str` |//! | [IntoStaticStr] | Implements `From<MyEnum> for &'static str` on an enum |//! | [EnumVariantNames] | Implements Strum::VariantNames which adds an associated constant `VARIANTS` which is an array of discriminant names |//! | [EnumIter] | Creates a new type that iterates of the variants of an enum. |//! | [EnumProperty] | Add custom properties to enum variants. |//! | [EnumMessage] | Add a verbose message to an enum variant. |//! | [EnumDiscriminants] | Generate a new type with only the discriminant names. |//! | [EnumCount] | Add a constant `usize` equal to the number of variants. |//! [EnumString]: https://github.com/Peternator7/strum/wiki/Derive-EnumString//! [Display]: https://github.com/Peternator7/strum/wiki/Derive-Display//! [AsRefStr]: https://github.com/Peternator7/strum/wiki/Derive-AsRefStr//! [IntoStaticStr]: https://github.com/Peternator7/strum/wiki/Derive-IntoStaticStr//! [EnumVariantNames]: https://github.com/Peternator7/strum/wiki/Derive-EnumVariantNames//! [EnumIter]: https://github.com/Peternator7/strum/wiki/Derive-EnumIter//! [EnumProperty]: https://github.com/Peternator7/strum/wiki/Derive-EnumProperty//! [EnumMessage]: https://github.com/Peternator7/strum/wiki/Derive-EnumMessage//! [EnumDiscriminants]: https://github.com/Peternator7/strum/wiki/Derive-EnumDiscriminants//! [EnumCount]: https://github.com/Peternator7/strum/wiki/Derive-EnumCount//! # Documentation for Additional Attributes//! ## Attributes on Enums//! Strum supports several custom attributes to modify the generated code. At the enum level, the following attributes are supported://! - `#[strum(serialize_all = "case_style")]` attribute can be used to change the case used when serializing to and deserializing//!   from strings. This feature is enabled by [withoutboats/heck](https://github.com/withoutboats/heck) and supported case styles are://!   - `camelCase`//!   - `PascalCase`//!   - `kebab-case`//!   - `snake_case`//!   - `SCREAMING_SNAKE_CASE`//!   - `SCREAMING-KEBAB-CASE`//!   - `lowercase`//!   - `UPPERCASE`//!   - `title_case`//!   - `mixed_case`//!   use std::string::ToString;//!   use strum;//!   use strum_macros;//!   #[derive(Debug, Eq, PartialEq, strum_macros::ToString)]//!   #[strum(serialize_all = "snake_case")]//!   enum Brightness {//!       DarkBlack,//!       Dim {//!           glow: usize,//!       #[strum(serialize = "bright")]//!       BrightWhite,//!   assert_eq!(//!       String::from("dark_black"),//!       Brightness::DarkBlack.to_string().as_ref()//!       String::from("dim"),//!       Brightness::Dim { glow: 0 }.to_string().as_ref()//!       String::from("bright"),//!       Brightness::BrightWhite.to_string().as_ref()//! - You can also apply the `#[strum(ascii_case_insensitive)]` attribute to the enum,//!   and this has the same effect of applying it to every variant.//! ## Attributes on Variants//! Custom attributes are applied to a variant by adding `#[strum(parameter="value")]` to the variant.//! - `serialize="..."`: Changes the text that `FromStr()` looks for when parsing a string. This attribute can//!    be applied multiple times to an element and the enum variant will be parsed if any of them match.//! - `to_string="..."`: Similar to `serialize`. This value will be included when using `FromStr()`. More importantly,//!    this specifies what text to use when calling `variant.to_string()` with the `Display` derivation, or when calling `variant.as_ref()` with `AsRefStr`.//! - `default`: Applied to a single variant of an enum. The variant must be a Tuple-like//!    variant with a single piece of data that can be create from a `&str` i.e. `T: From<&str>`.//!    The generated code will now return the variant with the input string captured as shown below//!    instead of failing.//!     ```text//!     // Replaces this://!     _ => Err(strum::ParseError::VariantNotFound)//!     // With this in generated code://!     default => Ok(Variant(default.into()))//!     The plugin will fail if the data doesn't implement From<&str>. You can only have one `default`//!     on your enum.//! - `disabled`: removes variant from generated code.//! - `ascii_case_insensitive`: makes the comparison to this variant case insensitive (ASCII only).//!   If the whole enum is marked `ascii_case_insensitive`, you can specify `ascii_case_insensitive = false`//!   to disable case insensitivity on this v ariant.//! - `message=".."`: Adds a message to enum variant. This is used in conjunction with the `EnumMessage`//!    trait to associate a message with a variant. If `detailed_message` is not provided,//!    then `message` will also be returned when `get_detailed_message` is called.//! - `detailed_message=".."`: Adds a more detailed message to a variant. If this value is omitted, then//!    `message` will be used in it's place.//! - Structured documentation, as in `/// ...`: If using `EnumMessage`, is accessible via get_documentation().//! - `props(key="value")`: Enables associating additional information with a given variant.additional_attributes// only for documentation purposes/// The `ParseError` enum is a collection of all the possible reasons/// use strum::{EnumIter, IntoEnumIterator};/// #[derive(EnumIter, Debug)]///     Green { range: usize },///     Blue(usize),///     Yellow,/// generic_iterator::<Color, _>(|color| println!("{:?}", color));get_documentation/// Get the doc comment associated with a variant if it exists./// `#[strum(message="...")]`.///     /// I am documented./// let my_pet = Pet::Dog;/// assert_eq!("I have a dog", my_pet.get_message().unwrap());/// `EnumProperty` is a trait that makes it possible to store additional information/// let history = Class::History;/// assert_eq!("Ms.Frizzle", history.get_str("Teacher").unwrap());DocumentMacroRexports// We actually only re-export these items individually if we're building// for docsrs. You can do a weird thing where you rename the macro// and then reference it through strum. The renaming feature should be deprecated now that// 2018 edition is almost 2 years old, but we'll need to give people some time to do that.//! Import strum and `strum_macros` into your project by adding the following lines to your//! Cargo.toml. `strum_macros` contains the macros needed to derive all the traits in Strum.//! strum = "0.24"//! strum_macros = "0.24"//! # You can also access strum_macros exports directly through strum using the "derive" feature//! strum = { version = "0.24", features = ["derive"] }CaseStyleCaseStyleHelperstest_convert_casetry_metalisttry_pathtry_namevalueMetaHelpersMetaListHelpersfind_attributefind_propertiesfind_unique_propertyMetaIteratorHelpers//impl MetaIteratorHelpers for [Meta]expand_innercase_stylemeta_helpersmeta_iterator_helpersmetalist_helpersextract_metadebug_print_generatedas_ref_strvariant_namesas_static_strinto_static_strenum_iterenum_messagesenum_propertiesenum_discriminantsenum_count//! # Documentation//! The documentation for this crate is found in the `strum` crate.enum_count_innerATTRIBUTES_TO_COPY/// Attributes to copy from the main enum's variants to the discriminant enum's variants./// Attributes not in this list may be for other `proc_macro`s on the main enum, and may cause/// compilation problems when copied across.enum_discriminants_innerenum_iter_innerenum_message_innerextract_propertiesenum_properties_innerenum_variant_names_innerenum_variant_namesget_armsas_ref_str_innerGenerateTraitVariantAsStaticStras_static_str_innerdisplay_innerfrom_string_innerto_string_innerVALID_CASE_STYLESCrateserialize_allimpl_parse_for_custom_keywordCustomTokenimpl_to_tokens_for_custom_keywordimpl_clone_for_custom_keywordimpl_extra_traits_for_custom_keyword__H// enum metadatause_phf// enum discriminant metadata// variant metadatadetailed_messageEnumMetaSerializeAllAsciiCaseInsensitivecrate_module_pathUsePhfEnumDiscriminantsMetaVis/// Get all the strum metadata associated with an enum.get_discriminants_metadata/// Get all the `strum_discriminants` metadata associated with an enum.DeriveInputExtVariantMetaDetailedMessageDocumentation/// Get all the metadata associated with an enum variant.VariantExtget_metadata_innertype_propsHasTypePropertiesvariant_propsHasStrumVariantPropertiesnon_enum_errorstrum_discriminants_passthrough_erroroccurrence_errorget_type_propertiesStrumTypePropertiesdiscriminant_derivesdiscriminant_namediscriminant_othersdiscriminant_visget_variant_propertiesStrumVariantPropertiesstring_propsident_as_strget_preferred_name/// Converts strings to enum variants based on their name./// auto-derives `std::str::FromStr` on the enum (for Rust 1.34 and above, `std::convert::TryFrom<&str>`/// will be derived as well). Each variant of the enum will match on it's own name./// This can be overridden using `serialize="DifferentName"` or `to_string="DifferentName"`/// on the attribute as shown below./// Multiple deserializations can be added to the same variant. If the variant contains additional data,/// they will be set to their default values upon deserialization./// The `default` attribute can be applied to a tuple variant with a single data parameter. When a match isn't/// found, the given variant will be returned and the input string will be captured in the parameter./// Note that the implementation of `FromStr` by default only matches on the name of the/// variant. There is an option to match on different case conversions through the/// `#[strum(serialize_all = "snake_case")]` type attribute./// See the [Additional Attributes](https://docs.rs/strum/0.22/strum/additional_attributes/index.html)/// Section for more information on using this feature./// If you have a large enum, you may want to consider using the `use_phf` attribute here. It leverages/// perfect hash functions to parse much quicker than a standard `match`. (MSRV 1.46)/// # Example howto use `EnumString`/// use strum_macros::EnumString;/// #[derive(Debug, PartialEq, EnumString)]///     // The Default value will be inserted into range if we match "Green".///     Green {///         range: usize,///     // We can match on multiple different patterns.///     #[strum(serialize = "blue", serialize = "b")]///     // Notice that we can disable certain variants from being found///     #[strum(disabled)]///     // We can make the comparison case insensitive (however Unicode is not supported at the moment)///     #[strum(ascii_case_insensitive)]///     Black,/// /*/// //The generated code will look like:/// impl std::str::FromStr for Color {///     type Err = ::strum::ParseError;///     fn from_str(s: &str) -> ::core::result::Result<Color, Self::Err> {///         match s {///             "Red" => ::core::result::Result::Ok(Color::Red),///             "Green" => ::core::result::Result::Ok(Color::Green { range:Default::default() }),///             "blue" => ::core::result::Result::Ok(Color::Blue(Default::default())),///             "b" => ::core::result::Result::Ok(Color::Blue(Default::default())),///             s if s.eq_ignore_ascii_case("Black") => ::core::result::Result::Ok(Color::Black),///             _ => ::core::result::Result::Err(::strum::ParseError::VariantNotFound),/// *//// // simple from string/// let color_variant = Color::from_str("Red").unwrap();/// assert_eq!(Color::Red, color_variant);/// // short version works too/// let color_variant = Color::from_str("b").unwrap();/// assert_eq!(Color::Blue(0), color_variant);/// // was disabled for parsing = returns parse-error/// let color_variant = Color::from_str("Yellow");/// assert!(color_variant.is_err());/// // however the variant is still normally usable/// println!("{:?}", Color::Yellow);/// let color_variant = Color::from_str("bLACk").unwrap();/// assert_eq!(Color::Black, color_variant);/// Converts enum variants to `&'static str`./// Implements `AsRef<str>` on your enum using the same rules as/// `Display` for determining what string is returned. The difference is that `as_ref()` returns/// a `&str` instead of a `String` so you don't allocate any additional memory with each call./// // You need to bring the AsRef trait into scope to use it/// use std::convert::AsRef;/// use strum_macros::AsRefStr;/// #[derive(AsRefStr, Debug)]///     #[strum(serialize = "redred")]/// // uses the serialize string for Display/// let red = Color::Red;/// assert_eq!("redred", red.as_ref());/// // by default the variants Name/// let yellow = Color::Yellow;/// assert_eq!("Yellow", yellow.as_ref());/// // or for string formatting///     "blue: {} green: {}",///     Color::Blue(10).as_ref(),///     Color::Green { range: 42 }.as_ref()/// Implements `Strum::VariantNames` which adds an associated constant `VARIANTS` which is an array of discriminant names./// Adds an `impl` block for the `enum` that adds a static `VARIANTS` array of `&'static str` that are the discriminant names./// This will respect the `serialize_all` attribute on the `enum` (like `#[strum(serialize_all = "snake_case")]`./// // import the macros needed/// use strum_macros::{EnumString, EnumVariantNames};/// // You need to import the trait, to have access to VARIANTS/// use strum::VariantNames;/// #[derive(Debug, EnumString, EnumVariantNames)]/// #[strum(serialize_all = "kebab_case")]///     RebeccaPurple,/// assert_eq!(["red", "blue", "yellow", "rebecca-purple"], Color::VARIANTS);/// Implements `From<MyEnum> for &'static str` on an enum./// Implements `From<YourEnum>` and `From<&'a YourEnum>` for `&'static str`. This is/// useful for turning an enum variant into a static string./// The Rust `std` provides a blanket impl of the reverse direction - i.e. `impl Into<&'static str> for YourEnum`./// use strum_macros::IntoStaticStr;/// #[derive(IntoStaticStr)]/// enum State<'a> {///     Initial(&'a str),///     Finished,/// fn verify_state<'a>(s: &'a str) {///     let mut state = State::Initial(s);///     // The following won't work because the lifetime is incorrect:///     // let wrong: &'static str = state.as_ref();///     // using the trait implemented by the derive works however:///     let right: &'static str = state.into();///     assert_eq!("Initial", right);///     state = State::Finished;///     let done: &'static str = state.into();///     assert_eq!("Finished", done);/// verify_state(&"hello world".to_string());/// implements `std::string::ToString` on en enum/// // You need to bring the ToString trait into scope to use it/// use std::string::ToString;/// use strum_macros;/// #[derive(strum_macros::ToString, Debug)]/// assert_eq!(String::from("redred"), red.to_string());/// assert_eq!(String::from("Yellow"), yellow.to_string());/// Converts enum variants to strings./// Deriving `Display` on an enum prints out the given enum. This enables you to perform round/// trip style conversions from enum into string and back again for unit style variants. `Display`/// choose which serialization to used based on the following criteria:/// 1. If there is a `to_string` property, this value will be used. There can only be one per variant./// 1. Of the various `serialize` properties, the value with the longest length is chosen. If that///    behavior isn't desired, you should use `to_string`./// 1. The name of the variant will be used if there are no `serialize` or `to_string` attributes./// use strum_macros::Display;/// #[derive(Display, Debug)]/// assert_eq!(String::from("redred"), format!("{}", red));///     Color::Blue(10),///     Color::Green { range: 42 }/// Creates a new type that iterates of the variants of an enum./// Iterate over the variants of an Enum. Any additional data on your variants will be set to `Default::default()`./// The macro implements `strum::IntoEnumIter` on your enum and creates a new type called `YourEnumIter` that is the iterator object./// You cannot derive `EnumIter` on any type with a lifetime bound (`<'a>`) because the iterator would surely/// create [unbounded lifetimes](https://doc.rust-lang.org/nightly/nomicon/unbounded-lifetimes.html)./// // You need to bring the trait into scope to use it!/// use strum_macros::EnumIter;/// #[derive(EnumIter, Debug, PartialEq)]/// // It's simple to iterate over the variants of an enum./// for color in Color::iter() {///     println!("My favorite color is {:?}", color);/// let mut ci = Color::iter();/// assert_eq!(Some(Color::Red), ci.next());/// assert_eq!(Some(Color::Green {range: 0}), ci.next());/// assert_eq!(Some(Color::Blue(0)), ci.next());/// assert_eq!(Some(Color::Yellow), ci.next());/// assert_eq!(None, ci.next());/// Add a function to enum that allows accessing variants by its discriminant/// This macro adds a standalone function to obtain an enum variant by its discriminant. The macro adds/// `from_repr(discriminant: usize) -> Option<YourEnum>` as a standalone function on the enum. For/// variants with additional data, the returned variant will use the `Default` trait to fill the/// data. The discriminant follows the same rules as `rustc`. The first discriminant is zero and each/// successive variant has a discriminant of one greater than the previous variant, expect where an/// explicit discriminant is specified. The type of the discriminant will match the `repr` type if/// it is specifed./// When the macro is applied using rustc >= 1.46 and when there is no additional data on any of/// the variants, the `from_repr` function is marked `const`. rustc >= 1.46 is required/// to allow `match` statements in `const fn`. The no additional data requirement is due to the/// inability to use `Default::default()` in a `const fn`./// You cannot derive `FromRepr` on any type with a lifetime bound (`<'a>`) because the function would surely/// use strum_macros::FromRepr;/// #[derive(FromRepr, Debug, PartialEq)]/// assert_eq!(Some(Color::Red), Color::from_repr(0));/// assert_eq!(Some(Color::Green {range: 0}), Color::from_repr(1));/// assert_eq!(Some(Color::Blue(0)), Color::from_repr(2));/// assert_eq!(Some(Color::Yellow), Color::from_repr(3));/// assert_eq!(None, Color::from_repr(4));/// // Custom discriminant tests/// enum Vehicle {///     Car = 1,///     Truck = 3,/// assert_eq!(None, Vehicle::from_repr(0));/// On versions of rust >= 1.46, the `from_repr` function is marked `const`./// enum Number {///     One = 1,///     Three = 3,/// # #[rustversion::since(1.46)]/// const fn number_from_repr(d: u8) -> Option<Number> {///     Number::from_repr(d)/// # #[rustversion::before(1.46)]/// # fn number_from_repr(d: u8) -> Option<Number> {/// #     Number::from_repr(d)/// assert_eq!(None, number_from_repr(0));/// assert_eq!(Some(Number::One), number_from_repr(1));/// assert_eq!(None, number_from_repr(2));/// assert_eq!(Some(Number::Three), number_from_repr(3));/// assert_eq!(None, number_from_repr(4));/// Add a verbose message to an enum variant./// Encode strings into the enum itself. The `strum_macros::EmumMessage` macro implements the `strum::EnumMessage` trait./// `EnumMessage` looks for `#[strum(message="...")]` attributes on your variants./// You can also provided a `detailed_message="..."` attribute to create a seperate more detailed message than the first./// `EnumMessage` also exposes the variants doc comments through `get_documentation()`. This is useful in some scenarios,/// but `get_message` should generally be preferred. Rust doc comments are intended for developer facing documentation,/// not end user messaging./// // You need to bring the trait into scope to use it/// #[derive(strum_macros::EnumMessage, Debug)]/// #[allow(dead_code)]///     /// Danger color.///     #[strum(message = "Red", detailed_message = "This is very red")]///     #[strum(message = "Simply Green")]///     #[strum(serialize = "b", serialize = "blue")]/// // Generated code looks like more or less like this:/// impl ::strum::EnumMessage for Color {///     fn get_message(&self) -> ::core::option::Option<&'static str> {///             &Color::Red => ::core::option::Option::Some("Red"),///             &Color::Green {..} => ::core::option::Option::Some("Simply Green"),///             _ => None///     fn get_detailed_message(&self) -> ::core::option::Option<&'static str> {///             &Color::Red => ::core::option::Option::Some("This is very red"),///             &Color::Green {..}=> ::core::option::Option::Some("Simply Green"),///     fn get_documentation(&self) -> ::std::option::Option<&'static str> {///             &Color::Red => ::std::option::Option::Some("Danger color."),///     fn get_serializations(&self) -> &'static [&'static str] {///             &Color::Red => {///                 static ARR: [&'static str; 1] = ["Red"];///                 &ARR///             &Color::Green {..}=> {///                 static ARR: [&'static str; 1] = ["Green"];///             &Color::Blue (..) => {///                 static ARR: [&'static str; 2] = ["b", "blue"];/// let c = Color::Red;/// assert_eq!("Red", c.get_message().unwrap());/// assert_eq!("This is very red", c.get_detailed_message().unwrap());/// assert_eq!("Danger color.", c.get_documentation().unwrap());/// assert_eq!(["Red"], c.get_serializations());/// Add custom properties to enum variants./// Enables the encoding of arbitary constants into enum variants. This method/// currently only supports adding additional string values. Other types of literals are still/// experimental in the rustc compiler. The generated code works by nesting match statements./// The first match statement matches on the type of the enum, and the inner match statement/// matches on the name of the property requested. This design works well for enums with a small/// number of variants and properties, but scales linearly with the number of variants so may not/// be the best choice in all situations./// // bring the trait into scope/// #[derive(strum_macros::EnumProperty, Debug)]///     #[strum(props(Red = "255", Blue = "255", Green = "255"))]///     White,///     #[strum(props(Red = "0", Blue = "0", Green = "0"))]///     #[strum(props(Red = "0", Blue = "255", Green = "0"))]///     #[strum(props(Red = "255", Blue = "0", Green = "0"))]///     #[strum(props(Red = "0", Blue = "0", Green = "255"))]///     Green,/// let my_color = Color::Red;/// let display = format!(///     "My color is {:?}. It's RGB is {},{},{}",///     my_color,///     my_color.get_str("Red").unwrap(),///     my_color.get_str("Green").unwrap(),///     my_color.get_str("Blue").unwrap()/// assert_eq!("My color is Red. It\'s RGB is 255,0,0", &display);/// Generate a new type with only the discriminant names./// Given an enum named `MyEnum`, generates another enum called `MyEnumDiscriminants` with the same/// variants but without any data fields. This is useful when you wish to determine the variant of/// an `enum` but one or more of the variants contains a non-`Default` field. `From`/// implementations are generated so that you can easily convert from `MyEnum` to/// `MyEnumDiscriminants`./// By default, the generated enum has the following derives: `Clone, Copy, Debug, PartialEq, Eq`./// You can add additional derives using the `#[strum_discriminants(derive(AdditionalDerive))]`/// Note, the variant attributes passed to the discriminant enum are filtered to avoid compilation/// errors due to the derives mismatches, thus only `#[doc]`, `#[cfg]`, `#[allow]`, and `#[deny]`/// are passed through by default. If you want to specify a custom attribute on the discriminant/// variant, wrap it with `#[strum_discriminants(...)]` attribute./// // Bring trait into scope/// use strum::{IntoEnumIterator, EnumMessage};/// use strum_macros::{EnumDiscriminants, EnumIter, EnumString, EnumMessage};/// struct NonDefault;/// // simple example/// #[derive(Debug, EnumDiscriminants)]/// #[strum_discriminants(derive(EnumString, EnumMessage))]///     #[strum_discriminants(strum(message = "Variant zero"))]///     Variant0(NonDefault),///     Variant1 { a: NonDefault },/// // You can rename the generated enum using the `#[strum_discriminants(name(OtherName))]` attribute:/// #[strum_discriminants(derive(EnumIter))]/// #[strum_discriminants(name(MyVariants))]/// enum MyEnumR {///     Variant0(bool),///     Variant1 { a: bool },/// // test simple example///     MyEnumDiscriminants::Variant0,///     MyEnumDiscriminants::from_str("Variant0").unwrap()/// // test rename example combined with EnumIter///     vec![MyVariants::Variant0, MyVariants::Variant1],///     MyVariants::iter().collect::<Vec<_>>()/// // Make use of the auto-From conversion to check whether an instance of `MyEnum` matches a/// // `MyEnumDiscriminants` discriminant.///     MyEnum::Variant0(NonDefault).into()///     MyEnumDiscriminants::from(MyEnum::Variant0(NonDefault))/// // Make use of the EnumMessage on the `MyEnumDiscriminants` discriminant.///     MyEnumDiscriminants::Variant0.get_message(),///     Some("Variant zero")/// It is also possible to specify the visibility (e.g. `pub`/`pub(crate)`/etc.)/// of the generated enum. By default, the generated enum inherits the/// visibility of the parent enum it was generated from./// ```nocompile/// use strum_macros::EnumDiscriminants;/// // You can set the visibility of the generated enum using the `#[strum_discriminants(vis(..))]` attribute:///     use strum_macros::EnumDiscriminants;///     # #[allow(dead_code)]///     #[derive(Debug, EnumDiscriminants)]///     #[strum_discriminants(vis(pub))]///     #[strum_discriminants(name(PubDiscriminants))]///     enum PrivateEnum {///         Variant0(bool),///         Variant1 { a: bool },/// // test visibility example, `PrivateEnum` should not be accessible here///     inner::PubDiscriminants::Variant0,///     inner::PubDiscriminants::Variant1,/// Add a constant `usize` equal to the number of variants./// For a given enum generates implementation of `strum::EnumCount`,/// which adds a static property `COUNT` of type usize that holds the number of variants./// use strum::{EnumCount, IntoEnumIterator};/// use strum_macros::{EnumCount as EnumCountMacro, EnumIter};/// #[derive(Debug, EnumCountMacro, EnumIter)]/// enum Week {///     Sunday,///     Monday,///     Tuesday,///     Wednesday,///     Thursday,///     Friday,///     Saturday,/// assert_eq!(7, Week::COUNT);/// assert_eq!(Week::iter().count(), Week::COUNT);from_repr_innerImplGenericstest_mapped_addresstest_mapped_address_v6test_alternate_servertest_other_addressaddr_testFAMILY_IPV4FAMILY_IPV6IPV4LENIPV6LENMappedAddress/// MappedAddress represents MAPPED-ADDRESS attribute./// This attribute is used only by servers for achieving backwards/// compatibility with RFC 3489 clients./// RFC 5389 Section 15.1add_to/// add_to adds MAPPED-ADDRESS to message./// get_from decodes MAPPED-ADDRESS from message.get_from_as/// get_from_as decodes MAPPED-ADDRESS value in message m as an attribute of type t.add_to_as/// add_to_as adds MAPPED-ADDRESS value to m as t attribute.AlternateServer/// AlternateServer represents ALTERNATE-SERVER attribute./// RFC 5389 Section 15.11ResponseOrigin/// ResponseOrigin represents RESPONSE-ORIGIN attribute./// RFC 5780 Section 7.3OtherAddress/// OtherAddress represents OTHER-ADDRESS attribute./// RFC 5780 Section 7.4test_agent_process_in_transactiontest_agent_processtest_agent_starttest_agent_stopagent_test/// Handler handles state changes of transaction./// Handler is called on transaction state change./// Usage of e is valid only during call, user must/// copy needed fields explicitly.noop_handler/// noop_handler just discards any event.transactionsTransactionIdAgentTransaction/// transactions is map of transactions that are currently/// in progress. Event handling is done in such way when/// transaction is unregistered before AgentTransaction access,/// minimizing mux lock and protecting AgentTransaction from/// data races via unexpected concurrent access./// all calls are invalid if true/// handles transactionsAgent/// Agent is low-level abstraction over transaction list that/// handles concurrency (all calls are goroutine-safe) and/// time outs (via Collect call).event_body/// Event is passed to Handler describing the transaction event./// Do not reuse outside Handler.//Clone/// AgentTransaction represents transaction in progress./// Concurrent access is invalid.AGENT_COLLECT_CAP/// AGENT_COLLECT_CAP is initial capacity for Agent.Collect slices,/// sufficient to make function zero-alloc in most cases.TRANSACTION_ID_SIZE/// new returns new random transaction ID using crypto/rand/// as source.ClientAgent/// ClientAgent is Agent implementation that is used by Client to/// process transactions./// new initializes and returns new Agent with provided handler.stop_with_error/// stop_with_error removes transaction from list and calls handler with/// provided error. Can return ErrTransactionNotExists and ErrAgentClosed./// process incoming message, synchronously passing it to handler./// close terminates all transactions with ErrAgentClosed and renders Agent to/// closed state./// start registers transaction with provided id and deadline./// Could return ErrAgentClosed, ErrTransactionExists./// Agent handler is guaranteed to be eventually called./// stop stops transaction by id with ErrTransactionStopped, blocking/// until handler returns./// collect terminates all transactions that have deadline before provided/// time, blocking until all handlers will process ErrTransactionTimeOut./// Will return ErrAgentClosed if agent is already closed./// It is safe to call Collect concurrently but makes no sense./// set_handler sets agent handler to h.textattrstest_raw_attribute_add_totest_message_get_no_allocstest_attr_type_rangeattributes_testRawAttribute/// Attributes is list of message attributes./// get returns first attribute from list by the type./// If attribute is present the RawAttribute is returned and the/// boolean is true. Otherwise the returned RawAttribute will be/// empty and boolean will be false./// AttrType is attribute type./// required returns true if type is from comprehension-required range (0x0000-0x7FFF)./// optional returns true if type is from comprehension-optional range (0x8000-0xFFFF)./// value returns uint16 representation of attribute type.ATTR_MAPPED_ADDRESS/// Attributes from comprehension-required range (0x0000-0x7FFF).ATTR_USERNAME// MAPPED-ADDRESSATTR_MESSAGE_INTEGRITY// USERNAMEATTR_ERROR_CODE// MESSAGE-INTEGRITYATTR_UNKNOWN_ATTRIBUTES// ERROR-CODEATTR_REALM// UNKNOWN-ATTRIBUTESATTR_NONCE// REALMATTR_XORMAPPED_ADDRESS// NONCEATTR_SOFTWARE/// Attributes from comprehension-optional range (0x8000-0xFFFF).ATTR_ALTERNATE_SERVER// SOFTWAREATTR_FINGERPRINT// ALTERNATE-SERVERATTR_PRIORITY/// Attributes from RFC 5245 ICE.ATTR_USE_CANDIDATE// PRIORITYATTR_ICE_CONTROLLED// USE-CANDIDATEATTR_ICE_CONTROLLING// ICE-CONTROLLEDATTR_CHANNEL_NUMBER/// Attributes from RFC 5766 TURN.ATTR_LIFETIME// CHANNEL-NUMBERATTR_XOR_PEER_ADDRESS// LIFETIMEATTR_DATA// XOR-PEER-ADDRESSATTR_XOR_RELAYED_ADDRESSATTR_EVEN_PORT// XOR-RELAYED-ADDRESSATTR_REQUESTED_TRANSPORT// EVEN-PORTATTR_DONT_FRAGMENT// REQUESTED-TRANSPORTATTR_RESERVATION_TOKEN// DONT-FRAGMENTATTR_CHANGE_REQUEST/// Attributes from RFC 5780 NAT Behavior DiscoveryATTR_PADDING// CHANGE-REQUESTATTR_RESPONSE_PORT// PADDINGATTR_CACHE_TIMEOUT// RESPONSE-PORTATTR_RESPONSE_ORIGIN// CACHE-TIMEOUTATTR_OTHER_ADDRESS// RESPONSE-ORIGINATTR_SOURCE_ADDRESS/// Attributes from RFC 3489, removed by RFC 5389,///  but still used by RFC5389-implementing software like Vovida.org, reTURNServer, etc.ATTR_CHANGED_ADDRESS// SOURCE-ADDRESSATTR_CONNECTION_ID/// Attributes from RFC 6062 TURN Extensions for TCP Allocations.ATTR_REQUESTED_ADDRESS_FAMILY/// Attributes from RFC 6156 TURN IPv6.ATTR_ORIGIN/// Attributes from An Origin Attribute for the STUN Protocol.ATTR_MESSAGE_INTEGRITY_SHA256/// Attributes from RFC 8489 STUN.ATTR_PASSWORD_ALGORITHM// MESSAGE-INTEGRITY-SHA256ATTR_USER_HASH// PASSWORD-ALGORITHMATTR_PASSWORD_ALGORITHMS// USER-HASHATTR_ALTERNATE_DOMAIN// PASSWORD-ALGORITHMS// ignored while encoding/// RawAttribute is a Type-Length-Value (TLV) object that/// can be added to a STUN message. Attributes are divided into two/// types: comprehension-required and comprehension-optional.  STUN/// agents can safely ignore comprehension-optional attributes they/// don't understand, but cannot successfully process a message if it/// contains comprehension-required attributes that are not/// understood./// add_to implements Setter, adding attribute as a.Type with a.Value and ignoring/// the Length field.nearest_padded_value_length/// STUN aligns attributes on 32-bit boundaries, attributes whose content/// is not a multiple of 4 bytes are padded with 1, 2, or 3 bytes of/// padding so that its value contains a multiple of 4 bytes.  The/// padding bits are ignored, and may be any value./// https://tools.ietf.org/html/rfc5389#section-15compat_attr_type/// This method converts uint16 vlue to AttrType. If it finds an old attribute/// type value, it also translates it to the new value to enable backward/// compatibility. (See: https://github.com/pion/stun/issues/21)// XOR-MAPPED-ADDRESS// FINGERPRINT// ICE-CONTROLLING// RESERVATION-TOKEN// OTHER-ADDRESS// CHANGED-ADDRESS// CONNECTION-ID// REQUESTED-ADDRESS-FAMILY// ALTERNATE-DOMAIN// check_size returns ErrAttrSizeInvalid if got is not equal to expected.is_attr_size_invalid// is_attr_size_invalid returns true if error means that attribute size is invalid.check_hmaccheck_fingerprintcheck_overflow// check_overflow returns ErrAttributeSizeOverflow if got is bigger that max.is_attr_size_overflow// is_attr_size_overflow returns true if error means that attribute size is too big.ensure_client_settings_is_sendensure_send//TODO: add more client testsclient_testagentDEFAULT_TIMEOUT_RATEDEFAULT_RTODEFAULT_MAX_ATTEMPTS/// Collector calls function f with constant rate./// The simple Collector is ticker which calls function on each tick.TickerCollectorrto/// ClientTransaction represents transaction in progress./// If transaction is succeed or failed, f will be called/// provided by event.rto_ratemax_attempts//handler: Handler,ClientSettingswith_rto/// with_rto sets client RTO as defined in STUN RFC.with_timeout_rate/// with_timeout_rate sets RTO timer minimum resolution.with_buffer_size/// with_buffer_size sets buffer size.with_collector/// with_collector rests client timeout collector, the implementation/// of ticker which calls function on each tick.with_conn/// with_conn sets transport connectionwith_no_retransmit/// with_no_retransmit disables retransmissions and sets RTO to/// DEFAULT_MAX_ATTEMPTS * DEFAULT_RTO which will be effectively time out/// if not set./// Useful for TCP connections where transport handles RTO.// WithHandler sets client handler which is called if Agent emits the Event// with TransactionID that is not currently registered by Client.// Useful for handling Data indications from TURN server.//pub fn with_handler(mut self, handler: Handler) -> Self {//    self.settings.handler = handler;//    selfclient_agent_txhandler_tx/// Client simulates "connection" to STUN server.read_until_closed/// close stops internal connection and agent, returning CloseErr on error.ErrAttributeNotFoundErrTransactionStoppedErrTransactionNotExistsErrTransactionExistsErrAgentClosedErrTransactionTimeOutErrNoDefaultReasonErrUnexpectedEofErrAttributeSizeInvalidErrAttributeSizeOverflowErrDecodeToNilErrUnexpectedHeaderEofErrIntegrityMismatchErrFingerprintMismatchErrFingerprintBeforeIntegrityErrBadUnknownAttrsSizeErrBadIpLengthErrNoConnectionErrClientClosedErrNoAgentErrCollectorClosedErrUnsupportedNetworkErrInvalidUrlErrSchemeTypeErrHostchecksErrorCodeAttribute// ErrorCodeAttribute represents ERROR-CODE attribute.// RFC 5389 Section 15.6ERROR_CODE_CLASS_BYTE// constants for ERROR-CODE encoding.ERROR_CODE_NUMBER_BYTEERROR_CODE_REASON_STARTERROR_CODE_REASON_MAX_BERROR_CODE_MODULO// add_to adds ERROR-CODE to m.// GetFrom decodes ERROR-CODE from m. Reason is valid until m.Raw is valid.// ErrorCode is code for ERROR-CODE attribute.// add_to adds ERROR-CODE with default reason to m. If there// is no default reason, returns ErrNoDefaultReason.CODE_TRY_ALTERNATE// Possible error codes.CODE_BAD_REQUESTCODE_UNAUTHORIZEDCODE_UNKNOWN_ATTRIBUTECODE_STALE_NONCECODE_ROLE_CONFLICTCODE_SERVER_ERRORCODE_UNAUTHORISED// DEPRECATED constants.// DEPRECATED, use CODE_UNAUTHORIZED.CODE_FORBIDDEN// Error codes from RFC 5766.// RFC 5766 Section 15CODE_ALLOC_MISMATCH// ForbiddenCODE_WRONG_CREDENTIALS// Allocation MismatchCODE_UNSUPPORTED_TRANS_PROTO// Wrong CredentialsCODE_ALLOC_QUOTA_REACHED// Unsupported Transport ProtocolCODE_INSUFFICIENT_CAPACITY// Allocation Quota ReachedCODE_CONN_ALREADY_EXISTS// Error codes from RFC 6062.// RFC 6062 Section 6.3CODE_CONN_TIMEOUT_OR_FAILURECODE_ADDR_FAMILY_NOT_SUPPORTED// Error codes from RFC 6156.// RFC 6156 Section 10.2CODE_PEER_ADDR_FAMILY_MISMATCH// Address Family not SupportedERROR_REASONS// Insufficient Capacity// Peer Address Family Mismatchfingerprint_uses_crc_32_iso_hdlctest_fingerprint_checktest_fingerprint_check_badfingerprint_testFingerprintAttr// FingerprintAttr represents FINGERPRINT attribute.// RFC 5389 Section 15.5FINGERPRINT// FINGERPRINT is shorthand for FingerprintAttr.// Example://  m := New()//  FINGERPRINT.add_to(m)FINGERPRINT_XOR_VALUEFINGERPRINT_SIZEfingerprint_value// FingerprintValue returns CRC-32 of b XOR-ed by 0x5354554e.// The value of the attribute is computed as the CRC-32 of the STUN message// up to (but excluding) the FINGERPRINT attribute itself, XOR'ed with// the 32-bit value 0x5354554e (the XOR helps in cases where an// application packet is also using CRC-32 in it).// add_to adds fingerprint to message.// Check reads fingerprint value from m and checks it, returning error if any.// Can return *AttrLengthErr, ErrAttributeNotFound, and *CRCMismatch.// 32 bittest_message_integrity_add_to_simpletest_message_integrity_with_fingerprinttest_message_integritytest_message_integrity_before_fingerprintintegrity_testCREDENTIALS_SEP// separator for credentials.MessageIntegrity// MessageIntegrity represents MESSAGE-INTEGRITY attribute.// add_to and Check methods are using zero-allocation version of hmac, see// newHMAC function and internal/hmac/pool.go.// RFC 5389 Section 15.4new_hmac// add_to adds MESSAGE-INTEGRITY attribute to message.// CPU costly, see BenchmarkMessageIntegrity_AddTo.MESSAGE_INTEGRITY_SIZEnew_long_term_integrity// new_long_term_integrity returns new MessageIntegrity with key for long-term// credentials. Password, username, and realm must be SASL-prepared.new_short_term_integrity// new_short_term_integrity returns new MessageIntegrity with key for short-term// credentials. Password must be SASL-prepared.// Check checks MESSAGE-INTEGRITY attribute.// CPU costly, see BenchmarkMessageIntegrity_Check.integrityuattrsxoraddrDEFAULT_PORT// IANA assigned ports for "stun" protocol.DEFAULT_TLS_PORTtest_message_buffertest_message_type_valuetest_message_type_read_valuetest_message_type_read_write_valuetest_message_write_totest_message_cookietest_message_length_less_header_sizetest_message_bad_lengthtest_message_attr_length_less_than_headertest_message_attr_size_less_than_lengthtest_message_read_from_errortest_message_class_stringtest_attr_type_stringtest_method_stringtest_attribute_equaltest_message_equaltest_message_growtest_message_grow_smallertest_message_stringtest_is_messagetest_message_containstest_message_full_sizetest_message_clone_totest_message_add_totest_message_marshal_binaryMAGIC_COOKIE// MAGIC_COOKIE is fixed value that aids in distinguishing STUN packets// from packets of other protocols when STUN is multiplexed with those// other protocols on the same Port.// The magic cookie field MUST contain the fixed value 0x2112A442 in// network byte order.// Defined in "STUN Message Structure", section 6.ATTRIBUTE_HEADER_SIZEMESSAGE_HEADER_SIZE// TRANSACTION_ID_SIZE is length of transaction id array (in bytes).// Setter sets *Message attribute.// Interfaces that are implemented by message attributes, shorthands for them,// or helpers for message fields as type or transaction id.// Getter parses attribute from *Message.// Checker checks *Message attribute.// is_message returns true if b looks like STUN message.// Useful for multiplexing. is_message does not guarantee// that decoding will be successful.transaction_id// len(Raw) not including header// Message represents a single STUN packet. It uses aggressive internal// buffering to enable zero-allocation encoding and decoding,// so there are some usage constraints:// 	Message, its fields, results of m.Get or any attribute a.GetFrom//	are valid only until Message.Raw is not modified.// Equal returns true if Message b equals to m.// Ignores m.Raw.DEFAULT_RAW_CAPACITY// add_to sets b.TransactionID to m.TransactionID.// Implements Setter to aid in crafting responses.// New returns *Message with pre-allocated Raw.// marshal_binary implements the encoding.BinaryMarshaler interface.// unmarshal_binary implements the encoding.BinaryUnmarshaler interface.new_transaction_id// NewTransactionID sets m.TransactionID to random value from crypto/rand// and returns error if any.// Reset resets Message, attributes and underlying buffer length.// grow ensures that internal buffer has n length.// Add appends new attribute to message. Not goroutine-safe.// Value of attribute is copied to internal buffer so// it is safe to reuse v.write_length// WriteLength writes m.Length to m.Raw.// WriteHeader writes header to underlying buffer. Not goroutine-safe.write_transaction_id// WriteTransactionID writes m.TransactionID to m.Raw.write_attributes// WriteAttributes encodes all m.Attributes to m.write_type// WriteType writes m.Type to m.Raw.// SetType sets m.Type and writes it to m.Raw.// Encode re-encodes message into m.Raw.// Decode decodes m.Raw into m.// WriteTo implements WriterTo via calling Write(m.Raw) on w and returning// call result.// ReadFrom implements ReaderFrom. Reads message from r into m.Raw,// Decodes it and return error if any. If m.Raw is too small, will return// ErrUnexpectedEOF, ErrUnexpectedHeaderEOF or *DecodeErr.// Can return *DecodeErr while decoding too.// Write decodes message and return error if any.// Any error is unrecoverable, but message could be partially decoded.// CloneTo clones m to b securing any further m mutations.// Contains return true if message contain t attribute.// get returns byte slice that represents attribute value,// if there is no attribute with such type,// ErrAttributeNotFound is returned.// Build resets message and applies setters to it in batch, returning on// first error. To prevent allocations, pass pointers to values.//  var (//  	t        = BindingRequest//  	username = NewUsername("username")//  	nonce    = NewNonce("nonce")//  	realm    = NewRealm("example.org")//  )//  m := new(Message)//  m.Build(t, username, nonce, realm)     // 4 allocations//  m.Build(&t, &username, &nonce, &realm) // 0 allocations// See BenchmarkBuildOverhead.// Check applies checkers to message in batch, returning on first error.// Parse applies getters to message in batch, returning on first error.MessageClass// MessageClass is 8-bit representation of 2-bit class of STUN Message Class.CLASS_REQUEST// Possible values for message class in STUN Message Type.CLASS_INDICATION// 0b00CLASS_SUCCESS_RESPONSE// 0b01CLASS_ERROR_RESPONSE// 0b10// Method is uint16 representation of 12-bit STUN method.METHOD_BINDING// Possible methods for STUN Message.METHOD_ALLOCATEMETHOD_REFRESHMETHOD_SENDMETHOD_DATAMETHOD_CREATE_PERMISSIONMETHOD_CHANNEL_BINDMETHOD_CONNECT// Methods from RFC 6062.METHOD_CONNECTION_BINDMETHOD_CONNECTION_ATTEMPT// e.g. binding// e.g. request// MessageType is STUN Message Type Field.BINDING_REQUEST// Common STUN message types.// Binding request message type.BINDING_SUCCESS// Binding success response message typeBINDING_ERROR// Binding error response message type.METHOD_ABITSMETHOD_BBITS// 0b0000000000001111METHOD_DBITS// 0b0000000001110000METHOD_BSHIFTMETHOD_DSHIFTFIRST_BITSECOND_BITC0BITC1BITCLASS_C0SHIFTCLASS_C1SHIFT// add_to sets m type to t.// NewType returns new message type with provided method and class.// Value returns bit representation of messageType.// ReadValue decodes uint16 into MessageType.// 96 bit// 0b11// 0b0000111110000000test_software_get_fromtest_software_add_to_invalidtest_software_add_to_regressiontest_usernametest_realm_get_fromtest_realm_add_to_invalidtest_nonce_get_fromtest_nonce_add_to_invalidtest_nonce_add_totextattrs_testMAX_USERNAME_BMAX_REALM_BMAX_SOFTWARE_BMAX_NONCE_B// Username represents USERNAME attribute.// RFC 5389 Section 15.3Realm// Realm represents REALM attribute.// RFC 5389 Section 15.7// Nonce represents NONCE attribute.// RFC 5389 Section 15.8// Software is SOFTWARE attribute.// RFC 5389 Section 15.10// TextAttribute is helper for adding and getting text attributes.// add_to_as adds attribute with type t to m, checking maximum length. If max_len// is less than 0, no check is performed.// get_from_as gets t attribute from m and appends its value to reset v.test_unknown_attributesuattrs_testUnknownAttributes// UnknownAttributes represents UNKNOWN-ATTRIBUTES attribute.// RFC 5389 Section 15.9ATTR_TYPE_SIZE// type size is 16 bit.// add_to adds UNKNOWN-ATTRIBUTES attribute to message.// GetFrom parses UNKNOWN-ATTRIBUTES from message.test_parse_uriSCHEMESCHEME_SECURE// URI as defined in RFC 7064.// parse_uri parses URI from string.// SCHEME definitions from RFC 7064 Section 3.2.test_xor_safetest_xor_safe_bsmallertest_xormapped_address_get_fromtest_xormapped_address_get_from_invalidtest_xormapped_address_add_totest_xormapped_address_add_to_ipv6test_xormapped_address_string/*
#[test]
fn TestXORMappedAddress_AddTo_Invalid() -> Result<()> {
    let mut m = Message::new();
    let mut addr = XORMappedAddress{
        ip:   1, 2, 3, 4, 5, 6, 7, 8},
        port: 21254,
    }
    if err := addr.AddTo(m); !errors.Is(err, ErrBadIPLength) {
        t.Errorf("AddTo should return %q, got: %v", ErrBadIPLength, err)
    }
}*/xoraddr_testsafe_xor_bytesxor_bytes/// xor_bytes xors the bytes in a and b. The destination is assumed to have enough/// space. Returns the number of bytes xor'd.XorMappedAddress/// XORMappedAddress implements XOR-MAPPED-ADDRESS attribute./// RFC 5389 Section 15.2/// add_to adds XOR-MAPPED-ADDRESS to m. Can return ErrBadIPLength/// if len(a.IP) is invalid./// get_from decodes XOR-MAPPED-ADDRESS attribute in message and returns/// error if any. While decoding, a.IP is reused if possible and can be/// rendered to invalid state (e.g. if a.IP was set to IPv6 and then/// IPv4 value were decoded into it), be careful./// add_to_as adds XOR-MAPPED-ADDRESS value to m as t attribute./// get_from_as decodes XOR-MAPPED-ADDRESS attribute value in message/// getting it as for t type.//var supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "amd64" // nolint:gochecknoglobals// fast_xor_bytes xors in bulk. It only works on architectures that// support unaligned read/writes./*TODO: fn fast_xor_bytes(dst:&[u8], a:&[u8], b:&[u8]) ->usize {
    let mut n = a.len();
    if b.len() < n {
        n = b.len();
    }

    let w = n / WORD_SIZE;
    if w > 0 {
        let dw = *(*[]uintptr)(unsafe.Pointer(&dst))
        let aw = *(*[]uintptr)(unsafe.Pointer(&a))
        let bw = *(*[]uintptr)(unsafe.Pointer(&b))
        for i := 0; i < w; i++ {
            dw[i] = aw[i] ^ bw[i]
        }
    }

    for i := n - n%WORD_SIZE; i < n; i++ {
        dst[i] = a[i] ^ b[i]
    }

    return n
}*/rfc5389rfc5766MyAttributeRfc5389Rfc5766AttributeDecoderMyAttributeDecoderAttributeTypeAttributeEncoderMyAttributeEncoder/// The decoder of the value part of the attribute./// The encoder of the value part of the attribute./// Returns the type of the attribute.before_encode/// This method is called before encoding the attribute./// `message` is the message to which the attribute belongs./// The message only contains the attributes preceding to `self`./// The default implementation simply returns `Ok(())`.after_decode/// This method is called after decoding the attribute and before being appended to the given message./// STUN attribute./// > **Attribute**:  The STUN term for a Type-Length-Value (TLV) object that/// > can be added to a STUN message. Attributes are divided into two/// > types: comprehension-required and comprehension-optional. STUN/// > agents can safely ignore comprehension-optional attributes they/// > don't understand, but cannot successfully process a message if it/// > contains comprehension-required attributes that are not/// > understood./// > [RFC 5389 -- 5. Definitions]/// [RFC 5389 -- 5. Definitions]: https://tools.ietf.org/html/rfc5389#section-5/// Attribute type./// > Attributes are divided into two/// > ---/// > A STUN Attribute type is a hex number in the range 0x0000 - 0xFFFF./// > STUN attribute types in the range 0x0000 - 0x7FFF are considered/// > comprehension-required; STUN attribute types in the range 0x8000 -/// > 0xFFFF are considered comprehension-optional./// > [RFC 5389 -- 18.2. STUN Attribute Registry]/// [RFC 5389 -- 18.2. STUN Attribute Registry]: https://tools.ietf.org/html/rfc5389#section-18.2/// Makes a new `Type` instance which corresponding to `codepoint`./// Returns the attribute codepoint corresponding this instance.is_comprehension_required/// Returns `true` if this is a comprehension-required type.is_comprehension_optional/// Returns `true` if this is a comprehension-optional type.attr_type/// An [`Attribute`] implementation that has raw value bytes./// Makes a new `RawAttribute` instance./// Returns a reference to the value bytes of the attribute./// Takes ownership of this instance, and returns the value bytes.RawAttributeDecoderRawAttributeEncoder/// [`RawAttribute`] decoder./// Makes a new `RawAttributeDecoder` instance./// [`RawAttribute`] encoder./// Makes a new `RawAttributeEncoder` instance.LosslessAttributeas_knownknown_valueunknown_valueLosslessAttributeDecoderLosslessAttributeEncoder/// The magic cookie value./// > The magic cookie field **MUST** contain the fixed value `0x2112A442` in/// > network byte order./// > In [RFC 3489](https://tools.ietf.org/html/rfc3489), this field was part of/// > the transaction ID; placing the magic cookie in this location allows/// > a server to detect if the client will understand certain attributes/// > that were added in this revised specification.  In addition, it aids/// > in distinguishing STUN packets from packets of other protocols when/// > STUN is multiplexed with those other protocols on the same port./// > ([RFC 5389 -- 6. STUN Message Structure](https://tools.ietf.org/html/rfc5389#section-6))try_as_ref/// Attempts to convert `self` to a reference to `T`./// If it is not possible, this method will return `None`.TryAsRef/// This trait allows for attempting to a cheap reference-to-reference conversion.//! Conversion traits.BrokenMessageDecodedMessageMessageDecoderMessageEncoder/// Macros.rfc5245rfc5780rfc8016rfc8656MainErrorBINDINGrfc5769_2_1_sample_requestrfc5769_2_2_sample_ipv4_responserfc5769_2_3_sample_ipv6_responserfc5769_2_4_sample_request_with_long_term_authentication//! Encoders and decoders for [STUN (RFC 5389)][RFC 5389] and its extensions.//! # extern crate bytecodec;//! # extern crate stun_codec;//! use bytecodec::{DecodeExt, EncodeExt, Error};//! use stun_codec::{Message, MessageClass, MessageDecoder, MessageEncoder, TransactionId};//! use stun_codec::rfc5389::{attributes::Software, methods::BINDING, Attribute};//! # fn main() -> bytecodec::Result<()> {//! // Creates a message//! let mut message = Message::<Attribute>::new(MessageClass::Request, BINDING, TransactionId::new([3; 12]));//! message.add_attribute(Software::new("foo".to_owned())?);//! // Encodes the message//! let mut encoder = MessageEncoder::new();//! let bytes = encoder.encode_into_bytes(message.clone())?;//!     bytes,//!     [//!         0, 1, 0, 8, 33, 18, 164, 66, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 128, 34, 0, 3,//!         102, 111, 111, 0//! // Decodes the message//! let mut decoder = MessageDecoder::<Attribute>::new();//! let decoded = decoder.decode_from_bytes(&bytes)?.map_err(Error::from)?;//! assert_eq!(decoded.class(), message.class());//! assert_eq!(decoded.method(), message.method());//! assert_eq!(decoded.transaction_id(), message.transaction_id());//! assert!(decoded.attributes().eq(message.attributes()));//! # Define your own attribute enum//! By using [`define_attribute_enums!`](./macro.define_attribute_enums.html) macro,//! you can easily define an enum that includes arbitrary attributes.//! The following is an example taken from [`rusturn`][rusturn-attributes] crate://! #[macro_use] extern crate trackable;//! use stun_codec::define_attribute_enums;//! use stun_codec::rfc5389::attributes::*;//! use stun_codec::rfc5766::attributes::*;//! define_attribute_enums!(//!     Attribute, AttributeDecoder, AttributeEncoder,//!         // RFC 5389//!         MappedAddress, Username, MessageIntegrity, ErrorCode,//!         UnknownAttributes, Realm, Nonce, XorMappedAddress,//!         Software, AlternateServer, Fingerprint,//!         // RFC 5766//!         ChannelNumber, Lifetime, XorPeerAddress, Data,//!         XorRelayAddress, EvenPort, RequestedTransport,//!         DontFragment, ReservationToken//! [rusturn-attributes]: https://github.com/sile/rusturn/blob/8efe92b7b63fa85a77664045f4a3bf172a3083ed/src/attribute.rs//! - [RFC 5389 - Session Traversal Utilities for NAT (STUN)][RFC 5389]//! - [RFC 5769 - Test Vectors for Session Traversal Utilities for NAT (STUN)][RFC 5769]//! - [RFC 5245 - Interactive Connectivity Establishment (ICE)][RFC 5245]//! - [RFC 5780 - NAT Behavior Discovery Using Session Traversal Utilities for NAT][RFC 5780]//! - [RFC 8016 - Mobility with Traversal Using Relays around NAT (TURN)][RFC 8016]//! - [RFC 8656 - Traversal Using Relays around NAT (TURN): Relay Extensions to Session Traversal Utilities for NAT (STUN)][RFC 8656]//! [RFC 5389]: https://tools.ietf.org/html/rfc5389//! [RFC 5769]: https://tools.ietf.org/html/rfc5769//! [RFC 5245]: https://tools.ietf.org/html/rfc5245//! [RFC 5780]: https://tools.ietf.org/html/rfc5780//! [RFC 8016]: https://tools.ietf.org/html/rfc8016//! [RFC 8656]: https://tools.ietf.org/html/rfc8656tracktrack_asserttrack_panicdefine_attribute_enums/// Defines an aggregated attribute type and its decoder and encoder./// Message decoded by [`MessageDecoder`].IndicationSuccessResponseErrorResponse/// The class of a message./// STUN message./// # NOTE: Binary Format of STUN Messages/// > STUN messages are encoded in binary using network-oriented format/// > (most significant byte or octet first, also commonly known as big-/// > endian).  The transmission order is described in detail in Appendix B/// > of [RFC 791].  Unless otherwise noted, numeric constants are/// > in decimal (base 10)./// > All STUN messages MUST start with a 20-byte header followed by zero/// > or more Attributes.  The STUN header contains a STUN message type,/// > magic cookie, transaction ID, and message length./// > ```text/// >  0                   1                   2                   3/// >  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1/// > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/// > |0 0|     STUN Message Type     |         Message Length        |/// > |                         Magic Cookie                          |/// > |                                                               |/// > |                     Transaction ID (96 bits)                  |/// >             Figure 2: Format of STUN Message Header/// > The most significant 2 bits of every STUN message MUST be zeroes./// > This can be used to differentiate STUN packets from other protocols/// > when STUN is multiplexed with other protocols on the same port./// > The message type defines the message class (request, success/// > response, failure response, or indication) and the message method/// > (the primary function) of the STUN message.  Although there are four/// > message classes, there are only two types of transactions in STUN:/// > request/response transactions (which consist of a request message and/// > a response message) and indication transactions (which consist of a/// > single indication message).  Response classes are split into error/// > and success responses to aid in quickly processing the STUN message./// > The message type field is decomposed further into the following structure:/// >  0                 1/// >  2  3  4 5 6 7 8 9 0 1 2 3 4 5/// > +--+--+-+-+-+-+-+-+-+-+-+-+-+-+/// > |M |M |M|M|M|C|M|M|M|C|M|M|M|M|/// > |11|10|9|8|7|1|6|5|4|0|3|2|1|0|/// > Figure 3: Format of STUN Message Type Field/// > Here the bits in the message type field are shown as most significant/// > (M11) through least significant (M0).  M11 through M0 represent a 12-/// > bit encoding of the method.  C1 and C0 represent a 2-bit encoding of/// > the class.  A class of 0b00 is a request, a class of 0b01 is an/// > indication, a class of 0b10 is a success response, and a class of/// > 0b11 is an error response.  This specification defines a single/// > method, Binding.  The method and class are orthogonal, so that for/// > each method, a request, success response, error response, and/// > indication are possible for that method.  Extensions defining new/// > methods MUST indicate which classes are permitted for that method./// > For example, a Binding request has class=0b00 (request) and/// > method=0b000000000001 (Binding) and is encoded into the first 16 bits/// > as 0x0001.  A Binding response has class=0b10 (success response) and/// > method=0b000000000001, and is encoded into the first 16 bits as 0x0101./// > > Note: This unfortunate encoding is due to assignment of values in/// > > [RFC 3489] that did not consider encoding Indications, Success, and/// > > Errors using bit fields./// > The magic cookie field MUST contain the fixed value 0x2112A442 in/// > network byte order.  In [RFC 3489], this field was part of/// > The transaction ID is a 96-bit identifier, used to uniquely identify/// > STUN transactions.  For request/response transactions, the/// > transaction ID is chosen by the STUN client for the request and/// > echoed by the server in the response.  For indications, it is chosen/// > by the agent sending the indication.  It primarily serves to/// > correlate requests with responses, though it also plays a small role/// > in helping to prevent certain types of attacks.  The server also uses/// > the transaction ID as a key to identify each transaction uniquely/// > across all clients.  As such, the transaction ID MUST be uniformly/// > and randomly chosen from the interval 0 .. 2**96-1, and SHOULD be/// > cryptographically random.  Resends of the same request reuse the same/// > transaction ID, but the client MUST choose a new transaction ID for/// > new transactions unless the new request is bit-wise identical to the/// > previous request and sent from the same transport address to the same/// > IP address.  Success and error responses MUST carry the same/// > transaction ID as their corresponding request.  When an agent is/// > acting as a STUN server and STUN client on the same port, the/// > transaction IDs in requests sent by the agent have no relationship to/// > the transaction IDs in requests received by the agent./// > The message length MUST contain the size, in bytes, of the message/// > not including the 20-byte STUN header.  Since all STUN attributes are/// > padded to a multiple of 4 bytes, the last 2 bits of this field are/// > always zero.  This provides another way to distinguish STUN packets/// > from packets of other protocols./// > Following the STUN fixed portion of the header are zero or more/// > attributes.  Each attribute is TLV (Type-Length-Value) encoded.  The/// > details of the encoding, and of the attributes themselves are given/// > in Section 15./// > [RFC 5389 -- 6. STUN Message Structure]/// [RFC 5389 -- 6. STUN Message Structure]: https://tools.ietf.org/html/rfc5389#section-6/// [RFC 791]: https://tools.ietf.org/html/rfc791/// [RFC 3489]: https://tools.ietf.org/html/rfc3489/// Makes a new `Message` instance./// Returns the class of the message./// Returns the method of the message./// Returns the transaction ID of the message./// Returns a reference to the first occurance of `T` attribute in the attributes of the message./// If there is no such attribute, this method will return `None`./// Returns an iterator that iterates over the known attributes in the message.unknown_attributes/// Returns an iterator that iterates over the unknown attributes in the message./// Note that it is the responsibility of users to check/// whether the unknown attributes contains comprehension-required ones./// Adds the given attribute to the tail of the attributes in the message./// STUN message of which [`MessageDecoder`] could not decode the attribute part./// Returns a reference to the error object storing the cause of failure to decode the message.magic_cookieMessageHeaderDecodercheck_magic_cookieAttributesDecoder/// [`Message`] decoder./// Makes a new `MessageDecoder` instance.finish_decoding_with_header/// [`Message`] encoder./// Makes a new `MessageEncoder` instance.message_class_from_u8_worksdecoder_fails_when_decoding_attributes/// STUN method./// > All STUN messages start with a fixed header that includes a **method**, a/// > class, and the transaction ID.  The **method** indicates which of the/// > various requests or indications this is;/// > [RFC 5389 -- 3. Overview of Operation]/// [RFC 5389 -- 3. Overview of Operation]: https://tools.ietf.org/html/rfc5389#section-3/// Makes a new `Method` instance with the given codepoint./// If `codepoint` is greater than `0xFFF`, this will return an `ErrorKind::InvalidInput` error./// Returns the codepoint corresponding this method.socket_addr_xor/// Applies XOR operation on the given socket address.IpBytesSocketAddrDecoder/// Socket address decoder./// Makes a new `SocketAddrDecoder` instance.SocketAddrEncoder/// Socket address encoder./// Makes a new `SocketAddrEncoder` instance.socket_addr_xor_workssocket_addr_encoder_workssocket_addr_decoder_works//! Socket address related components.//! # Binary Format of Socket Address//!  0                   1                   2                   3//!  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1//! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+//! |0 0 0 0 0 0 0 0|    Family     |           Port                |//! |                                                               |//! |                 Address (32 bits or 128 bits)                 |//! Family: IPv4=1, IPv6=2/// `PRIORITY` attribute./// See [RFC 5245 -- 7.1.2.1 PRIORITY] about this attribute./// [RFC 5245 -- 7.1.2.1 PRIORITY]: https://tools.ietf.org/html/rfc5245#section-7.1.2.1CODEPOINT/// The codepoint of the type of the attribute./// Makes a new `Priority` instance./// Returns the alternate address.PriorityDecoderPriorityEncoder/// [`Priority`] decoder./// Makes a new `PriorityDecoder` instance./// [`Priority`] encoder./// Makes a new `PriorityEncoder` instance.UseCandidate/// `USE-CANDIDATE` attribute./// See [RFC 5245 -- 7.1.2.1 USE-CANDIDATE] about this attribute./// [RFC 5245 -- 7.1.2.1 USE-CANDIDATE]: https://tools.ietf.org/html/rfc5245#section-7.1.2.1/// Makes a new `UseCandidate` instance.UseCandidateDecoderUseCandidateEncoder/// [`UseCandidate`] decoder./// Makes a new `UseCandidateDecoder` instance./// [`UseCandidate`] encoder./// Makes a new `UseCandidateEncoder` instance.IceControlled/// `ICE-CONTROLLED` attribute./// See [RFC 5245 -- 7.1.2.1 ICE-CONTROLLED] about this attribute./// [RFC 5245 -- 7.1.2.1 ICE-CONTROLLED]: https://tools.ietf.org/html/rfc5245#section-7.1.2.2/// Makes a new `IceControlled` instance.IceControlledDecoderIceControlledEncoder/// [`IceControlled`] decoder./// Makes a new `IceControlledDecoder` instance./// [`IceControlled`] encoder./// Makes a new `IceControlledEncoder` instance.IceControlling/// `ICE-CONTROLLING` attribute./// See [RFC 5245 -- 7.1.2.1 ICE-CONTROLLING] about this attribute./// [RFC 5245 -- 7.1.2.1 ICE-CONTROLLING]: https://tools.ietf.org/html/rfc5245#section-7.1.2.2/// Makes a new `IceControlling` instance.IceControllingDecoderIceControllingEncoder/// [`IceControlling`] decoder./// Makes a new `IceControllingDecoder` instance./// [`IceControlling`] encoder./// Makes a new `IceControllingEncoder` instance.//! Attributes that are defined in [RFC 5245].RoleConflict/// `487`: "Role Conflict"./// > The client asserted an ICE role (controlling or/// > controlled) that is in conflict with the role of the server./// > [RFC 5245 -- 21.3.  STUN Error Responses]/// [RFC 5245 -- 21.3.  STUN Error Responses]: https://tools.ietf.org/html/rfc5245#section-21.3/// The codepoint of the error.//! Error codes that are defined in [RFC 5389 -- 15.6 ERROR-CODE].//! [RFC 5389 -- 15.6 ERROR-CODE]: https://tools.ietf.org/html/rfc5389#section-15.6r" Attribute set."r" Attribute set decoder."r" Makes a new decoder instance."r" Attribute set encoder."r" Makes a new encoder instance."//! [RFC 5245(ICE)][RFC 5245] specific components./// `ALTERNATE-SERVER` attribute./// See [RFC 5389 -- 15.11. ALTERNATE-SERVER] about this attribute./// [RFC 5389 -- 15.11. ALTERNATE-SERVER]: https://tools.ietf.org/html/rfc5389#section-15.11/// Makes a new `AlternateServer` instance.AlternateServerDecoderAlternateServerEncoder/// [`AlternateServer`] decoder./// Makes a new `AlternateServerDecoder` instance./// [`AlternateServer`] encoder./// Makes a new `AlternateServerEncoder` instance./// `ERROR-CODE` attribute./// See [RFC 5389 -- 15.6. ERROR-CODE] about this attribute./// [RFC 5389 -- 15.6. ERROR-CODE]: https://tools.ietf.org/html/rfc5389#section-15.6/// Makes a new `ErrorCode` instance./// Note that the value of `code` must be in range of `300..600`./// If the value is out-of-range this will return an `ErrorKind::InvalidInput` error./// Returns the code of this error./// Returns the reason phrase of this error.ErrorCodeDecoderErrorCodeEncoder/// [`ErrorCode`] decoder./// Makes a new `ErrorCodeDecoder` instance./// [`ErrorCode`] encoder./// Makes a new `ErrorCodeEncoder` instance.Fingerprint/// `FINGERPRINT` attribute./// See [RFC 5389 -- 15.5. FINGERPRINT] about this attribute./// [RFC 5389 -- 15.5. FINGERPRINT]: https://tools.ietf.org/html/rfc5389#section-15.5/// Calculates the CRC-32 value of `message` and returns a `Fingerprint` instance containing it./// Returns the crc32 value of this instance.FingerprintDecoderFingerprintEncoder/// [`Fingerprint`] decoder./// Makes a new `FingerprintDecoder` instance./// [`Fingerprint`] encoder./// Makes a new `FingerprintEncoder` instance./// `MAPPED-ADDRESS` attribute./// See [RFC 5389 -- 15.1. MAPPED-ADDRESS] about this attribute./// [RFC 5389 -- 15.1. MAPPED-ADDRESS]: https://tools.ietf.org/html/rfc5389#section-15.1/// The codepoint of the tyep of the attribute./// Makes a new `MappedAddress` instance./// Returns the address of this instance.MappedAddressDecoderMappedAddressEncoder/// [`MappedAddress`] decoder./// Makes a new `MappedAddressDecoder` instance./// [`MappedAddress`] encoder./// Makes a new `MappedAddressEncoder` instance.preceding_message_bytes/// `MESSAGE-INTEGRITY` attribute./// See [RFC 5389 -- 15.3. MESSAGE-INTEGRITY] about this attribute./// [RFC 5389 -- 15.3. MESSAGE-INTEGRITY]: https://tools.ietf.org/html/rfc5389#section-15.4/// # TODO/// - Support SASLprepgenerate_hmac_token/// utility function for creating HMAC-SHA1 signaturesnew_short_term_credential/// Makes a new `MessageIntegrity` instance for short-term credentials.new_long_term_credential/// Makes a new `MessageIntegrity` instance for long-term credentials.check_short_term_credential/// Checks whether this has the valid short-term credential for `password`.check_long_term_credential/// Checks whether this has the valid long-term credential for `password`./// Returns the HMAC-SHA1 of this instance.message_into_bytesMessageIntegrityDecoderMessageIntegrityEncoder/// [`MessageIntegrity`] decoder./// Makes a new `MessageIntegrityDecoder` instance./// [`MessageIntegrity`] encoder./// Makes a new `MessageIntegrityEncoder` instance./// `NONCE` attribute./// See [RFC 5389 -- 15.8. NONCE] about this attribute./// [RFC 5389 -- 15.8. NONCE]: https://tools.ietf.org/html/rfc5389#section-15.8/// - Support [RFC 3261] and [RFC 2617]/// Makes a new `Nonce` instance./// The length of `value` must be less than `128` characters./// If it is too long, this will return an `ErrorKind::InvalidInput` error./// Returns the value of this instance.NonceDecoderNonceEncoder/// [`Nonce`] decoder./// Makes a new `NonceDecoder` instance./// [`Nonce`] encoder./// Makes a new `NonceEncoder` instance./// `REALM` attribute./// See [RFC 5389 -- 15.7. REALM] about this attribute./// [RFC 5389 -- 15.7. REALM]: https://tools.ietf.org/html/rfc5389#section-15.7/// - Support SASLprep [RFC 4013]/// Makes a new `Realm` instance./// The length of `text` must be less than `128` characters./// Returns the text of this instance.RealmDecoderRealmEncoder/// [`Realm`] decoder./// Makes a new `RealmDecoder` instance./// [`Realm`] encoder./// Makes a new `RealmEncoder` instance./// `SOFTWARE` attribute./// See [RFC 5389 -- 15.10. SOFTWARE] about this attribute./// [RFC 5389 -- 15.10. SOFTWARE]: https://tools.ietf.org/html/rfc5389#section-15.10/// Makes a new `Software` instance./// The length of `description` must be less than `128` characters./// Makes a new `Software` instance from a static string./// This function is const, so you can create this in a const context./// Panics if the string is longer./// Returns the description of this instance.SoftwareDecoderSoftwareEncoder/// [`Software`] decoder./// Makes a new `SoftwareDecoder` instance./// [`Software`] encoder./// Makes a new `SoftwareEncoder` instance.unknowns/// `UNKNOWN-ATTRIBUTES` attribute./// See [RFC 5389 -- 15.9. UNKNOWN-ATTRIBUTES] about this attribute./// [RFC 5389 -- 15.9. UNKNOWN-ATTRIBUTES]: https://tools.ietf.org/html/rfc5389#section-15.9/// Makes a new `UnknownAttributes` instance./// Returns the unknown attribute types of this instance.UnknownAttributesDecoderUnknownAttributesEncoder/// [`UnknownAttributes`] decoder./// Makes a new `UnknownAttributesDecoder` instance./// [`UnknownAttributes`] encoder./// Makes a new `UnknownAttributesEncoder` instance./// `USERNAME` attribute./// See [RFC 5389 -- 15.3. USERNAME] about this attribute./// [RFC 5389 -- 15.3. USERNAME]: https://tools.ietf.org/html/rfc5389#section-15.3/// Makes a new `Username` instance./// The length of `name` must be less then `513` bytes./// Returns the name of this instance.UsernameDecoderUsernameEncoder/// [`Username`] decoder./// Makes a new `UsernameDecoder` instance./// [`Username`] encoder./// Makes a new `UsernameEncoder` instance./// `XOR-MAPPED-ADDRESS` attribute./// See [RFC 5389 -- 15.2. XOR-MAPPED-ADDRESS] about this attribute./// [RFC 5389 -- 15.2. XOR-MAPPED-ADDRESS]: https://tools.ietf.org/html/rfc5389#section-15.2/// Makes a new `XorMappedAddress` instance.XorMappedAddressDecoderXorMappedAddressEncoder/// [`XorMappedAddress`] decoder./// Makes a new `XorMappedAddressDecoder` instance./// [`XorMappedAddress`] encoder./// Makes a new `XorMappedAddressEncoder` instance.XorMappedAddress2/// `XOR-MAPPED-ADDRESS` attribute with an alternative code./// Such attribute is returned by e.g. "Vovida.org 0.98-CPC" on stun.counterpath.net/// Makes a new `XorMappedAddress2` instance.XorMappedAddress2DecoderXorMappedAddress2Encoder/// [`XorMappedAddress2`] decoder.//! Attributes that are defined in [RFC 5389].TryAlternate/// `300`: "Try Alternate"./// > The client should contact an alternate server for/// > this request.  This error response MUST only be sent if the/// > request included a USERNAME attribute and a valid MESSAGE-/// > INTEGRITY attribute; otherwise, it MUST NOT be sent and error/// > code 400 (Bad Request) is suggested.  This error response MUST/// > be protected with the MESSAGE-INTEGRITY attribute, and receivers/// > MUST validate the MESSAGE-INTEGRITY of this response before/// > redirecting themselves to an alternate server./// > > Note: Failure to generate and validate message integrity/// > > for a 300 response allows an on-path attacker to falsify a/// > > 300 response thus causing subsequent STUN messages to be/// > > sent to a victim./// > [RFC 5389 -- 15.6 ERROR-CODE]/// [RFC 5389 -- 15.6 ERROR-CODE]: https://tools.ietf.org/html/rfc5389#section-15.6/// `400`: "Bad Request"./// > The request was malformed.  The client SHOULD NOT/// > retry the request without modification from the previous/// > attempt.  The server may not be able to generate a valid/// > MESSAGE-INTEGRITY for this error, so the client MUST NOT expect/// > a valid MESSAGE-INTEGRITY attribute on this response.Unauthorized/// `401`: "Unauthorized"./// > The request did not contain the correct/// > credentials to proceed.  The client should retry the request/// > with proper credentials./// `420`: "Unknown Attribute"./// > The server received a STUN packet containing/// > a comprehension-required attribute that it did not understand./// > The server MUST put this unknown attribute in the UNKNOWN-/// > ATTRIBUTE attribute of its error response.StaleNonce/// `438`: "Stale Nonce"./// > The NONCE used by the client was no longer valid./// > The client should retry, using the NONCE provided in the/// > response.ServerError/// `500`: "Server Error"./// > The server has suffered a temporary error.  The/// > client should try again./// Binding method./// > This document defines a single method called Binding.  The Binding/// > method can be used either in request/response transactions or in/// > indication transactions.  When used in request/response transactions,/// > the Binding method can be used to determine the particular "binding"/// > a NAT has allocated to a STUN client.  When used in either request//// > response or in indication transactions, the Binding method can also/// > be used to keep these "bindings" alive./// > In the Binding request/response transaction, a Binding request is/// > sent from a STUN client to a STUN server.  When the Binding request/// > arrives at the STUN server, it may have passed through one or more/// > NATs between the STUN client and the STUN server (in Figure 1, there/// > were two such NATs).  As the Binding request message passes through a/// > NAT, the NAT will modify the source transport address (that is, the/// > source IP address and the source port) of the packet.  As a result,/// > the source transport address of the request received by the server/// > will be the public IP address and port created by the NAT closest to/// > the server.  This is called a reflexive transport address.  The STUN/// > server copies that source transport address into an XOR-MAPPED-/// > ADDRESS attribute in the STUN Binding response and sends the Binding/// > response back to the STUN client.  As this packet passes back through/// > a NAT, the NAT will modify the destination transport address in the/// > IP header, but the transport address in the XOR-MAPPED-ADDRESS/// > attribute within the body of the STUN response will remain untouched./// > In this way, the client can learn its reflexive transport address/// > allocated by the outermost NAT with respect to the STUN server.//! Methods that are defined in [RFC 5389].//! [RFC 5389(STUN)][RFC 5389] specific components.ChannelNumber/// `CHANNEL-NUMBER` attribute./// See [RFC 5766 -- 14.1. CHANNEL-NUMBER] about this attribute./// [RFC 5766 -- 14.1. CHANNEL-NUMBER]: https://tools.ietf.org/html/rfc5766#section-14.1/// Minimum channel number./// Maximum channel number./// Makes a new `ChannelNumber` instance./// If `n` is not a number between `ChannelNumber::MIN` and `ChannelNumber::MAX`,/// this will return an `ErrorKind::InvalidInput` error./// Returns the channel number indicated by the attribute./// Returns the minimum channel number./// Returns the maximum channel number.wrapping_increment/// Wrapping incrementation.ChannelNumberDecoderChannelNumberEncoder/// [`ChannelNumber`] decoder./// Makes a new `ChannelNumberDecoder` instance./// [`ChannelNumber`] encoder./// Makes a new `ChannelNumberEncoder` instance./// `LIFETIME` attribute./// See [RFC 5766 -- 14.2. LIFETIME] about this attribute./// [RFC 5766 -- 14.2. LIFETIME]: https://tools.ietf.org/html/rfc5766#section-14.2/// Makes a new `Lifetime` instance./// Note that the nanoseconds part of `lifetime` is ignored and always set to `0`./// If the seconds part of `lifetime` is greater than `0xFFFF_FFFF`,/// this function will return an `ErrorKind::InvalidInput` error./// Makes a new `Lifetime` instance from `u32` value./// Returns the lifetime indicated by the attribute.LifetimeDecoderLifetimeEncoder/// [`Lifetime`] decoder./// Makes a new `LifetimeDecoder` instance./// [`Lifetime`] encoder./// Makes a new `LifetimeEncoder` instance.XorPeerAddress/// `XOR-PEER-ADDRESS` attribute./// See [RFC 5766 -- 14.3. XOR-PEER-ADDRESS] about this attribute./// [RFC 5766 -- 14.3. XOR-PEER-ADDRESS]: https://tools.ietf.org/html/rfc5766#section-14.3/// Makes a new `XorPeerAddress` instance./// Returns the address specified by the attribute.XorPeerAddressDecoderXorPeerAddressEncoder/// [`XorPeerAddress`] decoder./// Makes a new `XorPeerAddressDecoder` instance./// [`XorPeerAddress`] encoder./// Makes a new `XorPeerAddressEncoder` instance./// `DATA` attribute./// See [RFC 5766 -- 14.4. DATA] about this attribute./// [RFC 5766 -- 14.4. DATA]: https://tools.ietf.org/html/rfc5766#section-14.4/// Makes a new `Data` instance./// If the length of `data` is greater than `0xFFFF`,/// Returns a reference the data held by the attribute.DataDecoderDataEncoder/// [`Data`] decoder./// Makes a new `DataDecoder` instance./// [`Data`] encoder./// Makes a new `DataEncoder` instance.XorRelayAddress/// `XOR-RELAY-ADDRESS` attribute./// See [RFC 5766 -- 14.5. XOR-RELAY-ADDRESS] about this attribute./// [RFC 5766 -- 14.5. XOR-RELAY-ADDRESS]: https://tools.ietf.org/html/rfc5766#section-14.5/// Makes a new `XorRelayAddress` instance.XorRelayAddressDecoderXorRelayAddressEncoder/// [`XorRelayAddress`] decoder./// Makes a new `XorRelayAddressDecoder` instance./// [`XorRelayAddress`] encoder./// Makes a new `XorRelayAddressEncoder` instance.EvenPort/// `EVEN-PORT` attribute./// See [RFC 5766 -- 14.6. EVEN-PORT] about this attribute./// [RFC 5766 -- 14.6. EVEN-PORT]: https://tools.ietf.org/html/rfc5766#section-14.6/// Makes a new `EvenPort` instance.is_requested/// Returns whether the client requested that the port in the relayed transport address be even.EvenPortDecoderEvenPortEncoder/// [`EvenPort`] decoder./// Makes a new `EvenPortDecoder` instance./// [`EvenPort`] encoder./// Makes a new `EvenPortEncoder` instance.RequestedTransport/// `REQUESTED-TRANSPORT` attribute./// See [RFC 5766 -- 14.7. REQUESTED-TRANSPORT] about this attribute./// [RFC 5766 -- 14.7. REQUESTED-TRANSPORT]: https://tools.ietf.org/html/rfc5766#section-14.7/// Makes a new `RequestedTransport` instance./// Returns the transport protocol requested by the client.RequestedTransportDecoderRequestedTransportEncoder/// [`RequestedTransport`] decoder./// Makes a new `RequestedTransportDecoder` instance./// [`RequestedTransport`] encoder./// Makes a new `RequestedTransportEncoder` instance.DontFragment/// `DONT-FRAGMENT` attribute./// See [RFC 5766 -- 14.8. DONT-FRAGMENT] about this attribute./// [RFC 5766 -- 14.8. DONT-FRAGMENT]: https://tools.ietf.org/html/rfc5766#section-14.8DontFragmentDecoderDontFragmentEncoder/// [`DontFragment`] decoder./// Makes a new `DontFragmentDecoder` instance./// [`DontFragment`] encoder./// Makes a new `DontFragmentEncoder` instance.ReservationToken/// `RESERVATION-TOKEN` attribute./// See [RFC 5766 -- 14.9. RESERVATION-TOKEN] about this attribute./// [RFC 5766 -- 14.9. RESERVATION-TOKEN]: https://tools.ietf.org/html/rfc5766#section-14.9/// Makes a new `ReservationToken` instance./// Returns the token value contained by the attribute.ReservationTokenDecoderReservationTokenEncoder/// [`ReservationToken`] decoder./// Makes a new `ReservationTokenDecoder` instance./// [`ReservationToken`] encoder./// Makes a new `ReservationTokenEncoder` instance.first_byte_of_channel_number_is_in_range//! Attributes that are defined in [RFC 5766 -- 14. New STUN Attributes].//! [RFC 5766 -- 14. New STUN Attributes]: https://tools.ietf.org/html/rfc5766#section-14Forbidden/// `403`: "Forbidden"./// > The request was valid but cannot be performed due to administrative or similar restrictions./// > [RFC 5766 -- 15. New STUN Error Response Codes]/// [RFC 5766 -- 15. New STUN Error Response Codes]: https://tools.ietf.org/html/rfc5766#section-15AllocationMismatch/// `437`: "Allocation Mismatch"./// > A request was received by the server that requires an allocation to be in place, but no allocation exists,/// > or a request was received that requires no allocation, but an allocation exists.WrongCredentials/// `441`: "Wrong Credentials"./// > The credentials in the (non-Allocate) request do not match those used to create the allocation.UnsupportedTransportProtocol/// `442`: "Unsupported Transport Protocol"./// > The Allocate request asked the server to use a transport protocol between the server and the peer/// > that the server does not support.  NOTE: This does NOT refer to the transport protocol used in the 5-tuple.AllocationQuotaReached/// `486`: "Allocation Quota Reached"./// > No more allocations using this username can be created at the present time.InsufficientCapacity/// `508`: "Insufficient Capacity"./// > The server is unable to carry out the request due to some capacity limit being reached./// > In an Allocate response, this could be due to the server having no more relayed transport/// > addresses available at that time, having none with the requested properties,/// > or the one that corresponds to the specified reservation token is not available.//! Error codes that are defined in [RFC 5766 -- 15. New STUN Error Response Codes].//! [RFC 5766 -- 15. New STUN Error Response Codes]: https://tools.ietf.org/html/rfc5766#section-15ALLOCATE/// Allocate method./// Only request/response semantics defined./// Reference method./// Send method./// Only indication semantics defined./// Data method./// only indication semantics defined.CREATE_PERMISSION/// CreatePermission method.CHANNEL_BIND/// ChannelBind method.//! Methods that are defined in [RFC 5766 -- 13. New STUN Methods].//! [RFC 5766 -- 13. New STUN Methods]: https://tools.ietf.org/html/rfc5766#section-13//! [RFC 5766(TURN)][RFC 5766] specific components.//! [RFC 5766]: https://tools.ietf.org/html/rfc5766ChangeRequest/// `CHANGE-REQUEST` attribute./// See [RFC 5780 -- 7.2. CHANGE-REQUEST] about this attribute./// [RFC 5780 -- 7.2. CHANGE-REQUEST]: https://tools.ietf.org/html/rfc5780#section-7.2/// Makes a new `ChangeRequest` instance./// Returns whether the client requested the server to send the Binding Response with a/// different IP address than the one the Binding Request was received on/// different port than the one the Binding Request was received onChangeRequestDecoderChangeRequestEncoder/// [`ChangeRequest`] decoder./// Makes a new `ChangeRequestDecoder` instance./// [`ChangeRequest`] encoder./// Makes a new `ChangeRequestEncoder` instance./// `RESPONSE-ORIGIN` attribute./// See [RFC 5780 -- 7.3. RESPONSE-ORIGIN] about this attribute./// [RFC 5780 -- 7.3. RESPONSE-ORIGIN]: https://tools.ietf.org/html/rfc5780#section-7.3/// Makes a new `ResponseOrigin` instance.ResponseOriginDecoderResponseOriginEncoder/// [`ResponseOrigin`] decoder./// Makes a new `ResponseOriginDecoder` instance./// [`ResponseOrigin`] encoder./// [`ResponseOrigin`]: ./struct.ResponseOrigin.html/// Makes a new `ResponseOriginEncoder` instance./// `OTHER-ADDRESS` attribute./// See [RFC 5780 -- 7.4. OTHER-ADDRESS] about this attribute./// [RFC 5780 -- 7.4. OTHER-ADDRESS]: https://tools.ietf.org/html/rfc5780#section-7.4/// Makes a new `OtherAddress` instance.OtherAddressDecoderOtherAddressEncoder/// [`OtherAddress`] decoder./// Makes a new `OtherAddressDecoder` instance./// [`OtherAddress`] encoder./// Makes a new `OtherAddressEncoder` instance.ResponsePort/// `RESPONSE-PORT` attribute./// See [RFC 5780 -- 7.5. RESPONSE-PORT] about this attribute./// [RFC 5780 -- 7.5. RESPONSE-PORT]: https://tools.ietf.org/html/rfc5780#section-7.5/// Makes a new `ResponsePort` instance.ResponsePortDecoderResponsePortEncoder/// [`ResponsePort`] decoder./// Makes a new `ResponsePortDecoder` instance./// [`ResponsePort`] encoder./// Makes a new `ResponsePortEncoder` instance.//! Attributes that are defined in [RFC 5780].//! [RFC 5780(NAT Behavior Discovery)][RFC 5780] specific components.MobilityTicket/// `MOBILITY-TICKET` attribute./// See [Mobility with TURN RFC] about this attribute./// [Mobility with TURN RFC]: https://www.rfc-editor.org/rfc/rfc8016.html/// Makes a new, filled `MobilityTicket` instance./// Fails on exceeding length./// Makes a new, empty `MobilityTicket` for requesting mobility during creating allocation.MobilityTicketDecoderMobilityTicketEncoder//! Attributes that are defined in [RFC 8016].MobilityForbidden/// `405`: "Mobility Forbidden"./// >  405 (Mobility Forbidden): Mobility request was valid but cannot be performed due to administrative or similar restrictions./// > [RFC 8016 -- 3.4]/// [RFC 8016 -- 3.4]: https://www.rfc-editor.org/rfc/rfc8016.html#section-3.4//! Error codes that are defined in RFC 8016.//! [RFC 8016(Mobility with Traversal Using Relays around NAT (TURN))][RFC 8016] specific components./// Version 4 of IP/// Version 6 of IP/// The family of an IP address, either IPv4 or IPv6.RequestedAddressFamily/// This attribute is used in Allocate and Refresh requests to specify the address type requested by the client./// See <https://datatracker.ietf.org/doc/html/rfc8656#name-requested-address-family> for details./// Makes a new `RequestedAddressFamily` instance./// Returns the requested address family.RequestedAddressFamilyDecoderRequestedAddressFamilyEncoderAddressFamilyDecoder/// [`RequestedAddressFamily`] decoder./// Makes a new `RequestedAddressFamilyDecoder` instance.AddressFamilyEncoder/// [`RequestedAddressFamily`] encoder./// Makes a new `RequestedAddressFamilyEncoder` instance.AdditionalAddressFamily/// This attribute is used by clients to request the allocation of an IPv4 and IPv6 address type from a server./// See <https://datatracker.ietf.org/doc/html/rfc8656#name-additional-address-family> for details./// Makes a new `AdditionalAddressFamily` instance.AdditionalAddressFamilyDecoderAdditionalAddressFamilyEncoder/// [`AdditionalAddressFamily`] decoder./// [`AdditionalAddressFamily`] encoder.address_family_encoder_worksaddress_family_decoder_works//! Attributes that are defined in [RFC 8656].AddressFamilyNotSupported/// The server does not support the address family requested by the client./// See <https://datatracker.ietf.org/doc/html/rfc8656#section-19-2.6> for details.PeerAddressFamilyMismatch/// A peer address is part of a different address family than that of the relayed transport address of the allocation./// See <https://datatracker.ietf.org/doc/html/rfc8656#section-19-2.12> for details.//! Error codes that are defined in RFC 8656.//! [RFC 8656(Traversal Using Relays around NAT (TURN): Relay Extensions to Session Traversal Utilities for NAT (STUN))][RFC 8656] specific components./// Transaction ID./// > STUN is a client-server protocol.  It supports two types of/// > transactions.  One is a request/response transaction in which a/// > client sends a request to a server, and the server returns a/// > response.  The second is an indication transaction in which either/// > agent -- client or server -- sends an indication that generates no/// > response.  Both types of transactions include a **transaction ID**, which/// > is a randomly selected 96-bit number.  For request/response/// > transactions, this transaction ID allows the client to associate the/// > response with the request that generated it; for indications, the/// > transaction ID serves as a debugging aid./// Makes a new `TransactionId` instance./// Returns a reference to the bytes that represents the identifier./// Unsigned 12 bit integer./// Converts from `u8` value./// Tries to convert from `u16` value./// If `value` is greater than `0xFFF`, this will return `None`./// Converts to `u16` value.//! Miscellaneous types.// XorMappedAddress2,Bytecodec/// Could not encode or decode messageStun/// Broken STUN messageNoAddress/// No XorMappedAddress or MappedAddress in STUN reply/// UDP socket error/// Time out while reading socket/// The error type for any [`StunClient`] operations/// "End-to-end" timeout for the operation.retry_interval/// How often to repeat STUN binding requestsstun_server/// Address of the STUN serversoftware/// `SOFTWARE` attribute value in binding requestStunClient/// Options for querying STUN server/// A constructor with default parameterswith_google_stun_server/// Use hard coded STUN server `stun.l.google.com:19302`./// Not for production use, for tests, prototypes and demos./// May block the thread./// May panic in case of address resolution problems./// Set `timeout` field, builder pattern.set_retry_interval/// Set `retry_interval` field, builder pattern.set_software/// Set `software` field, builder pattern.get_binding_requestdecode_addressquery_external_address/// Get external (server-reflexive transport address) IP address and port of specified UDP socketquery_external_address_async_implquery_external_address_async/// async version of `query_external_address`./// Requires `async` crate feature to be enabled (it is by default)just_give_me_the_udp_socket_and_its_external_address/// Super-simple function with everything hard coded:/// just return `UdpSocket` and its external address in one step/// May block, may panic, uses public Google STUN server.it_works_async//! Simple UDP-only STUN client for resolving external IP address:port behind NAT./// Obtains a string slice containing the characters within the range specified by/// `start_index` and `end_index`./// The range specified is a character range, not a byte range./// Provides a [`substring()`] method./// The [`substring()`] method obtains a string slice of characters within the range specified by/// [`substring()`]: trait.Substring.html#tymethod.substring/// Obtain a slice of the characters within the range of `start_index` and `end_index`./// As this is by character index, rather than byte index, the temporal complexity of finding a/// substring is *O(n)*, where *n* is the byte length of the string./// use substring::Substring;/// assert_eq!("foobar".substring(2,5), "oba");/// Implements a [`substring()`] method for [`str`]./// Note that structs which implement `Deref<Target=str>` (such as [`String`]) will also have/// access to this implementation./// [`str`]: https://doc.rust-lang.org/std/primitive.str.html/// [`substring()`]: trait.Substring.html#method.substringtest_substringtest_out_of_boundstest_start_less_than_endtest_start_and_end_equaltest_multiple_byte_characters//! Substring method for string types.//! This crate provides a [`substring()`] method on Rust string types. The method takes a start and//! end character index and returns a string slice of the characters within that range.//! The method is provided via the [`Substring`] trait which is implemented on the [`str`]//! primitive.//! use substring::Substring;//! // Works on a string slice.//! assert_eq!("foobar".substring(2,5), "oba");//! // Also works on a String.//! assert_eq!("foobar".to_string().substring(1,6), "oobar");//! As Rust strings are UTF-8 encoded, the algorithm for finding a character substring is `O(n)`,//! where `n` is the byte length of the string. This is due to characters not being of predictible//! byte lengths.//! The indexing of substrings is based on [*Unicode Scalar Value*]. As such, substrings may not//! always match your intuition://! assert_eq!("ã".substring(0, 1), "a");  // As opposed to "ã".//! assert_eq!("ã".substring(1, 2), "\u{0303}")//! The above example occurs because "ã" is technically made up of two UTF-8 scalar values.//! [`str`]: https://doc.rust-lang.org/std/primitive.str.html//! [`Substring`]: trait.Substring.html//! [`substring()`]: trait.Substring.html#tymethod.substring//! [*Unicode Scalar Value*]: http://www.unicode.org/glossary/#unicode_scalar_value// Since the MSRV is 1.0.0, allowing usage of deprecated items is ok, as the replacements are likely// not available in early versions./// The `Choice` struct represents a choice for use in conditional assignment./// It is a wrapper around a `u8`, which should have the value either `1` (true)/// or `0` (false)./// The conversion from `u8` to `Choice` passes the value through an optimization/// barrier, as a best-effort attempt to prevent the compiler from inferring that/// the `Choice` value is a boolean. This strategy is based on Tim Maclean's/// [work on `rust-timing-shield`][rust-timing-shield], which attempts to provide/// a more comprehensive approach for preventing software side-channels in Rust/// The `Choice` struct implements operators for AND, OR, XOR, and NOT, to allow/// combining `Choice` values. These operations do not short-circuit./// [rust-timing-shield]:/// https://www.chosenplaintext.ca/open-source/rust-timing-shield/securityunwrap_u8/// Unwrap the `Choice` wrapper to reveal the underlying `u8`./// This function only exists as an **escape hatch** for the rare case/// where it's not possible to use one of the `subtle`-provided/// trait impls./// **To convert a `Choice` to a `bool`, use the `From` implementation instead.**/// Convert the `Choice` wrapper into a `bool`, depending on whether/// the underlying `u8` was a `0` or a `1`./// This function exists to avoid having higher-level cryptographic protocol/// implementations duplicating this pattern./// The intended use case for this conversion is at the _end_ of a/// higher-level primitive implementation: for example, in checking a keyed/// MAC, where the verification should happen in constant-time (and thus use/// a `Choice`) but it is safe to return a `bool` at the end of the/// This function is a best-effort attempt to prevent the compiler from knowing/// anything about the value of the returned `u8`, other than its type./// Because we want to support stable Rust, we don't have access to inline/// assembly or test::black_box, so we use the fact that volatile values will/// never be elided to register values./// Note: Rust's notion of "volatile" is subject to change over time. While this/// code may break in a non-destructive way in the future, “constant-time” code/// is a continually moving target, and this is better than doing nothing./// Determine if two items are equal./// The `ct_eq` function should execute in constant time./// * `Choice(1u8)` if `self == other`;/// * `Choice(0u8)` if `self != other`.ct_ne/// Determine if two items are NOT equal./// The `ct_ne` function should execute in constant time./// * `Choice(0u8)` if `self == other`;/// * `Choice(1u8)` if `self != other`./// An `Eq`-like trait that produces a `Choice` instead of a `bool`./// use subtle::ConstantTimeEq;/// let x: u8 = 5;/// let y: u8 = 13;/// assert_eq!(x.ct_eq(&y).unwrap_u8(), 0);/// assert_eq!(x.ct_eq(&x).unwrap_u8(), 1);// #[inline] is specified on these function prototypes to signify that they// should be in the actual implementation/// Check whether two slices of `ConstantTimeEq` types are equal./// This function short-circuits if the lengths of the input slices/// are different.  Otherwise, it should execute in time independent/// of the slice contents./// Since arrays coerce to slices, this function works with fixed-size arrays:/// # use subtle::ConstantTimeEq;/// let a: [u8; 8] = [0,1,2,3,4,5,6,7];/// let b: [u8; 8] = [0,1,2,3,0,1,2,3];/// let a_eq_a = a.ct_eq(&a);/// let a_eq_b = a.ct_eq(&b);/// assert_eq!(a_eq_a.unwrap_u8(), 1);/// assert_eq!(a_eq_b.unwrap_u8(), 0);generate_integer_equal/// Given the bit-width `$bit_width` and the corresponding primitive/// unsigned and signed types `$t_u` and `$t_i` respectively, generate/// an `ConstantTimeEq` implementation./// `Ordering` is `#[repr(i8)]` making it possible to leverage `i8::ct_eq`./// Select `a` or `b` according to `choice`./// * `a` if `choice == Choice(0)`;/// * `b` if `choice == Choice(1)`./// This function should execute in constant time./// let x: u8 = 13;/// let y: u8 = 42;/// let z = u8::conditional_select(&x, &y, 0.into());/// assert_eq!(z, x);/// let z = u8::conditional_select(&x, &y, 1.into());/// assert_eq!(z, y);/// Conditionally assign `other` to `self`, according to `choice`./// let mut x: u8 = 13;/// let mut y: u8 = 42;/// x.conditional_assign(&y, 0.into());/// assert_eq!(x, 13);/// x.conditional_assign(&y, 1.into());/// Conditionally swap `self` and `other` if `choice == 1`; otherwise,/// reassign both unto themselves./// u8::conditional_swap(&mut x, &mut y, 0.into());/// assert_eq!(y, 42);/// u8::conditional_swap(&mut x, &mut y, 1.into());/// assert_eq!(y, 13);/// A type which can be conditionally selected in constant time./// This trait also provides generic implementations of conditional/// assignment and conditional swaps.to_signed_intgenerate_integer_conditional_select/// `Ordering` is `#[repr(i8)]` where:/// - `Less` => -1/// - `Equal` => 0/// - `Greater` => 1/// Given this, it's possible to operate on orderings as if they're integers,/// which allows leveraging conditional masking for predication./// Negate `self` if `choice == Choice(1)`; otherwise, leave it/// A type which can be conditionally negated in constant time./// A generic implementation of `ConditionallyNegatable` is provided/// for types `T` which are `ConditionallySelectable` and have `Neg`/// implemented on `&T`./// The `CtOption<T>` type represents an optional value similar to the/// [`Option<T>`](core::option::Option) type but is intended for/// use in constant time APIs./// Any given `CtOption<T>` is either `Some` or `None`, but unlike/// `Option<T>` these variants are not exposed. The/// [`is_some()`](CtOption::is_some) method is used to determine if/// the value is `Some`, and [`unwrap_or()`](CtOption::unwrap_or) and/// [`unwrap_or_else()`](CtOption::unwrap_or_else) methods are/// provided to access the underlying value. The value can also be/// obtained with [`unwrap()`](CtOption::unwrap) but this will panic/// if it is `None`./// Functions that are intended to be constant time may not produce/// valid results for all inputs, such as square root and inversion/// operations in finite field arithmetic. Returning an `Option<T>`/// from these functions makes it difficult for the caller to reason/// about the result in constant time, and returning an incorrect/// value burdens the caller and increases the chance of bugs./// Convert the `CtOption<T>` wrapper into an `Option<T>`, depending on whether/// the underlying `is_some` `Choice` was a `0` or a `1` once unwrapped./// This function exists to avoid ending up with ugly, verbose and/or bad handled/// conversions from the `CtOption<T>` wraps to an `Option<T>` or `Result<T, E>`./// This implementation doesn't intend to be constant-time nor try to protect the/// leakage of the `T` since the `Option<T>` will do it anyways./// This method is used to construct a new `CtOption<T>` and takes/// a value of type `T`, and a `Choice` that determines whether/// the optional value should be `Some` or not. If `is_some` is/// false, the value will still be stored but its value is never/// exposed./// Returns the contained value, consuming the `self` value./// Panics if the value is none with a custom panic message provided by/// `msg`./// This returns the underlying value but panics if it/// is not `Some`./// This returns the underlying value if it is `Some`/// or the provided value otherwise./// or the value produced by the provided closure otherwise./// This operates in constant time, because the provided closure/// is always called./// Returns a true `Choice` if this value is `Some`./// Returns a true `Choice` if this value is `None`./// Returns a `None` value if the option is `None`, otherwise/// returns a `CtOption` enclosing the value of the provided closure./// The closure is given the enclosed value or, if the option is/// `None`, it is provided a dummy value computed using/// `Default::default()`./// returns the result of the provided closure. The closure is/// given the enclosed value or, if the option is `None`, it/// is provided a dummy value computed using `Default::default()`./// Returns `self` if it contains a value, and otherwise returns the result of/// calling `f`. The provided function `f` is always called./// It's equivalent to the corresponding `From` impl, however this version is/// friendlier for type inference./// Two `CtOption<T>`s are equal if they are both `Some` and/// their values are equal, or both `None`./// Determine whether `self > other`./// The bitwise-NOT of the return value of this function should be usable to/// determine if `self <= other`./// A `Choice` with a set bit if `self > other`, and with no set bits/// use subtle::ConstantTimeGreater;/// let x_gt_y = x.ct_gt(&y);/// assert_eq!(x_gt_y.unwrap_u8(), 0);/// let y_gt_x = y.ct_gt(&x);/// assert_eq!(y_gt_x.unwrap_u8(), 1);/// let x_gt_x = x.ct_gt(&x);/// assert_eq!(x_gt_x.unwrap_u8(), 0);/// A type which can be compared in some manner and be determined to be greater/// than another of the same type.generate_unsigned_integer_greaterr" Returns Choice::from(1) iff x > y, and Choice::from(0) iff x <= y."r" # Note"r" This algoritm would also work for signed integers if we first"r" flip the top bit, e.g. `let x: u8 = x ^ 0x80`, etc."/// Determine whether `self < other`./// determine if `self >= other`./// A default implementation is provided and implemented for the unsigned/// integer types./// A `Choice` with a set bit if `self < other`, and with no set bits/// use subtle::ConstantTimeLess;/// let x_lt_y = x.ct_lt(&y);/// assert_eq!(x_lt_y.unwrap_u8(), 1);/// let y_lt_x = y.ct_lt(&x);/// assert_eq!(y_lt_x.unwrap_u8(), 0);/// let x_lt_x = x.ct_lt(&x);/// assert_eq!(x_lt_x.unwrap_u8(), 0);/// A type which can be compared in some manner and be determined to be lessBlackBox/// Wrapper type which implements an optimization barrier for all accesses./// Constructs a new instance of `BlackBox` which will wrap the specified value./// All access to the inner value will be mediated by a `black_box` optimization barrier./// Read the inner value, applying an optimization barrier on access.// This file is part of subtle, part of the dalek cryptography project.// Copyright (c) 2016-2018 isis lovecruft, Henry de Valence//! # subtle [![](https://img.shields.io/crates/v/subtle.svg)](https://crates.io/crates/subtle) [![](https://img.shields.io/badge/dynamic/json.svg?label=docs&uri=https%3A%2F%2Fcrates.io%2Fapi%2Fv1%2Fcrates%2Fsubtle%2Fversions&query=%24.versions%5B0%5D.num&colorB=4F74A6)](https://doc.dalek.rs/subtle) [![](https://travis-ci.org/dalek-cryptography/subtle.svg?branch=master)](https://travis-ci.org/dalek-cryptography/subtle)//! **Pure-Rust traits and utilities for constant-time cryptographic implementations.**//! It consists of a `Choice` type, and a collection of traits using `Choice`//! instead of `bool` which are intended to execute in constant-time.  The `Choice`//! type is a wrapper around a `u8` that holds a `0` or `1`.//! subtle = "2.6"//! This crate represents a “best-effort” attempt, since side-channels//! are ultimately a property of a deployed cryptographic system//! including the hardware it runs on, not just of software.//! The traits are implemented using bitwise operations, and should execute in//! constant time provided that a) the bitwise operations are constant-time and//! b) the bitwise operations are not recognized as a conditional assignment and//! optimized back into a branch.//! For a compiler to recognize that bitwise operations represent a conditional//! assignment, it needs to know that the value used to generate the bitmasks is//! really a boolean `i1` rather than an `i8` byte value. In an attempt to//! prevent this refinement, the crate tries to hide the value of a `Choice`'s//! inner `u8` by passing it through a volatile read. For more information, see//! the _About_ section below.//! Rust versions from 1.51 or higher have const generics support. You may enable//! `const-generics` feautre to have `subtle` traits implemented for arrays `[T; N]`.//! Versions prior to `2.2` recommended use of the `nightly` feature to enable an//! optimization barrier; this is not required in versions `2.2` and above.//! Note: the `subtle` crate contains `debug_assert`s to check invariants during//! debug builds. These invariant checks involve secret-dependent branches, and//! are not present when compiled in release mode. This crate is intended to be//! used in release mode.//! Documentation is available [here][docs].//! ## Minimum Supported Rust Version//! Rust **1.41** or higher.//! Minimum supported Rust version can be changed in the future, but it will be done with a minor version bump.//! This library aims to be the Rust equivalent of Go’s `crypto/subtle` module.//! Old versions of the optimization barrier in `impl From<u8> for Choice` were//! based on Tim Maclean's [work on `rust-timing-shield`][rust-timing-shield],//! which attempts to provide a more comprehensive approach for preventing//! software side-channels in Rust code.//! From version `2.2`, it was based on Diane Hosfelt and Amber Sprenkels' work on//! "Secret Types in Rust".//! `subtle` is authored by isis agora lovecruft and Henry de Valence.//! ## Warning//! This code is a low-level library, intended for specific use-cases implementing//! cryptographic protocols.  It represents a best-effort attempt to protect//! against some software side-channels.  Because side-channel resistance is not a//! property of software alone, but of software together with hardware, any such//! effort is fundamentally limited.//! **USE AT YOUR OWN RISK**//! [docs]: https://docs.rs/subtle//! [rust-timing-shield]: https://www.chosenplaintext.ca/open-source/rust-timing-shield/securityast_structr" An attribute like `#[repr(transparent)]`."r#" *This type is available if Syn is built with the `"derive"` or `"full"`"#r" feature.*"r" Rust has six types of attributes."r" - Outer attributes like `#[repr(transparent)]`. These appear outside or"r"   in front of the item they describe."r" - Inner attributes like `#![feature(proc_macro)]`. These appear inside"r"   of the item they describe, usually a module."r" - Outer doc comments like `/// # Example`."r" - Inner doc comments like `//! Please file an issue`."r" - Outer block comments `/** # Example */`."r" - Inner block comments `/*! Please file an issue */`."r" The `style` field of type `AttrStyle` distinguishes whether an attribute"r" is outer or inner. Doc comments and block comments are promoted to"r" attributes, as this is how they are processed by the compiler and by"r" `macro_rules!` macros."r" The `path` field gives the possibly colon-delimited path against which"r#" the attribute is resolved. It is equal to `"doc"` for desugared doc"#r" comments. The `tts` field contains the rest of the attribute body as"r" tokens."r" #[derive(Copy)]      #[crate::precondition x < 5]"r"   ^^^^^^~~~~~~         ^^^^^^^^^^^^^^^^^^^ ~~~~~"r"    path  tts                   path         tts"r" Use the [`parse_meta`] method to try parsing the tokens of an attribute"r" into the structured representation that is used by convention across"r" most Rust libraries."r" [`parse_meta`]: Attribute::parse_meta"r" # Parsing"r" This type does not implement the [`Parse`] trait and thus cannot be"r" parsed directly by [`ParseStream::parse`]. Instead use"r" [`ParseStream::call`] with one of the two parser functions"r" [`Attribute::parse_outer`] or [`Attribute::parse_inner`] depending on"r" which you intend to parse."r" [`Parse`]: parse::Parse"r" [`ParseStream::parse`]: parse::ParseBuffer::parse"r" [`ParseStream::call`]: parse::ParseBuffer::call"r" ```edition2018"r" use syn::{Attribute, Ident, Result, Token};"r" use syn::parse::{Parse, ParseStream};"r" // Parses a unit struct with attributes."r#" //     #[path = "s.tmpl"]"#r" //     struct S;"r" struct UnitStruct {"r"     attrs: Vec<Attribute>,"r"     struct_token: Token![struct],"r"     name: Ident,"r"     semi_token: Token![;],"r" impl Parse for UnitStruct {"r"     fn parse(input: ParseStream) -> Result<Self> {"r"         Ok(UnitStruct {"r"             attrs: input.call(Attribute::parse_outer)?,"r"             struct_token: input.parse()?,"r"             name: input.parse()?,"r"             semi_token: input.parse()?,"r"         })"bracket_tokenttsinterpret_meta/// Parses the content of the attribute, consisting of the path and tts, as/// a [`Meta`] if possible./// Deprecated; use `parse_meta` instead.parse_metaparse_outer/// Parses zero or more outer attributes from the stream./// *This function is available if Syn is built with the `"parsing"`/// feature.*/// Parses zero or more inner attributes from the stream.ast_enumr" Distinguishes between attributes that decorate an item and attributes"r" that are contained within an item."r" # Outer attributes"r" - `#[repr(transparent)]`"r" - `/// # Example`"r" - `/** Please file an issue */`"r" # Inner attributes"r" - `#![feature(proc_macro)]`"r" - `//! # Example`"r" - `/*! Please file an issue */`"Bangast_enum_of_structsr" Content of a compile-time structured attribute."r" ## Word"r" A meta word is like the `test` in `#[test]`."r" ## List"r" A meta list is like the `derive(Copy)` in `#[derive(Copy)]`."r" ## NameValue"r#" A name-value meta is like the `path = "..."` in `#[path ="#r#" "sys/windows.rs"]`."#r" # Syntax tree enum"r" This type is a [syntax tree enum]."r" [syntax tree enum]: enum.Expr.html#syntax-tree-enums"r" A structured list within an attribute, like `derive(Copy, Clone)`."r#" *This type is available if Syn is built with the `"derive"` or"#r#" `"full"` feature.*"#r#" A name-value pair within an attribute, like `feature = "nightly"`."#NameValuemaybe_ast_structparen_tokenPareneq_tokengenerate_to_tokens/// Returns the identifier that begins this structured meta item./// For example this would return the `test` in `#[test]`, the `derive` in/// `#[derive(Copy)]`, and the `path` in `#[path = "sys/windows.rs"]`.r" Element of a compile-time attribute list."r" A structured meta item, like the `Copy` in `#[derive(Copy)]` which"r" would be a nested `Meta::Word`."r#" A Rust literal, like the `"new_name"` in `#[rename("new_name")]`."#AttributeArgs/// Conventional argument type associated with an invocation of an attribute/// For example if we are developing an attribute macro that is intended to be/// invoked on function items as follows:/// #[my_attribute(path = "/v1/refresh")]/// pub fn refresh() {/// The implementation of this macro would want to parse its attribute arguments/// as type `AttributeArgs`./// use syn::{parse_macro_input, AttributeArgs, ItemFn};/// #[proc_macro_attribute]/// pub fn my_attribute(args: TokenStream, input: TokenStream) -> TokenStream {///     let args = parse_macro_input!(args as AttributeArgs);///     let input = parse_macro_input!(input as ItemFn);/// #   "".parse().unwrap()FilterAttrssingle_parse_innersingle_parse_outerparse_meta_after_identparse_meta_list_after_identparse_meta_name_value_after_identprintingpm// Mimicking types from proc-macro.// End entries contain a raw pointer to the entry from the containing// token tree, or null if this is the outermost level./// Internal type which is used instead of `TokenTree` to represent a token tree/// within a `TokenBuffer`.// NOTE: Do not derive clone on this - there are raw pointers inside which// will be messed up. Moving the `TokenBuffer` itself is safe as the actual// backing slices won't be moved./// A buffer that can be efficiently traversed multiple times, unlike/// `TokenStream` which requires a deep copy in order to traverse more than/// *This type is available if Syn is built with the `"parsing"` feature.*inner_new// NOTE: DO NOT MUTATE THE `Vec` RETURNED FROM THIS FUNCTION ONCE IT// RETURNS, THE ADDRESS OF ITS BACKING MEMORY MUST REMAIN STABLE./// Creates a `TokenBuffer` containing all the tokens from the input/// `TokenStream`./// *This method is available if Syn is built with both the `"parsing"` and/// `"proc-macro"` features.*/// Creates a cursor referencing the first token in the buffer and able to/// traverse until the end of the buffer.// The current entry which the `Cursor` is pointing at.// This is the only `Entry::End(..)` object which this cursor is allowed to// point at. All other `End` objects are skipped over in `Cursor::create`.// Cursor is covariant in 'a. This field ensures that our pointers are still// valid./// A cheaply copyable cursor into a `TokenBuffer`./// This cursor holds a shared reference into the immutable data which is used/// internally to represent a `TokenStream`, and can be efficiently manipulated/// and copied around./// An empty `Cursor` can be created directly, or one may create a `TokenBuffer`/// object and get a cursor to its first token with `begin()`./// Two cursors are equal if they have the same location in the same input/// stream, and have the same scope./// Creates a cursor referencing a static empty TokenStream./// This create method intelligently exits non-explicitly-entered/// `None`-delimited scopes when the cursor reaches the end of them,/// allowing for them to be treated transparently./// Get the current entry./// Bump the cursor to point at the next token after the current one. This/// is undefined behavior if the cursor is currently looking at an/// `Entry::End`.ignore_none/// If the cursor is looking at a `None`-delimited group, move it to look at/// the first token inside instead. If the group is empty, this will move/// the cursor past the `None`-delimited group./// WARNING: This mutates its argument./// Checks whether the cursor is currently pointing at the end of its valid/// If the cursor is pointing at a `Group` with the given delimiter, returns/// a cursor into that group and one pointing to the next `TokenTree`./// If the cursor is pointing at a `Ident`, returns it along with a cursor/// pointing at the next `TokenTree`./// If the cursor is pointing at an `Punct`, returns it along with a cursor/// If the cursor is pointing at a `Literal`, return it along with a cursor/// If the cursor is pointing at a `Lifetime`, returns it along with a/// cursor pointing at the next `TokenTree`./// Copies all remaining tokens visible from this cursor into a/// If the cursor is pointing at a `TokenTree`, returns it along with a/// Returns `None` if the cursor has reached the end of its stream./// This method does not treat `None`-delimited groups as transparent, and/// will return a `Group(None, ..)` if the cursor is looking at one./// Returns the `Span` of the current token, or `Span::call_site()` if this/// cursor points to eof.same_scope//! A stably addressed token buffer supporting efficient traversal based on a//! cheaply copyable cursor.//! *This module is available if Syn is built with the `"parsing"` feature.*// This module is heavily commented as it contains most of the unsafe code in// Syn, and caution should be used when editing it. The public-facing interface// is 100% safe but the implementation is fragile internally./// Define a type that supports parsing and printing a given identifier as if it/// were a keyword./// As a convention, it is recommended that this macro be invoked within a/// module called `kw` or `keyword` and that the resulting parser be invoked/// with a `kw::` or `keyword::` prefix./// mod kw {///     syn::custom_keyword!(whatever);/// The generated syntax tree node supports the following operations just like/// any built-in keyword token./// - [Peeking] — `input.peek(kw::whatever)`/// - [Parsing] — `input.parse::<kw::whatever>()?`/// - [Printing] — `quote!( ... #whatever_token ... )`/// - Construction from a [`Span`] — `let whatever_token = kw::whatever(sp)`/// - Field access to its span — `let sp = whatever_token.span`/// [Peeking]: parse::ParseBuffer::peek/// [Parsing]: parse::ParseBuffer::parse/// [Printing]: quote::ToTokens/// This example parses input that looks like `bool = true` or `str = "value"`./// The key must be either the identifier `bool` or the identifier `str`. If/// `bool`, the value may be either `true` or `false`. If `str`, the value may/// be any string literal./// The symbols `bool` and `str` are not reserved keywords in Rust so these are/// not considered keywords in the `syn::token` module. Like any other/// identifier that is not a keyword, these can be declared as custom keywords/// by crates that need to use them as such./// use syn::{LitBool, LitStr, Result, Token};/// use syn::parse::{Parse, ParseStream};///     syn::custom_keyword!(bool);///     syn::custom_keyword!(str);/// enum Argument {///     Bool {///         bool_token: kw::bool,///         eq_token: Token![=],///         value: LitBool,///     Str {///         str_token: kw::str,///         value: LitStr,/// impl Parse for Argument {///     fn parse(input: ParseStream) -> Result<Self> {///         let lookahead = input.lookahead1();///         if lookahead.peek(kw::bool) {///             Ok(Argument::Bool {///                 bool_token: input.parse::<kw::bool>()?,///                 eq_token: input.parse()?,///                 value: input.parse()?,///         } else if lookahead.peek(kw::str) {///             Ok(Argument::Str {///                 str_token: input.parse::<kw::str>()?,///             Err(lookahead.error())custom_punctuation/// Define a type that supports parsing and printing a multi-character symbol/// as if it were a punctuation token./// syn::custom_punctuation!(LeftRightArrow, <=>);/// any built-in punctuation token./// - [Peeking] — `input.peek(LeftRightArrow)`/// - [Parsing] — `input.parse::<LeftRightArrow>()?`/// - [Printing] — `quote!( ... #lrarrow ... )`/// - Construction from a [`Span`] — `let lrarrow = LeftRightArrow(sp)`/// - Construction from multiple [`Span`] — `let lrarrow = LeftRightArrow([sp, sp, sp])`/// - Field access to its spans — `let spans = lrarrow.spans`/// use proc_macro2::{TokenStream, TokenTree};/// use syn::parse::{Parse, ParseStream, Peek, Result};/// use syn::punctuated::Punctuated;/// use syn::Expr;/// syn::custom_punctuation!(PathSeparator, </>);/// // expr </> expr </> expr .../// struct PathSegments {///     segments: Punctuated<Expr, PathSeparator>,/// impl Parse for PathSegments {///         let mut segments = Punctuated::new();///         let first = parse_until(input, PathSeparator)?;///         segments.push_value(syn::parse2(first)?);///         while input.peek(PathSeparator) {///             segments.push_punct(input.parse()?);///             let next = parse_until(input, PathSeparator)?;///             segments.push_value(syn::parse2(next)?);///         Ok(PathSegments { segments })/// fn parse_until<E: Peek>(input: ParseStream, end: E) -> Result<TokenStream> {///     let mut tokens = TokenStream::new();///     while !input.is_empty() && !input.peek(end) {///         let next: TokenTree = input.parse()?;///         tokens.extend(Some(next));///     Ok(tokens)///     let input = r#" a::b </> c::d::e "#;///     let _: PathSegments = syn::parse_str(input).unwrap();impl_parse_for_custom_punctuationimpl_to_tokens_for_custom_punctuationimpl_clone_for_custom_punctuationimpl_extra_traits_for_custom_punctuationcustom_punctuation_reprcustom_punctuation_lencustom_punctuation_unexpectedstringify_punctcustom_punctuation_concat// Without this, local_inner_macros breaks when looking for concat!r" An enum variant."r" Attributes tagged on the variant."r" Name of the variant."r" Content stored in the variant."r" Explicit discriminant: `Variant = 1`"r" Data stored within an enum variant or struct."r" Named fields of a struct or struct variant such as `Point { x: f64,"r" y: f64 }`."r" Unnamed fields of a tuple struct or tuple variant such as `Some(T)`."r" Unit struct or unit variant such as `None`."brace_tokenunnamed/// Get an iterator over the borrowed [`Field`] items in this object. This/// iterator can be used to iterate over a named or unnamed struct or/// variant's fields uniformly./// Get an iterator over the mutably borrowed [`Field`] items in this/// object. This iterator can be used to iterate over a named or unnamed/// struct or variant's fields uniformly.r" A field of a struct or enum variant."r" Attributes tagged on the field."r" Visibility of the field."r" Name of the field, if any."r" Fields of tuple structs have no names."colon_tokenr" Type of the field."r" The visibility level of an item: inherited or `pub` or"r" `pub(restricted)`."r" A public visibility level: `pub`."VisPublicr" A crate-level visibility: `crate`."VisCrater" A visibility level restricted to some path: `pub(self)` or"r" `pub(super)` or `pub(crate)` or `pub(in some::module)`."Restrictedr" An inherited visibility, which usually means private."pub_tokenPubcrate_tokenin_tokenparse_named/// Parses a named (braced struct) field.parse_unnamed/// Parses an unnamed (tuple struct) field.parse_pubparse_crateTokensOrDefaultr" Data structure sent to a `proc_macro_derive` macro."r#" *This type is available if Syn is built with the `"derive"` feature.*"#r" Attributes tagged on the whole struct or enum."r" Visibility of the struct or enum."r" Name of the struct or enum."r" Generics required to complete the definition."r" Data within the struct or enum."r" The storage of a struct, enum or union data structure."r" A struct input to a `proc_macro_derive` macro."r#" *This type is available if Syn is built with the `"derive"`"#r" An enum input to a `proc_macro_derive` macro."r" A tagged union input to a `proc_macro_derive` macro."DataUnionstruct_tokenenum_tokenunion_tokendata_structdata_enumdata_unionadvance_to/// Advance this parse stream to the position of a forked parse stream./// This is the opposite operation to [`ParseStream::fork`]. You can fork a/// parse stream, perform some speculative parsing, then join the original/// stream to the fork to "commit" the parsing from the fork to the main/// If you can avoid doing this, you should, as it limits the ability to/// generate useful errors. That said, it is often the only way to parse/// syntax of the form `A* B*` for arbitrary syntax `A` and `B`. The problem/// is that when the fork fails to parse an `A`, it's impossible to tell/// whether that was because of a syntax error and the user meant to provide/// an `A`, or that the `A`s are finished and its time to start parsing/// `B`s. Use with care./// Also note that if `A` is a subset of `B`, `A* B*` can be parsed by/// parsing `B*` and removing the leading members of `A` from the/// repetition, bypassing the need to involve the downsides associated with/// speculative parsing./// [`ParseStream::fork`]: ParseBuffer::fork/// There has been chatter about the possibility of making the colons in the/// turbofish syntax like `path::to::<T>` no longer required by accepting/// `path::to<T>` in expression position. Specifically, according to [RFC/// 2544], [`PathSegment`] parsing should always try to consume a following/// `<` token as the start of generic arguments, and reset to the `<` if/// that fails (e.g. the token is acting as a less-than operator)./// This is the exact kind of parsing behavior which requires the "fork,/// try, commit" behavior that [`ParseStream::fork`] discourages. With/// `advance_to`, we can avoid having to parse the speculatively parsed/// content a second time./// This change in behavior can be implemented in syn by replacing just the/// `Parse` implementation for `PathSegment`:/// # use syn::ext::IdentExt;/// use syn::parse::discouraged::Speculative;/// # use syn::parse::{Parse, ParseStream};/// # use syn::{Ident, PathArguments, Result, Token};/// pub struct PathSegment {///     pub ident: Ident,///     pub arguments: PathArguments,/// # impl<T> From<T> for PathSegment/// #     T: Into<Ident>,/// #     fn from(ident: T) -> Self {/// #         PathSegment {/// #             ident: ident.into(),/// #             arguments: PathArguments::None,/// impl Parse for PathSegment {///         if input.peek(Token![super])///             || input.peek(Token![self])///             || input.peek(Token![Self])///             || input.peek(Token![crate])///             || input.peek(Token![extern])///             let ident = input.call(Ident::parse_any)?;///             return Ok(PathSegment::from(ident));///         let ident = input.parse()?;///         if input.peek(Token![::]) && input.peek3(Token![<]) {///             return Ok(PathSegment {///                 ident: ident,///                 arguments: PathArguments::AngleBracketed(input.parse()?),///         if input.peek(Token![<]) && !input.peek(Token![<=]) {///             let fork = input.fork();///             if let Ok(arguments) = fork.parse() {///                 input.advance_to(&fork);///                 return Ok(PathSegment {///                     ident: ident,///                     arguments: PathArguments::AngleBracketed(arguments),///                 });///         Ok(PathSegment::from(ident))/// # syn::parse_str::<PathSegment>("a<b,c>").unwrap();/// # Drawbacks/// The main drawback of this style of speculative parsing is in error/// presentation. Even if the lookahead is the "correct" parse, the error/// that is shown is that of the "fallback" parse. To use the same example/// as the turbofish above, take the following unfinished "turbofish":/// let _ = f<&'a fn(), for<'a> serde::>();/// If this is parsed as generic arguments, we can provide the error message/// error: expected identifier///  --> src.rs:L:C/// L | let _ = f<&'a fn(), for<'a> serde::>();///   |                                    ^/// but if parsed using the above speculative parsing, it falls back to/// assuming that the `<` is a less-than when it fails to parse the generic/// arguments, and tries to interpret the `&'a` as the start of a labelled/// loop, resulting in the much less helpful error/// error: expected `:`///   |               ^^/// This can be mitigated with various heuristics (two examples: show both/// forks' parse errors, or show the one that consumed more tokens), but/// when you can control the grammar, sticking to something that can be/// parsed LL(3) and without the LL(*) speculative parsing this makes/// possible, displaying reasonable errors becomes much more simple./// [RFC 2544]: https://github.com/rust-lang/rfcs/pull/2544/// [`PathSegment`]: crate::PathSegment/// This method performs a cheap fixed amount of work that does not depend/// on how far apart the two streams are positioned./// The forked stream in the argument of `advance_to` must have been/// obtained by forking `self`. Attempting to advance to any other stream/// will cause a panic.Speculative/// Extensions to the `ParseStream` API to support speculative parsing.//! Extensions to the parsing API with niche applicability.ThreadBound/// The result of a Syn parser.// Span is implemented as an index into a thread-local interner to keep the// size small. It is not safe to access from a different thread. We want// errors to be Send and Sync to play nicely with the Failure crate, so pin// the span we're given to its original thread and assume it is// Span::call_site if accessed from any other thread./// Error returned when a Syn parser cannot parse the input tokens./// Refer to the [module documentation] for details about parsing in Syn.// TODO: change the parse module link to an intra rustdoc link, currently// blocked on https://github.com/rust-lang/rust/issues/62830_Test/// Usually the [`ParseStream::error`] method will be used instead, which/// automatically uses the correct span from the current position of the/// parse stream./// Use `Error::new` when the error needs to be triggered on some span other/// than where the parse stream is currently positioned./// [`ParseStream::error`]: crate::parse::ParseBuffer::error/// use syn::{Error, Ident, LitStr, Result, Token};/// use syn::parse::ParseStream;/// // Parses input that looks like `name = "string"` where the key must be/// // the identifier `name` and the value may be any string literal./// // Returns the string literal./// fn parse_name(input: ParseStream) -> Result<LitStr> {///     let name_token: Ident = input.parse()?;///     if name_token != "name" {///         // Trigger an error not on the current position of the stream,///         // but on the position of the unexpected identifier.///         return Err(Error::new(name_token.span(), "expected `name`"));///     input.parse::<Token![=]>()?;///     let s: LitStr = input.parse()?;new_spanned/// Creates an error with the specified message spanning the given syntax/// tree node./// Unlike the `Error::new` constructor, this constructor takes an argument/// `tokens` which is a syntax tree node. This allows the resulting `Error`/// to attempt to span all tokens inside of `tokens`. While you would/// typically be able to use the `Spanned` trait with the above `Error::new`/// constructor, implementation limitations today mean that/// `Error::new_spanned` may provide a higher-quality error message on/// stable Rust./// When in doubt it's recommended to stick to `Error::new` (or/// `ParseStream::error`)!/// The source location of the error./// Spans are not thread-safe so this function returns `Span::call_site()`/// if called from a different thread than the one on which the `Error` was/// originally created./// Render the error as an invocation of [`compile_error!`]./// The [`parse_macro_input!`] macro provides a convenient way to invoke/// this method correctly in a procedural macro./// [`compile_error!`]: https://doc.rust-lang.org/std/macro.compile_error.htmlnew_atr" A Rust expression."r" # Syntax tree enums"r" This type is a syntax tree enum. In Syn this and other syntax tree enums"r" are designed to be traversed using the following rebinding idiom."r" # use syn::Expr;"r" # fn example(expr: Expr) {"r" let expr: Expr = /* ... */;"r" match expr {"r"     Expr::MethodCall(expr) => {"r"         /* ... */"r"     Expr::Cast(expr) => {"r"     Expr::If(expr) => {"r"     /* ... */"r"     # _ => {}"r" We begin with a variable `expr` of type `Expr` that has no fields"r" (because it is an enum), and by matching on it and rebinding a variable"r" with the same name `expr` we effectively imbue our variable with all of"r" the data fields provided by the variant that it turned out to be. So for"r" example above if we ended up in the `MethodCall` case then we get to use"r" `expr.receiver`, `expr.args` etc; if we ended up in the `If` case we get"r" to use `expr.cond`, `expr.then_branch`, `expr.else_branch`."r" This approach avoids repeating the variant names twice on every line."r" # use syn::{Expr, ExprMethodCall};"r" // Repetitive; recommend not doing this."r"     Expr::MethodCall(ExprMethodCall { method, args, .. }) => {"r" # _ => {}"r" In general, the name to which a syntax tree enum variant is bound should"r" be a suitable name for the complete syntax tree enum type."r" # use syn::{Expr, ExprField};"r" # fn example(discriminant: ExprField) {"r" // Binding is called `base` which is the name I would use if I were"r" // assigning `*discriminant.base` without an `if let`."r" if let Expr::Tuple(base) = *discriminant.base {"r" A sign that you may not be choosing the right variable names is if you"r" see names getting repeated in your code, like accessing"r" `receiver.receiver` or `pat.pat` or `cond.cond`."r" A box expression: `box f`."r#" *This type is available if Syn is built with the `"full"` feature.*"#ExprBoxr" A placement expression: `place <- value`."ExprInPlaceInPlacer" A slice literal expression: `[a, b, c, d]`."r" A function call expression: `invoke(a, b)`."r" A method call expression: `x.foo::<T>(a, b)`."r" A tuple expression: `(a, b, c, d)`."r" A binary operation: `a + b`, `a * b`."r" A unary operation: `!x`, `*x`."r#" A literal in place of an expression: `1`, `"foo"`."#r" A cast expression: `foo as f64`."r" A type ascription expression: `foo: f64`."ExprTyper" A `let` guard: `let Some(x) = opt`."Letr" An `if` expression with an optional `else` block: `if expr { ... }"r" else { ... }`."r" The `else` branch expression may only be an `If` or `Block`"r" expression, not any of the other types of expression."r" A while loop: `while expr { ... }`."Whiler" A for loop: `for pat in expr { ... }`."ForLoopr" Conditionless loop: `loop { ... }`."r" A `match` expression: `match n { Some(n) => {}, None => {} }`."r" A closure expression: `|a, b| a + b`."r" An unsafe block: `unsafe { ... }`."r" A blocked scope: `{ ... }`."r" An assignment expression: `a = compute()`."r" A compound assignment expression: `counter += 1`."ExprAssignOpAssignOpr" Access of a named struct field (`obj.k`) or unnamed tuple struct"r" field (`obj.0`)."r" A square bracketed indexing expression: `vector[2]`."r" A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`."r" A path like `std::mem::replace` possibly containing generic"r" parameters and a qualified self-type."r" A plain identifier like `x` is a path of length 1."r" A referencing operation: `&a` or `&mut a`."r" A `break`, with an optional label to break and an optional"r" expression."r" A `continue`, with an optional label."r" A `return`, with an optional value to be returned."r#" A macro invocation expression: `format!("{}", q)`."#r" A struct literal expression: `Point { x: 1, y: 1 }`."r" The `rest` provides the value of the remaining fields as in `S { a:"r" 1, b: 1, ..rest }`."r" An array literal constructed from one repeated element: `[0u8; N]`."r" A parenthesized expression: `(a + b)`."r" An expression contained within invisible delimiters."r" This variant is important for faithfully representing the precedence"r" of expressions and is related to `None`-delimited spans in a"r" `TokenStream`."r" A try-expression: `expr?`."r" An async block: `async { ... }`."r" A try block: `try { ... }`."TryBlockr" A yield expression: `yield expr`."r" Tokens in expression position not interpreted by Syn."ExprVerbatim_noconstructas_tokendot_tokenqselfr" A struct or tuple struct field accessed in a struct literal or field"r" A named field like `self.x`."r" An unnamed field like `self.0`."r" The index of an unnamed tuple struct field."AllowStruct// When we're parsing expressions which occur before blocks, like in an if// statement's condition, we cannot parse a struct literal.// Struct literals are ambiguous in certain positions// https://github.com/rust-lang/rfcs/pull/92Precedencepeek_precedenceambiguous_expr// Parse an arbitrary expression.unary_exprtrailer_expratom_exprimpl_by_parsing_exprouter_attrs_to_tokensinner_attrs_to_tokens/// Parses any identifier including keywords./// This is useful when parsing macro input which allows Rust keywords as/// use syn::{Error, Ident, Result, Token};/// use syn::ext::IdentExt;///     syn::custom_keyword!(name);/// // Parses input that looks like `name = NAME` where `NAME` can be/// // any identifier./// // Examples:/// //     name = anything/// //     name = impl/// fn parse_dsl(input: ParseStream) -> Result<Ident> {///     input.parse::<kw::name>()?;///     let name = input.call(Ident::parse_any)?;///     Ok(name)peek_anyPeekFn/// Peeks any identifier including keywords. Usage:/// `input.peek(Ident::peek_any)`/// This is different from `input.peek(Ident)` which only returns true in/// the case of an ident which is not a Rust keyword./// Strips the raw marker `r#`, if any, from the beginning of an ident.///   - unraw(`x`) = `x`///   - unraw(`move`) = `move`///   - unraw(`r#move`) = `move`/// In the case of interop with other languages like Python that have a/// different set of keywords than Rust, we might come across macro input/// that involves raw identifiers to refer to ordinary variables in the/// other language with a name that happens to be a Rust keyword./// The function below appends an identifier from the caller's input onto a/// fixed prefix. Without using `unraw()`, this would tend to produce/// invalid identifiers like `__pyo3_get_r#move`./// use proc_macro2::Span;/// use syn::Ident;/// fn ident_for_getter(variable: &Ident) -> Ident {///     let getter = format!("__pyo3_get_{}", variable.unraw());///     Ident::new(&getter, Span::call_site())/// Additional methods for `Ident` not provided by proc-macro2 or libproc_macro./// This trait is sealed and cannot be implemented for types outside of Syn. It/// is implemented only for `proc_macro2::Ident`./// *This trait is available if Syn is built with the `"parsing"` feature.*IdentAny//! Extension traits to provide parsing methods on foreign types.fold_abifold_angle_bracketed_generic_argumentsfold_arg_capturedArgCapturedfold_arg_selfArgSelffold_arg_self_refArgSelfReffold_armfold_attr_stylefold_attributefold_bare_fn_argfold_bare_fn_arg_nameBareFnArgNamefold_bin_opfold_bindingfold_blockfold_bound_lifetimesfold_const_paramfold_constraintfold_datafold_data_enumfold_data_structfold_data_unionfold_derive_inputfold_expr_arrayfold_expr_assignfold_expr_assign_opfold_expr_asyncfold_expr_binaryfold_expr_blockfold_expr_boxfold_expr_breakfold_expr_callfold_expr_castfold_expr_closurefold_expr_continuefold_expr_fieldfold_expr_for_loopfold_expr_groupfold_expr_iffold_expr_in_placefold_expr_indexfold_expr_letfold_expr_litfold_expr_loopfold_expr_macrofold_expr_matchfold_expr_method_callfold_expr_parenfold_expr_pathfold_expr_rangefold_expr_referencefold_expr_repeatfold_expr_returnfold_expr_structfold_expr_tryfold_expr_try_blockfold_expr_tuplefold_expr_typefold_expr_unaryfold_expr_unsafefold_expr_verbatimfold_expr_whilefold_expr_yieldfold_fieldfold_field_patfold_field_valuefold_fieldsfold_fields_namedfold_fields_unnamedfold_filefold_fn_argfold_fn_declFnDeclfold_foreign_itemfold_foreign_item_fnfold_foreign_item_macrofold_foreign_item_staticfold_foreign_item_typefold_foreign_item_verbatimForeignItemVerbatimfold_generic_argumentfold_generic_method_argumentGenericMethodArgumentfold_generic_paramfold_genericsfold_impl_itemfold_impl_item_constfold_impl_item_existentialImplItemExistentialfold_impl_item_macrofold_impl_item_methodImplItemMethodfold_impl_item_typefold_impl_item_verbatimImplItemVerbatimfold_indexfold_itemfold_item_constfold_item_enumfold_item_existentialItemExistentialfold_item_extern_cratefold_item_fnfold_item_foreign_modfold_item_implfold_item_macrofold_item_macro2ItemMacro2fold_item_modfold_item_staticfold_item_structfold_item_traitfold_item_trait_aliasfold_item_typefold_item_unionfold_item_usefold_item_verbatimItemVerbatimfold_labelfold_lifetimefold_lifetime_defLifetimeDeffold_litfold_lit_boolfold_lit_bytefold_lit_byte_strfold_lit_charfold_lit_floatfold_lit_intfold_lit_strfold_lit_verbatimLitVerbatimfold_localfold_macrofold_macro_delimiterfold_memberfold_metafold_meta_listfold_meta_name_valuefold_method_sigMethodSigfold_method_turbofishMethodTurbofishfold_nested_metafold_parenthesized_generic_argumentsfold_patfold_pat_boxPatBoxfold_pat_identfold_pat_litPatLitfold_pat_macroPatMacrofold_pat_pathPatPathfold_pat_rangePatRangefold_pat_refPatReffold_pat_slicefold_pat_structfold_pat_tuplefold_pat_tuple_structfold_pat_verbatimPatVerbatimfold_pat_wildfold_pathfold_path_argumentsfold_path_segmentfold_predicate_eqPredicateEqfold_predicate_lifetimefold_predicate_typefold_qselffold_range_limitsfold_return_typefold_stmtfold_trait_boundfold_trait_bound_modifierfold_trait_itemfold_trait_item_constfold_trait_item_macrofold_trait_item_methodTraitItemMethodfold_trait_item_typefold_trait_item_verbatimTraitItemVerbatimfold_typefold_type_arrayfold_type_bare_fnfold_type_groupfold_type_impl_traitfold_type_inferfold_type_macrofold_type_neverfold_type_paramfold_type_param_boundfold_type_parenfold_type_pathfold_type_ptrfold_type_referencefold_type_slicefold_type_trait_objectfold_type_tuplefold_type_verbatimTypeVerbatimfold_un_opfold_use_globfold_use_groupfold_use_namefold_use_pathfold_use_renamefold_use_treefold_variantfold_vis_cratefold_vis_publicfold_vis_restrictedfold_visibilityfold_where_clausefold_where_predicatefold_spanfold_ident/// Syntax tree traversal to transform the nodes of an owned syntax tree./// See the [module documentation] for details./// [module documentation]: self/// *This trait is available if Syn is built with the `"fold"` feature.*// This file is @generated by syn-internal-codegen.visit_abi'astvisit_angle_bracketed_generic_argumentsvisit_arg_capturedvisit_arg_selfvisit_arg_self_refvisit_armvisit_attr_stylevisit_attributevisit_bare_fn_argvisit_bare_fn_arg_namevisit_bin_opvisit_bindingvisit_blockvisit_bound_lifetimesvisit_const_paramvisit_constraintvisit_datavisit_data_enumvisit_data_structvisit_data_unionvisit_derive_inputvisit_exprvisit_expr_arrayvisit_expr_assignvisit_expr_assign_opvisit_expr_asyncvisit_expr_binaryvisit_expr_blockvisit_expr_boxvisit_expr_breakvisit_expr_callvisit_expr_castvisit_expr_closurevisit_expr_continuevisit_expr_fieldvisit_expr_for_loopvisit_expr_groupvisit_expr_ifvisit_expr_in_placevisit_expr_indexvisit_expr_letvisit_expr_litvisit_expr_loopvisit_expr_macrovisit_expr_matchvisit_expr_method_callvisit_expr_parenvisit_expr_pathvisit_expr_rangevisit_expr_referencevisit_expr_repeatvisit_expr_returnvisit_expr_structvisit_expr_tryvisit_expr_try_blockvisit_expr_tuplevisit_expr_typevisit_expr_unaryvisit_expr_unsafevisit_expr_verbatimvisit_expr_whilevisit_expr_yieldvisit_fieldvisit_field_patvisit_field_valuevisit_fields_namedvisit_fields_unnamedvisit_filevisit_fn_argvisit_fn_declvisit_foreign_itemvisit_foreign_item_fnvisit_foreign_item_macrovisit_foreign_item_staticvisit_foreign_item_typevisit_foreign_item_verbatimvisit_generic_argumentvisit_generic_method_argumentvisit_generic_paramvisit_genericsvisit_impl_itemvisit_impl_item_constvisit_impl_item_existentialvisit_impl_item_macrovisit_impl_item_methodvisit_impl_item_typevisit_impl_item_verbatimvisit_indexvisit_item_constvisit_item_enumvisit_item_existentialvisit_item_extern_cratevisit_item_fnvisit_item_foreign_modvisit_item_macrovisit_item_macro2visit_item_modvisit_item_staticvisit_item_structvisit_item_trait_aliasvisit_item_typevisit_item_unionvisit_item_usevisit_item_verbatimvisit_labelvisit_lifetime_defvisit_litvisit_lit_boolvisit_lit_bytevisit_lit_byte_strvisit_lit_charvisit_lit_floatvisit_lit_intvisit_lit_strvisit_lit_verbatimvisit_localvisit_macrovisit_macro_delimitervisit_membervisit_metavisit_meta_listvisit_meta_name_valuevisit_method_sigvisit_method_turbofishvisit_nested_metavisit_parenthesized_generic_argumentsvisit_patvisit_pat_boxvisit_pat_identvisit_pat_litvisit_pat_macrovisit_pat_pathvisit_pat_rangevisit_pat_refvisit_pat_slicevisit_pat_structvisit_pat_tuplevisit_pat_tuple_structvisit_pat_verbatimvisit_pat_wildvisit_pathvisit_path_argumentsvisit_path_segmentvisit_predicate_eqvisit_predicate_lifetimevisit_predicate_typevisit_qselfvisit_range_limitsvisit_return_typevisit_stmtvisit_trait_boundvisit_trait_bound_modifiervisit_trait_itemvisit_trait_item_constvisit_trait_item_macrovisit_trait_item_methodvisit_trait_item_typevisit_trait_item_verbatimvisit_typevisit_type_arrayvisit_type_bare_fnvisit_type_groupvisit_type_impl_traitvisit_type_infervisit_type_macrovisit_type_nevervisit_type_paramvisit_type_param_boundvisit_type_parenvisit_type_pathvisit_type_ptrvisit_type_referencevisit_type_slicevisit_type_trait_objectvisit_type_tuplevisit_type_verbatimvisit_un_opvisit_use_globvisit_use_groupvisit_use_namevisit_use_pathvisit_use_renamevisit_use_treevisit_vis_cratevisit_vis_publicvisit_vis_restrictedvisit_visibilityvisit_where_clausevisit_where_predicatevisit_spanvisit_ident/// Syntax tree traversal to walk a shared borrow of a syntax tree./// *This trait is available if Syn is built with the `"visit"` feature.*visit_abi_mutvisit_angle_bracketed_generic_arguments_mutvisit_arg_captured_mutvisit_arg_self_mutvisit_arg_self_ref_mutvisit_arm_mutvisit_attr_style_mutvisit_attribute_mutvisit_bare_fn_arg_mutvisit_bare_fn_arg_name_mutvisit_bin_op_mutvisit_binding_mutvisit_block_mutvisit_bound_lifetimes_mutvisit_const_param_mutvisit_constraint_mutvisit_data_enum_mutvisit_data_struct_mutvisit_data_union_mutvisit_derive_input_mutvisit_expr_array_mutvisit_expr_assign_mutvisit_expr_assign_op_mutvisit_expr_async_mutvisit_expr_binary_mutvisit_expr_block_mutvisit_expr_box_mutvisit_expr_break_mutvisit_expr_call_mutvisit_expr_cast_mutvisit_expr_closure_mutvisit_expr_continue_mutvisit_expr_field_mutvisit_expr_for_loop_mutvisit_expr_group_mutvisit_expr_if_mutvisit_expr_in_place_mutvisit_expr_index_mutvisit_expr_let_mutvisit_expr_lit_mutvisit_expr_loop_mutvisit_expr_macro_mutvisit_expr_match_mutvisit_expr_method_call_mutvisit_expr_paren_mutvisit_expr_range_mutvisit_expr_reference_mutvisit_expr_repeat_mutvisit_expr_return_mutvisit_expr_try_mutvisit_expr_try_block_mutvisit_expr_tuple_mutvisit_expr_type_mutvisit_expr_unary_mutvisit_expr_unsafe_mutvisit_expr_verbatim_mutvisit_expr_while_mutvisit_expr_yield_mutvisit_field_mutvisit_field_pat_mutvisit_field_value_mutvisit_fields_mutvisit_fields_named_mutvisit_fields_unnamed_mutvisit_fn_arg_mutvisit_fn_decl_mutvisit_foreign_item_mutvisit_foreign_item_fn_mutvisit_foreign_item_macro_mutvisit_foreign_item_static_mutvisit_foreign_item_type_mutvisit_foreign_item_verbatim_mutvisit_generic_method_argument_mutvisit_generic_param_mutvisit_impl_item_mutvisit_impl_item_const_mutvisit_impl_item_existential_mutvisit_impl_item_macro_mutvisit_impl_item_method_mutvisit_impl_item_type_mutvisit_impl_item_verbatim_mutvisit_index_mutvisit_item_const_mutvisit_item_enum_mutvisit_item_existential_mutvisit_item_extern_crate_mutvisit_item_fn_mutvisit_item_foreign_mod_mutvisit_item_impl_mutvisit_item_macro_mutvisit_item_macro2_mutvisit_item_static_mutvisit_item_struct_mutvisit_item_trait_alias_mutvisit_item_type_mutvisit_item_union_mutvisit_item_use_mutvisit_item_verbatim_mutvisit_label_mutvisit_lifetime_mutvisit_lifetime_def_mutvisit_lit_mutvisit_lit_bool_mutvisit_lit_byte_mutvisit_lit_byte_str_mutvisit_lit_char_mutvisit_lit_float_mutvisit_lit_int_mutvisit_lit_str_mutvisit_lit_verbatim_mutvisit_local_mutvisit_macro_delimiter_mutvisit_member_mutvisit_meta_mutvisit_meta_list_mutvisit_meta_name_value_mutvisit_method_sig_mutvisit_method_turbofish_mutvisit_nested_meta_mutvisit_parenthesized_generic_arguments_mutvisit_pat_mutvisit_pat_box_mutvisit_pat_lit_mutvisit_pat_macro_mutvisit_pat_path_mutvisit_pat_range_mutvisit_pat_ref_mutvisit_pat_slice_mutvisit_pat_tuple_mutvisit_pat_verbatim_mutvisit_pat_wild_mutvisit_path_segment_mutvisit_predicate_eq_mutvisit_predicate_lifetime_mutvisit_predicate_type_mutvisit_qself_mutvisit_range_limits_mutvisit_stmt_mutvisit_trait_bound_mutvisit_trait_bound_modifier_mutvisit_trait_item_mutvisit_trait_item_const_mutvisit_trait_item_macro_mutvisit_trait_item_method_mutvisit_trait_item_type_mutvisit_trait_item_verbatim_mutvisit_type_array_mutvisit_type_group_mutvisit_type_infer_mutvisit_type_macro_mutvisit_type_never_mutvisit_type_param_mutvisit_type_paren_mutvisit_type_slice_mutvisit_type_trait_object_mutvisit_type_tuple_mutvisit_type_verbatim_mutvisit_un_op_mutvisit_use_glob_mutvisit_use_group_mutvisit_use_name_mutvisit_use_path_mutvisit_use_rename_mutvisit_use_tree_mutvisit_variant_mutvisit_vis_crate_mutvisit_vis_public_mutvisit_vis_restricted_mutvisit_visibility_mutvisit_where_clause_mutvisit_where_predicate_mutvisit_span_mut/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in/// *This trait is available if Syn is built with the `"visit-mut"` feature.*r" Lifetimes and type parameters attached to a declaration of a function,"r" enum, trait, etc."lt_tokengt_tokenr" A generic type parameter, lifetime, or const generic: `T: Into<String>`,"r" `'a: 'b`, `const LEN: usize`."r" A generic type parameter: `T: Into<String>`."r" A lifetime definition: `'a: 'b + 'c + 'd`."r" A const generic parameter: `const LENGTH: usize`."const_tokenTypeParams/// Returns an/// <code///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a///   href="struct.TypeParam.html"><code///   style="padding-left:0;padding-right:0;">TypeParam</code></a><code///   style="padding-left:0;">&gt;</code>/// over the type parameters in `self.params`.type_params_mutTypeParamsMut///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><aLifetimes///   href="struct.LifetimeDef.html"><code///   style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code/// over the lifetime parameters in `self.params`.lifetimes_mutLifetimesMutconst_paramsConstParams///   href="struct.ConstParam.html"><code///   style="padding-left:0;padding-right:0;">ConstParam</code></a><code/// over the constant parameters in `self.params`.const_params_mutConstParamsMutmake_where_clause/// Initializes an empty `where`-clause if there is not one present already./// Returned by `Generics::split_for_impl`./// *This type is available if Syn is built with the `"derive"` or `"full"`/// feature and the `"printing"` feature.*Turbofish/// Returned by `TypeGenerics::as_turbofish`.split_for_impl/// Split a type's generics into the pieces required for impl'ing a trait/// for that type./// # use proc_macro2::{Span, Ident};/// #     let generics: syn::Generics = Default::default();/// #     let name = Ident::new("MyType", Span::call_site());/// let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();///     impl #impl_generics MyTrait for #name #ty_generics #where_clause {/// #     ;/// *This method is available if Syn is built with the `"derive"` or/// `"full"` feature and the `"printing"` feature.*as_turbofish/// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`.r" A set of bound lifetimes: `for<'a, 'b, 'c>`."for_tokenForr" A trait or lifetime used as a bound on a type parameter."r" A trait used as a bound on a type parameter."r" The `for<'a>` in `for<'a> Foo<&'a T>`"r" The `Foo<&'a T>` in `for<'a> Foo<&'a T>`"r" A modifier on a trait bound, currently only used for the `?` in"r" `?Sized`."r" A `where` clause in a definition: `where T: Deserialize<'de>, D:"r" 'static`."where_tokenr" A single predicate in a `where` clause: `T: Deserialize<'de>`."r" A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`."r" A lifetime predicate in a `where` clause: `'a: 'b + 'c`."r" An equality predicate in a `where` clause (unsupported)."r" Any lifetimes from a `for` binding"r" The type being bounded"bounded_tyr" Trait and lifetime bounds (`Clone+Send+'static`)"lhs_tyrhs_tyParensBracesBracketsparse_parensparse_bracesparse_bracketsparse_delimited/// Parse a set of parentheses and expose their content to subsequent parsers./// use syn::{parenthesized, token, Ident, Result, Token, Type};/// // Parse a simplified tuple struct syntax like:/// //     struct S(A, B);/// struct TupleStruct {///     struct_token: Token![struct],///     ident: Ident,///     paren_token: token::Paren,///     fields: Punctuated<Type, Token![,]>,///     semi_token: Token![;],/// impl Parse for TupleStruct {///         let content;///         Ok(TupleStruct {///             struct_token: input.parse()?,///             ident: input.parse()?,///             paren_token: parenthesized!(content in input),///             fields: content.parse_terminated(Type::parse)?,///             semi_token: input.parse()?,/// #     let input = quote! {/// #         struct S(A, B);/// #     };/// #     syn::parse2::<TupleStruct>(input).unwrap();braced/// Parse a set of curly braces and expose their content to subsequent parsers./// use syn::{braced, token, Ident, Result, Token, Type};/// // Parse a simplified struct syntax like:/// //     struct S {/// //         a: A,/// //         b: B,/// //     }/// struct Struct {///     brace_token: token::Brace,///     fields: Punctuated<Field, Token![,]>,/// struct Field {///     name: Ident,///     colon_token: Token![:],///     ty: Type,/// impl Parse for Struct {///         Ok(Struct {///             brace_token: braced!(content in input),///             fields: content.parse_terminated(Field::parse)?,/// impl Parse for Field {///         Ok(Field {///             name: input.parse()?,///             colon_token: input.parse()?,///             ty: input.parse()?,/// #         struct S {/// #             a: A,/// #             b: B,/// #     syn::parse2::<Struct>(input).unwrap();/// Parse a set of square brackets and expose their content to subsequent/// parsers./// use proc_macro2::TokenStream;/// use syn::{bracketed, token, Result, Token};/// // Parse an outer attribute like:/// //     #[repr(C, packed)]/// struct OuterAttribute {///     pound_token: Token![#],///     bracket_token: token::Bracket,///     content: TokenStream,/// impl Parse for OuterAttribute {///         Ok(OuterAttribute {///             pound_token: input.parse()?,///             bracket_token: bracketed!(content in input),///             content: content.parse()?,/// #         #[repr(C, packed)]/// #     syn::parse2::<OuterAttribute>(input).unwrap();TokenMarkeraccept_as_identident_from_tokenSelfValueUnderscorepeek_any_identTokenStreamHelper// TODO: figure out the actual grammar; is body required to be braced?arg_self_refarg_selfarg_capturedparse_trait_or_trait_aliasparse_rest_of_traitparse_start_of_trait_aliasparse_rest_of_trait_aliasis_inheritedis_braceNamedDeclFloatSuffixIntSuffixStrStyle// Not public API except the `parse_quote!` macro.// Not public API except the `parse_macro_input!` macro."../gen_helper.rs"/// Parse tokens of source code into the chosen syntax tree node./// This is preferred over parsing a string because tokens are able to preserve/// information about where in the user's code they were originally written (the/// "span" of the token), possibly allowing the compiler to produce better error/// This function parses a `proc_macro::TokenStream` which is the type used for/// interop with the compiler in a procedural macro. To parse a/// `proc_macro2::TokenStream`, use [`syn::parse2`] instead./// [`syn::parse2`]: parse2/// *This function is available if Syn is built with both the `"parsing"` and/// use syn::DeriveInput;/// # const IGNORE_TOKENS: &str = stringify! {/// #[proc_macro_derive(MyMacro)]/// pub fn my_macro(input: TokenStream) -> TokenStream {///     // Parse the tokens into a syntax tree///     let ast: DeriveInput = syn::parse(input).unwrap();///     // Build the output, possibly using quasi-quotation///     // Convert into a token stream and return it///     expanded.into()/// Parse a proc-macro2 token stream into the chosen syntax tree node./// This function parses a `proc_macro2::TokenStream` which is commonly useful/// when the input comes from a node of the Syn syntax tree, for example the tts/// of a [`Macro`] node. When in a procedural macro parsing the/// `proc_macro::TokenStream` provided by the compiler, use [`syn::parse`]/// [`syn::parse`]: parse()/// *This function is available if Syn is built with the `"parsing"` feature.*/// Parse a string of Rust code into the chosen syntax tree node./// Every span in the resulting syntax tree will be set to resolve at the macro/// use syn::{Expr, Result};/// fn run() -> Result<()> {///     let code = "assert_eq!(u8::max_value(), 255)";///     let expr = syn::parse_str::<Expr>(code)?;///     println!("{:#?}", expr);/// #     run().unwrap();//! Syn is a parsing library for parsing a stream of Rust tokens into a syntax//! tree of Rust source code.//! Currently this library is geared toward use in Rust procedural macros, but//! contains some APIs that may be useful more generally.//! - **Data structures** — Syn provides a complete syntax tree that can//!   represent any valid Rust source code. The syntax tree is rooted at//!   [`syn::File`] which represents a full source file, but there are other//!   entry points that may be useful to procedural macros including//!   [`syn::Item`], [`syn::Expr`] and [`syn::Type`].//! - **Custom derives** — Of particular interest to custom derives is//!   [`syn::DeriveInput`] which is any of the three legal input items to a//!   derive macro. An example below shows using this type in a library that can//!   derive implementations of a trait of your own.//! - **Parsing** — Parsing in Syn is built around [parser functions] with the//!   signature `fn(ParseStream) -> Result<T>`. Every syntax tree node defined//!   by Syn is individually parsable and may be used as a building block for//!   custom syntaxes, or you may dream up your own brand new syntax without//!   involving any of our syntax tree types.//! - **Location information** — Every token parsed by Syn is associated with a//!   `Span` that tracks line and column information back to the source of that//!   token. These spans allow a procedural macro to display detailed error//!   messages pointing to all the right places in the user's code. There is an//!   example of this below.//! - **Feature flags** — Functionality is aggressively feature gated so your//!   procedural macros enable only what they need, and do not pay in compile//!   time for all the rest.//! [`syn::File`]: struct.File.html//! [`syn::Item`]: enum.Item.html//! [`syn::Expr`]: enum.Expr.html//! [`syn::Type`]: enum.Type.html//! [`syn::DeriveInput`]: struct.DeriveInput.html//! [parser functions]: parse/index.html//! *Version requirement: Syn supports any compiler version back to Rust's very//! first support for procedural macros in Rust 1.15.0. Some features especially//! around error reporting are only available in newer compilers or on the//! nightly channel.*//! ## Example of a custom derive//! The canonical custom derive using Syn looks like this. We write an ordinary//! Rust function tagged with a `proc_macro_derive` attribute and the name of//! the trait we are deriving. Any time that derive appears in the user's code,//! the Rust compiler passes their data structure as tokens into our macro. We//! get to execute arbitrary Rust code to figure out what to do with those//! tokens, then hand some tokens back to the compiler to compile into the//! user's crate.//! [`TokenStream`]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html//! syn = "0.15"//! [lib]//! proc-macro = true//! use quote::quote;//! use syn::{parse_macro_input, DeriveInput};//! # const IGNORE_TOKENS: &str = stringify! {//! #[proc_macro_derive(MyMacro)]//! pub fn my_macro(input: TokenStream) -> TokenStream {//!     // Parse the input tokens into a syntax tree//!     let input = parse_macro_input!(input as DeriveInput);//!     // Build the output, possibly using quasi-quotation//!     let expanded = quote! {//!         // ...//!     // Hand the output tokens back to the compiler//!     TokenStream::from(expanded)//! The [`heapsize`] example directory shows a complete working Macros 1.1//! implementation of a custom derive. It works on any Rust compiler 1.15+.//! The example derives a `HeapSize` trait which computes an estimate of the//! amount of heap memory owned by a value.//! [`heapsize`]: https://github.com/dtolnay/syn/tree/master/examples/heapsize//! pub trait HeapSize {//!     /// Total number of bytes of heap memory owned by `self`.//!     fn heap_size_of_children(&self) -> usize;//! The custom derive allows users to write `#[derive(HeapSize)]` on data//! structures in their program.//! #[derive(HeapSize)]//! struct Demo<'a, T: ?Sized> {//!     a: Box<T>,//!     b: u8,//!     c: &'a str,//!     d: String,//! ## Spans and error reporting//! The token-based procedural macro API provides great control over where the//! compiler's error messages are displayed in user code. Consider the error the//! user sees if one of their field types does not implement `HeapSize`.//! struct Broken {//!     ok: String,//!     bad: std::thread::Thread,//! By tracking span information all the way through the expansion of a//! procedural macro as shown in the `heapsize` example, token-based macros in//! Syn are able to trigger errors that directly pinpoint the source of the//! error[E0277]: the trait bound `std::thread::Thread: HeapSize` is not satisfied//!  --> src/main.rs:7:5//! 7 |     bad: std::thread::Thread,//!   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `HeapSize` is not implemented for `Thread`//! ## Parsing a custom syntax//! The [`lazy-static`] example directory shows the implementation of a//! `functionlike!(...)` procedural macro in which the input tokens are parsed//! using Syn's parsing API.//! [`lazy-static`]: https://github.com/dtolnay/syn/tree/master/examples/lazy-static//! The example reimplements the popular `lazy_static` crate from crates.io as a//! procedural macro.//! # macro_rules! lazy_static {//! #     ($($tt:tt)*) => {}//! lazy_static! {//!     static ref USERNAME: Regex = Regex::new("^[a-z0-9_-]{3,16}$").unwrap();//! The implementation shows how to trigger custom warnings and error messages//! on the macro input.//! warning: come on, pick a more creative name//!   --> src/main.rs:10:16//! 10 |     static ref FOO: String = "lazy_static".to_owned();//!    |                ^^^//! When testing macros, we often care not just that the macro can be used//! successfully but also that when the macro is provided with invalid input it//! produces maximally helpful error messages. Consider using the [`trybuild`]//! crate to write tests for errors that are emitted by your macro or errors//! detected by the Rust compiler in the expanded code following misuse of the//! macro. Such tests help avoid regressions from later refactors that//! mistakenly make an error no longer trigger or be less helpful than it used//! to be.//! [`trybuild`]: https://github.com/dtolnay/trybuild//! ## Debugging//! When developing a procedural macro it can be helpful to look at what the//! generated code looks like. Use `cargo rustc -- -Zunstable-options//! --pretty=expanded` or the [`cargo expand`] subcommand.//! [`cargo expand`]: https://github.com/dtolnay/cargo-expand//! To show the expanded code for some crate that uses your procedural macro,//! run `cargo expand` from that crate. To show the expanded code for one of//! your own test cases, run `cargo expand --test the_test_case` where the last//! argument is the name of the test file without the `.rs` extension.//! This write-up by Brandon W Maister discusses debugging in more detail://! [Debugging Rust's new Custom Derive system][debugging].//! [debugging]: https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system///! Syn puts a lot of functionality behind optional features in order to//! optimize compile time for the most common use cases. The following features//! are available.//! - **`derive`** *(enabled by default)* — Data structures for representing the//!   possible input to a custom derive, including structs and enums and types.//! - **`full`** — Data structures for representing the syntax tree of all valid//!   Rust source code, including items and expressions.//! - **`parsing`** *(enabled by default)* — Ability to parse input tokens into//!   a syntax tree node of a chosen type.//! - **`printing`** *(enabled by default)* — Ability to print a syntax tree//!   node as tokens of Rust source code.//! - **`visit`** — Trait for traversing a syntax tree.//! - **`visit-mut`** — Trait for traversing and mutating in place a syntax//!   tree.//! - **`fold`** — Trait for transforming an owned syntax tree.//! - **`clone-impls`** *(enabled by default)* — Clone impls for all syntax tree//! - **`extra-traits`** — Debug, Eq, PartialEq, Hash impls for all syntax tree//! - **`proc-macro`** *(enabled by default)* — Runtime dependency on the//!   dynamic library libproc_macro from rustc toolchain.// Syn types in rustdoc of other crates get linked to here.// Ignored clippy lints.// Ignored clippy_pedantic lints./// A Rust lifetime: `'a`./// Lifetime names must conform to the following rules:/// - Must start with an apostrophe./// - Must not consist of just an apostrophe: `'`./// - Character after the apostrophe must be `_` or a Unicode code point with///   the XID_Start property./// - All following characters must be Unicode code points with the XID_Continue///   property./// Panics if the lifetime does not conform to the bulleted rules above./// # Invocation/// # use syn::Lifetime;/// # fn f() -> Lifetime {/// Lifetime::new("'a", Span::call_site())r" A Rust literal such as a string or integer or boolean."r#" A UTF-8 string literal: `"foo"`."#r#" A byte string literal: `b"foo"`."#r" A byte literal: `b'f'`."r" A character literal: `'a'`."r" An integer literal: `1` or `1u16`."r" Holds up to 64 bits of data. Use `LitVerbatim` for any larger"r" integer literal."r" A floating point literal: `1f64` or `1.0e10f64`."r" Must be finite. May not be infinte or NaN."r" A boolean literal: `true` or `false`."r" A raw token literal not interpreted by Syn, possibly because it"r" represents an integer larger than 64 bits."/// Parse a syntax tree node from the content of this string literal./// All spans in the syntax tree will point to the span of this `LitStr`./// use syn::{Attribute, Error, Ident, Lit, Meta, MetaNameValue, Path, Result};/// // Parses the path from an attribute that looks like:/// //     #[path = "a::b::c"]/// // or returns `None` if the input is some other attribute./// fn get_path(attr: &Attribute) -> Result<Option<Path>> {///     if !attr.path.is_ident("path") {///         return Ok(None);///     match attr.parse_meta()? {///         Meta::NameValue(MetaNameValue { lit: Lit::Str(lit_str), .. }) => {///             lit_str.parse().map(Some)///             let message = "expected #[path = \"...\"]";///             Err(Error::new_spanned(attr, message))/// Invoke parser on the content of this string literal./// # use syn::{LitStr, Result};/// #     let lit_str = LitStr::new("a::b::c", Span::call_site());/// #     const IGNORE: &str = stringify! {/// let lit_str: LitStr = /* ... */;/// // Parse a string literal like "a::b::c" into a Path, not allowing/// // generic arguments on any of the path segments./// let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?;lit_extra_traitsr" The style of a string literal, either plain quoted or a raw string like"r###" `r##"data"##`."###r#" An ordinary string like `"data"`."#Cookedr###" A raw string like `r##"data"##`."###r" The unsigned integer is the number of `#` symbols used."r" The suffix on an integer literal if any, like the `u8` in `127u8`."r" The suffix on a floating point literal if any, like the `f32` in"r" `1.0f32`."/// Interpret a Syn literal from a proc-macro2 literal./// Not all proc-macro2 literals are valid Syn literals. In particular,/// doc comments are considered by proc-macro2 to be literals but in Syn/// they are [`Attribute`]./// [`Attribute`]: crate::Attribute/// Panics if the input is a doc comment literal.number_is_intnumber_is_float/// Get the byte at offset idx, or a default of `b'\0'` if we're looking/// past the end of the input buffer.next_chrparse_lit_strparse_lit_str_cooked// Clippy false positive// https://github.com/rust-lang-nursery/rust-clippy/issues/2329parse_lit_str_rawparse_lit_byte_strparse_lit_byte_str_cookedparse_lit_byte_str_rawparse_lit_byteparse_lit_charbackslash_xparse_lit_intparse_lit_floatto_literalLookahead1/// Support for checking the next token in a stream to decide how to parse./// An important advantage over [`ParseStream::peek`] is that here we/// automatically construct an appropriate error message based on the token/// alternatives that get peeked. If you are producing your own error message,/// go ahead and use `ParseStream::peek` instead./// Use [`ParseStream::lookahead1`] to construct this object./// [`ParseStream::peek`]: crate::parse::ParseBuffer::peek/// [`ParseStream::lookahead1`]: crate::parse::ParseBuffer::lookahead1/// use syn::{ConstParam, Ident, Lifetime, LifetimeDef, Result, Token, TypeParam};/// // A generic parameter, a single one of the comma-separated elements inside/// // angle brackets in:/// //     fn f<T: Clone, 'a, 'b: 'a, const N: usize>() { ... }/// // On invalid input, lookahead gives us a reasonable error message./// //     error: expected one of: identifier, lifetime, `const`/// //       |/// //     5 |     fn f<!Sized>() {}/// //       |          ^/// enum GenericParam {///     Type(TypeParam),///     Lifetime(LifetimeDef),///     Const(ConstParam),/// impl Parse for GenericParam {///         if lookahead.peek(Ident) {///             input.parse().map(GenericParam::Type)///         } else if lookahead.peek(Lifetime) {///             input.parse().map(GenericParam::Lifetime)///         } else if lookahead.peek(Token![const]) {///             input.parse().map(GenericParam::Const)peek_impl/// Looks at the next token in the parse stream to determine whether it/// matches the requested type of token./// Note that this method does not use turbofish syntax. Pass the peek type/// inside of parentheses./// - `input.peek(Token![struct])`/// - `input.peek(Token![==])`/// - `input.peek(Ident)`&emsp;*(does not accept keywords)*/// - `input.peek(Ident::peek_any)`/// - `input.peek(Lifetime)`/// - `input.peek(token::Brace)`/// Triggers an error at the current position of the parse stream./// The error message will identify all of the expected token types that/// have been peeked against this lookahead instance./// Types that can be parsed by looking at just one token./// Use [`ParseStream::peek`] to peek one of these types in a parse stream/// without consuming it from the stream./// This trait is sealed and cannot be implemented for types outside of Syn.into_spansis_delimiterr#" A macro invocation: `println!("{}", mac)`."#bang_tokenr" A grouping token that surrounds a macro body: `m!(...)` or `m!{...}` or `m![...]`."delimiter_spanparse_body/// Parse the tokens within the macro invocation's delimiters into a syntax/// tree./// This is equivalent to `syn::parse2::<T>(mac.tts)` except that it/// produces a more useful span when `tts` is empty./// use syn::{parse_quote, Expr, ExprLit, Ident, Lit, LitStr, Macro, Token};/// use syn::parse::{Error, Parse, ParseStream, Result};/// // The arguments expected by libcore's format_args macro, and as a/// // result most other formatting and printing macros like println./// //     println!("{} is {number:.prec$}", "x", prec=5, number=0.01)/// struct FormatArgs {///     format_string: Expr,///     positional_args: Vec<Expr>,///     named_args: Vec<(Ident, Expr)>,/// impl Parse for FormatArgs {///         let format_string: Expr;///         let mut positional_args = Vec::new();///         let mut named_args = Vec::new();///         format_string = input.parse()?;///         while !input.is_empty() {///             input.parse::<Token![,]>()?;///             if input.is_empty() {///             if input.peek(Ident::peek_any) && input.peek2(Token![=]) {///                 while !input.is_empty() {///                     let name: Ident = input.call(Ident::parse_any)?;///                     input.parse::<Token![=]>()?;///                     let value: Expr = input.parse()?;///                     named_args.push((name, value));///                     if input.is_empty() {///                         break;///                     input.parse::<Token![,]>()?;///             positional_args.push(input.parse()?);///         Ok(FormatArgs {///             format_string,///             positional_args,///             named_args,/// // Extract the first argument, the format string literal, from an/// // invocation of a formatting or printing macro./// fn get_format_string(m: &Macro) -> Result<LitStr> {///     let args: FormatArgs = m.parse_body()?;///     match args.format_string {///         Expr::Lit(ExprLit { lit: Lit::Str(lit), .. }) => Ok(lit),///         other => {///             // First argument was not a string literal expression.///             // Maybe something like: println!(concat!(...), ...)///             Err(Error::new_spanned(other, "format string must be a string literal"))///     let invocation = parse_quote! {///         println!("{:?}", Instant::now())///     let lit = get_format_string(&invocation).unwrap();///     assert_eq!(lit.value(), "{:?}");parse_body_with/// Parse the tokens within the macro invocation's delimiters using the/// given parser.parse_delimiterto_tokens_call// If the variant is marked as #full, don't auto-generate to-tokens for it.r" A binary operator: `+`, `+=`, `&`."r" The `+` operator (addition)"r" The `-` operator (subtraction)"r" The `*` operator (multiplication)"r" The `/` operator (division)"r" The `%` operator (modulus)"r" The `&&` operator (logical and)"AndAndr" The `||` operator (logical or)"OrOrr" The `^` operator (bitwise xor)"r" The `&` operator (bitwise and)"r" The `|` operator (bitwise or)"r" The `<<` operator (shift left)"r" The `>>` operator (shift right)"r" The `==` operator (equality)"EqEqr" The `<` operator (less than)"r" The `<=` operator (less than or equal to)"r" The `!=` operator (not equal to)"r" The `>=` operator (greater than or equal to)"r" The `>` operator (greater than)"r" The `+=` operator"AddEqr" The `-=` operator"SubEqr" The `*=` operator"MulEqr" The `/=` operator"DivEqr" The `%=` operator"RemEqr" The `^=` operator"CaretEqBitXorEqr" The `&=` operator"AndEqBitAndEqr" The `|=` operator"OrEqBitOrEqr" The `<<=` operator"ShlEqr" The `>>=` operator"ShrEqr" A unary operator: `*`, `!`, `-`."r" The `*` operator for dereferencing"r" The `!` operator for logical inversion"r" The `-` operator for negation"parse_binop"discouraged.rs"discouraged/// Parsing interface implemented by all types that can be parsed in a default/// way from a token stream./// Input to a Syn parser function./// See the methods of this type under the documentation of [`ParseBuffer`]. For/// an overview of parsing in Syn, refer to the [module documentation].// Instead of Cell<Cursor<'a>> so that ParseBuffer<'a> is covariant in 'a.// The rest of the code in this module needs to be careful that only a// cursor derived from this `cell` is ever assigned to this `cell`.// Cell<Cursor<'a>> cannot be covariant in 'a because then we could take a// ParseBuffer<'a>, upcast to ParseBuffer<'short> for some lifetime shorter// than 'a, and then assign a Cursor<'short> into the Cell.// By extension, it would not be safe to expose an API that accepts a// Cursor<'a> and trusts that it lives as long as the cursor currently in// the cell./// Cursor position within a buffered token stream./// This type is more commonly used through the type alias [`ParseStream`] which/// is an alias for `&ParseBuffer`./// `ParseStream` is the input type for all parser functions in Syn. They have/// the signature `fn(ParseStream) -> Result<T>`./// ## Calling a parser function/// There is no public way to construct a `ParseBuffer`. Instead, if you are/// looking to invoke a parser function that requires `ParseStream` as input,/// you will need to go through one of the public parsing entry points./// - The [`parse_macro_input!`] macro if parsing input of a procedural macro;/// - One of [the `syn::parse*` functions][syn-parse]; or/// - A method of the [`Parser`] trait./// [syn-parse]: index.html#the-synparse-functions// This field is covariant in 'c.// This field is contravariant in 'c. Together these make StepCursor// invariant in 'c. Also covariant in 'a. The user cannot cast 'c to a// different lifetime but can upcast into a StepCursor with a shorter// lifetime 'a.// As long as we only ever construct a StepCursor for which 'c outlives 'a,// this means if ever a StepCursor<'c, 'a> exists we are guaranteed that 'c// outlives 'a.StepCursor/// Cursor state associated with speculative parsing./// This type is the input of the closure provided to [`ParseStream::step`]./// [`ParseStream::step`]: ParseBuffer::step/// use proc_macro2::TokenTree;/// use syn::Result;/// // This function advances the stream past the next occurrence of `@`. If/// // no `@` is present in the stream, the stream position is unchanged and/// // an error is returned./// fn skip_past_next_at(input: ParseStream) -> Result<()> {///     input.step(|cursor| {///         let mut rest = *cursor;///         while let Some((tt, next)) = rest.token_tree() {///             match &tt {///                 TokenTree::Punct(punct) if punct.as_char() == '@' => {///                     return Ok(((), next));///                 _ => rest = next,///         Err(cursor.error("no `@` was found after this point"))/// # fn remainder_after_skipping_past_next_at(/// #     input: ParseStream,/// # ) -> Result<proc_macro2::TokenStream> {/// #     skip_past_next_at(input)?;/// #     input.parse()/// #     use syn::parse::Parser;/// #     let remainder = remainder_after_skipping_past_next_at/// #         .parse_str("a @ b c")/// #         .unwrap();/// #     assert_eq!(remainder.to_string(), "b c");/// The `ParseStream::step` invocation will return this same error without/// advancing the stream state.advance_step_cursornew_parse_bufferget_unexpected/// Parses a syntax tree node of type `T`, advancing the position of our/// parse stream past it./// Calls the given parser function to parse a syntax tree node of type `T`/// from this stream./// The parser below invokes [`Attribute::parse_outer`] to parse a vector of/// zero or more outer attributes./// [`Attribute::parse_outer`]: crate::Attribute::parse_outer/// use syn::{Attribute, Ident, Result, Token};/// // Parses a unit struct with attributes./// //     #[path = "s.tmpl"]/// //     struct S;/// struct UnitStruct {///     attrs: Vec<Attribute>,/// impl Parse for UnitStruct {///         Ok(UnitStruct {///             attrs: input.call(Attribute::parse_outer)?,/// Does not advance the position of the parse stream./// In this example we finish parsing the list of supertraits when the next/// token in the input is either `where` or an opening curly brace./// use syn::{braced, token, Generics, Ident, Result, Token, TypeParamBound};/// // Parses a trait definition containing no associated items./// //     trait Marker<'de, T>: A + B<'de> where Box<T>: Clone {}/// struct MarkerTrait {///     trait_token: Token![trait],///     generics: Generics,///     colon_token: Option<Token![:]>,///     supertraits: Punctuated<TypeParamBound, Token![+]>,/// impl Parse for MarkerTrait {///         let trait_token: Token![trait] = input.parse()?;///         let ident: Ident = input.parse()?;///         let mut generics: Generics = input.parse()?;///         let colon_token: Option<Token![:]> = input.parse()?;///         let mut supertraits = Punctuated::new();///         if colon_token.is_some() {///             loop {///                 supertraits.push_value(input.parse()?);///                 if input.peek(Token![where]) || input.peek(token::Brace) {///                     break;///                 supertraits.push_punct(input.parse()?);///         generics.where_clause = input.parse()?;///         let empty_brace_token = braced!(content in input);///         Ok(MarkerTrait {///             trait_token: trait_token,///             ident: ident,///             generics: generics,///             colon_token: colon_token,///             supertraits: supertraits,///             brace_token: empty_brace_token,/// Looks at the second-next token in the parse stream./// This is commonly useful as a way to implement contextual keywords./// This example needs to use `peek2` because the symbol `union` is not a/// keyword in Rust. We can't use just `peek` and decide to parse a union if/// the very next token is `union`, because someone is free to write a `mod/// union` and a macro invocation that looks like `union::some_macro! { .../// }`. In other words `union` is a contextual keyword./// use syn::{Ident, ItemUnion, Macro, Result, Token};/// // Parses either a union or a macro invocation./// enum UnionOrMacro {///     // union MaybeUninit<T> { uninit: (), value: T }///     Union(ItemUnion),///     // lazy_static! { ... }///     Macro(Macro),/// impl Parse for UnionOrMacro {///         if input.peek(Token![union]) && input.peek2(Ident) {///             input.parse().map(UnionOrMacro::Union)///             input.parse().map(UnionOrMacro::Macro)peek3/// Looks at the third-next token in the parse stream.parse_terminated/// Parses zero or more occurrences of `T` separated by punctuation of type/// `P`, with optional trailing punctuation./// Parsing continues until the end of this parse stream. The entire content/// of this parse stream must consist of `T` and `P`./// Returns whether there are tokens remaining in this stream./// This method returns true at the end of the content of a set of/// delimiters, as well as at the very end of the complete macro input./// use syn::{braced, token, Ident, Item, Result, Token};/// // Parses a Rust `mod m { ... }` containing zero or more items./// struct Mod {///     mod_token: Token![mod],///     items: Vec<Item>,/// impl Parse for Mod {///         Ok(Mod {///             mod_token: input.parse()?,///             items: {///                 let mut items = Vec::new();///                 while !content.is_empty() {///                     items.push(content.parse()?);///                 itemslookahead1/// Constructs a helper for peeking at the next token in this stream and/// building an error message if it is not one of a set of expected tokens./// Forks a parse stream so that parsing tokens out of either the original/// or the fork does not advance the position of the other./// Forking a parse stream is a cheap fixed amount of work and does not/// involve copying token buffers. Where you might hit performance problems/// is if your macro ends up parsing a large amount of content more than/// # use syn::{Expr, Result};/// # use syn::parse::ParseStream;/// # fn bad(input: ParseStream) -> Result<Expr> {/// // Do not do this./// if input.fork().parse::<Expr>().is_ok() {///     return input.parse::<Expr>();/// # unimplemented!()/// As a rule, avoid parsing an unbounded amount of tokens out of a forked/// parse stream. Only use a fork when the amount of work performed against/// the fork is small and bounded./// When complex speculative parsing against the forked stream is/// unavoidable, use [`parse::discouraged::Speculative`] to advance the/// original stream once the fork's parse is determined to have been/// For a lower level way to perform speculative parsing at the token level,/// consider using [`ParseStream::step`] instead./// [`parse::discouraged::Speculative`]: discouraged::Speculative/// The parse implementation shown here parses possibly restricted `pub`/// visibilities./// - `pub`/// - `pub(crate)`/// - `pub(self)`/// - `pub(super)`/// - `pub(in some::path)`/// To handle the case of visibilities inside of tuple structs, the parser/// needs to distinguish parentheses that specify visibility restrictions/// from parentheses that form part of a tuple type./// # struct A;/// # struct B;/// # struct C;/// struct S(pub(crate) A, pub (B, C));/// In this example input the first tuple struct element of `S` has/// `pub(crate)` visibility while the second tuple struct element has `pub`/// visibility; the parentheses around `(B, C)` are part of the type rather/// than part of a visibility restriction./// The parser uses a forked parse stream to check the first token inside of/// parentheses after the `pub` keyword. This is a small bounded amount of/// work performed against the forked parse stream./// use syn::{parenthesized, token, Ident, Path, Result, Token};/// struct PubVisibility {///     pub_token: Token![pub],///     restricted: Option<Restricted>,/// struct Restricted {///     in_token: Option<Token![in]>,///     path: Path,/// impl Parse for PubVisibility {///         let pub_token: Token![pub] = input.parse()?;///         if input.peek(token::Paren) {///             let ahead = input.fork();///             let mut content;///             parenthesized!(content in ahead);///             if content.peek(Token![crate])///                 || content.peek(Token![self])///                 || content.peek(Token![super])///                 return Ok(PubVisibility {///                     pub_token: pub_token,///                     restricted: Some(Restricted {///                         paren_token: parenthesized!(content in input),///                         in_token: None,///                         path: Path::from(content.call(Ident::parse_any)?),///                     }),///             } else if content.peek(Token![in]) {///                         in_token: Some(content.parse()?),///                         path: content.call(Path::parse_mod_style)?,///         Ok(PubVisibility {///             pub_token: pub_token,///             restricted: None,/// use syn::{Expr, Result, Token};/// // Some kind of loop: `while` or `for` or `loop`./// struct Loop {///     expr: Expr,/// impl Parse for Loop {///         if input.peek(Token![while])///             || input.peek(Token![for])///             || input.peek(Token![loop])///             Ok(Loop {///                 expr: input.parse()?,///             Err(input.error("expected some kind of loop"))/// Speculatively parses tokens from this parse stream, advancing the/// position of this stream only if parsing succeeds./// This is a powerful low-level API used for defining the `Parse` impls of/// the basic built-in token types. It is not something that will be used/// widely outside of the Syn codebase./// Provides low-level access to the token representation underlying this/// Cursors are immutable so no operations you perform against the cursor/// will affect the state of this parse stream.check_unexpected/// This function will check that the input is fully parsed. If there are/// any unparsed tokens at the end of the stream, an error is returned./// any unparsed tokens at the end of the string, an error is returned./// Every span in the resulting syntax tree will be set to resolve at the/// macro call site.__parse_scoped/// Parser that can parse Rust tokens into a particular syntax tree node.tokens_to_parse_bufferparse_scoped//! Parsing interface for parsing a token stream into a syntax tree node.//! Parsing in Syn is built on parser functions that take in a [`ParseStream`]//! and produce a [`Result<T>`] where `T` is some syntax tree node. Underlying//! these parser functions is a lower level mechanism built around the//! [`Cursor`] type. `Cursor` is a cheaply copyable cursor over a range of//! tokens in a token stream.//! [`ParseStream`]: type.ParseStream.html//! [`Result<T>`]: type.Result.html//! [`Cursor`]: ../buffer/index.html//! Here is a snippet of parsing code to get a feel for the style of the//! library. We define data structures for a subset of Rust syntax including//! enums (not shown) and structs, then provide implementations of the [`Parse`]//! trait to parse these syntax tree data structures from a token stream.//! Once `Parse` impls have been defined, they can be called conveniently from a//! procedural macro through [`parse_macro_input!`] as shown at the bottom of//! the snippet. If the caller provides syntactically invalid input to the//! procedural macro, they will receive a helpful compiler error message//! pointing out the exact token that triggered the failure to parse.//! [`parse_macro_input!`]: ../macro.parse_macro_input.html//! use syn::{braced, parse_macro_input, token, Field, Ident, Result, Token};//! use syn::parse::{Parse, ParseStream};//! use syn::punctuated::Punctuated;//! enum Item {//!     Struct(ItemStruct),//!     Enum(ItemEnum),//! struct ItemStruct {//!     struct_token: Token![struct],//!     ident: Ident,//!     brace_token: token::Brace,//!     fields: Punctuated<Field, Token![,]>,//! # enum ItemEnum {}//! impl Parse for Item {//!     fn parse(input: ParseStream) -> Result<Self> {//!         let lookahead = input.lookahead1();//!         if lookahead.peek(Token![struct]) {//!             input.parse().map(Item::Struct)//!         } else if lookahead.peek(Token![enum]) {//!             input.parse().map(Item::Enum)//!             Err(lookahead.error())//! impl Parse for ItemStruct {//!         let content;//!         Ok(ItemStruct {//!             struct_token: input.parse()?,//!             ident: input.parse()?,//!             brace_token: braced!(content in input),//!             fields: content.parse_terminated(Field::parse_named)?,//! # impl Parse for ItemEnum {//! #     fn parse(input: ParseStream) -> Result<Self> {//! #         unimplemented!()//! #[proc_macro]//! pub fn my_macro(tokens: TokenStream) -> TokenStream {//!     let input = parse_macro_input!(tokens as Item);//! #   "".parse().unwrap()//! # The `syn::parse*` functions//! The [`syn::parse`], [`syn::parse2`], and [`syn::parse_str`] functions serve//! as an entry point for parsing syntax tree nodes that can be parsed in an//! obvious default way. These functions can return any syntax tree node that//! implements the [`Parse`] trait, which includes most types in Syn.//! [`syn::parse`]: ../fn.parse.html//! [`syn::parse2`]: ../fn.parse2.html//! [`syn::parse_str`]: ../fn.parse_str.html//! [`Parse`]: trait.Parse.html//! use syn::Type;//! # fn run_parser() -> syn::Result<()> {//! let t: Type = syn::parse_str("std::collections::HashMap<String, Value>")?;//! #     run_parser().unwrap();//! The [`parse_quote!`] macro also uses this approach.//! [`parse_quote!`]: ../macro.parse_quote.html//! # The `Parser` trait//! Some types can be parsed in several ways depending on context. For example//! an [`Attribute`] can be either "outer" like `#[...]` or "inner" like//! `#![...]` and parsing the wrong one would be a bug. Similarly [`Punctuated`]//! may or may not allow trailing punctuation, and parsing it the wrong way//! would either reject valid input or accept invalid input.//! [`Attribute`]: ../struct.Attribute.html//! [`Punctuated`]: ../punctuated/index.html//! The `Parse` trait is not implemented in these cases because there is no good//! behavior to consider the default.//! ```edition2018,compile_fail//! # extern crate proc_macro;//! # use syn::punctuated::Punctuated;//! # use syn::{PathSegment, Result, Token};//! # fn f(tokens: proc_macro::TokenStream) -> Result<()> {//! // Can't parse `Punctuated` without knowing whether trailing punctuation//! // should be allowed in this context.//! let path: Punctuated<PathSegment, Token![::]> = syn::parse(tokens)?;//! In these cases the types provide a choice of parser functions rather than a//! single `Parse` implementation, and those parser functions can be invoked//! through the [`Parser`] trait.//! [`Parser`]: trait.Parser.html//! use syn::parse::Parser;//! use syn::{Attribute, Expr, PathSegment, Result, Token};//! fn call_some_parser_methods(input: TokenStream) -> Result<()> {//!     // Parse a nonempty sequence of path segments separated by `::` punctuation//!     // with no trailing punctuation.//!     let tokens = input.clone();//!     let parser = Punctuated::<PathSegment, Token![::]>::parse_separated_nonempty;//!     let _path = parser.parse(tokens)?;//!     // Parse a possibly empty sequence of expressions terminated by commas with//!     // an optional trailing punctuation.//!     let parser = Punctuated::<Expr, Token![,]>::parse_terminated;//!     let _args = parser.parse(tokens)?;//!     // Parse zero or more outer attributes but not inner attributes.//!     let parser = Attribute::parse_outer;//!     let _attrs = parser.parse(tokens)?;/// Parse the input TokenStream of a macro, triggering a compile error if the/// tokens fail to parse./// Refer to the [`parse` module] documentation for more details about parsing/// in Syn./// [`parse` module]: parse/index.html/// # Intended usage/// use syn::{parse_macro_input, Result};/// struct MyMacroInput {/// impl Parse for MyMacroInput {/// #       Ok(MyMacroInput {})/// #[proc_macro]/// pub fn my_macro(tokens: TokenStream) -> TokenStream {///     let input = parse_macro_input!(tokens as MyMacroInput);ParseMacroInput// Can parse any type that implements Parse.// Any other types that we want `parse_macro_input!` to be able to parse./// Quasi-quotation macro that accepts input like the [`quote!`] macro but uses/// type inference to figure out a return type for those tokens./// [`quote!`]: https://docs.rs/quote/0.6/quote/index.html/// The return type can be any syntax tree node that implements the [`Parse`]/// [`Parse`]: parse::Parse/// use syn::{parse_quote, Stmt};///     let name = quote!(v);///     let ty = quote!(u8);///     let stmt: Stmt = parse_quote! {///         let #name: #ty = Default::default();///     println!("{:#?}", stmt);/// *This macro is available if Syn is built with the `"parsing"` feature,/// although interpolation of syntax tree nodes into the quoted tokens is only/// supported if Syn is built with the `"printing"` feature as well.*/// The following helper function adds a bound `T: HeapSize` to every type/// parameter `T` in the input generics./// use syn::{parse_quote, Generics, GenericParam};/// // Add a bound `T: HeapSize` to every type parameter T./// fn add_trait_bounds(mut generics: Generics) -> Generics {///     for param in &mut generics.params {///         if let GenericParam::Type(type_param) = param {///             type_param.bounds.push(parse_quote!(HeapSize));///     generics/// This macro can parse the following additional types as a special case even/// though they do not implement the `Parse` trait./// - [`Attribute`] — parses one attribute, allowing either outer like `#[...]`///   or inner like `#![...]`/// - [`Punctuated<T, P>`] — parses zero or more `T` separated by punctuation///   `P` with optional trailing punctuation/// [`Punctuated<T, P>`]: punctuated::Punctuated/// Panics if the tokens fail to parse as the expected syntax tree type. The/// caller is responsible for ensuring that the input tokens are syntactically// TODO: allow Punctuated to be inferred as intra doc link, currently blocked on// https://github.com/rust-lang/rust/issues/62834quote_implParseQuote// Any other types that we want `parse_quote!` to be able to parse.r" A path at which a named item is exported: `std::collections::HashMap`."leading_colonColon2r" A segment of a path together with any path arguments on that segment."r" Angle bracketed or parenthesized arguments of a path segment."r" ## Angle bracketed"r" The `<'a, T>` in `std::slice::iter<'a, T>`."r" ## Parenthesized"r" The `(A, B) -> C` in `Fn(A, B) -> C`."AngleBracketedParenthesizedr" An individual generic argument, like `'a`, `T`, or `Item = T`."r" A lifetime argument."r" A type argument."r" A binding (equality constraint) on an associated type: the `Item ="r" u8` in `Iterator<Item = u8>`."r" An associated type bound: `Iterator<Item: Display>`."r" A const expression. Must be inside of a block."r" NOTE: Identity expressions are represented as Type arguments, as"r" they are indistinguishable syntactically."r" Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K,"r" V>`."colon2_tokenr" A binding (equality constraint) on an associated type: `Item = u8`."r" Arguments of a function path segment: the `(A, B) -> C` in `Fn(A,B) ->"r" C`."r" `(A, B)`"r" `C`"r" The explicit Self type in a qualified path: the `T` in `<T as"r" Display>::fmt`."r" The actual path, including the trait and the associated item, is stored"r" separately. The `position` field represents the index of the associated"r" item qualified with this Self type."r" <Vec<T> as a::b::Trait>::AssociatedItem"r"  ^~~~~~    ~~~~~~~~~~~~~~^"r"  ty        position = 3"r" <Vec<T>>::AssociatedItem"r"  ^~~~~~   ^"r"  ty       position = 0"parse_helperparse_mod_style/// Parse a `Path` containing no path arguments on any of its segments./// use syn::{Path, Result, Token};/// // A simplified single `use` statement like:/// //     use std::collections::HashMap;/// // Note that generic parameters are not allowed in a `use` statement/// // so the following must not be accepted./// //     use a::<b>::c;/// struct SingleUse {///     use_token: Token![use],/// impl Parse for SingleUse {///         Ok(SingleUse {///             use_token: input.parse()?,///             path: input.call(Path::parse_mod_style)?,/// Determines whether this is a path of length 1 equal to the given/// ident./// For them to compare equal, it must be the case that:/// - the path has no leading colon,/// - the number of path segments is 1,/// - the first path segment has no angle bracketed or parenthesized///   path arguments/// - and the ident of the first path segment is equal to the given one./// A punctuated sequence of syntax tree nodes of type `T` separated by/// punctuation of type `P`./// Refer to the [module documentation] for details about punctuated sequences./// Creates an empty punctuated sequence./// Determines whether this punctuated sequence is empty, meaning it/// contains no syntax tree nodes or punctuation./// Returns the number of syntax tree nodes in this punctuated sequence./// This is the number of nodes of type `T`, not counting the punctuation of/// type `P`./// Borrows the first punctuated pair in this sequence./// Borrows the last punctuated pair in this sequence./// Mutably borrows the last punctuated pair in this sequence./// Returns an iterator over borrowed syntax tree nodes of type `&T`./// Returns an iterator over mutably borrowed syntax tree nodes of type/// `&mut T`.Pairs/// Returns an iterator over the contents of this sequence as borrowed/// punctuated pairs.PairsMut/// Returns an iterator over the contents of this sequence as mutably/// borrowed punctuated pairs.into_pairsIntoPairs/// Returns an iterator over the contents of this sequence as ownedpush_value/// Appends a syntax tree node onto the end of this punctuated sequence. The/// sequence must previously have a trailing punctuation./// Use [`push`] instead if the punctuated sequence may or may not already/// have trailing punctuation./// [`push`]: Punctuated::push/// Panics if the sequence does not already have a trailing punctuation when/// this method is called./// Appends a trailing punctuation onto the end of this punctuated sequence./// The sequence must be non-empty and must not already have trailing/// punctuation./// Panics if the sequence is empty or already has a trailing punctuation./// Removes the last punctuated pair from this sequence, or `None` if the/// sequence is empty.trailing_punct/// Determines whether this punctuated sequence ends with a trailingempty_or_trailing/// Returns true if either this `Punctuated` is empty, or it has a trailing/// Equivalent to `punctuated.is_empty() || punctuated.trailing_punct()`./// Appends a syntax tree node onto the end of this punctuated sequence./// If there is not a trailing punctuation in this sequence when this method/// is called, the default value of punctuation type `P` is inserted before/// the given value of type `T`./// Inserts an element at position `index`./// Panics if `index` is greater than the number of elements previously in/// this punctuated sequence.parse_terminated_with/// Parses zero or more occurrences of `T` using the given parse function,/// separated by punctuation of type `P`, with optional trailing/// Like [`parse_terminated`], the entire content of this stream is expected/// to be parsed./// [`parse_terminated`]: Punctuated::parse_terminatedparse_separated_nonempty/// Parses one or more occurrences of `T` separated by punctuation of type/// `P`, not accepting trailing punctuation./// Parsing continues as long as punctuation `P` is present at the head of/// the stream. This method returns upon parsing a `T` and observing that it/// is not followed by a `P`, even if there are remaining tokens in theparse_separated_nonempty_with/// Parses one or more occurrences of `T` using the given parse function,/// separated by punctuation of type `P`, not accepting trailing/// Like [`parse_separated_nonempty`], may complete early without parsing/// the entire content of this stream./// [`parse_separated_nonempty`]: Punctuated::parse_separated_nonempty/// An iterator over borrowed pairs of type `Pair<&T, &P>`.// No Clone bound on T or P./// An iterator over mutably borrowed pairs of type `Pair<&mut T, &mut P>`./// An iterator over owned pairs of type `Pair<T, P>`.// TODO: remove P type parameter in the next breaking change/// An iterator over owned values of type `T`.IterTrait// The `Item = &'a T` needs to be specified to support rustc 1.31 and older.// On modern compilers we would be able to write just IterTrait<'a, T> where// Item can be inferred unambiguously from the supertrait./// An iterator over borrowed values of type `&T`.PrivateIterempty_punctuated_iter// No Clone bound on T./// An iterator over mutably borrowed values of type `&mut T`.PrivateIterMutempty_punctuated_iter_mut/// A single syntax tree node of type `T` followed by its trailing punctuation/// of type `P` if any./// Extracts the syntax tree node from this punctuated pair, discarding the/// following punctuation./// Borrows the syntax tree node from this punctuated pair./// Mutably borrows the syntax tree node from this punctuated pair./// Borrows the punctuation from this punctuated pair, unless this pair is/// the final one and there is no trailing punctuation./// Creates a punctuated pair out of a syntax tree node and an optional/// Produces this punctuated pair as a tuple of syntax tree node and/// optional following punctuation.//! A punctuated sequence of syntax tree nodes separated by punctuation.//! Lots of things in Rust are punctuated sequences.//! - The fields of a struct are `Punctuated<Field, Token![,]>`.//! - The segments of a path are `Punctuated<PathSegment, Token![::]>`.//! - The bounds on a generic parameter are `Punctuated<TypeParamBound,//!   Token![+]>`.//! - The arguments to a function call are `Punctuated<Expr, Token![,]>`.//! This module provides a common representation for these punctuated sequences//! in the form of the [`Punctuated<T, P>`] type. We store a vector of pairs of//! syntax tree node + punctuation, where every node in the sequence is followed//! by punctuation except for possibly the final one.//! [`Punctuated<T, P>`]: struct.Punctuated.html//! a_function_call(arg1, arg2, arg3);//!                 ^^^^^ ~~~~~ ^^^^from_spansFromSpans/// Returns a `Span` covering the complete contents of this syntax tree/// node, or [`Span::call_site()`] if this node is empty./// [`Span::call_site()`]: proc_macro2::Span::call_site/// A trait that can provide the `Span` of the complete contents of a syntax/// This trait is automatically implemented for all types that implement/// [`ToTokens`] from the `quote` crate. It is sealed and cannot be implemented/// outside of the Syn crate other than by implementing `ToTokens`./// [`ToTokens`]: quote::ToTokens/// See the [module documentation] for an example./// *This trait is available if Syn is built with both the `"parsing"` and/// `"printing"` features.*//! A trait that can provide the `Span` of the complete contents of a syntax//! tree node.//! *This module is available if Syn is built with both the `"parsing"` and//! `"printing"` features.*//! Suppose in a procedural macro we have a [`Type`] that we want to assert//! implements the [`Sync`] trait. Maybe this is the type of one of the fields//! of a struct for which we are deriving a trait implementation, and we need to//! be able to pass a reference to one of those fields across threads.//! [`Type`]: ../enum.Type.html//! If the field type does *not* implement `Sync` as required, we want the//! compiler to report an error pointing out exactly which type it was.//! The following macro code takes a variable `ty` of type `Type` and produces a//! static assertion that `Sync` is implemented for that type.//! use proc_macro2::Span;//! use quote::quote_spanned;//! use syn::spanned::Spanned;//!     # let ty = get_a_type();//!     let assert_sync = quote_spanned! {ty.span()=>//!         struct _AssertSync where #ty: Sync;//!     # input//! # fn get_a_type() -> Type {//! #     unimplemented!()//! By inserting this `assert_sync` fragment into the output code generated by//! our macro, the user's code will fail to compile if `ty` does not implement//! `Sync`. The errors they would see look like the following.//! error[E0277]: the trait bound `*const i32: std::marker::Sync` is not satisfied//!   --> src/main.rs:10:21//! 10 |     bad_field: *const i32,//!    |                ^^^^^^^^^^ `*const i32` cannot be shared between threads safely//! In this technique, using the `Type`'s span for the error message makes the//! error appear in the correct place underlining the right type./// ThreadBound is a Sync-maker and Send-maker that allows accessing a value/// of type T only from the original thread on which the ThreadBound was// Send bound requires Copy, as otherwise Drop could run in the wrong place.WithSpan/// Marker trait for types that represent single tokens./// Support writing `token.span` rather than `token.spans[0]` on tokens that/// hold a single span.impl_tokendefine_keywordsimpl_deref_if_len_is_1define_punctuation_structsdefine_punctuationdefine_delimitersr" `_`"r" Don't try to remember the name of this type -- use the [`Token!`]"r" macro instead."r" [`Token!`]: crate::token"r" `abstract`"r" `as`"r" `async`"r" `auto`"r" `become`"Becomer" `box`"r" `break`"r" `const`"r" `continue`"r" `crate`"r" `default`"r" `do`"Dor" `dyn`"r" `else`"Elser" `enum`"r" `existential`"Existentialr" `extern`"r" `final`"r" `fn`"r" `for`"r" `if`"r" `impl`"r" `in`"r" `let`"r" `loop`"r" `macro`"r" `match`"r" `mod`"r" `move`"r" `mut`"r" `override`"Overrider" `priv`"Privr" `pub`"r" `ref`"r" `return`"r" `Self`"r" `self`"r" `static`"r" `struct`"r" `super`"r" `trait`"r" `try`"r" `type`"r" `typeof`"Typeofr" `union`"r" `unsafe`"r" `unsized`"Unsizedr" `use`"User" `virtual`"r" `where`"r" `while`"r" `yield`"r" `+`"r" `+=`"r" `&`"r" `&&`"r" `&=`"r" `@`"r" `!`"r" `^`"r" `^=`"r" `:`"r" `::`"r" `,`"r" `/`"r" `/=`"r" `$`"Dollarr" `.`"r" `..`"Dot2r" `...`"Dot3r" `..=`"DotDotEqr" `=`"r" `==`"r" `>=`"r" `>`"r" `<=`"r" `<`"r" `*=`"r" `!=`"r" `|`"r" `|=`"r" `||`"r" `#`"r" `?`"r" `->`"RArrowr" `<-`"LArrowr" `%`"r" `%=`"r" `=>`"FatArrowr" `;`"r" `<<`"r" `<<=`"r" `>>`"r" `>>=`"r" `*`"r" `-`"r" `-=`"r" `~`"r" `{...}`"surroundr" `[...]`"r" `(...)`"r" None-delimited group"export_token_macror" A type-macro that expands to the name of the Rust type representation of a"r" given token."r" See the [token module] documentation for details and examples."r" [token module]: crate::token"CapSelf// Old names. TODO: remove these re-exports in a breaking change.// https://github.com/dtolnay/syn/issues/486Self_peek_keywordpunct_helperpeek_punct//! Tokens representing Rust punctuation, keywords, and delimiters.//! The type names in this module can be difficult to keep straight, so we//! prefer to use the [`Token!`] macro instead. This is a type-macro that//! expands to the token type of the given token.//! [`Token!`]: ../macro.Token.html//! The [`ItemStatic`] syntax tree node is defined like this.//! [`ItemStatic`]: ../struct.ItemStatic.html//! # use syn::{Attribute, Expr, Ident, Token, Type, Visibility};//! pub struct ItemStatic {//!     pub attrs: Vec<Attribute>,//!     pub vis: Visibility,//!     pub static_token: Token![static],//!     pub mutability: Option<Token![mut]>,//!     pub ident: Ident,//!     pub colon_token: Token![:],//!     pub ty: Box<Type>,//!     pub eq_token: Token![=],//!     pub expr: Box<Expr>,//!     pub semi_token: Token![;],//! # Parsing//! Keywords and punctuation can be parsed through the [`ParseStream::parse`]//! method. Delimiter tokens are parsed using the [`parenthesized!`],//! [`bracketed!`] and [`braced!`] macros.//! [`ParseStream::parse`]: ../parse/struct.ParseBuffer.html#method.parse//! [`parenthesized!`]: ../macro.parenthesized.html//! [`bracketed!`]: ../macro.bracketed.html//! [`braced!`]: ../macro.braced.html//! use syn::{Attribute, Result};//! # enum ItemStatic {}//! // Parse the ItemStatic struct shown above.//! impl Parse for ItemStatic {//!         # use syn::ItemStatic;//!         # fn parse(input: ParseStream) -> Result<ItemStatic> {//!         Ok(ItemStatic {//!             attrs: input.call(Attribute::parse_outer)?,//!             vis: input.parse()?,//!             static_token: input.parse()?,//!             mutability: input.parse()?,//!             colon_token: input.parse()?,//!             ty: input.parse()?,//!             eq_token: input.parse()?,//!             expr: input.parse()?,//!             semi_token: input.parse()?,//!         # }//!         # unimplemented!()//! # Other operations//! Every keyword and punctuation token supports the following operations.//! - [Peeking] — `input.peek(Token![...])`//! - [Parsing] — `input.parse::<Token![...]>()?`//! - [Printing] — `quote!( ... #the_token ... )`//! - Construction from a [`Span`] — `let the_token = Token![...](sp)`//! - Field access to its span — `let sp = the_token.span`//! [Peeking]: ../parse/struct.ParseBuffer.html#method.peek//! [Parsing]: ../parse/struct.ParseBuffer.html#method.parse//! [Printing]: https://docs.rs/quote/0.6/quote/trait.ToTokens.html//! [`Span`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.htmlTokenTreeHelperr" The possible types that a Rust value could have."r" A dynamically sized slice type: `[T]`."r" A fixed size array type: `[T; n]`."r" A raw pointer type: `*const T` or `*mut T`."r" A reference type: `&'a T` or `&'a mut T`."r" A bare function type: `fn(usize) -> bool`."BareFnr" The never type: `!`."r" A tuple type: `(A, B, C, String)`."r" A path like `std::slice::Iter`, optionally qualified with a"r" self-type as in `<Vec<T> as SomeTrait>::Associated`."r" Type arguments are stored in the Path itself."r" A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a"r" trait or a lifetime."TraitObjectr" An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or"r" a lifetime."ImplTraitr" A parenthesized type equivalent to the inner type."r" A type contained within invisible delimiters."r" Indication that a type should be inferred by the compiler: `_`."Inferr" A macro in the type position."r" Tokens in type position not interpreted by Syn."star_tokenand_tokenunsafetyfn_tokendyn_tokengroup_tokenunderscore_tokenr#" The binary interface of a function: `extern "C"`."#extern_tokenr" An argument in a function type: the `usize` in `fn(usize) -> bool`."r" Name of an argument in a function type: the `n` in `fn(n: usize)`."r" Argument given a name."r" Argument not given a name, matched with `_`."Wildr" Return type of a function signature."r" Return type is not specified."r" Functions default to `()` and closures default to type inference."r" A particular type is returned."without_plus/// In some positions, types may not contain the `+` character, to/// disambiguate them. For example in the expression `1 as T`, T may not/// contain a `+` character./// This parser does not allow a `+`, while the default parser does.ambig_tyat_least_one_type// Only allow multiple trait references if allow_plus is true.strip_attrs_pubcheck_keyword_matchesr#" *This type is available only if Syn is built with the `"derive"` or `"full"`"#r" comments. The `tokens` field contains the rest of the attribute body as"r"   path  tokens                 path        tokens"r" # Parsing from tokens to Attribute"r" # Parsing from Attribute to structured arguments"r" The grammar of attributes in Rust is very flexible, which makes the"r" syntax tree not that useful on its own. In particular, arguments of the"r" attribute are held in an arbitrary `tokens: TokenStream`. Macros are"r" expected to check the `path` of the attribute, decide whether they"r" recognize it, and then parse the remaining tokens according to whatever"r" grammar they wish to require for that kind of attribute."r" If the attribute you are parsing is expected to conform to the"r" conventional structured form of attribute, use [`parse_meta()`] to"r" obtain that structured representation. If the attribute follows some"r" other grammar of its own, use [`parse_args()`] to parse that into the"r" expected data structure."r" [`parse_meta()`]: Attribute::parse_meta"r" [`parse_args()`]: Attribute::parse_args"r" # Doc comments"r" The compiler transforms doc comments, such as `/// comment` and `/*!"r" comment */`, into attributes before macros are expanded. Each comment is"r#" expanded into an attribute of the form `#[doc = r"comment"]`."#r" As an example, the following `mod` items are expanded identically:"r" # use syn::{ItemMod, parse_quote};"r" let doc: ItemMod = parse_quote! {"r"     /// Single line doc comments"r"     /// We write so many!"r"     /**"r"      * Multi-line comments..."r"      * May span many lines"r"      */"r"     mod example {"r"         //! Of course, they can be inner too"r"         /*! And fit in a single line */"r" let attr: ItemMod = parse_quote! {"r#"     #[doc = r" Single line doc comments"]"#r#"     #[doc = r" We write so many!"]"#r#"     #[doc = r""#r#"      "]"#r#"         #![doc = r" Of course, they can be inner too"]"#r#"         #![doc = r" And fit in a single line "]"#r" assert_eq!(doc, attr);"/// Parses the content of the attribute, consisting of the path and tokens,/// as a [`Meta`] if possible./// *This function is available only if Syn is built with the `"parsing"`/// Parse the arguments to the attribute as a syntax tree./// This is similar to `syn::parse2::<T>(attr.tokens)` except that:/// - the surrounding delimiters are *not* included in the input to the///   parser; and/// - the error message has a more useful span when `tokens` is empty./// #[my_attr(value < 5)]///           ^^^^^^^^^ what gets parsedparse_args_with/// Parse the arguments to the attribute using the given parser.expected_parenthesesenter_argsr" ## Path"r" A meta path is like the `test` in `#[test]`."r" [syntax tree enum]: Expr#syntax-tree-enums"ast_enum_of_structs_implast_enum_from_structr#" *This type is available only if Syn is built with the `"derive"` or"#r" would be a nested `Meta::Path`."/// # extern crate proc_macro;parse_meta_path// Like Path::parse_mod_style but accepts keywords in the path.parse_meta_after_pathparse_meta_list_after_pathparse_meta_name_value_after_path// See include!("await.rs") in token.rs.// For implementing base10_digits() accessor on LitInt.reserve_two_digits// Assumes increment <16.// Assumes base <=16.// Group entries contain the offset to the matching End entry.// End entries contain the offset (negative) to the start of the buffer.// NOTE: Do not implement clone on this - while the current design could be// cloned, other designs which could be desirable may not be cloneable./// *This type is available only if Syn is built with the `"parsing"` feature.*recursive_new/// *This method is available only if Syn is built with both the `"parsing"` and/// `proc_macro2::TokenStream`.// This is the only `Entry::End` object which this cursor is allowed tobump_ignore_group/// If the cursor is looking at an `Entry::Group`, the bumped cursor will/// point at the first token in the group (with the same scope end)./// While the cursor is looking at a `None`-delimited group, move it to look/// at the first token inside instead. If the group is empty, this will move/// If the cursor is pointing at a `Punct`, returns it along with a cursor/// Skip over the next token without cloning it. Returns `None` if this/// This method treats `'lifetimes` as a single token.same_buffercmp_assuming_same_bufferopen_span_of_groupclose_span_of_group//! *This module is available only if Syn is built with the `"parsing"` feature.*/// [Peeking]: crate::parse::ParseBuffer::peek/// [Parsing]: crate::parse::ParseBuffer::parse/// Returns the number of fields./// Returns `true` if there are zero fields.r#" *This type is available only if Syn is built with the `"derive"` feature.*"#r" An untagged union input to a `proc_macro_derive` macro."r#" *This type is available only if Syn is built with the `"derive"`"#/// an `A`, or that the `A`s are finished and it's time to start parsing///                 ident,///                     ident,TrivialDroptest_needs_drop/// # Error reporting in proc macros/// The correct way to report errors back to the compiler from a procedural/// macro is by emitting an appropriately spanned invocation of/// [`compile_error!`] in the generated code. This produces a better diagnostic/// message than simply panicking the macro./// [`compile_error!`]: std::compile_error!/// When parsing macro input, the [`parse_macro_input!`] macro handles the/// conversion to `compile_error!` automatically./// [`parse_macro_input!`]: crate::parse_macro_input!/// pub fn my_attr(args: TokenStream, input: TokenStream) -> TokenStream {///     # TokenStream::new()/// For errors that arise later than the initial parsing stage, the/// [`.to_compile_error()`] or [`.into_compile_error()`] methods can be used to/// perform an explicit conversion to `compile_error!`./// [`.to_compile_error()`]: Error::to_compile_error/// [`.into_compile_error()`]: Error::into_compile_error/// # use proc_macro::TokenStream;/// # use syn::{parse_macro_input, DeriveInput};/// #[proc_macro_derive(MyDerive)]/// pub fn my_derive(input: TokenStream) -> TokenStream {///     let input = parse_macro_input!(input as DeriveInput);///     // fn(DeriveInput) -> syn::Result<proc_macro2::TokenStream>///     expand::my_derive(input)///         .unwrap_or_else(syn::Error::into_compile_error)///         .into()/// # mod expand {/// #     use proc_macro2::TokenStream;/// #     use syn::{DeriveInput, Result};/// #     pub fn my_derive(input: DeriveInput) -> Result<TokenStream> {/// use syn::{parse_macro_input, DeriveInput, Error};/// # const _: &str = stringify! {/// #[proc_macro_derive(MyTrait)]/// pub fn derive_my_trait(input: TokenStream) -> TokenStream {///     my_trait::expand(input)///         .unwrap_or_else(Error::into_compile_error)/// mod my_trait {///     use proc_macro2::TokenStream;///     use syn::{DeriveInput, Result};///     pub(crate) fn expand(input: DeriveInput) -> Result<TokenStream> {///         # unimplemented!()/// Add another error message to self such that when `to_compile_error()` is/// called, both errors will be emitted together.r#" feature, but most of the variants are not available unless "full" is enabled.*"#r" An await expression: `fut.await`."Awaitr#" *This type is available only if Syn is built with the `"full"` feature.*"#async_tokenawait_tokenbox_tokenbreak_tokenmovabilityasyncnessor1_tokenor2_tokencontinue_tokenif_tokenthen_branchelse_branchlet_tokenloop_tokenmatch_tokenarmsturbofishreturn_tokendot2_tokenquestion_tokentry_tokenunsafe_tokenwhile_tokenyield_tokenreplace_attrsr" The `::<>` explicit type parameters passed to a method call:"r" `parse::<u64>()`."r" An individual generic argument to a method, like `T`."r" A field-value pair in a struct literal."r" Name or index of the field."r" The colon in `Struct { x: x }`. If written in shorthand like"r" `Struct { x }`, there is no colon."r" Value of the field."r" A lifetime labeling a `for`, `while`, or `loop`."r" One arm of a `match` expression: `0...10 => { return true; }`."r" As in:"r" # fn f() -> bool {"r" #     let n = 0;"r" match n {"r"     0...10 => {"r"         return true;"r"     // ..."r" #   false"fat_arrow_tokenr" Limit types of a range, inclusive or exclusive."r" Inclusive at the beginning, exclusive at the end."HalfOpenr" Inclusive at the beginning and end."parse_without_eager_brace/// An alternative to the primary `Expr::parse` parser (from the/// [`Parse`] trait) for ambiguous syntactic positions in which a/// trailing brace should not be taken as part of the expression./// Rust grammar has an ambiguity where braces sometimes turn a path/// expression into a struct initialization and sometimes do not. In the/// following code, the expression `S {}` is one expression. Presumably/// there is an empty struct `struct S {}` defined somewhere which it is/// instantiating./// # struct S;/// # impl std::ops::Deref for S {/// #     type Target = bool;/// #     fn deref(&self) -> &Self::Target {/// #         &true/// let _ = *S {};/// // parsed by rustc as: `*(S {})`/// We would want to parse the above using `Expr::parse` after the `=`/// token./// But in the following, `S {}` is *not* a struct init expression./// # const S: &bool = &true;/// if *S {} {}/// // parsed by rustc as:/// //    if (*S) {/// //        /* empty block *//// //    }/// //    {/// //        /* another empty block *//// For that reason we would want to parse if-conditions using/// `Expr::parse_without_eager_brace` after the `if` token. Same for/// similar syntactic positions such as the condition expr after a/// `while` token or the expr at the top of a `match`./// The Rust grammar's choices around which way this ambiguity is/// resolved at various syntactic positions is fairly arbitrary. Really/// either parse behavior could work in most positions, and language/// designers just decide each case based on which is more likely to be/// what the programmer had in mind most of the time./// # fn doc() -> S {/// if return S {} {}/// //    if (return (S {})) {/// // but could equally well have been this other arbitrary choice:/// //    if (return S) {/// //    {}/// Note the grammar ambiguity on trailing braces is distinct from/// precedence and is not captured by assigning a precedence level to/// the braced struct init expr in relation to other operators. This can/// be illustrated by `return 0..S {}` vs `match 0..S {}`. The former/// parses as `return (0..(S {}))` implying tighter precedence for/// struct init than `..`, while the latter parses as `match (0..S) {}`/// implying tighter precedence for `..` than struct init, a/// contradiction.expr_attrs// <UnOp> <trailer>// & <trailer>// &mut <trailer>// box <trailer>// <atom> (..<args>) ...// <atom> . <ident> (..<args>) ...// <atom> . <ident> ...// <atom> . <lit> ...// <atom> [ <expr> ] ...// <atom> ? ...trailer_helper// Parse all atomic expressions which don't have to worry about precedence// interactions, as they are fully contained.path_or_macro_or_structparen_or_tuplearray_or_repeatexpr_earlyelse_blockexpr_boxclosure_argexpr_retexpr_struct_helpermulti_indexcheck_castwrap_bare_struct// If the given expression is a bare `ExprStruct`, wraps it in parenthesis// before appending it to `TokenStream`.maybe_wrap_else/// *This trait is available only if Syn is built with the `"parsing"` feature.*r" A complete file of Rust source code."r" Parse a Rust source file into a `syn::File` and print out a debug"r" representation of the syntax tree."r" use std::env;"r" use std::fs::File;"r" use std::io::Read;"r" use std::process;"r" # fn fake_main() {"r"     let mut args = env::args();"r"     let _ = args.next(); // executable name"r"     let filename = match (args.next(), args.next()) {"r"         (Some(filename), None) => filename,"r"         _ => {"r#"             eprintln!("Usage: dump-syntax path/to/filename.rs");"#r"             process::exit(1);"r#"     let mut file = File::open(&filename).expect("Unable to open file");"#r"     let mut src = String::new();"r#"     file.read_to_string(&mut src).expect("Unable to read file");"#r#"     let syntax = syn::parse_file(&src).expect("Unable to parse file");"#r#"     // Debug impl is available if Syn is built with "extra-traits" feature."#r#"     println!("{:#?}", syntax);"#r" Running with its own source code as input, this program prints output"r" that begins with:"r" File {"r"     shebang: None,"r"     attrs: [],"r"     items: ["r"         Use("r"             ItemUse {"r"                 attrs: [],"r"                 vis: Inherited,"r"                 use_token: Use,"r"                 leading_colon: None,"r"                 tree: Path("r"                     UsePath {"r"                         ident: Ident("r"                             std,"r"                         ),"r"                         colon2_token: Colon2,"r"                         tree: Name("r"                             UseName {"r"                                 ident: Ident("r"                                     env,"r"                                 ),"r"                             },"r"                     },"r"                 ),"r"                 semi_token: Semi,"r"         ),"fold_expr_awaitfold_pat_orfold_pat_referencefold_pat_restfold_pat_typefold_receiverfold_signaturefold_variadic/// *This trait is available only if Syn is built with the `"fold"` feature.*visit_expr_awaitvisit_pat_orvisit_pat_referencevisit_pat_restvisit_pat_typevisit_receivervisit_signaturevisit_variadic/// *This trait is available only if Syn is built with the `"visit"` feature.*visit_expr_await_mutvisit_pat_or_mutvisit_pat_reference_mutvisit_pat_rest_mutvisit_pat_type_mutvisit_signature_mutvisit_variadic_mut/// *This trait is available only if Syn is built with the `"visit-mut"` feature.*FoldHelpertokens_helper/// *This type is available only if Syn is built with the `"derive"` or `"full"`/// # let generics: syn::Generics = Default::default();/// # let name = Ident::new("MyType", Span::call_site());/// *This method is available only if Syn is built with the `"derive"` orgenerics_wrapper_implsparse_multiplexid_okr" Things that can appear directly inside of a module or scope."r" A constant item: `const MAX: u16 = 65535`."r" An enum definition: `enum Foo<A, B> { A(A), B(B) }`."r" An `extern crate` item: `extern crate serde`."ExternCrater" A free-standing function: `fn process(n: usize) -> Result<()> { ..."r" }`."r#" A block of foreign items: `extern "C" { ... }`."#ForeignModr" An impl block providing trait or associated items: `impl<A> Trait"r" for Data<A> { ... }`."r" A macro invocation, which includes `macro_rules!` definitions."r" A 2.0-style declarative macro introduced by the `macro` keyword."Macro2r" A module or module declaration: `mod m` or `mod m { ... }`."r" A static item: `static BIKE: Shed = Shed(42)`."r" A struct definition: `struct Foo<A> { x: A }`."r" A trait definition: `pub trait Iterator { ... }`."r" A trait alias: `pub trait SharableIterator = Iterator + Sync`."TraitAliasr" A type alias: `type Result<T> = std::result::Result<T, MyError>`."r" A union definition: `union Foo<A, B> { x: A, y: B }`."r" A use declaration: `use std::collections::HashMap`."r" Tokens forming an item not interpreted by Syn."r" Trait this impl implements."trait_r" The Self type of the impl."r" The `example` in `macro_rules! example { ... }`."macro_tokenmod_tokensemistatic_tokenauto_tokentrait_tokentype_tokenr" A suffix of an import tree in a `use` item: `Type as Renamed` or `*`."r" A path prefix of imports in a `use` item: `std::...`."r" An identifier imported by a `use` item: `HashMap`."r" An renamed identifier imported by a `use` item: `HashMap as Map`."r" A glob import in a `use` item: `*`."r" A braced group of imports in a `use` item: `{A, B, C}`."r" An item within an `extern` block."r" A foreign function in an `extern` block."r" A foreign static item in an `extern` block: `static ext: u8`."r" A foreign type in an `extern` block: `type void`."r" A macro invocation within an extern block."r" Tokens in an `extern` block not interpreted by Syn."r" An item declaration within the definition of a trait."r" An associated constant within the definition of a trait."r" A trait method within the definition of a trait."r" An associated type within the definition of a trait."r" A macro invocation within the definition of a trait."r" Tokens within the definition of a trait not interpreted by Syn."r" An item within an impl block."r" An associated constant within an impl block."r" A method within an impl block."r" An associated type within an impl block."r" A macro invocation within an impl block."r" Tokens within an impl block not interpreted by Syn."r" A function signature in a trait or implementation: `unsafe fn"r" initialize(&self)`."constness/// A method's `self` receiver, such as `&self` or `self: Box<Self>`.r" An argument in a function signature: the `n: usize` in `fn f(n: usize)`."r" The `self` argument of an associated method, whether taken by value"r" or by reference."r" Note that `self` receivers with a specified type, such as `self:"r" Box<Self>`, are parsed as a `FnArg::Typed`."r" A function argument accepted by pattern and type."Typedself_tokenFlexibleItemTypeWhereClauseLocationBeforeEq// type Ty<T> where T: 'static = T;AfterEq// type Ty<T> = T where T: 'static;// TODO: goes away once the migration period on rust-lang/rust#89122 is overpop_variadicvariadic_to_tokenspeek_signatureparse_rest_of_fnparse_fn_argsfn_arg_typedparse_foreign_item_typeparse_item_typeparse_trait_item_typeparse_implparse_impl_item_typemaybe_variadic_to_tokensdrops/// Each method of the [`Visit`] trait is a hook that can be overridden to/// customize the behavior when visiting the corresponding type of node. By/// default, every method recursively visits the substructure of the input/// by invoking the right visitor method of each of its fields./// [`Visit`]: visit::Visit/// # use syn::{Attribute, BinOp, Expr, ExprBinary};/// pub trait Visit<'ast> {///     fn visit_expr_binary(&mut self, node: &'ast ExprBinary) {///         visit_expr_binary(self, node);///     # fn visit_attribute(&mut self, node: &'ast Attribute);///     # fn visit_expr(&mut self, node: &'ast Expr);///     # fn visit_bin_op(&mut self, node: &'ast BinOp);/// pub fn visit_expr_binary<'ast, V>(v: &mut V, node: &'ast ExprBinary)///     V: Visit<'ast> + ?Sized,///     for attr in &node.attrs {///         v.visit_attribute(attr);///     v.visit_expr(&*node.left);///     v.visit_bin_op(&node.op);///     v.visit_expr(&*node.right);/// /* ... *//// *This module is available only if Syn is built with the `"visit"` feature.*/// This visitor will print the name of every freestanding function in the/// syntax tree, including nested functions./// // [dependencies]/// // quote = "1.0"/// // syn = { version = "1.0", features = ["full", "visit"] }/// use syn::visit::{self, Visit};/// use syn::{File, ItemFn};/// struct FnVisitor;/// impl<'ast> Visit<'ast> for FnVisitor {///     fn visit_item_fn(&mut self, node: &'ast ItemFn) {///         println!("Function with name={}", node.sig.ident);///         // Delegate to the default impl to visit any nested functions.///         visit::visit_item_fn(self, node);///     let code = quote! {///         pub fn f() {///             fn g() {}///     let syntax_tree: File = syn::parse2(code).unwrap();///     FnVisitor.visit_file(&syntax_tree);/// The `'ast` lifetime on the input references means that the syntax tree/// outlives the complete recursive visit call, so the visitor is allowed to/// hold on to references into the syntax tree./// struct FnVisitor<'ast> {///     functions: Vec<&'ast ItemFn>,/// impl<'ast> Visit<'ast> for FnVisitor<'ast> {///         self.functions.push(node);///     let mut visitor = FnVisitor { functions: Vec::new() };///     visitor.visit_file(&syntax_tree);///     for f in visitor.functions {///         println!("Function with name={}", f.sig.ident);/// Each method of the [`Fold`] trait is a hook that can be overridden to/// customize the behavior when transforming the corresponding type of node./// By default, every method recursively visits the substructure of the/// input by invoking the right visitor method of each of its fields./// [`Fold`]: fold::Fold/// pub trait Fold {///     fn fold_expr_binary(&mut self, node: ExprBinary) -> ExprBinary {///         fold_expr_binary(self, node)///     # fn fold_attribute(&mut self, node: Attribute) -> Attribute;///     # fn fold_expr(&mut self, node: Expr) -> Expr;///     # fn fold_bin_op(&mut self, node: BinOp) -> BinOp;/// pub fn fold_expr_binary<V>(v: &mut V, node: ExprBinary) -> ExprBinary///     V: Fold + ?Sized,///     ExprBinary {///         attrs: node///             .attrs///             .into_iter()///             .map(|attr| v.fold_attribute(attr))///             .collect(),///         left: Box::new(v.fold_expr(*node.left)),///         op: v.fold_bin_op(node.op),///         right: Box::new(v.fold_expr(*node.right)),/// *This module is available only if Syn is built with the `"fold"` feature.*/// This fold inserts parentheses to fully parenthesizes any expression./// // syn = { version = "1.0", features = ["fold", "full"] }/// use syn::fold::{fold_expr, Fold};/// use syn::{token, Expr, ExprParen};/// struct ParenthesizeEveryExpr;/// impl Fold for ParenthesizeEveryExpr {///     fn fold_expr(&mut self, expr: Expr) -> Expr {///         Expr::Paren(ExprParen {///             attrs: Vec::new(),///             expr: Box::new(fold_expr(self, expr)),///             paren_token: token::Paren::default(),///     let code = quote! { a() + b(1) * c.d };///     let expr: Expr = syn::parse2(code).unwrap();///     let parenthesized = ParenthesizeEveryExpr.fold_expr(expr);///     println!("{}", quote!(#parenthesized));///     // Output: (((a)()) + (((b)((1))) * ((c).d)))"export.rs"/// *This function is available only if Syn is built with both the `"parsing"` and/// when the input comes from a node of the Syn syntax tree, for example the/// body tokens of a [`Macro`] node. When in a procedural macro parsing the/// *This function is available only if Syn is built with the `"parsing"` feature.*parse_file// FIXME the name parse_file makes it sound like you might pass in a path to a// file, rather than the content./// Parse the content of a file of Rust code./// This is different from `syn::parse_str::<File>(content)` in two ways:/// - It discards a leading byte order mark `\u{FEFF}` if the file has one./// - It preserves the shebang line of the file, such as `#!/usr/bin/env rustx`./// If present, either of these would be an error using `from_str`./// *This function is available only if Syn is built with the `"parsing"` and/// `"full"` features.*/// fn run() -> Result<(), Box<Error>> {///     let mut file = File::open("path/to/code.rs")?;///     let mut content = String::new();///     file.read_to_string(&mut content)?;///     let ast = syn::parse_file(&content)?;///     if let Some(shebang) = ast.shebang {///         println!("{}", shebang);///     println!("{} items", ast.items.len());//! [![github]](https://github.com/dtolnay/syn)&ensp;[![crates-io]](https://crates.io/crates/syn)&ensp;[![docs-rs]](crate)//! - **Derives** — Of particular interest to derive macros is//!   derive implementations of a user-defined trait.//! [`syn::File`]: File//! [`syn::Item`]: Item//! [`syn::Expr`]: Expr//! [`syn::Type`]: Type//! [`syn::DeriveInput`]: DeriveInput//! [parser functions]: mod@parse//! # Example of a derive macro//! The canonical derive macro using Syn looks like this. We write an ordinary//! [`TokenStream`]: proc_macro::TokenStream//! syn = "1.0"//! The [`heapsize`] example directory shows a complete working implementation//! of a derive macro. It works on any Rust compiler 1.31+. The example derives//! a `HeapSize` trait which computes an estimate of the amount of heap memory//! owned by a value.//! The derive macro allows users to write `#[derive(HeapSize)]` on data//! <p><br></p>//! # Spans and error reporting//! # Parsing a custom syntax//! # Debugging//!   possible input to a derive macro, including structs and enums and types.r" [syntax tree enum]: crate::Expr#syntax-tree-enums"r" Must be finite. May not be infinite or NaN."r" A raw token literal not interpreted by Syn."LitReprLitIntReprLitFloatReprbase10_digitsbase10_parse/// Parses the literal into a selected number type./// This is equivalent to `lit.base10_digits().parse()` except that the/// resulting errors will be correctly spanned to point to the literal token/// in the macro input./// use syn::LitInt;/// use syn::parse::{Parse, ParseStream, Result};/// struct Port {///     value: u16,/// impl Parse for Port {///         let lit: LitInt = input.parse()?;///         let value = lit.base10_parse::<u16>()?;///         Ok(Port { value })debug_implsparse_negative_lit// Returns (content, suffix).// Returns (value, suffix).// Returns base 10 digits and suffix./// Consuming tokens from the source stream after constructing a lookahead/// object does not also advance the lookahead object.delimiter_span_close/// This is equivalent to `syn::parse2::<T>(mac.tokens)` except that it/// produces a more useful span when `tokens` is empty.// Drop the `#no_visit` attribute, if present.// No From<TokenStream> for verbatim variants./// Refer to the [module documentation] for details about implementing and using/// the `Parse` trait./// [syn-parse]: self#the-synparse-functions/// # use syn::parse::Parser;/// # let remainder = remainder_after_skipping_past_next_at/// #     .parse_str("a @ b c")/// #     .unwrap();/// # assert_eq!(remainder.to_string(), "b c");cell_clone// We call this on Cell<Unexpected> and Cell<Option<T>> where temporarily// swapping in a None is cheap.inner_unexpectedspan_of_unexpected_ignoring_nones///             trait_token,///             ident,///             generics,///             colon_token,///             supertraits,/// # let input = quote! {/// #     struct S(A, B);/// # syn::parse2::<TupleStruct>(input).unwrap();///                     pub_token,///             pub_token,/// Returns the `Span` of the next token in the parse stream, or/// `Span::call_site()` if this parse stream has completely exhausted its/// input `TokenStream`.__parse_streamparse_stream/// An empty syntax tree node that consumes no tokens when parsed./// This is useful for attribute macros that want to ensure they are not/// provided any attribute args./// use syn::parse_macro_input;/// use syn::parse::Nothing;///     parse_macro_input!(args as Nothing);/// error: unexpected token///  --> src/main.rs:3:19/// 3 | #[my_attr(asdf)]///   |           ^^^^//! [`Result<T>`]: Result//! [`Cursor`]: crate::buffer::Cursor//! [`parse_macro_input!`]: crate::parse_macro_input!//! [`syn::parse`]: crate::parse()//! [`syn::parse2`]: crate::parse2()//! [`syn::parse_str`]: crate::parse_str()//! # run_parser().unwrap();//! [`parse_quote!`]: crate::parse_quote!//! [`Attribute`]: crate::Attribute//! [`Punctuated`]: crate::punctuated/// [`parse` module]: mod@crate::parse/// This macro must be called from a function that returns/// `proc_macro::TokenStream`. Usually this will be your proc macro entry point,/// the function that has the #\[proc_macro\] / #\[proc_macro_derive\] //// #\[proc_macro_attribute\] attribute./// # Usage with Parser/// This macro can also be used with the [`Parser` trait] for types that have/// multiple ways that they can be parsed./// [`Parser` trait]: crate::parse::Parser/// # use syn::{parse_macro_input, Result};/// # struct MyMacroInput {}/// impl MyMacroInput {///     fn parse_alternate(input: ParseStream) -> Result<Self> {///     let input = parse_macro_input!(tokens with MyMacroInput::parse_alternate);/// # Expansion/// `parse_macro_input!($variable as $Type)` expands to something like:/// # macro_rules! doc_test {/// #     ($variable:ident as $Type:ty) => {/// match syn::parse::<$Type>($variable) {///     Ok(syntax_tree) => syntax_tree,///     Err(err) => return proc_macro::TokenStream::from(err.to_compile_error()),/// # fn test(input: proc_macro::TokenStream) -> proc_macro::TokenStream {/// #     let _ = doc_test!(input as syn::Ident);/// #     proc_macro::TokenStream::new()/// [`quote!`]: https://docs.rs/quote/1.0/quote/index.html/// [`Parse`]: crate::parse::Parse/// *This macro is available only if Syn is built with the `"parsing"` feature,/// - [`Vec<Stmt>`] — parses the same as `Block::parse_within`/// [`Vec<Stmt>`]: Block::parse_within/// This macro is [`parse_quote!`] + [`quote_spanned!`][quote::quote_spanned]./// Please refer to each of their documentation./// use quote::{quote, quote_spanned};/// use syn::spanned::Spanned;/// use syn::{parse_quote_spanned, ReturnType, Signature};/// // Changes `fn()` to `fn() -> Pin<Box<dyn Future<Output = ()>>>`,/// // and `fn() -> T` to `fn() -> Pin<Box<dyn Future<Output = T>>>`,/// // without introducing any call_site() spans./// fn make_ret_pinned_future(sig: &mut Signature) {///     let ret = match &sig.output {///         ReturnType::Default => quote_spanned!(sig.paren_token.span=> ()),///         ReturnType::Type(_, ret) => quote!(#ret),///     sig.output = parse_quote_spanned! {ret.span()=>///         -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = #ret>>>r" A pattern in a local binding, function signature, match expression, or"r" various other places."r" A box pattern: `box v`."r" A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`."r" A literal pattern: `0`."r" This holds an `Expr` rather than a `Lit` because negative numbers"r" are represented as an `Expr::Unary`."r" A macro in pattern position."r" A pattern that matches any one of a set of cases."r" A path pattern like `Color::Red`, optionally qualified with a"r" self-type."r" Unqualified path patterns can legally refer to variants, structs,"r" constants or associated constants. Qualified path patterns like"r" `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to"r" associated constants."r" A range pattern: `1..=2`."r" A reference pattern: `&mut var`."r" The dots in a tuple or slice pattern: `[0, 1, ..]`"r" A dynamically sized slice pattern: `[a, b, ref i @ .., y, z]`."r" A struct or struct variant pattern: `Variant { x, y, .. }`."r" A tuple pattern: `(a, b)`."r" A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`."r" A type ascription pattern: `foo: f64`."r" Tokens in pattern position not interpreted by Syn."r" A pattern that matches any value: `_`."r" It may also be a unit struct or struct variant (e.g. `None`), or a"r" constant; these cannot be distinguished syntactically."subpatleading_vertr" A single field in a struct pattern."r" Patterns like the fields of Foo `{ x, ref y, ref mut z }` are treated"r" the same as `x: x, y: ref y, z: ref mut z` but there is no colon token."pat_path_or_macro_or_struct_or_rangepat_boxpat_rangepat_range_half_openpat_lit_or_rangepat_lit_exprpat_constmulti_patmulti_pat_with_leading_vertmulti_pat_implr" A path at which a named item is exported (e.g. `std::collections::HashMap`)."const_argumentconstraint_bounds///   path arguments, and/// - the ident of the first path segment is equal to the given one./// use syn::{Attribute, Error, Meta, NestedMeta, Result};/// # use std::iter::FromIterator;/// fn get_serde_meta_items(attr: &Attribute) -> Result<Vec<NestedMeta>> {///     if attr.path.is_ident("serde") {///         match attr.parse_meta()? {///             Meta::List(meta) => Ok(Vec::from_iter(meta.nested)),///             bad => Err(Error::new_spanned(bad, "unrecognized attribute")),///         Ok(Vec::new())get_ident/// If this path consists of a single ident, returns the ident./// A path is considered an ident if:/// - the number of path segments is 1, and///   path arguments./// Borrows the first element in this sequence./// Mutably borrows the first element in this sequence./// Borrows the last element in this sequence./// Mutably borrows the last element in this sequence./// Clears the sequence of all values and punctuation, making it empty.IterMutTraitpunct_mut/// Mutably borrows the punctuation from this punctuated pair, unless the/// pair is the final one and there is no trailing punctuation./// # use syn::punctuated::Punctuated;/// # use syn::{parse_quote, Token, TypeParamBound};/// # let mut punctuated = Punctuated::<TypeParamBound, Token![+]>::new();/// punctuated.insert(0, parse_quote!('lifetime));/// if let Some(punct) = punctuated.pairs_mut().next().unwrap().punct_mut() {///     punct.span = span;//! [`Punctuated<T, P>`]: Punctuated//!                 ~~~~^ ~~~~^ ~~~~// Type for a syntax tree node that is reserved for future use.// For example ExprReference contains a field `raw` of type Reserved. If `&raw// place` syntax becomes a thing as per https://github.com/rust-lang/rfcs/pull/2582,// we can backward compatibly change `raw`'s type to Option<Token![raw]> without// the possibility of breaking any code./// [`ToTokens`] from the `quote` crate, as well as for `Span` itself./// *This trait is available only if Syn is built with both the `"parsing"` and//! *This module is available only if Syn is built with both the `"parsing"` and//! [`Type`]: crate::Type//! [`Sync`]: std::marker::Sync//! The underlying [`proc_macro::Span::join`] method is nightly-only. When//! called from within a procedural macro in a nightly compiler, `Spanned` will//! use `join` to produce the intended span. When not using a nightly compiler,//! only the span of the *first token* of the syntax tree node is returned.//! In the common case of wanting to use the joined span as the span of a//! `syn::Error`, consider instead using [`syn::Error::new_spanned`] which is//! able to span the error correctly under the complete syntax tree node without//! needing the unstable `join`.//! [`syn::Error::new_spanned`]: crate::Error::new_spannedr" A braced block containing Rust statements."r" Statements in a block"stmtsr" A statement, usually ending in a semicolon."r" A local (let) binding."r" An item definition."r" Expr without trailing semicolon."r" Expression with trailing semicolon."r" A local `let` binding: `let x: u64 = s.parse()?`."parse_within/// Parse the body of a block as zero or more statements, possibly/// including one trailing expression./// use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token};/// // Parse a function with no generics or parameter list./// //     fn playground {/// //         let mut x = 1;/// //         x += 1;/// //         println!("{}", x);/// struct MiniFunction {///     fn_token: Token![fn],///     stmts: Vec<Stmt>,/// impl Parse for MiniFunction {///         let outer_attrs = input.call(Attribute::parse_outer)?;///         let fn_token: Token![fn] = input.parse()?;///         let name: Ident = input.parse()?;///         let brace_token = braced!(content in input);///         let inner_attrs = content.call(Attribute::parse_inner)?;///         let stmts = content.call(Block::parse_within)?;///         Ok(MiniFunction {///             attrs: {///                 let mut attrs = outer_attrs;///                 attrs.extend(inner_attrs);///                 attrs///             fn_token,///             name,///             brace_token,///             stmts,parse_stmtstmt_macstmt_localstmt_exprimpl_low_level_tokenr" Don't try to remember the name of this type &mdash; use the"r" [`Token!`] macro instead."r" `await`"// Old rustc does not permit `await` appearing anywhere in the source file.// https://github.com/rust-lang/rust/issues/57919// We put the Token![await] rule in a place that is not lexed by old rustc.//! [`Token!`]: crate::Token//! [`ItemStatic`]: crate::ItemStatic//! [`ParseStream::parse`]: crate::parse::ParseBuffer::parse()//! [`parenthesized!`]: crate::parenthesized!//! [`bracketed!`]: crate::bracketed!//! [`braced!`]: crate::braced!//! [Peeking]: crate::parse::ParseBuffer::peek()//! [Parsing]: crate::parse::ParseBuffer::parse()//! [Printing]: https://docs.rs/quote/1.0/quote/trait.ToTokens.html//! [`Span`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.htmlr" A trait object type `dyn Bound1 + Bound2 + Bound3` where `Bound` is a"r" The variadic argument of a foreign function."r" # struct c_char;"r" # struct c_int;"r#" extern "C" {"#r"     fn printf(format: *const c_char, ...) -> c_int;"r"     //                               ^^^"dotsparse_bare_fnparse_boundsparse_bare_fn_argr" An attribute, like `#[repr(transparent)]`."r" - Outer one-line doc comments like `/// Example`."r" - Inner one-line doc comments like `//! Please file an issue`."r" - Outer documentation blocks `/** Example */`."r" - Inner documentation blocks `/*! Please file an issue */`."r" is outer or inner."r" Every attribute has a `path` that indicates the intended interpretation"r" of the rest of the attribute's contents. The path and the optional"r" additional contents are represented together in the `meta` field of the"r" attribute in three possible varieties:"r" - Meta::Path &mdash; attributes whose information content conveys just a"r"   path, for example the `#[test]` attribute."r" - Meta::List &mdash; attributes that carry arbitrary tokens after the"r"   path, surrounded by a delimiter (parenthesis, bracket, or brace). For"r"   example `#[derive(Copy)]` or `#[precondition(x < 5)]`."r" - Meta::NameValue &mdash; attributes with an `=` sign after the path,"r"   followed by a Rust expression. For example `#[path ="r#"   "sys/windows.rs"]`."#r" All doc comments are represented in the NameValue style with a path of"r#" "doc", as this is how they are processed by the compiler and by"#r" #[derive(Copy, Clone)]"r"   ~~~~~~Path"r"   ^^^^^^^^^^^^^^^^^^^Meta::List"r#" #[path = "sys/windows.rs"]"#r"   ~~~~Path"r"   ^^^^^^^^^^^^^^^^^^^^^^^Meta::NameValue"r" #[test]"r"   ^^^^Meta::Path"r" [`Parse`]: crate::parse::Parse"r" [`ParseStream::parse`]: crate::parse::ParseBuffer::parse"r" [`ParseStream::call`]: crate::parse::ParseBuffer::call"r" `Meta::List` variety of attribute are held in an arbitrary `tokens:"r" TokenStream`. Macros are expected to check the `path` of the attribute,"r" decide whether they recognize it, and then parse the remaining tokens"r" according to whatever grammar they wish to require for that kind of"r" attribute. Use [`parse_args()`] to parse those tokens into the expected"r" data structure."/// Returns the path that identifies the interpretation of this attribute./// This is similar to pulling out the `TokenStream` from `Meta::List` and/// doing `syn::parse2::<T>(meta_list.tokens)`, except that using/// `parse_args` the error message has a more useful span when `tokens` is/// The surrounding delimiters are *not* included in the input to the/// use syn::{parse_quote, Attribute, Expr};/// let attr: Attribute = parse_quote! {///     #[precondition(value < 5)]/// if attr.path().is_ident("precondition") {///     let precondition: Expr = attr.parse_args()?;/// # anyhow::Ok(())/// use syn::{parse_quote, Attribute};///     #[inception { #[brrrrrrraaaaawwwwrwrrrmrmrmmrmrmmmmm] }]/// let bwom = attr.parse_args_with(Attribute::parse_outer)?;/// // Attribute does not have a Parse impl, so we couldn't directly do:/// // let bwom: Attribute = attr.parse_args()?;parse_nested_meta/// Parse the arguments to the attribute, expecting it to follow the/// conventional structure used by most of Rust's built-in attributes./// The [*Meta Item Attribute Syntax*][syntax] section in the Rust reference/// explains the convention in more detail. Not all attributes follow this/// convention, so [`parse_args()`][Self::parse_args] is available if you/// need to parse arbitrarily goofy attribute syntax./// [syntax]: https://doc.rust-lang.org/reference/attributes.html#meta-item-attribute-syntax/// We'll parse a struct, and then parse some of Rust's `#[repr]` attribute/// syntax./// use syn::{parenthesized, parse_quote, token, ItemStruct, LitInt};/// let input: ItemStruct = parse_quote! {///     #[repr(C, align(4))]///     pub struct MyStruct(u16, u32);/// let mut repr_c = false;/// let mut repr_transparent = false;/// let mut repr_align = None::<usize>;/// let mut repr_packed = None::<usize>;/// for attr in &input.attrs {///     if attr.path().is_ident("repr") {///         attr.parse_nested_meta(|meta| {///             // #[repr(C)]///             if meta.path.is_ident("C") {///                 repr_c = true;///                 return Ok(());///             // #[repr(transparent)]///             if meta.path.is_ident("transparent") {///                 repr_transparent = true;///             // #[repr(align(N))]///             if meta.path.is_ident("align") {///                 let content;///                 parenthesized!(content in meta.input);///                 let lit: LitInt = content.parse()?;///                 let n: usize = lit.base10_parse()?;///                 repr_align = Some(n);///             // #[repr(packed)] or #[repr(packed(N))], omitted N means 1///             if meta.path.is_ident("packed") {///                 if meta.input.peek(token::Paren) {///                     let content;///                     parenthesized!(content in meta.input);///                     let lit: LitInt = content.parse()?;///                     let n: usize = lit.base10_parse()?;///                     repr_packed = Some(n);///                     repr_packed = Some(1);///             Err(meta.error("unrecognized repr"))///         })?;/// In some cases, for attributes which have nested layers of structured/// content, the following less flexible approach might be more convenient:/// # use syn::{parse_quote, ItemStruct};/// # let input: ItemStruct = parse_quote! {/// #     #[repr(C, align(4))]/// #     pub struct MyStruct(u16, u32);/// use syn::{parenthesized, token, Error, LitInt, Meta, Token};///         let nested = attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?;///         for meta in nested {///             match meta {///                 // #[repr(C)]///                 Meta::Path(path) if path.is_ident("C") => {///                     repr_c = true;///                 // #[repr(align(N))]///                 Meta::List(meta) if meta.path.is_ident("align") => {///                     let lit: LitInt = meta.parse_args()?;///                     repr_align = Some(n);///                 /* ... *////                 _ => {///                     return Err(Error::new_spanned(meta, "unrecognized repr"));/// [*Parsing from tokens to Attribute*](#parsing-from-tokens-to-attribute).r" [syntax tree enum]: crate::expr::Expr#syntax-tree-enums"/// Returns the path that begins this structured meta item.require_path_only/// Error if this is a `Meta::List` or `Meta::NameValue`.require_list/// Error if this is a `Meta::Path` or `Meta::NameValue`.require_name_value/// Error if this is a `Meta::Path` or `Meta::List`./// See [`Attribute::parse_args`]./// See [`Attribute::parse_args_with`]./// See [`Attribute::parse_nested_meta`].parse_outermost_meta_path// Unlike meta::parse_meta_path which accepts arbitrary keywords in the path,// only the `unsafe` keyword is accepted as an attribute's outermost path.DisplayAttrStyleDisplayPathPathStyle// End entries contain the offset (negative) to the start of the buffer, and// offset (negative) to the matching Group entry.any_group/// If the cursor is pointing at a `Group`, returns a cursor into the group/// and one pointing to the next `TokenTree`.any_group_tokenprev_span/// Returns the `Span` of the token immediately prior to the position of/// this cursor, or of the current token if there is no previous one./// Skip over the next token that is not a None-delimited group, without/// cloning it. Returns `None` if this cursor points to eof.scope_delimiterstart_of_bufferrequires_semi_to_be_stmtrequires_comma_to_be_match_armtrailing_unparameterized_pathexpr_leading_label/// Whether the expression's first token is the label of a loop/block.expr_trailing_brace/// Whether the expression's last token is `}`.restrictionFieldMutabilityreturn_impl_traitr" Get an iterator over the fields of a struct or variant as [`Member`]s."r" This iterator can be used to iterate over a named or unnamed struct or"r" variant's fields uniformly."r" The following is a simplistic [`Clone`] derive for structs. (A more"r" complete implementation would additionally want to infer trait bounds on"r" the generic type parameters.)"r" fn derive_clone(input: &syn::ItemStruct) -> proc_macro2::TokenStream {"r"     let ident = &input.ident;"r"     let members = input.fields.members();"r"     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();"r"     quote! {"r"         impl #impl_generics Clone for #ident #ty_generics #where_clause {"r"             fn clone(&self) -> Self {"r"                 Self {"r"                     #(#members: self.#members.clone()),*"r"                 }"r" For structs with named fields, it produces an expression like `Self { a:"r" self.a.clone() }`. For structs with unnamed fields, `Self { 0:"r" self.0.clone() }`. And for unit structs, `Self {}`."parse_any_delimiter/// Returns the delimiter, the span of the delimiter token, and the nested/// contents for further parsing.AnyDelimiter/// Extensions to the `ParseStream` API to support manipulating invisible/// delimiters the same as if they were visible./// use syn::{parse_macro_input, ItemFn};///     let args = parse_macro_input!(args as MyAttrArgs);/// struct MyAttrArgs {///     # _k: [(); { stringify! {///     # }; 0 }]/// impl Parse for MyAttrArgs {///         # stringify! {// errors to be Send and Sync to play nicely with ecosystem crates for error// handling, so pin the span we're given to its original thread and assume// it is Span::call_site if accessed from any other thread.// Cannot use std::ops::Range<Span> because that does not implement Copy,// whereas ThreadBound<T> requires a Copy impl as a way to ensure no Drop impls// are involved.print_punctr" A binary operation: `a + b`, `a += b`."r" A const block: `const { ... }`."r" The inferred value of a const generic argument, denoted `_`."r" Address-of operation: `&raw const place` or `&raw mut place`."ExprRawAddrRawAddrPointerMutabilityPLACEHOLDER/// An unspecified invalid expression./// use quote::ToTokens;/// use syn::{parse_quote, Expr};/// fn unparenthesize(e: &mut Expr) {///     while let Expr::Paren(paren) = e {///         *e = mem::replace(&mut *paren.expr, Expr::PLACEHOLDER);///     let mut e: Expr = parse_quote! { ((1 + 1)) };///     unparenthesize(&mut e);///     assert_eq!("1 + 1", e.to_token_stream().to_string());/// An alternative to the primary `Expr::parse` parser (from the [`Parse`]/// trait) for ambiguous syntactic positions in which a trailing brace/// should not be taken as part of the expression./// `Expr::parse_without_eager_brace` after the `if` token. Same for similar/// syntactic positions such as the condition expr after a `while` token or/// the expr at the top of a `match`./// The Rust grammar's choices around which way this ambiguity is resolved/// at various syntactic positions is fairly arbitrary. Really either parse/// behavior could work in most positions, and language designers just/// decide each case based on which is more likely to be what the programmer/// had in mind most of the time./// precedence and is not captured by assigning a precedence level to the/// braced struct init expr in relation to other operators. This can be/// illustrated by `return 0..S {}` vs `match 0..S {}`. The former parses as/// `return (0..(S {}))` implying tighter precedence for struct init than/// `..`, while the latter parses as `match (0..S) {}` implying tighter/// precedence for `..` than struct init, a contradiction.parse_with_earlier_boundary_rule/// trait) for syntactic positions in which expression boundaries are placed/// more eagerly than done by the typical expression grammar. This includes/// expressions at the head of a statement or in the right-hand side of a/// `match` arm./// Compare the following cases:/// 1.///   # let result = ();///   # let guard = false;///   # let cond = true;///   # let f = true;///   # let g = f;///   #///   let _ = match result {///       () if guard => if cond { f } else { g }///       () => false,///   # let f = ();///   let _ = || {///       if cond { f } else { g }///       ()/// 3.///   # let f = || ();///   let _ = [if cond { f } else { g } ()];/// The same sequence of tokens `if cond { f } else { g } ()` appears in/// expression position 3 times. The first two syntactic positions use eager/// placement of expression boundaries, and parse as `Expr::If`, with the/// adjacent `()` becoming `Pat::Tuple` or `Expr::Tuple`. In contrast, the/// third case uses standard expression boundaries and parses as/// `Expr::Call`./// As with [`parse_without_eager_brace`], this ambiguity in the Rust/// grammar is independent of precedence./// [`parse_without_eager_brace`]: Self::parse_without_eager_brace/// Returns whether the next token in the parse stream is one that might/// possibly form the beginning of an expr./// This classification is a load-bearing part of the grammar of some Rust/// expressions, notably `return` and `break`. For example `return < …` will/// never parse `<` as a binary operator regardless of what comes after,/// because `<` is a legal starting token for an expression and so it's/// required to be continued as a return value, such as `return <Struct as/// Trait>::CONST`. Meanwhile `return > …` treats the `>` as a binary/// operator because it cannot be a starting token for any Rust expression.r" One arm of a `match` expression: `0..=10 => { return true; }`."r"     0..=10 => {"r" Mutability of a raw pointer (`*const T`, `*mut T`), in which non-mutable"r" isn't the implicit default."parse_binop_rhsatom_labeledexpr_builtinrest_of_path_or_macro_or_structcontinue_parsing_earlyexpr_becomeparse_range_endparse_obsoletefixupFixupContextprint_subexpressionprint_exprprint_expr_assignprint_expr_awaitprint_expr_binaryprint_expr_breakprint_expr_callprint_expr_castprint_expr_closureprint_expr_fieldprint_expr_indexprint_expr_letprint_expr_method_callprint_expr_rangeprint_expr_raw_addrprint_expr_referenceprint_expr_returnprint_expr_tryprint_expr_unaryprint_expr_yieldr" Typically `File` objects are created with [`parse_file`]."r" [`parse_file`]: crate::parse_file"r" use std::fs;"r#"     let src = fs::read_to_string(&filename).expect("unable to read file");"#r#"     let syntax = syn::parse_file(&src).expect("unable to parse file");"#previous_operatornext_operator// Print expression such that it can be parsed back as a statement// consisting of the original expression.// The effect of this is for binary operators in statement position to set// `leftmost_subexpression_in_stmt` when printing their left-hand operand.//     (match x {}) - 1;  // match needs parens when LHS of binary operator//     match x {};  // not when its own statementleftmost_subexpression_in_stmt// This is the difference between://     (match x {}) - 1;  // subexpression needs parens//     let _ = match x {} - 1;  // no parens// There are 3 distinguishable contexts in which `print_expr` might be// called with the expression `$match` as its argument, where `$match`// represents an expression of kind `ExprKind::Match`://   - stmt=false leftmost_subexpression_in_stmt=false//     Example: `let _ = $match - 1;`//     No parentheses required.//   - stmt=false leftmost_subexpression_in_stmt=true//     Example: `$match - 1;`//     Must parenthesize `($match)`, otherwise parsing back the output as a//     statement would terminate the statement after the closing brace of//     the match, parsing `-1;` as a separate statement.//   - stmt=true leftmost_subexpression_in_stmt=false//     Example: `$match;`match_arm// Print expression such that it can be parsed as a match arm.// This is almost equivalent to `stmt`, but the grammar diverges a tiny bit// between statements and match arms when it comes to braced macro calls.// Macro calls with brace delimiter terminate a statement without a// semicolon, but do not terminate a match-arm without comma.//     m! {} - 1;  // two statements: a macro call followed by -1 literal//     match () {//         _ => m! {} - 1,  // binary subtraction operatorleftmost_subexpression_in_match_arm// This is almost equivalent to `leftmost_subexpression_in_stmt`, other than// for braced macro calls.// If we have `m! {} - 1` as an expression, the leftmost subexpression// `m! {}` will need to be parenthesized in the statement case but not the// match-arm case.//     (m! {}) - 1;  // subexpression needs parens//         _ => m! {} - 1,  // no parens//     if let _ = (Struct {}) {}  // needs parens//         () if let _ = Struct {} => {}  // no parensrightmost_subexpression_in_condition//     if break Struct {} == (break) {}  // needs parens//     if break break == Struct {} {}  // no parensleftmost_subexpression_in_optional_operand//     if break ({ x }).field + 1 {}  needs parens//     if break 1 + { x }.field {}  // no parensnext_operator_can_begin_expr//     let _ = (return) - 1;  // without paren, this would return -1//     let _ = return + 1;  // no paren because '+' cannot begin exprnext_operator_can_continue_expr//     let _ = 1 + return 1;  // no parens if rightmost subexpression//     let _ = 1 + (return 1) + 1;  // needs parensnext_operator_can_begin_generics//     let _ = x as u8 + T;//     let _ = (x as u8) < T;// Without parens, the latter would want to parse `u8<T...` as a type./// The default amount of fixing is minimal fixing. Fixups should be turned/// on in a targeted fashion where needed.new_stmt/// Create the initial fixup for printing an expression in statementnew_match_arm/// Create the initial fixup for printing an expression as the right-hand/// side of a match arm.new_condition/// Create the initial fixup for printing an expression as the "condition"/// of an `if` or `while`. There are a few other positions which are/// grammatically equivalent and also use this, such as the iterator/// expression in `for` and the scrutinee in `match`.leftmost_subexpression_with_operator/// Transform this fixup into the one that should apply when printing the/// leftmost subexpression of the current expression./// The leftmost subexpression is any subexpression that has the same first/// token as the current expression, but has a different last token./// For example in `$a + $b` and `$a.method()`, the subexpression `$a` is a/// leftmost subexpression./// Not every expression has a leftmost subexpression. For example neither/// `-$a` nor `[$a]` have one.leftmost_subexpression_with_dot/// Transform this fixup into the one that should apply when printing a/// leftmost subexpression followed by a `.` or `?` token, which confer/// different statement boundary rules compared to other leftmostleftmost_subexpression_precedencerightmost_subexpression/// rightmost subexpression of the current expression./// The rightmost subexpression is any subexpression that has a different/// first token than the current expression, but has the same last token./// For example in `$a + $b` and `-$b`, the subexpression `$b` is a/// rightmost subexpression./// Not every expression has a rightmost subexpression. For example neither/// `[$b]` nor `$a.f($b)` have one.rightmost_subexpression_fixuprightmost_subexpression_precedenceparenthesize/// Determine whether parentheses are needed around the given expression to/// head off the early termination of a statement or condition./// Determines the effective precedence of a subexpression. Some expressions/// have higher or lower precedence when adjacent to particular operators.BailoutConsumescan_leftscan_rightCapturedParamImplRestrictionLocalInitPreciseCaptureStmtMacrofold_assoc_constfold_assoc_typefold_attributesfold_bare_variadicfold_captured_paramfold_expr_constfold_expr_inferfold_expr_raw_addrfold_field_mutabilityfold_impl_item_fnfold_impl_restrictionfold_lifetime_paramfold_lit_cstrfold_local_initfold_pat_parenfold_pointer_mutabilityfold_precise_capturefold_static_mutabilityfold_stmt_macrofold_trait_item_fnfold_vecvisit_assoc_constvisit_assoc_typevisit_bare_variadicvisit_captured_paramvisit_expr_constvisit_expr_infervisit_expr_raw_addrvisit_field_mutabilityvisit_impl_item_fnvisit_impl_restrictionvisit_lifetime_paramvisit_lit_cstrvisit_local_initvisit_pat_parenvisit_pointer_mutabilityvisit_precise_capturevisit_static_mutabilityvisit_stmt_macrovisit_trait_item_fnvisit_assoc_const_mutvisit_assoc_type_mutvisit_attributes_mutvisit_bare_variadic_mutvisit_captured_param_mutvisit_expr_const_mutvisit_expr_infer_mutvisit_expr_raw_addr_mutvisit_field_mutability_mutvisit_impl_item_fn_mutvisit_impl_restriction_mutvisit_lifetime_param_mutvisit_lit_cstr_mutvisit_local_init_mutvisit_pat_paren_mutvisit_pointer_mutability_mutvisit_precise_capture_mutvisit_static_mutability_mutvisit_stmt_macro_mutvisit_trait_item_fn_mutr" This struct represents two distinct optional syntactic elements,"r" [generic parameters] and [where clause]. In some locations of the"r" grammar, there may be other tokens in between these two things."r" [generic parameters]: https://doc.rust-lang.org/stable/reference/items/generics.html#generic-parameters"r" [where clause]: https://doc.rust-lang.org/stable/reference/items/generics.html#where-clauses"r" A lifetime parameter: `'a: 'b + 'c + 'd`."r" Iterator over the lifetime parameters in `self.params`."r" Iterator over the type parameters in `self.params`."r" Iterator over the constant parameters in `self.params`."r" Precise capturing bound: the 'use&lt;&hellip;&gt;' in `impl Trait +"r" use<'a, T>`."r" Single parameter in a precise capturing bound."r" A lifetime parameter in precise capturing bound: `fn f<'a>() -> impl"r" Trait + use<'a>`."r" A type parameter or const generic parameter in precise capturing"r" bound: `fn f<T>() -> impl Trait + use<T>` or `fn f<const K: T>() ->"r" impl Trait + use<K>`."print_const_argument///             fields: content.parse_terminated(Type::parse, Token![,])?,///             fields: content.parse_terminated(Field::parse, Token![,])?,pub_if_not_docr" A free-standing function: `fn process(n: usize) -> Result<()> { ... }`."r" An associated function within the definition of a trait."r" An associated function within an impl block."r" The `self` argument of an associated method."r" If `colon_token` is present, the receiver is written with an explicit"r" type such as `self: Box<Self>`. If `colon_token` is absent, the receiver"r" is written in shorthand such as `self` or `&self` or `&mut self`. In the"r" shorthand case, the type in `ty` is reconstructed as one of `Self`,"r" `&Self`, or `&mut Self`."DotDotDotr" The mutability of an `Item::Static` or `ForeignItem::Static`."r" Unused, but reserved for RFC 3323 restrictions."parse_rest_of_itemTypeDefaultnessparse_optional_boundsparse_optional_definitionparse_macro2parse_item_useparse_use_treeFnArgOrVariadicparse_fn_arg_or_variadicparse_impl_item_fn// https://github.com/rust-lang/rust-clippy/issues/10410// https://github.com/dtolnay/syn/issues/1566PatConst/// // syn = { version = "2.0", features = ["full", "visit"] }/// Each method of the [`VisitMut`] trait is a hook that can be overridden/// to customize the behavior when mutating the corresponding type of node./// [`VisitMut`]: visit_mut::VisitMut/// pub trait VisitMut {///     fn visit_expr_binary_mut(&mut self, node: &mut ExprBinary) {///         visit_expr_binary_mut(self, node);///     # fn visit_attribute_mut(&mut self, node: &mut Attribute);///     # fn visit_expr_mut(&mut self, node: &mut Expr);///     # fn visit_bin_op_mut(&mut self, node: &mut BinOp);/// pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary)///     V: VisitMut + ?Sized,///     for attr in &mut node.attrs {///         v.visit_attribute_mut(attr);///     v.visit_expr_mut(&mut *node.left);///     v.visit_bin_op_mut(&mut node.op);///     v.visit_expr_mut(&mut *node.right);/// This mut visitor replace occurrences of u256 suffixed integer literals/// like `999u256` with a macro invocation `bigint::u256!(999)`./// // syn = { version = "2.0", features = ["full", "visit-mut"] }/// use syn::visit_mut::{self, VisitMut};/// use syn::{parse_quote, Expr, File, Lit, LitInt};/// struct BigintReplace;/// impl VisitMut for BigintReplace {///     fn visit_expr_mut(&mut self, node: &mut Expr) {///         if let Expr::Lit(expr) = &node {///             if let Lit::Int(int) = &expr.lit {///                 if int.suffix() == "u256" {///                     let digits = int.base10_digits();///                     let unsuffixed: LitInt = syn::parse_str(digits).unwrap();///                     *node = parse_quote!(bigint::u256!(#unsuffixed));///                     return;///         // Delegate to the default impl to visit nested expressions.///         visit_mut::visit_expr_mut(self, node);///         fn main() {///             let _ = 999u256;///     let mut syntax_tree: File = syn::parse2(code).unwrap();///     BigintReplace.visit_file_mut(&mut syntax_tree);///     println!("{}", quote!(#syntax_tree));// https://github.com/rust-lang/rustfmt/issues/6176/// This function enforces that the input is fully parsed. If there are any/// unparsed tokens at the end of the stream, an error is returned./// fn run() -> Result<(), Box<dyn Error>> {///     let content = fs::read_to_string("path/to/code.rs")?;//! syn = "2.0"//! of a derive macro. The example derives a `HeapSize` trait which computes an//! estimate of the amount of heap memory owned by a value.r#" A nul-terminated C-string literal: `c"foo"`."#/// use syn::{Attribute, Error, Expr, Lit, Meta, Path, Result};///     if !attr.path().is_ident("path") {///     if let Meta::NameValue(meta) = &attr.meta {///         if let Expr::Lit(expr) = &meta.value {///             if let Lit::Str(lit_str) = &expr.lit {///                 return lit_str.parse().map(Some);///     let message = "expected #[path = \"...\"]";///     Err(Error::new_spanned(attr, message))/// An ordinary string like `"data"`./// A raw string like `r##"data"##`./// The unsigned integer is the number of `#` symbols used./// The style of a string literal, either plain quoted or a raw string like/// `r##"data"##`.parse_lit_c_strparse_lit_c_str_cookedparse_lit_c_str_raw/// use syn::{ConstParam, Ident, Lifetime, LifetimeParam, Result, Token, TypeParam};///     Lifetime(LifetimeParam),/// Pseudo-token used for peeking the end of a parse stream./// This type is only useful as an argument to one of the following functions:/// - [`ParseStream::peek`][crate::parse::ParseBuffer::peek]/// - [`ParseStream::peek2`][crate::parse::ParseBuffer::peek2]/// - [`ParseStream::peek3`][crate::parse::ParseBuffer::peek3]/// - [`Lookahead1::peek`]/// The peek will return `true` if there are no remaining tokens after that/// point in the parse stream./// Suppose we are parsing attributes containing core::fmt inspired formatting/// arguments:/// - `#[fmt("simple example")]`/// - `#[fmt("interpolation e{}ample", self.x)]`/// - `#[fmt("interpolation e{x}ample")]`/// and we want to recognize the cases where no interpolation occurs so that/// more efficient code can be generated./// The following implementation uses `input.peek(Token![,]) &&/// input.peek2(End)` to recognize the case of a trailing comma without/// consuming the comma from the parse stream, because if it isn't a trailing/// comma, that same comma needs to be parsed as part of `args`./// use syn::parse::{End, Parse, ParseStream, Result};/// use syn::{parse_quote, Attribute, LitStr, Token};///     template: LitStr,  // "...{}..."///     args: TokenStream, // , self.x///         let template: LitStr = input.parse()?;///         let args = if input.is_empty()///             || input.peek(Token![,]) && input.peek2(End)///             input.parse::<Option<Token![,]>>()?;///             TokenStream::new()///             input.parse()?///             template,///             args,///     let attrs: Vec<Attribute> = parse_quote! {///         #[fmt("simple example")]///         #[fmt("interpolation e{}ample", self.x)]///         #[fmt("interpolation e{x}ample")]///     for attr in &attrs {///         let FormatArgs { template, args } = attr.parse_args()?;///         let requires_fmt_machinery =///             !args.is_empty() || template.value().contains(['{', '}']);///         let out = if requires_fmt_machinery {///             quote! {///                 ::core::write!(__formatter, #template #args)///                 __formatter.write_str(#template)///         println!("{}", out);/// Implementing this parsing logic without `peek2(End)` is more clumsy because/// we'd need a parse stream actually advanced past the comma before being able/// to find out whether there is anything after it. It would look something/// like:/// # use syn::parse::{ParseStream, Result};/// # use syn::Token;/// # fn parse(input: ParseStream) -> Result<()> {/// use syn::parse::discouraged::Speculative as _;/// let ahead = input.fork();/// ahead.parse::<Option<Token![,]>>()?;/// let args = if ahead.is_empty() {///     input.advance_to(&ahead);///     TokenStream::new()///     input.parse()?/// or:/// use quote::ToTokens as _;/// let comma: Option<Token![,]> = input.parse()?;/// let mut args = TokenStream::new();/// if !input.is_empty() {///     comma.to_tokens(&mut args);///     input.parse::<TokenStream>()?.to_tokens(&mut args);/// Make a parser that is usable with `parse_macro_input!` in a/// `#[proc_macro_attribute]` macro./// *Warning:* When parsing attribute args **other than** the/// `proc_macro::TokenStream` input of a `proc_macro_attribute`, you do **not**/// need this function. In several cases your callers will get worse error/// messages if you use this function, because the surrounding delimiter's span/// is concealed from attribute macros by rustc. Use/// [`Attribute::parse_nested_meta`] instead./// [`Attribute::parse_nested_meta`]: crate::Attribute::parse_nested_meta/// This example implements an attribute macro whose invocations look like this:/// #[tea(kind = "EarlGrey", hot)]/// struct Picard {...}/// The "parameters" supported by the attribute are:/// - `kind = "..."`/// - `hot`/// - `with(sugar, milk, ...)`, a comma-separated list of ingredients/// use syn::{parse_macro_input, LitStr, Path};/// pub fn tea(args: TokenStream, input: TokenStream) -> TokenStream {///     let mut kind: Option<LitStr> = None;///     let mut hot: bool = false;///     let mut with: Vec<Path> = Vec::new();///     let tea_parser = syn::meta::parser(|meta| {///         if meta.path.is_ident("kind") {///             kind = Some(meta.value()?.parse()?);///         } else if meta.path.is_ident("hot") {///             hot = true;///         } else if meta.path.is_ident("with") {///             meta.parse_nested_meta(|meta| {///                 with.push(meta.path);///             Err(meta.error("unsupported tea property"))///     parse_macro_input!(args with tea_parser);///     eprintln!("kind={kind:?} hot={hot} with={with:?}");/// #   TokenStream::new()/// The `syn::meta` library will take care of dealing with the commas including/// trailing commas, and producing sensible error messages on unexpected input./// error: expected `,`///  --> src/main.rs:3:37/// 3 | #[tea(kind = "EarlGrey", with(sugar = "lol", milk))]///   |                                     ^/// Same as above but we factor out most of the logic into a separate function./// use syn::meta::ParseNestedMeta;/// use syn::parse::{Parser, Result};///     let mut attrs = TeaAttributes::default();///     let tea_parser = syn::meta::parser(|meta| attrs.parse(meta));/// struct TeaAttributes {///     kind: Option<LitStr>,///     hot: bool,///     with: Vec<Path>,/// impl TeaAttributes {///     fn parse(&mut self, meta: ParseNestedMeta) -> Result<()> {///             self.kind = Some(meta.value()?.parse()?);///         } else /* just like in last example *//// #           { unimplemented!() }/// Context for parsing a single property in the conventional syntax for/// structured attributes./// Refer to usage examples on the following two entry-points:/// - [`Attribute::parse_nested_meta`] if you have an entire `Attribute` to///   parse. Always use this if possible. Generally this is able to produce///   better error messages because `Attribute` holds span information for all///   of the delimiters therein./// - [`syn::meta::parser`] if you are implementing a `proc_macro_attribute`///   macro and parsing the arguments to the attribute macro, i.e. the ones///   written in the same attribute that dispatched the macro invocation. Rustc///   does not pass span information for the surrounding delimiters into the///   attribute macro invocation in this situation, so error messages might be///   less precise./// [`syn::meta::parser`]: crate::meta::parser/// Used when parsing `key = "value"` syntax./// All it does is advance `meta.input` past the `=` sign in the input. You/// could accomplish the same effect by writing/// `meta.parse::<Token![=]>()?`, so at most it is a minor convenience to/// use `meta.value()?`./// use syn::{parse_quote, Attribute, LitStr};///     #[tea(kind = "EarlGrey")]///                                          // conceptually:/// if attr.path().is_ident("tea") {         // this parses the `tea`///     attr.parse_nested_meta(|meta| {      // this parses the `(`///         if meta.path.is_ident("kind") {  // this parses the `kind`///             let value = meta.value()?;   // this parses the `=`///             let s: LitStr = value.parse()?;  // this parses `"EarlGrey"`///             if s.value() == "EarlGrey" {///                 // ...///             Err(meta.error("unsupported attribute"))/// Used when parsing `list(...)` syntax **if** the content inside the/// nested parentheses is also expected to conform to Rust's structured/// attribute convention.///     #[tea(with(sugar, milk))]/// if attr.path().is_ident("tea") {///     attr.parse_nested_meta(|meta| {///         if meta.path.is_ident("with") {///             meta.parse_nested_meta(|meta| {  // <---///                 if meta.path.is_ident("sugar") {///                     // Here we can go even deeper if needed.///                     Ok(())///                 } else if meta.path.is_ident("milk") {///                     Err(meta.error("unsupported ingredient"))/// # Counterexample/// If you don't need `parse_nested_meta`'s help in parsing the content/// written within the nested parentheses, keep in mind that you can always/// just parse it yourself from the exposed ParseStream. Rust syntax permits/// arbitrary tokens within those parentheses so for the crazier stuff,/// `parse_nested_meta` is not what you want./// use syn::{parenthesized, parse_quote, Attribute, LitInt};///     #[repr(align(32))]/// let mut align: Option<LitInt> = None;/// if attr.path().is_ident("repr") {///         if meta.path.is_ident("align") {///             let content;///             parenthesized!(content in meta.input);///             align = Some(content.parse()?);///             Err(meta.error("unsupported repr"))/// Report that the attribute's content did not conform to expectations./// The span of the resulting error will cover `meta.path` *and* everything/// that has been parsed so far since it./// There are 2 ways you might call this. First, if `meta.path` is not/// something you recognize:/// # use syn::Attribute;/// # fn example(attr: &Attribute) -> syn::Result<()> {/// attr.parse_nested_meta(|meta| {///     if meta.path.is_ident("kind") {///         Err(meta.error("unsupported tea property"))/// In this case, it behaves exactly like/// `syn::Error::new_spanned(&meta.path, "message...")`./// error: unsupported tea property///  --> src/main.rs:3:26/// 3 | #[tea(kind = "EarlGrey", wat = "foo")]///   |                          ^^^/// More usefully, the second place is if you've already parsed a value but/// have decided not to accept the value:///         let expr: Expr = meta.value()?.parse()?;///         match expr {///             Expr::Lit(expr) => /* ... *//// #               unimplemented!(),///             Expr::Path(expr) => /* ... *////             Expr::Macro(expr) => /* ... *////             _ => Err(meta.error("tea kind must be a string literal, path, or macro")),///     } else /* as above *//// #       { unimplemented!() }/// error: tea kind must be a string literal, path, or macro///  --> src/main.rs:3:7/// 3 | #[tea(kind = async { replicator.await })]///   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^/// Often you may want to use `syn::Error::new_spanned` even in this/// situation. In the above code, that would be:/// # use syn::{Error, Expr};/// # fn example(expr: Expr) -> syn::Result<()> {///     match expr {///         Expr::Lit(expr) => /* ... *//// #           unimplemented!(),///         Expr::Path(expr) => /* ... *////         Expr::Macro(expr) => /* ... *////         _ => Err(Error::new_spanned(expr, "unsupported expression type for `kind`")),/// error: unsupported expression type for `kind`///  --> src/main.rs:3:14///   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^// Like Path::parse_mod_style, but accepts keywords in the path.//! Facility for interpreting structured content inside of an `Attribute`.PlusEqMinusEqStarEqSlashEqPercentEq/// - `input.peek(syn::Ident)`&emsp;*(does not accept keywords)*/// - `input.peek(syn::Ident::peek_any)`/// If your separator is anything more complicated than an invocation of the/// `Token!` macro, this method won't be applicable and you can instead/// directly use `Punctuated`'s parser functions: [`parse_terminated`],/// [`parse_separated_nonempty`] etc./// use syn::{custom_keyword, Expr, Result, Token};///     syn::custom_keyword!(fin);/// struct Fin(kw::fin, Token![;]);/// impl Parse for Fin {///         Ok(Self(input.parse()?, input.parse()?))/// struct Thing {///     steps: Punctuated<Expr, Fin>,/// impl Parse for Thing {/// # if true {///         Ok(Thing {///             steps: Punctuated::parse_terminated(input)?,///         // or equivalently, this means the same thing:/// #       Ok(Thing {///             steps: input.call(Punctuated::parse_terminated)?,/// #       })/// Returns whether there are no more tokens remaining to be parsed from/// this stream./// This method returns true upon reaching the end of the content within a/// set of delimiters, as well as at the end of the tokens provided to the/// outermost parsing entry point./// <code>.<a href="#method.peek">peek</a>(<a href="struct.End.html">syn::parse::End</a>)</code>./// Use `.peek2(End)` or `.peek3(End)` to look for the end of a parse stream/// further ahead than the current position./// use syn::buffer::Cursor;/// use syn::parse::{ParseStream, Result};/// // Run a parser that returns T, but get its output as TokenStream instead of T./// // This works without T needing to implement ToTokens./// fn recognize_token_stream<T>(///     recognizer: fn(ParseStream) -> Result<T>,/// ) -> impl Fn(ParseStream) -> Result<TokenStream> {///     move |input| {///         let begin = input.cursor();///         recognizer(input)?;///         let end = input.cursor();///         Ok(tokens_between(begin, end))/// // Collect tokens between two cursors as a TokenStream./// fn tokens_between(begin: Cursor, end: Cursor) -> TokenStream {///     assert!(begin <= end);///     let mut cursor = begin;///     while cursor < end {///         let (token, next) = cursor.token_tree().unwrap();///         tokens.extend(std::iter::once(token));///         cursor = next;///     tokens///     use quote::quote;///     use syn::parse::{Parse, Parser};///     use syn::Token;///     // Parse syn::Type as a TokenStream, surrounded by angle brackets.///     fn example(input: ParseStream) -> Result<TokenStream> {///         let _langle: Token![<] = input.parse()?;///         let ty = recognize_token_stream(syn::Type::parse)(input)?;///         let _rangle: Token![>] = input.parse()?;///         Ok(ty)///     let tokens = quote! { <fn() -> u8> };///     println!("{}", example.parse2(tokens).unwrap());/// unparsed tokens at the end of the string, an error is returned.err_unexpected_token//!             fields: content.parse_terminated(Field::parse_named, Token![,])?,//! #   TokenStream::new()/// *This macro is available only if Syn is built with both the `"parsing"` and/// - [`Vec<Attribute>`] — parses multiple attributes, including mixed kinds in///   any order/// - [`Vec<Arm>`] — parses arms separated by optional commas according to the///   same grammar as the inside of a `match` expression/// - [`Pat`], [`Box<Pat>`] — parses the same as///   `Pat::parse_multi_with_leading_vert`/// - [`Field`] — parses a named or unnamed struct field/// [`Vec<Attribute>`]: Attribute/// [`Vec<Arm>`]: Arm/// [`Pat`]: Pat::parse_multi_with_leading_vert/// [`Box<Pat>`]: Pat::parse_multi_with_leading_vertr" A parenthesized pattern: `(A | B)`."r" The dots in a tuple or slice pattern: `[0, 1, ..]`."/// Parse a pattern that does _not_ involve `|` at the top level./// This parser matches the behavior of the `$:pat_param` macro_rules/// matcher, and on editions prior to Rust 2021, the behavior of/// `$:pat`./// In Rust syntax, some examples of where this syntax would occur are/// in the argument pattern of functions and closures. Patterns using/// `|` are not allowed to occur in these positions./// fn f(Some(_) | None: Option<T>) {///     let _ = |Some(_) | None: Option<T>| {};///     //       ^^^^^^^^^^^^^^^^^^^^^^^^^??? :(/// error: top-level or-patterns are not allowed in function parameters///  --> src/main.rs:1:6/// 1 | fn f(Some(_) | None: Option<T>) {///   |      ^^^^^^^^^^^^^^ help: wrap the pattern in parentheses: `(Some(_) | None)`parse_multi/// Parse a pattern, possibly involving `|`, but not a leading `|`.parse_multi_with_leading_vert/// Parse a pattern, possibly involving `|`, possibly including a/// leading `|`./// This parser matches the behavior of the Rust 2021 edition's `$:pat`/// macro_rules matcher./// In Rust syntax, an example of where this syntax would occur is in/// the pattern of a `match` arm, where the language permits an optional/// leading `|`, although it is not idiomatic to write one there in/// handwritten code./// # let wat = None;/// match wat {///     | None | Some(false) => {}///     | Some(true) => {}/// The compiler accepts it only to facilitate some situations in/// macro-generated code where a macro author might need to write:/// # macro_rules! doc {/// #     ($value:expr, ($($conditions1:pat),*), ($($conditions2:pat),*), $then:expr) => {/// match $value {///     $(| $conditions1)* $(| $conditions2)* => $then/// # doc!(true, (true), (false), {});/// # doc!(true, (), (true, false), {});/// # doc!(true, (true, false), (), {});/// Expressing the same thing correctly in the case that either one (but/// not both) of `$conditions1` and `$conditions2` might be empty,/// without leading `|`, is complex./// Use [`Pat::parse_multi`] instead if you are not intending to support/// macro-generated macro input.pat_paren_or_tuplePatRangeBound// Patterns that can appear on either side of a range pattern.into_exprinto_patpat_range_bound/// use syn::{Attribute, Error, Meta, Result};/// fn get_serde_meta_item(attr: &Attribute) -> Result<Option<&TokenStream>> {///     if attr.path().is_ident("serde") {///         match &attr.meta {///             Meta::List(meta) => Ok(Some(&meta.tokens)),require_ident/// An error if this path is not a single ident, as defined in `get_ident`.r" An equality constraint on an associated constant: the `PANIC ="r" false` in `Trait<PANIC = false>`."r" A binding (equality constraint) on an associated type: the `Item = u8`"r" in `Iterator<Item = u8>`."r" An equality constraint on an associated constant: the `PANIC = false` in"r" `Trait<PANIC = false>`."parse_turbofish/// Parse `::<…>` with mandatory leading `::`./// The ordinary [`Parse`] impl for `AngleBracketedGenericArguments`/// parses optional leading `::`.is_mod_styleAsWrittenprint_path_segmentprint_path_argumentsprint_angle_bracketed_generic_argumentsprint_parenthesized_generic_argumentsprint_qpathconditionally_print_turbofish// return, break, closures// = += -= *= /= %= &= |= ^= <<= >>=// .. ..=// ||// &&// let// == != < > <= >=// |// ^// &// << >>// + -// * / %// as// unary - * ! & &mutUnambiguous// paths, loops, function calls, array indexing, field expressions, method calls// Reference: https://doc.rust-lang.org/reference/expressions.html#expression-precedenceof_binop/// **A punctuated sequence of syntax tree nodes of type `T` separated by/// punctuation of type `P`.**/// Borrows the element at the given index./// Mutably borrows the element at the given index./// sequence must already have a trailing punctuation, or be empty./// Panics if the sequence is nonempty and does not already have a trailingpop_punct/// Removes the trailing punctuation from this punctuated sequence, or/// `None` if there isn't any.do_extendConsumeAnyConsumeBinOpConsumeBraceConsumeDelimiterConsumeIdentConsumeLifetimeConsumeLiteralConsumeNestedBraceExpectPathExpectTurbofishExpectTypeCanBeginExprOtherwiseSetStateIncDepthDecDepthPOSTFIXBREAK_LABELBREAK_VALUECLOSURECLOSURE_ARGSCLOSURE_RETCONSTDOTFORIF_ELSEIF_THENMETHODPATTERNRETURNscan_exprr" Expression, with or without trailing semicolon."r" A macro invocation in statement position."r" Syntactically it's ambiguous which other kind of statement this"r" macro would expand to. It can be any of local variable (`let`),"r" item, or expression."r" The expression assigned in a local `let` binding, including optional"r" diverging `else` block."r" `LocalInit` represents `= s.parse()?` in `let x: u64 = s.parse()?` and"r" `= r else { return }` in `let Ok(x) = r else { return }`."diverger" Syntactically it's ambiguous which other kind of statement this macro"r" would expand to. It can be any of local variable (`let`), item, or"AllowNoSemi// Today Copy and Drop are mutually exclusive so `T: Copy` implies `T: !Drop`.// This impl needs to be revisited if that restriction is relaxed in the future.// Copy the bytes of T, even if the currently running thread is the "wrong"// thread. This is fine as long as the original thread is not simultaneously// mutating this value via interior mutability, which would be a data race.// Currently `T: Copy` is sufficient to guarantee that T contains no interior// mutability, because _all_ interior mutability in Rust is built on// std::cell::UnsafeCell, which has no Copy impl. This impl needs to be// revisited if that restriction is relaxed in the future.// False positive: https://github.com/rust-lang/rust/issues/78586#issuecomment-1722680482r" Usage:"/// None-delimited groupr" `{`&hellip;`}`"r" `[`&hellip;`]`"r" `(`&hellip;`)`"/// A type-macro that expands to the name of the Rust type representation of a/// given token./// As a type, `Token!` is commonly used in the type of struct fields, the type/// of a `let` statement, or in turbofish for a `parse` function./// use syn::{Ident, Token};/// // `struct Foo;`/// pub struct UnitStruct {///         let struct_token: Token![struct] = input.parse()?;///         let semi_token = input.parse::<Token![;]>()?;///         Ok(UnitStruct { struct_token, ident, semi_token })/// As an expression, `Token!` is used for peeking tokens or instantiating/// tokens from a span./// # use syn::{Ident, Token};/// # use syn::parse::{Parse, ParseStream, Result};/// # struct UnitStruct {/// #     struct_token: Token![struct],/// #     ident: Ident,/// #     semi_token: Token![;],/// # impl Parse for UnitStruct {/// #     fn parse(input: ParseStream) -> Result<Self> {/// fn make_unit_struct(name: Ident) -> UnitStruct {///     let span = name.span();///     UnitStruct {///         struct_token: Token![struct](span),///         ident: name,///         semi_token: Token![;](span),/// if input.peek(Token![struct]) {///     let unit_struct: UnitStruct = input.parse()?;/// See the [token module] documentation for details and examples./// [token module]: crate::tokenr" The variadic argument of a function pointer like `fn(usize, ...)`."parse_bare_variadic/// A mutual exclusion primitive that relies on static type information only/// In some cases synchronization can be proven statically: whenever you hold an exclusive `&mut`/// reference, the Rust type system ensures that no other part of the program can hold another/// reference to the data. Therefore it is safe to access it even if the current thread obtained/// this reference via a channel. Whenever this is the case, the overhead of allocating and locking/// a [`Mutex`] can be avoided by using this static version./// One example where this is often applicable is [`Future`], which requires an exclusive reference/// for its [`poll`] method: While a given `Future` implementation may not be safe to access by/// multiple threads concurrently, the executor can only run the `Future` on one thread at any/// given time, making it [`Sync`] in practice as long as the implementation is `Send`. You can/// therefore use the static mutex to prove that your data structure is `Sync` even though it/// contains such a `Future`./// use sync_wrapper::SyncWrapper;/// struct MyThing {///     future: SyncWrapper<Box<dyn Future<Output = String> + Send>>,/// impl MyThing {///     // all accesses to `self.future` now require an exclusive reference or ownership/// fn assert_sync<T: Sync>() {}/// assert_sync::<MyThing>();/// [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html/// [`Future`]: https://doc.rust-lang.org/std/future/trait.Future.html/// [`poll`]: https://doc.rust-lang.org/std/future/trait.Future.html#method.poll/// Creates a new static mutex containing the given value./// let mutex = SyncWrapper::new(42);/// This is safe because it requires an exclusive reference to the mutex. Therefore this method/// let mut mutex = SyncWrapper::new(42);/// let value = mutex.get_mut();/// assert_eq!(*mutex.get_mut(), 0);/// Acquires a pinned reference to the protected value./// See [`Self::get_mut`] for why this method is safe.///     struct FutureWrapper<F> {///         inner: SyncWrapper<F>,/// impl<F: Future> Future for FutureWrapper<F> {///     type Output = F::Output;///     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {///         self.project().inner.get_pin_mut().poll(cx)/// This is safe because it requires ownership of the mutex, therefore this method will neither/// assert_eq!(mutex.into_inner(), 42);SyncFuture/// `Future` which is `Sync`./// use sync_wrapper::{SyncWrapper, SyncFuture};/// let fut = async { 1 };/// let fut = SyncFuture::new(fut);SyncStream/// `Stream` which is `Sync`./// use sync_wrapper::SyncStream;/// use futures::stream;/// let st = stream::iter(vec![1]);/// let st = SyncStream::new(st);/*
 * Copyright 2020 Actyx AG
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *///! A mutual exclusion primitive that relies on static type information only//! This library is inspired by [this discussion](https://internals.rust-lang.org/t/what-shall-sync-mean-across-an-await/12020/2).// re-export the quote! macro so we can depend on it being around in our macro's// implementations.// NOTE: This module has documentation hidden, as it only exports macros (which// always appear in the root of the crate) and helper methods / re-exports used// in the implementation of those macros.AddBounds/// Add for fields and generics/// Fields only/// Generics only/// Changes how bounds are addedBindStylegenerics_fuse// Internal method for merging seen_generics arrays together.fetch_generics// Internal method for extracting the set of generics which have been matched.merge_generics// Internal method to merge two Generics objects together intelligently./// Helper method which does the same thing as rustc 1.20's/// `Option::get_or_insert_with`. This method is used to keep backwards/// compatibility with rustc 1.15./// The name which this `BindingInfo` will bind to./// The type of binding which this `BindingInfo` will create.// These are used to determine which type parameters are avaliable.seen_generics// The original index of the binding// this will not change when .filter() is called/// Information about a specific binding. This contains both an `Ident`/// reference to the given field, and the syn `&'a Field` descriptor for that/// This type supports `quote::ToTokens`, so can be directly used within the/// `quote!` macro. It expands to a reference to the matched field./// Returns a reference to the underlying `syn` AST node which this/// `BindingInfo` references/// Generates the pattern fragment for this field binding./// # use synstructure::*;/// let di: syn::DeriveInput = syn::parse_quote! {///     enum A {///         B{ a: i32, b: i32 },///         C(u32),/// let s = Structure::new(&di);///     s.variants()[0].bindings()[0].pat().to_string(),///     quote! {///         ref __binding_0///     }.to_string()referenced_ty_params/// Returns a list of the type parameters which are referenced in this/// field's type./// If the field contains any macros in type position, all parameters will/// be considered bound. This is because we cannot determine which type/// parameters are bound by type macros.///     struct A<T, U> {///         a: Option<T>,///         b: U,/// let mut s = Structure::new(&di);///     s.variants()[0].bindings()[0].referenced_ty_params(),///     &[&quote::format_ident!("T")]VariantAst/// This type is similar to `syn`'s `Variant` type, however each of the fields/// are references rather than owned. When this is used as the AST for a real/// variant, this struct simply borrows the fields of the `syn::Variant`,/// however this type may also be used as the sole variant for a struct.// The original length of `bindings` before any `.filter()` callsVariantInfo/// A wrapper around a `syn::DeriveInput`'s variant which provides utilities/// for destructuring `Variant`s with `match` expressions.get_ty_params/// Helper function used by the `VariantInfo` constructor. Walks all of the types/// in `field` and returns a list of the type parameters from `ty_params` which/// are referenced in the field./// Returns a slice of the bindings in this Variant.bindings_mut/// Returns a mut slice of the bindings in this Variant./// Returns a `VariantAst` object which contains references to the/// underlying `syn` AST node which this `Variant` was created from.omitted_bindings/// True if any bindings were omitted due to a `filter` call./// Generates the match-arm pattern which could be used to match against this Variant.///         B(i32, i32),///     s.variants()[0].pat().to_string(),///     quote!{///         A::B(ref __binding_0, ref __binding_1,)/// Generates the token stream required to construct the current variant./// The init array initializes each of the fields in the order they are/// written in `variant.ast().fields`.///         B(usize, usize),///         C{ v: usize },///     s.variants()[0].construct(|_, i| quote!(#i)).to_string(),///         A::B(0usize, 1usize,)///     s.variants()[1].construct(|_, i| quote!(#i)).to_string(),///         A::C{ v: 0usize, }each/// Runs the passed-in function once for each bound field, passing in a `BindingInfo`./// and generating a `match` arm which evaluates the returned tokens./// This method will ignore fields which are ignored through the `filter`///     s.variants()[0].each(|bi| quote!(println!("{:?}", #bi))).to_string(),///         A::B(ref __binding_0, ref __binding_1,) => {///             { println!("{:?}", __binding_0) }///             { println!("{:?}", __binding_1) }/// Runs the passed-in function once for each bound field, passing in the/// result of the previous call, and a `BindingInfo`. generating a `match`/// arm which evaluates to the resulting tokens.///     s.variants()[0].fold(quote!(0), |acc, bi| quote!(#acc + #bi)).to_string(),///             0 + __binding_0 + __binding_1/// Filter the bindings created by this `Variant` object. This has 2 effects:/// * The bindings will no longer appear in match arms generated by methods///   on this `Variant` or its subobjects./// * Impl blocks created with the `bound_impl` or `unsafe_bound_impl`///   method only consider type parameters referenced in the types of///   non-filtered fields.///         C{ a: u32 },/// s.variants_mut()[0].filter(|bi| {///     bi.ast().ident == Some(quote::format_ident!("b"))///     s.each(|bi| quote!(println!("{:?}", #bi))).to_string(),///         A::B{ b: ref __binding_1, .. } => {///         A::C{ a: ref __binding_0, } => {/// Iterates all the bindings of this `Variant` object and uses a closure to determine if a/// binding should be removed. If the closure returns `true` the binding is removed from the/// variant. If the closure returns `false`, the binding remains in the variant./// All the removed bindings are moved to a new `Variant` object which is otherwise identical/// to the current one. To understand the effects of removing a binding from a variant check/// the [`VariantInfo::filter`] documentation./// let mut with_b = &mut s.variants_mut()[0];/// let with_a = with_b.drain_filter(|bi| {///     bi.ast().ident == Some(quote::format_ident!("a"))///     with_a.each(|bi| quote!(println!("{:?}", #bi))).to_string(),///         A::B{ a: ref __binding_0, .. } => {///     with_b.each(|bi| quote!(println!("{:?}", #bi))).to_string(),remove_binding/// Remove the binding at the given index./// Panics if the index is out of range.bind_with/// Updates the `BindStyle` for each of the passed-in fields by calling the/// passed-in function for each `BindingInfo`./// s.variants_mut()[0].bind_with(|bi| BindStyle::RefMut);///         A::B(ref mut __binding_0, ref mut __binding_1,) => {///         A::C(ref __binding_0,) => {/// Updates the binding name for each fo the passed-in fields by calling the/// The function will be called with the `BindingInfo` and its index in the/// enclosing variant./// The default name is `__binding_{}` where `{}` is replaced with an/// increasing number./// s.variants_mut()[0].binding_name(|bi, i| bi.ident.clone().unwrap());///         A::B{ a: ref a, b: ref b, } => {///             { println!("{:?}", a) }///             { println!("{:?}", b) }omitted_variantsextra_implextra_predicatesadd_bounds/// A wrapper around a `syn::DeriveInput` which provides utilities for creating/// custom derive trait implementations./// Create a new `Structure` with the variants and fields from the passed-in/// `DeriveInput`./// This method will panic if the provided AST node represents an untagged/// union./// Unlike `Structure::new`, this method does not panic if the provided AST/// node represents an untagged union./// Returns a slice of the variants in this Structure.variants_mut/// Returns a mut slice of the variants in this Structure./// `Structure` was created from./// True if any variants were omitted due to a `filter_variants` call./// and generating `match` arms which evaluate the returned tokens./// This method will ignore variants or fields which are ignored through the/// `filter` and `filter_variant` methods./// result of the previous call, and a `BindingInfo`. generating `match`/// arms which evaluate to the resulting tokens./// If a variant has been ignored, it will return the `init` value.///     s.fold(quote!(0), |acc, bi| quote!(#acc + #bi)).to_string(),///             0 + __binding_0each_variant/// Runs the passed-in function once for each variant, passing in a/// `VariantInfo`. and generating `match` arms which evaluate the returned/// This method will ignore variants and not bind fields which are ignored/// through the `filter` and `filter_variant` methods.///     s.each_variant(|v| {///         let name = &v.ast().ident;///         quote!(println!(stringify!(#name)))///     }).to_string(),///             println!(stringify!(B))///             println!(stringify!(C))/// Filter the bindings created by this `Structure` object. This has 2 effects:///   on this `Structure` or its subobjects./// s.filter(|bi| {/// Iterates all the bindings of this `Structure` object and uses a closure to determine if a/// structure. If the closure returns `false`, the binding remains in the structure./// All the removed bindings are moved to a new `Structure` object which is otherwise identical/// to the current one. To understand the effects of removing a binding from a structure check/// the [`Structure::filter`] documentation./// let mut with_b = Structure::new(&di);///         A::C{ .. } => {add_where_predicate/// Specify additional where predicate bounds which should be generated by/// impl-generating functions such as `gen_impl`, `bound_impl`, and/// `unsafe_bound_impl`.///     enum A<T, U> {///         B(T),///         C(Option<U>),/// // Add an additional where predicate./// s.add_where_predicate(syn::parse_quote!(T: std::fmt::Display));///     s.bound_impl(quote!(krate::Trait), quote!{///         fn a() {}///         const _: () = {///             extern crate krate;///             impl<T, U> krate::Trait for A<T, U>///                 where T: std::fmt::Display,///                       T: krate::Trait,///                       Option<U>: krate::Trait,///                       U: krate::Trait///                 fn a() {}/// Specify which bounds should be generated by impl-generating functions/// such as `gen_impl`, `bound_impl`, and `unsafe_bound_impl`./// The default behaviour is to generate both field and generic bounds from/// type parameters./// // Limit bounds to only generics./// s.add_bounds(AddBounds::Generics);///                 where T: krate::Trait,filter_variants/// Filter the variants matched by this `Structure` object. This has 2 effects:/// * Match arms destructuring these variants will no longer be generated by///   methods on this `Structure`///   fields in non-fitered variants./// s.filter_variants(|v| v.ast().ident != "B");///         _ => {}drain_filter_variants/// Iterates all the variants of this `Structure` object and uses a closure to determine if a/// variant should be removed. If the closure returns `true` the variant is removed from the/// structure. If the closure returns `false`, the variant remains in the structure./// All the removed variants are moved to a new `Structure` object which is otherwise identical/// to the current one. To understand the effects of removing a variant from a structure check/// the [`Structure::filter_variants`] documentation./// let mut with_c = Structure::new(&di);/// let with_b = with_c.drain_filter_variants(|v| v.ast().ident == "B");///     with_c.each(|bi| quote!(println!("{:?}", #bi))).to_string(),remove_variant/// Remove the variant at the given index./// s.bind_with(|bi| BindStyle::RefMut);///         A::C(ref mut __binding_0,) => {/// s.binding_name(|bi, i| bi.ident.clone().unwrap());///         A::C{ a: ref a, } => {/// Returns a list of the type parameters which are refrenced in the types/// of non-filtered fields / variants./// If the struct contains any macros in type position, all parameters will///         B(T, i32),/// s.filter_variants(|v| v.ast().ident != "C");///     s.referenced_ty_params(),add_impl_generic/// Adds an `impl<>` generic parameter./// This can be used when the trait to be derived needs some extra generic parameters./// let generic: syn::GenericParam = syn::parse_quote!(X: krate::AnotherTrait);///     s.add_impl_generic(generic)///         .bound_impl(quote!(krate::Trait<X>),///         quote!{///     ).to_string(),///             impl<T, U, X: krate::AnotherTrait> krate::Trait<X> for A<T, U>///                 where T : krate :: Trait < X >,///                       Option<U>: krate::Trait<X>,///                       U: krate::Trait<X>add_trait_bounds/// Add trait bounds for a trait with the given path for each type parmaeter/// referenced in the types of non-filtered fields./// If the method contains any macros in type position, all parameters willunderscore_const/// This method is a no-op, underscore consts are used by default now.bound_impl/// > NOTE: This methods' features are superceded by `Structure::gen_impl`./// Creates an `impl` block with the required generic type fields filled in/// to implement the trait `path`./// This method also adds where clauses to the impl requiring that all/// referenced type parmaeters implement the trait `path`./// # Hygiene and Paths/// This method wraps the impl block inside of a `const` (see the example/// below). In this scope, the first segment of the passed-in path is/// `extern crate`-ed in. If you don't want to generate that `extern crate`/// item, use a global path./// This means that if you are implementing `my_crate::Trait`, you simply/// write `s.bound_impl(quote!(my_crate::Trait), quote!(...))`, and for the/// entirety of the definition, you can refer to your crate as `my_crate`./// Panics if the path string parameter is not a valid `TraitBound`.///                 where Option<U>: krate::Trait,unsafe_bound_impl/// to implement the unsafe trait `path`.///     s.unsafe_bound_impl(quote!(krate::Trait), quote!{///             unsafe impl<T, U> krate::Trait for A<T, U>unbound_impl/// This method will not add any where clauses to the impl.///     s.unbound_impl(quote!(krate::Trait), quote!{///             impl<T, U> krate::Trait for A<T, U> {unsafe_unbound_impl///     s.unsafe_unbound_impl(quote!(krate::Trait), quote!{///             unsafe impl<T, U> krate::Trait for A<T, U> {impl_internalgen_impl/// Generate an impl block for the given struct. This impl block will/// automatically use hygiene tricks to avoid polluting the caller's/// namespace, and will automatically add trait bounds for generic type/// This function accepts its arguments as a `TokenStream`. The recommended way/// to call this function is passing the result of invoking the `quote!`/// macro to it./// s.gen_impl(quote! {///     // You can write any items which you want to import into scope here.///     // For example, you may want to include an `extern crate` for the///     // crate which implements your trait. These items will only be///     // visible to the code you generate, and won't be exposed to the///     // consuming crate///     extern crate krate;///     // You can also add `use` statements here to bring types or traits///     // into scope.///     /////     // WARNING: Try not to use common names here, because the stable///     // version of syn does not support hygiene and you could accidentally///     // shadow types from the caller crate.///     use krate::Trait as MyTrait;///     // The actual impl block is a `gen impl` or `gen unsafe impl` block.///     // You can use `@Self` to refer to the structure's type.///     gen impl MyTrait for @Self {///         fn f(&self) { ... }/// The most common usage of this trait involves loading the crate the/// target trait comes from with `extern crate`, and then invoking a `gen/// impl` block./// This method tries to handle hygiene intelligently for both stable and/// unstable proc-macro implementations, however there are visible/// differences./// The output of every `gen_impl` function is wrapped in a dummy `const`/// value, to ensure that it is given its own scope, and any values brought/// into scope are not leaked to the calling crate./// By default, the above invocation may generate an output like the/// const _: () = {///     impl<T> MyTrait for Struct<T> where T: MyTrait {/// ### Using the `std` crate/// If you are using `quote!()` to implement your trait, with the/// `proc-macro2/nightly` feature, `std` isn't considered to be in scope for/// your macro. This means that if you use types from `std` in your/// procedural macro, you'll want to explicitly load it with an `extern/// crate std;`./// ### Absolute paths/// You should generally avoid using absolute paths in your generated code,/// as they will resolve very differently when using the stable and nightly/// versions of `proc-macro2`. Instead, load the crates you need to use/// explictly with `extern crate` and/// # Trait Bounds/// This method will automatically add trait bounds for any type parameters/// which are referenced within the types of non-ignored fields./// Additional type parameters may be added with the generics syntax after/// the `impl` keyword./// ### Type Macro Caveat/// This function will generate a `compile_error!` if additional type/// parameters added by `impl<..>` conflict with generic type parameters on/// the original struct./// This function will panic if the input `TokenStream` is not well-formed./// # Example Usage///     s.gen_impl(quote! {///         extern crate krate;///         gen impl krate::Trait for @Self {///             fn a() {}///                 Option<U>: krate::Trait,///                 U: krate::Trait/// // NOTE: You can also add extra generics after the impl///         gen impl<X: krate::OtherTrait> krate::Trait<X> for @Self///             X: Send + Sync,///             impl<X: krate::OtherTrait, T, U> krate::Trait<X> for A<T, U>///                 X: Send + Sync,///                 Option<U>: krate::Trait<X>,///                 U: krate::Trait<X>/// // NOTE: you can generate multiple traits with a single call///         gen impl krate::OtherTrait for @Self {///             fn b() {}///             impl<T, U> krate::OtherTrait for A<T, U>///                 Option<U>: krate::OtherTrait,///                 U: krate::OtherTrait///                 fn b() {}/// Use `add_bounds` to change which bounds are generated.gen_impl_parseunpretty_print/// Dumps an unpretty version of a tokenstream. Takes any type which implements/// `Display`./// This is mostly useful for visualizing the output of a procedural macro, as/// it makes it marginally more readable. It is used in the implementation of/// `test_derive!` to unprettily print the output./// The stability of the output of this function is not guaranteed. Do not/// assert that the output of this function does not change between minor///     synstructure::unpretty_print(quote! {///     "const _ : (/// = {///     extern crate krate ;///     impl < T , U > krate :: Trait for A < T , U > where Option < U > : krate :: Trait , U : krate :: Trait {///         fn a (/// "trim_start_matches/// `trim_left_matches` has been deprecated in favor of `trim_start_matches`./// This helper silences the warning, as we need to continue using/// `trim_left_matches` for rust 1.15 support./// Convert this result into a `Result` for further processing / validation./// Convert this result into a `proc_macro::TokenStream`, ready to return/// from a native `proc_macro` implementation./// If `into_result()` would return an `Err`, this method should instead/// generate a `compile_error!` invocation to nicely report the error./// *This method is available if `synstructure` is built with the/// `"proc-macro"` feature.*MacroResult/// Helper trait describing values which may be returned by macro implementation/// methods used by this crate's macros.test_each_enum// Regression test for #48//! This crate provides helper types for matching against enum variants, and//! extracting bindings to each of the fields in the deriving Struct or Enum in//! a generic way.//! If you are writing a `#[derive]` which needs to perform some operation on//! every field, then you have come to the right place!//! # Example: `WalkFields`//! ### Trait Implementation//! pub trait WalkFields: std::any::Any {//!     fn walk_fields(&self, walk: &mut FnMut(&WalkFields));//! impl WalkFields for i32 {//!     fn walk_fields(&self, _walk: &mut FnMut(&WalkFields)) {}//! ### Custom Derive//! fn walkfields_derive(s: synstructure::Structure) -> proc_macro2::TokenStream {//!     let body = s.each(|bi| quote!{//!         walk(#bi)//!     s.gen_impl(quote! {//!         extern crate synstructure_test_traits;//!         gen impl synstructure_test_traits::WalkFields for @Self {//!             fn walk_fields(&self, walk: &mut FnMut(&synstructure_test_traits::WalkFields)) {//!                 match *self { #body }//! # const _IGNORE: &'static str = stringify!(//! synstructure::decl_derive!([WalkFields] => walkfields_derive);//! /*//!  * Test Case//!  *///!     synstructure::test_derive! {//!         walkfields_derive {//!             enum A<T> {//!                 B(i32, T),//!                 C(i32),//!         expands to {//!             const _: () = {//!                 extern crate synstructure_test_traits;//!                 impl<T> synstructure_test_traits::WalkFields for A<T>//!                     where T: synstructure_test_traits::WalkFields//!                 {//!                     fn walk_fields(&self, walk: &mut FnMut(&synstructure_test_traits::WalkFields)) {//!                         match *self {//!                             A::B(ref __binding_0, ref __binding_1,) => {//!                                 { walk(__binding_0) }//!                                 { walk(__binding_1) }//!                             }//!                             A::C(ref __binding_0,) => {//!                         }//!             };//! # Example: `Interest`//! pub trait Interest {//!     fn interesting(&self) -> bool;//! impl Interest for i32 {//!     fn interesting(&self) -> bool { *self > 0 }//! fn interest_derive(mut s: synstructure::Structure) -> proc_macro2::TokenStream {//!     let body = s.fold(false, |acc, bi| quote!{//!         #acc || synstructure_test_traits::Interest::interesting(#bi)//!         gen impl synstructure_test_traits::Interest for @Self {//!             fn interesting(&self) -> bool {//!                 match *self {//!                     #body//! synstructure::decl_derive!([Interest] => interest_derive);//!     synstructure::test_derive!{//!         interest_derive {//!                 impl<T> synstructure_test_traits::Interest for A<T>//!                     where T: synstructure_test_traits::Interest//!                     fn interesting(&self) -> bool {//!                                 false ||//!                                     synstructure_test_traits::Interest::interesting(__binding_0) ||//!                                     synstructure_test_traits::Interest::interesting(__binding_1)//!                                     synstructure_test_traits::Interest::interesting(__binding_0)//! For more example usage, consider investigating the `abomonation_derive` crate,//! which makes use of this crate, and is fairly simple.// Re-exports used by the decl_derive! and test_derive!// XXX: Switch to using this variant everywhere?/// The `decl_derive!` macro declares a custom derive wrapper. It will parse the/// incoming `TokenStream` into a `synstructure::Structure` object, and pass it/// into the inner function./// Your inner function should take a `synstructure::Structure` by value, and/// return a type implementing `synstructure::MacroResult`, for example:/// fn derive_simple(input: synstructure::Structure) -> proc_macro2::TokenStream {/// fn derive_result(input: synstructure::Structure)///     -> syn::Result<proc_macro2::TokenStream>/// ### Without Attributes/// fn derive_interesting(_input: synstructure::Structure) -> proc_macro2::TokenStream {///     quote::quote! { ... }/// # const _IGNORE: &'static str = stringify! {/// decl_derive!([Interesting] => derive_interesting);/// ### With Attributes/// decl_derive!([Interesting, attributes(interesting_ignore)] => derive_interesting);/// ### Decl Attributes & Doc Comments/// decl_derive! {///     [Interesting] =>///     #[allow(some_lint)]///     /// Documentation Comments///     derive_interesting/// *This macro is available if `synstructure` is built with the `"proc-macro"`decl_attribute/// The `decl_attribute!` macro declares a custom attribute wrapper. It will/// parse the incoming `TokenStream` into a `synstructure::Structure` object,/// and pass it into the inner function./// Your inner function should have the following type:/// fn attribute(///     attr: proc_macro2::TokenStream,///     structure: synstructure::Structure,/// ) -> proc_macro2::TokenStream {/// fn attribute_interesting(///     _attr: proc_macro2::TokenStream,///     _structure: synstructure::Structure,/// decl_attribute!([interesting] => attribute_interesting);test_derive/// Run a test on a custom derive. This macro expands both the original struct/// and the expansion to ensure that they compile correctly, and confirms that/// feeding the original struct into the named derive will produce the written/// You can add `no_build` to the end of the macro invocation to disable/// checking that the written code compiles. This is useful in contexts where/// the procedural macro cannot depend on the crate where it is used during/// tests./// fn test_derive_example(_s: synstructure::Structure)///     -> Result<proc_macro2::TokenStream, syn::Error>///     Ok(quote::quote! { const YOUR_OUTPUT: &'static str = "here"; })///     synstructure::test_derive!{///         test_derive_example {///             struct A;///         expands to {///             const YOUR_OUTPUT: &'static str = "here";//! This module provides two utility macros for testing custom derives. They can//! be used together to eliminate some of the boilerplate required in order to//! declare and test custom derive implementations.LOCALE_KEYPRODUCT_LOCALE_KEYPRODUCT_LANGUAGE_KEYPRODUCT_REGION_KEYLANG_KEY// Android 4.0 and belowCOUNTRY_KEYLOCALEVAR_KEYread_locale// Ported from https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/jni/AndroidRuntime.cpp#431__CFStringCFLocaleCopyPreferredLanguagesget_languagesCFArray// Most of these definitions come from `core-foundation-sys`, but we want this crate// to be `no_std` and `core-foundation-sys` isn't currently.get_locale/// Returns the active locale for the system or application./// This may be equivalent to `get_locales().next()` (the first entry),/// depending on the platform./// Returns `Some(String)` with a BCP-47 language tag inside. If the locale/// couldn't be obtained, `None` is returned instead./// use sys_locale::get_locale;/// let current_locale = get_locale().unwrap_or_else(|| String::from("en-US"));/// println!("The locale is {}", current_locale);get_locales/// Returns the preferred locales for the system or application, in descending order of preference./// Returns a `Vec` with any number of BCP-47 language tags inside./// If no locale preferences could be obtained, the vec will be empty./// use sys_locale::get_locales;/// let mut  locales = get_locales();/// println!("The most preferred locale is {}", locales.next().unwrap_or("en-US".to_string()));/// println!("The least preferred locale is {}", locales.last().unwrap_or("en-US".to_string()));can_obtain_locale//! A library to safely and easily obtain the current locale on the system or for an application.//! This library currently supports the following platforms://! - Android//! - iOS//! - Linux, BSD, and other UNIX variations//! - WebAssembly on the web (via the `js` feature)LANG/// See also [std::env::var]EnvAccess/// Environment variable access abstraction to allow testing without/// mutating env variables./// Use [StdEnv] to query [std::env]StdEnv/// Proxy to [std::env]parse_locale_codeMockEnvPARSE_LOCALELANG_PARSE_LOCALEparse_non_suffixed_identifierenv_priorityGlobalTypeWorkerGlobalScope/// Returns a handle to the global scope object./// Simplified version of https://github.com/rustwasm/wasm-bindgen/blob/main/crates/js-sys/src/lib.rs,/// which we can't use directly because it discards information about how it/// retrieved the global."./windows_sys.rs"GetUserPreferredUILanguagesMUI_LANGUAGE_NAMEEnumStringVersionComparePkgConfig/// pkg-config errorBuildInternalClosureError/// One of the `Config::add_build_internal` closures failedFailToRead/// Failed to read `Cargo.toml`InvalidMetadata/// Raised when an error is detected in the metadata defined in `Cargo.toml`MissingLib/// Raised when dependency defined manually using `SYSTEM_DEPS_$NAME_NO_PKG_CONFIG`/// did not define at least one lib using `SYSTEM_DEPS_$NAME_LIB` or/// `SYSTEM_DEPS_$NAME_LIB_FRAMEWORK`BuildInternalInvalid/// An environment variable in the form of `SYSTEM_DEPS_$NAME_BUILD_INTERNAL`/// contained an invalid value (allowed: `auto`, `always`, `never`)BuildInternalNoClosure/// system-deps has been asked to internally build a lib, through/// `SYSTEM_DEPS_$NAME_BUILD_INTERNAL=always' or `SYSTEM_DEPS_$NAME_BUILD_INTERNAL=auto',/// but not closure has been defined using `Config::add_build_internal` to build/// this libBuildInternalWrongVersion/// The library which has been build internally does not match the/// required version defined in `Cargo.toml`/// system-deps errors/// `pkg-config` error/// General failure/// Error used in return value of `Config::add_build_internal` closures/// Create a new `BuildInternalClosureError::Failed` representing a general/// * `details`: human-readable details about the failureLibLibFrameworkSearchNativeSearchFrameworkNoPkgConfigBuildInternalEnvVariableIter// enums representing the environment variables user can define to tune system-depsnew_libnew_lib_frameworknew_search_nativenew_search_frameworknew_includenew_no_pkg_confignew_build_internalFnBuildInternalEnvVariablesbuild_internals/// Structure used to configure `metadata` before starting to probe for dependencies/// Create a new set of configurationnew_with_env/// Probe all libraries configured in the Cargo.toml/// `[package.metadata.system-deps]` section.add_build_internal/// Add hook so system-deps can internally build library `name` if requested by user./// It will only be triggered if the environment variable/// `SYSTEM_DEPS_$NAME_BUILD_INTERNAL` is defined with either `always` or/// `auto` as value. In the latter case, `func` is called only if the requested/// version of the library was not found on the system./// * `name`: the name of the library, as defined in `Cargo.toml`/// * `func`: closure called when internally building the library./// It receives as argument the library name and the minimum version required.probe_fullBuildFlagsprobe_pkg_configget_build_internal_env_varget_build_internal_statuscall_build_internaloverride_from_flagsgen_flags/// Settings have been retrieved from `pkg-config`/// Settings have been defined using user defined environment variables/// From where the library settings have been retrieved/// libraries the linker should link on/// directories where the compiler should look for libraries/// frameworks the linker should link on/// directories where the compiler should look for frameworks/// directories where the compiler should look for header files/// macros that should be defined by the compiler/// library version/// A system dependencyfrom_pkg_configfrom_env_variablesfrom_internal_pkg_config/// Create a `Library` by probing `pkg-config` on an internal directory./// This helper is meant to be used by `Config::add_build_internal` closures/// after having built the lib to return the library information to system-deps./// * `pkg_config_dir`: the directory where the library `.pc` file is located/// * `lib`: the name of the library to look for/// * `version`: the minimum version of `lib` required/// let mut config = system_deps::Config::new();/// config.add_build_internal("mylib", |lib, version| {///   // Actually build the library here///   system_deps::Library::from_internal_pkg_config("build-dir",///       lib, version)EnvironnementEnvVariablesExtBuildFlagRerunIfEnvChanged// TODO: add support for "rustc-link-lib=static=" ?split_pathssplit_string//!`system-deps` lets you write system dependencies in `Cargo.toml` metadata,//! rather than programmatically in `build.rs`. This makes those dependencies//! declarative, so other tools can read them as well.//! In your `Cargo.toml`://! system-deps = "1.3"//! Then, to declare a dependency on `testlib >= 1.2`//! add the following section://! [package.metadata.system-deps]//! testlib = "1.2"//! Finally, in your `build.rs`, add://! ```should_panic//!     system_deps::Config::new().probe().unwrap();//! # Optional dependency//! You can easily declare an optional system dependency by associating it with a feature://! testdata = { version = "4.5", feature = "use-testdata" }//! # Overriding library name//! `toml` keys cannot contain dot characters so if your library name does you can define it using the `name` field://! glib = { name = "glib-2.0", version = "2.64" }//! # Feature versions//! `-sys` crates willing to support various versions of their underlying system libraries//! can use features to control the version of the dependency required.//! `system-deps` will pick the highest version among enabled features.//! v1_2 = []//! v1_4 = ["v1_2"]//! v1_6 = ["v1_4"]//! gstreamer = { name = "gstreamer-1.0", version = "1.0", feature-versions = { v1_2 = "1.2", v1_4 = "1.4", v1_6 = "1.6" }}//! # Overriding build flags//! By default `system-deps` automatically defines the required build flags for each dependency using the information fetched from `pkg-config`.//! These flags can be overriden using environment variables if needed://! - `SYSTEM_DEPS_$NAME_SEARCH_NATIVE` to override the [`cargo:rustc-link-search=native`](https://doc.rust-lang.org/cargo/reference/build-scripts.html#cargorustc-link-searchkindpath) flag;//! - `SYSTEM_DEPS_$NAME_SEARCH_FRAMEWORK` to override the [`cargo:rustc-link-search=framework`](https://doc.rust-lang.org/cargo/reference/build-scripts.html#cargorustc-link-searchkindpath) flag;//! - `SYSTEM_DEPS_$NAME_LIB` to override the [`cargo:rustc-link-lib`](https://doc.rust-lang.org/cargo/reference/build-scripts.html#rustc-link-lib) flag;//! - `SYSTEM_DEPS_$NAME_LIB_FRAMEWORK` to override the [`cargo:rustc-link-lib=framework`](https://doc.rust-lang.org/cargo/reference/build-scripts.html#rustc-link-lib) flag;//! - `SYSTEM_DEPS_$NAME_INCLUDE` to override the [`cargo:include`](https://kornel.ski/rust-sys-crate#headers) flag.//! With `$NAME` being the upper case name of the key defining the dependency in `Cargo.toml`.//! For example `SYSTEM_DEPS_TESTLIB_SEARCH_NATIVE=/opt/lib` could be used to override a dependency named `testlib`.//! One can also define the environment variable `SYSTEM_DEPS_$NAME_NO_PKG_CONFIG` to fully disable `pkg-config` lookup//! for the given dependency. In this case at least SYSTEM_DEPS_$NAME_LIB or SYSTEM_DEPS_$NAME_LIB_FRAMEWORK should be defined as well.//! # Statically build system library//! `-sys` crates can provide support for building and statically link their underlying system libray as part of their build process.//! Here is how to do this in your `build.rs`://!     system_deps::Config::new()//!         .add_build_internal("testlib", |lib, version| {//!             // Actually build the library here//!             system_deps::Library::from_internal_pkg_config("build/path-to-pc-file", lib, version)//!          })//!         .probe()//! This feature can be controlled using the `SYSTEM_DEPS_$NAME_BUILD_INTERNAL` environment variable//! which can have the following values://! - `auto`: build the dependency only if the required version has not been found by `pkg-config`;//! - `always`: always build the dependency, ignoring any version which may be installed on the system;//! - `never`: (default) never build the dependency, `system-deps` will fail if the required version is not found on the system.//! You can also use the `SYSTEM_DEPS_BUILD_INTERNAL` environment variable with the same values//! defining the behavior for all the dependencies which don't have `SYSTEM_DEPS_$NAME_BUILD_INTERNAL` defined.create_configassert_flagstoml_errtoml_pkg_config_err_version// Assert a PkgConfig error because requested lib version cannot be foundmissing_filemissing_keynot_tableversion_missingversion_not_stringversion_in_table_not_stringfeature_not_stringunexpected_keyoverride_namefeature_versionsoverride_search_nativeoverride_search_frameworkoverride_liboverride_frameworkoverride_includeoverride_unsetoverride_no_pkg_configoverride_no_pkg_config_errortest_build_internalbuild_internal_alwaysbuild_internal_auto_not_calledbuild_internal_auto_calledbuild_internal_auto_neverbuild_internal_always_no_closurebuild_internal_invalidbuild_internal_wrong_versionbuild_internal_failbuild_internal_always_gobalbuild_internal_gobal_overridebuild_internal_override_nameUnsupportedCfg/// The `cfg()` expression used in `Cargo.toml` is currently not supported/// All the system dependencies retrieved by [Config::probe]./// Retrieve details about a system dependency./// * `name`: the name of the `toml` key defining the dependency in `Cargo.toml`/// A vector listing all system dependencies in sorted (for build reproducibility) order./// The first element of the tuple is the name of the `toml` key defining the/// dependency in `Cargo.toml`.aggregate_straggregate_path_bufall_libs/// Returns a vector of [Library::libs] of each library, removing duplicates.all_link_paths/// Returns a vector of [Library::link_paths] of each library, removing duplicates.all_frameworks/// Returns a vector of [Library::frameworks] of each library, removing duplicates.all_framework_paths/// Returns a vector of [Library::framework_paths] of each library, removing duplicates.all_include_paths/// Returns a vector of [Library::include_paths] of each library, removing duplicates.all_defines/// Returns a vector of [Library::defines] of each library, removing duplicates.// Enum representing the environment variables user can define to tune system-deps.new_linkset_rerun_if_changed_for_all_variants/// The returned hash is using the `toml` key defining the dependency as key./// It receives as argument the library name, and the minimum version required.probe_with_fallbackcheck_cfg/// Name of the library/// Indicates if a static library is available on the systemInternalLib/// Internal library name and if a static library is available on the system/// library is statically linked/// This library will be statically linked.///   // Actually build the library here that fulfills the passed in version requirements///       lib, "1.2.4")// true if static//! system-deps = "2.0"//! # Version format//! Versions can be expressed in the following formats//!   * "1.2" or ">= 1.2": At least version 1.2//!   * ">= 1.2, < 2.0": At least version 1.2 but less than version 2.0//! In the future more complicated version expressions might be supported.//! Note that these versions are not interpreted according to the semver rules, but based on the//! rules defined by pkg-config.//! # Feature-specific dependency//! `system-deps` will check for `testdata` only if the `use-testdata` feature has been enabled.//! Another option is to use the `optional` setting, which can also be used using [features versions](#feature-versions)://! test-data = { version = "4.5", optional = true }//! testmore = { version = "2", v3 = { version = "3.0", optional = true }}//! `system-deps` will automatically export for each dependency a feature `system_deps_have_$DEP` where `$DEP`//! is the `toml` key defining the dependency in [snake_case](https://en.wikipedia.org/wiki/Snake_case).//! This can be used to check if an optional dependency has been found or not://! #[cfg(system_deps_have_testdata)]//! println!("found test-data");//! `toml` keys cannot contain dot characters so if your library name does, you can define it using the `name` field://! # Fallback library names//! Some libraries may be available under different names on different platforms or distributions.//! To allow for this, you can define fallback names to search for if the main library name does not work.//! aravis = { fallback-names = ["aravis-0.8"] }//! You may also specify different fallback names for different versions://! [package.metadata.system-deps.libfoo]//! version = "0.1"//! fallback-names = ["libfoo-0.1"]//! v1 = { version = "1.0", fallback-names = ["libfoo1"] }//! v2 = { version = "2.0", fallback-names = ["libfoo2"] }//! Such version features must use the pattern `v1_0`, `v1_2`, etc.//! [package.metadata.system-deps.gstreamer_1_0]//! name = "gstreamer-1.0"//! version = "1.0"//! v1_2 = { version = "1.2" }//! v1_4 = { version = "1.4" }//! v1_6 = { version = "1.6" }//! The same mechanism can be used to require a different library name depending on the version://! [package.metadata.system-deps.gst_gl]//! name = "gstreamer-gl-1.0"//! version = "1.14"//! v1_18 = { version = "1.18", name = "gstreamer-gl-egl-1.0" }//! # Target specific dependencies//! You can define target specific dependencies://! [package.metadata.system-deps.'cfg(target_os = "linux")']//! testdata = "1"//! [package.metadata.system-deps.'cfg(not(target_os = "macos"))']//! testlib = "1"//! [package.metadata.system-deps.'cfg(unix)']//! testanotherlib = { version = "1", optional = true }//! See [the Rust documentation](https://doc.rust-lang.org/reference/conditional-compilation.html)//! for the exact syntax.//! Currently, those keys are supported://! - `target_arch`//! - `target_endian`//! - `target_env`//! - `target_family`//! - `target_os`//! - `target_pointer_width`//! - `target_vendor`//! - `unix` and `windows`//! These flags can be overridden using environment variables if needed://! # Internally build system libraries//! `-sys` crates can provide support for building and statically link their underlying system library as part of their build process.//!             // Actually build the library here that fulfills the passed in version requirements//!             system_deps::Library::from_internal_pkg_config("build/path-to-pc-file", lib, "1.2.4")//! # Static linking//! By default all libraries are dynamically linked, except when build internally as [described above](#internally-build-system-libraries).//! Libraries can be statically linked by defining the environment variable `SYSTEM_DEPS_$NAME_LINK=static`.//! You can also use `SYSTEM_DEPS_LINK=static` to statically link all the libraries.Dependencyfallback_namesversion_overridesVersionOverridelib_nameVersionOverrideBuilderErrorMissingVersionFieldMetadataErrorNotATableNestedCfgNotStringOrTableNotStringCfgExprTomlUnexpectedVersionSettingUnexpectedKeyVersionOverrideBuilderversion_idparse_deps_tableparse_depparse_dep_tableparse_name_listvalidate_versionVersionRangeparse_goodparse_feature_not_stringparse_override_nameparse_feature_versionsparse_fallback_namesparse_version_fallback_namesparse_optionalparse_os_specific// Parse system-deps metadata from Cargo.tomlversion_rangeversion_range_unsatisfiedtoml_err_invalidversion_fallback_namesbuild_internal_always_globalbuild_internal_global_overrideos_specificinvalid_cfgstatic_one_liboverride_static_no_pkg_configstatic_all_libsstatic_lib_not_available/// A specialized `Result` type for shut down, reboot and log out operations./// Calls the OS-specific function to shut down the machine.force_shutdown/// Calls the OS-specific function to force to shut down the machine./// Calls the OS-specific function to reboot the machine.force_reboot/// Calls the OS-specific function to force to reboot the machine./// Calls the OS-specific function to log out the user.force_logout/// Calls the OS-specific function to force to log out the user./// Calls the OS-specific function to put the machine to sleep.hibernate/// Calls the OS-specific function to hibernate the machine.//! `system_shutdown` provides a cross platform way to shut down, reboot or log out operations.//! Supported platforms: Linux, Windows and macOS.//! The example below shows how to shut down the machine://! use system_shutdown::shutdown;//!     match shutdown() {//!         Ok(_) => println!("Shutting down, bye!"),//!         Err(error) => eprintln!("Failed to shut down: {}", error),//! In most of the systems it does not requires the user to be root/admin.DynamicTypedbus_sendget_session_id/// Linux specific function to shut down the machine using D-BUS method call./// The following D-BUS calls are attempted:/// - org.gnome.SessionManager.Shutdown()/// - org.kde.KSMServerInterface.logout(-1, 2, 2)/// - org.xfce.SessionManager.Shutdown(true)/// - org.freedesktop.login1.Manager.PowerOff(true)/// - org.freedesktop.PowerManagement.Shutdown()/// - org.freedesktop.SessionManagement.Shutdown()/// - org.freedesktop.ConsoleKit.Manager.Stop()/// - org.freedesktop.Hal.Device.SystemPowerManagement.Shutdown()/// - org.freedesktop.systemd1.Manager.PowerOff()/// If nothing works up to this point, as a last resort this function calls `shutdown -h now`/// Linux specific function to reboot the machine using D-BUS method call./// - org.gnome.SessionManager.Reboot()/// - org.kde.KSMServerInterface.logout(-1, 1, 2)/// - org.xfce.SessionManager.Restart(true)/// - org.freedesktop.login1.Manager.Reboot(true)/// - org.freedesktop.PowerManagement.Reboot()/// - org.freedesktop.SessionManagement.Reboot()/// - org.freedesktop.ConsoleKit.Manager.Restart()/// - org.freedesktop.Hal.Device.SystemPowerManagement.Reboot()/// - org.freedesktop.systemd1.Manager.Reboot()/// If nothing works up to this point, as a last resort this function calls `shutdown -r now`/// Linux specific function to force reboot the machine using the magic SysRq key./// Reference: https://www.kernel.org/doc/html/latest/admin-guide/sysrq.html/// Linux specific function to log out the user using D-BUS method call./// - org.gnome.SessionManager.Logout(1)/// - org.kde.KSMServerInterface.logout(-1, 0, 2)/// - org.kde.KSMServerInterface.closeSession()/// - org.xfce.SessionManager.Logout(true, true)/// - org.freedesktop.login1.Manager.TerminateSession(session_id)/// If nothing works up to this point, as a last resort this function calls `loginctl kill-session $XDG_SESSION_ID`/// Linux specific function to put the machine to sleep using D-BUS method call./// - org.xfce.SessionManager.Suspend()/// - org.freedesktop.login1.Manager.Suspend(true)/// - org.freedesktop.UPower.Suspend()/// - org.freedesktop.Hal.Device.SystemPowerManagement.Suspend()/// If nothing works up to this point, as a last resort this function calls `systemctl suspend`/// Linux specific function to hibernate the machine using D-BUS method call./// - org.xfce.SessionManager.Hibernate()/// - org.freedesktop.login1.Manager.Hibernate(true)/// - org.freedesktop.UPower.Hibernate()/// - org.freedesktop.Hal.Device.SystemPowerManagement.Hibernate()/// If nothing works up to this point, as a last resort this function calls `systemctl hibernate`invoke_scriptrequest_permission_dialog/// macOS requires to explicitly allow the application to call "System Events". If you want to use this crate in an unattended way (automation etc.),/// you may want to ask for permission beforehand to allow this app to call "System Events"./// This function requests the "System Events" to "stop current screen saver", which should be a fairly safe operation./// macOS specific function to shut down the system using AppleScript and "System Events" call "shut down"/// First time you use this, macOS will ask for a permission. If you want to ask for a permission beforehand, use [`request_permission_dialog`]/// macOS specific function to reboot using AppleScript and "System Events" call "restart"/// Unix specific function to force reboot the machine using the magic SysRq key./// macOS specific function to logout with a confirmation dialog using AppleScript and "System Events" call "log out"./// macOS specific function to force logout without showing a confirmation dialog using AppleScript and "loginwindow" call "«event aevtrlgo»"/// macOS specific function to put the machine to sleep using AppleScript and "System Events" call "sleep"AdjustTokenPrivilegesLookupPrivilegeValueWSE_PRIVILEGE_ENABLEDTOKEN_ADJUST_PRIVILEGESTOKEN_PRIVILEGESSetSuspendStateExitWindowsExInitiateSystemShutdownWEWX_LOGOFFEWX_REBOOTEWX_SHUTDOWNEXIT_WINDOWS_FLAGSSHTDN_REASON_FLAG_PLANNEDSHTDN_REASON_MAJOR_OPERATINGSYSTEMSHTDN_REASON_MINOR_UPGRADESE_SHUTDOWN_NAMEEWX_FORCEEWX_FORCEIFHUNGrequest_privilegesexit_windowsinitiate_system_shutdownset_suspend_stateshutdown_with_message/// Windows specific function to gracefully request system shutdown, providing a way to show a message,/// set a timeout and specify if apps should be force-closedreboot_with_message/// Windows specific function to gracefully request system reboot, providing a way to show a message,/// Windows specific function to shut down the machine using the `ExitWindowsEx()` from `winuser` API./// Windows specific function to shut down the machine instantly without confirmations using the `ExitWindowsEx()` from `winuser` API./// Windows specific function to reboot the machine using the `ExitWindowsEx()` from `winuser` API./// Windows specific function to reboot the machine instantly without confirmations using the `ExitWindowsEx()` from `winuser` API./// Windows specific function to log out the user using the `ExitWindowsEx()` from `winuser` API./// Windows specific function to log out the user instantly without confirmations using the `ExitWindowsEx()` from `winuser` API./// Windows specific function to put the machine to sleep using `SetSuspendState()` API call./// Windows specific function to hibernate the machine using `SetSuspendState()` API call./// Converts `self` into `T` using `Into<T>`./// use tap::conv::Conv;/// let len = "Saluton, mondo!"///   .conv::<String>()///   .len();/// Wraps `Into::<T>::into` as a method that can be placed in pipelines.try_conv/// Attempts to convert `self` into `T` using `TryInto<T>`./// use tap::conv::TryConv;///   .try_conv::<String>()///   .unwrap()/// Wraps `TryInto::<T>::try_into` as a method that can be placed in pipelines./*! # Method-Directed Type Conversion

The `std::convert` module provides traits for converting values from one type to
another. The first of these, [`From<T>`], provides an associated function
[`from(orig: T) -> Self`]. This function can only be called in prefix-position,
as it does not have a `self` receiver. The second, [`Into<T>`], provides a
method [`into(self) -> T`] which *can* be called in suffix-position; due to
intractable problems in the type solver, this method cannot have any *further*
method calls attached to it. It must be bound directly into a `let` or function
call.

The [`TryFrom<T>`] and [`TryInto<T>`] traits have the same properties, but
permit failure.

This module provides traits that place the conversion type parameter in the
method, rather than in the trait, so that users can write `.conv::<T>()` to
convert the preceding expression into `T`, without causing any failures in the
type solver. These traits are blanket-implemented on all types that have an
`Into<T>` implementation, which covers both the blanket implementation of `Into`
for types with `From`, and manual implementations of `Into`.

[`From<T>`]: https://doc.rust-lang.org/std/convert/trait.From.html
[`Into<T>`]: https://doc.rust-lang.org/std/convert/trait.Into.html
[`TryFrom<T>`]: https://doc.rust-lang.org/std/convert/trait.TryFrom.html
[`TryInto<T>`]: https://doc.rust-lang.org/std/convert/trait.TryInto.html
[`from(orig: T) -> Self`]: https://doc.rust-lang.org/std/convert/trait.From.html#tymethod.from
[`into(self) -> T`]: https://doc.rust-lang.org/std/convert/trait.Into.html#tymethod.into
!*//// Reëxports all traits in one place, for easy import.// also make traits available at crate root/*! # `tap` – Syntactical Plumb-Lines

Rust permits functions that take a `self` receiver to be written in “dot-call”
suffix position, rather than the more traditional prefix-position function call
syntax. These functions are restricted to `impl [Trait for] Type` blocks, and
functions anywhere else cannot take advantage of this syntax.

This crate provides universally-implemented extension traits that permit smooth
suffix-position calls for a handful of common operations: transparent inspection
or modification (tapping), transformation (piping), and type conversion.

## Tapping

The [`tap`] module provides the [`Tap`], [`TapOptional`], and [`TapFallible`]
traits. Each of these traits provides methods that take and return a value, and
expose it as a borrow to an effect function. They look like this:

```rust
use tap::prelude::*;
# struct Tmp;
# fn make_value() -> Tmp { Tmp }
# impl Tmp { fn process_value(self) {} }
# macro_rules! log { ($msg:literal, $val:ident) => {{}}; }

let end = make_value()
  .tap(|v| log!("Produced value: {:?}", v))
  .process_value();
```

These methods are `self -> Self`, and return the value they received without
any transformation. This enables them to be placed anywhere in a larger
expression witohut changing its shape, or causing any semantic changes to the
code. The effect function receives a borrow of the tapped value, optionally run
through the `Borrow`, `AsRef`, or `Deref` view conversions, for the duration of
its execution.

The effect function cannot return a value, as the tap is incapable of handling
it.

## Piping

The [`pipe`] module provides the [`Pipe`] trait. This trait provides methods
that take and transform a value, returning the result of the transformation.
They look like this:

```rust
use tap::prelude::*;

struct One;
fn start() -> One { One }
struct Two;
fn end(_: One) -> Two { Two }

let val: Two = start().pipe(end);

// without pipes, this would be written as
let _: Two = end(start());
```

These methods are `self -> Other`, and return the value produced by the effect
function. As the methods are always available in suffix position, they can take
as arguments methods that are *not* eligible for dot-call syntax and still place
them as expression suffices. The effect function receives the piped value,
optionally run through the `Borrow`, `AsRef`, or `Deref` view conversions, as
its input, and its output is returned from the pipe.

For `.pipe()`, the input value is *moved* into the pipe and the effect function,
so the effect function *cannot* return a value whose lifetime depends on the
input value. The other pipe methods all borrow the input value, and may return a
value whose lifetime is tied to it.

## Converting

The [`conv`] module provides the [`Conv`] and [`TryConv`] traits. These provide
methods that accept a type parameter on the method name, and forward to the
appropriate `Into` or `TryInto` trait implementation when called. The difference
between `Conv` and `Into` is that `Conv` is declared as `Conv::conv::<T>`, while
`Into` is declared as `Into::<T>::into`. The location of the destination type
parameter makes `.into()` unusable as a non-terminal method call of an
expression, while `.conv::<T>()` can be used as a method call anywhere.

```rust,compile_fail
let upper = "hello, world"
  .into()
  .tap_mut(|s| s.make_ascii_uppercase());
```

The above snippet is illegal, because the Rust type solver cannot determine the
type of the sub-expression `"hello, world".into()`, and it will not attempt to
search all available `impl Into<X> for str` implementations to find an `X` which
has a
`fn tap_mut({self, &self, &mut self, Box<Self>, Rc<Self>, Arc<Self>}, _) -> Y`
declared, either as an inherent method or in a trait implemented by `X`, to
resolve the expression.

Instead, you can write it as

```rust
use tap::prelude::*;

let upper = "hello, world"
  .conv::<String>()
  .tap_mut(|s| s.make_ascii_uppercase());
```

The trait implementation is

```rust
pub trait Conv: Sized {
 fn conv<T: Sized>(self) -> T
 where Self: Into<T> {
  self.into()
 }
}
```

Each monomorphization of `.conv::<T>()` expands to the appropriate `Into<T>`
implementation, and does nothing else.

[`Conv`]: conv/trait.Conv.html
[`Pipe`]: pipe/trait.Pipe.html
[`Tap`]: tap/trait.Tap.html
[`TapFallible`]: tap/trait.TapFallible.html
[`TapOptional`]: tap/trait.TapOptional.html
[`TryConv`]: conv/trait.TryConv.html
[`conv`]: conv/index.html
[`pipe`]: pipe/index.html
[`tap`]: tap/index.html
!*//// Pipes by value. This is generally the method you want to use./// use tap::pipe::Pipe;/// fn triple(x: i32) -> i64 {///   x as i64 * 3///   10.pipe(triple),///   30,pipe_ref/// Borrows `self` and passes that borrow into the pipe function./// fn fold(v: &Vec<i32>) -> i32 {///   v.iter().copied().sum()/// let sum = vec.pipe_ref(fold);/// assert_eq!(sum, 15);/// assert_eq!(vec.len(), 5);pipe_ref_mut/// Mutably borrows `self` and passes that borrow into the pipe function./// let mut vec = vec![false, true];/// let last = vec///   .pipe_ref_mut(Vec::pop)///   .pipe(Option::unwrap);/// assert!(last);/// Both of these functions are eligible for method-call syntax, and should/// not be piped. Writing out non-trivial examples for these is a lot of/// boilerplate.pipe_borrow/// Borrows `self`, then passes `self.borrow()` into the pipe function./// let len = Cow::<'static, str>::from("hello, world")///   .pipe_borrow(str::len);/// assert_eq!(len, 12);pipe_borrow_mut/// Mutably borrows `self`, then passes `self.borrow_mut()` into the pipe/// let mut txt = "hello, world".to_string();/// let ptr = txt///   .pipe_borrow_mut(str::as_mut_ptr);/// This is a very contrived example, but the `BorrowMut` trait has almost/// no implementors in the standard library, and of the implementations/// available, there are almost no methods that fit this API.pipe_as_ref/// Borrows `self`, then passes `self.as_ref()` into the pipe function.pipe_as_mut/// Mutably borrows `self`, then passes `self.as_mut()` into the pipepipe_deref/// Borrows `self`, then passes `self.deref()` into the pipe function.pipe_deref_mut/// Mutably borrows `self`, then passes `self.deref_mut()` into the pipe/** Provides universal suffix-position call syntax for any function.

This trait provides methods that allow any closure or free function to be placed
as a suffix-position call, by writing them as

```rust
# use tap::pipe::Pipe;
# let receiver = 5;
fn not_a_method(x: i32) -> u8 { x as u8 }
receiver.pipe(not_a_method);
```

Piping into functions that take more than one argument still requires writing a
closure with ordinary function-call syntax. This is after all only a library,
not a syntax transformation:

```rust
use tap::pipe::Pipe;
fn add(x: i32, y: i32) -> i32 { x + y }

let out = 5.pipe(|x| add(x, 10));
assert_eq!(out, 15);
```

Like tapping, piping is useful for cases where you want to write a sequence of
processing steps without introducing many intermediate bindings, and your steps
contain functions which are not eligible for dot-call syntax.

The main difference between piping and tapping is that tapping always returns
the value that was passed into the tap, while piping forwards the value into the
effect function, and returns the output of evaluating the effect function with
the value. Piping is a transformation, not merely an inspection or modification.
**//*! # Universal Suffix Calls

This module provides a single trait, `Pipe`, which provides a number of methods
useful for placing functions in suffix position. The most common method, `pipe`,
forwards a value `T` into any function `T -> R`, returning `R`. The other
methods all apply some form of borrowing to the value before passing the borrow
into the piped function. These are of less value, but provided to maintain a
similar API to the `tap` module’s methods, and for convenience in the event that
you do have a use for them.

This module is as much of a [UFCS] method syntax that can be provided as a
library, rather than in the language grammar.

[UFCS]: https://en.wikipedia.org/wiki/Uniform_Function_Call_Syntax
!*//// Immutable access to a value./// This function permits a value to be viewed by some inspecting function/// without affecting the overall shape of the expression that contains this/// method call. It is useful for attaching assertions or logging points/// into a multi-part expression./// Here we use `.tap()` to attach logging tracepoints to each stage of a/// value-processing pipeline./// use tap::tap::Tap;/// # struct Tmp;/// # impl Tmp { fn process_value(self) -> Self { self } }/// # fn make_value() -> Tmp { Tmp }/// # macro_rules! log { ($msg:literal, $x:ident) => {{}}; }/// let end = make_value()///   // this line has no effect on the rest of the code///   .tap(|v| log!("The produced value was: {}", v))///   .process_value();tap_mut/// Mutable access to a value./// This function permits a value to be modified by some function without/// affecting the overall shape of the expression that contains this method/// call. It is useful for attaching modifier functions that have an/// `&mut Self -> ()` signature to an expression, without requiring an/// explicit `let mut` binding./// Here we use `.tap_mut()` to sort an array without requring multiple/// let sorted = [1i32, 5, 2, 4, 3]///   .tap_mut(|arr| arr.sort());/// assert_eq!(sorted, [1, 2, 3, 4, 5]);/// Without tapping, this would be written as/// let mut received = [1, 5, 2, 4, 3];/// received.sort();/// let sorted = received;/// The mutable tap is a convenient alternative when the expression to/// produce the collection is more complex, for example, an iterator/// pipeline collected into a vector.tap_borrow/// Immutable access to the `Borrow<B>` of a value./// This function is identcal to [`Tap::tap`], except that the effect/// function recevies an `&B` produced by `Borrow::<B>::borrow`, rather than/// an `&Self`./// [`Tap::tap`]: trait.Tap.html#method.taptap_borrow_mut/// Mutable access to the `BorrowMut<B>` of a value./// This function is identical to [`Tap::tap_mut`], except that the effect/// function receives an `&mut B` produced by `BorrowMut::<B>::borrow_mut`,/// rather than an `&mut Self`./// [`Tap::tap_mut`]: trait.Tap.html#method.tap_muttap_ref/// Immutable access to the `AsRef<R>` view of a value./// This function is identical to [`Tap::tap`], except that the effect/// function receives an `&R` produced by `AsRef::<R>::as_ref`, rather thantap_ref_mut/// Mutable access to the `AsMut<R>` view of a value./// function receives an `&mut R` produced by `AsMut::<R>::as_mut`, rather/// than an `&mut Self`.tap_deref/// Immutable access to the `Deref::Target` of a value./// function receives an `&Self::Target` produced by `Deref::deref`, rather/// than an `&Self`.tap_deref_mut/// Mutable access to the `Deref::Target` of a value./// function receives an `&mut Self::Target` produced by/// `DerefMut::deref_mut`, rather than an `&mut Self`.tap_dbg/// Calls `.tap()` only in debug builds, and is erased in release builds.tap_mut_dbg/// Calls `.tap_mut()` only in debug builds, and is erased in release/// builds.tap_borrow_dbg/// Calls `.tap_borrow()` only in debug builds, and is erased in releasetap_borrow_mut_dbg/// Calls `.tap_borrow_mut()` only in debug builds, and is erased in releasetap_ref_dbg/// Calls `.tap_ref()` only in debug builds, and is erased in releasetap_ref_mut_dbg/// Calls `.tap_ref_mut()` only in debug builds, and is erased in releasetap_deref_dbg/// Calls `.tap_deref()` only in debug builds, and is erased in releasetap_deref_mut_dbg/// Calls `.tap_deref_mut()` only in debug builds, and is erased in release//  debug-build-only copies of the above methods/** Point-free value inspection and modification.

This trait provides methods that permit viewing the value of an expression
without requiring a new `let` binding or any other alterations to the original
code other than insertion of the `.tap()` call.

The methods in this trait do not perform any view conversions on the value they
receive; it is borrowed and passed directly to the effect argument.
**//// The interior type that the container may or may not carry.tap_some/// Immutabily accesses an interior value only when it is present./// This function is identical to [`Tap::tap`], except that it is required/// to check the implementing container for value presence before running./// Implementors must not run the effect function if the container is marked/// as being empty.tap_some_mut/// Mutably accesses an interor value only when it is present./// This function is identical to [`Tap::tap_mut`], except that it is/// required to check the implementing container for value presence before/// running. Implementors must not run the effect function if the container/// is marked as being empty.tap_none/// Runs an effect function when the container is empty./// to check the implementing container for value absence before running./// as being non-empty.tap_some_dbg/// Calls `.tap_some()` only in debug builds, and is erased in releasetap_some_mut_dbg/// Calls `.tap_some_mut()` only in debug builds, and is erased in releasetap_none_dbg/// Calls `.tap_none()` only in debug builds, and is erased in release/** Optional tapping, conditional on the optional presence of a value.

This trait is intended for use on types that express the concept of “optional
presence”, primarily the [`Option`] monad. It provides taps that inspect the
container to determine if the effect function should execute or not.

> Note: This trait is a specialization of [`TapFallible`], and exists because
> the [`std::ops::Try`] trait is still unstable. When `Try` stabilizes, this
> trait can be removed, and `TapFallible` blanket-applied to all `Try`
> implementors.

[`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
[`TapFallible`]: trait.TapFallible.html
[`std::ops::Try`]: https://doc.rust-lang.org/std/ops/trait.Try.html
**//// The interior type used to indicate a successful construction./// The interior type used to indicate a failed construction.tap_ok/// Immutably accesses an interior success value./// to check the implementing container for value success before running./// as being a failure.tap_ok_mut/// Mutably accesses an interior success value./// required to check the implementing container for value success before/// is marked as being a failure.tap_err/// Immutably accesses an interior failure value./// to check the implementing container for value failure before running./// as being a success.tap_err_mut/// Mutably accesses an interior failure value./// required to check the implementing container for value failure before/// is marked as being a success.tap_ok_dbg/// Calls `.tap_ok()` only in debug builds, and is erased in release builds.tap_ok_mut_dbg/// Calls `.tap_ok_mut()` only in debug builds, and is erased in releasetap_err_dbg/// Calls `.tap_err()` only in debug builds, and is erased in releasetap_err_mut_dbg/// Calls `.tap_err_mut()` only in debug builds, and is erased in releaseTapFallible/** Fallible tapping, conditional on the optional success of an expression.

This trait is intended for use on types that express the concept of “fallible
presence”, primarily the [`Result`] monad. It provides taps that inspect the
container to determine if the effect function should execute or not.

> Note: This trait would ideally be implemented as a blanket over all
> [`std::ops::Try`] implementors. When `Try` stabilizes, this crate can be
> updated to do so.

[`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html
[`std::ops::Try`]: https://doc.rust-lang.org/std/ops/trait.Try.html
**//*! # Point-Free Inspection

The standard library does not provide a way to view or modify an expression
without binding it to a name. This module provides extension methods that take
and return a value, allowing it to be temporarily bound without creating a new
`let`-statement in the enclosing scope.

The two main uses of these methods are to temporarily attach debugging
tracepoints to an expression without modifying its surrounding code, or to
temporarily mutate an otherwise-immutable object.

For convenience, methods are available that will modify the *view* of the tapped
object that is passed to the effect function, by using the value’s
`Borrow`/`BorrowMut`, `AsRef`/`AsMut`, or `Index`/`IndexMut` trait
implementations. For example, the `Vec` collection has no `fn sort` method: this
is actually implemented on slices, to which `Vec` dereferences.

```rust
use tap::tap::*;
# fn make_vec() -> Vec<i32> { vec![] }

// taps take ordinary closures, which can use deref coercion
make_vec().tap_mut(|v| v.sort());
// `Vec<T>` implements `BorrowMut<[T]>`,
make_vec().tap_borrow_mut(<[_]>::sort);
// and `AsMut<[T]>`,
make_vec().tap_ref_mut(<[_]>::sort);
// and `DerefMut<Target = [T]>,
make_vec().tap_deref_mut(<[_]>::sort);
// but has no inherent method `sort`.
// make_vec().tap_mut(Vec::sort);
```
!*/data_model// Include triple.rs and targets.rs so we can parse the TARGET environment variable.// targets.rs depends on data_modelUnrecognizedArchitectureUnrecognizedOperatingSystemUnrecognizedEnvironmentUnrecognizedBinaryFormatUnrecognizedFieldparse_error// Stub out `ParseError` to minimally support triple.rs and targets.rs.using_1_40write_host_rsvendor_display//! build.rs file to obtain the host information.// Allow dead code in triple.rs and targets.rs for our purposes here./// The size of a type./// Return the number of bits this `Size` represents./// Return the number of bytes in a size./// A byte is assumed to be 8 bits.CDataModelLP32/// The data model used most commonly on Win16. `long` and `pointer` are 32 bits.ILP32/// The data model used most commonly on Win32 and 32-bit Unix systems./// `int`, `long`, and `pointer` are all 32 bits.LLP64/// The data model used most commonly on Win64/// `long long`, and `pointer` are 64 bits.LP64/// The data model used most commonly on 64-bit Unix systems/// `long`, and `pointer` are 64 bits.ILP64/// A rare data model used on early 64-bit Unix systems/// `int`, `long`, and `pointer` are all 64 bits./// The C data model used on a target./// See also https://en.cppreference.com/w/c/language/arithmetic_types/// The width of a pointer (in the default address space).short_size/// The size of a C `short`. This is required to be at least 16 bits.int_size/// The size of a C `int`. This is required to be at least 16 bits.long_size/// The size of a C `long`. This is required to be at least 32 bits.long_long_size/// The size of a C `long long`. This is required (in C99+) to be at least 64 bits.float_size/// The size of a C `float`.double_size/// The size of a C `double`.OperatingSystemAarch64ArchitectureArmArchitectureCustomVendorMips32ArchitectureMips64ArchitectureRiscv32ArchitectureRiscv64ArchitectureX86_32Architecture" The `Triple` of the current host."" Return the architecture for the current host."" Return the vendor for the current host."" Return the operating system for the current host."" Return the environment for the current host."" Return the binary format for the current host."" Return the triple for the current host."// Include the implementations of the `HOST` object containing information// about the current host.test_linuxtest_ptr64host_objectDefaultToHost/// A simple wrapper around `Triple` that provides an implementation of/// `Default` which defaults to `Triple::host()`.DefaultToUnknown/// `Default` which defaults to `Triple::unknown()`.//! Target triple support.// For some reason, the below `serde` impls don't work when they're in the// `triple` module./// An error returned from parsing a triple.AmdGcnAsmjsBpfebBpfelX86_32M68kMips32Nvptx64PowerpcPowerpc64Powerpc64leSparcv9X86_64h/// x86_64 target that only supports Haswell-compatible Intel chips.XTensaCleverArchitectureClever/// The "architecture" field, which in some cases also specifies a specific/// subarchitecture.Armeb// Generic armArmv4Armv4tArmv5tArmv5teArmv5tejArmv6Armv6jArmv6kArmv6zArmv6kzArmv6t2Armv6mArmv7Armv7aArmv7kArmv7veArmv7mArmv7rArmv7sArmv8Armv8aArmv8_1aArmv8_2aArmv8_3aArmv8_4aArmv8_5aArmv8mBaseArmv8mMainArmv8rArmebv7rThumbebThumbv4tThumbv5teThumbv6mThumbv7aThumbv7emThumbv7mThumbv7neonThumbv8mBaseThumbv8mMainAarch64beis_thumb/// Test if this architecture uses the Thumb instruction set./// Return the pointer bit width of this target's architecture./// Return the endianness of this architecture.into_str/// Convert into a string// pub fn has_fpu(self) -> Result<&'static [ArmFpu], ()> {/// This function is only aware of the CPU architecture so it is not aware/// of ilp32 ABIs.Clever1_0Riscv32gcRiscv32iRiscv32imRiscv32imacRiscv32imc/// An enum for all 32-bit RISC-V architectures.Riscv64gcRiscv64imac/// An enum for all 64-bit RISC-V architectures.I586I686/// An enum for all 32-bit x86 architectures.MipselMipsisa32r6Mipsisa32r6el/// An enum for all 32-bit MIPS architectures (not just "MIPS32").Mips64elMipsisa64r6Mipsisa64r6el/// An enum for all 64-bit MIPS architectures (not just "MIPS64")./// An owned `String`. This supports the general case./// A static `str`, so that `CustomVendor` can be constructed in `const`/// A string for a `Vendor::Custom` that can either be used in `const`/// contexts or hold dynamic strings./// Extracts a string slice.AppleEspressifExperimentalFortanixIbmKmcNintendoPcRumprunUwpWrs/// A custom vendor. "Custom" in this context means that the vendor is/// not specifically recognized by upstream Autotools, LLVM, Rust, or other/// relevant authorities on triple naming. It's useful for people building/// and using locally patched toolchains./// Outside of such patched environments, users of `target-lexicon` should/// treat `Custom` the same as `Unknown` and ignore the string./// The "vendor" field, which in practice is little more than an arbitrary/// modifier.AixAmdHsaCloudabiCudaDarwinEspidfFreebsdHermitHorizonIllumosIosL4reMacOSXNebuletNetbsdNone_OpenbsdPspSolidAsp3TvosUefiVxWorksWasiWasiP1WasiP2WatchosAmdGizAndroideabiEabiEabihfGnuabi64GnueabiGnueabihfGnuspeGnux32GnuIlp32GnuLlvmHermitKernelLinuxKernelMacabiMusleabiMusleabihfMuslabi64NewlibUclibcUclibceabiUclibceabihfSgxSimSoftfloatSpeThreadsMacho/// The "binary format" field, which is usually omitted, and the binary format/// is implied by the other fields./// of ilp32 and x32 ABIs.is_clever/// Checks if this Architecture is some variant of Clever-ISAdefault_binary_format/// Return the binary format implied by this target triple, ignoring its/// `binary_format` field.roundtrip_known_triplesthumbv7em_none_eabihfcustom_vendors// This file defines all the identifier enums and target-aware logic.// #[cfg_attr(feature = "rust_1_40", non_exhaustive)]// #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]// #[allow(missing_docs)]// pub enum ArmFpu {//     Vfp,//     Vfpv2,//     Vfpv3,//     Vfpv3Fp16,//     Vfpv3Xd,//     Vfpv3XdFp16,//     Neon,//     NeonVfpv3,//     NeonVfpv4,//     Vfpv4,//     Vfpv4D16,//     Fpv4SpD16,//     Fpv5SpD16,//     Fpv5D16,//     FpArmv8,//     NeonFpArmv8,//     CryptoNeonFpArmv8,/// The target memory endianness./// Return the number of bits in a pointer./// Return the number of bytes in a pointer./// For these purposes, there are 8 bits in a byte.SystemV/// "System V", which is used on most Unix-like platfoms. Note that the/// specific conventions vary between hardware architectures; for example,/// x86-32's "System V" is entirely different from x86-64's "System V".WasmBasicCAbi/// The WebAssembly C ABI./// https://github.com/WebAssembly/tool-conventions/blob/master/BasicCABI.mdWindowsFastcall/// "Windows Fastcall", which is used on Windows. Note that like "System V",/// this varies between hardware architectures. On x86-32 it describes what/// Windows documentation calls "fastcall", and on x86-64 it describes what/// Windows documentation often just calls the Windows x64 calling convention/// (though the compiler still recognizes "fastcall" as an alias for it).AppleAarch64/// Apple Aarch64 platforms use their own variant of the common Aarch64/// calling convention./// <https://developer.apple.com/documentation/xcode/writing_arm64_code_for_apple_platforms>/// The calling convention, which specifies things like which registers are/// used for passing arguments, which registers are callee-saved, and so on./// The "architecture" (and sometimes the subarchitecture)./// The "vendor" (whatever that means)./// The "operating system" (sometimes also the environment)./// The "environment" on top of the operating system (often omitted for/// operating systems with a single predominant environment).binary_format/// The "binary format" (rarely used)./// A target "triple". Historically such things had three fields, though they've/// added additional fields over time./// Note that `Triple` doesn't implement `Default` itself. If you want a type/// which defaults to the host triple, or defaults to unknown-unknown-unknown,/// use `DefaultToHost` or `DefaultToUnknown`, respectively./// Return the endianness of this target's architecture./// Return the pointer width of this target's architecture./// This function is aware of x32 and ilp32 ABIs on 64-bit architectures.default_calling_convention/// Return the default calling convention for the given target triple./// The C data model for a given target. If the model is not known, returns `Err(())`./// Return a `Triple` with all unknown fields.special_case_display/// Handle special cases in the `Display` implementation.special_case_from_str/// Handle special cases in the `FromStr` implementation./// A convenient syntax for triple literals./// This currently expands to code that just calls `Triple::from_str` and does/// an `expect`, though in the future it would be cool to use procedural macros/// or so to report errors at compile time instead.defaultsunknown_propertiesapple_calling_conventionp32_abi// This file defines the `Triple` type and support code shared by all targets.cfg_for_target/// Release 0.3.0 (2017-02-10)/// # Breaking changes/// * The `Error` enumeration gained a new variant `CustomTargetsUnsupported` to signify the fact///   this particular build of the crate does not support custom JSON targets./// # Other changes/// * `serde_json` is now an enabled-by-default optional dependency. If custom target support is/// not necessary in your project, it can be disabled with [`default-features =/// false`](http://doc.crates.io/specifying-dependencies.html#choosing-features).r0_2_1/// Release 0.2.1 (2017-02-03)/// * Upgrade serde to 0.9r0_2_0/// Release 0.2.0 (2017-01-18)/// * `TargetInfo::target_vendor` changed signature to return `Option<&str>` instead of `&str`./// Non-nightly rustc doesn’t give the information about target vendor, so it is not available when/// compiling with stable/beta rustc./// * Added `TargetInfo::target_cfg`. Can be used to emulate e.g. `#[cfg(unix)]` or/// `#[cfg(windows)]`./// * Added `TargetInfo::target_cfg_value`. Can be used to extract more obscure target properties/// such as `#[cfg(target_has_atomic = "64")]`. Note that many of these depend on rustc channel,/// just like `target_vendor`.r0_1_2/// Release 0.1.2 (2016-10-17)/// * Now figures out target info from the rustc that is used to compile the library. This results/// in less divergence between versions of rustc (i.e. when targets are added), but is not able to/// provide target info for some targets on some hosts anymore. For example all `*-apple-ios`/// targets are not available anymore on the linux host./// * `Error` implements `std::error::Error` trait now.//! Project ChangelogTargetUnset/// The `TARGET` environment variable does not exist or is not valid utf-8TargetNotFound/// Target was not found/// Custom target JSON was found, but was invalid/// IO error occured during search of JSON target filesCustomTargetsUnsupported/// Crate was built without support for custom targets JSON fileBUILTINSswitches// Switches such as `cfg(unix)`other_keys// Other keys such as `target_vendor` or `target_has_atomic`/// Parse the target info from `TARGET` environment variable/// `TARGET` environment variable is usually set for you in build.rs scripts, therefore this/// function is all that’s necessary in majority of cases./// use target_build_utils::TargetInfo;/// let target = TargetInfo::new().expect("could not get target");/// Calculate the target info from the provided target value/// String may contain a triple or path to the json file./// let target = TargetInfo::from_str("x86_64-unknown-linux-gnu")///     .expect("could not get target");load_specific/// Architecture of the targeted machine/// Corresponds to the `#[cfg(target_arch = {})]` in Rust code./// OS of the targeted machine/// Corresponds to the `#[cfg(target_os = {})]` in Rust code./// Environment (ABI) of the targeted machine/// Corresponds to the `#[cfg(target_env = {})]` in Rust code.target_endian/// Endianess of the targeted machine/// Valid values are: `little` and `big`./// Corresponds to the `#[cfg(target_endian = {})]` in Rust code./// Pointer width of the targeted machine/// Corresponds to the `#[cfg(target_pointer_width = {})]` in Rust code.target_vendor/// Vendor of the targeted machine/// Corresponds to the `#[cfg(target_vendor = {})]` in Rust code./// This currently returns `Some` only when when targetting nightly rustc version as well as/// for custom JSON targets.target_cfg/// Check if the configuration switch is set for target/// Corresponds to the `#[cfg({key} = {})]` in Rust code./// This function behaves specially in regard to custom JSON targets and will always return/// `false` for them currently./// let info = TargetInfo::new().expect("target info");/// let is_unix = info.target_cfg("unix");target_cfg_value/// Return the value of an arbitrary configuration key/// This function behaves specially in regard to custom JSON targets and will rarely return/// any extra target information./// assert_eq!(info.target_cfg_value("target_os"), Some(info.target_os()));/// assert_eq!(info.target_cfg_value("target_banana"), None);correct_archscorrect_vendorscorrect_oscorrect_envexternal_workexternal_search_workexternal_is_correct//! # DEPRECATED//! Use environment variables set by cargo from 1.14.0 onwards.//! They look like this: `CARGO_CFG_TARGET_OS`, `CARGO_CFG_TARGET_ENV`…//! Utility crate to handle the `TARGET` environment variable passed into build.rs scripts.//! Unlike rust’s `#[cfg(target…)]` attributes, `build.rs`-scripts do not expose a convenient way//! to detect the system the code will be built for in a way which would properly support//! cross-compilation.//! This crate exposes `target_arch`, `target_vendor`, `target_os` and `target_abi` very much in//! the same manner as the corresponding `cfg` attributes in Rust do, thus allowing `build.rs`//! script to adjust the output depending on the target the crate is being built for..//! Custom target json files are also supported.//! This crate is only useful if you’re using a build script (`build.rs`). Add dependency to this//! crate to your `Cargo.toml` via://! # ...//! target_build_utils = "0.1"//! Then write your `build.rs` like this://! extern crate target_build_utils;//! use target_build_utils::TargetInfo;//!     let target = TargetInfo::new().expect("could not get target info");//!     if target.target_os() == "windows" {//!         // conditional stuff for windows//! Now, when running `cargo build`, your `build.rs` should be aware of the properties of the//! target system when your crate is being cross-compiled.IoResultExtnot_supported/// Create a new temporary directory./// The `tempdir` function creates a directory in the file system/// and returns a [`TempDir`]./// The directory will be automatically deleted when the `TempDir`s/// destructor is run./// # Resource Leaking/// See [the resource leaking][resource-leaking] docs on `TempDir`./// If the directory can not be created, `Err` is returned./// #     if let Err(_) = run() {/// #         ::std::process::exit(1);/// # fn run() -> Result<(), io::Error> {/// // Create a directory inside of `std::env::temp_dir()`/// let tmp_dir = tempdir()?;/// let file_path = tmp_dir.path().join("my-temporary-note.txt");/// let mut tmp_file = File::create(file_path)?;/// writeln!(tmp_file, "Brian was here. Briefly.")?;/// // `tmp_dir` goes out of scope, the directory as well as/// // `tmp_file` will be deleted here./// drop(tmp_file);/// tmp_dir.close()?;/// [`TempDir`]: struct.TempDir.html/// [resource-leaking]: struct.TempDir.html#resource-leakingtempdir_in/// Create a new temporary directory in a specific directory./// The `tempdir_in` function creates a directory in the specified directory/// use tempfile::tempdir_in;/// // Create a directory inside of the current directory./// let tmp_dir = tempdir_in(".")?;/// A directory in the filesystem that is automatically deleted when/// it goes out of scope./// The [`TempDir`] type creates a directory on the file system that/// is deleted once it goes out of scope. At construction, the/// `TempDir` creates a new directory with a randomly generated name./// The default constructor, [`TempDir::new()`], creates directories in/// the location returned by [`std::env::temp_dir()`], but `TempDir`/// can be configured to manage a temporary directory in any location/// by constructing with a [`Builder`]./// After creating a `TempDir`, work with the file system by doing/// standard [`std::fs`] file system operations on its [`Path`],/// which can be retrieved with [`TempDir::path()`]. Once the `TempDir`/// value is dropped, the directory at the path will be deleted, along/// with any files and directories it contains. It is your responsibility/// to ensure that no further file system operations are attempted/// inside the temporary directory once it has been deleted./// Various platform-specific conditions may cause `TempDir` to fail/// to delete the underlying directory. It's important to ensure that/// handles (like [`File`] and [`ReadDir`]) to files inside the/// directory are dropped before the `TempDir` goes out of scope. The/// `TempDir` destructor will silently ignore any errors in deleting/// the directory; to instead handle errors call [`TempDir::close()`]./// Note that if the program exits before the `TempDir` destructor is/// run, such as via [`std::process::exit()`], by segfaulting, or by/// receiving a signal like `SIGINT`, then the temporary directory/// will not be deleted./// Create a temporary directory with a generated name:/// use tempfile::TempDir;/// let tmp_dir = TempDir::new()?;/// Create a temporary directory with a prefix in its name:/// use tempfile::Builder;/// // Create a directory inside of `std::env::temp_dir()`,/// // whose name will begin with 'example'./// let tmp_dir = Builder::new().prefix("example").tempdir()?;/// [`File`]: http://doc.rust-lang.org/std/fs/struct.File.html/// [`Path`]: http://doc.rust-lang.org/std/path/struct.Path.html/// [`ReadDir`]: http://doc.rust-lang.org/std/fs/struct.ReadDir.html/// [`TempDir::close()`]: struct.TempDir.html#method.close/// [`TempDir::new()`]: struct.TempDir.html#method.new/// [`TempDir::path()`]: struct.TempDir.html#method.path/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html/// [`std::fs`]: http://doc.rust-lang.org/std/fs/index.html/// [`std::process::exit()`]: http://doc.rust-lang.org/std/process/fn.exit.html/// Attempts to make a temporary directory inside of `env::temp_dir()`./// See [`Builder`] for more configuration./// The directory and everything inside it will be automatically deleted/// once the returned `TempDir` is destroyed./// Attempts to make a temporary directory inside of `dir`./// The directory and everything inside it will be automatically/// deleted once the returned `TempDir` is destroyed./// use std::fs::{self, File};/// // Create a directory inside of the current directory/// let tmp_dir = TempDir::new_in(".")?;/// Attempts to make a temporary directory with the specified prefix inside of/// `env::temp_dir()`. The directory and everything inside it will be automatically/// let tmp_dir = TempDir::with_prefix("foo-")?;/// let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap();/// assert!(tmp_name.starts_with("foo-"));with_prefix_in/// Attempts to make a temporary directory with the specified prefix inside/// the specified directory. The directory and everything inside it will be/// automatically deleted once the returned `TempDir` is destroyed./// let tmp_dir = TempDir::with_prefix_in("foo-", ".")?;/// Accesses the [`Path`] to the temporary directory./// let tmp_path;///    let tmp_dir = TempDir::new()?;///    tmp_path = tmp_dir.path().to_owned();///    // Check that the temp directory actually exists.///    assert!(tmp_path.exists());///    // End of `tmp_dir` scope, directory will be deleted/// // Temp directory should be deleted by now/// assert_eq!(tmp_path.exists(), false);/// Persist the temporary directory to disk, returning the [`PathBuf`] where it is located./// This consumes the [`TempDir`] without deleting directory on the filesystem, meaning that/// the directory will no longer be automatically deleted./// [`PathBuf`]: http://doc.rust-lang.org/std/path/struct.PathBuf.html/// // Persist the temporary directory to disk,/// // getting the path where it is./// let tmp_path = tmp_dir.into_path();/// // Delete the temporary directory ourselves./// fs::remove_dir_all(tmp_path)?;/// Closes and removes the temporary directory, returning a `Result`./// Although `TempDir` removes the directory on drop, in the destructor/// any errors are ignored. To detect errors cleaning up the temporary/// directory, call `close` instead./// This function may return a variety of [`std::io::Error`]s that result from deleting/// the files and directories contained with the temporary directory,/// as well as from deleting the temporary directory itself. These errors/// may be platform specific./// [`std::io::Error`]: http://doc.rust-lang.org/std/io/struct.Error.html/// // Create a directory inside of `std::env::temp_dir()`./// // By closing the `TempDir` explicitly we can check that it has/// // been deleted successfully. If we don't close it explicitly,/// // the directory will still be deleted when `tmp_dir` goes out/// // of scope, but we won't know whether deleting the directory/// // succeeded.PathErrorwith_err_pathreopenkeepcreate_unlinkedcreate_unixMoveFileExWReOpenFileSetFileAttributesWFILE_ATTRIBUTE_NORMALFILE_FLAG_DELETE_ON_CLOSEFILE_GENERIC_READFILE_GENERIC_WRITEFILE_SHARE_DELETEMOVEFILE_REPLACE_EXISTING/// Create a new temporary file./// The file will be created in the location returned by [`std::env::temp_dir()`]./// This variant is secure/reliable in the presence of a pathological temporary file cleaner./// The temporary file will be automatically removed by the OS when the last handle to it is closed./// This doesn't rely on Rust destructors being run, so will (almost) never fail to clean up the temporary file./// If the file can not be created, `Err` is returned./// use tempfile::tempfile;/// // Create a file inside of `std::env::temp_dir()`./// let mut file = tempfile()?;/// writeln!(file, "Brian was here. Briefly.")?;tempfile_in/// Create a new temporary file in the specified directory./// If the temporary file isn't created in [`std::env::temp_dir()`] then temporary file cleaners aren't an issue./// use tempfile::tempfile_in;/// // Create a file inside of the current working directory/// let mut file = tempfile_in("./")?;/// The underlying IO error.TempPath/// The temporary file path that couldn't be persisted.PathPersistError/// Error returned when persisting a temporary file path fails./// A path to a named temporary file without an open file handle./// This is useful when the temporary file needs to be used by a child process,/// When dropped, the temporary file is deleted./// Close and remove the temporary file./// Use this if you want to detect errors in deleting the file./// If the file cannot be deleted, `Err` is returned./// use tempfile::NamedTempFile;/// let file = NamedTempFile::new()?;/// // Close the file, but keep the path to it around./// let path = file.into_temp_path();/// // By closing the `TempPath` explicitly, we can check that it has/// // been deleted successfully. If we don't close it explicitly, the/// // file will still be deleted when `file` goes out of scope, but we/// // won't know whether deleting the file succeeded./// path.close()?;/// Persist the temporary file at the target path./// If a file exists at the target path, persist will atomically replace it./// If this method fails, it will return `self` in the resulting/// [`PathPersistError`]./// Note: Temporary files cannot be persisted across filesystems. Also/// neither the file contents nor the containing directory are/// synchronized, so the update may not yet have reached the disk when/// `persist` returns./// Only use this method if you're positive that a temporary file cleaner/// won't have deleted your file. Otherwise, you might end up persisting an/// attacker controlled file./// If the file cannot be moved to the new location, `Err` is returned./// # use std::io::{self, Write};/// let mut file = NamedTempFile::new()?;/// path.persist("./saved_file.txt")?;/// [`PathPersistError`]: struct.PathPersistError.htmlpersist_noclobber/// Persist the temporary file at the target path if and only if no file exists there./// If a file exists at the target path, fail. If this method fails, it will/// return `self` in the resulting [`PathPersistError`]./// Note: Temporary files cannot be persisted across filesystems. Also Note:/// This method is not atomic. It can leave the original link to the/// temporary file behind./// If the file cannot be moved to the new location or a file already exists/// there, `Err` is returned./// path.persist_noclobber("./saved_file.txt")?;/// Keep the temporary file from being deleted. This function will turn the/// temporary file into a non-temporary file without moving it./// On some platforms (e.g., Windows), we need to mark the file as/// non-temporary. This operation could fail./// let path = path.keep()?;/// Create a new TempPath from an existing path. This can be done even if no/// file exists at the given path./// This is mostly useful for interacting with libraries and external/// components that provide files to be consumed or expect a path with no/// existing file to be given./// A named temporary file./// The default constructor, [`NamedTempFile::new()`], creates files in/// the location returned by [`std::env::temp_dir()`], but `NamedTempFile`/// can be configured to manage a temporary file in any location/// by constructing with [`NamedTempFile::new_in()`]./// Most operating systems employ temporary file cleaners to delete old/// temporary files. Unfortunately these temporary file cleaners don't always/// reliably _detect_ whether the temporary file is still being used./// Specifically, the following sequence of events can happen:/// 1. A user creates a temporary file with `NamedTempFile::new()`./// 2. Time passes./// 3. The temporary file cleaner deletes (unlinks) the temporary file from the///    filesystem./// 4. Some other program creates a new file to replace this deleted temporary///    file./// 5. The user tries to re-open the temporary file (in the same program or in a///    different program) by path. Unfortunately, they'll end up opening the///    file created by the other program, not the original file./// ## Operating System Specific Concerns/// The behavior of temporary files and temporary file cleaners differ by/// ### Windows/// On Windows, open files _can't_ be deleted. This removes most of the concerns/// around temporary file cleaners./// Furthermore, temporary files are, by default, created in per-user temporary/// file directories so only an application running as the same user would be/// able to interfere (which they could do anyways). However, an application/// running as the same user can still _accidentally_ re-create deleted/// temporary files if the number of random bytes in the temporary file name is/// So, the only real concern on Windows is:/// 1. Opening a named temporary file in a world-writable directory./// 2. Using the `into_temp_path()` and/or `into_parts()` APIs to close the file///    handle without deleting the underlying file./// 3. Continuing to use the file by path./// ### UNIX/// Unlike on Windows, UNIX (and UNIX like) systems allow open files to be/// "unlinked" (deleted)./// #### MacOS/// Like on Windows, temporary files are created in per-user temporary file/// directories by default so calling `NamedTempFile::new()` should be/// relatively safe./// #### Linux/// Unfortunately, most _Linux_ distributions don't create per-user temporary/// file directories. Worse, systemd's tmpfiles daemon (a common temporary file/// cleaner) will happily remove open temporary files if they haven't been/// modified within the last 10 days./// If the program exits before the `NamedTempFile` destructor is/// run, the temporary file will not be deleted. This can happen/// if the process exits using [`std::process::exit()`], a segfault occurs,/// receiving an interrupt signal like `SIGINT` that is not handled, or by using/// a statically declared `NamedTempFile` instance (like with [`lazy_static`])./// Use the [`tempfile()`] function unless you need a named file path./// [`tempfile()`]: fn.tempfile.html/// [`NamedTempFile::new()`]: #method.new/// [`NamedTempFile::new_in()`]: #method.new_in/// [`lazy_static`]: https://github.com/rust-lang-nursery/lazy-static.rs/issues/62/// The temporary file that couldn't be persisted.PersistError/// Error returned when persisting a temporary file fails./// Create a new named temporary file./// This will create a temporary file in the default temporary file/// directory (platform dependent). This has security implications on many/// platforms so please read the security section of this type's/// Reasons to use this method:///   1. The file has a short lifetime and your temporary file cleaner is///      sane (doesn't delete recently accessed files).///   2. You trust every user on your system (i.e. you are the only user).///   3. You have disabled your system's temporary file cleaner or verified///      that your system doesn't have a temporary file cleaner./// Reasons not to use this method:///   1. You'll fix it later. No you won't.///   2. You don't care about the security of the temporary file. If none of///      the "reasons to use this method" apply, referring to a temporary///      file by name may allow an attacker to create/overwrite your///      non-temporary files. There are exceptions but if you don't already///      know them, don't use this method./// Create a named temporary file and write some data to it:/// # fn run() -> Result<(), ::std::io::Error> {/// Create a new named temporary file in the specified directory./// This is equivalent to:/// Builder::new().tempfile_in(dir)/// See [`NamedTempFile::new()`] for details./// Create a new named temporary file with the specified filename prefix./// Create a new named temporary file with the specified filename prefix,/// in the specified directory./// Builder::new().prefix(&prefix).tempfile_in(directory)/// Get the temporary file's path./// Referring to a temporary file's path may not be secure in all cases./// Please read the security section on the top level documentation of this/// type for details./// println!("{:?}", file.path());/// // By closing the `NamedTempFile` explicitly, we can check that it has/// // the file will still be deleted when `file` goes out/// // of scope, but we won't know whether deleting the file/// file.close()?;/// [`PersistError`]./// This method persists the temporary file using its path and may not be/// secure in all cases. Please read the security section on the top/// level documentation of this type for details./// let mut persisted_file = file.persist("./saved_file.txt")?;/// writeln!(persisted_file, "Brian was here. Briefly.")?;/// [`PersistError`]: struct.PersistError.html/// return `self` in the resulting PersistError./// If the file cannot be moved to the new location or a file already exists there,/// let mut persisted_file = file.persist_noclobber("./saved_file.txt")?;/// let (file, path) = file.keep()?;/// Get a reference to the underlying file./// Get a mutable reference to the underlying file.into_file/// Convert the temporary file into a `std::fs::File`./// The inner file will be deleted.into_temp_path/// Closes the file, leaving only the temporary file path./// This is useful when another process must be able to open the temporary/// Converts the named temporary file into its constituent parts./// Note: When the path is dropped, the file is deleted but the file handle/// is still usable./// Creates a `NamedTempFile` from its constituent parts./// This can be used with [`NamedTempFile::into_parts`] to reconstruct the/// `NamedTempFile`./// Securely reopen the temporary file./// This function is useful when you need multiple independent handles to/// the same file. It's perfectly fine to drop the original `NamedTempFile`/// while holding on to `File`s returned by this function; the `File`s will/// remain usable. However, they may not be nameable./// If the file cannot be reopened, `Err` is returned./// Unlike `File::open(my_temp_file.path())`, `NamedTempFile::reopen()`/// guarantees that the re-opened file is the _same_ file, even in the/// presence of pathological temporary file cleaners./// let another_handle = file.reopen()?;NUM_RETRIESNUM_RAND_CHARSspooledspooled_tempfileSpooledTempFilerandom_lenpermissions/// Create a new temporary file or directory with custom parameters./// Create a new `Builder`./// Create a named temporary file and write some data into it:/// let named_tempfile = Builder::new()///     .prefix("my-temporary-note")///     .suffix(".txt")///     .rand_bytes(5)///     .tempfile()?;/// let name = named_tempfile///     .path()///     .file_name().and_then(OsStr::to_str);/// if let Some(name) = name {///     assert!(name.starts_with("my-temporary-note"));///     assert!(name.ends_with(".txt"));///     assert_eq!(name.len(), "my-temporary-note.txt".len() + 5);/// Create a temporary directory and add a file to it:/// let dir = Builder::new()///     .prefix("my-temporary-dir")///     .tempdir()?;/// let file_path = dir.path().join("my-temporary-note.txt");/// let mut file = File::create(file_path)?;/// // By closing the `TempDir` explicitly, we can check that it has/// // the directory will still be deleted when `dir` goes out/// drop(file);/// dir.close()?;/// Create a temporary directory with a chosen prefix under a chosen folder:///     .tempdir_in("folder-with-tempdirs")?;/// Set a custom filename prefix./// Path separators are legal but not advisable./// Default: `.tmp`./// # use tempfile::Builder;/// Set a custom filename suffix./// Default: empty./// Set the number of random bytes./// Default: `6`./// Set the file to be opened in append mode./// Default: `false`./// The permissions to create the tempfile or [tempdir](Self::tempdir) with./// This allows to them differ from the default mode of `0o600` on Unix./// By default, the permissions of tempfiles on unix are set for it to be/// readable and writable by the owner only, yielding the greatest amount/// of security./// As this method allows to widen the permissions, security would be/// reduced in such cases./// # Platform Notes/// ## Unix/// The actual permission bits set on the tempfile or tempdir will be affected by the/// `umask` applied by the underlying syscall./// ## Windows and others/// This setting is unsupported and trying to set a file or directory read-only/// will cause an error to be returned../// Create a named temporary file that is world-readable.///     use std::os::unix::fs::PermissionsExt;///     let all_read_write = std::fs::Permissions::from_mode(0o666);///     let tempfile = Builder::new().permissions(all_read_write).tempfile()?;///     let actual_permissions = tempfile.path().metadata()?.permissions();///     assert_ne!(///         actual_permissions.mode() & !0o170000,///         0o600,///         "we get broader permissions than the default despite umask"/// Create a named temporary directory that is restricted to the owner.///     let owner_rwx = std::fs::Permissions::from_mode(0o700);///     let tempdir = Builder::new().permissions(owner_rwx).tempdir()?;///     let actual_permissions = tempdir.path().metadata()?.permissions();///         0o700,///         "we get the narrow permissions we asked for"/// Create the named temporary file./// See [the security][security] docs on `NamedTempFile`./// # Resource leaking/// See [the resource leaking][resource-leaking] docs on `NamedTempFile`./// If the file cannot be created, `Err` is returned./// let tempfile = Builder::new().tempfile()?;/// [security]: struct.NamedTempFile.html#security/// [resource-leaking]: struct.NamedTempFile.html#resource-leaking/// Create the named temporary file in the specified directory./// let tempfile = Builder::new().tempfile_in("./")?;/// Attempts to make a temporary directory inside of `env::temp_dir()` whose/// name will have the prefix, `prefix`. The directory and/// everything inside it will be automatically deleted once the/// returned `TempDir` is destroyed./// let tmp_dir = Builder::new().tempdir()?;/// let tmp_dir = Builder::new().tempdir_in("./")?;/// Attempts to create a temporary file (or file-like object) using the/// provided closure. The closure is passed a temporary file path and/// returns an [`std::io::Result`]. The path provided to the closure will be/// inside of [`std::env::temp_dir()`]. Use [`Builder::make_in`] to provide/// a custom temporary directory. If the closure returns one of the/// following errors, then another randomized file path is tried:///  - [`std::io::ErrorKind::AlreadyExists`]///  - [`std::io::ErrorKind::AddrInUse`]/// This can be helpful for taking full control over the file creation, but/// leaving the temporary file path construction up to the library. This/// also enables creating a temporary UNIX domain socket, since it is not/// possible to bind to a socket that already exists./// Note that [`Builder::append`] is ignored when using [`Builder::make`]./// This has the same [security implications][security] as/// [`NamedTempFile`], but with additional caveats. Specifically, it is up/// to the closure to ensure that the file does not exist and that such a/// check is *atomic*. Otherwise, a [time-of-check to time-of-use/// bug][TOCTOU] could be introduced./// For example, the following is **not** secure:/// // This is NOT secure!/// let tempfile = Builder::new().make(|path| {///     if path.is_file() {///         return Err(io::ErrorKind::AlreadyExists.into());///     // Between the check above and the usage below, an attacker could///     // have replaced `path` with another file, which would get truncated///     // by `File::create`.///     File::create(path)/// Note that simply using [`std::fs::File::create`] alone is not correct/// because it does not fail if the file already exists:/// // This could overwrite an existing file!/// let tempfile = Builder::new().make(|path| File::create(path))?;/// For creating regular temporary files, use [`Builder::tempfile`] instead/// to avoid these problems. This function is meant to enable more exotic/// use-cases./// If the closure returns any error besides/// [`std::io::ErrorKind::AlreadyExists`] or/// [`std::io::ErrorKind::AddrInUse`], then `Err` is returned./// let tempsock = Builder::new().make(|path| UnixListener::bind(path))?;/// [TOCTOU]: https://en.wikipedia.org/wiki/Time-of-check_to_time-of-usemake_in/// This is the same as [`Builder::make`], except `dir` is used as the base/// directory for the temporary file path./// See [`Builder::make`] for more details and security implications./// let tempsock = Builder::new().make_in("./", |path| UnixListener::bind(path))?;//! Temporary files and directories.//! - Use the [`tempfile()`] function for temporary files//! - Use the [`tempdir()`] function for temporary directories.//! This crate provides several approaches to creating temporary files and directories.//! [`tempfile()`] relies on the OS to remove the temporary file once the last handle is closed.//! [`TempDir`] and [`NamedTempFile`] both rely on Rust destructors for cleanup.//! When choosing between the temporary file variants, prefer `tempfile`//! unless you either need to know the file's path or to be able to persist it.//! ## Resource Leaking//! `tempfile` will (almost) never fail to cleanup temporary resources. However `TempDir` and `NamedTempFile` will//! fail if their destructors don't run. This is because `tempfile` relies on the OS to cleanup the//! underlying file, while `TempDir` and `NamedTempFile` rely on rust destructors to do so.//! Destructors may fail to run if the process exits through an unhandled signal interrupt (like `SIGINT`),//! or if the instance is declared statically (like with [`lazy_static`]), among other possible//! reasons.//! ## Security//! In the presence of pathological temporary file cleaner, relying on file paths is unsafe because//! a temporary file cleaner could delete the temporary file which an attacker could then replace.//! `tempfile` doesn't rely on file paths so this isn't an issue. However, `NamedTempFile` does//! rely on file paths for _some_ operations. See the security documentation on//! the `NamedTempFile` type for more information.//! ## Early drop pitfall//! Because `TempDir` and `NamedTempFile` rely on their destructors for cleanup, this can lead//! to an unexpected early removal of the directory/file, usually when working with APIs which are//! generic over `AsRef<Path>`. Consider the following example://! # use tempfile::tempdir;//! # use std::process::Command;//! #     if let Err(_) = run() {//! #         ::std::process::exit(1);//! # fn run() -> Result<(), io::Error> {//! // Create a directory inside of `std::env::temp_dir()`.//! let temp_dir = tempdir()?;//! // Spawn the `touch` command inside the temporary directory and collect the exit status//! // Note that `temp_dir` is **not** moved into `current_dir`, but passed as a reference//! let exit_status = Command::new("touch").arg("tmp").current_dir(&temp_dir).status()?;//! assert!(exit_status.success());//! This works because a reference to `temp_dir` is passed to `current_dir`, resulting in the//! destructor of `temp_dir` being run after the `Command` has finished execution. Moving the//! `TempDir` into the `current_dir` call would result in the `TempDir` being converted into//! an internal representation, with the original value being dropped and the directory thus//! being deleted, before the command can be executed.//! The `touch` command would fail with an `No such file or directory` error.//! Create a temporary file and write some data into it://! use tempfile::tempfile;//! // Create a file inside of `std::env::temp_dir()`.//! let mut file = tempfile()?;//! writeln!(file, "Brian was here. Briefly.")?;//! Create a named temporary file and open an independent file handle://! use tempfile::NamedTempFile;//! use std::io::{self, Write, Read};//! let text = "Brian was here. Briefly.";//! let mut file1 = NamedTempFile::new()?;//! // Re-open it.//! let mut file2 = file1.reopen()?;//! // Write some test data to the first handle.//! file1.write_all(text.as_bytes())?;//! // Read the test data using the second handle.//! let mut buf = String::new();//! file2.read_to_string(&mut buf)?;//! assert_eq!(buf, text);//! Create a temporary directory and add a file to it://! use tempfile::tempdir;//! let dir = tempdir()?;//! let file_path = dir.path().join("my-temporary-note.txt");//! let mut file = File::create(file_path)?;//! // By closing the `TempDir` explicitly, we can check that it has//! // been deleted successfully. If we don't close it explicitly,//! // the directory will still be deleted when `dir` goes out//! // of scope, but we won't know whether deleting the directory//! // succeeded.//! drop(file);//! dir.close()?;//! [`tempfile()`]: fn.tempfile.html//! [`tempdir()`]: fn.tempdir.html//! [`TempDir`]: struct.TempDir.html//! [`NamedTempFile`]: struct.NamedTempFile.html//! [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html//! [`lazy_static`]: https://github.com/rust-lang-nursery/lazy-static.rs/issues/62SpooledDataInMemoryOnDisk/// A wrapper for the two states of a `SpooledTempFile`./// An object that behaves like a regular temporary file, but keeps data in/// memory until it reaches a configured size, at which point the data is/// written to a temporary file on disk, and further operations use the file/// on disk./// Create a new spooled temporary file./// This variant is secure/reliable in the presence of a pathological temporary/// file cleaner./// The temporary file will be automatically removed by the OS when the last/// handle to it is closed. This doesn't rely on Rust destructors being run, so/// will (almost) never fail to clean up the temporary file./// use tempfile::spooled_tempfile;/// let mut file = spooled_tempfile(15);/// writeln!(file, "short line")?;/// assert!(!file.is_rolled());/// // as a result of this write call, the size of the data will exceed/// // `max_size` (15), so it will be written to a temporary file on disk,/// // and the in-memory buffer will be dropped/// writeln!(file, "marvin gardens")?;/// assert!(file.is_rolled());is_rolled/// Returns true if the file has been rolled over to disk./// Rolls over to a file on disk, regardless of current size. Does nothing/// if already rolled over./// Consumes and returns the inner `SpooledData` type.create_helpersupports_color/// Returns true if and only if the underlying writer supports colors./// Set the color settings of the writer./// Subsequent writes to this writer will use these settings until either/// `reset` is called or new color settings are set./// If there was a problem setting the color settings, then an error is/// Reset the current color settings to their original settings./// If there was a problem resetting the color settings, then an error is/// Note that this does not reset hyperlinks. Those need to be/// reset on their own, e.g., by calling `set_hyperlink` with/// [`HyperlinkSpec::none`].is_synchronous/// Returns true if and only if the underlying writer must synchronously/// interact with an end user's device in order to control colors. By/// default, this always returns `false`./// In practice, this should return `true` if the underlying writer is/// manipulating colors using the Windows console APIs./// This is useful for writing generic code (such as a buffered writer)/// that can perform certain optimizations when the underlying writer/// doesn't rely on synchronous APIs. For example, ANSI escape sequences/// can be passed through to the end user's device as is.set_hyperlinkHyperlinkSpec/// Set the current hyperlink of the writer./// The typical way to use this is to first call it with a/// [`HyperlinkSpec::open`] to write the actual URI to a tty that supports/// [OSC-8]. At this point, the caller can now write the label for the/// hyperlink. This may include coloring or other styles. Once the caller/// has finished writing the label, one should call this method again with/// [`HyperlinkSpec::close`]./// If there was a problem setting the hyperlink, then an error is/// This defaults to doing nothing./// [OSC8]: https://github.com/Alhadis/OSC8-Adoption/supports_hyperlinks/// Returns true if and only if the underlying writer supports hyperlinks./// This can be used to avoid generating hyperlink URIs unnecessarily./// This defaults to `false`./// This trait describes the behavior of writers that support colored output./// Try very hard to emit colors. This includes emitting ANSI colors/// on Windows if the console API is unavailable./// AlwaysAnsi is like Always, except it never tries to use anything other/// than emitting ANSI color codes./// Try to use colors, but don't force the issue. If the console isn't/// available on Windows, or if TERM=dumb, or if `NO_COLOR` is defined, for/// example, then don't use colors./// ColorChoice represents the color preferences of an end user./// The `Default` implementation for this type will select `Auto`, which tries/// to do the right thing based on the current environment./// The `FromStr` implementation for this type converts a lowercase kebab-case/// string of the variant name to the corresponding variant. Any other string/// results in an error./// The default is `Auto`.ColorChoiceParseErrorshould_attempt_color/// Returns true if we should attempt to write colored output.env_allows_colorunknown_choice/// An error that occurs when parsing a `ColorChoice` fails.StandardStreamTypeStdoutBufferedStderrBuffered/// `std::io` implements `Stdout` and `Stderr` (and their `Lock` variants) as/// separate types, which makes it difficult to abstract over them. We use/// some simple internal enum types to work around this.IoStandardStreamIoStandardStreamLockWriterInnerLossyStandardStreamStandardStream/// Satisfies `io::Write` and `WriteColor`, and supports optional coloring/// to either of the standard output streams, stdout and stderr.WriterInnerLockStandardStreamLock/// `StandardStreamLock` is a locked reference to a `StandardStream`./// This implements the `io::Write` and `WriteColor` traits, and is constructed/// via the `Write::lock` method./// `StandardStream`.BufferedStandardStream/// Like `StandardStream`, but does buffered writing.NoColor/// WriterInner is a (limited) generic representation of a writer. It is/// limited because W should only ever be stdout/stderr on Windows.Unreachable/// What a gross hack. On Windows, we need to specify a lifetime for the/// console when in a locked state, but obviously don't need to do that/// on Unix, which makes the `'a` unused. To satisfy the compiler, we need/// a PhantomData./// WriterInnerLock is a (limited) generic representation of a writer. It is/// Create a new `StandardStream` with the given color preferences that/// writes to standard output./// On Windows, if coloring is desired and a Windows console could not be/// found, then ANSI escape sequences are used instead./// The specific color/style settings can be configured when writing via/// the `WriteColor` trait./// writes to standard error./// Lock the underlying writer./// The lock guard returned also satisfies `io::Write` and/// `WriteColor`./// This method is **not reentrant**. It may panic if `lock` is called/// while a `StandardStreamLock` is still alive./// Create a new `BufferedStandardStream` with the given color preferences/// that writes to standard output via a buffered writer./// that writes to standard error via a buffered writer./// Create a new inner writer for a standard stream with the given color/// preferences.printedcolor_choice/// Writes colored buffers to stdout or stderr./// Writable buffers can be obtained by calling `buffer` on a `BufferWriter`./// This writer works with terminals that support ANSI escape sequences or/// with a Windows console./// It is intended for a `BufferWriter` to be put in an `Arc` and written to/// from multiple threads simultaneously./// Create a new `BufferWriter` that writes to a standard stream with the/// given color preferences./// The specific color/style settings can be configured when writing to/// the buffers themselves./// Create a new `BufferWriter` that writes to stdout with the given/// color preferences./// Create a new `BufferWriter` that writes to stderr with the given/// If set, the separator given is printed between buffers. By default, no/// separator is printed./// The default value is `None`./// Creates a new `Buffer` with the current color preferences./// A `Buffer` satisfies both `io::Write` and `WriteColor`. A `Buffer` can/// be printed using the `print` method./// Prints the contents of the given buffer./// It is safe to call this from multiple threads simultaneously. In/// particular, all buffers are written atomically. No interleaving willBufferInner/// Write colored text to memory./// `Buffer` is a platform independent abstraction for printing colored text to/// an in memory buffer. When the buffer is printed using a `BufferWriter`, the/// color information will be applied to the output device (a tty on Unix and a/// console on Windows)./// A `Buffer` is typically created by calling the `BufferWriter.buffer`/// method, which will take color preferences and the environment into/// account. However, buffers can also be manually created using `no_color`,/// `ansi` or `console` (on Windows)./// No coloring information should be applied. This ignores all coloring/// directives./// Apply coloring using ANSI escape sequences embedded into the buffer./// BufferInner is an enumeration of different buffer types./// Create a new buffer with the given color settings./// Create a buffer that drops all color information./// Create a buffer that uses ANSI escape sequences./// Returns true if and only if this buffer is empty./// Returns the length of this buffer in bytes./// Clears this buffer./// Consume this buffer and return the underlying raw data./// On Windows, this unrecoverably drops all color information associated/// with the buffer./// Return the underlying data of the buffer./// Return the underlying data of the buffer as a mutable slice./// Satisfies `WriteColor` but ignores all color options./// Create a new writer that satisfies `WriteColor` but drops all color/// Consume this `NoColor` value and return the inner writer./// Return a reference to the inner writer./// Return a mutable reference to the inner writer./// Satisfies `WriteColor` using standard ANSI escape sequences./// Create a new writer that satisfies `WriteColor` using standard ANSI/// escape sequences./// Consume this `Ansi` value and return the inner writer.// Adding this method here is not required because it has a default impl,// but it seems to provide a perf improvement in some cases when using// a `BufWriter` with lots of writes.// See https://github.com/BurntSushi/termcolor/pull/56 for more details// and a minimized example.write_colorintense/// A color specification./// Create a new color specification that has no colors or styles./// Get the foreground color.set_fg/// Set the foreground color./// Get the background color./// Get whether this is bold or not./// Note that the bold setting has no effect in a Windows console./// Set whether the text is bolded or not./// Get whether this is dimmed or not./// Note that the dimmed setting has no effect in a Windows console./// Set whether the text is dimmed or not./// Get whether this is italic or not./// Note that the italic setting has no effect in a Windows console.set_italic/// Set whether the text is italicized or not./// Get whether this is underline or not./// Note that the underline setting has no effect in a Windows console./// Set whether the text is underlined or not./// Get whether this is strikethrough or not./// Note that the strikethrough setting has no effect in a Windows console./// Set whether the text is strikethrough or not./// Get whether reset is enabled or not./// reset is enabled by default. When disabled and using ANSI escape/// sequences, a "reset" code will be emitted every time a `ColorSpec`'s/// settings are applied./// Note that the reset setting has no effect in a Windows console.set_reset/// Set whether to reset the terminal whenever color settings are applied./// Typically this is useful if callers have a requirement to more/// scrupulously manage the exact sequence of escape codes that are emitted/// when using ANSI for colors./// Get whether this is intense or not./// On Unix-like systems, this will output the ANSI escape sequence/// that will print a high-intensity version of the color/// On Windows systems, this will output the ANSI escape sequence/// that will print a brighter version of the color specified./// Set whether the text is intense or not./// Returns true if this color specification has no colors or styles./// Clears this color specification so that it has no color/style settings.from_str_numericParseColorError/// Parses a numeric color string, either ANSI or RGB.ParseColorErrorKind/// An error from parsing an invalid color specification.InvalidAnsi256InvalidRgb/// Return the string that couldn't be parsed as a valid color./// A hyperlink specification./// Creates a new hyperlink specification./// Creates a hyperlink specification representing no hyperlink./// Returns the URI of the hyperlink if one is attached to this spec.assert_is_sendstandard_stream_is_sendtest_simple_parse_oktest_256_parse_oktest_256_parse_err_out_of_rangetest_rgb_parse_oktest_rgb_parse_err_out_of_rangetest_rgb_parse_err_bad_formattest_var_ansi_write_rgbtest_no_resettest_var_ansi_write_256test_is_nonetest_ansi_hyperlink/*!
This crate provides a cross platform abstraction for writing colored text to
a terminal. Colors are written using either ANSI escape sequences or by
communicating with a Windows console. Much of this API was motivated by use
inside command line applications, where colors or styles can be configured
by the end user and/or the environment.

This crate also provides platform independent support for writing colored text
to an in memory buffer. While this is easy to do with ANSI escape sequences
(because they are in the buffer themselves), it is trickier to do with the
Windows console API, which requires synchronous communication.

In ANSI mode, this crate also provides support for writing hyperlinks.

# Organization

The `WriteColor` trait extends the `io::Write` trait with methods for setting
colors or resetting them.

`StandardStream` and `StandardStreamLock` both satisfy `WriteColor` and are
analogous to `std::io::Stdout` and `std::io::StdoutLock`, or `std::io::Stderr`
and `std::io::StderrLock`.

`Buffer` is an in memory buffer that supports colored text. In a parallel
program, each thread might write to its own buffer. A buffer can be printed to
using a `BufferWriter`. The advantage of this design is that each thread can
work in parallel on a buffer without having to synchronize access to global
resources such as the Windows console. Moreover, this design also prevents
interleaving of buffer output.

`Ansi` and `NoColor` both satisfy `WriteColor` for arbitrary implementors of
`io::Write`. These types are useful when you know exactly what you need. An
analogous type for the Windows console is not provided since it cannot exist.

# Example: using `StandardStream`

The `StandardStream` type in this crate works similarly to `std::io::Stdout`,
except it is augmented with methods for coloring by the `WriteColor` trait.
For example, to write some green text:

```rust,no_run
# fn test() -> Result<(), Box<::std::error::Error>> {
use std::io::Write;
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};

let mut stdout = StandardStream::stdout(ColorChoice::Always);
stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
writeln!(&mut stdout, "green text!")?;
# Ok(()) }
```

Note that any text written to the terminal now will be colored
green when using ANSI escape sequences, even if it is written via
stderr, and even if stderr had previously been set to `Color::Red`.
Users will need to manage any color changes themselves by calling
[`WriteColor::set_color`](trait.WriteColor.html#tymethod.set_color), and this
may include calling [`WriteColor::reset`](trait.WriteColor.html#tymethod.reset)
before the program exits to a shell.

# Example: using `BufferWriter`

A `BufferWriter` can create buffers and write buffers to stdout or stderr. It
does *not* implement `io::Write` or `WriteColor` itself. Instead, `Buffer`
implements `io::Write` and `io::WriteColor`.

This example shows how to print some green text to stderr.

```rust,no_run
# fn test() -> Result<(), Box<::std::error::Error>> {
use std::io::Write;
use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};

let mut bufwtr = BufferWriter::stderr(ColorChoice::Always);
let mut buffer = bufwtr.buffer();
buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
writeln!(&mut buffer, "green text!")?;
bufwtr.print(&buffer)?;
# Ok(()) }
```

# Detecting presence of a terminal

In many scenarios when using color, one often wants to enable colors
automatically when writing to a terminal and disable colors automatically when
writing to anything else. The typical way to achieve this in Unix environments
is via libc's
[`isatty`](https://man7.org/linux/man-pages/man3/isatty.3.html)
function.
Unfortunately, this notoriously does not work well in Windows environments. To
work around that, the recommended solution is to use the standard library's
[`IsTerminal`](https://doc.rust-lang.org/std/io/trait.IsTerminal.html) trait.
It goes out of its way to get it as right as possible in Windows environments.

For example, in a command line application that exposes a `--color` flag,
your logic for how to enable colors might look like this:

```ignore
use std::io::IsTerminal;

use termcolor::{ColorChoice, StandardStream};

let preference = argv.get_flag("color").unwrap_or("auto");
let mut choice = preference.parse::<ColorChoice>()?;
if choice == ColorChoice::Auto && !std::io::stdin().is_terminal() {
    choice = ColorChoice::Never;
}
let stdout = StandardStream::stdout(choice);
// ... write to stdout
```

Currently, `termcolor` does not provide anything to do this for you.
*/// #[cfg(doctest)]// use doc_comment::doctest;// doctest!("../README.md");// Same rigmarole for the locked variants of the standard streams.TERMINFOTERMCAP/// Returns the name of the capability in its long form./// Parse the capability from its raw value./// Convert the capability into its raw value./// A trait for any object that will represent a terminal capability./// A number./// An ASCII string requiring expansion./// Possible value types for capabilities.Expansion/// Expansion helper struct./// Expand using the given context./// Expand to the given output./// Expand into a vector.AutoLeftMarginAutoRightMarginNoEscCtlcCeolStandoutGlitchEatNewlineGlitchEraseOverstrikeGenericTypeHardCopyHasMetaKeyHasStatusLineInsertNullGlitchMemoryAboveMemoryBelowMoveInsertModeMoveStandoutModeOverStrikeStatusLineEscOkDestTabsMagicSmsoTildeGlitchTransparentUnderlineXonXoffNeedsXonXoffPrtrSilentHardCursorNonRevRmcupNoPadCharNonDestScrollRegionCanChangeBackColorEraseHueLightnessSaturationColAddrGlitchCrCancelsMicroModeHasPrintWheelRowAddrGlitchSemiAutoRightMarginCpiChangesResLpiChangesResBackspacesWithBsCrtNoScrollingNoCorrectlyWorkingCrGnuHasMetaKeyLinefeedIsNewlineHasHardwareTabsReturnDoesClrEolInitTabsLinesOfMemoryMagicCookieGlitchPaddingBaudRateVirtualTerminalWidthStatusLineNumLabelsLabelHeightLabelWidthMaxAttributesMaximumWindowsMaxColorsMaxPairsNoColorVideoBufferCapacityDotVertSpacingDotHorzSpacingMaxMicroAddressMaxMicroJumpMicroColSizeMicroLineSizeNumberOfPinsOutputResCharOutputResLineOutputResHorzInchOutputResVertInchPrintRateWideCharSizeBitImageEntwiningBitImageTypeMagicCookieGlitchUlCarriageReturnDelayNewLineDelayBackspaceDelayHorizontalTabDelayNumberOfFunctionKeysBackTabr" Begin expanding the capability."r" Pass all expansion parameters at once."ClearAllTabsClearScreenClrEolClrEosCommandCharacterCursorDownCursorHomeCursorInvisibleCursorMemAddressCursorNormalCursorRightCursorToLlCursorUpCursorVisibleDeleteCharacterDeleteLineDisStatusLineDownHalfLineEnterAltCharsetModeEnterBlinkModeEnterBoldModeEnterCaModeEnterDeleteModeEnterDimModeEnterInsertModeEnterSecureModeEnterProtectedModeEnterReverseModeEnterStandoutModeEnterUnderlineModeExitAltCharsetModeExitAttributeModeExitCaModeExitDeleteModeExitInsertModeExitStandoutModeExitUnderlineModeFlashScreenFromStatusLineInit1StringInit2StringInit3StringInitFileInsertCharacterInsertLineInsertPaddingKeyBackspaceKeyCATabKeyClearKeyCTabKeyDcKeyDlKeyEicKeyEolKeyEosKeyF0KeyF1KeyF10KeyF2KeyF3KeyF4KeyF5KeyF6KeyF7KeyF8KeyF9KeyHomeKeyIcKeyIlKeyLeftKeyLlKeyNPageKeyPPageKeyRightKeySfKeySrKeySTabKeypadLocalKeypadXmitLabF0LabF1LabF10LabF2LabF3LabF4LabF5LabF6LabF7LabF8LabF9MetaOffMetaOnNewlinePadCharPKeyKeyPKeyLocalPKeyXmitPrtrOffPrtrOnRepeatCharReset1StringReset2StringReset3StringResetFileRestoreCursorSaveCursorScrollForwardScrollReverseSetTabSetWindowToStatusLineUnderlineCharUpHalfLineInitProgKeyA1KeyA3KeyB2KeyC1KeyC3PrtrNonCharPaddingAcsCharsPlabNormKeyBTabEnterXonModeExitXonModeEnterAmModeExitAmModeXonCharacterXoffCharacterEnaAcsLabelOnLabelOffKeyBegKeyCancelKeyCloseKeyCommandKeyCopyKeyCreateKeyEndKeyEnterKeyExitKeyFindKeyHelpKeyMarkKeyMessageKeyMoveKeyNextKeyOpenKeyOptionsKeyPreviousKeyPrintKeyRedoKeyReferenceKeyRefreshKeyReplaceKeyRestartKeyResumeKeySaveKeySuspendKeyUndoKeySBegKeySCancelKeySCommandKeySCopyKeySCreateKeySDcKeySDlKeySelectKeySEndKeySEolKeySExitKeySFindKeySHelpKeySHomeKeySIcKeySLeftKeySMessageKeySMoveKeySNextKeySOptionsKeySPreviousKeySPrintKeySRedoKeySReplaceKeySRightKeySRsumeKeySSaveKeySSuspendKeySUndoReqForInputKeyF11KeyF12KeyF13KeyF14KeyF15KeyF16KeyF17KeyF18KeyF19KeyF20KeyF21KeyF22KeyF23KeyF24KeyF25KeyF26KeyF27KeyF28KeyF29KeyF30KeyF31KeyF32KeyF33KeyF34KeyF35KeyF36KeyF37KeyF38KeyF39KeyF40KeyF41KeyF42KeyF43KeyF44KeyF45KeyF46KeyF47KeyF48KeyF49KeyF50KeyF51KeyF52KeyF53KeyF54KeyF55KeyF56KeyF57KeyF58KeyF59KeyF60KeyF61KeyF62KeyF63ClrBolClearMarginsSetLeftMarginSetRightMarginLabelFormatSetClockDisplayClockRemoveClockCreateWindowGotoWindowDialPhoneQuickDialTonePulseFlashHookFixedPauseWaitToneUser0User3User4User5User6User7User8User9OrigPairOrigColorsInitializeColorInitializePairSetColorPairChangeCharPitchChangeLinePitchChangeResHorzChangeResVertDefineCharEnterDoublewideModeEnterDraftQualityEnterItalicsModeEnterLeftwardModeEnterMicroModeEnterNearLetterQualityEnterNormalQualityEnterShadowModeEnterSubscriptModeEnterSuperscriptModeEnterUpwardModeExitDoublewideModeExitItalicsModeExitLeftwardModeExitMicroModeExitShadowModeExitSubscriptModeExitSuperscriptModeExitUpwardModeMicroColumnAddressMicroDownMicroLeftMicroRightMicroRowAddressMicroUpOrderOfPinsSelectCharSetSetBottomMarginSetBottomMarginParmSetLeftMarginParmSetRightMarginParmSetTopMarginSetTopMarginParmStartBitImageStartCharSetDefStopBitImageStopCharSetDefSubscriptCharactersSuperscriptCharactersTheseCauseCrZeroMotionCharSetNamesKeyMouseMouseInfoReqMousePosGetMousePkeyPlabCodeSetInitSet0DesSeqSet1DesSeqSet2DesSeqSet3DesSeqSetLrMarginSetTbMarginBitImageRepeatBitImageNewlineBitImageCarriageReturnColorNamesDefineBitImageRegionEndBitImageRegionSetColorBandSetPageLengthDisplayPcCharEnterPcCharsetModeExitPcCharsetModeEnterScancodeModeExitScancodeModePcTermOptionsScancodeEscapeAltScancodeEscEnterHorizontalHlModeEnterLeftHlModeEnterLowHlModeEnterRightHlModeEnterTopHlModeEnterVerticalHlModeSetAAttributesSetPglenInchTermcapInit2TermcapResetLinefeedIfNotLfBackspaceIfNotBsOtherNonFunctionKeysArrowKeyMapAcsULcornerAcsLLcornerAcsURcornerAcsLRcornerAcsLTeeAcsRTeeAcsBTeeAcsTTeeAcsHLineAcsVLineAcsPlusMemoryLockMemoryUnlockBoxChars1ChangeScrollRegionr" Set the given parameter."ColumnAddressCursorAddressEraseCharsParmDchParmDeleteLineParmDownCursorParmIchParmIndexParmInsertLineParmLeftCursorParmRightCursorParmRindexParmUpCursorParmDownMicroParmLeftMicroParmRightMicroParmUpMicroRowAddressSetAttributesstandoutdimprotectedalt_charsetSetAForegroundSetABackgroundSetForegroundSetBackgroundXTermTitle// Extended capabilities from screen.BrightAttributeXTermMouse// Extended capabilities from tmux.SetClipboardSetCursorStyleResetCursorStyleSetTrueColorForeground// True color extended capabilities from vim.SetTrueColorBackgroundResetCursorColorSetCursorColorcursor_address//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE//                    Version 2, December 2004// Copyleft (ↄ) meh. <meh@schizofreni.co> | http://meh.schizofreni.co// Everyone is permitted to copy and distribute verbatim or modified// copies of this license document, and changing it is allowed as long// as the name is changed.//   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION//  0. You just DO WHAT THE FUCK YOU WANT TO.//! Standard capabilities./// A capability database./// Builder for a new `Database`./// Build the database./// Set the terminal name./// Set the terminal aliases./// Set the terminal description./// Set a capability./// use terminfo::{Database, capability as cap};/// let mut info = Database::new();/// info.name("foo");/// info.description("foo terminal");/// // Set the amount of available colors./// info.set(cap::MaxColors(16));/// info.build().unwrap();/// Set a raw capability./// info.raw("colors", 16);/// Create a new empty database./// Load a database from the current environment./// Load a database for the given name./// Load a database from the given path./// Load a database from a buffer./// The terminal name./// The terminal aliases./// The terminal description./// Get a capability./// let info        = Database::from_env().unwrap();/// let colors: i32 = info.get::<cap::MaxColors>().unwrap().into();/// Get a capability by name./// This interface only makes sense for extended capabilities since they/// don't have standardized types./// use terminfo::Database;/// let info      = Database::from_env().unwrap();/// let truecolor = info.raw("Tc").is_some();/// IO error./// Database not found./// Parsing error./// Expansion error./// The expansion string is invalid./// There was a type mismatch while expanding.StackUnderflow/// The stack underflowed while expanding.expansion/// Trait for items that can be expanded./// An expansion parameter./// The expansion context./// The same context should be passed around through every expansion for the/// same `Database`./// Expand a parametrized string./// Write the expansion to `stdout`./// # #[macro_use] extern crate terminfo;/// let info = Database::from_env().unwrap();/// // Move the cursor to X: 20, Y: 30/// expand!(io::stdout(), info.get::<cap::CursorAddress>().unwrap().as_ref(); 20, 30).unwrap();/// Load the expansion for later usage./// // Set foreground color to red./// let red     = expand!(info.get::<cap::SetAForeground>().unwrap().as_ref(); 1).unwrap();/// let on_blue = expand!(info.get::<cap::SetABackground>().unwrap().as_ref(); 4).unwrap();test_basic_setabf/// Parsers for various formats./// String capability expansion./// Standard terminal capabilities./// Constants to deal with name differences across terminfo and termcap.BOOLEAN_INDEXNUMBER_INDEXSTRING_INDEXALIASESbooleansbigger_numbersVariableIncrementNOTSubtractRemainderANDORXORLesserChrDecOctconstant_charconstant_integeris_flagis_eolis_wswsis_printable_no_commais_printable_no_controlis_printable_no_pipeeolPRINTSPACECOMMAEOLASCII// Ugly table of DOOM, gotta run and gun.//! Unsafe FFI bindings.// c_cc subscripts// input modes// output modes// baud rate selection// control modes// local modes// attribute selection/// Unix terminal I/O control structure./// The `Termios` structure is a thin wrapper for the OS-specific `termios` struct. The only safe/// way to obtain a `Termios` structure is to fill one from a file descriptor with/// [`Termios::from_fd()`](#method.from_fd), after which it can be treated just like the POSIX/// `termios` struct. It provides access to the standard fields of the `termios` struct (`c_iflag`,/// `c_oflag`, `c_cflag`, `c_lflag`, and `c_cc`) through the `Deref` and `DerefMut` traits./// The following is an example of how one might setup a file descriptor for a serial port:/// fn setup_serial(fd: RawFd) -> io::Result<()> {///     use termios::*;///     let mut termios = try!(Termios::from_fd(fd));///     termios.c_cflag |= CREAD | CLOCAL;///     termios.c_lflag &= !(ICANON | ECHO | ECHOE | ECHOK | ECHONL | ISIG | IEXTEN);///     termios.c_oflag &= !OPOST;///     termios.c_iflag &= !(INLCR | IGNCR | ICRNL | IGNBRK);///     termios.c_cc[VMIN] = 0;///     termios.c_cc[VTIME] = 0;///     try!(cfsetspeed(&mut termios, B9600));///     try!(tcsetattr(fd, TCSANOW, &mut termios));/// Creates a `Termios` structure based on the current settings of a file descriptor./// `fd` must be an open file descriptor for a terminal device./// Gets the input baud rate stored in a `Termios` structure./// # use termios::{Termios,B9600,cfsetispeed,cfgetispeed};/// # let mut termios = unsafe { mem::uninitialized() };/// cfsetispeed(&mut termios, B9600).unwrap();/// assert_eq!(cfgetispeed(&termios), B9600);/// Gets the output baud rate stored in a `Termios` structure./// # use termios::{Termios,B9600,cfsetospeed,cfgetospeed};/// cfsetospeed(&mut termios, B9600).unwrap();/// assert_eq!(cfgetospeed(&termios), B9600);/// Sets the input baud rate./// This function only sets the necessary values on the given `Termios` structure. The settings are/// applied by a subsequent call to [`tcsetattr()`](fn.tcsetattr.html)./// * `termios` should be a mutable reference to a `Termios` structure./// * `speed` should be one of the baud rate constants:///   - `B0`///   - `B50`///   - `B75`///   - `B110`///   - `B134`///   - `B150`///   - `B200`///   - `B300`///   - `B600`///   - `B1200`///   - `B1800`///   - `B2400`///   - `B4800`///   - `B9600`///   - `B19200`///   - `B38400`///   - any OS-specific baud rate defined in [`termios::os`](os/index.html)./// A value of `B0` for `speed` sets the input baud rate to be the same as the output baud rate./// Sets the output baud rate./// applied on a successful call to [`tcsetattr()`](fn.tcsetattr.html).///   - `B0` (hang up)/// A value of `B0` for `speed` deasserts the modem control lines when applied with/// [`tcsetattr()`](fn.tcsetattr.html).  This normally has the effect of disconnecting the line./// Sets input and output baud rates./// # use termios::{Termios,B9600,cfsetspeed,cfgetispeed,cfgetospeed};/// cfsetspeed(&mut termios, B9600).unwrap();/// This function is not part of the IEEE Std 1003.1 ("POSIX.1") specification, but it is available/// on Linux, BSD, and OS X./// Sets flags to disable all input and output processing./// Blocks until all output written to the file descriptor is transmitted./// * `fd` should be an open file descriptor associated with a terminal./// Suspends or restarts transmission or reception of data./// * `action` should be one of the following constants:///   - `TCOOFF` suspends output.///   - `TCOON` restarts output.///   - `TCIOFF` transmits a STOP character, intended to cause the remote device to stop///     transmitting.///   - `TCION` transmits a START character, intended to cause the remote device to resume/// Discards data waiting in the terminal device's buffers./// `tcflush()` discards data that has been written to the device by an application but has not yet/// been transmitted by the hardware or data that has been received by the hardware but has not yet/// been read by an application./// * `queue_selector` should be one of:///   - `TCIFLUSH` to discard data received but not read.///   - `TCOFLUSH` to discard data written but not transmitted.///   - `TCIOFLUSH` to discard both data received but not read and data written but not///     transmitted./// Populates a `Termios` structure with parameters associated with a terminal./// Upon successful completion, the `Termios` structure referred to by the `termios` parameter will/// contain the parameters associated with the terminal device referred to by `fd`./// * `termios` should be a mutable reference to the `Termios` structure that will hold the///   terminal device's parameters./// Sets a terminal device's parameters./// `tcsetattr()` returns successfully if it was able to perform any of the requested actions, even/// if other requested actions could not be performed. It will set all attributes that the/// implementation supports and leave others unchanged. The `Termios` structure will not be updated/// to reflect the changes that were applied./// In order to determine which parameters were applied to the terminal device, an application/// should use [`tcgetattr()`](fn.tcgetattr.html) to obtain the latest state of the terminal/// device. In particular, when attempting to change baud rates, [`tcgetattr()`](fn.tcgetattr.html)/// can be used to determine which baud rates were actually selected./// If none of the requested actions could be performed, then `tcsetattr()` returns an error./// * `action` should be one of the constants:///   - `TCSANOW` applies the change immediately.///   - `TCSADRAIN` applies the change after all output previously written to `fd` is transmitted.///     This mode should be used when changing parameters that affect output.///   - `TCSAFLUSH` applies the change after all output previously written to `fd` is transmitted.///     All data received but not read is discarded before applying the change./// * `termios` should be a mutable reference to a `Termios` structure containing the parameters to///   apply to the terminal device./// Returns the process group ID of the controlling terminal's session./// * `fd` should be an open file descriptor associated with a controlling terminal./// Transmits data to generate a break condition./// If the terminal device is using asynchronous data transmission, `tcsendbreak()` transmits a/// continuous stream of zero bits for a specific duration./// * `duration` controls the duration of the transmitted zero bits. A value of 0 causes a///   transmission between 0.25 and 0.5 seconds. A value other than 0 causes a transmission for an///   implementation-defined period of time.//! The `termios` crate provides Rust bindings for the POSIX termios API that is implemented on//! Unix operating systems. The termios API is defined in the [IEEE Std 1003.1 ("POSIX.1")//! specification](http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/termios.h.html).//! ## Getting Started//! The termios API operates on file descriptors that are associated with terminal devices, e.g.,//! `/dev/tty*`. When used with other file descriptors, termios functions return an error. All//! functions that are part of the POSIX standard are included in the `termios` crate. Where file//! descriptors are expected, the type `std::os::unix::io::RawFd` is used, and integer error codes//! are translated to `std::io::Result`.//! A major feature of the termios API is configuring a terminal device's parameters. The POSIX//! standard defines a `termios` structure that contains the parameters and several functions for//! manipulating the parameters. The `termios` crate defines a safe constructor that returns a//! [`Termios`](struct.Termios.html) struct populated with the parameters of an open terminal//! device://! use termios::*;//! # let fd = 1;//! let mut termios = Termios::from_fd(fd).unwrap();//! The [`Termios`](struct.Termios.html) struct provides access to the fields defined in the POSIX//! standard (`c_iflag`, `c_oflag`, `c_cflag`, `c_lflag`, and `c_cc`)://! # use termios::*;//! # let mut termios = Termios::from_fd(fd).unwrap();//! termios.c_cflag |= CREAD | CLOCAL;//! termios.c_lflag &= !(ICANON | ECHO | ECHOE | ECHOK | ECHONL | ISIG | IEXTEN);//! termios.c_oflag &= !OPOST;//! termios.c_iflag &= !(INLCR | IGNCR | ICRNL | IGNBRK);//! termios.c_cc[VMIN] = 0;//! termios.c_cc[VTIME] = 0;//! The [`Termios`](struct.Termios.html) struct can also be manipulated using any of the standard//! termios API functions://! cfgetispeed(&termios);//! cfgetospeed(&termios);//! cfsetispeed(&mut termios, B9600).unwrap();//! cfsetospeed(&mut termios, B9600).unwrap();//! tcsetattr(fd, TCSANOW, &termios).unwrap();//! ## Portability//! The `termios` crate is organized in a way to help write portable code, while also allowing//! access to OS-specific functionality when necessary.//! The crate root contains types, constants, and function definitions that are common across Unix//! operating systems. Most of the definitions in the crate root are from the POSIX standard;//! however, support for the standard may differ across operating systems. A couple functions in//! the crate root are not part of the POSIX standard, but are included in the crate root because//! they are widely available across Unix operating systems.//! To write portable code, import the `termios` crate and use only the definitions from the crate//! ### OS-Specific Extensions//! Each operating system may define extensions to the POSIX API. To make it clear when code//! depends on OS-specific definitions, any non-standard definitions are exported in the//! `termios::os` module. Programs that depend on OS-specific functionality must explicity opt-in.//! When writing portable code that depends on OS-specific definitions, it will often be necessary//! to use `#[cfg(...)]` attributes to support alternative implementations. The following is an//! example of a portable function that sets the maximum speed on a `Termios` struct.//! use termios::{Termios,cfsetspeed};//! fn set_fastest_speed(termios: &mut Termios) -> io::Result<()> {//!     cfsetspeed(termios, termios::os::linux::B4000000)//!     cfsetspeed(termios, termios::os::macos::B230400)//! #[cfg(target_os = "freebsd")]//!     cfsetspeed(termios, termios::os::freebsd::B921600)//! #[cfg(target_os = "openbsd")]//!     cfsetspeed(termios, termios::os::openbsd::B921600)//! set_fastest_speed(&mut termios).unwrap();// line control// c_cc characters// c_iflag bits// c_oflag bits// c_cflag bits// c_lflag bits// baud rates// tcflow()// tcflush()// tcsetattr()// baud speeds//! OS-specific definitions.//! #[cfg(target_os = "netbsd")]//!     cfsetspeed(termios, termios::os::netbsd::B921600)//! #[cfg(target_os = "dragonfly")]//!     cfsetspeed(termios, termios::os::dragonfly::B230400)//! #[cfg(target_os = "solaris")]//!     cfsetspeed(termios, termios::os::solaris::B921600)//! #[cfg(target_os = "illumos")]//!     cfsetspeed(termios, termios::os::illumos::B921600)RCV1ENXMT1ENLOBLKXCLUDE/// Add prefix to each non-empty line./// use textwrap::indent;/// assert_eq!(indent("/// Foo/// Bar/// ", "  "), "///   Foo///   Bar/// Empty lines (lines consisting only of whitespace) are not indented/// and the whitespace is replaced by a single newline (`\n`):///   \t/// Baz/// ", "->"), "/// ->Foo/// ->Bar/// ->Baz/// Leading and trailing whitespace on non-empty lines is kept/// unchanged:/// assert_eq!(indent(" \t  Foo   ", "->"), "-> \t  Foo   \n");dedent/// Removes common leading whitespace from each line./// This function will look at each non-empty line and determine the/// maximum amount of whitespace that can be removed from all lines:/// use textwrap::dedent;/// assert_eq!(dedent("///     1st line///       2nd line///     3rd line/// "), "/// 1st line///   2nd line/// 3rd lineadd_nl/// Add newlines. Ensures that the final line in the vector also/// has a newline.indent_emptyindent_nonemptyindent_empty_linededent_emptydedent_multi_linededent_empty_linededent_blank_linededent_whitespace_linededent_mixed_whitespacededent_tabbed_whitespacededent_mixed_tabbed_whitespacededent_mixed_tabbed_whitespace2dedent_preserve_no_terminating_newline//! Functions related to adding and removing indentation from lines of//! text.//! The functions here can be used to uniformly indent or dedent//! (unindent) word wrapped lines of text.UnicodeWidthCharNBSP/// A non-breaking space.splittingHyphenSplitterNoHyphenationWordSplitter/// The width in columns at which the text will be wrapped.initial_indent/// Indentation used for the first line of output.subsequent_indent/// Indentation used for subsequent lines of output.break_words/// Allow long words to be broken if they cannot fit on a line./// When set to `false`, some lines may be longer than/// `self.width`./// The method for splitting words. If the `hyphenation` feature/// is enabled, you can use a `hyphenation::Standard` dictionary/// here to get language-aware hyphenation./// A Wrapper holds settings for wrapping and filling text. Use it/// when the convenience [`wrap_iter`], [`wrap`] and [`fill`] functions/// are not flexible enough./// [`wrap_iter`]: fn.wrap_iter.html/// [`wrap`]: fn.wrap.html/// [`fill`]: fn.fill.html/// The algorithm used by the `WrapIter` iterator (returned from the/// `wrap_iter` method)  works by doing successive partial scans over/// words in the input string (where each single scan yields a single/// line) so that the overall time and memory complexity is O(*n*) where/// *n* is the length of the input string./// Create a new Wrapper for wrapping at the specified width. By/// default, we allow words longer than `width` to be broken. A/// [`HyphenSplitter`] will be used by default for splitting/// words. See the [`WordSplitter`] trait for other options./// [`HyphenSplitter`]: struct.HyphenSplitter.html/// [`WordSplitter`]: trait.WordSplitter.htmlwith_splitter/// Use the given [`WordSplitter`] to create a new Wrapper for/// wrapping at the specified width. By default, we allow words/// longer than `width` to be broken./// Change [`self.initial_indent`]. The initial indentation is/// used on the very first line of output./// Classic paragraph indentation can be achieved by specifying an/// initial indentation and wrapping each paragraph by itself:/// use textwrap::Wrapper;/// let wrapper = Wrapper::new(15).initial_indent("    ");/// [`self.initial_indent`]: #structfield.initial_indent/// Change [`self.subsequent_indent`]. The subsequent indentation/// is used on lines following the first line of output./// Combining initial and subsequent indentation lets you format a/// single paragraph as a bullet list:/// let wrapper = Wrapper::new(15)///     .initial_indent("* ")///     .subsequent_indent("  ");/// [`self.subsequent_indent`]: #structfield.subsequent_indent/// Change [`self.break_words`]. This controls if words longer/// than `self.width` can be broken, or if they will be left/// sticking out into the right margin./// [`self.break_words`]: #structfield.break_words/// Fill a line of text at `self.width` characters. Strings are/// wrapped based on their displayed width, not their size in/// The result is a string with newlines between each line. Use/// the `wrap` method if you need access to the individual lines./// # Complexities/// This method simply joins the lines produced by `wrap_iter`. As/// such, it inherits the O(*n*) time and memory complexity where/// *n* is the input string length./// let wrapper = Wrapper::new(15);/// assert_eq!(wrapper.fill("Memory safety without garbage collection."),///            "Memory safety\nwithout garbage\ncollection.");/// Wrap a line of text at `self.width` characters. Strings are/// This method simply collects the lines produced by `wrap_iter`./// As such, it inherits the O(*n*) overall time and memory/// complexity where *n* is the input string length./// let wrap15 = Wrapper::new(15);/// assert_eq!(wrap15.wrap("Concurrency without data races."),///            vec!["Concurrency",///                 "without data",///                 "races."]);/// let wrap20 = Wrapper::new(20);/// assert_eq!(wrap20.wrap("Concurrency without data races."),///            vec!["Concurrency without",///                 "data races."]);/// Notice that newlines in the input are preserved. This means/// that they force a line break, regardless of how long the/// current line is:/// let wrapper = Wrapper::new(40);/// assert_eq!(wrapper.wrap("First line.\nSecond line."),///            vec!["First line.", "Second line."]);wrap_iterWrapIter/// Lazily wrap a line of text at `self.width` characters. Strings/// are wrapped based on their displayed width, not their size in/// The [`WordSplitter`] stored in [`self.splitter`] is used/// whenever when a word is too large to fit on the current line./// By changing the field, different hyphenation strategies can be/// implemented./// This method returns a [`WrapIter`] iterator which borrows this/// `Wrapper`. The algorithm used has a linear complexity, so/// getting the next line from the iterator will take O(*w*) time,/// where *w* is the wrapping width. Fully processing the iterator/// will take O(*n*) time for an input string of length *n*./// When no indentation is used, each line returned is a slice of/// the input string and the memory overhead is thus constant./// Otherwise new memory is allocated for each line returned./// let mut wrap20_iter = wrap20.wrap_iter("Zero-cost abstractions.");/// assert_eq!(wrap20_iter.next(), Some(Cow::from("Zero-cost")));/// assert_eq!(wrap20_iter.next(), Some(Cow::from("abstractions.")));/// assert_eq!(wrap20_iter.next(), None);/// let wrap25 = Wrapper::new(25);/// let mut wrap25_iter = wrap25.wrap_iter("Zero-cost abstractions.");/// assert_eq!(wrap25_iter.next(), Some(Cow::from("Zero-cost abstractions.")));/// assert_eq!(wrap25_iter.next(), None);/// [`self.splitter`]: #structfield.splitter/// [`WrapIter`]: struct.WrapIter.htmlinto_wrap_iterIntoWrapIter/// This method consumes the `Wrapper` and returns a/// [`IntoWrapIter`] iterator. Fully processing the iterator has/// the same O(*n*) time complexity as [`wrap_iter`], where *n* is/// the length of the input string./// let mut wrap20_iter = wrap20.into_wrap_iter("Zero-cost abstractions.");/// [`IntoWrapIter`]: struct.IntoWrapIter.html/// [`wrap_iter`]: #method.wrap_iterWrapIterImpl/// An iterator over the lines of the input string which owns a/// `Wrapper`. An instance of `IntoWrapIter` is typically obtained/// through either [`wrap_iter`] or [`Wrapper::into_wrap_iter`]./// Each call of `.next()` method yields a line wrapped in `Some` if the/// input hasn't been fully processed yet. Otherwise it returns `None`./// [`Wrapper::into_wrap_iter`]: struct.Wrapper.html#method.into_wrap_iter/// An iterator over the lines of the input string which borrows a/// `Wrapper`. An instance of `WrapIter` is typically obtained/// through the [`Wrapper::wrap_iter`] method./// [`Wrapper::wrap_iter`]: struct.Wrapper.html#method.wrap_iter/// Like `char::is_whitespace`, but non-breaking spaces don't count.// String to wrap.// CharIndices iterator over self.source.// Byte index where the current line starts.// Byte index of the last place where the string can be split.split_len// Size in bytes of the character at self.source[self.split].// Width of self.source[self.start..idx].line_width_at_split// Width of self.source[self.start..self.split].in_whitespace// Tracking runs of whitespace characters.// Has iterator finished producing elements?/// Common implementation details for `WrapIter` and `IntoWrapIter`.create_result_line/// Fill a line of text at `width` characters. Strings are wrapped/// based on their displayed width, not their size in bytes./// [`wrap`] if you need access to the individual lines or/// [`wrap_iter`] for its iterator counterpart./// use textwrap::fill;/// assert_eq!(fill("Memory safety without garbage collection.", 15),/// This function creates a Wrapper on the fly with default settings./// If you need to set a language corpus for automatic hyphenation, or/// need to fill many strings, then it is suggested to create a Wrapper/// and call its [`fill` method]./// [`fill` method]: struct.Wrapper.html#method.fill/// Wrap a line of text at `width` characters. Strings are wrapped/// need to wrap many strings, then it is suggested to create a Wrapper/// and call its [`wrap` method]./// The result is a vector of strings. Use [`wrap_iter`] if you need an/// iterator version./// use textwrap::wrap;/// assert_eq!(wrap("Concurrency without data races.", 15),/// assert_eq!(wrap("Concurrency without data races.", 20),/// [`wrap` method]: struct.Wrapper.html#method.wrap/// Lazily wrap a line of text at `width` characters. Strings are/// wrapped based on their displayed width, not their size in bytes./// It then calls the [`into_wrap_iter`] method. Hence, the return/// value is an [`IntoWrapIter`], not a [`WrapIter`] as the function/// name would otherwise suggest./// and call its [`wrap_iter`] or [`into_wrap_iter`] methods./// use textwrap::wrap_iter;/// let mut wrap20_iter = wrap_iter("Zero-cost abstractions.", 20);/// let mut wrap25_iter = wrap_iter("Zero-cost abstractions.", 25);/// [`wrap_iter`]: struct.Wrapper.html#method.wrap_iter/// [`into_wrap_iter`]: struct.Wrapper.html#method.into_wrap_iterno_wrapmulti_word_on_linelong_wordlong_wordsleading_whitespacetrailing_whitespaceinterior_whitespaceextra_whitespace_start_of_lineissue_99issue_129wide_character_handlingempty_input_not_indentedindent_single_lineindent_multiple_linesindent_break_wordshyphenstrailing_hyphenmultiple_hyphenshyphens_flagrepeated_hyphenshyphens_alphanumerichyphens_non_alphanumericmultiple_splitsforced_splitno_hyphenationbreak_words_wide_charactersbreak_words_zero_widthbreak_words_line_breakspreserve_line_breakswrap_preserve_line_breaksnon_breaking_spacenon_breaking_hyphenfill_simple//! `textwrap` provides functions for word wrapping and filling text.//! Wrapping text can be very useful in commandline programs where you//! want to format dynamic output nicely so it looks good in a//! terminal. A quick example://! extern crate textwrap;//! use textwrap::fill;//!     let text = "textwrap: a small library for wrapping text.";//!     println!("{}", fill(text, 18));//! This will display the following output://! textwrap: a small//! library for//! wrapping text.//! # Displayed Width vs Byte Size//! To word wrap text, one must know the width of each word so one can//! know when to break lines. This library measures the width of text//! using the [displayed width][unicode-width], not the size in bytes.//! This is important for non-ASCII text. ASCII characters such as `a`//! and `!` are simple and take up one column each. This means that//! the displayed width is equal to the string length in bytes.//! However, non-ASCII characters and symbols take up more than one//! byte when UTF-8 encoded: `é` is `0xc3 0xa9` (two bytes) and `⚙` is//! `0xe2 0x9a 0x99` (three bytes) in UTF-8, respectively.//! This is why we take care to use the displayed width instead of the//! byte count when computing line lengths. All functions in this//! library handle Unicode characters like this.//! [unicode-width]: https://docs.rs/unicode-width//// Return all possible splits of word. Each split is a triple/// with a head, a hyphen, and a tail where `head + &hyphen +/// &tail == word`. The hyphen can be empty if there is already a/// hyphen in the head./// The splits should go from smallest to longest and should/// include no split at all. So the word "technology" could be/// split into/// vec![("tech", "-", "nology"),///      ("technol", "-", "ogy"),///      ("technolo", "-", "gy"),///      ("technology", "", "")];/// An interface for splitting words./// When the [`wrap_iter`] method will try to fit text into a line, it/// will eventually find a word that it too large the current text/// width. It will then call the currently configured `WordSplitter` to/// have it attempt to split the word into smaller parts. This trait/// describes that functionality via the [`split`] method./// If the `textwrap` crate has been compiled with the `hyphenation`/// feature enabled, you will find an implementation of `WordSplitter`/// by the `hyphenation::language::Corpus` struct. Use this struct for/// language-aware hyphenation. See the [`hyphenation` documentation]/// [`wrap_iter`]: ../struct.Wrapper.html#method.wrap_iter/// [`split`]: #tymethod.split/// [`hyphenation` documentation]: https://docs.rs/hyphenation//// Use this as a [`Wrapper.splitter`] to avoid any kind of/// hyphenation:/// use textwrap::{Wrapper, NoHyphenation};/// let wrapper = Wrapper::with_splitter(8, NoHyphenation);/// assert_eq!(wrapper.wrap("foo bar-baz"), vec!["foo", "bar-baz"]);/// [`Wrapper.splitter`]: ../struct.Wrapper.html#structfield.splitter/// `NoHyphenation` implements `WordSplitter` by not splitting the/// word at all./// Simple and default way to split words: splitting on existing/// hyphens only./// You probably don't need to use this type since it's already used/// by default by `Wrapper::new`./// `HyphenSplitter` is the default `WordSplitter` used by/// `Wrapper::new`. It will split words on any existing hyphens in the/// word./// It will only use hyphens that are surrounded by alphanumeric/// characters, which prevents a word like "--foo-bar" from being/// split on the first or second hyphen.//! Word splitting functionality.//! To wrap text into lines, long words sometimes need to be split//! across lines. The [`WordSplitter`] trait defines this//! functionality. [`HyphenSplitter`] is the default implementation of//! this treat: it will simply split words on existing hyphens.ThingMyError// thiserror is able to provide backtrace support.as_dyn_errorAsDynError// TODO: convert to generic associated type.// https://github.com/dtolnay/thiserror/pull/253aserror//! [![github]](https://github.com/dtolnay/thiserror)&ensp;[![crates-io]](https://crates.io/crates/thiserror)&ensp;[![docs-rs]](https://docs.rs/thiserror)//! [`std::error::Error`] trait.//! [`std::error::Error`]: https://doc.rust-lang.org/std/error/trait.Error.html//! #[derive(Error, Debug)]//!     #[error("data store disconnected")]//!     Disconnect(#[from] io::Error),//!     #[error("the data for key `{0}` is not available")]//!     #[error("invalid header (expected {expected:?}, found {found:?})")]//!     #[error("unknown data store error")]//! - Thiserror deliberately does not appear in your public API. You get the//!   same thing as if you had written an implementation of `std::error::Error`//!   by hand, and switching from handwritten impls to thiserror or vice versa//!   is not a breaking change.//! - Errors may be enums, structs with named fields, tuple structs, or unit//!   structs.//! - A `Display` impl is generated for your error if you provide//!   `#[error("...")]` messages on the struct or each variant of your enum, as//!   shown above in the example.//!   The messages support a shorthand for interpolating fields from the error.//!     - `#[error("{var}")]`&ensp;⟶&ensp;`write!("{}", self.var)`//!     - `#[error("{0}")]`&ensp;⟶&ensp;`write!("{}", self.0)`//!     - `#[error("{var:?}")]`&ensp;⟶&ensp;`write!("{:?}", self.var)`//!     - `#[error("{0:?}")]`&ensp;⟶&ensp;`write!("{:?}", self.0)`//!   These shorthands can be used together with any additional format args,//!   which may be arbitrary expressions. For example://!   # use core::i32;//!   # use thiserror::Error;//!   pub enum Error {//!       #[error("invalid rdo_lookahead_frames {0} (expected < {})", i32::MAX)]//!       InvalidLookahead(u32),//!   If one of the additional expression arguments needs to refer to a field of//!   the struct or enum, then refer to named fields as `.var` and tuple fields//!   as `.0`.//!   # fn first_char(s: &String) -> char {//!   #     s.chars().next().unwrap()//!   # struct Limits {//!   #     lo: usize,//!   #     hi: usize,//!       #[error("first letter must be lowercase but was {:?}", first_char(.0))]//!       WrongCase(String),//!       #[error("invalid index {idx}, expected at least {} and at most {}", .limits.lo, .limits.hi)]//!       OutOfBounds { idx: usize, limits: Limits },//! - A `From` impl is generated for each variant containing a `#[from]`//!   attribute.//!   Note that the variant must not contain any other fields beyond the source//!   error and possibly a backtrace. A backtrace is captured from within the//!   `From` impl if there is a field for it.//!   # const IGNORE: &str = stringify! {//!   pub enum MyError {//!       Io {//!           #[from]//!           source: io::Error,//!           backtrace: Backtrace,//!   # };//! - The Error trait's `source()` method is implemented to return whichever//!   field has a `#[source]` attribute or is named `source`, if any. This is//!   for identifying the underlying lower level error that caused your error.//!   The `#[from]` attribute always implies that the same field is `#[source]`,//!   so you don't ever need to specify both attributes.//!   Any error type that implements `std::error::Error` or dereferences to `dyn//!   std::error::Error` will work as a source.//!   # use core::fmt::{self, Display};//!   pub struct MyError {//!       msg: String,//!       #[source]  // optional if field name is `source`//!       source: anyhow::Error,//!   # impl Display for MyError {//! - The Error trait's `provide()` method is implemented to provide whichever//!   field has a type named `Backtrace`, if any, as a//!   `std::backtrace::Backtrace`.//!   use std::backtrace::Backtrace;//!       backtrace: Backtrace,  // automatically detected//! - If a field is both a source (named `source`, or has `#[source]` or//!   `#[from]` attribute) *and* is marked `#[backtrace]`, then the Error//!   trait's `provide()` method is forwarded to the source's `provide` so that//!   both layers of the error share the same backtrace.//!           #[backtrace]//! - Errors may use `error(transparent)` to forward the source and Display//!   methods straight through to an underlying error without adding an//!   additional message. This would be appropriate for enums that need an//!   "anything else" variant.//!       # /*//!       # *///!       #[error(transparent)]//!       Other(#[from] anyhow::Error),  // source and Display delegate to anyhow::Error//!   Another use case is hiding implementation details of an error//!   representation behind an opaque error type, so that the representation is//!   able to evolve without breaking the crate's public API.//!   // PublicError is public, but opaque and easy to keep compatible.//!   #[error(transparent)]//!   pub struct PublicError(#[from] ErrorRepr);//!   impl PublicError {//!       // Accessors for anything we do want to expose publicly.//!   // Private and free to change across minor version of the crate.//!   enum ErrorRepr {//! - See also the [`anyhow`] library for a convenient single error type to use//!   in application code.//!   [`anyhow`]: https://github.com/dtolnay/anyhowthiserror_provideThiserrorProvide//!   same thing as if you had written an implementation of//!   [`std::error::Error`] by hand, and switching from handwritten impls to//!   thiserror or vice versa is not a breaking change.//! - A [`Display`] impl is generated for your error if you provide//!       #[error("invalid rdo_lookahead_frames {0} (expected < {max})", max = i32::MAX)]//! - A [`From`] impl is generated for each variant that contains a `#[from]`//!   The variant using `#[from]` must not contain any other fields beyond the//!   source error (and possibly a backtrace &mdash; see below). Usually//!   `#[from]` fields are unnamed, but `#[from]` is allowed on a named field//!   too.//!   # use std::io;//!   # mod globset {//!   #     #[derive(thiserror::Error, Debug)]//!   #     #[error("...")]//!   #     pub struct Error;//!       Io(#[from] io::Error),//!       Glob(#[from] globset::Error),//! - The Error trait's [`source()`] method is implemented to return whichever//! - The Error trait's [`provide()`] method is implemented to provide whichever//!   [`std::backtrace::Backtrace`]. Using `Backtrace` in errors requires a//!   nightly compiler with Rust version 1.73 or newer.//!   trait's [`provide()`] method is forwarded to the source's `provide` so//!   that both layers of the error share the same backtrace. The `#[backtrace]`//!   attribute requires a nightly compiler with Rust version 1.73 or newer.//! - For variants that use `#[from]` and also contain a `Backtrace` field, a//!   backtrace is captured from within the `From` impl.//! - Errors may use `error(transparent)` to forward the source and [`Display`]//! [`anyhow`]: https://github.com/dtolnay/anyhow//! [`source()`]: std::error::Error::source//! [`provide()`]: std::error::Error::provide//! [`Display`]: std::fmt::DisplayAttrsParamsInScopecontains_genericfrom_synmultiple_from_synrequires_fmt_machineryhas_bonus_displayimplied_boundsparse_error_attributeparse_token_exprInferredBoundsMemberSpanfields_patuse_as_displayfrom_initializertype_is_optionunoptional_typetype_parameter_of_optionexplicit_named_argscrawl// clippy bug: https://github.com/rust-lang/rust-clippy/issues/8771augment_where_clausesource_fieldbacktrace_fielddistinct_backtrace_fieldhas_backtracehas_displayis_backtracesource_span// The #[backtrace] field, if it is not the same as the #[from] field.type_is_backtracemember_spancheck_non_field_attrscheck_field_attrssame_membercontains_non_static_lifetimeIdentUnrawMemberUnrawContainerKindinfinite_recursivecall_site_ident// Create an ident with which we can expand `impl Trait for #ident {}` on a// deprecated type without triggering deprecation warning on the generated impl.first_unnamedFmtArgumentstry_explicit_named_argsfallback_explicit_named_argsis_syn_fullThreadLocalCachedThreadLocal/// Wrapper around [`ThreadLocal`]./// This used to add a fast path for a single thread, however that has been/// obsoleted by performance improvements to [`ThreadLocal`] itself./// Creates a new empty `CachedThreadLocal`./// Returns the element for the current thread, if it exists.get_or/// Returns the element for the current thread, or creates it if it doesn't/// exist.get_or_try/// exist. If `create` fails, that error is returned and no element isCachedIterMut/// Returns a mutable iterator over the local values of all threads./// Since this call borrows the `ThreadLocal` mutably, this operation can/// be done safely---the mutable borrow statically guarantees no other/// threads are currently accessing their associated values./// Removes all thread-specific values from the `ThreadLocal`, effectively/// reseting it to its original state.CachedIntoIter/// Returns the element for the current thread, or creates a default one if/// it doesn't exist./// Mutable iterator over the contents of a `CachedThreadLocal`./// An iterator that moves out of a `CachedThreadLocal`.UncheckedResultExtPOINTER_WIDTH/// The total number of buckets stored in each thread local./// All buckets combined can hold up to `usize::MAX - 1` entries./// The buckets in the thread local. The nth bucket contains `2^n`/// elements. Each bucket is lazily allocated./// The number of values in the thread local. This can be less than the real number of values,/// but is never more./// Thread-local variable wrapper/// See the [module-level documentation](index.html) for more.// ThreadLocal is always Sync, even if T isn't/// Creates a new empty `ThreadLocal`./// Creates a new `ThreadLocal` with an initial capacity. If less than the capacity threads/// access the thread local it will never reallocate. The capacity may be rounded up to the/// nearest power of two./// Returns an iterator over the local values of all threads in unspecified/// This call can be done safely, as `T` is required to implement [`Sync`]./// Returns a mutable iterator over the local values of all threads in/// unspecified order.yieldednext_mutnext_bucketsize_hint_frozen/// Iterator over the contents of a `ThreadLocal`./// Mutable iterator over the contents of a `ThreadLocal`.// Manual impl so we don't call Debug on the ThreadLocal, as doing so would create a reference to// this thread's value that potentially aliases with a mutable reference we have given out./// An iterator that moves out of a `ThreadLocal`.allocate_bucketdeallocate_bucketmake_createsame_threaddifferent_threadmiri_iter_soundness_checktest_earlyreturn_bucketsis_sync// Copyright 2017 Amanieu d'Antras//! Per-object thread-local storage//! This library provides the `ThreadLocal` type which allows a separate copy of//! an object to be used for each thread. This allows for per-object//! thread-local storage, unlike the standard library's `thread_local!` macro//! which only allows static thread-local storage.//! Per-thread objects are not destroyed when a thread exits. Instead, objects//! are only destroyed when the `ThreadLocal` containing them is destroyed.//! You can also iterate over the thread-local values of all thread in a//! `ThreadLocal` object using the `iter_mut` and `into_iter` methods. This can//! only be done if you have mutable access to the `ThreadLocal` object, which//! guarantees that you are the only thread currently accessing it.//! Note that since thread IDs are recycled when a thread exits, it is possible//! for one thread to retrieve the object of another thread. Since this can only//! occur after a thread has exited this does not lead to any race conditions.//! Basic usage of `ThreadLocal`://! use thread_local::ThreadLocal;//! let tls: ThreadLocal<u32> = ThreadLocal::new();//! assert_eq!(tls.get(), None);//! assert_eq!(tls.get_or(|| 5), &5);//! assert_eq!(tls.get(), Some(&5));//! Combining thread-local values into a single result://! let tls = Arc::new(ThreadLocal::new());//! // Create a bunch of threads to do stuff//! for _ in 0..5 {//!     let tls2 = tls.clone();//!         // Increment a counter to count some event...//!         let cell = tls2.get_or(|| Cell::new(0));//!         cell.set(cell.get() + 1);//!     }).join().unwrap();//! // Once all threads are done, collect the counter values and return the//! // sum of all thread-local counter values.//! let tls = Arc::try_unwrap(tls).unwrap();//! let total = tls.into_iter().fold(0, |x, y| x + y.get());//! assert_eq!(total, 5);free_fromThreadIdManager/// Thread ID manager which allocates thread IDs. It attempts to aggressively/// reuse thread IDs where possible to avoid cases where a ThreadLocal grows/// indefinitely when it is used by many short-lived threads.THREAD_ID_MANAGER/// The thread ID obtained from the thread ID manager./// The bucket this thread's local storage will be in./// The size of the bucket this thread's local storage will be in./// The index into the bucket this thread's local storage is in./// Data which is unique to the current thread while it is running./// A thread ID may be reused after a thread exits.THREADTHREAD_GUARDr" Returns a thread ID for the current thread, allocating one if needed."r" Out-of-line slow path for allocating a thread ID."test_thread/// Get the value out of this Option without checking for None.unchecked_unwrap_none/// Assert that this Option is a None to the optimizer./// An extension trait for `Option<T>` providing unchecked unwrapping methods.unchecked_unwrap_ok/// Get the value out of this Result without checking for Err.unchecked_unwrap_err/// Get the error out of this Result without checking for Ok./// An extension trait for `Result<T, E>` providing unchecked unwrapping methods.call_boxFnBoxThunkshared_dataThreadPoolSharedData/// Cancel and destroy this sentinel.thread_stack_size/// [`ThreadPool`] factory, which can be used in order to configure the properties of the/// [`ThreadPool`]./// The three configuration options available:/// * `num_threads`: maximum number of threads that will be alive at any given moment by the built///   [`ThreadPool`]/// * `thread_name`: thread name for each of the threads spawned by the built [`ThreadPool`]/// * `thread_stack_size`: stack size (in bytes) for each of the threads spawned by the built/// Build a [`ThreadPool`] that uses a maximum of eight threads simultaneously and each thread has/// a 8 MB stack size:/// let pool = threadpool::Builder::new()///     .num_threads(8)///     .thread_stack_size(8_000_000)/// Initiate a new [`Builder`]./// let builder = threadpool::Builder::new();/// Set the maximum number of worker-threads that will be alive at any given moment by the built/// [`ThreadPool`]. If not specified, defaults the number of threads to the number of CPUs./// This method will panic if `num_threads` is 0./// No more than eight threads will be alive simultaneously for this pool:///     pool.execute(|| {///         println!("Hello from a worker thread!")/// Set the thread name for each of the threads spawned by the built [`ThreadPool`]. If not/// specified, threads spawned by the thread pool will be unnamed./// Each thread spawned by this pool will have the name "foo":///     .thread_name("foo".into())///         assert_eq!(thread::current().name(), Some("foo"));/// Set the stack size (in bytes) for each of the threads spawned by the built [`ThreadPool`]./// If not specified, threads spawned by the threadpool will have a stack size [as specified in/// the `std::thread` documentation][thread]./// [thread]: https://doc.rust-lang.org/nightly/std/thread/index.html#stack-size/// Each thread spawned by this pool will have a 4 MB stack:///     .thread_stack_size(4_000_000)///         println!("This thread has a 4 MB stack size!");/// Finalize the [`Builder`] and build the [`ThreadPool`].job_receiverempty_triggerempty_condvarjoin_generationqueued_countmax_thread_countpanic_counthas_workno_work_notify_all/// Notify all observers joining this pool if there is no more work to do.// How the threadpool communicates with subthreads.// This is the only such Sender, so when it is dropped all subthreads will// quit./// Abstraction of a thread pool for basic parallelism./// Creates a new thread pool capable of executing `num_threads` number of jobs concurrently./// This function will panic if `num_threads` is 0./// Create a new thread pool capable of executing four jobs concurrently:/// use threadpool::ThreadPool;/// let pool = ThreadPool::new(4);/// Each thread will have the [name][thread name] `name`./// let pool = ThreadPool::with_name("worker".into(), 2);/// for _ in 0..2 {///         assert_eq!(///             thread::current().name(),///             Some("worker")/// pool.join();/// [thread name]: https://doc.rust-lang.org/std/thread/struct.Thread.html#method.namenew_with_name/// **Deprecated: Use [`ThreadPool::with_name`](#method.with_name)**/// Executes the function `job` on a thread in the pool./// Execute four jobs on a thread pool that can run two jobs concurrently:/// let pool = ThreadPool::new(2);/// pool.execute(|| println!("hello"));/// pool.execute(|| println!("world"));/// pool.execute(|| println!("foo"));/// pool.execute(|| println!("bar"));/// Returns the number of jobs waiting to executed in the pool./// use std::thread::sleep;///         sleep(Duration::from_secs(100));/// sleep(Duration::from_secs(1)); // wait for threads to start/// assert_eq!(8, pool.queued_count());/// Returns the number of currently active threads.///     pool.execute(move || {/// assert_eq!(4, pool.active_count());max_count/// Returns the maximum number of threads the pool will execute concurrently./// let mut pool = ThreadPool::new(4);/// assert_eq!(4, pool.max_count());/// pool.set_num_threads(8);/// assert_eq!(8, pool.max_count());/// Returns the number of panicked threads over the lifetime of the pool./// for n in 0..10 {///         // simulate a panic///         if n % 2 == 0 {///             panic!()/// assert_eq!(5, pool.panic_count());/// **Deprecated: Use [`ThreadPool::set_num_threads`](#method.set_num_threads)**set_num_threads/// Sets the number of worker-threads to use as `num_threads`./// Can be used to change the threadpool size during runtime./// Will not abort already running or waiting threads./// assert_eq!(6, pool.queued_count());/// // Increase thread capacity of the pool/// sleep(Duration::from_secs(1)); // wait for new threads to start/// assert_eq!(8, pool.active_count());/// assert_eq!(2, pool.queued_count());/// // Decrease thread capacity of the pool/// // No active threads are killed/// pool.set_num_threads(4);/// Block the current thread until all jobs in the pool have been executed./// Calling `join` on an empty pool will cause an immediate return./// `join` may be called from multiple threads concurrently./// A `join` is an atomic point in time. All threads joining before the join/// event will exit together even if the pool is processing new jobs by the/// time they get scheduled./// Calling `join` from a thread within the pool will cause a deadlock. This/// behavior is considered safe./// let pool = ThreadPool::new(8);/// let test_count = Arc::new(AtomicUsize::new(0));/// for _ in 0..42 {///     let test_count = test_count.clone();///         test_count.fetch_add(1, Ordering::Relaxed);/// assert_eq!(42, test_count.load(Ordering::Relaxed));/// Cloning a pool will create a new handle to the pool./// The behavior is similar to [Arc](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html)./// We could for example submit jobs from multiple threads concurrently./// let pool = ThreadPool::with_name("clone example".into(), 2);/// let results = (0..2)///     .map(|i| {///         let pool = pool.clone();///         thread::spawn(move || {///             let (tx, rx) = channel();///             for i in 1..12 {///                 let tx = tx.clone();///                 pool.execute(move || {///                     tx.send(i).expect("channel will be waiting");///             drop(tx);///                 rx.iter().fold(0, |accumulator, element| accumulator + element)///                 rx.iter().fold(1, |accumulator, element| accumulator * element)///     .map(|join_handle| join_handle.join().expect("collect results from threads"))///     .collect::<Vec<usize>>();/// assert_eq!(vec![66, 39916800], results);/// Create a thread pool with one thread per CPU./// On machines with hyperthreading,/// this will create one thread per hyperthread./// Check if you are working with the same pool/// let a = ThreadPool::new(2);/// let b = ThreadPool::new(2);/// assert_eq!(a, a);/// assert_eq!(b, b);/// # // TODO: change this to assert_ne in the future/// assert!(a != b);/// assert!(b != a);spawn_in_poolTEST_TASKStest_set_num_threads_increasingtest_set_num_threads_decreasingtest_active_counttest_workstest_zero_tasks_panictest_recovery_from_subtask_panictest_should_not_panic_on_drop_if_subtasks_panic_after_droptest_massive_task_creationtest_shrinktest_nametest_repeate_jointest_multi_jointest_empty_pooltest_no_fun_or_joytest_sync_shared_datatest_send_shared_datatest_cloned_eqtest_join_wavesurfer/// The scenario is joining threads should not be stuck once their wave/// of joins has completed. So once one thread joining on a pool has/// succeded other threads joining on the same pool must get out even if/// the thread is used for other jobs while the first group is finishing/// their join/// In this example this means the waiting threads will exit the join in/// groups of four because the waiter pool has four workers.//! A thread pool used to execute functions in parallel.//! Spawns a specified number of worker threads and replenishes the pool if any worker threads//! panic.//! ## Synchronized with a channel//! Every thread sends one message over the channel, which then is collected with the `take()`.//! use threadpool::ThreadPool;//! use std::sync::mpsc::channel;//! let n_workers = 4;//! let n_jobs = 8;//! let pool = ThreadPool::new(n_workers);//! let (tx, rx) = channel();//! for _ in 0..n_jobs {//!     let tx = tx.clone();//!     pool.execute(move|| {//!         tx.send(1).expect("channel will be there waiting for the pool");//! assert_eq!(rx.iter().take(n_jobs).fold(0, |a, b| a + b), 8);//! ## Synchronized with a barrier//! Keep in mind, if a barrier synchronizes more jobs than you have workers in the pool,//! you will end up with a [deadlock](https://en.wikipedia.org/wiki/Deadlock)//! at the barrier which is [not considered unsafe](//! https://doc.rust-lang.org/reference/behavior-not-considered-unsafe.html).//! use std::sync::{Arc, Barrier};//! // create at least as many workers as jobs or you will deadlock yourself//! let n_workers = 42;//! let n_jobs = 23;//! let an_atomic = Arc::new(AtomicUsize::new(0));//! assert!(n_jobs <= n_workers, "too many jobs, will deadlock");//! // create a barrier that waits for all jobs plus the starter thread//! let barrier = Arc::new(Barrier::new(n_jobs + 1));//!     let barrier = barrier.clone();//!     let an_atomic = an_atomic.clone();//!         // do the heavy work//!         an_atomic.fetch_add(1, Ordering::Relaxed);//!         // then wait for the other threads//!         barrier.wait();//! // wait for the threads to finish the work//! barrier.wait();//! assert_eq!(an_atomic.load(Ordering::SeqCst), /* n_jobs = */ 23);integral_slice_as_bytesi8_as_ne_bytesi8_as_ne_mut_bytesu16_as_ne_bytesu16_as_ne_mut_bytesi16_as_ne_bytesi16_as_ne_mut_bytesu32_as_ne_bytesu32_as_ne_mut_bytesi32_as_ne_bytesi32_as_ne_mut_bytesu64_as_ne_bytesu64_as_ne_mut_bytesi64_as_ne_bytesi64_as_ne_mut_bytesf32_as_ne_bytesf32_as_ne_mut_bytesf64_as_ne_bytesf64_as_ne_mut_bytes//! Trivial, internal byte transmutation.//! A dependency like bytemuck would give us extra assurance of the safety but overall would not//! reduce the amount of total unsafety. We don't use it in the interface where the traits would//! really become useful.//! SAFETY: These are benign casts as we apply them to fixed size integer types only. All of them//! are naturally aligned, valid for all bit patterns and their alignment is surely at most their//! size (we assert the latter fact since it is 'implementation defined' if following the letter of//! the unsafe code guidelines).//! TODO: Would like to use std-lib here.SmartReaderTiffFormatErrorTiffResultIfdIfdBigRationalBigSRationalSRationalBigSignedBigUnsignedBiginto_u16into_u32into_i64into_f32into_f64into_u32_vecinto_u8_vecinto_u16_vecinto_i32_vecinto_f32_vecinto_f64_vecinto_u64_vecinto_i64_vec/// Returns a mem_reader for the offset/value fielddecode_offsetoffset_to_bytes/// Extracts a list of BYTE tags stored in an offsetoffset_to_sbytes/// Extracts a list of SBYTE tags stored in an offset/// Type representing an Image File Directory//! Function for reading TIFF tagsifdDeflateReaderLZWReaderPackBitsReadertag_readerTagReaderfp_predict_f32fp_predict_f64DecodingBufferCompressionMethodPhotometricInterpretationPlanarConfigurationTiffUnsupportedErrorUsageErrorrows_per_stripStripDecodeStatetile_widthtile_lengthTileAttributes/// Computed values useful for tile decodingtiles_acrosstiles_downpadding_downphotometric_interpretationpredictorjpeg_tablesplanar_configstrip_decodertile_attributeschunk_offsetschunk_bytescolortypecreate_reader/// Samples per pixel within chunk./// In planar config, samples are stored in separate strips/chunks, also called bands./// Example with `bits_per_sample = [8, 8, 8]` and `PhotometricInterpretation::RGB`:/// * `PlanarConfiguration::Chunky` -> 3 (RGBRGBRGB...)/// * `PlanarConfiguration::Planar` -> 1 (RRR...) (GGG...) (BBB...)strips_per_pixel/// Number of strips per pixel.chunk_file_rangechunk_dimensionschunk_data_dimensionsexpand_chunkbytecastDecodingResult/// A vector of unsigned bytes/// A vector of unsigned words/// A vector of 32 bit unsigned ints/// A vector of 64 bit unsigned ints/// A vector of 32 bit IEEE floats/// A vector of 64 bit IEEE floats/// A vector of 8 bit signed ints/// A vector of 16 bit signed ints/// A vector of 32 bit signed ints/// A vector of 64 bit signed ints/// Result of a decoding processnew_f32new_f64new_i8new_i16new_i32new_i64as_buffer/// A slice of unsigned bytes/// A slice of unsigned words/// A slice of 32 bit unsigned ints/// A slice of 64 bit unsigned ints/// A slice of 32 bit IEEE floats/// A slice of 64 bit IEEE floats/// A slice of 8 bits signed ints/// A slice of 16 bits signed ints/// A slice of 32 bits signed ints/// A slice of 64 bits signed ints// A buffer for image decodingsubrange/// Chunk type of the internal representationdecoding_buffer_size/// The maximum size of any `DecodingResult` in bytes, the default is/// 256MiB. If the entire image is decoded at once, then this will/// be the maximum size of the image. If it is decoded one strip at a/// time, this will be the maximum size of a strip.ifd_value_size/// The maximum size of any ifd value in bytes, the default is/// 1MiB.intermediate_buffer_size/// Maximum size for intermediate buffer which may be used to limit the amount of data read per/// segment even if the entire image is decoded at once./// The purpose of this is to prevent all the fields of the struct from/// being public, as this would make adding new fields a major version/// bump.unlimited/// A configuration that does not impose any limits./// This is a good start if the caller only wants to impose selective limits, contrary to the/// default limits which allows selectively disabling limits./// Note that this configuration is likely to crash on excessively large images since,/// naturally, the machine running the program does not have infinite memory.bigtiffnext_ifdifd_offsetsseen_ifds/// The representation of a TIFF decoder/// Currently does not support decoding of interlaced imagesrev_hpredict_nsampfix_endianness_and_predictinvert_colors_unsignedinvert_colors_fpinvert_colorsfix_endianness/// Fix endianness. If `byte_order` matches the host, then conversion is a no-op.seek_to_image/// Loads the IFD at the specified index in the list, if one existsnext_image/// Reads in the next image./// If there is no further image in the TIFF file a format error is returned./// To determine whether there are more images call `TIFFDecoder::more_images` instead.more_images/// Returns `true` if there is at least one more image available./// Returns the byte_orderread_ifd_offset/// Reads a TIFF byte valueread_short/// Reads a TIFF short valueread_sshort/// Reads a TIFF sshort valueread_long/// Reads a TIFF long valueread_slong/// Reads a TIFF slong value/// Reads a TIFF float value/// Reads a TIFF double valueread_long8read_slong8/// Reads a string/// Reads a TIFF IFA offset/value fieldread_offset_u64goto_offset/// Moves the cursor to the specified offsetgoto_offset_u64/// Reads a IFD entry.// An IFD entry has four fields:// Tag   2 bytes// Type  2 bytes// Count 4 bytes// Value 4 bytes either a pointer the value itselfread_ifd/// Reads the IFD starting at the indicated location./// Tries to retrieve a tag./// Return `Ok(None)` if the tag is not present.find_tag_unsigned/// Tries to retrieve a tag and convert it to the desired unsigned type.find_tag_unsigned_vec/// Tries to retrieve a vector of all a tag's values and convert them to/// the desired unsigned type.get_tag_unsigned/// Returns an error if the tag is not present./// Returns an error if the tag is not presentget_tag_u32/// Tries to retrieve a tag and convert it to the desired type.get_tag_u64get_tag_f32get_tag_f64get_tag_u32_vecget_tag_u16_vecget_tag_u64_vecget_tag_f32_vecget_tag_f64_vecget_tag_u8_vec/// Tries to retrieve a tag and convert it to a 8bit vector.get_tag_ascii_string/// Tries to retrieve a tag and convert it to a ascii vector.check_chunk_typeget_chunk_type/// The chunk type (Strips / Tiles) of the imagestrip_count/// Number of strips in imagetile_count/// Number of tiles in imageread_chunk_to_bufferresult_buffer/// Read the specified chunk (at index `chunk_index`) and return the binary data as a Vector./// Returns the default chunk size for the current image. Any given chunk in the image is at most as large as/// the value returned here. For the size of the data (chunk minus padding), use `chunk_data_dimensions`./// Returns the size of the data in the chunk with the specified index. This is the default size of the chunk,/// minus any padding./// Decodes the entire image and return it as a Vector/// little endian byte order/// big endian byte order/// Byte order of the TIFF file./// Byte order that should be adhered to/// Reads an u16/// Reads an i8/// Reads an i16/// Reads an u32/// Reads an i32/// Reads an u64/// Reads an i64/// Reads an f32/// Reads an f64/// Reader that is aware of the byte order./// # READERS/// ## Deflate Reader/// ## LZW Reader/// Reader that decompresses LZW streams/// Wraps a readerPackBitsReaderState/// ## PackBits Reader/// Reader that unpacks Apple's `PackBits` format/// ## SmartReader Readertest_packbits//! All IO functionality needed for TIFF decodingrequire_tagfind_tag_uint_vecTiffValue/// The type of each sample of this colortypeTIFF_VALUE/// The value of the tiff tag `PhotometricInterpretation`BITS_PER_SAMPLE/// The value of the tiff tag `BitsPerSample`SAMPLE_FORMAT/// The value of the tiff tag `SampleFormat`/// Trait for different colortypes that can be encoded.GrayI8Gray16GrayI16Gray32GrayI32Gray32FloatGray64GrayI64Gray64FloatRGB32FloatRGB64RGB64FloatRGBA32FloatRGBA64RGBA64FloatCMYK8CMYK16CMYK32FloatCMYK64CMYK64FloatYCbCr8FlateCompression/// The Deflate algorithm used to compress image data in TIFF files.DeflateLevel/// The fastest possible compression mode.Balanced/// The conserative choice between speed and ratio./// The best compression available with Deflate./// The level of compression used by the Deflate algorithm./// It allows trading compression ratio for compression speed.with_level/// Create a new deflate compressor with a specific level of compression.COMPRESSION_METHODget_algorithmCompressionAlgorithmtest_deflateLZWEncoder/// The LZW algorithm used to compress image data in TIFF files.test_lzwlzwpackbitsPackbits/// The algorithm writes data directly into the writer./// It returns the total number of bytes written./// An algorithm used for compression/// The corresponding tag to the algorithm./// Method to optain a type that can store each variant of comression algorithm./// An algorithm used for compression with associated enums and optional configurations./// An enum to store each compression algorithm./// The default compression strategy does not apply any compression./// Compressor that uses the Packbits[^note] algorithm to compress bytes./// [^note]: PackBits is often ineffective on continuous tone images,///          including many grayscale images. In such cases, it is better///          to leave the image uncompressed.test_packbits_single_bytetest_packbits_repttest_packbits_large_rept_nonrept/// The default algorithm which does not compress at all.test_no_compressiontiff_valueResolutionUnitTiffWriterTiffKindStandardTiffKind/// Encoder for Tiff and BigTiff files./// With this type you can get a `DirectoryEncoder` or a `ImageEncoder`/// to encode Tiff/BigTiff ifd directories with images./// See `DirectoryEncoder` and `ImageEncoder`./// # extern crate tiff;/// # let mut file = std::io::Cursor::new(Vec::new());/// # let image_data = vec![0; 100*100*3];/// use tiff::encoder::*;/// // create a standard Tiff file/// let mut tiff = TiffEncoder::new(&mut file).unwrap();/// tiff.write_image::<colortype::RGB8>(100, 100, &image_data).unwrap();/// // create a BigTiff file/// let mut bigtiff = TiffEncoder::new_big(&mut file).unwrap();/// bigtiff.write_image::<colortype::RGB8>(100, 100, &image_data).unwrap();/// Creates a new encoder for standard Tiff files./// To create BigTiff files, use [`new_big`][TiffEncoder::new_big] or/// [`new_generic`][TiffEncoder::new_generic]./// Constructor functions to create standard Tiff files.new_big/// Creates a new encoder for BigTiff files./// To create standard Tiff files, use [`new`][TiffEncoder::new] orTiffKindBig/// Constructor functions to create BigTiff files.new_generic/// Creates a new Tiff or BigTiff encoder, inferred from the return type.DirectoryEncoder/// Create a [`DirectoryEncoder`] to encode an ifd directory.new_image/// Create an [`ImageEncoder`] to encode an image one slice at a time.new_image_with_compression/// Convenience function to write an entire image from memory.write_image_with_compression/// Convenience function to write an entire image from memory with a given compression./// Generic functions that are available for both Tiff and BigTiff encoders.ifd_pointer_pos// We use BTreeMap to make sure tags are written in correct orderOffsetTypeDirectoryEntry/// Low level interface to encode ifd directories./// You should call `finish` on this when you are finished with it./// Encoding can silently fail while this is dropping./// Write a single ifd tag.write_directory/// Write some data to the tiff file, the offset of the data is returned./// This could be used to write tiff strips.last_written/// Provides the number of bytes written by the underlying TiffWriter during the last call./// Write out the ifd directory.strip_idxrow_samplesstrip_offsetsstrip_byte_count/// Type to encode images strip by strip./// use tiff::tags::Tag;/// let mut image = tiff.new_image::<colortype::RGB8>(100, 100).unwrap();/// // You can encode tags here/// image.encoder().write_tag(Tag::Artist, "Image-tiff").unwrap();/// // Strip size can be configured before writing data/// image.rows_per_strip(2).unwrap();/// let mut idx = 0;/// while image.next_strip_sample_count() > 0 {///     let sample_count = image.next_strip_sample_count() as usize;///     image.write_strip(&image_data[idx..idx+sample_count]).unwrap();///     idx += sample_count;/// image.finish().unwrap();/// You can also call write_data function wich will encode by strip and finishwith_compressionnext_strip_sample_count/// Number of samples the next strip should have.write_strip/// Write a single strip./// Write strips from data/// Set image resolutionresolution_unit/// Set image resolution unitx_resolution/// Set image x-resolutiony_resolution/// Set image y-resolution/// Set image number of lines per strip/// This function needs to be called before any calls to `write_data` or/// `write_strip` and will return an error otherwise./// Get a reference of the underlying `DirectoryEncoder`/// Write out image and ifd directory./// The type of offset fields, `u32` for normal Tiff, `u64` for BigTiff.OffsetArrayType/// Needed for the `convert_slice` method./// Write the (Big)Tiff header.convert_offset/// Convert a file offset to `Self::OffsetType`./// This returns an error for normal Tiff if the offset is larger than `u32::MAX`./// Write an offset value to the given writer./// Like `convert_offset`, this errors if `offset > u32::MAX` for normal Tiff.write_entry_count/// Write the IFD entry count field with the given `count` value./// The entry count field is an `u16` for normal Tiff and `u64` for BigTiff. Errors/// if the given `usize` is larger than the representable values.convert_slice/// Internal helper method for satisfying Rust's type checker./// The `TiffValue` trait is implemented for both primitive values (e.g. `u8`, `u32`) and/// slices of primitive values (e.g. `[u8]`, `[u32]`). However, this is not represented in/// the type system, so there is no guarantee that that for all `T: TiffValue` there is also/// an implementation of `TiffValue` for `[T]`. This method works around that problem by/// providing a conversion from `[T]` to some value that implements `TiffValue`, thereby/// making all slices of `OffsetType` usable with `write_tag` and similar methods./// Implementations of this trait should always set `OffsetArrayType` to `[OffsetType]`./// Trait to abstract over Tiff/BigTiff differences./// Implemented for [`TiffKindStandard`] and [`TiffKindBig`]./// Create a standard Tiff file./// Create a BigTiff file.BYTE_LENFIELD_TYPE/// Access this value as an contiguous sequence of bytes./// If their is no trivial representation, allocate it on the heap./// Write this value to a TiffWriter./// While the default implementation will work in all cases, it may require unnecessary allocations./// The written bytes of any custom implementation MUST be the same as yielded by `self.data()`./// Trait for types that can be encoded in a tiff fileIfd8impl_tiff_value_for_contiguous_sequence/// Type to represent tiff values of type `IFD`/// Type to represent tiff values of type `IFD8`/// Type to represent tiff values of type `RATIONAL`/// Type to represent tiff values of type `SRATIONAL`write_tiff_headerwrite_bigtiff_header/// Writes a BigTiff header, excluding the IFD offset field./// Writes the byte order, version number, offset byte size, and zero constant fields. Does// _not_ write the offset to the first IFD, this should be done by the caller.reset_compressionpad_word_boundary/// The Image is not formatted properly./// The Decoder does not support features required by the image./// An I/O Error occurred while decoding the image./// The Limits of the Decoder is exceeded.IntSizeError/// An integer conversion to or from a platform size failed, either due to/// limits of the platform size or limits of the format./// The image does not support the requested operation/// Tiff error kinds.TiffSignatureNotFoundTiffSignatureInvalidImageFileDirectoryNotFoundInconsistentSizesEncounteredactual_bytesrequired_bytesUnexpectedCompressedDataactual_samplesrequired_samplesInconsistentStripSamplesInvalidTagValueTypeRequiredTagNotFoundUnknownPredictorUnknownPlanarConfigurationByteExpectedUnsignedIntegerExpectedSignedIntegerExpectedRequiredTagEmptyStripTileTagConflictCycleInOffsetsJpegDecoderErrorSamplesPerPixelIsZero/// The image is not formatted properly./// This indicates that the encoder producing the image might behave incorrectly or that the input/// file has been corrupted./// The list of variants may grow to incorporate errors of future features. Matching against this/// exhaustively is not covered by interface stability guarantees.FloatingPointPredictorHorizontalPredictorInconsistentBitsPerSampleInterpretationWithBitsUnknownInterpretationUnsupportedCompressionMethodUnsupportedSampleDepthUnsupportedSampleFormatUnsupportedColorTypeUnsupportedBitsPerChannelUnsupportedPlanarConfigUnsupportedDataTypeUnsupportedInterpretationUnsupportedJpegFeature/// This only captures known failures for which the standard either does not require support or an/// implementation has been planned but not yet completed. Some variants may become unused over/// time and will then get deprecated before being removed./// The list of variants may grow. Matching against this exhaustively is not covered by interface/// stability guarantees.InvalidChunkTypeInvalidChunkIndex/// User attempted to use the Decoder in a way that is incompatible with a specific image./// For example: attempting to read a tile from a stripped image./// Pixel is grayscale/// Pixel contains R, G and B channels/// Pixel is an index into a color palette/// Pixel is grayscale with an alpha channel/// Pixel is RGB with an alpha channel/// Pixel is CMYK/// Pixel is YCbCr/// An enumeration over supported color types and their bit depths//! * <https://web.archive.org/web/20210108073850/https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification// For u16 tags, provide direct inherent primitive conversion methods.// For other tag types, do nothing for now. With concat_idents one could// provide inherent conversion methods for all types.r" TIFF tags"BitsPerSampleCellLengthCellWidthExtraSamplesFillOrderFreeByteCountsFreeOffsetsGrayResponseCurveGrayResponseUnitHostComputerImageDescriptionImageLengthMakeMaxSampleValueMinSampleValueModelNewSubfileTypeRowsPerStripSamplesPerPixelStripByteCountsStripOffsetsSubfileTypeThreshholdingXResolutionYResolutionTileWidthTileLengthTileOffsetsTileByteCountsSMinSampleValueSMaxSampleValueJPEGTablesModelPixelScaleTagModelTransformationTagModelTiepointTagGeoKeyDirectoryTagGeoDoubleParamsTagGeoAsciiParamsTagGdalNodata"A private or extension tag"__from_inner_type__to_inner_typefrom_u16_exhaustive// Note: These tags appear in the order they are mentioned in the TIFF referencer" The type of an IFD entry (a 2 byte field)."r" 8-bit unsigned integer"r" 8-bit byte that contains a 7-bit ASCII code; the last byte must be zero"r" 16-bit unsigned integer"r" 32-bit unsigned integer"r" Fraction stored as two 32-bit unsigned integers"r" 8-bit signed integer"SBYTEr" 8-bit byte that may contain anything, depending on the field"r" 16-bit signed integer"SSHORTr" 32-bit signed integer"SLONGr" Fraction stored as two 32-bit signed integers"SRATIONALr" 32-bit IEEE floating point"FLOATr" 64-bit IEEE floating point"r" 32-bit unsigned integer (offset)"IFDr" BigTIFF 64-bit unsigned integer"LONG8r" BigTIFF 64-bit signed integer"SLONG8r" BigTIFF 64-bit unsigned integer (offset)"IFD8r" See [TIFF compression tags](https://www.awaresystems.be/imaging/tiff/tifftags/compression.html)"r" for reference."Fax3Fax4LZWModernJPEGOldDeflatePackBits"A custom compression method"WhiteIsZeroBlackIsZeroRGBPaletteTransparencyMaskCIELabChunkyPlanarFloatingPointr" Type to represent resolution units"CentimeterIEEEFP"An unknown extension sample format"DigitCountFormattablecascadeconst_tryensure_rangedexpect_optimpl_add_assignimpl_sub_assigndays_in_yeardays_in_year_monthweeks_in_year/// The minimum valid year./// The maximum valid year./// Bitpacked field containing both the year and ordinal.// |     xx     | xxxxxxxxxxxxxxxxxxxxx | xxxxxxxxx |// |   2 bits   |        21 bits        |  9 bits   |// | unassigned |         year          |  ordinal  |// The year is 15 bits when `large-dates` is not enabled./// Date in the proleptic Gregorian calendar./// By default, years between ±9999 inclusive are representable. This can be expanded to ±999,999/// inclusive by enabling the `large-dates` crate feature. Doing so has performance implications/// and introduces some ambiguities when parsing./// The minimum valid `Date`./// The value of this may vary depending on the feature flags enabled.// Safety: `ordinal` is not zero./// The maximum valid `Date`.__from_ordinal_date_unchecked// region: constructors/// Construct a `Date` from the year and ordinal values, the validity of which must be/// guaranteed by the caller./// `ordinal` must not be zero. `year` should be in the range `MIN_YEAR..=MAX_YEAR`, but this/// is not a safety invariant.from_calendar_date/// Attempt to create a `Date` from the year, month, and day./// # use time::{Date, Month};/// assert!(Date::from_calendar_date(2019, Month::January, 1).is_ok());/// assert!(Date::from_calendar_date(2019, Month::December, 31).is_ok());/// assert!(Date::from_calendar_date(2019, Month::February, 29).is_err()); // 2019 isn't a leap year.from_ordinal_date/// Attempt to create a `Date` from the year and ordinal day number./// # use time::Date;/// assert!(Date::from_ordinal_date(2019, 1).is_ok());/// assert!(Date::from_ordinal_date(2019, 365).is_ok());/// assert!(Date::from_ordinal_date(2019, 366).is_err()); // 2019 isn't a leap year.from_iso_week_date/// Attempt to create a `Date` from the ISO year, week, and weekday./// # use time::{Date, Weekday::*};/// assert!(Date::from_iso_week_date(2019, 1, Monday).is_ok());/// assert!(Date::from_iso_week_date(2019, 1, Tuesday).is_ok());/// assert!(Date::from_iso_week_date(2020, 53, Friday).is_ok());/// assert!(Date::from_iso_week_date(2019, 53, Monday).is_err()); // 2019 doesn't have 53 weeks.from_julian_day/// Create a `Date` from the Julian day./// The algorithm to perform this conversion is derived from one provided by Peter Baum; it is/// freely available [here](https://www.researchgate.net/publication/316558298_Date_Algorithms)./// # use time_macros::date;/// assert_eq!(Date::from_julian_day(0), Ok(date!(-4713 - 11 - 24)));/// assert_eq!(Date::from_julian_day(2_451_545), Ok(date!(2000 - 01 - 01)));/// assert_eq!(Date::from_julian_day(2_458_485), Ok(date!(2019 - 01 - 01)));/// assert_eq!(Date::from_julian_day(2_458_849), Ok(date!(2019 - 12 - 31)));from_julian_day_unchecked/// This does not check the validity of the provided Julian day, and as such may result in an/// internally invalid value.// region: getters/// Get the year of the date./// assert_eq!(date!(2019 - 01 - 01).year(), 2019);/// assert_eq!(date!(2019 - 12 - 31).year(), 2019);/// assert_eq!(date!(2020 - 01 - 01).year(), 2020);/// # use time::Month;/// assert_eq!(date!(2019 - 01 - 01).month(), Month::January);/// assert_eq!(date!(2019 - 12 - 31).month(), Month::December);/// Get the day of the month./// The returned value will always be in the range `1..=31`./// assert_eq!(date!(2019 - 01 - 01).day(), 1);/// assert_eq!(date!(2019 - 12 - 31).day(), 31);/// Get the month and day. This is more efficient than fetching the components individually.// For whatever reason, rustc has difficulty optimizing this function. It's significantly faster// to write the statements out by hand./// Get the day of the year./// The returned value will always be in the range `1..=366` (`1..=365` for common years)./// assert_eq!(date!(2019 - 01 - 01).ordinal(), 1);/// assert_eq!(date!(2019 - 12 - 31).ordinal(), 365);iso_year_week/// Get the ISO 8601 year and week number./// Get the ISO week number./// The returned value will always be in the range `1..=53`./// assert_eq!(date!(2019 - 01 - 01).iso_week(), 1);/// assert_eq!(date!(2019 - 10 - 04).iso_week(), 40);/// assert_eq!(date!(2020 - 01 - 01).iso_week(), 1);/// assert_eq!(date!(2020 - 12 - 31).iso_week(), 53);/// assert_eq!(date!(2021 - 01 - 01).iso_week(), 53);sunday_based_week/// Get the week number where week 1 begins on the first Sunday./// The returned value will always be in the range `0..=53`./// assert_eq!(date!(2019 - 01 - 01).sunday_based_week(), 0);/// assert_eq!(date!(2020 - 01 - 01).sunday_based_week(), 0);/// assert_eq!(date!(2020 - 12 - 31).sunday_based_week(), 52);/// assert_eq!(date!(2021 - 01 - 01).sunday_based_week(), 0);monday_based_week/// Get the week number where week 1 begins on the first Monday./// assert_eq!(date!(2019 - 01 - 01).monday_based_week(), 0);/// assert_eq!(date!(2020 - 01 - 01).monday_based_week(), 0);/// assert_eq!(date!(2020 - 12 - 31).monday_based_week(), 52);/// assert_eq!(date!(2021 - 01 - 01).monday_based_week(), 0);to_calendar_date/// Get the year, month, and day.///     date!(2019 - 01 - 01).to_calendar_date(),///     (2019, Month::January, 1)to_ordinal_date/// Get the year and ordinal day number./// assert_eq!(date!(2019 - 01 - 01).to_ordinal_date(), (2019, 1));to_iso_week_date/// Get the ISO 8601 year, week number, and weekday./// # use time::Weekday::*;/// assert_eq!(date!(2019 - 01 - 01).to_iso_week_date(), (2019, 1, Tuesday));/// assert_eq!(date!(2019 - 10 - 04).to_iso_week_date(), (2019, 40, Friday));///     date!(2020 - 01 - 01).to_iso_week_date(),///     (2020, 1, Wednesday)///     date!(2020 - 12 - 31).to_iso_week_date(),///     (2020, 53, Thursday)/// assert_eq!(date!(2021 - 01 - 01).to_iso_week_date(), (2020, 53, Friday));/// Get the weekday./// assert_eq!(date!(2019 - 01 - 01).weekday(), Tuesday);/// assert_eq!(date!(2019 - 02 - 01).weekday(), Friday);/// assert_eq!(date!(2019 - 03 - 01).weekday(), Friday);/// assert_eq!(date!(2019 - 04 - 01).weekday(), Monday);/// assert_eq!(date!(2019 - 05 - 01).weekday(), Wednesday);/// assert_eq!(date!(2019 - 06 - 01).weekday(), Saturday);/// assert_eq!(date!(2019 - 07 - 01).weekday(), Monday);/// assert_eq!(date!(2019 - 08 - 01).weekday(), Thursday);/// assert_eq!(date!(2019 - 09 - 01).weekday(), Sunday);/// assert_eq!(date!(2019 - 10 - 01).weekday(), Tuesday);/// assert_eq!(date!(2019 - 11 - 01).weekday(), Friday);/// assert_eq!(date!(2019 - 12 - 01).weekday(), Sunday);next_day/// Get the next calendar date.///     date!(2019 - 01 - 01).next_day(),///     Some(date!(2019 - 01 - 02))///     date!(2019 - 01 - 31).next_day(),///     Some(date!(2019 - 02 - 01))///     date!(2019 - 12 - 31).next_day(),///     Some(date!(2020 - 01 - 01))/// assert_eq!(Date::MAX.next_day(), None);previous_day/// Get the previous calendar date.///     date!(2019 - 01 - 02).previous_day(),///     Some(date!(2019 - 01 - 01))///     date!(2019 - 02 - 01).previous_day(),///     Some(date!(2019 - 01 - 31))///     date!(2020 - 01 - 01).previous_day(),///     Some(date!(2019 - 12 - 31))/// assert_eq!(Date::MIN.previous_day(), None);next_occurrence/// Calculates the first occurrence of a weekday that is strictly later than a given `Date`./// Panics if an overflow occurred./// # use time::Weekday;///     date!(2023 - 06 - 28).next_occurrence(Weekday::Monday),///     date!(2023 - 07 - 03)///     date!(2023 - 06 - 19).next_occurrence(Weekday::Monday),///     date!(2023 - 06 - 26)prev_occurrence/// Calculates the first occurrence of a weekday that is strictly earlier than a given `Date`.///     date!(2023 - 06 - 28).prev_occurrence(Weekday::Monday),///     date!(2023 - 06 - 19).prev_occurrence(Weekday::Monday),///     date!(2023 - 06 - 12)nth_next_occurrence/// Calculates the `n`th occurrence of a weekday that is strictly later than a given `Date`./// Panics if an overflow occurred or if `n == 0`.///     date!(2023 - 06 - 25).nth_next_occurrence(Weekday::Monday, 5),///     date!(2023 - 07 - 24)///     date!(2023 - 06 - 26).nth_next_occurrence(Weekday::Monday, 5),///     date!(2023 - 07 - 31)nth_prev_occurrence/// Calculates the `n`th occurrence of a weekday that is strictly earlier than a given `Date`.///     date!(2023 - 06 - 27).nth_prev_occurrence(Weekday::Monday, 3),///     date!(2023 - 06 - 26).nth_prev_occurrence(Weekday::Monday, 3),///     date!(2023 - 06 - 05)to_julian_day/// Get the Julian day for the date./// assert_eq!(date!(-4713 - 11 - 24).to_julian_day(), 0);/// assert_eq!(date!(2000 - 01 - 01).to_julian_day(), 2_451_545);/// assert_eq!(date!(2019 - 01 - 01).to_julian_day(), 2_458_485);/// assert_eq!(date!(2019 - 12 - 31).to_julian_day(), 2_458_849);// region: checked arithmetic/// Computes `self + duration`, returning `None` if an overflow occurred./// # use time::{Date, ext::NumericalDuration};/// assert_eq!(Date::MAX.checked_add(1.days()), None);/// assert_eq!(Date::MIN.checked_add((-2).days()), None);///     date!(2020 - 12 - 31).checked_add(2.days()),///     Some(date!(2021 - 01 - 02))/// This function only takes whole days into account./// assert_eq!(Date::MAX.checked_add(23.hours()), Some(Date::MAX));/// assert_eq!(Date::MIN.checked_add((-23).hours()), Some(Date::MIN));///     date!(2020 - 12 - 31).checked_add(23.hours()),///     Some(date!(2020 - 12 - 31))///     date!(2020 - 12 - 31).checked_add(47.hours()),///     Some(date!(2021 - 01 - 01))checked_add_std/// # use time::{Date, ext::NumericalStdDuration};/// assert_eq!(Date::MAX.checked_add_std(1.std_days()), None);///     date!(2020 - 12 - 31).checked_add_std(2.std_days()),/// assert_eq!(Date::MAX.checked_add_std(23.std_hours()), Some(Date::MAX));///     date!(2020 - 12 - 31).checked_add_std(23.std_hours()),///     date!(2020 - 12 - 31).checked_add_std(47.std_hours()),/// Computes `self - duration`, returning `None` if an overflow occurred./// assert_eq!(Date::MAX.checked_sub((-2).days()), None);/// assert_eq!(Date::MIN.checked_sub(1.days()), None);///     date!(2020 - 12 - 31).checked_sub(2.days()),///     Some(date!(2020 - 12 - 29))/// assert_eq!(Date::MAX.checked_sub((-23).hours()), Some(Date::MAX));/// assert_eq!(Date::MIN.checked_sub(23.hours()), Some(Date::MIN));///     date!(2020 - 12 - 31).checked_sub(23.hours()),///     date!(2020 - 12 - 31).checked_sub(47.hours()),///     Some(date!(2020 - 12 - 30))checked_sub_std/// assert_eq!(Date::MIN.checked_sub_std(1.std_days()), None);///     date!(2020 - 12 - 31).checked_sub_std(2.std_days()),/// assert_eq!(Date::MIN.checked_sub_std(23.std_hours()), Some(Date::MIN));///     date!(2020 - 12 - 31).checked_sub_std(23.std_hours()),///     date!(2020 - 12 - 31).checked_sub_std(47.std_hours()),checked_next_occurrence/// Returns `None` if an overflow occurred.checked_prev_occurrencechecked_nth_next_occurrence/// Returns `None` if an overflow occurred or if `n == 0`.checked_nth_prev_occurrence// region: saturating arithmetic/// Computes `self + duration`, saturating value on overflow./// assert_eq!(Date::MAX.saturating_add(1.days()), Date::MAX);/// assert_eq!(Date::MIN.saturating_add((-2).days()), Date::MIN);///     date!(2020 - 12 - 31).saturating_add(2.days()),///     date!(2021 - 01 - 02)/// # use time::ext::NumericalDuration;///     date!(2020 - 12 - 31).saturating_add(23.hours()),///     date!(2020 - 12 - 31)///     date!(2020 - 12 - 31).saturating_add(47.hours()),///     date!(2021 - 01 - 01)/// Computes `self - duration`, saturating value on overflow./// assert_eq!(Date::MAX.saturating_sub((-2).days()), Date::MAX);/// assert_eq!(Date::MIN.saturating_sub(1.days()), Date::MIN);///     date!(2020 - 12 - 31).saturating_sub(2.days()),///     date!(2020 - 12 - 29)///     date!(2020 - 12 - 31).saturating_sub(23.hours()),///     date!(2020 - 12 - 31).saturating_sub(47.hours()),///     date!(2020 - 12 - 30)"This method does not mutate the original `Date`."replace_year// region: replacement/// Replace the year. The month and day will be unchanged.///     date!(2022 - 02 - 18).replace_year(2019),///     Ok(date!(2019 - 02 - 18))/// assert!(date!(2022 - 02 - 18).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year/// assert!(date!(2022 - 02 - 18).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid yearreplace_month/// Replace the month of the year.///     date!(2022 - 02 - 18).replace_month(Month::January),///     Ok(date!(2022 - 01 - 18))///     date!(2022 - 01 - 30)///         .replace_month(Month::February)/// ); // 30 isn't a valid day in Februaryreplace_day/// Replace the day of the month.///     date!(2022 - 02 - 18).replace_day(1),///     Ok(date!(2022 - 02 - 01))/// assert!(date!(2022 - 02 - 18).replace_day(0).is_err()); // 0 isn't a valid day/// assert!(date!(2022 - 02 - 18).replace_day(30).is_err()); // 30 isn't a valid day in Februaryreplace_ordinal/// Replace the day of the year./// assert_eq!(date!(2022 - 049).replace_ordinal(1), Ok(date!(2022 - 001)));/// assert!(date!(2022 - 049).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal/// assert!(date!(2022 - 049).replace_ordinal(366).is_err()); // 2022 isn't a leap year// endregion constructors// endregion getters// endregion: checked arithmetic// endregion replacementmidnight/// Create a [`PrimitiveDateTime`] using the existing date. The [`Time`] component will be set/// to midnight./// # use time_macros::{date, datetime};/// assert_eq!(date!(1970-01-01).midnight(), datetime!(1970-01-01 0:00));/// Create a [`PrimitiveDateTime`] using the existing date and the provided [`Time`]./// # use time_macros::{date, datetime, time};///     date!(1970-01-01).with_time(time!(0:00)),///     datetime!(1970-01-01 0:00),with_hms/// Attempt to create a [`PrimitiveDateTime`] using the existing date and the provided time./// assert!(date!(1970 - 01 - 01).with_hms(0, 0, 0).is_ok());/// assert!(date!(1970 - 01 - 01).with_hms(24, 0, 0).is_err());with_hms_milli/// assert!(date!(1970 - 01 - 01).with_hms_milli(0, 0, 0, 0).is_ok());/// assert!(date!(1970 - 01 - 01).with_hms_milli(24, 0, 0, 0).is_err());with_hms_micro/// assert!(date!(1970 - 01 - 01).with_hms_micro(0, 0, 0, 0).is_ok());/// assert!(date!(1970 - 01 - 01).with_hms_micro(24, 0, 0, 0).is_err());with_hms_nano/// assert!(date!(1970 - 01 - 01).with_hms_nano(0, 0, 0, 0).is_ok());/// assert!(date!(1970 - 01 - 01).with_hms_nano(24, 0, 0, 0).is_err());// region: attach time/// Methods to add a [`Time`] component, resulting in a [`PrimitiveDateTime`].format_into/// Format the `Date` using the provided [format description](crate::format_description)./// # use time::{format_description};/// let format = format_description::parse("[year]-[month]-[day]")?;/// assert_eq!(date!(2020 - 01 - 02).format(&format)?, "2020-01-02");/// # Ok::<_, time::Error>(())// region: formatting & parsing/// Parse a `Date` from the input using the provided [format/// description](crate::format_description)./// # use time_macros::{date, format_description};/// let format = format_description!("[year]-[month]-[day]");/// assert_eq!(Date::parse("2020-01-02", &format)?, date!(2020 - 01 - 02));year_width/// The width of the year component, including the sign.display_sign/// Whether the sign should be displayed.DateMetadata/// This may panic if an overflow occurs.// region: trait impls__impl_assign//! The [`Date`] struct and its associated `impl`s.// endregion attach time// endregion formatting & parsing// endregion trait implsimpl_div_assignOptimize/// By explicitly inserting this enum where padding is expected, the compiler is able to better/// perform niche value optimization.Nanosecondsper/// The type of the `nanosecond` field of `Duration`./// Number of whole seconds./// Number of nanoseconds within the second. The sign always matches the `seconds` field.// Sign must match that of `seconds` (though this is not a safety requirement)./// A span of time with nanosecond precision./// Each `Duration` is composed of a whole number of seconds and a fractional part represented in/// nanoseconds./// This implementation allows for negative durations, unlike [`core::time::Duration`].try_from_secs/// This is adapted from the [`std` implementation][std], which uses mostly bit/// operations to ensure the highest precision:/// Changes from `std` are marked and explained below./// [std]: https://github.com/rust-lang/rust/blob/3a37c2f0523c87147b64f1b8099fc9df22e8c53e/library/core/src/time.rs#L1262-L1340// Skip `rustfmt` because it reformats the arguments of the macro weirdly.// region: constants/// Equivalent to `0.seconds()`./// # use time::{Duration, ext::NumericalDuration};/// assert_eq!(Duration::ZERO, 0.seconds());/// Equivalent to `1.nanoseconds()`./// assert_eq!(Duration::NANOSECOND, 1.nanoseconds());MICROSECOND/// Equivalent to `1.microseconds()`./// assert_eq!(Duration::MICROSECOND, 1.microseconds());/// Equivalent to `1.milliseconds()`./// assert_eq!(Duration::MILLISECOND, 1.milliseconds());/// Equivalent to `1.seconds()`./// assert_eq!(Duration::SECOND, 1.seconds());MINUTE/// Equivalent to `1.minutes()`./// assert_eq!(Duration::MINUTE, 1.minutes());HOUR/// Equivalent to `1.hours()`./// assert_eq!(Duration::HOUR, 1.hours());DAY/// Equivalent to `1.days()`./// assert_eq!(Duration::DAY, 1.days());WEEK/// Equivalent to `1.weeks()`./// assert_eq!(Duration::WEEK, 1.weeks());/// The minimum possible duration. Adding any negative duration to this will cause an overflow./// The maximum possible duration. Adding any positive duration to this will cause an overflow.// region: is_{sign}/// Check if a duration is exactly zero./// assert!(0.seconds().is_zero());/// assert!(!1.nanoseconds().is_zero());/// Check if a duration is negative./// assert!((-1).seconds().is_negative());/// assert!(!0.seconds().is_negative());/// assert!(!1.seconds().is_negative());/// Check if a duration is positive./// assert!(1.seconds().is_positive());/// assert!(!0.seconds().is_positive());/// assert!(!(-1).seconds().is_positive());// region: abs/// Get the absolute value of the duration./// This method saturates the returned value if it would otherwise overflow./// assert_eq!(1.seconds().abs(), 1.seconds());/// assert_eq!(0.seconds().abs(), 0.seconds());/// assert_eq!((-1).seconds().abs(), 1.seconds());/// Convert the existing `Duration` to a `std::time::Duration` and its sign. This returns a/// [`std::time::Duration`] and does not saturate the returned value (unlike [`Duration::abs`])./// # use time::ext::{NumericalDuration, NumericalStdDuration};/// assert_eq!(1.seconds().unsigned_abs(), 1.std_seconds());/// assert_eq!(0.seconds().unsigned_abs(), 0.std_seconds());/// assert_eq!((-1).seconds().unsigned_abs(), 1.std_seconds());/// Create a new `Duration` without checking the validity of the components./// - `nanoseconds` must be in the range `-999_999_999..=999_999_999`./// While the sign of `nanoseconds` is required to be the same as the sign of `seconds`, this is/// not a safety invariant.new_ranged_unchecked/// Create a new `Duration` with the provided seconds and nanoseconds. If nanoseconds is at/// least ±10<sup>9</sup>, it will wrap to the number of seconds./// assert_eq!(Duration::new(1, 0), 1.seconds());/// assert_eq!(Duration::new(-1, 0), (-1).seconds());/// assert_eq!(Duration::new(1, 2_000_000_000), 3.seconds());new_ranged/// Create a new `Duration` with the provided seconds and nanoseconds./// Create a new `Duration` with the given number of weeks. Equivalent to/// `Duration::seconds(weeks * 604_800)`./// assert_eq!(Duration::weeks(1), 604_800.seconds());/// Create a new `Duration` with the given number of days. Equivalent to/// `Duration::seconds(days * 86_400)`./// assert_eq!(Duration::days(1), 86_400.seconds());/// Create a new `Duration` with the given number of hours. Equivalent to/// `Duration::seconds(hours * 3_600)`./// assert_eq!(Duration::hours(1), 3_600.seconds());/// Create a new `Duration` with the given number of minutes. Equivalent to/// `Duration::seconds(minutes * 60)`./// assert_eq!(Duration::minutes(1), 60.seconds());/// Create a new `Duration` with the given number of seconds./// assert_eq!(Duration::seconds(1), 1_000.milliseconds());seconds_f64/// Creates a new `Duration` from the specified number of seconds represented as `f64`./// assert_eq!(Duration::seconds_f64(0.5), 0.5.seconds());/// assert_eq!(Duration::seconds_f64(-0.5), -0.5.seconds());seconds_f32/// Creates a new `Duration` from the specified number of seconds represented as `f32`./// assert_eq!(Duration::seconds_f32(0.5), 0.5.seconds());/// assert_eq!(Duration::seconds_f32(-0.5), (-0.5).seconds());saturating_seconds_f64/// Creates a new `Duration` from the specified number of seconds/// represented as `f64`. Any values that are out of bounds are saturated at/// the minimum or maximum respectively. `NaN` gets turned into a `Duration`/// of 0 seconds./// assert_eq!(Duration::saturating_seconds_f64(0.5), 0.5.seconds());/// assert_eq!(Duration::saturating_seconds_f64(-0.5), -0.5.seconds());///     Duration::saturating_seconds_f64(f64::NAN),///     Duration::new(0, 0),///     Duration::saturating_seconds_f64(f64::NEG_INFINITY),///     Duration::MIN,///     Duration::saturating_seconds_f64(f64::INFINITY),///     Duration::MAX,saturating_seconds_f32/// represented as `f32`. Any values that are out of bounds are saturated at/// assert_eq!(Duration::saturating_seconds_f32(0.5), 0.5.seconds());/// assert_eq!(Duration::saturating_seconds_f32(-0.5), (-0.5).seconds());///     Duration::saturating_seconds_f32(f32::NAN),///     Duration::saturating_seconds_f32(f32::NEG_INFINITY),///     Duration::saturating_seconds_f32(f32::INFINITY),checked_seconds_f64/// represented as `f64`. Returns `None` if the `Duration` can't be/// assert_eq!(Duration::checked_seconds_f64(0.5), Some(0.5.seconds()));/// assert_eq!(Duration::checked_seconds_f64(-0.5), Some(-0.5.seconds()));/// assert_eq!(Duration::checked_seconds_f64(f64::NAN), None);/// assert_eq!(Duration::checked_seconds_f64(f64::NEG_INFINITY), None);/// assert_eq!(Duration::checked_seconds_f64(f64::INFINITY), None);checked_seconds_f32/// represented as `f32`. Returns `None` if the `Duration` can't be/// assert_eq!(Duration::checked_seconds_f32(0.5), Some(0.5.seconds()));/// assert_eq!(Duration::checked_seconds_f32(-0.5), Some(-0.5.seconds()));/// assert_eq!(Duration::checked_seconds_f32(f32::NAN), None);/// assert_eq!(Duration::checked_seconds_f32(f32::NEG_INFINITY), None);/// assert_eq!(Duration::checked_seconds_f32(f32::INFINITY), None);/// Create a new `Duration` with the given number of milliseconds./// assert_eq!(Duration::milliseconds(1), 1_000.microseconds());/// assert_eq!(Duration::milliseconds(-1), (-1_000).microseconds());/// Create a new `Duration` with the given number of microseconds./// assert_eq!(Duration::microseconds(1), 1_000.nanoseconds());/// assert_eq!(Duration::microseconds(-1), (-1_000).nanoseconds());/// Create a new `Duration` with the given number of nanoseconds./// assert_eq!(Duration::nanoseconds(1), 1.microseconds() / 1_000);/// assert_eq!(Duration::nanoseconds(-1), (-1).microseconds() / 1_000);nanoseconds_i128/// As the input range cannot be fully mapped to the output, this should only be used where it's/// known to result in a valid value.whole_weeks/// Get the number of whole weeks in the duration./// assert_eq!(1.weeks().whole_weeks(), 1);/// assert_eq!((-1).weeks().whole_weeks(), -1);/// assert_eq!(6.days().whole_weeks(), 0);/// assert_eq!((-6).days().whole_weeks(), 0);whole_days/// Get the number of whole days in the duration./// assert_eq!(1.days().whole_days(), 1);/// assert_eq!((-1).days().whole_days(), -1);/// assert_eq!(23.hours().whole_days(), 0);/// assert_eq!((-23).hours().whole_days(), 0);whole_hours/// Get the number of whole hours in the duration./// assert_eq!(1.hours().whole_hours(), 1);/// assert_eq!((-1).hours().whole_hours(), -1);/// assert_eq!(59.minutes().whole_hours(), 0);/// assert_eq!((-59).minutes().whole_hours(), 0);whole_minutes/// Get the number of whole minutes in the duration./// assert_eq!(1.minutes().whole_minutes(), 1);/// assert_eq!((-1).minutes().whole_minutes(), -1);/// assert_eq!(59.seconds().whole_minutes(), 0);/// assert_eq!((-59).seconds().whole_minutes(), 0);whole_seconds/// Get the number of whole seconds in the duration./// assert_eq!(1.seconds().whole_seconds(), 1);/// assert_eq!((-1).seconds().whole_seconds(), -1);/// assert_eq!(1.minutes().whole_seconds(), 60);/// assert_eq!((-1).minutes().whole_seconds(), -60);/// Get the number of fractional seconds in the duration./// assert_eq!(1.5.seconds().as_seconds_f64(), 1.5);/// assert_eq!((-1.5).seconds().as_seconds_f64(), -1.5);/// assert_eq!(1.5.seconds().as_seconds_f32(), 1.5);/// assert_eq!((-1.5).seconds().as_seconds_f32(), -1.5);whole_milliseconds/// Get the number of whole milliseconds in the duration./// assert_eq!(1.seconds().whole_milliseconds(), 1_000);/// assert_eq!((-1).seconds().whole_milliseconds(), -1_000);/// assert_eq!(1.milliseconds().whole_milliseconds(), 1);/// assert_eq!((-1).milliseconds().whole_milliseconds(), -1);subsec_milliseconds/// Get the number of milliseconds past the number of whole seconds./// Always in the range `-999..=999`./// assert_eq!(1.4.seconds().subsec_milliseconds(), 400);/// assert_eq!((-1.4).seconds().subsec_milliseconds(), -400);// Allow the lint, as the value is guaranteed to be less than 1000.whole_microseconds/// Get the number of whole microseconds in the duration./// assert_eq!(1.milliseconds().whole_microseconds(), 1_000);/// assert_eq!((-1).milliseconds().whole_microseconds(), -1_000);/// assert_eq!(1.microseconds().whole_microseconds(), 1);/// assert_eq!((-1).microseconds().whole_microseconds(), -1);subsec_microseconds/// Get the number of microseconds past the number of whole seconds./// Always in the range `-999_999..=999_999`./// assert_eq!(1.0004.seconds().subsec_microseconds(), 400);/// assert_eq!((-1.0004).seconds().subsec_microseconds(), -400);whole_nanoseconds/// Get the number of nanoseconds in the duration./// assert_eq!(1.microseconds().whole_nanoseconds(), 1_000);/// assert_eq!((-1).microseconds().whole_nanoseconds(), -1_000);/// assert_eq!(1.nanoseconds().whole_nanoseconds(), 1);/// assert_eq!((-1).nanoseconds().whole_nanoseconds(), -1);subsec_nanoseconds/// Get the number of nanoseconds past the number of whole seconds./// The returned value will always be in the range `-999_999_999..=999_999_999`./// assert_eq!(1.000_000_400.seconds().subsec_nanoseconds(), 400);/// assert_eq!((-1.000_000_400).seconds().subsec_nanoseconds(), -400);/// Computes `self + rhs`, returning `None` if an overflow occurred./// assert_eq!(5.seconds().checked_add(5.seconds()), Some(10.seconds()));/// assert_eq!(Duration::MAX.checked_add(1.nanoseconds()), None);/// assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));/// Computes `self - rhs`, returning `None` if an overflow occurred./// assert_eq!(5.seconds().checked_sub(5.seconds()), Some(Duration::ZERO));/// assert_eq!(Duration::MIN.checked_sub(1.nanoseconds()), None);/// assert_eq!(5.seconds().checked_sub(10.seconds()), Some((-5).seconds()));/// Computes `self * rhs`, returning `None` if an overflow occurred./// assert_eq!(5.seconds().checked_mul(2), Some(10.seconds()));/// assert_eq!(5.seconds().checked_mul(-2), Some((-10).seconds()));/// assert_eq!(5.seconds().checked_mul(0), Some(0.seconds()));/// assert_eq!(Duration::MAX.checked_mul(2), None);/// assert_eq!(Duration::MIN.checked_mul(2), None);/// Computes `self / rhs`, returning `None` if `rhs == 0` or if the result would overflow./// assert_eq!(10.seconds().checked_div(2), Some(5.seconds()));/// assert_eq!(10.seconds().checked_div(-2), Some((-5).seconds()));/// assert_eq!(1.seconds().checked_div(0), None);/// Computes `-self`, returning `None` if the result would overflow./// # use time::Duration;/// assert_eq!(5.seconds().checked_neg(), Some((-5).seconds()));/// assert_eq!(Duration::MIN.checked_neg(), None);/// Computes `self + rhs`, saturating if an overflow occurred./// assert_eq!(5.seconds().saturating_add(5.seconds()), 10.seconds());/// assert_eq!(Duration::MAX.saturating_add(1.nanoseconds()), Duration::MAX);///     Duration::MIN.saturating_add((-1).nanoseconds()),///     Duration::MIN/// assert_eq!((-5).seconds().saturating_add(5.seconds()), Duration::ZERO);/// Computes `self - rhs`, saturating if an overflow occurred./// assert_eq!(5.seconds().saturating_sub(5.seconds()), Duration::ZERO);/// assert_eq!(Duration::MIN.saturating_sub(1.nanoseconds()), Duration::MIN);///     Duration::MAX.saturating_sub((-1).nanoseconds()),///     Duration::MAX/// assert_eq!(5.seconds().saturating_sub(10.seconds()), (-5).seconds());/// Computes `self * rhs`, saturating if an overflow occurred./// assert_eq!(5.seconds().saturating_mul(2), 10.seconds());/// assert_eq!(5.seconds().saturating_mul(-2), (-10).seconds());/// assert_eq!(5.seconds().saturating_mul(0), Duration::ZERO);/// assert_eq!(Duration::MAX.saturating_mul(2), Duration::MAX);/// assert_eq!(Duration::MIN.saturating_mul(2), Duration::MIN);/// assert_eq!(Duration::MAX.saturating_mul(-2), Duration::MIN);/// assert_eq!(Duration::MIN.saturating_mul(-2), Duration::MAX);time_fn/// Runs a closure, returning the duration of time it took to run. The return value of the/// closure is provided in the second part of the tuple.// endregion constants// endregion is_{sign}// endregion abs// endregion checked arithmetic// endregion saturating arithmetic/// The format returned by this implementation is not stable and must not be relied upon./// By default this produces an exact, full-precision printout of the duration./// For a concise, rounded printout instead, you can use the `.N` format specifier:/// let duration = Duration::new(123456, 789011223);/// println!("{duration:.3}");/// For the purposes of this implementation, a day is exactly 24 hours and a minute is exactly 60/// seconds.ConversionRange/// This may panic if the resulting addition cannot be represented./// This may panic if the resulting subtraction can not be represented.duration_mul_div_int/// Implement `Mul` (reflexively) and `Div` for `Duration` for various types.//! The [`Duration`] struct and its associated `impl`s./// Name of the component./// Minimum allowed value, inclusive./// Maximum allowed value, inclusive./// Value that was provided.conditional_range/// The minimum and/or maximum value is conditional on the value of other/// An error type indicating that a component provided to a method was out of range, causing a// i64 is the narrowest type fitting all use cases. This eliminates the need for a type parameter./// Obtain the name of the component whose value was out of range.is_conditional/// Whether the value's permitted range is conditional, i.e. whether an input with this/// value could have succeeded if the values of other components were different.DifferentVariant//! Component range error/// An error type indicating that a conversion failed because the target type could not store the/// initial value.//! Conversion range error/// An error type indicating that a [`TryFrom`](core::convert::TryFrom) call failed because the/// original value was of a different variant.//! Different variant errorInsufficientTypeInformation/// The type being formatted does not contain sufficient information to format a component.InvalidComponent/// The component named has a value that cannot be formatted into the requested format./// This variant is only returned when using well-known formats.StdIo/// A value of `std::io::Error` was returned internally./// An error occurred when formatting.//! Error formatting a structIndeterminateOffset/// The system's UTC offset could not be determined at the given datetime.//! Indeterminate offsetInvalidFormatDescription/// The zero-based index of the opening bracket.UnclosedOpeningBracket/// There was a bracket pair that was opened but not closed./// The name of the invalid component name./// The zero-based index the component name starts at.InvalidComponentName/// A component name is not valid./// The value of the invalid modifier./// The zero-based index the modifier starts at.InvalidModifier/// A modifier is not valid./// The zero-based index where the component name should start.MissingComponentName/// A component name is missing./// The name of the modifier that is missing./// The zero-based index of the component.MissingRequiredModifier/// A required modifier is missing./// What was expected to be present, but wasn't./// The zero-based index the item was expected to be found at./// Something was expected, but not found./// The behavior that is not supported./// The context in which the behavior is not supported./// The zero-based index the error occurred at./// Certain behavior is not supported in the given context./// The format description provided was not valid.//! Invalid format descriptionInvalidVariant/// An error type indicating that a [`FromStr`](core::str::FromStr) call failed because the value/// was not a valid variant.//! Invalid variant errorcomponent_rangeconversion_rangedifferent_variantindeterminate_offsetinvalid_format_descriptioninvalid_variantparse_from_descriptiontry_from_parsedParseFromDescriptionTryFromParsedUnexpectedTrailingCharacters/// A unified error type for anything returned by a method in the time crate./// This can be used when you either don't know or don't care about the exact error returned./// `Result<_, time::Error>` (or its alias `time::Result<_>`) will work in these situations.//! Various error types returned by methods in the time crate./// The input should have ended, but there were characters remaining./// An error that occurred at some stage of parsing.//! Error that occurred at some stage of parsing/// A string literal was not what was expected./// A dynamic component was not valid./// The input was expected to have ended, but there are characters that remain./// An error that occurred while parsing the input into a [`Parsed`](crate::parsing::Parsed) struct.//! Error parsing an input into a [`Parsed`](crate::parsing::Parsed) structInsufficientInformation/// The [`Parsed`](crate::parsing::Parsed) did not include enough information to construct the/// Some component contained an invalid value for the type./// An error that occurred when converting a [`Parsed`](crate::parsing::Parsed) to another type.//! Error converting a [`Parsed`](crate::parsing::Parsed) struct to another typenum_digits/// The number of digits in the stringified value./// A trait that indicates the formatted width of the value can be determined./// Note that this should not be implemented for any signed integers. This forces the caller to/// write the sign if desired.impl_digit_count/// A macro to generate implementations of `DigitCount` for unsigned integers.StdInstant/// A trait that cannot be implemented by downstream users./// Sealed trait to prevent downstream implementations.add_signed/// This function may panic if the resulting point in time cannot be represented by the/// underlying data structure. See [`InstantExt::checked_add_signed`] for a non-panickingsub_signed/// underlying data structure. See [`InstantExt::checked_sub_signed`] for a non-panicking/// Returns `Some(t)` where `t` is the time `self.checked_add_signed(duration)` if `t` can be/// represented as `Instant` (which means it's inside the bounds of the underlying data/// structure), `None` otherwise./// Returns `Some(t)` where `t` is the time `self.checked_sub_signed(duration)` if `t` can be/// Returns the amount of time elapsed from another instant to this one. This will be negative/// if `earlier` is later than `self`./// # use std::thread::sleep;/// # use std::time::{Duration, Instant};/// # use time::ext::InstantExt;/// sleep(Duration::new(1, 0));/// let new_now = Instant::now();/// println!("{:?}", new_now.signed_duration_since(now)); // positive/// println!("{:?}", now.signed_duration_since(new_now)); // negativeInstantExt/// An extension trait for [`std::time::Instant`] that adds methods for/// [`time::Duration`](Duration)s.digit_countnumerical_durationnumerical_std_durationNumericalDurationNumericalStdDuration/// Create a [`Duration`] from the number of nanoseconds./// Create a [`Duration`] from the number of microseconds./// Create a [`Duration`] from the number of milliseconds./// Create a [`Duration`] from the number of seconds./// Create a [`Duration`] from the number of minutes./// Create a [`Duration`] from the number of hours./// Create a [`Duration`] from the number of days./// Create a [`Duration`] from the number of weeks./// Create [`Duration`]s from numeric literals./// Basic construction of [`Duration`]s./// assert_eq!(5.nanoseconds(), Duration::nanoseconds(5));/// assert_eq!(5.microseconds(), Duration::microseconds(5));/// assert_eq!(5.milliseconds(), Duration::milliseconds(5));/// assert_eq!(5.seconds(), Duration::seconds(5));/// assert_eq!(5.minutes(), Duration::minutes(5));/// assert_eq!(5.hours(), Duration::hours(5));/// assert_eq!(5.days(), Duration::days(5));/// assert_eq!(5.weeks(), Duration::weeks(5));/// Signed integers work as well!/// assert_eq!((-5).nanoseconds(), Duration::nanoseconds(-5));/// assert_eq!((-5).microseconds(), Duration::microseconds(-5));/// assert_eq!((-5).milliseconds(), Duration::milliseconds(-5));/// assert_eq!((-5).seconds(), Duration::seconds(-5));/// assert_eq!((-5).minutes(), Duration::minutes(-5));/// assert_eq!((-5).hours(), Duration::hours(-5));/// assert_eq!((-5).days(), Duration::days(-5));/// assert_eq!((-5).weeks(), Duration::weeks(-5));/// Just like any other [`Duration`], they can be added, subtracted, etc./// assert_eq!(2.seconds() + 500.milliseconds(), 2_500.milliseconds());/// assert_eq!(2.seconds() - 500.milliseconds(), 1_500.milliseconds());/// When called on floating point values, any remainder of the floating point value will be/// truncated. Keep in mind that floating point numbers are inherently imprecise and have/// limited capacity.std_nanoseconds/// Create a [`std::time::Duration`] from the number of nanoseconds.std_microseconds/// Create a [`std::time::Duration`] from the number of microseconds.std_milliseconds/// Create a [`std::time::Duration`] from the number of milliseconds.std_seconds/// Create a [`std::time::Duration`] from the number of seconds.std_minutes/// Create a [`std::time::Duration`] from the number of minutes.std_hours/// Create a [`std::time::Duration`] from the number of hours.std_days/// Create a [`std::time::Duration`] from the number of days.std_weeks/// Create a [`std::time::Duration`] from the number of weeks./// Create [`std::time::Duration`]s from numeric literals./// Basic construction of [`std::time::Duration`]s./// # use time::ext::NumericalStdDuration;/// # use core::time::Duration;/// assert_eq!(5.std_nanoseconds(), Duration::from_nanos(5));/// assert_eq!(5.std_microseconds(), Duration::from_micros(5));/// assert_eq!(5.std_milliseconds(), Duration::from_millis(5));/// assert_eq!(5.std_seconds(), Duration::from_secs(5));/// assert_eq!(5.std_minutes(), Duration::from_secs(5 * 60));/// assert_eq!(5.std_hours(), Duration::from_secs(5 * 3_600));/// assert_eq!(5.std_days(), Duration::from_secs(5 * 86_400));/// assert_eq!(5.std_weeks(), Duration::from_secs(5 * 604_800));/// Just like any other [`std::time::Duration`], they can be added, subtracted, etc.///     2.std_seconds() + 500.std_milliseconds(),///     2_500.std_milliseconds()///     2.std_seconds() - 500.std_milliseconds(),///     1_500.std_milliseconds()/// This will panic if self is negative.BorrowedFormatItemFormatItem/// Bytes that are formatted as-is./// **Note**: These bytes **should** be UTF-8, but are not required to be. The value is passed/// through `String::from_utf8_lossy` when necessary./// A minimal representation of a single non-literal item./// A series of literals or components that collectively form a partial or complete/// A `FormatItem` that may or may not be present when parsing. If parsing fails, there/// will be no effect on the resulting `struct`./// This variant has no effect on formatting, as the value is guaranteed to be present./// A series of `FormatItem`s where, when parsing, the first successful parse is used. When/// formatting, the first element of the slice is used.  An empty slice is a no-op when/// formatting or parsing./// A complete description of how to format and parse a type.//! A format item with borrowed data./// Day of the month./// Month of the year./// Ordinal day of the year./// Day of the week.WeekNumber/// Week within the year./// Year of the date./// Hour of the day./// Minute within the hour./// AM/PM part of the time./// Second within the minute.Subsecond/// Subsecond within the second.OffsetHour/// Hour of the UTC offset.OffsetMinute/// Minute within the hour of the UTC offset.OffsetSecond/// Second within the minute of the UTC offset./// A number of bytes to ignore when parsing. This has no effect on formatting.UnixTimestamp/// The end of input. Parsing this component will fail if there is any input remaining. This/// component neither affects formatting nor consumes any input when parsing./// A component of a larger format description.//! Part of a format description.borrowed_format_itemowned_format_itemOwnedFormatItemparse_borrowedparse_ownediso8601rfc2822rfc3339Iso8601/// Well-known formats, typically standards.//! Description of how types should be formatted and parsed.//! The formatted value will be output to the provided writer. Format descriptions can be//! [well-known](crate::format_description::well_known) or obtained by using the//! [`format_description!`](crate::macros::format_description) macro or a function listed below.//! For examples, see the implementors of [Formattable](crate::formatting::Formattable),//! e.g. [`well_known::Rfc3339`]./// The padding to obtain the minimum width.// region: date modifiersMonthReprNumerical/// The number of the month (January is 1, December is 12)./// The long form of the month name (e.g. "January")./// The short form of the month name (e.g. "Jan")./// The representation of a month./// What form of representation should be used?/// Is the value case sensitive when parsing?WeekdayRepr/// The short form of the weekday (e.g. "Mon")./// The long form of the weekday (e.g. "Monday")./// A numerical representation using Sunday as the first day of the week./// Sunday is either 0 or 1, depending on the other modifier's value./// A numerical representation using Monday as the first day of the week./// Monday is either 0 or 1, depending on the other modifier's value./// The representation used for the day of the week.one_indexed/// When using a numerical representation, should it be zero or one-indexed?WeekNumberRepr/// Week 1 is the week that contains January 4./// Week 1 begins on the first Sunday of the calendar year./// Week 1 begins on the first Monday of the calendar year./// The representation used for the week number./// What kind of representation should be used?YearRepr/// The full value of the year.LastTwo/// Only the last two digits of the year./// The representation used for a year value.iso_week_based/// Whether the value is based on the ISO week number or the Gregorian calendar.sign_is_mandatory/// Whether the `+` sign is present when a positive year contains fewer than five digits.is_12_hour_clock/// Is the hour displayed using a 12 or 24-hour clock?// region: time modifiersis_uppercase/// Is the period uppercase or lowercase?/// Note that when `false`, the `is_uppercase` field has no effect on parsing behavior.SubsecondDigits/// Exactly one digit./// Exactly two digits./// Exactly three digits./// Exactly four digits.Five/// Exactly five digits./// Exactly six digits.Seven/// Exactly seven digits./// Exactly eight digits.Nine/// Exactly nine digits./// Any number of digits (up to nine) that is at least one. When formatting, the minimum digits/// necessary will be used./// The number of digits present in a subsecond representation./// How many digits are present in the component?/// Whether the `+` sign is present on positive values.// region: offset modifiers/// A space character (` `) should be used as padding./// A zero character (`0`) should be used as padding./// There is no padding. This can result in a width below the otherwise minimum number of/// Type of padding to ensure a minimum width./// The number of bytes to ignore./// Ignore some number of bytes./// This has no effect when formatting./// Create an instance of `Ignore` with the provided number of bytes to ignore.// Needed as `Default` is deliberately not implemented for `Ignore`. The number of bytes to ignore// must be explicitly provided.UnixTimestampPrecision/// Seconds since the Unix epoch.Millisecond/// Milliseconds since the Unix epoch.Microsecond/// Microseconds since the Unix epoch./// Nanoseconds since the Unix epoch./// The precision of a Unix timestamp./// The precision of the timestamp./// Whether the `+` sign must be present for a non-negative timestamp./// The end of input./// There is currently not customization for this modifier.if_pub/// Generate the provided code if and only if `pub` is present.impl_const_default/// Implement `Default` for the given type. This also generates an inherent implementation of a/// `default` method that is `const fn`, permitting the default value to be used in const contexts.// Every modifier should use this macro rather than a derived `Default`.r" Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero)."r" This function exists since [`Default::default()`] cannot be used in a `const` context."r" It may be removed once that becomes possible. As the [`Default`] trait is in the"r" prelude, removing this function in the future will not cause any resolution failures for"r" the overwhelming majority of users; only users who use `#![no_implicit_prelude]` will be"r" affected. As such it will not be considered a breaking change."r" Creates a modifier that indicates the value uses the"r" [`Numerical`](Self::Numerical) representation."r" Creates an instance of this type that indicates the value uses the"r" [`Numerical`](MonthRepr::Numerical) representation, is [padded with zeroes](Padding::Zero),"r" and is case-sensitive when parsing."r" Creates a modifier that indicates the value uses the [`Long`](Self::Long) representation."r" Creates a modifier that indicates the value uses the [`Long`](WeekdayRepr::Long)"r" representation and is case-sensitive when parsing. If the representation is changed to a"r" numerical one, the instance defaults to one-based indexing."r" Creates a modifier that indicates that the value uses the [`Iso`](Self::Iso) representation."r" Creates a modifier that indicates that the value is [padded with zeroes](Padding::Zero)"r" and uses the [`Iso`](WeekNumberRepr::Iso) representation."r" Creates a modifier that indicates the value uses the [`Full`](Self::Full) representation."r" Creates a modifier that indicates the value uses the [`Full`](YearRepr::Full)"r" representation, is [padded with zeroes](Padding::Zero), uses the Gregorian calendar as its"r" base, and only includes the year's sign if necessary."r" Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero) and"r" has the 24-hour representation."r" Creates a modifier that indicates the value uses the upper-case representation and is"r" case-sensitive when parsing."r" Creates a modifier that indicates the stringified value contains [one or more"r" digits](Self::OneOrMore)."r" digits](SubsecondDigits::OneOrMore)."r" Creates a modifier that indicates the value only uses a sign for negative values and is"r" [padded with zeroes](Padding::Zero)."r" Creates a modifier that indicates the value is [padded with zeroes](Self::Zero)."r" Creates a modifier that indicates the value represents the [number of seconds](Self::Second)"r" since the Unix epoch."r" Creates a modifier that indicates the value represents the [number of"r" seconds](UnixTimestampPrecision::Second) since the Unix epoch. The sign is not mandatory."r" Creates a modifier used to represent the end of input."//! Various modifiers for components.// endregion date modifiers// endregion time modifiers// endregion offset modifiers/// formatting, the first element of the [`Vec`] is used. An empty [`Vec`] is a no-op when// region: conversions from FormatItem// region: from variants// region: equality//! A format item with owned data.// endregion conversions from FormatItem// endregion from variants// endregion equalitySpannedValueUnused/// A literal string, formatted and parsed as-is./// This should never be present inside a nested format description._first/// The first bracket._second/// The second bracket.EscapedBracket/// A sequence of brackets. The first acts as the escape character./// This should never be present if the lexer has `BACKSLASH_ESCAPE` set to `true`._opening_bracket/// Where the opening bracket was in the format string._leading_whitespace/// Whitespace between the opening bracket and name./// The name of the component./// The modifiers for the component._trailing_whitespace/// Whitespace between the modifiers and closing bracket._closing_bracket/// Where the closing bracket was in the format string./// Part of a type, along with its modifiers.opening_bracket/// Whitespace between the opening bracket and "optional"._optional_kw/// The "optional" keyword._whitespace/// Whitespace between the "optional" keyword and the opening bracket.nested_format_descriptionNestedFormatDescription/// The items within the optional sequence.closing_bracket/// An optional sequence of items./// Whitespace between the opening bracket and "first"._first_kw/// The "first" keyword./// Whitespace between the "first" keyword and the opening bracket.nested_format_descriptions/// The sequences of items to try./// The first matching parse of a sequence of items./// One part of a complete format description./// The items within the nested format description./// Whitespace between the closing bracket and the next item./// A format description that is nested within another format description./// Whitespace preceding the modifier./// The key of the modifier._colon/// Where the colon of the modifier was in the format string./// The value of the modifier./// A modifier for a component.Lexed/// Parse the provided tokens into an AST.NESTED/// Parse the provided tokens into an AST. The const generic indicates whether the resulting/// [`Item`] will be used directly or as part of a [`NestedFormatDescription`].parse_component/// Parse a component. This assumes that the opening bracket has already been consumed./// Parse a nested format description. The location provided is the the most recent one consumed.//! AST for parsing format descriptions./// Parse an AST iterator into a sequence of format items./// A literal string./// The items themselves./// The span of the full sequence./// A sequence of optional items./// The sequence of format descriptions./// The first matching parse of a sequence of format descriptions./// A description of how to format and parse one part of a type./// Parse an AST item into a format item.component_definition/// Declare the `Component` struct.HourBaseMonthCaseSensitivesign_behaviorSignBehaviorPeriodCasePeriodCaseSensitiveWeekdayOneIndexedWeekdayCaseSensitiveYearBaser" Parse the component from the AST, given its modifiers."with_modifiersr" Parse a component from the AST, given its name and modifiers."component_from_ast// Keep in alphabetical order.target_ty/// Get the target type for a given enum.target_value/// Get the target value for a given enum./// Declare the various modifiers./// For the general case, ordinary syntax can be used. Note that you _must_ declare a default/// variant. The only significant change is that the string representation of the variant must be/// provided after the variant name. For example, `Numerical = b"numerical"` declares a variant/// named `Numerical` with the string representation `b"numerical"`. This is the value that will be/// used when parsing the modifier. The value is not case sensitive./// If the type in the public API does not have the same name as the type in the internal/// representation, then the former must be specified in parenthesis after the internal name. For/// example, `HourBase(bool)` has an internal name "HourBase", but is represented as a boolean in/// By default, the internal variant name is assumed to be the same as the public variant name. If/// this is not the case, the qualified path to the variant must be specified in parenthesis after/// the internal variant name. For example, `Twelve(true)` has an internal variant name "Twelve",/// but is represented as `true` in the public API.TwelveTwentyFourr" Parse the modifier from its string representation."from_modifier_valueparse_from_modifier_value/// Parse a modifier value using `FromStr`. Requires the modifier value to be valid UTF-8.//! Typed, validated representation of a parsed format description./// The internal iterator./// An iterator over the lexed tokens./// Peek at the next item in the iterator.next_if_whitespace'token/// Consume the next token if it is whitespace.next_if_not_whitespace/// Consume the next token if it is a component item that is not whitespace.next_if_opening_bracket/// Consume the next token if it is an opening bracket.peek_closing_bracket/// Peek at the next token if it is a closing bracket.next_if_closing_bracket/// Consume the next token if it is a closing bracket.BracketKind/// Whether the bracket is opening or closing./// Where the bracket was in the format string./// An opening or closing bracket. May or may not be the start or end of a component.ComponentKind/// Whether the part is whitespace or not./// The part itself.ComponentPart/// One part of a component. This could be its name, a modifier, or whitespace./// A token emitted by the lexer. There is no semantic meaning at this stage.Opening/// An opening bracket: `[`Closing/// A closing bracket: `]`/// What type of bracket is present.NotWhitespace/// Indicates whether the component is whitespace or not.attach_location/// Attach [`Location`] information to each byte in the iterator./// Parse the string into a series of [`Token`]s./// `VERSION` controls the version of the format description that is being parsed. Currently, this/// must be 1 or 2./// - When `VERSION` is 1, `[[` is the only escape sequence, resulting in a literal `[`./// - When `VERSION` is 2, all escape sequences begin with `\`. The only characters that may///   currently follow are `\`, `[`, and `]`, all of which result in the literal character. All///   other characters result in a lex error.//! Lexer for parsing format descriptions./// A helper macro to make version restrictions simpler to read and write./// A helper macro to statically validate the version (when used as a const parameter)./// A struct that is used to ensure that the version is valid.IS_VALID/// A constant that panics if the version is not valid. This results in a post-monomorphization/// Parse a sequence of items from the format description./// The syntax for the format description can be found in [the/// book](https://time-rs.github.io/book/api/format-description.html)./// This function exists for backward compatibility reasons. It is equivalent to calling/// `parse_borrowed::<1>(s)`. In the future, this function will be deprecated in favor of/// `parse_borrowed`./// book](https://time-rs.github.io/book/api/format-description.html). The version of the format/// description is provided as the const parameter. **It is recommended to use version 2.**/// description is provided as the const parameter./// Unlike [`parse`], this function returns [`OwnedFormatItem`], which owns its contents. This means/// that there is no lifetime that needs to be handled. **It is recommended to use version 2.**/// [`OwnedFormatItem`]: crate::format_description::OwnedFormatItem/// The zero-indexed byte of the string./// A location within a string./// Create a new [`Span`] from `self` to `other`."this does not modify the original value"/// Offset the location by the provided amount./// Note that this assumes the resulting location is on the same line as the original location./// Create an error with the provided message at this location./// A start and end point within a string.shrink_to_start/// Obtain a `Span` pointing at the start of the pre-existing span.shrink_to_end/// Obtain a `Span` pointing at the end of the pre-existing span.shrink_to_before/// Obtain a `Span` that ends before the provided position of the pre-existing span.shrink_to_after/// Obtain a `Span` that starts after provided position to the end of the pre-existing span./// Create an error with the provided message at this span./// Where the value was in the format string./// A value with an associated [`Span`]./// Attach a [`Span`] to a value./// Helper trait to attach a [`Span`] to a value./// The message displayed to the user./// Where the error originated./// The internal error type./// The internal error./// The error needed for interoperability with the rest of `time`./// A complete error description./// A value that may be used in the future, but currently is not./// This struct exists so that data can semantically be passed around without _actually_ passing it/// around. This way the data still exists if it is needed in the future.// `PhantomData` is not used directly because we don't want to introduce any trait implementations./// Indicate that a value is currently unused.//! Parser for format descriptions.DateKindFormattedComponentsFCTimePrecisionDoNotRelyOnWhatThisIs// This provides a way to include `EncodedConfig` in documentation without displaying the type it is// aliased to.EncodedConfig/// An encoded [`Config`] that can be used as a const parameter to [`Iso8601`](super::Iso8601)./// The type this is aliased to must not be relied upon. It can change in any release without/// notice.CONFIG/// The user-provided configuration for the ISO 8601 format.FORMAT_DATE/// Whether the date should be formatted.FORMAT_TIME/// Whether the time should be formatted.FORMAT_OFFSET/// Whether the UTC offset should be formatted.YEAR_IS_SIX_DIGITS/// Whether the year is six digits.USE_SEPARATORS/// Whether the format contains separators (such as `-` or `:`).DATE_KIND/// Which format to use for the date.TIME_PRECISION/// The precision and number of decimal digits to use for the time.OFFSET_PRECISION/// The precision for the UTC offset./// Encode the configuration, permitting it to be used as a const parameter of [`Iso8601`]./// The value returned by this method must only be used as a const parameter to [`Iso8601`]. Any/// other usage is unspecified behavior./// Decode the configuration. The configuration must have been generated from/// [`Config::encode`].encoding_roundtripassert_decode_faildecode_fail//! Hackery to work around not being able to use ADTs in const generics on stable.adt_hack/// The format described in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html)./// This implementation is of ISO 8601-1:2019. It may not be compatible with other versions./// The const parameter `CONFIG` **must** be a value that was returned by [`Config::encode`]./// Passing any other value is **unspecified behavior**./// Example: 1997-11-21T09:55:06.000000000-06:00/// # use time::format_description::well_known::Iso8601;/// # use time_macros::datetime;///     datetime!(1997-11-12 9:55:06 -6:00).format(&Iso8601::DEFAULT)?,///     "1997-11-12T09:55:06.000000000-06:00"define_assoc_consts/// Define associated constants for `Iso8601`.r" An [`Iso8601`] with the default configuration."r" The following is the default behavior:"r" - The configuration can be used for both formatting and parsing."r" - The date, time, and UTC offset are all formatted."r" - Separators (such as `-` and `:`) are included."r" - The year contains four digits, such that the year must be between 0 and 9999."r" - The date uses the calendar format."r" - The time has precision to the second and nine decimal digits."r" - The UTC offset has precision to the minute."r" If you need different behavior, use another associated constant. For full customization, use"r" [`Config::DEFAULT`] and [`Config`]'s methods to create a custom configuration."PARSINGr" An [`Iso8601`] that can only be used for parsing. Using this to format a value is"r" unspecified behavior."r" An [`Iso8601`] that handles only the date, but is otherwise the same as [`Config::DEFAULT`]."r" An [`Iso8601`] that handles only the time, but is otherwise the same as [`Config::DEFAULT`]."r" An [`Iso8601`] that handles only the UTC offset, but is otherwise the same as"r" [`Config::DEFAULT`]."DATE_TIMEr" An [`Iso8601`] that handles the date and time, but is otherwise the same as"DATE_TIME_OFFSETr" An [`Iso8601`] that handles the date, time, and UTC offset. This is the same as"TIME_OFFSETr" An [`Iso8601`] that handles the time and UTC offset, but is otherwise the same as"/// The configuration can only be used for parsing. Using this to format a value is/// unspecified behavior./// Format only the date./// Format only the time./// Format only the UTC offset./// Format the date and time.DateTimeOffset/// Format the date, time, and UTC offset.TimeOffset/// Format the time and UTC offset./// Which components to format./// Use the year-month-day format.Week/// Use the year-week-weekday format./// Use the week-ordinal format.decimal_digits/// Format the hour only. Minutes, seconds, and nanoseconds will be represented with the/// specified number of decimal digits, if any./// Format the hour and minute. Seconds and nanoseconds will be represented with the specified/// number of decimal digits, if any./// Format the hour, minute, and second. Nanoseconds will be represented with the specified/// The precision and number of decimal digits present for the time./// Format only the offset hour. Requires the offset minute to be zero./// Format both the offset hour and minute.formatted_components/// Which components, if any, will be formatted.use_separatorsyear_is_six_digitsdate_kind/// The format used for the date.time_precisionoffset_precision/// Configuration for [`Iso8601`].// This is only used as a const generic, so there's no need to have a number of implementations on// People will likely search for `EncodedConfig`, so show them this./// A configuration for the [`Iso8601`] format./// The following is the default behavior:/// - The configuration can be used for both formatting and parsing./// - The date, time, and UTC offset are all formatted./// - Separators (such as `-` and `:`) are included./// - The year contains four digits, such that the year must be between 0 and 9999./// - The date uses the calendar format./// - The time has precision to the second and nine decimal digits./// - The UTC offset has precision to the minute./// If you need different behavior, use the setter methods on this struct./// A configuration that can only be used for parsing. Using this to format a value isset_formatted_components/// Set whether the format the date, time, and/or UTC offset.set_use_separators/// Set whether the format contains separators (such as `-` or `:`).set_year_is_six_digits/// Set whether the year is six digits.set_date_kind/// Set the format used for the date.set_time_precision/// Set the precision and number of decimal digits present for the time.set_offset_precision/// Set the precision for the UTC offset.//! The format described in ISO 8601./// The format described in [RFC 2822](https://tools.ietf.org/html/rfc2822#section-3.3)./// Example: Fri, 21 Nov 1997 09:55:06 -0600/// # use time::{format_description::well_known::Rfc2822, OffsetDateTime};/// use time_macros::datetime;///     OffsetDateTime::parse("Sat, 12 Jun 1993 13:25:19 GMT", &Rfc2822)?,///     datetime!(1993-06-12 13:25:19 +00:00)/// # use time::format_description::well_known::Rfc2822;///     datetime!(1997-11-21 09:55:06 -06:00).format(&Rfc2822)?,///     "Fri, 21 Nov 1997 09:55:06 -0600"//! The format described in RFC 2822./// The format described in [RFC 3339](https://tools.ietf.org/html/rfc3339#section-5.6)./// Format example: 1985-04-12T23:20:50.52Z/// # use time::{format_description::well_known::Rfc3339, OffsetDateTime};///     OffsetDateTime::parse("1985-04-12T23:20:50.52Z", &Rfc3339)?,///     datetime!(1985-04-12 23:20:50.52 +00:00)/// # use time::format_description::well_known::Rfc3339;///     datetime!(1985-04-12 23:20:50.52 +00:00).format(&Rfc3339)?,///     "1985-04-12T23:20:50.52Z"//! The format described in RFC 3339.format_componentformat_number_pad_zeroMONTH_NAMESWEEKDAY_NAMES/// A type that describes a format./// Implementors of [`Formattable`] are [format descriptions](crate::format_description)./// [`Date::format`] and [`Time::format`] each use a format description to generate/// a String from their data. See the respective methods for usage examples./// Format the item into the provided output, returning the number of bytes written./// Format the item directly to a `String`./// Format the item using a format description, the intended output, and the various components./// Seal the trait to prevent downstream users from implementing it.// region: custom formats// region: well-known formats//! A trait that can be used to format an item from its components.// endregion custom formats// endregion well-known formatsformat_floatwrite_ifwrite_if_elseformat_date/// Format the date portion of ISO 8601.format_time/// Format the time portion of ISO 8601.format_offset/// Format the UTC offset portion of ISO 8601.//! Helpers for implementing formatting for ISO 8601.formattable/// Write all bytes to the output, returning the number of bytes written./// If `pred` is true, write all bytes to the output, returning the number of bytes written./// If `pred` is true, write `true_bytes` to the output. Otherwise, write `false_bytes`./// Write the floating point number to the output, returning the number of bytes written./// This method accepts the number of digits before and after the decimal. The value will be padded/// with zeroes to the left if necessary.format_number/// Format a number with the provided padding and width./// The sign must be written by the caller.format_number_pad_space/// Format a number with the provided width and spaces as padding./// Format a number with the provided width and zeros as padding.format_number_pad_none/// Format a number with no padding./// If the sign is mandatory, the sign must be written by the caller./// Format the provided component into the designated output. An `Err` will be returned if the/// component requires information that it does not provide or if the value cannot be output to thefmt_day// region: date formatters/// Format the day into the designated output.fmt_month/// Format the month into the designated output.fmt_ordinal/// Format the ordinal into the designated output.fmt_weekday/// Format the weekday into the designated output.fmt_week_number/// Format the week number into the designated output.fmt_year/// Format the year into the designated output.fmt_hour// region: time formatters/// Format the hour into the designated output.fmt_minute/// Format the minute into the designated output.fmt_period/// Format the period into the designated output.fmt_second/// Format the second into the designated output.fmt_subsecond/// Format the subsecond into the designated output.fmt_offset_hour// region: offset formatters/// Format the offset hour into the designated output.fmt_offset_minute/// Format the offset minute into the designated output.fmt_offset_second/// Format the offset second into the designated output.fmt_unix_timestamp/// Format the Unix timestamp into the designated output.//! Formatting for various types.// endregion date formatters// endregion time formatters// endregion offset formatters/// A measurement of a monotonically non-decreasing clock. Opaque and useful only with [`Duration`]./// Instants are always guaranteed to be no less than any previously measured instant when created,/// and are often useful for tasks such as measuring benchmarks or timing how long an operation/// takes./// Note, however, that instants are not guaranteed to be **steady**. In other words, each tick of/// the underlying clock may not be the same length (e.g. some seconds may be longer than others)./// An instant may jump forwards or experience time dilation (slow down or speed up), but it will/// never go backwards./// Instants are opaque types that can only be compared to one another. There is no method to get/// "the number of seconds" from an instant. Instead, it only allows measuring the duration between/// two instants (or comparing two instants)./// This implementation allows for operations with signed [`Duration`]s, but is otherwise identical/// to [`std::time::Instant`].// region: delegation/// Returns an `Instant` corresponding to "now"./// # use time::Instant;/// println!("{:?}", Instant::now());/// Returns the amount of time elapsed since this instant was created. The duration will always/// be nonnegative if the instant is not synthetically created./// # use time::{Instant, ext::{NumericalStdDuration, NumericalDuration}};/// let instant = Instant::now();/// thread::sleep(1.std_milliseconds());/// assert!(instant.elapsed() >= 1.milliseconds());/// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as/// `Instant` (which means it's inside the bounds of the underlying data structure), `None`/// # use time::{Instant, ext::NumericalDuration};/// assert_eq!(now.checked_add(5.seconds()), Some(now + 5.seconds()));/// assert_eq!(now.checked_add((-5).seconds()), Some(now + (-5).seconds()));/// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as/// assert_eq!(now.checked_sub(5.seconds()), Some(now - 5.seconds()));/// assert_eq!(now.checked_sub((-5).seconds()), Some(now - (-5).seconds()));/// Obtain the inner [`std::time::Instant`]./// assert_eq!(now.into_inner(), now.0);// endregion delegation/// underlying data structure.//! The [`Instant`] struct and its associated `impl`s./// Helper macro for easily implementing `OpAssign`./// Implement `AddAssign` for the provided types./// Implement `SubAssign` for the provided types./// Implement `MulAssign` for the provided types./// Implement `DivAssign` for the provided types./// Division of integers, rounding the resulting value towards negative infinity.// Cascade an out-of-bounds value from "from" to "to".// Special case the ordinal-to-year cascade, as it has different behavior./// Cascade an out-of-bounds value./// Constructs a ranged integer, returning a `ComponentRange` error if the value is out of range./// Try to unwrap an expression, returning if not possible./// This is similar to the `?` operator, but does not perform `.into()`. Because of this, it is/// usable in `const` contexts./// This is similar to the `?` operator, but is usable in `const` contexts./// Try to unwrap an expression, panicking if not possible./// This is similar to `$e.expect($message)`, but is usable in `const` contexts./// `unreachable!()`, but better.//! Macros for use within the library. They are not publicly available.offset_date_timeprimitive_date_time/// An alias for [`std::result::Result`] with a generic error from the time crate.expect_failed/// This is a separate function to reduce the code size of `expect_opt!`.//! This crate exposes a number of features. These can be enabled or disabled as shown//! [in Cargo's documentation](https://doc.rust-lang.org/cargo/reference/features.html). Features//! are _disabled_ by default unless otherwise noted.//! Reliance on a given feature is always indicated alongside the item definition.//! - `std` (_enabled by default, implicitly enables `alloc`_)//!   This enables a number of features that depend on the standard library.//! - `alloc` (_enabled by default via `std`_)//!   Enables a number of features that require the ability to dynamically allocate memory.//! - `macros`//!   Enables macros that provide compile-time verification of values and intuitive syntax.//! - `formatting` (_implicitly enables `std`_)//!   Enables formatting of most structs.//! - `parsing`//!   Enables parsing of most structs.//! - `local-offset` (_implicitly enables `std`_)//!   This feature enables a number of methods that allow obtaining the system's UTC offset.//! - `large-dates`//!   By default, only years within the ±9999 range (inclusive) are supported. If you need support//!   for years outside this range, consider enabling this feature; the supported range will be//!   increased to ±999,999.//!   Note that enabling this feature has some costs, as it means forgoing some optimizations.//!   Ambiguities may be introduced when parsing that would not otherwise exist.//!   Enables [serde](https://docs.rs/serde) support for all types except [`Instant`].//! - `serde-human-readable` (_implicitly enables `serde`, `formatting`, and `parsing`_)//!   Allows serde representations to use a human-readable format. This is determined by the//!   serializer, not the user. If this feature is not enabled or if the serializer requests a//!   non-human-readable format, a format optimized for binary representation will be used.//!   Libraries should never enable this feature, as the decision of what format to use should be up//!   to the user.//! - `rand`//!   Enables [rand](https://docs.rs/rand) support for all types.//! - `quickcheck` (_implicitly enables `alloc`_)//!   Enables [quickcheck](https://docs.rs/quickcheck) support for all types except [`Instant`].//! - `wasm-bindgen`//!   Enables [wasm-bindgen](https://github.com/rustwasm/wasm-bindgen) support for converting//!   [JavaScript dates](https://rustwasm.github.io/wasm-bindgen/api/js_sys/struct.Date.html), as//!   well as obtaining the UTC offset from JavaScript./// Construct a [`Date`](crate::Date) with a statically known value./// The resulting expression can be used in `const` or `static` declarations./// Three formats are supported: year-week-weekday, year-ordinal, and year-month-day./// # use time::{Date, Weekday::*, Month, macros::date};///     date!(2020 - W 01 - 3),///     Date::from_iso_week_date(2020, 1, Wednesday)?/// assert_eq!(date!(2020 - 001), Date::from_ordinal_date(2020, 1)?);///     date!(2020 - 01 - 01),///     Date::from_calendar_date(2020, Month::January, 1)?/// Construct a [`PrimitiveDateTime`] or [`OffsetDateTime`] with a statically known value./// The syntax accepted by this macro is the same as [`date!`] and [`time!`], with an optional/// [`offset!`], all space-separated. If an [`offset!`] is provided, the resulting value will/// be an [`OffsetDateTime`]; otherwise it will be a [`PrimitiveDateTime`]./// [`OffsetDateTime`]: crate::OffsetDateTime/// [`PrimitiveDateTime`]: crate::PrimitiveDateTime/// # use time::{Date, Month, macros::datetime, UtcOffset};///     datetime!(2020-01-01 0:00),///     Date::from_calendar_date(2020, Month::January, 1)?.midnight()///     datetime!(2020-01-01 0:00 UTC),///     Date::from_calendar_date(2020, Month::January, 1)?.midnight().assume_utc()///     datetime!(2020-01-01 0:00 -1),///         .assume_offset(UtcOffset::from_hms(-1, 0, 0)?)/// Equivalent of performing [`format_description::parse()`] at compile time./// Using the macro instead of the function results in a static slice rather than a/// [`Vec`](alloc::vec::Vec), such that it can be used in `#![no_alloc]` situations./// The resulting expression can be used in `const` or `static` declarations, and implements/// the sealed traits required for both formatting and parsing./// # use time::{format_description, macros::format_description};///     format_description!("[hour]:[minute]:[second]"),///     format_description::parse("[hour]:[minute]:[second]")?/// The syntax accepted by this macro is the same as [`format_description::parse()`], which can/// be found in [the book](https://time-rs.github.io/book/api/format-description.html)./// [`format_description::parse()`]: crate::format_description::parse()/// Construct a [`UtcOffset`](crate::UtcOffset) with a statically known value./// A sign and the hour must be provided; minutes and seconds default to zero. `UTC` (both/// uppercase and lowercase) is also allowed./// # use time::{UtcOffset, macros::offset};/// assert_eq!(offset!(UTC), UtcOffset::from_hms(0, 0, 0)?);/// assert_eq!(offset!(utc), UtcOffset::from_hms(0, 0, 0)?);/// assert_eq!(offset!(+0), UtcOffset::from_hms(0, 0, 0)?);/// assert_eq!(offset!(+1), UtcOffset::from_hms(1, 0, 0)?);/// assert_eq!(offset!(-1), UtcOffset::from_hms(-1, 0, 0)?);/// assert_eq!(offset!(+1:30), UtcOffset::from_hms(1, 30, 0)?);/// assert_eq!(offset!(-1:30), UtcOffset::from_hms(-1, -30, 0)?);/// assert_eq!(offset!(+1:30:59), UtcOffset::from_hms(1, 30, 59)?);/// assert_eq!(offset!(-1:30:59), UtcOffset::from_hms(-1, -30, -59)?);/// assert_eq!(offset!(+23:59:59), UtcOffset::from_hms(23, 59, 59)?);/// assert_eq!(offset!(-23:59:59), UtcOffset::from_hms(-23, -59, -59)?);/// Construct a [`Time`](crate::Time) with a statically known value./// Hours and minutes must be provided, while seconds defaults to zero. AM/PM is allowed/// (either uppercase or lowercase). Any number of subsecond digits may be provided (though any/// past nine will be discarded)./// All components are validated at compile-time. An error will be raised if any value is/// # use time::{Time, macros::time};/// assert_eq!(time!(0:00), Time::from_hms(0, 0, 0)?);/// assert_eq!(time!(1:02:03), Time::from_hms(1, 2, 3)?);///     time!(1:02:03.004_005_006),///     Time::from_hms_nano(1, 2, 3, 4_005_006)?/// assert_eq!(time!(12:00 am), Time::from_hms(0, 0, 0)?);/// assert_eq!(time!(1:02:03 am), Time::from_hms(1, 2, 3)?);///     time!(1:02:03.004_005_006 am),/// assert_eq!(time!(12 pm), Time::from_hms(12, 0, 0)?);/// assert_eq!(time!(12:00 pm), Time::from_hms(12, 0, 0)?);/// assert_eq!(time!(1:02:03 pm), Time::from_hms(13, 2, 3)?);///     time!(1:02:03.004_005_006 pm),///     Time::from_hms_nano(13, 2, 3, 4_005_006)?//! Macros to construct statically known values./// Months of the year./// Create a `Month` from its numerical value./// Get the previous month./// assert_eq!(Month::January.previous(), Month::December);/// Get the next month./// assert_eq!(Month::January.next(), Month::February);nth_next/// Get n-th next month./// assert_eq!(Month::January.nth_next(4), Month::May);/// assert_eq!(Month::July.nth_next(9), Month::April);nth_prev/// Get n-th previous month./// assert_eq!(Month::January.nth_prev(4), Month::September);/// assert_eq!(Month::July.nth_prev(9), Month::October);MonthMetadata//! The `Month` enum and its associated `impl`s.UNIX_EPOCH_JULIAN_DAY/// The Julian day of the Unix epoch.local_date_time/// A [`PrimitiveDateTime`] with a [`UtcOffset`]./// All comparisons are performed using the UTC time./// Midnight, 1 January, 1970 (UTC)./// # use time::OffsetDateTime;/// assert_eq!(OffsetDateTime::UNIX_EPOCH, datetime!(1970-01-01 0:00 UTC),);// region: now/// Create a new `OffsetDateTime` with the current date and time in UTC./// # use time_macros::offset;/// assert!(OffsetDateTime::now_utc().year() >= 2019);/// assert_eq!(OffsetDateTime::now_utc().offset(), offset!(UTC));/// Attempt to create a new `OffsetDateTime` with the current date and time in the local offset./// If the offset cannot be determined, an error is returned./// assert!(OffsetDateTime::now_local().is_ok());new_in_offset/// Create a new `OffsetDateTime` with the given [`Date`], [`Time`], and [`UtcOffset`]./// # use time::{Date, Month, OffsetDateTime, Time, UtcOffset};/// let dt = OffsetDateTime::new_in_offset(///     Date::from_calendar_date(2024, Month::January, 1)?,///     Time::from_hms_nano(12, 59, 59, 500_000_000)?,///     UtcOffset::from_hms(-5, 0, 0)?,/// assert_eq!(dt, datetime!(2024-01-01 12:59:59.5 -5));/// # Ok::<_, time::error::Error>(())/// Create a new `OffsetDateTime` with the given [`Date`] and [`Time`] in the UTC timezone./// # use time::{Date, Month, OffsetDateTime, Time};/// let dt = OffsetDateTime::new_utc(/// assert_eq!(dt, datetime!(2024-01-01 12:59:59.5 UTC));to_offset/// Convert the `OffsetDateTime` from the current [`UtcOffset`] to the provided [`UtcOffset`]./// # use time_macros::{datetime, offset};///     datetime!(2000-01-01 0:00 UTC)///         .to_offset(offset!(-1))///         .year(),///     1999,/// // Let's see what time Sydney's new year's celebration is in New York and Los Angeles./// // Construct midnight on new year's in Sydney./// let sydney = datetime!(2000-01-01 0:00 +11);/// let new_york = sydney.to_offset(offset!(-5));/// let los_angeles = sydney.to_offset(offset!(-8));/// assert_eq!(sydney.hour(), 0);/// assert_eq!(new_york.hour(), 8);/// assert_eq!(los_angeles.hour(), 5);/// This method panics if the local date-time in the new offset is outside the supported range.checked_to_offset/// Convert the `OffsetDateTime` from the current [`UtcOffset`] to the provided [`UtcOffset`],/// returning `None` if the date-time in the resulting offset is invalid./// # use time::PrimitiveDateTime;///         .checked_to_offset(offset!(-1))///     PrimitiveDateTime::MAX///         .assume_utc()///         .checked_to_offset(offset!(+1)),to_offset_raw/// Equivalent to `.to_offset(UtcOffset::UTC)`, but returning the year, ordinal, and time. This/// avoids constructing an invalid [`Date`] if the new value is out of range.from_unix_timestamp/// Create an `OffsetDateTime` from the provided Unix timestamp. Calling `.offset()` on the/// resulting value is guaranteed to return UTC.///     OffsetDateTime::from_unix_timestamp(0),///     Ok(OffsetDateTime::UNIX_EPOCH),///     OffsetDateTime::from_unix_timestamp(1_546_300_800),///     Ok(datetime!(2019-01-01 0:00 UTC)),/// If you have a timestamp-nanosecond pair, you can use something along the lines of the/// # use time::{Duration, OffsetDateTime, ext::NumericalDuration};/// let (timestamp, nanos) = (1, 500_000_000);///     OffsetDateTime::from_unix_timestamp(timestamp)? + Duration::nanoseconds(nanos),///     OffsetDateTime::UNIX_EPOCH + 1.5.seconds()from_unix_timestamp_nanos/// Construct an `OffsetDateTime` from the provided Unix timestamp (in nanoseconds). Calling/// `.offset()` on the resulting value is guaranteed to return UTC.///     OffsetDateTime::from_unix_timestamp_nanos(0),///     OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000),/// Get the [`UtcOffset`]./// assert_eq!(datetime!(2019-01-01 0:00 UTC).offset(), offset!(UTC));/// assert_eq!(datetime!(2019-01-01 0:00 +1).offset(), offset!(+1));unix_timestamp/// Get the [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time)./// assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp(), 0);/// assert_eq!(datetime!(1970-01-01 0:00 -1).unix_timestamp(), 3_600);unix_timestamp_nanos/// Get the Unix timestamp in nanoseconds./// assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp_nanos(), 0);///     datetime!(1970-01-01 0:00 -1).unix_timestamp_nanos(),///     3_600_000_000_000,/// Get the [`PrimitiveDateTime`] in the stored offset./// Get the [`Date`] in the stored offset./// # use time_macros::{date, datetime, offset};/// assert_eq!(datetime!(2019-01-01 0:00 UTC).date(), date!(2019-01-01));///     datetime!(2019-01-01 0:00 UTC)///         .date(),///     date!(2018-12-31),/// Get the [`Time`] in the stored offset./// # use time_macros::{datetime, offset, time};/// assert_eq!(datetime!(2019-01-01 0:00 UTC).time(), time!(0:00));///         .time(),///     time!(23:00)// region: date getters/// Get the year of the date in the stored offset./// assert_eq!(datetime!(2019-01-01 0:00 UTC).year(), 2019);///     datetime!(2019-12-31 23:00 UTC)///         .to_offset(offset!(+1))///     2020,/// assert_eq!(datetime!(2020-01-01 0:00 UTC).year(), 2020);/// Get the month of the date in the stored offset./// assert_eq!(datetime!(2019-01-01 0:00 UTC).month(), Month::January);///         .month(),///     Month::January,/// Get the day of the date in the stored offset./// assert_eq!(datetime!(2019-01-01 0:00 UTC).day(), 1);///         .day(),///     1,/// Get the day of the year of the date in the stored offset./// The returned value will always be in the range `1..=366`./// assert_eq!(datetime!(2019-01-01 0:00 UTC).ordinal(), 1);///         .ordinal(),/// Get the ISO week number of the date in the stored offset./// assert_eq!(datetime!(2019-01-01 0:00 UTC).iso_week(), 1);/// assert_eq!(datetime!(2020-01-01 0:00 UTC).iso_week(), 1);/// assert_eq!(datetime!(2020-12-31 0:00 UTC).iso_week(), 53);/// assert_eq!(datetime!(2021-01-01 0:00 UTC).iso_week(), 53);/// assert_eq!(datetime!(2019-01-01 0:00 UTC).sunday_based_week(), 0);/// assert_eq!(datetime!(2020-01-01 0:00 UTC).sunday_based_week(), 0);/// assert_eq!(datetime!(2020-12-31 0:00 UTC).sunday_based_week(), 52);/// assert_eq!(datetime!(2021-01-01 0:00 UTC).sunday_based_week(), 0);/// assert_eq!(datetime!(2019-01-01 0:00 UTC).monday_based_week(), 0);/// assert_eq!(datetime!(2020-01-01 0:00 UTC).monday_based_week(), 0);/// assert_eq!(datetime!(2020-12-31 0:00 UTC).monday_based_week(), 52);/// assert_eq!(datetime!(2021-01-01 0:00 UTC).monday_based_week(), 0);///     datetime!(2019-01-01 0:00 UTC).to_calendar_date(),///     datetime!(2019-01-01 0:00 UTC).to_ordinal_date(),///     (2019, 1)///     datetime!(2019-01-01 0:00 UTC).to_iso_week_date(),///     (2019, 1, Tuesday)///     datetime!(2019-10-04 0:00 UTC).to_iso_week_date(),///     (2019, 40, Friday)///     datetime!(2020-01-01 0:00 UTC).to_iso_week_date(),///     datetime!(2020-12-31 0:00 UTC).to_iso_week_date(),///     datetime!(2021-01-01 0:00 UTC).to_iso_week_date(),///     (2020, 53, Friday)/// Get the weekday of the date in the stored offset./// assert_eq!(datetime!(2019-01-01 0:00 UTC).weekday(), Tuesday);/// assert_eq!(datetime!(2019-02-01 0:00 UTC).weekday(), Friday);/// assert_eq!(datetime!(2019-03-01 0:00 UTC).weekday(), Friday);/// Get the Julian day for the date. The time is not taken into account for this calculation./// assert_eq!(datetime!(-4713-11-24 0:00 UTC).to_julian_day(), 0);/// assert_eq!(datetime!(2000-01-01 0:00 UTC).to_julian_day(), 2_451_545);/// assert_eq!(datetime!(2019-01-01 0:00 UTC).to_julian_day(), 2_458_485);/// assert_eq!(datetime!(2019-12-31 0:00 UTC).to_julian_day(), 2_458_849);to_hms// region: time getters/// Get the clock hour, minute, and second./// assert_eq!(datetime!(2020-01-01 0:00:00 UTC).to_hms(), (0, 0, 0));/// assert_eq!(datetime!(2020-01-01 23:59:59 UTC).to_hms(), (23, 59, 59));to_hms_milli/// Get the clock hour, minute, second, and millisecond.///     datetime!(2020-01-01 0:00:00 UTC).to_hms_milli(),///     (0, 0, 0, 0)///     datetime!(2020-01-01 23:59:59.999 UTC).to_hms_milli(),///     (23, 59, 59, 999)to_hms_micro/// Get the clock hour, minute, second, and microsecond.///     datetime!(2020-01-01 0:00:00 UTC).to_hms_micro(),///     datetime!(2020-01-01 23:59:59.999_999 UTC).to_hms_micro(),///     (23, 59, 59, 999_999)to_hms_nano/// Get the clock hour, minute, second, and nanosecond.///     datetime!(2020-01-01 0:00:00 UTC).to_hms_nano(),///     datetime!(2020-01-01 23:59:59.999_999_999 UTC).to_hms_nano(),///     (23, 59, 59, 999_999_999)/// Get the clock hour in the stored offset./// The returned value will always be in the range `0..24`./// assert_eq!(datetime!(2019-01-01 0:00 UTC).hour(), 0);///     datetime!(2019-01-01 23:59:59 UTC)///         .to_offset(offset!(-2))///         .hour(),///     21,/// Get the minute within the hour in the stored offset./// The returned value will always be in the range `0..60`./// assert_eq!(datetime!(2019-01-01 0:00 UTC).minute(), 0);///         .to_offset(offset!(+0:30))///         .minute(),///     29,/// Get the second within the minute in the stored offset./// assert_eq!(datetime!(2019-01-01 0:00 UTC).second(), 0);///         .to_offset(offset!(+0:00:30))///         .second(),/// Get the milliseconds within the second in the stored offset./// The returned value will always be in the range `0..1_000`./// assert_eq!(datetime!(2019-01-01 0:00 UTC).millisecond(), 0);/// assert_eq!(datetime!(2019-01-01 23:59:59.999 UTC).millisecond(), 999);/// Get the microseconds within the second in the stored offset./// The returned value will always be in the range `0..1_000_000`./// assert_eq!(datetime!(2019-01-01 0:00 UTC).microsecond(), 0);///     datetime!(2019-01-01 23:59:59.999_999 UTC).microsecond(),///     999_999,/// Get the nanoseconds within the second in the stored offset./// The returned value will always be in the range `0..1_000_000_000`./// assert_eq!(datetime!(2019-01-01 0:00 UTC).nanosecond(), 0);///     datetime!(2019-01-01 23:59:59.999_999_999 UTC).nanosecond(),///     999_999_999,/// let datetime = Date::MIN.midnight().assume_offset(offset!(+10));/// assert_eq!(datetime.checked_add((-2).days()), None);/// let datetime = Date::MAX.midnight().assume_offset(offset!(+10));/// assert_eq!(datetime.checked_add(2.days()), None);///     datetime!(2019 - 11 - 25 15:30 +10).checked_add(27.hours()),///     Some(datetime!(2019 - 11 - 26 18:30 +10))/// assert_eq!(datetime.checked_sub(2.days()), None);/// assert_eq!(datetime.checked_sub((-2).days()), None);///     datetime!(2019 - 11 - 25 15:30 +10).checked_sub(27.hours()),///     Some(datetime!(2019 - 11 - 24 12:30 +10))///     datetime!(2019 - 11 - 25 15:30 +10).saturating_add(27.hours()),///     datetime!(2019 - 11 - 26 18:30 +10)///     datetime!(2019 - 11 - 25 15:30 +10).saturating_sub(27.hours()),///     datetime!(2019 - 11 - 24 12:30 +10)// endregion now// endregion date getters// Because a `UtcOffset` is limited in resolution to one second, any subsecond value will not// change when adjusting for the offset.// endregion time getters// endregion: saturating arithmetic"This method does not mutate the original `OffsetDateTime`."replace_time/// Replace the time, which is assumed to be in the stored offset. The date and offset/// components are unchanged./// # use time_macros::{datetime, time};///     datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)),///     datetime!(2020-01-01 12:00 UTC)///     datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)),///     datetime!(2020-01-01 7:00 -5)///     datetime!(2020-01-01 0:00 +1).replace_time(time!(12:00)),///     datetime!(2020-01-01 12:00 +1)replace_date/// Replace the date, which is assumed to be in the stored offset. The time and offset/// # use time_macros::{datetime, date};///     datetime!(2020-01-01 12:00 UTC).replace_date(date!(2020-01-30)),///     datetime!(2020-01-30 12:00 UTC)///     datetime!(2020-01-01 0:00 +1).replace_date(date!(2020-01-30)),///     datetime!(2020-01-30 0:00 +1)replace_date_time/// Replace the date and time, which are assumed to be in the stored offset. The offset/// component remains unchanged.///     datetime!(2020-01-01 12:00 UTC).replace_date_time(datetime!(2020-01-30 16:00)),///     datetime!(2020-01-30 16:00 UTC)///     datetime!(2020-01-01 12:00 +1).replace_date_time(datetime!(2020-01-30 0:00)),replace_offset/// Replace the offset. The date and time components remain unchanged.///     datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)),///     datetime!(2020-01-01 0:00 -5)///     datetime!(2022 - 02 - 18 12:00 +01).replace_year(2019),///     Ok(datetime!(2019 - 02 - 18 12:00 +01))/// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year/// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year///     datetime!(2022 - 02 - 18 12:00 +01).replace_month(Month::January),///     Ok(datetime!(2022 - 01 - 18 12:00 +01))/// assert!(datetime!(2022 - 01 - 30 12:00 +01).replace_month(Month::February).is_err()); // 30 isn't a valid day in February///     datetime!(2022 - 02 - 18 12:00 +01).replace_day(1),///     Ok(datetime!(2022 - 02 - 01 12:00 +01))/// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_day(0).is_err()); // 00 isn't a valid day/// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_day(30).is_err()); // 30 isn't a valid day in February/// assert_eq!(datetime!(2022-049 12:00 +01).replace_ordinal(1), Ok(datetime!(2022-001 12:00 +01)));/// assert!(datetime!(2022-049 12:00 +01).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal/// assert!(datetime!(2022-049 12:00 +01).replace_ordinal(366).is_err()); // 2022 isn't a leap yearreplace_hour/// Replace the clock hour.///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_hour(7),///     Ok(datetime!(2022 - 02 - 18 07:02:03.004_005_006 +01))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_hour(24).is_err()); // 24 isn't a valid hourreplace_minute/// Replace the minutes within the hour.///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_minute(7),///     Ok(datetime!(2022 - 02 - 18 01:07:03.004_005_006 +01))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_minute(60).is_err()); // 60 isn't a valid minutereplace_second/// Replace the seconds within the minute.///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_second(7),///     Ok(datetime!(2022 - 02 - 18 01:02:07.004_005_006 +01))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_second(60).is_err()); // 60 isn't a valid secondreplace_millisecond/// Replace the milliseconds within the second.///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_millisecond(7),///     Ok(datetime!(2022 - 02 - 18 01:02:03.007 +01))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecondreplace_microsecond/// Replace the microseconds within the second.///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_microsecond(7_008),///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008 +01))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecondreplace_nanosecond/// Replace the nanoseconds within the second.///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_nanosecond(7_008_009),///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008_009 +01))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond/// Methods that replace part of the `OffsetDateTime`./// Format the `OffsetDateTime` using the provided [format/// # use time::format_description;/// let format = format_description::parse(///     "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \///          sign:mandatory]:[offset_minute]:[offset_second]",///     datetime!(2020-01-02 03:04:05 +06:07:08).format(&format)?,///     "2020-01-02 03:04:05 +06:07:08"/// Parse an `OffsetDateTime` from the input using the provided [format/// # use time_macros::{datetime, format_description};/// let format = format_description!(///          sign:mandatory]:[offset_minute]:[offset_second]"///     OffsetDateTime::parse("2020-01-02 03:04:05 +06:07:08", &format)?,///     datetime!(2020-01-02 03:04:05 +06:07:08)is_valid_leap_second_stand_in/// A helper method to check if the `OffsetDateTime` is a valid representation of a leap second./// Leap seconds, when parsed, are represented as the preceding nanosecond. However, leap/// seconds can only occur as the last second of a month UTC.//! The [`OffsetDateTime`] struct and its associated `impl`s.rfcshimIntegerParseBytesParsedItem/// Parse a "+" or "-" sign. Returns the ASCII byte representing the sign, if present.first_match/// Consume the first matching item, returning its associated value.zero_or_more/// Consume zero or more instances of the provided parser. The parser must return the unit value.one_or_more/// Consume one of or more instances of the provided parser. The parser must produce the unit value.n_to_m/// Consume between `n` and `m` instances of the provided parser.n_to_m_digits/// Consume between `n` and `m` digits, returning the numerical value.exactly_n_digits/// Consume exactly `n` digits, returning the numerical value.exactly_n_digits_paddedn_to_m_digits_paddedany_digit/// Consume exactly one digit./// Consume exactly one of the provided ASCII characters.ascii_char_ignore_case/// Consume exactly one of the provided ASCII characters, case-insensitive./// Optionally consume an input with a given parser.//! Implementations of the low-level parser combinators.ExtendedKind/// The basic format./// The extended format./// ¯\_(ツ)_/¯/// What kind of format is being parsed. This is used to ensure each part of the format (date, time,/// offset) is the same kind.maybe_extended/// Is it possible that the format is extended?/// Is the format known for certain to be extended?coerce_basic/// If the kind is `Unknown`, make it `Basic`. Otherwise, do nothing. Returns `Some` if and only/// if the kind is now `Basic`.coerce_extended/// If the kind is `Unknown`, make it `Extended`. Otherwise, do nothing. Returns `Some` if and/// only if the kind is now `Extended`./// Parse a possibly expanded year./// Parse a month./// Parse a week number./// Parse a day of the month.dayk/// Parse a day of the week.dayo/// Parse a day of the year./// Parse the hour./// Parse the minute./// Parse a floating point number as its integer and optional fractional parts./// The number must have two digits before the decimal point. If a decimal point is present, at/// least one digit must follow./// The return type is a tuple of the integer part and optional fraction part.decimal_sign/// Parse a "decimal sign", which is either a comma or a period.//! Rules defined in [ISO 8601].//! [ISO 8601]: https://www.iso.org/iso-8601-date-and-time-format.htmlrfc2234//! Combinators for rules as defined in a standard.//! When applicable, these rules have been converted strictly following the ABNF syntax as specified//! in [RFC 2234].//! [RFC 2234]: https://datatracker.ietf.org/doc/html/rfc2234wsp/// Consume exactly one space or tab.//! Rules defined in [RFC 2234].fws/// Consume the `fws` rule.// The full rule is equivalent to /\r\n[ \t]+|[ \t]+(?:\r\n[ \t]+)*/cfws/// Consume the `cfws` rule.// The full rule is equivalent to any combination of `fws` and `comment` so long as it is not empty./// Consume the `comment` rule.ccontent/// Consume the `ccontent` rule.ctext/// Consume the `ctext` rule.// rust-lang/rust-clippy#8522quoted_pair/// Consume the `quoted_pair` rule.no_ws_ctl/// Consume the `no_ws_ctl` rule./// Consume the `text` rule.//! Rules defined in [RFC 2822].//! [RFC 2822]: https://datatracker.ietf.org/doc/html/rfc2822parse_year// region: date components/// Parse the "year" component of a `Date`.parse_month/// Parse the "month" component of a `Date`.parse_week_number/// Parse the "week number" component of a `Date`.parse_weekday/// Parse the "weekday" component of a `Date`./// Parse the "ordinal" component of a `Date`.parse_day/// Parse the "day" component of a `Date`.AmPm// region: time components/// Indicate whether the hour is "am" or "pm".parse_hour/// Parse the "hour" component of a `Time`.parse_minute/// Parse the "minute" component of a `Time`.parse_second/// Parse the "second" component of a `Time`.parse_period/// Parse the "period" component of a `Time`. Required if the hour is on a 12-hour clock.parse_subsecond/// Parse the "subsecond" component of a `Time`.parse_offset_hour// region: offset components/// Parse the "hour" component of a `UtcOffset`./// Returns the value and whether the value is negative. This is used for when "-0" is parsed.parse_offset_minute/// Parse the "minute" component of a `UtcOffset`.parse_offset_second/// Parse the "second" component of a `UtcOffset`.parse_ignore/// Ignore the given number of bytes.parse_unix_timestamp/// Parse the Unix timestamp component./// Parse the `end` component, which represents the end of input. If any input is remaining, `None`//! Parsing implementations for all [`Component`](crate::format_description::Component)s.// endregion date components// endregion time components// endregion offset componentsparse_date// Basic: [year][month][day]// Extended: [year]["-"][month]["-"][day]// Basic: [year][dayo]// Extended: [year]["-"][dayo]// Basic: [year]["W"][week][dayk]// Extended: [year]["-"]["W"][week]["-"][dayk]/// Parse a date in the basic or extended format. Reduced precision is permitted.// Basic: ["T"][hour][min][sec]// Extended: ["T"][hour][":"][min][":"][sec]// Reduced precision: components after [hour] (including their preceding separator) can be// omitted. ["T"] can be omitted if there is no date present./// Parse a time in the basic or extended format. Reduced precision is permitted.// Basic: [±][hour][min] or ["Z"]// Extended: [±][hour][":"][min] or ["Z"]// Reduced precision: [±][hour] or ["Z"]/// Parse a UTC offset in the basic or extended format. Reduced precision is supported./// Round wrapper that uses hardware implementation if `std` is available, falling back to manual/// implementation for `no_std`//! Parse parts of an ISO 8601-formatted value.parsable/// An item that has been parsed. Represented as a `(remaining, value)` pair./// Map the value to a new value, preserving the remaining input./// Map the value to a new, optional value, preserving the remaining input."this returns the remaining input"consume_value/// Consume the stored value with the provided function. The remaining input is returned./// Filter the value with the provided function. If the function returns `false`, the value/// is discarded and `None` is returned. Otherwise, the value is preserved and `Some(self)` is/// Discard the unit value, returning the remaining input./// Discard the potential unit value, returning the remaining input.//! Parsing for various types./// A type that can be parsed./// Parse the item into the provided [`Parsed`] struct./// This method can be used to parse a single component without parsing the full value./// Parse the item into a new [`Parsed`] struct./// This method can only be used to parse a complete value of a type. If any characters/// remain after parsing, an error will be returned./// Parse a [`Date`] from the format description./// Parse a [`Time`] from the format description./// Parse a [`UtcOffset`] from the format description.parse_primitive_date_time/// Parse a [`PrimitiveDateTime`] from the format description.parse_offset_date_time/// Parse a [`OffsetDateTime`] from the format description./// Parse the item using a format description and an input./// Seal the trait to prevent downstream users from implementing it, while still allowing it to/// exist in generic bounds.//! A trait that can be used to parse an item from an input.parse_item/// Parse a single item, returning the remaining input on success.AnyFormatItem/// A trait to allow `parse_item` to be generic./// Sealed to prevent downstream implementations./// Calendar year.year_last_two/// The last two digits of the calendar year.iso_year/// Year of the [ISO week date](https://en.wikipedia.org/wiki/ISO_week_date).iso_year_last_two/// The last two digits of the ISO week year.sunday_week_number/// Week of the year, where week one begins on the first Sunday of the calendar year.monday_week_number/// Week of the year, where week one begins on the first Monday of the calendar year.iso_week_number/// Week of the year, where week one is the Monday-to-Sunday period containing January 4.366/// Day of the year.hour_24/// Hour within the day.hour_12/// Hour within the 12-hour period (midnight to noon or vice versa). This is typically used in/// conjunction with AM/PM, which is indicated by the `hour_12_is_pm` field.hour_12_is_pm/// Whether the `hour_12` field indicates a time that "PM".// minute: MaybeUninit<u8>,// do not subtract one, as leap seconds may be allowedsubsecond/// Nanosecond within the second.offset_hour/// Whole hours of the UTC offset.offset_minute/// Minutes within the hour of the UTC offset.offset_second/// Seconds within the minute of the UTC offset.MIDNIGHT/// The Unix timestamp in nanoseconds.offset_is_negative/// Indicates whether the [`UtcOffset`] is negative. This information is obtained when parsing/// the offset hour, but may not otherwise be stored due to "-0" being equivalent to "0".leap_second_allowed/// Indicates whether a leap second is permitted to be parsed. This is required by some/// well-known formats./// All information parsed./// This information is directly used to construct the final values./// Most users will not need think about this struct in any way. It is public to allow for manual/// control over values, in the instance that the default parser is insufficient./// Create a new instance of `Parsed` with no information known./// Parse a single [`BorrowedFormatItem`] or [`OwnedFormatItem`], mutating the struct. The/// remaining input is returned as the `Ok` value./// If a [`BorrowedFormatItem::Optional`] or [`OwnedFormatItem::Optional`] is passed, parsing/// will not fail; the input will be returned as-is if the expected format is not present.parse_items/// Parse a sequence of [`BorrowedFormatItem`]s or [`OwnedFormatItem`]s, mutating the struct./// The remaining input is returned as the `Ok` value./// This method will fail if any of the contained [`BorrowedFormatItem`]s or/// [`OwnedFormatItem`]s fail to parse. `self` will not be mutated in this instance./// Parse a literal byte sequence. The remaining input is returned as the `Ok` value./// Parse a single component, mutating the struct. The remaining input is returned as the `Ok`/// Obtain the `year` component./// Obtain the `year_last_two` component./// Obtain the `iso_year` component./// Obtain the `iso_year_last_two` component./// Obtain the `month` component./// Obtain the `sunday_week_number` component./// Obtain the `monday_week_number` component./// Obtain the `iso_week_number` component./// Obtain the `weekday` component./// Obtain the `ordinal` component./// Obtain the `day` component./// Obtain the `hour_24` component./// Obtain the `hour_12` component./// Obtain the `hour_12_is_pm` component./// Obtain the `minute` component./// Obtain the `second` component./// Obtain the `subsecond` component./// Obtain the `offset_hour` component./// Obtain the absolute value of the `offset_minute` component.offset_minute_signed/// Obtain the `offset_minute` component./// Obtain the absolute value of the `offset_second` component.offset_second_signed/// Obtain the `offset_second` component./// Obtain the `unix_timestamp_nanos` component./// Getter methodssetters/// Generate setters based on the builders.set_year_last_twoset_iso_yearset_iso_year_last_twoset_sunday_week_numberset_monday_week_numberset_iso_week_numberset_hour_24set_hour_12set_hour_12_is_pmset_subsecondset_offset_hourset_offset_minute_signedset_offset_second_signedset_unix_timestamp_nanosset_offset_minute/// Set the `offset_minute` component.set_offset_second/// Setter methods/// All setters return `Option<()>`, which is `Some` if the value was set, and `None` if not. The/// setters _may_ fail if the value is invalid, though behavior is not guaranteed./// Set the `year` component and return `self`.with_year_last_two/// Set the `year_last_two` component and return `self`.with_iso_year/// Set the `iso_year` component and return `self`.with_iso_year_last_two/// Set the `iso_year_last_two` component and return `self`./// Set the `month` component and return `self`.with_sunday_week_number/// Set the `sunday_week_number` component and return `self`.with_monday_week_number/// Set the `monday_week_number` component and return `self`.with_iso_week_number/// Set the `iso_week_number` component and return `self`.with_weekday/// Set the `weekday` component and return `self`./// Set the `ordinal` component and return `self`./// Set the `day` component and return `self`.with_hour_24/// Set the `hour_24` component and return `self`.with_hour_12/// Set the `hour_12` component and return `self`.with_hour_12_is_pm/// Set the `hour_12_is_pm` component and return `self`./// Set the `minute` component and return `self`./// Set the `second` component and return `self`.with_subsecond/// Set the `subsecond` component and return `self`.with_offset_hour/// Set the `offset_hour` component and return `self`.with_offset_minute/// Set the `offset_minute` component and return `self`.with_offset_minute_signedwith_offset_secondwith_offset_second_signed/// Set the `offset_second` component and return `self`.with_unix_timestamp_nanos/// Set the `unix_timestamp_nanos` component and return `self`./// Builder methods/// All builder methods return `Option<Self>`, which is `Some` if the value was set, and `None` if/// not. The builder methods _may_ fail if the value is invalid, though behavior is not guaranteed.//! Information parsed from an input and format description./// Equivalent of `foo.parse()` for slices./// Marker trait for all integer types, including `NonZero*`impl_parse_bytes/// Parse the given types from bytes.impl_parse_bytes_nonzero//! Extension traits for things either not implemented or not yet stable in the MSRV./// Combined date and time./// The smallest value that can be represented by `PrimitiveDateTime`./// Depending on `large-dates` feature flag, value of this constant may vary./// 1. With `large-dates` disabled it is equal to `-9999-01-01 00:00:00.0`/// 2. With `large-dates` enabled it is equal to `-999999-01-01 00:00:00.0`/// The largest value that can be represented by `PrimitiveDateTime`./// 1. With `large-dates` disabled it is equal to `9999-12-31 23:59:59.999_999_999`/// 2. With `large-dates` enabled it is equal to `999999-12-31 23:59:59.999_999_999`/// Create a new `PrimitiveDateTime` from the provided [`Date`] and [`Time`].///     PrimitiveDateTime::new(date!(2019-01-01), time!(0:00)),///     datetime!(2019-01-01 0:00),// region: component getters/// Get the [`Date`] component of the `PrimitiveDateTime`./// assert_eq!(datetime!(2019-01-01 0:00).date(), date!(2019-01-01));/// Get the [`Time`] component of the `PrimitiveDateTime`./// assert_eq!(datetime!(2019-01-01 0:00).time(), time!(0:00));/// assert_eq!(datetime!(2019-01-01 0:00).year(), 2019);/// assert_eq!(datetime!(2019-12-31 0:00).year(), 2019);/// assert_eq!(datetime!(2020-01-01 0:00).year(), 2020);/// Get the month of the date./// assert_eq!(datetime!(2019-01-01 0:00).month(), Month::January);/// assert_eq!(datetime!(2019-12-31 0:00).month(), Month::December);/// Get the day of the date./// assert_eq!(datetime!(2019-01-01 0:00).day(), 1);/// assert_eq!(datetime!(2019-12-31 0:00).day(), 31);/// assert_eq!(datetime!(2019-01-01 0:00).ordinal(), 1);/// assert_eq!(datetime!(2019-12-31 0:00).ordinal(), 365);/// assert_eq!(datetime!(2019-01-01 0:00).iso_week(), 1);/// assert_eq!(datetime!(2019-10-04 0:00).iso_week(), 40);/// assert_eq!(datetime!(2020-01-01 0:00).iso_week(), 1);/// assert_eq!(datetime!(2020-12-31 0:00).iso_week(), 53);/// assert_eq!(datetime!(2021-01-01 0:00).iso_week(), 53);/// assert_eq!(datetime!(2019-01-01 0:00).sunday_based_week(), 0);/// assert_eq!(datetime!(2020-01-01 0:00).sunday_based_week(), 0);/// assert_eq!(datetime!(2020-12-31 0:00).sunday_based_week(), 52);/// assert_eq!(datetime!(2021-01-01 0:00).sunday_based_week(), 0);/// assert_eq!(datetime!(2019-01-01 0:00).monday_based_week(), 0);/// assert_eq!(datetime!(2020-01-01 0:00).monday_based_week(), 0);/// assert_eq!(datetime!(2020-12-31 0:00).monday_based_week(), 52);/// assert_eq!(datetime!(2021-01-01 0:00).monday_based_week(), 0);///     datetime!(2019-01-01 0:00).to_calendar_date(),/// assert_eq!(datetime!(2019-01-01 0:00).to_ordinal_date(), (2019, 1));///     datetime!(2019-01-01 0:00).to_iso_week_date(),///     datetime!(2019-10-04 0:00).to_iso_week_date(),///     datetime!(2020-01-01 0:00).to_iso_week_date(),///     datetime!(2020-12-31 0:00).to_iso_week_date(),///     datetime!(2021-01-01 0:00).to_iso_week_date(),/// assert_eq!(datetime!(2019-01-01 0:00).weekday(), Tuesday);/// assert_eq!(datetime!(2019-02-01 0:00).weekday(), Friday);/// assert_eq!(datetime!(2019-03-01 0:00).weekday(), Friday);/// assert_eq!(datetime!(2019-04-01 0:00).weekday(), Monday);/// assert_eq!(datetime!(2019-05-01 0:00).weekday(), Wednesday);/// assert_eq!(datetime!(2019-06-01 0:00).weekday(), Saturday);/// assert_eq!(datetime!(2019-07-01 0:00).weekday(), Monday);/// assert_eq!(datetime!(2019-08-01 0:00).weekday(), Thursday);/// assert_eq!(datetime!(2019-09-01 0:00).weekday(), Sunday);/// assert_eq!(datetime!(2019-10-01 0:00).weekday(), Tuesday);/// assert_eq!(datetime!(2019-11-01 0:00).weekday(), Friday);/// assert_eq!(datetime!(2019-12-01 0:00).weekday(), Sunday);/// assert_eq!(datetime!(-4713-11-24 0:00).to_julian_day(), 0);/// assert_eq!(datetime!(2000-01-01 0:00).to_julian_day(), 2_451_545);/// assert_eq!(datetime!(2019-01-01 0:00).to_julian_day(), 2_458_485);/// assert_eq!(datetime!(2019-12-31 0:00).to_julian_day(), 2_458_849);as_hms/// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms(), (0, 0, 0));/// assert_eq!(datetime!(2020-01-01 23:59:59).as_hms(), (23, 59, 59));as_hms_milli/// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms_milli(), (0, 0, 0, 0));///     datetime!(2020-01-01 23:59:59.999).as_hms_milli(),as_hms_micro/// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms_micro(), (0, 0, 0, 0));///     datetime!(2020-01-01 23:59:59.999_999).as_hms_micro(),as_hms_nano/// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms_nano(), (0, 0, 0, 0));///     datetime!(2020-01-01 23:59:59.999_999_999).as_hms_nano(),/// Get the clock hour./// assert_eq!(datetime!(2019-01-01 0:00).hour(), 0);/// assert_eq!(datetime!(2019-01-01 23:59:59).hour(), 23);/// Get the minute within the hour./// assert_eq!(datetime!(2019-01-01 0:00).minute(), 0);/// assert_eq!(datetime!(2019-01-01 23:59:59).minute(), 59);/// Get the second within the minute./// assert_eq!(datetime!(2019-01-01 0:00).second(), 0);/// assert_eq!(datetime!(2019-01-01 23:59:59).second(), 59);/// Get the milliseconds within the second./// assert_eq!(datetime!(2019-01-01 0:00).millisecond(), 0);/// assert_eq!(datetime!(2019-01-01 23:59:59.999).millisecond(), 999);/// Get the microseconds within the second./// assert_eq!(datetime!(2019-01-01 0:00).microsecond(), 0);///     datetime!(2019-01-01 23:59:59.999_999).microsecond(),///     999_999/// Get the nanoseconds within the second./// assert_eq!(datetime!(2019-01-01 0:00).nanosecond(), 0);///     datetime!(2019-01-01 23:59:59.999_999_999).nanosecond(),assume_offset// region: attach offset/// Assuming that the existing `PrimitiveDateTime` represents a moment in the provided/// [`UtcOffset`], return an [`OffsetDateTime`].///     datetime!(2019-01-01 0:00)///         .assume_offset(offset!(UTC))///         .unix_timestamp(),///     1_546_300_800,///         .assume_offset(offset!(-1))///     1_546_304_400,assume_utc/// Assuming that the existing `PrimitiveDateTime` represents a moment in UTC, return an/// [`OffsetDateTime`].///     datetime!(2019-01-01 0:00).assume_utc().unix_timestamp(),/// let datetime = Date::MIN.midnight();/// let datetime = Date::MAX.midnight();/// assert_eq!(datetime.checked_add(1.days()), None);///     datetime!(2019 - 11 - 25 15:30).checked_add(27.hours()),///     Some(datetime!(2019 - 11 - 26 18:30))/// assert_eq!(datetime.checked_sub((-1).days()), None);///     datetime!(2019 - 11 - 25 15:30).checked_sub(27.hours()),///     Some(datetime!(2019 - 11 - 24 12:30))/// # use time::{PrimitiveDateTime, ext::NumericalDuration};///     PrimitiveDateTime::MIN.saturating_add((-2).days()),///     PrimitiveDateTime::MIN///     PrimitiveDateTime::MAX.saturating_add(2.days()),///     datetime!(2019 - 11 - 25 15:30).saturating_add(27.hours()),///     datetime!(2019 - 11 - 26 18:30)///     PrimitiveDateTime::MIN.saturating_sub(2.days()),///     PrimitiveDateTime::MAX.saturating_sub((-2).days()),///     datetime!(2019 - 11 - 25 15:30).saturating_sub(27.hours()),///     datetime!(2019 - 11 - 24 12:30)// endregion component getters// endregion attach offset"This method does not mutate the original `PrimitiveDateTime`."/// Replace the time, preserving the date.///     datetime!(2020-01-01 17:00).replace_time(time!(5:00)),///     datetime!(2020-01-01 5:00)/// Replace the date, preserving the time.///     datetime!(2020-01-01 12:00).replace_date(date!(2020-01-30)),///     datetime!(2020-01-30 12:00)///     datetime!(2022 - 02 - 18 12:00).replace_year(2019),///     Ok(datetime!(2019 - 02 - 18 12:00))/// assert!(datetime!(2022 - 02 - 18 12:00).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year/// assert!(datetime!(2022 - 02 - 18 12:00).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year///     datetime!(2022 - 02 - 18 12:00).replace_month(Month::January),///     Ok(datetime!(2022 - 01 - 18 12:00))/// assert!(datetime!(2022 - 01 - 30 12:00).replace_month(Month::February).is_err()); // 30 isn't a valid day in February///     datetime!(2022 - 02 - 18 12:00).replace_day(1),///     Ok(datetime!(2022 - 02 - 01 12:00))/// assert!(datetime!(2022 - 02 - 18 12:00).replace_day(0).is_err()); // 00 isn't a valid day/// assert!(datetime!(2022 - 02 - 18 12:00).replace_day(30).is_err()); // 30 isn't a valid day in February/// assert_eq!(datetime!(2022-049 12:00).replace_ordinal(1), Ok(datetime!(2022-001 12:00)));/// assert!(datetime!(2022-049 12:00).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal/// assert!(datetime!(2022-049 12:00).replace_ordinal(366).is_err()); // 2022 isn't a leap year///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_hour(7),///     Ok(datetime!(2022 - 02 - 18 07:02:03.004_005_006))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_hour(24).is_err()); // 24 isn't a valid hour///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_minute(7),///     Ok(datetime!(2022 - 02 - 18 01:07:03.004_005_006))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_minute(60).is_err()); // 60 isn't a valid minute///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_second(7),///     Ok(datetime!(2022 - 02 - 18 01:02:07.004_005_006))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_second(60).is_err()); // 60 isn't a valid second///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_millisecond(7),///     Ok(datetime!(2022 - 02 - 18 01:02:03.007))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecond///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_microsecond(7_008),///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecond///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_nanosecond(7_008_009),///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008_009))/// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond/// Methods that replace part of the `PrimitiveDateTime`./// Format the `PrimitiveDateTime` using the provided [format/// let format = format_description::parse("[year]-[month]-[day] [hour]:[minute]:[second]")?;///     datetime!(2020-01-02 03:04:05).format(&format)?,///     "2020-01-02 03:04:05"/// Parse a `PrimitiveDateTime` from the input using the provided [format/// let format = format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");///     PrimitiveDateTime::parse("2020-01-02 03:04:05", &format)?,///     datetime!(2020-01-02 03:04:05)//! The [`PrimitiveDateTime`] struct and its associated `impl`s.empty_shrinkersingle_shrinkerarbitrary_between/// Obtain an arbitrary value between the minimum and maximum inclusive.//! Implementations of the [`quickcheck::Arbitrary`](quickcheck::Arbitrary) trait.//! This enables users to write tests such as this, and have test values provided automatically://! use quickcheck::quickcheck;//! use time::Date;//! struct DateRange {//!     from: Date,//!     to: Date,//! impl DateRange {//!     fn new(from: Date, to: Date) -> Result<Self, ()> {//!         Ok(DateRange { from, to })//! quickcheck! {//!     fn date_range_is_well_defined(from: Date, to: Date) -> bool {//!         let r = DateRange::new(from, to);//!         if from <= to {//!             r.is_ok()//!             r.is_err()//! An implementation for `Instant` is intentionally omitted since its values are only meaningful in//! relation to a [`Duration`], and obtaining an `Instant` from a [`Duration`] is very simple//! anyway.//! Implementation of [`Distribution`] for various structs.SERDE_CONFIG/// The configuration of ISO 8601 used for serde implementations./// Serialize an [`OffsetDateTime`] using the well-known ISO 8601 format./// Deserialize an [`OffsetDateTime`] from its ISO 8601 representation./// Serialize an [`Option<OffsetDateTime>`] using the well-known ISO 8601 format./// Deserialize an [`Option<OffsetDateTime>`] from its ISO 8601 representation./// Use the well-known ISO 8601 format when serializing and deserializing an/// [`Option<OffsetDateTime>`]./// Use this module in combination with serde's [`#[with]`][with] attribute./// [ISO 8601 format]: https://www.iso.org/iso-8601-date-and-time-format.html/// [with]: https://serde.rs/field-attrs.html#with//! Use the well-known [ISO 8601 format] when serializing and deserializing an [`OffsetDateTime`].//! Use this module in combination with serde's [`#[with]`][with] attribute.//! [ISO 8601 format]: https://www.iso.org/iso-8601-date-and-time-format.html//! [with]: https://serde.rs/field-attrs.html#with/// Consume the next item in a sequence.serde_format_description/// Generate a custom serializer and deserializer from a format string or an existing format./// Invoked as `serde::format_description!(mod_name, Date, FORMAT)` where `FORMAT` is either a/// `"<format string>"` or something that implements/// This puts a module named `mod_name` in the current scope that can be used to format `Date`/// structs. A submodule (`mod_name::option`) is also generated for `Option<Date>`. Both/// modules are only visible in the current scope./// The returned `Option` will contain a deserialized value if present and `None` if the field/// is present but the value is `null` (or the equivalent in other formats). To return `None`/// when the field is not present, you should use `#[serde(default)]` on the field./// Using a format string:/// use time::serde;/// // Makes a module `mod my_format { ... }`./// serde::format_description!(my_format, OffsetDateTime, "hour=[hour], minute=[minute]");/// struct SerializesWithCustom {///     #[serde(with = "my_format")]///     dt: OffsetDateTime,///     #[serde(with = "my_format::option")]///     maybe_dt: Option<OffsetDateTime>,/// Define the format separately to be used in multiple places:/// use time::format_description::BorrowedFormatItem;/// const DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = time::macros::format_description!(///     "hour=[hour], minute=[minute]"/// serde::format_description!(my_format, OffsetDateTime, DATE_TIME_FORMAT);///     # #[allow(unused_variables)]///     let str_ts = OffsetDateTime::now_utc().format(DATE_TIME_FORMAT).unwrap();/// Customize the configuration of ISO 8601 formatting/parsing:/// use time::format_description::well_known::{iso8601, Iso8601};/// const CONFIG: iso8601::EncodedConfig = iso8601::Config::DEFAULT///     .set_year_is_six_digits(false)///     .encode();/// const FORMAT: Iso8601<CONFIG> = Iso8601::<CONFIG>;/// serde::format_description!(my_format, OffsetDateTime, FORMAT);DATE_FORMAT// region: Date/// The format used when serializing and deserializing a human-readable `Date`.// region: DurationOFFSET_DATE_TIME_FORMAT// region: OffsetDateTime/// The format used when serializing and deserializing a human-readable `OffsetDateTime`.PRIMITIVE_DATE_TIME_FORMAT// region: PrimitiveDateTime/// The format used when serializing and deserializing a human-readable `PrimitiveDateTime`.TIME_FORMAT// region: Time/// The format used when serializing and deserializing a human-readable `Time`.UTC_OFFSET_FORMAT// region: UtcOffset/// The format used when serializing and deserializing a human-readable `UtcOffset`.// region: Weekday// region: Month//! Differential formats for serde.// This also includes the serde implementations for all types. This doesn't need to be externally// documented, though.// Types with guaranteed stable serde representations. Strings are avoided to allow for optimal// representations in various binary forms.// endregion date// endregion Duration// endregion OffsetDateTime// endregion PrimitiveDateTime// endregion Time// endregion UtcOffset// endregion Weekday// endregion Month/// Serialize an [`OffsetDateTime`] using the well-known RFC2822 format./// Deserialize an [`OffsetDateTime`] from its RFC2822 representation./// Serialize an [`Option<OffsetDateTime>`] using the well-known RFC2822 format./// Deserialize an [`Option<OffsetDateTime>`] from its RFC2822 representation./// Use the well-known [RFC2822 format] when serializing and deserializing an/// [RFC2822 format]: https://tools.ietf.org/html/rfc2822#section-3.3//! Use the well-known [RFC2822 format] when serializing and deserializing an [`OffsetDateTime`].//! [RFC2822 format]: https://tools.ietf.org/html/rfc2822#section-3.3/// Serialize an [`OffsetDateTime`] using the well-known RFC3339 format./// Deserialize an [`OffsetDateTime`] from its RFC3339 representation./// Serialize an [`Option<OffsetDateTime>`] using the well-known RFC3339 format./// Deserialize an [`Option<OffsetDateTime>`] from its RFC3339 representation./// Use the well-known [RFC3339 format] when serializing and deserializing an/// [RFC3339 format]: https://tools.ietf.org/html/rfc3339#section-5.6//! Use the well-known [RFC3339 format] when serializing and deserializing an [`OffsetDateTime`].//! [RFC3339 format]: https://tools.ietf.org/html/rfc3339#section-5.6/// Serialize an `OffsetDateTime` as its Unix timestamp with microseconds/// Deserialize an `OffsetDateTime` from its Unix timestamp with microseconds/// Serialize an `Option<OffsetDateTime>` as its Unix timestamp with microseconds/// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp with microseconds/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] with microseconds/// for the purposes of serde./// When deserializing, the offset is assumed to be UTC./// [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time//! Treat an [`OffsetDateTime`] as a [Unix timestamp] with microseconds for//! the purposes of serde.//! When deserializing, the offset is assumed to be UTC.//! [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time/// Serialize an `OffsetDateTime` as its Unix timestamp with milliseconds/// Deserialize an `OffsetDateTime` from its Unix timestamp with milliseconds/// Serialize an `Option<OffsetDateTime>` as its Unix timestamp with milliseconds/// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp with milliseconds/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] with milliseconds//! Treat an [`OffsetDateTime`] as a [Unix timestamp] with milliseconds for/// Serialize an `OffsetDateTime` as its Unix timestamp/// Deserialize an `OffsetDateTime` from its Unix timestamp/// Serialize an `Option<OffsetDateTime>` as its Unix timestamp/// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] for the purposes of/// serde.//! Treat an [`OffsetDateTime`] as a [Unix timestamp] for the purposes of serde./// Serialize an `OffsetDateTime` as its Unix timestamp with nanoseconds/// Deserialize an `OffsetDateTime` from its Unix timestamp with nanoseconds/// Serialize an `Option<OffsetDateTime>` as its Unix timestamp with nanoseconds/// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp with nanoseconds/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] with nanoseconds//! Treat an [`OffsetDateTime`] as a [Unix timestamp] with nanoseconds for/// A serde visitor for various types./// Implement a visitor for a well-known format.//! Serde visitor for various types.local_offset_at//! A fallback for any OS not covered./// Attempt to obtain the system's UTC offset. If the offset cannot be determined, `None` is//! A method to obtain the local offset from UTC.local_offsetSoundnessOS_HAS_THREAD_SAFE_ENVIRONMENT/// Whether the operating system has a thread-safe environment. This allows bypassing the check for/// if the process is multi-threaded.// This is the same value as `cfg!(target_os = "x")`.// Use byte-strings to work around current limitations of const eval.timestamp_to_tm/// Convert the given Unix timestamp to a `libc::tm`. Returns `None` on any error./// This method must only be called when the process is single-threaded./// This method will remain `unsafe` until `std::env::set_var` is deprecated or has its behavior/// altered. This method is, on its own, safe. It is the presence of a safe, unsound way to set/// environment variables that makes it unsafe.tm_to_offset/// Convert a `libc::tm` to a `UtcOffset`. Returns `None` on any error.// This is available to any target known to have the `tm_gmtoff` extension./// Obtain the system's UTC offset.//! Get the system's UTC offset on Unix.// ffi: WINAPI FILETIME struct// ffi: WINAPI SYSTEMTIME struct// https://docs.microsoft.com/en-us/windows/win32/api/timezoneapi/nf-timezoneapi-systemtimetofiletimeSystemTimeToTzSpecificLocalTime// We only pass `nullptr` here// https://docs.microsoft.com/en-us/windows/win32/api/timezoneapi/nf-timezoneapi-systemtimetotzspecificlocaltimesystemtime_to_filetime/// Convert a `SYSTEMTIME` to a `FILETIME`. Returns `None` if any error occurred.filetime_to_secs/// Convert a `FILETIME` to an `i64`, representing a number of seconds.offset_to_systemtime/// Convert an [`OffsetDateTime`] to a `SYSTEMTIME`.//! Get the system's UTC offset on Windows.//! Functions with a common interface that rely on system calls.// We're interfacing with system calls.parsing_internals//! Tests for internal details.//! This module should only be used when it is not possible to test the implementation in a//! reasonable manner externally.DateAdjustment/// The type of the `hour` field of `Time`./// The type of the `minute` field of `Time`./// The type of the `second` field of `Time`./// The type of the `nanosecond` field of `Time`.// Little endian version// The order of this struct's fields matter!// Do not change them./// The clock time within a given date. Nanosecond precision./// All minutes are assumed to have exactly 60 seconds; no attempt is made to handle leap seconds/// (either positive or negative)./// When comparing two `Time`s, they are assumed to be in the same calendar date./// Provides an u64 based representation **of the correct endianness**/// This representation can be used to do comparisons equality testing or hashing./// Create a `Time` that is exactly midnight./// # use time::Time;/// # use time_macros::time;/// assert_eq!(Time::MIDNIGHT, time!(0:00));/// The smallest value that can be represented by `Time`./// `00:00:00.0`/// The largest value that can be represented by `Time`./// `23:59:59.999_999_999`__from_hms_nanos_unchecked/// Create a `Time` from its components./// - `hours` must be in the range `0..=23`./// - `minutes` must be in the range `0..=59`./// - `seconds` must be in the range `0..=59`./// - `nanoseconds` must be in the range `0..=999_999_999`./// Attempt to create a `Time` from the hour, minute, and second./// assert!(Time::from_hms(1, 2, 3).is_ok());/// assert!(Time::from_hms(24, 0, 0).is_err()); // 24 isn't a valid hour./// assert!(Time::from_hms(0, 60, 0).is_err()); // 60 isn't a valid minute./// assert!(Time::from_hms(0, 0, 60).is_err()); // 60 isn't a valid second.from_hms_nanos_ranged/// Create a `Time` from the hour, minute, second, and nanosecond./// Attempt to create a `Time` from the hour, minute, second, and millisecond./// assert!(Time::from_hms_milli(1, 2, 3, 4).is_ok());/// assert!(Time::from_hms_milli(24, 0, 0, 0).is_err()); // 24 isn't a valid hour./// assert!(Time::from_hms_milli(0, 60, 0, 0).is_err()); // 60 isn't a valid minute./// assert!(Time::from_hms_milli(0, 0, 60, 0).is_err()); // 60 isn't a valid second./// assert!(Time::from_hms_milli(0, 0, 0, 1_000).is_err()); // 1_000 isn't a valid millisecond./// Attempt to create a `Time` from the hour, minute, second, and microsecond./// assert!(Time::from_hms_micro(1, 2, 3, 4).is_ok());/// assert!(Time::from_hms_micro(24, 0, 0, 0).is_err()); // 24 isn't a valid hour./// assert!(Time::from_hms_micro(0, 60, 0, 0).is_err()); // 60 isn't a valid minute./// assert!(Time::from_hms_micro(0, 0, 60, 0).is_err()); // 60 isn't a valid second./// assert!(Time::from_hms_micro(0, 0, 0, 1_000_000).is_err()); // 1_000_000 isn't a valid microsecond./// Attempt to create a `Time` from the hour, minute, second, and nanosecond./// assert!(Time::from_hms_nano(1, 2, 3, 4).is_ok());/// assert!(Time::from_hms_nano(24, 0, 0, 0).is_err()); // 24 isn't a valid hour./// assert!(Time::from_hms_nano(0, 60, 0, 0).is_err()); // 60 isn't a valid minute./// assert!(Time::from_hms_nano(0, 0, 60, 0).is_err()); // 60 isn't a valid second./// assert!(Time::from_hms_nano(0, 0, 0, 1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond./// assert_eq!(time!(0:00:00).as_hms(), (0, 0, 0));/// assert_eq!(time!(23:59:59).as_hms(), (23, 59, 59));/// assert_eq!(time!(0:00:00).as_hms_milli(), (0, 0, 0, 0));/// assert_eq!(time!(23:59:59.999).as_hms_milli(), (23, 59, 59, 999));/// assert_eq!(time!(0:00:00).as_hms_micro(), (0, 0, 0, 0));///     time!(23:59:59.999_999).as_hms_micro(),/// assert_eq!(time!(0:00:00).as_hms_nano(), (0, 0, 0, 0));///     time!(23:59:59.999_999_999).as_hms_nano(),/// assert_eq!(time!(0:00:00).hour(), 0);/// assert_eq!(time!(23:59:59).hour(), 23);/// assert_eq!(time!(0:00:00).minute(), 0);/// assert_eq!(time!(23:59:59).minute(), 59);/// assert_eq!(time!(0:00:00).second(), 0);/// assert_eq!(time!(23:59:59).second(), 59);/// assert_eq!(time!(0:00).millisecond(), 0);/// assert_eq!(time!(23:59:59.999).millisecond(), 999);/// assert_eq!(time!(0:00).microsecond(), 0);/// assert_eq!(time!(23:59:59.999_999).microsecond(), 999_999);/// assert_eq!(time!(0:00).nanosecond(), 0);/// assert_eq!(time!(23:59:59.999_999_999).nanosecond(), 999_999_999);adjusting_add// region: arithmetic helpers/// Add the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow, returning whether/// the date is different.adjusting_sub/// Subtract the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow, returning/// whether the date is different.adjusting_add_std/// Add the sub-day time of the [`std::time::Duration`] to the `Time`. Wraps on overflow,/// returning whether the date is the previous date as the first element of the tuple.adjusting_sub_std/// Subtract the sub-day time of the [`std::time::Duration`] to the `Time`. Wraps on overflow,"This method does not mutate the original `Time`."///     time!(01:02:03.004_005_006).replace_hour(7),///     Ok(time!(07:02:03.004_005_006))/// assert!(time!(01:02:03.004_005_006).replace_hour(24).is_err()); // 24 isn't a valid hour///     time!(01:02:03.004_005_006).replace_minute(7),///     Ok(time!(01:07:03.004_005_006))/// assert!(time!(01:02:03.004_005_006).replace_minute(60).is_err()); // 60 isn't a valid minute///     time!(01:02:03.004_005_006).replace_second(7),///     Ok(time!(01:02:07.004_005_006))/// assert!(time!(01:02:03.004_005_006).replace_second(60).is_err()); // 60 isn't a valid second///     time!(01:02:03.004_005_006).replace_millisecond(7),///     Ok(time!(01:02:03.007))/// assert!(time!(01:02:03.004_005_006).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecond///     time!(01:02:03.004_005_006).replace_microsecond(7_008),///     Ok(time!(01:02:03.007_008))/// assert!(time!(01:02:03.004_005_006).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecond///     time!(01:02:03.004_005_006).replace_nanosecond(7_008_009),///     Ok(time!(01:02:03.007_008_009))/// assert!(time!(01:02:03.004_005_006).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond// endregion arithmetic helpers/// Format the `Time` using the provided [format description](crate::format_description)./// let format = format_description::parse("[hour]:[minute]:[second]")?;/// assert_eq!(time!(12:00).format(&format)?, "12:00:00");/// Parse a `Time` from the input using the provided [format/// # use time_macros::{time, format_description};/// let format = format_description!("[hour]:[minute]:[second]");/// assert_eq!(Time::parse("12:00:00", &format)?, time!(12:00));subsecond_width/// How many characters wide the formatted subsecond is.subsecond_value/// The value to use when formatting the subsecond. Leading zeroes will be added asTimeMetadata/// Add the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow./// assert_eq!(time!(12:00) + 2.hours(), time!(14:00));/// assert_eq!(time!(0:00:01) + (-2).seconds(), time!(23:59:59));/// Add the sub-day time of the [`std::time::Duration`] to the `Time`. Wraps on overflow./// assert_eq!(time!(12:00) + 2.std_hours(), time!(14:00));/// assert_eq!(time!(23:59:59) + 2.std_seconds(), time!(0:00:01));/// Subtract the sub-day time of the [`Duration`] from the `Time`. Wraps on overflow./// assert_eq!(time!(14:00) - 2.hours(), time!(12:00));/// assert_eq!(time!(23:59:59) - (-2).seconds(), time!(0:00:01));/// Subtract the sub-day time of the [`std::time::Duration`] from the `Time`. Wraps on overflow./// assert_eq!(time!(14:00) - 2.std_hours(), time!(12:00));/// assert_eq!(time!(0:00:01) - 2.std_seconds(), time!(23:59:59));/// Subtract two `Time`s, returning the [`Duration`] between. This assumes both `Time`s are in/// the same calendar day./// assert_eq!(time!(0:00) - time!(0:00), 0.seconds());/// assert_eq!(time!(1:00) - time!(0:00), 1.hours());/// assert_eq!(time!(0:00) - time!(1:00), (-1).hours());/// assert_eq!(time!(0:00) - time!(23:00), (-23).hours());//! The [`Time`] struct and its associated `impl`s./// The type of the `hours` field of `UtcOffset`./// The type of the `minutes` field of `UtcOffset`./// The type of the `seconds` field of `UtcOffset`.WholeSeconds/// The type capable of storing the range of whole seconds that a `UtcOffset` can encompass./// An offset from UTC./// This struct can store values up to ±25:59:59. If you need support outside this range, please/// file an issue with your use case.// All three components _must_ have the same sign./// A `UtcOffset` that is UTC./// # use time::UtcOffset;/// assert_eq!(UtcOffset::UTC, offset!(UTC));__from_hms_unchecked/// Create a `UtcOffset` representing an offset of the hours, minutes, and seconds provided, the/// validity of which must be guaranteed by the caller. All three parameters must have the same/// sign./// - Hours must be in the range `-25..=25`./// - Minutes must be in the range `-59..=59`./// - Seconds must be in the range `-59..=59`./// While the signs of the parameters are required to match to avoid bugs, this is not a safety/// invariant./// Create a `UtcOffset` representing an offset by the number of hours, minutes, and seconds/// The sign of all three components should match. If they do not, all smaller components will/// have their signs flipped./// assert_eq!(UtcOffset::from_hms(1, 2, 3)?.as_hms(), (1, 2, 3));/// assert_eq!(UtcOffset::from_hms(1, -2, -3)?.as_hms(), (1, 2, 3));from_hms_ranged_unchecked/// Create a `UtcOffset` representing an offset of the hours, minutes, and seconds provided. All/// three parameters must have the same sign./// While the signs of the parameters are required to match, this is not a safety invariant.from_hms_rangedfrom_whole_seconds/// Create a `UtcOffset` representing an offset by the number of seconds provided./// assert_eq!(UtcOffset::from_whole_seconds(3_723)?.as_hms(), (1, 2, 3));from_whole_seconds_ranged// ignore because the function is crate-private/// # use deranged::RangedI32;///     UtcOffset::from_whole_seconds_ranged(RangedI32::new_static::<3_723>()).as_hms(),///     (1, 2, 3)/// Obtain the UTC offset as its hours, minutes, and seconds. The sign of all three components/// will always match. A positive value indicates an offset to the east; a negative to the west./// assert_eq!(offset!(+1:02:03).as_hms(), (1, 2, 3));/// assert_eq!(offset!(-1:02:03).as_hms(), (-1, -2, -3));/// Obtain the number of whole hours the offset is from UTC. A positive value indicates an/// offset to the east; a negative to the west./// assert_eq!(offset!(+1:02:03).whole_hours(), 1);/// assert_eq!(offset!(-1:02:03).whole_hours(), -1);/// Obtain the number of whole minutes the offset is from UTC. A positive value indicates an/// assert_eq!(offset!(+1:02:03).whole_minutes(), 62);/// assert_eq!(offset!(-1:02:03).whole_minutes(), -62);minutes_past_hour/// Obtain the number of minutes past the hour the offset is from UTC. A positive value/// indicates an offset to the east; a negative to the west./// assert_eq!(offset!(+1:02:03).minutes_past_hour(), 2);/// assert_eq!(offset!(-1:02:03).minutes_past_hour(), -2);/// Obtain the number of whole seconds the offset is from UTC. A positive value indicates an/// assert_eq!(offset!(+1:02:03).whole_seconds(), 3723);/// assert_eq!(offset!(-1:02:03).whole_seconds(), -3723);// This may be useful for anyone manually implementing arithmetic, as it// would let them construct a `Duration` directly.seconds_past_minute/// Obtain the number of seconds past the minute the offset is from UTC. A positive value/// assert_eq!(offset!(+1:02:03).seconds_past_minute(), 3);/// assert_eq!(offset!(-1:02:03).seconds_past_minute(), -3);is_utc/// Check if the offset is exactly UTC./// assert!(!offset!(+1:02:03).is_utc());/// assert!(!offset!(-1:02:03).is_utc());/// assert!(offset!(UTC).is_utc());/// Check if the offset is positive, or east of UTC./// assert!(offset!(+1:02:03).is_positive());/// assert!(!offset!(-1:02:03).is_positive());/// assert!(!offset!(UTC).is_positive());/// Check if the offset is negative, or west of UTC./// assert!(!offset!(+1:02:03).is_negative());/// assert!(offset!(-1:02:03).is_negative());/// assert!(!offset!(UTC).is_negative());// region: local offset/// Attempt to obtain the system's UTC offset at a known moment in time. If the offset cannot be/// determined, an error is returned./// # use time::{UtcOffset, OffsetDateTime};/// let local_offset = UtcOffset::local_offset_at(OffsetDateTime::UNIX_EPOCH);/// assert!(local_offset.is_ok());current_local_offset/// Attempt to obtain the system's current UTC offset. If the offset cannot be determined, an/// let local_offset = UtcOffset::current_local_offset();// endregion: local offset/// Format the `UtcOffset` using the provided [format description](crate::format_description)./// let format = format_description::parse("[offset_hour sign:mandatory]:[offset_minute]")?;/// assert_eq!(offset!(+1).format(&format)?, "+01:00");/// Parse a `UtcOffset` from the input using the provided [format/// # use time_macros::{offset, format_description};/// let format = format_description!("[offset_hour]:[offset_minute]");/// assert_eq!(UtcOffset::parse("-03:42", &format)?, offset!(-3:42));UtcOffsetMetadata//! The [`UtcOffset`] struct and its associated `impl`s./// The previous day should be used./// The next day should be used./// The date should be used as-is./// Whether to adjust the date, and in which direction. Useful when implementing arithmetic./// Get the number of days in the month of a given year./// # use time::{Month, util};/// assert_eq!(util::days_in_year_month(2020, Month::February), 29);LOCAL_OFFSET_IS_SOUND/// Whether obtaining the local UTC offset is required to be sound./// Obtaining the local UTC offset is required to be sound. Undefined behavior will never/// occur. This is the default.Unsound/// Obtaining the local UTC offset is allowed to invoke undefined behavior. **Setting this/// value is strongly discouraged.** To do so, you must comply with the safety requirements/// of [`time::local_offset::set_soundness`](set_soundness)./// The soundness of obtaining the local UTC offset.set_soundness/// Set whether obtaining the local UTC offset is allowed to invoke undefined behavior. **Use of/// this function is heavily discouraged.**/// If this method is called with [`Soundness::Sound`], the call is always sound. If this method/// is called with [`Soundness::Unsound`], the following conditions apply./// - If the operating system provides a thread-safe environment, the call is sound./// - If the process is single-threaded, the call is sound./// - If the process is multi-threaded, no other thread may mutate the environment in any way at///   the same time a call to a method that obtains the local UTC offset. This includes adding,///   removing, or modifying an environment variable./// The first two conditions are automatically checked by `time`, such that you do not need to/// declare your code unsound. Currently, the only known operating systems that does _not_/// provide a thread-safe environment are some Unix-like OS's. All other operating systems/// should succeed when attempting to obtain the local UTC offset./// Note that you must not only verify this safety condition for your code, but for **all** code/// that will be included in the final binary. Notably, it applies to both direct and transitive/// dependencies and to both Rust and non-Rust code. **For this reason it is not possible to/// soundly pass [`Soundness::Unsound`] to this method if you are writing a library that may/// used by others.**/// If using this method is absolutely necessary, it is recommended to keep the time between/// setting the soundness to [`Soundness::Unsound`] and setting it back to [`Soundness::Sound`]/// as short as possible./// The following methods currently obtain the local UTC offset:/// - [`OffsetDateTime::now_local`](crate::OffsetDateTime::now_local)/// - [`UtcOffset::local_offset_at`](crate::UtcOffset::local_offset_at)/// - [`UtcOffset::current_local_offset`](crate::UtcOffset::current_local_offset)get_soundness/// Obtains the soundness of obtaining the local UTC offset. If it is [`Soundness::Unsound`],/// it is allowed to invoke undefined behavior when obtaining the local UTC offset./// Utility functions relating to the local UTC offset.//! Utility functions./// Days of the week./// As order is dependent on context (Sunday could be either two days after or five days before/// Friday), this type does not implement `PartialOrd` or `Ord`./// Get the previous weekday./// assert_eq!(Weekday::Tuesday.previous(), Weekday::Monday);/// Get the next weekday./// assert_eq!(Weekday::Monday.next(), Weekday::Tuesday);/// Get n-th next day./// assert_eq!(Weekday::Monday.nth_next(1), Weekday::Tuesday);/// assert_eq!(Weekday::Sunday.nth_next(10), Weekday::Wednesday);/// Get n-th previous day./// assert_eq!(Weekday::Monday.nth_prev(1), Weekday::Sunday);/// assert_eq!(Weekday::Sunday.nth_prev(10), Weekday::Thursday);/// Get the one-indexed number of days from Monday./// assert_eq!(Weekday::Monday.number_from_monday(), 1);/// Get the one-indexed number of days from Sunday./// assert_eq!(Weekday::Monday.number_from_sunday(), 2);number_days_from_monday/// Get the zero-indexed number of days from Monday./// assert_eq!(Weekday::Monday.number_days_from_monday(), 0);number_days_from_sunday/// Get the zero-indexed number of days from Sunday./// assert_eq!(Weekday::Monday.number_days_from_sunday(), 1);WeekdayMetadata//! Days of the week.Per/// The smallest unsigned integer type that can represent [`VALUE`](Self::VALUE)./// The number of one unit of time in the other./// A trait for defining the ratio of two units of time./// This trait is used to implement the `per` method on the various structs.impl_per/// Declare and implement `Per` for all relevant types. Identity implementations are automatic.r" compile. The return type is the smallest unsigned integer type that can represent"r" the value."r" Valid calls:"//! Conversion between units of time.//! Core items for `time`.//! This crate is an implementation detail of `time` and should not be relied upon directly./// Returns if the provided year is a leap year in the proleptic Gregorian calendar. Uses/// [astronomical year numbering](https://en.wikipedia.org/wiki/Astronomical_year_numbering)./// # use time::util::is_leap_year;/// assert!(!is_leap_year(1900));/// assert!(is_leap_year(2000));/// assert!(is_leap_year(2004));/// assert!(!is_leap_year(2005));/// assert!(!is_leap_year(2100));/// Get the number of calendar days in a given year./// The returned value will always be either 365 or 366./// # use time::util::days_in_year;/// assert_eq!(days_in_year(1900), 365);/// assert_eq!(days_in_year(2000), 366);/// assert_eq!(days_in_year(2004), 366);/// assert_eq!(days_in_year(2005), 365);/// assert_eq!(days_in_year(2100), 365);/// Get the number of weeks in the ISO year./// The returned value will always be either 52 or 53./// # use time::util::weeks_in_year;/// assert_eq!(weeks_in_year(2019), 52);/// assert_eq!(weeks_in_year(2020), 53);consume_any_identconsume_numberconsume_punctymd_to_yoywd_to_yoToTokenTreewith_spanspan_startspan_endMissingComponentExpectedStringUnexpectedEndOfInputparse_with_versionFormatDescriptionVersionproc_spanToTokenStreamdeclare_componentget_string_literaljan_weekday// irrelevant for proc macros// TODO removeVersionOrModuleNameModuleNameNO_EQUALS_IS_MOD_NAMEparse_format_description_versionquote_appendquote_groupquote_inner// Single or double symbols// Identifier// Literal// Lifetime// Groups// Interpolated values// TokenTree by default// Allow a TokenStream by request. It's more expensive, so avoid if possible.// Varies by feature flag combination._24/// Turn a type into a [`TokenStream`].impl_for_tree_typesimpl_for_intAlphaU8LengthU32AlphaRunAlphaRuns/// Sparse array of run-length-encoded alpha (supersampling coverage) values./// Sparseness allows us to independently compose several paths into the/// same AlphaRuns buffer.catch_overflow/// Returns 0-255 given 0-256./// Returns true if the scanline contains only a single run, of alpha value 0./// Reinitialize for a new scanline./// Insert into the buffer a run starting at (x-offset_x)./// if start_alpha > 0///     one pixel with value += start_alpha,///         max 255/// if middle_count > 0///     middle_count pixels with value += max_value/// if stop_alpha > 0///     one pixel with value += stop_alpha/// Returns the offset_x value that should be passed on the next call,/// assuming we're on the same scanline. If the caller is switching/// scanlines, then offset_x should be 0 when this is called.break_run/// Break the runs in the buffer at offsets x and x+count, properly/// updating the runs to the right and left./// i.e. from the state AAAABBBB, run-length encoded as A4B4,/// break_run(..., 2, 5) would produce AAAABBBB rle as A2A2B3B1./// Allows add() to sum another run to some of the new sub-runs./// i.e. adding ..CCCCC. would produce AADDEEEB, rle as A2D2E3B1.break_at/// Cut (at offset x in the buffer) a run into two shorter runs with/// matching alpha values./// Used by the RectClipBlitter to trim a RLE encoding to match the/// clipping rectangle.// Copyright 2006 The Android Open Source Project// Copyright 2020 Yevhenii Reizner// Use of this source code is governed by a BSD-style license that can be// found in the LICENSE file.BlendMode/// Replaces destination with zero: fully transparent./// Replaces destination./// Preserves destination.SourceOver/// Source over destination.DestinationOver/// Destination over source.SourceIn/// Source trimmed inside destination.DestinationIn/// Destination trimmed by source.SourceOut/// Source trimmed outside destination.DestinationOut/// Destination trimmed outside source.SourceAtop/// Source inside destination blended with destination.DestinationAtop/// Destination inside source blended with source./// Each of source and destination trimmed outside the other./// Sum of colors.Modulate/// Product of premultiplied colors; darkens destination./// Multiply inverse of pixels, inverting result; brightens destination./// Multiply or screen, depending on destination./// Darker of source and destination./// Lighter of source and destination./// Brighten destination to reflect source./// Darken destination to reflect source./// Multiply or screen, depending on source./// Lighten or darken, depending on source./// Subtract darker from lighter with higher contrast./// Subtract darker from lighter with lower contrast./// Multiply source with destination, darkening image./// Hue of source with saturation and luminosity of destination./// Saturation of source with hue and luminosity of destination./// Hue and saturation of source with luminosity of destination.Luminosity/// Luminosity of source with hue and saturation of destination./// A blending mode.should_pre_scale_coverageto_stageStageScreenIntRectalpha_runsrow_bytes/// Mask is used to describe alpha bitmaps.blit_h/// Blits a horizontal run of one or more pixels.blit_anti_h/// Blits a horizontal run of antialiased pixels./// runs[] is a *sparse* zero-terminated run-length encoding of spans of constant alpha values./// The runs[] and antialias[] work together to represent long runs of pixels with the same/// alphas. The runs[] contains the number of pixels with the same alpha, and antialias[]/// contain the coverage value for that number of pixels. The runs[] (and antialias[]) are/// encoded in a clever way. The runs array is zero terminated, and has enough entries for/// each pixel plus one, in most cases some of the entries will not contain valid data. An entry/// in the runs array contains the number of pixels (np) that have the same alpha value. The/// next np value is found np entries away. For example, if runs[0] = 7, then the next valid/// entry will by at runs[7]. The runs array and antialias[] are coupled by index. So, if the/// np entry is at runs[45] = 12 then the alpha value can be found at antialias[45] = 0x88./// This would mean to use an alpha value of 0x88 for the next 12 pixels starting at pixel 45.blit_v/// Blits a vertical run of pixels with a constant alpha value.blit_anti_h2blit_anti_v2blit_rect/// Blits a solid rectangle one or more pixels wide.blit_mask/// Blits a pattern of pixels defined by a rectangle-clipped mask.Blitter/// Blitter is responsible for actually writing pixels into memory./// Besides efficiency, they handle clipping and antialiasing./// An object that implements Blitter contains all the context needed to generate pixels/// for the destination and how src/generated pixels map to the destination./// The coordinates passed to the `blit_*` calls are in destination pixel space./// 8-bit type for an alpha value. 255 is 100% opaque, zero is 100% transparent.ALPHA_U8_TRANSPARENT/// Represents fully transparent AlphaU8 value.ALPHA_U8_OPAQUE/// Represents fully opaque AlphaU8 value.ALPHA_TRANSPARENT/// Represents fully transparent Alpha value.ALPHA_OPAQUE/// Represents fully opaque Alpha value.ColorU8/// A 32-bit RGBA color value./// Byteorder: RGBA (relevant for bytemuck casts)/// Creates a new color./// Returns color's red component./// Returns color's green component./// Returns color's blue component./// Returns color's alpha component./// Check that color is opaque./// Alpha == 255premultiply/// Converts into a premultiplied color./// A 32-bit premultiplied RGBA color value.// Perfectly safe, since [u8; 4] is already Pod./// A transparent color./// Creates a new premultiplied color./// RGB components must be <= alpha.from_rgba_unchecked/// The value is <= alpha.demultiply/// Returns a demultiplied color./// An RGBA color value, holding four floating point components./// - All values are in 0..=1 range.NV_ZERONV_ONE/// A black color./// A white color./// Creates a new color from 4 components./// All values must be in 0..=1 range.from_rgba8/// u8 will be divided by 255 to get the float component./// The value is guarantee to be in a 0..=1 range./// Sets the red component value./// The new value will be clipped to the 0..=1 range./// Sets the green component value./// Sets the blue component value./// Sets the alpha component value.apply_opacity/// Shifts color's opacity./// Essentially, multiplies color's alpha by opacity./// `opacity` will be clamped to the 0..=1 range first./// The final alpha will also be clamped./// Alpha == 1.0PremultipliedColorto_color_u8/// Converts into `ColorU8`./// A premultiplied RGBA color value, holding four floating point components./// - RGB components are <= A./// - The value is guarantee to be in a 0..=1 range./// - The value is <= alpha./// Converts into `PremultipliedColorU8`.premultiply_u8/// Return a*b/255, rounding any fractional bits.color_f32_to_u8premultiply_u8_opaquedemultiply_u8_1demultiply_u8_2demultiply_u8_3bytemuck_casts_rgbafixed_pointfdot16fdot6FDot16FDot6left_shiftMAX_COEFF_SHIFT/// We store 1<<shift in a (signed) byte, so its maximum value is 1<<6 == 64./// Note that this limits the number of lines we use to approximate a curve./// If we need to increase this, we need to store curve_count in something/// larger than i8.LineEdgeQuadraticEdgeCubicEdgeas_lineas_line_mut// Imitate a linked list.first_ylast_ywinding// 1 or -1is_verticalcurve_countcurve_shiftqx// applied to all dx/ddx/dddxqyqdxqdyqddxqddyq_last_xq_last_ydshift// applied to all dx/ddx/dddx except for dshift exception// applied to cdx and cdycdxcdycddxcddycdddxcdddyc_last_xc_last_ycompute_dy// This correctly favors the lower-pixel when y0 is on a 1/2 pixel boundarydiff_to_shiftcheap_distancefdot6_to_fixed_div2// In LineEdge::new, QuadraticEdge::new, CubicEdge::new, the first thing we do is to convert// the points into FDot6. This is modulated by the shift parameter, which// will either be 0, or something like 2 for antialiasing.// In the float case, we want to turn the float into .6 by saying pt * 64,// or pt * 256 for antialiasing. This is implemented as 1 << (shift + 6).// In the fixed case, we want to turn the fixed into .6 by saying pt >> 10,// or pt >> 8 for antialiasing. This is implemented as pt >> (10 - shift).fdot6_up_shiftcubic_delta_from_line// f(1/3) = (8a + 12b + 6c + d) / 27// f(2/3) = (a + 6b + 12c + 8d) / 27// f(1/3)-b = (8a - 15b + 6c + d) / 27// f(2/3)-c = (a + 6b - 15c + 8d) / 27// use 16/512 to approximate 1/27PathVerbedge_clipperEdgeClipperIterpath_geometryCombineTotalshiftedShiftedIntRectclip_shiftBasicEdgeBuilderbuild_edges// Skia returns a linked list here, but it's a nightmare to use in Rust,// so we're mimicking it with Vec.// TODO: build_polypush_linepush_quadpush_cubiccombine_verticaledge_iterPathEdgeIterPathEdgeQuadToCubicToverb_indexpoints_indexneeds_close_line/// Lightweight variant of PathIter that only returns segments (e.g. lines/quads)./// Does not return Move or Close. Always "auto-closes" each contour.close_line// Copyright 2011 Google Inc.NormalizedF32ExclusiveSCALAR_MAXedge_builderline_clippercopy_3_points// This is a fail-safe `arr[n..n+3].try_into().unwrap()` alternative.// Everything is checked at compile-time so there is no bound checking and panics.copy_4_pointsMAX_VERBS/// Max curvature in X and Y split cubic into 9 pieces, * (line + cubic).ClippedEdgescan_cull_to_the_rightEdgeClipperclip_linepush_vlineclip_quadclip_mono_quad// src[] must be monotonic in X and Yclip_cubicclip_mono_cubicquick_rejectsort_increasing_y// src[] must be monotonic in Y. This routine copies src into dst, and sorts// it to be increasing in Y. If it had to reverse the order of the points,// it returns true, otherwise it returns falsechop_quad_in_y/// Modifies pts[] in place so that it is clipped in Y to the clip rect.chop_mono_quad_at_xchop_mono_quad_at_ychop_mono_quad_attoo_big_for_reliable_float_mathchop_cubic_in_ychop_mono_cubic_at_xchop_mono_cubic_at_ymono_cubic_closest_t// Copyright 2009 The Android Open Source ProjectSaturateCastleft_shift64/// A 26.6 fixed point.FDot8/// A 24.8 fixed point./// A 16.16 fixed point.to_fdot16can_convert_to_fdot16small_scalefrom_fdot16// Extracted from SkScan_Antihair.cppfdot8// `from_f32` seems to lack a rounding step. For all fixed-point// values, this version is as accurate as possible for (fixed -> float -> fixed). Rounding reduces// accuracy if the intermediate floats are in the range that only holds integers (adding 0.5 to an// odd integer then snaps to nearest even). Using double for the rounding math gives maximum// accuracy for (float -> fixed -> float), but that's usually overkill.floor_to_i32ceil_to_i32round_to_i32// The divide may exceed 32 bits. Clamp to a signed 32 bit result.fast_div// Skia uses fixed points pretty chaotically, therefore we cannot use// strongly typed wrappers. Which is unfortunate.IntRectIntSize/// A screen `IntRect`./// - X and Y are in 0..=i32::MAX range./// - Width and height are in 1..=i32::MAX range./// - x+width and y+height does not overflow.from_xywh/// Creates a new `ScreenIntRect`.from_xywh_safe/// Returns rect's X position./// Returns rect's Y position./// Returns rect's width./// Returns rect's height.width_safe/// Returns rect's left edge./// Returns rect's top edge./// Returns rect's right edge./// The right edge is at least 1./// Returns rect's bottom edge./// The bottom edge is at least 1./// Returns rect's size./// Checks that the rect is completely includes `other` Rect.to_int_rect/// Converts into a `IntRect`.to_rect/// Converts into a `Rect`.screen_int_rect_teststo_screen_int_rect/// Converts the current size into a `IntRect` at a provided position.IntSizeExt/// Converts into `ScreenIntRect`./// # Checks/// - x >= 0/// - y >= 0IntRectExtblend_modeblitterpath64shaderswidepainterMaskTypeBYTES_PER_PIXELFilterQualityGradientStopSpreadModeNonZeroRectStrokeDashPathStroker/// An integer length that is guarantee to be > 0/*!
`tiny-skia` is a tiny [Skia](https://skia.org/) subset ported to Rust.

`tiny-skia` API is a bit unconventional.
It doesn't look like cairo, QPainter (Qt), HTML Canvas or even Skia itself.
Instead, `tiny-skia` provides a set of low-level drawing APIs
and a user should manage the world transform, clipping mask and style manually.

See the `examples/` directory for usage examples.
*/// Keep it under `pixmap` for a better order in the docs.MAX_POINTS/// Clip the line pts[0]...pts[1] against clip, ignoring segments that/// lie completely above or below the clip. For portions to the left or/// right, turn those into vertical line segments that are aligned to the/// edge of the clip./// Return the number of line segments that result, and store the end-points/// of those segments sequentially in lines as follows:/// 1st segment: lines[0]..lines[1]/// 2nd segment: lines[1]..lines[2]/// 3rd segment: lines[2]..lines[3]sect_with_horizontal/// Returns X coordinate of intersection with horizontal line at Y.is_between_unsorted/// Returns value between the two limits, where the limits are either ascending or descending.sect_clamp_with_verticalsect_with_vertical/// Returns Y coordinate of intersection with vertical line at X.pin_unsorted_f32pin_unsorted_f64/// Intersect the line segment against the rect. If there is a non-empty/// resulting segment, return true and set dst[] to that segment. If not,/// return false and ignore dst[]./// `clip` is specialized for scan-conversion, as it adds vertical/// segments on the sides to show where the line extended beyond the/// left or right sides. `intersect` does not.nested_ltcontains_no_empty_check// returns true if outer contains inner, even if inner is empty.DrawTilerRasterPipelineBlitterSubPixmapMut/// Transfers only the Alpha channel from `Pixmap` to `Mask`.Luminance/// Transfers RGB channels as luminance from `Pixmap` to `Mask`./// Formula: `Y = 0.2126 * R + 0.7152 * G + 0.0722 * B`/// A mask type./// A mask./// During drawing over `Pixmap`, mask's black (0) "pixels" would block rendering/// and white (255) will allow it./// Anything in between is used for gradual masking and anti-aliasing./// Unlike Skia, we're using just a simple 8bit alpha mask./// It's way slower, but easier to implement./// Creates a new mask by taking ownership over a mask buffer./// The size needs to match the data provided.from_pixmap/// Creates a new mask from a `PixmapRef`./// Returns mask's width./// Returns mask's height./// Returns mask's size./// Returns the internal data./// Returns the mutable internal data.as_submaskSubMaskRefsubmaskas_subpixmapsubpixmapdecode_png/// Loads a PNG file into a `Mask`./// Only grayscale images are supported.load_pngencode_png/// Encodes mask into a PNG data.save_png/// Saves mask as a PNG file.fill_path// Almost a direct copy of PixmapMut::fill_path/// Draws a filled path onto the mask./// In terms of RGB (no alpha) image, draws a white path on top of black mask./// Doesn't reset the existing mask content and draws the path on top of existing data./// If the above behavior is undesired, [`Mask::clear()`] should be called first./// This method is intended to be used for simple cases. For more complex masks/// prefer [`Mask::from_pixmap()`].intersect_path/// Intersects the provided path with the current clipping path./// A temporary mask with the same size as the current one will be created./// Inverts the mask./// Clears the mask./// Zero-fills the internal data buffer.mask_ctxMaskCtxLENGTH_U32_ONE// Perfectly safe.RasterPipelineBuilder/// Specifies that "inside" is computed by a non-zero sum of signed edge crossings./// Specifies that "inside" is computed by an odd number of edge crossings./// A path filling rule.shader/// A paint shader./// Default: black color/// Paint blending mode./// Default: SourceOveranti_alias/// Enables anti-aliased painting./// Default: trueforce_hq_pipeline/// Forces the high quality/precision rendering pipeline./// `tiny-skia`, just like Skia, has two rendering pipelines:/// one uses `f32` and another one uses `u16`. `u16` one is usually way faster,/// but less precise. Which can lead to slight differences./// By default, `tiny-skia` will choose the pipeline automatically,/// depending on a blending mode and other parameters./// But you can force the high quality one using this flag./// This feature is especially useful during testing./// Unlike high quality pipeline, the low quality one doesn't support all/// rendering stages, therefore we cannot force it like hq one./// Controls how a shape should be painted./// Sets a paint source to a solid color.set_color_rgba8/// `self.shader = Shader::SolidColor(Color::from_rgba8(50, 127, 150, 200));` shorthand.is_solid_color/// Checks that the paint source is a solid color.fill_rect/// Draws a filled rectangle onto the pixmap./// See [`PixmapMut::fill_rect`](struct.PixmapMut.html#method.fill_rect) for details./// Draws a filled path onto the pixmap./// See [`PixmapMut::fill_path`](struct.PixmapMut.html#method.fill_path) for details.stroke_path/// Strokes a path./// See [`PixmapMut::stroke_path`](struct.PixmapMut.html#method.stroke_path) for details.draw_pixmap/// Draws a `Pixmap` on top of the current `Pixmap`./// See [`PixmapMut::draw_pixmap`](struct.PixmapMut.html#method.draw_pixmap) for details./// Applies a masks./// See [`PixmapMut::apply_mask`](struct.PixmapMut.html#method.apply_mask) for details.// TODO: accept NonZeroRect?/// This function is usually slower than filling a rectangular path,/// but it produces better results. Mainly it doesn't suffer from weird/// clipping of horizontal/vertical edges./// Used mainly to render a pixmap onto a pixmap./// Returns `None` when there is nothing to fill or in case of a numeric overflow./// Stroking is implemented using two separate algorithms:/// 1. If a stroke width is wider than 1px (after applying the transformation),///    a path will be converted into a stroked path and then filled using `fill_path`.///    Which means that we have to allocate a separate `Path`, that can be 2-3x larger///    then the original path./// 2. If a stroke width is thinner than 1px (after applying the transformation),///    we will use hairline stroking, which doesn't involve a separate path allocation./// Also, if a `stroke` has a dash array, then path will be converted into/// a dashed path first and then stroked. Which means a yet another allocation.stroke_hairline/// A stroking for paths with subpixel/hairline width./// The same as filling a rectangle with a `pixmap` pattern./// When a `Mask` is passed to drawing methods, it will be used to mask-out/// content we're about to draw./// This method masks-out an already drawn content./// It's not as fast, but can be useful when a mask is not available during drawing./// This method is similar to filling the whole pixmap with an another,/// mask-like pixmap using the `DestinationOut` blend mode./// `Mask` must have the same size as `Pixmap`. No transform or offset are allowed.treat_as_hairlineis_too_big_for_math/// Sometimes in the drawing pipeline, we have to perform math on path coordinates, even after/// the path is in device-coordinates. Tessellation and clipping are two examples. Usually this/// is pretty modest, but it can involve subtracting/adding coordinates, or multiplying by/// small constants (e.g. 2,3,4). To try to preflight issues where these optionations could turn/// finite path values into infinities (or NaNs), we allow the upper drawing code to reject/// the path if its bounds (in device coordinates) is too close to max float./// Splits the target pixmap into a list of tiles./// Skia/tiny-skia uses a lot of fixed-point math during path rendering./// Probably more for precision than performance./// And our fixed-point types are limited by 8192 and 32768./// Which means that we cannot render a path larger than 8192 onto a pixmap./// When pixmap is smaller than 8192, the path will be automatically clipped anyway,/// but for large pixmaps we have to render in tiles.MAX_DIMENSIONS// 8K is 1 too big, since 8K << supersample == 32768 which is too big for Fixed.MAX_DIMpoint64Point64SearchAxisquad64Scalar64POINT_COUNTCubic64PairCubic64point_at_tsearch_rootsfind_inflections// give up when changing t no longer moves point// also, copy point rather than recompute it when it does changechop_atroots_valid_t// from SkGeometry.cpp (and Numeric Solutions, 5.6)roots_realfind_extrema// Cubic64'(t) = At^2 + Bt + C, where// A = 3(-a + 3(b - c) + d)// B = 6(a - 2b + c)// C = 3(b - a)// Solve for t, keeping only those that fit between 0 < t < 1cmp_f64// Skia doesn't seems to care about NaN/inf during sorting, so we don't too.interp_cubic_coords_x// classic one t subdivisioninterp_cubic_coords_y// Copyright 2012 Google Inc.cubic64horizontal_intersectvertical_intersect/*
Find the intersection of a line and cubic by solving for valid t values.

Analogous to line-quadratic intersection, solve line-cubic intersection by
representing the cubic as:
  x = a(1-t)^3 + 2b(1-t)^2t + c(1-t)t^2 + dt^3
  y = e(1-t)^3 + 2f(1-t)^2t + g(1-t)t^2 + ht^3
and the line as:
  y = i*x + j  (if the line is more horizontal)
or:
  x = i*y + j  (if the line is more vertical)

Then using Mathematica, solve for the values of t where the cubic intersects the
line:

  (in) Resultant[
        a*(1 - t)^3 + 3*b*(1 - t)^2*t + 3*c*(1 - t)*t^2 + d*t^3 - x,
        e*(1 - t)^3 + 3*f*(1 - t)^2*t + 3*g*(1 - t)*t^2 + h*t^3 - i*x - j, x]
  (out) -e     +   j     +
       3 e t   - 3 f t   -
       3 e t^2 + 6 f t^2 - 3 g t^2 +
         e t^3 - 3 f t^3 + 3 g t^3 - h t^3 +
     i ( a     -
       3 a t + 3 b t +
       3 a t^2 - 6 b t^2 + 3 c t^2 -
         a t^3 + 3 b t^3 - 3 c t^3 + d t^3 )

if i goes to infinity, we can rewrite the line in terms of x. Mathematica:

  (in) Resultant[
        a*(1 - t)^3 + 3*b*(1 - t)^2*t + 3*c*(1 - t)*t^2 + d*t^3 - i*y - j,
        e*(1 - t)^3 + 3*f*(1 - t)^2*t + 3*g*(1 - t)*t^2 + h*t^3 - y,       y]
  (out)  a     -   j     -
       3 a t   + 3 b t   +
       3 a t^2 - 6 b t^2 + 3 c t^2 -
         a t^3 + 3 b t^3 - 3 c t^3 + d t^3 -
     i ( e     -
       3 e t   + 3 f t   +
       3 e t^2 - 6 f t^2 + 3 g t^2 -
         e t^3 + 3 f t^3 - 3 g t^3 + h t^3 )

Solving this with Mathematica produces an expression with hundreds of terms;
instead, use Numeric Solutions recipe to solve the cubic.

The near-horizontal case, in terms of:  Ax^3 + Bx^2 + Cx + D == 0
    A =   (-(-e + 3*f - 3*g + h) + i*(-a + 3*b - 3*c + d)     )
    B = 3*(-( e - 2*f +   g    ) + i*( a - 2*b +   c    )     )
    C = 3*(-(-e +   f          ) + i*(-a +   b          )     )
    D =   (-( e                ) + i*( a                ) + j )

The near-vertical case, in terms of:  Ax^3 + Bx^2 + Cx + D == 0
    A =   ( (-a + 3*b - 3*c + d) - i*(-e + 3*f - 3*g + h)     )
    B = 3*( ( a - 2*b +   c    ) - i*( e - 2*f +   g    )     )
    C = 3*( (-a +   b          ) - i*(-e +   f          )     )
    D =   ( ( a                ) - i*( e                ) - j )

For horizontal lines:
(in) Resultant[
      a*(1 - t)^3 + 3*b*(1 - t)^2*t + 3*c*(1 - t)*t^2 + d*t^3 - j,
      e*(1 - t)^3 + 3*f*(1 - t)^2*t + 3*g*(1 - t)*t^2 + h*t^3 - y, y]
(out)  e     -   j     -
     3 e t   + 3 f t   +
     3 e t^2 - 6 f t^2 + 3 g t^2 -
       e t^3 + 3 f t^3 - 3 g t^3 + h t^3
*/// Must be first, because of macro scope rules.line_cubic_intersectionsDBL_EPSILON_ERRFLT_EPSILON_HALFFLT_EPSILON_CUBEDFLT_EPSILON_INVERSEprecisely_zeroapproximately_zero_or_moreapproximately_one_or_lessapproximately_zeroapproximately_zero_inverseapproximately_zero_cubedapproximately_zero_halfapproximately_zero_when_compared_toapproximately_equalapproximately_equal_halfalmost_dequal_ulps// Works just like SkTPin, returning `max` for NaN/inf/// Returns true if (a <= self <= b) || (a >= self >= b).// Use this for comparing Ts in the range of 0 to 1. For general numbers (larger and smaller) use// AlmostEqualUlps instead.cube_roothalley_cbrt3d// cube root approximation using 3 iterations of Halley's method (double)cbrt_5d// cube root approximation using bit hack for 64-bit float// adapted from Kahan's cbrtcbrta_halleyd// iterative cube root approximation using Halley's method (double)// The code below is from SkPathOpsTypes.from_xyaxis_coordpush_valid_ts// note: caller expects multiple results to be sorted smaller first// note: http://en.wikipedia.org/wiki/Loss_of_significance has an interesting//  analysis of the quadratic equation, suggesting why the following looks at//  the sign of B -- and further suggesting that the greatest loss of precision//  is in b squared less two a c// Numeric Solutions (5.6) suggests to solve the quadratic by computing//     Q = -1/2(B + sgn(B)Sqrt(B^2 - 4 A C))// and using the roots//     t1 = Q / A//     t2 = C / Q// this does not discard real roots <= 0 or >= 1handle_zerochop_cubic_at2chop_quad_atfind_cubic_max_curvaturefind_unit_quad_rootsnew_t_valuesCubicCoeffQuadCoeffvalid_unit_dividechop_quad_at_x_extrema// TODO: return custom type/// Returns 0 for 1 quad, and 1 for two quads, either way the answer is stored in dst[]./// Guarantees that the 1/2 quads will be monotonic.chop_quad_at_y_extremais_not_monotonicchop_cubic_at_x_extremachop_cubic_at_y_extrema/// Given 4 points on a cubic bezier, chop it into 1, 2, 3 beziers such that/// the resulting beziers are monotonic in Y./// This is called by the scan converter./// Depending on what is returned, dst[] is treated as follows:/// - 0: dst[0..3] is the original cubic/// - 1: dst[0..3] and dst[3..6] are the two new cubics/// - 2: dst[0..3], dst[3..6], dst[6..9] are the three new cubicsfind_cubic_extrema// Cubic'(t) = At^2 + Bt + C, wherechop_cubic_at// http://code.google.com/p/skia/issues/detail?id=32// This test code would fail when we didn't check the return result of// valid_unit_divide in SkChopCubicAt(... NormalizedF32Exclusives[], int roots). The reason is// that after the first chop, the parameters to valid_unit_divide are equal// (thanks to finite float precision and rounding in the subtracts). Thus// even though the 2nd NormalizedF32Exclusive looks < 1.0, after we renormalize it, we end// up with 1.0, hence the need to check and just return the last cubic as// a degenerate clump of 4 points in the same place.chop_cubic_at_max_curvaturecubic_dchop_at_interceptchop_cubic_at_y_extrema_1RasterPipelinepixmap_srcmemset2d_colorblit_anti_h_rpblit_rect_rpblit_mask_rpis_mask// Copyright 2016 Google Inc.f32x8i32x8STAGE_WIDTHStageFnpixmap_dst// TODO: remove mutaa_mask_ctxAAMaskCtxdrdgdanext_stageSTAGESSTAGES_COUNT// Must be in the same order as raster_pipeline::Stagemove_source_to_destinationmove_destination_to_sourceclamp_0clamp_auniform_colorseed_shaderload_dstload_dst_tailstore_tailload_dst_u8// Currently, all mask/A8 pixmaps are handled by lowp.load_dst_u8_tailstore_u8store_u8_tailgathergather_ixulp_subload_mask_u8mask_u8scale_u8lerp_u8scale_1_floatlerp_1_floatblend_fnsource_atopdestination_atopsource_indestination_insource_outdestination_outsource_overdestination_overmodulate// Wants a type for some reason.blend_fn2darkenlightenexclusioncolor_burncolor_dodgehard_lightsoft_lightblend_fn3huehue_ksaturationsaturation_kcolor_kluminosityluminosity_ksatlumset_satset_lumclip_colorsource_over_rgbasource_over_rgba_tailexclusive_reflectexclusive_repeatbilinearbicubicbicubic_nearbicubic_farsampler_2x2SamplerCtxsampler_4x4pad_x1reflect_x1repeat_x1gradient_lookupGradientCtxevenly_spaced_2_stop_gradientxy_to_radiusxy_to_2pt_conical_focal_on_circlexy_to_2pt_conical_well_behavedxy_to_2pt_conical_greatermask_2pt_conical_degeneratesapply_vector_maskjust_returnload_8888load_8888_tailstore_8888store_8888_tailunnormtwomad// Copyright 2018 Google Inc./*!
A high precision raster pipeline implementation.

Unlike lowp, this one implements all stages.

Just like Skia, this pipeline is implemented using f32x8.

For some reason, we are almost 2x slower. Maybe because Skia uses clang's vector extensions
and we're using a manual implementation.
*/// We're basing our implementation of non-separable blend modes on//   https://www.w3.org/TR/compositing-1/#blendingnonseparable.// and//   https://www.khronos.org/registry/OpenGL/specs/es/3.2/es_spec_3.2.pdf// They're equivalent, but ES' math has been better simplified.// Anything extra we add beyond that is to make the math work with premul inputs.// Tile x or y to [0,limit) == [0,limit - 1 ulp] (think, sampling from images).// The gather stages will hard clamp the output of these stages to [0,limit)...// we just need to do the basic repeat or mirroring.// In bicubic interpolation, the 16 pixels and +/- 0.5 and +/- 1.5 offsets from the sample// pixel center are combined with a non-uniform cubic filter, with higher values near the center.// We break this function into two parts, one for near 0.5 offsets and one for far 1.5 offsets.u16x16f32x16fn_ptr_eq// Similar to mask_u8, but only loads the mask values without actually masking the pipeline.// We are using u16 for index, not u32 as Skia, to simplify the code a bit.// The gradient creation code will not allow that many stops anyway.round_f32_to_u16null_fnload_8div255/*!
A low precision raster pipeline implementation.

A lowp pipeline uses u16 instead of f32 for math.
Because of that, it doesn't implement stages that require high precision.
The pipeline compiler will automatically decide which one to use.

Skia uses u16x8 (128bit) types for a generic CPU and u16x16 (256bit) for modern x86 CPUs.
But instead of explicit SIMD instructions, it mainly relies on clang's vector extensions.
And since they are unavailable in Rust, we have to do everything manually.

According to our benchmarks, a SIMD-accelerated u16x8 in Rust is almost 2x slower than in Skia.
Not sure why. For example, there are no div instruction for u16x8, so we have to use
a basic scalar version. Which means unnecessary load/store. No idea what clang does in this case.
Surprisingly, a SIMD-accelerated u16x8 is even slower than a scalar one. Again, not sure why.

Therefore we are using scalar u16x16 by default and relying on rustc/llvm auto vectorization instead.
When targeting a generic CPU, we're just 5-10% slower than Skia. While u16x8 is 30-40% slower.
And while `-C target-cpu=haswell` boosts our performance by around 25%,
we are still 40-60% behind Skia built for Haswell.

On ARM AArch64 the story is different and explicit SIMD make our code up to 2-3x faster.
*/highplowpMAX_STAGESMoveSourceToDestinationMoveDestinationToSourceClamp0ClampAPremultiplyUniformColorSeedShaderLoadDestinationLoadDestinationU8StoreU8GatherLoadMaskU8MaskU8ScaleU8LerpU8Scale1FloatLerp1FloatSourceOverRgbaBicubicPadX1ReflectX1RepeatX1EvenlySpaced2StopGradientXYToRadiusXYTo2PtConicalFocalOnCircleXYTo2PtConicalWellBehavedXYTo2PtConicalGreaterMask2PtConicalDegeneratesApplyVectorMaskslice_at_xyslice_mask_at_xyslice4_at_xyslice16_at_xyslice16_mask_at_xy// can be zero// mask offset/position in pixmap coordinatescopy_at_xycurrent_coverageUniformColorCtxEvenlySpaced2StopGradientCtxtwo_point_conical_gradientTwoPointConicalGradientCtxlimit_xTileCtxlimit_yspread_modeinv_widthinv_height// [0,255] in a 16-bit lane.GradientColor// A gradient color is an unpremultiplied RGBA not in a 0..1 range.// It basically can have any float value.factor/// This value stores the actual colors count./// `factors` and `biases` must store at least 16 values,/// since this is the length of a lowp pipeline stage./// So any any value past `len` is just zeros.factorsbiasest_valuespush_const_color// This context is used only in highp, where we use Tx4.p0inv_scale// cache of 1/scalestagesset_force_hq_pipelinepush_transformpush_uniform_colorRasterPipelineKindtail_functionstest_blendtest_blend_lowptest_blend_highpclear_lowpdestination_lowp// Source is a no-opsource_over_lowpdestination_over_lowpsource_in_lowpdestination_in_lowpsource_out_lowpdestination_out_lowpsource_atop_lowpdestination_atop_lowpxor_lowpplus_lowpmodulate_lowpscreen_lowpoverlay_lowpdarken_lowplighten_lowphard_light_lowp// ColorDodge in not available for lowp.// ColorBurn in not available for lowp.difference_lowp// SoftLight in not available for lowp.exclusion_lowpmultiply_lowpclear_highpdestination_highpsource_over_highpdestination_over_highpsource_in_highpdestination_in_highpsource_out_highpdestination_out_highpsource_atop_highpdestination_atop_highpxor_highpplus_highpmodulate_highpscreen_highpoverlay_highpdarken_highplighten_highpcolor_dodge_highpcolor_burn_highphard_light_highpsoft_light_highpdifference_highpexclusion_highpmultiply_highphue_highpsaturation_highpcolor_highpluminosity_highp// Test blending modes.// Skia has two kinds of a raster pipeline: high and low precision.// "High" uses f32 and "low" uses u16.// And for basic operations we don't need f32 and u16 simply faster.// But those modes are not identical. They can produce slightly different results// due rounding.// Hue in not available for lowp.// Saturation in not available for lowp.// Color in not available for lowp.// Luminosity in not available for lowp.blend_tests/*!
A raster pipeline implementation.

Despite having a lot of changes compared to `SkRasterPipeline`,
the core principles are the same:

1. A pipeline consists of stages.
1. A pipeline has a global context shared by all stages.
   Unlike Skia, were each stage has it's own, possibly shared, context.
1. Each stage has a high precision implementation. See `highp.rs`.
1. Some stages have a low precision implementation. See `lowp.rs`.
1. Each stage calls the "next" stage after its done.
1. During pipeline "compilation", if **all** stages have a lowp implementation,
   the lowp pipeline will be used. Otherwise, the highp variant will be used.
1. The pipeline "compilation" produces a list of function pointer.
   The last pointer is a pointer to the "return" function,
   which simply stops the execution of the pipeline.

This implementation is a bit tricky, but it gives the maximum performance.
A simple and straightforward implementation using traits and loops, like:

```ignore
trait StageTrait {
    fn apply(&mut self, pixels: &mut [Pixel]);
}

let stages: Vec<&mut dyn StageTrait>;
for stage in stages {
    stage.apply(pixels);
}
```

will be at least 20-30% slower. Not really sure why.

Also, since this module is all about performance, any kind of branching is
strictly forbidden. All stage functions must not use `if`, `match` or loops.
There are still some exceptions, which are basically an imperfect implementations
and should be optimized out in the future.
*/// More than enough./// Number of bytes per pixel./// A container that owns premultiplied RGBA pixels./// The data is not aligned, therefore width == stride./// Allocates a new pixmap./// A pixmap is filled with transparent black by default, aka (0, 0, 0, 0)./// Zero size in an error./// Pixmap's width is limited by i32::MAX/4./// Creates a new pixmap by taking ownership over an image buffer/// (premultiplied RGBA pixels)./// Decodes a PNG data into a `Pixmap`./// Only 8-bit images are supported./// Index PNGs are not supported./// Loads a PNG file into a `Pixmap`./// Encodes pixmap into a PNG data./// Saves pixmap as a PNG file./// Returns a container that references Pixmap's data./// Returns pixmap's width./// Returns pixmap's height./// Returns pixmap's size./// Fills the entire pixmap with a specified color./// Byteorder: RGBA/// Returns a pixel color./// Returns `None` when position is out of bounds./// Returns a mutable slice of pixels./// Returns a slice of pixels./// Consumes the internal data.clone_rect/// Returns a copy of the pixmap that intersects the `rect`./// Returns `None` when `Pixmap`'s rect doesn't contain `rect`./// A container that references premultiplied RGBA pixels./// Can be created from `Pixmap` or from a user provided data./// Creates a new `PixmapRef` from bytes./// The size must be at least `size.width() * size.height() * BYTES_PER_PIXEL`./// Zero size in an error. Width is limited by i32::MAX/4./// The `data` is assumed to have premultiplied RGBA pixels (byteorder: RGBA)./// Creates a new `Pixmap` from the current data./// Clones the underlying data./// Returns pixmap's rect.// TODO: add rows() iterator/// A container that references mutable premultiplied RGBA pixels./// Creates a new `PixmapMut` from bytes./// Creates `SubPixmapMut` that contains the whole `PixmapMut`./// Returns a mutable reference to the pixmap region that intersects the `rect`./// A `PixmapMut` subregion./// Unlike `PixmapMut`, contains `real_width` which references the parent `PixmapMut` width./// This way we can operate on a `PixmapMut` subregion without reallocations./// Primarily required because of `DrawTiler`./// We cannot implement it in `PixmapMut` directly, because it will brake `fill`, `data_mut`/// `pixels_mut` and other similar methods./// This is because `SubPixmapMut.data` references more "data" than it actually allowed to access./// On the other hand, `PixmapMut.data` can access all it's data and it's stored linearly.min_row_bytes/// Returns minimum bytes per row as usize./// Pixmap's maximum value for row bytes must fit in 31 bits.compute_data_len/// Returns storage size required by pixel array.data_len_for_sizef32x2FLOAT_PILineProcMAX_CUBIC_SUBDIVIDE_LEVELMAX_QUAD_SUBDIVIDE_LEVELhair_line_rgnstroke_path_implextend_pts/// Extend the points in the direction of the starting or ending tangent by 1/2 unit to/// account for a round or square cap./// If there's no distance between the end point and/// the control point, use the next control point to create a tangent. If the curve/// is degenerate, move the cap out 1/2 unit horizontally.hair_quadcompute_nocheck_quad_boundsgeometric_overlapgeometric_containshair_quad2compute_quad_levelcompute_int_quad_disthair_cubiccompute_nocheck_cubic_boundsquick_cubic_niceness_check// The off-curve points are "inside" the limits of the on-curve points.lt_90hair_cubic2compute_cubic_segmentsFixedRectfrom_rectalpha_mul/// Multiplies value by 0..256, and shift the result down 8/// (i.e. return (value * alpha256) >> 8)fill_fixed_rectfill_dot8do_scanlinecall_hline_blitteranti_hair_line_rgnBlitterKindHLineHorishVLineVertishdo_anti_hairlinebad_int// returns high-bit set if x == 0x8000any_bad_intscontribution_64// We want the fractional part of ordinate, but we want multiples of 64 to// return 64, not 0, so we can't just say (ordinate & 63).// We basically want to compute those bits, and if they're 0, return 64.// We can do that w/o a branch with an extra sub and add.draw_capAntiHairBlitterHLineAntiHairBlitterHorishAntiHairBlitterVLineAntiHairBlitterVertishAntiHairBlitteri32_to_alphaRectClipBlittercompute_anti_width// Copyright 2011 The Android Open Source Projecthairlinehairline_aapath_aafill_int_rectfill_rect_aaconservative_round_to_int// Conservative rounding function, which effectively nudges the int-rect to be slightly larger// than Rect::round() might have produced. This is a safety-net for the scan-converter, which// inspects the returned int-rect, and may disable clipping (for speed) if it thinks all of the// edges will fit inside the clip's bounds. The scan-converter introduces slight numeric errors// due to accumulated += of the slope, so this function is used to return a conservatively large// int-bounds, and thus we will only disable clipping if we're sure the edges will stay in-bounds.CONSERVATIVE_ROUND_BIAS// Bias used for conservative rounding of float rects to int rects, to nudge the irects a little// larger, so we don't "think" a path's bounds are inside a clip, when (due to numeric drift in// the scan-converter) we might walk beyond the predicted limits.// This value has been determined trial and error: pick the smallest value (after the 0.5) that// fixes any problematic cases (e.g. crbug.com/844457)// NOTE: cubics appear to be the main reason for needing this slop. If we could (perhaps) have a// more accurate walker for cubics, we may be able to reduce this fudge factor.round_down_to_int// Round the value down. This is used to round the top and left of a rectangle,// and corresponds to the way the scan converter treats the top and left edges.// It has a slight bias to make the "rounded" int smaller than a normal round, to create a more// conservative int-bounds (larger) from a float rect.round_up_to_int// Round the value up. This is used to round the right and bottom of a rectangle.fill_path_implwalk_edges// TODO: simplify!backward_insert_edge_based_on_xinsert_edge_afterbackward_insert_start// Start from the right side, searching backwards for the point to begin the new edge list// insertion, marching forwards from here. The implementation could have started from the left// of the prior insertion, and search to the right, or with some additional caching, binary// search the starting point. More work could be done to determine optimal new edge insertion.insert_new_edgesSUPERSAMPLE_SHIFT/// controls how much we super-sample (when we use that scan conversion)rect_overflows_short_shift// Would any of the coordinates of this rectangle not fit in a short,// when left-shifted by shift?overflows_short_shiftreal_blittercurr_iy/// Current y coordinate, in destination coordinates./// Widest row of region to be blitted, in destination coordinates./// Leftmost x coordinate in any row, in destination coordinates.super_left/// Leftmost x coordinate in any row, in supersampled coordinates.curr_y/// Current y coordinate in supersampled coordinates./// Initial y coordinate (top of bounds).BaseSuperBlitterSuperBlitter/// Once `runs` contains a complete supersampled row, flush() blits/// it out through the wrapped blitter./// Blits a row of pixels, with location and width specified/// in supersampled coordinates.coverage_to_partial_alpha// coverage_to_partial_alpha() is being used by AlphaRuns, which// *accumulates* SCALE pixels worth of "alpha" in [0,(256/SCALE)]// to produce a final value in [0, 255] and handles clamping 256->255// itself, with the same (alpha - (alpha >> 8)) correction as// coverage_to_exact_alpha().DEGENERATE_THRESHOLD// The default SCALAR_NEARLY_ZERO threshold of .0024 is too big and causes regressions for svg// gradients defined in the wild./// A gradient point./// Creates a new gradient point./// `position` will be clamped to a 0..=1 range.stopspoints_to_unitcolors_are_opaquehas_uniform_stopspush_stages/// A linear gradient shader./// Creates a new linear gradient shader./// Returns `Shader::SolidColor` when:/// - `stops.len()` == 1/// - `start` and `end` are very close/// - `stops` is empty/// - `start` == `end`/// - `transform` is not invertiblepoints_to_unit_tsaverage_gradient_colorts_from_sin_cos_atsdotlinear_gradientradial_gradient/// Replicate the edge color if the shader draws outside of its/// original bounds./// Repeat the shader's image horizontally and vertically, alternating/// mirror images so that adjacent images always seam./// Repeat the shader's image horizontally and vertically./// A shader spreading mode.SolidColor/// A solid color shader./// A radial gradient shader./// A pattern shader./// A shader specifies the source color(s) for what is being drawn./// If a paint has no shader, then the paint's color is used. If the paint has a/// shader, then the shader's color(s) are use instead, but they are/// modulated by the paint's alpha. This makes it easy to create a shader/// once (e.g. bitmap tiling or gradient) and then change its transparency/// without having to modify the original shader. Only the paint's alpha needs/// to be modified./// Checks if the shader is guaranteed to produce only opaque colors./// If this returns false, then we draw nothing (do not fall back to shader context)/// Transforms the shader./// Shifts shader's opacity./// `opacity` will be clamped to the 0..=1 range./// This is roughly the same as Skia's `SkPaint::setAlpha`./// Unlike Skia, we do not support global alpha/opacity, which is in Skia/// is set via the alpha channel of the `SkPaint::fColor4f`./// Instead, you can shift the opacity of the shader to whatever value you need./// - For `SolidColor` this function will multiply `color.alpha` by `opacity`./// - For gradients this function will multiply all colors by `opacity`./// - For `Pattern` this function will multiply `Patter::opacity` by `opacity`.// Unlike Skia, we do not have is_constant, because we don't have Color shaders./// Nearest-neighbor. Low quality, but fastest./// Bilinear./// Bicubic. High quality, but slow./// Controls how much filtering to be done when transforming images./// Pixmap opacity./// Must be in 0..=1 range./// Default: 1.0/// Pixmap blending mode./// Specifies how much filtering to be done when transforming images./// Default: Nearest/// Controls how a pixmap should be blended./// Like `Paint`, but for `Pixmap`./// Essentially a `SkImageShader`./// Unlike Skia, we do not support FilterQuality::Medium, because it involves/// mipmap generation, which adds too much complexity./// Creates a new pattern shader.// r1 after mapping focal point to (0, 0)FocalDatais_focal_on_circle// Whether the focal point (0, 0) is on the end circle with center (1, 0) and radius r1. If// this is true, it's as if an aircraft is flying at Mach 1 and all circles (soundwaves)// will go through the focal point (aircraft). In our previous implementations, this was// known as the edge case where the inside circle touches the outside circle (on the focal// point). If we were to solve for t bruteforcely using a quadratic equation, this case// implies that the quadratic equation degenerates to a linear equation.is_well_behavedfocal_data/// This is not `SkRadialGradient` like in Skia, but rather `SkTwoPointConicalGradient`/// without the start radius./// Creates a new radial gradient shader./// - `radius` <= 0ts_from_poly_to_polyfrom_poly2cmp_gtsave_to_u16x16// This method is too heavy and shouldn't be inlined.i32x4f32x4cmp_eqcmp_necmp_gecmp_lecmp_ltround_inttrunc_intrecip_fastrecip_sqrt// Based on https://github.com/Lokathor/wide (Zlib)to_i32x8_bitcastto_u32x8_bitcastto_f32x4to_f32x4_bitcastto_f32x8to_f32x8_bitcastf32x16_tf32x4_tf32x8_ti32x4_ti32x8_tu16x16_tu32x4_tu32x8_tgeneric_bit_blendfaster_minfaster_maxFasterMinMax/// A faster and more forgiving f32 min/max implementation./// Unlike std one, we do not care about NaN.// This module was written from scratch, therefore there is no Google copyright.// f32x16, i32x16 and u32x16 are implemented as [Tx8; 2] and not as [T; 16].// This way we still can use some SIMD.// We doesn't use #[inline] that much in this module.// The compiler will inline most of the methods automatically.// The only exception is U16x16, were we have to force inlining,// otherwise the performance will be horrible.impl_u16x16_op// No need to use explicit 256bit AVX2 SIMD.// `-C target-cpu=native` will autovectorize it better than us.// Not even sure why explicit instructions are so slow...// On ARM AArch64 we can actually get up to 2x performance boost by using SIMD.// We also have to inline all the methods. They are pretty large,// but without the inlining the performance is plummeting.// unused when AVX is availablefloating_pointpath_builderinterval_lenfirst_lenfirst_index// TODO: PositiveF32/// A stroke dashing properties./// Contains an array of pairs, where the first number indicates an "on" interval/// and the second one indicates an "off" interval;/// a dash offset value and internal properties./// - The dash array always have an even number of values./// - All dash array values are finite and >= 0./// - There is at least two dash array values./// - The sum of all dash array values is positive and finite./// - Dash offset is finite./// Creates a new stroke dashing object.bug_26adjust_dash_offset// Adjust phase to be between 0 and len, "flipping" phase if negative.// e.g., if len is 100, then phase of -20 (or -120) is equivalent to 80.find_first_interval/// Converts the current path into a dashed one./// `resolution_scale` can be obtained via/// [`compute_resolution_scale`](crate::PathStroker::compute_resolution_scale)./// Returns `None` when more than 1_000_000 dashes had to be produced/// or when the final path has an invalid bounding box.dash_implMAX_T_VALUEContourMeasureIterContourMeasure// If it encounters a zero-length contour, it is skipped.SegmentTypepoint_index// total distance up to this pointt_value// index into the ContourMeasure::points arrayscalar_tpush_segmentdistance_to_segmentcompute_line_segcompute_quad_segscompute_cubic_segsfind_segmentcompute_pos_tansegment_tot_span_big_enoughquad_too_curvycubic_too_curvycheap_dist_exceeds_limit/// Linearly interpolate between A and B, based on t./// If t is 0, return A. If t is 1, return B else interpolate.interp_safe// Copyright 2014 Google Inc.// This module is a mix of SkDashPath, SkDashPathEffect, SkContourMeasure and SkPathMeasure.// Right now, there are no visible benefits of using SIMD for f32x2. So we don't./// A pair of f32 numbers./// Mainly for internal use. Do not rely on it!/// Creates a new pair./// Creates a new pair from a single value./// Returns an absolute value./// Returns a minimum value./// Returns a maximum value.max_component/// Returns a maximum of both values./// Returns the first value./// Returns the second value.pmaxpmin// A faster and more forgiving f32 min/max implementation.// Unlike std one, we do not care about NaN.// Right now, there are no visible benefits of using SIMD for f32x4. So we don't.MAX_I32_FITS_IN_F32MIN_I32_FITS_IN_F32saturate_from/// Return the closest integer for the given float.// TODO: is there an std alternative?/// Custom float to integer conversion routines./// Returns MAX_I32_FITS_IN_F32 for NaN./// Return the closest integer for the given double./// Returns i32::MAX for NaN.saturate_floorsaturate_ceilsaturate_roundSaturateRound/// Custom float to integer rounding routines.f32_as_2s_compliment/// Return the float as a 2s compliment int. Just to be used to compare floats/// to each other or against positive float-bit-constants (like 0). This does/// not return the int equivalent of the float, just something cheaper for/// compares-only.sign_bit_to_2s_compliment/// Convert a sign-bit int (i.e. float interpreted as int) into a 2s compliement/// int. This also converts -0 (0x80000000) to 0. Doing this to a float allows/// it to be compared using normal C operators (<, <=, etc.)/// An immutable `f32` that is larger than 0 but less then 1./// Just a random, valid number./// A predefined 0.5 value./// Creates a `NormalizedF32Exclusive`./// Creates a `NormalizedF32Exclusive` clamping the given value.to_normalizedf32x2_tstroker/// A point./// Doesn't guarantee to be finite./// Creates a new `Point`.from_f32x2/// Creates a new `Point` from `f32x2`.to_f32x2/// Converts a `Point` into a `f32x2`./// Creates a point at 0x0 position./// Returns true if x and y are both zero./// Returns true if both x and y are measurable values./// Both values are other than infinities and NaN.almost_equal/// Checks that two `Point`s are almost equal.equals_within_tolerance/// Checks that two `Point`s are almost equal using the specified tolerance./// Scales (fX, fY) so that length() returns one, while preserving ratio of fX to fY,/// If prior length is nearly zero, sets vector to (0, 0) and returns/// false; otherwise returns true.set_normalize/// Sets vector to (x, y) scaled so length() returns one, and so that (x, y)/// is proportional to (x, y)./// If (x, y) length is nearly zero, sets vector to (0, 0) and returns false;/// otherwise returns true.can_normalize/// Returns the Euclidean distance from origin./// Scales vector so that distanceToOrigin() returns length, if possible./// If former length is nearly zero, sets vector to (0, 0) and return false;set_length_from/// Sets vector to (x, y) scaled to length, if possible./// Returns the dot product of two points./// Returns the cross product of vector and vec./// Vector and vec form three-dimensional vectors with z-axis value equal to zero./// The cross product is a three-dimensional vector with x-axis and y-axis values/// equal to zero. The cross product z-axis component is returned.distance_to_sqdlength_sqd/// Scales Point in-place by scale.swap_coordsrotate_cwrotate_ccwset_point_length// We have to worry about 2 tricky conditions:// 1. underflow of mag2 (compared against nearlyzero^2)// 2. overflow of mag2 (compared w/ isfinite)// If we underflow, we return false. If we overflow, we compute again using// doubles, which is much slower (3x in a desktop test) but will not overflow.//! A [tiny-skia](https://github.com/RazrFalcon/tiny-skia) Bezier path implementation.//! Provides a memory-efficient Bezier path container, path builder, path stroker and path dasher.//! Also provides some basic geometry types, but they will be moved to an external crate eventually.//! Note that all types use single precision floats (`f32`), just like [Skia](https://skia.org/)./// A path verb.verbs/// A Bezier path./// Can be created via [`PathBuilder`]./// Where [`PathBuilder`] can be created from the [`Path`] using [`clear`] to reuse the allocation./// Path is immutable and uses compact storage, where segment types and numbers are stored/// separately. Use can access path segments via [`Path::verbs`] and [`Path::points`],/// or via [`Path::segments`]/// - Has a valid, precomputed bounds./// - All points are finite./// - Has at least two segments./// - Each contour starts with a MoveTo./// - No duplicated Move./// - No duplicated Close./// - Zero-length contours are allowed./// [`PathBuilder`]: struct.PathBuilder.html/// [`clear`]: struct.Path.html#method.clear/// Returns the number of segments in the path./// Return if the path is empty./// Returns the bounds of the path's points./// The value is already calculated.compute_tight_bounds/// Calculates path's tight bounds./// This operation can be expensive./// Returns an internal vector of verbs./// Returns an internal vector of points./// Returns a transformed in-place path./// Some points may become NaN/inf therefore this method can fail./// Returns an iterator over path's segments./// Clears the path and returns a `PathBuilder` that will reuse an allocated memory.compute_quad_extremascompute_cubic_extremas/// A path segment.is_auto_closelast_move_tolast_point/// A path segments iterator.set_auto_close/// Sets the auto closing mode. Off by default./// When enabled, emits an additional `PathSegment::Line` from the current position/// to the previous `PathSegment::Move`. And only then emits `PathSegment::Close`.auto_closehas_valid_tangentcurr_verb/// Returns the current verb.next_verb/// Returns the next verb.SCALAR_ROOT_2_OVER_2PathDirectionCW/// Clockwise direction for adding closed contours.CCW/// Counter-clockwise direction for adding closed contours.last_move_to_indexmove_to_required/// A path builder./// Creates a new builder with a specified capacity./// Number of points depends on a verb type:/// - Move - 1/// - Line - 1/// - Quad - 2/// - Cubic - 3/// - Close - 0/// Creates a new `Path` from `Rect`./// Never fails since `Rect` is always valid./// Segments are created clockwise: TopLeft -> TopRight -> BottomRight -> BottomLeft/// The contour is closed.from_circle/// Creates a new `Path` from a circle./// See [`PathBuilder::push_circle`] for details.from_oval/// Creates a new `Path` from an oval./// See [`PathBuilder::push_oval`] for details./// Returns the current number of segments in the builder./// Checks if the builder has any segments added./// Adds beginning of a contour./// Multiple continuous MoveTo segments are not allowed./// If the previous segment was also MoveTo, it will be overwritten with the current one.inject_move_to_if_needed/// Adds a line from the last point./// - If `Path` is empty - adds Move(0, 0) first./// - If `Path` ends with Close - adds Move(last_x, last_y) first./// Adds a quad curve from the last point to `x`, `y`.quad_to_ptconic_to// We do not support conic segments, but Skia still relies on them from time to time.// This method will simply convert the input data into quad segments.conic_points_tocubic_to/// Adds a cubic curve from the last point to `x`, `y`.cubic_to_pt/// Closes the current contour./// A closed contour connects the first and the last Point/// with a line, forming a continuous loop./// Does nothing when `Path` is empty or already closed./// Open and closed contour will be filled the same way./// Stroking an open contour will add LineCap at contour's start and end./// Stroking an closed contour will add LineJoin at contour's start and end./// Returns the last point if any.set_last_pointis_zero_length_since_pointpush_rect/// Adds a rectangle contour./// The contour is closed and has a clock-wise direction.push_oval/// Adds an oval contour bounded by the provided rectangle.push_circle/// Adds a circle contour./// Does nothing when:/// - any value is not finite or really largepush_path/// Adds a path.push_path_builderreverse_path_to/// Appends, in a reverse order, the first contour of path ignoring path's last point./// Reset the builder./// Memory is not deallocated./// Finishes the builder and returns a `Path`./// Returns `None` when `Path` is empty or has invalid bounds.// NOTE: this is not SkPathBuilder, but rather a reimplementation of SkPath.SCALAR_NEARLY_ZERO// use for : eval(t) == A * t^2 + B * t + Cfrom_points// TODO: to a custom type?// From Numerical Recipes in C.// Q = -1/2 (B + sign(B) sqrt[B*B - 4*A*C])// x1 = Q / A// x2 = C / Qfind_quad_extrema// Quad'(t) = At + B, where// A = 2(a - 2b + c)// B = 2(b - a)// Solve for t, only if it fits between 0 < t < 1times_2find_quad_max_curvature// F(t)    = a (1 - t) ^ 2 + 2 b t (1 - t) + c t ^ 2// F'(t)   = 2 (b - a) + 2 (a - 2b + c) t// F''(t)  = 2 (a - 2b + c)// A = 2 (b - a)// B = 2 (a - 2b + c)// Maximum curvature for a quadratic means solving// Fx' Fx'' + Fy' Fy'' = 0// t = - (Ax Bx + Ay By) / (Bx ^ 2 + By ^ 2)eval_quad_ateval_quad_tangent_at// Looking for F' dot F'' == 0// A = b - a// B = c - 2b + a// C = d - 3c + 3b - a// F' = 3Ct^2 + 6Bt + 3A// F'' = 6Ct + 6B// F' dot F'' -> CCt^3 + 3BCt^2 + (2BB + CA)t + ABformulate_f1_dot_f2solve_cubic_poly/// Solve coeff(t) == 0, returning the number of roots that lie withing 0 < t < 1./// coeff[0]t^3 + coeff[1]t^2 + coeff[2]t + coeff[3]/// Eliminates repeated roots (so that all t_values are distinct, and are always/// in increasing order.sort_array3collapse_duplicates3scalar_cube_rooteval_cubic_pos_at// This is SkEvalCubicAt split into three functions.eval_cubic_tangent_ateval_cubic_derivativefind_cubic_inflections// http://www.faculty.idc.ac.il/arik/quality/appendixA.html// Inflection means that curvature is zero.// Curvature is [F' x F''] / [F'^3]// So we solve F'x X F''y - F'y X F''y == 0// After some canceling of the cubic term, we get// (BxCy - ByCx)t^2 + (AxCy - AyCx)t + AxBy - AyBx == 0find_cubic_cusp// Return location (in t) of cubic cusp, if there is one.// Note that classify cubic code does not reliably return all cusp'd cubics, so// it is not called here.on_same_side// Returns true if both points src[testIndex], src[testIndex+1] are in the same half plane defined// by the line segment src[lineIndex], src[lineIndex+1].calc_cubic_precision// Returns a constant proportional to the dimensions of the cubic.// Constant found through experimentation -- maybe there's a better way....Coniccompute_quad_pow2chop_into_quads_pow2// Chop this conic into N quads, stored continuously in pts[], where// N = 1 << pow2. The amount of storage needed is (1 + 2 * N)chopbuild_unit_arcsubdivide_weight_valuesubdivide// This was originally developed and tested for pathops: see SkOpTypes.h// returns true if (a <= b <= c) || (a >= b >= c)// the number of quadsAutoConicToQuadseval_cubic_at_1find_cubic_max_curvature_1//! A collection of functions to work with Bezier paths.//! Mainly for internal use. Do not rely on it!/// An integer rectangle./// Creates a new `IntRect`.from_ltrb/// Returns an intersection of two rectangles.inset/// Insets the rectangle.make_outset/// Outsets the rectangle./// Translates the rect by the specified offset.translate_to/// Translates the rect to the specified position./// Converts into `Rect`.int_rect_tests/// A rectangle defined by left, top, right and bottom edges./// Can have zero width and/or height. But not a negative one./// - All values are finite./// - Left edge is <= right./// - Top edge is <= bottom./// - Width and height are <= f32::MAX./// Creates new `Rect`./// Returns the left edge./// Returns the top edge./// Returns the right edge./// Returns the bottom edge./// Converts into an `IntRect` by adding 0.5 and discarding the fractional portion./// Width and height are guarantee to be >= 1.round_out/// Converts into an `IntRect` rounding outwards./// Creates a Rect from Point array./// Returns None if count is zero or if Point array contains an infinity or NaN./// Insets the rectangle by the specified offset.outset/// Outsets the rectangle by the specified offset./// Transforms the rect using the provided `Transform`./// This method is expensive.bbox_transform/// Applies a bounding box transform.to_non_zero_rect/// Converts into [`NonZeroRect`].checked_f32_subround_overflowrect_tests/// Similar to [`Rect`], but width and height guarantee to be non-zero and positive./// - Left edge is < right./// - Top edge is < bottom./// - Width and height are > 0.0/// Creates new `NonZeroRect`./// Converts into [`Rect`]./// Converts into [`IntRect`].aveis_nearly_equalis_nearly_zerois_nearly_zero_within_tolerance/// Float number extension methods./// A non-panicking clamp.// From SkPathOpsTypes./// An integer size./// - Width and height are positive and non-zero.from_wh/// Creates a new `IntSize` from width and height.from_wh_safe/// Returns width./// Returns height./// Returns width and height as a tuple.scale_by/// Scales current size by the specified factor.scale_to/// Scales current size to the specified size.scale_to_width/// Scales current size to the specified width.scale_to_height/// Scales current size to the specified height.to_size/// Converts into [`Size`]./// Converts into [`IntRect`] at the provided position.size_scaleint_size_tests/// A size./// - Width and height are positive, non-zero and finite./// Creates a new `Size` from width and height./// Scales current size to specified size.expand_to/// Expands current size to specified size.to_int_size/// Converts into [`IntSize`]./// Converts the current size to `Rect` at provided position./// Converts the current size to `NonZeroRect` at provided position.size_scale_f64SwappableBuilders/// A stroke thickness./// Must be >= 0./// When set to 0, a hairline stroking will be used./// The limit at which a sharp corner is drawn beveled./// Default: 4.0/// A stroke line cap./// Default: Butt/// A stroke line join./// Default: Miter/// Default: None/// Stroke properties./// No stroke extension./// Adds circle./// Adds square./// Draws at the beginning and end of an open path contour./// Extends to miter limit, then switches to bevel.MiterClip/// Extends to miter limit, then clips the corner./// Connects outside edges./// Specifies how corners are drawn when a shape is stroked./// Join affects the four corners of a stroked rectangle, and the connected segments in a/// stroked path./// Choose miter join to draw sharp corners. Choose round join to draw a circle with a/// radius equal to the stroke width on top of the corner. Choose bevel join to minimally/// connect the thick strokes./// The fill path constructed to describe the stroked path respects the join setting but may/// not contain the actual join. For instance, a fill path constructed with round joins does/// not necessarily include circles at each connected segment.QUAD_RECURSIVE_LIMITRECURSIVE_LIMITS// quads with extreme widths (e.g. (0,1) (1,6) (0,3) width=5e7) recurse to point of failure// largest seen for normal cubics: 5, 26// largest seen for normal quads: 11CapProcJoinProcReductionType// all curve points are practically identical// the control point is on the line between the endsDegenerate// the control point is outside the line between the endsDegenerate2// the control point is on the line but outside the endsDegenerate3// two control points are on the line but outside ends (cubic)// three areas of max curvature found (for cubic)StrokeType// use sign-opposite values later to flip perpendicular axis// the caller should split the quad stroke in two// the caller should add a line// the caller should (continue to try to) add a quad strokeIntersectRayTypeCtrlPt/// Returns a stoked path./// [`compute_resolution_scale`](PathStroker::compute_resolution_scale)./// If you plan stroking multiple paths, you can try using [`PathStroker`]/// which will preserve temporary allocations required during stroking./// This might improve performance a bit.inv_miter_limitres_scaleinv_res_scaleinv_res_scale_squaredfirst_normalprev_normalfirst_unit_normalprev_unit_normalfirst_pt// on original pathprev_ptfirst_outer_ptfirst_outer_pt_index_in_contoursegment_countprev_is_linecapperjoiner// outer is our working answer, inner is tempcusperstroke_typerecursion_depthfound_tangents// track stack depth to abort if numerics run amokjoin_completed// do less work until tangents meet (cubic)// previous join was not degenerate/// A path stroker./// Creates a new PathStroker.compute_resolution_scale/// Computes a resolution scale./// Resolution scale is the "intended" resolution for the output. Default is 1.0./// Larger values (res > 1) indicate that the result should be more precise, since it will/// be zoomed up, and small errors will be magnified./// Smaller values (0 < res < 1) indicate that the result can be less precise, since it will/// be zoomed down, and small errors may be invisible./// Stokes the path./// Can be called multiple times to reuse allocated buffers./// [`compute_resolution_scale`](Self::compute_resolution_scale).stroke_innermove_to_ptcubic_strokeQuadConstructcubic_mid_on_linecubic_quad_midcubic_perp_ray// Given a cubic and t, return the point on curve,// its perpendicular, and the perpendicular tangent.set_cubic_end_normalcompare_quad_cubiccubic_quad_ends// Given a cubic and a t range, find the start and end if they haven't been found already.finish_contourpre_join_topost_join_toinit_quadquad_strokecompare_quad_quadset_ray_points// Given a point on the curve and its derivative, scale the derivative by the radius, and// compute the perpendicular point and its tangent.quad_perp_ray// Given a quad and t, return the point on curve,add_degenerate_linestroke_close_enoughintersect_ray// Find the intersection of the stroke tangents to construct a stroke quad.// Return whether the stroke is a degenerate (a line), a quad, or must be split.// Optionally compute the quad's control point.tangents_meet// Given a cubic and a t-range, determine if the stroke can be described by a quadratic.has_only_move_tois_current_contour_emptycap_factorybutt_capperround_cappersquare_capperjoin_factoryis_clockwiseAngleTypeNearly180SharpShallowNearlyLinedot_to_angle_typehandle_inner_joinbevel_joinerround_joinermiter_joinermiter_clip_joinermiter_joiner_innerset_normal_unit_normalset_normal_unit_normal2// The state of the quad stroke under construction.tangent_start// the stroked quad parallel to the original curvetangent_end// a point tangent to quad[0]start_t// a point tangent to quad[2]mid_t// a segment of the original curveend_tstart_setend_set// state to share common points across structsopposite_tangents// set if coincident tangents have opposite directions// return false if start and end are too close to have a unique middleinit_with_startinit_with_endcheck_quad_lineardegenerate_vectorquad_in_line/// Given quad, see if all there points are in a line./// Return true if the inside point is close to a line connecting the outermost points./// Find the outermost point by looking for the largest difference in X or Y./// Since the XOR of the indices is 3  (0 ^ 1 ^ 2)/// the missing index equals: outer_1 ^ outer_2 ^ 3.pt_to_line// returns the distance squared from the point to the lineintersect_quad_ray// Intersect the line with the quad and return the t values on the quad where the line crosses.points_within_distsharp_anglept_in_quad_bounds// Return true if the point is close to the bounds of the quad. This is used as a quick reject.check_cubic_linearcubic_in_line/// Given a cubic, determine if all four points are in a line./// Return true if the inner points is close to a line connecting the outermost points./// Given the indices of the outermost points, and that outer_1 is greater than outer_2,/// this table shows the index of the smaller of the remaining points:///                   outer_2///               0    1    2    3///   outer_1     ----------------///      0     |  -    2    1    1///      1     |  -    -    0    0///      2     |  -    -    -    0///      3     |  -    -    -    -/// If outer_1 == 0 and outer_2 == 1, the smaller of the remaining indices (2 and 3) is 2./// This table can be collapsed to: (1 + (2 >> outer_2)) >> outer_1/// Given three indices (outer_1 outer_2 mid_1) from 0..3, the remaining index is:/// mid_2 == (outer_1 ^ outer_2 ^ mid_1)new_move_tonew_line_tonew_close// fn new_quad_to(x1: f32, y1: f32, x: f32, y: f32) -> Self {//     PathSegment::QuadTo(Point::from_xy(x1, y1), Point::from_xy(x, y))// fn new_cubic_to(x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) -> Self {//     PathSegment::CubicTo(Point::from_xy(x1, y1), Point::from_xy(x2, y2), Point::from_xy(x, y))// Make sure that subpath auto-closing is enabled.cubic_1// From skia/tests/StrokeTest.cppcubic_2// From skbug.com/6491. The large stroke width can cause numerical instabilities.quad_stroker_one_off// From skia/tests/StrokerTest.cppcubic_stroker_one_off// Copyright 2008 The Android Open Source Project// Based on SkStroke.cpp// 3x limits seen in practicesxkysy/// An affine transformation matrix./// Unlike other types, doesn't guarantee to be valid. This is Skia quirk./// Meaning Transform(0, 0, 0, 0, 0, 0) is ok, while it's technically not./// Non-finite values are also not an error./// Creates an identity transform.from_row/// Creates a new `Transform`./// We are using column-major-column-vector matrix notation, therefore it's ky-kx, not kx-ky.from_translate/// Creates a new translating `Transform`.from_scale/// Creates a new scaling `Transform`.from_skew/// Creates a new skewing `Transform`.from_rotate/// Creates a new rotating `Transform`./// `angle` in degrees.from_rotate_at/// Creates a new rotating `Transform` at the specified position.from_bbox/// Converts `Rect` into a bounding box `Transform`./// Checks that transform is finite./// Checks that transform is finite and has non-zero scale./// Checks that transform is identity.is_scale/// Checks that transform is scale-only.is_skew/// Checks that transform is skew-only.is_translate/// Checks that transform is translate-only.is_scale_translate/// Checks that transform contains only scale and translate.has_scale/// Checks that transform contains a scale part.has_skew/// Checks that transform contains a skew part.has_translate/// Checks that transform contains a translate part.get_scale/// Returns transform's scale part.pre_scale/// Pre-scales the current transform.post_scale/// Post-scales the current transform.pre_translate/// Pre-translates the current transform.post_translate/// Post-translates the current transform.pre_rotate/// Pre-rotates the current transform.post_rotate/// Post-rotates the current transform.pre_rotate_at/// Pre-rotates the current transform by the specified position.post_rotate_at/// Post-rotates the current transform by the specified position.pre_concat/// Pre-concats the current transform.post_concat/// Post-concats the current transform.from_sin_cosmap_point/// Transforms a points using the current transform.map_points/// Transforms a slice of points using the current transform./// Returns an inverted transform.inv_determinantcompute_invdcrossdcross_dscalemul_add_mulfind_link_depsfind_dlopen_dirs// MIT/Apache2/Zlib License//! Finds the path of Xlib and Xlib-XCB.//! Normally, we should be able to link directly to these packages. However, on some atypical//! Linux configurations (like NixOS), they might be in other directories. As far as I know//! `pkg-config` is the only blessed way to find and link to these libraries. So unfortunately,//! we have to have a heavy build script and build-time dependency.XLIB_LIBDIRXLIB_XCB_LIBDIR// See build.rs for how this file is generated./// Base type for the display pointer./// The type of the error.// Function pointer types.XErrorHook_xlib_library/// The currently loaded Xlib library._xlib_xcb_library/// The currently loaded XlibXcb library.x_open_display/// The XOpenDisplay function.x_close_display/// The XCloseDisplay function.x_get_xcb_connection/// The XGetXCBConnection function.x_default_screen/// The XDefaultScreen function.x_set_error_handler/// The XSetErrorHandler function.x_init_threads/// The XInitThreads function./// Catalogue of functions offered by Xlib./// Open a new connection to the X server.close_display/// Close a connection to the X server.get_xcb_connection/// Get the XCB connection from an Xlib display./// Get the default screen index.set_error_handler/// Set the error handler.init_threads/// Initialize threads./// Load the Xlib library at runtime.// Copyright 2023 John Nunley// Licensed under the Apache License, Version 2.0, the MIT License, and// the Zlib license. You may not use this software except in compliance// with at least one of these licenses. You should have received a copy// of these licenses with this software. You may also find them at://     https://opensource.org/licenses/MIT//     https://opensource.org/licenses/Zlib// distributed under these licenses is distributed on an "AS IS" BASIS,// See the licenses for the specific language governing permissions and// limitations under the licenses.//! FFI bindings to Xlib and XlibXCB.XLIBget_xlibDEFAULT_ERROR_HOOKErrorHookSlot/// The default error hook to compare against.ErrorHook/// An error handling hook.ERROR_HANDLERSHandlerList/// List of error hooks to invoke./// Global error handler for X11.setup_error_handler/// Register the error handler.HandlerKey/// A key to the error handler list that can be used to remove handlers./// The error event type.// SAFETY: With XInitThreads, ErrorEvent is both Send and Sync./// Get the serial number of the failed request./// Get the error code./// Get the request code./// Get the minor opcode of the failed request.resource_id/// Get the resource ID of the failed request./// The display pointer./// This owns the memory that the display pointer points to.// SAFETY: With XInitThreads, Display is both Send and Sync./// Open a new display./// Create a new `Display` from a pointer./// The pointer must be a valid pointer to an Xlib display. In addition, it should only be dropped if the/// user logically owns the display./// Get the pointer to the display.screen_index/// Get the default screen index for this display.register_error_handler/// Insert an error handler into the list.unregister_error_handler/// Remove an error handler from the list./// The inner list of slots./// The number of filled slots./// The first unfilled slot./// The last error handler hook./// The list of error handlers.Filled/// A slot that is filled.Unfilled/// A slot that is unfilled./// This value points to the next unfilled slot./// A slot in the error handler list./// Create a new handler list./// Push a new error handler./// Returns the index of the handler./// Remove an error handler./// Iterate over the error handlers./// Static unsafe error hook slot.//! A tiny set of bindings to the [Xlib] library.//! The primary contemporary library for handling [Xlib] is the [`x11-dl`] crate. However, there are three//! primary issues.//! 1. **You should not be using Xlib in 2023.** [Xlib] is legacy code, and even that doesn't get across//!     how poor the API decisions that it's locked itself into are. It has a global error hook for//!     some reason, thread-safety is a mess, and it has so many soundness holes it might as well be made//!     out of swiss cheese. You should not be using [Xlib]. If you *have* to use [Xlib], you should just//!     run all of your logic using the much more sound [XCB] library, or, even more ideally, something//!     like [`x11rb`]. Then, you take the `Display` pointer and use it for whatever legacy API you've//!     locked yourself into, and use [XCB] or [`x11rb`] for everything else. Yes, I just called [GLX]//!     a legacy API. It's the 2020's now. [Vulkan] and [`wgpu`] run everywhere aside from legacy machines.//!     Not to mention, they support [XCB].//! 2. Even if you manage to use [`x11-dl`] without tripping over the legacy API, it is a massive crate.//!     [Xlib] comes with quite a few functions, most of which are unnecessary in the 21st century.//!     Even if you don't use any of these and just stick to [XCB], you still pay the price for it.//!     Binaries that use [`x11-dl`] need to dedicate a significant amount of their binary and memory//!     space to the library. Even on Release builds, I have recorded [`x11-dl`] taking up to seven//!     percent of the binary.//! 3. Global error handling. [Xlib] has a single global error hook. This is reminiscent of the Unix//!     signal handling API, in that it makes it difficult to create well-modularized programs//!     since they will fight with each-other over the error handlers. However, unlike the signal//!     handling API, there is no way to tell if you're replacing an existing error hook.//! `tiny-xlib` aims to solve all of these problems. It provides a safe API around [Xlib] that is//! conducive to being handed off to both [XCB] APIs and legacy [Xlib] APIs. The library only//! imports absolutely necessary functions. In addition, it also provides a common API for//! handling errors in a safe, modular way.//! - Safe API around [Xlib]. See the [`Display`] structure.//! - Minimal set of dependencies.//! - Implements [`AsRawXcbConnection`], which allows it to be used with [XCB] APIs.//! - Modular error handling.//! # Non-Features//! - Any API outside of opening [`Display`]s and handling errors. If this library doesn't support some//!   feature, it's probably intentional. You should use [XCB] or [`x11rb`] instead. This includes://!  - Window management.//!  - Any extensions outside of `Xlib-xcb`.//!  - IME handling.//!  - Hardware rendering.//! use as_raw_xcb_connection::AsRawXcbConnection;//! use tiny_xlib::Display;//! use x11rb::connection::Connection;//! use x11rb::xcb_ffi::XCBConnection;//! // Open a display.//! let display = Display::new(None)?;//! // Get the XCB connection.//! let xcb_conn = display.as_raw_xcb_connection();//! // Use that pointer to create a new XCB connection.//! let xcb_conn = unsafe {//!     XCBConnection::from_raw_xcb_connection(xcb_conn.cast(), false)?//! // Register a handler for X11 errors.//! tiny_xlib::register_error_handler(Box::new(|_, error| {//!     println!("X11 error: {:?}", error);//!     false//! // Do whatever you want with the XCB connection.//!     println!("Event: {:?}", xcb_conn.wait_for_event()?);//! - `tracing`, enabled by default, enables telemetry using the [`tracing`] crate.//! - `dlopen` uses the [`libloading`] library to load the X11 libraries instead of linking to them//!   directly.//! [Xlib]: https://en.wikipedia.org/wiki/Xlib//! [XCB]: https://xcb.freedesktop.org///! [`x11-dl`]: https://crates.io/crates/x11-dl//! [`x11rb`]: https://crates.io/crates/x11rb//! [GLX]: https://en.wikipedia.org/wiki/GLX//! [Vulkan]: https://www.khronos.org/vulkan///! [`wgpu`]: https://crates.io/crates/wgpu//! [`Display`]: struct.Display.html//! [`AsRawXcbConnection`]: https://docs.rs/as_raw_xcb_connection/latest/as_raw_xcb_connection/trait.AsRawXcbConnection.html//! [`tracing`]: https://crates.io/crates/tracing//! [`libloading`]: https://crates.io/crates/libloading// Generated file, to regenerate run
//     ./gen-array-impls.sh > src/array/generated_impl.rs
// from the repo root
/// The type of the items in the thing.
/// The number of slots in the thing.
/// Gives a shared slice over the whole thing.
/// A correct implementation will return a slice with a length equal to the
/// `CAPACITY` value.
/// Gives a unique slice over the whole thing.
/// Create a default-initialized instance of ourself, similar to the
/// [`Default`] trait, but implemented for the same range of sizes as
/// [`Array`].
/// A trait for types that are an array.
/// An "array", for our purposes, has the following properties:
/// * Owns some number of elements.
/// * The element type can be generic, but must implement [`Default`].
/// * The capacity is fixed at compile time, based on the implementing type.
/// * You can get a shared or mutable slice to the elements.
/// You are generally **not** expected to need to implement this yourself. It is
/// already implemented for all the major array lengths (`0..=32` and the powers
/// of 2 up to 4,096), or for all array lengths with the feature `rustc_1_55`.
/// **Additional lengths can easily be added upon request.**
/// ## Safety Reminder
/// Just a reminder: this trait is 100% safe, which means that `unsafe` code
/// **must not** rely on an instance of this trait being correct.
generated_implarray_vec/// Helper to make an `ArrayVec`.
/// You specify the backing array type, and optionally give all the elements you
/// want to initially place into the array.
/// use tinyvec::*;
/// // The backing array type can be specified in the macro call
/// let empty_av = array_vec!([u8; 16]);
/// let some_ints = array_vec!([i32; 4] => 1, 2, 3);
/// // Or left to inference
/// let empty_av: ArrayVec<[u8; 10]> = array_vec!();
/// let some_ints: ArrayVec<[u8; 10]> = array_vec!(5, 6, 7, 8);
/// An array-backed, vector-like data structure.
/// * `ArrayVec` has a fixed capacity, equal to the minimum of the array size
/// and `u16::MAX`. Note that not all capacities are necessarily supported by
/// default. See comments in [`Array`].
/// * `ArrayVec` has a variable length, as you add and remove elements. Attempts
///   to fill the vec beyond its capacity will cause a panic.
/// * All of the vec's array slots are always initialized in terms of Rust's
///   memory model. When you remove a element from a location, the old value at
///   that location is replaced with the type's default value.
/// The overall API of this type is intended to, as much as possible, emulate
/// the API of the [`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)
/// ## Construction
/// You can use the `array_vec!` macro similarly to how you might use the `vec!`
/// macro. Specify the array type, then optionally give all the initial values
/// you want to have.
/// # use tinyvec::*;
/// assert_eq!(some_ints.len(), 3);
/// The [`default`](ArrayVec::new) for an `ArrayVec` is to have a default
/// array with length 0. The [`new`](ArrayVec::new) method is the same as
/// calling `default`
/// let some_ints = ArrayVec::<[i32; 7]>::default();
/// assert_eq!(some_ints.len(), 0);
/// let more_ints = ArrayVec::<[i32; 7]>::new();
/// assert_eq!(some_ints, more_ints);
/// If you have an array and want the _whole thing_ so count as being "in" the
/// new `ArrayVec` you can use one of the `from` implementations. If you want
/// _part of_ the array then you can use
/// [`from_array_len`](ArrayVec::from_array_len):
/// let some_ints = ArrayVec::from([5, 6, 7, 8]);
/// assert_eq!(some_ints.len(), 4);
/// let more_ints = ArrayVec::from_array_len([5, 6, 7, 8], 2);
/// assert_eq!(more_ints.len(), 2);
/// let no_ints: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([1, 2, 3, 4, 5]);
/// assert_eq!(no_ints.len(), 0);
/// Move all values from `other` into this vec.
/// ## Panics
/// * If the vec overflows its capacity
/// ## Example
/// let mut av = array_vec!([i32; 10] => 1, 2, 3);
/// let mut av2 = array_vec!([i32; 10] => 4, 5, 6);
/// av.append(&mut av2);
/// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
/// assert_eq!(av2, &[][..]);
'other/// If appending would overflow the capacity, Some(other) is returned.
/// let mut av = array_vec!([i32; 7] => 1, 2, 3);
/// let mut av2 = array_vec!([i32; 7] => 4, 5, 6);
/// let mut av3 = array_vec!([i32; 7] => 7, 8, 9);
/// assert!(av.try_append(&mut av3).is_some());
/// assert_eq!(av3, &[7, 8, 9][..]);
/// A `*mut` pointer to the backing array.
/// ## Safety
/// This pointer has provenance over the _entire_ backing array.
/// Performs a `deref_mut`, into unique slice form.
/// A `*const` pointer to the backing array.
/// Performs a `deref`, into shared slice form.
/// The capacity of the `ArrayVec`.
/// This is fixed based on the array type, but can't yet be made a `const fn`
/// on Stable Rust.
/// Truncates the `ArrayVec` down to length 0.
ArrayVecDrain/// Creates a draining iterator that removes the specified range in the vector
/// and yields the removed items.
/// * If the start is greater than the end
/// * If the end is past the edge of the vec.
/// let mut av = array_vec!([i32; 4] => 1, 2, 3);
/// let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect();
/// assert_eq!(av.as_slice(), &[1][..]);
/// assert_eq!(av2.as_slice(), &[2, 3][..]);
/// av.drain(..);
/// assert_eq!(av.as_slice(), &[]);
/// Returns the inner array of the `ArrayVec`.
/// This returns the full array, even if the `ArrayVec` length is currently
/// less than that.
/// # use tinyvec::{array_vec, ArrayVec};
/// let mut favorite_numbers = array_vec!([i32; 5] => 87, 48, 33, 9, 26);
/// assert_eq!(favorite_numbers.clone().into_inner(), [87, 48, 33, 9, 26]);
/// favorite_numbers.pop();
/// assert_eq!(favorite_numbers.into_inner(), [87, 48, 33, 9, 0]);
/// A use for this function is to build an array from an iterator by first
/// collecting it into an `ArrayVec`.
/// # use tinyvec::ArrayVec;
/// let arr_vec: ArrayVec<[i32; 10]> = (1..=3).cycle().take(10).collect();
/// let inner = arr_vec.into_inner();
/// assert_eq!(inner, [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]);
/// Clone each element of the slice into this `ArrayVec`.
/// * If the `ArrayVec` would overflow, this will panic.
/// Fill the vector until its capacity has been reached.
/// Successively fills unused space in the spare slice of the vector with
/// elements from the iterator. It then returns the remaining iterator
/// without exhausting it. This also allows appending the head of an
/// infinite iterator.
/// This is an alternative to `Extend::extend` method for cases where the
/// length of the iterator can not be checked. Since this vector can not
/// reallocate to increase its capacity, it is unclear what to do with
/// remaining elements in the iterator and the iterator itself. The
/// interface also provides no way to communicate this to the caller.
/// * If the `next` method of the provided iterator panics.
/// let mut av = array_vec!([i32; 4]);
/// let mut to_inf = av.fill(0..);
/// assert_eq!(&av[..], [0, 1, 2, 3]);
/// assert_eq!(to_inf.next(), Some(4));
from_array_len/// Wraps up an array and uses the given length as the initial length.
/// If you want to simply use the full array, use `from` instead.
/// * The length specified must be less than or equal to the capacity of the
///   array.
/// Inserts an item at the position given, moving all following elements +1
/// index.
/// * If `index` > `len`
/// * If the capacity is exhausted
/// av.insert(1, 4);
/// assert_eq!(av.as_slice(), &[1, 4, 2, 3]);
/// av.insert(4, 5);
/// assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);
/// Tries to insert an item at the position given, moving all following
/// elements +1 index.
/// Returns back the element if the capacity is exhausted,
/// otherwise returns None.
/// let mut av = array_vec!([&'static str; 4] => "one", "two", "three");
/// av.insert(1, "four");
/// assert_eq!(av.as_slice(), &["one", "four", "two", "three"]);
/// assert_eq!(av.try_insert(4, "five"), Some("five"));
/// Checks if the length is 0.
/// The length of the `ArrayVec` (in elements).
/// Makes a new, empty `ArrayVec`.
/// Remove and return the last element of the vec, if there is one.
/// ## Failure
/// * If the vec is empty you get `None`.
/// let mut av = array_vec!([i32; 10] => 1, 2);
/// assert_eq!(av.pop(), Some(2));
/// assert_eq!(av.pop(), Some(1));
/// assert_eq!(av.pop(), None);
/// Place an element onto the end of the vec.
/// * If the length of the vec would overflow the capacity.
/// let mut av = array_vec!([i32; 2]);
/// assert_eq!(&av[..], []);
/// av.push(1);
/// assert_eq!(&av[..], [1]);
/// av.push(2);
/// assert_eq!(&av[..], [1, 2]);
/// // av.push(3); this would overflow the ArrayVec and panic!
/// Tries to place an element onto the end of the vec.\
/// assert_eq!(av.as_slice(), []);
/// assert_eq!(av.try_push(1), None);
/// assert_eq!(av.try_push(2), None);
/// assert_eq!(av.try_push(3), Some(3));
/// Removes the item at `index`, shifting all others down by one index.
/// Returns the removed element.
/// * If the index is out of bounds.
/// assert_eq!(av.remove(1), 2);
/// assert_eq!(&av[..], [1, 3]);
/// As [`resize_with`](ArrayVec::resize_with)
/// and it clones the value as the closure.
/// let mut av = array_vec!([&str; 10] => "hello");
/// av.resize(3, "world");
/// assert_eq!(&av[..], ["hello", "world", "world"]);
/// let mut av = array_vec!([i32; 10] => 1, 2, 3, 4);
/// av.resize(2, 0);
/// Resize the vec to the new length.
/// If it needs to be longer, it's filled with repeated calls to the provided
/// function. If it needs to be shorter, it's truncated.
/// av.resize_with(5, Default::default);
/// assert_eq!(&av[..], [1, 2, 3, 0, 0]);
/// let mut av = array_vec!([i32; 10]);
/// let mut p = 1;
/// av.resize_with(4, || {
///   p *= 2;
///   p
/// assert_eq!(&av[..], [2, 4, 8, 16]);
/// Walk the vec and keep only the elements that pass the predicate given.
/// let mut av = array_vec!([i32; 10] => 1, 1, 2, 3, 3, 4);
/// av.retain(|&x| x % 2 == 0);
/// assert_eq!(&av[..], [2, 4]);
/// Forces the length of the vector to `new_len`.
/// * If `new_len` is greater than the vec's capacity.
/// * This is a fully safe operation! The inactive memory already counts as
///   "initialized" by Rust's rules.
/// * Other than "the memory is initialized" there are no other guarantees
///   regarding what you find in the inactive portion of the vec.
/// Splits the collection at the point given.
/// * `[0, at)` stays in this vec
/// * `[at, len)` ends up in the new vec.
/// * if at > len
/// let av2 = av.split_off(1);
/// assert_eq!(&av2[..], [2, 3]);
ArrayVecSplice/// Creates a splicing iterator that removes the specified range in the
/// vector, yields the removed items, and replaces them with elements from
/// the provided iterator.
/// `splice` fuses the provided iterator, so elements after the first `None`
/// are ignored.
/// * If the start is greater than the end.
/// * If the provided iterator panics.
/// * If the new length would overflow the capacity of the array. Because
///   `ArrayVecSplice` adds elements to this vec in its destructor when
///   necessary, this panic would occur when it is dropped.
/// let av2: ArrayVec<[i32; 4]> = av.splice(1.., 4..=6).collect();
/// assert_eq!(av.as_slice(), &[1, 4, 5, 6][..]);
/// av.splice(.., None);
/// Remove an element, swapping the end of the vec into its place.
/// let mut av = array_vec!([&str; 4] => "foo", "bar", "quack", "zap");
/// assert_eq!(av.swap_remove(1), "bar");
/// assert_eq!(&av[..], ["foo", "zap", "quack"]);
/// assert_eq!(av.swap_remove(0), "foo");
/// assert_eq!(&av[..], ["quack", "zap"]);
/// Reduces the vec's length to the given value.
/// If the vec is already shorter than the input, nothing happens.
try_from_array_len/// Wraps an array, using the given length as the starting length.
/// If you want to use the whole length of the array, you can just use the
/// `From` impl.
/// If the given length is greater than the capacity of the array this will
/// error, and you'll get the array back in the `Err`.
from_array_empty/// Wraps up an array as a new empty `ArrayVec`.
/// ## Examples
/// This method in particular allows to create values for statics:
/// static DATA: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([0; 5]);
/// assert_eq!(DATA.len(), 0);
/// But of course it is just an normal empty `ArrayVec`:
/// let mut data = ArrayVec::from_array_empty([1, 2, 3, 4]);
/// assert_eq!(&data[..], &[]);
/// data.push(42);
/// assert_eq!(&data[..], &[42]);
removal_startremoval_endreplacement/// Splicing iterator for `ArrayVec`
/// See [`ArrayVec::splice`](ArrayVec::<A>::splice)
/// The output has a length equal to the full array.
/// If you want to select a length, use
/// [`from_array_len`](ArrayVec::from_array_len)
/// The error type returned when a conversion from a slice to an [`ArrayVec`]
/// fails.
/// The output has a length equal to that of the slice, with the same capacity
/// as `A`.
ArrayVecIterator/// Iterator for consuming an `ArrayVec` and returning owned elements.
/// Returns the remaining items of this iterator as a slice.
// // // // // // // //
// Formatting impls
drain_to_vec_and_reserve/// Drains all elements to a Vec, but reserves additional space
/// let v = av.drain_to_vec_and_reserve(10);
/// assert_eq!(v, &[1, 2, 3]);
/// assert_eq!(v.capacity(), 13);
drain_to_vec/// Drains all elements to a Vec
/// let v = av.drain_to_vec();
/// assert_eq!(v.capacity(), 3);
/// Draining iterator for [`ArrayVec`]
/// See [`ArrayVec::drain`](ArrayVec::drain)
/* No need to impl Drop! */needs_drop// re-export for macros
arrayvec_drainslicevec//! `tinyvec` provides 100% safe vec-like data structures.
//! ## Provided Types
//! With no features enabled, this crate provides the [`ArrayVec`] type, which
//! is an array-backed storage. You can push values into the array and pop them
//! out of the array and so on. If the array is made to overflow it will panic.
//! Similarly, there is also a [`SliceVec`] type available, which is a vec-like
//! that's backed by a slice you provide. You can add and remove elements, but
//! if you overflow the slice it will panic.
//! With the `alloc` feature enabled, the crate also has a [`TinyVec`] type.
//! This is an enum type which is either an `Inline(ArrayVec)` or a `Heap(Vec)`.
//! If a `TinyVec` is `Inline` and would overflow it automatically transitions
//! itself into being `Heap` mode instead of a panic.
//! All of this is done with no `unsafe` code within the crate. Technically the
//! `Vec` type from the standard library uses `unsafe` internally, but *this
//! crate* introduces no new `unsafe` code into your project.
//! The limitation is that the element type of a vec from this crate must
//! support the [`Default`] trait. This means that this crate isn't suitable for
//! all situations, but a very surprising number of types do support `Default`.
//! ## Other Features
//! * `grab_spare_slice` lets you get access to the "inactive" portions of an
//!   ArrayVec.
//! * `serde` provides a `Serialize` and `Deserialize` implementation for
//!   [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has an
//!   implementation.
//! ## API
//! The general goal of the crate is that, as much as possible, the vecs here
//! should be a "drop in" replacement for the standard library `Vec` type. We
//! strive to provide all of the `Vec` methods with the same names and
//! signatures. The exception is that the element type of some methods will have
//! a `Default` bound that's not part of the normal `Vec` type.
//! The vecs here also have a few additional methods that aren't on the `Vec`
//! type. In this case, the names tend to be fairly long so that they are
//! unlikely to clash with any future methods added to `Vec`.
//! ## Stability
//! * The `1.0` series of the crate works with Rustc `1.34.0` or later, though
//!   you still need to have Rustc `1.36.0` to use the `alloc` feature.
//! * The `2.0` version of the crate is planned for some time after the
//!   `min_const_generics` stuff becomes stable. This would greatly raise the
//!   minimum rust version and also allow us to totally eliminate the need for
//!   the `Array` trait. The actual usage of the crate is not expected to break
//!   significantly in this transition.
SliceVec/// A slice-backed vector-like data structure.
/// This is a very similar concept to `ArrayVec`, but instead
/// of the backing memory being an owned array, the backing
/// memory is a unique-borrowed slice. You can thus create
/// one of these structures "around" some slice that you're
/// working with to make it easier to manipulate.
/// * Has a fixed capacity (the initial slice size).
/// * Has a variable length.
/// A `*mut` pointer to the backing slice.
/// This pointer has provenance over the _entire_ backing slice.
/// A `*const` pointer to the backing slice.
/// The capacity of the `SliceVec`.
/// This the length of the initial backing slice.
/// Truncates the `SliceVec` down to length 0.
SliceVecDrain/// let mut arr = [6, 7, 8];
/// let mut sv = SliceVec::from(&mut arr);
/// let drained_values: ArrayVec<[i32; 4]> = sv.drain(1..).collect();
/// assert_eq!(sv.as_slice(), &[6][..]);
/// assert_eq!(drained_values.as_slice(), &[7, 8][..]);
/// sv.drain(..);
/// assert_eq!(sv.as_slice(), &[]);
/// let mut arr = [7, 7, 7, 7];
/// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
/// let mut to_inf = sv.fill(0..);
/// assert_eq!(&sv[..], [0, 1, 2, 3]);
from_slice_len/// Wraps up a slice and uses the given length as the initial length.
/// If you want to simply use the full slice, use `from` instead.
///   slice.
/// let mut arr = [1, 2, 3, 0, 0];
/// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
/// sv.insert(1, 4);
/// assert_eq!(sv.as_slice(), &[1, 4, 2, 3]);
/// sv.insert(4, 5);
/// assert_eq!(sv.as_slice(), &[1, 4, 2, 3, 5]);
/// The length of the `SliceVec` (in elements).
/// let mut arr = [1, 2];
/// assert_eq!(sv.pop(), Some(2));
/// assert_eq!(sv.pop(), Some(1));
/// assert_eq!(sv.pop(), None);
/// let mut arr = [0, 0];
/// assert_eq!(&sv[..], []);
/// sv.push(1);
/// assert_eq!(&sv[..], [1]);
/// sv.push(2);
/// assert_eq!(&sv[..], [1, 2]);
/// // sv.push(3); this would overflow the ArrayVec and panic!
/// let mut arr = [1, 2, 3];
/// assert_eq!(sv.remove(1), 2);
/// assert_eq!(&sv[..], [1, 3]);
/// As [`resize_with`](SliceVec::resize_with)
/// // bigger
/// let mut arr = ["hello", "", "", "", ""];
/// let mut sv = SliceVec::from_slice_len(&mut arr, 1);
/// sv.resize(3, "world");
/// assert_eq!(&sv[..], ["hello", "world", "world"]);
/// // smaller
/// let mut arr = ['a', 'b', 'c', 'd'];
/// sv.resize(2, 'z');
/// assert_eq!(&sv[..], ['a', 'b']);
/// * If it needs to be longer, it's filled with repeated calls to the
///   provided function.
/// * If it needs to be shorter, it's truncated.
///   * If the type needs to drop the truncated slots are filled with calls to
///     the provided function.
/// let mut arr = [1, 2, 3, 7, 7, 7, 7];
/// sv.resize_with(5, Default::default);
/// assert_eq!(&sv[..], [1, 2, 3, 0, 0]);
/// let mut arr = [0, 0, 0, 0];
/// sv.resize_with(4, || {
/// assert_eq!(&sv[..], [2, 4, 8, 16]);
/// let mut arr = [1, 1, 2, 3, 3, 4];
/// sv.retain(|&x| x % 2 == 0);
/// assert_eq!(&sv[..], [2, 4]);
/// * `[0, at)` stays in this vec (and this vec is now full).
/// * `[at, len)` ends up in the new vec (with any spare capacity).
/// * if `at` > `self.len()`
/// let sv2 = sv.split_off(1);
/// assert_eq!(&sv2[..], [2, 3]);
/// let mut arr = ["foo", "bar", "quack", "zap"];
/// assert_eq!(sv.swap_remove(1), "bar");
/// assert_eq!(&sv[..], ["foo", "zap", "quack"]);
/// assert_eq!(sv.swap_remove(0), "foo");
/// assert_eq!(&sv[..], ["quack", "zap"]);
try_from_slice_len/// Wraps a slice, using the given length as the starting length.
/// If you want to use the whole length of the slice, you can just use the
/// If the given length is greater than the length of the slice you get
/// `None`.
/// Uses the full slice as the initial length.
/// let mut arr = [0_i32; 2];
/// let mut sv = SliceVec::from(&mut arr[..]);
/// Calls `AsRef::as_mut` then uses the full slice as the initial length.
target_starttarget_indextarget_end/// Draining iterator for [`SliceVec`]
/// See [`SliceVec::drain`](SliceVec::drain)
impl_mirroredtiny_vec/// Helper to make a `TinyVec`.
/// let empty_tv = tiny_vec!([u8; 16]);
/// let some_ints = tiny_vec!([i32; 4] => 1, 2, 3);
/// let many_ints = tiny_vec!([i32; 4] => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
/// let empty_tv: TinyVec<[u8; 16]> = tiny_vec!();
/// let some_ints: TinyVec<[i32; 4]> = tiny_vec!(1, 2, 3);
/// let many_ints: TinyVec<[i32; 4]> = tiny_vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
TinyVecConstructor// Internal implementation details of `tiny_vec!`
/// A vector that starts inline, but can automatically move to the heap.
/// * Requires the `alloc` feature
/// A `TinyVec` is either an Inline([`ArrayVec`](crate::ArrayVec::<A>)) or
/// Heap([`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)). The
/// interface for the type as a whole is a bunch of methods that just match on
/// the enum variant and then call the same method on the inner vec.
/// Because it's an enum, you can construct a `TinyVec` simply by making an
/// `ArrayVec` or `Vec` and then putting it into the enum.
/// There is also a macro
is_heap/// Returns whether elements are on heap
/// Returns whether elements are on stack
/// Shrinks the capacity of the vector as much as possible.\
/// It is inlined if length is less than `A::CAPACITY`.
/// let mut tv = tiny_vec!([i32; 2] => 1, 2, 3);
/// assert!(tv.is_heap());
/// let _ = tv.pop();
/// tv.shrink_to_fit();
/// assert!(tv.is_inline());
move_to_the_heap/// Moves the content of the TinyVec to the heap, if it's inline.
/// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
/// tv.move_to_the_heap();
move_to_the_heap_and_reserve/// If TinyVec is inline, moves the content of it to the heap.
/// Also reserves additional space.
/// tv.move_to_the_heap_and_reserve(32);
/// assert!(tv.capacity() >= 35);
/// Reserves additional space.
/// Moves to the heap if array can't hold `n` more items
/// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
/// tv.reserve(1);
/// assert!(tv.capacity() >= 5);
/// From [Vec::reserve_exact](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.reserve_exact)
/// 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.
/// tv.reserve_exact(1);
/// Makes a new TinyVec with _at least_ the given capacity.
/// If the requested capacity is less than or equal to the array capacity you
/// get an inline vec. If it's greater than you get a heap vec.
/// let t = TinyVec::<[u8; 10]>::with_capacity(5);
/// assert!(t.is_inline());
/// assert!(t.capacity() >= 5);
/// let t = TinyVec::<[u8; 10]>::with_capacity(20);
/// assert!(t.is_heap());
/// assert!(t.capacity() >= 20);
r" Remove an element, swapping the end of the vec into its place.
"r" ## Panics
"r" * If the index is out of bounds.
"r" ## Example
"r" ```rust
"r" use tinyvec::*;
"r#" let mut tv = tiny_vec!([&str; 4] => "foo", "bar", "quack", "zap");
"#r#" assert_eq!(tv.swap_remove(1), "bar");
"#r#" assert_eq!(tv.as_slice(), &["foo", "zap", "quack"][..]);
"#r#" assert_eq!(tv.swap_remove(0), "foo");
"#r#" assert_eq!(tv.as_slice(), &["quack", "zap"][..]);
"#r" Remove and return the last element of the vec, if there is one.
"r" ## Failure
"r" * If the vec is empty you get `None`.
"r" Removes the item at `index`, shifting all others down by one index.
"r" Returns the removed element.
"r" If the index is out of bounds.
"r" let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
"r" assert_eq!(tv.remove(1), 2);
"r" assert_eq!(tv.as_slice(), &[1, 3][..]);
"r" The length of the vec (in elements).
"r" The capacity of the `TinyVec`.
"r" When not heap allocated this is fixed based on the array type.
"r" Otherwise its the result of the underlying Vec::capacity.
"r" Reduces the vec's length to the given value.
"r" If the vec is already shorter than the input, nothing happens.
"r" A mutable pointer to the backing array.
"r" ## Safety
"r" This pointer has provenance over the _entire_ backing array/buffer.
"r" A const pointer to the backing array.
"/// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);
/// tv.retain(|&x| x % 2 == 0);
/// assert_eq!(tv.as_slice(), &[2, 4][..]);
/// Helper for getting the mut slice.
/// Helper for getting the shared slice.
/// Removes all elements from the vec.
TinyVecDrain/// **Note: This method has significant performance issues compared to
/// matching on the TinyVec and then calling drain on the Inline or Heap value
/// inside. The draining iterator has to branch on every single access. It is
/// provided for simplicity and compatibility only.**
/// let tv2: TinyVec<[i32; 4]> = tv.drain(1..).collect();
/// assert_eq!(tv.as_slice(), &[1][..]);
/// assert_eq!(tv2.as_slice(), &[2, 3][..]);
/// tv.drain(..);
/// assert_eq!(tv.as_slice(), &[]);
/// Clone each element of the slice into this vec.
/// let mut tv = tiny_vec!([i32; 4] => 1, 2);
/// tv.extend_from_slice(&[3, 4]);
/// assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
/// Note that the `From` impl for arrays assumes the full length is used.
/// The length must be less than or equal to the capacity of the array.
constructor_for_capacity/// This is an internal implementation detail of the `tiny_vec!` macro, and
/// using it other than from that macro is not supported by this crate's
/// SemVer guarantee.
/// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3);
/// tv.insert(1, 4);
/// assert_eq!(tv.as_slice(), &[1, 4, 2, 3]);
/// tv.insert(4, 5);
/// assert_eq!(tv.as_slice(), &[1, 4, 2, 3, 5]);
/// If the vec is empty.
/// Makes a new, empty vec.
/// If it needs to be longer, it's filled with clones of the provided value.
/// If it needs to be shorter, it's truncated.
/// let mut tv = tiny_vec!([&str; 10] => "hello");
/// tv.resize(3, "world");
/// assert_eq!(tv.as_slice(), &["hello", "world", "world"][..]);
/// tv.resize(2, 0);
/// assert_eq!(tv.as_slice(), &[1, 2][..]);
/// let mut tv = tiny_vec!([i32; 3] => 1, 2, 3);
/// tv.resize_with(5, Default::default);
/// assert_eq!(tv.as_slice(), &[1, 2, 3, 0, 0][..]);
/// let mut tv = tiny_vec!([i32; 2]);
/// tv.resize_with(4, || {
/// assert_eq!(tv.as_slice(), &[2, 4, 8, 16][..]);
/// let tv2 = tv.split_off(1);
TinyVecSplice/// let tv2: TinyVec<[i32; 4]> = tv.splice(1.., 4..=6).collect();
/// assert_eq!(tv.as_slice(), &[1, 4, 5, 6][..]);
/// tv.splice(.., None);
/// Draining iterator for `TinyVecDrain`
/// See [`TinyVecDrain::drain`](TinyVecDrain::<A>::drain)
/// Splicing iterator for `TinyVec`
/// See [`TinyVec::splice`](TinyVec::<A>::splice)
TinyVecIterator/// Iterator for consuming an `TinyVec` and returning owned elements.
r" Returns the remaining items of this iterator as a slice.
"cfg_rtcfg_fsspawn_mandatory_blockingcfg_not_rtNotDefinedHere/// The name of a type which is not defined here./// This is typically used as an alias for another type, like so:/// /// See [some::other::location](https://example.com)./// type DEFINED_ELSEWHERE = crate::doc::NotDefinedHere;/// This type is uninhabitable like the [`never` type] to ensure that no one/// will ever accidentally use it./// [`never` type]: https://doc.rust-lang.org/std/primitive.never.html//! Types which are documented locally in the Tokio crate, but does not actually//! live here.//! **Note** this module is only visible on docs.rs, you cannot use it directly//! in your own code./// See [`std::os::windows::io::RawHandle`](https://doc.rust-lang.org/std/os/windows/io/type.RawHandle.html)/// See [`std::os::windows::io::OwnedHandle`](https://doc.rust-lang.org/std/os/windows/io/struct.OwnedHandle.html)/// See [`std::os::windows::io::AsRawHandle::as_raw_handle`](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawHandle.html#tymethod.as_raw_handle)/// See [`std::os::windows::io::AsRawHandle`](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawHandle.html)/// See [`std::os::windows::io::FromRawHandle::from_raw_handle`](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawHandle.html#tymethod.from_raw_handle)/// See [`std::os::windows::io::FromRawHandle`](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawHandle.html)/// See [`std::os::windows::io::RawSocket`](https://doc.rust-lang.org/std/os/windows/io/type.RawSocket.html)/// See [`std::os::windows::io::AsRawSocket::as_raw_socket`](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawSocket.html#tymethod.as_raw_socket)/// See [`std::os::windows::io::AsRawSocket`](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawSocket.html)/// See [`std::os::windows::io::FromRawSocket::from_raw_socket`](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawSocket.html#tymethod.from_raw_socket)/// See [`std::os::windows::io::FromRawSocket`](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawSocket.html)/// See [`std::os::windows::io::IntoRawSocket::into_raw_socket`](https://doc.rust-lang.org/std/os/windows/io/trait.IntoRawSocket.html#tymethod.into_raw_socket)/// See [`std::os::windows::io::IntoRawSocket`](https://doc.rust-lang.org/std/os/windows/io/trait.IntoRawSocket.html)/// See [`std::os::windows::io::BorrowedHandle`](https://doc.rust-lang.org/std/os/windows/io/struct.BorrowedHandle.html)/// See [`std::os::windows::io::AsHandle::as_handle`](https://doc.rust-lang.org/std/os/windows/io/trait.AsHandle.html#tymethod.as_handle)/// See [`std::os::windows::io::AsHandle`](https://doc.rust-lang.org/std/os/windows/io/trait.AsHandle.html)/// See [`std::os::windows::io::BorrowedSocket`](https://doc.rust-lang.org/std/os/windows/io/struct.BorrowedSocket.html)/// See [`std::os::windows::io::AsSocket::as_socket`](https://doc.rust-lang.org/std/os/windows/io/trait.AsSocket.html#tymethod.as_socket)/// See [`std::os::windows::io::AsSocket`](https://doc.rust-lang.org/std/os/windows/io/trait.AsSocket.html)/// Windows-specific extensions to general I/O primitives./// See [`std::os::windows::io`](https://doc.rust-lang.org/std/os/windows/io/index.html)./// Platform-specific extensions to `std` for Windows./// See [`std::os::windows`](https://doc.rust-lang.org/std/os/windows/index.html).//! See [`std::os`](https://doc.rust-lang.org/std/os/index.html).asyncify/// Returns the canonical, absolute form of a path with all intermediate/// components normalized and symbolic links resolved./// This is an async version of [`std::fs::canonicalize`]./// This function currently corresponds to the `realpath` function on Unix/// and the `CreateFile` and `GetFinalPathNameByHandle` functions on Windows./// Note that, this [may change in the future][changes]./// On Windows, this converts the path to use [extended length path][path]/// syntax, which allows your program to use longer path names, but means you/// can only join backslash-delimited paths to it, and it may be incompatible/// with other applications (if passed to the application on the command-line,/// or written to a file another application may read)./// [changes]: https://doc.rust-lang.org/std/io/index.html#platform-specific-behavior/// [path]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx#maxpath/// This function will return an error in the following situations, but is not/// limited to just these cases:/// * `path` does not exist./// * A non-final component in path is not a directory./// use tokio::fs;/// async fn main() -> io::Result<()> {///     let path = fs::canonicalize("../a/../foo.txt").await?;/// Copies the contents of one file to another. This function will also copy the permission bits/// of the original file to the destination file./// This function will overwrite the contents of to./// This is the async equivalent of [`std::fs::copy`]./// # async fn dox() -> std::io::Result<()> {/// fs::copy("foo.txt", "bar.txt").await?;/// Creates a new, empty directory at the provided path./// This is an async version of [`std::fs::create_dir`]./// This function currently corresponds to the `mkdir` function on Unix/// and the `CreateDirectory` function on Windows./// **NOTE**: If a parent of the given path doesn't exist, this function will/// return an error. To create a directory and all its missing parents at the/// same time, use the [`create_dir_all`] function./// * User lacks permissions to create directory at `path`./// * A parent of the given path doesn't exist. (To create a directory and all///   its missing parents at the same time, use the [`create_dir_all`]///   function.)/// * `path` already exists./// [`create_dir_all`]: super::create_dir_all()///     fs::create_dir("/some/dir").await?;/// Recursively creates a directory and all of its parent components if they/// are missing./// This is an async version of [`std::fs::create_dir_all`]./// * If any directory in the path specified by `path` does not already exist/// and it could not be created otherwise. The specific error conditions for/// when a directory is being created (after it is determined to not exist) are/// outlined by [`fs::create_dir`]./// Notable exception is made for situations where any of the directories/// specified in the `path` could not be created as it was being created concurrently./// Such cases are considered to be successful. That is, calling `create_dir_all`/// concurrently from multiple threads or processes is guaranteed not to fail/// due to a race condition with itself./// [`fs::create_dir`]: std::fs::create_dir/// async fn main() -> std::io::Result<()> {///     fs::create_dir_all("/some/dir").await?;/// Indicates whether to create parent directories if they are missing./// Sets the Unix mode for newly created directories./// A builder for creating directories in various manners./// This is a specialized version of [`std::fs::DirBuilder`] for usage on/// the Tokio runtime./// Creates a new set of options with default mode/security settings for all/// platforms and also non-recursive./// This is an async version of [`std::fs::DirBuilder::new`]./// use tokio::fs::DirBuilder;/// Indicates whether to create directories recursively (including all parent directories)./// Parents that do not exist are created with the same security and permissions settings./// This is an async version of [`std::fs::DirBuilder::recursive`]./// Creates the specified directory with the configured options./// It is considered an error if the directory already exists unless/// recursive mode is enabled./// This is an async version of [`std::fs::DirBuilder::create`]./// An error will be returned under the following circumstances:/// * Path already points to an existing file./// * Path already points to an existing directory and the mode is///   non-recursive./// * The calling process doesn't have permissions to create the directory///   or its missing parents./// * Other I/O error occurred.///     DirBuilder::new()///         .recursive(true)///         .create("/tmp/foo/bar/baz")///         .await?;r" Sets the mode to create new directories with."r" This option defaults to 0o777."r" use tokio::fs::DirBuilder;"r" let mut builder = DirBuilder::new();"r" builder.mode(0o775);"mocksmockallassert_pendingassert_ready_errassert_ready_okHELLOopen_readread_twice_before_dispatchread_with_smaller_bufread_with_bigger_bufread_err_then_read_successopen_writeflush_while_idleread_with_buffer_larger_than_max// takes a really long time with miriwrite_with_buffer_larger_than_maxwrite_twice_before_dispatchincomplete_read_followed_by_writeincomplete_partial_read_followed_by_writeincomplete_read_followed_by_flushincomplete_flush_followed_by_writeread_errwrite_write_errwrite_read_write_errwrite_read_flush_errwrite_seek_write_errwrite_seek_flush_errsync_all_ordered_after_writesync_all_err_ordered_after_writesync_data_ordered_after_writesync_data_err_ordered_after_writeopen_set_len_okopen_set_len_errpartial_read_set_len_okbusy_file_seek_errorDEFAULT_MAX_BUF_SIZEMockFileStdFile/// A reference to an open file on the filesystem./// This is a specialized version of [`std::fs::File`] for usage from the/// Tokio runtime./// An instance of a `File` can be read and/or written depending on what options/// it was opened with. Files also implement [`AsyncSeek`] to alter the logical/// cursor that the file contains internally./// A file will not be closed immediately when it goes out of scope if there/// are any IO operations that have not yet completed. To ensure that a file is/// closed immediately when it is dropped, you should call [`flush`] before/// dropping it. Note that this does not ensure that the file has been fully/// written to disk; the operating system might keep the changes around in an/// in-memory buffer. See the [`sync_all`] method for telling the OS to write/// the data to disk./// Reading and writing to a `File` is usually done using the convenience/// methods found on the [`AsyncReadExt`] and [`AsyncWriteExt`] traits./// [`AsyncSeek`]: trait@crate::io::AsyncSeek/// [`flush`]: fn@crate::io::AsyncWriteExt::flush/// [`sync_all`]: fn@crate::fs::File::sync_all/// [`AsyncReadExt`]: trait@crate::io::AsyncReadExt/// [`AsyncWriteExt`]: trait@crate::io::AsyncWriteExt/// Create a new file and asynchronously write bytes to it:/// use tokio::fs::File;/// use tokio::io::AsyncWriteExt; // for write_all()/// let mut file = File::create("foo.txt").await?;/// file.write_all(b"hello, world!").await?;/// Read the contents of a file into a buffer:/// use tokio::io::AsyncReadExt; // for read_to_end()/// let mut file = File::open("foo.txt").await?;/// let mut contents = vec![];/// println!("len = {}", contents.len());last_write_err/// Errors from writes/flushes are returned in write/flush calls. If a write/// error is observed while performing a read, it is saved until the next/// write / flush call./// Attempts to open a file in read-only mode./// See [`OpenOptions`] for more details./// This function will return an error if called from outside of the Tokio/// runtime or if path does not already exist. Other errors may also be/// returned according to `OpenOptions::open`./// use tokio::io::AsyncReadExt;/// The [`read_to_end`] method is defined on the [`AsyncReadExt`] trait./// [`read_to_end`]: fn@crate::io::AsyncReadExt::read_to_end/// This function will create a file if it does not exist, and will truncate/// it if it does./// Results in an error if called from outside of the Tokio runtime or if/// the underlying [`create`] call results in an error./// [`create`]: std::fs::File::create/// use tokio::io::AsyncWriteExt;/// The [`write_all`] method is defined on the [`AsyncWriteExt`] trait./// [`write_all`]: fn@crate::io::AsyncWriteExt::write_all/// Opens a file in read-write mode./// This function will create a file if it does not exist, or return an error/// if it does. This way, if the call succeeds, the file returned is guaranteed/// to be new./// This option is useful because it is atomic. Otherwise between checking/// whether a file exists and creating a new one, the file may have been/// created by another process (a TOCTOU race condition / attack)./// This can also be written using `File::options().read(true).write(true).create_new(true).open(...)`./// let mut file = File::create_new("foo.txt").await?;/// Returns a new [`OpenOptions`] object./// This function returns a new `OpenOptions` object that you can use to/// open or create a file with specific options if `open()` or `create()`/// are not appropriate./// It is equivalent to `OpenOptions::new()`, but allows you to write more/// readable code. Instead of/// `OpenOptions::new().append(true).open("example.log")`,/// you can write `File::options().append(true).open("example.log")`. This/// also avoids the need to import `OpenOptions`./// See the [`OpenOptions::new`] function for more details./// let mut f = File::options().append(true).open("example.log").await?;/// f.write_all(b"new line\n").await?;/// Converts a [`std::fs::File`] to a [`tokio::fs::File`](File)./// // This line could block. It is not recommended to do this on the Tokio/// // runtime./// let std_file = std::fs::File::open("foo.txt").unwrap();/// let file = tokio::fs::File::from_std(std_file);/// Attempts to sync all OS-internal metadata to disk./// This function will attempt to ensure that all in-core data reaches the/// filesystem before returning./// This function is similar to `sync_all`, except that it may not/// synchronize file metadata to the filesystem./// This is intended for use cases that must synchronize content, but don't/// need the metadata on disk. The goal of this method is to reduce disk/// Note that some platforms may simply implement this in terms of `sync_all`./// Truncates or extends the underlying file, updating the size of this file to become size./// If the size is less than the current file's size, then the file will be/// shrunk. If it is greater than the current file's size, then the file/// will be extended to size and have all of the intermediate data filled in/// with 0s./// This function will return an error if the file is not opened for/// Queries metadata about the underlying file./// let file = File::open("foo.txt").await?;/// println!("{:?}", metadata);/// Creates a new `File` instance that shares the same underlying file handle/// as the existing `File` instance. Reads, writes, and seeks will affect both/// File instances simultaneously./// let file_clone = file.try_clone().await?;/// Destructures `File` into a [`std::fs::File`]. This function is/// async to allow any in-flight operations to complete./// Use `File::try_into_std` to attempt conversion immediately./// let tokio_file = File::open("foo.txt").await?;/// let std_file = tokio_file.into_std().await;try_into_std/// Tries to immediately destructure `File` into a [`std::fs::File`]./// This function will return an error containing the file if some/// operation is in-flight./// let std_file = tokio_file.try_into_std().unwrap();/// Changes the permissions on the underlying file./// This function currently corresponds to the `fchmod` function on Unix and/// the `SetFileInformationByHandle` function on Windows. Note that, this/// [may change in the future][changes]./// This function will return an error if the user lacks permission change/// attributes on the underlying file. It may also return an error in other/// os-specific unspecified cases./// Set the maximum buffer size for the underlying [`AsyncRead`] / [`AsyncWrite`] operation./// Although Tokio uses a sensible default value for this buffer size, this function would be/// useful for changing that default depending on the situation./// // Set maximum buffer size to 8 MiB/// file.set_max_buf_size(8 * 1024 * 1024);/// let mut buf = vec![1; 1024 * 1024 * 1024];/// // Write the 1 GiB buffer in chunks up to 8 MiB each./// file.write_all(&mut buf).await?;start_seekcfg_windowscomplete_inflightpoll_complete_inflight//! Types for working with [`File`].//! [`File`]: File/// Creates a new hard link on the filesystem./// This is an async version of [`std::fs::hard_link`]./// The `link` path will be a link pointing to the `original` path. Note that systems/// often require these two paths to both be located on the same filesystem./// This function currently corresponds to the `link` function on Unix/// and the `CreateHardLink` function on Windows./// * The `original` path is not a file or doesn't exist.///     fs::hard_link("a.txt", "b.txt").await?; // Hard link a.txt to b.txt/// Given a path, queries the file system to get information about a file,/// directory, etc./// This is an async version of [`std::fs::metadata`]./// This function will traverse symbolic links to query information about the/// destination file./// This function currently corresponds to the `stat` function on Unix and the/// `GetFileAttributesEx` function on Windows.  Note that, this [may change in/// the future][changes]./// * The user lacks permissions to perform `metadata` call on `path`.///     let attr = fs::metadata("/some/file/path.txt").await?;///     // inspect attr ...tokio_thread_localrun_one//! Mock version of std::fs::File;dir_builderopen_optionstry_exists//! Asynchronous file utilities.//! This module contains utility methods for working with the file system//! asynchronously. This includes reading/writing to files, and working with//! directories.//! Be aware that most operating systems do not provide asynchronous file system//! APIs. Because of that, Tokio will use ordinary blocking file operations//! behind the scenes. This is done using the [`spawn_blocking`] threadpool to//! run them in the background.//! The `tokio::fs` module should only be used for ordinary files. Trying to use//! it with e.g., a named pipe on Linux can result in surprising behavior,//! such as hangs during runtime shutdown. For special files, you should use a//! dedicated type such as [`tokio::net::unix::pipe`] or [`AsyncFd`] instead.//! Currently, Tokio will always use [`spawn_blocking`] on all platforms, but it//! may be changed to use asynchronous file system APIs such as io_uring in the//! The easiest way to use this module is to use the utility functions that//! operate on entire files://!  * [`tokio::fs::read`](fn@crate::fs::read)//!  * [`tokio::fs::read_to_string`](fn@crate::fs::read_to_string)//!  * [`tokio::fs::write`](fn@crate::fs::write)//! The two `read` functions reads the entire file and returns its contents.//! The `write` function takes the contents of the file and writes those//! contents to the file. It overwrites the existing file, if any.//! For example, to read the file://! # async fn dox() -> std::io::Result<()> {//! let contents = tokio::fs::read_to_string("my_file.txt").await?;//! println!("File has {} lines.", contents.lines().count());//! To overwrite the file://! let contents = "First line.\nSecond line.\nThird line.\n";//! tokio::fs::write("my_file.txt", contents.as_bytes()).await?;//! ## Using `File`//! The main type for interacting with files is [`File`]. It can be used to read//! from and write to a given file. This is done using the [`AsyncRead`] and//! [`AsyncWrite`] traits. This type is generally used when you want to do//! something more complex than just reading or writing the entire contents in//! one go.//! **Note:** It is important to use [`flush`] when writing to a Tokio//! [`File`]. This is because calls to `write` will return before the write has//! finished, and [`flush`] will wait for the write to finish. (The write will//! happen even if you don't flush; it will just happen later.) This is//! different from [`std::fs::File`], and is due to the fact that `File` uses//! `spawn_blocking` behind the scenes.//! For example, to count the number of lines in a file without loading the//! entire file into memory://! use tokio::fs::File;//! use tokio::io::AsyncReadExt;//! let mut file = File::open("my_file.txt").await?;//! let mut chunk = vec![0; 4096];//! let mut number_of_lines = 0;//!     let len = file.read(&mut chunk).await?;//!     if len == 0 {//!         // Length of zero means end of file.//!     for &b in &chunk[..len] {//!         if b == b'\n' {//!             number_of_lines += 1;//! println!("File has {} lines.", number_of_lines);//! For example, to write a file line-by-line://! use tokio::io::AsyncWriteExt;//! let mut file = File::create("my_file.txt").await?;//! file.write_all(b"First line.\n").await?;//! file.write_all(b"Second line.\n").await?;//! file.write_all(b"Third line.\n").await?;//! // Remember to call `flush` after writing!//! ## Tuning your file IO//! Tokio's file uses [`spawn_blocking`] behind the scenes, and this has serious//! performance consequences. To get good performance with file IO on Tokio, it//! is recommended to batch your operations into as few `spawn_blocking` calls//! as possible.//! One example of this difference can be seen by comparing the two reading//! examples above. The first example uses [`tokio::fs::read`], which reads the//! entire file in a single `spawn_blocking` call, and then returns it. The//! second example will read the file in chunks using many `spawn_blocking`//! calls. This means that the second example will most likely be more expensive//! for large files. (Of course, using chunks may be necessary for very large//! files that don't fit in memory.)//! The following examples will show some strategies for this://! When creating a file, write the data to a `String` or `Vec<u8>` and then//! write the entire file in a single `spawn_blocking` call with//! `tokio::fs::write`.//! contents.push_str("First line.\n");//! contents.push_str("Second line.\n");//! contents.push_str("Third line.\n");//! Use [`BufReader`] and [`BufWriter`] to buffer many small reads or writes//! into a few large ones. This example will most likely only perform one//! `spawn_blocking` call.//! use tokio::io::{AsyncWriteExt, BufWriter};//! let mut file = BufWriter::new(File::create("my_file.txt").await?);//! // Due to the BufWriter, the actual write and spawn_blocking//! // call happens when you flush.//! Manually use [`std::fs`] inside [`spawn_blocking`].//! use tokio::task::spawn_blocking;//! spawn_blocking(move || {//!     let mut file = File::create("my_file.txt")?;//!     file.write_all(b"First line.\n")?;//!     file.write_all(b"Second line.\n")?;//!     file.write_all(b"Third line.\n")?;//!     // Unlike Tokio's file, the std::fs file does//!     // not need flush.//!     io::Result::Ok(())//! }).await.unwrap()?;//! It's also good to be aware of [`File::set_max_buf_size`], which controls the//! maximum amount of bytes that Tokio's [`File`] will read or write in a single//! [`spawn_blocking`] call. The default is two megabytes, but this is subject//! to change.//! [`spawn_blocking`]: fn@crate::task::spawn_blocking//! [`AsyncRead`]: trait@crate::io::AsyncRead//! [`AsyncWrite`]: trait@crate::io::AsyncWrite//! [`BufReader`]: struct@crate::io::BufReader//! [`BufWriter`]: struct@crate::io::BufWriter//! [`tokio::net::unix::pipe`]: crate::net::unix::pipe//! [`AsyncFd`]: crate::io::unix::AsyncFd//! [`flush`]: crate::io::AsyncWriteExt::flush//! [`tokio::fs::read`]: fn@crate::fs::read//! Mock version of `std::fs::OpenOptions`;mock_open_optionsMockOpenOptionsStdOpenOptions/// Options and flags which can be used to configure how a file is opened./// This builder exposes the ability to configure how a [`File`] is opened and/// what operations are permitted on the open file. The [`File::open`] and/// [`File::create`] methods are aliases for commonly used options using this/// Generally speaking, when using `OpenOptions`, you'll first call [`new`],/// then chain calls to methods to set each option, then call [`open`], passing/// the path of the file you're trying to open. This will give you a/// [`io::Result`] with a [`File`] inside that you can further operate/// on./// This is a specialized version of [`std::fs::OpenOptions`] for usage from/// `From<std::fs::OpenOptions>` is implemented for more advanced configuration/// than the methods provided here./// [`new`]: OpenOptions::new/// [`open`]: OpenOptions::open/// [`File`]: File/// [`File::open`]: File::open/// [`File::create`]: File::create/// Opening a file to read:/// use tokio::fs::OpenOptions;///     let file = OpenOptions::new()///         .read(true)///         .open("foo.txt")/// Opening a file for both reading and writing, as well as creating it if it/// doesn't exist:///         .write(true)///         .create(true)/// Creates a blank new set of options ready for configuration./// This is an async version of [`std::fs::OpenOptions::new`][std]/// [std]: std::fs::OpenOptions::new/// let future = options.read(true).open("foo.txt");/// Sets the option for read access./// This option, when true, will indicate that the file should be/// `read`-able if opened./// This is an async version of [`std::fs::OpenOptions::read`][std]/// [std]: std::fs::OpenOptions::read/// Sets the option for write access./// `write`-able if opened./// This is an async version of [`std::fs::OpenOptions::write`][std]/// [std]: std::fs::OpenOptions::write/// Sets the option for the append mode./// This option, when true, means that writes will append to a file instead/// of overwriting previous contents.  Note that setting/// `.write(true).append(true)` has the same effect as setting only/// `.append(true)`./// For most filesystems, the operating system guarantees that all writes are/// atomic: no writes get mangled because another process writes at the same/// One maybe obvious note when using append-mode: make sure that all data/// that belongs together is written to the file in one operation. This/// can be done by concatenating strings before passing them to [`write()`],/// or using a buffered writer (with a buffer of adequate size),/// and calling [`flush()`] when the message is complete./// If a file is opened with both read and append access, beware that after/// opening, and after every write, the position for reading may be set at the/// end of the file. So, before writing, save the current position (using/// [`seek`]`(`[`SeekFrom`]`::`[`Current`]`(0))`), and restore it before the next read./// This is an async version of [`std::fs::OpenOptions::append`][std]/// [std]: std::fs::OpenOptions::append/// This function doesn't create the file if it doesn't exist. Use the [`create`]/// method to do so./// [`write()`]: crate::io::AsyncWriteExt::write/// [`flush()`]: crate::io::AsyncWriteExt::flush/// [`seek`]: crate::io::AsyncSeekExt::seek/// [`SeekFrom`]: std::io::SeekFrom/// [`Current`]: std::io::SeekFrom::Current/// [`create`]: OpenOptions::create///         .append(true)/// Sets the option for truncating a previous file./// If a file is successfully opened with this option set it will truncate/// the file to 0 length if it already exists./// The file must be opened with write access for truncate to work./// This is an async version of [`std::fs::OpenOptions::truncate`][std]/// [std]: std::fs::OpenOptions::truncate///         .truncate(true)/// Sets the option for creating a new file./// This option indicates whether a new file will be created if the file/// does not yet already exist./// In order for the file to be created, [`write`] or [`append`] access must/// This is an async version of [`std::fs::OpenOptions::create`][std]/// [std]: std::fs::OpenOptions::create/// [`write`]: OpenOptions::write/// [`append`]: OpenOptions::append/// Sets the option to always create a new file./// This option indicates whether a new file will be created.  No file is/// allowed to exist at the target location, also no (dangling) symlink./// If `.create_new(true)` is set, [`.create()`] and [`.truncate()`] are/// ignored./// The file must be opened with write or append access in order to create a/// new file./// This is an async version of [`std::fs::OpenOptions::create_new`][std]/// [std]: std::fs::OpenOptions::create_new/// [`.create()`]: OpenOptions::create/// [`.truncate()`]: OpenOptions::truncate///         .create_new(true)/// Opens a file at `path` with the options specified by `self`./// This is an async version of [`std::fs::OpenOptions::open`][std]/// [std]: std::fs::OpenOptions::open/// This function will return an error under a number of different/// circumstances. Some of these error conditions are listed here, together/// with their [`ErrorKind`]. The mapping to [`ErrorKind`]s is not part of/// the compatibility contract of the function, especially the `Other` kind/// might change to more specific kinds in the future./// * [`NotFound`]: The specified file does not exist and neither `create`///   or `create_new` is set./// * [`NotFound`]: One of the directory components of the file path does///   not exist./// * [`PermissionDenied`]: The user lacks permission to get the specified///   access rights for the file./// * [`PermissionDenied`]: The user lacks permission to open one of the///   directory components of the specified path./// * [`AlreadyExists`]: `create_new` was specified and the file already///   exists./// * [`InvalidInput`]: Invalid combinations of open options (truncate///   without write access, no access mode set, etc.)./// * [`Other`]: One of the directory components of the specified file path///   was not, in fact, a directory./// * [`Other`]: Filesystem-level errors: full disk, write permission///   requested on a read-only file system, exceeded disk quota, too many///   open files, too long filename, too many symbolic links in the///   specified path (Unix-like systems only), etc.///     let file = OpenOptions::new().open("foo.txt").await?;/// [`ErrorKind`]: std::io::ErrorKind/// [`AlreadyExists`]: std::io::ErrorKind::AlreadyExists/// [`InvalidInput`]: std::io::ErrorKind::InvalidInput/// [`NotFound`]: std::io::ErrorKind::NotFound/// [`Other`]: std::io::ErrorKind::Other/// [`PermissionDenied`]: std::io::ErrorKind::PermissionDenied/// Returns a mutable reference to the underlying `std::fs::OpenOptions`r" Sets the mode bits that a new file will be created with."r" If a new file is created as part of an `OpenOptions::open` call then this"r" specified `mode` will be used as the permission bits for the new file."r" If no `mode` is set, the default of `0o666` will be used."r" The operating system masks out bits with the system's `umask`, to produce"r" the final permissions."r" use tokio::fs::OpenOptions;"r" #[tokio::main]"r" async fn main() -> io::Result<()> {"r"     let mut options = OpenOptions::new();"r"     options.mode(0o644); // Give read/write for owner and read for others."r#"     let file = options.open("foo.txt").await?;"#r" Passes custom flags to the `flags` argument of `open`."r" The bits that define the access mode are masked out with `O_ACCMODE`, to"r" ensure they do not interfere with the access mode set by Rusts options."r" Custom flags can only set flags, not remove flags set by Rusts options."r" This options overwrites any previously set custom flags."r"     options.write(true);"r"     if cfg!(unix) {"r"         options.custom_flags(libc::O_NOFOLLOW);"/// Reads the entire contents of a file into a bytes vector./// This is an async version of [`std::fs::read`]./// This is a convenience function for using [`File::open`] and [`read_to_end`]/// with fewer imports and without an intermediate variable. It pre-allocates a/// buffer based on the file size when available, so it is generally faster than/// reading into a vector created with `Vec::new()`./// This operation is implemented by running the equivalent blocking operation/// on a separate thread pool using [`spawn_blocking`]./// [`File::open`]: super::File::open/// [`read_to_end`]: crate::io::AsyncReadExt::read_to_end/// [`spawn_blocking`]: crate::task::spawn_blocking/// This function will return an error if `path` does not already exist./// Other errors may also be returned according to [`OpenOptions::open`]./// [`OpenOptions::open`]: super::OpenOptions::open/// It will also return an error if it encounters while reading an error/// of a kind other than [`ErrorKind::Interrupted`]./// [`ErrorKind::Interrupted`]: std::io::ErrorKind::Interrupted/// async fn main() -> Result<(), Box<dyn std::error::Error + 'static>> {///     let contents = fs::read("address.txt").await?;///     let foo: SocketAddr = String::from_utf8_lossy(&contents).parse()?;/// Returns a stream over the entries within a directory./// This is an async version of [`std::fs::read_dir`]./// This operation is implemented by running the equivalent blocking/// operation on a separate thread pool using [`spawn_blocking`]./// Reads the entries in a directory./// This struct is returned from the [`read_dir`] function of this module and/// will yield instances of [`DirEntry`]. Through a [`DirEntry`] information/// like the entry's path and possibly other metadata can be learned./// A `ReadDir` can be turned into a `Stream` with [`ReadDirStream`]./// [`ReadDirStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.ReadDirStream.html/// This stream will return an [`Err`] if there's some sort of intermittent/// IO error during iteration./// [`read_dir`]: read_dir/// [`DirEntry`]: DirEntry/// [`Err`]: std::result::Result::Err/// Returns the next entry in the directory stream./// This method is cancellation safe.poll_next_entry/// Polls for the next directory entry in the stream.///  * `Poll::Pending` if the next directory entry is not yet available.///  * `Poll::Ready(Ok(Some(entry)))` if the next directory entry is available.///  * `Poll::Ready(Ok(None))` if there are no more directory entries in this///    stream.///  * `Poll::Ready(Err(err))` if an IO error occurred while reading the next///    directory entry./// When the method returns `Poll::Pending`, the `Waker` in the provided/// `Context` is scheduled to receive a wakeup when the next directory entry/// becomes available on the underlying IO resource./// Note that on multiple calls to `poll_next_entry`, only the `Waker` from/// the `Context` passed to the most recent call is scheduled to receive a/// wakeup.next_chunkr" Returns the underlying `d_ino` field in the contained `dirent`"r" structure."r" use tokio::fs;"r" # #[tokio::main]"r" # async fn main() -> std::io::Result<()> {"r#" let mut entries = fs::read_dir(".").await?;"#r" while let Some(entry) = entries.next_entry().await? {"r"     // Here, `entry` is a `DirEntry`."r#"     println!("{:?}: {}", entry.file_name(), entry.ino());"#/// Entries returned by the [`ReadDir`] stream./// [`ReadDir`]: struct@ReadDir/// This is a specialized version of [`std::fs::DirEntry`] for usage from the/// An instance of `DirEntry` represents an entry inside of a directory on the/// filesystem. Each entry can be inspected via methods to learn about the full/// path or possibly other metadata through per-platform extension traits./// Returns the full path to the file that this entry represents./// The full path is created by joining the original path to `read_dir`/// with the filename of this entry./// let mut entries = fs::read_dir(".").await?;/// while let Some(entry) = entries.next_entry().await? {/// This prints output like:/// "./whatever.txt"/// "./foo.html"/// "./hello_world.rs"/// The exact text, of course, depends on what files you have in `.`./// Returns the bare file name of this directory entry without any other/// leading path component.///     println!("{:?}", entry.file_name());/// Returns the metadata for the file that this entry points at./// This function will not traverse symlinks if this entry points at a/// symlink./// On Windows this function is cheap to call (no extra system calls/// needed), but on Unix platforms this function is the equivalent of/// calling `symlink_metadata` on the path.///     if let Ok(metadata) = entry.metadata().await {///         // Now let's show our entry's permissions!///         println!("{:?}: {:?}", entry.path(), metadata.permissions());///         println!("Couldn't get file type for {:?}", entry.path());/// Returns the file type for the file that this entry points at./// On Windows and most Unix platforms this function is free (no extra/// system calls needed), but some Unix platforms may require the equivalent/// call to `symlink_metadata` to learn about the target file type.///     if let Ok(file_type) = entry.file_type().await {///         // Now let's show our entry's file type!///         println!("{:?}: {:?}", entry.path(), file_type);as_inner/// Returns a reference to the underlying `std::fs::DirEntry`./// Reads a symbolic link, returning the file that the link points to./// This is an async version of [`std::fs::read_link`]./// Creates a future which will open a file for reading and read the entire/// contents into a string and return said string./// This is the async equivalent of [`std::fs::read_to_string`][std]./// [std]: fn@std::fs::read_to_string/// let contents = fs::read_to_string("foo.txt").await?;/// println!("foo.txt contains {} bytes", contents.len());/// Removes an existing, empty directory./// This is an async version of [`std::fs::remove_dir`]./// Removes a directory at this path, after removing all its contents. Use carefully!/// This is an async version of [`std::fs::remove_dir_all`][std]/// [std]: fn@std::fs::remove_dir_all/// Removes a file from the filesystem./// Note that there is no guarantee that the file is immediately deleted (e.g./// depending on platform, other open file descriptors may prevent immediate/// removal)./// This is an async version of [`std::fs::remove_file`]./// Renames a file or directory to a new name, replacing the original file if/// `to` already exists./// This will not work if the new name is on a different mount point./// This is an async version of [`std::fs::rename`]./// Changes the permissions found on a file or a directory./// This is an async version of [`std::fs::set_permissions`][std]/// [std]: fn@std::fs::set_permissions/// The `link` path will be a symbolic link pointing to the `original` path./// This is an async version of [`std::os::unix::fs::symlink`].symlink_dir/// Creates a new directory symlink on the filesystem./// The `link` path will be a directory symbolic link pointing to the `original`/// This is an async version of [`std::os::windows::fs::symlink_dir`][std]/// [std]: https://doc.rust-lang.org/std/os/windows/fs/fn.symlink_dir.htmlsymlink_file/// Creates a new file symbolic link on the filesystem./// The `link` path will be a file symbolic link pointing to the `original`/// This is an async version of [`std::os::windows::fs::symlink_file`][std]/// [std]: https://doc.rust-lang.org/std/os/windows/fs/fn.symlink_file.html/// Queries the file system metadata for a path./// This is an async version of [`std::fs::symlink_metadata`][std]/// [std]: fn@std::fs::symlink_metadata/// Returns `Ok(true)` if the path points at an existing entity./// destination file. In case of broken symbolic links this will return `Ok(false)`./// This is the async equivalent of [`std::path::Path::try_exists`][std]./// [std]: fn@std::path::Path::try_exists/// fs::try_exists("foo.txt").await?;/// Creates a future that will open a file for writing and write the entire/// contents of `contents` to it./// This is the async equivalent of [`std::fs::write`][std]./// [std]: fn@std::fs::write/// fs::write("foo.txt", b"Hello world!").await?;r" A future that may have completed."r" A not-yet-completed future."r" The output of the completed future."r" The empty variant after the result of a [`MaybeDone`] has been"r" taken using the [`take_output`](MaybeDone::take_output) method."MaybeDoneProjMaybeDoneProjReplace/// Wraps a future into a `MaybeDone`./// Attempts to take the output of a `MaybeDone` without driving itthingThingAddermaybe_done_miriDummyWakermiri_tests// Test for https://github.com/tokio-rs/tokio/issues/6729//! Definition of the [`MaybeDone`] combinator.cfg_processcfg_synccfg_tracecfg_not_traceInstrumentedFutureInstrumentedfuture3fuzz_linked_list/// Attempts to return the contents of the internal buffer, filling it with more data/// Reads bytes asynchronously./// This trait is analogous to [`std::io::BufRead`], but integrates with/// the asynchronous task system. In particular, the [`poll_fill_buf`] method,/// unlike [`BufRead::fill_buf`], will automatically queue the current task for wakeup/// and return if data is not yet available, rather than blocking the calling/// Utilities for working with `AsyncBufRead` values are provided by/// [`AsyncBufReadExt`]./// [`std::io::BufRead`]: std::io::BufRead/// [`BufRead::fill_buf`]: std::io::BufRead::fill_buf/// [`AsyncBufReadExt`]: crate::io::AsyncBufReadExtReadyEventscheduler// The inner value is always present. the Option is required for `drop` and `into_inner`.// In all other methods `unwrap` is valid, and will never panic./// Associates an IO object backed by a Unix file descriptor with the tokio/// reactor, allowing for readiness to be polled. The file descriptor must be of/// a type that can be used with the OS polling facilities (ie, `poll`, `epoll`,/// `kqueue`, etc), such as a network socket or pipe, and the file descriptor/// must have the nonblocking mode set to true./// Creating an [`AsyncFd`] registers the file descriptor with the current tokio/// Reactor, allowing you to directly await the file descriptor being readable/// or writable. Once registered, the file descriptor remains registered until/// the [`AsyncFd`] is dropped./// The [`AsyncFd`] takes ownership of an arbitrary object to represent the IO/// object. It is intended that the inner object will handle closing the file/// descriptor when it is dropped, avoiding resource leaks and ensuring that the/// [`AsyncFd`] can clean up the registration before closing the file descriptor./// The [`AsyncFd::into_inner`] function can be used to extract the inner object/// to retake control from the tokio IO reactor. The [`OwnedFd`] type is often/// used as the inner object, as it is the simplest type that closes the fd on/// drop./// The inner object is required to implement [`AsRawFd`]. This file descriptor/// must not change while [`AsyncFd`] owns the inner object, i.e. the/// [`AsRawFd::as_raw_fd`] method on the inner type must always return the same/// file descriptor when called multiple times. Failure to uphold this results/// in unspecified behavior in the IO driver, which may include breaking/// notifications for other sockets/etc./// Polling for readiness is done by calling the async functions [`readable`]/// and [`writable`]. These functions complete when the associated readiness/// condition is observed. Any number of tasks can query the same `AsyncFd` in/// parallel, on the same or different conditions./// On some platforms, the readiness detecting mechanism relies on/// edge-triggered notifications. This means that the OS will only notify Tokio/// when the file descriptor transitions from not-ready to ready. For this to/// work you should first try to read or write and only poll for readiness/// if that fails with an error of [`std::io::ErrorKind::WouldBlock`]./// Tokio internally tracks when it has received a ready notification, and when/// readiness checking functions like [`readable`] and [`writable`] are called,/// if the readiness flag is set, these async functions will complete/// immediately. This however does mean that it is critical to ensure that this/// ready flag is cleared when (and only when) the file descriptor ceases to be/// ready. The [`AsyncFdReadyGuard`] returned from readiness checking functions/// serves this function; after calling a readiness-checking async function,/// you must use this [`AsyncFdReadyGuard`] to signal to tokio whether the file/// descriptor is no longer in a ready state./// ## Use with to a poll-based API/// In some cases it may be desirable to use `AsyncFd` from APIs similar to/// [`TcpStream::poll_read_ready`]. The [`AsyncFd::poll_read_ready`] and/// [`AsyncFd::poll_write_ready`] functions are provided for this purpose./// Because these functions don't create a future to hold their state, they have/// the limitation that only one task can wait on each direction (read or write)/// at a time./// This example shows how to turn [`std::net::TcpStream`] asynchronous using/// `AsyncFd`.  It implements the read/write operations both as an `async fn`/// and using the IO traits [`AsyncRead`] and [`AsyncWrite`]./// use std::io::{self, Read, Write};/// use std::task::{ready, Context, Poll};/// use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};/// use tokio::io::unix::AsyncFd;/// pub struct AsyncTcpStream {///     inner: AsyncFd<TcpStream>,/// impl AsyncTcpStream {///     pub fn new(tcp: TcpStream) -> io::Result<Self> {///         tcp.set_nonblocking(true)?;///         Ok(Self {///             inner: AsyncFd::new(tcp)?,///     pub async fn read(&self, out: &mut [u8]) -> io::Result<usize> {///         loop {///             let mut guard = self.inner.readable().await?;///             match guard.try_io(|inner| inner.get_ref().read(out)) {///                 Ok(result) => return result,///                 Err(_would_block) => continue,///     pub async fn write(&self, buf: &[u8]) -> io::Result<usize> {///             let mut guard = self.inner.writable().await?;///             match guard.try_io(|inner| inner.get_ref().write(buf)) {/// impl AsyncRead for AsyncTcpStream {///     fn poll_read(///         self: Pin<&mut Self>,///         cx: &mut Context<'_>,///         buf: &mut ReadBuf<'_>///     ) -> Poll<io::Result<()>> {///             let mut guard = ready!(self.inner.poll_read_ready(cx))?;///             let unfilled = buf.initialize_unfilled();///             match guard.try_io(|inner| inner.get_ref().read(unfilled)) {///                 Ok(Ok(len)) => {///                     buf.advance(len);///                     return Poll::Ready(Ok(()));///                 },///                 Ok(Err(err)) => return Poll::Ready(Err(err)),/// impl AsyncWrite for AsyncTcpStream {///     fn poll_write(///         buf: &[u8]///     ) -> Poll<io::Result<usize>> {///             let mut guard = ready!(self.inner.poll_write_ready(cx))?;///                 Ok(result) => return Poll::Ready(result),///     fn poll_flush(///         // tcp flush is a no-op///         Poll::Ready(Ok(()))///     fn poll_shutdown(///         self.inner.get_ref().shutdown(std::net::Shutdown::Write)?;/// [`readable`]: method@Self::readable/// [`writable`]: method@Self::writable/// [`AsyncFdReadyGuard`]: struct@self::AsyncFdReadyGuard/// [`TcpStream::poll_read_ready`]: struct@crate::net::TcpStream/// [`AsyncRead`]: trait@crate::io::AsyncRead/// [`AsyncWrite`]: trait@crate::io::AsyncWrite/// [`OwnedFd`]: struct@std::os::fd::OwnedFd"You must explicitly choose whether to clear the readiness state by calling a method on ReadyGuard"async_fdAsyncFdReadyGuard/// Represents an IO-ready event detected on a particular file descriptor that/// has not yet been acknowledged. This is a `must_use` structure to help ensure/// that you do not forget to explicitly clear (or not clear) the event./// This type exposes an immutable reference to the underlying IO object.AsyncFdReadyMutGuard/// This type exposes a mutable reference to the underlying IO object./// Creates an [`AsyncFd`] backed by (and taking ownership of) an object/// implementing [`AsRawFd`]. The backing file descriptor is cached at the/// time of creation./// Only configures the [`Interest::READABLE`] and [`Interest::WRITABLE`] interests. For more/// control, use [`AsyncFd::with_interest`]./// This method must be called in the context of a tokio runtime./// This function panics if there is no current reactor set, or if the `rt`/// feature flag is not enabled.with_interest/// implementing [`AsRawFd`], with a specific [`Interest`]. The backing/// file descriptor is cached at the time of creation.new_with_handle_and_interestAsyncFdTryNewError/// control, use [`AsyncFd::try_with_interest`]./// In the case of failure, it returns [`AsyncFdTryNewError`] that contains the original objecttry_with_interesttry_new_with_handle_and_interest/// Returns a shared reference to the backing object of this [`AsyncFd`]./// Returns a mutable reference to the backing object of this [`AsyncFd`]./// Deregisters this file descriptor and returns ownership of the backingpoll_read_ready/// Polls for read readiness./// If the file descriptor is not currently ready for reading, this method/// will store a clone of the [`Waker`] from the provided [`Context`]. When the/// file descriptor becomes ready for reading, [`Waker::wake`] will be called./// Note that on multiple calls to [`poll_read_ready`] or/// [`poll_read_ready_mut`], only the `Waker` from the `Context` passed to the/// most recent call is scheduled to receive a wakeup. (However,/// [`poll_write_ready`] retains a second, independent waker)./// This method is intended for cases where creating and pinning a future/// via [`readable`] is not feasible. Where possible, using [`readable`] is/// preferred, as this supports polling from multiple tasks at once./// This method takes `&self`, so it is possible to call this method/// concurrently with other methods on this struct. This method only/// provides shared access to the inner IO resource when handling the/// [`AsyncFdReadyGuard`]./// [`poll_read_ready`]: method@Self::poll_read_ready/// [`poll_read_ready_mut`]: method@Self::poll_read_ready_mut/// [`poll_write_ready`]: method@Self::poll_write_ready/// [`Context`]: struct@std::task::Context/// [`Waker`]: struct@std::task::Waker/// [`Waker::wake`]: method@std::task::Waker::wakepoll_read_ready_mut/// This method takes `&mut self`, so it is possible to access the inner IO/// resource mutably when handling the [`AsyncFdReadyMutGuard`].poll_write_ready/// Polls for write readiness./// If the file descriptor is not currently ready for writing, this method/// file descriptor becomes ready for writing, [`Waker::wake`] will be called./// Note that on multiple calls to [`poll_write_ready`] or/// [`poll_write_ready_mut`], only the `Waker` from the `Context` passed to the/// [`poll_read_ready`] retains a second, independent waker)./// via [`writable`] is not feasible. Where possible, using [`writable`] is/// [`poll_write_ready_mut`]: method@Self::poll_write_ready_mut/// [`writable`]: method@Self::readablepoll_write_ready_mut/// Waits for any of the requested ready states, returning a/// [`AsyncFdReadyGuard`] that must be dropped to resume/// polling for the requested ready states./// The function may complete without the file descriptor being ready. This is a/// false-positive and attempting an operation will return with/// `io::ErrorKind::WouldBlock`. The function can also return with an empty/// [`Ready`] set, so you should always check the returned value and possibly/// wait again if the requested states are not set./// When an IO operation does return `io::ErrorKind::WouldBlock`, the readiness must be cleared./// When a combined interest is used, it is important to clear only the readiness/// that is actually observed to block. For instance when the combined/// interest `Interest::READABLE | Interest::WRITABLE` is used, and a read blocks, only/// read readiness should be cleared using the [`AsyncFdReadyGuard::clear_ready_matching`] method:/// `guard.clear_ready_matching(Ready::READABLE)`./// Also clearing the write readiness in this case would be incorrect. The [`AsyncFdReadyGuard::clear_ready`]/// method clears all readiness flags./// Concurrently read and write to a [`std::net::TcpStream`] on the same task without/// splitting./// use tokio::io::{Interest, Ready};/// async fn main() -> Result<(), Box<dyn Error>> {///     let stream = TcpStream::connect("127.0.0.1:8080")?;///     stream.set_nonblocking(true)?;///     let stream = AsyncFd::new(stream)?;///         let mut guard = stream///             .ready(Interest::READABLE | Interest::WRITABLE)///             .await?;///         if guard.ready().is_readable() {///             let mut data = vec![0; 1024];///             // Try to read data, this may still fail with `WouldBlock`///             // if the readiness event is a false positive.///             match stream.get_ref().read(&mut data) {///                 Ok(n) => {///                     println!("read {} bytes", n);///                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {///                     // a read has blocked, but a write might still succeed.///                     // clear only the read readiness.///                     guard.clear_ready_matching(Ready::READABLE);///                     continue;///                 Err(e) => {///                     return Err(e.into());///         if guard.ready().is_writable() {///             // Try to write data, this may still fail with `WouldBlock`///             match stream.get_ref().write(b"hello world") {///                     println!("write {} bytes", n);///                     // a write has blocked, but a read might still succeed.///                     // clear only the write readiness.///                     guard.clear_ready_matching(Ready::WRITABLE);ready_mut/// [`AsyncFdReadyMutGuard`] that must be dropped to resume/// read readiness should be cleared using the [`AsyncFdReadyMutGuard::clear_ready_matching`] method:/// Also clearing the write readiness in this case would be incorrect./// The [`AsyncFdReadyMutGuard::clear_ready`] method clears all readiness flags.///     let mut stream = AsyncFd::new(stream)?;///             .ready_mut(Interest::READABLE | Interest::WRITABLE)///             match guard.get_inner_mut().read(&mut data) {///             match guard.get_inner_mut().write(b"hello world") {/// Waits for the file descriptor to become readable, returning a/// [`AsyncFdReadyGuard`] that must be dropped to resume read-readiness/// This method is cancel safe. Once a readiness event occurs, the method/// will continue to return immediately until the readiness event is/// consumed by an attempt to read or write that fails with `WouldBlock` or/// `Poll::Pending`.// The lifetime improves rustdoc rendering.readable_mut/// [`AsyncFdReadyMutGuard`] that must be dropped to resume read-readiness/// Waits for the file descriptor to become writable, returning a/// [`AsyncFdReadyGuard`] that must be dropped to resume write-readinesswritable_mut/// [`AsyncFdReadyMutGuard`] that must be dropped to resume write-readiness/// Reads or writes from the file descriptor using a user-provided IO operation./// The `async_io` method is a convenience utility that waits for the file/// descriptor to become ready, and then executes the provided IO operation./// Since file descriptors may be marked ready spuriously, the closure will/// be called repeatedly until it returns something other than a/// [`WouldBlock`] error. This is done using the following loop:/// # use std::io::{self, Result};/// # struct Dox<T> { inner: T }/// # impl<T> Dox<T> {/// #     async fn writable(&self) -> Result<&Self> {/// #         Ok(self)/// #     fn try_io<R>(&self, _: impl FnMut(&T) -> Result<R>) -> Result<Result<R>> {/// #         panic!()/// async fn async_io<R>(&self, mut f: impl FnMut(&T) -> io::Result<R>) -> io::Result<R> {///         // or `readable` if called with the read interest.///         let guard = self.writable().await?;///         match guard.try_io(&mut f) {///             Ok(result) => return result,///             Err(_would_block) => continue,/// The closure should only return a [`WouldBlock`] error if it has performed/// an IO operation on the file descriptor that failed due to the file descriptor not being/// ready. Returning a [`WouldBlock`] error in any other situation will/// incorrectly clear the readiness flag, which can cause the file descriptor to/// behave incorrectly./// The closure should not perform the IO operation using any of the methods/// defined on the Tokio [`AsyncFd`] type, as this will mess with the/// readiness flag and can cause the file descriptor to behave incorrectly./// This method is not intended to be used with combined interests./// The closure should perform only one type of IO operation, so it should not/// require more than one ready state. This method may panic or sleep forever/// if it is called with a combined interest./// This example sends some bytes on the inner [`std::net::UdpSocket`]. The `async_io`/// method waits for readiness, and retries if the send operation does block. This example/// is equivalent to the one given for [`try_io`]./// use tokio::io::{Interest, unix::AsyncFd};///     let socket = UdpSocket::bind("0.0.0.0:8080")?;///     let async_fd = AsyncFd::new(socket)?;///     let written = async_fd///         .async_io(Interest::WRITABLE, |inner| inner.send(&[1, 2]))///     println!("wrote {written} bytes");/// [`try_io`]: AsyncFdReadyGuard::try_ioasync_io_mut/// The behavior is the same as [`async_io`], except that the closure can mutate the inner/// value of the [`AsyncFd`]./// [`async_io`]: AsyncFd::async_io/// Tries to read or write from the file descriptor using a user-provided IO operation./// If the file descriptor is ready, the provided closure is called. The closure/// should attempt to perform IO operation on the file descriptor by manually/// calling the appropriate syscall. If the operation fails because the/// file descriptor is not actually ready, then the closure should return a/// `WouldBlock` error and the readiness flag is cleared. The return value/// of the closure is then returned by `try_io`./// If the file descriptor is not ready, then the closure is not called/// and a `WouldBlock` error is returned./// The closure should only return a `WouldBlock` error if it has performed/// ready. Returning a `WouldBlock` error in any other situation will/// defined on the Tokio `AsyncFd` type, as this will mess with thetry_io_mut/// The behavior is the same as [`try_io`], except that the closure can mutate the inner/// [`try_io`]: AsyncFd::try_ioclear_ready/// Indicates to tokio that the file descriptor is no longer ready. All/// internal readiness flags will be cleared, and tokio will wait for the/// next edge-triggered readiness notification from the OS./// This function is commonly used with guards returned by [`AsyncFd::readable`] and/// [`AsyncFd::writable`]./// It is critical that this function not be called unless your code/// _actually observes_ that the file descriptor is _not_ ready. Do not call/// it simply because, for example, a read succeeded; it should be called/// when a read is observed to block./// This method only clears readiness events that happened before the creation of this guard./// In other words, if the IO resource becomes ready between the creation of the guard and/// this call to `clear_ready`, then the readiness is not actually cleared.clear_ready_matching/// Indicates to tokio that the file descriptor no longer has a specific readiness./// The internal readiness flag will be cleared, and tokio will wait for the/// This function is useful in combination with the [`AsyncFd::ready`] method when a/// combined interest like `Interest::READABLE | Interest::WRITABLE` is used./// _actually observes_ that the file descriptor is _not_ ready for the provided `Ready`./// Do not call it simply because, for example, a read succeeded; it should be called/// when a read is observed to block. Only clear the specific readiness that is observed to/// block. For example when a read blocks when using a combined interest,/// only clear `Ready::READABLE`.retain_ready/// This method should be invoked when you intentionally want to keep the/// ready flag asserted./// While this function is itself a no-op, it satisfies the `#[must_use]`/// constraint on the [`AsyncFdReadyGuard`] type./// Get the [`Ready`] value associated with this guard./// This method will return the empty readiness state if/// [`AsyncFdReadyGuard::clear_ready`] has been called on/// the guard./// [`Ready`]: crate::io::ReadyTryIoError/// Performs the provided IO operation./// If `f` returns a [`WouldBlock`] error, the readiness state associated/// with this file descriptor is cleared, and the method returns/// `Err(TryIoError::WouldBlock)`. You will typically need to poll the/// `AsyncFd` again when this happens./// This method helps ensure that the readiness state of the underlying file/// descriptor remains in sync with the tokio-side readiness state, by/// clearing the tokio-side state only when a [`WouldBlock`] condition/// occurs. It is the responsibility of the caller to ensure that `f`/// returns [`WouldBlock`] only if the file descriptor that originated this/// `AsyncFdReadyGuard` no longer expresses the readiness state that was queried to/// create this `AsyncFdReadyGuard`./// This example sends some bytes to the inner [`std::net::UdpSocket`]. Waiting/// for write-readiness and retrying when the send operation does block are explicit./// This example can be written more succinctly using [`AsyncFd::async_io`].///     let written = loop {///         let mut guard = async_fd.writable().await?;///         match guard.try_io(|inner| inner.get_ref().send(&[1, 2])) {///             Ok(result) => {///                 break result?;///             Err(_would_block) => {///                 // try_io already cleared the file descriptor's readiness state// Alias for old name in 0.x/// Returns a shared reference to the inner [`AsyncFd`]./// Returns a shared reference to the backing object of the inner [`AsyncFd`]./// This function is commonly used with guards returned by [`AsyncFd::readable_mut`] and/// [`AsyncFd::writable_mut`]./// This function is useful in combination with the [`AsyncFd::ready_mut`] method when a/// [`Ready`]: super::Ready/// Returns a mutable reference to the inner [`AsyncFd`]./// Returns a mutable reference to the backing object of the inner [`AsyncFd`]./// The error type returned by [`try_io`]./// This error indicates that the IO resource returned a [`WouldBlock`] error./// [`try_io`]: method@AsyncFdReadyGuard::try_io/// Error returned by [`try_new`] or [`try_with_interest`]./// [`try_new`]: AsyncFd::try_new/// [`try_with_interest`]: AsyncFd::try_with_interest/// Returns the original object passed to [`try_new`] or [`try_with_interest`]/// alongside the error that caused these functions to fail./// Attempts to read from the `AsyncRead` into `buf`./// unfilled portion of `buf`. If no data was read (`buf.filled().len()` is/// This trait is analogous to the [`std::io::Read`] trait, but integrates with/// the asynchronous task system. In particular, the [`poll_read`] method,/// unlike [`Read::read`], will automatically queue the current task for wakeup/// Specifically, this means that the `poll_read` function will return one of/// the following:/// * `Poll::Ready(Ok(()))` means that data was immediately read and placed into///   the output buffer. The amount of data read can be determined by the///   increase in the length of the slice returned by `ReadBuf::filled`. If the///   difference is 0, either EOF has been reached, or the output buffer had zero///   capacity (i.e. `buf.remaining()` == 0)./// * `Poll::Pending` means that no data was read into the buffer///   provided. The I/O object is not currently readable but may become readable///   in the future. Most importantly, **the current future's task is scheduled///   to get unparked when the object is readable**. This means that like///   `Future::poll` you'll receive a notification when the I/O object is///   readable again./// * `Poll::Ready(Err(e))` for other errors are standard I/O errors coming from the///   underlying object./// This trait importantly means that the `read` method only works in the/// context of a future's task. The object may panic if used outside of a task./// Utilities for working with `AsyncRead` values are provided by/// [`AsyncReadExt`]./// [`std::io::Read`]: std::io::Read/// [`Read::read`]: std::io::Read::read/// [`AsyncReadExt`]: crate::io::AsyncReadExt/// Attempts to seek to an offset, in bytes, in a stream./// If this function returns successfully, then the job has been submitted./// To find out when it completes, call `poll_complete`./// This function can return [`io::ErrorKind::Other`] in case there is/// another seek in progress. To avoid this, it is advisable that any call/// to `start_seek` is preceded by a call to `poll_complete` to ensure all/// pending seeks have completed./// Waits for a seek operation to complete./// That position can be used later with [`SeekFrom::Start`]. Repeatedly/// calling this function without calling `start_seek` might return the/// same result./// This trait is analogous to the [`std::io::Seek`] trait, but integrates/// with the asynchronous task system. In particular, the `start_seek`/// method, unlike [`Seek::seek`], will not block the calling thread./// Utilities for working with `AsyncSeek` values are provided by/// [`AsyncSeekExt`]./// [`std::io::Seek`]: std::io::Seek/// [`Seek::seek`]: std::io::Seek::seek()/// [`AsyncSeekExt`]: crate::io::AsyncSeekExt/// On success, returns `Poll::Ready(Ok(num_bytes_written))`. If successful,/// then it must be guaranteed that `n <= buf.len()`. A return value of `0`/// typically means that the underlying object is no longer able to accept/// bytes and will likely not be able to in the future as well, or that the/// buffer provided is empty./// `cx.waker()`) to receive a notification when the object becomes/// Attempts to flush the object, ensuring that any buffered data reach/// `cx.waker()`) to receive a notification when the object can make/// Initiates or attempts to shut down this writer, returning success when/// the I/O connection has completely shut down./// This method is intended to be used for asynchronous shutdown of I/O/// connections. For example this is suitable for implementing shutdown of a/// TLS connection or calling `TcpStream::shutdown` on a proxied connection./// Protocols sometimes need to flush out final pieces of data or otherwise/// perform a graceful shutdown handshake, reading/writing more data as/// appropriate. This method is the hook for such protocols to implement the/// graceful shutdown logic./// This `shutdown` method is required by implementers of the/// `AsyncWrite` trait. Wrappers typically just want to proxy this call/// through to the wrapped type, and base types will typically implement/// shutdown logic here or just return `Ok(().into())`. Note that if you're/// wrapping an underlying `AsyncWrite` a call to `shutdown` implies that/// transitively the entire stream has been shut down. After your wrapper's/// shutdown logic has been executed you should shut down the underlying/// Invocation of a `shutdown` implies an invocation of `flush`. Once this/// method returns `Ready` it implies that a flush successfully happened/// before the shutdown happened. That is, callers don't need to call/// `flush` before calling `shutdown`. They can rely that by calling/// `shutdown` any pending buffered data will be written out./// This function returns a `Poll<io::Result<()>>` classified as such:/// * `Poll::Ready(Ok(()))` - indicates that the connection was///   successfully shut down and is now safe to deallocate/drop/close///   resources associated with it. This method means that the current task///   will no longer receive any notifications due to this method and the///   I/O object itself is likely no longer usable./// * `Poll::Pending` - indicates that shutdown is initiated but could///   not complete just yet. This may mean that more I/O needs to happen to///   continue this shutdown operation. The current task is scheduled to///   receive a notification when it's otherwise ready to continue the///   shutdown operation. When woken up this method should be called again./// * `Poll::Ready(Err(e))` - indicates a fatal error has happened with shutdown,///   indicating that the shutdown operation did not complete successfully.///   This typically means that the I/O object is no longer usable./// This function can return normal I/O errors through `Err`, described/// above. Additionally this method may also render the underlying/// `Write::write` method no longer usable (e.g. will return errors in the/// future). It's recommended that once `shutdown` is called the/// `write` method is no longer called./// This function will panic if not called within the context of a future's/// Like [`poll_write`], except that it writes from a slice of buffers./// Data is copied from each buffer in order, with the final buffer/// read from possibly being only partially consumed. This method must/// behave as a call to [`write`] with the buffers concatenated would./// The default implementation calls [`poll_write`] with either the first nonempty/// buffer provided, or an empty one if none exists./// This should be implemented as a single "atomic" write action. If any/// data has been partially written, it is wrong to return an error or/// pending./// [`poll_write`]: AsyncWrite::poll_write/// Determines if this writer has an efficient [`poll_write_vectored`]/// If a writer does not override the default [`poll_write_vectored`]/// implementation, code using it may want to avoid the method all together/// and coalesce writes into a single buffer for higher performance./// [`poll_write_vectored`]: AsyncWrite::poll_write_vectored/// Writes bytes asynchronously./// The trait inherits from [`std::io::Write`] and indicates that an I/O object is/// **nonblocking**. All non-blocking I/O objects must return an error when/// bytes cannot be written instead of blocking the current thread./// Specifically, this means that the [`poll_write`] function will return one of/// * `Poll::Ready(Ok(n))` means that `n` bytes of data was immediately///   written./// * `Poll::Pending` means that no data was written from the buffer///   provided. The I/O object is not currently writable but may become writable///   to get unparked when the object is writable**. This means that like///   writable again./// This trait importantly means that the [`write`][stdwrite] method only works in/// the context of a future's task. The object may panic if used outside of a task./// Note that this trait also represents that the  [`Write::flush`][stdflush] method/// works very similarly to the `write` method, notably that `Ok(())` means that the/// writer has successfully been flushed, a "would block" error means that the/// current task is ready to receive a notification when flushing can make more/// progress, and otherwise normal errors can happen as well./// Utilities for working with `AsyncWrite` values are provided by/// [`AsyncWriteExt`]./// [`std::io::Write`]: std::io::Write/// [`poll_write`]: AsyncWrite::poll_write()/// [stdwrite]: std::io::Write::write()/// [stdflush]: std::io::Write::flush()/// [`AsyncWriteExt`]: crate::io::AsyncWriteExtneed_flush/// `true` if the lower IO layer needs flushing./// `T` should not implement _both_ Read and Write.cfg_io_blockingr" The `Read` implementation of `inner` must never read from the buffer"r" it is borrowing and must correctly report the length of the data"r" written into the buffer."uninterruptibly/// Repeats operations that are interrupted./// `rd` must not read from the buffer `read` is borrowing and must correctly/// report the length of the data written into the buffer.discard_readcopy_from_bufs/// Registers this AIO event source with Tokio's reactor./// Deregisters this AIO event source with Tokio's reactor.AioSource/// Like [`mio::event::Source`], but for POSIX AIO only./// Tokio's consumer must pass an implementor of this trait to create a/// [`Aio`] object.MioSource/// Wraps the user's AioSource in order to implement mio::event::Source, which/// is what the rest of the crate wants./// Associates a POSIX AIO control block with the reactor that drives it./// `Aio`'s wrapped type must implement [`AioSource`] to be driven/// by the reactor./// The wrapped source may be accessed through the `Aio` via the `Deref` and/// `DerefMut` traits./// ## Clearing readiness/// If [`Aio::poll_ready`] returns ready, but the consumer determines that the/// Source is not completely ready and must return to the Pending state,/// [`Aio::clear_ready`] may be used.  This can be useful with/// [`lio_listio`], which may generate a kevent when only a portion of the/// operations have completed./// ## Platforms/// Only FreeBSD implements POSIX AIO with kqueue notification, so/// `Aio` is only available for that operating system.// Note: Unlike every other kqueue event source, POSIX AIO registers events not// via kevent(2) but when the aiocb is submitted to the kernel via aio_read,// aio_write, etc.  It needs the kqueue's file descriptor to do that.  So// AsyncFd can't be used for POSIX AIO.// Note that Aio doesn't implement Drop.  There's no need.  Unlike other// kqueue sources, simply dropping the object effectively deregisters it.new_for_aio/// Creates a new `Aio` suitable for use with POSIX AIO functions./// It will be associated with the default reactor.  The runtime is usually/// set implicitly when this function is called from a future driven by a/// Tokio runtime, otherwise runtime can be set explicitly with/// [`Runtime::enter`](crate::runtime::Runtime::enter) function.new_for_lio/// Creates a new `Aio` suitable for use with [`lio_listio`].new_with_interestAioEvent/// Indicates to Tokio that the source is no longer ready.  The internal/// readiness flag will be cleared, and tokio will wait for the next/// edge-triggered readiness notification from the OS./// It is critical that this method not be called unless your code/// _actually observes_ that the source is _not_ ready.  The OS must/// deliver a subsequent notification, or this source will block/// forever.  It is equally critical that you `do` call this method if you/// resubmit the same structure to the kernel and poll it again./// This method is not very useful with AIO readiness, since each `aiocb`/// structure is typically only used once.  It's main use with/// [`lio_listio`], which will sometimes send notification when only a/// portion of its elements are complete.  In that case, the caller must/// call `clear_ready` before resubmitting it./// Destroy the [`Aio`] and return its inner source./// Polls for readiness.  Either AIO or LIO counts.///  * `Poll::Pending` if the underlying operation is not complete, whether///     or not it completed successfully.  This will be true if the OS is///     still processing it, or if it has not yet been submitted to the OS.///  * `Poll::Ready(Ok(_))` if the underlying operation is complete.///  * `Poll::Ready(Err(_))` if the reactor has been shutdown.  This does///     _not_ indicate that the underlying operation encountered an error./// When the method returns `Poll::Pending`, the `Waker` in the provided `Context`/// is scheduled to receive a wakeup when the underlying operation/// completes. Note that on multiple calls to `poll_ready`, only the `Waker` from the/// `Context` passed to the most recent call is scheduled to receive a wakeup./// Opaque data returned by [`Aio::poll_ready`]./// It can be fed back to [`Aio::clear_ready`].//! Use POSIX AIO futures with Tokio.// ===== impl Aio =====// same as mio// error is available on all platforms, but behavior is platform-specific// mio does not have this interest/// Readiness event interest./// Specifies the readiness events the caller is interested in when awaiting on/// I/O resource readiness states.cfg_aio// The non-FreeBSD definitions in this block are active only when// building documentation./// Interest in all readable events./// Readable interest includes read-closed events./// Interest in all writable events./// Writable interest includes write-closed events./// Interest in error events./// Passes error interest to the underlying OS selector./// Behavior is platform-specific, read your platform's documentation./// Returns true if the value includes readable interest./// use tokio::io::Interest;/// assert!(Interest::READABLE.is_readable());/// assert!(!Interest::WRITABLE.is_readable());/// let both = Interest::READABLE | Interest::WRITABLE;/// assert!(both.is_readable());/// Returns true if the value includes writable interest./// assert!(!Interest::READABLE.is_writable());/// assert!(Interest::WRITABLE.is_writable());/// assert!(both.is_writable());/// Returns true if the value includes error interest./// assert!(Interest::ERROR.is_error());/// assert!(!Interest::WRITABLE.is_error());/// let combined = Interest::READABLE | Interest::ERROR;/// assert!(combined.is_error());/// Returns true if the value includes priority interest./// assert!(!Interest::READABLE.is_priority());/// assert!(Interest::PRIORITY.is_priority());/// let both = Interest::READABLE | Interest::PRIORITY;/// assert!(both.is_priority());/// Add together two `Interest` values./// This function works from a `const` context./// const BOTH: Interest = Interest::READABLE.add(Interest::WRITABLE);/// assert!(BOTH.is_readable());/// assert!(BOTH.is_writable());/// Remove `Interest` from `self`./// Interests present in `other` but *not* in `self` are ignored./// Returns `None` if the set would be empty after removing `Interest`./// const RW_INTEREST: Interest = Interest::READABLE.add(Interest::WRITABLE);/// let w_interest = RW_INTEREST.remove(Interest::READABLE).unwrap();/// // Removing all interests from the set returns `None`./// // Remove all interests at once./// assert_eq!(RW_INTEREST.remove(RW_INTEREST), None);to_mio// This function must be crate-private to avoid exposing a `mio` dependency./// Join two values implementing `AsyncRead` and `AsyncWrite` into a/// single handle.r" Joins two values implementing `AsyncRead` and `AsyncWrite` into a"r" single handle."/// Splits this `Join` back into its `AsyncRead` and `AsyncWrite`/// Returns a reference to the inner reader./// Returns a reference to the inner writer.reader_mut/// Returns a mutable reference to the inner reader./// Returns a mutable reference to the inner writer.reader_pin_mut/// Returns a pinned mutable reference to the inner reader.writer_pin_mut/// Returns a pinned mutable reference to the inner writer.//! Join two values implementing `AsyncRead` and `AsyncWrite` into a single one.async_seekasync_write// with conflicts when `use`ing `tokio::io` and `std::io`.cfg_io_driver_implpoll_eventedPollEvented// The bsd module can't be build on Windows, so we completely ignore it, even// when building documentation.cfg_net_unixr" Asynchronous IO structures specific to Unix-like operating systems."cfg_io_stdstdio_commoncfg_io_utilcopy_bidirectionalcopy_bidirectional_with_sizessimplexBufStreamDuplexStreamSimplexStreamcfg_not_io_utilr" Types in this module can be mocked out in tests."//! Traits, helpers, and type definitions for asynchronous I/O functionality.//! This module is the asynchronous version of `std::io`. Primarily, it//! defines two traits, [`AsyncRead`] and [`AsyncWrite`], which are asynchronous//! versions of the [`Read`] and [`Write`] traits in the standard library.//! # `AsyncRead` and `AsyncWrite`//! Like the standard library's [`Read`] and [`Write`] traits, [`AsyncRead`] and//! [`AsyncWrite`] provide the most general interface for reading and writing//! input and output. Unlike the standard library's traits, however, they are//! _asynchronous_ &mdash; meaning that reading from or writing to a `tokio::io`//! type will _yield_ to the Tokio scheduler when IO is not ready, rather than//! blocking. This allows other tasks to run while waiting on IO.//! Another difference is that `AsyncRead` and `AsyncWrite` only contain//! core methods needed to provide asynchronous reading and writing//! functionality. Instead, utility methods are defined in the [`AsyncReadExt`]//! and [`AsyncWriteExt`] extension traits. These traits are automatically//! implemented for all values that implement `AsyncRead` and `AsyncWrite`//! respectively.//! End users will rarely interact directly with `AsyncRead` and//! `AsyncWrite`. Instead, they will use the async functions defined in the//! extension traits. Library authors are expected to implement `AsyncRead`//! and `AsyncWrite` in order to provide types that behave like byte streams.//! Even with these differences, Tokio's `AsyncRead` and `AsyncWrite` traits//! can be used in almost exactly the same manner as the standard library's//! `Read` and `Write`. Most types in the standard library that implement `Read`//! and `Write` have asynchronous equivalents in `tokio` that implement//! `AsyncRead` and `AsyncWrite`, such as [`File`] and [`TcpStream`].//! For example, the standard library documentation introduces `Read` by//! [demonstrating][std_example] reading some bytes from a [`std::fs::File`]. We//! can do the same with [`tokio::fs::File`][`File`]://! use tokio::io::{self, AsyncReadExt};//! #[tokio::main]//! async fn main() -> io::Result<()> {//!     let mut f = File::open("foo.txt").await?;//!     let mut buffer = [0; 10];//!     // read up to 10 bytes//!     let n = f.read(&mut buffer).await?;//!     println!("The bytes: {:?}", &buffer[..n]);//! [`File`]: crate::fs::File//! [`TcpStream`]: crate::net::TcpStream//! [`std::fs::File`]: std::fs::File//! [std_example]: std::io#read-and-write//! ## Buffered Readers and Writers//! Byte-based interfaces are unwieldy and can be inefficient, as we'd need to be//! making near-constant calls to the operating system. To help with this,//! `std::io` comes with [support for _buffered_ readers and writers][stdbuf],//! and therefore, `tokio::io` does as well.//! Tokio provides an async version of the [`std::io::BufRead`] trait,//! [`AsyncBufRead`]; and async [`BufReader`] and [`BufWriter`] structs, which//! wrap readers and writers. These wrappers use a buffer, reducing the number//! of calls and providing nicer methods for accessing exactly what you want.//! For example, [`BufReader`] works with the [`AsyncBufRead`] trait to add//! extra methods to any async reader://! use tokio::io::{self, BufReader, AsyncBufReadExt};//!     let f = File::open("foo.txt").await?;//!     let mut reader = BufReader::new(f);//!     let mut buffer = String::new();//!     // read a line into buffer//!     reader.read_line(&mut buffer).await?;//!     println!("{}", buffer);//! [`BufWriter`] doesn't add any new ways of writing; it just buffers every call//! to [`write`](crate::io::AsyncWriteExt::write). However, you **must** flush//! [`BufWriter`] to ensure that any buffered data is written.//! use tokio::io::{self, BufWriter, AsyncWriteExt};//!     let f = File::create("foo.txt").await?;//!         let mut writer = BufWriter::new(f);//!         // Write a byte to the buffer.//!         writer.write(&[42u8]).await?;//!         // Flush the buffer before it goes out of scope.//!         writer.flush().await?;//!     } // Unless flushed or shut down, the contents of the buffer is discarded on drop.//! [stdbuf]: std::io#bufreader-and-bufwriter//! [`std::io::BufRead`]: std::io::BufRead//! [`AsyncBufRead`]: crate::io::AsyncBufRead//! [`BufReader`]: crate::io::BufReader//! [`BufWriter`]: crate::io::BufWriter//! ## Implementing `AsyncRead` and `AsyncWrite`//! Because they are traits, we can implement [`AsyncRead`] and [`AsyncWrite`] for//! our own types, as well. Note that these traits must only be implemented for//! non-blocking I/O types that integrate with the futures type system. In//! other words, these types must never block the thread, and instead the//! current task is notified when the I/O resource is ready.//! ## Conversion to and from Stream/Sink//! It is often convenient to encapsulate the reading and writing of bytes in a//! [`Stream`] or [`Sink`] of data.//! Tokio provides simple wrappers for converting [`AsyncRead`] to [`Stream`]//! and vice-versa in the [tokio-util] crate, see [`ReaderStream`] and//! [`StreamReader`].//! There are also utility traits that abstract the asynchronous buffering//! necessary to write your own adaptors for encoding and decoding bytes to/from//! your structured data, allowing to transform something that implements//! [`AsyncRead`]/[`AsyncWrite`] into a [`Stream`]/[`Sink`], see [`Decoder`] and//! [`Encoder`] in the [tokio-util::codec] module.//! [tokio-util]: https://docs.rs/tokio-util//! [tokio-util::codec]: https://docs.rs/tokio-util/latest/tokio_util/codec/index.html//! # Standard input and output//! Tokio provides asynchronous APIs to standard [input], [output], and [error].//! These APIs are very similar to the ones provided by `std`, but they also//! implement [`AsyncRead`] and [`AsyncWrite`].//! Note that the standard input / output APIs  **must** be used from the//! context of the Tokio runtime, as they require Tokio-specific features to//! function. Calling these functions outside of a Tokio runtime will panic.//! [input]: fn@stdin//! [output]: fn@stdout//! [error]: fn@stderr//! # `std` re-exports//! Additionally, [`Error`], [`ErrorKind`], [`Result`], and [`SeekFrom`] are//! re-exported from `std::io` for ease of use.//! [`AsyncRead`]: trait@AsyncRead//! [`AsyncWrite`]: trait@AsyncWrite//! [`AsyncReadExt`]: trait@AsyncReadExt//! [`AsyncWriteExt`]: trait@AsyncWriteExt//! ["codec"]: https://docs.rs/tokio-util/latest/tokio_util/codec/index.html//! [`Encoder`]: https://docs.rs/tokio-util/latest/tokio_util/codec/trait.Encoder.html//! [`Decoder`]: https://docs.rs/tokio-util/latest/tokio_util/codec/trait.Decoder.html//! [`ReaderStream`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.ReaderStream.html//! [`StreamReader`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.StreamReader.html//! [`Error`]: struct@Error//! [`ErrorKind`]: enum@ErrorKind//! [`Result`]: type@Result//! [`Read`]: std::io::Read//! [`SeekFrom`]: enum@SeekFrom//! [`Sink`]: https://docs.rs/futures/0.3/futures/sink/trait.Sink.html//! [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.htmlcfg_io_driverr" Associates an I/O resource that implements the [`std::io::Read`] and/or"r" [`std::io::Write`] traits with the reactor that drives it."r" `PollEvented` uses [`Registration`] internally to take a type that"r" implements [`mio::event::Source`] as well as [`std::io::Read`] and/or"r" [`std::io::Write`] and associate it with a reactor that will drive it."r" Once the [`mio::event::Source`] type is wrapped by `PollEvented`, it can be"r" used from within the future's execution model. As such, the"r" `PollEvented` type provides [`AsyncRead`] and [`AsyncWrite`]"r" implementations using the underlying I/O resource as well as readiness"r" events provided by the reactor."r" **Note**: While `PollEvented` is `Sync` (if the underlying I/O type is"r" `Sync`), the caller must ensure that there are at most two tasks that"r" use a `PollEvented` instance concurrently. One for reading and one for"r#" writing. While violating this requirement is "safe" from a Rust memory"#r" model point of view, it will result in unexpected behavior in the form"r" of lost notifications and tasks hanging."r" ## Readiness events"r" Besides just providing [`AsyncRead`] and [`AsyncWrite`] implementations,"r" this type also supports access to the underlying readiness event stream."r" While similar in function to what [`Registration`] provides, the"r" semantics are a bit different."r" Two functions are provided to access the readiness events:"r" [`poll_read_ready`] and [`poll_write_ready`]. These functions return the"r" current readiness state of the `PollEvented` instance. If"r" [`poll_read_ready`] indicates read readiness, immediately calling"r" [`poll_read_ready`] again will also indicate read readiness."r" When the operation is attempted and is unable to succeed due to the I/O"r" resource not being ready, the caller must call [`clear_readiness`]."r" This clears the readiness state until a new readiness event is received."r" This allows the caller to implement additional functions. For example,"r" [`TcpListener`] implements `poll_accept` by using [`poll_read_ready`] and"r" [`clear_readiness`]."r" ## Platform-specific events"r" `PollEvented` also allows receiving platform-specific `mio::Ready` events."r" These events are included as part of the read readiness event stream. The"r" write readiness event stream is only for `Ready::writable()` events."r" [`AsyncRead`]: crate::io::AsyncRead"r" [`AsyncWrite`]: crate::io::AsyncWrite"r" [`TcpListener`]: crate::net::TcpListener"r" [`clear_readiness`]: Registration::clear_readiness"r" [`poll_read_ready`]: Registration::poll_read_ready"r" [`poll_write_ready`]: Registration::poll_write_ready"/// Creates a new `PollEvented` associated with the default reactor./// The returned `PollEvented` has readable and writable interests. For more control, use/// [`Self::new_with_interest`]./// This function panics if thread-local runtime is not set./// The runtime is usually set implicitly when this function is called/// from a future driven by a tokio runtime, otherwise runtime can be set/// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function./// Creates a new `PollEvented` associated with the default reactor, for/// specific `Interest` state. `new_with_interest` should be used over `new`/// when you need control over the readiness state, such as when a file/// descriptor only allows reads. This does not add `hup` or `error` so if/// you are interested in those states, you will need to add them to the/// readiness state passed to this function./// The runtime is usually set implicitly when this function is called from/// a future driven by a tokio runtime, otherwise runtime can be set/// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter)new_with_interest_and_handle/// Returns a reference to the registration./// Deregisters the inner io from the registration and returns a Result containing the inner io./// Re-register under new runtime with `interest`.// ===== impl PollEvented =====/// Creates a new `ReadBuf` from a fully initialized buffer./// Creates a new `ReadBuf` from a buffer that may be uninitialized./// The internal cursor will mark the entire buffer as uninitialized. If/// the buffer is known to be partially initialized, then use `assume_init`/// to move the internal cursor./// Returns the total capacity of the buffer./// Returns a shared reference to the filled portion of the buffer./// Returns a mutable reference to the filled portion of the buffer./// Returns a new `ReadBuf` comprised of the unfilled section up to `n`./// Returns a shared reference to the initialized portion of the buffer./// This includes the filled portion.initialized_mut/// Returns a mutable reference to the initialized portion of the buffer./// Returns a mutable reference to the entire buffer, without ensuring that it has been fully/// The elements between 0 and `self.filled().len()` are filled, and those between 0 and/// `self.initialized().len()` are initialized (and so can be converted to a `&mut [u8]`)./// The caller of this method must ensure that these invariants are upheld. For example, if the/// caller initializes some of the uninitialized section of the buffer, it must call/// [`assume_init`](Self::assume_init) with the number of bytes initialized./// The caller must not de-initialize portions of the buffer that have already been initialized./// This includes any bytes in the region marked as uninitialized by `ReadBuf`.unfilled_mut/// Returns a mutable reference to the unfilled part of the buffer without ensuring that it has been fullyinitialize_unfilled/// Returns a mutable reference to the unfilled part of the buffer, ensuring it is fully initialized./// Since `ReadBuf` tracks the region of the buffer that has been initialized, this is effectively "free" after/// the first use.initialize_unfilled_to/// Returns a mutable reference to the first `n` bytes of the unfilled part of the buffer, ensuring it is/// fully initialized./// Panics if `self.remaining()` is less than `n`./// Returns the number of bytes at the end of the slice that have not yet been filled./// Clears the buffer, resetting the filled region to empty./// The number of initialized bytes is not changed, and the contents of the buffer are not modified./// Advances the size of the filled region of the buffer./// The number of initialized bytes is not changed./// Panics if the filled region of the buffer would become larger than the initialized region.set_filled/// Sets the size of the filled region of the buffer./// Note that this can be used to *shrink* the filled region of the buffer in addition to growing it (for/// example, by a `AsyncRead` implementation that compresses data in-place)./// Asserts that the first `n` unfilled bytes of the buffer are initialized./// `ReadBuf` assumes that bytes are never de-initialized, so this method does nothing when called with fewer/// bytes than are already known to be initialized./// The caller must ensure that `n` unfilled bytes of the buffer have already been initialized./// Appends data to the buffer, advancing the written position and possibly also the initialized position./// Panics if `self.remaining()` is less than `buf.len()`.// SAFETY: The caller guarantees that at least `cnt` unfilled bytes have been initialized.slice_to_uninit_mut// TODO: This could use `MaybeUninit::slice_assume_init` when it is stable.// TODO: This could use `MaybeUninit::slice_assume_init_mut` when it is stable.READ_CLOSEDWRITE_CLOSED/// Describes the readiness state of an I/O resources./// `Ready` tracks which operation an I/O resource is ready to perform./// Returns the empty `Ready` set./// Returns a `Ready` representing readable readiness./// Returns a `Ready` representing writable readiness./// Returns a `Ready` representing read closed readiness./// Returns a `Ready` representing write closed readiness./// Returns a `Ready` representing priority readiness./// Returns a `Ready` representing error readiness./// Returns a `Ready` representing readiness for all operations.from_mio// Must remain crate-private to avoid adding a public dependency on Mio./// Returns true if `Ready` is the empty set./// use tokio::io::Ready;/// assert!(Ready::EMPTY.is_empty());/// assert!(!Ready::READABLE.is_empty());/// Returns `true` if the value includes `readable`./// assert!(!Ready::EMPTY.is_readable());/// assert!(Ready::READABLE.is_readable());/// assert!(Ready::READ_CLOSED.is_readable());/// assert!(!Ready::WRITABLE.is_readable());/// Returns `true` if the value includes writable `readiness`./// assert!(!Ready::EMPTY.is_writable());/// assert!(!Ready::READABLE.is_writable());/// assert!(Ready::WRITABLE.is_writable());/// assert!(Ready::WRITE_CLOSED.is_writable());/// Returns `true` if the value includes read-closed `readiness`./// assert!(!Ready::EMPTY.is_read_closed());/// assert!(!Ready::READABLE.is_read_closed());/// assert!(Ready::READ_CLOSED.is_read_closed());/// Returns `true` if the value includes write-closed `readiness`./// assert!(!Ready::EMPTY.is_write_closed());/// assert!(!Ready::WRITABLE.is_write_closed());/// assert!(Ready::WRITE_CLOSED.is_write_closed());/// Returns `true` if the value includes priority `readiness`./// assert!(!Ready::EMPTY.is_priority());/// assert!(!Ready::WRITABLE.is_priority());/// assert!(Ready::PRIORITY.is_priority());/// Returns `true` if the value includes error `readiness`./// assert!(!Ready::EMPTY.is_error());/// assert!(!Ready::WRITABLE.is_error());/// assert!(Ready::ERROR.is_error());/// Returns true if `self` is a superset of `other`./// `other` may represent more than one readiness operations, in which case/// the function only returns true if `self` contains all readiness/// specified in `other`./// Creates a `Ready` instance using the given `usize` representation./// The `usize` representation must have been obtained from a call to/// `Readiness::as_usize`./// This function is mainly provided to allow the caller to get a/// readiness value from an `AtomicUsize`./// Returns a `usize` representation of the `Ready` value./// This function is mainly provided to allow the caller to store a/// readiness value in an `AtomicUsize`.from_interestsatisfiesr" Future for the [`seek`](crate::io::AsyncSeekExt::seek) method."r" The readable half of a value returned from [`split`](split())."r" The writable half of a value returned from [`split`](split())."r" Splits a single value implementing `AsyncRead + AsyncWrite` into separate"r" `AsyncRead` and `AsyncWrite` handles."r" To restore this read/write object from its `ReadHalf` and"r" `WriteHalf` use [`unsplit`](ReadHalf::unsplit())."with_lock/// Checks if this `ReadHalf` and some `WriteHalf` were split from the same/// Reunites with a previously split `WriteHalf`./// If this `ReadHalf` and the given `WriteHalf` do not originate from the/// same `split` operation this method will panic./// This can be checked ahead of time by calling [`is_pair_of()`](Self::is_pair_of)./// Checks if this `WriteHalf` and some `ReadHalf` were split from the same//! Split a single value implementing `AsyncRead + AsyncWrite` into separate//! `AsyncRead` and `AsyncWrite` handles.//! To restore this read/write object from its `split::ReadHalf` and//! `split::WriteHalf` use `unsplit`.SplitByUtf8BoundaryIfWindowsr" A handle to the standard error stream of a process."r" Concurrent writes to stderr must be executed with care: Only individual"r" writes to this [`AsyncWrite`] are guaranteed to be intact. In particular"r" you should be aware that writes using [`write_all`] are not guaranteed"r" to occur as a single write, so multiple threads writing data with"r" [`write_all`] may result in interleaved output."r" Created by the [`stderr`] function."r" [`stderr`]: stderr()"r" [`AsyncWrite`]: AsyncWrite"r" [`write_all`]: crate::io::AsyncWriteExt::write_all()"r" use tokio::io::{self, AsyncWriteExt};"r"     let mut stderr = io::stdout();"r#"     stderr.write_all(b"Print some error here.").await?;"#r" Constructs a new handle to the standard error of the current process."r" The returned handle allows writing to standard error from the within the"r" Tokio runtime."r"     let mut stderr = io::stderr();"r" A handle to the standard input stream of a process."r" The handle implements the [`AsyncRead`] trait, but beware that concurrent"r" reads of `Stdin` must be executed with care."r" This handle is best used for non-interactive uses, such as when a file"r" is piped into the application. For technical reasons, `stdin` is"r" implemented by using an ordinary blocking read on a separate thread, and"r" it is impossible to cancel that read. This can make shutdown of the"r" runtime hang until the user presses enter."r" For interactive uses, it is recommended to spawn a thread dedicated to"r" user input and use blocking IO directly in that thread."r" Created by the [`stdin`] function."r" [`stdin`]: fn@stdin"r" [`AsyncRead`]: trait@AsyncRead"r" Constructs a new handle to the standard input of the current process."/// [`AsyncWrite`] adapter that finds last char boundary in given buffer and does not write the rest,/// if buffer contents seems to be `utf8`. Otherwise it only trims buffer down to `DEFAULT_MAX_BUF_SIZE`./// That's why, wrapped writer will always receive well-formed utf-8 bytes./// # Other platforms/// Passes data to `inner` as is.MAX_BYTES_PER_CHAR// this constant is defined by Unicode standard.MAGIC_CONST// Subject for tweaking hereTextMockWriterwrite_historyLoggingMockWritertest_splittertest_pseudo_text//! Contains utilities for stdout and stderr.r" A handle to the standard output stream of a process."r" Concurrent writes to stdout must be executed with care: Only individual"r" Created by the [`stdout`] function."r" [`stdout`]: stdout()"r"     let mut stdout = io::stdout();"r#"     stdout.write_all(b"Hello world!").await?;"#r" The following is an example of using `stdio` with loop."r" async fn main() {"r#"     let messages = vec!["hello", " world\n"];"#r"     // When you use `stdio` in a loop, it is recommended to create"r"     // a single `stdio` instance outside the loop and call a write"r"     // operation against that instance on each loop."r"     //"r"     // Repeatedly creating `stdout` instances inside the loop and"r"     // writing to that handle could result in mangled output since"r"     // each write operation is handled by a different blocking thread."r"     for message in &messages {"r"         stdout.write_all(message.as_bytes()).await.unwrap();"r"         stdout.flush().await.unwrap();"r" Constructs a new handle to the standard output of the current process."r" The returned handle allows writing to standard out from the within the"r" Reads all bytes into `buf` until the delimiter `byte` or EOF is reached."r" Equivalent to:"r" async fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize>;"r" This function will read bytes from the underlying stream until the"r" delimiter or EOF is found. Once found, all bytes up to, and including,"r" the delimiter (if found) will be appended to `buf`."r" If successful, this function will return the total number of bytes read."r" If this function returns `Ok(0)`, the stream has reached EOF."r" This function will ignore all instances of [`ErrorKind::Interrupted`] and"r" will otherwise return any errors returned by [`fill_buf`]."r" If an I/O error is encountered then all bytes read so far will be"r" present in `buf` and its length will have been adjusted appropriately."r" [`fill_buf`]: AsyncBufRead::poll_fill_buf"r" [`ErrorKind::Interrupted`]: std::io::ErrorKind::Interrupted"r" # Cancel safety"r" If the method is used as the event in a"r" [`tokio::select!`](crate::select) statement and some other branch"r" completes first, then some data may have been partially read. Any"r" partially read bytes are appended to `buf`, and the method can be"r" called again to continue reading until `byte`."r" This method returns the total number of bytes read. If you cancel"r" the call to `read_until` and then call it again to continue reading,"r" the counter is reset."r" [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In"r" this example, we use [`Cursor`] to read all the bytes in a byte slice"r" in hyphen delimited segments:"r" [`Cursor`]: std::io::Cursor"r" use tokio::io::AsyncBufReadExt;"r" use std::io::Cursor;"r#"     let mut cursor = Cursor::new(b"lorem-ipsum");"#r"     let mut buf = vec![];"r"     // cursor is at 'l'"r"     let num_bytes = cursor.read_until(b'-', &mut buf)"r"         .await"r#"         .expect("reading from cursor won't fail");"#r"     assert_eq!(num_bytes, 6);"r#"     assert_eq!(buf, b"lorem-");"#r"     buf.clear();"r"     // cursor is at 'i'"r"     assert_eq!(num_bytes, 5);"r#"     assert_eq!(buf, b"ipsum");"#r"     // cursor is at EOF"r"     assert_eq!(num_bytes, 0);"r#"     assert_eq!(buf, b"");"#r" Reads all bytes until a newline (the 0xA byte) is reached, and append"r" them to the provided buffer."r" async fn read_line(&mut self, buf: &mut String) -> io::Result<usize>;"r" newline delimiter (the 0xA byte) or EOF is found. Once found, all bytes"r" up to, and including, the delimiter (if found) will be appended to"r" `buf`."r" This function has the same error semantics as [`read_until`] and will"r" also return an error if the read bytes are not valid UTF-8. If an I/O"r" error is encountered then `buf` may contain some bytes already read in"r" the event that all data read so far was valid UTF-8."r" [`read_until`]: AsyncBufReadExt::read_until"r" This method is not cancellation safe. If the method is used as the"r" event in a [`tokio::select!`](crate::select) statement and some"r" other branch completes first, then some data may have been partially"r" read, and this data is lost. There are no guarantees regarding the"r" contents of `buf` when the call is cancelled. The current"r" implementation replaces `buf` with the empty string, but this may"r" change in the future."r" This function does not behave like [`read_until`] because of the"r" requirement that a string contains only valid utf-8. If you need a"r" cancellation safe `read_line`, there are three options:"r"  * Call [`read_until`] with a newline character and manually perform the utf-8 check."r"  * The stream returned by [`lines`] has a cancellation safe"r"    [`next_line`] method."r"  * Use [`tokio_util::codec::LinesCodec`][LinesCodec]."r" [LinesCodec]: https://docs.rs/tokio-util/latest/tokio_util/codec/struct.LinesCodec.html"r" [`read_until`]: Self::read_until"r" [`lines`]: Self::lines"r" [`next_line`]: crate::io::Lines::next_line"r" [`std::io::Cursor`][`Cursor`] is a type that implements"r" `AsyncBufRead`. In this example, we use [`Cursor`] to read all the"r" lines in a byte slice:"r#"     let mut cursor = Cursor::new(b"foo\nbar");"#r"     let mut buf = String::new();"r"     // cursor is at 'f'"r"     let num_bytes = cursor.read_line(&mut buf)"r"     assert_eq!(num_bytes, 4);"r#"     assert_eq!(buf, "foo\n");"#r"     // cursor is at 'b'"r"     assert_eq!(num_bytes, 3);"r#"     assert_eq!(buf, "bar");"#r#"     assert_eq!(buf, "");"#r" Returns a stream of the contents of this reader split on the byte"r" `byte`."r" This method is the asynchronous equivalent to"r" [`BufRead::split`](std::io::BufRead::split)."r" The stream returned from this function will yield instances of"r" [`io::Result`]`<`[`Option`]`<`[`Vec<u8>`]`>>`. Each vector returned will *not* have"r" the delimiter byte at the end."r" [`io::Result`]: std::io::Result"r" [`Option`]: core::option::Option"r" [`Vec<u8>`]: std::vec::Vec"r" Each item of the stream has the same error semantics as"r" [`AsyncBufReadExt::read_until`](AsyncBufReadExt::read_until)."r" # use tokio::io::AsyncBufRead;"r" # async fn dox(my_buf_read: impl AsyncBufRead + Unpin) -> std::io::Result<()> {"r" let mut segments = my_buf_read.split(b'f');"r" while let Some(segment) = segments.next_segment().await? {"r#"     println!("length = {}", segment.len())"#r" Returns the contents of the internal buffer, filling it with more"r" data from the inner reader if it is empty."r" This function is a lower-level call. It needs to be paired with the"r" [`consume`] method to function properly. When calling this method,"r#" none of the contents will be "read" in the sense that later calling"#r" `read` may return the same contents. As such, [`consume`] must be"r" called with the number of bytes that are consumed from this buffer"r" to ensure that the bytes are never returned twice."r" An empty buffer returned indicates that the stream has reached EOF."r" async fn fill_buf(&mut self) -> io::Result<&[u8]>;"r" This function will return an I/O error if the underlying reader was"r" read, but returned an error."r" This method is cancel safe. If you use it as the event in a"r" completes first, then it is guaranteed that no data was read."r" [`consume`]: crate::io::AsyncBufReadExt::consume"r" Tells this buffer that `amt` bytes have been consumed from the"r" buffer, so they should no longer be returned in calls to [`read`]."r" [`fill_buf`] method to function properly. This function does not"r" perform any I/O, it simply informs this object that some amount of"r" its buffer, returned from [`fill_buf`], has been consumed and should"r" no longer be returned. As such, this function may do odd things if"r" [`fill_buf`] isn't called before calling it."r" The `amt` must be less than the number of bytes in the buffer"r" returned by [`fill_buf`]."r" [`read`]: crate::io::AsyncReadExt::read"r" [`fill_buf`]: crate::io::AsyncBufReadExt::fill_buf"r" Returns a stream over the lines of this reader."r" This method is the async equivalent to [`BufRead::lines`](std::io::BufRead::lines)."r" [`io::Result`]`<`[`Option`]`<`[`String`]`>>`. Each string returned will *not* have a newline"r" byte (the 0xA byte) or `CRLF` (0xD, 0xA bytes) at the end."r" [`String`]: String"r" Each line of the stream has the same error semantics as [`AsyncBufReadExt::read_line`]."r" this example, we use [`Cursor`] to iterate over all the lines in a byte"r" slice."r#"     let cursor = Cursor::new(b"lorem\nipsum\r\ndolor");"#r"     let mut lines = cursor.lines();"r#"     assert_eq!(lines.next_line().await.unwrap(), Some(String::from("lorem")));"#r#"     assert_eq!(lines.next_line().await.unwrap(), Some(String::from("ipsum")));"#r#"     assert_eq!(lines.next_line().await.unwrap(), Some(String::from("dolor")));"#r"     assert_eq!(lines.next_line().await.unwrap(), None);"r" [`AsyncBufReadExt::read_line`]: AsyncBufReadExt::read_line"r" An extension trait which adds utility methods to [`AsyncBufRead`] types."r" [`AsyncBufRead`]: crate::io::AsyncBufRead"ReadF32ReadF32LeReadF64ReadF64LeReadI128ReadI128LeReadI16ReadI16LeReadI32ReadI32LeReadI64ReadI64LeReadI8ReadU128ReadU128LeReadU16ReadU16LeReadU32ReadU32LeReadU64ReadU64LeReadU8r" Defines numeric reader"read_implr" Creates a new `AsyncRead` instance that chains this stream with"r" `next`."r" The returned `AsyncRead` instance will first read all bytes from this object"r" until EOF is encountered. Afterwards the output is equivalent to the"r" output of `next`."r" [`File`][crate::fs::File]s implement `AsyncRead`:"r" use tokio::fs::File;"r" use tokio::io::{self, AsyncReadExt};"r#"     let f1 = File::open("foo.txt").await?;"#r#"     let f2 = File::open("bar.txt").await?;"#r"     let mut handle = f1.chain(f2);"r"     let mut buffer = String::new();"r"     // read the value into a String. We could use any AsyncRead"r"     // method here, this is just one example."r"     handle.read_to_string(&mut buffer).await?;"r" Pulls some bytes from this source into the specified buffer,"r" returning how many bytes were read."r" async fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>;"r" This method does not provide any guarantees about whether it"r" completes immediately or asynchronously."r" # Return"r" If the return value of this method is `Ok(n)`, then it must be"r" guaranteed that `0 <= n <= buf.len()`. A nonzero `n` value indicates"r" that the buffer `buf` has been filled in with `n` bytes of data from"r" this source. If `n` is `0`, then it can indicate one of two"r" scenarios:"r#" 1. This reader has reached its "end of file" and will likely no longer"#r"    be able to produce bytes. Note that this does not mean that the"r"    reader will *always* no longer be able to produce bytes."r" 2. The buffer specified was 0 bytes in length."r" No guarantees are provided about the contents of `buf` when this"r" function is called, implementations cannot rely on any property of the"r" contents of `buf` being true. It is recommended that *implementations*"r" only write data to `buf` instead of reading its contents."r" Correspondingly, however, *callers* of this method may not assume"r" any guarantees about how the implementation uses `buf`. It is"r" possible that the code that's supposed to write to the buffer might"r" also read from it. It is your responsibility to make sure that `buf`"r" is initialized before calling `read`."r" If this function encounters any form of I/O or other error, an error"r" variant will be returned. If an error is returned then it must be"r" guaranteed that no bytes were read."r" [`File`][crate::fs::File]s implement `Read`:"r#"     let mut f = File::open("foo.txt").await?;"#r"     let mut buffer = [0; 10];"r"     // read up to 10 bytes"r"     let n = f.read(&mut buffer[..]).await?;"r#"     println!("The bytes: {:?}", &buffer[..n]);"#r" advancing the buffer's internal cursor."r" async fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> io::Result<usize>;"r" Usually, only a single `read` syscall is issued, even if there is"r" more space in the supplied buffer."r" A nonzero `n` value indicates that the buffer `buf` has been filled"r" in with `n` bytes of data from this source. If `n` is `0`, then it"r" can indicate one of two scenarios:"r" 2. The buffer specified had a remaining capacity of zero."r" [`File`] implements `Read` and [`BytesMut`] implements [`BufMut`]:"r" [`File`]: crate::fs::File"r" [`BytesMut`]: bytes::BytesMut"r" [`BufMut`]: bytes::BufMut"r" use bytes::BytesMut;"r"     let mut buffer = BytesMut::with_capacity(10);"r"     assert!(buffer.is_empty());"r"     assert!(buffer.capacity() >= 10);"r"     // note that the return value is not needed to access the data"r"     // that was read as `buffer`'s internal cursor is updated."r"     // this might read more than 10 bytes if the capacity of `buffer`"r"     // is larger than 10."r"     f.read_buf(&mut buffer).await?;"r#"     println!("The bytes: {:?}", &buffer[..]);"#r" Reads the exact number of bytes required to fill `buf`."r" async fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<usize>;"r" This function reads as many bytes as necessary to completely fill"r" the specified buffer `buf`."r#" If the operation encounters an "end of file" before completely"#r" filling the buffer, it returns an error of the kind"r" [`ErrorKind::UnexpectedEof`]. The contents of `buf` are unspecified"r" in this case."r" If any other read error is encountered then the operation"r" immediately returns. The contents of `buf` are unspecified in this"r" case."r" If this operation returns an error, it is unspecified how many bytes"r" it has read, but it will never read more than would be necessary to"r" completely fill the buffer."r" other branch completes first, then some data may already have been"r" read into `buf`."r"     let len = 10;"r"     let mut buffer = vec![0; len];"r"     // read exactly 10 bytes"r"     f.read_exact(&mut buffer).await?;"r" [`ErrorKind::UnexpectedEof`]: std::io::ErrorKind::UnexpectedEof"r" Reads an unsigned 8 bit integer from the underlying reader."r" async fn read_u8(&mut self) -> io::Result<u8>;"r" It is recommended to use a buffered reader to avoid excessive"r" syscalls."r" This method returns the same errors as [`AsyncReadExt::read_exact`]."r" [`AsyncReadExt::read_exact`]: AsyncReadExt::read_exact"r" This method is cancel safe. If this method is used as an event in a"r" completes first, it is guaranteed that no data were read."r" Read unsigned 8 bit integers from an `AsyncRead`:"r"     let mut reader = Cursor::new(vec![2, 5]);"r"     assert_eq!(2, reader.read_u8().await?);"r"     assert_eq!(5, reader.read_u8().await?);"r" Reads a signed 8 bit integer from the underlying reader."r" async fn read_i8(&mut self) -> io::Result<i8>;"r"     let mut reader = Cursor::new(vec![0x02, 0xfb]);"r"     assert_eq!(2, reader.read_i8().await?);"r"     assert_eq!(-5, reader.read_i8().await?);"r" Reads an unsigned 16-bit integer in big-endian order from the"r" underlying reader."r" async fn read_u16(&mut self) -> io::Result<u16>;"r" other branch completes first, then some data may be lost."r" Read unsigned 16 bit big-endian integers from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec![2, 5, 3, 0]);"r"     assert_eq!(517, reader.read_u16().await?);"r"     assert_eq!(768, reader.read_u16().await?);"r" Reads a signed 16-bit integer in big-endian order from the"r" async fn read_i16(&mut self) -> io::Result<i16>;"r" Read signed 16 bit big-endian integers from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);"r"     assert_eq!(193, reader.read_i16().await?);"r"     assert_eq!(-132, reader.read_i16().await?);"r" Reads an unsigned 32-bit integer in big-endian order from the"r" async fn read_u32(&mut self) -> io::Result<u32>;"r" Read unsigned 32-bit big-endian integers from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);"r"     assert_eq!(267, reader.read_u32().await?);"r" Reads a signed 32-bit integer in big-endian order from the"r" async fn read_i32(&mut self) -> io::Result<i32>;"r" Read signed 32-bit big-endian integers from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);"r"     assert_eq!(-34253, reader.read_i32().await?);"r" Reads an unsigned 64-bit integer in big-endian order from the"r" async fn read_u64(&mut self) -> io::Result<u64>;"r" Read unsigned 64-bit big-endian integers from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec!["r"         0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83"r"     ]);"r"     assert_eq!(918733457491587, reader.read_u64().await?);"r" Reads an signed 64-bit integer in big-endian order from the"r" async fn read_i64(&mut self) -> io::Result<i64>;"r" Read signed 64-bit big-endian integers from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);"r"     assert_eq!(i64::MIN, reader.read_i64().await?);"r" Reads an unsigned 128-bit integer in big-endian order from the"r" async fn read_u128(&mut self) -> io::Result<u128>;"r" Read unsigned 128-bit big-endian integers from a `AsyncRead`:"r"         0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,"r"     assert_eq!(16947640962301618749969007319746179, reader.read_u128().await?);"r" Reads an signed 128-bit integer in big-endian order from the"r" async fn read_i128(&mut self) -> io::Result<i128>;"r" Read signed 128-bit big-endian integers from a `AsyncRead`:"r"         0x80, 0, 0, 0, 0, 0, 0, 0,"r"         0, 0, 0, 0, 0, 0, 0, 0"r"     assert_eq!(i128::MIN, reader.read_i128().await?);"r" Reads an 32-bit floating point type in big-endian order from the"r" async fn read_f32(&mut self) -> io::Result<f32>;"r" Read 32-bit floating point type from a `AsyncRead`:"r"     let mut reader = Cursor::new(vec![0xff, 0x7f, 0xff, 0xff]);"r"     assert_eq!(f32::MIN, reader.read_f32().await?);"r" Reads an 64-bit floating point type in big-endian order from the"r" async fn read_f64(&mut self) -> io::Result<f64>;"r" Read 64-bit floating point type from a `AsyncRead`:"r"         0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff"r"     assert_eq!(f64::MIN, reader.read_f64().await?);"r" Reads an unsigned 16-bit integer in little-endian order from the"r" async fn read_u16_le(&mut self) -> io::Result<u16>;"r" Read unsigned 16 bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(1282, reader.read_u16_le().await?);"r"     assert_eq!(3, reader.read_u16_le().await?);"r" Reads a signed 16-bit integer in little-endian order from the"r" async fn read_i16_le(&mut self) -> io::Result<i16>;"r" Read signed 16 bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(-16128, reader.read_i16_le().await?);"r"     assert_eq!(31999, reader.read_i16_le().await?);"read_i16_ler" Reads an unsigned 32-bit integer in little-endian order from the"r" async fn read_u32_le(&mut self) -> io::Result<u32>;"r" Read unsigned 32-bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(184614912, reader.read_u32_le().await?);"r" Reads a signed 32-bit integer in little-endian order from the"r" async fn read_i32_le(&mut self) -> io::Result<i32>;"r" Read signed 32-bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(863698943, reader.read_i32_le().await?);"read_i32_ler" Reads an unsigned 64-bit integer in little-endian order from the"r" async fn read_u64_le(&mut self) -> io::Result<u64>;"r" Read unsigned 64-bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(9477368352180732672, reader.read_u64_le().await?);"read_u64_ler" Reads an signed 64-bit integer in little-endian order from the"r" async fn read_i64_le(&mut self) -> io::Result<i64>;"r" Read signed 64-bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(128, reader.read_i64_le().await?);"read_i64_ler" Reads an unsigned 128-bit integer in little-endian order from the"r" async fn read_u128_le(&mut self) -> io::Result<u128>;"r" Read unsigned 128-bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(174826588484952389081207917399662330624, reader.read_u128_le().await?);"read_u128_ler" Reads an signed 128-bit integer in little-endian order from the"r" async fn read_i128_le(&mut self) -> io::Result<i128>;"r" Read signed 128-bit little-endian integers from a `AsyncRead`:"r"     assert_eq!(128, reader.read_i128_le().await?);"read_i128_ler" Reads an 32-bit floating point type in little-endian order from the"r" async fn read_f32_le(&mut self) -> io::Result<f32>;"r"     let mut reader = Cursor::new(vec![0xff, 0xff, 0x7f, 0xff]);"r"     assert_eq!(f32::MIN, reader.read_f32_le().await?);"read_f32_ler" Reads an 64-bit floating point type in little-endian order from the"r" async fn read_f64_le(&mut self) -> io::Result<f64>;"r"         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff"r"     assert_eq!(f64::MIN, reader.read_f64_le().await?);"read_f64_ler" Reads all bytes until EOF in this source, placing them into `buf`."r" async fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize>;"r" All bytes read from this source will be appended to the specified"r" buffer `buf`. This function will continuously call [`read()`] to"r" append more data to `buf` until [`read()`] returns `Ok(0)`."r" If successful, the total number of bytes read is returned."r" [`read()`]: AsyncReadExt::read"r" If a read error is encountered then the `read_to_end` operation"r" immediately completes. Any bytes which have already been read will"r" be appended to `buf`."r"     let mut buffer = Vec::new();"r"     // read the whole file"r"     f.read_to_end(&mut buffer).await?;"r" (See also the [`tokio::fs::read`] convenience function for reading from a"r" file.)"r" [`tokio::fs::read`]: fn@crate::fs::read"r" Reads all bytes until EOF in this source, appending them to `buf`."r" async fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize>;"r" If successful, the number of bytes which were read and appended to"r" `buf` is returned."r" If the data in this stream is *not* valid UTF-8 then an error is"r" returned and `buf` is unchanged."r" See [`read_to_end`][AsyncReadExt::read_to_end] for other error semantics."r"     f.read_to_string(&mut buffer).await?;"r" (See also the [`crate::fs::read_to_string`] convenience function for"r" reading from a file.)"r" [`crate::fs::read_to_string`]: fn@crate::fs::read_to_string"r" Creates an adaptor which reads at most `limit` bytes from it."r" This function returns a new instance of `AsyncRead` which will read"r" at most `limit` bytes, after which it will always return EOF"r" (`Ok(0)`). Any read errors will not count towards the number of"r" bytes read and future calls to [`read()`] may succeed."r" [`read()`]: fn@crate::io::AsyncReadExt::read"r" [read]: AsyncReadExt::read"r#"     let f = File::open("foo.txt").await?;"#r"     let mut buffer = [0; 5];"r"     // read at most five bytes"r"     let mut handle = f.take(5);"r"     handle.read(&mut buffer).await?;"r" Reads bytes from a source."r" Implemented as an extension trait, adding utility methods to all"r" [`AsyncRead`] types. Callers will tend to import this trait instead of"r" [`AsyncRead`]."r"     // The `read` method is defined by this trait."r" See [module][crate::io] documentation for more details."r" [`AsyncRead`]: AsyncRead"r" Creates a future which will seek an IO object, and then yield the"r" new position in the object and the object itself."r" async fn seek(&mut self, pos: SeekFrom) -> io::Result<u64>;"r" In the case of an error the buffer and the object will be discarded, with"r" the error yielded."r" use tokio::io::{AsyncSeekExt, AsyncReadExt};"r" use std::io::SeekFrom;"r" # async fn dox() -> std::io::Result<()> {"r#" let mut file = File::open("foo.txt").await?;"#r" file.seek(SeekFrom::Start(6)).await?;"r" let mut contents = vec![0u8; 10];"r" file.read_exact(&mut contents).await?;"r" Creates a future which will rewind to the beginning of the stream."r" This is convenience method, equivalent to `self.seek(SeekFrom::Start(0))`."r" Creates a future which will return the current seek position from the"r" start of the stream."r" This is equivalent to `self.seek(SeekFrom::Current(0))`."r" An extension trait that adds utility methods to [`AsyncSeek`] types."r" use std::io::{self, Cursor, SeekFrom};"r#"     let mut cursor = Cursor::new(b"abcdefg");"#r"     // the `seek` method is defined by this trait"r"     cursor.seek(SeekFrom::Start(3)).await?;"r"     let mut buf = [0; 1];"r"     let n = cursor.read(&mut buf).await?;"r"     assert_eq!(n, 1);"r"     assert_eq!(buf, [b'd']);"r" [`AsyncSeek`]: AsyncSeek"write_all_bufWriteAllBufWriteF32WriteF32LeWriteF64WriteF64LeWriteI128WriteI128LeWriteI16WriteI16LeWriteI32WriteI32LeWriteI64WriteI64LeWriteI8WriteU128WriteU128LeWriteU16WriteU16LeWriteU32WriteU32LeWriteU64WriteU64LeWriteU8r" Defines numeric writer."write_implr" Writes a buffer into this writer, returning how many bytes were"r" written."r" async fn write(&mut self, buf: &[u8]) -> io::Result<usize>;"r" This function will attempt to write the entire contents of `buf`, but"r" the entire write may not succeed, or the write may also generate an"r" error. A call to `write` represents *at most one* attempt to write to"r" any wrapped object."r" If the return value is `Ok(n)` then it must be guaranteed that `n <="r" buf.len()`. A return value of `0` typically means that the"r" underlying object is no longer able to accept bytes and will likely"r" not be able to in the future as well, or that the buffer provided is"r" empty."r" Each call to `write` may generate an I/O error indicating that the"r" operation could not be completed. If an error is returned then no bytes"r" in the buffer were written to this writer."r" It is **not** considered an error if the entire buffer could not be"r" written to this writer."r" This method is cancellation safe in the sense that if it is used as"r" the event in a [`tokio::select!`](crate::select) statement and some"r" other branch completes first, then it is guaranteed that no data was"r" written to this `AsyncWrite`."r#"     let mut file = File::create("foo.txt").await?;"#r"     // Writes some prefix of the byte string, not necessarily all of it."r#"     file.write(b"some bytes").await?;"#r"     file.flush().await?;"r" Like [`write`], except that it writes from a slice of buffers."r" async fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize>;"r" See [`AsyncWrite::poll_write_vectored`] for more details."r" use std::io::IoSlice;"r"     let bufs: &[_] = &["r#"         IoSlice::new(b"hello"),"#r#"         IoSlice::new(b" "),"#r#"         IoSlice::new(b"world"),"#r"     ];"r"     file.write_vectored(&bufs).await?;"r" [`write`]: AsyncWriteExt::write"r" Writes a buffer into this writer, advancing the buffer's internal"r" cursor."r" async fn write_buf<B: Buf>(&mut self, buf: &mut B) -> io::Result<usize>;"r" error. After the operation completes, the buffer's"r" internal cursor is advanced by the number of bytes written. A"r" subsequent call to `write_buf` using the **same** `buf` value will"r" resume from the point that the first call to `write_buf` completed."r" A call to `write_buf` represents *at most one* attempt to write to any"r" wrapped object."r" [`File`] implements [`AsyncWrite`] and [`Cursor`]`<&[u8]>` implements [`Buf`]:"r" [`Buf`]: bytes::Buf"r" use bytes::Buf;"r#"     let mut buffer = Cursor::new(b"data to write");"#r"     // Loop until the entire contents of the buffer are written to"r"     // the file."r"     while buffer.has_remaining() {"r"         // Writes some prefix of the byte string, not necessarily"r"         // all of it."r"         file.write_buf(&mut buffer).await?;"r" Attempts to write an entire buffer into this writer."r" async fn write_all_buf(&mut self, buf: impl Buf) -> Result<(), io::Error> {"r"     while buf.has_remaining() {"r"         self.write_buf(&mut buf).await?;"r" This method will continuously call [`write`] until"r" [`buf.has_remaining()`](bytes::Buf::has_remaining) returns false. This method will not"r" return until the entire buffer has been successfully written or an error occurs. The"r" first error generated will be returned."r" The buffer is advanced after each chunk is successfully written. After failure,"r" `src.chunk()` will return the chunk that failed to write."r" If `write_all_buf` is used as the event in a"r" completes first, then the data in the provided buffer may have been"r" partially written. However, it is guaranteed that the provided"r" buffer has been [advanced] by the amount of bytes that have been"r" partially written."r" [advanced]: bytes::Buf::advance"r"     file.write_all_buf(&mut buffer).await?;"r" async fn write_all(&mut self, buf: &[u8]) -> io::Result<()>;"r" This method will continuously call [`write`] until there is no more data"r" to be written. This method will not return until the entire buffer"r" has been successfully written or such an error occurs. The first"r" error generated from this method will be returned."r" This method is not cancellation safe. If it is used as the event"r" in a [`tokio::select!`](crate::select) statement and some other"r" branch completes first, then the provided buffer may have been"r" partially written, but future calls to `write_all` will start over"r" from the beginning of the buffer."r" This function will return the first error that [`write`] returns."r#"     file.write_all(b"some bytes").await?;"#r" Writes an unsigned 8-bit integer to the underlying writer."r" async fn write_u8(&mut self, n: u8) -> io::Result<()>;"r" It is recommended to use a buffered writer to avoid excessive"r" This method returns the same errors as [`AsyncWriteExt::write_all`]."r" [`AsyncWriteExt::write_all`]: AsyncWriteExt::write_all"r" Write unsigned 8 bit integers to a `AsyncWrite`:"r"     let mut writer = Vec::new();"r"     writer.write_u8(2).await?;"r"     writer.write_u8(5).await?;"r#"     assert_eq!(writer, b"\x02\x05");"#r" Writes a signed 8-bit integer to the underlying writer."r" async fn write_i8(&mut self, n: i8) -> io::Result<()>;"r" Write signed 8 bit integers to a `AsyncWrite`:"r"     writer.write_i8(-2).await?;"r"     writer.write_i8(126).await?;"r#"     assert_eq!(writer, b"\xFE\x7E");"#r" Writes an unsigned 16-bit integer in big-endian order to the"r" underlying writer."r" async fn write_u16(&mut self, n: u16) -> io::Result<()>;"r" Write unsigned 16-bit integers to a `AsyncWrite`:"r"     writer.write_u16(517).await?;"r"     writer.write_u16(768).await?;"r#"     assert_eq!(writer, b"\x02\x05\x03\x00");"#r" Writes a signed 16-bit integer in big-endian order to the"r" async fn write_i16(&mut self, n: i16) -> io::Result<()>;"r" Write signed 16-bit integers to a `AsyncWrite`:"r"     writer.write_i16(193).await?;"r"     writer.write_i16(-132).await?;"r#"     assert_eq!(writer, b"\x00\xc1\xff\x7c");"#r" Writes an unsigned 32-bit integer in big-endian order to the"r" async fn write_u32(&mut self, n: u32) -> io::Result<()>;"r" Write unsigned 32-bit integers to a `AsyncWrite`:"r"     writer.write_u32(267).await?;"r"     writer.write_u32(1205419366).await?;"r#"     assert_eq!(writer, b"\x00\x00\x01\x0b\x47\xd9\x3d\x66");"#r" Writes a signed 32-bit integer in big-endian order to the"r" async fn write_i32(&mut self, n: i32) -> io::Result<()>;"r" Write signed 32-bit integers to a `AsyncWrite`:"r"     writer.write_i32(267).await?;"r"     writer.write_i32(1205419366).await?;"r" Writes an unsigned 64-bit integer in big-endian order to the"r" async fn write_u64(&mut self, n: u64) -> io::Result<()>;"r" Write unsigned 64-bit integers to a `AsyncWrite`:"r"     writer.write_u64(918733457491587).await?;"r"     writer.write_u64(143).await?;"r#"     assert_eq!(writer, b"\x00\x03\x43\x95\x4d\x60\x86\x83\x00\x00\x00\x00\x00\x00\x00\x8f");"#r" Writes an signed 64-bit integer in big-endian order to the"r" async fn write_i64(&mut self, n: i64) -> io::Result<()>;"r" Write signed 64-bit integers to a `AsyncWrite`:"r"     writer.write_i64(i64::MIN).await?;"r"     writer.write_i64(i64::MAX).await?;"r#"     assert_eq!(writer, b"\x80\x00\x00\x00\x00\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff");"#r" Writes an unsigned 128-bit integer in big-endian order to the"r" async fn write_u128(&mut self, n: u128) -> io::Result<()>;"r" Write unsigned 128-bit integers to a `AsyncWrite`:"r"     writer.write_u128(16947640962301618749969007319746179).await?;"r"     assert_eq!(writer, vec!["r" Writes an signed 128-bit integer in big-endian order to the"r" async fn write_i128(&mut self, n: i128) -> io::Result<()>;"r" Write signed 128-bit integers to a `AsyncWrite`:"r"     writer.write_i128(i128::MIN).await?;"r" Writes an 32-bit floating point type in big-endian order to the"r" async fn write_f32(&mut self, n: f32) -> io::Result<()>;"r" Write 32-bit floating point type to a `AsyncWrite`:"r"     writer.write_f32(f32::MIN).await?;"r"     assert_eq!(writer, vec![0xff, 0x7f, 0xff, 0xff]);"r" Writes an 64-bit floating point type in big-endian order to the"r" async fn write_f64(&mut self, n: f64) -> io::Result<()>;"r" Write 64-bit floating point type to a `AsyncWrite`:"r"     writer.write_f64(f64::MIN).await?;"r" Writes an unsigned 16-bit integer in little-endian order to the"r" async fn write_u16_le(&mut self, n: u16) -> io::Result<()>;"r"     writer.write_u16_le(517).await?;"r"     writer.write_u16_le(768).await?;"r#"     assert_eq!(writer, b"\x05\x02\x00\x03");"#r" Writes a signed 16-bit integer in little-endian order to the"r" async fn write_i16_le(&mut self, n: i16) -> io::Result<()>;"r"     writer.write_i16_le(193).await?;"r"     writer.write_i16_le(-132).await?;"r#"     assert_eq!(writer, b"\xc1\x00\x7c\xff");"#write_i16_ler" Writes an unsigned 32-bit integer in little-endian order to the"r" async fn write_u32_le(&mut self, n: u32) -> io::Result<()>;"r"     writer.write_u32_le(267).await?;"r"     writer.write_u32_le(1205419366).await?;"r#"     assert_eq!(writer, b"\x0b\x01\x00\x00\x66\x3d\xd9\x47");"#write_u32_ler" Writes a signed 32-bit integer in little-endian order to the"r" async fn write_i32_le(&mut self, n: i32) -> io::Result<()>;"r"     writer.write_i32_le(267).await?;"r"     writer.write_i32_le(1205419366).await?;"write_i32_ler" Writes an unsigned 64-bit integer in little-endian order to the"r" async fn write_u64_le(&mut self, n: u64) -> io::Result<()>;"r"     writer.write_u64_le(918733457491587).await?;"r"     writer.write_u64_le(143).await?;"r#"     assert_eq!(writer, b"\x83\x86\x60\x4d\x95\x43\x03\x00\x8f\x00\x00\x00\x00\x00\x00\x00");"#write_u64_ler" Writes an signed 64-bit integer in little-endian order to the"r" async fn write_i64_le(&mut self, n: i64) -> io::Result<()>;"r"     writer.write_i64_le(i64::MIN).await?;"r"     writer.write_i64_le(i64::MAX).await?;"r#"     assert_eq!(writer, b"\x00\x00\x00\x00\x00\x00\x00\x80\xff\xff\xff\xff\xff\xff\xff\x7f");"#write_i64_ler" Writes an unsigned 128-bit integer in little-endian order to the"r" async fn write_u128_le(&mut self, n: u128) -> io::Result<()>;"r"     writer.write_u128_le(16947640962301618749969007319746179).await?;"r"         0x83, 0x86, 0x60, 0x4d, 0x95, 0x43, 0x03, 0x00,"write_u128_ler" Writes an signed 128-bit integer in little-endian order to the"r" async fn write_i128_le(&mut self, n: i128) -> io::Result<()>;"r"     writer.write_i128_le(i128::MIN).await?;"r"          0, 0, 0, 0, 0, 0, 0,"r"         0, 0, 0, 0, 0, 0, 0, 0, 0x80"write_i128_ler" Writes an 32-bit floating point type in little-endian order to the"r" async fn write_f32_le(&mut self, n: f32) -> io::Result<()>;"r"     writer.write_f32_le(f32::MIN).await?;"r"     assert_eq!(writer, vec![0xff, 0xff, 0x7f, 0xff]);"write_f32_ler" Writes an 64-bit floating point type in little-endian order to the"r" async fn write_f64_le(&mut self, n: f64) -> io::Result<()>;"r"     writer.write_f64_le(f64::MIN).await?;"write_f64_ler" Flushes this output stream, ensuring that all intermediately buffered"r" contents reach their destination."r" async fn flush(&mut self) -> io::Result<()>;"r" It is considered an error if not all bytes could be written due to"r" I/O errors or EOF being reached."r" use tokio::io::{self, BufWriter, AsyncWriteExt};"r#"     let f = File::create("foo.txt").await?;"#r"     let mut buffer = BufWriter::new(f);"r#"     buffer.write_all(b"some bytes").await?;"#r"     buffer.flush().await?;"r" Shuts down the output stream, ensuring that the value can be dropped"r" cleanly."r" async fn shutdown(&mut self) -> io::Result<()>;"r" Similar to [`flush`], all intermediately buffered is written to the"r" underlying stream. Once the operation completes, the caller should"r" no longer attempt to write to the stream. For example, the"r" `TcpStream` implementation will issue a `shutdown(Write)` sys call."r" [`flush`]: fn@crate::io::AsyncWriteExt::flush"r"     buffer.shutdown().await?;"r" Writes bytes to a sink."r" [`AsyncWrite`] types. Callers will tend to import this trait instead of"r" [`AsyncWrite`]."r#"     let data = b"some bytes";"#r"     let mut pos = 0;"r#"     let mut buffer = File::create("foo.txt").await?;"#r"     while pos < data.len() {"r"         let bytes_written = buffer.write(&data[pos..]).await?;"r"         pos += bytes_written;"seek_stateSeekState/// It is inadvisable to directly read from the underlying reader./// Consumes this `BufReader`, returning the underlying reader./// `start_seek` has not been called./// `start_seek` has been called, but `poll_complete` has not yet been called.PendingOverflowed/// Waiting for completion of the first `poll_complete` in the `n.checked_sub(remainder).is_none()` branch./// Waiting for completion of `poll_complete`.r" Wraps a type that is [`AsyncWrite`] and [`AsyncRead`], and buffers its input and output."r" It can be excessively inefficient to work directly with something that implements [`AsyncWrite`]"r" and [`AsyncRead`]. For example, every `write`, however small, has to traverse the syscall"r" interface, and similarly, every read has to do the same. The [`BufWriter`] and [`BufReader`]"r" types aid with these problems respectively, but do so in only one direction. `BufStream` wraps"r" one in the other so that both directions are buffered. See their documentation for details."/// Wraps a type in both [`BufWriter`] and [`BufReader`]./// See the documentation for those types and [`BufStream`] for details./// Creates a `BufStream` with the specified [`BufReader`] capacity and [`BufWriter`]/// Gets a reference to the underlying I/O object./// It is inadvisable to directly read from the underlying I/O object./// Gets a mutable reference to the underlying I/O object./// Gets a pinned mutable reference to the underlying I/O object./// Consumes this `BufStream`, returning the underlying I/O object./// Seek to an offset, in bytes, in the underlying stream./// position the underlying stream would be at if the `BufStream` had nor" Stream for the [`chain`](super::AsyncReadExt::chain) method."CopyBufferpoll_write_bufpoll_copy/// A future that asynchronously copies the entire contents of a reader into ar" Asynchronously copies the entire contents of a reader into a writer."r" This function returns a future that will continuously read data from"r" `reader` and then write it into `writer` in a streaming fashion until"r" `reader` returns EOF or fails."r" On success, the total number of bytes that were copied from `reader` to"r" `writer` is returned."r" This is an asynchronous version of [`std::io::copy`][std]."r" A heap-allocated copy buffer with 8 KB is created to take data from the"r" reader to the writer, check [`copy_buf`] if you want an alternative for"r" [`AsyncBufRead`]. You can use `copy_buf` with [`BufReader`] to change the"r" buffer capacity."r" [std]: std::io::copy"r" [`copy_buf`]: crate::io::copy_buf"r" [`BufReader`]: crate::io::BufReader"r" The returned future will return an error immediately if any call to"r" `poll_read` or `poll_write` returns an error."r" use tokio::io;"r#" let mut reader: &[u8] = b"hello";"#r" let mut writer: Vec<u8> = vec![];"r" io::copy(&mut reader, &mut writer).await?;"r#" assert_eq!(&b"hello"[..], &writer[..]);"#TransferStateShuttingDowntransfer_one_direction/// Copies data in both directions between `a` and `b`./// This function returns a future that will read from both streams,/// writing any data read to the opposing stream./// This happens in both directions concurrently./// If an EOF is observed on one stream, [`shutdown()`] will be invoked on/// the other, and reading from that stream will stop. Copying of data in/// the other direction will continue./// The future will complete successfully once both directions of communication has been shut down./// A direction is shut down when the reader reports EOF,/// at which point [`shutdown()`] is called on the corresponding writer. When finished,/// it will return a tuple of the number of bytes copied from a to b/// and the number of bytes copied from b to a, in that order./// It uses two 8 KB buffers for transferring bytes between `a` and `b` by default./// To set your own buffers sizes use [`copy_bidirectional_with_sizes()`]./// [`shutdown()`]: crate::io::AsyncWriteExt::shutdown/// The future will immediately return an error if any IO operation on `a`/// or `b` returns an error. Some data read from either stream may be lost (not/// written to the other stream) in this case./// Returns a tuple of bytes copied `a` to `b` and bytes copied `b` to `a`./// Copies data in both directions between `a` and `b` using buffers of the specified size./// This method is the same as the [`copy_bidirectional()`], except that it allows you to set the/// size of the internal buffers used when copying data.copy_bidirectional_implr" A future that asynchronously copies the entire contents of a reader into a"r" writer."r" This struct is generally created by calling [`copy_buf`][copy_buf]. Please"r" see the documentation of `copy_buf()` for more details."r" [copy_buf]: copy_buf()"r" This is a [`tokio::io::copy`] alternative for [`AsyncBufRead`] readers"r" with no extra buffer allocation, since [`AsyncBufRead`] allow access"r" to the reader's inner buffer."r" [`tokio::io::copy`]: crate::io::copy"r" The returned future will finish with an error will return an error"r" immediately if any call to `poll_fill_buf` or `poll_write` returns an"r" io::copy_buf(&mut reader, &mut writer).await?;"r#" assert_eq!(b"hello", &writer[..]);"#poll_proceed_and_make_progressr" `Empty` ignores any data written via [`AsyncWrite`], and will always be empty"r" (returning zero bytes) when read via [`AsyncRead`]."r" This struct is generally created by calling [`empty`]. Please see"r" the documentation of [`empty()`][`empty`] for more details."r" This is an asynchronous version of [`std::io::empty`][std]."r" [`empty`]: fn@empty"r" [std]: std::io::empty"r" Creates a value that is always at EOF for reads, and ignores all data written."r" All writes on the returned instance will return `Poll::Ready(Ok(buf.len()))`"r" and the contents of the buffer will not be inspected."r" All reads from the returned instance will return `Poll::Ready(Ok(0))`."r" A slightly sad example of not reading anything into a buffer:"r"     io::empty().read_to_string(&mut buffer).await.unwrap();"r" A convoluted way of getting the length of a buffer:"r"     let buffer = vec![1, 2, 3, 5, 8];"r"     let num_bytes = io::empty().write(&buffer).await.unwrap();"r" Future for the [`fill_buf`](crate::io::AsyncBufReadExt::fill_buf) method."r" A future used to fully flush an I/O object."r" Created by the [`AsyncWriteExt::flush`][flush] function."r" [flush]: crate::io::AsyncWriteExt::flush"/// Creates a future which will entirely flush an I/O object.r" Reads lines from an [`AsyncBufRead`]."r" A `Lines` can be turned into a `Stream` with [`LinesStream`]."r" This type is usually created using the [`lines`] method."r" [`LinesStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.LinesStream.html"r" [`lines`]: crate::io::AsyncBufReadExt::lines"/// Returns the next line in the stream./// # use tokio::io::AsyncBufRead;/// use tokio::io::AsyncBufReadExt;/// # async fn dox(my_buf_read: impl AsyncBufRead + Unpin) -> std::io::Result<()> {/// let mut lines = my_buf_read.lines();/// while let Some(line) = lines.next_line().await? {///     println!("length = {}", line.len())/// Obtains a mutable reference to the underlying reader./// Obtains a reference to the underlying reader./// Unwraps this `Lines<R>`, returning the underlying reader./// Therefore, a following read from the underlying reader may lead to data loss.poll_next_line/// Polls for the next line in the stream.///  * `Poll::Pending` if the next line is not yet available.///  * `Poll::Ready(Ok(Some(line)))` if the next line is available.///  * `Poll::Ready(Ok(None))` if there are no more lines in this stream.///  * `Poll::Ready(Err(err))` if an IO error occurred while reading the next line./// `Context` is scheduled to receive a wakeup when more bytes become/// available on the underlying IO resource.  Note that on multiple calls to/// `poll_next_line`, only the `Waker` from the `Context` passed to the most/// recent call is scheduled to receive a wakeup./// A bidirectional pipe to read and write bytes in memory./// A pair of `DuplexStream`s are created together, and they act as a "channel"/// that can be used as in-memory IO types. Writing to one of the pairs will/// allow that data to be read from the other, and vice versa./// # Closing a `DuplexStream`/// If one end of the `DuplexStream` channel is dropped, any pending reads on/// the other side will continue to read data until the buffer is drained, then/// they will signal EOF by returning 0 bytes. Any writes to the other side,/// including pending ones (that are waiting for free space in the buffer) will/// return `Err(BrokenPipe)` immediately./// # async fn ex() -> std::io::Result<()> {/// # use tokio::io::{AsyncReadExt, AsyncWriteExt};/// let (mut client, mut server) = tokio::io::duplex(64);/// client.write_all(b"ping").await?;/// let mut buf = [0u8; 4];/// server.read_exact(&mut buf).await?;/// assert_eq!(&buf, b"ping");/// server.write_all(b"pong").await?;/// client.read_exact(&mut buf).await?;/// assert_eq!(&buf, b"pong");/// The buffer storing the bytes written, also read from./// Using a `BytesMut` because it has efficient `Buf` and `BufMut`/// functionality already. Additionally, it can try to copy data in the/// same buffer if there read index has advanced far enough./// Determines if the write side has been closed./// The maximum amount of bytes that can be written before returningread_waker/// If the `read` side has been polled and is pending, this is the waker/// for that parked task.write_waker/// If the `write` side has filled the `max_buf_size` and returned/// `Poll::Pending`, this is the waker for that parked task./// A unidirectional pipe to read and write bytes in memory./// It can be constructed by [`simplex`] function which will create a pair of/// reader and writer or by calling [`SimplexStream::new_unsplit`] that will/// create a handle for both reading and writing./// let (mut receiver, mut sender) = tokio::io::simplex(64);/// sender.write_all(b"ping").await?;/// receiver.read_exact(&mut buf).await?;/// Create a new pair of `DuplexStream`s that act like a pair of connected sockets./// The `max_buf_size` argument is the maximum amount of bytes that can be/// written to a side before the write returns `Poll::Pending`.// Previous rustc required this `self` to be `mut`, even though newer// versions recognize it isn't needed to call `lock()`. So for// compatibility, we include the `mut` and `allow` the lint.// See https://github.com/rust-lang/rust/issues/73592/// Creates unidirectional buffer that acts like in memory pipe./// written to a buffer before the it returns `Poll::Pending`./// # Unify reader and writer/// The reader and writer half can be unified into a single structure/// of `SimplexStream` that supports both reading and writing or/// the `SimplexStream` can be already created as unified structure/// using [`SimplexStream::new_unsplit()`]./// let (reader, writer) = tokio::io::simplex(64);/// let mut simplex_stream = reader.unsplit(writer);/// simplex_stream.write_all(b"hello").await?;/// simplex_stream.read_exact(&mut buf).await?;/// assert_eq!(&buf, b"hello");new_unsplit/// Creates unidirectional buffer that acts like in memory pipe. To create split/// version with separate reader and writer you can use [`simplex`] function.poll_read_internalpoll_write_internalpoll_write_vectored_internalcfg_coopcfg_not_coop//! In-process memory IO types.// ===== impl DuplexStream =====// ===== impl SimplexStream =====async_buf_read_extasync_read_extasync_seek_extasync_write_extbuf_streamvec_with_initialized/// The returned future will resolve to both the I/O stream and the buffer/// as well as the number of bytes read once the read operation is completed.r" A future which can be used to easily read available number of bytes to fill"r" a buffer."r" Created by the [`read`] function."r" Future returned by [`read_buf`](crate::io::AsyncReadExt::read_buf)."/// A future which can be used to easily read exactly enough bytes to fill/// a buffer./// Created by the [`AsyncReadExt::read_exact`][read_exact]./// [`read_exact`]: [`crate::io::AsyncReadExt::read_exact`]r" Creates a future which will read exactly enough bytes to fill `buf`,"r" returning an error if EOF is hit sooner."r" On success the number of bytes is returned"reader8r" Future returned from `read_u8`"r" Future for the [`read_line`](crate::io::AsyncBufReadExt::read_line) method."put_back_original_datafinish_string_read/// This handles the various failure cases and puts the string back into `output`./// The `truncate_on_io_error` `bool` is necessary because `read_to_string` and `read_line`/// disagree on what should happen when an IO error occurs.into_read_buf_partsVecWithInitializedpoll_read_to_end/// Tries to read from the provided [`AsyncRead`]./// The length of the buffer is increased by the number of bytes read.r" Future for the [`read_to_string`](super::AsyncReadExt::read_to_string) method."r" Future for the [`read_until`](crate::io::AsyncBufReadExt::read_until) method."r" The delimiter is included in the resulting vector."r" An async reader which yields one byte over and over and over and over and"r" over and..."r" This struct is generally created by calling [`repeat`][repeat]. Please"r" see the documentation of `repeat()` for more details."r" This is an asynchronous version of [`std::io::Repeat`][std]."r" [repeat]: fn@repeat"r" [std]: std::io::Repeat"r" Creates an instance of an async reader that infinitely repeats one byte."r" All reads from this reader will succeed by filling the specified buffer with"r" the given byte."r" This is an asynchronous version of [`std::io::repeat`][std]."r" [std]: std::io::repeat"r"     let mut buffer = [0; 3];"r"     io::repeat(0b101).read_exact(&mut buffer).await.unwrap();"r"     assert_eq!(buffer, [0b101, 0b101, 0b101]);"r" A future used to shutdown an I/O object."r" Created by the [`AsyncWriteExt::shutdown`][shutdown] function."r" [shutdown]: [`crate::io::AsyncWriteExt::shutdown`]"/// Creates a future which will shutdown an I/O object.r" An async writer which will move data into the void."r" This struct is generally created by calling [`sink`][sink]. Please"r" see the documentation of `sink()` for more details."r" This is an asynchronous version of [`std::io::Sink`][std]."r" [sink]: sink()"r" [std]: std::io::Sink"r" Creates an instance of an async writer which will successfully consume all"r" data."r" All calls to [`poll_write`] on the returned instance will return"r" `Poll::Ready(Ok(buf.len()))` and the contents of the buffer will not be"r" inspected."r" This is an asynchronous version of [`std::io::sink`][std]."r" [`poll_write`]: crate::io::AsyncWrite::poll_write()"r" [std]: std::io::sink"r"     let num_bytes = io::sink().write(&buffer).await?;"r" Splitter for the [`split`](crate::io::AsyncBufReadExt::split) method."r" A `Split` can be turned into a `Stream` with [`SplitStream`]."r" [`SplitStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.SplitStream.html"next_segment/// Returns the next segment in the stream./// let mut segments = my_buf_read.split(b'f');/// while let Some(segment) = segments.next_segment().await? {///     println!("length = {}", segment.len())poll_next_segment/// Polls for the next segment in the stream.///  * `Poll::Pending` if the next segment is not yet available.///  * `Poll::Ready(Ok(Some(segment)))` if the next segment is available.///  * `Poll::Ready(Ok(None))` if there are no more segments in this stream.///  * `Poll::Ready(Err(err))` if an IO error occurred while reading the///    next segment./// available on the underlying IO resource./// Note that on multiple calls to `poll_next_segment`, only the `Waker`/// from the `Context` passed to the most recent call is scheduled to/// receive a wakeup.r" Stream for the [`take`](super::AsyncReadExt::take) method.""streams do nothing unless you `.await` or poll them"limit_/// underlying reader as doing so may corrupt the internal limit of this/// `Take`./// Consumes the `Take`, returning the wrapped reader./// Something that looks like a `Vec<u8>`./// The implementor must guarantee that the vector returned by the/// `as_mut` and `as_mut` methods do not change from one call tonum_initialized// The number of initialized bytes in the vector.// Always between `vec.len()` and `vec.capacity()`.starting_capacity/// This struct wraps a `Vec<u8>` or `&mut Vec<u8>`, combining it with a/// `num_initialized`, which keeps track of the number of initialized bytes/// in the unused capacity./// The purpose of this struct is to remember how many bytes were initialized/// through a `ReadBuf` from call to call./// This struct has the safety invariant that the first `num_initialized` of the/// vector's allocation must be initialized at any time.get_read_bufapply_read_bufReadBufPartstry_small_read_first// Returns a boolean telling the caller to try reading into a small local buffer first if true.// Doing so would avoid overallocating when vec is filled to capacity and we reached EOF.// Pointer is only used to check that the ReadBuf actually came from the// right VecWithInitialized.// This is needed to release the borrow on `VecWithInitialized<V>`.r" A future to write some of the buffer to an `AsyncWrite`."/// Tries to write some bytes from the given `buf` to the writer in an/// asynchronous manner, returning a future.writer8r" A future to write a slice of buffers to an `AsyncWrite`."// Includes re-exports used by macros.// This module is not intended to be part of the public API. In general, any// `doc(hidden)` code is not part of Tokio's public and stable API.cfg_signalcfg_signal_internalcfg_not_synccfg_timecfg_taskdumpcfg_not_taskdumptrace_leafasync_trace_leaf/// Due to the `Stream` trait's inclusion in `std` landing later than Tokio's 1.0/// release, most of the Tokio stream utilities have been moved into the [`tokio-stream`]/// # Why was `Stream` not included in Tokio 1.0?/// Originally, we had planned to ship Tokio 1.0 with a stable `Stream` type/// but unfortunately the [RFC] had not been merged in time for `Stream` to/// reach `std` on a stable compiler in time for the 1.0 release of Tokio. For/// this reason, the team has decided to move all `Stream` based utilities to/// the [`tokio-stream`] crate. While this is not ideal, once `Stream` has made/// it into the standard library and the `MSRV` period has passed, we will implement/// stream for our different types./// While this may seem unfortunate, not all is lost as you can get much of the/// `Stream` support with `async/await` and `while let` loops. It is also possible/// to create a `impl Stream` from `async fn` using the [`async-stream`] crate./// [`tokio-stream`]: https://docs.rs/tokio-stream/// [`async-stream`]: https://docs.rs/async-stream/// [RFC]: https://github.com/rust-lang/rfcs/pull/2996/// Convert a [`sync::mpsc::Receiver`] to an `impl Stream`./// use tokio::sync::mpsc;/// let (tx, mut rx) = mpsc::channel::<usize>(16);/// let stream = async_stream::stream! {///     while let Some(item) = rx.recv().await {///         yield item;cfg_macrosr" Implementation detail of the `select!` macro. This macro is **not**"r" intended to be used as part of the public API and is permitted to"r" change."select_priv_declare_output_enumselect_priv_clean_patterncfg_not_rt_multi_threadis_unpin// TODO: rm//! A runtime for writing reliable network applications without compromising speed.//! Tokio is an event-driven, non-blocking I/O platform for writing asynchronous//! applications with the Rust programming language. At a high level, it//! provides a few major components://! * Tools for [working with asynchronous tasks][tasks], including//!   [synchronization primitives and channels][sync] and [timeouts, sleeps, and//!   intervals][time].//! * APIs for [performing asynchronous I/O][io], including [TCP and UDP][net] sockets,//!   [filesystem][fs] operations, and [process] and [signal] management.//! * A [runtime] for executing asynchronous code, including a task scheduler,//!   an I/O driver backed by the operating system's event queue (`epoll`, `kqueue`,//!   `IOCP`, etc...), and a high performance timer.//! Guide level documentation is found on the [website].//! [tasks]: #working-with-tasks//! [sync]: crate::sync//! [time]: crate::time//! [io]: #asynchronous-io//! [net]: crate::net//! [fs]: crate::fs//! [process]: crate::process//! [signal]: crate::signal//! [runtime]: crate::runtime//! [website]: https://tokio.rs/tokio/tutorial//! # A Tour of Tokio//! Tokio consists of a number of modules that provide a range of functionality//! essential for implementing asynchronous applications in Rust. In this//! section, we will take a brief tour of Tokio, summarizing the major APIs and//! their uses.//! The easiest way to get started is to enable all features. Do this by//! enabling the `full` feature flag://! tokio = { version = "1", features = ["full"] }//! ### Authoring applications//! Tokio is great for writing applications and most users in this case shouldn't//! worry too much about what features they should pick. If you're unsure, we suggest//! going with `full` to ensure that you don't run into any road blocks while you're//! building your application.//! #### Example//! This example shows the quickest way to get started with Tokio.//! ### Authoring libraries//! As a library author your goal should be to provide the lightest weight crate//! that is based on Tokio. To achieve this you should ensure that you only enable//! the features you need. This allows users to pick up your crate without having//! to enable unnecessary features.//! This example shows how you may want to import features for a library that just//! needs to `tokio::spawn` and use a `TcpStream`.//! tokio = { version = "1", features = ["rt", "net"] }//! ## Working With Tasks//! Asynchronous programs in Rust are based around lightweight, non-blocking//! units of execution called [_tasks_][tasks]. The [`tokio::task`] module provides//! important tools for working with tasks://! * The [`spawn`] function and [`JoinHandle`] type, for scheduling a new task//!   on the Tokio runtime and awaiting the output of a spawned task, respectively,//! * Functions for [running blocking operations][blocking] in an asynchronous//!   task context.//! The [`tokio::task`] module is present only when the "rt" feature flag//! is enabled.//! [tasks]: task/index.html#what-are-tasks//! [`tokio::task`]: crate::task//! [`spawn`]: crate::task::spawn()//! [`JoinHandle`]: crate::task::JoinHandle//! [blocking]: task/index.html#blocking-and-yielding//! The [`tokio::sync`] module contains synchronization primitives to use when//! needing to communicate or share data. These include://! * channels ([`oneshot`], [`mpsc`], [`watch`], and [`broadcast`]), for sending values//!   between tasks,//! * a non-blocking [`Mutex`], for controlling access to a shared, mutable//!   value,//! * an asynchronous [`Barrier`] type, for multiple tasks to synchronize before//!   beginning a computation.//! The `tokio::sync` module is present only when the "sync" feature flag is//! [`tokio::sync`]: crate::sync//! [`Mutex`]: crate::sync::Mutex//! [`Barrier`]: crate::sync::Barrier//! [`oneshot`]: crate::sync::oneshot//! [`mpsc`]: crate::sync::mpsc//! [`watch`]: crate::sync::watch//! [`broadcast`]: crate::sync::broadcast//! The [`tokio::time`] module provides utilities for tracking time and//! scheduling work. This includes functions for setting [timeouts][timeout] for//! tasks, [sleeping][sleep] work to run in the future, or [repeating an operation at an//! interval][interval].//! In order to use `tokio::time`, the "time" feature flag must be enabled.//! [`tokio::time`]: crate::time//! [sleep]: crate::time::sleep()//! [interval]: crate::time::interval()//! [timeout]: crate::time::timeout()//! Finally, Tokio provides a _runtime_ for executing asynchronous tasks. Most//! applications can use the [`#[tokio::main]`][main] macro to run their code on the//! Tokio runtime. However, this macro provides only basic configuration options. As//! an alternative, the [`tokio::runtime`] module provides more powerful APIs for configuring//! and managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't//! provide the functionality you need.//! Using the runtime requires the "rt" or "rt-multi-thread" feature flags, to//! enable the current-thread [single-threaded scheduler][rt] and the [multi-thread//! scheduler][rt-multi-thread], respectively. See the [`runtime` module//! documentation][rt-features] for details. In addition, the "macros" feature//! flag enables the `#[tokio::main]` and `#[tokio::test]` attributes.//! [main]: attr.main.html//! [`tokio::runtime`]: crate::runtime//! [`Builder`]: crate::runtime::Builder//! [`Runtime`]: crate::runtime::Runtime//! [rt]: runtime/index.html#current-thread-scheduler//! [rt-multi-thread]: runtime/index.html#multi-thread-scheduler//! [rt-features]: runtime/index.html#runtime-scheduler//! ## CPU-bound tasks and blocking code//! Tokio is able to concurrently run many tasks on a few threads by repeatedly//! swapping the currently running task on each thread. However, this kind of//! swapping can only happen at `.await` points, so code that spends a long time//! without reaching an `.await` will prevent other tasks from running. To//! combat this, Tokio provides two kinds of threads: Core threads and blocking threads.//! The core threads are where all asynchronous code runs, and Tokio will by default//! spawn one for each CPU core. You can use the environment variable `TOKIO_WORKER_THREADS`//! to override the default value.//! The blocking threads are spawned on demand, can be used to run blocking code//! that would otherwise block other tasks from running and are kept alive when//! not used for a certain amount of time which can be configured with [`thread_keep_alive`].//! Since it is not possible for Tokio to swap out blocking tasks, like it//! can do with asynchronous code, the upper limit on the number of blocking//! threads is very large. These limits can be configured on the [`Builder`].//! To spawn a blocking task, you should use the [`spawn_blocking`] function.//! [`spawn_blocking`]: crate::task::spawn_blocking()//! [`thread_keep_alive`]: crate::runtime::Builder::thread_keep_alive()//! async fn main() {//!     // This is running on a core thread.//!     let blocking_task = tokio::task::spawn_blocking(|| {//!         // This is running on a blocking thread.//!         // Blocking here is ok.//!     // We can wait for the blocking task like this://!     // If the blocking task panics, the unwrap below will propagate the//!     // panic.//!     blocking_task.await.unwrap();//! If your code is CPU-bound and you wish to limit the number of threads used//! to run it, you should use a separate thread pool dedicated to CPU bound tasks.//! For example, you could consider using the [rayon] library for CPU-bound//! tasks. It is also possible to create an extra Tokio runtime dedicated to//! CPU-bound tasks, but if you do this, you should be careful that the extra//! runtime runs _only_ CPU-bound tasks, as IO-bound tasks on that runtime//! will behave poorly.//! Hint: If using rayon, you can use a [`oneshot`] channel to send the result back//! to Tokio when the rayon task finishes.//! [rayon]: https://docs.rs/rayon//! ## Asynchronous IO//! As well as scheduling and running tasks, Tokio provides everything you need//! to perform input and output asynchronously.//! The [`tokio::io`] module provides Tokio's asynchronous core I/O primitives,//! the [`AsyncRead`], [`AsyncWrite`], and [`AsyncBufRead`] traits. In addition,//! when the "io-util" feature flag is enabled, it also provides combinators and//! functions for working with these traits, forming as an asynchronous//! counterpart to [`std::io`].//! Tokio also includes APIs for performing various kinds of I/O and interacting//! with the operating system asynchronously. These include://! * [`tokio::net`], which contains non-blocking versions of [TCP], [UDP], and//!   [Unix Domain Sockets][UDS] (enabled by the "net" feature flag),//! * [`tokio::fs`], similar to [`std::fs`] but for performing filesystem I/O//!   asynchronously (enabled by the "fs" feature flag),//! * [`tokio::signal`], for asynchronously handling Unix and Windows OS signals//!   (enabled by the "signal" feature flag),//! * [`tokio::process`], for spawning and managing child processes (enabled by//!   the "process" feature flag).//! [`tokio::io`]: crate::io//! [`AsyncRead`]: crate::io::AsyncRead//! [`AsyncWrite`]: crate::io::AsyncWrite//! [`std::io`]: std::io//! [`tokio::net`]: crate::net//! [TCP]: crate::net::tcp//! [UDP]: crate::net::UdpSocket//! [UDS]: crate::net::unix//! [`tokio::fs`]: crate::fs//! [`std::fs`]: std::fs//! [`tokio::signal`]: crate::signal//! [`tokio::process`]: crate::process//! A simple TCP echo server://! use tokio::net::TcpListener;//! use tokio::io::{AsyncReadExt, AsyncWriteExt};//! async fn main() -> Result<(), Box<dyn std::error::Error>> {//!     let listener = TcpListener::bind("127.0.0.1:8080").await?;//!         let (mut socket, _) = listener.accept().await?;//!         tokio::spawn(async move {//!             let mut buf = [0; 1024];//!             // In a loop, read data from the socket and write the data back.//!                 let n = match socket.read(&mut buf).await {//!                     // socket closed//!                     Ok(0) => return,//!                     Ok(n) => n,//!                         eprintln!("failed to read from socket; err = {:?}", e);//!                         return;//!                 };//!                 // Write the data back//!                 if let Err(e) = socket.write_all(&buf[0..n]).await {//!                     eprintln!("failed to write to socket; err = {:?}", e);//! Tokio uses a set of [feature flags] to reduce the amount of compiled code. It//! is possible to just enable certain features over others. By default, Tokio//! does not enable any features but allows one to enable a subset for their use//! case. Below is a list of the available feature flags. You may also notice//! above each function, struct and trait there is listed one or more feature flags//! that are required for that item to be used. If you are new to Tokio it is//! recommended that you use the `full` feature flag which will enable all public APIs.//! Beware though that this will pull in many extra dependencies that you may not//! - `full`: Enables all features listed below except `test-util` and `tracing`.//! - `rt`: Enables `tokio::spawn`, the current-thread scheduler,//!         and non-scheduler utilities.//! - `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.//! - `io-util`: Enables the IO based `Ext` traits.//! - `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types.//! - `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and//!          `UdpSocket`, as well as (on Unix-like systems) `AsyncFd` and (on//!          FreeBSD) `PollAio`.//! - `time`: Enables `tokio::time` types and allows the schedulers to enable//!           the built in timer.//! - `process`: Enables `tokio::process` types.//! - `macros`: Enables `#[tokio::main]` and `#[tokio::test]` macros.//! - `sync`: Enables all `tokio::sync` types.//! - `signal`: Enables all `tokio::signal` types.//! - `fs`: Enables `tokio::fs` types.//! - `test-util`: Enables testing based infrastructure for the Tokio runtime.//! - `parking_lot`: As a potential optimization, use the `_parking_lot_` crate's//!                  synchronization primitives internally. Also, this//!                  dependency is necessary to construct some of our primitives//!                  in a `const` context. `MSRV` may increase according to the//!                  `_parking_lot_` release in use.//! _Note: `AsyncRead` and `AsyncWrite` traits do not require any features and are//! always available._//! Some feature flags are only available when specifying the `tokio_unstable` flag://! - `tracing`: Enables tracing events.//! Likewise, some parts of the API are only available with the same flag://! - [`task::Builder`]//! - Some methods on [`task::JoinSet`]//! - [`runtime::RuntimeMetrics`]//! - [`runtime::Builder::on_task_spawn`]//! - [`runtime::Builder::on_task_terminate`]//! - [`runtime::Builder::unhandled_panic`]//! - [`runtime::TaskMeta`]//! This flag enables **unstable** features. The public API of these features//! may break in 1.x releases. To enable these features, the `--cfg//! tokio_unstable` argument must be passed to `rustc` when compiling. This//! serves to explicitly opt-in to features which may break semver conventions,//! since Cargo [does not yet directly support such opt-ins][unstable features].//! You can specify it in your project's `.cargo/config.toml` file://! [build]//! rustflags = ["--cfg", "tokio_unstable"]//! The <code>[build]</code> section does <strong>not</strong> go in a//! <code>Cargo.toml</code> file. Instead it must be placed in the Cargo config//! file <code>.cargo/config.toml</code>.//! Alternatively, you can specify it with an environment variable://! ## Many *nix shells://! export RUSTFLAGS="--cfg tokio_unstable"//! cargo build//! ## Windows PowerShell://! $Env:RUSTFLAGS="--cfg tokio_unstable"//! [unstable features]: https://internals.rust-lang.org/t/feature-request-unstable-opt-in-non-transitive-crate-features/16193#why-not-a-crate-feature-2//! # Supported platforms//! Tokio currently guarantees support for the following platforms://!  * Linux//!  * Windows//!  * Android (API level 21)//!  * macOS//!  * iOS//!  * FreeBSD//! Tokio will continue to support these platforms in the future. However,//! future releases may change requirements such as the minimum required libc//! version on Linux, the API level on Android, or the supported FreeBSD//! release.//! Beyond the above platforms, Tokio is intended to work on all platforms//! supported by the mio crate. You can find a longer list [in mio's//! documentation][mio-supported]. However, these additional platforms may//! become unsupported in the future.//! Note that Wine is considered to be a different platform from Windows. See//! mio's documentation for more information on Wine support.//! [mio-supported]: https://crates.io/crates/mio#platforms//! ## `WASM` support//! Tokio has some limited support for the `WASM` platform. Without the//! `tokio_unstable` flag, the following features are supported://!  * `sync`//!  * `macros`//!  * `io-util`//!  * `rt`//!  * `time`//! Enabling any other feature (including `full`) will cause a compilation//! failure.//! The `time` module will only work on `WASM` platforms that have support for//! timers (e.g. wasm32-wasi). The timing functions will panic if used on a `WASM`//! platform that does not support timers.//! Note also that if the runtime becomes indefinitely idle, it will panic//! immediately instead of blocking forever. On platforms that don't support//! time, this means that the runtime can never be idle in any way.//! ## Unstable `WASM` support//! Tokio also has unstable support for some additional `WASM` features. This//! requires the use of the `tokio_unstable` flag.//! Using this flag enables the use of `tokio::net` on the wasm32-wasi target.//! However, not all methods are available on the networking types as `WASI`//! currently does not support the creation of new sockets from within `WASM`.//! Because of this, sockets must currently be created via the `FromRawFd`// local re-exports of platform specific things, allowing for decent// documentation to be shimmed in on docs.rsStaticAtomicU64// TODO: implement a loom version//! This module abstracts over `loom` and `std::sync` depending on whether we//! are running tests or not./// `AtomicU16` providing an additional `unsync_load` function.unsync_load/// Performs an unsynchronized load./// All mutations must have happened before the unsynchronized load./// Additionally, there must be no concurrent mutations./// `AtomicU32` providing an additional `unsync_load` function.cfg_has_atomic_u64"atomic_u64_native.rs"// `AtomicU64` can only be used on targets with `target_has_atomic` is 64 or greater.// Once `cfg_target_has_atomic` feature is stable, we can replace it with// `#[cfg(target_has_atomic = "64")]`.// Refs: https://github.com/rust-lang/rust/tree/master/src/librustc_targetcfg_not_has_atomic_u64//! Implementation of an atomic `u64` cell. On 64 bit platforms, this is a//! re-export of `AtomicU64`. On 32 bit platforms, this is implemented using acfg_has_const_mutex_newcfg_not_has_const_mutex_newstatic_macro/// Alias `AtomicU64` to `StaticAtomicU64`/// `AtomicUsize` providing an additional `unsync_load` function./// A barrier enables multiple threads to synchronize the beginning/// of some computation./// let barrier = Arc::new(Barrier::new(10));///     let c = Arc::clone(&barrier);/// A `BarrierWaitResult` is returned by [`Barrier::wait()`] when all threads/// in the [`Barrier`] have rendezvoused./// use std::sync::Barrier;/// A barrier will block `n`-1 threads which call [`wait()`] and then wake/// up all threads at once when the `n`th thread calls [`wait()`]./// [`wait()`]: Barrier::wait/// let barrier = Barrier::new(10);/// returns `true` from [`BarrierWaitResult::is_leader()`] when returning/// from this function, and all other threads will receive a result that/// will return `false` from [`BarrierWaitResult::is_leader()`]./// Blocks the current thread until all threads have rendezvoused here for/// at most `timeout` duration./// Returns `true` if this thread is the "leader thread" for the call to/// [`Barrier::wait()`].//! A `Barrier` that provides `wait_timeout`.//! This implementation mirrors that of the Rust standard library.unsafe_cell// Below, make sure all the feature-influenced types are exported for// internal use. Note however that some are not _currently_ named by// consuming code.panicking/// Adapter for `std::Mutex` that removes the poisoning aspects/// from its API.// Types that do not need wrapping// Note: Additional methods `is_poisoned` and `into_inner`, can be// provided here as needed.// Note: Additional methods `wait_timeout_ms`, `wait_timeout_until`,// `wait_until` can be provided here as needed.//! A minimal adaption of the `parking_lot` synchronization primitives to the//! equivalent `std::sync` types.//! This can be extended to additional types/methods as required.// All types in this file are marked with PhantomData to ensure that// parking_lot's send_guard feature does not leak through and affect when Tokio// types are Send.// See <https://github.com/tokio-rs/tokio/pull/4359> for more info./// Adapter for `std::sync::RwLock` that removes the poisoning aspects/// from its api.generate_addr_of_methods//! This module defines a macro that lets you go from a raw pointer to a struct//! to a raw pointer to a field of the struct./// Enables Windows-specific code./// Use this macro instead of `cfg(windows)` to generate docs properly.cfg_unix/// Enables Unix-specific code./// Use this macro instead of `cfg(unix)` to generate docs properly.cfg_unstable_windows/// Enables unstable Windows-specific code.cfg_block_on/// Enables `enter::block_on`.cfg_atomic_waker_impl/// Enables internal `AtomicWaker` impl.cfg_not_io_drivercfg_io_readinesscfg_loomcfg_not_loomcfg_unstable_metricscfg_64bit_metrics/// Some metrics require 64-bit atomics.cfg_no_64bit_metricscfg_not_unstable_metricscfg_not_rt_and_metrics_and_netcfg_net_or_processcfg_net_windowscfg_process_drivercfg_not_process_drivercfg_signal_internal_and_unixcfg_not_signal_internalcfg_rt_multi_threadcfg_test_utilcfg_not_test_utilcfg_not_timecfg_unstablecfg_not_wasicfg_is_wasm_not_wasir" Waits on multiple concurrent branches, returning when **all** branches"r" complete."r" The `join!` macro must be used inside of async functions, closures, and"r" blocks."r" The `join!` macro takes a list of async expressions and evaluates them"r" concurrently on the same task. Each async expression evaluates to a future"r" and the futures from each expression are multiplexed on the current task."r" When working with async expressions returning `Result`, `join!` will wait"r" for **all** branches complete regardless if any complete with `Err`. Use"r" [`try_join!`] to return early when `Err` is encountered."r" [`try_join!`]: crate::try_join"r" The supplied futures are stored inline and do not require allocating a"r" `Vec`."r" ### Runtime characteristics"r" By running all async expressions on the current task, the expressions are"r" able to run **concurrently** but not in **parallel**. This means all"r" expressions are run on the same thread and if one branch blocks the thread,"r" all other expressions will be unable to continue. If parallelism is"r" required, spawn each async expression using [`tokio::spawn`] and pass the"r" join handle to `join!`."r" [`tokio::spawn`]: crate::spawn"r" Basic join with two branches"r" async fn do_stuff_async() {"r"     // async work"r" async fn more_async_work() {"r"     // more here"r"     let (first, second) = tokio::join!("r"         do_stuff_async(),"r"         more_async_work());"r"     // do something with the values"if_loom// Includes re-exports needed to implement macros/// Calls to `async fn` return anonymous [`Future`] values that are `!Unpin`./// These values must be pinned before they can be polled. Calling `.await` will/// handle this, but consumes the future. If it is required to call `.await` on/// a `&mut _` reference, the caller is responsible for pinning the future./// Pinning may be done by allocating with [`Box::pin`] or by using the stack/// with the `pin!` macro./// The following will **fail to compile**:/// async fn my_async_fn() {///     // async logic here///     let mut future = my_async_fn();///     (&mut future).await;/// To make this work requires pinning:/// use tokio::pin;///     let future = my_async_fn();///     pin!(future);/// Pinning is useful when using `select!` and stream operators that require `T:/// Stream + Unpin`./// [`Future`]: trait@std::future::Future/// [`Box::pin`]: std::boxed::Box::pin/// The `pin!` macro takes **identifiers** as arguments. It does **not** work/// with expressions./// The following does not compile as an expression is passed to `pin!`.///     let mut future = pin!(my_async_fn());/// Using with select:/// use tokio::{pin, select};/// use tokio_stream::{self as stream, StreamExt};///     let mut stream = stream::iter(vec![1, 2, 3, 4]);///         select! {///             _ = &mut future => {///                 // Stop looping `future` will be polled after completion///             Some(val) = stream.next() => {///                 println!("got value = {}", val);/// Because assigning to a variable followed by pinning is common, there is also/// a variant of the macro that supports doing both in one go.///     pin! {///         let future1 = my_async_fn();///         let future2 = my_async_fn();///         _ = &mut future1 => {}///         _ = &mut future2 => {}r" Waits on multiple concurrent branches, returning when the **first** branch"r" completes, cancelling the remaining branches."r" The `select!` macro must be used inside of async functions, closures, and"r" The `select!` macro accepts one or more branches with the following pattern:"r" <pattern> = <async expression> (, if <precondition>)? => <handler>,"r" Additionally, the `select!` macro may include a single, optional `else`"r" branch, which evaluates if none of the other branches match their patterns:"r" else => <expression>"r" The macro aggregates all `<async expression>` expressions and runs them"r" concurrently on the **current** task. Once the **first** expression"r" completes with a value that matches its `<pattern>`, the `select!` macro"r" returns the result of evaluating the completed branch's `<handler>`"r" Additionally, each branch may include an optional `if` precondition. If the"r" precondition returns `false`, then the branch is disabled. The provided"r" `<async expression>` is still evaluated but the resulting future is never"r" polled. This capability is useful when using `select!` within a loop."r" The complete lifecycle of a `select!` expression is as follows:"r" 1. Evaluate all provided `<precondition>` expressions. If the precondition"r"    returns `false`, disable the branch for the remainder of the current call"r#"    to `select!`. Re-entering `select!` due to a loop clears the "disabled""#r"    state."r" 2. Aggregate the `<async expression>`s from each branch, including the"r"    disabled ones. If the branch is disabled, `<async expression>` is still"r"    evaluated, but the resulting future is not polled."r" 3. If **all** branches are disabled: go to step 6."r" 4. Concurrently await on the results for all remaining `<async expression>`s."r" 5. Once an `<async expression>` returns a value, attempt to apply the value to the"r"    provided `<pattern>`. If the pattern matches, evaluate the `<handler>` and return."r"    If the pattern **does not** match, disable the current branch for the remainder of"r"    the current call to `select!`. Continue from step 3."r" 6. Evaluate the `else` expression. If no else expression is provided, panic."r" # Runtime characteristics"r" join handle to `select!`."r" # Fairness"r" By default, `select!` randomly picks a branch to check first. This provides"r" some level of fairness when calling `select!` in a loop with branches that"r" are always ready."r" This behavior can be overridden by adding `biased;` to the beginning of the"r" macro usage. See the examples for details. This will cause `select` to poll"r" the futures in the order they appear from top to bottom. There are a few"r" reasons you may want this:"r" - The random number generation of `tokio::select!` has a non-zero CPU cost"r" - Your futures may interact in a way where known polling order is significant"r" But there is an important caveat to this mode. It becomes your responsibility"r" to ensure that the polling order of your futures is fair. If for example you"r" are selecting between a stream and a shutdown future, and the stream has a"r" huge volume of messages and zero or nearly zero time between them, you should"r" place the shutdown future earlier in the `select!` list to ensure that it is"r" always polled, and will not be ignored due to the stream being constantly"r" ready."r" The `select!` macro panics if all branches are disabled **and** there is no"r" provided `else` branch. A branch is disabled when the provided `if`"r" precondition returns `false` **or** when the pattern does not match the"r" result of `<async expression>`."r" # Cancellation safety"r" When using `select!` in a loop to receive messages from multiple sources,"r" you should make sure that the receive call is cancellation safe to avoid"r" losing messages. This section goes through various common methods and"r" describes whether they are cancel safe.  The lists in this section are not"r" exhaustive."r" The following methods are cancellation safe:"r"  * [`tokio::sync::mpsc::Receiver::recv`](crate::sync::mpsc::Receiver::recv)"r"  * [`tokio::sync::mpsc::UnboundedReceiver::recv`](crate::sync::mpsc::UnboundedReceiver::recv)"r"  * [`tokio::sync::broadcast::Receiver::recv`](crate::sync::broadcast::Receiver::recv)"r"  * [`tokio::sync::watch::Receiver::changed`](crate::sync::watch::Receiver::changed)"r"  * [`tokio::net::TcpListener::accept`](crate::net::TcpListener::accept)"r"  * [`tokio::net::UnixListener::accept`](crate::net::UnixListener::accept)"r"  * [`tokio::signal::unix::Signal::recv`](crate::signal::unix::Signal::recv)"r"  * [`tokio::io::AsyncReadExt::read`](crate::io::AsyncReadExt::read) on any `AsyncRead`"r"  * [`tokio::io::AsyncReadExt::read_buf`](crate::io::AsyncReadExt::read_buf) on any `AsyncRead`"r"  * [`tokio::io::AsyncWriteExt::write`](crate::io::AsyncWriteExt::write) on any `AsyncWrite`"r"  * [`tokio::io::AsyncWriteExt::write_buf`](crate::io::AsyncWriteExt::write_buf) on any `AsyncWrite`"r"  * [`tokio_stream::StreamExt::next`](https://docs.rs/tokio-stream/0.1/tokio_stream/trait.StreamExt.html#method.next) on any `Stream`"r"  * [`futures::stream::StreamExt::next`](https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html#method.next) on any `Stream`"r" The following methods are not cancellation safe and can lead to loss of data:"r"  * [`tokio::io::AsyncReadExt::read_exact`](crate::io::AsyncReadExt::read_exact)"r"  * [`tokio::io::AsyncReadExt::read_to_end`](crate::io::AsyncReadExt::read_to_end)"r"  * [`tokio::io::AsyncReadExt::read_to_string`](crate::io::AsyncReadExt::read_to_string)"r"  * [`tokio::io::AsyncWriteExt::write_all`](crate::io::AsyncWriteExt::write_all)"r" The following methods are not cancellation safe because they use a queue for"r" fairness and cancellation makes you lose your place in the queue:"r"  * [`tokio::sync::Mutex::lock`](crate::sync::Mutex::lock)"r"  * [`tokio::sync::RwLock::read`](crate::sync::RwLock::read)"r"  * [`tokio::sync::RwLock::write`](crate::sync::RwLock::write)"r"  * [`tokio::sync::Semaphore::acquire`](crate::sync::Semaphore::acquire)"r"  * [`tokio::sync::Notify::notified`](crate::sync::Notify::notified)"r" To determine whether your own methods are cancellation safe, look for the"r" location of uses of `.await`. This is because when an asynchronous method is"r" cancelled, that always happens at an `.await`. If your function behaves"r" correctly even if it is restarted while waiting at an `.await`, then it is"r" cancellation safe."r" Cancellation safety can be defined in the following way: If you have a"r" future that has not yet completed, then it must be a no-op to drop that"r" future and recreate it. This definition is motivated by the situation where"r" a `select!` is used in a loop. Without this guarantee, you would lose your"r" progress when another branch completes and you restart the `select!` by"r" going around the loop."r" Be aware that cancelling something that is not cancellation safe is not"r" necessarily wrong. For example, if you are cancelling a task because the"r" application is shutting down, then you probably don't care that partially"r" read data is lost."r" Basic select with two branches."r"     tokio::select! {"r"         _ = do_stuff_async() => {"r#"             println!("do_stuff_async() completed first")"#r"         _ = more_async_work() => {"r#"             println!("more_async_work() completed first")"#r" Basic stream selecting."r" use tokio_stream::{self as stream, StreamExt};"r"     let mut stream1 = stream::iter(vec![1, 2, 3]);"r"     let mut stream2 = stream::iter(vec![4, 5, 6]);"r"     let next = tokio::select! {"r"         v = stream1.next() => v.unwrap(),"r"         v = stream2.next() => v.unwrap(),"r"     assert!(next == 1 || next == 4);"r" Collect the contents of two streams. In this example, we rely on pattern"r#" matching and the fact that `stream::iter` is "fused", i.e. once the stream"#r" is complete, all calls to `next()` return `None`."r"     let mut values = vec![];"r"     loop {"r"         tokio::select! {"r"             Some(v) = stream1.next() => values.push(v),"r"             Some(v) = stream2.next() => values.push(v),"r"             else => break,"r"     values.sort();"r"     assert_eq!(&[1, 2, 3, 4, 5, 6], &values[..]);"r" Using the same future in multiple `select!` expressions can be done by passing"r" a reference to the future. Doing so requires the future to be [`Unpin`]. A"r" future can be made [`Unpin`] by either using [`Box::pin`] or stack pinning."r" [`Unpin`]: std::marker::Unpin"r" [`Box::pin`]: std::boxed::Box::pin"r" Here, a stream is consumed for at most 1 second."r" use tokio::time::{self, Duration};"r"     let mut stream = stream::iter(vec![1, 2, 3]);"r"     let sleep = time::sleep(Duration::from_secs(1));"r"     tokio::pin!(sleep);"r"             maybe_v = stream.next() => {"r"                 if let Some(v) = maybe_v {"r#"                     println!("got = {}", v);"#r"                 } else {"r"                     break;"r"             _ = &mut sleep => {"r#"                 println!("timeout");"#r"                 break;"r" Joining two values using `select!`."r" use tokio::sync::oneshot;"r"     let (tx1, mut rx1) = oneshot::channel();"r"     let (tx2, mut rx2) = oneshot::channel();"r"     tokio::spawn(async move {"r#"         tx1.send("first").unwrap();"#r"     });"r#"         tx2.send("second").unwrap();"#r"     let mut a = None;"r"     let mut b = None;"r"     while a.is_none() || b.is_none() {"r"             v1 = (&mut rx1), if a.is_none() => a = Some(v1.unwrap()),"r"             v2 = (&mut rx2), if b.is_none() => b = Some(v2.unwrap()),"r"     let res = (a.unwrap(), b.unwrap());"r#"     assert_eq!(res.0, "first");"#r#"     assert_eq!(res.1, "second");"#r" Using the `biased;` mode to control polling order."r"     let mut count = 0u8;"r"             // If you run this example without `biased;`, the polling order is"r"             // pseudo-random, and the assertions on the value of count will"r"             // (probably) fail."r"             biased;"r"             _ = async {}, if count < 1 => {"r"                 count += 1;"r"                 assert_eq!(count, 1);"r"             _ = async {}, if count < 2 => {"r"                 assert_eq!(count, 2);"r"             _ = async {}, if count < 3 => {"r"                 assert_eq!(count, 3);"r"             _ = async {}, if count < 4 => {"r"                 assert_eq!(count, 4);"r"             else => {"r"         };"r" ## Avoid racy `if` preconditions"r" Given that `if` preconditions are used to disable `select!` branches, some"r" caution must be used to avoid missing values."r" For example, here is **incorrect** usage of `sleep` with `if`. The objective"r" is to repeatedly run an asynchronous task for up to 50 milliseconds."r" However, there is a potential for the `sleep` completion to be missed."r" ```no_run,should_panic"r" async fn some_async_work() {"r"     // do work"r"     let sleep = time::sleep(Duration::from_millis(50));"r"     while !sleep.is_elapsed() {"r"             _ = &mut sleep, if !sleep.is_elapsed() => {"r#"                 println!("operation timed out");"#r"             _ = some_async_work() => {"r#"                 println!("operation completed");"#r#"     panic!("This example shows how not to do it!");"#r" In the above example, `sleep.is_elapsed()` may return `true` even if"r" `sleep.poll()` never returned `Ready`. This opens up a potential race"r" condition where `sleep` expires between the `while !sleep.is_elapsed()`"r" check and the call to `select!` resulting in the `some_async_work()` call to"r" run uninterrupted despite the sleep having elapsed."r" One way to write the above example without the race would be:"r" # time::sleep(Duration::from_millis(10)).await;"r" # Alternatives from the Ecosystem"r" The `select!` macro is a powerful tool for managing multiple asynchronous"r" branches, enabling tasks to run concurrently within the same thread. However,"r" its use can introduce challenges, particularly around cancellation safety, which"r" can lead to subtle and hard-to-debug errors. For many use cases, ecosystem"r" alternatives may be preferable as they mitigate these concerns by offering"r" clearer syntax, more predictable control flow, and reducing the need to manually"r" handle issues like fuse semantics or cancellation safety."r" ## Merging Streams"r" For cases where `loop { select! { ... } }` is used to poll multiple tasks,"r" stream merging offers a concise alternative, inherently handle cancellation-safe"r" processing, removing the risk of data loss. Libraries such as [`tokio_stream`],"r" [`futures::stream`] and [`futures_concurrency`] provide tools for merging"r" streams and handling their outputs sequentially."r" [`tokio_stream`]: https://docs.rs/tokio-stream/latest/tokio_stream/"r" [`futures::stream`]: https://docs.rs/futures/latest/futures/stream/"r" [`futures_concurrency`]: https://docs.rs/futures-concurrency/latest/futures_concurrency/"r" ### Example with `select!`"r" struct File;"r" struct Channel;"r" struct Socket;"r" impl Socket {"r"     async fn read_packet(&mut self) -> Vec<u8> {"r"         vec![]"r" async fn read_send(_file: &mut File, _channel: &mut Channel) {"r"     // do work that is not cancel safe"r"     // open our IO types"r"     let mut file = File;"r"     let mut channel = Channel;"r"     let mut socket = Socket;"r"             _ = read_send(&mut file, &mut channel) => { /* ... */ },"r"             _data = socket.read_packet() => { /* ... */ }"r"             _ = futures::future::ready(()) => break"r" ### Moving to `merge`"r" By using merge, you can unify multiple asynchronous tasks into a single stream,"r" eliminating the need to manage tasks manually and reducing the risk of"r" unintended behavior like data loss."r" use std::pin::pin;"r" use futures::stream::unfold;"r" use tokio_stream::StreamExt;"r" enum Message {"r"     Stop,"r"     Sent,"r"     Data(Vec<u8>),"r"     let file = File;"r"     let channel = Channel;"r"     let socket = Socket;"r"     let a = unfold((file, channel), |(mut file, mut channel)| async {"r"         read_send(&mut file, &mut channel).await;"r"         Some((Message::Sent, (file, channel)))"r"     let b = unfold(socket, |mut socket| async {"r"         let data = socket.read_packet().await;"r"         Some((Message::Data(data), socket))"r"     let c = tokio_stream::iter([Message::Stop]);"r"     let mut s = pin!(a.merge(b).merge(c));"r"     while let Some(msg) = s.next().await {"r"         match msg {"r"             Message::Data(_data) => { /* ... */ }"r"             Message::Sent => continue,"r"             Message::Stop => break,"r" ## Racing Futures"r" If you need to wait for the first completion among several asynchronous tasks,"r" ecosystem utilities such as"r" [`futures`](https://docs.rs/futures/latest/futures/),"r" [`futures-lite`](https://docs.rs/futures-lite/latest/futures_lite/) or"r" [`futures-concurrency`](https://docs.rs/futures-concurrency/latest/futures_concurrency/)"r" provide streamlined syntax for racing futures:"r" - [`futures_concurrency::future::Race`](https://docs.rs/futures-concurrency/latest/futures_concurrency/future/trait.Race.html)"r" - [`futures::select`](https://docs.rs/futures/latest/futures/macro.select.html)"r" - [`futures::stream::select_all`](https://docs.rs/futures/latest/futures/stream/select_all/index.html) (for streams)"r" - [`futures_lite::future::or`](https://docs.rs/futures-lite/latest/futures_lite/future/fn.or.html)"r" - [`futures_lite::future::race`](https://docs.rs/futures-lite/latest/futures_lite/future/fn.race.html)"r" use futures_concurrency::future::Race;"r#"     let task_a = async { Ok("ok") };"#r#"     let task_b = async { Err("error") };"#r"     let result = (task_a, task_b).race().await;"r"     match result {"r#"         Ok(output) => println!("First task completed with: {output}"),"#r#"         Err(err) => eprintln!("Error occurred: {err}"),"#count_fieldselect_variant// And here... we manually list out matches for up to 64 branches... I'm not// happy about it either, but this is how we manage to use a declarative macro!thread_rng_npoll_budget_availabler" complete with `Ok(_)` or on the first `Err(_)`."r" The `try_join!` macro must be used inside of async functions, closures, and"r" Similar to [`join!`], the `try_join!` macro takes a list of async"r" expressions and evaluates them concurrently on the same task. Each async"r" expression evaluates to a future and the futures from each expression are"r" multiplexed on the current task. The `try_join!` macro returns when **all**"r" branches return with `Ok` or when the **first** branch returns with `Err`."r" [`join!`]: macro@join"r" join handle to `try_join!`."r" Basic `try_join` with two branches."r" async fn do_stuff_async() -> Result<(), &'static str> {"r" async fn more_async_work() -> Result<(), &'static str> {"r"     let res = tokio::try_join!("r"     match res {"r"          Ok((first, second)) => {"r"              // do something with the values"r"          }"r"          Err(err) => {"r#"             println!("processing failed; error = {}", err);"#r" Using `try_join!` with spawned tasks."r" use tokio::task::JoinHandle;"r#" # Err("failed")"#r" async fn flatten<T>(handle: JoinHandle<Result<T, &'static str>>) -> Result<T, &'static str> {"r"     match handle.await {"r"         Ok(Ok(result)) => Ok(result),"r"         Ok(Err(err)) => Err(err),"r#"         Err(err) => Err("handling failed"),"#r"     let handle1 = tokio::spawn(do_stuff_async());"r"     let handle2 = tokio::spawn(more_async_work());"r"     match tokio::try_join!(flatten(handle1), flatten(handle2)) {"r"         Ok(val) => {"r"             // do something with the values"r"         Err(err) => {"r#"             println!("Failed with {}.", err);"#r#"             # assert_eq!(err, "failed");"#ToSocketAddrsPriv/// Converts or resolves without blocking to one or more `SocketAddr` values./// # DNS/// Implementations of `ToSocketAddrs` for string types require a DNS lookup./// # Calling/// Currently, this trait is only used as an argument to Tokio functions that/// need to reference a target socket address. To perform a `SocketAddr`/// conversion directly, use [`lookup_host()`](super::lookup_host())./// This trait is sealed and is intended to be opaque. The details of the trait/// will change. Stabilization is pending enhancements to the Rust language.ReadyFutureMaybeReady//! The contents of this trait are intended to remain private and __not__//! part of the `ToSocketAddrs` public API. The details will change over// ===== impl &impl ToSocketAddrs =====// ===== impl SocketAddr =====// ===== impl SocketAddrV4 =====// ===== impl SocketAddrV6 =====// ===== impl (IpAddr, u16) =====// ===== impl (Ipv4Addr, u16) =====// ===== impl (Ipv6Addr, u16) =====// ===== impl &[SocketAddr] =====r" Performs a DNS resolution."r" The returned iterator may not actually yield any values depending on the"r" outcome of any resolution performed."r" This API is not intended to cover all DNS use cases. Anything beyond the"r" basic use case should be done with a specialized library."r" To resolve a DNS entry:"r" use tokio::net;"r#"     for addr in net::lookup_host("localhost:3000").await? {"#r#"         println!("socket address is {}", addr);"#lookup_hostUnixSocket//! TCP/UDP/Unix bindings for `tokio`.//! This module contains the TCP/UDP/Unix networking types, similar to the standard//! library, which can be used to implement networking protocols.//! * [`TcpListener`] and [`TcpStream`] provide functionality for communication over TCP//! * [`UdpSocket`] provides functionality for communication over UDP//! * [`UnixListener`] and [`UnixStream`] provide functionality for communication over a//! Unix Domain Stream Socket **(available on Unix only)**//! * [`UnixDatagram`] provides functionality for communication//! over Unix Domain Datagram Socket **(available on Unix only)**//! * [`tokio::net::unix::pipe`] for FIFO pipes **(available on Unix only)**//! * [`tokio::net::windows::named_pipe`] for Named Pipes **(available on Windows only)**//! For IO resources not available in `tokio::net`, you can use [`AsyncFd`].//! [`TcpListener`]: TcpListener//! [`TcpStream`]: TcpStream//! [`UdpSocket`]: UdpSocket//! [`UnixListener`]: UnixListener//! [`UnixStream`]: UnixStream//! [`UnixDatagram`]: UnixDatagram//! [`tokio::net::unix::pipe`]: unix::pipe//! [`tokio::net::windows::named_pipe`]: windows::named_pipecheck_socket_for_blockingr" A TCP socket server, listening for connections."r" You can accept a new connection by using the [`accept`](`TcpListener::accept`)"r" A `TcpListener` can be turned into a `Stream` with [`TcpListenerStream`]."r" [`TcpListenerStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.TcpListenerStream.html"r" Note that accepting a connection can lead to various errors and not all"r" of them are necessarily fatal ‒ for example having too many open file"r" descriptors or the other side closing the connection while it waits in"r" an accept queue. These would terminate the stream if not handled in any"r" way."r" Using `accept`:"r" use tokio::net::TcpListener;"r" async fn process_socket<T>(socket: T) {"r"     # drop(socket);"r"     // do work with socket here"r#"     let listener = TcpListener::bind("127.0.0.1:8080").await?;"#r"         let (socket, _) = listener.accept().await?;"r"         process_socket(socket).await;"r" Creates a new `TcpListener`, which will be bound to the specified address."r" The returned listener is ready for accepting connections."r" Binding with a port number of 0 will request that the OS assigns a port"r" to this listener. The port allocated can be queried via the `local_addr`"r" The address type can be any implementor of the [`ToSocketAddrs`] trait."r" If `addr` yields multiple addresses, bind will be attempted with each of"r" the addresses until one succeeds and returns the listener. If none of"r" the addresses succeed in creating a listener, the error returned from"r" the last attempt (the last address) is returned."r" This function sets the `SO_REUSEADDR` option on the socket."r" To configure the socket before binding, you can use the [`TcpSocket`]"r" type."r" [`ToSocketAddrs`]: trait@crate::net::ToSocketAddrs"r" [`TcpSocket`]: struct@crate::net::TcpSocket"r" # if cfg!(miri) { return } // No `socket` in miri."r#"     let listener = TcpListener::bind("127.0.0.1:2345").await?;"#r"     // use the listener"r"     # let _ = listener;"/// Accepts a new incoming connection from this listener./// This function will yield once a new TCP connection is established. When/// established, the corresponding [`TcpStream`] and the remote peer's/// address will be returned./// This method is cancel safe. If the method is used as the event in a/// [`tokio::select!`](crate::select) statement and some other branch/// completes first, then it is guaranteed that no new connections were/// accepted by this method./// [`TcpStream`]: struct@crate::net::TcpStream/// use tokio::net::TcpListener;///     let listener = TcpListener::bind("127.0.0.1:8080").await?;///     match listener.accept().await {///         Ok((_socket, addr)) => println!("new client: {:?}", addr),///         Err(e) => println!("couldn't get client: {:?}", e),/// Polls to accept a new incoming connection to this listener./// If there is no connection to accept, `Poll::Pending` is returned and the/// current task will be notified by a waker.  Note that on multiple calls/// to `poll_accept`, only the `Waker` from the `Context` passed to the most/// Creates new `TcpListener` from a `std::net::TcpListener`./// standard library in the Tokio equivalent./// This API is typically paired with the `socket2` crate and the `Socket`/// type to build up and customize a listener before it's shipped off to the/// backing event loop. This allows configuration of options like/// `SO_REUSEPORT`, binding to multiple addresses, etc./// The caller is responsible for ensuring that the listener is in/// non-blocking mode. Otherwise all I/O operations on the listener/// will block the thread, which will cause unexpected behavior./// Non-blocking mode can be set using [`set_nonblocking`]./// Passing a listener in blocking mode is always erroneous,/// and the behavior in that case may change in the future./// For example, it could panic./// [`set_nonblocking`]: std::net::TcpListener::set_nonblocking///     let std_listener = std::net::TcpListener::bind("127.0.0.1:0")?;///     std_listener.set_nonblocking(true)?;///     let listener = TcpListener::from_std(std_listener)?;/// This function panics if it is not called from within a runtime with/// IO enabled./// Turns a [`tokio::net::TcpListener`] into a [`std::net::TcpListener`]./// The returned [`std::net::TcpListener`] will have nonblocking mode set as/// `true`.  Use [`set_nonblocking`] to change the blocking mode if needed.///     let tokio_listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;///     let std_listener = tokio_listener.into_std()?;///     std_listener.set_nonblocking(false)?;/// [`tokio::net::TcpListener`]: TcpListener/// [`std::net::TcpListener`]: std::net::TcpListener/// [`set_nonblocking`]: fn@std::net::TcpListener::set_nonblocking/// Returns the local address that this listener is bound to./// This can be useful, for example, when binding to port 0 to figure out/// which port was actually bound./// use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};///     assert_eq!(listener.local_addr()?,///                SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));/// [`set_ttl`]: method@Self::set_ttl///    let listener = TcpListener::bind("127.0.0.1:0").await?;///    listener.set_ttl(100).expect("could not set TTL");///    assert_eq!(listener.ttl()?, 100);///     let listener = TcpListener::bind("127.0.0.1:0").await?;///     listener.set_ttl(100).expect("could not set TTL");/// Consumes stream, returning the tokio I/O object./// [`TcpListener::from_std(stream)`](TcpListener::from_std).split_ownedOwnedReadHalfOwnedWriteHalf//! TCP utility types.r" A TCP socket that has not yet been converted to a `TcpStream` or"r" `TcpListener`."r" `TcpSocket` wraps an operating system socket and enables the caller to"r" configure the socket before establishing a TCP connection or accepting"r" inbound connections. The caller is able to set socket option and explicitly"r" bind the socket with a socket address."r" The underlying socket is closed when the `TcpSocket` value is dropped."r" `TcpSocket` should only be used directly if the default configuration used"r" by `TcpStream::connect` and `TcpListener::bind` does not meet the required"r" use case."r#" Calling `TcpStream::connect("127.0.0.1:8080")` is equivalent to:"#r" use tokio::net::TcpSocket;"r#"     let addr = "127.0.0.1:8080".parse().unwrap();"#r"     let socket = TcpSocket::new_v4()?;"r"     let stream = socket.connect(addr).await?;"r" # drop(stream);"r#" Calling `TcpListener::bind("127.0.0.1:8080")` is equivalent to:"#r"     // On platforms with Berkeley-derived sockets, this allows to quickly"r"     // rebind a socket, without needing to wait for the OS to clean up the"r"     // previous one."r"     // On Windows, this allows rebinding sockets which are actively in use,"r#"     // which allows "socket hijacking", so we explicitly don't set it here."#r"     // https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse"r"     socket.set_reuseaddr(true)?;"r"     socket.bind(addr)?;"r"     let listener = socket.listen(1024)?;"r" # drop(listener);"r" Setting socket options not explicitly provided by `TcpSocket` may be done by"r" accessing the `RawFd`/`RawSocket` using [`AsRawFd`]/[`AsRawSocket`] and"r" setting the option with a crate like [`socket2`]."r" [`RawFd`]: https://doc.rust-lang.org/std/os/unix/io/type.RawFd.html"r" [`RawSocket`]: https://doc.rust-lang.org/std/os/windows/io/type.RawSocket.html"r" [`AsRawFd`]: https://doc.rust-lang.org/std/os/unix/io/trait.AsRawFd.html"r" [`AsRawSocket`]: https://doc.rust-lang.org/std/os/windows/io/trait.AsRawSocket.html"r" [`socket2`]: https://docs.rs/socket2/"/// Creates a new socket configured for IPv4./// Calls `socket(2)` with `AF_INET` and `SOCK_STREAM`./// On success, the newly created `TcpSocket` is returned. If an error is/// encountered, it is returned instead./// Create a new IPv4 socket and start listening./// use tokio::net::TcpSocket;///     let addr = "127.0.0.1:8080".parse().unwrap();///     let socket = TcpSocket::new_v4()?;///     socket.bind(addr)?;///     let listener = socket.listen(128)?;/// Creates a new socket configured for IPv6./// Calls `socket(2)` with `AF_INET6` and `SOCK_STREAM`./// Create a new IPv6 socket and start listening.///     let addr = "[::1]:8080".parse().unwrap();///     let socket = TcpSocket::new_v6()?;/// Sets value for the `SO_KEEPALIVE` option on this socket./// Gets the value of the `SO_KEEPALIVE` option on this socket./// Allows the socket to bind to an in-use address./// Behavior is platform specific. Refer to the target platform's///     socket.set_reuseaddr(true)?;///     let listener = socket.listen(1024)?;reuseaddr/// Retrieves the value set for `SO_REUSEADDR` on this socket.///     assert!(socket.reuseaddr().unwrap());set_reuseport/// Allows the socket to bind to an in-use port. Only available for unix systems/// (excluding Solaris & Illumos).///     socket.set_reuseport(true)?;reuseport///     assert!(socket.reuseport().unwrap());/// Sets the size of the TCP send buffer on this socket./// On most operating systems, this sets the `SO_SNDBUF` socket option./// Returns the size of the TCP send buffer for this socket./// On most operating systems, this is the value of the `SO_SNDBUF` socket/// Note that if [`set_send_buffer_size`] has been called on this socket/// previously, the value returned by this function may not be the same as/// the argument provided to `set_send_buffer_size`. This is for the/// following reasons:/// * Most operating systems have minimum and maximum allowed sizes for the///   send buffer, and will clamp the provided value if it is below the///   minimum or above the maximum. The minimum and maximum buffer sizes are///   OS-dependent./// * Linux will double the buffer size to account for internal bookkeeping///   data, and returns the doubled value from `getsockopt(2)`. As per `man///   7 socket`:///   > Sets or gets the maximum socket send buffer in bytes. The///   > kernel doubles this value (to allow space for bookkeeping///   > overhead) when it is set using `setsockopt(2)`, and this doubled///   > value is returned by `getsockopt(2)`./// [`set_send_buffer_size`]: #method.set_send_buffer_size/// Sets the size of the TCP receive buffer on this socket./// On most operating systems, this sets the `SO_RCVBUF` socket option./// Returns the size of the TCP receive buffer for this socket./// On most operating systems, this is the value of the `SO_RCVBUF` socket/// Note that if [`set_recv_buffer_size`] has been called on this socket///   receive buffer, and will clamp the provided value if it is below the/// [`set_recv_buffer_size`]: #method.set_recv_buffer_size/// Sets the linger duration of this socket by setting the `SO_LINGER` option./// This option controls the action taken when a stream has unsent messages and the stream is/// closed. If `SO_LINGER` is set, the system shall block the process until it can transmit the/// data or until the time expires./// If `SO_LINGER` is not specified, and the socket is closed, the system handles the call in a/// way that allows the process to continue as quickly as possible./// Reads the linger duration for this socket by getting the `SO_LINGER`/// [`set_linger`]: TcpSocket::set_linger/// If set, this option disables the Nagle algorithm. This means that segments are always/// sent as soon as possible, even if there is only a small amount of data. When not set,/// data is buffered until there is a sufficient amount to send out, thereby avoiding/// the frequent sending of small packets./// # async fn dox() -> Result<(), Box<dyn std::error::Error>> {/// let socket = TcpSocket::new_v4()?;/// socket.set_nodelay(true)?;/// [`set_nodelay`]: TcpSocket::set_nodelay/// println!("{:?}", socket.nodelay()?);/// Gets the value of the `IP_TOS` option for this socket./// **NOTE:** On Windows, `IP_TOS` is only supported on [Windows 8+ or/// Windows Server 2012+.](https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options)/// [`set_tos`]: Self::set_tos// https://docs.rs/socket2/0.5.3/src/socket2/socket.rs.html#1464/// Sets the value for the `IP_TOS` option on this socket.// https://docs.rs/socket2/0.5.3/src/socket2/socket.rs.html#1446/// Gets the value for the `SO_BINDTODEVICE` option on this socket/// Sets the value for the `SO_BINDTODEVICE` option on this socket/// Gets the local address of this socket./// Will fail on windows if called before `bind`.///     assert_eq!(socket.local_addr().unwrap().to_string(), "127.0.0.1:8080");/// Binds the socket to the given address./// This calls the `bind(2)` operating-system function. Behavior is/// platform specific. Refer to the target platform's documentation for more/// Bind a socket before listening./// Establishes a TCP connection with a peer at the specified socket address./// The `TcpSocket` is consumed. Once the connection is established, a/// connected [`TcpStream`] is returned. If the connection fails, the/// encountered error is returned./// [`TcpStream`]: TcpStream/// This calls the `connect(2)` operating-system function. Behavior is/// Connecting to a peer.///     let stream = socket.connect(addr).await?;/// # drop(stream);/// Converts the socket into a `TcpListener`./// `backlog` defines the maximum number of pending connections are queued/// by the operating system at any given time. Connection are removed from/// the queue with [`TcpListener::accept`]. When the queue is full, the/// operating-system will start rejecting connections./// [`TcpListener::accept`]: TcpListener::accept/// This calls the `listen(2)` operating-system function, marking the socket/// as a passive socket. Behavior is platform specific. Refer to the target/// platform's documentation for more details./// Create a `TcpListener`.from_std_stream/// Converts a [`std::net::TcpStream`] into a `TcpSocket`. The provided/// socket must not have been connected prior to calling this function. This/// function is typically used together with crates such as [`socket2`] to/// configure socket options that are not available on `TcpSocket`./// [`std::net::TcpStream`]: struct@std::net::TcpStream/// [`socket2`]: https://docs.rs/socket2//// non-blocking mode. Otherwise all I/O operations on the socket/// [`set_nonblocking`]: std::net::TcpStream::set_nonblocking/// # if cfg!(miri) { return } // No `socket` in miri.///     let socket2_socket = Socket::new(Domain::IPV4, Type::STREAM, None)?;///     socket2_socket.set_nonblocking(true)?;///     let socket = TcpSocket::from_std_stream(socket2_socket.into());r" Converts a `RawFd` to a `TcpSocket`."r" The caller is responsible for ensuring that the socket is in"r" non-blocking mode."// These trait implementations can't be build on Windows, so we completely// ignore them, even when building documentation./// Borrowed read half of a [`TcpStream`], created by [`split`]./// Reading from a `ReadHalf` is usually done using the convenience methods found on the/// [`AsyncReadExt`] trait./// [`split`]: TcpStream::split()/// Borrowed write half of a [`TcpStream`], created by [`split`]./// Note that in the [`AsyncWrite`] implementation of this type, [`poll_shutdown`] will/// shut down the TCP stream in the write direction./// Writing to an `WriteHalf` is usually done using the convenience methods found/// on the [`AsyncWriteExt`] trait./// [`poll_shutdown`]: fn@crate::io::AsyncWrite::poll_shutdown/// Attempts to receive data on the socket, without removing that data from/// the queue, registering the current task for wakeup if data is not yet/// Note that on multiple calls to `poll_peek` or `poll_read`, only the/// `Waker` from the `Context` passed to the most recent call is scheduled/// to receive a wakeup./// See the [`TcpStream::poll_peek`] level documentation for more details./// use tokio::io::{self, ReadBuf};/// use tokio::net::TcpStream;/// use std::future::poll_fn;///     let mut stream = TcpStream::connect("127.0.0.1:8000").await?;///     let (mut read_half, _) = stream.split();///     let mut buf = [0; 10];///     let mut buf = ReadBuf::new(&mut buf);///     poll_fn(|cx| {///         read_half.poll_peek(cx, &mut buf)///     }).await?;/// [`TcpStream::poll_peek`]: TcpStream::poll_peek/// See the [`TcpStream::peek`] level documentation for more details./// [`TcpStream::peek`]: TcpStream::peek///     // Connect to a peer///     let mut stream = TcpStream::connect("127.0.0.1:8080").await?;///     let mut b1 = [0; 10];///     let mut b2 = [0; 10];///     // Peek at the data///     let n = read_half.peek(&mut b1).await?;///     // Read the data///     assert_eq!(n, read_half.read(&mut b2[..n]).await?);///     assert_eq!(&b1[..n], &b2[..n]);/// The [`read`] method is defined on the [`AsyncReadExt`] trait./// [`read`]: fn@crate::io::AsyncReadExt::read/// Waits for any of the requested ready states./// This function is usually paired with [`try_read()`]. It can be used instead/// of [`readable()`] to check the returned ready set for [`Ready::READABLE`]/// and [`Ready::READ_CLOSED`] events./// The function may complete without the socket being ready. This is a/// This function is equivalent to [`TcpStream::ready`]./// [`try_read()`]: Self::try_read/// [`readable()`]: Self::readable/// Waits for the socket to become readable./// This function is equivalent to `ready(Interest::READABLE)` and is usually/// paired with `try_read()`./// This function is also equivalent to [`TcpStream::ready`]./// consumed by an attempt to read that fails with `WouldBlock` or/// Tries to read data from the stream into the provided buffer, returning how/// many bytes were read./// Receives any pending data from the socket but does not wait for new data/// to arrive. On success, returns the number of bytes read. Because/// `try_read()` is non-blocking, the buffer does not have to be stored by/// the async task and can exist entirely on the stack./// Usually, [`readable()`] or [`ready()`] is used with this function./// [`readable()`]: Self::readable()/// [`ready()`]: Self::ready()/// If data is successfully read, `Ok(n)` is returned, where `n` is the/// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios:/// 1. The stream's read half is closed and will no longer yield data./// 2. The specified buffer was 0 bytes in length./// If the stream is not ready to read data,/// `Err(io::ErrorKind::WouldBlock)` is returned.try_read_vectored/// Tries to read data from the stream into the provided buffers, returning/// how many bytes were read./// Data is copied to fill each buffer in order, with the final buffer/// written to possibly being only partially filled. This method behaves/// equivalently to a single call to [`try_read()`] with concatenated/// buffers./// `try_read_vectored()` is non-blocking, the buffer does not have to be/// stored by the async task and can exist entirely on the stack./// [`try_read()`]: Self::try_read()/// number of bytes read. `Ok(0)` indicates the stream's read half is closed/// and will no longer yield data. If the stream is not ready to read datar" Tries to read data from the stream into the provided buffer, advancing the"r" buffer's internal cursor, returning how many bytes were read."r" Receives any pending data from the socket but does not wait for new data"r" to arrive. On success, returns the number of bytes read. Because"r" `try_read_buf()` is non-blocking, the buffer does not have to be stored by"r" the async task and can exist entirely on the stack."r" Usually, [`readable()`] or [`ready()`] is used with this function."r" [`readable()`]: Self::readable()"r" [`ready()`]: Self::ready()"r" If data is successfully read, `Ok(n)` is returned, where `n` is the"r" number of bytes read. `Ok(0)` indicates the stream's read half is closed"r" and will no longer yield data. If the stream is not ready to read data"r" `Err(io::ErrorKind::WouldBlock)` is returned."try_read_buf/// Returns the remote address that this stream is connected to./// Returns the local address that this stream is bound to./// This function is usually paired with [`try_write()`]. It can be used instead/// of [`writable()`] to check the returned ready set for [`Ready::WRITABLE`]/// and [`Ready::WRITE_CLOSED`] events./// [`try_write()`]: Self::try_write/// [`writable()`]: Self::writable/// Waits for the socket to become writable./// This function is equivalent to `ready(Interest::WRITABLE)` and is usually/// paired with `try_write()`./// consumed by an attempt to write that fails with `WouldBlock` or/// Tries to write a buffer to the stream, returning how many bytes were/// The function will attempt to write the entire contents of `buf`, but/// only part of the buffer may be written./// This function is usually paired with `writable()`./// If data is successfully written, `Ok(n)` is returned, where `n` is the/// number of bytes written. If the stream is not ready to write data,try_write_vectored/// Tries to write several buffers to the stream, returning how many bytes/// were written./// Data is written from each buffer in order, with the final buffer read/// from possible being only partially consumed. This method behaves/// equivalently to a single call to [`try_write()`] with concatenated/// [`try_write()`]: Self::try_write()// `poll_shutdown` on a write half shutdowns the stream in the "write" direction.//! `TcpStream` split support.//! A `TcpStream` can be split into a `ReadHalf` and a//! `WriteHalf` with the `TcpStream::split` method. `ReadHalf`//! implements `AsyncRead` while `WriteHalf` implements `AsyncWrite`.//! Compared to the generic split of `AsyncRead + AsyncWrite`, this specialized//! split has no associated overhead and enforces all invariants at the type//! level./// Owned read half of a [`TcpStream`], created by [`into_split`]./// Reading from an `OwnedReadHalf` is usually done using the convenience methods found/// on the [`AsyncReadExt`] trait./// [`into_split`]: TcpStream::into_split()shutdown_on_drop/// Owned write half of a [`TcpStream`], created by [`into_split`]./// shut down the TCP stream in the write direction.  Dropping the write half/// will also shut down the write half of the TCP stream./// Writing to an `OwnedWriteHalf` is usually done using the convenience methods found/// Error indicating that two halves were not from the same socket, and thus could/// not be reunited./// Attempts to put the two halves of a `TcpStream` back together and/// recover the original socket. Succeeds only if the two halves/// originated from the same call to [`into_split`]./// Attempt to receive data on the socket, without removing that data from///     let stream = TcpStream::connect("127.0.0.1:8000").await?;///     let (mut read_half, _) = stream.into_split();///     let stream = TcpStream::connect("127.0.0.1:8080").await?;/// Destroys the write half, but don't close the write half of the stream/// until the read half is dropped. If the read half has already been/// dropped, this closes the stream.//! `TcpStream` owned split support.//! A `TcpStream` can be split into an `OwnedReadHalf` and a `OwnedWriteHalf`//! with the `TcpStream::into_split` method.  `OwnedReadHalf` implements//! `AsyncRead` while `OwnedWriteHalf` implements `AsyncWrite`.r" A TCP stream between a local and a remote socket."r" A TCP stream can either be created by connecting to an endpoint, via the"r" [`connect`] method, or by [accepting] a connection from a [listener]. A"r" TCP stream can also be created via the [`TcpSocket`] type."r" Reading and writing to a `TcpStream` is usually done using the"r" convenience methods found on the [`AsyncReadExt`] and [`AsyncWriteExt`]"r" traits."r" [`connect`]: method@TcpStream::connect"r" [accepting]: method@crate::net::TcpListener::accept"r" [listener]: struct@crate::net::TcpListener"r" [`AsyncReadExt`]: trait@crate::io::AsyncReadExt"r" [`AsyncWriteExt`]: trait@crate::io::AsyncWriteExt"r" use tokio::net::TcpStream;"r" use tokio::io::AsyncWriteExt;"r" use std::error::Error;"r" async fn main() -> Result<(), Box<dyn Error>> {"r"     // Connect to a peer"r#"     let mut stream = TcpStream::connect("127.0.0.1:8080").await?;"#r"     // Write some data."r#"     stream.write_all(b"hello world!").await?;"#r" The [`write_all`] method is defined on the [`AsyncWriteExt`] trait."r" [`write_all`]: fn@crate::io::AsyncWriteExt::write_all"r" To shut down the stream in the write direction, you can call the"r" [`shutdown()`] method. This will cause the other peer to receive a read of"r" length 0, indicating that no more data will be sent. This only closes"r" the stream in one direction."r" [`shutdown()`]: fn@crate::io::AsyncWriteExt::shutdown"r" Opens a TCP connection to a remote host."r" `addr` is an address of the remote host. Anything which implements the"r" [`ToSocketAddrs`] trait can be supplied as the address.  If `addr`"r" yields multiple addresses, connect will be attempted with each of the"r" addresses until a connection is successful. If none of the addresses"r" result in a successful connection, the error returned from the last"r" connection attempt (the last address) is returned."r" To configure the socket before connecting, you can use the [`TcpSocket`]"r" Establishes a connection to the specified `addr`."connect_mio/// Creates new `TcpStream` from a `std::net::TcpStream`./// The caller is responsible for ensuring that the stream is in/// non-blocking mode. Otherwise all I/O operations on the stream///     let std_stream = std::net::TcpStream::connect("127.0.0.1:34254")?;///     std_stream.set_nonblocking(true)?;///     let stream = TcpStream::from_std(std_stream)?;/// Turns a [`tokio::net::TcpStream`] into a [`std::net::TcpStream`]./// The returned [`std::net::TcpStream`] will have nonblocking mode set as `true`./// Use [`set_nonblocking`] to change the blocking mode if needed./// # use tokio::net::TcpStream;/// # use tokio::io::AsyncWriteExt;///     let mut data = [0u8; 12];/// #   if false {///     let listener = TcpListener::bind("127.0.0.1:34254").await?;/// #   let listener = TcpListener::bind("127.0.0.1:0").await?;/// #   let addr = listener.local_addr().unwrap();/// #   let handle = tokio::spawn(async move {/// #       let mut stream: TcpStream = TcpStream::connect(addr).await.unwrap();/// #       stream.write_all(b"Hello world!").await.unwrap();/// #   });///     let (tokio_tcp_stream, _) = listener.accept().await?;///     let mut std_tcp_stream = tokio_tcp_stream.into_std()?;/// #   handle.await.expect("The task being joined has panicked");///     std_tcp_stream.set_nonblocking(false)?;///     std_tcp_stream.read_exact(&mut data)?;/// #   assert_eq!(b"Hello world!", &data);/// [`tokio::net::TcpStream`]: TcpStream/// [`std::net::TcpStream`]: std::net::TcpStream/// [`set_nonblocking`]: fn@std::net::TcpStream::set_nonblocking/// let stream = TcpStream::connect("127.0.0.1:8080").await?;/// println!("{:?}", stream.local_addr()?);/// println!("{:?}", stream.peer_addr()?);/// Note that on multiple calls to `poll_peek`, `poll_read` or/// `poll_read_ready`, only the `Waker` from the `Context` passed to the/// `poll_write` retains a second, independent waker.)/// The function returns:/// * `Poll::Pending` if data is not yet available./// * `Poll::Ready(Ok(n))` if data is available. `n` is the number of bytes peeked./// * `Poll::Ready(Err(e))` if an error is encountered./// This function may encounter any standard I/O error except `WouldBlock`.///         stream.poll_peek(cx, &mut buf)/// This function is usually paired with `try_read()` or `try_write()`. It/// can be used to concurrently read / write to the same socket on a single/// task without splitting the socket./// Concurrently read and write to the stream on the same task without///         let ready = stream.ready(Interest::READABLE | Interest::WRITABLE).await?;///         if ready.is_readable() {///             match stream.try_read(&mut data) {///         if ready.is_writable() {///             match stream.try_write(b"hello world") {///                     continue///     let mut msg = vec![0; 1024];///         // Wait for the socket to be readable///         stream.readable().await?;///         // Try to read data, this may still fail with `WouldBlock`///         // if the readiness event is a false positive.///         match stream.try_read(&mut msg) {///             Ok(n) => {///                 msg.truncate(n);///             Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {///             Err(e) => {///                 return Err(e.into());///     println!("GOT = {:?}", msg);/// If the tcp stream is not currently ready for reading, this method will/// store a clone of the `Waker` from the provided `Context`. When the tcp/// stream becomes ready for reading, `Waker::wake` will be called on the/// waker./// Note that on multiple calls to `poll_read_ready`, `poll_read` or/// `poll_peek`, only the `Waker` from the `Context` passed to the most/// recent call is scheduled to receive a wakeup. (However,/// `poll_write_ready` retains a second, independent waker.)/// This function is intended for cases where creating and pinning a future/// * `Poll::Pending` if the tcp stream is not ready for reading./// * `Poll::Ready(Ok(()))` if the tcp stream is ready for reading./// [`readable()`]: TcpStream::readable()/// [`ready()`]: TcpStream::ready()///         // Creating the buffer **after** the `await` prevents it from///         // being stored in the async task.///         let mut buf = [0; 4096];///         match stream.try_read(&mut buf) {///             Ok(0) => break,///                 println!("read {} bytes", n);/// [`try_read()`]: TcpStream::try_read()/// use std::io::{self, IoSliceMut};///         let mut buf_a = [0; 512];///         let mut buf_b = [0; 1024];///         let mut bufs = [///             IoSliceMut::new(&mut buf_a),///             IoSliceMut::new(&mut buf_b),///         match stream.try_read_vectored(&mut bufs) {r" [`readable()`]: TcpStream::readable()"r" [`ready()`]: TcpStream::ready()"r#"     let stream = TcpStream::connect("127.0.0.1:8080").await?;"#r"         // Wait for the socket to be readable"r"         stream.readable().await?;"r"         let mut buf = Vec::with_capacity(4096);"r"         // Try to read data, this may still fail with `WouldBlock`"r"         // if the readiness event is a false positive."r"         match stream.try_read_buf(&mut buf) {"r"             Ok(0) => break,"r"             Ok(n) => {"r#"                 println!("read {} bytes", n);"#r"             Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {"r"                 continue;"r"             Err(e) => {"r"                 return Err(e.into());"///         // Wait for the socket to be writable///         stream.writable().await?;///         // Try to write data, this may still fail with `WouldBlock`///         match stream.try_write(b"hello world") {/// If the tcp stream is not currently ready for writing, this method will/// stream becomes ready for writing, `Waker::wake` will be called on the/// Note that on multiple calls to `poll_write_ready` or `poll_write`, only/// the `Waker` from the `Context` passed to the most recent call is/// scheduled to receive a wakeup. (However, `poll_read_ready` retains a/// second, independent waker.)/// * `Poll::Pending` if the tcp stream is not ready for writing./// * `Poll::Ready(Ok(()))` if the tcp stream is ready for writing./// Try to write a buffer to the stream, returning how many bytes were/// from possibly being only partially consumed. This method behaves/// [`try_write()`]: TcpStream::try_write()///     let bufs = [io::IoSlice::new(b"hello "), io::IoSlice::new(b"world")];///         match stream.try_write_vectored(&bufs) {/// Tries to read or write from the socket using a user-provided IO operation./// If the socket is ready, the provided closure is called. The closure/// should attempt to perform IO operation on the socket by manually/// socket is not actually ready, then the closure should return a/// If the socket is not ready, then the closure is not called/// an IO operation on the socket that failed due to the socket not being/// incorrectly clear the readiness flag, which can cause the socket to/// defined on the Tokio `TcpStream` type, as this will mess with the/// readiness flag and can cause the socket to behave incorrectly./// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function./// [`writable()`]: TcpStream::writable()/// Reads or writes from the socket using a user-provided IO operation./// The readiness of the socket is awaited and when the socket is ready,/// the provided closure is called. The closure should attempt to perform/// IO operation on the socket by manually calling the appropriate syscall./// If the operation fails because the socket is not actually ready,/// then the closure should return a `WouldBlock` error. In such case the/// readiness flag is cleared and the socket readiness is awaited again./// This loop is repeated until the closure returns an `Ok` or an error/// other than `WouldBlock`.///     let n = stream.peek(&mut b1).await?;///     assert_eq!(n, stream.read(&mut b2[..n]).await?);shutdown_std/// [`set_nodelay`]: TcpStream::set_nodelay/// println!("{:?}", stream.nodelay()?);/// stream.set_nodelay(true)?;r" Reads the linger duration for this socket by getting the `SO_LINGER`"r" For more information about this option, see [`set_linger`]."r" [`set_linger`]: TcpStream::set_linger"r" # async fn dox() -> Result<(), Box<dyn std::error::Error>> {"r#" let stream = TcpStream::connect("127.0.0.1:8080").await?;"#r#" println!("{:?}", stream.linger()?);"#r" Sets the linger duration of this socket by setting the `SO_LINGER` option."r" This option controls the action taken when a stream has unsent messages and the stream is"r" closed. If `SO_LINGER` is set, the system shall block the process until it can transmit the"r" data or until the time expires."r" If `SO_LINGER` is not specified, and the stream is closed, the system handles the call in a"r" way that allows the process to continue as quickly as possible."r" stream.set_linger(None)?;"/// [`set_ttl`]: TcpStream::set_ttl/// println!("{:?}", stream.ttl()?);/// stream.set_ttl(123)?;// These lifetime markers also appear in the generated documentation, and make// it more clear that this is a *borrowed* split./// Splits a `TcpStream` into a read half and a write half, which can be used/// to read and write the stream concurrently./// This method is more efficient than [`into_split`], but the halves cannot be/// moved into independently spawned tasks.into_split/// Unlike [`split`], the owned halves can be moved to separate tasks, however/// this comes at the cost of a heap allocation./// **Note:** Dropping the write half will shut down the write half of the TCP/// stream. This is equivalent to calling [`shutdown()`] on the `TcpStream`./// [`shutdown()`]: fn@crate::io::AsyncWriteExt::shutdownpoll_read_privpoll_write_privpoll_write_vectored_priv// == Poll IO functions that takes `&self` ==// To read or write without mutable access to the `TcpStream`, combine the// `poll_read_ready` or `poll_write_ready` methods with the `try_read` or// `try_write` methods./// [`TcpStream::from_std(stream)`](TcpStream::from_std).// ===== impl Read / Write =====r" A UDP socket."r#" UDP is "connectionless", unlike TCP. Meaning, regardless of what address you've bound to, a `UdpSocket`"#r" is free to communicate with many different remotes. In tokio there are basically two main ways to use `UdpSocket`:"r" * one to many: [`bind`](`UdpSocket::bind`) and use [`send_to`](`UdpSocket::send_to`)"r"   and [`recv_from`](`UdpSocket::recv_from`) to communicate with many different addresses"r" * one to one: [`connect`](`UdpSocket::connect`) and associate with a single address, using [`send`](`UdpSocket::send`)"r"   and [`recv`](`UdpSocket::recv`) to communicate only with that remote address"r" This type does not provide a `split` method, because this functionality"r" can be achieved by instead wrapping the socket in an [`Arc`]. Note that"r" you do not need a `Mutex` to share the `UdpSocket` — an `Arc<UdpSocket>`"r" is enough. This is because all of the methods take `&self` instead of"r" `&mut self`. Once you have wrapped it in an `Arc`, you can call"r" `.clone()` on the `Arc<UdpSocket>` to get multiple shared handles to the"r" same socket. An example of such usage can be found further down."r" [`Arc`]: std::sync::Arc"r" # Streams"r" If you need to listen over UDP and produce a [`Stream`], you can look"r" at [`UdpFramed`]."r" [`UdpFramed`]: https://docs.rs/tokio-util/latest/tokio_util/udp/struct.UdpFramed.html"r" [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html"r" # Example: one to many (bind)"r" Using `bind` we can create a simple echo server that sends and recv's with many different clients:"r" use tokio::net::UdpSocket;"r#"     let sock = UdpSocket::bind("0.0.0.0:8080").await?;"#r"     let mut buf = [0; 1024];"r"         let (len, addr) = sock.recv_from(&mut buf).await?;"r#"         println!("{:?} bytes received from {:?}", len, addr);"#r"         let len = sock.send_to(&buf[..len], addr).await?;"r#"         println!("{:?} bytes sent", len);"#r" # Example: one to one (connect)"r" Or using `connect` we can echo with a single remote address using `send` and `recv`:"r#"     let remote_addr = "127.0.0.1:59611";"#r"     sock.connect(remote_addr).await?;"r"         let len = sock.recv(&mut buf).await?;"r#"         println!("{:?} bytes received from {:?}", len, remote_addr);"#r"         let len = sock.send(&buf[..len]).await?;"r" # Example: Splitting with `Arc`"r" Because `send_to` and `recv_from` take `&self`. It's perfectly alright"r" to use an `Arc<UdpSocket>` and share the references to multiple tasks."r#" Here is a similar "echo" example that supports concurrent"#r" sending/receiving:"r" use tokio::{net::UdpSocket, sync::mpsc};"r" use std::{io, net::SocketAddr, sync::Arc};"r#"     let sock = UdpSocket::bind("0.0.0.0:8080".parse::<SocketAddr>().unwrap()).await?;"#r"     let r = Arc::new(sock);"r"     let s = r.clone();"r"     let (tx, mut rx) = mpsc::channel::<(Vec<u8>, SocketAddr)>(1_000);"r"         while let Some((bytes, addr)) = rx.recv().await {"r"             let len = s.send_to(&bytes, &addr).await.unwrap();"r#"             println!("{:?} bytes sent", len);"#r"         let (len, addr) = r.recv_from(&mut buf).await?;"r"         tx.send((buf[..len].to_vec(), addr)).await.unwrap();"/// This function will create a new UDP socket and attempt to bind it to/// the `addr` provided./// Binding with a port number of 0 will request that the OS assigns a port/// to this listener. The port allocated can be queried via the `local_addr`/// use tokio::net::UdpSocket;///     let sock = UdpSocket::bind("0.0.0.0:8080").await?;///     // use `sock`/// #   let _ = sock;/// Creates new `UdpSocket` from a previously bound `std::net::UdpSocket`./// This can be used in conjunction with `socket2`'s `Socket` interface to/// configure a socket before it's handed off, such as setting options like/// `reuse_address` or binding to multiple addresses./// [`set_nonblocking`]: std::net::UdpSocket::set_nonblocking/// # use std::{io, net::SocketAddr};/// # async fn main() -> io::Result<()> {/// let addr = "0.0.0.0:8080".parse::<SocketAddr>().unwrap();/// let std_sock = std::net::UdpSocket::bind(addr)?;/// std_sock.set_nonblocking(true)?;/// let sock = UdpSocket::from_std(std_sock)?;/// // use `sock`/// Turns a [`tokio::net::UdpSocket`] into a [`std::net::UdpSocket`]./// The returned [`std::net::UdpSocket`] will have nonblocking mode set as///     let tokio_socket = tokio::net::UdpSocket::bind("127.0.0.1:0").await?;///     let std_socket = tokio_socket.into_std()?;///     std_socket.set_nonblocking(false)?;/// [`tokio::net::UdpSocket`]: UdpSocket/// [`std::net::UdpSocket`]: std::net::UdpSocket/// [`set_nonblocking`]: fn@std::net::UdpSocket::set_nonblocking/// Returns the local address that this socket is bound to./// let sock = UdpSocket::bind(addr).await?;/// // the address the socket is bound to/// let local_addr = sock.local_addr()?;/// let peer = "127.0.0.1:11100".parse::<SocketAddr>().unwrap();/// sock.connect(peer).await?;/// assert_eq!(peer, sock.peer_addr()?);/// Connects the UDP socket setting the default destination for send() and/// limiting packets that are read via `recv` from the address specified in/// `addr`./// let sock = UdpSocket::bind("0.0.0.0:8080".parse::<SocketAddr>().unwrap()).await?;/// let remote_addr = "127.0.0.1:59600".parse::<SocketAddr>().unwrap();/// sock.connect(remote_addr).await?;/// // recv from remote_addr/// let len = sock.recv(&mut buf).await?;/// // send to remote_addr/// let _len = sock.send(&buf[..len]).await?;/// This function is usually paired with `try_recv()` or `try_send()`. It/// can be used to concurrently `recv` / `send` to the same socket on a single/// Concurrently receive from and send to the socket on the same task/// without splitting./// use tokio::io::{self, Interest};///     let socket = UdpSocket::bind("127.0.0.1:8080").await?;///     socket.connect("127.0.0.1:8081").await?;///         let ready = socket.ready(Interest::READABLE | Interest::WRITABLE).await?;///             // The buffer is **not** included in the async task and will only exist///             // on the stack.///             let mut data = [0; 1024];///             match socket.try_recv(&mut data[..]) {///                     println!("received {:?}", &data[..n]);///                 // False-positive, continue///                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}///                     return Err(e);///             // Write some data///             match socket.try_send(b"hello world") {///                     println!("sent {} bytes", n);/// This function is equivalent to `ready(Interest::WRITABLE)` and is/// usually paired with `try_send()` or `try_send_to()`./// The function may complete without the socket being writable. This is a/// false-positive and attempting a `try_send()` will return with/// `io::ErrorKind::WouldBlock`.///     // Bind socket///         socket.writable().await?;///         // Try to send data, this may still fail with `WouldBlock`///         match socket.try_send(b"hello world") {///                 return Err(e);poll_send_ready/// Polls for write/send readiness./// If the udp stream is not currently ready for sending, this method will/// store a clone of the `Waker` from the provided `Context`. When the udp/// stream becomes ready for sending, `Waker::wake` will be called on the/// Note that on multiple calls to `poll_send_ready` or `poll_send`, only/// scheduled to receive a wakeup. (However, `poll_recv_ready` retains a/// * `Poll::Pending` if the udp stream is not ready for writing./// * `Poll::Ready(Ok(()))` if the udp stream is ready for writing./// Sends data on the socket to the remote address that the socket is/// connected to./// [`connect`]: method@Self::connect/// On success, the number of bytes sent is returned, otherwise, the/// This method is cancel safe. If `send` is used as the event in a/// completes first, then it is guaranteed that the message was not sent./// use tokio::io;///     // Send a message///     socket.send(b"hello world").await?;poll_send/// Attempts to send data on the socket to the remote address to which it/// was previously `connect`ed./// Note that on multiple calls to a `poll_*` method in the send direction,/// only the `Waker` from the `Context` passed to the most recent call will/// be scheduled to receive a wakeup./// * `Poll::Pending` if the socket is not available to write/// * `Poll::Ready(Ok(n))` `n` is the number of bytes sent/// Tries to send data on the socket to the remote address to which it is/// When the socket buffer is full, `Err(io::ErrorKind::WouldBlock)` is/// returned. This function is usually paired with `writable()`./// If successful, `Ok(n)` is returned, where `n` is the number of bytes/// sent. If the socket is not ready to send data,/// `Err(ErrorKind::WouldBlock)` is returned.///     // Bind a UDP socket/// paired with `try_recv()`./// The function may complete without the socket being readable. This is a/// false-positive and attempting a `try_recv()` will return with///         socket.readable().await?;///         // The buffer is **not** included in the async task and will///         // only exist on the stack.///         let mut buf = [0; 1024];///         // Try to recv data, this may still fail with `WouldBlock`///         match socket.try_recv(&mut buf) {///                 println!("GOT {:?}", &buf[..n]);poll_recv_ready/// Polls for read/receive readiness./// If the udp stream is not currently ready for receiving, this method will/// socket becomes ready for reading, `Waker::wake` will be called on the/// Note that on multiple calls to `poll_recv_ready`, `poll_recv` or/// `poll_send_ready` retains a second, independent waker.)/// * `Poll::Pending` if the udp stream is not ready for reading./// * `Poll::Ready(Ok(()))` if the udp stream is ready for reading./// Receives a single datagram message on the socket from the remote address/// to which it is connected. On success, returns the number of bytes read./// The function must be called with valid byte array `buf` of sufficient/// size to hold the message bytes. If a message is too long to fit in the/// supplied buffer, excess bytes may be discarded./// This method is cancel safe. If `recv` is used as the event in a/// completes first, it is guaranteed that no messages were received on this/// socket.///     let mut buf = vec![0; 10];///     let n = socket.recv(&mut buf).await?;///     println!("received {} bytes {:?}", n, &buf[..n]);/// Attempts to receive a single datagram message on the socket from the remote/// address to which it is `connect`ed./// The [`connect`] method will connect this socket to a remote address. This method/// resolves to an error if the socket is not connected./// Note that on multiple calls to a `poll_*` method in the `recv` direction, only the/// `Waker` from the `Context` passed to the most recent call will be scheduled to/// * `Poll::Pending` if the socket is not ready to read/// * `Poll::Ready(Ok(()))` reads data `ReadBuf` if the socket is ready/// Tries to receive a single datagram message on the socket from the remote/// address to which it is connected. On success, returns the number of/// bytes read./// This method must be called with valid byte array `buf` of sufficient size/// to hold the message bytes. If a message is too long to fit in the/// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is/// returned. This function is usually paired with `readable()`.r" Tries to receive data from the stream into the provided buffer, advancing the"r" This method must be called with valid byte array `buf` of sufficient size"r" to hold the message bytes. If a message is too long to fit in the"r" supplied buffer, excess bytes may be discarded."r" This method can be used even if `buf` is uninitialized."r" When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is"r" returned. This function is usually paired with `readable()`."r#"     let socket = UdpSocket::bind("127.0.0.1:8080").await?;"#r#"     socket.connect("127.0.0.1:8081").await?;"#r"         socket.readable().await?;"r"         let mut buf = Vec::with_capacity(1024);"r"         // Try to recv data, this may still fail with `WouldBlock`"r"         match socket.try_recv_buf(&mut buf) {"r#"                 println!("GOT {:?}", &buf[..n]);"#r"                 return Err(e);"try_recv_bufr" Receives a single datagram message on the socket from the remote address"r" to which it is connected, advancing the buffer's internal cursor,"r"     let mut buf = Vec::with_capacity(512);"r"     let len = socket.recv_buf(&mut buf).await?;"r#"     println!("received {} bytes {:?}", len, &buf[..len]);"#r" Tries to receive a single datagram message on the socket. On success,"r" returns the number of bytes read and the origin."r" Note that the socket address **cannot** be implicitly trusted, because it is relatively"r" trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]."r" Because UDP is stateless and does not validate the origin of a packet,"r" the attacker does not need to be able to intercept traffic in order to interfere."r" It is important to be aware of this when designing your application-level protocol."r" [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection"r"         match socket.try_recv_buf_from(&mut buf) {"r"             Ok((n, _addr)) => {"try_recv_buf_fromr" Receives a single datagram message on the socket, advancing the"r" buffer's internal cursor, returning how many bytes were read and the origin."r"     let (len, addr) = socket.recv_buf_from(&mut buf).await?;"r#"     println!("received {:?} bytes from {:?}", len, addr);"#recv_buf_from/// Address type can be any implementor of [`ToSocketAddrs`] trait. See its/// It is possible for `addr` to yield multiple addresses, but `send_to`/// will only send data to the first address yielded by `addr`./// This will return an error when the IP version of the local socket does/// not match that returned from [`ToSocketAddrs`]./// [`ToSocketAddrs`]: crate::net::ToSocketAddrs/// This method is cancel safe. If `send_to` is used as the event in a///     let len = socket.send_to(b"hello world", "127.0.0.1:8081").await?;///     println!("Sent {} bytes", len);poll_send_to/// Attempts to send data on the socket to a given address./// Note that on multiple calls to a `poll_*` method in the send direction, only the/// * `Poll::Pending` if the socket is not ready to write/// * `Poll::Ready(Ok(n))` `n` is the number of bytes sent.try_send_to/// Tries to send data on the socket to the given address, but if the send is/// blocked this will return right away./// If successful, returns the number of bytes sent/// Users should ensure that when the remote cannot receive, the/// [`ErrorKind::WouldBlock`] is properly handled. An error can also occur/// if the IP version of the socket does not match that of `target`./// [`ErrorKind::WouldBlock`]: std::io::ErrorKind::WouldBlock///     let dst = "127.0.0.1:8081".parse()?;///         match socket.try_send_to(&b"hello world"[..], dst) {///             Ok(sent) => {///                 println!("sent {} bytes", sent);///                 // Writable false positive.///             Err(e) => return Err(e.into()),send_to_addr/// Receives a single datagram message on the socket. On success, returns/// the number of bytes read and the origin./// This method is cancel safe. If `recv_from` is used as the event in a///     let mut buf = vec![0u8; 32];///     let (len, addr) = socket.recv_from(&mut buf).await?;///     println!("received {:?} bytes from {:?}", len, addr);/// Note that the socket address **cannot** be implicitly trusted, because it is relatively/// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]./// Because UDP is stateless and does not validate the origin of a packet,/// the attacker does not need to be able to intercept traffic in order to interfere./// It is important to be aware of this when designing your application-level protocol./// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injectionpoll_recv_from/// Attempts to receive a single datagram on the socket./// * `Poll::Ready(Ok(addr))` reads data from `addr` into `ReadBuf` if the socket is readytry_recv_from/// Tries to receive a single datagram message on the socket. On success,/// returns the number of bytes read and the origin.///         match socket.try_recv_from(&mut buf) {///             Ok((n, _addr)) => {/// defined on the Tokio `UdpSocket` type, as this will mess with the/// [`readable()`]: UdpSocket::readable()/// [`writable()`]: UdpSocket::writable()/// [`ready()`]: UdpSocket::ready()/// Receives a single datagram from the connected address without removing it from the queue./// On success, returns the number of bytes read from whence the data came./// is filled with the first part of the data, and `peek_from` returns the error/// `WSAEMSGSIZE(10040)`. The excess data is lost./// MacOS will return an error if you pass a zero-sized buffer./// If you're merely interested in learning the sender of the data at the head of the queue,/// try [`peek_sender`].///     let len = socket.peek(&mut buf).await?;///     println!("peeked {:?} bytes", len);/// [`peek_sender`]: method@Self::peek_sender/// Receives data from the connected address, without removing it from the input queue./// On success, returns the sending address of the datagram./// receive a wakeup/// try [`poll_peek_sender`]./// * `Poll::Ready(Ok(()))` reads data into `ReadBuf` if the socket is ready/// [`poll_peek_sender`]: method@Self::poll_peek_sendertry_peek/// Tries to receive data on the connected address without removing it from the input queue./// try [`try_peek_sender`]./// [`try_peek_sender`]: method@Self::try_peek_sender///     let (len, addr) = socket.peek_from(&mut buf).await?;///     println!("peeked {:?} bytes from {:?}", len, addr);poll_peek_fromtry_peek_from/// Tries to receive data on the socket without removing it from the input queue./// On success, returns the number of bytes read and the sending address of the/// datagram./// Retrieve the sender of the data at the head of the input queue, waiting if empty./// but suppresses the `WSAEMSGSIZE` error on Windows and the "invalid argument" error on macOS./// [`peek_from`]: method@Self::peek_frompoll_peek_sender/// Retrieve the sender of the data at the head of the input queue,/// scheduling a wakeup if empty./// This is equivalent to calling [`poll_peek_from`] with a zero-sized buffer,/// [`poll_peek_from`]: method@Self::poll_peek_fromtry_peek_sender/// Try to retrieve the sender of the data at the head of the input queue.peek_sender_inner/// [`set_broadcast`]: method@Self::set_broadcast/// [`set_multicast_loop_v4`]: method@Self::set_multicast_loop_v4/// This may not have any affect on IPv6 sockets./// [`set_multicast_ttl_v4`]: method@Self::set_multicast_ttl_v4/// [`set_multicast_loop_v6`]: method@Self::set_multicast_loop_v6/// This may not have any affect on IPv4 sockets./// # async fn dox() -> io::Result<()> {/// let sock = UdpSocket::bind("127.0.0.1:8080").await?;/// println!("{:?}", sock.ttl()?);/// sock.set_ttl(60)?;/// This value gets the socket-bound device's interface name./// [`join_multicast_v4`]: method@Self::join_multicast_v4/// [`join_multicast_v6`]: method@Self::join_multicast_v6///     // Create a socket///     let socket = UdpSocket::bind("0.0.0.0:8080").await?;///     if let Ok(Some(err)) = socket.take_error() {///         println!("Got error: {:?}", err);/// [`UdpSocket::from_std(stream)`](UdpSocket::from_std).//! Unix datagram types.r" An I/O object representing a Unix datagram socket."r" A socket can be either named (associated with a filesystem path) or"r" unnamed."r" can be achieved by wrapping the socket in an [`Arc`]. Note that you do"r" not need a `Mutex` to share the `UnixDatagram` — an `Arc<UnixDatagram>`"r" `&mut self`."r" **Note:** named sockets are persisted even after the object is dropped"r" and the program has exited, and cannot be reconnected. It is advised"r" that you either check for and unlink the existing socket if it exists,"r" or use a temporary file that is guaranteed to not already exist."r" Using named sockets, associated with a filesystem path:"r" # async fn main() -> Result<(), Box<dyn Error>> {"r" use tokio::net::UnixDatagram;"r" // We use a temporary directory so that the socket"r" // files left by the bound sockets will get cleaned up."r" let tmp = tempdir()?;"r" // Bind each socket to a filesystem path"r#" let tx_path = tmp.path().join("tx");"#r" let tx = UnixDatagram::bind(&tx_path)?;"r#" let rx_path = tmp.path().join("rx");"#r" let rx = UnixDatagram::bind(&rx_path)?;"r#" let bytes = b"hello world";"#r" tx.send_to(bytes, &rx_path).await?;"r" let mut buf = vec![0u8; 24];"r" let (size, addr) = rx.recv_from(&mut buf).await?;"r" let dgram = &buf[..size];"r" assert_eq!(dgram, bytes);"r" assert_eq!(addr.as_pathname().unwrap(), &tx_path);"r" Using unnamed sockets, created as a pair"r" # if cfg!(miri) { return } // No SOCK_DGRAM for `socketpair` in miri."r" // Create the pair of sockets"r" let (sock1, sock2) = UnixDatagram::pair()?;"r" // Since the sockets are paired, the paired send/recv"r" // functions can be used"r" sock1.send(bytes).await?;"r" let mut buff = vec![0u8; 24];"r" let size = sock2.recv(&mut buff).await?;"r" let dgram = &buff[..size];"/// use tokio::net::UnixDatagram;///     let dir = tempfile::tempdir().unwrap();///     let client_path = dir.path().join("client.sock");///     let server_path = dir.path().join("server.sock");///     let socket = UnixDatagram::bind(&client_path)?;///     socket.connect(&server_path)?;/// If the socket is not currently ready for sending, this method will/// store a clone of the `Waker` from the provided `Context`. When the socket/// becomes ready for sending, `Waker::wake` will be called on the/// * `Poll::Pending` if the socket is not ready for writing./// * `Poll::Ready(Ok(()))` if the socket is ready for writing./// If the socket is not currently ready for receiving, this method will/// store a clone of the `Waker` from the provided `Context`. When the/// * `Poll::Pending` if the socket is not ready for reading./// * `Poll::Ready(Ok(()))` if the socket is ready for reading./// Creates a new `UnixDatagram` bound to the specified path./// # async fn main() -> Result<(), Box<dyn Error>> {/// // We use a temporary directory so that the socket/// // files left by the bound sockets will get cleaned up./// let tmp = tempdir()?;/// // Bind the socket to a filesystem path/// let socket_path = tmp.path().join("socket");/// let socket = UnixDatagram::bind(&socket_path)?;/// This function will create a pair of interconnected Unix sockets for/// communicating back and forth between one another./// # if cfg!(miri) { return } // No SOCK_DGRAM for `socketpair` in miri./// // Create the pair of sockets/// let (sock1, sock2) = UnixDatagram::pair()?;/// // Since the sockets are paired, the paired send/recv/// // functions can be used/// let bytes = b"hail eris";/// sock1.send(bytes).await?;/// let mut buff = vec![0u8; 24];/// let size = sock2.recv(&mut buff).await?;/// let dgram = &buff[..size];/// assert_eq!(dgram, bytes);/// Creates new [`UnixDatagram`] from a [`std::os::unix::net::UnixDatagram`]./// This function is intended to be used to wrap a `UnixDatagram` from the/// [`set_nonblocking`]: std::os::unix::net::UnixDatagram::set_nonblocking/// from a future driven by a Tokio runtime, otherwise runtime can be set/// use std::os::unix::net::UnixDatagram as StdUDS;/// let std_socket = StdUDS::bind(&socket_path)?;/// std_socket.set_nonblocking(true)?;/// let tokio_socket = UnixDatagram::from_std(std_socket)?;/// Turns a [`tokio::net::UnixDatagram`] into a [`std::os::unix::net::UnixDatagram`]./// The returned [`std::os::unix::net::UnixDatagram`] will have nonblocking/// mode set as `true`. Use [`set_nonblocking`] to change the blocking mode/// # async fn dox() -> Result<(), Box<dyn Error>> {/// let tokio_socket = tokio::net::UnixDatagram::bind("/path/to/the/socket")?;/// let std_socket = tokio_socket.into_std()?;/// std_socket.set_nonblocking(false)?;/// [`tokio::net::UnixDatagram`]: UnixDatagram/// [`std::os::unix::net::UnixDatagram`]: std::os::unix::net::UnixDatagram/// [`set_nonblocking`]: fn@std::os::unix::net::UnixDatagram::set_nonblocking/// Creates a new `UnixDatagram` which is not bound to any address./// // Create an unbound socket/// let tx = UnixDatagram::unbound()?;/// // Create another, bound socket/// let rx_path = tmp.path().join("rx");/// let rx = UnixDatagram::bind(&rx_path)?;/// // Send to the bound socket/// let bytes = b"hello world";/// tx.send_to(bytes, &rx_path).await?;/// let mut buf = vec![0u8; 24];/// let (size, addr) = rx.recv_from(&mut buf).await?;/// let dgram = &buf[..size];/// The `send` method may be used to send data to the specified address./// `recv` and `recv_from` will only receive data from that address./// // Connect to the bound socket/// tx.connect(&rx_path)?;/// tx.send(bytes).await?;/// Tries to send a datagram to the peer without waiting.///         match socket.try_send_to(b"hello world", &server_path) {/// Tries to receive a datagram from the peer without waiting.r" Tries to receive data from the socket without waiting."r"     let dir = tempfile::tempdir().unwrap();"r#"     let client_path = dir.path().join("client.sock");"#r#"     let server_path = dir.path().join("server.sock");"#r"     let socket = UnixDatagram::bind(&client_path)?;"r" Receives from the socket, advances the"r" buffer's internal cursor and returns how many bytes were read and the origin."r" let mut buf = Vec::with_capacity(24);"r" let (size, addr) = rx.recv_buf_from(&mut buf).await?;"r"     socket.connect(&server_path)?;"r" Receives data from the socket from the address to which it is connected,"r" advancing the buffer's internal cursor, returning how many bytes were read."r" let mut buff = Vec::with_capacity(24);"r" let size = sock2.recv_buf(&mut buff).await?;"/// // Bind each socket to a filesystem path/// let tx_path = tmp.path().join("tx");/// let tx = UnixDatagram::bind(&tx_path)?;/// assert_eq!(addr.as_pathname().unwrap(), &tx_path);/// Attempts to receive a single datagram on the specified address./// Attempts to send data to the specified address./// Tries to receive data from the socket without waiting./// defined on the Tokio `UnixDatagram` type, as this will mess with the/// [`readable()`]: UnixDatagram::readable()/// [`writable()`]: UnixDatagram::writable()/// [`ready()`]: UnixDatagram::ready()/// For a socket bound to a local path/// // Bind socket to a filesystem path/// assert_eq!(socket.local_addr()?.as_pathname().unwrap(), &socket_path);/// For an unbound socket/// let socket = UnixDatagram::unbound()?;/// assert!(socket.local_addr()?.is_unnamed());/// For a peer with a local path/// assert_eq!(tx.peer_addr()?.as_pathname().unwrap(), &rx_path);/// For an unbound peer/// assert!(sock1.peer_addr()?.is_unnamed());/// if let Ok(Some(err)) = socket.take_error() {///     println!("Got error: {:?}", err);/// use std::net::Shutdown;/// let (socket, other) = UnixDatagram::pair()?;/// socket.shutdown(Shutdown::Both)?;/// // NOTE: the following commented out code does NOT work as expected./// // Due to an underlying issue, the recv call will block indefinitely./// // See: https://github.com/tokio-rs/tokio/issues/1679/// //let mut buff = vec![0u8; 24];/// //let size = socket.recv(&mut buff).await?;/// //assert_eq!(size, 0);/// let send_result = socket.send(b"hello world").await;/// assert!(send_result.is_err());/// Consumes stream, returning the Tokio I/O object./// [`UnixDatagram::from_std(stream)`](UnixDatagram::from_std).StdSocketAddrr" A Unix socket which can accept connections from other Unix sockets."r" You can accept a new connection by using the [`accept`](`UnixListener::accept`) method."r" A `UnixListener` can be turned into a `Stream` with [`UnixListenerStream`]."r" [`UnixListenerStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.UnixListenerStream.html"r" use tokio::net::UnixListener;"r#"     let listener = UnixListener::bind("/path/to/the/socket").unwrap();"#r"         match listener.accept().await {"r"             Ok((stream, _addr)) => {"r#"                 println!("new client!");"#r"             Err(e) => { /* connection failed */ }"/// Creates a new `UnixListener` bound to the specified path./// Creates new [`UnixListener`] from a [`std::os::unix::net::UnixListener`]./// This function is intended to be used to wrap a `UnixListener` from the/// [`set_nonblocking`]: std::os::unix::net::UnixListener::set_nonblocking/// use tokio::net::UnixListener;/// use std::os::unix::net::UnixListener as StdUnixListener;/// let std_listener = StdUnixListener::bind("/path/to/the/socket")?;/// std_listener.set_nonblocking(true)?;/// let listener = UnixListener::from_std(std_listener)?;/// Turns a [`tokio::net::UnixListener`] into a [`std::os::unix::net::UnixListener`]./// The returned [`std::os::unix::net::UnixListener`] will have nonblocking mode/// set as `true`. Use [`set_nonblocking`] to change the blocking mode if needed./// let tokio_listener = tokio::net::UnixListener::bind("/path/to/the/socket")?;/// let std_listener = tokio_listener.into_std()?;/// std_listener.set_nonblocking(false)?;/// [`tokio::net::UnixListener`]: UnixListener/// [`std::os::unix::net::UnixListener`]: std::os::unix::net::UnixListener/// [`set_nonblocking`]: fn@std::os::unix::net::UnixListener::set_nonblocking/// [`UnixListener::from_std(stream)`](UnixListener::from_std).// This module does not currently provide any public API, but it was// unintentionally defined as a public module. Hide it from the documentation// instead of changing it to a private module to avoid breakage./// A type representing user ID./// A type representing group ID./// A type representing process and process group IDs.//! Unix specific network types.mio_pipe/// Creates a new anonymous Unix pipe./// This function will open a new pipe and associate both pipe ends with the default/// event loop./// If you need to create a pipe for communication with a spawned process, you can/// use [`Stdio::piped()`] instead./// [`Stdio::piped()`]: std::process::Stdio::piped/// If creating a pipe fails, this function will return with the related OS error./// Create a pipe and pass the writing end to a spawned process./// use tokio::net::unix::pipe;/// use tokio::process::Command;/// # use tokio::io::AsyncReadExt;/// let (tx, mut rx) = pipe::pipe()?;/// let status = Command::new("echo")///     .stdout(tx.into_blocking_fd()?)///     .status();/// rx.read_to_string(&mut buffer).await?;/// assert!(status.await?.success());/// assert_eq!(buffer, "Hello, world!\n");/// Options and flags which can be used to configure how a FIFO file is opened./// This builder allows configuring how to create a pipe end from a FIFO file./// then chain calls to methods to set each option, then call either/// [`open_receiver`] or [`open_sender`], passing the path of the FIFO file you/// are trying to open. This will give you a [`io::Result`] with a pipe end/// inside that you can further operate on./// [`open_receiver`]: OpenOptions::open_receiver/// [`open_sender`]: OpenOptions::open_sender/// Opening a pair of pipe ends from a FIFO file:/// const FIFO_NAME: &str = "path/to/a/fifo";/// let rx = pipe::OpenOptions::new().open_receiver(FIFO_NAME)?;/// let tx = pipe::OpenOptions::new().open_sender(FIFO_NAME)?;/// Opening a [`Sender`] on Linux when you are sure the file is a FIFO:/// use nix::{unistd::mkfifo, sys::stat::Mode};/// // Our program has exclusive access to this path./// const FIFO_NAME: &str = "path/to/a/new/fifo";/// mkfifo(FIFO_NAME, Mode::S_IRWXU)?;/// let tx = pipe::OpenOptions::new()///     .read_write(true)///     .unchecked(true)///     .open_sender(FIFO_NAME)?;/// Sets the option for read-write access./// This option, when true, will indicate that a FIFO file will be opened/// in read-write access mode. This operation is not defined by the POSIX/// standard and is only guaranteed to work on Linux./// Opening a [`Sender`] even if there are no open reading ends:///     .open_sender("path/to/a/fifo");/// Opening a resilient [`Receiver`] i.e. a reading pipe end which will not/// fail with [`UnexpectedEof`] during reading if all writing ends of the/// pipe close the FIFO file./// [`UnexpectedEof`]: std::io::ErrorKind::UnexpectedEof///     .open_receiver("path/to/a/fifo");/// Sets the option to skip the check for FIFO file type./// By default, [`open_receiver`] and [`open_sender`] functions will check/// if the opened file is a FIFO file. Set this option to `true` if you are/// sure the file is a FIFO file./// let rx = pipe::OpenOptions::new()///     .open_receiver(FIFO_NAME)?;open_receiver/// Creates a [`Receiver`] from a FIFO file with the options specified by `self`./// This function will open the FIFO file at the specified path, possibly/// check if it is a pipe, and associate the pipe with the default event/// loop for reading./// If the file type check fails, this function will fail with `io::ErrorKind::InvalidInput`./// This function may also fail with other standard OS errors.open_sender/// Creates a [`Sender`] from a FIFO file with the options specified by `self`./// loop for writing./// If the file is not opened in read-write access mode and the file is not/// currently open for reading, this function will fail with `ENXIO`.PipeEnd/// Writing end of a Unix pipe./// It can be constructed from a FIFO file with [`OpenOptions::open_sender`]./// Opening a named pipe for writing involves a few steps./// Call to [`OpenOptions::open_sender`] might fail with an error indicating/// different things:/// * [`io::ErrorKind::NotFound`] - There is no file at the specified path./// * [`io::ErrorKind::InvalidInput`] - The file exists, but it is not a FIFO./// * [`ENXIO`] - The file is a FIFO, but no process has it open for reading.///   Sleep for a while and try again./// * Other OS errors not specific to opening FIFO files./// Opening a `Sender` from a FIFO file should look like this:/// use tokio::time::{self, Duration};/// // Wait for a reader to open the file./// let tx = loop {///     match pipe::OpenOptions::new().open_sender(FIFO_NAME) {///         Ok(tx) => break tx,///         Err(e) if e.raw_os_error() == Some(libc::ENXIO) => {},///         Err(e) => return Err(e.into()),///     time::sleep(Duration::from_millis(50)).await;/// On Linux, it is possible to create a `Sender` without waiting in a sleeping/// loop. This is done by opening a named pipe in read-write access mode with/// `OpenOptions::read_write`. This way, a `Sender` can at the same time hold/// both a writing end and a reading end, and the latter allows to open a FIFO/// without [`ENXIO`] error since the pipe is open for reading as well./// `Sender` cannot be used to read from a pipe, so in practice the read access/// is only used when a FIFO is opened. However, using a `Sender` in read-write/// mode **may lead to lost data**, because written data will be dropped by the/// system as soon as all pipe ends are closed. To avoid lost data you have to/// make sure that a reading end has been opened before dropping a `Sender`./// Note that using read-write access mode with FIFO files is not defined by/// the POSIX standard and it is only guaranteed to work on Linux./// let mut tx = pipe::OpenOptions::new()/// // Asynchronously write to the pipe before a reader./// tx.write_all(b"hello world").await?;/// [`ENXIO`]: https://docs.rs/libc/latest/libc/constant.ENXIO.html/// Creates a new `Sender` from a [`File`]./// This function is intended to construct a pipe from a [`File`] representing/// a special FIFO file. It will check if the file is a pipe and has write access,/// set it in non-blocking mode and perform the conversion./// Fails with `io::ErrorKind::InvalidInput` if the file is not a pipe or it/// does not have write access. Also fails with any standard OS error if it occurs.from_owned_fd/// Creates a new `Sender` from an [`OwnedFd`]./// This function is intended to construct a pipe from an [`OwnedFd`] representing/// an anonymous pipe or a special FIFO file. It will check if the file descriptor/// is a pipe and has write access, set it in non-blocking mode and perform the/// conversion./// Fails with `io::ErrorKind::InvalidInput` if the file descriptor is not a pipe/// or it does not have write access. Also fails with any standard OS error if itfrom_file_unchecked/// Creates a new `Sender` from a [`File`] without checking pipe properties./// This function is intended to construct a pipe from a File representing/// a special FIFO file. The conversion assumes nothing about the underlying/// file; it is left up to the user to make sure it is opened with write access,/// represents a pipe and is set in non-blocking mode./// use std::os::unix::fs::{FileTypeExt, OpenOptionsExt};///     .custom_flags(libc::O_NONBLOCK)///     .open(FIFO_NAME)?;/// if file.metadata()?.file_type().is_fifo() {///     let tx = pipe::Sender::from_file_unchecked(file)?;///     /* use the Sender */from_owned_fd_unchecked/// Creates a new `Sender` from an [`OwnedFd`] without checking pipe properties./// an anonymous pipe or a special FIFO file. The conversion assumes nothing about/// the underlying pipe; it is left up to the user to make sure that the file/// descriptor represents the writing end of a pipe and the pipe is set in/// This function can be used instead of [`writable()`] to check the returned/// ready set for [`Ready::WRITABLE`] and [`Ready::WRITE_CLOSED`] events./// The function may complete without the pipe being ready. This is a/// Waits for the pipe to become writable./// paired with [`try_write()`].///     // Open a writing end of a fifo///     let tx = pipe::OpenOptions::new().open_sender("path/to/a/fifo")?;///         // Wait for the pipe to be writable///         tx.writable().await?;///         match tx.try_write(b"hello world") {///             Err(e) if e.kind() == io::ErrorKind::WouldBlock => {/// If the pipe is not currently ready for writing, this method will/// store a clone of the `Waker` from the provided `Context`. When the pipe/// becomes ready for writing, `Waker::wake` will be called on the waker./// scheduled to receive a wakeup./// [`writable`]: Self::writable/// * `Poll::Pending` if the pipe is not ready for writing./// * `Poll::Ready(Ok(()))` if the pipe is ready for writing./// Tries to write a buffer to the pipe, returning how many bytes were/// only part of the buffer may be written. If the length of `buf` is not/// greater than `PIPE_BUF` (an OS constant, 4096 under Linux), then the/// write is guaranteed to be atomic, i.e. either the entire content of/// `buf` will be written or this method will fail with `WouldBlock`. There/// is no such guarantee if `buf` is larger than `PIPE_BUF`./// This function is usually paired with [`writable`]./// number of bytes written. If the pipe is not ready to write data,/// Tries to write several buffers to the pipe, returning how many bytes/// If the total length of buffers is not greater than `PIPE_BUF` (an OS/// constant, 4096 under Linux), then the write is guaranteed to be atomic,/// i.e. either the entire contents of buffers will be written or this/// method will fail with `WouldBlock`. There is no such guarantee if the/// total length of buffers is greater than `PIPE_BUF`.///         match tx.try_write_vectored(&bufs) {into_blocking_fd/// Converts the pipe into an [`OwnedFd`] in blocking mode./// This function will deregister this pipe end from the event loop, set/// it in blocking mode and perform the conversion.into_nonblocking_fd/// Converts the pipe into an [`OwnedFd`] in nonblocking mode./// This function will deregister this pipe end from the event loop and/// perform the conversion. The returned file descriptor will be in nonblocking/// Reading end of a Unix pipe./// It can be constructed from a FIFO file with [`OpenOptions::open_receiver`]./// Receiving messages from a named pipe in a loop:/// use tokio::io::{self, AsyncReadExt};/// let mut rx = pipe::OpenOptions::new().open_receiver(FIFO_NAME)?;///     let mut msg = vec![0; 256];///     match rx.read_exact(&mut msg).await {///         Ok(_) => {///             /* handle the message *////         Err(e) if e.kind() == io::ErrorKind::UnexpectedEof => {///             // Writing end has been closed, we should reopen the pipe.///             rx = pipe::OpenOptions::new().open_receiver(FIFO_NAME)?;/// On Linux, you can use a `Receiver` in read-write access mode to implement/// resilient reading from a named pipe. Unlike `Receiver` opened in read-only/// mode, read from a pipe in read-write mode will not fail with `UnexpectedEof`/// when the writing end is closed. This way, a `Receiver` can asynchronously/// wait for the next writer to open the pipe./// You should not use functions waiting for EOF such as [`read_to_end`] with/// a `Receiver` in read-write access mode, since it **may wait forever**./// `Receiver` in this mode also holds an open writing end, which prevents/// receiving EOF./// To set the read-write access mode you can use `OpenOptions::read_write`./// let mut rx = pipe::OpenOptions::new()///     rx.read_exact(&mut msg).await?;///     /* handle the message *//// Creates a new `Receiver` from a [`File`]./// a special FIFO file. It will check if the file is a pipe and has read access,/// does not have read access. Also fails with any standard OS error if it occurs./// Creates a new `Receiver` from an [`OwnedFd`]./// is a pipe and has read access, set it in non-blocking mode and perform the/// or it does not have read access. Also fails with any standard OS error if it/// Creates a new `Receiver` from a [`File`] without checking pipe properties./// file; it is left up to the user to make sure it is opened with read access,///     let rx = pipe::Receiver::from_file_unchecked(file)?;///     /* use the Receiver *//// Creates a new `Receiver` from an [`OwnedFd`] without checking pipe properties./// descriptor represents the reading end of a pipe and the pipe is set in/// This function can be used instead of [`readable()`] to check the returned/// ready set for [`Ready::READABLE`] and [`Ready::READ_CLOSED`] events./// Waits for the pipe to become readable./// paired with [`try_read()`].///     // Open a reading end of a fifo///     let rx = pipe::OpenOptions::new().open_receiver("path/to/a/fifo")?;///         // Wait for the pipe to be readable///         rx.readable().await?;///         match rx.try_read(&mut msg) {/// If the pipe is not currently ready for reading, this method will/// becomes ready for reading, `Waker::wake` will be called on the waker./// Note that on multiple calls to `poll_read_ready` or `poll_read`, only/// [`readable`]: Self::readable/// * `Poll::Pending` if the pipe is not ready for reading./// * `Poll::Ready(Ok(()))` if the pipe is ready for reading./// Tries to read data from the pipe into the provided buffer, returning how/// Reads any pending data from the pipe but does not wait for new data/// Usually [`readable()`] is used with this function./// 1. The pipe's writing end is closed and will no longer write data./// If the pipe is not ready to read data,/// Tries to read data from the pipe into the provided buffers, returning/// Usually, [`readable()`] is used with this function./// number of bytes read. `Ok(0)` indicates the pipe's writing end is/// closed and will no longer write data. If the pipe is not ready to read/// data `Err(io::ErrorKind::WouldBlock)` is returned.///             io::IoSliceMut::new(&mut buf_a),///             io::IoSliceMut::new(&mut buf_b),///         match rx.try_read_vectored(&mut bufs) {r" Tries to read data from the pipe into the provided buffer, advancing the"r" Reads any pending data from the pipe but does not wait for new data"r" [`readable()`]: Self::readable"r" [`ready()`]: Self::ready"r" number of bytes read. `Ok(0)` indicates the pipe's writing end is"r" closed and will no longer write data. If the pipe is not ready to read"r" data `Err(io::ErrorKind::WouldBlock)` is returned."r" use tokio::net::unix::pipe;"r"     // Open a reading end of a fifo"r#"     let rx = pipe::OpenOptions::new().open_receiver("path/to/a/fifo")?;"#r"         // Wait for the pipe to be readable"r"         rx.readable().await?;"r"         match rx.try_read_buf(&mut buf) {"/// perform the conversion. Returned file descriptor will be in nonblockingis_pipe/// Checks if the file descriptor is a pipe or a FIFO.get_file_flags/// Gets file descriptor's flags by fcntl.has_read_access/// Checks for `O_RDONLY` or `O_RDWR` access mode.has_write_access/// Checks for `O_WRONLY` or `O_RDWR` access mode./// Sets file descriptor's flags with `O_NONBLOCK` by fcntl./// Removes `O_NONBLOCK` from fd's flags.//! Unix pipe types.r" A Unix socket that has not yet been converted to a [`UnixStream`], [`UnixDatagram`], or"r" [`UnixListener`]."r" `UnixSocket` wraps an operating system socket and enables the caller to"r" configure the socket before establishing a connection or accepting"r" The underlying socket is closed when the `UnixSocket` value is dropped."r" `UnixSocket` should only be used directly if the default configuration used"r" by [`UnixStream::connect`], [`UnixDatagram::bind`], and [`UnixListener::bind`]"r" does not meet the required use case."r" Calling `UnixStream::connect(path)` effectively performs the same function as:"r" use tokio::net::UnixSocket;"r#"     let path = dir.path().join("bind_path");"#r"     let socket = UnixSocket::new_stream()?;"r"     let stream = socket.connect(path).await?;"r" Calling `UnixDatagram::bind(path)` effectively performs the same function as:"r"     let socket = UnixSocket::new_datagram()?;"r"     socket.bind(path)?;"r"     let datagram = socket.datagram()?;"r" Calling `UnixListener::bind(path)` effectively performs the same function as:"r" Setting socket options not explicitly provided by `UnixSocket` may be done by"r" accessing the [`RawFd`]/[`RawSocket`] using [`AsRawFd`]/[`AsRawSocket`] and"r" [`RawFd`]: std::os::fd::RawFd"r" [`AsRawFd`]: std::os::fd::AsRawFd"new_datagram/// Creates a new Unix datagram socket./// Calls `socket(2)` with `AF_UNIX` and `SOCK_DGRAM`./// On success, the newly created [`UnixSocket`] is returned. If an error isnew_stream/// Creates a new Unix stream socket./// Calls `socket(2)` with `AF_UNIX` and `SOCK_STREAM`./// This calls the `bind(2)` operating-system function./// Converts the socket into a `UnixListener`./// the queue with [`UnixListener::accept`]. When the queue is full, the/// Calling this function on a socket created by [`new_datagram`] will return an error./// as a passive socket./// [`new_datagram`]: `UnixSocket::new_datagram`/// Establishes a Unix connection with a peer at the specified socket address./// The `UnixSocket` is consumed. Once the connection is established, a/// connected [`UnixStream`] is returned. If the connection fails, the/// This calls the `connect(2)` operating-system function./// Converts the socket into a [`UnixDatagram`]./// Calling this function on a socket created by [`new_stream`] will return an error./// [`new_stream`]: `UnixSocket::new_stream`/// An address associated with a Tokio Unix socket./// This type is a thin wrapper around [`std::os::unix::net::SocketAddr`]. You/// can convert to and from the standard library `SocketAddr` type using the/// [`From`] trait./// Returns `true` if the address is unnamed./// Documentation reflected in [`SocketAddr`]/// [`SocketAddr`]: std::os::unix::net::SocketAddr/// Returns the contents of this address if it is a `pathname` address./// Borrowed read half of a [`UnixStream`], created by [`split`]./// [`UnixStream`]: UnixStream/// [`split`]: UnixStream::split()/// Borrowed write half of a [`UnixStream`], created by [`split`]./// shut down the [`UnixStream`] stream in the write direction./// Wait for any of the requested ready states./// This function is equivalent to [`UnixStream::ready`].//! `UnixStream` split support.//! A `UnixStream` can be split into a read half and a write half with//! `UnixStream::split`. The read half implements `AsyncRead` while the write//! half implements `AsyncWrite`./// Owned read half of a [`UnixStream`], created by [`into_split`]./// [`UnixStream`]: crate::net::UnixStream/// [`into_split`]: crate::net::UnixStream::into_split()/// Owned write half of a [`UnixStream`], created by [`into_split`]./// Note that in the [`AsyncWrite`] implementation of this type,/// [`poll_shutdown`] will shut down the stream in the write direction./// Dropping the write half will also shut down the write half of the stream./// Writing to an `OwnedWriteHalf` is usually done using the convenience methods/// found on the [`AsyncWriteExt`] trait./// Attempts to put the two halves of a `UnixStream` back together and//! `UnixStream` owned split support.//! A `UnixStream` can be split into an `OwnedReadHalf` and a `OwnedWriteHalf`//! with the `UnixStream::into_split` method.  `OwnedReadHalf` implementsr" A structure representing a connected Unix socket."r" This socket can be connected directly with [`UnixStream::connect`] or accepted"r" from a listener with [`UnixListener::accept`]. Additionally, a pair of"r" anonymous Unix sockets can be created with `UnixStream::pair`."r" [`UnixListener::accept`]: crate::net::UnixListener::accept"/// This function will create a new Unix socket and connect to the path/// specified, associating the returned stream with the default event loop's/// use tokio::net::UnixStream;///     let bind_path = dir.path().join("bind_path");///     let stream = UnixStream::connect(bind_path).await?;/// If the unix stream is not currently ready for reading, this method will/// store a clone of the `Waker` from the provided `Context`. When the unix/// scheduled to receive a wakeup. (However, `poll_write_ready` retains a/// * `Poll::Pending` if the unix stream is not ready for reading./// * `Poll::Ready(Ok(()))` if the unix stream is ready for reading./// Try to read data from the stream into the provided buffer, returning how/// [`readable()`]: UnixStream::readable()/// [`ready()`]: UnixStream::ready()/// [`try_read()`]: UnixStream::try_read()r" [`readable()`]: UnixStream::readable()"r" [`ready()`]: UnixStream::ready()"r" use tokio::net::UnixStream;"r#"     let bind_path = dir.path().join("bind_path");"#r"     let stream = UnixStream::connect(bind_path).await?;"/// If the unix stream is not currently ready for writing, this method will/// * `Poll::Pending` if the unix stream is not ready for writing./// * `Poll::Ready(Ok(()))` if the unix stream is ready for writing./// [`try_write()`]: UnixStream::try_write()/// defined on the Tokio `UnixStream` type, as this will mess with the/// [`writable()`]: UnixStream::writable()/// Creates new [`UnixStream`] from a [`std::os::unix::net::UnixStream`]./// This function is intended to be used to wrap a `UnixStream` from the/// [`set_nonblocking`]: std::os::unix::net::UnixStream::set_nonblocking/// use std::os::unix::net::UnixStream as StdUnixStream;/// let std_stream = StdUnixStream::connect("/path/to/the/socket")?;/// std_stream.set_nonblocking(true)?;/// let stream = UnixStream::from_std(std_stream)?;/// Turns a [`tokio::net::UnixStream`] into a [`std::os::unix::net::UnixStream`]./// The returned [`std::os::unix::net::UnixStream`] will have nonblocking/// mode set as `true`.  Use [`set_nonblocking`] to change the blocking/// mode if needed./// # use tokio::net::UnixStream;///     let listener = UnixListener::bind(&bind_path)?;/// #   let handle = tokio::spawn(async {/// #       let mut stream = UnixStream::connect(bind_path).await.unwrap();/// #       stream.write(b"Hello world!").await.unwrap();///     let (tokio_unix_stream, _) = listener.accept().await?;///     let mut std_unix_stream = tokio_unix_stream.into_std()?;///     std_unix_stream.set_nonblocking(false)?;///     std_unix_stream.read_exact(&mut data)?;/// [`tokio::net::UnixStream`]: UnixStream/// [`std::os::unix::net::UnixStream`]: std::os::unix::net::UnixStream/// [`set_nonblocking`]: fn@std::os::unix::net::UnixStream::set_nonblocking/// communicating back and forth between one another. Each socket will/// be associated with the default event loop's handle./// let dir = tempfile::tempdir().unwrap();/// let bind_path = dir.path().join("bind_path");/// let stream = UnixStream::connect(bind_path).await?;peer_cred/// Returns effective credentials of the process which called `connect` or `pair`./// Splits a `UnixStream` into a read half and a write half, which can be used/// [`into_split`]: Self::into_split()/// **Note:** Dropping the write half will shut down the write half of the/// stream. This is equivalent to calling [`shutdown()`] on the `UnixStream`./// [`split`]: Self::split()/// [`UnixStream::from_std(stream)`](UnixStream::from_std).// To read or write without mutable access to the `UnixStream`, combine the/// PID (process ID) of the process./// UID (user ID) of the process./// GID (group ID) of the process./// Credentials of a process./// Gets UID (user ID) of the process./// Gets GID (group ID) of the process./// Gets PID (process ID) of the process./// This is only implemented under Linux, Android, iOS, macOS, Solaris and/// Illumos. On other platforms this will always return `None`.impl_linuxget_peer_cred//! Windows specific network types.mio_windows// Hide imports which are not used when generating documentation.// NB: none of these shows up in public API, so don't document them./// A [Windows named pipe] server./// Accepting client connections involves creating a server with/// [`ServerOptions::create`] and waiting for clients to connect using/// [`NamedPipeServer::connect`]./// To avoid having clients sporadically fail with/// [`std::io::ErrorKind::NotFound`] when they connect to a server, we must/// ensure that at least one server instance is available at all times. This/// means that the typical listen loop for a server is a bit involved, because/// we have to ensure that we never drop a server accidentally while a client/// might connect./// So a correctly implemented server looks like this:/// use tokio::net::windows::named_pipe::ServerOptions;/// const PIPE_NAME: &str = r"\\.\pipe\named-pipe-idiomatic-server";/// # #[tokio::main] async fn main() -> std::io::Result<()> {/// // The first server needs to be constructed early so that clients can/// // be correctly connected. Otherwise calling .wait will cause the client to/// // error./// // Here we also make use of `first_pipe_instance`, which will ensure that/// // there are no other servers up and running already./// let mut server = ServerOptions::new()///     .first_pipe_instance(true)///     .create(PIPE_NAME)?;/// // Spawn the server loop./// let server = tokio::spawn(async move {///         // Wait for a client to connect.///         server.connect().await?;///         let connected_client = server;///         // Construct the next server to be connected before sending the one///         // we already have of onto a task. This ensures that the server///         // isn't closed (after it's done in the task) before a new one is///         // available. Otherwise the client might error with///         // `io::ErrorKind::NotFound`.///         server = ServerOptions::new().create(PIPE_NAME)?;///         let client = tokio::spawn(async move {///             /* use the connected client *//// #           Ok::<_, std::io::Error>(())/// #       if true { break } // needed for type inference to work///     Ok::<_, io::Error>(())/// /* do something else not server related here *//// [Windows named pipe]: https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes/// Constructs a new named pipe server from the specified raw handle./// This function will consume ownership of the handle given, passing/// responsibility for closing the handle to the returned object./// This function is also unsafe as the primitives currently returned have/// the contract that they are the sole owner of the file descriptor they/// are wrapping. Usage of this function could accidentally allow violating/// this contract which can cause memory unsafety in code that relies on it/// being true./// This errors if called outside of a [Tokio Runtime], or in a runtime that/// has not [enabled I/O], or if any OS-specific I/O errors occur./// [Tokio Runtime]: crate::runtime::Runtime/// [enabled I/O]: crate::runtime::Builder::enable_ioPipeInfo/// Retrieves information about the named pipe the server is associated/// use tokio::net::windows::named_pipe::{PipeEnd, PipeMode, ServerOptions};/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-info";/// let server = ServerOptions::new()///     .pipe_mode(PipeMode::Message)///     .max_instances(5)/// let server_info = server.info()?;/// assert_eq!(server_info.end, PipeEnd::Server);/// assert_eq!(server_info.mode, PipeMode::Message);/// assert_eq!(server_info.max_instances, 5);/// Enables a named pipe server process to wait for a client process to/// connect to an instance of a named pipe. A client process connects by/// creating a named pipe with the same name./// This corresponds to the [`ConnectNamedPipe`] system call./// This method is cancellation safe in the sense that if it is used as the/// event in a [`select!`](crate::select) statement and some other branch/// completes first, then no connection events have been lost./// [`ConnectNamedPipe`]: https://docs.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-connectnamedpipe/// const PIPE_NAME: &str = r"\\.\pipe\mynamedpipe";/// let pipe = ServerOptions::new().create(PIPE_NAME)?;/// // Wait for a client to connect./// pipe.connect().await?;/// // Use the connected client.../// Disconnects the server end of a named pipe instance from a client/// use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};/// use windows_sys::Win32::Foundation::ERROR_PIPE_NOT_CONNECTED;/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-disconnect";/// let mut client = ClientOptions::new()///     .open(PIPE_NAME)?;/// // Wait for a client to become connected./// server.connect().await?;/// // Forcibly disconnect the client./// server.disconnect()?;/// // Write fails with an OS-specific error after client has been/// // disconnected./// let e = client.write(b"ping").await.unwrap_err();/// assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_NOT_CONNECTED as i32));/// can be used to concurrently read / write to the same pipe on a single/// task without splitting the pipe./// Concurrently read and write to the pipe on the same task without/// use tokio::net::windows::named_pipe;/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-ready";///     let server = named_pipe::ServerOptions::new()///         .create(PIPE_NAME)?;///         let ready = server.ready(Interest::READABLE | Interest::WRITABLE).await?;///             match server.try_read(&mut data) {///                 Err(e) if e.kind() == io::ErrorKind::WouldBlock => {///             match server.try_write(b"hello world") {/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-readable";///         server.readable().await?;///         match server.try_read(&mut msg) {/// Receives any pending data from the pipe but does not wait for new data/// [`readable()`]: NamedPipeServer::readable()/// [`ready()`]: NamedPipeServer::ready()/// 1. The pipe's read half is closed and will no longer yield data./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-try-read";///         match server.try_read(&mut buf) {/// [`try_read()`]: NamedPipeServer::try_read()/// number of bytes read. `Ok(0)` indicates the pipe's read half is closed/// and will no longer yield data. If the pipe is not ready to read data/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-try-read-vectored";///         match server.try_read_vectored(&mut bufs) {/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-writable";///         server.writable().await?;///         match server.try_write(b"hello world") {/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-try-write";/// [`try_write()`]: NamedPipeServer::try_write()/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-server-try-write-vectored";///         match server.try_write_vectored(&bufs) {/// Tries to read or write from the pipe using a user-provided IO operation./// If the pipe is ready, the provided closure is called. The closure/// should attempt to perform IO operation from the pipe by manually/// pipe is not actually ready, then the closure should return a/// If the pipe is not ready, then the closure is not called/// an IO operation on the pipe that failed due to the pipe not being/// incorrectly clear the readiness flag, which can cause the pipe to/// The closure should not perform the IO operation using any of the/// methods defined on the Tokio `NamedPipeServer` type, as this will mess with/// the readiness flag and can cause the pipe to behave incorrectly./// [`writable()`]: NamedPipeServer::writable()/// Reads or writes from the pipe using a user-provided IO operation./// The readiness of the pipe is awaited and when the pipe is ready,/// IO operation on the pipe by manually calling the appropriate syscall./// If the operation fails because the pipe is not actually ready,/// readiness flag is cleared and the pipe readiness is awaited again./// defined on the Tokio `NamedPipeServer` type, as this will mess with the/// readiness flag and can cause the pipe to behave incorrectly./// A [Windows named pipe] client./// Constructed using [`ClientOptions::open`]./// Connecting a client correctly involves a few steps. When connecting through/// [`ClientOptions::open`], it might error indicating one of two things:/// * [`std::io::ErrorKind::NotFound`] - There is no server available./// * [`ERROR_PIPE_BUSY`] - There is a server available, but it is busy. Sleep///   for a while and try again./// So a correctly implemented client looks like this:/// use tokio::net::windows::named_pipe::ClientOptions;/// use tokio::time;/// use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;/// const PIPE_NAME: &str = r"\\.\pipe\named-pipe-idiomatic-client";/// let client = loop {///     match ClientOptions::new().open(PIPE_NAME) {///         Ok(client) => break client,///         Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),///         Err(e) => return Err(e),/// /* use the connected client *//// [`ERROR_PIPE_BUSY`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Foundation/constant.ERROR_PIPE_BUSY.html/// Constructs a new named pipe client from the specified raw handle./// Retrieves information about the named pipe the client is associated/// use tokio::net::windows::named_pipe::{ClientOptions, PipeEnd, PipeMode};/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-info";/// let client = ClientOptions::new()/// let client_info = client.info()?;/// assert_eq!(client_info.end, PipeEnd::Client);/// assert_eq!(client_info.mode, PipeMode::Message);/// assert_eq!(client_info.max_instances, 5);/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-ready";///     let client = named_pipe::ClientOptions::new().open(PIPE_NAME)?;///         let ready = client.ready(Interest::READABLE | Interest::WRITABLE).await?;///             match client.try_read(&mut data) {///             match client.try_write(b"hello world") {/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-readable";///         client.readable().await?;///         match client.try_read(&mut msg) {/// [`readable()`]: NamedPipeClient::readable()/// [`ready()`]: NamedPipeClient::ready()/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-try-read";///         match client.try_read(&mut buf) {/// [`try_read()`]: NamedPipeClient::try_read()/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-try-read-vectored";///         match client.try_read_vectored(&mut bufs) {/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-writable";///         client.writable().await?;///         match client.try_write(b"hello world") {/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-try-write";/// [`try_write()`]: NamedPipeClient::try_write()/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-try-write-vectored";///         match client.try_write_vectored(&bufs) {/// defined on the Tokio `NamedPipeClient` type, as this will mess with the/// [`writable()`]: NamedPipeClient::writable()access_inbound// dwOpenModeaccess_outboundfirst_pipe_instancewrite_dacwrite_owneraccess_system_securitypipe_modePipeMode// dwPipeModereject_remote_clientsmax_instances// other optionsout_buffer_sizein_buffer_sizeServerOptions/// A builder structure for construct a named pipe with named pipe-specific/// options. This is required to use for named pipe servers who wants to modify/// pipe-related options./// See [`ServerOptions::create`]./// Creates a new named pipe builder with the default settings./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-new";/// let server = ServerOptions::new().create(PIPE_NAME)?;/// The pipe mode./// The default pipe mode is [`PipeMode::Byte`]. See [`PipeMode`] for/// documentation of what each mode means./// This corresponds to specifying `PIPE_TYPE_` and `PIPE_READMODE_` in  [`dwPipeMode`]./// [`dwPipeMode`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// The flow of data in the pipe goes from client to server only./// This corresponds to setting [`PIPE_ACCESS_INBOUND`]./// [`PIPE_ACCESS_INBOUND`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea#pipe_access_inbound/// Server side prevents connecting by denying inbound access, client errors/// with [`std::io::ErrorKind::PermissionDenied`] when attempting to create/// the connection./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-access-inbound-err1";/// # #[tokio::main] async fn main() -> io::Result<()> {/// let _server = ServerOptions::new()///     .access_inbound(false)/// let e = ClientOptions::new()///     .open(PIPE_NAME)/// assert_eq!(e.kind(), io::ErrorKind::PermissionDenied);/// Disabling writing allows a client to connect, but errors with/// [`std::io::ErrorKind::PermissionDenied`] if a write is attempted./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-access-inbound-err2";///     .write(false)/// A unidirectional named pipe that only supports server-to-client/// communication./// use tokio::io::{AsyncReadExt, AsyncWriteExt};/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-access-inbound";/// let write = server.write_all(b"ping");/// let read = client.read_exact(&mut buf);/// let ((), read) = tokio::try_join!(write, read)?;/// assert_eq!(read, 4);/// assert_eq!(&buf[..], b"ping");/// The flow of data in the pipe goes from server to client only./// This corresponds to setting [`PIPE_ACCESS_OUTBOUND`]./// [`PIPE_ACCESS_OUTBOUND`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea#pipe_access_outbound/// Server side prevents connecting by denying outbound access, client/// errors with [`std::io::ErrorKind::PermissionDenied`] when attempting to/// create the connection./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-access-outbound-err1";///     .access_outbound(false)/// Disabling reading allows a client to connect, but attempting to read/// will error with [`std::io::ErrorKind::PermissionDenied`]./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-access-outbound-err2";///     .read(false)/// let e = client.read(&mut buf).await.unwrap_err();/// A unidirectional named pipe that only supports client-to-server/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-access-outbound";/// let write = client.write_all(b"ping");/// let read = server.read_exact(&mut buf);/// println!("done reading and writing");/// If you attempt to create multiple instances of a pipe with this flag/// set, creation of the first server instance succeeds, but creation of any/// subsequent instances will fail with/// [`std::io::ErrorKind::PermissionDenied`]./// This option is intended to be used with servers that want to ensure that/// they are the only process listening for clients on a given named pipe./// This is accomplished by enabling it for the first server instance/// created in a process./// This corresponds to setting [`FILE_FLAG_FIRST_PIPE_INSTANCE`]./// If this option is set and more than one instance of the server for a/// given named pipe exists, calling [`create`] will fail with/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-first-instance-error";/// let server1 = ServerOptions::new()/// // Second server errs, since it's not the first instance./// let e = ServerOptions::new()///     .create(PIPE_NAME)/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-first-instance";/// let mut builder = ServerOptions::new();/// builder.first_pipe_instance(true);/// let server = builder.create(PIPE_NAME)?;/// let e = builder.create(PIPE_NAME).unwrap_err();/// drop(server);/// // OK: since, we've closed the other instance./// let _server2 = builder.create(PIPE_NAME)?;/// [`create`]: ServerOptions::create/// [`FILE_FLAG_FIRST_PIPE_INSTANCE`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea#pipe_first_pipe_instance/// Requests permission to modify the pipe's discretionary access control list./// This corresponds to setting [`WRITE_DAC`] in dwOpenMode./// use std::{io, os::windows::prelude::AsRawHandle, ptr};/// use windows_sys::{///     Win32::Foundation::ERROR_SUCCESS,///     Win32::Security::DACL_SECURITY_INFORMATION,///     Win32::Security::Authorization::{SetSecurityInfo, SE_KERNEL_OBJECT},/// const PIPE_NAME: &str = r"\\.\pipe\write_dac_pipe";/// let mut pipe_template = ServerOptions::new();/// pipe_template.write_dac(true);/// let pipe = pipe_template.create(PIPE_NAME)?;///         ERROR_SUCCESS,///         SetSecurityInfo(///             pipe.as_raw_handle() as _,///             SE_KERNEL_OBJECT,///             DACL_SECURITY_INFORMATION,///             ptr::null_mut(),///     Win32::Foundation::ERROR_ACCESS_DENIED,/// const PIPE_NAME: &str = r"\\.\pipe\write_dac_pipe_fail";/// pipe_template.write_dac(false);///         ERROR_ACCESS_DENIED,/// [`WRITE_DAC`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// Requests permission to modify the pipe's owner./// This corresponds to setting [`WRITE_OWNER`] in dwOpenMode./// [`WRITE_OWNER`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// Requests permission to modify the pipe's system access control list./// This corresponds to setting [`ACCESS_SYSTEM_SECURITY`] in dwOpenMode./// [`ACCESS_SYSTEM_SECURITY`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// Indicates whether this server can accept remote clients or not. Remote/// clients are disabled by default./// This corresponds to setting [`PIPE_REJECT_REMOTE_CLIENTS`]./// [`PIPE_REJECT_REMOTE_CLIENTS`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea#pipe_reject_remote_clients/// The maximum number of instances that can be created for this pipe. The/// first instance of the pipe can specify this value; the same number must/// be specified for other instances of the pipe. Acceptable values are in/// the range 1 through 254. The default value is unlimited./// This corresponds to specifying [`nMaxInstances`]./// [`nMaxInstances`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// The same numbers of `max_instances` have to be used by all servers. Any/// additional servers trying to be built which uses a mismatching value/// might error./// use tokio::net::windows::named_pipe::{ServerOptions, ClientOptions};/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-max-instances";/// let mut server = ServerOptions::new();/// server.max_instances(2);/// let s1 = server.create(PIPE_NAME)?;/// let c1 = ClientOptions::new().open(PIPE_NAME);/// let s2 = server.create(PIPE_NAME)?;/// let c2 = ClientOptions::new().open(PIPE_NAME);/// // Too many servers!/// let e = server.create(PIPE_NAME).unwrap_err();/// assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_BUSY as i32));/// // Still too many servers even if we specify a higher value!/// let e = server.max_instances(100).create(PIPE_NAME).unwrap_err();/// This function will panic if more than 254 instances are specified. If/// you do not wish to set an instance limit, leave it unspecified./// let builder = ServerOptions::new().max_instances(255);/// The number of bytes to reserve for the output buffer./// This corresponds to specifying [`nOutBufferSize`]./// [`nOutBufferSize`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// The number of bytes to reserve for the input buffer./// This corresponds to specifying [`nInBufferSize`]./// [`nInBufferSize`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// Creates the named pipe identified by `addr` for use as a server./// This uses the [`CreateNamedPipe`] function./// [`CreateNamedPipe`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea/// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-create";create_with_security_attributes_raw/// This is the same as [`create`] except that it supports providing the raw/// pointer to a structure of [`SECURITY_ATTRIBUTES`] which will be passed/// as the `lpSecurityAttributes` argument to [`CreateFile`]./// The `attrs` argument must either be null or point at a valid instance of/// the [`SECURITY_ATTRIBUTES`] structure. If the argument is null, the/// behavior is identical to calling the [`create`] method./// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew/// [`SECURITY_ATTRIBUTES`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Security/struct.SECURITY_ATTRIBUTES.htmlgeneric_readgeneric_writesecurity_qos_flagsClientOptions/// A builder suitable for building and interacting with named pipes from the/// client side./// See [`ClientOptions::open`]./// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-new";/// // Server must be created in order for the client creation to succeed./// let client = ClientOptions::new().open(PIPE_NAME)?;/// If the client supports reading data. This is enabled by default./// This corresponds to setting [`GENERIC_READ`] in the call to [`CreateFile`]./// [`GENERIC_READ`]: https://docs.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights/// If the created pipe supports writing data. This is enabled by default./// This corresponds to setting [`GENERIC_WRITE`] in the call to [`CreateFile`]./// [`GENERIC_WRITE`]: https://docs.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights/// Sets qos flags which are combined with other flags and attributes in the/// call to [`CreateFile`]./// By default `security_qos_flags` is set to [`SECURITY_IDENTIFICATION`],/// calling this function would override that value completely with the/// argument specified./// When `security_qos_flags` is not set, a malicious program can gain the/// elevated privileges of a privileged Rust process when it allows opening/// user-specified paths, by tricking it into opening a named pipe. So/// arguably `security_qos_flags` should also be set when opening arbitrary/// paths. However the bits can then conflict with other flags, specifically/// `FILE_FLAG_OPEN_NO_RECALL`./// For information about possible values, see [Impersonation Levels] on the/// Windows Dev Center site. The `SECURITY_SQOS_PRESENT` flag is set/// automatically when using this method./// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea/// [`SECURITY_IDENTIFICATION`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Storage/FileSystem/constant.SECURITY_IDENTIFICATION.html/// [Impersonation Levels]: https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level/// Opens the named pipe identified by `addr`./// This opens the client using [`CreateFile`] with the/// `dwCreationDisposition` option set to `OPEN_EXISTING`./// There are a few errors you need to take into account when creating a/// named pipe on the client side:/// * [`std::io::ErrorKind::NotFound`] - This indicates that the named pipe///   does not exist. Presumably the server is not up./// * [`ERROR_PIPE_BUSY`] - This error is raised when the named pipe exists,///   but the server is not currently waiting for a connection. Please see the///   examples for how to check for this error./// A connect loop that waits until a pipe becomes available looks like/// // use the connected client.open_with_security_attributes_raw/// This is the same as [`open`] except that it supports providing the raw/// behavior is identical to calling the [`open`] method./// [`open`]: ClientOptions::open/// Data is written to the pipe as a stream of bytes. The pipe does not/// distinguish bytes written during different write operations./// Corresponds to [`PIPE_TYPE_BYTE`]./// [`PIPE_TYPE_BYTE`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_TYPE_BYTE.html/// Data is written to the pipe as a stream of messages. The pipe treats the/// bytes written during each write operation as a message unit. Any reading/// on a named pipe returns [`ERROR_MORE_DATA`] when a message is not read/// completely./// Corresponds to [`PIPE_TYPE_MESSAGE`]./// [`ERROR_MORE_DATA`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Foundation/constant.ERROR_MORE_DATA.html/// [`PIPE_TYPE_MESSAGE`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_TYPE_MESSAGE.html/// The pipe mode of a named pipe./// Set through [`ServerOptions::pipe_mode`]./// The named pipe refers to the client end of a named pipe instance./// Corresponds to [`PIPE_CLIENT_END`]./// [`PIPE_CLIENT_END`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_CLIENT_END.html/// The named pipe refers to the server end of a named pipe instance./// Corresponds to [`PIPE_SERVER_END`]./// [`PIPE_SERVER_END`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_SERVER_END.html/// Indicates the end of a named pipe./// Indicates the mode of a named pipe./// The maximum number of instances that can be created for this pipe./// Information about a named pipe./// Constructed through [`NamedPipeServer::info`] or [`NamedPipeClient::info`]./// Encodes an address so that it is a null-terminated wide string.named_pipe_info/// Internal function to get the info out of a raw named pipe.//! Tokio support for [Windows named pipes].//! [Windows named pipes]: https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes/// Forcefully kills the process./// An interface for killing a running process.StdCommand/// This structure mimics the API of [`std::process::Command`] found in the standard library, but/// replaces functions that create a process with an asynchronous variant. The main provided/// asynchronous functions are [spawn](Command::spawn), [status](Command::status), and/// [output](Command::output)./// `Command` uses asynchronous versions of some `std` types (for example [`Child`])./// [`std::process::Command`]: std::process::Command/// [`Child`]: struct@ChildChildStdioSpawnedChild/// Constructs a new `Command` for launching the program at/// path `program`, with the following default configuration:/// * No arguments to the program/// * Inherit the current process's environment/// * Inherit the current process's working directory/// * Inherit stdin/stdout/stderr for `spawn` or `status`, but create pipes for `output`/// Builder methods are provided to change these defaults and/// otherwise configure the process./// If `program` is not an absolute path, the `PATH` will be searched in/// an OS-defined way./// The search path to be used may be controlled by setting the/// `PATH` environment variable on the Command,/// but this has some implementation limitations on Windows/// (see issue [rust-lang/rust#37519])./// let mut command = Command::new("sh");/// # let _ = command.output(); // assert borrow checker/// [rust-lang/rust#37519]: https://github.com/rust-lang/rust/issues/37519/// Cheaply convert to a `&std::process::Command` for places where the type from the standard/// library is expected.as_std_mut/// Cheaply convert to a `&mut std::process::Command` for places where the type from the/// standard library is expected./// Cheaply convert into a `std::process::Command`./// Note that Tokio specific options will be lost. Currently, this only applies to [`kill_on_drop`]./// [`kill_on_drop`]: Command::kill_on_drop/// Adds an argument to pass to the program./// Only one argument can be passed per use. So instead of:/// let mut command = tokio::process::Command::new("sh");/// command.arg("-C /path/to/repo");/// usage would be:/// command.arg("-C");/// command.arg("/path/to/repo");/// To pass multiple arguments see [`args`]./// [`args`]: method@Self::args/// # async fn test() { // allow using await/// let output = Command::new("ls")///         .arg("-l")///         .arg("-a")///         .output().await.unwrap();/// To pass a single argument see [`arg`]./// [`arg`]: method@Self::arg///         .args(&["-l", "-a"])/// Inserts or updates an environment variable mapping.///         .env("PATH", "/bin")/// Adds or updates multiple environment variable mappings./// use std::process::{Stdio};/// let filtered_env : HashMap<String, String> =///     env::vars().filter(|&(ref k, _)|///         k == "TERM" || k == "TZ" || k == "LANG" || k == "PATH"/// let output = Command::new("printenv")///         .stdin(Stdio::null())///         .stdout(Stdio::inherit())///         .env_clear()///         .envs(&filtered_env)///         .env_remove("PATH")/// Clears the entire environment map for the child process./// Sets the working directory for the child process./// If the program path is relative (e.g., `"./script.sh"`), it's ambiguous/// whether it should be interpreted relative to the parent's working/// directory or relative to `current_dir`. The behavior in this case is/// platform specific and unstable, and it's recommended to use/// [`canonicalize`] to get an absolute program path instead./// [`canonicalize`]: crate::fs::canonicalize()///         .current_dir("/bin")/// Sets configuration for the child process's standard input (stdin) handle./// Defaults to [`inherit`]./// [`inherit`]: std::process::Stdio::inherit/// Sets configuration for the child process's standard output (stdout) handle./// Defaults to [`inherit`] when used with `spawn` or `status`, and/// defaults to [`piped`] when used with `output`./// [`piped`]: std::process::Stdio::piped///         .stdout(Stdio::null())/// Sets configuration for the child process's standard error (stderr) handle.///         .stderr(Stdio::null())/// Controls whether a `kill` operation should be invoked on a spawned child/// process when its corresponding `Child` handle is dropped./// By default, this value is assumed to be `false`, meaning the next spawned/// process will not be killed on drop, similar to the behavior of the standard/// On Unix platforms processes must be "reaped" by their parent process after/// they have exited in order to release all OS resources. A child process which/// has exited, but has not yet been reaped by its parent is considered a "zombie"/// process. Such processes continue to count against limits imposed by the system,/// and having too many zombie processes present can prevent additional processes/// from being spawned./// Although issuing a `kill` signal to the child process is a synchronous/// operation, the resulting zombie process cannot be `.await`ed inside of the/// destructor to avoid blocking other tasks. The tokio runtime will, on a/// best-effort basis, attempt to reap and clean up such processes in the/// background, but no additional guarantees are made with regard to/// how quickly or how often this procedure will take place./// If stronger guarantees are required, it is recommended to avoid dropping/// a [`Child`] handle where possible, and instead utilize `child.wait().await`/// or `child.kill().await` where possible./// Similar to `uid` but sets the group ID of the child process. This has/// Sets executable argument.process_group/// Sets the process group ID (PGID) of the child process. Equivalent to a/// `setpgid` call in the child process, but may be more efficient./// Process groups determine which processes receive signals./// Pressing Ctrl-C in a terminal will send `SIGINT` to all processes/// in the current foreground process group. By spawning the `sleep`/// subprocess in a new process group, it will not receive `SIGINT`/// from the terminal./// The parent process could install a [signal handler] and manage the/// process on its own terms./// A process group ID of 0 will use the process ID as the PGID./// let output = Command::new("sleep")///     .arg("10")///     .process_group(0)///     .await/// [signal handler]: crate::signal/// Executes the command as a child process, returning a handle to it./// By default, stdin, stdout and stderr are inherited from the parent./// This method will spawn the child process synchronously and return a/// handle to a future-aware child process. The `Child` returned implements/// `Future` itself to acquire the `ExitStatus` of the child, and otherwise/// the `Child` has methods to acquire handles to the stdin, stdout, and/// stderr streams./// All I/O this child does will be associated with the current default/// # if cfg!(miri) { return } // No `pidfd_spawnp` in miri./// async fn run_ls() -> std::process::ExitStatus {///     Command::new("ls")///         .expect("ls command failed to start")///         .expect("ls command failed to run")/// ## Dropping/Cancellation/// Similar to the behavior to the standard library, and unlike the futures/// paradigm of dropping-implies-cancellation, a spawned process will, by/// default, continue to execute even after the `Child` handle has been dropped./// The [`Command::kill_on_drop`] method can be used to modify this behavior/// and kill the child process if the `Child` wrapper is dropped before it/// has exited./// ## Unix Processes/// The tokio runtime will, on a best-effort basis, attempt to reap and clean up/// any process which it has spawned. No additional guarantees are made with regard to/// It is recommended to avoid dropping a [`Child`] process handle before it has been/// fully `await`ed if stricter cleanup guarantees are required./// [`Command`]: crate::process::Command/// [`Command::kill_on_drop`]: crate::process::Command::kill_on_drop/// [`Child`]: crate::process::Child/// On Unix platforms this method will fail with `std::io::ErrorKind::WouldBlock`/// if the system process limit is reached (which includes other applications/// running on the system)./// Executes the command as a child process, waiting for it to finish and/// collecting its exit status./// If any input/output handles are set to a pipe then they will be immediately/// closed after the child is spawned./// The destructor of the future returned by this function will kill/// the child if [`kill_on_drop`] is set to true./// [`kill_on_drop`]: fn@Self::kill_on_drop/// This future will return an error if the child process cannot be spawned/// or if there is an error while awaiting its status.///         .status()/// collecting all of its output./// > **Note**: this method, unlike the standard library, will/// > unconditionally configure the stdout/stderr handles to be pipes, even/// > if they have been previously configured. If this is not desired then/// > the `spawn` method should be used in combination with the/// > `wait_with_output` method on child./// This method will return a future representing the collection of the/// child process's stdout/stderr. It will resolve to/// the `Output` type in the standard library, containing `stdout` and/// `stderr` as `Vec<u8>` along with an `ExitStatus` representing how the/// process exited./// async fn run_ls() {///     let output: std::process::Output = Command::new("ls")///         .output()///         .expect("ls command failed to run");///     println!("stderr of ls: {:?}", output.stderr);get_kill_on_drop/// Returns the boolean value that was previously set by [`Command::kill_on_drop`]./// Note that if you have not previously called [`Command::kill_on_drop`], the/// default value of `false` will be returned here./// assert!(!cmd.get_kill_on_drop());/// assert!(cmd.get_kill_on_drop());ChildDropGuard/// A drop guard which can ensure the child process is killed on drop if specified.FusedChild/// Keeps track of the exit status of a child process without worrying about/// polling the underlying futures even after they have completed./// The handle for writing to the child's standard input (stdin), if it has/// been captured. To avoid partially moving the `child` and thus blocking/// yourself from calling functions on `child` while using `stdin`, you might/// find it helpful to do:/// # let mut child = tokio::process::Command::new("echo").spawn().unwrap();/// let stdin = child.stdin.take().unwrap();/// The handle for reading from the child's standard output (stdout), if it/// has been captured. You might find it helpful to do/// let stdout = child.stdout.take().unwrap();/// to avoid partially moving the `child` and thus blocking yourself from calling/// functions on `child` while using `stdout`./// The handle for reading from the child's standard error (stderr), if it/// let stderr = child.stderr.take().unwrap();/// functions on `child` while using `stderr`./// Representation of a child process spawned onto an event loop./// The `Command::kill_on_drop` method can be used to modify this behavior/// Returns the OS-assigned process identifier associated with this child/// while it is still running./// Once the child has been polled to completion this will return `None`./// This is done to avoid confusion on platforms like Unix where the OS/// identifier could be reused once the process has completed.start_kill/// Attempts to force the child to exit, but does not wait for the request/// to take effect./// On Unix platforms, this is the equivalent to sending a `SIGKILL`. Note/// that on Unix platforms it is possible for a zombie process to remain/// after a kill is sent; to avoid this, the caller should ensure that either/// `child.wait().await` or `child.try_wait()` is invoked successfully./// Forces the child to exit./// This is equivalent to sending a `SIGKILL` on unix platforms/// followed by [`wait`](Child::wait)./// Note: std version of [`Child::kill`](std::process::Child::kill) does not `wait`./// For an equivalent of `Child::kill` in the standard library,/// use [`start_kill`](Child::start_kill)./// If the child has to be killed remotely, it is possible to do it using/// a combination of the select! macro and a `oneshot` channel. In the following/// example, the child will run until completion unless a message is sent on/// the `oneshot` channel. If that happens, the child is killed immediately/// using the `.kill()` method./// use tokio::sync::oneshot::channel;///     let (send, recv) = channel::<()>();///     let mut child = Command::new("sleep").arg("1").spawn().unwrap();///     tokio::spawn(async move { send.send(()) });///     tokio::select! {///         _ = child.wait() => {}///         _ = recv => child.kill().await.expect("kill failed"),/// You can also interact with the child's standard I/O. For example, you can/// read its stdout while waiting for it to exit./// # use std::process::Stdio;/// # use tokio::process::Command;/// # use tokio::sync::oneshot::channel;///     let (_tx, rx) = channel::<()>();///     let mut child = Command::new("echo")///         .arg("Hello World!")///         .stdout(Stdio::piped())///     let mut stdout = child.stdout.take().expect("stdout is not captured");///     let read_stdout = tokio::spawn(async move {///         let mut buff = Vec::new();///         let _ = stdout.read_to_end(&mut buff).await;///         buff///         _ = rx => { child.kill().await.expect("kill failed") },///     let buff = read_stdout.await.unwrap();///     assert_eq!(buff, b"Hello World!\n");/// Waits for the child to exit completely, returning the status that it/// exited with. This function will continue to have the same return value/// after it has been called at least once./// The stdin handle to the child process, if any, will be closed/// before waiting. This helps avoid deadlock: it ensures that the/// child does not block waiting for input from the parent, while/// the parent waits for the child to exit./// If the caller wishes to explicitly control when the child's stdin/// handle is closed, they may `.take()` it before calling `.wait()`:/// This function is cancel safe./// # #[cfg(not(unix))]fn main(){}///     let mut child = Command::new("cat")///         .stdin(Stdio::piped())///     let mut stdin = child.stdin.take().unwrap();///     tokio::spawn(async move {///         // do something with stdin here...///         stdin.write_all(b"hello world\n").await.unwrap();///         // then drop when finished///         drop(stdin);///     // wait for the process to complete///     let _ = child.wait().await;/// Attempts to collect the exit status of the child if it has already/// exited./// This function will not block the calling thread and will only/// check to see if the child process has exited or not. If the child has/// exited then on Unix the process ID is reaped. This function is/// guaranteed to repeatedly return a successful exit status so long as the/// child has already exited./// If the child has exited, then `Ok(Some(status))` is returned. If the/// exit status is not available at this time then `Ok(None)` is returned./// If an error occurs, then that error is returned./// Note that unlike `wait`, this function will not attempt to drop stdin,/// nor will it wake the current task if the child exits.wait_with_output/// Returns a future that will resolve to an `Output`, containing the exit/// status, stdout, and stderr of the child process./// The returned future will simultaneously waits for the child to exit and/// collect all remaining output on the stdout/stderr handles, returning an/// `Output` instance./// The stdin handle to the child process, if any, will be closed before/// waiting. This helps avoid deadlock: it ensures that the child does not/// block waiting for input from the parent, while the parent waits for the/// child to exit./// By default, stdin, stdout and stderr are inherited from the parent. In/// order to capture the output into this `Output` it is necessary to create/// new pipes between parent and child. Use `stdout(Stdio::piped())` or/// `stderr(Stdio::piped())`, respectively, when creating a `Command`./// The standard input stream for spawned children./// This type implements the `AsyncWrite` trait to pass data to the stdin/// handle of a child process asynchronously./// The standard output stream for spawned children./// This type implements the `AsyncRead` trait to read data from the stdout/// The standard error stream for spawned children./// This type implements the `AsyncRead` trait to read data from the stderr/// Creates an asynchronous `ChildStdin` from a synchronous one./// This method may fail if an error is encountered when setting the pipe to/// non-blocking mode, or when registering the pipe with the runtime's IO/// driver./// Creates an asynchronous `ChildStdout` from a synchronous one./// Creates an asynchronous `ChildStderr` from a synchronous one.impl_traitsr" Convert into [`OwnedFd`]."into_owned_fdnum_killsnum_pollspoll_resultwith_resultkills_on_drop_if_specifiedno_kill_on_drop_by_defaultno_kill_if_already_killedno_kill_if_reaped//! An implementation of asynchronous process management for Tokio.//! This module provides a [`Command`] struct that imitates the interface of the//! [`std::process::Command`] type in the standard library, but provides asynchronous versions of//! functions that create processes. These functions (`spawn`, `status`, `output` and their//! variants) return "future aware" types that interoperate with Tokio. The asynchronous process//! support is provided through signal handling on Unix and system APIs on Windows.//! [`std::process::Command`]: std::process::Command//! Here's an example program which will spawn `echo hello world` and then wait//! for it complete.//! use tokio::process::Command;//!     // The usage is similar as with the standard library's `Command` type//!     let mut child = Command::new("echo")//!         .arg("hello")//!         .arg("world")//!         .spawn()//!         .expect("failed to spawn");//!     // Await until the command completes//!     let status = child.wait().await?;//!     println!("the command exited with: {}", status);//! Next, let's take a look at an example where we not only spawn `echo hello//! world` but we also capture its output.//!     // Like above, but use `output` which returns a future instead of//!     // immediately returning the `Child`.//!     let output = Command::new("echo").arg("hello").arg("world")//!                         .output();//!     let output = output.await?;//!     assert!(output.status.success());//!     assert_eq!(output.stdout, b"hello world\n");//! We can also read input line by line.//! use tokio::io::{BufReader, AsyncBufReadExt};//! use std::process::Stdio;//!     let mut cmd = Command::new("cat");//!     // Specify that we want the command's standard output piped back to us.//!     // By default, standard input/output/error will be inherited from the//!     // current process (for example, this means that standard input will//!     // come from the keyboard and standard output/error will go directly to//!     // the terminal if this process is invoked from the command line).//!     cmd.stdout(Stdio::piped());//!     let mut child = cmd.spawn()//!         .expect("failed to spawn command");//!     let stdout = child.stdout.take()//!         .expect("child did not have a handle to stdout");//!     let mut reader = BufReader::new(stdout).lines();//!     // Ensure the child process is spawned in the runtime so it can//!     // make progress on its own while we await for any output.//!     tokio::spawn(async move {//!         let status = child.wait().await//!             .expect("child process encountered an error");//!         println!("child status was: {}", status);//!     while let Some(line) = reader.next_line().await? {//!         println!("Line: {}", line);//! Here is another example using `sort` writing into the child process//! standard input, capturing the output of the sorted text.//!     let mut cmd = Command::new("sort");//!     // Specifying that we want pipe both the output and the input.//!     // Similarly to capturing the output, by configuring the pipe//!     // to stdin it can now be used as an asynchronous writer.//!     cmd.stdin(Stdio::piped());//!     let mut child = cmd.spawn().expect("failed to spawn command");//!     // These are the animals we want to sort//!     let animals: &[&str] = &["dog", "bird", "frog", "cat", "fish"];//!     let mut stdin = child//!         .stdin//!         .take()//!         .expect("child did not have a handle to stdin");//!     // Write our animals to the child process//!     // Note that the behavior of `sort` is to buffer _all input_ before writing any output.//!     // In the general sense, it is recommended to write to the child in a separate task as//!     // awaiting its exit (or output) to avoid deadlocks (for example, the child tries to write//!     // some output but gets stuck waiting on the parent to read from it, meanwhile the parent//!     // is stuck waiting to write its input completely before reading the output).//!     stdin//!         .write(animals.join("\n").as_bytes())//!         .await//!         .expect("could not write to stdin");//!     // We drop the handle here which signals EOF to the child process.//!     // This tells the child process that it there is no more data on the pipe.//!     drop(stdin);//!     let op = child.wait_with_output().await?;//!     // Results should come back in sorted order//!     assert_eq!(op.stdout, "bird\ncat\ndog\nfish\nfrog\n".as_bytes());//! With some coordination, we can also pipe the output of one command into//! another.//! use tokio::join;//!     let mut echo = Command::new("echo")//!         .arg("hello world!")//!         .stdout(Stdio::piped())//!         .expect("failed to spawn echo");//!     let tr_stdin: Stdio = echo//!         .stdout//!         .try_into()//!         .expect("failed to convert to Stdio");//!     let tr = Command::new("tr")//!         .arg("a-z")//!         .arg("A-Z")//!         .stdin(tr_stdin)//!         .expect("failed to spawn tr");//!     let (echo_result, tr_output) = join!(echo.wait(), tr.wait_with_output());//!     assert!(echo_result.unwrap().success());//!     let tr_output = tr_output.expect("failed to await tr");//!     assert!(tr_output.status.success());//!     assert_eq!(tr_output.stdout, b"HELLO WORLD!\n");//! # Caveats//! ## Dropping/Cancellation//! Similar to the behavior to the standard library, and unlike the futures//! paradigm of dropping-implies-cancellation, a spawned process will, by//! default, continue to execute even after the `Child` handle has been dropped.//! The [`Command::kill_on_drop`] method can be used to modify this behavior//! and kill the child process if the `Child` wrapper is dropped before it//! has exited.//! ## Unix Processes//! On Unix platforms processes must be "reaped" by their parent process after//! they have exited in order to release all OS resources. A child process which//! has exited, but has not yet been reaped by its parent is considered a "zombie"//! process. Such processes continue to count against limits imposed by the system,//! and having too many zombie processes present can prevent additional processes//! from being spawned.//! The tokio runtime will, on a best-effort basis, attempt to reap and clean up//! any process which it has spawned. No additional guarantees are made with regard to//! how quickly or how often this procedure will take place.//! It is recommended to avoid dropping a [`Child`] process handle before it has been//! fully `await`ed if stricter cleanup guarantees are required.//! [`Command`]: crate::process::Command//! [`Command::kill_on_drop`]: crate::process::Command::kill_on_drop//! [`Child`]: crate::process::ChildorphanOrphanQueueOrphanQueueImplpidfd_reaperSignalHandleSignalKindStdChildget_orphan_queueGlobalOrphanQueuereap_orphanspush_orphanSignalReaperPidfdReaperspawn_childstd_child// Actually a pipe is not a File. However, we are reusing `File` to get// close on drop. This is a similar trick as `mio`.convert_to_blocking_fileconvert_to_stdio//! Unix handling of child processes.//! Right now the only "fancy" thing about this is how we implement the//! `Future` implementation on `Child` to get the exit status. Unix offers//! no way to register a child with epoll, and the only real way to get a//! notification when a process exits is the SIGCHLD signal.//! Signal handling in general is *super* hairy and complicated, and it's even//! more complicated here with the fact that signals are coalesced, so we may//! not get a SIGCHLD-per-child.//! Our best approximation here is to check *all spawned processes* for all//! SIGCHLD signals received. To do that we create a `Signal`, implemented in//! the `tokio-net` crate, which is a stream over signals being received.//! Later when we poll the process's exit status we simply check to see if a//! SIGCHLD has happened since we last checked, and while that returns "yes" we//! keep trying.//! Note that this means that this isn't really scalable, but then again//! processes in general aren't scalable (e.g. millions) so it shouldn't be that//! bad in theory...signal_with_handle/// Get the identifier for this process or diagnostics./// Try waiting for a process to exit in a non-blocking manner./// An interface for waiting on a process to exit./// Adds an orphan to the queue./// An interface for queueing up an orphaned process so that it can be reaped.sigchild/// An implementation of `OrphanQueue`./// Attempts to reap every process in the queue, ignoring any errors and/// enqueueing any orphans which have not yet exited.drain_orphan_queueIoDriverSignalDriverExitStatusExtall_enqueuedMockQueuetotal_waitsnum_wait_until_statusreturn_errMockWaitdrain_attempts_a_single_reap_of_all_queued_orphansno_reap_if_no_signal_receivedno_reap_if_signal_lock_helddoes_not_register_signal_if_queue_empty// Miri does not support epoll.does_nothing_if_signal_could_not_be_registeredRUNTIME_SHUTTING_DOWN_ERRORPidfdPidfdReaperInneris_rt_shutdown_errorphan_queueRuntimeBuildercreate_runtimerun_testis_pidfd_availabletest_pidfd_reaper_polltest_pidfd_reaper_killtest_pidfd_reaper_dropInternalStream/// Orchestrates between registering interest for receiving signals when a/// child process has exited, and attempting to poll for process completion.total_killstotal_pollsdrop_reaps_if_possibledrop_enqueues_orphan_if_wait_failsUnregisterWaitExWT_EXECUTEINWAITTHREADwait_object// Used for accessing the raw handle, even if the io version is busy// For doing I/O operations asynchronouslyinto_owned_handleconvert_to_fileduplicate_handle//! Windows asynchronous process handling.//! Like with Unix we don't actually have a way of registering a process with an//! IOCP object. As a result we similarly need another mechanism for getting a//! signal when a process has exited. For now this is implemented with the//! `RegisterWaitForSingleObject` function in the kernel32.dll.//! This strategy is the same that libuv takes and essentially just queues up a//! wait for the process in a kernel32-specific thread pool. Once the object is//! notified (e.g. the process exits) then we have a callback that basically//! just completes a `Oneshot`.//! The `poll_exit` implementation will attempt to wait for the process in a//! nonblocking fashion, but failing that it'll fire off a//! `RegisterWaitForSingleObject` and then wait on the other end of the oneshot//! from then on out.BlockingPoolBlockingTaskcreate_blocking_pool//! Abstracts out the APIs necessary to `Runtime` for integrating the blocking//! pool. When the `blocking` feature flag is **not** enabled, these APIs are//! shells. This isolates the complexity of dealing with conditional//! compilation.BlockingScheduleThreadNameFnBOX_FUTURE_THRESHOLDmetric_atomicsMetricAtomicUsizeblocking_taskSpawnMetashutdown_rxnum_idle_threadsqueue_depthSpawnerMetricsinc_num_threadsdec_num_threadsinc_num_idle_threadsdec_num_idle_threadsinc_queue_depthdec_queue_depth/// State shared between worker threads./// Pool threads wait on this./// Spawned threads use this name./// Spawned thread stack size./// Call after a thread starts./// Call before a thread stops.thread_cap// Maximum number of threads.// Customizable wait timeout.// Metrics about the pool.num_notifyshutdown_txlast_exiting_thread/// Prior to shutdown, we clean up `JoinHandles` by having each timed-out/// thread join on the previous timed-out thread. This is not strictly/// necessary but helps avoid Valgrind false positives, see/// <https://github.com/tokio-rs/tokio/commit/646fbae76535e397ef79dbcaacb945d4c829f666>worker_threads/// This holds the `JoinHandles` for all running threads; on shutdown, the thread/// calling shutdown handles joining on these./// This is a counter used to iterate `worker_threads` in a consistent order (for loom's/// benefit).UnownedTaskmandatoryNonMandatory/// Pool is shutting down and the task was not scheduledNoThreads/// There are no worker threads available to take the task/// and the OS failed to spawn a new oneshutdown_or_run_if_mandatoryKEEP_ALIVE/// Runs the provided function on an executor dedicated to blocking operations./// Tasks will be scheduled as non-mandatory, meaning they may not get executed/// in case of runtime shutdown.r" Runs the provided function on an executor dedicated to blocking"r" operations. Tasks will be scheduled as mandatory, meaning they are"r" guaranteed to run unless a shutdown is already taking place. In case a"r" shutdown is already taking place, `None` will be returned."spawn_blocking_innerspawn_taskis_temporary_os_thread_error// Tells whether the error when spawning a thread is temporary.//! Thread pool for blocking operations// ===== impl BlockingPool =====// ===== impl Spawner =====TaskHarnessScheduleHooks/// `task::Schedule` implementation that does nothing (except some bookkeeping/// in test-util builds). This is unique to the blocking scheduler as tasks/// scheduled are not really futures but blocking operations./// We avoid storing the task by forgetting it in `bind` and re-materializing it/// in `release`._tx/// Blocks the current thread until all `Sender` handles drop./// If `timeout` is `Some`, the thread is blocked for **at most** `timeout`/// duration. If `timeout` is `None`, then the thread is blocked until the/// shutdown signal is received./// If the timeout has elapsed, it returns `false`, otherwise it returns `true`.//! A shutdown channel.//! Each worker holds the `Sender` half. When all the `Sender` halves are//! dropped, the `Receiver` receives a notification./// Converts a function to a future that completes on poll./// Initializes a new blocking task from the given function.// The closure `F` is never pinnedHistogramBuilderRngSeedRngSeedGeneratorCurrentThread/// Runtime typeenable_io/// Whether or not to enable the I/O driverneventsenable_time/// Whether or not to enable the time driverstart_paused/// Whether or not the clock should start paused./// The number of worker threads, used by Runtime./// Only used when not using the current-thread executor.max_blocking_threads/// Cap on thread usage./// Name fn used for threads spawned by the runtime./// Stack size used for threads spawned by the runtime./// Callback to run after each thread starts./// To run before each worker thread stopsbefore_park/// To run before each worker thread is parked.after_unpark/// To run after each thread is unparked.before_spawn/// To run before each task is spawned.after_termination/// To run after each task is terminated./// Customizable keep alive timeout for `BlockingPool`global_queue_interval/// How many ticks before pulling a task from the global/remote queue?/// When `None`, the value is unspecified and behavior details are left to/// the scheduler. Each scheduler flavor could choose to either pick its own/// default value or use some other strategy to decide when to poll from the/// global queue. For example, the multi-threaded scheduler uses a/// self-tuning strategy based on mean task poll times.event_interval/// How many ticks before yielding to the driver for timer and I/O events?local_queue_capacitydisable_lifo_slot/// When true, the multi-threade scheduler LIFO slot should not be used./// This option should only be exposed as unstable.seed_generator/// Specify a random number generator seed to provide deterministic resultsmetrics_poll_count_histogram_enable/// When true, enables task poll count histogram instrumentation.metrics_poll_count_histogram/// Configures the task poll count histogram/// Builds Tokio Runtime with custom configuration values./// Methods can be chained in order to set the configuration values. The/// Runtime is constructed by calling [`build`]./// New instances of `Builder` are obtained via [`Builder::new_multi_thread`]/// or [`Builder::new_current_thread`]./// See function level documentation for details on the various configuration/// [`build`]: method@Self::build/// [`Builder::new_multi_thread`]: method@Self::new_multi_thread/// [`Builder::new_current_thread`]: method@Self::new_current_thread/// use tokio::runtime::Builder;///     // build runtime///     let runtime = Builder::new_multi_thread()///         .worker_threads(4)///         .thread_name("my-custom-name")///         .thread_stack_size(3 * 1024 * 1024)///     // use runtime ...new_current_thread/// Returns a new builder with the current thread scheduler selected./// Configuration methods can be chained on the return value./// To spawn non-`Send` tasks on the resulting runtime, combine it with a/// [`LocalSet`]./// [`LocalSet`]: crate::task::LocalSetnew_multi_thread/// Returns a new builder with the multi thread scheduler selected./// Returns a new runtime builder initialized with default configurationenable_all/// Enables both I/O and time drivers./// Doing this is a shorthand for calling `enable_io` and `enable_time`/// individually. If additional components are added to Tokio in the future,/// `enable_all` will include these future components./// use tokio::runtime;/// let rt = runtime::Builder::new_multi_thread()///     .enable_all()/// Sets the number of worker threads the `Runtime` will use./// This can be any number above 0 though it is advised to keep this value/// on the smaller side./// This will override the value read from environment variable `TOKIO_WORKER_THREADS`./// # Default/// The default value is the number of cores available to the system./// When using the `current_thread` runtime this method has no effect./// ## Multi threaded runtime with 4 threads/// // This will spawn a work-stealing runtime with 4 worker threads.///     .worker_threads(4)/// rt.spawn(async move {});/// ## Current thread runtime (will only run on the current thread via `Runtime::block_on`)/// // Create a runtime that _must_ be driven from a call/// // to `Runtime::block_on`./// let rt = runtime::Builder::new_current_thread()/// // This will run the runtime and future on the current thread/// rt.block_on(async move {});/// This will panic if `val` is not larger than `0`./// Specifies the limit for additional threads spawned by the Runtime./// These threads are used for blocking operations like tasks spawned/// through [`spawn_blocking`], this includes but is not limited to:/// - [`fs`] operations/// - dns resolution through [`ToSocketAddrs`]/// - writing to [`Stdout`] or [`Stderr`]/// - reading from [`Stdin`]/// Unlike the [`worker_threads`], they are not always active and will exit/// if left idle for too long. You can change this timeout duration with [`thread_keep_alive`]./// It's recommended to not set this limit too low in order to avoid hanging on operations/// requiring [`spawn_blocking`]./// The default value is 512./// # Upgrading from 0.x/// In old versions `max_threads` limited both blocking and worker threads, but the/// current `max_blocking_threads` does not include async worker threads in the count./// [`spawn_blocking`]: fn@crate::task::spawn_blocking/// [`fs`]: mod@crate::fs/// [`ToSocketAddrs`]: trait@crate::net::ToSocketAddrs/// [`Stdout`]: struct@crate::io::Stdout/// [`Stdin`]: struct@crate::io::Stdin/// [`Stderr`]: struct@crate::io::Stderr/// [`worker_threads`]: Self::worker_threads/// [`thread_keep_alive`]: Self::thread_keep_alive/// Sets name of threads spawned by the `Runtime`'s thread pool./// The default name is "tokio-runtime-worker"./// # use tokio::runtime;///     .thread_name("my-pool")thread_name_fn/// Sets a function used to generate the name of threads spawned by the `Runtime`'s thread pool./// The default name fn is `|| "tokio-runtime-worker".into()`./// # use std::sync::atomic::{AtomicUsize, Ordering};///     .thread_name_fn(|| {///        static ATOMIC_ID: AtomicUsize = AtomicUsize::new(0);///        let id = ATOMIC_ID.fetch_add(1, Ordering::SeqCst);///        format!("my-pool-{}", id)/// Sets the stack size (in bytes) for worker threads./// The actual stack size may be greater than this value if the platform/// specifies minimal stack size./// The default stack size for spawned threads is 2 MiB, though this/// particular stack size is subject to change in the future.///     .thread_stack_size(32 * 1024)on_thread_start/// Executes function `f` after each thread is started but before it starts/// doing work./// This is intended for bookkeeping and monitoring use cases./// let runtime = runtime::Builder::new_multi_thread()///     .on_thread_start(|| {///         println!("thread started");on_thread_stop/// Executes function `f` before each thread stops.///     .on_thread_stop(|| {///         println!("thread stopping");on_thread_park/// Executes function `f` just before a thread is parked (goes idle)./// `f` is called within the Tokio context, so functions like [`tokio::spawn`](crate::spawn)/// can be called, and may result in this thread being unparked immediately./// This can be used to start work only when the executor is idle, or for bookkeeping/// and monitoring purposes./// Note: There can only be one park callback for a runtime; calling this function/// more than once replaces the last callback defined, rather than adding to it./// ## Multithreaded executor/// # use tokio::sync::Barrier;/// let once = AtomicBool::new(true);/// let barrier = Arc::new(Barrier::new(2));///     .worker_threads(1)///     .on_thread_park({///         let barrier = barrier.clone();///         move || {///             let barrier = barrier.clone();///             if once.swap(false, Ordering::Relaxed) {///                 tokio::spawn(async move { barrier.wait().await; });/// runtime.block_on(async {///    barrier.wait().await;/// ## Current thread executor/// let runtime = runtime::Builder::new_current_thread()on_thread_unpark/// Executes function `f` just after a thread unparks (starts executing tasks)./// This is intended for bookkeeping and monitoring use cases; note that work/// in this callback will increase latencies when the application has allowed one or/// more runtime threads to go idle./// Note: There can only be one unpark callback for a runtime; calling this function///     .on_thread_unpark(|| {///         println!("thread unparking");/// runtime.unwrap().block_on(async {///    tokio::task::yield_now().await;///    println!("Hello from Tokio!");/// Creates the configured `Runtime`./// The returned `Runtime` instance is ready to spawn tasks./// let rt  = Builder::new_multi_thread().build().unwrap();/// rt.block_on(async {///     println!("Hello from the Tokio runtime");get_cfgthread_keep_alive/// Sets a custom timeout for a thread in the blocking pool./// By default, the timeout for a thread is set to 10 seconds. This can/// be overridden using `.thread_keep_alive()`.///     .thread_keep_alive(Duration::from_millis(100))/// Sets the number of scheduler ticks after which the scheduler will poll the global/// task queue./// A scheduler "tick" roughly corresponds to one `poll` invocation on a task./// By default the global queue interval is 31 for the current-thread scheduler. Please see/// [the module documentation] for the default behavior of the multi-thread scheduler./// Schedulers have a local queue of already-claimed tasks, and a global queue of incoming/// tasks. Setting the interval to a smaller value increases the fairness of the scheduler,/// at the cost of more synchronization overhead. That can be beneficial for prioritizing/// getting started on new work, especially if tasks frequently yield rather than complete/// or await on further I/O. Conversely, a higher value prioritizes existing work, and/// is a good choice when most tasks quickly complete polling./// [the module documentation]: crate::runtime#multi-threaded-runtime-behavior-at-the-time-of-writing/// This function will panic if 0 is passed as an argument.///     .global_queue_interval(31)/// Sets the number of scheduler ticks after which the scheduler will poll for/// external events (timers, I/O, and so on)./// By default, the event interval is `61` for all scheduler types./// Setting the event interval determines the effective "priority" of delivering/// these external events (which may wake up additional tasks), compared to/// executing tasks that are currently ready to run. A smaller value is useful/// when tasks frequently spend a long time in polling, or frequently yield,/// which can result in overly long delays picking up I/O events. Conversely,/// picking up new events requires extra synchronization and syscall overhead,/// so if tasks generally complete their polling quickly, a higher event interval/// will minimize that overhead while still keeping the scheduler responsive to///     .event_interval(31)build_current_thread_runtimebuild_current_thread_runtime_componentsmetrics_poll_count_histogram_builderr" Enables the I/O driver."r" Doing this enables using net, process, signal, and some I/O types on"r" the runtime."r" use tokio::runtime;"r" let rt = runtime::Builder::new_multi_thread()"r"     .enable_io()"r"     .build()"r" Enables the I/O driver and configures the max number of events to be"r" processed per tick."r" let rt = runtime::Builder::new_current_thread()"r"     .max_io_events_per_tick(1024)"max_io_events_per_tickr" Enables the time driver."r" Doing this enables using `tokio::time` on the runtime."r"     .enable_time()"build_threaded_runtime/// How big to make each worker's local queue/// Callback for a worker parking itself/// Callback for a worker unparking itself/// The multi-threaded scheduler includes a per-worker LIFO slot used to/// store the last scheduled task. This can improve certain usage patterns,/// especially message passing between tasks. However, this LIFO slot is not/// currently stealable./// Eventually, the LIFO slot **will** become stealable, however as a/// stop-gap, this unstable option lets users disable the LIFO task./// Random number generator seed to configure runtimes to act in a/// deterministic way./// How to build poll time histogramsEnterRuntimeNotSendOrSyncBlockingRegionGuard/// Guard tracking that a caller has entered a blocking region.DisallowBlockInPlaceGuardtry_enter_blocking_regiondisallow_block_in_place/// Disallows blocking in the current runtime context until the guard is dropped./// Blocks the thread on the specified future, returning the value with/// which that future completes.block_on_timeout/// Blocks the thread on the specified future for **at most** `timeout`/// If the future completes before `timeout`, the result is returned. If/// `timeout` elapses, then `Err` is returned.TryCurrentErrorSyncNotSend// The previous handle// The depth for this guard// Don't let the type move across threads.SetCurrentGuard/// Current handle/// Tracks the number of nested calls to `try_set_current`.HandleCelltry_set_current/// Sets this [`Handle`] as the current active [`Handle`]./// [`Handle`]: crate::runtime::scheduler::Handlewith_currentFastRandallow_block_in_placeEntered/// Currently in a runtime context.NotEntered/// Not in a runtime context **or** a blocking region./// Tracks that the current thread has entered a blocking function call.// Only tracking the guard.old_seed// Tracks the previous random number generator seedEnterRuntimeGuard/// Guard tracking that a caller has entered a runtime context.enter_runtimeis_enteredcurrent_enter_context/// Returns true if in a runtime context.exit_runtime/// Forces the current "entered" state to be cleared while the closure/// is executed./// Scoped thread-local storage/// Inserts a value into the scoped cell for the duration of the closure/// Gets the value out of the scoped cell;coopruntime_mt/// Uniquely identifies the current thread/// Handle to the runtime scheduler running on the current thread./// Handle to the scheduler's internal "context"current_task_id/// Tracks if the current thread is currently driving a runtime./// Note, that if this is set to "entered", the current scheduler/// handle may not reference the runtime currently executing. This/// is because other runtime handles may be set to current from/// within a runtime./// Tracks the amount of "work" a task may still do before yielding back to/// the schedulerset_current_task_idset_schedulerwith_schedulerParkThreadUnparkThreadTimeDriverIoHandle/// IO driver handle/// Signal driver handleTimeHandle/// Time driver handle/// Source of `Instant::now()`enable_pause_timer" Returns a reference to the time driver handle."r" Panics if no time driver is present."IoStackProcessDrivercreate_io_stackcreate_signal_drivercreate_process_drivercreate_clockcreate_time_driver//! Abstracts out the entire chain of runtime sub-drivers into common types.// Eventually, this file will see significant refactoring / cleanup. For now, we// don't need to worry much about dead code with certain feature permutations.// ===== io driver =====// ===== signal driver =====// ===== process driver =====// ===== time driver =====Tasks/// A snapshot of a runtime's state./// See [`Handle::dump`][crate::runtime::Handle::dump]./// Snapshots of tasks./// A snapshot of a task./// Represents an address that should not be dereferenced./// This type exists to get the auto traits correct, the public API/// uses raw pointers to make life easier for users.// Safe since Address should not be dereferencedname_demangled/// A backtrace symbol./// This struct provides accessors for backtrace symbols, similar to [`backtrace::BacktraceSymbol`].from_backtrace_symbolname_raw/// Return the raw name of the symbol./// Return the demangled name of the symbol./// Returns the starting address of this symbol./// Returns the file name where this function was defined. If debuginfo/// is missing, this is likely to return None./// If debuginfo is missing, this is likely to return `None`./// A backtrace frame./// This struct represents one stack frame in a captured backtrace, similar to [`backtrace::BacktraceFrame`].from_resolved_backtrace_frame/// Return the instruction pointer of this frame./// See the ABI docs for your platform for the exact meaning./// Return an iterator over the symbols of this backtrace frame./// Due to inlining, it is possible for there to be multiple [`BacktraceSymbol`] items relating/// to a single frame. The first symbol listed is the "innermost function",/// whereas the last symbol is the outermost (last caller)./// A captured backtrace./// This struct provides access to each backtrace frame, similar to [`backtrace::Backtrace`]./// Return the frames in this backtrace, innermost (in a task dump,/// likely to be a leaf future's poll function) first./// An execution trace of a task's last poll./// Resolving a backtrace, either via the [`Display`][std::fmt::Display] impl or via/// [`resolve_backtraces`][Trace::resolve_backtraces], parses debuginfo, which is/// possibly a CPU-expensive operation that can take a platform-specific but/// long time to run - often over 100 milliseconds, especially if the current/// process's binary is big. In some cases, the platform might internally cache some of the/// debuginfo, so successive calls to `resolve_backtraces` might be faster than/// the first call, but all guarantees are platform-dependent./// To avoid blocking the runtime, it is recommended/// that you resolve backtraces inside of a [`spawn_blocking()`][crate::task::spawn_blocking]/// and to have some concurrency-limiting mechanism to avoid unexpected performance impact.resolve_backtraces/// Resolve and return a list of backtraces that are involved in polls in this trace./// The exact backtraces included here are unstable and might change in the future,/// but you can expect one [`Backtrace`] for every call to/// [`poll`] to a bottom-level Tokio future - so if something like [`join!`] is/// used, there will be a backtrace for each future in the join./// [`poll`]: std::future::Future::poll/// [`join!`]: macro@join/// Runs the function `f` in tracing mode, and returns its result along with the resulting [`Trace`]./// This is normally called with `f` being the poll function of a future, and will give you a backtrace/// that tells you what that one future is doing./// Use [`Handle::dump`] instead if you want to know what *all the tasks* in your program are doing./// Also see [`Handle::dump`] for more documentation about dumps, but unlike [`Handle::dump`], this function/// should not be much slower than calling `f` directly./// Due to the way tracing is implemented, Tokio leaf futures will usually, instead of doing their/// actual work, do the equivalent of a `yield_now` (returning a `Poll::Pending` and scheduling the/// current context for execution), which means forward progress will probably not happen unless/// you eventually call your future outside of `capture`./// [`Handle::dump`]: crate::runtime::Handle::dump/// use std::task::Poll;/// use tokio::runtime::dump::Trace;/// # async fn test_fn() {/// // some future/// let mut test_future = std::pin::pin!(async move { tokio::task::yield_now().await; 0 });/// // trace it once, see what it's doing/// let (trace, res) = Trace::root(std::future::poll_fn(|cx| {///     let (res, trace) = Trace::capture(|| test_future.as_mut().poll(cx));///     Poll::Ready((trace, res))/// })).await;/// // await it to let it finish, outside of a `capture`/// let output = match res {///    Poll::Ready(output) => output,///    Poll::Pending => test_future.await,/// println!("{trace}");/// ### Nested calls/// Nested calls to `capture` might return partial traces, but will not do any other undesirable behavior (for/// example, they will not panic)./// Create a root for stack traces captured using [`Trace::capture`]. Stack frames above/// the root will not be captured./// Nesting multiple [`Root`] futures is fine. Captures will stop at the first root. Not having/// a [`Root`] is fine as well, but there is no guarantee on where the capture will stop./// Tasks in this snapshot./// Iterate over tasks./// Returns a [task ID] that uniquely identifies this task relative to other/// tasks spawned at the time of the dump./// **Note**: This is an [unstable API][unstable]. The public API of this type/// may break in 1.x releases. See [the documentation on unstable/// features][unstable] for details./// [task ID]: crate::task::Id/// [unstable]: crate#unstable-features/// A trace of this task's state.//! Snapshots of runtime state.//! See [`Handle::dump`][crate::runtime::Handle::dump].RuntimeFlavorRuntimeMetrics/// Handle to the runtime./// The handle is internally reference-counted and can be freely cloned. A handle can be/// obtained using the [`Runtime::handle`] method./// [`Runtime::handle`]: crate::runtime::Runtime::handle()// When the `rt` feature is *not* enabled, this type is still defined, but not// included in the public API.CONTEXT_MISSING_ERRORTHREAD_LOCAL_DESTROYED_ERROR"Creating and dropping a guard does nothing"_handle_lifetimeEnterGuard/// Runtime context guard./// Returned by [`Runtime::enter`] and [`Handle::enter`], the context guard exits/// the runtime context on drop./// [`Runtime::enter`]: fn@crate::runtime::Runtime::enter/// Enters the runtime context. This allows you to construct types that must/// have an executor available on creation such as [`Sleep`] or/// [`TcpStream`]. It will also allow you to call methods such as/// [`tokio::spawn`] and [`Handle::current`] without panicking./// When calling `Handle::enter` multiple times, the returned guards/// **must** be dropped in the reverse order that they were acquired./// Failure to do so will result in a panic and possible memory leaks./// use tokio::runtime::Runtime;/// let rt = Runtime::new().unwrap();/// let _guard = rt.enter();/// tokio::spawn(async {/// Do **not** do the following, this shows a scenario that will result in a/// panic and possible memory leak./// let rt1 = Runtime::new().unwrap();/// let rt2 = Runtime::new().unwrap();/// let enter1 = rt1.enter();/// let enter2 = rt2.enter();/// drop(enter1);/// drop(enter2);/// [`Sleep`]: struct@crate::time::Sleep/// [`tokio::spawn`]: fn@crate::spawn/// Returns a `Handle` view over the currently running `Runtime`./// This will panic if called outside the context of a Tokio runtime. That means that you must/// call this on one of the threads **being run by the runtime**, or from a thread with an active/// `EnterGuard`. Calling this from within a thread created by `std::thread::spawn` (for example)/// will cause a panic unless that thread has an active `EnterGuard`./// This can be used to obtain the handle of the surrounding runtime from an async/// block or function running on that runtime./// # use tokio::runtime::Runtime;/// # fn dox() {/// # let rt = Runtime::new().unwrap();/// # rt.spawn(async {/// use tokio::runtime::Handle;/// // Inside an async block or function./// let handle = Handle::current();/// handle.spawn(async {///     println!("now running in the existing Runtime");/// # let handle =///     // Notice that the handle is created outside of this thread and then moved in///     handle.spawn(async { /* ... */ });///     // This next line would cause a panic because we haven't entered the runtime///     // and created an EnterGuard///     // let handle2 = Handle::current(); // panic///     // So we create a guard here with Handle::enter();///     let _guard = handle.enter();///     // Now we can call Handle::current();///     let handle2 = Handle::current();try_current/// Returns a Handle view over the currently running Runtime/// Returns an error if no Runtime has been started/// Contrary to `current`, this never panics/// Spawns a future onto the Tokio runtime./// This spawns the given future onto the runtime's executor, usually a/// thread pool. The thread pool is then responsible for polling the future/// until it completes./// The provided future will start running in the background immediately/// when `spawn` is called, even if you don't await the returned/// `JoinHandle`./// See [module level][mod] documentation for more details./// [mod]: index.html/// // Create the runtime/// // Get a handle from this runtime/// let handle = rt.handle();/// // Spawn a future onto the runtime using the handle///     println!("now running on a worker thread");/// Runs the provided function on an executor dedicated to blocking/// // Spawn a blocking function onto the runtime using the handle/// handle.spawn_blocking(|| {/// Runs a future to completion on this `Handle`'s associated `Runtime`./// This runs the given future on the current thread, blocking until it is/// complete, and yielding its resolved result. Any tasks or timers which/// the future spawns internally will be executed on the runtime./// When this is used on a `current_thread` runtime, only the/// [`Runtime::block_on`] method can drive the IO and timer drivers, but the/// `Handle::block_on` method cannot drive them. This means that, when using/// this method on a `current_thread` runtime, anything that relies on IO or/// timers will not work unless there is another thread currently calling/// [`Runtime::block_on`] on the same runtime./// # If the runtime has been shut down/// If the `Handle`'s associated `Runtime` has been shut down (through/// [`Runtime::shutdown_background`], [`Runtime::shutdown_timeout`], or by/// dropping it) and `Handle::block_on` is used it might return an error or/// panic. Specifically IO resources will return an error and timers will/// panic. Runtime independent futures will run as normal./// This function panics if the provided future panics, if called within an/// asynchronous execution context, or if a timer future is executed on a runtime that has been/// shut down./// let rt  = Runtime::new().unwrap();/// // Execute the future, blocking the current thread until completion/// handle.block_on(async {///     println!("hello");/// Or using `Handle::current`:/// async fn main () {///     let handle = Handle::current();///         // Using Handle::block_on to run async code in the new thread.///         handle.block_on(async {///             println!("hello");/// [`JoinError`]: struct@crate::task::JoinError/// [`JoinHandle`]: struct@crate::task::JoinHandle/// [`Runtime::block_on`]: fn@crate::runtime::Runtime::block_on/// [`Runtime::shutdown_background`]: fn@crate::runtime::Runtime::shutdown_background/// [`Runtime::shutdown_timeout`]: fn@crate::runtime::Runtime::shutdown_timeout/// [`tokio::fs`]: crate::fs/// [`tokio::net`]: crate::net/// [`tokio::time`]: crate::timeblock_on_innerspawn_namedspawn_local_namedruntime_flavor/// Returns the flavor of the current `Runtime`./// use tokio::runtime::{Handle, RuntimeFlavor};/// #[tokio::main(flavor = "current_thread")]///   assert_eq!(RuntimeFlavor::CurrentThread, Handle::current().runtime_flavor());/// #[tokio::main(flavor = "multi_thread", worker_threads = 4)]///   assert_eq!(RuntimeFlavor::MultiThread, Handle::current().runtime_flavor());/// Returns a view that lets you get information about how the runtime/// is performing.TryCurrentErrorKind/// Error returned by `try_current` when no Runtime has been startednew_no_contextnew_thread_local_destroyedis_missing_context/// Returns true if the call failed because there is currently no runtime in/// the Tokio context.is_thread_local_destroyed/// Returns true if the call failed because the Tokio context thread-local/// had been destroyed. This can usually only happen if in the destructor of/// other thread-locals.NoContextThreadLocalDestroyed/// An opaque ID that uniquely identifies a runtime relative to all other currently/// running runtimes./// - Runtime IDs are unique relative to other *currently running* runtimes.///   When a runtime completes, the same ID may be used for another runtime./// - Runtime IDs are *not* sequential, and do not indicate the order in which///   runtimes are started or any other data./// - The runtime ID of the currently running task can be obtained from the///   Handle.///   println!("Current runtime id: {}", Handle::current().id());TOKEN_SIGNALregister_signal_receiverconsume_signal_ready// Signal handlingregistration_setIoDriverMetricsRegistrationSetScheduledIosignal_ready/// True when an event with the signal token is received/// Reuse the `mio::Events` value across calls to poll./// The system event queue./// I/O driver, backed by Mio.registrations/// Tracks all registrationssyncedSynced/// State that should be synchronized/// Used to wake up the reactor from a call to `turn`./// Not supported on `Wasi` due to lack of threading support./// A reference to an I/O driver.with_readyTOKEN_WAKEUP_assert_kinds/// Creates a new event loop, returning any error that happened during the/// creation./// Forces a reactor blocked in a call to `turn` to wakeup, or otherwise/// makes the next call to `turn` return immediately./// This method is intended to be used in situations where a notification/// needs to otherwise be sent to the main reactor. If the reactor is/// currently blocked inside of `turn` then it will wake up and soon return/// after this method has been called. If the reactor is not currently/// blocked in `turn`, then the next call to `turn` will not block and/// return immediately./// Registers an I/O resource with the reactor for a given `mio::Ready` state./// The registration token is returned.deregister_source/// Deregisters an I/O resource from the reactor.release_pending_registrations// ===== impl Driver =====incr_fd_countdec_fd_countincr_ready_count_by//! This file contains mocks of the metrics types used in the I/O driver.//! The reason these mocks don't live in `src/runtime/mock.rs` is because//! these need to be available in the case when `net` is enabled but//! `rt` is not.scheduled_ioptr_exposePtrExposeDomainEXPOSE_IOr" Associates an I/O resource with the reactor instance that drives it."r" A registration represents an I/O resource registered with a Reactor such"r" that it will receive task notifications on readiness. This is the lowest"r" level API for integrating with a reactor."r" The association between an I/O resource is made by calling"r" [`new_with_interest_and_handle`]."r" Once the association is established, it remains established until the"r" registration instance is dropped."r" A registration instance represents two separate readiness streams. One"r" for the read readiness and one for write readiness. These streams are"r" independent and can be consumed from separate tasks."r" **Note**: while `Registration` is `Sync`, the caller must ensure that"r" there are at most two tasks that use a registration instance"r" concurrently. One task for [`poll_read_ready`] and one task for"r#" [`poll_write_ready`]. While violating this requirement is "safe" from a"#r" Rust memory safety point of view, it will result in unexpected behavior"r" in the form of lost notifications and tasks hanging."r" `Registration` also allows receiving platform-specific `mio::Ready`"r" events. These events are included as part of the read readiness event"r" stream. The write readiness event stream is only for `Ready::writable()`"r" events."r" [`new_with_interest_and_handle`]: method@Self::new_with_interest_and_handle"r" [`poll_read_ready`]: method@Self::poll_read_ready`"r" [`poll_write_ready`]: method@Self::poll_write_ready`"r" Handle to the associated runtime."r" TODO: this can probably be moved into `ScheduledIo`."r" Reference to state stored by the driver."/// Registers the I/O resource with the reactor for the provided handle, for/// a specific `Interest`. This does not add `hup` or `error` so if you are/// interested in those states, you will need to add them to the readiness/// state passed to this function./// - `Ok` if the registration happened successfully/// - `Err` if an error was encountered during registration/// Deregisters the I/O resource from the reactor it is associated with./// This function must be called before the I/O resource associated with the/// registration is dropped./// Note that deregistering does not guarantee that the I/O resource can be/// registered with a different reactor. Some I/O resource types can only be/// associated with a single reactor instance for their lifetime./// If the deregistration was successful, `Ok` is returned. Any calls to/// `Reactor::turn` that happen after a successful call to `deregister` will/// no longer result in notifications getting sent for this registration./// `Err` is returned if an error is encountered.clear_readiness// Uses the poll path, requiring the caller to ensure mutual exclusion for// correctness. Only the last task to call this function is notified.poll_read_iopoll_write_io/// Polls for events on the I/O resource's `direction` readiness stream./// If called with a task context, notify the task when a new event ispoll_iogone// ===== impl Registration =====NOTIFY_AFTER// Kind of arbitrary, but buffering 16 `ScheduledIo`s doesn't seem like muchnum_pending_release// True when the I/O driver shutdown. At this point, no more registrations// should be added to the set.// List of all registrations tracked by the setpending_release// Registrations that are pending drop. When a `Registration` is dropped, it// stores its `ScheduledIo` in this list. The I/O driver is responsible for// dropping it. This ensures the `ScheduledIo` is not freed while it can// still be included in an I/O event.needs_release/// Returns `true` if there are registrations that need to be released// Returns `true` if the caller should unblock the I/O driver to purge// registrations pending release.// This function is marked as unsafe, because the caller must make sure that// `io` is part of the registration set.pointersPointers// Safety: `Arc` pins the inner dataWakeListlinked_list_pointers/// Packs the resource's readiness and I/O driver latest tick.Waiters/// Stored in the I/O driver resource slab.// # This struct should be cache padded to avoid false sharing. The cache padding rules are copied// from crossbeam-utils/src/cache_padded.rs// x86, riscv, wasm, and sparc64 have 64-byte cache line size.WaitList/// List of all current waiters./// Waker used for `AsyncRead`./// Waker used for `AsyncWrite`./// The waker for this task./// The interest this waiter is waiting on./// Should never be `!Unpin`.addr_of_pointers/// Entry in the waiter `LinkedList`./// Future returned by `readiness()`.READINESSTICK/// Invoked when the IO driver is shut down; forces this `ScheduledIo` into a/// permanently shutdown state.set_readiness/// Sets the readiness on this `ScheduledIo` by invoking the given closure on/// the current value, returning the previous readiness value./// - `tick`: whether setting the tick or trying to clear readiness for a///    specific tick./// - `f`: a closure returning a new readiness value given the previous///   readiness./// Notifies all pending waiters that have registered interest in `ready`./// There may be many waiters to notify. Waking the pending task **must** be/// done from outside of the lock otherwise there is a potential for a/// A stack array of wakers is created and filled with wakers to notify, the/// lock is released, and the wakers are notified. Because there may be more/// than 32 wakers to notify, if the stack array fills up, the lock is/// released, the array is cleared, and the iteration continues.ready_eventpoll_readiness/// Polls for readiness events in a given direction./// These are to support `AsyncRead` and `AsyncWrite` polling methods,/// which cannot use the `async fn` version. This uses reserved reader/// and writer slots.clear_wakers/// An async version of `poll_readiness` which uses a linked list of wakers.readiness_fut// This is in a separate function so that the borrow checker doesn't think// we are borrowing the `UnsafeCell` possibly over await boundaries.// Go figure.// The `ScheduledIo::readiness` (`AtomicUsize`) is packed full of goodness.// | shutdown | driver tick | readiness |// |----------+-------------+-----------|// |   1 bit  |  15 bits    +   16 bits |// ===== impl ScheduledIo =====// ===== impl Readiness =====LocalOptionsLocalRuntimeLocalRuntimeScheduler/// Marker used to make this !Send and !Sync./// `LocalRuntime`-only config options/// Currently, there are no such options, but in the future, things like `!Send + !Sync` hooks may/// be added./// Task scheduler/// Handle to runtime, also contains driver handlesblocking_pool/// Blocking pool handle, used to signal shutdown/// A local Tokio runtime./// This runtime is capable of driving tasks which are not `Send + Sync` without the use of a/// `LocalSet`, and thus supports `spawn_local` without the need for a `LocalSet` context./// This runtime cannot be moved between threads or driven from different threads./// This runtime is incompatible with `LocalSet`. You should not attempt to drive a `LocalSet` within a/// `LocalRuntime`./// Currently, this runtime supports one flavor, which is internally identical to `current_thread`,/// save for the aforementioned differences related to `spawn_local`./// For more general information on how to use runtimes, see the [module] docs./// [runtime]: crate::runtime::Runtime/// [module]: crate::runtime/// Execute all tasks on the current-thread./// The runtime scheduler is always a `current_thread` scheduler right now./// Creates a new local runtime instance with default configuration values./// This results in the scheduler, I/O driver, and time driver being/// When a more complex configuration is necessary, the [runtime builder] may be used./// Creating a new `LocalRuntime` with default configuration values./// use tokio::runtime::LocalRuntime;/// let rt = LocalRuntime::new()/// // Use the runtime.../// [mod]: crate::runtime/// [runtime builder]: crate::runtime::Builder/// Returns a handle to the runtime's spawner./// The returned handle can be used to spawn tasks that run on this runtime, and can/// be cloned to allow moving the `Handle` to other threads./// As the handle can be sent to other threads, it can only be used to spawn tasks that are `Send`./// Calling [`Handle::block_on`] on a handle to a `LocalRuntime` is error-prone./// Refer to the documentation of [`Handle::block_on`] for more./// // Use the handle.../// Spawns a task on the runtime./// This is analogous to the [`spawn`] method on the standard [`Runtime`], but works even if the task is not thread-safe./// [`spawn`]: crate::runtime::Runtime::spawn/// [`Runtime`]: crate::runtime::Runtime/// let rt = LocalRuntime::new().unwrap();/// // Spawn a future onto the runtime/// rt.spawn_local(async {/// Runs the provided function on a thread from a dedicated blocking thread pool./// This function _will_ be run on another thread./// See the [documentation in the non-local runtime][Runtime] for more/// [Runtime]: crate::runtime::Runtime::spawn_blocking/// // Spawn a blocking function onto the runtime/// rt.spawn_blocking(|| {/// Runs a future to completion on the Tokio runtime. This is the/// runtime's entry point./// See the documentation for [the equivalent method on Runtime][Runtime]/// [Runtime]: crate::runtime::Runtime::block_on/// let rt  = LocalRuntime::new().unwrap();/// Enters the runtime context./// This allows you to construct types that must have an executor/// available on creation such as [`Sleep`] or [`TcpStream`]. It will/// also allow you to call methods such as [`tokio::spawn`]./// If this is a handle to a [`LocalRuntime`], and this function is being invoked from the same/// thread that the runtime was created on, you will also be able to call/// [`tokio::task::spawn_local`]./// [`LocalRuntime`]: struct@crate::runtime::LocalRuntime/// [`tokio::task::spawn_local`]: fn@crate::task::spawn_local/// use tokio::task::JoinHandle;/// fn function_that_spawns(msg: String) -> JoinHandle<()> {///     // Had we not used `rt.enter` below, this would panic.///         println!("{}", msg);///     let rt = LocalRuntime::new().unwrap();///     let s = "Hello World!".to_string();///     // By entering the context, we tie `tokio::spawn` to this executor.///     let _guard = rt.enter();///     let handle = function_that_spawns(s);///     // Wait for the task before we end the test.///     rt.block_on(handle).unwrap();shutdown_timeout/// Shuts down the runtime, waiting for at most `duration` for all spawned/// work to stop./// Note that `spawn_blocking` tasks, and only `spawn_blocking` tasks, can get left behind if/// the timeout expires./// See the [struct level documentation](LocalRuntime#shutdown) for more details./// use tokio::task;///    let runtime = LocalRuntime::new().unwrap();///    runtime.block_on(async move {///        task::spawn_blocking(move || {///            thread::sleep(Duration::from_secs(10_000));///    runtime.shutdown_timeout(Duration::from_millis(100));shutdown_background/// Shuts down the runtime, without waiting for any spawned work to stop./// This can be useful if you want to drop a runtime from within another runtime./// Normally, dropping a runtime will block indefinitely for spawned blocking tasks/// to complete, which would normally not be permitted within an asynchronous context./// By calling `shutdown_background()`, you can drop the runtime from such a context./// Note however, that because we do not wait for any blocking tasks to complete, this/// may result in a resource leak (in that any blocking tasks are still running until they/// return. No other tasks will leak./// This function is equivalent to calling `shutdown_timeout(Duration::from_nanos(0))`.///        let inner_runtime = LocalRuntime::new().unwrap();///        // ...///        inner_runtime.shutdown_background();// there are comments in the error branch, so we don't want if-letHistogramBatchWorkerMetricspark_count/// Number of times the worker parked.park_unpark_count/// Number of times the worker parked and unparked.noop_count/// Number of times the worker woke w/o doing work.steal_count/// Number of tasks stolen.steal_operations/// Number of times tasks where stolen.poll_count/// Number of tasks that were polled by the worker.poll_count_on_last_park/// Number of tasks polled when the worker entered park. This is used to/// track the noop count.local_schedule_count/// Number of tasks that were scheduled locally on this worker./// Number of tasks moved to the global queue to make space in the local/// queuebusy_duration_total/// The total busy duration in nanoseconds.processing_scheduled_tasks_started_at/// Instant at which work last resumed (continued after park).poll_timerPollTimer/// If `Some`, tracks poll times in nanosecondsMetricsBatchpoll_counts/// Histogram of poll counts within each band.poll_started_at/// Instant when the most recent task started polling.about_to_park/// The worker is about to park./// The worker was unparked.start_processing_scheduled_tasks/// Start processing a batch of tasksend_processing_scheduled_tasks/// Stop processing a batch of tasks/// Start polling an individual taskend_poll/// Stop polling an individual taskinc_local_schedule_countduration_as_u64DEFAULT_PRECISION/// Default precision is 2^-2 = 25% max errorMAX_PRECISION/// Number of buckets in the histogram/// Precision of histogram. Error is bounded to 2^-p.bucket_offset/// All buckets `idx < bucket_offset` are grouped into bucket 0./// This increases the smallest measurable value of the histogram.LogHistogram/// Log Histogram/// This implements an [H2 Histogram](https://iop.systems/blog/h2-histogram/), a histogram similar/// to HdrHistogram, but with better performance. It guarantees an error bound of `2^-p`./// Unlike a traditional H2 histogram this has two small changes:/// 1. The 0th bucket runs for `0..min_value`. This allows truncating a large number of buckets that///    would cover extremely short timescales that customers usually don't care about./// 2. The final bucket runs all the way to `u64::MAX` — traditional H2 histograms would truncate///    or reject these values./// For information about the default configuration, see [`LogHistogramBuilder`].from_n_p/// Create a Histogram configuration directly from values for `n` and `p`./// - If `bucket_offset` is greater than the specified number of buckets, `(n - p + 1) * 2^p`truncate_to_max_valueLogHistogramBuilder/// Creates a builder for [`LogHistogram`]/// The maximum value that can be stored before truncation in this histogramvalue_to_bucketbucket_range/// Configuration for a [`LogHistogram`]/// The log-scaled histogram implements an H2 histogram where the first bucket covers/// the range from 0 to [`LogHistogramBuilder::min_value`] and the final bucket covers/// [`LogHistogramBuilder::max_value`] to infinity. The precision is bounded to the specified/// [`LogHistogramBuilder::max_error`]. Specifically, the precision is the next smallest value/// of `2^-p` such that it is smaller than the requested max error. You can also select `p` directly/// with [`LogHistogramBuilder::precision_exact`]./// Depending on the selected parameters, the number of buckets required is variable. To ensure/// that the histogram size is acceptable, callers may call [`LogHistogramBuilder::max_buckets`]./// If the resulting histogram would require more buckets, then the method will return an error./// ## Default values/// The default configuration provides the following settings:/// 1. `min_value`: 100ns/// 2. `max_value`: 68 seconds. The final bucket covers all values >68 seconds/// 3. `precision`: max error of 25%/// This uses 237 64-bit buckets.max_error/// Set the precision for this histogram/// This function determines the smallest value of `p` that would satisfy the requested precision/// such that `2^-p` is less than `precision`. To set `p` directly, use/// [`LogHistogramBuilder::precision_exact`]./// Precision controls the size of the "bucket groups" (consecutive buckets with identical/// ranges). When `p` is 0, each bucket will be twice the size of the previous bucket. To match/// the behavior of the legacy log histogram implementation, use `builder.precision_exact(0)`./// The default value is 25% (2^-2)/// The highest supported precision is `0.0977%` `(2^-10)`. Provided values/// less than this will be truncated./// - `max_error` < 0/// - `max_error` > 1precision_exact/// Sets the precision of this histogram directly./// The precision (meaning: the ratio `n/bucket_range(n)` for some given `n`) will be `2^-p`./// Precision controls the number consecutive buckets with identically sized ranges./// When `p` is 0, each bucket will be twice the size of the previous bucket (bucket groups are/// only a single bucket wide)./// To match the behavior of the legacy implementation ([`HistogramScale::Log`]), use `builder.precision_exact(0)`./// - `p` > 10/// [`HistogramScale::Log`]: [crate::runtime::HistogramScale]/// Sets the minimum duration that can be accurately stored by this histogram./// This sets the resolution. The first bucket will be no larger than/// the provided duration. Setting this value will reduce the number of required buckets,/// sometimes quite significantly./// Sets the maximum value that can by this histogram without truncation/// Values greater than this fall in the final bucket that stretches to `u64::MAX`./// The provided value is 0max_bucketsInvalidHistogramConfiguration/// Builds the log histogram, enforcing the max buckets requirement/// Builds the log histogramrequired_bucket_count/// The number of buckets that would have been requiredTooManyBuckets/// This histogram required more than the specified number of buckets/// Error constructing a histogram/// Compute the index for a given value + p combination/// This function does NOT enforce that the value is within the number of expected buckets.h2_histogramvalid_log_histogram_strategylog_histogram_settings// test against a wide assortment of different histogram configurations to ensure invariants holdproptestsbucket_ranges_are_correctbucket_computation_spot_check// test buckets against known valueslast_bucket_goes_to_infinitymax_buckets_enforcementdefault_configuration_sizeMetricAtomicU64/// The histogram bucketshistogram_type/// The type of the histogram/// This handles `fn(bucket) -> Range` and `fn(value) -> bucket`HistogramLegacyBuilderHistogramScaleLinearHistogram/// Linear histogram with fixed width bucketsLegacyLogHistogramLogLegacy/// Old log histogram where each bucket doubles in size/// Log histogram implementation based on H2 Histogramsbucket_widthfirst_bucket_widthfrom_histogrammeasurelegacy_mutassert_bucket_eqtest_legacy_builderlog_scale_resolution_1log_scale_resolution_2linear_scale_resolution_1linear_scale_resolution_100inc_by_more_than_onefd_registered_countfd_deregistered_countready_countSchedulerMetricsinc_remote_schedule_count/// Increment the number of tasks scheduled externallyset_queue_depthset_thread_idincr_steal_countincr_steal_operationsincr_overflow_count//! This file contains mocks of the types in src/runtime/metrics//! This module contains information need to view information about how the//! runtime is performing.//! **Note**: This is an [unstable API][unstable]. The public API of types in//! this module may break in 1.x releases. See [the documentation on unstable//! features][unstable] for details.//! [unstable]: crate#unstable-features/// Handle to the runtime's metrics./// This handle is internally reference-counted and can be freely cloned. A/// `RuntimeMetrics` handle is obtained using the [`Runtime::metrics`] method./// [`Runtime::metrics`]: crate::runtime::Runtime::metrics()num_workers/// Returns the number of worker threads used by the runtime./// The number of workers is set by configuring `worker_threads` on/// `runtime::Builder`. When using the `current_thread` runtime, the return/// value is always `1`.///     let metrics = Handle::current().metrics();///     let n = metrics.num_workers();///     println!("Runtime is using {} workers", n);num_alive_tasks/// Returns the current number of alive tasks in the runtime./// This counter increases when a task is spawned and decreases when a/// task exits.///    let metrics = Handle::current().metrics();///     let n = metrics.num_alive_tasks();///     println!("Runtime has {} alive tasks", n);global_queue_depth/// Returns the number of tasks currently scheduled in the runtime's/// Tasks that are spawned or notified from a non-runtime thread are/// scheduled using the runtime's global queue. This metric returns the/// **current** number of tasks pending in the global queue. As such, the/// returned value may increase or decrease as new tasks are scheduled and///     let n = metrics.global_queue_depth();///     println!("{} tasks currently pending in the runtime's global queue", n);remote_schedule_count/// Number of tasks that are scheduled from outside the runtime.budget_forced_yield_count/// Retrieves metrics from the Tokio runtime.inc_budget_forced_yield_count/// Increment the number of tasks forced to yield due to budget exhaustion///  Number of times the worker parked.///  Number of times the worker parked and unparked./// Number of times the worker woke then parked again without doing work./// Number of tasks the worker stole./// Number of times the worker stole/// Number of tasks the worker polled.mean_poll_time/// EWMA task poll time, in nanoseconds./// Amount of time the worker spent doing work vs. parking./// Number of tasks scheduled for execution on the worker's local queue./// Number of tasks moved from the local queue to the global queue to free space./// Number of tasks currently in the local queue. Used only by the/// current-thread scheduler.poll_count_histogram/// If `Some`, tracks the number of polls by duration range./// Thread id of worker thread./// Retrieve runtime worker metrics.// At the top due to macrostask_hooksTaskHooksTaskMetar" Boundary value to prevent stack overflow caused by a large-sized"r" Future being placed in the stack."r" After thread starts / before thread stops"//! The Tokio runtime.//! Unlike other Rust programs, asynchronous applications require runtime//! support. In particular, the following runtime services are necessary://! * An **I/O event loop**, called the driver, which drives I/O resources and//!   dispatches I/O events to tasks that depend on them.//! * A **scheduler** to execute [tasks] that use these I/O resources.//! * A **timer** for scheduling work to run after a set period of time.//! Tokio's [`Runtime`] bundles all of these services as a single type, allowing//! them to be started, shut down, and configured together. However, often it is//! not required to configure a [`Runtime`] manually, and a user may just use the//! [`tokio::main`] attribute macro, which creates a [`Runtime`] under the hood.//! When no fine tuning is required, the [`tokio::main`] attribute macro can be//!                         println!("failed to read from socket; err = {:?}", e);//!                     println!("failed to write to socket; err = {:?}", e);//! From within the context of the runtime, additional tasks are spawned using//! the [`tokio::spawn`] function. Futures spawned using this function will be//! executed on the same thread pool used by the [`Runtime`].//! A [`Runtime`] instance can also be used directly.//! use tokio::runtime::Runtime;//! fn main() -> Result<(), Box<dyn std::error::Error>> {//!     // Create the runtime//!     let rt  = Runtime::new()?;//!     // Spawn the root task//!     rt.block_on(async {//!         let listener = TcpListener::bind("127.0.0.1:8080").await?;//!             let (mut socket, _) = listener.accept().await?;//!             tokio::spawn(async move {//!                 let mut buf = [0; 1024];//!                 // In a loop, read data from the socket and write the data back.//!                 loop {//!                     let n = match socket.read(&mut buf).await {//!                         // socket closed//!                         Ok(0) => return,//!                         Ok(n) => n,//!                         Err(e) => {//!                             println!("failed to read from socket; err = {:?}", e);//!                             return;//!                     };//!                     // Write the data back//!                     if let Err(e) = socket.write_all(&buf[0..n]).await {//!                         println!("failed to write to socket; err = {:?}", e);//! ## Runtime Configurations//! Tokio provides multiple task scheduling strategies, suitable for different//! applications. The [runtime builder] or `#[tokio::main]` attribute may be//! used to select which scheduler to use.//! #### Multi-Thread Scheduler//! The multi-thread scheduler executes futures on a _thread pool_, using a//! work-stealing strategy. By default, it will start a worker thread for each//! CPU core available on the system. This tends to be the ideal configuration//! for most applications. The multi-thread scheduler requires the `rt-multi-thread`//! feature flag, and is selected by default://! use tokio::runtime;//! let threaded_rt = runtime::Runtime::new()?;//! Most applications should use the multi-thread scheduler, except in some//! niche use-cases, such as when running only a single thread is required.//! #### Current-Thread Scheduler//! The current-thread scheduler provides a _single-threaded_ future executor.//! All tasks will be created and executed on the current thread. This requires//! the `rt` feature flag.//! let rt = runtime::Builder::new_current_thread()//!     .build()?;//! #### Resource drivers//! When configuring a runtime by hand, no resource drivers are enabled by//! default. In this case, attempting to use networking types or time types will//! fail. In order to enable these types, the resource drivers must be enabled.//! This is done with [`Builder::enable_io`] and [`Builder::enable_time`]. As a//! shorthand, [`Builder::enable_all`] enables both resource drivers.//! ## Lifetime of spawned threads//! The runtime may spawn threads depending on its configuration and usage. The//! multi-thread scheduler spawns threads to schedule tasks and for `spawn_blocking`//! calls.//! While the `Runtime` is active, threads may shut down after periods of being//! idle. Once `Runtime` is dropped, all runtime threads have usually been//! terminated, but in the presence of unstoppable spawned work are not//! guaranteed to have been terminated. See the//! [struct level documentation](Runtime#shutdown) for more details.//! [tasks]: crate::task//! [`Runtime`]: Runtime//! [`tokio::spawn`]: crate::spawn//! [`tokio::main`]: ../attr.main.html//! [runtime builder]: crate::runtime::Builder//! [`Runtime::new`]: crate::runtime::Runtime::new//! [`Builder::threaded_scheduler`]: crate::runtime::Builder::threaded_scheduler//! [`Builder::enable_io`]: crate::runtime::Builder::enable_io//! [`Builder::enable_time`]: crate::runtime::Builder::enable_time//! [`Builder::enable_all`]: crate::runtime::Builder::enable_all//! # Detailed runtime behavior//! This section gives more details into how the Tokio runtime will schedule//! tasks for execution.//! At its most basic level, a runtime has a collection of tasks that need to be//! scheduled. It will repeatedly remove a task from that collection and//! schedule it (by calling [`poll`]). When the collection is empty, the thread//! will go to sleep until a task is added to the collection.//! However, the above is not sufficient to guarantee a well-behaved runtime.//! For example, the runtime might have a single task that is always ready to be//! scheduled, and schedule that task every time. This is a problem because it//! starves other tasks by not scheduling them. To solve this, Tokio provides//! the following fairness guarantee://! > If the total number of tasks does not grow without bound, and no task is//! > [blocking the thread], then it is guaranteed that tasks are scheduled//! > fairly.//! Or, more formally://! > Under the following two assumptions://! > * There is some number `MAX_TASKS` such that the total number of tasks on//! >   the runtime at any specific point in time never exceeds `MAX_TASKS`.//! > * There is some number `MAX_SCHEDULE` such that calling [`poll`] on any//! >   task spawned on the runtime returns within `MAX_SCHEDULE` time units.//! > Then, there is some number `MAX_DELAY` such that when a task is woken, it//! > will be scheduled by the runtime within `MAX_DELAY` time units.//! (Here, `MAX_TASKS` and `MAX_SCHEDULE` can be any number and the user of//! the runtime may choose them. The `MAX_DELAY` number is controlled by the//! runtime, and depends on the value of `MAX_TASKS` and `MAX_SCHEDULE`.)//! Other than the above fairness guarantee, there is no guarantee about the//! order in which tasks are scheduled. There is also no guarantee that the//! runtime is equally fair to all tasks. For example, if the runtime has two//! tasks A and B that are both ready, then the runtime may schedule A five//! times before it schedules B. This is the case even if A yields using//! [`yield_now`]. All that is guaranteed is that it will schedule B eventually.//! Normally, tasks are scheduled only if they have been woken by calling//! [`wake`] on their waker. However, this is not guaranteed, and Tokio may//! schedule tasks that have not been woken under some circumstances. This is//! called a spurious wakeup.//! ## IO and timers//! Beyond just scheduling tasks, the runtime must also manage IO resources and//! timers. It does this by periodically checking whether there are any IO//! resources or timers that are ready, and waking the relevant task so that//! it will be scheduled.//! These checks are performed periodically between scheduling tasks. Under the//! same assumptions as the previous fairness guarantee, Tokio guarantees that//! it will wake tasks with an IO or timer event within some maximum number of//! time units.//! ## Current thread runtime (behavior at the time of writing)//! This section describes how the [current thread runtime] behaves today. This//! behavior may change in future versions of Tokio.//! The current thread runtime maintains two FIFO queues of tasks that are ready//! to be scheduled: the global queue and the local queue. The runtime will prefer//! to choose the next task to schedule from the local queue, and will only pick a//! task from the global queue if the local queue is empty, or if it has picked//! a task from the local queue 31 times in a row. The number 31 can be//! changed using the [`global_queue_interval`] setting.//! The runtime will check for new IO or timer events whenever there are no//! tasks ready to be scheduled, or when it has scheduled 61 tasks in a row. The//! number 61 may be changed using the [`event_interval`] setting.//! When a task is woken from within a task running on the runtime, then the//! woken task is added directly to the local queue. Otherwise, the task is//! added to the global queue. The current thread runtime does not use [the lifo//! slot optimization].//! ## Multi threaded runtime (behavior at the time of writing)//! This section describes how the [multi thread runtime] behaves today. This//! A multi thread runtime has a fixed number of worker threads, which are all//! created on startup. The multi thread runtime maintains one global queue, and//! a local queue for each worker thread. The local queue of a worker thread can//! fit at most 256 tasks. If more than 256 tasks are added to the local queue,//! then half of them are moved to the global queue to make space.//! The runtime will prefer to choose the next task to schedule from the local//! queue, and will only pick a task from the global queue if the local queue is//! empty, or if it has picked a task from the local queue//! [`global_queue_interval`] times in a row. If the value of//! [`global_queue_interval`] is not explicitly set using the runtime builder,//! then the runtime will dynamically compute it using a heuristic that targets//! 10ms intervals between each check of the global queue (based on the//! [`worker_mean_poll_time`] metric).//! If both the local queue and global queue is empty, then the worker thread//! will attempt to steal tasks from the local queue of another worker thread.//! Stealing is done by moving half of the tasks in one local queue to another//! local queue.//! The multi thread runtime uses [the lifo slot optimization]: Whenever a task//! wakes up another task, the other task is added to the worker thread's lifo//! slot instead of being added to a queue. If there was already a task in the//! lifo slot when this happened, then the lifo slot is replaced, and the task//! that used to be in the lifo slot is placed in the thread's local queue.//! When the runtime finishes scheduling a task, it will schedule the task in//! the lifo slot immediately, if any. When the lifo slot is used, the [coop//! budget] is not reset. Furthermore, if a worker thread uses the lifo slot//! three times in a row, it is temporarily disabled until the worker thread has//! scheduled a task that didn't come from the lifo slot. The lifo slot can be//! disabled using the [`disable_lifo_slot`] setting. The lifo slot is separate//! from the local queue, so other worker threads cannot steal the task in the//! lifo slot.//! When a task is woken from a thread that is not a worker thread, then the//! task is placed in the global queue.//! [`poll`]: std::future::Future::poll//! [`wake`]: std::task::Waker::wake//! [`yield_now`]: crate::task::yield_now//! [blocking the thread]: https://ryhl.io/blog/async-what-is-blocking///! [current thread runtime]: crate::runtime::Builder::new_current_thread//! [multi thread runtime]: crate::runtime::Builder::new_multi_thread//! [`global_queue_interval`]: crate::runtime::Builder::global_queue_interval//! [`event_interval`]: crate::runtime::Builder::event_interval//! [`disable_lifo_slot`]: crate::runtime::Builder::disable_lifo_slot//! [the lifo slot optimization]: crate::runtime::Builder::disable_lifo_slot//! [coop budget]: crate::task::coop#cooperative-scheduling//! [`worker_mean_poll_time`]: crate::runtime::RuntimeMetrics::worker_mean_poll_time/// Unblocks a thread that was blocked by `ParkThread`.CURRENT_PARKER/// Parks the current thread for at most `dur`._anchorCachedParkThread/// Blocks the current thread using a condition variable./// Creates a new `ParkThread` handle for the current thread./// This type cannot be moved to other threads, so it should be created on/// the thread that the caller intends to park./// Gets a reference to the `ParkThread` handle for this thread.into_wakerunparker_to_raw_waker// ==== impl ParkThread ====// ==== impl Inner ====// ===== impl UnparkThread =====signal_handle/// Responsible for cleaning up orphaned child processes on Unix platforms./// Creates a new signal `Driver` instance that delegates wakeups to `park`.//! Process driver./// The Tokio runtime./// The runtime provides an I/O driver, task scheduler, [timer], and/// blocking pool, necessary for running asynchronous tasks./// Instances of `Runtime` can be created using [`new`], or [`Builder`]./// However, most users will use the [`#[tokio::main]`][main] annotation on/// their entry point instead./// # Shutdown/// Shutting down the runtime is done by dropping the value, or calling/// [`shutdown_background`] or [`shutdown_timeout`]./// Tasks spawned through [`Runtime::spawn`] keep running until they yield./// Then they are dropped. They are not *guaranteed* to run to completion, but/// *might* do so if they do not yield until completion./// Blocking functions spawned through [`Runtime::spawn_blocking`] keep running/// until they return./// The thread initiating the shutdown blocks until all spawned work has been/// stopped. This can take an indefinite amount of time. The `Drop`/// implementation waits forever for this./// The [`shutdown_background`] and [`shutdown_timeout`] methods can be used if/// waiting forever is undesired. When the timeout is reached, spawned work that/// did not stop in time and threads running it are leaked. The work continues/// to run until one of the stopping conditions is fulfilled, but the thread/// initiating the shutdown is unblocked./// Once the runtime has been dropped, any outstanding I/O resources bound to/// it will no longer function. Calling any method on them will result in an/// There are several ways to establish shared access to a Tokio runtime:///  * Using an <code>[Arc]\<Runtime></code>.///  * Using a [`Handle`].///  * Entering the runtime context./// Using an <code>[Arc]\<Runtime></code> or [`Handle`] allows you to do various/// things with the runtime such as spawning new tasks or entering the runtime/// context. Both types can be cloned to create a new handle that allows access/// to the same runtime. By passing clones into different tasks or threads, you/// will be able to access the runtime from those tasks or threads./// The difference between <code>[Arc]\<Runtime></code> and [`Handle`] is that/// an <code>[Arc]\<Runtime></code> will prevent the runtime from shutting down,/// whereas a [`Handle`] does not prevent that. This is because shutdown of the/// runtime happens when the destructor of the `Runtime` object runs./// Calls to [`shutdown_background`] and [`shutdown_timeout`] require exclusive/// ownership of the `Runtime` type. When using an <code>[Arc]\<Runtime></code>,/// this can be achieved via [`Arc::try_unwrap`] when only one strong count/// reference is left over./// The runtime context is entered using the [`Runtime::enter`] or/// [`Handle::enter`] methods, which use a thread-local variable to store the/// current runtime. Whenever you are inside the runtime context, methods such/// as [`tokio::spawn`] will use the runtime whose context you are inside./// [timer]: crate::time/// [`new`]: method@Self::new/// [`Builder`]: struct@Builder/// [`Handle`]: struct@Handle/// [main]: macro@crate::main/// [`tokio::spawn`]: crate::spawn/// [`Arc::try_unwrap`]: std::sync::Arc::try_unwrap/// [`shutdown_background`]: method@Runtime::shutdown_background/// [`shutdown_timeout`]: method@Runtime::shutdown_timeout/// The flavor that executes all tasks on the current thread./// The flavor that executes tasks across multiple threads./// The flavor of a `Runtime`./// This is the return type for [`Handle::runtime_flavor`](crate::runtime::Handle::runtime_flavor())./// Execute tasks across multiple threads./// The runtime scheduler is either a multi-thread or a current-thread executor./// Creates a new runtime instance with default configuration values./// This results in the multi threaded scheduler, I/O driver, and time driver being/// Most applications will not need to call this function directly. Instead,/// they will use the  [`#[tokio::main]` attribute][main]. When a more complex/// configuration is necessary, the [runtime builder] may be used./// Creating a new `Runtime` with default configuration values./// let rt = Runtime::new()/// [main]: ../attr.main.html/// [threaded scheduler]: index.html#threaded-scheduler/// Calling [`Handle::block_on`] on a handle to a `current_thread` runtime is error-prone./// rt.spawn(async {/// complete, and yielding its resolved result. Any tasks or timers/// which the future spawns internally will be executed on the runtime./// # Non-worker future/// Note that the future required by this function does not run as a/// worker. The expectation is that other tasks are spawned by the future here./// Awaiting on other futures from the future provided here will not/// perform as fast as those spawned as workers./// # Multi thread scheduler/// When the multi thread scheduler is used this will allow futures/// to run within the io driver and timer context of the overall runtime./// Any spawned tasks will continue running after `block_on` returns./// # Current thread scheduler/// When the current thread scheduler is enabled `block_on`/// can be called concurrently from multiple threads. The first call/// will take ownership of the io and timer drivers. This means/// other threads which do not own the drivers will hook into that one./// When the first `block_on` completes, other threads will be able to/// "steal" the driver to allow continued execution of their futures./// Any spawned tasks will be suspended after `block_on` returns. Calling/// `block_on` again will resume previously spawned tasks./// This function panics if the provided future panics, or if called within an/// asynchronous execution context./// [handle]: fn@Handle::block_on///     let rt = Runtime::new().unwrap();/// See the [struct level documentation](Runtime#shutdown) for more details./// # if cfg!(miri) { return } // Miri reports error when main thread terminated without waiting all remaining threads.///    let runtime = Runtime::new().unwrap();/// return.///        let inner_runtime = Runtime::new().unwrap();block_in_placeDeferInjectOwnedTasks/// Core scheduler data is acquired by a thread entering `block_on`./// Notifier for waking up other threads to steal the/// Executes tasks on the current thread/// Scheduler state shared across threads/// Resource driver handlesblocking_spawner/// Blocking pool spawner/// Current random number generator seed/// User-supplied hooks to invoke for thingslocal_tid/// If this is a `LocalRuntime`, flags the owning thread ID./// Handle to the current thread scheduler/// Scheduler run queue/// Current tick/// Runtime driver/// The driver is removed before starting to park the thread/// Metrics batch/// How often to check the global queueunhandled_panic/// True if a task panicked without being handled and the runtime is/// configured to shutdown on unhandled panic./// Data required for executing the scheduler. The struct is passed around to/// a function that will perform the scheduling work and acts as a capability token./// Remote run queue/// Collection of all active tasks spawned onto this executor./// Indicates whether the blocked on thread was woken./// Scheduler configuration optionsscheduler_metrics/// Keeps track of various runtime metrics.worker_metrics/// This scheduler only has one worker./// Scheduler state shared between threads./// Scheduler handle/// Scheduler core, enabling the holder of `Context` to execute the/// Deferred tasks, usually ones that called `task::yield_now()`./// Thread-local context./// pub(crate) to store in `runtime::context`.INITIAL_CAPACITY/// Initial queue capacity.DEFAULT_GLOBAL_QUEUE_INTERVAL/// Used if none is specified. This is a temporary constant and will be removed/// as we unify tuning logic between the multi-thread and current-thread/// schedulers.take_coreCoreGuardshutdown2/// Get and increment the current ticknext_tasknext_local_taskpush_tasksubmit_metricsrun_task/// Execute the closure with the given scheduler core stored in the/// thread-local context./// Blocks the current thread until an event is received by the driver,/// including I/O events, timer events, ...park_yield/// Checks the driver for new events without blocking the thread./// Spawns a future onto the `CurrentThread` scheduler/// Spawn a task which isn't safe to send across thread boundaries onto the runtime./// This should only be used when this is a `LocalRuntime` or in another case where the runtime/// provably cannot be driven from or moved to different threads from the one on which the task/// is spawned.next_remote_taskreset_woken// reset woken to false and return original valueinjection_queue_depth/// Wake by reference/// Used to ensure we always place the `Core` value back into its slot in/// `CurrentThread`, even if the future panics./// Enters the scheduler context. This sets the queue and other necessary/// scheduler state in the thread-local.// ===== impl Core =====// ===== impl Context =====// ===== impl Handle =====// ===== CoreGuard =====Poppush_batch/// Pushes several values into the queue./// Must be called with the same `Synced` instance returned by `Inject::new`push_batch_inner/// Inserts several tasks that have been linked together into the queue./// The provided head and tail may be be the same task. In this case, a/// single task is inserted./// Number of pending tasks in the queue. This helps prevent unnecessary/// locking in the hot path.// Kind of annoying to have to include the cfg here/// Closes the injection queue, returns `true` if the queue is open when the/// transition is made./// Pushes a value into the queue./// This does nothing if the queue is closed./// Pop a value from the queue.pop_n/// Pop `n` values from the queue/// True if the queue is closed./// Linked-list head./// Linked-list tail.rt_multi_thread/// Growable, MPMC queue used to inject new tasks into the scheduler and as an/// overflow queue when the local, fixed-size, array queue overflows.//! Inject queue used to send wakeups to a work-stealing scheduler/// A lock (mutex) yielding generic data.multi_threadmatch_flavorr" Returns true if this is a local runtime and the runtime is owned by the current thread."can_spawn_local_on_local_runtimer" Spawn a local task"r" This should only be called in `LocalRuntime` if the runtime has been verified to be owned"r" by the current thread."as_current_threadexpect_current_threadexpect_multi_threadinc_num_inc_notify_localinc_num_unparks_localinc_num_maintenanceinc_lifo_schedulesinc_lifo_capped/// Task spawner/// Handle to the multi thread scheduler/// Spawns a future onto the thread poolbind_new_task/// Tracks both the number of searching workers and the number of unparked/// workers./// Used as a fast-path to avoid acquiring the lock when needed./// Total number of workers./// Sleeping workers/// Data synchronized by the scheduler mutexUNPARK_SHIFTUNPARK_MASKSEARCH_MASKworker_to_notify/// If there are no workers actively searching, returns the index of a/// worker currently sleeping.transition_worker_to_parked/// Returns `true` if the worker needs to do a final check for submittedtransition_worker_to_searchingtransition_worker_from_searching/// A lightweight transition from searching -> running./// Returns `true` if this is the final searching worker. The caller/// **must** notify a new worker.unpark_worker_by_id/// Unpark a specific worker. This happens if tasks are submitted from/// within the worker's park routine./// Returns `true` if the worker was parked before calling the method./// Returns `true` if `worker_id` is contained in the sleep set.notify_should_wakeupinc_num_searchingdec_num_searching/// Returns `true` if this is the final searching workerdec_num_unparked/// Track a sleeping worker/// Returns `true` if this is the final searching worker.num_searching/// Number of workers currently searchingnum_unparked/// Number of workers currently unparked//! Coordinates idling workersStatsLaunchtrace_mockTraceStatus/// Work-stealing based thread pool for executing futures./// Blocks the current thread waiting for the future to complete./// The future will execute on the current thread, but all spawned tasks/// will be executed on the thread pool.//! Multi-threaded runtime// ===== impl MultiThread =====/// Avoids entering the park if possible/// Used to coordinate access to the driver / `condvar`/// `Condvar` to block on if the driver is unavailable./// Resource (I/O, time, ...) driverPARKED_CONDVARPARKED_DRIVER/// Shared driver. Only one thread at a time can use this/// Shared across multiple Parker handlespark_condvarpark_driverunpark_condvar//! Parks the runtime.//! A combination of the various resource driver park handles.UnsignedShortUnsignedLongAtomicUnsignedShortAtomicUnsignedLong// Use wider integers when possible to increase ABA resilience.// See issue #5041: <https://github.com/tokio-rs/tokio/issues/5041>./// Producer handle. May only be used from a single thread./// Consumer handle. May be used from many threads./// Concurrently updated by many threads./// Contains two `UnsignedShort` values. The `LSB` byte is the "real" head of/// the queue. The `UnsignedShort` in the `MSB` is set by a stealer in process/// of stealing values. It represents the first value being stolen in the/// batch. The `UnsignedShort` indices are intentionally wider than strictly/// required for buffer indexing in order to provide ABA mitigation and make/// it possible to distinguish between full and empty buffers./// When both `UnsignedShort` values are the same, there is no active/// stealer./// Tracking an in-progress stealer prevents a wrapping scenario./// Only updated by producer thread but read by many threads.LOCAL_QUEUE_CAPACITY/// Elementsmake_fixed_size// Constructing the fixed size array directly is very awkward. The only way to// do it is to repeat `UnsafeCell::new(MaybeUninit::uninit())` 256 times, as// the contents are not Copy. The trick with defining a const doesn't work for// generic types./// Create a new local run-queue/// Returns the number of entries in the queueremaining_slots/// How many tasks can be pushed into the queuehas_tasks/// Returns false if there are any entries in the queue/// Separate to `is_stealable` so that refactors of `is_stealable` to "protect"/// some tasks from stealing won't affect this/// Pushes a batch of tasks to the back of the queue. All tasks must fit in/// the local queue./// The method panics if there is not enough capacity to fit in the queue.push_back_or_overflow/// Pushes a task to the back of the local queue, if there is not enough/// capacity in the queue, this triggers the overflow operation./// When the queue overflows, half of the current contents of the queue is/// moved to the given Injection queue. This frees up capacity for more/// tasks to be pushed into the local queue.push_back_finish// Second half of `push_back`push_overflow/// Moves a batch of tasks into the inject queue./// This will temporarily make some of the tasks unavailable to stealers./// Once `push_overflow` is done, a notification is sent out, so if other/// workers "missed" some of the tasks during a steal, they will get/// another opportunity./// Pops a task from the local queue.steal_into/// Steals half the tasks from self and place them into `dst`.steal_into2// Steal tasks from `self`, placing them into `dst`. Returns the number of// tasks that were stolen./// Split the head value into the real head and the index a stealer is working/// Join the two head valuestest_local_queue_capacity//! Run-queue structures to support a work-stealing scheduler/// The metrics batch used to report runtime-level metrics/stats to the/// This duplicates the value stored in `MetricsBatch`. We will unify/// `Stats` and `MetricsBatch` when we stabilize metrics.tasks_polled_in_batch/// Number of tasks polled in the batch of scheduled taskstask_poll_time_ewma/// Exponentially-weighted moving average of time spent polling scheduled a/// Tracked in nanoseconds, stored as a `f64` since that is what we use with/// the EWMA calculations/// Per-worker statistics. This is used for both tuning the scheduler and/// reporting runtime-level metrics/stats.TASK_POLL_TIME_EWMA_ALPHA/// How to weigh each individual poll time, value is plucked from thin air.TARGET_GLOBAL_QUEUE_INTERVAL/// Ideally, we wouldn't go above this, value is plucked from thin air.MAX_TASKS_POLLED_PER_GLOBAL_QUEUE_INTERVAL/// Max value for the global queue interval. This is 2x the previous defaultTARGET_TASKS_POLLED_PER_GLOBAL_QUEUE_INTERVAL/// This is the previous defaulttuned_global_queue_intervaltrace_requestedtrace_starttrace_endresult_readytrace_result/// Tracing status of the worker.start_trace_requeststash_resultend_trace_requesttrace_multi_threadtrace_coresteal_all/// Steal all tasks from remotes into a single local queue.taskdump_mock/// Reference to scheduler's handle/// Index holding this worker's remote state/// Used to hand-off a worker's core to another thread./// A scheduler worker/// Used to schedule bookkeeping tasks every so often.lifo_slot/// When a task is scheduled from a worker, it is stored in this slot. The/// worker will check this slot for a task **before** checking the run/// queue. This effectively results in the **last** scheduled task to be run/// next (LIFO). This is an optimization for improving locality which/// benefits message passing patterns and helps to reduce latency.lifo_enabled/// When `true`, locally scheduled tasks go to the LIFO slot. When `false`,/// they go to the back of the `run_queue`.run_queue/// The worker-local run queue.is_searching/// True if the worker is currently searching for more work. Searching/// involves attempting to steal from other workers./// True if the scheduler is being shutdownis_traced/// True if the scheduler is being traced/// Parker/// Stored in an `Option` as the parker is added / removed to make the/// borrow checker happy./// Per-worker runtime stats/// Fast random number generator./// Core data/// Per-worker remote state. All other workers have access to this and is/// how they communicate between each other./// Global task queue used for:///  1. Submit work to the scheduler while **not** currently on a worker thread.///  2. Submit work to the scheduler when a worker run queue is saturated/// Coordinates idle workersshutdown_cores/// Cores that have observed the shutdown signal/// The core is **not** placed back in the worker to avoid it from being/// stolen by a thread that was spawned as part of `block_in_place`.// we're moving an already-boxed value/// The number of cores that have observed the trace signal./// Collects metrics from the runtime._counters/// Only held to trigger some code on drop. This is used to get internal/// runtime metrics that can be useful when doing performance/// investigations. This does nothing (empty struct, no drop impl) unless/// the `tokio_internal_mt_counters` `cfg` flag is set./// State shared across all workers/// Synchronized state for `Idle`./// Synchronized state for `Inject`./// Steals tasks from this worker./// Unparks the associated worker thread/// Used to communicate with a worker from other threads./// Worker/// Tasks to wake after resource drivers are polled. This is mostly to/// handle yielded tasks./// Thread-local context/// Starts the workersRunResult/// Running a task may consume the core. If the core is still available when/// running the task completes, it is returned. Otherwise, the worker will need/// to stop processing./// A task handle/// A notified task handleMAX_LIFO_POLLS_PER_TICK/// Value picked out of thin-air. Running the LIFO slot a handful of times/// seems sufficient to benefit from locality. More than 3 times probably is/// overweighing. The value can be tuned in the future with data that shows/// improvements.reset_lifo_enabledassert_lifo_enabled_is_correctmaintenance/// Parks the worker thread while waiting for tasks to execute./// This function checks if indeed there's no more work left to be done before parking./// Also important to notice that, before parking, the worker thread will try to take/// ownership of the Driver (IO/Time) and dispatch any events that might have fired./// Whenever a worker thread executes the Driver loop, all waken tasks are scheduled/// in its own local queue until the queue saturates (ntasks > `LOCAL_QUEUE_CAPACITY`)./// When the local queue is saturated, the overflow tasks are added to the injection queue/// from where other workers can pick them up./// Also, we rely on the workstealing algorithm to spread the tasks amongst workers/// after all the IOs get dispatchedget_worker_index/// Increment the tick/// Return the next notified task available to this worker.steal_work/// Function responsible for stealing tasks from another worker/// Note: Only if less than half the workers are searching for tasks to steal/// a new worker will actually try to steal. The idea is to make sure not all/// workers will be trying to steal at the same time.transition_to_searchingtransition_from_searchingshould_notify_otherstransition_to_parked/// Prepares the worker state for parking./// Returns true if the transition happened, false if there is work to do first.transition_from_parked/// Returns `true` if the transition happened./// Runs maintenance work such as checking the pool's state.pre_shutdown/// Signals all tasks to shut down, and waits for them to complete. Must run/// before we enter the single-threaded phase of shutdown processing./// Shuts down the core.tune_global_queue_interval/// Returns a reference to the scheduler's injection queue.// TODO: Move `Handle` impls into handle.rsschedule_taskschedule_option_task_without_yieldschedule_localpush_remote_tasknotify_parked_localnotify_parked_remotenotify_if_work_pendingshutdown_core/// Signals that a worker has observed the shutdown signal and has replaced/// its core back into its handle./// If all workers have reached this point, the final cleanup is performed.InjectGuard//! A scheduler is initialized with a fixed number of workers. Each worker is//! driven by a thread. Each worker has a "core" which contains data such as the//! run queue and other state. When `block_in_place` is called, the worker's//! "core" is handed off to a new thread allowing the scheduler to continue to//! make progress while the originating thread blocks.//! # Shutdown//! Shutting down the runtime involves the following steps://!  1. The Shared::close method is called. This closes the inject queue and//!     `OwnedTasks` instance and wakes up all worker threads.//!  2. Each worker thread observes the close signal next time it runs//!     Core::maintenance by checking whether the inject queue is closed.//!     The `Core::is_shutdown` flag is set to true.//!  3. The worker thread calls `pre_shutdown` in parallel. Here, the worker//!     will keep removing tasks from `OwnedTasks` until it is empty. No new//!     tasks can be pushed to the `OwnedTasks` during or after this step as it//!     was closed in step 1.//!  5. The workers call Shared::shutdown to enter the single-threaded phase of//!     shutdown. These calls will push their core to `Shared::shutdown_cores`,//!     and the last thread to push its core will finish the shutdown procedure.//!  6. The local run queue of each core is emptied, then the inject queue is//!     emptied.//! At this point, shutdown has completed. It is not possible for any of the//! collections to contain any tasks at this point, as each collection was//! closed first, then emptied afterwards.//! ## Spawns during shutdown//! When spawning tasks during shutdown, there are two cases://!  * The spawner observes the `OwnedTasks` being open, and the inject queue is//!    closed.//!  * The spawner observes the `OwnedTasks` being closed and doesn't check the//!    inject queue.//! The first case can only happen if the `OwnedTasks::bind` call happens before//! or during step 1 of shutdown. In this case, the runtime will clean up the//! task in step 3 of shutdown.//! In the latter case, the task was not spawned and the task is immediately//! cancelled by the spawner.//! The correctness of shutdown requires both the inject queue and `OwnedTasks`//! collection to have a closed bit. With a close bit on only the inject queue,//! spawning could run in to a situation where a task is successfully bound long//! after the runtime has shut down. With a close bit on only the `OwnedTasks`,//! the first spawning situation could result in the notification being pushed//! to the inject queue after step 6 of shutdown, which would leave a task in//! the inject queue indefinitely. This would be a ref-count cycle and a memory//! leak.NUM_MAINTENANCENUM_NOTIFY_LOCALNUM_NOTIFY_REMOTENUM_UNPARKS_LOCALNUM_UNPARKS_REMOTENUM_LIFO_SCHEDULESNUM_LIFO_CAPPEDNUM_STEALSNUM_OVERFLOWNUM_PARKNUM_POLLSNUM_LIFO_POLLSNUM_REMOTE_BATCHNUM_GLOBAL_QUEUE_INTERVALNUM_NO_AVAIL_CORENUM_RELAY_SEARCHNUM_SPIN_STALLNUM_NO_LOCAL_WORKinc_num_notify_remoteinc_num_unparks_remoteinc_num_stealsinc_num_overflowsinc_num_parksinc_num_pollsinc_num_lifo_pollsinc_num_remote_batchinc_global_queue_intervalinc_notify_no_coreinc_num_relay_searchinc_num_spin_stallinc_num_no_local_worknum_blocking_threadsnum_idle_blocking_threadsworker_local_queue_depthblocking_queue_depthmulti_thread_alt/// Number of searching coresnum_idle/// Number of idle coresidle_mapIdleMap/// Map of idle coresneeds_searching/// Used to catch false-negatives when waking workersnum_cores/// Total number of coresSnapshot/// Worker IDs that are currently sleepingavailable_cores/// Cores available for workerstry_acquire_available_core/// Try to acquire an available corenotify_local/// We need at least one searching workernotify_remote/// Notifies a single workernotify_synced/// Notify a worker while syncednotify_multshutdown_unassigned_coresrelease_core/// The worker releases the given core, making it available to other workers/// that are waiting.try_transition_worker_to_searchingtransition_worker_to_searching_if_needed/// Needs to happen while synchronized in order to avoid racesBIT_MASKnew_nset_allnum_chunksindex_to_masknum_active_workers// TODO: implement task dump/// Used to coordinate access to the driver / condvar/// Condvar to block on if the driver is unavailable./// Returns `true` if there are no entries in the queuecan_stealbatch_started/// Used to ensure calls to start / stop batch are pairedEphemeral/// Transient statenum_seq_local_queue_polls/// Counter used to track when to poll from the local queue vs. the/// injection queueworkers_to_notify/// Used to collect a list of workers to notifyidle_snapshot/// Snapshot of idle core list. This helps speedup stealing/// Data is stack-allocated and never migrates threads/// Index holding this core's remote/shared state./// Data is heap-allocated and migrates threads./// Per-core remote state./// Power's Tokio's I/O, timers, etc... the responsibility of polling the/// driver is shared across workers.condvars/// Condition variables used to unblock worker threads. Each worker thread/// has its own `condvar` it waits on.assigned_cores/// When worker is notified, it is assigned a core. The core is placed here/// until the worker wakes up to take it.shutdown_driver/// The driver goes here when shutting down// lifo_slot: Lifo,// Current scheduler's handle/// Worker index/// True when the LIFO slot is enabledhandoff_core/// Used to pass cores to other threads when `block_in_place` is calledNextTaskResulttry_tasktry_task_new_batch// Try to acquire an available core, but do not block the threadwait_for_core// Block the current thread, waiting for an available corereset_acquired_core/// Ensure core's state is set correctly for the worker to start using./// Finds the next task to run, this could be from a queue or stealing. If/// none are available, the thread sleeps and tries again.next_notified_tasknext_remote_task_batchnext_remote_task_batch_syncedsearch_for_worksteal_one_roundschedule_deferred_with_coreschedule_deferred_without_coremaybe_maintenanceflush_metricsupdate_global_flagsdo_park/// Returns `true` if another worker must be notifiedcan_transition_to_parkedshutdown_clear_defer/*
    fn poll_driver(&mut self, cx: &Context, core: Box<Core>) -> NextTaskResult {
        // Call `park` with a 0 timeout. This enables the I/O driver, timer, ...
        // to run without actually putting the thread to sleep.
        if let Some(mut driver) = cx.shared().driver.take() {
            driver.park_timeout(&cx.handle.driver, Duration::from_millis(0));

            cx.shared().driver.set(driver);

            // If there are more I/O events, schedule them.
            self.schedule_deferred_with_core(cx, core, || cx.shared().synced.lock())
        } else {
            Ok((None, core))
        }
    }
    */next_lifo_tasknext_remote_task_syncedschedule_remotepush_remote_task_batchpush_remote_task_batch_syncedtake_driverdriver_enabledshutdown_finalizeSyncedGuardstd_io/// Thread parker. The `Driver` park implementation delegates to this./// A pipe for receiving wake events from the signal handler/// Shared state. The driver keeps a strong ref and the handle keeps a weak/// ref. The weak ref is used to check if the driver is still active before/// trying to register a signal handler./// Responsible for registering wakeups when an OS signal is received, and/// subsequently dispatching notifications to any signal listeners as appropriate./// Note: this driver relies on having an enabled IO driver in order to listen to/// pipe write wakeups./// Paired w/ the `Arc` above and is used to check if the driver is still/// around before attempting to register a signal handler./// Returns a handle to this event loop which can be sent across threads/// and can be used as a proxy to the event loop itself.check_inner//! Signal driver/// An owned permission to abort a spawned task, without awaiting its completion./// Unlike a [`JoinHandle`], an `AbortHandle` does *not* represent the/// permission to await the task's completion, only to terminate it./// The task may be aborted by calling the [`AbortHandle::abort`] method./// Dropping an `AbortHandle` releases the permission to terminate the task/// --- it does *not* abort the task./// Be aware that tasks spawned using [`spawn_blocking`] cannot be aborted/// because they are not async. If you call `abort` on a `spawn_blocking` task,/// then this *will not have any effect*, and the task will continue running/// normally. The exception is if the task has not started running yet; in that/// case, calling `abort` may prevent the task from starting./// [`JoinHandle`]: crate::task::JoinHandle/// Abort the task associated with the handle./// Awaiting a cancelled task might complete as usual if the task was/// already completed at the time it was cancelled, but most likely it/// will fail with a [cancelled] `JoinError`./// If the task was already cancelled, such as by [`JoinHandle::abort`],/// this method will do nothing./// because they are not async. If you call `abort` on a `spawn_blocking`/// task, then this *will not have any effect*, and the task will continue/// running normally. The exception is if the task has not started running/// yet; in that case, calling `abort` may prevent the task from starting./// See also [the module level docs] for more information on cancellation./// [cancelled]: method@super::error::JoinError::is_cancelled/// [`JoinHandle::abort`]: method@super::JoinHandle::abort/// [the module level docs]: crate::task#cancellation/// Checks if the task associated with this `AbortHandle` has finished./// Please note that this method can return `false` even if `abort` has been/// called on the task. This is because the cancellation process may take/// some time, and this method does not return `true` until it has/// currently spawned tasks./// Returns a cloned `AbortHandle` that can be used to remotely abort this task./// Hot task state data/// Either the future or output, depending on the execution stage.trailer/// Cold data/// The task cell. Contains the components of the task./// It is critical for `Header` to be the first field as the task structure will/// be referenced by both *mut Cell and *mut Header./// Any changes to the layout of this struct _must_ also be reflected in the/// `const` fns in raw.rs.CoreStage/// Scheduler used to drive this future.task_id/// The task's ID, used for populating `JoinError`s./// Either the future or the output./// The core of the task./// Holds the future or output, depending on the stage of execution./// Task state.queue_next/// Pointer to next task, used with the injection queue./// Table of function pointers for executing actions on the task.owner_id/// This integer contains the id of the `OwnedTasks` or `LocalOwnedTasks`/// that this task is stored in. If the task is not in any list, should be/// the id of the list that it was previously in, or `None` if it has never/// been in any list./// Once a task has been bound to a list, it can never be bound to another/// list, even if removed from the first list./// The id is not unset when removed from a list because we want to be able/// to read the id without synchronization, even if it is concurrently being/// removed from the list./// Crate public as this is also needed by the pool./// Pointers for the linked list in the `OwnedTasks` that owns this task./// Consumer task waiting on completion of this task./// Optional hooks needed in the harness./// Cold data is stored after the future. Data is considered cold if it is only/// used during creation or shutdown of the task.addr_of_ownedConsumed// https://github.com/rust-lang/miri/issues/3780/// Allocates a new task cell, containing the header, trailer, and coreparent_task_idTaskIdGuard/// Set and clear the task id in the context when the future is executed or/// dropped, or when the output produced by the future is dropped./// Polls the future./// The caller must ensure it is safe to mutate the `state` field. This/// requires ensuring mutual exclusion between any concurrent thread that/// might modify the future or output field./// The mutual exclusion is implemented by `Harness` and the `Lifecycle`/// component of the task state./// `self` must also be pinned. This is handled by storing the task on thedrop_future_or_output/// Drops the future./// The caller must ensure it is safe to mutate the `stage` field.store_output/// Stores the task output./// Takes the task output.set_stageset_owner_id// safety: The caller must guarantee exclusive access to this field, and// must ensure that the id is either `None` or the id of the OwnedTasks// containing this task.get_owner_idget_trailer/// Gets a pointer to the `Trailer` of the task containing this `Header`./// The provided raw pointer must point at the header of a task.get_scheduler/// Gets a pointer to the scheduler of the task containing this `Header`./// The generic type S must be set to the correct scheduler type for thisget_id_ptr/// Gets a pointer to the id of the task containing this `Header`./// Gets the id of the task containing this `Header`.wake_joinheader_lte_cache_line//! Core task module.//! The functions in this module are private to the `task` module. All of them//! should be considered `unsafe` to use, but are not marked as such since it//! would be too noisy.//! Make sure to consult the relevant safety section of each function before//! use.r" Task failed to execute to completion."/// Returns true if the error was caused by the task being cancelled./// See [the module level docs] for more information on cancellation./// Returns true if the error was caused by the task panicking.///     let err = tokio::spawn(async {///         panic!("boom");///     }).await.unwrap_err();///     assert!(err.is_panic());/// Consumes the join error, returning the object with which the task panicked./// `into_panic()` panics if the `Error` does not represent the underlying/// task terminating with a panic. Use `is_panic` to check the error reason/// or `try_into_panic` for a variant that does not panic.///     if err.is_panic() {///         // Resume the panic on the main task///         panic::resume_unwind(err.into_panic());/// Consumes the join error, returning the object with which the task/// panicked if the task terminated due to a panic. Otherwise, `self` is///     if let Ok(reason) = err.try_into_panic() {///         panic::resume_unwind(reason);/// Returns a [task ID] that identifies the task which errored relative to/// other currently spawned tasks.panic_payload_as_strHarness/// Typed raw task handle.header_ptrdrop_referencewake_by_val/// This call consumes a ref-count and notifies the task. This will create a/// new Notified and submit it if necessary./// The caller does not need to hold a ref-count besides the one that was/// passed to this call./// This call notifies the task. It will not consume any ref-counts, but the/// caller should hold a ref-count.  This will create a new Notified and/// submit it if necessary.remote_abort/// Remotely aborts the task./// The caller should hold a ref-count, but we do not consume it./// This is similar to `shutdown` except that it asks the runtime to perform/// the shutdown. This is necessary to avoid the shutdown happening in the/// wrong thread for non-Send tasks.try_set_join_waker/// Try to set the waker notified when the task is complete. Returns true if/// the task has already completed. If this call returns false, then the/// waker will not be notified./// Task operations that can be implemented without being generic over the/// scheduler or task. Only one version of these methods should exist in the/// final binary./// Polls the inner future. A ref-count is consumed./// All necessary state checks and transitions are performed./// Panics raised while polling the future are handled.PollFuture/// Polls the task and cancel it if necessary. This takes ownership of a/// ref-count./// If the return value is Notified, the caller is given ownership of two/// ref-counts./// If the return value is Complete, the caller is given ownership of a/// single ref-count, which should be passed on to `complete`./// If the return value is `Dealloc`, then this call consumed the last/// ref-count and the caller should call `dealloc`./// Otherwise the ref-count is consumed and the caller should not access/// `self` again./// Forcibly shuts down the task./// Attempt to transition to `Running` in order to forcibly shutdown the/// task. If the task is currently running or in a state of completion, then/// there is nothing further to do. When the task completes running, it will/// notice the `CANCELLED` bit and finalize the task.try_read_output/// Read the task output into `dst`.drop_join_handle_slow/// Completes the task. This method assumes that the state is RUNNING./// Releases the task from the scheduler. Returns the number of ref-counts/// that should be decremented.get_new_task/// Creates a new task that holds its own ref-count./// Any use of `self` after this call must ensure that a ref-count to the/// task holds the task alive until after the use of `self`. Passing the/// returned Task to any method on `self` is unsound if dropping the Task/// could drop `self` before the call on `self` returned.// ===== join handle =====// ====== internal ======can_read_outputset_join_wakerDealloccancel_task/// Cancels the task and store the appropriate error in the stage field.panic_result_to_join_errorpoll_future/// Polls the future. If the future completes, the output is written to the/// stage field.panic_to_error/// An opaque ID that uniquely identifies a task relative to all other currently/// running tasks./// - Task IDs are unique relative to other *currently running* tasks. When a///   task completes, the same ID may be used for another task./// - Task IDs are *not* sequential, and do not indicate the order in which///   tasks are spawned, what runtime a task is spawned on, or any other data./// - The task ID of the currently running task can be obtained from inside the///   task via the [`task::try_id()`](crate::task::try_id()) and///   [`task::id()`](crate::task::id()) functions and from outside the task via///   the [`JoinHandle::id()`](crate::task::JoinHandle::id()) function./// Returns the [`Id`] of the currently running task./// This function panics if called from outside a task. Please note that calls/// to `block_on` do not have task IDs, so the method will panic if called from/// within a call to `block_on`. For a version of this function that doesn't/// panic, see [`task::try_id()`](crate::runtime::task::try_id()).try_id/// Returns the [`Id`] of the currently running task, or `None` if called outside/// of a task./// This function is similar to  [`task::id()`](crate::runtime::task::id()), except/// that it returns `None` rather than panicking if called outside of a taskr" An owned permission to join on a task (await its termination)."r" This can be thought of as the equivalent of [`std::thread::JoinHandle`]"r" for a Tokio task rather than a thread. Note that the background task"r" associated with this `JoinHandle` started running immediately when you"r" called spawn, even if you have not yet awaited the `JoinHandle`."r" A `JoinHandle` *detaches* the associated task when it is dropped, which"r" means that there is no longer any handle to the task, and no way to `join`"r" on it."r" This `struct` is created by the [`task::spawn`] and [`task::spawn_blocking`]"r" The `&mut JoinHandle<T>` type is cancel safe. If it is used as the event"r" in a `tokio::select!` statement and some other branch completes first,"r" then it is guaranteed that the output of the task is not lost."r" If a `JoinHandle` is dropped, then the task continues running in the"r" background and its return value is lost."r" Creation from [`task::spawn`]:"r" use tokio::task;"r" # async fn doc() {"r" let join_handle: task::JoinHandle<_> = task::spawn(async {"r"     // some work here"r" Creation from [`task::spawn_blocking`]:"r" let join_handle: task::JoinHandle<_> = task::spawn_blocking(|| {"r"     // some blocking work here"r" The generic parameter `T` in `JoinHandle<T>` is the return type of the spawned task."r" If the return value is an `i32`, the join handle has type `JoinHandle<i32>`:"r" let join_handle: task::JoinHandle<i32> = task::spawn(async {"r"     5 + 3"r" If the task does not have a return value, the join handle has type `JoinHandle<()>`:"r" let join_handle: task::JoinHandle<()> = task::spawn(async {"r#"     println!("I return nothing.");"#r" Note that `handle.await` doesn't give you the return type directly. It is wrapped in a"r" `Result` because panics in the spawned task are caught by Tokio. The `?` operator has"r" to be double chained to extract the returned value:"r"     let join_handle: task::JoinHandle<Result<i32, io::Error>> = tokio::spawn(async {"r"         Ok(5 + 3)"r"     let result = join_handle.await??;"r"     assert_eq!(result, 8);"r" If the task panics, the error is a [`JoinError`] that contains the panic:"r" use std::panic;"r#"         panic!("boom");"#r"     let err = join_handle.await.unwrap_err();"r"     assert!(err.is_panic());"r" Child being detached and outliving its parent:"r" use tokio::time;"r" # #[tokio::main] async fn main() {"r" let original_task = task::spawn(async {"r"     let _detached_task = task::spawn(async {"r"         // Here we sleep to make sure that the first task returns before."r"         time::sleep(Duration::from_millis(10)).await;"r"         // This will be called, even though the JoinHandle is dropped."r#"         println!("♫ Still alive ♫");"#r#" original_task.await.expect("The task being joined has panicked");"#r#" println!("Original task is joined.");"#r" // We make sure that the new task has time to run, before the main"r" // task returns."r" time::sleep(Duration::from_millis(1000)).await;"r" [`task::spawn`]: crate::task::spawn()"r" [`task::spawn_blocking`]: crate::task::spawn_blocking"r" [`std::thread::JoinHandle`]: std::thread::JoinHandle"r" [`JoinError`]: crate::task::JoinError"/// # #[tokio::main(flavor = "current_thread", start_paused = true)]/// # async fn main() {/// let mut handles = Vec::new();/// handles.push(tokio::spawn(async {///    time::sleep(time::Duration::from_secs(10)).await;///    false/// for handle in &handles {///     handle.abort();///     assert!(handle.await.unwrap_err().is_cancelled());/// Checks if the task associated with this `JoinHandle` has finished./// Please note that this method can return `false` even if [`abort`] has been/// let handle1 = tokio::spawn(async {///     // do some stuff here/// let handle2 = tokio::spawn(async {///     // do some other stuff here///     time::sleep(time::Duration::from_secs(10)).await;/// // Wait for the task to finish/// handle2.abort();/// time::sleep(time::Duration::from_secs(1)).await;/// assert!(handle1.is_finished());/// assert!(handle2.is_finished());/// [`abort`]: method@JoinHandle::abort/// Set the waker that is notified when the task completes."abort handles do nothing unless `.abort` is called"abort_handle/// Returns a new `AbortHandle` that can be used to remotely abort this task./// Awaiting a task cancelled by the `AbortHandle` might complete as usual if the task was/// use tokio::{time, task};/// let abort_handles: Vec<task::AbortHandle> = handles.iter().map(|h| h.abort_handle()).collect();/// for handle in abort_handles {LocalNotifiedsharded_listNEXT_OWNED_TASKS_IDget_next_idShardedListOwnedTasksInner_not_send_or_syncLocalOwnedTasks/// Binds the provided task to this `OwnedTasks` instance. This fails if the/// `OwnedTasks` has been closed.bind_local/// Bind a task that isn't safe to transfer across thread boundaries./// Only use this in `LocalRuntime` where the task cannot movebind_inner/// The part of `bind` that's the same for every type of future.assert_owner/// Asserts that the given task is owned by this `OwnedTasks` and convert it to/// a `LocalNotified`, giving the thread permission to poll this task.close_and_shutdown_all/// Shuts down all tasks in the collection. This call also closes the/// collection, preventing new items from being added./// The parameter start determines which shard this method will start at./// Using different values for each worker thread reduces contention.get_shard_sizespawned_tasks_countgen_shared_list_size/// Generates the size of the sharded list based on the number of worker threads./// The sharded lock design can effectively alleviate/// lock contention performance problems caused by high concurrency./// However, as the number of shards increases, the memory continuity between/// nodes in the intrusive linked list will diminish. Furthermore,/// the construction time of the sharded list will also increase with a higher number of shards./// Due to the above reasons, we set a maximum value for the shared list size,/// denoted as `MAX_SHARED_LIST_SIZE`./// Asserts that the given task is owned by this `LocalOwnedTasks` and convert/// it to a `LocalNotified`, giving the thread permission to poll this task.test_id_not_broken// This test may run in parallel with other tests, so we only test that ids// come in increasing order.//! This module has containers for storing the tasks spawned on a scheduler. The//! `OwnedTasks` container is thread-safe but can only store tasks that//! implement Send. The `LocalOwnedTasks` container is not thread safe, but can//! store non-Send tasks.//! The collections can be closed to prevent adding new tasks during shutdown of//! the scheduler with the collection.// The id from the module below is used to verify whether a given task is stored// in this OwnedTasks, or some other task. The counter starts at one so we can// use `None` for tasks not owned by any list.// The safety checks in this file can technically be violated if the counter is// overflown, but the checks are not supposed to ever fail unless there is a// bug in Tokio, so we accept that certain bugs would not be caught if the two// mixed up runtimes happen to have the same id.harness/// An owned handle to the task, tracked by ref count./// A task was notified.// safety: This type cannot be used to touch the task without first verifying// that the value is on a thread where it is safe to poll the task./// A non-Send variant of Notified with the invariant that it is on a thread/// where it is safe to poll it./// A task that is not owned by any `OwnedTasks`. Used for blocking tasks./// This type holds two ref-counts.// safety: This type can only be created given a Send task./// Task result sent back.task_terminate_callback/// Hooks for scheduling tasks which are needed in the task harness./// The task has completed work and is ready to be released. The scheduler/// should release it immediately and return it. The task module will batch/// the ref-dec with setting other options./// If the scheduler has already released the task, then None is returned./// Schedule the task/// Schedule the task to run in the near future, yielding the thread to/// other tasks./// Polling the task resulted in a panic. Should the runtime shutdown?r" This is the constructor for a new task. Three references to the task are"r" created. The first task reference is usually put into an `OwnedTasks`"r" immediately. The Notified is sent to the scheduler as an ordinary"r" notification."new_taskr" Creates a new task with an associated join handle. This method is used"r" only when the task is not going to be stored in an `OwnedTasks` list."r" Currently only blocking tasks use this method."unowned/// Preemptively cancels the task as part of the shutdown process.into_notified// Used in test of the inject queue./// Tasks are pinned.get_shard_idShardedListItem/// The id of a task is never changed after creation of the task, so the return value of/// `get_shard_id` will not change. (The cast may throw away the upper 32 bits of the task id, but/// the shard id still won't change from call to call.)//! The task module.//! The task module contains the code that manages spawned tasks and provides a//! safe API for the rest of the runtime to use. Each task in a runtime is//! stored in an `OwnedTasks` or `LocalOwnedTasks` object.//! # Task reference types//! A task is usually referenced by multiple handles, and there are several//! types of handles.//!  * `OwnedTask` - tasks stored in an `OwnedTasks` or `LocalOwnedTasks` are of this//!    reference type.//!  * `JoinHandle` - each task has a `JoinHandle` that allows access to the output//!    of the task.//!  * `Waker` - every waker for a task has this reference type. There can be any//!    number of waker references.//!  * `Notified` - tracks whether the task is notified.//!  * `Unowned` - this task reference type is used for tasks not stored in any//!    runtime. Mainly used for blocking tasks, but also in tests.//! The task uses a reference count to keep track of how many active references//! exist. The `Unowned` reference type takes up two ref-counts. All other//! reference types take up a single ref-count.//! Besides the waker type, each task has at most one of each reference type.//! # State//! The task stores its state in an atomic `usize` with various bitfields for the//! necessary information. The state has the following bitfields://!  * `RUNNING` - Tracks whether the task is currently being polled or cancelled.//!    This bit functions as a lock around the task.//!  * `COMPLETE` - Is one once the future has fully completed and has been//!    dropped. Never unset once set. Never set together with RUNNING.//!  * `NOTIFIED` - Tracks whether a Notified object currently exists.//!  * `CANCELLED` - Is set to one for tasks that should be cancelled as soon as//!    possible. May take any value for completed tasks.//!  * `JOIN_INTEREST` - Is set to one if there exists a `JoinHandle`.//!  * `JOIN_WAKER` - Acts as an access control bit for the join handle waker. The//!    protocol for its usage is described below.//! The rest of the bits are used for the ref-count.//! # Fields in the task//! The task has various fields. This section describes how and when it is safe//! to access a field.//!  * The state field is accessed with atomic instructions.//!  * The `OwnedTask` reference has exclusive access to the `owned` field.//!  * The Notified reference has exclusive access to the `queue_next` field.//!  * The `owner_id` field can be set as part of construction of the task, but//!    is otherwise immutable and anyone can access the field immutably without//!    synchronization.//!  * If COMPLETE is one, then the `JoinHandle` has exclusive access to the//!    stage field. If COMPLETE is zero, then the RUNNING bitfield functions as//!    a lock for the stage field, and it can be accessed only by the thread//!    that set RUNNING to one.//!  * The waker field may be concurrently accessed by different threads: in one//!    thread the runtime may complete a task and *read* the waker field to//!    invoke the waker, and in another thread the task's `JoinHandle` may be//!    polled, and if the task hasn't yet completed, the `JoinHandle` may *write*//!    a waker to the waker field. The `JOIN_WAKER` bit ensures safe access by//!    multiple threads to the waker field using the following rules://!    1. `JOIN_WAKER` is initialized to zero.//!    2. If `JOIN_WAKER` is zero, then the `JoinHandle` has exclusive (mutable)//!       access to the waker field.//!    3. If `JOIN_WAKER` is one, then the `JoinHandle` has shared (read-only)//!    4. If `JOIN_WAKER` is one and COMPLETE is one, then the runtime has shared//!       (read-only) access to the waker field.//!    5. If the `JoinHandle` needs to write to the waker field, then the//!       `JoinHandle` needs to (i) successfully set `JOIN_WAKER` to zero if it is//!       not already zero to gain exclusive access to the waker field per rule//!       2, (ii) write a waker, and (iii) successfully set `JOIN_WAKER` to one.//!       If the `JoinHandle` unsets `JOIN_WAKER` in the process of being dropped//!       to clear the waker field, only steps (i) and (ii) are relevant.//!    6. The `JoinHandle` can change `JOIN_WAKER` only if COMPLETE is zero (i.e.//!       the task hasn't yet completed). The runtime can change `JOIN_WAKER` only//!       if COMPLETE is one.//!    7. If `JOIN_INTEREST` is zero and COMPLETE is one, then the runtime has//!       exclusive (mutable) access to the waker field. This might happen if the//!       `JoinHandle` gets dropped right after the task completes and the runtime//!       sets the `COMPLETE` bit. In this case the runtime needs the mutable access//!       to the waker field to drop it.//!    Rule 6 implies that the steps (i) or (iii) of rule 5 may fail due to a//!    race. If step (i) fails, then the attempt to write a waker is aborted. If//!    step (iii) fails because COMPLETE is set to one by another thread after//!    step (i), then the waker field is cleared. Once COMPLETE is one (i.e.//!    task has completed), the `JoinHandle` will not modify `JOIN_WAKER`. After the//!    runtime sets COMPLETE to one, it invokes the waker if there is one so in this//!    case when a task completes the `JOIN_WAKER` bit implicates to the runtime//!    whether it should invoke the waker or not. After the runtime is done with//!    using the waker during task completion, it unsets the `JOIN_WAKER` bit to give//!    the `JoinHandle` exclusive access again so that it is able to drop the waker//!    at a later point.//! All other fields are immutable and can be accessed immutably without//! synchronization by anyone.//! This section goes through various situations and explains why the API is//! safe in that situation.//! ## Polling or dropping the future//! Any mutable access to the future happens after obtaining a lock by modifying//! the RUNNING field, so exclusive access is ensured.//! When the task completes, exclusive access to the output is transferred to//! the `JoinHandle`. If the `JoinHandle` is already dropped when the transition to//! complete happens, the thread performing that transition retains exclusive//! access to the output and should immediately drop it.//! ## Non-Send futures//! If a future is not Send, then it is bound to a `LocalOwnedTasks`.  The future//! will only ever be polled or dropped given a `LocalNotified` or inside a call//! to `LocalOwnedTasks::shutdown_all`. In either case, it is guaranteed that the//! future is on the right thread.//! If the task is never removed from the `LocalOwnedTasks`, then it is leaked, so//! there is no risk that the task is dropped on some other thread when the last//! ref-count drops.//! ## Non-Send output//! When a task completes, the output is placed in the stage of the task. Then,//! a transition that sets COMPLETE to true is performed, and the value of//! `JOIN_INTEREST` when this transition happens is read.//! If `JOIN_INTEREST` is zero when the transition to COMPLETE happens, then the//! output is immediately dropped.//! If `JOIN_INTEREST` is one when the transition to COMPLETE happens, then the//! `JoinHandle` is responsible for cleaning up the output. If the output is not//! Send, then this happens://!  1. The output is created on the thread that the future was polled on. Since//!     only non-Send futures can have non-Send output, the future was polled on//!     the thread that the future was spawned from.//!  2. Since `JoinHandle<Output>` is not Send if Output is not Send, the//!     `JoinHandle` is also on the thread that the future was spawned from.//!  3. Thus, the `JoinHandle` will not move the output across threads when it//!     takes or drops the output.//! ## Recursive poll/shutdown//! Calling poll from inside a shutdown call or vice-versa is not prevented by//! the API exposed by the task module, so this has to be safe. In either case,//! the lock in the RUNNING bitfield makes the inner call return immediately. If//! the inner call is a `shutdown` call, then the CANCELLED bit is set, and the//! poll call will notice it when the poll finishes, and the task is cancelled//! at that point.// Some task infrastructure is here to support `JoinSet`, which is currently// unstable. This should be removed once `JoinSet` is stabilized./// Raw task handle/// Schedules the task for execution on the runtime./// Deallocates the memory./// Reads the task output, if complete./// The join handle has been dropped.drop_abort_handle/// An abort handle has been dropped./// Scheduler is being shutdown.trailer_offset/// The number of bytes that the `trailer` field is offset from the header.scheduler_offset/// The number of bytes that the `scheduler` field is offset from the header.id_offset/// The number of bytes that the `id` field is offset from the header./// Get the vtable for the requested `T` and `S` generics.OffsetHelper/// Calling `get_trailer_offset` directly in vtable doesn't work because it/// prevents the vtable from being promoted to a static reference./// See this thread for more info:/// <https://users.rust-lang.org/t/custom-vtables-with-integers/78508>TRAILER_OFFSET// Pass `size_of`/`align_of` as arguments rather than calling them directly// inside `get_trailer_offset` because trait bounds on generic parameters// of const fn are unstable on our MSRV.SCHEDULER_OFFSET// The `scheduler` is the first field of `Core`, so it has the same// offset as `Core`.ID_OFFSETget_trailer_offset/// Compute the offset of the `Trailer` field in `Cell<T, S>` using the/// `#[repr(C)]` algorithm./// Pseudo-code for the `#[repr(C)]` algorithm can be found here:/// <https://doc.rust-lang.org/reference/type-layout.html#reprc-structs>get_core_offset/// Compute the offset of the `Core<T, S>` field in `Cell<T, S>` using theget_id_offset/// Compute the offset of the `Id` field in `Cell<T, S>` using thetrailer_ptr/// Returns a reference to the task's header./// Returns a reference to the task's trailer./// Returns a reference to the task's state./// Safety: mutual exclusion is required to call this function./// Safety: `dst` must be a `*mut Poll<super::Result<T::Output>>` where `T`/// is the future stored by the task.ref_inc/// Increment the task's reference count./// Currently, this is used only when creating an `AbortHandle`.get_queue_next/// Get the queue-next pointer/// This is for usage by the injection queue/// Safety: make sure only one queue uses this and access is synchronized.set_queue_next/// Sets the queue-next pointer/// Current state value.UpdateResult/// The task is currently being run./// The task is complete./// Once this bit is set, it is never unset.LIFECYCLE_MASK/// Extracts the task's lifecycle value from the state./// Flag tracking if the task has been pushed into a run queue.JOIN_INTEREST/// The join handle is still around.JOIN_WAKER/// A join handle waker has been set.CANCELLED/// The task has been forcibly cancelled./// All bits.REF_COUNT_MASK/// Bits used by the ref count portion of the state.REF_COUNT_SHIFT/// Number of positions to shift the ref count.REF_ONE/// One ref count.INITIAL_STATE/// State a task is initialized with./// A task is initialized with three references:///  * A reference that will be stored in an `OwnedTasks` or `LocalOwnedTasks`.///  * A reference that will be sent to the scheduler as an ordinary notification.///  * A reference for the `JoinHandle`./// As the task starts with a `JoinHandle`, `JOIN_INTEREST` is set./// As the task starts with a `Notified`, `NOTIFIED` is set.TransitionToRunningTransitionToIdleOkNotifiedOkDeallocTransitionToNotifiedByValSubmitTransitionToNotifiedByRefTransitionToJoinHandleDrop/// Returns a task's initial state./// Loads the current state, establishes `Acquire` ordering.transition_to_running/// Attempts to transition the lifecycle to `Running`. This sets the/// notified bit to false so notifications during the poll can be detected.transition_to_idle/// Transitions the task from `Running` -> `Idle`./// The transition to `Idle` fails if the task has been flagged to betransition_to_complete/// Transitions the task from `Running` -> `Complete`.transition_to_terminal/// Transitions from `Complete` -> `Terminal`, decrementing the reference/// count the specified number of times./// Returns true if the task should be deallocated.transition_to_notified_by_val/// Transitions the state to `NOTIFIED`./// If no task needs to be submitted, a ref-count is consumed./// If a task needs to be submitted, the ref-count is incremented for the/// new Notified.transition_to_notified_by_reftransition_to_notified_and_cancel/// Sets the cancelled bit and transitions the state to `NOTIFIED` if idle./// Returns `true` if the task needs to be submitted to the pool fortransition_to_shutdown/// Sets the `CANCELLED` bit and attempts to transition to `Running`./// Returns `true` if the transition to `Running` succeeded.drop_join_handle_fast/// Optimistically tries to swap the state assuming the join handle is/// __immediately__ dropped on spawn.transition_to_join_handle_dropped/// Unsets the `JOIN_INTEREST` flag. If `COMPLETE` is not set, the `JOIN_WAKER`/// flag is also unset./// The returned `TransitionToJoinHandleDrop` indicates whether the `JoinHandle` should drop/// the output of the future or the join waker after the transition./// Sets the `JOIN_WAKER` bit./// Returns `Ok` if the bit is set, `Err` otherwise. This operation fails if/// the task has completed.unset_waker/// Unsets the `JOIN_WAKER` bit./// Returns `Ok` has been unset, `Err` otherwise. This operation fails ifunset_waker_after_complete/// Unsets the `JOIN_WAKER` bit unconditionally after task completion./// This operation requires the task to be completed.ref_dec/// Returns `true` if the task should be released.ref_dec_twicefetch_update_action/// All transitions are performed via RMW operations. This establishes an/// unambiguous modification order./// Returns `true` if the task is in an idle state./// Returns `true` if the task has been flagged as notified.unset_notifiedset_notifiedset_runningunset_runningset_cancelled/// Returns `true` if the task's future has completed execution.is_join_interestedunset_join_interestedis_join_waker_setunset_join_waker// ===== impl Snapshot =====SymbolTraceactive_frame/// The address of [`Trace::root`] establishes an upper unwinding bound on/// the backtraces in `Trace`./// The place to stash backtraces./// The ambient backtracing context.inner_addr/// The location associated with this frame./// The parent frame, if any./// A [`Frame`] in an intrusive, doubly-linked tree of [`Frame`]s.backtraces// The linear backtraces that comprise this trace. These linear traces can// be re-knitted into a tree./// An tree execution trace./// Traces are captured with [`Trace::capture`], rooted with [`Trace::root`]/// and leaved with [`trace_leaf`].FAIL_NO_THREAD_LOCALtry_with_current/// SAFETY: Callers of this function must ensure that trace frames always/// form a valid linked list.with_current_framewith_current_collectoris_tracing/// Produces `true` if the current task is being traced; otherwise false./// Invokes `f`, returning both its result and the collection of backtraces/// captured at each sub-invocation of [`trace_leaf`]./// The root of a trace./// If this is a sub-invocation of [`Trace::capture`], capture a backtrace./// The captured backtrace will be returned by [`Trace::capture`]./// Invoking this function does nothing when it is not a sub-invocation/// [`Trace::capture`].// This function is marked `#[inline(never)]` to ensure that it gets a distinct `Frame` in the// backtrace, below which frames should not be included in the backtrace (since they reflect the// internal implementation details of this crate).trace_current_thread/// Trace and poll all tasks of the `current_thread` runtime.trace_owned/// Trace the `OwnedTasks`./// This helper presumes exclusive access to each task. The tasks must not exist/// in any other queue.parent_hash/// A symbol in a backtrace./// This wrapper type serves two purposes. The first is that it provides a/// representation of a symbol that can be inserted into hashmaps and hashsets;/// the [`backtrace`] crate does not define [`Hash`], [`PartialEq`], or [`Eq`]/// on [`BacktraceSymbol`], and recommends that users define their own wrapper/// which implements these traits./// Second, this wrapper includes a `parent_hash` field that uniquely/// identifies this symbol's position in its trace. Otherwise, e.g., our code/// would not be able to distinguish between recursive calls of a function at/// different depths./// The roots of the trees./// There should only be one root, but the code is robust to multiple roots./// The adjacency list of symbols in the execution tree(s)./// An adjacency list representation of an execution tree./// This tree provides a convenient intermediate representation for formatting/// [`Trace`] as a tree.from_trace/// Constructs a [`Tree`] from [`Trace`]consequences/// Produces the sub-symbols of a given symbol./// Format this [`Tree`] as a textual tree.to_symboltrace/// Resolve a sequence of [`backtrace::BacktraceFrame`]s into a sequence of/// [`Symbol`]s./// Returns a `WakerRef` which avoids having to preemptively increase the/// refcount if there is no need to do so.// Wake without consuming the wakerWAKER_VTABLEraw_wakertask_spawn_callback/// The opaque ID of the task./// Task metadata supplied to user-provided hooks for task events./// Return the opaque ID of the task./// Runs on specific task-related eventspush_and_poppush_batch_and_poppop_n_drains_on_dropblocking_shutdownspawn_mandatory_blocking_should_always_runspawn_mandatory_blocking_should_run_even_when_shutting_down_from_other_threadspawn_blocking_when_pausedmk_runtimeyield_calls_park_before_scheduling_againassert_at_most_num_pollsblock_on_num_pollsassert_no_unnecessary_pollsdrop_jh_during_scheduleBlockedFuturepending_cntResetFuturetest_join_setabort_all_during_completionloom_oneshotLocalSetwake_during_shutdown/// Waking a runtime will attempt to push a task into a queue of notifications/// in the runtime, however the tasks in such a queue usually have a reference/// to the runtime itself. This means that if they are not properly removed at/// runtime shutdown, this will cause a memory leak./// This test verifies that waking something during shutdown of a `LocalSet` does/// not result in tasks lingering in the queue once shutdown is complete. This/// is verified using loom's leak finder.NoopSchedulenew_statssteal_overflowmulti_stealerchained_stealjoin_handle_cancel_on_shutdown/// Full runtime loom tests. These are heavy tests and take significant time to/// run on CI./// Use `LOOM_MAX_PREEMPTIONS=1` to do a "quick" run as a smoke test./// In order to speed up the Cassert_oktakenAtomicTakeatomic_takeAtomicOneshotracy_shutdownpool_multi_spawnonly_blocking_inneronly_blocking_without_pendingonly_blocking_with_pendinggroup_a/// Tests are divided into groups to make the runs faster on CI.blocking_and_regular_innerblocking_and_regularblocking_and_regular_with_pendingjoin_outputpoll_drop_handle_then_dropcomplete_block_on_under_loadshutdown_with_notificationgroup_bpool_shutdowngroup_cpool_multi_notifygroup_dmk_poolgated2multi_gatedblocking_and_regular_without_pending// TODO: uncommentfill_local_queuepool_concurrent_park_with_steal_with_inject// This tests a very specific case that happened when a worker has no more// available work to process because a peer is in the process of stealing// (but does not finish stealing), and the worker happens to find more work// from the injection queue *right* before parking.noop_schedulerunowned_wrapper/// `task::Schedule` implementation that does nothing, for testing.task_combinations// Enable dead_code / unreachable_pub here. It has been disabled in lib.rs for// other code when running loom tests.assert_metricsfits_256_one_at_a_timefits_256_all_at_oncefits_256_all_in_chunksnormal_or_miristress1stress2AssertDropHandleassert_not_droppedAssertDropcreate_drop1// A Notified does not shut down on drop, but it is dropped once the ref-count// hits zero.create_drop2drop_abort_handle1drop_abort_handle2drop_abort_handle_clonecreate_shutdown1// Shutting down through Notified workscreate_shutdown2unowned_pollshutdown_immediatelyspawn_niche_in_taskspawn_during_shutdowntick_maxCombiRuntimeMulti1Multi2CombiLocalSetCombiTaskPanicOnRunPanicOnDropPanicOnRunAndDropNoPanicCombiOutputCombiJoinInterestPolledNotPolledCombiJoinHandleDropImmediatelyDropFirstPollDropAfterNoConsumeDropAfterConsume// we aren't using glob importsCombiAbortNotAbortedAbortedImmediatelyAbortedFirstPollAbortedAfterFinishAbortedAfterConsumeOutputCombiAbortSourcetest_combinationstest_combination// Enums for each option in the combinations being testedexhaustedStdUnsafeCellTimerResultSTATE_DEREGISTEREDSTATE_PENDING_FIRESTATE_MIN_VALUEMAX_SAFE_MILLIS_DURATION/// The largest safe integer to use for ticks./// This value should be updated if any other signal values are added above./// Holds either the scheduled expiration time for this timer, or (if the/// timer has been fired and is unregistered), `u64::MAX`./// If the timer is fired (an Acquire order read on state shows/// `u64::MAX`), holds the result that should be returned from/// polling the timer. Otherwise, the contents are unspecified and reading/// without holding the driver lock is undefined behavior./// The currently-registered wakerStateCell/// This structure holds the current shared state of the timer - its scheduled/// time (if registered), or otherwise the result of the timer completing, as/// well as the registered waker./// Generally, the `StateCell` is only permitted to be accessed from two contexts:/// Either a thread holding the corresponding `&mut TimerEntry`, or a thread/// holding the timer driver lock. The write actions on the `StateCell` amount to/// passing "ownership" of the `StateCell` between these contexts; moving a timer/// from the `TimerEntry` to the driver requires _both_ holding the `&mut/// TimerEntry` and the driver lock, while moving it back (firing the timer)/// requires only the driver lock./// Returns the current expiration time, or None if not currently scheduled./// If the timer is completed, returns the result of the timer. Otherwise,/// returns None and registers the waker.read_statemark_pending/// Marks this timer as being moved to the pending list, if its scheduled/// time is not after `not_after`./// If the timer is scheduled for a time after `not_after`, returns an Err/// containing the current scheduled time./// SAFETY: Must hold the driver lock./// Fires the timer, setting the result to the provided result./// * `Some(waker)` - if fired and a waker needs to be invoked once the///   driver lock is released/// * `None` - if fired and a waker does not need to be invoked, or if///   already fired/// SAFETY: The driver lock must be held.set_expiration/// Marks the timer as registered (poll will return None) and sets the/// expiration time./// While this function is memory-safe, it should only be called from a/// context holding both `&mut TimerEntry` and the driver lock.extend_expiration/// Attempts to adjust the timer to a new timestamp./// If the timer has already been fired, is pending firing, or the new/// timestamp is earlier than the old timestamp, (or occasionally/// spuriously) returns Err without changing the timer's state. In this/// case, the timer must be deregistered and re-registered.might_be_registered/// Returns true if the state of this timer indicates that the timer might/// be registered with the driver. This check is performed with relaxed/// ordering, but is conservative - if it returns false, the timer is/// definitely _not_ registered./// Arc reference to the runtime handle. We can only free the driver after/// deregistering everything from their respective timer wheels.TimerShared/// Shared inner structure; this is part of an intrusive linked list, and/// therefore other references can exist to it while mutable references to/// Entry exist./// This is manipulated only under the inner mutex. TODO: Can we use loom/// cells for this?/// Deadline for the timer. This is used to register on the first/// poll, as we can't register prior to being pinned./// Whether the deadline has been registered._m/// Ensure the type is !UnpinTimerEntry/// A timer entry./// This is the handle to a timer that is controlled by the requester of the/// timer. As this participates in intrusive data structures, it must be pinned/// before polling.TimerHandle/// An `TimerHandle` is the (non-enforced) "unique" pointer from the driver to the/// timer entry. Generally, at most one `TimerHandle` exists for a timer at a time/// (enforced by the timer state machine)./// SAFETY: An `TimerHandle` is essentially a raw pointer, and the usual caveats/// of pointer safety apply. In particular, `TimerHandle` does not itself enforce/// that the timer does still exist; however, normally an `TimerHandle` is created/// immediately before registering the timer, and is consumed when firing the/// timer, to help minimize mistakes. Still, because `TimerHandle` cannot enforce/// memory safety, all operations are unsafe.EntryListshard_id/// The shard id. We should never change it./// A link within the doubly-linked list of timers on a particular level and/// slot. Valid only if state is equal to Registered./// Only accessed under the entry lock.cached_when/// The expiration time for which this entry is currently registered./// Generally owned by the driver, but is accessed by the entry when not/// Current state. This records whether the timer entry is currently under/// the ownership of the driver, and if not, its current state (not/// complete, fired, error, etc)./// The shared state structure of a timer. This structure is shared between the/// frontend (`Entry`) and driver backend./// Note that this structure is located inside the `TimerEntry` structure./// Gets the cached time-of-expiration value.sync_when/// Gets the true time-of-expiration value, and copies it into the cached/// time-of-expiration value./// SAFETY: Must be called with the driver lock held, and when this entry is/// not in any timer wheel lists.set_cached_when/// Sets the cached time-of-expiration value.true_when/// Returns the true time-of-expiration value, with relaxed memory ordering./// Sets the true time-of-expiration value, even if it is less than the/// current expiration or the timer is deregistered./// SAFETY: Must only be called with the driver lock held and the entry not/// in the timer wheel./// Sets the true time-of-expiration only if it is after the current./// Returns a `TimerHandle` for this timer./// Gets the shard id.is_inner_init// This lazy initialization is for performance purposes.is_elapsed/// Cancels and deregisters the timer. This operation is irreversible.poll_elapsed/// Forcibly sets the true and cached expiration times to the given tick./// SAFETY: The caller must ensure that the handle remains valid, the driver/// lock is held, and that the timer is not in any wheel linked lists./// Attempts to mark this entry as pending. If the expiration time is after/// `not_after`, however, returns an Err with the current expiration time./// If an `Err` is returned, the `cached_when` value will be updated to this/// new expiration time./// After returning Ok, the entry must be added to the pending list./// Attempts to transition to a terminal state. If the state is already a/// terminal state, does nothing./// Because the entry might be dropped after the state is moved to a/// terminal state, this function consumes the handle to ensure we don't/// access the entry afterwards./// Returns the last-registered waker, if any./// SAFETY: The driver lock must be held while invoking this function, and/// the entry must not be in any wheel linked lists.generate_shard_id// Generates a shard id. If current thread is a worker thread, we use its worker index as a shard id.// Otherwise, we use a random number generator to obtain the shard id.//! Timer state structures.//! This module contains the heart of the intrusive timer implementation, and as//! such the structures inside are full of tricky concurrency and unsafe code.//! # Ground rules//! The heart of the timer implementation here is the [`TimerShared`] structure,//! shared between the [`TimerEntry`] and the driver. Generally, we permit access//! to [`TimerShared`] ONLY via either 1) a mutable reference to [`TimerEntry`] or//! 2) a held driver lock.//! It follows from this that any changes made while holding BOTH 1 and 2 will//! be reliably visible, regardless of ordering. This is because of the `acq/rel`//! fences on the driver lock ensuring ordering with 2, and rust mutable//! reference rules for 1 (a mutable reference to an object can't be passed//! between threads without an `acq/rel` barrier, and same-thread we have local//! happens-before ordering).//! # State field//! Each timer has a state field associated with it. This field contains either//! the current scheduled time, or a special flag value indicating its state.//! This state can either indicate that the timer is on the 'pending' queue (and//! thus will be fired with an `Ok(())` result soon) or that it has already been//! fired/deregistered.//! This single state field allows for code that is firing the timer to//! synchronize with any racing `reset` calls reliably.//! # Cached vs true timeouts//! To allow for the use case of a timeout that is periodically reset before//! expiration to be as lightweight as possible, we support optimistically//! lock-free timer resets, in the case where a timer is rescheduled to a later//! point than it was originally scheduled for.//! This is accomplished by lazily rescheduling timers. That is, we update the//! state field with the true expiration of the timer from the holder of//! the [`TimerEntry`]. When the driver services timers (ie, whenever it's//! walking lists of timers), it checks this "true when" value, and reschedules//! based on it.//! We do, however, also need to track what the expiration time was when we//! originally registered the timer; this is used to locate the right linked//! list when the timer is being cancelled. This is referred to as the "cached//! when" internally.//! There is of course a race condition between timer reset and timer//! expiration. If the driver fails to observe the updated expiration time, it//! could trigger expiration of the timer too early. However, because//! [`mark_pending`][mark_pending] performs a compare-and-swap, it will identify this race and//! refuse to mark the timer as pending.//! [mark_pending]: TimerHandle::mark_pending/// Handle to time driver instance./// Returns the time source associated with this handle./// Checks whether the driver has been shutdown./// Track that the driver is being unparkedAtomicOptionNonZeroU64// A helper type to store the `next_wake`./// Parker to delegate to./// Time implementation that drives [`Sleep`][sleep], [`Interval`][interval], and [`Timeout`][timeout]./// A `Driver` instance tracks the state necessary for managing time and/// notifying the [`Sleep`][sleep] instances once their deadlines are reached./// It is expected that a single instance manages many individual [`Sleep`][sleep]/// instances. The `Driver` implementation is thread-safe and, as such, is able/// to handle callers from across threads./// After creating the `Driver` instance, the caller must repeatedly call `park`/// or `park_timeout`. The time driver will perform no work unless `park` or/// `park_timeout` is called repeatedly./// The driver has a resolution of one millisecond. Any unit of time that falls/// between milliseconds are rounded up to the next millisecond./// When an instance is dropped, any outstanding [`Sleep`][sleep] instance that has not/// elapsed will be notified with an error. At this point, calling `poll` on the/// [`Sleep`][sleep] instance will result in panic./// The time driver is based on the [paper by Varghese and Lauck][paper]./// A hashed timing wheel is a vector of slots, where each slot handles a time/// slice. As time progresses, the timer walks over the slot for the current/// instant, and processes each entry for that slot. When the timer reaches the/// end of the wheel, it starts again at the beginning./// The implementation maintains six wheels arranged in a set of levels. As the/// levels go up, the slots of the associated wheel represent larger intervals/// of time. At each level, the wheel has 64 slots. Each slot covers a range of/// time equal to the wheel at the lower level. At level zero, each slot/// represents one millisecond of time./// The wheels are:/// * Level 0: 64 x 1 millisecond slots./// * Level 1: 64 x 64 millisecond slots./// * Level 2: 64 x ~4 second slots./// * Level 3: 64 x ~4 minute slots./// * Level 4: 64 x ~4 hour slots./// * Level 5: 64 x ~12 day slots./// When the timer processes entries at level zero, it will notify all the/// `Sleep` instances as their deadlines have been reached. For all higher/// levels, all entries will be redistributed across the wheel at the next level/// down. Eventually, as time progresses, entries with [`Sleep`][sleep] instances will/// either be canceled (dropped) or their associated entries will reach level/// zero and be notified./// [paper]: http://www.cs.columbia.edu/~nahum/w6998/papers/ton97-timing-wheels.pdf/// [sleep]: crate::time::Sleep/// [timeout]: crate::time::Timeout/// [interval]: crate::time::Intervalnext_wake/// The earliest time at which we promise to wake up without unparking.wheelsShardedWheel/// Sharded Timer wheels.wheels_len/// Number of entries in the sharded timer wheels./// True if the driver is being shutdown./// Timer state shared between `Driver`, `Handle`, and `Registration`./// Wrapper around the sharded timer wheels./// Creates a new `Driver` instance that uses `park` to block the current/// thread and `time_source` to get the current time and convert to ticks./// Specifying the source of time is useful when testing.park_internalpark_thread_timeoutnext_wake_time// Helper function to turn expiration_time into next_wake_time.// Since the `park_timeout` will round up to 1ms for avoiding very// short-duration microsecond-resolution sleeps, we do the same here.// The conversion is as follows// None => None// Some(0) => Some(1)// Some(i) => Some(i)/// Runs timer related logic, and returns the next wakeup timeprocess_at_timeprocess_at_sharded_time// Returns the next wakeup time of this shard.clear_entry/// Removes a registered timer from the driver./// The timer will be moved to the cancelled state. Wakers will _not_ be/// invoked. If the timer is already completed, this function is a no-op./// This function always acquires the driver lock, even if the entry does/// not appear to be registered./// SAFETY: The timer must not be registered with some other driver, and/// `add_entry` must not be called concurrently./// Removes and re-adds an entry to the driver./// SAFETY: The timer must be either unregistered, or registered with this/// driver. No other threads are allowed to concurrently manipulate the/// timer at all (the current thread should hold an exclusive reference to/// the `TimerEntry`)// Check whether the driver has been shutdown// Gets the number of shards.lock_sharded_wheel/// Locks the driver's sharded wheel structure.// Currently, rust warns when an unsafe fn contains an unsafe {} block. However,// in the future, this will change to the reverse. For now, suppress this// warning and generally stick with being explicit about unsafety.//! Time driver.// ===== impl Inner =====// ===== impl ShardedWheel =====/// A structure which handles conversion from Instants to `u64` timestamps.deadline_to_tickinstant_to_ticktick_to_durationsingle_timerdrop_timerchange_wakerreset_futurepoll_process_levelspoll_process_levels_targetedinstant_to_tick_max/// Bit field tracking which slots currently contain entries./// Using a bit field to track slots that contain entries allows avoiding a/// scan to find entries. This field is updated when entries are added or/// removed from a slot./// The least-significant bit represents slot zero.LEVEL_MULT/// Slots. We access these via the EntryInner `current_list` as well, so this needs to be an `UnsafeCell`./// Wheel for a single level in the timer. This wheel contains 64 slots./// The level containing the slot./// The slot index./// The instant at which the slot needs to be processed./// Indicates when a slot must be processed next./// Level multiplier./// Being a power of 2 is very important.next_expiration/// Finds the slot that needs to be processed next and returns the slot and/// `Instant` at which this slot must be processed.next_occupied_slottake_slotoccupied_bitslot_rangelevel_rangeslot_for/// Converts a duration (milliseconds) and a level to a slot position.test_slot_for/// The number of milliseconds elapsed since the wheel started./// Timer wheel./// Levels:/// * 1 ms slots / 64 ms range/// * 64 ms slots / ~ 4 sec range/// * ~ 4 sec slots / ~ 4 min range/// * ~ 4 min slots / ~ 4 hr range/// * ~ 4 hr slots / ~ 12 day range/// * ~ 12 day slots / ~ 2 yr range/// Entries queued for firing/// Timing wheel implementation./// This type provides the hashed timing wheel implementation that backs `Timer`/// and `DelayQueue`./// The structure is generic over `T: Stack`. This allows handling timeout data/// being stored on the heap or in a slab. In order to support the latter case,/// the slab must be passed into each function allowing the implementation to/// lookup timer entries./// See `Timer` documentation for some implementation notes./// Number of levels. Each level has 64 slots. By using 6 levels with 64 slots/// each, the timer is able to track time up to 2 years into the future with a/// precision of 1 millisecond.MAX_DURATION/// The maximum duration of a `Sleep`./// Creates a new timing wheel./// Returns the number of milliseconds that have elapsed since the timing/// wheel's creation./// Inserts an entry into the timing wheel./// * `item`: The item to insert into the wheel./// Returns `Ok` when the item is successfully inserted, `Err` otherwise./// `Err(Elapsed)` indicates that `when` represents an instant that has/// already passed. In this case, the caller should fire the timeout/// `Err(Invalid)` indicates an invalid `when` argument as been supplied./// This function registers item into an intrusive linked list. The caller/// must ensure that `item` is pinned and will not be dropped without first/// being deregistered./// Removes `item` from the timing wheel.poll_at/// Instant at which to poll./// Advances the timer up to the instant represented by `now`./// Returns the instant at which the next timeout expires.next_expiration_time/// Returns the tick at which this timer wheel next needs to perform some/// processing, or None if there are no timers registered.no_expirations_before/// Used for debug assertionsprocess_expiration/// iteratively find entries that are between the wheel's current/// time and the expiration time.  for each in that population either/// queue it for notification (in the case of the last level) or tier/// it down to the next level (in all other cases).set_elapsedtake_entries/// Obtains the list of entries that need processing for the given expiration.level_fortest_level_foros_implctrl_c/// Completes when a "ctrl-c" notification is sent to the process./// While signals are handled very differently between Unix and Windows, both/// platforms support receiving a signal on "ctrl-c". This function provides a/// portable API for receiving this notification./// Once the returned future is polled, a listener is registered. The future/// will complete on the first received `ctrl-c` **after** the initial call to/// either `Future::poll` or `.await`./// On Unix platforms, the first time that a `Signal` instance is registered for a/// particular signal kind, an OS signal-handler is installed which replaces the/// default platform behavior when that signal is received, **for the duration of/// the entire process**./// For example, Unix systems will terminate a process by default when it/// receives a signal generated by `"CTRL+C"` on the terminal. But, when a/// `ctrl_c` stream is created to listen for this signal, the time it arrives,/// it will be translated to a stream event, and the process will continue to/// execute.  **Even if this `Signal` instance is dropped, subsequent `SIGINT`/// deliveries will end up captured by Tokio, and the default platform behavior/// will NOT be reset**./// Thus, applications should take care to ensure the expected signal behavior/// occurs as expected after listening for specific signals./// use tokio::signal;///     println!("waiting for ctrl-c");///     signal::ctrl_c().await.expect("failed to listen for event");///     println!("received ctrl-c event");/// Listen in the background:///     tokio::signal::ctrl_c().await.unwrap();///     // Your handler hereOsExtraDataOsStoragereusable_boxReusableBoxFutureRxFuturemake_future//! Asynchronous signal handling for Tokio.//! Note that signal handling is in general a very tricky topic and should be//! used with great care. This crate attempts to implement 'best practice' for//! signal handling, but it should be evaluated for your own applications' needs//! to see if it's suitable.//! There are some fundamental limitations of this crate documented on the OS//! specific structures, as well.//! Print on "ctrl-c" notification.//! use tokio::signal;//!     signal::ctrl_c().await?;//!     println!("ctrl-c received!");//! Wait for `SIGHUP` on Unix//! # #[cfg(unix)] {//! use tokio::signal::unix::{signal, SignalKind};//!     // An infinite stream of hangup signals.//!     let mut stream = signal(SignalKind::hangup())?;//!     // Print whenever a HUP signal is received//!         stream.recv().await;//!         println!("got signal HUP");EventIdEventInfo/// State for a specific event, whether a notification is pending delivery,/// and what listeners are registered./// Gets the `EventInfo` for `id` if it exists./// Invokes `f` once for each defined `EventInfo` in this storage./// An interface for retrieving the `EventInfo` for a particular `eventId`./// An interface for initializing a type. Useful for situations where we cannot/// inject a configured instance in the constructor of another type./// Manages and distributes event notifications to any registered listeners./// Generic over the underlying storage to allow for domain specific/// optimizations (e.g. `eventIds` may or may not be contiguous).register_listener/// Registers a new listener for `event_id`.record_event/// Marks `event_id` as having been delivered, without broadcasting it to/// any listeners./// Broadcasts all previously recorded events to their respective listeners./// Returns `true` if an event was delivered to at least one listener.Globalsglobals_init"invalid event_id: 1"register_panics_on_invalid_inputrecord_invalid_event_does_nothingbroadcast_returns_if_at_least_one_event_fired/// A reusable `Pin<Box<dyn Future<Output = T> + Send>>`./// This type lets you replace the future stored in the box without/// reallocating when the size and alignment permits this./// Create a new `ReusableBoxFuture<T>` containing the provided future./// Replaces the future currently stored in this box./// This reallocates if and only if the layout of the provided future is/// different from the layout of the currently stored future.try_set/// This function never reallocates, but returns an error if the provided/// future has a different size or alignment from the currently storedset_same_layout/// Sets the current future./// This function requires that the layout of the provided future is the/// same as `self.layout`.get_pin/// Gets a pinned reference to the underlying future./// Polls the future stored inside this box.// The future stored inside ReusableBoxFuture<T> must be Send.// The only method called on self.boxed is poll, which takes &mut self, so this// struct being Sync does not permit any invalid access to the Future, even if// the future is not Sync.// Just like a Pin<Box<dyn Future>> is always Unpin, so is this type.test_different_futurestest_different_sizesZeroSizedFuturetest_zero_sized/// Represents the specific kind of signal to listen for./// Allows for listening to any valid OS signal./// For example, this can be used for listening for platform-specific/// # use tokio::signal::unix::SignalKind;/// # let signum = -1;/// // let signum = libc::OS_SPECIFIC_SIGNAL;/// let kind = SignalKind::from_raw(signum);// Use `std::os::raw::c_int` on public API to prevent leaking a non-stable// type alias from libc.// `libc::c_int` and `std::os::raw::c_int` are currently the same type, and are// unlikely to change to other types, but technically libc can change this// in the future minor version.// See https://github.com/tokio-rs/tokio/issues/3767 for more.as_raw_value/// Get the signal's numeric value./// let kind = SignalKind::interrupt();/// assert_eq!(kind.as_raw_value(), libc::SIGINT);/// Represents the `SIGALRM` signal./// On Unix systems this signal is sent when a real-time timer has expired./// By default, the process is terminated by this signal./// Represents the `SIGCHLD` signal./// On Unix systems this signal is sent when the status of a child process/// has changed. By default, this signal is ignored.hangup/// Represents the `SIGHUP` signal./// On Unix systems this signal is sent when the terminal is disconnected./// Represents the `SIGINT` signal./// On Unix systems this signal is sent to interrupt a program./// Represents the `SIGIO` signal./// On Unix systems this signal is sent when I/O operations are possible/// on some file descriptor. By default, this signal is ignored./// Represents the `SIGPIPE` signal./// On Unix systems this signal is sent when the process attempts to write/// to a pipe which has no reader. By default, the process is terminated by/// this signal./// Represents the `SIGQUIT` signal./// On Unix systems this signal is sent to issue a shutdown of the/// process, after which the OS will dump the process core./// Represents the `SIGTERM` signal./// process. By default, the process is terminated by this signal.user_defined1/// Represents the `SIGUSR1` signal./// On Unix systems this is a user defined signal.user_defined2/// Represents the `SIGUSR2` signal.window_change/// Represents the `SIGWINCH` signal./// On Unix systems this signal is sent when the terminal window is resized./// By default, this signal is ignored./// Our global signal handler for all signals registered by this module./// The purpose of this signal handler is to primarily:/// 1. Flag that our specific signal was received (e.g. store an atomic flag)/// 2. Wake up the driver by writing a byte to a pipe/// Those two operations should both be async-signal safe.signal_enable/// Enables this module to receive signal notifications for the `signal`/// This will register the signal handler if it hasn't already been registered,/// returning any error along the way if that fails./// An listener for receiving a particular type of OS signal./// The listener can be turned into a `Stream` using [`SignalStream`]./// [`SignalStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.SignalStream.html/// In general signal handling on Unix is a pretty tricky topic, and this/// structure is no exception! There are some important limitations to keep in/// mind when using `Signal` streams:/// * Signals handling in Unix already necessitates coalescing signals///   together sometimes. This `Signal` stream is also no exception here in///   that it will also coalesce signals. That is, even if the signal handler///   for this process runs multiple times, the `Signal` stream may only return///   one signal notification. Specifically, before `poll` is called, all///   signal notifications are coalesced into one item returned from `poll`.///   Once `poll` has been called, however, a further signal is guaranteed to///   be yielded as an item.///   Put another way, any element pulled off the returned listener corresponds to///   *at least one* signal, but possibly more./// * Signal handling in general is relatively inefficient. Although some///   improvements are possible in this crate, it's recommended to not plan on///   having millions of signal channels open./// If you've got any questions about this feel free to open an issue on the/// repo! New approaches to alleviate some of these limitations are always/// appreciated!/// The first time that a `Signal` instance is registered for a particular/// signal kind, an OS signal-handler is installed which replaces the default/// platform behavior when that signal is received, **for the duration of the/// entire process**./// receives `SIGINT`. But, when a `Signal` instance is created to listen for/// this signal, the next `SIGINT` that arrives will be translated to a stream/// event, and the process will continue to execute. **Even if this `Signal`/// instance is dropped, subsequent `SIGINT` deliveries will end up captured by/// Tokio, and the default platform behavior will NOT be reset**./// Wait for `SIGHUP`/// use tokio::signal::unix::{signal, SignalKind};/// async fn main() -> Result<(), Box<dyn std::error::Error>> {///     // An infinite stream of hangup signals.///     let mut sig = signal(SignalKind::hangup())?;///     // Print whenever a HUP signal is received///         sig.recv().await;///         println!("got signal HUP");/// Creates a new listener which will receive notifications when the current/// process receives the specified signal `kind`./// This function will create a new stream which binds to the default reactor./// The `Signal` stream is an infinite stream which will receive/// notifications whenever a signal is received. More documentation can be/// found on `Signal` itself, but to reiterate:/// * Signals may be coalesced beyond what the kernel already does./// * Once a signal handler is registered with the process the underlying///   libc signal handler is never unregistered./// A `Signal` stream can be created for a particular signal number/// multiple times. When a signal is received then all the associated/// channels will receive the signal notification./// * If the lower-level C functions fail for some reason./// * If the previous initialization of this specific signal failed./// * If the signal is one of///   [`signal_hook::FORBIDDEN`](fn@signal_hook_registry::register#panics)/// Receives the next signal notification event./// `None` is returned if no more events can be received by this stream./// This method is cancel safe. If you use it as the event in a/// completes first, then it is guaranteed that no signal is lost.///     let mut stream = signal(SignalKind::hangup())?;///         stream.recv().await;/// Polls to receive the next signal notification event, outside of an/// `async` context.///  * `Poll::Pending` if no signals are available but the channel is not///    closed.///  * `Poll::Ready(Some(()))` if a signal is available.///  * `Poll::Ready(None)` if the channel has been closed and all signals///    sent before it was closed have been received./// Polling from a manually implemented future/// use tokio::signal::unix::Signal;/// struct MyFuture {///     signal: Signal,/// impl Future for MyFuture {///     type Output = Option<()>;///     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {///         println!("polling MyFuture");///         self.signal.poll_recv(cx)// Work around for abstracting streams internallysignal_enable_error_on_invalid_inputsignal_enable_error_on_forbidden_inputfrom_c_intinto_c_int//! Unix-specific types for signal handling.//! This module is only defined on Unix platforms and contains the primary//! `Signal` type for receiving notifications of signals.ctrl_breakctrl_closectrl_logoffctrl_shutdown//! Stub implementations for the platform API so that rustdoc can build linkable//! documentation on non-windows platforms.event_requires_infinite_sleep_in_handlerglobal_initraise_event"windows/sys.rs""windows/stub.rs"// For building documentation on Unix machines when the `docsrs` flag is set.CtrlC/// Creates a new listener which receives "ctrl-c" notifications sent to the/// use tokio::signal::windows::ctrl_c;///     // A listener of CTRL-C events.///     let mut signal = ctrl_c()?;///     // Print whenever a CTRL-C event is received.///     for countdown in (0..3).rev() {///         signal.recv().await;///         println!("got CTRL-C. {} more to exit", countdown);"listeners do nothing unless polled"/// Represents a listener which receives "ctrl-c" notifications sent to the process/// via `SetConsoleCtrlHandler`./// This event can be turned into a `Stream` using [`CtrlCStream`]./// [`CtrlCStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.CtrlCStream.html/// A notification to this process notifies *all* receivers for/// this event. Moreover, the notifications **are coalesced** if they aren't processed/// quickly enough. This means that if two notifications are received back-to-back,/// then the listener may only receive one item about the two notifications./// `None` is returned if no more events can be received by the listener./// `None` is returned if no more events can be received./// use tokio::signal::windows::CtrlC;///     ctrl_c: CtrlC,///         self.ctrl_c.poll_recv(cx)CtrlBreak/// Represents a listener which receives "ctrl-break" notifications sent to the process/// This listener can be turned into a `Stream` using [`CtrlBreakStream`]./// [`CtrlBreakStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.CtrlBreakStream.html/// `None` is returned if no more events can be received by this listener./// use tokio::signal::windows::ctrl_break;///     // A listener of CTRL-BREAK events.///     let mut signal = ctrl_break()?;///     // Print whenever a CTRL-BREAK event is received.///         println!("got signal CTRL-BREAK");/// use tokio::signal::windows::CtrlBreak;///     ctrl_break: CtrlBreak,///         self.ctrl_break.poll_recv(cx)/// Creates a new listener which receives "ctrl-break" notifications sent to theCtrlClose/// Creates a new listener which receives "ctrl-close" notifications sent to the/// use tokio::signal::windows::ctrl_close;///     // A listener of CTRL-CLOSE events.///     let mut signal = ctrl_close()?;///     // Print whenever a CTRL-CLOSE event is received.///         println!("got CTRL-CLOSE. {} more to exit", countdown);/// Represents a listener which receives "ctrl-close" notifications sent to the process/// A notification to this process notifies *all* listeners listening for///     signal.recv().await;///     println!("got CTRL-CLOSE. Cleaning up before exiting");/// use tokio::signal::windows::CtrlClose;///     ctrl_close: CtrlClose,///         self.ctrl_close.poll_recv(cx)CtrlShutdown/// Creates a new listener which receives "ctrl-shutdown" notifications sent to the/// use tokio::signal::windows::ctrl_shutdown;///     // A listener of CTRL-SHUTDOWN events.///     let mut signal = ctrl_shutdown()?;///     println!("got CTRL-SHUTDOWN. Cleaning up before exiting");/// Represents a listener which receives "ctrl-shutdown" notifications sent to the process///     // Print whenever a CTRL-SHUTDOWN event is received./// use tokio::signal::windows::CtrlShutdown;///     ctrl_shutdown: CtrlShutdown,///         self.ctrl_shutdown.poll_recv(cx)CtrlLogoff/// Creates a new listener which receives "ctrl-logoff" notifications sent to the/// use tokio::signal::windows::ctrl_logoff;///     // A listener of CTRL-LOGOFF events.///     let mut signal = ctrl_logoff()?;///     println!("got CTRL-LOGOFF. Cleaning up before exiting");/// Represents a listener which receives "ctrl-logoff" notifications sent to the process///     // An listener of CTRL-LOGOFF events.///     // Print whenever a CTRL-LOGOFF event is received./// use tokio::signal::windows::CtrlLogoff;///     ctrl_logoff: CtrlLogoff,///         self.ctrl_logoff.poll_recv(cx)//! Windows-specific types for signal handling.//! This module is only defined on Windows and allows receiving "ctrl-c",//! "ctrl-break", "ctrl-logoff", "ctrl-shutdown", and "ctrl-close"//! notifications. These events are listened for via the `SetConsoleCtrlHandler`//! function which receives the corresponding `windows_sys` event type./// A barrier enables multiple tasks to synchronize the beginning of some computation./// use tokio::sync::Barrier;///     handles.push(tokio::spawn(async move {///         let wait_result = c.wait().await;///         wait_result/// // Will not resolve until all "after wait" messages have been printed/// let mut num_leaders = 0;///     let wait_result = handle.await.unwrap();///     if wait_result.is_leader() {///         num_leaders += 1;/// // Exactly one barrier will resolve as the "leader"/// assert_eq!(num_leaders, 1);arrived/// Creates a new barrier that can block a given number of tasks./// A barrier will block `n`-1 tasks which call [`Barrier::wait`] and then wake up all/// tasks at once when the `n`th task calls `wait`./// Does not resolve until all tasks have rendezvoused here./// Barriers are re-usable after all tasks have rendezvoused once, and can/// A single (arbitrary) future will receive a [`BarrierWaitResult`] that returns `true` from/// [`BarrierWaitResult::is_leader`] when returning from this function, and all other tasks/// will receive a result that will return `false` from `is_leader`./// This method is not cancel safe./// A `BarrierWaitResult` is returned by `wait` when all tasks in the `Barrier` have rendezvoused./// Returns `true` if this task from wait is the "leader task"./// Only one task will have `true` returned from their result, all other tasks will have/// `false` returned.Waitlistpermits/// The current number of available permits in the semaphore./// An asynchronous counting semaphore which permits waiting on multiple permits at once.TryAcquireError/// The semaphore has been [closed] and cannot issue new permits./// [closed]: crate::sync::Semaphore::closeNoPermits/// The semaphore has no available permits./// Error returned from the [`Semaphore::try_acquire`] function./// [`Semaphore::try_acquire`]: crate::sync::Semaphore::try_acquireAcquireError/// Error returned from the [`Semaphore::acquire`] function./// An `acquire` operation can only fail if the semaphore has been/// [closed]./// [`Semaphore::acquire`]: crate::sync::Semaphore::acquirenum_permits/// The current state of the waiter./// This is either the number of remaining permits required by/// the waiter, or a flag indicating that the waiter is not yet queued./// The waker to notify the task awaiting permits./// This may only be accessed while the wait queue is locked./// Intrusive linked-list pointers./// TODO: Ideally, we would be able to use loom to enforce that/// this isn't accessed concurrently. However, it is difficult to/// use a `UnsafeCell` here, since the `Link` trait requires _returning_/// references to `Pointers`, and `UnsafeCell` requires that checked access/// take place inside a closure. We should consider changing `Pointers` to/// use `UnsafeCell` internally./// Should not be `Unpin`./// An entry in the wait queue.MAX_PERMITS/// The maximum number of permits which a semaphore can hold./// Note that this reserves three bits of flags in the permit counter, but/// we only actually use one of them. However, the previous semaphore/// implementation used three bits, so we will continue to reserve them to/// avoid a breaking change if additional flags need to be added in thePERMIT_SHIFT// The least-significant bit in the number of permits is reserved to use// as a flag indicating that the semaphore has been closed. Consequently// PERMIT_SHIFT is used to leave that bit for that purpose./// Creates a new semaphore with the initial number of permits/// Maximum number of permits on 32-bit platforms is `1<<29`./// Creates a new semaphore with the initial number of permits./// Creates a new closed semaphore with 0 permits.const_new_closedavailable_permits/// Returns the current number of available permits./// Adds `added` new permits to the semaphore./// The maximum number of permits is `usize::MAX >> 3`, and this function will panic if the limit is exceeded./// Closes the semaphore. This prevents the semaphore from issuing new/// permits and notifies all pending waiters./// Returns true if the semaphore is closed.add_permits_locked/// Release `rem` permits to the semaphore's wait list, starting from the/// end of the queue./// If `rem` exceeds the number of permits needed by the wait list, the/// remainder are assigned back to the semaphore.forget_permits/// Decrease a semaphore's permits by a maximum of `n`./// If there are insufficient permits and it's not possible to reduce by `n`,/// return the number of permits that were actually reduced.poll_acquireassign_permits/// Assign permits to the waiter./// Returns `true` if the waiter should be removed from the queue// Safety: the `Acquire` future is not `Sync` automatically because it contains// a `Waiter`, which, in turn, contains an `UnsafeCell`. However, the// `UnsafeCell` is only accessed when the future is borrowed mutably (either in// `poll` or in `drop`). Therefore, it is safe (although not particularly// _useful_) for the future to be borrowed immutably across threads./// Returns `true` if the error was caused by a closed semaphore.// may be used later!is_no_permits/// Returns `true` if the error was caused by calling `try_acquire` on a/// semaphore with no available permits./// `Waiter` is forced to be !Unpin.//! # Implementation Details.//! The semaphore is implemented using an intrusive linked list of waiters. An//! atomic counter tracks the number of available permits. If the semaphore does//! not contain the required number of permits, the task attempting to acquire//! permits places its waker at the end of a queue. When new permits are made//! available (such as by releasing an initial acquisition), they are assigned//! to the task at the front of the queue, waking that task if its requested//! number of permits is met.//! Because waiters are enqueued at the back of the linked list and dequeued//! from the front, the semaphore is fair. Tasks trying to acquire large numbers//! of permits at a time will always be woken eventually, even if many other//! tasks are acquiring smaller numbers of permits. This means that in a//! use-case like tokio's read-write lock, writers will not be starved by//! readers.// ===== impl AcquireError ====// ===== impl TryAcquireError =====cooperativeGuardedLinkedList/// Sending-half of the [`broadcast`] channel./// May be used from many threads. Messages can be sent with/// [`send`][Sender::send]./// use tokio::sync::broadcast;///     let (tx, mut rx1) = broadcast::channel(16);///     let mut rx2 = tx.subscribe();///         assert_eq!(rx1.recv().await.unwrap(), 10);///         assert_eq!(rx1.recv().await.unwrap(), 20);///         assert_eq!(rx2.recv().await.unwrap(), 10);///         assert_eq!(rx2.recv().await.unwrap(), 20);///     tx.send(10).unwrap();///     tx.send(20).unwrap();/// [`broadcast`]: crate::sync::broadcast/// If all [`Sender`] instances of a channel were dropped and only `WeakSender`/// instances remain, the channel is closed./// In order to send messages, the `WeakSender` needs to be upgraded using/// [`WeakSender::upgrade`], which returns `Option<Sender>`. It returns `None`/// if all `Sender`s have been dropped, and otherwise it returns a `Sender`./// [`Sender`]: Sender/// [`WeakSender::upgrade`]: WeakSender::upgrade/// use tokio::sync::broadcast::channel;///     let (tx, _rx) = channel::<i32>(15);///     let tx_weak = tx.downgrade();///     // Upgrading will succeed because `tx` still exists.///     assert!(tx_weak.upgrade().is_some());///     // If we drop `tx`, then it will fail.///     drop(tx);///     assert!(tx_weak.clone().upgrade().is_none());/// State shared with all receivers and senders./// Next position to read from/// Receiving-half of the [`broadcast`] channel./// Must not be used concurrently. Messages may be retrieved using/// [`recv`][Receiver::recv]./// To turn this receiver into a `Stream`, you can use the [`BroadcastStream`]/// wrapper./// [`BroadcastStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.BroadcastStream.html/// Error returned by the [`send`] function on a [`Sender`]./// A **send** operation can only fail if there are no active receivers,/// implying that the message could never be received. The error contains the/// message being sent as a payload so it can be recovered./// [`send`]: crate::sync::broadcast::Sender::send/// [`Sender`]: crate::sync::broadcast::Sender/// There are no more active senders implying no further messages will everLagged/// The receiver lagged too far behind. Attempting to receive again will/// return the oldest message still retained by the channel./// Includes the number of skipped messages./// An error returned from the [`recv`] function on a [`Receiver`]./// [`recv`]: crate::sync::broadcast::Receiver::recv/// [`Receiver`]: crate::sync::broadcast::Receiver/// The channel is currently empty. There are still active/// [`Sender`] handles, so data may yet become available./// The receiver lagged too far behind and has been forcibly disconnected./// Attempting to receive again will return the oldest message still/// retained by the channel./// An error returned from the [`try_recv`] function on a [`Receiver`]./// [`try_recv`]: crate::sync::broadcast::Receiver::try_recv//! Broadcast error types/// slots in the channel./// Mask a position -> index.Tail/// Tail of the queue. Includes the rx wait list.num_tx/// Number of outstanding Sender handles.num_weak_tx/// Number of outstanding weak Sender handles.notify_last_rx_drop/// Notify when the last subscribed [`Receiver`] drops./// Data shared between senders and receivers./// Next position to write to.rx_cnt/// Number of active receivers./// True if the channel is closed./// Receivers waiting for a value./// Next position to write a value./// Remaining number of receivers that are expected to see this value./// When this goes to zero, the value is released./// An atomic is used as it is mutated concurrently with the slot read lock/// Uniquely identifies the `send` stored in the slot./// The value being broadcast./// The value is set by `send` when the write lock is held. When a reader/// drops, `rem` is decremented. When it hits zero, the value is dropped./// Slot in the buffer./// True if queued./// Task waiting on the broadcast channel.RecvGuard/// Receiver being waited on.WaiterCell/// Receive a value future.// The wrapper around `UnsafeCell` isolates the unsafe impl `Send` and `Sync`// from `Recv`.MAX_RECEIVERS/// Max number of receivers. Reserve space to lock./// Create a bounded, multi-producer, multi-consumer channel where each sent/// value is broadcasted to all active receivers./// **Note:** The actual capacity may be greater than the provided `capacity`./// All data sent on [`Sender`] will become available on every active/// [`Receiver`] in the same order as it was sent./// The `Sender` can be cloned to `send` to the same channel from multiple/// points in the process or it can be used concurrently from an `Arc`. New/// `Receiver` handles are created by calling [`Sender::subscribe`]./// If all [`Receiver`] handles are dropped, the `send` method will return a/// [`SendError`]. Similarly, if all [`Sender`] handles are dropped, the [`recv`]/// method will return a [`RecvError`]./// [`Sender::subscribe`]: crate::sync::broadcast::Sender::subscribe/// [`SendError`]: crate::sync::broadcast::error::SendError/// [`RecvError`]: crate::sync::broadcast::error::RecvError/// This will panic if `capacity` is equal to `0` or larger/// than `usize::MAX / 2`./// Creates the sending-half of the [`broadcast`] channel./// See the documentation of [`broadcast::channel`] for more information on this method./// [`broadcast::channel`]: crate::sync::broadcast::channelnew_with_receiver_count/// Creates the sending-half of the [`broadcast`](self) channel, and provide the receiver/// count./// See the documentation of [`broadcast::channel`](self::channel) for more errors when/// # Safety:/// The caller must ensure that the amount of receivers for this Sender is correct before/// the channel functionalities are used, the count is zero by default, as this function/// does not create any receivers by itself./// Attempts to send a value to all active [`Receiver`] handles, returning/// it back if it could not be sent./// A successful send occurs when there is at least one active [`Receiver`]/// handle. An unsuccessful send would be one where all associated/// [`Receiver`] handles have already been dropped./// On success, the number of subscribed [`Receiver`] handles is returned./// This does not mean that this number of receivers will see the message as/// a receiver may drop or lag ([see lagging](self#lagging)) before receiving/// the message./// A return value of `Ok` **does not** mean that the sent value will be/// observed by all or any of the active [`Receiver`] handles. [`Receiver`]/// handles may be dropped before receiving the sent message./// A return value of `Err` **does not** mean that future calls to `send`/// will fail. New [`Receiver`] handles may be created by calling/// [`subscribe`]./// [`subscribe`]: crate::sync::broadcast::Sender::subscribe/// Creates a new [`Receiver`] handle that will receive values sent **after**/// this call to `subscribe`.///     let (tx, _rx) = broadcast::channel(16);///     // Will not be seen///     let mut rx = tx.subscribe();///     let value = rx.recv().await.unwrap();///     assert_eq!(20, value);"Downgrade creates a WeakSender without destroying the original non-weak sender."/// Converts the `Sender` to a [`WeakSender`] that does not count/// towards RAII semantics, i.e. if all `Sender` instances of the/// channel were dropped and only `WeakSender` instances remain,/// the channel is closed./// Returns the number of queued values./// A value is queued until it has either been seen by all receivers that were alive at the time/// it was sent, or has been evicted from the queue by subsequent sends that exceeded the/// queue's capacity./// In contrast to [`Receiver::len`], this method only reports queued values and not values that/// have been evicted from the queue before being seen by all receivers.///     tx.send(30).unwrap();///     assert_eq!(tx.len(), 3);///     rx1.recv().await.unwrap();///     // The len is still 3 since rx2 hasn't seen the first value yet.///     rx2.recv().await.unwrap();///     assert_eq!(tx.len(), 2);/// Returns true if there are no queued values.///     assert!(tx.is_empty());///     assert!(!tx.is_empty());///     // The queue is still not empty since rx2 hasn't seen the value./// Returns the number of active receivers./// An active receiver is a [`Receiver`] handle returned from [`channel`] or/// [`subscribe`]. These are the handles that will receive values sent on/// this [`Sender`]./// It is not guaranteed that a sent message will reach this number of/// receivers. Active receivers may never call [`recv`] again before/// dropping./// [`channel`]: crate::sync::broadcast::channel///     let (tx, _rx1) = broadcast::channel(16);///     assert_eq!(1, tx.receiver_count());///     let mut _rx2 = tx.subscribe();///     assert_eq!(2, tx.receiver_count());///     let (tx, _rx) = broadcast::channel::<()>(16);///     let tx2 = tx.clone();///     assert!(tx.same_channel(&tx2));///     let (tx3, _rx3) = broadcast::channel::<()>(16);///     assert!(!tx3.same_channel(&tx2));/// A future which completes when the number of [Receiver]s subscribed to this `Sender` reaches/// use futures::FutureExt;///     let (tx, mut rx1) = broadcast::channel::<u32>(16);///     let _ = tx.send(10);///     assert_eq!(rx1.recv().await.unwrap(), 10);///     drop(rx1);///     assert!(tx.closed().now_or_never().is_none());///     assert_eq!(rx2.recv().await.unwrap(), 10);///     drop(rx2);///     assert!(tx.closed().now_or_never().is_some());/// Returns the number of [`Sender`] handles./// Returns the number of [`WeakSender`] handles./// Create a new `Receiver` which reads starting from the tail.WaitersList/// List used in `Shared::notify_rx`. It wraps a guarded linked list/// and gates the access to it on the `Shared.tail` mutex. It also empties/// the list on drop.pop_back_locked/// Removes the last element from the guarded list. Modifying this list/// requires an exclusive access to the main list in `Notify`.notify_rx/// Tries to convert a `WeakSender` into a [`Sender`]./// This will return `Some` if there are other `Sender` instances alive and/// the channel wasn't previously dropped, otherwise `None` is returned./// Returns the number of messages that were sent into the channel and that/// this [`Receiver`] has yet to receive./// If the returned value from `len` is larger than the next largest power of 2/// of the capacity of the channel any call to [`recv`] will return an/// `Err(RecvError::Lagged)` and any call to [`try_recv`] will return an/// `Err(TryRecvError::Lagged)`, e.g. if the capacity of the channel is 10,/// [`recv`] will start to return `Err(RecvError::Lagged)` once `len` returns/// values larger than 16.///     assert_eq!(rx1.len(), 2);///     assert_eq!(rx1.len(), 1);///     assert_eq!(rx1.recv().await.unwrap(), 20);///     assert_eq!(rx1.len(), 0);/// Returns true if there aren't any messages in the channel that the [`Receiver`]/// has yet to receive./// [`Receiver]: create::sync::broadcast::Receiver///     assert!(rx1.is_empty());///     assert!(!rx1.is_empty());///     let (tx, rx) = broadcast::channel::<()>(16);///     let rx2 = tx.subscribe();///     assert!(rx.same_channel(&rx2));///     let (_tx3, rx3) = broadcast::channel::<()>(16);///     assert!(!rx3.same_channel(&rx2));recv_ref/// Locks the next value if there is one.sender_strong_countsender_weak_count/// Checks if a channel is closed./// This method returns `true` if the channel has been closed. The channel is closed/// when all [`Sender`] have been dropped.///     let (tx, rx) = broadcast::channel::<()>(10);///     assert!(!rx.is_closed());///     assert!(rx.is_closed());resubscribe/// Re-subscribes to the channel starting from the current tail element./// This [`Receiver`] handle will receive a clone of all values sent/// **after** it has resubscribed. This will not include elements that are/// in the queue of the current receiver. Consider the following example.///   let (tx, mut rx) = broadcast::channel(2);///   tx.send(1).unwrap();///   let mut rx2 = rx.resubscribe();///   tx.send(2).unwrap();///   assert_eq!(rx2.recv().await.unwrap(), 2);///   assert_eq!(rx.recv().await.unwrap(), 1);/// Receives the next value for this receiver./// Each [`Receiver`] handle will receive a clone of all values sent/// **after** it has subscribed./// `Err(RecvError::Closed)` is returned when all `Sender` halves have/// dropped, indicating that no further values can be sent on the channel./// If the [`Receiver`] handle falls behind, once the channel is full, newly/// sent values will overwrite old values. At this point, a call to [`recv`]/// will return with `Err(RecvError::Lagged)` and the [`Receiver`]'s/// internal cursor is updated to point to the oldest value still held by/// the channel. A subsequent call to [`recv`] will return this value/// **unless** it has been since overwritten./// Handling lag///     let (tx, mut rx) = broadcast::channel(2);///     // The receiver lagged behind///     assert!(rx.recv().await.is_err());///     // At this point, we can abort or continue with lost messages///     assert_eq!(20, rx.recv().await.unwrap());///     assert_eq!(30, rx.recv().await.unwrap());/// Attempts to return a pending value on this receiver without awaiting./// This is useful for a flavor of "optimistic check" before deciding to/// await on a receiver./// Compared with [`recv`], this function has three failure cases instead of two/// (one for closed, one for an empty buffer, one for a lagging receiver)./// `Err(TryRecvError::Closed)` is returned when all `Sender` halves have/// will return with `Err(TryRecvError::Lagged)` and the [`Receiver`]'s/// the channel. A subsequent call to [`try_recv`] will return this value/// **unless** it has been since overwritten. If there are no values to/// receive, `Err(TryRecvError::Empty)` is returned.///     let (tx, mut rx) = broadcast::channel(16);///     assert!(rx.try_recv().is_err());///     let value = rx.try_recv().unwrap();///     assert_eq!(10, value);blocking_recv/// Blocking receive to call outside of asynchronous contexts./// This function panics if called within an asynchronous execution///     let sync_code = thread::spawn(move || {///         assert_eq!(rx.blocking_recv(), Ok(10));///     sync_code.join().unwrap();/// A custom `project` implementation is used in place of `pin-project-lite`/// as a custom drop implementation is needed.clone_valuereceiver_count_on_sender_constructorreceiver_count_on_channel_constructor//! A multi-producer, multi-consumer broadcast queue. Each sent value is seen by//! all consumers.//! A [`Sender`] is used to broadcast values to **all** connected [`Receiver`]//! values. [`Sender`] handles are clone-able, allowing concurrent send and//! receive actions. [`Sender`] and [`Receiver`] are both `Send` and `Sync` as//! long as `T` is `Send`.//! When a value is sent, **all** [`Receiver`] handles are notified and will//! receive the value. The value is stored once inside the channel and cloned on//! demand for each receiver. Once all receivers have received a clone of the//! value, the value is released from the channel.//! A channel is created by calling [`channel`], specifying the maximum number//! of messages the channel can retain at any given time.//! New [`Receiver`] handles are created by calling [`Sender::subscribe`]. The//! returned [`Receiver`] will receive values sent **after** the call to//! `subscribe`.//! This channel is also suitable for the single-producer multi-consumer//! use-case, where a single sender broadcasts values to many receivers.//! ## Lagging//! As sent messages must be retained until **all** [`Receiver`] handles receive//! a clone, broadcast channels are susceptible to the "slow receiver" problem.//! In this case, all but one receiver are able to receive values at the rate//! they are sent. Because one receiver is stalled, the channel starts to fill//! up.//! This broadcast channel implementation handles this case by setting a hard//! upper bound on the number of values the channel may retain at any given//! time. This upper bound is passed to the [`channel`] function as an argument.//! If a value is sent when the channel is at capacity, the oldest value//! currently held by the channel is released. This frees up space for the new//! value. Any receiver that has not yet seen the released value will return//! [`RecvError::Lagged`] the next time [`recv`] is called.//! Once [`RecvError::Lagged`] is returned, the lagging receiver's position is//! updated to the oldest value contained by the channel. The next call to//! [`recv`] will return this value.//! This behavior enables a receiver to detect when it has lagged so far behind//! that data has been dropped. The caller may decide how to respond to this://! either by aborting its task or by tolerating lost messages and resuming//! consumption of the channel.//! ## Closing//! When **all** [`Sender`] handles have been dropped, no new values may be//! sent. At this point, the channel is "closed". Once a receiver has received//! all values retained by the channel, the next call to [`recv`] will return//! with [`RecvError::Closed`].//! When a [`Receiver`] handle is dropped, any messages not read by the receiver//! will be marked as read. If this receiver was the only one not to have read//! that message, the message will be dropped at this point.//! [`Sender`]: crate::sync::broadcast::Sender//! [`Sender::subscribe`]: crate::sync::broadcast::Sender::subscribe//! [`Receiver`]: crate::sync::broadcast::Receiver//! [`channel`]: crate::sync::broadcast::channel//! [`RecvError::Lagged`]: crate::sync::broadcast::error::RecvError::Lagged//! [`RecvError::Closed`]: crate::sync::broadcast::error::RecvError::Closed//! [`recv`]: crate::sync::broadcast::Receiver::recv//! Basic usage//! use tokio::sync::broadcast;//!     let (tx, mut rx1) = broadcast::channel(16);//!     let mut rx2 = tx.subscribe();//!         assert_eq!(rx1.recv().await.unwrap(), 10);//!         assert_eq!(rx1.recv().await.unwrap(), 20);//!         assert_eq!(rx2.recv().await.unwrap(), 10);//!         assert_eq!(rx2.recv().await.unwrap(), 20);//!     tx.send(10).unwrap();//!     tx.send(20).unwrap();//! Handling lag//!     let (tx, mut rx) = broadcast::channel(2);//!     tx.send(30).unwrap();//!     // The receiver lagged behind//!     assert!(rx.recv().await.is_err());//!     // At this point, we can abort or continue with lost messages//!     assert_eq!(20, rx.recv().await.unwrap());//!     assert_eq!(30, rx.recv().await.unwrap());r" Named future types."OwnedMappedMutexGuardbatch_semaphoreSemaphorePermitOwnedSemaphorePermitowned_read_guardOwnedRwLockReadGuardowned_write_guardOwnedRwLockWriteGuardowned_write_guard_mappedOwnedRwLockMappedWriteGuardwrite_guard_mappedRwLockMappedWriteGuardSetError/// Unit tests//! Synchronization primitives for use in asynchronous contexts.//! Tokio programs tend to be organized as a set of [tasks] where each task//! operates independently and may be executed on separate physical threads. The//! synchronization primitives provided in this module permit these independent//! tasks to communicate together.//! # Message passing//! The most common form of synchronization in a Tokio program is message//! passing. Two tasks operate independently and send messages to each other to//! synchronize. Doing so has the advantage of avoiding shared state.//! Message passing is implemented using channels. A channel supports sending a//! message from one producer task to one or more consumer tasks. There are a//! few flavors of channels provided by Tokio. Each channel flavor supports//! different message passing patterns. When a channel supports multiple//! producers, many separate tasks may **send** messages. When a channel//! supports multiple consumers, many different separate tasks may **receive**//! messages.//! Tokio provides many different channel flavors as different message passing//! patterns are best handled with different implementations.//! ## `oneshot` channel//! The [`oneshot` channel][oneshot] supports sending a **single** value from a//! single producer to a single consumer. This channel is usually used to send//! the result of a computation to a waiter.//! **Example:** using a [`oneshot` channel][oneshot] to receive the result of a//! computation.//! use tokio::sync::oneshot;//! async fn some_computation() -> String {//!     "represents the result of the computation".to_string()//!     let (tx, rx) = oneshot::channel();//!         let res = some_computation().await;//!         tx.send(res).unwrap();//!     // Do other work while the computation is happening in the background//!     // Wait for the computation result//!     let res = rx.await.unwrap();//! Note, if the task produces a computation result as its final//! action before terminating, the [`JoinHandle`] can be used to//! receive that value instead of allocating resources for the//! `oneshot` channel. Awaiting on [`JoinHandle`] returns `Result`. If//! the task panics, the `Joinhandle` yields `Err` with the panic//! cause.//! **Example:**//!     "the result of the computation".to_string()//!     let join_handle = tokio::spawn(async move {//!         some_computation().await//!     let res = join_handle.await.unwrap();//! ## `mpsc` channel//! The [`mpsc` channel][mpsc] supports sending **many** values from **many**//! producers to a single consumer. This channel is often used to send work to a//! task or to receive the result of many computations.//! This is also the channel you should use if you want to send many messages//! from a single producer to a single consumer. There is no dedicated spsc//! channel.//! **Example:** using an mpsc to incrementally stream the results of a series//! of computations.//! use tokio::sync::mpsc;//! async fn some_computation(input: u32) -> String {//!     format!("the result of computation {}", input)//!     let (tx, mut rx) = mpsc::channel(100);//!         for i in 0..10 {//!             let res = some_computation(i).await;//!             tx.send(res).await.unwrap();//!     while let Some(res) = rx.recv().await {//!         println!("got = {}", res);//! The argument to `mpsc::channel` is the channel capacity. This is the maximum//! number of values that can be stored in the channel pending receipt at any//! given time. Properly setting this value is key in implementing robust//! programs as the channel capacity plays a critical part in handling back//! pressure.//! A common concurrency pattern for resource management is to spawn a task//! dedicated to managing that resource and using message passing between other//! tasks to interact with the resource. The resource may be anything that may//! not be concurrently used. Some examples include a socket and program state.//! For example, if multiple tasks need to send data over a single socket, spawn//! a task to manage the socket and use a channel to synchronize.//! **Example:** sending data from many tasks over a single socket using message//! passing.//! use tokio::io::{self, AsyncWriteExt};//!     let mut socket = TcpStream::connect("www.example.com:1234").await?;//!         // Each task needs its own `tx` handle. This is done by cloning the//!         // original handle.//!         let tx = tx.clone();//!             tx.send(&b"data to write"[..]).await.unwrap();//!     // The `rx` half of the channel returns `None` once **all** `tx` clones//!     // drop. To ensure `None` is returned, drop the handle owned by the//!     // current task. If this `tx` handle is not dropped, there will always//!     // be a single outstanding `tx` handle.//!     drop(tx);//!         socket.write_all(res).await?;//! The [`mpsc`] and [`oneshot`] channels can be combined to provide a request ///! response type synchronization pattern with a shared resource. A task is//! spawned to synchronize a resource and waits on commands received on a//! [`mpsc`] channel. Each command includes a [`oneshot`] `Sender` on which the//! result of the command is sent.//! **Example:** use a task to synchronize a `u64` counter. Each task sends an//! "fetch and increment" command. The counter value **before** the increment is//! sent over the provided `oneshot` channel.//! use tokio::sync::{oneshot, mpsc};//! use Command::Increment;//!     Increment,//!     // Other commands can be added here//!     let (cmd_tx, mut cmd_rx) = mpsc::channel::<(Command, oneshot::Sender<u64>)>(100);//!     // Spawn a task to manage the counter//!         let mut counter: u64 = 0;//!         while let Some((cmd, response)) = cmd_rx.recv().await {//!             match cmd {//!                 Increment => {//!                     let prev = counter;//!                     counter += 1;//!                     response.send(prev).unwrap();//!     let mut join_handles = vec![];//!     // Spawn tasks that will send the increment command.//!         let cmd_tx = cmd_tx.clone();//!         join_handles.push(tokio::spawn(async move {//!             let (resp_tx, resp_rx) = oneshot::channel();//!             cmd_tx.send((Increment, resp_tx)).await.ok().unwrap();//!             let res = resp_rx.await.unwrap();//!             println!("previous value = {}", res);//!         }));//!     // Wait for all tasks to complete//!     for join_handle in join_handles.drain(..) {//!         join_handle.await.unwrap();//! ## `broadcast` channel//! The [`broadcast` channel] supports sending **many** values from//! **many** producers to **many** consumers. Each consumer will receive//! **each** value. This channel can be used to implement "fan out" style//! patterns common with pub / sub or "chat" systems.//! This channel tends to be used less often than `oneshot` and `mpsc` but still//! has its use cases.//! This is also the channel you should use if you want to broadcast values from//! a single producer to many consumers. There is no dedicated spmc broadcast//! [`broadcast` channel]: crate::sync::broadcast//! ## `watch` channel//! The [`watch` channel] supports sending **many** values from a **many**//! producer to **many** consumers. However, only the **most recent** value is//! stored in the channel. Consumers are notified when a new value is sent, but//! there is no guarantee that consumers will see **all** values.//! The [`watch` channel] is similar to a [`broadcast` channel] with capacity 1.//! Use cases for the [`watch` channel] include broadcasting configuration//! changes or signalling program state changes, such as transitioning to//! shutdown.//! **Example:** use a [`watch` channel] to notify tasks of configuration//! changes. In this example, a configuration file is checked periodically. When//! the file changes, the configuration changes are signalled to consumers.//! use tokio::sync::watch;//! use tokio::time::{self, Duration, Instant};//! #[derive(Debug, Clone, Eq, PartialEq)]//!     timeout: Duration,//! impl Config {//!     async fn load_from_file() -> io::Result<Config> {//!         // file loading and deserialization logic here//! # Ok(Config { timeout: Duration::from_secs(1) })//! async fn my_async_operation() {//!     // Do something here//!     // Load initial configuration value//!     let mut config = Config::load_from_file().await.unwrap();//!     // Create the watch channel, initialized with the loaded configuration//!     let (tx, rx) = watch::channel(config.clone());//!     // Spawn a task to monitor the file.//!             // Wait 10 seconds between checks//!             time::sleep(Duration::from_secs(10)).await;//!             // Load the configuration file//!             let new_config = Config::load_from_file().await.unwrap();//!             // If the configuration changed, send the new config value//!             // on the watch channel.//!             if new_config != config {//!                 tx.send(new_config.clone()).unwrap();//!                 config = new_config;//!     let mut handles = vec![];//!     // Spawn tasks that runs the async operation for at most `timeout`. If//!     // the timeout elapses, restart the operation.//!     // The task simultaneously watches the `Config` for changes. When the//!     // timeout duration changes, the timeout is updated without restarting//!     // the in-flight operation.//!     for _ in 0..5 {//!         // Clone a config watch handle for use in this task//!         let mut rx = rx.clone();//!         let handle = tokio::spawn(async move {//!             // Start the initial operation and pin the future to the stack.//!             // Pinning to the stack is required to resume the operation//!             // across multiple calls to `select!`//!             let op = my_async_operation();//!             tokio::pin!(op);//!             // Get the initial config value//!             let mut conf = rx.borrow().clone();//!             let mut op_start = Instant::now();//!             let sleep = time::sleep_until(op_start + conf.timeout);//!             tokio::pin!(sleep);//!                 tokio::select! {//!                     _ = &mut sleep => {//!                         // The operation elapsed. Restart it//!                         op.set(my_async_operation());//!                         // Track the new start time//!                         op_start = Instant::now();//!                         // Restart the timeout//!                         sleep.set(time::sleep_until(op_start + conf.timeout));//!                     _ = rx.changed() => {//!                         conf = rx.borrow_and_update().clone();//!                         // The configuration has been updated. Update the//!                         // `sleep` using the new `timeout` value.//!                         sleep.as_mut().reset(op_start + conf.timeout);//!                     _ = &mut op => {//!                         // The operation completed!//!                         return//!         handles.push(handle);//!     for handle in handles.drain(..) {//!         handle.await.unwrap();//! [`watch` channel]: mod@crate::sync::watch//! [`broadcast` channel]: mod@crate::sync::broadcast//! # State synchronization//! The remaining synchronization primitives focus on synchronizing state.//! These are asynchronous equivalents to versions provided by `std`. They//! operate in a similar way as their `std` counterparts but will wait//! asynchronously instead of blocking the thread.//! * [`Barrier`] Ensures multiple tasks will wait for each other to reach a//!   point in the program, before continuing execution all together.//! * [`Mutex`] Mutual Exclusion mechanism, which ensures that at most one//!   thread at a time is able to access some data.//! * [`Notify`] Basic task notification. `Notify` supports notifying a//!   receiving task without sending data. In this case, the task wakes up and//!   resumes processing.//! * [`RwLock`] Provides a mutual exclusion mechanism which allows multiple//!   readers at the same time, while allowing only one writer at a time. In//!   some cases, this can be more efficient than a mutex.//! * [`Semaphore`] Limits the amount of concurrency. A semaphore holds a//!   number of permits, which tasks may request in order to enter a critical//!   section. Semaphores are useful for implementing limiting or bounding of//!   any kind.//! # Runtime compatibility//! All synchronization primitives provided in this module are runtime agnostic.//! You can freely move them between different instances of the Tokio runtime//! or even use them from non-Tokio runtimes.//! When used in a Tokio runtime, the synchronization primitives participate in//! [cooperative scheduling](crate::task::coop#cooperative-scheduling) to avoid//! starvation. This feature does not apply when used from non-Tokio runtimes.//! As an exception, methods ending in `_timeout` are not runtime agnostic//! because they require access to the Tokio timer. See the documentation of//! each `*_timeout` method for more information on its use./// The header fields./// Array containing values pushed into the block. Values are stored in a/// continuous array in order to improve cache line behavior when reading./// The values must be manually dropped./// The start index of this block./// Slots in this block have indices in `start_index .. start_index + BLOCK_CAP`.ready_slots/// Bitfield tracking slots that are ready to have their values consumed.observed_tail_position/// The observed `tail_position` value *after* the block has been passed by/// `block_tail`./// Extra fields for a `Block<T>`.BLOCK_MASK/// Masks an index to get the block identifier./// Masks an index to get the value offset in a block.RELEASED/// Flag tracking that a block has gone through the sender's release routine./// When this is set, the receiver may consider freeing the block.TX_CLOSED/// Flag tracking all senders dropped./// When this flag is set, the send half of the channel has closed.READY_MASK/// Mask covering all bits used to track slot readiness./// Returns the index of the first slot in the block referenced by `slot_index`./// Returns the offset into the block referenced by `slot_index`.addr_of_headeraddr_of_valuesis_at_index/// Returns `true` if the block matches the given index./// Returns the number of blocks between `self` and the block at the/// specified index./// `start_index` must represent a block *after* `self`./// Reads the value at the given offset./// Returns `None` if the slot is empty./// To maintain safety, the caller must ensure:/// * No concurrent access to the slot./// Returns true if *this* block has a value in the given slot./// Always returns false when given an index from a different block./// Writes a value to the block at the given offset./// * The slot is empty.tx_close/// Signal to the receiver that the sender half of the list is closed.reclaim/// Resets the block to a blank state. This enables reusing blocks in the/// * All slots are empty./// * The caller holds a unique pointer to the block.tx_release/// Releases the block to the rx half for freeing./// This function is called by the tx half once it can be guaranteed that no/// more senders will attempt to access the block./// * The block will no longer be accessed by any sender./// Mark a slot as readyis_final/// Returns `true` when all slots have their `ready` bits set./// This indicates that the block is in its final state and will no longer/// be mutated./// Returns the `observed_tail_position` value, if setload_next/// Loads the next block/// Pushes `block` as the next block in the link./// Returns Ok if successful, otherwise, a pointer to the next block in/// the list is returned./// This requires that the next pointer is null./// This performs a compare-and-swap on `next` using `AcqRel` ordering./// * `block` is not freed until it has been removed from the list./// Grows the `Block` linked list by allocating and appending a new block./// The next block in the linked list is returned. This may or may not be/// the one allocated by the function call./// It is assumed that `self.next` is null. A new block is allocated with/// `start_index` set to be the next block. A compare-and-swap is performed/// with `AcqRel` memory ordering. If the compare-and-swap is successful, the/// newly allocated block is released to other threads walking the block/// linked list. If the compare-and-swap fails, the current thread acquires/// the next block in the linked list, allowing the current thread to access/// the slots./// Returns `true` if the specified slot has a value ready to be consumed.is_tx_closed/// Returns `true` if the closed flag has been set./// Initialize a `Values` struct from a pointer./// The raw pointer must be valid for writing a `Values<T>`.assert_no_stack_overflow/// Sends values to the associated `Receiver`./// Instances are created by the [`channel`] function./// To convert the `Sender` into a `Sink` or use it in a poll function, you can/// use the [`PollSender`] utility./// [`PollSender`]: https://docs.rs/tokio-util/latest/tokio_util/sync/struct.PollSender.html/// use tokio::sync::mpsc::channel;Permit/// Permits to send one value into the channel./// `Permit` values are returned by [`Sender::reserve()`] and [`Sender::try_reserve()`]/// and are used to guarantee channel capacity before generating a message to send./// [`Sender::reserve()`]: Sender::reserve/// [`Sender::try_reserve()`]: Sender::try_reservePermitIterator/// An [`Iterator`] of [`Permit`] that can be used to hold `n` slots in the channel./// `PermitIterator` values are returned by [`Sender::reserve_many()`] and [`Sender::try_reserve_many()`]/// and are used to guarantee channel capacity before generating `n` messages to send./// [`Sender::reserve_many()`]: Sender::reserve_many/// [`Sender::try_reserve_many()`]: Sender::try_reserve_manyOwnedPermit/// Owned permit to send one value into the channel./// This is identical to the [`Permit`] type, except that it moves the sender/// rather than borrowing it./// `OwnedPermit` values are returned by [`Sender::reserve_owned()`] and/// [`Sender::try_reserve_owned()`] and are used to guarantee channel capacity/// before generating a message to send./// [`Permit`]: Permit/// [`Sender::reserve_owned()`]: Sender::reserve_owned/// [`Sender::try_reserve_owned()`]: Sender::try_reserve_owned/// The channel receiver./// Receives values from the associated `Sender`./// This receiver can be turned into a `Stream` using [`ReceiverStream`]./// [`ReceiverStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.ReceiverStream.html/// Creates a bounded mpsc channel for communicating between asynchronous tasks/// with backpressure./// The channel will buffer up to the provided number of messages.  Once the/// buffer is full, attempts to send new messages will wait until a message is/// received from the channel. The provided buffer capacity must be at least 1./// All data sent on `Sender` will become available on `Receiver` in the same/// order as it was sent./// The `Sender` can be cloned to `send` to the same channel from multiple code/// locations. Only one `Receiver` is supported./// If the `Receiver` is disconnected while trying to `send`, the `send` method/// will return a `SendError`. Similarly, if `Sender` is disconnected while/// trying to `recv`, the `recv` method will return `None`./// Panics if the buffer capacity is 0.///     let (tx, mut rx) = mpsc::channel(100);///         for i in 0..10 {///             if let Err(_) = tx.send(i).await {///                 println!("receiver dropped");///                 return;///     while let Some(i) = rx.recv().await {///         println!("got = {}", i);/// Channel semaphore is a tuple of the semaphore implementation and a `usize`/// representing the channel bound./// This method returns `None` if the channel has been closed and there are/// no remaining messages in the channel's buffer. This indicates that no/// further values can ever be received from this `Receiver`. The channel is/// closed when all senders have been dropped, or when [`close`] is called./// If there are no messages in the channel's buffer, but the channel has/// not yet been closed, this method will sleep until a message is sent or/// the channel is closed.  Note that if [`close`] is called, but there are/// still outstanding [`Permits`] from before it was closed, the channel is/// not considered closed by `recv` until the permits are released./// [`close`]: Self::close/// [`Permits`]: struct@crate::sync::mpsc::Permit///         tx.send("hello").await.unwrap();///     assert_eq!(Some("hello"), rx.recv().await);///     assert_eq!(None, rx.recv().await);/// Values are buffered:///     tx.send("hello").await.unwrap();///     tx.send("world").await.unwrap();///     assert_eq!(Some("world"), rx.recv().await);recv_many/// Receives the next values for this receiver and extends `buffer`./// This method extends `buffer` by no more than a fixed number of values/// as specified by `limit`. If `limit` is zero, the function immediately/// returns `0`. The return value is the number of values added to `buffer`./// For `limit > 0`, if there are no messages in the channel's queue, but/// the channel has not yet been closed, this method will sleep until a/// message is sent or the channel is closed. Note that if [`close`] is/// called, but there are still outstanding [`Permits`] from before it was/// closed, the channel is not considered closed by `recv_many` until the/// permits are released./// For non-zero values of `limit`, this method will never return `0` unless/// the channel has been closed and there are no remaining messages in the/// channel's queue. This indicates that no further values can ever be/// received from this `Receiver`. The channel is closed when all senders/// have been dropped, or when [`close`] is called./// The capacity of `buffer` is increased as needed./// This method is cancel safe. If `recv_many` is used as the event in a///     let mut buffer: Vec<&str> = Vec::with_capacity(2);///     let limit = 2;///     tx2.send("first").await.unwrap();///     tx2.send("second").await.unwrap();///     tx2.send("third").await.unwrap();///     // Call `recv_many` to receive up to `limit` (2) values.///     assert_eq!(2, rx.recv_many(&mut buffer, limit).await);///     assert_eq!(vec!["first", "second"], buffer);///     // If the buffer is full, the next call to `recv_many`///     // reserves additional capacity.///     assert_eq!(1, rx.recv_many(&mut buffer, 1).await);///         tx.send("fourth").await.unwrap();///     // 'tx' is dropped, but `recv_many`///     // is guaranteed not to return 0 as the channel///     // is not yet closed.///     assert_eq!(vec!["first", "second", "third", "fourth"], buffer);///     // Once the last sender is dropped, the channel is///     // closed and `recv_many` returns 0, capacity unchanged.///     drop(tx2);///     assert_eq!(0, rx.recv_many(&mut buffer, limit).await);/// Tries to receive the next value for this receiver./// This method returns the [`Empty`] error if the channel is currently/// empty, but there are still outstanding [senders] or [permits]./// This method returns the [`Disconnected`] error if the channel is/// currently empty, and there are no outstanding [senders] or [permits]./// Unlike the [`poll_recv`] method, this method will never return an/// [`Empty`] error spuriously./// [`Empty`]: crate::sync::mpsc::error::TryRecvError::Empty/// [`Disconnected`]: crate::sync::mpsc::error::TryRecvError::Disconnected/// [`poll_recv`]: Self::poll_recv/// [senders]: crate::sync::mpsc::Sender/// [permits]: crate::sync::mpsc::Permit/// use tokio::sync::mpsc::error::TryRecvError;///     assert_eq!(Ok("hello"), rx.try_recv());///     assert_eq!(Err(TryRecvError::Empty), rx.try_recv());///     // Drop the last sender, closing the channel.///     assert_eq!(Err(TryRecvError::Disconnected), rx.try_recv());/// not yet been closed, this method will block until a message is sent or/// This method is intended for use cases where you are sending from/// asynchronous code to synchronous code, and will work even if the sender/// is not using [`blocking_send`] to send the message./// Note that if [`close`] is called, but there are still outstanding/// [`Permits`] from before it was closed, the channel is not considered/// closed by `blocking_recv` until the permits are released./// [`blocking_send`]: fn@crate::sync::mpsc::Sender::blocking_send///     let (tx, mut rx) = mpsc::channel::<u8>(10);///         assert_eq!(Some(10), rx.blocking_recv());///     Runtime::new()///         .block_on(async move {///             let _ = tx.send(10).await;///     sync_code.join().unwrap()blocking_recv_many/// Variant of [`Self::recv_many`] for blocking contexts./// The same conditions as in [`Self::blocking_recv`] apply./// Closes the receiving half of a channel without dropping it./// still enabling the receiver to drain messages that are buffered. Any/// outstanding [`Permit`] values will still be able to send messages./// To guarantee that no messages are dropped, after calling `close()`,/// `recv()` must be called until `None` is returned. If there are/// outstanding [`Permit`] or [`OwnedPermit`] values, the `recv` method will/// not return `None` until those are released./// [`OwnedPermit`]: OwnedPermit///     let (tx, mut rx) = mpsc::channel(20);///         while let Ok(permit) = tx.reserve().await {///             permit.send(i);///     rx.close();///     while let Some(msg) = rx.recv().await {///         println!("got {}", msg);///     // Channel closed and no messages are lost./// when all [`Sender`] have been dropped, or when [`Receiver::close`] is called./// [`Sender`]: crate::sync::mpsc::Sender/// [`Receiver::close`]: crate::sync::mpsc::Receiver::close///     let (_tx, mut rx) = mpsc::channel::<()>(10);/// Checks if a channel is empty./// This method returns `true` if the channel has no messages.///     let (tx, rx) = mpsc::channel(10);///     assert!(rx.is_empty());///     tx.send(0).await.unwrap();///     assert!(!rx.is_empty());///     assert_eq!(0, rx.len());///     assert_eq!(1, rx.len());/// The capacity goes down when the sender sends a value by calling [`Sender::send`] or by reserving/// capacity with [`Sender::reserve`]. The capacity goes up when values are received./// This is distinct from [`max_capacity`], which always returns buffer capacity initially/// specified when calling [`channel`].///     let (tx, mut rx) = mpsc::channel::<()>(5);///     assert_eq!(rx.capacity(), 5);///     // Making a reservation drops the capacity by one.///     let permit = tx.reserve().await.unwrap();///     assert_eq!(rx.capacity(), 4);///     assert_eq!(rx.len(), 0);///     // Sending and receiving a value increases the capacity by one.///     permit.send(());///     assert_eq!(rx.len(), 1);///     rx.recv().await.unwrap();///     // Directly sending a message drops the capacity by one.///     tx.send(()).await.unwrap();///     // Receiving the message increases the capacity by one./// [`capacity`]: Receiver::capacity/// [`max_capacity`]: Receiver::max_capacity/// Returns the maximum buffer capacity of the channel./// The maximum capacity is the buffer capacity initially specified when calling/// [`channel`]. This is distinct from [`capacity`], which returns the *current*/// available buffer capacity: as messages are sent and received, the value/// returned by [`capacity`] will go up or down, whereas the value/// returned by [`max_capacity`] will remain constant.///     let (tx, rx) = mpsc::channel::<()>(5);///     // both max capacity and capacity are the same at first///     assert_eq!(rx.max_capacity(), 5);///     // Making a reservation doesn't change the max capacity.///     // but drops the capacity by one/// Polls to receive the next message on this channel.///  * `Poll::Pending` if no messages are available but the channel is not///    closed, or if a spurious failure happens.///  * `Poll::Ready(Some(message))` if a message is available.///  * `Poll::Ready(None)` if the channel has been closed and all messages/// `Context` is scheduled to receive a wakeup when a message is sent on any/// receiver, or when the channel is closed.  Note that on multiple calls to/// `poll_recv` or `poll_recv_many`, only the `Waker` from the `Context`/// passed to the most recent call is scheduled to receive a wakeup./// If this method returns `Poll::Pending` due to a spurious failure, then/// the `Waker` will be notified when the situation causing the spurious/// failure has been resolved. Note that receiving such a wakeup does not/// guarantee that the next call will succeed — it could fail with another/// spurious failure.poll_recv_many/// Polls to receive multiple messages on this channel, extending the provided buffer./// * `Poll::Pending` if no messages are available but the channel is not closed, or if a///   spurious failure happens./// * `Poll::Ready(count)` where `count` is the number of messages successfully received and///   stored in `buffer`. This can be less than, or equal to, `limit`./// * `Poll::Ready(0)` if `limit` is set to zero or when the channel is closed./// Note that this method does not guarantee that exactly `limit` messages/// are received. Rather, if at least one message is available, it returns/// as many messages as it can up to the given limit. This method returns/// zero only if the channel is closed (or if `limit` is zero)./// use futures::Future;/// struct MyReceiverFuture<'a> {///     receiver: mpsc::Receiver<i32>,///     buffer: &'a mut Vec<i32>,///     limit: usize,/// impl<'a> Future for MyReceiverFuture<'a> {///     type Output = usize; // Number of messages received///         let MyReceiverFuture { receiver, buffer, limit } = &mut *self;///         // Now `receiver` and `buffer` are mutable references, and `limit` is copied///         match receiver.poll_recv_many(cx, *buffer, *limit) {///             Poll::Pending => Poll::Pending,///             Poll::Ready(count) => Poll::Ready(count),///     let (tx, rx) = mpsc::channel(32);///     let my_receiver_future = MyReceiverFuture {///         receiver: rx,///         buffer: &mut buffer,///         limit: 3,///     for i in 0..10 {///         tx.send(i).await.unwrap();///     let count = my_receiver_future.await;///     assert_eq!(count, 3);///     assert_eq!(buffer, vec![0,1,2])/// Sends a value, waiting until there is capacity./// A successful send occurs when it is determined that the other end of the/// channel has not hung up already. An unsuccessful send would be one where/// the corresponding receiver has already been closed. Note that a return/// value of `Err` means that the data will never be received, but a return/// value of `Ok` does not mean that the data will be received. It is/// possible for the corresponding receiver to hang up immediately after/// this function returns `Ok`./// If the receive half of the channel is closed, either due to [`close`]/// being called or the [`Receiver`] handle dropping, the function returns/// an error. The error includes the value passed to `send`./// [`close`]: Receiver::close/// [`Receiver`]: Receiver/// If `send` is used as the event in a [`tokio::select!`](crate::select)/// statement and some other branch completes first, then it is guaranteed/// that the message was not sent. **However, in that case, the message/// is dropped and will be lost.**/// To avoid losing messages, use [`reserve`](Self::reserve) to reserve/// capacity, then use the returned [`Permit`] to send the message./// This channel uses a queue to ensure that calls to `send` and `reserve`/// complete in the order they were requested.  Cancelling a call to/// `send` makes you lose your place in the queue./// In the following example, each call to `send` will block until the/// previously sent value was received.///     let (tx, mut rx) = mpsc::channel(1);/// Completes when the receiver has dropped./// This allows the producers to get notified when interest in the produced/// values is canceled and immediately stop doing work./// This method is cancel safe. Once the channel is closed, it stays closed/// forever and all future calls to `closed` will return immediately.///     let (tx1, rx) = mpsc::channel::<()>(1);///     let tx2 = tx1.clone();///     let tx3 = tx1.clone();///     let tx4 = tx1.clone();///     let tx5 = tx1.clone();///         drop(rx);///     futures::join!(///         tx1.closed(),///         tx2.closed(),///         tx3.closed(),///         tx4.closed(),///         tx5.closed()///     println!("Receiver dropped");/// Attempts to immediately send a message on this `Sender`/// This method differs from [`send`] by returning immediately if the channel's/// buffer is full or no receiver is waiting to acquire some data. Compared/// with [`send`], this function has two failure cases instead of one (one for/// disconnection, one for a full buffer)./// If the channel capacity has been reached, i.e., the channel has `n`/// buffered values where `n` is the argument passed to [`channel`], then an/// [`send`]: Sender::send/// [`channel`]: channel///     // Create a channel with buffer size 1///     let (tx1, mut rx) = mpsc::channel(1);///         tx1.send(1).await.unwrap();///         tx1.send(2).await.unwrap();///         // task waits until the receiver receives a value.///         // This will return an error and send///         // no message if the buffer is full///         let _ = tx2.try_send(3);///     let mut msg;///     msg = rx.recv().await.unwrap();///     println!("message {} received", msg);///     // Third message may have never been sent///     match rx.recv().await {///         Some(msg) => println!("message {} received", msg),///         None => println!("the third message was never sent"),/// Sends a value, waiting until there is capacity, but only for a limited time./// Shares the same success and error conditions as [`send`], adding one more/// condition for an unsuccessful send, which is when the provided timeout has/// elapsed, and there is no capacity available./// being called or the [`Receiver`] having been dropped,/// the function returns an error. The error includes the value passed to `send`./// This function panics if it is called outside the context of a Tokio/// runtime [with time enabled](crate::runtime::Builder::enable_time)./// In the following example, each call to `send_timeout` will block until the/// previously sent value was received, unless the timeout has elapsed./// use tokio::time::{sleep, Duration};///             if let Err(e) = tx.send_timeout(i, Duration::from_millis(100)).await {///                 println!("send error: #{:?}", e);///         sleep(Duration::from_millis(200)).await;blocking_send/// Blocking send to call outside of asynchronous contexts./// synchronous code to asynchronous code, and will work even if the/// receiver is not using [`blocking_recv`] to receive the message./// [`blocking_recv`]: fn@crate::sync::mpsc::Receiver::blocking_recv///     let (tx, mut rx) = mpsc::channel::<u8>(1);///         tx.blocking_send(10).unwrap();///     Runtime::new().unwrap().block_on(async move {///         assert_eq!(Some(10), rx.recv().await);/// Checks if the channel has been closed. This happens when the/// [`Receiver`] is dropped, or when the [`Receiver::close`] method is/// [`Receiver`]: crate::sync::mpsc::Receiver/// let (tx, rx) = tokio::sync::mpsc::channel::<()>(42);/// assert!(!tx.is_closed());/// let tx2 = tx.clone();/// assert!(!tx2.is_closed());/// drop(rx);/// assert!(tx.is_closed());/// assert!(tx2.is_closed());/// Waits for channel capacity. Once capacity to send one message is/// available, it is reserved for the caller./// If the channel is full, the function waits for the number of unreceived/// messages to become less than the channel capacity. Capacity to send one/// message is reserved for the caller. A [`Permit`] is returned to track/// the reserved capacity. The [`send`] function on [`Permit`] consumes the/// reserved capacity./// Dropping [`Permit`] without sending a message releases the capacity back/// to the channel./// [`send`]: Permit::send/// `reserve` makes you lose your place in the queue.///     // Reserve capacity///     // Trying to send directly on the `tx` will fail due to no///     // available capacity.///     assert!(tx.try_send(123).is_err());///     // Sending on the permit succeeds///     permit.send(456);///     // The value sent on the permit is received///     assert_eq!(rx.recv().await.unwrap(), 456);reserve_many/// Waits for channel capacity. Once capacity to send `n` messages is/// If the channel is full or if there are fewer than `n` permits available, the function waits/// for the number of unreceived messages to become `n` less than the channel capacity./// Capacity to send `n` message is then reserved for the caller./// A [`PermitIterator`] is returned to track the reserved capacity./// You can call this [`Iterator`] until it is exhausted to/// get a [`Permit`] and then call [`Permit::send`]. This function is similar to/// [`try_reserve_many`] except it awaits for the slots to become available./// If the channel is closed, the function returns a [`SendError`]./// Dropping [`PermitIterator`] without consuming it entirely releases the remaining/// permits back to the channel./// [`PermitIterator`]: PermitIterator/// [`try_reserve_many`]: Sender::try_reserve_many/// This channel uses a queue to ensure that calls to `send` and `reserve_many`/// complete in the order they were requested. Cancelling a call to/// `reserve_many` makes you lose your place in the queue.///     let (tx, mut rx) = mpsc::channel(2);///     let mut permit = tx.reserve_many(2).await.unwrap();///     // Sending with the permit iterator succeeds///     permit.next().unwrap().send(456);///     permit.next().unwrap().send(457);///     // The iterator should now be exhausted///     assert!(permit.next().is_none());///     assert_eq!(rx.recv().await.unwrap(), 457);reserve_owned/// Waits for channel capacity, moving the `Sender` and returning an owned/// permit. Once capacity to send one message is available, it is reserved/// for the caller./// This moves the sender _by value_, and returns an owned permit that can/// be used to send a message into the channel. Unlike [`Sender::reserve`],/// this method may be used in cases where the permit must be valid for the/// `'static` lifetime. `Sender`s may be cloned cheaply (`Sender::clone` is/// essentially a reference count increment, comparable to [`Arc::clone`]),/// so when multiple [`OwnedPermit`]s are needed or the `Sender` cannot be/// moved, it can be cloned prior to calling `reserve_owned`./// message is reserved for the caller. An [`OwnedPermit`] is returned to/// track the reserved capacity. The [`send`] function on [`OwnedPermit`]/// consumes the reserved capacity./// Dropping the [`OwnedPermit`] without sending a message releases the/// capacity back to the channel./// `reserve_owned` makes you lose your place in the queue./// Sending a message using an [`OwnedPermit`]:///     // Reserve capacity, moving the sender.///     let permit = tx.reserve_owned().await.unwrap();///     // Send a message, consuming the permit and returning///     // the moved sender.///     let tx = permit.send(123);///     // The value sent on the permit is received.///     assert_eq!(rx.recv().await.unwrap(), 123);///     // The sender can now be used again.///     tx.send(456).await.unwrap();/// When multiple [`OwnedPermit`]s are needed, or the sender cannot be moved/// by value, it can be inexpensively cloned before calling `reserve_owned`:///     // Clone the sender and reserve capacity.///     let permit = tx.clone().reserve_owned().await.unwrap();///     // Sending on the permit succeeds./// [`Sender::reserve`]: Sender::reserve/// [`send`]: OwnedPermit::send/// [`Arc::clone`]: std::sync::Arc::clone/// Tries to acquire a slot in the channel without waiting for the slot to become/// If the channel is full this function will return [`TrySendError`], otherwise/// if there is a slot available it will return a [`Permit`] that will then allow you/// to [`send`] on the channel with a guaranteed slot. This function is similar to/// [`reserve`] except it does not await for the slot to become available./// [`reserve`]: Sender::reserve///     let permit = tx.try_reserve().unwrap();///     // Trying to reserve an additional slot on the `tx` will///     // fail because there is no capacity.///     assert!(tx.try_reserve().is_err());try_reserve_many/// Tries to acquire `n` slots in the channel without waiting for the slot to become/// [`reserve_many`] except it does not await for the slots to become available./// If there are fewer than `n` permits available on the channel, then/// this function will return a [`TrySendError::Full`]. If the channel is closed/// this function will return a [`TrySendError::Closed`]./// [`reserve_many`]: Sender::reserve_many///     let mut permit = tx.try_reserve_many(2).unwrap();///     // Trying to call try_reserve_many with 0 will return an empty iterator///     let mut permit = tx.try_reserve_many(0).unwrap();///     // Trying to call try_reserve_many with a number greater than the channel///     // capacity will return an error///     let permit = tx.try_reserve_many(3);///     assert!(permit.is_err());///     // Trying to call try_reserve_many on a closed channel will return an error///     drop(rx);///     let permit = tx.try_reserve_many(1);///     let permit = tx.try_reserve_many(0);try_reserve_owned/// available, returning an owned permit./// be used to send a message into the channel. Unlike [`Sender::try_reserve`],/// `'static` lifetime.  `Sender`s may be cloned cheaply (`Sender::clone` is/// moved, it can be cloned prior to calling `try_reserve_owned`./// If the channel is full this function will return a [`TrySendError`]./// Since the sender is taken by value, the `TrySendError` returned in this/// case contains the sender, so that it may be used again. Otherwise, if/// there is a slot available, this method will return an [`OwnedPermit`]/// that can then be used to [`send`] on the channel with a guaranteed slot./// This function is similar to  [`reserve_owned`] except it does not await/// for the slot to become available./// Dropping the [`OwnedPermit`] without sending a message releases the capacity back/// [`reserve_owned`]: Sender::reserve_owned///     let permit = tx.clone().try_reserve_owned().unwrap();/// let (tx, rx) = tokio::sync::mpsc::channel::<()>(1);/// let  tx2 = tx.clone();/// assert!(tx.same_channel(&tx2));/// let (tx3, rx3) = tokio::sync::mpsc::channel::<()>(1);/// assert!(!tx3.same_channel(&tx2));/// The capacity goes down when sending a value by calling [`send`] or by reserving capacity/// with [`reserve`]. The capacity goes up when values are received by the [`Receiver`]./// specified when calling [`channel`]///     assert_eq!(tx.capacity(), 5);///     assert_eq!(tx.capacity(), 4);/// [`max_capacity`]: Sender::max_capacity/// available buffer capacity: as messages are sent and received, the/// value returned by [`capacity`] will go up or down, whereas the value///     let (tx, _rx) = mpsc::channel::<()>(5);///     assert_eq!(tx.max_capacity(), 5);/// [`capacity`]: Sender::capacity/// Tries to convert a `WeakSender` into a [`Sender`]. This will return `Some`/// if there are other `Sender` instances alive and the channel wasn't/// previously dropped, otherwise `None` is returned./// Sends a value using the reserved capacity./// Capacity for the message has already been reserved. The message is sent/// to the receiver and the permit is consumed. The operation will succeed/// even if the receiver half has been closed. See [`Receiver::close`] for/// more details on performing a clean shutdown./// [`Receiver::close`]: Receiver::close///     // Send a message on the permit/// Unlike [`Permit::send`], this method returns the [`Sender`] from which/// the `OwnedPermit` was reserved.///     // Send a message on the permit, returning the sender.///     let tx = permit.send(456);///     // We may now reuse `tx` to send another message.///     tx.send(789).await.unwrap();/// Releases the reserved capacity *without* sending a message, returning the/// [`Sender`].///     let (tx, rx) = mpsc::channel(1);///     // Clone the sender and reserve capacity///     // Trying to send on the original `tx` will fail, since the `permit`///     // has reserved all the available capacity.///     // Release the permit without sending a message, returning the clone///     // of the sender.///     let tx2 = permit.release();///     # drop(rx); drop(tx2);// ===== impl Permit =====// ===== impl PermitIterator =====cacheline/// Channel sender./// Channel receiver.add_permit/// Handle to the push half of the lock-free list.rx_waker/// Receiver waker. Notified when a value is pushed into the channel.notify_rx_closed/// Notifies all tasks listening for the receiver being dropped./// Coordinates access to channel's capacity.tx_count/// Tracks the number of outstanding sender handles./// When this drops to zero, the send half of the channel is closed.tx_weak_count/// Tracks the number of outstanding weak sender handles.rx_fieldsRxFields/// Only accessed by `Rx` handle./// Channel receiver. This field is only accessed by the `Receiver` type./// `true` if `Rx::close` is called./// Fields only accessed by `Rx` handle.// Returns the upgraded channel or None if the upgrade failed./// Send a message and notify the receiver.wake_rx/// Wake the receive half/// Receive the next value/// Receives up to `limit` values into `buffer`/// For `limit > 0`, receives up to limit values into `buffer`./// For `limit == 0`, immediately returns Ready(0)./// Try to receive the next value.decrement_weak_countincrement_weak_count// ===== impl Tx =====// ===== impl Rx =====// ===== impl Chan =====// ===== impl Semaphore for (::Semaphore, capacity) =====// ===== impl Semaphore for AtomicUsize =====/// Error returned by the `Sender`./// The data could not be sent on the channel because the channel is/// currently full and sending would require blocking./// The receive half of the channel was explicitly closed or has been/// This enumeration is the list of the possible error outcomes for the/// [`try_send`](super::Sender::try_send) method./// Consume the `TrySendError`, returning the unsent value./// This **channel** is currently empty, but the **Sender**(s) have not yet/// disconnected, so data may yet become available./// The **channel**'s sending half has become disconnected, and there will/// never be any more data received on it./// Error returned by `try_recv`./// Error returned by `Receiver`.r" Error returned by [`Sender::send_timeout`](super::Sender::send_timeout)]."r" The data could not be sent on the channel because the channel is"r" full, and the timeout to send has elapsed."r" The receive half of the channel was explicitly closed or has been"r" dropped."r" Consume the `SendTimeoutError`, returning the unsent value."//! Channel error types.// ===== TrySendError =====// ===== TryRecvError =====// ===== RecvError =====block_tail/// Tail in the `Block` mpmc list.tail_position/// Position to push the next message. This references a block and offset/// into the block./// List queue transmit handle./// Pointer to the block being processed./// Next slot index to process./// Pointer to the next block pending release./// List queue receive handleTryPopResult/// Successfully popped a value./// The channel is empty./// The channel is not empty, but the first value is being written./// Return value of `Rx::try_pop`./// Pushes a value into the list./// Closes the send half of the list./// Similar process as pushing a value, but instead of writing the value &/// setting the ready flag, the `TX_CLOSED` flag is set on the block.find_blockreclaim_block/// Pops the next value off the queue./// Pops the next value off the queue, detecting whether the block/// is busy or empty on failure./// This function exists because `Rx::pop` can return `None` even if the/// channel's queue contains a message that has been completely written./// This can happen if the fully delivered message is behind another message/// that is in the middle of being written to the block, since the channel/// can't return the messages out of order.try_advancing_head/// Tries advancing the block pointer to the block referenced by `self.index`./// Returns `true` if successful, `false` if there is no next block to load.reclaim_blocksfree_blocks/// Effectively `Drop` all the blocks. Should only be called once, when/// the list is dropping.//! A concurrent, lock-free, FIFO list.unbounded_channelWeakUnboundedSender/// The number of values a block can contain./// This value must be a power of 2. It also must be smaller than the number of/// bits in `usize`.//! A multi-producer, single-consumer queue for sending values between//! This module provides two variants of the channel: bounded and unbounded. The//! bounded variant has a limit on the number of messages that the channel can//! store, and if this limit is reached, trying to send another message will//! wait until a message is received from the channel. An unbounded channel has//! an infinite capacity, so the `send` method will always complete immediately.//! This makes the [`UnboundedSender`] usable from both synchronous and//! asynchronous code.//! Similar to the `mpsc` channels provided by `std`, the channel constructor//! functions provide separate send and receive handles, [`Sender`] and//! [`Receiver`] for the bounded channel, [`UnboundedSender`] and//! [`UnboundedReceiver`] for the unbounded channel. If there is no message to read,//! the current task will be notified when a new value is sent. [`Sender`] and//! [`UnboundedSender`] allow sending values into the channel. If the bounded//! channel is at capacity, the send is rejected and the task will be notified//! when additional capacity is available. In other words, the channel provides//! backpressure.//! This channel is also suitable for the single-producer single-consumer//! use-case. (Unless you only need to send one message, in which case you//! should use the [oneshot] channel.)//! event of the stream. As such, `Receiver::poll` returns `Ok(Ready(None))`.//! result in an error. Additionally, all unread messages will be drained from the//! channel and dropped.//! When the [`Receiver`] is dropped, it is possible for unprocessed messages to//! remain in the channel. Instead, it is usually desirable to perform a "clean"//! shutdown. To do this, the receiver first calls `close`, which will prevent//! any further messages to be sent into the channel. Then, the receiver//! consumes the channel to completion, at which point the receiver can be//! dropped.//! # Communicating between sync and async code//! When you want to communicate between synchronous and asynchronous code, there//! are two situations to consider://! **Bounded channel**: If you need a bounded channel, you should use a bounded//! Tokio `mpsc` channel for both directions of communication. Instead of calling//! the async [`send`][bounded-send] or [`recv`][bounded-recv] methods, in//! synchronous code you will need to use the [`blocking_send`][blocking-send] or//! [`blocking_recv`][blocking-recv] methods.//! **Unbounded channel**: You should use the kind of channel that matches where//! the receiver is. So for sending a message _from async to sync_, you should//! use [the standard library unbounded channel][std-unbounded] or//! [crossbeam][crossbeam-unbounded].  Similarly, for sending a message _from sync//! to async_, you should use an unbounded Tokio `mpsc` channel.//! Please be aware that the above remarks were written with the `mpsc` channel//! in mind, but they can also be generalized to other kinds of channels. In//! general, any channel method that isn't marked async can be called anywhere,//! including outside of the runtime. For example, sending a message on a//! [oneshot] channel from outside the runtime is perfectly fine.//! # Multiple runtimes//! The `mpsc` channel is runtime agnostic. You can freely move it between//! different instances of the Tokio runtime or even use it from non-Tokio//! runtimes.//! When used in a Tokio runtime, it participates in//! # Allocation behavior//! <div class="warning">The implementation details described in this section may change in future//! Tokio releases.</div>//! The mpsc channel stores elements in blocks. Blocks are organized in a linked list. Sending//! pushes new elements onto the block at the front of the list, and receiving pops them off the//! one at the back. A block can hold 32 messages on a 64-bit target and 16 messages on a 32-bit//! target. This number is independent of channel and message size. Each block also stores 4//! pointer-sized values for bookkeeping (so on a 64-bit machine, each message has 1 byte of//! overhead).//! When all values in a block have been received, it becomes empty. It will then be freed, unless//! the channel's first block (where newly-sent elements are being stored) has no next block. In//! that case, the empty block is reused as the next block.//! [`Sender`]: crate::sync::mpsc::Sender//! [`Receiver`]: crate::sync::mpsc::Receiver//! [bounded-send]: crate::sync::mpsc::Sender::send()//! [bounded-recv]: crate::sync::mpsc::Receiver::recv()//! [blocking-send]: crate::sync::mpsc::Sender::blocking_send()//! [blocking-recv]: crate::sync::mpsc::Receiver::blocking_recv()//! [`UnboundedSender`]: crate::sync::mpsc::UnboundedSender//! [`UnboundedReceiver`]: crate::sync::mpsc::UnboundedReceiver//! [oneshot]: crate::sync::oneshot//! [`Handle::block_on`]: crate::runtime::Handle::block_on()//! [std-unbounded]: std::sync::mpsc::channel//! [crossbeam-unbounded]: https://docs.rs/crossbeam/*/crossbeam/channel/fn.unbounded.html//! [`send_timeout`]: crate::sync::mpsc::Sender::send_timeout/// Send values to the associated `UnboundedReceiver`./// Instances are created by the [`unbounded_channel`] function./// An unbounded sender that does not prevent the channel from being closed./// If all [`UnboundedSender`] instances of a channel were dropped and only/// `WeakUnboundedSender` instances remain, the channel is closed./// In order to send messages, the `WeakUnboundedSender` needs to be upgraded using/// [`WeakUnboundedSender::upgrade`], which returns `Option<UnboundedSender>`. It returns `None`/// if all `UnboundedSender`s have been dropped, and otherwise it returns an `UnboundedSender`./// [`UnboundedSender`]: UnboundedSender/// [`WeakUnboundedSender::upgrade`]: WeakUnboundedSender::upgrade/// use tokio::sync::mpsc::unbounded_channel;///     let (tx, _rx) = unbounded_channel::<i32>();/// The channel receiver/// Receive values from the associated `UnboundedSender`./// This receiver can be turned into a `Stream` using [`UnboundedReceiverStream`]./// [`UnboundedReceiverStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.UnboundedReceiverStream.html/// tasks without backpressure./// No capacity///     let (tx, mut rx) = mpsc::unbounded_channel();///         tx.send("hello").unwrap();///     tx.send("hello").unwrap();///     tx.send("world").unwrap();/// as specified by `limit`. If `limit` is zero, the function returns/// immediately with `0`. The return value is the number of values added to/// `buffer`./// For `limit > 0`, if there are no messages in the channel's queue,/// but the channel has not yet been closed, this method will sleep/// until a message is sent or the channel is closed.///     tx2.send("first").unwrap();///     tx2.send("second").unwrap();///     tx2.send("third").unwrap();///     assert_eq!(1, rx.recv_many(&mut buffer, limit).await);///         tx.send("fourth").unwrap();///     let (tx, mut rx) = mpsc::unbounded_channel::<u8>();/// `recv()` must be called until `None` is returned./// when all [`UnboundedSender`] have been dropped, or when [`UnboundedReceiver::close`] is called./// [`UnboundedSender`]: crate::sync::mpsc::UnboundedSender/// [`UnboundedReceiver::close`]: crate::sync::mpsc::UnboundedReceiver::close///     let (_tx, mut rx) = mpsc::unbounded_channel::<()>();///     let (tx, rx) = mpsc::unbounded_channel();///     tx.send(0).unwrap();///     receiver: mpsc::UnboundedReceiver<i32>,///     let (tx, rx) = mpsc::unbounded_channel::<i32>();///         tx.send(i).expect("Unable to send integer");/// Returns the number of [`UnboundedSender`] handles./// Returns the number of [`WeakUnboundedSender`] handles./// Attempts to send a message on this `UnboundedSender` without blocking./// This method is not marked async because sending a message to an unbounded channel/// never requires any form of waiting. Because of this, the `send` method can be/// used in both synchronous and asynchronous code without problems./// being called or the [`UnboundedReceiver`] having been dropped, this/// function returns an error. The error includes the value passed to `send`./// [`close`]: UnboundedReceiver::close/// [`UnboundedReceiver`]: UnboundedReceiver///     let (tx1, rx) = mpsc::unbounded_channel::<()>();////     println!("Receiver dropped");/// [`UnboundedReceiver`] is dropped, or when the/// [`UnboundedReceiver::close`] method is called./// [`UnboundedReceiver`]: crate::sync::mpsc::UnboundedReceiver/// let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<()>();/// let (tx3, rx3) = tokio::sync::mpsc::unbounded_channel::<()>();/// Converts the `UnboundedSender` to a [`WeakUnboundedSender`] that does not count/// towards RAII semantics, i.e. if all `UnboundedSender` instances of the/// channel were dropped and only `WeakUnboundedSender` instances remain,/// Tries to convert a `WeakUnboundedSender` into an [`UnboundedSender`]./// An asynchronous `Mutex`-like type./// This type acts similarly to [`std::sync::Mutex`], with two major/// differences: [`lock`] is an async method so does not block, and the lock/// guard is designed to be held across `.await` points./// Tokio's Mutex operates on a guaranteed FIFO basis./// This means that the order in which tasks call the [`lock`] method is/// the exact order in which they will acquire the lock./// # Which kind of mutex should you use?/// Contrary to popular belief, it is ok and often preferred to use the ordinary/// [`Mutex`][std] from the standard library in asynchronous code./// The feature that the async mutex offers over the blocking mutex is the/// ability to keep it locked across an `.await` point. This makes the async/// mutex more expensive than the blocking mutex, so the blocking mutex should/// be preferred in the cases where it can be used. The primary use case for the/// async mutex is to provide shared mutable access to IO resources such as a/// database connection. If the value behind the mutex is just data, it's/// usually appropriate to use a blocking mutex such as the one in the standard/// library or [`parking_lot`]./// Note that, although the compiler will not prevent the std `Mutex` from holding/// its guard across `.await` points in situations where the task is not movable/// between threads, this virtually never leads to correct concurrent code in/// practice as it can easily lead to deadlocks./// A common pattern is to wrap the `Arc<Mutex<...>>` in a struct that provides/// non-async methods for performing operations on the data within, and only/// lock the mutex inside these methods. The [mini-redis] example provides an/// illustration of this pattern./// Additionally, when you _do_ want shared access to an IO resource, it is/// often better to spawn a task to manage the IO resource, and to use message/// passing to communicate with that task./// [std]: std::sync::Mutex/// [`parking_lot`]: https://docs.rs/parking_lot/// [mini-redis]: https://github.com/tokio-rs/mini-redis/blob/master/src/db.rs/// use tokio::sync::Mutex;///     let data1 = Arc::new(Mutex::new(0));///     let data2 = Arc::clone(&data1);///         let mut lock = data2.lock().await;///         *lock += 1;///     let mut lock = data1.lock().await;///     *lock += 1;///     let count = Arc::new(Mutex::new(0));///     for i in 0..5 {///         let my_count = Arc::clone(&count);///         tokio::spawn(async move {///             for j in 0..10 {///                 let mut lock = my_count.lock().await;///                 *lock += 1;///                 println!("{} {} {}", i, j, lock);///         if *count.lock().await >= 50 {///     println!("Count hit 50.");/// There are a few things of note here to pay attention to in this example./// 1. The mutex is wrapped in an [`Arc`] to allow it to be shared across///    threads./// 2. Each spawned task obtains a lock and releases it on every iteration./// 3. Mutation of the data protected by the Mutex is done by de-referencing///    the obtained lock as seen on lines 13 and 20./// Tokio's Mutex works in a simple FIFO (first in, first out) style where all/// calls to [`lock`] complete in the order they were performed. In that way the/// Mutex is "fair" and predictable in how it distributes the locks to inner/// data. Locks are released and reacquired after every iteration, so basically,/// each thread goes to the back of the line after it increments the value once./// Note that there's some unpredictability to the timing between when the/// threads are started, but once they are going they alternate predictably./// Finally, since there is only a single valid lock at any given time, there is/// no possibility of a race condition when mutating the inner value./// Note that in contrast to [`std::sync::Mutex`], this implementation does not/// poison the mutex when a thread holding the [`MutexGuard`] panics. In such a/// case, the mutex will be unlocked. If the panic is caught, this might leave/// the data protected by the mutex in an inconsistent state./// [`Mutex`]: struct@Mutex/// [`MutexGuard`]: struct@MutexGuard/// [`Arc`]: struct@std::sync::Arc/// [`std::sync::Mutex`]: struct@std::sync::Mutex/// [`Send`]: trait@std::marker::Send/// [`lock`]: method@Mutex::lock/// A handle to a held `Mutex`. The guard can be held across any `.await` point/// as it is [`Send`]./// As long as you have this guard, you have exclusive access to the underlying/// `T`. The guard internally borrows the `Mutex`, so the mutex will not be/// dropped while a guard exists./// The lock is automatically released whenever the guard is dropped, at which/// point `lock` will succeed yet again./// An owned handle to a held `Mutex`./// This guard is only available from a `Mutex` that is wrapped in an [`Arc`]. It/// is identical to `MutexGuard`, except that rather than borrowing the `Mutex`,/// it clones the `Arc`, incrementing the reference count. This means that/// unlike `MutexGuard`, it will have the `'static` lifetime./// `T`. The guard internally keeps a reference-counted pointer to the original/// `Mutex`, so even if the lock goes away, the guard remains valid.// Needed to tell the borrow checker that we are holding a `&mut T`/// A handle to a held `Mutex` that has had a function applied to it via [`MutexGuard::map`]./// This can be used to hold a subfield of the protected data./// [`MutexGuard::map`]: method@MutexGuard::map/// A owned handle to a held `Mutex` that has had a function applied to it via/// [`OwnedMutexGuard::map`]./// [`OwnedMutexGuard::map`]: method@OwnedMutexGuard::mapMutexGuardInner/// A helper type used when taking apart a `MutexGuard` without running its/// Drop implementation.// Unused fields are still used in Drop.OwnedMutexGuardInner/// A helper type used when taking apart a `OwnedMutexGuard` without running/// its Drop implementation.MappedMutexGuardInner/// A helper type used when taking apart a `MappedMutexGuard` without runningOwnedMappedMutexGuardInner/// A helper type used when taking apart a `OwnedMappedMutexGuard` without running// As long as T: Send, it's fine to send and share Mutex<T> between threads.// If T was not Send, sending and sharing a Mutex<T> would be bad, since you can// access T through Mutex<T>./// Error returned from the [`Mutex::try_lock`], [`RwLock::try_read`] and/// [`RwLock::try_write`] functions./// `Mutex::try_lock` operation will only fail if the mutex is already locked./// `RwLock::try_read` operation will only fail if the lock is currently held/// by an exclusive writer./// `RwLock::try_write` operation will only fail if the lock is currently held/// by any reader or by an exclusive writer./// [`Mutex::try_lock`]: Mutex::try_lock/// [`RwLock::try_read`]: fn@super::RwLock::try_read/// [`RwLock::try_write`]: fn@super::RwLock::try_write/// Creates a new lock in an unlocked state ready for use./// let lock = Mutex::new(5);/// When using the `tracing` [unstable feature], a `Mutex` created with/// `const_new` will not be instrumented. As such, it will not be visible/// in [`tokio-console`]. Instead, [`Mutex::new`] should be used to create/// an instrumented object if that is needed./// static LOCK: Mutex<i32> = Mutex::const_new(5);/// [`tokio-console`]: https://github.com/tokio-rs/console/// [unstable feature]: crate#unstable-features/// Locks this mutex, causing the current task to yield until the lock has/// been acquired.  When the lock has been acquired, function returns a/// [`MutexGuard`]./// If the mutex is available to be acquired immediately, then this call/// will typically not yield to the runtime. However, this is not guaranteed/// under all circumstances./// This method uses a queue to fairly distribute locks in the order they/// were requested. Cancelling a call to `lock` makes you lose your place in/// the queue.///     let mutex = Mutex::new(1);///     let mut n = mutex.lock().await;///     *n = 2;blocking_lock/// Blockingly locks this `Mutex`. When the lock has been acquired, function returns a/// This method is intended for use cases where you/// need to use this mutex in asynchronous code as well as in synchronous code./// This function panics if called within an asynchronous execution context.///   - If you find yourself in an asynchronous execution context and needing///     to call some (synchronous) function which performs one of these///     `blocking_` operations, then consider wrapping that call inside///     [`spawn_blocking()`][crate::runtime::Handle::spawn_blocking]///     (or [`block_in_place()`][crate::task::block_in_place]).///     let mutex =  Arc::new(Mutex::new(1));///     let lock = mutex.lock().await;///     let mutex1 = Arc::clone(&mutex);///     let blocking_task = tokio::task::spawn_blocking(move || {///         // This shall block until the `lock` is released.///         let mut n = mutex1.blocking_lock();///         *n = 2;///     assert_eq!(*lock, 1);///     // Release the lock.///     // Await the completion of the blocking task.///     blocking_task.await.unwrap();///     // Assert uncontended.///     let n = mutex.try_lock().unwrap();///     assert_eq!(*n, 2);blocking_lock_owned/// Blockingly locks this `Mutex`. When the lock has been acquired, function returns an/// [`OwnedMutexGuard`]./// This method is identical to [`Mutex::blocking_lock`], except that the returned/// guard references the `Mutex` with an [`Arc`] rather than by borrowing/// it. Therefore, the `Mutex` must be wrapped in an `Arc` to call this/// method, and the guard will live for the `'static` lifetime, as it keeps/// the `Mutex` alive by holding an `Arc`.///         let mut n = mutex1.blocking_lock_owned();/// been acquired. When the lock has been acquired, this returns an/// This method is identical to [`Mutex::lock`], except that the returned/// were requested. Cancelling a call to `lock_owned` makes you lose your/// place in the queue.///     let mutex = Arc::new(Mutex::new(1));///     let mut n = mutex.clone().lock_owned().await;/// Attempts to acquire the lock, and returns [`TryLockError`] if the/// lock is currently held somewhere else./// [`TryLockError`]: TryLockError/// # async fn dox() -> Result<(), tokio::sync::TryLockError> {/// let mutex = Mutex::new(1);/// let n = mutex.try_lock()?;///     let mut mutex = Mutex::new(1);///     let n = mutex.get_mut();/// Attempts to acquire the lock, and returns [`TryLockError`] if the lock/// is currently held somewhere else./// This method is identical to [`Mutex::try_lock`], except that the/// returned  guard references the `Mutex` with an [`Arc`] rather than by/// borrowing it. Therefore, the `Mutex` must be wrapped in an `Arc` to call/// this method, and the guard will live for the `'static` lifetime, as it/// keeps the `Mutex` alive by holding an `Arc`./// let mutex = Arc::new(Mutex::new(1));/// let n = mutex.clone().try_lock_owned()?;///     let n = mutex.into_inner();///     assert_eq!(n, 1);skip_drop/// Makes a new [`MappedMutexGuard`] for a component of the locked data./// This operation cannot fail as the [`MutexGuard`] passed in already locked the mutex./// This is an associated function that needs to be used as `MutexGuard::map(...)`. A method/// would interfere with methods of the same name on the contents of the locked data./// use tokio::sync::{Mutex, MutexGuard};/// #[derive(Debug, Clone, Copy, PartialEq, Eq)]/// struct Foo(u32);/// let foo = Mutex::new(Foo(1));///     let mut mapped = MutexGuard::map(foo.lock().await, |f| &mut f.0);///     *mapped = 2;/// assert_eq!(Foo(2), *foo.lock().await);/// [`MappedMutexGuard`]: struct@MappedMutexGuard/// Attempts to make a new [`MappedMutexGuard`] for a component of the locked data. The/// original guard is returned if the closure returns `None`./// This is an associated function that needs to be used as `MutexGuard::try_map(...)`. A/// method would interfere with methods of the same name on the contents of the locked data.///     let mut mapped = MutexGuard::try_map(foo.lock().await, |f| Some(&mut f.0))///         .expect("should not fail");/// Returns a reference to the original `Mutex`./// async fn unlock_and_relock<'l>(guard: MutexGuard<'l, u32>) -> MutexGuard<'l, u32> {///     println!("1. contains: {:?}", *guard);///     let mutex = MutexGuard::mutex(&guard);///     drop(guard);///     let guard = mutex.lock().await;///     println!("2. contains: {:?}", *guard);///     guard/// #     let mutex = Mutex::new(0u32);/// #     let guard = mutex.lock().await;/// #     let _guard = unlock_and_relock(guard).await;/// Makes a new [`OwnedMappedMutexGuard`] for a component of the locked data./// This operation cannot fail as the [`OwnedMutexGuard`] passed in already locked the mutex./// This is an associated function that needs to be used as `OwnedMutexGuard::map(...)`. A method/// use tokio::sync::{Mutex, OwnedMutexGuard};/// let foo = Arc::new(Mutex::new(Foo(1)));///     let mut mapped = OwnedMutexGuard::map(foo.clone().lock_owned().await, |f| &mut f.0);/// [`OwnedMutexGuard`]: struct@OwnedMutexGuard/// [`OwnedMappedMutexGuard`]: struct@OwnedMappedMutexGuard/// Attempts to make a new [`OwnedMappedMutexGuard`] for a component of the locked data. The/// This is an associated function that needs to be used as `OwnedMutexGuard::try_map(...)`. A///     let mut mapped = OwnedMutexGuard::try_map(foo.clone().lock_owned().await, |f| Some(&mut f.0))/// Returns a reference to the original `Arc<Mutex>`./// async fn unlock_and_relock(guard: OwnedMutexGuard<u32>) -> OwnedMutexGuard<u32> {///     let mutex: Arc<Mutex<u32>> = OwnedMutexGuard::mutex(&guard).clone();///     let guard = mutex.lock_owned().await;/// #     let mutex = Arc::new(Mutex::new(0u32));/// #     let guard = mutex.lock_owned().await;/// #     unlock_and_relock(guard).await;/// This operation cannot fail as the [`MappedMutexGuard`] passed in already locked the mutex./// This is an associated function that needs to be used as `MappedMutexGuard::map(...)`. A/// This is an associated function that needs to be used as `MappedMutexGuard::try_map(...)`. A/// This operation cannot fail as the [`OwnedMappedMutexGuard`] passed in already locked the mutex./// This is an associated function that needs to be used as `OwnedMappedMutexGuard::map(...)`. A method// === impl MutexGuard ===// === impl OwnedMutexGuard ===// === impl MappedMutexGuard ===// === impl OwnedMappedMutexGuard ===GuardedWaitList// `state` uses 2 bits to store one of `EMPTY`,// `WAITING` or `NOTIFIED`. The rest of the bits// are used to store the number of times `notify_waiters`// was called.// Throughout the code there are two assumptions:// - state can be transitioned *from* `WAITING` only if//   `waiters` lock is held// - number of times `notify_waiters` was called can//   be modified only if `waiters` lock is held/// Notifies a single task to wake up./// `Notify` provides a basic mechanism to notify a single task of an event./// `Notify` itself does not carry any data. Instead, it is to be used to signal/// another task to perform an operation./// A `Notify` can be thought of as a [`Semaphore`] starting with 0 permits. The/// [`notified().await`] method waits for a permit to become available, and/// [`notify_one()`] sets a permit **if there currently are no available/// permits**./// The synchronization details of `Notify` are similar to/// [`thread::park`][park] and [`Thread::unpark`][unpark] from std. A [`Notify`]/// value contains a single permit. [`notified().await`] waits for the permit to/// be made available, consumes the permit, and resumes.  [`notify_one()`] sets/// the permit, waking a pending task if there is one./// If `notify_one()` is called **before** `notified().await`, then the next/// call to `notified().await` will complete immediately, consuming the permit./// Any subsequent calls to `notified().await` will wait for a new permit./// If `notify_one()` is called **multiple** times before `notified().await`,/// only a **single** permit is stored. The next call to `notified().await` will/// complete immediately, but the one after will wait for a new permit./// use tokio::sync::Notify;///     let notify = Arc::new(Notify::new());///     let notify2 = notify.clone();///     let handle = tokio::spawn(async move {///         notify2.notified().await;///         println!("received notification");///     println!("sending notification");///     notify.notify_one();///     // Wait for task to receive notification.///     handle.await.unwrap();/// Unbound multi-producer single-consumer (mpsc) channel./// No wakeups can be lost when using this channel because the call to/// `notify_one()` will store a permit in the `Notify`, which the following call/// to `notified()` will consume./// use std::collections::VecDeque;/// struct Channel<T> {///     values: Mutex<VecDeque<T>>,///     notify: Notify,/// impl<T> Channel<T> {///     pub fn send(&self, value: T) {///         self.values.lock().unwrap()///             .push_back(value);///         // Notify the consumer a value is available///         self.notify.notify_one();///     // This is a single-consumer channel, so several concurrent calls to///     // `recv` are not allowed.///     pub async fn recv(&self) -> T {///             // Drain values///             if let Some(value) = self.values.lock().unwrap().pop_front() {///                 return value;///             // Wait for values to be available///             self.notify.notified().await;/// Unbound multi-producer multi-consumer (mpmc) channel./// The call to [`enable`] is important because otherwise if you have two/// calls to `recv` and two calls to `send` in parallel, the following could/// happen:///  1. Both calls to `try_recv` return `None`.///  2. Both new elements are added to the vector.///  3. The `notify_one` method is called twice, adding only a single///     permit to the `Notify`.///  4. Both calls to `recv` reach the `Notified` future. One of them///     consumes the permit, and the other sleeps forever./// By adding the `Notified` futures to the list by calling `enable` before/// `try_recv`, the `notify_one` calls in step three would remove the/// futures from the list and mark them notified instead of adding a permit/// to the `Notify`. This ensures that both futures are woken./// Notice that this failure can only happen if there are two concurrent calls/// to `recv`. This is why the mpsc example above does not require a call to/// `enable`.///     messages: Mutex<VecDeque<T>>,///     notify_on_sent: Notify,///     pub fn send(&self, msg: T) {///         let mut locked_queue = self.messages.lock().unwrap();///         locked_queue.push_back(msg);///         drop(locked_queue);///         // Send a notification to one of the calls currently///         // waiting in a call to `recv`.///         self.notify_on_sent.notify_one();///     pub fn try_recv(&self) -> Option<T> {///         locked_queue.pop_front()///         let future = self.notify_on_sent.notified();///         tokio::pin!(future);///             // Make sure that no wakeup is lost if we get///             // `None` from `try_recv`.///             future.as_mut().enable();///             if let Some(msg) = self.try_recv() {///                 return msg;///             // Wait for a call to `notify_one`.///             // This uses `.as_mut()` to avoid consuming the future,///             // which lets us call `Pin::set` below.///             future.as_mut().await;///             // Reset the future in case another call to///             // `try_recv` got the message before us.///             future.set(self.notify_on_sent.notified());/// [park]: std::thread::park/// [unpark]: std::thread::Thread::unpark/// [`notified().await`]: Notify::notified()/// [`notify_one()`]: Notify::notify_one()/// [`enable`]: Notified::enable()/// [`Semaphore`]: crate::sync::Semaphore/// Waiting task's waker. Depending on the value of `notification`,/// this field is either protected by the `waiters` lock in/// `Notify`, or it is exclusively owned by the enclosing `Waiter`.AtomicNotification/// Notification for this waiter. Uses 2 bits to store if and how was/// notified, 1 bit for storing if it was woken up using FIFO or LIFO, and/// the rest of it is unused./// * if it's `None`, then `waker` is protected by the `waiters` lock./// * if it's `Some`, then `waker` is exclusively owned by the///   enclosing `Waiter` and can be accessed without locking.NOTIFICATION_NONE// No notification.NOTIFICATION_ONE// Notification type used by `notify_one`.NOTIFICATION_LAST// Notification type used by `notify_last`.NOTIFICATION_ALL// Notification type used by `notify_waiters`./// Notification for a `Waiter`./// This struct is equivalent to `Option<Notification>`, but uses/// `AtomicUsize` inside for atomic operations.store_release/// Store-release a notification./// This method should be called exactly once./// Clears the notification./// This method is used by a `Notified` future to consume the/// notification. It uses relaxed ordering and should be only/// used once the atomic notification is no longer shared.NotifyOneStrategyNotifyWaitersList/// List used in `Notify::notify_waiters`. It wraps a guarded linked list/// and gates the access to it on `notify.waiters` mutex. It also empties/// The `Notify` being received on./// The current state of the receiving process.notify_waiters_calls/// Number of calls to `notify_waiters` at the time of creation./// Future returned from [`Notify::notified()`]./// This future is fused, so once it has completed, any future calls to poll/// will immediately return `Poll::Ready`.NOTIFY_WAITERS_SHIFTNOTIFY_WAITERS_CALLS_MASK/// Initial "idle" state./// One or more threads are currently waiting to be notified./// Pending notification.get_num_notify_waiters_callsinc_num_notify_waiters_callsatomic_inc_num_notify_waiters_calls/// Create a new `Notify`, initialized without a permit./// let notify = Notify::new();/// When using the `tracing` [unstable feature], a `Notify` created with/// in [`tokio-console`]. Instead, [`Notify::new`] should be used to create/// static NOTIFY: Notify = Notify::const_new();/// Wait for a notification./// async fn notified(&self);/// Each `Notify` value holds a single permit. If a permit is available from/// an earlier call to [`notify_one()`], then `notified().await` will complete/// immediately, consuming that permit. Otherwise, `notified().await` waits/// for a permit to be made available by the next call to `notify_one()`./// The `Notified` future is not guaranteed to receive wakeups from calls to/// `notify_one()` if it has not yet been polled. See the documentation for/// [`Notified::enable()`] for more details./// The `Notified` future is guaranteed to receive wakeups from/// `notify_waiters()` as soon as it has been created, even if it has not/// yet been polled./// [`notify_one()`]: Notify::notify_one/// [`Notified::enable()`]: Notified::enable/// This method uses a queue to fairly distribute notifications in the order/// they were requested. Cancelling a call to `notified` makes you lose your/// Notifies the first waiting task./// If a task is currently waiting, that task is notified. Otherwise, a/// permit is stored in this `Notify` value and the **next** call to/// [`notified().await`] will complete immediately consuming the permit made/// available by this call to `notify_one()`./// At most one permit may be stored by `Notify`. Many sequential calls to/// `notify_one` will result in a single permit being stored. The next call to/// `notified().await` will complete immediately, but the one after that/// will wait.notify_last/// Notifies the last waiting task./// This function behaves similar to `notify_one`. The only difference is that it wakes/// the most recently added waiter instead of the oldest waiter./// Check the [`notify_one()`] documentation for more info and/// examples.notify_with_strategynotify_waiters/// Notifies all waiting tasks./// If a task is currently waiting, that task is notified. Unlike with/// `notify_one()`, no permit is stored to be used by the next call to/// `notified().await`. The purpose of this method is to notify all/// already registered waiters. Registering for notification is done by/// acquiring an instance of the `Notified` future via calling `notified()`.///     let notified1 = notify.notified();///     let notified2 = notify.notified();///         println!("sending notifications");///         notify2.notify_waiters();///     notified1.await;///     notified2.await;///     println!("received notifications");notify_locked/// Adds this future to the list of futures that are ready to receive/// wakeups from calls to [`notify_one`]./// Polling the future also adds it to the list, so this method should only/// be used if you want to add the future to the list before the first call/// to `poll`. (In fact, this method is equivalent to calling `poll` except/// that no `Waker` is registered.)/// This has no effect on notifications sent using [`notify_waiters`], which/// are received as long as they happen after the creation of the `Notified`/// regardless of whether `enable` or `poll` has been called./// This method returns true if the `Notified` is ready. This happens in the/// following situations:///  1. The `notify_waiters` method was called between the creation of the///     `Notified` and the call to this method.///  2. This is the first call to `enable` or `poll` on this future, and the///     `Notify` was holding a permit from a previous call to `notify_one`.///     The call consumes the permit in that case.///  3. The future has previously been enabled or polled, and it has since///     then been marked ready by either consuming a permit from the///     `Notify`, or by a call to `notify_one` or `notify_waiters` that///     removed it from the list of futures ready to receive wakeups./// If this method returns true, any future calls to poll on the same future/// The call to `enable` is important because otherwise if you have two/// [`notify_one`]: Notify::notify_one()/// [`notify_waiters`]: Notify::notify_waiters()poll_notified// Allow `unreachable_pub` warnings when sync is not enabled// due to the usage of `Notify` within the `rt` feature set.// When this module is compiled with `sync` enabled we will warn on// this lint. When `rt` is enabled we use `pub(crate)` which// triggers this warning but it is safe to ignore in this case.// ===== impl Notified =====value_set/// A thread-safe cell that can be written to only once./// A `OnceCell` is typically used for global variables that need to be/// initialized once on first use, but need no further changes. The `OnceCell`/// in Tokio allows the initialization procedure to be asynchronous./// use tokio::sync::OnceCell;/// async fn some_computation() -> u32 {///     1 + 1/// static ONCE: OnceCell<u32> = OnceCell::const_new();///     let result = ONCE.get_or_init(some_computation).await;///     assert_eq!(*result, 2);/// It is often useful to write a wrapper method for accessing the value./// async fn get_global_integer() -> &'static u32 {///     ONCE.get_or_init(|| async {///         1 + 1///     }).await///     let result = get_global_integer().await;/// Creates a new empty `OnceCell` instance./// Equivalent to `OnceCell::new`, except that it can be used in static/// When using the `tracing` [unstable feature], a `OnceCell` created with/// in [`tokio-console`]. Instead, [`OnceCell::new`] should be used to/// create an instrumented object if that is needed./// Creates a new `OnceCell` that contains the provided value, if any./// If the `Option` is `None`, this is equivalent to `OnceCell::new`./// [`OnceCell::new`]: crate::sync::OnceCell::new// Once https://github.com/rust-lang/rust/issues/73255 lands// and tokio MSRV is bumped to the rustc version with it stabilised,// we can make this function available in const context,// by creating `Semaphore::const_new_closed`.const_new_with/// Creates a new `OnceCell` that contains the provided value./// `const_new_with` will not be instrumented. As such, it will not be/// visible in [`tokio-console`]. Instead, [`OnceCell::new_with`] should be/// used to create an instrumented object if that is needed./// static ONCE: OnceCell<u32> = OnceCell::const_new_with(1);///     assert_eq!(*result, 1);/// Returns `true` if the `OnceCell` currently contains a value, and `false`// SAFETY: The OnceCell must not be empty./// Returns a reference to the value currently stored in the `OnceCell`, or/// `None` if the `OnceCell` is empty./// Returns a mutable reference to the value currently stored in the/// `OnceCell`, or `None` if the `OnceCell` is empty./// Since this call borrows the `OnceCell` mutably, it is safe to mutate the/// value inside the `OnceCell` — the mutable borrow statically guarantees/// no other references exist./// Sets the value of the `OnceCell` to the given value if the `OnceCell` is/// If the `OnceCell` already has a value, this call will fail with an/// [`SetError::AlreadyInitializedError`]./// If the `OnceCell` is empty, but some other task is currently trying to/// set the value, this call will fail with [`SetError::InitializingError`]./// [`SetError::AlreadyInitializedError`]: crate::sync::SetError::AlreadyInitializedError/// [`SetError::InitializingError`]: crate::sync::SetError::InitializingError/// Gets the value currently in the `OnceCell`, or initialize it with the/// given asynchronous operation./// If some other task is currently working on initializing the `OnceCell`,/// this call will wait for that other task to finish, then return the value/// that the other task produced./// If the provided operation is cancelled or panics, the initialization/// attempt is cancelled. If there are other tasks waiting for the value to/// be initialized, one of them will start another attempt at initializing/// the value./// This will deadlock if `f` tries to initialize the cell recursively./// If the provided operation returns an error, is cancelled or panics, the/// initialization attempt is cancelled. If there are other tasks waiting/// for the value to be initialized, one of them will start another attempt/// at initializing the value./// Takes the value from the cell, destroying the cell in the process./// Takes ownership of the current value, leaving the cell empty.  Returns/// `None` if the cell is empty.// Since `get` gives us access to immutable references of the OnceCell, OnceCell// can only be Sync if T is Sync, otherwise OnceCell would allow sharing// references of !Sync values across threads. We need T to be Send in order for// OnceCell to by Sync because we can use `set` on `&OnceCell<T>` to send values// (of type T) across threads.// Access to OnceCell's value is guarded by the semaphore permit// and atomic operations on `value_set`, so as long as T itself is Send// it's safe to send it to another threadAlreadyInitializedError/// The cell was already initialized when [`OnceCell::set`] was called./// [`OnceCell::set`]: crate::sync::OnceCell::setInitializingError/// The cell is currently being initialized./// Errors that can be returned from [`OnceCell::set`].is_already_init_err/// Whether `SetError` is `SetError::AlreadyInitializedError`.is_initializing_err/// Whether `SetError` is `SetError::InitializingError`// This file contains an implementation of an OnceCell. The principle// behind the safety of the cell is that any thread with an `&OnceCell` may// access the `value` field according the following rules://  1. When `value_set` is false, the `value` field may be modified by the//     thread holding the permit on the semaphore.//  2. When `value_set` is true, the `value` field may be accessed immutably by//     any thread.// It is an invariant that if the semaphore is closed, then `value_set` is true.// The reverse does not necessarily hold — but if not, the semaphore may not// have any available permits.// A thread with a `&mut OnceCell` may modify the value in any way it wants as// long as the invariants are upheld./// Sends a value to the associated [`Receiver`]./// A pair of both a [`Sender`] and a [`Receiver`]  are created by the/// [`channel`](fn@channel) function./// use tokio::sync::oneshot;///     let (tx, rx) = oneshot::channel();///         if let Err(_) = tx.send(3) {///             println!("the receiver dropped");///     match rx.await {///         Ok(v) => println!("got = {:?}", v),///         Err(_) => println!("the sender dropped"),/// If the sender is dropped without sending, the receiver will fail with/// [`error::RecvError`]:///     let (tx, rx) = oneshot::channel::<u32>();///         drop(tx);///         Ok(_) => panic!("This doesn't happen"),/// To use a `Sender` from a destructor, put it in an [`Option`] and call/// [`Option::take`]./// struct SendOnDrop {///     sender: Option<oneshot::Sender<&'static str>>,/// impl Drop for SendOnDrop {///         if let Some(sender) = self.sender.take() {///             // Using `let _ =` to ignore send errors.///             let _ = sender.send("I got dropped!");/// # async fn _doc() {}/// # #[tokio::main(flavor = "current_thread")]///     let (send, recv) = oneshot::channel();///     let send_on_drop = SendOnDrop { sender: Some(send) };///     drop(send_on_drop);///     assert_eq!(recv.await, Ok("I got dropped!"));/// [`Option`]: std::option::Option/// [`Option::take`]: std::option::Option::take/// Receives a value from the associated [`Sender`]./// This channel has no `recv` method because the receiver itself implements the/// [`Future`] trait. To receive a `Result<T, `[`error::RecvError`]`>`, `.await` the `Receiver` object directly./// The `poll` method on the `Future` trait is allowed to spuriously return/// `Poll::Pending` even if the message has been sent. If such a spurious/// failure happens, then the caller will be woken when the spurious failure has/// been resolved so that the caller can attempt to receive the message again./// Note that receiving such a wakeup does not guarantee that the next call will/// succeed — it could fail with another spurious failure. (A spurious failure/// does not mean that the message is lost. It is just delayed.)/// To use a `Receiver` in a `tokio::select!` loop, add `&mut` in front of the/// use tokio::time::{interval, sleep, Duration};///     let (send, mut recv) = oneshot::channel();///     let mut interval = interval(Duration::from_millis(100));///     # let handle =///         sleep(Duration::from_secs(1)).await;///         send.send("shut down").unwrap();///         tokio::select! {///             _ = interval.tick() => println!("Another 100ms"),///             msg = &mut recv => {///                 println!("Got message: {}", msg.unwrap());///     # handle.await.unwrap();/// Error returned by the `Future` implementation for `Receiver`./// This error is returned by the receiver when the sender is dropped without sending./// The send half of the channel has not yet sent a value./// The send half of the channel was dropped without sending a value./// Error returned by the `try_recv` function on `Receiver`.//! `Oneshot` error types.// ===== impl RecvError =====// ===== impl TryRecvError =====/// Manages the state of the inner cell./// The value. This is set by `Sender` and read by `Receiver`. The state of/// the cell is tracked by `state`./// The task to notify when the receiver drops without consuming the value./// The `TX_TASK_SET` bit in the `state` field is set if this field is/// initialized. If that bit is unset, this field may be uninitialized./// The task to notify when the value is sent./// The `RX_TASK_SET` bit in the `state` field is set if this field iswith_taskdrop_taskset_task/// Creates a new one-shot channel for sending single values across asynchronous/// The function returns separate "send" and "receive" handles. The `Sender`/// handle is used by the producer to send the value. The `Receiver` handle is/// used by the consumer to receive the value./// Each handle can be used on separate tasks./// Attempts to send a value on this channel, returning it back if it could/// not be sent./// This method consumes `self` as only one value may ever be sent on a `oneshot`/// channel. It is not marked async because sending a message to an `oneshot`/// channel never requires any form of waiting.  Because of this, the `send`/// method can be used in both synchronous and asynchronous code without/// problems./// the corresponding receiver has already been deallocated. Note that a/// return value of `Err` means that the data will never be received, but/// a return value of `Ok` does *not* mean that the data will be received./// It is possible for the corresponding receiver to hang up immediately/// after this function returns `Ok`./// Send a value to another task/// Waits for the associated [`Receiver`] handle to close./// A [`Receiver`] is closed by either calling [`close`] explicitly or the/// [`Receiver`] value is dropped./// This function is useful when paired with `select!` to abort a/// computation when the receiver is no longer interested in the result./// Returns a `Future` which must be awaited on.///     let (mut tx, rx) = oneshot::channel::<()>();///     tx.closed().await;///     println!("the receiver dropped");/// Paired with select/// async fn compute() -> String {///     // Complex computation returning a `String`/// # "hello".to_string()///     let (mut tx, rx) = oneshot::channel();///             _ = tx.closed() => {///                 // The receiver dropped, no need to do any further work///             value = compute() => {///                 // The send can fail if the channel was closed at the exact same///                 // time as when compute() finished, so just ignore the failure.///                 let _ = tx.send(value);///     // Wait for up to 10 seconds///     let _ = time::timeout(Duration::from_secs(10), rx).await;/// Returns `true` if the associated [`Receiver`] handle has been dropped./// If `true` is returned, a call to `send` will always result in an error.///     assert!(!tx.is_closed());///     assert!(tx.is_closed());///     assert!(tx.send("never received").is_err());poll_closed/// Checks whether the `oneshot` channel has been closed, and if not, schedules the/// `Waker` in the provided `Context` to receive a notification when the channel is/// A [`Receiver`] is closed by either calling [`close`] explicitly, or when the/// Note that on multiple calls to poll, only the `Waker` from the `Context` passed/// to the most recent call will be scheduled to receive a wakeup./// [`Receiver`]: struct@crate::sync::oneshot::Receiver/// [`close`]: fn@crate::sync::oneshot::Receiver::close///  * `Poll::Pending` if the channel is still open.///  * `Poll::Ready(())` if the channel is closed.///     let (mut tx, mut rx) = oneshot::channel::<()>();///         rx.close();///     poll_fn(|cx| tx.poll_closed(cx)).await;/// Prevents the associated [`Sender`] handle from sending a value./// Any `send` operation which happens after calling `close` is guaranteed/// to fail. After calling `close`, [`try_recv`] should be called to/// receive a value if one was sent **before** the call to `close`/// This function is useful to perform a graceful shutdown and ensure that a/// value will not be sent into the channel and never received./// `close` is no-op if a message is already received or the channel/// is already closed./// [`try_recv`]: Receiver::try_recv/// Prevent a value from being sent/// use tokio::sync::oneshot::error::TryRecvError;///     let (tx, mut rx) = oneshot::channel();///     match rx.try_recv() {///         Err(TryRecvError::Closed) => {}/// Receive a value sent **before** calling `close`///     assert!(tx.send("will receive").is_ok());///     let msg = rx.try_recv().unwrap();///     assert_eq!(msg, "will receive");/// Checks if this receiver is terminated./// This function returns true if this receiver has already yielded a [`Poll::Ready`] result./// If so, this receiver should no longer be polled./// Sending a value and polling it.///     // A receiver is not terminated when it is initialized.///     assert!(!rx.is_terminated());///     // A receiver is not terminated it is polled and is still pending.///     let poll = futures::poll!(&mut rx);///     assert_eq!(poll, Poll::Pending);///     // A receiver is not terminated if a value has been sent, but not yet read.///     // A receiver *is* terminated after it has been polled and yielded a value.///     assert_eq!((&mut rx).await, Ok(0));///     assert!(rx.is_terminated());/// Dropping the sender.///     let (tx, mut rx) = oneshot::channel::<()>();///     // A receiver is not immediately terminated when the sender is dropped.///     // A receiver *is* terminated after it has been polled and yielded an error.///     let _ = (&mut rx).await.unwrap_err();/// It is not necessarily safe to poll an empty receiver, which may have/// already yielded a value. Use [`is_terminated()`][Self::is_terminated]/// to check whether or not a receiver can be safely polled, instead./// Sending a value.///     let _ = (&mut rx).await;///     // A channel is empty if the sender is dropped.///     // A closed channel still yields an error, however.///     (&mut rx).await.expect_err("should yield an error");/// Terminated channels are empty.///     // NB: an empty channel is not necessarily safe to poll!/// Attempts to receive a value./// If a pending value exists in the channel, it is returned. If no value/// has been sent, the current task **will not** be registered for/// future notification./// This function is useful to call from outside the context of an/// asynchronous task./// Note that unlike the `poll` method, the `try_recv` method cannot fail/// spuriously. Any send or close event that happens before this call to/// `try_recv` will be correctly returned to the caller./// - `Ok(T)` if a value is pending in the channel./// - `Err(TryRecvError::Empty)` if no value has been sent yet./// - `Err(TryRecvError::Closed)` if the sender has dropped without sending///   a value, or if the message has already been received./// `try_recv` before a value is sent, then after.///         // The channel is currently empty///         Err(TryRecvError::Empty) => {}///     // Send a value///         Ok(value) => assert_eq!(value, "hello"),/// `try_recv` when the sender dropped before sending a value///         // The channel will never receive a value.///     let (tx, rx) = oneshot::channel::<u8>();///         assert_eq!(Ok(10), rx.blocking_recv());/// Called by `Receiver` to indicate that the value will never be received./// Consumes the value. This function does not check `state`./// Calling this method concurrently on multiple threads will result in a/// data race. The `VALUE_SENT` state bit is used to ensure that only the/// sender *or* the receiver will call this method at a given point in time./// If `VALUE_SENT` is not set, then only the sender may call this method;/// if it is set, then only the receiver may call this method./// Returns true if there is a value. This function does not check `state`.mut_loadRX_TASK_SET/// Indicates that a waker for the receiving task has been set./// If this bit is not set, the `rx_task` field may be uninitialized.VALUE_SENT/// Indicates that a value has been stored in the channel's inner `UnsafeCell`./// This bit controls which side of the channel is permitted to access the/// `UnsafeCell`. If it is set, the `UnsafeCell` may ONLY be accessed by the/// receiver. If this bit is NOT set, the `UnsafeCell` may ONLY be accessed by/// the sender.TX_TASK_SET/// Indicates that a waker for the sending task has been set./// If this bit is not set, the `tx_task` field may be uninitialized.set_completeis_rx_task_setset_rx_taskunset_rx_taskset_tx_taskunset_tx_taskis_tx_task_set//! A one-shot channel is used for sending a single message between//! asynchronous tasks. The [`channel`] function is used to create a//! [`Sender`] and [`Receiver`] handle pair that form the channel.//! The `Sender` handle is used by the producer to send the value.//! The `Receiver` handle is used by the consumer to receive the value.//! Each handle can be used on separate tasks.//! Since the `send` method is not async, it can be used anywhere. This includes//! sending between two runtimes, and using it from non-async code.//! If the [`Receiver`] is closed before receiving a message which has already//! been sent, the message will remain in the channel until the receiver is//! dropped, at which point the message will be dropped immediately.//!         if let Err(_) = tx.send(3) {//!             println!("the receiver dropped");//!     match rx.await {//!         Ok(v) => println!("got = {:?}", v),//!         Err(_) => println!("the sender dropped"),//! If the sender is dropped without sending, the receiver will fail with//! [`error::RecvError`]://!     let (tx, rx) = oneshot::channel::<u32>();//!         drop(tx);//!         Ok(_) => panic!("This doesn't happen"),//! To use a `oneshot` channel in a `tokio::select!` loop, add `&mut` in front of//! the channel.//! use tokio::time::{interval, sleep, Duration};//! # async fn _doc() {}//! # #[tokio::main(flavor = "current_thread", start_paused = true)]//!     let (send, mut recv) = oneshot::channel();//!     let mut interval = interval(Duration::from_millis(100));//!     # let handle =//!         sleep(Duration::from_secs(1)).await;//!         send.send("shut down").unwrap();//!         tokio::select! {//!             _ = interval.tick() => println!("Another 100ms"),//!             msg = &mut recv => {//!                 println!("Got message: {}", msg.unwrap());//!     # handle.await.unwrap();//! To use a `Sender` from a destructor, put it in an [`Option`] and call//! [`Option::take`].//! struct SendOnDrop {//!     sender: Option<oneshot::Sender<&'static str>>,//! impl Drop for SendOnDrop {//!         if let Some(sender) = self.sender.take() {//!             // Using `let _ =` to ignore send errors.//!             let _ = sender.send("I got dropped!");//! # #[tokio::main(flavor = "current_thread")]//!     let (send, recv) = oneshot::channel();//!     let send_on_drop = SendOnDrop { sender: Some(send) };//!     drop(send_on_drop);//!     assert_eq!(recv.await, Ok("I got dropped!"));/// Owned RAII structure used to release the shared read access of a lock when/// This structure is created by the [`read_owned`] method on/// [`RwLock`]./// [`read_owned`]: method@crate::sync::RwLock::read_owned/// [`RwLock`]: struct@crate::sync::RwLock/// Makes a new `OwnedRwLockReadGuard` for a component of the locked data./// This operation cannot fail as the `OwnedRwLockReadGuard` passed in/// already locked the data./// used as `OwnedRwLockReadGuard::map(...)`. A method would interfere with/// methods of the same name on the contents of the locked data./// use tokio::sync::{RwLock, OwnedRwLockReadGuard};/// let lock = Arc::new(RwLock::new(Foo(1)));/// let guard = lock.read_owned().await;/// let guard = OwnedRwLockReadGuard::map(guard, |f| &f.0);/// assert_eq!(1, *guard);/// Attempts to make a new [`OwnedRwLockReadGuard`] for a component of the/// locked data. The original guard is returned if the closure returns/// This is an associated function that needs to be used as/// `OwnedRwLockReadGuard::try_map(..)`. A method would interfere with/// let guard = OwnedRwLockReadGuard::try_map(guard, |f| Some(&f.0)).expect("should not fail");/// Returns a reference to the original `Arc<RwLock>`./// let guard = lock.clone().read_owned().await;/// assert!(Arc::ptr_eq(&lock, OwnedRwLockReadGuard::rwlock(&guard)));permits_acquired/// Owned RAII structure used to release the exclusive write access of a lock when/// This structure is created by the [`write_owned`] method/// on [`RwLock`]./// [`write_owned`]: method@crate::sync::RwLock::write_owned/// Makes a new [`OwnedRwLockMappedWriteGuard`] for a component of the locked/// This operation cannot fail as the `OwnedRwLockWriteGuard` passed in/// `OwnedRwLockWriteGuard::map(..)`. A method would interfere with methods/// of the same name on the contents of the locked data./// use tokio::sync::{RwLock, OwnedRwLockWriteGuard};///     let lock = Arc::clone(&lock);///     let mut mapped = OwnedRwLockWriteGuard::map(lock.write_owned().await, |f| &mut f.0);/// assert_eq!(Foo(2), *lock.read().await);downgrade_map/// Makes a new [`OwnedRwLockReadGuard`] for a component of the locked data./// This operation cannot fail as the `OwnedRwLockWriteGuard` passed in already/// locked the data./// `OwnedRwLockWriteGuard::downgrade_map(..)`. A method would interfere with methods of/// Inside of `f`, you retain exclusive access to the data, despite only being given a `&T`. Handing out a/// `&mut T` would result in unsoundness, as you could use interior mutability./// let guard = Arc::clone(&lock).write_owned().await;/// let mapped = OwnedRwLockWriteGuard::downgrade_map(guard, |f| &f.0);/// let foo = lock.read_owned().await;/// assert_eq!(foo.0, *mapped);/// Attempts to make a new [`OwnedRwLockMappedWriteGuard`] for a component/// of the locked data. The original guard is returned if the closure/// used as `OwnedRwLockWriteGuard::try_map(...)`. A method would interfere/// with methods of the same name on the contents of the locked data./// [`RwLockMappedWriteGuard`]: struct@crate::sync::RwLockMappedWriteGuard///     let guard = Arc::clone(&lock).write_owned().await;///     let mut guard = OwnedRwLockWriteGuard::try_map(guard, |f| Some(&mut f.0)).expect("should not fail");///     *guard = 2;try_downgrade_map/// Attempts to make a new [`OwnedRwLockReadGuard`] for a component of/// the locked data. The original guard is returned if the closure returns/// used as `OwnedRwLockWriteGuard::try_downgrade_map(...)`. A method would interfere with/// If this function returns `Err(...)`, the lock is never unlocked nor downgraded./// let guard = OwnedRwLockWriteGuard::try_downgrade_map(guard, |f| Some(&f.0)).expect("should not fail");/// assert_eq!(foo.0, *guard);into_mapped/// Converts this `OwnedRwLockWriteGuard` into an/// `OwnedRwLockMappedWriteGuard`. This method can be used to store a/// non-mapped guard in a struct field that expects a mapped guard./// This is equivalent to calling `OwnedRwLockWriteGuard::map(guard, |me| me)`./// Atomically downgrades a write lock into a read lock without allowing/// any writers to take exclusive access of the lock in the meantime./// **Note:** This won't *necessarily* allow any additional readers to acquire/// locks, since [`RwLock`] is fair and it is possible that a writer is next/// in line./// Returns an RAII guard which will drop this read access of the `RwLock`/// # use tokio::sync::RwLock;/// let n = lock.clone().write_owned().await;/// let cloned_lock = lock.clone();/// let handle = tokio::spawn(async move {///     *cloned_lock.write_owned().await = 2;/// let n = n.downgrade();/// assert_eq!(*n, 1, "downgrade is atomic");/// drop(n);/// handle.await.unwrap();/// assert_eq!(*lock.read().await, 2, "second writer obtained write lock");/// let guard = lock.clone().write_owned().await;/// assert!(Arc::ptr_eq(&lock, OwnedRwLockWriteGuard::rwlock(&guard)));/// This structure is created by [mapping] an [`OwnedRwLockWriteGuard`]. It is a/// separate type from `OwnedRwLockWriteGuard` to disallow downgrading a mapped/// guard, since doing so can cause undefined behavior./// [mapping]: method@crate::sync::OwnedRwLockWriteGuard::map/// [`OwnedRwLockWriteGuard`]: struct@crate::sync::OwnedRwLockWriteGuard/// Makes a new `OwnedRwLockMappedWriteGuard` for a component of the locked/// This operation cannot fail as the `OwnedRwLockMappedWriteGuard` passed/// Attempts to make a new `OwnedRwLockMappedWriteGuard` for a component/// used as `OwnedRwLockMappedWriteGuard::try_map(...)`. A method would interfere with/// use tokio::sync::{///     RwLock,///     OwnedRwLockWriteGuard,///     OwnedRwLockMappedWriteGuard,/// let guard = OwnedRwLockWriteGuard::map(guard, |x| x);/// assert!(Arc::ptr_eq(&lock, OwnedRwLockMappedWriteGuard::rwlock(&guard)));/// This structure is created by the [`read`] method on/// [`read`]: method@crate::sync::RwLock::read/// Makes a new `RwLockReadGuard` for a component of the locked data./// This operation cannot fail as the `RwLockReadGuard` passed in already/// used as `RwLockReadGuard::map(...)`. A method would interfere with/// This is an asynchronous version of [`RwLockReadGuard::map`] from the/// [`parking_lot` crate]./// [`RwLockReadGuard::map`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockReadGuard.html#method.map/// [`parking_lot` crate]: https://crates.io/crates/parking_lot/// use tokio::sync::{RwLock, RwLockReadGuard};/// let lock = RwLock::new(Foo(1));/// let guard = lock.read().await;/// let guard = RwLockReadGuard::map(guard, |f| &f.0);/// Attempts to make a new [`RwLockReadGuard`] for a component of the/// `RwLockReadGuard::try_map(..)`. A method would interfere with methods of the/// same name on the contents of the locked data./// This is an asynchronous version of [`RwLockReadGuard::try_map`] from the/// [`RwLockReadGuard::try_map`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockReadGuard.html#method.try_map/// let guard = RwLockReadGuard::try_map(guard, |f| Some(&f.0)).expect("should not fail");/// This structure is created by the [`write`] method/// [`write`]: method@crate::sync::RwLock::write/// Makes a new [`RwLockMappedWriteGuard`] for a component of the locked data./// This operation cannot fail as the `RwLockWriteGuard` passed in already/// `RwLockWriteGuard::map(..)`. A method would interfere with methods of/// This is an asynchronous version of [`RwLockWriteGuard::map`] from the/// [`RwLockWriteGuard::map`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.map/// use tokio::sync::{RwLock, RwLockWriteGuard};///     let mut mapped = RwLockWriteGuard::map(lock.write().await, |f| &mut f.0);/// Makes a new [`RwLockReadGuard`] for a component of the locked data./// `RwLockWriteGuard::downgrade_map(..)`. A method would interfere with methods of/// This is equivalent to a combination of asynchronous [`RwLockWriteGuard::map`] and [`RwLockWriteGuard::downgrade`]/// from the [`parking_lot` crate]./// [`RwLockWriteGuard::downgrade`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.downgrade/// let mapped = RwLockWriteGuard::downgrade_map(lock.write().await, |f| &f.0);/// let foo = lock.read().await;/// Attempts to make a new [`RwLockMappedWriteGuard`] for a component of/// used as `RwLockWriteGuard::try_map(...)`. A method would interfere with/// This is an asynchronous version of [`RwLockWriteGuard::try_map`] from/// the [`parking_lot` crate]./// [`RwLockWriteGuard::try_map`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.try_map///     let guard = lock.write().await;///     let mut guard = RwLockWriteGuard::try_map(guard, |f| Some(&mut f.0)).expect("should not fail");/// Attempts to make a new [`RwLockReadGuard`] for a component of/// used as `RwLockWriteGuard::try_downgrade_map(...)`. A method would interfere with/// This is equivalent to a combination of asynchronous [`RwLockWriteGuard::try_map`] and [`RwLockWriteGuard::downgrade`]/// let guard = RwLockWriteGuard::try_downgrade_map(lock.write().await, |f| Some(&f.0)).expect("should not fail");/// Converts this `RwLockWriteGuard` into an `RwLockMappedWriteGuard`. This/// method can be used to store a non-mapped guard in a struct field that/// expects a mapped guard./// This is equivalent to calling `RwLockWriteGuard::map(guard, |me| me)`./// let n = lock.write().await;///     *cloned_lock.write().await = 2;/// This structure is created by [mapping] an [`RwLockWriteGuard`]. It is a/// separate type from `RwLockWriteGuard` to disallow downgrading a mapped/// [mapping]: method@crate::sync::RwLockWriteGuard::map/// [`RwLockWriteGuard`]: struct@crate::sync::RwLockWriteGuard/// Makes a new `RwLockMappedWriteGuard` for a component of the locked data./// This operation cannot fail as the `RwLockMappedWriteGuard` passed in already/// `RwLockMappedWriteGuard::map(..)`. A method would interfere with methods/// used as `RwLockMappedWriteGuard::try_map(...)`. A method would interfere// Note: No `downgrade`, `downgrade_map` nor `try_downgrade_map` because they would be unsound, as we're already//       potentially been mapped with internal mutability.MAX_READSmr// maximum number of concurrent readers//semaphore to coordinate read and write access to T//inner data T/// An asynchronous reader-writer lock./// In comparison, a [`Mutex`] does not distinguish between readers or writers/// that acquire the lock, therefore causing any tasks waiting for the lock to/// become available to yield. An `RwLock` will allow any number of readers to/// acquire the lock as long as a writer is not holding the lock./// The priority policy of Tokio's read-write lock is _fair_ (or/// [_write-preferring_]), in order to ensure that readers cannot starve/// writers. Fairness is ensured using a first-in, first-out queue for the tasks/// awaiting the lock; if a task that wishes to acquire the write lock is at the/// head of the queue, read locks will not be given out until the write lock has/// been released. This is in contrast to the Rust standard library's/// `std::sync::RwLock`, where the priority policy is dependent on the/// operating system's implementation./// required that `T` satisfies [`Send`] to be shared across threads. The RAII guards/// returned from the locking methods implement [`Deref`](trait@std::ops::Deref)/// (and [`DerefMut`](trait@std::ops::DerefMut)/// for the `write` methods) to allow access to the content of the lock./// use tokio::sync::RwLock;///     let lock = RwLock::new(5);///     // many reader locks can be held at once///         let r1 = lock.read().await;///         let r2 = lock.read().await;///         assert_eq!(*r1, 5);///         assert_eq!(*r2, 5);///     } // read locks are dropped at this point///     // only one write lock may be held, however///         let mut w = lock.write().await;///         *w += 1;///         assert_eq!(*w, 6);///     } // write lock is dropped here/// [`Mutex`]: struct@super::Mutex/// [`RwLock`]: struct@RwLock/// [`RwLockReadGuard`]: struct@RwLockReadGuard/// [`RwLockWriteGuard`]: struct@RwLockWriteGuard/// [_write-preferring_]: https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock#Priority_policies// As long as T: Send + Sync, it's fine to send and share RwLock<T> between threads.// If T were not Send, sending and sharing a RwLock<T> would be bad, since you can access T through// RwLock<T>.// NB: These impls need to be explicit since we're storing a raw pointer.// Safety: Stores a raw pointer to `T`, so if `T` is `Sync`, the lock guard over// `T` is `Send`.// T is required to be `Send` because an OwnedRwLockReadGuard can be used to drop the value held in// the RwLock, unlike RwLockReadGuard.// `T` is `Send` - but since this is also provides mutable access, we need to// make sure that `T` is `Send` since its value can be sent across thread// boundaries.with_max_readers/// Creates a new instance of an `RwLock<T>` which is unlocked/// and allows a maximum of `max_reads` concurrent readers./// let lock = RwLock::with_max_readers(5, 1024);/// Panics if `max_reads` is more than `u32::MAX >> 3`./// When using the `tracing` [unstable feature], a `RwLock` created with/// in [`tokio-console`]. Instead, [`RwLock::new`] should be used to create/// static LOCK: RwLock<i32> = RwLock::const_new(5);const_with_max_readers/// static LOCK: RwLock<i32> = RwLock::const_with_max_readers(5, 1024);/// Locks this `RwLock` with shared read access, causing the current task/// to yield until the lock has been acquired./// The calling task will yield until there are no writers which hold the/// lock. There may be other readers inside the lock when the task resumes./// Note that under the priority policy of [`RwLock`], read locks are not/// granted until prior write locks, to prevent starvation. Therefore/// deadlock may occur if a read lock is held by the current task, a write/// lock attempt is made, and then a subsequent read lock attempt is made/// by the current task./// were requested. Cancelling a call to `read` makes you lose your place in///     let lock = Arc::new(RwLock::new(1));///     let c_lock = lock.clone();///     let n = lock.read().await;///     assert_eq!(*n, 1);///         // While main has an active read lock, we acquire one too.///         let r = c_lock.read().await;///         assert_eq!(*r, 1);///     }).await.expect("The spawned task has panicked");///     // Drop the guard after the spawned task finishes.///     drop(n);blocking_read/// Blockingly locks this `RwLock` with shared read access./// need to use this rwlock in asynchronous code as well as in synchronous code./// Returns an RAII guard which will drop the read access of this `RwLock` when dropped.///     let rwlock = Arc::new(RwLock::new(1));///     let mut write_lock = rwlock.write().await;///     let blocking_task = tokio::task::spawn_blocking({///         let rwlock = Arc::clone(&rwlock);///             // This shall block until the `write_lock` is released.///             let read_lock = rwlock.blocking_read();///             assert_eq!(*read_lock, 0);///     *write_lock -= 1;///     drop(write_lock); // release the lock.///     assert!(rwlock.try_write().is_ok());read_owned/// This method is identical to [`RwLock::read`], except that the returned/// guard references the `RwLock` with an [`Arc`] rather than by borrowing/// it. Therefore, the `RwLock` must be wrapped in an `Arc` to call this/// the `RwLock` alive by holding an `Arc`./// were requested. Cancelling a call to `read_owned` makes you lose your///     let n = lock.read_owned().await;///         let r = c_lock.read_owned().await;///}/// If the access couldn't be acquired immediately, returns [`TryLockError`]./// Otherwise, an RAII guard is returned which will release read access///     let v = lock.try_read().unwrap();///     assert_eq!(*v, 1);///         let n = c_lock.read().await;///         assert_eq!(*n, 1);///     // Drop the guard when spawned task finishes.///     drop(v);try_read_owned/// This method is identical to [`RwLock::try_read`], except that the/// returned guard references the `RwLock` with an [`Arc`] rather than by/// borrowing it. Therefore, the `RwLock` must be wrapped in an `Arc` to/// call this method, and the guard will live for the `'static` lifetime,/// as it keeps the `RwLock` alive by holding an `Arc`.///     let v = lock.try_read_owned().unwrap();///         let n = c_lock.read_owned().await;/// Locks this `RwLock` with exclusive write access, causing the current/// task to yield until the lock has been acquired./// The calling task will yield while other writers or readers currently/// have access to the lock./// were requested. Cancelling a call to `write` makes you lose your place/// in the queue.///   let lock = RwLock::new(1);///   let mut n = lock.write().await;///   *n = 2;blocking_write/// Blockingly locks this `RwLock` with exclusive write access./// Returns an RAII guard which will drop the write access of this `RwLock` when dropped./// use tokio::{sync::RwLock};///     let rwlock =  Arc::new(RwLock::new(1));///     let read_lock = rwlock.read().await;///             // This shall block until the `read_lock` is released.///             let mut write_lock = rwlock.blocking_write();///             *write_lock = 2;///     assert_eq!(*read_lock, 1);///     // Release the last outstanding read lock.///     drop(read_lock);///     let read_lock = rwlock.try_read().unwrap();///     assert_eq!(*read_lock, 2);write_owned/// This method is identical to [`RwLock::write`], except that the returned/// were requested. Cancelling a call to `write_owned` makes you lose your///   let lock = Arc::new(RwLock::new(1));///   let mut n = lock.write_owned().await;/// Attempts to acquire this `RwLock` with exclusive write access./// Otherwise, an RAII guard is returned which will release write access///     let rw = RwLock::new(1);///     let v = rw.read().await;///     assert!(rw.try_write().is_err());try_write_owned/// This method is identical to [`RwLock::try_write`], except that the///     let rw = Arc::new(RwLock::new(1));///     let v = Arc::clone(&rw).read_owned().await;///     assert!(rw.try_write_owned().is_err());///     let mut lock = RwLock::new(1);///     let n = lock.get_mut();/// Consumes the lock, returning the underlying data.// low level implementationll_sem/// The low level semaphore/// Counting semaphore performing asynchronous permit acquisition./// A semaphore maintains a set of permits. Permits are used to synchronize/// access to a shared resource. A semaphore differs from a mutex in that it/// can allow more than one concurrent caller to access the shared resource at a/// When `acquire` is called and the semaphore has remaining permits, the/// function immediately returns a permit. However, if no remaining permits are/// available, `acquire` (asynchronously) waits until an outstanding permit is/// dropped. At this point, the freed permit is assigned to the caller./// This `Semaphore` is fair, which means that permits are given out in the order/// they were requested. This fairness is also applied when `acquire_many` gets/// involved, so if a call to `acquire_many` at the front of the queue requests/// more permits than currently available, this can prevent a call to `acquire`/// from completing, even if the semaphore has enough permits complete the call/// to `acquire`./// To use the `Semaphore` in a poll function, you can use the [`PollSemaphore`]/// use tokio::sync::{Semaphore, TryAcquireError};///     let semaphore = Semaphore::new(3);///     let a_permit = semaphore.acquire().await.unwrap();///     let two_permits = semaphore.acquire_many(2).await.unwrap();///     assert_eq!(semaphore.available_permits(), 0);///     let permit_attempt = semaphore.try_acquire();///     assert_eq!(permit_attempt.err(), Some(TryAcquireError::NoPermits));/// ## Limit the number of simultaneously opened files in your program/// Most operating systems have limits on the number of open file/// handles. Even in systems without explicit limits, resource constraints/// implicitly set an upper bound on the number of open files. If your/// program attempts to open a large number of files and exceeds this/// limit, it will result in an error./// This example uses a Semaphore with 100 permits. By acquiring a permit from/// the Semaphore before accessing a file, you ensure that your program opens/// no more than 100 files at a time. When trying to open the 101st/// file, the program will wait until a permit becomes available before/// proceeding to open another file./// use std::io::Result;/// use tokio::sync::Semaphore;/// static PERMITS: Semaphore = Semaphore::const_new(100);/// async fn write_to_file(message: &[u8]) -> Result<()> {///     let _permit = PERMITS.acquire().await.unwrap();///     let mut buffer = File::create("example.txt").await?;///     buffer.write_all(message).await?;///     Ok(()) // Permit goes out of scope here, and is available again for acquisition/// ## Limit the number of outgoing requests being sent at the same time/// In some scenarios, it might be required to limit the number of outgoing/// requests being sent in parallel. This could be due to limits of a consumed/// API or the network resources of the system the application is running on./// This example uses an `Arc<Semaphore>` with 10 permits. Each task spawned is/// given a reference to the semaphore by cloning the `Arc<Semaphore>`. Before/// a task sends a request, it must acquire a permit from the semaphore by/// calling [`Semaphore::acquire`]. This ensures that at most 10 requests are/// sent in parallel at any given time. After a task has sent a request, it/// drops the permit to allow other tasks to send requests.///     // Define maximum number of parallel requests.///     let semaphore = Arc::new(Semaphore::new(10));///     // Spawn many tasks that will send requests.///     let mut jhs = Vec::new();///     for task_id in 0..100 {///         let semaphore = semaphore.clone();///         let jh = tokio::spawn(async move {///             // Acquire permit before sending request.///             let _permit = semaphore.acquire().await.unwrap();///             // Send the request.///             let response = send_request(task_id).await;///             // Drop the permit after the request has been sent.///             drop(_permit);///             // Handle response.///             response///         jhs.push(jh);///     // Collect responses from tasks.///     let mut responses = Vec::new();///     for jh in jhs {///         let response = jh.await.unwrap();///         responses.push(response);///     // Process responses./// # async fn send_request(task_id: usize) {/// #     // Send request./// ## Limit the number of incoming requests being handled at the same time/// Similar to limiting the number of simultaneously opened files, network handles/// are a limited resource. Allowing an unbounded amount of requests to be processed/// could result in a denial-of-service, among many other issues./// This example uses an `Arc<Semaphore>` instead of a global variable./// To limit the number of requests that can be processed at the time,/// we acquire a permit for each task before spawning it. Once acquired,/// a new task is spawned; and once finished, the permit is dropped inside/// of the task to allow others to spawn. Permits must be acquired via/// [`Semaphore::acquire_owned`] to be movable across the task boundary./// (Since our semaphore is not a global variable — if it was, then `acquire` would be enough.)///     let semaphore = Arc::new(Semaphore::new(3));///         // Acquire permit before accepting the next socket.///         // We use `acquire_owned` so that we can move `permit` into///         // other tasks.///         let permit = semaphore.clone().acquire_owned().await.unwrap();///         let (mut socket, _) = listener.accept().await?;///             // Do work using the socket.///             handle_connection(&mut socket).await;///             // Drop socket while the permit is still live.///             drop(socket);///             // Drop the permit, so more tasks can be created.///             drop(permit);/// # async fn handle_connection(_socket: &mut tokio::net::TcpStream) {/// #   // Do work/// ## Prevent tests from running in parallel/// By default, Rust runs tests in the same file in parallel. However, in some/// cases, running two tests in parallel may lead to problems. For example, this/// can happen when tests use the same database./// Consider the following scenario:/// 1. `test_insert`: Inserts a key-value pair into the database, then retrieves///    the value using the same key to verify the insertion./// 2. `test_update`: Inserts a key, then updates the key to a new value and///    verifies that the value has been accurately updated./// 3. `test_others`: A third test that doesn't modify the database state. It///    can run in parallel with the other tests./// In this example, `test_insert` and `test_update` need to run in sequence to/// work, but it doesn't matter which test runs first. We can leverage a/// semaphore with a single permit to address this challenge./// # use tokio::sync::Mutex;/// # use std::collections::BTreeMap;/// # struct Database {/// #   map: Mutex<BTreeMap<String, i32>>,/// # impl Database {/// #    pub const fn setup() -> Database {/// #        Database {/// #            map: Mutex::const_new(BTreeMap::new()),/// #        }/// #    pub async fn insert(&self, key: &str, value: i32) {/// #        self.map.lock().await.insert(key.to_string(), value);/// #    pub async fn update(&self, key: &str, value: i32) {/// #        self.map.lock().await/// #            .entry(key.to_string())/// #            .and_modify(|origin| *origin = value);/// #    pub async fn delete(&self, key: &str) {/// #        self.map.lock().await.remove(key);/// #    pub async fn get(&self, key: &str) -> i32 {/// #        *self.map.lock().await.get(key).unwrap()/// // Initialize a static semaphore with only one permit, which is used to/// // prevent test_insert and test_update from running in parallel./// static PERMIT: Semaphore = Semaphore::const_new(1);/// // Initialize the database that will be used by the subsequent tests./// static DB: Database = Database::setup();/// #[tokio::test]/// # async fn fake_test_insert() {}/// async fn test_insert() {///     // Acquire permit before proceeding. Since the semaphore has only one permit,///     // the test will wait if the permit is already acquired by other tests.///     let permit = PERMIT.acquire().await.unwrap();///     // Do the actual test stuff with database///     // Insert a key-value pair to database///     let (key, value) = ("name", 0);///     DB.insert(key, value).await;///     // Verify that the value has been inserted correctly.///     assert_eq!(DB.get(key).await, value);///     // Undo the insertion, so the database is empty at the end of the test.///     DB.delete(key).await;///     // Drop permit. This allows the other test to start running.///     drop(permit);/// # async fn fake_test_update() {}/// async fn test_update() {///     // Do the same insert.///     // Update the existing value with a new one.///     let new_value = 1;///     DB.update(key, new_value).await;///     // Verify that the value has been updated correctly.///     assert_eq!(DB.get(key).await, new_value);///     // Undo any modificattion./// # async fn fake_test_others() {}/// async fn test_others() {///     // This test can run in parallel with test_insert and test_update,///     // so it does not use PERMIT./// #   test_insert().await;/// #   test_update().await;/// #   test_others().await;/// ## Rate limiting using a token bucket/// This example showcases the [`add_permits`] and [`SemaphorePermit::forget`] methods./// Many applications and systems have constraints on the rate at which certain/// operations should occur. Exceeding this rate can result in suboptimal/// performance or even errors./// This example implements rate limiting using a [token bucket]. A token bucket is a form of rate/// limiting that doesn't kick in immediately, to allow for short bursts of incoming requests that/// arrive at the same time./// With a token bucket, each incoming request consumes a token, and the tokens are refilled at a/// certain rate that defines the rate limit. When a burst of requests arrives, tokens are/// immediately given out until the bucket is empty. Once the bucket is empty, requests will have to/// wait for new tokens to be added./// Unlike the example that limits how many requests can be handled at the same time, we do not add/// tokens back when we finish handling a request. Instead, tokens are added only by a timer task./// Note that this implementation is suboptimal when the duration is small, because it consumes a/// lot of cpu constantly looping and sleeping./// [token bucket]: https://en.wikipedia.org/wiki/Token_bucket/// [`add_permits`]: crate::sync::Semaphore::add_permits/// [`SemaphorePermit::forget`]: crate::sync::SemaphorePermit::forget/// use tokio::time::{interval, Duration};/// struct TokenBucket {///     sem: Arc<Semaphore>,///     jh: tokio::task::JoinHandle<()>,/// impl TokenBucket {///     fn new(duration: Duration, capacity: usize) -> Self {///         let sem = Arc::new(Semaphore::new(capacity));///         // refills the tokens at the end of each interval///         let jh = tokio::spawn({///             let sem = sem.clone();///             let mut interval = interval(duration);///             interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);///             async move {///                     interval.tick().await;///                     if sem.available_permits() < capacity {///                         sem.add_permits(1);///         Self { jh, sem }///     async fn acquire(&self) {///         // This can return an error if the semaphore is closed, but we///         // never close it, so this error can never happen.///         let permit = self.sem.acquire().await.unwrap();///         // To avoid releasing the permit back to the semaphore, we use///         // the `SemaphorePermit::forget` method.///         permit.forget();/// impl Drop for TokenBucket {///         // Kill the background task so it stops taking up resources when we///         // don't need it anymore.///         self.jh.abort();/// # async fn _hidden() {}///     let capacity = 5;///     let update_interval = Duration::from_secs_f32(1.0 / capacity as f32);///     let bucket = TokenBucket::new(update_interval, capacity);///     for _ in 0..5 {///         bucket.acquire().await;///         // do the operation/// [`PollSemaphore`]: https://docs.rs/tokio-util/latest/tokio_util/sync/struct.PollSemaphore.html/// [`Semaphore::acquire_owned`]: crate::sync::Semaphore::acquire_owned/// A permit from the semaphore./// This type is created by the [`acquire`] method./// [`acquire`]: crate::sync::Semaphore::acquire()/// An owned permit from the semaphore./// This type is created by the [`acquire_owned`] method./// [`acquire_owned`]: crate::sync::Semaphore::acquire_owned()/// The maximum number of permits which a semaphore can hold. It is `usize::MAX >> 3`./// Exceeding this limit typically results in a panic./// Panics if `permits` exceeds [`Semaphore::MAX_PERMITS`]./// When using the `tracing` [unstable feature], a `Semaphore` created with/// in [`tokio-console`]. Instead, [`Semaphore::new`] should be used to/// static SEM: Semaphore = Semaphore::const_new(10);/// Adds `n` new permits to the semaphore./// The maximum number of permits is [`Semaphore::MAX_PERMITS`], and this function will panic if the limit is exceeded./// Acquires a permit from the semaphore./// If the semaphore has been closed, this returns an [`AcquireError`]./// Otherwise, this returns a [`SemaphorePermit`] representing the/// acquired permit./// This method uses a queue to fairly distribute permits in the order they/// were requested. Cancelling a call to `acquire` makes you lose your place///     let semaphore = Semaphore::new(2);///     let permit_1 = semaphore.acquire().await.unwrap();///     assert_eq!(semaphore.available_permits(), 1);///     let permit_2 = semaphore.acquire().await.unwrap();///     drop(permit_1);/// [`AcquireError`]: crate::sync::AcquireError/// [`SemaphorePermit`]: crate::sync::SemaphorePermitacquire_many/// Acquires `n` permits from the semaphore./// acquired permits./// were requested. Cancelling a call to `acquire_many` makes you lose your///     let semaphore = Semaphore::new(5);///     let permit = semaphore.acquire_many(3).await.unwrap();///     assert_eq!(semaphore.available_permits(), 2);/// Tries to acquire a permit from the semaphore./// If the semaphore has been closed, this returns a [`TryAcquireError::Closed`]/// and a [`TryAcquireError::NoPermits`] if there are no permits left. Otherwise,/// this returns a [`SemaphorePermit`] representing the acquired permits./// let semaphore = Semaphore::new(2);/// let permit_1 = semaphore.try_acquire().unwrap();/// assert_eq!(semaphore.available_permits(), 1);/// let permit_2 = semaphore.try_acquire().unwrap();/// assert_eq!(semaphore.available_permits(), 0);/// let permit_3 = semaphore.try_acquire();/// assert_eq!(permit_3.err(), Some(TryAcquireError::NoPermits));/// [`TryAcquireError::Closed`]: crate::sync::TryAcquireError::Closed/// [`TryAcquireError::NoPermits`]: crate::sync::TryAcquireError::NoPermitstry_acquire_many/// Tries to acquire `n` permits from the semaphore./// and a [`TryAcquireError::NoPermits`] if there are not enough permits left./// Otherwise, this returns a [`SemaphorePermit`] representing the acquired permits./// let semaphore = Semaphore::new(4);/// let permit_1 = semaphore.try_acquire_many(3).unwrap();/// let permit_2 = semaphore.try_acquire_many(2);/// assert_eq!(permit_2.err(), Some(TryAcquireError::NoPermits));acquire_owned/// The semaphore must be wrapped in an [`Arc`] to call this method./// Otherwise, this returns a [`OwnedSemaphorePermit`] representing the/// were requested. Cancelling a call to `acquire_owned` makes you lose your///     let mut join_handles = Vec::new();///         join_handles.push(tokio::spawn(async move {///             // perform task...///             // explicitly own `permit` in the task///         }));///     for handle in join_handles {///         handle.await.unwrap();/// [`OwnedSemaphorePermit`]: crate::sync::OwnedSemaphorePermitacquire_many_owned/// were requested. Cancelling a call to `acquire_many_owned` makes you lose/// your place in the queue.///         let permit = semaphore.clone().acquire_many_owned(2).await.unwrap();try_acquire_owned/// The semaphore must be wrapped in an [`Arc`] to call this method. If/// the semaphore has been closed, this returns a [`TryAcquireError::Closed`]/// and a [`TryAcquireError::NoPermits`] if there are no permits left./// let semaphore = Arc::new(Semaphore::new(2));/// let permit_1 = Arc::clone(&semaphore).try_acquire_owned().unwrap();/// let permit_2 = Arc::clone(&semaphore).try_acquire_owned().unwrap();/// let permit_3 = semaphore.try_acquire_owned();try_acquire_many_owned/// let semaphore = Arc::new(Semaphore::new(4));/// let permit_1 = Arc::clone(&semaphore).try_acquire_many_owned(3).unwrap();/// let permit_2 = semaphore.try_acquire_many_owned(2);/// Closes the semaphore./// This prevents the semaphore from issuing new permits and notifies all pending waiters./// use tokio::sync::TryAcquireError;///     let semaphore = Arc::new(Semaphore::new(1));///     let semaphore2 = semaphore.clone();///         let permit = semaphore.acquire_many(2).await;///         assert!(permit.is_err());///         println!("waiter received error");///     println!("closing semaphore");///     semaphore2.close();///     // Cannot obtain more permits///     assert_eq!(semaphore2.try_acquire().err(), Some(TryAcquireError::Closed))/// Returns true if the semaphore is closed/// Forgets the permit **without** releasing it back to the semaphore./// This can be used to reduce the amount of permits available from a/// semaphore./// let sem = Arc::new(Semaphore::new(10));///     let permit = sem.try_acquire_many(5).unwrap();///     assert_eq!(sem.available_permits(), 5);///     permit.forget();/// // Since we forgot the permit, available permits won't go back to its initial value/// // even after the permit is dropped./// assert_eq!(sem.available_permits(), 5);/// Merge two [`SemaphorePermit`] instances together, consuming `other`/// without releasing the permits it holds./// Permits held by both `self` and `other` are released when `self` drops./// This function panics if permits from different [`Semaphore`] instances/// are merged./// let mut permit = sem.try_acquire().unwrap();/// for _ in 0..9 {///     let _permit = sem.try_acquire().unwrap();///     // Merge individual permits into a single one.///     permit.merge(_permit)/// assert_eq!(sem.available_permits(), 0);/// // Release all permits in a single batch./// drop(permit);/// assert_eq!(sem.available_permits(), 10);/// Splits `n` permits from `self` and returns a new [`SemaphorePermit`] instance that holds `n` permits./// If there are insufficient permits and it's not possible to reduce by `n`, returns `None`./// let sem = Arc::new(Semaphore::new(3));/// let mut p1 = sem.try_acquire_many(3).unwrap();/// let p2 = p1.split(1).unwrap();/// assert_eq!(p1.num_permits(), 2);/// assert_eq!(p2.num_permits(), 1);/// Returns the number of permits held by `self`.///     let permit = sem.clone().try_acquire_many_owned(5).unwrap();/// Merge two [`OwnedSemaphorePermit`] instances together, consuming `other`/// let mut permit = sem.clone().try_acquire_owned().unwrap();///     let _permit = sem.clone().try_acquire_owned().unwrap();/// Splits `n` permits from `self` and returns a new [`OwnedSemaphorePermit`] instance that holds `n` permits./// It will clone the owned `Arc<Semaphore>` to construct the new instance./// let mut p1 = sem.try_acquire_many_owned(3).unwrap();/// Returns the [`Semaphore`] from which this permit was acquired./// A synchronization primitive for task waking./// `AtomicWaker` will coordinate concurrent wakes with the consumer/// potentially "waking" the underlying task. This is useful in scenarios/// where a computation completes in another thread and wants to wake the/// consumer, but the consumer is in the process of being migrated to a new/// logical task./// Idle state./// The task currently registered with the `AtomicWaker` cell is being woken./// Create an `AtomicWaker`register_by_ref/// Registers the provided waker to be notified on calls to `wake`./// The new waker will take place of any previous wakers that were registered/// wake the `register` caller's task./// task being woken once./// tasks to be woken. One of the callers will win and have its task set,do_register/// Wakes the task that last called `register`.take_waker/// Attempts to take the `Waker` value out of the `AtomicWaker` with the/// intention that the caller will wake the task later./*
    /// Registers the current waker to be notified on calls to `wake`.
    pub(crate) fn register(&self, waker: Waker) {
        self.do_register(waker);
    }
    */// race to take the waker by calling `wake`.// If a new `Waker` instance is produced by calling `register` before an existing// one is consumed, then the existing one is overwritten.// the `Waker` cell. There are two bits that are operated on independently. These// are represented by `REGISTERING` and `WAKING`.// `WAKING` bit is set when a consumer enters the critical section. Neither// bit being set is represented by `WAITING`.// state from `WAITING` to `REGISTERING` or `WAKING`, depending on the// operation the thread wishes to perform. When this transition is made, it is// guaranteed that no other thread will access the waker cell.// If the transition fails, then there was a concurrent call to `wake` that// was unable to access the waker cell (due to the registering thread holding the// attempt to wake by the other thread (that set the `WAKING` bit). The// state is then transitioned from `REGISTERING | WAKING` back to `WAITING`.// This transition must succeed because, at this point, the state cannot be// If the thread is unable to obtain the lock, the `WAKING` bit is still set.// This is because it has either been set by the current thread but the previous// the `register` critical section, it will observe the `WAKING` bit and// handle the waker itself.// If another thread is in the `waker` critical section, then it will handle// waking the caller task.//   task being woken, but it cannot because thread A still holds the wake//   lock.// in the task being woken. The wakers also change the application state// before calling wake.// Because of this, the task will do one of two things.// 1) Observe the application state change that Thread B is waking on. In//    this case, it is OK for Thread B's wake to be lost.//! Thread-safe task notification primitives.AssertSendAssertSyncbasic_usagewake_without_registeratomic_waker_panic_safe// wasm currently doesn't support unwindingbasic_notificationtest_panicky_wakerbroadcast_sendbroadcast_two// An `Arc` is used as the value in order to detect memory leaks.broadcast_wrapdrop_multiple_rx_with_overflowclosing_txclosing_unbounded_txclosing_bounded_rxclosing_and_sendingclosing_unbounded_rxdropping_txdropping_unbounded_txlen_nonzero_after_sendnonempty_after_sendassert_readyWAKE_LIST_SIZE/// `util::wake_list::NUM_WAKERS`notify_waiters_and_onenotify_multinotify_dropnotify_waiters_poll_consistency/// Polls two `Notified` futures and checks if poll results are consistent/// with each other. If the first future is notified by a `notify_waiters`/// call, then the second one must be notified as well.notify_waiters_poll_consistency_many/// Here we also add other `Notified` futures in between to force the two/// tested futures to end up in different chunks.notify_waiters_is_atomic/// Checks if a call to `notify_waiters` is observed as atomic when combined/// with a concurrent call to `notify_one`.notify_waiters_sequential_notified_await/// Checks if a single call to `notify_waiters` does not get through two `Notified`/// futures created and awaited sequentially like this:/// notify.notified().await;changing_rx_tasktry_recv_closeOnClosechanging_tx_taskchecking_tx_send_ok_not_drop// TODO: Move this into `oneshot` proper.concurrent_writeconcurrent_read_writebasic_closingconcurrent_closeconcurrent_cancelrelease_during_acquireconcurrent_permit_updateswait_for_testwait_for_returns_correct_valuemultiple_sender_drop_concurrentlysemaphore_batchnotify_clones_waker_before_locknotify_waiters_handles_panicking_wakernotify_simplewatch_testpoll_acquire_one_availablepoll_acquire_many_availabletry_acquire_one_availabletry_acquire_many_availablepoll_acquire_one_unavailablepoll_acquire_many_unavailabletry_acquire_one_unavailabletry_acquire_many_unavailablepoll_acquire_one_zero_permitsmax_permits_doesnt_panicvalidates_max_permitsclose_semaphore_prevents_acquireclose_semaphore_notifies_permit1close_semaphore_notifies_permit2cancel_acquire_releases_permitsrelease_permits_at_dropforget_permits_basicupdate_permits_many_times/// Pointer to the shared state/// Last observed version/// Receives values from the associated [`Sender`](struct@Sender)./// Instances are created by the [`channel`](fn@channel) function./// To turn this receiver into a `Stream`, you can use the [`WatchStream`]/// [`WatchStream`]: https://docs.rs/tokio-stream/0.1/tokio_stream/wrappers/struct.WatchStream.html/// Sends values to the associated [`Receiver`](struct@Receiver).has_changed/// Outstanding borrows hold a read lock on the inner value. This means that/// long-lived borrows could cause the producer half to block. It is recommended/// to keep the borrow as short-lived as possible. Additionally, if you are/// running in an environment that allows `!Send` futures, you must ensure that/// the returned `Ref` type is never held alive across an `.await` point,/// otherwise, it can lead to a deadlock./// The priority policy of the lock is dependent on the underlying lock/// implementation, and this type does not guarantee that any particular policy/// will be used. In particular, a producer which is waiting to acquire the lock/// in `send` might or might not block concurrent calls to `borrow`, e.g.:/// <details><summary>Potential deadlock example</summary>/// // Task 1 (on thread A)    |  // Task 2 (on thread B)/// let _ref1 = rx.borrow();   |///                            |  // will block///                            |  let _ = tx.send(());/// // may deadlock            |/// let _ref2 = rx.borrow();   |/// </details>/// Indicates if the borrowed value is considered as _changed_ since the last/// time it has been marked as seen./// Unlike [`Receiver::has_changed()`], this method does not fail if the channel is closed./// When borrowed from the [`Sender`] this function will always return `false`./// use tokio::sync::watch;///     let (tx, mut rx) = watch::channel("hello");///     tx.send("goodbye").unwrap();///     // The sender does never consider the value as changed.///     assert!(!tx.borrow().has_changed());///     // Drop the sender immediately, just for testing purposes.///     // Even if the sender has already been dropped...///     assert!(rx.has_changed().is_err());///     // ...the modified value is still readable and detected as changed.///     assert_eq!(*rx.borrow(), "goodbye");///     assert!(rx.borrow().has_changed());///     // Read the changed value and mark it as seen.///         let received = rx.borrow_and_update();///         assert_eq!(*received, "goodbye");///         assert!(received.has_changed());///         // Release the read lock when leaving this scope.///     // Now the value has already been marked as seen and could///     // never be modified again (after the sender has been dropped).///     assert!(!rx.borrow().has_changed());/// The most recent value.AtomicState/// The current version./// The lowest bit represents a "closed" state. The rest of the bits/// represent the current version.ref_count_rx/// Tracks the number of `Receiver` instances.ref_count_tx/// Tracks the number of `Sender` instances.big_notifyBigNotify/// Notifies waiting receivers that the value changed.notify_tx/// Notifies any task listening for `Receiver` dropped events./// Error produced when sending a value fails./// Error produced when receiving a change notification.//! Watch error types.// ===== impl SendError =====/// This function implements the case where randomness is available.// To avoid contention on the lock inside the `Notify`, we store multiple// copies of it. Then, we use either circular access or randomness to spread// out threads over different `Notify` objects.// Some simple benchmarks show that randomness performs slightly better than// circular access (probably due to contention on `next`), so we prefer to// use randomness when Tokio is compiled with a random number generator.// When the random number generator is not available, we fall back to// circular access.CLOSED_BITSTEP_SIZE// Using 2 as the step size preserves the `CLOSED_BIT`./// The version part of the state. The lowest bit is always zero.StateSnapshot/// Snapshot of the state. The first bit is used as the CLOSED bit./// The remaining bits are used as the version./// The CLOSED bit tracks whether the Sender has been dropped. Dropping all/// receivers does not set it./// The state stored in an atomic integer./// The `Sender` uses `Release` ordering for storing a new state/// and the `Receiver`s use `Acquire` ordering for loading the/// current state. This ensures that written values are seen by/// the `Receiver`s for a proper handover./// Decrements the version.INITIAL/// Extract the version from the state./// Is the closed bit set?/// Create a new `AtomicState` that is not closed and which has the/// version set to `Version::INITIAL`./// Load the current value of the state./// Only used by the receiver and for debugging purposes./// The receiver side (read-only) uses `Acquire` ordering for a proper handover/// of the shared value with the sender side (single writer). The state is always/// updated after modifying and before releasing the (exclusive) lock on the/// shared value.increment_version_while_locked/// Increment the version counter./// Set the closed bit in the state./// Creates a new watch channel, returning the "send" and "receive" handles./// All values sent by [`Sender`] will become visible to the [`Receiver`] handles./// Only the last value sent is made available to the [`Receiver`] half. All/// intermediate values are dropped./// The following example prints `hello! world! `./// use tokio::time::{Duration, sleep};/// let (tx, mut rx) = watch::channel("hello");///     // Use the equivalent of a "do-while" loop so the initial value is///     // processed before awaiting the `changed()` future.///         println!("{}! ", *rx.borrow_and_update());///         if rx.changed().await.is_err() {/// sleep(Duration::from_millis(100)).await;/// tx.send("world")?;/// [`Sender`]: struct@Sender/// [`Receiver`]: struct@Receiver/// Returns a reference to the most recently sent value./// This method does not mark the returned value as seen, so future calls to/// [`changed`] may return immediately even if you have already seen the/// value with a call to `borrow`./// For more information on when to use this method versus/// [`borrow_and_update`], see [here](self#borrow_and_update-versus-borrow)./// [`changed`]: Receiver::changed/// [`borrow_and_update`]: Receiver::borrow_and_update/// let (_, rx) = watch::channel("hello");/// assert_eq!(*rx.borrow(), "hello");borrow_and_update/// Returns a reference to the most recently sent value and marks that value/// as seen./// This method marks the current value as seen. Subsequent calls to [`changed`]/// will not return immediately until the [`Sender`] has modified the shared/// value again./// // Task 1 (on thread A)                |  // Task 2 (on thread B)/// let _ref1 = rx1.borrow_and_update();   |///                                        |  // will block///                                        |  let _ = tx.send(());/// // may deadlock                        |/// let _ref2 = rx2.borrow_and_update();   |/// For more information on when to use this method versus [`borrow`], see/// [here](self#borrow_and_update-versus-borrow)./// [`borrow`]: Receiver::borrow/// Checks if this channel contains a message that this receiver has not yet/// seen. The new value is not marked as seen./// Although this method is called `has_changed`, it does not check new/// messages for equality, so this call will return true even if the new/// message is equal to the old message./// Returns an error if the channel has been closed.///     assert!(rx.has_changed().unwrap());///     assert_eq!(*rx.borrow_and_update(), "goodbye");///     // The value has been marked as seen///     assert!(!rx.has_changed().unwrap());///     // The `tx` handle has been droppedmark_changed/// Marks the state as changed./// After invoking this method [`has_changed()`](Self::has_changed)/// returns `true` and [`changed()`](Self::changed) returns/// immediately, regardless of whether a new value has been sent./// This is useful for triggering an initial change notification after/// subscribing to synchronize new receivers.mark_unchanged/// Marks the state as unchanged./// The current value will be considered seen by the receiver./// This is useful if you are not interested in the current value/// visible in the receiver./// Waits for a change notification, then marks the newest value as seen./// If the newest value in the channel has not yet been marked seen when/// this method is called, the method marks that value seen and returns/// immediately. If the newest value has already been marked seen, then the/// method sleeps until a new message is sent by the [`Sender`] connected to/// this `Receiver`, or until the [`Sender`] is dropped./// This method returns an error if and only if the [`Sender`] is dropped./// For more information, see/// [*Change notifications*](self#change-notifications) in the module-level documentation./// completes first, then it is guaranteed that no values have been marked/// seen by this call to `changed`.///         tx.send("goodbye").unwrap();///     assert!(rx.changed().await.is_ok());///     assert!(rx.changed().await.is_err());/// Waits for a value that satisfies the provided condition./// This method will call the provided closure whenever something is sent on/// the channel. Once the closure returns `true`, this method will return a/// reference to the value that was passed to the closure./// Before `wait_for` starts waiting for changes, it will call the closure/// on the current value. If the closure returns `true` when given the/// current value, then `wait_for` will immediately return a reference to/// the current value. This is the case even if the current value is already/// considered seen./// The watch channel only keeps track of the most recent value, so if/// several messages are sent faster than `wait_for` is able to call the/// closure, then it may skip some updates. Whenever the closure is called,/// it will be called with the most recent value./// When this function returns, the value that was passed to the closure/// when it returned `true` will be considered seen./// If the channel is closed, then `wait_for` will return a [`RecvError`]./// Once this happens, no more messages can ever be sent on the channel./// When an error is returned, it is guaranteed that the closure has been/// called on the last value, and that it returned `false` for that value./// (If the closure returned `true`, then the last value would have been/// returned instead of the error.)/// Like the [`borrow`] method, the returned borrow holds a read lock on the/// inner value. This means that long-lived borrows could cause the producer/// half to block. It is recommended to keep the borrow as short-lived as/// possible. See the documentation of `borrow` for more information on/// [`RecvError`]: error::RecvError/// completes first, then it is guaranteed that the last seen value `val`/// (if any) satisfies `f(val) == false`./// If and only if the closure `f` panics. In that case, no resource owned/// or shared by this [`Receiver`] will be poisoned./// #[tokio::main(flavor = "current_thread", start_paused = true)]///     assert!(rx.wait_for(|val| *val == "goodbye").await.is_ok());wait_for_inner/// let (tx, rx) = tokio::sync::watch::channel(true);/// let rx2 = rx.clone();/// assert!(rx.same_channel(&rx2));/// let (tx3, rx3) = tokio::sync::watch::channel(true);/// assert!(!rx3.same_channel(&rx2));try_has_changedmaybe_changedchanged_impl/// Creates the sending-half of the [`watch`] channel./// See documentation of [`watch::channel`] for errors when calling this function./// Beware that attempting to send a value when there are no receivers will/// [`watch`]: crate::sync::watch/// [`watch::channel`]: crate::sync::watch/// let sender = tokio::sync::watch::Sender::new(0u8);/// assert!(sender.send(3).is_err());/// let _rec = sender.subscribe();/// assert!(sender.send(4).is_ok());/// Sends a new value via the channel, notifying all receivers./// This method fails if the channel is closed, which is the case when/// every receiver has been dropped. It is possible to reopen the channel/// using the [`subscribe`] method. However, when `send` fails, the value/// isn't made available for future receivers (but returned with the/// [`SendError`])./// To always make a new value available for future receivers, even if no/// receiver currently exists, one of the other send methods/// ([`send_if_modified`], [`send_modify`], or [`send_replace`]) can be/// [`subscribe`]: Sender::subscribe/// [`SendError`]: error::SendError/// [`send_if_modified`]: Sender::send_if_modified/// [`send_modify`]: Sender::send_modify/// [`send_replace`]: Sender::send_replacesend_modify/// Modifies the watched value **unconditionally** in-place,/// notifying all receivers./// This can be useful for modifying the watched value, without/// having to allocate a new instance. Additionally, this/// method permits sending values even when there are no receivers./// Prefer to use the more versatile function [`Self::send_if_modified()`]/// if the value is only modified conditionally during the mutable borrow/// to prevent unneeded change notifications for unmodified values./// This function panics when the invocation of the `modify` closure panics./// No receivers are notified when panicking. All changes of the watched/// value applied by the closure before panicking will be visible in/// subsequent calls to `borrow`./// struct State {///     counter: usize,/// let (state_tx, state_rx) = watch::channel(State { counter: 0 });/// state_tx.send_modify(|state| state.counter += 1);/// assert_eq!(state_rx.borrow().counter, 1);send_if_modified/// Modifies the watched value **conditionally** in-place,/// notifying all receivers only if modified./// The `modify` closure must return `true` if the value has actually/// been modified during the mutable borrow. It should only return `false`/// if the value is guaranteed to be unmodified despite the mutable/// borrow./// Receivers are only notified if the closure returned `true`. If the/// closure has modified the value but returned `false` this results/// in a *silent modification*, i.e. the modified value will be visible/// in subsequent calls to `borrow`, but receivers will not receive/// a change notification./// Returns the result of the closure, i.e. `true` if the value has/// been modified and `false` otherwise./// let (state_tx, mut state_rx) = watch::channel(State { counter: 1 });/// let inc_counter_if_odd = |state: &mut State| {///     if state.counter % 2 == 1 {///         state.counter += 1;/// assert!(!state_rx.has_changed().unwrap());/// assert!(state_tx.send_if_modified(inc_counter_if_odd));/// assert!(state_rx.has_changed().unwrap());/// assert_eq!(state_rx.borrow_and_update().counter, 2);/// assert!(!state_tx.send_if_modified(inc_counter_if_odd));send_replace/// Sends a new value via the channel, notifying all receivers and returning/// the previous value in the channel./// This can be useful for reusing the buffers inside a watched value./// Additionally, this method permits sending values even when there are no/// receivers./// let (tx, _rx) = watch::channel(1);/// assert_eq!(tx.send_replace(2), 1);/// assert_eq!(tx.send_replace(3), 2);/// Returns a reference to the most recently sent value/// let (tx, _) = watch::channel("hello");/// assert_eq!(*tx.borrow(), "hello");/// Checks if the channel has been closed. This happens when all receivers/// have dropped./// let (tx, rx) = tokio::sync::watch::channel(());/// Completes when all receivers have dropped./// This allows the producer to get notified when interest in the produced/// values is canceled and immediately stop doing work. Once a channel is/// closed, the only way to reopen it is to call [`Sender::subscribe`] to/// get a new receiver./// If the channel becomes closed for a brief amount of time (e.g., the last/// receiver is dropped and then `subscribe` is called), then this call to/// `closed` might return, but it is also possible that it does not "notice"/// that the channel was closed for a brief amount of time./// This method is cancel safe.///     let (tx, rx) = watch::channel("hello");///         // use `rx`///     // Waits for `rx` to drop///     println!("the `rx` handles dropped")/// Creates a new [`Receiver`] connected to this `Sender`./// All messages sent before this call to `subscribe` are initially marked/// as seen by the new `Receiver`./// This method can be called even if there are no other receivers. In this/// case, the channel is reopened./// The new channel will receive messages sent on this `Sender`.///     let (tx, _rx) = watch::channel(0u64);///     tx.send(5).unwrap();///     let rx = tx.subscribe();///     assert_eq!(5, *rx.borrow());///     assert_eq!(10, *rx.borrow());/// The most recent message is considered seen by the channel, so this test/// is guaranteed to pass./// use tokio::time::Duration;///         // by spawning and sleeping, the message is sent after `main`///         // hits the call to `changed`.///         # if false {///         tokio::time::sleep(Duration::from_millis(10)).await;///         # }///         tx.send(100).unwrap();///     rx.changed().await.unwrap();///     assert_eq!(100, *rx.borrow());/// Returns the number of receivers that currently exist.///     let (tx, rx1) = watch::channel("hello");///     let mut _rx2 = rx1.clone();/// Returns the number of senders that currently exist.///     let (tx1, rx) = watch::channel("hello");///     assert_eq!(1, tx1.sender_count());///     assert_eq!(2, tx1.sender_count());///     assert_eq!(2, tx2.sender_count());//! A multi-producer, multi-consumer channel that only retains the *last* sent//! value.//! This channel is useful for watching for changes to a value from multiple//! points in the code base, for example, changes to configuration values.//! [`channel`] returns a [`Sender`] / [`Receiver`] pair. These are the producer//! and consumer halves of the channel. The channel is created with an initial//! Each [`Receiver`] independently tracks the last value *seen* by its caller.//! To access the **current** value stored in the channel and mark it as *seen*//! by a given [`Receiver`], use [`Receiver::borrow_and_update()`].//! To access the current value **without** marking it as *seen*, use//! [`Receiver::borrow()`]. (If the value has already been marked *seen*,//! [`Receiver::borrow()`] is equivalent to [`Receiver::borrow_and_update()`].)//! For more information on when to use these methods, see//! [here](#borrow_and_update-versus-borrow).//! ## Change notifications//! The [`Receiver`] half provides an asynchronous [`changed`] method. This//! method is ready when a new, *unseen* value is sent via the [`Sender`] half.//! * [`Receiver::changed()`] returns `Ok(())` on receiving a new value, or//!   `Err(`[`error::RecvError`]`)` if the [`Sender`] has been dropped.//! * If the current value is *unseen* when calling [`changed`], then//!   [`changed`] will return immediately. If the current value is *seen*, then//!   it will sleep until either a new message is sent via the [`Sender`] half,//!   or the [`Sender`] is dropped.//! * On completion, the [`changed`] method marks the new value as *seen*.//! * At creation, the initial value is considered *seen*. In other words,//!   [`Receiver::changed()`] will not return until a subsequent value is sent.//! * New [`Receiver`] instances can be created with [`Sender::subscribe()`].//!   The current value at the time the [`Receiver`] is created is considered//!   *seen*.//! ## `borrow_and_update` versus `borrow`//! If the receiver intends to await notifications from [`changed`] in a loop,//! [`Receiver::borrow_and_update()`] should be preferred over//! [`Receiver::borrow()`].  This avoids a potential race where a new value is//! sent between [`changed`] being ready and the value being read. (If//! [`Receiver::borrow()`] is used, the loop may run twice with the same value.)//! If the receiver is only interested in the current value, and does not intend//! to wait for changes, then [`Receiver::borrow()`] can be used. It may be more//! convenient to use [`borrow`](Receiver::borrow) since it's an `&self`//! method---[`borrow_and_update`](Receiver::borrow_and_update) requires `&mut//! self`.//! The following example prints `hello! world! `.//! use tokio::time::{Duration, sleep};//! # async fn dox() -> Result<(), Box<dyn std::error::Error>> {//! let (tx, mut rx) = watch::channel("hello");//! tokio::spawn(async move {//!     // Use the equivalent of a "do-while" loop so the initial value is//!     // processed before awaiting the `changed()` future.//!         println!("{}! ", *rx.borrow_and_update());//!         if rx.changed().await.is_err() {//! sleep(Duration::from_millis(100)).await;//! tx.send("world")?;//! # Closing//! [`Sender::is_closed`] and [`Sender::closed`] allow the producer to detect//! when all [`Receiver`] handles have been dropped. This indicates that there//! is no further interest in the values being produced and work can be stopped.//! The value in the channel will not be dropped until the sender and all//! receivers have been dropped.//! # Thread safety//! Both [`Sender`] and [`Receiver`] are thread safe. They can be moved to other//! threads and can be used in a concurrent environment. Clones of [`Receiver`]//! handles may be moved to separate threads and also used concurrently.//! [`Sender`]: crate::sync::watch::Sender//! [`Receiver`]: crate::sync::watch::Receiver//! [`changed`]: crate::sync::watch::Receiver::changed//! [`Receiver::changed()`]: crate::sync::watch::Receiver::changed//! [`Receiver::borrow()`]: crate::sync::watch::Receiver::borrow//! [`Receiver::borrow_and_update()`]://!     crate::sync::watch::Receiver::borrow_and_update//! [`channel`]: crate::sync::watch::channel//! [`Sender::is_closed`]: crate::sync::watch::Sender::is_closed//! [`Sender::closed`]: crate::sync::watch::Sender::closed//! [`Sender::subscribe()`]: crate::sync::watch::Sender::subscribe// ===== impl Ref =====r" Runs the provided blocking function on the current thread without"r" blocking the executor."r" In general, issuing a blocking call or performing a lot of compute in a"r" future without yielding is problematic, as it may prevent the executor"r" from driving other tasks forward. Calling this function informs the"r" executor that the currently executing task is about to block the thread,"r" so the executor is able to hand off any other tasks it has to a new"r" worker thread before that happens. See the [CPU-bound tasks and blocking"r" code][blocking] section for more information."r" Be aware that although this function avoids starving other independently"r" spawned tasks, any other code running concurrently in the same task will"r" be suspended during the call to `block_in_place`. This can happen e.g."r" when using the [`join!`] macro. To avoid this issue, use"r" [`spawn_blocking`] instead of `block_in_place`."r" Note that this function cannot be used within a [`current_thread`] runtime"r" because in this case there are no other worker threads to hand off tasks"r" to. On the other hand, calling the function outside a runtime is"r" allowed. In this case, `block_in_place` just calls the provided closure"r" normally."r" Code running behind `block_in_place` cannot be cancelled. When you shut"r" down the executor, it will wait indefinitely for all blocking operations"r" to finish. You can use [`shutdown_timeout`] to stop waiting for them"r" after a certain timeout. Be aware that this will still not cancel the"r" tasks — they are simply allowed to keep running after the method"r" returns."r" [blocking]: ../index.html#cpu-bound-tasks-and-blocking-code"r" [`spawn_blocking`]: fn@crate::task::spawn_blocking"r" [`thread::spawn`]: fn@std::thread::spawn"r" [`shutdown_timeout`]: fn@crate::runtime::Runtime::shutdown_timeout"r" # async fn docs() {"r" task::block_in_place(move || {"r"     // do some compute-heavy work or call synchronous code"r" Code running inside `block_in_place` may use `block_on` to reenter the"r" async context."r" use tokio::runtime::Handle;"r"     Handle::current().block_on(async move {"r"         // do something async"r" This function panics if called from a [`current_thread`] runtime."r" [`current_thread`]: fn@crate::runtime::Builder::new_current_thread"r" Runs the provided closure on a thread where blocking is acceptable."r" future without yielding is problematic, as it may prevent the executor from"r" driving other futures forward. This function runs the provided closure on a"r" thread dedicated to blocking operations. See the [CPU-bound tasks and"r" blocking code][blocking] section for more information."r" Tokio will spawn more blocking threads when they are requested through this"r" function until the upper limit configured on the [`Builder`] is reached."r" After reaching the upper limit, the tasks are put in a queue."r" The thread limit is very large by default, because `spawn_blocking` is often"r" used for various kinds of IO operations that cannot be performed"r" asynchronously.  When you run CPU-bound code using `spawn_blocking`, you"r" should keep this large upper limit in mind. When running many CPU-bound"r" computations, a semaphore or some other synchronization primitive should be"r" used to limit the number of computation executed in parallel. Specialized"r" CPU-bound executors, such as [rayon], may also be a good fit."r" This function is intended for non-async operations that eventually finish on"r" their own. If you want to spawn an ordinary thread, you should use"r" [`thread::spawn`] instead."r" Be aware that tasks spawned using `spawn_blocking` cannot be aborted"r" because they are not async. If you call [`abort`] on a `spawn_blocking`"r" task, then this *will not have any effect*, and the task will continue"r" running normally. The exception is if the task has not started running"r" yet; in that case, calling `abort` may prevent the task from starting."r" When you shut down the executor, it will wait indefinitely for all blocking operations to"r" finish. You can use [`shutdown_timeout`] to stop waiting for them after a"r" certain timeout. Be aware that this will still not cancel the tasks — they"r" are simply allowed to keep running after the method returns.  It is possible"r" for a blocking task to be cancelled if it has not yet started running, but this"r" is not guaranteed."r" Note that if you are using the single threaded runtime, this function will"r" still spawn additional threads for blocking operations. The current-thread"r" scheduler's single thread is only used for asynchronous code."r" # Related APIs and patterns for bridging asynchronous and blocking code"r" In simple cases, it is sufficient to have the closure accept input"r" parameters at creation time and return a single value (or struct/tuple, etc.)."r" For more complex situations in which it is desirable to stream data to or from"r" the synchronous context, the [`mpsc channel`] has `blocking_send` and"r" `blocking_recv` methods for use in non-async code such as the thread created"r" by `spawn_blocking`."r" Another option is [`SyncIoBridge`] for cases where the synchronous context"r" is operating on byte streams.  For example, you might use an asynchronous"r" HTTP client such as [hyper] to fetch data, but perform complex parsing"r" of the payload body using a library written for synchronous I/O."r" Finally, see also [Bridging with sync code][bridgesync] for discussions"r" around the opposite case of using Tokio as part of a larger synchronous"r" codebase."r" [`Builder`]: struct@crate::runtime::Builder"r" [rayon]: https://docs.rs/rayon"r" [`mpsc channel`]: crate::sync::mpsc"r" [`SyncIoBridge`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.SyncIoBridge.html"r" [hyper]: https://docs.rs/hyper"r" [bridgesync]: https://tokio.rs/tokio/topics/bridging"r" [`AtomicBool`]: struct@std::sync::atomic::AtomicBool"r" [`abort`]: crate::task::JoinHandle::abort"r" Pass an input value and receive result of computation:"r" # async fn docs() -> Result<(), Box<dyn std::error::Error>>{"r" // Initial input"r#" let mut v = "Hello, ".to_string();"#r" let res = task::spawn_blocking(move || {"r"     // Stand-in for compute-heavy work or using synchronous APIs"r#"     v.push_str("world");"#r"     // Pass ownership of the value back to the asynchronous context"r"     v"r" }).await?;"r" // `res` is the value returned from the thread"r#" assert_eq!(res.as_str(), "Hello, world");"#r" Use a channel:"r" use tokio::sync::mpsc;"r" let (tx, mut rx) = mpsc::channel(2);"r" let start = 5;"r" let worker = task::spawn_blocking(move || {"r"     for x in 0..10 {"r"         // Stand in for complex computation"r"         tx.blocking_send(start + x).unwrap();"r" let mut acc = 0;"r" while let Some(v) = rx.recv().await {"r"     acc += v;"r" assert_eq!(acc, 95);"r" worker.await.unwrap();"/// Factory which is used to configure the properties of a new task./// Methods can be chained in order to configure it./// Currently, there is only one configuration option:/// - [`name`], which specifies an associated name for///   the task/// There are three types of task that can be spawned from a Builder:/// - [`spawn_local`] for executing futures on the current thread/// - [`spawn`] for executing [`Send`] futures on the runtime/// - [`spawn_blocking`] for executing blocking code in the///   blocking thread pool./// use tokio::net::{TcpListener, TcpStream};/// async fn process(socket: TcpStream) {/// # drop(socket);///         let (socket, _) = listener.accept().await?;///         tokio::task::Builder::new()///             .name("tcp connection handler")///             .spawn(async move {///                 // Process each socket concurrently.///                 process(socket).await///             })?;/// [`name`]: Builder::name/// [`spawn_local`]: Builder::spawn_local/// [`spawn`]: Builder::spawn/// [`spawn_blocking`]: Builder::spawn_blocking/// Assigns a name to the task which will be spawned./// Spawns a task with this builder's settings on the current runtime./// This method panics if called outside of a Tokio runtime./// See [`task::spawn`](crate::task::spawn()) forspawn_on/// Spawn a task with this builder's settings on the provided [runtime/// handle]./// See [`Handle::spawn`] for more details./// [runtime handle]: crate::runtime::Handle/// [`Handle::spawn`]: crate::runtime::Handle::spawn/// Spawns `!Send` a task on the current [`LocalSet`] with this builder's/// The spawned future will be run on the same thread that called `spawn_local`./// This may only be called from the context of a [local task set][`LocalSet`]./// This function panics if called outside of a [local task set][`LocalSet`]./// See [`task::spawn_local`] for more details./// [`task::spawn_local`]: crate::task::spawn_localspawn_local_on/// Spawns `!Send` a task on the provided [`LocalSet`] with this builder's/// See [`LocalSet::spawn_local`] for more details./// [`LocalSet::spawn_local`]: crate::task::LocalSet::spawn_local/// Spawns blocking code on the blocking threadpool./// See [`task::spawn_blocking`](crate::task::spawn_blocking)spawn_blocking_on/// Spawns blocking code on the provided [runtime handle]'s blocking threadpool./// See [`Handle::spawn_blocking`] for more details./// [`Handle::spawn_blocking`]: crate::runtime::Handle::spawn_blockingconsume_budget/// Consumes a unit of budget and returns the execution back to the Tokio/// runtime *if* the task's coop budget was exhausted./// The task will only yield if its entire coop budget has been exhausted./// This function can be used in order to insert optional yield points into long/// computations that do not use Tokio resources like sockets or semaphores,/// without redundantly yielding to the runtime each time./// Make sure that a function which returns a sum of (potentially lots of)/// iterated values is cooperative./// async fn sum_iterator(input: &mut impl std::iter::Iterator<Item=i64>) -> i64 {///     let mut sum: i64 = 0;///     while let Some(i) = input.next() {///         tokio::task::consume_budget().await///     sumunconstrained/// Opaque type tracking the amount of "work" a task may still do before/// yielding back to the scheduler.hit_zeroBudgetDecrement/// Budget assigned to a task on each poll./// The value itself is chosen somewhat arbitrarily. It needs to be high/// enough to amortize wakeup and scheduling costs, but low enough that we/// do not starve other tasks for too long. The value also needs to be high/// enough that particularly deep tasks are able to do at least some useful/// Note that as more yield points are added in the ecosystem, this value/// will probably also have to be raised./// Returns an unconstrained budget. Operations will not be limited./// Runs the given closure with a cooperative task budget. When the function/// returns, the budget is reset to the value prior to calling the function.with_unconstrained/// Runs the given closure with an unconstrained task budget. When the function returns, the budget/// is reset to the value prior to calling the function.with_budgethas_budget_remaining/// Returns `true` if there is still budget left on the task./// This example defines a `Timeout` future that requires a given `future` to complete before the/// specified duration elapses. If it does, its result is returned; otherwise, an error is returned/// and the future is canceled./// Note that the future could exhaust the budget before we evaluate the timeout. Using `has_budget_remaining`,/// we can detect this scenario and ensure the timeout is always checked./// # use std::pin::{pin, Pin};/// # use std::task::{ready, Context, Poll};/// # use tokio::task::coop;/// # use tokio::time::Sleep;/// pub struct Timeout<T> {///     future: T,///     delay: Pin<Box<Sleep>>,/// impl<T> Future for Timeout<T>///     T: Future + Unpin,///     type Output = Result<T::Output, ()>;///         let this = Pin::into_inner(self);///         let future = Pin::new(&mut this.future);///         let delay = Pin::new(&mut this.delay);///         // check if the future is ready///         let had_budget_before = coop::has_budget_remaining();///         if let Poll::Ready(v) = future.poll(cx) {///             return Poll::Ready(Ok(v));///         let has_budget_now = coop::has_budget_remaining();///         // evaluate the timeout///         if let (true, false) = (had_budget_before, has_budget_now) {///             // it is the underlying future that exhausted the budget///             ready!(pin!(coop::unconstrained(delay)).poll(cx));///             ready!(delay.poll(cx));///         return Poll::Ready(Err(()));r" Sets the current task's budget."r" Forcibly removes the budgeting constraints early."r" Returns the remaining budget"RestoreOnPendingmade_progressr" Returns `Poll::Pending` if the current task has exceeded its budget and should yield."r" When you call this method, the current budget is decremented. However, to ensure that"r" progress is made every time a task is polled, the budget is automatically restored to its"r" former value if the returned `RestoreOnPending` is dropped. It is the caller's"r" responsibility to call `RestoreOnPending::made_progress` if it made progress, to ensure"r" that the budget empties appropriately."r" Note that `RestoreOnPending` restores the budget **as it was before `poll_proceed`**."r" Therefore, if the budget is _further_ adjusted between when `poll_proceed` returns and"r" `RestRestoreOnPending` is dropped, those adjustments are erased unless the caller indicates"r" that progress was made."poll_proceedr" Returns `Poll::Ready` if the current task has budget to consume, and `Poll::Pending` otherwise."r" Note that in contrast to `poll_proceed`, this method does not consume any budget and is used when"r" polling for budget availability."r" Decrements the budget. Returns `true` if successful. Decrementing fails"r" when there is not enough remaining budget."is_unconstrainedr" Future wrapper to ensure cooperative scheduling."r" When being polled `poll_proceed` is called before the inner future is polled to check"r" if the inner future has exceeded its budget. If the inner future resolves, this will"r" automatically call `RestoreOnPending::made_progress` before resolving this future with"r" the result of the inner one. If polling the inner future is pending, polling this future"r" type will also return a `Poll::Pending`."Coopr" Run a future with a budget constraint for cooperative scheduling."r" If the future exceeds its budget while being polled, control is yielded back to the"r" runtime."budgeting//! Utilities for improved cooperative scheduling.//! ### Cooperative scheduling//! A single call to [`poll`] on a top-level task may potentially do a lot of//! work before it returns `Poll::Pending`. If a task runs for a long period of//! time without yielding back to the executor, it can starve other tasks//! waiting on that executor to execute them, or drive underlying resources.//! Since Rust does not have a runtime, it is difficult to forcibly preempt a//! long-running task. Instead, this module provides an opt-in mechanism for//! futures to collaborate with the executor to avoid starvation.//! Consider a future like this one://! # use tokio_stream::{Stream, StreamExt};//! async fn drop_all<I: Stream + Unpin>(mut input: I) {//!     while let Some(_) = input.next().await {}//! It may look harmless, but consider what happens under heavy load if the//! input stream is _always_ ready. If we spawn `drop_all`, the task will never//! yield, and will starve other tasks and resources on the same executor.//! To account for this, Tokio has explicit yield points in a number of library//! functions, which force tasks to return to the executor periodically.//! #### unconstrained//! If necessary, [`task::unconstrained`] lets you opt a future out of Tokio's cooperative//! scheduling. When a future is wrapped with `unconstrained`, it will never be forced to yield to//! Tokio. For example://! # #[tokio::main]//! # async fn main() {//! use tokio::{task, sync::mpsc};//! let fut = async {//!     let (tx, mut rx) = mpsc::unbounded_channel();//!     for i in 0..1000 {//!         let _ = tx.send(());//!         // This will always be ready. If coop was in effect, this code would be forced to yield//!         // periodically. However, if left unconstrained, then this code will never yield.//!         rx.recv().await;//! task::coop::unconstrained(fut).await;//! [`poll`]: method@std::future::Future::poll//! [`task::unconstrained`]: crate::task::unconstrained()// ```ignore// # use tokio_stream::{Stream, StreamExt};// async fn drop_all<I: Stream + Unpin>(mut input: I) {//     while let Some(_) = input.next().await {//         tokio::coop::proceed().await;// The `proceed` future will coordinate with the executor to make sure that// every so often control is yielded back to the executor so it can run other// tasks.// # Placing yield points// Voluntary yield points should be placed _after_ at least some work has been// done. If they are not, a future sufficiently deep in the task hierarchy may// end up _never_ getting to run because of the number of yield points that// inevitably appear before it is reached. In general, you will want yield// points to only appear in "leaf" futures -- those that do not themselves poll// other futures. By doing this, you avoid double-counting each iteration of// the outer future against the cooperating budget.r" Future for the [`unconstrained`](unconstrained) method.""Unconstrained does nothing unless polled"/// Turn off cooperative scheduling for a future. The future will never be forced to yield by/// Tokio. Using this exposes your service to starvation if the unconstrained future never yields/// See also the usage example in the [task module](index.html#unconstrained).IdleNotifiedSet/// A collection of tasks spawned on a Tokio runtime./// A `JoinSet` can be used to await the completion of some or all of the tasks/// in the set. The set is not ordered, and the tasks will be returned in the/// order they complete./// All of the tasks must have the same return type `T`./// When the `JoinSet` is dropped, all tasks in the `JoinSet` are immediately aborted./// Spawn multiple tasks and wait for them./// use tokio::task::JoinSet;///     let mut set = JoinSet::new();///         set.spawn(async move { i });///     let mut seen = [false; 10];///     while let Some(res) = set.join_next().await {///         let idx = res.unwrap();///         seen[idx] = true;///         assert!(seen[i]);/// Create a new `JoinSet`./// Returns the number of tasks currently in the `JoinSet`./// Returns whether the `JoinSet` is empty./// Spawn the provided task on the `JoinSet`, returning an [`AbortHandle`]/// that can be used to remotely cancel the task./// when this method is called, even if you don't await anything on this/// `JoinSet`./// [`AbortHandle`]: crate::task::AbortHandle/// Spawn the provided task on the provided runtime and store it in this/// `JoinSet` returning an [`AbortHandle`] that can be used to remotely/// cancel the task./// Spawn the provided task on the current [`LocalSet`] and store it in this/// `JoinSet`, returning an [`AbortHandle`] that can be used to remotely/// This method panics if it is called outside of a `LocalSet`./// Spawn the provided task on the provided [`LocalSet`] and store it in/// this `JoinSet`, returning an [`AbortHandle`] that can be used to/// remotely cancel the task./// Unlike the [`spawn_local`] method, this method may be used to spawn local/// tasks on a `LocalSet` that is _not_ currently running. The provided/// future will start running whenever the `LocalSet` is next started./// [`spawn_local`]: Self::spawn_local/// Spawn the blocking code on the blocking threadpool and store/// it in this `JoinSet`, returning an [`AbortHandle`] that can be/// used to remotely cancel the task./// Spawn multiple blocking tasks and wait for them.///         set.spawn_blocking(move || { i });/// Spawn the blocking code on the blocking threadpool of the/// provided runtime and store it in this `JoinSet`, returning an/// [`AbortHandle`] that can be used to remotely cancel the task.join_next/// Waits until one of the tasks in the set completes and returns its output./// # Cancel Safety/// This method is cancel safe. If `join_next` is used as the event in a `tokio::select!`/// statement and some other branch completes first, it is guaranteed that no tasks were/// removed from this `JoinSet`.join_next_with_id/// Waits until one of the tasks in the set completes and returns its/// output, along with the [task ID] of the completed task./// When this method returns an error, then the id of the task that failed can be accessed/// using the [`JoinError::id`] method./// This method is cancel safe. If `join_next_with_id` is used as the event in a `tokio::select!`/// [`JoinError::id`]: fn@crate::task::JoinError::idtry_join_next/// Tries to join one of the tasks in the set that has completed and return its output./// Returns `None` if there are no completed tasks, or if the set is empty.try_join_next_with_id/// Tries to join one of the tasks in the set that has completed and return its output,/// along with the [task ID] of the completed task./// Aborts all tasks and waits for them to finish shutting down./// Calling this method is equivalent to calling [`abort_all`] and then calling [`join_next`] in/// a loop until it returns `None`./// This method ignores any panics in the tasks shutting down. When this call returns, the/// `JoinSet` will be empty./// [`abort_all`]: fn@Self::abort_all/// [`join_next`]: fn@Self::join_next/// Awaits the completion of all tasks in this `JoinSet`, returning a vector of their results./// The results will be stored in the order they completed not the order they were spawned./// This is a convenience method that is equivalent to calling [`join_next`] in/// a loop. If any tasks on the `JoinSet` fail with an [`JoinError`], then this call/// to `join_all` will panic and all remaining tasks on the `JoinSet` are/// cancelled. To handle errors in any other way, manually call [`join_next`]/// in a loop./// Spawn multiple tasks and `join_all` them.///     for i in 0..3 {///        set.spawn(async move {///            tokio::time::sleep(Duration::from_secs(3 - i)).await;///            i///     let output = set.join_all().await;///     assert_eq!(output, vec![2, 1, 0]);/// Equivalent implementation of `join_all`, using [`join_next`] and loop.///        set.spawn(async move {i});///     let mut output = Vec::new();///     while let Some(res) = set.join_next().await{///             Ok(t) => output.push(t),///             Err(err) if err.is_panic() => panic::resume_unwind(err.into_panic()),///             Err(err) => panic!("{err}"),///     assert_eq!(output.len(),3);abort_all/// Aborts all tasks on this `JoinSet`./// This does not remove the tasks from the `JoinSet`. To wait for the tasks to complete/// cancellation, you should call `join_next` in a loop until the `JoinSet` is empty.detach_all/// Removes all tasks from this `JoinSet` without aborting them./// The tasks removed by this call will continue to run in the background even if the `JoinSet`/// is dropped.poll_join_next/// Polls for one of the tasks in the set to complete./// If this returns `Poll::Ready(Some(_))`, then the task that completed is removed from the set./// When the method returns `Poll::Pending`, the `Waker` in the provided `Context` is scheduled/// to receive a wakeup when a task in the `JoinSet` completes. Note that on multiple calls to/// `poll_join_next`, only the `Waker` from the `Context` passed to the most recent call is///  * `Poll::Pending` if the `JoinSet` is not empty but there is no task whose output is///     available right now.///  * `Poll::Ready(Some(Ok(value)))` if one of the tasks in this `JoinSet` has completed.///     The `value` is the return value of one of the tasks that completed.///  * `Poll::Ready(Some(Err(err)))` if one of the tasks in this `JoinSet` has panicked or been///     aborted. The `err` is the `JoinError` from the panicked/aborted task.///  * `Poll::Ready(None)` if the `JoinSet` is empty./// Note that this method may return `Poll::Pending` even if one of the tasks has completed./// This can happen if the [coop budget] is reached./// [coop budget]: crate::task::coop#cooperative-schedulingpoll_join_next_with_id///  * `Poll::Ready(Some(Ok((id, value))))` if one of the tasks in this `JoinSet` has completed.///     The `value` is the return value of one of the tasks that completed, and///    `id` is the [task ID] of that task./// Collect an iterator of futures into a [`JoinSet`]./// This is equivalent to calling [`JoinSet::spawn`] on each element of the iterator./// The main example from [`JoinSet`]'s documentation can also be written using [`collect`]:///     let mut set: JoinSet<_> = (0..10).map(|i| async move { i }).collect();/// [`collect`]: std::iter::Iterator::collect//! A collection of tasks spawned on a Tokio runtime.//! This module provides the [`JoinSet`] type, a collection which stores a set//! of spawned tasks and allows asynchronously awaiting the output of those//! tasks as they complete. See the documentation for the [`JoinSet`] type for//! details.// === impl Builder ===RcCellr" A set of tasks which are executed on the same thread."r" In some cases, it is necessary to run one or more futures that do not"r" implement [`Send`] and thus are unsafe to send between threads. In these"r" cases, a [local task set] may be used to schedule one or more `!Send`"r" futures to run together on the same thread."r" For example, the following code will not compile:"r" ```rust,compile_fail"r" use std::rc::Rc;"r"     // `Rc` does not implement `Send`, and thus may not be sent between"r"     // threads safely."r#"     let nonsend_data = Rc::new("my nonsend data...");"#r"     let nonsend_data = nonsend_data.clone();"r"     // Because the `async` block here moves `nonsend_data`, the future is `!Send`."r"     // Since `tokio::spawn` requires the spawned future to implement `Send`, this"r"     // will not compile."r#"         println!("{}", nonsend_data);"#r"         // ..."r"     }).await.unwrap();"r" # Use with `run_until`"r" To spawn `!Send` futures, we can use a local task set to schedule them"r" on the thread calling [`Runtime::block_on`]. When running inside of the"r" local task set, we can use [`task::spawn_local`], which can spawn"r" `!Send` futures. For example:"r"     // Construct a local task set that can run `!Send` futures."r"     let local = task::LocalSet::new();"r"     // Run the local task set."r"     local.run_until(async move {"r"         let nonsend_data = nonsend_data.clone();"r"         // `spawn_local` ensures that the future is spawned on the local"r"         // task set."r"         task::spawn_local(async move {"r#"             println!("{}", nonsend_data);"#r"             // ..."r"         }).await.unwrap();"r"     }).await;"r" **Note:** The `run_until` method can only be used in `#[tokio::main]`,"r" `#[tokio::test]` or directly inside a call to [`Runtime::block_on`]. It"r" cannot be used inside a task spawned with `tokio::spawn`."r" ## Awaiting a `LocalSet`"r" Additionally, a `LocalSet` itself implements `Future`, completing when"r" *all* tasks spawned on the `LocalSet` complete. This can be used to run"r" several futures on a `LocalSet` and drive the whole set until they"r" complete. For example,"r" use tokio::{task, time};"r#"     let nonsend_data = Rc::new("world");"#r"     let nonsend_data2 = nonsend_data.clone();"r"     local.spawn_local(async move {"r#"         println!("hello {}", nonsend_data2)"#r"         time::sleep(time::Duration::from_millis(100)).await;"r#"         println!("goodbye {}", nonsend_data)"#r"     local.await;"r" **Note:** Awaiting a `LocalSet` can only be done inside"r" `#[tokio::main]`, `#[tokio::test]` or directly inside a call to"r" [`Runtime::block_on`]. It cannot be used inside a task spawned with"r" `tokio::spawn`."r" ## Use inside `tokio::spawn`"r" The two methods mentioned above cannot be used inside `tokio::spawn`, so"r" to spawn `!Send` futures from inside `tokio::spawn`, we need to do"r" something else. The solution is to create the `LocalSet` somewhere else,"r" and communicate with it using an [`mpsc`] channel."r" The following example puts the `LocalSet` inside a new thread."r" use tokio::runtime::Builder;"r" use tokio::sync::{mpsc, oneshot};"r" use tokio::task::LocalSet;"r" // This struct describes the task you want to spawn. Here we include"r" // some simple examples. The oneshot channel allows sending a response"r" // to the spawner."r" #[derive(Debug)]"r" enum Task {"r"     PrintNumber(u32),"r"     AddOne(u32, oneshot::Sender<u32>),"r" #[derive(Clone)]"r" struct LocalSpawner {"r"    send: mpsc::UnboundedSender<Task>,"r" impl LocalSpawner {"r"     pub fn new() -> Self {"r"         let (send, mut recv) = mpsc::unbounded_channel();"r"         let rt = Builder::new_current_thread()"r"             .enable_all()"r"             .build()"r"             .unwrap();"r"         std::thread::spawn(move || {"r"             let local = LocalSet::new();"r"             local.spawn_local(async move {"r"                 while let Some(new_task) = recv.recv().await {"r"                     tokio::task::spawn_local(run_task(new_task));"r"                 // If the while loop returns, then all the LocalSpawner"r"                 // objects have been dropped."r"             });"r"             // This will return once all senders are dropped and all"r"             // spawned tasks have returned."r"             rt.block_on(local);"r"         });"r"         Self {"r"             send,"r"     pub fn spawn(&self, task: Task) {"r#"         self.send.send(task).expect("Thread with LocalSet has shut down.");"#r" // This task may do !Send stuff. We use printing a number as an example,"r" // but it could be anything."r" // The Task struct is an enum to support spawning many different kinds"r" // of operations."r" async fn run_task(task: Task) {"r"     match task {"r"         Task::PrintNumber(n) => {"r#"             println!("{}", n);"#r"         Task::AddOne(n, response) => {"r"             // We ignore failures to send the response."r"             let _ = response.send(n + 1);"r"     let spawner = LocalSpawner::new();"r"     let (send, response) = oneshot::channel();"r"     spawner.spawn(Task::AddOne(10, send));"r"     let eleven = response.await.unwrap();"r"     assert_eq!(eleven, 11);"r" [`Send`]: trait@std::marker::Send"r" [local task set]: struct@LocalSet"r" [`Runtime::block_on`]: method@crate::runtime::Runtime::block_on"r" [`task::spawn_local`]: fn@spawn_local"r" [`mpsc`]: mod@crate::sync::mpsc"r" Current scheduler tick."r" State available from thread-local."r" This type should not be Send."/// State shared between threads./// True if a task panicked without being handled and the local set is/// State available from the thread-local.local_stateLocalState/// This field must *only* be accessed from the thread that owns the/// `LocalSet` (i.e., `Thread::current().id() == owner`)./// Remote run queue sender./// Wake the `LocalSet` task./// `LocalSet` state shared between threads./// The `ThreadId` of the thread that owns the `LocalSet`.local_queue/// Local run queue sender and receiver./// Tracks the `LocalSet` state that must only be accessed from the thread that/// created the `LocalSet`.local_setRunUntilLocalDatawake_on_schedule"dropping this guard will reset the entered state"LocalDataEnterGuard/// Should be called except when we call `LocalSet::enter`./// Especially when we poll a `LocalSet`.local_data_ref/// A guard for `LocalData::enter()`r" Spawns a `!Send` future on the current [`LocalSet`] or [`LocalRuntime`]."r" The spawned future will run on the same thread that called `spawn_local`."r" The provided future will start running in the background immediately"r" when `spawn_local` is called, even if you don't await the returned"r" `JoinHandle`."r" This function panics if called outside of a [`LocalSet`]."r" Note that if [`tokio::spawn`] is used from within a `LocalSet`, the"r" resulting new task will _not_ be inside the `LocalSet`, so you must use"r" `spawn_local` if you want to stay within the `LocalSet`."r" [`LocalSet`]: struct@crate::task::LocalSet"r" [`LocalRuntime`]: struct@crate::runtime::LocalRuntime"r" [`tokio::spawn`]: fn@crate::task::spawn"spawn_local_innerMAX_TASKS_PER_TICK/// Max number of tasks to poll per tick.REMOTE_FIRST_INTERVAL/// How often it check the remote queue first./// Distinguishes whether the context was entered or being polled./// When we enter it, the value `wake_on_schedule` is set. In this case/// `spawn_local` refers the context, whereas it is not being polled now.LocalEnterGuard/// Context guard for `LocalSet`/// Returns a new local task set./// Enters the context of this `LocalSet`./// The [`spawn_local`] method will spawn tasks on the `LocalSet` whose/// context you are inside./// [`spawn_local`]: fn@crate::task::spawn_local/// Spawns a `!Send` task onto the local task set./// This task is guaranteed to be run on the current thread./// Unlike the free function [`spawn_local`], this method may be used to/// spawn local tasks when the `LocalSet` is _not_ running. The provided/// future will start running once the `LocalSet` is next started, even if/// you don't await the returned `JoinHandle`.///     let local = task::LocalSet::new();///     // Spawn a future on the local set. This future will be run when///     // we call `run_until` to drive the task set.///     local.spawn_local(async {///     // Run the local task set.///     local.run_until(async move {///     }).await;///     // When `run` finishes, we can spawn _more_ futures, which will///     // run in subsequent calls to `run_until`./// [`spawn_local`]: fn@spawn_local/// Runs a future to completion on the provided runtime, driving any local/// futures spawned on this task set on the current thread./// This runs the given future on the runtime, blocking until it is/// the future spawns internally will be executed on the runtime. The future/// may also call [`spawn_local`] to `spawn_local` additional local futures on the/// This method should not be called from an asynchronous context./// This function panics if the executor is at capacity, if the provided/// future panics, or if called within an asynchronous execution context./// Since this function internally calls [`Runtime::block_on`], and drives/// futures in the local task set inside that call to `block_on`, the local/// futures may not use [in-place blocking]. If a blocking call needs to be/// issued from a local task, the [`spawn_blocking`] API may be used instead./// For example, this will panic:/// let local = task::LocalSet::new();/// local.block_on(&rt, async {///     let join = task::spawn_local(async {///         let blocking_result = task::block_in_place(|| {///     join.await.unwrap();/// This, however, will not panic:///         let blocking_result = task::spawn_blocking(|| {///         }).await;/// [`Runtime::block_on`]: method@crate::runtime::Runtime::block_on/// [in-place blocking]: fn@crate::task::block_in_place/// Runs a future to completion on the local set, returning its output./// This returns a future that runs the given future with a local set,/// allowing it to call [`spawn_local`] to spawn additional `!Send` futures./// Any local futures spawned on the local set will be driven in the/// background until the future passed to `run_until` completes. When the future/// passed to `run_until` finishes, any local futures which have not completed/// will remain on the local set, and will be driven on subsequent calls to/// `run_until` or when [awaiting the local set] itself./// This method is cancel safe when `future` is cancel safe.///     task::LocalSet::new().run_until(async {///         task::spawn_local(async move {///         }).await.unwrap();/// [awaiting the local set]: #awaiting-a-localsetspawn_named_inner/// Ticks the scheduler, returning whether the local future needs to bepop_localwith_if_possible/// This method is like `with`, but it just calls `f` without setting the thread-local if that/// fails./// Schedule the provided task on the scheduler.// This is safe because (and only because) we *pinky pwomise* to never touch the// local run queue except from the thread that owns the `LocalSet`.// localset does not currently support task hookstask_pop_fronttask_push_backtake_local_queuetask_removeowned_is_empty/// Returns true if the `LocalSet` does not have any spawned tasksassert_called_from_owner_thread// This is `Send` because it is stored in `Shared`. It is up to the caller to// ensure they are on the same thread that owns the `LocalSet`.local_current_thread_scheduler// Does a `LocalSet` running on a current-thread runtime...basically work?// This duplicates a test in `tests/task_local_set.rs`, but because this is// a lib test, it will run under Miri, so this is necessary to catch stacked// borrows violations in the `LocalSet` implementation.wakes_to_local_queue// Tests that when a task on a `LocalSet` is woken by an io driver on the// same thread, the task is woken to the localset's local queue rather than// its remote queue.// This test has to be defined in the `local.rs` file as a lib test, rather// than in `tests/`, because it makes assertions about the local set's// internal state.//! Runs `!Send` futures on the current thread.// === impl Context ===// === impl LocalFuture ==="Moved to tokio::task::coop::consume_budget""Moved to tokio::task::coop::unconstrained""Moved to tokio::task::coop::Unconstrained"task_localjoin_setr" Task-related futures."TaskLocalFuture//! Asynchronous green-threads.//! ## What are Tasks?//! A _task_ is a light weight, non-blocking unit of execution. A task is similar//! to an OS thread, but rather than being managed by the OS scheduler, they are//! managed by the [Tokio runtime][rt]. Another name for this general pattern is//! [green threads]. If you are familiar with [Go's goroutines], [Kotlin's//! coroutines], or [Erlang's processes], you can think of Tokio's tasks as//! something similar.//! Key points about tasks include://! * Tasks are **light weight**. Because tasks are scheduled by the Tokio//!   runtime rather than the operating system, creating new tasks or switching//!   between tasks does not require a context switch and has fairly low//!   overhead. Creating, running, and destroying large numbers of tasks is//!   quite cheap, especially compared to OS threads.//! * Tasks are scheduled **cooperatively**. Most operating systems implement//!   _preemptive multitasking_. This is a scheduling technique where the//!   operating system allows each thread to run for a period of time, and then//!   _preempts_ it, temporarily pausing that thread and switching to another.//!   Tasks, on the other hand, implement _cooperative multitasking_. In//!   cooperative multitasking, a task is allowed to run until it _yields_,//!   indicating to the Tokio runtime's scheduler that it cannot currently//!   continue executing. When a task yields, the Tokio runtime switches to//!   executing the next task.//! * Tasks are **non-blocking**. Typically, when an OS thread performs I/O or//!   must synchronize with another thread, it _blocks_, allowing the OS to//!   schedule another thread. When a task cannot continue executing, it must//!   yield instead, allowing the Tokio runtime to schedule another task. Tasks//!   should generally not perform system calls or other operations that could//!   block a thread, as this would prevent other tasks running on the same//!   thread from executing as well. Instead, this module provides APIs for//!   running blocking operations in an asynchronous context.//! [rt]: crate::runtime//! [green threads]: https://en.wikipedia.org/wiki/Green_threads//! [Go's goroutines]: https://tour.golang.org/concurrency/1//! [Kotlin's coroutines]: https://kotlinlang.org/docs/reference/coroutines-overview.html//! [Erlang's processes]: http://erlang.org/doc/getting_started/conc_prog.html#processes//! ## Working with Tasks//! This module provides the following APIs for working with tasks://! ### Spawning//! Perhaps the most important function in this module is [`task::spawn`]. This//! function can be thought of as an async equivalent to the standard library's//! [`thread::spawn`][`std::thread::spawn`]. It takes an `async` block or other//! [future], and creates a new task to run that work concurrently://! use tokio::task;//! # async fn doc() {//! task::spawn(async {//!     // perform some work here...//! Like [`std::thread::spawn`], `task::spawn` returns a [`JoinHandle`] struct.//! A `JoinHandle` is itself a future which may be used to await the output of//! the spawned task. For example://! # #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> {//! let join = task::spawn(async {//!     "hello world!"//! // Await the result of the spawned task.//! let result = join.await?;//! assert_eq!(result, "hello world!");//! Again, like `std::thread`'s [`JoinHandle` type][thread_join], if the spawned//! task panics, awaiting its `JoinHandle` will return a [`JoinError`]. For//! # #[tokio::main] async fn main() {//!     panic!("something bad happened!")//! // The returned result indicates that the task failed.//! assert!(join.await.is_err());//! `spawn`, `JoinHandle`, and `JoinError` are present when the "rt"//! feature flag is enabled.//! [`task::spawn`]: crate::task::spawn()//! [future]: std::future::Future//! [`std::thread::spawn`]: std::thread::spawn//! [thread_join]: std::thread::JoinHandle//! [`JoinError`]: crate::task::JoinError//! #### Cancellation//! Spawned tasks may be cancelled using the [`JoinHandle::abort`] or//! [`AbortHandle::abort`] methods. When one of these methods are called, the//! task is signalled to shut down next time it yields at an `.await` point. If//! the task is already idle, then it will be shut down as soon as possible//! without running again before being shut down. Additionally, shutting down a//! Tokio runtime (e.g. by returning from `#[tokio::main]`) immediately cancels//! all tasks on it.//! When tasks are shut down, it will stop running at whichever `.await` it has//! yielded at. All local variables are destroyed by running their destructor.//! Once shutdown has completed, awaiting the [`JoinHandle`] will fail with a//! [cancelled error](crate::task::JoinError::is_cancelled).//! Note that aborting a task does not guarantee that it fails with a cancelled//! error, since it may complete normally first. For example, if the task does//! not yield to the runtime at any point between the call to `abort` and the//! end of the task, then the [`JoinHandle`] will instead report that the task//! exited normally.//! Be aware that tasks spawned using [`spawn_blocking`] cannot be aborted//! because they are not async. If you call `abort` on a `spawn_blocking`//! task, then this *will not have any effect*, and the task will continue//! running normally. The exception is if the task has not started running//! yet; in that case, calling `abort` may prevent the task from starting.//! Be aware that calls to [`JoinHandle::abort`] just schedule the task for//! cancellation, and will return before the cancellation has completed. To wait//! for cancellation to complete, wait for the task to finish by awaiting the//! [`JoinHandle`]. Similarly, the [`JoinHandle::is_finished`] method does not//! return `true` until the cancellation has finished.//! Calling [`JoinHandle::abort`] multiple times has the same effect as calling//! it once.//! Tokio also provides an [`AbortHandle`], which is like the [`JoinHandle`],//! except that it does not provide a mechanism to wait for the task to finish.//! Each task can only have one [`JoinHandle`], but it can have more than one//! [`AbortHandle`].//! [`JoinHandle::abort`]: crate::task::JoinHandle::abort//! [`AbortHandle::abort`]: crate::task::AbortHandle::abort//! [`AbortHandle`]: crate::task::AbortHandle//! [`JoinHandle::is_finished`]: crate::task::JoinHandle::is_finished//! ### Blocking and Yielding//! As we discussed above, code running in asynchronous tasks should not perform//! operations that can block. A blocking operation performed in a task running//! on a thread that is also running other tasks would block the entire thread,//! preventing other tasks from running.//! Instead, Tokio provides two APIs for running blocking operations in an//! asynchronous context: [`task::spawn_blocking`] and [`task::block_in_place`].//! Be aware that if you call a non-async method from async code, that non-async//! method is still inside the asynchronous context, so you should also avoid//! blocking operations there. This includes destructors of objects destroyed in//! async code.//! #### `spawn_blocking`//! The `task::spawn_blocking` function is similar to the `task::spawn` function//! discussed in the previous section, but rather than spawning an//! _non-blocking_ future on the Tokio runtime, it instead spawns a//! _blocking_ function on a dedicated thread pool for blocking tasks. For//! # async fn docs() {//! task::spawn_blocking(|| {//!     // do some compute-heavy work or call synchronous code//! Just like `task::spawn`, `task::spawn_blocking` returns a `JoinHandle`//! which we can use to await the result of the blocking operation://! # use tokio::task;//! # async fn docs() -> Result<(), Box<dyn std::error::Error>>{//! let join = task::spawn_blocking(|| {//!     "blocking completed"//! assert_eq!(result, "blocking completed");//! #### `block_in_place`//! When using the [multi-threaded runtime][rt-multi-thread], the [`task::block_in_place`]//! function is also available. Like `task::spawn_blocking`, this function//! allows running a blocking operation from an asynchronous context. Unlike//! `spawn_blocking`, however, `block_in_place` works by transitioning the//! _current_ worker thread to a blocking thread, moving other tasks running on//! that thread to another worker thread. This can improve performance by avoiding//! context switches.//! let result = task::block_in_place(|| {//! #### `yield_now`//! In addition, this module provides a [`task::yield_now`] async function//! that is analogous to the standard library's [`thread::yield_now`]. Calling//! and `await`ing this function will cause the current task to yield to the//! Tokio runtime's scheduler, allowing other tasks to be//! scheduled. Eventually, the yielding task will be polled again, allowing it//! to execute. For example://! async {//!     task::spawn(async {//!         println!("spawned task done!")//!     // Yield, allowing the newly-spawned task to execute first.//!     task::yield_now().await;//!     println!("main task done!");//! # .await;//! [`task::spawn_blocking`]: crate::task::spawn_blocking//! [`task::block_in_place`]: crate::task::block_in_place//! [rt-multi-thread]: ../runtime/index.html#threaded-scheduler//! [`task::yield_now`]: crate::task::yield_now()//! [`thread::yield_now`]: std::thread::yield_nowr" Spawns a new asynchronous task, returning a"r" [`JoinHandle`](JoinHandle) for it."r" when `spawn` is called, even if you don't await the returned"r" Spawning a task enables the task to execute concurrently to other tasks. The"r" spawned task may execute on the current thread, or it may be sent to a"r" different thread to be executed. The specifics depend on the current"r" [`Runtime`](crate::runtime::Runtime) configuration."r" It is guaranteed that spawn will not synchronously poll the task being spawned."r" This means that calling spawn while holding a lock does not pose a risk of"r" deadlocking with the spawned task."r" There is no guarantee that a spawned task will execute to completion."r" When a runtime is shutdown, all outstanding tasks are dropped,"r" regardless of the lifecycle of that task."r" This function must be called from the context of a Tokio runtime. Tasks running on"r" the Tokio runtime are always inside its context, but you can also enter the context"r" using the [`Runtime::enter`](crate::runtime::Runtime::enter()) method."r" In this example, a server is started and `spawn` is used to start a new task"r" that processes each received connection."r" use tokio::net::{TcpListener, TcpStream};"r" async fn process(socket: TcpStream) {"r" # drop(socket);"r"         tokio::spawn(async move {"r"             // Process each socket concurrently."r"             process(socket).await"r" To run multiple tasks in parallel and receive their results, join"r" handles can be stored in a vector."r#" # #[tokio::main(flavor = "current_thread")] async fn main() {"#r" async fn my_background_op(id: i32) -> String {"r#"     let s = format!("Starting background task {}.", id);"#r#"     println!("{}", s);"#r"     s"r" let ops = vec![1, 2, 3];"r" let mut tasks = Vec::with_capacity(ops.len());"r" for op in ops {"r"     // This call will make them start running in the background"r"     // immediately."r"     tasks.push(tokio::spawn(my_background_op(op)));"r" let mut outputs = Vec::with_capacity(tasks.len());"r" for task in tasks {"r"     outputs.push(task.await.unwrap());"r#" println!("{:?}", outputs);"#r" This example pushes the tasks to `outputs` in the order they were"r" started in. If you do not care about the ordering of the outputs, then"r" you can also use a [`JoinSet`]."r" [`JoinSet`]: struct@crate::task::JoinSet"r" Panics if called from **outside** of the Tokio runtime."r" # Using `!Send` values from a task"r" The task supplied to `spawn` must implement `Send`. However, it is"r" possible to **use** `!Send` values from the task as long as they only"r" exist between calls to `.await`."r" For example, this will work:"r" fn use_rc(rc: Rc<()>) {"r"     // Do stuff w/ rc"r" # drop(rc);"r"     tokio::spawn(async {"r"         // Force the `Rc` to stay in a scope with no `.await`"r"         {"r"             let rc = Rc::new(());"r"             use_rc(rc.clone());"r"         task::yield_now().await;"r" This will **not** work:"r"         let rc = Rc::new(());"r"         use_rc(rc.clone());"r" Holding on to a `!Send` value across calls to `.await` will result in"r" an unfriendly compile error message similar to:"r" `[... some type ...]` cannot be sent between threads safely"r" or:"r" error[E0391]: cycle detected when processing `main`"// empty (base case for the recursion)/// Declares a new task-local key of type [`tokio::task::LocalKey`]./// The macro wraps any number of static declarations and makes them local to the current task./// Publicity and attributes for each static is preserved. For example:/// # use tokio::task_local;/// task_local! {///     pub static ONE: u32;///     #[allow(unused)]///     static TWO: f32;/// See [`LocalKey` documentation][`tokio::task::LocalKey`] for more/// [`tokio::task::LocalKey`]: struct@crate::task::LocalKey__task_local_inner/// A key for task-local data./// This type is generated by the [`task_local!`] macro./// Unlike [`std::thread::LocalKey`], `tokio::task::LocalKey` will/// _not_ lazily initialize the value on first access. Instead, the/// value is first initialized when the future containing/// the task-local is first polled by a futures executor, like Tokio./// # async fn dox() {/// tokio::task_local! {///     static NUMBER: u32;/// NUMBER.scope(1, async move {///     assert_eq!(NUMBER.get(), 1);/// NUMBER.scope(2, async move {///     assert_eq!(NUMBER.get(), 2);///     NUMBER.scope(3, async move {///         assert_eq!(NUMBER.get(), 3);/// [`std::thread::LocalKey`]: struct@std::thread::LocalKey/// [`task_local!`]: ../macro.task_local.html/// Sets a value `T` as the task-local value for the future `F`./// On completion of `scope`, the task-local will be dropped./// If you poll the returned future inside a call to [`with`] or/// [`try_with`] on the same `LocalKey`, then the call to `poll` will panic.///     println!("task local value: {}", NUMBER.get());/// [`with`]: fn@Self::with/// [`try_with`]: fn@Self::try_withsync_scope/// Sets a value `T` as the task-local value for the closure `F`./// On completion of `sync_scope`, the task-local will be dropped./// This method panics if called inside a call to [`with`] or [`try_with`]/// on the same `LocalKey`./// NUMBER.sync_scope(1, || {scope_innerScopeInnerErr/// Accesses the current task-local and runs the provided closure./// This function will panic if the task local doesn't have a value set.try_with/// If the task-local with the associated key is not present, this/// method will return an `AccessError`. For a panicking variant,/// see `with`./// Returns a copy of the task-local value/// if the task-local value implements `Clone`.r" A future that sets a value `T` of a task local for the future `F` during"r" its execution."r" The value of the task-local must be `'static` and will be dropped on the"r" completion of the future."r" Created by the function [`LocalKey::scope`](self::LocalKey::scope)."r" ### Examples"r" # async fn dox() {"r" tokio::task_local! {"r"     static NUMBER: u32;"r" NUMBER.scope(1, async move {"r#"     println!("task local value: {}", NUMBER.get());"#r" }).await;"/// Returns the value stored in the task local by this `TaskLocalFuture`./// * `Some(T)` if the task local value exists./// * `None` if the task local value has already been taken./// Note that this function attempts to take the task local value even if/// the future has not yet completed. In that case, the value will no longer/// be available via the task local after the call to `take_value`.///     static KEY: u32;/// let fut = KEY.scope(42, async {///     // Do some async work/// let mut pinned = Box::pin(fut);/// // Complete the TaskLocalFuture/// let _ = pinned.as_mut().await;/// // And here, we can take task local value/// let value = pinned.as_mut().take_value();/// assert_eq!(value, Some(42));/// An error returned by [`LocalKey::try_with`](method@LocalKey::try_with)./// Yields execution back to the Tokio runtime./// A task yields by awaiting on `yield_now()`, and may resume when that future/// completes (with no output.) The current task will be re-added as a pending/// task at the _back_ of the pending queue. Any other pending tasks will be/// scheduled. No other waking is required for the task to continue./// See also the usage example in the [task module](index.html#yield_now)./// ## Non-guarantees/// This function may not yield all the way up to the executor if there are any/// special combinators above it in the call stack. For example, if a/// [`tokio::select!`] has another branch complete during the same poll as the/// `yield_now()`, then the yield is not propagated all the way up to the/// It is generally not guaranteed that the runtime behaves like you expect it/// to when deciding which task to schedule next after a call to `yield_now()`./// In particular, the runtime may choose to poll the task that just ran/// `yield_now()` again immediately without polling any other tasks first. For/// example, the runtime will not drive the IO driver between every poll of a/// task, and this could result in the runtime polling the current task again/// immediately even if there is another task that could make progress if that/// other task is waiting for a notification from the IO driver./// In general, changes to the order in which the runtime polls tasks is not/// considered a breaking change, and your program should be correct no matter/// which order the runtime polls your tasks in./// [`tokio::select!`]: macro@crate::select//! Source of time abstraction.//! By default, `std::time::Instant::now()` is used. However, when the//! `test-util` feature flag is enabled, the values returned for `now()` are//! configurable./// Errors encountered by the timer implementation./// Currently, there are two different errors that can occur:/// * `shutdown` occurs when a timer operation is attempted, but the timer///   instance has been dropped. In this case, the operation will never be able///   to complete and the `shutdown` error is returned. This is a permanent///   error, i.e., once this error is observed, timer operations will never///   succeed in the future./// * `at_capacity` occurs when a timer operation is attempted, but the timer///   instance is currently handling its maximum number of outstanding sleep instances.///   In this case, the operation is not able to be performed at the current///   moment, and `at_capacity` is returned. This is a transient error, i.e., at///   some point in the future, if the operation is attempted again, it might///   succeed. Callers that observe this error should attempt to [shed load]. One///   way to do this would be dropping the future that issued the timer operation./// [shed load]: https://en.wikipedia.org/wiki/Load_SheddingAtCapacityElapsed/// Errors returned by `Timeout`./// This error is returned when a timeout expires before the function was able/// to finish./// Creates an error representing a shutdown timer./// Returns `true` if the error was caused by the timer being shutdown.at_capacity/// Creates an error representing a timer at capacity.is_at_capacity/// Returns `true` if the error was caused by the timer being at capacity./// Creates an error representing a misconfigured timer./// Returns `true` if the error was caused by the timer being misconfigured.//! Time error types.// ===== impl Error =====// ===== impl Elapsed =====/// A measurement of a monotonically nondecreasing clock./// Opaque and useful only with `Duration`./// Instants are always guaranteed to be no less than any previously measured/// instant when created, and are often useful for tasks such as measuring/// benchmarks or timing how long an operation takes./// Note, however, that instants are not guaranteed to be **steady**. In other/// words, each tick of the underlying clock may not be the same length (e.g./// some seconds may be longer than others). An instant may jump forwards or/// experience time dilation (slow down or speed up), but it will never go/// backwards./// Instants are opaque types that can only be compared to one another. There is/// no method to get "the number of seconds" from an instant. Instead, it only/// allows measuring the duration between two instants (or comparing two/// instants)./// The size of an `Instant` struct may vary depending on the target operating/// This type wraps the inner `std` variant and is used to align the Tokio/// clock for uses of `now()`. This can be useful for testing where you can/// take advantage of `time::pause()` and `time::advance()`./// Returns an instant corresponding to "now"./// use tokio::time::Instant;/// Create a `tokio::time::Instant` from a `std::time::Instant`.far_future/// Convert the value into a `std::time::Instant`./// Returns the amount of time elapsed from another instant to this one, or/// zero duration if that instant is later than this one./// None if that instant is later than this one./// use tokio::time::{Duration, Instant, sleep};///     let now = Instant::now();///     sleep(Duration::new(1, 0)).await;///     let new_now = Instant::now();///     println!("{:?}", new_now.checked_duration_since(now));///     println!("{:?}", now.checked_duration_since(new_now)); // None///     println!("{:?}", new_now.saturating_duration_since(now));///     println!("{:?}", now.saturating_duration_since(new_now)); // 0ns/// Returns the amount of time elapsed since this instant was created,/// or zero duration if this instant is in the future.///     let instant = Instant::now();///     let three_secs = Duration::from_secs(3);///     sleep(three_secs).await;///     assert!(instant.elapsed() >= three_secs);/// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be/// represented as `Instant` (which means it's inside the bounds of the/// underlying data structure), `None` otherwise./// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be/// Creates new [`Interval`] that yields with interval of `period`. The first/// tick completes immediately. The default [`MissedTickBehavior`] is/// [`Burst`](MissedTickBehavior::Burst), but this can be configured/// by calling [`set_missed_tick_behavior`](Interval::set_missed_tick_behavior)./// An interval will tick indefinitely. At any time, the [`Interval`] value can/// be dropped. This cancels the interval./// This function is equivalent to/// [`interval_at(Instant::now(), period)`](interval_at)./// This function panics if `period` is zero.///     let mut interval = time::interval(Duration::from_millis(10));///     interval.tick().await; // ticks immediately///     interval.tick().await; // ticks after 10ms///     // approximately 20ms have elapsed./// A simple example using `interval` to execute a task every two seconds./// The difference between `interval` and [`sleep`] is that an [`Interval`]/// measures the time since the last tick, which means that [`.tick().await`]/// may wait for a shorter time than the duration specified for the interval/// if some time has passed between calls to [`.tick().await`]./// If the tick in the example below was replaced with [`sleep`], the task/// would only be executed once every three seconds, and not every two/// async fn task_that_takes_a_second() {///     time::sleep(time::Duration::from_secs(1)).await///     let mut interval = time::interval(time::Duration::from_secs(2));///     for _i in 0..5 {///         interval.tick().await;///         task_that_takes_a_second().await;/// [`sleep`]: crate::time::sleep()/// [`.tick().await`]: Interval::tick/// Creates new [`Interval`] that yields with interval of `period` with the/// first tick completing at `start`. The default [`MissedTickBehavior`] is/// use tokio::time::{interval_at, Duration, Instant};///     let start = Instant::now() + Duration::from_millis(50);///     let mut interval = interval_at(start, Duration::from_millis(10));///     interval.tick().await; // ticks after 50ms///     // approximately 70ms have elapsed.internal_interval_atBurst/// Ticks as fast as possible until caught up./// When this strategy is used, [`Interval`] schedules ticks "normally" (the/// same as it would have if the ticks hadn't been delayed), which results/// in it firing ticks as fast as possible until it is caught up in time to/// where it should be. Unlike [`Delay`] and [`Skip`], the ticks yielded/// when `Burst` is used (the [`Instant`]s that [`tick`](Interval::tick)/// yields) aren't different than they would have been if a tick had not/// been missed. Like [`Skip`], and unlike [`Delay`], the ticks may be/// shortened./// This looks something like this:/// Expected ticks: |     1     |     2     |     3     |     4     |     5     |     6     |/// Actual ticks:   | work -----|          delay          | work | work | work -| work -----|/// In code:/// # async fn task_that_takes_200_millis() {}/// let mut interval = interval(Duration::from_millis(50));/// // First tick resolves immediately after creation/// interval.tick().await;/// task_that_takes_200_millis().await;/// // The `Interval` has missed a tick/// // Since we have exceeded our timeout, this will resolve immediately/// // Since we are more than 100ms after the start of `interval`, this will/// // also resolve immediately./// // Also resolves immediately, because it was supposed to resolve at/// // 150ms after the start of `interval`/// // Resolves immediately/// // Since we have gotten to 200ms after the start of `interval`, this/// // will resolve after 50ms/// This is the default behavior when [`Interval`] is created with/// [`interval`] and [`interval_at`]./// [`Delay`]: MissedTickBehavior::Delay/// [`Skip`]: MissedTickBehavior::Skip/// Tick at multiples of `period` from when [`tick`] was called, rather than/// from `start`./// When this strategy is used and [`Interval`] has missed a tick, instead/// of scheduling ticks to fire at multiples of `period` from `start` (the/// time when the first tick was fired), it schedules all future ticks to/// happen at a regular `period` from the point when [`tick`] was called./// Unlike [`Burst`] and [`Skip`], ticks are not shortened, and they aren't/// guaranteed to happen at a multiple of `period` from `start` any longer./// Actual ticks:   | work -----|          delay          | work -----| work -----| work -----|/// use tokio::time::{interval, Duration, MissedTickBehavior};/// # async fn task_that_takes_more_than_50_millis() {}/// interval.set_missed_tick_behavior(MissedTickBehavior::Delay);/// task_that_takes_more_than_50_millis().await;/// // But this one, rather than also resolving immediately, as might happen/// // with the `Burst` or `Skip` behaviors, will not resolve until/// // 50ms after the call to `tick` up above. That is, in `tick`, when we/// // recognize that we missed a tick, we schedule the next tick to happen/// // 50ms (or whatever the `period` is) from right then, not from when/// // were *supposed* to tick/// [`Burst`]: MissedTickBehavior::Burst/// [`tick`]: Interval::tick/// Skips missed ticks and tick on the next multiple of `period` from/// `start`./// When this strategy is used, [`Interval`] schedules the next tick to fire/// at the next-closest tick that is a multiple of `period` away from/// `start` (the point where [`Interval`] first ticked). Like [`Burst`], all/// ticks remain multiples of `period` away from `start`, but unlike/// [`Burst`], the ticks may not be *one* multiple of `period` away from the/// last tick. Like [`Delay`], the ticks are no longer the same as they/// would have been if ticks had not been missed, but unlike [`Delay`], and/// like [`Burst`], the ticks may be shortened to be less than one `period`/// away from each other./// Actual ticks:   | work -----|          delay          | work ---| work -----| work -----|/// # async fn task_that_takes_75_millis() {}/// interval.set_missed_tick_behavior(MissedTickBehavior::Skip);/// task_that_takes_75_millis().await;/// // This one will resolve after 25ms, 100ms after the start of/// // `interval`, which is the closest multiple of `period` from the start/// // of `interval` after the call to `tick` up above./// Defines the behavior of an [`Interval`] when it misses a tick./// Sometimes, an [`Interval`]'s tick is missed. For example, consider the/// # async fn task_that_takes_one_to_three_millis() {}///     // ticks every 2 milliseconds///     let mut interval = time::interval(Duration::from_millis(2));///         // if this takes more than 2 milliseconds, a tick will be delayed///         task_that_takes_one_to_three_millis().await;/// Generally, a tick is missed if too much time is spent without calling/// [`Interval::tick()`]./// By default, when a tick is missed, [`Interval`] fires ticks as quickly as it/// can until it is "caught up" in time to where it should be./// `MissedTickBehavior` can be used to specify a different behavior for/// [`Interval`] to exhibit. Each variant represents a different strategy./// Note that because the executor cannot guarantee exact precision with timers,/// these strategies will only apply when the delay is greater than 5/// If a tick is missed, this method is called to determine when the next tick should happen./// Returns [`MissedTickBehavior::Burst`]./// For most usecases, the [`Burst`] strategy is what is desired./// Additionally, to preserve backwards compatibility, the [`Burst`]/// strategy must be the default. For these reasons,/// [`MissedTickBehavior::Burst`] is the default for [`MissedTickBehavior`]./// See [`Burst`] for more details./// Future that completes the next time the `Interval` yields a value./// The duration between values yielded by `Interval`.missed_tick_behavior/// The strategy `Interval` should use when a tick is missed./// Interval returned by [`interval`] and [`interval_at`]./// This type allows you to wait on a sequence of instants with a certain/// duration between each instant. Unlike calling [`sleep`] in a loop, this lets/// you count the time spent between the calls to [`sleep`] as well./// An `Interval` can be turned into a `Stream` with [`IntervalStream`]./// [`IntervalStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.IntervalStream.html/// Completes when the next instant in the interval has been reached./// This method is cancellation safe. If `tick` is used as the branch in a `tokio::select!` and/// another branch completes first, then no tick has been consumed.///     interval.tick().await;///     // approximately 0ms have elapsed. The first tick completes immediately.poll_tick/// Polls for the next instant in the interval to be reached./// This method can return the following values:///  * `Poll::Pending` if the next instant has not yet been reached.///  * `Poll::Ready(instant)` if the next instant has been reached./// When this method returns `Poll::Pending`, the current task is scheduled/// to receive a wakeup when the instant has elapsed. Note that on multiple/// calls to `poll_tick`, only the [`Waker`](std::task::Waker) from the/// [`Context`] passed to the most recent call is scheduled to receive a/// Resets the interval to complete one period after the current time./// This method ignores [`MissedTickBehavior`] strategy./// This is equivalent to calling `reset_at(Instant::now() + period)`.///     let mut interval = time::interval(Duration::from_millis(100));///     interval.reset();///     // approximately 250ms have elapsed.reset_immediately/// Resets the interval immediately./// This is equivalent to calling `reset_at(Instant::now())`.///     interval.reset_immediately();///     // approximately 150ms have elapsed.reset_after/// Resets the interval after the specified [`std::time::Duration`]./// This is equivalent to calling `reset_at(Instant::now() + after)`.///     let after = Duration::from_millis(20);///     interval.reset_after(after);///     // approximately 170ms have elapsed.reset_at/// Resets the interval to a [`crate::time::Instant`] deadline./// Sets the next tick to expire at the given instant. If the instant is in/// the past, then the [`MissedTickBehavior`] strategy will be used to/// catch up. If the instant is in the future, then the next tick will/// complete at the given instant, even if that means that it will sleep for/// longer than the duration of this [`Interval`]. If the [`Interval`] had/// any missed ticks before calling this method, then those are discarded./// use tokio::time::{self, Instant};///     let deadline = Instant::now() + Duration::from_millis(30);///     interval.reset_at(deadline);///     // approximately 180ms have elapsed./// Returns the [`MissedTickBehavior`] strategy currently being used.set_missed_tick_behavior/// Sets the [`MissedTickBehavior`] strategy that should be used./// Returns the period of the interval.timeout_at// Re-export for convenience//! Utilities for tracking time.//! This module provides a number of types for executing code after a set period//! of time.//! * [`Sleep`] is a future that does no work and completes at a specific [`Instant`]//!   in time.//! * [`Interval`] is a stream yielding a value at a fixed period. It is//!   initialized with a [`Duration`] and repeatedly yields each time the duration//!   elapses.//! * [`Timeout`]: Wraps a future or stream, setting an upper bound to the amount//!   of time it is allowed to execute. If the future or stream does not//!   complete in time, then it is canceled and an error is returned.//! These types are sufficient for handling a large number of scenarios//! involving time.//! These types must be used from within the context of the [`Runtime`](crate::runtime::Runtime).//! Wait 100ms and print "100 ms have elapsed"//! use tokio::time::sleep;//!     sleep(Duration::from_millis(100)).await;//!     println!("100 ms have elapsed");//! Require that an operation takes no more than 1s.//! use tokio::time::{timeout, Duration};//! async fn long_future() {//!     // do work here//! # async fn dox() {//! let res = timeout(Duration::from_secs(1), long_future()).await;//! if res.is_err() {//!     println!("operation timed out");//! A simple example using [`interval`] to execute a task every two seconds.//! The difference between [`interval`] and [`sleep`] is that an [`interval`]//! measures the time since the last tick, which means that `.tick().await` may//! wait for a shorter time than the duration specified for the interval//! if some time has passed between calls to `.tick().await`.//! If the tick in the example below was replaced with [`sleep`], the task//! would only be executed once every three seconds, and not every two//! seconds.//! use tokio::time;//! async fn task_that_takes_a_second() {//!     println!("hello");//!     time::sleep(time::Duration::from_secs(1)).await//!     let mut interval = time::interval(time::Duration::from_secs(2));//!     for _i in 0..5 {//!         interval.tick().await;//!         task_that_takes_a_second().await;//! [`interval`]: crate::time::interval()//! [`sleep`]: sleep()/// Waits until `deadline` is reached./// No work is performed while awaiting on the sleep future to complete. `Sleep`/// operates at millisecond granularity and should not be used for tasks that/// require high-resolution timers./// To run something regularly on a schedule, see [`interval`]./// Canceling a sleep instance is done by dropping the returned future. No additional/// cleanup work is required./// Wait 100ms and print "100 ms have elapsed"./// use tokio::time::{sleep_until, Instant, Duration};///     sleep_until(Instant::now() + Duration::from_millis(100)).await;///     println!("100 ms have elapsed");/// See the documentation for the [`Sleep`] type for more examples./// This function panics if there is no current timer set./// It can be triggered when [`Builder::enable_time`] or/// [`Builder::enable_all`] are not included in the builder./// It can also panic whenever a timer is created outside of a/// Tokio runtime. That is why `rt.block_on(sleep(...))` will panic,/// since the function is executed outside of the runtime./// Whereas `rt.block_on(async {sleep(...).await})` doesn't panic./// And this is because wrapping the function on an async makes it lazy,/// and so gets executed inside the runtime successfully without/// panicking./// [`interval`]: crate::time::interval()/// [`Builder::enable_time`]: crate::runtime::Builder::enable_time/// [`Builder::enable_all`]: crate::runtime::Builder::enable_all/// Waits until `duration` has elapsed./// Equivalent to `sleep_until(Instant::now() + duration)`. An asynchronous/// analog to `std::thread::sleep`./// require high-resolution timers. The implementation is platform specific,/// and some platforms (specifically Windows) will provide timers with a/// larger resolution than 1 ms./// The maximum duration for a sleep is 68719476734 milliseconds (approximately 2.2 years).///     sleep(Duration::from_millis(100)).await;r" Future returned by [`sleep`](sleep) and [`sleep_until`](sleep_until)."r" This type does not implement the `Unpin` trait, which means that if you"r" use it with [`select!`] or by calling `poll`, you have to pin it first."r" If you use it with `.await`, this does not apply."r#" Wait 100ms and print "100 ms have elapsed"."#r" use tokio::time::{sleep, Duration};"r"     sleep(Duration::from_millis(100)).await;"r#"     println!("100 ms have elapsed");"#r" Use with [`select!`]. Pinning the `Sleep` with [`tokio::pin!`] is"r" necessary when the same `Sleep` is selected on multiple times."r" use tokio::time::{self, Duration, Instant};"r"     let sleep = time::sleep(Duration::from_millis(10));"r"             () = &mut sleep => {"r#"                 println!("timer elapsed");"#r"                 sleep.as_mut().reset(Instant::now() + Duration::from_millis(50));"r" Use in a struct with boxing. By pinning the `Sleep` with a `Box`, the"r" `HasSleep` struct implements `Unpin`, even though `Sleep` does not."r" use std::future::Future;"r" use std::pin::Pin;"r" use std::task::{Context, Poll};"r" use tokio::time::Sleep;"r" struct HasSleep {"r"     sleep: Pin<Box<Sleep>>,"r" impl Future for HasSleep {"r"     type Output = ();"r"     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {"r"         self.sleep.as_mut().poll(cx)"r" Use in a struct with pin projection. This method avoids the `Box`, but"r" the `HasSleep` struct will not be `Unpin` as a consequence."r" use pin_project_lite::pin_project;"r" pin_project! {"r"     struct HasSleep {"r"         #[pin]"r"         sleep: Sleep,"r"     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {"r"         self.project().sleep.poll(cx)"r" [`select!`]: ../macro.select.html"r" [`tokio::pin!`]: ../macro.pin.html"new_timeout/// Returns the instant at which the future will complete./// Returns `true` if `Sleep` has elapsed./// A `Sleep` instance is elapsed when the requested duration has elapsed./// Resets the `Sleep` instance to a new deadline./// Calling this function allows changing the instant at which the `Sleep`/// future completes without having to create new associated state./// This function can be called both before and after the future has/// To call this method, you will usually combine the call with/// [`Pin::as_mut`], which lets you call the method without consuming the/// `Sleep` itself./// use tokio::time::{Duration, Instant};/// let sleep = tokio::time::sleep(Duration::from_millis(10));/// tokio::pin!(sleep);/// sleep.as_mut().reset(Instant::now() + Duration::from_millis(20));/// See also the top-level examples./// [`Pin::as_mut`]: fn@std::pin::Pin::as_mutreset_without_reregister/// Resets the `Sleep` instance to a new deadline without reregistering it/// to be woken up./// future completes without having to create new associated state and/// without having it registered. This is required in e.g. the/// [`crate::time::Interval`] where we want to reset the internal [Sleep]/// without having it wake up the last task that polled it.reset_inner// `poll_elapsed` can return an error in two cases:// - AtCapacity: this is a pathological case where far too many//   sleep instances have been scheduled.// - Shutdown: No timer has been setup, which is a mis-use error.// Both cases are extremely rare, and pretty accurately fit into// "logic errors", so we just panic in this case. A user couldn't// really do much better if we passed the error onwards./// Requires a `Future` to complete before the specified duration has elapsed./// If the future completes before the duration has elapsed, then the completed/// value is returned. Otherwise, an error is returned and the future is/// canceled./// Note that the timeout is checked before polling the future, so if the future/// does not yield during execution then it is possible for the future to complete/// and exceed the timeout _without_ returning an error./// This function returns a future whose return type is [`Result`]`<T,`[`Elapsed`]`>`, where `T` is the/// return type of the provided future./// If the provided future completes immediately, then the future returned from/// this function is guaranteed to complete immediately with an [`Ok`] variant/// no matter the provided duration./// [`Ok`]: std::result::Result::Ok/// [`Elapsed`]: crate::time::error::Elapsed/// Cancelling a timeout is done by dropping the future. No additional cleanup/// or other work is required./// The original future may be obtained by calling [`Timeout::into_inner`]. This/// consumes the `Timeout`./// Create a new `Timeout` set to expire in 10 milliseconds./// use tokio::time::timeout;/// let (tx, rx) = oneshot::channel();/// # tx.send(()).unwrap();/// // Wrap the future with a `Timeout` set to expire in 10 milliseconds./// if let Err(_) = timeout(Duration::from_millis(10), rx).await {///     println!("did not receive value within 10 ms");/// Requires a `Future` to complete before the specified instant in time./// If the future completes before the instant is reached, then the completed/// value is returned. Otherwise, an error is returned./// no matter the provided deadline./// use tokio::time::{Instant, timeout_at};/// // Wrap the future with a `Timeout` set to expire 10 milliseconds into the/// // future./// if let Err(_) = timeout_at(Instant::now() + Duration::from_millis(10), rx).await {r" Future returned by [`timeout`](timeout) and [`timeout_at`](timeout_at)."new_with_delay/// Gets a reference to the underlying value in this timeout./// Gets a mutable reference to the underlying value in this timeout./// Consumes this timeout, returning the underlying value.//! Allows a future to execute for a maximum amount of time.//! See [`Timeout`] documentation for more details.//! [`Timeout`]: struct@Timeoutto_rawleast_significant/// Value is packed in the `width` least-significant bits./// Value is packed in the `width` more-significant bits./// Width, in bits, dedicated to storing the value./// Max representable value.mask_for/// Returns a `usize` with the right-most `n` bits set./// Unpacks a value using a mask & shift.// arm, mips and mips64 have 32-byte cache line size.// x86, riscv and wasm have 64-byte cache line size./// Error string explaining that the Tokio context hasn't been instantiated./// Error string explaining that the Tokio context is shutting down and cannot drive timers./// Error string explaining that the Tokio context is not available because the/// thread-local storing it has been destroyed. This usually only happens during/// destructors of other thread-locals.// Some combinations of features may not use these constants.ListEntryLists/// This is the main handle to the collection.EntryInOneOfTheLists/// A handle to an entry that is guaranteed to be stored in the idle or notified/// list of its `IdleNotifiedSet`. This value borrows the `IdleNotifiedSet`/// mutably to prevent the entry from being moved to the `Neither` list, which/// only the `IdleNotifiedSet` may do./// The main consequence of being stored in one of the lists is that the `value`/// field has not yet been consumed./// Note: This entry can be moved from the idle to the notified list while this/// object exists by waking its waker.ListsInner/// Whenever an element in the `notified` list is woken, this waker will be/// notified and consumed, if it exists./// The linked lists hold strong references to the `ListEntry` items, and the/// `ListEntry` items also hold a strong reference back to the Lists object, but/// the destructor of the `IdleNotifiedSet` will clear the two lists, so once/// that object is destroyed, no ref-cycles will remain./// Which of the two lists in the shared Lists object is this entry stored in?/// If the value is `Idle`, then an entry's waker may move it to the notified/// list. Otherwise, only the `IdleNotifiedSet` may move it./// If the value is `Neither`, then it is still possible that the entry is in/// some third external list (this happens in `drain`)./// The linked list pointers of the list this entry is in./// Pointer to the shared `Lists` struct./// The value stored in this entry.my_list/// Used to remember which list this entry is in./// Required by the `linked_list::Pointers` field./// An entry in the list./// The `my_list` field must only be accessed while holding the mutex in/// `parent`. It is an invariant that the value of `my_list` corresponds to/// which linked list in the `parent` holds this entry. Once this field takes/// the value `Neither`, then it may never be modified again./// If the value of `my_list` is `Notified` or `Idle`, then the `pointers` field/// must only be accessed while holding the mutex. If the value of `my_list` is/// `Neither`, then the `pointers` field may be accessed by the/// `IdleNotifiedSet` (this happens inside `drain`)./// The `value` field is owned by the `IdleNotifiedSet` and may only be accessed/// by the `IdleNotifiedSet`. The operation that sets the value of `my_list` to/// `Neither` assumes ownership of the `value`, and it must either drop it or/// move it out from this entry to prevent it from getting leaked. (Since the/// two linked lists are emptied in the destructor of `IdleNotifiedSet`, the/// value should not be leaked.)// With mutable access to the `IdleNotifiedSet`, you can get mutable access to// the values.// With the current API we strictly speaking don't even need `T: Sync`, but we// require it anyway to support adding &self APIs that access the values in the// future.// These impls control when it is safe to create a Waker. Since the waker does// not allow access to the value in any way (including its destructor), it is// not necessary for `T` to be Send or Sync./// Create a new `IdleNotifiedSet`./// Insert the given value into the `idle` list.pop_notified/// Pop an entry from the notified list to poll it. The entry is moved to/// the idle list atomically.try_pop_notified/// Tries to pop an entry from the notified list to poll it. The entry is moved to/// Call a function on every element in this list./// Remove all entries in both lists, applying some function to each element./// The closure is called on all elements even if it panics. Having it panic/// twice is a double-panic, and will abort the application.move_to_new_list/// The mutex for the entries must be held, and the target list must be such/// that setting `my_list` to `Neither` is ok./// Remove this entry from the list it is in, returning the value associated/// with the entry./// This consumes the value, since it is no longer guaranteed to be in awith_value_and_context/// Access the value in this entry together with a context for its waker./// `ListEntry` is forced to be !Unpin.join_set_test// A test that runs under miri.// https://github.com/tokio-rs/tokio/pull/5693//! This module defines an `IdleNotifiedSet`, which is a collection of elements.//! Each element is intended to correspond to a task, and the collection will//! keep track of which tasks have had their waker notified, and which have not.//! Each entry in the set holds some user-specified value. The value's type is//! specified using the `T` parameter. It will usually be a `JoinHandle` or//! similar./// Linked list head/// Linked list tail/// Node type marker./// An intrusive linked list./// Currently, the list is not emptied on drop. It is the caller's/// responsibility to ensure the list is empty before dropping it./// Handle to the list entry./// This is usually a pointer-ish type./// Node type./// Convert the handle to a raw pointer without consuming the handle./// Convert the raw pointer to a handle/// Return the pointers for a node/// The resulting pointer should have the same tag in the stacked-borrows/// stack as the argument. In particular, the method may not create an/// intermediate reference in the process of creating the resulting raw/// Defines how a type is tracked within a linked list./// In order to support storing a single type within multiple lists, accessing/// the list pointers is decoupled from the entry type./// Implementations must guarantee that `Target` types are pinned in memory. In/// other words, when a node is inserted, the value will not be moved as long as/// it is stored in the list.PointersInner/// Previous / next pointers./// The previous node in the list. null if there is no previous node./// The next node in the list. null if there is no previous node./// This type is !Unpin due to the heuristic from:/// <https://github.com/rust-lang/rust/pull/82834>/// We do not want the compiler to put the `noalias` attribute on mutable/// references to this type, so the type has been made `!Unpin` with a/// `PhantomPinned` field./// Additionally, we never access the `prev` or `next` fields directly, as any/// such access would implicitly involve the creation of a reference to the/// field, which we want to avoid since the fields are not `!Unpin`, and would/// hence be given the `noalias` attribute if we were to do such an access. As/// an alternative to accessing the fields directly, the `Pointers` type/// provides getters and setters for the two fields, and those are implemented/// using `ptr`-specific methods which avoids the creation of intermediate/// See this link for more information:/// Creates an empty linked list./// Adds an element first in the list./// Removes the first element from a list and returns it, or None if it is/// Removes the last element from a list and returns it, or None if it is/// Returns whether the linked list does not contain any node/// Removes the specified node from the list/// The caller **must** ensure that exactly one of the following is true:/// - `node` is currently contained by `self`,/// - `node` is not contained by any list,/// - `node` is currently contained by some other `GuardedLinkedList` **and**///   the caller has an exclusive access to that list. This condition is///   used by the linked list in `sync::Notify`.r" An intrusive linked list, but instead of keeping pointers to the head"r" and tail nodes, it uses a special guard node linked with those nodes."r" It means that the list is circular and every pointer of a node from"r" the list is not `None`, including pointers from the guard node."r" If a list is empty, then both pointers of the guard node are pointing"r" at the guard node itself."r" Pointer to the guard node."r" Node type marker."r" Turns a linked list into the guarded version by linking the guard node"r" with the head and tail nodes. Like with other nodes, you should guarantee"r" that the guard node is pinned in memory."into_guardedr" Removes the last element from a list and returns it, or None if it is"/// Create a new set of empty pointersget_prevset_prevcollect_listpush_allassert_cleanassert_ptr_eqpush_and_drainpush_pop_push_popremove_by_address//! An intrusive double linked list of data.//! The data structure supports tracking pinned nodes. Most of the data//! structure's APIs are `unsafe` as they require the caller to ensure the//! specified node is actually contained by the list.// ===== impl LinkedList =====// ===== impl DrainFilter =====// ===== impl GuardedLinkedList =====// ===== impl Pointers =====/// Marker for types that are `Sync` but not `Send`memchr_testmemchr_allmemchr_empty//! Search for a byte in a byte array using libc.//! When nothing pulls in libc, then just use a trivial implementation. Note//! that we only depend on libc on unix./// `AtomicU64` that is is a no-op on platforms without 64-bit atomics/// When used on platforms without 64-bit atomics, writes to this are no-ops./// The `load` method is only defined when 64-bit atomics are available.// Load is only defined when supported// some of these are currently only used behind cfg_unstable/// `AtomicUsize` for use in metrics./// This exposes simplified APIs for use in metrics & uses `std::sync` instead of Loom to avoid polluting loom logs with metric information.blocking_checkwake_listidle_notified_setrc_cell/// Get the value inside this cell, initializing it using the provided/// function if necessary./// If the `init` closure panics, then the `OnceCell` is poisoned and all/// future calls to `get` will panic.do_init// SAFETY: Actually using the pointers is unsafe, so it's sound to transfer them across threads.expose_provenancefrom_exposed_addr// mirrors std nameunexpose_provenance//! Utility for helping miri understand our exposed pointers.//! During normal execution, this module is equivalent to pointer casts. However, when running//! under miri, pointer casts are replaced with lookups in a hash map. This makes Tokio compatible//! with strict provenance when running under miri (which comes with a performance cost)./// Internal state for the seed generator. We keep it in a Mutex so that we can safely/// use it across multiple threads./// A deterministic generator for seeds (and other generators)./// Given the same initial seed, the generator will output the same sequence of seeds./// Since the seed generator will be kept in a runtime handle, we need to wrap `FastRand`/// in a Mutex to make it thread safe. Different to the `FastRand` that we keep in a/// thread local store, the expectation is that seed generation will not need to happen/// very frequently, so the cost of the mutex should be minimal./// Returns a new generator from the provided seed.next_seed/// Returns the next seed in the sequence.next_generator/// Directly creates a generator using the next seed.replace_seed/// Replaces the state of the random number generator with the provided seed, returning/// the seed that represents the previous state of the random number generator./// The random number generator will become equivalent to one created with/// the same seed./// Generates a seed from the provided byte slice./// # use tokio::runtime::RngSeed;/// let seed = RngSeed::from_bytes(b"make me a seed");/// A seed for random number generation./// In order to make certain functions within a runtime deterministic, a seed/// can be specified at the time of creation./// Fast random number generate./// Implement `xorshift64+`: 2 32-bit `xorshift` sequences added together./// Shift triplet `[17,7,16]` was calculated as indicated in Marsaglia's/// `Xorshift` paper: <https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf>/// This generator passes the SmallCrush suite, part of TestU01 framework:/// <http://simul.iro.umontreal.ca/testu01/tu01.html>/// Creates a random seed using loom internally.from_pair/// Initialize a new fast random number generator using the default source of entropy./// Initializes a new, thread-local, fast random number generator.fastrand_n/// This is exactly like `Cell<Option<Rc<T>>>`, except that it provides a `get`/// method even though `Rc` is not `Copy`./// Safety: This method may not be called recursively.shard_mask/// An intrusive linked list supporting highly concurrent updates./// It currently relies on `LinkedList`, so it is the caller's/// Note: Due to its inner sharded design, the order of nodes cannot be guaranteed./// The provided pointer must point at a valid list item./// Determines which linked list an item should be stored in./// Implementations must guarantee that the id of an item does not change from/// call to call./// Creates a new and empty sharded linked list with the specified size.ShardGuard/// Used to get the lock of shard./// Removes the last element from a list specified by `shard_id` and returns it, or None if it is/// Removes the specified node from the list./// - `node` is currently contained by some other `GuardedLinkedList`.lock_shard/// Gets the lock of `ShardedList`, makes us have the write permission./// Gets the count of elements in this list.r" Gets the total number of elements added to this list."/// Returns whether the linked list does not contain any node.shard_size/// Gets the shard size of this `SharedList`./// Used to help us to decide the parameter `shard_id` of the `pop_back` method.shard_inner/// Push a value to this shard.// safety: The SyncWrapper being send allows you to send the inner value across// thread boundaries.// safety: An immutable reference to a SyncWrapper is useless, so moving such an// immutable reference across threads is safe.downcast_ref_sync/// Attempt to downcast using `Any::downcast_ref()` to a type that is known to be `Sync`.//! This module contains a type that can make `Send + !Sync` types `Sync` by//! disallowing all immutable access to the value.//! A similar primitive is provided in the `sync_wrapper` crate.r" Create a new unnamed spawn meta with the original size (before possible auto-boxing)"caller_location/// Create a new `TryLock`/// Attempt to acquire lock/// Wake by value./// Wake by reference./// Simplified waking interface based on Arcs./// A `Waker` that is only valid for a given lifetime./// Creates a reference to a `Waker` from a reference to `Arc<impl Wake>`.NUM_WAKERS/// A list of wakers to be woken./// The first `curr` elements of `inner` are initialized.// syn::AttributeArgs does not implement syn::ParseThreadedUnhandledPanicShutdownRuntimeFinalConfigDEFAULT_ERROR_CONFIG/// Config used in case of the attribute not being able to build a valid configrt_multi_thread_availabledefault_flavorset_flavorset_worker_threadsset_start_pausedset_crate_nameset_unhandled_panicmacro_nameparse_intparse_pathbuild_configparse_knobstoken_stream_with_erroris_test_attribute// Check whether given attribute is a test attribute of forms:// * `#[test]`// * `#[core::prelude::*::test]` or `#[::core::prelude::*::test]`// * `#[std::prelude::*::test]` or `#[::std::prelude::*::test]`/// Access all attributes of the function item./// Get the body of the function item in a manner so that it can be/// conveniently used with the `quote!` macro./// Convert our local function item into a token stream.// Statements, with terminating `;`.// This `extern` is required for older `rustc` versions but newer `rustc`// versions warn about the unused `extern crate`./// Marks async function to be executed by the selected runtime. This macro/// helps set up a `Runtime` without requiring the user to use/// [Runtime](../tokio/runtime/struct.Runtime.html) or/// [Builder](../tokio/runtime/struct.Builder.html) directly./// Note: This macro is designed to be simplistic and targets applications that/// do not require a complex setup. If the provided functionality is not/// sufficient, you may be interested in using/// [Builder](../tokio/runtime/struct.Builder.html), which provides a more/// powerful interface./// Note: This macro can be used on any function and not just the `main`/// function. Using it on a non-main function makes the function behave as if it/// was synchronous by starting a new runtime each time it is called. If the/// function is called often, it is preferable to create the runtime using the/// runtime builder so the runtime can be reused across calls./// # Non-worker async function/// Note that the async function marked with this macro does not run as a/// worker. The expectation is that other tasks are spawned by the function here./// Awaiting on other futures from the function provided here will not/// # Multi-threaded runtime/// To use the multi-threaded runtime, the macro can be configured using/// #[tokio::main(flavor = "multi_thread", worker_threads = 10)]/// # async fn main() {}/// The `worker_threads` option configures the number of worker threads, and/// defaults to the number of cpus on the system. This is the default flavor./// Note: The multi-threaded runtime requires the `rt-multi-thread` feature/// flag./// # Current thread runtime/// To use the single-threaded runtime known as the `current_thread` runtime,/// the macro can be configured using/// ## Function arguments:/// Arguments are allowed for any functions aside from `main` which is special/// ### Using the multi-thread runtime/// Equivalent code not using `#[tokio::main]`///     tokio::runtime::Builder::new_multi_thread()///         .enable_all()///         .block_on(async {///             println!("Hello world");/// ### Using current thread runtime/// The basic scheduler is single-threaded.///     tokio::runtime::Builder::new_current_thread()/// ### Set number of worker threads/// #[tokio::main(worker_threads = 2)]///         .worker_threads(2)/// ### Configure the runtime to start with time paused///         .start_paused(true)/// Note that `start_paused` requires the `test-util` feature to be enabled./// ### Rename package/// use tokio as tokio1;/// #[tokio1::main(crate = "tokio1")]///     tokio1::runtime::Builder::new_multi_thread()/// ### Configure unhandled panic behavior/// Available options are `shutdown_runtime` and `ignore`. For more details, see/// [`Builder::unhandled_panic`]./// This option is only compatible with the `current_thread` runtime./// # #![allow(unknown_lints, unexpected_cfgs)]/// #[cfg(tokio_unstable)]/// #[tokio::main(flavor = "current_thread", unhandled_panic = "shutdown_runtime")]///     let _ = tokio::spawn(async {///         panic!("This panic will shutdown the runtime.");/// # #[cfg(not(tokio_unstable))]///         .unhandled_panic(UnhandledPanic::ShutdownRuntime)///             let _ = tokio::spawn(async {///                 panic!("This panic will shutdown the runtime.");///             }).await;/// **Note**: This option depends on Tokio's [unstable API][unstable]. See [the/// documentation on unstable features][unstable] for details on how to enable/// Tokio's unstable features./// [`Builder::unhandled_panic`]: ../tokio/runtime/struct.Builder.html#method.unhandled_panic/// [unstable]: ../tokio/index.html#unstable-featuresmain_rt/// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`/// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or/// ### Using default/// Marks async function to be executed by runtime, suitable to test environment./// This macro helps set up a `Runtime` without requiring the user to use/// #[tokio::test(flavor = "multi_thread", worker_threads = 1)]/// async fn my_test() {///     assert!(true);/// defaults to the number of cpus on the system./// The default test runtime is single-threaded. Each test gets a/// separate current-thread runtime./// #[tokio::test(flavor = "multi_thread")]/// Equivalent code not using `#[tokio::test]`/// fn my_test() {///             assert!(true);/// #[tokio::test(flavor = "multi_thread", worker_threads = 2)]/// #[tokio::test(start_paused = true)]/// #[tokio1::test(crate = "tokio1")]/// #[tokio::test(flavor = "current_thread", unhandled_panic = "shutdown_runtime")]test_rt/// Marks async function to be executed by runtime, suitable to test environmentmain_fail/// Always fails with the error message below./// The #[tokio::main] macro requires rt or rt-multi-thread.test_fail/// The #[tokio::test] macro requires rt or rt-multi-thread./// Implementation detail of the `select!` macro. This macro is **not** intended/// to be used as part of the public API and is permitted to change.//! Macros for use with Tokiodeclare_output_enumclean_pattern_macroclean_pattern// Removes any occurrences of ref or mut in the provided pattern.AllowStd/// An intermediate wrapper for the inner stream `S`./// A wrapper around an underlying raw stream which implements the TLS or SSL/// A `TlsStream<S>` represents a handshake that has been completed successfully/// and both the server and the client are ready for receiving and sending/// data. Bytes read from a `TlsStream` are decrypted from `S` and bytes written/// to a `TlsStream` are encrypted when passing through to `S`./// A wrapper around a `native_tls::TlsConnector`, providing an async `connect`/// A wrapper around a `native_tls::TlsAcceptor`, providing an async `accept`MidHandshakeStartedHandshakeMidStartedHandshakeFutureInnerStartedHandshakeFuture// *mut () context is neither Send nor Sync/// Connects the provided stream with this connector, assuming the provided/// domain./// This function will internally call `TlsConnector::connect` to connect/// the stream and returns a future representing the resolution of the/// connection operation. The returned future will resolve to either/// `TlsStream<S>` or `Error` depending if it's successful or not./// This is typically used for clients who have already established, for/// example, a TCP connection to a remote server. That stream is then/// provided here to perform the client half of a connection to a/// TLS-powered server./// Accepts a new client connection with the provided stream./// This function will internally call `TlsAcceptor::accept` to connect/// This is typically used after a new socket has been accepted from a/// `TcpListener`. That socket is then passed to this function to perform/// the server half of accepting a client connection./// re-export native_tls//! Async TLS streams//! This library is an implementation of TLS streams using the most appropriate//! system library by default for negotiating the connection. That is, on//! Windows this library uses SChannel, on OSX it uses SecureTransport, and on//! other platforms it uses OpenSSL.//! Each TLS stream implements the `Read` and `Write` traits to interact and//! interoperate with the rest of the futures I/O ecosystem. Client connections//! initiated from this crate verify hostnames automatically and by default.//! This crate primarily exports this ability through two newtypes,//! `TlsConnector` and `TlsAcceptor`. These newtypes augment the//! functionality provided by the `native-tls` crate, on which this crate is//! built. Configuration of TLS parameters is still primarily done through the//! `native-tls` crate.IoSessionTlsStateskip_handshake/// Note: that it does not guarantee the final data to be sent./// To be cautious, you must manually call `flush`.SyncWriteAdapterISSendAlertSDReadShutdownWriteShutdownFullyShutdownshutdown_readshutdown_writewriteableis_early_dataset_eofas_mut_pinread_iowrite_ioSyncReadAdapter/// An adapter that implements a [`Read`] interface for [`AsyncRead`] types and an/// associated [`Context`]./// Turns `Poll::Pending` into `WouldBlock`./// An adapter that implements a [`Write`] interface for [`AsyncWrite`] types and antest_streamstream_goodstream_good_vectoredstream_good_implstream_badstream_handshakestream_buffered_handshakestream_handshake_eofstream_handshake_regression_issues_77stream_eofmake_pair// Share `utils` module with integration tests/// A wrapper around a `rustls::ClientConfig`, providing an async `connect` method./// A wrapper around a `rustls::ServerConfig`, providing an async `accept` method.acceptorLazyConfigAcceptortake_io/// Takes back the client connection. Will return `None` if called more than once or if the/// connection has been accepted./// # async fn listen() {/// let listener = tokio::net::TcpListener::bind("127.0.0.1:4443").await.unwrap();/// let (stream, _) = listener.accept().await.unwrap();/// let acceptor = tokio_rustls::LazyConfigAcceptor::new(rustls::server::Acceptor::default(), stream);/// tokio::pin!(acceptor);/// match acceptor.as_mut().await {///     Ok(start) => {///         let clientHello = start.client_hello();///         let config = choose_server_config(clientHello);///         let stream = start.into_stream(config).await.unwrap();///         // Proceed with handling the ServerConnection...///         if let Some(mut stream) = acceptor.take_io() {///             stream///                 .write_all(///                     format!("HTTP/1.1 400 Invalid Input\r\n\r\n\r\n{:?}\n", err)///                         .as_bytes()///                 )///                 .await///                 .unwrap();StartHandshakeinto_stream_with/// Future returned from `TlsConnector::connect` which will resolve/// once the connection handshake has finished./// Future returned from `TlsAcceptor::accept` which will resolve/// once the accept handshake has finished.FallibleConnect/// Like [Connect], but returns `IO` on failure.FallibleAccept/// Like [Accept], but returns `IO` on failure.into_fallible/// Unified TLS stream type/// This abstracts over the inner `client::TlsStream` and `server::TlsStream`, so you can use/// a single type to keep both client- and server-initiated TLS-encrypted connections.// https://github.com/rust-lang/rust-clippy/issues/9798//! Asynchronous TLS/SSL streams for Tokio using [Rustls](https://github.com/rustls/rustls).//! # Why do I need to call `poll_flush`?//! Most TLS implementations will have an internal buffer to improve throughput,//! and rustls is no exception.//! When we write data to `TlsStream`, we always write rustls buffer first,//! then take out rustls encrypted data packet, and write it to data channel (like TcpStream).//! When data channel is pending, some data may remain in rustls buffer.//! `tokio-rustls` To keep it simple and correct, [TlsStream] will behave like `BufWriter`.//! For `TlsStream<TcpStream>`, this means that data written by `poll_write` is not guaranteed to be written to `TcpStream`.//! You must call `poll_flush` to ensure that it is written to `TcpStream`.//! You should call `poll_flush` at the appropriate time,//! such as when a period of `poll_write` write is complete and there is no more data to write.//! ## Why don't we write during `poll_read`?//! We did this in the early days of `tokio-rustls`, but it caused some bugs.//! We can solve these bugs through some solutions, but this will cause performance degradation (reverse false wakeup).//! And reverse write will also prevent us implement full duplex in the future.//! see <https://github.com/tokio-rs/tls/issues/40>//! ## Why can't we handle it like `native-tls`?//! When data channel returns to pending, `native-tls` will falsely report the number of bytes it consumes.//! This means that if data written by `poll_write` is not actually written to data channel, it will not return `Ready`.//! Thus avoiding the call of `poll_flush`.//! but which does not conform to convention of `AsyncWrite` trait.//! This means that if you give inconsistent data in two `poll_write`, it may cause unexpected behavior.//! see <https://github.com/tokio-rs/tls/issues/41>WsErrorContextWakerwrite_waker_proxyWakerProxy// We have the problem that external read operations (i.e. the Stream impl)// can trigger both read (AsyncRead) and write (AsyncWrite) operations on// the underyling stream. At the same time write operations (i.e. the Sink// impl) can trigger write operations (AsyncWrite) too.// Both the Stream and the Sink can be used on two different tasks, but it// is required that AsyncRead and AsyncWrite are only ever used by a single// task (or better: with a single waker) at a time.// Doing otherwise would cause only the latest waker to be remembered, so// in our case either the Stream or the Sink impl would potentially wait// forever to be woken up because only the other one would've been woken// up.// To solve this we implement a waker proxy that has two slots (one for// read, one for write) to store wakers. One waker proxy is always passed// to the AsyncRead, the other to AsyncWrite so that they will only ever// have to store a single waker, but internally we dispatch any wakeups to// up to two actual wakers (one from the Sink impl and one from the Stream// impl).// write_waker_proxy is always used for AsyncWrite, read_waker_proxy for// AsyncRead. The read_waker slots of both are used for the Stream impl// (and handshaking), the write_waker slots for the Sink impl.read_waker_proxySetWaker// Internal trait used only in the Handshake module for registering// the waker for the context used during handshaking. We're using the// read waker slot for this, but any would do.// Don't ever use this from multiple tasks at the same time!// Set the read or write waker for our proxies.// Read: this is only supposed to be called by read (or handshake) operations, i.e. the Stream// impl on the WebSocketStream.// Reading can also cause writes to happen, e.g. in case of Message::Ping handling.// Write: this is only supposde to be called by write operations, i.e. the Sink impl on the// WebSocketStream.// Proxy Waker that we pass to the internal AsyncRead/Write of the// stream underlying the websocket. We have two slots here for the// actual wakers to allow external read operations to trigger both// reads and writes, and the same for writes.UrlErrorWebSocketConfigMaybeTlsStreamIntoClientRequest/// Connect to a given URL./// Accepts any request that implements [`IntoClientRequest`], which is often just `&str`, but can/// be a variety of types such as `httparse::Request` or [`tungstenite::http::Request`] for more/// complex uses./// # use tungstenite::client::IntoClientRequest;/// # async fn test() {/// use tungstenite::http::{Method, Request};/// use tokio_tungstenite::connect_async;/// let mut request = "wss://api.example.com".into_client_request().unwrap();/// request.headers_mut().insert("api-key", "42".parse().unwrap());/// let (stream, response) = connect_async(request).await.unwrap();connect_async_with_config/// The same as `connect_async()` but the one can specify a websocket configuration./// Please refer to `connect_async()` for more details. `disable_nagle` specifies if/// the Nagle's algorithm must be disabled, i.e. `set_nodelay(true)`. If you don't know/// what the Nagle's algorithm is, better leave it set to `false`.connect_async_tls_with_config/// The same as `connect_async()` but the one can specify a websocket configuration,/// and a TLS connector to use. Please refer to `connect_async()` for more details./// `disable_nagle` specifies if the Nagle's algorithm must be disabled, i.e./// `set_nodelay(true)`. If you don't know what the Nagle's algorithm is, better/// leave it to `false`.//! Connection helper.WebSocketHandshakeRoleWsHandshakeClientHandshakeServerHandshakewithout_handshakeSkippedHandshakeFutureInnerSkippedHandshakeFutureFinalResultclient_handshakeserver_handshakeNoCallbackclient_async_tlsclient_async_tls_with_configCloseFrameclient_async/// Creates a WebSocket handshake from a request and a stream./// For convenience, the user may call this with a url string, a URL,/// or a `Request`. Calling with `Request` allows the user to add/// a WebSocket protocol or other custom headers./// Internally, this custom creates a handshake representation and returns/// a future representing the resolution of the WebSocket handshake. The/// returned future will resolve to either `WebSocketStream<S>` or `Error`/// depending on whether the handshake is successful./// example, a TCP connection to the remote server.client_async_with_config/// The same as `client_async()` but the one can specify a websocket configuration./// Please refer to `client_async()` for more details./// Accepts a new WebSocket connection with the provided stream./// This function will internally call `server::accept` to create a/// handshake representation and returns a future representing the/// resolution of the WebSocket handshake. The returned future will resolve/// to either `WebSocketStream<S>` or `Error` depending if it's successful/// This is typically used after a socket has been accepted from a/// the server half of the accepting a client's websocket connection.accept_async_with_config/// The same as `accept_async()` but the one can specify a websocket configuration./// Please refer to `accept_async()` for more details.accept_hdr_async/// This function does the same as `accept_async()` but accepts an extra callback/// for header processing. The callback receives headers of the incoming/// requests and is able to add extra headers to the reply.accept_hdr_async_with_config/// The same as `accept_hdr_async()` but the one can specify a websocket configuration./// Please refer to `accept_hdr_async()` for more details./// Tungstenite is probably ready to receive more data./// `false` once start_send hits `WouldBlock` errors./// `true` initially and after `flush`ing./// A wrapper around an underlying raw stream which implements the WebSocket/// A `WebSocketStream<S>` represents a handshake that has been completed/// successfully and both the server and the client are ready for receiving/// and sending data. Message from a `WebSocketStream<S>` are accessible/// through the respective `Stream` and `Sink`. Check more information about/// them in `futures-rs` crate documentation or have a look on the examples/// and unit tests for this crate./// Convert a raw socket into a WebSocketStream without performing afrom_partially_read/// Returns a reference to the configuration of the tungstenite stream./// Close the underlying web socket/// Get a domain from an URL.is_readis_writeis_async_readis_async_writeweb_socket_stream_has_traits//! Async WebSocket usage.//! This library is an implementation of WebSocket handshakes and streams. It//! is based on the crate which implements all required WebSocket protocol//! logic. So this crate basically just brings tokio support / tokio integration//! to it.//! Each WebSocket stream implements the required `Stream` and `Sink` traits,//! so the socket is just a stream of messages coming in and going out./// Unencrypted socket stream.NativeTls/// Encrypted socket stream using `native-tls`./// Encrypted socket stream using `rustls`.//! Convenience wrapper for streams to switch between plain TCP and TLS at runtime.//!  There is no dependency on actual TLS implementations. Everything like//! `native_tls` or `openssl` will work as long as there is a TLS stream supporting standard//! `Read + Write` traits.uri_mode/// Plain (non-TLS) connector./// `native-tls` TLS connector./// `rustls` TLS connector./// A connector that can be used when establishing connections, allowing to control whether/// `native-tls` or `rustls` is used to create a TLS connection. Or TLS can be disabled with the/// `Plain` variant.TokioTlsConnectorwrap_stream/// Creates a WebSocket handshake from a request and a stream,/// upgrading the stream to TLS if required./// The same as `client_async_tls()` but the one can specify a websocket configuration,/// and an optional connector. If no connector is specified, a default one will/// be created./// Please refer to `client_async_tls()` for more details.cfg_codeccfg_compatcfg_ioDEFAULT_SEEK_DELIMITERSDEFAULT_SEQUENCE_WRITER// Stored index of the next index to examine for the delimiter character.// This is used to optimize searching.// For example, if `decode` was called with `abc` and the delimiter is '{}', it would hold `3`,// because that is the next index to examine.// The next time `decode` is called with `abcde}`, the method will// only look at `de}` before returning./// The maximum length for a given chunk. If `usize::MAX`, chunks will be/// read until a delimiter character is reached.is_discarding/// Are we currently discarding the remainder of a chunk which was over/// the length limit?seek_delimiters/// The bytes that are using for search during decodesequence_writer/// The bytes that are using for encodingAnyDelimiterCodec/// A simple [`Decoder`] and [`Encoder`] implementation that splits up data into chunks based on any character in the given delimiter string./// [`Decoder`]: crate::codec::Decoder/// [`Encoder`]: crate::codec::Encoder/// Decode string of bytes containing various different delimiters./// [`BytesMut`]: bytes::BytesMut/// [`Error`]: std::io::Error/// use tokio_util::codec::{AnyDelimiterCodec, Decoder};/// use bytes::{BufMut, BytesMut};/// # async fn main() -> Result<(), std::io::Error> {/// let mut codec = AnyDelimiterCodec::new(b",;\r\n".to_vec(),b";".to_vec());/// let buf = &mut BytesMut::new();/// buf.reserve(200);/// buf.put_slice(b"chunk 1,chunk 2;chunk 3\n\r");/// assert_eq!("chunk 1", codec.decode(buf).unwrap().unwrap());/// assert_eq!("chunk 2", codec.decode(buf).unwrap().unwrap());/// assert_eq!("chunk 3", codec.decode(buf).unwrap().unwrap());/// assert_eq!("", codec.decode(buf).unwrap().unwrap());/// assert_eq!(None, codec.decode(buf).unwrap());/// Returns a `AnyDelimiterCodec` for splitting up data into chunks./// The returned `AnyDelimiterCodec` will not have an upper bound on the length/// of a buffered chunk. See the documentation for [`new_with_max_length`]/// for information on why this could be a potential security risk./// [`new_with_max_length`]: crate::codec::AnyDelimiterCodec::new_with_max_length()new_with_max_length/// Returns a `AnyDelimiterCodec` with a maximum chunk length limit./// If this is set, calls to `AnyDelimiterCodec::decode` will return a/// [`AnyDelimiterCodecError`] when a chunk exceeds the length limit. Subsequent calls/// will discard up to `limit` bytes from that chunk until a delimiter/// character is reached, returning `None` until the delimiter over the limit/// has been fully discarded. After that point, calls to `decode` will/// function as normal./// Setting a length limit is highly recommended for any `AnyDelimiterCodec` which/// will be exposed to untrusted input. Otherwise, the size of the buffer/// that holds the chunk currently being read is unbounded. An attacker could/// exploit this unbounded buffer by sending an unbounded amount of input/// without any delimiter characters, causing unbounded memory consumption./// [`AnyDelimiterCodecError`]: crate::codec::AnyDelimiterCodecError/// Returns the maximum chunk length when decoding./// use tokio_util::codec::AnyDelimiterCodec;/// let codec = AnyDelimiterCodec::new(b",;\n".to_vec(), b";".to_vec());/// assert_eq!(codec.max_length(), usize::MAX);/// let codec = AnyDelimiterCodec::new_with_max_length(b",;\n".to_vec(), b";".to_vec(), 256);/// assert_eq!(codec.max_length(), 256);AnyDelimiterCodecErrordecode_eofMaxChunkLengthExceeded/// The maximum chunk length was exceeded./// An IO error occurred./// An error occurred while encoding or decoding a chunk./// A simple [`Decoder`] and [`Encoder`] implementation that just ships bytes around./// Turn an [`AsyncRead`] into a stream of `Result<`[`BytesMut`]`, `[`Error`]`>`./// # mod hidden {/// # #[allow(unused_imports)]/// use tokio::io::AsyncRead;/// use tokio_util::codec::{FramedRead, BytesCodec};/// # enum File {}/// #     async fn open(_name: &str) -> Result<impl AsyncRead, std::io::Error> {/// #         use std::io::Cursor;/// #         Ok(Cursor::new(vec![0, 1, 2, 3, 4, 5]))/// let my_async_read = File::open("filename.txt").await?;/// let my_stream_of_bytes = FramedRead::new(my_async_read, BytesCodec::new());/// Creates a new `BytesCodec` for shipping around raw bytes.Framed/// The type of decoded frames./// The type of unrecoverable frame decoding errors./// If an individual message is ill-formed but can be ignored without/// interfering with the processing of future messages, it may be more/// useful to report the failure as an `Item`./// `From<io::Error>` is required in the interest of making `Error` suitable/// for returning directly from a [`FramedRead`], and to enable the default/// implementation of `decode_eof` to yield an `io::Error` when the decoder/// fails to consume all available data./// Note that implementors of this trait can simply indicate `type Error =/// io::Error` to use I/O errors as this type./// [`FramedRead`]: crate::codec::FramedRead/// Attempts to decode a frame from the provided buffer of bytes./// This method is called by [`FramedRead`] whenever bytes are ready to be/// parsed. The provided buffer of bytes is what's been read so far, and/// this instance of `Decode` can determine whether an entire frame is in/// the buffer and is ready to be returned./// If an entire frame is available, then this instance will remove those/// bytes from the buffer provided and return them as a decoded/// frame. Note that removing bytes from the provided buffer doesn't always/// necessarily copy the bytes, so this should be an efficient operation in/// most circumstances./// If the bytes look valid, but a frame isn't fully available yet, then/// `Ok(None)` is returned. This indicates to the [`Framed`] instance that/// it needs to read some more bytes before calling this method again./// Note that the bytes provided may be empty. If a previous call to/// `decode` consumed all the bytes in the buffer then `decode` will be/// called again until it returns `Ok(None)`, indicating that more bytes need to/// be read./// Finally, if the bytes in the buffer are malformed then an error is/// returned indicating why. This informs [`Framed`] that the stream is now/// corrupt and should be terminated./// [`Framed`]: crate::codec::Framed/// # Buffer management/// Before returning from the function, implementations should ensure that/// the buffer has appropriate capacity in anticipation of future calls to/// `decode`. Failing to do so leads to inefficiency./// For example, if frames have a fixed length, or if the length of the/// current frame is known from a header, a possible buffer management/// strategy is:/// # use bytes::BytesMut;/// # use tokio_util::codec::Decoder;/// # struct MyCodec;/// impl Decoder for MyCodec {///     # type Item = BytesMut;///     # type Error = io::Error;///     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {///         // Reserve enough to complete decoding of the current frame.///         let current_frame_len: usize = 1000; // Example.///         // And to start decoding the next frame.///         let next_frame_header_len: usize = 10; // Example.///         src.reserve(current_frame_len + next_frame_header_len);/// An optimal buffer management strategy minimizes reallocations and/// over-allocations./// A default method available to be called when there are no more bytes/// available to be read from the underlying I/O./// This method defaults to calling `decode` and returns an error if/// `Ok(None)` is returned while there is unconsumed data in `buf`./// Typically this doesn't need to be implemented unless the framing/// protocol differs near the end of the stream, or if you need to construct/// frames _across_ eof boundaries on sources that can be resumed./// Note that the `buf` argument may be empty. If a previous call to/// `decode_eof` consumed all the bytes in the buffer, `decode_eof` will be/// called again until it returns `None`, indicating that there are no more/// frames to yield. This behavior enables returning finalization frames/// that may not be based on inbound data./// Once `None` has been returned, `decode_eof` won't be called again until/// an attempt to resume the stream has been made, where the underlying stream/// actually returned more data./// Provides a [`Stream`] and [`Sink`] interface for reading and writing to this/// `Io` object, using `Decode` and `Encode` to read and write the raw data./// Raw I/O objects work with byte sequences, but higher-level code usually/// wants to batch these into meaningful chunks, called "frames". This/// method layers framing on top of an I/O object, by using the `Codec`/// traits to handle encoding and decoding of messages frames. Note that/// the incoming and outgoing frame types may be distinct./// This function returns a *single* object that is both `Stream` and/// `Sink`; grouping this into a single object is often useful for layering/// things like gzip or TLS, which require both read and write access to the/// underlying object./// If you want to work more directly with the streams and sink, consider/// calling `split` on the [`Framed`] returned by this method, which will/// break them into separate objects, allowing them to interact more easily./// [`Stream`]: futures_core::Stream/// [`Sink`]: futures_sink::Sink/// Decoding of frames via buffers./// This trait is used when constructing an instance of [`Framed`] or/// [`FramedRead`]. An implementation of `Decoder` takes a byte stream that has/// already been buffered in `src` and decodes the data into a stream of/// `Self::Item` frames./// Implementations are able to track state on `self`, which enables/// implementing stateful streaming parsers. In many cases, though, this type/// will simply be a unit struct (e.g. `struct HttpDecoder`)./// For some underlying data-sources, namely files and FIFOs,/// it's possible to temporarily read 0 bytes by reaching EOF./// In these cases `decode_eof` will be called until it signals/// fulfillment of all closing frames by returning `Ok(None)`./// After that, repeated attempts to read from the [`Framed`] or [`FramedRead`]/// will not invoke `decode` or `decode_eof` again, until data can be read/// during a retry./// It is up to the Decoder to keep track of a restart after an EOF,/// and to decide how to handle such an event by, for example,/// allowing frames to cross EOF boundaries, re-emitting opening frames, or/// resetting the entire internal state./// The type of encoding errors./// [`FramedWrite`] requires `Encoder`s errors to implement `From<io::Error>`/// in the interest of letting it return `Error`s directly./// [`FramedWrite`]: crate::codec::FramedWrite/// Encodes a frame into the buffer provided./// This method will encode `item` into the byte buffer provided by `dst`./// The `dst` provided is an internal buffer of the [`FramedWrite`] instance and/// will be written out when possible./// Trait of helper objects to write out messages as bytes, for use with/// [`FramedWrite`].framed_implFramedImplRWFramesReadFrameWriteFramer" A unified [`Stream`] and [`Sink`] interface to an underlying I/O object, using"r" the `Encoder` and `Decoder` traits to encode and decode frames."r" You can create a `Framed` instance by using the [`Decoder::framed`] adapter, or"r" by using the `new` function seen below."r" * [`futures_util::sink::SinkExt::send`]: if send is used as the event in a"r" `tokio::select!` statement and some other branch completes first, then it is"r" guaranteed that the message was not sent, but the message itself is lost."r" * [`tokio_stream::StreamExt::next`]: This method is cancel safe. The returned"r" future only holds onto a reference to the underlying stream, so dropping it will"r" never lose a value."r" [`Stream`]: futures_core::Stream"r" [`Sink`]: futures_sink::Sink"r" [`AsyncRead`]: tokio::io::AsyncRead"r" [`Decoder::framed`]: crate::codec::Decoder::framed()"r" [`futures_util::sink::SinkExt::send`]: futures_util::sink::SinkExt::send"r" [`tokio_stream::StreamExt::next`]: https://docs.rs/tokio-stream/latest/tokio_stream/trait.StreamExt.html#method.next"/// I/O object, using [`Decoder`] and [`Encoder`] to read and write the raw data./// method layers framing on top of an I/O object, by using the codec/// This function returns a *single* object that is both [`Stream`] and/// [`Sink`]; grouping this into a single object is often useful for layering/// calling [`split`] on the `Framed` returned by this method, which will/// Note that, for some byte sources, the stream can be resumed after an EOF/// by reading from it, even after it has returned `None`. Repeated attempts/// to do so, without new data available, continue to return `None` without/// creating more (closing) frames./// [`Decode`]: crate::codec::Decoder/// [`split`]: https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html#method.split/// I/O object, using [`Decoder`] and [`Encoder`] to read and write the raw data,/// with a specific read buffer initial capacity.FramedParts/// This objects takes a stream and a `readbuffer` and a `writebuffer`. These field/// can be obtained from an existing `Framed` with the [`into_parts`] method./// [`into_parts`]: crate::codec::Framed::into_parts()/// Returns a reference to the underlying I/O stream wrapped by/// `Framed`./// Note that care should be taken to not tamper with the underlying stream/// of data coming in as it may corrupt the stream of frames otherwise/// being worked with./// Returns a mutable reference to the underlying I/O stream wrapped by/// Returns a pinned mutable reference to the underlying I/O stream wrapped by/// Returns a reference to the underlying codec wrapped by/// Note that care should be taken to not tamper with the underlying codec/// as it may corrupt the stream of frames otherwise being worked with.codec_mut/// Returns a mutable reference to the underlying codec wrapped bymap_codec/// Maps the codec `U` to `C`, preserving the read and write buffers/// wrapped by `Framed`.codec_pin_mut/// Returns a reference to the read buffer.read_buffer_mut/// Returns a mutable reference to the read buffer./// Returns a reference to the write buffer.write_buffer_mut/// Returns a mutable reference to the write buffer.backpressure_boundary/// Returns backpressure boundaryset_backpressure_boundary/// Updates backpressure boundary/// Consumes the `Framed`, returning its underlying I/O stream./// Consumes the `Framed`, returning its underlying I/O stream, the buffer/// with unprocessed data, and the codec.// This impl just defers to the underlying FramedImpl/// The inner transport used to read bytes to and write bytes to/// The codec/// The buffer with read but unprocessed data./// A buffer with unprocessed data which are not written yet./// This private field allows us to add additional fields in the future in a/// backwards compatible way./// `FramedParts` contains an export of the data of a Framed transport./// It can be used to construct a new [`Framed`] with a different codec./// It contains all current buffers and the inner transport./// Create a new, default, `FramedParts`has_erroredr" A [`Stream`] of messages decoded from an [`AsyncRead`]."r" For examples of how to use `FramedRead` with a codec, see the"r" examples on the [`codec`] module."r" [`codec`]: crate::codec"/// Creates a new `FramedRead` with the given `decoder`./// Creates a new `FramedRead` with the given `decoder` and a buffer of `capacity`/// initial size./// `FramedRead`./// Consumes the `FramedRead`, returning its underlying I/O stream./// Returns a reference to the underlying decoder.decoder_mut/// Returns a mutable reference to the underlying decoder.map_decoder/// Maps the decoder `D` to `C`, preserving the read bufferdecoder_pin_mut// This impl just defers to the underlying T: Sink// ===== impl FramedRead =====r" A [`Sink`] of frames encoded to an `AsyncWrite`."r" For examples of how to use `FramedWrite` with a codec, see the"FramedWrite/// Creates a new `FramedWrite` with the given `encoder`./// `FramedWrite`./// Consumes the `FramedWrite`, returning its underlying I/O stream./// Returns a reference to the underlying encoder.encoder_mut/// Returns a mutable reference to the underlying encoder.map_encoder/// Maps the encoder `E` to `C`, preserving the write bufferencoder_pin_mut// This impl just defers to the underlying T: Streammax_frame_len// Maximum frame lengthlength_field_len// Number of bytes representing the field lengthlength_field_offset// Number of bytes in the header before the length fieldlength_adjustment// Adjust the length specified in the header field by this amountnum_skip// Total number of bytes to skip before reading the payload, if not set,// `length_field_len + length_field_offset`length_field_is_big_endian// Length field byte order (little or big endian)/// Configure length delimited `LengthDelimitedCodec`s./// `Builder` enables constructing configured length delimited codecs. Note/// that not all configuration settings apply to both encoding and decoding. See/// the documentation for specific methods for more detail./// Note that the if the value of [`Builder::max_frame_length`] becomes larger than/// what can actually fit in [`Builder::length_field_length`], it will be clipped to/// the maximum value that can fit.LengthDelimitedCodecError/// An error when the number of bytes read is more than max frame length.// Configuration valuesDecodeState// Read stateLengthDelimitedCodec/// A codec for frames delimited by a frame head specifying their lengths./// This allows the consumer to work with entire frames without having to worry/// about buffering or other framing logic./// See [module level] documentation for more detail./// [module level]: index.html/// Creates a new `LengthDelimitedCodec` with the default configuration values./// Creates a new length delimited codec builder with default configurationmax_frame_length/// Returns the current max frame setting/// This is the largest size this codec will accept from the wire. Larger/// frames will be rejected.set_max_frame_length/// Updates the max frame setting./// The change takes effect the next time a frame is decoded. In other/// words, if a frame is currently in process of being decoded with a frame/// size greater than `val` but less than the max frame length in effect/// before calling this function, then the frame will be allowed.decode_headLengthFieldType/// Types that can be used with `Builder::length_field_type`./// # use tokio::io::AsyncRead;/// use tokio_util::codec::LengthDelimitedCodec;/// # fn bind_read<T: AsyncRead>(io: T) {/// LengthDelimitedCodec::builder()///     .length_field_offset(0)///     .length_field_type::<u16>()///     .length_adjustment(0)///     .num_skip(0)///     .new_read(io);/// # pub fn main() {}/// Read the length field as a big endian integer/// This is the default setting./// This configuration option applies to both encoding and decoding.///     .big_endian()/// Read the length field as a little endian integer/// The default setting is big endian.///     .little_endian()/// Read the length field as a native endian integer///     .native_endian()/// Sets the max frame length in bytes/// This configuration option applies to both encoding and decoding. The/// default value is 8MB./// When decoding, the length field read from the byte stream is checked/// against this setting **before** any adjustments are applied. When/// encoding, the length of the submitted payload is checked against this/// When frames exceed the max length, an `io::Error` with the custom value/// of the `LengthDelimitedCodecError` type will be returned.///     .max_frame_length(8 * 1024 * 1024)length_field_type/// Sets the unsigned integer type used to represent the length field./// The default type is [`u32`]. The max type is [`u64`] (or [`usize`] on/// 64-bit targets).///     .length_field_type::<u32>()/// Unlike [`Builder::length_field_length`], this does not fail at runtime/// and instead produces a compile error:/// # use tokio_util::codec::LengthDelimitedCodec;///     .length_field_type::<u128>()length_field_length/// Sets the number of bytes used to represent the length field/// The default value is `4`. The max value is `8`.///     .length_field_length(4)/// Sets the number of bytes in the header before the length field/// This configuration option only applies to decoding.///     .length_field_offset(1)/// Delta between the payload length specified in the header and the real/// payload length///     .length_adjustment(-2)/// Sets the number of bytes to skip before reading the payload/// Default value is `length_field_len + length_field_offset`/// This configuration option only applies to decoding///     .num_skip(4)new_codec/// Create a configured length delimited `LengthDelimitedCodec`///     .new_codec();new_read/// Create a configured length delimited `FramedRead`/// Create a configured length delimited `FramedWrite`/// # use tokio::io::AsyncWrite;/// # fn write_frame<T: AsyncWrite>(io: T) {///     .new_write(io);new_framed/// Create a configured length delimited `Framed`/// # use tokio::io::{AsyncRead, AsyncWrite};/// # fn write_frame<T: AsyncRead + AsyncWrite>(io: T) {///     .new_framed(io);num_head_bytesget_num_skipadjust_max_frame_len//! Frame a stream of bytes based on a length prefix//! Many protocols delimit their frames by prefacing frame data with a//! frame head that specifies the length of the frame. The//! `length_delimited` module provides utilities for handling the length//! based framing. This allows the consumer to work with entire frames//! without having to worry about buffering or other framing logic.//! If implementing a protocol from scratch, using length delimited framing//! is an easy way to get started. [`LengthDelimitedCodec::new()`] will//! return a length delimited codec using default configuration values.//! This can then be used to construct a framer to adapt a full-duplex//! byte stream into a stream of frames.//! use tokio::io::{AsyncRead, AsyncWrite};//! use tokio_util::codec::{Framed, LengthDelimitedCodec};//! fn bind_transport<T: AsyncRead + AsyncWrite>(io: T)//!     -> Framed<T, LengthDelimitedCodec>//!     Framed::new(io, LengthDelimitedCodec::new())//! # pub fn main() {}//! The returned transport implements `Sink + Stream` for `BytesMut`. It//! encodes the frame with a big-endian `u32` header denoting the frame//! payload length://! +----------+--------------------------------+//! | len: u32 |          frame payload         |//! Specifically, given the following://! use futures::SinkExt;//! async fn write_frame<T>(io: T) -> Result<(), Box<dyn std::error::Error>>//!     T: AsyncRead + AsyncWrite + Unpin,//!     let mut transport = Framed::new(io, LengthDelimitedCodec::new());//!     let frame = Bytes::from("hello world");//!     transport.send(frame).await?;//! The encoded frame will look like this://! +---- len: u32 ----+---- data ----+//! | \x00\x00\x00\x0b |  hello world |//! +------------------+--------------+//! # Decoding//! [`FramedRead`] adapts an [`AsyncRead`] into a `Stream` of [`BytesMut`],//! such that each yielded [`BytesMut`] value contains the contents of an//! entire frame. There are many configuration parameters enabling//! [`FramedRead`] to handle a wide range of protocols. Here are some//! examples that will cover the various options at a high level.//! ## Example 1//! The following will parse a `u16` length field at offset 0, omitting the//! frame head in the yielded `BytesMut`.//! # use tokio_stream::StreamExt;//! # use tokio_util::codec::LengthDelimitedCodec;//! # let io: &[u8] = b"\x00\x0BHello world";//! let mut reader = LengthDelimitedCodec::builder()//!     .length_field_offset(0) // default value//!     .length_field_type::<u16>()//!     .length_adjustment(0)   // default value//!     .new_read(io);//! # let res = reader.next().await.unwrap().unwrap().to_vec();//! # assert_eq!(res, b"Hello world");//! The following frame will be decoded as such://!          INPUT                        DECODED//! +-- len ---+--- Payload ---+     +--- Payload ---+//! | \x00\x0B |  Hello world  | --> |  Hello world  |//! +----------+---------------+     +---------------+//! The value of the length field is 11 (`\x0B`) which represents the length//! of the payload, `hello world`. By default, [`FramedRead`] assumes that//! the length field represents the number of bytes that **follows** the//! length field. Thus, the entire frame has a length of 13: 2 bytes for the//! frame head + 11 bytes for the payload.//! ## Example 2//! The following will parse a `u16` length field at offset 0, including the//!     .length_adjustment(2)   // Add head size to length//!     .num_skip(0)            // Do NOT skip the head//! # assert_eq!(res, b"\x00\x0BHello world");//!          INPUT                           DECODED//! +-- len ---+--- Payload ---+     +-- len ---+--- Payload ---+//! | \x00\x0B |  Hello world  | --> | \x00\x0B |  Hello world  |//! +----------+---------------+     +----------+---------------+//! This is similar to the first example, the only difference is that the//! frame head is **included** in the yielded `BytesMut` value. To achieve//! this, we need to add the header size to the length with `length_adjustment`,//! and set `num_skip` to `0` to prevent skipping the head.//! ## Example 3//! frame head in the yielded `BytesMut`. In this case, the length field//! **includes** the frame head length.//! # let io: &[u8] = b"\x00\x0DHello world";//!     .length_adjustment(-2)  // size of head//! | \x00\x0D |  Hello world  | --> |  Hello world  |//! In most cases, the length field represents the length of the payload//! only, as shown in the previous examples. However, in some protocols the//! length field represents the length of the whole frame, including the//! head. In such cases, we specify a negative `length_adjustment` to adjust//! the value provided in the frame head to represent the payload length.//! ## Example 4//! The following will parse a 3 byte length field at offset 0 in a 5 byte//! frame head, including the frame head in the yielded `BytesMut`.//! # let io: &[u8] = b"\x00\x00\x0B\xCA\xFEHello world";//!     .length_field_length(3)//!     .length_adjustment(3 + 2)  // len field and remaining head//!     .num_skip(0)//! # assert_eq!(res, b"\x00\x00\x0B\xCA\xFEHello world");//!                  INPUT//! +---- len -----+- head -+--- Payload ---+//! | \x00\x00\x0B | \xCAFE |  Hello world  |//! +--------------+--------+---------------+//!                  DECODED//! A more advanced example that shows a case where there is extra frame//! head data between the length field and the payload. In such cases, it is//! usually desirable to include the frame head as part of the yielded//! `BytesMut`. This lets consumers of the length delimited framer to//! process the frame head as needed.//! The positive `length_adjustment` value lets `FramedRead` factor in the//! additional head into the frame length calculation.//! ## Example 5//! The following will parse a `u16` length field at offset 1 of a 4 byte//! frame head. The first byte and the length field will be omitted from the//! yielded `BytesMut`, but the trailing 2 bytes of the frame head will be//! included.//! # let io: &[u8] = b"\xCA\x00\x0B\xFEHello world";//!     .length_field_offset(1) // length of hdr1//!     .length_adjustment(1)  // length of hdr2//!     .num_skip(3) // length of hdr1 + LEN//! # assert_eq!(res, b"\xFEHello world");//! +- hdr1 -+-- len ---+- hdr2 -+--- Payload ---+//! |  \xCA  | \x00\x0B |  \xFE  |  Hello world  |//! +--------+----------+--------+---------------+//!          DECODED//! +- hdr2 -+--- Payload ---+//! |  \xFE  |  Hello world  |//! +--------+---------------+//! The length field is situated in the middle of the frame head. In this//! case, the first byte in the frame head could be a version or some other//! identifier that is not needed for processing. On the other hand, the//! second half of the head is needed.//! `length_field_offset` indicates how many bytes to skip before starting//! to read the length field.  `length_adjustment` is the number of bytes to//! skip starting at the end of the length field. In this case, it is the//! second half of the head.//! ## Example 6//! included. In this case, the length field **includes** the frame head//! length.//! # let io: &[u8] = b"\xCA\x00\x0F\xFEHello world";//!     .length_adjustment(-3)  // length of hdr1 + LEN, negative//!     .num_skip(3)//! |  \xCA  | \x00\x0F |  \xFE  |  Hello world  |//! Similar to the example above, the difference is that the length field//! represents the length of the entire frame instead of just the payload.//! The length of `hdr1` and `len` must be counted in `length_adjustment`.//! Note that the length of `hdr2` does **not** need to be explicitly set//! anywhere because it already is factored into the total frame length that//! is read from the byte stream.//! ## Example 7//! The following will parse a 3 byte length field at offset 0 in a 4 byte//! frame head, excluding the 4th byte from the yielded `BytesMut`.//! # let io: &[u8] = b"\x00\x00\x0B\xFFHello world";//!     .length_adjustment(0)  // default value//!     .num_skip(4) // skip the first 4 bytes//!                  INPUT                       DECODED//! +------- len ------+--- Payload ---+    +--- Payload ---+//! | \x00\x00\x0B\xFF |  Hello world  | => |  Hello world  |//! +------------------+---------------+    +---------------+//! A simple example where there are unused bytes between the length field//! and the payload.//! # Encoding//! [`FramedWrite`] adapts an [`AsyncWrite`] into a `Sink` of [`BytesMut`],//! such that each submitted [`BytesMut`] is prefaced by a length field.//! There are fewer configuration options than [`FramedRead`]. Given//! protocols that have more complex frame heads, an encoder should probably//! be written by hand using [`Encoder`].//! Here is a simple example, given a `FramedWrite` with the following//! configuration://! # use tokio::io::AsyncWrite;//! # fn write_frame<T: AsyncWrite>(io: T) {//! # let _ =//! LengthDelimitedCodec::builder()//!     .new_write(io);//! A payload of `hello world` will be encoded as://! +- len: u16 -+---- data ----+//! |  \x00\x0b  |  hello world |//! +------------+--------------+//! [`LengthDelimitedCodec::new()`]: method@LengthDelimitedCodec::new//! [`FramedRead`]: struct@FramedRead//! [`FramedWrite`]: struct@FramedWrite//! [`AsyncRead`]: trait@tokio::io::AsyncRead//! [`AsyncWrite`]: trait@tokio::io::AsyncWrite//! [`Encoder`]: trait@Encoder//! [`BytesMut`]: bytes::BytesMut// ===== impl LengthDelimitedCodec ======// ===== impl LengthDelimitedCodecError =====// Stored index of the next index to examine for a `\n` character.// For example, if `decode` was called with `abc`, it would hold `3`,// The next time `decode` is called with `abcde\n`, the method will// only look at `de\n` before returning./// The maximum length for a given line. If `usize::MAX`, lines will be/// read until a `\n` character is reached./// Are we currently discarding the remainder of a line which was overLinesCodec/// A simple [`Decoder`] and [`Encoder`] implementation that splits up data into lines./// This uses the `\n` character as the line ending on all platforms./// Returns a `LinesCodec` for splitting up data into lines./// The returned `LinesCodec` will not have an upper bound on the length/// of a buffered line. See the documentation for [`new_with_max_length`]/// [`new_with_max_length`]: crate::codec::LinesCodec::new_with_max_length()/// Returns a `LinesCodec` with a maximum line length limit./// If this is set, calls to `LinesCodec::decode` will return a/// [`LinesCodecError`] when a line exceeds the length limit. Subsequent calls/// will discard up to `limit` bytes from that line until a newline/// character is reached, returning `None` until the line over the limit/// Setting a length limit is highly recommended for any `LinesCodec` which/// that holds the line currently being read is unbounded. An attacker could/// without any `\n` characters, causing unbounded memory consumption./// [`LinesCodecError`]: crate::codec::LinesCodecError/// Returns the maximum line length when decoding./// use tokio_util::codec::LinesCodec;/// let codec = LinesCodec::new();/// let codec = LinesCodec::new_with_max_length(256);without_carriage_returnLinesCodecErrorMaxLineLengthExceeded/// The maximum line length was exceeded./// An error occurred while encoding or decoding a line.bytes_codecframed_readframed_writelines_codecany_delimiter_codec//! Adaptors from `AsyncRead`/`AsyncWrite` to Stream/Sink//! Raw I/O objects work with byte sequences, but higher-level code usually//! wants to batch these into meaningful chunks, called "frames".//! This module contains adapters to go from streams of bytes, [`AsyncRead`] and//! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].//! Framed streams are also known as transports.//! # Example encoding using `LinesCodec`//! The following example demonstrates how to use a codec such as [`LinesCodec`] to//! write framed data. [`FramedWrite`] can be used to achieve this. Data sent to//! [`FramedWrite`] are first framed according to a specific codec, and then sent to//! an implementor of [`AsyncWrite`].//! use futures::sink::SinkExt;//! use tokio_util::codec::LinesCodec;//! use tokio_util::codec::FramedWrite;//!     let buffer = Vec::new();//!     let messages = vec!["Hello", "World"];//!     let encoder = LinesCodec::new();//!     // FramedWrite is a sink which means you can send values into it//!     // asynchronously.//!     let mut writer = FramedWrite::new(buffer, encoder);//!     // To be able to send values into a FramedWrite, you need to bring the//!     // `SinkExt` trait into scope.//!     writer.send(messages[0]).await.unwrap();//!     writer.send(messages[1]).await.unwrap();//!     let buffer = writer.get_ref();//!     assert_eq!(buffer.as_slice(), "Hello\nWorld\n".as_bytes());//! # Example decoding using `LinesCodec`//! read a stream of framed data. [`FramedRead`] can be used to achieve this. [`FramedRead`]//! will keep reading from an [`AsyncRead`] implementor until a whole frame, according to a codec,//! can be parsed.//! use tokio_stream::StreamExt;//! use tokio_util::codec::FramedRead;//!     let message = "Hello\nWorld".as_bytes();//!     let decoder = LinesCodec::new();//!     // FramedRead can be used to read a stream of values that are framed according to//!     // a codec. FramedRead will read from its input (here `buffer`) until a whole frame//!     // can be parsed.//!     let mut reader = FramedRead::new(message, decoder);//!     // To read values from a FramedRead, you need to bring the//!     // `StreamExt` trait into scope.//!     let frame1 = reader.next().await.unwrap().unwrap();//!     let frame2 = reader.next().await.unwrap().unwrap();//!     assert!(reader.next().await.is_none());//!     assert_eq!(frame1, "Hello");//!     assert_eq!(frame2, "World");//! # The Decoder trait//! A [`Decoder`] is used together with [`FramedRead`] or [`Framed`] to turn an//! [`AsyncRead`] into a [`Stream`]. The job of the decoder trait is to specify//! how sequences of bytes are turned into a sequence of frames, and to//! determine where the boundaries between frames are.  The job of the//! `FramedRead` is to repeatedly switch between reading more data from the IO//! resource, and asking the decoder whether we have received enough data to//! decode another frame of data.//! The main method on the `Decoder` trait is the [`decode`] method. This method//! takes as argument the data that has been read so far, and when it is called,//! it will be in one of the following situations://!  1. The buffer contains less than a full frame.//!  2. The buffer contains exactly a full frame.//!  3. The buffer contains more than a full frame.//! In the first situation, the decoder should return `Ok(None)`.//! In the second situation, the decoder should clear the provided buffer and//! return `Ok(Some(the_decoded_frame))`.//! In the third situation, the decoder should use a method such as [`split_to`]//! or [`advance`] to modify the buffer such that the frame is removed from the//! buffer, but any data in the buffer after that frame should still remain in//! the buffer. The decoder should also return `Ok(Some(the_decoded_frame))` in//! this case.//! Finally the decoder may return an error if the data is invalid in some way.//! The decoder should _not_ return an error just because it has yet to receive//! a full frame.//! It is guaranteed that, from one call to `decode` to another, the provided//! buffer will contain the exact same data as before, except that if more data//! has arrived through the IO resource, that data will have been appended to//! the buffer.  This means that reading frames from a `FramedRead` is//! essentially equivalent to the following loop://! # // This uses async_stream to create an example that compiles.//! # fn foo() -> impl futures_core::Stream<Item = std::io::Result<bytes::BytesMut>> { async_stream::try_stream! {//! # use tokio_util::codec::Decoder;//! # let mut decoder = tokio_util::codec::BytesCodec::new();//! # let io_resource = &mut &[0u8, 1, 2, 3][..];//! let mut buf = bytes::BytesMut::new();//!     // The read_buf call will append to buf rather than overwrite existing data.//!     let len = io_resource.read_buf(&mut buf).await?;//!         while let Some(frame) = decoder.decode_eof(&mut buf)? {//!             yield frame;//!     while let Some(frame) = decoder.decode(&mut buf)? {//!         yield frame;//! # }}//! The example above uses `yield` whenever the `Stream` produces an item.//! ## Example decoder//! As an example, consider a protocol that can be used to send strings where//! each frame is a four byte integer that contains the length of the frame,//! followed by that many bytes of string data. The decoder fails with an error//! if the string data is not valid utf-8 or too long.//! Such a decoder can be written like this://! use tokio_util::codec::Decoder;//! use bytes::{BytesMut, Buf};//! struct MyStringDecoder {}//! const MAX: usize = 8 * 1024 * 1024;//! impl Decoder for MyStringDecoder {//!     type Item = String;//!     fn decode(//!         &mut self,//!         src: &mut BytesMut//!     ) -> Result<Option<Self::Item>, Self::Error> {//!         if src.len() < 4 {//!             // Not enough data to read length marker.//!             return Ok(None);//!         // Read length marker.//!         let mut length_bytes = [0u8; 4];//!         length_bytes.copy_from_slice(&src[..4]);//!         let length = u32::from_le_bytes(length_bytes) as usize;//!         // Check that the length is not too large to avoid a denial of//!         // service attack where the server runs out of memory.//!         if length > MAX {//!             return Err(std::io::Error::new(//!                 std::io::ErrorKind::InvalidData,//!                 format!("Frame of length {} is too large.", length)//!             ));//!         if src.len() < 4 + length {//!             // The full string has not yet arrived.//!             // We reserve more space in the buffer. This is not strictly//!             // necessary, but is a good idea performance-wise.//!             src.reserve(4 + length - src.len());//!             // We inform the Framed that we need more bytes to form the next//!             // frame.//!         // Use advance to modify src such that it no longer contains//!         // this frame.//!         let data = src[4..4 + length].to_vec();//!         src.advance(4 + length);//!         // Convert the data to a string, or fail if it is not valid utf-8.//!         match String::from_utf8(data) {//!             Ok(string) => Ok(Some(string)),//!             Err(utf8_error) => {//!                 Err(std::io::Error::new(//!                     std::io::ErrorKind::InvalidData,//!                     utf8_error.utf8_error(),//!                 ))//! # The Encoder trait//! An [`Encoder`] is used together with [`FramedWrite`] or [`Framed`] to turn//! an [`AsyncWrite`] into a [`Sink`]. The job of the encoder trait is to//! specify how frames are turned into a sequences of bytes.  The job of the//! `FramedWrite` is to take the resulting sequence of bytes and write it to the//! IO resource.//! The main method on the `Encoder` trait is the [`encode`] method. This method//! takes an item that is being written, and a buffer to write the item to. The//! buffer may already contain data, and in this case, the encoder should append//! the new frame to the buffer rather than overwrite the existing data.//! It is guaranteed that, from one call to `encode` to another, the provided//! buffer will contain the exact same data as before, except that some of the//! data may have been removed from the front of the buffer. Writing to a//! `FramedWrite` is essentially equivalent to the following loop://! use bytes::Buf; // for advance//! # use tokio_util::codec::Encoder;//! # async fn next_frame() -> bytes::Bytes { bytes::Bytes::new() }//! # async fn no_more_frames() { }//! # #[tokio::main] async fn main() -> std::io::Result<()> {//! # let mut io_resource = tokio::io::sink();//! # let mut encoder = tokio_util::codec::BytesCodec::new();//! const MAX: usize = 8192;//!     tokio::select! {//!         num_written = io_resource.write(&buf), if !buf.is_empty() => {//!             buf.advance(num_written?);//!         frame = next_frame(), if buf.len() < MAX => {//!             encoder.encode(frame, &mut buf)?;//!         _ = no_more_frames() => {//!             io_resource.write_all(&buf).await?;//!             io_resource.shutdown().await?;//!             return Ok(());//! Here the `next_frame` method corresponds to any frames you write to the//! `FramedWrite`. The `no_more_frames` method corresponds to closing the//! `FramedWrite` with [`SinkExt::close`].//! ## Example encoder//! followed by that many bytes of string data. The encoder will fail if the//! string is too long.//! Such an encoder can be written like this://! use tokio_util::codec::Encoder;//! use bytes::BytesMut;//! struct MyStringEncoder {}//! impl Encoder<String> for MyStringEncoder {//!     fn encode(&mut self, item: String, dst: &mut BytesMut) -> Result<(), Self::Error> {//!         // Don't send a string if it is longer than the other end will//!         // accept.//!         if item.len() > MAX {//!                 format!("Frame of length {} is too large.", item.len())//!         // Convert the length into a byte array.//!         // The cast to u32 cannot overflow due to the length check above.//!         let len_slice = u32::to_le_bytes(item.len() as u32);//!         // Reserve space in the buffer.//!         dst.reserve(4 + item.len());//!         // Write the length and string to the buffer.//!         dst.extend_from_slice(&len_slice);//!         dst.extend_from_slice(item.as_bytes());//! [`Stream`]: futures_core::Stream//! [`Sink`]: futures_sink::Sink//! [`SinkExt`]: futures::sink::SinkExt//! [`SinkExt::close`]: https://docs.rs/futures/0.3/futures/sink/trait.SinkExt.html#method.close//! [`FramedRead`]: struct@crate::codec::FramedRead//! [`FramedWrite`]: struct@crate::codec::FramedWrite//! [`Framed`]: struct@crate::codec::Framed//! [`Decoder`]: trait@crate::codec::Decoder//! [`decode`]: fn@crate::codec::Decoder::decode//! [`encode`]: fn@crate::codec::Encoder::encode//! [`split_to`]: fn@bytes::BytesMut::split_to//! [`advance`]: fn@bytes::Buf::advancer" A compatibility layer that allows conversion between the"r" `tokio::io` and `futures-io` `AsyncRead` and `AsyncWrite` traits."seek_pos/// Wraps `self` with a compatibility layer that implements/// `tokio_io::AsyncRead`.FuturesAsyncReadCompatExt/// Extension trait that allows converting a type implementing/// `futures_io::AsyncRead` to implement `tokio::io::AsyncRead`.compat_write/// `tokio::io::AsyncWrite`.FuturesAsyncWriteCompatExt/// `futures_io::AsyncWrite` to implement `tokio::io::AsyncWrite`./// `futures_io::AsyncRead`.TokioAsyncReadCompatExt/// `tokio::io::AsyncRead` to implement `futures_io::AsyncRead`./// `futures_io::AsyncWrite`.TokioAsyncWriteCompatExt/// `tokio::io::AsyncWrite` to implement `futures_io::AsyncWrite`./// Get a reference to the `Future`, `Stream`, `AsyncRead`, or `AsyncWrite` object/// Get a mutable reference to the `Future`, `Stream`, `AsyncRead`, or `AsyncWrite` object/// Returns the wrapped item.//! Compatibility between the `tokio::io` and `futures-io` versions of the//! `AsyncRead` and `AsyncWrite` traits.// === impl Compat ===r" `TokioContext` allows running futures that must be inside Tokio's"r" context on a non-Tokio runtime."r" It contains a [`Handle`] to the runtime. A handle to the runtime can be"r" obtain by calling the [`Runtime::handle()`] method."r" Note that the `TokioContext` wrapper only works if the `Runtime` it is"r" connected to has not yet been destroyed. You must keep the `Runtime`"r" alive until the future has finished executing."r" **Warning:** If `TokioContext` is used together with a [current thread]"r" runtime, that runtime must be inside a call to `block_on` for the"r" wrapped future to work. For this reason, it is recommended to use a"r" [multi thread] runtime, even if you configure it to only spawn one"r" worker thread."r" This example creates two runtimes, but only [enables time] on one of"r" them. It then uses the context of the runtime with the timer enabled to"r" execute a [`sleep`] future on the runtime with timing disabled."r" use tokio_util::context::RuntimeExt;"r" // This runtime has timers enabled."r" let rt = tokio::runtime::Builder::new_multi_thread()"r"     .enable_all()"r" // This runtime has timers disabled."r" let rt2 = tokio::runtime::Builder::new_multi_thread()"r" // Wrap the sleep future in the context of rt."r" let fut = rt.wrap(async { sleep(Duration::from_millis(2)).await });"r" // Execute the future on rt2."r" rt2.block_on(fut);"r" [`Handle`]: struct@tokio::runtime::Handle"r" [`Runtime::handle()`]: fn@tokio::runtime::Runtime::handle"r" [`RuntimeExt`]: trait@crate::context::RuntimeExt"r" [`new_static`]: fn@Self::new_static"r" [`sleep`]: fn@tokio::time::sleep"r" [current thread]: fn@tokio::runtime::Builder::new_current_thread"r" [enables time]: fn@tokio::runtime::Builder::enable_time"r" [multi thread]: fn@tokio::runtime::Builder::new_multi_thread"TokioContext/// Associate the provided future with the context of the runtime behind/// the provided `Handle`./// This constructor uses a `'static` lifetime to opt-out of checking that/// the runtime still exists./// This is the same as the example above, but uses the `new` constructor/// rather than [`RuntimeExt::wrap`]./// [`RuntimeExt::wrap`]: fn@RuntimeExt::wrap/// use tokio_util::context::TokioContext;/// // This runtime has timers enabled./// let rt = tokio::runtime::Builder::new_multi_thread()/// // This runtime has timers disabled./// let rt2 = tokio::runtime::Builder::new_multi_thread()/// let fut = TokioContext::new(///     async { sleep(Duration::from_millis(2)).await },///     rt.handle().clone(),/// // Execute the future on rt2./// rt2.block_on(fut);/// Obtain a reference to the handle inside this `TokioContext`./// Remove the association between the Tokio runtime and the wrapped future./// Create a [`TokioContext`] that wraps the provided future and runs it in/// this runtime's context./// This example creates two runtimes, but only [enables time] on one of/// them. It then uses the context of the runtime with the timer enabled to/// execute a [`sleep`] future on the runtime with timing disabled./// use tokio_util::context::RuntimeExt;/// // Wrap the sleep future in the context of rt./// let fut = rt.wrap(async { sleep(Duration::from_millis(2)).await });/// [`TokioContext`]: struct@crate::context::TokioContext/// [`sleep`]: fn@tokio::time::sleep/// [enables time]: fn@tokio::runtime::Builder::enable_timeRuntimeExt/// Extension trait that simplifies bundling a `Handle` with a `Future`.//! Tokio context aware futures utilities.//! This module includes utilities around integrating tokio with other runtimes//! by allowing the context to be attached to futures. This allows spawning//! futures on other executors while still using tokio to drive them. This//! can be useful if you need to use a tokio based library in an executor/runtime//! that does not provide a tokio context./// This type implements common asynchronous traits such as [`Future`] and those in Tokio./// [`Future`]: std::future::Future/// The following code will not work:/// # fn some_condition() -> bool { true }/// # async fn some_async_function() -> u32 { 10 }/// # async fn other_async_function() -> u32 { 20 }///     let result = if some_condition() {///         some_async_function()///         other_async_function() // <- Will print: "`if` and `else` have incompatible types"///     println!("Result is {}", result.await);// This is because although the output types for both futures is the same, the exact future// types are different, but the compiler must be able to choose a single type for the// `result` variable./// When the output type is the same, we can wrap each future in `Either` to avoid the/// issue:/// use tokio_util::either::Either;///         Either::Left(some_async_function())///         Either::Right(other_async_function())///     let value = result.await;///     println!("Result is {}", value);///     # assert_eq!(value, 10);// Doc-comments for variants in this particular case don't make much sense.delegate_call/// A small helper macro which reduces amount of boilerplate in the actual trait method implementation./// It takes an invocation of method as an argument (e.g. `self.poll(cx)`), and redirects it to either/// enum variant held in `self`.tokio_streameither_is_streameither_is_async_read//! Module defining an Either type.r" A helper that wraps a [`Sink`]`<`[`Bytes`]`>` and converts it into a"r" [`Sink`]`<&'a [u8]>` by copying each byte slice into an owned [`Bytes`]."r" See the documentation for [`SinkWriter`] for an example."r" [`Bytes`]: bytes::Bytes"r" [`SinkWriter`]: crate::io::SinkWriter"CopyToBytes/// Creates a new [`CopyToBytes`]./// Gets a reference to the underlying sink./// Gets a mutable reference to the underlying sink./// Consumes this [`CopyToBytes`], returning the underlying sink.r" An adapter that lets you inspect the data that's being read."r" This is useful for things like hashing data as it's read in."InspectReader/// Create a new `InspectReader`, wrapping `reader` and calling `f` for the/// new data supplied by each read call./// The closure will only be called with an empty slice if the inner reader/// returns without reading data into the buffer. This happens at EOF, or if/// `poll_read` is called with a zero-size buffer./// Consumes the `InspectReader`, returning the wrapped readerr" An adapter that lets you inspect the data that's being written."r" This is useful for things like hashing data as it's written out."InspectWriter/// Create a new `InspectWriter`, wrapping `write` and calling `f` for the/// data successfully written by each write call./// The closure `f` will never be called with an empty slice. A vectored/// write can result in multiple calls to `f` - at most one call to `f` per/// buffer supplied to `poll_write_vectored`./// Consumes the `InspectWriter`, returning the wrapped writerreader_streamsink_writerread_exact_arcsync_bridgeSyncIoBridgeReaderStreamSinkWriter//! Helpers for IO related tasks.//! The stream types are often used in combination with hyper or reqwest, as they//! allow converting between a hyper [`Body`] and [`AsyncRead`].//! The [`SyncIoBridge`] type converts from the world of async I/O//! to synchronous I/O; this may often come up when using synchronous APIs//! inside [`tokio::task::spawn_blocking`].//! [`Body`]: https://docs.rs/hyper/0.13/hyper/struct.Body.html/// Read data from an `AsyncRead` into an `Arc`./// This uses `Arc::new_uninit_slice` and reads into the resulting uninitialized `Arc`./// # async fn main() -> std::io::Result<()> {/// use tokio_util::io::read_exact_arc;/// let read = tokio::io::repeat(42);/// let arc = read_exact_arc(read, 4).await?;/// assert_eq!(&arc[..], &[42; 4]);/// Read data from an `AsyncRead` into an implementer of the [`BufMut`] trait./// [`BufMut`]: bytes::BufMut/// use tokio_stream as stream;/// use tokio::io::Result;/// use tokio_util::io::{StreamReader, read_buf};/// // Create a reader from an iterator. This particular reader will always be/// // ready./// let mut read = StreamReader::new(stream::iter(vec![Result::Ok(Bytes::from_static(&[0, 1, 2, 3]))]));/// let mut reads = 0;///     reads += 1;///     let n = read_buf(&mut read, &mut buf).await?;///     if n == 0 {/// // one or more reads might be necessary./// assert!(reads >= 1);/// assert_eq!(&buf[..], &[0, 1, 2, 3]);DEFAULT_CAPACITYr" Convert an [`AsyncRead`] into a [`Stream`] of byte chunks."r" This stream is fused. It performs the inverse operation of"r" [`StreamReader`]."r" use tokio_util::io::ReaderStream;"r" // Create a stream of data."r#" let data = b"hello, world!";"#r" let mut stream = ReaderStream::new(&data[..]);"r" // Read all of the chunks into a vector."r" let mut stream_contents = Vec::new();"r" while let Some(chunk) = stream.next().await {"r"    stream_contents.extend_from_slice(&chunk?);"r" // Once the chunks are concatenated, we should have the"r" // original data."r" assert_eq!(stream_contents, data);"r" [`StreamReader`]: crate::io::StreamReader"/// Convert an [`AsyncRead`] into a [`Stream`] with item type/// `Result<Bytes, std::io::Error>`./// `Result<Bytes, std::io::Error>`,r" Convert a [`Sink`] of byte chunks into an [`AsyncWrite`]."r" Whenever you write to this [`SinkWriter`], the supplied bytes are"r" forwarded to the inner [`Sink`]. When `shutdown` is called on this"r" [`SinkWriter`], the inner sink is closed."r" This adapter takes a `Sink<&[u8]>` and provides an [`AsyncWrite`] impl"r" for it. Because of the lifetime, this trait is relatively rarely"r" implemented. The main ways to get a `Sink<&[u8]>` that you can use with"r" this type are:"r"  * With the codec module by implementing the [`Encoder`]`<&[u8]>` trait."r"  * By wrapping a `Sink<Bytes>` in a [`CopyToBytes`]."r"  * Manually implementing `Sink<&[u8]>` directly."r" The opposite conversion of implementing `Sink<_>` for an [`AsyncWrite`]"r" is done using the [`codec`] module."r" use bytes::Bytes;"r" use futures_util::SinkExt;"r" use std::io::{Error, ErrorKind};"r" use tokio_util::io::{SinkWriter, CopyToBytes};"r" use tokio_util::sync::PollSender;"r#" # #[tokio::main(flavor = "current_thread")]"#r" # async fn main() -> Result<(), Error> {"r" // We use an mpsc channel as an example of a `Sink<Bytes>`."r" let (tx, mut rx) = tokio::sync::mpsc::channel::<Bytes>(1);"r" let sink = PollSender::new(tx).sink_map_err(|_| Error::from(ErrorKind::BrokenPipe));"r" // Wrap it in `CopyToBytes` to get a `Sink<&[u8]>`."r" let mut writer = SinkWriter::new(CopyToBytes::new(sink));"r" // Write data to our interface..."r" let data: [u8; 4] = [1, 2, 3, 4];"r" let _ = writer.write(&data).await?;"r" // ... and receive it."r" assert_eq!(data.as_slice(), &*rx.recv().await.unwrap());"r" [`AsyncWrite`]: tokio::io::AsyncWrite"r" [`CopyToBytes`]: crate::io::CopyToBytes"r" [`Encoder`]: crate::codec::Encoder"/// Creates a new [`SinkWriter`]./// Consumes this [`SinkWriter`], returning the underlying sink.// This field is pinned.// This field is not pinned./// Convert a [`Stream`] of byte chunks into an [`AsyncRead`]./// This type performs the inverse operation of [`ReaderStream`]./// This type also implements the [`AsyncBufRead`] trait, so you can use it/// to read a `Stream` of byte chunks line-by-line. See the examples below./// use tokio::io::{AsyncReadExt, Result};/// use tokio_util::io::StreamReader;/// // Create a stream from an iterator./// let stream = tokio_stream::iter(vec![///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),///     Result::Ok(Bytes::from_static(&[8, 9, 10, 11])),/// // Convert it to an AsyncRead./// let mut read = StreamReader::new(stream);/// // Read five bytes from the stream./// let mut buf = [0; 5];/// read.read_exact(&mut buf).await?;/// assert_eq!(buf, [0, 1, 2, 3, 4]);/// // Read the rest of the current chunk./// assert_eq!(read.read(&mut buf).await?, 3);/// assert_eq!(&buf[..3], [5, 6, 7]);/// // Read the next chunk./// assert_eq!(read.read(&mut buf).await?, 4);/// assert_eq!(&buf[..4], [8, 9, 10, 11]);/// // We have now reached the end./// assert_eq!(read.read(&mut buf).await?, 0);/// If the stream produces errors which are not [`std::io::Error`],/// the errors can be converted using [`StreamExt`] to map each/// element./// use tokio_stream::StreamExt;/// // Create a stream from an iterator, including an error.///     Result::Err("Something bad happened!")/// // Use StreamExt to map the stream and error to a std::io::Error/// let stream = stream.map(|result| result.map_err(|err| {///     std::io::Error::new(std::io::ErrorKind::Other, err)/// // Reading the next chunk will produce an error/// let error = read.read(&mut buf).await.unwrap_err();/// assert_eq!(error.kind(), std::io::ErrorKind::Other);/// assert_eq!(error.into_inner().unwrap().to_string(), "Something bad happened!");/// Using the [`AsyncBufRead`] impl, you can read a `Stream` of byte chunks/// line-by-line. Note that you will usually also need to convert the error/// type when doing this. See the second example for an explanation of how/// to do this./// use tokio::io::{Result, AsyncBufReadExt};/// // Create a stream of byte chunks.///     Result::Ok(b"The first line.\n".as_slice()),///     Result::Ok(b"The second line.".as_slice()),///     Result::Ok(b"\nThe third".as_slice()),///     Result::Ok(b" line.\nThe fourth line.\nThe fifth line.\n".as_slice()),/// // Loop through the lines from the `StreamReader`./// let mut lines = Vec::new();///     line.clear();///     let len = read.read_line(&mut line).await?;///     if len == 0 { break; }///     lines.push(line.clone());/// // Verify that we got the lines we expected.///     lines,///     vec![///         "The first line.\n",///         "The second line.\n",///         "The third line.\n",///         "The fourth line.\n",///         "The fifth line.\n",/// [`AsyncBufRead`]: tokio::io::AsyncBufRead/// [`ReaderStream`]: crate::io::ReaderStream/// [`StreamExt`]: https://docs.rs/tokio-stream/latest/tokio_stream/trait.StreamExt.html/// Convert a stream of byte chunks into an [`AsyncRead`]./// The item should be a [`Result`] with the ok variant being something that/// implements the [`Buf`] trait (e.g. `Cursor<Vec<u8>>` or `Bytes`). The error/// should be convertible into an [io error]./// [`Buf`]: bytes::Buf/// [io error]: std::io::Errorhas_chunk/// Do we have a chunk and is it non-empty?into_inner_with_chunk/// Consumes this `StreamReader`, returning a Tuple consisting/// of the underlying stream and an Option of the internal buffer,/// which is Some in case the buffer contains elements./// Gets a reference to the underlying stream./// It is inadvisable to directly read from the underlying stream./// Gets a mutable reference to the underlying stream./// Gets a pinned mutable reference to the underlying stream./// Consumes this `BufWriter`, returning the underlying stream./// If you additionally want access to the internal buffer use/// [`into_inner_with_chunk`]./// [`into_inner_with_chunk`]: crate::io::StreamReader::into_inner_with_chunkStreamReaderProject// The code below is a manual expansion of the code that pin-project-lite would// generate. This is done because pin-project-lite fails by hitting the recursion// limit on this struct. (Every line of documentation is handled recursively by// the macro.)/// Use a [`tokio::io::AsyncRead`] synchronously as a [`std::io::Read`] or/// a [`tokio::io::AsyncWrite`] synchronously as a [`std::io::Write`]./// In many cases, there are better alternatives to using `SyncIoBridge`, especially/// if you want to avoid blocking the async runtime. Consider the following scenarios:/// When hashing data, using `SyncIoBridge` can lead to suboptimal performance and/// might not fully leverage the async capabilities of the system./// ### Why It Matters:/// `SyncIoBridge` allows you to use asynchronous I/O operations in an synchronous/// context by blocking the current thread. However, this can be inefficient because:/// - **Inefficient Resource Usage**: `SyncIoBridge` takes up an entire OS thread,///   which is inefficient compared to asynchronous code that can multiplex many///   tasks on a single thread./// - **Thread Pool Saturation**: Excessive use of `SyncIoBridge` can exhaust the///   async runtime's thread pool, reducing the number of threads available for///   other tasks and impacting overall performance./// - **Missed Concurrency Benefits**: By using synchronous operations with///   `SyncIoBridge`, you lose the ability to interleave tasks efficiently,///   which is a key advantage of asynchronous programming./// ## Example 1: Hashing Data/// The use of `SyncIoBridge` is unnecessary when hashing data. Instead, you can/// process the data asynchronously by reading it into memory, which avoids blocking/// the async runtime./// There are two strategies for avoiding `SyncIoBridge` when hashing data. When/// the data fits into memory, the easiest is to read the data into a `Vec<u8>`/// and hash it:/// Explanation: This example demonstrates how to asynchronously read data from a/// reader into memory and hash it using a synchronous hashing function. The/// `SyncIoBridge` is avoided, ensuring that the async runtime is not blocked./// # mod blake3 { pub fn hash(_: &[u8]) {} }/// async fn hash_contents(mut reader: impl AsyncRead + Unpin) -> Result<(), std::io::Error> {///    // Read all data from the reader into a Vec<u8>.///    let mut data = Vec::new();///    reader.read_to_end(&mut data).await?;///    // Hash the data using the blake3 hashing function.///    let hash = blake3::hash(&data);///    Ok(hash)/// async fn main() -> Result<(), std::io::Error> {///     // Example: In-memory data.///     let data = b"Hello, world!"; // A byte slice.///     let reader = Cursor::new(data); // Create an in-memory AsyncRead.///     hash_contents(reader).await/// When the data doesn't fit into memory, the hashing library will usually/// provide a `hasher` that you can repeatedly call `update` on to hash the data/// one chunk at the time./// Explanation: This example demonstrates how to asynchronously stream data in/// chunks for hashing. Each chunk is read asynchronously, and the hash is updated/// incrementally. This avoids blocking and improves performance over using/// `SyncIoBridge`./// # struct Hasher;/// # impl Hasher { pub fn update(&mut self, _: &[u8]) {} pub fn finalize(&self) {} }/// /// Asynchronously streams data from an async reader, processes it in chunks,/// /// and hashes the data incrementally./// async fn hash_stream(mut reader: impl AsyncRead + Unpin, mut hasher: Hasher) -> Result<(), std::io::Error> {///    // Create a buffer to read data into, sized for performance.///    let mut data = vec![0; 64 * 1024];///    loop {///        // Read data from the reader into the buffer.///        let len = reader.read(&mut data).await?;///        if len == 0 { break; } // Exit loop if no more data.///        // Update the hash with the data read.///        hasher.update(&data[..len]);///    // Finalize the hash after all data has been processed.///    let hash = hasher.finalize();///     let hasher = Hasher;///     hash_stream(reader, hasher).await/// ## Example 2: Compressing Data/// When compressing data, the use of `SyncIoBridge` is unnecessary as it introduces/// blocking and inefficient code. Instead, you can utilize an async compression library/// such as the [`async-compression`](https://docs.rs/async-compression/latest/async_compression/)/// crate, which is built to handle asynchronous data streams efficiently./// Explanation: This example shows how to asynchronously compress data using an/// async compression library. By reading and writing asynchronously, it avoids/// blocking and is more efficient than using `SyncIoBridge` with a non-async/// compression library./// use async_compression::tokio::write::GzipEncoder;/// /// Asynchronously compresses data from an async reader using Gzip and an async encoder./// async fn compress_data(mut reader: impl AsyncRead + Unpin) -> Result<(), std::io::Error> {///    let writer = tokio::io::sink();///    // Create a Gzip encoder that wraps the writer.///    let mut encoder = GzipEncoder::new(writer);///    // Copy data from the reader to the encoder, compressing it.///    tokio::io::copy(&mut reader, &mut encoder).await?;///     compress_data(reader).await?;/// ## Example 3: Parsing Data Formats/// `SyncIoBridge` is not ideal when parsing data formats such as `JSON`, as it/// blocks async operations. A more efficient approach is to read data asynchronously/// into memory and then `deserialize` it, avoiding unnecessary synchronization overhead./// Explanation: This example shows how to asynchronously read data into memory/// and then parse it as `JSON`. By avoiding `SyncIoBridge`, the asynchronous runtime/// remains unblocked, leading to better performance when working with asynchronous/// I/O streams./// # mod serde {/// #     pub trait DeserializeOwned: 'static {}/// #     impl<T: 'static> DeserializeOwned for T {}/// #     use super::serde::DeserializeOwned;/// #     pub fn from_slice<T: DeserializeOwned>(_: &[u8]) -> Result<T, std::io::Error> {/// # #[derive(Debug)] struct MyStruct;/// async fn parse_json(mut reader: impl AsyncRead + Unpin) -> Result<MyStruct, std::io::Error> {///    // Deserialize the data from the Vec<u8> into a MyStruct instance.///    let value: MyStruct = serde_json::from_slice(&data)?;///    Ok(value)///     parse_json(reader).await?;/// ## Correct Usage of `SyncIoBridge` inside `spawn_blocking`/// `SyncIoBridge` is mainly useful when you need to interface with synchronous/// libraries from an asynchronous context./// Explanation: This example shows how to use `SyncIoBridge` inside a `spawn_blocking`/// task to safely perform synchronous I/O without blocking the async runtime. The/// `spawn_blocking` ensures that the synchronous code is offloaded to a dedicated/// thread pool, preventing it from interfering with the async tasks./// use tokio::task::spawn_blocking;/// use tokio_util::io::SyncIoBridge;/// /// Wraps an async reader with `SyncIoBridge` and performs synchronous I/O operations in a blocking task./// async fn process_sync_io(reader: impl AsyncRead + Unpin + Send + 'static) -> Result<Vec<u8>, std::io::Error> {///    // Wrap the async reader with `SyncIoBridge` to allow synchronous reading.///    let mut sync_reader = SyncIoBridge::new(reader);///    // Spawn a blocking task to perform synchronous I/O operations.///    let result = spawn_blocking(move || {///        // Create an in-memory buffer to hold the copied data.///        let mut buffer = Vec::new();///        // Copy data from the sync_reader to the buffer.///        std::io::copy(&mut sync_reader, &mut buffer)?;///        // Return the buffer containing the copied data.///        Ok::<_, std::io::Error>(buffer)///    .await??;///    // Return the result from the blocking task.///    Ok(result)///     let result = process_sync_io(reader).await?;///     // You can use `result` here as needed./// Determines if the underlying [`tokio::io::AsyncWrite`] target supports efficient vectored writes./// See [`tokio::io::AsyncWrite::is_write_vectored`].// Because https://doc.rust-lang.org/std/io/trait.Write.html#method.is_write_vectored is at the time// of this writing still unstable, we expose this as part of a standalone method./// Shutdown this writer. This method provides a way to call the [`AsyncWriteExt::shutdown`]/// function of the inner [`tokio::io::AsyncWrite`] instance./// This method returns the same errors as [`AsyncWriteExt::shutdown`]./// [`AsyncWriteExt::shutdown`]: tokio::io::AsyncWriteExt::shutdown/// a [`tokio::io::AsyncWrite`] as a [`std::io::Write`]./// When this struct is created, it captures a handle to the current thread's runtime with [`tokio::runtime::Handle::current`]./// It is hence OK to move this struct into a separate thread outside the runtime, as created/// by e.g. [`tokio::task::spawn_blocking`]./// Stated even more strongly: to make use of this bridge, you *must* move/// it into a separate thread outside the runtime.  The synchronous I/O will use the/// underlying handle to block on the backing asynchronous source, via/// [`tokio::runtime::Handle::block_on`].  As noted in the documentation for that/// function, an attempt to `block_on` from an asynchronous execution context/// # Wrapping `!Unpin` types/// Use e.g. `SyncIoBridge::new(Box::pin(src))`./// This will panic if called outside the context of a Tokio runtime./// This is the same as [`SyncIoBridge::new`], but allows passing an arbitrary handle and hence may/// be initially invoked outside of an asynchronous context./// Consume this bridge, returning the underlying stream.//! Utilities for working with Tokio.//! This crate is not versioned in lockstep with the core//! [`tokio`] crate. However, `tokio-util` _will_ respect Rust's//! semantic versioning policy, especially with regard to breaking changes.//! [`tokio`]: https://docs.rs/tokio/// The stream's type of this listener./// The socket address type of this listener.ListenerAcceptFut/// A trait for a listener: `TcpListener` and `UnixListener`./// Future for accepting a new connection from a listener.//! TCP/UDP/Unix helpers for tokio.//! Unix domain socket helpers.CancellationToken/// A wrapper for cancellation token which automatically cancels/// it on drop. It is created using `drop_guard` method on the `CancellationToken`.disarm/// Returns stored cancellation token and removes this drop guard instance/// (i.e. it will no longer cancel token). Other guards for this token/// are not affected.TreeNode/// A node of the cancellation tree structure/// The actual data it holds is wrapped inside a mutex for synchronization.parent_idxnum_handles/// The data contained inside a `TreeNode`./// This struct exists so that the data of the node can be wrapped/// in a Mutex./// Returns whether or not the node is cancelledchild_node/// Creates a child nodedisconnect_children/// Disconnects the given parent from all of its children./// Takes a reference to [Inner] to make sure the parent is already locked.with_locked_node_and_parent/// Figures out the parent of the node and locks the node and its parent atomically./// The basic principle of preventing deadlocks in the tree is/// that we always lock the parent first, and then the child./// For more info look at *deadlock safety* and *invariant #2*./// Sadly, it's impossible to figure out the parent of a node without/// locking it. To then achieve locking order consistency, the node/// has to be unlocked before the parent gets locked./// This leaves a small window where we already assume that we know the parent,/// but neither the parent nor the node is locked. Therefore, the parent could change./// To prevent that this problem leaks into the rest of the code, it is abstracted/// in this function./// The locked child and optionally its locked parent, if a parent exists, get passed/// to the `func` argument via (node, None) or (node, Some(parent)).move_children_to_parent/// Moves all children from `node` to `parent`./// `parent` MUST have been a parent of the node when they both got locked,/// otherwise there is a potential for a deadlock as invariant #2 would be violated./// To acquire the locks for node and parent, use [`with_locked_node_and_parent`].remove_child/// Removes a child from the parent./// `parent` MUST be the parent of `node`.increase_handle_refcount/// Increases the reference count of handles.decrease_handle_refcount/// Decreases the reference count of handles./// Once no handle is left, we can remove the node from the/// tree and connect its parent directly to its children./// Cancels a node and its children.//! This mod provides the logic for the inner tree structure of the `CancellationToken`.//! `CancellationTokens` are only light handles with references to [`TreeNode`].//! All the logic is actually implemented in the [`TreeNode`].//! A [`TreeNode`] is part of the cancellation tree and may have one parent and an arbitrary number of//! children.//! A [`TreeNode`] can receive the request to perform a cancellation through a `CancellationToken`.//! This cancellation request will cancel the node and all of its descendants.//! As soon as a node cannot get cancelled any more (because it was already cancelled or it has no//! more `CancellationTokens` pointing to it any more), it gets removed from the tree, to keep the//! tree as small as possible.//! # Invariants//! Those invariants shall be true at any time.//! 1. A node that has no parents and no handles can no longer be cancelled.//!     This is important during both cancellation and refcounting.//! 2. If node B *is* or *was* a child of node A, then node B was created *after* node A.//!     This is important for deadlock safety, as it is used for lock order.//!     Node B can only become the child of node A in two ways://!         - being created with `child_node()`, in which case it is trivially true that//!           node A already existed when node B was created//!         - being moved A->C->B to A->B because node C was removed in `decrease_handle_refcount()`//!           or `cancel()`. In this case the invariant still holds, as B was younger than C, and C//!           was younger than A, therefore B is also younger than A.//! 3. If two nodes are both unlocked and node A is the parent of node B, then node B is a child of//!    node A. It is important to always restore that invariant before dropping the lock of a node.//! # Deadlock safety//! We always lock in the order of creation time. We can prove this through invariant #2.//! Specifically, through invariant #2, we know that we always have to lock a parent//! before its child.tree_nodeMaybeDangling/// A token which can be used to signal a cancellation request to one or more/// Tasks can call [`CancellationToken::cancelled()`] in order to/// obtain a Future which will be resolved when cancellation is requested./// Cancellation can be requested through the [`CancellationToken::cancel`] method./// use tokio::select;/// use tokio_util::sync::CancellationToken;///     let token = CancellationToken::new();///     let cloned_token = token.clone();///     let join_handle = tokio::spawn(async move {///         // Wait for either cancellation or a very long time///             _ = cloned_token.cancelled() => {///                 // The token was cancelled///                 5///             _ = tokio::time::sleep(std::time::Duration::from_secs(9999)) => {///                 99///         tokio::time::sleep(std::time::Duration::from_millis(10)).await;///         token.cancel();///     assert_eq!(5, join_handle.await.unwrap());r" A Future that is resolved once the corresponding [`CancellationToken`]"r" is cancelled."cancellation_tokenWaitForCancellationFuturer" This is the counterpart to [`WaitForCancellationFuture`] that takes"r" [`CancellationToken`] by value instead of using a reference."WaitForCancellationFutureOwned/// Creates a clone of the `CancellationToken` which will get cancelled/// whenever the current token gets cancelled, and vice versa./// Creates a new `CancellationToken` in the non-cancelled state.child_token/// Creates a `CancellationToken` which will get cancelled whenever the/// current token gets cancelled. Unlike a cloned `CancellationToken`,/// cancelling a child token does not cancel the parent token./// If the current token is already cancelled, the child token will get/// returned in cancelled state.///     let child_token = token.child_token();///             _ = child_token.cancelled() => {/// Cancel the [`CancellationToken`] and all child tokens which had been/// derived from it./// This will wake up all tasks which are waiting for cancellation./// Be aware that cancellation is not an atomic operation. It is possible/// for another thread running in parallel with a call to `cancel` to first/// receive `true` from `is_cancelled` on one child node, and then receive/// `false` from `is_cancelled` on another child node. However, once the/// call to `cancel` returns, all child nodes have been fully cancelled./// Returns `true` if the `CancellationToken` is cancelled./// Returns a `Future` that gets fulfilled when cancellation is requested./// The future will complete immediately if the token is already cancelled/// when this method is called.cancelled_owned/// The function takes self by value and returns a future that owns thedrop_guard/// Creates a `DropGuard` for this token./// Returned guard will cancel this token (and all its children) on drop/// unless disarmed.run_until_cancelled/// Runs a future to completion and returns its result wrapped inside of an `Option`/// unless the `CancellationToken` is cancelled. In that case the function returns/// `None` and the future gets dropped./// This method is only cancel safe if `fut` is cancel safe.run_until_cancelled_owned/// The function takes self by value and returns a future that owns the token./// The returned future must be destroyed before the cancellation token is//! An asynchronously awaitable `CancellationToken`.//! The token allows to signal a cancellation request to one or more tasks.// ===== impl CancellationToken =====// ===== impl WaitForCancellationFuture =====// ===== impl WaitForCancellationFutureOwned =====PollSendErrorpoll_semaphorePollSemaphore//! Synchronization primitives/// Error returned by the `PollSender` when the channel is closed./// Consumes the stored value, if any./// If this error was encountered when calling `start_send`/`send_item`, this will be the item/// that the caller attempted to send.  Otherwise, it will be `None`.ReadyToSendPollSenderFuture/// A wrapper around [`mpsc::Sender`] that can be polled./// [`mpsc::Sender`]: tokio::sync::mpsc::Sendermake_acquire_future// Creates a future for acquiring a permit from the underlying channel.  This is used to ensure// there's capacity for a send to complete.// By reusing the same async fn for both `Some` and `None`, we make sure every future passed to// ReusableBoxFuture has the same underlying type, and hence the same size and alignment.InnerFuture// TODO: This should be replace with a type_alias_impl_trait to eliminate `'static` and all the transmutes/// Create with an empty inner future with no `Send` bound./// Create with an empty inner future./// Poll the inner future./// Replace the inner future./// Creates a new `PollSender`.poll_reserve/// Attempts to prepare the sender to receive a value./// This method must be called and return `Poll::Ready(Ok(()))` prior to each call to/// `send_item`./// This method returns `Poll::Ready` once the underlying channel is ready to receive a value,/// by reserving a slot in the channel for the item to be sent. If this method returns/// `Poll::Pending`, the current task is registered to be notified (via/// `cx.waker().wake_by_ref()`) when `poll_reserve` should be called again./// If the channel is closed, an error will be returned.  This is a permanent state.send_item/// Sends an item to the channel./// Before calling `send_item`, `poll_reserve` must be called with a successful return/// value of `Poll::Ready(Ok(()))`./// If `poll_reserve` was not successfully called prior to calling `send_item`, then this method/// Checks whether this sender is been closed./// The underlying channel that this sender was wrapping may still be open./// Gets a reference to the `Sender` of the underlying channel./// If `PollSender` has been closed, `None` is returned. The underlying channel that this sender/// was wrapping may still be open./// Closes this sender./// No more messages will be able to be sent from this sender, but the underlying channel will/// remain open until all senders have dropped, or until the [`Receiver`] closes the channel./// If a slot was previously reserved by calling `poll_reserve`, then a final call can be made/// to `send_item` in order to consume the reserved slot.  After that, no further sends will be/// possible.  If you do not intend to send another item, you can release the reserved slot back/// to the underlying sender by calling [`abort_send`]./// [`abort_send`]: crate::sync::PollSender::abort_send/// [`Receiver`]: tokio::sync::mpsc::Receiverabort_send/// Aborts the current in-progress send, if any./// Returns `true` if a send was aborted.  If the sender was closed prior to calling/// `abort_send`, then the sender will remain in the closed state, otherwise the sender will be/// ready to attempt another send./// Clones this `PollSender`./// The resulting `PollSender` will have an initial state identical to calling `PollSender::new`.permit_fut// The number of permits requested./// A wrapper around [`Semaphore`] that provides a `poll_acquire` method./// [`Semaphore`]: tokio::sync::Semaphore/// Create a new `PollSemaphore`./// Obtain a clone of the inner semaphore./// Get back the inner semaphore./// Poll to acquire a permit from the semaphore./// This can return the following values:///  - `Poll::Pending` if a permit is not currently available.///  - `Poll::Ready(Some(permit))` if a permit was acquired.///  - `Poll::Ready(None)` if the semaphore has been closed./// to receive a wakeup when a permit becomes available, or when the/// semaphore is closed. Note that on multiple calls to `poll_acquire`, onlypoll_acquire_many/// Poll to acquire many permits from the semaphore./// to receive a wakeup when the permits become available, or when the/// This is equivalent to the [`Semaphore::available_permits`] method on the/// `tokio::sync::Semaphore` type./// [`Semaphore::available_permits`]: tokio::sync::Semaphore::available_permits/// The maximum number of permits is [`Semaphore::MAX_PERMITS`], and this function/// will panic if the limit is exceeded./// This is equivalent to the [`Semaphore::add_permits`] method on the/// [`Semaphore::add_permits`]: tokio::sync::Semaphore::add_permits/// A reusable `Pin<Box<dyn Future<Output = T> + Send + 'a>>`./// Replace the future currently stored in this box./// Get a pinned reference to the underlying future./// Poll the future stored inside this box.reuse_pin_boxcancel_tokencancel_token_ownedcancel_with_childdrop_token_no_childdrop_token_with_childrendrop_and_cancel_tokencancel_parent_and_child"Dropping the handle aborts the task immediately"AbortOnDropHandle/// A wrapper around a [`tokio::task::JoinHandle`],/// which [aborts] the task when it is dropped./// [aborts]: tokio::task::JoinHandle::abort/// Create an [`AbortOnDropHandle`] from a [`JoinHandle`]./// Abort the task associated with this handle,/// equivalent to [`JoinHandle::abort`]./// Checks if the task associated with this handle is finished,/// equivalent to [`JoinHandle::is_finished`]./// Returns a new [`AbortHandle`] that can be used to remotely abort this task,/// equivalent to [`JoinHandle::abort_handle`].//! An [`AbortOnDropHandle`] is like a [`JoinHandle`], except that it//! will abort the task as soon as it is dropped.tasks_by_key/// A map of the [`AbortHandle`]s of the tasks spawned on this `JoinMap`,/// indexed by their keys and task IDs./// The [`Key`] type contains both the task's `K`-typed key provided when/// spawning tasks, and the task's IDs. The IDs are stored here to resolve/// hash collisions when looking up tasks based on their pre-computed hash/// (as stored in the `hashes_by_task` map).hashes_by_task/// A map from task IDs to the hash of the key associated with that task./// This map is used to perform reverse lookups of tasks in the/// `tasks_by_key` map based on their task IDs. When a task terminates, the/// ID is provided to us by the `JoinSet`, so we can look up the hash value/// of that task's key, and then remove it from the `tasks_by_key` map using/// the raw hash code, resolving collisions by comparing task IDs./// The [`JoinSet`] that awaits the completion of tasks spawned on this/// `JoinMap`.JoinMap/// A collection of tasks spawned on a Tokio runtime, associated with hash map/// This type is very similar to the [`JoinSet`] type in `tokio::task`, with the/// addition of a  set of keys associated with each task. These keys allow/// [cancelling a task][abort] or [multiple tasks][abort_matching] in the/// `JoinMap` based on   their keys, or [test whether a task corresponding to a/// given key exists][contains] in the `JoinMap`./// In addition, when tasks in the `JoinMap` complete, they will return the/// associated key along with the value returned by the task, if any./// A `JoinMap` can be used to await the completion of some or all of the tasks/// in the map. The map is not ordered, and the tasks will be returned in the/// All of the tasks must have the same return type `V`./// When the `JoinMap` is dropped, all tasks in the `JoinMap` are immediately aborted./// **Note**: This type depends on Tokio's [unstable API][unstable]. See [the/// Spawn multiple tasks and wait for them:/// use tokio_util::task::JoinMap;///     let mut map = JoinMap::new();///         // Spawn a task on the `JoinMap` with `i` as its key.///         map.spawn(i, async move { /* ... */ });///     // When a task completes, `join_next` returns the task's key along///     // with its output.///     while let Some((key, res)) = map.join_next().await {///         seen[key] = true;///         assert!(res.is_ok(), "task {} completed successfully!", key);/// Cancel tasks based on their keys:///     map.spawn("hello world", async move { /* ... */ });///     map.spawn("goodbye world", async move { /* ... */});///     // Look up the "goodbye world" task in the map and abort it.///     let aborted = map.abort("goodbye world");///     // `JoinMap::abort` returns `true` if a task existed for the///     // provided key.///     assert!(aborted);///         if key == "goodbye world" {///             // The aborted task should complete with a cancelled `JoinError`.///             assert!(res.unwrap_err().is_cancelled());///             // Other tasks should complete normally.///             assert!(res.is_ok());/// [`JoinSet`]: tokio::task::JoinSet/// [unstable]: tokio#unstable-features/// [abort]: fn@Self::abort/// [abort_matching]: fn@Self::abort_matching/// [contains]: fn@Self::contains_key/// A [`JoinMap`] key./// This holds both a `K`-typed key (the actual key as seen by the user), _and_/// a task ID, so that hash collisions between `K`-typed keys can be resolved/// using either `K`'s `Eq` impl *or* by checking the task IDs./// This allows looking up a task using either an actual key (such as when the/// user queries the map with a key), *or* using a task ID and a hash (such as/// when removing completed tasks from the map)./// Creates a new empty `JoinMap`./// The `JoinMap` is initially created with a capacity of 0, so it will not/// allocate until a task is first spawned on it./// let map: JoinMap<&str, i32> = JoinMap::new();/// Creates an empty `JoinMap` with the specified capacity./// The `JoinMap` will be able to hold at least `capacity` tasks without/// reallocating./// let map: JoinMap<&str, i32> = JoinMap::with_capacity(10);/// Creates an empty `JoinMap` which will use the given hash builder to hash/// is designed to allow `JoinMap` to be resistant to attacks that/// the `JoinMap` to be useful, see its documentation for details./// Creates an empty `JoinMap` with the specified capacity, using `hash_builder`/// The `JoinMap` will be able to hold at least `capacity` elements without/// reallocating. If `capacity` is 0, the `JoinMap` will not allocate./// the `JoinMap`to be useful, see its documentation for details./// let mut map = JoinMap::with_capacity_and_hasher(10, s);/// map.spawn(1, async move { "hello world!" });/// Returns the number of tasks currently in the `JoinMap`./// Returns whether the `JoinMap` is empty./// Returns the number of tasks the map can hold without reallocating./// This number is a lower bound; the `JoinMap` might be able to hold/// let map: JoinMap<i32, i32> = JoinMap::with_capacity(100);/// Spawn the provided task and store it in this `JoinMap` with the provided/// If a task previously existed in the `JoinMap` for this key, that task/// will be cancelled and replaced with the new one. The previous task will/// be removed from the `JoinMap`; a subsequent call to [`join_next`] will/// *not* return a cancelled [`JoinError`] for that task./// [`join_next`]: Self::join_next/// `JoinMap` with the provided key./// Spawn the blocking code on the blocking threadpool and store it in this `JoinMap` with the provided/// Note that blocking tasks cannot be cancelled after execution starts./// Replaced blocking tasks will still run to completion if the task has begun/// to execute when it is replaced. A blocking task which is replaced before/// it has been scheduled on a blocking worker thread will be cancelled./// Spawn the blocking code on the blocking threadpool of the provided runtime and store it in this/// [`LocalSet`]: tokio::task::LocalSet/// this `JoinMap` with the provided key./// Waits until one of the tasks in the map completes and returns its/// output, along with the key corresponding to that task./// Returns `None` if the map is empty./// This method is cancel safe. If `join_next` is used as the event in a [`tokio::select!`]/// removed from this `JoinMap`.///  * `Some((key, Ok(value)))` if one of the tasks in this `JoinMap` has///    completed. The `value` is the return value of that ask, and `key` is///    the key associated with the task.///  * `Some((key, Err(err))` if one of the tasks in this `JoinMap` has///    panicked or been aborted. `key` is the key associated  with the task///    that panicked or was aborted.///  * `None` if the `JoinMap` is empty./// [`tokio::select!`]: tokio::select/// `JoinMap` will be empty./// Abort the task corresponding to the provided `key`./// If this `JoinMap` contains a task corresponding to `key`, this method/// will abort that task and return `true`. Otherwise, if no task exists for/// `key`, this method returns `false`./// Aborting a task by key:/// let mut map = JoinMap::new();/// map.spawn("hello world", async move { /* ... */ });/// map.spawn("goodbye world", async move { /* ... */});/// // Look up the "goodbye world" task in the map and abort it./// map.abort("goodbye world");/// while let Some((key, res)) = map.join_next().await {///     if key == "goodbye world" {///         // The aborted task should complete with a cancelled `JoinError`.///         assert!(res.unwrap_err().is_cancelled());///         // Other tasks should complete normally.///         assert!(res.is_ok());/// `abort` returns `true` if a task was aborted:/// // A task for the key "goodbye world" should exist in the map:/// assert!(map.abort("goodbye world"));/// // Aborting a key that does not exist will return `false`:/// assert!(!map.abort("goodbye universe"));abort_matching/// Aborts all tasks with keys matching `predicate`./// `predicate` is a function called with a reference to each key in the/// map. If it returns `true` for a given key, the corresponding task will/// be cancelled./// # // use the current thread rt so that spawned tasks don't/// # // complete in the background before they can be aborted./// map.spawn("hello world", async move {///     # tokio::task::yield_now().await; // don't complete immediately, get aborted!/// map.spawn("goodbye world", async move {/// map.spawn("hello san francisco", async move {/// map.spawn("goodbye universe", async move {/// // Abort all tasks whose keys begin with "goodbye"/// map.abort_matching(|key| key.starts_with("goodbye"));/// let mut seen = 0;///     seen += 1;///     if key.starts_with("goodbye") {///         assert!(key.starts_with("hello"));/// // All spawned tasks should have completed./// assert_eq!(seen, 4);JoinMapKeys/// Returns an iterator visiting all keys in this `JoinMap` in arbitrary order./// If a task has completed, but its output hasn't yet been consumed by a/// call to [`join_next`], this method will still return its key./// Returns `true` if this `JoinMap` contains a task for the provided key./// If the task has completed, but its output hasn't yet been consumed by a/// call to [`join_next`], this method will still return `true`.contains_task/// Returns `true` if this `JoinMap` contains a task with the provided/// [task ID]./// [task ID]: tokio::task::Id/// Reserves capacity for at least `additional` more tasks to be spawned/// on this `JoinMap` without reallocating for the map of task keys. The/// collection may reserve more space to avoid frequent reallocations./// Note that spawning a task will still cause an allocation for the task/// let mut map: JoinMap<&str, i32> = JoinMap::new();/// Shrinks the capacity of the `JoinMap` as much as possible. It will drop/// let mut map: JoinMap<i32, i32> = JoinMap::with_capacity(100);/// map.spawn(1, async move { 2 });/// map.spawn(3, async move { 4 });/// If the current capacity is less than the lower limit, this is a no-op.get_by_key/// Look up a task in the map by its key, returning the key and abort handle.get_by_id/// Look up a task in the map by its task ID, returning the key and abort handle.remove_by_id/// Remove a task from the map by ID, returning the key for that task./// Returns the hash for a given key./// Aborts all tasks on this `JoinMap`./// This does not remove the tasks from the `JoinMap`. To wait for the tasks to complete/// cancellation, you should call `join_next` in a loop until the `JoinMap` is empty./// Removes all tasks from this `JoinMap` without aborting them./// The tasks removed by this call will continue to run in the background even if the `JoinMap`/// is dropped. They may still be aborted by key.// Hand-written `fmt::Debug` implementation in order to avoid requiring `V:// Debug`, since no value is ever actually stored in the map.// Don't include the task ID in the hash.// Because we override `Hash` for this type, we must also override the// `PartialEq` impl, so that all instances with the same hash are equal./// To make it easier to change `JoinMap` in the future, keep V as a generic/// An iterator over the keys of a [`JoinMap`].// === impl Key ===spawn_pinnedLocalPoolHandletask_trackerTaskTrackerabort_on_drop//! Extra utilities for spawning tasks/// A cloneable handle to a local pool, used for spawning `!Send` tasks./// Internally the local pool uses a [`tokio::task::LocalSet`] for each worker thread/// in the pool. Consequently you can also use [`tokio::task::spawn_local`] (which will/// execute on the same thread) inside the Future you supply to the various spawn methods/// of `LocalPoolHandle`./// [`tokio::task::LocalSet`]: tokio::task::LocalSet/// [`tokio::task::spawn_local`]: tokio::task::spawn_local/// use tokio_util::task::LocalPoolHandle;///     let pool = LocalPoolHandle::new(5);///     let output = pool.spawn_pinned(|| {///         // `data` is !Send + !Sync///         let data = Rc::new("local data");///         let data_clone = data.clone();///         async move {///             task::spawn_local(async move {///                 println!("{}", data_clone);///             data.to_string()///     }).await.unwrap();///     println!("output: {}", output);/// Create a new pool of threads to handle `!Send` tasks. Spawn tasks onto this/// pool via [`LocalPoolHandle::spawn_pinned`]./// Panics if the pool size is less than one./// Returns the number of threads of the Pool.get_task_loads_for_each_worker/// Returns the number of tasks scheduled on each worker. The indices of the/// worker threads correspond to the indices of the returned `Vec`./// Spawn a task onto a worker thread and pin it there so it can't be moved/// off of the thread. Note that the future is not [`Send`], but the/// [`FnOnce`] which creates it is.///     // Create the local pool///     let pool = LocalPoolHandle::new(1);///     // Spawn a !Send future onto the pool and await it///     let output = pool///         .spawn_pinned(|| {///             // Rc is !Send + !Sync///             let local_data = Rc::new("test");///             // This future holds an Rc, so it is !Send///             async move { local_data.to_string() }///     assert_eq!(output, "test");spawn_pinned_by_idx/// Differs from `spawn_pinned` only in that you can choose a specific worker thread/// of the pool, whereas `spawn_pinned` chooses the worker with the smallest/// number of tasks scheduled./// A worker thread is chosen by index. Indices are 0 based and the largest index/// is given by `num_threads() - 1`/// This method panics if the index is out of bounds./// This method can be used to spawn a task on all worker threads of the pool:///     const NUM_WORKERS: usize = 3;///     let pool = LocalPoolHandle::new(NUM_WORKERS);///     let handles = (0..pool.num_threads())///         .map(|worker_idx| {///             pool.spawn_pinned_by_idx(///                 || {///                     async {///                         "test"///                 worker_idx,///         .collect::<Vec<_>>();///     for handle in handles {WorkerChoiceLeastBurdenedByIdxLocalWorkerHandle/// Spawn a `?Send` future onto a workerfind_and_incr_least_burdened_workerJobCountGuard/// Find the worker with the least number of tasks, increment its task/// count, and return its handle. Make sure to actually spawn a task on/// the worker so the task count is kept consistent with load./// A job count guard is also returned to ensure the task count gets/// decremented when the job is done.find_worker_by_idx/// Automatically decrements a worker's job count when a job finishes (when/// this gets dropped)./// Calls abort on the handle when dropped.PinnedFutureSpawnerruntime_handletask_countnew_worker/// Create a new worker for executing pinned tasksTaskTrackerInner/// A task tracker used for waiting until tasks exit./// This is usually used together with [`CancellationToken`] to implement [graceful shutdown]. The/// `CancellationToken` is used to signal to tasks that they should shut down, and the/// `TaskTracker` is used to wait for them to finish shutting down./// The `TaskTracker` will also keep track of a `closed` boolean. This is used to handle the case/// where the `TaskTracker` is empty, but we don't want to shut down yet. This means that the/// [`wait`] method will wait until *both* of the following happen at the same time:///  * The `TaskTracker` must be closed using the [`close`] method.///  * The `TaskTracker` must be empty, that is, all tasks that it is tracking must have exited./// When a call to [`wait`] returns, it is guaranteed that all tracked tasks have exited and that/// the destructor of the future has finished running. However, there might be a short amount of/// time where [`JoinHandle::is_finished`] returns false./// # Comparison to `JoinSet`/// The main Tokio crate has a similar collection known as [`JoinSet`]. The `JoinSet` type has a/// lot more features than `TaskTracker`, so `TaskTracker` should only be used when one of its/// unique features is required:///  1. When tasks exit, a `TaskTracker` will allow the task to immediately free its memory.///  2. By not closing the `TaskTracker`, [`wait`] will be prevented from returning even if///     the `TaskTracker` is empty.///  3. A `TaskTracker` does not require mutable access to insert tasks.///  4. A `TaskTracker` can be cloned to share it with many tasks./// The first point is the most important one. A [`JoinSet`] keeps track of the return value of/// every inserted task. This means that if the caller keeps inserting tasks and never calls/// [`join_next`], then their return values will keep building up and consuming memory, _even if_/// most of the tasks have already exited. This can cause the process to run out of memory. With a/// `TaskTracker`, this does not happen. Once tasks exit, they are immediately removed from the/// `TaskTracker`./// Note that unlike [`JoinSet`], dropping a `TaskTracker` does not abort the tasks./// For more examples, please see the topic page on [graceful shutdown]./// ## Spawn tasks and wait for them to exit/// This is a simple example. For this case, [`JoinSet`] should probably be used instead./// use tokio_util::task::TaskTracker;///     let tracker = TaskTracker::new();///         tracker.spawn(async move {///             println!("Task {} is running!", i);///     // Once we spawned everything, we close the tracker.///     tracker.close();///     // Wait for everything to finish.///     tracker.wait().await;///     println!("This is printed after all of the tasks.");/// ## Wait for tasks to exit/// This example shows the intended use-case of `TaskTracker`. It is used together with/// [`CancellationToken`] to implement graceful shutdown./// async fn background_task(num: u64) {///         time::sleep(Duration::from_millis(100*num)).await;///         println!("Background task {} in iteration {}.", num, i);///         let token = token.clone();///             // Use a `tokio::select!` to kill the background task if the token is///             // cancelled.///             tokio::select! {///                 () = background_task(i) => {///                     println!("Task {} exiting normally.", i);///                 () = token.cancelled() => {///                     // Do some cleanup before we really exit.///                     time::sleep(Duration::from_millis(50)).await;///                     println!("Task {} finished cleanup.", i);///     // Spawn a background task that will send the shutdown signal.///         let tracker = tracker.clone();///             // Normally you would use something like ctrl-c instead of///             // sleeping.///             time::sleep(Duration::from_secs(2)).await;///             tracker.close();///             token.cancel();///     // Wait for all tasks to exit.///     println!("All tasks have exited now.");/// [`CancellationToken`]: crate::sync::CancellationToken/// [`JoinHandle::is_finished`]: tokio::task::JoinHandle::is_finished/// [`join_next`]: tokio::task::JoinSet::join_next/// [`wait`]: Self::wait/// [graceful shutdown]: https://tokio.rs/tokio/topics/shutdownTaskTrackerToken/// Represents a task tracked by a [`TaskTracker`]./// Keeps track of the state./// The lowest bit is whether the task tracker is closed./// The rest of the bits count the number of tracked tasks.on_last_exit/// Used to notify when the last task exits.r" A future that is tracked as a task by a [`TaskTracker`]."r" The associated [`TaskTracker`] cannot complete until this future is dropped."r" This future is returned by [`TaskTracker::track_future`]."TrackedFuturer" A future that completes when the [`TaskTracker`] is empty and closed."r" This future is returned by [`TaskTracker::wait`]."TaskTrackerWaitFutureis_closed_and_emptyset_openadd_tasknotify_now/// Creates a new `TaskTracker`./// The `TaskTracker` will start out as open./// Waits until this `TaskTracker` is both closed and empty./// If the `TaskTracker` is already closed and empty when this method is called, then it/// returns immediately./// The `wait` future is resistant against [ABA problems][aba]. That is, if the `TaskTracker`/// becomes both closed and empty for a short amount of time, then it is guarantee that all/// `wait` futures that were created before the short time interval will trigger, even if they/// are not polled during that short time interval./// However, the resistance against [ABA problems][aba] is lost when using `wait` as the/// condition in a `tokio::select!` loop./// [aba]: https://en.wikipedia.org/wiki/ABA_problem/// Close this `TaskTracker`./// This allows [`wait`] futures to complete. It does not prevent you from spawning new tasks./// Returns `true` if this closed the `TaskTracker`, or `false` if it was already closed./// Reopen this `TaskTracker`./// This prevents [`wait`] futures from completing even if the `TaskTracker` is empty./// Returns `true` if this reopened the `TaskTracker`, or `false` if it was already open./// Returns `true` if this `TaskTracker` is [closed](Self::close)./// Returns the number of tasks tracked by this `TaskTracker`./// Returns `true` if there are no tasks in this `TaskTracker`./// Spawn the provided future on the current Tokio runtime, and track it in this `TaskTracker`./// This is equivalent to `tokio::spawn(tracker.track_future(task))`./// Spawn the provided future on the provided Tokio runtime, and track it in this `TaskTracker`./// This is equivalent to `handle.spawn(tracker.track_future(task))`./// Spawn the provided future on the current [`LocalSet`], and track it in this `TaskTracker`./// This is equivalent to `tokio::task::spawn_local(tracker.track_future(task))`./// Spawn the provided future on the provided [`LocalSet`], and track it in this `TaskTracker`./// This is equivalent to `local_set.spawn_local(tracker.track_future(task))`./// Spawn the provided blocking task on the current Tokio runtime, and track it in this `TaskTracker`./// This is equivalent to `tokio::task::spawn_blocking(tracker.track_future(task))`./// Spawn the provided blocking task on the provided Tokio runtime, and track it in this `TaskTracker`./// This is equivalent to `handle.spawn_blocking(tracker.track_future(task))`.track_future/// Track the provided future./// The returned [`TrackedFuture`] will count as a task tracked by this collection, and will/// prevent calls to [`wait`] from returning until the task is dropped./// The task is removed from the collection when it is dropped, not when [`poll`] returns/// [`Poll::Ready`]./// Track a future spawned with [`tokio::spawn`]./// # async fn my_async_fn() {}/// let tracker = TaskTracker::new();/// tokio::spawn(tracker.track_future(my_async_fn()));/// Track a future spawned on a [`JoinSet`]./// let mut join_set = JoinSet::new();/// join_set.spawn(tracker.track_future(my_async_fn()));/// [`Poll::Pending`]: std::task::Poll::Pending/// Creates a [`TaskTrackerToken`] representing a task tracked by this `TaskTracker`./// This token is a lower-level utility than the spawn methods. Each token is considered to/// correspond to a task. As long as the token exists, the `TaskTracker` cannot complete./// Furthermore, the count returned by the [`len`] method will include the tokens in the count./// Dropping the token indicates to the `TaskTracker` that the task has exited./// [`len`]: TaskTracker::len/// Returns `true` if both task trackers correspond to the same set of tasks./// let tracker_1 = TaskTracker::new();/// let tracker_2 = TaskTracker::new();/// let tracker_1_clone = tracker_1.clone();/// assert!(TaskTracker::ptr_eq(&tracker_1, &tracker_1_clone));/// assert!(!TaskTracker::ptr_eq(&tracker_1, &tracker_2));/// Returns a new `TaskTracker` that tracks the same set of tasks./// Since the new `TaskTracker` shares the same set of tasks, changes to one set are visible in/// all other clones.///     let cloned = tracker.clone();///     // Spawns on `tracker` are visible in `cloned`.///     tracker.spawn(std::future::pending::<()>());///     assert_eq!(cloned.len(), 1);///     // Spawns on `cloned` are visible in `tracker`.///     cloned.spawn(std::future::pending::<()>());///     assert_eq!(tracker.len(), 2);///     // Calling `close` is visible to `cloned`.///     assert!(cloned.is_closed());///     // Calling `reopen` is visible to `tracker`.///     cloned.reopen();///     assert!(!tracker.is_closed());debug_inner/// Returns the [`TaskTracker`] that this token is associated with./// Returns a new `TaskTrackerToken` associated with the same [`TaskTracker`]./// This is equivalent to `token.task_tracker().token()`./// Dropping the token indicates to the [`TaskTracker`] that the task has exited.//! Types related to the [`TaskTracker`] collection.//! See the documentation of [`TaskTracker`] for more information.SlabStorage/// Stores data associated with entries/// Lookup structure tracking all delays in the queue/// Delays that were inserted when already expired. These cannot be stored/// in the wheel/// Delay expiring when the *first* item in the queue expireswheel_now/// Wheel polling state/// Instant at which the timer starts/// Waker that is invoked when we potentially need to reset the timer./// Because we lazily create the timer when the first entry is created, we/// need to awaken any poller that polled us before that point.DelayQueue/// A queue of delayed elements./// Once an element is inserted into the `DelayQueue`, it is yielded once the/// specified deadline has been reached./// Elements are inserted into `DelayQueue` using the [`insert`] or/// [`insert_at`] methods. A deadline is provided with the item and a [`Key`] is/// returned. The key is used to remove the entry or to change the deadline at/// which it should be yielded back./// Once delays have been configured, the `DelayQueue` is used via its/// [`Stream`] implementation. [`poll_expired`] is called. If an entry has reached its/// deadline, it is returned. If not, `Poll::Pending` is returned indicating that the/// current task will be notified once the deadline has been reached./// # `Stream` implementation/// Items are retrieved from the queue via [`DelayQueue::poll_expired`]. If no delays have/// expired, no items are returned. In this case, `Poll::Pending` is returned and the/// current task is registered to be notified once the next item's delay has/// expired./// If no items are in the queue, i.e. `is_empty()` returns `true`, then `poll`/// returns `Poll::Ready(None)`. This indicates that the stream has reached an end./// However, if a new item is inserted *after*, `poll` will once again start/// returning items or `Poll::Pending`./// Items are returned ordered by their expirations. Items that are configured/// to expire first will be returned first. There are no ordering guarantees/// for items configured to expire at the same instant. Also note that delays are/// rounded to the closest millisecond./// The [`DelayQueue`] is backed by a separate instance of a timer wheel similar to that used internally/// by Tokio's standalone timer utilities such as [`sleep`]. Because of this, it offers the same/// performance and scalability benefits./// State associated with each entry is stored in a [`slab`]. This amortizes the cost of allocation,/// and allows reuse of the memory allocated for expired entries./// Capacity can be checked using [`capacity`] and allocated preemptively by using/// the [`reserve`] method./// Using `DelayQueue` to manage cache entries./// use tokio_util::time::{DelayQueue, delay_queue};/// # type CacheKey = String;/// # type Value = String;/// struct Cache {///     entries: HashMap<CacheKey, (Value, delay_queue::Key)>,///     expirations: DelayQueue<CacheKey>,/// const TTL_SECS: u64 = 30;/// impl Cache {///     fn insert(&mut self, key: CacheKey, value: Value) {///         let delay = self.expirations///             .insert(key.clone(), Duration::from_secs(TTL_SECS));///         self.entries.insert(key, (value, delay));///     fn get(&self, key: &CacheKey) -> Option<&Value> {///         self.entries.get(key)///             .map(|&(ref v, _)| v)///     fn remove(&mut self, key: &CacheKey) {///         if let Some((_, cache_key)) = self.entries.remove(key) {///             self.expirations.remove(&cache_key);///     fn poll_purge(&mut self, cx: &mut Context<'_>) -> Poll<()> {///         while let Some(entry) = ready!(self.expirations.poll_expired(cx)) {///             self.entries.remove(entry.get_ref());/// [`insert`]: method@Self::insert/// [`insert_at`]: method@Self::insert_at/// [`Key`]: struct@Key/// [`Stream`]: https://docs.rs/futures/0.1/futures/stream/trait.Stream.html/// [`poll_expired`]: method@Self::poll_expired/// [`Stream::poll_expired`]: method@Self::poll_expired/// [`DelayQueue`]: struct@DelayQueue/// [`slab`]: slab/// [`capacity`]: method@Self::capacity/// [`reserve`]: method@Self::reserveKeyInternal// A `compact` call requires a re-mapping of the `Key`s that were changed// during the `compact` call of the `slab`. Since the keys that were given out// cannot be changed retroactively we need to keep track of these re-mappings.// The keys of `key_map` correspond to the old keys that were given out and// the values to the `Key`s that were re-mapped by the `compact` call.next_key_index// Index used to create new keys to hand out.compact_called// Whether `compact` has been called, necessary in order to decide whether// to include keys in `key_map`.// Inserts data into the inner slab and re-maps keys if necessary// Re-map the key in case compact was previously called.// Note: Since we include identity mappings in key_map after compact was called,// we have information about all keys that were handed out. In the case in which// compact was called and we try to remove a Key that was previously removed// we can detect invalid keys if no key is found in `key_map`. This is necessary// in order to prevent situations in which a previously removed key// corresponds to a re-mapped key internally and which would then be incorrectly// removed from the slab.// Example to illuminate this problem:// Let's assume our `key_map` is {1 -> 2, 2 -> 1} and we call remove(1). If we// were to remove 1 again, we would not find it inside `key_map` anymore.// If we were to imply from this that no re-mapping was necessary, we would// incorrectly remove 1 from `self.slab.inner`, which corresponds to the// handed-out key 2.remap_key// Tries to re-map a `Key` that was given out to the user to its// corresponding internal key.create_new_key/// The data stored in the queue/// The expiration time/// The key associated with the entry/// An entry in `DelayQueue` that has expired and been removed./// Values are returned by [`DelayQueue::poll_expired`]./// [`DelayQueue::poll_expired`]: method@DelayQueue::poll_expired/// Token to a value stored in a `DelayQueue`./// Instances of `Key` are returned by [`DelayQueue::insert`]. See [`DelayQueue`]/// [`DelayQueue::insert`]: method@DelayQueue::insert// Whereas `Key` is given out to users that use `DelayQueue`, internally we use// `KeyInternal` as the key type in order to make the logic of mapping between keys// as a result of `compact` calls clearer./// Head of the stack/// The data being stored in the queue and will be returned at the requested/// instant./// The instant at which the item is returned./// Set to true when stored in the `expired` queue/// Next entry in the stack/// Previous entry in the stackMAX_ENTRIES/// Maximum number of entries the queue can handle/// Creates a new, empty, `DelayQueue`./// The queue will not allocate storage until items are inserted into it./// # use tokio_util::time::DelayQueue;/// let delay_queue: DelayQueue<u32> = DelayQueue::new();/// Creates a new, empty, `DelayQueue` with the specified capacity./// The queue will be able to hold at least `capacity` elements without/// reallocating. If `capacity` is 0, the queue will not allocate for/// let mut delay_queue = DelayQueue::with_capacity(10);/// // These insertions are done without further allocation///     delay_queue.insert(i, Duration::from_secs(i));/// // This will make the queue allocate additional storage/// delay_queue.insert(11, Duration::from_secs(11));/// Inserts `value` into the queue set to expire at a specific instant in/// This function is identical to `insert`, but takes an `Instant` instead/// of a `Duration`./// `value` is stored in the queue until `when` is reached. At which point,/// `value` will be returned from [`poll_expired`]. If `when` has already been/// reached, then `value` is immediately made available to poll./// The return value represents the insertion and is used as an argument to/// [`remove`] and [`reset`]. Note that [`Key`] is a token and is reused once/// `value` is removed from the queue either by calling [`poll_expired`] after/// `when` is reached or by calling [`remove`]. At this point, the caller/// must take care to not use the returned [`Key`] again as it may reference/// a different item in the queue./// See [type] level documentation for more details./// This function panics if `when` is too far in the future./// use tokio_util::time::DelayQueue;/// let mut delay_queue = DelayQueue::new();/// let key = delay_queue.insert_at(///     "foo", Instant::now() + Duration::from_secs(5));/// // Remove the entry/// let item = delay_queue.remove(&key);/// assert_eq!(*item.get_ref(), "foo");/// [`remove`]: method@Self::remove/// [`reset`]: method@Self::reset/// [type]: #poll_expired/// Attempts to pull out the next value of the delay queue, registering the/// `None` if the queue is exhausted./// Inserts `value` into the queue set to expire after the requested duration/// elapses./// This function is identical to `insert_at`, but takes a `Duration`/// instead of an `Instant`./// `value` is stored in the queue until `timeout` duration has/// elapsed after `insert` was called. At that point, `value` will/// be returned from [`poll_expired`]. If `timeout` is a `Duration` of/// zero, then `value` is immediately made available to poll./// The return value represents the insertion and is used as an/// argument to [`remove`] and [`reset`]. Note that [`Key`] is a/// token and is reused once `value` is removed from the queue/// either by calling [`poll_expired`] after `timeout` has elapsed/// or by calling [`remove`]. At this point, the caller must not/// use the returned [`Key`] again as it may reference a different/// item in the queue./// This function panics if `timeout` is greater than the maximum/// duration supported by the timer in the current `Runtime`./// let key = delay_queue.insert("foo", Duration::from_secs(5));insert_idx/// Returns the deadline of the item associated with `key`./// Since the queue operates at millisecond granularity, the returned/// deadline may not exactly match the value that was given when initially/// inserting the item into the queue./// This function panics if `key` is not contained by the queue./// let key1 = delay_queue.insert("foo", Duration::from_secs(5));/// let key2 = delay_queue.insert("bar", Duration::from_secs(10));/// assert!(delay_queue.deadline(&key1) < delay_queue.deadline(&key2));/// Removes the key from the expired queue or the timer wheel/// depending on its expiration status./// Panics if the key is not contained in the expired queue or the wheel./// Removes the item associated with `key` from the queue./// There must be an item associated with `key`. The function returns the/// removed item as well as the `Instant` at which it will the delay will/// have expired./// The function panics if `key` is not contained by the queue./// Attempts to remove the item associated with `key` from the queue./// Removes the item associated with `key`, and returns it along with the/// `Instant` at which it would have expired, if it exists./// Returns `None` if `key` is not in the queue./// // The item is in the queue, `try_remove` returns `Some(Expired("foo"))`./// let item = delay_queue.try_remove(&key);/// assert_eq!(item.unwrap().into_inner(), "foo");/// // The item is not in the queue anymore, `try_remove` returns `None`./// assert!(item.is_none());/// Sets the delay of the item associated with `key` to expire at `when`./// This function is identical to `reset` but takes an `Instant` instead of/// a `Duration`./// The item remains in the queue but the delay is set to expire at `when`./// If `when` is in the past, then the item is immediately made available to/// This function panics if `when` is too far in the future or if `key` is/// not contained by the queue./// // "foo" is scheduled to be returned in 5 seconds/// delay_queue.reset_at(&key, Instant::now() + Duration::from_secs(10));/// // "foo" is now scheduled to be returned in 10 seconds/// Shrink the capacity of the slab, which `DelayQueue` uses internally for storage allocation./// This function is not guaranteed to, and in most cases, won't decrease the capacity of the slab/// to the number of elements still contained in it, because elements cannot be moved to a different/// index. To decrease the capacity to the size of the slab use [`compact`]./// This function can take O(n) time even when the capacity cannot be reduced or the allocation is/// shrunk in place. Repeated calls run in O(1) though./// [`compact`]: method@Self::compact/// Shrink the capacity of the slab, which `DelayQueue` uses internally for storage allocation,/// to the number of elements that are contained in it./// This methods runs in O(n)./// let key1 = delay_queue.insert(5, Duration::from_secs(5));/// let key2 = delay_queue.insert(10, Duration::from_secs(10));/// let key3 = delay_queue.insert(15, Duration::from_secs(15));/// delay_queue.remove(&key2);/// delay_queue.compact();/// assert_eq!(delay_queue.capacity(), 2);/// Gets the [`Key`] that [`poll_expired`] will pull out of the queue next, without/// pulling it out or waiting for the deadline to expire./// Entries that have already expired may be returned in any order, but it is/// guaranteed that this method returns them in the same order as when items/// are popped from the `DelayQueue`./// let key1 = delay_queue.insert("foo", Duration::from_secs(10));/// let key2 = delay_queue.insert("bar", Duration::from_secs(5));/// let key3 = delay_queue.insert("baz", Duration::from_secs(15));/// assert_eq!(delay_queue.peek().unwrap(), key2);/// Returns the next time to poll as determined by the wheel./// Note that this does not include deadlines in the `expired` queue./// Sets the delay of the item associated with `key` to expire after/// `timeout`./// This function is identical to `reset_at` but takes a `Duration` instead/// of an `Instant`./// The item remains in the queue but the delay is set to expire after/// `timeout`. If `timeout` is zero, then the item is immediately made/// available to the caller./// This function panics if `timeout` is greater than the maximum supported/// duration or if `key` is not contained by the queue./// delay_queue.reset(&key, Duration::from_secs(10));/// // "foo"is now scheduled to be returned in 10 seconds/// Clears the queue, removing all items./// After calling `clear`, [`poll_expired`] will return `Ok(Ready(None))`./// Note that this method has no effect on the allocated capacity./// delay_queue.insert("foo", Duration::from_secs(5));/// assert!(!delay_queue.is_empty());/// delay_queue.clear();/// assert!(delay_queue.is_empty());/// Returns the number of elements the queue can hold without reallocating./// let delay_queue: DelayQueue<i32> = DelayQueue::with_capacity(10);/// assert_eq!(delay_queue.capacity(), 10);/// Returns the number of elements currently in the queue./// let mut delay_queue: DelayQueue<i32> = DelayQueue::with_capacity(10);/// assert_eq!(delay_queue.len(), 0);/// delay_queue.insert(3, Duration::from_secs(5));/// assert_eq!(delay_queue.len(), 1);/// Reserves capacity for at least `additional` more items to be queued/// `reserve` does nothing if the queue already has sufficient capacity for/// As such, if the queue is already very large, a call to `reserve` can end/// The queue may reserve more than `additional` extra space in order to/// avoid frequent reallocations./// Panics if the new capacity exceeds the maximum number of entries the/// queue can contain./// delay_queue.insert("hello", Duration::from_secs(10));/// delay_queue.reserve(10);/// assert!(delay_queue.capacity() >= 11);/// Returns `true` if there are no items in the queue./// Note that this function returns `false` even if all items have not yet/// expired and a call to `poll` will return `Poll::Pending`./// delay_queue.insert("hello", Duration::from_secs(5));poll_idx/// Polls the queue, returning the index of the next slot in the slab that/// should be returned./// A slot should be returned when the associated deadline has been reached.normalize_deadline// We never put `T` in a `Pin`...// DelayQueue seems much more specific, where a user may care that it// has reached capacity, so return those errors instead of panicking./// Consumes `self` and returns the inner value./// Returns the deadline that the expiration was set to./// Returns the key that the expiration is indexed by.//! A queue of delayed elements.//! See [`DelayQueue`] for more details.//! [`DelayQueue`]: struct@DelayQueuedelay_queue/// A wrapper around [`tokio::time::timeout`], with the advantage that it is easier to write/// fluent call chains./// use tokio::{sync::oneshot, time::Duration};/// use tokio_util::time::FutureExt;/// let (tx, rx) = oneshot::channel::<()>();/// let res = rx.timeout(Duration::from_millis(10)).await;/// A trait which contains a variety of convenient adapters and utilities for `Future`s./// Convert a `Duration` to milliseconds, rounding up and saturating at/// `u64::MAX`./// The saturating is fine because `u64::MAX` milliseconds are still many/// million years.//! Additional utilities for tracking time.//! This module provides additional utilities for executing code after a set period//! of time. Currently there is only one://! * `DelayQueue`: A queue where items are returned once the requested delay//!   has expired.//! This type must be used from within the context of the `Runtime`.// ===== Internal utils =====/// Slotspop_entry_slotpeek_entry_slot/// Convert a duration (milliseconds) and a level to a slot position/// The maximum duration of a delay/// Create a new timing wheel/// Return the number of milliseconds that have elapsed since the timing/// Insert an entry into the timing wheel./// * `when`: is the instant at which the entry should be fired. It is///           represented as the number of milliseconds since the creation///           of the timing wheel./// * `store`: The slab or `()` when using heap storage./// Remove `item` from the timing wheel./// Instant at which to poll/// Next key that will expirepoll_expiration/// return it for notification (in the case of the last level) or tierpop_entrypeek_entry/// Type of the item stored in the stack/// Borrowed item/// Item storage, this allows a slab to be used instead of just the heap/// Returns `true` if the stack is empty/// Push an item onto the stack/// Pop an item from the stack/// Peek into the stack./// Abstracts the stack operations needed to track timeouts.wrout_addrcurrent_addr/// A unified [`Stream`] and [`Sink`] interface to an underlying `UdpSocket`, using/// the `Encoder` and `Decoder` traits to encode and decode frames./// Raw UDP sockets work with datagrams, but higher-level code usually wants to/// batch these into meaningful chunks, called "frames". This method layers/// framing on top of this socket by using the `Encoder` and `Decoder` traits to/// handle encoding and decoding of messages frames. Note that the incoming and/// outgoing frame types may be distinct./// This function returns a *single* object that is both [`Stream`] and [`Sink`];/// grouping this into a single object is often useful for layering things which/// require both read and write access to the underlying object./// calling [`split`] on the `UdpFramed` returned by this method, which will break/// them into separate objects, allowing them to interact more easily.INITIAL_RD_CAPACITYINITIAL_WR_CAPACITY/// Create a new `UdpFramed` backed by the given socket and codec./// See struct level documentation for more details./// Returns a reference to the underlying I/O stream wrapped by `Framed`./// Care should be taken to not tamper with the underlying stream of data/// coming in as it may corrupt the stream of frames otherwise being worked/// Returns a mutable reference to the underlying I/O stream wrapped by `Framed`./// `UdpFramed`.//! UDP framing/// A wrapper type that tells the compiler that the contents might not be valid./// This is necessary mainly when `T` contains a reference. In that case, the/// compiler will sometimes assume that the reference is always valid; in some/// cases it will assume this even after the destructor of `T` runs. For/// example, when a reference is used as a function argument, then the compiler/// will assume that the reference is valid until the function returns, even if/// the reference is destroyed during the function. When the reference is used/// as part of a self-referential struct, that assumption can be false. Wrapping/// the reference in this type prevents the compiler from making that/// assumption./// The `MaybeUninit` will always contain a valid value until the destructor runs.// Reference// See <https://users.rust-lang.org/t/unsafe-code-review-semi-owning-weak-rwlock-t-guard/95706>// TODO: replace this with an official solution once RFC #3336 or similar is available.// <https://github.com/rust-lang/rfcs/pull/3336>maybedangling_runs_dropmaybe_danglingpoll_buf/// Try to read data from an `AsyncRead` into an implementer of the [`BufMut`] trait./// [`BufMut`]: bytes::Buf/// use tokio_util::io::{StreamReader, poll_read_buf};///     let n = poll_fn(|cx| poll_read_buf(Pin::new(&mut read), cx, &mut buf)).await?;/// Try to write data from an implementer of the [`Buf`] trait to an/// [`AsyncWrite`], advancing the buffer's internal cursor./// This function will use [vectored writes] when the [`AsyncWrite`] supports/// vectored writes./// [`File`] implements [`AsyncWrite`] and [`Cursor<&[u8]>`] implements/// [`Buf`]:/// use tokio_util::io::poll_write_buf;///     let mut file = File::create("foo.txt").await?;///     let mut buf = Cursor::new(b"data to write");///     // Loop until the entire contents of the buffer are written to///     // the file.///     while buf.has_remaining() {///         poll_fn(|cx| poll_write_buf(Pin::new(&mut file), cx, &mut buf)).await?;/// [`File`]: tokio::fs::File/// [vectored writes]: tokio::io::AsyncWrite::poll_write_vectored/// Optional date./// Required for: *Offset Date-Time*, *Local Date-Time*, *Local Date*./// Optional time./// Required for: *Offset Date-Time*, *Local Date-Time*, *Local Time*./// Optional offset./// Required for: *Offset Date-Time*.Datetime/// A parsed TOML datetime value/// This structure is intended to represent the datetime primitive type that can/// be encoded into TOML documents. This type is a parsed version that contains/// all metadata internally./// Currently this type is intentionally conservative and only supports/// `to_string` as an accessor. Over time though it's intended that it'll grow/// more support!/// Note that if you're using `Deserialize` to deserialize a TOML document, you/// can use this as a placeholder for where you're expecting a datetime to be/// Also note though that while this type implements `Serialize` and/// `Deserialize` it's only recommended to use this type with the TOML format,/// otherwise encoded in other formats it may look a little odd./// Depending on how the option values are used, this struct will correspond/// with one of the following four datetimes from the [TOML v1.0.0 spec]:/// | `date`    | `time`    | `offset`  | TOML type          |/// | --------- | --------- | --------- | ------------------ |/// | `Some(_)` | `Some(_)` | `Some(_)` | [Offset Date-Time] |/// | `Some(_)` | `Some(_)` | `None`    | [Local Date-Time]  |/// | `Some(_)` | `None`    | `None`    | [Local Date]       |/// | `None`    | `Some(_)` | `None`    | [Local Time]       |/// **1. Offset Date-Time**: If all the optional values are used, `Datetime`/// corresponds to an [Offset Date-Time]. From the TOML v1.0.0 spec:/// > To unambiguously represent a specific instant in time, you may use an/// > RFC 3339 formatted date-time with offset./// > ```toml/// > odt1 = 1979-05-27T07:32:00Z/// > odt2 = 1979-05-27T00:32:00-07:00/// > odt3 = 1979-05-27T00:32:00.999999-07:00/// > For the sake of readability, you may replace the T delimiter between date/// > and time with a space character (as permitted by RFC 3339 section 5.6)./// > odt4 = 1979-05-27 07:32:00Z/// **2. Local Date-Time**: If `date` and `time` are given but `offset` is/// `None`, `Datetime` corresponds to a [Local Date-Time]. From the spec:/// > If you omit the offset from an RFC 3339 formatted date-time, it will/// > represent the given date-time without any relation to an offset or/// > timezone. It cannot be converted to an instant in time without additional/// > information. Conversion to an instant, if required, is implementation-/// > specific./// > ldt1 = 1979-05-27T07:32:00/// > ldt2 = 1979-05-27T00:32:00.999999/// **3. Local Date**: If only `date` is given, `Datetime` corresponds to a/// [Local Date]; see the docs for [`Date`]./// **4. Local Time**: If only `time` is given, `Datetime` corresponds to a/// [Local Time]; see the docs for [`Time`]./// [TOML v1.0.0 spec]: https://toml.io/en/v1.0.0/// [Offset Date-Time]: https://toml.io/en/v1.0.0#offset-date-time/// [Local Date-Time]: https://toml.io/en/v1.0.0#local-date-time/// [Local Date]: https://toml.io/en/v1.0.0#local-date/// [Local Time]: https://toml.io/en/v1.0.0#local-timeDatetimeParseError/// Error returned from parsing a `Datetime` in the `FromStr` implementation.FIELD// Currently serde itself doesn't have a datetime type, so we map our `Datetime`// to a special valid in the serde data model. Namely one with these special// In general the TOML encoder/decoder will catch this and not literally emit// these strings but rather emit datetimes as they're intended./// Year: four digits/// Month: 1 to 12/// Day: 1 to {28, 29, 30, 31} (based on month/year)/// A parsed TOML date value/// May be part of a [`Datetime`]. Alone, `Date` corresponds to a [Local Date]./// From the TOML v1.0.0 spec:/// > If you include only the date portion of an RFC 3339 formatted date-time,/// > it will represent that entire day without any relation to an offset or/// > timezone./// > ld1 = 1979-05-27/// Hour: 0 to 23/// Minute: 0 to 59/// Second: 0 to {58, 59, 60} (based on leap second rules)/// Nanosecond: 0 to 999_999_999/// A parsed TOML time value/// May be part of a [`Datetime`]. Alone, `Time` corresponds to a [Local Time]./// > If you include only the time portion of an RFC 3339 formatted date-time,/// > it will represent that time of day without any relation to a specific/// > day or any offset or timezone./// > lt1 = 07:32:00/// > lt2 = 00:32:00.999999/// > Millisecond precision is required. Further precision of fractional/// > seconds is implementation-specific. If the value contains greater/// > precision than the implementation can support, the additional precision/// > must be truncated, not rounded./// > A suffix which, when applied to a time, denotes a UTC offset of 00:00;/// > often spoken "Zulu" from the ICAO phonetic alphabet representation of/// > the letter "Z". --- [RFC 3339 section 2]/// [RFC 3339 section 2]: https://datatracker.ietf.org/doc/html/rfc3339#section-2/// Hours: -12 to +12/// Minutes: 0 to 59/// Offset between local time and UTC/// A parsed TOML time offsetDatetimeKeyDatetimeFromStringTokenErrorTablePair/// Type Alias for a TOML Table pair/// Deserializes a byte slice into a type./// This function will attempt to interpret `bytes` as UTF-8 data and then/// deserialize `T` from the TOML document provided./// Deserializes a string into a type./// This function will attempt to interpret `s` as a TOML document and/// deserialize `T` from the document./// struct Config {///     title: String,///     owner: Owner,/// struct Owner {/// let config: Config = toml::from_str(r#"///     title = 'TOML Example'///     [owner]///     name = 'Lisa'/// "#).unwrap();/// assert_eq!(config.title, "TOML Example");/// assert_eq!(config.owner.name, "Lisa");/// Errors that can occur when deserializing a type./// EOF was reached when looking for a valueInvalidCharInString/// An invalid character not allowed in a string was found/// An invalid character was found as an escapeInvalidHexEscape/// An invalid character was found in a hex escapeInvalidEscapeValue/// An invalid escape value was specified in a hex escape in a string./// Valid values are in the plane of unicode codepoints.NewlineInString/// A newline in a string was encountered when one was not allowed./// An unexpected character was encountered, typically when looking for aUnterminatedString/// An unterminated string was found where EOF was found before the ending/// EOF mark.NewlineInTableKey/// A newline was found in a table key.NumberInvalid/// A number failed to parseDateInvalid/// A date or datetime was invalid/// Expected token type/// Actually found token typeWanted/// Wanted one sort of token, but found another.DuplicateTable/// A duplicate table definition was found.RedefineAsArray/// A previously defined table was redefined as an array.EmptyTableKey/// An empty table key was found.MultilineStringKey/// Multiline strings are not allowed for key/// A custom error which could be generated when deserializing a particularExpectedTuple/// A tuple with a certain number of elements was expected but something/// else was found./// Expected index./// Key that was specified.ExpectedTupleIndex/// Expected table keys to be in increasing tuple index order, but somethingExpectedEmptyTable/// An empty table was expected but entries were foundDottedKeyInvalidType/// Dotted key attempted to extend something that is not a table./// The unexpected keys./// Keys that may be specified.UnexpectedKeys/// An unexpected key was encountered./// Used when deserializing a struct with a limited set of fields.UnquotedString/// Unquoted string was found when quoted one was expectedrequire_newline_after_tableallow_duplciate_after_longer_table/// Deserialization implementation for TOML.// Called when the type to deserialize is an enum, as opposed to a field in the type.build_table_indices// Builds a datastructure that allows for efficient sublinear lookups.// The returned HashMap contains a mapping from table header (like [a.b.c])// to list of tables with that precise name. The tables are being identified// by their index in the passed slice. We use a list as the implementation// uses this data structure for arrays as well as tables,// so if any top level [[name]] array contains multiple entries,// there are multiple entries in the list.// The lookup is performed in the `SeqAccess` implementation of `MapVisitor`.// The lists are ordered, which we exploit in the search code by using// bisection.build_table_pindices// to list of tables whose name at least starts with the specified// name. So searching for [a.b] would give both [a.b.c.d] as well as [a.b.e].// The tables are being identified by their index in the passed slice.// A list is used for two reasons: First, the implementation also// stores arrays in the same data structure and any top level array// of size 2 or greater creates multiple entries in the list with the// same shared name. Second, there can be multiple tables sharing// the same prefix.// The lookup is performed in the `MapAccess` implementation of `MapVisitor`.headers_equalcur_parenttable_indicestable_pindices// `None` is interpreted as a missing field so be sure to implement `Some`// as a present field.validate_struct_keyswith_struct_key_validationphantom_dataSpannedDeserializerDatetimeDeserializerDatetimeFieldDeserializerDottedTableDeserializerTableEnumDeserializerInlineTableDeserializer/// Deserializes table values into enum variants./// Creates a new deserializer which will be deserializing the stringset_require_newline_after_tableset_allow_duplicate_after_longer_tabletable_headerparse_keylikenumber_or_datestring_or_table/// Returns a string or table value type./// Used to deserialize enums. Unit enums may be represented as a string or a table, all other/// structures (tuple, newtype, struct) must be represented as a table.number_leading_plusinline_table// TODO(#140): shouldn't buffer up this entire table in memory, it'd be// great to defer parsing everything until later.// TODO(#140): shouldn't buffer up this entire array in memory, it'd betable_keydotted_keyadd_dotted_key/// Stores a value in the appropriate hierarchical structure positioned based on the dotted key./// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are/// intermediate parts which are mapped to the relevant fields in the deserialized type's data/// hierarchy./// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to///                `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`/// * `value`: The parsed value./// * `values`: The `Vec` to store the value in.eat_whitespaceeat_commenteat_newline_or_eofeat_spannedexpect_spannedtoken_errorto_linecol/// Converts a byte offset from an error message to a (line, column) pair/// All indexes are 0-based.line_col/// Produces a (line, column) pair of the position of the error if availableadd_key_contextfix_offsetfix_linecolInlineTableDottedTable//! Deserializing TOML into Rust structures.//! This module contains all the Serde support for deserializing TOML documents//! into Rust structures. Note that some top-level functions here are also//! provided at the top of the crate.// Just for rustdoc//! A [serde]-compatible [TOML]-parsing library//! TOML itself is a simple, ergonomic, and readable configuration format://! name = "toml"//! version = "0.4.2"//! authors = ["Alex Crichton <alex@alexcrichton.com>"]//! serde = "1.0"//! The TOML format tends to be relatively common throughout the Rust community//! for configuration, notably being used by [Cargo], Rust's package manager.//! ## TOML values//! A value in TOML is represented with the [`Value`] enum in this crate://! pub enum Value {//!     Integer(i64),//!     Float(f64),//!     Boolean(bool),//!     Datetime(Datetime),//!     Array(Array),//!     Table(Table),//! TOML is similar to JSON with the notable addition of a [`Datetime`]//! type. In general, TOML and JSON are interchangeable in terms of//! formats.//! ## Parsing TOML//! The easiest way to parse a TOML document is via the [`Value`] type://! use toml::Value;//! let value = "foo = 'bar'".parse::<Value>().unwrap();//! assert_eq!(value["foo"].as_str(), Some("bar"));//! The [`Value`] type implements a number of convenience methods and//! traits; the example above uses [`FromStr`] to parse a [`str`] into a//! [`Value`].//! ## Deserialization and Serialization//! This crate supports [`serde`] 1.0 with a number of//! implementations of the `Deserialize`, `Serialize`, `Deserializer`, and//! `Serializer` traits. Namely, you'll find://! * `Deserialize for Value`//! * `Serialize for Value`//! * `Deserialize for Datetime`//! * `Serialize for Datetime`//! * `Deserializer for de::Deserializer`//! * `Serializer for ser::Serializer`//! * `Deserializer for Value`//! This means that you can use Serde to deserialize/serialize the//! [`Value`] type as well as the [`Datetime`] type in this crate. You can also//! use the [`Deserializer`], [`Serializer`], or [`Value`] type itself to act as//! a deserializer/serializer for arbitrary types.//! An example of deserializing with TOML is://!     ip: String,//!     port: Option<u16>,//!     keys: Keys,//! struct Keys {//!     github: String,//!     travis: Option<String>,//!     let config: Config = toml::from_str(r#"//!         ip = '127.0.0.1'//!         [keys]//!         github = 'xxxxxxxxxxxxxxxxx'//!         travis = 'yyyyyyyyyyyyyyyyy'//!     "#).unwrap();//!     assert_eq!(config.ip, "127.0.0.1");//!     assert_eq!(config.port, None);//!     assert_eq!(config.keys.github, "xxxxxxxxxxxxxxxxx");//!     assert_eq!(config.keys.travis.as_ref().unwrap(), "yyyyyyyyyyyyyyyyy");//! You can serialize types in a similar fashion://! use serde_derive::Serialize;//! #[derive(Serialize)]//!     let config = Config {//!         ip: "127.0.0.1".to_string(),//!         port: None,//!         keys: Keys {//!             github: "xxxxxxxxxxxxxxxxx".to_string(),//!             travis: Some("yyyyyyyyyyyyyyyyy".to_string()),//!     let toml = toml::to_string(&config).unwrap();//! [TOML]: https://github.com/toml-lang/toml//! [Cargo]: https://crates.io///! [`serde`]: https://serde.rs//// Construct a [`toml::Value`] from TOML syntax./// [`toml::Value`]: value/enum.Value.html/// let cargo_toml = toml::toml! {///     [package]///     name = "toml"///     version = "0.4.5"///     authors = ["Alex Crichton <alex@alexcrichton.com>"]///     [badges]///     travis-ci = { repository = "alexcrichton/toml-rs" }///     [dependencies]///     serde = "1.0"///     [dev-dependencies]///     serde_derive = "1.0"///     serde_json = "1.0"/// println!("{:#?}", cargo_toml);toml_internal// Base case, no elements remaining.// Parse negative number `key = -value`.// Parse positive number `key = +value`.// Parse offset datetime `key = 1979-05-27T00:32:00.999999-07:00`.// Space instead of T.// Parse offset datetime `key = 1979-05-27T00:32:00-07:00`.// Parse local datetime `key = 1979-05-27T00:32:00.999999`.// Parse offset datetime `key = 1979-05-27T07:32:00Z` and local datetime `key = 1979-05-27T07:32:00`.// Parse local date `key = 1979-05-27`.// Parse local time `key = 00:32:00.999999`.// Parse local time `key = 07:32:00`.// Parse any other `key = value` including string, inline array, inline// table, number, and boolean.// Parse array header `[[bin]]`.// Parse table header `[patch.crates-io]`.// Parse datetime from string and insert into table.// Turn a path segment into a string.// For a path segment that is not an ident, expect that it is already a// quoted string, like in `[target."cfg(windows)".dependencies]`.// Construct a Value from an inline table.// Construct a Value from an inline array.// Construct a Value from any other type, probably string or boolean or number.// Base case of inline table.// Parse any other type, probably string or boolean or number.// Parse a Datetime from string and continue in @table state.// Base case of inline array.// Parse negative number `-value`.// Parse positive number `+value`.// Parse offset datetime `1979-05-27T00:32:00.999999-07:00`.// Parse offset datetime `1979-05-27T00:32:00-07:00`.// Parse local datetime `1979-05-27T00:32:00.999999`.// Parse offset datetime `1979-05-27T07:32:00Z` and local datetime `1979-05-27T07:32:00`.// Parse local date `1979-05-27`.// Parse local time `00:32:00.999999`.// Parse local time `07:32:00`.// Parse a Datetime from string and continue in @array state.// No trailing comma required if the tokens are empty.// Tokens end with a trailing comma, do not append another one.// Tokens end with something other than comma, append a trailing comma.// Not yet at the last token.// TT-muncher to parse TOML syntax into a toml::Value.//    @toplevel -- Parse tokens outside of an inline table or inline array. In//                 this state, `[table headers]` and `[[array headers]]` are//                 allowed and `key = value` pairs are not separated by commas.//    @topleveldatetime -- Helper to parse a Datetime from string and insert it//                 into a table, continuing in the @toplevel state.//    @path -- Turn a path segment into a string. Segments that look like idents//                 are stringified, while quoted segments like `"cfg(windows)"`//                 are not.//    @value -- Parse the value part of a `key = value` pair, which may be a//                 primitive or inline table or inline array.//    @table -- Parse the contents of an inline table, returning them as a//                 toml::Value::Table.//    @tabledatetime -- Helper to parse a Datetime from string and insert it//                 into a table, continuing in the @table state.//    @array -- Parse the contents of an inline array, returning them as a//                 toml::Value::Array.//    @arraydatetime -- Helper to parse a Datetime from string and push it into//                 an array, continuing in the @array state.//    @trailingcomma -- Helper to append a comma to a sequence of tokens if the//                 sequence is non-empty and does not already end in a trailing//                 comma.insert_toml// Called when parsing a `key = value` pair.// Inserts an entry into the table at the given path.push_toml// Called when parsing an `[[array header]]`.// Pushes an empty table onto the array at the given path./// Represents a TOML key/value type./// An iterator over a toml::Map's entries./// A mutable iterator over a toml::Map's entries./// An owning iterator over a toml::Map's entries./// An iterator over a toml::Map's keys./// An iterator over a toml::Map's values.// Copyright 2017 Serde Developers//! A map of String to toml::Value.//! feature of toml-rs to use [`LinkedHashMap`] instead.//! [`LinkedHashMap`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html/// Serialize the given data structure as a TOML byte vector./// fail, if `T` contains a map with non-string keys, or if `T` attempts to/// serialize an unsupported datatype such as an enum, tuple, or tuple struct./// Serialize the given data structure as a String of TOML.///     database: Database,/// struct Database {///     ip: String,///     port: Vec<u16>,///     connection_max: u32,///     enabled: bool,/// let config = Config {///     database: Database {///         ip: "192.168.1.1".to_string(),///         port: vec![8001, 8002, 8003],///         connection_max: 5000,///         enabled: false,/// let toml = toml::to_string(&config).unwrap();/// println!("{}", toml)/// Serialize the given data structure as a "pretty" String of TOML./// This is identical to `to_string` except the output string has a more/// "pretty" output. See `Serializer::pretty` for more details./// Indicates that a Rust type was requested to be serialized but it was not/// Currently the TOML format does not support serializing types such as/// enums, tuples and tuple structs.KeyNotString/// The key of all TOML maps must be strings, but serialization was/// attempted where the key of a map was not a string.KeyNewline/// An error that we never omit but keep for backwards compatibilityArrayMixedType/// An array had to be homogeneous, but now it is allowed to be heterogeneous.ValueAfterTable/// All values in a TOML table must be emitted before further tables are/// emitted. If a value is emitted *after* a table then this error is/// A serialized date was invalid./// A serialized number was invalid.UnsupportedNone/// None was attempted to be serialized, but it's not supported./// A custom error which could be generated when serializing a particular/// Errors that can occur when serializing a type.ArraySettings/// Internal place for holding array settings/// Whether to use literal strings when possibleStringSettings/// String settings/// Internal struct for holding serialization settings/// Serialization implementation for TOML./// This structure implements serialization support for TOML to serialize an/// arbitrary type to TOML. Note that the TOML format does not support all/// datatypes in Rust, such as enums, tuples, and tuple structs. These types/// will generate an error when serialized./// Currently a serializer always writes its output to an in-memory `String`,/// which is passed in when creating the serializer itself.ArrayStateStartedAsATabletable_emittedSerializeTable/// Creates a new serializer which will emit TOML into the buffer provided./// The serializer can then be used to serialize a type after which the data/// will be present in `dst`./// Instantiate a "pretty" formatter/// By default this will use:/// - pretty strings: strings with newlines will use the `'''` syntax. See///   `Serializer::pretty_string`/// - pretty arrays: each item in arrays will be on a newline, have an indentation of 4 and///   have a trailing comma. See `Serializer::pretty_array`pretty_string/// Enable or Disable pretty strings/// If enabled, literal strings will be used when possible and strings with/// one or more newlines will use triple quotes (i.e.: `'''` or `"""`)/// Instead of:/// ```toml,ignore/// single = "no newlines"/// text = "\nfoo\nbar\n"/// You will have:/// single = 'no newlines'/// text = '''/// foo/// bar/// '''pretty_string_literal/// Enable or Disable Literal strings for pretty strings/// If disabled, literal strings will NEVER be used and strings with one or/// more newlines will use `"""`/// text = """/// """pretty_array/// Enable or Disable pretty arrays/// If enabled, arrays will always have each item on their own line./// Some specific features can be controlled via other builder methods:/// - `Serializer::pretty_array_indent`: set the indent to a value other///   than 4./// - `Serializer::pretty_array_trailing_comma`: enable/disable the trailing///   comma on the last item./// array = ["foo", "bar"]/// array = [/// ]pretty_array_indent/// Set the indent for pretty arrays/// See `Serializer::pretty_array` for more details.pretty_array_trailing_comma/// Specify whether to use a trailing comma when serializing pretty arraysemit_key_emit_key// recursive implementation of `emit_key` aboveemit_arrayarray_typeescape_keyemit_stremit_table_headeremit_key_partserialize_floatDateStrEmitterStringExtractortables_last/// Convenience function to serialize items in a map in an order valid with/// TOML./// TOML carries the restriction that keys in a table must be serialized last if/// their value is a table itself. This isn't always easy to guarantee, so this/// helper can be used like so:/// struct Manifest {///     package: Package,///     #[serde(serialize_with = "toml::ser::tables_last")]///     dependencies: HashMap<String, Dependency>,/// # type Package = String;/// # type Dependency = String;Categorize//! Serializing Rust structures into TOML.//! This module contains all the Serde support for serializing Rust structures//! into TOML documents (as strings). Note that some top-level functions here//! are also provided at the top of the crate.//! Note that the TOML format has a restriction that if a table itself contains//! tables, all keys with non-table values must be emitted first. This is//! typically easy to ensure happens when you're defining a `struct` as you can//! reorder the fields manually, but when working with maps (such as `BTreeMap`//! or `HashMap`) this can lead to serialization errors. In those situations you//! may use the `tables_last` function in this module like so://! # use serde_derive::Serialize;//! struct Manifest {//!     package: Package,//!     #[serde(serialize_with = "toml::ser::tables_last")]//!     dependencies: HashMap<String, Dependency>,//! # type Package = String;//! # type Dependency = String;STARTEND/// The start range./// The end range (exclusive)./// struct Value {///     s: Spanned<String>,/// let t = "s = \"value\"\n";/// let u: Value = toml::from_str(t).unwrap();/// assert_eq!(u.s.start(), 4);/// assert_eq!(u.s.end(), 11);/// assert_eq!(u.s.get_ref(), "value");/// assert_eq!(u.s.into_inner(), String::from("value"));/// Access the start of the span of the contained value./// Access the end of the span of the contained value./// Get the span of the contained value.StdString/// The start of the range./// The end of the range (exclusive)./// A span, designating a range of bytes where a token is located.LeftBraceRightBraceKeylikemultilineCrlfFoldMaybeStringNotEscaped/// Eat a value, returning it's span if it was consumed./// Expect the given token returning its span.skip_to_newlineeatcwhitespace_tokencomment_tokenliteral_stringbasic_stringkeylikesubstr_offsetstep_span/// Calculate the span of a single character./// Peek one char without consuming it./// Take one char.is_keylikeliteral_stringsbasic_stringsbare_cr_badbad_comment/// Represents a TOML string/// Represents a TOML integer/// Represents a TOML float/// Represents a TOML boolean/// Represents a TOML datetime/// Represents a TOML array/// Represents a TOML table/// Representation of a TOML value./// Type representing a TOML array, payload of the `Value::Array` variant/// Type representing a TOML table, payload of the `Value::Table` variant./// By default it is backed by a BTreeMap, enable the `preserve_order` feature/// to use a LinkedHashMap instead./// Convert a `T` into `toml::Value` which is an enum that can represent/// any valid TOML data./// Interpret a `toml::Value` as an instance of type `T`./// This conversion can fail if the structure of the `Value` does not match the/// structure expected by `T`, for example if `T` is a struct type but the/// `Value` contains something other than a TOML table. It can also fail if the/// structure is correct but `T`'s implementation of `Deserialize` decides that/// something is wrong with the data, for example required struct fields are/// missing from the TOML map or some number is too big to fit in the expected/// primitive type./// Index into a TOML array or map. A string index can be used to access a/// Mutably index into a TOML array or map. A string index can be used to/// Extracts the integer value if it is an integer./// Tests whether this value is an integer./// Extracts the float value if it is a float./// Tests whether this value is a float./// Extracts the boolean value if it is a boolean./// Tests whether this value is a boolean./// Extracts the string of this value if it is a string./// Tests if this value is a string.as_datetime/// Extracts the datetime value if it is a datetime./// Note that a parsed TOML value will only contain ISO 8601 dates. An/// example date is:/// 1979-05-27T07:32:00Zis_datetime/// Tests whether this value is a datetime./// Extracts the array value if it is an array./// Tests whether this value is an array.as_table/// Extracts the table value if it is a table.as_table_mut/// Tests whether this value is a table.same_type/// Tests whether this and another value have the same type.type_str/// Returns a human-readable representation of the type of this value.impl_into_value/// Types that can be used to index a `toml::Value`/// Currently this is implemented for `usize` to index arrays and `str` to index/// tables./// This trait is sealed and not intended for implementation outside of the/// `toml` crate./// An implementation detail that should not be implemented, this will change in/// the future and break code otherwise.DatetimeOrTable//! Definition of a TOML value/// To deserializes TOML values, instead of documents, see [`ValueDeserializer`].add_key/// What went wrong/// The start/end index into the original document where the error occurred/// Deserialization TOML document/// Deserialization TOML [value][crate::Value]/// let config = Config::deserialize(toml::de::ValueDeserializer::new(///     r#"{ title = 'TOML Example', owner = { name = 'Lisa' } }"#/// )).unwrap();multiline_arrayis_valueDocumentFormattervisit_document_mutvisit_table_mutvisit_value_mutvisit_array_mut// Shortcuts for the module doc-comment//! A TOML document is represented with the [`Table`] type which maps `String` to the [`Value`] enum://! # use toml::value::{Datetime, Array, Table};//! The easiest way to parse a TOML document is via the [`Table`] type://! use toml::Table;//! let value = "foo = 'bar'".parse::<Table>().unwrap();//! The [`Table`] type implements a number of convenience methods and//! [`Table`].//! * `Deserialize for Table`//! * `Serialize for Table`//! * `Deserializer for Table`//! [`Table`] type as well as [`Value`] and [`Datetime`] type in this crate. You can also//! use the [`Deserializer`], [`Serializer`], or [`Table`] type itself to act as//! let config: Config = toml::from_str(r#"//!     ip = '127.0.0.1'//!     [keys]//!     github = 'xxxxxxxxxxxxxxxxx'//!     travis = 'yyyyyyyyyyyyyyyyy'//! "#).unwrap();//! assert_eq!(config.ip, "127.0.0.1");//! assert_eq!(config.port, None);//! assert_eq!(config.keys.github, "xxxxxxxxxxxxxxxxx");//! assert_eq!(config.keys.travis.as_ref().unwrap(), "yyyyyyyyyyyyyyyyy");//! use serde::Serialize;//! let config = Config {//!     ip: "127.0.0.1".to_string(),//!     port: None,//!     keys: Keys {//!         github: "xxxxxxxxxxxxxxxxx".to_string(),//!         travis: Some("yyyyyyyyyyyyyyyyy".to_string()),//! let toml = toml::to_string(&config).unwrap();/// Construct a [`Table`] from TOML syntax./// Retains only the elements specified by the `keep` predicate./// In other words, remove all pairs `(k, v)` for which `keep(&k, &mut v)`/// The elements are visited in iteration order.//! A map of `String` to [Value].//! feature of toml-rs to use [`IndexMap`] instead.//! [`IndexMap`]: https://docs.rs/indexmap/// To serialize TOML values, instead of documents, see [`ValueSerializer`]./// For greater customization, instead serialize to a/// [`toml_edit::Document`](https://docs.rs/toml_edit/latest/toml_edit/struct.Document.html).unsupported_typeunsupported_nonekey_not_string/// Serialization for TOML documents./// Apply a default "pretty" policy to the documentSerializeDocumentArraySerializeDocumentTableValueSerializer/// Serialization for TOML [values][crate::Value]./// let mut value = String::new();/// serde::Serialize::serialize(///     &config,///     toml::ser::ValueSerializer::new(&mut value)/// println!("{}", value)SerializeValueArraySerializeValueTableInnerSerializeDocumentSeqInnerSerializeDocumentTablewrite_documentInnerSerializeValueSeqInnerSerializeValueTable/// Convert a `T` into `toml::Table`./// Interpret a `toml::Table` as an instance of type `T`./// This conversion can fail if the structure of the `Table` does not match the structure/// expected by `T`, for example if `T` is a bool which can't be mapped to a `Table`. It can/// also fail if the structure is correct but `T`'s implementation of `Deserialize` decides/// that something is wrong with the data, for example required struct fields are missing from/// the TOML map or some number is too big to fit in the expected primitive type.// This is wrapped by `Table` and any trait methods implemented here need to be wrapped there.MapEnumDeserializerValueSerializeVecValueSerializeMapTableSerializer//! Definition of a TOML [value][Value]ValueSerializeTupleVariantValueSerializeStructVariantValueSerializeVariant/// Minutes: -1_440..1_440//! A [TOML]-compatible datetime typeDecorDEFAULT_LEADING_VALUE_DECORDEFAULT_VALUE_DECOR// `trailing` represents whitespaces, newlines// and comments in an empty array or after the trailing commadecor// prefix before `[` and suffix after `]`// always Vec<Item::Value>/// Type representing a TOML array,/// payload of the `Value::Array` variant's valueArrayIntoIter/// An owned iterator type over `Table`'s key/value pairs.ArrayIter/// An iterator type over `Array`'s values.ArrayIterMut/// Create an empty `Array`/// let mut arr = toml_edit::Array::new();/// See also `FromIterator`/// Auto formats the array.set_trailing_comma/// Set whether the array will use a trailing comma/// Whether the array will use a trailing commaset_trailing/// Set whitespace after last element/// Whitespace after last elementdecor_mut/// Returns the surrounding whitespace/// Returns the location within the original documentdespan/// Formatting/// Returns an iterator over all values./// Returns the length of the underlying Vec./// In some rare cases, placeholder elements will exist.  For a more accurate count, call/// `a.iter().count()`/// arr.push(1);/// arr.push("foo");/// assert_eq!(arr.len(), 2);/// Return true iff `self.len() == 0`./// assert!(arr.is_empty());/// assert!(! arr.is_empty());/// Clears the array, removing all values. Keeps the allocated memory for reuse./// Returns a reference to the value at the given index, or `None` if the index is out of/// Appends a new value to the end of the array, applying default formatting to it.push_formatted/// Appends a new, already formatted value to the end of the array./// let formatted_value = "'literal'".parse::<toml_edit::Value>().unwrap();/// arr.push_formatted(formatted_value);/// Inserts an element at the given position within the array, applying default formatting to/// it and shifting all values after it to the right./// arr.insert(0, "start");insert_formatted/// Inserts an already formatted value at the given position within the array, shifting all/// values after it to the right./// let formatted_value = "'start'".parse::<toml_edit::Value>().unwrap();/// arr.insert_formatted(0, formatted_value);/// Replaces the element at the given position within the array, preserving existing formatting./// Panics if `index >= len`./// arr.replace(0, "start");replace_formatted/// Replaces the element at the given position within the array with an already formatted value./// arr.replace_formatted(0, formatted_value);/// Removes the value at the given index./// arr.remove(0);/// assert_eq!(arr.len(), 1);/// Retains only the values specified by the `keep` predicate./// In other words, remove all values for which `keep(&value)` returns `false`./// This method operates in place, visiting each element exactly once in the/// original order, and preserves the order of the retained elements.value_opdecorate_array// Always Vec<Item::Table>, just `Item` to make `Index` workArrayOfTables/// Type representing a TOML array of tables/// Creates an empty array of tables./// Convert to an inline arrayArrayOfTablesIter/// Returns an iterator over tables.ArrayOfTablesIterMut/// To get the actual number of items use `a.iter().count()`./// Returns true iff `self.len() == 0`./// Removes all the tables./// Returns an optional reference to the table./// Returns an optional mutable reference to the table./// Appends a table to the array./// Removes a table with the given index./// In other words, remove all tables for which `keep(&table)` returns `false`./// An iterator type over `ArrayOfTables`'s values.ArrayOfTablesIntoIterArrayDeserializer// Note: this is wrapped by `ValueDeserializer` and any trait methods// implemented here need to be wrapped thereArraySeqAccessInternalStringKeyDeserializertable_enumTableMapAccess/// Add key while unwinding/// Convert a value into `T`.from_document/// Convert a document into `T`./// Deserialization for TOML [documents][crate::Document]./// Parses a document from a &str// Note: this is wrapped by `toml::de::Deserializer` and any trait methodsKeyValuePairs//! This module contains all the Serde support for deserializing TOML documents into Rust structures.TableDeserializer// Note: this is wrapped by `Deserializer` and `ValueDeserializer` and any trait methodsTableKeyValue/// Deserialization implementation for TOML [values][crate::Value]./// Can be created either directly from TOML strings, using [`std::str::FromStr`],/// or from parsed [values][crate::Value] using [`serde::de::IntoDeserializer::into_deserializer`]./// let value = r#"{ title = 'TOML Example', owner = { name = 'Lisa' } }"#;/// let deserializer = value.parse::<toml_edit::de::ValueDeserializer>().unwrap();/// let config = Config::deserialize(deserializer).unwrap();// Note: this is wrapped by `toml::de::ValueDeserializer` and any trait methods/// Parses a value from a &str// Trailing comments and whitespaces/// Type representing a TOML document/// Creates an empty documentas_item/// Returns a reference to the root item.as_item_mut/// Returns a mutable reference to the root item./// Returns a reference to the root table./// Returns a mutable reference to the root table./// Returns an iterator over the root table./// If run on on a `Document` not generated by the parserDEFAULT_INLINE_KEY_DECORValueReprDEFAULT_KEY_DECORDEFAULT_KEY_PATH_DECORDEFAULT_TABLE_DECORDEFAULT_TRAILING_VALUE_DECORvisit_nested_tablesvisit_tableto_string_reprStringStyleNewlineTripleOnelineTripleOnelineSingleliteral_startliteral_endstandard_startstandard_endinfer_styleto_f64_repr// copied from// https://github.com/serde-rs/json/blob/master/src/value/index.rsTableLikeKeyMutpreamble// `preamble` represents whitespaces in an empty table// prefix before `{` and suffix after `}`dotted// whether this is a proxy for dotted keys/// Type representing a TOML inline table,/// payload of the `Value::InlineTable` variant/// Creates an empty table.with_pairs/// Convert to a table/// Get key/values for values that are visually children of this table/// For example, this will return dotted keysappend_values/// Auto formats the table.sort_values/// Sorts the key/value pairs by key.sort_values_by/// Sort Key/Value Pairs of the table using the using the comparison function `compare`./// The comparison function receives two key and value pairs to compare (you can sort by keys or/// values or their combination as needed).sort_values_by_internalset_dotted/// Change this table's dotted statusis_dotted/// Check if this is a wrapper for dotted keys, rather than a standard tablekey_decor_mut/// Returns the decor associated with a given key of the table.key_decorset_preamble/// Set whitespace after before element/// Whitespace after before elementInlineTableIter/// Returns an iterator over key/value pairs.InlineTableIterMut/// Returns the number of key/value pairs./// Returns true iff the table is empty./// Clears the table, removing all key-value pairs. Keeps the allocated memory for reuse.InlineEntry/// Gets the given key's corresponding entry in the Table for in-place manipulation.entry_format/// Return an optional reference to the value at the given the key./// Return an optional mutable reference to the value at the given the key./// Return references to the key-value pair stored for key, if it is present, else None./// Return mutable references to the key-value pair stored for key, if it is present, else None./// Returns true iff the table contains given key./// Inserts a key/value pair if the table does not contain the key./// Returns a mutable reference to the corresponding value./// Removes an item given the key./// Removes a key from the map, returning the stored key and value if the key was previously in the map./// In other words, remove all pairs `(key, value)` for which/// `keep(&key, &mut value)` returns `false`.InlineTableIntoIterdecorate_inline_table/// An owned iterator type over key/value pairs of an inline table./// An iterator type over key/value pairs of an inline table./// A mutable iterator type over key/value pairs of an inline table.// `{ key1 = value1, ... }`InlineOccupiedEntryInlineVacantEntry/// A view into a single location in a map, which may be vacant or occupied./// Returns the entry key/// use toml_edit::Table;/// let mut map = Table::new();/// assert_eq!("hello", map.entry("hello").key());/// A view into a single occupied location in a `IndexMap`./// Gets a reference to the entry key/// assert_eq!("foo", map.entry("foo").key());/// Gets a mutable reference to the entry key/// with a lifetime bound to the map itself/// Sets the value of the entry, and returns the entry's old value/// Takes the value out of the entry, and returns it/// A view into a single empty location in a `IndexMap`./// and returns a mutable reference to it/// Opaque string storage internal to `toml_edit`/// Create an empty string/// Access the underlying stringarray_of_tables/// Type representing none./// Type representing value./// Type representing table./// Type representing array of tables./// Type representing either a value, a table, an array of tables, or none./// Sets `self` to the given item iff `self` is none and/// returns a mutable reference to `self`./// Text description of value type/// - The type of `self` does not match the type of the///   index, for example if the index is a string and `self` is an array or a///   number./// - The given key does not exist in the map///   or the given index is not within the bounds of the array.as_value/// Casts `self` to value./// Casts `self` to table.as_array_of_tables/// Casts `self` to array of tables./// Casts `self` to mutable value./// Casts `self` to mutable table.as_array_of_tables_mut/// Casts `self` to mutable array of tables.make_value/// In-place convert to a valueinto_array_of_tablesmake_item// Starting private because the name is unclear/// Returns true iff `self` is a value./// Returns true iff `self` is a table.is_array_of_tables/// Returns true iff `self` is an array of tables./// Returns true iff `self` is `None`./// Casts `self` to integer./// Returns true iff `self` is an integer./// Casts `self` to float./// Returns true iff `self` is a float./// Casts `self` to boolean./// Returns true iff `self` is a boolean./// Casts `self` to str./// Returns true iff `self` is a string./// Casts `self` to date-time./// Returns true iff `self` is a date-time./// Casts `self` to array./// Casts `self` to mutable array./// Returns true iff `self` is an array.as_inline_table/// Casts `self` to inline table.as_inline_table_mut/// Casts `self` to mutable inline table.is_inline_table/// Returns true iff `self` is an inline table.as_table_like/// Casts `self` to either a table or an inline table.as_table_like_mutis_table_like/// Returns true iff `self` is either a table, or an inline table.// Duplicate Value downcasting API// TODO: This should be generated by macro or derive/// Downcasting/// Returns a formatted value./// Since formatting is part of a `Value`, the right hand side of the/// assignment needs to be decorated with a space before the value./// The `value` function does just that./// # use snapbox::assert_eq;/// # use toml_edit::*;/// let mut table = Table::default();/// let mut array = Array::default();/// array.push("hello");/// array.push("\\, world"); // \ is only allowed in a literal string/// table["key1"] = value("value1");/// table["key2"] = value(42);/// table["key3"] = value(array);/// assert_eq(table.to_string(),/// r#"key1 = "value1"/// key2 = 42/// key3 = ["hello", '\, world']/// Returns an empty table./// Returns an empty array of tables.is_unquoted_char/// Key as part of a Key/Value Pair or a table header./// [dependencies."nom"]/// version = "5.0"/// 'literal key' = "nonsense"/// "basic string key" = 42/// There are 3 types of keys:/// 1. Bare keys (`version` and `dependencies`)/// 2. Basic quoted keys (`"basic string key"` and `"nom"`)/// 3. Literal quoted keys (`'literal key'`)/// For details see [toml spec](https://github.com/toml-lang/toml/#keyvalue-pair)./// To parse a key use `FromStr` trait implementation: `"string".parse::<Key>()`./// Create a new table key/// Parse a TOML key expression/// Unlike `"".parse<Key>()`, this supports dotted keys.with_repr_uncheckedwith_decor/// While creating the `Key`, add `Decor` to it/// Access a mutable proxy for the `Key`./// Returns the parsed key value./// Returns key raw representation, if available.default_repr/// Returns the default raw representation.display_repr/// Returns a raw representation./// Auto formats the key.try_parse_simpletry_parse_path/// Tries to parse a key from a &str,/// if fails, tries as basic quoted key (surrounds with "")/// and then literal quoted key (surrounds with '')to_key_repr/// A mutable reference to a `Key`/// Returns the raw representation, if available.internal_string// Prevent users from some traits.// https://github.com/Marwes/combine/issues/172//! # `toml_edit`//! This crate allows you to parse and modify toml//! documents, while preserving comments, spaces *and//! relative order* or items.//! If you also need the ease of a more traditional API, see the [`toml`] crate.//! use toml_edit::{Document, value};//! let toml = r#"//! "hello" = 'toml!' # comment//! ['a'.b]//! "#;//! let mut doc = toml.parse::<Document>().expect("invalid doc");//! assert_eq!(doc.to_string(), toml);//! // let's add a new key/value pair inside a.b: c = {d = "hello"}//! doc["a"]["b"]["c"]["d"] = value("hello");//! // autoformat inline table a.b.c: { d = "hello" }//! doc["a"]["b"]["c"].as_inline_table_mut().map(|t| t.fmt());//! let expected = r#"//! c = { d = "hello" }//! assert_eq!(doc.to_string(), expected);//! ## Controlling formatting//! By default, values are created with default formatting//! let mut doc = toml_edit::Document::new();//! doc["foo"] = toml_edit::value("bar");//! let expected = r#"foo = "bar"//! You can choose a custom TOML representation by parsing the value.//! doc["foo"] = "'bar'".parse::<toml_edit::Item>().unwrap();//! let expected = r#"foo = 'bar'//! Things it does not preserve://! * Scattered array of tables (tables are reordered by default, see [test]).//! * Order of dotted keys, see [issue](https://github.com/ordian/toml_edit/issues/163).//! [`toml`]: https://docs.rs/toml/latest/toml///! [test]: https://github.com/ordian/toml_edit/blob/f09bd5d075fdb7d2ef8d9bb3270a34506c276753/tests/test_valid.rs#L84cut_errseparated1triviaws_comment_newlineRecursionCheck// array = array-open array-values array-closeARRAY_OPEN// note: we're omitting ws and newlines here, because// they should be part of the formatted values// array-open  = %x5B ws-newline  ; [ARRAY_CLOSE// array-close = ws-newline %x5D  ; ]ARRAY_SEP// array-sep = ws %x2C ws  ; , Commaarray_values// note: this rule is modified// array-values = [ ( array-value array-sep array-values ) ///                  array-value / ws-comment-newline ]array_valueinvalid_arrays// ;; Array// date-time = offset-date-time / local-date-time / local-date / local-time// offset-date-time = full-date time-delim full-time// local-date-time = full-date time-delim partial-time// local-date = full-date// local-time = partial-time// full-time = partial-time time-offsetfull_date// full-date      = date-fullyear "-" date-month "-" date-mdaypartial_time// partial-time   = time-hour ":" time-minute ":" time-second [time-secfrac]time_offset// time-offset    = "Z" / time-numoffset// time-numoffset = ( "+" / "-" ) time-hour ":" time-minutedate_fullyear// date-fullyear  = 4DIGITdate_month// date-month     = 2DIGIT  ; 01-12date_mday// date-mday      = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on month/yeartime_delim// time-delim     = "T" / %x20 ; T, t, or spaceTIME_DELIMtime_hour// time-hour      = 2DIGIT  ; 00-23time_minute// time-minute    = 2DIGIT  ; 00-59time_second// time-second    = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second rulestime_secfrac// time-secfrac   = "." 1*DIGITunsigned_digitsDIGIT// DIGIT = %x30-39 ; 0-9local_datelocal_timetime_fraction_truncated// ;; Date and Time (as defined in RFC 3339)KEYVAL_SEPline_trailing// expression = ( ( ws comment ) ///                ( ws keyval ws [ comment ] ) ///                ( ws table ws [ comment ] ) ///                  ws )parse_wsparse_newlineparse_keyval// keyval = key keyval-sep val// ;; TOML// toml = expression *( newline expression )/// Type representing a TOML parse errorset_original/// Displays a TOML parse error/// TOML parse error at line 1, column 10/// 1 | 00:32:00.a999999///   |          ^/// Unexpected `a`/// Expected `digit`/// While parsing a Time/// While parsing a Date-Timetranslate_positionfirst_linestart_of_second_linesecond_linetest_translate_positionDuplicateKeyDottedKeyExtendWrongTypeduplicate_keyextend_wrong_typeseparated0// inline-table = inline-table-open inline-table-keyvals inline-table-closetable_from_pairsdescend_pathINLINE_TABLE_OPEN// inline-table-open  = %x7B ws     ; {INLINE_TABLE_CLOSE// inline-table-close = ws %x7D     ; }INLINE_TABLE_SEP// inline-table-sep   = ws %x2C ws  ; , Comma// keyval-sep = ws %x3D ws ; =inline_table_keyvalsinline_tablesinvalid_inline_tables// ;; Inline Table// inline-table-keyvals = [ inline-table-keyvals-non-empty ]// inline-table-keyvals-non-empty =// ( key keyval-sep val inline-table-sep inline-table-keyvals-non-empty ) /// ( key keyval-sep val )// key = simple-key / dotted-key// dotted-key = simple-key 1*( dot-sep simple-key )simple_key// simple-key = quoted-key / unquoted-key// quoted-key = basic-string / literal-stringunquoted_key// unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _UNQUOTED_CHARDOT_SEP// dot-sep   = ws %x2E ws  ; . Periodparse_documentparse_key_pathStrContextStrContextValueLocatednew_inputcheck_depthrecursingErrModedocumentsdocuments_parse_onlyinvalid_documents// boolean = true / false// directly define in `fn value`// integer = dec-int / hex-int / oct-int / bin-int// dec-int = [ minus / plus ] unsigned-dec-int// unsigned-dec-int = DIGIT / digit1-9 1*( DIGIT / underscore DIGIT )DIGIT1_9hex_int// hex-prefix = %x30.78               ; 0x// hex-int = hex-prefix HEXDIG *( HEXDIG / underscore HEXDIG )HEX_PREFIXoct_int// oct-prefix = %x30.6F               ; 0o// oct-int = oct-prefix digit0-7 *( digit0-7 / underscore digit0-7 )OCT_PREFIXDIGIT0_7bin_int// bin-prefix = %x30.62               ; 0b// bin-int = bin-prefix digit0-1 *( digit0-1 / underscore digit0-1 )BIN_PREFIXDIGIT0_1// float = float-int-part ( exp / frac [ exp ] )// float =/ special-float// float-int-part = dec-intfloat_// frac = decimal-point zero-prefixable-int// decimal-point = %x2E               ; .zero_prefixable_int// zero-prefixable-int = DIGIT *( DIGIT / underscore DIGIT )// exp = "e" float-exp-part// float-exp-part = [ minus / plus ] zero-prefixable-intspecial_float// special-float = [ minus / plus ] ( inf / nan )inf// inf = %x69.6e.66  ; infINF// nan = %x6e.61.6e  ; nanhexdig// HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"HEXDIGintegersassert_float_eqfloats// ;; Boolean// ;; Integer// ;; Floatcurrent_table_positioncurrent_tablecurrent_is_arraycurrent_table_pathinto_documenton_wson_commenton_keyvalstart_array_tablestart_tablefinalize_tableon_std_headeron_array_headerws_newlinesWSCHAR// string = ml-basic-string / basic-string / ml-literal-string / literal-string// basic-string = quotation-mark *basic-char quotation-mark// quotation-mark = %x22            ; "basic_chars// basic-char = basic-unescaped / escapedBASIC_UNESCAPED// basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii// escaped = escape escape-seq-char// escape = %x5C                    ; \escape_seq_char// escape-seq-char =  %x22         ; "    quotation mark  U+0022// escape-seq-char =/ %x5C         ; \    reverse solidus U+005C// escape-seq-char =/ %x62         ; b    backspace       U+0008// escape-seq-char =/ %x66         ; f    form feed       U+000C// escape-seq-char =/ %x6E         ; n    line feed       U+000A// escape-seq-char =/ %x72         ; r    carriage return U+000D// escape-seq-char =/ %x74         ; t    tab             U+0009// escape-seq-char =/ %x75 4HEXDIG ; uXXXX                U+XXXX// escape-seq-char =/ %x55 8HEXDIG ; UXXXXXXXX            U+XXXXXXXXhexescapeml_basic_string// ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body//                   ml-basic-string-delimML_BASIC_STRING_DELIM// ml-basic-string-delim = 3quotation-markml_basic_body// ml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]mlb_content// mlb-content = mlb-char / newline / mlb-escaped-nl// mlb-char = mlb-unescaped / escapedmlb_quotes// mlb-quotes = 1*2quotation-markMLB_UNESCAPED// mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-asciimlb_escaped_nl// mlb-escaped-nl = escape ws newline *( wschar / newline// When the last non-whitespace character on a line is a \,// it will be trimmed along with all whitespace// (including newlines) up to the next non-whitespace// character or closing delimiter.// literal-string = apostrophe *literal-char apostropheAPOSTROPHE// apostrophe = %x27 ; ' apostropheLITERAL_CHAR// literal-char = %x09 / %x20-26 / %x28-7E / non-asciiml_literal_string// ml-literal-string = ml-literal-string-delim [ newline ] ml-literal-body//                     ml-literal-string-delimML_LITERAL_STRING_DELIM// ml-literal-string-delim = 3apostropheml_literal_body// ml-literal-body = *mll-content *( mll-quotes 1*mll-content ) [ mll-quotes ]mll_content// mll-content = mll-char / newlineMLL_CHAR// mll-char = %x09 / %x20-26 / %x28-7E / non-asciimll_quotes// mll-quotes = 1*2apostropheml_basic_string_escape_ws// ;; String// ;; Basic String// ;; Multiline Basic String// ;; Literal String// ;; Multiline Literal String// https://github.com/rust-lang/rust/issues/41358STD_TABLE_OPEN// std-table-open  = %x5B ws     ; [ Left square bracketSTD_TABLE_CLOSE// std-table-close = ws %x5D     ; ] Right square bracketARRAY_TABLE_OPEN// array-table-open  = %x5B.5B ws  ; [[ Double left square bracketARRAY_TABLE_CLOSE// array-table-close = ws %x5D.5D  ; ]] Double right quare bracketstd_table// std-table = std-table-open key *( table-key-sep key) std-table-closearray_table// array-table = array-table-open key *( table-key-sep key) array-table-close// table = std-table / array-table// ;; Standard Table// ;; Array Table// ;; Table// wschar = ( %x20 /              ; Space//            %x09 )              ; Horizontal tab// ws = *wschar// non-ascii = %x80-D7FF / %xE000-10FFFF// - ASCII is 0xxxxxxx// - First byte for UTF-8 is 11xxxxxx// - Subsequent UTF-8 bytes are 10xxxxxxNON_EOL// non-eol = %x09 / %x20-7E / non-asciiCOMMENT_START_SYMBOL// comment-start-symbol = %x23 ; #// comment = comment-start-symbol *non-eol// newline = ( %x0A /              ; LF//             %x0D.0A )           ; CRLFws_newline// ws-newline       = *( wschar / newline )// ws-newlines      = newline *( wschar / newline )// note: this rule is not present in the original grammar// ws-comment-newline = *( ws-newline-nonempty / comment )// line-ending = newline / eof// line-trailing = ws [comment] skip-line-ending// val = string / boolean / array / inline-table / date-time / float / integerapply_rawRawStringInner/// Opaque string storage for raw TOML; internal to `toml_edit`to_str_with_default/// Access the underlying spanencode_with_default/// A value together with its `to_string` representation,/// including surrounding it whitespaces and comments./// Default-formatted valueset_repr_unchecked/// The wrapped value/// Auto formats the value./// The TOML representation of the value/// TOML-encoded value/// Access the underlying value/// A prefix and suffix,/// Including comments, whitespaces and newlines./// Creates a new decor from the given prefix and suffix./// Go back to default decor/// Get the prefix.prefix_encodeset_prefix/// Set the prefix./// Get the suffix.suffix_encode/// Set the suffix.KeySerializerSerializeDatetimeSerializeInlineTabletable_with_capacityDatetimeFieldSerializerMapValueSerializer/// Type could not be serialized to TOML/// Value was out of range for the given type/// `None` could not be serialized to TOML/// Key was not convertible to `String` for serializing to TOML/// A serialized date was invalid/// Other serialization error/// let toml = toml_edit::ser::to_string(&config).unwrap();/// "pretty" output. See `ValueSerializer::pretty` for more details.to_document/// Serialize the given data structure into a TOML document./// This would allow custom formatting to be applied, mixing with format preserving edits, etc.//! This module contains all the Serde support for serializing Rust structures into TOML.Pretty/// let value = serde::Serialize::serialize(///     toml_edit::ser::ValueSerializer::new()/// Creates a new serializer generate a TOML document.// Comments/spaces before and after the header// Whether to hide an empty table// Whether this is a proxy for dotted keysdoc_position// Used for putting tables back in their original order when serialising.// `None` for user created tables (can be overridden with `set_position`)/// Type representing a TOML non-inline tableinto_inline_table/// Convert to an inline table/// Sorts Key/Value Pairs of the table./// Doesn't affect subtables or subarrays.set_implicit/// If a table has no key/value pairs and implicit, it will not be displayed./// [target."x86_64/windows.json".dependencies]/// In the document above, tables `target` and `target."x86_64/windows.json"` are implicit./// use toml_edit::Document;/// let mut doc = "[a]\n[a.b]\n".parse::<Document>().expect("invalid toml");/// doc["a"].as_table_mut().unwrap().set_implicit(true);/// assert_eq!(doc.to_string(), "[a.b]\n");/// Sets the position of the `Table` within the `Document`./// The position of the `Table` within the `Document`./// Returns `None` if the `Table` was created manually (i.e. not via parsing)/// in which case its position is set automatically.  This can be overridden with/// [`Table::set_position`]./// Returns an iterator over all key/value pairs, including empty./// Returns an mutable iterator over all key/value pairs, including empty./// Returns the number of non-empty items in the table./// Returns true if the table is empty./// Returns an optional reference to an item given the key./// Returns an optional mutable reference to an item given the key./// Returns true if the table contains an item with the given key.contains_table/// Returns true if the table contains a table with the given key.contains_value/// Returns true if the table contains a value with the given key.contains_array_of_tables/// Returns true if the table contains an array of tables with the given key./// In other words, remove all pairs `(key, item)` for which/// `keep(&key, &mut item)` returns `false`.decorate_table// `key1 = value1`/// An iterator type over `Table`'s key/value pairs./// A mutable iterator type over `Table`'s key/value pairs./// Returns the number of nonempty items./// This trait represents either a `Table`, or an `InlineTable`./// A string value./// A 64-bit float value./// A boolean value./// An RFC 3339 formatted date-time with offset./// An inline array of values./// An inline table of key/value pairs./// Representation of a TOML Value (as part of a Key/Value Pair)./// Get the decoration of the value./// let v = toml_edit::Value::from(true);/// assert_eq!(v.decor().suffix(), None);/// Sets the prefix and the suffix for value./// let mut v = toml_edit::Value::from(42);/// assert_eq!(&v.to_string(), "42");/// let d = v.decorated(" ", " ");/// assert_eq!(&d.to_string(), " 42 ");decorate// `{ key = value }`// `[value1, value2]`from_iter_formattingvisit_document'docvisit_inline_tablevisit_table_likevisit_table_like_kvvisit_array_of_tablesvisit_booleanvisit_datetimevisit_floatvisit_integer/// Document tree traversal to mutate an exclusive borrow of a document tree in-place./// See the [module documentation](self) for details.empty_visit//! Document tree traversal to walk a shared borrow of a document tree.//! Each method of the [`Visit`] trait is a hook that can be overridden//! to customize the behavior when mutating the corresponding type of node.//! By default, every method recursively visits the substructure of the//! input by invoking the right visitor method of each of its fields.//! # use toml_edit::{Item, ArrayOfTables, Table, Value};//! pub trait Visit<'doc> {//!     fn visit_item(&mut self, i: &'doc Item) {//!         visit_item(self, i);//!     # fn visit_value(&mut self, i: &'doc Value);//!     # fn visit_table(&mut self, i: &'doc Table);//!     # fn visit_array_of_tables(&mut self, i: &'doc ArrayOfTables);//! pub fn visit_item<'doc, V>(v: &mut V, node: &'doc Item)//!     V: Visit<'doc> + ?Sized,//!     match node {//!         Item::None => {}//!         Item::Value(value) => v.visit_value(value),//!         Item::Table(table) => v.visit_table(table),//!         Item::ArrayOfTables(array) => v.visit_array_of_tables(array),//! The API is modeled after [`syn::visit`](https://docs.rs/syn/1/syn/visit).//! This visitor stores every string in the document.//! # use toml_edit::*;//! use toml_edit::visit::*;//! struct StringCollector<'doc> {//!     strings: Vec<&'doc str>,//! impl<'doc> Visit<'doc> for StringCollector<'doc> {//!     fn visit_string(&mut self, node: &'doc Formatted<String>) {//!          self.strings.push(node.value().as_str());//! let input = r#"//! laputa = "sky-castle"//! the-force = { value = "surrounds-you" }//! let mut document: Document = input.parse().unwrap();//! let mut visitor = StringCollector::default();//! visitor.visit_document(&document);//! assert_eq!(visitor.strings, vec!["sky-castle", "surrounds-you"]);//! For a more complex example where the visitor has internal state, see `examples/visit.rs`//! [on GitHub](https://github.com/ordian/toml_edit/blob/master/examples/visit.rs).visit_inline_table_mutvisit_table_like_mut/// [`visit_table_mut`](Self::visit_table_mut) and/// [`visit_inline_table_mut`](Self::visit_inline_table_mut) both recurse into this method.visit_table_like_kv_mutvisit_array_of_tables_mutvisit_boolean_mutvisit_datetime_mutvisit_float_mutvisit_integer_mutvisit_string_mutempty_visit_mut//! Document tree traversal to mutate an exclusive borrow of a document tree in place.//! Each method of the [`VisitMut`] trait is a hook that can be overridden//! pub trait VisitMut {//!     fn visit_item_mut(&mut self, i: &mut Item) {//!         visit_item_mut(self, i);//!     # fn visit_value_mut(&mut self, i: &mut Value);//!     # fn visit_table_mut(&mut self, i: &mut Table);//!     # fn visit_array_of_tables_mut(&mut self, i: &mut ArrayOfTables);//! pub fn visit_item_mut<V>(v: &mut V, node: &mut Item)//!     V: VisitMut + ?Sized,//!         Item::Value(value) => v.visit_value_mut(value),//!         Item::Table(table) => v.visit_table_mut(table),//!         Item::ArrayOfTables(array) => v.visit_array_of_tables_mut(array),//! The API is modeled after [`syn::visit_mut`](https://docs.rs/syn/1/syn/visit_mut).//! This visitor replaces every floating point value with its decimal string representation, to//! 2 decimal points.//! use toml_edit::visit_mut::*;//! struct FloatToString;//! impl VisitMut for FloatToString {//!     fn visit_value_mut(&mut self, node: &mut Value) {//!         if let Value::Float(f) = node {//!             // Convert the float to a string.//!             let mut s = Formatted::new(format!("{:.2}", f.value()));//!             // Copy over the formatting.//!             std::mem::swap(s.decor_mut(), f.decor_mut());//!             *node = Value::String(s);//!         // Most of the time, you will also need to call the default implementation to recurse//!         // further down the document tree.//!         visit_value_mut(self, node);//! banana = 3.26//! table = { apple = 4.5 }//! let mut visitor = FloatToString;//! visitor.visit_document_mut(&mut document);//! let output = r#"//! banana = "3.26"//! table = { apple = "4.50" }//! assert_eq!(format!("{}", document), output);SerializeVariantcustom_providersurl_errorRfc6238Rfc6238ErrorSecretParseErrorTotpUrlErrorHmacSha512/// Algorithm enum holds the three standards algorithms for TOTP as per the [reference implementation](https://tools.ietf.org/html/rfc6238#appendix-A)/// SHA-1 is the most widespread algorithm used, and for totp pursposes, SHA-1 hash collisions are [not a problem](https://tools.ietf.org/html/rfc4226#appendix-B.2) as HMAC-SHA-1 is not impacted. It's also the main one cited in [rfc-6238](https://tools.ietf.org/html/rfc6238#section-3) even though the [reference implementation](https://tools.ietf.org/html/rfc6238#appendix-A) permits the use of SHA-1, SHA-256 and SHA-512. Not all clients support other algorithms then SHA-1/// The number of digits composing the auth code. Per [rfc-4226](https://tools.ietf.org/html/rfc4226#section-5.3), this can oscilate between 6 and 8 digits/// Number of steps allowed as network delay. 1 would mean one step before current step and one step after are valids. The recommended value per [rfc-6238](https://tools.ietf.org/html/rfc6238#section-5.2) is 1. Anything more is sketchy, and anyone recommending more is, by definition, ugly and stupid/// Duration in seconds of a step. The recommended value per [rfc-6238](https://tools.ietf.org/html/rfc6238#section-5.2) is 30 seconds/// As per [rfc-4226](https://tools.ietf.org/html/rfc4226#section-4) the secret should come from a strong source, most likely a CSPRNG. It should be at least 128 bits, but 160 are recommended/// non-encoded value/// The "Github" part of "Github:constantoine@github.com". Must not contain a colon `:`/// For example, the name of your service/website./// Not mandatory, but strongly recommended!/// The "constantoine@github.com" part of "Github:constantoine@github.com". Must not contain a colon `:`/// For example, the name of your user's account.TOTP/// TOTP holds informations as to how to generate an auth code and validate it. Its [secret](struct.TOTP.html#structfield.secret) field is sensitive data, treat it accordingly/// Will not check for issuer and account_name equality/// As they aren't taken in account for token generation/token checking/// Will create a new instance of TOTP with given parameters. See [the doc](struct.TOTP.html#fields) for reference as to how to choose those values/// # Description/// * `secret`: expect a non-encoded value, to pass in base32 string use `Secret::Encoded(String)`/// * `digits`: MUST be between 6 & 8/// * `secret`: Must have bitsize of at least 128/// * `account_name`: Must not contain `:`/// * `issuer`: Must not contain `:`/// use totp_rs::{Secret, TOTP, Algorithm};/// let secret = Secret::Encoded("OBWGC2LOFVZXI4TJNZTS243FMNZGK5BNGEZDG".to_string());/// let totp = TOTP::new(Algorithm::SHA1, 6, 1, 30, secret.to_bytes().unwrap(), None, "".to_string()).unwrap();/// Will return an error if the `digit` or `secret` size is invalid or if `issuer` or `label` contain the character ':'/// Will create a new instance of TOTP with given parameters. See [the doc](struct.TOTP.html#fields) for reference as to how to choose those values. This is unchecked and does not check the `digits` and `secret` size/// let totp = TOTP::new_unchecked(Algorithm::SHA1, 6, 1, 30, secret.to_bytes().unwrap(), None, "".to_string());from_rfc6238/// Will create a new instance of TOTP from the given [Rfc6238](struct.Rfc6238.html) struct/// Will return an error in case issuer or label contain the character ':'/// Will sign the given timestamp/// Will generate a token given the provided timestamp in seconds/// Returns the timestamp of the first second for the next step/// given the provided timestamp in secondsnext_step_current/// Returns the timestamp of the first second of the next step/// According to system time/// Give the ttl (in seconds) of the current tokengenerate_current/// Generate a token from the current system time/// Will check if token is valid given the provided timestamp in seconds, accounting [skew](struct.TOTP.html#structfield.skew)check_current/// Will check if token is valid by current system time, accounting [skew](struct.TOTP.html#structfield.skew)get_secret_base32/// Will return the base32 representation of the secret, which might be useful when users want to manually add the secret to their authenticatorfrom_url/// Generate a TOTP from the standard otpauth URLfrom_url_unchecked/// Generate a TOTP from the standard otpauth URL, using `TOTP::new_unchecked` internallyparts_from_url/// Parse the TOTP parts from the standard otpauth URLget_url/// Will generate a standard URL used to automatically add TOTP auths. Usually used with qr codes/// Label and issuer will be URL-encoded if needed be/// Secret will be base 32'd without padding, as per RFC.new_wrong_issuernew_wrong_account_namenew_wrong_account_name_no_issuercomparison_okurl_for_secret_matches_sha1_without_issuerurl_for_secret_matches_sha1url_for_secret_matches_sha256url_for_secret_matches_sha512ttl_okfrom_url_errfrom_url_defaultfrom_url_queryfrom_url_query_sha512from_url_to_urlfrom_url_unknown_paramfrom_url_issuer_specialfrom_url_account_name_issuerfrom_url_account_name_issuer_encodedfrom_url_query_issuerfrom_url_wrong_schemefrom_url_wrong_algofrom_url_query_different_issuers//! This library permits the creation of 2FA authentification tokens per TOTP, the verification of said tokens, with configurable time skew, validity time of each token, algorithm and number of digits! Default features are kept as low-dependency as possible to ensure small binaries and short compilation time//! Be aware that some authenticator apps will accept the `SHA256`//! and `SHA512` algorithms but silently fallback to `SHA1` which will//! make the `check()` function fail due to mismatched algorithms.//! Use the `SHA1` algorithm to avoid this problem.//! # #[cfg(feature = "otpauth")] {//! use std::time::SystemTime;//! use totp_rs::{Algorithm, TOTP, Secret};//! let totp = TOTP::new(//!     Algorithm::SHA1,//!     6,//!     1,//!     30,//!     Secret::Raw("TestSecretSuperSecret".as_bytes().to_vec()).to_bytes().unwrap(),//!     Some("Github".to_string()),//!     "constantoine@github.com".to_string(),//! let token = totp.generate_current().unwrap();//! println!("{}", token);//! # #[cfg(feature = "qr")] {//! use totp_rs::{Algorithm, TOTP};//!     "supersecret_topsecret".as_bytes().to_vec(),//! let url = totp.get_url();//! println!("{}", url);//! let code = totp.get_qr_base64().unwrap();//! println!("{}", code);// enable `doc_cfg` feature for `docs.rs`.InvalidDigits/// Implementations MUST extract a 6-digit code at a minimum and possibly 7 and 8-digit code.SecretTooSmall/// The length of the shared secret MUST be at least 128 bits./// Error returned when input is not compliant to [rfc-6238](https://tools.ietf.org/html/rfc6238).assert_digitsassert_secret_length/// SHA-1/// The number of digits composing the auth code. Per [rfc-4226](https://tools.ietf.org/html/rfc4226#section-5.3), this can oscilate between 6 and 8 digits./// The recommended value per [rfc-6238](https://tools.ietf.org/html/rfc6238#section-5.2) is 1./// The recommended value per [rfc-6238](https://tools.ietf.org/html/rfc6238#section-5.2) is 30 seconds./// As per [rfc-4226](https://tools.ietf.org/html/rfc4226#section-4) the secret should come from a strong source, most likely a CSPRNG. It should be at least 128 bits, but 160 are recommended./// The "constantoine@github.com" part of "Github:constantoine@github.com". Must not contain a colon `:`./// [rfc-6238](https://tools.ietf.org/html/rfc6238) compliant set of options to create a [TOTP](struct.TOTP.html)/// use totp_rs::{Rfc6238, TOTP};/// let mut rfc = Rfc6238::with_defaults(///     "totp-sercret-123".as_bytes().to_vec()/// // optional, set digits, issuer, account_name/// rfc.digits(8).unwrap();/// let totp = TOTP::from_rfc6238(rfc).unwrap();/// Create an [rfc-6238](https://tools.ietf.org/html/rfc6238) compliant set of options that can be turned into a [TOTP](struct.TOTP.html)./// will return a [Rfc6238Error](enum.Rfc6238Error.html) when/// - `digits` is lower than 6 or higher than 8./// - `secret` is smaller than 128 bits (16 characters)./// Create an [rfc-6238](https://tools.ietf.org/html/rfc6238) compliant set of options that can be turned into a [TOTP](struct.TOTP.html),/// with a default value of 6 for `digits`, None `issuer` and an empty account./// Set the `digits`./// Set the `issuer`./// Set the `account_name`./// Try to create a [TOTP](struct.TOTP.html) from a [Rfc6238](struct.Rfc6238.html) config.GOOD_SECRETISSUERINVALID_ACCOUNTrfc_to_totp_failrfc_to_totp_okrfc_with_default_set_valuesParseBase32/// Invalid base32 input./// Different ways secret parsing failed./// Non-encoded "raw" secret./// Base32 encoded secret./// Shared secret between client and server to validate token against/generate token from./// Will check that to_bytes() returns the same./// One secret can be Raw, and the other Encoded./// Get the inner String value as a Vec of bytes./// Try to transform a `Secret::Encoded` into a `Secret::Raw`to_encoded/// Try to transforms a `Secret::Raw` into a `Secret::Encoded`.generate_secret/// Generate a CSPRNG binary value of 160 bits,/// the recomended size from [rfc-4226](https://www.rfc-editor.org/rfc/rfc4226#section-4)./// > The length of the shared secret MUST be at least 128 bits./// > This document RECOMMENDs a shared secret length of 160 bits./// ⚠️ The generated secret is not guaranteed to be a valid UTF-8 sequence.BYTES_DISPLAYsecret_displaysecret_convert_base32_rawsecret_as_bytessecret_from_stringsecret_gen_secretsecret_gen_defaultsecret_empty//! Representation of a secret either a "raw" \[u8\] or "base 32" encoded String//! - Create a TOTP from a "raw" secret//! # #[cfg(not(feature = "otpauth"))] {//! use totp_rs::{Secret, TOTP, Algorithm};//! let secret = [//!     0x70, 0x6c, 0x61, 0x69, 0x6e, 0x2d, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2d, 0x73, 0x65,//!     0x63, 0x72, 0x65, 0x74, 0x2d, 0x31, 0x32, 0x33,//! let secret_raw = Secret::Raw(secret.to_vec());//! let totp_raw = TOTP::new(//!     secret_raw.to_bytes().unwrap(),//! println!("code from raw secret:\t{}", totp_raw.generate_current().unwrap());//! - Create a TOTP from a base32 encoded secret//! let secret_b32 = Secret::Encoded(String::from("OBWGC2LOFVZXI4TJNZTS243FMNZGK5BNGEZDG"));//! let totp_b32 = TOTP::new(//!     secret_b32.to_bytes().unwrap(),//! println!("code from base32:\t{}", totp_b32.generate_current().unwrap());//! - Create a TOTP from a Generated Secret//! # #[cfg(all(feature = "gen_secret", not(feature = "otpauth")))] {//! let secret_b32 = Secret::default();//! - Create a TOTP from a Generated Secret 2//! let secret_b32 = Secret::generate_secret();/// Couldn't decode URL./// Invalid scheme./// Invalid host./// Wrong base32 input.SecretSize/// Invalid secret size. (Too short?)/// Unknown algorithm./// Characters should only be digits.DigitsNumber/// Digits should be between 6 and 8./// Couldn't decode step into a number./// Issuer contains invalid character `:`.IssuerDecoding/// Couldn't decode issuer.IssuerMistmatch/// Issuers should be the same.AccountName/// Account name contains invalid character `:` or couldn't be decoded.AccountNameDecoding/// Couldn't parse account name./// Errors returned mostly upon decoding URL.account_name_decodingdigits_numberissuer_decodingissuer_mismatchsecret_size/// The balancer's endpoint discovery stream failed.//! Error types for the [`tower::balance`] middleware.//! [`tower::balance`]: crate::balancep2c//! Middleware that allows balancing load among multiple services.//! In larger systems, multiple endpoints are often available for a given service. As load//! increases, you want to ensure that that load is spread evenly across the available services.//! Otherwise, clients could see spikes in latency if their request goes to a particularly loaded//! service, even when spare capacity is available to handle that request elsewhere.//! This module provides the [`p2c`] middleware, which implements the "[Power of//! Two Random Choices]" algorithm. This is a simple but robust  technique for//! spreading load across services with only inexact load measurements. Use this//! if the set of available services is not within your control, and you simply//! want to spread load among that set of services.//! [Power of Two Random Choices]: http://www.eecs.harvard.edu/~michaelm/postscripts/handbook2001.pdf//! # #[cfg(feature = "util")]//! # #[cfg(feature = "load")]//! # fn warnings_are_errors() {//! use tower::balance::p2c::Balance;//! use tower::load::Load;//! use tower::{Service, ServiceExt};//! use futures_util::pin_mut;//! # use futures_core::Stream;//! # use futures_util::StreamExt;//! async fn spread<Req, S: Service<Req> + Load>(svc1: S, svc2: S, reqs: impl Stream<Item = Req>)//!     S::Error: Into<tower::BoxError>,//! # // this bound is pretty unfortunate, and the compiler does _not_ help//!     S::Metric: std::fmt::Debug,//!     // Spread load evenly across the two services//!     let p2c = Balance::new(tower::discover::ServiceList::new(vec![svc1, svc2]));//!     // Issue all the requests that come in.//!     // Some will go to svc1, some will go to svc2.//!     pin_mut!(reqs);//!     let mut responses = p2c.call_all(reqs);//!     while let Some(rsp) = responses.next().await {MakeBalanceMakeBalanceLayer/// Construct load balancers ([`Balance`]) over dynamic service sets ([`Discover`]) produced by the/// "inner" service in response to requests coming from the "outer" service./// This construction may seem a little odd at first glance. This is not a layer that takes/// requests and produces responses in the traditional sense. Instead, it is more like/// [`MakeService`] in that it takes service _descriptors_ (see `Target` on [`MakeService`])/// and produces _services_. Since [`Balance`] spreads requests across a _set_ of services,/// the inner service should produce a [`Discover`], not just a single/// [`Service`], given a service descriptor./// See the [module-level documentation](crate::balance) for details on load balancing./// [`Balance`]: crate::balance::p2c::Balance/// [`Discover`]: crate::discover::Discover/// [`MakeService`]: crate::MakeService/// [`Service`]: crate::Service/// Build balancers using operating system entropy.Balance/// Constructs load balancers over dynamic service sets produced by a wrapped "inner" service./// This is effectively an implementation of [`MakeService`] except that it forwards the service/// descriptors (`Target`) to an inner service (`S`), and expects that service to produce a/// service set in the form of a [`Discover`]. It then wraps the service set in a [`Balance`]/// before returning it as the "made" service.MakeFuture//! This module implements the "[Power of Two Random Choices]" load balancing algorithm.//! It is a simple but robust technique for spreading load across services with only inexact load//! measurements. As its name implies, whenever a request comes in, it samples two ready services//! at random, and issues the request to whichever service is less loaded. How loaded a service is//! is determined by the return value of [`Load`](crate::load::Load).//! As described in the [Finagle Guide][finagle]://! > The algorithm randomly picks two services from the set of ready endpoints and//! > selects the least loaded of the two. By repeatedly using this strategy, we can//! > expect a manageable upper bound on the maximum load of any server.//! > The maximum load variance between any two servers is bound by `ln(ln(n))` where//! > `n` is the number of servers in the cluster.//! The balance service and layer implementations rely on _service discovery_ to provide the//! underlying set of services to balance requests across. This happens through the//! [`Discover`](crate::discover::Discover) trait, which is essentially a [`Stream`] that indicates//! when services become available or go away. If you have a fixed set of services, consider using//! [`ServiceList`](crate::discover::ServiceList).//! Since the load balancer needs to perform _random_ choices, the constructors in this module//! usually come in two forms: one that uses randomness provided by the operating system, and one//! that lets you specify the random seed to use. Usually the former is what you'll want, though//! the latter may come in handy for reproducibility or to reduce reliance on the operating system.//! [finagle]: https://twitter.github.io/finagle/guide/Clients.html#power-of-two-choices-p2c-least-loadedChangeready_cacheReadyCachesample_floyd2HasherRngready_index/// Efficiently distributes requests across an arbitrary number of services./// See the [module-level documentation](..) for details./// Note that [`Balance`] requires that the [`Discover`] you use is [`Unpin`] in order to implement/// [`Service`]. This is because it needs to be accessed from [`Service::poll_ready`], which takes/// `&mut self`. You can achieve this easily by wrapping your [`Discover`] in [`Box::pin`] before you/// construct the [`Balance`] instance. For more details, see [#319]./// [`Box::pin`]: std::boxed::Box::pin()/// [#319]: https://github.com/tower-rs/tower/issues/319/// Constructs a load balancer that uses operating system entropy./// Constructs a load balancer seeded with the provided random number generator./// Returns the number of endpoints currently tracked by the balancer./// Returns whether or not the balancer is empty.update_pending_from_discover/// Polls `discover` for updates, adding new items to `not_ready`./// Removals may alter the order of either `ready` or `not_ready`.promote_pending_to_readyp2c_ready_index/// Performs P2C on inner services to find a suitable endpoint.ready_index_loadMetric/// Accesses a ready endpoint by index and returns its current load.ServiceListtower_testassert_request_eqsingle_endpointtwo_endpoints_with_equal_loadServiceError/// An error produced by a [`Service`] wrapped by a [`Buffer`]/// An error produced when the a buffer's worker closes unexpectedly.// Private to avoid exposing `Clone` trait as part of the public API//! Error types for the `Buffer` middleware.// ===== impl ServiceError =====// ===== impl Closed =====//! Future types for the [`Buffer`] middleware.//! [`Buffer`]: crate::buffer::BufferBufferLayer/// Adds an mpsc buffer in front of an inner service./// The default Tokio executor is used to run the given service,/// which means that this layer can only be used on the Tokio runtime./// Creates a new [`BufferLayer`] with the provided `bound`./// `bound` gives the maximal number of requests that can be queued for the service before/// backpressure is applied to callers./// # A note on choosing a `bound`/// When [`Buffer`]'s implementation of [`poll_ready`] returns [`Poll::Ready`], it reserves a/// slot in the channel for the forthcoming [`call`]. However, if this call doesn't arrive,/// this reserved slot may be held up for a long time. As a result, it's advisable to set/// `bound` to be at least the maximum number of concurrent requests the [`Buffer`] will see./// If you do not, all the slots in the buffer may be held up by futures that have just called/// [`poll_ready`] but will not issue a [`call`], which prevents other senders from issuing new/// [`Poll::Ready`]: std::task::Poll::Ready/// [`call`]: crate::Service::call/// [`poll_ready`]: crate::Service::poll_ready/// Message sent over buffer/// Response sender/// Response receiver//! Middleware that provides a buffered mpsc channel to a service.//! Sometimes you want to give out multiple handles to a single service, and allow each handle to//! enqueue requests. That is, you want a [`Service`] to be [`Clone`]. This module allows you to do//! that by placing the service behind a multi-producer, single-consumer buffering channel. Clients//! enqueue requests by sending on the channel from any of the handles ([`Buffer`]), and the single//! service running elsewhere (usually spawned) receives and services the requests one by one. Each//! request is enqueued alongside a response channel that allows the service to report the result//! of the request back to the caller.//! use tower::buffer::Buffer;//! async fn mass_produce<S: Service<usize>>(svc: S)//!   S: 'static + Send,//!   S::Error: Send + Sync + std::error::Error,//!   S::Future: Send//!     let svc = Buffer::new(svc, 10 /* buffer length */);//!         let mut svc = svc.clone();//!             for i in 0usize.. {//!                 svc.ready().await.expect("service crashed").call(i).await;//! [`Service`]: crate::Service/// Creates a new [`Buffer`] wrapping `service`./// The default Tokio executor is used to run the given service, which means that this method/// must be called while on the Tokio runtime./// Creates a new [`Buffer`] wrapping `service`, but returns the background worker./// This is useful if you do not want to spawn directly onto the tokio runtime/// but instead want to use your own executor. This will return the [`Buffer`] and/// the background `Worker` that you can then spawn.get_worker_errorRsp/// Get the error outpoll_next_msg/// Return the next queued Message that hasn't been canceled./// If a `Message` is returned, the `bool` is true if this is the first time we received this/// message, and false otherwise (i.e., we tried to forward it to the backing service before).get_error_on_closed/// Declaratively construct [`Service`] values./// [`ServiceBuilder`] provides a [builder-like interface][builder] for composing/// layers to be applied to a [`Service`]./// # Service/// A [`Service`] is a trait representing an asynchronous function of a request/// to a response. It is similar to `async fn(Request) -> Result<Response, Error>`./// A [`Service`] is typically bound to a single transport, such as a TCP/// connection.  It defines how _all_ inbound or outbound requests are handled/// by that connection./// [builder]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html/// The order in which layers are added impacts how requests are handled. Layers/// that are added first will be called with the request first. The argument to/// `service` will be last to see the request./// # // this (and other) doctest is ignored because we don't have a way/// # // to say that it should only be run with cfg(feature = "...")/// # use tower::Service;/// # use tower::builder::ServiceBuilder;/// # #[cfg(all(feature = "buffer", feature = "limit"))]/// # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {/// ServiceBuilder::new()///     .buffer(100)///     .concurrency_limit(10)///     .service(svc)/// In the above example, the buffer layer receives the request first followed/// by `concurrency_limit`. `buffer` enables up to 100 request to be in-flight/// **on top of** the requests that have already been forwarded to the next/// layer. Combined with `concurrency_limit`, this allows up to 110 requests to be/// in-flight./// The above example is similar, but the order of layers is reversed. Now,/// `concurrency_limit` applies first and only allows 10 requests to be in-flight/// total./// A [`Service`] stack with a single layer:/// # #[cfg(feature = "limit")]/// # use tower::limit::concurrency::ConcurrencyLimitLayer;///     .concurrency_limit(5)///     .service(svc);/// A [`Service`] stack with _multiple_ layers that contain rate limiting,/// in-flight request limits, and a channel-backed, clonable [`Service`]:///     .buffer(5)///     .rate_limit(5, Duration::from_secs(1))/// Create a new [`ServiceBuilder`]./// Add a new layer `T` into the [`ServiceBuilder`]./// This wraps the inner service with the service provided by a user-defined/// [`Layer`]. The provided layer must implement the [`Layer`] trait./// [`Layer`]: crate::Layeroption_layer/// Optionally add a new layer `T` into the [`ServiceBuilder`]./// # use tower::timeout::TimeoutLayer;/// # let timeout = Some(Duration::new(10, 0));/// // Apply a timeout if configured///     .option_layer(timeout.map(TimeoutLayer::new))layer_fnLayerFn/// Add a [`Layer`] built from a function that accepts a service and returns another service./// See the documentation for [`layer_fn`] for more details./// [`layer_fn`]: crate::layer::layer_fnRetryLayer/// Retry failed requests according to the given [retry policy][policy]./// `policy` determines which failed requests will be retried. It must/// implement the [`retry::Policy`][policy] trait./// This wraps the inner service with an instance of the [`Retry`]/// middleware./// [`Retry`]: crate::retry/// [policy]: crate::retry::Policy/// Fail requests that take longer than `timeout`./// If the next layer takes more than `timeout` to respond to a request,/// processing is terminated and an error is returned./// This wraps the inner service with an instance of the [`timeout`]/// [`timeout`]: crate::timeout/// Map one request type to another./// This wraps the inner service with an instance of the [`MapRequest`]/// Changing the type of a request:/// use tower::ServiceBuilder;/// use tower::ServiceExt;/// # async fn main() -> Result<(), ()> {/// // Suppose we have some `Service` whose request type is `String`:/// let string_svc = tower::service_fn(|request: String| async move {///     println!("request: {}", request);/// // ...but we want to call that service with a `usize`. What do we do?/// let usize_svc = ServiceBuilder::new()///      // Add a middleware that converts the request type to a `String`:///     .map_request(|request: usize| format!("{}", request))///     // ...and wrap the string service with that middleware:///     .service(string_svc);/// // Now, we can call that service with a `usize`:/// usize_svc.oneshot(42).await?;/// Modifying the request value:/// // A service that takes a number and returns it:/// let svc = tower::service_fn(|request: usize| async move {///    Ok(request)/// let svc = ServiceBuilder::new()///      // Add a middleware that adds 1 to each request///     .map_request(|request: usize| request + 1)/// let response = svc.oneshot(1).await?;/// assert_eq!(response, 2);/// [`MapRequest`]: crate::util::MapRequestmap_responseMapResponseLayer/// Map one response type to another./// This wraps the inner service with an instance of the [`MapResponse`]/// See the documentation for the [`map_response` combinator] for details./// [`MapResponse`]: crate::util::MapResponse/// [`map_response` combinator]: crate::util::ServiceExt::map_responseMapErrLayer/// Map one error type to another./// This wraps the inner service with an instance of the [`MapErr`]/// See the documentation for the [`map_err` combinator] for details./// [`MapErr`]: crate::util::MapErr/// [`map_err` combinator]: crate::util::ServiceExt::map_errmap_futureMapFutureLayer/// Composes a function that transforms futures produced by the service./// This wraps the inner service with an instance of the [`MapFutureLayer`] middleware./// See the documentation for the [`map_future`] combinator for details./// [`MapFutureLayer`]: crate::util::MapFutureLayer/// [`map_future`]: crate::util::ServiceExt::map_futureThenLayer/// Apply an asynchronous function after the service, regardless of whether the future/// succeeds or fails./// This wraps the inner service with an instance of the [`Then`]/// This is similar to the [`map_response`] and [`map_err`] functions,/// except that the *same* function is invoked when the service's future/// completes, whether it completes successfully or fails. This function/// takes the [`Result`] returned by the service's future, and returns a/// [`Result`]./// See the documentation for the [`then` combinator] for details./// [`Then`]: crate::util::Then/// [`then` combinator]: crate::util::ServiceExt::then/// [`map_response`]: ServiceBuilder::map_response/// [`map_err`]: ServiceBuilder::map_errAndThenLayer/// Executes a new future after this service's future resolves. This does/// not alter the behaviour of the [`poll_ready`] method./// This method can be used to change the [`Response`] type of the service/// into a different type. You can use this method to chain along a computation once the/// service's response has been resolved./// This wraps the inner service with an instance of the [`AndThen`]/// See the documentation for the [`and_then` combinator] for details./// [`Response`]: crate::Service::Response/// [`and_then` combinator]: crate::util::ServiceExt::and_then/// [`AndThen`]: crate::util::AndThenMapResultLayer/// Maps this service's result type (`Result<Self::Response, Self::Error>`)/// to a different value, regardless of whether the future succeeds or/// This wraps the inner service with an instance of the [`MapResult`]/// See the documentation for the [`map_result` combinator] for details./// [`map_result` combinator]: crate::util::ServiceExt::map_result/// [`MapResult`]: crate::util::MapResult/// Returns the underlying `Layer` implementation./// Wrap the service `S` with the middleware provided by this/// [`ServiceBuilder`]'s [`Layer`]'s, returning a new [`Service`]./// Wrap the async function `F` with the middleware provided by this [`ServiceBuilder`]'s/// [`Layer`]s, returning a new [`Service`]./// This is a convenience method which is equivalent to calling/// [`ServiceBuilder::service`] with a [`service_fn`], like this:/// # use tower::{ServiceBuilder, service_fn};/// # async fn handler_fn(_: ()) -> Result<(), ()> { Ok(()) }/// # let _ = {///     .service(service_fn(handler_fn))/// use tower::{ServiceBuilder, ServiceExt, BoxError, service_fn};/// # async fn main() -> Result<(), BoxError> {/// async fn handle(request: &'static str) -> Result<&'static str, BoxError> {///     .buffer(1024)///     .service_fn(handle);/// let response = svc.oneshot("foo").await?;/// assert_eq!(response, "foo");/// [`service_fn`]: crate::service_fncheck_clone/// Check that the builder implements `Clone`./// This can be useful when debugging type errors in `ServiceBuilder`s with lots of layers./// Doesn't actually change the builder but serves as a type check./// let builder = ServiceBuilder::new()///     // Do something before processing the request///     .map_request(|request: String| {///         println!("got request!");///         request///     // Ensure our `ServiceBuilder` can be cloned///     .check_clone()///     // Do something after processing the request///     .map_response(|response: String| {///         println!("got response!");///         responsecheck_service_clone/// Check that the builder when given a service of type `S` produces a service that implements/// `Clone`./// # #[derive(Clone)]/// # struct MyService;///     // Ensure that the service produced when given a `MyService` implements///     .check_service_clone::<MyService>()check_service/// Check that the builder when given a service of type `S` produces a service with the given/// request, response, and error types./// use tower::{Service, ServiceExt};/// // An example service/// struct MyService;/// impl Service<Request> for MyService {///   type Response = Response;///   type Error = Error;///   type Future = futures_util::future::Ready<Result<Response, Error>>;///   fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {///       // ...///       # todo!()///   fn call(&mut self, request: Request) -> Self::Future {/// struct Request;/// struct Response;/// struct Error;/// struct WrappedResponse(Response);///     // At this point in the builder if given a `MyService` it produces a service that///     // accepts `Request`s, produces `Response`s, and fails with `Error`s///     .check_service::<MyService, Request, Response, Error>()///     // Wrap responses in `WrappedResponse`///     .map_response(|response: Response| WrappedResponse(response))///     // Now the response type will be `WrappedResponse`///     .check_service::<MyService, _, WrappedResponse, _>();BoxService/// This wraps the inner service with the [`Layer`] returned by [`BoxService::layer()`]./// See that method for more details./// use tower::{Service, ServiceBuilder, BoxError, util::BoxService};/// # struct Request;/// # struct Response;/// # impl Response {/// #     fn new() -> Self { Self }/// let service: BoxService<Request, Response, BoxError> = ServiceBuilder::new()///     .boxed()///     .load_shed()///     .concurrency_limit(64)///     .service_fn(|req: Request| async {///         Ok::<_, BoxError>(Response::new())/// # let service = assert_service(service);/// # fn assert_service<S, R>(svc: S) -> S/// # where S: Service<R> { svc }/// [`BoxService::layer()`]: crate::util::BoxService::layer()boxed_cloneBoxCloneService/// This wraps the inner service with the [`Layer`] returned by [`BoxCloneService::layer()`]./// This is similar to the [`boxed`] method, but it requires that `Self` implement/// [`Clone`], and the returned boxed service implements [`Clone`]./// See [`BoxCloneService`] for more details./// use tower::{Service, ServiceBuilder, BoxError, util::BoxCloneService};/// let service: BoxCloneService<Request, Response, BoxError> = ServiceBuilder::new()///     .boxed_clone()/// // The boxed service can still be cloned./// service.clone();/// [`BoxCloneService::layer()`]: crate::util::BoxCloneService::layer()/// [`BoxCloneService`]: crate::util::BoxCloneService/// [`boxed`]: Self::boxed//! Builder types to compose layers and servicesListVecTest// check that List can be directly over collectionsListVecIterTest/// A unique identifier for each active service./// An identifier can be re-used once a [`Change::Remove`] has been yielded for its service./// The type of [`Service`] yielded by this [`Discover`]./// Error produced during discoverypoll_discover/// Yields the next discovery change set./// A dynamically changing set of related services./// As new services arrive and old services are retired,/// [`Change`]s are returned which provide unique identifiers/// for the services./// A new service identified by key `K` was identified./// The service identified by key `K` disappeared./// A change in the service set.//! Service discovery//! This module provides the [`Change`] enum, which indicates the arrival or departure of a service//! from a collection of similar services. Most implementations should use the [`Discover`] trait//! in their bounds to indicate that they can handle services coming and going. [`Discover`] itself//! is primarily a convenience wrapper around [`TryStream<Ok = Change>`][`TryStream`].//! Every discovered service is assigned an identifier that is distinct among the currently active//! services. If that service later goes away, a [`Change::Remove`] is yielded with that service's//! identifier. From that point forward, the identifier may be re-used.//! use futures_util::{future::poll_fn, pin_mut};//! use tower::discover::{Change, Discover};//! async fn services_monitor<D: Discover>(services: D) {//!     pin_mut!(services);//!     while let Some(Ok(change)) = poll_fn(|cx| services.as_mut().poll_discover(cx)).await {//!         match change {//!             Change::Insert(key, svc) => {//!                 // a new service with identifier `key` was discovered//!                 # let _ = (key, svc);//!             Change::Remove(key) => {//!                 // the service with identifier `key` has gone away//!                 # let _ = (key);//! [`TryStream`]: https://docs.rs/futures/latest/futures/stream/trait.TryStream.htmlAsyncPredicateopaque_futureAsyncResponseFuture//! Future typesAsyncFilterFilterLayer/// Conditionally dispatch requests to the inner service based on a synchronous/// [predicate]./// This [`Layer`] produces instances of the [`Filter`] service./// [predicate]: crate::filter::Predicate/// [`Filter`]: crate::filter::FilterAsyncFilterLayer/// Conditionally dispatch requests to the inner service based on an asynchronous/// This [`Layer`] produces instances of the [`AsyncFilter`] service./// [predicate]: crate::filter::AsyncPredicate/// [`Filter`]: crate::filter::AsyncFilter/// Returns a new layer that produces [`Filter`] services with the given/// [`Predicate`]./// [`Predicate`]: crate::filter::Predicate/// Returns a new layer that produces [`AsyncFilter`] services with the given/// [`AsyncPredicate`]./// [`AsyncPredicate`]: crate::filter::AsyncPredicate// === impl FilterLayer ===// === impl AsyncFilterLayer ===/// Conditionally dispatch requests to the inner service based on a [predicate]./// [predicate]: Predicate/// Conditionally dispatch requests to the inner service based on an/// [asynchronous predicate]./// [asynchronous predicate]: AsyncPredicate/// Returns a new [`Filter`] service wrapping `inner`./// Returns a new [`Layer`] that wraps services with a [`Filter`] service/// with the given [`Predicate`]./// Check a `Request` value against this filter's predicate./// Get a reference to the inner service/// Get a mutable reference to the inner service/// Consume `self`, returning the inner service/// Returns a new [`AsyncFilter`] service wrapping `inner`./// Returns a new [`Layer`] that wraps services with an [`AsyncFilter`]/// service with the given [`AsyncPredicate`].//! Conditionally dispatch requests to the inner service based on the result of//! a predicate.//! A predicate takes some request type and returns a `Result<Request, Error>`.//! If the predicate returns [`Ok`], the inner service is called with the request//! returned by the predicate &mdash; which may be the original request or a//! modified one. If the predicate returns [`Err`], the request is rejected and//! the inner service is not called.//! Predicates may either be synchronous (simple functions from a `Request` to//! a [`Result`]) or asynchronous (functions returning [`Future`]s). Separate//! traits, [`Predicate`] and [`AsyncPredicate`], represent these two types of//! predicate. Note that when it is not necessary to await some other//! asynchronous operation in the predicate, the synchronous predicate should be//! preferred, as it introduces less overhead.//! The predicate traits are implemented for closures and function pointers.//! However, users may also implement them for other types, such as when the//! predicate requires some state carried between requests. For example,//! [`Predicate`] could be implemented for a type that rejects a fixed set of//! requests by checking if they are contained by a a [`HashSet`] or other//! collection.//! [`Future`]: std::future::Future//! [`HashSet`]: std::collections::HashSet// ==== impl Filter ====// ==== impl AsyncFilter ====/// The future returned by [`check`]./// [`check`]: crate::filter::AsyncPredicate::check/// The type of requests returned by [`check`]./// This request is forwarded to the inner service if the predicate/// succeeds./// Check whether the given request should be forwarded./// If the future resolves with [`Ok`], the request is forwarded to the inner service./// Checks a request asynchronously./// [`check`]: crate::filter::Predicate::check/// Checks a request synchronously./// A policy which specifies how long each request should be delayed for./// A middleware which delays sending the request to the underlying service/// for an amount of time specified by the policy.delayingcalled/// Record is the interface for accepting request latency measurements.  When/// a request completes, record is called with the elapsed duration between/// when the service was called and when the future completed.rec/// Latency is a middleware that measures request latency and records it to the/// provided Record instance.rotating_histogramRotatingHistogramHistoSelectPolicyDelayPolicyPolicyPredicateHedge/// A middleware that pre-emptively retries requests which have been outstanding/// for longer than a given latency percentile.  If either of the original/// future or the retry future completes, that value is used./// Called when the request is first received to determine if the request is retryable.can_retry/// Called after the hedge timeout to determine if the hedge retry should be issued./// A policy which describes which requests can be cloned and then whether those/// requests should be retried.histolatency_percentilemin_data_points/// Create a new hedge middleware.new_with_mock_latencies/// A hedge middleware with a prepopulated latency histogram.  This is usedful/// for integration tests.new_with_histo// TODO: Remove when Duration::as_millis() becomes stable.millis//! Pre-emptively retry requests which have been outstanding for longer//! than a given latency percentile.// NOTE: these are pub only because they appear inside a Future<F>hdrhistogramlast_rotation/// This represents a "rotating" histogram which stores two histogram, one which/// should be read and one which should be written to.  Every period, the read/// histogram is discarded and replaced by the write histogram.  The idea here/// is that the read histogram should always contain a full period (the previous/// period) of write operations.maybe_rotate/// A policy which decides which requests can be cloned and sent to the B/// Select is a middleware which attempts to clone the request and sends the/// original request to the A service and, if the request was able to be cloned,/// the cloned request to the B service.  Both resulting futures will be polled/// and whichever future completes first will be used as the result./// Utilities for combining layers/// [`Identity`]: crate::layer::util::Identity/// [`Stack`]: crate::layer::util::Stack//! A collection of [`Layer`] based tower services//! [`Layer`]: crate::LayerServiceExt/// Alias for a type-erased error type.// `rustdoc::broken_intra_doc_links` is checked on CI//! `async fn(Request) -> Result<Response, Error>`//! Tower is a library of modular and reusable components for building//! robust networking clients and servers.//! Tower provides a simple core abstraction, the [`Service`] trait, which//! represents an asynchronous function taking a request and returning either a//! response or an error. This abstraction can be used to model both clients and//! servers.//! Generic components, like [`timeout`], [rate limiting], and [load balancing],//! can be modeled as [`Service`]s that wrap some inner service and apply//! additional behavior before or after the inner service is called. This allows//! implementing these components in a protocol-agnostic, composable way. Typically,//! such services are referred to as _middleware_.//! An additional abstraction, the [`Layer`] trait, is used to compose//! middleware with [`Service`]s. If a [`Service`] can be thought of as an//! asynchronous function from a request type to a response type, a [`Layer`] is//! a function taking a [`Service`] of one type and returning a [`Service`] of a//! different type. The [`ServiceBuilder`] type is used to add middleware to a//! service by composing it with multiple [`Layer`]s.//! ## The Tower Ecosystem//! Tower is made up of the following crates://! * [`tower`] (this crate)//! * [`tower-service`]//! * [`tower-layer`]//! * [`tower-test`]//! Since the [`Service`] and [`Layer`] traits are important integration points//! for all libraries using Tower, they are kept as stable as possible, and//! breaking changes are made rarely. Therefore, they are defined in separate//! crates, [`tower-service`] and [`tower-layer`]. This crate contains//! re-exports of those core traits, implementations of commonly-used//! middleware, and [utilities] for working with [`Service`]s and [`Layer`]s.//! Finally, the [`tower-test`] crate provides tools for testing programs using//! Tower.//! Tower provides an abstraction layer, and generic implementations of various//! middleware. This means that the `tower` crate on its own does *not* provide//! a working implementation of a network client or server. Instead, Tower's//! [`Service` trait][`Service`] provides an integration point between//! application code, libraries providing middleware implementations, and//! libraries that implement servers and/or clients for various network//! protocols.//! Depending on your particular use case, you might use Tower in several ways://! * **Implementing application logic** for a networked program. You might//!   use the [`Service`] trait to model your application's behavior, and use//!   the middleware [provided by this crate](#modules) and by other libraries//!   to add functionality to clients and servers provided by one or more//!   protocol implementations.//! * **Implementing middleware** to add custom behavior to network clients and//!   servers in a reusable manner. This might be general-purpose middleware//!   (and if it is, please consider releasing your middleware as a library for//!   other Tower users!) or application-specific behavior that needs to be//!   shared between multiple clients or servers.//! * **Implementing a network protocol**. Libraries that implement network//!   protocols (such as HTTP) can depend on `tower-service` to use the//!   [`Service`] trait as an integration point between the protocol and user//!   code. For example, a client for some protocol might implement [`Service`],//!   allowing users to add arbitrary Tower middleware to those clients.//!   Similarly, a server might be created from a user-provided [`Service`].//!   Additionally, when a network protocol requires functionality already//!   provided by existing Tower middleware, a protocol implementation might use//!   Tower middleware internally, as well as as an integration point.//! ## Library Support//! A number of third-party libraries support Tower and the [`Service`] trait.//! The following is an incomplete list of such libraries://! * [`hyper`]: A fast and correct low-level HTTP implementation.//! * [`tonic`]: A [gRPC-over-HTTP/2][grpc] implementation built on top of//!   [`hyper`]. See [here][tonic-examples] for examples of using [`tonic`] with//!   Tower.//! * [`warp`]: A lightweight, composable web framework. See//!   [here][warp-service] for details on using [`warp`] with Tower.//! * [`tower-lsp`]: implementations of the [Language//!   Server Protocol][lsp] based on Tower.//! [`hyper`]: https://crates.io/crates/hyper//! [`tonic`]: https://crates.io/crates/tonic//! [tonic-examples]: https://github.com/hyperium/tonic/tree/master/examples/src/tower//! [grpc]: https://grpc.io//! [`warp`]: https://crates.io/crates/warp//! [warp-service]: https://docs.rs/warp/0.2.5/warp/fn.service.html//! [`tower-lsp`]: https://crates.io/crates/tower-lsp//! [lsp]: https://microsoft.github.io/language-server-protocol///! If you're the maintainer of a crate that supports Tower, we'd love to add//! your crate to this list! Please [open a PR] adding a brief description of//! your library!//! If you're brand new to Tower and want to start with the basics, we recommend you//! check out some of our [guides].//! The various middleware implementations provided by this crate are feature//! flagged, so that users can only compile the parts of Tower they need. By//! default, all the optional middleware are disabled.//! To get started using all of Tower's optional middleware, add this to your//! `Cargo.toml`://! tower = { version = "0.4", features = ["full"] }//! Alternatively, you can only enable some features. For example, to enable//! only the [`retry`] and [`timeout`] middleware, write://! tower = { version = "0.4", features = ["retry", "timeout"] }//! See [here](#modules) for a complete list of all middleware provided by//! ## Supported Rust Versions//! Tower will keep a rolling MSRV (minimum supported Rust version) policy of **at//! least** 6 months. When increasing the MSRV, the new Rust version must have been//! released at least six months ago. The current MSRV is 1.64.0.//! [rate limiting]: crate::limit::rate//! [load balancing]: crate::balance//! [`ServiceBuilder`]: crate::ServiceBuilder//! [utilities]: crate::ServiceExt//! [`tower`]: https://crates.io/crates/tower//! [`tower-service`]: https://crates.io/crates/tower-service//! [`tower-layer`]: https://crates.io/crates/tower-layer//! [`tower-test`]: https://crates.io/crates/tower-test//! [`retry`]: crate::retry//! [open a PR]: https://github.com/tower-rs/tower/compare//! [guides]: https://github.com/tower-rs/tower/tree/master/guides//! [`Future`] typesConcurrencyLimitConcurrencyLimitLayer/// Enforces a limit on the concurrent number of requests the underlying/// service can handle./// Create a new concurrency limit layer.GlobalConcurrencyLimitLayer/// Unlike [`ConcurrencyLimitLayer`], which enforces a per-service concurrency/// limit, this layer accepts a owned semaphore (`Arc<Semaphore>`) which can be/// shared across multiple services./// Cloning this layer will not create a new semaphore./// Create a new `GlobalConcurrencyLimitLayer`.with_semaphore/// Create a new `GlobalConcurrencyLimitLayer` from a `Arc<Semaphore>`//! Limit the max number of requests being concurrently processed.permit/// The currently acquired semaphore permit, if there is sufficient/// concurrency to send a new request./// The permit is acquired in `poll_ready`, and taken in `call` when sending/// a new request./// Create a new concurrency limiter./// Create a new concurrency limiter with a provided shared semaphoreconcurrencyRateLimitRateLimitLayer//! Tower middleware for limiting requests./// Enforces a rate limit on the number of requests the underlying/// service can handle over a period of time./// Create new rate limit layer.//! Limit the rate at which requests are processed./// A rate of requests per time period./// Create a new rate./// This function panics if `num` or `per` is 0.// The service has hit its limituntil/// Create a new rate limiter/// The instrumented value type.track_completion/// Attaches a `H`-typed handle to a `V`-typed value.TrackCompletion/// Attaches `H`-typed completion tracker to `V` typed values./// Handles (of type `H`) are intended to be RAII guards that primarily implement [`Drop`] and update/// load metric state as they are dropped. This trait allows implementors to "forward" the handle/// to later parts of the request-handling pipeline, so that the handle is only dropped when the/// request has truly completed./// This utility allows load metrics to have a protocol-agnostic means to track streams past their/// initial response future. For example, if `V` represents an HTTP response type, an/// implementation could add `H`-typed handles to each response's extensions to detect when all the/// response's extensions have been dropped./// A base `impl<H, V> TrackCompletion<H, V> for CompleteOnResponse` is provided to drop the handle/// once the response future is resolved. This is appropriate when a response is discrete and/// cannot comprise multiple messages./// In many cases, the `Output` type is simply `V`. However, [`TrackCompletion`] may alter the type/// in order to instrument it appropriately. For example, an HTTP [`TrackCompletion`] may modify/// the body type: so a [`TrackCompletion`] that takes values of type/// [`http::Response<A>`][response] may output values of type [`http::Response<B>`][response]./// [response]: https://docs.rs/http/latest/http/response/struct.Response.htmlCompleteOnResponse/// A [`TrackCompletion`] implementation that considers the request completed when the response/// future is resolved./// Wraps a future, propagating the tracker into its value if successful.TrackCompletionFuture//! Application-specific request completion semantics.// ===== impl InstrumentFuture =====// ===== CompleteOnResponse =====/// Wraps a `T`-typed service with a constant `M`-typed load metric./// Proxies [`Discover`] such that all changes are wrapped with a constant load.//! A constant [`Load`] implementation.// ===== impl Constant =====peak_ewmapending_requestsPeakEwmaPendingRequestsPeakEwmaDiscoverPendingRequestsDiscover/// A comparable load metric./// Lesser values indicate that the service is less loaded, and should be preferred for new/// requests over another service with a higher value./// Estimate the service's current load./// Types that implement this trait can give an estimate of how loaded they are.//! Service load measurement//! This module provides the [`Load`] trait, which allows measuring how loaded a service is.//! It also provides several wrapper types that measure load in different ways://! - [`Constant`] — Always returns the same constant load value for a service.//! - [`PendingRequests`] — Measures load by tracking the number of in-flight requests.//! - [`PeakEwma`] — Measures load using a moving average of the peak latency for the service.//! In general, you will want to use one of these when using the types in [`tower::balance`] which//! balance services depending on their load. Which load metric to use depends on your exact//! use-case, but the ones above should get you quite far!//! When the `discover` feature is enabled, wrapper types for [`Discover`] that//! wrap the discovered services with the given load estimator are also provided.//! # When does a request complete?//! For many applications, the request life-cycle is relatively simple: when a service responds to//! a request, that request is done, and the system can forget about it. However, for some//! applications, the service may respond to the initial request while other parts of the system//! are still acting on that request. In such an application, the system load must take these//! requests into account as well, or risk the system underestimating its own load.//! To support these use-cases, the load estimators in this module are parameterized by the//! [`TrackCompletion`] trait, with [`CompleteOnResponse`] as the default type. The behavior of//! [`CompleteOnResponse`] is what you would normally expect for a request-response cycle: when the//! response is produced, the request is considered "finished", and load goes down. This can be//! overridden by your own user-defined type to track more complex request completion semantics. See//! the documentation for [`completion`] for more details.//! use tower::util::ServiceExt;//! use tower::{load::Load, Service};//! async fn simple_balance<S1, S2, R>(//!     svc1: &mut S1,//!     svc2: &mut S2,//!     request: R//! ) -> Result<S1::Response, S1::Error>//!     S1: Load + Service<R>,//!     S2: Load<Metric = S1::Metric> + Service<R, Response = S1::Response, Error = S1::Error>//!     if svc1.load() < svc2.load() {//!         svc1.ready().await?.call(request).await//!         svc2.ready().await?.call(request).await//! [`Discover`]: crate::discover::Discover//! [`CompleteOnResponse`]: crate::load::completion::CompleteOnResponse// TODO: a custom completion example would be good heredecay_nsrtt_estimateRttEstimate/// Measures the load of the underlying service using Peak-EWMA load measurement./// [`PeakEwma`] implements [`Load`] with the [`Cost`] metric that estimates the amount of/// pending work to an endpoint. Work is calculated by multiplying the/// exponentially-weighted moving average (EWMA) of response latencies by the number of/// pending requests. The Peak-EWMA algorithm is designed to be especially sensitive to/// worst-case latencies. Over time, the peak latency value decays towards the moving/// average of latencies to the endpoint./// When no latency information has been measured for an endpoint, an arbitrary default/// RTT of 1 second is used to prevent the endpoint from being overloaded before a/// meaningful baseline can be established../// This is derived from [Finagle][finagle], which is distributed under the Apache V2/// license. Copyright 2017, Twitter Inc./// [finagle]:/// https://github.com/twitter/finagle/blob/9cc08d15216497bb03a1cafda96b7266cfbbcff1/finagle-core/src/main/scala/com/twitter/finagle/loadbalancer/PeakEwma.scalaCost/// Represents the relative cost of communicating with a service./// The underlying value estimates the amount of pending work to a service: the Peak-EWMA/// latency estimate multiplied by the number of pending requests.sent_at/// Tracks an in-flight request and updates the RTT-estimate on Drop.update_atrtt_ns/// Holds the current RTT estimate and the last time this value was updated./// Wraps an `S`-typed service so that its load is tracked by the EWMA of its peak latency.update_estimate/// Wraps a `D`-typed [`Discover`] so that services have a [`PeakEwma`] load metric./// The provided `default_rtt` is used as the default RTT estimate for newly/// added services./// They `decay` value determines over what time period a RTT estimate should/// decay.decay/// Decays the RTT estimate with a decay period of `decay_ns`./// Updates the Peak-EWMA RTT estimate./// The elapsed time from `sent_at` to `recv_at` is added// Utility that converts durations to nanos in f64.// Due to a lossy transformation, the maximum value that can be represented is ~585 years,// which, I hope, is more than enough to represent request latencies.Svcdefault_decay/// The default RTT estimate decays, so that new nodes are considered if the/// default RTT is too high.compound_decay// The default RTT estimate decays, so that new nodes are considered if the default RTT is too// high.//! A `Load` implementation that measures load using the PeakEWMA response latency.// ===== impl PeakEwma =====// ===== impl PeakEwmaDiscover =====// ===== impl RttEstimate =====// ===== impl Cost =====/// Measures the load of the underlying service using the number of currently-pending requests./// Shared between instances of [`PendingRequests`] and [`Handle`] to track active references./// Represents the number of currently-pending requests to a given service./// Tracks an in-flight request by reference count./// Wraps an `S`-typed service so that its load is tracked by the number of pending requests./// Wraps a [`Discover`], wrapping all of its services with [`PendingRequests`].with_completion//! A [`Load`] implementation that measures load using the number of in-flight requests.// ===== impl PendingRequests =====// ===== impl PendingRequestsDiscover =====// ==== RefCount ====Overloaded/// An error returned by [`LoadShed`] when the underlying service/// is not ready to handle any requests at the time of being/// [`LoadShed`]: crate::load_shed::LoadShed/// Construct a new overloaded erroroverloaded// bounds for future-proofing...LoadShedLoadShedLayer/// A [`Layer`] to wrap services in [`LoadShed`] middleware./// Creates a new layer./// A [`Service`] that sheds load when the inner service isn't ready./// Wraps a service in [`LoadShed`] middleware.//! Middleware for shedding load when inner services aren't ready.// ===== impl LoadShed =====/// The transport provided by this service/// Errors produced by the connecting service/// The future that eventually produces the transport/// Returns `Poll::Ready(Ok(()))` when it is able to make more connections.make_connection/// Connect and return a transport asynchronouslyMakeConnection/// The [`MakeConnection`] trait is used to create transports./// The goal of this service is to allow composable methods for creating/// `AsyncRead + AsyncWrite` transports. This could mean creating a TLS/// based connection or using some other method to authenticate the connection./// A [`MakeService`] that produces services by cloning an inner service./// [`MakeService`]: super::MakeService/// # use std::convert::Infallible;/// use tower::make::{MakeService, Shared};/// use tower::buffer::Buffer;/// use tower::Service;/// use futures::future::{Ready, ready};/// // An example connection type/// struct Connection {}/// // An example request type/// struct Request {}/// // An example response type/// struct Response {}/// // Some service that doesn't implement `Clone`///     type Response = Response;///     type Error = Infallible;///     type Future = Ready<Result<Response, Infallible>>;///     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {///     fn call(&mut self, req: Request) -> Self::Future {///         ready(Ok(Response {}))/// // Example function that runs a service by accepting new connections and using/// // `Make` to create new services that might be bound to the connection./// // This is similar to what you might find in hyper./// async fn serve_make_service<Make>(make: Make)///     Make: MakeService<Connection, Request>/// # async {/// // Our service/// let svc = MyService;/// // Make it `Clone` by putting a channel in front/// let buffered = Buffer::new(svc, 1024);/// // Convert it into a `MakeService`/// let make = Shared::new(buffered);/// // Run the service and just ignore the `Connection`s as `MyService` doesn't need them/// serve_make_service(make).await;/// Create a new [`Shared`] from a service.SharedFutureMakeServiceas_make_serviceas_make_service_into_service/// Responses given by the service/// Errors produced by the service/// The [`Service`] value created by this factoryMakeError/// Errors produced while building a service./// The future of the [`Service`] instance./// Returns [`Poll::Ready`] when the factory is able to create more services./// If the service is at capacity, then [`Poll::Pending`] is returned and the task/// is notified when the service becomes ready again. This function is/// expected to be called while on a task.make_service/// Create and return a new service value asynchronously.into_serviceIntoService/// Consume this [`MakeService`] and convert it into a [`Service`]./// use tower::make::MakeService;/// use tower::service_fn;/// // A `MakeService`/// let make_service = service_fn(|make_req: ()| async {///     Ok::<_, Infallible>(service_fn(|req: String| async {///         Ok::<_, Infallible>(req)/// // Convert the `MakeService` into a `Service`/// let mut svc = make_service.into_service();/// // Make a new service/// let mut new_svc = svc.call(()).await.unwrap();/// // Call the service/// let res = new_svc.call("foo".to_string()).await.unwrap();as_serviceAsService/// Convert this [`MakeService`] into a [`Service`] without consuming the original [`MakeService`]./// let mut make_service = service_fn(|make_req: ()| async {/// let mut svc = make_service.as_service();/// // The original `MakeService` is still accessible/// let new_svc = make_service.make_service(()).await.unwrap();/// Creates new [`Service`] values./// Acts as a service factory. This is useful for cases where new [`Service`]/// values must be produced. One case is a TCP server listener. The listener/// accepts new TCP streams, obtains a new [`Service`] value using the/// [`MakeService`] trait, and uses that new [`Service`] value to process inbound/// requests on that new TCP stream./// This is essentially a trait alias for a [`Service`] of [`Service`]s./// Service returned by [`MakeService::into_service`][into]./// See the documentation on [`into_service`][into] for details./// [into]: MakeService::into_service/// Service returned by [`MakeService::as_service`][as]./// See the documentation on [`as_service`][as] for details./// [as]: MakeService::as_service//! Contains [`MakeService`] which is a trait alias for a [`Service`] of [`Service`]s.//! Trait aliases for Services that produce specific types of Responses./// A stream of services that are not yet ready.pending_cancel_txsCancelTx/// An index of cancelation handles for pending streams.CancelPair/// Services that have previously become ready. Readiness can become stale,/// so a given service should be polled immediately before use./// The cancelation oneshot is preserved (though unused) while the service is/// ready so that it need not be reallocated each time a request is/// dispatched./// Drives readiness over a set of services./// The cache maintains two internal data structures:/// * a set of _pending_ services that have not yet become ready; and/// * a set of _ready_ services that have previously polled ready./// As each `S` typed [`Service`] is added to the cache via [`ReadyCache::push`], it/// is added to the _pending set_. As [`ReadyCache::poll_pending`] is invoked,/// pending services are polled and added to the _ready set_./// [`ReadyCache::call_ready`] (or [`ReadyCache::call_ready_index`]) dispatches a/// request to the specified service, but panics if the specified service is not/// in the ready set. The `ReadyCache::check_*` functions can be used to ensure/// that a service is ready before dispatching a request./// The ready set can hold services for an arbitrarily long time. During this/// time, the runtime may process events that invalidate that ready state (for/// instance, if a keepalive detects a lost connection). In such cases, callers/// should use [`ReadyCache::check_ready`] (or [`ReadyCache::check_ready_index`])/// immediately before dispatching a request to ensure that the service has not/// become unavailable./// Once `ReadyCache::call_ready*` is invoked, the service is placed back into/// the _pending_ set to be driven to readiness again./// When `ReadyCache::check_ready*` returns `false`, it indicates that the/// specified service is _not_ ready. If an error is returned, this indicates that/// the server failed and has been removed from the cache entirely./// [`ReadyCache::evict`] can be used to remove a service from the cache (by key),/// though the service may not be dropped (if it is currently pending) until/// [`ReadyCache::poll_pending`] is invoked./// Note that the by-index accessors are provided to support use cases (like/// power-of-two-choices load balancing) where the caller does not care to keep/// track of each service's key. Instead, it needs only to access _some_ ready/// service. In such a case, it should be noted that calls to/// [`ReadyCache::poll_pending`] and [`ReadyCache::evict`] may perturb the order of/// the ready set, so any cached indexes should be discarded after such a call.// Safety: This is safe because we do not use `Pin::new_unchecked`.canceledCancelRxPendingError/// Returns the total number of services in the cache./// Returns whether or not there are any services in the cache.ready_len/// Returns the number of services in the ready set.pending_len/// Returns the number of services in the unready set.pending_contains/// Returns true iff the given key is in the unready set./// Obtains a reference to a service in the ready set by key.get_ready_mut/// Obtains a mutable reference to a service in the ready set by key.get_ready_index/// Obtains a reference to a service in the ready set by index.get_ready_index_mut/// Obtains a mutable reference to a service in the ready set by index.iter_ready/// Returns an iterator over the ready keys and services.iter_ready_mut/// Returns a mutable iterator over the ready keys and services.evict/// Evicts an item from the cache./// Returns true if a service was marked for eviction./// Services are dropped from the ready set immediately. Services in the/// pending set are marked for cancellation, but [`ReadyCache::poll_pending`]/// must be called to cause the service to be dropped./// Pushes a new service onto the pending set./// The service will be promoted to the ready set as [`poll_pending`] is invoked./// Note that this does **not** remove services from the ready set. Once the/// old service is used, it will be dropped instead of being added back to/// the pending set; OR, when the new service becomes ready, it will replace/// the prior service in the ready set./// [`poll_pending`]: crate::ready_cache::cache::ReadyCache::poll_pendingpoll_pending/// Polls services pending readiness, adding ready services to the ready set./// Returns [`Poll::Ready`] when there are no remaining unready services./// [`poll_pending`] should be called again after [`push`] or/// [`call_ready_index`] are invoked./// Failures indicate that an individual pending service failed to become/// ready (and has been removed from the cache). In such a case,/// [`poll_pending`] should typically be called again to continue driving/// pending services to readiness./// [`push`]: crate::ready_cache::cache::ReadyCache::push/// [`call_ready_index`]: crate::ready_cache::cache::ReadyCache::call_ready_indexcheck_ready/// Checks whether the referenced endpoint is ready./// Returns true if the endpoint is ready and false if it is not. An error is/// returned if the endpoint fails.check_ready_index/// If the service is no longer ready, it is moved back into the pending set/// and `false` is returned./// If the service errors, it is removed and dropped and the error is returned.call_ready/// Calls a ready service by key./// If the specified key does not exist in the readycall_ready_index/// Calls a ready service by index./// If the specified index is out of range.cancelable/// Creates a cancelation sender and receiver./// A `tokio::sync::oneshot` is NOT used, as a `Receiver` is not guaranteed to/// observe results as soon as a `Sender` fires. Using an `AtomicBool` allows/// the state to be observed as soon as the cancelation is triggered.//! A cache of services.// === ReadyCache ===// === impl Cancel ===// === Pending ===/// An error indicating that the service with a `K`-typed key failed with an//! Errors// === Failed ===//! A cache of servicesMEmk_serviceReconnect/// Reconnect to failed services./// Lazily connect and reconnect to a [`Service`].with_connection/// Reconnect to a already connected [`Service`].//! Reconnect services when they fail.//! Reconnect takes some [`MakeService`] and transforms it into a//! [`Service`]. It then attempts to lazily connect and//! reconnect on failure. The `Reconnect` service becomes unavailable//! when the inner `MakeService::poll_ready` returns an error. When the//! connection future returned from `MakeService::call` fails this will be//! returned in the next call to `Reconnect::call`. This allows the user to//! call the service again even if the inner `MakeService` was unable to//! connect on the last call.//! [`MakeService`]: crate::make::MakeService/// The backoff type produced by this maker.make_backoff/// Constructs a new backoff type.MakeBackoff/// Trait used to construct [`Backoff`] trait implementors./// The future associated with each backoff. This usually will be some sort/// of timer.next_backoff/// Initiate the next backoff in the sequence./// A backoff trait where a single mutable reference represents a single/// backoff session. Implementors must also implement [`Clone`] which will/// reset the backoff back to the default state for the next session./// The minimum amount of time to wait before resuming an operation./// The maximum amount of time to wait before resuming an operation./// The ratio of the base timeout that may be randomly added to a backoff./// Must be greater than or equal to 0.0.ExponentialBackoffMaker/// A maker type for [`ExponentialBackoff`].iterationsExponentialBackoff/// A jittered [exponential backoff] strategy./// The backoff duration will increase exponentially for every subsequent/// backoff, up to a maximum duration. A small amount of [random jitter] is/// added to each backoff duration, in order to avoid retry spikes./// [exponential backoff]: https://en.wikipedia.org/wiki/Exponential_backoff/// [random jitter]: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/InvalidBackoff/// Create a new `ExponentialBackoff`./// Returns a config validation error if:/// - `min` > `max`/// - `max` > 0/// - `jitter` >= `0.0`/// - `jitter` < `100.0`/// - `jitter` is finite/// Returns a random, uniform duration on `[0, base*self.jitter]` no greater/// than `self.max`./// Backoff validation error.//! This module contains generic [backoff] utilities to be used with the retry//! layer.//! The [`Backoff`] trait is a generic way to represent backoffs that can use//! any timer type.//! [`ExponentialBackoffMaker`] implements the maker type for  //! [`ExponentialBackoff`] which implements the [`Backoff`] trait and provides//! a batteries included exponential backoff and jitter strategy.//! [backoff]: https://en.wikipedia.org/wiki/Exponential_backofftps_budgetdeposit/// Store a "deposit" in the budget, which will be used to permit future/// withdrawals./// Check whether there is enough "balance" in the budget to issue a new/// retry./// If there is not enough, false is returned./// For more info about [`Budget`], please see the [module-level documentation].//! A retry "budget" for allowing only a certain amount of retries over time.//! # Why budgets and not max retries?//! The most common way of configuring retries is to specify a maximum//! number of retry attempts to perform before giving up. This is a familiar idea to anyone//! who’s used a web browser: you try to load a webpage, and if it doesn’t load, you try again.//! If it still doesn’t load, you try a third time. Finally you give up.//! Unfortunately, there are at least two problems with configuring retries this way://! **Choosing the maximum number of retry attempts is a guessing game.**//! You need to pick a number that’s high enough to make a difference when things are somewhat failing,//! but not so high that it generates extra load on the system when it’s really failing. In practice,//! you usually pick a maximum retry attempts number out of a hat (e.g. 3) and hope for the best.//! **Systems configured this way are vulnerable to retry storms.**//! A retry storm begins when one service starts to experience a larger than normal failure rate.//! This causes its clients to retry those failed requests. The extra load from the retries causes the//! service to slow down further and fail more requests, triggering more retries. If each client is//! configured to retry up to 3 times, this can quadruple the number of requests being sent! To make//! matters even worse, if any of the clients’ clients are configured with retries, the number of retries//! compounds multiplicatively and can turn a small number of errors into a self-inflicted denial of service attack.//! It's generally dangerous to implement retries without some limiting factor. [`Budget`]s are that limit.//! use futures_util::future;//! use tower::retry::{budget::{Budget, TpsBudget}, Policy};//! type Req = String;//! type Res = String;//! struct RetryPolicy {//!     budget: Arc<TpsBudget>,//! impl<E> Policy<Req, Res, E> for RetryPolicy {//!     type Future = future::Ready<()>;//!     fn retry(&mut self, req: &mut Req, result: &mut Result<Res, E>) -> Option<Self::Future> {//!         match result {//!             Ok(_) => {//!                 // Treat all `Response`s as success,//!                 // so deposit budget and don't retry...//!                 self.budget.deposit();//!                 None//!             Err(_) => {//!                 // Treat all errors as failures...//!                 // Withdraw the budget, don't retry if we overdrew.//!                 let withdrew = self.budget.withdraw();//!                 if !withdrew {//!                     return None;//!                 // Try again!//!                 Some(future::ready(()))//!     fn clone_request(&mut self, req: &Req) -> Option<Req> {//!         Some(req.clone())/// Initial budget allowed for every second./// Slots of a the TTL divided evenly./// The amount of time represented by each slot./// The changers for the current slot to be committed/// after the slot expires.deposit_amount/// Amount of tokens to deposit for each put().withdraw_amount/// Amount of tokens to withdraw for each try_get()./// A Transactions Per Minute config for managing retry tokens./// [`TpsBudget`] uses a token bucket to decide if the request should be retried./// [`TpsBudget`] works by checking how much retries have been made in a certain period of time./// Minimum allowed number of retries are effectively reset on an interval. Allowed number of/// retries depends on failed request count in recent time frame./// [module-level documentation]: super/// Slot index of the last generation./// The timestamp since the last generation expired./// Create a [`TpsBudget`] that allows for a certain percent of the total/// requests to be retried./// - The `ttl` is the duration of how long a single `deposit` should be///   considered. Must be between 1 and 60 seconds./// - The `min_per_sec` is the minimum rate of retries allowed to accommodate///   clients that have just started issuing requests, or clients that do///   not issue many requests per window./// - The `retry_percent` is the percentage of calls to `deposit` that can///   be retried. This is in addition to any retries allowed for via///   `min_per_sec`. Must be between 0 and 1000.///   As an example, if `0.1` is used, then for every 10 calls to `deposit`,///   1 retry will be allowed. If `2.0` is used, then every `deposit`///   allows for 2 retries.tps_emptytps_leakytps_slotstps_reserve//! Transactions Per Minute (Tps) Budget implementations// ===== impl TpsBudget =====r" The [`Future`] returned by a [`Retry`] service."Retrying/// Retry requests based on a policy/// Creates a new [`RetryLayer`] from a retry policy.r#" Configure retrying requests of "failed" responses."#r#" A [`Policy`] classifies what is a "failed" response."#r" # Clone"r" This middleware requires that the inner `Service` implements [`Clone`],"r" because the `Service` must be stored in each [`ResponseFuture`] in"r" order to retry the request in the event of a failure. If the inner"r" `Service` type does not implement `Clone`, the [`Buffer`] middleware"r" can be added to make any `Service` cloneable."r" [`Buffer`]: crate::buffer::Buffer"r" The `Policy` must also implement `Clone`. This middleware will"r" clone the policy for each _request session_. This means a new clone"r" of the policy will be created for each initial request and any subsequent"r" retries of that request. Therefore, any state stored in the `Policy` instance"r" is for that request session only. In order to share data across request"r" sessions, that shared state may be stored in an [`Arc`], so that all clones"r" of the `Policy` type reference the same instance of the shared state."/// Retry the inner service depending on this [`Policy`].//! Middleware for retrying "failed" requests.// ===== impl Retry =====/// The [`Future`] type returned by [`Policy::retry`]./// Check the policy if a certain request should be retried./// This method is passed a reference to the original request, and either/// the [`Service::Response`] or [`Service::Error`] from the inner service./// If the request should **not** be retried, return `None`./// If the request *should* be retried, return `Some` future that will delay/// the next retry of the request. This can be used to sleep for a certain/// duration, to wait for some external condition to be met before retrying,/// or resolve right away, if the request should be retried immediately./// ## Mutating Requests/// The policy MAY chose to mutate the `req`: if the request is mutated, the/// mutated request will be sent to the inner service in the next retry./// This can be helpful for use cases like tracking the retry count in a/// ## Mutating Results/// The policy MAY chose to mutate the result. This enables the retry/// policy to convert a failure into a success and vice versa. For example,/// if the policy is used to poll while waiting for a state change, the/// policy can switch the result to emit a specific error when retries are/// The policy can also record metadata on the request to include/// information about the number of retries required or to record that a/// failure failed after exhausting all retries./// [`Service::Response`]: crate::Service::Response/// [`Service::Error`]: crate::Service::Error/// Tries to clone a request before being passed to the inner service./// If the request cannot be cloned, return [`None`]. Moreover, the retry/// function will not be called if the [`None`] is returned./// A "retry policy" to classify if a request should be retried./// use tower::retry::Policy;/// use futures_util::future;/// type Req = String;/// type Res = String;/// struct Attempts(usize);/// impl<E> Policy<Req, Res, E> for Attempts {///     type Future = future::Ready<()>;///     fn retry(&mut self, req: &mut Req, result: &mut Result<Res, E>) -> Option<Self::Future> {///         match result {///             Ok(_) => {///                 // Treat all `Response`s as success,///                 // so don't retry...///                 None///             Err(_) => {///                 // Treat all errors as failures...///                 // But we limit the number of attempts...///                 if self.0 > 0 {///                     // Try again!///                     self.0 -= 1;///                     Some(future::ready(()))///                     // Used all our attempts, no retry...///                     None///     fn clone_request(&mut self, req: &Req) -> Option<Req> {///         Some(req.clone())_obj_safe// Ensure `Policy` is object safe//! Background readiness typesSpawnReadyLayer/// Spawns tasks to drive its inner service to readiness./// Builds a [`SpawnReadyLayer`].SpawnReady//! When an underlying service is not ready, drive it to readiness on a//! background task./// Spawns tasks to drive an inner service to readiness./// See crate level documentation for more details./// Creates a new [`SpawnReady`] wrapping `service`./// Creates a layer that wraps services with [`SpawnReady`]./// Return an index into the iterator of `Service` passed to [`Steer::new`].Picker/// This is how callers of [`Steer`] tell it which `Service` a `Req` corresponds to.routernot_readySteer/// [`Steer`] manages a list of [`Service`]s which all handle the same type of request./// An example use case is a sharded service./// It accepts new requests, then:/// 1. Determines, via the provided [`Picker`], which [`Service`] the request corresponds to./// 2. Waits (in [`Service::poll_ready`]) for *all* services to be ready./// 3. Calls the correct [`Service`] with the request, and returns a future corresponding to the///    call./// Note that [`Steer`] must wait for all services to be ready since it can't know ahead of time/// which [`Service`] the next message will arrive for, and is unwilling to buffer items/// indefinitely. This will cause head-of-line blocking unless paired with a [`Service`] that does/// buffer items indefinitely, and thus always returns [`Poll::Ready`]. For example, wrapping each/// component service with a [`Buffer`] with a high enough limit (the maximum number of concurrent/// requests) will prevent head-of-line blocking in [`Steer`]./// Make a new [`Steer`] with a list of [`Service`]'s and a [`Picker`]./// Note: the order of the [`Service`]'s is significant for [`Picker::pick`]'s return value.//! This module provides functionality to aid managing routing requests between [`Service`]s.//! [`Steer`] can for example be used to create a router, akin to what you might find in web//! frameworks.//! Here, `GET /` will be sent to the `root` service, while all other requests go to `not_found`.//! # use std::task::{Context, Poll};//! # use tower_service::Service;//! # use futures_util::future::{ready, Ready, poll_fn};//! # use tower::steer::Steer;//! # use tower::service_fn;//! # use tower::util::BoxService;//! # use tower::ServiceExt;//! # use std::convert::Infallible;//! use http::{Request, Response, StatusCode, Method};//! # async fn main() -> Result<(), Box<dyn std::error::Error>> {//! // Service that responds to `GET /`//! let root = service_fn(|req: Request<String>| async move {//!     # assert_eq!(req.uri().path(), "/");//!     let res = Response::new("Hello, World!".to_string());//!     Ok::<_, Infallible>(res)//! // We have to box the service so its type gets erased and we can put it in a `Vec` with other//! // services//! let root = BoxService::new(root);//! // Service that responds with `404 Not Found` to all requests//! let not_found = service_fn(|req: Request<String>| async move {//!     let res = Response::builder()//!         .body(String::new())//!         .expect("response is valid");//! // Box that as well//! let not_found = BoxService::new(not_found);//! let mut svc = Steer::new(//!     // All services we route between//!     vec![root, not_found],//!     // How we pick which service to send the request to//!     |req: &Request<String>, _services: &[_]| {//!         if req.method() == Method::GET && req.uri().path() == "/" {//!             0 // Index of `root`//!             1 // Index of `not_found`//! // This request will get sent to `root`//! let req = Request::get("/").body(String::new()).unwrap();//! let res = svc.ready().await?.call(req).await?;//! assert_eq!(res.into_body(), "Hello, World!");//! // This request will get sent to `not_found`//! let req = Request::get("/does/not/exist").body(String::new()).unwrap();//! assert_eq!(res.status(), StatusCode::NOT_FOUND);//! assert_eq!(res.into_body(), "");/// The timeout elapsed./// Construct a new elapsed errorr" [`Timeout`] response future"r" [`Timeout`]: crate::timeout::Timeout"/// Applies a timeout to requests via the supplied inner service./// Create a timeout from a duration/// Applies a timeout to requests./// Creates a new [`Timeout`]//! Middleware that applies a timeout to requests.//! If the response does not complete within the specified timeout, the response//! will be aborted.// ===== impl Timeout =====/// Service returned by the [`and_then`] combinator./// [`and_then`]: crate::util::ServiceExt::and_thenr" Response future from [`AndThen`] services."r" [`AndThen`]: crate::util::AndThen"AndThenFuture/// A [`Layer`] that produces a [`AndThen`] service./// [`Layer`]: tower_layer::Layer/// Creates a new `AndThen` service./// Returns a new [`Layer`] that produces [`AndThen`] services./// This is a convenience function that simply calls [`AndThenLayer::new`]./// Creates a new [`AndThenLayer`] layer.BoxLayer/// A boxed [`Layer`] trait object./// [`BoxLayer`] turns a layer into a trait object, allowing both the [`Layer`] itself/// and the output [`Service`] to be dynamic, while having consistent types./// This [`Layer`] produces [`BoxService`] instances erasing the type of the/// [`Service`] produced by the wrapped [`Layer`]./// `BoxLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't have/// the same types. In this example, we include a [`Timeout`] layer/// only if an environment variable is set. We can use `BoxLayer`/// to return a consistent type regardless of runtime configuration:/// use tower::{Service, ServiceBuilder, BoxError, util::BoxLayer};/// fn common_layer<S, T>() -> BoxLayer<S, T, S::Response, BoxError>///     S: Service<T> + Send + 'static,///     S::Future: Send + 'static,///     S::Error: Into<BoxError> + 'static,///     let builder = ServiceBuilder::new()///         .concurrency_limit(100);///     if std::env::var("SET_TIMEOUT").is_ok() {///         let layer = builder///             .timeout(Duration::from_secs(30))///             .into_inner();///         BoxLayer::new(layer)///             .map_err(Into::into)/// [`Service`]: tower_service::Service/// [`BoxService`]: super::BoxService/// [`Timeout`]: crate::timeout/// Create a new [`BoxLayer`].BoxCloneServiceLayer/// A [`Clone`] + [`Send`] boxed [`Layer`]./// [`BoxCloneServiceLayer`] turns a layer into a trait object, allowing both the [`Layer`] itself/// This [`Layer`] produces [`BoxCloneService`] instances erasing the type of the/// This is similar to [`BoxLayer`](super::BoxLayer) except the layer and resulting/// service implements [`Clone`]./// `BoxCloneServiceLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't have/// the same types, when the underlying service must be clone (for example, when building a MakeService)/// In this example, we include a [`Timeout`] layer only if an environment variable is set. We can use/// `BoxCloneService` to return a consistent type regardless of runtime configuration:/// use tower::{Service, ServiceBuilder, BoxError};/// use tower::util::{BoxCloneServiceLayer, BoxCloneService};/// fn common_layer<S, T>() -> BoxCloneServiceLayer<S, T, S::Response, BoxError>///     S: Service<T> + Clone + Send + 'static,///         BoxCloneServiceLayer::new(layer)/// // We can clone the layer (this is true of BoxLayer as well)/// let boxed_clone_layer = common_layer();/// let cloned_layer = boxed_clone_layer.clone();/// // Using the `BoxCloneServiceLayer` we can create a `BoxCloneService`/// let service: BoxCloneService<Request, Response, BoxError> = ServiceBuilder::new().layer(boxed_clone_layer)///      .service_fn(|req: Request| async {/// // And we can still clone the service/// let cloned_service = service.clone();/// Create a new [`BoxCloneServiceLayer`]./// A [`Clone`] + [`Send`] + [`Sync`] boxed [`Layer`]./// [`BoxCloneSyncServiceLayer`] turns a layer into a trait object, allowing both the [`Layer`] itself/// This [`Layer`] produces [`BoxCloneSyncService`] instances erasing the type of the/// This is similar to [`BoxCloneServiceLayer`](super::BoxCloneServiceLayer) except the layer and resulting/// service implements [`Sync`]./// `BoxCloneSyncServiceLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't have/// the same types, when the underlying service must be clone and sync (for example, when building a Hyper connector)./// `BoxCloneSyncServiceLayer` to return a consistent type regardless of runtime configuration:/// use tower::util::{BoxCloneSyncServiceLayer, BoxCloneSyncService};/// fn common_layer<S, T>() -> BoxCloneSyncServiceLayer<S, T, S::Response, BoxError>///     S: Service<T> + Clone + Send + Sync + 'static,///         BoxCloneSyncServiceLayer::new(layer)/// let boxed_clone_sync_layer = common_layer();/// let cloned_sync_layer = boxed_clone_sync_layer.clone();/// // Using the `BoxCloneSyncServiceLayer` we can create a `BoxCloneSyncService`/// let service: BoxCloneSyncService<Request, Response, BoxError> = ServiceBuilder::new().layer(cloned_sync_layer)/// Create a new [`BoxCloneSyncServiceLayer`].layer_clonelayer_clone_syncUnsyncBoxService/// A boxed `Service + Send` trait object./// [`BoxService`] turns a service into a trait object, allowing the response/// future type to be dynamic. This type requires both the service and the/// response future to be [`Send`]./// If you need a boxed [`Service`] that implements [`Clone`] consider using/// [`BoxCloneService`](crate::util::BoxCloneService)./// Dynamically dispatched [`Service`] objects allow for erasing the underlying/// [`Service`] type and using the `Service` instances as opaque handles. This can/// be useful when the service instance cannot be explicitly named for whatever/// reason./// use futures_util::future::ready;/// # use tower_service::Service;/// # use tower::util::{BoxService, service_fn};/// // Respond to requests using a closure, but closures cannot be named.../// let svc = service_fn(|mut request: String| {///     request.push_str(" response");///     ready(Ok(request))/// let service: BoxService<String, String, ()> = BoxService::new(svc);/// # drop(service);/// A boxed `Future + Send` trait object./// This type alias represents a boxed future that is [`Send`] and can be moved/// Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxService`]UnsyncBoxFuture/// A boxed [`Service`] trait object./// A boxed [`Future`] trait object./// This type alias represents a boxed future that is *not* [`Send`] and must/// remain on the current thread.UnsyncBoxed/// Returns a [`Layer`] for wrapping a [`Service`] in an [`UnsyncBoxService`] middleware.CloneService/// A [`Clone`] + [`Send`] boxed [`Service`]./// [`BoxCloneService`] turns a service into a trait object, allowing the/// response future type to be dynamic, and allowing the service to be cloned./// This is similar to [`BoxService`](super::BoxService) except the resulting/// // This service has a complex type that is hard to name/// let service = ServiceBuilder::new()///     .map_request(|req| {///         println!("received request");///         req///     .map_response(|res| {///         println!("response produced");/// // `BoxCloneService` will erase the type so it's nameable/// let service: BoxCloneService<Request, Response, BoxError> = BoxCloneService::new(service);/// Create a new `BoxCloneService`./// Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneService`]/// A [`Clone`] + [`Send`] + [`Sync`] boxed [`Service`]./// [`BoxCloneSyncService`] turns a service into a trait object, allowing the/// response future type to be dynamic, and allowing the service to be cloned and shared./// This is similar to [`BoxCloneService`](super::BoxCloneService) except the resulting/// Create a new `BoxCloneSyncService`./// Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneSyncService`]r" The [`Future`] returned by the [`ServiceExt::call_all`] combinator."curr_reqCallAll/// Extract the wrapped [`Service`].take_serviceCallAllUnordered//! [`Stream<Item = Request>`][stream] + [`Service<Request>`] => [`Stream<Item = Response>`][stream].//! [`Service<Request>`]: crate::Service//! [stream]: https://docs.rs/futures/latest/futures/stream/trait.Stream.htmlr" This is a [`Stream`] of responses resulting from calling the wrapped [`Service`] for each"r" request received on the wrapped [`Stream`]."r" # use std::task::{Poll, Context};"r" # use std::cell::Cell;"r" # use std::rc::Rc;"r" use futures::future::{ready, Ready};"r" use futures::StreamExt;"r" use futures::channel::mpsc;"r" use tower_service::Service;"r" use tower::util::ServiceExt;"r" // First, we need to have a Service to process our requests."r" #[derive(Debug, Eq, PartialEq)]"r" struct FirstLetter;"r" impl Service<&'static str> for FirstLetter {"r"      type Response = &'static str;"r"      type Error = Box<dyn Error + Send + Sync>;"r"      type Future = Ready<Result<Self::Response, Self::Error>>;"r"      fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {"r"          Poll::Ready(Ok(()))"r"      }"r"      fn call(&mut self, req: &'static str) -> Self::Future {"r"          ready(Ok(&req[..1]))"r"     // Next, we need a Stream of requests."r"     let (mut reqs, rx) = mpsc::unbounded();"r"     // Note that we have to help Rust out here by telling it what error type to use."r"     // Specifically, it has to be From<Service::Error> + From<Stream::Error>."r"     let mut rsps = FirstLetter.call_all(rx);"r"     // Now, let's send a few requests and then check that we get the corresponding responses."r#"     reqs.unbounded_send("one").unwrap();"#r#"     reqs.unbounded_send("two").unwrap();"#r#"     reqs.unbounded_send("three").unwrap();"#r"     drop(reqs);"r"     // We then loop over the response `Stream` that we get back from call_all."r"     let mut i = 0usize;"r"     while let Some(rsp) = rsps.next().await {"r"         // Each response is a Result (we could also have used TryStream::try_next)"r"         match (i + 1, rsp.unwrap()) {"r#"             (1, "o") |"#r#"             (2, "t") |"#r#"             (3, "t") => {}"#r"             (n, i) => {"r#"                 unreachable!("{}. response was '{}'", n, i);"#r"         i += 1;"r"     // And at the end, we can get the Service back when there are no more requests."r"     assert_eq!(rsps.into_inner(), FirstLetter);"r" [`Stream`]: https://docs.rs/futures/latest/futures/stream/trait.Stream.html"/// Create new [`CallAll`] combinator./// Each request yielded by `stream` is passed to `svc`, and the resulting responses are/// yielded in the same order by the implementation of [`Stream`] for [`CallAll`]./// [`Stream`]: https://docs.rs/futures/latest/futures/stream/trait.Stream.html/// Panics if [`take_service`] was already called./// [`take_service`]: crate::util::CallAll::take_service/// This [`CallAll`] can no longer be used after this function has been called./// Return responses as they are ready, regardless of the initial order./// This function must be called before the stream is polled./// Panics if [`poll`] was called.r" A stream of responses received from the inner service in received order."r" Similar to [`CallAll`] except, instead of yielding responses in request order,"r" responses are returned as they are available."r" [`CallAll`]: crate::util::CallAll"/// Create new [`CallAllUnordered`] combinator./// [`take_service`]: crate::util::CallAllUnordered::take_service/// Extract the wrapped `Service`./// This [`CallAllUnordered`] can no longer be used after this function has been called./// Combine two different service types into a single type./// Both services must be of the same request, response, and error types./// [`Either`] is useful for handling conditional branching in service middleware/// to different inner service types.EitherResponseFuturer" Response future for [`Either`]."KindProj//! Contains [`Either`] and related types and functions.//! See [`Either`] documentation for more details.future_serviceFutureService/// Returns a new [`FutureService`] for the given future./// A [`FutureService`] allows you to treat a future that resolves to a service as a service. This/// can be useful for services that are created asynchronously./// use tower::{service_fn, Service, ServiceExt};/// use tower::util::future_service;/// // A future which outputs a type implementing `Service`./// let future_of_a_service = async {///     let svc = service_fn(|_req: ()| async { Ok::<_, Infallible>("ok") });///     Ok::<_, Infallible>(svc)/// // Wrap the future with a `FutureService`, allowing it to be used/// // as a service without awaiting the future's completion:/// let mut svc = future_service(Box::pin(future_of_a_service));/// // Now, when we wait for the service to become ready, it will/// // drive the future to completion internally./// let svc = svc.ready().await.unwrap();/// let res = svc.call(()).await.unwrap();/// # Regarding the [`Unpin`] bound/// The [`Unpin`] bound on `F` is necessary because the future will be polled in/// [`Service::poll_ready`] which doesn't have a pinned receiver (it takes `&mut self` and not `self:/// Pin<&mut Self>`). So we cannot put the future into a `Pin` without requiring `Unpin`./// This will most likely come up if you're calling `future_service` with an async block. In that/// case you can use `Box::pin(async { ... })` as shown in the example./// A type that implements [`Service`] for a [`Future`] that produces a [`Service`]./// See [`future_service`] for more details./// use tower::util::FutureService;/// let mut svc = FutureService::new(Box::pin(future_of_a_service));pending_service_debug_implDebugService/// Service returned by the [`map_err`] combinator./// [`map_err`]: crate::util::ServiceExt::map_err/// A [`Layer`] that produces [`MapErr`] services.r" Response future from [`MapErr`] services."r" [`MapErr`]: crate::util::MapErr"MapErrFuture/// Creates a new [`MapErr`] service./// Returns a new [`Layer`] that produces [`MapErr`] services./// This is a convenience function that simply calls [`MapErrLayer::new`]./// Creates a new [`MapErrLayer`].MapFuture/// [`Service`] returned by the [`map_future`] combinator./// Creates a new [`MapFuture`] service./// Returns a new [`Layer`] that produces [`MapFuture`] services./// This is a convenience function that simply calls [`MapFutureLayer::new`]./// A [`Layer`] that produces a [`MapFuture`] service./// Creates a new [`MapFutureLayer`] layer./// Service returned by the [`MapRequest`] combinator./// [`MapRequest`]: crate::util::ServiceExt::map_request/// Creates a new [`MapRequest`] service./// Returns a new [`Layer`] that produces [`MapRequest`] services./// This is a convenience function that simply calls [`MapRequestLayer::new`]./// A [`Layer`] that produces [`MapRequest`] services./// Creates a new [`MapRequestLayer`].MapResponse/// Service returned by the [`map_response`] combinator./// [`map_response`]: crate::util::ServiceExt::map_response/// A [`Layer`] that produces a [`MapResponse`] service.r" Response future from [`MapResponse`] services."r" [`MapResponse`]: crate::util::MapResponse"MapResponseFuture/// Creates a new `MapResponse` service./// Returns a new [`Layer`] that produces [`MapResponse`] services./// This is a convenience function that simply calls [`MapResponseLayer::new`]./// Creates a new [`MapResponseLayer`] layer.MapResult/// Service returned by the [`map_result`] combinator./// [`map_result`]: crate::util::ServiceExt::map_result/// A [`Layer`] that produces a [`MapResult`] service.r" Response future from [`MapResult`] services."r" [`MapResult`]: crate::util::MapResult"MapResultFuture/// Creates a new [`MapResult`] service./// Returns a new [`Layer`] that produces [`MapResult`] services./// This is a convenience function that simply calls [`MapResultLayer::new`]./// Creates a new [`MapResultLayer`] layer.boxed_clone_synccall_allReadyOneshotThenFuture/// Yields a mutable reference to the service when it is ready to accept a request.ready_oneshot/// Yields the service when it is ready to accept a request./// Consume this `Service`, calling it with the provided request once it is ready./// Process all requests from the given [`Stream`], and produce a [`Stream`] of their responses./// This is essentially [`Stream<Item = Request>`][stream] + `Self` => [`Stream<Item =/// Response>`][stream]. See the documentation for [`CallAll`] for/// [stream]: https://docs.rs/futures/latest/futures/stream/trait.Stream.html/// # use std::task::{Poll, Context};/// # use tower::{Service, ServiceExt};/// # struct DatabaseService;/// # impl DatabaseService {/// #   fn new(address: &str) -> Self {/// #       DatabaseService/// # struct Record {/// #   pub name: String,/// #   pub age: u16/// # impl Service<u32> for DatabaseService {/// #   type Response = Record;/// #   type Error = u8;/// #   type Future = futures_util::future::Ready<Result<Record, u8>>;/// #   fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {/// #       Poll::Ready(Ok(()))/// #   fn call(&mut self, request: u32) -> Self::Future {/// #       futures_util::future::ready(Ok(Record { name: "Jack".into(), age: 32 }))/// # async fn avatar_lookup(name: String) -> Result<Vec<u8>, u8> { Ok(vec![]) }/// #    async {/// // A service returning Result<Record, _>/// let service = DatabaseService::new("127.0.0.1:8080");/// // Map the response into a new response/// let mut new_service = service.and_then(|record: Record| async move {///     let name = record.name;///     avatar_lookup(name).await/// // Call the new service/// let id = 13;/// let avatar = new_service.call(id).await.unwrap();/// #    };/// Maps this service's response value to a different value. This does not/// alter the behaviour of the [`poll_ready`] method./// into a different type. It is similar to the [`Result::map`]/// let mut new_service = service.map_response(|record| record.name);/// let name = new_service///     .ready()///     .call(id)/// # Ok::<(), u8>(())/// Maps this service's error value to a different value. This does not/// This method can be used to change the [`Error`] type of the service/// into a different type. It is similar to the [`Result::map_err`] method./// [`Error`]: crate::Service::Error/// # struct Error {/// #   pub code: u32,/// #   pub message: String/// #   type Response = String;/// #   type Error = Error;/// #   type Future = futures_util::future::Ready<Result<String, Error>>;/// #       futures_util::future::ready(Ok(String::new()))/// #   async {/// // A service returning Result<_, Error>/// // Map the error to a new error/// let mut new_service = service.map_err(|err| err.code);/// let code = new_service/// # Ok::<(), u32>(())/// #   };/// This is similar to the [`map_response`] and [`map_err`] combinators,/// Like the standard library's [`Result::and_then`], this method can be/// used to implement control flow based on `Result` values. For example, it/// may be used to implement error recovery, by turning some [`Err`]/// responses from the service into [`Ok`] responses. Similarly, some/// successful responses from the service could be rejected, by returning an/// [`Err`] conditionally, depending on the value inside the [`Ok`.] Finally,/// this method can also be used to implement behaviors that must run when a/// service's future completes, regardless of whether it succeeded or failed./// into a different type. It can also be used to change the [`Error`] type/// of the service. However, because the [`map_result`] function is not applied/// to the errors returned by the service's [`poll_ready`] method, it must/// be possible to convert the service's [`Error`] type into the error type/// returned by the [`map_result`] function. This is trivial when the function/// returns the same error type as the service, but in other cases, it can/// be useful to use [`BoxError`] to erase differing error types./// Recovering from certain errors:/// # enum DbError {/// #   Parse(std::num::ParseIntError),/// #   NoRecordsFound,/// #   type Response = Vec<Record>;/// #   type Error = DbError;/// #   type Future = futures_util::future::Ready<Result<Vec<Record>, DbError>>;/// #       futures_util::future::ready(Ok(vec![Record { name: "Jack".into(), age: 32 }]))/// // A service returning Result<Vec<Record>, DbError>/// // If the database returns no records for the query, we just want an empty `Vec`./// let mut new_service = service.map_result(|result| match result {///     // If the error indicates that no records matched the query, return an empty///     // `Vec` instead.///     Err(DbError::NoRecordsFound) => Ok(Vec::new()),///     // Propagate all other responses (`Ok` and `Err`) unchanged///     x => x,/// # Ok::<(), DbError>(())/// Rejecting some `Ok` responses:/// # type DbError = String;/// # type AppError = String;/// #   type Future = futures_util::future::Ready<Result<Record, DbError>>;/// use tower::BoxError;/// // A service returning Result<Record, DbError>/// // If the user is zero years old, return an error./// let mut new_service = service.map_result(|result| {///    let record = result?;///    if record.age == 0 {///         // Users must have been born to use our app!///         let app_error = AppError::from("users cannot be 0 years old!");///         // Box the error to erase its type (as it can be an `AppError`///         // *or* the inner service's `DbError`).///         return Err(BoxError::from(app_error));///     // Otherwise, return the record.///     Ok(record)/// let record = new_service/// # Ok::<(), BoxError>(())/// Performing an action that must be run for both successes and failures:/// #   type Future = futures_util::future::Ready<Result<String, u8>>;/// // Print a message whenever a query completes.///     println!("query completed; success={}", result.is_ok());/// let response = new_service/// # response/// [`map_response`]: ServiceExt::map_response/// [`map_err`]: ServiceExt::map_err/// [`map_result`]: ServiceExt::map_result/// [`BoxError`]: crate::BoxErrorNewRequest/// Composes a function *in front of* the service./// This adapter produces a new service that passes each value through the/// # impl Service<String> for DatabaseService {/// #   fn call(&mut self, request: String) -> Self::Future {/// // A service taking a String as a request/// // Map the request to a new request/// let mut new_service = service.map_request(|id: u32| id.to_string());/// Composes an asynchronous function *after* this service./// This takes a function or closure returning a future, and returns a new/// `Service` that chains that function after this service's [`Future`]. The/// new `Service`'s future will consist of this service's future, followed/// by the future returned by calling the chained function with the future's/// [`Output`] type. The chained function is called regardless of whether/// this service's future completes with a successful response or with an/// This method can be thought of as an equivalent to the [`futures`/// crate]'s [`FutureExt::then`] combinator, but acting on `Service`s that/// _return_ futures, rather than on an individual future. Similarly to that/// combinator, [`ServiceExt::then`] can be used to implement asynchronous/// error recovery, by calling some asynchronous function with errors/// returned by this service. Alternatively, it may also be used to call a/// fallible async function with the successful response of this service./// of the service. However, because the `then` function is not applied/// returned by the `then` future. This is trivial when the function/// # type Record = ();/// # type DbError = ();/// #       futures_util::future::ready(Ok(()))/// // An async function that attempts to recover from errors returned by the/// // database./// async fn recover_from_error(error: DbError) -> Result<Record, DbError> {/// // If the database service returns an error, attempt to recover by/// // calling `recover_from_error`. Otherwise, return the successful response./// let mut new_service = service.then(|result| async move {///     match result {///         Ok(record) => Ok(record),///         Err(e) => recover_from_error(e).await,/// [`Future`]: crate::Service::Future/// [`Output`]: std::future::Future::Output/// [`futures` crate]: https://docs.rs/futures/// [`FutureExt::then`]: https://docs.rs/futures/latest/futures/future/trait.FutureExt.html#method.then/// This takes a function or closure returning a future computed from the future returned by/// the service's [`call`] method, as opposed to the responses produced by the future./// # use tower::{Service, ServiceExt, BoxError};/// # type DbError = crate::BoxError;/// let mut new_service = service.map_future(|future| async move {///     let res = timeout(Duration::from_secs(1), future).await?;///     Ok::<_, BoxError>(res)/// Note that normally you wouldn't implement timeouts like this and instead use [`Timeout`]./// [`Timeout`]: crate::timeout::Timeout/// Convert the service into a [`Service`] + [`Send`] trait object./// See [`BoxService`] for more details./// If `Self` implements the [`Clone`] trait, the [`boxed_clone`] method/// can be used instead, to produce a boxed service which will also/// implement [`Clone`]./// use tower::{Service, ServiceExt, BoxError, service_fn, util::BoxService};/// let service = service_fn(|req: Request| async {///     Ok::<_, BoxError>(Response::new())/// let service: BoxService<Request, Response, BoxError> = service///     .boxed();/// [`boxed_clone`]: Self::boxed_clone/// Convert the service into a [`Service`] + [`Clone`] + [`Send`] trait object./// use tower::{Service, ServiceExt, BoxError, service_fn, util::BoxCloneService};/// let service: BoxCloneService<Request, Response, BoxError> = service///     .boxed_clone();/// An extension trait for `Service`s that provides a variety of convenient/// adapters/// Convert an `Option<Layer>` into a [`Layer`]./// use tower::util::option_layer;/// // Layer to apply a timeout if configured/// let maybe_timeout = option_layer(timeout.map(TimeoutLayer::new));///     .layer(maybe_timeout)/// [`Layer`]: crate::layer::Layer//! Various utility types and functions that are generally used with Tower.r" A [`Future`] consuming a [`Service`] and request, waiting until the [`Service`]"r" is ready, and then calling [`Service::call`] with the request, and"r" waiting for that [`Future`]."/// Error returned if the inner [`Service`] has not been set.r" Response future returned by [`Optional`]."r" [`Optional`]: crate::util::Optional"/// Error types for [`Optional`]./// Future types for [`Optional`]./// Optionally forwards requests to an inner service./// If the inner service is [`None`], [`optional::None`] is returned as the response./// [`optional::None`]: crate::util::error::optional::None/// Create a new [`Optional`].//! Contains [`Optional`] and related types and functions.//! See [`Optional`] documentation for more details./// A [`Future`] that yields the service when it is ready to accept a request./// [`ReadyOneshot`] values are produced by [`ServiceExt::ready_oneshot`]./// [`ServiceExt::ready_oneshot`]: crate::util::ServiceExt::ready_oneshot// Safety: This is safe because `Services`'s are always `Unpin`./// A future that yields a mutable reference to the service when it is ready to accept a request./// [`Ready`] values are produced by [`ServiceExt::ready`]./// [`ServiceExt::ready`]: crate::util::ServiceExt::ready// Safety: This is safe for the same reason that the impl for ReadyOneshot is safe./// Generate a random [`u64`].next_f64/// Generate a random [`f64`] between `[0, 1)`./// Randomly pick a value within the range./// - If start < end this will panic in debug mode./// A simple [PRNG] trait for use within tower middleware./// [PRNG]: https://en.wikipedia.org/wiki/Pseudorandom_number_generator/// A [`Rng`] implementation that uses a [`Hasher`] to generate the random/// values. The implementation uses an internal counter to pass to the hasher/// for each iteration of [`Rng::next_u64`]./// This hasher has a default type of [`RandomState`] which just uses the/// libstd method of getting a random u64./// Create a new default [`HasherRng`]./// Create a new [`HasherRng`] with the provided hasher.sample_inplace_boundaries//! [PRNG] utilities for tower middleware.//! This module provides a generic [`Rng`] trait and a [`HasherRng`] that//! implements the trait based on [`RandomState`] or any other [`Hasher`].//! These utilities replace tower's internal usage of `rand` with these smaller,//! more lightweight methods. Most of the implementations are extracted from//! their corresponding `rand` implementations.//! [PRNG]: https://en.wikipedia.org/wiki/Pseudorandom_number_generator/// Returns a new [`ServiceFn`] with the given closure./// This lets you build a [`Service`] from an async function that returns a [`Result`]./// use tower::{service_fn, Service, ServiceExt, BoxError};/// # impl Request {/// # struct Response(&'static str);/// #     fn new(body: &'static str) -> Self {/// #         Self(body)/// #     fn into_body(self) -> &'static str { self.0 }/// async fn handle(request: Request) -> Result<Response, BoxError> {///     let response = Response::new("Hello, World!");///     Ok(response)/// let mut service = service_fn(handle);/// let response = service///     .call(Request::new())/// assert_eq!("Hello, World!", response.into_body());/// A [`Service`] implemented by a closure./// See [`service_fn`] for more details./// [`Service`] returned by the [`then`] combinator./// [`then`]: crate::util::ServiceExt::then/// A [`Layer`] that produces a [`Then`] service./// Creates a new `Then` service./// Returns a new [`Layer`] that produces [`Then`] services./// This is a convenience function that simply calls [`ThenLayer::new`].r" Response future from [`Then`] services."r" [`Then`]: crate::util::Then"/// Creates a new [`ThenLayer`] layer.AddExtensionLayer/// [`Layer`] for adding some shareable value to [request extensions]./// See the [module docs](crate::add_extension) for more details./// [request extensions]: https://docs.rs/http/latest/http/struct.Extensions.html/// Create a new [`AddExtensionLayer`].AddExtension/// Middleware for adding some shareable value to [request extensions]./// Create a new [`AddExtension`].define_inner_service_accessors/// Returns a new [`Layer`] that wraps services with a `AddExtension` middleware.test_helpers//! Middleware that clones a value into each request's [extensions].//! [extensions]: https://docs.rs/http/latest/http/struct.Extensions.html//! use tower_http::add_extension::AddExtensionLayer;//! use tower::{Service, ServiceExt, ServiceBuilder, service_fn};//! use http_body_util::Full;//! use std::{sync::Arc, convert::Infallible};//! # struct DatabaseConnectionPool;//! # impl DatabaseConnectionPool {//! #     fn new() -> DatabaseConnectionPool { DatabaseConnectionPool }//! // Shared state across all request handlers --- in this case, a pool of database connections.//! struct State {//!     pool: DatabaseConnectionPool,//! async fn handle(req: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {//!     // Grab the state from the request extensions.//!     let state = req.extensions().get::<Arc<State>>().unwrap();//!     Ok(Response::new(Full::default()))//! // Construct the shared state.//! let state = State {//!     pool: DatabaseConnectionPool::new(),//! let mut service = ServiceBuilder::new()//!     // Share an `Arc<State>` with all requests.//!     .layer(AddExtensionLayer::new(Arc::new(state)))//!     .service_fn(handle);//! // Call the service.//! let response = service//!     .ready()//!     .call(Request::new(Full::default()))AddAuthorizationLayer/// Layer that applies [`AddAuthorization`] which adds authorization to all requests using the/// [`Authorization`] header./// See the [module docs](crate::auth::add_authorization) for an example./// You can also use [`SetRequestHeader`] if you have a use case that isn't supported by this/// [`Authorization`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization/// [`SetRequestHeader`]: crate::set_header::SetRequestHeader/// Authorize requests using a username and password pair./// The `Authorization` header will be set to `Basic {credentials}` where `credentials` is/// `base64_encode("{username}:{password}")`./// Since the username and password is sent in clear text it is recommended to use HTTPS/TLS/// with this method. However use of HTTPS/TLS is not enforced by this middleware.bearer/// Authorize requests using a "bearer token". Commonly used for OAuth 2./// The `Authorization` header will be set to `Bearer {token}`./// Panics if the token is not a valid [`HeaderValue`].as_sensitive/// Mark the header as [sensitive]./// This can for example be used to hide the header value from logs./// [sensitive]: https://docs.rs/http/latest/http/header/struct.HeaderValue.html#method.set_sensitiveAddAuthorization/// Middleware that adds authorization all requests using the [`Authorization`] header.validate_requestValidateRequestHeaderLayermaking_header_sensitive//! Add authorization to requests using the [`Authorization`] header.//! [`Authorization`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization//! use tower_http::validate_request::{ValidateRequestHeader, ValidateRequestHeaderLayer};//! use tower_http::auth::AddAuthorizationLayer;//! use http::{Request, Response, StatusCode, header::AUTHORIZATION};//! use tower::{Service, ServiceExt, ServiceBuilder, service_fn, BoxError};//! # async fn handle(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, BoxError> {//! #     Ok(Response::new(Full::default()))//! # async fn main() -> Result<(), BoxError> {//! # let service_that_requires_auth = ValidateRequestHeader::basic(//! #     tower::service_fn(handle),//! #     "username",//! #     "password",//! let mut client = ServiceBuilder::new()//!     // Use basic auth with the given username and password//!     .layer(AddAuthorizationLayer::basic("username", "password"))//!     .service(service_that_requires_auth);//! // Make a request, we don't have to add the `Authorization` header manually//! let response = client//! assert_eq!(StatusCode::OK, response.status());AsyncRequireAuthorizationLayer/// Layer that applies [`AsyncRequireAuthorization`] which authorizes all requests using the/// See the [module docs](crate::auth::async_require_authorization) for an example./// Authorize requests using a custom scheme.AsyncRequireAuthorization/// Middleware that authorizes all requests using the [`Authorization`] header./// The `Authorization` header is required to have the value provided./// Returns a new [`Layer`] that wraps services with an [`AsyncRequireAuthorizationLayer`]AsyncAuthorizeRequestRequestBody/// The type of request body returned by `authorize`./// Set this to `B` unless you need to change the request body type./// The body type used for responses to unauthorized requests./// The Future type returned by `authorize`/// Authorize the request./// If the future resolves to `Ok(request)` then the request is allowed through, otherwise not./// Trait for authorizing requests.MyAuthrequire_async_auth_worksrequire_async_auth_401//! Authorize requests using the [`Authorization`] header asynchronously.//! use tower_http::auth::{AsyncRequireAuthorizationLayer, AsyncAuthorizeRequest};//! use futures_core::future::BoxFuture;//! #[derive(Clone, Copy)]//! struct MyAuth;//! impl<B> AsyncAuthorizeRequest<B> for MyAuth//!     B: Send + Sync + 'static,//!     type RequestBody = B;//!     type ResponseBody = Full<Bytes>;//!     type Future = BoxFuture<'static, Result<Request<B>, Response<Self::ResponseBody>>>;//!     fn authorize(&mut self, mut request: Request<B>) -> Self::Future {//!         Box::pin(async {//!             if let Some(user_id) = check_auth(&request).await {//!                 // Set `user_id` as a request extension so it can be accessed by other//!                 // services down the stack.//!                 request.extensions_mut().insert(user_id);//!                 Ok(request)//!                 let unauthorized_response = Response::builder()//!                     .status(StatusCode::UNAUTHORIZED)//!                     .body(Full::<Bytes>::default())//!                     .unwrap();//!                 Err(unauthorized_response)//! async fn check_auth<B>(request: &Request<B>) -> Option<UserId> {//!     # None//! #[derive(Debug, Clone)]//! struct UserId(String);//! async fn handle(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, BoxError> {//!     // Access the `UserId` that was set in `on_authorized`. If `handle` gets called the//!     // request was authorized and `UserId` will be present.//!     let user_id = request//!         .extensions()//!         .get::<UserId>()//!         .expect("UserId will be there if request was authorized");//!     println!("request from {:?}", user_id);//! let service = ServiceBuilder::new()//!     // Authorize requests using `MyAuth`//!     .layer(AsyncRequireAuthorizationLayer::new(MyAuth))//! Or using a closure://! use tower::{Service, ServiceExt, ServiceBuilder, BoxError};//!     # todo!();//!     .layer(AsyncRequireAuthorizationLayer::new(|request: Request<Full<Bytes>>| async move {//!         if let Some(user_id) = check_auth(&request).await {//!             Ok(request)//!             let unauthorized_response = Response::builder()//!                 .status(StatusCode::UNAUTHORIZED)//!                 .body(Full::<Bytes>::default())//!                 .unwrap();//!             Err(unauthorized_response)//!     }))add_authorizationasync_require_authorizationrequire_authorization//! Authorization related middleware.ValidateRequestValidateRequestHeader/// The `Authorization` header is required to be `Basic {credentials}` where `credentials` is/// The `Authorization` header is required to be `Bearer {token}`.Bearer/// Type that performs "bearer token" authorization./// See [`ValidateRequestHeader::bearer`] for more details./// Type that performs basic authorization./// See [`ValidateRequestHeader::basic`] for more details.valid_basic_tokeninvalid_basic_tokenvalid_bearer_tokenbasic_auth_is_case_sensitive_in_prefixbasic_auth_is_case_sensitive_in_valueinvalid_bearer_tokenbearer_token_is_case_sensitive_in_prefixbearer_token_is_case_sensitive_in_token//! Authorize requests using [`ValidateRequest`].//! use tower_http::validate_request::{ValidateRequest, ValidateRequestHeader, ValidateRequestHeaderLayer};//!     // Require the `Authorization` header to be `Bearer passwordlol`//!     .layer(ValidateRequestHeaderLayer::bearer("passwordlol"))//! // Requests with the correct token are allowed through//! let request = Request::builder()//!     .header(AUTHORIZATION, "Bearer passwordlol")//!     .body(Full::default())//!     .call(request)//! // Requests with an invalid token get a `401 Unauthorized` response//! assert_eq!(StatusCode::UNAUTHORIZED, response.status());//! Custom validation can be made by implementing [`ValidateRequest`].body_methods//! Body types.//! All these are wrappers around other body types. You shouldn't have to use them in your code.//! Use `http-body-util` instead.//! They exist because we don't want to expose types from `http-body-util` in `tower-http`s publicpropagate_headerPropagateHeaderLayer/// Propagate a header from the request to the response./// See [`tower_http::propagate_header`] for more details./// [`tower_http::propagate_header`]: crate::propagate_headeradd_extension/// Add some shareable value to [request extensions]./// See [`tower_http::add_extension`] for more details./// [`tower_http::add_extension`]: crate::add_extensionmap_request_bodyMapRequestBodyLayer/// Apply a transformation to the request body./// See [`tower_http::map_request_body`] for more details./// [`tower_http::map_request_body`]: crate::map_request_bodymap_response_bodyMapResponseBodyLayer/// Apply a transformation to the response body./// See [`tower_http::map_response_body`] for more details./// [`tower_http::map_response_body`]: crate::map_response_bodyCompressionLayer/// Compresses response bodies./// See [`tower_http::compression`] for more details./// [`tower_http::compression`]: crate::compressiondecompressionDecompressionLayer/// Decompress response bodies./// See [`tower_http::decompression`] for more details./// [`tower_http::decompression`]: crate::decompressiontrace_for_httpHttpMakeClassifierTraceLayer/// High level tracing that classifies responses using HTTP status codes./// This method does not support customizing the output, to do that use [`TraceLayer`]/// See [`tower_http::trace`] for more details./// [`tower_http::trace`]: crate::trace/// [`TraceLayer`]: crate::trace::TraceLayertrace_for_grpcGrpcMakeClassifier/// High level tracing that classifies responses using gRPC headers.FollowRedirectLayer/// Follow redirect resposes using the [`Standard`] policy./// See [`tower_http::follow_redirect`] for more details./// [`tower_http::follow_redirect`]: crate::follow_redirect/// [`Standard`]: crate::follow_redirect::policy::Standardsensitive_headersSetSensitiveHeadersLayer/// Mark headers as [sensitive] on both requests and responses./// See [`tower_http::sensitive_headers`] for more details./// [`tower_http::sensitive_headers`]: crate::sensitive_headerssensitive_request_headersSetSensitiveRequestHeadersLayer/// Mark headers as [sensitive] on requests.sensitive_response_headersSetSensitiveResponseHeadersLayer/// Mark headers as [sensitive] on responses.override_request_headerSetRequestHeaderLayer/// Insert a header into the request./// If a previous value exists for the same header, it is removed and replaced with the new/// header value./// See [`tower_http::set_header`] for more details./// [`tower_http::set_header`]: crate::set_headerappend_request_header/// Append a header into the request./// If previous values exist, the header will have multiple values.insert_request_header_if_not_present/// Insert a header into the request, if the header is not already present.override_response_headerSetResponseHeaderLayer/// Insert a header into the response.append_response_header/// Append a header into the response.insert_response_header_if_not_present/// Insert a header into the response, if the header is not already present.set_request_idSetRequestIdLayerMakeRequestId/// Add request id header and extension./// See [`tower_http::request_id`] for more details./// [`tower_http::request_id`]: crate::request_idset_x_request_id/// Add request id header and extension, using `x-request-id` as the header name.propagate_request_idPropagateRequestIdLayer/// Propgate request ids from requests to responses.propagate_x_request_id/// Propgate request ids from requests to responses, using `x-request-id` as the header name.DefaultResponseForPanicCatchPanicLayer/// Catch panics and convert them into `500 Internal Server` responses./// See [`tower_http::catch_panic`] for more details./// [`tower_http::catch_panic`]: crate::catch_panicrequest_body_limitRequestBodyLimitLayer/// Intercept requests with over-sized payloads and convert them into/// `413 Payload Too Large` responses./// See [`tower_http::limit`] for more details./// [`tower_http::limit`]: crate::limittrim_trailing_slashnormalize_pathNormalizePathLayer/// Remove trailing slashes from paths./// See [`tower_http::normalize_path`] for more details./// [`tower_http::normalize_path`]: crate::normalize_pathappend_trailing_slash/// Append trailing slash to paths.ServiceBuilderExt/// Extension trait that adds methods to [`tower::ServiceBuilder`] for adding middleware from/// tower-http./// [`Service`]: tower::Service/// use http::{Request, Response, header::HeaderName};/// use std::{time::Duration, convert::Infallible};/// use tower::{ServiceBuilder, ServiceExt, Service};/// use tower_http::ServiceBuilderExt;/// async fn handle(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {///     Ok(Response::new(Full::default()))///     // Methods from tower///     .timeout(Duration::from_secs(30))///     // Methods from tower-http///     .trace_for_http()///     .propagate_header(HeaderName::from_static("x-request-id"))/// # let mut service = service;/// # service.ready().await.unwrap().call(Request::new(Full::default())).await.unwrap();// ^ work around rustdoc not inferring doc(cfg)s for cfg's from surrounding scopes/// Layer that applies the [`CatchPanic`] middleware that catches panics and converts them into/// `500 Internal Server` responses./// See the [module docs](self) for an example./// Create a new `CatchPanicLayer` with the default panic handler.ResponseForPanic/// Create a new `CatchPanicLayer` with a custom panic handler.CatchPanic/// Middleware that catches panics and converts them into `500 Internal Server` responses./// Create a new `CatchPanic` with the default panic handler./// Create a new `CatchPanic` with a custom panic handler.response_for_panic/// The body type used for responses to panics./// Create a response from the panic error./// Trait for creating responses from panics./// The default `ResponseForPanic` used by `CatchPanic`./// It will log the panic message and return a `500 Internal Server` error response with an empty/// body.panic_before_returning_futurepanic_in_future//! Convert panics into responses.//! Note that using panics for error handling is _not_ recommended. Prefer instead to use `Result`//! whenever possible.//! use http::{Request, Response, header::HeaderName};//! use std::convert::Infallible;//! use tower_http::catch_panic::CatchPanicLayer;//!     panic!("something went wrong...")//! let mut svc = ServiceBuilder::new()//!     // Catch panics and convert them into responses.//!     .layer(CatchPanicLayer::new())//! let request = Request::new(Full::default());//! let response = svc.ready().await?.call(request).await?;//! assert_eq!(response.status(), 500);//! Using a custom panic handler://! use http::{Request, StatusCode, Response, header::{self, HeaderName}};//! use std::{any::Any, convert::Infallible};//! fn handle_panic(err: Box<dyn Any + Send + 'static>) -> Response<Full<Bytes>> {//!     let details = if let Some(s) = err.downcast_ref::<String>() {//!         s.clone()//!     } else if let Some(s) = err.downcast_ref::<&str>() {//!         s.to_string()//!         "Unknown panic message".to_string()//!     let body = serde_json::json!({//!         "error": {//!             "kind": "panic",//!             "details": details,//!     let body = serde_json::to_string(&body).unwrap();//!         .status(StatusCode::INTERNAL_SERVER_ERROR)//!         .header(header::CONTENT_TYPE, "application/json")//!         .body(Full::from(body))//! let svc = ServiceBuilder::new()//!     // Use `handle_panic` to create the response.//!     .layer(CatchPanicLayer::custom(handle_panic))ClassifiedResponseClassifyEosClassifyResponseSharedClassifierGrpcCode/// The operation completed successfully./// The operation was cancelled./// Client specified an invalid argument.DeadlineExceeded/// Deadline expired before operation could complete./// Some requested entity was not found./// Some entity that we attempted to create already exists./// The caller does not have permission to execute the specified operation.ResourceExhausted/// Some resource has been exhausted.FailedPrecondition/// The system is not in a state required for the operation's execution./// The operation was aborted./// Operation was attempted past the valid range./// Operation is not implemented or not supported./// Internal error./// The service is currently unavailable.DataLoss/// Unrecoverable data loss or corruption.Unauthenticated/// The request does not have valid authentication credentials/// gRPC status codes./// These variants match the [gRPC status codes]./// [gRPC status codes]: https://github.com/grpc/grpc/blob/master/doc/statuscodes.md#status-codes-and-their-use-in-grpcinto_bitmaskGrpcCodeBitmaskINVALID_ARGUMENTDEADLINE_EXCEEDEDALREADY_EXISTSPERMISSION_DENIEDRESOURCE_EXHAUSTEDFAILED_PRECONDITIONABORTEDUNIMPLEMENTEDINTERNALUNAVAILABLEDATA_LOSSUNAUTHENTICATEDtry_from_u32success_codesGrpcErrorsAsFailures/// Response classifier for gRPC responses./// gRPC doesn't use normal HTTP statuses for indicating success or failure but instead a special/// header that might appear in a trailer./// Responses are considered successful if/// - `grpc-status` header value contains a success value./// - `grpc-status` header is missing./// - `grpc-status` header value isn't a valid `String`./// - `grpc-status` header value can't parsed into an `i32`./// All others are considered failures./// Create a new [`GrpcErrorsAsFailures`].with_success/// Change which gRPC codes are considered success./// Defaults to only considering `Ok` as success./// `Ok` will always be considered a success./// Servers might not want to consider `Invalid Argument` or `Not Found` as failures since/// thats likely the clients fault:/// use tower_http::classify::{GrpcErrorsAsFailures, GrpcCode};/// let classifier = GrpcErrorsAsFailures::new()///     .with_success(GrpcCode::InvalidArgument)///     .with_success(GrpcCode::NotFound);make_classifier/// Returns a [`MakeClassifier`](super::MakeClassifier) that produces `GrpcErrorsAsFailures`./// This is a convenience function that simply calls `SharedClassifier::new`.FailureClassGrpcFailureClassGrpcEosErrorsAsFailuresclassify_responseclassify_error/// The [`ClassifyEos`] for [`GrpcErrorsAsFailures`].classify_eos/// A gRPC response was classified as a failure with the corresponding status./// A gRPC response was classified as an error with the corresponding error description./// The failure class for [`GrpcErrorsAsFailures`].classify_grpc_metadataParsedGrpcStatusNonSuccessGrpcStatusHeaderMissingHeaderNotString// these two are treated as `Success` but kept separate for clarityHeaderNotIntclassify_grpc_metadata_testbasic_okbasic_errortwo_success_codes_first_matchestwo_success_codes_second_matchestwo_success_codes_none_matchesMapFailureClass/// Response classifier that transforms the failure class of some other/// classifier./// Created with [`ClassifyResponse::map_failure_class`] or/// [`ClassifyEos::map_failure_class`].NewClassgrpc_errors_as_failuresmap_failure_classstatus_in_range_is_errorStatusInRangeAsFailuresStatusInRangeFailureClass/// The response classifier produced./// The type of failure classifications./// This might include additional information about the error, such as/// whether it was a client or server error, or whether or not it should/// be considered retryable./// The type used to classify the response end of stream (EOS)./// Returns a response classifier for this requestMakeClassifier/// Trait for producing response classifiers from a request./// This is useful when a classifier depends on data from the request. For example, this could/// include the URI or HTTP method./// This trait is generic over the [`Error` type] of the `Service`s used with the classifier./// This is necessary for [`ClassifyResponse::classify_error`]./// [`Error` type]: https://docs.rs/tower/latest/tower/trait.Service.html#associatedtype.Error/// A [`MakeClassifier`] that produces new classifiers by cloning an inner classifier./// When a type implementing [`ClassifyResponse`] doesn't depend on information/// from the request, [`SharedClassifier`] can be used to turn an instance of that type/// into a [`MakeClassifier`]./// use tower_http::classify::{///     ClassifyResponse, ClassifiedResponse, NeverClassifyEos,///     SharedClassifier, MakeClassifier,/// // A response classifier that only considers errors to be failures./// struct MyClassifier;/// impl ClassifyResponse for MyClassifier {///     type FailureClass = String;///     type ClassifyEos = NeverClassifyEos<Self::FailureClass>;///     fn classify_response<B>(///         self,///         _res: &Response<B>,///     ) -> ClassifiedResponse<Self::FailureClass, Self::ClassifyEos> {///         ClassifiedResponse::Ready(Ok(()))///     fn classify_error<E>(self, error: &E) -> Self::FailureClass///         E: fmt::Display + 'static,///         error.to_string()/// // Some function that requires a `MakeClassifier`/// fn use_make_classifier<M: MakeClassifier>(make: M) {/// // `MyClassifier` doesn't implement `MakeClassifier` but since it doesn't/// // care about the incoming request we can make `MyClassifier`s by cloning./// // That is what `SharedClassifier` does./// let make_classifier = SharedClassifier::new(MyClassifier);/// // We now have a `MakeClassifier`!/// use_make_classifier(make_classifier);/// Create a new `SharedClassifier` from the given classifier./// The type returned when a response is classified as a failure./// Depending on the classifier, this may simply indicate that the/// request failed, or it may contain additional  information about/// the failure, such as whether or not it is retryable./// Attempt to classify the beginning of a response./// In some cases, the response can be classified immediately, without/// waiting for a body to complete. This may include:/// - When the response has an error status code./// - When a successful response does not have a streaming body./// - When the classifier does not care about streaming bodies./// When the response can be classified immediately, `classify_response`/// returns a [`ClassifiedResponse::Ready`] which indicates whether the/// response succeeded or failed./// In other cases, however, the classifier may need to wait until the/// response body stream completes before it can classify the response./// For example, gRPC indicates RPC failures using the `grpc-status`/// trailer. In this case, `classify_response` returns a/// [`ClassifiedResponse::RequiresEos`] containing a type which will/// be used to classify the response when the body stream ends./// Classify an error./// Errors are always errors (doh) but sometimes it might be useful to have multiple classes of/// errors. A retry policy might allow retrying some errors and not others./// Transform the failure classification using a function.///     ServerErrorsAsFailures, ServerErrorsFailureClass,///     ClassifyResponse, ClassifiedResponse/// use http::{Response, StatusCode};/// fn transform_failure_class(class: ServerErrorsFailureClass) -> NewFailureClass {///     match class {///         // Convert status codes into u16///         ServerErrorsFailureClass::StatusCode(status) => {///             NewFailureClass::Status(status.as_u16())///         // Don't change errors.///         ServerErrorsFailureClass::Error(error) => {///             NewFailureClass::Error(error)/// enum NewFailureClass {///     Status(u16),///     Error(String),/// // Create a classifier who's failure class will be transformed by `transform_failure_class`/// let classifier = ServerErrorsAsFailures::new().map_failure_class(transform_failure_class);///     .status(StatusCode::INTERNAL_SERVER_ERROR)///     .body(Empty::<Bytes>::new())/// let classification = classifier.classify_response(&response);///     classification,///     ClassifiedResponse::Ready(Err(NewFailureClass::Status(500)))/// Trait for classifying responses as either success or failure. Designed to support both unary/// requests (single request for a single response) as well as streaming responses./// Response classifiers are used in cases where middleware needs to determine/// whether a response completed successfully or failed. For example, they may/// be used by logging or metrics middleware to record failures differently/// from successes./// Furthermore, when a response fails, a response classifier may provide/// additional information about the failure. This can, for example, be used to/// build [retry policies] by indicating whether or not a particular failure is/// retryable./// [retry policies]: https://docs.rs/tower/latest/tower/retry/trait.Policy.html/// Perform the classification from response trailers./// See [`ClassifyResponse::map_failure_class`] for more details./// Trait for classifying end of streams (EOS) as either success or failure./// The response was able to be classified immediately.RequiresEos/// We have to wait until the end of a streaming response to classify it./// Result of doing a classification._output_ty_neverNeverClassifyEos/// A [`ClassifyEos`] type that can be used in [`ClassifyResponse`] implementations that never have/// to classify streaming responses./// `NeverClassifyEos` exists only as type.  `NeverClassifyEos` values cannot be constructed.ServerErrorsAsFailures/// The default classifier used for normal HTTP responses./// Responses with a `5xx` status code are considered failures, all others are considered/// successes./// Create a new [`ServerErrorsAsFailures`]./// Returns a [`MakeClassifier`] that produces `ServerErrorsAsFailures`.ServerErrorsFailureClass/// A response was classified as a failure with the corresponding status./// A response was classified as an error with the corresponding error description./// The failure class for [`ServerErrorsAsFailures`].is_retryableIsRetryableRetryBasedOnClassificationReqBResBusable_for_retries// Just verify that we can actually use this response classifier to determine retries as well//! Tools for classifying responses as either success or failure./// Response classifier that considers responses with a status code within some range to be/// failures./// A client with tracing where server errors _and_ client errors are considered failures./// use tower_http::{trace::TraceLayer, classify::StatusInRangeAsFailures};/// use tower::{ServiceBuilder, Service, ServiceExt};/// use http::{Request, Method};/// use hyper_util::{rt::TokioExecutor, client::legacy::Client};/// # async fn foo() -> Result<(), tower::BoxError> {/// let classifier = StatusInRangeAsFailures::new(400..=599);/// let mut client = ServiceBuilder::new()///     .layer(TraceLayer::new(classifier.into_make_classifier()))///     .service(client);///     .method(Method::GET)///     .uri("https://example.com")///     .body(Full::<Bytes>::default())/// let response = client.ready().await?.call(request).await?;/// Creates a new `StatusInRangeAsFailures`./// Panics if the start or end of `range` aren't valid status codes as determined by/// [`StatusCode::from_u16`]./// [`StatusCode::from_u16`]: https://docs.rs/http/latest/http/status/struct.StatusCode.html#method.from_u16new_for_client_and_server_errors/// Creates a new `StatusInRangeAsFailures` that classifies client and server responses as/// This is a convenience for `StatusInRangeAsFailures::new(400..=599)`.into_make_classifier/// Convert this `StatusInRangeAsFailures` into a [`MakeClassifier`]./// [`MakeClassifier`]: super::MakeClassifier/// The failure class for [`StatusInRangeAsFailures`].response_with_statuscompression_utilsAsyncReadBodyBodyIntoStreamDecorateAsyncReadWrapBodypin_project_cfgCompressionBodyBodyInnerGzipBodyDeflateBodyBrotliBodyZstdBodycontent_encodingcontains_ignore_ascii_caseDefaultPredicate/// Compress response bodies of the underlying service./// This uses the `Accept-Encoding` header to pick an appropriate encoding and adds the/// `Content-Encoding` header to responses./// See the [module docs](crate::compression) for more details./// Creates a new [`CompressionLayer`]./// Sets whether to enable the gzip encoding./// Sets whether to enable the Deflate encoding./// Sets whether to enable the Brotli encoding./// Sets whether to enable the Zstd encoding./// Sets the compression quality./// Disables the gzip encoding./// This method is available even if the `gzip` crate feature is disabled./// Disables the Deflate encoding./// This method is available even if the `deflate` crate feature is disabled.no_br/// Disables the Brotli encoding./// This method is available even if the `br` crate feature is disabled./// Disables the Zstd encoding./// This method is available even if the `zstd` crate feature is disabled.compress_when/// Replace the current compression predicate./// See [`Compression::compress_when`] for more details.accept_encoding_configuration_workszstd_is_web_safe/// Test ensuring that zstd compression will not exceed an 8MiB window size; browsers do not/// accept responses using 16MiB+ window sizes.SizeAbove// Compression filter allows every other request to be compressedshould_compressgzip_worksx_gzip_workszstd_worksno_recompresswill_not_compress_if_filtered_outdoesnt_compress_imagesdoes_compress_svgcompress_with_qualityshould_not_compress_rangesshould_strip_accept_ranges_header_when_compressingsize_hint_identity//! Middleware that compresses response bodies.//! Example showing how to respond with the compressed contents of a file.//! use bytes::{Bytes, BytesMut};//! use http::{Request, Response, header::ACCEPT_ENCODING};//! use http_body_util::{Full, BodyExt, StreamBody, combinators::UnsyncBoxBody};//! use http_body::Frame;//! use tokio::fs::{self, File};//! use tokio_util::io::ReaderStream;//! use tower_http::{compression::CompressionLayer, BoxError};//! use futures_util::TryStreamExt;//! type BoxBody = UnsyncBoxBody<Bytes, std::io::Error>;//! async fn handle(req: Request<Full<Bytes>>) -> Result<Response<BoxBody>, Infallible> {//!     // Open the file.//!     let file = File::open("Cargo.toml").await.expect("file missing");//!     // Convert the file into a `Stream` of `Bytes`.//!     let stream = ReaderStream::new(file);//!     // Convert the stream into a stream of data `Frame`s.//!     let stream = stream.map_ok(Frame::data);//!     // Convert the `Stream` into a `Body`.//!     let body = StreamBody::new(stream);//!     // Erase the type because its very hard to name in the function signature.//!     let body = body.boxed_unsync();//!     // Create response.//!     Ok(Response::new(body))//!     // Compress responses based on the `Accept-Encoding` header.//!     .layer(CompressionLayer::new())//!     .header(ACCEPT_ENCODING, "gzip")//!     .body(Full::<Bytes>::default())?;//! assert_eq!(response.headers()["content-encoding"], "gzip");//! // Read the body//! let bytes = response//!     .into_body()//!     .collect()//!     .to_bytes();//! // The compressed body should be smaller 🤞//! let uncompressed_len = fs::read_to_string("Cargo.toml").await?.len();//! assert!(bytes.len() < uncompressed_len);// Accumulate type parameters and `where` clause.// Process a variant with `cfg`.// Process a variant without `cfg`.// Process a variant field with `cfg`.// Process a variant field without `cfg`.// Full credit to @tesaguri who posted this gist under CC0 1.0 Universal licence// https://gist.github.com/tesaguri/2a1c0790a48bbda3dd7f71c26d02a793/// Should this response be compressed or not?/// Combine two predicates into one./// The resulting predicate enables compression if both inner predicates do./// Predicate used to determine if a response should be compressed or not./// Two predicates combined into one./// Created with [`Predicate::and`]NotForContentType/// The default predicate used by [`Compression`] and [`CompressionLayer`]./// This will compress responses unless:/// - They're gRPC, which has its own protocol specific compression scheme./// - It's an image as determined by the `content-type` starting with `image/`./// - They're Server-Sent Events (SSE) as determined by the `content-type` being `text/event-stream`./// - The response is less than 32 bytes./// # Configuring the defaults/// `DefaultPredicate` doesn't support any configuration. Instead you can build your own predicate/// by combining types in this module:/// use tower_http::compression::predicate::{SizeAbove, NotForContentType, Predicate};/// // slightly large min size than the default 32/// let predicate = SizeAbove::new(256)///     // still don't compress gRPC///     .and(NotForContentType::GRPC)///     // still don't compress images///     .and(NotForContentType::IMAGES)///     // also don't compress JSON///     .and(NotForContentType::const_new("application/json"));/// [`Compression`]: super::Compression/// [`CompressionLayer`]: super::CompressionLayer/// Create a new `DefaultPredicate`./// [`Predicate`] that will only allow compression of responses above a certain size.DEFAULT_MIN_SIZE/// Create a new `SizeAbove` predicate that will only compress responses larger than/// `min_size_bytes`./// The response will be compressed if the exact size cannot be determined through either the/// `content-length` header or [`Body::size_hint`].exception/// Predicate that wont allow responses with a specific `content-type` to be compressed.GRPC/// Predicate that wont compress gRPC responses.IMAGES/// Predicate that wont compress images.SSE/// Predicate that wont compress Server-Sent Events (SSE) responses./// Create a new `NotForContentType`./// Create a new `NotForContentType` from a static string.//! Predicates for disabling compression of responses.//! Predicates are applied with [`Compression::compress_when`] or//! [`CompressionLayer::compress_when`].//! [`Compression::compress_when`]: super::Compression::compress_when//! [`CompressionLayer::compress_when`]: super::CompressionLayer::compress_when/// Creates a new `Compression` wrapping the `service`./// Returns a new [`Layer`] that wraps services with a `Compression` middleware./// Predicates are used to determine whether a response should be compressed or not./// The default predicate is [`DefaultPredicate`]. See its documentation for more/// details on which responses it wont compress./// # Changing the compression predicate/// use tower_http::compression::{///     Compression,///     predicate::{Predicate, NotForContentType, DefaultPredicate},/// use tower::util::service_fn;/// // Placeholder service_fn/// let service = service_fn(|_: ()| async {///     Ok::<_, std::io::Error>(http::Response::new(()))/// // build our custom compression predicate/// // its recommended to still include `DefaultPredicate` as part of/// // custom predicates/// let predicate = DefaultPredicate::new()///     // don't compress responses who's `content-type` starts with `application/json`///     .and(NotForContentType::new("application/json"));/// let service = Compression::new(service).compress_when(predicate);/// See [`predicate`](super::predicate) for more utilities for building compression predicates./// Responses that are already compressed (ie have a `content-encoding` header) will _never_ be/// recompressed, regardless what they predicate says.SupportedEncodingsto_header_valueset_gzipset_deflateset_brset_zstdStreamErrorIntoIoError/// A `Body` that has been converted into an `AsyncRead`./// Apply the decorator/// Get a pinned mutable reference to the original input./// This is necessary to implement `Body::poll_trailers`./// Trait for applying some decorator to an `AsyncRead`INTERNAL_BUF_CAPACITY/// Get a mutable reference to the inner inner/// Get a pinned mutable reference to the inner inner/// Consume `self`, returning the inner innerSENTINEL_ERROR_CODE/// Default quality of compression defined by the selected compression/// Precise quality based on the underlying compression algorithms'/// qualities./// The interpretation of this depends on the algorithm chosen and the/// specific implementation backing it./// Qualities are implicitly clamped to the algorithm's maximum.AsyncCompressionLevelinto_async_compression//! Types used by compression and decompression middleware.// This enum's variants are ordered from least to most preferred.to_file_extensioninto_header_valuefrom_headers// based on https://github.com/http-rs/accept-encodingpreferred_encodingQValue// Allowed q-values are numbers between 0 and 1 with at most 3 digits in the fractional part. They// are presented here as an unsigned integer between 0 and 1000.// Parse a q-value as specified in RFC 7231 section 5.3.1.encodingsSupportedEncodingsAllno_accept_encoding_headeraccept_encoding_header_single_encodingaccept_encoding_header_two_encodingsaccept_encoding_header_gzip_x_gzipaccept_encoding_header_x_gzip_deflateaccept_encoding_header_three_encodingsaccept_encoding_header_two_encodings_with_one_qvalueaccept_encoding_header_three_encodings_with_one_qvaluetwo_accept_encoding_headers_with_one_qvaluetwo_accept_encoding_headers_three_encodings_with_one_qvaluethree_accept_encoding_headers_with_one_qvalueaccept_encoding_header_two_encodings_with_two_qvaluesaccept_encoding_header_three_encodings_with_three_qvaluesaccept_encoding_header_invalid_encdoingaccept_encoding_header_with_qvalue_zeroaccept_encoding_header_with_uppercase_lettersaccept_encoding_header_with_allowed_spacesaccept_encoding_header_with_invalid_spacesaccept_encoding_header_with_invalid_quvaluesRequestPartsAllowCredentialsInnerAllowCredentials/// Holds configuration for how to set the [`Access-Control-Allow-Credentials`][mdn] header./// See [`CorsLayer::allow_credentials`] for more details./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials/// [`CorsLayer::allow_credentials`]: super::CorsLayer::allow_credentials/// Allow credentials for all requests/// Allow credentials for some requests, based on a given predicate/// The first argument to the predicate is the request origin.is_trueto_headerseparated_by_commasWILDCARDAllowHeadersInnerAllowHeaders/// Holds configuration for how to set the [`Access-Control-Allow-Headers`][mdn] header./// See [`CorsLayer::allow_headers`] for more details./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers/// [`CorsLayer::allow_headers`]: super::CorsLayer::allow_headers/// Allow any headers by sending a wildcard (`*`)/// Set multiple allowed headersmirror_request/// Allow any headers, by mirroring the preflight [`Access-Control-Request-Headers`][mdn]/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Request-Headersis_wildcardMirrorRequestAllowMethodsInnerAllowMethods/// Holds configuration for how to set the [`Access-Control-Allow-Methods`][mdn] header./// See [`CorsLayer::allow_methods`] for more details./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods/// [`CorsLayer::allow_methods`]: super::CorsLayer::allow_methods/// Allow any method by sending a wildcard (`*`)/// Set a single allowed method/// Set multiple allowed methods/// Allow any method, by mirroring the preflight [`Access-Control-Request-Method`][mdn]/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Request-MethodOriginInnerAllowOrigin/// Holds configuration for how to set the [`Access-Control-Allow-Origin`][mdn] header./// See [`CorsLayer::allow_origin`] for more details./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin/// [`CorsLayer::allow_origin`]: super::CorsLayer::allow_origin/// Allow any origin by sending a wildcard (`*`)/// Set a single allowed origin/// Set multiple allowed origins/// If the iterator contains a wildcard (`*`)./// Set the allowed origins from a predicateasync_predicate/// Set the allowed origins from an async predicate/// Allow any origin, by mirroring the request origin/// [`AllowOrigin::predicate(|_, _| true)`][Self::predicate].to_futureAllowOriginFutureAllowPrivateNetworkInnerAllowPrivateNetwork/// Holds configuration for how to set the [`Access-Control-Allow-Private-Network`][wicg] header./// See [`CorsLayer::allow_private_network`] for more details./// [wicg]: https://wicg.github.io/private-network-access//// [`CorsLayer::allow_private_network`]: super::CorsLayer::allow_private_network/// Allow requests via a more private network than the one used to access the origin/// Allow requests via private network for some requests, based on a given predicateCorsLayerREQUEST_PRIVATE_NETWORKALLOW_PRIVATE_NETWORKcors_private_network_header_is_added_correctlycors_private_network_header_is_added_correctly_with_predicateExposeHeadersInnerExposeHeaders/// Holds configuration for how to set the [`Access-Control-Expose-Headers`][mdn] header./// See [`CorsLayer::expose_headers`] for more details./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Expose-Headers/// [`CorsLayer::expose_headers`]: super::CorsLayer::expose_headers/// Expose any / all headers by sending a wildcard (`*`)/// Set multiple exposed header namesMaxAgeInnerMaxAge/// Holds configuration for how to set the [`Access-Control-Max-Age`][mdn] header./// See [`CorsLayer::max_age`][super::CorsLayer::max_age] for more details./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age/// Set a static max-age value/// Set the max-age based on the preflight request partsallow_originallow_credentialsallow_headersallow_methodsallow_private_networkexpose_headersvary/// Layer that applies the [`Cors`] middleware which adds headers for [CORS][mdn]./// See the [module docs](crate::cors) for an example./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS/// Create a new `CorsLayer`./// No headers are sent by default. Use the builder methods to customize/// the behavior./// You need to set at least an allowed origin for browsers to make/// successful cross-origin requests to your service.permissive/// A permissive configuration:/// - All request headers allowed./// - All methods allowed./// - All origins allowed./// - All headers exposed.very_permissive/// A very permissive configuration:/// - **Credentials allowed.**/// - The method received in `Access-Control-Request-Method` is sent back///   as an allowed method./// - The origin of the preflight request is sent back as an allowed origin./// - The header names received in `Access-Control-Request-Headers` are sent///   back as allowed headers./// - No headers are currently exposed, but this may change in the future./// Set the [`Access-Control-Allow-Credentials`][mdn] header./// use tower_http::cors::CorsLayer;/// let layer = CorsLayer::new().allow_credentials(true);/// Set the value of the [`Access-Control-Allow-Headers`][mdn] header./// use http::header::{AUTHORIZATION, ACCEPT};/// let layer = CorsLayer::new().allow_headers([AUTHORIZATION, ACCEPT]);/// All headers can be allowed with/// use tower_http::cors::{Any, CorsLayer};/// let layer = CorsLayer::new().allow_headers(Any);/// Note that multiple calls to this method will override any previous/// Also note that `Access-Control-Allow-Headers` is required for requests that have/// `Access-Control-Request-Headers`./// Set the value of the [`Access-Control-Max-Age`][mdn] header./// let layer = CorsLayer::new().max_age(Duration::from_secs(60) * 10);/// By default the header will not be set which disables caching and will/// require a preflight call for all requests./// Note that each browser has a maximum internal value that takes/// precedence when the Access-Control-Max-Age is greater. For more details/// see [mdn]./// If you need more flexibility, you can use supply a function which can/// dynamically decide the max-age based on the origin and other parts of/// each preflight request:/// # struct MyServerConfig { cors_max_age: Duration }/// use http::{request::Parts as RequestParts, HeaderValue};/// use tower_http::cors::{CorsLayer, MaxAge};/// let layer = CorsLayer::new().max_age(MaxAge::dynamic(///     |_origin: &HeaderValue, parts: &RequestParts| -> Duration {///         // Let's say you want to be able to reload your config at///         // runtime and have another middleware that always inserts///         // the current config into the request extensions///         let config = parts.extensions.get::<MyServerConfig>().unwrap();///         config.cors_max_age/// Set the value of the [`Access-Control-Allow-Methods`][mdn] header./// let layer = CorsLayer::new().allow_methods([Method::GET, Method::POST]);/// All methods can be allowed with/// let layer = CorsLayer::new().allow_methods(Any);/// Set the value of the [`Access-Control-Allow-Origin`][mdn] header./// use http::HeaderValue;/// let layer = CorsLayer::new().allow_origin(///     "http://example.com".parse::<HeaderValue>().unwrap(),/// Multiple origins can be allowed with/// let origins = [///     "http://example.com".parse().unwrap(),///     "http://api.example.com".parse().unwrap(),/// let layer = CorsLayer::new().allow_origin(origins);/// All origins can be allowed with/// let layer = CorsLayer::new().allow_origin(Any);/// You can also use a closure/// use tower_http::cors::{CorsLayer, AllowOrigin};/// let layer = CorsLayer::new().allow_origin(AllowOrigin::predicate(///     |origin: &HeaderValue, _request_parts: &RequestParts| {///         origin.as_bytes().ends_with(b".rust-lang.org")/// You can also use an async closure:/// # struct Client;/// # fn get_api_client() -> Client {/// #     Client/// # impl Client {/// #     async fn fetch_allowed_origins(&self) -> Vec<HeaderValue> {/// #         vec![HeaderValue::from_static("http://example.com")]/// #     async fn fetch_allowed_origins_for_path(&self, _path: String) -> Vec<HeaderValue> {/// let client = get_api_client();/// let layer = CorsLayer::new().allow_origin(AllowOrigin::async_predicate(///     |origin: HeaderValue, _request_parts: &RequestParts| async move {///         // fetch list of origins that are allowed///         let origins = client.fetch_allowed_origins().await;///         origins.contains(&origin)/// // if using &RequestParts, make sure all the values are owned/// // before passing into the future///     |origin: HeaderValue, parts: &RequestParts| {///         let path = parts.uri.path().to_owned();///             // fetch list of origins that are allowed for this path///             let origins = client.fetch_allowed_origins_for_path(path).await;///             origins.contains(&origin)/// Set the value of the [`Access-Control-Expose-Headers`][mdn] header./// use http::header::CONTENT_ENCODING;/// let layer = CorsLayer::new().expose_headers([CONTENT_ENCODING]);/// let layer = CorsLayer::new().expose_headers(Any);/// Set the value of the [`Access-Control-Allow-Private-Network`][wicg] header./// let layer = CorsLayer::new().allow_private_network(true);/// Set the value(s) of the [`Vary`][mdn] header./// In contrast to the other headers, this one has a non-empty default of/// [`preflight_request_headers()`]./// You only need to set this is you want to remove some of these defaults,/// or if you use a closure for one of the other headers and want to add a/// vary header accordingly./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Vary/// Represents a wildcard value (`*`) used with some CORS headers such as/// [`CorsLayer::allow_methods`]."Use Any as a unit struct literal instead"Cors/// Middleware which adds headers for [CORS][mdn]./// Create a new `Cors`./// See [`CorsLayer::new`] for more details./// A permissive configuration./// See [`CorsLayer::permissive`] for more details./// A very permissive configuration./// See [`CorsLayer::very_permissive`] for more details./// Returns a new [`Layer`] that wraps services with a [`Cors`] middleware./// See [`CorsLayer::max_age`] for more details.map_layerensure_usable_cors_rulespreflight_request_headers/// Returns an iterator over the three request headers that may be involved in a CORS preflight request./// This is the default set of header names returned in the `vary` header//! Middleware which adds headers for [CORS][mdn].//! use http::{Request, Response, Method, header};//! use tower::{ServiceBuilder, ServiceExt, Service};//! use tower_http::cors::{Any, CorsLayer};//! async fn handle(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {//! let cors = CorsLayer::new()//!     // allow `GET` and `POST` when accessing the resource//!     .allow_methods([Method::GET, Method::POST])//!     // allow requests from any origin//!     .allow_origin(Any);//!     .layer(cors)//!     .header(header::ORIGIN, "https://example.com")//!     response.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).unwrap(),//!     "*",//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORSvary_set_by_inner_servicetest_allow_origin_async_predicate/// Holds configuration for how to set the [`Vary`][mdn] header./// See [`CorsLayer::vary`] for more details./// [`CorsLayer::vary`]: super::CorsLayer::vary/// Set the list of header names to return as vary header valuesDecompressionBodyDecompression/// Decompresses response bodies of the underlying service./// This adds the `Accept-Encoding` header to requests and transparently decompresses response/// bodies based on the `Content-Encoding` header./// See the [module docs](crate::decompression) for more details./// Creates a new `DecompressionLayer`./// Sets whether to request the gzip encoding./// Sets whether to request the Deflate encoding./// Sets whether to request the Brotli encoding./// Sets whether to request the Zstd encoding.RequestDecompressionFutureRequestDecompressionLayerRequestDecompressiondecompress_multi_gzdecompress_multi_zstdhandle_multi_gzhandle_multi_zstdis_compatible_with_hyper//! Middleware that decompresses request and response bodies.//! #### Request//! use flate2::{write::GzEncoder, Compression};//! use http::{header, HeaderValue, Request, Response};//! use http_body_util::{Full, BodyExt};//! use std::{error::Error, io::Write};//! use tower::{Service, ServiceBuilder, service_fn, ServiceExt};//! use tower_http::{BoxError, decompression::{DecompressionBody, RequestDecompressionLayer}};//! // A request encoded with gzip coming from some HTTP client.//! encoder.write_all(b"Hello?")?;//!     .header(header::CONTENT_ENCODING, "gzip")//!     .body(Full::from(encoder.finish()?))?;//! // Our HTTP server//! let mut server = ServiceBuilder::new()//!     // Automatically decompress request bodies.//!     .layer(RequestDecompressionLayer::new())//!     .service(service_fn(handler));//! // Send the request, with the gzip encoded body, to our server.//! let _response = server.ready().await?.call(request).await?;//! // Handler receives request whose body is decoded when read//! async fn handler(//!     mut req: Request<DecompressionBody<Full<Bytes>>>,//! ) -> Result<Response<Full<Bytes>>, BoxError>{//!     let data = req.into_body().collect().await?.to_bytes();//!     assert_eq!(&data[..], b"Hello?");//!     Ok(Response::new(Full::from("Hello, World!")))//! #### Response//! use tower_http::{compression::Compression, decompression::DecompressionLayer, BoxError};//! # async fn main() -> Result<(), tower_http::BoxError> {//! # async fn handle(req: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {//! #     let body = Full::from("Hello, World!");//! #     Ok(Response::new(body))//! // Some opaque service that applies compression.//! let service = Compression::new(service_fn(handle));//! // Our HTTP client.//!     // Automatically decompress response bodies.//!     .layer(DecompressionLayer::new())//!     .service(service);//! // `DecompressionLayer` takes care of setting `Accept-Encoding`.//! let request = Request::new(Full::<Bytes>::default());//! let body = response.into_body();//! let bytes = body.collect().await?.to_bytes().to_vec();//! let body = String::from_utf8(bytes).map_err(Into::<BoxError>::into)?;//! assert_eq!(body, "Hello, World!");unsupported_encodingpass_through_unaccepted/// Decompresses request bodies and calls its underlying service./// Transparently decompresses request bodies based on the `Content-Encoding` header./// When the encoding in the `Content-Encoding` header is not accepted an `Unsupported Media Type`/// status code will be returned with the accepted encodings in the `Accept-Encoding` header./// Enabling pass-through of unaccepted encodings will not return an `Unsupported Media Type`. But/// will call the underlying service with the unmodified request if the encoding is not supported./// Creates a new `RequestDecompressionLayer`./// Sets whether to support gzip encoding./// Sets whether to support Deflate encoding./// Sets whether to support Brotli encoding./// Sets whether to support Zstd encoding./// Disables support for gzip encoding./// Disables support for Deflate encoding./// Disables support for Brotli encoding./// Disables support for Zstd encoding./// Sets whether to pass through the request even when the encoding is not supported.decompress_accepted_encodingsupport_unencoded_bodyunaccepted_content_encoding_returns_unsupported_media_typepass_through_unsupported_encoding_when_enabledassert_request_is_decompressedassert_request_is_passed_throughshould_not_be_calledrequest_gzip/// Enabling pass-through of unaccepted encodings will not return an `Unsupported Media Type` but/// Creates a new `RequestDecompression` wrapping the `service`./// Returns a new [`Layer`] that wraps services with a `RequestDecompression` middleware./// Passes through the request even when the encoding is not supported./// By default pass-through is disabled./// Creates a new `Decompression` wrapping the `service`./// Returns a new [`Layer`] that wraps services with a `Decompression` middleware./// [`Layer`] for retrying requests with a [`Service`] to follow redirection responses./// See the [module docs](self) for more details./// Create a new [`FollowRedirectLayer`] with a [`Standard`] redirection policy.with_policy/// Create a new [`FollowRedirectLayer`] with the given redirection [`Policy`]./// Middleware that retries requests with a [`Service`] to follow redirection responses./// Create a new [`FollowRedirect`] with a [`Standard`] redirection policy./// Returns a new [`Layer`] that wraps services with a `FollowRedirect` middleware./// Create a new [`FollowRedirect`] with the given redirection [`Policy`].layer_with_policy/// Returns a new [`Layer`] that wraps services with a `FollowRedirect` middleware/// with the given redirection [`Policy`].r" Gets a reference to the underlying service."r" Gets a mutable reference to the underlying service."r" Consumes `self`, returning the underlying service."r" Response future for [`FollowRedirect`]."BodyReprRequestUri/// Response [`Extensions`][http::Extensions] value that represents the effective request URI of/// a response returned by a [`FollowRedirect`] middleware./// The value differs from the original request's effective URI if the middleware has followed/// redirections.try_clone_fromresolve_uri/// Try to resolve a URI reference `relative` against a base URI `base`.follows/// A server with an endpoint `GET /{n}` which redirects to `/{n-1}` unless `n` equals zero,/// returning `n` as the response body.//! Middleware for following redirections.//! The [`FollowRedirect`] middleware retries requests with the inner [`Service`] to follow HTTP//! redirections.//! The middleware tries to clone the original [`Request`] when making a redirected request.//! However, since [`Extensions`][http::Extensions] are `!Clone`, any extensions set by outer//! middleware will be discarded. Also, the request body cannot always be cloned. When the//! original body is known to be empty by [`Body::size_hint`], the middleware uses `Default`//! implementation of the body type to create a new request body. If you know that the body can be//! cloned in some way, you can tell the middleware to clone it by configuring a [`policy`].//! use tower::{Service, ServiceBuilder, ServiceExt};//! use tower_http::follow_redirect::{FollowRedirectLayer, RequestUri};//! # async fn main() -> Result<(), std::convert::Infallible> {//! # let http_client = tower::service_fn(|req: Request<_>| async move {//! #     let dest = "https://www.rust-lang.org/";//! #     let mut res = http::Response::builder();//! #     if req.uri() != dest {//! #         res = res//! #             .status(http::StatusCode::MOVED_PERMANENTLY)//! #             .header(http::header::LOCATION, dest);//! #     Ok::<_, std::convert::Infallible>(res.body(Full::<Bytes>::default()).unwrap())//!     .layer(FollowRedirectLayer::new())//!     .service(http_client);//!     .uri("https://rust-lang.org/")//!     .body(Full::<Bytes>::default())//! let response = client.ready().await?.call(request).await?;//! // Get the final request URI.//! assert_eq!(response.extensions().get::<RequestUri>().unwrap().0, "https://www.rust-lang.org/");//! ## Customizing the `Policy`//! You can use a [`Policy`] value to customize how the middleware handles redirections.//! use tower_http::follow_redirect::{//!     policy::{self, PolicyExt},//!     FollowRedirectLayer,//!     TooManyRedirects,//!     Other(tower::BoxError),//! # async fn main() -> Result<(), MyError> {//! # let http_client =//! #     tower::service_fn(|_: Request<Full<Bytes>>| async { Ok(Response::new(Full::<Bytes>::default())) });//! let policy = policy::Limited::new(10) // Set the maximum number of redirections to 10.//!     // Return an error when the limit was reached.//!     .or::<_, (), _>(policy::redirect_fn(|_| Err(MyError::TooManyRedirects)))//!     // Do not follow cross-origin redirections, and return the redirection responses as-is.//!     .and::<_, (), _>(policy::SameOrigin::new());//!     .layer(FollowRedirectLayer::with_policy(policy))//!     .map_err(MyError::Other)//! # let _ = client.ready().await?.call(Request::default()).await?;/// A redirection [`Policy`] that combines the results of two `Policy`s./// See [`PolicyExt::and`][super::PolicyExt::and] for more details.TaintCloneBodyFn/// A redirection [`Policy`] created from a closure./// See [`clone_body_fn`] for more details.clone_body_fn/// Create a new redirection [`Policy`] from a closure `F: Fn(&B) -> Option<B>`./// [`clone_body`][Policy::clone_body] method of the returned `Policy` delegates to the wrapped/// closure and [`redirect`][Policy::redirect] method always returns [`Action::Follow`].eq_originblock_cross_originblock_anyremove_blocklistedblockedFilterCredentials/// A redirection [`Policy`] that removes credentials from requests in redirections.BLOCKLIST/// Create a new [`FilterCredentials`] that removes blocklisted request headers in cross-origin/// Configure `self` to mark cross-origin redirections as "blocked"./// Configure `self` to mark every redirection as "blocked".block_none/// Configure `self` to mark no redirections as "blocked"./// Configure `self` to remove blocklisted headers in "blocked" redirections./// The blocklist includes the following headers:/// - `Authorization`/// - `Cookie`/// - `Proxy-Authorization`/// Configure `self` to remove all headers in "blocked" redirections.remove_none/// Configure `self` to remove no headers in "blocked" redirections./// A redirection [`Policy`] that limits the number of successive redirections./// Create a new [`Limited`] with a limit of `max` redirections./// Returns the default [`Limited`] with a limit of `20` redirections.filter_credentialsredirect_fnsame_originRedirectFnSameOrigin/// Invoked when the service received a response with a redirection status code (`3xx`)./// This method returns an [`Action`] which indicates whether the service should follow/// the redirection./// Invoked right before the service makes a request, regardless of whether it is redirected/// This can for example be used to remove sensitive headers from the request/// or prepare the request in other ways./// Try to clone a request body before the service makes a redirected request./// If the request body cannot be cloned, return `None`./// This is not invoked when [`B::size_hint`][http_body::Body::size_hint] returns zero,/// in which case `B::default()` will be used to create a new request body./// The default implementation returns `None`./// Trait for the policy on handling redirection responses./// Detecting a cyclic redirection:/// use http::{Request, Uri};/// use tower_http::follow_redirect::policy::{Action, Attempt, Policy};/// pub struct DetectCycle {///     uris: HashSet<Uri>,/// impl<B, E> Policy<B, E> for DetectCycle {///     fn redirect(&mut self, attempt: &Attempt<'_>) -> Result<Action, E> {///         if self.uris.contains(attempt.location()) {///             Ok(Action::Stop)///             self.uris.insert(attempt.previous().clone());///             Ok(Action::Follow)/// Create a new `Policy` that returns [`Action::Follow`] only if `self` and `other` return/// `Action::Follow`./// [`clone_body`][Policy::clone_body] method of the returned `Policy` tries to clone the body/// with both policies./// use tower_http::follow_redirect::policy::{self, clone_body_fn, Limited, PolicyExt};/// enum MyBody {///     Bytes(Bytes),///     Full(Full<Bytes>),/// let policy = Limited::default().and::<_, _, ()>(clone_body_fn(|body| {///     if let MyBody::Bytes(buf) = body {///         Some(MyBody::Bytes(buf.clone()))/// Create a new `Policy` that returns [`Action::Follow`] if either `self` or `other` returns/// use tower_http::follow_redirect::policy::{self, Action, Limited, PolicyExt};///     TooManyRedirects,/// let policy = Limited::default().or::<_, (), _>(Err(MyError::TooManyRedirects));PolicyExt/// An extension trait for `Policy` that provides additional adapters./// A redirection [`Policy`] with a reasonable set of standard behavior./// This policy limits the number of successive redirections ([`Limited`])/// and removes credentials from requests in cross-origin redirections ([`FilterCredentials`])./// A type that holds information on a redirection attempt./// Returns the redirection response./// Returns the destination URI of the redirection./// Returns the URI of the original request./// Follow the redirection./// Do not follow the redirection, and return the redirection response as-is./// A value returned by [`Policy::redirect`] which indicates the action/// [`FollowRedirect`][super::FollowRedirect] should take for a redirection response.is_follow/// Returns `true` if the `Action` is a `Follow` value./// Returns `true` if the `Action` is a `Stop` value./// Compares the origins of two URIs as per RFC 6454 sections 4. through 5.eq_origin_works//! Tools for customizing the behavior of a [`FollowRedirect`][super::FollowRedirect] middleware./// See [`PolicyExt::or`][super::PolicyExt::or] for more details./// See [`redirect_fn`] for more details./// Create a new redirection [`Policy`] from a closure/// `F: FnMut(&Attempt<'_>) -> Result<Action, E>`./// [`redirect`][Policy::redirect] method of the returned `Policy` delegates to/// the wrapped closure./// A redirection [`Policy`] that stops cross-origin redirections./// Create a new [`SameOrigin`].// TODO: Remove this once the MSRV bumps to 1.42.0 or above.LatencyUnit/// Use seconds./// Use milliseconds./// Use microseconds./// Use nanoseconds./// The latency unit used to report latencies by middleware.//! `async fn(HttpRequest) -> Result<HttpResponse, Error>`//! tower-http is a library that provides HTTP-specific middleware and utilities built on top of//! [tower].//! All middleware uses the [http] and [http-body] crates as the HTTP abstractions. That means//! they're compatible with any library or framework that also uses those crates, such as//! [hyper], [tonic], and [warp].//! # Example server//! This example shows how to apply middleware from tower-http to a [`Service`] and then run//! that service using [hyper].//! use tower_http::{//!     add_extension::AddExtensionLayer,//!     compression::CompressionLayer,//!     propagate_header::PropagateHeaderLayer,//!     sensitive_headers::SetSensitiveRequestHeadersLayer,//!     set_header::SetResponseHeaderLayer,//!     trace::TraceLayer,//!     validate_request::ValidateRequestHeaderLayer,//! use tower::{ServiceBuilder, service_fn, BoxError};//! use http::{Request, Response, header::{HeaderName, CONTENT_TYPE, AUTHORIZATION}};//! use std::{sync::Arc, net::SocketAddr, convert::Infallible, iter::once};//! # fn content_length_from_response<B>(_: &http::Response<B>) -> Option<http::HeaderValue> { None }//! # async fn update_in_flight_requests_metric(count: usize) {}//! // Our request handler. This is where we would implement the application logic//! // for responding to HTTP requests...//! async fn handler(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, BoxError> {//!     # todo!()//!     // Construct the shared state.//!     let state = State {//!         pool: DatabaseConnectionPool::new(),//!     // Use tower's `ServiceBuilder` API to build a stack of tower middleware//!     // wrapping our request handler.//!     let service = ServiceBuilder::new()//!         // Mark the `Authorization` request header as sensitive so it doesn't show in logs//!         .layer(SetSensitiveRequestHeadersLayer::new(once(AUTHORIZATION)))//!         // High level logging of requests and responses//!         .layer(TraceLayer::new_for_http())//!         // Share an `Arc<State>` with all requests//!         .layer(AddExtensionLayer::new(Arc::new(state)))//!         // Compress responses//!         .layer(CompressionLayer::new())//!         // Propagate `X-Request-Id`s from requests to responses//!         .layer(PropagateHeaderLayer::new(HeaderName::from_static("x-request-id")))//!         // If the response has a known size set the `Content-Length` header//!         .layer(SetResponseHeaderLayer::overriding(CONTENT_TYPE, content_length_from_response))//!         // Authorize requests using a token//!         .layer(ValidateRequestHeaderLayer::bearer("passwordlol"))//!         // Accept only application/json, application/* and */* in a request's ACCEPT header//!         .layer(ValidateRequestHeaderLayer::accept("application/json"))//!         // Wrap a `Service` in our middleware stack//!         .service_fn(handler);//!     # let mut service = service;//!     # tower::Service::call(&mut service, Request::new(Full::default()));//! Keep in mind that while this example uses [hyper], tower-http supports any HTTP//! client/server implementation that uses the [http] and [http-body] crates.//! # Example client//! tower-http middleware can also be applied to HTTP clients://!     decompression::DecompressionLayer,//!     set_header::SetRequestHeaderLayer,//!     classify::StatusInRangeAsFailures,//! use tower::{ServiceBuilder, Service, ServiceExt};//! use hyper_util::{rt::TokioExecutor, client::legacy::Client};//! use http::{Request, HeaderValue, header::USER_AGENT};//! let client = Client::builder(TokioExecutor::new()).build_http();//!     let mut client = ServiceBuilder::new()//!         // Add tracing and consider server errors and client//!         // errors as failures.//!         .layer(TraceLayer::new(//!             StatusInRangeAsFailures::new(400..=599).into_make_classifier()//!         // Set a `User-Agent` header on all requests.//!         .layer(SetRequestHeaderLayer::overriding(//!             USER_AGENT,//!             HeaderValue::from_static("tower-http demo")//!         // Decompress response bodies//!         .layer(DecompressionLayer::new())//!         // Wrap a `Client` in our middleware stack.//!         // This is possible because `Client` implements//!         // `tower::Service`.//!         .service(client);//!     // Make a request//!     let request = Request::builder()//!         .uri("http://example.com")//!         .body(Full::<Bytes>::default())//!     let response = client//!         .ready()//!         .call(request)//! All middleware are disabled by default and can be enabled using [cargo features].//! For example, to enable the [`Trace`] middleware, add the "trace" feature flag in//! your `Cargo.toml`://! tower-http = { version = "0.1", features = ["trace"] }//! You can use `"full"` to enable everything://! tower-http = { version = "0.1", features = ["full"] }//! # Getting Help//! If you're new to tower its [guides] might help. In the tower-http repo we also have a [number//! of examples][examples] showing how to put everything together. You're also welcome to ask in//! the [`#tower` Discord channel][chat] or open an [issue] with your question.//! [tower]: https://crates.io/crates/tower//! [http]: https://crates.io/crates/http//! [http-body]: https://crates.io/crates/http-body//! [tonic]: https://crates.io/crates/tonic//! [warp]: https://crates.io/crates/warp//! [cargo features]: https://doc.rust-lang.org/cargo/reference/features.html//! [`AddExtension`]: crate::add_extension::AddExtension//! [`Service`]: https://docs.rs/tower/latest/tower/trait.Service.html//! [chat]: https://discord.gg/tokio//! [issue]: https://github.com/tower-rs/tower-http/issues/new//! [`Trace`]: crate::trace::Trace//! [examples]: https://github.com/tower-rs/tower-http/tree/master/examplespayload_too_largecreate_error_responseRequestBodyLimit/// Layer that applies the [`RequestBodyLimit`] middleware that intercepts requests/// with body lengths greater than the configured limit and converts them into/// See the [module docs](crate::limit) for an example./// [`RequestBodyLimit`]: super::RequestBodyLimit/// Create a new `RequestBodyLimitLayer` with the given body length limit.//! Middleware for limiting request bodies.//! This layer will also intercept requests with a `Content-Length` header//! larger than the allowable limit and return an immediate error response//! before reading any of the body.//! Note that payload length errors can be used by adversaries in an attempt//! to smuggle requests. When an incoming stream is dropped due to an//! over-sized payload, servers should close the connection or resynchronize//! by optimistically consuming some data in an attempt to reach the end of//! the current HTTP frame. If the incoming stream cannot be resynchronized,//! then the connection should be closed. If you're using [hyper] this is//! automatically handled for you.//! ## Limiting based on `Content-Length`//! If a `Content-Length` header is present and indicates a payload that is//! larger than the acceptable limit, then the underlying service will not//! be called and a `413 Payload Too Large` response will be generated.//! use http::{Request, Response, StatusCode, HeaderValue, header::CONTENT_LENGTH};//! use http_body_util::{LengthLimitError};//! use tower::{Service, ServiceExt, ServiceBuilder};//! use tower_http::{body::Limited, limit::RequestBodyLimitLayer};//! async fn handle(req: Request<Limited<Full<Bytes>>>) -> Result<Response<Full<Bytes>>, Infallible> {//!     panic!("This should not be hit")//!     // Limit incoming requests to 4096 bytes.//!     .layer(RequestBodyLimitLayer::new(4096))//! // Call the service with a header that indicates the body is too large.//!     .header(CONTENT_LENGTH, HeaderValue::from_static("5000"))//! // let response = svc.ready().await?.call(request).await?;//! let response = svc.call(request).await?;//! assert_eq!(response.status(), StatusCode::PAYLOAD_TOO_LARGE);//! ## Limiting without known `Content-Length`//! If a `Content-Length` header is not present, then the body will be read//! until the configured limit has been reached. If the payload is larger than//! the limit, the [`http_body_util::Limited`] body will return an error. This//! error can be inspected to determine if it is a [`http_body_util::LengthLimitError`]//! and return an appropriate response in such case.//! Note that no error will be generated if the body is never read. Similarly,//! if the body _would be_ to large, but is never consumed beyond the length//! limit, then no error is generated, and handling of the remaining incoming//! data stream is left to the server implementation as described above.//! # use bytes::Bytes;//! # use http::{Request, Response, StatusCode};//! # use http_body_util::LengthLimitError;//! # use tower::{Service, ServiceExt, ServiceBuilder, BoxError};//! # use tower_http::{body::Limited, limit::RequestBodyLimitLayer};//! # use http_body_util::Full;//! # use http_body_util::BodyExt;//! async fn handle(req: Request<Limited<Full<Bytes>>>) -> Result<Response<Full<Bytes>>, BoxError> {//!     let data = match req.into_body().collect().await {//!         Ok(collected) => collected.to_bytes(),//!         Err(err) => {//!             if let Some(_) = err.downcast_ref::<LengthLimitError>() {//!                 let mut resp = Response::new(Full::default());//!                 *resp.status_mut() = StatusCode::PAYLOAD_TOO_LARGE;//!                 return Ok(resp);//!                 return Err(err);//! assert_eq!(response.status(), StatusCode::OK);//! // Call the service with a body that is too large.//! let request = Request::new(Full::<Bytes>::from(Bytes::from(vec![0u8; 4097])));//! ## Limiting without `Content-Length`//! If enforcement of body size limits is desired without preemptively//! handling requests with a `Content-Length` header indicating an over-sized//! request, consider using [`MapRequestBody`] to wrap the request body with//! [`http_body_util::Limited`] and checking for [`http_body_util::LengthLimitError`]//! like in the previous example.//! [`MapRequestBody`]: crate::map_request_body/// Middleware that intercepts requests with body lengths greater than the/// configured limit and converts them into `413 Payload Too Large` responses./// Create a new `RequestBodyLimit` with the given body length limit./// Returns a new [`Layer`] that wraps services with a `RequestBodyLimit` middleware.opaque_body/// See the [module docs](crate::map_request_body) for an example./// Create a new [`MapRequestBodyLayer`]./// `F` is expected to be a function that takes a body and returns another body.MapRequestBody/// Create a new [`MapRequestBody`]./// Returns a new [`Layer`] that wraps services with a `MapRequestBodyLayer` middleware.NewReqBody//! Apply a transformation to the request body.//! use std::{pin::Pin, task::{ready, Context, Poll}};//! use tower::{ServiceBuilder, service_fn, ServiceExt, Service};//! use tower_http::map_request_body::MapRequestBodyLayer;//! // A wrapper for a `Full<Bytes>`//! struct BodyWrapper {//!     inner: Full<Bytes>,//! impl BodyWrapper {//!     fn new(inner: Full<Bytes>) -> Self {//!         Self { inner }//! impl http_body::Body for BodyWrapper {//!     # type Data = Bytes;//!     # type Error = tower::BoxError;//!     # fn poll_frame(//!     #     self: Pin<&mut Self>,//!     #     cx: &mut Context<'_>//!     # ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> { unimplemented!() }//!     # fn is_end_stream(&self) -> bool { unimplemented!() }//!     # fn size_hint(&self) -> http_body::SizeHint { unimplemented!() }//! async fn handle<B>(_: Request<B>) -> Result<Response<Full<Bytes>>, Infallible> {//!     # Ok(Response::new(Full::default()))//!     // Wrap response bodies in `BodyWrapper`//!     .layer(MapRequestBodyLayer::new(BodyWrapper::new))//! // Call the service//! svc.ready().await?.call(request).await?;/// See the [module docs](crate::map_response_body) for an example./// Create a new [`MapResponseBodyLayer`].MapResponseBody/// Create a new [`MapResponseBody`]./// Returns a new [`Layer`] that wraps services with a `MapResponseBodyLayer` middleware.NewResBody//! Apply a transformation to the response body.//! use tower_http::map_response_body::MapResponseBodyLayer;//!     .layer(MapResponseBodyLayer::new(BodyWrapper::new))//! let request = Request::new(Full::<Bytes>::from("foobar"));InFlightRequestsCounterInFlightRequestsLayer/// Layer for applying [`InFlightRequests`] which counts the number of in-flight requests./// See the [module docs](crate::metrics::in_flight_requests) for more details./// Create a new `InFlightRequestsLayer` and its associated counter./// Create a new `InFlightRequestsLayer` that will update the given counter.InFlightRequests/// Middleware that counts the number of in-flight requests./// Create a new `InFlightRequests` and its associated counter./// Create a new `InFlightRequests` that will update the given counter./// An atomic counter that keeps track of the number of in-flight requests./// This will normally combined with [`InFlightRequestsLayer`] or [`InFlightRequests`] which will/// update the counter as requests arrive./// Create a new `InFlightRequestsCounter`./// Get the current number of in-flight requests.IncrementGuardrun_emitter/// Run a future every `interval` which receives the current number of in-flight requests./// This can be used to send the current count to your metrics system./// This function will loop forever so normally it is called with [`tokio::spawn`]:/// use tower_http::metrics::in_flight_requests::InFlightRequestsCounter;/// let counter = InFlightRequestsCounter::new();/// tokio::spawn(///     counter.run_emitter(Duration::from_secs(10), |count: usize| async move {///         // Send `count` to metrics system.//! Measure the number of in-flight requests.//! In-flight requests is the number of requests a service is currently processing. The processing//! of a request starts when it is received by the service (`tower::Service::call` is called) and//! is considered complete when the response body is consumed, dropped, or an error happens.//! use tower_http::metrics::InFlightRequestsLayer;//! use std::{time::Duration, convert::Infallible};//! async fn update_in_flight_requests_metric(count: usize) {//! // Create a `Layer` with an associated counter.//! let (in_flight_requests_layer, counter) = InFlightRequestsLayer::pair();//! // Spawn a task that will receive the number of in-flight requests every 10 seconds.//! tokio::spawn(//!     counter.run_emitter(Duration::from_secs(10), |count| async move {//!         update_in_flight_requests_metric(count).await;//!     // Keep track of the number of in-flight requests. This will increment and decrement//!     // `counter` automatically.//!     .layer(in_flight_requests_layer)in_flight_requests//! Middlewares for adding metrics to services.//! Supported metrics://! - [In-flight requests][]: Measure the number of requests a service is currently processing.//! [In-flight requests]: in_flight_requestsTrim/// Normalizes paths by trimming the trailing slashes, e.g. /foo/ -> /foo/// Normalizes paths by appending trailing slash, e.g. /foo -> /foo//// Different modes of normalizing paths/// Layer that applies [`NormalizePath`] which normalizes paths./// Create a new [`NormalizePathLayer`]./// Any trailing slashes from request paths will be removed. For example, a request with `/foo/`/// will be changed to `/foo` before reaching the inner service./// Request paths without trailing slash will be appended with a trailing slash. For example, a request with `/foo`/// will be changed to `/foo/` before reaching the inner service.NormalizePath/// Middleware that normalizes paths./// Construct a new [`NormalizePath`] with trim mode./// Construct a new [`NormalizePath`] with append mode.trim_worksis_noop_if_no_trailing_slashmaintains_queryremoves_multiple_trailing_slashesremoves_multiple_trailing_slashes_even_with_queryis_noop_on_indexremoves_multiple_trailing_slashes_on_indexremoves_multiple_trailing_slashes_on_index_even_with_queryremoves_multiple_preceding_slashes_even_with_queryremoves_multiple_preceding_slashesappend_worksis_noop_if_trailing_slashappend_maintains_queryappend_only_keeps_one_slashappend_only_keeps_one_slash_even_with_queryappend_is_noop_on_indexappend_removes_multiple_trailing_slashes_on_indexappend_removes_multiple_trailing_slashes_on_index_even_with_queryappend_removes_multiple_preceding_slashes_even_with_queryappend_removes_multiple_preceding_slashes//! Middleware that normalizes paths.//! use tower_http::normalize_path::NormalizePathLayer;//! use std::{iter::once, convert::Infallible};//!     // `req.uri().path()` will not have trailing slashes//!     // trim trailing slashes from paths//!     .layer(NormalizePathLayer::trim_trailing_slash())//! // call the service//!     // `handle` will see `/foo`//!     .uri("/foo/")//!     .body(Full::default())?;//! service.ready().await?.call(request).await?;/// Layer that applies [`PropagateHeader`] which propagates headers from requests to responses./// If the header is present on the request it'll be applied to the response as well. This could/// for example be used to propagate headers such as `X-Request-Id`./// See the [module docs](crate::propagate_header) for more details./// Create a new [`PropagateHeaderLayer`].PropagateHeader/// Middleware that propagates headers from requests to responses./// Create a new [`PropagateHeader`] that propagates the given header./// Returns a new [`Layer`] that wraps services with a `PropagateHeader` middleware.//! Propagate a header from the request to the response.//! use tower_http::propagate_header::PropagateHeaderLayer;//!     // This will copy `x-request-id` headers from requests onto responses.//!     .layer(PropagateHeaderLayer::new(HeaderName::from_static("x-request-id")))//!     .header("x-request-id", "1337")//! assert_eq!(response.headers()["x-request-id"], "1337");X_REQUEST_IDmake_request_id/// Try and produce a [`RequestId`] from the request./// Trait for producing [`RequestId`]s./// Used by [`SetRequestId`]./// An identifier for a request./// Create a new `RequestId` from a [`HeaderValue`]./// Gets a reference to the underlying [`HeaderValue`]./// Consumes `self`, returning the underlying [`HeaderValue`]./// Set request id headers and extensions on requests./// This layer applies the [`SetRequestId`] middleware./// See the [module docs](self) and [`SetRequestId`] for more details./// Create a new `SetRequestIdLayer`.x_request_id/// Create a new `SetRequestIdLayer` that uses `x-request-id` as the header name.SetRequestId/// If [`MakeRequestId::make_request_id`] returns `Some(_)` and the request doesn't already have a/// header with the same name, then the header will be inserted./// Additionally [`RequestId`] will be inserted into [`Request::extensions`] so other/// services can access it./// Create a new `SetRequestId`./// Create a new `SetRequestId` that uses `x-request-id` as the header name./// Returns a new [`Layer`] that wraps services with a `SetRequestId` middleware./// Propagate request ids from requests to responses./// This layer applies the [`PropagateRequestId`] middleware./// See the [module docs](self) and [`PropagateRequestId`] for more details./// Create a new `PropagateRequestIdLayer`./// Create a new `PropagateRequestIdLayer` that uses `x-request-id` as the header name.PropagateRequestId/// If the request contains a matching header that header will be applied to responses. If a/// [`RequestId`] extension is also present it will be propagated as well./// Create a new `PropagateRequestId`./// Create a new `PropagateRequestId` that uses `x-request-id` as the header name./// Returns a new [`Layer`] that wraps services with a `PropagateRequestId` middleware.PropagateRequestIdResponseFutureMakeRequestUuid/// A [`MakeRequestId`] that generates `UUID`s.other_middleware_setting_request_idother_middleware_setting_request_id_on_response//! Set and propagate request ids.//! use tower_http::request_id::{//!     SetRequestIdLayer, PropagateRequestIdLayer, MakeRequestId, RequestId,//! use std::sync::{Arc, atomic::{AtomicU64, Ordering}};//! # let handler = tower::service_fn(|request: Request<Full<Bytes>>| async move {//! #     Ok::<_, std::convert::Infallible>(Response::new(request.into_body()))//! // A `MakeRequestId` that increments an atomic counter//! #[derive(Clone, Default)]//! struct MyMakeRequestId {//!     counter: Arc<AtomicU64>,//! impl MakeRequestId for MyMakeRequestId {//!     fn make_request_id<B>(&mut self, request: &Request<B>) -> Option<RequestId> {//!         let request_id = self.counter//!             .fetch_add(1, Ordering::SeqCst)//!             .to_string()//!             .parse()//!             .unwrap();//!         Some(RequestId::new(request_id))//! let x_request_id = HeaderName::from_static("x-request-id");//!     // set `x-request-id` header on all requests//!     .layer(SetRequestIdLayer::new(//!         x_request_id.clone(),//!         MyMakeRequestId::default(),//!     ))//!     // propagate `x-request-id` headers from request to response//!     .layer(PropagateRequestIdLayer::new(x_request_id))//!     .service(handler);//! assert_eq!(response.headers()["x-request-id"], "0");//! Additional convenience methods are available on [`ServiceBuilderExt`]://! use tower_http::ServiceBuilderExt;//! # use http::{Request, Response, header::HeaderName};//! # use tower::{Service, ServiceExt, ServiceBuilder};//! # use tower_http::request_id::{//! #     SetRequestIdLayer, PropagateRequestIdLayer, MakeRequestId, RequestId,//! # use std::sync::{Arc, atomic::{AtomicU64, Ordering}};//! # #[derive(Clone, Default)]//! # struct MyMakeRequestId {//! #     counter: Arc<AtomicU64>,//! # impl MakeRequestId for MyMakeRequestId {//! #     fn make_request_id<B>(&mut self, request: &Request<B>) -> Option<RequestId> {//! #         let request_id = self.counter//! #             .fetch_add(1, Ordering::SeqCst)//! #             .to_string()//! #             .parse()//! #             .unwrap();//! #         Some(RequestId::new(request_id))//!     .set_x_request_id(MyMakeRequestId::default())//!     .propagate_x_request_id()//! See [`SetRequestId`] and [`PropagateRequestId`] for more details.//! # Using `Trace`//! To have request ids show up correctly in logs produced by [`Trace`] you must apply the layers//! in this order://!     ServiceBuilderExt,//!     trace::{TraceLayer, DefaultMakeSpan, DefaultOnResponse},//!     // make sure to set request ids before the request reaches `TraceLayer`//!     // log requests and responses//!     .layer(//!         TraceLayer::new_for_http()//!             .make_span_with(DefaultMakeSpan::new().include_headers(true))//!             .on_response(DefaultOnResponse::new().include_headers(true))//!     // propagate the header to the response before the response reaches `TraceLayer`//! # Doesn't override existing headers//! [`SetRequestId`] and [`PropagateRequestId`] wont override request ids if its already present on//! requests or responses. Among other things, this allows other middleware to conditionally set//! request ids and use the middleware in this module as a fallback.//! [`ServiceBuilderExt`]: crate::ServiceBuilderExt//! [`Uuid`]: https://crates.io/crates/uuid/// Produces [`SetSensitiveHeaders`] services./// See the [module docs](crate::sensitive_headers) for more details./// Create a new [`SetSensitiveHeadersLayer`]./// Create a new [`SetSensitiveHeadersLayer`] from a shared slice of headers.SetSensitiveHeadersSetSensitiveResponseHeadersSetSensitiveRequestHeaders/// Mark request headers as [sensitive]./// Produces [`SetSensitiveRequestHeaders`] services./// Create a new [`SetSensitiveRequestHeadersLayer`]./// Create a new [`SetSensitiveRequestHeadersLayer`] from a shared slice of headers./// Create a new [`SetSensitiveRequestHeaders`]./// Create a new [`SetSensitiveRequestHeaders`] from a shared slice of headers./// Returns a new [`Layer`] that wraps services with a `SetSensitiveRequestHeaders` middleware./// Mark response headers as [sensitive]./// Produces [`SetSensitiveResponseHeaders`] services./// Create a new [`SetSensitiveResponseHeadersLayer`]./// Create a new [`SetSensitiveResponseHeadersLayer`] from a shared slice of headers./// Create a new [`SetSensitiveResponseHeaders`]./// Create a new [`SetSensitiveResponseHeaders`] from a shared slice of headers./// Returns a new [`Layer`] that wraps services with a `SetSensitiveResponseHeaders` middleware.SetSensitiveResponseHeadersResponseFuturemultiple_value_header//! Middlewares that mark headers as [sensitive].//! [sensitive]: https://docs.rs/http/latest/http/header/struct.HeaderValue.html#method.set_sensitive//! use tower_http::sensitive_headers::SetSensitiveHeadersLayer;//! use http::{Request, Response, header::AUTHORIZATION};//!     // Mark the `Authorization` header as sensitive so it doesn't show in logs//!     // `SetSensitiveHeadersLayer` will mark the header as sensitive on both the//!     // request and response.//!     // The middleware is constructed from an iterator of headers to easily mark//!     // multiple headers at once.//!     .layer(SetSensitiveHeadersLayer::new(once(AUTHORIZATION)))//!     .service(service_fn(handle));//! Its important to think about the order in which requests and responses arrive at your//! middleware. For example to hide headers both on requests and responses when using//! [`TraceLayer`] you have to apply [`SetSensitiveRequestHeadersLayer`] before [`TraceLayer`]//! and [`SetSensitiveResponseHeadersLayer`] afterwards.//!     sensitive_headers::{//!         SetSensitiveRequestHeadersLayer,//!         SetSensitiveResponseHeadersLayer,//! use http::header;//! # use http::{Request, Response};//! let headers: Arc<[_]> = Arc::new([//!     header::AUTHORIZATION,//!     header::PROXY_AUTHORIZATION,//!     header::COOKIE,//!     header::SET_COOKIE,//! ]);//!     .layer(SetSensitiveRequestHeadersLayer::from_shared(Arc::clone(&headers)))//!     .layer(TraceLayer::new_for_http())//!     .layer(SetSensitiveResponseHeadersLayer::from_shared(headers))//! [`TraceLayer`]: crate::trace::TraceLayerSetRequestHeaderSetResponseHeader/// Extension trait that adds methods to any [`Service`] for adding middleware fromtest_type_inferenceserve_dirserve_fileServeFileSystemResponseFutureDefaultServeDirFallbackServeFileSystemResponseBodyServeDir// The response body and future are used for both ServeDir and ServeFileServeFile/// Create a new [`AsyncReadBody`] wrapping the given reader,/// with a specific read buffer capacitywith_capacity_limited//! File system related services.open_fileFileOpenedFileRequestExtentOpenFileOutputopen_file_futureinvalid_pathmethod_not_allowednot_foundFResBodycall_fallbackResponseFutureInnerbuild_responsebody_from_bytesempty_body/// Check if the supplied time means the resource has been modified.from_header_value/// convert a header value into a IfModifiedSince, invalid values are silentely ignoredprecondition_passes/// Check if the supplied time passes the precondtion./// Convert a header value into a IfModifiedSince, invalid values are silentely ignoredSetStatus// default capacity 64KiBbuf_chunk_sizeprecompressed_variantsPrecompressedVariantsServeVariant// This is used to specialise implementation for// single filescall_fallback_on_method_not_allowed/// Service that serves files from a given directory and all its sub directories./// The `Content-Type` will be guessed from the file extension./// An empty response with status `404 Not Found` will be returned if:/// - The file doesn't exist/// - Any segment of the path contains `..`/// - Any segment of the path contains a backslash/// - On unix, any segment of the path referenced as directory is actually an///   existing file (`/file.html/something`)/// - We don't have necessary permissions to read the file/// use tower_http::services::ServeDir;/// // This will serve files in the "assets" directory and/// // its subdirectories/// let service = ServeDir::new("assets");/// Create a new [`ServeDir`].new_single_fileappend_index_html_on_directories/// If the requested path is a directory append `index.html`./// This is useful for static sites.with_buf_chunk_size/// Set a specific read buffer chunk size./// The default capacity is 64kb.precompressed_gzip/// Informs the service that it should also look for a precompressed gzip/// version of _any_ file in the directory./// Assuming the `dir` directory is being served and `dir/foo.txt` is requested,/// a client with an `Accept-Encoding` header that allows the gzip encoding/// will receive the file `dir/foo.txt.gz` instead of `dir/foo.txt`./// If the precompressed file is not available, or the client doesn't support it,/// the uncompressed version will be served instead./// Both the precompressed version and the uncompressed version are expected/// to be present in the directory. Different precompressed variants can be combined.precompressed_br/// Informs the service that it should also look for a precompressed brotli/// a client with an `Accept-Encoding` header that allows the brotli encoding/// will receive the file `dir/foo.txt.br` instead of `dir/foo.txt`.precompressed_deflate/// Informs the service that it should also look for a precompressed deflate/// a client with an `Accept-Encoding` header that allows the deflate encoding/// will receive the file `dir/foo.txt.zz` instead of `dir/foo.txt`.precompressed_zstd/// Informs the service that it should also look for a precompressed zstd/// a client with an `Accept-Encoding` header that allows the zstd encoding/// will receive the file `dir/foo.txt.zst` instead of `dir/foo.txt`./// Set the fallback service./// This service will be called if there is no file at the path of the request./// The status code returned by the fallback will not be altered. Use/// [`ServeDir::not_found_service`] to set a fallback and always respond with `404 Not Found`./// This can be used to respond with a different file:/// use tower_http::services::{ServeDir, ServeFile};/// let service = ServeDir::new("assets")///     // respond with `not_found.html` for missing files///     .fallback(ServeFile::new("assets/not_found.html"));not_found_service/// Set the fallback service and override the fallback's status code to `404 Not Found`.///     // respond with `404 Not Found` and the contents of `not_found.html` for missing files///     .not_found_service(ServeFile::new("assets/not_found.html"));/// Setups like this are often found in single page applications./// Customize whether or not to call the fallback for requests that aren't `GET` or `HEAD`./// Defaults to not calling the fallback and instead returning `405 Method Not Allowed`./// Call the service and get a future that contains any `std::io::Error` that might have/// happened./// By default `<ServeDir as Service<_>>::call` will handle IO errors and convert them into/// responses. It does that by converting [`std::io::ErrorKind::NotFound`] and/// [`std::io::ErrorKind::PermissionDenied`] to `404 Not Found` and any other error to `500/// Internal Server Error`. The error will also be logged with `tracing`./// If you want to manually control how the error response is generated you can make a new/// service that wraps a `ServeDir` and calls `try_call` instead of `call`./// use std::{io, convert::Infallible};/// use http_body::Body as _;/// use http_body_util::{Full, BodyExt, combinators::UnsyncBoxBody};/// use tower::{service_fn, ServiceExt, BoxError};/// async fn serve_dir(///     request: Request<Full<Bytes>>/// ) -> Result<Response<UnsyncBoxBody<Bytes, BoxError>>, Infallible> {///     let mut service = ServeDir::new("assets");///     // You only need to worry about backpressure, and thus call `ServiceExt::ready`, if///     // your adding a fallback to `ServeDir` that cares about backpressure.///     // Its shown here for demonstration but you can do `service.try_call(request)`///     // otherwise///     let ready_service = match ServiceExt::<Request<Full<Bytes>>>::ready(&mut service).await {///         Ok(ready_service) => ready_service,///         Err(infallible) => match infallible {},///     match ready_service.try_call(request).await {///         Ok(response) => {///             Ok(response.map(|body| body.map_err(Into::into).boxed_unsync()))///             let body = Full::from("Something went wrong...")///                 .map_err(Into::into)///                 .boxed_unsync();///             let response = Response::builder()///                 .status(StatusCode::INTERNAL_SERVER_ERROR)///                 .body(body)///             Ok(response)InfallibleResponseFutureSingleFile// Allow the ServeDir service to be used in the ServeFile service// with almost no overheadbuild_and_validate_path/// The default fallback service used with [`ServeDir`].http_range_headerRangeUnsatisfiableErrorPreconditionFailedNotModifiedInvalidRedirectUrimime_header_valuemaybe_encodingmaybe_rangelast_modifiedcheck_modified_headers// Returns the preferred_encoding encoding and modifies the path extension// to the corresponding file extension for the encoding.open_file_with_fallback// Attempts to open the file with any of the possible negotiated_encodings in the// preferred order. If none of the negotiated_encodings have a corresponding precompressed// file the uncompressed file is used as a fallback.file_metadata_with_fallback// Attempts to get the file metadata with any of the possible negotiated_encodings in themaybe_redirect_or_append_pathtry_parse_rangeappend_slash_on_pathpreferred_encoding_with_extensionpreferred_encoding_without_extensionbasic_with_indexhead_requestprecompresed_head_requestwith_custom_chunk_sizeunsupported_precompression_alogrithm_fallbacks_to_uncompressedonly_precompressed_variant_existingmissing_precompressed_variant_fallbacks_to_uncompressedmissing_precompressed_variant_fallbacks_to_uncompressed_for_head_requestprecompressed_without_extensionmissing_precompressed_without_extension_fallbacks_to_uncompressedaccess_to_sub_dirsnot_found_when_not_a_directorynot_found_precompressedfallbacks_to_different_precompressed_variant_if_not_found_for_head_requestfallbacks_to_different_precompressed_variant_if_not_foundredirect_to_trailing_slash_on_dirempty_directory_without_indexempty_directory_without_index_no_information_leakbody_into_textaccess_cjk_percent_encoded_uri_pathaccess_space_percent_encoded_uri_pathread_partial_emptyread_partial_in_boundsread_partial_accepts_out_of_bounds_rangeread_partial_errs_on_garbage_headerread_partial_errs_on_bad_rangeaccept_encoding_identitywith_fallback_svcwith_fallback_serve_filecalling_fallback_on_not_allowedwith_fallback_svc_and_not_append_index_html_on_directoriescalls_fallback_on_invalid_paths// https://github.com/tower-rs/tower-http/issues/308/// Service that serves a file./// Create a new [`ServeFile`].new_with_mime/// Create a new [`ServeFile`] with a specific mime type./// Will panic if the mime type isn't a valid [header value]./// [header value]: https://docs.rs/http/latest/http/header/struct.HeaderValue.html/// version of the file./// If the client has an `Accept-Encoding` header that allows the gzip encoding,/// the file `foo.txt.gz` will be served instead of `foo.txt`./// to be present in the same directory. Different precompressed/// variants can be combined./// If the client has an `Accept-Encoding` header that allows the brotli encoding,/// the file `foo.txt.br` will be served instead of `foo.txt`./// If the client has an `Accept-Encoding` header that allows the deflate encoding,/// the file `foo.txt.zz` will be served instead of `foo.txt`./// If the client has an `Accept-Encoding` header that allows the zstd encoding,/// the file `foo.txt.zst` will be served instead of `foo.txt`./// See [`ServeDir::try_call`] for more details.// Note that this is just a special case of ServeDirbasic_with_mimemissing_precompressed_variant_fallbacks_to_uncompressed_head_requestmulti_precompressedfallbacks_to_different_precompressed_variant_if_not_found_head_requestreturns_404_if_file_doesnt_existreturns_404_if_file_doesnt_exist_when_precompression_is_used//! Service that serves a file.//! [`Service`]s that return responses without wrapping other [`Service`]s.//! These kinds of services are also referred to as "leaf services" since they sit at the leaves of//! a [tree] of services.//! [tree]: https://en.wikipedia.org/wiki/Tree_(data_structure)// Covariant over ResBody, no dropping of ResBody/// Service that redirects all requests./// See the [module docs](crate::services::redirect) for more details.temporary/// Create a new [`Redirect`] that uses a [`307 Temporary Redirect`][mdn] status code./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/307permanent/// Create a new [`Redirect`] that uses a [`308 Permanent Redirect`][mdn] status code./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/308with_status_code/// Create a new [`Redirect`] that uses the given status code./// - If `status_code` isn't a [redirection status code][mdn] (3xx)./// - If `uri` isn't a valid [`HeaderValue`]./// [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages/// Response future of [`Redirect`].//! Service that redirects all requests.//! Imagine that we run `example.com` and want to redirect all requests using `HTTP` to `HTTPS`.//! That can be done like so://! use http::{Request, Uri, StatusCode};//! use tower_http::services::Redirect;//! let uri: Uri = "https://example.com/".parse().unwrap();//! let mut service: Redirect<Full<Bytes>> = Redirect::permanent(uri);//!     .uri("http://example.com")//! let response = service.oneshot(request).await?;//! assert_eq!(response.status(), StatusCode::PERMANENT_REDIRECT);//! assert_eq!(response.headers()["location"], "https://example.com/");make_header_value/// Try to create a header value from the request or response.MakeHeaderValue/// Trait for producing header values./// Used by [`SetRequestHeader`] and [`SetResponseHeader`]./// This trait is implemented for closures with the correct type signature. Typically users will/// not have to implement this trait for their own types./// It is also implemented directly for [`HeaderValue`]. When a fixed header value should be added/// to all responses, it can be supplied directly to the middleware.InsertHeaderModeIfNotPresent//! Middleware for setting headers on requests and responses.//! See [request] and [response] for more details./// Layer that applies [`SetRequestHeader`] which adds a request header./// See [`SetRequestHeader`] for more details.overriding/// Create a new [`SetRequestHeaderLayer`].appending/// The new header is always added, preserving any existing values. If previous values exist,/// the header will have multiple values.if_not_present/// If a previous value exists for the header, the new value is not inserted./// Middleware that sets a header on the request./// Create a new [`SetRequestHeader`].//! Set a header on the request.//! The header value to be set may be provided as a fixed value when the//! middleware is constructed, or determined dynamically based on the request//! by a closure. See the [`MakeHeaderValue`] trait for details.//! Setting a header from a fixed value provided when the middleware is constructed://! use http::{Request, Response, header::{self, HeaderValue}};//! use tower_http::set_header::SetRequestHeaderLayer;//! # let http_client = tower::service_fn(|_: Request<Full<Bytes>>| async move {//! #     Ok::<_, std::convert::Infallible>(Response::new(Full::<Bytes>::default()))//!         // Layer that sets `User-Agent: my very cool app` on requests.//!         // `if_not_present` will only insert the header if it does not already//!         // have a value.//!         SetRequestHeaderLayer::if_not_present(//!             header::USER_AGENT,//!             HeaderValue::from_static("my very cool app"),//! Setting a header based on a value determined dynamically from the request://! fn date_header_value() -> HeaderValue {//!     # HeaderValue::from_static("now")//!         // Layer that sets `Date` to the current date and time.//!         // `overriding` will insert the header and override any previous values it//!         // may have.//!         SetRequestHeaderLayer::overriding(//!             header::DATE,//!             |request: &Request<Full<Bytes>>| {//!                 Some(date_header_value())/// Layer that applies [`SetResponseHeader`] which adds a response header./// See [`SetResponseHeader`] for more details./// Create a new [`SetResponseHeaderLayer`]./// Middleware that sets a header on the response./// Create a new [`SetResponseHeader`].test_override_modetest_append_modetest_skip_if_present_modetest_skip_if_present_mode_when_not_present//! Set a header on the response.//! middleware is constructed, or determined dynamically based on the response//! use tower_http::set_header::SetResponseHeaderLayer;//! # let render_html = tower::service_fn(|request: Request<Full<Bytes>>| async move {//!         // Layer that sets `Content-Type: text/html` on responses.//!         SetResponseHeaderLayer::if_not_present(//!             header::CONTENT_TYPE,//!             HeaderValue::from_static("text/html"),//!     .service(render_html);//! assert_eq!(response.headers()["content-type"], "text/html");//! Setting a header based on a value determined dynamically from the response://! use http_body::Body as _; // for `Body::size_hint`//! #     Ok::<_, std::convert::Infallible>(Response::new(Full::from("1234567890")))//!         // Layer that sets `Content-Length` if the body has a known size.//!         // Bodies with streaming responses wont have a known size.//!         SetResponseHeaderLayer::overriding(//!             header::CONTENT_LENGTH,//!             |response: &Response<Full<Bytes>>| {//!                 if let Some(size) = response.body().size_hint().exact() {//!                     // If the response body has a known size, returning `Some` will//!                     // set the `Content-Length` header to that value.//!                     Some(HeaderValue::from_str(&size.to_string()).unwrap())//!                     // If the response body doesn't have a known size, return `None`//!                     // to skip setting the header on this response.//!                     None//! assert_eq!(response.headers()["content-length"], "10");SetStatusLayer/// Layer that applies [`SetStatus`] which overrides the status codes./// Create a new [`SetStatusLayer`]./// The response status code will be `status` regardless of what the inner service returns./// Middleware to override status codes./// Create a new [`SetStatus`]./// Returns a new [`Layer`] that wraps services with a `SetStatus` middleware.//! Middleware to override status codes.//! use tower_http::set_status::SetStatusLayer;//!     // change the status to `404 Not Found` regardless what the inner service returns//!     .layer(SetStatusLayer::new(StatusCode::NOT_FOUND))//! let request = Request::builder().body(Full::default())?;//! let response = service.ready().await?.call(request).await?;//! assert_eq!(response.status(), StatusCode::NOT_FOUND);body_from_impl/// Creates a new [`TimeoutBody`].TimeoutBodyTimeoutError/// Error for [`TimeoutBody`].MockErrorMockBodytest_body_available_within_timeouttest_body_unavailable_within_timeout_errorRequestBodyTimeoutRequestBodyTimeoutLayerResponseBodyTimeoutResponseBodyTimeoutLayer//! If the request does not complete within the specified timeout it will be aborted and a `408//! Request Timeout` response will be sent.//! # Differences from `tower::timeout`//! tower's [`Timeout`](tower::timeout::Timeout) middleware uses an error to signal timeout, i.e.//! it changes the error type to [`BoxError`](tower::BoxError). For HTTP services that is rarely//! what you want as returning errors will terminate the connection without sending a response.//! This middleware won't change the error type and instead return a `408 Request Timeout`//! response. That means if your service's error type is [`Infallible`] it will still be//! [`Infallible`] after applying this middleware.//! use std::{convert::Infallible, time::Duration};//! use tower::ServiceBuilder;//! use tower_http::timeout::TimeoutLayer;//! async fn handle(_: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {//!     // Timeout requests after 30 seconds//!     .layer(TimeoutLayer::new(Duration::from_secs(30)))//! [`Infallible`]: std::convert::Infallible/// Layer that applies the [`Timeout`] middleware which apply a timeout to requests./// See the [module docs](super) for an example./// Creates a new [`TimeoutLayer`]./// Middleware which apply a timeout to requests./// If the request does not complete within the specified timeout it will be aborted and a `408/// Request Timeout` response will be sent./// Creates a new [`Timeout`]./// Returns a new [`Layer`] that wraps services with a `Timeout` middleware./// Applies a [`TimeoutBody`] to the request body./// Creates a new [`RequestBodyTimeoutLayer`]./// Creates a new [`RequestBodyTimeout`]./// Returns a new [`Layer`] that wraps services with a [`RequestBodyTimeoutLayer`] middleware./// Applies a [`TimeoutBody`] to the response body./// Creates a new [`ResponseBodyTimeoutLayer`].ResponseBodyTimeoutFuture/// Creates a new [`ResponseBodyTimeout`]./// Returns a new [`Layer`] that wraps services with a [`ResponseBodyTimeoutLayer`] middleware.DefaultOnBodyChunkDefaultOnEosDefaultOnFailureOnBodyChunkOnEosOnFailureOnBodyChunkTOnEosTOnFailureTDefaultOnResponseOnResponseOnResponseTDefaultMakeSpanDefaultOnRequestmake_spanMakeSpanOnRequeston_responseon_body_chunkon_eoson_failure/// [`Layer`] that adds high level [tracing] to a [`Service`]./// See the [module docs](crate::trace) for more details./// [tracing]: https://crates.io/crates/tracing/// Create a new [`TraceLayer`] using the given [`MakeClassifier`].NewOnRequest/// Customize what to do when a request is received./// `NewOnRequest` is expected to implement [`OnRequest`]./// [`OnRequest`]: super::OnRequestNewOnResponse/// Customize what to do when a response has been produced./// `NewOnResponse` is expected to implement [`OnResponse`]./// [`OnResponse`]: super::OnResponseNewOnBodyChunk/// Customize what to do when a body chunk has been sent./// `NewOnBodyChunk` is expected to implement [`OnBodyChunk`]./// [`OnBodyChunk`]: super::OnBodyChunkNewOnEos/// Customize what to do when a streaming response has closed./// `NewOnEos` is expected to implement [`OnEos`]./// [`OnEos`]: super::OnEosNewOnFailure/// Customize what to do when a response has been classified as a failure./// `NewOnFailure` is expected to implement [`OnFailure`]./// [`OnFailure`]: super::OnFailureNewMakeSpanmake_span_with/// Customize how to make [`Span`]s that all request handling will be wrapped in./// `NewMakeSpan` is expected to implement [`MakeSpan`]./// [`MakeSpan`]: super::MakeSpan/// [`Span`]: tracing::Spannew_for_http/// Create a new [`TraceLayer`] using [`ServerErrorsAsFailures`] which supports classifying/// regular HTTP responses based on the status code.new_for_grpc/// Create a new [`TraceLayer`] using [`GrpcErrorsAsFailures`] which supports classifying/// gRPC responses and streams based on the `grpc-status` header.DEFAULT_MESSAGE_LEVEL/// Make a span from a request./// Trait used to generate [`Span`]s from requests. [`Trace`] wraps all request handling in this/// span./// [`Trace`]: super::Traceinclude_headers/// The default way [`Span`]s will be created for [`Trace`]./// Create a new `DefaultMakeSpan`./// Set the [`Level`] used for the [tracing span]./// Defaults to [`Level::DEBUG`]./// [tracing span]: https://docs.rs/tracing/latest/tracing/#spans/// Include request headers on the [`Span`]./// By default headers are not included./// MakeClassifier for HTTP requests./// MakeClassifier for gRPC requests.event_dynamic_lvlDEFAULT_ERROR_LEVELunary_requeststreaming_responsestreaming_body//! Middleware that adds high level [tracing] to a [`Service`].//! Adding tracing to your service can be as simple as://! use tower_http::trace::TraceLayer;//! // Setup tracing//! tracing_subscriber::fmt::init();//! let request = Request::new(Full::from("foo"));//! If you run this application with `RUST_LOG=tower_http=trace cargo run` you should see logs like://! Mar 05 20:50:28.523 DEBUG request{method=GET path="/foo"}: tower_http::trace::on_request: started processing request//! Mar 05 20:50:28.524 DEBUG request{method=GET path="/foo"}: tower_http::trace::on_response: finished processing request latency=1 ms status=200//! # Customization//! [`Trace`] comes with good defaults but also supports customizing many aspects of the output.//! The default behaviour supports some customization://! use http::{Request, Response, HeaderMap, StatusCode};//! use tracing::Level;//!     LatencyUnit,//!     trace::{TraceLayer, DefaultMakeSpan, DefaultOnRequest, DefaultOnResponse},//! # use tower::{ServiceExt, Service};//! # async fn handle(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {//! #     Ok(Response::new(Full::from("foo")))//! # tracing_subscriber::fmt::init();//!             .make_span_with(//!                 DefaultMakeSpan::new().include_headers(true)//!             )//!             .on_request(//!                 DefaultOnRequest::new().level(Level::INFO)//!             .on_response(//!                 DefaultOnResponse::new()//!                     .level(Level::INFO)//!                     .latency_unit(LatencyUnit::Micros)//!             // on so on for `on_eos`, `on_body_chunk`, and `on_failure`//! # let mut service = service;//! # let response = service//! #     .ready()//! #     .await?//! #     .call(Request::new(Full::from("foo")))//! #     .await?;//! However for maximum control you can provide callbacks://! use tower_http::{classify::ServerErrorsFailureClass, trace::TraceLayer};//! use tracing::Span;//!             .make_span_with(|request: &Request<Full<Bytes>>| {//!                 tracing::debug_span!("http-request")//!             .on_request(|request: &Request<Full<Bytes>>, _span: &Span| {//!                 tracing::debug!("started {} {}", request.method(), request.uri().path())//!             .on_response(|response: &Response<Full<Bytes>>, latency: Duration, _span: &Span| {//!                 tracing::debug!("response generated in {:?}", latency)//!             .on_body_chunk(|chunk: &Bytes, latency: Duration, _span: &Span| {//!                 tracing::debug!("sending {} bytes", chunk.len())//!             .on_eos(|trailers: Option<&HeaderMap>, stream_duration: Duration, _span: &Span| {//!                 tracing::debug!("stream closed after {:?}", stream_duration)//!             .on_failure(|error: ServerErrorsFailureClass, latency: Duration, _span: &Span| {//!                 tracing::debug!("something went wrong")//! ## Disabling something//! Setting the behaviour to `()` will be disable that particular step://! # use http::{Response, Request};//!         // This configuration will only emit events on failures//!             .on_request(())//!             .on_response(())//!             .on_body_chunk(())//!             .on_eos(())//! # When the callbacks are called//! ### `on_request`//! The `on_request` callback is called when the request arrives at the//! middleware in [`Service::call`] just prior to passing the request to the//! inner service.//! ### `on_response`//! The `on_response` callback is called when the inner service's response//! future completes with `Ok(response)` regardless if the response is//! classified as a success or a failure.//! For example if you're using [`ServerErrorsAsFailures`] as your classifier//! and the inner service responds with `500 Internal Server Error` then the//! `on_response` callback is still called. `on_failure` would _also_ be called//! in this case since the response was classified as a failure.//! ### `on_body_chunk`//! The `on_body_chunk` callback is called when the response body produces a new//! chunk, that is when [`Body::poll_frame`] returns a data frame.//! `on_body_chunk` is called even if the chunk is empty.//! ### `on_eos`//! The `on_eos` callback is called when a streaming response body ends, that is//! when [`Body::poll_frame`] returns a trailers frame.//! `on_eos` is called even if the trailers produced are `None`.//! ### `on_failure`//! The `on_failure` callback is called when://! - The inner [`Service`]'s response future resolves to an error.//! - A response is classified as a failure.//! - [`Body::poll_frame`] returns an error.//! - An end-of-stream is classified as a failure.//! # Recording fields on the span//! All callbacks receive a reference to the [tracing] [`Span`], corresponding to this request,//! produced by the closure passed to [`TraceLayer::make_span_with`]. It can be used to [record//! field values][record] that weren't known when the span was created.//!                 tracing::debug_span!(//!                     "http-request",//!                     status_code = tracing::field::Empty,//!                 )//!             .on_response(|response: &Response<Full<Bytes>>, _latency: Duration, span: &Span| {//!                 span.record("status_code", &tracing::field::display(response.status()));//!                 tracing::debug!("response generated")//! # Providing classifiers//! Tracing requires determining if a response is a success or failure. [`MakeClassifier`] is used//! to create a classifier for the incoming request. See the docs for [`MakeClassifier`] and//! [`ClassifyResponse`] for more details on classification.//! A [`MakeClassifier`] can be provided when creating a [`TraceLayer`]://!     classify::{//!         MakeClassifier, ClassifyResponse, ClassifiedResponse, NeverClassifyEos,//!         SharedClassifier,//! // Our `MakeClassifier` that always crates `MyClassifier` classifiers.//! #[derive(Copy, Clone)]//! struct MyMakeClassify;//! impl MakeClassifier for MyMakeClassify {//!     type Classifier = MyClassifier;//!     type FailureClass = &'static str;//!     type ClassifyEos = NeverClassifyEos<&'static str>;//!     fn make_classifier<B>(&self, req: &Request<B>) -> Self::Classifier {//!         MyClassifier//! // A classifier that classifies failures as `"something went wrong..."`.//! struct MyClassifier;//! impl ClassifyResponse for MyClassifier {//!     fn classify_response<B>(//!         self,//!         res: &Response<B>//!     ) -> ClassifiedResponse<Self::FailureClass, Self::ClassifyEos> {//!         // Classify based on the status code.//!         if res.status().is_server_error() {//!             ClassifiedResponse::Ready(Err("something went wrong..."))//!             ClassifiedResponse::Ready(Ok(()))//!     fn classify_error<E>(self, error: &E) -> Self::FailureClass//!         E: std::fmt::Display + 'static,//!         "something went wrong..."//!     // Create a trace layer that uses our classifier.//!     .layer(TraceLayer::new(MyMakeClassify))//! // Since `MyClassifier` is `Clone` we can also use `SharedClassifier`//! // to avoid having to define a separate `MakeClassifier`.//!     .layer(TraceLayer::new(SharedClassifier::new(MyClassifier)))//! [`TraceLayer`] comes with convenience methods for using common classifiers://! - [`TraceLayer::new_for_http`] classifies based on the status code. It doesn't consider//!   streaming responses.//! - [`TraceLayer::new_for_grpc`] classifies based on the gRPC protocol and supports streaming//!   responses.//! [tracing]: https://crates.io/crates/tracing//! [`Service::call`]: tower_service::Service::call//! [`MakeClassifier`]: crate::classify::MakeClassifier//! [`ClassifyResponse`]: crate::classify::ClassifyResponse//! [record]: https://docs.rs/tracing/latest/tracing/span/struct.Span.html#method.record//! [`TraceLayer::make_span_with`]: crate::trace::TraceLayer::make_span_with//! [`Span`]: tracing::Span//! [`ServerErrorsAsFailures`]: crate::classify::ServerErrorsAsFailures//! [`Body::poll_frame`]: http_body::Body::poll_frame/// Do the thing./// `latency` is the duration since the response was sent or since the last body chunk as sent./// `span` is the `tracing` [`Span`], corresponding to this request, produced by the closure/// passed to [`TraceLayer::make_span_with`]. It can be used to [record field values][record]/// that weren't known when the span was created./// [`Span`]: https://docs.rs/tracing/latest/tracing/span/index.html/// [record]: https://docs.rs/tracing/latest/tracing/span/struct.Span.html#method.record/// If you're using [hyper] as your server `B` will most likely be [`Bytes`]./// [hyper]: https://hyper.rs/// [`Bytes`]: https://docs.rs/bytes/latest/bytes/struct.Bytes.html/// [`TraceLayer::make_span_with`]: crate::trace::TraceLayer::make_span_with/// Trait used to tell [`Trace`] what to do when a body chunk has been sent./// See the [module docs](../trace/index.html#on_body_chunk) for details on exactly when the/// `on_body_chunk` callback is called./// The default [`OnBodyChunk`] implementation used by [`Trace`]./// Simply does nothing./// Create a new `DefaultOnBodyChunk`./// `stream_duration` is the duration since the response was sent./// Trait used to tell [`Trace`] what to do when a stream closes./// See the [module docs](../trace/index.html#on_eos) for details on exactly when the `on_eos`/// callback is called.latency_unit/// The default [`OnEos`] implementation used by [`Trace`]./// Create a new [`DefaultOnEos`]./// Set the [`Level`] used for [tracing events]./// [tracing events]: https://docs.rs/tracing/latest/tracing/#events/// [`Level::DEBUG`]: https://docs.rs/tracing/latest/tracing/struct.Level.html#associatedconstant.DEBUG/// Set the [`LatencyUnit`] latencies will be reported in./// Defaults to [`LatencyUnit::Millis`]./// `latency` is the duration since the request was received./// Trait used to tell [`Trace`] what to do when a request fails./// See the [module docs](../trace/index.html#on_failure) for details on exactly when the/// `on_failure` callback is called./// The default [`OnFailure`] implementation used by [`Trace`]./// Create a new `DefaultOnFailure`./// Defaults to [`Level::ERROR`]./// Trait used to tell [`Trace`] what to do when a request is received./// See the [module docs](../trace/index.html#on_request) for details on exactly when the/// `on_request` callback is called./// The default [`OnRequest`] implementation used by [`Trace`]./// Create a new `DefaultOnRequest`./// Please note that while this will set the level for the tracing events/// themselves, it might cause them to lack expected information, like/// request method or path. You can address this using/// [`DefaultMakeSpan::level`]./// [`DefaultMakeSpan::level`]: crate::trace::DefaultMakeSpan::level/// Trait used to tell [`Trace`] what to do when a response has been produced./// See the [module docs](../trace/index.html#on_response) for details on exactly when the/// `on_response` callback is called./// The default [`OnResponse`] implementation used by [`Trace`]./// Create a new `DefaultOnResponse`./// Include response headers on the [`Event`]./// [`Event`]: tracing::Event/// Middleware that adds high level [tracing] to a [`Service`]./// See the [module docs](crate::trace) for an example./// Create a new [`Trace`] using the given [`MakeClassifier`]./// Returns a new [`Layer`] that wraps services with a [`TraceLayer`] middleware./// Create a new [`Trace`] using [`ServerErrorsAsFailures`] which supports classifying/// Create a new [`Trace`] using [`GrpcErrorsAsFailures`] which supports classifyingOnRequestTMakeSpanTMimeIter/// Layer that applies [`ValidateRequestHeader`] which validates all requests./// See the [module docs](crate::validate_request) for an example./// Validate requests have the required Accept header./// The `Accept` header is required to be `*/*`, `type/*` or `type/subtype`,/// as configured./// Panics if `header_value` is not in the form: `type/subtype`, such as `application/json`/// See `AcceptHeader::new` for when this method panics./// use tower_http::validate_request::{AcceptHeader, ValidateRequestHeaderLayer};/// let layer = ValidateRequestHeaderLayer::<AcceptHeader<Full<Bytes>>>::accept("application/json");/// [`Accept`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/AcceptAcceptHeader/// Validate requests using a custom method./// Middleware that validates requests.invalid_header_value/// The body type used for responses to unvalidated requests./// Validate the request./// If `Ok(())` is returned then the request is allowed through, otherwise not./// Trait for validating requests./// Type that performs validation of the Accept header./// Create a new `AcceptHeader`.valid_accept_headervalid_accept_header_accept_all_jsonvalid_accept_header_accept_allinvalid_accept_headernot_accepted_accept_header_subtypenot_accepted_accept_headeraccepted_multiple_header_valueaccepted_inner_header_valueaccepted_header_with_quotes_validaccepted_header_with_quotes_invalid//! Middleware that validates requests.//! use tower_http::validate_request::ValidateRequestHeaderLayer;//! use http::{Request, Response, StatusCode, header::ACCEPT};//!     // Require the `Accept` header to be `application/json`, `*/*` or `application/*`//!     .layer(ValidateRequestHeaderLayer::accept("application/json"))//! // Requests with the correct value are allowed through//!     .header(ACCEPT, "application/json")//! // Requests with an invalid value get a `406 Not Acceptable` response//!     .header(ACCEPT, "text/strings")//! assert_eq!(StatusCode::NOT_ACCEPTABLE, response.status());//! Custom validation can be made by implementing [`ValidateRequest`]://! use tower_http::validate_request::{ValidateRequestHeaderLayer, ValidateRequest};//! pub struct MyHeader { /* ...  */ }//! impl<B> ValidateRequest<B> for MyHeader {//!     fn validate(//!         request: &mut Request<B>,//!     ) -> Result<(), Response<Self::ResponseBody>> {//!         // validate the request...//!     // Validate requests using `MyHeader`//!     .layer(ValidateRequestHeaderLayer::custom(MyHeader { /* ... */ }))//!     .layer(ValidateRequestHeaderLayer::custom(|request: &mut Request<Full<Bytes>>| {//!         // Validate the request//!         # Ok::<_, Response<Full<Bytes>>>(())/// A no-op middleware./// When wrapping a [`Service`], the [`Identity`] layer returns the provided/// service without modifying it./// [`Service`]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html/// Create a new [`Identity`] value/// Decorates a [`Service`], transforming either the request or the response./// Returns a new [`LayerFn`] that implements [`Layer`] by calling the/// given function./// The [`Layer::layer`] method takes a type implementing [`Service`] and/// returns a different type implementing [`Service`]. In many cases, this can/// be implemented by a function or a closure. The [`LayerFn`] helper allows/// writing simple [`Layer`] implementations without needing the boilerplate of/// a new struct implementing [`Layer`]./// # use tower_layer::{Layer, layer_fn};/// // A middleware that logs requests before forwarding them to another service/// pub struct LogService<S> {///     target: &'static str,///     service: S,/// impl<S, Request> Service<Request> for LogService<S>///     S: Service<Request>,///     Request: fmt::Debug,///     type Response = S::Response;///     type Error = S::Error;///     type Future = S::Future;///     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {///         self.service.poll_ready(cx)///     fn call(&mut self, request: Request) -> Self::Future {///         // Log the request///         println!("request = {:?}, target = {:?}", request, self.target);///         self.service.call(request)/// // A `Layer` that wraps services in `LogService`/// let log_layer = layer_fn(|service| {///     LogService {///         service,///         target: "tower-docs",/// // An example service. This one uppercases strings/// let uppercase_service = tower::service_fn(|request: String| async move {///     Ok::<_, Infallible>(request.to_uppercase())/// // Wrap our service in a `LogService` so requests are logged./// let wrapped_service = log_layer.layer(uppercase_service);/// [`Layer::layer`]: crate::Layer::layer/// A `Layer` implemented by a closure. See the docs for [`layer_fn`] for more details.layer_fn_has_useful_debug_impl/// The wrapped service/// Wrap the given service with the middleware, returning a new service/// that has been decorated with the middleware./// Often, many of the pieces needed for writing network applications can be/// reused across multiple services. The `Layer` trait can be used to write/// reusable components that can be applied to very different kinds of services;/// for example, it can be applied to services operating on different protocols,/// and to both the client and server side of a network transaction./// # Log/// Take request logging as an example:/// # use tower_layer::Layer;/// pub struct LogLayer {/// impl<S> Layer<S> for LogLayer {///     type Service = LogService<S>;///     fn layer(&self, service: S) -> Self::Service {///         LogService {///             target: self.target,///             service/// // This service implements the Log behavior///         // Insert log statement here or other functionality/// The above log implementation is decoupled from the underlying protocol and/// is also decoupled from client or server concerns. In other words, the same/// log middleware could be used in either a client or a server./// [`Service`]: https://docs.rs/tower/*/tower/trait.Service.html//! Layer traits and extensions.//! A layer decorates an service and provides additional functionality. It//! allows other services to be composed with the service that implements layer.//! A middleware implements the [`Layer`] and [`Service`] trait.//! [`Service`]: https://docs.rs/tower/*/tower/trait.Service.html/// Two middlewares chained together./// Create a new `Stack`.L11L12L13L14L15/// Returns `Poll::Ready(Ok(()))` when the service is able to process requests./// If the service is at capacity, then `Poll::Pending` is returned and the task/// expected to be called while on a task. Generally, this can be done with/// a simple `futures::future::poll_fn` call./// If `Poll::Ready(Err(_))` is returned, the service is no longer able to service requests/// and the caller should discard the service instance./// Once `poll_ready` returns `Poll::Ready(Ok(()))`, a request may be dispatched to the/// service using `call`. Until a request is dispatched, repeated calls to/// `poll_ready` must return either `Poll::Ready(Ok(()))` or `Poll::Ready(Err(_))`./// Note that `poll_ready` may reserve shared resources that are consumed in a subsequent/// invocation of `call`. Thus, it is critical for implementations to not assume that `call`/// will always be invoked and to ensure that such resources are released if the service is/// dropped before `call` is invoked or the future returned by `call` is dropped before it/// is polled./// This function is expected to be callable off task. As such,/// implementations should take care to not call `poll_ready`./// Before dispatching a request, `poll_ready` must be called and return/// `Poll::Ready(Ok(()))`./// Implementations are permitted to panic if `call` is invoked without/// obtaining `Poll::Ready(Ok(()))` from `poll_ready`./// underlying protocol. It is one of Tower's fundamental abstractions./// `Future` representing the eventual completion of processing the/// and the `Future` will resolve to a response or error./// # Server/// An RPC server *implements* the `Service` trait. Requests received by the/// server over the network are deserialized and then passed as an argument to the/// server value. The returned response is sent back over the network./// As an example, here is how an HTTP request is processed by a server:/// struct HelloWorld;/// impl Service<Request<Vec<u8>>> for HelloWorld {///     type Response = Response<Vec<u8>>;///     type Error = http::Error;///     type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;///     fn call(&mut self, req: Request<Vec<u8>>) -> Self::Future {///         // create the body///         let body: Vec<u8> = "hello, world!\n"///             .as_bytes()///             .to_owned();///         // Create the HTTP response///         let resp = Response::builder()///             .status(StatusCode::OK)///             .body(body)///             .expect("Unable to create `http::Response`");///         // create a response in a future.///         let fut = async {///             Ok(resp)///         // Return the response as an immediate future///         Box::pin(fut)/// # Client/// A client consumes a service by using a `Service` value. The client may/// issue requests by invoking `call` and passing the request as an argument./// It then receives the response by waiting for the returned future./// As an example, here is how a Redis request would be issued:/// let client = redis::Client::new()///     .connect("127.0.0.1:6379".parse().unwrap())/// let resp = client.call(Cmd::set("foo", "this is the value of foo")).await?;/// // Wait for the future to resolve/// println!("Redis response: {:?}", resp);/// # Middleware / Layer/// More often than not, all the pieces needed for writing robust, scalable/// network applications are the same no matter the underlying protocol. By/// unifying the API for both clients and servers in a protocol agnostic way,/// it is possible to write middleware that provide these pieces in a/// reusable way./// Take timeouts as an example:/// use tower_service::Service;/// use tower_layer::Layer;/// // Our timeout service, which wraps another service and/// // adds a timeout to its response future.///     inner: T,///     timeout: Duration,/// impl<T> Timeout<T> {///     pub const fn new(inner: T, timeout: Duration) -> Timeout<T> {///         Timeout {///             inner,///             timeout/// // The error returned if processing a request timed out/// pub struct Expired;/// impl fmt::Display for Expired {///         write!(f, "expired")/// impl Error for Expired {}/// // We can implement `Service` for `Timeout<T>` if `T` is a `Service`/// impl<T, Request> Service<Request> for Timeout<T>///     T: Service<Request>,///     T::Future: 'static,///     T::Error: Into<Box<dyn Error + Send + Sync>> + 'static,///     T::Response: 'static,///     // `Timeout` doesn't modify the response type, so we use `T`'s response type///     type Response = T::Response;///     // Errors may be either `Expired` if the timeout expired, or the inner service's///     // `Error` type. Therefore, we return a boxed `dyn Error + Send + Sync` trait object to erase///     // the error's type.///     type Error = Box<dyn Error + Send + Sync>;///         // Our timeout service is ready if the inner service is ready.///         // This is how backpressure can be propagated through a tree of nested services.///        self.inner.poll_ready(cx).map_err(Into::into)///         // Create a future that completes after `self.timeout`///         let timeout = tokio::time::sleep(self.timeout);///         // Call the inner service and get a future that resolves to the response///         let fut = self.inner.call(req);///         // Wrap those two futures in another future that completes when either one completes///         // If the inner service is too slow the `sleep` future will complete first///         // And an error will be returned and `fut` will be dropped and not polled again///         // We have to box the errors so the types match///         let f = async move {///                 res = fut => {///                     res.map_err(|err| err.into())///                 _ = timeout => {///                     Err(Box::new(Expired) as Box<dyn Error + Send + Sync>)///         Box::pin(f)/// // A layer for wrapping services in `Timeout`/// pub struct TimeoutLayer(Duration);/// impl TimeoutLayer {///     pub const fn new(delay: Duration) -> Self {///         TimeoutLayer(delay)/// impl<S> Layer<S> for TimeoutLayer {///     type Service = Timeout<S>;///     fn layer(&self, service: S) -> Timeout<S> {///         Timeout::new(service, self.0)/// The above timeout implementation is decoupled from the underlying protocol/// and is also decoupled from client or server concerns. In other words, the/// same timeout middleware could be used in either a client or a server./// # Backpressure/// Calling a `Service` which is at capacity (i.e., it is temporarily unable to process a/// request) should result in an error. The caller is responsible for ensuring/// that the service is ready to receive the request before calling it./// `Service` provides a mechanism by which the caller is able to coordinate/// readiness. `Service::poll_ready` returns `Ready` if the service expects that/// it is able to process a request./// # Be careful when cloning inner services/// Services are permitted to panic if `call` is invoked without obtaining `Poll::Ready(Ok(()))`/// from `poll_ready`. You should therefore be careful when cloning services for example to move/// them into boxed futures. Even though the original service is ready, the clone might not be./// Therefore this kind of code is wrong and might panic:/// struct Wrapper<S> {///     inner: S,/// impl<R, S> Service<R> for Wrapper<S>///     S: Service<R> + Clone + 'static,///     R: 'static,///         self.inner.poll_ready(cx)///     fn call(&mut self, req: R) -> Self::Future {///         let mut inner = self.inner.clone();///         Box::pin(async move {///             // `inner` might not be ready since its a clone///             inner.call(req).await/// You should instead use [`std::mem::replace`] to take the service that was ready:///         let clone = self.inner.clone();///         // take the service that was ready///         let mut inner = std::mem::replace(&mut self.inner, clone);//! Definition of the core `Service` trait to Tower//! The [`Service`] trait provides the necessary abstractions for defining//! request / response clients and servers. It is simple but powerful and is//! used as the foundation for the rest of Tower.with_defaultset_global_defaultSetGlobalDefaultErrorWeakDispatchhas_been_set/// Private API for internal use by tracing's macros./// This function is *not* considered part of `tracing`'s public API, and has no/// stability guarantees. If you use it, and it breaks or disappears entirely,/// don't say we didn;'t warn you.//! Dispatches trace events to [`Subscriber`]s.//! The _dispatcher_ is the component of the tracing system which is responsible//! for forwarding trace data from the instrumentation points that generate it//! to the subscriber that collects it.//! # Using the Trace Dispatcher//! Every thread in a program using `tracing` has a _default subscriber_. When//! events occur, or spans are created, they are dispatched to the thread's//! current subscriber.//! ## Setting the Default Subscriber//! By default, the current subscriber is an empty implementation that does//! nothing. To use a subscriber implementation, it must be set as the default.//! There are two methods for doing so: [`with_default`] and//! [`set_global_default`]. `with_default` sets the default subscriber for the//! duration of a scope, while `set_global_default` sets a default subscriber//! for the entire process.//! To use either of these functions, we must first wrap our subscriber in a//! [`Dispatch`], a cloneable, type-erased reference to a subscriber. For//! # pub struct FooSubscriber;//! # use tracing_core::{//! #   dispatcher, Event, Metadata,//! #   span::{Attributes, Id, Record}//! # impl tracing_core::Subscriber for FooSubscriber {//! #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(0) }//! #   fn record(&self, _: &Id, _: &Record) {}//! #   fn event(&self, _: &Event) {}//! #   fn record_follows_from(&self, _: &Id, _: &Id) {}//! #   fn enter(&self, _: &Id) {}//! #   fn exit(&self, _: &Id) {}//! # impl FooSubscriber { fn new() -> Self { FooSubscriber } }//! use dispatcher::Dispatch;//! let my_subscriber = FooSubscriber::new();//! let my_dispatch = Dispatch::new(my_subscriber);//! Then, we can use [`with_default`] to set our `Dispatch` as the default for//! the duration of a block://! # let my_subscriber = FooSubscriber::new();//! # let my_dispatch = dispatcher::Dispatch::new(my_subscriber);//! // no default subscriber//! dispatcher::with_default(&my_dispatch, || {//!     // my_subscriber is the default//! // no default subscriber again//! It's important to note that `with_default` will not propagate the current//! thread's default subscriber to any threads spawned within the `with_default`//! block. To propagate the default subscriber to new threads, either use//! `with_default` from the new thread, or use `set_global_default`.//! As an alternative to `with_default`, we can use [`set_global_default`] to//! set a `Dispatch` as the default for all threads, for the lifetime of the//! program. For example://! dispatcher::set_global_default(my_dispatch)//!     // `set_global_default` will return an error if the global default//!     // subscriber has already been set.//!     .expect("global default was already set!");//! // `my_subscriber` is now the default//! <pre class="ignore" style="white-space:normal;font:inherit;">//! <strong>Note</strong>: The thread-local scoped dispatcher (<code>with_default</code>)//! requires the Rust standard library. <code>no_std</code> users should//! use <a href="fn.set_global_default.html"><code>set_global_default</code></a>//! </pre>//! ## Accessing the Default Subscriber//! A thread's current default subscriber can be accessed using the//! [`get_default`] function, which executes a closure with a reference to the//! currently default `Dispatch`. This is used primarily by `tracing`//! instrumentation.//! [`Subscriber`]: crate::Subscriberas_field/// Attempts to convert `&self` into a `Field` with the specified `metadata`./// If `metadata` defines this field, then the field is returned. Otherwise,AsField/// Trait implemented to allow a type to be used as a field key./// <pre class="ignore" style="white-space:normal;font:inherit;">/// <strong>Note</strong>: Although this is implemented for both the/// <a href="./struct.Field.html"><code>Field</code></a> type <em>and</em> any/// type that can be borrowed as an <code>&str</code>, only <code>Field</code>/// allows <em>O</em>(1) access./// Indexing a field with a string results in an iterative search that performs/// string comparisons. Thus, if possible, once the key for a field is known, it/// should be used whenever possible.//! `Span` and `Event` key-value data.//! Spans and events may be annotated with key-value data, referred to as _fields_.//! These fields consist of a mapping from a key (corresponding to//! a `&str` but represented internally as an array index) to a [`Value`].//! # `Value`s and `Subscriber`s//! `Subscriber`s consume `Value`s as fields attached to [span]s or [`Event`]s.//! The set of field keys on a given span or event is defined on its [`Metadata`].//! When a span is created, it provides [`Attributes`] to the `Subscriber`'s//! [`new_span`] method, containing any fields whose values were provided when//! the span was created; and may call the `Subscriber`'s [`record`] method//! with additional [`Record`]s if values are added for more of its fields.//! Similarly, the [`Event`] type passed to the subscriber's [`event`] method//! will contain any fields attached to each event.//! `tracing` represents values as either one of a set of Rust primitives//! (`i64`, `u64`, `f64`, `bool`, and `&str`) or using a `fmt::Display` or//! `fmt::Debug` implementation. `Subscriber`s are provided these primitive//! value types as `dyn Value` trait objects.//! These trait objects can be formatted using `fmt::Debug`, but may also be//! recorded as typed data by calling the [`Value::record`] method on these//! trait objects with a _visitor_ implementing the [`Visit`] trait. This trait//! represents the behavior used to record values of various types. For example,//! an implementation of `Visit` might record integers by incrementing counters//! for their field names rather than printing them.//! # Using `valuable`//! `tracing`'s [`Value`] trait is intentionally minimalist: it supports only a small//! number of Rust primitives as typed values, and only permits recording//! user-defined types with their [`fmt::Debug`] or [`fmt::Display`]//! implementations. However, there are some cases where it may be useful to record//! nested values (such as arrays, `Vec`s, or `HashMap`s containing values), or//! user-defined `struct` and `enum` types without having to format them as//! unstructured text.//! To address `Value`'s limitations, `tracing` offers experimental support for//! the [`valuable`] crate, which provides object-safe inspection of structured//! values. User-defined types can implement the [`valuable::Valuable`] trait,//! and be recorded as a `tracing` field by calling their [`as_value`] method.//! If the [`Subscriber`] also supports the `valuable` crate, it can//! then visit those types fields as structured values using `valuable`.//!     <strong>Note</strong>: <code>valuable</code> support is an//!     <a href = "../index.html#unstable-features">unstable feature</a>. See//!     the documentation on unstable features for details on how to enable it.//! // Derive `Valuable` for our types://! use valuable::Valuable;//! #[derive(Clone, Debug, Valuable)]//!     age: u32,//!     country: String,//! let user = User {//!     name: "Arwen Undomiel".to_string(),//!     age: 3000,//!     address: Address {//!         country: "Middle Earth".to_string(),//!         city: "Rivendell".to_string(),//!         street: "leafy lane".to_string(),//! // Recording `user` as a `valuable::Value` will allow the `tracing` subscriber//! // to traverse its fields as a nested, typed structure://! tracing::info!(current_user = user.as_value());//! Alternatively, the [`valuable()`] function may be used to convert a type//! implementing [`Valuable`] into a `tracing` field value.//! When the `valuable` feature is enabled, the [`Visit`] trait will include an//! optional [`record_value`] method. `Visit` implementations that wish to//! record `valuable` values can implement this method with custom behavior.//! If a visitor does not implement `record_value`, the [`valuable::Value`] will//! be forwarded to the visitor's [`record_debug`] method.//! [`fmt::Debug`]: std::fmt::Debug//! [`fmt::Display`]: std::fmt::Debug//! [`valuable`]: https://crates.io/crates/valuable//! [`valuable::Valuable`]: https://docs.rs/valuable/latest/valuable/trait.Valuable.html//! [`as_value`]: https://docs.rs/valuable/latest/valuable/trait.Valuable.html#tymethod.as_value//! [`valuable::Value`]: https://docs.rs/valuable/latest/valuable/enum.Value.html//! [`record_value`]: Visit::record_value//! [`record_debug`]: Visit::record_debug//! [span]: mod@crate::span//! [`Event`]: crate::event::Event//! [`Metadata`]: crate::Metadata//! [`Attributes`]: crate::span::Attributes//! [`Record`]: crate::span::Record//! [`new_span`]: crate::Subscriber::new_span//! [`record`]: crate::Subscriber::record//! [`event`]: crate::Subscriber::event// ===== impl AsField =====/// Instruments this type with the provided [`Span`], returning an/// `Instrumented` wrapper./// The attached [`Span`] will be [entered] every time the instrumented/// [`Future`] is polled or [`Drop`]ped./// Instrumenting a future:/// use tracing::Instrument;/// # async fn doc() {/// let my_future = async {/// my_future///     .instrument(tracing::info_span!("my_future"))/// The [`Span::or_current`] combinator can be used in combination with/// `instrument` to ensure that the [current span] is attached to the/// future if the span passed to `instrument` is [disabled]:/// # mod tokio {/// #     pub(super) fn spawn(_: impl std::future::Future) {}/// let outer_span = tracing::info_span!("outer").entered();/// // If the "my_future" span is enabled, then the spawned task will/// // be within both "my_future" *and* "outer", since "outer" is/// // "my_future"'s parent. However, if "my_future" is disabled,/// // the spawned task will *not* be in any span.///     my_future///         .instrument(tracing::debug_span!("my_future"))/// // Using `Span::or_current` ensures the spawned task is instrumented/// // with the current span, if the new span passed to `instrument` is/// // not enabled. This means that if the "my_future"  span is disabled,/// // the spawned task will still be instrumented with the "outer" span:/// # let my_future = async {};///    my_future///         .instrument(tracing::debug_span!("my_future").or_current())/// [entered]: super::Span::enter()/// [`Span::or_current`]: super::Span::or_current()/// [current span]: super::Span::current()/// [disabled]: super::Span::is_disabled()in_current_span/// Instruments this type with the [current] [`Span`], returning an/// This can be used to propagate the current span when spawning a new future./// let span = tracing::info_span!("my_span");/// let _enter = span.enter();///     tracing::debug!("this event will occur inside `my_span`");/// tokio::spawn(future.in_current_span());/// [current]: super::Span::current()/// [`Span`]: crate::Span/// Attaches spans to a [`std::future::Future`]./// Extension trait allowing futures to be/// instrumented with a `tracing` [span]./// [span]: super::Spanwith_subscriberWithDispatch/// Attaches the provided [`Subscriber`] to this type, returning a/// [`WithDispatch`] wrapper./// The attached [`Subscriber`] will be set as the [default] when the returned/// [`Future`] is polled./// # use tracing::subscriber::NoSubscriber as MySubscriber;/// # use tracing::subscriber::NoSubscriber as MyOtherSubscriber;/// # async fn docs() {/// use tracing::instrument::WithSubscriber;/// // Set the default `Subscriber`/// let _default = tracing::subscriber::set_default(MySubscriber::default());/// tracing::info!("this event will be recorded by the default `Subscriber`");/// // Create a different `Subscriber` and attach it to a future./// let other_subscriber = MyOtherSubscriber::default();///     tracing::info!("this event will be recorded by the other `Subscriber`");/// future///     // Attach the other `Subscriber` to the future before awaiting it///     .with_subscriber(other_subscriber)/// // Once the future has completed, we return to the default `Subscriber`./// [`Subscriber`]: super::Subscriber/// [default]: crate::dispatcher#setting-the-default-subscriberwith_current_subscriber/// Attaches the current [default] [`Subscriber`] to this type, returning a/// The attached `Subscriber` will be set as the [default] when the returned/// This can be used to propagate the current dispatcher context when/// spawning a new future that may run on a different thread./// // Using `set_default` (rather than `set_global_default`) sets the/// // default `Subscriber` for *this* thread only./// // If a multi-threaded async runtime is in use, this spawned task may/// // run on a different thread, in a different default `Subscriber`'s context./// tokio::spawn(future);/// // However, calling `with_current_subscriber` on the future before/// // spawning it, ensures that the current thread's default `Subscriber` is/// // propagated to the spawned task, regardless of where it executes:/// # let future = async { };/// tokio::spawn(future.with_current_subscriber());WithSubscriber/// Extension trait allowing futures to be instrumented with/// a `tracing` [`Subscriber`](crate::Subscriber).r" A [`Future`] that has been instrumented with a `tracing` [`Subscriber`]."r" This type is returned by the [`WithSubscriber`] extension trait. See that"r" trait's documentation for details."r" [`Future`]: std::future::Future"r" [`Subscriber`]: crate::Subscriber"r" A [`Future`] that has been instrumented with a `tracing` [`Span`]."r" This type is returned by the [`Instrument`] extension trait. See that"r" [`Span`]: crate::Span"InstrumentedProjInstrumentedProjRefspan_and_inner_pin_mut/// Get a mutable reference to the [`Span`] a pinned mutable reference to/// the wrapped type.span_and_inner_pin_ref/// Get a reference to the [`Span`] a pinned reference to the wrapped type./// Borrows the `Span` that this type is instrumented by.span_mut/// Mutably borrows the `Span` that this type is instrumented by./// Borrows the wrapped type./// Mutably borrows the wrapped type.inner_pin_ref/// Get a pinned reference to the wrapped type.inner_pin_mut/// Get a pinned mutable reference to the wrapped type./// Consumes the `Instrumented`, returning the wrapped type./// Note that this drops the span./// Borrows the [`Dispatch`] that is entered when this type is polled.// === impl Instrumented ===// === impl WithDispatch ===ParseLevelFilterError/// The statically configured maximum trace level./// See the [module-level documentation] for information on how to configure/// This value is checked by the `event!` and `span!` macros. Code that/// manually constructs events or spans via the `Event::record` function or/// `Span` constructors should compare the level against this value to/// determine if those spans or events are enabled./// [module-level documentation]: self#compile-time-filtersget_max_level_inner//! Trace verbosity level filtering.//! Trace verbosity levels can be statically disabled at compile time via Cargo//! features, similar to the [`log` crate]. Trace instrumentation at disabled//! levels will be skipped and will not even be present in the resulting binary//! unless the verbosity level is specified dynamically. This level is//! configured separately for release and debug builds. The features are://! These features control the value of the `STATIC_MAX_LEVEL` constant. The//! instrumentation macros macros check this value before recording an event or//! constructing a span. By default, no levels are disabled.//! For example, a crate can disable trace level instrumentation in debug builds//! and trace, debug, and info level instrumentation in release builds with the//! following configuration://! tracing = { version = "0.1", features = ["max_level_debug", "release_max_level_warn"] }//! ## Notes//! Please note that `tracing`'s static max level features do *not* control the//! [`log`] records that may be emitted when [`tracing`'s "log" feature flag][f] is//! enabled. This is to allow `tracing` to be disabled entirely at compile time//! while still emitting `log` records --- such as when a library using//! `tracing` is used by an application using `log` that doesn't want to//! generate any `tracing`-related code, but does want to collect `log` records.//! This means that if the "log" feature is in use, some code may be generated//! for `log` records emitted by disabled `tracing` events. If this is not//! desirable, `log` records may be disabled separately using [`log`'s static//! max level features][`log` crate].//! [`log`]: https://docs.rs/log///! [`log` crate]: https://docs.rs/log/latest/log/#compile-time-filters//! [f]: https://docs.rs/tracing/latest/tracing/#emitting-log-records// Somehow this `use` statement is necessary for us to re-export the `core`// macros on Rust 1.26.0. I'm not sure how this makes it work, but it does.SubscribercallsiteCallsite/// Attach a span to a `std::future::Future`.stdlib// Re-export the `core` functions that are used in macros. This allows// a crate to be named `core` and avoid name clashes.// See here: https://github.com/tokio-rs/tracing/issues/2761DefaultCallsiteMacroCallsite/// Callsite implementation used by macro-generated code./// /!\ WARNING: This is *not* a stable API! /!\/// This type, and all code contained in the `__macro_support` module, is/// a *private* API of `tracing`. It is exposed publicly because it is used/// by the `tracing` macros, but it is not part of the stable versioned API./// Breaking changes to this module may occur in small-numbered versions/// without warning.__is_enabled/// This function, and all code contained in the `__macro_support` module, is__disabled_span__tracing_logValueSet__macro_supportLogValueSet/// Utility to format [`ValueSet`]s for logging.//! A scoped, structured logging and diagnostics system.//! `tracing` is a framework for instrumenting Rust programs to collect//! structured, event-based diagnostic information.//! In asynchronous systems like Tokio, interpreting traditional log messages can//! often be quite challenging. Since individual tasks are multiplexed on the same//! thread, associated events and log lines are intermixed making it difficult to//! trace the logic flow. `tracing` expands upon logging-style diagnostics by//! allowing libraries and applications to record structured events with additional//! information about *temporality* and *causality* — unlike a log message, a span//! in `tracing` has a beginning and end time, may be entered and exited by the//! flow of execution, and may exist within a nested tree of similar spans. In//! addition, `tracing` spans are *structured*, with the ability to record typed//! data as well as textual messages.//! The `tracing` crate provides the APIs necessary for instrumenting libraries//! and applications to emit trace data.//! *Compiler support: [requires `rustc` 1.63+][msrv]*//! [msrv]: #supported-rust-versions//! # Core Concepts//! The core of `tracing`'s API is composed of _spans_, _events_ and//! _subscribers_. We'll cover these in turn.//! ## Spans//! To record the flow of execution through a program, `tracing` introduces the//! concept of [spans]. Unlike a log line that represents a _moment in//! time_, a span represents a _period of time_ with a beginning and an end. When a//! program begins executing in a context or performing a unit of work, it//! _enters_ that context's span, and when it stops executing in that context,//! it _exits_ the span. The span in which a thread is currently executing is//! referred to as that thread's _current_ span.//! use tracing::{span, Level};//! let span = span!(Level::TRACE, "my_span");//! // `enter` returns a RAII guard which, when dropped, exits the span. this//! // indicates that we are in the span for the current lexical scope.//! let _enter = span.enter();//! // perform some work in the context of `my_span`...//! The [`span` module][span]'s documentation provides further details on how to//! use spans.//! <div class="example-wrap" style="display:inline-block"><pre class="compile_fail" style="white-space:normal;font:inherit;">//!  **Warning**: In asynchronous code that uses async/await syntax,//!  `Span::enter` may produce incorrect traces if the returned drop//!  guard is held across an await point. See//!  [the method documentation][Span#in-asynchronous-code] for details.//! </pre></div>//! ## Events//! An [`Event`] represents a _moment_ in time. It signifies something that//! happened while a trace was being recorded. `Event`s are comparable to the log//! records emitted by unstructured logging code, but unlike a typical log line,//! an `Event` may occur within the context of a span.//! use tracing::{event, span, Level};//! // records an event outside of any span context://! event!(Level::INFO, "something happened");//! let span = span!(Level::INFO, "my_span");//! let _guard = span.enter();//! // records an event within "my_span".//! event!(Level::DEBUG, "something happened inside my_span");//! In general, events should be used to represent points in time _within_ a//! span — a request returned with a given status code, _n_ new items were//! taken from a queue, and so on.//! The [`Event` struct][`Event`] documentation provides further details on using//! ## Subscribers//! As `Span`s and `Event`s occur, they are recorded or aggregated by//! implementations of the [`Subscriber`] trait. `Subscriber`s are notified//! when an `Event` takes place and when a `Span` is entered or exited. These//! notifications are represented by the following `Subscriber` trait methods://! + [`event`][Subscriber::event], called when an `Event` takes place,//! + [`enter`], called when execution enters a `Span`,//! + [`exit`], called when execution exits a `Span`//! In addition, subscribers may implement the [`enabled`] function to _filter_//! the notifications they receive based on [metadata] describing each `Span`//! or `Event`. If a call to `Subscriber::enabled` returns `false` for a given//! set of metadata, that `Subscriber` will *not* be notified about the//! corresponding `Span` or `Event`. For performance reasons, if no currently//! active subscribers express interest in a given set of metadata by returning//! `true`, then the corresponding `Span` or `Event` will never be constructed.//! ## Recording Spans and Events//! Spans and events are recorded using macros.//! ### Spans//! The [`span!`] macro expands to a [`Span` struct][`Span`] which is used to//! record a span. The [`Span::enter`] method on that struct records that the//! span has been entered, and returns a [RAII] guard object, which will exit//! the span when dropped.//! // Construct a new span named "my span" with trace log level.//! let span = span!(Level::TRACE, "my span");//! // Enter the span, returning a guard object.//! // Any trace events that occur before the guard is dropped will occur//! // within the span.//! // Dropping the guard will exit the span.//! The [`#[instrument]`][instrument] attribute provides an easy way to//! add `tracing` spans to functions. A function annotated with `#[instrument]`//! will create and enter a span with that function's name every time the//! function is called, with arguments to that function will be recorded as//! fields using `fmt::Debug`.//! # // this doctest is ignored because we don't have a way to say//! # // that it should only be run with cfg(feature = "attributes")//! use tracing::{Level, event, instrument};//! #[instrument]//! pub fn my_function(my_arg: usize) {//!     // This event will be recorded inside a span named `my_function` with the//!     // field `my_arg`.//!     event!(Level::INFO, "inside my_function!");//! For functions which don't have built-in tracing support and can't have//! the `#[instrument]` attribute applied (such as from an external crate),//! the [`Span` struct][`Span`] has a [`in_scope()` method][`in_scope`]//! which can be used to easily wrap synchronous code in a span.//! use tracing::info_span;//! # fn doc() -> Result<(), ()> {//! # mod serde_json {//! #    pub(crate) fn from_slice(buf: &[u8]) -> Result<(), ()> { Ok(()) }//! # let buf: [u8; 0] = [];//! let json = info_span!("json.parse").in_scope(|| serde_json::from_slice(&buf))?;//! # let _ = json; // suppress unused variable warning//! You can find more examples showing how to use this crate [here][examples].//! [RAII]: https://github.com/rust-unofficial/patterns/blob/main/src/patterns/behavioural/RAII.md//! [examples]: https://github.com/tokio-rs/tracing/tree/master/examples//! [`Event`]s are recorded using the [`event!`] macro://! use tracing::{event, Level};//! event!(Level::INFO, "something has happened!");//! ## Using the Macros//! The [`span!`] and [`event!`] macros as well as the `#[instrument]` attribute//! use fairly similar syntax, with some exceptions.//! ### Configuring Attributes//! Both macros require a [`Level`] specifying the verbosity of the span or//! event. Optionally, the, [target] and [parent span] may be overridden. If the//! target and parent span are not overridden, they will default to the//! module path where the macro was invoked and the current span (as determined//! by the subscriber), respectively.//! # use tracing::{span, event, Level};//! span!(target: "app_spans", Level::TRACE, "my span");//! event!(target: "app_events", Level::INFO, "something has happened!");//! event!(parent: &span, Level::INFO, "something has happened!");//! The span macros also take a string literal after the level, to set the name//! of the span (as above).  In the case of the event macros, the name of the event can//! be overridden (the default is `event file:line`) using the `name:` specifier.//! span!(Level::TRACE, "my span");//! event!(name: "some_info", Level::INFO, "something has happened!");//! ### Recording Fields//! Structured fields on spans and events are specified using the syntax//! `field_name = field_value`. Fields are separated by commas.//! # use tracing::{event, Level};//! // records an event with two fields://! //  - "answer", with the value 42//! //  - "question", with the value "life, the universe and everything"//! event!(Level::INFO, answer = 42, question = "life, the universe, and everything");//! As shorthand, local variables may be used as field values without an//! assignment, similar to [struct initializers]. For example://! # use tracing::{span, Level};//! let user = "ferris";//! span!(Level::TRACE, "login", user);//! // is equivalent to://! span!(Level::TRACE, "login", user = user);//! Field names can include dots, but should not be terminated by them://! let email = "ferris@rust-lang.org";//! span!(Level::TRACE, "login", user, user.email = email);//! Since field names can include dots, fields on local structs can be used//! using the local variable shorthand://! # struct User {//! #    name: &'static str,//! #    email: &'static str,//!     name: "ferris",//!     email: "ferris@rust-lang.org",//! // the span will have the fields `user.name = "ferris"` and//! // `user.email = "ferris@rust-lang.org"`.//! span!(Level::TRACE, "login", user.name, user.email);//! Fields with names that are not Rust identifiers, or with names that are Rust reserved words,//! may be created using quoted string literals. However, this may not be used with the local//! variable shorthand.//! // records an event with fields whose names are not Rust identifiers//! //  - "guid:x-request-id", containing a `:`, with the value "abcdef"//! //  - "type", which is a reserved word, with the value "request"//! span!(Level::TRACE, "api", "guid:x-request-id" = "abcdef", "type" = "request");//! Constant expressions can also be used as field names. Constants//! must be enclosed in curly braces (`{}`) to indicate that the *value*//! of the constant is to be used as the field name, rather than the//! constant's name. For example://! const RESOURCE_NAME: &str = "foo";//! // this span will have the field `foo = "some_id"`//! span!(Level::TRACE, "get", { RESOURCE_NAME } = "some_id");//! The `?` sigil is shorthand that specifies a field should be recorded using//! its [`fmt::Debug`] implementation://! struct MyStruct {//!     field: &'static str,//! let my_struct = MyStruct {//!     field: "Hello world!"//! // `my_struct` will be recorded using its `fmt::Debug` implementation.//! event!(Level::TRACE, greeting = ?my_struct);//! event!(Level::TRACE, greeting = tracing::field::debug(&my_struct));//! The `%` sigil operates similarly, but indicates that the value should be//! recorded using its [`fmt::Display`] implementation://! # struct MyStruct {//! #     field: &'static str,//! # let my_struct = MyStruct {//! #     field: "Hello world!"//! // `my_struct.field` will be recorded using its `fmt::Display` implementation.//! event!(Level::TRACE, greeting = %my_struct.field);//! event!(Level::TRACE, greeting = tracing::field::display(&my_struct.field));//! The `%` and `?` sigils may also be used with local variable shorthand://! event!(Level::TRACE, %my_struct.field);//! Additionally, a span may declare fields with the special value [`Empty`],//! which indicates that that the value for that field does not currently exist//! but may be recorded later. For example://! use tracing::{trace_span, field};//! // Create a span with two fields: `greeting`, with the value "hello world", and//! // `parting`, without a value.//! let span = trace_span!("my_span", greeting = "hello world", parting = field::Empty);//! // Now, record a value for parting as well.//! span.record("parting", &"goodbye world!");//! Finally, events may also include human-readable messages, in the form of a//! [format string][fmt] and (optional) arguments, **after** the event's//! key-value fields. If a format string and arguments are provided,//! they will implicitly create a new field named `message` whose value is the//! provided set of format arguments.//! let question = "the ultimate question of life, the universe, and everything";//! let answer = 42;//! // records an event with the following fields://! // - `question.answer` with the value 42,//! // - `question.tricky` with the value `true`,//! // - "message", with the value "the answer to the ultimate question of life, the//! //    universe, and everything is 42."//! event!(//!     Level::DEBUG,//!     question.answer = answer,//!     question.tricky = true,//!     "the answer to {} is {}.", question, answer//! Specifying a formatted message in this manner does not allocate by default.//! [struct initializers]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html#using-the-field-init-shorthand-when-variables-and-fields-have-the-same-name//! [target]: Metadata::target//! [parent span]: span::Attributes::parent//! [determined contextually]: span::Attributes::is_contextual//! [`fmt::Display`]: std::fmt::Display//! [fmt]: std::fmt#usage//! [`Empty`]: field::Empty//! ### Shorthand Macros//! `tracing` also offers a number of macros with preset verbosity levels.//! The [`trace!`], [`debug!`], [`info!`], [`warn!`], and [`error!`] behave//! similarly to the [`event!`] macro, but with the [`Level`] argument already//! specified, while the corresponding [`trace_span!`], [`debug_span!`],//! [`info_span!`], [`warn_span!`], and [`error_span!`] macros are the same,//! but for the [`span!`] macro.//! These are intended both as a shorthand, and for compatibility with the [`log`]//! crate (see the next section).//! [`span!`]: span!//! [`event!`]: event!//! [`trace!`]: trace!//! [`debug!`]: debug!//! [`info!`]: info!//! [`warn!`]: warn!//! [`error!`]: error!//! [`trace_span!`]: trace_span!//! [`debug_span!`]: debug_span!//! [`info_span!`]: info_span!//! [`warn_span!`]: warn_span!//! [`error_span!`]: error_span!//! ### For `log` Users//! Users of the [`log`] crate should note that `tracing` exposes a set of//! macros for creating `Event`s (`trace!`, `debug!`, `info!`, `warn!`, and//! `error!`) which may be invoked with the same syntax as the similarly-named//! macros from the `log` crate. Often, the process of converting a project to//! use `tracing` can begin with a simple drop-in replacement.//! Let's consider the `log` crate's yak-shaving example://! use std::{error::Error, io};//! use tracing::{debug, error, info, span, warn, Level};//! // the `#[tracing::instrument]` attribute creates and enters a span//! // every time the instrumented function is called. The span is named after the//! // the function or method. Parameters passed to the function are recorded as fields.//! #[tracing::instrument]//! pub fn shave(yak: usize) -> Result<(), Box<dyn Error + 'static>> {//!     // this creates an event at the DEBUG level with two fields://!     // - `excitement`, with the key "excitement" and the value "yay!"//!     // - `message`, with the key "message" and the value "hello! I'm gonna shave a yak."//!     // unlike other fields, `message`'s shorthand initialization is just the string itself.//!     debug!(excitement = "yay!", "hello! I'm gonna shave a yak.");//!     if yak == 3 {//!         warn!("could not locate yak!");//!         // note that this is intended to demonstrate `tracing`'s features, not idiomatic//!         // error handling! in a library or application, you should consider returning//!         // a dedicated `YakError`. libraries like snafu or thiserror make this easy.//!         return Err(io::Error::new(io::ErrorKind::Other, "shaving yak failed!").into());//!         debug!("yak shaved successfully");//! pub fn shave_all(yaks: usize) -> usize {//!     // Constructs a new span named "shaving_yaks" at the TRACE level,//!     // and a field whose key is "yaks". This is equivalent to writing://!     // let span = span!(Level::TRACE, "shaving_yaks", yaks = yaks);//!     // local variables (`yaks`) can be used as field values//!     // without an assignment, similar to struct initializers.//!     let _span = span!(Level::TRACE, "shaving_yaks", yaks).entered();//!     info!("shaving yaks");//!     let mut yaks_shaved = 0;//!     for yak in 1..=yaks {//!         let res = shave(yak);//!         debug!(yak, shaved = res.is_ok());//!         if let Err(ref error) = res {//!             // Like spans, events can also use the field initialization shorthand.//!             // In this instance, `yak` is the field being initalized.//!             error!(yak, error = error.as_ref(), "failed to shave yak!");//!             yaks_shaved += 1;//!         debug!(yaks_shaved);//!     yaks_shaved//! Libraries should link only to the `tracing` crate, and use the provided//! macros to record whatever information will be useful to downstream//! consumers.//! In order to record trace events, executables have to use a `Subscriber`//! implementation compatible with `tracing`. A `Subscriber` implements a//! way of collecting trace data, such as by logging it to standard output.//! This library does not contain any `Subscriber` implementations; these are//! provided by [other crates](#related-crates).//! The simplest way to use a subscriber is to call the [`set_global_default`]//! extern crate tracing;//! # use tracing::{span::{Id, Attributes, Record}, Metadata};//! # impl tracing::Subscriber for FooSubscriber {//! #   fn event(&self, _: &tracing::Event) {}//! # impl FooSubscriber {//! #   fn new() -> Self { FooSubscriber }//! tracing::subscriber::set_global_default(my_subscriber)//!     .expect("setting tracing default failed");//! <pre class="compile_fail" style="white-space:normal;font:inherit;">//!     <strong>Warning</strong>: In general, libraries should <em>not</em> call//!     <code>set_global_default()</code>! Doing so will cause conflicts when//!     executables that depend on the library try to set the default later.//! This subscriber will be used as the default in all threads for the//! remainder of the duration of the program, similar to setting the logger//! in the `log` crate.//! In addition, the default subscriber can be set through using the//! [`with_default`] function. This follows the `tokio` pattern of using//! closures to represent executing code in a context that is exited at the end//! of the closure. For example://! tracing::subscriber::with_default(my_subscriber, || {//!     // Any trace events generated in this closure or by functions it calls//!     // will be collected by `my_subscriber`.//! This approach allows trace data to be collected by multiple subscribers//! within different contexts in the program. Note that the override only applies to the//! currently executing thread; other threads will not see the change from with_default.//! Any trace events generated outside the context of a subscriber will not be collected.//! Once a subscriber has been set, instrumentation points may be added to the//! executable using the `tracing` crate's macros.//! ## `log` Compatibility//! The [`log`] crate provides a simple, lightweight logging facade for Rust.//! While `tracing` builds upon `log`'s foundation with richer structured//! diagnostic data, `log`'s simplicity and ubiquity make it the "lowest common//! denominator" for text-based logging in Rust — a vast majority of Rust//! libraries and applications either emit or consume `log` records. Therefore,//! `tracing` provides multiple forms of interoperability with `log`: `tracing`//! instrumentation can emit `log` records, and a compatibility layer enables//! `tracing` [`Subscriber`]s to consume `log` records as `tracing` [`Event`]s.//! ### Emitting `log` Records//! This crate provides two feature flags, "log" and "log-always", which will//! cause [spans] and [events] to emit `log` records. When the "log" feature is//! enabled, if no `tracing` `Subscriber` is active, invoking an event macro or//! creating a span with fields will emit a `log` record. This is intended//! primarily for use in libraries which wish to emit diagnostics that can be//! consumed by applications using `tracing` *or* `log`, without paying the//! additional overhead of emitting both forms of diagnostics when `tracing` is//! in use.//! Enabling the "log-always" feature will cause `log` records to be emitted//! even if a `tracing` `Subscriber` _is_ set. This is intended to be used in//! applications where a `log` `Logger` is being used to record a textual log,//! and `tracing` is used only to record other forms of diagnostics (such as//! metrics, profiling, or distributed tracing data). Unlike the "log" feature,//! libraries generally should **not** enable the "log-always" feature, as doing//! so will prevent applications from being able to opt out of the `log` records.//! See [here][flags] for more details on this crate's feature flags.//! The generated `log` records' messages will be a string representation of the//! span or event's fields, and all additional information recorded by `log`//! (target, verbosity level, module path, file, and line number) will also be//! populated. Additionally, `log` records are also generated when spans are//! entered, exited, and closed. Since these additional span lifecycle logs have//! the potential to be very verbose, and don't include additional fields, they//! will always be emitted at the `Trace` level, rather than inheriting the//! level of the span that generated them. Furthermore, they are are categorized//! under a separate `log` target, "tracing::span" (and its sub-target,//! "tracing::span::active", for the logs on entering and exiting a span), which//! may be enabled or disabled separately from other `log` records emitted by//! `tracing`.//! ### Consuming `log` Records//! The [`tracing-log`] crate provides a compatibility layer which//! allows a `tracing` [`Subscriber`] to consume `log` records as though they//! were `tracing` [events]. This allows applications using `tracing` to record//! the logs emitted by dependencies using `log` as events within the context of//! the application's trace tree. See [that crate's documentation][log-tracer]//! for details.//! [log-tracer]: https://docs.rs/tracing-log/latest/tracing_log/#convert-log-records-to-tracing-events//! In addition to `tracing` and `tracing-core`, the [`tokio-rs/tracing`] repository//! contains several additional crates designed to be used with the `tracing` ecosystem.//! This includes a collection of `Subscriber` implementations, as well as utility//! and adapter crates to assist in writing `Subscriber`s and instrumenting//! applications.//! In particular, the following crates are likely to be of interest://!  - [`tracing-futures`] provides a compatibility layer with the `futures`//!    crate, allowing spans to be attached to `Future`s, `Stream`s, and `Executor`s.//!  - [`tracing-subscriber`] provides `Subscriber` implementations and//!    utilities for working with `Subscriber`s. This includes a [`FmtSubscriber`]//!    `FmtSubscriber` for logging formatted trace data to stdout, with similar//!    filtering and formatting to the [`env_logger`] crate.//!  - [`tracing-log`] provides a compatibility layer with the [`log`] crate,//!    allowing log messages to be recorded as `tracing` `Event`s within the//!    trace tree. This is useful when a project using `tracing` have//!    dependencies which use `log`. Note that if you're using//!    `tracing-subscriber`'s `FmtSubscriber`, you don't need to depend on//!    `tracing-log` directly.//!  - [`tracing-appender`] provides utilities for outputting tracing data,//!     including a file appender and non blocking writer.//! Additionally, there are also several third-party crates which are not//! maintained by the `tokio` project. These include://!  - [`tracing-timing`] implements inter-event timing metrics on top of `tracing`.//!    It provides a subscriber that records the time elapsed between pairs of//!    `tracing` events and generates histograms.//!  - [`tracing-opentelemetry`] provides a subscriber for emitting traces to//!    [OpenTelemetry]-compatible distributed tracing systems.//!  - [`tracing-honeycomb`] Provides a layer that reports traces spanning multiple machines to [honeycomb.io]. Backed by [`tracing-distributed`].//!  - [`tracing-distributed`] Provides a generic implementation of a layer that reports traces spanning multiple machines to some backend.//!  - [`tracing-actix-web`] provides `tracing` integration for the `actix-web` web framework.//!  - [`tracing-actix`] provides `tracing` integration for the `actix` actor//!    framework.//!  - [`axum-insights`] provides `tracing` integration and Application insights export for the `axum` web framework.//!  - [`tracing-gelf`] implements a subscriber for exporting traces in Greylog//!    GELF format.//!  - [`tracing-coz`] provides integration with the [coz] causal profiler//!    (Linux-only).//!  - [`tracing-bunyan-formatter`] provides a layer implementation that reports events and spans//!    in [bunyan] format, enriched with timing information.//!  - [`tracing-wasm`] provides a `Subscriber`/`Layer` implementation that reports//!    events and spans via browser `console.log` and [User Timing API (`window.performance`)].//!  - [`tracing-web`] provides a layer implementation of level-aware logging of events//!    to web browsers' `console.*` and span events to the [User Timing API (`window.performance`)].//!  - [`tide-tracing`] provides a [tide] middleware to trace all incoming requests and responses.//!  - [`test-log`] takes care of initializing `tracing` for tests, based on//!    environment variables with an `env_logger` compatible syntax.//!  - [`tracing-unwrap`] provides convenience methods to report failed unwraps//!    on `Result` or `Option` types to a `Subscriber`.//!  - [`diesel-tracing`] provides integration with [`diesel`] database connections.//!  - [`tracing-tracy`] provides a way to collect [Tracy] profiles in instrumented//!    applications.//!  - [`tracing-elastic-apm`] provides a layer for reporting traces to [Elastic APM].//!  - [`tracing-etw`] provides a layer for emitting Windows [ETW] events.//!  - [`tracing-fluent-assertions`] provides a fluent assertions-style testing//!    framework for validating the behavior of `tracing` spans.//!  - [`sentry-tracing`] provides a layer for reporting events and traces to [Sentry].//!  - [`tracing-forest`] provides a subscriber that preserves contextual coherence by//!    grouping together logs from the same spans during writing.//!  - [`tracing-loki`] provides a layer for shipping logs to [Grafana Loki].//!  - [`tracing-logfmt`] provides a layer that formats events and spans into the logfmt format.//!  - [`reqwest-tracing`] provides a middleware to trace [`reqwest`] HTTP requests.//!  - [`tracing-cloudwatch`] provides a layer that sends events to AWS CloudWatch Logs.//!  - [`clippy-tracing`] provides a tool to add, remove and check for `tracing::instrument`.//!  - [`json-subscriber`] provides a subscriber for emitting JSON logs. The output can be customized much more than with [`tracing-subscriber`]'s JSON output.//! If you're the maintainer of a `tracing` ecosystem crate not listed above,//! please let us know! We'd love to add your project to the list!//! [`tracing-opentelemetry`]: https://crates.io/crates/tracing-opentelemetry//! [OpenTelemetry]: https://opentelemetry.io///! [`tracing-honeycomb`]: https://crates.io/crates/tracing-honeycomb//! [`tracing-distributed`]: https://crates.io/crates/tracing-distributed//! [honeycomb.io]: https://www.honeycomb.io///! [`tracing-actix-web`]: https://crates.io/crates/tracing-actix-web//! [`tracing-actix`]: https://crates.io/crates/tracing-actix//! [`axum-insights`]: https://crates.io/crates/axum-insights//! [`tracing-gelf`]: https://crates.io/crates/tracing-gelf//! [`tracing-coz`]: https://crates.io/crates/tracing-coz//! [coz]: https://github.com/plasma-umass/coz//! [`tracing-bunyan-formatter`]: https://crates.io/crates/tracing-bunyan-formatter//! [bunyan]: https://github.com/trentm/node-bunyan//! [`tracing-wasm`]: https://docs.rs/tracing-wasm//! [`tracing-web`]: https://docs.rs/tracing-web//! [User Timing API (`window.performance`)]: https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API//! [`tide-tracing`]: https://crates.io/crates/tide-tracing//! [tide]: https://crates.io/crates/tide//! [`test-log`]: https://crates.io/crates/test-log//! [`tracing-unwrap`]: https://docs.rs/tracing-unwrap//! [`diesel`]: https://crates.io/crates/diesel//! [`diesel-tracing`]: https://crates.io/crates/diesel-tracing//! [`tracing-tracy`]: https://crates.io/crates/tracing-tracy//! [Tracy]: https://github.com/wolfpld/tracy//! [`tracing-elastic-apm`]: https://crates.io/crates/tracing-elastic-apm//! [Elastic APM]: https://www.elastic.co/apm//! [`tracing-etw`]: https://github.com/microsoft/rust_win_etw/tree/main/win_etw_tracing//! [ETW]: https://docs.microsoft.com/en-us/windows/win32/etw/about-event-tracing//! [`tracing-fluent-assertions`]: https://crates.io/crates/tracing-fluent-assertions//! [`sentry-tracing`]: https://crates.io/crates/sentry-tracing//! [Sentry]: https://sentry.io/welcome///! [`tracing-forest`]: https://crates.io/crates/tracing-forest//! [`tracing-loki`]: https://crates.io/crates/tracing-loki//! [Grafana Loki]: https://grafana.com/oss/loki///! [`tracing-logfmt`]: https://crates.io/crates/tracing-logfmt//! [`reqwest-tracing`]: https://crates.io/crates/reqwest-tracing//! [`reqwest`]: https://crates.io/crates/reqwest//! [`tracing-cloudwatch`]: https://crates.io/crates/tracing-cloudwatch//! [`clippy-tracing`]: https://crates.io/crates/clippy-tracing//! [`json-subscriber`]: https://crates.io/crates/json-subscriber//!     <strong>Note</strong>: Some of these ecosystem crates are currently//!     unreleased and/or in earlier stages of development. They may be less stable//!     than <code>tracing</code> and <code>tracing-core</code>.//! ## Crate Feature Flags//! The following crate [feature flags] are available://! * A set of features controlling the [static verbosity level].//! * `log`: causes trace instrumentation points to emit [`log`] records as well//!   as trace events, if a default `tracing` subscriber has not been set. This//!   is intended for use in libraries whose users may be using either `tracing`//!   or `log`.//! * `log-always`: Emit `log` records from all `tracing` spans and events, even//!   if a `tracing` subscriber has been set. This should be set only by//!   applications which intend to collect traces and logs separately; if an//!   adapter is used to convert `log` records into `tracing` events, this will//!   cause duplicate events to occur.//! * `attributes`: Includes support for the `#[instrument]` attribute.//!   This is on by default, but does bring in the `syn` crate as a dependency,//!   which may add to the compile time of crates that do not already use it.//! * `std`: Depend on the Rust standard library (enabled by default).//!   `no_std` users may disable this feature with `default-features = false`://!   ```toml//!   [dependencies]//!   tracing = { version = "0.1.38", default-features = false }//!     <strong>Note</strong>: <code>tracing</code>'s <code>no_std</code> support//!     requires <code>liballoc</code>.//! ### Unstable Features//! These feature flags enable **unstable** features. The public API may break in 0.1.x//! releases. To enable these features, the `--cfg tracing_unstable` must be passed to//! `rustc` when compiling.//! The following unstable feature flags are currently available://! * `valuable`: Enables support for recording [field values] using the//!   [`valuable`] crate.//! #### Enabling Unstable Features//! The easiest way to set the `tracing_unstable` cfg is to use the `RUSTFLAGS`//! env variable when running `cargo` commands://! ```shell//! RUSTFLAGS="--cfg tracing_unstable" cargo build//! Alternatively, the following can be added to the `.cargo/config` file in a//! project to automatically enable the cfg flag for that project://! rustflags = ["--cfg", "tracing_unstable"]//! [field values]: crate::field//! Tracing is built against the latest stable release. The minimum supported//! version is 1.63. The current Tracing version is not guaranteed to build on//! Rust versions earlier than the minimum supported version.//! Tracing follows the same compiler support policies as the rest of the Tokio//! project. The current stable Rust compiler and the three most recent minor//! versions before it will always be supported. For example, if the current//! stable compiler version is 1.69, the minimum supported version will not be//! increased past 1.66, three minor versions prior. Increasing the minimum//! supported compiler version is not considered a semver breaking change as//! long as doing so complies with this policy.//! [`log`]: https://docs.rs/log/0.4.6/log///! [span]: mod@span//! [spans]: mod@span//! [`Span`]: span::Span//! [`in_scope`]: span::Span::in_scope//! [event]: Event//! [events]: Event//! [`Subscriber`]: subscriber::Subscriber//! [Subscriber::event]: subscriber::Subscriber::event//! [`enter`]: subscriber::Subscriber::enter//! [`exit`]: subscriber::Subscriber::exit//! [`enabled`]: subscriber::Subscriber::enabled//! [metadata]: Metadata//! [`field::display`]: field::display//! [`field::debug`]: field::debug//! [`set_global_default`]: subscriber::set_global_default//! [`with_default`]: subscriber::with_default//! [`tokio-rs/tracing`]: https://github.com/tokio-rs/tracing//! [`tracing-futures`]: https://crates.io/crates/tracing-futures//! [`tracing-subscriber`]: https://crates.io/crates/tracing-subscriber//! [`tracing-log`]: https://crates.io/crates/tracing-log//! [`tracing-timing`]: https://crates.io/crates/tracing-timing//! [`tracing-appender`]: https://crates.io/crates/tracing-appender//! [`env_logger`]: https://crates.io/crates/env_logger//! [`FmtSubscriber`]: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/fmt/struct.Subscriber.html//! [static verbosity level]: level_filters#compile-time-filters//! [instrument]: https://docs.rs/tracing-attributes/latest/tracing_attributes/attr.instrument.html//! [flags]: #crate-feature-flags/// Constructs a new span./// See [the top-level documentation][lib] for details on the syntax accepted by/// this macro./// [lib]: crate#using-the-macros/// Creating a new span:/// # use tracing::{span, Level};/// let span = span!(Level::TRACE, "my span");/// // do work inside the span.../// Constructs a span at the trace level./// [Fields] and [attributes] are set using the same syntax as the [`span!`]/// [attributes]: crate#configuring-attributes/// [Fields]: crate#recording-fields/// [`span!`]: crate::span!/// # use tracing::{trace_span, span, Level};/// trace_span!("my_span");/// // is equivalent to:/// span!(Level::TRACE, "my_span");/// let span = trace_span!("my span");/// span.in_scope(|| {///     // do work inside the span.../// Constructs a span at the debug level./// # use tracing::{debug_span, span, Level};/// debug_span!("my_span");/// span!(Level::DEBUG, "my_span");/// # use tracing::debug_span;/// let span = debug_span!("my span");/// Constructs a span at the info level./// # use tracing::{span, info_span, Level};/// info_span!("my_span");/// span!(Level::INFO, "my_span");/// # use tracing::info_span;/// let span = info_span!("my span");/// Constructs a span at the warn level./// # use tracing::{warn_span, span, Level};/// warn_span!("my_span");/// span!(Level::WARN, "my_span");/// use tracing::warn_span;/// let span = warn_span!("my span");/// Constructs a span at the error level./// # use tracing::{span, error_span, Level};/// error_span!("my_span");/// span!(Level::ERROR, "my_span");/// # use tracing::error_span;/// let span = error_span!("my span");// Name / target / parent.// Name / target.// Target / parent.// Name / parent.// Name.// Target.// Parent./// Constructs a new `Event`./// The event macro is invoked with a `Level` and up to 32 key-value fields./// Optionally, a format string and arguments may follow the fields; this will/// be used to construct an implicit field named "message"./// use tracing::{event, Level};/// let data = (42, "forty-two");/// let error = "a bad error";/// event!(Level::ERROR, %error, "Received error");/// event!(///     target: "app_events",///     Level::WARN,///     private_data,///     ?data,///     "App warning: {}",///     error/// event!(name: "answer", Level::INFO, the_answer = data.0);/// event!(Level::INFO, the_answer = data.0);// /// Note that *unlike `span!`*, `event!` requires a value for all fields. As// /// events are recorded immediately when the macro is invoked, there is no// /// opportunity for fields to be recorded later. A trailing comma on the final// /// field is valid.// /// For example, the following does not compile:// /// ```rust,compile_fail// /// # use tracing::{Level, event};// /// # fn main() {// /// event!(Level::INFO, foo = 5, bad_field, bar = "hello")// /// #}event_enabled/// Tests whether an event with the specified level and target would be enabled./// This is similar to [`enabled!`], but queries the current subscriber specifically for/// an event, whereas [`enabled!`] queries for an event _or_ span./// See the documentation for [`enabled!]` for more details on using this macro./// See also [`span_enabled!`]./// # use tracing::{event_enabled, Level};/// if event_enabled!(target: "my_crate", Level::DEBUG) {///     // some expensive work.../// // simpler/// if event_enabled!(Level::DEBUG) {/// // with fields/// if event_enabled!(Level::DEBUG, foo_field) {/// [`enabled!`]: crate::enabled/// [`span_enabled!`]: crate::span_enabledspan_enabled/// Tests whether a span with the specified level and target would be enabled./// # use tracing::{span_enabled, Level};/// if span_enabled!(target: "my_crate", Level::DEBUG) {/// if span_enabled!(Level::DEBUG) {/// if span_enabled!(Level::DEBUG, foo_field) {// Just target and level// These four cases handle fields with no values// Level and field case// Simplest `enabled!` case// Fallthrough from above/// Checks whether a span or event is [enabled] based on the provided [metadata]./// [enabled]: crate::Subscriber::enabled/// [metadata]: crate::Metadata/// This macro is a specialized tool: it is intended to be used prior/// to an expensive computation required *just* for that event, but/// *cannot* be done as part of an argument to that event, such as/// when multiple events are emitted (e.g., iterating over a collection/// and emitting an event for each item)./// [Subscribers] can make filtering decisions based all the data included in a/// span or event's [`Metadata`]. This means that it is possible for `enabled!`/// to return a _false positive_ (indicating that something would be enabled/// when it actually would not be) or a _false negative_ (indicating that/// something would be disabled when it would actually be enabled)./// [Subscribers]: crate::subscriber::Subscriber/// [`Metadata`]: crate::metadata::Metadata/// This occurs when a subscriber is using a _more specific_ filter than the/// metadata provided to the `enabled!` macro. Some situations that can result/// in false positives or false negatives include:/// - If a subscriber is using a filter which may enable a span or event based///   on field names, but `enabled!` is invoked without listing field names,///   `enabled!` may return a false negative if a specific field name would///   cause the subscriber to enable something that would otherwise be disabled./// - If a subscriber is using a filter which enables or disables specific events by///   file path and line number,  a particular event may be enabled/disabled///   even if an `enabled!` invocation with the same level, target, and fields///   indicated otherwise./// - The subscriber can choose to enable _only_ spans or _only_ events, which `enabled`///   will not reflect./// `enabled!()` requires a [level](crate::Level) argument, an optional `target:`/// argument, and an optional set of field names. If the fields are not provided,/// they are considered to be unknown. `enabled!` attempts to match the/// syntax of `event!()` as closely as possible, which can be seen in the/// examples below./// If the current subscriber is interested in recording `DEBUG`-level spans and/// events in the current file and module path, this will evaluate to true:/// use tracing::{enabled, Level};/// if enabled!(Level::DEBUG) {/// If the current subscriber is interested in recording spans and events/// in the current file and module path, with the target "my_crate", and at the/// level  `DEBUG`, this will evaluate to true:/// # use tracing::{enabled, Level};/// if enabled!(target: "my_crate", Level::DEBUG) {/// in the current file and module path, with the target "my_crate", at/// the level `DEBUG`, and with a field named "hello", this will evaluate/// to true:/// if enabled!(target: "my_crate", Level::DEBUG, hello) {/// `enabled!` queries subscribers with [`Metadata`] where/// [`is_event`] and [`is_span`] both return `false`. Alternatively,/// use [`event_enabled!`] or [`span_enabled!`] to ensure one of these/// [`Metadata`]: crate::Metadata/// [`is_event`]: crate::Metadata::is_event/// [`is_span`]: crate::Metadata::is_span/// Constructs an event at the trace level./// This functions similarly to the [`event!`] macro. See [the top-level/// documentation][lib] for details on the syntax accepted by/// [`event!`]: crate::event!/// use tracing::trace;/// # #[derive(Debug, Copy, Clone)] struct Position { x: f32, y: f32 }/// # impl Position {/// # const ORIGIN: Self = Self { x: 0.0, y: 0.0 };/// # fn dist(&self, other: Position) -> f32 {/// #    let x = (other.x - self.x).exp2(); let y = (self.y - other.y).exp2();/// #    (x + y).sqrt()/// let origin_dist = pos.dist(Position::ORIGIN);/// trace!(position = ?pos, ?origin_dist);/// trace!(///     position = ?pos,///     "x is {} and y is {}",///     if pos.x >= 0.0 { "positive" } else { "negative" },///     if pos.y >= 0.0 { "positive" } else { "negative" }/// trace!(name: "completed", position = ?pos);/// Constructs an event at the debug level./// use tracing::debug;/// # #[derive(Debug)] struct Position { x: f32, y: f32 }/// debug!(?pos.x, ?pos.y);/// debug!(target: "app_events", position = ?pos, "New position");/// debug!(name: "completed", position = ?pos);/// Constructs an event at the info level./// use tracing::info;/// # // this is so the test will still work in no-std mode/// # pub struct Ipv4Addr;/// # impl Ipv4Addr { fn new(o1: u8, o2: u8, o3: u8, o4: u8) -> Self { Self } }/// use tracing::field;/// let conn = Connection { port: 40, speed: 3.20 };/// info!(conn.port, "connected to {:?}", addr);/// info!(///     target: "connection_events",///     ip = ?addr,///     conn.port,///     ?conn.speed,/// info!(name: "completed", "completed connection to {:?}", addr);/// Constructs an event at the warn level./// use tracing::warn;/// let input = &[0x27, 0x45];/// warn!(?input, warning = warn_description);/// warn!(///     target: "input_events",///     warning = warn_description,///     "Received warning for input: {:?}", input,/// warn!(name: "invalid", ?input);/// Constructs an event at the error level./// use tracing::error;/// error!(port, error = %err_info);/// error!(target: "app_events", "App Error: {}", err_info);/// error!({ info = err_info }, "error on port: {}", port);/// error!(name: "invalid_input", "Invalid input: {}", err_info);/// Constructs a new static callsite for a span or event.callsite2level_enabled// TODO: determine if this ought to be public API?`valueset// === base case ===// === recursive case (more tts) ===// TODO(#1138): determine a new syntax for uninitialized span fields, and// re-enable this.// (@{ $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = _, $($rest:tt)*) => {//     $crate::valueset!(@ { $($out),*, (&$next, None) }, $next, $($rest)*)// Handle literal names// Handle constant names// Remainder is unparsable, but exists --- must be format args!// === entry ===fieldset// == base case ==// == recursive cases (more tts) ==// (@ { $($out:expr),* } $($k:ident).+ = _, $($rest:tt)*) => {//     $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)// == entry ==level_to_log__tracing_stringifyif_log_enabledas_id/// Returns the `Id` of the span that `self` corresponds to, or `None` if/// this corresponds to a disabled span.AsId/// Trait implemented by types which have a span `Id`./// A handle used to enter the span when it is not executing./// If this is `None`, then the span has either closed or was never enabled./// Metadata describing the span./// This might be `Some` even if `inner` is `None`, in the case that the/// span is disabled but the metadata is needed for `log` support./// A handle representing a span, with the capability to enter the span if it/// If the span was rejected by the current `Subscriber`'s filter, entering the/// span will silently do nothing. Thus, the handle can be used in the same/// manner regardless of whether or not the trace is currently being collected./// The span's ID, as provided by `subscriber`./// The subscriber that will receive events relating to this span./// This should be the same subscriber that provided this span with its/// `id`./// A handle representing the capacity to enter a span which is known to exist./// Unlike `Span`, this type is only constructed for spans which _have_ been/// enabled by the current filter. This type is primarily used for implementing/// span handles; users should typically not need to interact with it directly."once a span has been entered, it should be exited"/// A guard representing a span which has been entered and is currently/// executing./// When the guard is dropped, the span will be exited./// This is returned by the [`Span::enter`] function./// [`Span::enter`]: super::Span::enterPhantomNotSend/// use tracing::span::*;/// trait AssertSend: Send {}/// impl AssertSend for EnteredSpan {}/// An owned version of [`Entered`], a guard representing a span which has been/// entered and is currently executing./// This is returned by the [`Span::entered`] function./// [`Span::entered`]: super::Span::entered()LIFECYCLE_LOG_TARGET/// `log` target for all span lifecycle (creation/enter/exit/close) records.ACTIVITY_LOG_TARGET/// `log` target for span activity (enter/exit) records./// Constructs a new `Span` with the given [metadata] and set of/// [field values]./// The new span will be constructed by the currently-active [`Subscriber`],/// with the current span as its parent (if one exists)./// After the span is constructed, [field values] and/or [`follows_from`]/// annotations may be added to it./// [metadata]: super::Metadata/// [`Subscriber`]: super::subscriber::Subscriber/// [field values]: super::field::ValueSet/// [`follows_from`]: super::Span::follows_fromnew_root/// Constructs a new `Span` as the root of its own trace tree, with the/// given [metadata] and set of [field values].new_root_withchild_of/// Constructs a new `Span` as child of the given parent span, with thechild_of_withnew_disabled/// Constructs a new disabled span with the given `Metadata`./// This should be used when a span is constructed from a known callsite,/// but the subscriber indicates that it is disabled./// Entering, exiting, and recording values on this span will not notify the/// `Subscriber` but _may_ record log messages if the `log` feature flag is/// Constructs a new span that is *completely disabled*./// This can be used rather than `Option<Span>` to represent cases where a/// span is not present./// Entering, exiting, and recording values on this span will do nothing./// Returns a handle to the span [considered by the `Subscriber`] to be the/// current span./// If the subscriber indicates that it does not track the current span, or/// that the thread from which this function is called is not currently/// inside a span, the returned span will be disabled./// [considered by the `Subscriber`]:///     super::subscriber::Subscriber::current_spanmake_with/// Enters this span, returning a guard that will exit the span when dropped./// If this span is enabled by the current subscriber, then this function will/// call [`Subscriber::enter`] with the span's [`Id`], and dropping the guard/// will call [`Subscriber::exit`]. If the span is disabled, this does/// # In Asynchronous Code/// **Warning**: in asynchronous code that uses [async/await syntax][syntax],/// `Span::enter` should be used very carefully or avoided entirely. Holding/// the drop guard returned by `Span::enter` across `.await` points will/// result in incorrect traces. For example,/// # async fn some_other_async_function() {}/// async fn my_async_function() {///     let span = info_span!("my_async_function");///     // WARNING: This span will remain entered until this///     // guard is dropped...///     let _enter = span.enter();///     // ...but the `await` keyword may yield, causing the///     // runtime to switch to another task, while remaining in///     // this span!///     some_other_async_function().await/// The drop guard returned by `Span::enter` exits the span when it is/// dropped. When an async function or async block yields at an `.await`/// point, the current scope is _exited_, but values in that scope are/// **not** dropped (because the async block will eventually resume/// execution from that await point). This means that _another_ task will/// begin executing while _remaining_ in the entered span. This results in/// an incorrect trace./// Instead of using `Span::enter` in asynchronous code, prefer the/// * To enter a span for a synchronous section of code within an async///   block or function, prefer [`Span::in_scope`]. Since `in_scope` takes a///   synchronous closure and exits the span when the closure returns, the///   span will always be exited before the next await point. For example:///   # use tracing::info_span;///   # async fn some_other_async_function(_: ()) {}///   async fn my_async_function() {///       let span = info_span!("my_async_function");///       let some_value = span.in_scope(|| {///           // run some synchronous code inside the span...///       });///       // This is okay! The span has already been exited before we reach///       // the await point.///       some_other_async_function(some_value).await;/// * For instrumenting asynchronous code, `tracing` provides the///   [`Future::instrument` combinator][instrument] for///   attaching a span to a future (async function or block). This will///   enter the span _every_ time the future is polled, and exit it whenever///   the future yields.///   `Instrument` can be used with an async block inside an async function:///   ```ignore///   use tracing::Instrument;///   # async fn some_other_async_function() {}///       async move {///          // This is correct! If we yield here, the span will be exited,///          // and re-entered when we resume.///          some_other_async_function().await;///          //more asynchronous code inside the span...///         // instrument the async block with the span...///         .instrument(span)///         // ...and await it.///   It can also be used to instrument calls to async functions at the///   callsite:///   # use tracing::debug_span;///       let some_value = some_other_async_function()///          .instrument(debug_span!("some_other_async_function"))///          .await;/// * The [`#[instrument]` attribute macro][attr] can automatically generate///   correct code when used on an async function:///   #[tracing::instrument(level = "info")]///       // This is correct! If we yield here, the span will be exited,///       // and re-entered when we resume.///       some_other_async_function().await;/// [syntax]: https://rust-lang.github.io/async-book/01_getting_started/04_async_await_primer.html/// [`Span::in_scope`]: Span::in_scope()/// [instrument]: crate::Instrument/// [attr]: macro@crate::instrument/// let span = span!(Level::INFO, "my_span");/// let guard = span.enter();/// // code here is within the span/// // code here is no longer within the span/// Guards need not be explicitly dropped:/// # use tracing::trace_span;/// fn my_function() -> String {///     // enter a span for the duration of this function.///     let span = trace_span!("my_function");///     // anything happening in functions we call is still inside the span...///     my_other_function();///     // returning from the function drops the guard, exiting the span.///     return "Hello world".to_owned();/// fn my_other_function() {/// Sub-scopes may be created to limit the duration for which the span is/// entered:/// # use tracing::{info, info_span};/// let span = info_span!("my_great_span");///     // this event occurs inside the span.///     info!("i'm in the span!");///     // exiting the scope drops the guard, exiting the span./// // this event is not inside the span./// info!("i'm outside the span!")/// [`Subscriber::enter`]: super::subscriber::Subscriber::enter()/// [`Subscriber::exit`]: super::subscriber::Subscriber::exit()/// [`Id`]: super::Id/// Enters this span, consuming it and returning a [guard][`EnteredSpan`]/// that will exit the span when dropped./// <pre class="compile_fail" style="white-space:normal;font:inherit;">///     <strong>Warning</strong>: In asynchronous code that uses async/await syntax,///     <code>Span::entered</code> may produce incorrect traces if the returned drop///     guard is held across an await point. See <a href="#in-asynchronous-code">the///     <code>Span::enter</code> documentation</a> for details./// This is similar to the [`Span::enter`] method, except that it moves the/// span by value into the returned guard, rather than borrowing it./// Therefore, this method can be used to create and enter a span in a/// single expression, without requiring a `let`-binding. For example:/// let _span = info_span!("something_interesting").entered();/// rather than:/// let span = info_span!("something_interesting");/// let _e = span.enter();/// Furthermore, `entered` may be used when the span must be stored in some/// other struct or be passed to a function while remaining entered.///     <strong>Note</strong>: The returned <a href="../struct.EnteredSpan.html">///     <code>EnteredSpan</code></a> guard does not implement <code>Send</code>.///     Dropping the guard will exit <em>this</em> span, and if the guard is sent///     to another thread and dropped there, that thread may never have entered///     this span. Thus, <code>EnteredSpan</code>s should not be sent between threads./// The returned guard can be [explicitly exited][EnteredSpan::exit],/// returning the un-entered span:/// # use tracing::{Level, span};/// let span = span!(Level::INFO, "doing_something").entered();/// // explicitly exit the span, returning it/// let span = span.exit();/// // enter the span again/// let span = span.entered();/// // now we are inside the span once again///     let span = trace_span!("my_function").entered();/// Since the [`EnteredSpan`] guard can dereference to the [`Span`] itself,/// the span may still be accessed while entered. For example:/// // create the span with an empty field, and enter it./// let span = info_span!("my_span", some_field = field::Empty).entered();/// // we can still record a value for the field while the span is entered./// span.record("some_field", &"hello world!");or_current/// Returns this span, if it was [enabled] by the current [`Subscriber`], or/// the [current span] (whose lexical distance may be further than expected),///  if this span [is disabled]./// This method can be useful when propagating spans to spawned threads or/// [async tasks]. Consider the following:/// let _parent_span = tracing::info_span!("parent").entered();/// let child_span = tracing::debug_span!("child");///     let _entered = child_span.entered();///     tracing::info!("spawned a thread!");/// If the current [`Subscriber`] enables the [`DEBUG`] level, then both/// the "parent" and "child" spans will be enabled. Thus, when the "spawaned/// a thread!" event occurs, it will be inside of the "child" span. Because/// "parent" is the parent of "child", the event will _also_ be inside of/// "parent"./// However, if the [`Subscriber`] only enables the [`INFO`] level, the "child"/// span will be disabled. When the thread is spawned, the/// `child_span.entered()` call will do nothing, since "child" is not/// enabled. In this case, the "spawned a thread!" event occurs outside of/// *any* span, since the "child" span was responsible for propagating its/// parent to the spawned thread./// If this is not the desired behavior, `Span::or_current` can be used to/// ensure that the "parent" span is propagated in both cases, either as a/// parent of "child" _or_ directly. For example:/// // If DEBUG is enabled, then "child" will be enabled, and `or_current`/// // returns "child". Otherwise, if DEBUG is not enabled, "child" will be/// // disabled, and `or_current` returns "parent"./// let child_span = tracing::debug_span!("child").or_current();/// When spawning [asynchronous tasks][async tasks], `Span::or_current` can/// be used similarly, in combination with [`instrument`]:/// # // lol///     async {///         tracing::info!("spawned a task!");///     }.instrument(child_span.or_current())/// In general, `or_current` should be preferred over nesting an/// [`instrument`]  call inside of an [`in_current_span`] call, as using/// `or_current` will be more efficient./// // Do this:///     my_async_fn().instrument(tracing::debug_span!("child").or_current())/// // ...rather than this:///     my_async_fn()///         .instrument(tracing::debug_span!("child"))///         .in_current_span()/// [`Subscriber`]: crate::Subscriber/// [current span]: Span::current/// [is disabled]: Span::is_disabled/// [`INFO`]: crate::Level::INFO/// [`DEBUG`]: crate::Level::DEBUG/// [async tasks]: std::task/// [`instrument`]: crate::instrument::Instrument::instrument/// [`in_current_span`]: crate::instrument::Instrument::in_current_spando_enterdo_exit// Called from [`Entered`] and [`EnteredSpan`] drops.// Running this behaviour on drop rather than with an explicit function// call means that spans may still be exited when unwinding.in_scope/// Executes the given function in the context of this span./// If this span is enabled, then this function enters the span, invokes `f`/// and then exits the span. If the span is disabled, `f` will still be/// invoked, but in the context of the currently-executing span (if there is/// Returns the result of evaluating `f`./// # use tracing::{trace, span, Level};/// let my_span = span!(Level::TRACE, "my_span");/// my_span.in_scope(|| {///     // this event occurs within the span.///     trace!("i'm in the span!");/// // this event occurs outside the span./// trace!("i'm not in the span!");/// Calling a function and returning the result:/// # use tracing::{info_span, Level};/// fn hello_world() -> String {///     "Hello world!".to_owned()/// let span = info_span!("hello_world");/// // the span will be entered for the duration of the call to/// // `hello_world`./// let a_string = span.in_scope(hello_world);/// Returns a [`Field`][super::field::Field] for the field with the/// given `name`, if one exists,/// Returns true if this `Span` has a field for the given/// [`Field`][super::field::Field] or field name./// Records that the field described by `field` has the value `value`./// This may be used with [`field::Empty`] to declare fields whose values/// are not known when the span is created, and record them later:/// use tracing::{trace_span, field};/// // Create a span with two fields: `greeting`, with the value "hello world", and/// // `parting`, without a value./// let span = trace_span!("my_span", greeting = "hello world", parting = field::Empty);/// // Now, record a value for parting as well./// // (note that the field name is passed as a string slice)/// span.record("parting", "goodbye world!");/// However, it may also be used to record a _new_ value for a field whose/// value was already recorded:/// use tracing::info_span;/// # fn do_something() -> Result<(), ()> { Err(()) }/// // Initially, let's assume that our attempt to do something is going okay.../// let span = info_span!("doing_something", is_okay = true);/// match do_something() {///     Ok(something) => {///     Err(_) => {///         // Things are no longer okay!///         span.record("is_okay", false);///     <strong>Note</strong>: The fields associated with a span are part///     of its <a href="../struct.Metadata.html"><code>Metadata</code></a>.///     The <a href="../struct.Metadata.html"><code>Metadata</code></a>///     describing a particular span is constructed statically when the span///     is created and cannot be extended later to add new fields. Therefore,///     you cannot record a value for a field that was not specified when the///     span was created:/// // Now, you try to record a value for a new field, `new_field`, which was not/// // declared as `Empty` or populated when you created `span`./// // You won't get any error, but the assignment will have no effect!/// span.record("new_field", "interesting_value_you_really_need");/// // Instead, all fields that may be recorded after span creation should be declared up front,/// // using field::Empty when a value is not known, as we did for `parting`./// // This `record` call will indeed replace field::Empty with "you will be remembered"./// span.record("parting", "you will be remembered");/// [`field::Empty`]: super::field::Empty/// [`Metadata`]: super::Metadatarecord_all/// Records all the fields in the provided `ValueSet`./// Returns `true` if this span was disabled by the subscriber and does not/// See also [`is_none`]./// [`is_none`]: Span::is_none()/// Returns `true` if this span was constructed by [`Span::none`] and is/// If `is_none` returns `true` for a given span, then [`is_disabled`] will/// also return `true`. However, when a span is disabled by the subscriber/// rather than constructed by `Span::none`, this method will return/// `false`, while `is_disabled` will return `true`./// [`Span::none`]: Span::none()/// [`is_disabled`]: Span::is_disabled()follows_from/// Indicates that the span with the given ID has an indirect causal/// relationship with this span./// This relationship differs somewhat from the parent-child relationship: a/// span may have any number of prior spans, rather than a single one; and/// spans are not considered to be executing _inside_ of the spans they/// follow from. This means that a span may close even if subsequent spans/// that follow from it are still open, and time spent inside of a/// subsequent span should not be included in the time its precedents were/// executing. This is used to model causal relationships such as when a/// single future spawns several related background tasks, et cetera./// If this span is disabled, or the resulting follows-from relationship/// would be invalid, this function will do nothing./// Setting a `follows_from` relationship with a `Span`:/// # use tracing::{span, Id, Level, Span};/// let span1 = span!(Level::INFO, "span_1");/// let span2 = span!(Level::DEBUG, "span_2");/// span2.follows_from(span1);/// Setting a `follows_from` relationship with the current span:/// let span = span!(Level::INFO, "hello!");/// span.follows_from(Span::current());/// Setting a `follows_from` relationship with a `Span` reference:/// let curr = Span::current();/// span.follows_from(&curr);/// Setting a `follows_from` relationship with an `Id`:/// let id = span.id();/// span.follows_from(id);/// Returns this span's `Id`, if it is enabled./// Returns this span's `Metadata`, if it is enabled./// Invokes a function with a reference to this span's ID and subscriber./// if this span is enabled, the provided function is called, and the result is returned./// If the span is disabled, the function is not called, and this method returns `None`/// If this span is disabled, this function will do nothing. Otherwise, it/// returns `Ok(())` if the other span was added as a precedent of this/// span, or an error if this was not possible./// Returns the span's ID./// Exits this span, returning the underlying [`Span`]./// Technically, `EnteredSpan` _can_ implement both `Send` *and*/// `Sync` safely. It doesn't, because it has a `PhantomNotSend` field,/// specifically added in order to make it `!Send`./// Sending an `EnteredSpan` guard between threads cannot cause memory unsafety./// However, it *would* result in incorrect behavior, so we add a/// `PhantomNotSend` to prevent it from being sent between threads. This is/// because it must be *dropped* on the same thread that it was created;/// otherwise, the span will never be exited on the thread where it was entered,/// and it will attempt to exit the span on a thread that may never have entered/// it. However, we still want them to be `Sync` so that a struct holding an/// `Entered` guard can be `Sync`./// Thus, this is totally safe./// Trivially safe, as `PhantomNotSend` doesn't have any API.test_record_backwards_compat//! Spans represent periods of time in which a program was executing in a//! particular context.//! A span consists of [fields], user-defined key-value pairs of arbitrary data//! that describe the context the span represents, and a set of fixed attributes//! that describe all `tracing` spans and events. Attributes describing spans//! include://! - An [`Id`] assigned by the subscriber that uniquely identifies it in relation//!   to other spans.//! - The span's [parent] in the trace tree.//! - [Metadata] that describes static characteristics of all spans//!   originating from that callsite, such as its name, source code location,//!   [verbosity level], and the names of its fields.//! # Creating Spans//! Spans are created using the [`span!`] macro. This macro is invoked with the//! following arguments, in order://! - The [`target`] and/or [`parent`][parent] attributes, if the user wishes to//!   override their default values.//! - The span's [verbosity level]//! - A string literal providing the span's name.//! - Finally, zero or more arbitrary key/value fields.//! [`target`]: super::Metadata::target//! /// Construct a new span at the `INFO` level named "my_span", with a single//! /// field named answer , with the value `42`.//! let my_span = span!(Level::INFO, "my_span", answer = 42);//! The documentation for the [`span!`] macro provides additional examples of//! the various options that exist when creating spans.//! The [`trace_span!`], [`debug_span!`], [`info_span!`], [`warn_span!`], and//! [`error_span!`] exist as shorthand for constructing spans at various//! verbosity levels.//! ## Recording Span Creation//! The [`Attributes`] type contains data associated with a span, and is//! provided to the [`Subscriber`] when a new span is created. It contains//! the span's metadata, the ID of [the span's parent][parent] if one was//! explicitly set, and any fields whose values were recorded when the span was//! constructed. The subscriber, which is responsible for recording `tracing`//! data, can then store or record these values.//! # The Span Lifecycle//! ## Entering a Span//! A thread of execution is said to _enter_ a span when it begins executing,//! and _exit_ the span when it switches to another context. Spans may be//! entered through the [`enter`], [`entered`], and [`in_scope`] methods.//! The [`enter`] method enters a span, returning a [guard] that exits the span//! when dropped//! let my_var: u64 = 5;//! let my_span = span!(Level::TRACE, "my_span", my_var);//! // `my_span` exists but has not been entered.//! // Enter `my_span`...//! let _enter = my_span.enter();//! // Perform some work inside of the context of `my_span`...//! // Dropping the `_enter` guard will exit the span.//!     <strong>Warning</strong>: In asynchronous code that uses async/await syntax,//!     <code>Span::enter</code> may produce incorrect traces if the returned drop//!     guard is held across an await point. See//!     <a href="struct.Span.html#in-asynchronous-code">the method documentation</a>//!     for details.//! The [`entered`] method is analogous to [`enter`], but moves the span into//! the returned guard, rather than borrowing it. This allows creating and//! entering a span in a single expression://! // Create a span and enter it, returning a guard://! let span = span!(Level::INFO, "my_span").entered();//! // We are now inside the span! Like `enter()`, the guard returned by//! // `entered()` will exit the span when it is dropped...//! // ...but, it can also be exited explicitly, returning the `Span`//! // struct://! let span = span.exit();//! Finally, [`in_scope`] takes a closure or function pointer and executes it//! inside the span://! let my_span = span!(Level::TRACE, "my_span", my_var = &my_var);//! my_span.in_scope(|| {//!     // perform some work in the context of `my_span`...//! // Perform some work outside of the context of `my_span`...//!     // Perform some more work in the context of `my_span`.//!     <strong>Note</strong>: Since entering a span takes <code>&self</code>, and//!     <code>Span</code>s are <code>Clone</code>, <code>Send</code>, and//!     <code>Sync</code>, it is entirely valid for multiple threads to enter the//!     same span concurrently.//! ## Span Relationships//! Spans form a tree structure — unless it is a root span, all spans have a//! _parent_, and may have one or more _children_. When a new span is created,//! the current span becomes the new span's parent. The total execution time of//! a span consists of the time spent in that span and in the entire subtree//! represented by its children. Thus, a parent span always lasts for at least//! as long as the longest-executing span in its subtree.//! # use tracing::{Level, span};//! // this span is considered the "root" of a new trace tree://! span!(Level::INFO, "root").in_scope(|| {//!     // since we are now inside "root", this span is considered a child//!     // of "root"://!     span!(Level::DEBUG, "outer_child").in_scope(|| {//!         // this span is a child of "outer_child", which is in turn a//!         // child of "root"://!         span!(Level::TRACE, "inner_child").in_scope(|| {//!             // and so on...//!     // another span created here would also be a child of "root".//! In addition, the parent of a span may be explicitly specified in//! the `span!` macro. For example://! // Create, but do not enter, a span called "foo".//! let foo = span!(Level::INFO, "foo");//! // Create and enter a span called "bar".//! let bar = span!(Level::INFO, "bar");//! let _enter = bar.enter();//! // Although we have currently entered "bar", "baz"'s parent span//! // will be "foo".//! let baz = span!(parent: &foo, Level::INFO, "baz");//! A child span should typically be considered _part_ of its parent. For//! example, if a subscriber is recording the length of time spent in various//! spans, it should generally include the time spent in a span's children as//! part of that span's duration.//! In addition to having zero or one parent, a span may also _follow from_ any//! number of other spans. This indicates a causal relationship between the span//! and the spans that it follows from, but a follower is *not* typically//! considered part of the duration of the span it follows. Unlike the parent, a//! span may record that it follows from another span after it is created, using//! the [`follows_from`] method.//! As an example, consider a listener task in a server. As the listener accepts//! incoming connections, it spawns new tasks that handle those connections. We//! might want to have a span representing the listener, and instrument each//! spawned handler task with its own span. We would want our instrumentation to//! record that the handler tasks were spawned as a result of the listener task.//! However, we might not consider the handler tasks to be _part_ of the time//! spent in the listener task, so we would not consider those spans children of//! the listener span. Instead, we would record that the handler tasks follow//! from the listener, recording the causal relationship but treating the spans//! as separate durations.//! ## Closing Spans//! Execution may enter and exit a span multiple times before that span is//! _closed_. Consider, for example, a future which has an associated//! span and enters that span every time it is polled://! # use std::future::Future;//! # use std::pin::Pin;//! struct MyFuture {//!    // data//!    span: tracing::Span,//! impl Future for MyFuture {//!     fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {//!         let _enter = self.span.enter();//!         // Do actual future work...//! # Poll::Ready(())//! If this future was spawned on an executor, it might yield one or more times//! before `poll` returns [`Poll::Ready`]. If the future were to yield, then//! the executor would move on to poll the next future, which may _also_ enter//! an associated span or series of spans. Therefore, it is valid for a span to//! be entered repeatedly before it completes. Only the time when that span or//! one of its children was the current span is considered to be time spent in//! that span. A span which is not executing and has not yet been closed is said//! to be _idle_.//! Because spans may be entered and exited multiple times before they close,//! [`Subscriber`]s have separate trait methods which are called to notify them//! of span exits and when span handles are dropped. When execution exits a//! span, [`exit`] will always be called with that span's ID to notify the//! subscriber that the span has been exited. When span handles are dropped, the//! [`drop_span`] method is called with that span's ID. The subscriber may use//! this to determine whether or not the span will be entered again.//! If there is only a single handle with the capacity to exit a span, dropping//! that handle "closes" the span, since the capacity to enter it no longer//! exists. For example://!     span!(Level::TRACE, "my_span").in_scope(|| {//!         // perform some work in the context of `my_span`...//!     }); // --> Subscriber::exit(my_span)//!     // The handle to `my_span` only lives inside of this block; when it is//!     // dropped, the subscriber will be informed via `drop_span`.//! } // --> Subscriber::drop_span(my_span)//! However, if multiple handles exist, the span can still be re-entered even if//! one or more is dropped. For determining when _all_ handles to a span have//! been dropped, `Subscriber`s have a [`clone_span`] method, which is called//! every time a span handle is cloned. Combined with `drop_span`, this may be//! used to track the number of handles to a given span — if `drop_span` has//! been called one more time than the number of calls to `clone_span` for a//! given ID, then no more handles to the span with that ID exist. The//! subscriber may then treat it as closed.//! # When to use spans//! As a rule of thumb, spans should be used to represent discrete units of work//! (e.g., a given request's lifetime in a server) or periods of time spent in a//! given context (e.g., time spent interacting with an instance of an external//! system, such as a database).//! Which scopes in a program correspond to new spans depend somewhat on user//! intent. For example, consider the case of a loop in a program. Should we//! construct one span and perform the entire loop inside of that span, like://! # let n = 1;//! let span = span!(Level::TRACE, "my_loop");//! for i in 0..n {//!     # let _ = i;//! Or, should we create a new span for each iteration of the loop, as in://! # let n = 1u64;//!     let span = span!(Level::TRACE, "my_loop", iteration = i);//!     let _enter = span.enter();//! Depending on the circumstances, we might want to do either, or both. For//! example, if we want to know how long was spent in the loop overall, we would//! create a single span around the entire loop; whereas if we wanted to know how//! much time was spent in each individual iteration, we would enter a new span//! on every iteration.//! [fields]: super::field//! [Metadata]: super::Metadata//! [verbosity level]: super::Level//! [`Poll::Ready`]: std::task::Poll::Ready//! [`span!`]: super::span!//! [`trace_span!`]: super::trace_span!//! [`debug_span!`]: super::debug_span!//! [`info_span!`]: super::info_span!//! [`warn_span!`]: super::warn_span!//! [`error_span!`]: super::error_span!//! [`clone_span`]: super::subscriber::Subscriber::clone_span()//! [`drop_span`]: super::subscriber::Subscriber::drop_span()//! [`exit`]: super::subscriber::Subscriber::exit//! [`Subscriber`]: super::subscriber::Subscriber//! [`enter`]: Span::enter()//! [`entered`]: Span::entered()//! [`in_scope`]: Span::in_scope()//! [`follows_from`]: Span::follows_from()//! [guard]: Entered//! [parent]: #span-relationships// ===== impl Span =====// ===== impl Entered =====//! Re-exports either the Rust `std` library or `core` and `alloc` when `std` is//! disabled.//! `crate::stdlib::...` should be used rather than `std::` when adding code that//! will be available with the standard library disabled.//! Note that this module is called `stdlib` rather than `std`, as Rust 1.34.0//! does not permit redefining the name `stdlib` (although this works on the//! latest stable Rust)./// Sets this [`Subscriber`] as the default for the current thread for the/// The default subscriber is used when creating a new [`Span`] or/// [`Event`]./// [`Span`]: super::span::Span/// [`Event`]: super::event::Event/// Sets this subscriber as the global default for the duration of the entire program./// Will be used as a fallback if no thread-local subscriber has been set in a thread (using `with_default`.)/// Can only be set once; subsequent attempts to set the global default will fail./// Returns whether the initialization was successful./// Note: Libraries should *NOT* call `set_global_default()`! That will cause conflicts when/// executables try to set them later./// [span]: super::span"Dropping the guard unregisters the subscriber."/// Sets the [`Subscriber`] as the default for the current thread for the/// duration of the lifetime of the returned [`DefaultGuard`]./// The default subscriber is used when creating a new [`Span`] or [`Event`]./// [`DefaultGuard`]: super::dispatcher::DefaultGuard//! Collects and records trace data.FormatModeEventArgs/// Arguments to `#[instrument(err(...))]` and `#[instrument(ret(...))]` which describe how the/// return value event should be emitted.LitStrOrIdentskip_allerr_argsret_argsparse_warnings/// Errors describing any unrecognized parse inputs that we skipped.InstrumentArgs/// Generate "deprecation" warnings for any unrecognized attribute inputs/// that we skipped./// For backwards compatibility, we need to emit compiler warnings rather/// than errors for unrecognized inputs. Generating a fake deprecation is/// the only way to do this on stable Rust right now.StrArgSkipsMaybeItemFnMaybeItemFnRefgen_function/// Given an existing function, generate an instrumented version of that functiongen_block/// Instrument a blockRecordType/// The field should be recorded using its `Value` implementation./// The field should be recorded using `tracing::field::debug()`./// Indicates whether a field should be recorded as `Value` or `Debug`.TYPES_FOR_VALUE/// Array of primitive types which should be recorded as [RecordType::Value].parse_from_ty/// Parse `RecordType` from [Type] by looking up/// the [RecordType::TYPES_FOR_VALUE] array.param_namesAsyncKind/// Immediately-invoked async fn, as generated by `async-trait <= 0.1.43`:/// `async fn foo<...>(...) {...}; Box::pin(foo<...>(...))`async_exprpinned_box/// A function returning an async (move) block, optionally `Box::pin`-ed,/// as generated by `async-trait >= 0.1.44`:/// `Box::pin(async move { ... })`/// The specific async code pattern that was detectedsource_stmt'block// statement that must be patchedself_typeAsyncInfo/// Get the AST of the inner function we need to hook, if it looks like a/// manual future implementation./// When we are given a function that returns a (pinned) future containing the/// user logic, it is that (pinned) future that needs to be instrumented./// Were we to instrument its parent, we would only collect information/// regarding the allocation of that future, and not its own span of execution./// We inspect the block of the function to find if it matches any of the/// following patterns:/// - Immediately-invoked async fn, as generated by `async-trait <= 0.1.43`:///   `async fn foo<...>(...) {...}; Box::pin(foo<...>(...))`/// - A function returning an async (move) block, optionally `Box::pin`-ed,///   as generated by `async-trait >= 0.1.44`:///   `Box::pin(async move { ... })`/// We the return the statement that must be instrumented, along with some/// other information./// 'gen_body' will then be able to use that information to instrument the/// proper function/future./// (this follows the approach suggested in/// https://github.com/dtolnay/async-trait/issues/45#issuecomment-571245673)gen_asyncpath_to_string// Return a path as a StringidentsIdentAndTypesRenamer/// A visitor struct to replace idents and types in some piece/// of code (e.g. the "self" and "Self" tokens in user-supplied/// fields expressions when the function is generated by an old/// version of async-trait).// we deliberately compare strings because we want to ignore the spans// If we apply clippy's lint, the behavior changespatched_blockAsyncTraitBlockReplacer// A visitor struct that replace an async block by its patched versionImplTraitEraser// Replaces any `impl Trait` with `_` so it can be used as the type in// a `let` statement's LHS.erase_impl_trait/// Instruments a function to create and enter a `tracing` [span] every time/// the function is called./// Unless overridden, a span with the [`INFO`] [level] will be generated./// The generated span's name will be the name of the function./// By default, all arguments to the function are included as fields on the/// span. Arguments that are `tracing` [primitive types] implementing the/// [`Value` trait] will be recorded as fields of that type. Types which do/// not implement `Value` will be recorded using [`fmt::Debug`]./// [primitive types]: https://docs.rs/tracing/latest/tracing/field/trait.Value.html#foreign-impls/// [`Value` trait]: https://docs.rs/tracing/latest/tracing/field/trait.Value.html/// # Overriding Span Attributes/// To change the [name] of the generated span, add a `name` argument to the/// `#[instrument]` macro, followed by an equals sign and a string literal. For/// # use tracing_attributes::instrument;/// // The generated span's name will be "my_span" rather than "my_function"./// #[instrument(name = "my_span")]/// pub fn my_function() {///     // ... do something incredibly interesting and important .../// To override the [target] of the generated span, add a `target` argument to/// the `#[instrument]` macro, followed by an equals sign and a string literal/// for the new target. The [module path] is still recorded separately. For/// pub mod my_module {///     # use tracing_attributes::instrument;///     // The generated span's target will be "my_crate::some_special_target",///     // rather than "my_crate::my_module".///     #[instrument(target = "my_crate::some_special_target")]///     pub fn my_function() {///         // ... all kinds of neat code in here .../// Finally, to override the [level] of the generated span, add a `level`/// argument, followed by an equals sign and a string literal with the name of/// the desired level. Level names are not case sensitive. For example:/// // The span's level will be TRACE rather than INFO./// #[instrument(level = "trace")]///     // ... I have written a truly marvelous implementation of this function,///     // which this example is too narrow to contain .../// # Skipping Fields/// To skip recording one or more arguments to a function or method, pass/// the argument's name inside the `skip()` argument on the `#[instrument]`/// macro. This can be used when an argument to an instrumented function does/// not implement [`fmt::Debug`], or to exclude an argument with a verbose or/// costly `Debug` implementation. Note that:/// - multiple argument names can be passed to `skip`./// - arguments passed to `skip` do _not_ need to implement `fmt::Debug`./// You can also use `skip_all` to skip all arguments./// // This type doesn't implement `fmt::Debug`!/// struct NonDebug;/// // `arg` will be recorded, while `non_debug` will not./// #[instrument(skip(non_debug))]/// fn my_function(arg: usize, non_debug: NonDebug) {/// // These arguments are huge/// #[instrument(skip_all)]/// fn my_big_data_function(large: Vec<u8>, also_large: HashMap<String, String>) {/// Skipping the `self` parameter:/// struct MyType {///    data: Vec<u8>, // Suppose this buffer is often quite long.../// impl MyType {///     // Suppose we don't want to print an entire kilobyte of `data`///     // every time this is called...///     #[instrument(skip(self))]///     pub fn my_method(&mut self, an_interesting_argument: usize) {///          // ... do something (hopefully, using all that `data`!)/// # Adding Fields/// Additional fields (key-value pairs with arbitrary data) can be passed to/// to the generated span through the `fields` argument on the/// `#[instrument]` macro. Strings, integers or boolean literals are accepted values/// for each field. The name of the field must be a single valid Rust/// identifier, nested (dotted) field names are not supported. Any/// Rust expression can be used as a field value in this manner. These/// expressions will be evaluated at the beginning of the function's body, so/// arguments to the function may be used in these expressions. Field names may/// also be specified *without* values. Doing so will result in an [empty field]/// whose value may be recorded later within the function body./// Note that overlap between the names of fields and (non-skipped) arguments/// will result in a compile error./// Adding a new field based on the value of an argument:/// // This will record a field named "i" with the value of `i` *and* a field/// // named "next" with the value of `i` + 1./// #[instrument(fields(next = i + 1))]/// pub fn my_function(i: usize) {/// Recording specific properties of a struct as their own fields:/// # mod http {/// #   pub struct Error;/// #   pub struct Response<B> { pub(super) _b: std::marker::PhantomData<B> }/// #   pub struct Request<B> { _b: B }/// #   impl<B> std::fmt::Debug for Request<B> {/// #       fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {/// #           f.pad("request")/// #       }/// #   impl<B> Request<B> {/// #       pub fn uri(&self) -> &str { "fake" }/// #       pub fn method(&self) -> &str { "GET" }/// // This will record the request's URI and HTTP method as their own separate/// // fields./// #[instrument(fields(http.uri = req.uri(), http.method = req.method()))]/// pub fn handle_request<B>(req: http::Request<B>) -> http::Response<B> {///     // ... handle the request ...///     # http::Response { _b: std::marker::PhantomData }/// This can be used in conjunction with `skip` or `skip_all` to record only/// some fields of a struct:/// // Remember the struct with the very large `data` field from the earlier/// // example? Now it also has a `name`, which we might want to include in/// // our span.///    name: &'static str,///    data: Vec<u8>,///     // This will skip the `data` field, but will include `self.name`,///     // formatted using `fmt::Display`.///     #[instrument(skip(self), fields(self.name = %self.name))]/// Adding an empty field to be recorded later:/// // This function does a very interesting and important mathematical calculation./// // Suppose we want to record both the inputs to the calculation *and* its result.../// #[instrument(fields(result))]/// pub fn do_calculation(input_1: usize, input_2: usize) -> usize {///     // Rerform the calculation.///     let result = input_1 + input_2;///     // Record the result as part of the current span.///     tracing::Span::current().record("result", &result);///     // Now, the result will also be included on this event!///     tracing::info!("calculation complete!");///     // ... etc ...///     # 0/// Instrumenting a function:/// #[instrument]/// pub fn my_function(my_arg: usize) {///     // This event will be recorded inside a span named `my_function` with the///     // field `my_arg`.///     tracing::info!("inside my_function!");/// Setting the level for the generated span:/// # use tracing::Level;/// #[instrument(level = Level::DEBUG)]/// Levels can be specified either with [`Level`] constants, literal strings/// (e.g., `"debug"`, `"info"`) or numerically (1—5, corresponding to [`Level::TRACE`]—[`Level::ERROR`])./// Overriding the generated span's name:/// #[instrument(name = "my_name")]/// Overriding the generated span's target:/// #[instrument(target = "my_target")]/// Overriding the generated span's parent:/// #[instrument(parent = None)]/// // A struct which owns a span handle./// struct MyStruct///     span: tracing::Span/// impl MyStruct///     // Use the struct's `span` field as the parent span///     #[instrument(parent = &self.span, skip(self))]///     fn my_method(&self) {}/// Specifying [`follows_from`] relationships:/// #[instrument(follows_from = causes)]/// pub fn my_function(causes: &[tracing::Id]) {/// Any expression of type `impl IntoIterator<Item = impl Into<Option<Id>>>`/// may be provided to `follows_from`; e.g.:/// #[instrument(follows_from = [cause])]/// pub fn my_function(cause: &tracing::span::EnteredSpan) {/// To skip recording an argument, pass the argument's name to the `skip`:/// To add additional context to the span, pass key-value pairs to `fields`:/// #[instrument(fields(foo="bar", id=1, show=true))]/// fn my_function(arg: usize) {/// Adding the `ret` argument to `#[instrument]` will emit an event with the function's/// return value when the function returns:/// #[instrument(ret)]/// fn my_function() -> i32 {/// The return value event will have the same level as the span generated by `#[instrument]`./// By default, this will be [`INFO`], but if the level is overridden, the event will be at the same/// level./// It's also possible to override the level for the `ret` event independently:/// #[instrument(ret(level = Level::WARN))]/// **Note**:  if the function returns a `Result<T, E>`, `ret` will record returned values if and/// only if the function returns [`Result::Ok`]./// By default, returned values will be recorded using their [`std::fmt::Debug`] implementations./// If a returned value implements [`std::fmt::Display`], it can be recorded using its `Display`/// implementation instead, by writing `ret(Display)`:/// #[instrument(ret(Display))]/// If the function returns a `Result<T, E>` and `E` implements `std::fmt::Display`, adding/// `err` or `err(Display)` will emit error events when the function returns `Err`:/// #[instrument(err)]/// fn my_function(arg: usize) -> Result<(), std::io::Error> {/// The level of the error value event defaults to `ERROR`./// Similarly, overriding the level of the `err` event :/// #[instrument(err(level = Level::INFO))]/// By default, error values will be recorded using their `std::fmt::Display` implementations./// If an error implements `std::fmt::Debug`, it can be recorded using its `Debug` implementation/// instead by writing `err(Debug)`:/// #[instrument(err(Debug))]/// If a `target` is specified, both the `ret` and `err` arguments will emit outputs to/// the declared target (or the default channel if `target` is not specified)./// The `ret` and `err` arguments can be combined in order to record an event if a/// function returns [`Result::Ok`] or [`Result::Err`]:/// #[instrument(err, ret)]/// `async fn`s may also be instrumented:/// pub async fn my_function() -> Result<(), ()> {/// It also works with [async-trait](https://crates.io/crates/async-trait)/// (a crate that allows defining async functions in traits,/// something not currently possible in Rust),/// and hopefully most libraries that exhibit similar behaviors:/// # use tracing::instrument;/// use async_trait::async_trait;/// #[async_trait]/// pub trait Foo {///     async fn foo(&self, arg: usize);/// struct FooImpl(usize);/// impl Foo for FooImpl {///     #[instrument(fields(value = self.0, tmp = std::any::type_name::<Self>()))]///     async fn foo(&self, arg: usize) {}/// `const fn` cannot be instrumented, and will result in a compilation failure:/// const fn my_const_function() {}/// [span]: https://docs.rs/tracing/latest/tracing/span/index.html/// [name]: https://docs.rs/tracing/latest/tracing/struct.Metadata.html#method.name/// [target]: https://docs.rs/tracing/latest/tracing/struct.Metadata.html#method.target/// [level]: https://docs.rs/tracing/latest/tracing/struct.Level.html/// [module path]: https://docs.rs/tracing/latest/tracing/struct.Metadata.html#method.module_path/// [`INFO`]: https://docs.rs/tracing/latest/tracing/struct.Level.html#associatedconstant.INFO/// [empty field]: https://docs.rs/tracing/latest/tracing/field/struct.Empty.html/// [field syntax]: https://docs.rs/tracing/latest/tracing/#recording-fields/// [`follows_from`]: https://docs.rs/tracing/latest/tracing/struct.Span.html#method.follows_from/// [`tracing`]: https://github.com/tokio-rs/tracing/// [`fmt::Debug`]: std::fmt::Debug/// [`Level`]: https://docs.rs/tracing/latest/tracing/struct.Level.html/// [`Level::TRACE`]: https://docs.rs/tracing/latest/tracing/struct.Level.html#associatedconstant.TRACE/// [`Level::ERROR`]: https://docs.rs/tracing/latest/tracing/struct.Level.html#associatedconstant.ERRORinstrument_speculative/// Instrument the function, without parsing the function body (instead using the raw tokens).instrument_precise/// Instrument the function, by fully parsing the function body,/// which allows us to rewrite some statements related to async-like patterns./// This is a more flexible/imprecise `ItemFn` type,/// which's block is just a `TokenStream` (it may contain invalid code)./// This parses a `TokenStream` into a `MaybeItemFn`/// (just like `ItemFn`, but skips parsing the body)./// A generic reference type for `MaybeItemFn`,/// that takes a generic block type `B` that implements `ToTokens` (eg. `TokenStream`, `Block`).//! A procedural macro attribute for instrumenting functions with [`tracing`].//! [`tracing`] is a framework for instrumenting Rust programs to collect//! structured, event-based diagnostic information. This crate provides the//! [`#[instrument]`][instrument] procedural macro attribute.//! Note that this macro is also re-exported by the main `tracing` crate.//! *Compiler support: [requires `rustc` 1.65+][msrv]*//! In the `Cargo.toml`://! tracing-attributes = "0.1.24"//! The [`#[instrument]`][instrument] attribute can now be added to a function//! to automatically create and enter `tracing` [span] when that function is//! called. For example://! use tracing::instrument;//! [span]: https://docs.rs/tracing/latest/tracing/span/index.html//! [instrument]: macro@self::instrument//! version is 1.65. The current Tracing version is not guaranteed to build on// TODO: once `tracing` bumps its MSRV to 1.42, remove this allow.dispatchersDispatchersset_interest/// Sets the [`Interest`] for this callsite./// See the [documentation on callsite interest caching][cache-docs] for/// [`Interest`]: super::subscriber::Interest/// [cache-docs]: crate::callsite#performing-static-filtering/// Returns the [metadata] associated with the callsite./// <div class="example-wrap" style="display:inline-block">/// **Note:** Implementations of this method should not produce [`Metadata`]/// that share the same callsite [`Identifier`] but otherwise differ in any/// way (e.g., have different `name`s)./// </pre></div>/// [metadata]: super::metadata::Metadataprivate_type_id/// This method is an *internal implementation detail* of `tracing-core`. It/// is *not* intended to be called or overridden from downstream code./// The `Private` type can only be constructed from within `tracing-core`./// Because this method takes a `Private` as an argument, it cannot be/// called from (safe) code external to `tracing-core`. Because it must/// *return* a `Private`, the only valid implementation possible outside of/// `tracing-core` would have to always unconditionally panic./// THIS IS BY DESIGN. There is currently no valid reason for code outside/// of `tracing-core` to override this method.// TODO(eliza): this could be used to implement a public downcasting API// for `&dyn Callsite`s in the future./// Trait implemented by callsites./// These functions are only intended to be called by the callsite registry, which/// correctly handles determining the common interest between all subscribers./// See the [module-level documentation](crate::callsite) for details on/// callsites./// **Warning**: The fields on this type are currently `pub` because it must/// be able to be constructed statically by macros. However, when `const/// fn`s are available on stable Rust, this will no longer be necessary./// Thus, these fields are *not* considered stable public API, and they may/// change warning. Do not rely on any fields on `Identifier`. When/// constructing new `Identifier`s, use the `identify_callsite!` macro/// Uniquely identifies a [`Callsite`]/// Two `Identifier`s are equal if they both refer to the same callsite./// [`Callsite`]: super::callsite::Callsite/// A default [`Callsite`] implementation.rebuild_interest_cache/// Clear and reregister interest on every [`Callsite`]/// This function is intended for runtime reconfiguration of filters on traces/// when the filter recalculation is much less frequent than trace events are./// The alternative is to have the [`Subscriber`] that supports runtime/// reconfiguration of filters always return [`Interest::sometimes()`] so that/// [`enabled`] is evaluated for every event./// This function will also re-compute the global maximum level as determined by/// the [`max_level_hint`] method. If a [`Subscriber`]/// implementation changes the value returned by its `max_level_hint`/// implementation at runtime, then it **must** call this function after that/// value changes, in order for the change to be reflected./// additional information on this function's usage./// [`max_level_hint`]: super::subscriber::Subscriber::max_level_hint/// [`enabled`]: super::subscriber::Subscriber#tymethod.enabled/// [`Interest::sometimes()`]: super::subscriber::Interest::sometimes/// [cache-docs]: crate::callsite#rebuilding-cached-interest/// Register a new [`Callsite`] with the global registry./// This should be called once per callsite after the callsite has been/// See the [documentation on callsite registration][reg-docs] for details/// on the global callsite registry./// [`Callsite`]: crate::callsite::Callsite/// [reg-docs]: crate::callsite#registering-callsitesCALLSITESCallsitesDISPATCHERSLOCKED_CALLSITESlist_headhas_locked_callsitesUNREGISTEREDREGISTEREDINTEREST_NEVERINTEREST_SOMETIMESINTEREST_ALWAYS/// Returns a new `DefaultCallsite` with the specified `Metadata`./// Registers this callsite with the global callsite registry./// If the callsite is already registered, this does nothing. When using/// [`DefaultCallsite`], this method should be preferred over/// [`tracing_core::callsite::register`], as it ensures that the callsite is/// only registered a single time./// Other callsite implementations will generally ensure that/// callsites are not re-registered through another mechanism./// [`tracing_core::callsite::register`]: crate::callsite::register// This only happens once (or if the cached interest value was corrupted)./// Returns the callsite's cached `Interest`, or registers it for the/// first time if it has not yet been registered.rebuild_interestRebuilder/// Rebuild `Interest`s for all callsites in the registry./// This also re-computes the max level hint.push_dyn/// Push a `dyn Callsite` trait object to the callsite registry./// This will attempt to lock the callsites vector.push_default/// Push a `DefaultCallsite` to the callsite registry./// If we know the callsite being pushed is a `DefaultCallsite`, we can push/// it to the linked list without having to acquire a lock./// Invokes the provided closure `f` with each callsite in the registry.register_dispatchrebuild_callsite_interest/// Don't call this function, it's private.has_just_oneLOCKED_DISPATCHERSRegistrarJustOnerebuilder//! Callsites represent the source locations from which spans or events//! originate.//! # What Are Callsites?//! Every span or event in `tracing` is associated with a [`Callsite`]. A//! callsite is a small `static` value that is responsible for the following://! * Storing the span or event's [`Metadata`],//! * Uniquely [identifying](Identifier) the span or event definition,//! * Caching the subscriber's [`Interest`][^1] in that span or event, to avoid//!   re-evaluating filters.//! # Registering Callsites//! When a span or event is recorded for the first time, its callsite//! [`register`]s itself with the global callsite registry. Registering a//! callsite calls the [`Subscriber::register_callsite`][`register_callsite`]//! method with that callsite's [`Metadata`] on every currently active//! subscriber. This serves two primary purposes: informing subscribers of the//! callsite's existence, and performing static filtering.//! ## Callsite Existence//! If a [`Subscriber`] implementation wishes to allocate storage for each//! unique span/event location in the program, or pre-compute some value//! that will be used to record that span or event in the future, it can//! do so in its [`register_callsite`] method.//! ## Performing Static Filtering//! The [`register_callsite`] method returns an [`Interest`] value,//! which indicates that the subscriber either [always] wishes to record//! that span or event, [sometimes] wishes to record it based on a//! dynamic filter evaluation, or [never] wishes to record it.//! When registering a new callsite, the [`Interest`]s returned by every//! currently active subscriber are combined, and the result is stored at//! each callsite. This way, when the span or event occurs in the//! future, the cached [`Interest`] value can be checked efficiently//! to determine if the span or event should be recorded, without//! needing to perform expensive filtering (i.e. calling the//! [`Subscriber::enabled`] method every time a span or event occurs).//! ### Rebuilding Cached Interest//! When a new [`Dispatch`] is created (i.e. a new subscriber becomes//! active), any previously cached [`Interest`] values are re-evaluated//! for all callsites in the program. This way, if the new subscriber//! will enable a callsite that was not previously enabled, the//! [`Interest`] in that callsite is updated. Similarly, when a//! subscriber is dropped, the interest cache is also re-evaluated, so//! that any callsites enabled only by that subscriber are disabled.//! In addition, the [`rebuild_interest_cache`] function in this module can be//! used to manually invalidate all cached interest and re-register those//! callsites. This function is useful in situations where a subscriber's//! interest can change, but it does so relatively infrequently. The subscriber//! may wish for its interest to be cached most of the time, and return//! [`Interest::always`][always] or [`Interest::never`][never] in its//! [`register_callsite`] method, so that its [`Subscriber::enabled`] method//! doesn't need to be evaluated every time a span or event is recorded.//! However, when the configuration changes, the subscriber can call//! [`rebuild_interest_cache`] to re-evaluate the entire interest cache with its//! new configuration. This is a relatively costly operation, but if the//! configuration changes infrequently, it may be more efficient than calling//! [`Subscriber::enabled`] frequently.//! # Implementing Callsites//! In most cases, instrumenting code using `tracing` should *not* require//! implementing the [`Callsite`] trait directly. When using the [`tracing`//! crate's macros][macros] or the [`#[instrument]` attribute][instrument], a//! `Callsite` is automatically generated.//! However, code which provides alternative forms of `tracing` instrumentation//! may need to interact with the callsite system directly. If//! instrumentation-side code needs to produce a `Callsite` to emit spans or//! events, the [`DefaultCallsite`] struct provided in this module is a//! ready-made `Callsite` implementation that is suitable for most uses. When//! possible, the use of `DefaultCallsite` should be preferred over implementing//! [`Callsite`] for user types, as `DefaultCallsite` may benefit from//! additional performance optimizations.//! [^1]: Returned by the [`Subscriber::register_callsite`][`register_callsite`]//!     method.//! [`Metadata`]: crate::metadata::Metadata//! [`Interest`]: crate::subscriber::Interest//! [`Subscriber`]: crate::subscriber::Subscriber//! [`register_callsite`]: crate::subscriber::Subscriber::register_callsite//! [`Subscriber::enabled`]: crate::subscriber::Subscriber::enabled//! [always]: crate::subscriber::Interest::always//! [sometimes]: crate::subscriber::Interest::sometimes//! [never]: crate::subscriber::Interest::never//! [`Dispatch`]: crate::dispatcher::Dispatch//! [macros]: https://docs.rs/tracing/latest/tracing/#macros//! [instrument]: https://docs.rs/tracing/latest/tracing/attr.instrument.html// === impl DefaultCallsite ===// ===== impl Identifier =====// === impl Callsites ===NoSubscriber/// `Dispatch` trace data to a [`Subscriber`]./// `WeakDispatch` is a version of [`Dispatch`] that holds a non-owning reference/// to a [`Subscriber`]./// The `Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],/// which returns an `Option<Dispatch>`. If all [`Dispatch`] clones that point/// at the `Subscriber` have been dropped, [`WeakDispatch::upgrade`] will return/// `None`. Otherwise, it will return `Some(Dispatch)`./// A `WeakDispatch` may be created from a [`Dispatch`] by calling the/// [`Dispatch::downgrade`] method. The primary use for creating a/// [`WeakDispatch`] is to allow a Subscriber` to hold a cyclical reference to/// itself without creating a memory leak. See [here] for details./// This type is analogous to the [`std::sync::Weak`] type, but for a/// [`Dispatch`] rather than an [`Arc`]./// [here]: Subscriber#avoiding-memory-leaksCURRENT_STATESCOPED_COUNTGLOBAL_DISPATCHNO_SUBSCRIBER/// This thread's current default dispatcher.can_enter/// Whether or not we can currently begin dispatching a trace event./// This is set to `false` when functions such as `enter`, `exit`, `event`,/// and `new_span` are called on this thread's default dispatcher, to/// prevent further trace events triggered inside those functions from/// creating an infinite recursion. When we finish handling a dispatch, this/// is set back to `true`./// The dispatch state of a thread./// While this guard is active, additional calls to subscriber functions on/// the default dispatcher will not be able to access the dispatch context./// Dropping the guard will allow the dispatch context to be re-entered./// A guard that resets the current default dispatcher to the prior/// default dispatcher when dropped./// Sets this dispatch as the default for the duration of a closure./// The default dispatcher is used when creating a new [span] or///     <strong>Note</strong>: This function required the Rust standard library.///     <code>no_std</code> users should use <a href="fn.set_global_default.html">///     <code>set_global_default</code></a> instead."Dropping the guard unregisters the dispatcher."/// Sets the dispatch as the default dispatch for the duration of the lifetime/// of the returned DefaultGuard/// [`set_global_default`]: set_global_default/// Sets this dispatch as the global default for the duration of the entire program./// Will be used as a fallback if no thread-local dispatch has been set in a thread/// (using `with_default`.)/// Returns `Err` if the global default has already been set./// <div class="example-wrap" style="display:inline-block"><pre class="compile_fail" style="white-space:normal;font:inherit;">///     <strong>Warning</strong>: In general, libraries should <em>not</em> call///     <code>set_global_default()</code>! Doing so will cause conflicts when///     executables that depend on the library try to set the default later./// Returns true if a `tracing` dispatcher has ever been set./// This may be used to completely elide trace points if tracing is not in use/// at all or has yet to be initialized._no_construct/// Returned if setting the global dispatcher fails.MESSAGE/// Executes a closure with a reference to this thread's current [dispatcher]./// Note that calls to `get_default` should not be nested; if this function is/// called while inside of another `get_default`, that closure will be provided/// with `Dispatch::none` rather than the previously set dispatcher./// [dispatcher]: super::dispatcher::Dispatchget_global/// Returns a new `Dispatch` that discards events and spans./// Returns a `Dispatch` that forwards to the given [`Subscriber`].registrar/// Creates a [`WeakDispatch`] from this `Dispatch`./// A [`WeakDispatch`] is similar to a [`Dispatch`], but it does not prevent/// the underlying [`Subscriber`] from being dropped. Instead, it only permits/// access while other references to the `Subscriber` exist. This is equivalent/// to the standard library's [`Arc::downgrade`] method, but for `Dispatch`/// rather than `Arc`./// The primary use for creating a [`WeakDispatch`] is to allow a `Subscriber`/// to hold a cyclical reference to itself without creating a memory leak./// See [here] for details./// [`Arc::downgrade`]: std::sync::Arc::downgraderegister_callsite/// Registers a new callsite with this subscriber, returning whether or not/// the subscriber is interested in being notified about the callsite./// This calls the [`register_callsite`] function on the [`Subscriber`]/// that this `Dispatch` forwards to./// [`register_callsite`]: super::subscriber::Subscriber::register_callsitemax_level_hint/// Returns the highest [verbosity level][level] that this [`Subscriber`] will/// enable, or `None`, if the subscriber does not implement level-based/// filtering or chooses not to implement this method./// This calls the [`max_level_hint`] function on the [`Subscriber`]/// [level]: super::Level/// [`register_callsite`]: super::subscriber::Subscriber::max_level_hint// TODO(eliza): consider making this a public API?new_span/// Record the construction of a new span, returning a new [ID] for the/// span being constructed./// This calls the [`new_span`] function on the [`Subscriber`] that this/// `Dispatch` forwards to./// [ID]: super::span::Id/// [`new_span`]: super::subscriber::Subscriber::new_span/// Record a set of values on a span./// This calls the [`record`] function on the [`Subscriber`] that this/// [`record`]: super::subscriber::Subscriber::recordrecord_follows_from/// Adds an indication that `span` follows from the span with the id/// `follows`./// This calls the [`record_follows_from`] function on the [`Subscriber`]/// [`record_follows_from`]: super::subscriber::Subscriber::record_follows_from/// Returns true if a span with the specified [metadata] would be/// recorded./// This calls the [`enabled`] function on the [`Subscriber`] that this/// [`enabled`]: super::subscriber::Subscriber::enabled/// Records that an [`Event`] has occurred./// This calls the [`event`] function on the [`Subscriber`] that this/// [`event`]: super::subscriber::Subscriber::event/// Records that a span has been can_enter./// This calls the [`enter`] function on the [`Subscriber`] that this/// [`enter`]: super::subscriber::Subscriber::enter/// Records that a span has been exited./// This calls the [`exit`] function on the [`Subscriber`] that this/// [`exit`]: super::subscriber::Subscriber::exitclone_span/// Notifies the subscriber that a [span ID] has been cloned./// This function must only be called with span IDs that were returned by/// this `Dispatch`'s [`new_span`] function. The `tracing` crate upholds/// this guarantee and any other libraries implementing instrumentation APIs/// must as well./// This calls the [`clone_span`] function on the `Subscriber` that this/// [span ID]: super::span::Id/// [`clone_span`]: super::subscriber::Subscriber::clone_spandrop_span/// Notifies the subscriber that a [span ID] has been dropped./// This calls the [`drop_span`] function on the [`Subscriber`] that this///     <strong>Deprecated</strong>: The <a href="#method.try_close"><code>///     try_close</code></a> method is functionally identical, but returns///     <code>true</code> if the span is now closed. It should be used///     instead of this method./// [`drop_span`]: super::subscriber::Subscriber::drop_span/// [`try_close`]: Self::try_close()/// Notifies the subscriber that a [span ID] has been dropped, and returns/// `true` if there are now 0 IDs referring to that span./// This calls the [`try_close`] function on the [`Subscriber`] that this///  `Dispatch` forwards to./// [`try_close`]: super::subscriber::Subscriber::try_close/// Returns a type representing this subscriber's view of the current span./// This calls the [`current`] function on the `Subscriber` that this/// [`current`]: super::subscriber::Subscriber::current_span/// Returns `true` if this `Dispatch` forwards to a `Subscriber` of type/// Returns some reference to the `Subscriber` this `Dispatch` forwards to/// if it is of type `T`, or `None` if it isn't./// Returns the current default dispatcher/// Attempts to upgrade this `WeakDispatch` to a [`Dispatch`]./// Returns `None` if the referenced `Dispatch` has already been dropped./// # use tracing_core::subscriber::NoSubscriber;/// # use tracing_core::dispatcher::Dispatch;/// let strong = Dispatch::new(NoSubscriber::default());/// let weak = strong.downgrade();/// // The strong here keeps it alive, so we can still access the object./// assert!(weak.upgrade().is_some());/// drop(strong); // But not any more./// assert!(weak.upgrade().is_none());/// Replaces the current default dispatcher on this thread with the provided/// dispatcher.Any/// Dropping the returned `ResetGuard` will reset the default dispatcher to/// the previous value.dispatch_isdispatch_downcastsTestCallsiteTEST_CALLSITETEST_METAevents_dont_infinite_loopspans_dont_infinite_loopdefault_no_subscriberdefault_dispatch//!     <strong>Note</strong>:the thread-local scoped dispatcher//!     (<a href="#fn.with_default"><code>with_default</code></a>) requires the//!     Rust standard library. <code>no_std</code> users should use//!     <a href="#fn.set_global_default"><code>set_global_default</code></a>//!     instead.// === impl WeakDispatch ===// ===== impl State =====// ===== impl DefaultGuard =====/// `Event`s represent single points in time where something occurred during the/// execution of a program./// An `Event` can be compared to a log record in unstructured logging, but with/// two key differences:/// - `Event`s exist _within the context of a [span]_. Unlike log lines, they///   may be located within the trace tree, allowing visibility into the///   _temporal_ context in which the event occurred, as well as the source///   code location./// - Like spans, `Event`s have structured key-value data known as _[fields]_,///   which may include textual message. In general, a majority of the data///   associated with an event should be in the event's fields rather than in///   the textual message, as the fields are more structured./// [fields]: super::field/// Constructs a new `Event` with the specified metadata and set of values,/// and observes it with the current subscriber./// Returns a new `Event` in the current span, with the specified metadata/// and set of values.new_child_of/// Returns a new `Event` as a child of the specified span, with the/// provided metadata and set of values./// and observes it with the current subscriber and an explicit parent./// Visits all the fields on this `Event` with the specified [visitor]./// [visitor]: super::field::Visit/// Returns an iterator over the set of values on this `Event`./// Returns [metadata] describing this `Event`./// Returns true if the new event should be a root.is_contextual/// Returns true if the new event's parent should be determined based on the/// current context./// If this is true and the current thread is currently inside a span, then/// that span should be the new event's parent. Otherwise, if the current/// thread is _not_ inside a span, then the new event will be the root of its/// own trace tree./// Returns the new event's explicitly-specified parent, if there is one./// Otherwise (if the new event is a root or is a child of the current span),//! Events represent single points in time during the execution of a program.ValidLenFieldSet/// An opaque key allowing _O_(1) access to a field in a `Span`'s key-value/// As keys are defined by the _metadata_ of a span, rather than by an/// individual instance of a span, a key may be used to access the same field/// across all instances of a given span with the same metadata. Thus, when a/// subscriber observes a new span, it need only access a field by name _once_,/// and use the key for that name for all other accesses./// An empty field./// This can be used to indicate that the value of a field is not currently/// present but will be recorded later./// When a field's value is `Empty`. it will not be recorded./// The names of each field on the described span./// The callsite where the described span originates./// Describes the fields present on a span./// ## Equality/// In well-behaved applications, two `FieldSet`s [initialized] with equal/// [callsite identifiers] will have identical fields. Consequently, in release/// builds, [`FieldSet::eq`] *only* checks that its arguments have equal/// callsites. However, the equality of field names is checked in debug builds./// [initialized]: Self::new/// [callsite identifiers]: callsite::Identifier/// A set of fields and values for a span./// An iterator over a set of fields.record_f64/// Visit a double-precision floating point value.record_i64/// Visit a signed 64-bit integer value.record_u64/// Visit an unsigned 64-bit integer value.record_i128/// Visit a signed 128-bit integer value.record_u128/// Visit an unsigned 128-bit integer value.record_bool/// Visit a boolean value.record_str/// Visit a string value.record_bytes/// Visit a byte slice.record_error/// Records a type implementing `Error`./// <strong>Note</strong>: This is only enabled when the Rust standard library isrecord_debug/// Visit a value implementing `fmt::Debug`./// Visits typed values./// An instance of `Visit` ("a visitor") represents the logic necessary to/// record field values of various types. When an implementor of [`Value`] is/// [recorded], it calls the appropriate method on the provided visitor to/// indicate the type that value should be recorded as./// When a [`Subscriber`] implementation [records an `Event`] or a/// [set of `Value`s added to a `Span`], it can pass an `&mut Visit` to the/// `record` method on the provided [`ValueSet`] or [`Event`]. This visitor/// will then be used to record all the field-value pairs present on that/// `Event` or `ValueSet`./// A simple visitor that writes to a string might be implemented like so:/// # extern crate tracing_core as tracing;/// use std::fmt::{self, Write};/// use tracing::field::{Value, Visit, Field};/// pub struct StringVisitor<'a> {///     string: &'a mut String,/// impl<'a> Visit for StringVisitor<'a> {///     fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {///         write!(self.string, "{} = {:?}; ", field.name(), value).unwrap();/// This visitor will format each recorded value using `fmt::Debug`, and/// append the field name and formatted value to the provided string,/// regardless of the type of the recorded value. When all the values have/// been recorded, the `StringVisitor` may be dropped, allowing the string/// to be printed or stored in some other data structure./// The `Visit` trait provides default implementations for `record_i64`,/// `record_u64`, `record_bool`, `record_str`, and `record_error`, which simply/// forward the recorded value to `record_debug`. Thus, `record_debug` is the/// only method which a `Visit` implementation *must* implement. However,/// visitors may override the default implementations of these functions in/// order to implement type-specific behavior./// Additionally, when a visitor receives a value of a type it does not care/// about, it is free to ignore those values completely. For example, a/// visitor which only records numeric data might look like this:/// # use std::fmt::{self, Write};/// # use tracing::field::{Value, Visit, Field};/// pub struct SumVisitor {///     sum: i64,/// impl Visit for SumVisitor {///     fn record_i64(&mut self, _field: &Field, value: i64) {///        self.sum += value;///     fn record_u64(&mut self, _field: &Field, value: u64) {///         self.sum += value as i64;///     fn record_debug(&mut self, _field: &Field, _value: &fmt::Debug) {///         // Do nothing/// This visitor (which is probably not particularly useful) keeps a running/// sum of all the numeric values it records, and ignores all other values. A/// more practical example of recording typed values is presented in/// `examples/counters.rs`, which demonstrates a very simple metrics system/// implemented using `tracing`./// <strong>Note</strong>: The <code>record_error</code> trait method is only/// available when the Rust standard library is present, as it requires the/// <code>std::error::Error</code> trait./// [recorded]: Value::record/// [records an `Event`]: super::subscriber::Subscriber::event/// [set of `Value`s added to a `Span`]: super::subscriber::Subscriber::record/// Visits this value with the given `Visitor`./// A field value of an erased type./// Implementors of `Value` may call the appropriate typed recording methods on/// the [visitor] passed to their `record` method in order to indicate how/// their data should be recorded./// [visitor]: VisitDisplayValue/// A `Value` which serializes using `fmt::Display`./// Uses `record_debug` in the `Value` implementation to/// avoid an unnecessary evaluation.DebugValue/// A `Value` which serializes as a string using `fmt::Debug`./// Wraps a type implementing `fmt::Display` as a `Value` that can be/// recorded using its `Display` implementation./// Wraps a type implementing `fmt::Debug` as a `Value` that can be/// recorded using its `Debug` implementation.HexBytesimpl_valuesty_to_nonzeroimpl_one_valueimpl_value/// Returns an [`Identifier`] that uniquely identifies the [`Callsite`]/// which defines this field./// [`Identifier`]: super::callsite::Identifier/// Returns a string representing the name of the field./// Returns the index of this field in its [`FieldSet`]./// Constructs a new `FieldSet` with the given array of field names and callsite./// which defines this set of fields../// Returns the [`Field`] named `name`, or `None` if no such field exists./// [`Field`]: super::Field/// Returns `true` if `self` contains the given `field`./// <strong>Note</strong>: If <code>field</code> shares a name with a field/// in this <code>FieldSet</code>, but was created by a <code>FieldSet</code>/// with a different callsite, this <code>FieldSet</code> does <em>not</em>/// contain it. This is so that if two separate span callsites define a field/// named "foo", the <code>Field</code> corresponding to "foo" for each/// of those callsites are not equivalent./// Returns an iterator over the `Field`s in this `FieldSet`./// Returns a new `ValueSet` with entries for this `FieldSet`'s values./// Returns the number of fields in this `FieldSet`./// Returns whether or not this `FieldSet` has fields./// defining the fields this `ValueSet` refers to./// Visits all the fields in this `ValueSet` with the provided [visitor]./// Returns the number of fields in this `ValueSet` that would be visited/// by a given [visitor] to the [`ValueSet::record()`] method./// [`ValueSet::record()`]: ValueSet::record()/// Returns `true` if this `ValueSet` contains a value for the given `Field`./// Returns true if this `ValueSet` contains _no_ values.field_set/// Restrictions on `ValueSet` lengths were removed in #2508 but this type remains for backwards compatibility.TestCallsite1// Make sure TEST_CALLSITE_* have non-zero size, so they can't be located at the same address.TEST_CALLSITE_1TEST_META_1TestCallsite2TEST_CALLSITE_2TEST_META_2value_set_with_no_values_is_emptyindex_of_field_in_fieldset_is_correctempty_value_set_is_emptyvalue_sets_with_fields_from_other_callsites_are_emptysparse_value_sets_are_not_emptyfields_from_other_callsets_are_skippedempty_fields_are_skippedrecord_debug_fn//! Spans and events may be annotated with key-value data, known as _fields_.//! These fields consist of a mapping from a key (corresponding to a `&str` but//! represented internally as an array index) to a [`Value`].//! (`i64`, `u64`, `f64`, `i128`, `u128`, `bool`, and `&str`) or using a//! `fmt::Display` or `fmt::Debug` implementation. `Subscriber`s are provided//! these primitive value types as `dyn Value` trait objects.//! [`as_value`]: valuable::Valuable::as_value//! [span]: super::span//! [`Event`]: super::event::Event//! [`Metadata`]: super::metadata::Metadata//! [`Attributes`]:  super::span::Attributes//! [`Record`]: super::span::Record//! [`new_span`]: super::subscriber::Subscriber::new_span//! [`record`]: super::subscriber::Subscriber::record//! [`event`]:  super::subscriber::Subscriber::event//! [`Value::record`]: Value::record// ===== impl Visit =====// ===== impl Value =====// ===== impl DisplayValue =====// ===== impl DebugValue =====// ===== impl ValuableValue =====// ===== impl Field =====// ===== impl FieldSet =====// ===== impl ValueSet =====// ===== impl ValidLen =====identify_callsite/// Statically constructs an [`Identifier`] for the provided [`Callsite`]./// This may be used in contexts such as static initializers./// use tracing_core::{callsite, identify_callsite};/// # use tracing_core::{Metadata, subscriber::Interest};/// pub struct MyCallsite {///    // .../// impl callsite::Callsite for MyCallsite {/// # fn set_interest(&self, _: Interest) { unimplemented!() }/// # fn metadata(&self) -> &Metadata { unimplemented!() }/// static CALLSITE: MyCallsite = MyCallsite {/// static CALLSITE_ID: callsite::Identifier = identify_callsite!(&CALLSITE);/// [`Identifier`]: callsite::Identifier/// [`Callsite`]: callsite::Callsite/// Statically constructs new span [metadata]./// /// For example:/// # use tracing_core::{callsite::Callsite, subscriber::Interest};/// use tracing_core::metadata;/// use tracing_core::metadata::{Kind, Level, Metadata};/// # pub struct MyCallsite { }/// # impl Callsite for MyCallsite {/// static FOO_CALLSITE: MyCallsite = MyCallsite {/// static FOO_METADATA: Metadata = metadata!{///     name: "foo",///     target: module_path!(),///     level: Level::DEBUG,///     fields: &["bar", "baz"],///     callsite: &FOO_CALLSITE,///     kind: Kind::SPAN,/// [metadata]: metadata::Metadata/// [`Metadata::new`]: metadata::Metadata::new//! Core primitives for `tracing`.//! structured, event-based diagnostic information. This crate defines the core//! primitives of `tracing`.//! * [`span::Id`] identifies a span within the execution of a program.//! * [`Event`] represents a single event within a trace.//! * [`Subscriber`], the trait implemented to collect trace data.//! * [`Metadata`] and [`Callsite`] provide information describing spans and//!   `Event`s.//! * [`Field`], [`FieldSet`], [`Value`], and [`ValueSet`] represent the//!   structured data attached to a span.//! * [`Dispatch`] allows spans and events to be dispatched to `Subscriber`s.//! In addition, it defines the global callsite registry and per-thread current//! dispatcher which other components of the tracing system rely on.//! Application authors will typically not use this crate directly. Instead,//! they will use the [`tracing`] crate, which provides a much more//! fully-featured API. However, this crate's API will change very infrequently,//! so it may be used when dependencies must be very stable.//! `Subscriber` implementations may depend on `tracing-core` rather than//! `tracing`, as the additional APIs provided by `tracing` are primarily useful//! for instrumenting libraries and applications, and are generally not//! necessary for `Subscriber` implementations.//! The [`tokio-rs/tracing`] repository contains less stable crates designed to//! be used with the `tracing` ecosystem. It includes a collection of//! `Subscriber` implementations, as well as utility and adapter crates.//!   tracing-core = { version = "0.1.22", default-features = false }//!   **Note**:`tracing-core`'s `no_std` support requires `liballoc`.//! [`span::Id`]: span::Id//! [`Metadata`]: metadata::Metadata//! [`Callsite`]: callsite::Callsite//! [`Field`]: field::Field//! [`FieldSet`]: field::FieldSet//! [`Value`]: field::Value//! [`ValueSet`]: field::ValueSet//! [`Dispatch`]: dispatcher::Dispatch/// The name of the span described by this metadata./// The part of the system that the span that this metadata describes/// occurred in./// The level of verbosity of the described span./// The name of the Rust module where the span occurred, or `None` if this/// could not be determined./// The name of the source code file where the span occurred, or `None` if/// this could not be determined./// The line number in the source code file where the span occurred, or/// `None` if this could not be determined./// The names of the key-value fields attached to the described span or/// The kind of the callsite./// Metadata describing a [span] or [event]./// All spans and events have the following metadata:/// - A [name], represented as a static string./// - A [target], a string that categorizes part of the system where the span///   or event occurred. The `tracing` macros default to using the module///   path where the span or event originated as the target, but it may be///   overridden./// - A [verbosity level]. This determines how verbose a given span or event///   is, and allows enabling or disabling more verbose diagnostics///   situationally. See the documentation for the [`Level`] type for details./// - The names of the [fields] defined by the span or event./// - Whether the metadata corresponds to a span or event./// In addition, the following optional metadata describing the source code/// location where the span or event originated _may_ be provided:/// - The [file name]/// - The [line number]/// - The [module path]/// Metadata is used by [`Subscriber`]s when filtering spans and events, and it/// may also be used as part of their data payload./// When created by the `event!` or `span!` macro, the metadata describing a/// particular event or span is constructed statically and exists as a single/// static instance. Thus, the overhead of creating the metadata is/// _significantly_ lower than that of creating the actual span. Therefore,/// filtering is based on metadata, rather than on the constructed span./// In well-behaved applications, two `Metadata` with equal/// [callsite identifiers] will be equal in all other ways (i.e., have the same/// `name`, `target`, etc.). Consequently, in release builds, [`Metadata::eq`]/// *only* checks that its arguments have equal callsites. However, the equality/// of `Metadata`'s other fields is checked in debug builds./// [event]: super::event/// [name]: Self::name/// [target]: Self::target/// [fields]: Self::fields/// [verbosity level]: Self::level/// [file name]: Self::file/// [line number]: Self::line/// [module path]: Self::module_path/// [callsite identifiers]: Self::callsite/// Indicates whether the callsite is a span or event.LevelInner/// Describes the level of verbosity of a span or event./// # Comparing Levels/// `Level` implements the [`PartialOrd`] and [`Ord`] traits, allowing two/// `Level`s to be compared to determine which is considered more or less/// verbose. Levels which are more verbose are considered "greater than" levels/// which are less verbose, with [`Level::ERROR`] considered the lowest, and/// [`Level::TRACE`] considered the highest./// use tracing_core::Level;/// assert!(Level::TRACE > Level::DEBUG);/// assert!(Level::ERROR < Level::WARN);/// assert!(Level::INFO <= Level::DEBUG);/// assert_eq!(Level::TRACE, Level::TRACE);/// # Filtering/// `Level`s are typically used to implement filtering that determines which/// spans and events are enabled. Depending on the use case, more or less/// verbose diagnostics may be desired. For example, when running in/// development, [`DEBUG`]-level traces may be enabled by default. When running in/// production, only [`INFO`]-level and lower traces might be enabled. Libraries/// may include very verbose diagnostics at the [`DEBUG`] and/or [`TRACE`] levels./// Applications using those libraries typically chose to ignore those traces. However, when/// debugging an issue involving said libraries, it may be useful to temporarily/// enable the more verbose traces./// The [`LevelFilter`] type is provided to enable filtering traces by/// verbosity. `Level`s can be compared against [`LevelFilter`]s, and/// [`LevelFilter`] has a variant for each `Level`, which compares analogously/// to that level. In addition, [`LevelFilter`] adds a [`LevelFilter::OFF`]/// variant, which is considered "less verbose" than every other `Level`. This is/// intended to allow filters to completely disable tracing in a particular context./// use tracing_core::{Level, LevelFilter};/// assert!(LevelFilter::OFF < Level::TRACE);/// assert!(LevelFilter::TRACE > Level::DEBUG);/// assert!(LevelFilter::ERROR < Level::WARN);/// assert!(LevelFilter::INFO <= Level::DEBUG);/// assert!(LevelFilter::INFO >= Level::INFO);/// Below is a simple example of how a [`Subscriber`] could implement filtering through/// a [`LevelFilter`]. When a span or event is recorded, the [`Subscriber::enabled`] method/// compares the span or event's `Level` against the configured [`LevelFilter`]./// The optional [`Subscriber::max_level_hint`] method can also be implemented to allow spans/// and events above a maximum verbosity level to be skipped more efficiently,/// often improving performance in short-lived programs./// use tracing_core::{span, Event, Level, LevelFilter, Subscriber, Metadata};/// # use tracing_core::span::{Id, Record, Current};/// pub struct MySubscriber {///     /// The most verbose level that this subscriber will enable.///     max_level: LevelFilter,/// impl MySubscriber {///     /// Returns a new `MySubscriber` which will record spans and events up to///     /// `max_level`.///     pub fn with_max_level(max_level: LevelFilter) -> Self {///             max_level,/// impl Subscriber for MySubscriber {///     fn enabled(&self, meta: &Metadata<'_>) -> bool {///         // A span or event is enabled if it is at or below the configured///         // maximum level.///         meta.level() <= &self.max_level///     // This optional method returns the most verbose level that this///     // subscriber will enable. Although implementing this method is not///     // *required*, it permits additional optimizations when it is provided,///     // allowing spans and events above the max level to be skipped///     // more efficiently.///     fn max_level_hint(&self) -> Option<LevelFilter> {///         Some(self.max_level)///     // Implement the rest of the subscriber...///     fn new_span(&self, span: &span::Attributes<'_>) -> span::Id {///         # drop(span); Id::from_u64(1)///     fn event(&self, event: &Event<'_>) {///         # drop(event);///     # fn enter(&self, _: &Id) {}///     # fn exit(&self, _: &Id) {}///     # fn record(&self, _: &Id, _: &Record<'_>) {}///     # fn record_follows_from(&self, _: &Id, _: &Id) {}/// It is worth noting that the `tracing-subscriber` crate provides [additional/// APIs][envfilter] for performing more sophisticated filtering, such as/// enabling different levels based on which module or crate a span or event is/// recorded in./// [`DEBUG`]: Level::DEBUG/// [`INFO`]: Level::INFO/// [`TRACE`]: Level::TRACE/// [`Subscriber::enabled`]: crate::subscriber::Subscriber::enabled/// [`Subscriber::max_level_hint`]: crate::subscriber::Subscriber::max_level_hint/// [`Subscriber`]: crate::subscriber::Subscriber/// [envfilter]: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html/// A filter comparable to a verbosity [`Level`]./// If a [`Level`] is considered less than or equal to a `LevelFilter`, it/// should be considered enabled; if greater than the `LevelFilter`, that level/// is disabled. See [`LevelFilter::current`] for more details./// Note that this is essentially identical to the `Level` type, but with the/// addition of an [`OFF`] level that completely disables all trace/// instrumentation./// See the documentation for the [`Level`] type to see how `Level`s/// and `LevelFilter`s interact./// [`OFF`]: LevelFilter::OFF/// Indicates that a string could not be parsed to a valid level.MAX_LEVEL/// Construct new metadata for a span or event, with a name, target, level, field/// names, and optional source code location./// Returns the names of the fields on the described span or event./// Returns the level of verbosity of the described span or event./// Returns the name of the span./// Returns a string describing the part of the system where the span or/// event that this metadata describes occurred./// Typically, this is the module path, but alternate targets may be set/// when spans or events are constructed./// Returns the path to the Rust module where the span occurred, or/// `None` if the module path is unknown./// Returns the name of the source code file where the span/// occurred, or `None` if the file is unknown/// Returns the line number in the source code file where the span/// occurred, or `None` if the line number is unknown./// Returns an opaque `Identifier` that uniquely identifies the callsite/// this `Metadata` originated from.is_event/// Returns true if the callsite kind is `Event`./// Return true if the callsite kind is `Span`.EVENT_BITSPAN_BITHINT_BIT/// `Event` callsiteSPAN/// `Span` callsiteHINT/// `enabled!` callsite. [`Subscriber`][`crate::subscriber::Subscriber`]s can assume/// this `Kind` means they will never receive a/// full event with this [`Metadata`]./// Return true if the callsite kind is `Span`/// Return true if the callsite kind is `Event`/// Return true if the callsite kind is `Hint`/// Sets that this `Kind` is a [hint](Self::HINT)./// This can be called on [`SPAN`](Self::SPAN) and [`EVENT`](Self::EVENT)/// kinds to construct a hint callsite that also counts as a span or event.WARN/// The "off" level./// Designates that trace instrumentation should be completely disabled.from_level/// Returns a `LevelFilter` that enables spans and events with verbosity up/// to and including `level`.into_level/// Returns the most verbose [`Level`] that this filter accepts, or `None`/// if it is [`OFF`].ERROR_USIZE// These consts are necessary because `as` casts are not allowed as// match patterns.WARN_USIZEINFO_USIZEDEBUG_USIZETRACE_USIZEOFF_USIZE// Using the value of the last variant + 1 ensures that we match the value// for `Option::None` as selected by the niche optimization for// `LevelFilter`. If this is the case, converting a `usize` value into a// `LevelFilter` (in `LevelFilter::current`) will be an identity conversion,// rather than generating a lookup table./// Returns a `LevelFilter` that matches the most verbose [`Level`] that any/// currently active [`Subscriber`] will enable./// User code should treat this as a *hint*. If a given span or event has a/// level *higher* than the returned `LevelFilter`, it will not be enabled./// However, if the level is less than or equal to this value, the span or/// event is *not* guaranteed to be enabled; the subscriber will still/// filter each callsite individually./// Therefore, comparing a given span or event's level to the returned/// `LevelFilter` **can** be used for determining if something is/// *disabled*, but **should not** be used for determining if something is/// *enabled*./// [`Level`]: super::Level/// Returned if parsing a `Level` fails.filter_as_usizelevel_from_strfilter_level_conversionlevel_filter_is_usize_sizedlevel_filter_reprs//! Metadata describing trace data.// ===== impl Metadata =====// ===== impl Level =====// === impl LevelFilter ===// ==== Level and LevelFilter comparisons ====// /!\ BIG, IMPORTANT WARNING /!\// Do NOT mess with these implementations! They are hand-written for a reason!// Since comparing `Level`s and `LevelFilter`s happens in a *very* hot path// (potentially, every time a span or event macro is hit, regardless of whether// or not is enabled), we *need* to ensure that these comparisons are as fast as// possible. Therefore, we have some requirements:// 1. We want to do our best to ensure that rustc will generate integer-integer//    comparisons wherever possible.//    The derived `Ord`/`PartialOrd` impls for `LevelFilter` will not do this,//    because `LevelFilter`s are represented by `Option<Level>`, rather than as//    a separate `#[repr(usize)]` enum. This was (unfortunately) necessary for//    backwards-compatibility reasons, as the  `tracing` crate's original//    version of `LevelFilter` defined `const fn` conversions between `Level`s//    and `LevelFilter`, so we're stuck with the `Option<Level>` repr.//    Therefore, we need hand-written `PartialOrd` impls that cast both sides of//    the comparison to `usize`s, to force the compiler to generate integer//    compares.// 2. The hottest `Level`/`LevelFilter` comparison, the one that happens every//    time a callsite is hit, occurs *within the `tracing` crate's macros*.//    This means that the comparison is happening *inside* a crate that//    *depends* on `tracing-core`, not in `tracing-core` itself. The compiler//    will only inline function calls across crate boundaries if the called//    function is annotated with an `#[inline]` attribute, and we *definitely*//    want the comparison functions to be inlined: as previously mentioned, they//    should compile down to a single integer comparison on release builds, and//    it seems really sad to push an entire stack frame to call a function//    consisting of one `cmp` instruction!//    Therefore, we need to ensure that all the comparison methods have//    `#[inline]` or `#[inline(always)]` attributes. It's not sufficient to just//    add the attribute to `partial_cmp` in a manual implementation of the//    trait, since it's the comparison operators (`lt`, `le`, `gt`, and `ge`)//    that will actually be *used*, and the default implementation of *those*//    methods, which calls `partial_cmp`, does not have an inline annotation.// 3. We need the comparisons to be inverted. The discriminants for the//    `LevelInner` enum are assigned in "backwards" order, with `TRACE` having//    the *lowest* value. However, we want `TRACE` to compare greater-than all//    other levels.//    Why are the numeric values inverted? In order to ensure that `LevelFilter`//    (which, as previously mentioned, *has* to be internally represented by an//    `Option<Level>`) compiles down to a single integer value. This is//    necessary for storing the global max in an `AtomicUsize`, and for ensuring//    that we use fast integer-integer comparisons, as mentioned previously. In//    order to ensure this, we exploit the niche optimization. The niche//    optimization for `Option<{enum with a numeric repr}>` will choose//    `(HIGHEST_DISCRIMINANT_VALUE + 1)` as the representation for `None`.//    Therefore, the integer representation of `LevelFilter::OFF` (which is//    `None`) will be the number 5. `OFF` must compare higher than every other//    level in order for it to filter as expected. Since we want to use a single//    `cmp` instruction, we can't special-case the integer value of `OFF` to//    compare higher, as that will generate more code. Instead, we need it to be//    on one end of the enum, with `ERROR` on the opposite end, so we assign the//    value 0 to `ERROR`.//    This *does* mean that when parsing `LevelFilter`s or `Level`s from//    `String`s, the integer values are inverted, but that doesn't happen in a//    hot path.//    Note that we manually invert the comparisons by swapping the left-hand and//    right-hand side. Using `Ordering::reverse` generates significantly worse//    code (per Matt Godbolt's Compiler Explorer).// Anyway, that's a brief history of why this code is the way it is. Don't// change it unless you know what you're doing./// The new span will be a root span./// The new span will be rooted in the current span./// The new span has an explicitly-specified parent./// Identifies a span within the context of a subscriber./// They are generated by [`Subscriber`]s for each span as it is created, by/// the [`new_span`] trait method. See the documentation for that method for/// more information on span ID generation./// Attributes provided to a `Subscriber` describing a new span when it is/// A set of fields recorded by a span.CurrentInner/// Indicates what [the `Subscriber` considers] the "current" span./// As subscribers may not track a notion of a current span, this has three/// possible states:/// - "unknown", indicating that the subscriber does not track a current span,/// - "none", indicating that the current context is known to not be in a span,/// - "some", with the current span's [`Id`] and [`Metadata`]./// [the `Subscriber` considers]: super::subscriber::Subscriber::current_span/// [`Metadata`]: super::metadata::Metadata/// Constructs a new span ID from the given `u64`.///     <strong>Note</strong>: Span IDs must be greater than zero./// - If the provided `u64` is 0.from_non_zero_u64/// Constructs a new span ID from the given `NonZeroU64`./// Unlike [`Id::from_u64`](Id::from_u64()), this will never panic.// Allow `into` by-ref since we don't want to impl Copy for Id/// Returns the span's ID as a `u64`.into_non_zero_u64/// Returns the span's ID as a `NonZeroU64`./// Returns `Attributes` describing a new child span of the current span,/// with the provided metadata and values./// Returns `Attributes` describing a new span at the root of its own trace/// tree, with the provided metadata and values./// Returns `Attributes` describing a new child span of the specified/// parent span, with the provided metadata and values./// Returns a reference to the new span's metadata./// Returns a reference to a `ValueSet` containing any values the new span/// was created with./// Returns true if the new span should be a root./// Returns true if the new span's parent should be determined based on the/// that span should be the new span's parent. Otherwise, if the current/// thread is _not_ inside a span, then the new span will be the root of its/// Returns the new span's explicitly-specified parent, if there is one./// Otherwise (if the new span is a root or is a child of the current span),/// Records all the fields in this set of `Attributes` with the provided/// [Visitor]./// Returns `true` if this set of `Attributes` contains a value for the/// given `Field`./// Returns true if this set of `Attributes` contains _no_ values./// Returns the set of all [fields] defined by this span's [`Metadata`]./// Note that the [`FieldSet`] returned by this method includes *all* the/// fields declared by this span, not just those with values that are recorded/// as part of this set of `Attributes`. Other fields with values not present in/// this `Attributes`' value set may [record] values later./// [fields]: crate::field/// [record]: Attributes::record()/// [`FieldSet`]: crate::field::FieldSet/// Constructs a new `Record` from a `ValueSet`./// Records all the fields in this `Record` with the provided [Visitor]./// Returns the number of fields that would be visited from this `Record`/// when [`Record::record()`] is called/// [`Record::record()`]: Record::record()/// Returns `true` if this `Record` contains a value for the given `Field`./// Returns true if this `Record` contains _no_ values./// Constructs a new `Current` that indicates the current context is a span/// with the given `metadata` and `metadata`./// Constructs a new `Current` that indicates the current context is *not*/// in a span./// Constructs a new `Current` that indicates the `Subscriber` does not/// track a current span./// Returns `true` if the `Subscriber` that constructed this `Current` tracks a/// If this returns `true` and [`id`], [`metadata`], or [`into_inner`]/// return `None`, that indicates that we are currently known to *not* be/// inside a span. If this returns `false`, those methods will also return/// `None`, but in this case, that is because the subscriber does not keep/// track of the currently-entered span./// [`id`]: Current::id()/// [`metadata`]: Current::metadata()/// [`into_inner`]: Current::into_inner()/// Consumes `self` and returns the span `Id` and `Metadata` of the current/// span, if one exists and is known./// Borrows the `Id` of the current span, if one exists and is known./// Borrows the `Metadata` of the current span, if one exists and is known.//! Spans represent periods of time in the execution of a program.// ===== impl Attributes =====// ===== impl Record =====// ===== impl Current =====//! Synchronization primitives based on spinning/// This type provides MUTual EXclusion based on spinning./// A guard to which the protected data can be accessedobtain_lock/// Locks the spinlock and returns a guard./// Tries to lock the mutex. If it is already locked, it will return None. Otherwise it returns/// a guard within Some.// TODO remove option and use mem::uninitialized/// A synchronization primitive which can be used to run a one-time global/// initialization. Unlike its std equivalent, this is generalized so that the/// closure returns a value and it is stored. Once therefore acts something like/// a future, too.// Four states that a Once can be in, encoded into the lower bits of `state` inPANICKED/// Initialization constant of `Once`.r#try/// Returns a pointer iff the `Once` was previously initialized/// Like try, but will spin if the `Once` is in the process of being/// initializedon_register_dispatch/// Invoked when this subscriber becomes a [`Dispatch`]./// ## Avoiding Memory Leaks/// `Subscriber`s should not store their own [`Dispatch`]. Because the/// `Dispatch` owns the `Subscriber`, storing the `Dispatch` within the/// `Subscriber` will create a reference count cycle, preventing the `Dispatch`/// from ever being dropped./// Instead, when it is necessary to store a cyclical reference to the/// `Dispatch` within a `Subscriber`, use [`Dispatch::downgrade`] to convert a/// `Dispatch` into a [`WeakDispatch`]. This type is analogous to/// [`std::sync::Weak`], and does not create a reference count cycle. A/// [`WeakDispatch`] can be stored within a `Subscriber` without causing a/// memory leak, and can be [upgraded] into a `Dispatch` temporarily when/// the `Dispatch` must be accessed by the `Subscriber`./// [`WeakDispatch`]: crate::dispatcher::WeakDispatch/// [upgraded]: crate::dispatcher::WeakDispatch::upgrade/// Registers a new [callsite] with this subscriber, returning whether or not/// By default, this function assumes that the subscriber's [filter]/// represents an unchanging view of its interest in the callsite. However,/// if this is not the case, subscribers may override this function to/// indicate different interests, or to implement behaviour that should run/// once for every callsite./// This function is guaranteed to be called at least once per callsite on/// every active subscriber. The subscriber may store the keys to fields it/// cares about in order to reduce the cost of accessing fields by name,/// preallocate storage for that callsite, or perform any other actions it/// wishes to perform once for each callsite./// The subscriber should then return an [`Interest`], indicating/// whether it is interested in being notified about that callsite in the/// future. This may be `Always` indicating that the subscriber always/// wishes to be notified about the callsite, and its filter need not be/// re-evaluated; `Sometimes`, indicating that the subscriber may sometimes/// care about the callsite but not always (such as when sampling), or/// `Never`, indicating that the subscriber never wishes to be notified about/// that callsite. If all active subscribers return `Never`, a callsite will/// never be enabled unless a new subscriber expresses interest in it./// `Subscriber`s which require their filters to be run every time an event/// occurs or a span is entered/exited should return `Interest::sometimes`./// If a subscriber returns `Interest::sometimes`, then its [`enabled`] method/// will be called every time an event or span is created from that callsite./// For example, suppose a sampling subscriber is implemented by/// incrementing a counter every time `enabled` is called and only returning/// `true` when the counter is divisible by a specified sampling rate. If/// that subscriber returns `Interest::always` from `register_callsite`, then/// the filter will not be re-evaluated once it has been applied to a given/// set of metadata. Thus, the counter will not be incremented, and the span/// or event that corresponds to the metadata will never be `enabled`./// `Subscriber`s that need to change their filters occasionally should call/// [`rebuild_interest_cache`] to re-evaluate `register_callsite` for all/// Similarly, if a `Subscriber` has a filtering strategy that can be/// changed dynamically at runtime, it would need to re-evaluate that filter/// if the cached results have changed./// A subscriber which manages fanout to multiple other subscribers/// should proxy this decision to all of its child subscribers,/// returning `Interest::never` only if _all_ such children return/// `Interest::never`. If the set of subscribers to which spans are/// broadcast may change dynamically, the subscriber should also never/// return `Interest::Never`, as a new subscriber may be added that _is_/// interested./// See the [documentation on the callsite registry][cs-reg] for more/// details on how and when the `register_callsite` method is called./// This function may be called again when a new subscriber is created or/// when the registry is invalidated./// If a subscriber returns `Interest::never` for a particular callsite, it/// _may_ still see spans and events originating from that callsite, if/// another subscriber expressed interest in it./// [callsite]: crate::callsite/// [filter]: Self::enabled/// [`enabled`]: Subscriber::enabled()/// [`rebuild_interest_cache`]: super::callsite::rebuild_interest_cache/// [cs-reg]: crate::callsite#registering-callsites/// Returns true if a span or event with the specified [metadata] would be/// By default, it is assumed that this filter needs only be evaluated once/// for each callsite, so it is called by [`register_callsite`] when each/// callsite is registered. The result is used to determine if the subscriber/// is always [interested] or never interested in that callsite. This is intended/// primarily as an optimization, so that expensive filters (such as those/// involving string search, et cetera) need not be re-evaluated./// However, if the subscriber's interest in a particular span or event may/// change, or depends on contexts only determined dynamically at runtime,/// then the `register_callsite` method should be overridden to return/// [`Interest::sometimes`]. In that case, this function will be called every/// time that span or event occurs./// [interested]: Interest/// [`Interest::sometimes`]: Interest::sometimes/// [`register_callsite`]: Subscriber::register_callsite()/// Returns the highest [verbosity level][level] that this `Subscriber` will/// If this method returns a [`Level`][level], it will be used as a hint to/// determine the most verbose level that will be enabled. This will allow/// spans and events which are more verbose than that level to be skipped/// more efficiently. Subscribers which perform filtering are strongly/// encouraged to provide an implementation of this method./// If the maximum level the subscriber will enable can change over the/// course of its lifetime, it is free to return a different value from/// multiple invocations of this method. However, note that changes in the/// maximum level will **only** be reflected after the callsite [`Interest`]/// cache is rebuilt, by calling the [`callsite::rebuild_interest_cache`][rebuild]/// function. Therefore, if the subscriber will change the value returned by/// this method, it is responsible for ensuring that/// [`rebuild_interest_cache`][rebuild] is called after the value of the max/// level changes./// [rebuild]: super::callsite::rebuild_interest_cache/// Visit the construction of a new span, returning a new [span ID] for the/// The provided [`Attributes`] contains any field values that were provided/// when the span was created. The subscriber may pass a [visitor] to the/// `Attributes`' [`record` method] to record these values./// IDs are used to uniquely identify spans and events within the context of a/// subscriber, so span equality will be based on the returned ID. Thus, if/// the subscriber wishes for all spans with the same metadata to be/// considered equal, it should return the same ID every time it is given a/// particular set of metadata. Similarly, if it wishes for two separate/// instances of a span with the same metadata to *not* be equal, it should/// return a distinct ID every time this function is called, regardless of/// the metadata./// Note that the subscriber is free to assign span IDs based on whatever/// scheme it sees fit. Any guarantees about uniqueness, ordering, or ID/// reuse are left up to the subscriber implementation to determine./// [`Attributes`]: super::span::Attributes/// [`record` method]: super::span::Attributes::record/// This method will be invoked when value is recorded on a span./// Recording multiple values for the same field is possible,/// but the actual behaviour is defined by the subscriber implementation./// Keep in mind that a span might not provide a value/// for each field it declares./// The subscriber is expected to provide a [visitor] to the `Record`'s/// [`record` method] in order to record the added values.///  "foo = 3" will be recorded when [`record`] is called on the/// `Attributes` passed to `new_span`./// Since values are not provided for the `bar` and `baz` fields,/// the span's `Metadata` will indicate that it _has_ those fields,/// but values for them won't be recorded at this time./// # use tracing::span;/// let mut span = span!("my_span", foo = 3, bar, baz);/// // `Subscriber::record` will be called with a `Record`/// // containing "bar = false"/// span.record("bar", &false);/// // containing "baz = "a string""/// span.record("baz", &"a string");/// [`record`]: super::span::Attributes::record/// [`record` method]: super::span::Record::record/// If the subscriber has spans corresponding to the given IDs, it should/// record this relationship in whatever way it deems necessary. Otherwise,/// if one or both of the given span IDs do not correspond to spans that the/// subscriber knows about, or if a cyclical relationship would be created/// (i.e., some span _a_ which proceeds some other span _b_ may not also/// follow from _b_), it may silently do nothing./// Determine if an [`Event`] should be recorded./// By default, this returns `true` and `Subscriber`s can filter events in/// [`event`][Self::event] without any penalty. However, when `event` is/// more complicated, this can be used to determine if `event` should be/// called at all, separating out the decision from the processing./// This method will be invoked when an Event is constructed by/// the `Event`'s [`dispatch` method]. For example, this happens internally/// when an event macro from `tracing` is called./// The key difference between this method and `record` is that `record` is/// called when a value is recorded for a field defined by a span,/// while `event` is called when a new event occurs./// The provided `Event` struct contains any field values attached to the/// event. The subscriber may pass a [visitor] to the `Event`'s/// [`record` method] to record these values./// [`record` method]: super::event::Event::record/// [`dispatch` method]: super::event::Event::dispatch/// Records that a span has been entered./// When entering a span, this method is called to notify the subscriber/// that the span has been entered. The subscriber is provided with the/// [span ID] of the entered span, and should update any internal state/// tracking the current span accordingly./// When exiting a span, this method is called to notify the subscriber/// that the span has been exited. The subscriber is provided with the/// [span ID] of the exited span, and should update any internal state/// Exiting a span does not imply that the span will not be re-entered./// This function is guaranteed to only be called with span IDs that were/// returned by this subscriber's `new_span` function./// Note that the default implementation of this function this is just the/// identity function, passing through the identifier. However, it can be/// used in conjunction with [`try_close`] to track the number of handles/// capable of `enter`ing a span. When all the handles have been dropped/// (i.e., `try_close` has been called one more time than `clone_span` for a/// given ID), the subscriber may assume that the span will not be entered/// again. It is then free to deallocate storage for data associated with/// that span, write data from that span to IO, and so on./// For more unsafe situations, however, if `id` is itself a pointer of some/// kind this can be used as a hook to "clone" the pointer, depending on/// what that means for the specified pointer./// [`try_close`]: Subscriber::try_close/// **This method is deprecated.**/// Using `drop_span` may result in subscribers composed using/// `tracing-subscriber` crate's `Layer` trait from observing close events./// Use [`try_close`] instead./// The default implementation of this function does nothing./// `true` if there are now 0 IDs that refer to that span./// Higher-level libraries providing functionality for composing multiple/// subscriber implementations may use this return value to notify any/// "layered" subscribers that this subscriber considers the span closed./// The default implementation of this method calls the subscriber's/// [`drop_span`] method and returns `false`. This means that, unless the/// subscriber overrides the default implementation, close notifications/// will never be sent to any layered subscribers. In general, if the/// subscriber tracks reference counts, this method should be implemented,/// rather than `drop_span`./// It's guaranteed that if this function has been called once more than the/// number of times `clone_span` was called with the same `id`, then no more/// handles that can enter the span with that `id` exist. This means that it/// can be used in conjunction with [`clone_span`] to track the number of/// handles capable of `enter`ing a span. When all the handles have been/// dropped (i.e., `try_close` has been called one more time than/// `clone_span` for a given ID), the subscriber may assume that the span/// will not be entered again, and should return `true`. It is then free to/// deallocate storage for data associated with that span, write data from/// that span to IO, and so on./// **Note**: since this function is called when spans are dropped,/// implementations should ensure that they are unwind-safe. Panicking from/// inside of a `try_close` function may cause a double panic, if the span/// was dropped due to a thread unwinding./// [`clone_span`]: Subscriber::clone_span/// [`drop_span`]: Subscriber::drop_span/// If subscribers track a current span, they should override this function/// to return [`Current::new`] if the thread from which this method is/// called is inside a span, or [`Current::none`] if the thread is not/// inside a span./// By default, this returns a value indicating that the subscriber/// does **not** track what span is current. If the subscriber does not/// implement a current span, it should not override this method./// [`Current::new`]: super::span::Current#tymethod.new/// [`Current::none`]: super::span::Current#tymethod.nonedowncast_raw/// If `self` is the same type as the provided `TypeId`, returns an untyped/// `*const` pointer to that type. Otherwise, returns `None`./// If you wish to downcast a `Subscriber`, it is strongly advised to use/// the safe API provided by [`downcast_ref`] instead./// This API is required for `downcast_raw` to be a trait method; a method/// signature like [`downcast_ref`] (with a generic type parameter) is not/// object-safe, and thus cannot be a trait method for `Subscriber`. This/// means that if we only exposed `downcast_ref`, `Subscriber`/// implementations could not override the downcasting behavior/// This method may be overridden by "fan out" or "chained" subscriber/// implementations which consist of multiple composed types. Such/// subscribers might allow `downcast_raw` by returning references to those/// component if they contain components with the given `TypeId`./// The [`downcast_ref`] method expects that the pointer returned by/// `downcast_raw` is non-null and points to a valid instance of the type/// with the provided `TypeId`. Failure to ensure this will result in/// undefined behaviour, so implementing `downcast_raw` is unsafe./// [`downcast_ref`]: #method.downcast_ref// === Notification methods ===============================================// === Downcasting methods ================================================/// Trait representing the functions required to collect trace data./// Crates that provide implementations of methods for collecting or recording/// trace data should implement the `Subscriber` interface. This trait is/// intended to represent fundamental primitives for collecting trace events and/// spans — other libraries may offer utility functions and types to make/// subscriber implementations more modular or improve the ergonomics of writing/// subscribers./// A subscriber is responsible for the following:/// - Registering new spans as they are created, and providing them with span///   IDs. Implicitly, this means the subscriber may determine the strategy for///   determining span equality./// - Recording the attachment of field values and follows-from annotations to///   spans./// - Filtering spans and events, and determining when those filters must be///   invalidated./// - Observing spans as they are entered, exited, and closed, and events as///   they occur./// When a span is entered or exited, the subscriber is provided only with the/// [ID] with which it tagged that span when it was created. This means/// that it is up to the subscriber to determine whether and how span _data_ —/// the fields and metadata describing the span — should be stored. The/// [`new_span`] function is called when a new span is created, and at that/// point, the subscriber _may_ choose to store the associated data if it will/// be referenced again. However, if the data has already been recorded and will/// not be needed by the implementations of `enter` and `exit`, the subscriber/// may freely discard that data without allocating space to store it./// ## Overriding default impls/// Some trait methods on `Subscriber` have default implementations, either in/// order to reduce the surface area of implementing `Subscriber`, or for/// backward-compatibility reasons. However, many subscribers will likely want/// to override these default implementations./// The following methods are likely of interest:/// - [`register_callsite`] is called once for each callsite from which a span///   event may originate, and returns an [`Interest`] value describing whether or///   not the subscriber wishes to see events or spans from that callsite. By///   default, it calls [`enabled`], and returns `Interest::always()` if///   `enabled` returns true, or `Interest::never()` if enabled returns false.///   However, if the subscriber's interest can change dynamically at runtime,///   it may want to override this function to return `Interest::sometimes()`.///   Additionally, subscribers which wish to perform a behaviour once for each///   callsite, such as allocating storage for data related to that callsite,///   can perform it in `register_callsite`.///   See also the [documentation on the callsite registry][cs-reg] for details///   on [`register_callsite`]./// - [`event_enabled`] is called once before every call to the [`event`]///   method. This can be used to implement filtering on events once their field///   values are known, but before any processing is done in the `event` method./// - [`clone_span`] is called every time a span ID is cloned, and [`try_close`]///   is called when a span ID is dropped. By default, these functions do///   nothing. However, they can be used to implement reference counting for///   spans, allowing subscribers to free storage for span data and to determine///   when a span has _closed_ permanently (rather than being exited).///   Subscribers which store per-span data or which need to track span closures///   should override these functions together./// [`new_span`]: Subscriber::new_span/// [`register_callsite`]: Subscriber::register_callsite/// [`enabled`]: Subscriber::enabled/// [`event`]: Subscriber::event/// [`event_enabled`]: Subscriber::event_enabled/// Returns `true` if this `Subscriber` is the same type as `T`./// Returns some reference to this `Subscriber` value if it is of type `T`,/// or `None` if it isn't./// Returns `true` if this [`Subscriber`] is the same type as `T`./// Returns some reference to this [`Subscriber`] value if it is of type `T`,/// Returns some reference to this `[`Subscriber`] value if it is of type `T`,InterestKind/// Indicates a [`Subscriber`]'s interest in a particular callsite./// `Subscriber`s return an `Interest` from their [`register_callsite`] methods/// in order to determine whether that span should be enabled or disabled./// [`register_callsite`]: super::Subscriber::register_callsite/// Returns an `Interest` indicating that the subscriber is never interested/// in being notified about a callsite./// If all active subscribers are `never()` interested in a callsite, it will/// be completely disabled unless a new subscriber becomes active.sometimes/// Returns an `Interest` indicating the subscriber is sometimes interested/// If all active subscribers are `sometimes` or `never` interested in a/// callsite, the currently active subscriber will be asked to filter that/// callsite every time it creates a span. This will be the case until a new/// subscriber expresses that it is `always` interested in the callsite./// Returns an `Interest` indicating the subscriber is always interested in/// being notified about a callsite./// If any subscriber expresses that it is `always()` interested in a given/// callsite, then the callsite will always be enabled.is_never/// Returns `true` if the subscriber is never interested in being notified/// about this callsite.is_sometimes/// Returns `true` if the subscriber is sometimes interested in being notifiedis_always/// Returns `true` if the subscriber is always interested in being notified/// Returns the common interest between these two Interests./// If both interests are the same, this propagates that interest./// Otherwise, if they differ, the result must always be/// `Interest::sometimes` --- if the two subscribers differ in opinion, we/// will have to ask the current subscriber what it thinks, no matter what./// A no-op [`Subscriber`]./// [`NoSubscriber`] implements the [`Subscriber`] trait by never being enabled,/// never being interested in any callsite, and dropping all spans and events./// Returns a new `NoSubscriber`.//! Collectors collect and record trace data.LruCachemin_verbositylru_cache_sizeInterestCacheConfig/// The interest cache configuration.with_min_verbosity/// Sets the minimum logging verbosity for which the cache will apply./// The interest for logs with a lower verbosity than specified here/// will not be cached./// It should be set to the lowest verbosity level for which the majority/// of the logs in your application are usually *disabled*./// In normal circumstances with typical logger usage patterns/// you shouldn't ever have to change this./// By default this is set to `Debug`.with_lru_cache_size/// Sets the number of entries in the LRU cache used to cache interests/// for `log` records./// The bigger the cache, the more unlikely it will be for the interest/// in a given callsite to be recalculated, at the expense of extra/// memory usage per every thread which tries to log events./// Every unique [level] + [target] pair consumes a single slot/// in the cache. Entries will be added to the cache until its size/// reaches the value configured here, and from then on it will evict/// the least recently seen level + target pair when adding a new entry./// The ideal value to set here widely depends on how much exactly/// you're logging, and how diverse the targets are to which you are logging./// If your application spends a significant amount of time filtering logs/// which are *not* getting printed out then increasing this value will most/// likely help./// Setting this to zero will disable the cache./// By default this is set to 1024./// [level]: log::Metadata::level/// [target]: log::Metadata::targettarget_addresslevel_and_lengthINTEREST_CACHE_EPOCHinterest_cache_epochSentinelCallsiteSENTINEL_CALLSITESENTINEL_METADATAtry_cachelock_for_testtest_when_disabled_the_callback_is_always_calledtest_when_enabled_the_callback_is_called_only_once_for_a_high_enough_verbositytest_when_core_interest_cache_is_rebuilt_this_cache_is_also_flushedtest_when_enabled_the_callback_is_always_called_for_a_low_enough_verbositytest_different_log_levels_are_cached_separatelytest_different_log_targets_are_cached_separatelytest_when_cache_runs_out_of_space_the_callback_is_called_againtest_cache_returns_previously_computed_valuetest_cache_handles_non_static_target_string// When the logger's filters are reconfigured the interest cache in core is cleared,// and we also want to get notified when that happens so that we can clear our cache too.// So what we do here is to register a dummy callsite with the core, just so that we can be// notified when that happens. It doesn't really matter how exactly our dummy callsite looks// like and whether subscribers will actually be interested in it, since nothing will actually// be logged from it.log_tracerLogTracerformat_trace/// Format a log record as a trace event in the current span.dispatch_record// XXX(eliza): this is factored out so that we don't have to deal with the pub// function `format_trace`'s `Result` return type...maybe we should get rid of// that in 0.2.../// The `log` type that this type can be converted into.as_log/// Returns the `log` equivalent of `self`.AsLog/// Trait implemented for `tracing` types that can be converted to a `log`/// The `tracing` type that this type can be converted into.as_trace/// Returns the `tracing` equivalent of `self`.AsTrace/// Trait implemented for `log` types that can be converted to a `tracing`FIELD_NAMESlog_csTraceCallsiteTRACE_CSTRACE_METADebugCallsiteDEBUG_CSDEBUG_METAInfoCallsiteINFO_CSINFO_METAWarnCallsiteWARN_CSWARN_METAErrorCallsiteERROR_CSERROR_METATRACE_FIELDSDEBUG_FIELDSINFO_FIELDSWARN_FIELDSERROR_FIELDSlevel_to_csloglevel_to_csnormalized_metadata/// If this `Event` comes from a `log`, this method provides a new/// normalized `Metadata` which has all available attributes/// from the original log, including `file`, `line`, `module_path`/// and `target`./// Returns `None` is the `Event` is not issued from a `log`.is_log/// Returns whether this `Event` represents a log (from the `log` crate)NormalizeEvent/// Extends log `Event`s to provide complete `Metadata`./// In `tracing-log`, an `Event` produced by a log (through [`AsTrace`]) has an hard coded/// "log" target and no `file`, `line`, or `module_path` attributes. This happens because `Event`/// requires its `Metadata` to be `'static`, while [`log::Record`]s provide them with a generic/// However, these values are stored in the `Event`'s fields and/// the [`normalized_metadata`] method allows to build a new `Metadata`/// that only lives as long as its source `Event`, but provides complete/// It can typically be used by `Subscriber`s when processing an `Event`,/// to allow accessing its complete metadata in a consistent way,/// regardless of the source of its source./// [`normalized_metadata`]: NormalizeEvent#normalized_metadataLogVisitornew_for// We don't actually _use_ the provided event argument; it is simply to// ensure that the `LogVisitor` does not outlive the event whose fields it// is visiting, so that the reference casts in `record_str` are safe.test_callsiteerror_callsite_is_correctwarn_callsite_is_correctinfo_callsite_is_correctdebug_callsite_is_correcttrace_callsite_is_correct//! Adapters for connecting unstructured log records from the `log` crate into//! the `tracing` ecosystem.//! [`tracing`] is a framework for instrumenting Rust programs with context-aware,//! structured, event-based diagnostic information. This crate provides//! compatibility layers for using `tracing` alongside the logging facade provided//! by the [`log`] crate.//! - [`AsTrace`] and [`AsLog`] traits for converting between `tracing` and `log` types.//! - [`LogTracer`], a [`log::Log`] implementation that consumes [`log::Record`]s//!   and outputs them as [`tracing::Event`].//! *Compiler support: [requires `rustc` 1.56+][msrv]*//! ## Convert log records to tracing `Event`s//! To convert [`log::Record`]s as [`tracing::Event`]s, set `LogTracer` as the default//! logger by calling its [`init`] or [`init_with_filter`] methods.//! use tracing_log::LogTracer;//! use log;//! # fn main() -> Result<(), Box<Error>> {//! LogTracer::init()?;//! // will be available for Subscribers as a tracing Event//! log::trace!("an example trace log");//! This conversion does not convert unstructured data in log records (such as//! values passed as format arguments to the `log!` macro) to structured//! `tracing` fields. However, it *does* attach these new events to to the//! span that was currently executing when the record was logged. This is the//! primary use-case for this library: making it possible to locate the log//! records emitted by dependencies which use `log` within the context of a//! trace.//! ## Convert tracing `Event`s to logs//! Enabling the ["log" and "log-always" feature flags][flags] on the `tracing`//! crate will cause all `tracing` spans and events to emit `log::Record`s as//! they occur.//! ## Caution: Mixing both conversions//! Note that `log::Logger` implementations that convert log records to trace events//! should not be used with `Subscriber`s that convert trace events _back_ into//! `log` records, as doing so will result in the event recursing between the subscriber//! and the logger forever (or, in real life, probably overflowing the call stack).//! If the logging of trace events generated from log records produced by the//! `log` crate is desired, either the `log` crate should not be used to//! implement this logging, or an additional layer of filtering will be//! required to avoid infinitely converting between `Event` and `log::Record`.//! * `std`: enables features that require the Rust standard library (on by default)//! * `log-tracer`: enables the `LogTracer` type (on by default)//! * `interest-cache`: makes it possible to configure an interest cache for//!   logs emitted through the `log` crate (see [`Builder::with_interest_cache`]); requires `std`//! version is 1.56. The current Tracing version is not guaranteed to build on//! [`init`]: LogTracer::init//! [`init_with_filter`]: LogTracer::init_with_filter//! [`tracing::Subscriber`]: https://docs.rs/tracing/latest/tracing/trait.Subscriber.html//! [`Subscriber`]: https://docs.rs/tracing/latest/tracing/trait.Subscriber.html//! [`tracing::Event`]: https://docs.rs/tracing/latest/tracing/struct.Event.html//! [flags]: https://docs.rs/tracing/latest/tracing/#crate-feature-flags//! [`Builder::with_interest_cache`]: log_tracer::Builder::with_interest_cacheignore_crates/// A simple "logger" that converts all log records into `tracing` `Event`s./// Configures a new `LogTracer`./// Returns a builder that allows customizing a `LogTracer` and setting it/// the default logger./// use tracing_log::LogTracer;/// use log;/// # fn main() -> Result<(), Box<Error>> {/// LogTracer::builder()///     .ignore_crate("foo") // suppose the `foo` crate is using `tracing`'s log feature///     .with_max_level(log::LevelFilter::Info)///     .init()?;/// // will be available for Subscribers as a tracing Event/// log::info!("an example info log");/// Creates a new `LogTracer` that can then be used as a logger for the `log` crate./// It is generally simpler to use the [`init`] or [`init_with_filter`] methods/// which will create the `LogTracer` and set it as the global logger./// Logger setup without the initialization methods can be done with:/// let logger = LogTracer::new();/// log::set_boxed_logger(Box::new(logger))?;/// log::set_max_level(log::LevelFilter::Trace);/// log::trace!("an example trace log");/// [`init`]: LogTracer::init()/// [`init_with_filter`]: .#method.init_with_filterinit_with_filter/// Sets up `LogTracer` as global logger for the `log` crate,/// with the given level as max level filter./// Setting a global logger can only be done once./// The [`builder`] function can be used to customize the `LogTracer` before/// initializing it./// [`builder`]: LogTracer::builder()/// Sets a `LogTracer` as the global logger for the `log` crate./// LogTracer::init()?;/// This will forward all logs to `tracing` and lets the current `Subscriber`/// determine if they are enabled./// If you know in advance you want to filter some log levels,/// use [`builder`] or [`init_with_filter`] instead./// [`init_with_filter`]: LogTracer::init_with_filter()try_cache_interest/// Returns a new `Builder` to construct a [`LogTracer`].with_max_level/// Sets a global maximum level for `log` records./// Log records whose level is more verbose than the provided level will be/// By default, all `log` records will be enabled.ignore_crate/// Configures the `LogTracer` to ignore all log records whose target/// starts with the given string./// This should be used when a crate enables the `tracing/log` feature to/// emit log records for tracing events. Otherwise, those events will be/// recorded twice.ignore_all/// starts with any of the given the given strings./// Constructs a new `LogTracer` with the provided configuration and sets it/// as the default logger.//! An adapter for converting [`log`] records into `tracing` `Event`s.//! This module provides the [`LogTracer`] type which implements `log`'s [logger//! interface] by recording log records as `tracing` `Event`s. This is intended for//! use in conjunction with a `tracing` `Subscriber` to consume events from//! dependencies that emit [`log`] records within a trace context.//! To create and initialize a `LogTracer` with the default configurations, use://! * [`init`] if you want to convert all logs, regardless of log level,//!   allowing the tracing `Subscriber` to perform any filtering//! * [`init_with_filter`] to convert all logs up to a specified log level//! In addition, a [builder] is available for cases where more advanced//! configuration is required. In particular, the builder can be used to [ignore//! log records][ignore] emitted by particular crates. This is useful in cases//! such as when a crate emits both `tracing` diagnostics _and_ log records by//! default.//! [logger interface]: log::Log//! [`init`]: LogTracer.html#method.init//! [`init_with_filter`]: LogTracer.html#method.init_with_filter//! [builder]: LogTracer::builder()//! [ignore]: Builder::ignore_crate()// ===== impl LogTracer =====MakeVisitorVisitFmtVisitOutput/// A visitor wrapper that ensures any `fmt::Debug` fields are formatted using/// the alternate (`:#`) formatter./// Wraps the provided visitor so that any `fmt::Debug` fields are formatted/// using the alternative (`:#`) formatter.// === impl Alt ===make_visitor// TODO(eliza): add RecordError when stable// fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {//     self.record_debug(field, &format_args!("{}", value))VisitWrite//! `MakeVisitor` wrappers for working with `fmt::Debug` fields.// TODO(eliza): When `error` as a primitive type is stable, add a// `DisplayErrors` wrapper.../// A `MakeVisitor` wrapper that wraps a visitor that writes formatted output so/// that a delimiter is inserted between writing formatted field values.VisitDelimited/// A visitor wrapper that inserts a delimiter after the wrapped visitor formats/// a field value./// Returns a new [`MakeVisitor`] implementation that wraps `inner` so that/// it will format each visited field separated by the provided `delimiter`./// [`MakeVisitor`]: super::MakeVisitor/// Returns a new [`Visit`] implementation that wraps `inner` so that/// each formatted field is separated by the provided `delimiter`./// [`Visit`]: tracing_core::field::Visitdelimitdelimited_visitordelimited_new_visitor//! A `MakeVisitor` wrapper that separates formatted fields with a delimiter.// === impl Delimited ===// === impl VisitDelimited ===/// A visitor wrapper that ensures any strings named "message" are formatted/// using `fmt::Display`/// Returns a new [`MakeVisitor`] implementation that will wrap `inner` so/// that any strings named `message` are formatted using `fmt::Display`.// === impl Messages ===//! `MakeVisitor` wrappers for working with `fmt::Display` fields./// The visitor type produced by this `MakeVisitor`./// Make a new visitor for the provided `target`./// Creates new [visitors]./// A type implementing `MakeVisitor` represents a composable factory for types/// implementing the [`Visit` trait][visitors]. The `MakeVisitor` trait defines/// a single function, `make_visitor`, which takes in a `T`-typed `target` and/// returns a type implementing `Visit` configured for that target. A target may/// be a string, output stream, or data structure that the visitor will record/// data to, configuration variables that determine the visitor's behavior, or/// `()` when no input is required to produce a visitor./// [visitors]: tracing_core::field::Visit/// Completes the visitor, returning any output./// This is called once a full set of fields has been visited.RecordFields/// Visit a set of fields, and return the output of finishing the visitor/// once the fields have been visited./// A [visitor] that produces output once it has visited a set of fields./// [visitor]: tracing_core::field::Visit/// Record all the fields in `self` with the provided `visitor`.RecordFieldsMarker/// Extension trait implemented by types which can be recorded by a [visitor]./// This allows writing code that is generic over `tracing_core`'s/// [`span::Attributes`][attr], [`span::Record`][rec], and [`Event`]/// types. These types all provide inherent `record` methods that allow a/// visitor to record their fields, but there is no common trait representing this./// With `RecordFields`, we can write code like this:/// use tracing_core::field::Visit;/// # use tracing_core::field::Field;/// use tracing_subscriber::field::RecordFields;/// struct MyVisitor {/// # impl MyVisitor { fn new() -> Self { Self{} } }/// impl Visit for MyVisitor {/// # fn record_debug(&mut self, _: &Field, _: &dyn std::fmt::Debug) {}/// fn record_with_my_visitor<R>(r: R)///     R: RecordFields,///     let mut visitor = MyVisitor::new();///     r.record(&mut visitor);/// [attr]: tracing_core::span::Attributes/// [rec]: tracing_core::span::Recordvisit_with/// Visits all fields in `fields` with a new visitor constructed fromMakeOutput/// Extension trait implemented for all `MakeVisitor` implementations that/// produce a visitor implementing `VisitOutput`.r" Returns the writer that this visitor writes to."r" Extension trait implemented by visitors to indicate that they write to an"r" `io::Write` instance, and allow access to that writer."/// Returns the formatter that this visitor writes to./// Extension trait implemented by visitors to indicate that they write to a/// `fmt::Write` instance, and allow access to that writer.debug_alt/// Wraps `self` so that any `fmt::Debug` fields are recorded using the/// alternate formatter (`{:#?}`).display_messages/// Wraps `self` so that any string fields named "message" are recorded/// using `fmt::Display`./// Wraps `self` so that when fields are formatted to a writer, they are/// separated by the provided `delimiter`.MakeExtMakeExtMarker/// Extension trait providing `MakeVisitor` combinators.TestAttrs1TestAttrs2MakeDebugDebugVisitor//! Utilities for working with [fields] and [field visitors].//! [fields]: tracing_core::field//! [field visitors]: tracing_core::field::Visit// === impl RecordFields ===// === blanket impls ===/// Indicates that a string could not be parsed as a filtering directive.field_namesStaticDirective/// A directive which will statically enable or disable a given callsite./// Unlike a dynamic directive, this can be cached by the callsite.FilterVecDirectiveSetcares_aboutdirectives_fortarget_enabled/// Same as `enabled` above, but skips `Directive`'s with fields.directives_for_targetcares_about_target// === impl DirectiveSet ===// === impl Statics ===// === impl StaticDirective ===// === impl ParseError ===default_directive/// A [builder] for constructing new [`EnvFilter`]s.with_regex/// Sets whether span field values can be matched with regular expressions./// If this is `true`, field filter directives will be interpreted as/// regular expressions if they are not able to be interpreted as a `bool`,/// `i64`, `u64`, or `f64` literal. If this is `false,` those field values/// will be interpreted as literal [`std::fmt::Debug`] output instead./// By default, regular expressions are enabled./// **Note**: when [`EnvFilter`]s are constructed from untrusted inputs,/// disabling regular expressions is strongly encouraged.with_default_directive/// Sets a default [filtering directive] that will be added to the filter if/// the parsed string or environment variable contains no filter directives./// By default, there is no default directive./// If [`parse`], [`parse_lossy`], [`from_env`], or [`from_env_lossy`] are/// called with an empty string or environment variable, the default/// directive is used instead:/// use tracing_subscriber::filter::{EnvFilter, LevelFilter};/// let filter = EnvFilter::builder()///     .with_default_directive(LevelFilter::INFO.into())///     .parse("")?;/// assert_eq!(format!("{}", filter), "info");/// Note that the `lossy` variants ([`parse_lossy`] and [`from_env_lossy`])/// will ignore any invalid directives. If all directives in a filter/// string or environment variable are invalid, those methods will also use/// the default directive:///     .parse_lossy("some_target=fake level,foo::bar=lolwut");/// If the string or environment variable contains valid filtering/// directives, the default directive is not used:///     .parse_lossy("foo=trace");/// // The default directive is *not* used:/// assert_eq!(format!("{}", filter), "foo=trace");/// Parsing a more complex default directive from a string:/// let default = "myapp=debug".parse()///     .expect("hard-coded default directive should be valid");///     .with_default_directive(default)/// assert_eq!(format!("{}", filter), "myapp=debug");/// [`parse_lossy`]: Self::parse_lossy/// [`from_env_lossy`]: Self::from_env_lossy/// [`parse`]: Self::parse/// [`from_env`]: Self::from_envwith_env_var/// Sets the name of the environment variable used by the [`from_env`],/// [`from_env_lossy`], and [`try_from_env`] methods./// By default, this is the value of [`EnvFilter::DEFAULT_ENV`]/// (`RUST_LOG`)./// [`try_from_env`]: Self::try_from_envparse_lossy/// Returns a new [`EnvFilter`] from the directives in the given string,/// *ignoring* any that are invalid./// or an error if any are invalid.from_env_lossy/// Returns a new [`EnvFilter`] from the directives in the configured/// environment variable, ignoring any directives that are invalid./// environment variable. If the environment variable is unset, no directive is added./// An error is returned if the environment contains invalid directives.try_from_env/// environment variable, or an error if the environment variable is not set/// or contains invalid directives.from_directives// Clippy doesn't love this naming, because it suggests that `from_` methods// should not take a `Self`...but in this case, it's the `EnvFilter` that is// being constructed "from" the directives, rather than the builder itself.env_var_namein_span/// A single filtering directive.// TODO(eliza): add a builder for programmatically constructing directives?Dynamics/// A set of dynamic filtering directives.Statics/// A set of static filtering directives.CallsiteMatcherCallsiteMatchMatchSetSpanMatcherSpanMatchfield_matchesbase_levelis_dynamicfield_matchermake_tablesderegexifyhas_value_filtersto_span_match/// Create a new `SpanMatch` for a given instance of the matched callsite./// Returns the level currently enabled for this callsite.record_updateparse_directivesexpect_parsedirective_ordering_by_target_lendirective_ordering_by_spandirective_ordering_uses_lexicographic_when_equaldirective_ordering_by_field_num// TODO: this test requires the parser to support directives with multiple// fields, which it currently can't handle. We should enable this test when// that's implemented.parse_directives_ralithparse_directives_ralith_ucparse_directives_ralith_mixedparse_directives_validparse_level_directivesparse_uppercase_level_directivesparse_numeric_level_directivesparse_directives_invalid_crateparse_directives_invalid_levelparse_directives_string_levelparse_directives_empty_levelparse_directives_globaltest_parse_bare_level// helper function for tests belowparse_directives_global_bare_warn_lcparse_directives_global_bare_warn_ucparse_directives_global_bare_warn_mixedparse_directives_valid_with_spansparse_directives_with_dash_in_target_nameparse_directives_with_dash_in_span_nameparse_directives_with_special_characters_in_span_nameparse_directives_with_invalid_span_chars// === impl Dynamics ===// ===== impl DynamicMatch =====matchersValueMatch// TODO: allow match patterns for names?has_matchedMatchVisitor/// Matches a specific `bool` value./// Matches a specific `f64` value./// Matches a specific `u64` value./// Matches a specific `i64` value.NaN/// Matches any `NaN` `f64` value.MatchDebug/// Matches any field whose `fmt::Debug` output is equal to a fixed string.MatchPattern/// Matches any field whose `fmt::Debug` output matches a regular expression/// Matches a field's `fmt::Debug` output against a regular expression pattern./// This is used for matching all non-literal field value filters when regular/// expressions are enabled./// Matches a field's `fmt::Debug` output against a fixed string pattern./// expressions are disabled./// Indicates that a field name specified in a filter directive was invalid.// TODO: reference count these strings?value_match_f64parse_regex/// Parse a `ValueMatch` that will match `fmt::Debug` fields using regular/// This returns an error if the string didn't contain a valid `bool`,/// `u64`, `i64`, or `f64` literal, and couldn't be parsed as a regularparse_non_regex/// Parse a `ValueMatch` that will match `fmt::Debug` against a fixed/// This does *not* return an error, because any string that isn't a valid/// `bool`, `u64`, `i64`, or `f64` literal is treated as expected/// `fmt::Debug` output.str_matchesdebug_matchesinto_debug_matchis_matchedis_matched_slowMyStructdebug_struct_matchdebug_struct_not_match// === impl Match ===// === impl ValueMatch ===// === impl MatchPattern ===// === impl MatchDebug ===// === impl BadName ===BadFieldName// these are publicly re-exported, but the compiler doesn't realize// that for some reason.staticsdynamicshas_dynamicsby_cs/// A [`Layer`] which filters spans and events based on a set of filter/// `EnvFilter` implements both the [`Layer`](#impl-Layer<S>) and [`Filter`] traits, so it may/// be used for both [global filtering][global] and [per-layer filtering][plf],/// respectively. See [the documentation on filtering with `Layer`s][filtering]/// The [`Targets`] type implements a similar form of filtering, but without the/// ability to dynamically enable events based on the current span context, and/// without filtering on field values. When these features are not required,/// [`Targets`] provides a lighter-weight alternative to [`EnvFilter`]./// # Directives/// A filter consists of one or more comma-separated directives which match on [`Span`]s and [`Event`]s./// Each directive may have a corresponding maximum verbosity [`level`] which/// enables (e.g., _selects for_) spans and events that match. Like `log`,/// `tracing` considers less exclusive levels (like `trace` or `info`) to be more/// verbose than more exclusive levels (like `error` or `warn`)./// The directive syntax is similar to that of [`env_logger`]'s. At a high level, the syntax for directives/// consists of several parts:/// target[span{field=value}]=level/// Each component (`target`, `span`, `field`, `value`, and `level`) will be covered in turn./// - `target` matches the event or span's target. In general, this is the module path and/or crate name.///    Examples of targets `h2`, `tokio::net`, or `tide::server`. For more information on targets,///    please refer to [`Metadata`]'s documentation./// - `span` matches on the span's name. If a `span` directive is provided alongside a `target`,///    the `span` directive will match on spans _within_ the `target`./// - `field` matches on [fields] within spans. Field names can also be supplied without a `value`///    and will match on any [`Span`] or [`Event`] that has a field with that name.///    For example: `[span{field=\"value\"}]=debug`, `[{field}]=trace`./// - `value` matches on the value of a span's field. If a value is a numeric literal or a bool,///    it will match _only_ on that value. Otherwise, this filter matches the///    [`std::fmt::Debug`] output from the value./// - `level` sets a maximum verbosity level accepted by this directive./// When a field value directive (`[{<FIELD NAME>=<FIELD_VALUE>}]=...`) matches a/// value's [`std::fmt::Debug`] output (i.e., the field value in the directive/// is not a `bool`, `i64`, `u64`, or `f64` literal), the matched pattern may be/// interpreted as either a regular expression or as the precise expected/// output of the field's [`std::fmt::Debug`] implementation. By default, these/// filters are interpreted as regular expressions, but this can be disabled/// using the [`Builder::with_regex`] builder method to use precise matching/// When field value filters are interpreted as regular expressions, the/// [`regex-automata` crate's regular expression syntax][re-syntax] is/// **Note**: When filters are constructed from potentially untrusted inputs,/// [disabling regular expression matching](Builder::with_regex) is strongly/// recommended./// ## Usage Notes/// - The portion of the directive which is included within the square brackets is `tracing`-specific./// - Any portion of the directive can be omitted.///     - The sole exception are the `field` and `value` directives. If a `value` is provided,///       a `field` must _also_ be provided. However, the converse does not hold, as fields can///       be matched without a value./// - If only a level is provided, it will set the maximum level for all `Span`s and `Event`s///   that are not enabled by other filters./// - A directive without a level will enable anything that it matches. This is equivalent to `=trace`./// - When a crate has a dash in its name, the default target for events will be the///   crate's module path as it appears in Rust. This means every dash will be replaced///   with an underscore./// - A dash in a target will only appear when being specified explicitly:///   `tracing::info!(target: "target-name", ...);`/// ## Example Syntax/// - `tokio::net=info` will enable all spans or events that:///    - have the `tokio::net` target,///    - at the level `info` or above./// - `warn,tokio::net=info` will enable all spans and events that:///    - are at the level `warn` or above, *or*///    - have the `tokio::net` target at the level `info` or above./// - `my_crate[span_a]=trace` will enable all spans and events that:///    - are within the `span_a` span or named `span_a` _if_ `span_a` has the target `my_crate`,///    - at the level `trace` or above./// - `[span_b{name=\"bob\"}]` will enable all spans or event that:///    - have _any_ target,///    - are inside a span named `span_b`,///    - which has a field named `name` with value `bob`,///    - at _any_ level./// Parsing an `EnvFilter` from the [default environment/// variable](EnvFilter::from_default_env) (`RUST_LOG`):/// use tracing_subscriber::{EnvFilter, fmt, prelude::*};/// tracing_subscriber::registry()///     .with(fmt::layer())///     .with(EnvFilter::from_default_env())/// Parsing an `EnvFilter` [from a user-provided environment/// variable](EnvFilter::from_env):///     .with(EnvFilter::from_env("MYAPP_LOG"))/// Using `EnvFilter` as a [per-layer filter][plf] to filter only a single/// [`Layer`]:/// // Parse an `EnvFilter` configuration from the `RUST_LOG`/// // environment variable./// let filter = EnvFilter::from_default_env();/// // Apply the filter to this layer *only*./// let filtered_layer = fmt::layer().with_filter(filter);/// // Some other layer, whose output we don't want to filter./// let unfiltered_layer = // ...///     # fmt::layer();///     .with(filtered_layer)///     .with(unfiltered_layer)/// # Constructing `EnvFilter`s/// An `EnvFilter` is be constructed by parsing a string containing one or more/// directives. The [`EnvFilter::new`] constructor parses an `EnvFilter` from a/// string, ignoring any invalid directives, while [`EnvFilter::try_new`]/// returns an error if invalid directives are encountered. Similarly, the/// [`EnvFilter::from_env`] and [`EnvFilter::try_from_env`] constructors parse/// an `EnvFilter` from the value of the provided environment variable, with/// lossy and strict validation, respectively./// A [builder](EnvFilter::builder) interface is available to set additional/// configuration options prior to parsing an `EnvFilter`. See the [`Builder`/// type's documentation](Builder) for details on the options that can be/// configured using the builder./// [`Span`]: tracing_core::span/// [fields]: tracing_core::Field/// [`Event`]: tracing_core::Event/// [`level`]: tracing_core::Level/// [`Metadata`]: tracing_core::Metadata/// [`Targets`]: crate::filter::Targets/// [`env_logger`]: https://crates.io/crates/env_logger/// [`Filter`]: #impl-Filter<S>/// [global]: crate::layer#global-filtering/// [plf]: crate::layer#per-layer-filtering/// [filtering]: crate::layer#filtering-with-layers/// Indicates that an error occurred while parsing a `EnvFilter` from anDEFAULT_ENV/// `RUST_LOG` is the default environment variable used by/// [`EnvFilter::from_default_env`] and [`EnvFilter::try_from_default_env`]./// [`EnvFilter::from_default_env`]: EnvFilter::from_default_env()/// [`EnvFilter::try_from_default_env`]: EnvFilter::try_from_default_env()/// Returns a [builder] that can be used to configure a new [`EnvFilter`]/// instance./// The [`Builder`] type is used to set additional configurations, such as/// [whether regular expressions are enabled](Builder::with_regex) or [the/// default directive](Builder::with_default_directive) before parsing an/// [`EnvFilter`] from a string or environment variable./// Returns a new `EnvFilter` from the value of the `RUST_LOG` environment/// variable, ignoring any invalid filter directives./// If the environment variable is empty or not set, or if it contains only/// invalid directives, a default directive enabling the [`ERROR`] level is/// To set additional configuration options prior to parsing the filter, use/// the [`Builder`] type instead./// This function is equivalent to the following:/// # fn docs() -> EnvFilter {/// EnvFilter::builder()///     .with_default_directive(LevelFilter::ERROR.into())///     .from_env_lossy()/// [`ERROR`]: tracing::Level::ERROR/// Returns a new `EnvFilter` from the value of the given environment/// # let env = "";///     .with_env_var(env)/// Returns a new `EnvFilter` from the directives in the given string,/// ignoring any that are invalid./// If the string is empty or contains only invalid directives, a default/// directive enabling the [`ERROR`] level is added./// # let directives = "";///     .parse_lossy(directives)/// If the string is empty, a default directive enabling the [`ERROR`] level/// is added./// # fn docs() -> Result<EnvFilter, tracing_subscriber::filter::ParseError> {///     .parse(directives)try_from_default_env/// variable, or an error if the environment variable is unset or contains/// any invalid filter directives./// use tracing_subscriber::EnvFilter;/// # fn docs() -> Result<EnvFilter, tracing_subscriber::filter::FromEnvError> {/// EnvFilter::builder().try_from_env()/// EnvFilter::builder().with_env_var(env).try_from_env()/// Add a filtering directive to this `EnvFilter`./// The added directive will be used in addition to any previously set/// directives, either added using this method or provided when the filter/// is constructed./// Filters may be created from [`LevelFilter`] or [`Level`], which will/// enable all traces at or below a certain verbosity level, or/// parsed from a string specifying a directive./// If a filter directive is inserted that matches exactly the same spans/// and events as a previous filter, but sets a different level for those/// spans and events, the previous directive is overwritten./// [`LevelFilter`]: super::LevelFilter/// [`Level`]: tracing_core::Level/// From [`LevelFilter`]:/// let mut filter = EnvFilter::from_default_env()///     .add_directive(LevelFilter::INFO.into());/// Or from [`Level`]:/// # use tracing_subscriber::filter::{EnvFilter, LevelFilter};///     .add_directive(Level::INFO.into());/// Parsed from a string:/// use tracing_subscriber::filter::{EnvFilter, Directive};/// # fn try_mk_filter() -> Result<(), Box<dyn ::std::error::Error>> {/// let mut filter = EnvFilter::try_from_default_env()?///     .add_directive("my_crate::module=trace".parse()?)///     .add_directive("my_crate::my_other_module::something=info".parse()?);/// In the above example, substitute `my_crate`, `module`, etc. with the/// name your target crate/module is imported with. This might be/// different from the package name in Cargo.toml (`-` is replaced by `_`)./// Example, if the package name in your Cargo.toml is `MY-FANCY-LIB`, then/// the corresponding Rust identifier would be `MY_FANCY_LIB`:/// Returns `true` if this `EnvFilter` would enable the provided `metadata`/// in the current context./// This is equivalent to calling the [`Layer::enabled`] or/// [`Filter::enabled`] methods on `EnvFilter`'s implementations of those/// traits, but it does not require the trait to be in scope./// Returns an optional hint of the highest [verbosity level][level] that/// this `EnvFilter` will enable./// This is equivalent to calling the [`Layer::max_level_hint`] or/// [`Filter::max_level_hint`] methods on `EnvFilter`'s implementations of those/// [level]: tracing_core::metadata::Levelon_new_span/// Informs the filter that a new span was created./// This is equivalent to calling the [`Layer::on_new_span`] or/// [`Filter::on_new_span`] methods on `EnvFilter`'s implementations of thoseon_enter/// Informs the filter that the span with the provided `id` was entered./// This is equivalent to calling the [`Layer::on_enter`] or/// [`Filter::on_enter`] methods on `EnvFilter`'s implementations of thoseon_exit/// Informs the filter that the span with the provided `id` was exited./// This is equivalent to calling the [`Layer::on_exit`] or/// [`Filter::on_exit`] methods on `EnvFilter`'s implementations of thoseon_close/// Informs the filter that the span with the provided `id` was closed./// This is equivalent to calling the [`Layer::on_close`] or/// [`Filter::on_close`] methods on `EnvFilter`'s implementations of thoseon_record/// Informs the filter that the span with the provided `id` recorded the/// provided field `values`./// This is equivalent to calling the [`Layer::on_record`] or/// [`Filter::on_record`] methods on `EnvFilter`'s implementations of those/// traits, but it does not require the trait to be in scopecares_about_spanbase_interest// === constructors, etc ===// === filtering methods ===callsite_enabled_no_span_directivecallsite_offcallsite_enabled_includes_span_directivecallsite_enabled_includes_span_directive_fieldcallsite_enabled_includes_span_directive_multiple_fieldssize_of_filtersparse_empty_string//! A `Layer` that enables or disables spans and events based on a set of//! filtering directives.// ===== impl FromEnvError =====FilterFn/// A filter implemented by a closure or function pointer that/// determines whether a given span or event is enabled, based on its/// [`Metadata`]./// This type can be used for both [per-layer filtering][plf] (using its/// [`Filter`] implementation) and [global filtering][global] (using its/// [`Layer`] implementation)./// See the [documentation on filtering with layers][filtering] for details./// [`Filter`]: crate::layer::Filter_s// TODO(eliza): should these just be boxed functions?DynFilterFn/// determines whether a given span or event is enabled _dynamically_,/// potentially based on the current [span context]./// [span context]: crate::layer::Contextfilter_fn/// Constructs a [`FilterFn`], from a function or closure that returns `true` if/// a span or event should be enabled, based on its [`Metadata`]./// The returned [`FilterFn`] can be used for both [per-layer filtering][plf]/// (using its [`Filter`] implementation) and [global filtering][global] (using/// its  [`Layer`] implementation)./// This is equivalent to calling [`FilterFn::new`]./// use tracing_subscriber::{///     layer::{Layer, SubscriberExt},///     filter,///     util::SubscriberInitExt,/// let my_filter = filter::filter_fn(|metadata| {///     // Only enable spans or events with the target "interesting_things"///     metadata.target() == "interesting_things"/// let my_layer = tracing_subscriber::fmt::layer();///     .with(my_layer.with_filter(my_filter))/// // This event will not be enabled./// tracing::warn!("something important but uninteresting happened!");/// // This event will be enabled./// tracing::debug!(target: "interesting_things", "an interesting minor detail...");dynamic_filter_fn/// Constructs a [`DynFilterFn`] from a function or closure that returns `true`/// if a span or event should be enabled within a particular [span context][`Context`]./// This is equivalent to calling [`DynFilterFn::new`]./// Unlike [`filter_fn`], this function takes a closure or function pointer/// taking the [`Metadata`] for a span or event *and* the current [`Context`]./// This means that a [`DynFilterFn`] can choose whether to enable spans or/// events based on information about the _current_ span (or its parents)./// If this is *not* necessary, use [`filter_fn`] instead./// The returned [`DynFilterFn`] can be used for both [per-layer filtering][plf]/// // Only enable spans or events within a span named "interesting_span"./// let my_filter = filter::dynamic_filter_fn(|metadata, cx| {///     // If this *is* "interesting_span", make sure to enable it.///     if metadata.is_span() && metadata.name() == "interesting_span" {///     // Otherwise, are we in an interesting span?///     if let Some(current_span) = cx.lookup_current() {///         return current_span.name() == "interesting_span";/// tracing::info!("something happened");/// tracing::info_span!("interesting_span").in_scope(|| {///     // This event will be enabled.///     tracing::debug!("something else happened");/// [`Context`]: crate::layer::Context/// Constructs a [`FilterFn`] from a function or closure that returns `true`/// if a span or event should be enabled, based on its [`Metadata`]./// If determining whether a span or event should be enabled also requires/// information about the current span context, use [`DynFilterFn`] instead./// See the [documentation on per-layer filtering][plf] for details on using/// [`Filter`]s.///     filter::FilterFn,/// let my_filter = FilterFn::new(|metadata| {with_max_level_hint/// Sets the highest verbosity [`Level`] the filter function will enable./// The value passed to this method will be returned by this `FilterFn`'s/// [`Filter::max_level_hint`] method./// If the provided function will not enable all levels, it is recommended/// to call this method to configure it with the most verbose level it will/// enable.///     filter::{filter_fn, LevelFilter},/// let my_filter = filter_fn(|metadata| {///     // Only enable spans or events with targets starting with `my_crate`///     // and levels at or below `INFO`.///     metadata.level() <= &Level::INFO && metadata.target().starts_with("my_crate")///     // Since the filter closure will only enable the `INFO` level and///     // below, set the max level hint///     .with_max_level_hint(LevelFilter::INFO);/// [`Filter::max_level_hint`]: crate::layer::Filter::max_level_hintis_callsite_enabledis_below_max_level/// Constructs a [`Filter`] from a function or closure that returns `true`/// if a span or event should be enabled in the current [span/// context][`Context`]./// Unlike [`FilterFn`], a `DynFilterFn` is constructed from a closure or/// function pointer that takes both the [`Metadata`] for a span or event/// *and* the current [`Context`]. This means that a [`DynFilterFn`] can/// choose whether to enable spans or events based on information about the/// _current_ span (or its parents)./// If this is *not* necessary, use [`FilterFn`] instead.///     filter::DynFilterFn,/// let my_filter = DynFilterFn::new(|metadata, cx| {/// The value passed to this method will be returned by this `DynFilterFn`'s///     filter::{DynFilterFn, LevelFilter},/// // Only enable spans or events with levels at or below `INFO`, if/// // we are inside a span called "interesting_span".///     // If the level is greater than INFO, disable it.///     if metadata.level() > &Level::INFO {///         return false;///     // If any span in the current scope is named "interesting_span",///     // enable this span or event.///     for span in cx.lookup_current().iter().flat_map(|span| span.scope()) {///         if span.name() == "interesting_span" {///          }///     // Otherwise, disable it.with_callsite_filter/// Adds a function for filtering callsites to this filter./// When this filter's [`Filter::callsite_enabled`][cse] method is called,/// the provided function will be used rather than the default./// By default, `DynFilterFn` assumes that, because the filter _may_ depend/// dynamically on the current [span context], its result should never be/// cached. However, some filtering strategies may require dynamic information/// from the current span context in *some* cases, but are able to make/// static filtering decisions from [`Metadata`] alone in others./// For example, consider the filter given in the example for/// [`DynFilterFn::new`]. That filter enables all spans named/// "interesting_span", and any events and spans that occur inside of an/// interesting span. Since the span's name is part of its static/// [`Metadata`], the "interesting_span" can be enabled in/// [`callsite_enabled`][cse]:/// use tracing_core::subscriber::Interest;/// }).with_callsite_filter(|metadata| {///     // If this is an "interesting_span", we know we will always///     // enable it.///         return Interest::always();///     // Otherwise, it depends on whether or not we're in an interesting///     // span. You'll have to ask us again for each span/event!///     Interest::sometimes()/// [cse]: crate::layer::Filter::callsite_enabled/// [`enabled`]: crate::layer::Filter::enableddefault_callsite_enabledcallsite_enabled// === impl FilterFn ===// === impl DynFilterFn ==// === PLF impls ===/// Combines two [`Filter`]s so that spans and events are enabled if and only if/// *both* filters return `true`./// This type is typically returned by the [`FilterExt::and`] method. See that/// method's documentation for details./// [`FilterExt::and`]: crate::filter::FilterExt::and/// Combines two [`Filter`]s so that spans and events are enabled if *either* filter/// This type is typically returned by the [`FilterExt::or`] method. See that/// [`FilterExt::or`]: crate::filter::FilterExt::or/// Inverts the result of a [`Filter`]./// If the wrapped filter would enable a span or event, it will be disabled. If/// it would disable a span or event, that span or event will be enabled./// This type is typically returned by the [`FilterExt::not`] method. See that/// [`FilterExt::not`]: crate::filter::FilterExt::not/// Enabling spans or events if they have both a particular target *and* are/// above a certain level:///     filter::{filter_fn, LevelFilter, combinator::And},///     prelude::*,/// // Enables spans and events with targets starting with `interesting_target`:/// let target_filter = filter_fn(|meta| {///     meta.target().starts_with("interesting_target")/// // Enables spans and events with levels `INFO` and below:/// let level_filter = LevelFilter::INFO;/// // Combine the two filters together so that a span or event is only enabled/// // if *both* filters would enable it:/// let filter = And::new(level_filter, target_filter);///     .with(tracing_subscriber::fmt::layer().with_filter(filter))/// // This event will *not* be enabled:/// tracing::info!("an event with an uninteresting target");/// // This event *will* be enabled:/// tracing::info!(target: "interesting_target", "a very interesting event");/// tracing::debug!(target: "interesting_target", "interesting debug event...");/// Enabling spans and events at the `INFO` level and above, and all spans/// and events with a particular target:///     filter::{filter_fn, LevelFilter, combinator::Or},/// // Combine the two filters together so that a span or event is enabled/// // if it is at INFO or lower, or if it has a target starting with/// // `interesting_target`./// let filter = Or::new(level_filter, target_filter);/// tracing::debug!("an uninteresting event");/// tracing::info!("an uninteresting INFO event");/// Enabling a higher level for a particular target by using `Or` in/// conjunction with the [`And`] combinator:///     filter::{filter_fn, LevelFilter, combinator},/// // This filter will enable spans and events with targets beginning with/// // `my_crate`:/// let my_crate = filter_fn(|meta| {///     meta.target().starts_with("my_crate")/// // Combine the `my_crate` filter with a `LevelFilter` to produce a filter/// // that will enable the `INFO` level and lower for spans and events with/// // `my_crate` targets:/// let filter = combinator::And::new(my_crate, LevelFilter::INFO);/// // If a span or event *doesn't* have a target beginning with/// // `my_crate`, enable it if it has the `WARN` level or lower:/// // let filter = combinator::Or::new(filter, LevelFilter::WARN);/// This inverts the values returned by the [`enabled`] and [`callsite_enabled`]/// methods on the wrapped filter; it does *not* invert [`event_enabled`], as/// filters which do not implement filtering on event field values will return/// the default `true` even for events that their [`enabled`] method disables./// Consider a normal filter defined as:/// ```ignore (pseudo-code)/// // for spans/// match callsite_enabled() {///     ALWAYS => on_span(),///     SOMETIMES => if enabled() { on_span() },///     NEVER => (),/// // for events///    ALWAYS => on_event(),///    SOMETIMES => if enabled() && event_enabled() { on_event() },///    NEVER => (),/// and an inverted filter defined as:///     ALWAYS => (),///     SOMETIMES => if !enabled() { on_span() },///     NEVER => on_span(),///     SOMETIMES => if !enabled() { on_event() },///     NEVER => on_event(),/// A proper inversion would do `!(enabled() && event_enabled())` (or/// `!enabled() || !event_enabled()`), but because of the implicit `&&`/// relation between `enabled` and `event_enabled`, it is difficult to/// short circuit and not call the wrapped `event_enabled`./// A combinator which remembers the result of `enabled` in order to call/// `event_enabled` only when `enabled() == true` is possible, but requires/// additional thread-local mutable state to support a very niche use case.//  Also, it'd mean the wrapped layer's `enabled()` always gets called and//  globally applied to events where it doesn't today, since we can't know//  what `event_enabled` will say until we have the event to call it with./// [`event_enabled`]: crate::layer::Filter::event_enabled/// [`callsite_enabled`]: crate::layer::Filter::callsite_enabled//! Filter combinators// === impl And ===// === impl Or ===// === impl Not ===MagicPlfDowncastMarker/// A [`Layer`] that wraps an inner [`Layer`] and adds a [`Filter`] which/// controls what spans and events are enabled for that layer./// This is returned by the [`Layer::with_filter`] method. See the/// [documentation on per-layer filtering][plf] for details./// Uniquely identifies an individual [`Filter`] instance in the context of/// a [`Subscriber`]./// When adding a [`Filtered`] [`Layer`] to a [`Subscriber`], the [`Subscriber`]/// generates a `FilterId` for that [`Filtered`] layer. The [`Filtered`] layer/// will then use the generated ID to query whether a particular span was/// previously enabled by that layer's [`Filter`]./// **Note**: Currently, the [`Registry`] type provided by this crate is the/// **only** [`Subscriber`] implementation capable of participating in per-layer/// filtering. Therefore, the `FilterId` type cannot currently be constructed by/// code outside of `tracing-subscriber`. In the future, new APIs will be added to `tracing-subscriber` to/// allow non-Registry [`Subscriber`]s to also participate in per-layer/// filtering. When those APIs are added, subscribers will be responsible/// for generating and assigning `FilterId`s./// [`Subscriber`]: tracing_core::Subscriber/// [`Registry`]: crate::registry::Registry/// A bitmap tracking which [`FilterId`]s have enabled a given span or/// This is currently a private type that's used exclusively by the/// [`Registry`]. However, in the future, this may become a public API, in order/// to allow user subscribers to host [`Filter`]s./// [`Registry`]: crate::Registry// TODO(eliza): `Interest`s should _probably_ be `Copy`. The only reason// they're not is our Obsessive Commitment to Forwards-Compatibility. If// this changes in tracing-core`, we can make this a `Cell` rather than// `RefCell`...FilterState/// The current state of `enabled` calls to per-subscriber filters on this/// When `Filtered::enabled` is called, the filter will set the bit/// corresponding to its ID if the filter will disable the event/span being/// filtered. When the event or span is recorded, the per-layer filter will/// check its bit to determine if it disabled that event or span, and skip/// forwarding the event or span to the inner layer if the bit is set. Once/// a span or event has been skipped by a per-layer filter, it unsets its/// bit, so that the `FilterMap` has been cleared for the next set of/// `enabled` calls./// FilterState is also read by the `Registry`, for two reasons:/// 1. When filtering a span, the Registry must store the `FilterMap`///    generated by `Filtered::enabled` calls for that span as part of the///    span's per-span data. This allows `Filtered` layers to determine///    whether they had previously disabled a given span, and avoid showing it///    to the wrapped layer if it was disabled.///    This allows `Filtered` layers to also filter out the spans they///    disable from span traversals (such as iterating over parents, etc)./// 2. If all the bits are set, then every per-layer filter has decided it///    doesn't want to enable that span or event. In that case, the///    `Registry`'s `enabled` method will return `false`, so that///     recording a span or event can be skipped entirely.FILTERING/// Combines this [`Filter`] with another [`Filter`] s so that spans and/// events are enabled if and only if *both* filters return `true`.///     filter::{filter_fn, LevelFilter, FilterExt},/// // Combine the two filters together, returning a filter that only enables/// // spans and events that *both* filters will enable:/// let filter = target_filter.and(level_filter);/// let filter = level_filter.or(target_filter);/// Enabling a higher level for a particular target by using `or` in/// conjunction with the [`and`] combinator:/// let filter = my_crate///     // Combine the `my_crate` filter with a `LevelFilter` to produce a///     // filter that will enable the `INFO` level and lower for spans and///     // events with `my_crate` targets:///     .and(LevelFilter::INFO)///     // If a span or event *doesn't* have a target beginning with///     // `my_crate`, enable it if it has the `WARN` level or lower:///     .or(LevelFilter::WARN);/// [`and`]: FilterExt::and/// Inverts `self`, returning a filter that enables spans and events only if/// `self` would *not* enable them./// [Boxes] `self`, erasing its concrete type./// This is equivalent to calling [`Box::new`], but in method form, so that/// it can be used when chaining combinator methods./// When different combinations of filters are used conditionally, they may/// have different types. For example, the following code won't compile,/// since the `if` and `else` clause produce filters of different types:/// let enable_bar_target: bool = // .../// # false;/// let filter = if enable_bar_target {///     filter_fn(|meta| meta.target().starts_with("foo"))///         // If `enable_bar_target` is true, add a `filter_fn` enabling///         // spans and events with the target `bar`:///         .or(filter_fn(|meta| meta.target().starts_with("bar")))///         .and(LevelFilter::INFO)/// By using `boxed`, the types of the two different branches can be erased,/// so the assignment to the `filter` variable is valid (as both branches/// have the type `Box<dyn Filter<S> + Send + Sync + 'static>`). The/// following code *does* compile:///         // Boxing the filter erases its type, so both branches now///         // have the same type.///         .boxed()/// [Boxes]: std::boxed/// [`Box::new`]: std::boxed::Box::newFilterExt/// Extension trait adding [combinators] for combining [`Filter`]./// [combinators]: crate::filter::combinatorfilter_impl_body// Implement Filter for Option<Filter> where None => allow/// Wraps the provided [`Layer`] so that it is filtered by the given/// [`Filter`]./// This is equivalent to calling the [`Layer::with_filter`] method./// See the [documentation on per-layer filtering][plf] for details.did_enable/// Borrows the [`Filter`](crate::layer::Filter) used by this layer.filter_mut/// Mutably borrows the [`Filter`](crate::layer::Filter) used by this layer./// When this layer can be mutably borrowed, this may be used to mutate the filter./// Generally, this will primarily be used with the/// [`reload::Handle::modify`](crate::reload::Handle::modify) method./// # use tracing::info;/// # use tracing_subscriber::{filter,fmt,reload,Registry,prelude::*};/// let filtered_layer = fmt::Layer::default().with_filter(filter::LevelFilter::WARN);/// let (filtered_layer, reload_handle) = reload::Layer::new(filtered_layer);/// # // specifying the Registry type is required/// # let _: &reload::Handle<filter::Filtered<fmt::Layer<Registry>,/// # filter::LevelFilter, Registry>,Registry>/// # = &reload_handle;/// info!("This will be ignored");/// reload_handle.modify(|layer| *layer.filter_mut() = filter::LevelFilter::INFO);/// info!("This will be logged");/// Borrows the inner [`Layer`] wrapped by this `Filtered` layer./// Mutably borrows the inner [`Layer`] wrapped by this `Filtered` layer./// This method is primarily expected to be used with the/// # fn non_blocking<T: std::io::Write>(writer: T) -> (fn() -> std::io::Stdout) {/// #   std::io::stdout/// let filtered_layer = fmt::layer().with_writer(non_blocking(std::io::stderr())).with_filter(filter::LevelFilter::INFO);/// # let _: &reload::Handle<filter::Filtered<fmt::Layer<Registry, _, _, fn() -> std::io::Stdout>,/// # filter::LevelFilter, Registry>, Registry>/// info!("This will be logged to stderr");/// reload_handle.modify(|layer| *layer.inner_mut().writer_mut() = non_blocking(std::io::stdout()));/// info!("This will be logged to stdout");on_layeron_follows_fromon_id_change// XXX(eliza): the existence of this method still makes me sad...// TODO(eliza): can we figure out a nice way to make the `Filtered` layer// not call `is_enabled_for` in hooks that the inner layer doesn't actually// have real implementations of? probably not...// it would be cool if there was some wild rust reflection way of checking// if a trait impl has the default impl of a trait method or not, but that's// almost certainly impossible...right?'spanLookupSpan/// Returns a `FilterId` that will consider _all_ spans enabled./// Combines two `FilterId`s, returning a new `FilterId` that will match a/// [`FilterMap`] where the span was disabled by _either_ this `FilterId`/// *or* the combined `FilterId`./// This method is called by [`Context`]s when adding the `FilterId` of a/// [`Filtered`] layer to the context./// This is necessary for cases where we have a tree of nested [`Filtered`]/// layers, like this:/// Filtered {///     filter1,///     Layered {///         layer1,///         Filtered {///              filter2,///              layer2,/// We want `layer2` to be affected by both `filter1` _and_ `filter2`./// Without combining `FilterId`s, this works fine when filtering/// `on_event`/`new_span`, because the outer `Filtered` layer (`filter1`)/// won't call the inner layer's `on_event` or `new_span` callbacks if it/// disabled the event/span./// However, it _doesn't_ work when filtering span lookups and traversals/// (e.g. `scope`). This is because the [`Context`] passed to `layer2`/// would set its filter ID to the filter ID of `filter2`, and would skip/// spans that were disabled by `filter2`. However, what if a span was/// disabled by `filter1`? We wouldn't see it in `new_span`, but we _would_/// see it in lookups and traversals...which we don't want./// When a [`Filtered`] layer adds its ID to a [`Context`], it _combines_ it/// with any previous filter ID that the context had, rather than replacing/// it. That way, `layer2`'s context will check if a span was disabled by/// `filter1` _or_ `filter2`. The way we do this, instead of representing/// `FilterId`s as a number number that we shift a 1 over by to get a mask,/// we just store the actual mask,so we can combine them with a bitwise-OR./// For example, if we consider the following case (pretending that the/// masks are 8 bits instead of 64 just so i don't have to write out a bunch/// of extra zeroes):/// - `filter1` has the filter id 1 (`0b0000_0001`)/// - `filter2` has the filter id 2 (`0b0000_0010`)/// A span that gets disabled by filter 1 would have the [`FilterMap`] with/// bits `0b0000_0001`./// If the `FilterId` was internally represented as `(bits to shift + 1),/// when `layer2`'s [`Context`] checked if it enabled the  span, it would/// make the mask `0b0000_0010` (`1 << 1`). That bit would not be set in the/// [`FilterMap`], so it would see that it _didn't_ disable  the span. Which/// is *true*, it just doesn't reflect the tree-like shape of the actual/// subscriber./// By having the IDs be masks instead of shifts, though, when the/// [`Filtered`] with `filter2` gets the [`Context`] with `filter1`'s filter ID,/// instead of replacing it, it ors them together:/// 0b0000_0001 | 0b0000_0010 == 0b0000_0011;/// We then test if the span was disabled by  seeing if _any_ bits in the/// mask are `1`:/// filtermap & mask != 0;/// 0b0000_0001 & 0b0000_0011 != 0;/// 0b0000_0001 != 0;/// true;any_enabledadd_interest/// Executes a closure if the filter with the provided ID did not disable/// the current span/event./// This is used to implement the `on_event` and `new_span` methods for/// `Filtered`./// Run a second filtering pass, e.g. for Layer::event_enabled.clear_enabled/// Clears the current in-progress filter state./// This resets the [`FilterMap`] and current [`Interest`] as well as/// clearing the debug counters.take_interest/// This is a horrible and bad abuse of the downcasting system to expose/// *internally* whether a layer has per-layer filtering, within/// `tracing-subscriber`, without exposing a public API for it./// If a `Layer` has per-layer filtering, it will downcast to a/// `MagicPlfDowncastMarker`. Since layers which contain other layers permit/// downcasting to recurse to their children, this will do the Right Thing with/// layers like Reload, Option, etc./// Why is this a wrapper around the `FilterId`, you may ask? Because/// downcasting works by returning a pointer, and we don't want to risk/// introducing UB by  constructing pointers that _don't_ point to a valid/// instance of the type they claim to be. In this case, we don't _intend_ for/// this pointer to be dereferenced, so it would actually be fine to return one/// that isn't a valid pointer...but we can't guarantee that the caller won't/// (accidentally) dereference it, so it's better to be safe than sorry. We/// could, alternatively, add an additional field to the type that's used only/// for returning pointers to as as part of the evil downcasting hack, but I/// thought it was nicer to just add a `repr(transparent)` wrapper to the/// existing `FilterId` field, since it won't make the struct any bigger./// Don't worry, this isn't on the test. :)is_plf_downcast_markersubscriber_has_plf/// Does a type implementing `Subscriber` contain any per-layer filters?layer_has_plf/// Does a type implementing `Layer` contain any per-layer filters?FmtBitset//! ## Per-Layer Filtering//! Per-layer filters permit individual `Layer`s to have their own filter//! configurations without interfering with other `Layer`s.//! This module is not public; the public APIs defined in this module are//! re-exported in the top-level `filter` module. Therefore, this documentation//! primarily concerns the internal implementation details. For the user-facing//! public API documentation, see the individual public types in this module, as//! well as the, see the `Layer` trait documentation's [per-layer filtering//! section]][1].//! ## How does per-layer filtering work?//! As described in the API documentation, the [`Filter`] trait defines a//! filtering strategy for a per-layer filter. We expect there will be a variety//! of implementations of [`Filter`], both in `tracing-subscriber` and in user//! code.//! To actually *use* a [`Filter`] implementation, it is combined with a//! [`Layer`] by the [`Filtered`] struct defined in this module. [`Filtered`]//! implements [`Layer`] by calling into the wrapped [`Layer`], or not, based on//! the filtering strategy. While there will be a variety of types that implement//! [`Filter`], all actual *uses* of per-layer filtering will occur through the//! [`Filtered`] struct. Therefore, most of the implementation details live//! there.//! [1]: crate::layer#per-layer-filtering//! [`Filter`]: crate::layer::Filter// === impl Filter ===// === impl Filtered ===// === impl FilterId ===// === impl FilterExt ===// === impl FilterMap ===// === impl FilterState ===layer_filtersLevelParseErrorTargets//! [`Layer`]s that control which spans and events are enabled by the wrapped//! subscriber.//! This module contains a number of types that provide implementations of//! various strategies for filtering which spans and events are enabled. For//! details on filtering spans and events using [`Layer`]s, see the//! [`layer` module's documentation].//! [`layer` module's documentation]: crate::layer#filtering-with-layers//! [`Layer`]: crate::layer/// A filter that enables or disables spans and events based on their [target]/// and [level]./// Targets are typically equal to the Rust module path of the code where the/// span or event was recorded, although they may be overridden./// # Filtering With `Targets`/// A `Targets` filter consists of one or more [target] prefixes, paired with/// [`LevelFilter`]s. If a span or event's [target] begins with one of those/// prefixes, and its [level] is at or below the [`LevelFilter`] enabled for/// that prefix, then the span or event will be enabled./// This is similar to the behavior implemented by the [`env_logger` crate] in/// the `log` ecosystem./// The [`EnvFilter`] type also provided by this crate is very similar to `Targets`,/// but is capable of a more sophisticated form of filtering where events may/// also be enabled or disabled based on the span they are recorded in./// `Targets` can be thought of as a lighter-weight form of [`EnvFilter`] that/// can be used instead when this dynamic filtering is not required./// A `Targets` filter can be constructed by programmatically adding targets and/// levels to enable:/// use tracing_subscriber::{filter, prelude::*};/// let filter = filter::Targets::new()///     // Enable the `INFO` level for anything in `my_crate`///     .with_target("my_crate", Level::INFO)///     // Enable the `DEBUG` level for a specific module.///     .with_target("my_crate::interesting_module", Level::DEBUG);/// // Build a new subscriber with the `fmt` layer using the `Targets`/// // filter we constructed above.///     .with(tracing_subscriber::fmt::layer())///     .with(filter)/// [`LevelFilter::OFF`] can be used to disable a particular target:/// use tracing_subscriber::filter::{Targets, LevelFilter};/// let filter = Targets::new()///     // Disable all traces from `annoying_module`.///     .with_target("my_crate::annoying_module", LevelFilter::OFF);/// # drop(filter);/// Alternatively, `Targets` implements [`std::str::FromStr`], allowing it to be/// parsed from a comma-delimited list of `target=level` pairs. For example:/// use tracing_subscriber::filter;/// let filter = "my_crate=info,my_crate::interesting_module=trace,other_crate=debug"///     .parse::<filter::Targets>()?;/// // The parsed filter is identical to a filter constructed using `with_target`:///     filter::Targets::new()///         .with_target("my_crate", Level::INFO)///         .with_target("my_crate::interesting_module", Level::TRACE)///         .with_target("other_crate", Level::DEBUG)/// This is particularly useful when the list of enabled targets is configurable/// by the user at runtime./// The `Targets` filter can be used as a [per-layer filter][plf] *and* as a/// [global filter][global]:///     fmt,///     filter::{Targets, LevelFilter},/// use std::{sync::Arc, fs::File};/// # fn docs() -> Result<(), Box<dyn std::error::Error>> {/// // A layer that logs events to stdout using the human-readable "pretty"/// // format./// let stdout_log = fmt::layer().pretty();/// // A layer that logs events to a file, using the JSON format./// let file = File::create("debug_log.json")?;/// let debug_log = fmt::layer()///     .with_writer(Arc::new(file))///     .json();///     // Only log INFO and above to stdout, unless the span or event///     // has the `my_crate::cool_module` target prefix.///     .with(stdout_log///         .with_filter(///             Targets::default()///                 .with_target("my_crate::cool_module", Level::DEBUG)///                 .with_default(Level::INFO)///        )///     // Log everything enabled by the global filter to `debug_log.json`.///     .with(debug_log)///     // Configure a global filter for the whole subscriber stack. This will///     // control what spans and events are recorded by both the `debug_log`///     // and the `stdout_log` layers, and `stdout_log` will *additionally* be///     // filtered by its per-layer filter.///     .with(///         Targets::default()///             .with_target("my_crate", Level::TRACE)///             .with_target("other_crate", Level::INFO)///             .with_target("other_crate::annoying_module", LevelFilter::OFF)///             .with_target("third_crate", Level::DEBUG)///     ).init();/// [target]: tracing_core::Metadata::target/// [level]: tracing_core::Level/// [`env_logger` crate]: https://docs.rs/env_logger/0.9.0/env_logger/index.html#enabling-logging/// [`EnvFilter`]: crate::filter::EnvFilter/// Returns a new `Targets` filter./// This filter will enable no targets. Call [`with_target`] or [`with_targets`]/// to add enabled targets, and [`with_default`] to change the default level/// enabled for spans and events that didn't match any of the provided targets./// [`with_target`]: Targets::with_target/// [`with_targets`]: Targets::with_targets/// [`with_default`]: Targets::with_default/// Enables spans and events with [target]s starting with the provided target/// prefix if they are at or below the provided [`LevelFilter`].///     .with_target("my_crate::interesting_module", LevelFilter::OFF);with_targets/// Adds [target]s from an iterator of [target]-[`LevelFilter`] pairs to this filter.///     .with_targets(vec![///         ("my_crate", Level::INFO),///         ("my_crate::some_module", Level::DEBUG),///         ("my_crate::other_module::cool_stuff", Level::TRACE),///         ("other_crate", Level::WARN)/// Sets the default level to enable for spans and events whose targets did/// not match any of the configured prefixes./// By default, this is [`LevelFilter::OFF`]. This means that spans and/// events will only be enabled if they match one of the configured target/// prefixes. If this is changed to a different [`LevelFilter`], spans and/// events with targets that did not match any of the configured prefixes/// will be enabled if their level is at or below the provided level.default_level/// Returns the default level for this filter, if one is set./// The default level is used to filter any spans or events with targets/// that do not match any of the configured set of prefixes./// The default level can be set for a filter either by using/// [`with_default`](Self::with_default) or when parsing from a filter string that includes a/// level without a target (e.g. `"trace"`)./// use tracing_subscriber::filter::{LevelFilter, Targets};/// let filter = Targets::new().with_default(LevelFilter::INFO);/// assert_eq!(filter.default_level(), Some(LevelFilter::INFO));/// let filter: Targets = "info".parse().unwrap();/// The default level is `None` if no default is set:/// use tracing_subscriber::filter::Targets;/// let filter = Targets::new();/// assert_eq!(filter.default_level(), None);/// let filter: Targets = "my_crate=info".parse().unwrap();/// Note that an unset default level (`None`) behaves like [`LevelFilter::OFF`] when the filter is/// used, but it could also be set explicitly which may be useful to distinguish (such as when/// merging multiple `Targets`)./// let filter = Targets::new().with_default(LevelFilter::OFF);/// assert_eq!(filter.default_level(), Some(LevelFilter::OFF));/// let filter: Targets = "off".parse().unwrap();/// Returns an iterator over the [target]-[`LevelFilter`] pairs in this filter./// The order of iteration is undefined./// let mut targets: Vec<_> = filter.iter().collect();/// targets.sort();/// assert_eq!(targets, vec![///     ("my_crate", LevelFilter::INFO),///     ("my_crate::interesting_module", LevelFilter::DEBUG),interestedwould_enable/// Returns whether a [target]-[`Level`] pair would be enabled/// by this `Targets`./// This method can be used with [`module_path!`] from `std` as the target/// in order to emulate the behavior of the [`tracing::event!`] and [`tracing::span!`]/// macros./// assert!(filter.would_enable("my_crate", &Level::INFO));/// assert!(!filter.would_enable("my_crate::interesting_module", &Level::TRACE));/// [`module_path!`]: std::module_path!// alias indirection would probably make this more confusing/// An owning iterator over the [target]-[level] pairs of a `Targets` filter./// This struct is created by the `IntoIterator` trait implementation of [`Targets`]./// Merge the targets from one `Targets` with another:/// let mut filter = Targets::new().with_target("my_crate", Level::INFO);/// let overrides = Targets::new().with_target("my_crate::interesting_module", Level::DEBUG);/// filter.extend(overrides);/// A borrowing iterator over the [target]-[level] pairs of a `Targets` filter./// This struct is created by [`iter`] method of [`Targets`], or from the `IntoIterator`/// implementation for `&Targets`./// [`iter`]: Targets::iterexpect_parse_ralithexpect_parse_level_directivesparse_ralithparse_ralith_ucparse_ralith_mixedexpect_parse_validtargets_itertargets_into_itertargets_default_level// `println!` is only available with `libstd`.display_roundtrips/// Test that the `fmt::Display` implementation for `Targets` emits a string/// that can itself be parsed as a `Targets`, and that the parsed `Targets`/// is equivalent to the original one.//! A [filter] that enables or disables spans and events based on their [target] and [level].//! See [`Targets`] for details.//! [target]: tracing_core::Metadata::target//! [level]: tracing_core::Level//! [filter]: crate::layer#filtering-with-layersFormatEventFormatFieldsMakeWriterSpanRefFmtSpanTimingDisplaymake_writerfmt_eventfmt_spanFmtSpanConfigis_ansilog_internal_errorsDefaultFields/// A [`Layer`] that logs formatted representations of `tracing` events./// Constructing a layer with the default configuration:/// use tracing_subscriber::{fmt, Registry};/// use tracing_subscriber::prelude::*;/// let subscriber = Registry::default()///     .with(fmt::Layer::default());/// tracing::subscriber::set_global_default(subscriber).unwrap();/// Overriding the layer's behavior:/// let fmt_layer = fmt::layer()///    .with_target(false) // don't include event targets when logging///    .with_level(false); // don't include event levels when logging/// let subscriber = Registry::default().with(fmt_layer);/// # tracing::subscriber::set_global_default(subscriber).unwrap();/// Setting a custom event formatter:/// use tracing_subscriber::fmt::{self, format, time};/// let fmt = format().with_timer(time::Uptime::default());///     .event_format(fmt)///     .with_target(false);/// # let subscriber = fmt_layer.with_subscriber(tracing_subscriber::registry::Registry::default());/// [`Layer`]: super::layer::Layer/// Returns a new [`Layer`][self::Layer] with the default configuration.event_format/// Sets the [event formatter][`FormatEvent`] that the layer being built will/// use to format events./// The event formatter may be any type implementing the [`FormatEvent`]/// trait, which is implemented for all functions taking a [`FmtContext`], a/// [`Writer`], and an [`Event`]./// Setting a type implementing [`FormatEvent`] as the formatter:/// use tracing_subscriber::fmt::{self, format};/// let layer = fmt::layer()///     .event_format(format().compact());/// # // this is necessary for type inference./// # use tracing_subscriber::Layer as _;/// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());/// [`FormatEvent`]: format::FormatEvent/// [`Writer`]: format::Writermap_event_format/// Updates the event formatter by applying a function to the existing event formatter./// This sets the event formatter that the layer being built will use to record fields./// Updating an event formatter:/// let layer = tracing_subscriber::fmt::layer()///     .map_event_format(|e| e.compact());// This needs to be a seperate impl block because they place different bounds on the type parameters.with_writer/// Sets the [`MakeWriter`] that the layer being built will use to write events./// Using `stderr` rather than `stdout`:/// use tracing_subscriber::fmt;///     .with_writer(io::stderr);/// Borrows the [writer] for this [`Layer`]./// [writer]: MakeWriter/// Mutably borrows the [writer] for this [`Layer`]./// # use tracing_subscriber::{fmt,reload,Registry,prelude::*};/// let layer = fmt::layer().with_writer(non_blocking(std::io::stderr()));/// let (layer, reload_handle) = reload::Layer::new(layer);/// # let _: &reload::Handle<fmt::Layer<Registry, _, _, _>, Registry> = &reload_handle;/// reload_handle.modify(|layer| *layer.writer_mut() = non_blocking(std::io::stdout()));set_ansi/// Sets whether this layer should use ANSI terminal formatting/// escape codes (such as colors)./// [`reload::Handle::modify`](crate::reload::Handle::modify) method when changing/// the writer.set_span_events/// Modifies how synthesized events are emitted at points in the [span/// lifecycle][lifecycle]./// See [`Self::with_span_events`] for documentation on the [`FmtSpan`]/// [`reload::Handle::modify`](crate::reload::Handle::modify) method/// Note that using this method modifies the span configuration instantly and does not take into/// account any current spans. If the previous configuration was set to capture/// `FmtSpan::ALL`, for example, using this method to change to `FmtSpan::NONE` will cause an/// exit event for currently entered events not to be formatted/// [lifecycle]: mod@tracing::span#the-span-lifecyclewith_test_writer/// Configures the layer to support [`libtest`'s output capturing][capturing] when used in/// unit tests./// See [`TestWriter`] for additional details./// Using [`TestWriter`] to let `cargo test` capture test output:///     .with_test_writer();/// [capturing]:/// https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output/// [`TestWriter`]: super::writer::TestWriterwith_ansi/// Sets whether or not the formatter emits ANSI terminal escape codes/// for colors and other text formatting./// When the "ansi" crate feature flag is enabled, ANSI colors are enabled/// by default unless the [`NO_COLOR`] environment variable is set to/// a non-empty value.  If the [`NO_COLOR`] environment variable is set to/// any non-empty value, then ANSI colors will be suppressed by default./// The [`with_ansi`] and [`set_ansi`] methods can be used to forcibly/// enable ANSI colors, overriding any [`NO_COLOR`] environment variable./// [`NO_COLOR`]: https://no-color.org//// Enabling ANSI escapes (calling `with_ansi(true)`) requires the "ansi"/// crate feature flag. Calling `with_ansi(true)` without the "ansi"/// feature flag enabled will panic if debug assertions are enabled, or/// print a warning otherwise./// This method itself is still available without the feature flag. This/// is to allow ANSI escape codes to be explicitly *disabled* without/// having to opt-in to the dependencies required to emit ANSI formatting./// This way, code which constructs a formatter that should never emit/// ANSI escape codes can ensure that they are not used, regardless of/// whether or not other crates in the dependency graph enable the "ansi"/// feature flag./// [`with_ansi`]: Subscriber::with_ansi/// [`set_ansi`]: Subscriber::set_ansi/// Sets whether to write errors from [`FormatEvent`] to the writer./// By default, `fmt::Layer` will write any `FormatEvent`-internal errors to/// the writer. These errors are unlikely and will only occur if there is a/// bug in the `FormatEvent` implementation or its dependencies./// If writing to the writer fails, the error message is printed to stderr/// as a fallback./// [`FormatEvent`]: crate::fmt::FormatEventmap_writer/// Updates the [`MakeWriter`] by applying a function to the existing [`MakeWriter`]./// This sets the [`MakeWriter`] that the layer being built will use to write events./// Redirect output to stderr if level is <= WARN:/// use tracing::Level;/// use tracing_subscriber::fmt::{self, writer::MakeWriterExt};/// let stderr = std::io::stderr.with_max_level(Level::WARN);///     .map_writer(move |w| stderr.or_else(w));with_timer/// Use the given [`timer`] for span and event timestamps./// See the [`time` module] for the provided timer implementations./// Note that using the `"time`"" feature flag enables the/// additional time formatters [`UtcTime`] and [`LocalTime`], which use the/// [`time` crate] to provide more sophisticated timestamp formatting/// [`timer`]: super::time::FormatTime/// [`time` module]: mod@super::time/// [`UtcTime`]: super::time::UtcTime/// [`LocalTime`]: super::time::LocalTime/// [`time` crate]: https://docs.rs/time/0.3without_time/// Do not emit timestamps with spans and event.with_span_events/// Configures how synthesized events are emitted at points in the [span/// The following options are available:/// - `FmtSpan::NONE`: No events will be synthesized when spans are///    created, entered, exited, or closed. Data from spans will still be///    included as the context for formatted events. This is the default./// - `FmtSpan::NEW`: An event will be synthesized when spans are created./// - `FmtSpan::ENTER`: An event will be synthesized when spans are entered./// - `FmtSpan::EXIT`: An event will be synthesized when spans are exited./// - `FmtSpan::CLOSE`: An event will be synthesized when a span closes. If///    [timestamps are enabled][time] for this formatter, the generated///    event will contain fields with the span's _busy time_ (the total///    time for which it was entered) and _idle time_ (the total time that///    the span existed but was not entered)./// - `FmtSpan::ACTIVE`: Events will be synthesized when spans are entered///    or exited./// - `FmtSpan::FULL`: Events will be synthesized whenever a span is///    created, entered, exited, or closed. If timestamps are enabled, the///    close event will contain the span's busy and idle time, as///    described above./// The options can be enabled in any combination. For instance, the following/// will synthesize events whenever spans are created and closed:/// use tracing_subscriber::fmt::format::FmtSpan;/// let subscriber = fmt()///     .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)/// Note that the generated events will only be part of the log output by/// this formatter; they will not be recorded by other `Subscriber`s or by/// `Layer`s added to this subscriber./// [lifecycle]: https://docs.rs/tracing/latest/tracing/span/index.html#the-span-lifecycle/// [time]: Layer::without_time()/// Sets whether or not an event's target is displayed.with_file/// Sets whether or not an event's [source code file path][file] is/// displayed./// [file]: tracing_core::Metadata::filewith_line_number/// Sets whether or not an event's [source code line number][line] is/// [line]: tracing_core::Metadata::line/// Sets whether or not an event's level is displayed.with_thread_ids/// Sets whether or not the [thread ID] of the current thread is displayed/// when formatting events./// [thread ID]: std::thread::ThreadIdwith_thread_names/// Sets whether or not the [name] of the current thread is displayed/// [name]: std::thread#naming-threads/// Sets the layer being built to use a [less verbose formatter][super::format::Compact]./// Sets the layer being built to use an [excessively pretty, human-readable formatter](crate::fmt::format::Pretty)./// Sets the field formatter that the layer being built will use to recordmap_fmt_fields/// Updates the field formatter by applying a function to the existing field formatter./// This sets the field formatter that the layer being built will use to record fields./// Updating a field formatter:/// use tracing_subscriber::field::MakeExt;///     .map_fmt_fields(|f| f.debug_alt());make_ctxFmtContext_format_fieldswas_ansi/// The formatted fields of a span.FormattedFields/// A formatted representation of a span's fields stored in its [extensions]./// Because `FormattedFields` is generic over the type of the formatter that/// produced it, multiple versions of a span's formatted fields can be stored in/// the [`Extensions`][extensions] type-map. This means that when multiple/// formatters are in use, each can store its own formatted representation/// without conflicting./// [extensions]: crate::registry::Extensions/// Returns a new `FormattedFields`.as_writer/// Returns a new [`format::Writer`] for writing to this `FormattedFields`./// The returned [`format::Writer`] can be used with the/// [`FormatFields::format_fields`] method.with_event_from_span/// Provides the current span context to a formatter.format_fields'lookupvisit_spans/// Visits every span in the current context with a closure./// The provided closure will be called first with the current span,/// and then with that span's parent, and then that span's parent,/// and so on until a root span is reached./// Returns metadata for the span with the given `id`, if it exists./// If this returns `None`, then no span exists for that ID (either it has/// closed or the ID is invalid)./// Returns [stored data] for the span with the given `id`, if it exists./// [stored data]: crate::registry::SpanRef/// Returns `true` if an active span exists for the given `Id`.lookup_current/// Returns [stored data] for the span that the wrapped subscriber considers/// to be the current./// If this returns `None`, then we are not currently within a span./// Returns the current span for this formatter.parent_span/// Returns [stored data] for the parent span of the event currently being/// formatted./// If the event has a contextual parent, this will return the current span. If/// the event has an explicit parent span, this will return that span. If/// the event does not have a parent span, this will return `None`./// [stored data]: SpanRefspan_scope/// Returns an iterator over the [stored data] for all the spans in the/// current context, starting with the specified span and ending with the/// root of the trace tree and ending with the current span./// This is equivalent to the [`Context::span_scope`] method./// <div class="information">///     <div class="tooltip ignore" style="">ⓘ<span class="tooltiptext">Note</span></div>/// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this/// returns the spans in reverse order (from leaf to root). Use/// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>/// in case root-to-leaf ordering is desired./// <strong>Note</strong>: This requires the wrapped subscriber to implement the/// <a href="../registry/trait.LookupSpan.html"><code>LookupSpan</code></a> trait./// See the documentation on <a href="./struct.Context.html"><code>Context</code>'s/// declaration</a> for details.event_scope/// event's span context, starting with its parent span and ending with the/// root of the trace tree./// This is equivalent to calling the [`Context::event_scope`] method and/// passing the event currently being formatted.field_format/// Returns the [field formatter] configured by the subscriber invoking/// `format_event`./// The event formatter may use the returned field formatter to format the/// fields of any events it records./// [field formatter]: FormatFieldsTimingsMockMakeWriterMockWriterfmt_layer_downcastsfmt_layer_downcasts_to_partsis_lookup_spansanitize_timingsformat_error_print_to_stderrformat_error_ignore_if_log_internal_errors_is_falsesynthesize_span_nonesynthesize_span_activesynthesize_span_closesynthesize_span_close_no_timingsynthesize_span_fullmake_writer_based_on_metalayer_no_color// Because we need to modify an environment variable for these test cases,// we do them all in a single test.modify_span_events// Validates that span event configuration can be modified with a reload handle// === impl FmtLayer ===FormatTimefmt_layerWriteAdaptortracing_serdeAsSerdeflatten_eventdisplay_current_spandisplay_span_list/// Marker for [`Format`] that indicates that the newline-delimited JSON log/// format should be used./// This formatter is intended for production use with systems where structured/// logs are consumed as JSON by analysis and viewing tools. The JSON output is/// not optimized for human readability; instead, it should be pretty-printed/// using external JSON tools such as `jq`, or using a JSON log viewer./// # Example Output/// <pre><font color="#4E9A06"><b>:;</b></font> <font color="#4E9A06">cargo</font> run --example fmt-json/// <font color="#4E9A06"><b>    Finished</b></font> dev [unoptimized + debuginfo] target(s) in 0.08s/// <font color="#4E9A06"><b>     Running</b></font> `target/debug/examples/fmt-json`/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821315Z&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;preparing to shave yaks&quot;,&quot;number_of_yaks&quot;:3},&quot;target&quot;:&quot;fmt_json&quot;}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821422Z&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;shaving yaks&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821495Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;hello! I&apos;m gonna shave a yak&quot;,&quot;excitement&quot;:&quot;yay!&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:1,&quot;name&quot;:&quot;shave&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821546Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;yak shaved successfully&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:1,&quot;name&quot;:&quot;shave&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821598Z&quot;,&quot;level&quot;:&quot;DEBUG&quot;,&quot;fields&quot;:{&quot;yak&quot;:1,&quot;shaved&quot;:true},&quot;target&quot;:&quot;yak_events&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821637Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;yaks_shaved&quot;:1},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821684Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;hello! I&apos;m gonna shave a yak&quot;,&quot;excitement&quot;:&quot;yay!&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:2,&quot;name&quot;:&quot;shave&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821727Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;yak shaved successfully&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:2,&quot;name&quot;:&quot;shave&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821773Z&quot;,&quot;level&quot;:&quot;DEBUG&quot;,&quot;fields&quot;:{&quot;yak&quot;:2,&quot;shaved&quot;:true},&quot;target&quot;:&quot;yak_events&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821806Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;yaks_shaved&quot;:2},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821909Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;hello! I&apos;m gonna shave a yak&quot;,&quot;excitement&quot;:&quot;yay!&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:3,&quot;name&quot;:&quot;shave&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.821956Z&quot;,&quot;level&quot;:&quot;WARN&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;could not locate yak&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:3,&quot;name&quot;:&quot;shave&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.822006Z&quot;,&quot;level&quot;:&quot;DEBUG&quot;,&quot;fields&quot;:{&quot;yak&quot;:3,&quot;shaved&quot;:false},&quot;target&quot;:&quot;yak_events&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.822041Z&quot;,&quot;level&quot;:&quot;ERROR&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;failed to shave yak&quot;,&quot;yak&quot;:3,&quot;error&quot;:&quot;missing yak&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.822079Z&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;yaks_shaved&quot;:2},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}/// {&quot;timestamp&quot;:&quot;2022-02-15T18:47:10.822117Z&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;yak shaving completed&quot;,&quot;all_yaks_shaved&quot;:false},&quot;target&quot;:&quot;fmt_json&quot;}/// # Options/// This formatter exposes additional options to configure the structure of the/// output JSON objects:/// - [`Json::flatten_event`] can be used to enable flattening event fields into///   the root/// - [`Json::with_current_span`] can be used to control logging of the current///   span/// - [`Json::with_span_list`] can be used to control logging of the span list///   object./// By default, event fields are not flattened, and both current span and span/// list are logged./// # Valuable Support/// Experimental support is available for using the [`valuable`] crate to record/// user-defined values as structured JSON. When the ["valuable" unstable/// feature][unstable] is enabled, types implementing [`valuable::Valuable`] will/// be recorded as structured JSON, rather than/// using their [`std::fmt::Debug`] implementations./// **Note**: This is an experimental feature. [Unstable features][unstable]/// must be enabled in order to use `valuable` support./// [`Json::flatten_event`]: Json::flatten_event()/// [`Json::with_current_span`]: Json::with_current_span()/// [`Json::with_span_list`]: Json::with_span_list()/// [`valuable`]: https://crates.io/crates/valuable/// [`valuable::Valuable`]: https://docs.rs/valuable/latest/valuable/trait.Valuable.html/// If set to `true` event metadata will be flattened into the root object.with_current_span/// If set to `false`, formatted events won't contain a field for the current span.with_span_list/// If set to `false`, formatted events won't contain a list of all currently/// entered spans. Spans are logged in a list from root to leaf.SerializableContextSerializableSpanformat_event// reserve the ability to add fields to this without causing a breaking// change in the future.JsonFields/// The JSON [`FormatFields`] implementation./// Returns a new JSON [`FormatFields`] implementation./// Format the provided `fields` to the provided `writer`, returning a result.add_fields/// Record additional field(s) on an existing span./// By default, this appends a space to the current set of fields if it is/// non-empty, and then calls `self.format_fields`. If different behavior is/// required, the default implementation of this method can be overridden.JsonVisitor/// The [visitor] produced by [`JsonFields`]'s [`MakeVisitor`] implementation./// [visitor]: crate::field::Visit/// [`MakeVisitor`]: crate::field::MakeVisitor/// Returns a new default visitor that formats to the provided `writer`./// - `writer`: the writer to format to./// - `is_empty`: whether or not any fields have been previously written to///   that writer.record_valuevaluable_crate/// Visit a double precision floating point value.SubscriberBuilderjson_filenamejson_line_numberjson_flattened_eventjson_disabled_current_span_eventjson_disabled_span_list_eventjson_nested_spanjson_no_spanrecord_worksjson_span_event_show_correct_contextjson_span_event_with_no_fieldsparse_as_jsontest_jsontest_json_with_line_number/// Write a log message for `Event` in `Context` to the given [`Writer`]./// A type that can format a tracing [`Event`] to a [`Writer`]./// `FormatEvent` is primarily used in the context of [`fmt::Subscriber`] or/// [`fmt::Layer`]. Each time an event is dispatched to [`fmt::Subscriber`] or/// [`fmt::Layer`], the subscriber or layer/// forwards it to its associated `FormatEvent` to emit a log message./// This trait is already implemented for function pointers with the same/// signature as `format_event`./// The following arguments are passed to `FormatEvent::format_event`:/// * A [`FmtContext`]. This is an extension of the [`layer::Context`] type,///   which can be used for accessing stored information such as the current///   span context an event occurred in.///   In addition, [`FmtContext`] exposes access to the [`FormatFields`]///   implementation that the subscriber was configured to use via the///   [`FmtContext::field_format`] method. This can be used when the///   [`FormatEvent`] implementation needs to format the event's fields.///   For convenience, [`FmtContext`] also [implements `FormatFields`],///   forwarding to the configured [`FormatFields`] type./// * A [`Writer`] to which the formatted representation of the event is///   written. This type implements the [`std::fmt::Write`] trait, and therefore///   can be used with the [`std::write!`] and [`std::writeln!`] macros, as well///   as calling [`std::fmt::Write`] methods directly.///   The [`Writer`] type also implements additional methods that provide///   information about how the event should be formatted. The///   [`Writer::has_ansi_escapes`] method indicates whether [ANSI terminal///   escape codes] are supported by the underlying I/O writer that the event///   will be written to. If this returns `true`, the formatter is permitted to///   use ANSI escape codes to add colors and other text formatting to its///   output. If it returns `false`, the event will be written to an output that///   does not support ANSI escape codes (such as a log file), and they should///   not be emitted.///   Crates like [`nu_ansi_term`] and [`owo-colors`] can be used to add ANSI///   escape codes to formatted output./// * The actual [`Event`] to be formatted./// This example re-implements a simiplified version of this crate's [default/// formatter]:/// use tracing_core::{Subscriber, Event};/// use tracing_subscriber::fmt::{///     format::{self, FormatEvent, FormatFields},///     FmtContext,///     FormattedFields,/// use tracing_subscriber::registry::LookupSpan;/// struct MyFormatter;/// impl<S, N> FormatEvent<S, N> for MyFormatter///     S: Subscriber + for<'a> LookupSpan<'a>,///     N: for<'a> FormatFields<'a> + 'static,///     fn format_event(///         ctx: &FmtContext<'_, S, N>,///         mut writer: format::Writer<'_>,///         event: &Event<'_>,///     ) -> fmt::Result {///         // Format values from the event's's metadata:///         let metadata = event.metadata();///         write!(&mut writer, "{} {}: ", metadata.level(), metadata.target())?;///         // Format all the spans in the event's span context.///         if let Some(scope) = ctx.event_scope() {///             for span in scope.from_root() {///                 write!(writer, "{}", span.name())?;///                 // `FormattedFields` is a formatted representation of the span's///                 // fields, which is stored in its extensions by the `fmt` layer's///                 // `new_span` method. The fields will have been formatted///                 // by the same field formatter that's provided to the event///                 // formatter in the `FmtContext`.///                 let ext = span.extensions();///                 let fields = &ext///                     .get::<FormattedFields<N>>()///                     .expect("will never be `None`");///                 // Skip formatting the fields if the span had no fields.///                 if !fields.is_empty() {///                     write!(writer, "{{{}}}", fields)?;///                 write!(writer, ": ")?;///         // Write fields on the event///         ctx.field_format().format_fields(writer.by_ref(), event)?;///         writeln!(writer)/// let _subscriber = tracing_subscriber::fmt()///     .event_format(MyFormatter)/// let _span = tracing::info_span!("my_span", answer = 42).entered();/// tracing::info!(question = "life, the universe, and everything", "hello world");/// This formatter will print events like this:/// DEBUG yak_shaving::shaver: some-span{field-on-span=foo}: started shaving yak/// [`layer::Context`]: crate::layer::Context/// [`fmt::Layer`]: super::Layer/// [`fmt::Subscriber`]: super::Subscriber/// [implements `FormatFields`]: super::FmtContext#impl-FormatFields<'writer>/// [ANSI terminal escape codes]: https://en.wikipedia.org/wiki/ANSI_escape_code/// [`Writer::has_ansi_escapes`]: Writer::has_ansi_escapes/// [`nu_ansi_term`]: https://crates.io/crates/nu_ansi_term/// [`owo-colors`]: https://crates.io/crates/owo-colors/// [default formatter]: Full/// Format the provided `fields` to the provided [`Writer`], returning a result./// A type that can format a [set of fields] to a [`Writer`]./// `FormatFields` is primarily used in the context of [`FmtSubscriber`]. Each/// time a span or event with fields is recorded, the subscriber will format/// those fields with its associated `FormatFields` implementation./// [set of fields]: crate::field::RecordFields/// [`FmtSubscriber`]: super::Subscriber/// Returns the default configuration for an [event formatter]./// Methods on the returned event formatter can be used for further/// configuration. For example:/// let format = tracing_subscriber::fmt::format()///     .without_time()         // Don't include timestamps///     .with_target(false)     // Don't include event targets.///     .with_level(false)      // Don't include event levels.///     .compact();             // Use a more compact, abbreviated format./// // Use the configured formatter when building a new subscriber./// tracing_subscriber::fmt()///     .event_format(format)debug_fnFieldFn/// Returns a [`FormatFields`] implementation that formats fields using the/// provided function or closure.// TODO(eliza): add ANSI support/// A writer to which formatted representations of spans and events are written./// This type is provided as input to the [`FormatEvent::format_event`] and/// [`FormatFields::format_fields`] methods, which will write formatted/// representations of [`Event`]s and [fields] to the `Writer`./// This type implements the [`std::fmt::Write`] trait, allowing it to be used/// with any function that takes an instance of [`std::fmt::Write`]./// Additionally, it can be used with the standard library's [`std::write!`] and/// [`std::writeln!`] macros./// Additionally, a `Writer` may expose additional `tracing`-specific/// information to the formatter implementation./// [fields]: tracing_core::field/// A [`FormatFields`] implementation that formats fields by calling a function/// or closure.FieldFnVisitor/// The [visitor] produced by [`FieldFn`]'s [`MakeVisitor`] implementation./// [visitor]: super::super::field::Visit/// [`MakeVisitor`]: super::super::field::MakeVisitor/// Marker for [`Format`] that indicates that the compact log format should be used./// The compact format includes fields from all currently entered spans, after/// the event's fields. Span fields are ordered (but not grouped) by/// span, and span names are  not shown. A more compact representation of the/// event's [`Level`] is used, and additional information—such as the event's/// target—is disabled by default./// <pre><font color="#4E9A06"><b>:;</b></font> <font color="#4E9A06">cargo</font> run --example fmt-compact/// <font color="#4E9A06"><b>     Running</b></font> `target/debug/examples/fmt-compact`/// <font color="#AAAAAA">2022-02-17T19:51:05.809287Z </font><font color="#4E9A06"> INFO</font> <b>fmt_compact</b><font color="#AAAAAA">: preparing to shave yaks </font><i>number_of_yaks</i><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809367Z </font><font color="#4E9A06"> INFO</font> <b>shaving_yaks</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: shaving yaks </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809414Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>:<b>shave</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: hello! I&apos;m gonna shave a yak </font><i>excitement</i><font color="#AAAAAA">=&quot;yay!&quot; </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3 </font><font color="#AAAAAA"><i>yak</i></font><font color="#AAAAAA">=1</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809443Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>:<b>shave</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: yak shaved successfully </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3 </font><font color="#AAAAAA"><i>yak</i></font><font color="#AAAAAA">=1</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809477Z </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks</b>: <b>yak_events</b><font color="#AAAAAA">: </font><i>yak</i><font color="#AAAAAA">=1 </font><i>shaved</i><font color="#AAAAAA">=true </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809500Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: </font><i>yaks_shaved</i><font color="#AAAAAA">=1 </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809531Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>:<b>shave</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: hello! I&apos;m gonna shave a yak </font><i>excitement</i><font color="#AAAAAA">=&quot;yay!&quot; </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3 </font><font color="#AAAAAA"><i>yak</i></font><font color="#AAAAAA">=2</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809554Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>:<b>shave</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: yak shaved successfully </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3 </font><font color="#AAAAAA"><i>yak</i></font><font color="#AAAAAA">=2</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809581Z </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks</b>: <b>yak_events</b><font color="#AAAAAA">: </font><i>yak</i><font color="#AAAAAA">=2 </font><i>shaved</i><font color="#AAAAAA">=true </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809606Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: </font><i>yaks_shaved</i><font color="#AAAAAA">=2 </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809635Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>:<b>shave</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: hello! I&apos;m gonna shave a yak </font><i>excitement</i><font color="#AAAAAA">=&quot;yay!&quot; </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3 </font><font color="#AAAAAA"><i>yak</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809664Z </font><font color="#C4A000"> WARN</font> <b>shaving_yaks</b>:<b>shave</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: could not locate yak </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3 </font><font color="#AAAAAA"><i>yak</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809693Z </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks</b>: <b>yak_events</b><font color="#AAAAAA">: </font><i>yak</i><font color="#AAAAAA">=3 </font><i>shaved</i><font color="#AAAAAA">=false </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809717Z </font><font color="#CC0000">ERROR</font> <b>shaving_yaks</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: failed to shave yak </font><i>yak</i><font color="#AAAAAA">=3 </font><i>error</i><font color="#AAAAAA">=missing yak </font><i>error.sources</i><font color="#AAAAAA">=[out of space, out of cash] </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809743Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks</b>: <b>fmt_compact::yak_shave</b><font color="#AAAAAA">: </font><i>yaks_shaved</i><font color="#AAAAAA">=2 </font><font color="#AAAAAA"><i>yaks</i></font><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-17T19:51:05.809768Z </font><font color="#4E9A06"> INFO</font> <b>fmt_compact</b><font color="#AAAAAA">: yak shaving completed </font><i>all_yaks_shaved</i><font color="#AAAAAA">=false</font>/// Marker for [`Format`] that indicates that the default log format should be used./// This formatter shows the span context before printing event data. Spans are/// displayed including their names and fields./// <pre><font color="#4E9A06"><b>:;</b></font> <font color="#4E9A06">cargo</font> run --example fmt/// <font color="#4E9A06"><b>     Running</b></font> `target/debug/examples/fmt`/// <font color="#AAAAAA">2022-02-15T18:40:14.289898Z </font><font color="#4E9A06"> INFO</font> fmt: preparing to shave yaks <i>number_of_yaks</i><font color="#AAAAAA">=3</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.289974Z </font><font color="#4E9A06"> INFO</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: shaving yaks</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290011Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">:</font><b>shave{</b><i>yak</i><font color="#AAAAAA">=1</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: hello! I&apos;m gonna shave a yak </font><i>excitement</i><font color="#AAAAAA">=&quot;yay!&quot;</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290038Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">:</font><b>shave{</b><i>yak</i><font color="#AAAAAA">=1</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: yak shaved successfully</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290070Z </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: yak_events: </font><i>yak</i><font color="#AAAAAA">=1 </font><i>shaved</i><font color="#AAAAAA">=true</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290089Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: </font><i>yaks_shaved</i><font color="#AAAAAA">=1</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290114Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">:</font><b>shave{</b><i>yak</i><font color="#AAAAAA">=2</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: hello! I&apos;m gonna shave a yak </font><i>excitement</i><font color="#AAAAAA">=&quot;yay!&quot;</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290134Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">:</font><b>shave{</b><i>yak</i><font color="#AAAAAA">=2</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: yak shaved successfully</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290157Z </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: yak_events: </font><i>yak</i><font color="#AAAAAA">=2 </font><i>shaved</i><font color="#AAAAAA">=true</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290174Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: </font><i>yaks_shaved</i><font color="#AAAAAA">=2</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290198Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">:</font><b>shave{</b><i>yak</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: hello! I&apos;m gonna shave a yak </font><i>excitement</i><font color="#AAAAAA">=&quot;yay!&quot;</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290222Z </font><font color="#C4A000"> WARN</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">:</font><b>shave{</b><i>yak</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: could not locate yak</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290247Z </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: yak_events: </font><i>yak</i><font color="#AAAAAA">=3 </font><i>shaved</i><font color="#AAAAAA">=false</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290268Z </font><font color="#CC0000">ERROR</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: failed to shave yak </font><i>yak</i><font color="#AAAAAA">=3 </font><i>error</i><font color="#AAAAAA">=missing yak </font><i>error.sources</i><font color="#AAAAAA">=[out of space, out of cash]</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290287Z </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b><i>yaks</i><font color="#AAAAAA">=3</font><b>}</b><font color="#AAAAAA">: fmt::yak_shave: </font><i>yaks_shaved</i><font color="#AAAAAA">=2</font>/// <font color="#AAAAAA">2022-02-15T18:40:14.290309Z </font><font color="#4E9A06"> INFO</font> fmt: yak shaving completed. <i>all_yaks_shaved</i><font color="#AAAAAA">=false</font>display_timestampdisplay_targetdisplay_leveldisplay_thread_iddisplay_thread_namedisplay_filenamedisplay_line_number/// A pre-configured event formatter./// You will usually want to use this as the `FormatEvent` for a `FmtSubscriber`./// The default logging format, [`Full`] includes all fields in each event and its containing/// spans. The [`Compact`] logging format is intended to produce shorter log/// lines; it displays each event's fields, along with fields from the current/// span context, but other information is abbreviated. The [`Pretty`] logging/// format is an extra-verbose, multi-line human-readable logging format/// intended for use in development.// We may not want to do that if we choose to expose specialized// constructors instead (e.g. `from_string` that stores whether the string// is empty...?)//(@kaifastromai) I suppose having dedicated constructors may have certain benefits// but I am not privy to the larger direction of tracing/subscriber./// Create a new [`Writer`] from any type that implements [`fmt::Write`]./// The returned `Writer` value may be passed as an argument to methods/// such as [`Format::format_event`]. Since constructing a `Writer`/// mutably borrows the underlying [`fmt::Write`] instance, that value may/// be accessed again once the `Writer` is dropped. For example, if the/// value implementing [`fmt::Write`] is a [`String`], it will contain/// the formatted output of [`Format::format_event`], which may then be/// used for other purposes./// Return a new `Writer` that mutably borrows `self`./// This can be used to temporarily borrow a `Writer` to pass a new `Writer`/// to a function that takes a `Writer` by value, allowing the original writer/// to still be used once that function returns./// Writes a string slice into this `Writer`, returning whether the write succeeded./// This method can only succeed if the entire string slice was successfully/// written, and this method will not return until all data has been written/// This is identical to calling the [`write_str` method] from the `Writer`'s/// [`std::fmt::Write`] implementation. However, it is also provided as an/// inherent method, so that `Writer`s can be used without needing to import the/// [`std::fmt::Write`] trait./// This function will return an instance of [`std::fmt::Error`] on error./// [`write_str` method]: std::fmt::Write::write_str/// Writes a [`char`] into this writer, returning whether the write succeeded./// A single [`char`] may be encoded as more than one byte./// This method can only succeed if the entire byte sequence was successfully/// written, and this method will not return until all data has been/// written or an error occurs./// This is identical to calling the [`write_char` method] from the `Writer`'s/// [`write_char` method]: std::fmt::Write::write_char/// Glue for usage of the [`write!`] macro with `Writer`s./// This method should generally not be invoked manually, but rather through/// the [`write!`] macro itself./// This is identical to calling the [`write_fmt` method] from the `Writer`'s/// inherent method, so that `Writer`s can be used with the [`write!` macro]/// without needing to import the/// [`write_fmt` method]: std::fmt::Write::write_fmthas_ansi_escapes/// Returns `true` if [ANSI escape codes] may be used to add colors/// and other formatting when writing to this `Writer`./// If this returns `false`, formatters should not emit ANSI escape codes./// Use a less verbose output format./// See [`Compact`]./// Use an excessively pretty, human-readable output format./// See [`Pretty`]./// Note that this requires the "ansi" feature to be enabled./// [`Format::with_ansi`] can be used to disable ANSI terminal escape codes (which enable/// formatting such as colors, bold, italic, etc) in event formatting. However, a field/// formatter must be manually provided to avoid ANSI in the formatting of parent spans, like/// so:/// # use tracing_subscriber::fmt::format;///    .pretty()///    .with_ansi(false)///    .fmt_fields(format::PrettyFields::new().with_ansi(false))///    // ... other settings ...///    .init();/// Use the given [`timer`] for log message timestamps./// See [`time` module] for the provided timer implementations./// Note that using the `"time"` feature flag enables the/// Do not emit timestamps with log messages./// Enable ANSI terminal colors for formatted output.with_source_location/// Sets whether or not the source code location from which an event/// originated is displayed./// This is equivalent to calling [`Format::with_file`] and/// [`Format::with_line_number`] with the same value.// === impl FormatFields ===/// The default [`FormatFields`] implementation.DefaultVisitor/// The [visitor] produced by [`DefaultFields`]'s [`MakeVisitor`] implementation./// Returns a new default [`FormatFields`] implementation.maybe_padErrorSourceList/// Renders an error into a list of sources, *including* the errorFmtCtxFmtThreadNameFmtLevelTRACE_STRDEBUG_STRINFO_STRWARN_STRERROR_STR/// Configures what points in the span lifecycle are logged as events./// See also [`with_span_events`](super::SubscriberBuilder.html::with_span_events)./// one event when span is created/// one event per enter of a spanEXIT/// one event per exit of a span/// one event when the span is dropped/// spans are ignored (this is the default)/// one event per enter/exit of a span/// events at all points (new, enter, exit, drop)/// Check whether or not a certain flag is set for this [`FmtSpan`]impl_fmt_span_bit_opimpl_fmt_span_bit_assign_opfmt_timingwith_kindtrace_newtrace_entertrace_exittrace_closedisable_everythingtest_ansitest_without_levelwith_line_number_and_file_namewith_filenamepretty_defaultassert_info_helloassert_info_hello_ignore_numeric// When numeric characters are used they often form a non-deterministic value as they usually represent things like a thread id or line number.// This assert method should be used when non-deterministic numeric characters are present.test_overridden_parentstest_overridden_parents_in_scopewith_ansi_truewith_ansi_falsewithout_leveloverridden_parentsoverridden_parents_in_scopeformat_nanosfmt_span_combinations/// Returns the test's module path.//! Formatters for logging `tracing` events.//! This module provides several formatter implementations, as well as utilities//! for implementing custom formatters.//! # Formatters//! This module provides a number of formatter implementations://! * [`Full`]: The default formatter. This emits human-readable,//!   single-line logs for each event that occurs, with the current span context//!   displayed before the formatted representation of the event. See//!   [here](Full#example-output) for sample output.//! * [`Compact`]: A variant of the default formatter, optimized for//!   short line lengths. Fields from the current span context are appended to//!   the fields of the formatted event, and span names are not shown; the//!   verbosity level is abbreviated to a single character. See//!   [here](Compact#example-output) for sample output.//! * [`Pretty`]: Emits excessively pretty, multi-line logs, optimized//!   for human readability. This is primarily intended to be used in local//!   development and debugging, or for command-line applications, where//!   automated analysis and compact storage of logs is less of a priority than//!   readability and visual appeal. See [here](Pretty#example-output)//!   for sample output.//! * [`Json`]: Outputs newline-delimited JSON logs. This is intended//!   for production use with systems where structured logs are consumed as JSON//!   by analysis and viewing tools. The JSON output is not optimized for human//!   readability. See [here](Json#example-output) for sample output.// === impl Writer ===// === impl Format ===// === impl DefaultVisitor ===// === impl FieldFn ===// === printing synthetic Span events ===display_location/// An excessively pretty, human-readable event formatter./// Unlike the [`Full`], [`Compact`], and [`Json`] formatters, this is a/// multi-line output format. Each individual event may output multiple lines of/// text./// <pre><font color="#4E9A06"><b>:;</b></font> <font color="#4E9A06">cargo</font> run --example fmt-pretty/// <font color="#4E9A06"><b>     Running</b></font> `target/debug/examples/fmt-pretty`///   2022-02-15T18:44:24.535324Z <font color="#4E9A06"> INFO</font> <font color="#4E9A06"><b>fmt_pretty</b></font><font color="#4E9A06">: preparing to shave yaks, </font><font color="#4E9A06"><b>number_of_yaks</b></font><font color="#4E9A06">: 3</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt-pretty.rs:16 <font color="#AAAAAA"><i>on</i></font> main///   2022-02-15T18:44:24.535403Z <font color="#4E9A06"> INFO</font> <font color="#4E9A06"><b>fmt_pretty::yak_shave</b></font><font color="#4E9A06">: shaving yaks</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:41 <font color="#AAAAAA"><i>on</i></font> main///     <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3///   2022-02-15T18:44:24.535442Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: hello! I&apos;m gonna shave a yak, </font><font color="#75507B"><b>excitement</b></font><font color="#75507B">: &quot;yay!&quot;</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:16 <font color="#AAAAAA"><i>on</i></font> main///     <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 1///   2022-02-15T18:44:24.535469Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: yak shaved successfully</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:25 <font color="#AAAAAA"><i>on</i></font> main///   2022-02-15T18:44:24.535502Z <font color="#3465A4">DEBUG</font> <font color="#3465A4"><b>yak_events</b></font><font color="#3465A4">: </font><font color="#3465A4"><b>yak</b></font><font color="#3465A4">: 1, </font><font color="#3465A4"><b>shaved</b></font><font color="#3465A4">: true</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:46 <font color="#AAAAAA"><i>on</i></font> main///   2022-02-15T18:44:24.535524Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: </font><font color="#75507B"><b>yaks_shaved</b></font><font color="#75507B">: 1</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:55 <font color="#AAAAAA"><i>on</i></font> main///   2022-02-15T18:44:24.535551Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: hello! I&apos;m gonna shave a yak, </font><font color="#75507B"><b>excitement</b></font><font color="#75507B">: &quot;yay!&quot;</font>///     <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 2///   2022-02-15T18:44:24.535573Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: yak shaved successfully</font>///   2022-02-15T18:44:24.535600Z <font color="#3465A4">DEBUG</font> <font color="#3465A4"><b>yak_events</b></font><font color="#3465A4">: </font><font color="#3465A4"><b>yak</b></font><font color="#3465A4">: 2, </font><font color="#3465A4"><b>shaved</b></font><font color="#3465A4">: true</font>///   2022-02-15T18:44:24.535618Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: </font><font color="#75507B"><b>yaks_shaved</b></font><font color="#75507B">: 2</font>///   2022-02-15T18:44:24.535644Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: hello! I&apos;m gonna shave a yak, </font><font color="#75507B"><b>excitement</b></font><font color="#75507B">: &quot;yay!&quot;</font>///     <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 3///   2022-02-15T18:44:24.535670Z <font color="#C4A000"> WARN</font> <font color="#C4A000"><b>fmt_pretty::yak_shave</b></font><font color="#C4A000">: could not locate yak</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:18 <font color="#AAAAAA"><i>on</i></font> main///   2022-02-15T18:44:24.535698Z <font color="#3465A4">DEBUG</font> <font color="#3465A4"><b>yak_events</b></font><font color="#3465A4">: </font><font color="#3465A4"><b>yak</b></font><font color="#3465A4">: 3, </font><font color="#3465A4"><b>shaved</b></font><font color="#3465A4">: false</font>///   2022-02-15T18:44:24.535720Z <font color="#CC0000">ERROR</font> <font color="#CC0000"><b>fmt_pretty::yak_shave</b></font><font color="#CC0000">: failed to shave yak, </font><font color="#CC0000"><b>yak</b></font><font color="#CC0000">: 3, </font><font color="#CC0000"><b>error</b></font><font color="#CC0000">: missing yak, </font><font color="#CC0000"><b>error.sources</b></font><font color="#CC0000">: [out of space, out of cash]</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:51 <font color="#AAAAAA"><i>on</i></font> main///   2022-02-15T18:44:24.535742Z <font color="#75507B">TRACE</font> <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: </font><font color="#75507B"><b>yaks_shaved</b></font><font color="#75507B">: 2</font>///   2022-02-15T18:44:24.535765Z <font color="#4E9A06"> INFO</font> <font color="#4E9A06"><b>fmt_pretty</b></font><font color="#4E9A06">: yak shaving completed, </font><font color="#4E9A06"><b>all_yaks_shaved</b></font><font color="#4E9A06">: false</font>///     <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt-pretty.rs:19 <font color="#AAAAAA"><i>on</i></font> mainPrettyVisitor/// The [visitor] produced by [`Pretty`]'s [`MakeVisitor`] implementation./// [visitor]: field::Visit/// A value to override the provided `Writer`'s ANSI formatting/// If this is `Some`, we override the `Writer`'s ANSI setting. This is/// necessary in order to continue supporting the deprecated/// `PrettyFields::with_ansi` method. If it is `None`, we don't override the/// ANSI formatting configuration (because the deprecated method was not// TODO: when `PrettyFields::with_ansi` is removed, we can get rid// of this entirely.PrettyFields/// An excessively pretty, human-readable [`MakeVisitor`] implementation.style_for/// Sets whether the event's source code location is displayed./// This defaults to `true`./// Returns a new default [`PrettyFields`] implementation./// Enable ANSI encoding for formatted fields.// === impl Pretty ===// === impl PrettyFields ===// === impl PrettyVisitor ===Layered/// A `Subscriber` that logs formatted representations of `tracing` events./// This consists of an inner `Formatter` wrapped in a layer that performs filtering./// This type only logs formatted events; it does not perform any filtering./// Configures and constructs `Subscriber`s./// Returns a new [`SubscriberBuilder`] for configuring a [formatting subscriber]./// This is essentially shorthand for [`SubscriberBuilder::default()]`./// Using [`init`] to set the default subscriber:/// tracing_subscriber::fmt().init();/// Configuring the output format:///     // Configure formatting settings.///     .with_target(false)///     .with_timer(tracing_subscriber::fmt::time::uptime())///     .with_level(true)///     // Set the subscriber as the default./// [`try_init`] returns an error if the default subscriber could not be set:/// fn init_subscriber() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {///     tracing_subscriber::fmt()///         // Configure the subscriber to emit logs in JSON format.///         .json()///         // Configure the subscriber to flatten event fields in the output JSON objects.///         .flatten_event(true)///         // Set the subscriber as the default, returning an error if this fails.///         .try_init()?;/// Rather than setting the subscriber as the default, [`finish`] _returns_ the/// constructed subscriber, which may then be passed to other functions:/// let subscriber = tracing_subscriber::fmt()///     .with_max_level(tracing::Level::DEBUG)///     .compact()/// tracing::subscriber::with_default(subscriber, || {///     // the subscriber will only be set as the default///     // inside this closure.../// [formatting subscriber]: Subscriber/// [`SubscriberBuilder::default()`]: SubscriberBuilder::default/// [`init`]: SubscriberBuilder::init()/// [`try_init`]: SubscriberBuilder::try_init()/// [`finish`]: SubscriberBuilder::finish()/// Returns a new [formatting layer] that can be [composed] with other layers to/// construct a [`Subscriber`]./// This is a shorthand for the equivalent [`Layer::default()`] function./// [formatting layer]: Layer/// [composed]: crate::layer/// [`Layer::default()`]: Layer::defaultDEFAULT_MAX_LEVEL/// The maximum [verbosity level] that is enabled by a `Subscriber` by/// This can be overridden with the [`SubscriberBuilder::with_max_level`] method./// [verbosity level]: tracing_core::Level/// [`SubscriberBuilder::with_max_level`]: SubscriberBuilder::with_max_level/// Returns a new `SubscriberBuilder` for configuring a format subscriber./// Returns a new format subscriber with the default configuration.span_data/// Finish the builder, returning a new `FmtSubscriber`./// Install this Subscriber as the global default if one is/// not already set./// If the `tracing-log` feature is enabled, this will also install/// the LogTracer to convert `Log` records into `tracing` `Event`s./// Returns an Error if the initialization was unsuccessful, likely/// because a global subscriber was already installed by another/// call to `try_init`./// Install this Subscriber as the global default./// Panics if the initialization was unsuccessful, likely because a/// global subscriber was already installed by another call to `try_init`./// [`timer`]: time::FormatTime/// [`time` module]: mod@time/// [`UtcTime`]: time::UtcTime/// [`LocalTime`]: time::LocalTime/// - `FmtSpan::ACTIVE`: An event will be synthesized when spans are entered/// [time]: SubscriberBuilder::without_time()/// Sets the subscriber being built to use a less verbose formatter./// See [`format::Compact`]./// Sets the subscriber being built to use an [excessively pretty, human-readable formatter](crate::fmt::format::Pretty)./// Sets the field formatter that the subscriber being built will use to record/// use tracing_subscriber::fmt::format;/// let formatter =///     // Construct a custom formatter for `Debug` fields///     format::debug_fn(|writer, field, value| write!(writer, "{}: {:?}", field, value))///         // Use the `tracing_subscriber::MakeFmtExt` trait to wrap the///         // formatter so that a delimiter is added between fields.///         .delimited(", ");///     .fmt_fields(formatter)/// # drop(subscriber)/// Sets the maximum [verbosity level] that will be enabled by the/// If the max level has already been set, or a [`EnvFilter`] was added by/// [`with_env_filter`], this replaces that configuration with the new/// maximum level./// Enable up to the `DEBUG` verbosity level:/// fmt()///     .with_max_level(Level::DEBUG)/// This subscriber won't record any spans or events!/// use tracing_subscriber::{fmt, filter::LevelFilter};///     .with_max_level(LevelFilter::OFF)/// [`EnvFilter`]: struct@crate::filter::EnvFilter/// [`with_env_filter`]: fn@Self::with_env_filter/// Sets the [event formatter][`FormatEvent`] that the subscriber being built/// will use to format events that occur.///     .event_format(format().compact())/// [`Writer`]: struct@self::format::Writer/// Sets the [`MakeWriter`] that the subscriber being built will use to write events.///     .with_writer(io::stderr)/// Configures the subscriber to support [`libtest`'s output capturing][capturing] when used in/// Using [`TestWriter`] to let `cargo test` capture test output. Note that we do not install it/// globally as it may cause conflicts./// use tracing::subscriber;/// subscriber::set_default(///     fmt()///         .with_test_writer()///         .finish()/// [`TestWriter`]: writer::TestWriter/// This sets the event formatter that the subscriber being built will use to record fields.///     .map_event_format(|e| e.compact())/// This sets the field formatter that the subscriber being built will use to record fields.///     .map_fmt_fields(|f| f.debug_alt())/// This sets the [`MakeWriter`] that the subscriber being built will use to write events./// let layer = tracing_subscriber::fmt()///     .map_writer(move |w| stderr.or_else(w))/// Install a global tracing subscriber that listens for events and/// filters based on the value of the [`RUST_LOG` environment variable],/// if one is not already set./// the [`LogTracer`] to convert `log` records into `tracing` `Event`s./// This is shorthand for/// # fn doc() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {/// tracing_subscriber::fmt().try_init()/// Returns an Error if the initialization was unsuccessful,/// likely because a global subscriber was already installed by another/// [`LogTracer`]:///     https://docs.rs/tracing-log/0.1.0/tracing_log/struct.LogTracer.html/// [`RUST_LOG` environment variable]: crate::filter::EnvFilter::DEFAULT_ENV/// filters based on the value of the [`RUST_LOG` environment variable]./// The configuration of the subscriber initialized by this function/// depends on what [feature flags](crate#feature-flags) are enabled./// If the `env-filter` feature is enabled, this is shorthand for/// # use tracing_subscriber::EnvFilter;///     .with_env_filter(EnvFilter::from_default_env())map_errorsubscriber_downcastssubscriber_downcasts_to_parts//! A `Subscriber` for formatting and logging `tracing` data.//! structured, event-based diagnostic information. This crate provides an//! implementation of the [`Subscriber`] trait that records `tracing`'s `Event`s//! and `Span`s by formatting them as text and logging them to stdout.//! First, add this to your `Cargo.toml` file://! tracing-subscriber = "0.3"//! [msrv]: super#supported-rust-versions//! Add the following to your executable to initialize the default subscriber://! use tracing_subscriber;//! ## Filtering Events with Environment Variables//! The default subscriber installed by `init` enables you to filter events//! at runtime using environment variables (using the [`EnvFilter`]).//! The filter syntax is a superset of the [`env_logger`] syntax.//! - Setting `RUST_LOG=debug` enables all `Span`s and `Event`s//!     set to the log level `DEBUG` or higher//! - Setting `RUST_LOG=my_crate=trace` enables `Span`s and `Event`s//!     in `my_crate` at all log levels//! **Note**: This should **not** be called by libraries. Libraries should use//! [`tracing`] to publish `tracing` `Event`s.//! You can configure a subscriber instead of using the defaults with//! the following functions://! ### Subscriber//! The [`FmtSubscriber`] formats and records `tracing` events as line-oriented logs.//! You can create one by calling://! let subscriber = tracing_subscriber::fmt()//!     // ... add configuration//!     .finish();//! You can find the configuration methods for [`FmtSubscriber`] in//! [`SubscriberBuilder`].//! ## Formatters//! The output format used by the layer and subscriber in this module is//! represented by implementing the [`FormatEvent`] trait, and can be//! customized. This module provides a number of formatter implementations://! * [`format::Full`]: The default formatter. This emits human-readable,//!   [here](format::Full#example-output) for sample output.//! * [`format::Compact`]: A variant of the default formatter, optimized for//!   the fields of the formatted event. See//!   [here](format::Compact#example-output) for sample output.//! * [`format::Pretty`]: Emits excessively pretty, multi-line logs, optimized//!   readability and visual appeal. See [here](format::Pretty#example-output)//! * [`format::Json`]: Outputs newline-delimited JSON logs. This is intended//!   readability. See [here](format::Json#example-output) for sample output.//! ### Customizing Formatters//! The formatting of log lines for spans and events is controlled by two//! traits, [`FormatEvent`] and [`FormatFields`]. The [`FormatEvent`] trait//! determines the overall formatting of the log line, such as what information//! from the event's metadata and span context is included and in what order.//! The [`FormatFields`] trait determines how fields &mdash; both the event's//! fields and fields on spans &mdash; are formatted.//! The [`fmt::format`] module provides several types which implement these traits,//! many of which expose additional configuration options to customize their//! output. The [`format::Format`] type implements common configuration used by//! all the formatters provided in this crate, and can be used as a builder to//! set specific formatting settings. For example://! use tracing_subscriber::fmt;//! // Configure a custom event formatter//! let format = fmt::format()//!    .with_level(false) // don't include levels in formatted output//!    .with_target(false) // don't include targets//!    .with_thread_ids(true) // include the thread ID of the current thread//!    .with_thread_names(true) // include the name of the current thread//!    .compact(); // use the `Compact` formatting style.//! // Create a `fmt` subscriber that uses our custom event format, and set it//! // as the default.//! tracing_subscriber::fmt()//!     .event_format(format)//! However, if a specific output format is needed, other crates can//! also implement [`FormatEvent`] and [`FormatFields`]. See those traits'//! documentation for details on how to implement them.//! ## Filters//! If you want to filter the `tracing` `Events` based on environment//! variables, you can use the [`EnvFilter`] as follows://! use tracing_subscriber::EnvFilter;//! let filter = EnvFilter::from_default_env();//! As mentioned above, the [`EnvFilter`] allows `Span`s and `Event`s to//! be filtered at runtime by setting the `RUST_LOG` environment variable.//! You can find the other available [`filter`]s in the documentation.//! ### Using Your Subscriber//! Finally, once you have configured your `Subscriber`, you need to//! configure your executable to use it.//! A subscriber can be installed globally using://! use tracing;//! use tracing_subscriber::FmtSubscriber;//! let subscriber = FmtSubscriber::new();//! tracing::subscriber::set_global_default(subscriber)//!     .map_err(|_err| eprintln!("Unable to set global default subscriber"));//! // Note this will only fail if you try to set the global default//! // subscriber multiple times//! ### Composing Layers//! Composing an [`EnvFilter`] `Layer` and a [format `Layer`][super::fmt::Layer]://! use tracing_subscriber::{fmt, EnvFilter};//! use tracing_subscriber::prelude::*;//! let fmt_layer = fmt::layer()//!     .with_target(false);//! let filter_layer = EnvFilter::try_from_default_env()//!     .or_else(|_| EnvFilter::try_new("info"))//! tracing_subscriber::registry()//!     .with(filter_layer)//!     .with(fmt_layer)//! [`EnvFilter`]: super::filter::EnvFilter//! [`env_logger`]: https://docs.rs/env_logger///! [`filter`]: super::filter//! [`FmtSubscriber`]: Subscriber//! [`Subscriber`]://!     https://docs.rs/tracing/latest/tracing/trait.Subscriber.html//! [`fmt::format`]: mod@crate::fmt::format// === impl Subscriber ===// ===== impl SubscriberBuilder =====ChronoFmtTypeChronoLocal/// Formats [local time]s and [UTC time]s with `FormatTime` implementations/// that use the [`chrono` crate]./// [local time]: [`chrono::offset::Local`]/// [UTC time]: [`chrono::offset::Utc`]/// [`chrono` crate]: [`chrono`]/// Formats the current [local time] using a [formatter] from the [`chrono`] crate./// [local time]: chrono::Local::now()/// [formatter]: chrono::formatrfc_3339/// Format the time using the [`RFC 3339`] format/// (a subset of [`ISO 8601`])./// [`RFC 3339`]: https://tools.ietf.org/html/rfc3339/// [`ISO 8601`]: https://en.wikipedia.org/wiki/ISO_8601/// Format the time using the given format string./// See [`chrono::format::strftime`] for details on the supported syntax.ChronoUtc/// Formats the current [UTC time] using a [formatter] from the [`chrono`] crate./// [UTC time]: chrono::Utc::now()/// Format according to the RFC 3339 convention./// Format according to a custom format string./// The RFC 3339 format is used by default but a custom format string/// can be used. See [`chrono::format::strftime`]for details on/// the supported syntax./// [`chrono::format::strftime`]: https://docs.rs/chrono/0.4.9/chrono/format/strftime/index.htmltest_chrono_format_time_utc_defaulttest_chrono_format_time_utc_customtest_chrono_format_time_local_defaulttest_chrono_format_time_local_custom/// A date/time type which exists primarily to convert `SystemTime` timestamps into an ISO 8601/// formatted string./// Yes, this exists. Before you have a heart attack, understand that the meat of this is musl's/// [`__secs_to_tm`][1] converted to Rust via [c2rust][2] and then cleaned up by hand as part of/// the [kudu-rs project][3], [released under MIT][4]./// [1] http://git.musl-libc.org/cgit/musl/tree/src/time/__secs_to_tm.c/// [2] https://c2rust.com//// [3] https://github.com/danburkert/kudu-rs/blob/c9660067e5f4c1a54143f169b5eeb49446f82e54/src/timestamp.rs#L5-L18/// [4] https://github.com/tokio-rs/tracing/issues/1644#issuecomment-963888244/// All existing `strftime`-like APIs I found were unable to handle the full range of timestamps representable/// by `SystemTime`, including `strftime` itself, since tm.tm_year is an int.test_datetime// musl as a whole is licensed under the following standard MIT license:// ----------------------------------------------------------------------// Copyright © 2005-2020 Rich Felker, et al.// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.// Authors/contributors include:// A. Wilcox// Ada Worcester// Alex Dowad// Alex Suykov// Alexander Monakov// Andre McCurdy// Andrew Kelley// Anthony G. Basile// Aric Belsito// Arvid Picciani// Bartosz Brachaczek// Benjamin Peterson// Bobby Bingham// Boris Brezillon// Brent Cook// Chris Spiegel// Clément Vasseur// Daniel Micay// Daniel Sabogal// Daurnimator// David Carlier// David Edelsohn// Denys Vlasenko// Dmitry Ivanov// Dmitry V. Levin// Drew DeVault// Emil Renner Berthing// Fangrui Song// Felix Fietkau// Felix Janda// Gianluca Anzolin// Hauke Mehrtens// He X// Hiltjo Posthuma// Isaac Dunham// Jaydeep Patil// Jens Gustedt// Jeremy Huntwork// Jo-Philipp Wich// Joakim Sindholt// John Spencer// Julien Ramseier// Justin Cormack// Kaarle Ritvanen// Khem Raj// Kylie McClain// Leah Neukirchen// Luca Barbato// Luka Perkov// M Farkas-Dyck (Strake)// Mahesh Bodapati// Markus Wichmann// Masanori Ogino// Michael Clark// Michael Forney// Mikhail Kremnyov// Natanael Copa// Nicholas J. Kain// orc// Pascal Cuoq// Patrick Oppenlander// Petr Hosek// Petr Skocik// Pierre Carrier// Reini Urban// Rich Felker// Richard Pennington// Ryan Fairfax// Samuel Holland// Segev Finer// Shiz// sin// Solar Designer// Stefan Kristiansson// Stefan O'Rear// Szabolcs Nagy// Timo Teräs// Trutz Behn// Valentin Ochs// Will Dietz// William Haddon// William Pitcock// Portions of this software are derived from third-party works licensed// under terms compatible with the above MIT license:// The TRE regular expression implementation (src/regex/reg* and// src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed// under a 2-clause BSD license (license text in the source files). The// included version has been heavily modified by Rich Felker in 2012, in// the interests of size, simplicity, and namespace cleanliness.// Much of the math library code (src/math/* and src/complex/*) is// Copyright © 1993,2004 Sun Microsystems or// Copyright © 2003-2011 David Schultz or// Copyright © 2003-2009 Steven G. Kargl or// Copyright © 2003-2009 Bruce D. Evans or// Copyright © 2008 Stephen L. Moshier or// Copyright © 2017-2018 Arm Limited// and labelled as such in comments in the individual source files. All// have been licensed under extremely permissive terms.// The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008// The Android Open Source Project and is licensed under a two-clause BSD// license. It was taken from Bionic libc, used on Android.// The AArch64 memcpy and memset code (src/string/aarch64/*) are// Copyright © 1999-2019, Arm Limited.// The implementation of DES for crypt (src/crypt/crypt_des.c) is// Copyright © 1994 David Burren. It is licensed under a BSD license.// The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was// originally written by Solar Designer and placed into the public// domain. The code also comes with a fallback permissive license for use// in jurisdictions that may not recognize the public domain.// The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011// Valentin Ochs and is licensed under an MIT-style license.// The x86_64 port was written by Nicholas J. Kain and is licensed under// the standard MIT terms.// The mips and microblaze ports were originally written by Richard// Pennington for use in the ellcc project. The original code was adapted// by Rich Felker for build system and code conventions during upstream// integration. It is licensed under the standard MIT terms.// The mips64 port was contributed by Imagination Technologies and is// licensed under the standard MIT terms.// The powerpc port was also originally written by Richard Pennington,// and later supplemented and integrated by John Spencer. It is licensed// under the standard MIT terms.// All other files which have no copyright comments are original works// produced specifically for use as part of this library, written either// by Rich Felker, the main author of the library, or by one or more// contibutors listed above. Details on authorship of individual files// can be found in the git version control history of the project. The// omission of copyright and license comments in each file is in the// interest of source tree size.// In addition, permission is hereby granted for all public header files// (include/* and arch/*/bits/*) and crt files intended to be linked into// applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit// the copyright notice and permission notice otherwise required by the// license, and to use these files without any requirement of// attribution. These files include substantial contributions from:// all of whom have explicitly granted such permission.// This file previously contained text expressing a belief that most of// the files covered by the above exception were sufficiently trivial not// to be subject to copyright, resulting in confusion over whether it// negated the permissions granted in the license. In the spirit of// permissive licensing, and of not having licensing issues being an// obstacle to adoption, that text has been removed./// Measure and write out the current time./// When `format_time` is called, implementors should get the current time using their desired/// mechanism, and write it out to the given `fmt::Write`. Implementors must insert a trailing/// space themselves if they wish to separate the time from subsequent log message text./// A type that can measure and format the current time./// This trait is used by `Format` to include a timestamp with each `Event` when it is logged./// Notable default implementations of this trait are `SystemTime` and `()`. The former prints the/// current time as reported by `std::time::SystemTime`, and the latter does not print the current/// time at all. `FormatTime` is also automatically implemented for any function pointer with the/// appropriate signature./// The full list of provided implementations can be found in [`time`]./// [`time`]: self/// Returns a new `SystemTime` timestamp provider./// This can then be configured further to determine how timestamps should be/// configured./// # fn timer() -> tracing_subscriber::fmt::time::SystemTime {/// tracing_subscriber::fmt::time::SystemTime::default()/// Returns a new `Uptime` timestamp provider./// With this timer, timestamps will be formatted with the amount of time/// elapsed since the timestamp provider was constructed./// # fn timer() -> tracing_subscriber::fmt::time::Uptime {/// tracing_subscriber::fmt::time::Uptime::default()/// Retrieve and print the current wall-clock time./// Retrieve and print the relative elapsed wall-clock time since an epoch./// The `Default` implementation for `Uptime` makes the epoch the current time.//! Formatters for event timestamps./// Formats the current [local time] using a [formatter] from the [`time` crate]./// To format the current [UTC time] instead, use the [`UtcTime`] type.///     <strong>Warning</strong>: The <a href = "https://docs.rs/time/0.3/time/"><code>time</code>///     crate</a> must be compiled with <code>--cfg unsound_local_offset</code> in order to use///     local timestamps. When this cfg is not enabled, local timestamps cannot be recorded, and///     events will be logged without timestamps.///    Alternatively, [`OffsetTime`] can log with a local offset if it is initialized early.///    See the <a href="https://docs.rs/time/0.3.4/time/#feature-flags"><code>time</code>///    documentation</a> for more details./// [local time]: time::OffsetDateTime::now_local/// [UTC time]:     time::OffsetDateTime::now_utc/// [formatter]:    time::formatting::Formattable/// [`time` crate]: time/// Formats the current [UTC time] using a [formatter] from the [`time` crate]./// To format the current [local time] instead, use the [`LocalTime`] type.OffsetTime/// Formats the current time using a fixed offset and a [formatter] from the [`time` crate]./// This is typically used as an alternative to [`LocalTime`]. `LocalTime` determines the offset/// every time it formats a message, which may be unsound or fail. With `OffsetTime`, the offset is/// determined once. This makes it possible to do so while the program is still single-threaded and/// handle any errors. However, this also means the offset cannot change while the program is/// running (the offset will not change across DST changes)./// [formatter]: time::formatting::Formattable/// Returns a formatter that formats the current [local time] in the/// [RFC 3339] format (a subset of the [ISO 8601] timestamp format)./// use tracing_subscriber::fmt::{self, time};///     .with_timer(time::LocalTime::rfc_3339());/// # drop(subscriber);/// [RFC 3339]: https://datatracker.ietf.org/doc/html/rfc3339/// [ISO 8601]: https://en.wikipedia.org/wiki/ISO_8601/// Returns a formatter that formats the current [local time] using the/// [`time` crate] with the provided provided format. The format may be any/// type that implements the [`Formattable`] trait.///     <strong>Warning</strong>: The <a href = "https://docs.rs/time/0.3/time/">///     <code>time</code> crate</a> must be compiled with <code>--cfg///     unsound_local_offset</code> in order to use local timestamps. When this///     cfg is not enabled, local timestamps cannot be recorded, and///    See the <a href="https://docs.rs/time/0.3.4/time/#feature-flags">///    <code>time</code> documentation</a> for more details./// Typically, the format will be a format description string, or one of the/// `time` crate's [well-known formats]./// If the format description is statically known, then the/// [`format_description!`] macro should be used. This is identical to the/// [`time::format_description::parse`] method, but runs at compile-time,/// throwing an error if the format description is invalid. If the desired format/// is not known statically (e.g., a user is providing a format string), then the/// [`time::format_description::parse`] method should be used. Note that this/// method is fallible./// See the [`time` book] for details on the format description syntax./// Using the [`format_description!`] macro:/// use tracing_subscriber::fmt::{self, time::LocalTime};/// use time::macros::format_description;/// let timer = LocalTime::new(format_description!("[hour]:[minute]:[second]"));///     .with_timer(timer);/// Using [`time::format_description::parse`]:/// let time_format = time::format_description::parse("[hour]:[minute]:[second]")///     .expect("format string should be valid!");/// let timer = LocalTime::new(time_format);/// Using the [`format_description!`] macro requires enabling the `time`/// crate's "macros" feature flag./// Using a [well-known format][well-known formats] (this is equivalent to/// [`LocalTime::rfc_3339`]):/// let timer = LocalTime::new(time::format_description::well_known::Rfc3339);/// [local time]: time::OffsetDateTime::now_local()/// [`Formattable`]: time::formatting::Formattable/// [well-known formats]: time::format_description::well_known/// [`format_description!`]: time::macros::format_description!/// [`time::format_description::parse`]: time::format_description::parse()/// [`time` book]: https://time-rs.github.io/book/api/format-description.html/// Returns a formatter that formats the current [UTC time] in the/// [RFC 3339] format, which is a subset of the [ISO 8601] timestamp format.///     .with_timer(time::UtcTime::rfc_3339());/// [local time]: time::OffsetDateTime::now_utc/// Returns a formatter that formats the current [UTC time] using the/// [`time` crate], with the provided provided format. The format may be any/// failing  an error if the format description is invalid. If the desired format/// use tracing_subscriber::fmt::{self, time::UtcTime};/// let timer = UtcTime::new(format_description!("[hour]:[minute]:[second]"));/// let timer = UtcTime::new(time_format);/// [`UtcTime::rfc_3339`]):/// let timer = UtcTime::new(time::format_description::well_known::Rfc3339);/// [UTC time]: time::OffsetDateTime::now_utc()/// [`time::format_description::parse`]: time::format_description::parselocal_rfc_3339/// Returns a formatter that formats the current time using the [local time offset] in the [RFC/// 3339] format (a subset of the [ISO 8601] timestamp format)./// Returns an error if the local time offset cannot be determined. This typically occurs in/// multithreaded programs. To avoid this problem, initialize `OffsetTime` before forking/// threads. When using Tokio, this means initializing `OffsetTime` before the Tokio runtime.///     .with_timer(time::OffsetTime::local_rfc_3339().expect("could not get local offset!"));/// Using `OffsetTime` with Tokio:/// use tracing_subscriber::fmt::time::OffsetTime;/// async fn run() {///     tracing::info!("runtime initialized");///     // At this point the Tokio runtime is initialized, and we can use both Tokio and Tracing///     // normally.///     // Because we need to get the local offset before Tokio spawns any threads, our `main`///     // function cannot use `tokio::main`.///         .with_timer(OffsetTime::local_rfc_3339().expect("could not get local time offset"))///         .init();///     // Even though `run` is written as an `async fn`, because we used `tokio::main` on it///     // we can call it as a synchronous function.///     run();/// [local time offset]: time::UtcOffset::current_local_offset/// Returns a formatter that formats the current time using the [`time` crate] with the provided/// provided format and [timezone offset]. The format may be any type that implements the/// [`Formattable`] trait./// Typically, the offset will be the [local offset], and format will be a format description/// string, or one of the `time` crate's [well-known formats]./// use tracing_subscriber::fmt::{self, time::OffsetTime};/// use time::UtcOffset;/// let offset = UtcOffset::current_local_offset().expect("should get local offset!");/// let timer = OffsetTime::new(offset, format_description!("[hour]:[minute]:[second]"));/// let timer = OffsetTime::new(offset, time_format);/// [`OffsetTime::local_rfc_3339`]):/// let timer = OffsetTime::new(offset, time::format_description::well_known::Rfc3339);/// [timezone offset]: time::UtcOffset/// [local offset]: time::UtcOffset::current_local_offset()/// [`format_description!`]: time::macros::format_descriptionformat_datetime// === impl LocalTime ===// === impl UtcTime ===// === impl OffsetTime ===/// The concrete [`io::Write`] implementation returned by [`make_writer`]./// [`make_writer`]: MakeWriter::make_writer/// Returns an instance of [`Writer`]./// [`fmt::Layer`] or [`fmt::Subscriber`] will call this method each time an event is recorded. Ensure any state/// that must be saved across writes is not lost when the [`Writer`] instance is dropped. If/// creating a [`io::Write`] instance is expensive, be sure to cache it when implementing/// [`MakeWriter`] to improve performance./// [`Writer`]: MakeWriter::Writer/// [`fmt::Layer`]: crate::fmt::Layer/// [`fmt::Subscriber`]: crate::fmt::Subscribermake_writer_for/// Returns a [`Writer`] for writing data from the span or event described/// by the provided [`Metadata`]./// By default, this calls [`self.make_writer()`][make_writer], ignoring/// the provided metadata, but implementations can override this to provide/// metadata-specific behaviors./// This method allows `MakeWriter` implementations to implement different/// behaviors based on the span or event being written. The `MakeWriter`/// type might return different writers based on the provided metadata, or/// might write some values to the writer before or after providing it to/// For example, we might want to write data from spans and events at the/// [`ERROR`] and [`WARN`] levels to `stderr`, and data from spans or events/// at lower levels to stdout:/// use std::io::{self, Stdout, Stderr, StdoutLock, StderrLock};/// use tracing_subscriber::fmt::writer::MakeWriter;/// use tracing_core::{Metadata, Level};/// pub struct MyMakeWriter {///     stdout: Stdout,///     stderr: Stderr,/// /// A lock on either stdout or stderr, depending on the verbosity level/// /// of the event being written./// pub enum StdioLock<'a> {///     Stdout(StdoutLock<'a>),///     Stderr(StderrLock<'a>),/// impl<'a> io::Write for StdioLock<'a> {///     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {///             StdioLock::Stdout(lock) => lock.write(buf),///             StdioLock::Stderr(lock) => lock.write(buf),///     fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {///         # match self {///         #     StdioLock::Stdout(lock) => lock.write_all(buf),///         #     StdioLock::Stderr(lock) => lock.write_all(buf),///     fn flush(&mut self) -> io::Result<()> {///         #     StdioLock::Stdout(lock) => lock.flush(),///         #     StdioLock::Stderr(lock) => lock.flush(),/// impl<'a> MakeWriter<'a> for MyMakeWriter {///     type Writer = StdioLock<'a>;///     fn make_writer(&'a self) -> Self::Writer {///         // We must have an implementation of `make_writer` that makes///         // a "default" writer without any configuring metadata. Let's///         // just return stdout in that case.///         StdioLock::Stdout(self.stdout.lock())///     fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {///         // Here's where we can implement our special behavior. We'll///         // check if the metadata's verbosity level is WARN or ERROR,///         // and return stderr in that case.///         if meta.level() <= &Level::WARN {///             return StdioLock::Stderr(self.stderr.lock());///         // Otherwise, we'll return stdout./// [make_writer]: MakeWriter::make_writer/// [`WARN`]: tracing_core::Level::WARN/// [`ERROR`]: tracing_core::Level::ERROR/// A type that can create [`io::Write`] instances./// `MakeWriter` is used by [`fmt::Layer`] or [`fmt::Subscriber`] to print/// formatted text representations of [`Event`]s./// This trait is already implemented for function pointers and/// immutably-borrowing closures that return an instance of [`io::Write`], such/// as [`io::stdout`] and [`io::stderr`]. Additionally, it is implemented for/// [`std::sync::Mutex`] when the type inside the mutex implements/// [`io::Write`]./// The simplest usage is to pass in a named function that returns a writer. For/// example, to log all events to stderr, we could write:///     .with_writer(std::io::stderr)/// Any function that returns a writer can be used:/// fn make_my_great_writer() -> impl std::io::Write {///     # std::io::stdout()///     .with_writer(make_my_great_writer)/// A closure can be used to introduce arbitrary logic into how the writer is/// created. Consider the (admittedly rather silly) example of sending every 5th/// event to stderr, and all other events to stdout:/// use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};/// let n = AtomicUsize::new(0);///     .with_writer(move || -> Box<dyn io::Write> {///         if n.fetch_add(1, Relaxed) % 5 == 0 {///             Box::new(io::stderr())///             Box::new(io::stdout())/// A single instance of a type implementing [`io::Write`] may be used as a/// `MakeWriter` by wrapping it in a [`Mutex`]. For example, we could/// write to a file like so:/// use std::{fs::File, sync::Mutex};/// let log_file = File::create("my_cool_trace.log")?;///     .with_writer(Mutex::new(log_file))/// [`Event`]: tracing_core::event::Event/// [`io::stdout`]: std::io::stdout()/// [`io::stderr`]: std::io::stderr()/// [`MakeWriter::make_writer_for`]: MakeWriter::make_writer_for/// [levels]: tracing_core::Level/// [targets]: tracing_core::Metadata::targetWithMaxLevel/// Wraps `self` and returns a [`MakeWriter`] that will only write output/// for events at or below the provided verbosity [`Level`]. For instance,/// `Level::TRACE` is considered to be _more verbose` than `Level::INFO`./// Events whose level is more verbose than `level` will be ignored, and no/// output will be written./// use tracing_subscriber::fmt::writer::MakeWriterExt;/// // Construct a writer that outputs events to `stderr` only if the span or/// // event's level is >= WARN (WARN and ERROR)./// let mk_writer = std::io::stderr.with_max_level(Level::WARN);/// tracing_subscriber::fmt().with_writer(mk_writer).init();/// Writing the `ERROR` and `WARN` levels to `stderr`, and everything else/// to `stdout`:/// # use tracing_subscriber::fmt::writer::MakeWriterExt;/// let mk_writer = std::io::stderr///     .with_max_level(Level::WARN)///     .or_else(std::io::stdout);/// Writing the `ERROR` level to `stderr`, the `INFO` and `WARN` levels to/// `stdout`, and the `INFO` and DEBUG` levels to a file:/// # // don't actually create the file when running the tests./// # fn docs() -> std::io::Result<()> {/// let debug_log = Arc::new(File::create("debug.log")?);///     .with_max_level(Level::ERROR)///     .or_else(std::io::stdout///         .with_max_level(Level::INFO)///         .and(debug_log.with_max_level(Level::DEBUG))with_min_levelWithMinLevel/// for events at or above the provided verbosity [`Level`]./// Events whose level is less verbose than `level` will be ignored, and no/// // Construct a writer that outputs events to `stdout` only if the span or/// // event's level is <= DEBUG (DEBUG and TRACE)./// let mk_writer = std::io::stdout.with_min_level(Level::DEBUG);/// This can be combined with [`MakeWriterExt::with_max_level`] to write/// only within a range of levels:/// // Only write the `DEBUG` and `INFO` levels to stdout./// let mk_writer = std::io::stdout///     .with_min_level(Level::INFO)///     // Write the `WARN` and `ERROR` levels to stderr.///     .and(std::io::stderr.with_min_level(Level::WARN));with_filterWithFilter/// Wraps `self` with a predicate that takes a span or event's [`Metadata`]/// and returns a `bool`. The returned [`MakeWriter`]'s/// [`MakeWriter::make_writer_for`] method will check the predicate to/// determine if  a writer should be produced for a given span or event./// If the predicate returns `false`, the wrapped [`MakeWriter`]'s/// [`make_writer_for`][mwf] will return [`OptionalWriter::none`][own]./// Otherwise, it calls the wrapped [`MakeWriter`]'s/// [`make_writer_for`][mwf] method, and returns the produced writer./// This can be used to filter an output based on arbitrary [`Metadata`]/// Writing events with a specific target to an HTTP access log, and other/// events to stdout:/// let access_log = Arc::new(File::create("access.log")?);/// let mk_writer = access_log///     // Only write events with the target "http::access_log" to the///     // access log file.///     .with_filter(|meta| meta.target() == "http::access_log")///     // Write events with all other targets to stdout./// Conditionally enabling or disabling a log file:/// use std::{///     sync::{Arc, atomic::{AtomicBool, Ordering}},///     fs::File,/// static DEBUG_LOG_ENABLED: AtomicBool = AtomicBool::new(false);/// // Create the debug log file/// let debug_file = Arc::new(File::create("debug.log")?)///     // Enable the debug log only if the flag is enabled.///     .with_filter(|_| DEBUG_LOG_ENABLED.load(Ordering::Acquire));/// // Always write to stdout///     // Write to the debug file if it's enabled///     .and(debug_file);/// // Later, we can toggle on or off the debug log file./// DEBUG_LOG_ENABLED.store(true, Ordering::Release);/// [mwf]: MakeWriter::make_writer_for/// [own]: EitherWriter::none/// Combines `self` with another type implementing [`MakeWriter`], returning/// a new [`MakeWriter`] that produces [writers] that write to *both*/// If writing to either writer returns an error, the returned writer will/// return that error. However, both writers will still be written to before/// the error is returned, so it is possible for one writer to fail while/// the other is written to successfully./// // Construct a writer that outputs events to `stdout` *and* `stderr`./// let mk_writer = std::io::stdout.and(std::io::stderr);/// `and` can be used in conjunction with filtering combinators. For/// example, if we want to write to a number of outputs depending on the/// level of an event, we could write:/// // Write everything to the debug log./// let mk_writer = debug_log///     // Write the `ERROR` and `WARN` levels to stderr.///     .and(std::io::stderr.with_max_level(Level::WARN))///     // Write `INFO` to `stdout`.///     .and(std::io::stdout///         .with_min_level(Level::INFO)/// [writers]: std::io::WriteOptionalWriter/// a new [`MakeWriter`] that calls `other`'s [`make_writer`] if `self`'s/// `make_writer` returns [`OptionalWriter::none`][own]./// // Produces a writer that writes to `stderr` if the level is >= WARN,/// // or returns `OptionalWriter::none()` otherwise./// // If the `stderr` `MakeWriter` is disabled by the max level filter,/// // write to stdout instead:/// let mk_writer = stderr.or_else(std::io::stdout);MakeWriterExt/// Extension trait adding combinators for working with types implementing/// [`MakeWriter`]./// This is not intended to be implemented directly for user-defined/// [`MakeWriter`]s; instead, it should be imported when the desired methods are/// A writer intended to support [`libtest`'s output capturing][capturing] for use in unit tests./// `TestWriter` is used by [`fmt::Subscriber`] or [`fmt::Layer`] to enable capturing support./// `cargo test` can only capture output from the standard library's [`print!`] macro. See/// [`libtest`'s output capturing][capturing] for more details about output capturing./// Writing to [`io::stdout`] and [`io::stderr`] produces the same results as using/// [`libtest`'s `--nocapture` option][nocapture] which may make the results look unreadable./// [capturing]: https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output/// [nocapture]: https://doc.rust-lang.org/cargo/commands/cargo-test.html/// [`io::stdout`]: std::io::stdout/// [`io::stderr`]: std::io::stderr/// [`print!`]: std::print!BoxMakeWriter/// A writer that erases the specific [`io::Write`] and [`MakeWriter`] types being used./// This is useful in cases where the concrete type of the writer cannot be known/// A function that returns a [`Subscriber`] that will write to either stdout or stderr:/// # use tracing::Subscriber;/// # use tracing_subscriber::fmt::writer::BoxMakeWriter;/// fn dynamic_writer(use_stderr: bool) -> impl Subscriber {///     let writer = if use_stderr {///         BoxMakeWriter::new(std::io::stderr)///         BoxMakeWriter::new(std::io::stdout)///     tracing_subscriber::fmt().with_writer(writer).finish()/// [`Subscriber`]: tracing::SubscriberEitherWriter/// A writer of type `A`./// A writer of type `B`./// A [writer] that is one of two types implementing [`io::Write`]./// This may be used by [`MakeWriter`] implementations that may conditionally/// return one of two writers./// [writer]: std::io::Write/// A [writer] which may or may not be enabled./// This may be used by [`MakeWriter`] implementations that wish to/// conditionally enable or disable the returned writer based on a span or/// event's [`Metadata`]./// A [`MakeWriter`] combinator that only returns an enabled [writer] for spans/// and events with metadata at or below a specified verbosity [`Level`]./// This is returned by the [`MakeWriterExt::with_max_level`] method. See the/// method documentation for details./// and events with metadata at or above a specified verbosity [`Level`]./// This is returned by the [`MakeWriterExt::with_min_level`] method. See the/// A [`MakeWriter`] combinator that wraps a [`MakeWriter`] with a predicate for/// span and event [`Metadata`], so that the [`MakeWriter::make_writer_for`]/// method returns [`OptionalWriter::some`][ows] when the predicate returns `true`,/// and [`OptionalWriter::none`][own] when the predicate returns `false`./// This is returned by the [`MakeWriterExt::with_filter`] method. See the/// [ows]: EitherWriter::some/// Combines a [`MakeWriter`] that returns an [`OptionalWriter`] with another/// [`MakeWriter`], so that the second [`MakeWriter`] is used when the first/// [`MakeWriter`] returns [`OptionalWriter::none`][own]./// This is returned by the [`MakeWriterExt::or_else] method. See the/// Combines two types implementing [`MakeWriter`] (or [`std::io::Write`]) to/// produce a writer that writes to both [`MakeWriter`]'s returned writers./// This is returned by the [`MakeWriterExt::and`] method. See the methodMutexGuardWriter/// A type implementing [`io::Write`] for a [`MutexGuard`] where the type/// inside the [`Mutex`] implements [`io::Write`]./// This is used by the [`MakeWriter`] implementation for [`Mutex`], because/// [`MutexGuard`] itself will not implement [`io::Write`] — instead, it/// _dereferences_ to a type implementing [`io::Write`]. Because [`MakeWriter`]/// requires the `Writer` type to implement [`io::Write`], it's necessary to add/// a newtype that forwards the trait implementation./// [`MutexGuard`]: std::sync::MutexGuard/// [`Mutex`]: std::sync::MutexArcWriter/// Implements [`std::io::Write`] for an [`Arc`]<W> where `&W: Write`./// This is an implementation detail of the [`MakeWriter`] impl for [`Arc`]./// Returns a new `TestWriter` with the default configuration./// Constructs a `BoxMakeWriter` wrapping a type implementing [`MakeWriter`]./// Returns a [disabled writer]./// Any bytes written to the returned writer are discarded./// This is equivalent to returning [`Option::None`]./// [disabled writer]: std::io::sink/// Returns an enabled writer of type `T`./// This is equivalent to returning [`Option::Some`]./// Wraps the provided [`MakeWriter`] with a maximum [`Level`], so that it/// returns [`OptionalWriter::none`] for spans and events whose level is/// more verbose than the maximum level./// See [`MakeWriterExt::with_max_level`] for details./// Wraps the provided [`MakeWriter`] with a minimum [`Level`], so that it/// less verbose than the maximum level./// See [`MakeWriterExt::with_min_level`] for details./// Wraps `make` with the provided `filter`, returning a [`MakeWriter`] that/// will call `make.make_writer_for()` when `filter` returns `true` for a/// span or event's [`Metadata`], and returns a [`sink`] otherwise./// See [`MakeWriterExt::with_filter`] for details./// [`sink`]: std::io::sink/// Combines two types implementing [`MakeWriter`], returning/// See the documentation for [`MakeWriterExt::and`] for details.impl_tee/// Combineshas_linescustom_writer_closurecustom_writer_structcustom_writer_mutexcombinators_level_filterscombinators_or_elsecombinators_or_else_chaincombinators_and//! Abstractions for creating [`io::Write`] instances.//! [`io::Write`]: std::io::Write// === impl TestWriter ===// === impl BoxMakeWriter ===// === impl Mutex/MutexGuardWriter ===// === impl EitherWriter ===// === impl WithMaxLevel ===// === impl WithMinLevel ===// ==== impl WithFilter ===// === impl Tee ===// === impl OrElse ===// === impl ArcWriter ===// === impl WriteAdaptor ===/// The bitmask of all [`Filtered`] layers that currently apply in this/// context. If there is only a single [`Filtered`] wrapping the layer that/// produced this context, then this is that filter's ID. Otherwise, if we/// are in a nested tree with multiple filters, this is produced by/// [`and`]-ing together the [`FilterId`]s of each of the filters that wrap/// the current layer./// [`Filtered`]: crate::filter::Filtered/// [`FilterId`]: crate::filter::FilterId/// [`and`]: crate::filter::FilterId::and/// Represents information about the current context provided to [`Layer`]s by the/// wrapped [`Subscriber`]./// To access [stored data] keyed by a span ID, implementors of the `Layer`/// trait should ensure that the `Subscriber` type parameter is *also* bound by the/// [`LookupSpan`]:/// use tracing::Subscriber;/// use tracing_subscriber::{Layer, registry::LookupSpan};/// pub struct MyLayer;/// impl<S> Layer<S> for MyLayer/// [`Layer`]: super::Layer/// [`LookupSpan`]: crate::registry::LookupSpan/// Returns the wrapped subscriber's view of the current span./// Returns whether the wrapped subscriber would enable the current span./// Records the provided `event` with the wrapped subscriber./// - The subscriber is free to expect that the event's callsite has been///   [registered][register], and may panic or fail to observe the event if this is///   not the case. The `tracing` crate's macros ensure that all events are///   registered, but if the event is constructed through other means, the///   user is responsible for ensuring that [`register_callsite`][register]///   has been called prior to calling this method./// - This does _not_ call [`enabled`] on the inner subscriber. If the///   caller wishes to apply the wrapped subscriber's filter before choosing///   whether to record the event, it may first call [`Context::enabled`] to///   check whether the event would be enabled. This allows `Layer`s to///   elide constructing the event if it would not be recorded./// [register]: tracing_core::subscriber::Subscriber::register_callsite()/// [`enabled`]: tracing_core::subscriber::Subscriber::enabled()/// [`Context::enabled`]: Context::enabled()event_span/// Returns a [`SpanRef`] for the parent span of the given [`Event`], if/// it has a parent./// If the event has an explicitly overridden parent, this method returns/// a reference to that span. If the event's parent is the current span,/// this returns a reference to the current span, if there is one. If this/// returns `None`, then either the event's parent was explicitly set to/// `None`, or the event's parent was defined contextually, but no span/// is currently entered./// Compared to [`Context::current_span`] and [`Context::lookup_current`],/// this respects overrides provided by the [`Event`]./// Compared to [`Event::parent`], this automatically falls back to the contextual/// span, if required./// use tracing::{Event, Subscriber};///     layer::{Context, Layer},///     registry::LookupSpan,/// struct PrintingLayer;/// impl<S> Layer<S> for PrintingLayer///     S: Subscriber + for<'lookup> LookupSpan<'lookup>,///     fn on_event(&self, event: &Event, ctx: Context<S>) {///         let span = ctx.event_span(event);///         println!("Event in span: {:?}", span.map(|s| s.name()));/// tracing::subscriber::with_default(tracing_subscriber::registry().with(PrintingLayer), || {///     tracing::info!("no span");///     // Prints: Event in span: None///     let span = tracing::info_span!("span");///     tracing::info!(parent: &span, "explicitly specified");///     // Prints: Event in span: Some("span")///     let _guard = span.enter();///     tracing::info!("contextual span");///     <strong>Note</strong>: This requires the wrapped subscriber to///     implement the <a href="../registry/trait.LookupSpan.html"><code>///     LookupSpan</code></a> trait. See the documentation on///     <a href="./struct.Context.html"><code>Context</code>'s///     declaration</a> for details.lookup_current_filtered/// Slow path for when the current span is disabled by PLF and we have a/// registry.// This is called by `lookup_current` in the case that per-layer filtering// is in use. `lookup_current` is allowed to be inlined, but this method is// factored out to prevent the loop and (potentially-recursive) subscriber// downcasting from being inlined if `lookup_current` is inlined./// <strong>Note</strong>: This returns the spans in reverse order (from leaf to root). Use/// current context, starting with the parent span of the specified event,/// and ending with the root of the trace tree and ending with the current span.is_enabled_forif_enabled_foris_enabled_inner/// The layer./// The inner value that `self.layer` was layered onto./// If this is also a `Layer`, then this `Layered` will implement `Layer`./// If this is a `Subscriber`, then this `Layered` will implement/// `Subscriber` instead.inner_is_registry// These booleans are used to determine how to combine `Interest`s and max// level hints when per-layer filters are in use./// Is `self.inner` a `Registry`?/// If so, when combining `Interest`s, we want to "bubble up" its/// `Interest`.has_layer_filter/// Does `self.layer` have per-layer filters?/// This will be true if:/// - `self.inner` is a `Filtered`./// - `self.inner` is a tree of `Layered`s where _all_ arms of those///   `Layered`s have per-layer filters./// Otherwise, if it's a `Layered` with one per-layer filter in one branch,/// but a non-per-layer-filtered layer in the other branch, this will be/// _false_, because the `Layered` is already handling the combining of/// per-layer filter `Interest`s and max level hints with its non-filtered/// `Layer`.inner_has_layer_filter/// Does `self.inner` have per-layer filters?/// This is determined according to the same rules as/// `has_layer_filter` above./// A [`Subscriber`] composed of a `Subscriber` wrapped by one or more/// [`Layer`]s.register_filterpick_interestpick_level_hint// === impl Layered ===layered// The `tests` module is `pub(crate)` because it contains test utilities used by// other modules./// Performs late initialization when installing this layer as a/// [`Subscriber`]./// `Layer`s should not store the [`Dispatch`] pointing to the [`Subscriber`]/// that they are a part of. Because the `Dispatch` owns the `Subscriber`,/// storing the `Dispatch` within the `Subscriber` will create a reference/// count cycle, preventing the `Dispatch` from ever being dropped./// `Dispatch` within a `Layer`, use [`Dispatch::downgrade`] to convert a/// [`WeakDispatch`] can be stored within a subscriber without causing a/// the `Dispatch` must be accessed by the subscriber./// [`WeakDispatch`]: tracing_core::dispatcher::WeakDispatch/// [upgraded]: tracing_core::dispatcher::WeakDispatch::upgrade/// Performs late initialization when attaching a `Layer` to a/// This is a callback that is called when the `Layer` is added to a/// [`Subscriber`] (e.g. in [`Layer::with_subscriber`] and/// [`SubscriberExt::with`]). Since this can only occur before the/// [`Subscriber`] has been set as the default, both the `Layer` and/// [`Subscriber`] are passed to this method _mutably_. This gives the/// `Layer` the opportunity to set any of its own fields with values/// received by method calls on the [`Subscriber`]./// For example, [`Filtered`] layers implement `on_layer` to call the/// [`Subscriber`]'s [`register_filter`] method, and store the returned/// [`FilterId`] as a field./// **Note** In most cases, `Layer` implementations will not need to/// implement this method. However, in cases where a type implementing/// `Layer` wraps one or more other types that implement `Layer`, like the/// [`Layered`] and [`Filtered`] types in this crate, that type MUST ensure/// that the inner `Layer`s' `on_layer` methods are called. Otherwise,/// functionality that relies on `on_layer`, such as [per-layer filtering],/// may not work correctly./// [`register_filter`]: crate::registry::LookupSpan::register_filter/// [per-layer filtering]: #per-layer-filtering/// Registers a new callsite with this layer, returning whether or not/// the layer is interested in being notified about the callsite, similarly/// to [`Subscriber::register_callsite`]./// By default, this returns [`Interest::always()`] if [`self.enabled`] returns/// true, or [`Interest::never()`] if it returns false./// <strong>Note</strong>: This method (and <a href="#method.enabled">/// <code>Layer::enabled</code></a>) determine whether a span or event is/// globally enabled, <em>not</em> whether the individual layer will be/// notified about that span or event. This is intended to be used/// by layers that implement filtering for the entire stack. Layers which do/// not wish to be notified about certain spans or events but do not wish to/// globally disable them should ignore those spans or events in their/// <a href="#method.on_event"><code>on_event</code></a>,/// <a href="#method.on_enter"><code>on_enter</code></a>,/// <a href="#method.on_exit"><code>on_exit</code></a>, and other notification/// See [the trait-level documentation] for more information on filtering/// with `Layer`s./// Layers may also implement this method to perform any behaviour that/// should be run once per callsite. If the layer wishes to use/// `register_callsite` for per-callsite behaviour, but does not want to/// globally enable or disable those callsites, it should always return/// [`Interest::always()`]./// [`Interest`]: tracing_core::Interest/// [`Subscriber::register_callsite`]: tracing_core::Subscriber::register_callsite()/// [`Interest::never()`]: tracing_core::subscriber::Interest::never()/// [`Interest::always()`]: tracing_core::subscriber::Interest::always()/// [`self.enabled`]: Layer::enabled()/// [`Layer::enabled`]: Layer::enabled()/// [`on_event`]: Layer::on_event()/// [`on_enter`]: Layer::on_enter()/// [`on_exit`]: Layer::on_exit()/// [the trait-level documentation]: #filtering-with-layers/// Returns `true` if this layer is interested in a span or event with the/// given `metadata` in the current [`Context`], similarly to/// [`Subscriber::enabled`]./// By default, this always returns `true`, allowing the wrapped subscriber/// to choose to disable the span./// <strong>Note</strong>: This method (and <a href="#method.register_callsite">/// <code>Layer::register_callsite</code></a>) determine whether a span or event is/// [`Subscriber::enabled`]: tracing_core::Subscriber::enabled()/// [`Layer::register_callsite`]: Layer::register_callsite()/// Notifies this layer that a new span was constructed with the given/// `Attributes` and `Id`.// TODO(eliza): do we want this to be a public API? If we end up moving// filtering layers to a separate trait, we may no longer want `Layer`s to// be able to participate in max level hinting.../// Notifies this layer that a span with the given `Id` recorded the given/// `values`.// Note: it's unclear to me why we'd need the current span in `record` (the// only thing the `Context` type currently provides), but passing it in anyway// seems like a good future-proofing measure as it may grow other methods later.../// Notifies this layer that a span with the ID `span` recorded that it/// follows from the span with the ID `follows`./// Called before [`on_event`], to determine if `on_event` should be called./// **Note**: This method determines whether an event is globally enabled,/// *not* whether the individual `Layer` will be notified about the/// event. This is intended to be used by `Layer`s that implement/// filtering for the entire stack. `Layer`s which do not wish to be/// notified about certain events but do not wish to globally disable them/// should ignore those events in their [on_event][Self::on_event]./// [`on_event`]: Self::on_event// collapse this to a constant please mrs optimizer/// Notifies this layer that an event has occurred./// Notifies this layer that a span with the given ID was entered./// Notifies this layer that the span with the given ID was exited./// Notifies this layer that the span with the given ID has been closed./// Notifies this layer that a span ID has been cloned, and that the/// subscriber returned a different ID./// Composes this layer around the given `Layer`, returning a `Layered`/// struct implementing `Layer`./// The returned `Layer` will call the methods on this `Layer` and then/// those of the new `Layer`, before calling the methods on the subscriber/// it wraps. For example:/// # use tracing_subscriber::layer::Layer;/// # use tracing_core::Subscriber;/// pub struct FooLayer {/// pub struct BarLayer {/// impl<S: Subscriber> Layer<S> for FooLayer {/// impl<S: Subscriber> Layer<S> for BarLayer {/// # impl FooLayer {/// # fn new() -> Self { Self {} }/// # impl BarLayer {/// # fn new() -> Self { Self { }}/// # impl MySubscriber {/// # use tracing_core::{span::{Id, Attributes, Record}, Metadata, Event};/// # impl tracing_core::Subscriber for MySubscriber {/// #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(1) }/// #   fn record(&self, _: &Id, _: &Record) {}/// #   fn event(&self, _: &Event) {}/// #   fn record_follows_from(&self, _: &Id, _: &Id) {}/// #   fn enabled(&self, _: &Metadata) -> bool { false }/// #   fn enter(&self, _: &Id) {}/// #   fn exit(&self, _: &Id) {}/// let subscriber = FooLayer::new()///     .and_then(BarLayer::new())///     .with_subscriber(MySubscriber::new());/// Multiple layers may be composed in this manner:/// # pub struct FooLayer {}/// # pub struct BarLayer {}/// # pub struct MySubscriber {}/// # impl<S: Subscriber> Layer<S> for FooLayer {}/// # impl<S: Subscriber> Layer<S> for BarLayer {}/// pub struct BazLayer {/// impl<S: Subscriber> Layer<S> for BazLayer {/// # impl BazLayer { fn new() -> Self { BazLayer {} } }///     .and_then(BazLayer::new())/// Composes this `Layer` with the given [`Subscriber`], returning a/// `Layered` struct that implements [`Subscriber`]./// The returned `Layered` subscriber will call the methods on this `Layer`/// and then those of the wrapped subscriber./// # use tracing_core::{span::{Id, Attributes, Record}, Metadata};/// #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(0) }/// #   fn event(&self, _: &tracing_core::Event) {}/// Combines `self` with a [`Filter`], returning a [`Filtered`] layer./// The [`Filter`] will control which spans and events are enabled for/// this layer. See [the trait-level documentation][plf] for details on/// per-layer filtering./// Erases the type of this [`Layer`], returning a [`Box`]ed `dyn/// Layer` trait object./// This can be used when a function returns a `Layer` which may be of/// one of several types, or when a `Layer` subscriber has a very long type/// The following example will *not* compile, because the value assigned to/// `log_layer` may have one of several different types:/// use tracing_subscriber::{Layer, filter::LevelFilter, prelude::*};/// use std::{path::PathBuf, fs::File, io};/// /// Configures whether logs are emitted to a file, to stdout, or to stderr./// pub enum LogConfig {///     File(PathBuf),///     Stdout,///     Stderr,/// let config = // ...///     # LogConfig::Stdout;/// // Depending on the config, construct a layer of one of several types./// let log_layer = match config {///     // If logging to a file, use a maximally-verbose configuration.///     LogConfig::File(path) => {///         let file = File::create(path)?;///         tracing_subscriber::fmt::layer()///             .with_thread_ids(true)///             .with_thread_names(true)///             // Selecting the JSON logging format changes the layer's///             // type.///             .json()///             .with_span_list(true)///             // Setting the writer to use our log file changes the///             // layer's type again.///             .with_writer(file)///     // If logging to stdout, use a pretty, human-readable configuration.///     LogConfig::Stdout => tracing_subscriber::fmt::layer()///         // Selecting the "pretty" logging format changes the///         // layer's type!///         .pretty()///         .with_writer(io::stdout)///         // Add a filter based on the RUST_LOG environment variable;///         // this changes the type too!///         .and_then(tracing_subscriber::EnvFilter::from_default_env()),///     // If logging to stdout, only log errors and warnings.///     LogConfig::Stderr => tracing_subscriber::fmt::layer()///         // Changing the writer changes the layer's type///         .with_writer(io::stderr)///         // Only log the `WARN` and `ERROR` levels. Adding a filter///         // changes the layer's type to `Filtered<LevelFilter, ...>`.///         .with_filter(LevelFilter::WARN),///     .with(log_layer)/// However, adding a call to `.boxed()` after each match arm erases the/// layer's type, so this code *does* compile:/// # use tracing_subscriber::{Layer, filter::LevelFilter, prelude::*};/// # use std::{path::PathBuf, fs::File, io};/// # pub enum LogConfig {/// #    File(PathBuf),/// #    Stdout,/// #    Stderr,/// # let config = LogConfig::Stdout;///             // Erase the type by boxing the layer///             .boxed()///         .and_then(tracing_subscriber::EnvFilter::from_default_env())///         // Erase the type by boxing the layer///         .boxed(),///         .with_filter(LevelFilter::WARN)/// A composable handler for `tracing` events./// A `Layer` implements a behavior for recording or collecting traces that can/// be composed together with other `Layer`s to build a [`Subscriber`]. See the/// [module-level documentation](crate::layer) for details.r" Returns `true` if this layer is interested in a span or event with the"r" given [`Metadata`] in the current [`Context`], similarly to"r" [`Subscriber::enabled`]."r" If this returns `false`, the span or event will be disabled _for the"r" wrapped [`Layer`]_. Unlike [`Layer::enabled`], the span or event will"r" still be recorded if any _other_ layers choose to enable it. However,"r" the layer [filtered] by this filter will skip recording that span or"r" event."r" If all layers indicate that they do not wish to see this span or event,"r" it will be disabled."r" [`metadata`]: tracing_core::Metadata"r" [`Subscriber::enabled`]: tracing_core::Subscriber::enabled"r" [filtered]: crate::filter::Filtered"r" Returns an [`Interest`] indicating whether this layer will [always],"r" [sometimes], or [never] be interested in the given [`Metadata`]."r" When a given callsite will [always] or [never] be enabled, the results"r" of evaluating the filter may be cached for improved performance."r" Therefore, if a filter is capable of determining that it will always or"r" never enable a particular callsite, providing an implementation of this"r" function is recommended."r#" <pre class="ignore" style="white-space:normal;font:inherit;">"#r" <strong>Note</strong>: If a <code>Filter</code> will perform"r" <em>dynamic filtering</em> that depends on the current context in which"r" a span or event was observed (e.g. only enabling an event when it"r" occurs within a particular span), it <strong>must</strong> return"r" <code>Interest::sometimes()</code> from this method. If it returns"r" <code>Interest::always()</code> or <code>Interest::never()</code>, the"r" <code>enabled</code> method may not be called when a particular instance"r" of that span or event is recorded."r" </pre>"r" This method is broadly similar to [`Subscriber::register_callsite`];"r" however, since the returned value represents only the interest of"r" *this* layer, the resulting behavior is somewhat different."r" If a [`Subscriber`] returns [`Interest::always()`][always] or"r" [`Interest::never()`][never] for a given [`Metadata`], its [`enabled`]"r" method is then *guaranteed* to never be called for that callsite. On the"r" other hand, when a `Filter` returns [`Interest::always()`][always] or"r" [`Interest::never()`][never] for a callsite, _other_ [`Layer`]s may have"r" differing interests in that callsite. If this is the case, the callsite"r" will receive [`Interest::sometimes()`][sometimes], and the [`enabled`]"r" method will still be called for that callsite when it records a span or"r" Returning [`Interest::always()`][always] or [`Interest::never()`][never] from"r" `Filter::callsite_enabled` will permanently enable or disable a"r" callsite (without requiring subsequent calls to [`enabled`]) if and only"r" if the following is true:"r" - all [`Layer`]s that comprise the subscriber include `Filter`s"r"   (this includes a tree of [`Layered`] layers that share the same"r"   `Filter`)"r" - all those `Filter`s return the same [`Interest`]."r" For example, if a [`Subscriber`] consists of two [`Filtered`] layers,"r" and both of those layers return [`Interest::never()`][never], that"r" callsite *will* never be enabled, and the [`enabled`] methods of those"r" [`Filter`]s will not be called."r" ## Default Implementation"r" The default implementation of this method assumes that the"r" `Filter`'s [`enabled`] method _may_ perform dynamic filtering, and"r" returns [`Interest::sometimes()`][sometimes], to ensure that [`enabled`]"r" is called to determine whether a particular _instance_ of the callsite"r" is enabled in the current context. If this is *not* the case, and the"r" `Filter`'s [`enabled`] method will always return the same result"r" for a particular [`Metadata`], this method can be overridden as"r" use tracing_subscriber::layer;"r" use tracing_core::{Metadata, subscriber::Interest};"r" struct MyFilter {"r" impl MyFilter {"r"     // The actual logic for determining whether a `Metadata` is enabled"r"     // must be factored out from the `enabled` method, so that it can be"r"     // called without a `Context` (which is not provided to the"r"     // `callsite_enabled` method)."r"     fn is_enabled(&self, metadata: &Metadata<'_>) -> bool {"r"         # drop(metadata); true"r" impl<S> layer::Filter<S> for MyFilter {"r"     fn enabled(&self, metadata: &Metadata<'_>, _: &layer::Context<'_, S>) -> bool {"r"         // Even though we are implementing `callsite_enabled`, we must still provide a"r"         // working implementation of `enabled`, as returning `Interest::always()` or"r"         // `Interest::never()` will *allow* caching, but will not *guarantee* it."r"         // Other filters may still return `Interest::sometimes()`, so we may be"r"         // asked again in `enabled`."r"         self.is_enabled(metadata)"r"     fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest {"r"         // The result of `self.enabled(metadata, ...)` will always be"r"         // the same for any given `Metadata`, so we can convert it into"r"         // an `Interest`:"r"         if self.is_enabled(metadata) {"r"             Interest::always()"r"         } else {"r"             Interest::never()"r" [`Metadata`]: tracing_core::Metadata"r" [`Interest`]: tracing_core::Interest"r" [always]: tracing_core::Interest::always"r" [sometimes]: tracing_core::Interest::sometimes"r" [never]: tracing_core::Interest::never"r" [`Subscriber::register_callsite`]: tracing_core::Subscriber::register_callsite"r" [`Subscriber`]: tracing_core::Subscriber"r" [`enabled`]: Filter::enabled"r" [`Filtered`]: crate::filter::Filtered"r" Called before the filtered [`Layer]'s [`on_event`], to determine if"r" `on_event` should be called."r" This gives a chance to filter events based on their fields. Note,"r" however, that this *does not* override [`enabled`], and is not even"r" called if [`enabled`] returns `false`."r" By default, this method returns `true`, indicating that no events are"r" filtered out based on their fields."r" [`enabled`]: crate::layer::Filter::enabled"r" [`on_event`]: crate::layer::Layer::on_event"r" Returns an optional hint of the highest [verbosity level][level] that"r" this `Filter` will enable."r" If this method returns a [`LevelFilter`], it will be used as a hint to"r" determine the most verbose level that will be enabled. This will allow"r" spans and events which are more verbose than that level to be skipped"r" more efficiently. An implementation of this method is optional, but"r" strongly encouraged."r" If the maximum level the `Filter` will enable can change over the"r" course of its lifetime, it is free to return a different value from"r" multiple invocations of this method. However, note that changes in the"r" maximum level will **only** be reflected after the callsite [`Interest`]"r" cache is rebuilt, by calling the"r" [`tracing_core::callsite::rebuild_interest_cache`][rebuild] function."r" Therefore, if the `Filter will change the value returned by this"r" method, it is responsible for ensuring that"r" [`rebuild_interest_cache`][rebuild] is called after the value of the max"r" level changes."r" By default, this method returns `None`, indicating that the maximum"r" level is unknown."r" [level]: tracing_core::metadata::Level"r" [`LevelFilter`]: crate::filter::LevelFilter"r" [`Interest`]: tracing_core::subscriber::Interest"r" [rebuild]: tracing_core::callsite::rebuild_interest_cache"r" Notifies this filter that a new span was constructed with the given"r" `Attributes` and `Id`."r" By default, this method does nothing. `Filter` implementations that"r" need to be notified when new spans are created can override this"r" Notifies this filter that a span with the given `Id` recorded the given"r" `values`."r" Notifies this filter that a span with the given ID was entered."r" need to be notified when a span is entered can override this method."r" Notifies this filter that a span with the given ID was exited."r" need to be notified when a span is exited can override this method."r" Notifies this filter that a span with the given ID has been closed."r" need to be notified when a span is closed can override this method."r" A per-[`Layer`] filter that determines whether a span or event is enabled"r" for an individual layer."r" See [the module-level documentation][plf] for details on using [`Filter`]s."r" [plf]: crate::layer#per-layer-filtering"/// Wraps `self` with the provided `layer`./// Extension trait adding a `with(Layer)` combinator to `Subscriber`s./// A layer that does nothing.NoneLayerMarkerNONE_LAYER_MARKERlayer_is_none/// Is a type implementing `Layer` `Option::<_>::None`?subscriber_is_none/// Is a type implementing `Subscriber` `Option::<_>::None`?layer_impl_body/// Returns a new `Identity` layer.//! The [`Layer`] trait, a composable abstraction for building [`Subscriber`]s.//! The [`Subscriber`] trait in `tracing-core` represents the _complete_ set of//! functionality required to consume `tracing` instrumentation. This means that//! a single `Subscriber` instance is a self-contained implementation of a//! complete strategy for collecting traces; but it _also_ means that the//! `Subscriber` trait cannot easily be composed with other `Subscriber`s.//! In particular, [`Subscriber`]s are responsible for generating [span IDs] and//! assigning them to spans. Since these IDs must uniquely identify a span//! within the context of the current trace, this means that there may only be//! a single `Subscriber` for a given thread at any point in time &mdash;//! otherwise, there would be no authoritative source of span IDs.//! On the other hand, the majority of the [`Subscriber`] trait's functionality//! is composable: any number of subscribers may _observe_ events, span entry//! and exit, and so on, provided that there is a single authoritative source of//! span IDs. The [`Layer`] trait represents this composable subset of the//! [`Subscriber`] behavior; it can _observe_ events and spans, but does not//! assign IDs.//! # Composing Layers//! Since a [`Layer`] does not implement a complete strategy for collecting//! traces, it must be composed with a `Subscriber` in order to be used. The//! [`Layer`] trait is generic over a type parameter (called `S` in the trait//! definition), representing the types of `Subscriber` they can be composed//! with. Thus, a [`Layer`] may be implemented that will only compose with a//! particular `Subscriber` implementation, or additional trait bounds may be//! added to constrain what types implementing `Subscriber` a `Layer` can wrap.//! `Layer`s may be added to a `Subscriber` by using the [`SubscriberExt::with`]//! method, which is provided by `tracing-subscriber`'s [prelude]. This method//! returns a [`Layered`] struct that implements `Subscriber` by composing the//! `Layer` with the `Subscriber`.//! use tracing_subscriber::Layer;//! use tracing::Subscriber;//! pub struct MyLayer {//! impl<S: Subscriber> Layer<S> for MyLayer {//! pub struct MySubscriber {//! # use tracing_core::{span::{Id, Attributes, Record}, Metadata, Event};//! impl Subscriber for MySubscriber {//! #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(1) }//! # impl MyLayer {//! # fn new() -> Self { Self {} }//! # impl MySubscriber {//! # fn new() -> Self { Self { }}//! let subscriber = MySubscriber::new()//!     .with(MyLayer::new());//! tracing::subscriber::set_global_default(subscriber);//! Multiple `Layer`s may be composed in the same manner://! # use tracing_subscriber::{Layer, layer::SubscriberExt};//! # use tracing::Subscriber;//! pub struct MyOtherLayer {//! impl<S: Subscriber> Layer<S> for MyOtherLayer {//! pub struct MyThirdLayer {//! impl<S: Subscriber> Layer<S> for MyThirdLayer {//! # pub struct MyLayer {}//! # impl<S: Subscriber> Layer<S> for MyLayer {}//! # pub struct MySubscriber { }//! # impl Subscriber for MySubscriber {//! # impl MyOtherLayer {//! # impl MyThirdLayer {//!     .with(MyLayer::new())//!     .with(MyOtherLayer::new())//!     .with(MyThirdLayer::new());//! The [`Layer::with_subscriber`] constructs the [`Layered`] type from a//! [`Layer`] and [`Subscriber`], and is called by [`SubscriberExt::with`]. In//! general, it is more idiomatic to use [`SubscriberExt::with`], and treat//! [`Layer::with_subscriber`] as an implementation detail, as `with_subscriber`//! calls must be nested, leading to less clear code for the reader.//! ## Runtime Configuration With `Layer`s//! In some cases, a particular [`Layer`] may be enabled or disabled based on//! runtime configuration. This can introduce challenges, because the type of a//! layered [`Subscriber`] depends on which layers are added to it: if an `if`//! or `match` expression adds some [`Layer`] implementation in one branch,//! and other layers in another, the [`Subscriber`] values returned by those//! branches will have different types. For example, the following _will not_//! work://! # fn docs() -> Result<(), Box<dyn std::error::Error + 'static>> {//! # struct Config {//! #    is_prod: bool,//! #    path: &'static str,//! # let cfg = Config { is_prod: false, path: "debug.log" };//! use tracing_subscriber::{Registry, prelude::*};//! let stdout_log = tracing_subscriber::fmt::layer().pretty();//! let subscriber = Registry::default().with(stdout_log);//! // The compile error will occur here because the if and else//! // branches have different (and therefore incompatible) types.//! let subscriber = if cfg.is_prod {//!     let file = File::create(cfg.path)?;//!     let layer = tracing_subscriber::fmt::layer()//!         .json()//!         .with_writer(Arc::new(file));//!     layer.with(subscriber)//!     layer//!     .expect("Unable to set global subscriber");//! However, a [`Layer`] wrapped in an [`Option`] [also implements the `Layer`//! trait][option-impl]. This allows individual layers to be enabled or disabled at//! runtime while always producing a [`Subscriber`] of the same type. For//! // if `cfg.is_prod` is true, also log JSON-formatted logs to a file.//! let json_log = if cfg.is_prod {//!     let json_log = tracing_subscriber::fmt::layer()//!         .with_writer(file);//!     Some(json_log)//!     None//! // If `cfg.is_prod` is false, then `json` will be `None`, and this layer//! // will do nothing. However, the subscriber will still have the same type//! // regardless of whether the `Option`'s value is `None` or `Some`.//! let subscriber = subscriber.with(json_log);//!    .expect("Unable to set global subscriber");//! If a [`Layer`] may be one of several different types, note that [`Box<dyn//! Layer<S> + Send + Sync>` implements `Layer`][box-impl].//! This may be used to erase the type of a [`Layer`].//! For example, a function that configures a [`Layer`] to log to one of//! several outputs might return a `Box<dyn Layer<S> + Send + Sync + 'static>`://! use tracing_subscriber::{//!     Layer,//!     registry::LookupSpan,//!     prelude::*,//! use std::{path::PathBuf, fs::File, io};//! /// Configures whether logs are emitted to a file, to stdout, or to stderr.//! pub enum LogConfig {//!     File(PathBuf),//!     Stdout,//!     Stderr,//! impl LogConfig {//!     pub fn layer<S>(self) -> Box<dyn Layer<S> + Send + Sync + 'static>//!         S: tracing_core::Subscriber,//!         for<'a> S: LookupSpan<'a>,//!         // Shared configuration regardless of where logs are output to.//!         let fmt = tracing_subscriber::fmt::layer()//!             .with_target(true)//!             .with_thread_names(true);//!         // Configure the writer based on the desired log target://!         match self {//!             LogConfig::File(path) => {//!                 let file = File::create(path).expect("failed to create log file");//!                 Box::new(fmt.with_writer(file))//!             LogConfig::Stdout => Box::new(fmt.with_writer(io::stdout)),//!             LogConfig::Stderr => Box::new(fmt.with_writer(io::stderr)),//! let config = LogConfig::Stdout;//!     .with(config.layer())//! The [`Layer::boxed`] method is provided to make boxing a `Layer`//! more convenient, but [`Box::new`] may be used as well.//! When the number of `Layer`s varies at runtime, note that a//! [`Vec<L> where L: Layer` also implements `Layer`][vec-impl]. This//! can be used to add a variable number of `Layer`s to a `Subscriber`://! use tracing_subscriber::{Layer, prelude::*};//! struct MyLayer {//! # impl MyLayer { fn new() -> Self { Self {} }}//! impl<S: tracing_core::Subscriber> Layer<S> for MyLayer {//! /// Returns how many layers we need//! fn how_many_layers() -> usize {//!     # 3//! // Create a variable-length `Vec` of layers//! let mut layers = Vec::new();//! for _ in 0..how_many_layers() {//!     layers.push(MyLayer::new());//!     .with(layers)//! If a variable number of `Layer` is needed and those `Layer`s have//! different types, a `Vec` of [boxed `Layer` trait objects][box-impl] may//! be used. For example://! use tracing_subscriber::{filter::LevelFilter, Layer, prelude::*};//!     enable_log_file: bool,//!     enable_stdout: bool,//!     enable_stderr: bool,//! # impl Config {//! #    fn from_config_file()-> Result<Self, Box<dyn std::error::Error>> {//! #         // don't enable the log file so that the example doesn't actually create it//! #         Ok(Self { enable_log_file: false, enable_stdout: true, enable_stderr: true })//! #    }//! let cfg = Config::from_config_file()?;//! // Based on our dynamically loaded config file, create any number of layers://! if cfg.enable_log_file {//!     let file = File::create("myapp.log")?;//!         .with_thread_names(true)//!         .with_target(true)//!         .with_writer(file)//!         // Box the layer as a type-erased trait object, so that it can//!         // be pushed to the `Vec`.//!         .boxed();//!     layers.push(layer);//! if cfg.enable_stdout {//!         .pretty()//!         .with_filter(LevelFilter::INFO)//!         .with_target(false)//!         .with_filter(LevelFilter::WARN)//!# Ok(()) }//! Finally, if the number of layers _changes_ at runtime, a `Vec` of//! subscribers can be used alongside the [`reload`](crate::reload) module to//! add or remove subscribers dynamically at runtime.//! [option-impl]: Layer#impl-Layer<S>-for-Option<L>//! [box-impl]: Layer#impl-Layer%3CS%3E-for-Box%3Cdyn%20Layer%3CS%3E%20+%20Send%20+%20Sync%3E//! [vec-impl]: Layer#impl-Layer<S>-for-Vec<L>//! [prelude]: crate::prelude//! # Recording Traces//! The [`Layer`] trait defines a set of methods for consuming notifications from//! tracing instrumentation, which are generally equivalent to the similarly//! named methods on [`Subscriber`]. Unlike [`Subscriber`], the methods on//! `Layer` are additionally passed a [`Context`] type, which exposes additional//! information provided by the wrapped subscriber (such as [the current span])//! to the layer.//! # Filtering with `Layer`s//! As well as strategies for handling trace events, the `Layer` trait may also//! be used to represent composable _filters_. This allows the determination of//! what spans and events should be recorded to be decoupled from _how_ they are//! recorded: a filtering layer can be applied to other layers or//! subscribers. `Layer`s can be used to implement _global filtering_, where a//! `Layer` provides a filtering strategy for the entire subscriber.//! Additionally, individual recording `Layer`s or sets of `Layer`s may be//! combined with _per-layer filters_ that control what spans and events are//! recorded by those layers.//! ## Global Filtering//! A `Layer` that implements a filtering strategy should override the//! [`register_callsite`] and/or [`enabled`] methods. It may also choose to implement//! methods such as [`on_enter`], if it wishes to filter trace events based on//! the current span context.//! Note that the [`Layer::register_callsite`] and [`Layer::enabled`] methods//! determine whether a span or event is enabled *globally*. Thus, they should//! **not** be used to indicate whether an individual layer wishes to record a//! particular span or event. Instead, if a layer is only interested in a subset//! of trace data, but does *not* wish to disable other spans and events for the//! rest of the layer stack should ignore those spans and events in its//! notification methods.//! The filtering methods on a stack of `Layer`s are evaluated in a top-down//! order, starting with the outermost `Layer` and ending with the wrapped//! [`Subscriber`]. If any layer returns `false` from its [`enabled`] method, or//! [`Interest::never()`] from its [`register_callsite`] method, filter//! evaluation will short-circuit and the span or event will be disabled.//! ### Enabling Interest//! Whenever an tracing event (or span) is emitted, it goes through a number of//! steps to determine how and how much it should be processed. The earlier an//! event is disabled, the less work has to be done to process the event, so//! `Layer`s that implement filtering should attempt to disable unwanted//! events as early as possible. In order, each event checks://! - [`register_callsite`], once per callsite (roughly: once per time that//!   `event!` or `span!` is written in the source code; this is cached at the//!   callsite). See [`Subscriber::register_callsite`] and//!   [`tracing_core::callsite`] for a summary of how this behaves.//! - [`enabled`], once per emitted event (roughly: once per time that `event!`//!   or `span!` is *executed*), and only if `register_callsite` registers an//!   [`Interest::sometimes`]. This is the main customization point to globally//!   filter events based on their [`Metadata`]. If an event can be disabled//!   based only on [`Metadata`], it should be, as this allows the construction//!   of the actual `Event`/`Span` to be skipped.//! - For events only (and not spans), [`event_enabled`] is called just before//!   processing the event. This gives layers one last chance to say that//!   an event should be filtered out, now that the event's fields are known.//! **Note**: per-layer filtering APIs currently require the [`"registry"` crate//! feature flag][feat] to be enabled.//! Sometimes, it may be desirable for one `Layer` to record a particular subset//! of spans and events, while a different subset of spans and events are//! recorded by other `Layer`s. For example://! - A layer that records metrics may wish to observe only events including//!   particular tracked values, while a logging layer ignores those events.//! - If recording a distributed trace is expensive, it might be desirable to//!   only send spans with `INFO` and lower verbosity to the distributed tracing//!   system, while logging more verbose spans to a file.//! - Spans and events with a particular target might be recorded differently//!   from others, such as by generating an HTTP access log from a span that//!   tracks the lifetime of an HTTP request.//! The [`Filter`] trait is used to control what spans and events are//! observed by an individual `Layer`, while still allowing other `Layer`s to//! potentially record them. The [`Layer::with_filter`] method combines a//! `Layer` with a [`Filter`], returning a [`Filtered`] layer.//! This crate's [`filter`] module provides a number of types which implement//! the [`Filter`] trait, such as [`LevelFilter`], [`Targets`], and//! [`FilterFn`]. These [`Filter`]s provide ready-made implementations of//! common forms of filtering. For custom filtering policies, the [`FilterFn`]//! and [`DynFilterFn`] types allow implementing a [`Filter`] with a closure or//! function pointer. In addition, when more control is required, the [`Filter`]//! trait may also be implemented for user-defined types.//! //! [`Option<Filter>`] also implements [`Filter`], which allows for an optional//! filter. [`None`](Option::None) filters out _nothing_ (that is, allows//! everything through). For example://! # use tracing_subscriber::{filter::filter_fn, Layer};//! # use tracing_core::{Metadata, subscriber::Subscriber};//! # struct MyLayer<S>(std::marker::PhantomData<S>);//! # impl<S> MyLayer<S> { fn new() -> Self { Self(std::marker::PhantomData)} }//! # impl<S: Subscriber> Layer<S> for MyLayer<S> {}//! # fn my_filter(_: &str) -> impl Fn(&Metadata) -> bool { |_| true  }//! fn setup_tracing<S: Subscriber>(filter_config: Option<&str>) {//!     let layer = MyLayer::<S>::new()//!         .with_filter(filter_config.map(|config| filter_fn(my_filter(config))));//!     <strong>Warning</strong>: Currently, the <a href="../struct.Registry.html">//!     <code>Registry</code></a> type defined in this crate is the only root//!     <code>Subscriber</code> capable of supporting <code>Layer</code>s with//!     per-layer filters. In the future, new APIs will be added to allow other//!     root <code>Subscriber</code>s to support per-layer filters.//! For example, to generate an HTTP access log based on spans with//! the `http_access` target, while logging other spans and events to//! standard out, a [`Filter`] can be added to the access log layer://! use tracing_subscriber::{filter, prelude::*};//! // Generates an HTTP access log.//! let access_log = // ...//!     # filter::LevelFilter::INFO;//! // Add a filter to the access log layer so that it only observes//! // spans and events with the `http_access` target.//! let access_log = access_log.with_filter(filter::filter_fn(|metadata| {//!     // Returns `true` if and only if the span or event's target is//!     // "http_access".//!     metadata.target() == "http_access"//! // A general-purpose logging layer.//! let fmt_layer = tracing_subscriber::fmt::layer();//! // Build a subscriber that combines the access log and stdout log//! // layers.//!     .with(access_log)//! Multiple layers can have their own, separate per-layer filters. A span or//! event will be recorded if it is enabled by _any_ per-layer filter, but it//! will be skipped by the layers whose filters did not enable it. Building on//! the previous example://! use tracing_subscriber::{filter::{filter_fn, LevelFilter}, prelude::*};//!     # LevelFilter::INFO;//!     // Add the filter for the "http_access" target to the access//!     // log layer, like before.//!     .with(access_log.with_filter(filter_fn(|metadata| {//!         metadata.target() == "http_access"//!     })))//!     // Add a filter for spans and events with the INFO level//!     // and below to the logging layer.//!     .with(fmt_layer.with_filter(LevelFilter::INFO))//! // Neither layer will observe this event//! tracing::debug!(does_anyone_care = false, "a tree fell in the forest");//! // This event will be observed by the logging layer, but not//! // by the access log layer.//! tracing::warn!(dose_roentgen = %3.8, "not great, but not terrible");//! // This event will be observed only by the access log layer.//! tracing::trace!(target: "http_access", "HTTP request started");//! // Both layers will observe this event.//! tracing::error!(target: "http_access", "HTTP request failed with a very bad error!");//! A per-layer filter can be applied to multiple [`Layer`]s at a time, by//! combining them into a [`Layered`] layer using [`Layer::and_then`], and then//! calling [`Layer::with_filter`] on the resulting [`Layered`] layer.//! Consider the following://! - `layer_a` and `layer_b`, which should only receive spans and events at//!   the [`INFO`] [level] and above.//! - A third layer, `layer_c`, which should receive spans and events at//!   the [`DEBUG`] [level] as well.//! The layers and filters would be composed thusly://! use tracing_subscriber::{filter::LevelFilter, prelude::*};//! let layer_a = // ...//! # LevelFilter::INFO;//! let layer_b =  // ...//! let layer_c =  // ...//! let info_layers = layer_a//!     // Combine `layer_a` and `layer_b` into a `Layered` layer://!     .and_then(layer_b)//!     // ...and then add an `INFO` `LevelFilter` to that layer://!     .with_filter(LevelFilter::INFO);//!     // Add `layer_c` with a `DEBUG` filter.//!     .with(layer_c.with_filter(LevelFilter::DEBUG))//!     .with(info_layers)//! If a [`Filtered`] [`Layer`] is combined with another [`Layer`]//! [`Layer::and_then`], and a filter is added to the [`Layered`] layer, that//! layer will be filtered by *both* the inner filter and the outer filter.//! Only spans and events that are enabled by *both* filters will be//! observed by that layer. This can be used to implement complex filtering//! trees.//! As an example, consider the following constraints://! - Suppose that a particular [target] is used to indicate events that//!   should be counted as part of a metrics system, which should be only//!   observed by a layer that collects metrics.//! - A log of high-priority events ([`INFO`] and above) should be logged//!   to stdout, while more verbose events should be logged to a debugging log file.//! - Metrics-focused events should *not* be included in either log output.//! In that case, it is possible to apply a filter to both logging layers to//! exclude the metrics events, while additionally adding a [`LevelFilter`]//! to the stdout log://! # // wrap this in a function so we don't actually create `debug.log` when//! # // running the doctests..//! use std::{fs::File, sync::Arc};//! // A layer that logs events to stdout using the human-readable "pretty"//! // format.//! let stdout_log = tracing_subscriber::fmt::layer()//!     .pretty();//! // A layer that logs events to a file.//! let file = File::create("debug.log")?;//! let debug_log = tracing_subscriber::fmt::layer()//!     .with_writer(Arc::new(file));//! // A layer that collects metrics using specific events.//! let metrics_layer = /* ... */ filter::LevelFilter::INFO;//!     .with(//!         stdout_log//!             // Add an `INFO` filter to the stdout logging layer//!             .with_filter(filter::LevelFilter::INFO)//!             // Combine the filtered `stdout_log` layer with the//!             // `debug_log` layer, producing a new `Layered` layer.//!             .and_then(debug_log)//!             // Add a filter to *both* layers that rejects spans and//!             // events whose targets start with `metrics`.//!             .with_filter(filter::filter_fn(|metadata| {//!                 !metadata.target().starts_with("metrics")//!             }))//!         // Add a filter to the metrics label that *only* enables//!         // events whose targets start with `metrics`.//!         metrics_layer.with_filter(filter::filter_fn(|metadata| {//!             metadata.target().starts_with("metrics")//!         }))//! // This event will *only* be recorded by the metrics layer.//! tracing::info!(target: "metrics::cool_stuff_count", value = 42);//! // This event will only be seen by the debug log file layer://! tracing::debug!("this is a message, and part of a system of messages");//! // This event will be seen by both the stdout log layer *and*//! // the debug log file layer, but not by the metrics layer.//! tracing::warn!("the message is a warning about danger!");//! [`Subscriber`]: tracing_core::subscriber::Subscriber//! [span IDs]: tracing_core::span::Id//! [the current span]: Context::current_span//! [`register_callsite`]: Layer::register_callsite//! [`enabled`]: Layer::enabled//! [`event_enabled`]: Layer::event_enabled//! [`on_enter`]: Layer::on_enter//! [`Layer::register_callsite`]: Layer::register_callsite//! [`Layer::enabled`]: Layer::enabled//! [`Interest::never()`]: tracing_core::subscriber::Interest::never()//! [`Filtered`]: crate::filter::Filtered//! [`filter`]: crate::filter//! [`Targets`]: crate::filter::Targets//! [`FilterFn`]: crate::filter::FilterFn//! [`DynFilterFn`]: crate::filter::DynFilterFn//! [`INFO`]: tracing_core::Level::INFO//! [`DEBUG`]: tracing_core::Level::DEBUG//! [`LevelFilter`]: crate::filter::LevelFilter//! [feat]: crate#feature-flags// === impl Layer ===// === impl SubscriberExt ===// === impl Identity ===NopLayerNopLayer2StringLayer/// A layer that holds a string./// Used to test that pointers returned by downcasting are actually valid.StringLayer2StringLayer3StringSubscriberassert_subscriberassert_layerlayer_is_subscribertwo_layers_are_subscriberthree_layers_are_subscriberthree_layers_are_layerbox_layer_is_layerdowncasts_to_subscriberdowncasts_to_layercontext_event_spanmixed_with_unfilteredmixed_with_unfiltered_layeredmixed_interleavedmixed_layeredplf_only_unhintedplf_only_unhinted_nested_outerplf_only_unhinted_nested_innerunhinted_nested_innerunhinted_nested_inner_mixedplf_only_picks_maxmany_plf_only_picks_maxnested_plf_only_picks_maxmax_level_hints/// Tests for how max-level hints are calculated when combining layers/// with and without per-layer filtering.registry_tests// Allows displaying cfgs/feature flags in the documentation.// Allows adding traits to RustDoc's list of "notable traits"// Fail the docs build if any intra-docs links are brokenr" Returns a default [`Registry`]."//! Utilities for implementing and composing [`tracing`] subscribers.//! scoped, structured, and async-aware diagnostics. The [`Subscriber`] trait//! represents the functionality necessary to collect this trace data. This//! crate contains tools for composing subscribers out of smaller units of//! behaviour, and batteries-included implementations of common subscriber//! `tracing-subscriber` is intended for use by both `Subscriber` authors and//! application authors using `tracing` to instrument their applications.//! ## `Layer`s and `Filter`s//! The most important component of the `tracing-subscriber` API is the//! [`Layer`] trait, which provides a composable abstraction for building//! [`Subscriber`]s. Like the [`Subscriber`] trait, a [`Layer`] defines a//! particular behavior for collecting trace data. Unlike [`Subscriber`]s,//! which implement a *complete* strategy for how trace data is collected,//! [`Layer`]s provide *modular* implementations of specific behaviors.//! Therefore, they can be [composed together] to form a [`Subscriber`] which is//! capable of recording traces in a variety of ways. See the [`layer` module's//! documentation][layer] for details on using [`Layer`]s.//! In addition, the [`Filter`] trait defines an interface for filtering what//! spans and events are recorded by a particular layer. This allows different//! [`Layer`]s to handle separate subsets of the trace data emitted by a//! program. See the [documentation on per-layer filtering][plf] for more//! information on using [`Filter`]s.//! [`Layer`]: crate::layer::Layer//! [composed together]: crate::layer#composing-layers//! [layer]: crate::layer//! [plf]: crate::layer#per-layer-filtering//! ## Included Subscribers//! The following `Subscriber`s are provided for application authors://! - [`fmt`] - Formats and logs tracing data (requires the `fmt` feature flag)//! - `std`: Enables APIs that depend on the Rust standard library//!   (enabled by default).//! - `alloc`: Depend on [`liballoc`] (enabled by "std").//! - `env-filter`: Enables the [`EnvFilter`] type, which implements filtering//!   similar to the [`env_logger` crate]. **Requires "std"**.//! - `fmt`: Enables the [`fmt`] module, which provides a subscriber//!   implementation for printing formatted representations of trace events.//!   Enabled by default. **Requires "registry" and "std"**.//! - `ansi`: Enables `fmt` support for ANSI terminal colors. Enabled by//!   default.//! - `registry`: enables the [`registry`] module. Enabled by default.//!   **Requires "std"**.//! - `json`: Enables `fmt` support for JSON output. In JSON output, the ANSI//!   feature does nothing. **Requires "fmt" and "std"**.//! - `local-time`: Enables local time formatting when using the [`time`//!   crate]'s timestamp formatters with the `fmt` subscriber.//! [`registry`]: mod@registry//! ### Optional Dependencies//! - [`tracing-log`]: Enables better formatting for events emitted by `log`//!   macros in the `fmt` subscriber. Enabled by default.//! - [`time`][`time` crate]: Enables support for using the [`time` crate] for timestamp//!   formatting in the `fmt` subscriber.//! - [`smallvec`]: Causes the `EnvFilter` type to use the `smallvec` crate (rather//!   than `Vec`) as a performance optimization. Enabled by default.//! - [`parking_lot`]: Use the `parking_lot` crate's `RwLock` implementation//!   rather than the Rust standard library's implementation.//! ### `no_std` Support//! In embedded systems and other bare-metal applications, `tracing` can be//! used without requiring the Rust standard library, although some features are//! disabled. Although most of the APIs provided by `tracing-subscriber`, such//! as [`fmt`] and [`EnvFilter`], require the standard library, some//! functionality, such as the [`Layer`] trait, can still be used in//! `no_std` environments.//! The dependency on the standard library is controlled by two crate feature//! flags, "std", which enables the dependency on [`libstd`], and "alloc", which//! enables the dependency on [`liballoc`] (and is enabled by the "std"//! feature). These features are enabled by default, but `no_std` users can//! disable them using://! # Cargo.toml//! tracing-subscriber = { version = "0.3", default-features = false }//! Additional APIs are available when [`liballoc`] is available. To enable//! `liballoc` but not `std`, use://! tracing-subscriber = { version = "0.3", default-features = false, features = ["alloc"] }//! * `valuable`: Enables support for serializing values recorded using the//!   [`valuable`] crate as structured JSON in the [`format::Json`] formatter.//! [`format::Json`]: crate::fmt::format::Json//! [`tracing`]: https://docs.rs/tracing/latest/tracing//! [`EnvFilter`]: filter::EnvFilter//! [`fmt`]: mod@fmt//! [`smallvec`]: https://crates.io/crates/smallvec//! [`env_logger` crate]: https://crates.io/crates/env_logger//! [`parking_lot`]: https://crates.io/crates/parking_lot//! [`time` crate]: https://crates.io/crates/time//! [`liballoc`]: https://doc.rust-lang.org/alloc/index.html//! [`libstd`]: https://doc.rust-lang.org/std/index.html// Using struct update syntax when a struct has no additional fields avoids// a potential source change if additional fields are added to the struct in the// future, reducing diff noise. Allow this even though clippy considers it// "needless".__tracing_subscriber_field_MakeExt__tracing_subscriber_field_RecordFields__tracing_subscriber_Layer__tracing_subscriber_SubscriberExt//! The `tracing-subscriber` prelude.//! This brings into scope a number of extension traits that define methods on//! types defined here and in other crates./// With TypeIds as keys, there's no need to hash them. They are already hashes/// themselves, coming from the compiler. The IdHasher holds the u64 of/// the TypeId, and then returns it, instead of doing any bit fiddling.ExtensionsInner/// An immutable, read-only reference to a Span's extensions./// Immutably borrows a type previously inserted into this `Extensions`.ExtensionsMut/// An mutable reference to a Span's extensions./// Note that extensions are _not_/// `Layer`-specific—they are _span_-specific. This means that/// other layers can access and mutate extensions that/// a different Layer recorded. For example, an application might/// have a layer that records execution timings, alongside a layer/// that reports spans and events to a distributed/// tracing system that requires timestamps for spans./// Ideally, if one layer records a timestamp _x_, the other layer/// should be able to reuse timestamp _x_./// Therefore, extensions should generally be newtypes, rather than common/// types like [`String`](std::string::String), to avoid accidental/// cross-`Layer` clobbering./// If `T` is already present in `Extensions`, then this method will panic./// Replaces an existing `T` into this extensions./// If `T` is not present, `Option::None` will be returned./// Get a mutable reference to a type previously inserted on this `ExtensionsMut`./// A type map of span extensions./// [ExtensionsInner] is used by `SpanData` to store and/// span-specific data. A given `Layer` can read and write/// data that it is interested in recording and emitting./// Clear the `ExtensionsInner` in-place, dropping any elements in the map but/// retaining allocated capacity./// This permits the hash map allocation to be pooled by the registry so/// that future spans will not need to allocate new hashmaps.MyTypeclear_retains_capacityclear_drops_elements// taken from https://github.com/hyperium/http/blob/master/src/extensions.rs.r" A module containing a type map of span extensions."shardedSpanData/// The type of span data stored in this registry./// Returns the [`SpanData`] for a given `Id`, if it exists./// <strong>Note</strong>: users of the <code>LookupSpan</code> trait should/// typically call the <a href="#method.span"><code>span</code></a> method rather/// than this method. The <code>span</code> method is implemented by/// <em>calling</em> <code>span_data</code>, but returns a reference which is/// capable of performing more sophisiticated queries./// Returns a [`SpanRef`] for the span with the given `Id`, if it exists./// A `SpanRef` is similar to [`SpanData`], but it allows performing/// additional lookups against the registryr that stores the wrapped data./// In general, _users_ of the `LookupSpan` trait should use this method/// rather than the [`span_data`] method; while _implementors_ of this trait/// should only implement `span_data`./// [`span_data`]: LookupSpan::span_data()/// Registers a [`Filter`] for [per-layer filtering] with this/// The [`Filter`] can then use the returned [`FilterId`] to/// [check if it previously enabled a span][check]./// If this `Subscriber` does not support [per-layer filtering]./// [per-layer filtering]: crate::layer::Layer#per-layer-filtering/// [check]: SpanData::is_enabled_for/// Provides access to stored span data./// Subscribers which store span data and associate it with span IDs should/// implement this trait; if they do, any [`Layer`]s wrapping them can look up/// metadata via the [`Context`] type's [`span()`] method./// [`Context`]: super::layer::Context/// [`span()`]: super::layer::Context::span/// Returns this span's ID./// Returns a reference to the span's `Metadata`./// Returns a reference to the ID/// Returns a reference to this span's `Extensions`./// The extensions may be used by `Layer`s to store additional data/// describing the span./// Returns a mutable reference to this span's `Extensions`./// Returns `true` if this span is enabled for the [per-layer filter][plf]/// corresponding to the provided [`FilterId`]./// ## Default Implementation/// By default, this method assumes that the [`LookupSpan`] implementation/// does not support [per-layer filtering][plf], and always returns `true`./// [plf]: crate::layer::Layer#per-layer-filtering/// A stored representation of data associated with a span./// A reference to [span data] and the associated [registry]./// This type implements all the same methods as [`SpanData`], and provides/// additional methods for querying the registry based on values from the span./// [registry]: LookupSpan/// An iterator over the parents of a span, ordered from leaf to root./// This is returned by the [`SpanRef::scope`] method.r" An iterator over the parents of a span, ordered from root to leaf."r" This is returned by the [`Scope::from_root`] method."SpanRefVecArrayScopeFromRootr" Flips the order of the iterator, so that it is ordered from root to leaf."r" The iterator will first return the root span, then that span's immediate child,"r" and so on until it finally returns the span that [`SpanRef::scope`] was called on."r" If any items were consumed from the [`Scope`] before calling this method then they"r" will *not* be returned from the [`ScopeFromRoot`]."r" **Note**: this will allocate if there are many spans remaining, or if the"r#" "smallvec" feature flag is not enabled."#from_root/// Returns a static reference to the span's metadata./// Returns the span's name,/// Returns a list of [fields] defined by the span./// Returns a `SpanRef` describing this span's parent, or `None` if this/// span is the root of its trace tree./// Returns an iterator over all parents of this span, starting with this span,/// ordered from leaf to root./// The iterator will first return the span, then the span's immediate parent,/// followed by that span's parent, and so on, until it reaches a root span./// use tracing::{span, Subscriber};///     fn on_enter(&self, id: &span::Id, ctx: Context<S>) {///         let span = ctx.span(id).unwrap();///         let scope = span.scope().map(|span| span.name()).collect::<Vec<_>>();///         println!("Entering span: {:?}", scope);///     let _root = tracing::info_span!("root").entered();///     // Prints: Entering span: ["root"]///     let _child = tracing::info_span!("child").entered();///     // Prints: Entering span: ["child", "root"]///     let _leaf = tracing::info_span!("leaf").entered();///     // Prints: Entering span: ["leaf", "child", "root"]/// If the opposite order (from the root to this span) is desired, calling [`Scope::from_root`] on/// the returned iterator reverses the order./// # use tracing::{span, Subscriber};/// # use tracing_subscriber::{/// #     layer::{Context, Layer},/// #     prelude::*,/// #     registry::LookupSpan,/// # struct PrintingLayer;///         let scope = span.scope().from_root().map(|span| span.name()).collect::<Vec<_>>();///     // Prints: Entering span: ["root", "child"]///     // Prints: Entering span: ["root", "child", "leaf"]try_with_filterspanref_scope_iteration_orderspanref_scope_fromroot_iteration_order//! Storage for span data shared by multiple [`Layer`]s.//! ## Using the Span Registry//! This module provides the [`Registry`] type, a [`Subscriber`] implementation//! which tracks per-span data and exposes it to [`Layer`]s. When a `Registry`//! is used as the base `Subscriber` of a `Layer` stack, the//! [`layer::Context`][ctx] type will provide methods allowing `Layer`s to//! [look up span data][lookup] stored in the registry. While [`Registry`] is a//! reasonable default for storing spans and events, other stores that implement//! [`LookupSpan`] and [`Subscriber`] themselves (with [`SpanData`] implemented//! by the per-span data they store) can be used as a drop-in replacement.//! For example, we might create a `Registry` and add multiple `Layer`s like so://! use tracing_subscriber::{registry::Registry, Layer, prelude::*};//! # use tracing_core::Subscriber;//! # pub struct FooLayer {}//! # pub struct BarLayer {}//! # impl<S: Subscriber> Layer<S> for FooLayer {}//! # impl<S: Subscriber> Layer<S> for BarLayer {}//! # impl FooLayer {//! # impl BarLayer {//! let subscriber = Registry::default()//!     .with(FooLayer::new())//!     .with(BarLayer::new());//! If a type implementing `Layer` depends on the functionality of a `Registry`//! implementation, it should bound its `Subscriber` type parameter with the//! [`LookupSpan`] trait, like so://! use tracing_subscriber::{registry, Layer};//! use tracing_core::Subscriber;//! impl<S> Layer<S> for MyLayer//!     S: Subscriber + for<'a> registry::LookupSpan<'a>,//! When this bound is added, the `Layer` implementation will be guaranteed//! access to the [`Context`][ctx] methods, such as [`Context::span`][lookup], that//! require the root subscriber to be a registry.//! [`Subscriber`]: tracing_core::Subscriber//! [ctx]: crate::layer::Context//! [lookup]: crate::layer::Context::span()SpanStackDataInnercurrent_spansnext_filter_id/// A shared, reusable store for spans./// A `Registry` is a [`Subscriber`] around which multiple [`Layer`]s/// implementing various behaviors may be [added]. Unlike other types/// implementing `Subscriber`, `Registry` does not actually record traces itself:/// instead, it collects and stores span data that is exposed to any [`Layer`]s/// wrapping it through implementations of the [`LookupSpan`] trait./// The `Registry` is responsible for storing span metadata, recording/// relationships between spans, and tracking which spans are active and which/// are closed. In addition, it provides a mechanism for [`Layer`]s to store/// user-defined per-span data, called [extensions], in the registry. This/// allows [`Layer`]-specific data to benefit from the `Registry`'s/// high-performance concurrent storage./// This registry is implemented using a [lock-free sharded slab][slab], and is/// highly optimized for concurrent access./// # Span ID Generation/// Span IDs are not globally unique, but the registry ensures that/// no two currently active spans have the same ID within a process./// One of the primary responsibilities of the registry is to generate [span/// IDs]. Therefore, it's important for other code that interacts with the/// registry, such as [`Layer`]s, to understand the guarantees of the/// span IDs that are generated./// The registry's span IDs are guaranteed to be unique **at a given point/// in time**. This means that an active span will never be assigned the/// same ID as another **currently active** span. However, the registry/// **will** eventually reuse the IDs of [closed] spans, although an ID/// will never be reassigned immediately after a span has closed./// Spans are not [considered closed] by the `Registry` until *every*/// [`Span`] reference with that ID has been dropped./// Thus: span IDs generated by the registry should be considered unique/// only at a given point in time, and only relative to other spans/// generated by the same process. Two spans with the same ID will not exist/// in the same process concurrently. However, if historical span data is/// being stored, the same ID may occur for multiple spans times in that/// data. If spans must be uniquely identified in historical data, the user/// code storing this data must assign its own unique identifiers to those/// spans. A counter is generally sufficient for this./// Similarly, span IDs generated by the registry are not unique outside of/// a given process. Distributed tracing systems may require identifiers/// that are unique across multiple processes on multiple machines (for/// example, [OpenTelemetry's `SpanId`s and `TraceId`s][ot]). `tracing` span/// IDs generated by the registry should **not** be used for this purpose./// Instead, code which integrates with a distributed tracing system should/// generate and propagate its own IDs according to the rules specified by/// the distributed tracing system. These IDs can be associated with/// `tracing` spans using [fields] and/or [stored span data]./// [span IDs]: tracing_core::span::Id/// [slab]: sharded_slab/// [added]: crate::layer::Layer#composing-layers/// [extensions]: super::Extensions/// [closed]: https://docs.rs/tracing/latest/tracing/span/index.html#closing-spans/// [considered closed]: tracing_core::subscriber::Subscriber::try_close()/// [`Span`]: https://docs.rs/tracing/latest/tracing/span/struct.Span.html/// [ot]: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#spancontext/// [stored span data]: crate::registry::SpanData::extensions_mut/// Immutable reference to the pooled `DataInner` entry./// Span data stored in a [`Registry`]./// The registry stores well-known data defined by tracing: span relationships,/// metadata and reference counts. Additional user-defined data provided by/// [`Layer`s], such as formatted fields, metrics, or distributed traces should/// be stored in the [extensions] typemap./// [`Layer`s]: crate::layer::Layer/// [extensions]: Extensions// The span's `Extensions` typemap. Allocations for the `HashMap` backing// this are pooled and reused in place./// Stored data associated with a span./// This type is pooled using [`sharded_slab::Pool`]; when a span is/// dropped, the `DataInner` entry at that span's slab index is cleared/// in place and reused by a future span. Thus, the `Default` and/// [`sharded_slab::Clear`] implementations for this type are/// load-bearing.idx_to_idid_to_idxCloseGuard/// A guard that tracks how many [`Registry`]-backed `Layer`s have/// processed an `on_close` event./// This is needed to enable a [`Registry`]-backed Layer to access span/// data after the `Layer` has recieved the `on_close` callback./// Once all `Layer`s have processed this event, the [`Registry`] knows/// that is able to safely remove the span tracked by `id`. `CloseGuard`/// accomplishes this through a two-step process:/// 1. Whenever a [`Registry`]-backed `Layer::on_close` method is///    called, `Registry::start_close` is closed.///    `Registry::start_close` increments a thread-local `CLOSE_COUNT`///    by 1 and returns a `CloseGuard`./// 2. The `CloseGuard` is dropped at the end of `Layer::on_close`. On///    drop, `CloseGuard` checks thread-local `CLOSE_COUNT`. If///    `CLOSE_COUNT` is 0, the `CloseGuard` removes the span with the///    `id` from the registry, as all `Layers` that might have seen the///    `on_close` notification have processed it. If `CLOSE_COUNT` is///    greater than 0, `CloseGuard` decrements the counter by one and///    _does not_ remove the span from the [`Registry`].start_close/// Returns a guard which tracks how many `Layer`s have/// processed an `on_close` notification via the `CLOSE_COUNT` thread-local./// For additional details, see [`CloseGuard`].has_per_layer_filtersspan_stackr" `CLOSE_COUNT` is the thread-local counter used by `CloseGuard` to"r" track how many layers have processed the close."r" For additional details, see [`CloseGuard`]."CLOSE_COUNT/// This is intentionally not implemented, as recording fields/// on a span is the responsibility of layers atop of this registry./// This is intentionally not implemented, as recording events/// is the responsibility of layers atop of this registry./// Decrements the reference count of the span with the given `id`, and/// removes the span if it is zero./// The allocated span slot will be reused when a new span is created.set_closing/// Clears the span's data in place, dropping the parent's reference count.AssertionLayersingle_layer_can_access_closed_spanmultiple_layers_can_access_closed_spanCloseStateCloseLayerSetRemoved// Field is exercised via checking `Arc::downgrade()`assert_closedassert_openassert_removedassert_not_removedassert_last_closed// may want this for future testsassert_closed_in_orderspans_are_removed_from_registryspans_are_only_closed_when_the_last_ref_dropsspan_enter_guards_are_dropped_out_of_orderchild_closes_parentchild_closes_grandparent// === impl Registry ===// === impl CloseGuard ===// === impl Data ===// === impl DataInner ===ContextId/// `SpanStack` tracks what spans are currently executing on a thread-local basis./// A "separate current span" for each thread is a semantic choice, as each span/// can be executing in a different thread.pop_last_spanpop_first_span// TODO(eliza): this once used a `crossbeam_util::ShardedRwLock`. We may// eventually wish to replace it with a sharded lock implementation on top// of our internal `RwLock` wrapper type. If possible, we should profile// this first to determine if it's necessary./// Wraps a `Layer` or `Filter`, allowing it to be reloaded dynamically at runtime./// Allows reloading the state of an associated [`Layer`](crate::layer::Layer)./// Indicates that an error occurred when reloading a layer.SubscriberGone/// Wraps the given [`Layer`] or [`Filter`], returning a `reload::Layer`/// and a `Handle` that allows the inner value to be modified at runtime./// Returns a `Handle` that can be used to reload the wrapped [`Layer`] or [`Filter`]./// Replace the current [`Layer`] or [`Filter`] with the provided `new_value`./// [`Handle::reload`] cannot be used with the [`Filtered`] layer; use/// [`Handle::modify`] instead (see [this issue] for additional details)./// However, if the _only_ the [`Filter`]  needs to be modified, use/// `reload::Layer` to wrap the `Filter` directly./// [this issue]: https://github.com/tokio-rs/tracing/issues/1629/// Invokes a closure with a mutable reference to the current layer or filter,/// allowing it to be modified in place.clone_current/// Returns a clone of the layer or filter's current value if it still exists./// Otherwise, if the subscriber has been dropped, returns `None`./// Invokes a closure with a borrowed reference to the current layer or filter,/// returning the result (or an error if the subscriber no longer exists)./// Returns `true` if this error occurred because the layer was poisoned by/// a panic on another thread./// Returns `true` if this error occurred because the `Subscriber`/// containing the reloadable layer was dropped.//! Wrapper for a `Layer` to allow it to be dynamically reloaded.//! This module provides a [`Layer` type] implementing the [`Layer` trait] or [`Filter` trait]//! which wraps another type implementing the corresponding trait. This//! allows the wrapped type to be replaced with another//! instance of that type at runtime.//! This can be used in cases where a subset of `Layer` or `Filter` functionality//! should be dynamically reconfigured, such as when filtering directives may//! change at runtime. Note that this layer introduces a (relatively small)//! amount of overhead, and should thus only be used as needed.//! Reloading a [global filtering](crate::layer#global-filtering) layer://! # use tracing::info;//! use tracing_subscriber::{filter, fmt, reload, prelude::*};//! let filter = filter::LevelFilter::WARN;//! let (filter, reload_handle) = reload::Layer::new(filter);//!   .with(filter)//!   .with(fmt::Layer::default())//!   .init();//! # // specifying the Registry type is required//! # let _: &reload::Handle<filter::LevelFilter, tracing_subscriber::Registry> = &reload_handle;//! info!("This will be ignored");//! reload_handle.modify(|filter| *filter = filter::LevelFilter::INFO);//! info!("This will be logged");//! Reloading a [`Filtered`](crate::filter::Filtered) layer://! let filtered_layer = fmt::Layer::default().with_filter(filter::LevelFilter::WARN);//! let (filtered_layer, reload_handle) = reload::Layer::new(filtered_layer);//! # let _: &reload::Handle<filter::Filtered<fmt::Layer<tracing_subscriber::Registry>,//! # filter::LevelFilter, tracing_subscriber::Registry>,tracing_subscriber::Registry>//! # = &reload_handle;//!   .with(filtered_layer)//! reload_handle.modify(|layer| *layer.filter_mut() = filter::LevelFilter::INFO);//! The [`Layer`] implementation is unable to implement downcasting functionality,//! so certain [`Layer`] will fail to downcast if wrapped in a `reload::Layer`.//! If you only want to be able to dynamically change the//! `Filter` on a layer, prefer wrapping that `Filter` in the `reload::Layer`.//! [`Filter` trait]: crate::layer::Filter//! [`Layer` type]: Layer//! [`Layer` trait]: super::layer::Layer// ===== impl Layer =====// ===== impl Filter =====// may be used later;//! Abstracts over sync primitive implementations.//! Optionally, we allow the Rust standard library's `RwLock` to be replaced//! with the `parking_lot` crate's implementation. This may provide improved//! performance in some cases. However, the `parking_lot` dependency is an//! opt-in feature flag. Because `parking_lot::RwLock` has a slightly different//! API than `std::sync::RwLock` (it does not support poisoning on panics), we//! wrap it with a type that provides the same method signatures. This allows us//! to transparently swap `parking_lot` in without changing code at the callsite./// Sets `self` as the [default subscriber] in the current scope, returning a/// guard that will unset it when dropped./// If the "tracing-log" feature flag is enabled, this will also initialize/// a [`log`] compatibility layer. This allows the subscriber to consume/// `log::Record`s as though they were `tracing` `Event`s./// [default subscriber]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html#setting-the-default-subscriber/// [`log`]: https://crates.io/logTryInitError/// Attempts to set `self` as the [global default subscriber] in the current/// scope, returning an error if one is already set./// If the "tracing-log" feature flag is enabled, this will also attempt to/// initialize a [`log`] compatibility layer. This allows the subscriber to/// consume `log::Record`s as though they were `tracing` `Event`s./// This method returns an error if a global default subscriber has already/// been set, or if a `log` logger has already been set (when the/// "tracing-log" feature is enabled)./// [global default subscriber]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html#setting-the-default-subscriber/// scope, panicking if this fails./// This method panics if a global default subscriber has already been set,/// or if a `log` logger has already been set (when the "tracing-log"/// feature is enabled)./// Extension trait adding utility methods for subscriber initialization./// This trait provides extension methods to make configuring and setting a/// [default subscriber] more ergonomic. It is automatically implemented for all/// types that can be converted into a [trace dispatcher]. Since `Dispatch`/// implements `From<T>` for all `T: Subscriber`, all `Subscriber`/// implementations will implement this extension trait as well. Types which/// can be converted into `Subscriber`s, such as builders that construct a/// `Subscriber`, may implement `Into<Dispatch>`, and will also receive an/// implementation of this trait./// [trace dispatcher]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html/// Error returned by [`try_init`](SubscriberInitExt::try_init) if a global default subscriber could not be initialized.//! Extension traits and other utilities to make working with subscribers more//! ergonomic.// ==== impl TryInitError ====/// Boxed `Error` object.BoxErrorKind/// Boxed `ErrorKind` object./// `History` type specialized for `TrackableError`.TopLevelError/// An `Error` type for unit tests./// An `Error` type for `main` function.//! Functionalities for implementing trackable errors and operating on those.//! You can easily define your own trackable error types as follows://! extern crate trackable;//! use trackable::error::{TrackableError, ErrorKind, ErrorKindExt};//! #[derive(Debug, TrackableError)]//! #[trackable(error_kind = "MyErrorKind")]//! struct MyError(TrackableError<MyErrorKind>);//! impl From<std::io::Error> for MyError {//!     fn from(f: std::io::Error) -> Self {//!         // Any I/O errors are considered critical//!         MyErrorKind::Critical.cause(f).into()//! #[derive(Debug, PartialEq, Eq)]//! enum MyErrorKind {//!     Critical,//!     NonCritical,//! impl ErrorKind for MyErrorKind {}//!     // Tracks an error//!     let error: MyError = MyErrorKind::Critical.cause("something wrong").into();//!     let error = track!(error);//!     let error = track!(error, "I passed here");//!     assert_eq!(format!("\nError: {}", error).replace('\\', "/"), r#"//! Error: Critical (cause; something wrong)//! HISTORY://!   [0] at src/error.rs:27//!   [1] at src/error.rs:28 -- I passed here//! "#);//!     // Tries to execute I/O operation//!     let result = (|| -> Result<_, MyError> {//!         let f = track!(std::fs::File::open("/path/to/non_existent_file")//!                        .map_err(MyError::from))?;//!         Ok(f)//!     })();//!     let error = result.err().unwrap();//!     let cause = error.concrete_cause::<std::io::Error>().unwrap();//!     assert_eq!(cause.kind(), std::io::ErrorKind::NotFound);//! # `TrackableError` drive macro//! If it is specified (i.e., `#[derive(TrackableError)]`),//! the following traits will be automatically implemented in the target error type://! - `Trackable`//! - `Error`//! - `Display`//! - `Deref<Target = TrackableError<$error_kind>>`//! - `From<$error_kind>`//! - `From<TrackableError<$error_kind>>`//! - `From<$target_error_type> for TrackableError<$error_kind>`//! The default value of `$error_kind` is `ErrorKind`.//! It can be customized by using `#[trackable(error_type = "$error_kind")]` attribute.//! The target error type must be a newtype (i.e., a tuple struct that has a single element) of `TrackableError`.// for `trackable_derive`//! This crate provides functionalities to//! define [trackable](trait.Trackable.html) objects and track those.//! Below is an example that tracks failure of an I/O operation://! use trackable::error::Failure;//! fn foo() -> Result<(), Failure> {//!     track!(std::fs::File::open("/path/to/non_existent_file").map_err(Failure::from_error))?;//! fn bar() -> Result<(), Failure> {//!     track!(foo())?;//! fn baz() -> Result<(), Failure> {//!     track!(bar())?;//!     let result = baz();//!     assert_eq!(format!("\r{}", error).replace('\\', "/"), r#"//! Failed (cause; No such file or directory)//!   [0] at src/lib.rs:7//!   [1] at src/lib.rs:12//!   [2] at src/lib.rs:16//! This example used the built-in `Failure` type,//! but you can easily define your own trackable error types.//! See the documentaion of [error](error/index.html) module for more details./// Tries to track the current [location](struct.Location.html) into the history of the `$target`./// `$target` must be evaluated to a value which implements [Trackable](trait.Trackable.html) trait./// If `$target.in_tracking()` is `false`, it will simply return the value of `$target` untouched./// # extern crate trackable;/// use trackable::error::{Failed, ErrorKindExt};/// // Makes a `TrackableError` value/// let e = Failed.cause("something wrong");/// let e = track!(e);/// // `Result<_, TrackableError>` implements `Trackable`/// let message = "This is a note about this location";/// let e: Result<(), _> = Err(e);/// let e = track!(e; message);/// // `Option<T: Trackable>` implements `Trackable`/// let e = Some(e);/// let e = track!(e, "Hello {}", "World!");/// assert_eq!(format!("\n{}", e.unwrap().err().unwrap()).replace('\\', "/"), r#"/// Failed (cause; something wrong)///   [0] at src/macros.rs:10///   [1] at src/macros.rs:15 -- message="This is a note about this location"///   [2] at src/macros.rs:19 -- Hello World!track_any_err/// The abbreviation of `track!($target.map_err(Failure::from_error), ..)`./// use std::sync::mpsc;/// let rx = mpsc::channel::<()>().1;/// let result = track_any_err!(rx.recv(), "sender dropped");/// assert_eq!(format!("\n{}", result.err().unwrap()).replace('\\', "/"), r#"/// Failed (cause; receiving on a closed channel)///   [0] at src/macros.rs:10 -- sender droppedtrack_err/// The abbreviation of `$target.map_err(|e| track!(e, ..))`./// Error trackable variant of the standard `assert!` macro./// This is a simple wrapper of the `track_panic!` macro./// It will call `track_panic!($error_kind, $($format_arg)+)` if `$cond` is evaluated to `false`./// use trackable::error::{Failed, Failure};/// fn add_positive_f32(a: f32, b: f32) -> Result<f32, Failure> {///     track_assert!(a > 0.0 && b > 0.0, Failed; a, b);///     Ok(a + b)/// let r = add_positive_f32(3.0, 2.0); // Ok/// assert_eq!(r.ok(), Some(5.0));/// let r = add_positive_f32(1.0, -2.0); // Err/// assert!(r.is_err());/// assert_eq!(format!("\n{}", r.err().unwrap()).replace('\\', "/"), r#"/// Failed (cause; assertion failed: `a > 0.0 && b > 0.0`; a=1.0, b=-2.0)///   [0] at src/macros.rs:9track_assert_eq/// Error trackable variant of the standard `assert_ne!` macro./// Conceptually, `track_assert_eq!(left, right, error_kind)` is equivalent to/// `track_assert!(left == right, error_kind)`.track_assert_ne/// Conceptually, `track_assert_ne!(left, right, error_kind)` is equivalent to/// `track_assert!(left != right, error_kind)`.track_assert_some/// Trackable assertion for `Option` values./// It will call `track_panic!` if `$expr` is evaluated to `None`./// fn trackable_checked_sub(a: u32, b: u32) -> Result<u32, Failure> {///     let n = track_assert_some!(a.checked_sub(b), Failed);///     Ok(n)/// let r = trackable_checked_sub(10, 2); // Ok/// assert_eq!(r.ok(), Some(8));/// let r = trackable_checked_sub(2, 10); // Err/// Failed (cause; assertion failed: `a.checked_sub(b).is_some()`)/// Error trackable variant of the standard `panic!` macro./// This returns an `TrackableError` object as the result value of the calling function,/// instead of aborting the current thread./// Conceptually, `track_panic!(error)` is equivalent to the following code:/// # use trackable::error::{Failed, Failure};/// # fn main() { let _ = foo(); }/// # fn foo() -> Result<(), Failure> {/// use trackable::Trackable;/// use trackable::error::TrackableError;/// # let error = Failed;/// let e = TrackableError::from(error); // Converts to `TrackableError`/// let e = track!(e);                   // Tracks this location/// Err(e)?;                             // Returns from the current function/// fn foo<F>(f: F) -> Result<(), Failure> where F: FnOnce() -> Result<(), Failure> { f() }/// let e = foo(|| track_panic!(Failed) ).err().unwrap();/// assert_eq!(format!("\n{}", e).replace('\\', "/"), r#"/// Failed/// let e = foo(|| track_panic!(Failed, "something {}", "wrong") ).err().unwrap();///   [0] at src/macros.rs:17track_try_unwrap/// More human readable variant of the standard `Result::unwrap` method./// extern crate trackable;/// use trackable::error::{Failed, Failure, ErrorKindExt};///    let result: Result<(), Failure> = Err(Failed.error().into());///    // Following two expressions are conceptually equivalent.///    result.clone().unwrap();///    track_try_unwrap!(result.clone());///    // `track_try_unwrap!()` can take additional arguments compatible to `format!()`.///    result.clone().expect(&format!("Additional information: {}", "foo"));///    track_try_unwrap!(result.clone(), "Additional information: {}", "foo");derive_traits_for_trackable_error_newtype/// Implements the typical traits for a newtype $error of `TrackableError<$kind>`./// The automatically implemented traits are `Deref`, `From`, `Display`, `Error`,/// `Trackable` and `From`./// This macro is useful to reduce the boilerplate code when/// you define a your own trackable error type./// use trackable::error::{TrackableError, ErrorKind as TrackableErrorKind};/// #[derive(Debug, Clone, PartialEq, Eq)]/// pub enum ErrorKind {///    Foo,///    Bar,///    Baz,/// impl TrackableErrorKind for ErrorKind {}/// // Defines a newtype of `TrackableError<ErrorKind>`./// pub struct Error(TrackableError<ErrorKind>);/// derive_traits_for_trackable_error_newtype!(Error, ErrorKind);trackable_prepare_values_fmttrack_workstrack_assert_workstrack_try_unwrap_worksTopLevelResult/// A variant of [`Result`] for top-level functions that return a trackable error on failure.MainResult/// A variant of [`Result`] for main functions that return a trackable error on failure./// A variant of [`Result`] for unit tests that return a trackable error on failure.//! Trackable [`Result`] types for main and test functions.//! [`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html/// Built-in `ErrorKind` implementation which represents opaque errors./// `TrackableError` type specialized for `Failed`./// Makes a new `Failure` instance which was caused by the `error`./// A variant of `std::io::Error` that implements `Trackable` trait./// An `Error` type for top-level functions./// A short description of the error kind./// This is used for the description of the error that contains it./// The default implementation always returns `"An error"`./// Displays this kind./// The default implementation uses the debugging form of this./// This trait represents an error kind which `TrackableError` can have./// Makes a `TrackableError` instance without cause./// let e = Failed.error();/// assert!(e.cause().is_none());/// Makes a `TrackableError` instance with the specified `cause`./// assert_eq!(e.cause().unwrap().to_string(), "something wrong");takes_over/// Takes over from other `TrackableError` instance./// The history of `from` will be preserved./// use trackable::error::{ErrorKind, ErrorKindExt};/// struct Kind0;/// impl ErrorKind for Kind0 {}/// struct Kind1;/// impl ErrorKind for Kind1 {}///   let e = Kind0.error();///   let e = track!(e);///   let e = Kind1.takes_over(e);///   assert_eq!(format!("\nERROR: {}", e).replace('\\', "/"), r#"/// ERROR: Kind1///   [0] at src/error.rs:17///   [1] at src/error.rs:20/// An extention of `ErrorKind` trait./// This provides convenient functions to create a `TrackableError` instance of this kind./// Trackable error./// Defines your own `Error` type./// use trackable::error::{TrackableError, ErrorKind, ErrorKindExt};/// #[derive(Debug, TrackableError)]/// #[trackable(error_kind = "MyErrorKind")]/// struct MyError(TrackableError<MyErrorKind>);/// impl From<std::io::Error> for MyError {///     fn from(f: std::io::Error) -> Self {///         // Any I/O errors are considered critical///         MyErrorKind::Critical.cause(f).into()/// #[derive(Debug, PartialEq, Eq)]/// enum MyErrorKind {///     Critical,///     NonCritical,/// impl ErrorKind for MyErrorKind {}///     // Tracks an error///     let error: MyError = MyErrorKind::Critical.cause("something wrong").into();///     let error = track!(error);///     let error = track!(error, "I passed here");///     assert_eq!(format!("\nError: {}", error).replace('\\', "/"), r#"/// Error: Critical (cause; something wrong)///   [0] at src/error.rs:27///   [1] at src/error.rs:28 -- I passed here///     // Tries to execute I/O operation///     let result = (|| -> Result<_, MyError> {///         let f = track!(std::fs::File::open("/path/to/non_existent_file")///                        .map_err(MyError::from))?;///         Ok(f)///     })();///     let error = result.err().unwrap();///     let cause = error.concrete_cause::<std::io::Error>().unwrap();///     assert_eq!(cause.kind(), std::io::ErrorKind::NotFound);/// `TrackableError` is cloneable if `K` is so.///     let mut original = Failed.error();///     let original = track!(original, "Hello `original`!");///     let forked = original.clone();///     let forked = track!(forked, "Hello `forked`!");///     assert_eq!(format!("\n{}", original).replace('\\', "/"), r#"///   [0] at src/error.rs:11 -- Hello `original`!///     assert_eq!(format!("\n{}", forked).replace('\\', "/"), r#"///   [1] at src/error.rs:13 -- Hello `forked`!/// Makes a new `TrackableError` instance./// Makes a new `TrackableError` instance from `kind`./// Note that the returning error has no cause./// Returns the kind of this error.concrete_cause/// Tries to return the cause of this error as a value of `T` type./// If neither this error has a cause nor it is an `T` value,/// this method will return `None`./// Event type which a history of an instance of this type can have./// Add an event into the tail of the history of this instance./// Typically, this is called via [track!](macro.track.html) macro.in_tracking/// Returns `true` if it is being tracked, otherwise `false`./// Returns the reference of the tracking history of this instance./// If it is not being tracked, this will return `None./// Returns the mutable reference of the tracking history of this instance./// This trait allows to track an instance of an implementation type./// A trackable instance can have a tracking history that manages own backtrace-like (but more general)/// [history](struct.History.html) for tracking./// You can add entries to the history by calling tracking macros(e.g., [track!](macro.track.html))./// See [`TrackableError`](error/struct.TrackableError.html) as a typical implementaion of this trait./// Defines a trackable type./// use trackable::{Trackable, History, Location};/// struct TrackableObject {///     history: History<Location>,/// impl Trackable for TrackableObject {///     type Event = Location;///     fn history(&self) -> Option<&History<Self::Event>> {///         Some(&self.history)///     fn history_mut(&mut self) -> Option<&mut History<Self::Event>> {///         Some(&mut self.history)///     let o = TrackableObject::default();///     let o = track!(o);///     let o = track!(o, "Hello");///     let o = track!(o, "Hello {}", "World!");///     assert_eq!(format!("\n{}", o.history).replace('\\', "/"), r#"///   [0] at src/lib.rs:23///   [1] at src/lib.rs:24 -- Hello///   [2] at src/lib.rs:25 -- Hello World!/// The tracking history of a target./// A history is a sequence of the tracked events./// use std::fmt::{Display, Formatter, Result};/// use trackable::History;/// struct Event(&'static str);/// impl Display for Event {///     fn fmt(&self, f: &mut Formatter) -> Result {///         write!(f, "event: {}", self.0)/// let mut history = History::new();/// history.add(Event("foo"));/// history.add(Event("bar"));/// assert_eq!(format!("\n{}", history), r#"///   [0] event: foo///   [1] event: bar/// Makes an empty history./// Adds an event to the tail of this history./// Returns the tracked events in this history./// The location of interest in source code files./// Typically this is created in the macros which defined in this crate./// Makes a new `Location` instance./// use trackable::Location;/// let location = Location::new(module_path!(), file!(), line!(), "Hello".to_string());/// assert_eq!(location.message(), "Hello");/// Gets the crate name of this location./// Gets the module path of this location./// Gets the file name of this location./// Gets the line of this location./// Gets the message left at this location.derive_trackable_errorimpl_trackable_errorget_error_kind//! This crate provides `TrackableError` derive macro.//! This crate should not be used directly.//! See [trackable] documentation for the usage of `#[derive(TrackableError)]`.//! [trackable]: https://docs.rs/trackablemultiplicative_inversetranspose_inplace/// Transpose the input array in-place.
/// Given an input array of size input_width * input_height, representing flattened 2D data stored in row-major order,
/// transpose the rows and columns of that input array, in-place.
/// Despite being in-place, this algorithm requires max(width, height) in scratch space.
/// // row-major order: the rows of our 2D array are contiguous,
/// // and the columns are strided
/// let original_array = vec![ 1, 2, 3,
/// 						   4, 5, 6];
/// let mut input_array = original_array.clone();
/// // Treat our 6-element array as a 2D 3x2 array, and transpose it to a 2x3 array
/// // transpose_inplace requires max(width, height) scratch space, which is in this case 3
/// let mut scratch = vec![0; 3];
/// transpose::transpose_inplace(&mut input_array, &mut scratch, 3, 2);
/// // The rows have become the columns, and the columns have become the rows
/// let expected_array =  vec![ 1, 4,
///								2, 5,
///								3, 6];
/// assert_eq!(input_array, expected_array);
/// // If we transpose it again, we should get our original data back.
/// transpose::transpose_inplace(&mut input_array, &mut scratch, 2, 3);
/// assert_eq!(original_array, input_array);
/// Panics if `input.len() != input_width * input_height` or if `scratch.len() != max(width, height)`
in_placeout_of_place//! Utility for transposing multi-dimensional data stored as a flat slice
//! This library treats Rust slices as flattened row-major 2D arrays, and provides functions to transpose these 2D arrays, so that the row data becomes the column data, and vice versa.
//! // Create a 2D array in row-major order: the rows of our 2D array are contiguous,
//! // and the columns are strided
//! let input_array = vec![ 1, 2, 3,
//! 						4, 5, 6];
//! // Treat our 6-element array as a 2D 3x2 array, and transpose it to a 2x3 array
//! let mut output_array = vec![0; 6];
//! transpose::transpose(&input_array, &mut output_array, 3, 2);
//! // The rows have become the columns, and the columns have become the rows
//! let expected_array =  vec![ 1, 4,
//!								2, 5,
//!								3, 6];
//! assert_eq!(output_array, expected_array);
//! // If we transpose our data again, we should get our original data back.
//! let mut final_array = vec![0; 6];
//! transpose::transpose(&output_array, &mut final_array, 2, 3);
//! assert_eq!(final_array, input_array);
//! This library supports both in-place and out-of-place transposes. The out-of-place
//! transpose is much, much faster than the in-place transpose -- the in-place transpose should
//! only be used in situations where the system doesn't have enough memory to do an out-of-place transpose.
//! The out-of-place transpose uses one out of three different algorithms depending on the length of the input array.
//! - Small: simple iteration over the array. 
//! - Medium: divide the array into tiles of fixed size, and process each tile separately. 
//! - Large: recursively split the array into smaller parts until each part is of a good size for the tiling algorithm, and then transpose each part.  
// Block size used by the tiling algoritms
NBR_SEGMENTS// Number of segments used by the segmented block transpose function
RECURSIVE_LIMIT// recursively split data until the number of rows and columns is below this number
SMALL_LEN// Largest size for for using the direct approach
MEDIUM_LEN// Largest size for using the tiled approach
/// transpose the rows and columns of that 2D array into the output.
/// Benchmarking shows that loop tiling isn't effective for small arrays.
transpose_block// Transpose a subset of the array, from the input into the output. The idea is that by transposing one block at a time, we can be more cache-friendly
// SAFETY: Width * height must equal input.len() and output.len(), start_x + block_width must be <= width, start_y + block height must be <= height
transpose_block_segmented// This function works as `transpose_block`, but also divides the loop into a number of segments. This makes it more cache fiendly for large sizes.
transpose_tiled/// This algorithm divides the input into tiles of size BLOCK_SIZE*BLOCK_SIZE, 
/// in order to reduce cache misses. This works well for medium sizes, when the
/// data for each tile fits in the caches.  
transpose_recursive/// This is a recursive algorithm that divides the array into smaller pieces, until they are small enough to
/// transpose directly without worrying about cache misses.
/// Once they are small enough, they are transposed using a tiling algorithm. 
/// Transpose the input array into the output array. 
/// transpose the rows and columns of that input array into the output array
/// let input_array = vec![ 1, 2, 3,
/// 						4, 5, 6];
/// let mut output_array = vec![0; 6];
/// transpose::transpose(&input_array, &mut output_array, 3, 2);
/// assert_eq!(output_array, expected_array);
/// let mut final_array = vec![0; 6];
/// transpose::transpose(&output_array, &mut final_array, 2, 3);
/// assert_eq!(final_array, input_array);
/// Panics if `input.len() != input_width * input_height` or if `output.len() != input_width * input_height`
BaseTypematch_bytesmatch_fileget_supportedget_subclassesget_aliaslistis_text_plain_from_u8/// If there are any null bytes, return False. Otherwise return True.is_text_plain_from_file// TODO: Hoist the main logic here somewhere else. This'll get redundant fast!/// Returns Vec of parent->child relations//! Handles "base types" such as inode/* and text/plainALL_RULESfdo_magicfrom_u8_walkerFdoMagicsubclasses/// Get list of supported MIME types/// Get list of parent -> child subclass linksMagicRule/// Preload alias list/// Load magic file before anything else.//! Read magic file bundled in craterulesetsearch_pathsload_xdg_shared_magic/// Load the magic database from the predefined locations in the XDG standardload_concat_strings/// Load a number of files at `paths` and concatenate them together with a newline//! Enable loading the magic database files at runtime rather than embedding the GPLed databasefrom_u8_singlerule/// Test every given rule by walking graph/// TODO: Not loving the code duplication here.indent_levelstart_offregion_lenscan_len// Common routines for all fdo_magic parsersmagic_rules// Singular magic ruleset/// Converts a magic file given as a &[u8] array/// to a vector of MagicEntry structsgen_graphfrom_multiple/// Parse multiple ruleset magic files and aggregate the tuples into a single graphbasetypeTYPEORDER/// Check these types first/// TODO: Poll these from the checkers? Feels a bit arbitraryCHECKERSCHECKER_SUPPORTTypeStruct/// Information about currently loaded MIME types/// The `graph` contains subclass relations between all given mimes./// (EX: `application/json` -> `text/plain` -> `application/octet-stream`)/// This is a `petgraph` DiGraph, so you can walk the tree if needed./// The `hash` is a mapping between MIME types and nodes on the graph./// The root of the graph is "all/all", so start traversing there unless/// you need to jump to a particular node./// The TypeStruct autogenerated at library init, and used by the library.typegraph_walker/// Just the part of from_*_node that walks the graphget_alias/// Transforms an alias into it's real typematch_u8_noalias/// Internal function. Checks if an alias exists, and if it does,/// then runs `match_bytes`.match_u8/// Checks if the given bytestream matches the given MIME type./// Returns true or false if it matches or not. If the given MIME type is not known,/// the function will always return false./// If mimetype is an alias of a known MIME, the file will be checked agains that MIME./// // Load a GIF file/// let input: &[u8] = include_bytes!("../tests/image/gif");/// // Check if the MIME and the file are a match/// let result = tree_magic_mini::match_u8("image/gif", input);/// assert_eq!(result, true);from_u8_node/// Gets the type of a file from a raw bytestream, starting at a certain node/// in the type graph./// Returns MIME as string wrapped in Some if a type matches, or/// None if no match is found under the given node./// Retreive the node from the `TYPE.hash` HashMap, using the MIME as the key./// Will panic if the given node is not found in the graph./// As the graph is immutable, this should not happen if the node index comes from/// TYPE.hash./// Gets the type of a file from a byte stream./// Returns MIME as string./// // Find the MIME type of the GIF/// let result = tree_magic_mini::from_u8(input);/// assert_eq!(result, "image/gif");/// Check if the given file matches the given MIME type./// // Get path to a GIF file/// let file = File::open("tests/image/gif").unwrap();/// let result = tree_magic_mini::match_file("image/gif", &file);match_file_noalias/// then runs `match_file`.match_filepath/// Check if the file at the given path matches the given MIME type./// Returns false if the file could not be read or the given MIME type is not known./// let path: &Path = Path::new("tests/image/gif");/// let result = tree_magic_mini::match_filepath("image/gif", path);from_file_node/// Gets the type of a file, starting at a certain node in the type graph./// Gets the MIME type of a file./// Does not look at file name or extension, just the contents./// let result = tree_magic_mini::from_file(&file);/// assert_eq!(result, Some("image/gif"));from_filepath/// Returns None if the file cannot be opened/// or if no matching MIME type is found./// let path = Path::new("tests/image/gif");/// let result = tree_magic_mini::from_filepath(path);/// Reads the given number of bytes from a file//! `tree_magic_mini` is a Rust crate that determines the MIME type a given file or byte stream.//! This is a fork of the [tree_magic](https://crates.io/crates/tree_magic)//! crate by Allison Hancock. It includes the following changes://! * Updated dependencies.//! * Reduced copying and memory allocation, for a slight increase in speed and//!   decrease in memory use.//! * Reduced API surface. Some previously public APIs are now internal.//! * Removed the optional `cli` feature and `tmagic` binary.//! # About tree_magic//! `tree_magic` is designed to be more efficient and to have less false positives compared//! to the old approach used by `libmagic`, or old-fashioned file extension comparisons.//! Instead, this loads all known MIME types into a tree based on subclasses. Then, instead//! of checking against *every* file type, `tree_magic` will traverse down the tree and//! only check the files that make sense to check.//! - Very fast perfomance (~150ns to check one file against one type,//!   between 5,000ns and 100,000ns to find a MIME type.)//! - Check if a file *is* a certain type.//! - Handles aliases (ex: `application/zip` vs `application/x-zip-compressed`)//! - Can delegate different file types to different "checkers", reducing false positives//!   by choosing a different method of attack.//! ## Licensing and the MIME database//! By default, `tree_magic_mini` will attempt to load the shared MIME info//! database from the standard locations at runtime.//! If you won't have the database files available, or would like to include them//! in your binary for simplicity, you can optionally embed the database//! information if you enable the `tree_magic_db` feature.//! **As the magic database files themselves are licensed under the GPL, you must//! make sure your project uses a compatible license if you enable this behaviour.**//! // Load a GIF file//! let input: &[u8] = include_bytes!("../tests/image/gif");//! // Find the MIME type of the GIF//! let result = tree_magic_mini::from_u8(input);//! assert_eq!(result, "image/gif");//! // Check if the MIME and the file are a match//! let result = tree_magic_mini::match_u8("image/gif", input);//! assert_eq!(result, true);// Mappings between modules and supported mimes/// A light-weight lock guarded by an atomic boolean./// Most efficient when contention is low, acquiring the lock is a single/// atomic swap, and releasing it just 1 more atomic swap./// It is only possible to try to acquire the lock, it is not possible to/// wait for the lock to become ready, like with a `Mutex`./// Create a `TryLock` around the value./// Try to acquire the lock of this value./// If the lock is already acquired by someone else, this returns/// `None`. You can try to acquire again whenever you want, perhaps/// by spinning a few times, or by using some other means of/// The default memory ordering is to use `Acquire` to lock, and `Release`/// to unlock. If different ordering is required, use/// [`try_lock_explicit`](TryLock::try_lock_explicit) or/// [`try_lock_explicit_unchecked`](TryLock::try_lock_explicit_unchecked).try_lock_order/// Try to acquire the lock of this value using the lock and unlock orderings.try_lock_explicit/// Try to acquire the lock of this value using the specified lock and/// unlock orderings./// This method panics if `lock_order` is not any of `Acquire`, `AcqRel`,/// and `SeqCst`, or `unlock_order` is not any of `Release` and `SeqCst`.try_lock_explicit_unchecked/// unlock orderings without checking that the specified orderings are/// strong enough to be safe./// Unlike [`try_lock_explicit`], this method is unsafe because it does not/// check that the given memory orderings are strong enough to prevent data/// race./// [`try_lock_explicit`]: Self::try_lock_explicit/// Take the value back out of the lock when this is the sole owner."TryLock will immediately unlock if not used"/// Suppresses Send and Sync autotraits for `struct Locked`./// A locked value acquired from a `TryLock`./// The type represents an exclusive view at the underlying value. The lock is/// released when this type is dropped./// This type derefs to the underlying value.//! A light-weight lock guarded by an atomic boolean.//! Most efficient when contention is low, acquiring the lock is a single//! atomic swap, and releasing it just 1 more atomic swap.//! use try_lock::TryLock;//! // a thing we want to share//! struct Widget {//! // lock it up!//! let widget1 = Arc::new(TryLock::new(Widget {//!     name: "Spanner".into(),//! let widget2 = widget1.clone();//! // mutate the widget//! let mut locked = widget1.try_lock().expect("example isn't locked yet");//! locked.name.push_str(" Bundle");//! // hands off, buddy//! let not_locked = widget2.try_lock();//! assert!(not_locked.is_none(), "widget1 has the lock");//! // ok, you can have it//! drop(locked);//! let locked2 = widget2.try_lock().expect("widget1 lock is released");//! assert_eq!(locked2.name, "Spanner Bundle");FromDataLazyArray16NumFromOffset16Offset32START_OF_TEXT/// Predefined states.END_OF_TEXTOUT_OF_BOUNDSDELETED_GLYPH/// Predefined classes./// Search for _Class Code_ in [Apple Advanced Typography Font Tables](/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html)./// A new state./// Entry flags./// Additional data./// Use `()` if no data expected.GenericStateEntry/// A State Table entry./// Used by legacy and extended tables.has_offset/// Checks that entry has an offset.value_offsetValueOffset/// Returns a value offset./// Used by kern::format1 subtable.has_reset/// If set, reset the kerning data (clear the stack).has_advance/// If set, advance to the next glyph before going to the new state.has_push/// If set, push this glyph on the kerning stack.has_mark/// If set, remember this glyph as the marked glyph./// Used by kerx::format4 subtable./// Yes, the same as [`has_push`](Self::has_push).StateEntry/// A legacy state entry used by [StateTable]./// A type-safe wrapper for a kerning value offset./// Returns the next offset./// After reaching u16::MAX will start from 0.number_of_classesfirst_glyphclass_tablestate_array_offsetstate_arrayentry_tableStateTable/// A [State Table](/// Also called `STHeader`./// Currently used by `kern` table./// Returns a glyph class./// Returns a class entry.kerning/// Returns kerning at offset./// Produces a new state.ExtendedStateTable/// An [Extended State Table](/// Also called `STXHeader`./// Currently used by `kerx` and `morx` tables.// TODO: make private/// Parses an Extended State Table from a stream./// `number_of_glyphs` is from the `maxp` table.LookupInner/// A [lookup table](/// u32 values in Format10 tables will be truncated to u16./// u64 values in Format10 tables are not supported./// Parses a lookup table from raw data./// Returns a value associated with the specified glyph.Format1LookupSegmentBinarySearchTableFormat2Format4LookupSingleFormat6Format8value_sizeFormat10// values length excluding termination segmentBinarySearchValue/// A binary searching table as defined at/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.htmlis_terminationlast_glyph/*!
A collection of [Apple Advanced Typography](
https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html)
related types.
*/DeltaSetIndexMapClassDefinitionSequenceLookupRecordLazyOffsetArray16ChainedContextLookupsetsChainedSequenceRuleSets/// Simple glyph contexts.backtrack_classesinput_classeslookahead_classes/// Class-based glyph contexts.backtrack_coveragesinput_coverageslookahead_coverageslookupsFormat3/// Coverage-based glyph contexts./// A [Chained Contextual Lookup Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#chseqctxt1)./// Returns the subtable coverage.ChainedSequenceRuleSet/// A list of [`ChainedSequenceRule`] sets.ChainedSequenceRule/// A set of [`ChainedSequenceRule`]./// Contains either glyph IDs or glyph Classes./// A [Chained Sequence Rule](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#chained-sequence-context-format-1-simple-glyph-contexts).LookupIndexContextLookupSequenceRuleSetscoverages/// A [Contextual Lookup Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#seqctxt1).SequenceRuleSet/// A list of [`SequenceRuleSet`]s.SequenceRule/// A set of [`SequenceRule`]s./// A sequence rule.sequence_indexlookup_list_index/// A sequence rule record.FeatureIndexRecordListItemVariationIndexLazyArray32NormalizedCoordinaterecordsFeatureVariationRecordFeatureVariations/// A [Feature Variations Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#featurevariations-table).find_index/// Returns a [`VariationIndex`] for variation coordinates.find_substitute/// Returns a [`Feature`] at specified indices.conditionssubstitutionsConditionSetConditionaxis_indexfilter_range_minfilter_range_maxFeatureTableSubstitutionRecordFeatureTableSubstitutionfeature_indexLookupListScriptList/// A list of all supported scripts.FeatureList/// A list of all supported features./// A list of all lookups./// Used to substitute an alternate set of lookup tables/// to use for any given feature under specified conditions.LayoutTable/// A [Layout Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#table-organization).ScriptIndex/// An index in [`ScriptList`].LanguageIndex/// An index in [`LanguageSystemList`]./// An index in [`FeatureList`]./// An index in [`LookupList`]./// An index in [`FeatureVariations`]./// Parses raw data./// A trait to parse item in [`RecordList`]./// Internal use only.TagRecordRecordList/// A data storage used by [`ScriptList`], [`LanguageSystemList`] and [`FeatureList`] data types./// Returns a number of items in the RecordList./// Checks that RecordList is empty./// Returns RecordList value by index./// Returns RecordList value by [`Tag`]./// Returns RecordList value index by [`Tag`].RecordListIter/// An iterator over [`RecordList`] values./// A list of [`Script`] records.LanguageSystemListLanguageSystem/// A list of [`LanguageSystem`] records./// A list of [`Feature`] records./// Script tag./// Default language.languages/// List of supported languages, excluding the default one. Listed alphabetically./// A [Script Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#script-table-and-language-system-record)./// Language tag.required_feature/// Index of a feature required for this language system.feature_indices/// Array of indices into the FeatureList, in arbitrary order./// A [Language System Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#language-system-table).lookup_indices/// A [Feature](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#feature-table).// Suppresses `minor_version` variable warning./// A list of [`Lookup`] values.LookupFlags/// Lookup qualifiers.LookupSubtables/// Available subtables.mark_filtering_set/// Index into GDEF mark glyph sets structure./// A [Lookup Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#lookup-table).LookupSubtable/// A trait for parsing Lookup subtables./// A list of lookup subtables./// Returns a number of items in the LookupSubtables./// Checks if there are any items./// Parses a subtable at index./// Accepts either/// [`PositioningSubtable`](crate::gpos::PositioningSubtable)/// or [`SubstitutionSubtable`](crate::gsub::SubstitutionSubtable)./// Technically, we can enforce it at compile time, but it makes code too convoluted.LookupSubtablesIter/// Creates an iterator over subtables./// We cannot use `IntoIterator` here, because we have to use user-provided base type./// An iterator over lookup subtables./// Lookup table flags.right_to_leftignore_base_glyphsignore_ligaturesignore_marksignore_flagsuse_mark_filtering_setmark_attachment_typeparse_extension_lookupchained_contextfeature_variationslayout_table/// First glyph ID in the range/// Last glyph ID in the range/// Coverage Index of first glyph ID in range.RangeRecord/// A record that describes a range of glyph IDs./// Returns a [`RangeRecord`] for a glyph./// Array of glyph IDs. Sorted./// Array of glyph ranges. Ordered by `RangeRecord.start`./// A [Coverage Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-table)./// Checks that glyph is present./// Returns the coverage index of the glyph or `None` if it is not covered./// A value of [Class Definition Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table)./// A [Class Definition Table](/// Returns the glyph class of the glyph (zero if it is not defined).//! Common data types used by GDEF/GPOS/GSUB tables.//! <https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2>// A heavily modified port of https://github.com/harfbuzz/rustybuzz implementation// originally written by https://github.com/laurmaedjeAfrikaans_SouthAfricaAlbanian_AlbaniaAlsatian_FranceAmharic_EthiopiaArabic_AlgeriaArabic_BahrainArabic_EgyptArabic_IraqArabic_JordanArabic_KuwaitArabic_LebanonArabic_LibyaArabic_MoroccoArabic_OmanArabic_QatarArabic_SaudiArabiaArabic_SyriaArabic_TunisiaArabic_UAEArabic_YemenArmenian_ArmeniaAssamese_IndiaAzeri_Cyrillic_AzerbaijanAzeri_Latin_AzerbaijanBashkir_RussiaBasque_BasqueBelarusian_BelarusBengali_BangladeshBengali_IndiaBosnian_Cyrillic_BosniaAndHerzegovinaBosnian_Latin_BosniaAndHerzegovinaBreton_FranceBulgarian_BulgariaCatalan_CatalanChinese_HongKongSARChinese_MacaoSARChinese_PeoplesRepublicOfChinaChinese_SingaporeChinese_TaiwanCorsican_FranceCroatian_CroatiaCroatian_Latin_BosniaAndHerzegovinaCzech_CzechRepublicDanish_DenmarkDari_AfghanistanDivehi_MaldivesDutch_BelgiumDutch_NetherlandsEnglish_AustraliaEnglish_BelizeEnglish_CanadaEnglish_CaribbeanEnglish_IndiaEnglish_IrelandEnglish_JamaicaEnglish_MalaysiaEnglish_NewZealandEnglish_RepublicOfThePhilippinesEnglish_SingaporeEnglish_SouthAfricaEnglish_TrinidadAndTobagoEnglish_UnitedKingdomEnglish_UnitedStatesEnglish_ZimbabweEstonian_EstoniaFaroese_FaroeIslandsFilipino_PhilippinesFinnish_FinlandFrench_BelgiumFrench_CanadaFrench_FranceFrench_LuxembourgFrench_PrincipalityOfMonacoFrench_SwitzerlandFrisian_NetherlandsGalician_GalicianGeorgian_GeorgiaGerman_AustriaGerman_GermanyGerman_LiechtensteinGerman_LuxembourgGerman_SwitzerlandGreek_GreeceGreenlandic_GreenlandGujarati_IndiaHausa_Latin_NigeriaHebrew_IsraelHindi_IndiaHungarian_HungaryIcelandic_IcelandIgbo_NigeriaIndonesian_IndonesiaInuktitut_CanadaInuktitut_Latin_CanadaIrish_IrelandisiXhosa_SouthAfricaisiZulu_SouthAfricaItalian_ItalyItalian_SwitzerlandJapanese_JapanKannada_IndiaKazakh_KazakhstanKhmer_CambodiaKiche_GuatemalaKinyarwanda_RwandaKiswahili_KenyaKonkani_IndiaKorean_KoreaKyrgyz_KyrgyzstanLao_LaoPDRLatvian_LatviaLithuanian_LithuaniaLowerSorbian_GermanyLuxembourgish_LuxembourgMacedonian_NorthMacedoniaMalay_BruneiDarussalamMalay_MalaysiaMalayalam_IndiaMaltese_MaltaMaori_NewZealandMapudungun_ChileMarathi_IndiaMohawk_MohawkMongolian_Cyrillic_MongoliaMongolian_Traditional_PeoplesRepublicOfChinaNepali_NepalNorwegian_Bokmal_NorwayNorwegian_Nynorsk_NorwayOccitan_FranceOdia_IndiaPashto_AfghanistanPolish_PolandPortuguese_BrazilPortuguese_PortugalPunjabi_IndiaQuechua_BoliviaQuechua_EcuadorQuechua_PeruRomanian_RomaniaRomansh_SwitzerlandRussian_RussiaSami_Inari_FinlandSami_Lule_NorwaySami_Lule_SwedenSami_Northern_FinlandSami_Northern_NorwaySami_Northern_SwedenSami_Skolt_FinlandSami_Southern_NorwaySami_Southern_SwedenSanskrit_IndiaSerbian_Cyrillic_BosniaAndHerzegovinaSerbian_Cyrillic_SerbiaSerbian_Latin_BosniaAndHerzegovinaSerbian_Latin_SerbiaSesothoSaLeboa_SouthAfricaSetswana_SouthAfricaSinhala_SriLankaSlovak_SlovakiaSlovenian_SloveniaSpanish_ArgentinaSpanish_BoliviaSpanish_ChileSpanish_ColombiaSpanish_CostaRicaSpanish_DominicanRepublicSpanish_EcuadorSpanish_ElSalvadorSpanish_GuatemalaSpanish_HondurasSpanish_MexicoSpanish_NicaraguaSpanish_PanamaSpanish_ParaguaySpanish_PeruSpanish_PuertoRicoSpanish_ModernSort_SpainSpanish_TraditionalSort_SpainSpanish_UnitedStatesSpanish_UruguaySpanish_VenezuelaSwedish_FinlandSwedish_SwedenSyriac_SyriaTajik_Cyrillic_TajikistanTamazight_Latin_AlgeriaTamil_IndiaTatar_RussiaTelugu_IndiaThai_ThailandTibetan_PRCTurkish_TurkeyTurkmen_TurkmenistanUighur_PRCUkrainian_UkraineUpperSorbian_GermanyUrdu_IslamicRepublicOfPakistanUzbek_Cyrillic_UzbekistanUzbek_Latin_UzbekistanVietnamese_VietnamWelsh_UnitedKingdomWolof_SenegalYakut_RussiaYi_PRCYoruba_Nigeria/// A [`Name`](crate::name::Name) language./// Consists of Language + Region pairs./// <https://learn.microsoft.com/en-us/typography/opentype/spec/name#windows-language-ids>windows_languageprimary_language/// Returns the primary language./// Returns a language region.aatdelta_setgggvar_storeIndexToLocationFormatLazyArrayIter16LazyArrayIter32TryNumFromfvarname_idPlatformIdos2ScriptMetricsUnicodeRangesCFFErrorankrkerxmorxtrakavarcff2gvarhvarmvarvvarcbdtcblccff1cffvheacolrcpalglyfhheahmtxlocamaxpsbixvorggdefgposgsub//! This module contains//! [OpenType Layout](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#overview)//! supplementary tables implementation.opentype_layout//! [Apple Advanced Typography Layout](//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html)apple_layout/// A type-safe wrapper for glyph ID.TrueTypeOpenTypeFontCollection/// A TrueType font magic./// https://docs.microsoft.com/en-us/typography/opentype/spec/otff#organization-of-an-opentype-font/// A variation coordinate in a normalized coordinate system./// Basically any number in a -1.0..1.0 range./// Where 0 is a default value./// The number is stored as f2.16/// Creates a new coordinate./// The provided number will be clamped to the -16384..16384 range./// The provided number will be clamped to the -1.0..1.0 range./// Returns the coordinate value as f2.14./// An axis tag name./// An axis value.Variation/// A font variation value./// use ttf_parser::{Variation, Tag};/// Variation { axis: Tag::from_bytes(b"wght"), value: 500.0 };/// A 4-byte tag./// Creates a `Tag` from bytes./// println!("{}", ttf_parser::Tag::from_bytes(b"name"));from_bytes_lossy/// In case of empty data will return `Tag` set to 0./// When `bytes` are shorter than 4, will set missing bytes to ` `./// Data after first 4 bytes is ignored./// Returns tag as 4-element byte array.to_chars/// Checks if tag is null / `[0, 0, 0, 0]`./// Returns tag value as `u32` number./// Line position.thickness/// Line thickness.LineMetrics/// A line metrics./// Used for underline and strikeout.x_miny_minx_maxy_max/// A rectangle./// Doesn't guarantee that `x_min` <= `x_max` and/or `y_min` <= `y_max`./// The horizontal minimum of the rect./// The vertical minimum of the rect./// The horizontal maximum of the rect./// The vertical maximum of the rect.RectF/// A rectangle described by the left-lower and upper-right points.extend_by/// The 'a' component of the transform./// The 'b' component of the transform./// The 'c' component of the transform./// The 'd' component of the transform./// The 'e' component of the transform./// The 'f' component of the transform./// An affine transform./// Creates a new transform with the specified components.new_translate/// Creates a new translation transform.new_rotate/// Creates a new rotation transform.new_skew/// Creates a new skew transform./// Creates a new scale transform./// Combines two transforms with each other.apply_to/// Checks whether a transform is the identity transform./// The X-axis coordinate./// The Y-axis coordinate.PointF/// A float point./// Left side bearing point./// Right side bearing point./// Top side bearing point./// Bottom side bearing point.PhantomPoints/// Phantom points./// Available only for variable fonts with the `gvar` table.RgbaColor/// A RGBA color in the sRGB color space./// Creates a new `RgbaColor`.apply_alpha/// Appends a MoveTo segment./// Start of a contour./// Appends a LineTo segment./// Appends a QuadTo segment./// Appends a CurveTo segment./// Appends a ClosePath segment./// End of a contour./// A trait for glyph outline construction.DummyOutlineRasterImageFormat/// A glyph raster image format./// Horizontal offset./// Vertical offset./// It doesn't guarantee that this value is the same as set in the `data`./// A pixels per em of the selected strike./// An image format./// A raw image data. It's up to the caller to decode it.RasterGlyphImage/// A glyph's raster image./// Note, that glyph metrics are in pixels and not in font units.TableRecord/// A raw table record.MAX_VAR_COORDSVarCoords/// An attempt to read out of bounds detected./// Should occur only on malformed fonts.UnknownMagic/// Face data must start with `0x00010000`, `0x74727565`, `0x4F54544F` or `0x74746366`.FaceIndexOutOfBounds/// The face index is larger than the number of faces in the font.NoHeadTable/// The `head` table is missing or malformed.NoHheaTable/// The `hhea` table is missing or malformed.NoMaxpTable/// The `maxp` table is missing or malformed./// A list of font face parsing errors./// The input font file data.table_records/// An array of table records./// A raw font face./// You are probably looking for [`Face`]. This is a low-level type./// Unlike [`Face`], [`RawFace`] parses only face table records./// Meaning all you can get from this type is a raw (`&[u8]`) data of a requested table./// Then you can either parse just a singe table from a font/face or populate [`RawFaceTables`]/// manually before passing it to [`Face::from_raw_tables`]./// Creates a new [`RawFace`] from a raw data./// `index` indicates the specific font face in a font collection./// Use [`fonts_in_collection`] to get the total number of font faces./// Set to 0 if unsure./// While we do reuse [`FaceParsingError`], `No*Table` errors will not be throws./// Returns the raw data of a selected table.// Mandatory tables.bdatblocebdteblcvmtxRawFaceTables/// A list of all supported tables as raw data./// This type should be used in tandem with/// [`Face::from_raw_tables()`](struct.Face.html#method.from_raw_tables)./// This allows loading font faces not only from TrueType font files,/// but from any source. Mainly used for parsing WOFF.FaceTables/// Parsed face tables./// Unlike [`Face`], provides a low-level parsing abstraction over TrueType tables./// Useful when you need a direct access to tables data./// Also, used when high-level API is problematic to implement./// A good example would be OpenType layout tables (GPOS/GSUB).raw_face// Parsed tables./// A font face./// Provides a high-level API for working with TrueType fonts./// If you're not familiar with how TrueType works internally, you should use this type./// If you do know and want a bit more low-level access - checkout [`FaceTables`]./// Note that `Face` doesn't own the font data and doesn't allocate anything in heap./// Therefore you cannot "store" it. The idea is that you should parse the `Face`/// when needed, get required data and forget about it./// That's why the initial parsing is highly optimized and should not become a bottleneck./// If you still want to store `Face` - checkout/// [owned_ttf_parser](https://crates.io/crates/owned_ttf_parser). Requires `unsafe`./// While `Face` is technically copyable, we disallow it because it's almost 2KB big./// Creates a new [`Face`] from a raw data./// This method will do some parsing and sanitization,/// but in general can be considered free. No significant performance overhead./// Required tables: `head`, `hhea` and `maxp`./// If an optional table has invalid data it will be skipped.collect_tablesfrom_raw_tables/// Creates a new [`Face`] from provided [`RawFaceTables`].parse_tables/// Returns low-level face tables./// Returns the `RawFace` used to create this `Face`./// Useful if you want to parse the data manually./// Available only for faces created using [`Face::parse()`](struct.Face.html#method.parse)./// Returns a list of names./// Contains face name and other strings./// Checks that face is marked as *Regular*./// Returns `false` when OS/2 table is not present./// Checks that face is marked as *Italic*./// Checks that face is marked as *Bold*.is_oblique/// Checks that face is marked as *Oblique*./// Returns `false` when OS/2 table is not present or when its version is < 4./// Returns face style.is_monospaced/// Checks that face is marked as *Monospaced*./// Returns `false` when `post` table is not present./// Checks that face is variable./// Simply checks the presence of a `fvar` table./// Returns face's weight./// Returns `Weight::Normal` when OS/2 table is not present./// Returns face's width./// Returns `Width::Normal` when OS/2 table is not present or when value is invalid./// Returns face's italic angle./// Returns `0.0` when `post` table is not present.ascender/// Returns a horizontal face ascender./// This method is affected by variation axes.descender/// Returns a horizontal face descender./// Returns face's height./// Returns a horizontal face line gap.typographic_ascender/// Returns a horizontal typographic face ascender./// Prefer `Face::ascender` unless you explicitly want this. This is a more/// low-level alternative./// Returns `None` when OS/2 table is not present.typographic_descender/// Returns a horizontal typographic face descender./// Prefer `Face::descender` unless you explicitly want this. This is a moretypographic_line_gap/// Returns a horizontal typographic face line gap./// Prefer `Face::line_gap` unless you explicitly want this. This is a morevertical_ascender/// Returns a vertical face ascender.vertical_descender/// Returns a vertical face descender.vertical_height/// Returns a vertical face height.vertical_line_gap/// Returns a vertical face line gap./// Returns face's units per EM./// Guarantee to be in a 16..=16384 range.x_height/// Returns face's x height./// Returns `None` when OS/2 table is not present or when its version is < 2.capital_height/// Returns face's capital height.underline_metrics/// Returns face's underline metrics./// Returns `None` when `post` table is not present.strikeout_metrics/// Returns face's strikeout metrics.subscript_metrics/// Returns face's subscript metrics.superscript_metrics/// Returns face's superscript metrics./// Returns face permissions./// Returns `None` in case of a malformed value.is_subsetting_allowed/// Checks if the face allows embedding a subset, further restricted by [`Self::permissions`].is_outline_embedding_allowed/// Checks if the face allows outline data to be embedded./// If false, only bitmaps may be embedded in accordance with [`Self::permissions`]./// If the font contains no bitmaps and this flag is not set, it implies no embedding is allowed.unicode_ranges/// Returns [Unicode Ranges](https://docs.microsoft.com/en-us/typography/opentype/spec/os2#ur).number_of_glyphs/// Returns a total number of glyphs in the face./// Never zero./// The value was already parsed, so this function doesn't involve any parsing./// Resolves a Glyph ID for a code point./// Returns `None` instead of `0` when glyph is not found./// All subtable formats except Mixed Coverage (8) are supported./// If you need a more low-level control, prefer `Face::tables().cmap`.glyph_index_by_name/// Resolves a Glyph ID for a glyph name./// Uses the `post` and `CFF` tables as sources./// Returns `None` when no name is associated with a `glyph`./// Resolves a variation of a Glyph ID from two code points./// Implemented according to/// [Unicode Variation Sequences](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences).glyph_hor_advance/// Returns glyph's horizontal advance.glyph_ver_advance/// Returns glyph's vertical advance.glyph_hor_side_bearing/// Returns glyph's horizontal side bearing.glyph_ver_side_bearing/// Returns glyph's vertical side bearing.glyph_y_origin/// Returns glyph's vertical origin according to/// [Vertical Origin Table](https://docs.microsoft.com/en-us/typography/opentype/spec/vorg).glyph_name/// Returns glyph's name./// Outlines a glyph and returns its tight bounding box./// **Warning**: since `ttf-parser` is a pull parser,/// `OutlineBuilder` will emit segments even when outline is partially malformed./// You must check `outline_glyph()` result before using/// `OutlineBuilder`'s output./// `gvar`, `glyf`, `CFF` and `CFF2` tables are supported./// And they will be accesses in this specific order./// Returns `None` when glyph has no outline or on error./// use std::fmt::Write;/// use ttf_parser;/// struct Builder(String);/// impl ttf_parser::OutlineBuilder for Builder {///     fn move_to(&mut self, x: f32, y: f32) {///         write!(&mut self.0, "M {} {} ", x, y).unwrap();///     fn line_to(&mut self, x: f32, y: f32) {///         write!(&mut self.0, "L {} {} ", x, y).unwrap();///     fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {///         write!(&mut self.0, "Q {} {} {} {} ", x1, y1, x, y).unwrap();///     fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {///         write!(&mut self.0, "C {} {} {} {} {} {} ", x1, y1, x2, y2, x, y).unwrap();///     fn close(&mut self) {///         write!(&mut self.0, "Z ").unwrap();/// let data = std::fs::read("tests/fonts/demo.ttf").unwrap();/// let face = ttf_parser::Face::parse(&data, 0).unwrap();/// let mut builder = Builder(String::new());/// let bbox = face.outline_glyph(ttf_parser::GlyphId(1), &mut builder).unwrap();/// assert_eq!(builder.0, "M 173 267 L 369 267 L 270 587 L 173 267 Z M 6 0 L 224 656 \///                        L 320 656 L 541 0 L 452 0 L 390 200 L 151 200 L 85 0 L 6 0 Z ");/// assert_eq!(bbox, ttf_parser::Rect { x_min: 6, y_min: 0, x_max: 541, y_max: 656 });glyph_bounding_box/// Returns a tight glyph bounding box./// This is just a shorthand for `outline_glyph()` since only the `glyf` table stores/// a bounding box. We ignore `glyf` table bboxes because they can be malformed./// In case of CFF and variable fonts we have to actually outline/// a glyph to find it's bounding box./// When a glyph is defined by a raster or a vector image,/// that can be obtained via `glyph_image()`,/// the bounding box must be calculated manually and this method will return `None`./// Note: the returned bbox is not validated in any way. A font file can have a glyph bbox/// set to zero/negative width and/or height and this is perfectly ok./// For calculated bboxes, zero width and/or height is also perfectly fine.global_bounding_box/// Returns a bounding box that large enough to enclose any glyph from the face./// Returns a reference to a glyph's raster image./// A font can define a glyph using a raster or a vector image instead of a simple outline./// Which is primarily used for emojis. This method should be used to access raster images./// `pixels_per_em` allows selecting a preferred image size. The chosen size will/// be closer to an upper one. So when font has 64px and 96px images and `pixels_per_em`/// is set to 72, 96px image will be returned./// To get the largest image simply use `std::u16::MAX`./// Note that this method will return an encoded image. It should be decoded/// by the caller. We don't validate or preprocess it in any way./// Also, a font can contain both: images and outlines. So when this method returns `None`/// you should also try `outline_glyph()` afterwards./// There are multiple ways an image can be stored in a TrueType font/// and this method supports most of them./// This includes `sbix`, `bloc` + `bdat`, `EBLC` + `EBDT`, `CBLC` + `CBDT`./// And font's tables will be accesses in this specific order.SvgDocument/// Returns a reference to a glyph's SVG image./// Which is primarily used for emojis. This method should be used to access SVG images./// Note that this method will return just an SVG data. It should be rendered/// or even decompressed (in case of SVGZ) by the caller./// We don't validate or preprocess it in any way.is_color_glyph/// Returns `true` if the glyph can be colored/painted using the `COLR`+`CPAL` tables./// See [`paint_color_glyph`](Face::paint_color_glyph) for details.color_palettes/// Returns the number of palettes stored in the `COLR`+`CPAL` tables.paint_color_glyphPainter/// Paints a color glyph from the `COLR` table./// A font can have multiple palettes, which you can check via/// [`color_palettes`](Face::color_palettes)./// If unsure, just pass 0 to the `palette` argument, which is the default./// A font can define a glyph using layers of colored shapes instead of a/// simple outline. Which is primarily used for emojis. This method should/// be used to access glyphs defined in the `COLR` table./// Also, a font can contain both: a layered definition and outlines. So/// when this method returns `None` you should also try/// [`outline_glyph`](Face::outline_glyph) afterwards./// Returns `None` if the glyph has no `COLR` definition or if the glyph/// definition is malformed./// See `examples/font2svg.rs` for usage examples.variation_axes/// Returns an iterator over variation axes./// This is one of the two only mutable methods in the library./// We can simplify the API a lot by storing the variable coordinates/// in the face object itself./// Since coordinates are stored on the stack, we allow only 64 of them./// Returns `None` when face is not variable or doesn't have such axis.variation_coordinates/// Returns the current normalized variation coordinates.has_non_default_variation_coordinates/// Checks that face has non-default variation coordinates.glyph_phantom_points/// Parses glyph's phantom points.metrics_var_offsetapply_metrics_variationapply_metrics_variation_to// Read https://github.com/freetype/freetype/blob/49270c17011491227ec7bd3fb73ede4f674aa065/src/sfnt/sfobjs.c#L1279// to learn more about the logic behind the following functions.fonts_in_collection/// Returns the number of fonts stored in a TrueType font collection./// Returns `None` if a provided data is not a TrueType font collection./*!
A high-level, safe, zero-allocation font parser for:
* [TrueType](https://docs.microsoft.com/en-us/typography/truetype/),
* [OpenType](https://docs.microsoft.com/en-us/typography/opentype/spec/), and
* [AAT](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html)
  fonts.

Font parsing starts with a [`Face`].

## Features

- A high-level API for most common properties, hiding all parsing and data resolving logic.
- A low-level, but safe API to access TrueType tables data.
- Highly configurable. You can disable most of the features, reducing binary size.
  You can also parse TrueType tables separately, without loading the whole font/face.
- Zero heap allocations.
- Zero unsafe.
- Zero dependencies.
- `no_std`/WASM compatible.
- Fast.
- Stateless. All parsing methods are immutable.
- Simple and maintainable code (no magic numbers).

## Safety

- The library must not panic. Any panic considered as a critical bug and should be reported.
- The library forbids unsafe code.
- No heap allocations, so crash due to OOM is not possible.
- All recursive methods have a depth limit.
- Technically, should use less than 64KiB of stack in worst case scenario.
- Most of arithmetic operations are checked.
- Most of numeric casts are checked.
*/// we use it for readability/// Object's raw data size./// Not always the same as `mem::size_of`./// Parses an object from a raw data./// A trait for parsing raw binary data of fixed size./// This is a low-level, internal trait that should not be used directly./// A trait for parsing raw binary data of variable size./// A u24 number./// Stored as u32, but encoded as 3 bytes in the font./// <https://docs.microsoft.com/en-us/typography/opentype/spec/otff#data-types>F2DOT14/// A 16-bit signed fixed number with the low 14 bits of fraction (2.14)./// Converts i16 to f32.apply_float_delta/// A 32-bit signed fixed-point number (16.16).num_from/// Converts u32 into usize./// A safe u32 to usize casting./// Rust doesn't implement `From<u32> for usize`,/// because it has to support 16 bit targets./// We don't, so we can allow this.try_num_from/// Casts between numeric types./// Just like TryFrom<N>, but for numeric types not supported by the Rust's std./// A slice-like container that converts internal binary data only on access./// Array values are stored in a continuous data chunk./// Creates a new `LazyArray`./// Returns a value at `index`./// Returns the last value./// Returns sub-array./// Returns array's length./// Checks if array is empty./// Performs a binary search by specified `key`./// Performs a binary search using specified closure./// An iterator over `LazyArray16`./// This is a low-level, internal structure that should not be used directly./// Checks if the array is empty./// An iterator over `LazyArray32`.// Zero offsets must be ignored, therefore we're using `Option<Offset16>`./// A [`LazyArray16`]-like container, but data is accessed by offsets./// Unlike [`LazyArray16`], internal storage is not continuous./// Multiple offsets can point to the same data./// Creates a new `LazyOffsetArray16`./// Parses `LazyOffsetArray16` from raw data.LazyOffsetArrayIter16/// An iterator over [`LazyOffsetArray16`] values./// A streaming binary parser./// Creates a new `Stream` parser./// Creates a new `Stream` parser at offset./// Returns `None` when `offset` is out of bounds./// Checks that stream reached the end of the data.jump_to_end/// Jumps to the end of the stream./// Useful to indicate that we parsed all the data./// Returns the current offset./// Returns the trailing data./// Returns `None` when `Stream` is reached the end./// Advances by `FromData::SIZE`./// Doesn't check bounds./// Advances by the specified `len`.advance_checked/// Advances by the specified `len` and checks for bounds./// Parses the type from the steam./// Returns `None` when there is not enough data left in the stream/// or the type parsing failed./// Parses the type from the steam at offset./// Reads N bytes from the stream.read_array16/// Reads the next `count` types as a slice.read_array32read_at_offset16/// Converts the offset to `usize`./// A common offset methods./// A type-safe u16 offset.Offset24/// A type-safe u24 offset./// A type-safe u32 offset.i16_boundf32_bound//! Binary parsing utils.//! This module should not be used directly, unless you're planning to parse//! some tables manually./// An anchor point.glyphs_data// Ideally, Glyphs Data can be represented as an array,// but Apple's spec doesn't specify that Glyphs Data members have padding or not.// Meaning we cannot simply iterate over them./// An [Anchor Point Table](/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6ankr.html)./// Parses a table from raw data./// Returns a list of anchor points for the specified glyph.read_at_offset32//! An [Anchor Point Table](//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6ankr.html) implementation.from_coordinate/// A normalized coordinate value obtained using default normalization.to_coordinate/// The modified, normalized coordinate value.AxisValueMap/// An axis value map.SegmentMaps/// A list of segment maps./// Can be empty./// The internal data layout is not designed for random access,/// therefore we're not providing the `get()` method and only an iterator./// Returns the number of segments./// Checks if there are any segments.SegmentMapsIter/// An iterator over maps.segment_maps/// The segment maps array — one segment map for each axis/// in the order of axes specified in the `fvar` table./// An [Axis Variations Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/avar).map_coordinate/// Maps a single coordinatemap_value//! An [Axis Variations Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/avar) implementation.BitmapDataFormatMetricsFormat/// A [Color Bitmap Data Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt)./// EBDT and bdat also share the same structure, so this is re-used for them./// Returns a raster image for the glyph.//! A [Color Bitmap Data Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt) implementation.BitmapFormatByteAlignedBitAlignedppemsubtable_array_offsetnumber_of_subtables// Many fields are omitted.BitmapSizeTableselect_bitmap_size_table// absolute offsetIndexSubtableInfoselect_index_subtableGlyphIdOffsetPair/// A [Color Bitmap Location Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cblc)./// EBLC and bloc also share the same structure, so this is re-used for them.//! A [Color Bitmap Location Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/cblc) implementation.// TODO: rewriteArgumentsStackargstackparse_charsetcharstringCharStringParserDictionaryParserparse_encodingSTANDARD_ENCODINGskip_indexstd_namesSTANDARD_NAMEScalc_subroutine_biasconv_subroutine_indexIsEvenMAX_OPERANDS_LEN// Limits according to the Adobe Technical Note #5176, chapter 4 DICT Data.STACK_LIMIT// Limits according to the Adobe Technical Note #5177 Appendix B.MAX_ARGUMENTS_STACK_LENTWO_BYTE_OPERATOR_MARKHORIZONTAL_STEMVERTICAL_STEMVERTICAL_MOVE_TOLINE_TOHORIZONTAL_LINE_TOVERTICAL_LINE_TOCURVE_TOCALL_LOCAL_SUBROUTINEENDCHARHORIZONTAL_STEM_HINT_MASKHINT_MASKCOUNTER_MASKMOVE_TOHORIZONTAL_MOVE_TOVERTICAL_STEM_HINT_MASKCURVE_LINELINE_CURVEVV_CURVE_TOHH_CURVE_TOSHORT_INTCALL_GLOBAL_SUBROUTINEVH_CURVE_TOHV_CURVE_TOHFLEXFLEXHFLEX1FLEX1FIXED_16_16/// Enumerates some operators defined in the Adobe Technical Note #5177.CHARSET_OFFSETENCODING_OFFSETCHAR_STRINGS_OFFSETPRIVATE_DICT_SIZE_AND_OFFSETFONT_MATRIXROSFD_ARRAYFD_SELECTtop_dict_operator/// Enumerates some operators defined in the Adobe Technical Note #5176,/// Table 9 Top DICT Operator EntriesLOCAL_SUBROUTINES_OFFSETDEFAULT_WIDTHNOMINAL_WIDTHprivate_dict_operator/// Table 23 Private DICT OperatorsISO_ADOBEEXPERTEXPERT_SUBSETcharset_id/// Enumerates Charset IDs defined in the Adobe Technical Note #5176, Table 22encoding_id/// Enumerates Charset IDs defined in the Adobe Technical Note #5176, Table 16FontKindSIDMetadataSIDCIDMetadataCIDlocal_subrs/// Can be zero.nominal_widthfd_arrayfd_selectFDSelectcharset_offsetencoding_offsetchar_strings_offsetprivate_dict_rangehas_rosfd_array_offsetfd_select_offsetTopDictparse_top_dictprivate_dict_size_overflowprivate_dict_negative_char_strings_offsetprivate_dict_no_char_strings_offset_operandnegative_private_dict_offset_and_size// TODO: move to integrationlocal_subroutines_offsetPrivateDictparse_private_dictparse_font_dictparse_cid_local_subrs/// In CID fonts, to get local subroutines we have to:///   1. Find Font DICT index via FDSelect by GID.///   2. Get Font DICT data from FDArray using this index.///   3. Get a Private DICT offset from a Font DICT.///   4. Get a local subroutine offset from Private DICT.///   5. Parse a local subroutine at offset.stems_lenhas_endcharhas_seac// Required to parse local subroutine in CID fonts.CharStringParserContextparse_char_string_parse_char_stringseac_code_to_glyph_idFormat0// It's easier to parse it in-place.font_dict_indexparse_fd_selectparse_sid_metadataparse_cid_metadata// The whole CFF table.// Used to resolve a local subroutine in a CID font.global_subrschar_strings/// A [Compact Font Format Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cff)./// Returns a total number of glyphs in the font./// Returns a font transformation matrix./// Outlines a glyph./// Similar to [`Face::glyph_index`](crate::Face::glyph_index) but 8bit/// and uses CFF encoding and charset tables instead of TrueType `cmap`.glyph_width/// Returns a glyph width./// This value is different from outline bbox width and is stored separately./// Technically similar to [`Face::glyph_hor_advance`](crate::Face::glyph_hor_advance)./// Returns a glyph ID by a name./// Returns a glyph name.glyph_cid/// Returns the CID corresponding to a glyph ID./// Returns `None` if this is not a CIDFont.//! A [Compact Font Format Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/cff) implementation.// Useful links:// http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5176.CFF.pdf// http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5177.Type2.pdf// https://github.com/opentypejs/opentype.js/blob/master/src/tables/cff.js// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2#7-top-dict-data// 'Operators in DICT may be preceded by up to a maximum of 513 operands.'// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2charstr#appendix-b-cff2-charstring-implementation-limitsVS_INDEXBLEND// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2charstr#4-charstring-operatorsVARIATION_STORE_OFFSETFONT_DICT_INDEX_OFFSET// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2#table-9-top-dict-operator-entriesfont_dict_operator// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2#table-10-font-dict-operator-entries// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2#table-16-private-dict-operatorsfont_dict_index_offsetvariation_store_offsetTopDictDataSCALARS_MAX/// CFF2 allows up to 65535 scalars, but an average font will have 3-5./// So 64 is more than enough.// 256BScalarsscalarshad_vsindexhad_blendupdate_scalarsitem_variation_storeItemVariationStore/// A [Compact Font Format 2 Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2).//! A [Compact Font Format 2 Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/cff2) implementation.// https://docs.microsoft.com/en-us/typography/opentype/spec/cff2charstrEXPERT_ENCODING/// The Expert Encoding conversion as defined in the Adobe Technical Note #5176 Appendix C.EXPERT_SUBSET_ENCODING/// The Expert Subset Encoding conversion as defined in the Adobe Technical Note #5176 Appendix C.Format1RangeFormat2RangeISOAdobeExpertExpertSubsetsid_to_gidgid_to_sidf32_abshas_move_tois_first_move_towidth_only// Exit right after the glyph width is parsed.parse_move_toparse_horizontal_move_toparse_vertical_move_toparse_line_toparse_horizontal_line_toparse_vertical_line_toparse_curve_toparse_curve_lineparse_line_curveparse_hh_curve_toparse_vv_curve_toparse_hv_curve_toparse_vh_curve_toparse_flexparse_flex1parse_hflexparse_hflex1parse_int1parse_int2parse_int3parse_fixedFLOAT_STACK_LENEND_OF_FLOAT_FLAG// The current offset.operands_offset// Offset to the last operands start.operands// Actual operands.// While CFF can contain only i32 and f32 values, we have to store operands as f64// since f32 cannot represent the whole i32 range.// Meaning we have a choice of storing operands as f64 or as enum of i32/f32.// In both cases the type size would be 8 bytes, so it's easier to simply use f64.operands_len// An amount of operands in the `operands` array.parse_nextparse_operands/// Parses operands of the current operator./// In the DICT structure, operands are defined before an operator./// So we are trying to find an operator first and the we can actually parse the operands./// Since this methods is pretty expensive and we do not care about most of the operators,/// we can speed up parsing by parsing operands only for required operators./// We still have to "skip" operands during operators search (see `skip_number()`),/// but it's still faster that a naive method.parse_rangeis_dict_one_byte_op// One-byte CFF DICT Operators according to the// Adobe Technical Note #5176, Appendix H CFF DICT Encoding.// Adobe Technical Note #5177, Table 3 Operand Encodingparse_float_nibble// Adobe Technical Note #5176, Table 5 Nibble Definitionsskip_number// Just like `parse_number`, but doesn't actually parses the data.parse_dict_number/// The Standard Encoding as defined in the Adobe Technical Note #5176 Appendix B.SupplementEncodingKindsupplementalnew_standardnew_expertcode_to_gidIndexSizeparse_index_implskip_index_imploffset_sizeOffsetSizeVarOffsetsIndexIteroffset_indexSize1Size2Size3Size4parse_offset_sizeNoGlyphReadOutOfBoundsZeroBBoxInvalidOperatorMissingEndCharDataAfterEndCharNestingLimitReachedArgumentsStackLimitReachedInvalidArgumentsStackLengthBboxOverflowMissingMoveToInvalidSubroutineIndexNoLocalSubroutinesInvalidSeacCodeInvalidItemVariationDataIndexInvalidNumberOfBlendOperandsBlendRegionsLimitReached/// A list of errors that can occur during a CFF glyph outlining.bbox/// A type-safe wrapper for string ID.conv_subroutine_index_impl// Adobe Technical Note #5176, Chapter 16 "Local / Global Subrs INDEXes"glyph_ids/// Just a list of 256 8bit glyph IDs.Subtable0/// A [format 0](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-0-byte-encoding-table)/// subtable./// Parses a subtable from raw data./// Returns a glyph index for a code point./// Calls `f` for each codepoint defined in this table.first_code_point/// First character code covered./// Array of glyph indices for the character codes covered.Subtable10/// A [format 10](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-10-trimmed-array)start_char_codeend_char_codeSequentialMapGroupSubtable12/// A [format 12](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-12-segmented-coverage)format12Subtable13/// A [format 13](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-13-segmented-coverage)// https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-13-many-to-one-range-mappingsvar_selectordefault_uvs_offsetnon_default_uvs_offsetVariationSelectorRecordunicode_valueUVSMappingRecordstart_unicode_valueadditional_countUnicodeRangeRecordGlyphVariationResultFound/// Glyph was found in the variation encoding table.UseDefault/// Glyph should be looked in other, non-variation tables./// Basically, you should use `Encoding::glyph_index` or `Face::glyph_index`/// in this case./// A result of a variation glyph mapping.// The whole subtable data.Subtable14/// A [format 14](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences)first_codeentry_countid_deltaid_range_offsetSubHeaderRecordsub_header_keyssub_headers_offsetsub_headersSubtable2/// A [format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-2-high-byte-mapping-through-table)/// Returns `None` when `code_point` is larger than `u16`.codepoints_inner// This table has a pretty complex parsing algorithm.// A detailed explanation can be found here:// https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-2-high-byte-mapping-through-table// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6cmap.html// https://github.com/fonttools/fonttools/blob/a360252709a3d65f899915db0a5bd753007fdbb7/Lib/fontTools/ttLib/tables/_c_m_a_p.py#L360start_codesend_codesid_deltasid_range_offsetsid_range_offset_posSubtable4/// A [format 4](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-4-segment-mapping-to-delta-values)/// First character code of subrange./// Array of glyph indexes for character codes in the range.Subtable6/// A [format 6](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-6-trimmed-table-mapping)format0format10format13format14format2format4format6ByteEncodingTableHighByteMappingThroughTableSegmentMappingToDeltaValuesTrimmedTableMappingMixedCoverageTrimmedArray// unsupportedSegmentedCoverageManyToOneRangeMappingsUnicodeVariationSequences/// A character encoding subtable variant.platform_id/// Subtable platform./// Subtable encoding./// A subtable format./// A character encoding subtable.is_unicode/// Checks that the current encoding is Unicode compatible./// Maps a character to a glyph ID./// This is a low-level method and unlike `Face::glyph_index` it doesn't/// check that the current encoding is Unicode./// It simply maps a `u32` codepoint number to a glyph ID./// Returns `None`:/// - when glyph ID is `0`./// - when format is `MixedCoverage`, since it's not supported./// - when format is `UnicodeVariationSequences`. Use `glyph_variation_index` instead./// Resolves a variation of a glyph ID from two code points./// - when format is not `UnicodeVariationSequences`./// Calls `f` for all codepoints contained in this subtable./// This is a low-level method and it doesn't check that the current/// encoding is Unicode. It simply calls the function `f` for all `u32`/// codepoints that are present in this subtable./// Note that this may list codepoints for which `glyph_index` still returns/// `None` because this method finds all codepoints which were _defined_ in/// this subtable. The subtable may still map them to glyph ID `0`./// Returns without doing anything:/// - when format is `UnicodeVariationSequences`, since it's not supported.EncodingRecordSubtables/// A list of subtables./// Returns a subtable at an index./// Returns the number of subtables./// Checks if there are any subtables.SubtablesIter/// An iterator over [`Subtables`]./// A [Character to Glyph Index Mapping Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cmap)./*!
A [Character to Glyph Index Mapping Table](
https://docs.microsoft.com/en-us/typography/opentype/spec/cmap) implementation.

This module provides a low-level alternative to
[`Face::glyph_index`](../struct.Face.html#method.glyph_index) and
[`Face::glyph_variation_index`](../struct.Face.html#method.glyph_variation_index)
methods.
*/first_layer_indexnum_layersBaseGlyphRecord/// A [base glyph](/// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyph-and-layer-records).ClipBox/// A [ClipBox](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist)./// A paint with a solid color./// A paint with a linear gradient./// A paint with a radial gradient.SweepGradient/// A paint with a sweep gradient./// A paint.clip_box_offset/// The offset to the clip box.ClipRecord/// A [clip record](/// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist).glyphs_range/// Returns the glyphs range.ClipList/// A [clip list](VariationData/// Returns a ClipBox by glyph ID.palette_indexLayerRecord/// A [layer](paint_table_offsetBaseGlyphPaintRecord/// A [BaseGlyphPaintRecord](GradientExtend/// The `Pad` gradient extend mode./// The `Repeat` gradient extend mode./// The `Reflect` gradient extend mode./// A [gradient extend](stop_offsetColorStopRaw/// A [color stop](/// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline).var_index_baseVarColorStopRaw/// A [var color stop](colorspalettesforeground_colorNonVarColorLineColorStop// TODO: Color stops should be sorted, but hard to do without allocationsVarColorLineColorLine/// The offset of the color stop./// The color of the color stop./// The `x0` value./// The `y0` value./// The `x1` value./// The `y1` value./// The `x2` value./// The `y2` value./// The extend.variation_datacolor_line/// A [linear gradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-4-and-5-paintlineargradient-paintvarlineargradient)GradientStopsIter/// Returns an iterator over the stops of the linear gradient. Stops need to be sorted/// manually by the caller./// The `r0` value./// The `r1` value./// A [radial gradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-6-and-7-paintradialgradient-paintvarradialgradient)/// Returns an iterator over the stops of the radial gradient. Stops need to be sorted/// The x of the center./// The y of the center.start_angle/// The start angle.end_angle/// The end angle./// A [sweep gradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-8-and-9-paintsweepgradient-paintvarsweepgradient)// TODO: Make API nicer so that variable coordinates don't// need to be passed by the caller (same for radial and linear gradient)/// Returns an iterator over the stops of the sweep gradient. Stops need to be sorted/// An iterator over stops of a gradient.CompositeMode/// The composite mode 'Clear'./// The composite mode 'Source'./// The composite mode 'Destination'./// The composite mode 'SourceOver'./// The composite mode 'DestinationOver'./// The composite mode 'SourceIn'./// The composite mode 'DestinationIn'./// The composite mode 'SourceOut'./// The composite mode 'DestinationOut'./// The composite mode 'SourceAtop'./// The composite mode 'DestinationAtop'./// The composite mode 'Xor'./// The composite mode 'Plus'./// The composite mode 'Screen'./// The composite mode 'Overlay'./// The composite mode 'Darken'./// The composite mode 'Lighten'./// The composite mode 'ColorDodge'./// The composite mode 'ColorBurn'./// The composite mode 'HardLight'./// The composite mode 'SoftLight'./// The composite mode 'Difference'./// The composite mode 'Exclusion'./// The composite mode 'Multiply'./// The composite mode 'Hue'./// The composite mode 'Saturation'./// The composite mode 'Color'./// The composite mode 'Luminosity'./// A [composite mode](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-32-paintcomposite)/// Outline a glyph and store it./// Paint the stored outline using the provided color.push_clip/// Push a new clip path using the currently stored outline./// Push a new clip path using the clip box./// Pop the last clip path.push_layer/// Push a new layer with the given composite mode.pop_layer/// Pop the last layer./// Push a transform.pop_transform/// Pop the last transform./// A trait for color glyph painting./// See [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr) for details.base_glyphs// v0base_glyph_paints_offset// v1base_glyph_paintslayer_paint_offsets_offsetlayer_paint_offsetsclip_list_offsets_offsetclip_listvar_index_map/// A [Color Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/colr)./// Currently, only version 0 is supported./// Returns `true` if the current table has version 0./// A simple table can only emit `outline_glyph` and `paint`/// [`Painter`] methods.get_v0get_v1/// Whether the table contains a definition for the given glyph.clip_box/// Returns the clip box for a glyph.// This method should only be called from outside, not from within `colr.rs`.// From inside, you always should call paint_impl, so that the recursion stack can// be passed on and any kind of recursion can be prevented./// Paints the color glyph.paint_implRecursionStackpaint_v0paint_v1parse_paintparse_paint_implparse_color_lineparse_var_color_line// The limit of 64 is chosen arbitrarily and not from the spec. But we have to stop somewhere...variation_storedelta_mapread_deltas// Inspired from `fontations`.//! A [Color Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/colr) implementation.// NOTE: Parts of the implementation have been inspired by// [skrifa](https://github.com/googlefonts/fontations/tree/main/skrifa).color_indicesBgraColor/// A [Color Palette Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/cpal)./// Returns the number of palettes./// Returns the color at the given index into the given palette.//! A [Color Palette Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/cpal) implementation.setting_table_records_countsetting_table_offset// Offset from the beginning of the table.default_setting_indexname_indexFeatureNameRecord/// The setting./// The `name` table index for the feature's name in a 256..32768 range./// A setting name./// The feature's ID.setting_names/// The feature's setting names./// The index of the default setting in the `setting_names`./// The feature's exclusive settings. If set, the feature settings are mutually exclusive.FeatureName/// A feature names.FeatureNames/// A list of feature names./// Returns a feature name at an index./// Finds a feature name by ID./// Returns the number of feature names./// Checks if there are any feature names.FeatureNamesIter/// An iterator over [`FeatureNames`]./// A list of feature names. Sorted by `FeatureName.feature`./// A [Feature Name Table](/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html).//! A [Feature Name Table](//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html) implementation.def_value/// An axis name in the `name` table./// A [variation axis](https://docs.microsoft.com/en-us/typography/opentype/spec/fvar#variationaxisrecord).normalized_value/// Returns a normalized variation coordinate for this axis./// A list of variation axes./// A [Font Variations Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/fvar).//! A [Font Variations Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/fvar) implementation.GlyphClassLigature/// A [glyph class](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#glyph-class-definition-table).glyph_classesmark_attach_classesmark_glyph_coverage_offsets/// A [Glyph Definition Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gdef).has_glyph_classes/// Checks that face has/// [Glyph Class Definition Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#glyph-class-definition-table).glyph_class/// Returns glyph's class according to/// Returns `None` when *Glyph Class Definition Table* is not set/// or glyph class is not set or invalid.glyph_mark_attachment_class/// Returns glyph's mark attachment class according to/// [Mark Attachment Class Definition Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#mark-attachment-class-definition-table)./// All glyphs not assigned to a class fall into Class 0.is_mark_glyph/// Checks that glyph is a mark according to/// [Mark Glyph Sets Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#mark-glyph-sets-table)./// `set_index` allows checking a specific glyph coverage set./// Otherwise all sets will be checked.glyph_variation_delta/// Returns glyph's variation delta at a specified index according to/// [Item Variation Store Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gdef#item-variation-store-table).is_mark_glyph_impl//! A [Glyph Definition Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/gdef) implementation.is_default_ts// `bool` is faster than `Option` or `is_default`.// We have to always calculate the bbox, because `gvar` doesn't store one// and in case of a malformed bbox in `glyf`.first_on_curvefirst_off_curvelast_off_curvepush_point// - https://developer.apple.com/fonts/TrueType-Reference-Manual/RM01/Chap1.html// - https://stackoverflow.com/a/20772557CompositeGlyphFlagsCompositeGlyphInfoCompositeGlyphIteron_curve_point/// Indicates that a point is a point on curve/// and not a control point.GlyphPoint// Due to some optimization magic, using f32 instead of i16// makes the code ~10% slower. At least on my machine.// I guess it's due to the fact that with i16 the struct// fits into the machine word.EndpointsIterFlagsIterx_coordsCoordsItery_coordspoints_left// Number of points left in the glyph.GlyphPointsItercurrent_contour// Each endpoint indicates a contour end./// A simple flattening iterator for glyph's endpoints./// Translates endpoints like: 2 4 7/// into flags: 0 0 1 0 1 0 0 1// Number of times the `flags` should be used// before reading the next one from `stream`.SimpleGlyphFlags// Points are stored as deltas, so we have to keep the previous one.// https://docs.microsoft.com/en-us/typography/opentype/spec/glyf#simple-glyph-descriptionx_shorty_shortrepeat_flagx_is_same_or_positive_shorty_is_same_or_positive_short// https://docs.microsoft.com/en-us/typography/opentype/spec/glyf#composite-glyph-descriptionarg_1_and_2_are_wordsargs_are_xy_valueswe_have_a_scalemore_componentswe_have_an_x_and_y_scalewe_have_a_two_by_two// It's not defined in the spec, so we are using our own value.outline_implparse_simple_outlineresolve_coords_len/// Resolves coordinate arrays length./// The length depends on *Simple Glyph Flags*, so we have to process them all to find it.loca_table/// A [Glyph Data Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/glyf)./// The bounding box of the glyph. Unlike the `outline` method, this method does not/// calculate the bounding box manually by outlining the glyph, but instead uses the/// bounding box in the `glyf` program. As a result, this method will be much faster,/// but the bounding box could be more inaccurate.outline_points/// Returns the number of points in this outline.outline_points_impl//! A [Glyph Data Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/glyf) implementation.start_sizeend_sizedelta_formatHintingDevice/// A [Device Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#devVarIdxTbls)/// hinting values.x_delta/// Returns X-axis delta.y_delta/// Returns Y-axis delta.outer_indexinner_indexVariationDevice/// A [Device Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#devVarIdxTbls)/// indexes into [Item Variation Store](/// https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#IVS)./// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#devVarIdxTbls).ValueFormatFlagsx_placementy_placementx_placement_devicey_placement_devicex_advance_devicey_advance_device// The ValueRecord struct constrain either i16 values or Offset16 offsets// and the total size depend on how many flags are enabled./// Horizontal adjustment for placement, in design units./// Vertical adjustment for placement, in design units./// Horizontal adjustment for advance, in design units — only used for horizontal layout./// Vertical adjustment for advance, in design units — only used for vertical layout./// A [`Device`] table with horizontal adjustment for placement./// A [`Device`] table with vertical adjustment for placement./// A [`Device`] table with horizontal adjustment for advance./// A [`Device`] table with vertical adjustment for advance.ValueRecord/// A [Value Record](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#value-record).// Returns `None` only on parsing error.// We have to store the original table data because ValueRecords can have// a offset to Device tables and offset is from the beginning of the table.// A slice that contains all ValueRecords.// Number of records.// Size of the single record.// Flags, used during ValueRecord parsing.ValueRecordsArray/// An array of/// [Value Records](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#value-record)./// Returns a [`ValueRecord`] at index.SingleAdjustment/// A [Single Adjustment Positioning Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#SP).record_lenPairSet/// A [`ValueRecord`] pairs set used by [`PairAdjustment`]./// Returns a [`ValueRecord`] pair using the second glyph.PairSets/// A list of [`PairSet`]s.// We have to store table's original slice,// because offsets in ValueRecords are from the begging of the table.ClassMatrix/// A [`ValueRecord`] pairs matrix used by [`PairAdjustment`]./// Returns a [`ValueRecord`] pair using specified classes.PairAdjustment/// A [Pair Adjustment Positioning Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#PP).entry_anchor_offsetexit_anchor_offsetEntryExitRecordCursiveAnchorSet/// A list of entry and exit [`Anchor`] pairs./// Returns an entry [`Anchor`] at index./// Returns an exit [`Anchor`] at index./// Returns the number of items./// Checks if the set is empty.CursiveAdjustment/// A [Cursive Attachment Positioning Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#CAP).mark_coverage/// A mark coverage.base_coverage/// A base coverage.MarkArray/// A list of mark anchors.AnchorMatrix/// An anchors matrix.MarkToBaseAdjustment/// A [Mark-to-Base Attachment Positioning Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#MBP).ligature_coverageligature_arrayLigatureArrayMarkToLigatureAdjustment/// A [Mark-to-Ligature Attachment Positioning Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#MLP).class_count/// An array or ligature anchor matrices./// Returns an [`AnchorMatrix`] at index./// Returns the array length.mark_anchorMarkRecord/// A [Mark Array](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#mark-array-table)./// Returns contained data at index./// Horizontal value, in design units./// Vertical value, in design units.x_device/// A [`Device`] table with horizontal value.y_device/// A [`Device`] table with vertical value./// An [Anchor Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#anchor-tables)./// The *Anchor Table Format 2: Design Units Plus Contour Point* is not supported./// Number of rows in the matrix./// Number of columns in the matrix./// An [`Anchor`] parsing helper./// Returns an [`Anchor`] at position.mark1_coveragemark2_coveragemark2_matrixMarkToMarkAdjustment/// A [Mark-to-Mark Attachment Positioning Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#MMP).PositioningSubtableMarkToBaseMarkToLigatureMarkToMarkChainContext/// A glyph positioning/// [lookup subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#table-organization)//! A [Glyph Positioning Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos)// Essentially a `LazyOffsetArray16` but stores additional data required to parse [`PairSet`].SingleSubstitutionsubstitutes/// A [Single Substitution Subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#SS)./// A list of substitute glyphs./// A sequence of glyphs for/// [Multiple Substitution Subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#MS).SequenceList/// A list of [`Sequence`] tables.MultipleSubstitution/// A [Multiple Substitution Subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#MS)./// Array of alternate glyph IDs, in arbitrary order.AlternateSet/// A list of glyphs for/// [Alternate Substitution Subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#AS).AlternateSets/// A set of [`AlternateSet`].alternate_setsAlternateSubstitution/// A [Alternate Substitution Subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#AS)./// Ligature to substitute./// Glyph components for one ligature.LigatureSet/// A [`Ligature`] set.LigatureSets/// A list of [`Ligature`] sets.ligature_setsLigatureSubstitution/// A [Ligature Substitution Subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#LS).ReverseChainSingleSubstitution/// A [Reverse Chaining Contextual Single Substitution Subtable](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#RCCS).SubstitutionSubtableReverseChainSingle/// A glyph substitution/// [lookup subtable](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#table-organization)/// Checks that the current subtable is *Reverse Chaining Contextual Single*.//! A [Glyph Substitution Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gsub)PHANTOM_POINTS_LEN/// 'The TrueType rasterizer dynamically generates 'phantom' points for each glyph/// that represent horizontal and vertical advance widths and side bearings,/// and the variation data within the `gvar` table includes data for these phantom points.'/// We don't actually use them, but they are required during deltas parsing.GlyphVariationDataOffsetsPointAndDeltaset_pointsSetPointsIterPackedDeltasIterprev_point/// The last parsed point with delta in the contour./// Used during delta resolving.VariationTuple// This structure will be used by the `VariationTuples` stack buffer,// so it has to be as small as possible.MAX_STACK_TUPLES_LEN/// The maximum number of variation tuples stored on the stack./// The TrueType spec allows up to 4095 tuples, which is way larger/// than we do. But in reality, an average font will have less than 10 tuples./// We can avoid heap allocations if the number of tuples is less than this number.VariationTuples/// A list of variation tuples, possibly stored on the heap./// This is the only part of the `gvar` algorithm that actually allocates a data./// This is probably unavoidable due to `gvar` structure,/// since we have to iterate all tuples in parallel./// Attempt to reserve up to `capacity` total slots for variation tuples./// Get the number of tuples stored in the structure./// Append a new tuple header to the list./// This may panic if the list can't hold a new header./// Remove all tuples from the structure.apply_null// This is just like `apply()`, but without `infer_deltas`,// since we use it only for component points and not a contour.// And since there are no contour and no points, `infer_deltas()` will do nothing.has_private_point_numbersserialized_data_lenTupleVariationHeaderDataparse_variation_tuplesPackedPointsIter// https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuplevariationheaderparse_tuple_variation_headerPOINTS_ARE_WORDS_FLAGPOINT_RUN_COUNT_MASKis_points_are_wordsrun_count// 'Mask for the low 7 bits to provide the number of point values in the run, minus one.'// So we have to add 1.// It will never overflow because of a mask.ShortPointLongPoint// u16 is enough, since the maximum number of points is 32767.// Therefore we cannot use `Stream` and other abstractions.// The first Option::None indicates a parsing error.// The second Option::None indicates "no points".unref_count// The `PackedPointsIter` will return referenced point numbers as deltas.// i.e. 1 2 4 is actually 1 3 7// But this is not very useful in our current algorithm,// so we will convert it once again into:// false true false true false false false true// This way we can iterate glyph points and point numbers in parallel.deltas_are_wordsNewControlgen_controlsingle_zero_controlsingle_pointset_0_and_2set_1_and_2set_1_and_3set_2_5_7more_than_127_pointslong_pointsmultiple_runsruns_overflowpacked_points// https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#packed-point-numbersDELTAS_ARE_ZERO_FLAGDELTAS_ARE_WORDS_FLAGDELTA_RUN_COUNT_MASKis_deltas_are_zerois_deltas_are_words// 'Mask for the low 6 bits to provide the number of delta values in the run, minus one.'ZeroDeltaShortDeltaLongDeltarun_deltas_leftRunStatex_runy_run/// A total number of deltas per axis./// Required only by restart()/// `count` indicates a number of delta pairs.deltas_are_zerosingle_deltatwo_deltassingle_long_deltazeroszero_wordszero_runsdelta_after_zerosunexpected_end_of_data_1unexpected_end_of_data_2unexpected_end_of_data_3unexpected_end_of_data_4unexpected_end_of_data_6unexpected_end_of_data_7single_runtoo_many_pairsinvalid_number_of_pairsmixed_runsnon_default_scalarpacked_deltas// https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#packed-deltasinfer_deltas// A points iterator that starts after the current point.// A points iterator that starts from the first point in the glyph./// Infer unreferenced deltas./// A font can define deltas only for specific points, to reduce the file size./// In this case, we have to infer undefined/unreferenced deltas manually,/// depending on the context./// This is already a pretty complex task, since deltas should be resolved/// only inside the current contour (do not confuse with component)./// And during resolving we can actually wrap around the contour./// So if there is no deltas after the current one, we have to use/// the first delta of the current contour instead./// Same goes for the previous delta. If there are no deltas/// before the current one, we have to use the last one in the current contour./// And in case of `ttf-parser` everything is becoming even more complex,/// since we don't actually have a list of points and deltas, only iterators./// Because of `ttf-parser`'s allocation free policy./// Which makes the code even more complicated./// https://docs.microsoft.com/en-us/typography/opentype/spec/gvar#inferred-deltas-for-un-referenced-point-numbersinfer_deltaaxis_countshared_tuple_recordsglyphs_variation_data/// A [Glyph Variations Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/gvar).parse_variation_dataphantom_pointsoutline_var_impl// https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuple-variation-store-header//! A [Glyph Variations Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/gvar) implementation.// https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuple-variation-store// We do have to call clone for readability on some types./// An index format used by the [Index to Location Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/loca)./// Units per EM.global_bbox/// A bounding box that large enough to enclose any glyph from the face.index_to_location_format/// A [Font Header Table](https://docs.microsoft.com/en-us/typography/opentype/spec/head).//! A [Font Header Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/head) implementation./// Face ascender./// Face descender./// Face line gap.number_of_metrics/// Number of metrics in the `hmtx` table./// A [Horizontal Header Table](https://docs.microsoft.com/en-us/typography/opentype/spec/hhea).//! A [Horizontal Header Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/hhea) implementation./// Width/Height advance for `hmtx`/`vmtx`.side_bearing/// Left/Top side bearing for `hmtx`/`vmtx`./// Horizontal/Vertical Metrics./// A list of metrics indexed by glyph ID.bearings/// Side bearings for glyph IDs greater than or equal to the number of `metrics` values./// Sum of long metrics + bearings./// A [Horizontal/Vertical Metrics Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/hmtx)./// `hmtx` and `vmtx` tables has the same structure, so we're reusing the same struct for both./// - `number_of_metrics` is from the `hhea`/`vhea` table./// - `number_of_glyphs` is from the `maxp` table./// Returns advance for a glyph./// Returns side bearing for a glyph.//! A [Horizontal/Vertical Metrics Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/hmtx) implementation.advance_width_mapping_offsetlsb_mapping_offsetrsb_mapping_offset/// A [Horizontal Metrics Variations Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/hvar).advance_offset/// Returns the advance width offset for a glyph.left_side_bearing_offset/// Returns the left side bearing offset for a glyph.right_side_bearing_offset/// Returns the right side bearing offset for a glyph.side_bearing_offset//! A [Horizontal Metrics Variations Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/hvar) implementation.OTCoverageis_horizontalhas_cross_streamAATCoverage/// Glyphs pair./// In the kern table spec, a kerning pair is stored as two u16,/// but we are using one u32, so we can binary search it directly./// Kerning value.KerningPair/// A kerning pair./// Returns left glyph ID./// Returns right glyph ID.Subtable3/// A kerning subtable format./// Indicates that subtable is for horizontal text./// Indicates that subtable is variable./// Indicates that subtable has a cross-stream values.has_state_machine/// Indicates that subtable uses a state machine./// In this case `glyphs_kerning()` will return `None`./// Subtable format./// A kerning subtable.glyphs_kerning/// Returns kerning for a pair of glyphs./// Returns `None` in case of state machine based subtable.is_aat/// Indicates an Apple Advanced Typography format./// The total number of tables./// Actual data. Starts right after the `kern` header.table_index/// The current table index,number_of_tables/// Actual data. Starts right after `kern` header./// An iterator over kerning subtables./// A list of kerning pairs./// A format 0 subtable./// Ordered List of Kerning Pairs.// TODO: parse actual structure/// A format 2 subtable./// Simple n x m Array of Kerning Values.get_format2_class/// A format 3 subtable./// Simple n x m Array of Kerning Indices./// A [Kerning Table](https://docs.microsoft.com/en-us/typography/opentype/spec/kern)./*!
A [Kerning Table](
https://docs.microsoft.com/en-us/typography/opentype/spec/kern) implementation.

Supports both
[OpenType](https://docs.microsoft.com/en-us/typography/opentype/spec/kern)
and
[Apple Advanced Typography](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kern.html)
variants.

Since there is no single correct way to process a kerning data,
we have to provide an access to kerning subtables, so a caller can implement
a kerning algorithm manually.
But we still try to keep the API as high-level as possible.
*//// The same as in `kern`, but uses `LazyArray32` instead of `LazyArray16`.action_index/// An action index./// A state machine entry.state_table/// A state table.actions_dataSubtable1/// A format 1 subtable./// State Table for Contextual Kerning./// Returns kerning at action index./// The same as in `kern`, but uses 32bit offsets instead of 16bit one.AnchorPoints/// A container of Anchor Points used by [`Subtable4`]./// Returns a mark and current anchor points at action index.anchor_points/// Anchor points./// A format 4 subtable./// State Table for Control Point/Anchor Point Positioning./// Note: I wasn't able to find any fonts that actually use/// `ControlPointActions` and/or `ControlPointCoordinateActions`,/// therefore only `AnchorPointActions` is supported./// A format 6 subtable./// Simple Index-based n x m Array of Kerning Values./// An extended kerning subtable format.tuple_count/// The tuple count./// This value is only used with variation fonts and should be 0 for all other fonts.// TODO: use hex/// The number of glyphs from the `maxp` table./// Actual data. Starts right after the `kerx` header./// A list of extended kerning subtables./// The current table index./// An iterator over extended kerning subtables./// An [Extended Kerning Table](/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kerx.html).//! An [Extended Kerning Table](//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kerx.html) implementation.// TODO: find a way to test this table// This table is basically untested because it uses Apple's State Tables// and I have no idea how to generate them./// Short offsets./// Long offsets./// An [Index to Location Table](https://docs.microsoft.com/en-us/typography/opentype/spec/loca)./// - `format` is from the `head` table./// Returns the number of offsets./// Checks if there are any offsets.glyph_range/// Returns glyph's range in the `glyf` table.//! An [Index to Location Table](https://docs.microsoft.com/en-us/typography/opentype/spec/loca)/// The X or Y value in font design units./// Device corrections for this value.MathValue/// A [Math Value](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathvaluerecord)/// with optional device corrections.MathValueRecord/// A math value record with unresolved offset.MathValues/// A mapping from glyphs to/// [Math Values](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathvaluerecord)./// Returns the value for the glyph or `None` if it is not covered.Constants/// A [Math Constants Table](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathconstants-table).SCRIPT_PERCENT_SCALE_DOWN_OFFSETSCRIPT_SCRIPT_PERCENT_SCALE_DOWN_OFFSETDELIMITED_SUB_FORMULA_MIN_HEIGHT_OFFSETDISPLAY_OPERATOR_MIN_HEIGHT_OFFSETMATH_LEADING_OFFSETAXIS_HEIGHT_OFFSETACCENT_BASE_HEIGHT_OFFSETFLATTENED_ACCENT_BASE_HEIGHT_OFFSETSUBSCRIPT_SHIFT_DOWN_OFFSETSUBSCRIPT_TOP_MAX_OFFSETSUBSCRIPT_BASELINE_DROP_MIN_OFFSETSUPERSCRIPT_SHIFT_UP_OFFSETSUPERSCRIPT_SHIFT_UP_CRAMPED_OFFSETSUPERSCRIPT_BOTTOM_MIN_OFFSETSUPERSCRIPT_BASELINE_DROP_MAX_OFFSETSUB_SUPERSCRIPT_GAP_MIN_OFFSETSUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT_OFFSETSPACE_AFTER_SCRIPT_OFFSETUPPER_LIMIT_GAP_MIN_OFFSETUPPER_LIMIT_BASELINE_RISE_MIN_OFFSETLOWER_LIMIT_GAP_MIN_OFFSETLOWER_LIMIT_BASELINE_DROP_MIN_OFFSETSTACK_TOP_SHIFT_UP_OFFSETSTACK_TOP_DISPLAY_STYLE_SHIFT_UP_OFFSETSTACK_BOTTOM_SHIFT_DOWN_OFFSETSTACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN_OFFSETSTACK_GAP_MIN_OFFSETSTACK_DISPLAY_STYLE_GAP_MIN_OFFSETSTRETCH_STACK_TOP_SHIFT_UP_OFFSETSTRETCH_STACK_BOTTOM_SHIFT_DOWN_OFFSETSTRETCH_STACK_GAP_ABOVE_MIN_OFFSETSTRETCH_STACK_GAP_BELOW_MIN_OFFSETFRACTION_NUMERATOR_SHIFT_UP_OFFSETFRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP_OFFSETFRACTION_DENOMINATOR_SHIFT_DOWN_OFFSETFRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN_OFFSETFRACTION_NUMERATOR_GAP_MIN_OFFSETFRACTION_NUM_DISPLAY_STYLE_GAP_MIN_OFFSETFRACTION_RULE_THICKNESS_OFFSETFRACTION_DENOMINATOR_GAP_MIN_OFFSETFRACTION_DENOM_DISPLAY_STYLE_GAP_MIN_OFFSETSKEWED_FRACTION_HORIZONTAL_GAP_OFFSETSKEWED_FRACTION_VERTICAL_GAP_OFFSETOVERBAR_VERTICAL_GAP_OFFSETOVERBAR_RULE_THICKNESS_OFFSETOVERBAR_EXTRA_ASCENDER_OFFSETUNDERBAR_VERTICAL_GAP_OFFSETUNDERBAR_RULE_THICKNESS_OFFSETUNDERBAR_EXTRA_DESCENDER_OFFSETRADICAL_VERTICAL_GAP_OFFSETRADICAL_DISPLAY_STYLE_VERTICAL_GAP_OFFSETRADICAL_RULE_THICKNESS_OFFSETRADICAL_EXTRA_ASCENDER_OFFSETRADICAL_KERN_BEFORE_DEGREE_OFFSETRADICAL_KERN_AFTER_DEGREE_OFFSETRADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSETscript_percent_scale_down/// Percentage of scaling down for level 1 superscripts and subscripts.script_script_percent_scale_down/// Percentage of scaling down for level 2 (scriptScript) superscripts and subscripts.delimited_sub_formula_min_height/// Minimum height required for a delimited expression (contained within parentheses, etc.) to/// be treated as a sub-formula.display_operator_min_height/// Minimum height of n-ary operators (such as integral and summation) for formulas in display/// mode (that is, appearing as standalone page elements, not embedded inline within text).math_leading/// White space to be left between math formulas to ensure proper line spacing.axis_height/// Axis height of the font.accent_base_height/// Maximum (ink) height of accent base that does not require raising the accents.flattened_accent_base_height/// Maximum (ink) height of accent base that does not require flattening the accents.subscript_shift_down/// The standard shift down applied to subscript elements.subscript_top_max/// Maximum allowed height of the (ink) top of subscripts that does not require moving/// subscripts further down.subscript_baseline_drop_min/// Minimum allowed drop of the baseline of subscripts relative to the (ink) bottom of thesuperscript_shift_up/// Standard shift up applied to superscript elements.superscript_shift_up_cramped/// Standard shift of superscripts relative to the base, in cramped style.superscript_bottom_min/// Minimum allowed height of the (ink) bottom of superscripts that does not require moving/// subscripts further up.superscript_baseline_drop_max/// Maximum allowed drop of the baseline of superscripts relative to the (ink) top of thesub_superscript_gap_min/// Minimum gap between the superscript and subscript ink.superscript_bottom_max_with_subscript/// The maximum level to which the (ink) bottom of superscript can be pushed to increase the/// gap between superscript and subscript, before subscript starts being moved down.space_after_script/// Extra white space to be added after each subscript and superscript.upper_limit_gap_min/// Minimum gap between the (ink) bottom of the upper limit, and the (ink) top of the baseupper_limit_baseline_rise_min/// Minimum distance between baseline of upper limit and (ink) top of the base operator.lower_limit_gap_min/// Minimum gap between (ink) top of the lower limit, and (ink) bottom of the base operator.lower_limit_baseline_drop_min/// Minimum distance between baseline of the lower limit and (ink) bottom of the base operator.stack_top_shift_up/// Standard shift up applied to the top element of a stack.stack_top_display_style_shift_up/// Standard shift up applied to the top element of a stack in display style.stack_bottom_shift_down/// Standard shift down applied to the bottom element of a stack.stack_bottom_display_style_shift_down/// Standard shift down applied to the bottom element of a stack in display style.stack_gap_min/// Minimum gap between (ink) bottom of the top element of a stack, and the (ink) top of the/// bottom element.stack_display_style_gap_min/// bottom element in display style.stretch_stack_top_shift_up/// Standard shift up applied to the top element of the stretch stack.stretch_stack_bottom_shift_down/// Standard shift down applied to the bottom element of the stretch stack.stretch_stack_gap_above_min/// Minimum gap between the ink of the stretched element, and the (ink) bottom of the element above.stretch_stack_gap_below_min/// Minimum gap between the ink of the stretched element, and the (ink) top of the element below.fraction_numerator_shift_up/// Standard shift up applied to the numerator.fraction_numerator_display_style_shift_up/// Standard shift up applied to the numerator in display style.fraction_denominator_shift_down/// Standard shift down applied to the denominator.fraction_denominator_display_style_shift_down/// Standard shift down applied to the denominator in display style.fraction_numerator_gap_min/// Minimum tolerated gap between the (ink) bottom of the numerator and the ink of the/// fraction bar.fraction_num_display_style_gap_min/// fraction bar in display style.fraction_rule_thickness/// Thickness of the fraction bar.fraction_denominator_gap_min/// Minimum tolerated gap between the (ink) top of the denominator and the ink of the fraction bar.fraction_denom_display_style_gap_min/// Minimum tolerated gap between the (ink) top of the denominator and the ink of the fraction/// bar in display style.skewed_fraction_horizontal_gap/// Horizontal distance between the top and bottom elements of a skewed fraction.skewed_fraction_vertical_gap/// Vertical distance between the ink of the top and bottom elements of a skewed fraction.overbar_vertical_gap/// Distance between the overbar and the (ink) top of he base.overbar_rule_thickness/// Thickness of overbar.overbar_extra_ascender/// Extra white space reserved above the overbar.underbar_vertical_gap/// Distance between underbar and (ink) bottom of the base.underbar_rule_thickness/// Thickness of underbar.underbar_extra_descender/// Extra white space reserved below the underbar.radical_vertical_gap/// Space between the (ink) top of the expression and the bar over it.radical_display_style_vertical_gapradical_rule_thickness/// Thickness of the radical rule.radical_extra_ascender/// Extra white space reserved above the radical.radical_kern_before_degree/// Extra horizontal kern before the degree of a radical, if such is present.radical_kern_after_degree/// Negative kern after the degree of a radical, if such is present.radical_degree_bottom_raise_percent/// Height of the bottom of the radical degree, if such is present, in proportion to the/// ascender of the radical sign./// Read an `i16` at an offset into the table./// Read an `u16` at an offset into the table.read_record/// Read a `MathValueRecord` at an offset into the table.heightskernsKern/// A [Math Kern Table](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathkern-table)./// Number of heights at which the kern value changes./// The correction height at the given index./// The index must be smaller than `count()`./// The kern value at the given index./// The index must be smaller than or equal to `count()`.top_righttop_leftbottom_rightbottom_leftKernInfoRecordKernInfo/// The kerning data for the top-right corner./// The kerning data for the top-left corner./// The kerning data for the bottom-right corner./// The kerning data for the bottom-left corner./// An [entry in a Math Kern Info Table](/// https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathkerninforecord).KernInfos/// A [Math Kern Info Table](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathkerninfo-table)./// Returns the kerning info for the glyph or `None` if it is not covered.italic_corrections/// Per-glyph italics correction values.top_accent_attachments/// Per-glyph horizontal positions for attaching mathematical accents.extended_shapes/// Glyphs which are _extended shapes_.kern_infos/// Per-glyph information for mathematical kerning./// A [Math Glyph Info Table](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathglyphinfo-table).PartFlags/// Glyph part flags.extender/// Glyph ID for the part.start_connector_length/// Lengths of the connectors on the start of the glyph, in font design units.end_connector_length/// Lengths of the connectors on the end of the glyph, in font design units.full_advance/// The full advance of the part, in font design units.part_flags/// Part flags.GlyphPart/// Details for a glyph part in an assembly.italics_correction/// The italics correction of the assembled glyph./// Parts the assembly is composed of.GlyphAssembly/// A [Glyph Assembly Table](https://learn.microsoft.com/en-us/typography/opentype/spec/math#glyphassembly-table).variant_glyph/// The ID of the variant glyph.advance_measurement/// Advance width/height, in design units, of the variant glyph.GlyphVariant/// Description of math glyph variants.assembly/// A general recipe on how to construct a variant with large advance width/height./// Prepared variants of the glyph with varying advances.GlyphConstruction/// A [Math Glyph Construction Table](/// https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathglyphconstruction-table).constructionsGlyphConstructions/// [Math Glyph Construction Tables](/// Returns the construction for the glyph or `None` if it is not covered.min_connector_overlap/// Minimum overlap of connecting glyphs during glyph construction, in design units.vertical_constructions/// Constructions for shapes growing in the vertical direction.horizontal_constructions/// Constructions for shapes growing in the horizontal direction./// A [Math Variants Table](/// https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathvariants-table)./// Math positioning constants./// Per-glyph positioning information./// Variants and assembly recipes for growable glyphs./// A [Math Table](https://docs.microsoft.com/en-us/typography/opentype/spec/math).parse_at_offset16//! A [Math Table](https://docs.microsoft.com/en-us/typography/opentype/spec/math) implementation./// The total number of glyphs in the face./// A [Maximum Profile Table](https://docs.microsoft.com/en-us/typography/opentype/spec/maxp).//! A [Maximum Profile Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/maxp) implementation./// The type of feature./// The feature's setting (aka selector).enable_flags/// Flags for the settings that this feature and setting enables.disable_flags/// Complement of flags for the settings that this feature and setting disable./// The feature table is used to compute the sub-feature flags/// for a list of requested features and settings.mark_index/// A mark index./// A current index.ContextualEntryData/// A contextual subtable state table trailing data./// The contextual glyph substitution state table.offsets_dataContextualSubtable/// A contextual subtable./// Returns a [Lookup](aat::Lookup) at index.ligature_actions/// Ligature actions./// Ligature components.ligatures/// Ligatures.LigatureSubtable/// A ligature subtable.current_insert_index/// A current insert index.marked_insert_index/// A marked insert index.InsertionEntryData/// Insertion glyphs.InsertionSubtable/// An insertion subtable.SubtableKindRearrangementContextualNonContextualInsertion/// A subtable kind./// A subtable coverage.is_logical/// If true, this subtable will process glyphs in logical order/// (or reverse logical order if [`is_vertical`](Self::is_vertical) is also true).is_all_directions/// If true, this subtable will be applied to both horizontal and vertical text/// ([`is_vertical`](Self::is_vertical) should be ignored).is_backwards/// If true, this subtable will process glyphs in descending order./// If true, this subtable will only be applied to vertical text.feature_flags/// Subtable feature flags./// A subtable in a metamorphosis chain./// A list of subtables in a metamorphosis chain./// An iterator over a metamorphosis chain subtables.default_flags/// Default chain features./// A list of chain features./// A list of chain subtables./// A metamorphosis chain.Chains/// A list of metamorphosis chains.ChainsIter/// An iterator over metamorphosis chains./// An [Extended Glyph Metamorphosis Table](/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html)./// Subtable Glyph Coverage used by morx v3 is not supported.//! An [Extended Glyph Metamorphosis Table](//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html) implementation.// Note: We do not have tests for this table because it has a very complicated structure.// Specifically, the State Machine Tables. I have no idea how to generate them.// And all fonts that use this table are mainly Apple one, so we cannot use them for legal reasons.// On the other hand, this table is tested indirectly by https://github.com/harfbuzz/rustybuzz// And it has like 170 tests. Which is pretty good.// Therefore after applying any changes to this table,// you have to check that all rustybuzz tests are still passing.value_tagdelta_set_outer_indexdelta_set_inner_index/// A [Metrics Variations Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/mvar).metric_offset/// Returns a metric offset by tag.//! A [Metrics Variations Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/mvar) implementation.COPYRIGHT_NOTICESUBFAMILYUNIQUE_IDFULL_NAMEPOST_SCRIPT_NAMETRADEMARKMANUFACTURERDESIGNERVENDOR_URLDESIGNER_URLLICENSELICENSE_URLTYPOGRAPHIC_FAMILY//        RESERVED                                  = 15TYPOGRAPHIC_SUBFAMILYCOMPATIBLE_FULLSAMPLE_TEXTPOST_SCRIPT_CIDWWS_FAMILYWWS_SUBFAMILYLIGHT_BACKGROUND_PALETTEDARK_BACKGROUND_PALETTEVARIATIONS_POST_SCRIPT_NAME_PREFIX/// A list of [name ID](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids)'s.Macintosh/// A [platform ID](https://docs.microsoft.com/en-us/typography/opentype/spec/name#platform-ids).is_unicode_encodinglanguage_idNameRecord/// A platform ID./// A platform-specific encoding ID./// A language ID./// A [Name ID](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids)./// A predefined list of ID's can be found in the [`name_id`](name_id/index.html) module./// A raw name data./// Can be in any encoding. Can be empty./// A [Name Record](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-records)./// Returns the Name's data as a UTF-8 string./// Only Unicode names are supported. And since they are stored as UTF-16BE,/// we can't return `&str` and have to allocate a `String`./// Supports:/// - Unicode Platform ID/// - Windows Platform ID + Symbol/// - Windows Platform ID + Unicode BMP/// Checks that the current Name data has a Unicode encoding.name_from_utf16_be/// Returns a Name language./// A list of face names./// Returns a name at index./// Returns a number of name records./// Checks if there are any name records.NamesIter/// An iterator over face names./// A list of names./// A [Naming Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/name).//! A [Naming Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/name) implementation.WEIGHT_CLASS_OFFSETWIDTH_CLASS_OFFSETTYPE_OFFSETY_SUBSCRIPT_X_SIZE_OFFSETY_SUPERSCRIPT_X_SIZE_OFFSETY_STRIKEOUT_SIZE_OFFSETY_STRIKEOUT_POSITION_OFFSETUNICODE_RANGES_OFFSETSELECTION_OFFSETTYPO_ASCENDER_OFFSETTYPO_DESCENDER_OFFSETTYPO_LINE_GAP_OFFSETWIN_ASCENTWIN_DESCENTX_HEIGHT_OFFSETCAP_HEIGHT_OFFSETExtraLightSemiBoldExtraBold/// A face [weight](https://docs.microsoft.com/en-us/typography/opentype/spec/os2#usweightclass)./// Returns a numeric representation of a weight./// A face [width](https://docs.microsoft.com/en-us/typography/opentype/spec/os2#uswidthclass)./// Returns a numeric representation of a width.InstallablePreviewAndPrint/// Face [permissions](https://docs.microsoft.com/en-us/typography/opentype/spec/os2#fst)./// A face style.x_size/// Horizontal face size.y_size/// Vertical face size./// X offset./// Y offset./// A script metrics used by subscript and superscript.SelectionFlags// https://docs.microsoft.com/en-us/typography/opentype/spec/os2#fsselectionuse_typo_metrics// #[inline] fn regular(self) -> bool { self.0 & (1 << 6) != 0 }oblique/// [Unicode Ranges](https://docs.microsoft.com/en-us/typography/opentype/spec/os2#ur).contains_char/// Checks if ranges contain the specified character.char_range_index/// Table version./// A [OS/2 and Windows Metrics Table](https://docs.microsoft.com/en-us/typography/opentype/spec/os2)./// Returns weight class./// Returns face width./// Returns subscript metrics./// Returns superscript metrics./// Returns strikeout metrics./// Returns Unicode ranges.fs_selection/// Returns style./// Checks if face is bold./// Do not confuse with [`Weight::Bold`].use_typographic_metrics/// Checks if typographic metrics should be used./// Returns typographic ascender./// Returns typographic descender./// Returns typographic line gap.windows_ascender/// Returns Windows ascender.windows_descender/// Returns Windows descender./// Returns x height./// Returns `None` version is < 2./// Returns capital height.//! A [OS/2 and Windows Metrics Table](https://docs.microsoft.com/en-us/typography/opentype/spec/os2)ITALIC_ANGLE_OFFSETUNDERLINE_POSITION_OFFSETUNDERLINE_THICKNESS_OFFSETIS_FIXED_PITCH_OFFSETMACINTOSH_NAMES// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6post.html/// A list of Macintosh glyph names./// An iterator over glyph names./// The `post` table doesn't provide the glyph names count,/// so we have to simply iterate over all of them to find it out./// Italic angle in counter-clockwise degrees from the vertical./// Underline metrics./// Flag that indicates that the font is monospaced.glyph_indexesnames_data/// A [PostScript Table](https://docs.microsoft.com/en-us/typography/opentype/spec/post)./// Returns a glyph name by ID./// Returns an iterator over glyph names./// Default/predefined names are not included. Just the one in the font file.//! A [PostScript Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/post) implementation./// The pixels per EM size for which this strike was designed./// The device pixel density (in PPI) for which this strike was designed./// Data from the beginning of the `Strikes` table.Strike/// A strike of glyphs./// Returns a glyph data./// Returns the number of glyphs in this strike./// Checks if there are any glyphs./// `sbix` table data.// Offsets from the beginning of the `sbix` table.// The total number of glyphs in the face + 1. From the `maxp` table.Strikes/// A list of [`Strike`]s./// Returns a strike at the index./// Returns the number of strikes./// Checks if there are any strikes.StrikesIterstrikes/// An iterator over [`Strikes`]./// A [Standard Bitmap Graphics Table](/// https://docs.microsoft.com/en-us/typography/opentype/spec/sbix).best_strike/// Selects the best matching [`Strike`] based on `pixels_per_em`.png_size// The `sbix` table doesn't store the image size, so we have to parse it manually.// Which is quite simple in case of PNG, but way more complex for JPEG.// Therefore we are omitting it for now.//! A [Standard Bitmap Graphics Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/sbix) implementation./// Zero-based index into [`Table::axes`]./// Numeric value for this axis.AxisValue/// Axis-value pairing for [`AxisValueSubtableFormat4`].AxisValueSubtables/// Iterator over axis value subtables.AxisValueSubtable/// Axis tag./// The name ID for entries in the 'name' table that provide a display string for this axis./// Sort order for e.g. composing font family or face names.AxisRecord/// The [axis record](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#axis-records) struct provides information about a single design axis.AxisValueFlags/// [Flags](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#flags) for [`AxisValueSubtable`].older_sibling_attribute/// If set, this value also applies to older versions of this font.elidable/// If set, this value is the normal (a.k.a. "regular") value for the font family./// Flags for [`AxisValueSubtable`].value_name_id/// The name ID of the display string./// Numeric value for this record.AxisValueSubtableFormat1/// Axis value subtable [format 1](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-1).nominal_value/// Nominal numeric value for this record.range_min_value/// The minimum value for this record.range_max_value/// The maximum value for this record.AxisValueSubtableFormat2/// Axis value subtable [format 2](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-2).linked_value/// Numeric value for a style-linked mapping.AxisValueSubtableFormat3/// Axis value subtable [format 3](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-3)./// List of axis-value pairings.AxisValueSubtableFormat4/// Axis value subtable [format 4](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-4)./// An [axis value subtable](https://learn.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-tables)./// Returns the value from an axis value subtable./// For formats 1 and 3 the value is returned, for formats 2 and 4 `None` is returned as there/// is no single value associated with those formats./// Returns `true` if the axis subtable either is the value or is a range that contains the/// value passed in as an argument./// Note: this will always return false for format 4 subtables as they may contain multiple/// axes./// Returns the associated name ID.is_elidable/// Returns `true` if the axis subtable has the `ELIDABLE_AXIS_VALUE_NAME` flag set.is_older_sibling/// Returns `true` if the axis subtable has the `OLDER_SIBLING_FONT_ATTRIBUTE` flag set./// List of axesfallback_name_id/// Fallback name when everything can be elided.value_lookup_startvalue_offsets/// A [Style Attributes Table](https://docs.microsoft.com/en-us/typography/opentype/spec/stat)./// Returns an iterator over the collection of axis value tables.subtable_for_axis/// Returns the first matching subtable for a given axis./// If no match value is given the first subtable for the axis is returned. If a match value is/// given, the first subtable for the axis where the value matches is returned. A value matches/// if it is equal to the subtable's value or contained within the range defined by the/// subtable. If no matches are found `None` is returned. Typically a match value is not/// specified for non-variable fonts as multiple subtables for a given axis ought not exist. For/// variable fonts a non-`None` match value should be specified as multiple records for each of/// the variation axes exist./// Note: Format 4 subtables are explicitly ignored in this function.//! A [Style Attributes Table](https://docs.microsoft.com/en-us/typography/opentype/spec/stat) implementation./// The SVG document data./// Can be stored as a string or as a gzip compressed data, aka SVGZ./// An [SVG documents](/// https://docs.microsoft.com/en-us/typography/opentype/spec/svg#svg-document-list).svg_doc_offsetsvg_doc_lengthSvgDocumentRecordSvgDocumentsList/// A list of [SVG documents](/// Returns SVG document data at index./// `index` is not a GlyphId. You should use [`find()`](SvgDocumentsList::find) instead./// Returns a SVG document data by glyph ID./// Returns the number of SVG documents in the list./// Checks if the list is empty.SvgDocumentsListIter/// An iterator over [`SvgDocumentsList`] values./// A list of SVG documents./// An [SVG Table](https://docs.microsoft.com/en-us/typography/opentype/spec/svg).//! An [SVG Table](https://docs.microsoft.com/en-us/typography/opentype/spec/svg) implementation.// Offset from start of the table.TrackTableRecord/// A track value./// The `name` table index for the track's name./// A list of tracking values for each size./// A single track.// the whole tablesizes_countTracks/// A list of tracks./// Returns a track at index./// Returns the number of tracks./// Checks if there are any tracks.TracksItertracks/// An iterator over [`Tracks`]./// A list of sizes.TrackData/// A track data./// Horizontal track data./// Vertical track data./// A [Tracking Table](/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6trak.html).//! A [Tracking Table](//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6trak.html) implementation./// Number of metrics in the `vmtx` table./// A [Vertical Header Table](https://docs.microsoft.com/en-us/typography/opentype/spec/vhea).//! A [Vertical Header Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/vhea) implementation./// Glyph ID./// Y coordinate, in the font's design coordinate system, of the vertical origin.VerticalOriginMetrics/// Vertical origin metrics for thedefault_y/// Default origin./// A list of metrics for each glyph./// Ordered by `glyph_id`./// A [Vertical Origin Table](https://docs.microsoft.com/en-us/typography/opentype/spec/vorg)./// Returns glyph's Y origin.//! A [Vertical Origin Table](//! https://docs.microsoft.com/en-us/typography/opentype/spec/vorg) implementation.advance_height_mapping_offsettsb_mapping_offsetbsb_mapping_offsetvorg_mapping_offset/// A [Vertical Metrics Variations Table](/// Returns the advance height offset for a glyph.top_side_bearing_offset/// Returns the top side bearing offset for a glyph.bottom_side_bearing_offset/// Returns the bottom side bearing offset for a glyph.vertical_origin_offset/// Returns the vertical origin offset for a glyph.//! A [Vertical Metrics Variations Table](data_offsetsregionsVariationRegionListregion_indicesparse_deltaRegionAxisCoordinatesRecordevaluate_regionstart_coordpeak_coordend_coordevaluate_axis//! Implementation of Item Variation Store//! <https://docs.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#item-variation-store>ReadBuffer/// A FIFO buffer for reading packets from the network./// Create a new empty input buffer./// Create a new empty input buffer with a given `capacity`./// Create a input buffer filled with previously read data.as_cursor/// Get a cursor to the data storage.as_cursor_mut/// Get a cursor to the mutable data storage./// Consume the `ReadBuffer` and get the internal storage./// Read next portion of data from the given input stream.clean_up/// Cleans ups the part of the vector that has been already read by the cursor.simple_readingreading_in_chunks//! A buffer for reading data from the network.//! The `ReadBuffer` is a buffer of bytes similar to a first-in, first-out queue.//! It is filled by reading from a stream supporting `Read` and is then//! accessible as a cursor for reading bytes.NoDelayconnect_with_config/// Connect to the given WebSocket in blocking mode./// Uses a websocket configuration passed as an argument to the function. Calling it with `None` is/// equal to calling `connect()` function./// The URL may be either ws:// or wss://./// To support wss:// URLs, you must activate the TLS feature on the crate level. Please refer to the/// project's [README][readme] for more information on available features./// This function "just works" for those who wants a simple blocking solution/// similar to `std::net::TcpStream`. If you want a non-blocking or other/// custom stream, call `client` instead./// This function uses `native_tls` or `rustls` to do TLS depending on the feature flags enabled. If/// you want to use other TLS libraries, use `client` instead. There is no need to enable any of/// the `*-tls` features if you don't call `connect` since it's the only function that uses them./// [readme]: https://github.com/snapview/tungstenite-rs/#features/// To support wss:// URLs, feature `native-tls` or `rustls-tls` must be turned on.connect_to_some/// Get the mode of the given URL./// This function may be used to ease the creation of custom TLS streams/// in non-blocking algorithms or for use with TLS libraries other than `native_tls` or `rustls`.client_with_config/// Do the client handshake over the given stream given a web socket configuration. Passing `None`/// as configuration is equal to calling `client()` function./// Use this function if you need a nonblocking handshake support or if you/// want to use a custom stream like `mio::net::TcpStream` or `openssl::ssl::SslStream`./// Any stream supporting `Read + Write` will do./// Do the client handshake over the given stream.into_client_request/// Convert into a `Request` that can be used for a client connection./// Trait for converting various types into HTTP requests used for a client connection./// This trait is implemented by default for string slices, strings, `http::Uri` and/// `http::Request<()>`. Note that the implementation for `http::Request<()>` is trivial and will/// simply take your request and pass it as is further without altering any headers or URLs, so/// be aware of this. If you just want to connect to the endpoint with a certain URL, better pass/// a regular string containing the URL in which case `tungstenite-rs` will take care for generating/// the proper `http::Request<()>` for you.additional_headers/// Additional [`Request`] handshake headerssubprotocols/// Handsake subprotocolsClientRequestBuilder/// Builder for a custom [`IntoClientRequest`] with options to add/// custom additional headers and sub protocols./// ```rust no_run/// # use crate::*;/// use tungstenite::{connect, ClientRequestBuilder};/// let uri: Uri = "ws://localhost:3012/socket".parse().unwrap();/// let token = "my_jwt_token";/// let builder = ClientRequestBuilder::new(uri)///     .with_header("Authorization", format!("Bearer {token}"))///     .with_sub_protocol("my_sub_protocol");/// let socket = connect(builder).unwrap();/// Initializes an empty request builder/// Adds (`key`, `value`) as an additional header to the handshake requestwith_sub_protocol/// Adds `protocol` to the handshake request subprotocols (`Sec-WebSocket-Protocol`)//! Methods to connect to a WebSocket as a client./// Result type of all Tungstenite library calls./// WebSocket connection closed normally. This informs you of the close./// It's not an error as such and nothing wrong happened./// This is returned as soon as the close handshake is finished (we have both sent and/// received a close frame) on the server end and as soon as the server has closed the/// underlying connection if this endpoint is a client./// Thus when you receive this, it is safe to drop the underlying connection./// Receiving this error means that the WebSocket object is not usable anymore and the/// only meaningful action with it is dropping it.AlreadyClosed/// Trying to work with already closed connection./// Trying to read or write after receiving `ConnectionClosed` causes this./// As opposed to `ConnectionClosed`, this indicates your code tries to operate on the/// connection when it really shouldn't anymore, so this really indicates a programmer/// error on your part./// Input-output error. Apart from WouldBlock, these are generally errors with the/// underlying connection and you should probably consider them fatal./// TLS error./// Note that this error variant is enabled unconditionally even if no TLS feature is enabled,/// to provide a feature-agnostic API surface.Capacity/// - When reading: buffer capacity exhausted./// - When writing: your message is bigger than the configured max message size///   (64MB by default).ProtocolError/// Protocol violation.WriteBufferFull/// Message write buffer is full./// UTF coding error.AttackAttempt/// Attack attempt detected./// Invalid URL./// HTTP error.HttpFormat/// HTTP format error./// Possible WebSocket errors./// Too many headers provided (see [`httparse::Error::TooManyHeaders`])./// The size of the message./// The maximum allowed message size.MessageTooLong/// Received header is too long./// Message is bigger than the maximum allowed size./// Indicates the specific type/cause of a capacity error.SubProtocolErrorServerSentSubProtocolNoneRequested/// The server sent a subprotocol to a client handshake request but none was requestedInvalidSubProtocol/// The server sent an invalid subprotocol to a client handhshake requestNoSubProtocol/// The server sent no subprotocol to a client handshake request that requested one or more/// subprotocols/// Indicates the specific type/cause of a subprotocol header error.WrongHttpMethod/// Use of the wrong HTTP method (the WebSocket protocol requires the GET method be used).WrongHttpVersion/// Wrong HTTP version used (the WebSocket protocol requires version 1.1 or higher).MissingConnectionUpgradeHeader/// Missing `Connection: upgrade` HTTP header.MissingUpgradeWebSocketHeader/// Missing `Upgrade: websocket` HTTP header.MissingSecWebSocketVersionHeader/// Missing `Sec-WebSocket-Version: 13` HTTP header.MissingSecWebSocketKey/// Missing `Sec-WebSocket-Key` HTTP header.SecWebSocketAcceptKeyMismatch/// The `Sec-WebSocket-Accept` header is either not present or does not specify the correct key value.SecWebSocketSubProtocolError/// The `Sec-WebSocket-Protocol` header was invalidJunkAfterRequest/// Garbage data encountered after client request.CustomResponseSuccessful/// Custom responses must be unsuccessful./// Invalid header is passed. Or the header is missing in the request. Or not present at all. Check the request that you pass.HandshakeIncomplete/// No more data while still performing handshake.HttparseError/// Wrapper around a [`httparse::Error`] value.SendAfterClosing/// Not allowed to send after having sent a closing frame.ReceivedAfterClosing/// Remote sent data after sending a closing frame.NonZeroReservedBits/// Reserved bits in frame header are non-zero.UnmaskedFrameFromClient/// The server must close the connection when an unmasked frame is received.MaskedFrameFromServer/// The client must close the connection when a masked frame is received.FragmentedControlFrame/// Control frames must not be fragmented.ControlFrameTooBig/// Control frames must have a payload of 125 bytes or less.UnknownControlFrameType/// Type of control frame not recognised.UnknownDataFrameType/// Type of data frame not recognised.UnexpectedContinueFrame/// Received a continue frame despite there being nothing to continue.ExpectedFragment/// Received data while waiting for more fragments.ResetWithoutClosingHandshake/// Connection closed without performing the closing handshake.InvalidOpcode/// Encountered an invalid opcode.InvalidCloseSequence/// The payload for the closing frame is invalid./// Indicates the specific type/cause of a protocol error.TlsFeatureNotEnabled/// TLS is used despite not being compiled with the TLS feature enabled.NoHostName/// The URL does not include a host name.UnableToConnect/// Failed to connect with this URL.UnsupportedUrlScheme/// Unsupported URL scheme used (only `ws://` or `wss://` may be used).EmptyHostName/// The URL host name, though included, is empty.NoPathOrQuery/// The URL does not include a path/query./// Indicates the specific type/cause of URL error./// Native TLS error./// Rustls error.InvalidDnsName/// DNS name resolution error./// TLS errors./// Note that even if you enable only the rustls-based TLS support, the error at runtime could still/// be `Native`, as another crate in the dependency graph may enable native TLS support.//! Error handling.HttpResponsederive_accept_keyFromHttparseMAX_HEADERSHandshakeMachineStageResultTryParseProcessingResult/// Client request type./// Client response type.VerifyData/// Client handshake role./// Initiate a client handshake.IncomingDatastage_finishedgenerate_request/// Verifies and generates a client WebSocket request from the original request and extracts a WebSocket key from it.extract_subprotocols_from_requestaccept_key/// Accepted server key./// Accepted subprotocols/// Information for handshake verification.verify_responsefrom_httparse/// Generate a random key for the `Sec-WebSocket-Key` header.random_keysconstruct_expectedrequest_formattingrequest_formatting_with_hostrequest_formatting_with_atresponse_parsinginvalid_custom_request//! Client handshake machine./// Limit for the number of header lines./// Convert raw object into parsed HTTP headers./// Trait to convert raw objects into HTTP parseables.headers_iterheaders_incomplete//! HTTP Request and response header handling.NonBlockingResult/// A generic handshake state machine.start_read/// Start reading data from the peer.start_write/// Start writing data to the peer.Objsingle_roundRoundResult/// Perform a single handshake round./// Round not done, I/O would block./// Round done, state unchanged.StageFinished/// Stage complete./// The result of the round.DoneReading/// Reading round finished.DoneWriting/// Writing round finished./// The result of the stage./// Return Ok(None) if incomplete, Err on syntax error./// The parseable object.AttackCheck/// Reading data from the peer./// Sending data to the peer./// Flushing data to ensure that all intermediately buffered contents reach their destination./// The handshake state.number_of_packets/// Number of HTTP header successful reads (TCP packets).number_of_bytes/// Total number of bytes in HTTP header./// Attack mitigation. Contains counters needed to prevent DoS attacks/// and reject valid but useless headers./// Initialize attack checking for incoming buffer.check_incoming_packet_size/// Check the size of an incoming packet. To be called immediately after `read()`/// passing its returned bytes count as `size`.//! WebSocket handshake machine./// A WebSocket handshake./// Allow access to machine/// Allow mutable access to machine/// Handshake was interrupted (would block)./// Handshake failed./// A handshake result./// Handshake role./// Stage processing result./// Derive the `Sec-WebSocket-Accept` response header from a `Sec-WebSocket-Key` request header./// This function can be used to perform a handshake before passing a raw TCP stream to/// [`WebSocket::from_raw_socket`][crate::protocol::WebSocket::from_raw_socket].key_conversion//! WebSocket handshake control./// Server request type./// Server response type./// Server error response type.create_partscreate_response/// Create a response for the request.create_response_with_body/// Create a response for the request with a custom body./// Write `response` to the stream `w`./// Called whenever the server read the request from the client and is ready to reply to it./// May return additional reply headers./// Returning an error resulting in rejecting the incoming connection./// The callback trait./// The callback is called when the server receives an incoming WebSocket/// handshake request from the client. Specifying a callback allows you to analyze incoming headers/// and add additional headers to the response that server sends to the client and/or reject the/// connection based on the incoming headers./// Stub for callback that does nothing./// Callback which is called whenever the server read the request from the client and is ready/// to reply to it. The callback returns an optional headers which will be added to the reply/// which the server sends to the user./// WebSocket configuration.error_response/// Error code/flag. If set, an error will be returned after sending response to the client./// Internal stream type./// Server handshake role./// Start server handshake. `callback` specifies a custom callback which the user can pass to/// the handshake, this callback will be called when the a websocket client connects to the/// server, you can specify the callback if you want to add additional header to the client/// upon join based on the incoming headers.request_parsingrequest_replying//! Server handshake machine.READ_BUFFER_CHUNK_SIZE// re-export bytes since used in `Message` API.accept_hdraccept_hdr_with_configaccept_with_configclient_tlsclient_tls_with_config//! Lightweight, flexible WebSockets for Rust.// This can be removed when `error::Error::Http`, `handshake::HandshakeError::Interrupted` and// `handshake::server::ErrorResponse` are boxed.OpCode/// Data (text or binary)./// Control message (close, ping, pong)./// WebSocket message opcode as in RFC 6455./// 0x0 denotes a continuation frame/// 0x1 denotes a text frame/// 0x2 denotes a binary frame/// 0x3-7 are reserved for further non-control frames/// Data opcodes as in RFC 6455/// 0x8 denotes a connection close/// 0x9 denotes a pingPong/// 0xa denotes a pong/// 0xb-f are reserved for further control frames/// Control opcodes as in RFC 6455CloseCode/// Indicates a normal closure, meaning that the purpose for/// which the connection was established has been fulfilled./// Indicates that an endpoint is "going away", such as a server/// going down or a browser having navigated away from a page./// Indicates that an endpoint is terminating the connection due/// to a protocol error./// Indicates that an endpoint is terminating the connection/// because it has received a type of data it cannot accept (e.g., an/// endpoint that understands only text data MAY send this if it/// receives a binary message)./// Indicates that no status code was included in a closing frame. This/// close code makes it possible to use a single method, `on_close` to/// handle even cases where no close code was provided.Abnormal/// Indicates an abnormal closure. If the abnormal closure was due to an/// error, this close code will not be used. Instead, the `on_error` method/// of the handler will be called with the error. However, if the connection/// is simply dropped, without an error, this close code will be sent to the/// because it has received data within a message that was not/// consistent with the type of the message (e.g., non-UTF-8 \[RFC3629\]/// data within a text message)./// because it has received a message that violates its policy.  This/// is a generic status code that can be returned when there is no/// other more suitable status code (e.g., Unsupported or Size) or if there/// is a need to hide specific details about the policy./// because it has received a message that is too big for it to/// Indicates that an endpoint (client) is terminating the/// connection because it has expected the server to negotiate one or/// more extension, but the server didn't return them in the response/// message of the WebSocket handshake.  The list of extensions that/// are needed should be given as the reason for closing./// Note that this status code is not used by the server, because it/// can fail the WebSocket handshake instead./// Indicates that a server is terminating the connection because/// it encountered an unexpected condition that prevented it from/// fulfilling the request./// Indicates that the server is restarting. A client may choose to reconnect,/// and if it does, it should use a randomized delay of 5-30 seconds between attempts./// Indicates that the server is overloaded and the client should either connect/// to a different IP (when multiple targets exist), or reconnect to the same IP/// when a user has performed an action.Iana/// Status code used to indicate why an endpoint is closing the WebSocket connection./// Check if this CloseCode is allowed.opcode_from_u8opcode_into_u8closecode_from_u16closecode_into_u16//! Various codes defined in RFC 6455.generate_mask/// The reason as a code./// The reason as text string./// A struct representing the close command./// Indicates that the frame is the last one of a possibly fragmented message.rsv1/// Reserved for protocol extensions.rsv2rsv3/// WebSocket protocol opcode./// A frame mask, if any.FrameHeader/// A struct representing a WebSocket frame header./// Parse a header from an input stream./// Returns `None` if insufficient data and does not consume anything in this case./// Payload size is returned along with the header./// Get the size of the header formatted with given payload length./// Format a header for given payload size.set_random_mask/// Generate a random frame mask and store this in the header./// Of course this does not change frame contents. It just generates a mask./// Internal parse engine./// Returns `None` if insufficient data./// A struct representing a WebSocket frame./// Get the length of the frame./// This is the length of the header + the length of the payload./// Check if the frame is empty./// Get a reference to the frame's header.header_mut/// Get a mutable reference to the frame's header./// Get a reference to the frame's payload.is_masked/// Test whether the frame is masked./// Generate a random mask for the frame./// This just generates a mask, payload is not changed. The actual masking is performed/// either on `format()` or on `apply_mask()` call./// Consume the frame into its payload as string.into_payload/// Consume the frame into its payload./// Get frame payload as `&str`.into_close/// Consume the frame into a closing frame./// Create a new data frame.pong/// Create a new Pong control frame./// Create a new Ping control frame./// Create a new Close control frame.from_payload/// Create a frame from given header and data./// Write a frame out to a bufferformat_into_bufLengthFormat/// Handling of the length format.for_length/// Get the length format for a given data size.extra_bytes/// Get the size of the length encoding.length_byte/// Encode the given length.for_byte/// Get the length format for a given length byte./// Generate a random frame mask./// Mask/unmask a frame.apply_mask_fallback/// A safe unoptimized mask application.apply_mask_fast32/// Faster version of `apply_mask()` which operates on 4-byte blocks.test_apply_maskREAD_BUF_LEN/// Read buffer size used for `FrameSocket`./// The underlying network stream.FrameCodec/// Codec for reading/writing frames.FrameSocket/// A reader and writer for WebSocket frames./// Create a new frame socket./// Create a new frame socket from partially read data./// Extract a stream from the socket./// Read a frame from stream./// Writes and immediately flushes a frame./// Equivalent to calling [`write`](Self::write) then [`flush`](Self::flush)./// Write a frame to stream./// A subsequent call should be made to [`flush`](Self::flush) to flush writes./// This function guarantees that the frame is queued unless [`Error::WriteBufferFull`]/// In order to handle WouldBlock or Incomplete, call [`flush`](Self::flush) afterwards./// Flush writes.in_buffer/// Buffer to read data from the stream./// Buffer to send packets to the network.max_out_buffer_len/// Capacity limit for `out_buffer`.out_buffer_write_len/// Buffer target length to reach before writing to the stream/// on calls to `buffer_frame`./// Setting this to non-zero will buffer small writes from hitting/// Header and remaining size of the incoming packet being processed./// A codec for WebSocket frames./// Create a new frame codec./// Create a new frame codec from partially read data.set_max_out_buffer_len/// Sets a maximum size for the out buffer.set_out_buffer_write_len/// Sets [`Self::buffer_frame`] buffer target length to reach before/// writing to the stream./// Read a frame from the provided stream.read_in/// Read into available `in_buffer` capacity.buffer_frame/// Writes a frame into the `out_buffer`./// If the out buffer size is over the `out_buffer_write_len` will also write/// the out buffer into the provided `stream`./// To ensure buffered frames are written call [`Self::write_out_buffer`]./// May write to the stream, will **not** flush.write_out_buffer/// Writes the out_buffer to the provided stream./// Does **not** flush.read_frameswrite_framesparse_overflowsize_limit_hit//! Utilities to work with raw WebSocket frames./// Utf8 payload./// Creates from a static str./// Returns as a string slice./// Creates from a [`Bytes`] object without checking the encoding./// The bytes passed in must be valid UTF-8./// /// Example fn that takes a str slice/// fn a(s: &str) {}/// let data = tungstenite::Utf8Bytes::from_static("foo123");/// // auto-deref as arg/// a(&data);/// // deref to str methods/// assert_eq!(data.len(), 6);/// let payload = tungstenite::Utf8Bytes::from_static("foo123");/// assert_eq!(payload, "foo123");/// assert_eq!(payload, "foo123".to_string());/// assert_eq!(payload, &"foo123".to_string());/// assert_eq!(payload, std::borrow::Cow::from("foo123"));StringCollectorstring_collectIncompleteMessageCollector/// A struct representing the incomplete message.IncompleteMessageType/// Create new./// Get the current filled size of the buffer./// Add more data to an existing message./// Convert an incomplete message into a complete one./// The type of incomplete message./// A text WebSocket message/// A binary WebSocket message/// A ping message with the specified payload/// The payload here must have a length less than 125 bytes/// A pong message with the specified payload/// A close message with the optional close frame./// Raw frame. Note, that you're not going to get this value while reading the message./// An enum representing the various forms of a WebSocket message./// Create a new text WebSocket message from a stringable./// Create a new binary WebSocket message by converting to `Bytes`./// Indicates whether a message is a text message./// Indicates whether a message is a binary message./// Indicates whether a message is a ping message./// Indicates whether a message is a pong message.is_close/// Indicates whether a message is a close message./// Get the length of the WebSocket message./// Returns true if the WebSocket message has no content./// For example, if the other side of the connection sent an empty string./// Consume the WebSocket and return it as binary data./// Attempt to consume the WebSocket message and convert it to a String./// Attempt to get a &str from the WebSocket message,/// this will try to convert binary data to utf8.binary_convertbinary_convert_vecbinary_convert_into_bytestext_convertOpCtlOpData/// This socket is a server/// This socket is a client/// Indicates a Client or Server role of the websocket/// Read buffer capacity. This buffer is eagerly allocated and used for receiving/// For high read load scenarios a larger buffer, e.g. 128 KiB, improves performance./// For scenarios where you expect a lot of connections and don't need high read load/// performance a smaller buffer, e.g. 4 KiB, would be appropriate to lower total/// The default value is 128 KiB./// The target minimum size of the write buffer to reach before writing the data/// to the underlying stream./// If set to `0` each message will be eagerly written to the underlying stream./// It is often more optimal to allow them to buffer a little, hence the default value./// Note: [`flush`](WebSocket::flush) will always fully write the buffer regardless.max_write_buffer_size/// The max size of the write buffer in bytes. Setting this can provide backpressure/// in the case the write buffer is filling up due to write errors./// The default value is unlimited./// Note: The write buffer only builds up past [`write_buffer_size`](Self::write_buffer_size)/// when writes to the underlying stream are failing. So the **write buffer can not/// fill up if you are not observing write errors even if not flushing**./// Note: Should always be at least [`write_buffer_size + 1 message`](Self::write_buffer_size)/// and probably a little more depending on error handling strategy.max_message_size/// The maximum size of an incoming message. `None` means no size limit. The default value is 64 MiB/// which should be reasonably big for all normal use-cases but small enough to prevent/// memory eating by a malicious user./// The maximum size of a single incoming message frame. `None` means no size limit. The limit is for/// frame payload NOT including the frame header. The default value is 16 MiB which should/// be reasonably big for all normal use-cases but small enough to prevent memory eating/// by a malicious user.accept_unmasked_frames/// When set to `true`, the server will accept and handle unmasked frames/// from the client. According to the RFC 6455, the server must close the/// connection to the client in such cases, however it seems like there are/// some popular libraries that are sending unmasked frames, ignoring the RFC./// By default this option is set to `false`, i.e. according to RFC 6455./// The configuration for WebSocket connection./// # use tungstenite::protocol::WebSocketConfig;;/// let conf = WebSocketConfig::default()///     .read_buffer_size(256 * 1024)///     .write_buffer_size(256 * 1024);/// Set [`Self::read_buffer_size`]./// Set [`Self::write_buffer_size`]./// Set [`Self::max_write_buffer_size`]./// Set [`Self::max_message_size`]./// Set [`Self::max_frame_size`]./// Set [`Self::accept_unmasked_frames`]./// Panic if values are invalid./// The underlying socket.WebSocketContext/// The context for managing a WebSocket./// WebSocket input-output stream./// This is THE structure you want to create to be able to speak the WebSocket protocol./// It may be created by calling `connect`, `accept` or `client` functions./// Use [`WebSocket::read`], [`WebSocket::send`] to received and send messages./// Convert a raw socket into a WebSocket without performing a handshake./// Call this function if you're using Tungstenite as a part of a web framework/// or together with an existing one. If you need an initial handshake, use/// `connect()` or `accept()` functions of the crate to construct a websocket./// Panics if config is invalid e.g. `max_write_buffer_size <= write_buffer_size`./// Change the configuration./// Read the configuration./// Check if it is possible to read messages./// Reading is impossible after receiving `Message::Close`. It is still possible after/// sending close frame since the peer still may send some data before confirming close./// Check if it is possible to write messages./// Writing gets impossible immediately after sending or receiving `Message::Close`./// Read a message from stream, if possible./// This will also queue responses to ping and close messages. These responses/// will be written and flushed on the next call to [`read`](Self::read),/// [`write`](Self::write) or [`flush`](Self::flush)./// # Closing the connection/// When the remote endpoint decides to close the connection this will return/// the close message with an optional close frame./// You should continue calling [`read`](Self::read), [`write`](Self::write) or/// [`flush`](Self::flush) to drive the reply to the close frame until [`Error::ConnectionClosed`]/// is returned. Once that happens it is safe to drop the underlying connection./// Writes and immediately flushes a message./// Write a message to the provided stream, if possible./// In the event of stream write failure the message frame will be stored/// in the write buffer and will try again on the next call to [`write`](Self::write)/// or [`flush`](Self::flush)./// If the write buffer would exceed the configured [`WebSocketConfig::max_write_buffer_size`]/// [`Err(WriteBufferFull(msg_frame))`](Error::WriteBufferFull) is returned./// This call will generally not flush. However, if there are queued automatic messages/// they will be written and eagerly flushed./// For example, upon receiving ping messages tungstenite queues pong replies automatically./// The next call to [`read`](Self::read), [`write`](Self::write) or [`flush`](Self::flush)/// will write & flush the pong reply. This means you should not respond to ping frames manually./// You can however send pong frames manually in order to indicate a unidirectional heartbeat/// as described in [RFC 6455](https://tools.ietf.org/html/rfc6455#section-5.5.3). Note that/// if [`read`](Self::read) returns a ping, you should [`flush`](Self::flush) before passing/// a custom pong to [`write`](Self::write), otherwise the automatic queued response to the/// ping will not be sent as it will be replaced by your custom pong message./// - If the WebSocket's write buffer is full, [`Error::WriteBufferFull`] will be returned///   along with the equivalent passed message frame./// - If the connection is closed and should be dropped, this will return [`Error::ConnectionClosed`]./// - If you try again after [`Error::ConnectionClosed`] was returned either from here or from///   [`read`](Self::read), [`Error::AlreadyClosed`] will be returned. This indicates a program///   error on your part./// - [`Error::Io`] is returned if the underlying connection returns an error///   (consider these fatal except for WouldBlock)./// - [`Error::Capacity`] if your message size is bigger than the configured max message size./// Ensures all messages previously passed to [`write`](Self::write) and automatic/// queued pong responses are written & flushed into the underlying stream./// Close the connection./// This function guarantees that the close frame will be queued./// There is no need to call it again. Calling this function is/// the same as calling `write(Message::Close(..))`./// After queuing the close frame you should continue calling [`read`](Self::read) or/// [`flush`](Self::flush) to drive the close handshake to completion./// The websocket RFC defines that the underlying connection should be closed/// by the server. Tungstenite takes care of this asymmetry for you./// When the close handshake is finished (we have both sent and received/// a close message), [`read`](Self::read) or [`flush`](Self::flush) will return/// [Error::ConnectionClosed] if this endpoint is the server./// If this endpoint is a client, [Error::ConnectionClosed] will only be/// returned after the server has closed the underlying connection./// It is thus safe to drop the underlying connection as soon as [Error::ConnectionClosed]/// is returned from [`read`](Self::read) or [`flush`](Self::flush)./// Old name for [`read`](Self::read)./// Old name for [`send`](Self::send).write_pending/// Old name for [`flush`](Self::flush)./// Server or client?/// encoder/decoder of frame.WebSocketState/// The state of processing, either "active" or "closing"./// Receive: an incomplete message being processed.additional_send/// Send in addition to regular messages E.g. "pong" or "close".unflushed_additional/// True indicates there is an additional message (like a pong)/// that failed to flush previously and we should try again./// The configuration for the websocket session./// A context for managing WebSocket stream./// Create a WebSocket context that manages a post-handshake stream./// Create a WebSocket context that manages an post-handshake stream./// Read a message from the provided stream, if possible./// This function sends pong and close responses automatically./// However, it never blocks on write./// Write a message to the provided stream./// Ensures all messages previously passed to [`write`](Self::write) and automatically/// queued pong responses are written & flushed into the `stream`._write/// Writes any data in the out_buffer, `additional_send` and given `data`./// Returns true if the write contents indicate we should flush immediately./// the same as calling `send(Message::Close(..))`.read_message_frame/// Try to decode one message frame. May return None.do_close/// Received a close frame. Tells if we need to return a close frame to the user./// Write a single frame into the write-buffer.set_additional/// Replace `additional_send` if it is currently a `Pong` message.check_max_size/// The connection is active.ClosedByUs/// We initiated a close handshake.ClosedByPeer/// The peer initiated a close handshake.CloseAcknowledged/// The peer replied to our close handshake./// The connection does not exist anymore./// The current connection state./// Tell if we're allowed to process normal messages./// Tell if we should process incoming data. Note that if we send a close frame/// but the remote hasn't confirmed, they might have sent data before they receive our/// close frame, so we should still pass those to client code, hence ClosedByUs is valid.check_not_terminated/// Check if the state is active, return error if not.check_connection_resetCheckConnectionReset/// Translate "Connection reset by peer" into `ConnectionClosed` if appropriate.WriteMocsize_limiting_text_fragmentedsize_limiting_binary//! Generic WebSocket message stream./// Accept the given Stream as a WebSocket./// Uses a configuration provided as an argument. Calling it with `None` will use the default one/// used by `accept()`./// This function starts a server WebSocket handshake over the given stream./// If you want TLS support, use `native_tls::TlsStream`, `rustls::Stream` or/// `openssl::ssl::SslStream` for the stream here. Any `Read + Write` streams are supported,/// including those from `Mio` and others./// used by `accept_hdr()`./// This function does the same as `accept()` but accepts an extra callback//! Methods to accept an incoming WebSocket connection on a server./// Plain mode (`ws://` URL)./// TLS mode (`wss://` URL)./// Stream mode, either plain TCP or TLS./// Set the TCP_NODELAY option to the given value./// Trait to switch TCP_NODELAY.TlsHandshakeError/// The same as [`client_tls()`] but one can specify a websocket configuration,/// Please refer to [`client_tls()`] for more details.into_non_blocking/// Convert WouldBlock to None and don't touch other errors.NonBlockingError/// Non-blocking IO handling./// Type of the converted result: `Result<Option<T>, E>`no_block/// Perform the non-block conversion./// Non-blocking IO wrapper./// This trait is implemented for `Result<T, E: NonBlockingError>`.//! Helper traits to ease non-blocking handling.vnetgenerate_auth_keyAuthHandlerDEFAULT_LIFETIMErelayrelay_nonerelay_staticRelayAddressGeneratorStaticConnConfignew_test_managerManagerrandom_five_tupleFiveTupletest_packet_handlertest_create_allocation_duplicate_five_tupletest_delete_allocationtest_allocation_timeouttest_manager_closetest_delete_allocation_by_usernameTestAuthHandlerauth_handleAllocationInfocreate_clientallocation_manager_testrelay_addr_generatorRelayAddressGeneratoralloc_close_notifyManagerConfig/// `ManagerConfig` a bag of config params for `Manager`.allocationsAllocationMapreservations/// `Manager` is used to hold active allocations./// Creates a new [`Manager`]./// Closes this [`manager`] and closes all [`Allocation`]s it manages.get_allocations_info/// Returns the information about the all [`Allocation`]s associated with/// the specified [`FiveTuple`]s.get_allocation/// Fetches the [`Allocation`] matching the passed [`FiveTuple`].create_allocation/// Creates a new [`Allocation`] and starts relaying.delete_allocation/// Removes an [`Allocation`].delete_allocations_by_username/// Deletes the [`Allocation`]s according to the specified username `name`.create_reservation/// Stores the reservation for the token+port.get_reservation/// Returns the port for a given reservation if it exists.get_random_even_port/// Returns a random un-allocated udp4 port.test_has_permissiontest_add_permissiontest_remove_permissiontest_add_channel_bindtest_get_channel_by_numbertest_get_channel_by_addrtest_remove_channel_bindtest_allocation_refreshtest_allocation_closecreate_channel_bindtest_channel_bindtest_channel_bind_starttest_channel_bind_resetchannel_bind_testchannumchannel_bindingsChannelBindreset_txtimer_expired/// `ChannelBind` represents a TURN Channel./// https://tools.ietf.org/html/rfc5766#section-2.5./// Creates a new [`ChannelBind`]test_five_tuple_protocoltest_five_tuple_equalfive_tuple_test/// `FiveTuple` is the combination (client IP address and port, server IP/// address and port, and transport protocol (currently one of UDP,/// TCP, or TLS)) used to communicate between the client and the/// server.  The 5-tuple uniquely identifies this communication/// stream.  The 5-tuple also uniquely identifies the Allocation on/// the server.allocation_testallocation_managerchannel_bindfive_tupleSyncMutexchandatapeeraddrRTP_MTU/// [`FiveTuple`] of this [`Allocation`]./// Username of this [`Allocation`].relay_addr/// Relay address of this [`Allocation`]./// Information about an [`Allocation`]./// Creates a new [`AllocationInfo`].turn_socketrelay_socketrelayed_bytes// Option<mpsc::Receiver<()>>,/// `Allocation` is tied to a FiveTuple and relays traffic/// use create_allocation and get_allocation to operate.addr2ipfingerprint/// Creates a new [`Allocation`].has_permission/// Checks the Permission for the `addr`.add_permission/// Adds a new [`Permission`] to this [`Allocation`].remove_permission/// Removes the `addr`'s fingerprint from this [`Allocation`]'s permissions.add_channel_bind/// Adds a new [`ChannelBind`] to this [`Allocation`], it also updates the/// permissions needed for this [`ChannelBind`].remove_channel_bind/// Removes the [`ChannelBind`] from this [`Allocation`] by `number`.get_channel_addr/// Gets the [`ChannelBind`]'s address by `number`.get_channel_number/// Gets the [`ChannelBind`]'s number from this [`Allocation`] by `addr`./// Closes the [`Allocation`]./// Updates the allocations lifetime.packet_handler//  https://tools.ietf.org/html/rfc5766#section-10.3//  When the server receives a UDP datagram at a currently allocated//  relayed transport address, the server looks up the allocation//  associated with the relayed transport address.  The server then//  checks to see whether the set of permissions for the allocation allow//  the relaying of the UDP datagram as described in Section 8.//  If relaying is permitted, then the server checks if there is a//  channel bound to the peer that sent the UDP datagram (see//  Section 11).  If a channel is bound, then processing proceeds as//  described in Section 11.7.//  If relaying is permitted but no channel is bound to the peer, then//  the server forms and sends a Data indication.  The Data indication//  MUST contain both an XOR-PEER-ADDRESS and a DATA attribute.  The DATA//  attribute is set to the value of the 'data octets' field from the//  datagram, and the XOR-PEER-ADDRESS attribute is set to the source//  transport address of the received UDP datagram.  The Data indication//  is then sent on the 5-tuple associated with the allocation.PERMISSION_TIMEOUT/// `Permission` represents a TURN permission. TURN permissions mimic the address-restricted/// filtering mechanism of NATs that comply with [RFC4787]./// https://tools.ietf.org/html/rfc5766#section-2.3/// Creates a new [`Permission`].test_lt_credtest_generate_auth_key"This test is currently failing and needs fixing"test_new_long_term_auth_handlerauth_testgenerate_long_term_credentials/// `generate_long_term_credentials()` can be used to create credentials valid for `duration` time/long_term_credentials/// A convenience function to easily generate keys in the format used by [`AuthHandler`].shared_secretLongTermAuthHandler/// https://tools.ietf.org/search/rfc5389#section-10.2test_binding_manager_number_assignmenttest_binding_manager_methodtest_binding_manager_failurebinding_testMIN_CHANNEL_NUMBER//  Channel number://    0x4000 through 0x7FFF: These values are the allowed channel//    numbers (16,383 possible values).MAX_CHANNEL_NUMBERBindingStaterefreshed_atset_refreshed_atchan_mapaddr_mapBindingManager/// Thread-safe Binding map.assign_channel_numberfind_by_addrget_by_addrfind_by_numberget_by_numberdelete_by_addrdelete_by_numbercreate_listening_test_clientcreate_listening_test_client_with_stun_servtest_client_with_stun_send_binding_requesttest_client_with_stun_send_binding_request_to_paralleltest_client_with_stun_send_binding_request_to_timeouttest_client_nonce_expirationperiodic_timerrelay_connrelayaddrreqtransPROTO_UDPDEFAULT_RTO_IN_MSMAX_DATA_BUFFER_SIZEMAX_READ_QUEUE_SIZE// message size limit for Chromiumstun_serv_addrturn_serv_addr// STUN server address (e.g. "stun.abc.com:3478")// TURN server address (e.g. "turn.abc.com:3478")realmrto_in_ms/// ClientConfig is a bag of config parameters for Client.tr_mapTransactionMapbinding_mgrread_ch_txInboundDataclose_notifyClientInternal" Returns the TURN server address."turn_server_addr" Returns the `username`."" Return the `realm`."" Sends data to the specified destination using the base socket."" Performs STUN transaction."perform_transactionTransactionResultRelayConnObserver/// Creates a new [`ClientInternal`].stun_server_addr/// Returns the STUN server address./// `listen()` will have this client start listening on the `relay_conn` provided via the config./// This is optional. If not used, you will need to call `handle_inbound` method/// to supply incoming data, instead.handle_inbound/// Handles data received./// This method handles incoming packet demultiplex it by the source address/// and the types of the message./// Caller should check if the packet was handled by this client or not./// If not handled, it is assumed that the packet is application data./// If an error is returned, the caller should discard the packet regardless.handle_stun_messagehandle_channel_datahandle_inbound_relay_conn/// Passes inbound data in RelayConn./// Closes this client.send_binding_request_to/// Sends a new STUN request to the given transport address.send_binding_request/// Sends a new STUN request to the STUN server.find_addr_by_channel_number/// Returns a peer address associated with the// channel number on this UDPConnRelayConnConfig/// Sends a TURN allocation request to the given transport address.client_internal/// Client is a STUN server client.//              interval [msec]// 0: 0 ms      +500// 1: 500 ms	+1000// 2: 1500 ms   +2000// 3: 3500 ms   +4000// 4: 7500 ms   +8000// 5: 15500 ms  +16000// 6: 31500 ms  +32000// -: 63500 ms  failedDummyPeriodicTimerTimeoutHandleron_timeoutTimerIdRefreshPeriodicTimerTimeoutHandlertest_periodic_timerperiodic_timer_testPerms" `PeriodicTimerTimeoutHandler` is a handler called on timeout."PeriodicTimer/// `PeriodicTimer` is a periodic timer./// create a new [`PeriodicTimer`]./// Starts the timer./// Stops the timer./// Tests if the timer is running./// Debug purpose only.PermStatePermitted//PermState,perm_mapPermissionMap/// Thread-safe Permission map.DummyRelayConnObservertest_relay_connrelay_conn_test// client implements the API for a TURN clientPERM_REFRESH_INTERVALMAX_RETRY_ATTEMPTS" `RelayConnObserver` is an interface to [`RelayConn`] observer."relayed_addrread_ch_rx/// `RelayConnConfig` is a set of configuration params used by [`RelayConn::new()`].obsRelayConnInternalrefresh_alloc_timerrefresh_perms_timerRelayConn/// `RelayConn` is the implementation of the Conn interfaces for UDP Relayed network connections./// Creates a new [`RelayConn`]." Reads a packet from the connection,"" copying the payload into `p`. It returns the number of"" bytes copied into `p` and the return address that"" was on the packet."" It returns the number of bytes read `(0 <= n <= len(p))`"" and any error encountered. Callers should always process"" the `n > 0` bytes returned before considering the error."" It can be made to time out and return"" an Error with Timeout() == true after a fixed time limit;"" see SetDeadline and SetReadDeadline."" Writes a packet with payload `p` to `addr`."" see SetDeadline and SetWriteDeadline."" On packet-oriented connections, write timeouts are rare."" Returns the local network address."" Closes the connection."" Any blocked [`Self::recv_from()`] or [`Self::send_to()`] operations"" will be unblocked and return errors."/// Creates a new [`RelayConnInternal`]./// Writes a packet with payload `p` to `addr`./// It can be made to time out and return/// an Error with Timeout() == true after a fixed time limit;/// see SetDeadline and SetWriteDeadline./// On packet-oriented connections, write timeouts are rare.create_perm/// This func-block would block, per destination IP (, or perm), until/// the perm state becomes "requested". Purpose of this is to guarantee/// the order of packets (within the same perm)./// Note that CreatePermission transaction may not be complete before/// all the data transmission. This is done assuming that the request/// will be mostly likely successful and we can tolerate some loss of/// UDP packet (or reorder), inorder to minimize the latency in most cases.send_channel_datacreate_permissionsset_nonce_from_msg/// Closes the connection./// Any blocked `recv_from` or `send_to` operations will be unblocked and return errors.refresh_allocationrefresh_permissionssocket_addr2peer_addressPeerAddressMAX_RTX_INTERVAL_IN_MSMAX_RTX_COUNTon_rtx_timeout/// `TransactionResult` is a bag of result values of a transaction.ignore_result// true to throw away the result of this transaction (it will not be readable using wait_for_result)TransactionConfig/// `TransactionConfig` is a set of config params used by [`Transaction::new()`].n_rtxtimer_ch_txresult_ch_txresult_ch_rx/// `Transaction` represents a transaction./// Creates a new [`Transaction`] using the given `config`.start_rtx_timer/// Starts the transaction timer.stop_rtx_timer/// Stops the transaction timer.write_result/// Writes the result to the result channel.get_result_channel/// Returns the result channel./// Closes the transaction./// Returns the number of retransmission it has made./// `TransactionMap` is a thread-safe transaction map./// Create a new [`TransactionMap`]./// Inserts a [`Transaction`] to the map./// Looks up a [`Transaction`] by its key./// Gets the [`Transaction`] associated with the given `key`./// Deletes a [`Transaction`] by its key.close_and_delete_all/// Closes and deletes all [`Transaction`]s./// Returns its length.// total 7 requests (Rc)ErrRelayAddressInvalidErrNoAvailableConnsErrConnUnsetErrListenerUnsetErrListeningAddressInvalidErrRelayAddressGeneratorUnsetErrMaxRetriesExceededErrMaxPortNotZeroErrMinPortNotZeroErrMaxPortLessThanMinPortErrNilConnErrTodoErrAlreadyListeningErrFailedToCloseErrFailedToRetransmitTransactionErrAllRetransmissionsFailedErrChannelBindNotFoundErrStunserverAddressNotSetErrOneAllocateOnlyErrAlreadyAllocatedErrNonStunmessageErrFailedToDecodeStunErrUnexpectedStunrequestMessageErrInvalidChannelNumberErrBadChannelDataLengthErrInvalidRequestedFamilyValueErrPeerAddressFamilyMismatchErrFakeErrErrTryAgainErrClosedErrUdpaddrCastErrAlreadyClosedErrDoubleLockErrTransactionClosedErrWaitForResultOnNonResultTransactionErrFailedToBuildRefreshRequestErrFailedToRefreshAllocationErrFailedToGetLifetimeErrUnexpectedResponseErrAllocatePacketConnMustBeSetErrAllocateConnMustBeSetErrLeveledLoggerMustBeSetErrSameChannelDifferentPeerErrNilFiveTupleErrNilFiveTupleSrcAddrErrNilFiveTupleDstAddrErrNilTurnSocketErrLifetimeZeroErrDupeFiveTupleErrFailedToCastUdpaddrErrFailedToGenerateNonceErrFailedToSendErrorErrDuplicatedNonceErrNoSuchUserErrUnexpectedClassErrUnexpectedMethodErrFailedToHandleErrUnhandledStunpacketErrUnableToHandleChannelDataErrFailedToCreateStunpacketErrFailedToCreateChannelDataErrRelayAlreadyAllocatedForFiveTupleErrRequestedTransportMustBeUdpErrNoDontFragmentSupportErrRequestWithReservationTokenAndEvenPortErrRequestWithReservationTokenAndReqAddressFamilyErrNoAllocationFoundErrNoPermissionErrShortWriteErrNoSuchChannelBindErrFailedWriteSocketParseIptest_addr_from_socket_addrtest_addr_equal_iptest_five_tuple_string/// `Addr` is `ip:port`./// Returns this network.from_socket_addr/// Creates a new [`Addr`] from `n`.equal_ip/// Returns `true` if the `other` has the same IP address.// FiveTuple represents 5-TUPLE value.test_channel_data_encodetest_channel_data_equaltest_channel_data_decodetest_channel_data_resettest_is_channel_dataCHANDATA_TEST_HEXtest_chrome_channel_datachandata_testCHANNEL_DATA_LENGTH_SIZECHANNEL_DATA_NUMBER_SIZECHANNEL_DATA_HEADER_SIZE// can be subslice of Raw/// `ChannelData` represents the `ChannelData` Message defined in/// [RFC 5766 Section 11.4](https://www.rfc-editor.org/rfc/rfc5766#section-11.4)./// Resets length, [`Self::data`] and [`Self::raw`] length./// Encodes this to [`Self::raw`]./// Decodes this from [`Self::raw`]./// Writes channel number and length.is_channel_data/// Returns `true` if `buf` looks like the `ChannelData` Message.test_channel_number_stringtest_channel_number_add_to/*
#[test]
fn test_channel_number_NoAlloc() -> Result<(), stun::Error> {
    let mut m = Message::default();

        if wasAllocs(func() {
            // Case with ChannelNumber on stack.
            n: = ChannelNumber(6)
            n.AddTo(m) //nolint
            m.Reset()
        }) {
        t.Error("Unexpected allocations")
    }

        n: = ChannelNumber(12)
        nP: = &n
        if wasAllocs(func() {
            // On heap.
            nP.AddTo(m) //nolint
            m.Reset()
        }) {
        t.Error("Unexpected allocations")
    }
    Ok(())
}
*/channnum_testCHANNEL_NUMBER_SIZE// 16 bits of uint + 16 bits of RFFU = 0.// See https://tools.ietf.org/html/rfc5766#section-11:// 0x4000 through 0x7FFF: These values are the allowed channel// numbers (16,383 possible values)./// `ChannelNumber` represents `CHANNEL-NUMBER` attribute. Encoded as `u16`./// The `CHANNEL-NUMBER` attribute contains the number of the channel./// [RFC 5766 Section 14.1](https://www.rfc-editor.org/rfc/rfc5766#section-14.1)./// Adds `CHANNEL-NUMBER` to message./// Decodes `CHANNEL-NUMBER` from message.is_channel_number_valid/// Returns true if c in `[0x4000, 0x7FFF]`./// returns `true` if channel number has correct value that complies/// [RFC 5766 Section 11](https://www.rfc-editor.org/rfc/rfc5766#section-11) range.test_data_add_todata_test/// `Data` represents `DATA` attribute./// The `DATA` attribute is present in all Send and Data indications.  The/// value portion of this attribute is variable length and consists of/// the application data (that is, the data that would immediately follow/// the UDP header if the data was been sent directly between the client/// and the peer)./// [RFC 5766 Section 14.4](https://www.rfc-editor.org/rfc/rfc5766#section-14.4)./// Adds `DATA` to message./// Decodes `DATA` from message.test_dont_fragment_falsetest_dont_fragment_add_todontfrag_testDontFragmentAttr/// `DontFragmentAttr` represents `DONT-FRAGMENT` attribute./// Adds `DONT-FRAGMENT` attribute to message./// Returns true if `DONT-FRAGMENT` attribute is set.test_even_port_stringtest_even_port_falsetest_even_port_add_toevenport_testreserve_port/// `reserve_port` means that the server is requested to reserve/// the next-higher port number (on the same IP address)/// for a subsequent allocation./// `EvenPort` represents `EVEN-PORT` attribute./// This attribute allows the client to request that the port in the/// relayed transport address be even, and (optionally) that the server/// reserve the next-higher port number./// [RFC 5766 Section 14.6](https://www.rfc-editor.org/rfc/rfc5766#section-14.6).EVEN_PORT_SIZEFIRST_BIT_SET/// Adds `EVEN-PORT` to message./// Decodes `EVEN-PORT` from message.//FIXME? (1 << 8) - 1;test_lifetime_stringtest_lifetime_add_tolifetime_test/// `DEFAULT_LIFETIME` in RFC 5766 is 10 minutes./// [RFC 5766 Section 2.2](https://www.rfc-editor.org/rfc/rfc5766#section-2.2)./// `Lifetime` represents `LIFETIME` attribute./// The `LIFETIME` attribute represents the duration for which the server/// will maintain an allocation in the absence of a refresh. The value/// portion of this attribute is 4-bytes long and consists of a 32-bit/// unsigned integral value representing the number of seconds remaining/// until expiration./// [RFC 5766 Section 14.2](https://www.rfc-editor.org/rfc/rfc5766#section-14.2).LIFETIME_SIZE// uint32 seconds/// Adds `LIFETIME` to message./// Decodes `LIFETIME` from message.// 4 bytes, 32 bitsproto_testdontfragevenportreqfamilyrsrvtoken/// `Protocol` is IANA assigned protocol number.PROTO_TCP/// `PROTO_TCP` is IANA assigned protocol number for TCP./// `PROTO_UDP` is IANA assigned protocol number for UDP./// `DEFAULT_PORT` for TURN is same as STUN./// `DEFAULT_TLSPORT` is for TURN over TLS and is same as STUN.create_permission_request/// Shorthand for create permission request type.allocate_request/// Shorthand for allocation request message type.send_indication/// Shorthand for send indication message type.refresh_request/// Shorthand for refresh request message type.// proto implements RFC 5766 Traversal Using Relays around NAT.// Default ports for TURN from RFC 5766 Section 4.test_peer_addresspeeraddr_test/// `PeerAddress` implements `XOR-PEER-ADDRESS` attribute./// The `XOR-PEER-ADDRESS` specifies the address and port of the peer as/// seen from the TURN server. (For example, the peer's server-reflexive/// transport address if the peer is behind a NAT.)/// [RFC 5766 Section 14.3](https://www.rfc-editor.org/rfc/rfc5766#section-14.3)./// Adds `XOR-PEER-ADDRESS` to message./// Decodes `XOR-PEER-ADDRESS` from message.CHROME_ALLOC_REQ_TEST_HEXtest_chrome_alloc_requesttest_relayed_addressrelayaddr_testRelayedAddress/// `RelayedAddress` implements `XOR-RELAYED-ADDRESS` attribute./// It specifies the address and port that the server allocated to the/// client. It is encoded in the same way as `XOR-MAPPED-ADDRESS`./// [RFC 5766 Section 14.5](https://www.rfc-editor.org/rfc/rfc5766#section-14.5).XorRelayedAddress/// `XorRelayedAddress` implements `XOR-RELAYED-ADDRESS` attribute.test_requested_address_family_stringtest_requested_address_family_add_toreqfamily_testREQUESTED_FAMILY_IPV4// Values for RequestedAddressFamily as defined in RFC 6156 Section 4.1.1.REQUESTED_FAMILY_IPV6/// `RequestedAddressFamily` represents the `REQUESTED-ADDRESS-FAMILY` Attribute as/// defined in [RFC 6156 Section 4.1.1](https://www.rfc-editor.org/rfc/rfc6156#section-4.1.1).REQUESTED_FAMILY_SIZE/// Adds `REQUESTED-ADDRESS-FAMILY` to message./// Decodes `REQUESTED-ADDRESS-FAMILY` from message.test_requested_transport_stringtest_requested_transport_add_toreqtrans_test/// `RequestedTransport` represents `REQUESTED-TRANSPORT` attribute./// This attribute is used by the client to request a specific transport/// protocol for the allocated transport address. RFC 5766 only allows the use of/// codepoint 17 (User Datagram protocol)./// [RFC 5766 Section 14.7](https://www.rfc-editor.org/rfc/rfc5766#section-14.7).REQUESTED_TRANSPORT_SIZE/// Adds `REQUESTED-TRANSPORT` to message./// Decodes `REQUESTED-TRANSPORT` from message.test_reservation_tokenrsrvtoken_test/// `ReservationToken` represents `RESERVATION-TOKEN` attribute./// The `RESERVATION-TOKEN` attribute contains a token that uniquely/// identifies a relayed transport address being held in reserve by the/// server. The server includes this attribute in a success response to/// tell the client about the token, and the client includes this/// attribute in a subsequent Allocate request to request the server use/// that relayed transport address for the allocation./// [RFC 5766 Section 14.9](https://www.rfc-editor.org/rfc/rfc5766#section-14.9).RESERVATION_TOKEN_SIZE/// Adds `RESERVATION-TOKEN` to message./// Decodes `RESERVATION-TOKEN` from message.// 8 bytesrelay_range" Confirms that this is properly initialized"" Allocates a Relay Address"allocate_conn" `RelayAddressGenerator` is used to generate a Relay Address when creating an allocation."" You can use one of the provided ones or provide your own."/// `address` is passed to Listen/ListenPacket when creating the Relay.RelayAddressGeneratorNone/// `RelayAddressGeneratorNone` returns the listener with no modifications.DEFAULT_MAX_RETRIES/// Default maximum number of retries when allocating a random port in the defined range.relay_address/// `relay_address` is the IP returned to the user when the relay is created.min_port/// `min_port` the minimum port to allocate.max_port/// `max_port` the maximum (inclusive) port to allocate.max_retries/// `max_retries` the amount of tries to allocate a random port in the defined range.RelayAddressGeneratorRanges/// `RelayAddressGeneratorRanges` can be used to only allocate connections inside a defined port range./// `RelayAddressGeneratorStatic` can be used to return static IP address each time a relay is created./// This can be used when you have a single static IP address that you want to use.// When an allocation is generated the RelayAddressGenerator// creates the net.PacketConn and returns the IP/Port it is available at/// ConnConfig is used for UDP listenersconn_configs/// `conn_configs` are a list of all the turn listeners./// Each listener can have custom behavior around the creation of Relays./// `realm` sets the realm for this serverauth_handler/// `auth_handler` is a callback used to handle incoming auth requests,/// allowing users to customize Pion TURN with custom behavior.channel_bind_timeout/// `channel_bind_timeout` sets the lifetime of channel binding. Defaults to 10 minutes./// To receive notify on allocation close event, with metrics data./// ServerConfig configures the TURN Serverserver_testINBOUND_MTUnoncescommand_tx/// Server is an instance of the TURN Server/// creates a new TURN server/// Deletes all existing [`Allocation`][`Allocation`]s by the provided `username`./// [`Allocation`]: crate::allocation::Allocation/// Get information of [`Allocation`][`Allocation`]s by specified [`FiveTuple`]s./// If `five_tuples` is:/// - [`None`]: It returns information about the all///   [`Allocation`][`Allocation`]s./// - [`Some`] and not empty: It returns information about///   the [`Allocation`][`Allocation`]s associated with///   the specified [`FiveTuples`]./// - [`Some`], but empty: It returns an empty [`HashMap`].read_loop/// Close stops the TURN Server. It cleans up any associated state and closes all connections it is managing.DeleteAllocations/// Command to delete [`Allocation`][`Allocation`] by provided `username`./// [`Allocation`]: `crate::allocation::Allocation`GetAllocationsInfo/// Command to get information of [`Allocation`][`Allocation`]s by provided [`FiveTuple`]s./// Command to close the [`Server`]./// The protocol to communicate between the [`Server`]'s public methods/// and the tasks spawned in the [`Server::read_loop`] method.STATIC_KEYtest_allocation_lifetime_parsingtest_allocation_lifetime_overflowtest_allocation_lifetime_deletion_zero_lifetimerequest_testMAXIMUM_ALLOCATION_LIFETIMENONCE_LIFETIME// https://tools.ietf.org/html/rfc5766#section-6.2 defines 3600 seconds recommendation// Current Request Statebuff// Server State// User Configuration/// Request contains all the state needed to process a single incoming datagramhandle_request/// Processes the give [`Request`]handle_data_packethandle_turn_packetprocess_message_handlerauthenticate_requestrespond_with_noncehandle_binding_requesthandle_allocate_request/// https://tools.ietf.org/html/rfc5766#section-6.2handle_refresh_requesthandle_create_permission_requesthandle_send_indicationhandle_channel_bind_requestrand_seqbuild_noncebuild_and_send_err/// Send a STUN packet and return the original error to the callerbuild_msgallocation_lifetime// https://tools.ietf.org/html/rfc5766#section-4Niccred_maptest_server_simplewanRouternet0net1netl0VNetbuild_vnettest_server_vnet_send_binding_requesttest_server_vnet_echo_via_relayemit_implsfeature_gate_to_64_bitgeneric_const_mappingsUIntCodeIntCodegen_uintgen_intforce_unix_path_separatorHIGHEST// fixme: get a warning when testing without thisOpTypeexampleop_typewrite_op_macrogcdi/// Computes the greatest common divisor of two integers.gcduUIntTestuint_binary_testIntBinaryTestint_binary_testIntUnaryTestint_unary_testuint_cmp_testint_cmp_testbuild_tests// Allow for rustc 1.22 compatibility.// fn uint_unary_test(op: &'static str, a: u64, result: u64) -> UIntTest {//     UIntTest { a: a, op: op, b: Option::None, r: result }ATerm/// The terminating type for type arrays.TArr/// `TArr` is a type that acts as an array of types. It is defined similarly to `UInt`, only its/// values can be more than bits, and it is designed to act as an array. So you can only add two if/// they have the same number of elements, for example./// This array is only really designed to contain `Integer` types. If you use it with others, you/// may find it lacking functionality.tarr/// Create a new type-level array. Only usable on Rust 1.13.0 or newer./// There's not a whole lot you can do with it right now./// extern crate typenum;/// use typenum::consts::*;/// type Array = tarr![P3, N4, Z0, P38];/// # fn main() { let _: Array; }/// Length of `ATerm` by itself is 0/// Size of a `TypeArray`VlVrArProdPIntNIntQuotpartial_div// ---------------------------------------------------------------------------------------// Modulo an array by a scalar// Negate an arrayNegate//! A type-level array of type-level numbers.//! It is not very featureful right now, and should be considered a work in progress.// Length// Add arrays// Note that two arrays are only addable if they are the same length.// Subtract arrays// Note that two arrays are only subtractable if they are the same length.// Multiply an array by a scalar// Divide an array by a scalar// Partial Divide an array by a scalarInternalMarkerPowerOfTwoBit/// The type-level bit 0./// Instantiates a singleton representing this bit./// The type-level bit 1./// Not of 0 (!0 = 1)/// Not of 1 (!1 = 0)/// And with 0 ( 0 & B = 0)/// And with 1 ( 1 & 0 = 0)/// And with 1 ( 1 & 1 = 1)/// Or with 0 ( 0 | 0 = 0)/// Or with 0 ( 0 | 1 = 1)/// Or with 1 ( 1 | B = 1)/// Xor between 0 and 0 ( 0 ^ 0 = 0)/// Xor between 1 and 0 ( 1 ^ 0 = 1)/// Xor between 0 and 1 ( 0 ^ 1 = 1)/// Xor between 1 and 1 ( 1 ^ 1 = 0)bit_creation//! Type-level bits.//! These are rather simple and are used as the building blocks of the//! other number types in this crate.//! **Type operators** implemented://! - From `core::ops`: `BitAnd`, `BitOr`, `BitXor`, and `Not`.//! - From `typenum`: `Same` and `Cmp`.PrivateDivIntPrivateIntegerAddPrivateRemToInt/// Type-level signed integers with positive sign./// Type-level signed integers with negative sign./// Instantiates a singleton representing this strictly positive integer./// Instantiates a singleton representing this strictly negative integer./// The type-level signed integer 0./// Instantiates a singleton representing the integer 0.ISIZE// Simply negating the result of e.g. `U::I8` will result in overflow for `std::i8::MIN`. Instead,// we use the fact that `U: NonZero` by subtracting one from the `U::U8` before negating./// `-Z0 = Z0`/// `-PInt = NInt`/// `-NInt = PInt`/// `Z0 + I = I`/// `PInt + Z0 = PInt`/// `NInt + Z0 = NInt`UlUr/// `P(Ul) + P(Ur) = P(Ul + Ur)`/// `N(Ul) + N(Ur) = N(Ul + Ur)`/// `P(Ul) + N(Ur)`: We resolve this with our `PrivateAdd`/// `N(Ul) + P(Ur)`: We resolve this with our `PrivateAdd`// We just do the same thing as above, swapping Lhs and Rhsprivate_integer_add/// `P + N = 0` where `P == N`/// `P + N = Positive` where `P > N`/// `P + N = Negative` where `P < N`/// `Z0 - Z0 = Z0`/// `Z0 - P = N`/// `Z0 - N = P`/// `PInt - Z0 = PInt`/// `NInt - Z0 = NInt`/// `P(Ul) - N(Ur) = P(Ul + Ur)`/// `N(Ul) - P(Ur) = N(Ul + Ur)`/// `P(Ul) - P(Ur)`: We resolve this with our `PrivateAdd`/// `N(Ul) - N(Ur)`: We resolve this with our `PrivateAdd`/// `Z0 * I = Z0`/// `P * Z0 = Z0`/// `N * Z0 = Z0`/// P(Ul) * P(Ur) = P(Ul * Ur)/// N(Ul) * N(Ur) = P(Ul * Ur)/// P(Ul) * N(Ur) = N(Ul * Ur)/// N(Ul) * P(Ur) = N(Ul * Ur)/// `Z0 / I = Z0` where `I != 0`impl_int_divr" `$A<Ul> / $B<Ur> = $R<Ul / Ur>`"private_div_intIM/// 0 == 0/// 0 > -X/// 0 < X/// X > 0/// -X < 0/// -X < Y/// X > - YPlPr/// X <==> YNr/// -X <==> -Y/// `Z0 % I = Z0` where `I != 0`impl_int_remr" `$A<Ul> % $B<Ur> = $R<Ul % Ur>`"private_rem/// 0^0 = 1/// 0^P = 0/// 0^N = 0/// 1^N = 1/// (-1)^N = 1 if N is even/// (-1)^N = -1 if N is odd/// P^0 = 1/// N^0 = 1/// P(Ul)^P(Ur) = P(Ul^Ur)/// N(Ul)^P(Ur) = P(Ul^Ur) if Ur is even/// N(Ul)^P(Ur) = N(Ul^Ur) if Ur is oddGcdGcf// Gcd// Minto_ix_minint_toint_test//! Type-level signed integers.//! Type **operators** implemented://! From `core::ops`: `Add`, `Sub`, `Mul`, `Div`, and `Rem`.//! From `typenum`: `Same`, `Cmp`, and `Pow`.//! Rather than directly using the structs defined in this module, it is recommended that//! you import and use the relevant aliases from the [consts](../consts/index.html) module.//! Note that operators that work on the underlying structure of the number are//! intentionally not implemented. This is because this implementation of signed integers//! does *not* use twos-complement, and implementing them would require making arbitrary//! choices, causing the results of such operators to be difficult to reason about.//! use std::ops::{Add, Div, Mul, Rem, Sub};//! use typenum::{Integer, N3, P2};//! assert_eq!(<N3 as Add<P2>>::Output::to_i32(), -1);//! assert_eq!(<N3 as Sub<P2>>::Output::to_i32(), -5);//! assert_eq!(<N3 as Mul<P2>>::Output::to_i32(), -6);//! assert_eq!(<N3 as Div<P2>>::Output::to_i32(), -1);//! assert_eq!(<N3 as Rem<P2>>::Output::to_i32(), -1);// Neg// Add// Sub// Mul// Div// PartialDiv// Cmp// Rem// Pow// Max// -----------------------------------------// ToInt// negative numbers// positive numbers"\nConvenient type operations.\n\nAny types representing values must be able to be expressed as `ident`s. That means they need to be\nin scope.\n\nFor example, `P5` is okay, but `typenum::P5` is not.\n\nYou may combine operators arbitrarily, although doing so excessively may require raising the\nrecursion limit.\n\n# Example\n```rust\n#![recursion_limit=\"128\"]\n#[macro_use] extern crate typenum;\nuse typenum::consts::*;\n\nfn main() {\n    assert_type!(\n        op!(min((P1 - P2) * (N3 + N7), P5 * (P3 + P4)) == P10)\n    );\n}\n```\nOperators are evaluated based on the operator precedence outlined\n[here](https://doc.rust-lang.org/reference.html#operator-precedence).\n\nThe full list of supported operators and functions is as follows:\n\n`*`, `/`, `%`, `+`, `-`, `<<`, `>>`, `&`, `^`, `|`, `==`, `!=`, `<=`, `>=`, `<`, `>`, `cmp`, `sqr`, `sqrt`, `abs`, `cube`, `pow`, `min`, `max`, `log2`, `gcd`\n\nThey all expand to type aliases defined in the `operator_aliases` module. Here is an expanded list,\nincluding examples:\n\n---\nOperator `*`. Expands to `Prod`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P2 * P3), P6);\n# }\n```\n\n---\nOperator `/`. Expands to `Quot`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P6 / P2), P3);\n# }\n```\n\n---\nOperator `%`. Expands to `Mod`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P5 % P3), P2);\n# }\n```\n\n---\nOperator `+`. Expands to `Sum`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P2 + P3), P5);\n# }\n```\n\n---\nOperator `-`. Expands to `Diff`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P2 - P3), N1);\n# }\n```\n\n---\nOperator `<<`. Expands to `Shleft`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(U1 << U5), U32);\n# }\n```\n\n---\nOperator `>>`. Expands to `Shright`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(U32 >> U5), U1);\n# }\n```\n\n---\nOperator `&`. Expands to `And`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(U5 & U3), U1);\n# }\n```\n\n---\nOperator `^`. Expands to `Xor`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(U5 ^ U3), U6);\n# }\n```\n\n---\nOperator `|`. Expands to `Or`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(U5 | U3), U7);\n# }\n```\n\n---\nOperator `==`. Expands to `Eq`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P5 == P3 + P2), True);\n# }\n```\n\n---\nOperator `!=`. Expands to `NotEq`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P5 != P3 + P2), False);\n# }\n```\n\n---\nOperator `<=`. Expands to `LeEq`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P6 <= P3 + P2), False);\n# }\n```\n\n---\nOperator `>=`. Expands to `GrEq`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P6 >= P3 + P2), True);\n# }\n```\n\n---\nOperator `<`. Expands to `Le`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P4 < P3 + P2), True);\n# }\n```\n\n---\nOperator `>`. Expands to `Gr`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(P5 < P3 + P2), False);\n# }\n```\n\n---\nOperator `cmp`. Expands to `Compare`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(cmp(P2, P3)), Less);\n# }\n```\n\n---\nOperator `sqr`. Expands to `Square`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(sqr(P2)), P4);\n# }\n```\n\n---\nOperator `sqrt`. Expands to `Sqrt`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(sqrt(U9)), U3);\n# }\n```\n\n---\nOperator `abs`. Expands to `AbsVal`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(abs(N2)), P2);\n# }\n```\n\n---\nOperator `cube`. Expands to `Cube`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(cube(P2)), P8);\n# }\n```\n\n---\nOperator `pow`. Expands to `Exp`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(pow(P2, P3)), P8);\n# }\n```\n\n---\nOperator `min`. Expands to `Minimum`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(min(P2, P3)), P2);\n# }\n```\n\n---\nOperator `max`. Expands to `Maximum`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(max(P2, P3)), P3);\n# }\n```\n\n---\nOperator `log2`. Expands to `Log2`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(log2(U9)), U3);\n# }\n```\n\n---\nOperator `gcd`. Expands to `Gcf`.\n\n```rust\n# #[macro_use] extern crate typenum;\n# use typenum::*;\n# fn main() {\nassert_type_eq!(op!(gcd(U9, U21)), U3);\n# }\n```\n\n"__op_internal__"\nType aliases for many constants.\n\nThis file is generated by typenum\'s build script.\n\nFor unsigned integers, the format is `U` followed by the number. We define aliases for\n\n- Numbers 0 through 1024\n- Powers of 2 below `u64::MAX`\n- Powers of 10 below `u64::MAX`\n\nThese alias definitions look like this:\n\n```rust\nuse typenum::{B0, B1, UInt, UTerm};\n\n# #[allow(dead_code)]\ntype U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;\n```\n\nFor positive signed integers, the format is `P` followed by the number and for negative\nsigned integers it is `N` followed by the number. For the signed integer zero, we use\n`Z0`. We define aliases for\n\n- Numbers -1024 through 1024\n- Powers of 2 between `i64::MIN` and `i64::MAX`\n- Powers of 10 between `i64::MIN` and `i64::MAX`\n\nThese alias definitions look like this:\n\n```rust\nuse typenum::{B0, B1, UInt, UTerm, PInt, NInt};\n\n# #[allow(dead_code)]\ntype P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;\n# #[allow(dead_code)]\ntype N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;\n```\n\n# Example\n```rust\n# #[allow(unused_imports)]\nuse typenum::{U0, U1, U2, U3, U4, U5, U6};\n# #[allow(unused_imports)]\nuse typenum::{N3, N2, N1, Z0, P1, P2, P3};\n# #[allow(unused_imports)]\nuse typenum::{U774, N17, N10000, P1024, P4096};\n```\n\nWe also define the aliases `False` and `True` for `B0` and `B1`, respectively.\n"P16P17P18P19P20P21P22P23P24P25P26P27P28P29P30P31P32P33N33P34N34P35N35P36N36P37N37P38N38P39N39P40N40P41N41P42N42P43N43P44N44P45N45P46N46P47N47P48N48P49N49P50N50P51N51P52N52P53N53P54N54P55N55P56N56P57N57P58N58P59N59P60N60P61N61P62N62P63N63P64N64U65P65N65P66N66U67P67N67U68P68N68U69P69N69P70N70U71P71N71P72N72U73P73N73U74P74N74U75P75N75U76P76N76U77P77N77U78P78N78U79P79N79P80N80U81P81N81U82P82N82U83P83N83U84P84N84U85P85N85U86P86N86U87P87N87U88P88N88U89P89N89P90N90U91P91N91U92P92N92U93P93N93U94P94N94U95P95N95P96N96U97P97N97U98P98N98U99P99N99P100N100U101P101N101U102P102N102U103P103N103P104N104U105P105N105U106P106N106U107P107N107U108P108N108U109P109N109U110P110N110U111P111N111P112N112U113P113N113U114P114N114U115P115N115U116P116N116U117P117N117U118P118N118U119P119N119U120P120N120U121P121N121U122P122N122U123P123N123U124P124N124U125P125N125U126P126N126U127P127N127P128N128U129P129N129U130P130N130U131P131N131U132P132N132U133P133N133U134P134N134U135P135N135U136P136N136U137P137N137U138P138N138U139P139N139U140P140N140U141P141N141U142P142N142U143P143N143U144P144N144U145P145N145U146P146N146U147P147N147U148P148N148U149P149N149U150P150N150U151P151N151U152P152N152U153P153N153U154P154N154U155P155N155U156P156N156U157P157N157U158P158N158U159P159N159U160P160N160U161P161N161U162P162N162U163P163N163U164P164N164U165P165N165U166P166N166U167P167N167U168P168N168U169P169N169U170P170N170U171P171N171U172P172N172U173P173N173U174P174N174U175P175N175U176P176N176U177P177N177U178P178N178U179P179N179U180P180N180U181P181N181U182P182N182U183P183N183U184P184N184U185P185N185U186P186N186U187P187N187U188P188N188U189P189N189U190P190N190U191P191N191P192N192U193P193N193U194P194N194U195P195N195U196P196N196U197P197N197U198P198N198U199P199N199P200N200U201P201N201U202P202N202U203P203N203U204P204N204U205P205N205U206P206N206U207P207N207U208P208N208U209P209N209U210N210U211P211N211U212P212N212U213P213N213U214P214N214U215P215N215U216P216N216U217P217N217U218P218N218U219P219N219U220P220N220U221P221N221U222P222N222U223P223N223P224N224U225P225N225U226P226N226U227P227N227U228P228N228U229P229N229U230P230N230U231P231N231U232P232N232U233P233N233U234P234N234U235P235N235U236P236N236U237P237N237U238P238N238U239P239N239U240P240N240U241P241N241U242P242N242U243P243N243U244P244N244U245P245N245U246P246N246U247P247N247U248P248N248U249P249N249U250P250N250U251P251N251U252P252N252U253P253N253U254P254N254U255P255N255N256U257P257N257U258P258N258U259P259N259U260P260N260U261P261N261U262P262N262U263P263N263U264P264N264U265P265N265U266P266N266U267P267N267U268P268N268U269P269N269U270P270N270U271P271N271U272P272N272U273P273N273U274P274N274U275P275N275U276P276N276U277P277N277U278P278N278U279P279N279U280P280N280U281P281N281U282P282N282U283P283N283U284P284N284U285P285N285U286P286N286U287P287N287U288P288N288U289P289N289U290P290N290U291P291N291U292P292N292U293P293N293U294P294N294U295P295N295U296P296N296U297P297N297U298P298N298U299P299N299P300N300U301P301N301U302P302N302U303P303N303U304P304N304U305P305N305U306P306N306U307P307N307U308P308N308U309P309N309U310P310N310U311P311N311U312P312N312U313P313N313U314P314N314U315P315N315U316P316N316U317P317N317U318P318N318U319P319N319P320N320U321P321N321U322P322N322U323P323N323U324P324N324U325P325N325U326P326N326U327P327N327U328P328N328U329P329N329U330P330N330U331P331N331U332P332N332U333P333N333U334P334N334U335P335N335U336P336N336U337P337N337U338P338N338U339P339N339U340P340N340U341P341N341U342P342N342U343P343N343U344P344N344U345P345N345U346P346N346U347P347N347U348P348N348U349P349N349U350P350N350U351P351N351U352P352N352U353P353N353U354P354N354U355P355N355U356P356N356U357P357N357U358P358N358U359P359N359U360P360N360U361P361N361U362P362N362U363P363N363U364P364N364U365P365N365U366P366N366U367P367N367U368P368N368U369P369N369U370P370N370U371P371N371U372P372N372U373P373N373U374P374N374U375P375N375U376P376N376U377P377N377U378P378N378U379P379N379U380P380N380U381P381N381U382P382N382U383P383N383N384U385P385N385U386P386N386U387P387N387U388P388N388U389P389N389U390P390N390U391P391N391U392P392N392U393P393N393U394P394N394U395P395N395U396P396N396U397P397N397U398P398N398U399P399N399P400N400U401P401N401U402P402N402U403P403N403U404P404N404U405P405N405U406P406N406U407P407N407U408P408N408U409P409N409U410P410N410U411P411N411U412P412N412U413P413N413U414P414N414U415P415N415U416P416N416U417P417N417U418P418N418U419P419N419U420P420N420U421P421N421U422P422N422U423P423N423U424P424N424U425P425N425U426P426N426U427P427N427U428P428N428U429P429N429U430P430N430U431P431N431U432P432N432U433P433N433U434P434N434U435P435N435U436P436N436U437P437N437U438P438N438U439P439N439U440P440N440U441P441N441U442P442N442U443P443N443U444P444N444U445P445N445U446P446N446U447P447N447P448N448U449P449N449U450P450N450U451P451N451U452P452N452U453P453N453U454P454N454U455P455N455U456P456N456U457P457N457U458P458N458U459P459N459U460P460N460U461P461N461U462P462N462U463P463N463U464P464N464U465P465N465U466P466N466U467P467N467U468P468N468U469P469N469U470P470N470U471P471N471U472P472N472U473P473N473U474P474N474U475P475N475U476P476N476U477P477N477U478P478N478U479P479N479U480P480N480U481P481N481U482P482N482U483P483N483U484P484N484U485P485N485U486P486N486U487P487N487U488P488N488U489P489N489U490P490N490U491P491N491U492P492N492U493P493N493U494P494N494U495P495N495U496P496N496U497P497N497U498P498N498U499P499N499P500N500U501P501N501U502P502N502U503P503N503U504P504N504U505P505N505U506P506N506U507P507N507U508P508N508U509P509N509U510P510N510U511P511N511P512N512U513P513N513U514P514N514U515P515N515U516P516N516U517P517N517U518P518N518U519P519N519U520P520N520U521P521N521U522P522N522U523P523N523U524P524N524U525P525N525U526P526N526U527P527N527U528P528N528U529P529N529U530P530N530U531P531N531U532P532N532U533P533N533U534P534N534U535P535N535U536P536N536U537P537N537U538P538N538U539P539N539U540P540N540U541P541N541U542P542N542U543P543N543U544P544N544U545P545N545U546P546N546U547P547N547U548P548N548U549P549N549U550P550N550U551P551N551U552P552N552U553P553N553U554P554N554U555P555N555U556P556N556U557P557N557U558P558N558U559P559N559U560P560N560U561P561N561U562P562N562U563P563N563U564P564N564U565P565N565U566P566N566U567P567N567U568P568N568U569P569N569U570P570N570U571P571N571U572P572N572U573P573N573U574P574N574U575P575N575P576N576U577P577N577U578P578N578U579P579N579U580P580N580U581P581N581U582P582N582U583P583N583U584P584N584U585P585N585U586P586N586U587P587N587U588P588N588U589P589N589U590P590N590U591P591N591U592P592N592U593P593N593U594P594N594U595P595N595U596P596N596U597P597N597U598P598N598U599P599N599U600P600N600U601P601N601U602P602N602U603P603N603U604P604N604U605P605N605U606P606N606U607P607N607U608P608N608U609P609N609U610P610N610U611P611N611U612P612N612U613P613N613U614P614N614U615P615N615U616P616N616U617P617N617U618P618N618U619P619N619U620P620N620U621P621N621U622P622N622U623P623N623U624P624N624U625P625N625U626P626N626U627P627N627U628P628N628U629P629N629U630P630N630U631P631N631U632P632N632U633P633N633U634P634N634U635P635N635U636P636N636U637P637N637U638P638N638U639P639N639P640N640U641P641N641U642P642N642U643P643N643U644P644N644U645P645N645U646P646N646U647P647N647U648P648N648U649P649N649U650P650N650U651P651N651U652P652N652U653P653N653U654P654N654U655P655N655U656P656N656U657P657N657U658P658N658U659P659N659U660P660N660U661P661N661U662P662N662U663P663N663U664P664N664U665P665N665U666P666N666U667P667N667U668P668N668U669P669N669U670P670N670U671P671N671U672P672N672U673P673N673U674P674N674U675P675N675U676P676N676U677P677N677U678P678N678U679P679N679U680P680N680U681P681N681U682P682N682U683P683N683U684P684N684U685P685N685U686P686N686U687P687N687U688P688N688U689P689N689U690P690N690U691P691N691U692P692N692U693P693N693U694P694N694U695P695N695U696P696N696U697P697N697U698P698N698U699P699N699U700P700N700U701P701N701U702P702N702U703P703N703P704N704U705P705N705U706P706N706U707P707N707U708P708N708U709P709N709U710P710N710U711P711N711U712P712N712U713P713N713U714P714N714U715P715N715U716P716N716U717P717N717U718P718N718U719P719N719U720P720N720U721P721N721U722P722N722U723P723N723U724P724N724U725P725N725U726P726N726U727P727N727U728P728N728U729P729N729U730P730N730U731P731N731U732P732N732U733P733N733U734P734N734U735P735N735U736P736N736U737P737N737U738P738N738U739P739N739U740P740N740U741P741N741U742P742N742U743P743N743U744P744N744U745P745N745U746P746N746U747P747N747U748P748N748U749P749N749U750P750N750U751P751N751U752P752N752U753P753N753U754P754N754U755P755N755U756P756N756U757P757N757U758P758N758U759P759N759U760P760N760U761P761N761U762P762N762U763P763N763U764P764N764U765P765N765U766P766N766U767P767N767P768N768U769P769N769U770P770N770U771P771N771U772P772N772U773P773N773U774P774N774U775P775N775U776P776N776U777P777N777U778P778N778U779P779N779U780P780N780U781P781N781U782P782N782U783P783N783U784P784N784U785P785N785U786P786N786U787P787N787U788P788N788U789P789N789U790P790N790U791P791N791U792P792N792U793P793N793U794P794N794U795P795N795U796P796N796U797P797N797U798P798N798U799P799N799U800P800N800U801P801N801U802P802N802U803P803N803U804P804N804U805P805N805U806P806N806U807P807N807U808P808N808U809P809N809U810P810N810U811P811N811U812P812N812U813P813N813U814P814N814U815P815N815U816P816N816U817P817N817U818P818N818U819P819N819U820P820N820U821P821N821U822P822N822U823P823N823U824P824N824U825P825N825U826P826N826U827P827N827U828P828N828U829P829N829U830P830N830U831P831N831P832N832U833P833N833U834P834N834U835P835N835U836P836N836U837P837N837U838P838N838U839P839N839U840P840N840U841P841N841U842P842N842U843P843N843U844P844N844U845P845N845U846P846N846U847P847N847U848P848N848U849P849N849U850P850N850U851P851N851U852P852N852U853P853N853U854P854N854U855P855N855U856P856N856U857P857N857U858P858N858U859P859N859U860P860N860U861P861N861U862P862N862U863P863N863U864P864N864U865P865N865U866P866N866U867P867N867U868P868N868U869P869N869U870P870N870U871P871N871U872P872N872U873P873N873U874P874N874U875P875N875U876P876N876U877P877N877U878P878N878U879P879N879U880P880N880U881P881N881U882P882N882U883P883N883U884P884N884U885P885N885U886P886N886U887P887N887U888P888N888U889P889N889U890P890N890U891P891N891U892P892N892U893P893N893U894P894N894U895P895N895P896N896U897P897N897U898P898N898U899P899N899U900P900N900U901P901N901U902P902N902U903P903N903U904P904N904U905P905N905U906P906N906U907P907N907U908P908N908U909P909N909U910P910N910U911P911N911U912P912N912U913P913N913U914P914N914U915P915N915U916P916N916U917P917N917U918P918N918U919P919N919U920P920N920U921P921N921U922P922N922U923P923N923U924P924N924U925P925N925U926P926N926U927P927N927U928P928N928U929P929N929U930P930N930U931P931N931U932P932N932U933P933N933U934P934N934U935P935N935U936P936N936U937P937N937U938P938N938U939P939N939U940P940N940U941P941N941U942P942N942U943P943N943U944P944N944U945P945N945U946P946N946U947P947N947U948P948N948U949P949N949U950P950N950U951P951N951U952P952N952U953P953N953U954P954N954U955P955N955U956P956N956U957P957N957U958P958N958U959P959N959P960N960U961P961N961U962P962N962U963P963N963U964P964N964U965P965N965U966P966N966U967P967N967U968P968N968U969P969N969U970P970N970U971P971N971U972P972N972U973P973N973U974P974N974U975P975N975U976P976N976U977P977N977U978P978N978U979P979N979U980P980N980U981P981N981U982P982N982U983P983N983U984P984N984U985P985N985U986P986N986U987P987N987U988P988N988U989P989N989U990P990N990U991P991N991U992P992N992U993P993N993U994P994N994U995P995N995U996P996N996U997P997N997U998P998N998U999P999N999P1000N1000U1001P1001N1001U1002P1002N1002U1003P1003N1003U1004P1004N1004U1005P1005N1005U1006P1006N1006U1007P1007N1007U1008P1008N1008U1009P1009N1009U1010P1010N1010U1011P1011N1011U1012P1012N1012U1013P1013N1013U1014P1014N1014U1015P1015N1015U1016P1016N1016U1017P1017N1017U1018P1018N1018U1019P1019N1019U1020P1020N1020U1021P1021N1021U1022P1022N1022U1023P1023N1023P1024N1024P2048N2048P4096N4096P8192N8192P16384N16384P32768N32768U65536P65536N65536U131072P131072N131072U262144P262144N262144U524288P524288N524288U1048576P1048576N1048576U2097152P2097152N2097152U4194304P4194304N4194304U8388608P8388608N8388608U16777216P16777216N16777216U33554432P33554432N33554432U67108864P67108864N67108864U134217728P134217728N134217728U268435456P268435456N268435456U536870912P536870912N536870912U1073741824P1073741824N1073741824U2147483648P2147483648N2147483648U4294967296P4294967296N4294967296U8589934592P8589934592N8589934592U17179869184P17179869184N17179869184U34359738368P34359738368N34359738368U68719476736P68719476736N68719476736U137438953472P137438953472N137438953472U274877906944P274877906944N274877906944U549755813888P549755813888N549755813888U1099511627776P1099511627776N1099511627776U2199023255552P2199023255552N2199023255552U4398046511104P4398046511104N4398046511104U8796093022208P8796093022208N8796093022208U17592186044416P17592186044416N17592186044416U35184372088832P35184372088832N35184372088832U70368744177664P70368744177664N70368744177664U140737488355328P140737488355328N140737488355328U281474976710656P281474976710656N281474976710656U562949953421312P562949953421312N562949953421312U1125899906842624P1125899906842624N1125899906842624U2251799813685248P2251799813685248N2251799813685248U4503599627370496P4503599627370496N4503599627370496U9007199254740992P9007199254740992N9007199254740992U18014398509481984P18014398509481984N18014398509481984U36028797018963968P36028797018963968N36028797018963968U72057594037927936P72057594037927936N72057594037927936U144115188075855872P144115188075855872N144115188075855872U288230376151711744P288230376151711744N288230376151711744U576460752303423488P576460752303423488N576460752303423488U1152921504606846976P1152921504606846976N1152921504606846976U2305843009213693952P2305843009213693952N2305843009213693952U4611686018427387904P4611686018427387904N4611686018427387904U9223372036854775808U10000P10000N10000U100000P100000N100000U1000000P1000000N1000000U10000000P10000000N10000000U100000000P100000000N100000000U1000000000P1000000000N1000000000U10000000000P10000000000N10000000000U100000000000P100000000000N100000000000U1000000000000P1000000000000N1000000000000U10000000000000P10000000000000N10000000000000U100000000000000P100000000000000N100000000000000U1000000000000000P1000000000000000N1000000000000000U10000000000000000P10000000000000000N10000000000000000U100000000000000000P100000000000000000N100000000000000000U1000000000000000000P1000000000000000000N1000000000000000000U10000000000000000000type_operators/// A potential output from `Cmp`, this is the type equivalent to the enum variant/// `core::cmp::Ordering::Greater`./// `core::cmp::Ordering::Less`./// `core::cmp::Ordering::Equal`.to_ordering/// Returns `core::cmp::Ordering::Greater`/// Returns `core::cmp::Ordering::Less`/// Returns `core::cmp::Ordering::Equal`assert_type_eq/// Asserts that two types are the same./// Asserts that a type is `True`, aka `B1`.//! This crate provides type-level numbers evaluated at compile time. It depends only on libcore.//! The traits defined or used in this crate are used in a typical manner. They can be divided into//! two categories: **marker traits** and **type operators**.//! Many of the marker traits have functions defined, but they all do essentially the same thing://! convert a type into its runtime counterpart, and are really just there for debugging. For//! example,//! use typenum::{Integer, N4};//! assert_eq!(N4::to_i32(), -4);//! **Type operators** are traits that behave as functions at the type level. These are the meat of//! this library. Where possible, traits defined in libcore have been used, but their attached//! functions have not been implemented.//! For example, the `Add` trait is implemented for both unsigned and signed integers, but the//! `add` function is not. As there are never any objects of the types defined here, it wouldn't//! make sense to implement it. What is important is its associated type `Output`, which is where//! the addition happens.//! use std::ops::Add;//! use typenum::{Integer, P3, P4};//! type X = <P3 as Add<P4>>::Output;//! assert_eq!(<X as Integer>::to_i32(), 7);//! In addition, helper aliases are defined for type operators. For example, the above snippet//! could be replaced with//! use typenum::{Integer, Sum, P3, P4};//! type X = Sum<P3, P4>;//! Documented in each module is the full list of type operators implemented.// For debugging macros:// #![feature(trace_macros)]// trace_macros!(true);/// A **marker trait** to designate that a type is not zero. All number types in this/// crate implement `NonZero` except `B0`, `U0`, and `Z0`./// A **marker trait** to designate that a type is zero. Only `B0`, `U0`, and `Z0`/// A **Marker trait** for the types `Greater`, `Equal`, and `Less`./// The **marker trait** for compile time bits.USIZE/// The **marker trait** for compile time unsigned integers./// use typenum::{Unsigned, U3};/// assert_eq!(U3::to_u32(), 3);/// assert_eq!(U3::I32, 3);/// The **marker trait** for compile time signed integers./// use typenum::{Integer, P3};/// assert_eq!(P3::to_i32(), 3);/// assert_eq!(P3::I32, 3);/// The **marker trait** for type-level arrays of type-level numbers./// Someday, it may contain an associated constant to produce a runtime array,/// like the other marker traits here. However, that is blocked by [this/// issue](https://github.com/rust-lang/rust/issues/44168)./// The **marker trait** for type-level numbers which are a power of two./// Here's a working example:/// use typenum::{PowerOfTwo, P4, P8};/// fn only_p2<P: PowerOfTwo>() {}/// only_p2::<P4>();/// only_p2::<P8>();/// Numbers which are not a power of two will fail to compile in this example:/// use typenum::{P9, P511, P1023, PowerOfTwo};/// fn only_p2<P: PowerOfTwo>() { }/// only_p2::<P9>();/// only_p2::<P511>();/// only_p2::<P1023>();//! All of the **marker traits** used in typenum.//! Note that the definition here for marker traits is slightly different than//! the conventional one -- we include traits with functions that convert a type//! to the corresponding value, as well as associated constants that do the//! same.//! For example, the `Integer` trait includes the function (among others) `fn//! to_i32() -> i32` and the associated constant `I32` so that one can do this://! use typenum::{Integer, N42};//! assert_eq!(-42, N42::to_i32());//! assert_eq!(-42, N42::I32);Logarithm2SquareRoot// Aliases!!!/// Alias for the associated type of `BitAnd`: `And<A, B> = <A as BitAnd<B>>::Output`/// Alias for the associated type of `BitOr`: `Or<A, B> = <A as BitOr<B>>::Output`/// Alias for the associated type of `BitXor`: `Xor<A, B> = <A as BitXor<B>>::Output`Shleft/// Alias for the associated type of `Shl`: `Shleft<A, B> = <A as Shl<B>>::Output`Shright/// Alias for the associated type of `Shr`: `Shright<A, B> = <A as Shr<B>>::Output`/// Alias for the associated type of `Add`: `Sum<A, B> = <A as Add<B>>::Output`/// Alias for the associated type of `Sub`: `Diff<A, B> = <A as Sub<B>>::Output`/// Alias for the associated type of `Mul`: `Prod<A, B> = <A as Mul<B>>::Output`/// Alias for the associated type of `Div`: `Quot<A, B> = <A as Div<B>>::Output`/// Alias for the associated type of `Rem`: `Mod<A, B> = <A as Rem<B>>::Output`/// Alias for the associated type of/// `PartialDiv`: `PartialQuot<A, B> = <A as PartialDiv<B>>::Output`/// Alias for the associated type of `Neg`: `Negate<A> = <A as Neg>::Output`AbsVal/// Alias for the associated type of `Abs`: `AbsVal<A> = <A as Abs>::Output`/// Alias for the associated type of `Pow`: `Exp<A, B> = <A as Pow<B>>::Output`/// Alias for the associated type of `Gcd`: `Gcf<A, B> = <A as Gcd<B>>::Output>`/// Alias to make it easy to add 1: `Add1<A> = <A as Add<B1>>::Output`/// Alias to make it easy to subtract 1: `Sub1<A> = <A as Sub<B1>>::Output`/// Alias to make it easy to multiply by 2. `Double<A> = Shleft<A, B1>`/// Alias to make it easy to square. `Square<A> = <A as Mul<A>>::Output`/// Alias to make it easy to cube. `Cube<A> = <Square<A> as Mul<A>>::Output`Sqrt/// Alias for the associated type of `SquareRoot`: `Sqrt<A> = <A as SquareRoot>::Output`/// Alias for the associated type of `Cmp`: `Compare<A, B> = <A as Cmp<B>>::Output`/// Alias for the associated type of `Len`: `Length<A> = <A as Len>::Output`/// Alias for the associated type of `Min`: `Minimum<A, B> = <A as Min<B>>::Output`/// Alias for the associated type of `Max`: `Maximum<A, B> = <A as Max<B>>::Output`IsEqualIsGreaterIsGreaterOrEqualIsNotEqual/// Alias for the associated type of `IsLess`: `Le<A, B> = <A as IsLess<B>>::Output`/// Alias for the associated type of `IsEqual`: `Eq<A, B> = <A as IsEqual<B>>::Output`Gr/// Alias for the associated type of `IsGreater`: `Gr<A, B> = <A as IsGreater<B>>::Output`GrEq/// Alias for the associated type of `IsGreaterOrEqual`:/// `GrEq<A, B> = <A as IsGreaterOrEqual<B>>::Output`/// Alias for the associated type of `IsLessOrEqual`: `LeEq<A, B> = <A as IsLessOrEqual<B>>::Output`/// Alias for the associated type of `IsNotEqual`: `NotEq<A, B> = <A as IsNotEqual<B>>::Output`Log2/// Alias for the associated type of `Logarithm2`: `Log2<A> = <A as Logarithm2>::Output`//! Aliases for the type operators used in this crate.//! Their purpose is to increase the ergonomics of performing operations on the types defined//! here. For even more ergonomics, consider using the `op!` macro instead.//! For example, type `X` and type `Y` are the same here://! # #[macro_use] extern crate typenum;//! use std::ops::Mul;//! use typenum::{Prod, P5, P7};//! type X = <P7 as Mul<P5>>::Output;//! type Y = Prod<P7, P5>;//! assert_type_eq!(X, Y);/// A marker for restricting a method on a public trait to internal use only./// Convenience trait. Calls `Invert` -> `TrimTrailingZeros` -> `Invert`TrimOuttrim_trailing_zerosTrimTrailingZeros/// Gets rid of all zeros until it hits a one.// ONLY IMPLEMENT FOR INVERTED NUMBERS!TrimTrailingZerosOut/// Converts between standard numbers and inverted ones that have the most significant/// digit on the outside.InvertOutprivate_invertPrivateInvert/// Doubly private! Called by invert to make the magic happen once its done the first step./// The Rhs is what we've got so far.PrivateInvertOutInvertedUTerm/// Terminating character for `InvertedUInt`sIUlsbInvertedUnsignedInvertedUInt/// Inverted `UInt` (has most significant digit on the outside)private_andPrivateAnd/// Does the real anding for `UInt`s; `And` just calls this and then `Trim`.PrivateAndOutprivate_xorPrivateXor/// Does the real xoring for `UInt`s; `Xor` just calls this and then `Trim`.PrivateXorOutprivate_subPrivateSub/// Does the real subtraction for `UInt`s; `Sub` just calls this and then `Trim`.PrivateSubOut/// Used for addition of signed integers; `C = P.cmp(N)`/// Assumes `P = Self` is positive and `N` is negative/// where `P` and `N` are both passed as unsigned integersPrivateIntegerAddOutprivate_powPrivatePowPrivatePowOutShiftDiff/// Performs `Shl` on `Lhs` so that `SizeOf(Lhs) = SizeOf(Rhs)`/// Fails if `SizeOf(Lhs) > SizeOf(Rhs)`ShiftDiffOutBitDiff/// Gives `SizeOf(Lhs) - SizeOf(Rhs)`BitDiffOut/// Inverted unsigned numberstest_inversiontest_double_inversionprivate_cmpSoFarPrivateCmpPrivateCmpOutprivate_set_bitPrivateSetBit// Set BitPrivateSetBitOutQuotientprivate_div_quotientprivate_div_remainderPrivateDivPrivateDivQuotPrivateDivRemprivate_div_if_quotientRcmpDprivate_div_if_remainderPrivateDivIfPrivateDivIfQuotPrivateDivIfRemDivisor// Div for signed intsPrivateDivIntOutURemPrivateRemOutprivate_minCmpResultPrivateMin// min maxPrivateMinOutprivate_maxPrivateMaxPrivateMaxOutis_less_privateIsLessPrivateis_equal_privateIsEqualPrivateis_greater_privateIsGreaterPrivateis_less_or_equal_privateIsLessOrEqualPrivateis_not_equal_privateIsNotEqualPrivateis_greater_or_equal_privateIsGreaterOrEqualPrivatePrivateSquareRootPrivateLogarithm2//! **Ignore me!** This module is for things that are conceptually private but that must//! be made public for typenum to work correctly.//! Unless you are working on typenum itself, **there is no need to view anything here**.//! Certainly don't implement any of the traits here for anything.//! Just look away.//! Loooooooooooooooooooooooooooooooooook awaaaaaaaaaaaayyyyyyyyyyyyyyyyyyyyyyyyyyyyy...//! If you do manage to find something of use in here, please let me know. If you can make a//! compelling case, it may be moved out of __private.//! Note: Aliases for private type operators will all be named simply that operator followed//! by an abbreviated name of its associated type.// Note: Trimming is tested when we do subtraction./// Should always be `Self`/// A **type operator** that ensures that `Rhs` is the same as `Self`, it is mainly useful/// for writing macros that can take arbitrary binary or unary operators./// `Same` is implemented generically for all types; it should never need to be implemented/// for anything else./// Note that Rust lazily evaluates types, so this will only fail for two different types if/// the `Output` is used./// use typenum::{Same, Unsigned, U4, U5};/// assert_eq!(<U5 as Same<U5>>::Output::to_u32(), 5);/// // Only an error if we use it:/// type Undefined = <U5 as Same<U4>>::Output;/// // Compiler error:/// // Undefined::to_u32();/// The absolute value./// A **type operator** that returns the absolute value./// use typenum::{Abs, Integer, N5};/// assert_eq!(<N5 as Abs>::Output::to_i32(), 5);/// The result of the exponentiation./// This function isn't used in this crate, but may be useful for others./// It is implemented for primitives./// use typenum::{Pow, U3};/// let a = 7u32.powi(U3::new());/// let b = 7u32.pow(3);/// let x = 3.0.powi(U3::new());/// let y = 27.0;/// assert_eq!(x, y);/// A **type operator** that provides exponentiation by repeated squaring./// use typenum::{Integer, Pow, N3, P3};/// assert_eq!(<N3 as Pow<P3>>::Output::to_i32(), -27);impl_pow_fimpl_pow_i/// The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`./// A **type operator** for comparing `Self` and `Rhs`. It provides a similar functionality to/// the function/// [`core::cmp::Ord::cmp`](https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp)/// but for types./// use typenum::{Cmp, Ord, N3, P2, P5};/// assert_eq!(<P2 as Cmp<N3>>::Output::to_ordering(), Ordering::Greater);/// assert_eq!(<P2 as Cmp<P2>>::Output::to_ordering(), Ordering::Equal);/// assert_eq!(<P2 as Cmp<P5>>::Output::to_ordering(), Ordering::Less);/// The length as a type-level unsigned integer./// A **type operator** that gives the length of an `Array` or the number of bits in a `UInt`./// The type of the result of the division/// Method for performing the division/// Division as a partial function. This **type operator** performs division just as `Div`, but is/// only defined when the result is an integer (i.e. there is no remainder)./// The type of the minimum of `Self` and `Rhs`/// Method returning the minimum/// A **type operator** that returns the minimum of `Self` and `Rhs`./// The type of the maximum of `Self` and `Rhs`/// Method returning the maximum/// A **type operator** that returns the maximum of `Self` and `Rhs`./// The type representing either `True` or `False`is_less/// Method returning `True` or `False`./// A **type operator** that returns `True` if `Self < Rhs`, otherwise returns `False`./// A **type operator** that returns `True` if `Self == Rhs`, otherwise returns `False`.is_greater/// A **type operator** that returns `True` if `Self > Rhs`, otherwise returns `False`.is_less_or_equal/// A **type operator** that returns `True` if `Self <= Rhs`, otherwise returns `False`.is_not_equal/// A **type operator** that returns `True` if `Self != Rhs`, otherwise returns `False`.is_greater_or_equal/// A **type operator** that returns `True` if `Self >= Rhs`, otherwise returns `False`./**
A convenience macro for comparing type numbers. Use `op!` instead.

Due to the intricacies of the macro system, if the left-hand operand is more complex than a simple
`ident`, you must place a comma between it and the comparison sign.

For example, you can do `cmp!(P5 > P3)` or `cmp!(typenum::P5, > typenum::P3)` but not
`cmp!(typenum::P5 > typenum::P3)`.

The result of this comparison will always be one of `True` (aka `B1`) or `False` (aka `B0`).

# Example
```rust
#[macro_use] extern crate typenum;
use typenum::consts::*;
use typenum::Bit;

fn main() {
type Result = cmp!(P9 == op!(P1 + P2 * (P2 - N2)));
assert_eq!(Result::to_bool(), true);
}
```
 *//// The result of the integer square root./// A **type operator** for taking the integer square root of `Self`./// The integer square root of `n` is the largest integer `m` such/// that `n >= m*m`. This definition is equivalent to truncating the/// real-valued square root: `floor(real_sqrt(n))`./// The result of the integer binary logarithm./// A **type operator** for taking the integer binary logarithm of `Self`./// The integer binary logarighm of `n` is the largest integer `m` such/// that `n >= 2^m`. This definition is equivalent to truncating the/// real-valued binary logarithm: `floor(log2(n))`./// The greatest common divisor./// A **type operator** that computes the [greatest common divisor][gcd] of `Self` and `Rhs`./// [gcd]: https://en.wikipedia.org/wiki/Greatest_common_divisor/// use typenum::{Gcd, Unsigned, U12, U8};/// assert_eq!(<U12 as Gcd<U8>>::Output::to_i32(), 4);/// Method returning the concrete value for the type./// The concrete value for the type. Can be used in `const` contexts./// A **type operator** for taking a concrete integer value from a type./// It returns arbitrary integer value without explicitly specifying the/// type. It is useful when you pass the values to methods that accept/// distinct types without runtime casting.//! Useful **type operators** that are not defined in `core::ops`./// The terminating type for `UInt`; it always comes after the most significant/// bit. `UTerm` by itself represents zero, which is aliased to `U0`./// Instantiates a singleton representing this unsigned integer./// The more significant bits of `Self`./// The least significant bit of `Self`./// `UInt` is defined recursively, where `B` is the least significant bit and `U` is the rest/// of the number. Conceptually, `U` should be bound by the trait `Unsigned` and `B` should/// be bound by the trait `Bit`, but enforcing these bounds causes linear instead of/// logrithmic scaling in some places, so they are left off for now. They may be enforced in/// In order to keep numbers unique, leading zeros are not allowed, so `UInt<UTerm, B0>` is/// forbidden./// use typenum::{UInt, UTerm, B0, B1};/// type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;/// Length of `UTerm` by itself is 0/// Length of a bit is 1/// `UTerm + B0 = UTerm`/// `U + B0 = U`/// `UTerm + B1 = UInt<UTerm, B1>`/// `UInt<U, B0> + B1 = UInt<U + B1>`/// `UInt<U, B1> + B1 = UInt<U + B1, B0>`/// `UTerm + U = U`/// `UInt<U, B> + UTerm = UInt<U, B>`/// `UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>`/// `UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>`/// `UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>`/// `UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>`/// `UTerm - B0 = Term`/// `UInt - B0 = UInt`/// `UInt<U, B1> - B1 = UInt<U, B0>`/// `UInt<UTerm, B1> - B1 = UTerm`/// `UInt<U, B0> - B1 = UInt<U - B1, B1>`/// `UTerm - UTerm = UTerm`Bl/// Subtracting unsigned integers. We just do our `PrivateSub` and then `Trim` the output./// `U - UTerm = U`/// `UInt<Ul, B0> - UInt<Ur, B0> = UInt<Ul - Ur, B0>`/// `UInt<Ul, B0> - UInt<Ur, B1> = UInt<(Ul - Ur) - B1, B1>`/// `UInt<Ul, B1> - UInt<Ur, B0> = UInt<Ul - Ur, B1>`/// `UInt<Ul, B1> - UInt<Ur, B1> = UInt<Ul - Ur, B0>`/// 0 & X = 0/// Anding unsigned integers./// We use our `PrivateAnd` operator and then `Trim` the output./// `UTerm & X = UTerm`/// `X & UTerm = UTerm`/// `UInt<Ul, B0> & UInt<Ur, B0> = UInt<Ul & Ur, B0>`/// `UInt<Ul, B0> & UInt<Ur, B1> = UInt<Ul & Ur, B0>`/// `UInt<Ul, B1> & UInt<Ur, B0> = UInt<Ul & Ur, B0>`/// `UInt<Ul, B1> & UInt<Ur, B1> = UInt<Ul & Ur, B1>`/// `UTerm | X = X`///  `X | UTerm = X`/// `UInt<Ul, B0> | UInt<Ur, B0> = UInt<Ul | Ur, B0>`/// `UInt<Ul, B0> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`/// `UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>`/// `UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`/// 0 ^ X = X/// Xoring unsigned integers./// We use our `PrivateXor` operator and then `Trim` the output./// `UTerm ^ X = X`/// `X ^ UTerm = X`/// `UInt<Ul, B0> ^ UInt<Ur, B0> = UInt<Ul ^ Ur, B0>`/// `UInt<Ul, B0> ^ UInt<Ur, B1> = UInt<Ul ^ Ur, B1>`/// `UInt<Ul, B1> ^ UInt<Ur, B0> = UInt<Ul ^ Ur, B1>`/// `UInt<Ul, B1> ^ UInt<Ur, B1> = UInt<Ul ^ Ur, B0>`/// Shifting `UTerm` by a 0 bit: `UTerm << B0 = UTerm`/// Shifting `UTerm` by a 1 bit: `UTerm << B1 = UTerm`/// Shifting left any unsigned by a zero bit: `U << B0 = U`/// Shifting left a `UInt` by a one bit: `UInt<U, B> << B1 = UInt<UInt<U, B>, B0>`/// Shifting left `UInt` by `UTerm`: `UInt<U, B> << UTerm = UInt<U, B>`/// Shifting left `UTerm` by an unsigned integer: `UTerm << U = UTerm`Br/// Shifting left `UInt` by `UInt`: `X << Y` = `UInt(X, B0) << (Y - 1)`/// Shifting right a `UTerm` by an unsigned integer: `UTerm >> U = UTerm`/// Shifting right `UInt` by `UTerm`: `UInt<U, B> >> UTerm = UInt<U, B>`/// Shifting right `UTerm` by a 0 bit: `UTerm >> B0 = UTerm`/// Shifting right `UTerm` by a 1 bit: `UTerm >> B1 = UTerm`/// Shifting right any unsigned by a zero bit: `U >> B0 = U`/// Shifting right a `UInt` by a 1 bit: `UInt<U, B> >> B1 = U`/// Shifting right `UInt` by `UInt`: `UInt(U, B) >> Y` = `U >> (Y - 1)`/// `UInt * B0 = UTerm`/// `UTerm * B0 = UTerm`/// `UTerm * B1 = UTerm`/// `UInt * B1 = UInt`/// `UInt<U, B> * UTerm = UTerm`/// `UTerm * U = UTerm`/// `UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>`/// `UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>`/// Zero == Zero/// Nonzero > Zero/// Zero < Nonzero/// `UInt<Ul, B0>` cmp with `UInt<Ur, B0>`: `SoFar` is `Equal`/// `UInt<Ul, B1>` cmp with `UInt<Ur, B1>`: `SoFar` is `Equal`/// `UInt<Ul, B0>` cmp with `UInt<Ur, B1>`: `SoFar` is `Less`/// `UInt<Ul, B1>` cmp with `UInt<Ur, B0>`: `SoFar` is `Greater`/// Comparing non-terimal bits, with both having bit `B0`./// These are `Equal`, so we propagate `SoFar`./// Comparing non-terimal bits, with both having bit `B1`./// Comparing non-terimal bits, with `Lhs` having bit `B0` and `Rhs` having bit `B1`./// `SoFar`, Lhs is `Less`./// Comparing non-terimal bits, with `Lhs` having bit `B1` and `Rhs` having bit `B0`./// `SoFar`, Lhs is `Greater`./// Got to the end of just the `Lhs`. It's `Less`./// Got to the end of just the `Rhs`. `Lhs` is `Greater`./// Got to the end of both! Return `SoFar`// Shifting one number until it's the size of another/// X^N/// N is even/// N is odd/// The even number 2*N// Silence spurious warning on older versions of rust/// The odd number 2*N + 1/// gcd(0, 0) = 0/// gcd(x, 0) = x/// gcd(0, y) = yXpYp/// gcd(x, y) = 2*gcd(x/2, y/2) if both x and y even/// gcd(x, y) = gcd(x, y/2) if x odd and y even/// gcd(x, y) = gcd(x/2, y) if x even and y odd/// gcd(x, y) = gcd([max(x, y) - min(x, y)], min(x, y)) if both x and y odd/// This will immediately invoke the case for x even and y odd because the difference of two odd/// numbers is an even number.gcd_testgcd_testsGetBitGetBitOutUnUi// Recursion case// Ran out of bitstest_get_bitSetBit/// A **type operator** that, when implemented for unsigned integer `N`, sets the bit at position/// `I` to `B`.SetBitOut/// Alias for the result of calling `SetBit`: `SetBitOut<N, I, B> = <N as SetBit<I, B>>::Output`.// Call private one then trim it// Ran out of bits, setting B0// Ran out of bits, setting B1test_set_bit// 0 // N// M // N// 0 % N// M % N// PrivateDiv// R == 0: We set R = UInt<UTerm, N[i]>, then call out to PrivateDivIf for the if statement// R > 0: We perform R <<= 1 and R[0] = N[i], then call out to PrivateDivIf for the if statement// R < D, I > 0, we do nothing and recurse// R == D, I > 0, we set R = 0, Q[I] = 1 and recurse// R > D, I > 0, we set R -= D, Q[I] = 1 and recurse// R < D, I == 0: we do nothing, and return// R == D, I == 0: we set R = 0, Q[I] = 1, and return// R > D, I == 0: We set R -= D, Q[I] = 1, and return// M / N// PrivateMin// PrivateMax// sqrt(0) = 0.// sqrt(1) = 1.BaBb// General case of sqrt(Self) where Self >= 2. If a and b are// bit-valued and Self = 4*u + 2*a + b, then the integer-valued// (fractional part truncated) square root of Self is either 2*sqrt(u)// or 2*sqrt(u)+1. Guess and check by comparing (2*sqrt(u)+1)^2// against Self. Since the `typenum` result of that comparison is a// bit, directly add that bit to 2*sqrt(u).// Use `Sum<Double<Sqrt<U>>, GrEq<...>>` instead of `UInt<Sqrt<U>,// GrEq<...>>` because `Sqrt<U>` can turn out to be `UTerm` and// `GrEq<...>` can turn out to be `B0`, which would not be a valid// UInt as leading zeros are disallowed.sqrt_test// log2(1) = 0.// General case of log2(Self) where Self >= 2.log2_testuint_toint_test//! Type-level unsigned integers.//! From `::core::ops`: `BitAnd`, `BitOr`, `BitXor`, `Shl`, `Shr`, `Add`, `Sub`,//!                 `Mul`, `Div`, and `Rem`.//! use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};//! use typenum::{Unsigned, U1, U2, U3, U4};//! assert_eq!(<U3 as BitAnd<U2>>::Output::to_u32(), 2);//! assert_eq!(<U3 as BitOr<U4>>::Output::to_u32(), 7);//! assert_eq!(<U3 as BitXor<U2>>::Output::to_u32(), 1);//! assert_eq!(<U3 as Shl<U1>>::Output::to_u32(), 6);//! assert_eq!(<U3 as Shr<U1>>::Output::to_u32(), 1);//! assert_eq!(<U3 as Add<U2>>::Output::to_u32(), 5);//! assert_eq!(<U3 as Sub<U2>>::Output::to_u32(), 1);//! assert_eq!(<U3 as Mul<U2>>::Output::to_u32(), 6);//! assert_eq!(<U3 as Div<U2>>::Output::to_u32(), 1);//! assert_eq!(<U3 as Rem<U2>>::Output::to_u32(), 1);// Getting length of unsigned integers, which is defined as the number of bits before `UTerm`// Adding bits to unsigned integers// Adding unsigned integers// Subtracting bits from unsigned integers// Subtracting unsigned integers// And unsigned integers// Or unsigned integers// Xor unsigned integers// Shl unsigned integers// Shr unsigned integers// Multiply unsigned integers// Compare unsigned integers// Getting difference in number of bits// Powers of unsigned integers//------------------------------------------// Greatest Common Divisor// GetBit// SetBit// Division algorithm:// We have N / D:// let Q = 0, R = 0// NBits = len(N)// for I in NBits-1..0://   R <<=1//   R[0] = N[i]//   let C = R.cmp(D)//   if C == Equal or Greater://     R -= D//     Q[i] = 1// PrivateDivIf// SquareRoot// Logarithm2SECONDS_PER_NORMAL_YEAR/// Number of seconds in a normal yearSECONDS_PER_LEAP_YEAR/// Number of seconds in a leap yearDAYS_IN_MONTHS_NORMAL_YEARCUMUL_DAYS_IN_MONTHS_NORMAL_YEARCUMUL_DAYS_IN_MONTHS_LEAP_YEAR/// Cumulated month days in a leap year//! Some useful constants.FoundDateTimeKind/// Found date time is validbefore_transition/// Date time just before the forward transitionafter_transition/// Date time just after the forward transitionSkipped/// Found date time is invalid because it was skipped by a forward transition./// This variant gives the two [`DateTime`] corresponding to the transition instant, just before and just after the transition./// This is different from the `mktime` behavior, which allows invalid date times when no DST information is available (by specifying `tm_isdst = -1`)./// Type of a found date time created by the [`DateTime::find`] methodFoundDateTimeList/// List containing the found date times created by the [`DateTime::find`] method./// It can be empty if no local time type was found for the provided date, time and time zone./// Returns the found date time if existing and unique/// Returns the earliest found date time if existing/// Returns the latest found date time if existing/// Extracts and returns the inner list of found date times/// Preallocated buffer/// Current index/// Total count of found date timesFoundDateTimeListRefMut/// Wrapper reference type with methods for extracting the found date times, created by the [`DateTime::find_n`] method/// Construct a new [`FoundDateTimeListRefMut`] value/// Returns the subslice of written data/// Returns the count of found date timesis_exhaustive/// Returns `true` if all found date times have been written in the buffer/// Appends a found date time to the listDateTimeList/// Trait representing a list of found date timesfind_date_time/// Find the possible date times corresponding to a date, a time and a time zone/// * `found_date_time_list`: Buffer containing found date times/// * `hour`: Hours since midnight in `[0, 23]`/// * `minute`: Minutes in `[0, 59]`/// * `second`: Seconds in `[0, 60]`, with a possible leap second/// * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`/// * `time_zone_ref`: Reference to a time zonecheck_equal_date_timecheck_equal_option_date_timetest_find_date_time_fixedtest_find_date_time_no_offsettest_find_date_time_extra_rule_onlytest_find_date_time_transitions_onlytest_find_date_time_transitions_with_extra_ruletest_find_date_time_ref_mut//! Types related to the [`DateTime::find`] method./// Nanoseconds in `[0, 999_999_999]`MIN_UNIX_TIME/// Minimum allowed Unix time in secondsMAX_UNIX_TIME/// Maximum allowed Unix time in seconds" Check if the UTC date time associated to a Unix time in seconds is valid"check_unix_timeDateTimeError" Construct a UTC date time"" ## Inputs"" * `year`: Year"" * `month`: Month in `[1, 12]`"" * `month_day`: Day of the month in `[1, 31]`"" * `hour`: Hours since midnight in `[0, 23]`"" * `minute`: Minutes in `[0, 59]`"" * `second`: Seconds in `[0, 60]`, with a possible leap second"" * `nanoseconds`: Nanoseconds in `[0, 999_999_999]`"" Construct a UTC date time from a Unix time in seconds and nanoseconds"" Construct a UTC date time from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)"from_total_nanosecondsTzError/// Returns the current UTC date time" Returns the Unix time in seconds associated to the UTC date time"" Project the UTC date time into a time zone."" Leap seconds are not preserved."ProjectDateTimeErrorlocal_time_type/// Local time type/// UTC Unix time in seconds/// Date time associated to a local time type, exprimed in the [proleptic gregorian calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar)" Construct a date time"" * `local_time_type`: Local time type associated to a time zone"find_n/// Find the possible date times corresponding to a date, a time and a time zone./// This method doesn't allocate, and instead takes a preallocated buffer as an input./// It returns a [`FoundDateTimeListRefMut`] wrapper which has additional methods./// * `buf`: Preallocated buffer/// # fn main() -> Result<(), tz::TzError> {/// use tz::datetime::{DateTime, FoundDateTimeKind};/// use tz::timezone::{LocalTimeType, TimeZoneRef, Transition};/// let transitions = &[Transition::new(3600, 1), Transition::new(86400, 0), Transition::new(i64::MAX, 0)];/// let local_time_types = &[LocalTimeType::new(0, false, Some(b"STD"))?, LocalTimeType::new(3600, true, Some(b"DST"))?];/// let time_zone_ref = TimeZoneRef::new(transitions, local_time_types, &[], &None)?;/// // Buffer is too small, so the results are non exhaustive/// let mut small_buf = [None; 1];/// assert!(!DateTime::find_n(&mut small_buf, 1970, 1, 2, 0, 30, 0, 0, time_zone_ref)?.is_exhaustive());/// // Fill buffer/// let mut buf = [None; 2];/// let found_date_time_list = DateTime::find_n(&mut buf, 1970, 1, 2, 0, 30, 0, 0, time_zone_ref)?;/// let data = found_date_time_list.data();/// assert!(found_date_time_list.is_exhaustive());/// assert_eq!(found_date_time_list.count(), 2);/// assert!(matches!(data, [Some(FoundDateTimeKind::Normal(..)), Some(FoundDateTimeKind::Normal(..))]));/// // We can reuse the buffer/// let found_date_time_list = DateTime::find_n(&mut buf, 1970, 1, 1, 1, 30, 0, 0, time_zone_ref)?;/// assert_eq!(found_date_time_list.count(), 1);/// assert!(found_date_time_list.unique().is_none()); // FoundDateTimeKind::Skipped/// assert!(matches!(data, &[Some(FoundDateTimeKind::Skipped { .. })]));" Construct a date time from a Unix time in seconds with nanoseconds and a local time type"from_timespec_and_local" Construct a date time from a Unix time in seconds with nanoseconds and a time zone"" Construct a date time from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`) and a local time type"from_total_nanoseconds_and_local" Construct a date time from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`) and a time zone"/// Returns the current date time associated to the specified time zone" Project the date time into another time zone."impl_datetime/// Macro for implementing date time gettersr" Returns year"r" Returns month in `[1, 12]`"r" Returns day of the month in `[1, 31]`"r" Returns hours since midnight in `[0, 23]`"r" Returns minutes in `[0, 59]`"r" Returns seconds in `[0, 60]`, with a possible leap second"r" Returns nanoseconds in `[0, 999_999_999]`"r" Returns days since Sunday in `[0, 6]`"r" Returns days since January 1 in `[0, 365]`"year_dayr" Returns total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)"total_nanoseconds" Returns local time type"" Returns UTC Unix time in seconds"" Compute the number of days since Sunday in `[0, 6]`"" Compute the number of days since January 1 in `[0, 365]`"" Check if a year is a leap year"" Compute the number of days since Unix epoch (`1970-01-01T00:00:00Z`)."" The December 32nd date is possible, which corresponds to January 1st of the next year."" * `month_day`: Day of the month in `[1, 32]`"" Compute Unix time in seconds"" Compute the number of nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)"nanoseconds_since_unix_epoch" Compute Unix time in seconds with nanoseconds from total nanoseconds since Unix epoch (`1970-01-01T00:00:00Z`)"" ## Outputs"" * `unix_time`: Unix time in seconds"total_nanoseconds_to_timespec" Check date time inputs"check_date_time_inputsformat_date_time/// Format a date time/// * `f`: Formatter/// * `ut_offset`: Offset from UTC in secondstest_date_timetest_date_time_leap_secondstest_date_time_partial_eq_partial_ordtest_date_time_sync_and_sendtest_utc_date_time_ordtest_date_time_formattest_date_time_overflowtest_week_daytest_year_daytest_is_leap_yeartest_days_since_unix_epochtest_nanoseconds_since_unix_epochtest_total_nanoseconds_to_timespec//! Types related to a date time.TzStringError/// Unified error type for parsing a TZ stringTzFileError/// Conversion from slice to array error/// Unified error for parsing a TZ string/// Invalid TZif file/// Unsupported TZif file/// Unified error type for parsing a TZif file"Out of range error"r" Error description""Local time type error"LocalTimeTypeError"Transition rule error"TransitionRuleError"Time zone error"TimeZoneError"Date time error""Local time type search error"FindLocalTimeTypeError"Date time projection error"/// Unified error for parsing a TZif file/// Alias for [`std::result::Result`] with the crate unified error//! This crate provides the [`TimeZone`] and [`DateTime`] types, which can be used to determine local time on a given time zone.//! This allows to convert between an [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time) and a calendar time exprimed in the [proleptic gregorian calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) with a provided time zone.//! Time zones are provided to the library with a [POSIX `TZ` string](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html) which can be read from the environment.//! Two formats are currently accepted for the `TZ` string://! * `std offset[dst[offset][,start[/time],end[/time]]]` providing a time zone description,//! * `file` or `:file` providing the path to a [TZif file](https://datatracker.ietf.org/doc/html/rfc8536), which is absolute or relative to the system timezone directory.//! See also the [Linux manual page of tzset(3)](https://man7.org/linux/man-pages/man3/tzset.3.html) and the [glibc documentation of the `TZ` environment variable](https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html).//! ## Time zone//! # fn main() -> Result<(), tz::TzError> {//! use tz::TimeZone;//! // 2000-01-01T00:00:00Z//! let unix_time = 946684800;//! // Get UTC time zone//! let time_zone_utc = TimeZone::utc();//! assert_eq!(time_zone_utc.find_local_time_type(unix_time)?.ut_offset(), 0);//! // Get fixed time zone at GMT-1//! let time_zone_fixed = TimeZone::fixed(-3600)?;//! assert_eq!(time_zone_fixed.find_local_time_type(unix_time)?.ut_offset(), -3600);//! // Get local time zone (UNIX only)//! let time_zone_local = TimeZone::local()?;//! // Get the current local time type//! let _current_local_time_type = time_zone_local.find_current_local_time_type()?;//! // Get time zone from a TZ string://! // From an absolute file//! let _ = TimeZone::from_posix_tz("/usr/share/zoneinfo/Pacific/Auckland");//! // From a file relative to the system timezone directory//! let _ = TimeZone::from_posix_tz("Pacific/Auckland");//! // From a time zone description//! TimeZone::from_posix_tz("HST10")?;//! TimeZone::from_posix_tz("<-03>3")?;//! TimeZone::from_posix_tz("NZST-12:00:00NZDT-13:00:00,M10.1.0,M3.3.0")?;//! // Use a leading colon to force searching for a corresponding file//! let _ = TimeZone::from_posix_tz(":UTC");//! ## Date time//! use tz::{DateTime, LocalTimeType, TimeZone, UtcDateTime};//! // Get the current UTC date time//! let _current_utc_date_time = UtcDateTime::now()?;//! // Create a new UTC date time (2000-01-01T00:00:00.123456789Z)//! let utc_date_time = UtcDateTime::new(2000, 1, 1, 0, 0, 0, 123_456_789)?;//! assert_eq!(utc_date_time.year(), 2000);//! assert_eq!(utc_date_time.month(), 1);//! assert_eq!(utc_date_time.month_day(), 1);//! assert_eq!(utc_date_time.hour(), 0);//! assert_eq!(utc_date_time.minute(), 0);//! assert_eq!(utc_date_time.second(), 0);//! assert_eq!(utc_date_time.week_day(), 6);//! assert_eq!(utc_date_time.year_day(), 0);//! assert_eq!(utc_date_time.unix_time(), 946684800);//! assert_eq!(utc_date_time.nanoseconds(), 123_456_789);//! assert_eq!(utc_date_time.to_string(), "2000-01-01T00:00:00.123456789Z");//! // Create a new UTC date time from a Unix time with nanoseconds (2000-01-01T00:00:00.123456789Z)//! let other_utc_date_time = UtcDateTime::from_timespec(946684800, 123_456_789)?;//! assert_eq!(other_utc_date_time, utc_date_time);//! // Project the UTC date time to a time zone//! let date_time = utc_date_time.project(TimeZone::fixed(-3600)?.as_ref())?;//! assert_eq!(date_time.year(), 1999);//! assert_eq!(date_time.month(), 12);//! assert_eq!(date_time.month_day(), 31);//! assert_eq!(date_time.hour(), 23);//! assert_eq!(date_time.minute(), 0);//! assert_eq!(date_time.second(), 0);//! assert_eq!(date_time.week_day(), 5);//! assert_eq!(date_time.year_day(), 364);//! assert_eq!(date_time.local_time_type().ut_offset(), -3600);//! assert_eq!(date_time.unix_time(), 946684800);//! assert_eq!(date_time.nanoseconds(), 123_456_789);//! assert_eq!(date_time.to_string(), "1999-12-31T23:00:00.123456789-01:00");//! // Project the date time to another time zone//! let other_date_time = date_time.project(TimeZone::fixed(3600)?.as_ref())?;//! assert_eq!(other_date_time.year(), 2000);//! assert_eq!(other_date_time.month(), 1);//! assert_eq!(other_date_time.month_day(), 1);//! assert_eq!(other_date_time.hour(), 1);//! assert_eq!(other_date_time.minute(), 0);//! assert_eq!(other_date_time.second(), 0);//! assert_eq!(other_date_time.week_day(), 6);//! assert_eq!(other_date_time.year_day(), 0);//! assert_eq!(other_date_time.local_time_type().ut_offset(), 3600);//! assert_eq!(other_date_time.unix_time(), 946684800);//! assert_eq!(other_date_time.nanoseconds(), 123_456_789);//! assert_eq!(other_date_time.to_string(), "2000-01-01T01:00:00.123456789+01:00");//! // Create a new date time from a Unix time with nanoseconds and a time zone (2000-01-01T00:00:00.123456789Z)//! let another_date_time = DateTime::from_timespec(946684800, 123_456_789, TimeZone::fixed(86400)?.as_ref())?;//! // DateTime objects are compared by their Unix time and nanoseconds//! assert_eq!(another_date_time, other_date_time);//! // Get the current date time at the local time zone (UNIX only)//! let _date_time = DateTime::now(time_zone_local.as_ref())?;//! // Create a new date time with an UTC offset (2000-01-01T01:00:00.123456789+01:00)//! let date_time = DateTime::new(2000, 1, 1, 1, 0, 0, 123_456_789, LocalTimeType::with_ut_offset(3600)?)?;//! assert_eq!(date_time.year(), 2000);//! assert_eq!(date_time.month(), 1);//! assert_eq!(date_time.month_day(), 1);//! assert_eq!(date_time.hour(), 1);//! assert_eq!(date_time.week_day(), 6);//! assert_eq!(date_time.year_day(), 0);//! assert_eq!(date_time.to_string(), "2000-01-01T01:00:00.123456789+01:00");//! // Find the possible date times corresponding to a date, a time and a time zone//! let time_zone = TimeZone::from_posix_tz("CET-1CEST,M3.5.0,M10.5.0/3")?;//! // Found date time is unique//! let found_date_times = DateTime::find(2000, 1, 1, 0, 0, 0, 0, time_zone.as_ref())?;//! let unique = found_date_times.unique().unwrap();//! assert_eq!(unique, found_date_times.earliest().unwrap());//! assert_eq!(unique, found_date_times.latest().unwrap());//! assert_eq!(unique.local_time_type().ut_offset(), 3600);//! assert_eq!(unique.local_time_type().time_zone_designation(), "CET");//! // Found date time was skipped by a forward transition//! let found_date_times = DateTime::find(2000, 3, 26, 2, 30, 0, 0, time_zone.as_ref())?;//! assert_eq!(found_date_times.unique(), None);//! let earliest = found_date_times.earliest().unwrap();//! assert_eq!(earliest.hour(), 2);//! assert_eq!(earliest.minute(), 0);//! assert_eq!(earliest.local_time_type().ut_offset(), 3600);//! assert_eq!(earliest.local_time_type().time_zone_designation(), "CET");//! let latest = found_date_times.latest().unwrap();//! assert_eq!(latest.hour(), 3);//! assert_eq!(latest.minute(), 0);//! assert_eq!(latest.local_time_type().ut_offset(), 7200);//! assert_eq!(latest.local_time_type().time_zone_designation(), "CEST");//! // Found date time is ambiguous because of a backward transition//! let found_date_times = DateTime::find(2000, 10, 29, 2, 30, 0, 0, time_zone.as_ref())?;//! assert_eq!(earliest.minute(), 30);//! assert_eq!(earliest.local_time_type().ut_offset(), 7200);//! assert_eq!(earliest.local_time_type().time_zone_designation(), "CEST");//! assert_eq!(latest.hour(), 2);//! assert_eq!(latest.minute(), 30);//! assert_eq!(latest.local_time_type().ut_offset(), 3600);//! assert_eq!(latest.local_time_type().time_zone_designation(), "CET");tz_filetz_string//! Parsing functions.parse_posix_tz/// Number of time zone designations bytes/// Parse TZif headerparse_footer/// Parse TZif footertime_zone_designations/// Time zone designations data blockDataBlock/// Parse time zone dataparse_tz_file/// Parse TZif file as described in [RFC 8536](https://datatracker.ietf.org/doc/html/rfc8536)get_tz_file//! Functions used for parsing a TZif file./// Parse integer from a slice of bytesparse_time_zone_designation/// Parse time zone designationparse_rule_day/// Parse transition rule dayparse_rule_blocktest_min_dst_offsettest_max_dst_offset//! Functions used for parsing a TZ string." Construct a TZif file transition"" Returns Unix leap time"" Returns local time type index"" Construct a TZif file leap second"" Returns leap second correction"TzAsciiStr/// ASCII-encoded fixed-capacity string, used for storing time zone designations" Construct a time zone designation string"" Returns time zone designation as a byte slice"" Returns time zone designation as a string"" Check if two time zone designations are equal"time_zone_designation/// Time zone designation" Construct a local time type"/// Construct the local time type associated to UTC" Construct a local time type with the specified UTC offset in seconds"with_ut_offset" Returns offset from UTC in seconds"" Returns daylight saving time indicator"" Returns time zone designation"" Check if two local time types are equal"" Construct a time zone reference"" Construct the time zone reference associated to UTC"" Returns list of transitions"" Returns list of local time types"" Returns list of leap seconds"" Returns extra transition rule applicable after the last transition"" Find the local time type associated to the time zone at the specified Unix time in seconds"" Construct a reference to a time zone"" Check time zone inputs"check_inputs" Convert Unix time to Unix leap time, from the list of leap seconds in a time zone"" Convert Unix leap time to Unix time, from the list of leap seconds in a time zone"find_current_local_time_type/// Find the current local time type associated to the time zonestart_normal_year_offset/// Offset in seconds from the start of a normal yearend_normal_year_offset/// Offset in seconds from the end of a normal yearstart_leap_year_offset/// Offset in seconds from the start of a leap yearend_leap_year_offset/// Offset in seconds from the end of a leap yearJulianDayCheckInfos/// Informations needed for checking DST transition rules consistency, for a Julian daystart_normal_year_offset_range/// Possible offset range in seconds from the start of a normal yearend_normal_year_offset_range/// Possible offset range in seconds from the end of a normal yearstart_leap_year_offset_range/// Possible offset range in seconds from the start of a leap yearend_leap_year_offset_range/// Possible offset range in seconds from the end of a leap yearMonthWeekDayCheckInfos/// Informations needed for checking DST transition rules consistency, for a day represented by a month, a month week and a week day/// Julian day in `[1, 365]`, without taking occasional February 29th into account, which is not referenceable" Construct a transition rule day represented by a Julian day in `[1, 365]`, without taking occasional February 29th into account, which is not referenceable"" Returns inner value"" Compute transition date"" Compute the informations needed for checking DST transition rules consistency"compute_check_infos/// Zero-based Julian day in `[0, 365]`, taking occasional February 29th into account and allowing December 32nd" Construct a transition rule day represented by a zero-based Julian day in `[0, 365]`, taking occasional February 29th into account and allowing December 32nd"" Compute transition date."" On a non-leap year, a value of `365` corresponds to December 32nd (which is January 1st of the next year)."MonthWeekDay" Construct a transition rule day represented by a month, a month week and a week day"" Returns month in `[1, 12]`"" Returns week of the month in `[1, 5]`, with `5` representing the last week of the month"" Returns day of the week in `[0, 6]` from Sunday"" Compute transition date on a specific year"" Compute transition date for the provided year."" Returns the UTC Unix time in seconds associated to the transition date for the provided year"" Construct a transition rule representing alternate local time types"" Returns local time type for standard time"" Returns local time type for Daylight Saving Time"" Returns start day of Daylight Saving Time"" Returns local start day time of Daylight Saving Time, in seconds"" Returns end day of Daylight Saving Time"" Returns local end day time of Daylight Saving Time, in seconds"" Find the local time type associated to the alternate transition rule at the specified Unix time in seconds"" Find the local time type associated to the transition rule at the specified Unix time in seconds"" Check DST transition rules consistency, which ensures that the DST start and end time are always in the same order."" This prevents from having an additional transition at the year boundary, when the order of DST start and end time is different on consecutive years."check_dst_transition_rules_consistency" Check DST transition rules consistency for two Julian days"check_two_julian_days" Check DST transition rules consistency for a Julian day and a day represented by a month, a month week and a week day"check_month_week_day_and_julian_day" Check DST transition rules consistency for two days represented by a month, a month week and a week day"check_two_month_week_daystest_compute_check_infostest_check_dst_transition_rules_consistency//! Types related to a time zone extra transition rule." Compare two values"" Returns the minimum of two values"impl_try_into_integer/// Macro for implementing integer conversion" Convert a `i64` value to a `i32` value"try_into_i32" Convert a `i128` value to a `i64` value"try_into_i64impl_binary_search/// Macro for implementing binary search" Copy the input value"" Binary searches a sorted `i64` slice for the given element"binary_search_i64" Binary searches a sorted `Transition` slice for the given element"binary_search_transitions" Binary searches a sorted `LeapSecond` slice for the given element"binary_search_leap_secondsconst_panic/// Macro for panicking in a const context//! Some useful constant functions.const_fns//! Some useful utilities.//! Some useful types.raw_tz_by_nametz_by_nameTZ_NAMESVERSION_HASHlocal_tz/// Find the time zone of the current system/// This function uses [`iana_time_zone::get_timezone()`] in the background./// You may want to cache the output to avoid repeated filesystem accesses by `get_timezone()`./// // Query the time zone of the local system:/// let time_zone = tzdb::local_tz().unwrap();/// Most likely you will want to fallback to a default time zone,/// if the system time zone could not be determined or was not found in the database:/// let time_zone = tzdb::local_tz().unwrap_or(tzdb::time_zone::GMT);// Copyright 2022 René Kijewski <crates.io@k6i.de>// http://www.apache.org/licenses/LICENSE-2.0//! # tzdb — Time Zone Database//! [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/Kijewski/tzdb/ci.yml?branch=v0.5.x)](https://github.com/Kijewski/tzdb/actions/workflows/ci.yml)//! [![Crates.io](https://img.shields.io/crates/v/tzdb?logo=rust)](https://crates.io/crates/tzdb)//! ![Minimum supported Rust version](https://img.shields.io/badge/rustc-1.56+-important?logo=rust "Minimum Supported Rust Version: 1.56")//! [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-informational?logo=apache)](/LICENSE.md "License: Apache-2.0")//! Static time zone information for [tz-rs](https://crates.io/crates/tz-rs).//! This crate provides all time zones found in the [Time Zone Database](https://www.iana.org/time-zones),//! currently in the version 2023d (released 2023-12-22).//! See the documentation for a full list the the contained time zones://! <https://docs.rs/tzdb/latest/tzdb/time_zone/index.html>//! ## Usage examples//! // get the system time zone//! let time_zone = tzdb::local_tz().unwrap();       // tz::TimeZoneRef<'_>//! let current_time = tzdb::now::local().unwrap();  // tz::DateTime//! // access by identifier//! let time_zone = tzdb::time_zone::europe::KYIV;//! let current_time = tzdb::now::in_tz(tzdb::time_zone::europe::KYIV).unwrap();//! // access by name//! let time_zone = tzdb::tz_by_name("Europe/Berlin").unwrap();//! let current_time = tzdb::now::in_named("Europe/Berlin").unwrap();//! // names are case insensitive//! let time_zone = tzdb::tz_by_name("ArCtIc/LongYeArByEn").unwrap();//! let current_time = tzdb::now::in_named("ArCtIc/LongYeArByEn").unwrap();//! // provide a default time zone//! let current_time = tzdb::now::local_or(tzdb::time_zone::GMT).unwrap();//! let current_time = tzdb::now::in_named_or(tzdb::time_zone::GMT, "Some/City").unwrap();//! * `fallback` <sup>*(enabled by default)*</sup> — compile for unknown target platforms, tooNowError/// Could not get time zone. Only returned by [`local()`].UnknownTimezone/// Unknown system time zone. Only returned by [`local()`], and [`in_named()`]./// Could not project timestamp.Utcnow/// Could not get current system time./// An error as returned by [`local()`] and similar functions/// # See also:/// * [`local()`] / [`local_or()`]/// * [`in_named()`] / [`in_named_or()`]/// * [`in_tz()`]/// Get the current time in the local system time zone/// Possible errors include:/// * The current [Unix time](https://en.wikipedia.org/w/index.php?title=Unix_time&oldid=1101650731)///   could not be determined./// * The current Unix time could not be projected into the time zone.///   Most likely the system time is off, or you are a time traveler trying run this code a few billion years in the future or past./// * The local time zone could not be determined./// * The local time zone is not a valid [IANA time zone](https://www.iana.org/time-zones)./// # fn main() -> Result<(), tzdb::now::NowError> {/// let now = tzdb::now::local()?;/// In most cases you will want to default to a specified time zone if the system timezone/// could not be determined. Then use e.g./// let now = tzdb::now::local_or(tzdb::time_zone::GMT)?;/// * `local()` / [`local_or()`]local_or/// Get the current time in the local system time zone with a fallback time zone/// // Query the time zone of the local system, or use GMT as default:/// * [`local()`] / `local_or()`in_tz/// Get the current time a given time zone/// // What is the time in Berlin?/// let now = tzdb::now::in_tz(tzdb::time_zone::europe::BERLIN)?;/// * `in_tz()`in_named/// Get the current time in a given time zone, by name/// * The time zone is not a valid [IANA time zone](https://www.iana.org/time-zones)./// let now = tzdb::now::in_named("Europe/Berlin")?;/// In most cases you will want to default to a specified time zone if the time zone was not found./// Then use e.g./// let now = tzdb::now::in_named_or(tzdb::time_zone::GMT, "Some/City")?;/// * `in_named()` / [`in_named_or()`]in_named_or/// Get the current time in a given time zone, by name, or default to some static time zone/// // What is the time in Some City?/// * [`in_named()`] / `in_named_or()`//! Get the current time in some time zone/// Find a time zone by name, e.g. `"Europe/Berlin"` (case-insensitive)///     tzdb::time_zone::europe::BERLIN,///     tzdb::tz_by_name("Europe/Berlin").unwrap(),/// Find the raw, unparsed time zone data by name, e.g. `"Europe/Berlin"` (case-insensitive)///     tzdb::time_zone::europe::RAW_BERLIN,///     tzdb::raw_tz_by_name("Europe/Berlin").unwrap(),// Copyright 2022-2024 René Kijewski <crates.io@k6i.de>//! # `tzdb` — Time Zone Database//! [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/Kijewski/tzdb/ci.yml?branch=v0.6.x&style=for-the-badge)](https://github.com/Kijewski/tzdb/actions/workflows/ci.yml)//! [![Crates.io](https://img.shields.io/crates/v/tzdb?logo=rust&style=for-the-badge)](https://crates.io/crates/tzdb)//! ![Minimum supported Rust version](https://img.shields.io/badge/rustc-1.56+-important?logo=rust&style=for-the-badge "Minimum Supported Rust Version: 1.56")//! [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-informational?logo=apache&style=for-the-badge)](/LICENSE.md "License: Apache-2.0")//! This crate provides all time zones found in the [Time Zone Database](https://www.iana.org/time-zones).//! # #[cfg(feature = "local")] {//! let time_zone = tzdb::tz_by_name("ArCtIc/LoNgYeArByEn").unwrap();//! let current_time = tzdb::now::in_named("ArCtIc/LoNgYeArByEn").unwrap();//! * `local` <sup>(enabled by default)</sup> — enable functions to query the current system timeraw_tzdatatzdataV32V33V34V35V36V37V38V39V40V41V42V43V44V45V46V47V48V49V50V51V52V53V54V55V56V57V58V59V60V61V62V63V64V65V66V67V68V69V70V71V72V73V74V75V76V77V78V79V80V81V82V83V84V85V86V87V88V89V90V91V92V93V94V95V96V97V98V99V100V101V102V103V104V105V106V107V108V109V110V111V112V113V114V115V116V117V118V119V120V121V122V123V124V125V126V127V128V129V130V131V132V133V134V135V136V137V138V139V140V141V142V143V144V145V146V147V148V149V150V151V152V153V154V155V156V157V158V159V160V161V162V163V164V165V166V167V168V169V170V171V172V173V174V175V176V177V178V179V180V181V182V183V184V185V186V187V188V189V190V191V192V193V194V195V196V197V198V199V200V201V202V203V204V205V206V207V208V209V211V212V213V214V215V217V218V219V220V221V222V223V224V225V226V227V228V229V230V231V232V233V234V235V236V237V238V239V240V241V242V243V244V245V246V247V248V249V250V251V252V253V254V255V256V257V258V259V260V261V262V263V264V265V266V267V268V269V270V271V272V273V274V275V276V277V278V279V280V281V282V283V284V285V286V287V288V289V290V291V292V293V294V295V296V297V298V299V300V301V302V303V304V305V306V307V309V310V311V312V313V314V315V316V317V318V319V320V321V322V323V324V325V326V327V328V329V330V331V332V333V334V335V336V337V338339V339V340V341V342V343V344V345V346V347V348349V349350V350351V351352V352353V353354V354355V355356V356V357358V358359V359360V360361V361362V362363V363364V364365V365V366367V367368V368369V369370V370371V371372V372373V373374V374375V375376V376377V377378V378379V379380V380381V381382V382383V383V384385V385386V386387V387388V388389V389390V390391V391392V392393V393394V394395V395396V396397V397398V398399V399V400V401402V402403V403404V404405V405406V406407V407408V408409V409410V410411V411412V412413V413414V414415V415416V416417V417418V418419V419420V420421V421422V422423V423424V424425V425426V426427V427428V428429V429430V430431V431432V432433V433434V434435V435436V436437V437438V438439V439440V440441V441442V442443V443444V444445V445446V446447V447V448449V449V450451V451452V452453V453454V454455V455456V456457V457458V458459V459460V460461V461462V462463V463464V464465V465466V466467V467468V468469V469470V470471V471472V472473V473474V474475V475476V476477V477478V478479V479480V480481V481482V482483V483484V484485V485486V486487V487488V488489V489490V490491V491492V492493V493494V494495V495496V496497V497498V498499V499V500501V501502V502503V503504V504505V505506V506507V507508V508509V509510V510511V511V512V513514V514515V515516V516517V517518V518519V519520V520521V521522V522523V523524V524525V525526V526527V527528V528529V529530V530531V531532V532533V533534V534535V535536V536537V537538V538539V539540V540541V541542V542543V543544V544545V545546V546547V547548V548549V549550V550551V551552V552553V553554V554555V555556V556557V557558V558559V559560V560561V561562V562563V563564V564565V565566V566567V567568V568569V569570V570571V571572V572573V573574V574575V575V576577V577578V578579V579580V580581V581582V582583V583584V584585V585586V586587V587588V588589V589590V590591V591592V592593V593594V594V595596V596WORDLIST2522597TIME_ZONESRAW_TIME_ZONESASSO_VALUESfind_key// GENERATED FILE// ALL CHANGES MADE IN THIS FOLDER WILL BE LOST!test_all_names/// All defined time zones statically accessible/// The version of the source Time Zone Database/// The SHA512 hash of the source Time Zone Database (using the "Complete Distribution")/// A list of all known time zones// MIT No Attribution// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and// associated documentation files (the "Software"), to deal in the Software without restriction,// including without limitation the rights to use, copy, modify, merge, publish, distribute,// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is// furnished to do so.// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.AFRICA_ACCRAAFRICA_ADDIS_ABABAAFRICA_ALGIERSAFRICA_ASMARAAFRICA_ASMERAAFRICA_BAMAKOAFRICA_BANGUIAFRICA_BANJULAFRICA_BISSAUAFRICA_BLANTYREAFRICA_BRAZZAVILLEAFRICA_BUJUMBURAAFRICA_CASABLANCAAFRICA_CEUTAAFRICA_CONAKRYAFRICA_DAKARAFRICA_DAR_ES_SALAAMAFRICA_DJIBOUTIAFRICA_DOUALAAFRICA_EL_AAIUNAFRICA_FREETOWNAFRICA_GABORONEAFRICA_HARAREAFRICA_JOHANNESBURGAFRICA_JUBAAFRICA_KAMPALAAFRICA_KHARTOUMAFRICA_KIGALIAFRICA_KINSHASAAFRICA_LAGOSAFRICA_LIBREVILLEAFRICA_LOMEAFRICA_LUANDAAFRICA_LUBUMBASHIAFRICA_LUSAKAAFRICA_MALABOAFRICA_MAPUTOAFRICA_MASERUAFRICA_MBABANEAFRICA_MOGADISHUAFRICA_MONROVIAAFRICA_NDJAMENAAFRICA_NIAMEYAFRICA_NOUAKCHOTTAFRICA_OUAGADOUGOUAFRICA_PORTO_NOVOAFRICA_SAO_TOMEAFRICA_TUNISAFRICA_WINDHOEKAMERICA_ADAKAMERICA_ANCHORAGEAMERICA_ANGUILLAAMERICA_ANTIGUAAMERICA_ARAGUAINAAMERICA_ARGENTINA_LA_RIOJAAMERICA_ARGENTINA_RIO_GALLEGOSAMERICA_ARGENTINA_SALTAAMERICA_ARGENTINA_SAN_JUANAMERICA_ARGENTINA_SAN_LUISAMERICA_ARGENTINA_TUCUMANAMERICA_ARGENTINA_USHUAIAAMERICA_ARUBAAMERICA_ASUNCIONAMERICA_ATIKOKANAMERICA_BAHIAAMERICA_BAHIA_BANDERASAMERICA_BARBADOSAMERICA_BELEMAMERICA_BELIZEAMERICA_BLANC_SABLONAMERICA_BOA_VISTAAMERICA_BOGOTAAMERICA_BOISEAMERICA_BUENOS_AIRESAMERICA_CAMBRIDGE_BAYAMERICA_CAMPO_GRANDEAMERICA_CANCUNAMERICA_CARACASAMERICA_CATAMARCAAMERICA_CAYENNEAMERICA_CAYMANAMERICA_CHICAGOAMERICA_CHIHUAHUAAMERICA_CIUDAD_JUAREZAMERICA_CORAL_HARBOURAMERICA_CORDOBAAMERICA_COSTA_RICAAMERICA_CRESTONAMERICA_CUIABAAMERICA_CURACAOAMERICA_DANMARKSHAVNAMERICA_DAWSONAMERICA_DAWSON_CREEKAMERICA_DETROITAMERICA_DOMINICAAMERICA_EDMONTONAMERICA_EIRUNEPEAMERICA_EL_SALVADORAMERICA_ENSENADAAMERICA_FORTALEZAAMERICA_FORT_NELSONAMERICA_FORT_WAYNEAMERICA_GLACE_BAYAMERICA_GODTHABAMERICA_GOOSE_BAYAMERICA_GRAND_TURKAMERICA_GRENADAAMERICA_GUADELOUPEAMERICA_GUATEMALAAMERICA_GUAYAQUILAMERICA_GUYANAAMERICA_HALIFAXAMERICA_HERMOSILLOAMERICA_INDIANA_MARENGOAMERICA_INDIANA_PETERSBURGAMERICA_INDIANA_TELL_CITYAMERICA_INDIANA_VEVAYAMERICA_INDIANA_VINCENNESAMERICA_INDIANA_WINAMACAMERICA_INUVIKAMERICA_IQALUITAMERICA_JUJUYAMERICA_JUNEAUAMERICA_KENTUCKY_MONTICELLOAMERICA_KNOX_INAMERICA_KRALENDIJKAMERICA_LA_PAZAMERICA_LIMAAMERICA_LOS_ANGELESAMERICA_LOUISVILLEAMERICA_MACEIOAMERICA_MANAGUAAMERICA_MANAUSAMERICA_MARTINIQUEAMERICA_MATAMOROSAMERICA_MAZATLANAMERICA_MENDOZAAMERICA_MENOMINEEAMERICA_MERIDAAMERICA_METLAKATLAAMERICA_MEXICO_CITYAMERICA_MIQUELONAMERICA_MONCTONAMERICA_MONTERREYAMERICA_MONTEVIDEOAMERICA_MONTREALAMERICA_MONTSERRATAMERICA_NASSAUAMERICA_NEW_YORKAMERICA_NOMEAMERICA_NORONHAAMERICA_NORTH_DAKOTA_BEULAHAMERICA_NORTH_DAKOTA_CENTERAMERICA_NORTH_DAKOTA_NEW_SALEMAMERICA_OJINAGAAMERICA_PARAMARIBOAMERICA_PHOENIXAMERICA_PORTO_ACREAMERICA_PORTO_VELHOAMERICA_PORT_AU_PRINCEAMERICA_PORT_OF_SPAINAMERICA_PUNTA_ARENASAMERICA_RAINY_RIVERAMERICA_RANKIN_INLETAMERICA_RECIFEAMERICA_REGINAAMERICA_RESOLUTEAMERICA_SANTAREMAMERICA_SANTIAGOAMERICA_SANTO_DOMINGOAMERICA_SAO_PAULOAMERICA_SCORESBYSUNDAMERICA_SITKAAMERICA_ST_JOHNSAMERICA_ST_KITTSAMERICA_ST_LUCIAAMERICA_ST_THOMASAMERICA_ST_VINCENTAMERICA_SWIFT_CURRENTAMERICA_TEGUCIGALPAAMERICA_THULEAMERICA_TORTOLAAMERICA_VANCOUVERAMERICA_WHITEHORSEAMERICA_YAKUTATANTARCTICA_CASEYANTARCTICA_DAVISANTARCTICA_DUMONT_D_URVILLEANTARCTICA_MACQUARIEANTARCTICA_MAWSONANTARCTICA_MC_MURDOANTARCTICA_PALMERANTARCTICA_ROTHERAANTARCTICA_SYOWAANTARCTICA_TROLLANTARCTICA_VOSTOKARCTIC_LONGYEARBYENASIA_ADENASIA_ALMATYASIA_AMMANASIA_ANADYRASIA_AQTAUASIA_AQTOBEASIA_ASHGABATASIA_ATYRAUASIA_BAGHDADASIA_BAHRAINASIA_BAKUASIA_BANGKOKASIA_BARNAULASIA_BEIRUTASIA_BISHKEKASIA_BRUNEIASIA_CALCUTTAASIA_CHITAASIA_CHOIBALSANASIA_COLOMBOASIA_DACCAASIA_DAMASCUSASIA_DILIASIA_DUBAIASIA_DUSHANBEASIA_FAMAGUSTAASIA_GAZAASIA_HEBRONASIA_HOVDASIA_HO_CHI_MINHASIA_IRKUTSKASIA_JAKARTAASIA_JAYAPURAASIA_KABULASIA_KAMCHATKAASIA_KARACHIASIA_KASHGARASIA_KATHMANDUASIA_KHANDYGAASIA_KRASNOYARSKASIA_KUALA_LUMPURASIA_KUCHINGASIA_KUWAITASIA_MACAOASIA_MAGADANASIA_MAKASSARASIA_MANILAASIA_MUSCATASIA_NICOSIAASIA_NOVOKUZNETSKASIA_NOVOSIBIRSKASIA_OMSKASIA_ORALASIA_PHNOM_PENHASIA_PONTIANAKASIA_PYONGYANGASIA_QATARASIA_QOSTANAYASIA_QYZYLORDAASIA_RANGOONASIA_RIYADHASIA_SAKHALINASIA_SAMARKANDASIA_SREDNEKOLYMSKASIA_TASHKENTASIA_TBILISIASIA_THIMBUASIA_TOMSKASIA_ULAANBAATARASIA_UST_NERAASIA_VIENTIANEASIA_VLADIVOSTOKASIA_YAKUTSKASIA_YEKATERINBURGASIA_YEREVANATLANTIC_AZORESATLANTIC_BERMUDAATLANTIC_CANARYATLANTIC_CAPE_VERDEATLANTIC_FAEROEATLANTIC_MADEIRAATLANTIC_REYKJAVIKATLANTIC_SOUTH_GEORGIAATLANTIC_STANLEYATLANTIC_ST_HELENAAUSTRALIA_ACTAUSTRALIA_ADELAIDEAUSTRALIA_BRISBANEAUSTRALIA_BROKEN_HILLAUSTRALIA_CURRIEAUSTRALIA_DARWINAUSTRALIA_EUCLAAUSTRALIA_LHIAUSTRALIA_LINDEMANAUSTRALIA_MELBOURNEAUSTRALIA_PERTHCETCHILE_EASTER_ISLANDCST_6_CDTCUBAEETEGYPTEIREESTEST_5_EDTETC_GMT_MINUS_1ETC_GMT_MINUS_10ETC_GMT_MINUS_11ETC_GMT_MINUS_12ETC_GMT_MINUS_13ETC_GMT_MINUS_14ETC_GMT_MINUS_2ETC_GMT_MINUS_3ETC_GMT_MINUS_4ETC_GMT_MINUS_5ETC_GMT_MINUS_6ETC_GMT_MINUS_7ETC_GMT_MINUS_8ETC_GMT_MINUS_9ETC_GMT_PLUS_1ETC_GMT_PLUS_10ETC_GMT_PLUS_11ETC_GMT_PLUS_12ETC_GMT_PLUS_2ETC_GMT_PLUS_3ETC_GMT_PLUS_4ETC_GMT_PLUS_5ETC_GMT_PLUS_6ETC_GMT_PLUS_7ETC_GMT_PLUS_8ETC_GMT_PLUS_9EUROPE_AMSTERDAMEUROPE_ANDORRAEUROPE_ASTRAKHANEUROPE_ATHENSEUROPE_BELGRADEEUROPE_BRATISLAVAEUROPE_BRUSSELSEUROPE_BUCHARESTEUROPE_BUDAPESTEUROPE_BUSINGENEUROPE_CHISINAUEUROPE_COPENHAGENEUROPE_GIBRALTAREUROPE_GUERNSEYEUROPE_HELSINKIEUROPE_ISLE_OF_MANEUROPE_JERSEYEUROPE_KALININGRADEUROPE_KIEVEUROPE_KIROVEUROPE_LJUBLJANAEUROPE_LUXEMBOURGEUROPE_MADRIDEUROPE_MALTAEUROPE_MINSKEUROPE_MONACOEUROPE_OSLOEUROPE_PARISEUROPE_RIGAEUROPE_ROMEEUROPE_SAMARAEUROPE_SARAJEVOEUROPE_SARATOVEUROPE_SIMFEROPOLEUROPE_SKOPJEEUROPE_SOFIAEUROPE_STOCKHOLMEUROPE_TALLINNEUROPE_TIRANEEUROPE_ULYANOVSKEUROPE_VADUZEUROPE_VIENNAEUROPE_VILNIUSEUROPE_VOLGOGRADEUROPE_ZAGREBFACTORYGBGMTHONGKONGHSTICELANDINDIAN_ANTANANARIVOINDIAN_CHAGOSINDIAN_CHRISTMASINDIAN_COCOSINDIAN_COMOROINDIAN_KERGUELENINDIAN_MAHEINDIAN_MALDIVESINDIAN_MAURITIUSINDIAN_MAYOTTEINDIAN_REUNIONIRANISRAELJAMAICAJAPANKWAJALEINLIBYAMETMSTMST_7_MDTNAVAJONZNZ_CHATPACIFIC_APIAPACIFIC_BOUGAINVILLEPACIFIC_CHUUKPACIFIC_EFATEPACIFIC_ENDERBURYPACIFIC_FAKAOFOPACIFIC_FIJIPACIFIC_FUNAFUTIPACIFIC_GALAPAGOSPACIFIC_GAMBIERPACIFIC_GUADALCANALPACIFIC_GUAMPACIFIC_HONOLULUPACIFIC_KIRITIMATIPACIFIC_KOSRAEPACIFIC_MAJUROPACIFIC_MARQUESASPACIFIC_MIDWAYPACIFIC_NAURUPACIFIC_NIUEPACIFIC_NORFOLKPACIFIC_NOUMEAPACIFIC_PAGO_PAGOPACIFIC_PALAUPACIFIC_PITCAIRNPACIFIC_POHNPEIPACIFIC_PORT_MORESBYPACIFIC_RAROTONGAPACIFIC_SAIPANPACIFIC_TAHITIPACIFIC_TARAWAPACIFIC_TONGATAPUPACIFIC_WAKEPACIFIC_WALLISPOLANDPORTUGALPRCPST_8_PDTROCROKSINGAPORETURKEYUCTWETW_SUABIDJAN/// Time zone data for `"Africa/Abidjan"`ACCRA/// Time zone data for `"Africa/Accra"`ADDIS_ABABA/// Time zone data for `"Africa/Addis_Ababa"`ALGIERS/// Time zone data for `"Africa/Algiers"`ASMARA/// Time zone data for `"Africa/Asmara"`ASMERA/// Time zone data for `"Africa/Asmera"`BAMAKO/// Time zone data for `"Africa/Bamako"`BANGUI/// Time zone data for `"Africa/Bangui"`BANJUL/// Time zone data for `"Africa/Banjul"`BISSAU/// Time zone data for `"Africa/Bissau"`BLANTYRE/// Time zone data for `"Africa/Blantyre"`BRAZZAVILLE/// Time zone data for `"Africa/Brazzaville"`BUJUMBURA/// Time zone data for `"Africa/Bujumbura"`CAIRO/// Time zone data for `"Africa/Cairo"`CASABLANCA/// Time zone data for `"Africa/Casablanca"`CEUTA/// Time zone data for `"Africa/Ceuta"`CONAKRY/// Time zone data for `"Africa/Conakry"`DAKAR/// Time zone data for `"Africa/Dakar"`DAR_ES_SALAAM/// Time zone data for `"Africa/Dar_es_Salaam"`DJIBOUTI/// Time zone data for `"Africa/Djibouti"`DOUALA/// Time zone data for `"Africa/Douala"`EL_AAIUN/// Time zone data for `"Africa/El_Aaiun"`FREETOWN/// Time zone data for `"Africa/Freetown"`GABORONE/// Time zone data for `"Africa/Gaborone"`HARARE/// Time zone data for `"Africa/Harare"`JOHANNESBURG/// Time zone data for `"Africa/Johannesburg"`JUBA/// Time zone data for `"Africa/Juba"`KAMPALA/// Time zone data for `"Africa/Kampala"`KHARTOUM/// Time zone data for `"Africa/Khartoum"`KIGALI/// Time zone data for `"Africa/Kigali"`KINSHASA/// Time zone data for `"Africa/Kinshasa"`LAGOS/// Time zone data for `"Africa/Lagos"`LIBREVILLE/// Time zone data for `"Africa/Libreville"`LOME/// Time zone data for `"Africa/Lome"`LUANDA/// Time zone data for `"Africa/Luanda"`LUBUMBASHI/// Time zone data for `"Africa/Lubumbashi"`LUSAKA/// Time zone data for `"Africa/Lusaka"`MALABO/// Time zone data for `"Africa/Malabo"`MAPUTO/// Time zone data for `"Africa/Maputo"`MASERU/// Time zone data for `"Africa/Maseru"`MBABANE/// Time zone data for `"Africa/Mbabane"`MOGADISHU/// Time zone data for `"Africa/Mogadishu"`MONROVIA/// Time zone data for `"Africa/Monrovia"`NAIROBI/// Time zone data for `"Africa/Nairobi"`NDJAMENA/// Time zone data for `"Africa/Ndjamena"`NIAMEY/// Time zone data for `"Africa/Niamey"`NOUAKCHOTT/// Time zone data for `"Africa/Nouakchott"`OUAGADOUGOU/// Time zone data for `"Africa/Ouagadougou"`PORTO_NOVO/// Time zone data for `"Africa/Porto-Novo"`SAO_TOME/// Time zone data for `"Africa/Sao_Tome"`TIMBUKTU/// Time zone data for `"Africa/Timbuktu"`TRIPOLI/// Time zone data for `"Africa/Tripoli"`TUNIS/// Time zone data for `"Africa/Tunis"`WINDHOEK/// Time zone data for `"Africa/Windhoek"`RAW_ABIDJAN/// Raw, unparsed time zone data for `"Africa/Abidjan"`RAW_ACCRA/// Raw, unparsed time zone data for `"Africa/Accra"`RAW_ADDIS_ABABA/// Raw, unparsed time zone data for `"Africa/Addis_Ababa"`RAW_ALGIERS/// Raw, unparsed time zone data for `"Africa/Algiers"`RAW_ASMARA/// Raw, unparsed time zone data for `"Africa/Asmara"`RAW_ASMERA/// Raw, unparsed time zone data for `"Africa/Asmera"`RAW_BAMAKO/// Raw, unparsed time zone data for `"Africa/Bamako"`RAW_BANGUI/// Raw, unparsed time zone data for `"Africa/Bangui"`RAW_BANJUL/// Raw, unparsed time zone data for `"Africa/Banjul"`RAW_BISSAU/// Raw, unparsed time zone data for `"Africa/Bissau"`RAW_BLANTYRE/// Raw, unparsed time zone data for `"Africa/Blantyre"`RAW_BRAZZAVILLE/// Raw, unparsed time zone data for `"Africa/Brazzaville"`RAW_BUJUMBURA/// Raw, unparsed time zone data for `"Africa/Bujumbura"`RAW_CAIRO/// Raw, unparsed time zone data for `"Africa/Cairo"`RAW_CASABLANCA/// Raw, unparsed time zone data for `"Africa/Casablanca"`RAW_CEUTA/// Raw, unparsed time zone data for `"Africa/Ceuta"`RAW_CONAKRY/// Raw, unparsed time zone data for `"Africa/Conakry"`RAW_DAKAR/// Raw, unparsed time zone data for `"Africa/Dakar"`RAW_DAR_ES_SALAAM/// Raw, unparsed time zone data for `"Africa/Dar_es_Salaam"`RAW_DJIBOUTI/// Raw, unparsed time zone data for `"Africa/Djibouti"`RAW_DOUALA/// Raw, unparsed time zone data for `"Africa/Douala"`RAW_EL_AAIUN/// Raw, unparsed time zone data for `"Africa/El_Aaiun"`RAW_FREETOWN/// Raw, unparsed time zone data for `"Africa/Freetown"`RAW_GABORONE/// Raw, unparsed time zone data for `"Africa/Gaborone"`RAW_HARARE/// Raw, unparsed time zone data for `"Africa/Harare"`RAW_JOHANNESBURG/// Raw, unparsed time zone data for `"Africa/Johannesburg"`RAW_JUBA/// Raw, unparsed time zone data for `"Africa/Juba"`RAW_KAMPALA/// Raw, unparsed time zone data for `"Africa/Kampala"`RAW_KHARTOUM/// Raw, unparsed time zone data for `"Africa/Khartoum"`RAW_KIGALI/// Raw, unparsed time zone data for `"Africa/Kigali"`RAW_KINSHASA/// Raw, unparsed time zone data for `"Africa/Kinshasa"`RAW_LAGOS/// Raw, unparsed time zone data for `"Africa/Lagos"`RAW_LIBREVILLE/// Raw, unparsed time zone data for `"Africa/Libreville"`RAW_LOME/// Raw, unparsed time zone data for `"Africa/Lome"`RAW_LUANDA/// Raw, unparsed time zone data for `"Africa/Luanda"`RAW_LUBUMBASHI/// Raw, unparsed time zone data for `"Africa/Lubumbashi"`RAW_LUSAKA/// Raw, unparsed time zone data for `"Africa/Lusaka"`RAW_MALABO/// Raw, unparsed time zone data for `"Africa/Malabo"`RAW_MAPUTO/// Raw, unparsed time zone data for `"Africa/Maputo"`RAW_MASERU/// Raw, unparsed time zone data for `"Africa/Maseru"`RAW_MBABANE/// Raw, unparsed time zone data for `"Africa/Mbabane"`RAW_MOGADISHU/// Raw, unparsed time zone data for `"Africa/Mogadishu"`RAW_MONROVIA/// Raw, unparsed time zone data for `"Africa/Monrovia"`RAW_NAIROBI/// Raw, unparsed time zone data for `"Africa/Nairobi"`RAW_NDJAMENA/// Raw, unparsed time zone data for `"Africa/Ndjamena"`RAW_NIAMEY/// Raw, unparsed time zone data for `"Africa/Niamey"`RAW_NOUAKCHOTT/// Raw, unparsed time zone data for `"Africa/Nouakchott"`RAW_OUAGADOUGOU/// Raw, unparsed time zone data for `"Africa/Ouagadougou"`RAW_PORTO_NOVO/// Raw, unparsed time zone data for `"Africa/Porto-Novo"`RAW_SAO_TOME/// Raw, unparsed time zone data for `"Africa/Sao_Tome"`RAW_TIMBUKTU/// Raw, unparsed time zone data for `"Africa/Timbuktu"`RAW_TRIPOLI/// Raw, unparsed time zone data for `"Africa/Tripoli"`RAW_TUNIS/// Raw, unparsed time zone data for `"Africa/Tunis"`RAW_WINDHOEK/// Raw, unparsed time zone data for `"Africa/Windhoek"`africa/// AfricaADAK/// Time zone data for `"America/Adak"`ANCHORAGE/// Time zone data for `"America/Anchorage"`ANGUILLA/// Time zone data for `"America/Anguilla"`ANTIGUA/// Time zone data for `"America/Antigua"`ARAGUAINA/// Time zone data for `"America/Araguaina"`ARUBA/// Time zone data for `"America/Aruba"`ASUNCION/// Time zone data for `"America/Asuncion"`ATIKOKAN/// Time zone data for `"America/Atikokan"`ATKA/// Time zone data for `"America/Atka"`BAHIA/// Time zone data for `"America/Bahia"`BAHIA_BANDERAS/// Time zone data for `"America/Bahia_Banderas"`BARBADOS/// Time zone data for `"America/Barbados"`BELEM/// Time zone data for `"America/Belem"`BELIZE/// Time zone data for `"America/Belize"`BLANC_SABLON/// Time zone data for `"America/Blanc-Sablon"`BOA_VISTA/// Time zone data for `"America/Boa_Vista"`BOGOTA/// Time zone data for `"America/Bogota"`BOISE/// Time zone data for `"America/Boise"`BUENOS_AIRES/// Time zone data for `"America/Buenos_Aires"`CAMBRIDGE_BAY/// Time zone data for `"America/Cambridge_Bay"`CAMPO_GRANDE/// Time zone data for `"America/Campo_Grande"`CANCUN/// Time zone data for `"America/Cancun"`CARACAS/// Time zone data for `"America/Caracas"`CATAMARCA/// Time zone data for `"America/Catamarca"`CAYENNE/// Time zone data for `"America/Cayenne"`CAYMAN/// Time zone data for `"America/Cayman"`CHICAGO/// Time zone data for `"America/Chicago"`CHIHUAHUA/// Time zone data for `"America/Chihuahua"`CIUDAD_JUAREZ/// Time zone data for `"America/Ciudad_Juarez"`CORAL_HARBOUR/// Time zone data for `"America/Coral_Harbour"`CORDOBA/// Time zone data for `"America/Cordoba"`COSTA_RICA/// Time zone data for `"America/Costa_Rica"`CRESTON/// Time zone data for `"America/Creston"`CUIABA/// Time zone data for `"America/Cuiaba"`CURACAO/// Time zone data for `"America/Curacao"`DANMARKSHAVN/// Time zone data for `"America/Danmarkshavn"`DAWSON/// Time zone data for `"America/Dawson"`DAWSON_CREEK/// Time zone data for `"America/Dawson_Creek"`DENVER/// Time zone data for `"America/Denver"`DETROIT/// Time zone data for `"America/Detroit"`DOMINICA/// Time zone data for `"America/Dominica"`EDMONTON/// Time zone data for `"America/Edmonton"`EIRUNEPE/// Time zone data for `"America/Eirunepe"`EL_SALVADOR/// Time zone data for `"America/El_Salvador"`ENSENADA/// Time zone data for `"America/Ensenada"`FORTALEZA/// Time zone data for `"America/Fortaleza"`FORT_NELSON/// Time zone data for `"America/Fort_Nelson"`FORT_WAYNE/// Time zone data for `"America/Fort_Wayne"`GLACE_BAY/// Time zone data for `"America/Glace_Bay"`GODTHAB/// Time zone data for `"America/Godthab"`GOOSE_BAY/// Time zone data for `"America/Goose_Bay"`GRAND_TURK/// Time zone data for `"America/Grand_Turk"`GRENADA/// Time zone data for `"America/Grenada"`GUADELOUPE/// Time zone data for `"America/Guadeloupe"`GUATEMALA/// Time zone data for `"America/Guatemala"`GUAYAQUIL/// Time zone data for `"America/Guayaquil"`GUYANA/// Time zone data for `"America/Guyana"`HALIFAX/// Time zone data for `"America/Halifax"`HAVANA/// Time zone data for `"America/Havana"`HERMOSILLO/// Time zone data for `"America/Hermosillo"`INDIANAPOLIS/// Time zone data for `"America/Indianapolis"`INUVIK/// Time zone data for `"America/Inuvik"`IQALUIT/// Time zone data for `"America/Iqaluit"`/// Time zone data for `"America/Jamaica"`JUJUY/// Time zone data for `"America/Jujuy"`JUNEAU/// Time zone data for `"America/Juneau"`KNOX_IN/// Time zone data for `"America/Knox_IN"`KRALENDIJK/// Time zone data for `"America/Kralendijk"`LA_PAZ/// Time zone data for `"America/La_Paz"`LIMA/// Time zone data for `"America/Lima"`LOS_ANGELES/// Time zone data for `"America/Los_Angeles"`LOUISVILLE/// Time zone data for `"America/Louisville"`LOWER_PRINCES/// Time zone data for `"America/Lower_Princes"`MACEIO/// Time zone data for `"America/Maceio"`MANAGUA/// Time zone data for `"America/Managua"`MANAUS/// Time zone data for `"America/Manaus"`MARIGOT/// Time zone data for `"America/Marigot"`MARTINIQUE/// Time zone data for `"America/Martinique"`MATAMOROS/// Time zone data for `"America/Matamoros"`MAZATLAN/// Time zone data for `"America/Mazatlan"`MENDOZA/// Time zone data for `"America/Mendoza"`MENOMINEE/// Time zone data for `"America/Menominee"`MERIDA/// Time zone data for `"America/Merida"`METLAKATLA/// Time zone data for `"America/Metlakatla"`MEXICO_CITY/// Time zone data for `"America/Mexico_City"`MIQUELON/// Time zone data for `"America/Miquelon"`MONCTON/// Time zone data for `"America/Moncton"`MONTERREY/// Time zone data for `"America/Monterrey"`MONTEVIDEO/// Time zone data for `"America/Montevideo"`MONTREAL/// Time zone data for `"America/Montreal"`MONTSERRAT/// Time zone data for `"America/Montserrat"`NASSAU/// Time zone data for `"America/Nassau"`NEW_YORK/// Time zone data for `"America/New_York"`NIPIGON/// Time zone data for `"America/Nipigon"`NOME/// Time zone data for `"America/Nome"`NORONHA/// Time zone data for `"America/Noronha"`NUUK/// Time zone data for `"America/Nuuk"`OJINAGA/// Time zone data for `"America/Ojinaga"`PANAMA/// Time zone data for `"America/Panama"`PANGNIRTUNG/// Time zone data for `"America/Pangnirtung"`PARAMARIBO/// Time zone data for `"America/Paramaribo"`PHOENIX/// Time zone data for `"America/Phoenix"`PORTO_ACRE/// Time zone data for `"America/Porto_Acre"`PORTO_VELHO/// Time zone data for `"America/Porto_Velho"`PORT_AU_PRINCE/// Time zone data for `"America/Port-au-Prince"`PORT_OF_SPAIN/// Time zone data for `"America/Port_of_Spain"`PUERTO_RICO/// Time zone data for `"America/Puerto_Rico"`PUNTA_ARENAS/// Time zone data for `"America/Punta_Arenas"`RAINY_RIVER/// Time zone data for `"America/Rainy_River"`RANKIN_INLET/// Time zone data for `"America/Rankin_Inlet"`RECIFE/// Time zone data for `"America/Recife"`REGINA/// Time zone data for `"America/Regina"`RESOLUTE/// Time zone data for `"America/Resolute"`RIO_BRANCO/// Time zone data for `"America/Rio_Branco"`ROSARIO/// Time zone data for `"America/Rosario"`SANTAREM/// Time zone data for `"America/Santarem"`SANTA_ISABEL/// Time zone data for `"America/Santa_Isabel"`SANTIAGO/// Time zone data for `"America/Santiago"`SANTO_DOMINGO/// Time zone data for `"America/Santo_Domingo"`SAO_PAULO/// Time zone data for `"America/Sao_Paulo"`SCORESBYSUND/// Time zone data for `"America/Scoresbysund"`SHIPROCK/// Time zone data for `"America/Shiprock"`SITKA/// Time zone data for `"America/Sitka"`ST_BARTHELEMY/// Time zone data for `"America/St_Barthelemy"`ST_JOHNS/// Time zone data for `"America/St_Johns"`ST_KITTS/// Time zone data for `"America/St_Kitts"`ST_LUCIA/// Time zone data for `"America/St_Lucia"`ST_THOMAS/// Time zone data for `"America/St_Thomas"`ST_VINCENT/// Time zone data for `"America/St_Vincent"`SWIFT_CURRENT/// Time zone data for `"America/Swift_Current"`TEGUCIGALPA/// Time zone data for `"America/Tegucigalpa"`THULE/// Time zone data for `"America/Thule"`THUNDER_BAY/// Time zone data for `"America/Thunder_Bay"`TIJUANA/// Time zone data for `"America/Tijuana"`TORONTO/// Time zone data for `"America/Toronto"`TORTOLA/// Time zone data for `"America/Tortola"`VANCOUVER/// Time zone data for `"America/Vancouver"`VIRGIN/// Time zone data for `"America/Virgin"`WHITEHORSE/// Time zone data for `"America/Whitehorse"`WINNIPEG/// Time zone data for `"America/Winnipeg"`YAKUTAT/// Time zone data for `"America/Yakutat"`YELLOWKNIFE/// Time zone data for `"America/Yellowknife"`RAW_ADAK/// Raw, unparsed time zone data for `"America/Adak"`RAW_ANCHORAGE/// Raw, unparsed time zone data for `"America/Anchorage"`RAW_ANGUILLA/// Raw, unparsed time zone data for `"America/Anguilla"`RAW_ANTIGUA/// Raw, unparsed time zone data for `"America/Antigua"`RAW_ARAGUAINA/// Raw, unparsed time zone data for `"America/Araguaina"`RAW_ARUBA/// Raw, unparsed time zone data for `"America/Aruba"`RAW_ASUNCION/// Raw, unparsed time zone data for `"America/Asuncion"`RAW_ATIKOKAN/// Raw, unparsed time zone data for `"America/Atikokan"`RAW_ATKA/// Raw, unparsed time zone data for `"America/Atka"`RAW_BAHIA/// Raw, unparsed time zone data for `"America/Bahia"`RAW_BAHIA_BANDERAS/// Raw, unparsed time zone data for `"America/Bahia_Banderas"`RAW_BARBADOS/// Raw, unparsed time zone data for `"America/Barbados"`RAW_BELEM/// Raw, unparsed time zone data for `"America/Belem"`RAW_BELIZE/// Raw, unparsed time zone data for `"America/Belize"`RAW_BLANC_SABLON/// Raw, unparsed time zone data for `"America/Blanc-Sablon"`RAW_BOA_VISTA/// Raw, unparsed time zone data for `"America/Boa_Vista"`RAW_BOGOTA/// Raw, unparsed time zone data for `"America/Bogota"`RAW_BOISE/// Raw, unparsed time zone data for `"America/Boise"`RAW_BUENOS_AIRES/// Raw, unparsed time zone data for `"America/Buenos_Aires"`RAW_CAMBRIDGE_BAY/// Raw, unparsed time zone data for `"America/Cambridge_Bay"`RAW_CAMPO_GRANDE/// Raw, unparsed time zone data for `"America/Campo_Grande"`RAW_CANCUN/// Raw, unparsed time zone data for `"America/Cancun"`RAW_CARACAS/// Raw, unparsed time zone data for `"America/Caracas"`RAW_CATAMARCA/// Raw, unparsed time zone data for `"America/Catamarca"`RAW_CAYENNE/// Raw, unparsed time zone data for `"America/Cayenne"`RAW_CAYMAN/// Raw, unparsed time zone data for `"America/Cayman"`RAW_CHICAGO/// Raw, unparsed time zone data for `"America/Chicago"`RAW_CHIHUAHUA/// Raw, unparsed time zone data for `"America/Chihuahua"`RAW_CIUDAD_JUAREZ/// Raw, unparsed time zone data for `"America/Ciudad_Juarez"`RAW_CORAL_HARBOUR/// Raw, unparsed time zone data for `"America/Coral_Harbour"`RAW_CORDOBA/// Raw, unparsed time zone data for `"America/Cordoba"`RAW_COSTA_RICA/// Raw, unparsed time zone data for `"America/Costa_Rica"`RAW_CRESTON/// Raw, unparsed time zone data for `"America/Creston"`RAW_CUIABA/// Raw, unparsed time zone data for `"America/Cuiaba"`RAW_CURACAO/// Raw, unparsed time zone data for `"America/Curacao"`RAW_DANMARKSHAVN/// Raw, unparsed time zone data for `"America/Danmarkshavn"`RAW_DAWSON/// Raw, unparsed time zone data for `"America/Dawson"`RAW_DAWSON_CREEK/// Raw, unparsed time zone data for `"America/Dawson_Creek"`RAW_DENVER/// Raw, unparsed time zone data for `"America/Denver"`RAW_DETROIT/// Raw, unparsed time zone data for `"America/Detroit"`RAW_DOMINICA/// Raw, unparsed time zone data for `"America/Dominica"`RAW_EDMONTON/// Raw, unparsed time zone data for `"America/Edmonton"`RAW_EIRUNEPE/// Raw, unparsed time zone data for `"America/Eirunepe"`RAW_EL_SALVADOR/// Raw, unparsed time zone data for `"America/El_Salvador"`RAW_ENSENADA/// Raw, unparsed time zone data for `"America/Ensenada"`RAW_FORTALEZA/// Raw, unparsed time zone data for `"America/Fortaleza"`RAW_FORT_NELSON/// Raw, unparsed time zone data for `"America/Fort_Nelson"`RAW_FORT_WAYNE/// Raw, unparsed time zone data for `"America/Fort_Wayne"`RAW_GLACE_BAY/// Raw, unparsed time zone data for `"America/Glace_Bay"`RAW_GODTHAB/// Raw, unparsed time zone data for `"America/Godthab"`RAW_GOOSE_BAY/// Raw, unparsed time zone data for `"America/Goose_Bay"`RAW_GRAND_TURK/// Raw, unparsed time zone data for `"America/Grand_Turk"`RAW_GRENADA/// Raw, unparsed time zone data for `"America/Grenada"`RAW_GUADELOUPE/// Raw, unparsed time zone data for `"America/Guadeloupe"`RAW_GUATEMALA/// Raw, unparsed time zone data for `"America/Guatemala"`RAW_GUAYAQUIL/// Raw, unparsed time zone data for `"America/Guayaquil"`RAW_GUYANA/// Raw, unparsed time zone data for `"America/Guyana"`RAW_HALIFAX/// Raw, unparsed time zone data for `"America/Halifax"`RAW_HAVANA/// Raw, unparsed time zone data for `"America/Havana"`RAW_HERMOSILLO/// Raw, unparsed time zone data for `"America/Hermosillo"`RAW_INDIANAPOLIS/// Raw, unparsed time zone data for `"America/Indianapolis"`RAW_INUVIK/// Raw, unparsed time zone data for `"America/Inuvik"`RAW_IQALUIT/// Raw, unparsed time zone data for `"America/Iqaluit"`RAW_JAMAICA/// Raw, unparsed time zone data for `"America/Jamaica"`RAW_JUJUY/// Raw, unparsed time zone data for `"America/Jujuy"`RAW_JUNEAU/// Raw, unparsed time zone data for `"America/Juneau"`RAW_KNOX_IN/// Raw, unparsed time zone data for `"America/Knox_IN"`RAW_KRALENDIJK/// Raw, unparsed time zone data for `"America/Kralendijk"`RAW_LA_PAZ/// Raw, unparsed time zone data for `"America/La_Paz"`RAW_LIMA/// Raw, unparsed time zone data for `"America/Lima"`RAW_LOS_ANGELES/// Raw, unparsed time zone data for `"America/Los_Angeles"`RAW_LOUISVILLE/// Raw, unparsed time zone data for `"America/Louisville"`RAW_LOWER_PRINCES/// Raw, unparsed time zone data for `"America/Lower_Princes"`RAW_MACEIO/// Raw, unparsed time zone data for `"America/Maceio"`RAW_MANAGUA/// Raw, unparsed time zone data for `"America/Managua"`RAW_MANAUS/// Raw, unparsed time zone data for `"America/Manaus"`RAW_MARIGOT/// Raw, unparsed time zone data for `"America/Marigot"`RAW_MARTINIQUE/// Raw, unparsed time zone data for `"America/Martinique"`RAW_MATAMOROS/// Raw, unparsed time zone data for `"America/Matamoros"`RAW_MAZATLAN/// Raw, unparsed time zone data for `"America/Mazatlan"`RAW_MENDOZA/// Raw, unparsed time zone data for `"America/Mendoza"`RAW_MENOMINEE/// Raw, unparsed time zone data for `"America/Menominee"`RAW_MERIDA/// Raw, unparsed time zone data for `"America/Merida"`RAW_METLAKATLA/// Raw, unparsed time zone data for `"America/Metlakatla"`RAW_MEXICO_CITY/// Raw, unparsed time zone data for `"America/Mexico_City"`RAW_MIQUELON/// Raw, unparsed time zone data for `"America/Miquelon"`RAW_MONCTON/// Raw, unparsed time zone data for `"America/Moncton"`RAW_MONTERREY/// Raw, unparsed time zone data for `"America/Monterrey"`RAW_MONTEVIDEO/// Raw, unparsed time zone data for `"America/Montevideo"`RAW_MONTREAL/// Raw, unparsed time zone data for `"America/Montreal"`RAW_MONTSERRAT/// Raw, unparsed time zone data for `"America/Montserrat"`RAW_NASSAU/// Raw, unparsed time zone data for `"America/Nassau"`RAW_NEW_YORK/// Raw, unparsed time zone data for `"America/New_York"`RAW_NIPIGON/// Raw, unparsed time zone data for `"America/Nipigon"`RAW_NOME/// Raw, unparsed time zone data for `"America/Nome"`RAW_NORONHA/// Raw, unparsed time zone data for `"America/Noronha"`RAW_NUUK/// Raw, unparsed time zone data for `"America/Nuuk"`RAW_OJINAGA/// Raw, unparsed time zone data for `"America/Ojinaga"`RAW_PANAMA/// Raw, unparsed time zone data for `"America/Panama"`RAW_PANGNIRTUNG/// Raw, unparsed time zone data for `"America/Pangnirtung"`RAW_PARAMARIBO/// Raw, unparsed time zone data for `"America/Paramaribo"`RAW_PHOENIX/// Raw, unparsed time zone data for `"America/Phoenix"`RAW_PORTO_ACRE/// Raw, unparsed time zone data for `"America/Porto_Acre"`RAW_PORTO_VELHO/// Raw, unparsed time zone data for `"America/Porto_Velho"`RAW_PORT_AU_PRINCE/// Raw, unparsed time zone data for `"America/Port-au-Prince"`RAW_PORT_OF_SPAIN/// Raw, unparsed time zone data for `"America/Port_of_Spain"`RAW_PUERTO_RICO/// Raw, unparsed time zone data for `"America/Puerto_Rico"`RAW_PUNTA_ARENAS/// Raw, unparsed time zone data for `"America/Punta_Arenas"`RAW_RAINY_RIVER/// Raw, unparsed time zone data for `"America/Rainy_River"`RAW_RANKIN_INLET/// Raw, unparsed time zone data for `"America/Rankin_Inlet"`RAW_RECIFE/// Raw, unparsed time zone data for `"America/Recife"`RAW_REGINA/// Raw, unparsed time zone data for `"America/Regina"`RAW_RESOLUTE/// Raw, unparsed time zone data for `"America/Resolute"`RAW_RIO_BRANCO/// Raw, unparsed time zone data for `"America/Rio_Branco"`RAW_ROSARIO/// Raw, unparsed time zone data for `"America/Rosario"`RAW_SANTAREM/// Raw, unparsed time zone data for `"America/Santarem"`RAW_SANTA_ISABEL/// Raw, unparsed time zone data for `"America/Santa_Isabel"`RAW_SANTIAGO/// Raw, unparsed time zone data for `"America/Santiago"`RAW_SANTO_DOMINGO/// Raw, unparsed time zone data for `"America/Santo_Domingo"`RAW_SAO_PAULO/// Raw, unparsed time zone data for `"America/Sao_Paulo"`RAW_SCORESBYSUND/// Raw, unparsed time zone data for `"America/Scoresbysund"`RAW_SHIPROCK/// Raw, unparsed time zone data for `"America/Shiprock"`RAW_SITKA/// Raw, unparsed time zone data for `"America/Sitka"`RAW_ST_BARTHELEMY/// Raw, unparsed time zone data for `"America/St_Barthelemy"`RAW_ST_JOHNS/// Raw, unparsed time zone data for `"America/St_Johns"`RAW_ST_KITTS/// Raw, unparsed time zone data for `"America/St_Kitts"`RAW_ST_LUCIA/// Raw, unparsed time zone data for `"America/St_Lucia"`RAW_ST_THOMAS/// Raw, unparsed time zone data for `"America/St_Thomas"`RAW_ST_VINCENT/// Raw, unparsed time zone data for `"America/St_Vincent"`RAW_SWIFT_CURRENT/// Raw, unparsed time zone data for `"America/Swift_Current"`RAW_TEGUCIGALPA/// Raw, unparsed time zone data for `"America/Tegucigalpa"`RAW_THULE/// Raw, unparsed time zone data for `"America/Thule"`RAW_THUNDER_BAY/// Raw, unparsed time zone data for `"America/Thunder_Bay"`RAW_TIJUANA/// Raw, unparsed time zone data for `"America/Tijuana"`RAW_TORONTO/// Raw, unparsed time zone data for `"America/Toronto"`RAW_TORTOLA/// Raw, unparsed time zone data for `"America/Tortola"`RAW_VANCOUVER/// Raw, unparsed time zone data for `"America/Vancouver"`RAW_VIRGIN/// Raw, unparsed time zone data for `"America/Virgin"`RAW_WHITEHORSE/// Raw, unparsed time zone data for `"America/Whitehorse"`RAW_WINNIPEG/// Raw, unparsed time zone data for `"America/Winnipeg"`RAW_YAKUTAT/// Raw, unparsed time zone data for `"America/Yakutat"`RAW_YELLOWKNIFE/// Raw, unparsed time zone data for `"America/Yellowknife"`america/// America/// Time zone data for `"America/Argentina/Buenos_Aires"`/// Time zone data for `"America/Argentina/Catamarca"`COMOD_RIVADAVIA/// Time zone data for `"America/Argentina/ComodRivadavia"`/// Time zone data for `"America/Argentina/Cordoba"`/// Time zone data for `"America/Argentina/Jujuy"`LA_RIOJA/// Time zone data for `"America/Argentina/La_Rioja"`/// Time zone data for `"America/Argentina/Mendoza"`RIO_GALLEGOS/// Time zone data for `"America/Argentina/Rio_Gallegos"`SALTA/// Time zone data for `"America/Argentina/Salta"`SAN_JUAN/// Time zone data for `"America/Argentina/San_Juan"`SAN_LUIS/// Time zone data for `"America/Argentina/San_Luis"`TUCUMAN/// Time zone data for `"America/Argentina/Tucuman"`USHUAIA/// Time zone data for `"America/Argentina/Ushuaia"`/// Raw, unparsed time zone data for `"America/Argentina/Buenos_Aires"`/// Raw, unparsed time zone data for `"America/Argentina/Catamarca"`RAW_COMOD_RIVADAVIA/// Raw, unparsed time zone data for `"America/Argentina/ComodRivadavia"`/// Raw, unparsed time zone data for `"America/Argentina/Cordoba"`/// Raw, unparsed time zone data for `"America/Argentina/Jujuy"`RAW_LA_RIOJA/// Raw, unparsed time zone data for `"America/Argentina/La_Rioja"`/// Raw, unparsed time zone data for `"America/Argentina/Mendoza"`RAW_RIO_GALLEGOS/// Raw, unparsed time zone data for `"America/Argentina/Rio_Gallegos"`RAW_SALTA/// Raw, unparsed time zone data for `"America/Argentina/Salta"`RAW_SAN_JUAN/// Raw, unparsed time zone data for `"America/Argentina/San_Juan"`RAW_SAN_LUIS/// Raw, unparsed time zone data for `"America/Argentina/San_Luis"`RAW_TUCUMAN/// Raw, unparsed time zone data for `"America/Argentina/Tucuman"`RAW_USHUAIA/// Raw, unparsed time zone data for `"America/Argentina/Ushuaia"`america_argentina/// America/Argentina/// Time zone data for `"America/Indiana/Indianapolis"`KNOX/// Time zone data for `"America/Indiana/Knox"`MARENGO/// Time zone data for `"America/Indiana/Marengo"`PETERSBURG/// Time zone data for `"America/Indiana/Petersburg"`TELL_CITY/// Time zone data for `"America/Indiana/Tell_City"`VEVAY/// Time zone data for `"America/Indiana/Vevay"`VINCENNES/// Time zone data for `"America/Indiana/Vincennes"`WINAMAC/// Time zone data for `"America/Indiana/Winamac"`/// Raw, unparsed time zone data for `"America/Indiana/Indianapolis"`RAW_KNOX/// Raw, unparsed time zone data for `"America/Indiana/Knox"`RAW_MARENGO/// Raw, unparsed time zone data for `"America/Indiana/Marengo"`RAW_PETERSBURG/// Raw, unparsed time zone data for `"America/Indiana/Petersburg"`RAW_TELL_CITY/// Raw, unparsed time zone data for `"America/Indiana/Tell_City"`RAW_VEVAY/// Raw, unparsed time zone data for `"America/Indiana/Vevay"`RAW_VINCENNES/// Raw, unparsed time zone data for `"America/Indiana/Vincennes"`RAW_WINAMAC/// Raw, unparsed time zone data for `"America/Indiana/Winamac"`america_indiana/// America/Indiana/// Time zone data for `"America/Kentucky/Louisville"`MONTICELLO/// Time zone data for `"America/Kentucky/Monticello"`/// Raw, unparsed time zone data for `"America/Kentucky/Louisville"`RAW_MONTICELLO/// Raw, unparsed time zone data for `"America/Kentucky/Monticello"`america_kentucky/// America/KentuckyBEULAH/// Time zone data for `"America/North_Dakota/Beulah"`CENTER/// Time zone data for `"America/North_Dakota/Center"`NEW_SALEM/// Time zone data for `"America/North_Dakota/New_Salem"`RAW_BEULAH/// Raw, unparsed time zone data for `"America/North_Dakota/Beulah"`RAW_CENTER/// Raw, unparsed time zone data for `"America/North_Dakota/Center"`RAW_NEW_SALEM/// Raw, unparsed time zone data for `"America/North_Dakota/New_Salem"`america_north_dakota/// America/North_DakotaCASEY/// Time zone data for `"Antarctica/Casey"`DAVIS/// Time zone data for `"Antarctica/Davis"`DUMONT_D_URVILLE/// Time zone data for `"Antarctica/DumontDUrville"`MACQUARIE/// Time zone data for `"Antarctica/Macquarie"`MAWSON/// Time zone data for `"Antarctica/Mawson"`MC_MURDO/// Time zone data for `"Antarctica/McMurdo"`PALMER/// Time zone data for `"Antarctica/Palmer"`ROTHERA/// Time zone data for `"Antarctica/Rothera"`SOUTH_POLE/// Time zone data for `"Antarctica/South_Pole"`SYOWA/// Time zone data for `"Antarctica/Syowa"`TROLL/// Time zone data for `"Antarctica/Troll"`VOSTOK/// Time zone data for `"Antarctica/Vostok"`RAW_CASEY/// Raw, unparsed time zone data for `"Antarctica/Casey"`RAW_DAVIS/// Raw, unparsed time zone data for `"Antarctica/Davis"`RAW_DUMONT_D_URVILLE/// Raw, unparsed time zone data for `"Antarctica/DumontDUrville"`RAW_MACQUARIE/// Raw, unparsed time zone data for `"Antarctica/Macquarie"`RAW_MAWSON/// Raw, unparsed time zone data for `"Antarctica/Mawson"`RAW_MC_MURDO/// Raw, unparsed time zone data for `"Antarctica/McMurdo"`RAW_PALMER/// Raw, unparsed time zone data for `"Antarctica/Palmer"`RAW_ROTHERA/// Raw, unparsed time zone data for `"Antarctica/Rothera"`RAW_SOUTH_POLE/// Raw, unparsed time zone data for `"Antarctica/South_Pole"`RAW_SYOWA/// Raw, unparsed time zone data for `"Antarctica/Syowa"`RAW_TROLL/// Raw, unparsed time zone data for `"Antarctica/Troll"`RAW_VOSTOK/// Raw, unparsed time zone data for `"Antarctica/Vostok"`antarctica/// AntarcticaLONGYEARBYEN/// Time zone data for `"Arctic/Longyearbyen"`RAW_LONGYEARBYEN/// Raw, unparsed time zone data for `"Arctic/Longyearbyen"`arctic/// ArcticADEN/// Time zone data for `"Asia/Aden"`ALMATY/// Time zone data for `"Asia/Almaty"`AMMAN/// Time zone data for `"Asia/Amman"`ANADYR/// Time zone data for `"Asia/Anadyr"`AQTAU/// Time zone data for `"Asia/Aqtau"`AQTOBE/// Time zone data for `"Asia/Aqtobe"`ASHGABAT/// Time zone data for `"Asia/Ashgabat"`ASHKHABAD/// Time zone data for `"Asia/Ashkhabad"`ATYRAU/// Time zone data for `"Asia/Atyrau"`BAGHDAD/// Time zone data for `"Asia/Baghdad"`BAHRAIN/// Time zone data for `"Asia/Bahrain"`BAKU/// Time zone data for `"Asia/Baku"`BANGKOK/// Time zone data for `"Asia/Bangkok"`BARNAUL/// Time zone data for `"Asia/Barnaul"`BEIRUT/// Time zone data for `"Asia/Beirut"`BISHKEK/// Time zone data for `"Asia/Bishkek"`BRUNEI/// Time zone data for `"Asia/Brunei"`CALCUTTA/// Time zone data for `"Asia/Calcutta"`CHITA/// Time zone data for `"Asia/Chita"`CHOIBALSAN/// Time zone data for `"Asia/Choibalsan"`CHONGQING/// Time zone data for `"Asia/Chongqing"`CHUNGKING/// Time zone data for `"Asia/Chungking"`COLOMBO/// Time zone data for `"Asia/Colombo"`DACCA/// Time zone data for `"Asia/Dacca"`DAMASCUS/// Time zone data for `"Asia/Damascus"`DHAKA/// Time zone data for `"Asia/Dhaka"`DILI/// Time zone data for `"Asia/Dili"`DUBAI/// Time zone data for `"Asia/Dubai"`DUSHANBE/// Time zone data for `"Asia/Dushanbe"`FAMAGUSTA/// Time zone data for `"Asia/Famagusta"`GAZA/// Time zone data for `"Asia/Gaza"`HARBIN/// Time zone data for `"Asia/Harbin"`HEBRON/// Time zone data for `"Asia/Hebron"`HONG_KONG/// Time zone data for `"Asia/Hong_Kong"`HOVD/// Time zone data for `"Asia/Hovd"`HO_CHI_MINH/// Time zone data for `"Asia/Ho_Chi_Minh"`IRKUTSK/// Time zone data for `"Asia/Irkutsk"`ISTANBUL/// Time zone data for `"Asia/Istanbul"`JAKARTA/// Time zone data for `"Asia/Jakarta"`JAYAPURA/// Time zone data for `"Asia/Jayapura"`JERUSALEM/// Time zone data for `"Asia/Jerusalem"`KABUL/// Time zone data for `"Asia/Kabul"`KAMCHATKA/// Time zone data for `"Asia/Kamchatka"`KARACHI/// Time zone data for `"Asia/Karachi"`KASHGAR/// Time zone data for `"Asia/Kashgar"`KATHMANDU/// Time zone data for `"Asia/Kathmandu"`KATMANDU/// Time zone data for `"Asia/Katmandu"`KHANDYGA/// Time zone data for `"Asia/Khandyga"`KOLKATA/// Time zone data for `"Asia/Kolkata"`KRASNOYARSK/// Time zone data for `"Asia/Krasnoyarsk"`KUALA_LUMPUR/// Time zone data for `"Asia/Kuala_Lumpur"`KUCHING/// Time zone data for `"Asia/Kuching"`KUWAIT/// Time zone data for `"Asia/Kuwait"`MACAO/// Time zone data for `"Asia/Macao"`MACAU/// Time zone data for `"Asia/Macau"`MAGADAN/// Time zone data for `"Asia/Magadan"`MAKASSAR/// Time zone data for `"Asia/Makassar"`MANILA/// Time zone data for `"Asia/Manila"`MUSCAT/// Time zone data for `"Asia/Muscat"`NICOSIA/// Time zone data for `"Asia/Nicosia"`NOVOKUZNETSK/// Time zone data for `"Asia/Novokuznetsk"`NOVOSIBIRSK/// Time zone data for `"Asia/Novosibirsk"`OMSK/// Time zone data for `"Asia/Omsk"`ORAL/// Time zone data for `"Asia/Oral"`PHNOM_PENH/// Time zone data for `"Asia/Phnom_Penh"`PONTIANAK/// Time zone data for `"Asia/Pontianak"`PYONGYANG/// Time zone data for `"Asia/Pyongyang"`QATAR/// Time zone data for `"Asia/Qatar"`QOSTANAY/// Time zone data for `"Asia/Qostanay"`QYZYLORDA/// Time zone data for `"Asia/Qyzylorda"`RANGOON/// Time zone data for `"Asia/Rangoon"`RIYADH/// Time zone data for `"Asia/Riyadh"`SAIGON/// Time zone data for `"Asia/Saigon"`SAKHALIN/// Time zone data for `"Asia/Sakhalin"`SAMARKAND/// Time zone data for `"Asia/Samarkand"`SEOUL/// Time zone data for `"Asia/Seoul"`SHANGHAI/// Time zone data for `"Asia/Shanghai"`/// Time zone data for `"Asia/Singapore"`SREDNEKOLYMSK/// Time zone data for `"Asia/Srednekolymsk"`TAIPEI/// Time zone data for `"Asia/Taipei"`TASHKENT/// Time zone data for `"Asia/Tashkent"`TBILISI/// Time zone data for `"Asia/Tbilisi"`TEHRAN/// Time zone data for `"Asia/Tehran"`TEL_AVIV/// Time zone data for `"Asia/Tel_Aviv"`THIMBU/// Time zone data for `"Asia/Thimbu"`THIMPHU/// Time zone data for `"Asia/Thimphu"`TOKYO/// Time zone data for `"Asia/Tokyo"`TOMSK/// Time zone data for `"Asia/Tomsk"`UJUNG_PANDANG/// Time zone data for `"Asia/Ujung_Pandang"`ULAANBAATAR/// Time zone data for `"Asia/Ulaanbaatar"`ULAN_BATOR/// Time zone data for `"Asia/Ulan_Bator"`URUMQI/// Time zone data for `"Asia/Urumqi"`UST_NERA/// Time zone data for `"Asia/Ust-Nera"`VIENTIANE/// Time zone data for `"Asia/Vientiane"`VLADIVOSTOK/// Time zone data for `"Asia/Vladivostok"`YAKUTSK/// Time zone data for `"Asia/Yakutsk"`YANGON/// Time zone data for `"Asia/Yangon"`YEKATERINBURG/// Time zone data for `"Asia/Yekaterinburg"`YEREVAN/// Time zone data for `"Asia/Yerevan"`RAW_ADEN/// Raw, unparsed time zone data for `"Asia/Aden"`RAW_ALMATY/// Raw, unparsed time zone data for `"Asia/Almaty"`RAW_AMMAN/// Raw, unparsed time zone data for `"Asia/Amman"`RAW_ANADYR/// Raw, unparsed time zone data for `"Asia/Anadyr"`RAW_AQTAU/// Raw, unparsed time zone data for `"Asia/Aqtau"`RAW_AQTOBE/// Raw, unparsed time zone data for `"Asia/Aqtobe"`RAW_ASHGABAT/// Raw, unparsed time zone data for `"Asia/Ashgabat"`RAW_ASHKHABAD/// Raw, unparsed time zone data for `"Asia/Ashkhabad"`RAW_ATYRAU/// Raw, unparsed time zone data for `"Asia/Atyrau"`RAW_BAGHDAD/// Raw, unparsed time zone data for `"Asia/Baghdad"`RAW_BAHRAIN/// Raw, unparsed time zone data for `"Asia/Bahrain"`RAW_BAKU/// Raw, unparsed time zone data for `"Asia/Baku"`RAW_BANGKOK/// Raw, unparsed time zone data for `"Asia/Bangkok"`RAW_BARNAUL/// Raw, unparsed time zone data for `"Asia/Barnaul"`RAW_BEIRUT/// Raw, unparsed time zone data for `"Asia/Beirut"`RAW_BISHKEK/// Raw, unparsed time zone data for `"Asia/Bishkek"`RAW_BRUNEI/// Raw, unparsed time zone data for `"Asia/Brunei"`RAW_CALCUTTA/// Raw, unparsed time zone data for `"Asia/Calcutta"`RAW_CHITA/// Raw, unparsed time zone data for `"Asia/Chita"`RAW_CHOIBALSAN/// Raw, unparsed time zone data for `"Asia/Choibalsan"`RAW_CHONGQING/// Raw, unparsed time zone data for `"Asia/Chongqing"`RAW_CHUNGKING/// Raw, unparsed time zone data for `"Asia/Chungking"`RAW_COLOMBO/// Raw, unparsed time zone data for `"Asia/Colombo"`RAW_DACCA/// Raw, unparsed time zone data for `"Asia/Dacca"`RAW_DAMASCUS/// Raw, unparsed time zone data for `"Asia/Damascus"`RAW_DHAKA/// Raw, unparsed time zone data for `"Asia/Dhaka"`RAW_DILI/// Raw, unparsed time zone data for `"Asia/Dili"`RAW_DUBAI/// Raw, unparsed time zone data for `"Asia/Dubai"`RAW_DUSHANBE/// Raw, unparsed time zone data for `"Asia/Dushanbe"`RAW_FAMAGUSTA/// Raw, unparsed time zone data for `"Asia/Famagusta"`RAW_GAZA/// Raw, unparsed time zone data for `"Asia/Gaza"`RAW_HARBIN/// Raw, unparsed time zone data for `"Asia/Harbin"`RAW_HEBRON/// Raw, unparsed time zone data for `"Asia/Hebron"`RAW_HONG_KONG/// Raw, unparsed time zone data for `"Asia/Hong_Kong"`RAW_HOVD/// Raw, unparsed time zone data for `"Asia/Hovd"`RAW_HO_CHI_MINH/// Raw, unparsed time zone data for `"Asia/Ho_Chi_Minh"`RAW_IRKUTSK/// Raw, unparsed time zone data for `"Asia/Irkutsk"`RAW_ISTANBUL/// Raw, unparsed time zone data for `"Asia/Istanbul"`RAW_JAKARTA/// Raw, unparsed time zone data for `"Asia/Jakarta"`RAW_JAYAPURA/// Raw, unparsed time zone data for `"Asia/Jayapura"`RAW_JERUSALEM/// Raw, unparsed time zone data for `"Asia/Jerusalem"`RAW_KABUL/// Raw, unparsed time zone data for `"Asia/Kabul"`RAW_KAMCHATKA/// Raw, unparsed time zone data for `"Asia/Kamchatka"`RAW_KARACHI/// Raw, unparsed time zone data for `"Asia/Karachi"`RAW_KASHGAR/// Raw, unparsed time zone data for `"Asia/Kashgar"`RAW_KATHMANDU/// Raw, unparsed time zone data for `"Asia/Kathmandu"`RAW_KATMANDU/// Raw, unparsed time zone data for `"Asia/Katmandu"`RAW_KHANDYGA/// Raw, unparsed time zone data for `"Asia/Khandyga"`RAW_KOLKATA/// Raw, unparsed time zone data for `"Asia/Kolkata"`RAW_KRASNOYARSK/// Raw, unparsed time zone data for `"Asia/Krasnoyarsk"`RAW_KUALA_LUMPUR/// Raw, unparsed time zone data for `"Asia/Kuala_Lumpur"`RAW_KUCHING/// Raw, unparsed time zone data for `"Asia/Kuching"`RAW_KUWAIT/// Raw, unparsed time zone data for `"Asia/Kuwait"`RAW_MACAO/// Raw, unparsed time zone data for `"Asia/Macao"`RAW_MACAU/// Raw, unparsed time zone data for `"Asia/Macau"`RAW_MAGADAN/// Raw, unparsed time zone data for `"Asia/Magadan"`RAW_MAKASSAR/// Raw, unparsed time zone data for `"Asia/Makassar"`RAW_MANILA/// Raw, unparsed time zone data for `"Asia/Manila"`RAW_MUSCAT/// Raw, unparsed time zone data for `"Asia/Muscat"`RAW_NICOSIA/// Raw, unparsed time zone data for `"Asia/Nicosia"`RAW_NOVOKUZNETSK/// Raw, unparsed time zone data for `"Asia/Novokuznetsk"`RAW_NOVOSIBIRSK/// Raw, unparsed time zone data for `"Asia/Novosibirsk"`RAW_OMSK/// Raw, unparsed time zone data for `"Asia/Omsk"`RAW_ORAL/// Raw, unparsed time zone data for `"Asia/Oral"`RAW_PHNOM_PENH/// Raw, unparsed time zone data for `"Asia/Phnom_Penh"`RAW_PONTIANAK/// Raw, unparsed time zone data for `"Asia/Pontianak"`RAW_PYONGYANG/// Raw, unparsed time zone data for `"Asia/Pyongyang"`RAW_QATAR/// Raw, unparsed time zone data for `"Asia/Qatar"`RAW_QOSTANAY/// Raw, unparsed time zone data for `"Asia/Qostanay"`RAW_QYZYLORDA/// Raw, unparsed time zone data for `"Asia/Qyzylorda"`RAW_RANGOON/// Raw, unparsed time zone data for `"Asia/Rangoon"`RAW_RIYADH/// Raw, unparsed time zone data for `"Asia/Riyadh"`RAW_SAIGON/// Raw, unparsed time zone data for `"Asia/Saigon"`RAW_SAKHALIN/// Raw, unparsed time zone data for `"Asia/Sakhalin"`RAW_SAMARKAND/// Raw, unparsed time zone data for `"Asia/Samarkand"`RAW_SEOUL/// Raw, unparsed time zone data for `"Asia/Seoul"`RAW_SHANGHAI/// Raw, unparsed time zone data for `"Asia/Shanghai"`RAW_SINGAPORE/// Raw, unparsed time zone data for `"Asia/Singapore"`RAW_SREDNEKOLYMSK/// Raw, unparsed time zone data for `"Asia/Srednekolymsk"`RAW_TAIPEI/// Raw, unparsed time zone data for `"Asia/Taipei"`RAW_TASHKENT/// Raw, unparsed time zone data for `"Asia/Tashkent"`RAW_TBILISI/// Raw, unparsed time zone data for `"Asia/Tbilisi"`RAW_TEHRAN/// Raw, unparsed time zone data for `"Asia/Tehran"`RAW_TEL_AVIV/// Raw, unparsed time zone data for `"Asia/Tel_Aviv"`RAW_THIMBU/// Raw, unparsed time zone data for `"Asia/Thimbu"`RAW_THIMPHU/// Raw, unparsed time zone data for `"Asia/Thimphu"`RAW_TOKYO/// Raw, unparsed time zone data for `"Asia/Tokyo"`RAW_TOMSK/// Raw, unparsed time zone data for `"Asia/Tomsk"`RAW_UJUNG_PANDANG/// Raw, unparsed time zone data for `"Asia/Ujung_Pandang"`RAW_ULAANBAATAR/// Raw, unparsed time zone data for `"Asia/Ulaanbaatar"`RAW_ULAN_BATOR/// Raw, unparsed time zone data for `"Asia/Ulan_Bator"`RAW_URUMQI/// Raw, unparsed time zone data for `"Asia/Urumqi"`RAW_UST_NERA/// Raw, unparsed time zone data for `"Asia/Ust-Nera"`RAW_VIENTIANE/// Raw, unparsed time zone data for `"Asia/Vientiane"`RAW_VLADIVOSTOK/// Raw, unparsed time zone data for `"Asia/Vladivostok"`RAW_YAKUTSK/// Raw, unparsed time zone data for `"Asia/Yakutsk"`RAW_YANGON/// Raw, unparsed time zone data for `"Asia/Yangon"`RAW_YEKATERINBURG/// Raw, unparsed time zone data for `"Asia/Yekaterinburg"`RAW_YEREVAN/// Raw, unparsed time zone data for `"Asia/Yerevan"`asia/// AsiaAZORES/// Time zone data for `"Atlantic/Azores"`BERMUDA/// Time zone data for `"Atlantic/Bermuda"`CANARY/// Time zone data for `"Atlantic/Canary"`CAPE_VERDE/// Time zone data for `"Atlantic/Cape_Verde"`FAEROE/// Time zone data for `"Atlantic/Faeroe"`FAROE/// Time zone data for `"Atlantic/Faroe"`JAN_MAYEN/// Time zone data for `"Atlantic/Jan_Mayen"`MADEIRA/// Time zone data for `"Atlantic/Madeira"`REYKJAVIK/// Time zone data for `"Atlantic/Reykjavik"`SOUTH_GEORGIA/// Time zone data for `"Atlantic/South_Georgia"`STANLEY/// Time zone data for `"Atlantic/Stanley"`ST_HELENA/// Time zone data for `"Atlantic/St_Helena"`RAW_AZORES/// Raw, unparsed time zone data for `"Atlantic/Azores"`RAW_BERMUDA/// Raw, unparsed time zone data for `"Atlantic/Bermuda"`RAW_CANARY/// Raw, unparsed time zone data for `"Atlantic/Canary"`RAW_CAPE_VERDE/// Raw, unparsed time zone data for `"Atlantic/Cape_Verde"`RAW_FAEROE/// Raw, unparsed time zone data for `"Atlantic/Faeroe"`RAW_FAROE/// Raw, unparsed time zone data for `"Atlantic/Faroe"`RAW_JAN_MAYEN/// Raw, unparsed time zone data for `"Atlantic/Jan_Mayen"`RAW_MADEIRA/// Raw, unparsed time zone data for `"Atlantic/Madeira"`RAW_REYKJAVIK/// Raw, unparsed time zone data for `"Atlantic/Reykjavik"`RAW_SOUTH_GEORGIA/// Raw, unparsed time zone data for `"Atlantic/South_Georgia"`RAW_STANLEY/// Raw, unparsed time zone data for `"Atlantic/Stanley"`RAW_ST_HELENA/// Raw, unparsed time zone data for `"Atlantic/St_Helena"`atlantic/// AtlanticACT/// Time zone data for `"Australia/ACT"`ADELAIDE/// Time zone data for `"Australia/Adelaide"`BRISBANE/// Time zone data for `"Australia/Brisbane"`BROKEN_HILL/// Time zone data for `"Australia/Broken_Hill"`CANBERRA/// Time zone data for `"Australia/Canberra"`CURRIE/// Time zone data for `"Australia/Currie"`DARWIN/// Time zone data for `"Australia/Darwin"`EUCLA/// Time zone data for `"Australia/Eucla"`HOBART/// Time zone data for `"Australia/Hobart"`LHI/// Time zone data for `"Australia/LHI"`LINDEMAN/// Time zone data for `"Australia/Lindeman"`LORD_HOWE/// Time zone data for `"Australia/Lord_Howe"`MELBOURNE/// Time zone data for `"Australia/Melbourne"`NORTH/// Time zone data for `"Australia/North"`NSW/// Time zone data for `"Australia/NSW"`PERTH/// Time zone data for `"Australia/Perth"`QUEENSLAND/// Time zone data for `"Australia/Queensland"`SOUTH/// Time zone data for `"Australia/South"`SYDNEY/// Time zone data for `"Australia/Sydney"`TASMANIA/// Time zone data for `"Australia/Tasmania"`VICTORIA/// Time zone data for `"Australia/Victoria"`WEST/// Time zone data for `"Australia/West"`YANCOWINNA/// Time zone data for `"Australia/Yancowinna"`RAW_ACT/// Raw, unparsed time zone data for `"Australia/ACT"`RAW_ADELAIDE/// Raw, unparsed time zone data for `"Australia/Adelaide"`RAW_BRISBANE/// Raw, unparsed time zone data for `"Australia/Brisbane"`RAW_BROKEN_HILL/// Raw, unparsed time zone data for `"Australia/Broken_Hill"`RAW_CANBERRA/// Raw, unparsed time zone data for `"Australia/Canberra"`RAW_CURRIE/// Raw, unparsed time zone data for `"Australia/Currie"`RAW_DARWIN/// Raw, unparsed time zone data for `"Australia/Darwin"`RAW_EUCLA/// Raw, unparsed time zone data for `"Australia/Eucla"`RAW_HOBART/// Raw, unparsed time zone data for `"Australia/Hobart"`RAW_LHI/// Raw, unparsed time zone data for `"Australia/LHI"`RAW_LINDEMAN/// Raw, unparsed time zone data for `"Australia/Lindeman"`RAW_LORD_HOWE/// Raw, unparsed time zone data for `"Australia/Lord_Howe"`RAW_MELBOURNE/// Raw, unparsed time zone data for `"Australia/Melbourne"`RAW_NORTH/// Raw, unparsed time zone data for `"Australia/North"`RAW_NSW/// Raw, unparsed time zone data for `"Australia/NSW"`RAW_PERTH/// Raw, unparsed time zone data for `"Australia/Perth"`RAW_QUEENSLAND/// Raw, unparsed time zone data for `"Australia/Queensland"`RAW_SOUTH/// Raw, unparsed time zone data for `"Australia/South"`RAW_SYDNEY/// Raw, unparsed time zone data for `"Australia/Sydney"`RAW_TASMANIA/// Raw, unparsed time zone data for `"Australia/Tasmania"`RAW_VICTORIA/// Raw, unparsed time zone data for `"Australia/Victoria"`RAW_WEST/// Raw, unparsed time zone data for `"Australia/West"`RAW_YANCOWINNA/// Raw, unparsed time zone data for `"Australia/Yancowinna"`australia/// AustraliaACRE/// Time zone data for `"Brazil/Acre"`DE_NORONHA/// Time zone data for `"Brazil/DeNoronha"`EAST/// Time zone data for `"Brazil/East"`/// Time zone data for `"Brazil/West"`RAW_ACRE/// Raw, unparsed time zone data for `"Brazil/Acre"`RAW_DE_NORONHA/// Raw, unparsed time zone data for `"Brazil/DeNoronha"`RAW_EAST/// Raw, unparsed time zone data for `"Brazil/East"`/// Raw, unparsed time zone data for `"Brazil/West"`brazil/// BrazilATLANTIC/// Time zone data for `"Canada/Atlantic"`CENTRAL/// Time zone data for `"Canada/Central"`EASTERN/// Time zone data for `"Canada/Eastern"`MOUNTAIN/// Time zone data for `"Canada/Mountain"`NEWFOUNDLAND/// Time zone data for `"Canada/Newfoundland"`PACIFIC/// Time zone data for `"Canada/Pacific"`SASKATCHEWAN/// Time zone data for `"Canada/Saskatchewan"`YUKON/// Time zone data for `"Canada/Yukon"`RAW_ATLANTIC/// Raw, unparsed time zone data for `"Canada/Atlantic"`RAW_CENTRAL/// Raw, unparsed time zone data for `"Canada/Central"`RAW_EASTERN/// Raw, unparsed time zone data for `"Canada/Eastern"`RAW_MOUNTAIN/// Raw, unparsed time zone data for `"Canada/Mountain"`RAW_NEWFOUNDLAND/// Raw, unparsed time zone data for `"Canada/Newfoundland"`RAW_PACIFIC/// Raw, unparsed time zone data for `"Canada/Pacific"`RAW_SASKATCHEWAN/// Raw, unparsed time zone data for `"Canada/Saskatchewan"`RAW_YUKON/// Raw, unparsed time zone data for `"Canada/Yukon"`canadaCONTINENTAL/// Time zone data for `"Chile/Continental"`EASTER_ISLAND/// Time zone data for `"Chile/EasterIsland"`RAW_CONTINENTAL/// Raw, unparsed time zone data for `"Chile/Continental"`RAW_EASTER_ISLAND/// Raw, unparsed time zone data for `"Chile/EasterIsland"`chile/// Chile/// Time zone data for `"Etc/GMT"`GMT_0/// Time zone data for `"Etc/GMT0"`GMT_MINUS_0/// Time zone data for `"Etc/GMT-0"`GMT_MINUS_1/// Time zone data for `"Etc/GMT-1"`GMT_MINUS_10/// Time zone data for `"Etc/GMT-10"`GMT_MINUS_11/// Time zone data for `"Etc/GMT-11"`GMT_MINUS_12/// Time zone data for `"Etc/GMT-12"`GMT_MINUS_13/// Time zone data for `"Etc/GMT-13"`GMT_MINUS_14/// Time zone data for `"Etc/GMT-14"`GMT_MINUS_2/// Time zone data for `"Etc/GMT-2"`GMT_MINUS_3/// Time zone data for `"Etc/GMT-3"`GMT_MINUS_4/// Time zone data for `"Etc/GMT-4"`GMT_MINUS_5/// Time zone data for `"Etc/GMT-5"`GMT_MINUS_6/// Time zone data for `"Etc/GMT-6"`GMT_MINUS_7/// Time zone data for `"Etc/GMT-7"`GMT_MINUS_8/// Time zone data for `"Etc/GMT-8"`GMT_MINUS_9/// Time zone data for `"Etc/GMT-9"`GMT_PLUS_0/// Time zone data for `"Etc/GMT+0"`GMT_PLUS_1/// Time zone data for `"Etc/GMT+1"`GMT_PLUS_10/// Time zone data for `"Etc/GMT+10"`GMT_PLUS_11/// Time zone data for `"Etc/GMT+11"`GMT_PLUS_12/// Time zone data for `"Etc/GMT+12"`GMT_PLUS_2/// Time zone data for `"Etc/GMT+2"`GMT_PLUS_3/// Time zone data for `"Etc/GMT+3"`GMT_PLUS_4/// Time zone data for `"Etc/GMT+4"`GMT_PLUS_5/// Time zone data for `"Etc/GMT+5"`GMT_PLUS_6/// Time zone data for `"Etc/GMT+6"`GMT_PLUS_7/// Time zone data for `"Etc/GMT+7"`GMT_PLUS_8/// Time zone data for `"Etc/GMT+8"`GMT_PLUS_9/// Time zone data for `"Etc/GMT+9"`GREENWICH/// Time zone data for `"Etc/Greenwich"`/// Time zone data for `"Etc/UCT"`/// Time zone data for `"Etc/Universal"`/// Time zone data for `"Etc/UTC"`ZULU/// Time zone data for `"Etc/Zulu"`RAW_GMT/// Raw, unparsed time zone data for `"Etc/GMT"`RAW_GMT_0/// Raw, unparsed time zone data for `"Etc/GMT0"`RAW_GMT_MINUS_0/// Raw, unparsed time zone data for `"Etc/GMT-0"`RAW_GMT_MINUS_1/// Raw, unparsed time zone data for `"Etc/GMT-1"`RAW_GMT_MINUS_10/// Raw, unparsed time zone data for `"Etc/GMT-10"`RAW_GMT_MINUS_11/// Raw, unparsed time zone data for `"Etc/GMT-11"`RAW_GMT_MINUS_12/// Raw, unparsed time zone data for `"Etc/GMT-12"`RAW_GMT_MINUS_13/// Raw, unparsed time zone data for `"Etc/GMT-13"`RAW_GMT_MINUS_14/// Raw, unparsed time zone data for `"Etc/GMT-14"`RAW_GMT_MINUS_2/// Raw, unparsed time zone data for `"Etc/GMT-2"`RAW_GMT_MINUS_3/// Raw, unparsed time zone data for `"Etc/GMT-3"`RAW_GMT_MINUS_4/// Raw, unparsed time zone data for `"Etc/GMT-4"`RAW_GMT_MINUS_5/// Raw, unparsed time zone data for `"Etc/GMT-5"`RAW_GMT_MINUS_6/// Raw, unparsed time zone data for `"Etc/GMT-6"`RAW_GMT_MINUS_7/// Raw, unparsed time zone data for `"Etc/GMT-7"`RAW_GMT_MINUS_8/// Raw, unparsed time zone data for `"Etc/GMT-8"`RAW_GMT_MINUS_9/// Raw, unparsed time zone data for `"Etc/GMT-9"`RAW_GMT_PLUS_0/// Raw, unparsed time zone data for `"Etc/GMT+0"`RAW_GMT_PLUS_1/// Raw, unparsed time zone data for `"Etc/GMT+1"`RAW_GMT_PLUS_10/// Raw, unparsed time zone data for `"Etc/GMT+10"`RAW_GMT_PLUS_11/// Raw, unparsed time zone data for `"Etc/GMT+11"`RAW_GMT_PLUS_12/// Raw, unparsed time zone data for `"Etc/GMT+12"`RAW_GMT_PLUS_2/// Raw, unparsed time zone data for `"Etc/GMT+2"`RAW_GMT_PLUS_3/// Raw, unparsed time zone data for `"Etc/GMT+3"`RAW_GMT_PLUS_4/// Raw, unparsed time zone data for `"Etc/GMT+4"`RAW_GMT_PLUS_5/// Raw, unparsed time zone data for `"Etc/GMT+5"`RAW_GMT_PLUS_6/// Raw, unparsed time zone data for `"Etc/GMT+6"`RAW_GMT_PLUS_7/// Raw, unparsed time zone data for `"Etc/GMT+7"`RAW_GMT_PLUS_8/// Raw, unparsed time zone data for `"Etc/GMT+8"`RAW_GMT_PLUS_9/// Raw, unparsed time zone data for `"Etc/GMT+9"`RAW_GREENWICH/// Raw, unparsed time zone data for `"Etc/Greenwich"`RAW_UCT/// Raw, unparsed time zone data for `"Etc/UCT"`RAW_UNIVERSAL/// Raw, unparsed time zone data for `"Etc/Universal"`RAW_UTC/// Raw, unparsed time zone data for `"Etc/UTC"`RAW_ZULU/// Raw, unparsed time zone data for `"Etc/Zulu"`etc/// EtcAMSTERDAM/// Time zone data for `"Europe/Amsterdam"`ANDORRA/// Time zone data for `"Europe/Andorra"`ASTRAKHAN/// Time zone data for `"Europe/Astrakhan"`ATHENS/// Time zone data for `"Europe/Athens"`BELFAST/// Time zone data for `"Europe/Belfast"`BELGRADE/// Time zone data for `"Europe/Belgrade"`BERLIN/// Time zone data for `"Europe/Berlin"`BRATISLAVA/// Time zone data for `"Europe/Bratislava"`BRUSSELS/// Time zone data for `"Europe/Brussels"`BUCHAREST/// Time zone data for `"Europe/Bucharest"`BUDAPEST/// Time zone data for `"Europe/Budapest"`BUSINGEN/// Time zone data for `"Europe/Busingen"`CHISINAU/// Time zone data for `"Europe/Chisinau"`COPENHAGEN/// Time zone data for `"Europe/Copenhagen"`DUBLIN/// Time zone data for `"Europe/Dublin"`GIBRALTAR/// Time zone data for `"Europe/Gibraltar"`GUERNSEY/// Time zone data for `"Europe/Guernsey"`HELSINKI/// Time zone data for `"Europe/Helsinki"`ISLE_OF_MAN/// Time zone data for `"Europe/Isle_of_Man"`/// Time zone data for `"Europe/Istanbul"`JERSEY/// Time zone data for `"Europe/Jersey"`KALININGRAD/// Time zone data for `"Europe/Kaliningrad"`KIEV/// Time zone data for `"Europe/Kiev"`KIROV/// Time zone data for `"Europe/Kirov"`KYIV/// Time zone data for `"Europe/Kyiv"`LISBON/// Time zone data for `"Europe/Lisbon"`LJUBLJANA/// Time zone data for `"Europe/Ljubljana"`LONDON/// Time zone data for `"Europe/London"`LUXEMBOURG/// Time zone data for `"Europe/Luxembourg"`MADRID/// Time zone data for `"Europe/Madrid"`MALTA/// Time zone data for `"Europe/Malta"`MARIEHAMN/// Time zone data for `"Europe/Mariehamn"`MINSK/// Time zone data for `"Europe/Minsk"`MONACO/// Time zone data for `"Europe/Monaco"`MOSCOW/// Time zone data for `"Europe/Moscow"`/// Time zone data for `"Europe/Nicosia"`OSLO/// Time zone data for `"Europe/Oslo"`PARIS/// Time zone data for `"Europe/Paris"`PODGORICA/// Time zone data for `"Europe/Podgorica"`PRAGUE/// Time zone data for `"Europe/Prague"`RIGA/// Time zone data for `"Europe/Riga"`ROME/// Time zone data for `"Europe/Rome"`SAMARA/// Time zone data for `"Europe/Samara"`SAN_MARINO/// Time zone data for `"Europe/San_Marino"`SARAJEVO/// Time zone data for `"Europe/Sarajevo"`SARATOV/// Time zone data for `"Europe/Saratov"`SIMFEROPOL/// Time zone data for `"Europe/Simferopol"`SKOPJE/// Time zone data for `"Europe/Skopje"`SOFIA/// Time zone data for `"Europe/Sofia"`STOCKHOLM/// Time zone data for `"Europe/Stockholm"`TALLINN/// Time zone data for `"Europe/Tallinn"`TIRANE/// Time zone data for `"Europe/Tirane"`TIRASPOL/// Time zone data for `"Europe/Tiraspol"`ULYANOVSK/// Time zone data for `"Europe/Ulyanovsk"`UZHGOROD/// Time zone data for `"Europe/Uzhgorod"`VADUZ/// Time zone data for `"Europe/Vaduz"`VATICAN/// Time zone data for `"Europe/Vatican"`VIENNA/// Time zone data for `"Europe/Vienna"`VILNIUS/// Time zone data for `"Europe/Vilnius"`VOLGOGRAD/// Time zone data for `"Europe/Volgograd"`WARSAW/// Time zone data for `"Europe/Warsaw"`ZAGREB/// Time zone data for `"Europe/Zagreb"`ZAPOROZHYE/// Time zone data for `"Europe/Zaporozhye"`ZURICH/// Time zone data for `"Europe/Zurich"`RAW_AMSTERDAM/// Raw, unparsed time zone data for `"Europe/Amsterdam"`RAW_ANDORRA/// Raw, unparsed time zone data for `"Europe/Andorra"`RAW_ASTRAKHAN/// Raw, unparsed time zone data for `"Europe/Astrakhan"`RAW_ATHENS/// Raw, unparsed time zone data for `"Europe/Athens"`RAW_BELFAST/// Raw, unparsed time zone data for `"Europe/Belfast"`RAW_BELGRADE/// Raw, unparsed time zone data for `"Europe/Belgrade"`RAW_BERLIN/// Raw, unparsed time zone data for `"Europe/Berlin"`RAW_BRATISLAVA/// Raw, unparsed time zone data for `"Europe/Bratislava"`RAW_BRUSSELS/// Raw, unparsed time zone data for `"Europe/Brussels"`RAW_BUCHAREST/// Raw, unparsed time zone data for `"Europe/Bucharest"`RAW_BUDAPEST/// Raw, unparsed time zone data for `"Europe/Budapest"`RAW_BUSINGEN/// Raw, unparsed time zone data for `"Europe/Busingen"`RAW_CHISINAU/// Raw, unparsed time zone data for `"Europe/Chisinau"`RAW_COPENHAGEN/// Raw, unparsed time zone data for `"Europe/Copenhagen"`RAW_DUBLIN/// Raw, unparsed time zone data for `"Europe/Dublin"`RAW_GIBRALTAR/// Raw, unparsed time zone data for `"Europe/Gibraltar"`RAW_GUERNSEY/// Raw, unparsed time zone data for `"Europe/Guernsey"`RAW_HELSINKI/// Raw, unparsed time zone data for `"Europe/Helsinki"`RAW_ISLE_OF_MAN/// Raw, unparsed time zone data for `"Europe/Isle_of_Man"`/// Raw, unparsed time zone data for `"Europe/Istanbul"`RAW_JERSEY/// Raw, unparsed time zone data for `"Europe/Jersey"`RAW_KALININGRAD/// Raw, unparsed time zone data for `"Europe/Kaliningrad"`RAW_KIEV/// Raw, unparsed time zone data for `"Europe/Kiev"`RAW_KIROV/// Raw, unparsed time zone data for `"Europe/Kirov"`RAW_KYIV/// Raw, unparsed time zone data for `"Europe/Kyiv"`RAW_LISBON/// Raw, unparsed time zone data for `"Europe/Lisbon"`RAW_LJUBLJANA/// Raw, unparsed time zone data for `"Europe/Ljubljana"`RAW_LONDON/// Raw, unparsed time zone data for `"Europe/London"`RAW_LUXEMBOURG/// Raw, unparsed time zone data for `"Europe/Luxembourg"`RAW_MADRID/// Raw, unparsed time zone data for `"Europe/Madrid"`RAW_MALTA/// Raw, unparsed time zone data for `"Europe/Malta"`RAW_MARIEHAMN/// Raw, unparsed time zone data for `"Europe/Mariehamn"`RAW_MINSK/// Raw, unparsed time zone data for `"Europe/Minsk"`RAW_MONACO/// Raw, unparsed time zone data for `"Europe/Monaco"`RAW_MOSCOW/// Raw, unparsed time zone data for `"Europe/Moscow"`/// Raw, unparsed time zone data for `"Europe/Nicosia"`RAW_OSLO/// Raw, unparsed time zone data for `"Europe/Oslo"`RAW_PARIS/// Raw, unparsed time zone data for `"Europe/Paris"`RAW_PODGORICA/// Raw, unparsed time zone data for `"Europe/Podgorica"`RAW_PRAGUE/// Raw, unparsed time zone data for `"Europe/Prague"`RAW_RIGA/// Raw, unparsed time zone data for `"Europe/Riga"`RAW_ROME/// Raw, unparsed time zone data for `"Europe/Rome"`RAW_SAMARA/// Raw, unparsed time zone data for `"Europe/Samara"`RAW_SAN_MARINO/// Raw, unparsed time zone data for `"Europe/San_Marino"`RAW_SARAJEVO/// Raw, unparsed time zone data for `"Europe/Sarajevo"`RAW_SARATOV/// Raw, unparsed time zone data for `"Europe/Saratov"`RAW_SIMFEROPOL/// Raw, unparsed time zone data for `"Europe/Simferopol"`RAW_SKOPJE/// Raw, unparsed time zone data for `"Europe/Skopje"`RAW_SOFIA/// Raw, unparsed time zone data for `"Europe/Sofia"`RAW_STOCKHOLM/// Raw, unparsed time zone data for `"Europe/Stockholm"`RAW_TALLINN/// Raw, unparsed time zone data for `"Europe/Tallinn"`RAW_TIRANE/// Raw, unparsed time zone data for `"Europe/Tirane"`RAW_TIRASPOL/// Raw, unparsed time zone data for `"Europe/Tiraspol"`RAW_ULYANOVSK/// Raw, unparsed time zone data for `"Europe/Ulyanovsk"`RAW_UZHGOROD/// Raw, unparsed time zone data for `"Europe/Uzhgorod"`RAW_VADUZ/// Raw, unparsed time zone data for `"Europe/Vaduz"`RAW_VATICAN/// Raw, unparsed time zone data for `"Europe/Vatican"`RAW_VIENNA/// Raw, unparsed time zone data for `"Europe/Vienna"`RAW_VILNIUS/// Raw, unparsed time zone data for `"Europe/Vilnius"`RAW_VOLGOGRAD/// Raw, unparsed time zone data for `"Europe/Volgograd"`RAW_WARSAW/// Raw, unparsed time zone data for `"Europe/Warsaw"`RAW_ZAGREB/// Raw, unparsed time zone data for `"Europe/Zagreb"`RAW_ZAPOROZHYE/// Raw, unparsed time zone data for `"Europe/Zaporozhye"`RAW_ZURICH/// Raw, unparsed time zone data for `"Europe/Zurich"`europe/// EuropeANTANANARIVO/// Time zone data for `"Indian/Antananarivo"`CHAGOS/// Time zone data for `"Indian/Chagos"`CHRISTMAS/// Time zone data for `"Indian/Christmas"`COCOS/// Time zone data for `"Indian/Cocos"`COMORO/// Time zone data for `"Indian/Comoro"`KERGUELEN/// Time zone data for `"Indian/Kerguelen"`MAHE/// Time zone data for `"Indian/Mahe"`MALDIVES/// Time zone data for `"Indian/Maldives"`MAURITIUS/// Time zone data for `"Indian/Mauritius"`MAYOTTE/// Time zone data for `"Indian/Mayotte"`REUNION/// Time zone data for `"Indian/Reunion"`RAW_ANTANANARIVO/// Raw, unparsed time zone data for `"Indian/Antananarivo"`RAW_CHAGOS/// Raw, unparsed time zone data for `"Indian/Chagos"`RAW_CHRISTMAS/// Raw, unparsed time zone data for `"Indian/Christmas"`RAW_COCOS/// Raw, unparsed time zone data for `"Indian/Cocos"`RAW_COMORO/// Raw, unparsed time zone data for `"Indian/Comoro"`RAW_KERGUELEN/// Raw, unparsed time zone data for `"Indian/Kerguelen"`RAW_MAHE/// Raw, unparsed time zone data for `"Indian/Mahe"`RAW_MALDIVES/// Raw, unparsed time zone data for `"Indian/Maldives"`RAW_MAURITIUS/// Raw, unparsed time zone data for `"Indian/Mauritius"`RAW_MAYOTTE/// Raw, unparsed time zone data for `"Indian/Mayotte"`RAW_REUNION/// Raw, unparsed time zone data for `"Indian/Reunion"`indian/// IndianBAJA_NORTE/// Time zone data for `"Mexico/BajaNorte"`BAJA_SUR/// Time zone data for `"Mexico/BajaSur"`GENERAL/// Time zone data for `"Mexico/General"`RAW_BAJA_NORTE/// Raw, unparsed time zone data for `"Mexico/BajaNorte"`RAW_BAJA_SUR/// Raw, unparsed time zone data for `"Mexico/BajaSur"`RAW_GENERAL/// Raw, unparsed time zone data for `"Mexico/General"`mexico/// MexicoAPIA/// Time zone data for `"Pacific/Apia"`AUCKLAND/// Time zone data for `"Pacific/Auckland"`BOUGAINVILLE/// Time zone data for `"Pacific/Bougainville"`CHATHAM/// Time zone data for `"Pacific/Chatham"`CHUUK/// Time zone data for `"Pacific/Chuuk"`EASTER/// Time zone data for `"Pacific/Easter"`EFATE/// Time zone data for `"Pacific/Efate"`ENDERBURY/// Time zone data for `"Pacific/Enderbury"`FAKAOFO/// Time zone data for `"Pacific/Fakaofo"`FIJI/// Time zone data for `"Pacific/Fiji"`FUNAFUTI/// Time zone data for `"Pacific/Funafuti"`GALAPAGOS/// Time zone data for `"Pacific/Galapagos"`GAMBIER/// Time zone data for `"Pacific/Gambier"`GUADALCANAL/// Time zone data for `"Pacific/Guadalcanal"`GUAM/// Time zone data for `"Pacific/Guam"`HONOLULU/// Time zone data for `"Pacific/Honolulu"`JOHNSTON/// Time zone data for `"Pacific/Johnston"`KANTON/// Time zone data for `"Pacific/Kanton"`KIRITIMATI/// Time zone data for `"Pacific/Kiritimati"`KOSRAE/// Time zone data for `"Pacific/Kosrae"`/// Time zone data for `"Pacific/Kwajalein"`MAJURO/// Time zone data for `"Pacific/Majuro"`MARQUESAS/// Time zone data for `"Pacific/Marquesas"`MIDWAY/// Time zone data for `"Pacific/Midway"`NAURU/// Time zone data for `"Pacific/Nauru"`NIUE/// Time zone data for `"Pacific/Niue"`NORFOLK/// Time zone data for `"Pacific/Norfolk"`NOUMEA/// Time zone data for `"Pacific/Noumea"`PAGO_PAGO/// Time zone data for `"Pacific/Pago_Pago"`PALAU/// Time zone data for `"Pacific/Palau"`PITCAIRN/// Time zone data for `"Pacific/Pitcairn"`POHNPEI/// Time zone data for `"Pacific/Pohnpei"`PONAPE/// Time zone data for `"Pacific/Ponape"`PORT_MORESBY/// Time zone data for `"Pacific/Port_Moresby"`RAROTONGA/// Time zone data for `"Pacific/Rarotonga"`SAIPAN/// Time zone data for `"Pacific/Saipan"`SAMOA/// Time zone data for `"Pacific/Samoa"`TAHITI/// Time zone data for `"Pacific/Tahiti"`TARAWA/// Time zone data for `"Pacific/Tarawa"`TONGATAPU/// Time zone data for `"Pacific/Tongatapu"`TRUK/// Time zone data for `"Pacific/Truk"`WAKE/// Time zone data for `"Pacific/Wake"`WALLIS/// Time zone data for `"Pacific/Wallis"`YAP/// Time zone data for `"Pacific/Yap"`RAW_APIA/// Raw, unparsed time zone data for `"Pacific/Apia"`RAW_AUCKLAND/// Raw, unparsed time zone data for `"Pacific/Auckland"`RAW_BOUGAINVILLE/// Raw, unparsed time zone data for `"Pacific/Bougainville"`RAW_CHATHAM/// Raw, unparsed time zone data for `"Pacific/Chatham"`RAW_CHUUK/// Raw, unparsed time zone data for `"Pacific/Chuuk"`RAW_EASTER/// Raw, unparsed time zone data for `"Pacific/Easter"`RAW_EFATE/// Raw, unparsed time zone data for `"Pacific/Efate"`RAW_ENDERBURY/// Raw, unparsed time zone data for `"Pacific/Enderbury"`RAW_FAKAOFO/// Raw, unparsed time zone data for `"Pacific/Fakaofo"`RAW_FIJI/// Raw, unparsed time zone data for `"Pacific/Fiji"`RAW_FUNAFUTI/// Raw, unparsed time zone data for `"Pacific/Funafuti"`RAW_GALAPAGOS/// Raw, unparsed time zone data for `"Pacific/Galapagos"`RAW_GAMBIER/// Raw, unparsed time zone data for `"Pacific/Gambier"`RAW_GUADALCANAL/// Raw, unparsed time zone data for `"Pacific/Guadalcanal"`RAW_GUAM/// Raw, unparsed time zone data for `"Pacific/Guam"`RAW_HONOLULU/// Raw, unparsed time zone data for `"Pacific/Honolulu"`RAW_JOHNSTON/// Raw, unparsed time zone data for `"Pacific/Johnston"`RAW_KANTON/// Raw, unparsed time zone data for `"Pacific/Kanton"`RAW_KIRITIMATI/// Raw, unparsed time zone data for `"Pacific/Kiritimati"`RAW_KOSRAE/// Raw, unparsed time zone data for `"Pacific/Kosrae"`RAW_KWAJALEIN/// Raw, unparsed time zone data for `"Pacific/Kwajalein"`RAW_MAJURO/// Raw, unparsed time zone data for `"Pacific/Majuro"`RAW_MARQUESAS/// Raw, unparsed time zone data for `"Pacific/Marquesas"`RAW_MIDWAY/// Raw, unparsed time zone data for `"Pacific/Midway"`RAW_NAURU/// Raw, unparsed time zone data for `"Pacific/Nauru"`RAW_NIUE/// Raw, unparsed time zone data for `"Pacific/Niue"`RAW_NORFOLK/// Raw, unparsed time zone data for `"Pacific/Norfolk"`RAW_NOUMEA/// Raw, unparsed time zone data for `"Pacific/Noumea"`RAW_PAGO_PAGO/// Raw, unparsed time zone data for `"Pacific/Pago_Pago"`RAW_PALAU/// Raw, unparsed time zone data for `"Pacific/Palau"`RAW_PITCAIRN/// Raw, unparsed time zone data for `"Pacific/Pitcairn"`RAW_POHNPEI/// Raw, unparsed time zone data for `"Pacific/Pohnpei"`RAW_PONAPE/// Raw, unparsed time zone data for `"Pacific/Ponape"`RAW_PORT_MORESBY/// Raw, unparsed time zone data for `"Pacific/Port_Moresby"`RAW_RAROTONGA/// Raw, unparsed time zone data for `"Pacific/Rarotonga"`RAW_SAIPAN/// Raw, unparsed time zone data for `"Pacific/Saipan"`RAW_SAMOA/// Raw, unparsed time zone data for `"Pacific/Samoa"`RAW_TAHITI/// Raw, unparsed time zone data for `"Pacific/Tahiti"`RAW_TARAWA/// Raw, unparsed time zone data for `"Pacific/Tarawa"`RAW_TONGATAPU/// Raw, unparsed time zone data for `"Pacific/Tongatapu"`RAW_TRUK/// Raw, unparsed time zone data for `"Pacific/Truk"`RAW_WAKE/// Raw, unparsed time zone data for `"Pacific/Wake"`RAW_WALLIS/// Raw, unparsed time zone data for `"Pacific/Wallis"`RAW_YAP/// Raw, unparsed time zone data for `"Pacific/Yap"`pacific/// PacificALASKA/// Time zone data for `"US/Alaska"`ALEUTIAN/// Time zone data for `"US/Aleutian"`ARIZONA/// Time zone data for `"US/Arizona"`/// Time zone data for `"US/Central"`/// Time zone data for `"US/Eastern"`EAST_INDIANA/// Time zone data for `"US/East-Indiana"`HAWAII/// Time zone data for `"US/Hawaii"`INDIANA_STARKE/// Time zone data for `"US/Indiana-Starke"`MICHIGAN/// Time zone data for `"US/Michigan"`/// Time zone data for `"US/Mountain"`/// Time zone data for `"US/Pacific"`/// Time zone data for `"US/Samoa"`RAW_ALASKA/// Raw, unparsed time zone data for `"US/Alaska"`RAW_ALEUTIAN/// Raw, unparsed time zone data for `"US/Aleutian"`RAW_ARIZONA/// Raw, unparsed time zone data for `"US/Arizona"`/// Raw, unparsed time zone data for `"US/Central"`/// Raw, unparsed time zone data for `"US/Eastern"`RAW_EAST_INDIANA/// Raw, unparsed time zone data for `"US/East-Indiana"`RAW_HAWAII/// Raw, unparsed time zone data for `"US/Hawaii"`RAW_INDIANA_STARKE/// Raw, unparsed time zone data for `"US/Indiana-Starke"`RAW_MICHIGAN/// Raw, unparsed time zone data for `"US/Michigan"`/// Raw, unparsed time zone data for `"US/Mountain"`/// Raw, unparsed time zone data for `"US/Pacific"`/// Raw, unparsed time zone data for `"US/Samoa"`us/// US/// Time zone data for `"CET"`/// Time zone data for `"CST6CDT"`/// Time zone data for `"Cuba"`/// Time zone data for `"EET"`/// Time zone data for `"Egypt"`/// Time zone data for `"Eire"`/// Time zone data for `"EST"`/// Time zone data for `"EST5EDT"`/// Time zone data for `"Factory"`/// Time zone data for `"GB"`GB_EIRE/// Time zone data for `"GB-Eire"`/// Time zone data for `"GMT"`/// Time zone data for `"GMT0"`/// Time zone data for `"GMT-0"`/// Time zone data for `"GMT+0"`/// Time zone data for `"Greenwich"`/// Time zone data for `"Hongkong"`/// Time zone data for `"HST"`/// Time zone data for `"Iceland"`/// Time zone data for `"Iran"`/// Time zone data for `"Israel"`/// Time zone data for `"Jamaica"`/// Time zone data for `"Japan"`/// Time zone data for `"Kwajalein"`/// Time zone data for `"Libya"`/// Time zone data for `"MET"`/// Time zone data for `"MST"`/// Time zone data for `"MST7MDT"`/// Time zone data for `"Navajo"`/// Time zone data for `"NZ"`/// Time zone data for `"NZ-CHAT"`/// Time zone data for `"Poland"`/// Time zone data for `"Portugal"`/// Time zone data for `"PRC"`/// Time zone data for `"PST8PDT"`/// Time zone data for `"ROC"`/// Time zone data for `"ROK"`/// Time zone data for `"Singapore"`/// Time zone data for `"Turkey"`/// Time zone data for `"UCT"`/// Time zone data for `"Universal"`/// Time zone data for `"UTC"`/// Time zone data for `"WET"`/// Time zone data for `"W-SU"`/// Time zone data for `"Zulu"`RAW_CET/// Raw, unparsed time zone data for `"CET"`RAW_CST_6_CDT/// Raw, unparsed time zone data for `"CST6CDT"`RAW_CUBA/// Raw, unparsed time zone data for `"Cuba"`RAW_EET/// Raw, unparsed time zone data for `"EET"`RAW_EGYPT/// Raw, unparsed time zone data for `"Egypt"`RAW_EIRE/// Raw, unparsed time zone data for `"Eire"`RAW_EST/// Raw, unparsed time zone data for `"EST"`RAW_EST_5_EDT/// Raw, unparsed time zone data for `"EST5EDT"`RAW_FACTORY/// Raw, unparsed time zone data for `"Factory"`RAW_GB/// Raw, unparsed time zone data for `"GB"`RAW_GB_EIRE/// Raw, unparsed time zone data for `"GB-Eire"`/// Raw, unparsed time zone data for `"GMT"`/// Raw, unparsed time zone data for `"GMT0"`/// Raw, unparsed time zone data for `"GMT-0"`/// Raw, unparsed time zone data for `"GMT+0"`/// Raw, unparsed time zone data for `"Greenwich"`RAW_HONGKONG/// Raw, unparsed time zone data for `"Hongkong"`RAW_HST/// Raw, unparsed time zone data for `"HST"`RAW_ICELAND/// Raw, unparsed time zone data for `"Iceland"`RAW_IRAN/// Raw, unparsed time zone data for `"Iran"`RAW_ISRAEL/// Raw, unparsed time zone data for `"Israel"`/// Raw, unparsed time zone data for `"Jamaica"`RAW_JAPAN/// Raw, unparsed time zone data for `"Japan"`/// Raw, unparsed time zone data for `"Kwajalein"`RAW_LIBYA/// Raw, unparsed time zone data for `"Libya"`RAW_MET/// Raw, unparsed time zone data for `"MET"`RAW_MST/// Raw, unparsed time zone data for `"MST"`RAW_MST_7_MDT/// Raw, unparsed time zone data for `"MST7MDT"`RAW_NAVAJO/// Raw, unparsed time zone data for `"Navajo"`RAW_NZ/// Raw, unparsed time zone data for `"NZ"`RAW_NZ_CHAT/// Raw, unparsed time zone data for `"NZ-CHAT"`RAW_POLAND/// Raw, unparsed time zone data for `"Poland"`RAW_PORTUGAL/// Raw, unparsed time zone data for `"Portugal"`RAW_PRC/// Raw, unparsed time zone data for `"PRC"`RAW_PST_8_PDT/// Raw, unparsed time zone data for `"PST8PDT"`RAW_ROC/// Raw, unparsed time zone data for `"ROC"`RAW_ROK/// Raw, unparsed time zone data for `"ROK"`/// Raw, unparsed time zone data for `"Singapore"`RAW_TURKEY/// Raw, unparsed time zone data for `"Turkey"`/// Raw, unparsed time zone data for `"UCT"`/// Raw, unparsed time zone data for `"Universal"`/// Raw, unparsed time zone data for `"UTC"`RAW_WET/// Raw, unparsed time zone data for `"WET"`RAW_W_SU/// Raw, unparsed time zone data for `"W-SU"`/// Raw, unparsed time zone data for `"Zulu"`new_alternate_timenew_local_time_typenew_month_week_daynew_time_zone_refnew_transitionfind_tz/// Find a time zone by name, e.g. `b"Europe/Berlin"` (case-insensitive)///     &tzdb_data::time_zone::europe::BERLIN,///     tzdb_data::find_tz(b"Europe/Berlin").unwrap(),/// Find the raw, unparsed time zone data by name, e.g. `b"Europe/Berlin"` (case-insensitive)///     tzdb_data::time_zone::europe::RAW_BERLIN,///     tzdb_data::find_raw(b"Europe/Berlin").unwrap(),// This implementation allows for invalid equalities like `b'-' == b'\x7f'`, but that's OK.// The only troublesome characters are://     @ -> `//     [ -> {//     \ -> |//     ] -> }//     ^ -> ~//     _ -> DEL// None the these characters have a "false lower case" variant which can occur in the input.// This function is 40% faster than the variant in rust's core library, which is implemented// more strictly.// SPDX-License-Identifier: MIT-0//! # `tzdb_data` — Time Zone Database//! [![Crates.io](https://img.shields.io/crates/v/tzdb_data?logo=rust&style=for-the-badge)](https://crates.io/crates/tzdb_data)//! [![License: MIT-0](https://img.shields.io/badge/license-MIT--0-informational?logo=apache&style=for-the-badge)](https://github.com/Kijewski/tzdb/blob/v0.6.1/tzdb_data/LICENSE.md "License: MIT-0")//! Static, `#![no_std]` time zone information for tz-rs//! let time_zone = tzdb_data::time_zone::europe::KYIV;//! let time_zone = tzdb_data::find_tz(b"Europe/Berlin").unwrap();//! let time_zone = tzdb_data::find_tz(b"ArCtIc/LoNgYeArByEn").unwrap();UniCase/// Construct a new `Ascii`./// For Rust versions >= 1.31, this is a `const fn`.into_unicase/// Convert this into a [`UniCase`]./// Consume this `Ascii` and get the inner value.test_case_insensitivetest_case_cmptest_ascii_new_const/// Case Insensitive wrapper of strings./// Case Insensitive wrapper of Ascii strings./// Compare two string-like types for case-less equality, using unicode folding./// Equivalent to `UniCase::new(left) == UniCase::new(right)`./// Note: This will perform a scan for ASCII characters before doing the/// the comparison. See `UniCase` for more information.eq_ascii/// Compare two string-like types for case-less equality, ignoring ASCII case./// Equivalent to `Ascii::new(left) == Ascii::new(right)`./// Creates a new `UniCase`./// Note: This scans the text to determine if it is all ASCII or not.to_folded_case/// Returns a copy of this string where each character is mapped to its/// Unicode CaseFolding equivalent./// Unicode Case Folding is meant for string storage and matching, not for/// display./// Creates a new `UniCase`, skipping the ASCII check./// Creates a new `UniCase` which performs only ASCII case folding./// Return `true` if this instance will only perform ASCII case folding./// Unwraps the inner value held by this `UniCase`.into_impltest_copy_for_refstest_eq_asciitest_eq_unicodetest_eq_unicode_left_is_substringtest_from_implstest_into_implstest_unicase_unicode_const//! # UniCase//! UniCase provides a way of specifying strings that are case-insensitive.//! UniCase supports full [Unicode case//! folding](https://www.w3.org/International/wiki/Case_folding). It can also//! utilize faster ASCII case comparisons, if both strings are ASCII.//! Using the `UniCase::new()` constructor will check the string to see if it//! is all ASCII. When a `UniCase` is compared against another, if both are//! ASCII, it will use the faster comparison.//! There also exists the `Ascii` type in this crate, which will always assume//! to use the ASCII case comparisons, if the encoding is already known.//! use unicase::UniCase;//! let a = UniCase::new("Maße");//! let b = UniCase::new("MASSE");//! let c = UniCase::new("mase");//! assert_eq!(a, b);//! assert!(b != c);//! ## Ascii//! use unicase::Ascii;//! let a = Ascii::new("foobar");//! let b = Ascii::new("FoObAr");lookup_consistency// Generated by scripts/mapgen.py// 2024-10-18// internal mod so that the enum can be 'pub'// thanks privacy-checker :___(test_ascii_foldingtest_simple_case_foldingtest_full_case_foldingtest_to_folded_caseUNICODE_VERSIONbidi_class_tableBidiMatchedOpeningBracketBidiDataSourceHardcodedBidiData/// Hardcoded Bidi data that ships with the unicode-bidi crate./// This can be enabled with the default `hardcoded-data` Cargo feature./// Find the `BidiClass` of a single char.bidi_matched_opening_bracket/// If this character is a bracket according to BidiBrackets.txt,/// return the corresponding *normalized* *opening bracket* of the pair,/// and whether or not it itself is an opening bracket.is_rtlbsearch_range_value_tabletest_asciitest_bmptest_smptest_unassigned_planes// Copyright 2015 The Servo Project Developers. See the// COPYRIGHT file at the top-level directory of this distribution.//! Accessor for `Bidi_Class` property from Unicode Character Database (UCD)/// The [Unicode version](http://www.unicode.org/versions/) of dataALANBNENFSILRELRILRONSMPDIRLIRLO/// Represents values of the Unicode character property/// [`Bidi_Class`](http://www.unicode.org/reports/tr44/#Bidi_Class), also/// known as the *bidirectional character type*./// * <http://www.unicode.org/reports/tr9/#Bidirectional_Character_Types>/// * <http://www.unicode.org/reports/tr44/#Bidi_Class_Values>bidi_pairs_table// NOTE:// The following code was generated by "tools/generate.py". do not edit directlyopening/// The corresponding opening bracket in this bracket pair, normalized/// In case of opening brackets, this will be the bracket itself, except for when the bracket/// is not normalized, in which case it will be the normalized form./// Whether or not the requested bracket was an opening bracket. True for opening/// This is the return value of [`BidiDataSource::bidi_matched_opening_bracket()`]./// It represents the matching *normalized* opening bracket for a given bracket in a bracket pair,/// and whether or not that bracket is opening./// This effectively buckets brackets into equivalence classes keyed on the/// normalized opening bracket./// The default implementation will pull in a small amount of hardcoded data,/// regardless of the `hardcoded-data` feature. This is in part for convenience/// (since this data is small and changes less often), and in part so that this method can be/// added without needing a breaking version bump./// Override this method in your custom data source to prevent the use of hardcoded data./// This trait abstracts over a data source that is able to produce the Unicode Bidi class for a given/// charactervisual_runsLevelRun/// Find the level runs within a line and return them in visual order./// NOTE: This implementation is incomplete. The algorithm needs information about the text,/// including original `BidiClass` property of each character, to be able to perform correctly./// Please see [`BidiInfo::visual_runs()`](../struct.BidiInfo.html#method.visual_runs) for the/// improved implementation./// `line` is a range of bytes indices within `levels`./// <http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>//! This module holds deprecated assets only.char_dataTextSource/// Compute explicit embedding levels for one paragraph of text (X1-X8)./// `processing_classes[i]` must contain the `BidiClass` of the char at byte index `i`,/// for each char in `text`.OverrideStatus/// Entries in the directional status stack:RTLLTRDirectionalStatusStack//! 3.3.2 Explicit Levels and Directions//! <http://www.unicode.org/reports/tr9/#Explicit_Levels_and_Directions>ALM// == Implicit ==/// ARABIC LETTER MARKLRM/// LEFT-TO-RIGHT MARKRLM/// RIGHT-TO-LEFT MARK// == Explicit Isolates ==/// LEFT‑TO‑RIGHT ISOLATE/// RIGHT‑TO‑LEFT ISOLATE/// FIRST STRONG ISOLATE/// POP DIRECTIONAL ISOLATE// == Explicit Embeddings and Overrides ==/// LEFT-TO-RIGHT EMBEDDING/// RIGHT-TO-LEFT EMBEDDING/// POP DIRECTIONAL FORMATTING/// LEFT-TO-RIGHT OVERRIDE/// RIGHT-TO-LEFT OVERRIDE// Copyright 2017 The Servo Project Developers. See the//! Directional Formatting Characters//! <http://www.unicode.org/reports/tr9/#Directional_Formatting_Characters>not_removed_by_x9IsolatingRunSequenceresolve_weak/// 3.3.4 Resolving Weak Types/// <http://www.unicode.org/reports/tr9/#Resolving_Weak_Types>resolve_neutral/// 3.3.5 Resolving Neutral Types/// <http://www.unicode.org/reports/tr9/#Resolving_Neutral_Types>/// The text-relative index of the opening bracket./// The text-relative index of the closing bracket.start_run/// The index of the run (in the run sequence) that the opening bracket is in.end_run/// The index of the run (in the run sequence) that the closing bracket is in.BracketPairidentify_bracket_pairs/// 3.1.3 Identifying Bracket Pairs/// Returns all paired brackets in the source, as indices into the/// text source./// <https://www.unicode.org/reports/tr9/#BD16>resolve_levels/// 3.3.6 Resolving Implicit Levels/// Returns the maximum embedding level in the paragraph./// <http://www.unicode.org/reports/tr9/#Resolving_Implicit_Levels>is_NI/// Neutral or Isolate formatting character (B, S, WS, ON, FSI, LRI, RLI, PDI)/// <http://www.unicode.org/reports/tr9/#NI>//! 3.3.4 - 3.3.6. Resolve implicit levels and types./// Embedding Level/// Embedding Levels are numbers between 0 and 126 (inclusive), where even values denote a/// left-to-right (LTR) direction and odd values a right-to-left (RTL) direction./// This struct maintains a *valid* status for level numbers, meaning that creating a new level, or/// mutating an existing level, with the value smaller than `0` (before conversion to `u8`) or/// larger than 125 results in an `Error`./// <http://www.unicode.org/reports/tr9/#BD2>LTR_LEVELRTL_LEVELMAX_EXPLICIT_DEPTH/// During explicit level resolution, embedding level can go as high as `max_depth`.MAX_IMPLICIT_DEPTH/// During implicit level resolution, embedding level can go as high as `max_depth + 1`.OutOfRangeNumber/// Out-of-range (invalid) embedding level number./// Errors that can occur on Level creation or mutationltr/// New LTR level with smallest number value (0)./// New RTL level with smallest number value (1).max_implicit_depth/// Maximum depth of the directional status stack during implicit resolutions.max_explicit_depth/// Maximum depth of the directional status stack during explicit resolutions./// Create new level, fail if number is larger than `max_depth + 1`./// Create new level, fail if number is larger than `max_depth`./// The level number.is_ltr/// If this level is left-to-right./// If this level is right-to-left./// Raise level by `amount`, fail if number is larger than `max_depth + 1`.raise_explicit/// Raise level by `amount`, fail if number is larger than `max_depth`./// Lower level by `amount`, fail if number goes below zero.new_explicit_next_ltr/// The next LTR (even) level greater than this, or fail if number is larger than `max_depth`.new_explicit_next_rtl/// The next RTL (odd) level greater than this, or fail if number is larger than `max_depth`.new_lowest_ge_rtl/// The lowest RTL (odd) level greater than or equal to this, or fail if number is larger than/// `max_depth + 1`./// Generate a character type based on a level (as specified in steps X10 and N2)./// Converts a byte slice to a slice of Levels/// Does _not_ check if each level is within bounds (`<=` [`MAX_IMPLICIT_DEPTH`]),/// which is not a requirement for safety but is a requirement for correctness of the algorithm.// == Inquiries ==// == Mutators ==// == Helpers ==has_rtl/// If levels has any RTL (odd) level/// This information is usually used to skip re-ordering of text when no RTL level is present/// Convert to the level number/// Create level by number/// Used for matching levels in conformance teststest_new_explicittest_is_ltrtest_is_rtltest_raisetest_raise_explicittest_lowertest_has_rtltest_str_eqtest_string_eq//! Bidi Embedding Level//! See [`Level`](struct.Level.html) for more details.//! <http://www.unicode.org/reports/tr9/#BD2>// We need to link to std to make doc tests work on older Rust versionsformat_charsCharIterCharIndexIterIndexLenIter/// Return the length of the text in code units./// Get the character at a given code unit index, along with its length in code units./// Returns None if index is out of range, or points inside a multi-code-unit character./// Returns REPLACEMENT_CHARACTER for any unpaired surrogates in UTF-16./// Return a subrange of the text, indexed by code units./// (We don't implement all of the Index trait, just the minimum we use.)/// An iterator over the text returning Unicode characters,/// REPLACEMENT_CHAR for invalid code units./// An iterator over the text returning (index, char) tuples,/// where index is the starting code-unit index of the character,/// and char is its Unicode value (or REPLACEMENT_CHAR if invalid).indices_lengths/// An iterator over the text returning (index, length) tuples,/// and length is its length in code units.char_len/// Number of code units the given character uses./// Trait that abstracts over a text source for use by the bidi algorithms./// We implement this for str (UTF-8) and for [u16] (UTF-16, native-endian)./// (For internal unicode-bidi use; API may be unstable.)// Implement for str and [u16] only./// The paragraphs boundaries within the text, as byte indices./// TODO: Shrink this to only include the starting index?/// The paragraph embedding level./// <http://www.unicode.org/reports/tr9/#BD4>ParagraphInfo/// Bidi information about a single paragraph/// Gets the length of the paragraph in the source text./// The textoriginal_classes/// The BidiClass of the character at each byte in the text./// If a character is multiple bytes, its class will appear multiple times in the vector.paragraphs/// The boundaries and level of each paragraph within the text.InitialInfo/// Initial bidi information of the text./// Contains the text paragraphs and `BidiClass` of its characters./// Find the paragraphs and BidiClasses in a string of text./// <http://www.unicode.org/reports/tr9/#The_Paragraph_Level>/// Also sets the class for each First Strong Isolate initiator (FSI) to LRI or RLI if a strong/// character is found before the matching PDI.  If no strong character is found, the class will/// remain FSI, and it's up to later stages to treat these as LRI when needed./// The `hardcoded-data` Cargo feature (enabled by default) must be enabled to use this.new_with_data_source/// Find the paragraphs and BidiClasses in a string of text, with a custom [`BidiDataSource`]/// for Bidi data. If you just wish to use the hardcoded Bidi data, please use [`InitialInfo::new()`]/// instead (enabled with tbe default `hardcoded-data` Cargo feature)/// The base InitialInfo for the text, recording its paragraphs and bidi classes.pure_ltr/// Parallel to base.paragraphs, records whether each paragraph is "pure LTR" that/// requires no further bidi processing (i.e. there are no RTL characters or bidi/// control codes present).InitialInfoExt/// Extended version of InitialInfo (not public API).compute_initial_info/// Implementation of initial-info computation for both BidiInfo and ParagraphBidiInfo./// To treat the text as (potentially) multiple paragraphs, the caller should pass the/// pair of optional outparam arrays to receive the ParagraphInfo and pure-ltr flags/// for each paragraph. Passing None for split_paragraphs will ignore any paragraph-/// separator characters in the text, treating it just as a single paragraph./// Returns the array of BidiClass values for each code unit of the text, along with/// the embedding level and pure-ltr flag for the *last* (or only) paragraph./// The directional embedding level of each byte in the text./// The boundaries and paragraph embedding level of each paragraph within the text./// TODO: Use SmallVec or similar to avoid overhead when there are only one or two paragraphs?/// Or just don't include the first paragraph, which always starts at 0?BidiInfo/// Bidi information of the text./// The `original_classes` and `levels` vectors are indexed by byte offsets into the text.  If a/// character is multiple bytes wide, then its class and level will appear multiple times in these/// vectors.// TODO: Impl `struct StringProperty<T> { values: Vec<T> }` and use instead of Vec<T>/// Split the text into paragraphs and determine the bidi embedding levels for each paragraph./// TODO: In early steps, check for special cases that allow later steps to be skipped. like/// text that is entirely LTR.  See the `nsBidi` class from Gecko for comparison./// TODO: Support auto-RTL base direction/// Split the text into paragraphs and determine the bidi embedding levels for each paragraph, with a custom [`BidiDataSource`]/// for Bidi data. If you just wish to use the hardcoded Bidi data, please use [`BidiInfo::new()`]/// instead (enabled with tbe default `hardcoded-data` Cargo feature).reordered_levels/// Produce the levels for this paragraph as needed for reordering, one level per *byte*/// in the paragraph. The returned vector includes bytes that are not included/// in the `line`, but will not adjust them./// This runs [Rule L1], you can run/// [Rule L2] by calling [`Self::reorder_visual()`]./// If doing so, you may prefer to use [`Self::reordered_levels_per_char()`] instead/// to avoid non-byte indices./// For an all-in-one reordering solution, consider using [`Self::reorder_visual()`]./// [Rule L1]: https://www.unicode.org/reports/tr9/#L1/// [Rule L2]: https://www.unicode.org/reports/tr9/#L2reordered_levels_per_char/// Produce the levels for this paragraph as needed for reordering, one level per *character*/// in the paragraph. The returned vector includes characters that are not includedreorder_line/// Re-order a line based on resolved levels and return the line in display order./// This does not apply [Rule L3] or [Rule L4] around combining characters or mirroring./// [Rule L3]: https://www.unicode.org/reports/tr9/#L3/// [Rule L4]: https://www.unicode.org/reports/tr9/#L4reorder_visual/// Reorders pre-calculated levels of a sequence of characters./// NOTE: This is a convenience method that does not use a `Paragraph`  object. It is/// intended to be used when an application has determined the levels of the objects (character sequences)/// and just needs to have them reordered./// the index map will result in `indexMap[visualIndex]==logicalIndex`./// This only runs [Rule L2](http://www.unicode.org/reports/tr9/#L2) as it does not have/// information about the actual text./// Furthermore, if `levels` is an array that is aligned with code units, bytes within a codepoint may be/// reversed. You may need to fix up the map to deal with this. Alternatively, only pass in arrays where each `Level`/// is for a single code point.///   # # Example/// use unicode_bidi::BidiInfo;/// use unicode_bidi::Level;/// let l0 = Level::from(0);/// let l1 = Level::from(1);/// let l2 = Level::from(2);/// let levels = vec![l0, l0, l0, l0];/// let index_map = BidiInfo::reorder_visual(&levels);/// assert_eq!(levels.len(), index_map.len());/// assert_eq!(index_map, [0, 1, 2, 3]);/// let levels: Vec<Level> = vec![l0, l0, l0, l1, l1, l1, l2, l2];/// assert_eq!(index_map, [0, 1, 2, 6, 7, 5, 4, 3]);/// The first return value is a vector of levels used by the reordering algorithm,/// i.e. the result of [Rule L1]. The second return value is a vector of level runs,/// the result of [Rule L2], showing the visual order that each level run (a run of text with the/// same level) should be displayed. Within each run, the display order can be checked/// against the Level vector./// This does not handle [Rule L3] (combining characters) or [Rule L4] (mirroring),/// as that should be handled by the engine using this API./// Conceptually, this is the same as running [`Self::reordered_levels()`] followed by/// [`Self::reorder_visual()`], however it returns the result as a list of level runs instead/// of producing a level map, since one may wish to deal with the fact that this is operating on/// byte rather than character indices./// If processed text has any computed RTL levelsparagraph_levelis_pure_ltr/// Whether the paragraph is purely LTR.ParagraphBidiInfo/// Bidi information of text treated as a single paragraph./// Determine the bidi embedding level./// Determine the bidi embedding level, with a custom [`BidiDataSource`]/// (This is the single-paragraph equivalent of BidiInfo::new_with_data_source,/// and should be kept in sync with it./// See BidiInfo::reordered_levels for details./// (This should be kept in sync with BidiInfo::reordered_levels.)/// See BidiInfo::reordered_levels_per_char for details./// (This should be kept in sync with BidiInfo::reordered_levels_per_char.)/// See BidiInfo::reorder_line for details./// (This should be kept in sync with BidiInfo::reorder_line.)/// See BidiInfo::reorder_visual for details./// See BidiInfo::visual_runs for details./// (This should be kept in sync with BidiInfo::visual_runs.)/// Return the paragraph's Direction (Ltr, Rtl, or Mixed) based on its levels./// Return a line of the text in display order based on resolved levels./// `text`   the full text passed to the `BidiInfo` or `ParagraphBidiInfo` for analysis/// `line`   a range of byte indices within `text` corresponding to one line/// `levels` array of `Level` values, with `line`'s levels reordered into visual order/// `runs`   array of `LevelRun`s in visual order/// (`levels` and `runs` are the result of calling `BidiInfo::visual_runs()` or/// `ParagraphBidiInfo::visual_runs()` for the line of interest.)/// Returns: the reordered text of the line.visual_runs_for_line/// `line` is a range of code-unit indices within `levels`./// Conceptually, this is the same as running [`reordered_levels()`] followed by/// [`reorder_visual()`], however it returns the result as a list of level runs insteadcompute_bidi_info_for_para/// The core of BidiInfo initialization, factored out into a function that both/// the utf-8 and utf-16 versions of BidiInfo can use.reorder_levels/// Produce the levels for this paragraph as needed for reordering, one level per *code unit*/// in the paragraph. The returned vector includes code units that are not included/// This runs [Rule L1]para/// Contains a reference of `BidiInfo` and one of its `paragraphs`./// And it supports all operation in the `Paragraph` that needs also its/// `BidiInfo` such as `direction`./// Returns if the paragraph is Left direction, right direction or mixed.level_at/// Returns the `Level` of a certain character in the paragraph.para_direction/// Return the directionality of the paragraph (Left, Right or Mixed) from its levels.assign_levels_to_removed_chars/// Assign levels to characters removed by rule X9./// The levels assigned to these characters are not specified by the algorithm.  This function/// assigns each one the level of the previous character, to avoid breaking level runs.get_base_direction/// Get the base direction of the text provided according to the Unicode Bidirectional Algorithm./// See rules P2 and P3./// The base direction is derived from the first character in the string with bidi character type/// L, R, or AL. If the first such character has type L, Direction::Ltr is returned. If the first/// such character has type R or AL, Direction::Rtl is returned./// If the string does not contain any character of these types (outside of embedded isolate runs),/// then Direction::Mixed is returned (but should be considered as meaning "neutral" or "unknown",/// not in fact mixed directions)./// This is a lightweight function for use when only the base direction is needed and no further/// bidi processing of the text is needed./// If the text contains paragraph separators, this function considers only the first paragraph.get_base_direction_full/// Get the base direction of the text provided according to the Unicode Bidirectional Algorithm,/// considering the full text if the first paragraph is all-neutral./// This is the same as get_base_direction except that it does not stop at the first block/// separator, but just resets the embedding level and continues to look for a strongly-/// directional character. So the result will be the base direction of the first paragraph/// that is not purely neutral characters.get_base_direction_with_data_sourceget_base_direction_full_with_data_sourceget_base_direction_implUtf8IndexLenIter/// Implementation of TextSource for UTF-8 text (a string slice)./// Iterator over (UTF-8) string slices returning (index, char_len) tuple.BidiInfoU16InitialInfoU16ParagraphU16ParagraphBidiInfoU16test_utf16_text_sourcetest_utf16_char_itertest_initial_text_infotest_process_texttest_paragraph_bidi_infotest_bidi_info_has_rtlreorder_parasreorder_paras_u16test_reorder_linereordered_levels_for_parasreordered_levels_per_char_for_parasreordered_levels_for_paras_u16reordered_levels_per_char_for_paras_u16test_reordered_levelstest_paragraph_info_lentest_directiontest_edge_cases_directiontest_level_attest_get_base_directiontest_get_base_direction_full//! This crate implements the [Unicode Bidirectional Algorithm][tr9] for display of mixed//! right-to-left and left-to-right text.  It is written in safe Rust, compatible with the//! current stable release.//! # #[cfg(feature = "hardcoded-data")] {//! use unicode_bidi::BidiInfo;//! // This example text is defined using `concat!` because some browsers//! // and text editors have trouble displaying bidi strings.//! let text = concat![//!   "א",//!   "ב",//!   "ג",//!   "a",//!   "b",//!   "c",//! // Resolve embedding levels within the text.  Pass `None` to detect the//! // paragraph level automatically.//! let bidi_info = BidiInfo::new(&text, None);//! // This paragraph has embedding level 1 because its first strong character is RTL.//! assert_eq!(bidi_info.paragraphs.len(), 1);//! let para = &bidi_info.paragraphs[0];//! assert_eq!(para.level.number(), 1);//! assert_eq!(para.level.is_rtl(), true);//! // Re-ordering is done after wrapping each paragraph into a sequence of//! // lines. For this example, I'll just use a single line that spans the//! // entire paragraph.//! let line = para.range.clone();//! let display = bidi_info.reorder_line(para, line);//! assert_eq!(display, concat![//! # } // feature = "hardcoded-data"//! - `std`: Enabled by default, but can be disabled to make `unicode_bidi`//!   `#![no_std]` + `alloc` compatible.//! - `hardcoded-data`: Enabled by default. Includes hardcoded Unicode bidi data and more convenient APIs.//! - `serde`: Adds [`serde::Serialize`] and [`serde::Deserialize`]//!   implementations to relevant types.//! [tr9]: <http://www.unicode.org/reports/tr9/>/// A maximal substring of characters with the same embedding level./// Represented as a range of byte indices.sos// Start-of-sequence type.// End-of-sequence type./// Output of `isolating_run_sequences` (steps X9-X10)isolating_run_sequences/// Compute the set of isolating run sequences./// An isolating run sequence is a maximal sequence of level runs such that for all level runs/// except the last one in the sequence, the last character of the run is an isolate initiator/// whose matching PDI is the first character of the next level run in the sequence./// Note: This function does *not* return the sequences in order by their first characters.iter_forwards_from/// Given a text-relative position `pos` and an index of the level run it is in,/// produce an iterator of all characters after and pos (`pos..`) that are in this/// run sequenceiter_backwards_from/// produce an iterator of all characters before and excludingpos (`..pos`) that are in thislevel_runs/// Finds the level runs in a paragraph./// <http://www.unicode.org/reports/tr9/#BD7>removed_by_x9/// Should this character be ignored in steps after X9?/// <http://www.unicode.org/reports/tr9/#X9>// For use as a predicate for `position` / `rposition`test_level_runstest_isolating_run_sequences// From <http://www.unicode.org/reports/tr9/#BD13>test_isolating_run_sequences_sos_and_eos// From <http://www.unicode.org/reports/tr9/#X10>test_removed_by_x9test_not_removed_by_x9//! 3.3.3 Preparations for Implicit Processing//! <http://www.unicode.org/reports/tr9/#Preparations_for_Implicit_Processing>/// The BidiClass of the character at each code unit in the text./// If a character is multiple code units, its class will appear multiple times in the vector./// Initial bidi information of the text (UTF-16 version)./// Bidi information of the text (UTF-16 version)./// The `original_classes` and `levels` vectors are indexed by code unit offsets into the text.  If a/// character is multiple code units wide, then its class and level will appear multiple times in these/// See `BidiInfo::visual_runs` for details.is_high_surrogate/// Implementation of TextSource for UTF-16 text in a [u16] array./// Note that there could be unpaired surrogates present!// Convenience functions to check whether a UTF16 code unit is a surrogate.is_low_surrogateUtf16CharIterUtf16CharIndexIterUtf16IndexLenItercur_pos/// Iterator over UTF-16 text in a [u16] slice, returning (index, char_len) tuple./// Iterator over UTF-16 text in a [u16] slice, returning (index, char) tuple.end_pos/// Iterator over UTF-16 text in a [u16] slice, returning Unicode chars./// (Unlike the other iterators above, this also supports reverse iteration.)// Copyright 2023 The Mozilla Foundation. See theASCII_CONTINUEASCII_STARTCHUNKLEAFTRIE_CONTINUETRIE_STARTis_xid_startis_xid_continue//! [![github]](https://github.com/dtolnay/unicode-ident)&ensp;[![crates-io]](https://crates.io/crates/unicode-ident)&ensp;[![docs-rs]](https://docs.rs/unicode-ident)//! Implementation of [Unicode Standard Annex #31][tr31] for determining which//! `char` values are valid in programming language identifiers.//! [tr31]: https://www.unicode.org/reports/tr31///! This crate is a better optimized implementation of the older `unicode-xid`//! crate. This crate uses less static storage, and is able to classify both//! ASCII and non-ASCII codepoints with better performance, 2&ndash;10&times;//! faster than `unicode-xid`.//! ## Comparison of performance//! The following table shows a comparison between five Unicode identifier//! - `unicode-ident` is this crate;//! - [`unicode-xid`] is a widely used crate run by the "unicode-rs" org;//! - `ucd-trie` and `fst` are two data structures supported by the//!   [`ucd-generate`] tool;//! - [`roaring`] is a Rust implementation of Roaring bitmap.//! The *static storage* column shows the total size of `static` tables that the//! crate bakes into your binary, measured in 1000s of bytes.//! The remaining columns show the **cost per call** to evaluate whether a//! single `char` has the XID\_Start or XID\_Continue Unicode property,//! comparing across different ratios of ASCII to non-ASCII codepoints in the//! input data.//! [`unicode-xid`]: https://github.com/unicode-rs/unicode-xid//! [`ucd-generate`]: https://github.com/BurntSushi/ucd-generate//! [`roaring`]: https://github.com/RoaringBitmap/roaring-rs//! | | static storage | 0% nonascii | 1% | 10% | 100% nonascii |//! |---|---|---|---|---|---|//! | **`unicode-ident`** | 10.1 K | 0.96 ns | 0.95 ns | 1.09 ns | 1.55 ns |//! | **`unicode-xid`** | 11.5 K | 1.88 ns | 2.14 ns | 3.48 ns | 15.63 ns |//! | **`ucd-trie`** | 10.2 K | 1.29 ns | 1.28 ns | 1.36 ns | 2.15 ns |//! | **`fst`** | 139 K | 55.1 ns | 54.9 ns | 53.2 ns | 28.5 ns |//! | **`roaring`** | 66.1 K | 2.78 ns | 3.09 ns | 3.37 ns | 4.70 ns |//! Source code for the benchmark is provided in the *bench* directory of this//! repo and may be repeated by running `cargo criterion`.//! ## Comparison of data structures//! #### unicode-xid//! They use a sorted array of character ranges, and do a binary search to look//! up whether a given character lands inside one of those ranges.//! static XID_Continue_table: [(char, char); 763] = [//!     ('\u{30}', '\u{39}'),  // 0-9//!     ('\u{41}', '\u{5a}'),  // A-Z//! # "//!     …//!     ('\u{e0100}', '\u{e01ef}'),//! The static storage used by this data structure scales with the number of//! contiguous ranges of identifier codepoints in Unicode. Every table entry//! consumes 8 bytes, because it consists of a pair of 32-bit `char` values.//! In some ranges of the Unicode codepoint space, this is quite a sparse//! representation &ndash; there are some ranges where tens of thousands of//! adjacent codepoints are all valid identifier characters. In other places,//! the representation is quite inefficient. A characater like `µ` (U+00B5)//! which is surrounded by non-identifier codepoints consumes 64 bits in the//! table, while it would be just 1 bit in a dense bitmap.//! On a system with 64-byte cache lines, binary searching the table touches 7//! cache lines on average. Each cache line fits only 8 table entries.//! Additionally, the branching performed during the binary search is probably//! mostly unpredictable to the branch predictor.//! Overall, the crate ends up being about 10&times; slower on non-ASCII input//! compared to the fastest crate.//! A potential improvement would be to pack the table entries more compactly.//! Rust's `char` type is a 21-bit integer padded to 32 bits, which means every//! table entry is holding 22 bits of wasted space, adding up to 3.9 K. They//! could instead fit every table entry into 6 bytes, leaving out some of the//! padding, for a 25% improvement in space used. With some cleverness it may be//! possible to fit in 5 bytes or even 4 bytes by storing a low char and an//! extent, instead of low char and high char. I don't expect that performance//! would improve much but this could be the most efficient for space across all//! the libraries, needing only about 7 K to store.//! #### ucd-trie//! Their data structure is a compressed trie set specifically tailored for//! Unicode codepoints. The design is credited to Raph Levien in//! [rust-lang/rust#33098].//! [rust-lang/rust#33098]: https://github.com/rust-lang/rust/pull/33098//! pub struct TrieSet {//!     tree1_level1: &'static [u64; 32],//!     tree2_level1: &'static [u8; 992],//!     tree2_level2: &'static [u64],//!     tree3_level1: &'static [u8; 256],//!     tree3_level2: &'static [u8],//!     tree3_level3: &'static [u64],//! It represents codepoint sets using a trie to achieve prefix compression. The//! final states of the trie are embedded in leaves or "chunks", where each//! chunk is a 64-bit integer. Each bit position of the integer corresponds to//! whether a particular codepoint is in the set or not. These chunks are not//! just a compact representation of the final states of the trie, but are also//! a form of suffix compression. In particular, if multiple ranges of 64//! contiguous codepoints have the same Unicode properties, then they all map to//! the same chunk in the final level of the trie.//! Being tailored for Unicode codepoints, this trie is partitioned into three//! disjoint sets: tree1, tree2, tree3. The first set corresponds to codepoints//! \[0, 0x800), the second \[0x800, 0x10000) and the third \[0x10000,//! 0x110000). These partitions conveniently correspond to the space of 1 or 2//! byte UTF-8 encoded codepoints, 3 byte UTF-8 encoded codepoints and 4 byte//! UTF-8 encoded codepoints, respectively.//! Lookups in this data structure are significantly more efficient than binary//! search. A lookup touches either 1, 2, or 3 cache lines based on which of the//! trie partitions is being accessed.//! One possible performance improvement would be for this crate to expose a way//! to query based on a UTF-8 encoded string, returning the Unicode property//! corresponding to the first character in the string. Without such an API, the//! caller is required to tokenize their UTF-8 encoded input data into `char`,//! hand the `char` into `ucd-trie`, only for `ucd-trie` to undo that work by//! converting back into the variable-length representation for trie traversal.//! #### fst//! Uses a [finite state transducer][fst]. This representation is built into//! [ucd-generate] but I am not aware of any advantage over the `ucd-trie`//! representation. In particular `ucd-trie` is optimized for storing Unicode//! properties while `fst` is not.//! [fst]: https://github.com/BurntSushi/fst//! [ucd-generate]: https://github.com/BurntSushi/ucd-generate//! As far as I can tell, the main thing that causes `fst` to have large size//! and slow lookups for this use case relative to `ucd-trie` is that it does//! not specialize for the fact that only 21 of the 32 bits in a `char` are//! meaningful. There are some dense arrays in the structure with large ranges//! that could never possibly be used.//! #### roaring//! This crate is a pure-Rust implementation of [Roaring Bitmap], a data//! structure designed for storing sets of 32-bit unsigned integers.//! [Roaring Bitmap]: https://roaringbitmap.org/about///! Roaring bitmaps are compressed bitmaps which tend to outperform conventional//! compressed bitmaps such as WAH, EWAH or Concise. In some instances, they can//! be hundreds of times faster and they often offer significantly better//! compression.//! In this use case the performance was reasonably competitive but still//! substantially slower than the Unicode-optimized crates. Meanwhile the//! compression was significantly worse, requiring 6&times; as much storage for//! the data structure.//! I also benchmarked the [`croaring`] crate which is an FFI wrapper around the//! C reference implementation of Roaring Bitmap. This crate was consistently//! about 15% slower than pure-Rust `roaring`, which could just be FFI overhead.//! I did not investigate further.//! [`croaring`]: https://crates.io/crates/croaring//! #### unicode-ident//! This crate is most similar to the `ucd-trie` library, in that it's based on//! bitmaps stored in the leafs of a trie representation, achieving both prefix//! compression and suffix compression.//! The key differences are://! - Uses a single 2-level trie, rather than 3 disjoint partitions of different//!   depth each.//! - Uses significantly larger chunks: 512 bits rather than 64 bits.//! - Compresses the XID\_Start and XID\_Continue properties together//!   simultaneously, rather than duplicating identical trie leaf chunks across//!   the two.//! The following diagram show the XID\_Start and XID\_Continue Unicode boolean//! properties in uncompressed form, in row-major order://! <tr><th>XID_Start</th><th>XID_Continue</th></tr>//! <tr>//! <td><img alt="XID_Start bitmap" width="256" src="https://user-images.githubusercontent.com/1940490/168647353-c6eeb922-afec-49b2-9ef5-c03e9d1e0760.png"></td>//! <td><img alt="XID_Continue bitmap" width="256" src="https://user-images.githubusercontent.com/1940490/168647367-f447cca7-2362-4d7d-8cd7-d21c011d329b.png"></td>//! </tr>//! Uncompressed, these would take 140 K to store, which is beyond what would be//! reasonable. However, as you can see there is a large degree of similarity//! between the two bitmaps and across the rows, which lends well to//! This crate stores one 512-bit "row" of the above bitmaps in the leaf level//! of a trie, and a single additional level to index into the leafs. It turns//! out there are 124 unique 512-bit chunks across the two bitmaps so 7 bits are//! sufficient to index them.//! The chunk size of 512 bits is selected as the size that minimizes the total//! size of the data structure. A smaller chunk, like 256 or 128 bits, would//! achieve better deduplication but require a larger index. A larger chunk//! would increase redundancy in the leaf bitmaps. 512 bit chunks are the//! optimum for total size of the index plus leaf bitmaps.//! In fact since there are only 124 unique chunks, we can use an 8-bit index//! with a spare bit to index at the half-chunk level. This achieves an//! additional 8.5% compression by eliminating redundancies between the second//! half of any chunk and the first half of any other chunk. Note that this is//! not the same as using chunks which are half the size, because it does not//! necessitate raising the size of the trie's first level.//! In contrast to binary search or the `ucd-trie` crate, performing lookups in//! this data structure is straight-line code with no need for branching.Align8Align6417937584// @generated by ../generate. To regenerate, run the following in the repo root:// $ curl -LO https://www.unicode.org/Public/zipped/15.0.0/UCD.zip// $ unzip UCD.zip -d UCD// $ cargo run --manifest-path generate/Cargo.tomlstream_safeStreamSafequick_check// This crate comprises hacks and glue required to test private functions from tests/// Keep this as slim as possible.// If you're caught using this outside this crates tests/, you get to clean up the mess.DecompositionTypeCompatible// This buffer stores pairs of (canonical combining class, character),// pushed onto the end in text order.// It's divided into up to three sections:// 1) A prefix that is free space;// 2) "Ready" characters which are sorted and ready to emit on demand;// 3) A "pending" block which stills needs more characters for us to be able//    to sort in canonical order and is not safe to emit.Decompositions/// External iterator for a string decomposition's characters.new_canonicalnew_compatiblesort_pendingincrement_next_readyis_nfc_quickis_nfc_stream_safeis_nfc_stream_safe_quickis_nfdis_nfd_quickis_nfd_stream_safeis_nfd_stream_safe_quickis_nfkcis_nfkc_quickis_nfkdis_nfkd_quickIsNormalizedrecomposeRecompositionsReplacementsno_std_preludeperfect_hash__test_apidecompose_canonicaldecompose_cjk_compat_variantsdecompose_compatiblecanonical_combining_classis_public_assigned/// Return whether the given character is assigned (`General_Category` != `Unassigned`)/// and not Private-Use (`General_Category` != `Private_Use`), in the supported version/// of Unicode./// Methods for composing and decomposing characters.nfd/// Returns an iterator over the string in Unicode Normalization Form D/// (canonical decomposition).nfkd/// Returns an iterator over the string in Unicode Normalization Form KD/// (compatibility decomposition)./// An Iterator over the string in Unicode Normalization Form C/// (canonical decomposition followed by canonical composition).nfkc/// An Iterator over the string in Unicode Normalization Form KC/// (compatibility decomposition followed by canonical composition).cjk_compat_variants/// A transformation which replaces CJK Compatibility Ideograph codepoints/// with normal forms using Standardized Variation Sequences. This is not/// part of the canonical or compatibility decomposition algorithms, but/// performing it before those algorithms produces normalized output which/// better preserves the intent of the original text./// Note that many systems today ignore variation selectors, so these/// may not immediately help text display as intended, but they at/// least preserve the information in a standardized form, giving/// implementations the option to recognize them./// An Iterator over the string with Conjoining Grapheme Joiner characters/// inserted according to the Stream-Safe Text Process (UAX15-D4)/// Methods for iterating over strings while applying Unicode normalizations/// as described in/// [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/).//! Unicode character composition and decomposition utilities//! as described in//! [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/).//! extern crate unicode_normalization;//! use unicode_normalization::char::compose;//! use unicode_normalization::UnicodeNormalization;//!     assert_eq!(compose('A','\u{30a}'), Some('Å'));//!     let s = "ÅΩ";//!     let c = s.nfc().collect::<String>();//!     assert_eq!(c, "ÅΩ");//! # crates.io//! You can use this package in your project by adding the following//! to your `Cargo.toml`://! unicode-normalization = "0.1.20"mph_lookup/// Look up the canonical combining class for a codepoint./// The value returned is as defined in the Unicode Character Database.composition_tablecanonical_fully_decomposedcompatibility_fully_decomposedcjk_compat_variants_fully_decomposed/// Return whether the given character is a combining mark (`General_Category=Mark`)stream_safe_trailing_nonstartersu8_lookup_fk/// Extract the key in a 24 bit key and 8 bit value packed in a u32.u8_lookup_fv/// Extract the value in a 24 bit key and 8 bit value packed in a u32.bool_lookup_fk/// Extract the key for a boolean lookup.bool_lookup_fv/// Extract the value for a boolean lookup.pair_lookup_fk/// Extract the key in a pair.pair_lookup_fv_opt/// Extract the value in a pair, returning an option.// Copyright 2019 The Rust Project Developers. See the COPYRIGHT//! Lookups of unicode properties using minimal perfect hashing./// Compute canonical Unicode decomposition for character./// See [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/)/// Compute canonical or compatible Unicode decomposition for character./// Compute standard-variation decomposition for character./// [Standardized Variation Sequences] are used instead of the standard canonical/// decompositions, notably for CJK codepoints with singleton canonical decompositions,/// to avoid losing information. See the/// [Unicode Variation Sequence FAQ](http://unicode.org/faq/vs.html) and the/// "Other Enhancements" section of the/// [Unicode 6.3 Release Summary](https://www.unicode.org/versions/Unicode6.3.0/#Summary)/// Compose two characters into a single character, if possible.S_BASE// Constants from Unicode 9.0.0 Section 3.12 Conjoining Jamo Behavior// http://www.unicode.org/versions/Unicode9.0.0/ch03.pdf#M9.32468.Heading.310.Combining.Jamo.BehaviorL_BASEV_BASET_BASEL_COUNTV_COUNTT_COUNTN_COUNTS_COUNTS_LASTL_LASTV_LASTT_LASTT_FIRST// Composition only occurs for `TPart`s in `U+11A8 ... U+11C2`,// i.e. `T_BASE + 1 ... T_LAST`.is_hangul_syllabledecompose_hangul// Decompose a precomposed Hangul syllablehangul_decomposition_lengthcompose_hangul// Compose a pair of Hangul Jamotest_hangul_composition// Regression test from a bugfix where we were composing an LV_Syllable with// T_BASE directly. (We should only compose an LV_Syllable with a character// in the range `T_BASE + 1 ... T_LAST`.)//! Functions for computing canonical and compatible decompositions for Unicode characters.my_hash// This function is based on multiplication being fast and is "good enough". Also// it can share some work between the unsalted and salted versions.KVFKFV/// Do a lookup using minimal perfect hashing./// The table is stored as a sequence of "salt" values, then a sequence of/// values that contain packed key/value pairs. The strategy is to hash twice./// The first hash retrieves a salt value that makes the second hash unique./// The hash function doesn't have to be very good, just good enough that the/// resulting map is unique.//! Support for lookups based on minimal perfect hashing./// The text is definitely normalized./// The text is definitely not normalized./// The text may be normalized./// The QuickCheck algorithm can quickly determine if a text is or isn't/// normalized without any allocations in many cases, but it has to be able to/// return `Maybe` when a full decomposition and recomposition is necessary.// https://unicode.org/reports/tr15/#Detecting_Normalization_Forms/// Quickly check if a string is in NFC, potentially returning/// `IsNormalized::Maybe` if further checks are necessary.  In this case a check/// like `s.chars().nfc().eq(s.chars())` should suffice./// Quickly check if a string is in NFKC./// Quickly check if a string is in NFD./// Quickly check if a string is in NFKD./// Quickly check if a string is Stream-Safe NFC./// Quickly check if a string is Stream-Safe NFD./// Authoritatively check if a string is in NFC./// Authoritatively check if a string is in NFKC./// Authoritatively check if a string is in NFD./// Authoritatively check if a string is in NFKD./// Authoritatively check if a string is Stream-Safe NFC./// Authoritatively check if a string is Stream-Safe NFD.test_stream_safe_nfdtest_stream_safe_nfcRecompositionStateComposingPurgingcomposeelast_ccc/// External iterator for a string recomposition's characters.// At this time, the longest replacement sequence has length 2, so we just// need buffer space for 1 codepoint./// External iterator for replacements for a string's characters.new_cjk_compat_variantsstream_safe_leading_nonstartersMAX_NONSTARTERSCOMBINING_GRAPHEME_JOINERnonstarter_count/// UAX15-D4: This iterator keeps track of how many non-starters there have been/// since the last starter in *NFKD* and will emit a Combining Grapheme Joiner/// (U+034F) if the count exceeds 30.leading_nonstarterstrailing_nonstartersdecomposition_lenDecompositionclassify_nonstarterstest_all_nonstarterstest_classify_nonstartersCANONICAL_COMBINING_CLASS_SALTCANONICAL_COMBINING_CLASS_KVCOMPOSITION_TABLE_SALTCOMPOSITION_TABLE_KVcomposition_table_astralCANONICAL_DECOMPOSED_CHARSCANONICAL_DECOMPOSED_SALTCANONICAL_DECOMPOSED_KVCOMPATIBILITY_DECOMPOSED_CHARSCOMPATIBILITY_DECOMPOSED_SALTCOMPATIBILITY_DECOMPOSED_KVCJK_COMPAT_VARIANTS_DECOMPOSED_CHARSCJK_COMPAT_VARIANTS_DECOMPOSED_SALTCJK_COMPAT_VARIANTS_DECOMPOSED_KVCOMBINING_MARK_SALTCOMBINING_MARK_KVqc_nfcqc_nfkcqc_nfdqc_nfkdTRAILING_NONSTARTERS_SALTTRAILING_NONSTARTERS_KV// Copyright 2012-2018 The Rust Project Developers. See the COPYRIGHT// NOTE: The following code was generated by "scripts/unicode.py", do not edit directlytest_nfdtest_nfkdtest_nfctest_nfkctest_normalize_chartest_is_combining_mark_asciitest_is_combining_mark_miscgraphemeGraphemeCatGraphemesGraphemeIndices/// External iterator for grapheme clusters and byte offsets./// This struct is created by the [`grapheme_indices`] method on the [`UnicodeSegmentation`]/// trait. See its documentation for more./// [`grapheme_indices`]: trait.UnicodeSegmentation.html#tymethod.grapheme_indices/// [`UnicodeSegmentation`]: trait.UnicodeSegmentation.html/// View the underlying data (the part yet to be iterated) as a slice of the original string./// # use unicode_segmentation::UnicodeSegmentation;/// let mut iter = "abc".grapheme_indices(true);/// assert_eq!(iter.as_str(), "abc");/// iter.next();/// assert_eq!(iter.as_str(), "bc");/// assert_eq!(iter.as_str(), "");GraphemeCursorcursor_back/// External iterator for a string's/// [grapheme clusters](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries)./// This struct is created by the [`graphemes`] method on the [`UnicodeSegmentation`] trait. See its/// [`graphemes`]: trait.UnicodeSegmentation.html#tymethod.graphemes/// let mut iter = "abc".graphemes(true);new_graphemesnew_grapheme_indicesGraphemeState// No information is known.NotBreak// It is known to not be a boundary.// It is known to be a boundary.Regional// The codepoint after is a Regional Indicator Symbol, so a boundary iff// it is preceded by an even number of RIS codepoints. (GB12, GB13)Emoji// The codepoint after is Extended_Pictographic,// so whether it's a boundary depends on pre-context according to GB11.// maybe unify with PairResult?// An enum describing information about a potential boundary.// Current cursor position.// Total length of the string.// A config flag indicating whether this cursor computes legacy or extended// grapheme cluster boundaries (enables GB9a and GB9b if set).// Information about the potential boundary at `offset`cat_before// Category of codepoint immediately preceding cursor, if known.cat_after// Category of codepoint immediately after cursor, if known.pre_context_offset// If set, at least one more codepoint immediately preceding this offset// is needed to resolve whether there's a boundary at `offset`.ris_count// The number of RIS codepoints preceding `offset`. If `pre_context_offset`// is set, then counts the number of RIS between that and `offset`, otherwise// is an accurate count relative to the string.// Set if a call to `prev_boundary` or `next_boundary` was suspended due// to needing more input.grapheme_cat_cache// Cached grapheme category and associated scalar value range./// Cursor-based segmenter for grapheme clusters./// This allows working with ropes and other datastructures where the string is not contiguous or/// fully known at initialization time.GraphemeIncompletePreContext/// More pre-context is needed. The caller should call `provide_context`/// with a chunk ending at the offset given, then retry the query. This/// will only be returned if the `chunk_start` parameter is nonzero.PrevChunk/// When requesting `prev_boundary`, the cursor is moving past the beginning/// of the current chunk, so the chunk before that is requested. This will/// only be returned if the `chunk_start` parameter is nonzero./// When requesting `next_boundary`, the cursor is moving past the end of the/// current chunk, so the chunk after that is requested. This will only be/// returned if the chunk ends before the `len` parameter provided on/// creation of the cursor.InvalidOffset/// An error returned when the chunk given does not contain the cursor position.// requesting chunk following the one given/// An error return indicating that not enough content was available in the/// provided chunk to satisfy the query, and that more content must be provided.PairResult// definitely not a break// definitely a break// a break iff not in extended mode// a break if preceded by an even number of RIS// a break if preceded by emoji base and (Extend)*// An enum describing the result from lookup of a pair of categories.check_pair/// Create a new cursor. The string and initial offset are given at creation/// time, but the contents of the string are not. The `is_extended` parameter/// controls whether extended grapheme clusters are selected./// The `offset` parameter must be on a codepoint boundary./// # use unicode_segmentation::GraphemeCursor;/// let s = "हिन्दी";/// let mut legacy = GraphemeCursor::new(0, s.len(), false);/// assert_eq!(legacy.next_boundary(s, 0), Ok(Some("ह".len())));/// let mut extended = GraphemeCursor::new(0, s.len(), true);/// assert_eq!(extended.next_boundary(s, 0), Ok(Some("हि".len())));grapheme_category/// Set the cursor to a new location in the same string./// let s = "abcd";/// let mut cursor = GraphemeCursor::new(0, s.len(), false);/// assert_eq!(cursor.cur_cursor(), 0);/// cursor.set_cursor(2);/// assert_eq!(cursor.cur_cursor(), 2);cur_cursor/// The current offset of the cursor. Equal to the last value provided to/// `new()` or `set_cursor()`, or returned from `next_boundary()` or/// `prev_boundary()`./// // Two flags (🇷🇸🇮🇴), each flag is two RIS codepoints, each RIS is 4 bytes./// let flags = "\u{1F1F7}\u{1F1F8}\u{1F1EE}\u{1F1F4}";/// let mut cursor = GraphemeCursor::new(4, flags.len(), false);/// assert_eq!(cursor.cur_cursor(), 4);/// assert_eq!(cursor.next_boundary(flags, 0), Ok(Some(8)));/// assert_eq!(cursor.cur_cursor(), 8);provide_context/// Provide additional pre-context when it is needed to decide a boundary./// The end of the chunk must coincide with the value given in the/// `GraphemeIncomplete::PreContext` request./// # use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};/// let mut cursor = GraphemeCursor::new(8, flags.len(), false);/// // Not enough pre-context to decide if there's a boundary between the two flags./// assert_eq!(cursor.is_boundary(&flags[8..], 8), Err(GraphemeIncomplete::PreContext(8)));/// // Provide one more Regional Indicator Symbol of pre-context/// cursor.provide_context(&flags[4..8], 4);/// // Still not enough context to decide./// assert_eq!(cursor.is_boundary(&flags[8..], 8), Err(GraphemeIncomplete::PreContext(4)));/// // Provide additional requested context./// cursor.provide_context(&flags[0..4], 0);/// // That's enough to decide (it always is when context goes to the start of the string)/// assert_eq!(cursor.is_boundary(&flags[8..], 8), Ok(true));decidedecisionis_boundary_resulthandle_regionalhandle_emoji/// Determine whether the current cursor location is a grapheme cluster boundary./// Only a part of the string need be supplied. If `chunk_start` is nonzero or/// the length of `chunk` is not equal to `len` on creation, then this method/// may return `GraphemeIncomplete::PreContext`. The caller should then/// call `provide_context` with the requested chunk, then retry calling this/// For partial chunks, if the cursor is not at the beginning or end of the/// string, the chunk should contain at least the codepoint following the cursor./// If the string is nonempty, the chunk must be nonempty./// All calls should have consistent chunk contents (ie, if a chunk provides/// content for a given slice, all further chunks covering that slice must have/// the same content for it)./// assert_eq!(cursor.is_boundary(flags, 0), Ok(true));/// cursor.set_cursor(12);/// assert_eq!(cursor.is_boundary(flags, 0), Ok(false));next_boundary/// Find the next boundary after the current cursor position. Only a part of/// the string need be supplied. If the chunk is incomplete, then this/// method might return `GraphemeIncomplete::PreContext` or/// `GraphemeIncomplete::NextChunk`. In the former case, the caller should/// call `provide_context` with the requested chunk, then retry. In the/// latter case, the caller should provide the chunk following the one/// given, then retry./// See `is_boundary` for expectations on the provided chunk./// assert_eq!(cursor.next_boundary(flags, 0), Ok(Some(16)));/// assert_eq!(cursor.next_boundary(flags, 0), Ok(None));/// And an example that uses partial strings:/// assert_eq!(cursor.next_boundary(&s[..2], 0), Ok(Some(1)));/// assert_eq!(cursor.next_boundary(&s[..2], 0), Err(GraphemeIncomplete::NextChunk));/// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(Some(2)));/// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(Some(3)));/// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(Some(4)));/// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(None));prev_boundary/// Find the previous boundary after the current cursor position. Only a part/// of the string need be supplied. If the chunk is incomplete, then this/// `GraphemeIncomplete::PrevChunk`. In the former case, the caller should/// latter case, the caller should provide the chunk preceding the one/// let mut cursor = GraphemeCursor::new(12, flags.len(), false);/// assert_eq!(cursor.prev_boundary(flags, 0), Ok(Some(8)));/// assert_eq!(cursor.prev_boundary(flags, 0), Ok(Some(0)));/// assert_eq!(cursor.prev_boundary(flags, 0), Ok(None));/// And an example that uses partial strings (note the exact return is not/// guaranteed, and may be `PrevChunk` or `PreContext` arbitrarily):/// let mut cursor = GraphemeCursor::new(4, s.len(), false);/// assert_eq!(cursor.prev_boundary(&s[2..4], 2), Ok(Some(3)));/// assert_eq!(cursor.prev_boundary(&s[2..4], 2), Err(GraphemeIncomplete::PrevChunk));/// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(Some(2)));/// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(Some(1)));/// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(Some(0)));/// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(None));// Not sure I'm gonna keep this, the advantage over new() seems thin.test_grapheme_cursor_ris_precontexttest_grapheme_cursor_chunk_start_require_precontexttest_grapheme_cursor_prev_boundarytest_grapheme_cursor_prev_boundary_chunk_startsentenceUSentenceBoundIndicesUSentenceBoundsUnicodeSentencesUWordBoundIndicesUWordBoundsUnicodeWordIndicesUnicodeWordstestdatagraphemes/// Returns an iterator over the [grapheme clusters][graphemes] of `self`./// [graphemes]: http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries/// If `is_extended` is true, the iterator is over the/// *extended grapheme clusters*;/// otherwise, the iterator is over the *legacy grapheme clusters*./// [UAX#29](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries)/// recommends extended grapheme cluster boundaries for general processing./// # use self::unicode_segmentation::UnicodeSegmentation;/// let gr1 = UnicodeSegmentation::graphemes("a\u{310}e\u{301}o\u{308}\u{332}", true)///           .collect::<Vec<&str>>();/// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];/// assert_eq!(&gr1[..], b);/// let gr2 = UnicodeSegmentation::graphemes("a\r\nb🇷🇺🇸🇹", true).collect::<Vec<&str>>();/// let b: &[_] = &["a", "\r\n", "b", "🇷🇺", "🇸🇹"];/// assert_eq!(&gr2[..], b);grapheme_indices/// Returns an iterator over the grapheme clusters of `self` and their/// byte offsets. See `graphemes()` for more information./// let gr_inds = UnicodeSegmentation::grapheme_indices("a̐éö̲\r\n", true)///               .collect::<Vec<(usize, &str)>>();/// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];/// assert_eq!(&gr_inds[..], b);unicode_words/// Returns an iterator over the words of `self`, separated on/// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries)./// Here, "words" are just those substrings which, after splitting on/// UAX#29 word boundaries, contain any alphanumeric characters. That is, the/// substring must contain at least one character with the/// [Alphabetic](http://unicode.org/reports/tr44/#Alphabetic)/// property, or with/// [General_Category=Number](http://unicode.org/reports/tr44/#General_Category_Values)./// let uws = "The quick (\"brown\") fox can't jump 32.3 feet, right?";/// let uw1 = uws.unicode_words().collect::<Vec<&str>>();/// let b: &[_] = &["The", "quick", "brown", "fox", "can't", "jump", "32.3", "feet", "right"];/// assert_eq!(&uw1[..], b);unicode_word_indices/// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries), and their/// let uwis = "The quick (\"brown\") fox can't jump 32.3 feet, right?";/// let uwi1 = uwis.unicode_word_indices().collect::<Vec<(usize, &str)>>();/// let b: &[_] = &[(0, "The"), (4, "quick"), (12, "brown"), (20, "fox"), (24, "can't"),///                 (30, "jump"), (35, "32.3"), (40, "feet"), (46, "right")];/// assert_eq!(&uwi1[..], b);split_word_bounds/// Returns an iterator over substrings of `self` separated on/// The concatenation of the substrings returned by this function is just the original string./// let swu1 = "The quick (\"brown\")  fox".split_word_bounds().collect::<Vec<&str>>();/// let b: &[_] = &["The", " ", "quick", " ", "(", "\"", "brown", "\"", ")", "  ", "fox"];/// assert_eq!(&swu1[..], b);split_word_bound_indices/// Returns an iterator over substrings of `self`, split on UAX#29 word boundaries,/// and their offsets. See `split_word_bounds()` for more information./// let swi1 = "Brr, it's 29.3°F!".split_word_bound_indices().collect::<Vec<(usize, &str)>>();/// let b: &[_] = &[(0, "Brr"), (3, ","), (4, " "), (5, "it's"), (9, " "), (10, "29.3"),///                 (14, "°"), (16, "F"), (17, "!")];/// assert_eq!(&swi1[..], b);unicode_sentences/// [UAX#29 sentence boundaries](http://www.unicode.org/reports/tr29/#Sentence_Boundaries)./// Here, "sentences" are just those substrings which, after splitting on/// UAX#29 sentence boundaries, contain any alphanumeric characters. That is, the/// let uss = "Mr. Fox jumped. [...] The dog was too lazy.";/// let us1 = uss.unicode_sentences().collect::<Vec<&str>>();/// let b: &[_] = &["Mr. ", "Fox jumped. ", "The dog was too lazy."];/// assert_eq!(&us1[..], b);split_sentence_bounds/// let ssbs = "Mr. Fox jumped. [...] The dog was too lazy.";/// let ssb1 = ssbs.split_sentence_bounds().collect::<Vec<&str>>();/// let b: &[_] = &["Mr. ", "Fox jumped. ", "[...] ", "The dog was too lazy."];/// assert_eq!(&ssb1[..], b);split_sentence_bound_indices/// Returns an iterator over substrings of `self`, split on UAX#29 sentence boundaries,/// and their offsets. See `split_sentence_bounds()` for more information./// let ssis = "Mr. Fox jumped. [...] The dog was too lazy.";/// let ssi1 = ssis.split_sentence_bound_indices().collect::<Vec<(usize, &str)>>();/// let b: &[_] = &[(0, "Mr. "), (4, "Fox jumped. "), (16, "[...] "),///                 (22, "The dog was too lazy.")];/// assert_eq!(&ssi1[..], b);/// Methods for segmenting strings according to/// [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/).//! Iterators which split strings on Grapheme Cluster, Word or Sentence boundaries, according//! to the [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/) rules.//! extern crate unicode_segmentation;//! use unicode_segmentation::UnicodeSegmentation;//!     let s = "a̐éö̲\r\n";//!     let g = UnicodeSegmentation::graphemes(s, true).collect::<Vec<&str>>();//!     let b: &[_] = &["a̐", "é", "ö̲", "\r\n"];//!     assert_eq!(g, b);//!     let s = "The quick (\"brown\") fox can't jump 32.3 feet, right?";//!     let w = s.unicode_words().collect::<Vec<&str>>();//!     let b: &[_] = &["The", "quick", "brown", "fox", "can't", "jump", "32.3", "feet", "right"];//!     assert_eq!(w, b);//!     let s = "The quick (\"brown\")  fox";//!     let w = s.split_word_bounds().collect::<Vec<&str>>();//!     let b: &[_] = &["The", " ", "quick", " ", "(", "\"", "brown", "\"", ")", "  ", "fox"];//! # no_std//! unicode-segmentation does not depend on libstd, so it can be used in crates//! with the `#![no_std]` attribute.//! unicode-segmentation = "1.9.0"SentenceCatStatePartSotEotSepUpperLowerClosePlusSpPlusSTerm// Describe a parsed part of source string as described in this table:// https://unicode.org/reports/tr29/#Default_Sentence_BoundariesSentenceBreaksStateSentenceBreaks// Attempt to advance the internal state by one part// Whitespace and some punctutation will be collapsedmatch1// Helper function to check if state head matches a single `StatePart`match2// Helper function to check if first two `StateParts` in state match// the given twomatch_sb8// https://unicode.org/reports/tr29/#SB8// TODO cache this, it is currently quadraticmatch_sb8a// https://unicode.org/reports/tr29/#SB8amatch_sb9// https://unicode.org/reports/tr29/#SB9match_sb11// https://unicode.org/reports/tr29/#SB11// Returns the index of the character which follows a breaknew_sentence_breaks// All of the logic for forward iteration over sentences/// An iterator over the substrings of a string which, after splitting the string on/// [sentence boundaries](http://www.unicode.org/reports/tr29/#Sentence_Boundaries),/// contain any characters with the/// This struct is created by the [`unicode_sentences`] method on the [`UnicodeSegmentation`]/// [`unicode_sentences`]: trait.UnicodeSegmentation.html#tymethod.unicode_sentencessentence_start/// [sentence boundaries](http://www.unicode.org/reports/tr29/#Sentence_Boundaries)./// This struct is created by the [`split_sentence_bounds`] method on the [`UnicodeSegmentation`]/// [`split_sentence_bounds`]: trait.UnicodeSegmentation.html#tymethod.split_sentence_bounds/// External iterator for sentence boundaries and byte offsets./// This struct is created by the [`split_sentence_bound_indices`] method on the/// [`UnicodeSegmentation`] trait. See its documentation for more./// [`split_sentence_bound_indices`]: trait.UnicodeSegmentation.html#tymethod.split_sentence_bound_indicesnew_sentence_boundsnew_sentence_bound_indicesnew_unicode_sentences/// The version of [Unicode](http://www.unicode.org/)/// that this version of unicode-segmentation is based on.N_tableAlphabetic_tableGC_AnyGC_CRGC_ControlGC_ExtendGC_Extended_PictographicGC_LGC_LFGC_LVGC_LVTGC_PrependGC_Regional_IndicatorGC_SpacingMarkGC_TGC_VGC_ZWJgrapheme_cat_lookupgrapheme_cat_tableWordCatWC_ALetterWC_AnyWC_CRWC_Double_QuoteWC_ExtendWC_ExtendNumLetWC_FormatWC_Hebrew_LetterWC_KatakanaWC_LFWC_MidLetterWC_MidNumWC_MidNumLetWC_NewlineWC_NumericWC_Regional_IndicatorWC_Single_QuoteWC_WSegSpaceWC_ZWJword_categoryword_cat_lookupword_cat_tableEmojiCatEC_AnyEC_Extended_Pictographicemoji_categoryemoji_cat_lookupemoji_cat_tableemojiSC_ATermSC_AnySC_CRSC_CloseSC_ExtendSC_FormatSC_LFSC_LowerSC_NumericSC_OLetterSC_SContinueSC_STermSC_SepSC_SpSC_Uppersentence_categorysentence_cat_lookupsentence_cat_tabletest_graphemestest_wordstest_sentencestest_syriac_abbr_marktest_end_of_ayah_catTEST_SAME// official Unicode test data// http://www.unicode.org/Public/15.1.0/ucd/auxiliary/GraphemeBreakTest.txtTEST_DIFFTEST_WORD// http://www.unicode.org/Public/15.1.0/ucd/auxiliary/WordBreakTest.txtTEST_SENTENCE// http://www.unicode.org/Public/15.1.0/ucd/auxiliary/SentenceBreakTest.txt/// [word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries),/// This struct is created by the [`unicode_words`] method on the [`UnicodeSegmentation`] trait. See/// its documentation for more./// [`unicode_words`]: trait.UnicodeSegmentation.html#tymethod.unicode_words/// This iterator also provides the byte offsets for each substring./// This struct is created by the [`unicode_word_indices`] method on the [`UnicodeSegmentation`] trait. See/// [`unicode_word_indices`]: trait.UnicodeSegmentation.html#tymethod.unicode_word_indicescatb/// [word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries)./// This struct is created by the [`split_word_bounds`] method on the [`UnicodeSegmentation`]/// [`split_word_bounds`]: trait.UnicodeSegmentation.html#tymethod.split_word_bounds/// External iterator for word boundaries and byte offsets./// This struct is created by the [`split_word_bound_indices`] method on the/// [`split_word_bound_indices`]: trait.UnicodeSegmentation.html#tymethod.split_word_bound_indices/// let mut iter = "Hello world".split_word_bound_indices();/// assert_eq!(iter.as_str(), "Hello world");/// assert_eq!(iter.as_str(), " world");/// assert_eq!(iter.as_str(), "world");UWordBoundsStateLetterHLetterExtendNumLetRegionalStateFormatExtendTypeFormatExtendZwjWSegSpace// state machine for word boundary rulesAcceptAnyAcceptNoneRequireLetterRequireHLetterAcceptQLetterRequireNumeric// subtypes for FormatExtend state in UWordBoundsStateis_emoji/// let mut iter = "Hello world".split_word_bounds();get_next_catget_prev_catnew_word_boundsnew_word_bound_indiceshas_alphanumericnew_unicode_wordsnew_unicode_word_indicescharwidthcw/// Returns the character's displayed width in columns, or `None` if the/// character is a control character./// This function treats characters in the Ambiguous category according/// to [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)/// as 1 column wide. This is consistent with the recommendations for non-CJK/// contexts, or when the context cannot be reliably determined.width_cjk/// as 2 columns wide. This is consistent with the recommendations for/// CJK contexts./// Methods for determining displayed width of Unicode characters.single_char_width/// Returns the [UAX #11](https://www.unicode.org/reports/tr11/) based width of `c`, or/// `None` if `c` is a control character./// If `is_cjk == true`, ambiguous width characters are treated as double width; otherwise,/// they're treated as single width./// Returns the string's displayed width in columns./// as 1 column wide. This is consistent with the recommendations for/// non-CJK contexts, or when the context cannot be reliably determined./// as 2 column wide. This is consistent with the recommendations for/// Methods for determining displayed width of Unicode strings.NextCharInfo/// `'\n'`CombiningLongSolidusOverlay/// '\u{0338}'/// For preserving canonical equivalence with CJKTrailingLisuToneLetter/// `'\u{A4FC}'..='\u{A4FD}'`/// <https://www.unicode.org/versions/Unicode15.0.0/ch18.pdf#G42078>/// `'\u{FE0E}'`/// `'\u{FE0F}'`width_in_str/// Returns the [UAX #11](https://www.unicode.org/reports/tr11/) based width of `c`.//! Determine displayed width of `char` and `str` types according to//! [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)//! and other portions of the Unicode standard.//! See the [Rules for determining width](#rules-for-determining-width) section//! for the exact rules.//! This crate is `#![no_std]`.//! use unicode_width::UnicodeWidthStr;//! let teststr = "Ｈｅｌｌｏ, ｗｏｒｌｄ!";//! let width = UnicodeWidthStr::width(teststr);//! println!("{}", teststr);//! println!("The above string is {} columns wide.", width);//! let width = teststr.width_cjk();//! println!("The above string is {} columns wide (CJK).", width);//! # Rules for determining width//! This crate currently uses the following rules to determine the width of a//! character or string, in order of decreasing precedence. These may be tweaked in the future.//! 1. [Emoji presentation sequences] have width 2.//! 2. Outside of an East Asian context, [text presentation sequences] have width 1//!    if their base character://!    - Has the [`Emoji_Presentation`] property, and//!    - Is not in the [Enclosed Ideographic Supplement] block.//! 3. The sequence `"\r\n"` has width 1.//! 4. [Lisu tone letter] combinations consisting of a character in the range `'\u{A4F8}'..='\u{A4FB}'`//!    followed by a character in the range `'\u{A4FC}'..='\u{A4FD}'` have width 1.//! 5. In an East Asian context only, `<`, `=`, or `>` have width 2 when followed by [`'\u{0338}'` COMBINING LONG SOLIDUS OVERLAY].//! 6. [`'\u{115F}'` HANGUL CHOSEONG FILLER](https://util.unicode.org/UnicodeJsps/character.jsp?a=115F) has width 2.//! 7. The following have width 0://!    - [Characters](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5Cp%7BDefault_Ignorable_Code_Point%7D)//!       with the [`Default_Ignorable_Code_Point`] property.//!    - [Characters](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5Cp%7BGrapheme_Extend%7D)//!       with the [`Grapheme_Extend`] property.//!    - The following 8 characters, all of which have NFD decompositions consisting of two [`Grapheme_Extend`] characters://!      - [`'\u{0CC0}'` KANNADA VOWEL SIGN II](https://util.unicode.org/UnicodeJsps/character.jsp?a=0CC0),//!      - [`'\u{0CC7}'` KANNADA VOWEL SIGN EE](https://util.unicode.org/UnicodeJsps/character.jsp?a=0CC7),//!      - [`'\u{0CC8}'` KANNADA VOWEL SIGN AI](https://util.unicode.org/UnicodeJsps/character.jsp?a=0CC8),//!      - [`'\u{0CCA}'` KANNADA VOWEL SIGN O](https://util.unicode.org/UnicodeJsps/character.jsp?a=0CCA),//!      - [`'\u{0CCB}'` KANNADA VOWEL SIGN OO](https://util.unicode.org/UnicodeJsps/character.jsp?a=0CCB),//!      - [`'\u{1B3B}'` BALINESE VOWEL SIGN RA REPA TEDUNG](https://util.unicode.org/UnicodeJsps/character.jsp?a=1B3B),//!      - [`'\u{1B3D}'` BALINESE VOWEL SIGN LA LENGA TEDUNG](https://util.unicode.org/UnicodeJsps/character.jsp?a=1B3D), and//!      - [`'\u{1B43}'` BALINESE VOWEL SIGN PEPET TEDUNG](https://util.unicode.org/UnicodeJsps/character.jsp?a=1B43).//!    - [Characters](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5Cp%7BHangul_Syllable_Type%3DV%7D%5Cp%7BHangul_Syllable_Type%3DT%7D)//!       with a [`Hangul_Syllable_Type`] of `Vowel_Jamo` (`V`) or `Trailing_Jamo` (`T`).//!    - The following [`Prepended_Concatenation_Mark`]s://!      - [`'\u{0605}'` NUMBER MARK ABOVE](https://util.unicode.org/UnicodeJsps/character.jsp?a=0605),//!      - [`'\u{070F}'` SYRIAC ABBREVIATION MARK](https://util.unicode.org/UnicodeJsps/character.jsp?a=070F),//!      - [`'\u{0890}'` POUND MARK ABOVE](https://util.unicode.org/UnicodeJsps/character.jsp?a=0890),//!      - [`'\u{0891}'` PIASTRE MARK ABOVE](https://util.unicode.org/UnicodeJsps/character.jsp?a=0891), and//!      - [`'\u{08E2}'` DISPUTED END OF AYAH](https://util.unicode.org/UnicodeJsps/character.jsp?a=08E2).//!    - [`'\u{A8FA}'` DEVANAGARI CARET](https://util.unicode.org/UnicodeJsps/character.jsp?a=A8FA).//! 8. [Characters](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5Cp%7BEast_Asian_Width%3DF%7D%5Cp%7BEast_Asian_Width%3DW%7D)//!    with an [`East_Asian_Width`] of [`Fullwidth`] or [`Wide`] have width 2.//! 9. Characters fulfilling all of the following conditions have width 2 in an East Asian context, and width 1 otherwise://!    - Has an [`East_Asian_Width`] of [`Ambiguous`], or//!      has a canonical decomposition to an [`Ambiguous`] character followed by [`'\u{0338}'` COMBINING LONG SOLIDUS OVERLAY], or//!      is [`'\u{0387}'` GREEK ANO TELEIA](https://util.unicode.org/UnicodeJsps/character.jsp?a=0387), and//!    - Does not have a [`General_Category`] of `Modifier_Symbol`, and//!    - Does not have a [`Script`] of `Latin`, `Greek`, or `Cyrillic`, or is a Roman numeral in the range `'\u{2160}'..='\u{217F}'`.//! 10. All other characters have width 1.//! [`'\u{0338}'` COMBINING LONG SOLIDUS OVERLAY]: https://util.unicode.org/UnicodeJsps/character.jsp?a=0338//! [`Default_Ignorable_Code_Point`]: https://www.unicode.org/versions/Unicode15.0.0/ch05.pdf#G40095//! [`East_Asian_Width`]: https://www.unicode.org/reports/tr11/#ED1//! [`Emoji_Presentation`]: https://unicode.org/reports/tr51/#def_emoji_presentation//! [`General_Category`]: https://www.unicode.org/versions/Unicode15.0.0/ch04.pdf#G124142//! [`Grapheme_Extend`]: https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf#G52443//! [`Hangul_Syllable_Type`]: https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf#G45593//! [`Prepended_Concatenation_Mark`]: https://www.unicode.org/versions/Unicode15.0.0/ch23.pdf#G37908//! [`Script`]: https://www.unicode.org/reports/tr24/#Script//! [`Fullwidth`]: https://www.unicode.org/reports/tr11/#ED2//! [`Wide`]: https://www.unicode.org/reports/tr11/#ED4//! [`Ambiguous`]: https://www.unicode.org/reports/tr11/#ED6//! [Emoji presentation sequences]: https://unicode.org/reports/tr51/#def_emoji_presentation_sequence//! [text presentation sequences]: https://unicode.org/reports/tr51/#def_text_presentation_sequence//! [Enclosed Ideographic Supplement]: https://unicode.org/charts/nameslist/n_1F200.html//! [Lisu tone letter]: https://www.unicode.org/versions/Unicode15.0.0/ch18.pdf#G42078//! ## Canonical equivalence//! Canonically equivalent strings are assigned the same width (CJK and non-CJK)./// that this version of unicode-width is based on.lookup_width/// Returns the [UAX #11](https://www.unicode.org/reports/tr11/) based width of `c` by/// consulting a multi-level lookup table./// # Maintenance/// The tables themselves are autogenerated but this function is hardcoded. You should have/// nothing to worry about if you re-run `unicode.py` (for example, when updating Unicode.)/// However, if you change the *actual structure* of the lookup tables (perhaps by editing the/// `TABLE_CFGS` global in `unicode.py`) you must ensure that this code reflects those changes.starts_emoji_presentation_seq/// Whether this character forms an [emoji presentation sequence]/// (https://www.unicode.org/reports/tr51/#def_emoji_presentation_sequence)/// when followed by `'\u{FEOF}'`./// Emoji presentation sequences are considered to have width 2./// This may spuriously return `true` or `false` for characters that are always wide.starts_non_ideographic_text_presentation_seq/// Returns `true` iff `c` has default emoji presentation, but forms a [text presentation sequence]/// (https://www.unicode.org/reports/tr51/#def_text_presentation_sequence)/// when followed by `'\u{FEOE}'`, and is not ideographic./// Such sequences are considered to have width 1./// This may spuriously return `true` for characters of narrow or ambiguous width.Align128TABLES_0/// Autogenerated. 1 sub-table(s). Consult [`lookup_width`] for layout info.TABLES_12432/// Autogenerated. 19 sub-table(s). Consult [`lookup_width`] for layout info.TABLES_23808/// Autogenerated. 238 sub-table(s). Consult [`lookup_width`] for layout info.EMOJI_PRESENTATION_LEAVES/// Array of 1024-bit bitmaps. Index into the correct bitmap with the 10 LSB of your codepoint/// to get whether it can start an emoji presentation sequence.TEXT_PRESENTATION_LEAVES/// to get whether it can start a text presentation sequence.// Copyright 2012-2022 The Rust Project Developers. See the COPYRIGHT/// Returns whether the specified character satisfies the 'XID_Start'/// Unicode property./// 'XID_Start' is a Unicode Derived Property specified in/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),/// mostly similar to ID_Start but modified for closure under NFKx./// Returns whether the specified `char` satisfies the 'XID_Continue'/// 'XID_Continue' is a Unicode Derived Property specified in/// mostly similar to 'ID_Continue' but modified for closure under NFKx./// Methods for determining if a character is a valid identifier character.//! Determine if a `char` is a valid identifier for a parser and/or lexer according to//! [Unicode Standard Annex #31](http://www.unicode.org/reports/tr31/) rules.//! extern crate unicode_xid;//! use unicode_xid::UnicodeXID;//!     let ch = 'a';//!     println!("Is {} a valid start of an identifier? {}", ch, UnicodeXID::is_xid_start(ch));//! # features//! unicode-xid supports a `no_std` feature. This eliminates dependence//! on std, and instead uses equivalent functions from core.//! unicode-xid = "0.0.4"/// that this version of unicode-xid is based on.XID_Continue_tableXID_ContinueXID_Start_tableXID_Starttest_is_xid_starttest_is_not_xid_starttest_is_xid_continuetest_is_not_xid_continue/// Process single block./// Process several blocks in parallel./// Returns the number of blocks that should be passed to `Self::proc_block` before/// `Self::proc_par_blocks` can be used efficiently. This is always less than/// `Self::ParBlocksSize`./// Trait implemented by UHF backends./// Execute closure with the provided UHF backend./// Trait for [`UhfBackend`] users./// Update hash function state using the provided rank-2 closure./// Update hash function state with the provided block.update_padded/// Input data into the universal hash function. If the length of the/// data is not a multiple of the block size, the remaining data is/// padded with zeroes up to the `BlockSize`./// This approach is frequently used by AEAD modes which use/// Message Authentication Codes (MACs) based on universal hashing./// Obtain the [`Output`] of a [`UniversalHash`] computation and reset it back/// to its initial state./// Verify the [`UniversalHash`] of the processed input matches/// a given `expected` value./// This is useful when constructing Message Authentication Codes (MACs)/// from universal hash functions./// The [`UniversalHash`] trait defines a generic interface for universal hash/// Error type used by the [`UniversalHash::verify`] method/// to indicate that UHF output is not equal the expected value.to_blocks/// Split message into slice of blocks and leftover tail.// TODO: replace with `slice::as_chunks` on migration to const generics//! Traits for [Universal Hash Functions].//! # About universal hashes//! Universal hash functions provide a "universal family" of possible//! hash functions where a given member of a family is selected by a key.//! They are well suited to the purpose of "one time authenticators" for a//! sequence of bytestring inputs, as their construction has a number of//! desirable properties such as pairwise independence as well as amenability//! to efficient implementations, particularly when implemented using SIMD//! When combined with a cipher, such as in Galois/Counter Mode (GCM) or the//! Salsa20 family AEAD constructions, they can provide the core functionality//! for a Message Authentication Code (MAC).//! [Universal Hash Functions]: https://en.wikipedia.org/wiki/Universal_hashing/// A wrapper around `&'a [u8]` that helps in writing panic-free code./// No methods of `Input` will ever panic./// Intentionally avoids implementing `PartialEq` and `Eq` to avoid implicit/// non-constant-time comparisons./// The value is intentionally omitted from the output to avoid leaking/// secrets./// Construct a new `Input` for the given input `bytes`./// Returns `true` if the input is empty and false otherwise./// Returns the length of the `Input`./// Calls `read` with the given input as a `Reader`, ensuring that `read`/// consumed the entire input. If `read` does not consume the entire input,/// `incomplete_read` is returned.as_slice_less_safe/// Access the input as a slice so it can be processed by functions that/// are not written using the Input/Reader framework.read_all_optional/// consumed the entire input. When `input` is `None`, `read` will be/// called with `None`.//! untrusted.rs: Safe, fast, zero-panic, zero-crashing, zero-allocation//! parsing of untrusted inputs in Rust.//! <code>git clone https://github.com/briansmith/untrusted</code>//! untrusted.rs goes beyond Rust's normal safety guarantees by  also//! guaranteeing that parsing will be panic-free, as long as//! `untrusted::Input::as_slice_less_safe()` is not used. It avoids copying//! data and heap allocation and strives to prevent common pitfalls such as//! accidentally parsing input bytes multiple times. In order to meet these//! goals, untrusted.rs is limited in functionality such that it works best for//! input languages with a small fixed amount of lookahead such as ASN.1, TLS,//! TCP/IP, and many other networking, IPC, and related protocols. Languages//! that require more lookahead and/or backtracking require some significant//! contortions to parse using this framework. It would not be realistic to use//! it for parsing programming language code, for example.//! The overall pattern for using untrusted.rs is://! 1. Write a recursive-descent-style parser for the input language, where the//!    input data is given as a `&mut untrusted::Reader` parameter to each//!    function. Each function should have a return type of `Result<V, E>` for//!    some value type `V` and some error type `E`, either or both of which may//!    be `()`. Functions for parsing the lowest-level language constructs//!    should be defined. Those lowest-level functions will parse their inputs//!    using `::read_byte()`, `Reader::peek()`, and similar functions.//!    Higher-level language constructs are then parsed by calling the//!    lower-level functions in sequence.//! 2. Wrap the top-most functions of your recursive-descent parser in//!    functions that take their input data as an `untrusted::Input`. The//!    wrapper functions should call the `Input`'s `read_all` (or a variant//!    thereof) method. The wrapper functions are the only ones that should be//!    exposed outside the parser's module.//! 3. After receiving the input data to parse, wrap it in an `untrusted::Input`//!    using `untrusted::Input::from()` as early as possible. Pass the//!    `untrusted::Input` to the wrapper functions when they need to be parsed.//! In general parsers built using `untrusted::Reader` do not need to explicitly//! check for end-of-input unless they are parsing optional constructs, because//! `Reader::read_byte()` will return `Err(EndOfInput)` on end-of-input.//! Similarly, parsers using `untrusted::Reader` generally don't need to check//! for extra junk at the end of the input as long as the parser's API uses the//! pattern described above, as `read_all` and its variants automatically check//! for trailing junk. `Reader::skip_to_end()` must be used when any remaining//! unread input should be ignored without triggering an error.//! untrusted.rs works best when all processing of the input data is done//! through the `untrusted::Input` and `untrusted::Reader` types. In//! particular, avoid trying to parse input data using functions that take//! byte slices. However, when you need to access a part of the input data as//! a slice to use a function that isn't written using untrusted.rs,//! `Input::as_slice_less_safe()` can be used.//! It is recommend to use `use untrusted;` and then `untrusted::Input`,//! `untrusted::Reader`, etc., instead of using `use untrusted::*`. Qualifying//! the names with `untrusted` helps remind the reader of the code that it is//! dealing with *untrusted* input.//! [*ring*](https://github.com/briansmith/ring)'s parser for the subset of//! ASN.1 DER it needs to understand,//! [`ring::der`](https://github.com/briansmith/ring/blob/main/src/io/der.rs),//! is built on top of untrusted.rs. *ring* also uses untrusted.rs to parse ECC//! public keys, RSA PKCS#1 1.5 padding, and for all other parsing it does.//! All of [webpki](https://github.com/briansmith/webpki)'s parsing of X.509//! certificates (also ASN.1 DER) is done using untrusted.rs./// A wrapper around a slice that exposes no functions that can panic./// Intentionally avoids implementing `Debug`, `Eq`, and `PartialEq` to avoid/// creating a side channel that would leak information about the value.subslice/// A read-only, forward-only cursor into the data in an `Input`./// Using `Reader` to parse input helps to ensure that no byte of the input/// will be accidentally processed more than once. Using `Reader` in/// conjunction with `read_all` and `read_all_optional` helps ensure that no/// byte of the input is accidentally left unprocessed. The methods of `Reader`/// never panic, so `Reader` also assists the writing of panic-free code./// Avoids writing the value or position to avoid creating a side channel,/// though `Reader` can't avoid leaking the position via timing./// Construct a new Reader for the given input. Use `read_all` or/// `read_all_optional` instead of `Reader::new` whenever possible./// Returns `true` if the reader is at the end of the input, and `false`/// Returns `true` if there is at least one more byte in the input and that/// byte is equal to `b`, and false otherwise./// Reads the next input byte./// Returns `Ok(b)` where `b` is the next input byte, or `Err(EndOfInput)`/// if the `Reader` is at the end of the input./// Skips `num_bytes` of the input, returning the skipped input as an/// `Input`./// Returns `Ok(i)` if there are at least `num_bytes` of input remaining,/// and `Err(EndOfInput)` otherwise.read_bytes_to_end/// Skips the reader to the end of the input, returning the skipped input/// as an `Input`.read_partial/// Calls `read()` with the given input as a `Reader`. On success, returns a/// pair `(bytes_read, r)` where `bytes_read` is what `read()` consumed and/// `r` is `read()`'s return value./// Skips `num_bytes` of the input.skip_to_end/// Skips the reader to the end of the input./// The error type used to indicate the end of the input was reached before the/// operation could be completed.HostInternal/// A DNS domain name, as '.' dot-separated labels./// Non-ASCII labels are encoded in punycode per IDNA if this is the host of/// a special URL, or percent encoded for non-special URLs. Hosts for/// non-special URLs are also called opaque hosts./// `Url::host_str` returns the serialization of this address,/// as four decimal integers separated by `.` dots./// `Url::host_str` returns the serialization of that address between `[` and `]` brackets,/// in the format per [RFC 5952 *A Recommendation/// for IPv6 Address Text Representation*](https://tools.ietf.org/html/rfc5952):/// lowercase hexadecimal with maximal `::` compression./// The host name of an URL./// Return a copy of `self` that owns an allocated `String` but does not borrow an `&Url`./// Parse a host: either an IPv6 address in [] square brackets, or a domain./// <https://url.spec.whatwg.org/#host-parsing>parse_opaque// <https://url.spec.whatwg.org/#concept-opaque-host-parser>/// convert domain with idnawrite_ipv6longest_zero_sequence// https://url.spec.whatwg.org/#concept-ipv6-serializer step 2 and 3ends_in_a_number/// <https://url.spec.whatwg.org/#ends-in-a-number-checker>parse_ipv4number/// <https://url.spec.whatwg.org/#ipv4-number-parser>/// Ok(None) means the input is a valid number, but it overflows a `u32`.parse_ipv4addr/// <https://url.spec.whatwg.org/#concept-ipv4-parser>parse_ipv6addr/// <https://url.spec.whatwg.org/#concept-ipv6-parser>SchemeTypePATH_SEGMENTSPECIAL_PATH_SEGMENTOpaqueOriginSyntaxViolationpath_segmentsPathSegmentsMutslicingquirks/// Syntax in pseudo-BNF:///   url = scheme ":" [ hierarchical | non-hierarchical ] [ "?" query ]? [ "#" fragment ]?///   non-hierarchical = non-hierarchical-path///   non-hierarchical-path = /* Does not start with "/" *////   hierarchical = authority? hierarchical-path///   authority = "//" userinfo? host [ ":" port ]?///   userinfo = username [ ":" password ]? "@"///   hierarchical-path = [ "/" path-segment ]+// Componentsusername_end// Before ':'// Before ':' (if a password is given) or '@' (if not)path_start// Before initial '/', if any// Before '?', unlike Position::QueryStart// Before '#', unlike Position::FragmentStart/// A parsed URL record.base_urlviolation_fnParseOptions/// Full configuration for the URL parser./// Change the base URL/// See the notes of [`Url::join`] for more details about how this base is considered/// when parsing./// Override the character encoding of query strings./// This is a legacy concept only relevant for HTML.syntax_violation_callback/// Call the provided function or closure for a non-fatal `SyntaxViolation`/// when it occurs during parsing. Note that since the provided function is/// `Fn`, the caller might need to utilize _interior mutability_, such as with/// a `RefCell`, to collect the violations./// use url::{Url, SyntaxViolation};/// # use url::ParseError;/// # fn run() -> Result<(), url::ParseError> {/// let violations = RefCell::new(Vec::new());/// let url = Url::options()///     .syntax_violation_callback(Some(&|v| violations.borrow_mut().push(v)))///     .parse("https:////example.com")?;/// assert_eq!(url.as_str(), "https://example.com/");/// assert_eq!(violations.into_inner(),///            vec!(SyntaxViolation::ExpectedDoubleSlash));/// Parse an URL string with the configuration so far./// Parse an absolute URL from a string./// use url::Url;/// # fn run() -> Result<(), ParseError> {/// let url = Url::parse("https://example.net")?;/// If the function can not parse an absolute URL from the given string,/// a [`ParseError`] variant will be returned./// [`ParseError`]: enum.ParseError.htmlparse_with_params/// Parse an absolute URL from a string and add params to its query string./// Existing params are not removed./// let url = Url::parse_with_params("https://example.net?dont=clobberme",///                                  &[("lang", "rust"), ("browser", "servo")])?;/// assert_eq!("https://example.net/?dont=clobberme&lang=rust&browser=servo", url.as_str());strip_trailing_spaces_from_opaque_path/// https://url.spec.whatwg.org/#potentially-strip-trailing-spaces-from-an-opaque-path/// Parse a string as an URL, with this URL as the base URL./// The inverse of this is [`make_relative`]./// - A trailing slash is significant./// Without it, the last path component is considered to be a “file” name/// to be removed to get at the “directory” that is used as the base./// - A [scheme relative special URL](https://url.spec.whatwg.org/#scheme-relative-special-url-string)/// as input replaces everything in the base URL after the scheme./// - An absolute URL (with a scheme) as input replaces the whole base URL (even the scheme)./// // Base without a trailing slash/// let base = Url::parse("https://example.net/a/b.html")?;/// let url = base.join("c.png")?;/// assert_eq!(url.as_str(), "https://example.net/a/c.png");  // Not /a/b.html/c.png/// // Base with a trailing slash/// let base = Url::parse("https://example.net/a/b/")?;/// assert_eq!(url.as_str(), "https://example.net/a/b/c.png");/// // Input as scheme relative special URL/// let base = Url::parse("https://alice.com/a")?;/// let url = base.join("//eve.com/b")?;/// assert_eq!(url.as_str(), "https://eve.com/b");/// // Input as absolute URL/// let url = base.join("http://eve.com/b")?;/// assert_eq!(url.as_str(), "http://eve.com/b");  // http instead of https/// If the function can not parse an URL from the given string/// with this URL as the base URL, a [`ParseError`] variant will be returned./// [`make_relative`]: #method.make_relativemake_relative/// Creates a relative URL if possible, with this URL as the base URL./// This is the inverse of [`join`]./// let url = Url::parse("https://example.net/a/c.png")?;/// let relative = base.make_relative(&url);/// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("c.png"));/// let url = Url::parse("https://example.net/a/b/c.png")?;/// let url = Url::parse("https://example.net/a/d/c.png")?;/// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("../d/c.png"));/// let base = Url::parse("https://example.net/a/b.html?c=d")?;/// let url = Url::parse("https://example.net/a/b.html?e=f")?;/// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("?e=f"));/// If this URL can't be a base for the given URL, `None` is returned./// This is for example the case if the scheme, host or port are not the same./// [`join`]: #method.join/// Return a default `ParseOptions` that can fully configure the URL parser./// Get default `ParseOptions`, then change base url/// let options = Url::options();/// let api = Url::parse("https://api.example.com")?;/// let base_url = options.base_url(Some(&api));/// let version_url = base_url.parse("version.json")?;/// assert_eq!(version_url.as_str(), "https://api.example.com/version.json");/// Return the serialization of this URL./// This is fast since that serialization is already stored in the `Url` struct./// let url_str = "https://example.net/";/// let url = Url::parse(url_str)?;/// assert_eq!(url.as_str(), url_str);/// This consumes the `Url` and takes ownership of the `String` stored in it./// assert_eq!(String::from(url), url_str);check_invariants/// For internal testing, not part of the public API./// Methods of the `Url` struct assume a number of invariants./// This checks each of these invariants and panic if one is not met./// This is for testing rust-url itself./// Return the origin of this URL (<https://url.spec.whatwg.org/#origin>)/// Note: this returns an opaque origin for `file:` URLs, which causes/// `url.origin() != url.origin()`./// URL with `ftp` scheme:/// use url::{Host, Origin, Url};/// let url = Url::parse("ftp://example.com/foo")?;/// assert_eq!(url.origin(),///            Origin::Tuple("ftp".into(),///                          Host::Domain("example.com".into()),///                          21));/// URL with `blob` scheme:/// let url = Url::parse("blob:https://example.com/foo")?;///            Origin::Tuple("https".into(),///                          443));/// URL with `file` scheme:/// let url = Url::parse("file:///tmp/foo")?;/// assert!(!url.origin().is_tuple());/// let other_url = Url::parse("file:///tmp/foo")?;/// assert!(url.origin() != other_url.origin());/// URL with other scheme:/// let url = Url::parse("foo:bar")?;/// Return the scheme of this URL, lower-cased, as an ASCII string without the ':' delimiter./// assert_eq!(url.scheme(), "file");/// Return whether the URL is special (has a special scheme)/// assert!(Url::parse("http:///tmp/foo")?.is_special());/// assert!(Url::parse("file:///tmp/foo")?.is_special());/// assert!(!Url::parse("moz:///tmp/foo")?.is_special());/// Return whether the URL has an 'authority',/// which can contain a username, password, host, and port number./// URLs that do *not* are either path-only like `unix:/run/foo.socket`/// or cannot-be-a-base like `data:text/plain,Stuff`./// See also the `authority` method./// let url = Url::parse("ftp://rms@example.com")?;/// assert!(url.has_authority());/// let url = Url::parse("unix:/run/foo.socket")?;/// assert!(!url.has_authority());/// let url = Url::parse("data:text/plain,Stuff")?;/// Return the authority of this URL as an ASCII string./// Non-ASCII domains are punycode-encoded per IDNA if this is the host/// of a special URL, or percent encoded for non-special URLs./// IPv6 addresses are given between `[` and `]` brackets./// Ports are omitted if they match the well known port of a special URL./// Username and password are percent-encoded./// See also the `has_authority` method./// assert_eq!(url.authority(), "");/// let url = Url::parse("https://user:password@example.com/tmp/foo")?;/// assert_eq!(url.authority(), "user:password@example.com");/// let url = Url::parse("irc://àlex.рф.example.com:6667/foo")?;/// assert_eq!(url.authority(), "%C3%A0lex.%D1%80%D1%84.example.com:6667");/// let url = Url::parse("http://àlex.рф.example.com:80/foo")?;/// assert_eq!(url.authority(), "xn--lex-8ka.xn--p1ai.example.com");cannot_be_a_base/// Return whether this URL is a cannot-be-a-base URL,/// meaning that parsing a relative URL string with this URL as the base will return an error./// This is the case if the scheme and `:` delimiter are not followed by a `/` slash,/// as is typically the case of `data:` and `mailto:` URLs./// assert!(!url.cannot_be_a_base());/// assert!(url.cannot_be_a_base());/// Return the username for this URL (typically the empty string)/// as a percent-encoded ASCII string./// assert_eq!(url.username(), "rms");/// let url = Url::parse("ftp://:secret123@example.com")?;/// assert_eq!(url.username(), "");/// let url = Url::parse("https://example.com")?;/// Return the password for this URL, if any, as a percent-encoded ASCII string./// let url = Url::parse("ftp://rms:secret123@example.com")?;/// assert_eq!(url.password(), Some("secret123"));/// assert_eq!(url.password(), None);has_host/// Equivalent to `url.host().is_some()`./// assert!(url.has_host());/// assert!(!url.has_host());host_str/// Return the string representation of the host (domain or IP address) for this URL, if any./// Cannot-be-a-base URLs (typical of `data:` and `mailto:`) and some `file:` URLs/// don’t have a host./// See also the `host` method./// let url = Url::parse("https://127.0.0.1/index.html")?;/// assert_eq!(url.host_str(), Some("127.0.0.1"));/// assert_eq!(url.host_str(), Some("example.com"));/// assert_eq!(url.host_str(), None);/// Return the parsed representation of the host for this URL./// Non-ASCII domain labels are punycode-encoded per IDNA if this is the host/// See also the `host_str` method./// assert!(url.host().is_some());/// assert!(url.host().is_none());/// If this URL has a host and it is a domain name (not an IP address), return it./// let url = Url::parse("https://127.0.0.1/")?;/// assert_eq!(url.domain(), None);/// let url = Url::parse("mailto:rms@example.net")?;/// let url = Url::parse("https://example.com/")?;/// assert_eq!(url.domain(), Some("example.com"));/// Return the port number for this URL, if any./// Note that default port numbers are never reflected by the serialization,/// use the `port_or_known_default()` method if you want a default port number returned./// assert_eq!(url.port(), None);/// let url = Url::parse("https://example.com:443/")?;/// let url = Url::parse("ssh://example.com:22")?;/// assert_eq!(url.port(), Some(22));port_or_known_default/// Return the port number for this URL, or the default port number if it is known./// This method only knows the default port number/// of the `http`, `https`, `ws`, `wss` and `ftp` schemes./// For URLs in these schemes, this method always returns `Some(_)`./// For other schemes, it is the same as `Url::port()`./// let url = Url::parse("foo://example.com")?;/// assert_eq!(url.port_or_known_default(), None);/// let url = Url::parse("foo://example.com:1456")?;/// assert_eq!(url.port_or_known_default(), Some(1456));/// assert_eq!(url.port_or_known_default(), Some(443));socket_addrs/// Resolve a URL’s host and port number to `SocketAddr`./// If the URL has the default port number of a scheme that is unknown to this library,/// `default_port_number` provides an opportunity to provide the actual port number./// In non-example code this should be implemented either simply as `|| None`,/// or by matching on the URL’s `.scheme()`./// If the host is a domain, it is resolved using the standard library’s DNS support./// let url = url::Url::parse("https://example.net/").unwrap();/// let addrs = url.socket_addrs(|| None).unwrap();/// std::net::TcpStream::connect(&*addrs)/// /// With application-specific known default port numbers/// fn socket_addrs(url: url::Url) -> std::io::Result<Vec<std::net::SocketAddr>> {///     url.socket_addrs(|| match url.scheme() {///         "socks5" | "socks5h" => Some(1080),///         _ => None,/// Return the path for this URL, as a percent-encoded ASCII string./// For cannot-be-a-base URLs, this is an arbitrary string that doesn’t start with '/'./// For other URLs, this starts with a '/' slash/// and continues with slash-separated path segments./// use url::{Url, ParseError};/// let url = Url::parse("https://example.com/api/versions?page=2")?;/// assert_eq!(url.path(), "/api/versions");/// assert_eq!(url.path(), "/");/// let url = Url::parse("https://example.com/countries/việt nam")?;/// assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");/// Unless this URL is cannot-be-a-base,/// return an iterator of '/' slash-separated path segments,/// each as a percent-encoded ASCII string./// Return `None` for cannot-be-a-base URLs./// When `Some` is returned, the iterator always contains at least one string/// (which may be empty)./// # fn run() -> Result<(), Box<dyn Error>> {/// let url = Url::parse("https://example.com/foo/bar")?;/// let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?;/// assert_eq!(path_segments.next(), Some("foo"));/// assert_eq!(path_segments.next(), Some("bar"));/// assert_eq!(path_segments.next(), None);/// assert_eq!(path_segments.next(), Some(""));/// let url = Url::parse("data:text/plain,HelloWorld")?;/// assert!(url.path_segments().is_none());/// assert_eq!(path_segments.next(), Some("countries"));/// assert_eq!(path_segments.next(), Some("vi%E1%BB%87t%20nam"));/// Return this URL’s query string, if any, as a percent-encoded ASCII string./// fn run() -> Result<(), ParseError> {/// let url = Url::parse("https://example.com/products?page=2")?;/// let query = url.query();/// assert_eq!(query, Some("page=2"));/// let url = Url::parse("https://example.com/products")?;/// assert!(query.is_none());/// let url = Url::parse("https://example.com/?country=español")?;/// assert_eq!(query, Some("country=espa%C3%B1ol"));query_pairs/// Parse the URL’s query string, if any, as `application/x-www-form-urlencoded`/// and return an iterator of (key, value) pairs./// let url = Url::parse("https://example.com/products?page=2&sort=desc")?;/// let mut pairs = url.query_pairs();/// assert_eq!(pairs.count(), 2);/// assert_eq!(pairs.next(), Some((Cow::Borrowed("page"), Cow::Borrowed("2"))));/// assert_eq!(pairs.next(), Some((Cow::Borrowed("sort"), Cow::Borrowed("desc"))));/// Return this URL’s fragment identifier, if any./// A fragment is the part of the URL after the `#` symbol./// The fragment is optional and, if present, contains a fragment identifier/// that identifies a secondary resource, such as a section heading/// of a document./// In HTML, the fragment identifier is usually the id attribute of a an element/// that is scrolled to on load. Browsers typically will not send the fragment portion/// of a URL to the server./// **Note:** the parser did *not* percent-encode this component,/// but the input may have been percent-encoded already./// let url = Url::parse("https://example.com/data.csv#row=4")?;/// assert_eq!(url.fragment(), Some("row=4"));/// let url = Url::parse("https://example.com/data.csv#cell=4,1-6,2")?;/// assert_eq!(url.fragment(), Some("cell=4,1-6,2"));mutate/// Change this URL’s fragment identifier./// let mut url = Url::parse("https://example.com/data.csv")?;/// assert_eq!(url.as_str(), "https://example.com/data.csv");/// url.set_fragment(Some("cell=4,1-6,2"));/// assert_eq!(url.as_str(), "https://example.com/data.csv#cell=4,1-6,2");/// url.set_fragment(None);/// assert!(url.fragment().is_none());take_fragmentrestore_already_parsed_fragmentset_query/// Change this URL’s query string. If `query` is `None`, this URL's/// query string will be cleared./// let mut url = Url::parse("https://example.com/products")?;/// assert_eq!(url.as_str(), "https://example.com/products");/// url.set_query(Some("page=2"));/// assert_eq!(url.as_str(), "https://example.com/products?page=2");/// assert_eq!(url.query(), Some("page=2"));query_pairs_mutUrlQuery/// Manipulate this URL’s query string, viewed as a sequence of name/value pairs/// in `application/x-www-form-urlencoded` syntax./// The return value has a method-chaining API:/// # use url::{Url, ParseError};/// let mut url = Url::parse("https://example.net?lang=fr#nav")?;/// assert_eq!(url.query(), Some("lang=fr"));/// url.query_pairs_mut().append_pair("foo", "bar");/// assert_eq!(url.query(), Some("lang=fr&foo=bar"));/// assert_eq!(url.as_str(), "https://example.net/?lang=fr&foo=bar#nav");/// url.query_pairs_mut()///     .clear()///     .append_pair("saisons", "\u{00C9}t\u{00E9}+hiver");/// assert_eq!(url.query(), Some("foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver"));/// assert_eq!(url.as_str(),///            "https://example.net/?foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver#nav");/// Note: `url.query_pairs_mut().clear();` is equivalent to `url.set_query(Some(""))`,/// not `url.set_query(None)`./// The state of `Url` is unspecified if this return value is leaked without being dropped.take_after_path/// Change this URL’s path./// let mut url = Url::parse("https://example.com")?;/// url.set_path("api/comments");/// assert_eq!(url.as_str(), "https://example.com/api/comments");/// assert_eq!(url.path(), "/api/comments");/// let mut url = Url::parse("https://example.com/api")?;/// url.set_path("data/report.csv");/// assert_eq!(url.as_str(), "https://example.com/data/report.csv");/// assert_eq!(url.path(), "/data/report.csv");/// // `set_path` percent-encodes the given string if it's not already percent-encoded./// url.set_path("api/some comments");/// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");/// assert_eq!(url.path(), "/api/some%20comments");/// // `set_path` will not double percent-encode the string if it's already percent-encoded./// url.set_path("api/some%20comments");path_segments_mut/// Return an object with methods to manipulate this URL’s path segments./// Return `Err(())` if this URL is cannot-be-a-base.restore_after_path/// Change this URL’s port number./// Note that default port numbers are not reflected in the serialization./// If this URL is cannot-be-a-base, does not have a host, or has the `file` scheme;/// do nothing and return `Err`./// let mut url = Url::parse("ssh://example.net:2048/")?;/// url.set_port(Some(4096)).map_err(|_| "cannot be base")?;/// assert_eq!(url.as_str(), "ssh://example.net:4096/");/// url.set_port(None).map_err(|_| "cannot be base")?;/// assert_eq!(url.as_str(), "ssh://example.net/");/// Known default port numbers are not reflected:/// let mut url = Url::parse("https://example.org/")?;/// url.set_port(Some(443)).map_err(|_| "cannot be base")?;/// assert!(url.port().is_none());/// Cannot set port for cannot-be-a-base URLs:/// let mut url = Url::parse("mailto:rms@example.net")?;/// let result = url.set_port(Some(80));/// let result = url.set_port(None);set_port_internal/// Change this URL’s host./// Removing the host (calling this with `None`)/// will also remove any username, password, and port number./// Change host:/// let mut url = Url::parse("https://example.net")?;/// let result = url.set_host(Some("rust-lang.org"));/// assert_eq!(url.as_str(), "https://rust-lang.org/");/// Remove host:/// let mut url = Url::parse("foo://example.net")?;/// let result = url.set_host(None);/// assert_eq!(url.as_str(), "foo:/");/// Cannot remove host for 'special' schemes (e.g. `http`):/// assert_eq!(url.as_str(), "https://example.net/");/// Cannot change or remove host for cannot-be-a-base URLs:/// assert_eq!(url.as_str(), "mailto:rms@example.net");/// If this URL is cannot-be-a-base or there is an error parsing the given `host`,set_host_internal/// opt_new_port: None means leave unchanged, Some(None) means remove any port number.set_ip_host/// Change this URL’s host to the given IP address./// If this URL is cannot-be-a-base, do nothing and return `Err`./// Compared to `Url::set_host`, this skips the host parser./// let mut url = Url::parse("http://example.com")?;/// url.set_ip_host("127.0.0.1".parse().unwrap());/// assert_eq!(url.as_str(), "http://127.0.0.1/");/// Cannot change URL's from mailto(cannot-be-base) to ip:/// let mut url = Url::parse("mailto:rms@example.com")?;/// let result = url.set_ip_host("127.0.0.1".parse().unwrap());/// assert_eq!(url.as_str(), "mailto:rms@example.com");/// Change this URL’s password./// If this URL is cannot-be-a-base or does not have a host, do nothing and return `Err`./// let mut url = Url::parse("mailto:rmz@example.com")?;/// let result = url.set_password(Some("secret_password"));/// let mut url = Url::parse("ftp://user1:secret1@example.com")?;/// assert_eq!(url.password(), Some("secret_password"));/// let mut url = Url::parse("ftp://user2:@example.com")?;/// let result = url.set_password(Some("secret2"));/// assert_eq!(url.password(), Some("secret2"));/// Change this URL’s username./// Cannot setup username from mailto(cannot-be-base)/// let result = url.set_username("user1");/// assert_eq!(url.as_str(), "mailto:rmz@example.com");/// Setup username to user1/// let mut url = Url::parse("ftp://:secre1@example.com/")?;/// assert_eq!(url.username(), "user1");/// assert_eq!(url.as_str(), "ftp://user1:secre1@example.com/");/// Change this URL’s scheme./// Do nothing and return `Err` under the following circumstances:/// * If the new scheme is not in `[a-zA-Z][a-zA-Z0-9+.-]+`/// * If this URL is cannot-be-a-base and the new scheme is one of///   `http`, `https`, `ws`, `wss` or `ftp`/// * If either the old or new scheme is `http`, `https`, `ws`,///   `wss` or `ftp` and the other is not one of these/// * If the new scheme is `file` and this URL includes credentials///   or has a non-null port/// * If this URL's scheme is `file` and its host is empty or null/// See also [the URL specification's section on legal scheme state/// overrides](https://url.spec.whatwg.org/#scheme-state)./// Change the URL’s scheme from `https` to `http`:/// let result = url.set_scheme("http");/// assert_eq!(url.as_str(), "http://example.net/");/// Change the URL’s scheme from `foo` to `bar`:/// let result = url.set_scheme("bar");/// assert_eq!(url.as_str(), "bar://example.net");/// Cannot change URL’s scheme from `https` to `foõ`:/// let result = url.set_scheme("foõ");/// Cannot change URL’s scheme from `mailto` (cannot-be-a-base) to `https`:/// let result = url.set_scheme("https");/// Cannot change the URL’s scheme from `foo` to `https`:/// assert_eq!(url.as_str(), "foo://example.net");/// Cannot change the URL’s scheme from `http` to `foo`:/// let mut url = Url::parse("http://example.net")?;/// let result = url.set_scheme("foo");from_file_path/// Convert a file name as `std::path::Path` into an URL in the `file` scheme./// This returns `Err` if the given path is not absolute or,/// on Windows, if the prefix is not a disk prefix (e.g. `C:`) or a UNC prefix (`\\`)./// On Unix-like platforms:/// # if cfg!(unix) {/// # fn run() -> Result<(), ()> {/// let url = Url::from_file_path("/tmp/foo.txt")?;/// assert_eq!(url.as_str(), "file:///tmp/foo.txt");/// let url = Url::from_file_path("../foo.txt");/// assert!(url.is_err());/// let url = Url::from_file_path("https://google.com/");from_directory_path/// Convert a directory name as `std::path::Path` into an URL in the `file` scheme./// Compared to `from_file_path`, this ensure that URL’s the path has a trailing slash/// so that the entire path is considered when using this URL as a base URL./// * `"index.html"` parsed with `Url::from_directory_path(Path::new("/var/www"))`///   as the base URL is `file:///var/www/index.html`/// * `"index.html"` parsed with `Url::from_file_path(Path::new("/var/www"))`///   as the base URL is `file:///var/index.html`, which might not be what was intended./// Note that `std::path` does not consider trailing slashes significant/// and usually does not include them (e.g. in `Path::parent()`).serialize_internal/// Serialize with Serde using the internal representation of the `Url` struct./// The corresponding `deserialize_internal` method sacrifices some invariant-checking/// for speed, compared to the `Deserialize` trait impl./// This method is only available if the `serde` Cargo feature is enabled.deserialize_internalto_file_path/// Assuming the URL is in the `file` scheme or similar,/// convert its path to an absolute `std::path::Path`./// **Note:** This does not actually check the URL’s `scheme`,/// and may give nonsensical results for other schemes./// It is the user’s responsibility to check the URL’s scheme before calling this./// # use url::Url;/// # let url = Url::parse("file:///etc/passwd").unwrap();/// let path = url.to_file_path();/// Returns `Err` if the host is neither empty nor `"localhost"` (except on Windows, where/// `file:` URLs may have a non-local host),/// or if `Path::new_opt()` returns `None`./// (That is, if the percent-decoded path contains a NUL byte or,/// for a Windows path, is not UTF-8.)RangeArg// Private helper methods:/// Parse a string as an URL, without a base URL or encoding override./// Display the serialization of this URL./// String conversion./// Debug the serialization of this URL./// URLs compare like their serialization./// URLs hash like their serialization.slice_of/// Serializes this URL into a `serde` stream./// This implementation is only available if the `serde` Cargo feature is enabled./// Deserializes this URL from a `serde` stream.path_to_file_url_segmentspath_to_file_url_segments_windows// Build this unconditionally to alleviate https://github.com/servo/rust-url/issues/102file_url_segments_to_pathbuffile_url_segments_to_pathbuf_windows/// Implementation detail of `Url::query_pairs_mut`. Typically not used directly.// `as_mut_string` string here exposes the internal serialization of an `Url`,// which should not be exposed to users.// We achieve that by not giving users direct access to `UrlQuery`:// * Its fields are private//   (and so can not be constructed with struct literal syntax outside of this crate),// * It has no constructor// * It is only visible (on the type level) to users in the return type of//   `Url::query_pairs_mut` which is `Serializer<UrlQuery>`// * `Serializer` keeps its target in a private field// * Unlike in other `Target` impls, `UrlQuery::finished` does not return `Self`.// Copyright 2013-2015 The rust-url developers./*!

rust-url is an implementation of the [URL Standard](http://url.spec.whatwg.org/)
for the [Rust](http://rust-lang.org/) programming language.


# URL parsing and data structures

First, URL parsing may fail for various reasons and therefore returns a `Result`.

```
use url::{Url, ParseError};

assert!(Url::parse("http://[:::1]") == Err(ParseError::InvalidIpv6Address))
```

Let’s parse a valid URL and look at its components.

```
use url::{Url, Host, Position};
# use url::ParseError;
# fn run() -> Result<(), ParseError> {
let issue_list_url = Url::parse(
    "https://github.com/rust-lang/rust/issues?labels=E-easy&state=open"
)?;


assert!(issue_list_url.scheme() == "https");
assert!(issue_list_url.username() == "");
assert!(issue_list_url.password() == None);
assert!(issue_list_url.host_str() == Some("github.com"));
assert!(issue_list_url.host() == Some(Host::Domain("github.com")));
assert!(issue_list_url.port() == None);
assert!(issue_list_url.path() == "/rust-lang/rust/issues");
assert!(issue_list_url.path_segments().map(|c| c.collect::<Vec<_>>()) ==
        Some(vec!["rust-lang", "rust", "issues"]));
assert!(issue_list_url.query() == Some("labels=E-easy&state=open"));
assert!(&issue_list_url[Position::BeforePath..] == "/rust-lang/rust/issues?labels=E-easy&state=open");
assert!(issue_list_url.fragment() == None);
assert!(!issue_list_url.cannot_be_a_base());
# Ok(())
# }
# run().unwrap();
```

Some URLs are said to be *cannot-be-a-base*:
they don’t have a username, password, host, or port,
and their "path" is an arbitrary string rather than slash-separated segments:

```
use url::Url;
# use url::ParseError;

# fn run() -> Result<(), ParseError> {
let data_url = Url::parse("data:text/plain,Hello?World#")?;

assert!(data_url.cannot_be_a_base());
assert!(data_url.scheme() == "data");
assert!(data_url.path() == "text/plain,Hello");
assert!(data_url.path_segments().is_none());
assert!(data_url.query() == Some("World"));
assert!(data_url.fragment() == Some(""));
# Ok(())
# }
# run().unwrap();
```

## Serde

Enable the `serde` feature to include `Deserialize` and `Serialize` implementations for `url::Url`.

# Base URL

Many contexts allow URL *references* that can be relative to a *base URL*:

```html
<link rel="stylesheet" href="../main.css">
```

Since parsed URLs are absolute, giving a base is required for parsing relative URLs:

```
use url::{Url, ParseError};

assert!(Url::parse("../main.css") == Err(ParseError::RelativeUrlWithoutBase))
```

Use the `join` method on an `Url` to use it as a base URL:

```
use url::Url;
# use url::ParseError;

# fn run() -> Result<(), ParseError> {
let this_document = Url::parse("http://servo.github.io/rust-url/url/index.html")?;
let css_url = this_document.join("../main.css")?;
assert_eq!(css_url.as_str(), "http://servo.github.io/rust-url/main.css");
# Ok(())
# }
# run().unwrap();
```

# Feature: `serde`

If you enable the `serde` feature, [`Url`](struct.Url.html) will implement
[`serde::Serialize`](https://docs.rs/serde/1/serde/trait.Serialize.html) and
[`serde::Deserialize`](https://docs.rs/serde/1/serde/trait.Deserialize.html).
See [serde documentation](https://serde.rs) for more information.

```toml
url = { version = "2", features = ["serde"] }
```

# Feature: `debugger_visualizer`

If you enable the `debugger_visualizer` feature, the `url` crate will include
a [natvis file](https://docs.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects)
for [Visual Studio](https://www.visualstudio.com/) that allows you to view
[`Url`](struct.Url.html) objects in the debugger.

This feature requires Rust 1.71 or later.

```toml
url = { version = "2", features = ["debugger_visualizer"] }
```

*/default_porturl_origin/// A globally unique identifier/// Consists of the URL's scheme, host and port/// The origin of an URL/// Two URLs with the same origin are considered/// to originate from the same entity and can therefore trust/// each other./// The origin is determined based on the scheme as follows:/// - If the scheme is "blob" the origin is the origin of the///   URL contained in the path component. If parsing fails,///   it is an opaque origin./// - If the scheme is "ftp", "http", "https", "ws", or "wss",///   then the origin is a tuple of the scheme, host, and port./// - If the scheme is anything else, the origin is opaque, meaning///   the URL does not have the same origin as any other URL./// For more information see <https://url.spec.whatwg.org/#origin>new_opaque/// Creates a new opaque origin that is only equal to itself./// Return whether this origin is a (scheme, host, port) tuple/// (as opposed to an opaque origin).ascii_serialization/// <https://html.spec.whatwg.org/multipage/#ascii-serialisation-of-an-origin>unicode_serialization/// <https://html.spec.whatwg.org/multipage/#unicode-serialisation-of-an-origin>/// Opaque identifier for URLs that have file or other schemes/// https://url.spec.whatwg.org/#fragment-percent-encode-set/// https://url.spec.whatwg.org/#path-percent-encode-set/// https://url.spec.whatwg.org/#userinfo-percent-encode-set// The backslash (\) character is treated as a path separator in special URLs// so it needs to be additionally escaped in that case.QUERY// https://url.spec.whatwg.org/#query-stateSPECIAL_QUERYsimple_enum_errorr" Errors that can occur during parsing."r" This may be extended in the future so exhaustive matching is"r" discouraged with an unused variant."EmptyHostIdnaErrorInvalidIpv4AddressInvalidIpv6AddressInvalidDomainCharacterRelativeUrlWithoutBaseRelativeUrlWithCannotBeABaseBaseSetHostOnCannotBeABaseUrlsyntax_violation_enumr" Non-fatal syntax violations that can occur during parsing."r" forbidden.""backslash""leading or trailing control or space character are ignored in URLs"C0SpaceIgnored"embedding authentication information (username or password) \
         in an URL is not recommended"EmbeddedCredentials"expected //"ExpectedDoubleSlash"expected // after file:"ExpectedFileDoubleSlash"file: with host and Windows drive letter"FileWithHostAndWindowsDrive"non-URL code point"NonUrlCodePoint"NULL characters are ignored in URL fragment identifiers"NullInFragment"expected 2 hex digits after %""tabs or newlines are ignored in URLs"TabOrNewlineIgnored"unencoded @ sign in username or password"UnencodedAtSignSpecialNotFileNotSpecialnew_no_trimnew_trim_tab_and_newlinesnew_trim_c0_control_and_spacesplit_prefixcount_matchingnext_utf8query_encoding_overrideUrlParserPathSegmentSetterlog_violationlog_violation_iffor_setterparse_url/// https://url.spec.whatwg.org/#concept-basic-url-parserparse_with_schemeparse_non_special/// Scheme other than file, http, https, ws, ws, ftp.after_double_slashparse_userinfo/// Return (username_end, remaining)parse_host_and_portparse_hostget_file_hostparse_file_hostfile_hostparse_portparse_path_startlast_slash_can_be_removedshorten_path/// https://url.spec.whatwg.org/#shorten-a-urls-pathpop_path/// https://url.spec.whatwg.org/#pop-a-urls-pathparse_cannot_be_a_base_pathwith_query_and_fragmentparse_query_and_fragment/// Return (query_start, fragment_start)parse_queryfragment_onlyparse_fragmentcheck_url_code_pointis_url_code_point// Non URL code points:// U+0000 to U+0020 (space)// " # % < > [ \ ] ^ ` { | }// U+007F to U+009F// surrogates// U+FDD0 to U+FDEF// Last two of each plane: U+__FFFE to U+__FFFF for __ in 00 to 10 hexc0_control_or_space/// https://url.spec.whatwg.org/#c0-controls-and-spaceascii_tab_or_new_line/// https://infra.spec.whatwg.org/#ascii-tab-or-newlineascii_alpha/// https://url.spec.whatwg.org/#ascii-alphais_normalized_windows_drive_letteris_windows_drive_letter/// Whether the scheme is file:, the path has a single segment, and that segment/// is a Windows drive letterpath_starts_with_windows_drive_letter/// Whether path starts with a root slash/// and a windows drive letter eg: "/c:" or "/a:/"starts_with_windows_drive_letterstarts_with_windows_drive_letter_segment/// https://url.spec.whatwg.org/#start-with-a-windows-drive-letterafter_first_slashafter_pathold_after_path_position/// Exposes methods to manipulate the path of an URL that is not cannot-be-base./// The path always starts with a `/` slash, and is made of slash-separated segments./// There is always at least one segment (which may be the empty string)./// let mut url = Url::parse("mailto:me@example.com")?;/// assert!(url.path_segments_mut().is_err());/// let mut url = Url::parse("http://example.net/foo/index.html")?;/// url.path_segments_mut().map_err(|_| "cannot be base")?///     .pop().push("img").push("2/100%.png");/// assert_eq!(url.as_str(), "http://example.net/foo/img/2%2F100%25.png");// Not re-exported outside the crate/// Remove all segments in the path, leaving the minimal `url.path() == "/"`./// Returns `&mut Self` so that method calls can be chained./// let mut url = Url::parse("https://github.com/servo/rust-url/")?;///     .clear().push("logout");/// assert_eq!(url.as_str(), "https://github.com/logout");pop_if_empty/// Remove the last segment of this URL’s path if it is empty,/// except if these was only one segment to begin with./// In other words, remove one path trailing slash, if any,/// unless it is also the initial slash (so this does nothing if `url.path() == "/")`.///     .push("pulls");/// assert_eq!(url.as_str(), "https://github.com/servo/rust-url//pulls");///     .pop_if_empty().push("pulls");/// assert_eq!(url.as_str(), "https://github.com/servo/rust-url/pulls");/// Remove the last segment of this URL’s path./// If the path only has one segment, make it empty such that `url.path() == "/"`./// Append the given segment at the end of this URL’s path./// See the documentation for `.extend()`./// Append each segment from the given iterator at the end of this URL’s path./// Each segment is percent-encoded like in `Url::parse` or `Url::join`,/// except that `%` and `/` characters are also encoded (to `%25` and `%2F`)./// This is unlike `Url::parse` where `%` is left as-is in case some of the input/// is already percent-encoded, and `/` denotes a path segment separator.)/// Note that, in addition to slashes between new segments,/// this always adds a slash between the existing path and the new segments/// *except* if the existing path is `"/"`./// If the previous last segment was empty (if the path had a trailing slash)/// the path after `.extend()` will contain two consecutive slashes./// If that is undesired, call `.pop_if_empty()` first./// To obtain a behavior similar to `Url::join`, call `.pop()` unconditionally first./// let mut url = Url::parse("https://github.com/")?;/// let org = "servo";/// let repo = "rust-url";/// let issue_number = "188";///     .extend(&[org, repo, "issues", issue_number]);/// assert_eq!(url.as_str(), "https://github.com/servo/rust-url/issues/188");/// In order to make sure that parsing the serialization of an URL gives the same URL,/// a segment is ignored if it is `"."` or `".."`:/// let mut url = Url::parse("https://github.com/servo")?;///     .extend(&["..", "rust-url", ".", "pulls"]);/// <https://url.spec.whatwg.org/#dom-url-domaintoascii>/// <https://url.spec.whatwg.org/#dom-url-domaintounicode>href/// Getter for <https://url.spec.whatwg.org/#dom-url-href>set_href/// Setter for <https://url.spec.whatwg.org/#dom-url-href>/// Getter for <https://url.spec.whatwg.org/#dom-url-origin>/// Getter for <https://url.spec.whatwg.org/#dom-url-protocol>/// Setter for <https://url.spec.whatwg.org/#dom-url-protocol>/// Getter for <https://url.spec.whatwg.org/#dom-url-username>/// Setter for <https://url.spec.whatwg.org/#dom-url-username>/// Getter for <https://url.spec.whatwg.org/#dom-url-password>/// Setter for <https://url.spec.whatwg.org/#dom-url-password>/// Getter for <https://url.spec.whatwg.org/#dom-url-host>/// Setter for <https://url.spec.whatwg.org/#dom-url-host>/// Getter for <https://url.spec.whatwg.org/#dom-url-hostname>/// Setter for <https://url.spec.whatwg.org/#dom-url-hostname>/// Getter for <https://url.spec.whatwg.org/#dom-url-port>/// Setter for <https://url.spec.whatwg.org/#dom-url-port>/// Getter for <https://url.spec.whatwg.org/#dom-url-pathname>set_pathname/// Setter for <https://url.spec.whatwg.org/#dom-url-pathname>/// Getter for <https://url.spec.whatwg.org/#dom-url-search>set_search/// Setter for <https://url.spec.whatwg.org/#dom-url-search>/// Getter for <https://url.spec.whatwg.org/#dom-url-hash>set_hash/// Setter for <https://url.spec.whatwg.org/#dom-url-hash>//! Getters and setters for URL components implemented per <https://url.spec.whatwg.org/#api>//! Unless you need to be interoperable with web browsers,//! you probably want to use `Url` method instead.count_digits// Counts how many base-10 digits are required to represent n in the given basetest_count_digitsBeforeSchemeAfterSchemeBeforeUsernameAfterUsernameBeforePasswordAfterPasswordBeforeHostAfterHostBeforePortAfterPortBeforePathAfterPathBeforeQueryAfterQueryBeforeFragmentAfterFragment/// Indicates a position within a URL based on its components./// A range of positions can be used for slicing `Url`:/// # use url::{Url, Position};/// # fn something(some_url: Url) {/// let serialization: &str = &some_url[..];/// let serialization_without_fragment: &str = &some_url[..Position::AfterQuery];/// let authority: &str = &some_url[Position::BeforeUsername..Position::AfterPort];/// let data_url_payload: &str = &some_url[Position::BeforePath..Position::AfterQuery];/// let scheme_relative: &str = &some_url[Position::BeforeUsername..];/// In a pseudo-grammar (where `[`…`]?` makes a sub-sequence optional),/// URL components and delimiters that separate them are:/// url =///     scheme ":"///     [ "//" [ username [ ":" password ]? "@" ]? host [ ":" port ]? ]?///     path [ "?" query ]? [ "#" fragment ]?/// When a given component is not present,/// its "before" and "after" position are the same/// (so that `&some_url[BeforeFoo..AfterFoo]` is the empty string)/// and component ordering is preserved/// (so that a missing query "is between" a path and a fragment)./// The end of a component and the start of the next are either the same or separate/// by a delimiter./// (Note that the initial `/` of a path is considered part of the path here, not a delimiter.)/// For example, `&url[..BeforeFragment]` would include a `#` delimiter (if present in `url`),/// so `&url[..AfterQuery]` might be desired instead./// `BeforeScheme` and `AfterFragment` are always the start and end of the entire URL,/// so `&url[BeforeScheme..X]` is the same as `&url[..X]`/// and `&url[X..AfterFragment]` is the same as `&url[X..]`./// Decode percent-encoded string assuming UTF-8 encoding./// If you need a `String`, call `.into_owned()` (not `.to_owned()`)./// Unencoded `+` is preserved literally, and _not_ changed to a space.decode_binary/// Decode percent-encoded string as binary data, in any encoding.NeverReallocdec_borrows/// Wrapper type that implements `Display`. Encodes on the fly, without allocating./// Percent-encodes every byte except alphanumerics and `-`, `_`, `.`, `~`. Assumes UTF-8 encoding./// use urlencoding::Encoded;/// format!("{}", Encoded("hello!"));/// Long way of writing `Encoded(data)`/// Takes any string-like type or a slice of bytes, either owned or borrowed./// Perform urlencoding to a string/// Perform urlencoding into a writer/// Perform urlencoding into a string/// Same as new, but hints a more specific type, so you can avoid errors about `AsRef<[u8]>` not implemented/// on references-to-references./// Call `.into_owned()` if you need a `String`/// Percent-encodes every byte except alphanumerics and `-`, `_`, `.`, `~`.to_hex_digitit_encodes_successfullyit_encodes_successfully_emojiit_decodes_successfullyit_decodes_successfully_emojiit_decodes_unsuccessfully_emojilazy_writerwhatwg_examples//! To encode a string, do the following://! use urlencoding::encode;//! let encoded = encode("This string will be URL encoded.");//! println!("{}", encoded);//! // This%20string%20will%20be%20URL%20encoded.//! To decode a string, it's only slightly different://! use urlencoding::decode;//! let decoded = decode("%F0%9F%91%BE%20Exterminate%21").expect("UTF-8");//! println!("{}", decoded);//! // 👾 Exterminate!//! To decode allowing arbitrary bytes and invalid UTF-8://! use urlencoding::decode_binary;//! let binary = decode_binary(b"%F1%F2%F3%C0%C1%C2");//! let decoded = String::from_utf8_lossy(&binary);//! This library returns [`Cow`](https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html) to avoid allocating when decoding/encoding is not needed. Call `.into_owned()` on the `Cow` to get a `Vec` or `String`.c_passwdc_groupprimary_groupextrasUserExtrasname_arc/// Information about a particular user./// For more information, see the [module documentation](index.html)./// Create a new `User` with the given user ID, name, and primary/// group ID, with the rest of the fields filled with dummy values./// This method does not actually create a new user on the system — it/// should only be used for comparing users in tests./// use users::User;/// let user = User::new(501, "stevedore", 100);/// Returns this user’s ID./// assert_eq!(user.uid(), 501);/// Returns this user’s name./// assert_eq!(user.name(), OsStr::new("stevedore"));primary_group_id/// Returns the ID of this user’s primary group./// assert_eq!(user.primary_group_id(), 100);/// Returns a list of groups this user is a member of. This involves/// loading the groups list, as it is _not_ contained within this type./// # libc functions used/// - [`getgrouplist`](https://docs.rs/libc/*/libc/fn.getgrouplist.html)/// for group in user.groups().expect("User not found") {///     println!("User is in group: {:?}", group.name());GroupExtras/// Information about a particular group./// Create a new `Group` with the given group ID and name, with the/// rest of the fields filled in with dummy values./// This method does not actually create a new group on the system — it/// should only be used for comparing groups in tests./// use users::Group;/// let group = Group::new(102, "database");/// Returns this group’s ID./// assert_eq!(group.gid(), 102);/// Returns this group’s name./// assert_eq!(group.name(), OsStr::new("database"));from_raw_buf/// Reads data from a `*char` field in `c_passwd` or `g_group` into an/// `OsString` for use in a user or group value./// The underlying buffer is managed by the C library, not by us, so we *need*/// to move data out of it before the next user gets read.passwd_to_user/// Reads data from the `c_passwd` and returns it as a `User`.struct_to_group/// Reads data from the `c_group` and returns it as a `Group`./// Expand a list of group members to a vector of strings./// The list of members is, in true C fashion, a pointer to a pointer of/// characters, terminated by a null pointer. We check `members[0]`, then/// `members[1]`, and so on, until that null pointer is reached. It doesn’t/// specify whether we should expect a null pointer or a pointer to a null/// pointer, so we check for both here!get_user_by_uid/// Searches for a `User` with the given ID in the system’s user database./// Returns it if one is found, otherwise returns `None`./// - [`getpwuid_r`](https://docs.rs/libc/*/libc/fn.getpwuid_r.html)/// use users::get_user_by_uid;/// match get_user_by_uid(501) {///     Some(user) => println!("Found user {:?}", user.name()),///     None       => println!("User not found"),get_user_by_name/// Searches for a `User` with the given username in the system’s user database./// - [`getpwnam_r`](https://docs.rs/libc/*/libc/fn.getpwnam_r.html)/// use users::get_user_by_name;/// match get_user_by_name("stevedore") {///     Some(user) => println!("Found user #{}", user.uid()),get_group_by_gid/// Searches for a `Group` with the given ID in the system’s group database./// - [`getgrgid_r`](https://docs.rs/libc/*/libc/fn.getgrgid_r.html)/// use users::get_group_by_gid;/// match get_group_by_gid(102) {///     Some(group) => println!("Found group {:?}", group.name()),///     None        => println!("Group not found"),/// Searches for a `Group` with the given group name in the system’s group database./// - [`getgrnam_r`](https://docs.rs/libc/*/libc/fn.getgrnam_r.html)/// use users::get_group_by_name;/// match get_group_by_name("db-access") {///     Some(group) => println!("Found group #{}", group.gid()),get_current_uid/// Returns the user ID for the user running the process./// - [`getuid`](https://docs.rs/libc/*/libc/fn.getuid.html)/// use users::get_current_uid;/// println!("The ID of the current user is {}", get_current_uid());get_current_username/// Returns the username of the user running the process./// This function to return `None` if the current user does not exist, which/// could happed if they were deleted after the program started running./// use users::get_current_username;/// match get_current_username() {///     Some(uname) => println!("Running as user with name {:?}", uname),///     None        => println!("The current user does not exist!"),get_effective_uid/// Returns the user ID for the effective user running the process./// - [`geteuid`](https://docs.rs/libc/*/libc/fn.geteuid.html)/// use users::get_effective_uid;/// println!("The ID of the effective user is {}", get_effective_uid());get_effective_username/// Returns the username of the effective user running the process./// use users::get_effective_username;/// match get_effective_username() {///     Some(uname) => println!("Running as effective user with name {:?}", uname),///     None        => println!("The effective user does not exist!"),get_current_gid/// Returns the group ID for the user running the process./// - [`getgid`](https://docs.rs/libc/*/libc/fn.getgid.html)/// use users::get_current_gid;/// println!("The ID of the current group is {}", get_current_gid());get_current_groupname/// Returns the groupname of the user running the process./// - [`getgrgid`](https://docs.rs/libc/*/libc/fn.getgrgid.html)/// use users::get_current_groupname;/// match get_current_groupname() {///     Some(gname) => println!("Running as group with name {:?}", gname),///     None        => println!("The current group does not exist!"),get_effective_gid/// Returns the group ID for the effective user running the process./// - [`getegid`](https://docs.rs/libc/*/libc/fn.getegid.html)/// use users::get_effective_gid;/// println!("The ID of the effective group is {}", get_effective_gid());get_effective_groupname/// Returns the groupname of the effective user running the process./// use users::get_effective_groupname;/// match get_effective_groupname() {///     Some(gname) => println!("Running as effective group with name {:?}", gname),///     None        => println!("The effective group does not exist!"),group_access_list/// Returns the group access list for the current process./// - [`getgroups`](https://docs.rs/libc/*/libc/fn.getgroups.html)/// This function will return `Err` when an I/O error occurs during the/// `getgroups` call./// use users::group_access_list;/// for group in group_access_list().expect("Error looking up groups") {///     println!("Process can access group #{} ({:?})", group.gid(), group.name());/// Returns groups for a provided user name and primary group id./// use users::get_user_groups;/// for group in get_user_groups("stevedore", 1001).expect("Error looking up groups") {///     println!("User is a member of group #{} ({:?})", group.gid(), group.name());AllUsers/// An iterator over every user present on the system.all_users/// Creates a new iterator over every user present on the system./// - [`getpwent`](https://docs.rs/libc/*/libc/fn.getpwent.html)/// - [`setpwent`](https://docs.rs/libc/*/libc/fn.setpwent.html)/// - [`endpwent`](https://docs.rs/libc/*/libc/fn.endpwent.html)/// This constructor is marked as `unsafe`, which is odd for a crate/// that’s meant to be a safe interface. It *has* to be unsafe because/// we cannot guarantee that the underlying C functions,/// `getpwent`/`setpwent`/`endpwent` that iterate over the system’s/// `passwd` entries, are called in a thread-safe manner./// These functions [modify a global/// state](http://man7.org/linux/man-pages/man3/getpwent.3.html#ATTRIBUTES),/// and if any are used at the same time, the state could be reset,/// resulting in a data race. We cannot even place it behind an internal/// `Mutex`, as there is nothing stopping another `extern` function/// definition from calling it!/// So to iterate all users, construct the iterator inside an `unsafe`/// block, then make sure to not make a new instance of it until/// iteration is over./// use users::all_users;/// let iter = unsafe { all_users() };/// for user in iter {///     println!("User #{} ({:?})", user.uid(), user.name());/// Returns a path to this user’s home directory.with_home_dir/// Sets this user value’s home directory to the given string./// Can be used to construct test users, which by default come with a/// dummy home directory string./// Returns a path to this user’s shell.with_shell/// Sets this user’s shell path to the given string./// dummy shell field./// Returns the user’s encrypted password./// Sets this user’s password to the given string./// Can be used to construct tests users, which by default come with a/// dummy password field.UserExt/// Unix-specific extensions for `User`s./// Returns a slice of the list of users that are in this group as/// their non-primary group.add_member/// Adds a new member to this group.GroupExt/// Unix-specific extensions for `Group`s./// The path to the user’s home directory./// The path to the user’s shell./// The user’s encrypted password./// Unix-specific fields for `User`s.from_passwd/// Extract the OS-specific fields from the C `passwd` struct that/// we just read./// Vector of usernames that are members of this group./// Unix-specific fields for `Group`s./// Extract the OS-specific fields from the C `group` struct that/// Extensions to users and groups for Unix platforms./// Although the `passwd` struct is common among Unix systems, its actual/// format can vary. See the definitions in the `base` module to check which/// fields are actually present./// Any extra fields on a `User` specific to the current platform./// Any extra fields on a `Group` specific to the current platform./// OS-specific extensions to users and groups./// Every OS has a different idea of what data a user or a group comes with./// Although they all provide a *username*, some OS’ users have an *actual name*/// too, or a set of permissions or directories or timestamps associated with/// This module provides extension traits for users and groups that allow/// implementors of this library to access this data *as long as a trait is/// available*, which requires the OS they’re using to support this data./// It’s the same method taken by `Metadata` in the standard Rust library,/// which has a few cross-platform fields and many more OS-specific fields:/// traits in `std::os` provides access to any data that is not guaranteed to/// be there in the actual struct.uid_for_usernameusername_for_uid_for_usernameuser_infouser_by_nameuser_get_groupsgroup_by_name//! Integration with the C library’s users and groups.//! This module uses `extern` functions and types from `libc` that integrate//! with the system’s C library, which integrates with the OS itself to get user//! and group information. It’s where the “core” user handling is done.//! ## Name encoding rules//! Under Unix, usernames and group names are considered to be//! null-terminated, UTF-8 strings. These are `CString`s in Rust, although in//! this library, they are just `String` values. Why?//! The reason is that any user or group values with invalid `CString` data//! can instead just be assumed to not exist://! - If you try to search for a user with a null character in their name,//!   such a user could not exist anyway — so it’s OK to return `None`.//! - If the OS returns user information with a null character in a field,//!   then that field will just be truncated instead, which is valid behaviour//!   for a `CString`.//! The downside is that we use `from_utf8_lossy` instead, which has a small//! runtime penalty when it calculates and scans the length of the string for//! invalid characters. However, this should not be a problem when dealing with//! usernames of a few bytes each.//! In short, if you want to check for null characters in user fields, your//! best bet is to check for them yourself before passing strings into anyBiMapUsersCache/// A producer of user and group instances that caches every result./// For more information, see the [`users::cache` module documentation](index.html).backward/// A kinda-bi-directional `HashMap` that associates keys to values, and/// then strings back to keys./// It doesn’t go the full route and offer *values*-to-keys lookup, because we/// only want to search based on usernames and group names. There wouldn’t be/// much point offering a “User to uid” map, as the uid is present in the/// `User` struct!// Default has to be impl’d manually here, because there’s no// Default impl on User or Group, even though those types aren’t// needed to produce a default instance of any HashMaps.../// Creates a new empty cache./// use users::cache::UsersCache;/// let cache = UsersCache::new();with_all_users/// Creates a new cache that contains all the users present on the system./// This is `unsafe` because we cannot prevent data races if two caches/// were attempted to be initialised on different threads at the same time./// For more information, see the [`all_users` documentation](../fn.all_users.html)./// let cache = unsafe { UsersCache::with_all_users() };//! A cache for users and groups provided by the OS.//! Because the users table changes so infrequently, it's common for//! short-running programs to cache the results instead of getting the most//! up-to-date entries every time. The [`UsersCache`](struct.UsersCache.html)//! type helps with this, providing methods that have the same name as the//! others in this crate, only they store the results.//! use users::{Users, UsersCache};//! let mut cache = UsersCache::new();//! let user      = cache.get_user_by_uid(502).expect("User not found");//! let same_user = cache.get_user_by_uid(502).unwrap();//! // The two returned values point to the same User//! assert!(Arc::ptr_eq(&user, &same_user));//! ## Caching, multiple threads, and mutability//! The `UsersCache` type is caught between a rock and a hard place when it//! comes to providing references to users and groups.//! Instead of returning a fresh `User` struct each time, for example, it will//! return a reference to the version it currently has in its cache. So you can//! ask for User #501 twice, and you’ll get a reference to the same value both//! time. Its methods are *idempotent* -- calling one multiple times has the//! same effect as calling one once.//! This works fine in theory, but in practice, the cache has to update its own//! state somehow: it contains several `HashMap`s that hold the result of user//! and group lookups. Rust provides mutability in two ways://! 1. Have its methods take `&mut self`, instead of `&self`, allowing the//!   internal maps to be mutated (“inherited mutability”)//! 2. Wrap the internal maps in a `RefCell`, allowing them to be modified//!   (“interior mutability”).//! Unfortunately, Rust is also very protective of references to a mutable//! value. In this case, switching to `&mut self` would only allow for one user//! to be read at a time!//! let mut cache = UsersCache::empty_cache();//! let uid   = cache.get_current_uid();                     // OK...//! let user  = cache.get_user_by_uid(uid).unwrap()          // OK...//! let group = cache.get_group_by_gid(user.primary_group);  // No!//! When we get the `user`, it returns an optional reference (which we unwrap)//! to the user’s entry in the cache. This is a reference to something contained//! in a mutable value. Then, when we want to get the user’s primary group, it//! will return *another* reference to the same mutable value. This is something//! that Rust explicitly disallows!//! The compiler wasn’t on our side with Option 1, so let’s try Option 2://! changing the methods back to `&self` instead of `&mut self`, and using//! `RefCell`s internally. However, Rust is smarter than this, and knows that//! we’re just trying the same trick as earlier. A simplified implementation of//! a user cache lookup would look something like this://! fn get_user_by_uid(&self, uid: uid_t) -> Option<&User> {//!     let users = self.users.borrow_mut();//!     users.get(uid)//! Rust won’t allow us to return a reference like this because the `Ref` of the//! `RefCell` just gets dropped at the end of the method, meaning that our//! reference does not live long enough.//! So instead of doing any of that, we use `Arc` everywhere in order to get//! around all the lifetime restrictions. Returning reference-counted users and//! groups mean that we don’t have to worry about further uses of the cache, as//! the values themselves don’t count as being stored *in* the cache anymore. So//! it can be queried multiple times or go out of scope and the values it//! produces are not affected.//! This is a library for getting information on Unix users and groups. It//! supports getting the system users, and creating your own mock tables.//! In Unix, each user has an individual *user ID*, and each process has an//! *effective user ID* that says which user’s permissions it is using.//! Furthermore, users can be the members of *groups*, which also have names and//! IDs. This functionality is exposed in libc, the C standard library, but as//! an unsafe Rust interface. This wrapper library provides a safe interface,//! using [`User`](struct.user.html) and [`Group`](struct.group.html) types//! and functions such as [`get_user_by_uid`](fn.get_user_by_uid.html) instead//! of low-level pointers and strings. It also offers basic caching//! It does not (yet) offer *editing* functionality; the values returned are//! read-only.//! ## Users//! The function [`get_current_uid`](fn.get_current_uid.html) returns a//! `uid_t` value representing the user currently running the program, and the//! [`get_user_by_uid`](fn.get_user_by_uid.html) function scans the users//! database and returns a `User` with the user’s information. This function//! returns `None` when there is no user for that ID. The `uid_t` type is//! re-exported from the libc crate.//! A [`User`](struct.User.html) value has the following accessors://! - **uid:** The user’s ID//! - **name:** The user’s name//! - **primary_group:** The ID of this user’s primary group//! Here is a complete example that prints out the current user’s name://! use users::{get_user_by_uid, get_current_uid};//! let user = get_user_by_uid(get_current_uid()).unwrap();//! println!("Hello, {}!", user.name().to_string_lossy());//! This code assumes (with `unwrap()`) that the user hasn’t been deleted after//! the program has started running. For arbitrary user IDs, this is **not** a//! safe assumption: it’s possible to delete a user while it’s running a//! program, or is the owner of files, or for that user to have never existed.//! So always check the return values!//! There is also a [`get_current_username`](fn.get_current_username.html)//! function, as it’s such a common operation that it deserves special//! treatment.//! ## Caching//! Despite the above warning, the users and groups database rarely changes.//! While a short program may only need to get user information once, a//! long-running one may need to re-query the database many times, and a//! medium-length one may get away with caching the values to save on redundant//! system calls.//! For this reason, this crate offers a caching interface to the database,//! which offers the same functionality while holding on to every result,//! caching the information so it can be re-used.//! To introduce a cache, create a new//! [`UsersCache`](cache/struct.UsersCache.html). It has functions with the//! same names as the ones from earlier. For example://! use users::{Users, Groups, UsersCache};//! let uid = cache.get_current_uid();//! let user = cache.get_user_by_uid(uid).unwrap();//! println!("Hello again, {}!", user.name().to_string_lossy());//! This cache is **only additive**: it’s not possible to drop it, or erase//! selected entries, as when the database may have been modified, it’s best to//! start entirely afresh. So to accomplish this, just start using a new//! `UsersCache`.//! ## Groups//! Finally, it’s possible to get groups in a similar manner.//! A [`Group`](struct.Group.html) has the following accessors://! - **gid:** The group’s ID//! - **name:** The group’s name//! And again, a complete example://! let group = cache.get_group_by_name("admin").expect("No such group 'admin'!");//! println!("The '{}' group has the ID {}", group.name().to_string_lossy(), group.gid());//! The `logging` feature, which is on by default, uses the `log` crate to//! record all interactions with the operating system.//! ## Caveats//! You should be prepared for the users and groups tables to be completely//! broken: IDs shouldn’t be assumed to map to actual users and groups, and//! usernames and group names aren’t guaranteed to map either!//! Use the [`mock`](mock/index.html) module to create custom tables to test//! your code for these edge cases.MockUsers/// A mocking users table that you can add your own users and groups to.with_current_uid/// Create a new, empty mock users table.add_user/// Add a user to the users table./// Add a group to the groups table.current_usernameno_current_usernameno_usernameno_uidno_group_nameno_gid//! Mockable users and groups.//! When you’re testing your code, you don’t want to actually rely on the//! system actually having various users and groups present - it’s much better//! to have a custom set of users that are *guaranteed* to be there, so you can//! test against them.//! This module allows you to create these custom users and groups//! definitions, then access them using the same `Users` trait as in the main//! library, with few changes to your code.//! ## Creating Mock Users//! The only thing a mock users table needs to know in advance is the UID of//! the current user. Aside from that, you can add users and groups with//! `add_user` and `add_group` to the table://! use users::mock::{MockUsers, User, Group};//! use users::os::unix::{UserExt, GroupExt};//! let mut users = MockUsers::with_current_uid(1000);//! let bobbins = User::new(1000, "Bobbins", 1000).with_home_dir("/home/bobbins");//! users.add_user(bobbins);//! users.add_group(Group::new(100, "funkyppl"));//! The exports get re-exported into the mock module, for simpler `use` lines.//! ## Using Mock Users//! To set your program up to use either type of `Users` table, make your//! functions and structs accept a generic parameter that implements the `Users`//! trait. Then, you can pass in a value of either Cache or Mock type.//! Here’s a complete example://! use users::{Users, UsersCache, User};//! use users::os::unix::UserExt;//! use users::mock::MockUsers;//! fn print_current_username<U: Users>(users: &mut U) {//!     println!("Current user: {:?}", users.get_current_username());//! let mut users = MockUsers::with_current_uid(1001);//! users.add_user(User::new(1001, "fred", 101));//! print_current_username(&mut users);//! let mut actual_users = UsersCache::new();//! print_current_username(&mut actual_users);set_current_uid/// Sets the **current user** for the running process to the one with the/// given user ID./// Typically, trying to switch to anyone other than the user already running/// the process requires root privileges./// - [`setuid`](https://docs.rs/libc/*/libc/fn.setuid.html)/// `setuid` call./// use users::switch::set_current_uid;/// set_current_uid(1001);/// // current user ID is 1001set_current_gid/// Sets the **current group** for the running process to the one with the/// given group ID./// Typically, trying to switch to any group other than the group already/// running the process requires root privileges./// - [`setgid`](https://docs.rs/libc/*/libc/fn.setgid.html)/// `setgid` call./// use users::switch::set_current_gid;/// set_current_gid(1001);/// // current group ID is 1001set_effective_uid/// Sets the **effective user** for the running process to the one with the/// - [`seteuid`](https://docs.rs/libc/*/libc/fn.seteuid.html)/// `seteuid` call./// use users::switch::set_effective_uid;/// set_effective_uid(1001);/// // current effective user ID is 1001set_effective_gid/// Sets the **effective group** for the running process to the one with the/// - [`setegid`](https://docs.rs/libc/*/libc/fn.setegid.html)/// `setegid` call./// use users::switch::set_effective_gid;/// set_effective_gid(1001);/// // current effective group ID is 1001set_both_uid/// Sets both the **current user** and the **effective user** for the running/// process to the ones with the given user IDs./// - [`setreuid`](https://docs.rs/libc/*/libc/fn.setreuid.html)/// `setreuid` call./// use users::switch::set_both_uid;/// set_both_uid(1001, 1001);/// // current user ID and effective user ID are 1001set_both_gid/// Sets both the **current group** and the **effective group** for the/// running process to the ones with the given group IDs./// - [`setregid`](https://docs.rs/libc/*/libc/fn.setregid.html)/// `setregid` call./// use users::switch::set_both_gid;/// set_both_gid(1001, 1001);/// // current user ID and effective group ID are 1001SwitchUserGuard/// Guard returned from a `switch_user_group` call.switch_user_group/// Sets the **effective user** and the **effective group** for the current/// Typically, trying to switch to any user or group other than the ones already/// # Security considerations/// - Because Rust does not guarantee running the destructor, it’s a good idea///   to call [`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html)///   on the guard manually in security-sensitive situations./// - This function switches the group before the user to prevent the user’s///   privileges being dropped before trying to change the group (look up///   `POS36-C`)./// - This function will panic upon failing to set either walue, so the///   program does not continue executing with too many privileges./// This function will return `Err` when an I/O error occurs during either/// the `seteuid` or `setegid` calls./// use users::switch::switch_user_group;/// use std::mem::drop;///     let guard = switch_user_group(1001, 1001);///     // current and effective user and group IDs are 1001/// // back to the old values//! Functions for switching the running process’s user or group.// NOTE: for whatever reason, it seems these are not available in libc on BSD platforms, so they//       need to be included manually/// Returns a `User` if one exists for the given user ID; otherwise, returns `None`./// Returns a `User` if one exists for the given username; otherwise, returns `None`./// Returns the effective user id./// Returns the effective username./// Trait for producers of users./// Returns a `Group` if one exists for the given group ID; otherwise, returns `None`./// Returns a `Group` if one exists for the given groupname; otherwise, returns `None`./// Returns the group name of the user running the process./// Returns the effective group id./// Returns the effective group name./// Trait for producers of groups./// Reads data from a `*char` field in `c_passwd` or `g_group`. The return/// type will be an `Arc<OsStr>` if the text is meant to be shared in a cache,/// or a plain `OsString` if it’s not.//! let uid   = cache.get_current_uid();                          // OK...//! let user  = cache.get_user_by_uid(uid).unwrap();              // OK...//! let group = cache.get_group_by_gid(user.primary_group_id());  // No!// TODO: stop using ‘Arc::from’ with entry API// The ‘get_*_by_name’ functions below create a new Arc before even testing if// the user exists in the cache, essentially creating an unnecessary Arc.// https://internals.rust-lang.org/t/pre-rfc-abandonning-morals-in-the-name-of-performance-the-raw-entry-api/7043/51// https://github.com/rust-lang/rfcs/pull/1769LossyDecoderBufReadDecoderBufReadDecoderError/// The replacement character, U+FFFD. In lossy decoding, insert it for every decoding error.valid_prefix/// In lossy decoding insert `valid_prefix`, then `"\u{FFFD}"`,/// then call `decode()` again with `remaining_input`.incomplete_suffix/// Call the `incomplete_suffix.try_complete` method with more input when available./// If no more input is available, this is an invalid byte sequence.try_complete/// * `None`: still incomplete, call `try_complete` again with more input.///   If no more input is available, this is invalid byte sequence./// * `Some((result, remaining_input))`: We’re done with this `Incomplete`.///   To keep decoding, pass `remaining_input` to `decode()`.try_complete_offsets/// (consumed_from_input, None): not enough input/// (consumed_from_input, Some(Err(()))): error bytes in buffer/// (consumed_from_input, Some(Ok(()))): UTF-8 string in buffer/// A push-based, lossy decoder for UTF-8./// Errors are replaced with the U+FFFD replacement character./// Users “push” bytes into the decoder, which in turn “pushes” `&str` slices into a callback./// For example, `String::from_utf8_lossy` (but returning `String` instead of `Cow`)/// can be rewritten as:/// fn string_from_utf8_lossy(input: &[u8]) -> String {///     let mut string = String::new();///     utf8::LossyDecoder::new(|s| string.push_str(s)).feed(input);///     string/// **Note:** Dropping the decoder signals the end of the input:/// If the last input chunk ended with an incomplete byte sequence for a code point,/// this is an error and a replacement character is emitted./// Use `std::mem::forget` to inhibit this behavior./// Create a new decoder from a callback./// Feed one chunk of input into the decoder./// The input is decoded lossily/// and the callback called once or more with `&str` string slices./// If the UTF-8 byte sequence for one code point was split into this bytes chunk/// and previous bytes chunks, it will be correctly pieced back together./// Wraps a `std::io::BufRead` buffered byte stream and decode it as UTF-8.InvalidByteSequence/// Represents one UTF-8 error in the byte stream./// In lossy decoding, each such error should be replaced with U+FFFD./// (See `BufReadDecoder::next_lossy` and `BufReadDecoderError::lossy`.)/// An I/O error from the underlying byte stream/// Replace UTF-8 errors with U+FFFDread_to_string_lossy/// This is to `Read::read_to_string` what `String::from_utf8_lossy` is to `String::from_utf8`.next_lossy/// Same as `BufReadDecoder::next_strict`, but replace UTF-8 errors with U+FFFD.next_strict/// Decode and consume the next chunk of UTF-8 input./// This method is intended to be called repeatedly until it returns `None`,/// which represents EOF from the underlying byte stream./// This is similar to `Iterator::next`,/// except that decoded chunks borrow the decoder (~iterator)/// so they need to be handled or copied before the next chunk can start decoding.Utf16Errorvalid_up_to/// Returns the index in given bytes up to which valid UTF-16 was verified.error_len/// Return the length of the error if it is recoverable.///  - `None`: the end of the input was reached unexpectedly.///    [`Utf16Error::valid_up_to`] is 1 to 3 bytes from the end of the input.  If a byte///    stream such as a file or a network socket is being decoded incrementally, this///    could still be a valid char whose byte sequence is spanning multiple chunks./// - `Some(len)`: an unexpected byte was encountered.  The length provided is that of///   the invalid byte sequence that starts at the index given by///   [`Utf16Error::valid_up_to`].  Decoding should resume after that sequence (after///   inserting a [`U+FFFD REPLACEMENT CHARACTER`](std::char::REPLACEMENT_CHARACTER)) in///   case of lossy decoding.  In fact for UTF-16 the `len` reported here will always be///   exactly 2 since this never looks ahead to see if the bytes following the error///   sequence are valid as well as otherwise you would not know how many replacement///   characters to insert when writing a lossy decoder./// The semantics of this API are compatible with the semantics of/// [`Utf8Error`](std::str::Utf8Error).//! Implementations for [`Utf16Error`].decode_surrogatesis_leading_surrogateis_trailing_surrogateUtf16CharExtWStrCharIndicesWStrCharsWStrtest_wstr_charstest_wstr_chars_reversetest_wstr_chars_lasttest_wstr_chars_counttest_wstr_char_indicestest_wstr_char_indices_reversetest_wstr_char_indices_lasttest_wstr_char_indices_count//! Implementation for the various char iterators.//! The type itself lives in the lib.rs file to avoid having to have a public alias, but//! implementations live here.iterswstring/// Error for invalid UTF-16 encoded bytes.WString/// A UTF-16 [`String`]-like type with little- or big-endian byte order./// use utf16string::{LE, WString};/// let v = Vec::from(&b"h\x00e\x00l\x00l\x00o\x00"[..]);/// let s = WString::from_utf16le(v)?;/// let chars: Vec<char> = s.chars().collect();/// assert_eq!(chars, vec!['h', 'e', 'l', 'l', 'o']);/// assert_eq!(s.to_utf8(), "hello");/// Converting from valid Unicode is infallible:/// let s0: WString<LE> = WString::from("hello");/// assert_eq!(s0.len(), 10);/// let s1: WString<LE> = From::from("hello");/// assert_eq!(s0, s1);/// A UTF-16 [`str`]-like type with little- or big-endian byte order./// This mostly behaves like [`str`] does for UTF-8 encoded bytes slices, but works with/// UTF-16 encoded byte slices.  The endianess is determined by the type parameter./// use utf16string::{LE, WStr};/// let b = b"h\x00e\x00l\x00l\x00o\x00";/// let s: &WStr<LE> = WStr::from_utf16le(b)?;/// Iterator yielding [`char`] from a UTF-16 encoded byte slice./// The slice must contain valid UTF-16, otherwise this may panic or cause undefined/// Iterator yielding `(index, char)` tuples from a UTF-16 little-endian encoded byte slice.//! A UTF-16 little-endian string type.//! This crate provides two string types to handle UTF-16 encoded bytes directly as strings://! [`WString`] and [`WStr`].  They are to UTF-16 exactly like [`String`] and [`str`] are to//! UTF-8.  Some of the concepts and functions here are rather tersely documented, in this//! case you can look up their equivalents on [`String`] or [`str`] and the behaviour should//! be exactly the same, only the underlying byte encoding is different.//! Thus [`WString`] is a type which owns the bytes containing the string.  Just like//! [`String`] and the underlying [`Vec`] it is built on, it distinguishes length//! ([`WString::len`]) and capacity ([`String::capacity`]).  Here length is the number of//! bytes used while capacity is the number of bytes the string can grow withouth//! The [`WStr`] type does not own any bytes, it can only point to a slice of bytes//! containing valid UTF-16.  As such you will only ever use it as a reference like `&WStr`,//! just you you only use [`str`] as `&str`.//! The [`WString`] type implements `Deref<Target = WStr<ByteOrder>`//! # UTF-16 ByteOrder//! UTF-16 encodes to unsigned 16-bit integers ([`u16`]), denoting *code units*.  However//! different CPU architectures encode these [`u16`] integers using different byte order://! *little-endian* and *big-endian*.  Thus when handling UTF-16 strings you need to be//! aware of the byte order of the encoding, commonly the encoding variants are know as//! UTF-16LE and UTF-16BE respectively.//! For this crate this means the types need to be aware of the byte order, which is done//! using the [`byteorder::ByteOrder`] trait as a generic parameter to the types://! `WString<ByteOrder>` and `WStr<ByteOrder>` commonly written as `WString<E>` and//! `WStr<E>` where `E` stands for "endianess".//! This crate exports [`BigEndian`], [`BE`], [`LittleEndian`] and [`LE`] in case you need//! to denote the type://! use utf16string::{BigEndian, BE, WString};//! let s0: WString<BigEndian> = WString::from("hello");//! assert_eq!(s0.len(), 10);//! let s1: WString<BE> = WString::from("hello");//! assert_eq!(s0, s1);//! As these types can often be a bit cumbersome to write they can often be inferred,//! especially with the help of the shorthand constructors like [`WString::from_utf16le`],//! [`WString::from_utf16be`], [`WStr::from_utf16le`], [`WStr::from_utf16be`] and related.//! use utf16string::{LE, WStr};//! let b = b"h\x00e\x00l\x00l\x00o\x00";//! let s0: &WStr<LE> = WStr::from_utf16(b)?;//! let s1 = WStr::from_utf16le(b)?;//! assert_eq!(s0.to_utf8(), "hello");SealedSliceIndex/// The result of slicing, another slice of the same type as you started with normally./// Returns a shared reference to the output at this location, if in bounds./// Returns a mutable reference to the output at this location, if in bounds./// Like [`SliceIndex::get`] but without bounds checking./// You must guarantee the resulting slice is valid UTF-16LE, otherwise you will get/// undefined behaviour./// Like [`SliceIndex::get_mut`] but without bounds checking./// undefined behavour./// Returns a shared reference to the output at this location, panicking if out of bounds./// Returns a mutable reference to the output at this location, panicking if out of bounds./// Our own version of [`std::slice::SliceIndex`]./// Since this is a sealed trait, we need to re-define this trait.  This trait itself is/// sealed as well./// Implments substring slicing with syntax `&self[..]` or `&mut self[..]`./// Unlike other implementations this can never panic./// Implements substring slicing with syntax `&self[begin .. end]` or `&mut self[begin .. end]`./// Implements substring slicing with syntax `&self[.. end]` or `&mut self[.. end]`./// Implements substring slicing with syntax `&self[begin ..]` or `&mut self[begin ..]`./// Implements substring slicing with syntax `&self[begin ..= end]` or `&mut self[begin ..= end]`./// Implements substring slicing with syntax `&self[..= end]` or `&mut self[..= end]`.test_wstr_rangetest_wstr_range_totest_wstr_range_fromtest_wstr_range_fulltest_wstr_range_inclusivetest_wstr_range_to_inclusivetest_wstring_rangetest_wstring_range_totest_wstring_range_fromtest_wstring_range_fulltest_wstring_range_inclusivetest_wstring_range_to_inclusive//! The [`SliceIndex`] trait and implementations.//! This supports all slicing for [`WStr`] and [`WString`]./// Whether a code unit is a leading or high surrogate./// If a Unicode code point does not fit in one code unit (i.e. in one `u16`) it is split/// into two code units called a *surrogate pair*.  The first code unit of this pair is the/// *leading surrogate* and since it carries the high bits of the complete Unicode code/// point it is also known as the *high surrogate*./// These surrogate code units have the first 6 bits set to a fixed prefix identifying/// whether they are the *leading* or *trailing* code unit of the surrogate pair.  And for/// the leading surrogate this bit prefix is `110110`, thus all leading surrogates have a/// code unit between 0xD800-0xDBFF./// Whether a code unit is a trailing or low surrogate./// into two code units called a *surrogate pair*.  The second code unit of this pair is the/// *trailing surrogate* and since it carries the low bits of the complete Unicode code/// point it is also know as the *low surrogate*./// These surrogate code unites have the first 6 bits set to a fixed prefix identifying/// whether tye are the *leading* or *trailing* code unit of the surrogate pair.  Anf for/// the trailing surrogate this bit prefix is `110111`, thus all trailing surrogates have a/// code unit between 0xDC00-0xDFFF./// Decodes a surrogate pair of code units into a char./// This results in undefined behaviour if the code units do not form a valid surrogate/// pair.validate_raw_utf16/// Checks that the raw bytes are valid UTF-16LE./// When an error occurs this code needs to set `error_len` to skip forward 2 bytes,/// *unless* we have a lone leading surrogate and are at the end of the input slice in which/// case we need to return `None./// We compute `valid_up_to` lazily for performance, even though it's a little more verbose.encoded_utf16_len/// Returns the number of bytes this character encodes into./// The [`char::len_utf16`] method from the standard library returns the size in number/// of u16 code units instead of in bytes.  This provides a character length method/// which matches a string's length (`len`) definition.encode_utf16_into/// Encodes this char, writing it into a bytes buffer./// Panics if the destination buffer is too small./// Extension trait for UTF-16 utilities on [`char`].test_is_leading_surrogatetest_is_trailing_surrogatetest_wstr_utf16errortest_utf16_char_ext_encode_utf16_intotest_utf16_char_ext_encode_utf16_into_too_small_single_unittest_utf16_char_ext_encode_utf16_into_too_small_surrogatetest_utf16_char_ext_len_utf16_bytes//! UTF-16 helper utilities.from_utf16le/// Creates a new `&WStr<LE>`.from_utf16le_mut/// Creates a new `&mut WStr<LE>`.from_utf16le_unchecked/// Creates a new [WStr] with little-endian byte-ordering./// This is a shortcut to easily create `WStr<LE>` without having to specify the type/// explicitly./// let b = b"h\x00i\x00";/// let s: &WStr<LE> = unsafe { WStr::from_utf16_unchecked(b) };/// let t = unsafe { WStr::from_utf16le_unchecked(b) };/// assert_eq!(s, t);/// You must guarantee that the buffer passed in is encoded correctly as UTF-16 with/// little-endian byte-order, otherwise you will get undefined behaviour.from_utf16le_unchecked_mut/// Creates a new `&WStr<BE>`.from_utf16be_mut/// Creates a new `&mut WStr<BE>`.from_utf16be_unchecked/// Creates a new `&WStr<BE>` from an existing byte-slice with big-endian byte-ordering./// This is a shortcut to easily create `WStr<BE>` without having to specify the type/// use utf16string::{BE, WStr};/// let s: &WStr<BE> = unsafe { WStr::from_utf16_unchecked(b) };/// let t = unsafe { WStr::from_utf16be_unchecked(b) };/// big-endian byte-order, otherwise you will get undefined behaviour.from_utf16be_unchecked_mutfrom_utf16/// Creates a new `&WStr<E>` from an existing UTF-16 byte-slice./// If the byte-slice is not valid [`Utf16Error`] is returned.from_utf16_mut/// Creates a new `&mut WStr<E>` from an existing UTF-16 byte-slice.from_utf16_unchecked/// You must guarantee that the buffer passed in is encoded correctly otherwise you will/// get undefined behaviour.  Be aware of the byte-level endianess.from_utf16_unchecked_mut/// Like [`WStr::from_utf16_unchecked`] but return a mutable reference./// get undefined behaviour./// The length in bytes, not chars or graphemes./// Returns `true` if the [WStr::len] is zero./// Returns `true` if the index into the bytes is on a char boundary./// Converts to a byte slice./// Converts to a mutable byte slice./// When mutating the bytes it must still be valid encoded UTF-16 with the correct/// byte-order, otherwise you will get undefined behaviour./// Converts to a raw pointer to the byte slice./// This is currently not `const fn` because this is not yet stable with a trait bound./// Converts to a mutable raw pointer to the byte slice./// Returns a subslice of `self`./// The slice indices are on byte offsets of the underlying UTF-16 encoded buffer, if/// the subslice is not on character boundaries or otherwise invalid this will return/// [`None`]./// Returns a mutable subslice of `self`./// Like [`WStr::get`] but this results in undefined behaviour if the sublice is not on/// character boundaries or otherwise invalid./// Lice [`WStr::get_mut`] but this results in undefined behaviour if the subslice is/// not on character boundaries or otherwise invalid./// Returns an iterator of the [`char`]s of a string slice./// Returns and iterator over the [`char`]s of a string slice and their positions./// Returns this [`WStr`] as a new owned [`String`]./// Returns `true` if all characters in the string are ASCII.test_wstr_from_utf16letest_wstr_from_utf16le_uncheckedtest_wstr_lentest_wstr_is_emptytest_wstr_is_char_boundarytest_wstr_as_bytestest_wstr_as_bytes_muttest_wstr_gettest_wstr_get_muttest_wstr_slicetest_wstr_bad_indextest_wstr_to_utf8test_wstr_is_asciitest_wstr_as_ref//! Implementations for the [`WStr`] type.//! The type itself lives in the `lib.rs` file to avoid having to have a public alias, but/// Creates a new [`WString`] from raw bytes in little-endian byte order./// Converts a vector of bytes to a [`WString`], not checking validity./// You must ensure the vector contains already valid UTF-16 with little-endian/// Creates a new [`WString`] from raw bytes in big-endian byte-order./// You must ensure the vector contains already valid UTF-16 with big-endian byte-order,/// otherwise you will get undefined behaviour./// Creates a new empty [`WString`]./// Creates a new empty [`WString`] with a capacity./// Converts a vector of bytes to a [`WString`]./// You must ensure the vector contains already valid UTF-16 in the correct byte-order,/// Converts this string into a byte vector.as_wstr/// Returns a `&WStr` slice containing the entire string.as_mut_wstr/// Returns a `&mut WStr` slice containing the entire string.push_wstr/// Appends a string slice onto the end of this string./// Returns the capacity in bytes./// Ensure that this string has spare capacity of at least `additional` bytes./// Shrinks the capacity of this string to match its length./// Appends the given [`char`] to the end of this string./// Shortens this string to the specified length./// The `new_len` is specified in bytes and not characters, just as [WString::len]/// returns the length in bytes.  If `new_len` is greater than the string's current/// length, this has no effect./// Note that this method has no effect on the allocated capacity of the string./// Panics if `new_len` does not lie on a [char] boundary./// Removes the last character from the string buffer and returns it./// Returns [`None`] if this string is empty./// Removes a [`char`] from this string at the given byte position and returns it./// This is an `O(n)` operation as it requires copying every element in the buffer./// Panics if `idx` is larger than or equal to the string's length, or if it does not/// lie on a [`char`] boundary./// Retains only the characters specified by the predicate./// Inserts a [`char`] into this string at the given byte position./// Panics if `idx` is larger than the string's length or if it does not lie on a/// [`char`] boundary.insert_bytesinsert_wstr/// Inserts a string slice into this string at the given byte position./// This is an `O(n)` operation as it requires copying every element in the buffer.  The/// string slice must have the same endianess.as_mut_vec/// Returns a mutable reference to the contents of this string./// You must ensure that the bytes remain encoded in UTF-16 with the correct byte-order,/// otherwise you will get undefined behaviour trying to use the string./// Returns the length in bytes, not chars or graphemes./// Returns `true` if the string has a [`WString::len`] of zero, `false` otherwise."use `.truncate()` if you don't need the other half"/// Splits the string into two at the given index./// Returns a newly allocated [`WString`].  `self` contains bytes `[0..at]` and the/// returned [WString] contains bytes `[at..len]]`./// Panics if `at` is not on a character boundary or is beyond the end of the string./// Truncates this string, removing all contents./// The length will be zero, but the capacity will remain unchanged.test_from_utf16test_from_utf16_le_betest_from_utf16_uncheckedtest_from_stringtest_into_bytestest_as_wstrtest_as_mut_wstrtest_push_wstrtest_reservetest_shrink_to_fittest_truncate_no_char_boundarytest_poptest_insert_wstrtest_as_mut_vectest_split_offtest_split_off_bad_indextest_dereftest_deref_mut//! Implementations for the [`WString`] type.MIN_0_1MAX_0_1MIN_0_2MAX_0_2MIN_1MAX_1MIN_2MAX_2MIN_3MAX_3MIN_4MAX_4is_width_1is_width_2is_width_3is_width_4is_width_0/// Given a first byte, determine how many bytes are in this UTF-8 character. If the UTF-8 character is invalid, return `0`; otherwise, return `1` to `4`.get_width_assume_valid/// *Assuming the input first byte is from a valid UTF-8 character*, determine how many bytes are in this UTF-8 character. It returns `1` to `4`./// You must ensure that the input byte is a valid UTF-8 first byte on your own./*!
# UTF-8 Width

To determine the width of a UTF-8 character by providing its first byte.

References: https://tools.ietf.org/html/rfc3629

## Examples

```rust
assert_eq!(1, utf8_width::get_width(b'1'));
assert_eq!(3, utf8_width::get_width("中".as_bytes()[0]));
```

## Benchmark

```bash
cargo bench
```
*//// Called whenever a codepoint is parsed successfully/// Called when an invalid_sequence is detected/// Handles codepoint and invalid sequence events from the parser./// A parser for Utf8 Characters/// Repeatedly call `advance` with bytes to emit Utf8 charactersCONTINUATION_MASK/// Continuation bytes are masked with this value./// Advance the parser/// The provider receiver will be called whenever a codepoint is completed or an invalid/// sequence is detected.//! A table-driven UTF-8 Parser//! This module implements a table-driven UTF-8 parser which should//! theoretically contain the minimal number of branches (1). The only branch is//! on the `Action` returned from unpacking a transition.InvalidSequence/// Unexpected byte; sequence is invalidEmitByte/// Received valid 7-bit ASCII byte which can be directly emitted.SetByte1/// Set the bottom continuation byteSetByte2/// Set the 2nd-from-last continuation byteSetByte2Top/// Set the 2nd-from-last byte which is part of a two byte sequenceSetByte3/// Set the 3rd-from-last continuation byteSetByte3Top/// Set the 3rd-from-last byte which is part of a three byte sequenceSetByte4/// Set the top byte of a four byte sequence./// Action to take when receiving a byte/// Ground state; expect anythingTail3/// 3 tail bytesTail2/// 2 tail bytesTail1/// 1 tail byteU3_2_e0/// UTF8-3 starting with E0U3_2_ed/// UTF8-3 starting with EDUtf8_4_3_f0/// UTF8-4 starting with F0Utf8_4_3_f4/// UTF8-4 starting with F4/// States the parser can be in./// There is a state for each initial input of the 3 and 4 byte sequences since/// the following bytes are subject to different conditions than a tail byte./// Advance the parser state./// This takes the current state and input byte into consideration, to determine the next state/// and any action that should be taken.//! Types supporting the UTF-8 parser/// A builder for creating a UUID./// This type is useful if you need to mutate individual fields of a [`Uuid`]/// while constructing it. Since the [`Uuid`] type is `Copy`, it doesn't offer/// any methods to mutate in place. They live on the `Builder` instead./// The `Builder` type also always exposes APIs to construct [`Uuid`]s for any/// version without needing crate features or additional dependencies. It's a/// lower-level API than the methods on [`Uuid`]./// Creating a version 4 UUID from externally generated random bytes:/// # use uuid::{Builder, Version, Variant};/// # let rng = || [/// #     70, 235, 208, 238, 14, 109, 67, 201, 185, 13, 204, 195, 90,/// # 145, 63, 62,/// let random_bytes = rng();/// let uuid = Builder::from_random_bytes(random_bytes).into_uuid();/// assert_eq!(Some(Version::Random), uuid.get_version());/// assert_eq!(Variant::RFC4122, uuid.get_variant());/// The 'nil UUID' (all zeros)./// The nil UUID is a special form of UUID that is specified to have all/// 128 bits set to zero./// * [Nil UUID in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.9)/// # use uuid::Uuid;/// let uuid = Uuid::nil();///     "00000000-0000-0000-0000-000000000000",///     uuid.hyphenated().to_string(),/// The 'max UUID' (all ones)./// The max UUID is a special form of UUID that is specified to have all/// 128 bits set to one./// * [Max UUID in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.10)/// let uuid = Uuid::max();///     "ffffffff-ffff-ffff-ffff-ffffffffffff",/// Creates a UUID from four field values./// let d1 = 0xa1a2a3a4;/// let d2 = 0xb1b2;/// let d3 = 0xc1c2;/// let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];/// let uuid = Uuid::from_fields(d1, d2, d3, &d4);///     "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",from_fields_le/// Creates a UUID from four field values in little-endian order./// The bytes in the `d1`, `d2` and `d3` fields will be flipped to convert/// into big-endian order. This is based on the endianness of the UUID,/// rather than the target environment so bytes will be flipped on both/// big and little endian machines./// let uuid = Uuid::from_fields_le(d1, d2, d3, &d4);///     "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8",/// Creates a UUID from a 128bit value./// let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128;/// let uuid = Uuid::from_u128(v);from_u128_le/// Creates a UUID from a 128bit value in little-endian order./// The entire value will be flipped to convert into big-endian order./// This is based on the endianness of the UUID, rather than the target/// environment so bytes will be flipped on both big and little endian/// machines./// let uuid = Uuid::from_u128_le(v);///     "d8d7d6d5-d4d3-d2d1-c2c1-b2b1a4a3a2a1",from_u64_pair/// Creates a UUID from two 64bit values./// let hi = 0xa1a2a3a4b1b2c1c2u64;/// let lo = 0xd1d2d3d4d5d6d7d8u64;/// let uuid = Uuid::from_u64_pair(hi, lo);/// Creates a UUID using the supplied bytes./// This function will return an error if `b` has any length other than 16./// # fn main() -> Result<(), uuid::Error> {///     0xa1, 0xa2, 0xa3, 0xa4,///     0xb1, 0xb2,///     0xc1, 0xc2,///     0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,/// let uuid = Uuid::from_slice(&bytes)?;from_slice_le/// Creates a UUID using the supplied bytes in little endian order./// The individual fields encoded in the buffer will be flipped./// let uuid = Uuid::from_slice_le(&bytes)?;///     "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8"/// let uuid = Uuid::from_bytes(bytes);///     "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"/// let uuid = Uuid::from_bytes_le(bytes);from_bytes_ref/// Creates a reference to a UUID from a reference to the supplied bytes./// let uuid = Uuid::from_bytes_ref(&bytes);///     uuid as *const Uuid as *const u8,///     &bytes as *const [u8; 16] as *const u8,// NOTE: There is no `from_u128_ref` because in little-endian// environments the value isn't properly encoded. Callers would// need to use `.to_be()` themselves./// Creates a `Builder` using the supplied bytes./// # use uuid::Builder;/// let uuid = Builder::from_bytes(bytes).into_uuid();/// Creates a `Builder` using the supplied bytes in little endian order./// # use uuid::{Builder, Uuid};/// let uuid = Builder::from_bytes_le(bytes).into_uuid();from_gregorian_timestamp/// Creates a `Builder` for a version 1 UUID using the supplied timestamp, counter, and node ID.from_md5_bytes/// Creates a `Builder` for a version 3 UUID using the supplied MD5 hashed bytes.from_random_bytes/// Creates a `Builder` for a version 4 UUID using the supplied random bytes./// This method assumes the bytes are already sufficiently random, it will only/// set the appropriate bits for the UUID version and variant./// # use uuid::{Builder, Variant, Version};from_sha1_bytes/// Creates a `Builder` for a version 5 UUID using the supplied SHA-1 hashed bytes./// This method assumes the bytes are already a SHA-1 hash, it will only set the appropriate/// bits for the UUID version and variant.from_sorted_gregorian_timestamp/// Creates a `Builder` for a version 6 UUID using the supplied timestamp, counter, and node ID./// This method will encode the ticks, counter, and node ID in a sortable UUID.from_unix_timestamp_millis/// Creates a `Builder` for a version 7 UUID using the supplied Unix timestamp and counter bytes./// This method will set the variant field within the counter bytes without attempting to shift/// the data around it. Callers using the counter as a monotonic value should be careful not to/// store significant data in the 2 least significant bits of the 3rd byte./// Creating a UUID using the current system timestamp:/// use std::time::{Duration, SystemTime};/// # use uuid::{Builder, Uuid, Variant, Version, Timestamp, NoContext};/// #     70, 235, 208, 238, 14, 109, 67, 201, 185, 13/// let ts = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;/// let uuid = Builder::from_unix_timestamp_millis(ts.as_millis().try_into()?, &random_bytes).into_uuid();/// assert_eq!(Some(Version::SortRand), uuid.get_version());from_custom_bytes/// Creates a `Builder` for a version 8 UUID using the supplied user-defined bytes./// This method won't interpret the given bytes in any way, except to set the appropriate/// let uuid = Builder::from_slice(&bytes)?.into_uuid();/// let uuid = Builder::from_slice_le(&bytes)?.into_uuid();/// Creates a `Builder` from four field values./// let uuid = Builder::from_fields(d1, d2, d3, &d4).into_uuid();/// let uuid = Builder::from_fields_le(d1, d2, d3, &d4).into_uuid();/// Creates a `Builder` from a 128bit value./// let uuid = Builder::from_u128(v).into_uuid();/// let uuid = Builder::from_u128_le(v).into_uuid();/// Creates a `Builder` with an initial [`Uuid::nil`]./// let uuid = Builder::nil().into_uuid();/// Specifies the variant of the UUID./// Specifies the version number of the UUID.with_versionas_uuid/// Get a reference to the underlying [`Uuid`]./// let builder = Builder::nil();/// let uuid1 = builder.as_uuid();/// let uuid2 = builder.as_uuid();/// assert_eq!(uuid1, uuid2);into_uuid/// Convert the builder into a [`Uuid`].///     "00000000-0000-0000-0000-000000000000"from_rfc4122_timestampfrom_sorted_rfc4122_timestamp// Copyright 2013-2014 The Rust Project Developers.// Copyright 2018 The Uuid Project Developers.//! A Builder type for [`Uuid`]s.//! [`Uuid`]: ../struct.Uuid.html/// A general error that can occur when working with UUIDs./// Invalid character in the [`Uuid`] string./// [`Uuid`]: ../struct.Uuid.htmlSimpleLength/// A simple [`Uuid`] didn't contain 32 characters.ByteLength/// A byte array didn't contain 16 bytesGroupCount/// A hyphenated [`Uuid`] didn't contain 5 groupsGroupLength/// A hyphenated [`Uuid`] had a group that wasn't the right length/// The input was not a valid UTF8 stringNil/// The UUID is nil./// Some other error occurred.InvalidUuid/// A string that is guaranteed to fail to parse to a [`Uuid`]./// This type acts as a lightweight error indicator, suggesting/// that the string cannot be parsed but offering no error/// details. To get details, use `InvalidUuid::into_err`.into_err/// Converts the lightweight error type into detailed diagnostics.// NOTE: This impl is part of the public API. Breaking changes to it should be carefully consideredNonNilUuidtest_arbitrary_emptytest_arbitrary_non_nilHyphenatedUrnExpectedFormat/// Serialize from a [`Uuid`] as a `[u8; 16]`/// [`Uuid`]: ../../struct.Uuid.html/// Deserialize a `[u8; 16]` as a [`Uuid`]test_serialize_compact//! Serialize a [`Uuid`] as a `[u8; 16]`.//! [`Uuid`]: ../../struct.Uuid.htmlparse_simple/// Serialize from a [`Uuid`] as a `uuid::fmt::Simple`/// #[derive(serde_derive::Serialize)]///     // This will be serialize as uuid::fmt::Simple///     #[serde(serialize_with = "uuid::serde::simple::serialize")]///     id: uuid::Uuid,/// Deserialize a simple Uuid string as a [`Uuid`]HYPHENATED_UUID_STRSIMPLE_UUID_STRtest_serialize_as_simpletest_de_from_simpletest_de_reject_hypenated/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]/// struct StructA {///     // This will change both serailization and deserialization///     #[serde(with = "uuid::serde::simple")]/// struct StructB {///     // This will be serialized as uuid::fmt::Simple and deserialize from all valid formatsparse_braced/// Serialize from a [`Uuid`] as a `uuid::fmt::Braced`///     // This will be serialize as uuid::fmt::Braced///     #[serde(serialize_with = "uuid::serde::braced::serialize")]/// Deserialize a braced Uuid string as a [`Uuid`]BRACED_UUID_STRtest_serialize_as_bracedtest_de_from_braced///     #[serde(with = "uuid::serde::braced")]///     // This will be serialized as uuid::fmt::Urn and deserialize from all valid formatsparse_urn/// Serialize from a [`Uuid`] as a `uuid::fmt::Urn`///     // This will be serialize as uuid::fmt::Urn///     #[serde(serialize_with = "uuid::serde::urn::serialize")]/// Deserialize a urn Uuid string as a [`Uuid`]URN_UUID_STRtest_serialize_as_urntest_de_from_urnurn///     #[serde(with = "uuid::serde::urn")]test_serialize_readable_stringtest_deserialize_readable_compacttest_deserialize_readable_bytestest_serialize_hyphenatedtest_serialize_urntest_serialize_bracedtest_serialize_non_human_readabletest_de_failuretest_serde_non_nil_uuidserde_testsslogcrittest_slog_kv/// Format a [`Uuid`] as a hyphenated string, like/// `67e55044-10b1-426f-9247-bb680e5fe0c8`./// Format a [`Uuid`] as a simple string, like/// `67e5504410b1426f9247bb680e5fe0c8`./// Format a [`Uuid`] as a URN string, like/// `urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8`./// Format a [`Uuid`] as a braced hyphenated string, like/// `{67e55044-10b1-426f-9247-bb680e5fe0c8}`.hyphenated/// Get a [`Hyphenated`] formatter.as_hyphenated/// Get a borrowed [`Hyphenated`] formatter./// Get a [`Simple`] formatter.as_simple/// Get a borrowed [`Simple`] formatter./// Get a [`Urn`] formatter.as_urn/// Get a borrowed [`Urn`] formatter./// Get a [`Braced`] formatter.as_braced/// Get a borrowed [`Braced`] formatter.format_simpleformat_hyphenatedencode_simpleencode_hyphenatedencode_bracedencode_urn/// The length of a hyphenated [`Uuid`] string.from_uuid/// Creates a [`Hyphenated`] from a [`Uuid`]./// [`Hyphenated`]: struct.Hyphenated.htmlencode_lower/// Writes the [`Uuid`] as a lower-case hyphenated string to/// `buffer`, and returns the subslice of the buffer that contains the/// encoded UUID./// This is slightly more efficient than using the formatting/// infrastructure as it avoids virtual calls, and may avoid/// double buffering./// Panics if the buffer is not large enough: it must have length at least/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a/// sufficiently-large temporary buffer./// [`LENGTH`]: #associatedconstant.LENGTH/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer/// use uuid::Uuid;/// fn main() -> Result<(), uuid::Error> {///     let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8")?;///     // the encoded portion is returned///         uuid.hyphenated()///             .encode_lower(&mut Uuid::encode_buffer()),///         "936da01f-9abd-4d9d-80c7-02af85c822a8"///     // the buffer is mutated directly, and trailing contents remains///     let mut buf = [b'!'; 40];///     uuid.hyphenated().encode_lower(&mut buf);///         &buf as &[_],///         b"936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_]/// Writes the [`Uuid`] as an upper-case hyphenated string to///     let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8")?;///             .encode_upper(&mut Uuid::encode_buffer()),///         "936DA01F-9ABD-4D9D-80C7-02AF85C822A8"///     uuid.hyphenated().encode_upper(&mut buf);///         b"936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_]/// let hyphenated = Uuid::nil().hyphenated();/// assert_eq!(*hyphenated.as_uuid(), Uuid::nil());/// Consumes the [`Hyphenated`], returning the underlying [`Uuid`]./// assert_eq!(hyphenated.into_uuid(), Uuid::nil());/// The length of a braced [`Uuid`] string./// Creates a [`Braced`] from a [`Uuid`]./// [`Braced`]: struct.Braced.html/// Writes the [`Uuid`] as a lower-case hyphenated string surrounded by/// braces to `buffer`, and returns the subslice of the buffer that contains/// the encoded UUID.///         uuid.braced()///         "{936da01f-9abd-4d9d-80c7-02af85c822a8}"///     uuid.braced().encode_lower(&mut buf);///         b"{936da01f-9abd-4d9d-80c7-02af85c822a8}!!" as &[_]/// Writes the [`Uuid`] as an upper-case hyphenated string surrounded by///         "{936DA01F-9ABD-4D9D-80C7-02AF85C822A8}"///     uuid.braced().encode_upper(&mut buf);///         b"{936DA01F-9ABD-4D9D-80C7-02AF85C822A8}!!" as &[_]/// let braced = Uuid::nil().braced();/// assert_eq!(*braced.as_uuid(), Uuid::nil());/// Consumes the [`Braced`], returning the underlying [`Uuid`]./// assert_eq!(braced.into_uuid(), Uuid::nil());/// The length of a simple [`Uuid`] string./// Creates a [`Simple`] from a [`Uuid`]./// [`Simple`]: struct.Simple.html/// Writes the [`Uuid`] as a lower-case simple string to `buffer`,/// and returns the subslice of the buffer that contains the encoded UUID.///         uuid.simple().encode_lower(&mut Uuid::encode_buffer()),///         "936da01f9abd4d9d80c702af85c822a8"///     let mut buf = [b'!'; 36];///         uuid.simple().encode_lower(&mut buf),///         b"936da01f9abd4d9d80c702af85c822a8!!!!" as &[_]/// Writes the [`Uuid`] as an upper-case simple string to `buffer`,///         uuid.simple().encode_upper(&mut Uuid::encode_buffer()),///         "936DA01F9ABD4D9D80C702AF85C822A8"///         uuid.simple().encode_upper(&mut buf),///         b"936DA01F9ABD4D9D80C702AF85C822A8!!!!" as &[_]/// let simple = Uuid::nil().simple();/// assert_eq!(*simple.as_uuid(), Uuid::nil());/// Consumes the [`Simple`], returning the underlying [`Uuid`]./// assert_eq!(simple.into_uuid(), Uuid::nil());/// The length of a URN [`Uuid`] string./// Creates a [`Urn`] from a [`Uuid`]./// [`Urn`]: struct.Urn.html/// Writes the [`Uuid`] as a lower-case URN string to///         uuid.urn().encode_lower(&mut Uuid::encode_buffer()),///         "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8"///     let mut buf = [b'!'; 49];///     uuid.urn().encode_lower(&mut buf);///         uuid.urn().encode_lower(&mut buf),///         b"urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_]/// Writes the [`Uuid`] as an upper-case URN string to///         uuid.urn().encode_upper(&mut Uuid::encode_buffer()),///         "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8"///         uuid.urn().encode_upper(&mut buf),///         b"urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_]/// let urn = Uuid::nil().urn();/// assert_eq!(*urn.as_uuid(), Uuid::nil());/// Consumes the [`Urn`], returning the underlying [`Uuid`]./// assert_eq!(urn.into_uuid(), Uuid::nil());impl_fmt_traitsimpl_fmt_fromhyphenated_trailinghyphenated_ref_trailingsimple_trailingsimple_ref_trailingurn_trailingurn_ref_trailingbraced_trailingbraced_ref_trailinghyphenated_too_smallsimple_too_smallurn_too_smallbraced_too_smallhyphenated_to_innersimple_to_innerurn_to_innerbraced_to_inner//! Adapters for alternative string formats.ClockSequence/// A 128-bit (16 byte) buffer containing the UUID./// # ABI/// The `Bytes` type is always guaranteed to be have the same ABI as [`Uuid`].0u8/// The "nil" (all zeros) UUID./// Version 1: Timestamp and node ID.Dce/// Version 2: DCE Security./// Version 3: MD5 hash./// Version 4: Random./// Version 5: SHA-1 hash.SortMac/// Version 6: Sortable Timestamp and node ID.SortRand/// Version 7: Timestamp and random./// Version 8: Custom./// The "max" (all ones) UUID./// The version of the UUID, denoting the generating algorithm./// * [Version Field in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-4.2)NCS/// Reserved by the NCS for backward compatibility.RFC4122/// As described in the RFC 9562 Specification (default)./// (for backward compatibility it is not yet renamed)/// Reserved by Microsoft for backward compatibility./// Reserved for future expansion./// The reserved variants of UUIDs./// * [Variant Field in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-4.1)/// A Universally Unique Identifier (UUID)./// Parse a UUID given in the simple format and print it as a urn:/// let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?;/// println!("{}", my_uuid.urn());/// Create a new random (V4) UUID and print it out in hexadecimal form:/// // Note that this requires the `v4` feature enabled in the uuid crate./// # #[cfg(feature = "v4")] {/// let my_uuid = Uuid::new_v4();/// println!("{}", my_uuid);/// A UUID can be formatted in one of a few ways:/// * [`simple`](#method.simple): `a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8`./// * [`hyphenated`](#method.hyphenated):///   `a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8`./// * [`urn`](#method.urn): `urn:uuid:A1A2A3A4-B1B2-C1C2-D1D2-D3D4D5D6D7D8`./// * [`braced`](#method.braced): `{a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8}`./// The default representation when formatting a UUID with `Display` is/// hyphenated:///     my_uuid.to_string(),/// Other formats can be specified using adapter methods on the UUID:///     "urn:uuid:a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",///     my_uuid.urn().to_string(),/// # Endianness/// The specification for UUIDs encodes the integer fields that make up the/// value in big-endian order. This crate assumes integer inputs are already in/// the correct order by default, regardless of the endianness of the/// environment. Most methods that accept integers have a `_le` variant (such as/// `from_fields_le`) that assumes any integer values will need to have their/// bytes flipped, regardless of the endianness of the environment./// Most users won't need to worry about endianness unless they need to operate/// on individual fields (such as when converting between Microsoft GUIDs). The/// important things to remember are:/// - The endianness is in terms of the fields of the UUID, not the environment./// - The endianness is assumed to be big-endian when there's no `_le` suffix///   somewhere./// - Byte-flipping in `_le` methods applies to each integer./// - Endianness roundtrips, so if you create a UUID with `from_fields_le`///   you'll get the same values back out with `to_fields_le`./// The `Uuid` type is always guaranteed to be have the same ABI as [`Bytes`].// NOTE: Also check `NonNilUuid` when ading new derives hereNAMESPACE_DNS/// UUID namespace for Domain Name System (DNS).NAMESPACE_OID/// UUID namespace for ISO Object Identifiers (OIDs).NAMESPACE_URL/// UUID namespace for Uniform Resource Locators (URLs).NAMESPACE_X500/// UUID namespace for X.500 Distinguished Names (DNs).get_variant/// Returns the variant of the UUID structure./// This determines the interpretation of the structure of the UUID./// This method simply reads the value of the variant byte. It doesn't/// validate the rest of the UUID as conforming to that variant./// # use uuid::{Uuid, Variant};/// let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;/// assert_eq!(Variant::RFC4122, my_uuid.get_variant());get_version_num/// Returns the version number of the UUID./// This represents the algorithm used to generate the value./// This method is the future-proof alternative to [`Uuid::get_version`]./// assert_eq!(3, my_uuid.get_version_num());/// Returns the version of the UUID./// If the version field doesn't contain a recognized version then `None`/// is returned. If you're trying to read the version for a future extension/// you can also use [`Uuid::get_version_num`] to unconditionally return a/// number. Future extensions may start to return `Some` once they're/// standardized and supported./// # use uuid::{Uuid, Version};/// assert_eq!(Some(Version::Md5), my_uuid.get_version());as_fields/// Returns the four field values of the UUID./// These values can be passed to the [`Uuid::from_fields`] method to get/// the original `Uuid` back./// * The first field value represents the first group of (eight) hex///   digits, taken as a big-endian `u32` value.  For V1 UUIDs, this field///   represents the low 32 bits of the timestamp./// * The second field value represents the second group of (four) hex///   digits, taken as a big-endian `u16` value.  For V1 UUIDs, this field///   represents the middle 16 bits of the timestamp./// * The third field value represents the third group of (four) hex digits,///   taken as a big-endian `u16` value.  The 4 most significant bits give///   the UUID version, and for V1 UUIDs, the last 12 bits represent the///   high 12 bits of the timestamp./// * The last field value represents the last two groups of four and twelve///   hex digits, taken in order.  The first 1-3 bits of this indicate the///   UUID variant, and for V1 UUIDs, the next 13-15 bits indicate the clock///   sequence and the last 48 bits indicate the node ID./// assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8]));/// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;///     uuid.as_fields(),///     (///         0xa1a2a3a4,///         0xb1b2,///         0xc1c2,///         &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8],to_fields_le/// Returns the four field values of the UUID in little-endian order./// The bytes in the returned integer fields will be converted from/// big-endian order. This is based on the endianness of the UUID,///     uuid.to_fields_le(),///         0xa4a3a2a1,///         0xb2b1,///         0xc2c1,/// Returns a 128bit value containing the value./// The bytes in the UUID will be packed directly into a `u128`.///     uuid.as_u128(),///     0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8,to_u128_le/// Returns a 128bit little-endian value containing the value./// The bytes in the `u128` will be flipped to convert into big-endian/// order. This is based on the endianness of the UUID, rather than the/// target environment so bytes will be flipped on both big and little/// endian machines./// Note that this will produce a different result than/// [`Uuid::to_fields_le`], because the entire UUID is reversed, rather/// than reversing the individual fields in-place.///     uuid.to_u128_le(),///     0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1,as_u64_pair/// Returns two 64bit values containing the value./// The bytes in the UUID will be split into two `u64`./// The first u64 represents the 64 most significant bits,/// the second one represents the 64 least significant.///     uuid.as_u64_pair(),///     (0xa1a2a3a4b1b2c1c2, 0xd1d2d3d4d5d6d7d8),/// Returns a slice of 16 octets containing the value./// This method borrows the underlying byte value of the UUID./// let bytes1 = [/// let uuid1 = Uuid::from_bytes_ref(&bytes1);/// let bytes2 = uuid1.as_bytes();/// let uuid2 = Uuid::from_bytes_ref(bytes2);///     uuid2 as *const Uuid as *const u8,///     &bytes1 as *const [u8; 16] as *const u8,/// Consumes self and returns the underlying byte value of the UUID./// assert_eq!(bytes, uuid.into_bytes());/// Returns the bytes of the UUID in little-endian order./// The bytes will be flipped to convert into little-endian order. This is/// based on the endianness of the UUID, rather than the target environment/// so bytes will be flipped on both big and little endian machines.///     uuid.to_bytes_le(),///     ([///         0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2,///         0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8is_nil/// Tests if the UUID is nil (all zeros)./// Tests if the UUID is max (all ones).encode_buffer/// A buffer that can be used for `encode_...` calls, that is/// guaranteed to be long enough for any of the format adapters.///     uuid.simple().encode_lower(&mut Uuid::encode_buffer()),///     "00000000000000000000000000000000"///     uuid.hyphenated()///         .encode_lower(&mut Uuid::encode_buffer()),///     uuid.urn().encode_lower(&mut Uuid::encode_buffer()),///     "urn:uuid:00000000-0000-0000-0000-000000000000"/// If the UUID is the correct version (v1, v6, or v7) this will return/// the timestamp in a version-agnostic [`Timestamp`]. For other versions/// this will return `None`./// # Roundtripping/// This method is unlikely to roundtrip a timestamp in a UUID due to the way/// UUIDs encode timestamps. The timestamp returned from this method will be truncated to/// 100ns precision for version 1 and 6 UUIDs, and to millisecond precision for version 7 UUIDs.get_node_id/// If the UUID is the correct version (v1, or v6) this will return the/// node value as a 6-byte array. For other versions this will return `None`.test_uuid_comparetest_uuid_defaulttest_uuid_displaytest_uuid_lowerhextest_uuid_operator_eq// noinspection RsAssertEqualtest_uuid_to_stringtest_non_conformingtest_niltest_predefined_namespacestest_get_timestamp_unsupported_versiontest_get_node_id_unsupported_versiontest_get_varianttest_to_simple_stringtest_hyphenated_stringtest_upper_lower_hextest_to_urn_stringtest_to_simple_string_matchingtest_string_roundtriptest_from_fieldstest_from_fields_letest_as_fieldstest_fields_roundtriptest_fields_le_roundtriptest_fields_le_are_actually_letest_from_u128test_from_u128_letest_from_u64_pairtest_u128_roundtriptest_u128_le_roundtriptest_u64_pair_roundtriptest_u128_le_is_actually_letest_from_bytestest_convert_vectest_bytes_roundtriptest_bytes_le_roundtriptest_iterbytes_impl_for_uuid//! Generate and parse universally unique identifiers (UUIDs).//! Here's an example of a UUID://! 67e55044-10b1-426f-9247-bb680e5fe0c8//! A UUID is a unique 128-bit value, stored as 16 octets, and regularly//! formatted as a hex string in five groups. UUIDs are used to assign unique//! identifiers to entities without requiring a central allocating authority.//! They are particularly useful in distributed systems, though can be used in//! disparate areas, such as databases and network protocols.  Typically a UUID//! is displayed in a readable string form as a sequence of hexadecimal digits,//! separated into groups by hyphens.//! The uniqueness property is not strictly guaranteed, however for all//! practical purposes, it can be assumed that an unintentional collision would//! be extremely unlikely.//! UUIDs have a number of standardized encodings that are specified in [RFC 9562](https://www.ietf.org/rfc/rfc9562.html).//! [dependencies.uuid]//! version = "1.16.0"//! # Lets you generate random UUIDs//! features = [//!     "v4",//! ]//! When you want a UUID, you can generate one://! # #[cfg(feature = "v4")]//! use uuid::Uuid;//! let id = Uuid::new_v4();//! If you have a UUID value, you can use its string literal form inline://! use uuid::{uuid, Uuid};//! const ID: Uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8");//! # Working with different UUID versions//! This library supports all standardized methods for generating UUIDs through individual Cargo features.//! By default, this crate depends on nothing but the Rust standard library and can parse and format//! UUIDs, but cannot generate them. Depending on the kind of UUID you'd like to work with, there//! are Cargo features that enable generating them://! * `v1` - Version 1 UUIDs using a timestamp and monotonic counter.//! * `v3` - Version 3 UUIDs based on the MD5 hash of some data.//! * `v4` - Version 4 UUIDs with random data.//! * `v5` - Version 5 UUIDs based on the SHA1 hash of some data.//! * `v6` - Version 6 UUIDs using a timestamp and monotonic counter.//! * `v7` - Version 7 UUIDs using a Unix timestamp.//! * `v8` - Version 8 UUIDs using user-defined data.//! This library also includes a [`Builder`] type that can be used to help construct UUIDs of any//! version without any additional dependencies or features. It's a lower-level API than [`Uuid`]//! that can be used when you need control over implicit requirements on things like a source//! of randomness.//! ## Which UUID version should I use?//! If you just want to generate unique identifiers then consider version 4 (`v4`) UUIDs. If you want//! to use UUIDs as database keys or need to sort them then consider version 7 (`v7`) UUIDs.//! Other versions should generally be avoided unless there's an existing need for them.//! Some UUID versions supersede others. Prefer version 6 over version 1 and version 5 over version 3.//! # Other features//! Other crate features can also be useful beyond the version support://! * `macro-diagnostics` - enhances the diagnostics of `uuid!` macro.//! * `serde` - adds the ability to serialize and deserialize a UUID using//!   `serde`.//! * `borsh` - adds the ability to serialize and deserialize a UUID using//!   `borsh`.//! * `arbitrary` - adds an `Arbitrary` trait implementation to `Uuid` for//!   fuzzing.//! * `fast-rng` - uses a faster algorithm for generating random UUIDs when available.//!   This feature requires more dependencies to compile, but is just as suitable for//!   UUIDs as the default algorithm.//! * `rng-rand` - forces `rand` as the backend for randomness.//! * `rng-getrandom` - forces `getrandom` as the backend for randomness.//! * `bytemuck` - adds a `Pod` trait implementation to `Uuid` for byte manipulation//! Some features are unstable. They may be incomplete or depend on other//! unstable libraries. These include://! * `zerocopy` - adds support for zero-copy deserialization using the//!   `zerocopy` library.//! Unstable features may break between minor releases.//! To allow unstable features, you'll need to enable the Cargo feature as//! normal, but also pass an additional flag through your environment to opt-in//! to unstable `uuid` features://! RUSTFLAGS="--cfg uuid_unstable"//! # Building for other targets//! ## WebAssembly//! For WebAssembly, enable the `js` feature://!     "v7",//!     "js",//! ## Embedded//! For embedded targets without the standard library, you'll need to//! disable default features when building `uuid`://! Some additional features are supported in no-std environments://! * `v1`, `v3`, `v5`, `v6`, and `v8`.//! * `serde`.//! If you need to use `v4` or `v7` in a no-std environment, you'll need to//! produce random bytes yourself and then pass them to [`Builder::from_random_bytes`]//! without enabling the `v4` or `v7` features.//! If you're using `getrandom`, you can specify the `rng-getrandom` or `rng-rand`//! features of `uuid` and configure `getrandom`'s provider per its docs. `uuid`//! may upgrade its version of `getrandom` in minor releases.//! Parse a UUID given in the simple format and print it as a URN://! # use uuid::Uuid;//! # fn main() -> Result<(), uuid::Error> {//! let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?;//! println!("{}", my_uuid.urn());//! Generate a random UUID and print it out in hexadecimal form://! // Note that this requires the `v4` feature to be enabled.//! # #[cfg(feature = "v4")] {//! let my_uuid = Uuid::new_v4();//! println!("{}", my_uuid);//! * [Wikipedia: Universally Unique Identifier](http://en.wikipedia.org/wiki/Universally_unique_identifier)//! * [RFC 9562: Universally Unique IDentifiers (UUID)](https://www.ietf.org/rfc/rfc9562.html).//! [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgendefine_uuid_macror" Parse [`Uuid`][uuid::Uuid]s from string literals at compile time."r" ## Usage"r" This macro transforms the string literal representation of a"r" [`Uuid`][uuid::Uuid] into the bytes representation, raising a compilation"r" error if it cannot properly be parsed."r" Setting a global constant:"r" # use uuid::{uuid, Uuid};"r#" pub const SCHEMA_ATTR_CLASS: Uuid = uuid!("00000000-0000-0000-0000-ffff00000000");"#r#" pub const SCHEMA_ATTR_UUID: Uuid = uuid!("00000000-0000-0000-0000-ffff00000001");"#r#" pub const SCHEMA_ATTR_NAME: Uuid = uuid!("00000000-0000-0000-0000-ffff00000002");"#r" Defining a local variable:"r" # use uuid::uuid;"r#" let uuid = uuid!("urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4");"#r" Using a const variable:"r#" const UUID_STR: &str = "12345678-1234-5678-1234-567812345678";"#r" let UUID = uuid!(UUID_STR);"r" ## Compilation Failures"r" Invalid UUIDs are rejected:"r#" let uuid = uuid!("F9168C5E-ZEB2-4FAA-B6BF-329BF39FA1E4");"#r" Enable the feature `macro-diagnostics` to see the error messages below."r" Provides the following compilation error:"r" ```txt"r" error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-fA-F-], found Z at 9"r"     |"r#"     |     let id = uuid!("F9168C5E-ZEB2-4FAA-B6BF-329BF39FA1E4");"#r"     |                              ^"r" [uuid::Uuid]: https://docs.rs/uuid/*/uuid/struct.Uuid.html"/// A UUID that is guaranteed not to be the [nil UUID](https://www.ietf.org/rfc/rfc9562.html#name-nil-uuid)./// This is useful for representing optional UUIDs more efficiently, as `Option<NonNilUuid>`/// takes up the same space as `Uuid`./// Note that `Uuid`s created by the following methods are guaranteed to be non-nil:/// - [`Uuid::new_v1`]/// - [`Uuid::now_v1`]/// - [`Uuid::new_v3`]/// - [`Uuid::new_v4`]/// - [`Uuid::new_v5`]/// - [`Uuid::new_v6`]/// - [`Uuid::now_v6`]/// - [`Uuid::new_v7`]/// - [`Uuid::now_v7`]/// - [`Uuid::new_v8`]/// The `NonNilUuid` type does not yet have a stable ABI. Its representation or alignment/// may change. It is currently only guaranteed that `NonNilUuid` and `Option<NonNilUuid>`/// are the same size as `Uuid`./// Creates a non-nil UUID if the value is non-nil./// Creates a non-nil without checking whether the value is non-nil. This results in undefined behavior if the value is nil./// The value must not be nil./// Get the underlying [`Uuid`] value./// Converts a [`NonNilUuid`] back into a [`Uuid`]./// # use uuid::{NonNilUuid, Uuid};/// let uuid = Uuid::from_u128(0x0123456789abcdef0123456789abcdef);/// let non_nil = NonNilUuid::try_from(uuid).unwrap();/// let uuid_again = Uuid::from(non_nil);/// assert_eq!(uuid, uuid_again);/// Attempts to convert a [`Uuid`] into a [`NonNilUuid`].test_non_nil_with_option_sizetest_non_niltest_non_nil_formatting//! A wrapper type for nil UUIDs that provides a more memory-efficient//! `Option<NonNilUuid>` representation./// Parses a `Uuid` from a string of hexadecimal digits with optional/// hyphens./// Any of the formats generated by this module (simple, hyphenated, urn,/// Microsoft GUID) are supported by this parsing function./// Prefer [`try_parse`] unless you need detailed user-facing diagnostics./// This method will be eventually deprecated in favor of `try_parse`./// Parse a hyphenated UUID:/// # use uuid::{Uuid, Version, Variant};/// let uuid = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")?;/// [`try_parse`]: #method.try_parse/// This function is similar to [`parse_str`], in fact `parse_str` shares/// the same underlying parser. The difference is that if `try_parse`/// fails, it won't generate very useful error messages. The `parse_str`/// function will eventually be deprecated in favor of `try_parse`./// To parse a UUID from a byte stream instead of a UTF8 string, see/// [`try_parse_ascii`]./// let uuid = Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000")?;/// [`parse_str`]: #method.parse_str/// [`try_parse_ascii`]: #method.try_parse_asciitry_parse_ascii/// The input is expected to be a string of ASCII characters. This method/// can be more convenient than [`try_parse`] if the UUID is being/// parsed from a byte stream instead of from a UTF8 string./// let uuid = Uuid::try_parse_ascii(b"550e8400-e29b-41d4-a716-446655440000")?;parse_hyphenatedHEX_TABLESHL4_TABLEtest_parse_uuid_v4_validtest_parse_uuid_v4_invalidtest_roundtrip_defaulttest_roundtrip_hyphenatedtest_roundtrip_simpletest_roundtrip_urntest_roundtrip_bracedtest_roundtrip_parse_urntest_roundtrip_parse_bracedtest_try_parse_ascii_non_utf8//! [`Uuid`] parsing constructs and utilities.RngImp// Using `getrandom`/*
    Random support for non `wasm32-unknown-unknown` platforms.
    */// Keeps our cfg's from becoming too convoluted in hereUUID_TICKS_BETWEEN_EPOCHS/// The number of 100 nanosecond ticks between the RFC 9562 epoch/// (`1582-10-15 00:00:00`) and the Unix epoch (`1970-01-01 00:00:00`).usable_counter_bits/// A timestamp that can be encoded into a UUID./// This type abstracts the specific encoding, so versions 1, 6, and 7/// UUIDs can both be supported through the same type, even/// though they have a different representation of a timestamp./// * [Timestamp Considerations in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-6.1)/// * [UUID Generator States in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-6.3)/// Get a timestamp representing the current system time and up to a 128-bit counter./// This method defers to the standard library's `SystemTime` type.from_gregorian/// Construct a `Timestamp` from the number of 100 nanosecond ticks since 00:00:00.00,/// 15 October 1582 (the date of Gregorian reform to the Christian calendar) and a 14-bit/// counter, as used in versions 1 and 6 UUIDs./// # Overflow/// If conversion from RFC 9562 ticks to the internal timestamp format would overflow/// it will wrap./// Construct a `Timestamp` from a Unix timestamp and up to a 128-bit counter, as used in version 7 UUIDs.to_gregorian/// Get the value of the timestamp as the number of 100 nanosecond ticks since 00:00:00.00,/// 15 October 1582 and a 14-bit counter, as used in versions 1 and 6 UUIDs./// If conversion from the internal timestamp format to ticks would overflow/// then it will wrap./// If the internal counter is wider than 14 bits then it will be truncated to 14 bits./// Get the value of the timestamp as a Unix timestamp, as used in version 7 UUIDs.unix_to_gregorian_ticksgregorian_to_unixfrom_rfc4122to_rfc4122to_unix_nanosencode_gregorian_timestampdecode_gregorian_timestampencode_sorted_gregorian_timestampdecode_sorted_gregorian_timestampencode_unix_timestamp_millisdecode_unix_timestamp_millis/// The type of sequence returned by this counter.generate_sequence/// Get the next value in the sequence to feed into a timestamp./// This method will be called each time a [`Timestamp`] is constructed./// Any bits beyond [`ClockSequence::usable_bits`] in the output must be unset.generate_timestamp_sequence/// Get the next value in the sequence, potentially also adjusting the timestamp./// This method should be preferred over `generate_sequence`.usable_bits/// The number of usable bits from the least significant bit in the result of [`ClockSequence::generate_sequence`]/// or [`ClockSequence::generate_timestamp_sequence`]./// The number of usable bits must not exceed 128./// The number of usable bits is not expected to change between calls. An implementation of `ClockSequence` should/// always return the same value from this method./// A counter that can be used by versions 1 and 6 UUIDs to support/// the uniqueness of timestamps./// * [UUID Version 1 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.1)/// * [UUID Version 6 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.6)ThreadLocalContext/// A wrapper for a context that uses thread-local storage./// Wrap a thread-local container with a context./// An empty counter that will always return the value `0`./// This type can be used when constructing version 7 UUIDs. When used to/// construct a version 7 UUID, the entire counter segment of the UUID will be/// filled with a random value. This type does not maintain ordering of UUIDs/// within a millisecond but is efficient./// This type should not be used when constructing version 1 or version 6 UUIDs./// When used to construct a version 1 or version 6 UUID, the counter/// segment will remain zero./// Default implementations for the [`ClockSequence`] trait.//! Generating UUIDs from timestamps.//! Timestamps are used in a few UUID versions as a source of decentralized//! uniqueness (as in versions 1 and 6), and as a way to enable sorting (as//! in versions 6 and 7). Timestamps aren't encoded the same way by all UUID//! versions so this module provides a single [`Timestamp`] type that can//! convert between them.//! # Timestamp representations in UUIDs//! Versions 1 and 6 UUIDs use a bespoke timestamp that consists of the//! number of 100ns ticks since `1582-10-15 00:00:00`, along with//! a counter value to avoid duplicates.//! Version 7 UUIDs use a more standard timestamp that consists of the//! number of millisecond ticks since the Unix epoch (`1970-01-01 00:00:00`).//! * [UUID Version 1 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.1)//! * [UUID Version 7 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.7)//! * [Timestamp Considerations in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-6.1)now_v1/// Create a new version 1 UUID using the current system time and node ID./// This method is only available if both the `std` and `rng` features are enabled./// This method is a convenient alternative to [`Uuid::new_v1`] that uses the current system time/// as the source timestamp./// Note that usage of this method requires the `v1`, `std`, and `rng` features of this crate/// to be enabled.new_v1/// Create a new version 1 UUID using the given timestamp and node ID./// Also see [`Uuid::now_v1`] for a convenient way to generate version 1/// UUIDs using the current system time./// When generating [`Timestamp`]s using a [`ClockSequence`], this function/// is only guaranteed to produce unique values if the following conditions/// hold:/// 1. The *node ID* is unique for this process,/// 2. The *context* is shared across all threads which are generating version 1///    UUIDs,/// 3. The [`ClockSequence`] implementation reliably returns unique///    clock sequences (this crate provides [`Context`] for this///    purpose. However you can create your own [`ClockSequence`]///    implementation, if [`Context`] does not meet your needs)./// Note that usage of this method requires the `v1` feature of this crate/// A UUID can be created from a unix [`Timestamp`] with a/// [`ClockSequence`]. RFC 9562 requires the clock sequence/// is seeded with a random value:/// # use uuid::{Timestamp, Context};/// # fn random_seed() -> u16 { 42 }/// let context = Context::new(random_seed());/// let ts = Timestamp::from_unix(&context, 1497624119, 1234);/// let uuid = Uuid::new_v1(ts, &[1, 2, 3, 4, 5, 6]);///     "f3b4958c-52a1-11e7-802a-010203040506"/// The timestamp can also be created manually as per RFC 9562:/// # use uuid::{Uuid, Timestamp, Context, ClockSequence};/// let context = Context::new(42);/// let ts = Timestamp::from_gregorian(14976234442241191232, context.generate_sequence(0, 0));///     "b2c1ad40-45e0-1fd6-802a-010203040506"/// [`Timestamp`]: v1/struct.Timestamp.html/// [`ClockSequence`]: v1/trait.ClockSequence.html/// [`Context`]: v1/struct.Context.htmltest_now//! The implementation for Version 1 UUIDs.//! This module is soft-deprecated. Instead of using the `Context` type re-exported here,//! use the one from the crate root.new_v3/// Creates a UUID using a name from a namespace, based on the MD5/// hash./// A number of namespaces are available as constants in this crate:/// * [`NAMESPACE_DNS`]/// * [`NAMESPACE_OID`]/// * [`NAMESPACE_URL`]/// * [`NAMESPACE_X500`]/// Note that usage of this method requires the `v3` feature of this crate/// Generating a MD5 DNS UUID for `rust-lang.org`:/// let uuid = Uuid::new_v3(&Uuid::NAMESPACE_DNS, b"rust-lang.org");/// assert_eq!(Some(Version::Md5), uuid.get_version());/// * [UUID Version 3 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.3)/// * [Name-Based UUID Generation in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-6.5)/// [`NAMESPACE_DNS`]: #associatedconstant.NAMESPACE_DNS/// [`NAMESPACE_OID`]: #associatedconstant.NAMESPACE_OID/// [`NAMESPACE_URL`]: #associatedconstant.NAMESPACE_URL/// [`NAMESPACE_X500`]: #associatedconstant.NAMESPACE_X500FIXTURE/// Creates a random UUID./// This uses the [`getrandom`] crate to utilise the operating system's RNG/// as the source of random numbers. If you'd like to use a custom/// generator, don't use this method: generate random bytes using your/// custom generator and pass them to the/// [`uuid::Builder::from_random_bytes`][from_random_bytes] function/// Note that usage of this method requires the `v4` feature of this crate/// let uuid = Uuid::new_v4();/// * [UUID Version 4 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.4)/// [from_random_bytes]: struct.Builder.html#method.from_random_bytestest_get_versionnew_v5/// Creates a UUID using a name from a namespace, based on the SHA-1 hash./// Note that usage of this method requires the `v5` feature of this crate/// Generating a SHA1 DNS UUID for `rust-lang.org`:/// let uuid = Uuid::new_v5(&Uuid::NAMESPACE_DNS, b"rust-lang.org");/// assert_eq!(Some(Version::Sha1), uuid.get_version());/// * [UUID Version 5 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.5)/// [`NAMESPACE_DNS`]: struct.Uuid.html#associatedconstant.NAMESPACE_DNS/// [`NAMESPACE_OID`]: struct.Uuid.html#associatedconstant.NAMESPACE_OID/// [`NAMESPACE_URL`]: struct.Uuid.html#associatedconstant.NAMESPACE_URL/// [`NAMESPACE_X500`]: struct.Uuid.html#associatedconstant.NAMESPACE_X500test_hyphenatednow_v6/// Create a new version 6 UUID using the current system time and node ID./// This method is only available if the `std` feature is enabled./// This method is a convenient alternative to [`Uuid::new_v6`] that uses the current system time/// Note that usage of this method requires the `v6`, `std`, and `rng` features of this crate/// Create a new version 6 UUID using the given timestamp and a node ID./// This is similar to version 1 UUIDs, except that it is lexicographically sortable by timestamp./// Also see [`Uuid::now_v6`] for a convenient way to generate version 6/// 2. The *context* is shared across all threads which are generating version 6/// The NodeID must be exactly 6 bytes long./// Note that usage of this method requires the `v6` feature of this crate/// # use uuid::{Uuid, Timestamp, Context};/// let ts = Timestamp::from_unix(context, 1497624119, 1234);/// let uuid = Uuid::new_v6(ts, &[1, 2, 3, 4, 5, 6]);///     "1e752a1f-3b49-658c-802a-010203040506"/// let ts = Timestamp::from_gregorian(14976241191231231313, context.generate_sequence(0, 0));///     "fd64c041-1e91-6551-802a-010203040506"/// [`Timestamp`]: timestamp/struct.Timestamp.html/// [`ClockSequence`]: timestamp/trait.ClockSequence.html/// [`Context`]: timestamp/context/struct.Context.html//! The implementation for Version 6 UUIDs.//! Note that you need to enable the `v6` Cargo feature//! in order to use this module.now_v7/// Create a new version 7 UUID using the current time value./// This method is a convenient alternative to [`Uuid::new_v7`] that uses the current system time/// as the source timestamp. All UUIDs generated through this method by the same process are/// guaranteed to be ordered by their creation.new_v7/// Create a new version 7 UUID using a time value and random bytes./// When the `std` feature is enabled, you can also use [`Uuid::now_v7`]./// Note that usage of this method requires the `v7` feature of this crate/// Also see [`Uuid::now_v7`] for a convenient way to generate version 7/// A v7 UUID can be created from a unix [`Timestamp`] plus a 128 bit/// random number. When supplied as such, the data will be combined/// to ensure uniqueness and sortability at millisecond granularity./// # use uuid::{Uuid, Timestamp, NoContext};/// let ts = Timestamp::from_unix(NoContext, 1497624119, 1234);/// let uuid = Uuid::new_v7(ts);///     uuid.hyphenated().to_string().starts_with("015cb15a-86d8-7")/// A v7 UUID can also be created with a counter to ensure batches of/// UUIDs created together remain sortable:/// # use uuid::{Uuid, Timestamp, ContextV7};/// let context = ContextV7::new();/// let uuid1 = Uuid::new_v7(Timestamp::from_unix(&context, 1497624119, 1234));/// let uuid2 = Uuid::new_v7(Timestamp::from_unix(&context, 1497624119, 1234));/// assert!(uuid1 < uuid2);/// * [UUID Version 7 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.7)test_sortingtest_new_timestamp_roundtriptest_new_max_context//! The implementation for Version 7 UUIDs.//! Note that you need to enable the `v7` Cargo featurenew_v8/// Creates a custom UUID comprised almost entirely of user-supplied bytes./// This will inject the UUID Version at 4 bits starting at the 48th bit/// and the Variant into 2 bits 64th bit. Any existing bits in the user-supplied bytes/// at those locations will be overridden./// Note that usage of this method requires the `v8` feature of this crate/// let buf: [u8; 16] = *b"abcdefghijklmnop";/// let uuid = Uuid::new_v8(buf);/// assert_eq!(Some(Version::Custom), uuid.get_version());/// * [UUID Version 8 in RFC 9562](https://www.ietf.org/rfc/rfc9562.html#section-5.8)VideoOutputVbiCaputreVbiOutputSlicedVbiCaptureSlicedVbiOutputVideoOutputOverlayVideoCaptureMplaneVideoOutputMplaneSdrCaptureSdrOutputMetaCaptureMetaOutput/// Deprecated, do not use/// Buffer type/// Specific types of devices require buffers of corresponding types.r" Buffer is mapped"MAPPEDr" Buffer is queued for processing"QUEUEDr" Buffer is ready"DONEr" Image is a keyframe (I-frame)"KEYFRAMEr" Image is a P-frame"PFRAMEr" Image is a B-frame"BFRAMEr" Buffer is ready, but the data contained within is corrupted"r" Buffer is added to an unqueued request"IN_REQUESTr" Timecode field is valid"TIMECODEr" Don't return the capture buffer until OUTPUT timestamp changes"M2M_HOLD_CAPTURE_BUFr" Buffer is prepared for queuing"PREPAREDr" Cache handling flags"NO_CACHE_INVALIDATENO_CACHE_CLEANr" Timestamp type"TIMESTAMP_MASKTIMESTAMP_UNKNOWNTIMESTAMP_MONOTONICTIMESTAMP_COPYr" Timestamp sources"TSTAMP_SRC_MASKTSTAMP_SRC_EOFTSTAMP_SRC_SOEr" mem2mem encoder/decoder"r" request_fd is valid"REQUEST_FDbytesused/// Number of bytes occupied by the data in the buffer/// Buffer flags/// Indicates the field order of the image in the buffer./// Time of capture (usually set by the driver)/// Sequence number, counting the frames/// Buffer metadata, mostly used not to convolute the main buffer structsVIDEO_CAPTUREVIDEO_OUTPUTVIDEO_OVERLAYVBI_CAPTUREVBI_OUTPUTSLICED_VBI_CAPTURESLICED_VBI_OUTPUTRDS_CAPTUREVIDEO_OUTPUT_OVERLAYHW_FREQ_SEEKRDS_OUTPUTVIDEO_CAPTURE_MPLANEVIDEO_OUTPUT_MPLANEVIDEO_M2M_MPLANEVIDEO_M2MTUNERRADIOMODULATORSDR_CAPTUREEXT_PIX_FORMATSDR_OUTPUTMETA_CAPTUREREAD_WRITEASYNC_IOSTREAMINGMETA_OUTPUTDEVICE_CAPS/// Driver name, e.g. uvc for usb video class devices/// Card name/// Bus name, e.g. USB or PCI/// Version number MAJOR.MINOR.PATCH/// Capability flagsCapabilities/// Device capabilitiesv4l2_capabilityenum_devices/// Returns a list of devices currently known to the system/// use v4l::context;/// for dev in context::enum_devices() {///     print!("{}{}", dev.index(), dev.name().unwrap());/// Device node path/// Represents a video4linux device node/// Returns a device node observer by path/// The device is opened in read only mode./// * `path` - Node path (usually a character device or sysfs entry)/// use v4l::context::Node;/// let node = Node::new("/dev/video0");/// Returns the absolute path of the device node/// Returns the index of the device node/// Returns name of the device by parsing its sysfs entryInteger64CtrlClassIntegerMenu/* Compound types are >= 0x0100 */0x01010x01020x0106Area/// Control data typeDISABLEDGRABBEDREAD_ONLYWRITE_ONLYVOLATILEHAS_PAYLOADEXECUTE_ON_WRITEMODIFY_LAYOUTNEXT_CTRLNEXT_COMPOUND/// Device control menu itemv4l2_querymenu/// Control identifier, set by the the application/// Type of control/// Name of the control, intended for the user/// Minimum value, inclusive/// Maximum value, inclusive/// Step size, always positive/// Default value/// Control flags/// Items for menu controls (only valid if typ is a menu type)/// Device control descriptionv4l2_query_ext_ctrl/* buttons *//* single values */CompoundU8/* compound (matrix) values */CompoundU16CompoundU32CompoundPtr/// Device control valuev4l2_controlv4l2videodevv4l2_ext_controls/// Raw handle/// Linux capture device abstraction/// Returns a capture device by index/// Devices are usually enumerated by the system./// An index of zero thus represents the first device the system got to know about./// * `index` - Index (0: first, 1: second, ..)/// use v4l::device::Device;/// let dev = Device::new(0);/// Returns a capture device by path/// Linux device nodes are usually found in /dev/videoX or /sys/class/video4linux/videoX./// * `path` - Path (e.g. "/dev/video0")/// let dev = Device::with_path("/dev/video0");/// Returns the raw device handle/// Returns video4linux framework defined information such as card, driver, etc.query_controls/// Returns the supported controls for a device such as gain, focus, white balance, etc./// Returns the control value for an ID/// * `id` - Control identifier/// Modifies the control value/// * `ctrl` - Control to be setset_controls/// Modifies the control values atomically/// * `ctrls` - Vec of the controls to be set/// Device handle for low-level access./// Acquiring a handle facilitates (possibly mutating) interactions with the device./// Returns the raw file descriptor/// Polls the file descriptor for I/O events/// * `events`  - The events you are interested in (e.g. POLLIN)/// * `timeout` - Timeout in milliseconds///               A value of zero returns immedately, even if the fd is not ready.///               A negative value means infinite timeout (blocking)./// driver will pick defaultSMPTE170M/// SMPTE 170MSMPTE240M/// SMPTE 240MRec709/// Rec. 709, aka BT.709NTSC// BT878=4: deprecated, no driver returns this/// NTSCEBUTech3212/// EBU Tech 3213/// use for JPEGs: sRGB colorspace, YCbCr encoding, and full range quantizationSRGB/// sRGBOPRGB/// opRGBRec2020/// Rec. 2020, aka BT.2020/// for RAW imagesDCIP3/// DCI-P3/// Colorspace for pixels./// The driver decides this for capture streams and the user sets it for/// output streams.EMULATEDCONTINUOUS_BITSTREAMDYN_RESOLUTION/// Format description as returned by [`crate::v4l2::vidioc::VIDIOC_ENUM_FMT`]v4l2_fmtdescFieldOrder/// Progressive, Top, Bottom, or Interlaced is acceptable; driver will pick one/// progressive, not interlaced/// top, or odd, field/// bottom, or even, fieldInterlaced/// both fields interlacedSequentialTB/// top field stored first, then bottom fieldSequentialBT/// bottom field stored first, then top field/// one field at a time, alternates between top and bottomInterlacedTB/// both fields interlaced, starts with topInterlacedBT/// both fields interlaced, starts with bottom/// Represents how fields are interlaced (if they are)/// Four character code representing a pixelformat/// Returns a pixelformat as four character code/// * `repr` - Four characters as raw bytes/// use v4l::format::FourCC;/// let fourcc = FourCC::new(b"YUYV");/// Returns the string representation of a four character code/// let str = fourcc.str().unwrap();quantizationQuantizationTransferFunctionPREMUL_ALPHA/// width in pixels/// height in pixels/// pixelformat code/// field order for interlacing/// bytes per line/// maximum number of bytes required to store an image/// flags set by the application or driver/// supplements the pixelformat (fourcc) information/// the way colors are mapped/// the transfer function for the colorspace/// Streaming format (single-planar)/// Returns a capture format/// * `width` - Width in pixels/// * `height` - Height in pixels/// * `fourcc` - Four character code (pixelformat)/// use v4l::{Format, FourCC};/// let fmt = Format::new(640, 480, FourCC::new(b"YUYV"));v4l2_pix_format/// default for the colorspaceFullRange/// maps to the full range; 0 goes to 0 and 1 goes to 255LimitedRange/// maps to a limited range; 0 goes to 16 and 1 goes to 235/// Quantization for the colorspace./// The driver decides this for capture streams and the user sets/// it for output streams./// default from the colorspace/// Rec. 709 transfer function/// sRGB transfer function/// opRGB transfer function/// SMPTE 230M transfer function/// No transfer function/// DCI-P3 transfer functionSMPTE2084/// SMPTE 2084 transfer function/// Transfer function for the colorspace. The driver decides this for capture streams and the user/// sets it for output streams.numeratordenominator/// Fraction used for timing settings/// Returns a fraction representation/// * `num` - Numerator/// * `denom` - Denominator/// use v4l::fraction::Fraction;/// let frac = Fraction::new(30, 1);v4l2_fractFrameInterval/// Format description as returned by [`crate::v4l2::vidioc::VIDIOC_ENUM_FRAMEINTERVALS`]Stepwisev4l2_frmivalenum/// Minimum frame interval (in seconds)./// Maximum frame interval (in seconds)./// Frame interval step size (in seconds).FrameSize/// Format description as returned by [`crate::v4l2::vidioc::VIDIOC_ENUM_FRAMESIZES`]to_discretev4l2_frmsizeenum/// Width of the frame (in pixels)./// Height of the frame (in pixels)./// Minimum frame width (in pixels)./// Maximum frame width (in pixels).step_width/// Frame width step size (in pixels)./// Minimum frame height (in pixels)./// Maximum frame height (in pixels).step_height/// Frame height step size (in pixels).buf_typeArena/// Manage mapped buffers/// All buffers are unmapped in the Drop impl./// In case of errors during unmapping, we panic because there is memory corruption going on./// Returns a new buffer manager instance/// You usually do not need to use this directly./// A MappedBufferStream creates its own manager instance by default./// * `handle` - Device handle to get its file descriptor/// * `buf_type` - Type of the buffersbuffer_descv4l2_bufferrequestbuffers_descv4l2_requestbuffersStreamTraitarena_indexbuf_meta/// Stream of mapped buffers/// An arena instance is used internally for buffer handling./// Returns a stream for frame capturing/// * `dev` - Capture device ref to get its file descriptor/// use v4l::buffer::Type;/// use v4l::io::mmap::Stream;/// if let Ok(dev) = dev {///     let stream = Stream::new(&dev, Type::VideoCapture);/// Sets a timeout of the v4l file handle./// Clears the timeout of the v4l file handle.userptr/// Start streaming, takes exclusive ownership of a device/// Stop streaming, frees all buffers/// Streaming I/O/// Insert a buffer into the drivers' incoming queue/// Remove a buffer from the drivers' outgoing queue/// Fetch a new frame by first queueing and then dequeueing./// First time initialization is performed if necessary./// Dump a new frame by first queueing and then dequeueing./// Manage user allocated buffers/// All buffers are released in the Drop impl./// A UserBufferStream creates its own manager instance by default./// * `dev` - Device handle to get its file descriptor/// Stream of user buffers/// * `dev` - Device ref to get its file descriptor/// use v4l::io::userptr::Stream;UserptrStream//! This crate provides safe bindings for the Video4Linux (v4l) stack.//! The stack consists of three libraries written in C://! * libv4l1       (v4l1 API, deprecated)//! * libv4l2       (v4l2 API, the primary target of this crate)//! * libv4lconvert (emulates common formats such as RGB3 in userspace)//! Additional documentation can currently also be found in the//! [README.md file which is most easily viewed on github](https://github.com/raymanfx/libv4l-rs/blob/master/README.md).//! [Jump forward to crate content](#reexports)//! Video devices on Linux can be accessed by path or by index (which then corresponds to a path),//! e.g. "/dev/video0" for the device which first became known to the system.//! There are three methods of dealing with (capture) device memory://! * `MMAP` (memory region in device memory or kernel space, mapped into userspace)//! * `User` pointer (memory region allocated in host memory, written into by the kernel)//! * `DMA` (direct memory access for memory transfer without involving the CPU)//! The following schematic shows the `mmap` and `userptr` mechanisms://! **mmap**//! 1. `device --[MAP]--> kernel --[MAP]--> user`//! 2. `device --[DMA]--> kernel --[MAP]--> user`//! **userptr**//! 3. `device --[DMA]-->                   user`//! It is important to note that user pointer is for device-to-user memory transfer whereas//! DMA is for device-to-device transfer, e.g. directly uploading a captured frame into GPU//! As you can see, user pointer and DMA are potential candidates for zero-copy applications where//! buffers should be writable. If a read-only buffer is good enough, MMAP buffers are fine and//! do not incur any copy overhead either. Most (if not all) devices reporting streaming I/O//! capabilities support MMAP buffer sharing, but not all support user pointer access.//! The regular user of this crate will mainly be interested in frame capturing.//! Here is a very brief example of streaming I/O with memory mapped buffers://! use v4l::buffer::Type;//! use v4l::io::traits::CaptureStream;//! use v4l::prelude::*;//! let mut dev = Device::new(0).expect("Failed to open device");//! let mut stream =//!     MmapStream::with_buffers(&mut dev, Type::VideoCapture, 4).expect("Failed to create buffer stream");//!     let (buf, meta) = stream.next().unwrap();//!     println!(//!         "Buffer size: {}, seq: {}, timestamp: {}",//!        buf.len(),//!        meta.sequence,//!        meta.timestamp//!    );//!}//! Have a look at the examples to learn more about device and buffer management.UserPtrDmaBuf/// Memory used for buffer exchangeTIME_PER_FRAMEusec/// Timestamp consisting of a seconds and a microseconds component/// Returns a timestamp representation/// * `sec` - Seconds/// * `usec` - Microseconds/// use v4l::timestamp::Timestamp;/// let ts = Timestamp::new(5, 5);vidioc_IOC_TYPE/// A convenience wrapper around v4l2_open./// Returns the file descriptor on success./// In case of errors, the last OS error will be reported, aka errno on Linux./// * `path` - Path to the device node/// * `flags` - Open flags/// extern crate v4l;/// use v4l::v4l2;/// let fd = v4l2::open("/dev/video0", libc::O_RDWR);/// A convenience wrapper around v4l2_close./// * `fd` - File descriptor of a previously opened device/// if let Ok(fd) = fd {///     v4l2::close(fd).unwrap();/// A convenience wrapper around v4l2_ioctl./// * `fd` - File descriptor/// * `request` - IO control code (see [`vidioc`])/// * `argp` - Pointer to memory region holding the argument type/// For maximum flexibility, argp must be a raw pointer. Thus, the entire function is unsafe./// use v4l::v4l_sys::*;/// let mut v4l2_caps: v4l2_capability;///     v4l2_caps = mem::zeroed();///         v4l2::ioctl(fd, v4l2::vidioc::VIDIOC_QUERYCAP,///                     &mut v4l2_caps as *mut _ as *mut std::os::raw::c_void);/// A convenience wrapper around v4l2_mmap./// * `start` - Starting address of the new mapping, usually NULL/// * `length` - Length of the mapped region/// * `prot` - Desired memory protection of the mapped region/// * `flags` - Mapping flags/// * `fd` - File descriptor representing an opened device/// * `offset` - Offset in the source region, usually 0/// Start must be a raw pointer. Thus, the entire function is unsafe.///     /* VIDIOC_REQBUFS *////     /* VIDIOC_QUERYBUF *////     let mapping_length: usize = 1000;///         let mapping = v4l2::mmap(ptr::null_mut(), mapping_length,///                                  libc::PROT_READ | libc::PROT_WRITE,///                                  libc::MAP_SHARED, fd, 0);/// A convenience wrapper around v4l2_munmap./// * `start` - Starting address of the mapping///         if let Ok(mapping) = mapping {///             v4l2::munmap(mapping, mapping_length).unwrap();v4l2_ext_controlerror_idxrequest_fdcontrols// We need to carry our own copy of this struct, because the `which` field used to be called// `ctrl_class` and Linux now has both fields in a union. While the change is transparent as far as// C (and thus Linux) is concerned, it causes us trouble with bindgen since we cannot directly// access union members.// See https://github.com/raymanfx/libv4l-rs/pull/40#issuecomment-885169894 for additional details.// linux ioctl.h_IOC_TYPECHECKVIDIOC_RESERVEDFormatDescriptionimpl_enum_frameintervalsenum_frameintervalsimpl_enum_framesizesenum_framesizesimpl_enum_formatsenum_formatsimpl_set_formatModesHIGH_QUALITY/// Streaming parameters (single-planar)with_fpsv4l2_captureparm/// Output parameters (single-planar)v4l2_outputparmCaptureParametersOutputParameters/// Returns a vector of all frame intervals that the device supports for the given pixel format/// and frame size/// Returns a vector of valid framesizes that the device supports for the given pixel format/// Returns a vector of valid formats for this device/// The "emulated" field describes formats filled in by libv4lconvert./// There may be a conversion related performance penalty when using them./// Returns the format currently in use/// Modifies the capture format and returns the actual format/// The driver tries to match the format parameters on a best effort basis./// Thus, if the combination of format properties cannot be achieved, the closest possible/// settings are used and reported back./// * `fmt` - Desired format/// Returns the parameters currently in use/// Modifies the capture parameters and returns the actual parameters/// * `params` - Desired parameters/// Capture device protocol/// Modifies the output parameters and returns the actual parameters/// Output device protocol_SYS_TIME_H_FEATURES_H_DEFAULT_SOURCE__GLIBC_USE_ISOC2X__USE_ISOC11__USE_ISOC99__USE_ISOC95__USE_POSIX_IMPLICITLY_POSIX_SOURCE_POSIX_C_SOURCE__USE_POSIX__USE_POSIX2__USE_POSIX199309__USE_POSIX199506__USE_XOPEN2K__USE_XOPEN2K8_ATFILE_SOURCE__WORDSIZE__WORDSIZE_TIME64_COMPAT32__SYSCALL_WORDSIZE__TIMESIZE__USE_MISC__USE_ATFILE__USE_FORTIFY_LEVEL__GLIBC_USE_DEPRECATED_GETS__GLIBC_USE_DEPRECATED_SCANF__GLIBC_USE_C2X_STRTOL_STDC_PREDEF_H__STDC_IEC_559____STDC_IEC_60559_BFP____STDC_IEC_559_COMPLEX____STDC_IEC_60559_COMPLEX____STDC_ISO_10646____GNU_LIBRARY____GLIBC____GLIBC_MINOR___SYS_CDEFS_H__glibc_c99_flexarr_available__LDOUBLE_REDIRECTS_TO_FLOAT128_ABI__HAVE_GENERIC_SELECTION_BITS_TYPES_H_BITS_TYPESIZES_H__OFF_T_MATCHES_OFF64_T__INO_T_MATCHES_INO64_T__RLIM_T_MATCHES_RLIM64_T__STATFS_MATCHES_STATFS64__KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64_BITS_TIME64_H__time_t_defined__timeval_defined_SYS_SELECT_H__sigset_t_defined_STRUCT_TIMESPEC_BITS_ENDIAN_H_BITS_ENDIANNESS_HV4L2_SEL_TGT_CROPV4L2_SEL_TGT_CROP_DEFAULTV4L2_SEL_TGT_CROP_BOUNDSV4L2_SEL_TGT_NATIVE_SIZEV4L2_SEL_TGT_COMPOSEV4L2_SEL_TGT_COMPOSE_DEFAULTV4L2_SEL_TGT_COMPOSE_BOUNDSV4L2_SEL_TGT_COMPOSE_PADDEDV4L2_SEL_FLAG_GEV4L2_SEL_FLAG_LEV4L2_SEL_FLAG_KEEP_CONFIGV4L2_SEL_TGT_CROP_ACTIVEV4L2_SEL_TGT_COMPOSE_ACTIVEV4L2_SUBDEV_SEL_TGT_CROP_ACTUALV4L2_SUBDEV_SEL_TGT_COMPOSE_ACTUALV4L2_SUBDEV_SEL_TGT_CROP_BOUNDSV4L2_SUBDEV_SEL_TGT_COMPOSE_BOUNDSV4L2_SUBDEV_SEL_FLAG_SIZE_GEV4L2_SUBDEV_SEL_FLAG_SIZE_LEV4L2_SUBDEV_SEL_FLAG_KEEP_CONFIGV4L2_CTRL_CLASS_USERV4L2_CTRL_CLASS_CODECV4L2_CTRL_CLASS_CAMERAV4L2_CTRL_CLASS_FM_TXV4L2_CTRL_CLASS_FLASHV4L2_CTRL_CLASS_JPEGV4L2_CTRL_CLASS_IMAGE_SOURCEV4L2_CTRL_CLASS_IMAGE_PROCV4L2_CTRL_CLASS_DVV4L2_CTRL_CLASS_FM_RXV4L2_CTRL_CLASS_RF_TUNERV4L2_CTRL_CLASS_DETECTV4L2_CTRL_CLASS_CODEC_STATELESSV4L2_CTRL_CLASS_COLORIMETRYV4L2_CID_BASEV4L2_CID_USER_BASEV4L2_CID_USER_CLASSV4L2_CID_AUDIO_VOLUMEV4L2_CID_AUDIO_BALANCEV4L2_CID_AUDIO_BASSV4L2_CID_AUDIO_TREBLEV4L2_CID_AUDIO_MUTEV4L2_CID_AUDIO_LOUDNESSV4L2_CID_BLACK_LEVELV4L2_CID_AUTO_WHITE_BALANCEV4L2_CID_DO_WHITE_BALANCEV4L2_CID_RED_BALANCEV4L2_CID_BLUE_BALANCEV4L2_CID_WHITENESSV4L2_CID_AUTOGAINV4L2_CID_HFLIPV4L2_CID_VFLIPV4L2_CID_POWER_LINE_FREQUENCYV4L2_CID_HUE_AUTOV4L2_CID_CHROMA_AGCV4L2_CID_COLOR_KILLERV4L2_CID_COLORFXV4L2_CID_AUTOBRIGHTNESSV4L2_CID_BAND_STOP_FILTERV4L2_CID_ROTATEV4L2_CID_BG_COLORV4L2_CID_CHROMA_GAINV4L2_CID_ILLUMINATORS_1V4L2_CID_ILLUMINATORS_2V4L2_CID_MIN_BUFFERS_FOR_CAPTUREV4L2_CID_MIN_BUFFERS_FOR_OUTPUTV4L2_CID_ALPHA_COMPONENTV4L2_CID_COLORFX_CBCRV4L2_CID_COLORFX_RGBV4L2_CID_LASTP1V4L2_CID_USER_MEYE_BASEV4L2_CID_USER_BTTV_BASEV4L2_CID_USER_S2255_BASEV4L2_CID_USER_SI476X_BASEV4L2_CID_USER_TI_VPE_BASEV4L2_CID_USER_SAA7134_BASEV4L2_CID_USER_ADV7180_BASEV4L2_CID_USER_TC358743_BASEV4L2_CID_USER_MAX217X_BASEV4L2_CID_USER_IMX_BASEV4L2_CID_USER_ATMEL_ISC_BASEV4L2_CID_USER_CODA_BASEV4L2_CID_USER_CCS_BASEV4L2_CID_USER_ALLEGRO_BASEV4L2_CID_USER_ISL7998X_BASEV4L2_CID_USER_DW100_BASEV4L2_CID_USER_ASPEED_BASEV4L2_CID_USER_NPCM_BASEV4L2_CID_USER_THP7312_BASEV4L2_CID_CODEC_BASEV4L2_CID_CODEC_CLASSV4L2_CID_MPEG_STREAM_TYPEV4L2_CID_MPEG_STREAM_PID_PMTV4L2_CID_MPEG_STREAM_PID_AUDIOV4L2_CID_MPEG_STREAM_PID_VIDEOV4L2_CID_MPEG_STREAM_PID_PCRV4L2_CID_MPEG_STREAM_PES_ID_AUDIOV4L2_CID_MPEG_STREAM_PES_ID_VIDEOV4L2_CID_MPEG_STREAM_VBI_FMTV4L2_CID_MPEG_AUDIO_SAMPLING_FREQV4L2_CID_MPEG_AUDIO_ENCODINGV4L2_CID_MPEG_AUDIO_L1_BITRATEV4L2_CID_MPEG_AUDIO_L2_BITRATEV4L2_CID_MPEG_AUDIO_L3_BITRATEV4L2_CID_MPEG_AUDIO_MODEV4L2_CID_MPEG_AUDIO_MODE_EXTENSIONV4L2_CID_MPEG_AUDIO_EMPHASISV4L2_CID_MPEG_AUDIO_CRCV4L2_CID_MPEG_AUDIO_MUTEV4L2_CID_MPEG_AUDIO_AAC_BITRATEV4L2_CID_MPEG_AUDIO_AC3_BITRATEV4L2_CID_MPEG_AUDIO_DEC_PLAYBACKV4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACKV4L2_CID_MPEG_VIDEO_ENCODINGV4L2_CID_MPEG_VIDEO_ASPECTV4L2_CID_MPEG_VIDEO_B_FRAMESV4L2_CID_MPEG_VIDEO_GOP_SIZEV4L2_CID_MPEG_VIDEO_GOP_CLOSUREV4L2_CID_MPEG_VIDEO_PULLDOWNV4L2_CID_MPEG_VIDEO_BITRATE_MODEV4L2_CID_MPEG_VIDEO_BITRATEV4L2_CID_MPEG_VIDEO_BITRATE_PEAKV4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATIONV4L2_CID_MPEG_VIDEO_MUTEV4L2_CID_MPEG_VIDEO_MUTE_YUVV4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACEV4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTERV4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MBV4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLEV4L2_CID_MPEG_VIDEO_HEADER_MODEV4L2_CID_MPEG_VIDEO_MAX_REF_PICV4L2_CID_MPEG_VIDEO_MB_RC_ENABLEV4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTESV4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MBV4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODEV4L2_CID_MPEG_VIDEO_VBV_SIZEV4L2_CID_MPEG_VIDEO_DEC_PTSV4L2_CID_MPEG_VIDEO_DEC_FRAMEV4L2_CID_MPEG_VIDEO_VBV_DELAYV4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADERV4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGEV4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGEV4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAMEV4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_IDV4L2_CID_MPEG_VIDEO_AU_DELIMITERV4L2_CID_MPEG_VIDEO_LTR_COUNTV4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEXV4L2_CID_MPEG_VIDEO_USE_LTR_FRAMESV4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLORV4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIODV4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPEV4L2_CID_MPEG_VIDEO_MPEG2_LEVELV4L2_CID_MPEG_VIDEO_MPEG2_PROFILEV4L2_CID_FWHT_I_FRAME_QPV4L2_CID_FWHT_P_FRAME_QPV4L2_CID_MPEG_VIDEO_H263_I_FRAME_QPV4L2_CID_MPEG_VIDEO_H263_P_FRAME_QPV4L2_CID_MPEG_VIDEO_H263_B_FRAME_QPV4L2_CID_MPEG_VIDEO_H263_MIN_QPV4L2_CID_MPEG_VIDEO_H263_MAX_QPV4L2_CID_MPEG_VIDEO_H264_I_FRAME_QPV4L2_CID_MPEG_VIDEO_H264_P_FRAME_QPV4L2_CID_MPEG_VIDEO_H264_B_FRAME_QPV4L2_CID_MPEG_VIDEO_H264_MIN_QPV4L2_CID_MPEG_VIDEO_H264_MAX_QPV4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORMV4L2_CID_MPEG_VIDEO_H264_CPB_SIZEV4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODEV4L2_CID_MPEG_VIDEO_H264_I_PERIODV4L2_CID_MPEG_VIDEO_H264_LEVELV4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHAV4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETAV4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODEV4L2_CID_MPEG_VIDEO_H264_PROFILEV4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHTV4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTHV4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLEV4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDCV4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKINGV4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPEV4L2_CID_MPEG_VIDEO_H264_FMOV4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPEV4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUPV4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTIONV4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATEV4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTHV4L2_CID_MPEG_VIDEO_H264_ASOV4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDERV4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODINGV4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPEV4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYERV4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QPV4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTIONV4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSETV4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QPV4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QPV4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QPV4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QPV4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QPV4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QPV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L0_BRV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L1_BRV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L2_BRV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L3_BRV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L4_BRV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L5_BRV4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L6_BRV4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QPV4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QPV4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QPV4L2_CID_MPEG_VIDEO_MPEG4_MIN_QPV4L2_CID_MPEG_VIDEO_MPEG4_MAX_QPV4L2_CID_MPEG_VIDEO_MPEG4_LEVELV4L2_CID_MPEG_VIDEO_MPEG4_PROFILEV4L2_CID_MPEG_VIDEO_MPEG4_QPELV4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONSV4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMESV4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVELV4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESSV4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIODV4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SELV4L2_CID_MPEG_VIDEO_VPX_MIN_QPV4L2_CID_MPEG_VIDEO_VPX_MAX_QPV4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QPV4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QPV4L2_CID_MPEG_VIDEO_VP8_PROFILEV4L2_CID_MPEG_VIDEO_VPX_PROFILEV4L2_CID_MPEG_VIDEO_VP9_PROFILEV4L2_CID_MPEG_VIDEO_VP9_LEVELV4L2_CID_MPEG_VIDEO_HEVC_MIN_QPV4L2_CID_MPEG_VIDEO_HEVC_MAX_QPV4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QPV4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QPV4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPEV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYERV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QPV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QPV4L2_CID_MPEG_VIDEO_HEVC_PROFILEV4L2_CID_MPEG_VIDEO_HEVC_LEVELV4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTIONV4L2_CID_MPEG_VIDEO_HEVC_TIERV4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTHV4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODEV4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPEV4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIODV4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CUV4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PREDV4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONTV4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PBV4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_IDV4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHINGV4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLITV4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTIONV4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODEV4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELDV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BRV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BRV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BRV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BRV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BRV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BRV4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BRV4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMESV4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDRV4L2_CID_MPEG_VIDEO_CONSTANT_QUALITYV4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODEV4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QPV4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QPV4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QPV4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QPV4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QPV4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QPV4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAYV4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLEV4L2_CID_MPEG_VIDEO_AV1_PROFILEV4L2_CID_MPEG_VIDEO_AV1_LEVELV4L2_CID_CODEC_CX2341X_BASEV4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODEV4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTERV4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPEV4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPEV4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODEV4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTERV4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPEV4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOMV4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOPV4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOMV4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOPV4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETSV4L2_CID_CODEC_MFC51_BASEV4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAYV4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLEV4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODEV4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPEV4L2_CID_MPEG_MFC51_VIDEO_PADDINGV4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUVV4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BITV4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFFV4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITYV4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARKV4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTHV4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATICV4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_PV4L2_CID_CAMERA_CLASS_BASEV4L2_CID_CAMERA_CLASSV4L2_CID_EXPOSURE_AUTOV4L2_CID_EXPOSURE_ABSOLUTEV4L2_CID_EXPOSURE_AUTO_PRIORITYV4L2_CID_PAN_RESETV4L2_CID_TILT_RESETV4L2_CID_PAN_ABSOLUTEV4L2_CID_TILT_ABSOLUTEV4L2_CID_FOCUS_ABSOLUTEV4L2_CID_FOCUS_AUTOV4L2_CID_ZOOM_ABSOLUTEV4L2_CID_ZOOM_CONTINUOUSV4L2_CID_PRIVACYV4L2_CID_IRIS_ABSOLUTEV4L2_CID_AUTO_EXPOSURE_BIASV4L2_CID_AUTO_N_PRESET_WHITE_BALANCEV4L2_CID_WIDE_DYNAMIC_RANGEV4L2_CID_IMAGE_STABILIZATIONV4L2_CID_ISO_SENSITIVITYV4L2_CID_ISO_SENSITIVITY_AUTOV4L2_CID_EXPOSURE_METERINGV4L2_CID_SCENE_MODEV4L2_CID_3A_LOCKV4L2_LOCK_EXPOSUREV4L2_LOCK_WHITE_BALANCEV4L2_LOCK_FOCUSV4L2_CID_AUTO_FOCUS_STARTV4L2_CID_AUTO_FOCUS_STOPV4L2_CID_AUTO_FOCUS_STATUSV4L2_AUTO_FOCUS_STATUS_IDLEV4L2_AUTO_FOCUS_STATUS_BUSYV4L2_AUTO_FOCUS_STATUS_REACHEDV4L2_AUTO_FOCUS_STATUS_FAILEDV4L2_CID_AUTO_FOCUS_RANGEV4L2_CID_PAN_SPEEDV4L2_CID_TILT_SPEEDV4L2_CID_CAMERA_ORIENTATIONV4L2_CAMERA_ORIENTATION_FRONTV4L2_CAMERA_ORIENTATION_BACKV4L2_CAMERA_ORIENTATION_EXTERNALV4L2_CID_CAMERA_SENSOR_ROTATIONV4L2_CID_HDR_SENSOR_MODEV4L2_CID_FM_TX_CLASS_BASEV4L2_CID_FM_TX_CLASSV4L2_CID_RDS_TX_DEVIATIONV4L2_CID_RDS_TX_PIV4L2_CID_RDS_TX_PTYV4L2_CID_RDS_TX_PS_NAMEV4L2_CID_RDS_TX_RADIO_TEXTV4L2_CID_RDS_TX_MONO_STEREOV4L2_CID_RDS_TX_ARTIFICIAL_HEADV4L2_CID_RDS_TX_COMPRESSEDV4L2_CID_RDS_TX_DYNAMIC_PTYV4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENTV4L2_CID_RDS_TX_TRAFFIC_PROGRAMV4L2_CID_RDS_TX_MUSIC_SPEECHV4L2_CID_RDS_TX_ALT_FREQS_ENABLEV4L2_CID_RDS_TX_ALT_FREQSV4L2_CID_AUDIO_LIMITER_ENABLEDV4L2_CID_AUDIO_LIMITER_RELEASE_TIMEV4L2_CID_AUDIO_LIMITER_DEVIATIONV4L2_CID_AUDIO_COMPRESSION_ENABLEDV4L2_CID_AUDIO_COMPRESSION_GAINV4L2_CID_AUDIO_COMPRESSION_THRESHOLDV4L2_CID_AUDIO_COMPRESSION_ATTACK_TIMEV4L2_CID_AUDIO_COMPRESSION_RELEASE_TIMEV4L2_CID_PILOT_TONE_ENABLEDV4L2_CID_PILOT_TONE_DEVIATIONV4L2_CID_PILOT_TONE_FREQUENCYV4L2_CID_TUNE_PREEMPHASISV4L2_CID_TUNE_POWER_LEVELV4L2_CID_TUNE_ANTENNA_CAPACITORV4L2_CID_FLASH_CLASS_BASEV4L2_CID_FLASH_CLASSV4L2_CID_FLASH_LED_MODEV4L2_CID_FLASH_STROBE_SOURCEV4L2_CID_FLASH_STROBEV4L2_CID_FLASH_STROBE_STOPV4L2_CID_FLASH_STROBE_STATUSV4L2_CID_FLASH_TIMEOUTV4L2_CID_FLASH_INTENSITYV4L2_CID_FLASH_TORCH_INTENSITYV4L2_CID_FLASH_INDICATOR_INTENSITYV4L2_CID_FLASH_FAULTV4L2_FLASH_FAULT_OVER_VOLTAGEV4L2_FLASH_FAULT_TIMEOUTV4L2_FLASH_FAULT_OVER_TEMPERATUREV4L2_FLASH_FAULT_SHORT_CIRCUITV4L2_FLASH_FAULT_OVER_CURRENTV4L2_FLASH_FAULT_INDICATORV4L2_FLASH_FAULT_UNDER_VOLTAGEV4L2_FLASH_FAULT_INPUT_VOLTAGEV4L2_FLASH_FAULT_LED_OVER_TEMPERATUREV4L2_CID_FLASH_CHARGEV4L2_CID_FLASH_READYV4L2_CID_JPEG_CLASS_BASEV4L2_CID_JPEG_CLASSV4L2_CID_JPEG_CHROMA_SUBSAMPLINGV4L2_CID_JPEG_RESTART_INTERVALV4L2_CID_JPEG_COMPRESSION_QUALITYV4L2_CID_JPEG_ACTIVE_MARKERV4L2_JPEG_ACTIVE_MARKER_APP0V4L2_JPEG_ACTIVE_MARKER_APP1V4L2_JPEG_ACTIVE_MARKER_COMV4L2_JPEG_ACTIVE_MARKER_DQTV4L2_JPEG_ACTIVE_MARKER_DHTV4L2_CID_IMAGE_SOURCE_CLASS_BASEV4L2_CID_IMAGE_SOURCE_CLASSV4L2_CID_VBLANKV4L2_CID_HBLANKV4L2_CID_ANALOGUE_GAINV4L2_CID_TEST_PATTERN_REDV4L2_CID_TEST_PATTERN_GREENRV4L2_CID_TEST_PATTERN_BLUEV4L2_CID_TEST_PATTERN_GREENBV4L2_CID_UNIT_CELL_SIZEV4L2_CID_NOTIFY_GAINSV4L2_CID_IMAGE_PROC_CLASS_BASEV4L2_CID_IMAGE_PROC_CLASSV4L2_CID_LINK_FREQV4L2_CID_PIXEL_RATEV4L2_CID_TEST_PATTERNV4L2_CID_DEINTERLACING_MODEV4L2_CID_DIGITAL_GAINV4L2_CID_DV_CLASS_BASEV4L2_CID_DV_CLASSV4L2_CID_DV_TX_HOTPLUGV4L2_CID_DV_TX_RXSENSEV4L2_CID_DV_TX_EDID_PRESENTV4L2_CID_DV_TX_MODEV4L2_CID_DV_TX_RGB_RANGEV4L2_CID_DV_TX_IT_CONTENT_TYPEV4L2_CID_DV_RX_POWER_PRESENTV4L2_CID_DV_RX_RGB_RANGEV4L2_CID_DV_RX_IT_CONTENT_TYPEV4L2_CID_FM_RX_CLASS_BASEV4L2_CID_FM_RX_CLASSV4L2_CID_TUNE_DEEMPHASISV4L2_CID_RDS_RECEPTIONV4L2_CID_RDS_RX_PTYV4L2_CID_RDS_RX_PS_NAMEV4L2_CID_RDS_RX_RADIO_TEXTV4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENTV4L2_CID_RDS_RX_TRAFFIC_PROGRAMV4L2_CID_RDS_RX_MUSIC_SPEECHV4L2_CID_RF_TUNER_CLASS_BASEV4L2_CID_RF_TUNER_CLASSV4L2_CID_RF_TUNER_BANDWIDTH_AUTOV4L2_CID_RF_TUNER_BANDWIDTHV4L2_CID_RF_TUNER_RF_GAINV4L2_CID_RF_TUNER_LNA_GAIN_AUTOV4L2_CID_RF_TUNER_LNA_GAINV4L2_CID_RF_TUNER_MIXER_GAIN_AUTOV4L2_CID_RF_TUNER_MIXER_GAINV4L2_CID_RF_TUNER_IF_GAIN_AUTOV4L2_CID_RF_TUNER_IF_GAINV4L2_CID_RF_TUNER_PLL_LOCKV4L2_CID_DETECT_CLASS_BASEV4L2_CID_DETECT_CLASSV4L2_CID_DETECT_MD_MODEV4L2_CID_DETECT_MD_GLOBAL_THRESHOLDV4L2_CID_DETECT_MD_THRESHOLD_GRIDV4L2_CID_DETECT_MD_REGION_GRIDV4L2_CID_CODEC_STATELESS_BASEV4L2_CID_CODEC_STATELESS_CLASSV4L2_CID_STATELESS_H264_DECODE_MODEV4L2_CID_STATELESS_H264_START_CODEV4L2_H264_SPS_CONSTRAINT_SET0_FLAGV4L2_H264_SPS_CONSTRAINT_SET1_FLAGV4L2_H264_SPS_CONSTRAINT_SET2_FLAGV4L2_H264_SPS_CONSTRAINT_SET3_FLAGV4L2_H264_SPS_CONSTRAINT_SET4_FLAGV4L2_H264_SPS_CONSTRAINT_SET5_FLAGV4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANEV4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASSV4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZEROV4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWEDV4L2_H264_SPS_FLAG_FRAME_MBS_ONLYV4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELDV4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCEV4L2_CID_STATELESS_H264_SPSV4L2_H264_PPS_FLAG_ENTROPY_CODING_MODEV4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENTV4L2_H264_PPS_FLAG_WEIGHTED_PREDV4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENTV4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PREDV4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENTV4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODEV4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENTV4L2_CID_STATELESS_H264_PPSV4L2_CID_STATELESS_H264_SCALING_MATRIXV4L2_CID_STATELESS_H264_PRED_WEIGHTSV4L2_H264_SLICE_TYPE_PV4L2_H264_SLICE_TYPE_BV4L2_H264_SLICE_TYPE_IV4L2_H264_SLICE_TYPE_SPV4L2_H264_SLICE_TYPE_SIV4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PREDV4L2_H264_SLICE_FLAG_SP_FOR_SWITCHV4L2_H264_TOP_FIELD_REFV4L2_H264_BOTTOM_FIELD_REFV4L2_H264_FRAME_REFV4L2_H264_NUM_DPB_ENTRIESV4L2_H264_REF_LIST_LENV4L2_CID_STATELESS_H264_SLICE_PARAMSV4L2_H264_DPB_ENTRY_FLAG_VALIDV4L2_H264_DPB_ENTRY_FLAG_ACTIVEV4L2_H264_DPB_ENTRY_FLAG_LONG_TERMV4L2_H264_DPB_ENTRY_FLAG_FIELDV4L2_H264_DECODE_PARAM_FLAG_IDR_PICV4L2_H264_DECODE_PARAM_FLAG_FIELD_PICV4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELDV4L2_H264_DECODE_PARAM_FLAG_PFRAMEV4L2_H264_DECODE_PARAM_FLAG_BFRAMEV4L2_CID_STATELESS_H264_DECODE_PARAMSV4L2_FWHT_VERSIONV4L2_FWHT_FL_COMPONENTS_NUM_OFFSETV4L2_FWHT_FL_PIXENC_OFFSETV4L2_FWHT_FL_PIXENC_YUVV4L2_FWHT_FL_PIXENC_RGBV4L2_FWHT_FL_PIXENC_HSVV4L2_CID_STATELESS_FWHT_PARAMSV4L2_VP8_SEGMENT_FLAG_ENABLEDV4L2_VP8_SEGMENT_FLAG_UPDATE_MAPV4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATAV4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODEV4L2_VP8_LF_ADJ_ENABLEV4L2_VP8_LF_DELTA_UPDATEV4L2_VP8_LF_FILTER_TYPE_SIMPLEV4L2_VP8_COEFF_PROB_CNTV4L2_VP8_MV_PROB_CNTV4L2_VP8_FRAME_FLAG_KEY_FRAMEV4L2_VP8_FRAME_FLAG_EXPERIMENTALV4L2_VP8_FRAME_FLAG_SHOW_FRAMEV4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFFV4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDENV4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALTV4L2_CID_STATELESS_VP8_FRAMEV4L2_MPEG2_SEQ_FLAG_PROGRESSIVEV4L2_CID_STATELESS_MPEG2_SEQUENCEV4L2_MPEG2_PIC_CODING_TYPE_IV4L2_MPEG2_PIC_CODING_TYPE_PV4L2_MPEG2_PIC_CODING_TYPE_BV4L2_MPEG2_PIC_CODING_TYPE_DV4L2_MPEG2_PIC_TOP_FIELDV4L2_MPEG2_PIC_BOTTOM_FIELDV4L2_MPEG2_PIC_FRAMEV4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRSTV4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCTV4L2_MPEG2_PIC_FLAG_CONCEALMENT_MVV4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPEV4L2_MPEG2_PIC_FLAG_INTRA_VLCV4L2_MPEG2_PIC_FLAG_ALT_SCANV4L2_MPEG2_PIC_FLAG_REPEAT_FIRSTV4L2_MPEG2_PIC_FLAG_PROGRESSIVEV4L2_CID_STATELESS_MPEG2_PICTUREV4L2_CID_STATELESS_MPEG2_QUANTISATIONV4L2_CID_STATELESS_HEVC_SPSV4L2_CID_STATELESS_HEVC_PPSV4L2_CID_STATELESS_HEVC_SLICE_PARAMSV4L2_CID_STATELESS_HEVC_SCALING_MATRIXV4L2_CID_STATELESS_HEVC_DECODE_PARAMSV4L2_CID_STATELESS_HEVC_DECODE_MODEV4L2_CID_STATELESS_HEVC_START_CODEV4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETSV4L2_HEVC_SLICE_TYPE_BV4L2_HEVC_SLICE_TYPE_PV4L2_HEVC_SLICE_TYPE_IV4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANEV4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLEDV4L2_HEVC_SPS_FLAG_AMP_ENABLEDV4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSETV4L2_HEVC_SPS_FLAG_PCM_ENABLEDV4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLEDV4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENTV4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLEDV4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLEDV4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLEDV4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENTV4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLEDV4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENTV4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PREDV4L2_HEVC_PPS_FLAG_TRANSFORM_SKIP_ENABLEDV4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLEDV4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENTV4L2_HEVC_PPS_FLAG_WEIGHTED_PREDV4L2_HEVC_PPS_FLAG_WEIGHTED_BIPREDV4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLEDV4L2_HEVC_PPS_FLAG_TILES_ENABLEDV4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLEDV4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLEDV4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLEDV4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLEDV4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTERV4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENTV4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENTV4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENTV4L2_HEVC_PPS_FLAG_UNIFORM_SPACINGV4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCEV4L2_HEVC_SEI_PIC_STRUCT_FRAMEV4L2_HEVC_SEI_PIC_STRUCT_TOP_FIELDV4L2_HEVC_SEI_PIC_STRUCT_BOTTOM_FIELDV4L2_HEVC_SEI_PIC_STRUCT_TOP_BOTTOMV4L2_HEVC_SEI_PIC_STRUCT_BOTTOM_TOPV4L2_HEVC_SEI_PIC_STRUCT_TOP_BOTTOM_TOPV4L2_HEVC_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOMV4L2_HEVC_SEI_PIC_STRUCT_FRAME_DOUBLINGV4L2_HEVC_SEI_PIC_STRUCT_FRAME_TRIPLINGV4L2_HEVC_SEI_PIC_STRUCT_TOP_PAIRED_PREVIOUS_BOTTOMV4L2_HEVC_SEI_PIC_STRUCT_BOTTOM_PAIRED_PREVIOUS_TOPV4L2_HEVC_SEI_PIC_STRUCT_TOP_PAIRED_NEXT_BOTTOMV4L2_HEVC_SEI_PIC_STRUCT_BOTTOM_PAIRED_NEXT_TOPV4L2_HEVC_DPB_ENTRIES_NUM_MAXV4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMAV4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMAV4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLEDV4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZEROV4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INITV4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MVV4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLEDV4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLEDV4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENTV4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PICV4L2_HEVC_DECODE_PARAM_FLAG_IDR_PICV4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIORV4L2_CID_COLORIMETRY_CLASS_BASEV4L2_CID_COLORIMETRY_CLASSV4L2_CID_COLORIMETRY_HDR10_CLL_INFOV4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAYV4L2_HDR10_MASTERING_PRIMARIES_X_LOWV4L2_HDR10_MASTERING_PRIMARIES_X_HIGHV4L2_HDR10_MASTERING_PRIMARIES_Y_LOWV4L2_HDR10_MASTERING_PRIMARIES_Y_HIGHV4L2_HDR10_MASTERING_WHITE_POINT_X_LOWV4L2_HDR10_MASTERING_WHITE_POINT_X_HIGHV4L2_HDR10_MASTERING_WHITE_POINT_Y_LOWV4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGHV4L2_HDR10_MASTERING_MAX_LUMA_LOWV4L2_HDR10_MASTERING_MAX_LUMA_HIGHV4L2_HDR10_MASTERING_MIN_LUMA_LOWV4L2_HDR10_MASTERING_MIN_LUMA_HIGHV4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLEDV4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATEV4L2_VP9_SEGMENTATION_FLAG_ENABLEDV4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAPV4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATEV4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATAV4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATEV4L2_VP9_SEG_LVL_ALT_QV4L2_VP9_SEG_LVL_ALT_LV4L2_VP9_SEG_LVL_REF_FRAMEV4L2_VP9_SEG_LVL_SKIPV4L2_VP9_SEG_LVL_MAXV4L2_VP9_SEGMENT_FEATURE_ENABLED_MASKV4L2_VP9_FRAME_FLAG_KEY_FRAMEV4L2_VP9_FRAME_FLAG_SHOW_FRAMEV4L2_VP9_FRAME_FLAG_ERROR_RESILIENTV4L2_VP9_FRAME_FLAG_INTRA_ONLYV4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MVV4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTXV4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODEV4L2_VP9_FRAME_FLAG_X_SUBSAMPLINGV4L2_VP9_FRAME_FLAG_Y_SUBSAMPLINGV4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWINGV4L2_VP9_SIGN_BIAS_LASTV4L2_VP9_SIGN_BIAS_GOLDENV4L2_VP9_SIGN_BIAS_ALTV4L2_VP9_RESET_FRAME_CTX_NONEV4L2_VP9_RESET_FRAME_CTX_SPECV4L2_VP9_RESET_FRAME_CTX_ALLV4L2_VP9_INTERP_FILTER_EIGHTTAPV4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTHV4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARPV4L2_VP9_INTERP_FILTER_BILINEARV4L2_VP9_INTERP_FILTER_SWITCHABLEV4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCEV4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCEV4L2_VP9_REFERENCE_MODE_SELECTV4L2_VP9_PROFILE_MAXV4L2_CID_STATELESS_VP9_FRAMEV4L2_VP9_NUM_FRAME_CTXV4L2_CID_STATELESS_VP9_COMPRESSED_HDRV4L2_VP9_TX_MODE_ONLY_4X4V4L2_VP9_TX_MODE_ALLOW_8X8V4L2_VP9_TX_MODE_ALLOW_16X16V4L2_VP9_TX_MODE_ALLOW_32X32V4L2_VP9_TX_MODE_SELECTV4L2_AV1_TOTAL_REFS_PER_FRAMEV4L2_AV1_CDEF_MAXV4L2_AV1_NUM_PLANES_MAXV4L2_AV1_MAX_SEGMENTSV4L2_AV1_MAX_OPERATING_POINTSV4L2_AV1_REFS_PER_FRAMEV4L2_AV1_MAX_NUM_Y_POINTSV4L2_AV1_MAX_NUM_CB_POINTSV4L2_AV1_MAX_NUM_CR_POINTSV4L2_AV1_AR_COEFFS_SIZEV4L2_AV1_MAX_NUM_PLANESV4L2_AV1_MAX_TILE_COLSV4L2_AV1_MAX_TILE_ROWSV4L2_AV1_MAX_TILE_COUNTV4L2_AV1_SEQUENCE_FLAG_STILL_PICTUREV4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCKV4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRAV4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTERV4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUNDV4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUNDV4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTIONV4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTERV4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINTV4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMPV4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVSV4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRESV4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEFV4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATIONV4L2_AV1_SEQUENCE_FLAG_MONO_CHROMEV4L2_AV1_SEQUENCE_FLAG_COLOR_RANGEV4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_XV4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_YV4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENTV4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_QV4L2_CID_STATELESS_AV1_SEQUENCEV4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRYV4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBALV4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOMV4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATIONV4L2_AV1_LOOP_RESTORATION_FLAG_USES_LRV4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LRV4L2_AV1_SEGMENTATION_FLAG_ENABLEDV4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAPV4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATEV4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATAV4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIPV4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLEDV4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATEV4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENTV4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTIV4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTAV4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIXV4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENTV4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACINGV4L2_AV1_FRAME_FLAG_SHOW_FRAMEV4L2_AV1_FRAME_FLAG_SHOWABLE_FRAMEV4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODEV4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATEV4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLSV4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MVV4L2_AV1_FRAME_FLAG_ALLOW_INTRABCV4L2_AV1_FRAME_FLAG_USE_SUPERRESV4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MVV4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLEV4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVSV4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDFV4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTIONV4L2_AV1_FRAME_FLAG_REFERENCE_SELECTV4L2_AV1_FRAME_FLAG_REDUCED_TX_SETV4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWEDV4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENTV4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDEV4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENTV4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALINGV4L2_CID_STATELESS_AV1_FRAMEV4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAINV4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAINV4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMAV4L2_AV1_FILM_GRAIN_FLAG_OVERLAPV4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGEV4L2_CID_STATELESS_AV1_FILM_GRAINV4L2_CTRL_CLASS_MPEGV4L2_CID_MPEG_CLASSV4L2_CID_MPEG_BASEV4L2_CID_MPEG_CX2341X_BASEV4L2_CID_MPEG_MFC51_BASEVIDEO_MAX_FRAMEV4L2_CAP_VIDEO_CAPTUREV4L2_CAP_VIDEO_OUTPUTV4L2_CAP_VIDEO_OVERLAYV4L2_CAP_VBI_CAPTUREV4L2_CAP_VBI_OUTPUTV4L2_CAP_SLICED_VBI_CAPTUREV4L2_CAP_SLICED_VBI_OUTPUTV4L2_CAP_RDS_CAPTUREV4L2_CAP_VIDEO_OUTPUT_OVERLAYV4L2_CAP_HW_FREQ_SEEKV4L2_CAP_RDS_OUTPUTV4L2_CAP_VIDEO_CAPTURE_MPLANEV4L2_CAP_VIDEO_OUTPUT_MPLANEV4L2_CAP_VIDEO_M2M_MPLANEV4L2_CAP_VIDEO_M2MV4L2_CAP_TUNERV4L2_CAP_AUDIOV4L2_CAP_RADIOV4L2_CAP_MODULATORV4L2_CAP_SDR_CAPTUREV4L2_CAP_EXT_PIX_FORMATV4L2_CAP_SDR_OUTPUTV4L2_CAP_META_CAPTUREV4L2_CAP_READWRITEV4L2_CAP_STREAMINGV4L2_CAP_META_OUTPUTV4L2_CAP_TOUCHV4L2_CAP_IO_MCV4L2_CAP_DEVICE_CAPSV4L2_PIX_FMT_PRIV_MAGICV4L2_PIX_FMT_FLAG_PREMUL_ALPHAV4L2_PIX_FMT_FLAG_SET_CSCV4L2_FMT_FLAG_COMPRESSEDV4L2_FMT_FLAG_EMULATEDV4L2_FMT_FLAG_CONTINUOUS_BYTESTREAMV4L2_FMT_FLAG_DYN_RESOLUTIONV4L2_FMT_FLAG_ENC_CAP_FRAME_INTERVALV4L2_FMT_FLAG_CSC_COLORSPACEV4L2_FMT_FLAG_CSC_XFER_FUNCV4L2_FMT_FLAG_CSC_YCBCR_ENCV4L2_FMT_FLAG_CSC_HSV_ENCV4L2_FMT_FLAG_CSC_QUANTIZATIONV4L2_TC_TYPE_24FPSV4L2_TC_TYPE_25FPSV4L2_TC_TYPE_30FPSV4L2_TC_TYPE_50FPSV4L2_TC_TYPE_60FPSV4L2_TC_FLAG_DROPFRAMEV4L2_TC_FLAG_COLORFRAMEV4L2_TC_USERBITS_fieldV4L2_TC_USERBITS_USERDEFINEDV4L2_TC_USERBITS_8BITCHARSV4L2_JPEG_MARKER_DHTV4L2_JPEG_MARKER_DQTV4L2_JPEG_MARKER_DRIV4L2_JPEG_MARKER_COMV4L2_JPEG_MARKER_APPV4L2_MEMORY_FLAG_NON_COHERENTV4L2_BUF_CAP_SUPPORTS_MMAPV4L2_BUF_CAP_SUPPORTS_USERPTRV4L2_BUF_CAP_SUPPORTS_DMABUFV4L2_BUF_CAP_SUPPORTS_REQUESTSV4L2_BUF_CAP_SUPPORTS_ORPHANED_BUFSV4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUFV4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTSV4L2_BUF_CAP_SUPPORTS_MAX_NUM_BUFFERSV4L2_BUF_FLAG_MAPPEDV4L2_BUF_FLAG_QUEUEDV4L2_BUF_FLAG_DONEV4L2_BUF_FLAG_KEYFRAMEV4L2_BUF_FLAG_PFRAMEV4L2_BUF_FLAG_BFRAMEV4L2_BUF_FLAG_ERRORV4L2_BUF_FLAG_IN_REQUESTV4L2_BUF_FLAG_TIMECODEV4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUFV4L2_BUF_FLAG_PREPAREDV4L2_BUF_FLAG_NO_CACHE_INVALIDATEV4L2_BUF_FLAG_NO_CACHE_CLEANV4L2_BUF_FLAG_TIMESTAMP_MASKV4L2_BUF_FLAG_TIMESTAMP_UNKNOWNV4L2_BUF_FLAG_TIMESTAMP_MONOTONICV4L2_BUF_FLAG_TIMESTAMP_COPYV4L2_BUF_FLAG_TSTAMP_SRC_MASKV4L2_BUF_FLAG_TSTAMP_SRC_EOFV4L2_BUF_FLAG_TSTAMP_SRC_SOEV4L2_BUF_FLAG_LASTV4L2_BUF_FLAG_REQUEST_FDV4L2_FBUF_CAP_EXTERNOVERLAYV4L2_FBUF_CAP_CHROMAKEYV4L2_FBUF_CAP_LIST_CLIPPINGV4L2_FBUF_CAP_BITMAP_CLIPPINGV4L2_FBUF_CAP_LOCAL_ALPHAV4L2_FBUF_CAP_GLOBAL_ALPHAV4L2_FBUF_CAP_LOCAL_INV_ALPHAV4L2_FBUF_CAP_SRC_CHROMAKEYV4L2_FBUF_FLAG_PRIMARYV4L2_FBUF_FLAG_OVERLAYV4L2_FBUF_FLAG_CHROMAKEYV4L2_FBUF_FLAG_LOCAL_ALPHAV4L2_FBUF_FLAG_GLOBAL_ALPHAV4L2_FBUF_FLAG_LOCAL_INV_ALPHAV4L2_FBUF_FLAG_SRC_CHROMAKEYV4L2_MODE_HIGHQUALITYV4L2_CAP_TIMEPERFRAMEV4L2_STD_UNKNOWNV4L2_DV_PROGRESSIVEV4L2_DV_INTERLACEDV4L2_DV_VSYNC_POS_POLV4L2_DV_HSYNC_POS_POLV4L2_DV_BT_STD_CEA861V4L2_DV_BT_STD_DMTV4L2_DV_BT_STD_CVTV4L2_DV_BT_STD_GTFV4L2_DV_BT_STD_SDIV4L2_DV_FL_REDUCED_BLANKINGV4L2_DV_FL_CAN_REDUCE_FPSV4L2_DV_FL_REDUCED_FPSV4L2_DV_FL_HALF_LINEV4L2_DV_FL_IS_CE_VIDEOV4L2_DV_FL_FIRST_FIELD_EXTRA_LINEV4L2_DV_FL_HAS_PICTURE_ASPECTV4L2_DV_FL_HAS_CEA861_VICV4L2_DV_FL_HAS_HDMI_VICV4L2_DV_FL_CAN_DETECT_REDUCED_FPSV4L2_DV_BT_656_1120V4L2_DV_BT_CAP_INTERLACEDV4L2_DV_BT_CAP_PROGRESSIVEV4L2_DV_BT_CAP_REDUCED_BLANKINGV4L2_DV_BT_CAP_CUSTOMV4L2_INPUT_TYPE_TUNERV4L2_INPUT_TYPE_CAMERAV4L2_INPUT_TYPE_TOUCHV4L2_IN_ST_NO_POWERV4L2_IN_ST_NO_SIGNALV4L2_IN_ST_NO_COLORV4L2_IN_ST_HFLIPV4L2_IN_ST_VFLIPV4L2_IN_ST_NO_H_LOCKV4L2_IN_ST_COLOR_KILLV4L2_IN_ST_NO_V_LOCKV4L2_IN_ST_NO_STD_LOCKV4L2_IN_ST_NO_SYNCV4L2_IN_ST_NO_EQUV4L2_IN_ST_NO_CARRIERV4L2_IN_ST_MACROVISIONV4L2_IN_ST_NO_ACCESSV4L2_IN_ST_VTRV4L2_IN_CAP_DV_TIMINGSV4L2_IN_CAP_CUSTOM_TIMINGSV4L2_IN_CAP_STDV4L2_IN_CAP_NATIVE_SIZEV4L2_OUTPUT_TYPE_MODULATORV4L2_OUTPUT_TYPE_ANALOGV4L2_OUTPUT_TYPE_ANALOGVGAOVERLAYV4L2_OUT_CAP_DV_TIMINGSV4L2_OUT_CAP_CUSTOM_TIMINGSV4L2_OUT_CAP_STDV4L2_OUT_CAP_NATIVE_SIZEV4L2_CTRL_ID_MASKV4L2_CTRL_MAX_DIMSV4L2_CTRL_WHICH_CUR_VALV4L2_CTRL_WHICH_DEF_VALV4L2_CTRL_WHICH_REQUEST_VALV4L2_CTRL_FLAG_DISABLEDV4L2_CTRL_FLAG_GRABBEDV4L2_CTRL_FLAG_READ_ONLYV4L2_CTRL_FLAG_UPDATEV4L2_CTRL_FLAG_INACTIVEV4L2_CTRL_FLAG_SLIDERV4L2_CTRL_FLAG_WRITE_ONLYV4L2_CTRL_FLAG_VOLATILEV4L2_CTRL_FLAG_HAS_PAYLOADV4L2_CTRL_FLAG_EXECUTE_ON_WRITEV4L2_CTRL_FLAG_MODIFY_LAYOUTV4L2_CTRL_FLAG_DYNAMIC_ARRAYV4L2_CTRL_FLAG_NEXT_CTRLV4L2_CTRL_FLAG_NEXT_COMPOUNDV4L2_CID_MAX_CTRLSV4L2_CID_PRIVATE_BASEV4L2_TUNER_CAP_LOWV4L2_TUNER_CAP_NORMV4L2_TUNER_CAP_HWSEEK_BOUNDEDV4L2_TUNER_CAP_HWSEEK_WRAPV4L2_TUNER_CAP_STEREOV4L2_TUNER_CAP_LANG2V4L2_TUNER_CAP_SAPV4L2_TUNER_CAP_LANG1V4L2_TUNER_CAP_RDSV4L2_TUNER_CAP_RDS_BLOCK_IOV4L2_TUNER_CAP_RDS_CONTROLSV4L2_TUNER_CAP_FREQ_BANDSV4L2_TUNER_CAP_HWSEEK_PROG_LIMV4L2_TUNER_CAP_1HZV4L2_TUNER_SUB_MONOV4L2_TUNER_SUB_STEREOV4L2_TUNER_SUB_LANG2V4L2_TUNER_SUB_SAPV4L2_TUNER_SUB_LANG1V4L2_TUNER_SUB_RDSV4L2_TUNER_MODE_MONOV4L2_TUNER_MODE_STEREOV4L2_TUNER_MODE_LANG2V4L2_TUNER_MODE_SAPV4L2_TUNER_MODE_LANG1V4L2_TUNER_MODE_LANG1_LANG2V4L2_BAND_MODULATION_VSBV4L2_BAND_MODULATION_FMV4L2_BAND_MODULATION_AMV4L2_RDS_BLOCK_MSKV4L2_RDS_BLOCK_AV4L2_RDS_BLOCK_BV4L2_RDS_BLOCK_CV4L2_RDS_BLOCK_DV4L2_RDS_BLOCK_C_ALTV4L2_RDS_BLOCK_INVALIDV4L2_RDS_BLOCK_CORRECTEDV4L2_RDS_BLOCK_ERRORV4L2_AUDCAP_STEREOV4L2_AUDCAP_AVLV4L2_AUDMODE_AVLV4L2_ENC_IDX_FRAME_IV4L2_ENC_IDX_FRAME_PV4L2_ENC_IDX_FRAME_BV4L2_ENC_IDX_FRAME_MASKV4L2_ENC_IDX_ENTRIESV4L2_ENC_CMD_STARTV4L2_ENC_CMD_STOPV4L2_ENC_CMD_PAUSEV4L2_ENC_CMD_RESUMEV4L2_ENC_CMD_STOP_AT_GOP_ENDV4L2_DEC_CMD_STARTV4L2_DEC_CMD_STOPV4L2_DEC_CMD_PAUSEV4L2_DEC_CMD_RESUMEV4L2_DEC_CMD_FLUSHV4L2_DEC_CMD_START_MUTE_AUDIOV4L2_DEC_CMD_PAUSE_TO_BLACKV4L2_DEC_CMD_STOP_TO_BLACKV4L2_DEC_CMD_STOP_IMMEDIATELYV4L2_DEC_START_FMT_NONEV4L2_DEC_START_FMT_GOPV4L2_VBI_UNSYNCV4L2_VBI_INTERLACEDV4L2_VBI_ITU_525_F1_STARTV4L2_VBI_ITU_525_F2_STARTV4L2_VBI_ITU_625_F1_STARTV4L2_VBI_ITU_625_F2_STARTV4L2_SLICED_TELETEXT_BV4L2_SLICED_VPSV4L2_SLICED_CAPTION_525V4L2_SLICED_WSS_625V4L2_SLICED_VBI_525V4L2_SLICED_VBI_625V4L2_MPEG_VBI_IVTV_TELETEXT_BV4L2_MPEG_VBI_IVTV_CAPTION_525V4L2_MPEG_VBI_IVTV_WSS_625V4L2_MPEG_VBI_IVTV_VPSV4L2_MPEG_VBI_IVTV_MAGIC0V4L2_MPEG_VBI_IVTV_MAGIC1V4L2_EVENT_ALLV4L2_EVENT_VSYNCV4L2_EVENT_EOSV4L2_EVENT_CTRLV4L2_EVENT_FRAME_SYNCV4L2_EVENT_SOURCE_CHANGEV4L2_EVENT_MOTION_DETV4L2_EVENT_PRIVATE_STARTV4L2_EVENT_CTRL_CH_VALUEV4L2_EVENT_CTRL_CH_FLAGSV4L2_EVENT_CTRL_CH_RANGEV4L2_EVENT_CTRL_CH_DIMENSIONSV4L2_EVENT_SRC_CH_RESOLUTIONV4L2_EVENT_MD_FL_HAVE_FRAME_SEQV4L2_EVENT_SUB_FL_SEND_INITIALV4L2_EVENT_SUB_FL_ALLOW_FEEDBACKV4L2_CHIP_MATCH_BRIDGEV4L2_CHIP_MATCH_SUBDEVV4L2_CHIP_MATCH_HOSTV4L2_CHIP_MATCH_I2C_DRIVERV4L2_CHIP_MATCH_I2C_ADDRV4L2_CHIP_MATCH_AC97V4L2_CHIP_FL_READABLEV4L2_CHIP_FL_WRITABLEBASE_VIDIOC_PRIVATEV4L2_CAP_ASYNCIObindgen_test_layout___fsid_tbindgen_test_layout_timevalbindgen_test_layout___sigset_tbindgen_test_layout_timespec__fds_bitsbindgen_test_layout_fd_setbindgen_test_layout_timezone__itimer_which_ITIMER_REAL__itimer_which__itimer_which_ITIMER_VIRTUAL__itimer_which_ITIMER_PROFbindgen_test_layout_itimerval__itimer_which_tbindgen_test_layout___kernel_fd_setbindgen_test_layout___kernel_fsid_tstart_blockedidv4l2_edidbindgen_test_layout_v4l2_edidv4l2_power_line_frequency_V4L2_CID_POWER_LINE_FREQUENCY_DISABLEDv4l2_power_line_frequencyv4l2_power_line_frequency_V4L2_CID_POWER_LINE_FREQUENCY_50HZv4l2_power_line_frequency_V4L2_CID_POWER_LINE_FREQUENCY_60HZv4l2_power_line_frequency_V4L2_CID_POWER_LINE_FREQUENCY_AUTOv4l2_colorfx_V4L2_COLORFX_NONEv4l2_colorfxv4l2_colorfx_V4L2_COLORFX_BWv4l2_colorfx_V4L2_COLORFX_SEPIAv4l2_colorfx_V4L2_COLORFX_NEGATIVEv4l2_colorfx_V4L2_COLORFX_EMBOSSv4l2_colorfx_V4L2_COLORFX_SKETCHv4l2_colorfx_V4L2_COLORFX_SKY_BLUEv4l2_colorfx_V4L2_COLORFX_GRASS_GREENv4l2_colorfx_V4L2_COLORFX_SKIN_WHITENv4l2_colorfx_V4L2_COLORFX_VIVIDv4l2_colorfx_V4L2_COLORFX_AQUAv4l2_colorfx_V4L2_COLORFX_ART_FREEZEv4l2_colorfx_V4L2_COLORFX_SILHOUETTEv4l2_colorfx_V4L2_COLORFX_SOLARIZATIONv4l2_colorfx_V4L2_COLORFX_ANTIQUEv4l2_colorfx_V4L2_COLORFX_SET_CBCRv4l2_colorfx_V4L2_COLORFX_SET_RGBv4l2_mpeg_stream_type_V4L2_MPEG_STREAM_TYPE_MPEG2_PSv4l2_mpeg_stream_typev4l2_mpeg_stream_type_V4L2_MPEG_STREAM_TYPE_MPEG2_TSv4l2_mpeg_stream_type_V4L2_MPEG_STREAM_TYPE_MPEG1_SSv4l2_mpeg_stream_type_V4L2_MPEG_STREAM_TYPE_MPEG2_DVDv4l2_mpeg_stream_type_V4L2_MPEG_STREAM_TYPE_MPEG1_VCDv4l2_mpeg_stream_type_V4L2_MPEG_STREAM_TYPE_MPEG2_SVCDv4l2_mpeg_stream_vbi_fmt_V4L2_MPEG_STREAM_VBI_FMT_NONEv4l2_mpeg_stream_vbi_fmtv4l2_mpeg_stream_vbi_fmt_V4L2_MPEG_STREAM_VBI_FMT_IVTVv4l2_mpeg_audio_sampling_freq_V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100v4l2_mpeg_audio_sampling_freqv4l2_mpeg_audio_sampling_freq_V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000v4l2_mpeg_audio_sampling_freq_V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000v4l2_mpeg_audio_encoding_V4L2_MPEG_AUDIO_ENCODING_LAYER_1v4l2_mpeg_audio_encodingv4l2_mpeg_audio_encoding_V4L2_MPEG_AUDIO_ENCODING_LAYER_2v4l2_mpeg_audio_encoding_V4L2_MPEG_AUDIO_ENCODING_LAYER_3v4l2_mpeg_audio_encoding_V4L2_MPEG_AUDIO_ENCODING_AACv4l2_mpeg_audio_encoding_V4L2_MPEG_AUDIO_ENCODING_AC3v4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_32Kv4l2_mpeg_audio_l1_bitratev4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_64Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_96Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_128Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_160Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_192Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_224Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_256Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_288Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_320Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_352Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_384Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_416Kv4l2_mpeg_audio_l1_bitrate_V4L2_MPEG_AUDIO_L1_BITRATE_448Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_32Kv4l2_mpeg_audio_l2_bitratev4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_48Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_56Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_64Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_80Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_96Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_112Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_128Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_160Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_192Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_224Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_256Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_320Kv4l2_mpeg_audio_l2_bitrate_V4L2_MPEG_AUDIO_L2_BITRATE_384Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_32Kv4l2_mpeg_audio_l3_bitratev4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_40Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_48Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_56Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_64Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_80Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_96Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_112Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_128Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_160Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_192Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_224Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_256Kv4l2_mpeg_audio_l3_bitrate_V4L2_MPEG_AUDIO_L3_BITRATE_320Kv4l2_mpeg_audio_mode_V4L2_MPEG_AUDIO_MODE_STEREOv4l2_mpeg_audio_modev4l2_mpeg_audio_mode_V4L2_MPEG_AUDIO_MODE_JOINT_STEREOv4l2_mpeg_audio_mode_V4L2_MPEG_AUDIO_MODE_DUALv4l2_mpeg_audio_mode_V4L2_MPEG_AUDIO_MODE_MONOv4l2_mpeg_audio_mode_extension_V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4v4l2_mpeg_audio_mode_extensionv4l2_mpeg_audio_mode_extension_V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_8v4l2_mpeg_audio_mode_extension_V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_12v4l2_mpeg_audio_mode_extension_V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16v4l2_mpeg_audio_emphasis_V4L2_MPEG_AUDIO_EMPHASIS_NONEv4l2_mpeg_audio_emphasisv4l2_mpeg_audio_emphasis_V4L2_MPEG_AUDIO_EMPHASIS_50_DIV_15_uSv4l2_mpeg_audio_emphasis_V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17v4l2_mpeg_audio_crc_V4L2_MPEG_AUDIO_CRC_NONEv4l2_mpeg_audio_crcv4l2_mpeg_audio_crc_V4L2_MPEG_AUDIO_CRC_CRC16v4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_32Kv4l2_mpeg_audio_ac3_bitratev4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_40Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_48Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_56Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_64Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_80Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_96Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_112Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_128Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_160Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_192Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_224Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_256Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_320Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_384Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_448Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_512Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_576Kv4l2_mpeg_audio_ac3_bitrate_V4L2_MPEG_AUDIO_AC3_BITRATE_640Kv4l2_mpeg_audio_dec_playback_V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTOv4l2_mpeg_audio_dec_playbackv4l2_mpeg_audio_dec_playback_V4L2_MPEG_AUDIO_DEC_PLAYBACK_STEREOv4l2_mpeg_audio_dec_playback_V4L2_MPEG_AUDIO_DEC_PLAYBACK_LEFTv4l2_mpeg_audio_dec_playback_V4L2_MPEG_AUDIO_DEC_PLAYBACK_RIGHTv4l2_mpeg_audio_dec_playback_V4L2_MPEG_AUDIO_DEC_PLAYBACK_MONOv4l2_mpeg_audio_dec_playback_V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREOv4l2_mpeg_video_encoding_V4L2_MPEG_VIDEO_ENCODING_MPEG_1v4l2_mpeg_video_encodingv4l2_mpeg_video_encoding_V4L2_MPEG_VIDEO_ENCODING_MPEG_2v4l2_mpeg_video_encoding_V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVCv4l2_mpeg_video_aspect_V4L2_MPEG_VIDEO_ASPECT_1x1v4l2_mpeg_video_aspectv4l2_mpeg_video_aspect_V4L2_MPEG_VIDEO_ASPECT_4x3v4l2_mpeg_video_aspect_V4L2_MPEG_VIDEO_ASPECT_16x9v4l2_mpeg_video_aspect_V4L2_MPEG_VIDEO_ASPECT_221x100v4l2_mpeg_video_bitrate_mode_V4L2_MPEG_VIDEO_BITRATE_MODE_VBRv4l2_mpeg_video_bitrate_modev4l2_mpeg_video_bitrate_mode_V4L2_MPEG_VIDEO_BITRATE_MODE_CBRv4l2_mpeg_video_bitrate_mode_V4L2_MPEG_VIDEO_BITRATE_MODE_CQv4l2_mpeg_video_header_mode_V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATEv4l2_mpeg_video_header_modev4l2_mpeg_video_header_mode_V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAMEv4l2_mpeg_video_multi_slice_mode_V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLEv4l2_mpeg_video_multi_slice_modev4l2_mpeg_video_multi_slice_mode_V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_MBv4l2_mpeg_video_multi_slice_mode_V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTESv4l2_mpeg_video_multi_slice_mode_V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MBv4l2_mpeg_video_multi_slice_mode_V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTESv4l2_mpeg_video_intra_refresh_period_type_V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_RANDOMv4l2_mpeg_video_intra_refresh_period_typev4l2_mpeg_video_intra_refresh_period_type_V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_CYCLICv4l2_mpeg_video_mpeg2_level_V4L2_MPEG_VIDEO_MPEG2_LEVEL_LOWv4l2_mpeg_video_mpeg2_levelv4l2_mpeg_video_mpeg2_level_V4L2_MPEG_VIDEO_MPEG2_LEVEL_MAINv4l2_mpeg_video_mpeg2_level_V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH_1440v4l2_mpeg_video_mpeg2_level_V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGHv4l2_mpeg_video_mpeg2_profile_V4L2_MPEG_VIDEO_MPEG2_PROFILE_SIMPLEv4l2_mpeg_video_mpeg2_profilev4l2_mpeg_video_mpeg2_profile_V4L2_MPEG_VIDEO_MPEG2_PROFILE_MAINv4l2_mpeg_video_mpeg2_profile_V4L2_MPEG_VIDEO_MPEG2_PROFILE_SNR_SCALABLEv4l2_mpeg_video_mpeg2_profile_V4L2_MPEG_VIDEO_MPEG2_PROFILE_SPATIALLY_SCALABLEv4l2_mpeg_video_mpeg2_profile_V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGHv4l2_mpeg_video_mpeg2_profile_V4L2_MPEG_VIDEO_MPEG2_PROFILE_MULTIVIEWv4l2_mpeg_video_h264_entropy_mode_V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLCv4l2_mpeg_video_h264_entropy_modev4l2_mpeg_video_h264_entropy_mode_V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABACv4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_1_0v4l2_mpeg_video_h264_levelv4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_1Bv4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_1_1v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_1_2v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_1_3v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_2_0v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_2_1v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_2_2v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_3_0v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_3_1v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_3_2v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_4_0v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_4_1v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_4_2v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_5_0v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_5_1v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_5_2v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_6_0v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_6_1v4l2_mpeg_video_h264_level_V4L2_MPEG_VIDEO_H264_LEVEL_6_2v4l2_mpeg_video_h264_loop_filter_mode_V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLEDv4l2_mpeg_video_h264_loop_filter_modev4l2_mpeg_video_h264_loop_filter_mode_V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLEDv4l2_mpeg_video_h264_loop_filter_mode_V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARYv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_BASELINEv4l2_mpeg_video_h264_profilev4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINEv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_MAINv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDEDv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGHv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10v4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422v4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVEv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRAv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRAv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRAv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRAv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINEv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGHv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRAv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGHv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGHv4l2_mpeg_video_h264_profile_V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGHv4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIEDv4l2_mpeg_video_h264_vui_sar_idcv4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1v4l2_mpeg_video_h264_vui_sar_idc_V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDEDv4l2_mpeg_video_h264_sei_fp_arrangement_type_V4L2_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE_CHECKERBOARDv4l2_mpeg_video_h264_sei_fp_arrangement_typev4l2_mpeg_video_h264_sei_fp_arrangement_type_V4L2_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE_COLUMNv4l2_mpeg_video_h264_sei_fp_arrangement_type_V4L2_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE_ROWv4l2_mpeg_video_h264_sei_fp_arrangement_type_V4L2_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE_SIDE_BY_SIDEv4l2_mpeg_video_h264_sei_fp_arrangement_type_V4L2_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE_TOP_BOTTOMv4l2_mpeg_video_h264_sei_fp_arrangement_type_V4L2_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE_TEMPORALv4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_INTERLEAVED_SLICESv4l2_mpeg_video_h264_fmo_map_typev4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_SCATTERED_SLICESv4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_FOREGROUND_WITH_LEFT_OVERv4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_BOX_OUTv4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_RASTER_SCANv4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_WIPE_SCANv4l2_mpeg_video_h264_fmo_map_type_V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_EXPLICITv4l2_mpeg_video_h264_fmo_change_dir_V4L2_MPEG_VIDEO_H264_FMO_CHANGE_DIR_RIGHTv4l2_mpeg_video_h264_fmo_change_dirv4l2_mpeg_video_h264_fmo_change_dir_V4L2_MPEG_VIDEO_H264_FMO_CHANGE_DIR_LEFTv4l2_mpeg_video_h264_hierarchical_coding_type_V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_Bv4l2_mpeg_video_h264_hierarchical_coding_typev4l2_mpeg_video_h264_hierarchical_coding_type_V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_Pv4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_0v4l2_mpeg_video_mpeg4_levelv4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_0Bv4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_1v4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_2v4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_3v4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_3Bv4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_4v4l2_mpeg_video_mpeg4_level_V4L2_MPEG_VIDEO_MPEG4_LEVEL_5v4l2_mpeg_video_mpeg4_profile_V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLEv4l2_mpeg_video_mpeg4_profilev4l2_mpeg_video_mpeg4_profile_V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLEv4l2_mpeg_video_mpeg4_profile_V4L2_MPEG_VIDEO_MPEG4_PROFILE_COREv4l2_mpeg_video_mpeg4_profile_V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE_SCALABLEv4l2_mpeg_video_mpeg4_profile_V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCYv4l2_vp8_num_partitions_V4L2_CID_MPEG_VIDEO_VPX_1_PARTITIONv4l2_vp8_num_partitionsv4l2_vp8_num_partitions_V4L2_CID_MPEG_VIDEO_VPX_2_PARTITIONSv4l2_vp8_num_partitions_V4L2_CID_MPEG_VIDEO_VPX_4_PARTITIONSv4l2_vp8_num_partitions_V4L2_CID_MPEG_VIDEO_VPX_8_PARTITIONSv4l2_vp8_num_ref_frames_V4L2_CID_MPEG_VIDEO_VPX_1_REF_FRAMEv4l2_vp8_num_ref_framesv4l2_vp8_num_ref_frames_V4L2_CID_MPEG_VIDEO_VPX_2_REF_FRAMEv4l2_vp8_num_ref_frames_V4L2_CID_MPEG_VIDEO_VPX_3_REF_FRAMEv4l2_vp8_golden_frame_sel_V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_PREVv4l2_vp8_golden_frame_selv4l2_vp8_golden_frame_sel_V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_REF_PERIODv4l2_mpeg_video_vp8_profile_V4L2_MPEG_VIDEO_VP8_PROFILE_0v4l2_mpeg_video_vp8_profilev4l2_mpeg_video_vp8_profile_V4L2_MPEG_VIDEO_VP8_PROFILE_1v4l2_mpeg_video_vp8_profile_V4L2_MPEG_VIDEO_VP8_PROFILE_2v4l2_mpeg_video_vp8_profile_V4L2_MPEG_VIDEO_VP8_PROFILE_3v4l2_mpeg_video_vp9_profile_V4L2_MPEG_VIDEO_VP9_PROFILE_0v4l2_mpeg_video_vp9_profilev4l2_mpeg_video_vp9_profile_V4L2_MPEG_VIDEO_VP9_PROFILE_1v4l2_mpeg_video_vp9_profile_V4L2_MPEG_VIDEO_VP9_PROFILE_2v4l2_mpeg_video_vp9_profile_V4L2_MPEG_VIDEO_VP9_PROFILE_3v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_1_0v4l2_mpeg_video_vp9_levelv4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_1_1v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_2_0v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_2_1v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_3_0v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_3_1v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_4_0v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_4_1v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_5_0v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_5_1v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_5_2v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_6_0v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_6_1v4l2_mpeg_video_vp9_level_V4L2_MPEG_VIDEO_VP9_LEVEL_6_2v4l2_mpeg_video_hevc_hier_coding_type_V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_Bv4l2_mpeg_video_hevc_hier_coding_typev4l2_mpeg_video_hevc_hier_coding_type_V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_Pv4l2_mpeg_video_hevc_profile_V4L2_MPEG_VIDEO_HEVC_PROFILE_MAINv4l2_mpeg_video_hevc_profilev4l2_mpeg_video_hevc_profile_V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTUREv4l2_mpeg_video_hevc_profile_V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_1v4l2_mpeg_video_hevc_levelv4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_2v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_2_1v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_3v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_3_1v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_4v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_4_1v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_5v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_5_1v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_5_2v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_6v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_6_1v4l2_mpeg_video_hevc_level_V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2v4l2_mpeg_video_hevc_tier_V4L2_MPEG_VIDEO_HEVC_TIER_MAINv4l2_mpeg_video_hevc_tierv4l2_mpeg_video_hevc_tier_V4L2_MPEG_VIDEO_HEVC_TIER_HIGHv4l2_cid_mpeg_video_hevc_loop_filter_mode_V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLEDv4l2_cid_mpeg_video_hevc_loop_filter_modev4l2_cid_mpeg_video_hevc_loop_filter_mode_V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_ENABLEDv4l2_cid_mpeg_video_hevc_loop_filter_mode_V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARYv4l2_cid_mpeg_video_hevc_refresh_type_V4L2_MPEG_VIDEO_HEVC_REFRESH_NONEv4l2_cid_mpeg_video_hevc_refresh_typev4l2_cid_mpeg_video_hevc_refresh_type_V4L2_MPEG_VIDEO_HEVC_REFRESH_CRAv4l2_cid_mpeg_video_hevc_refresh_type_V4L2_MPEG_VIDEO_HEVC_REFRESH_IDRv4l2_cid_mpeg_video_hevc_size_of_length_field_V4L2_MPEG_VIDEO_HEVC_SIZE_0v4l2_cid_mpeg_video_hevc_size_of_length_fieldv4l2_cid_mpeg_video_hevc_size_of_length_field_V4L2_MPEG_VIDEO_HEVC_SIZE_1v4l2_cid_mpeg_video_hevc_size_of_length_field_V4L2_MPEG_VIDEO_HEVC_SIZE_2v4l2_cid_mpeg_video_hevc_size_of_length_field_V4L2_MPEG_VIDEO_HEVC_SIZE_4v4l2_mpeg_video_frame_skip_mode_V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLEDv4l2_mpeg_video_frame_skip_modev4l2_mpeg_video_frame_skip_mode_V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMITv4l2_mpeg_video_frame_skip_mode_V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMITv4l2_mpeg_video_av1_profile_V4L2_MPEG_VIDEO_AV1_PROFILE_MAINv4l2_mpeg_video_av1_profilev4l2_mpeg_video_av1_profile_V4L2_MPEG_VIDEO_AV1_PROFILE_HIGHv4l2_mpeg_video_av1_profile_V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONALv4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_2_0v4l2_mpeg_video_av1_levelv4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_2_1v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_2_2v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_2_3v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_3_0v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_3_1v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_3_2v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_3_3v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_4_0v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_4_1v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_4_2v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_4_3v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_5_0v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_5_1v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_5_2v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_5_3v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_6_0v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_6_1v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_6_2v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_6_3v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_7_0v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_7_1v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_7_2v4l2_mpeg_video_av1_level_V4L2_MPEG_VIDEO_AV1_LEVEL_7_3v4l2_mpeg_cx2341x_video_spatial_filter_mode_V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUALv4l2_mpeg_cx2341x_video_spatial_filter_modev4l2_mpeg_cx2341x_video_spatial_filter_mode_V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTOv4l2_mpeg_cx2341x_video_luma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFFv4l2_mpeg_cx2341x_video_luma_spatial_filter_typev4l2_mpeg_cx2341x_video_luma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HORv4l2_mpeg_cx2341x_video_luma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_VERTv4l2_mpeg_cx2341x_video_luma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_HV_SEPARABLEv4l2_mpeg_cx2341x_video_luma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLEv4l2_mpeg_cx2341x_video_chroma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFFv4l2_mpeg_cx2341x_video_chroma_spatial_filter_typev4l2_mpeg_cx2341x_video_chroma_spatial_filter_type_V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HORv4l2_mpeg_cx2341x_video_temporal_filter_mode_V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUALv4l2_mpeg_cx2341x_video_temporal_filter_modev4l2_mpeg_cx2341x_video_temporal_filter_mode_V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTOv4l2_mpeg_cx2341x_video_median_filter_type_V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFFv4l2_mpeg_cx2341x_video_median_filter_typev4l2_mpeg_cx2341x_video_median_filter_type_V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HORv4l2_mpeg_cx2341x_video_median_filter_type_V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_VERTv4l2_mpeg_cx2341x_video_median_filter_type_V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR_VERTv4l2_mpeg_cx2341x_video_median_filter_type_V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAGv4l2_mpeg_mfc51_video_frame_skip_mode_V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLEDv4l2_mpeg_mfc51_video_frame_skip_modev4l2_mpeg_mfc51_video_frame_skip_mode_V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMITv4l2_mpeg_mfc51_video_frame_skip_mode_V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMITv4l2_mpeg_mfc51_video_force_frame_type_V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLEDv4l2_mpeg_mfc51_video_force_frame_typev4l2_mpeg_mfc51_video_force_frame_type_V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAMEv4l2_mpeg_mfc51_video_force_frame_type_V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODEDv4l2_exposure_auto_type_V4L2_EXPOSURE_AUTOv4l2_exposure_auto_typev4l2_exposure_auto_type_V4L2_EXPOSURE_MANUALv4l2_exposure_auto_type_V4L2_EXPOSURE_SHUTTER_PRIORITYv4l2_exposure_auto_type_V4L2_EXPOSURE_APERTURE_PRIORITYv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_MANUALv4l2_auto_n_preset_white_balancev4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_AUTOv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_INCANDESCENTv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_FLUORESCENTv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_FLUORESCENT_Hv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_HORIZONv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_DAYLIGHTv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_FLASHv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_CLOUDYv4l2_auto_n_preset_white_balance_V4L2_WHITE_BALANCE_SHADEv4l2_iso_sensitivity_auto_type_V4L2_ISO_SENSITIVITY_MANUALv4l2_iso_sensitivity_auto_typev4l2_iso_sensitivity_auto_type_V4L2_ISO_SENSITIVITY_AUTOv4l2_exposure_metering_V4L2_EXPOSURE_METERING_AVERAGEv4l2_exposure_meteringv4l2_exposure_metering_V4L2_EXPOSURE_METERING_CENTER_WEIGHTEDv4l2_exposure_metering_V4L2_EXPOSURE_METERING_SPOTv4l2_exposure_metering_V4L2_EXPOSURE_METERING_MATRIXv4l2_scene_mode_V4L2_SCENE_MODE_NONEv4l2_scene_modev4l2_scene_mode_V4L2_SCENE_MODE_BACKLIGHTv4l2_scene_mode_V4L2_SCENE_MODE_BEACH_SNOWv4l2_scene_mode_V4L2_SCENE_MODE_CANDLE_LIGHTv4l2_scene_mode_V4L2_SCENE_MODE_DAWN_DUSKv4l2_scene_mode_V4L2_SCENE_MODE_FALL_COLORSv4l2_scene_mode_V4L2_SCENE_MODE_FIREWORKSv4l2_scene_mode_V4L2_SCENE_MODE_LANDSCAPEv4l2_scene_mode_V4L2_SCENE_MODE_NIGHTv4l2_scene_mode_V4L2_SCENE_MODE_PARTY_INDOORv4l2_scene_mode_V4L2_SCENE_MODE_PORTRAITv4l2_scene_mode_V4L2_SCENE_MODE_SPORTSv4l2_scene_mode_V4L2_SCENE_MODE_SUNSETv4l2_scene_mode_V4L2_SCENE_MODE_TEXTv4l2_auto_focus_range_V4L2_AUTO_FOCUS_RANGE_AUTOv4l2_auto_focus_rangev4l2_auto_focus_range_V4L2_AUTO_FOCUS_RANGE_NORMALv4l2_auto_focus_range_V4L2_AUTO_FOCUS_RANGE_MACROv4l2_auto_focus_range_V4L2_AUTO_FOCUS_RANGE_INFINITYv4l2_preemphasis_V4L2_PREEMPHASIS_DISABLEDv4l2_preemphasisv4l2_preemphasis_V4L2_PREEMPHASIS_50_uSv4l2_preemphasis_V4L2_PREEMPHASIS_75_uSv4l2_flash_led_mode_V4L2_FLASH_LED_MODE_NONEv4l2_flash_led_modev4l2_flash_led_mode_V4L2_FLASH_LED_MODE_FLASHv4l2_flash_led_mode_V4L2_FLASH_LED_MODE_TORCHv4l2_flash_strobe_source_V4L2_FLASH_STROBE_SOURCE_SOFTWAREv4l2_flash_strobe_sourcev4l2_flash_strobe_source_V4L2_FLASH_STROBE_SOURCE_EXTERNALv4l2_jpeg_chroma_subsampling_V4L2_JPEG_CHROMA_SUBSAMPLING_444v4l2_jpeg_chroma_subsamplingv4l2_jpeg_chroma_subsampling_V4L2_JPEG_CHROMA_SUBSAMPLING_422v4l2_jpeg_chroma_subsampling_V4L2_JPEG_CHROMA_SUBSAMPLING_420v4l2_jpeg_chroma_subsampling_V4L2_JPEG_CHROMA_SUBSAMPLING_411v4l2_jpeg_chroma_subsampling_V4L2_JPEG_CHROMA_SUBSAMPLING_410v4l2_jpeg_chroma_subsampling_V4L2_JPEG_CHROMA_SUBSAMPLING_GRAYv4l2_dv_tx_mode_V4L2_DV_TX_MODE_DVI_Dv4l2_dv_tx_modev4l2_dv_tx_mode_V4L2_DV_TX_MODE_HDMIv4l2_dv_rgb_range_V4L2_DV_RGB_RANGE_AUTOv4l2_dv_rgb_rangev4l2_dv_rgb_range_V4L2_DV_RGB_RANGE_LIMITEDv4l2_dv_rgb_range_V4L2_DV_RGB_RANGE_FULLv4l2_dv_it_content_type_V4L2_DV_IT_CONTENT_TYPE_GRAPHICSv4l2_dv_it_content_typev4l2_dv_it_content_type_V4L2_DV_IT_CONTENT_TYPE_PHOTOv4l2_dv_it_content_type_V4L2_DV_IT_CONTENT_TYPE_CINEMAv4l2_dv_it_content_type_V4L2_DV_IT_CONTENT_TYPE_GAMEv4l2_dv_it_content_type_V4L2_DV_IT_CONTENT_TYPE_NO_ITCv4l2_deemphasis_V4L2_DEEMPHASIS_DISABLEDv4l2_deemphasisv4l2_deemphasis_V4L2_DEEMPHASIS_50_uSv4l2_deemphasis_V4L2_DEEMPHASIS_75_uSv4l2_detect_md_mode_V4L2_DETECT_MD_MODE_DISABLEDv4l2_detect_md_modev4l2_detect_md_mode_V4L2_DETECT_MD_MODE_GLOBALv4l2_detect_md_mode_V4L2_DETECT_MD_MODE_THRESHOLD_GRIDv4l2_detect_md_mode_V4L2_DETECT_MD_MODE_REGION_GRIDv4l2_stateless_h264_decode_mode_V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASEDv4l2_stateless_h264_decode_modev4l2_stateless_h264_decode_mode_V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASEDv4l2_stateless_h264_start_code_V4L2_STATELESS_H264_START_CODE_NONEv4l2_stateless_h264_start_codev4l2_stateless_h264_start_code_V4L2_STATELESS_H264_START_CODE_ANNEX_Bprofile_idcconstraint_set_flagslevel_idcseq_parameter_set_idchroma_format_idcbit_depth_luma_minus8bit_depth_chroma_minus8log2_max_frame_num_minus4pic_order_cnt_typelog2_max_pic_order_cnt_lsb_minus4max_num_ref_framesnum_ref_frames_in_pic_order_cnt_cycleoffset_for_ref_frameoffset_for_non_ref_picoffset_for_top_to_bottom_fieldpic_width_in_mbs_minus1pic_height_in_map_units_minus1v4l2_ctrl_h264_spsbindgen_test_layout_v4l2_ctrl_h264_spspic_parameter_set_idnum_slice_groups_minus1num_ref_idx_l0_default_active_minus1num_ref_idx_l1_default_active_minus1weighted_bipred_idcpic_init_qp_minus26pic_init_qs_minus26chroma_qp_index_offsetsecond_chroma_qp_index_offsetv4l2_ctrl_h264_ppsbindgen_test_layout_v4l2_ctrl_h264_ppsscaling_list_4x4scaling_list_8x8v4l2_ctrl_h264_scaling_matrixbindgen_test_layout_v4l2_ctrl_h264_scaling_matrixluma_weightluma_offsetchroma_weightchroma_offsetv4l2_h264_weight_factorsbindgen_test_layout_v4l2_h264_weight_factorsluma_log2_weight_denomchroma_log2_weight_denomweight_factorsv4l2_ctrl_h264_pred_weightsbindgen_test_layout_v4l2_ctrl_h264_pred_weightsv4l2_h264_referencebindgen_test_layout_v4l2_h264_referenceheader_bit_sizefirst_mb_in_sliceslice_typecolour_plane_idredundant_pic_cntcabac_init_idcslice_qp_deltaslice_qs_deltadisable_deblocking_filter_idcslice_alpha_c0_offset_div2slice_beta_offset_div2num_ref_idx_l0_active_minus1num_ref_idx_l1_active_minus1ref_pic_list0ref_pic_list1v4l2_ctrl_h264_slice_paramsbindgen_test_layout_v4l2_ctrl_h264_slice_paramsreference_tspic_numframe_numtop_field_order_cntbottom_field_order_cntv4l2_h264_dpb_entrybindgen_test_layout_v4l2_h264_dpb_entrydpbnal_ref_idcidr_pic_idpic_order_cnt_lsbdelta_pic_order_cnt_bottomdelta_pic_order_cnt0delta_pic_order_cnt1dec_ref_pic_marking_bit_sizepic_order_cnt_bit_sizeslice_group_change_cyclev4l2_ctrl_h264_decode_paramsbindgen_test_layout_v4l2_ctrl_h264_decode_paramsbackward_ref_tsxfer_funcycbcr_encv4l2_ctrl_fwht_paramsbindgen_test_layout_v4l2_ctrl_fwht_paramsquant_updatelf_updatesegment_probsv4l2_vp8_segmentbindgen_test_layout_v4l2_vp8_segmentref_frm_deltamb_mode_deltav4l2_vp8_loop_filterbindgen_test_layout_v4l2_vp8_loop_filtery_ac_qiy_dc_deltay2_dc_deltay2_ac_deltauv_dc_deltauv_ac_deltav4l2_vp8_quantizationbindgen_test_layout_v4l2_vp8_quantizationcoeff_probsy_mode_probsuv_mode_probsmv_probsv4l2_vp8_entropybindgen_test_layout_v4l2_vp8_entropyv4l2_vp8_entropy_coder_statebindgen_test_layout_v4l2_vp8_entropy_coder_statequantcoder_statehorizontal_scalevertical_scaleprob_lastprob_gfnum_dct_partsfirst_part_sizefirst_part_header_bitsdct_part_sizeslast_frame_tsgolden_frame_tsalt_frame_tsv4l2_ctrl_vp8_framebindgen_test_layout_v4l2_ctrl_vp8_framehorizontal_sizevertical_sizevbv_buffer_sizeprofile_and_level_indicationchroma_formatv4l2_ctrl_mpeg2_sequencebindgen_test_layout_v4l2_ctrl_mpeg2_sequenceforward_ref_tsf_codepicture_coding_typepicture_structureintra_dc_precisionv4l2_ctrl_mpeg2_picturebindgen_test_layout_v4l2_ctrl_mpeg2_pictureintra_quantiser_matrixnon_intra_quantiser_matrixchroma_intra_quantiser_matrixchroma_non_intra_quantiser_matrixv4l2_ctrl_mpeg2_quantisationbindgen_test_layout_v4l2_ctrl_mpeg2_quantisationv4l2_stateless_hevc_decode_mode_V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASEDv4l2_stateless_hevc_decode_modev4l2_stateless_hevc_decode_mode_V4L2_STATELESS_HEVC_DECODE_MODE_FRAME_BASEDv4l2_stateless_hevc_start_code_V4L2_STATELESS_HEVC_START_CODE_NONEv4l2_stateless_hevc_start_codev4l2_stateless_hevc_start_code_V4L2_STATELESS_HEVC_START_CODE_ANNEX_Bvideo_parameter_set_idpic_width_in_luma_samplespic_height_in_luma_samplessps_max_dec_pic_buffering_minus1sps_max_num_reorder_picssps_max_latency_increase_plus1log2_min_luma_coding_block_size_minus3log2_diff_max_min_luma_coding_block_sizelog2_min_luma_transform_block_size_minus2log2_diff_max_min_luma_transform_block_sizemax_transform_hierarchy_depth_intermax_transform_hierarchy_depth_intrapcm_sample_bit_depth_luma_minus1pcm_sample_bit_depth_chroma_minus1log2_min_pcm_luma_coding_block_size_minus3log2_diff_max_min_pcm_luma_coding_block_sizenum_short_term_ref_pic_setsnum_long_term_ref_pics_spssps_max_sub_layers_minus1v4l2_ctrl_hevc_spsbindgen_test_layout_v4l2_ctrl_hevc_spsnum_extra_slice_header_bitsinit_qp_minus26diff_cu_qp_delta_depthpps_cb_qp_offsetpps_cr_qp_offsetnum_tile_columns_minus1num_tile_rows_minus1column_width_minus1row_height_minus1pps_beta_offset_div2pps_tc_offset_div2log2_parallel_merge_level_minus2v4l2_ctrl_hevc_ppsbindgen_test_layout_v4l2_ctrl_hevc_ppsfield_picpic_order_cnt_valv4l2_hevc_dpb_entrybindgen_test_layout_v4l2_hevc_dpb_entrydelta_luma_weight_l0luma_offset_l0delta_chroma_weight_l0chroma_offset_l0delta_luma_weight_l1luma_offset_l1delta_chroma_weight_l1chroma_offset_l1delta_chroma_log2_weight_denomv4l2_hevc_pred_weight_tablebindgen_test_layout_v4l2_hevc_pred_weight_tabledata_byte_offsetnum_entry_point_offsetsnal_unit_typenuh_temporal_id_plus1slice_pic_order_cntcollocated_ref_idxfive_minus_max_num_merge_candslice_cb_qp_offsetslice_cr_qp_offsetslice_act_y_qp_offsetslice_act_cb_qp_offsetslice_act_cr_qp_offsetslice_tc_offset_div2pic_structslice_segment_addrref_idx_l0ref_idx_l1short_term_ref_pic_set_sizelong_term_ref_pic_set_sizepred_weight_tablev4l2_ctrl_hevc_slice_paramsbindgen_test_layout_v4l2_ctrl_hevc_slice_paramsnum_active_dpb_entriesnum_poc_st_curr_beforenum_poc_st_curr_afternum_poc_lt_currpoc_st_curr_beforepoc_st_curr_afterpoc_lt_currnum_delta_pocs_of_ref_rps_idxv4l2_ctrl_hevc_decode_paramsbindgen_test_layout_v4l2_ctrl_hevc_decode_paramsscaling_list_16x16scaling_list_32x32scaling_list_dc_coef_16x16scaling_list_dc_coef_32x32v4l2_ctrl_hevc_scaling_matrixbindgen_test_layout_v4l2_ctrl_hevc_scaling_matrixmax_pic_average_light_levelv4l2_ctrl_hdr10_cll_infobindgen_test_layout_v4l2_ctrl_hdr10_cll_infodisplay_primaries_xdisplay_primaries_ywhite_point_xwhite_point_yv4l2_ctrl_hdr10_mastering_displaybindgen_test_layout_v4l2_ctrl_hdr10_mastering_displayref_deltasmode_deltassharpnessv4l2_vp9_loop_filterbindgen_test_layout_v4l2_vp9_loop_filterbase_q_idxdelta_q_y_dcdelta_q_uv_dcdelta_q_uv_acv4l2_vp9_quantizationbindgen_test_layout_v4l2_vp9_quantizationfeature_datafeature_enabledtree_probspred_probsv4l2_vp9_segmentationbindgen_test_layout_v4l2_vp9_segmentationcompressed_header_sizeuncompressed_header_sizeframe_width_minus_1frame_height_minus_1render_width_minus_1render_height_minus_1ref_frame_sign_biasreset_frame_contextframe_context_idxinterpolation_filtertile_cols_log2tile_rows_log2reference_modev4l2_ctrl_vp9_framebindgen_test_layout_v4l2_ctrl_vp9_framejointclass0_bitclass0_frclass0_hphpv4l2_vp9_mv_probsbindgen_test_layout_v4l2_vp9_mv_probstx_modetx8tx16tx32inter_modeinterp_filteris_intercomp_modesingle_refcomp_refy_modeuv_modemvv4l2_ctrl_vp9_compressed_hdrbindgen_test_layout_v4l2_ctrl_vp9_compressed_hdrseq_profileorder_hint_bitsmax_frame_width_minus_1max_frame_height_minus_1v4l2_ctrl_av1_sequencebindgen_test_layout_v4l2_ctrl_av1_sequencetile_offsettile_rowtile_colv4l2_ctrl_av1_tile_group_entrybindgen_test_layout_v4l2_ctrl_av1_tile_group_entryv4l2_av1_warp_model_V4L2_AV1_WARP_MODEL_IDENTITYv4l2_av1_warp_modelv4l2_av1_warp_model_V4L2_AV1_WARP_MODEL_TRANSLATIONv4l2_av1_warp_model_V4L2_AV1_WARP_MODEL_ROTZOOMv4l2_av1_warp_model_V4L2_AV1_WARP_MODEL_AFFINEv4l2_av1_reference_frame_V4L2_AV1_REF_INTRA_FRAMEv4l2_av1_reference_framev4l2_av1_reference_frame_V4L2_AV1_REF_LAST_FRAMEv4l2_av1_reference_frame_V4L2_AV1_REF_LAST2_FRAMEv4l2_av1_reference_frame_V4L2_AV1_REF_LAST3_FRAMEv4l2_av1_reference_frame_V4L2_AV1_REF_GOLDEN_FRAMEv4l2_av1_reference_frame_V4L2_AV1_REF_BWDREF_FRAMEv4l2_av1_reference_frame_V4L2_AV1_REF_ALTREF2_FRAMEv4l2_av1_reference_frame_V4L2_AV1_REF_ALTREF_FRAMEv4l2_av1_global_motionbindgen_test_layout_v4l2_av1_global_motionv4l2_av1_frame_restoration_type_V4L2_AV1_FRAME_RESTORE_NONEv4l2_av1_frame_restoration_typev4l2_av1_frame_restoration_type_V4L2_AV1_FRAME_RESTORE_WIENERv4l2_av1_frame_restoration_type_V4L2_AV1_FRAME_RESTORE_SGRPROJv4l2_av1_frame_restoration_type_V4L2_AV1_FRAME_RESTORE_SWITCHABLElr_unit_shiftlr_uv_shiftframe_restoration_typeloop_restoration_sizev4l2_av1_loop_restorationbindgen_test_layout_v4l2_av1_loop_restorationdamping_minus_3y_pri_strengthy_sec_strengthuv_pri_strengthuv_sec_strengthv4l2_av1_cdefbindgen_test_layout_v4l2_av1_cdefv4l2_av1_segment_feature_V4L2_AV1_SEG_LVL_ALT_Qv4l2_av1_segment_featurev4l2_av1_segment_feature_V4L2_AV1_SEG_LVL_ALT_LF_Y_Vv4l2_av1_segment_feature_V4L2_AV1_SEG_LVL_REF_FRAMEv4l2_av1_segment_feature_V4L2_AV1_SEG_LVL_REF_SKIPv4l2_av1_segment_feature_V4L2_AV1_SEG_LVL_REF_GLOBALMVv4l2_av1_segment_feature_V4L2_AV1_SEG_LVL_MAXlast_active_seg_idv4l2_av1_segmentationbindgen_test_layout_v4l2_av1_segmentationdelta_lf_resv4l2_av1_loop_filterbindgen_test_layout_v4l2_av1_loop_filterdelta_q_u_dcdelta_q_u_acdelta_q_v_dcdelta_q_v_acqm_yqm_uqm_vdelta_q_resv4l2_av1_quantizationbindgen_test_layout_v4l2_av1_quantizationcontext_update_tile_idtile_colstile_rowsmi_col_startsmi_row_startswidth_in_sbs_minus_1height_in_sbs_minus_1tile_size_bytesv4l2_av1_tile_infobindgen_test_layout_v4l2_av1_tile_infov4l2_av1_frame_type_V4L2_AV1_KEY_FRAMEv4l2_av1_frame_typev4l2_av1_frame_type_V4L2_AV1_INTER_FRAMEv4l2_av1_frame_type_V4L2_AV1_INTRA_ONLY_FRAMEv4l2_av1_frame_type_V4L2_AV1_SWITCH_FRAMEv4l2_av1_interpolation_filter_V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAPv4l2_av1_interpolation_filterv4l2_av1_interpolation_filter_V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTHv4l2_av1_interpolation_filter_V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARPv4l2_av1_interpolation_filter_V4L2_AV1_INTERPOLATION_FILTER_BILINEARv4l2_av1_interpolation_filter_V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLEv4l2_av1_tx_mode_V4L2_AV1_TX_MODE_ONLY_4X4v4l2_av1_tx_modev4l2_av1_tx_mode_V4L2_AV1_TX_MODE_LARGESTv4l2_av1_tx_mode_V4L2_AV1_TX_MODE_SELECTtile_infosuperres_denomsegmentationcdefskip_mode_frameprimary_ref_frameloop_restorationglobal_motionorder_hintupscaled_widthcurrent_frame_idbuffer_removal_timeorder_hintsreference_frame_tsref_frame_idxrefresh_frame_flagsv4l2_ctrl_av1_framebindgen_test_layout_v4l2_ctrl_av1_framecr_multgrain_seedfilm_grain_params_ref_idxnum_y_pointspoint_y_valuepoint_y_scalingnum_cb_pointspoint_cb_valuepoint_cb_scalingnum_cr_pointspoint_cr_valuepoint_cr_scalinggrain_scaling_minus_8ar_coeff_lagar_coeffs_y_plus_128ar_coeffs_cb_plus_128ar_coeffs_cr_plus_128ar_coeff_shift_minus_6grain_scale_shiftcb_multcb_luma_multcr_luma_multcb_offsetcr_offsetv4l2_ctrl_av1_film_grainbindgen_test_layout_v4l2_ctrl_av1_film_grainv4l2_field_V4L2_FIELD_ANYv4l2_fieldv4l2_field_V4L2_FIELD_NONEv4l2_field_V4L2_FIELD_TOPv4l2_field_V4L2_FIELD_BOTTOMv4l2_field_V4L2_FIELD_INTERLACEDv4l2_field_V4L2_FIELD_SEQ_TBv4l2_field_V4L2_FIELD_SEQ_BTv4l2_field_V4L2_FIELD_ALTERNATEv4l2_field_V4L2_FIELD_INTERLACED_TBv4l2_field_V4L2_FIELD_INTERLACED_BTv4l2_buf_type_V4L2_BUF_TYPE_VIDEO_CAPTUREv4l2_buf_typev4l2_buf_type_V4L2_BUF_TYPE_VIDEO_OUTPUTv4l2_buf_type_V4L2_BUF_TYPE_VIDEO_OVERLAYv4l2_buf_type_V4L2_BUF_TYPE_VBI_CAPTUREv4l2_buf_type_V4L2_BUF_TYPE_VBI_OUTPUTv4l2_buf_type_V4L2_BUF_TYPE_SLICED_VBI_CAPTUREv4l2_buf_type_V4L2_BUF_TYPE_SLICED_VBI_OUTPUTv4l2_buf_type_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAYv4l2_buf_type_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANEv4l2_buf_type_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANEv4l2_buf_type_V4L2_BUF_TYPE_SDR_CAPTUREv4l2_buf_type_V4L2_BUF_TYPE_SDR_OUTPUTv4l2_buf_type_V4L2_BUF_TYPE_META_CAPTUREv4l2_buf_type_V4L2_BUF_TYPE_META_OUTPUTv4l2_buf_type_V4L2_BUF_TYPE_PRIVATEv4l2_tuner_type_V4L2_TUNER_RADIOv4l2_tuner_typev4l2_tuner_type_V4L2_TUNER_ANALOG_TVv4l2_tuner_type_V4L2_TUNER_DIGITAL_TVv4l2_tuner_type_V4L2_TUNER_SDRv4l2_tuner_type_V4L2_TUNER_RFv4l2_memory_V4L2_MEMORY_MMAPv4l2_memoryv4l2_memory_V4L2_MEMORY_USERPTRv4l2_memory_V4L2_MEMORY_OVERLAYv4l2_memory_V4L2_MEMORY_DMABUFv4l2_colorspace_V4L2_COLORSPACE_DEFAULTv4l2_colorspacev4l2_colorspace_V4L2_COLORSPACE_SMPTE170Mv4l2_colorspace_V4L2_COLORSPACE_SMPTE240Mv4l2_colorspace_V4L2_COLORSPACE_REC709v4l2_colorspace_V4L2_COLORSPACE_BT878v4l2_colorspace_V4L2_COLORSPACE_470_SYSTEM_Mv4l2_colorspace_V4L2_COLORSPACE_470_SYSTEM_BGv4l2_colorspace_V4L2_COLORSPACE_JPEGv4l2_colorspace_V4L2_COLORSPACE_SRGBv4l2_colorspace_V4L2_COLORSPACE_OPRGBv4l2_colorspace_V4L2_COLORSPACE_BT2020v4l2_colorspace_V4L2_COLORSPACE_RAWv4l2_colorspace_V4L2_COLORSPACE_DCI_P3v4l2_xfer_func_V4L2_XFER_FUNC_DEFAULTv4l2_xfer_funcv4l2_xfer_func_V4L2_XFER_FUNC_709v4l2_xfer_func_V4L2_XFER_FUNC_SRGBv4l2_xfer_func_V4L2_XFER_FUNC_OPRGBv4l2_xfer_func_V4L2_XFER_FUNC_SMPTE240Mv4l2_xfer_func_V4L2_XFER_FUNC_NONEv4l2_xfer_func_V4L2_XFER_FUNC_DCI_P3v4l2_xfer_func_V4L2_XFER_FUNC_SMPTE2084v4l2_ycbcr_encoding_V4L2_YCBCR_ENC_DEFAULTv4l2_ycbcr_encodingv4l2_ycbcr_encoding_V4L2_YCBCR_ENC_601v4l2_ycbcr_encoding_V4L2_YCBCR_ENC_709v4l2_ycbcr_encoding_V4L2_YCBCR_ENC_XV601v4l2_ycbcr_encoding_V4L2_YCBCR_ENC_XV709v4l2_ycbcr_encoding_V4L2_YCBCR_ENC_SYCCv4l2_ycbcr_encoding_V4L2_YCBCR_ENC_BT2020v4l2_ycbcr_encoding_V4L2_YCBCR_ENC_BT2020_CONST_LUMv4l2_ycbcr_encoding_V4L2_YCBCR_ENC_SMPTE240Mv4l2_hsv_encoding_V4L2_HSV_ENC_180v4l2_hsv_encodingv4l2_hsv_encoding_V4L2_HSV_ENC_256v4l2_quantization_V4L2_QUANTIZATION_DEFAULTv4l2_quantizationv4l2_quantization_V4L2_QUANTIZATION_FULL_RANGEv4l2_quantization_V4L2_QUANTIZATION_LIM_RANGEv4l2_priority_V4L2_PRIORITY_UNSETv4l2_priorityv4l2_priority_V4L2_PRIORITY_BACKGROUNDv4l2_priority_V4L2_PRIORITY_INTERACTIVEv4l2_priority_V4L2_PRIORITY_RECORDv4l2_priority_V4L2_PRIORITY_DEFAULTv4l2_rectbindgen_test_layout_v4l2_rectbindgen_test_layout_v4l2_fractv4l2_areabindgen_test_layout_v4l2_areabus_infodevice_capsbindgen_test_layout_v4l2_capabilitypixelformatbytesperlinesizeimagev4l2_pix_format__bindgen_ty_1hsv_encbindgen_test_layout_v4l2_pix_format__bindgen_ty_1bindgen_test_layout_v4l2_pix_formatmbus_codebindgen_test_layout_v4l2_fmtdescv4l2_frmsizetypes_V4L2_FRMSIZE_TYPE_DISCRETEv4l2_frmsizetypesv4l2_frmsizetypes_V4L2_FRMSIZE_TYPE_CONTINUOUSv4l2_frmsizetypes_V4L2_FRMSIZE_TYPE_STEPWISEv4l2_frmsize_discretebindgen_test_layout_v4l2_frmsize_discretev4l2_frmsize_stepwisebindgen_test_layout_v4l2_frmsize_stepwisev4l2_frmsizeenum__bindgen_ty_1stepwisebindgen_test_layout_v4l2_frmsizeenum__bindgen_ty_1bindgen_test_layout_v4l2_frmsizeenumv4l2_frmivaltypes_V4L2_FRMIVAL_TYPE_DISCRETEv4l2_frmivaltypesv4l2_frmivaltypes_V4L2_FRMIVAL_TYPE_CONTINUOUSv4l2_frmivaltypes_V4L2_FRMIVAL_TYPE_STEPWISEv4l2_frmival_stepwisebindgen_test_layout_v4l2_frmival_stepwisev4l2_frmivalenum__bindgen_ty_1bindgen_test_layout_v4l2_frmivalenum__bindgen_ty_1bindgen_test_layout_v4l2_frmivalenumuserbitsv4l2_timecodebindgen_test_layout_v4l2_timecodeAPPnAPP_lenAPP_dataCOM_lenCOM_datajpeg_markersv4l2_jpegcompressionbindgen_test_layout_v4l2_jpegcompressionbindgen_test_layout_v4l2_requestbuffersv4l2_plane__bindgen_ty_1v4l2_planemem_offsetbindgen_test_layout_v4l2_plane__bindgen_ty_1bindgen_test_layout_v4l2_planetimecodev4l2_buffer__bindgen_ty_1v4l2_buffer__bindgen_ty_2bindgen_test_layout_v4l2_buffer__bindgen_ty_1bindgen_test_layout_v4l2_buffer__bindgen_ty_2bindgen_test_layout_v4l2_bufferv4l2_exportbufferbindgen_test_layout_v4l2_exportbufferv4l2_framebuffer__bindgen_ty_1v4l2_framebufferbindgen_test_layout_v4l2_framebuffer__bindgen_ty_1bindgen_test_layout_v4l2_framebufferv4l2_clipbindgen_test_layout_v4l2_clipchromakeyclipsclipcountglobal_alphav4l2_windowbindgen_test_layout_v4l2_windowcapturemodetimeperframeextendedmodereadbuffersbindgen_test_layout_v4l2_captureparmoutputmodewritebuffersbindgen_test_layout_v4l2_outputparmdefrectpixelaspectv4l2_cropcapbindgen_test_layout_v4l2_cropcapv4l2_cropbindgen_test_layout_v4l2_cropv4l2_selectionbindgen_test_layout_v4l2_selectionv4l2_std_idframeperiodframelinesv4l2_standardbindgen_test_layout_v4l2_standardpolaritiespixelclockhfrontporchhbackporchvfrontporchvbackporchil_vfrontporchil_vsyncil_vbackporchstandardspicture_aspectcea861_vichdmi_vic46usizev4l2_bt_timingsbindgen_test_layout_v4l2_bt_timingsv4l2_dv_timings__bindgen_ty_1v4l2_dv_timingsbtbindgen_test_layout_v4l2_dv_timings__bindgen_ty_1bindgen_test_layout_v4l2_dv_timingsv4l2_enum_dv_timingsbindgen_test_layout_v4l2_enum_dv_timingsmin_pixelclockmax_pixelclockv4l2_bt_timings_capbindgen_test_layout_v4l2_bt_timings_capv4l2_dv_timings_cap__bindgen_ty_1v4l2_dv_timings_capbindgen_test_layout_v4l2_dv_timings_cap__bindgen_ty_1bindgen_test_layout_v4l2_dv_timings_capaudiosettunerv4l2_inputbindgen_test_layout_v4l2_inputmodulatorv4l2_outputbindgen_test_layout_v4l2_outputbindgen_test_layout_v4l2_controlv4l2_ext_control__bindgen_ty_1value64p_u8p_u16p_u32p_s32p_s64p_areap_h264_spsp_h264_ppsp_h264_scaling_matrixp_h264_pred_weightsp_h264_slice_paramsp_h264_decode_paramsp_fwht_paramsp_vp8_framep_mpeg2_sequencep_mpeg2_picturep_mpeg2_quantisationp_vp9_compressed_hdr_probsp_vp9_framep_hevc_spsp_hevc_ppsp_hevc_slice_paramsp_hevc_scaling_matrixp_hevc_decode_paramsp_av1_sequencep_av1_tile_group_entryp_av1_framep_av1_film_grainp_hdr10_cll_infop_hdr10_mastering_displaybindgen_test_layout_v4l2_ext_control__bindgen_ty_1bindgen_test_layout_v4l2_ext_controlv4l2_ext_controls__bindgen_ty_1ctrl_classbindgen_test_layout_v4l2_ext_controls__bindgen_ty_1bindgen_test_layout_v4l2_ext_controlsv4l2_ctrl_type_V4L2_CTRL_TYPE_INTEGERv4l2_ctrl_typev4l2_ctrl_type_V4L2_CTRL_TYPE_BOOLEANv4l2_ctrl_type_V4L2_CTRL_TYPE_MENUv4l2_ctrl_type_V4L2_CTRL_TYPE_BUTTONv4l2_ctrl_type_V4L2_CTRL_TYPE_INTEGER64v4l2_ctrl_type_V4L2_CTRL_TYPE_CTRL_CLASSv4l2_ctrl_type_V4L2_CTRL_TYPE_STRINGv4l2_ctrl_type_V4L2_CTRL_TYPE_BITMASKv4l2_ctrl_type_V4L2_CTRL_TYPE_INTEGER_MENUv4l2_ctrl_type_V4L2_CTRL_COMPOUND_TYPESv4l2_ctrl_type_V4L2_CTRL_TYPE_U8v4l2_ctrl_type_V4L2_CTRL_TYPE_U16v4l2_ctrl_type_V4L2_CTRL_TYPE_U32v4l2_ctrl_type_V4L2_CTRL_TYPE_AREAv4l2_ctrl_type_V4L2_CTRL_TYPE_HDR10_CLL_INFOv4l2_ctrl_type_V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAYv4l2_ctrl_type_V4L2_CTRL_TYPE_H264_SPSv4l2_ctrl_type_V4L2_CTRL_TYPE_H264_PPSv4l2_ctrl_type_V4L2_CTRL_TYPE_H264_SCALING_MATRIXv4l2_ctrl_type_V4L2_CTRL_TYPE_H264_SLICE_PARAMSv4l2_ctrl_type_V4L2_CTRL_TYPE_H264_DECODE_PARAMSv4l2_ctrl_type_V4L2_CTRL_TYPE_H264_PRED_WEIGHTSv4l2_ctrl_type_V4L2_CTRL_TYPE_FWHT_PARAMSv4l2_ctrl_type_V4L2_CTRL_TYPE_VP8_FRAMEv4l2_ctrl_type_V4L2_CTRL_TYPE_MPEG2_QUANTISATIONv4l2_ctrl_type_V4L2_CTRL_TYPE_MPEG2_SEQUENCEv4l2_ctrl_type_V4L2_CTRL_TYPE_MPEG2_PICTUREv4l2_ctrl_type_V4L2_CTRL_TYPE_VP9_COMPRESSED_HDRv4l2_ctrl_type_V4L2_CTRL_TYPE_VP9_FRAMEv4l2_ctrl_type_V4L2_CTRL_TYPE_HEVC_SPSv4l2_ctrl_type_V4L2_CTRL_TYPE_HEVC_PPSv4l2_ctrl_type_V4L2_CTRL_TYPE_HEVC_SLICE_PARAMSv4l2_ctrl_type_V4L2_CTRL_TYPE_HEVC_SCALING_MATRIXv4l2_ctrl_type_V4L2_CTRL_TYPE_HEVC_DECODE_PARAMSv4l2_ctrl_type_V4L2_CTRL_TYPE_AV1_SEQUENCEv4l2_ctrl_type_V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRYv4l2_ctrl_type_V4L2_CTRL_TYPE_AV1_FRAMEv4l2_ctrl_type_V4L2_CTRL_TYPE_AV1_FILM_GRAINv4l2_queryctrlbindgen_test_layout_v4l2_queryctrlelem_sizenr_of_dimsdimsbindgen_test_layout_v4l2_query_ext_ctrlv4l2_querymenu__bindgen_ty_1bindgen_test_layout_v4l2_querymenu__bindgen_ty_1bindgen_test_layout_v4l2_querymenurangelowrangehighrxsubchansaudmodeafcv4l2_tunerbindgen_test_layout_v4l2_tunertxsubchansv4l2_modulatorbindgen_test_layout_v4l2_modulatorv4l2_frequencybindgen_test_layout_v4l2_frequencymodulationv4l2_frequency_bandbindgen_test_layout_v4l2_frequency_bandseek_upwardwrap_aroundv4l2_hw_freq_seekbindgen_test_layout_v4l2_hw_freq_seekv4l2_rds_databindgen_test_layout_v4l2_rds_databindgen_test_layout_v4l2_audiov4l2_audiooutbindgen_test_layout_v4l2_audiooutv4l2_enc_idx_entrybindgen_test_layout_v4l2_enc_idx_entryentries_capv4l2_enc_idxbindgen_test_layout_v4l2_enc_idxv4l2_encoder_cmd__bindgen_ty_1v4l2_encoder_cmdv4l2_encoder_cmd__bindgen_ty_1__bindgen_ty_1bindgen_test_layout_v4l2_encoder_cmd__bindgen_ty_1__bindgen_ty_1bindgen_test_layout_v4l2_encoder_cmd__bindgen_ty_1bindgen_test_layout_v4l2_encoder_cmdv4l2_decoder_cmd__bindgen_ty_1v4l2_decoder_cmdv4l2_decoder_cmd__bindgen_ty_1__bindgen_ty_1v4l2_decoder_cmd__bindgen_ty_1__bindgen_ty_2v4l2_decoder_cmd__bindgen_ty_1__bindgen_ty_3bindgen_test_layout_v4l2_decoder_cmd__bindgen_ty_1__bindgen_ty_1bindgen_test_layout_v4l2_decoder_cmd__bindgen_ty_1__bindgen_ty_2bindgen_test_layout_v4l2_decoder_cmd__bindgen_ty_1__bindgen_ty_3bindgen_test_layout_v4l2_decoder_cmd__bindgen_ty_1bindgen_test_layout_v4l2_decoder_cmdsamples_per_linev4l2_vbi_formatbindgen_test_layout_v4l2_vbi_formatservice_setservice_linesio_sizev4l2_sliced_vbi_formatbindgen_test_layout_v4l2_sliced_vbi_formatv4l2_sliced_vbi_capbindgen_test_layout_v4l2_sliced_vbi_capv4l2_sliced_vbi_databindgen_test_layout_v4l2_sliced_vbi_data42usizev4l2_mpeg_vbi_itv0_linebindgen_test_layout_v4l2_mpeg_vbi_itv0_linelinemask35usizev4l2_mpeg_vbi_itv0bindgen_test_layout_v4l2_mpeg_vbi_itv0v4l2_mpeg_vbi_ITV0bindgen_test_layout_v4l2_mpeg_vbi_ITV0v4l2_mpeg_vbi_fmt_ivtv__bindgen_ty_1v4l2_mpeg_vbi_fmt_ivtvitv0ITV0bindgen_test_layout_v4l2_mpeg_vbi_fmt_ivtv__bindgen_ty_1bindgen_test_layout_v4l2_mpeg_vbi_fmt_ivtvv4l2_plane_pix_formatbindgen_test_layout_v4l2_plane_pix_formatplane_fmtnum_planesv4l2_pix_format_mplane__bindgen_ty_1v4l2_pix_format_mplanebindgen_test_layout_v4l2_pix_format_mplane__bindgen_ty_1bindgen_test_layout_v4l2_pix_format_mplanev4l2_sdr_formatbindgen_test_layout_v4l2_sdr_formatdataformatv4l2_meta_formatbindgen_test_layout_v4l2_meta_formatv4l2_format__bindgen_ty_1v4l2_formatpixpix_mpvbislicedsdr200usizebindgen_test_layout_v4l2_format__bindgen_ty_1bindgen_test_layout_v4l2_formatparmv4l2_streamparm__bindgen_ty_1v4l2_streamparmbindgen_test_layout_v4l2_streamparm__bindgen_ty_1bindgen_test_layout_v4l2_streamparmv4l2_event_vsyncbindgen_test_layout_v4l2_event_vsyncchangesv4l2_event_ctrl__bindgen_ty_1v4l2_event_ctrlbindgen_test_layout_v4l2_event_ctrl__bindgen_ty_1bindgen_test_layout_v4l2_event_ctrlframe_sequencev4l2_event_frame_syncbindgen_test_layout_v4l2_event_frame_syncv4l2_event_src_changebindgen_test_layout_v4l2_event_src_changeregion_maskv4l2_event_motion_detbindgen_test_layout_v4l2_event_motion_detv4l2_event__bindgen_ty_1v4l2_eventframe_syncsrc_changemotion_detbindgen_test_layout_v4l2_event__bindgen_ty_1bindgen_test_layout_v4l2_eventv4l2_event_subscriptionbindgen_test_layout_v4l2_event_subscriptionv4l2_dbg_match__bindgen_ty_1v4l2_dbg_matchbindgen_test_layout_v4l2_dbg_match__bindgen_ty_1bindgen_test_layout_v4l2_dbg_matchv4l2_dbg_registerbindgen_test_layout_v4l2_dbg_registerv4l2_dbg_chip_infobindgen_test_layout_v4l2_dbg_chip_infomax_num_buffersv4l2_create_buffersbindgen_test_layout_v4l2_create_buffers// https://github.com/rust-lang/rust-bindgen/issues/1651/// should the cargo metadata actually be emitted
emit_includes/// should cargo:include= metadata be emitted (defaults to false)
required_libs/// .lib/.a files that must be be found for probing to be considered successful
required_dlls/// .dlls that must be be found for probing to be considered successful
copy_dlls/// should DLLs be copied to OUT_DIR?
vcpkg_root/// override VCPKG_ROOT environment variable
TargetTriplet/// Configuration options for finding packages, setting up the tree and emitting metadata to cargo
/// Paths for the linker to search for static or import libraries
dll_paths/// Paths to search at runtme to find DLLs
/// Paths to include files
/// cargo: metadata lines
/// libraries found are static
found_dlls/// DLLs found
found_libs/// static libs or import libs found
found_names/// link name of libraries found, this is useful to emit linker commands
/// ports that are providing the libraries to link to, in port link order
vcpkg_triplet/// the vcpkg triplet that has been selected
/// Details of a package that was found
tripletlib_suffixstrip_lib_prefixDisabledByEnv/// Aborted because of a `VCPKGRS_NO_*` environment variable.
/// Contains the name of the responsible environment variable.
RequiredEnvMissing/// Aborted because a required environment variable was not set.
NotMSVC/// On Windows, only MSVC ABI is supported
VcpkgNotFound/// Can't find a vcpkg tree
LibNotFound/// Library not found in vcpkg tree
VcpkgInstallation/// Could not understand vcpkg installation
// need Display?
probe_package/// Deprecated in favor of the find_package function
/// Find the package `package` in a Vcpkg tree.
/// Emits cargo metadata to link to libraries provided by the Vcpkg package/port
/// named, and any (non-system) libraries that they depend on.
/// This will select the architecture and linkage based on environment
/// variables and build flags as described in the module docs.
find_vcpkg_root/// Find the vcpkg root
validate_vcpkg_rootfind_vcpkg_targetVcpkgTarget/// The pkg-config name of this library.
/// List of libraries found as '-l', translated to a given vcpkg_target. e.g. libbrotlicommon.a
/// List of pkgconfig dependencies, e.g. PcFile::id.
PcFile/// Parsed knowledge from a .pc file.
parse_pc_filePcFiles/// Collection of PcFile.  Can be built and queried as a set of .pc files.
load_pkgconfig_dirfix_ordering/// Use the .pc files as a hint to the library sort order.
locate_pc_file_by_lib/// Locate which PcFile contains this library, if any.
dlls// dlls if any
// libs (static or import)
// ports that this port depends on
load_port_manifestload_port_file// load ports from the status file or one of the incremental updates
load_portslib_pathbin_pathinclude_pathstatus_path// directory containing the status file
packages_path// directory containing the install files per port.
target_triplet// target-specific settings.
/// paths and triple for the chosen target
link_name_for_libget_target_triplet/// Find the package `port_name` in a Vcpkg tree.
/// variables and build flags as described in the module docs, and any configuration
/// set on the builder.
/// Define whether metadata should be emitted for cargo allowing it to
/// automatically link the binary. Defaults to `true`.
/// Define cargo:include= metadata should be emitted. Defaults to `false`.
/// Should DLLs be copied to OUT_DIR?
/// Defaults to `true`.
/// Define which path to use as vcpkg root overriding the VCPKG_ROOT environment variable
/// Default to `None`, which means use VCPKG_ROOT or try to find out automatically
/// Specify target triplet. When triplet is not specified, inferred triplet from rust target is used.
/// Specifying a triplet using `target_triplet` will override the default triplet for this crate. This
/// cannot change the choice of triplet made by other crates, so a safer choice will be to set
/// `VCPKGRS_TRIPLET` in the environment which will allow all crates to use a consistent set of
/// external dependencies.
/// Find the library `port_name` in a Vcpkg tree.
/// This will use all configuration previously set to select the
/// architecture and linkage.
emit_libsdo_dll_copy/// Override the name of the library to look for if it differs from the package name.
/// It should not be necessary to use `lib_name` anymore. Calling `find_package` with a package name
/// will result in the correct library names.
/// This may be called more than once if multiple libs are required.
/// All libs must be found for the probe to succeed. `.probe()` must
/// be run with a different configuration to look for libraries under one of several names.
/// `.libname("ssleay32")` will look for ssleay32.lib and also ssleay32.dll if
/// dynamic linking is selected.
lib_names/// It should not be necessary to use `lib_names` anymore. Calling `find_package` with a package name
/// `.lib_names("libcurl_imp","curl")` will look for libcurl_imp.lib and also curl.dll if
msvc_targetdo_nothing_for_unsupported_targetdo_nothing_for_bailout_variables_setstatic_build_finds_lib// these tests are good but are leaning on a real vcpkg installation
// #[test]
// fn default_build_refuses_dynamic() {
//     let _g = LOCK.lock();
//     clean_env();
//     env::set_var("VCPKG_ROOT", vcpkg_test_tree_loc("no-status"));
//     env::set_var("TARGET", "x86_64-pc-windows-msvc");
//     println!("Result is {:?}", ::find_package("libmysql"));
//     assert!(match ::find_package("libmysql") {
//         Err(Error::RequiredEnvMissing(ref v)) if v == "VCPKGRS_DYNAMIC" => true,
//         _ => false,
//     });
dynamic_build_finds_libhandle_multiline_descriptionlink_libs_required_by_optional_featureslink_lib_name_is_correctlink_dependencies_after_portcustom_target_triplet_in_configcustom_target_triplet_by_env_no_defaultcustom_target_triplet_by_env_with_defaultpc_files_reordering// fn dynamic_build_package_specific_bailout() {
//     env::set_var("VCPKGRS_DYNAMIC", "1");
//     env::set_var("VCPKGRS_NO_LIBMYSQL", "1");
//         Err(Error::DisabledByEnv(ref v)) if v == "VCPKGRS_NO_LIBMYSQL" => true,
// fn dynamic_build_global_bailout() {
//     env::set_var("VCPKGRS_DISABLE", "1");
//         Err(Error::DisabledByEnv(ref v)) if v == "VCPKGRS_DISABLE" => true,
clean_envvcpkg_test_tree_loc// path to a to vcpkg installation to test against
//! A build dependency for Cargo libraries to find libraries in a
//! [Vcpkg](https://github.com/microsoft/vcpkg) tree
//! From a Vcpkg package name
//! this build helper will emit cargo metadata to link it and it's dependencies
//! (excluding system libraries, which it does not determine).
//! The simplest possible usage looks like this :-
//! ```rust,no_run
//! // build.rs
//! vcpkg::find_package("libssh2").unwrap();
//! The cargo metadata that is emitted can be changed like this :-
//! vcpkg::Config::new()
//!     .emit_includes(true)
//!     .find_package("zlib").unwrap();
//! If the search was successful all appropriate Cargo metadata will be printed
//! to stdout.
//! # Static vs. dynamic linking
//! ## Linux and Mac
//! At this time, vcpkg has a single triplet on macOS and Linux, which builds
//! static link versions of libraries. This triplet works well with Rust. It is also possible
//! to select a custom triplet using the `VCPKGRS_TRIPLET` environment variable.
//! ## Windows
//! On Windows there are three
//! configurations that are supported for 64-bit builds and another three for 32-bit.
//! The default 64-bit configuration is `x64-windows-static-md` which is a
//! [community supported](https://github.com/microsoft/vcpkg/blob/master/docs/users/triplets.md#community-triplets)
//! configuration that is a good match for Rust - dynamically linking to the C runtime,
//! and statically linking to the packages in vcpkg.
//! Another option is to build a fully static
//! binary using `RUSTFLAGS=-Ctarget-feature=+crt-static`. This will link to libraries built
//! with vcpkg triplet `x64-windows-static`.
//! For dynamic linking, set `VCPKGRS_DYNAMIC=1` in the
//! environment. This will link to libraries built with vcpkg triplet `x64-windows`. If `VCPKGRS_DYNAMIC` is set, `cargo install` will
//! generate dynamically linked binaries, in which case you will have to arrange for
//! dlls from your Vcpkg installation to be available in your path.
//! # Environment variables
//! A number of environment variables are available to globally configure which
//! libraries are selected.
//! * `VCPKG_ROOT` - Set the directory to look in for a vcpkg installation. If
//! it is not set, vcpkg will use the user-wide installation if one has been
//! set up with `vcpkg integrate install`, and check the crate source and target
//! to see if a vcpkg tree has been created by [cargo-vcpkg](https://crates.io/crates/cargo-vcpkg).
//! * `VCPKGRS_TRIPLET` - Use this to override vcpkg-rs' default triplet selection with your own.
//! This is how to select a custom vcpkg triplet.
//! * `VCPKGRS_NO_FOO` - if set, vcpkg-rs will not attempt to find the
//! library named `foo`.
//! * `VCPKGRS_DISABLE` - if set, vcpkg-rs will not attempt to find any libraries.
//! * `VCPKGRS_DYNAMIC` - if set, vcpkg-rs will link to DLL builds of ports.
//! # Related tools
//! ## cargo vcpkg
//! [`cargo vcpkg`](https://crates.io/crates/cargo-vcpkg) can fetch and build a vcpkg installation of
//! required packages from scratch. It merges package requirements specified in the `Cargo.toml` of
//! crates in the dependency tree.  
//! ## vcpkg_cli
//! There is also a rudimentary companion crate, `vcpkg_cli` that allows testing of environment
//! and flag combinations.
//! ```Batchfile
//! C:\src> vcpkg_cli probe -l static mysqlclient
//! Found library mysqlclient
//! Include paths:
//!         C:\src\[..]\vcpkg\installed\x64-windows-static\include
//! Library paths:
//!         C:\src\[..]\vcpkg\installed\x64-windows-static\lib
//! Cargo metadata:
//!         cargo:rustc-link-search=native=C:\src\[..]\vcpkg\installed\x64-windows-static\lib
//!         cargo:rustc-link-lib=static=mysqlclient
// The CI will test vcpkg-rs on 1.12 because that is how far back vcpkg-rs 0.2 tries to be
// compatible (was actually 1.10 see #29).  This was originally based on how far back
// rust-openssl's openssl-sys was backward compatible when this crate originally released.
// This will likely get bumped by the next major release.
/// A map optimized for small integer keys./// use vec_map::VecMap;/// let mut months = VecMap::new();/// months.insert(1, "Jan");/// months.insert(2, "Feb");/// months.insert(3, "Mar");/// if !months.contains_key(12) {///     println!("The end is near!");/// assert_eq!(months.get(1), Some(&"Jan"));/// if let Some(value) = months.get_mut(3) {///     *value = "Venus";/// assert_eq!(months.get(3), Some(&"Venus"));/// // Print out all months/// for (key, value) in &months {///     println!("month {} is {}", key, value);/// months.clear();/// assert!(months.is_empty());/// A vacant Entry/// An occupied Entry/// Creates an empty `VecMap`./// let mut map: VecMap<&str> = VecMap::new();/// Creates an empty `VecMap` with space for at least `capacity`/// elements before resizing./// let mut map: VecMap<&str> = VecMap::with_capacity(10);/// Returns the number of elements the `VecMap` can hold without/// let map: VecMap<String> = VecMap::with_capacity(10);reserve_len/// Reserves capacity for the given `VecMap` to contain `len` distinct keys./// In the case of `VecMap` this means reallocations will not occur as long/// as all inserted keys are less than `len`./// The collection may reserve more space to avoid frequent reallocations./// map.reserve_len(10);reserve_len_exact/// Reserves the minimum capacity for the given `VecMap` to contain `len` distinct keys./// In the case of `VecMap` this means reallocations will not occur as long as all inserted/// keys are less than `len`./// Note that the allocator may give the collection more space than it requests./// Therefore capacity cannot be relied upon to be precisely minimal.  Prefer/// `reserve_len` if future insertions are expected./// map.reserve_len_exact(10);/// Trims the `VecMap` of any excess capacity./// Returns an iterator visiting all keys in ascending order of the keys./// The iterator's element type is `usize`./// Returns an iterator visiting all values in ascending order of the keys./// The iterator's element type is `&'r V`./// The iterator's element type is `&'r mut V`./// Returns an iterator visiting all key-value pairs in ascending order of the keys./// The iterator's element type is `(usize, &'r V)`./// let mut map = VecMap::new();/// map.insert(3, "c");/// map.insert(2, "b");/// // Print `1: a` then `2: b` then `3: c`///     println!("{}: {}", key, value);/// Returns an iterator visiting all key-value pairs in ascending order of the keys,/// The iterator's element type is `(usize, &'r mut V)`.///     *value = "x";/// for (key, value) in &map {///     assert_eq!(value, &"x");/// Moves all elements from `other` into the map while overwriting existing keys./// let mut a = VecMap::new();/// let mut b = VecMap::new();/// b.insert(3, "c");/// b.insert(4, "d");/// a.append(&mut b);/// assert_eq!(a.len(), 4);/// assert_eq!(b.len(), 0);/// assert_eq!(a[1], "a");/// assert_eq!(a[2], "b");/// assert_eq!(a[3], "c");/// assert_eq!(a[4], "d");/// Splits the collection into two at the given key./// Returns a newly allocated `Self`. `self` contains elements `[0, at)`,/// and the returned `Self` contains elements `[at, max_key)`./// Note that the capacity of `self` does not change./// a.insert(3, "c");/// a.insert(4, "d");/// let b = a.split_off(3);/// assert_eq!(b[3], "c");/// assert_eq!(b[4], "d");/// Returns an iterator visiting all key-value pairs in ascending order of/// the keys, emptying (but not consuming) the original `VecMap`./// The iterator's element type is `(usize, &'r V)`. Keeps the allocated memory for reuse./// let vec: Vec<(usize, &str)> = map.drain().collect();/// assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);/// Clears the map, removing all key-value pairs./// assert_eq!(map.get(1), Some(&"a"));/// assert_eq!(map.get(2), None);/// assert_eq!(map.contains_key(1), true);/// assert_eq!(map.contains_key(2), false);/// if let Some(x) = map.get_mut(1) {/// assert_eq!(map[1], "b");/// Inserts a key-value pair into the map. If the key already had a value/// present in the map, that value is returned. Otherwise, `None` is returned./// assert_eq!(map[37], "c");/// assert_eq!(map.remove(1), Some("a"));/// assert_eq!(map.remove(1), None);/// let mut count: VecMap<u32> = VecMap::new();/// // count the number of occurrences of numbers in the vec/// for x in vec![1, 2, 1, 2, 3, 4, 1, 2, 4] {///     *count.entry(x).or_insert(0) += 1;/// assert_eq!(count[1], 3);/// let mut map: VecMap<usize> = (0..8).map(|x|(x, x*10)).collect();/// map.retain(|k, _| k % 2 == 0);/// Sets the value of the entry with the OccupiedEntry's key,/// and returns the entry's old value./// the keys, consuming the original `VecMap`./// let vec: Vec<(usize, &str)> = map.into_iter().collect();double_ended_iterator/// An iterator over the key-value pairs of a map.// FIXME(#19839) Remove in favor of `#[derive(Clone)]`/// An iterator over the key-value pairs of a map, with the/// values being mutable./// An iterator over the keys of a map./// An iterator over the values of a map./// A consuming iterator over the key-value pairs of a map./// A draining iterator over the key-value pairs of a map.assert_propertiestest_lentest_iteratortest_iterator_size_hintstest_mut_iteratortest_rev_iteratortest_mut_rev_iteratortest_drain_iteratortest_append//! A simple map based on a vector for small integer keys. Space requirements//! are O(highest integer key).CompOp/// Equal (`==`, `=`)./// When version `A` is equal to `B`./// Not equal (`!=`, `!`, `<>`)./// When version `A` is not equal to `B`./// Less than (`<`)./// When version `A` is less than `B` but not equal./// Less or equal (`<=`)./// When version `A` is less than or equal to `B`./// Greater or equal (`>=`)./// When version `A` is greater than or equal to `B`./// Greater than (`>`)./// When version `A` is greater than `B` but not equal./// Enum of supported comparison operators.from_sign/// Get a comparison operator by it's sign./// Whitespaces are stripped from the sign string./// An error is returned if the sign isn't recognized./// The following signs are supported:/// * `==` _or_ `=` -> `Eq`/// * `!=` _or_ `!` _or_ `<>` -> `Ne`/// * `< ` -> `Lt`/// * `<=` -> `Le`/// * `>=` -> `Ge`/// * `> ` -> `Gt`/// use version_compare::CompOp;/// assert_eq!(CompOp::from_sign("=="), Ok(CompOp::Eq));/// assert_eq!(CompOp::from_sign("<"), Ok(CompOp::Lt));/// assert_eq!(CompOp::from_sign("  >=   "), Ok(CompOp::Ge));/// assert!(CompOp::from_sign("*").is_err());/// Get a comparison operator by it's name./// Names are case-insensitive, and whitespaces are stripped from the string./// An error is returned if the name isn't recognized./// assert_eq!(CompOp::from_name("eq"), Ok(CompOp::Eq));/// assert_eq!(CompOp::from_name("lt"), Ok(CompOp::Lt));/// assert_eq!(CompOp::from_name("  Ge   "), Ok(CompOp::Ge));/// assert!(CompOp::from_name("abc").is_err());from_ord/// Get the comparison operator from Rusts `Ordering` enum./// The following comparison operators are returned:/// * `Ordering::Less` -> `Lt`/// * `Ordering::Equal` -> `Eq`/// * `Ordering::Greater` -> `Gt`/// Get the name of this comparison operator./// assert_eq!(CompOp::Eq.name(), "eq");/// assert_eq!(CompOp::Lt.name(), "lt");/// assert_eq!(CompOp::Ge.name(), "ge");as_inverted/// Covert to the inverted comparison operator./// This uses the following bidirectional rules:/// * `Eq` <-> `Ne`/// * `Lt` <-> `Ge`/// * `Le` <-> `Gt`/// assert_eq!(CompOp::Eq.as_inverted(), CompOp::Ne);/// assert_eq!(CompOp::Lt.as_inverted(), CompOp::Ge);/// assert_eq!(CompOp::Gt.as_inverted(), CompOp::Le);/// Get the inverted comparison operator./// assert_eq!(CompOp::Eq.invert(), CompOp::Ne);/// assert_eq!(CompOp::Lt.invert(), CompOp::Ge);/// assert_eq!(CompOp::Gt.invert(), CompOp::Le);as_opposite/// Convert to the opposite comparison operator./// * `Lt` <-> `Gt`/// * `Le` <-> `Ge`/// assert_eq!(CompOp::Eq.as_opposite(), CompOp::Ne);/// assert_eq!(CompOp::Lt.as_opposite(), CompOp::Gt);/// assert_eq!(CompOp::Ge.as_opposite(), CompOp::Le);/// Get the opposite comparison operator./// assert_eq!(CompOp::Eq.opposite(), CompOp::Ne);/// assert_eq!(CompOp::Lt.opposite(), CompOp::Gt);/// assert_eq!(CompOp::Ge.opposite(), CompOp::Le);as_flipped/// Convert to the flipped comparison operator./// * Other operators are returned as is./// assert_eq!(CompOp::Eq.as_flipped(), CompOp::Eq);/// assert_eq!(CompOp::Lt.as_flipped(), CompOp::Gt);/// assert_eq!(CompOp::Ge.as_flipped(), CompOp::Le);/// Get the flipped comparison operator./// assert_eq!(CompOp::Eq.flip(), CompOp::Eq);/// assert_eq!(CompOp::Lt.flip(), CompOp::Gt);/// assert_eq!(CompOp::Ge.flip(), CompOp::Le);/// Get the sign for this comparison operator./// The following signs are returned:/// * `Eq` -> `==`/// * `Ne` -> `!=`/// * `Lt` -> `< `/// * `Le` -> `<=`/// * `Ge` -> `>=`/// * `Gt` -> `> `/// Note: Some comparison operators also support other signs,/// such as `=` for `Eq` and `!` for `Ne`,/// these are never returned by this method however as the table above is used./// assert_eq!(CompOp::Eq.sign(), "==");/// assert_eq!(CompOp::Lt.sign(), "<");/// assert_eq!(CompOp::Ge.flip().sign(), "<=");/// Get a factor (number) for this comparison operator./// These factors can be useful for quick calculations./// The following factor numbers are returned:/// * `Eq` or `Ne` -> ` 0 `/// * `Lt` or `Le` -> `-1`/// * `Gt` or `Ge` -> ` 1`/// use version_compare::Version;/// let ver_a = Version::from("1.2.3").unwrap();/// let ver_b = Version::from("1.3").unwrap();/// assert_eq!(ver_a.compare(&ver_b).factor(), -1);/// assert_eq!(10 * ver_b.compare(&ver_a).factor(), 10);/// Get Rust's ordering for this comparison operator./// The following comparison operators are supported:/// * `Eq` -> `Ordering::Equal`/// * `Lt` -> `Ordering::Less`/// * `Gt` -> `Ordering::Greater`/// For other comparison operators `None` is returned./// assert_eq!(ver_a.compare(&ver_b).ord().unwrap(), Ordering::Less);//! Module with all supported comparison operators.//! This module provides an enum with all comparison operators that can be used with this library.//! The enum provides various useful helper functions to inverse or flip an operator.//! Methods like `CompOp::from_sign(">");` can be used to get a comparison operator by it's logical//! sign from a string.comp_opversion_manifestversion_partVersionManifestVersionPart//! A Rust library to easily compare version numbers in any format,//! and test them against various comparison operators.//! Comparing version numbers is hard. Especially when version numbers get really complex,//! or when their formatting differs.//! This library helps you to easily compare any kind of version number with minimal code.//! Two version numbers can be compared to each other, to get a relevant comparison operator (<, ==, >),//! or version numbers can be tested against any given comparison operator.//! Along with version comparison, the library also features other useful tools.//! For example: version numbers can be parsed to inspect a version number by it's bare numeric or text based parts.//! Inspired by PHPs [version_compare()](http://php.net/manual/en/function.version-compare.php).//! ### Version formats//! A list of version number examples that are parsed successfully://! - `1`//! - `3.10.4.1`//! - `1.2.alpha`//! - `1.2.dev.4`//! - ` ` _(empty)_//! - ` .   -32 . 1` _(undefined formats)_//! - `MyApp 3.2.0 / build 0932` _(complex formats, not fully functional yet)_//! - _Many more and support for custom formats to come..._//! ### Semver//! Version number formats like [_semver_](http://semver.org/) try to make version numbers consistent and manageable,//! there are too many projects however that don't follow such format.//! Version-compare makes working with them easy and supports semver formats out of the box with zero configuration.//! * Compare two version numbers, get: `<`, `==` or `>`.//! * Compare two version numbers against any comparison operator, get `true` or `false`.//! * Parse complex version numbers.//! * Static, single-statement methods available.//! The following features will be added in a later version://! * Support for text parts in version strings.//! * Version manifest, to specify detailed version number constraints.//! * Version ranges, and tests against them.//! * Support for operators in version strings, [npm-style](https://docs.npmjs.com/misc/semver), and tests against them.//! * Batch comparisons.//! Check out the [examples](https://github.com/timvisee/version-compare/tree/master/examples) directory for all available examples.//! _[View complete README](https://github.com/timvisee/version-compare/blob/master/README.md)_test_versiontest_version_setTestVersion/// Struct containing a version number with some meta data./// Such a set can be used for testing./// - `0`: The version string./// - `1`: Number of version parts.TEST_VERSIONS/// List of version numbers with metadata for dynamic testsTEST_VERSIONS_ERROR/// List of version numbers that contain errors with metadata for dynamic testsTestVersionSet/// Struct containing two version numbers, and the comparison operator./// - `0`: The main version./// - `1`: The other version./// - `2`: The comparison operator.TEST_VERSION_SETS/// List of version sets for dynamic testsTEST_VERSION_SETS_ERROR/// List of invalid version sets for dynamic testsmanifest/// Version struct, which is a representation for a parsed version string./// A version in string format can be parsed using methods like `Version::from("1.2.3");`./// These methods return a `Result` holding the parsed version or an error on failure./// The original version string is stored in the struct, and can be accessed using the/// `version.as_str()` method. Note, that when the version wasn't parsed from a string/// representation, the returned value is generated./// The struct provides many methods for comparison and probing./// Create a `Version` instance from a version string./// The version string should be passed to the `version` parameter./// use version_compare::{CompOp, Version};/// let ver = Version::from("1.2.3").unwrap();/// assert_eq!(ver.compare(&Version::from("1.2.3").unwrap()), CompOp::Eq);from_manifest/// Create a `Version` instance from a version string with the given `manifest`./// use version_compare::{CompOp, Version, VersionManifest};/// let manifest = VersionManifest::new();/// let ver = Version::from_manifest("1.2.3", &manifest).unwrap();/// Get the version manifest, if available./// let version = Version::from("1.2.3").unwrap();/// if version.has_manifest() {///         "Maximum version part depth is {} for this version",///         version.manifest().unwrap().max_depth_number()///     println!("Version has no manifest");has_manifest/// Check whether this version has a manifest.///     println!("This version does have a manifest");///     println!("This version does not have a manifest");set_manifest/// Set the version manifest./// use version_compare::{Version, VersionManifest};/// let mut version = Version::from("1.2.3").unwrap();/// version.set_manifest(Some(&manifest));split_version_str/// Split the given version string, in it's version parts./// TODO: Move this method to some sort of helper class, maybe as part of `VersionPart`./// Get the original version string./// assert_eq!(ver.as_str(), "1.2.3");/// Get a specific version part by it's `index`./// An error is returned if the given index is out of bound./// use version_compare::{Version, VersionPart};/// assert_eq!(ver.part(0), Ok(&VersionPart::Number(1)));/// assert_eq!(ver.part(1), Ok(&VersionPart::Number(2)));/// assert_eq!(ver.part(2), Ok(&VersionPart::Number(3)));/// Get a vector of all version parts./// assert_eq!(ver.parts(), &vec![///     VersionPart::Number(1),///     VersionPart::Number(2),///     VersionPart::Number(3)part_count/// Get the number of parts in this version string./// let ver_b = Version::from("1.2.3.4").unwrap();/// assert_eq!(ver_a.part_count(), 3);/// assert_eq!(ver_b.part_count(), 4);/// Compare this version to the given `other` version./// This method returns one of the following comparison operators:/// * `Lt`/// * `Gt`/// Other comparison operators can be used when comparing, but aren't returned by this method./// assert_eq!(Version::from("1.2").unwrap().compare(&Version::from("1.3.2").unwrap()), CompOp::Lt);/// assert_eq!(Version::from("1.9").unwrap().compare(&Version::from("1.9").unwrap()), CompOp::Eq);/// assert_eq!(Version::from("0.3.0.0").unwrap().compare(&Version::from("0.3").unwrap()), CompOp::Eq);/// assert_eq!(Version::from("2").unwrap().compare(&Version::from("1.7.3").unwrap()), CompOp::Gt);compare_to/// Compare this version to the given `other` version,/// and check whether the given comparison operator is valid./// All comparison operators can be used./// assert!(Version::from("1.2").unwrap().compare_to(&Version::from("1.3.2").unwrap(), &CompOp::Lt));/// assert!(Version::from("1.2").unwrap().compare_to(&Version::from("1.3.2").unwrap(), &CompOp::Le));/// assert!(Version::from("1.2").unwrap().compare_to(&Version::from("1.2").unwrap(), &CompOp::Eq));/// assert!(Version::from("1.2").unwrap().compare_to(&Version::from("1.2").unwrap(), &CompOp::Le));compare_iter/// Compare two version numbers based on the iterators of their version parts.// Show just the version component parts as debug output/// Implement the partial ordering trait for the version struct, to easily allow version comparison./// Implement the partial equality trait for the version struct, to easily allow version comparison.// TODO: This doesn't really test whether this method fully worksparts_max_depthparts_ignore_text//! Version module, which provides the `Version` struct as parsed version representation.//! Version numbers in the form of a string are parsed to a `Version` first, before any comparison//! is made. This struct provides many methods and features for easy comparison, probing and other//! things./// The main library structure, which provides various static methods for easy version comparison./// This structure uses static methods only, and doesn't need to be constructed./// Compare two version number strings to each other./// This compares version `a` to version `b`, and returns whether version `a` is greater, less/// or equal to version `b`./// The two given version numbers must be valid, or an error will be returned./// One of the following ok results may be returned:/// * `CompOp::Eq`/// * `CompOp::Lt`/// * `CompOp::Gt`/// use version_compare::{CompOp, VersionCompare};/// // Compare version numbers/// assert_eq!(VersionCompare::compare("1.2.3", "1.2.3"), Ok(CompOp::Eq));/// assert_eq!(VersionCompare::compare("1.2.3", "1.2.4"), Ok(CompOp::Lt));/// assert_eq!(VersionCompare::compare("1", "0.1"), Ok(CompOp::Gt));/// Compare two version number strings to each other and check whether the given comparison/// `operator` is valid./// assert!(VersionCompare::compare_to("1.2.3", "1.2.3", &CompOp::Eq).unwrap());/// assert!(VersionCompare::compare_to("1.2.3", "1.2.3", &CompOp::Le).unwrap());/// assert!(VersionCompare::compare_to("1.2.3", "1.2.4", &CompOp::Lt).unwrap());/// assert!(VersionCompare::compare_to("1", "0.1", &CompOp::Gt).unwrap());/// assert!(VersionCompare::compare_to("1", "0.1", &CompOp::Ge).unwrap());//! Version compare module, with useful static comparison methods.//! This module provides the `VersionCompare` struct, which provides many static functions, that are//! useful for version comparison.max_depth/// The maximum depth of a version number. This specifies the maximum number of parts.ignore_text/// True to ignore text parts in version strings./// Version manifest (configuration)./// A manifest (configuration) that is used respectively when parsing and comparing version strings./// use version_compare::VersionManifest;/// let mut manifest = VersionManifest::new();/// // Ignore text parts/// manifest.set_ignore_text(true);/// The maximum depth of a version number./// None if no depth is configured./// match manifest.max_depth() {///     &Some(depth) => println!("Maximum depth of {}", depth),///     &None => println!("No maximum depth")max_depth_number/// The maximum depth of a version number as numerical value./// Zero is returned if no depth is configured./// println!("Maximum depth of {}", manifest.max_depth_number());set_max_depth/// Set the maximum depth of a version number./// // Set the maximum depth to 3/// manifest.set_max_depth(Some(3));/// // Don't use a maximum depth/// manifest.set_max_depth(None);set_max_depth_number/// Use zero to disable the maximum depth./// manifest.set_max_depth_number(3);/// manifest.set_max_depth_number(0);has_max_depth/// Check whether there's a maximum configured depth./// assert!(!manifest.has_max_depth());/// assert!(manifest.has_max_depth());/// Check whether to ignore text parts in version numbers./// if manifest.ignore_text() {///     println!("Text parts are ignored");///     println!("Text parts are not ignored");set_ignore_text/// Set whether to ignore text parts./// // Don't ignore text parts/// manifest.set_ignore_text(false);/// Version manifest implementation.//! Module for the version manifest.//! A version manifest can be used to configure and specify how versions are parsed and compared.//! For example, you can configure the maximum depth of a version number, and set whether text//! parts are ignored in a version string./// Numeric part, most common in version strings./// Holds the numerical value./// A text part./// These parts usually hold text with an yet unknown definition./// Holds the string slice./// Enum of version string parts./// Each version string is broken down into these version parts when being parsed to a `Version`.//! Version part module.//! A module that provides the `VersionPart` enum, with the specification of all available version//! parts. Each version string is broken down into these version parts when being parsed to a//! `Version`./// Comparison operators enum./// use version_compare::Cmp;/// assert_eq!(Cmp::from_sign("=="), Ok(Cmp::Eq));/// assert_eq!(Cmp::from_sign("<"), Ok(Cmp::Lt));/// assert_eq!(Cmp::from_sign("  >=   "), Ok(Cmp::Ge));/// assert!(Cmp::from_sign("*").is_err());/// assert_eq!(Cmp::from_name("eq"), Ok(Cmp::Eq));/// assert_eq!(Cmp::from_name("lt"), Ok(Cmp::Lt));/// assert_eq!(Cmp::from_name("  Ge   "), Ok(Cmp::Ge));/// assert!(Cmp::from_name("abc").is_err());/// assert_eq!(Cmp::Eq.name(), "eq");/// assert_eq!(Cmp::Lt.name(), "lt");/// assert_eq!(Cmp::Ge.name(), "ge");/// assert_eq!(Cmp::Eq.invert(), Cmp::Ne);/// assert_eq!(Cmp::Lt.invert(), Cmp::Ge);/// assert_eq!(Cmp::Gt.invert(), Cmp::Le);/// assert_eq!(Cmp::Eq.opposite(), Cmp::Ne);/// assert_eq!(Cmp::Lt.opposite(), Cmp::Gt);/// assert_eq!(Cmp::Ge.opposite(), Cmp::Le);/// assert_eq!(Cmp::Eq.flip(), Cmp::Eq);/// assert_eq!(Cmp::Lt.flip(), Cmp::Gt);/// assert_eq!(Cmp::Ge.flip(), Cmp::Le);/// assert_eq!(Cmp::Eq.sign(), "==");/// assert_eq!(Cmp::Lt.sign(), "<");/// assert_eq!(Cmp::Ge.flip().sign(), "<=");/// * `Eq` _or_ `Ne` -> ` 0`/// * `Lt` _or_ `Le` -> `-1`/// * `Gt` _or_ `Ge` -> ` 1`/// let a = Version::from("1.2.3").unwrap();/// let b = Version::from("1.3").unwrap();/// assert_eq!(a.compare(&b).factor(), -1);/// assert_eq!(10 * b.compare(a).factor(), 10);/// assert_eq!(a.compare(b).ord().unwrap(), Ordering::Less);//! Methods like `Cmp::from_sign(">");` can be used to get a comparison operator by it's logical/// If either version number string is invalid an error is returned./// One of the following operators is returned:/// * `Cmp::Eq`/// * `Cmp::Lt`/// * `Cmp::Gt`/// use version_compare::{Cmp, compare};/// assert_eq!(compare("1.2.3", "1.2.3"), Ok(Cmp::Eq));/// assert_eq!(compare("1.2.3", "1.2.4"), Ok(Cmp::Lt));/// assert_eq!(compare("1", "0.1"), Ok(Cmp::Gt));/// Compare two version number strings to each other and test against the given comparison/// `operator`./// use version_compare::{Cmp, compare_to};/// assert!(compare_to("1.2.3", "1.2.3", Cmp::Eq).unwrap());/// assert!(compare_to("1.2.3", "1.2.3", Cmp::Le).unwrap());/// assert!(compare_to("1.2.3", "1.2.4", Cmp::Lt).unwrap());/// assert!(compare_to("1", "0.1", Cmp::Gt).unwrap());/// assert!(compare_to("1", "0.1", Cmp::Ge).unwrap());COMBISCOMBIS_ERROR// Re-exportsManifest//! Rust library to easily compare version numbers with no specific format, and test against various comparison operators.//! Comparing version numbers is hard, especially with weird version number formats.//! This library helps you to easily compare any kind of version number with no//! specific format using a best-effort approach.//! Two version numbers can be compared to each other to get a comparison operator//! (`<`, `==`, `>`), or test them against a comparison operator.//! Along with version comparison, the library provides various other tools for//! working with version numbers.//! ### Formats//! Version numbers that would parse successfully include:  //! `1`, `3.10.4.1`, `1.2.alpha`, `1.2.dev.4`, ` `, ` .   -32 . 1`, `MyApp 3.2.0 / build 0932` ...//! See a list of how version numbers compare [here](https://github.com/timvisee/version-compare/blob/411ed7135741ed7cf2fcf4919012fb5412dc122b/src/test.rs#L50-L103).//! [example.rs](examples/example.rs)://! use version_compare::{compare, compare_to, Cmp, Version};//! let a = "1.2";//! let b = "1.5.1";//! // The following comparison operators are used://! // - Cmp::Eq -> Equal//! // - Cmp::Ne -> Not equal//! // - Cmp::Lt -> Less than//! // - Cmp::Le -> Less than or equal//! // - Cmp::Ge -> Greater than or equal//! // - Cmp::Gt -> Greater than//! // Easily compare version strings//! assert_eq!(compare(a, b), Ok(Cmp::Lt));//! assert_eq!(compare_to(a, b, Cmp::Le), Ok(true));//! assert_eq!(compare_to(a, b, Cmp::Gt), Ok(false));//! // Parse and wrap version strings as a Version//! let a = Version::from(a).unwrap();//! let b = Version::from(b).unwrap();//! // The Version can easily be compared with//! assert_eq!(a < b, true);//! assert_eq!(a <= b, true);//! assert_eq!(a > b, false);//! assert_eq!(a != b, true);//! assert_eq!(a.compare(&b), Cmp::Lt);//! assert_eq!(a.compare_to(&b, Cmp::Lt), true);//! // Or match the comparison operators//! match a.compare(b) {//!     Cmp::Lt => println!("Version a is less than b"),//!     Cmp::Eq => println!("Version a is equal to b"),//!     Cmp::Gt => println!("Version a is greater than b"),//!     _ => unreachable!(),//! See the [`examples`](https://github.com/timvisee/version-compare/tree/master/examples) directory for more.//! * Compare version numbers, get: `<`, `==`, `>`//! * Compare against a comparison operator//!   (`<`, `<=`, `==`, `!=`, `>=`, `>`)//! * Parse complex and unspecified formats//! * Static, standalone methods to easily compare version strings in a single line//!   of code//! Version numbers using the [semver](http://semver.org/) format are compared//! correctly with no additional configuration.//! If your version number strings follow this exact format you may be better off//! using the [`semver`](https://crates.io/crates/semver) crate for more format//! specific features.//! If that isn't certain however, `version-compare` makes comparing a breeze./// This specifies the maximum number of parts. There is no limit if `None` is set./// Whether to ignore text parts in version strings.gnu_ordering/// Use GNU sort based ordering./// Enabling this modifies the ordering of numbers with a leading zero to mimick GNUs sort./// Issue: https://github.com/timvisee/version-compare/issues/27/// use version_compare::{Manifest, Version};/// // Create manifest with max depth of 2/// let mut manifest = Manifest::default();/// manifest.max_depth = Some(2);/// // Version strings equal with manifest because we compare up-to 2 parts deep/// let a = Version::from_manifest("1.0.1", &manifest).unwrap();/// let b = Version::from_manifest("1.0.2", &manifest).unwrap();/// assert!(a == b);/// use version_compare::Manifest;/// manifest.max_depth = Some(3);/// These parts usually hold text with an yet unknown definition. Holds the string slice./// Version string part enum.//! A module that provides the `Part` enum, with the specification of all available versionMANIFEST_GNU/// A manifest configuration for GNU versions.VERSIONSVERSIONS_ERRORVersionCombi/// - `3`: An optional custom manifest./// Get versions./// List of version combinations for dynamic tests/// List of invalid version combinations for dynamic tests/// Version struct, wrapping a string, providing useful comparison functions./// A version in string format can be parsed using methods like `Version::from("1.2.3");`,/// returning a `Result` with the parse result./// The original version string can be accessed using `version.as_str()`. A `Version` that isn't/// derrived from a version string returns a generated string./// The struct provides many methods for easy comparison and probing./// use version_compare::{Version};/// use version_compare::{Cmp, Version};/// let b = Version::from("1.3.0").unwrap();/// assert_eq!(a.compare(b), Cmp::Lt);/// Create a `Version` instance from already existing parts/// use version_compare::{Cmp, Version, Part};/// let ver = Version::from_parts("1.0", vec![Part::Number(1), Part::Number(0)]);/// use version_compare::{Cmp, Version, Manifest};/// let manifest = Manifest::default();/// assert_eq!(ver.compare(Version::from("1.2.3").unwrap()), Cmp::Eq);///         version.manifest().unwrap().max_depth.unwrap_or(0),/// use version_compare::{Version, Manifest};/// use version_compare::{Version, Part};/// assert_eq!(ver.part(0), Ok(Part::Number(1)));/// assert_eq!(ver.part(1), Ok(Part::Number(2)));/// assert_eq!(ver.part(2), Ok(Part::Number(3)));/// assert_eq!(ver.parts(), [///     Part::Number(1),///     Part::Number(2),///     Part::Number(3)/// Compare this version to the given `other` version using the default `Manifest`./// let a = Version::from("1.2").unwrap();/// let b = Version::from("1.3.2").unwrap();/// assert_eq!(a.compare(&b), Cmp::Lt);/// assert_eq!(b.compare(&a), Cmp::Gt);/// assert_eq!(a.compare(&a), Cmp::Eq);/// and check whether the given comparison operator is valid using the default `Manifest`./// assert!(a.compare_to(&b, Cmp::Lt));/// assert!(a.compare_to(&b, Cmp::Le));/// assert!(a.compare_to(&a, Cmp::Eq));/// assert!(a.compare_to(&a, Cmp::Le));compare_gnu_number_text/// Special logic for comparing a number and text with GNU ordering./// Numbers should be ordered like this:/// - 3/// - 04/// - 4// TODO: this is not efficient, find a better method/// Release channel: "dev", "nightly", "beta", or "stable"./// Reads the release channel of the running compiler. If it cannot be/// determined (see the [top-level documentation](crate)), returns `None`./// use version_check::Channel;/// match Channel::read() {///     Some(c) => format!("The channel is: {}", c),///     None => format!("Failed to read the release channel.")/// Parse a Rust release channel from a Rust release version string (of the/// form `major[.minor[.patch[-channel]]]`). Returns `None` if `version` is/// not a valid Rust version string./// let dev = Channel::parse("1.3.0-dev").unwrap();/// assert!(dev.is_dev());/// let nightly = Channel::parse("1.42.2-nightly").unwrap();/// assert!(nightly.is_nightly());/// let beta = Channel::parse("1.32.0-beta").unwrap();/// assert!(beta.is_beta());/// let stable = Channel::parse("1.4.0").unwrap();/// assert!(stable.is_stable());/// Returns the name of the release channel.supports_features/// Returns `true` if this channel supports feature flags. In other words,/// returns `true` if the channel is either `dev` or `nightly`./// assert!(dev.supports_features());/// assert!(nightly.supports_features());/// assert!(!beta.supports_features());/// assert!(!stable.supports_features());is_dev/// Returns `true` if this channel is `dev` and `false` otherwise./// let stable = Channel::parse("1.0.0").unwrap();/// assert!(!stable.is_dev());is_nightly/// Returns `true` if this channel is `nightly` and `false` otherwise./// let nightly = Channel::parse("1.3.0-nightly").unwrap();/// assert!(!stable.is_nightly());is_beta/// Returns `true` if this channel is `beta` and `false` otherwise./// let beta = Channel::parse("1.3.0-beta").unwrap();/// assert!(!stable.is_beta());is_stable/// Returns `true` if this channel is `stable` and `false` otherwise./// assert!(!beta.is_stable());/// Release date including year, month, and day.// Internal storage is: y[31..9] | m[8..5] | d[5...0]./// Reads the release date of the running compiler. If it cannot be/// use version_check::Date;/// match Date::read() {///     Some(d) => format!("The release date is: {}", d),///     None => format!("Failed to read the release date.")/// Parse a release date of the form `%Y-%m-%d`. Returns `None` if `date` is/// not in `%Y-%m-%d` format./// let date = Date::parse("2016-04-20").unwrap();/// assert!(date.at_least("2016-01-10"));/// assert!(date.at_most("2016-04-20"));/// assert!(date.exactly("2016-04-20"));/// assert!(Date::parse("2021-12-31").unwrap().exactly("2021-12-31"));/// assert!(Date::parse("March 13, 2018").is_none());/// assert!(Date::parse("1-2-3-4-5").is_none());/// assert!(Date::parse("2020-300-23120").is_none());/// assert!(Date::parse("2020-12-12 1").is_none());/// assert!(Date::parse("2020-10").is_none());/// assert!(Date::parse("2020").is_none());/// Creates a `Date` from `(year, month, day)` date components./// Does not check the validity of `year`, `month`, or `day`, but `year` is/// truncated to 23 bits (% 8,388,608), `month` to 4 bits (% 16), and `day`/// to 5 bits (% 32)./// assert!(Date::from_ymd(2021, 7, 30).exactly("2021-07-30"));/// assert!(Date::from_ymd(2010, 3, 23).exactly("2010-03-23"));/// assert!(Date::from_ymd(2090, 1, 31).exactly("2090-01-31"));/// // Truncation: 33 % 32 == 0x21 & 0x1F == 1./// assert!(Date::from_ymd(2090, 1, 33).exactly("2090-01-01"));to_ymd/// Return the original (YYYY, MM, DD).at_least/// Returns `true` if `self` occurs on or after `date`./// If `date` occurs before `self`, or if `date` is not in `%Y-%m-%d`/// format, returns `false`./// let date = Date::parse("2020-01-01").unwrap();/// assert!(date.at_least("2019-12-31"));/// assert!(date.at_least("2020-01-01"));/// assert!(date.at_least("2014-04-31"));/// assert!(!date.at_least("2020-01-02"));/// assert!(!date.at_least("2024-08-18"));at_most/// Returns `true` if `self` occurs on or before `date`./// If `date` occurs after `self`, or if `date` is not in `%Y-%m-%d`/// assert!(date.at_most("2020-01-01"));/// assert!(date.at_most("2020-01-02"));/// assert!(date.at_most("2024-08-18"));/// assert!(!date.at_most("2019-12-31"));/// assert!(!date.at_most("2014-04-31"));exactly/// Returns `true` if `self` occurs exactly on `date`./// If `date` is not exactly `self`, or if `date` is not in `%Y-%m-%d`/// assert!(date.exactly("2020-01-01"));/// assert!(!date.exactly("2019-12-31"));/// assert!(!date.exactly("2014-04-31"));/// assert!(!date.exactly("2020-01-02"));/// assert!(!date.exactly("2024-08-18"));reflexive_displayversion_and_date_from_rustc_version/// Parses (version, date) as available from rustc version string.version_and_date_from_rustc_verbose_version/// Parses (version, date) as available from rustc verbose version output.get_version_and_date/// Returns (version, date) as available from `rustc --version`./// Reads the triple of [`Version`], [`Channel`], and [`Date`] of the installed/// or running `rustc`./// If any attribute cannot be determined (see the [top-level/// documentation](crate)), returns `None`./// To obtain only one of three attributes, use [`Version::read()`],/// [`Channel::read()`], or [`Date::read()`].is_min_date/// Checks that the running or installed `rustc` was released **on or after**/// some date./// The format of `min_date` must be YYYY-MM-DD. For instance: `2016-12-20` or/// `2017-01-09`./// If the date cannot be retrieved or parsed, or if `min_date` could not be/// parsed, returns `None`. Otherwise returns `true` if the installed `rustc`/// was release on or after `min_date` and `false` otherwise.is_max_date/// Checks that the running or installed `rustc` was released **on or before**/// The format of `max_date` must be YYYY-MM-DD. For instance: `2016-12-20` or/// If the date cannot be retrieved or parsed, or if `max_date` could not be/// was release on or before `max_date` and `false` otherwise.is_exact_date/// Checks that the running or installed `rustc` was released **exactly** on/// The format of `date` must be YYYY-MM-DD. For instance: `2016-12-20` or/// If the date cannot be retrieved or parsed, or if `date` could not be parsed,/// returns `None`. Otherwise returns `true` if the installed `rustc` was/// release on `date` and `false` otherwise.is_min_version/// Checks that the running or installed `rustc` is **at least** some minimum/// The format of `min_version` is a semantic version: `1.3.0`, `1.15.0-beta`,/// `1.14.0`, `1.16.0-nightly`, etc./// If the version cannot be retrieved or parsed, or if `min_version` could not/// be parsed, returns `None`. Otherwise returns `true` if the installed `rustc`/// is at least `min_version` and `false` otherwise.is_max_version/// Checks that the running or installed `rustc` is **at most** some maximum/// The format of `max_version` is a semantic version: `1.3.0`, `1.15.0-beta`,/// If the version cannot be retrieved or parsed, or if `max_version` could not/// is at most `max_version` and `false` otherwise.is_exact_version/// Checks that the running or installed `rustc` is **exactly** some version./// The format of `version` is a semantic version: `1.3.0`, `1.15.0-beta`,/// If the version cannot be retrieved or parsed, or if `version` could not be/// parsed, returns `None`. Otherwise returns `true` if the installed `rustc` is/// exactly `version` and `false` otherwise.is_feature_flaggable/// Checks whether the running or installed `rustc` supports feature flags./// In other words, if the channel is either "nightly" or "dev"./// Note that support for specific `rustc` features can be enabled or disabled/// via the `allow-features` compiler flag, which this function _does not_/// check. That is, this function _does not_ check whether a _specific_ feature/// is supported, but instead whether features are supported at all. To check/// for support for a specific feature, use [`supports_feature()`]./// If the version could not be determined, returns `None`. Otherwise returns/// `true` if the running version supports feature flags and `false` otherwise.supports_feature/// Checks whether the running or installed `rustc` supports `feature`./// Returns _true_ _iff_ [`is_feature_flaggable()`] returns `true` _and_ the/// feature is not disabled via exclusion in `allow-features` via `RUSTFLAGS` or/// `CARGO_ENCODED_RUSTFLAGS`. If the version could not be determined, returns/// use version_check as rustc;/// if let Some(true) = rustc::supports_feature("doc_cfg") {///    println!("cargo:rustc-cfg=has_doc_cfg");check_parsecheck_terse_parsecheck_verbose_parsetest_version_parsetest_verbose_version_parseread_staticSTATIC_PATHDATEStest_stable_compatibilitytest_parse_current//! This tiny crate checks that the running or installed `rustc` meets some//! version requirements. The version is queried by calling the Rust compiler//! with `--version`. The path to the compiler is determined first via the//! `RUSTC` environment variable. If it is not set, then `rustc` is used. If//! that fails, no determination is made, and calls return `None`.//! * Set a `cfg` flag in `build.rs` if the running compiler was determined to//!   be at least version `1.13.0`://!   extern crate version_check as rustc;//!   if rustc::is_min_version("1.13.0").unwrap_or(false) {//!       println!("cargo:rustc-cfg=question_mark_operator");//!   See [`is_max_version`] or [`is_exact_version`] to check if the compiler//!   is _at most_ or _exactly_ a certain version.//! * Check that the running compiler was released on or after `2018-12-18`://!   match rustc::is_min_date("2018-12-18") {//!       Some(true) => "Yep! It's recent!",//!       Some(false) => "No, it's older.",//!       None => "Couldn't determine the rustc version."//!   };//!   See [`is_max_date`] or [`is_exact_date`] to check if the compiler was//!   released _prior to_ or _exactly on_ a certain date.//! * Check that the running compiler supports feature flags://!   match rustc::is_feature_flaggable() {//!       Some(true) => "Yes! It's a dev or nightly release!",//!       Some(false) => "No, it's stable or beta.",//! * Check that the running compiler supports a specific feature://!   if let Some(true) = rustc::supports_feature("doc_cfg") {//!      println!("cargo:rustc-cfg=has_doc_cfg");//! * Check that the running compiler is on the stable channel://!   match rustc::Channel::read() {//!       Some(c) if c.is_stable() => format!("Yes! It's stable."),//!       Some(c) => format!("No, the channel {} is not stable.", c),//!       None => format!("Couldn't determine the rustc version.")//! To interact with the version, release date, and release channel as structs,//! use [`Version`], [`Date`], and [`Channel`], respectively. The [`triple()`]//! function returns all three values efficiently.//! # Alternatives//! This crate is dead simple with no dependencies. If you need something more//! and don't care about panicking if the version cannot be obtained, or if you//! don't mind adding dependencies, see//! [rustc_version](https://crates.io/crates/rustc_version)./// Version number: `major.minor.patch`, ignoring release channel./// Reads the version of the running compiler. If it cannot be determined/// (see the [top-level documentation](crate)), returns `None`./// use version_check::Version;/// match Version::read() {///     Some(d) => format!("Version is: {}", d),///     None => format!("Failed to read the version.")/// Parse a Rust release version (of the form/// `major[.minor[.patch[-channel]]]`), ignoring the release channel, if/// any. Returns `None` if `version` is not a valid Rust version string./// let version = Version::parse("1.18.0").unwrap();/// assert!(version.exactly("1.18.0"));/// let version = Version::parse("1.20.0-nightly").unwrap();/// assert!(version.exactly("1.20.0"));/// assert!(version.exactly("1.20.0-beta"));/// let version = Version::parse("1.3").unwrap();/// assert!(version.exactly("1.3.0"));/// let version = Version::parse("1").unwrap();/// assert!(version.exactly("1.0.0"));/// assert!(Version::parse("one.two.three").is_none());/// assert!(Version::parse("1.65536.2").is_none());/// assert!(Version::parse("1. 2").is_none());/// assert!(Version::parse("").is_none());/// assert!(Version::parse("1.").is_none());/// assert!(Version::parse("1.2.3.4").is_none());from_mmp/// Creates a `Version` from `(major, minor, patch)` version components./// assert!(Version::from_mmp(1, 35, 0).exactly("1.35.0"));/// assert!(Version::from_mmp(1, 33, 0).exactly("1.33.0"));/// assert!(Version::from_mmp(1, 35, 1).exactly("1.35.1"));/// assert!(Version::from_mmp(1, 13, 2).exactly("1.13.2"));to_mmp/// Returns the `(major, minor, patch)` version components of `self`./// assert_eq!(Version::parse("1.35.0").unwrap().to_mmp(), (1, 35, 0));/// assert_eq!(Version::parse("1.33.0").unwrap().to_mmp(), (1, 33, 0));/// assert_eq!(Version::parse("1.35.1").unwrap().to_mmp(), (1, 35, 1));/// assert_eq!(Version::parse("1.13.2").unwrap().to_mmp(), (1, 13, 2));/// Returns `true` if `self` is greater than or equal to `version`./// If `version` is greater than `self`, or if `version` is not a valid Rust/// version string, returns `false`./// let version = Version::parse("1.35.0").unwrap();/// assert!(version.at_least("1.33.0"));/// assert!(version.at_least("1.35.0"));/// assert!(version.at_least("1.13.2"));/// assert!(!version.at_least("1.35.1"));/// assert!(!version.at_least("1.55.0"));/// let version = Version::parse("1.12.5").unwrap();/// assert!(version.at_least("1.12.0"));/// assert!(!version.at_least("1.35.0"));/// Returns `true` if `self` is less than or equal to `version`./// If `version` is less than `self`, or if `version` is not a valid Rust/// assert!(version.at_most("1.35.1"));/// assert!(version.at_most("1.55.0"));/// assert!(version.at_most("1.35.0"));/// assert!(!version.at_most("1.33.0"));/// assert!(!version.at_most("1.13.2"));/// Returns `true` if `self` is exactly equal to `version`./// If `version` is not equal to `self`, or if `version` is not a valid Rust/// assert!(version.exactly("1.35.0"));/// assert!(!version.exactly("1.33.0"));/// assert!(!version.exactly("1.35.1"));/// assert!(!version.exactly("1.13.2"));assert_to_mmp// We don't use `.into::<Option<_>>` because it's not available in 1.0.// We don't use the message part of `assert!` for the same reason.assert_from_mmptest_str_to_mmptest_from_mmpWaitGroupFuture//! A WaitGroup waits for a collection of task to finish.//! use waitgroup::WaitGroup;//! use async_std::task;//! # task::block_on(//!     let wg = WaitGroup::new();//!     for _ in 0..100 {//!         let w = wg.worker();//!         task::spawn(async move {//!             // do work//!             drop(w); // drop w means task finished//!     wg.wait().await;/*
IntoFuture tracking issue: https://github.com/rust-lang/rust/issues/67644
impl IntoFuture for WaitGroup {
    type Output = ();
    type Future = WaitGroupFuture;

    fn into_future(self) -> Self::Future {
        WaitGroupFuture { inner: Arc::downgrade(&self.inner) }
    }
}
*//// Converts a closure into a [`Waker`]./// The closure gets called every time the waker is woken./// let waker = waker_fn(|| println!("woken"));/// waker.wake_by_ref(); // Prints "woken"./// waker.wake();        // Prints "woken".//! Convert closures into wakers.//! A [`Waker`] is just a fancy callback. This crate converts regular closures into wakers./// The path as reported by the [`fs::ReadDir`] iterator (even if it's a/// symbolic link)./// [`fs::ReadDir`]: https://doc.rust-lang.org/stable/std/fs/struct.ReadDir.html/// The file type. Necessary for recursive iteration, so store it.follow_link/// Is set when this entry was created from a symbolic link and the user/// expects the iterator to follow symbolic links./// The depth at which this entry was generated relative to the root./// The underlying inode number (Unix only)./// A directory entry./// This is the type of value that is yielded from the iterators defined in/// On Unix systems, this type implements the [`DirEntryExt`] trait, which/// provides efficient access to the inode number of the directory entry./// # Differences with `std::fs::DirEntry`/// This type mostly mirrors the type by the same name in [`std::fs`]. There/// are some differences however:/// * All recursive directory iterators must inspect the entry's type./// Therefore, the value is stored and its access is guaranteed to be cheap and/// * [`path`] and [`file_name`] return borrowed variants./// * If [`follow_links`] was enabled on the originating iterator, then all/// operations except for [`path`] operate on the link target. Otherwise, all/// operations operate on the symbolic link./// [`std::fs`]: https://doc.rust-lang.org/stable/std/fs/index.html/// [`path`]: #method.path/// [`file_name`]: #method.file_name/// [`follow_links`]: struct.WalkDir.html#method.follow_links/// [`DirEntryExt`]: trait.DirEntryExt.html/// The full path that this entry represents./// The full path is created by joining the parents of this entry up to the/// root initially given to [`WalkDir::new`] with the file name of this/// Note that this *always* returns the path reported by the underlying/// directory entry, even when symbolic links are followed. To get the/// target path, use [`path_is_symlink`] to (cheaply) check if this entry/// corresponds to a symbolic link, and [`std::fs::read_link`] to resolve/// the target./// [`WalkDir::new`]: struct.WalkDir.html#method.new/// [`path_is_symlink`]: struct.DirEntry.html#method.path_is_symlink/// [`std::fs::read_link`]: https://doc.rust-lang.org/stable/std/fs/fn.read_link.html/// Analogous to [`path`], but moves ownership of the path./// [`path`]: struct.DirEntry.html#method.pathpath_is_symlink/// Returns `true` if and only if this entry was created from a symbolic/// link. This is unaffected by the [`follow_links`] setting./// When `true`, the value returned by the [`path`] method is a/// symbolic link name. To get the full target path, you must call/// [`std::fs::read_link(entry.path())`]./// [`std::fs::read_link(entry.path())`]: https://doc.rust-lang.org/stable/std/fs/fn.read_link.html/// Return the metadata for the file that this entry points to./// This will follow symbolic links if and only if the [`WalkDir`] value/// has [`follow_links`] enabled./// # Platform behavior/// This always calls [`std::fs::symlink_metadata`]./// If this entry is a symbolic link and [`follow_links`] is enabled, then/// [`std::fs::metadata`] is called instead./// Similar to [`std::fs::metadata`], returns errors for path values that/// the program does not have permissions to access or if the path does not/// [`WalkDir`]: struct.WalkDir.html/// [`std::fs::metadata`]: https://doc.rust-lang.org/std/fs/fn.metadata.html/// [`std::fs::symlink_metadata`]: https://doc.rust-lang.org/stable/std/fs/fn.symlink_metadata.htmlmetadata_internal/// Return the file type for the file that this entry points to./// If this is a symbolic link and [`follow_links`] is `true`, then this/// returns the type of the target./// This never makes any system calls./// Return the file name of this entry./// If this entry has no file name (e.g., `/`), then the full path is/// Returns the depth at which this entry was created relative to the root./// The smallest depth is `0` and always corresponds to the path given/// to the `new` function on `WalkDir`. Its direct descendents have depth/// `1`, and their descendents have depth `2`, and so on./// Returns true if and only if this entry points to a directory./// Returns the underlying `d_ino` field in the contained `dirent`/// structure./// Unix-specific extension methods for `walkdir::DirEntry`/// An error produced by recursively walking a directory./// This error type is a light wrapper around [`std::io::Error`]. In/// particular, it adds the following information:/// * The depth at which the error occurred in the file tree, relative to the/// * The path, if any, associated with the IO error./// * An indication that a loop occurred when following symbolic links. In this/// case, there is no underlying IO error./// To maintain good ergonomics, this type has a/// [`impl From<Error> for std::io::Error`][impl] defined which preserves the original context./// This allows you to use an [`io::Result`] with methods in this crate if you don't care about/// accessing the underlying error data in a structured form./// [`std::io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html/// [`io::Result`]: https://doc.rust-lang.org/stable/std/io/type.Result.html/// [impl]: struct.Error.html#impl-From%3CError%3E/// Returns the path associated with this error if one exists./// For example, if an error occurred while opening a directory handle,/// the error will include the path passed to [`std::fs::read_dir`]./// [`std::fs::read_dir`]: https://doc.rust-lang.org/stable/std/fs/fn.read_dir.htmlloop_ancestor/// Returns the path at which a cycle was detected./// If no cycle was detected, [`None`] is returned./// A cycle is detected when a directory entry is equivalent to one of/// its ancestors./// To get the path to the child directory entry in the cycle, use the/// [`path`] method./// [`None`]: https://doc.rust-lang.org/stable/std/option/enum.Option.html#variant.None/// [`path`]: struct.Error.html#path/// Returns the depth at which this error occurred relative to the root./// The smallest depth is `0` and always corresponds to the path given to/// the [`new`] function on [`WalkDir`]. Its direct descendents have depth/// [`new`]: struct.WalkDir.html#method.new/// Inspect the original [`io::Error`] if there is one./// [`None`] is returned if the [`Error`] doesn't correspond to an/// [`io::Error`]. This might happen, for example, when the error was/// produced because a cycle was found in the directory tree while/// following symbolic links./// This method returns a borrowed value that is bound to the lifetime of the [`Error`]. To/// obtain an owned value, the [`into_io_error`] can be used instead./// > This is the original [`io::Error`] and is _not_ the same as/// > [`impl From<Error> for std::io::Error`][impl] which contains additional context about the/// use walkdir::WalkDir;/// for entry in WalkDir::new("foo") {///         Ok(entry) => println!("{}", entry.path().display()),///             let path = err.path().unwrap_or(Path::new("")).display();///             println!("failed to access entry {}", path);///             if let Some(inner) = err.io_error() {///                 match inner.kind() {///                     io::ErrorKind::InvalidData => {///                         println!(///                             "entry contains invalid data: {}",///                             inner)///                     io::ErrorKind::PermissionDenied => {///                             "Missing permission to read entry: {}",///                     _ => {///                             "Unexpected error occurred: {}",/// [`io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html/// [`From`]: https://doc.rust-lang.org/stable/std/convert/trait.From.html/// [`into_io_error`]: struct.Error.html#method.into_io_error/// Similar to [`io_error`] except consumes self to convert to the original/// [`io::Error`] if one exists./// [`io_error`]: struct.Error.html#method.io_errorfrom_loop/// Convert the [`Error`] to an [`io::Error`], preserving the original/// [`Error`] as the ["inner error"]. Note that this also makes the display/// of the error include the context./// This is different from [`into_io_error`] which returns the original/// [`io::Error`]./// ["inner error"]: https://doc.rust-lang.org/std/io/struct.Error.html#method.into_inner/// [`into_io_error`]: struct.WalkDir.html#method.into_io_errordentitry/// Like try, but for iterators that return [`Option<Result<_, _>>`]./// [`Option<Result<_, _>>`]: https://doc.rust-lang.org/stable/std/option/enum.Option.html/// A result type for walkdir operations./// Note that this result type embeds the error type in this crate. This/// is only useful if you care about the additional information provided by/// the error (such as the path associated with the error or whether a loop/// was dectected). If you want things to Just Work, then you can use/// [`io::Result`] instead since the error type in this package will/// automatically convert to an [`io::Result`] when using the [`try!`] macro./// [`try!`]: https://doc.rust-lang.org/stable/std/macro.try.htmlWalkDirOptionsWalkDir/// A builder to create an iterator for recursively walking a directory./// Results are returned in depth first fashion, with directories yielded/// before their contents. If [`contents_first`] is true, contents are yielded/// before their directories. The order is unspecified but if [`sort_by`] is/// given, directory entries are sorted according to this function. Directory/// entries `.` and `..` are always omitted./// If an error occurs at any point during iteration, then it is returned in/// place of its corresponding directory entry and iteration continues as/// normal. If an error occurs while opening a directory for reading, then it/// is not descended into (but the error is still yielded by the iterator)./// Iteration may be stopped at any time. When the iterator is destroyed, all/// resources associated with it are freed./// [`contents_first`]: struct.WalkDir.html#method.contents_first/// [`sort_by`]: struct.WalkDir.html#method.sort_by/// This type implements [`IntoIterator`] so that it may be used as the subject/// of a `for` loop. You may need to call [`into_iter`] explicitly if you want/// to use iterator adapters such as [`filter_entry`]./// Idiomatic use of this type should use method chaining to set desired/// options. For example, this only shows entries with a depth of `1`, `2` or/// `3` (relative to `foo`):/// # use walkdir::Error;/// # fn try_main() -> Result<(), Error> {/// for entry in WalkDir::new("foo").min_depth(1).max_depth(3) {///     println!("{}", entry?.path().display());/// [`IntoIterator`]: https://doc.rust-lang.org/stable/std/iter/trait.IntoIterator.html/// [`into_iter`]: https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html#tymethod.into_iter/// [`filter_entry`]: struct.IntoIter.html#method.filter_entry/// Note that the iterator by default includes the top-most directory. Since/// this is the only directory yielded with depth `0`, it is easy to ignore it/// with the [`min_depth`] setting:/// for entry in WalkDir::new("foo").min_depth(1) {/// [`min_depth`]: struct.WalkDir.html#method.min_depth/// This will only return descendents of the `foo` directory and not `foo`/// # Loops/// This iterator (like most/all recursive directory iterators) assumes that/// no loops can be made with *hard* links on your file system. In particular,/// this would require creating a hard link to a directory such that it creates/// a loop. On most platforms, this operation is illegal./// Note that when following symbolic/soft links, loops are detected and an/// error is reported.follow_linksfollow_root_linksmax_openmin_depthsortercontents_firstsame_file_system/// Create a builder for a recursive directory iterator starting at the/// file path `root`. If `root` is a directory, then it is the first item/// yielded by the iterator. If `root` is a file, then it is the first/// and only item yielded by the iterator. If `root` is a symlink, then it/// is always followed for the purposes of directory traversal. (A root/// `DirEntry` still obeys its documentation with respect to symlinks and/// the `follow_links` setting.)/// Set the minimum depth of entries yielded by the iterator./// to the `new` function on this type. Its direct descendents have depth/// Set the maximum depth of entries yield by the iterator./// Note that this will not simply filter the entries of the iterator, but/// it will actually avoid descending into directories when the depth is/// Follow symbolic links. By default, this is disabled./// When `yes` is `true`, symbolic links are followed as if they were/// normal directories and files. If a symbolic link is broken or is/// involved in a loop, an error is yielded./// When enabled, the yielded [`DirEntry`] values represent the target of/// the link while the path corresponds to the link. See the [`DirEntry`]/// type for more details./// [`DirEntry`]: struct.DirEntry.html/// Follow symbolic links if these are the root of the traversal./// When `yes` is `true`, symbolic links on root paths are followed/// which is effective if the symbolic link points to a directory./// If a symbolic link is broken or is involved in a loop, an error is yielded/// as the first entry of the traversal./// type for more details, and all future entries will be contained within/// the resolved directory behind the symbolic link of the root path./// Set the maximum number of simultaneously open file descriptors used/// by the iterator./// `n` must be greater than or equal to `1`. If `n` is `0`, then it is set/// to `1` automatically. If this is not set, then it defaults to some/// reasonably low number./// This setting has no impact on the results yielded by the iterator/// (even when `n` is `1`). Instead, this setting represents a trade off/// between scarce resources (file descriptors) and memory. Namely, when/// the maximum number of file descriptors is reached and a new directory/// needs to be opened to continue iteration, then a previous directory/// handle is closed and has its unyielded entries stored in memory. In/// practice, this is a satisfying trade off because it scales with respect/// to the *depth* of your file tree. Therefore, low values (even `1`) are/// acceptable./// Note that this value does not impact the number of system calls made by/// an exhausted iterator./// On Windows, if `follow_links` is enabled, then this limit is not/// respected. In particular, the maximum number of file descriptors opened/// is proportional to the depth of the directory tree traversed./// Set a function for sorting directory entries with a comparator/// If a compare function is set, the resulting iterator will return all/// paths in sorted order. The compare function will be called to compare/// entries from the same directory./// WalkDir::new("foo").sort_by(|a,b| a.file_name().cmp(b.file_name()));/// Set a function for sorting directory entries with a key extraction/// WalkDir::new("foo").sort_by_key(|a| a.file_name().to_owned());sort_by_file_name/// Sort directory entries by file name, to ensure a deterministic order./// This is a convenience function for calling `Self::sort_by()`./// WalkDir::new("foo").sort_by_file_name();/// Yield a directory's contents before the directory itself. By default,/// this is disabled./// When `yes` is `false` (as is the default), the directory is yielded/// before its contents are read. This is useful when, e.g. you want to/// skip processing of some directories./// When `yes` is `true`, the iterator yields the contents of a directory/// before yielding the directory itself. This is useful when, e.g. you/// want to recursively delete a directory./// Assume the following directory tree:/// foo////   abc////     qrs///     tuv///   def//// With contents_first disabled (the default), the following code visits/// the directory tree in depth-first order:///     println!("{}", entry.path().display());/// // foo/// // foo/abc/// // foo/abc/qrs/// // foo/abc/tuv/// // foo/def/// With contents_first enabled:/// for entry in WalkDir::new("foo").contents_first(true) {/// Do not cross file system boundaries./// When this option is enabled, directory traversal will not descend into/// directories that are on a different file system from the root path./// Currently, this option is only supported on Unix and Windows. If this/// option is used on an unsupported platform, then directory traversal/// will immediately return an error and will not yield any entries./// Options specified in the builder. Depths, max fds, etc./// The start path./// This is only `Some(...)` at the beginning. After the first iteration,/// this is always `None`.stack_listDirList/// A stack of open (up to max fd) or closed handles to directories./// An open handle is a plain [`fs::ReadDir`] while a closed handle is/// a `Vec<fs::DirEntry>` corresponding to the as-of-yet consumed entries.stack_path/// A stack of file paths./// This is *only* used when [`follow_links`] is enabled. In all other/// cases this stack is empty.oldest_opened/// An index into `stack_list` that points to the oldest open directory/// handle. If the maximum fd limit is reached and a new directory needs to/// be read, the handle at this index is closed before the new directory is/// opened./// The current depth of iteration (the length of the stack at the/// beginning of each iteration).deferred_dirs/// A list of DirEntries corresponding to directories, that are/// yielded after their contents has been fully yielded. This is only/// used when `contents_first` is enabled.root_device/// The device of the root file path when the first call to `next` was/// made./// If the `same_file_system` option isn't enabled, then this is always/// `None`. Conversely, if it is enabled, this is always `Some(...)` after/// handling the root path./// An iterator for recursively descending into a directory./// A value with this type must be constructed with the [`WalkDir`] type, which/// uses a builder pattern to set options such as min/max depth, max open file/// descriptors and whether the iterator should follow symbolic links. After/// constructing a `WalkDir`, call [`.into_iter()`] at the end of the chain./// The order of elements yielded by this iterator is unspecified./// [`.into_iter()`]: struct.WalkDir.html#into_iter.v/// The path of this ancestor./// An ancestor is an item in the directory tree traversed by walkdir, and is/// used to check for loops in the tree when traversing symlinks./// Create a new ancestor from the given directory path./// Returns true if and only if the given open file handle corresponds to/// the same directory as this ancestor./// An opened handle./// This includes the depth of the handle itself./// If there was an error with the initial [`fs::read_dir`] call, then it/// is stored here. (We use an [`Option<...>`] to make yielding the error/// exactly once simpler.)/// [`fs::read_dir`]: https://doc.rust-lang.org/stable/std/fs/fn.read_dir.html/// [`Option<...>`]: https://doc.rust-lang.org/stable/std/option/enum.Option.html/// A closed handle./// All remaining directory entries are read into memory./// A sequence of unconsumed directory entries./// This represents the opened or closed state of a directory handle. When/// open, future entries are read by iterating over the raw `fs::ReadDir`./// When closed, all future entries are read into memory. Iteration then/// proceeds over a [`Vec<fs::DirEntry>`]./// [`Vec<fs::DirEntry>`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html/// If the iterator fails to retrieve the next value, this method returns/// an error value. The error will be wrapped in an Option::Some.skip_current_dir/// Skips the current directory./// This causes the iterator to stop traversing the contents of the least/// recently yielded directory. This means any remaining entries in that/// directory will be skipped (including sub-directories)./// Note that the ergonomics of this method are questionable since it/// borrows the iterator mutably. Namely, you must write out the looping/// condition manually. For example, to skip hidden entries efficiently on/// unix systems:/// use walkdir::{DirEntry, WalkDir};/// fn is_hidden(entry: &DirEntry) -> bool {///     entry.file_name()///          .to_str()///          .map(|s| s.starts_with("."))///          .unwrap_or(false)/// let mut it = WalkDir::new("foo").into_iter();///     let entry = match it.next() {///         Some(Err(err)) => panic!("ERROR: {}", err),///         Some(Ok(entry)) => entry,///     if is_hidden(&entry) {///         if entry.file_type().is_dir() {///             it.skip_current_dir();///         continue;/// You may find it more convenient to use the [`filter_entry`] iterator/// adapter. (See its documentation for the same example functionality as/// above.)/// [`filter_entry`]: #method.filter_entryfilter_entryFilterEntry/// Yields only entries which satisfy the given predicate and skips/// descending into directories that do not satisfy the given predicate./// The predicate is applied to all entries. If the predicate is/// true, iteration carries on as normal. If the predicate is false, the/// entry is ignored and if it is a directory, it is not descended into./// This is often more convenient to use than [`skip_current_dir`]. For/// example, to skip hidden files and directories efficiently on unix/// systems:/// for entry in WalkDir::new("foo")///                      .into_iter()///                      .filter_entry(|e| !is_hidden(e)) {/// Note that the iterator will still yield errors for reading entries that/// may not satisfy the predicate./// Note that entries skipped with [`min_depth`] and [`max_depth`] are not/// passed to this predicate./// Note that if the iterator has `contents_first` enabled, then this/// method is no different than calling the standard `Iterator::filter`/// method (because directory entries are yielded after they've been/// descended into)./// [`skip_current_dir`]: #method.skip_current_dir/// [`max_depth`]: struct.WalkDir.html#method.max_depthhandle_entryget_deferred_dircheck_loopis_same_file_systemskippable/// A recursive directory iterator that skips entries./// Values of this type are created by calling [`.filter_entry()`] on an/// `IntoIter`, which is formed by calling [`.into_iter()`] on a `WalkDir`./// Directories that fail the predicate `P` are skipped. Namely, they are/// never yielded and never descended into./// Entries that are skipped with the [`min_depth`] and [`max_depth`] options/// are not passed through this filter./// If opening a handle to a directory resulted in an error, then it is yielded/// and no corresponding call to the predicate is made./// Type parameter `I` refers to the underlying iterator and `P` refers to the/// predicate, which is usually `FnMut(&DirEntry) -> bool`./// [`.filter_entry()`]: struct.IntoIter.html#method.filter_entry/// an error value. The error will be wrapped in an `Option::Some`./*!
Crate `walkdir` provides an efficient and cross platform implementation
of recursive directory traversal. Several options are exposed to control
iteration, such as whether to follow symbolic links (default off), limit the
maximum number of simultaneous open file descriptors and the ability to
efficiently skip descending into directories.

To use this crate, add `walkdir` as a dependency to your project's
`Cargo.toml`:

```toml
[dependencies]
walkdir = "2"
```

# From the top

The [`WalkDir`] type builds iterators. The [`DirEntry`] type describes values
yielded by the iterator. Finally, the [`Error`] type is a small wrapper around
[`std::io::Error`] with additional information, such as if a loop was detected
while following symbolic links (not enabled by default).

[`WalkDir`]: struct.WalkDir.html
[`DirEntry`]: struct.DirEntry.html
[`Error`]: struct.Error.html
[`std::io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html

# Example

The following code recursively iterates over the directory given and prints
the path for each entry:

```no_run
use walkdir::WalkDir;
# use walkdir::Error;

# fn try_main() -> Result<(), Error> {
for entry in WalkDir::new("foo") {
    println!("{}", entry?.path().display());
}
# Ok(())
# }
```

Or, if you'd like to iterate over all entries and ignore any errors that
may arise, use [`filter_map`]. (e.g., This code below will silently skip
directories that the owner of the running process does not have permission to
access.)

```no_run
use walkdir::WalkDir;

for entry in WalkDir::new("foo").into_iter().filter_map(|e| e.ok()) {
    println!("{}", entry.path().display());
}
```

[`filter_map`]: https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.filter_map

# Example: follow symbolic links

The same code as above, except [`follow_links`] is enabled:

```no_run
use walkdir::WalkDir;
# use walkdir::Error;

# fn try_main() -> Result<(), Error> {
for entry in WalkDir::new("foo").follow_links(true) {
    println!("{}", entry?.path().display());
}
# Ok(())
# }
```

[`follow_links`]: struct.WalkDir.html#method.follow_links

# Example: skip hidden files and directories on unix

This uses the [`filter_entry`] iterator adapter to avoid yielding hidden files
and directories efficiently (i.e. without recursing into hidden directories):

```no_run
use walkdir::{DirEntry, WalkDir};
# use walkdir::Error;

fn is_hidden(entry: &DirEntry) -> bool {
    entry.file_name()
         .to_str()
         .map(|s| s.starts_with("."))
         .unwrap_or(false)
}

# fn try_main() -> Result<(), Error> {
let walker = WalkDir::new("foo").into_iter();
for entry in walker.filter_entry(|e| !is_hidden(e)) {
    println!("{}", entry?.path().display());
}
# Ok(())
# }
```

[`filter_entry`]: struct.IntoIter.html#method.filter_entry
*/send_sync_traitsempty_followempty_fileempty_file_followone_dirone_fileone_dir_one_filemany_filesmany_dirsmany_mixednested_small_max_opensiblingssym_root_file_nofollowsym_root_file_followbroken_sym_root_dir_nofollow_and_root_nofollowbroken_sym_root_dir_follow_and_root_nofollowbroken_sym_root_dir_root_is_always_followedsym_root_dir_nofollow_root_nofollowsym_root_dir_nofollow_root_followsym_root_dir_followsym_file_nofollowsym_file_followsym_dir_nofollowsym_dir_followsym_noloopsym_loop_detectsym_self_loop_no_errorsym_file_self_loop_io_errorsym_dir_self_loop_io_errormin_depth_1min_depth_2max_depth_0max_depth_1max_depth_2min_max_depth_diff_nada// FIXME: This test seems wrong. It should return nothing!min_max_depth_diff_0min_max_depth_diff_1sort_max_openregression_skip_current_dir// Tests that skip_current_dir doesn't destroy internal invariants.// See: https://github.com/BurntSushi/walkdir/issues/118/// A convenient result type alias.entserrsRecursiveResults/// The result of running a recursive directory iterator on a single directory./// Return all of the errors encountered during traversal.assert_no_errors/// Assert that no errors have occurred./// Return all the successfully retrieved directory entries in the order/// in which they were retrieved./// Return all paths from all successfully retrieved directory entries./// This does not include paths that correspond to an error.sorted_ents/// Return all the successfully retrieved directory entries, sorted/// lexicographically by their full file path.sorted_paths/// Return all paths from all successfully retrieved directory entries,/// sorted lexicographically./// A helper for managing a directory in which to run tests./// When manipulating paths within this directory, paths are interpreted/// relative to this directory./// Create a new empty temporary directory./// Return the path to this directory./// Return a path joined to the path to this directory.run_recursive/// Run the given iterator and return the result as a distinct collection/// of directory entries and errors.mkdirp/// Create a directory at the given path, while creating all intermediate/// directories as needed./// Create an empty file at the given path. All ancestor directories must/// already exists.touch_all/// Create empty files at the given paths. All ancestor directories must/// Create a file symlink to the given src with the given link name./// Create a directory symlink to the given src with the given link name./// A simple wrapper for creating a temporary directory that is automatically/// deleted when it's dropped./// Create a new empty temporary directory under the system's configured/// temporary directory.device_num// SeqCst is the only ordering used to ensure accessing the state and// TryLock are never re-ordered./// Create a new `want` channel./// An entity that gives a value when wanted./// An entity that wants a value.SharedGiver/// A cloneable `Giver`./// It differs from `Giver` in that you cannot poll for `want`. It's only/// usable as a cancellation watcher./// The `Taker` has canceled its interest in a value.WantGive/// Returns a `Future` that fulfills when the `Taker` has done some action./// Poll whether the `Taker` has registered interest in another value./// - If the `Taker` has called `want()`, this returns `Async::Ready(())`./// - If the `Taker` has not called `want()` since last poll, this///   returns `Async::NotReady`, and parks the current task to be notified///   when the `Taker` does call `want()`./// - If the `Taker` has canceled (or dropped), this returns `Closed`./// After knowing that the Taker is wanting, the state can be reset by/// calling [`give`](Giver::give).give/// Mark the state as idle, if the Taker currently is wanting./// Returns true if Taker was wanting, false otherwise.is_wanting/// Check if the `Taker` has called `want()` without parking a task./// This is safe to call outside of a futures task context, but other/// means of being notified is left to the user./// Check if the `Taker` has canceled interest without parking a task./// Converts this into a `SharedGiver`./// Signal to the `Giver` that the want is canceled./// This is useful to tell that the channel is closed if you cannot/// drop the value yet./// Signal to the `Giver` that a value is wanted.tokio_syncwant_readywant_notify_0/*
    /// This tests that if the Giver moves tasks after parking,
    /// it will still wake up the correct task.
    #[test]
    fn want_notify_moving_tasks() {
        use std::sync::Arc;
        use futures::executor::{spawn, Notify, NotifyHandle};

        struct WantNotify;

        impl Notify for WantNotify {
            fn notify(&self, _id: usize) {
            }
        }

        fn n() -> NotifyHandle {
            Arc::new(WantNotify).into()
        }

        let (mut gv, mut tk) = new();

        let mut s = spawn(poll_fn(move || {
            gv.poll_want()
        }));

        // Register with t1 as the task::current()
        let t1 = n();
        assert!(s.poll_future_notify(&t1, 1).unwrap().is_not_ready());

        thread::spawn(move || {
            thread::sleep(::std::time::Duration::from_millis(100));
            tk.want();
        });

        // And now, move to a ThreadNotify task.
        s.into_inner().wait().expect("poll_want");
    }
    *//*
    #[test]
    fn stress() {
        let nthreads = 5;
        let nwants = 100;

        for _ in 0..nthreads {
            let (mut gv, mut tk) = new();
            let (mut tx, mut rx) = mpsc::channel(0);

            // rx thread
            thread::spawn(move || {
                let mut cnt = 0;
                poll_fn(move || {
                    while cnt < nwants {
                        let n = match rx.poll().expect("rx poll") {
                            Async::Ready(n) => n.expect("rx opt"),
                            Async::NotReady => {
                                tk.want();
                                return Ok(Async::NotReady);
                            },
                        };
                        assert_eq!(cnt, n);
                        cnt += 1;
                    }
                    Ok::<_, ()>(Async::Ready(()))
                }).wait().expect("rx wait");
            });

            // tx thread
            thread::spawn(move || {
                let mut cnt = 0;
                let nsent = poll_fn(move || {
                    loop {
                        while let Ok(()) = tx.try_send(cnt) {
                            cnt += 1;
                        }
                        match gv.poll_want() {
                            Ok(Async::Ready(_)) => (),
                            Ok(Async::NotReady) => return Ok::<_, ()>(Async::NotReady),
                            Err(_) => return Ok(Async::Ready(cnt)),
                        }
                    }
                }).wait().expect("tx wait");

                assert_eq!(nsent, nwants);
            }).join().expect("thread join");
        }
    }
    *///! A Futures channel-like utility to signal when a value is wanted.//! Futures are supposed to be lazy, and only starting work if `Future::poll`//! is called. The same is true of `Stream`s, but when using a channel as//! a `Stream`, it can be hard to know if the receiver is ready for the next//! Put another way, given a `(tx, rx)` from `futures::sync::mpsc::channel()`,//! how can the sender (`tx`) know when the receiver (`rx`) actually wants more//! work to be produced? Just because there is room in the channel buffer//! doesn't mean the work would be used by the receiver.//! This is where something like `want` comes in. Added to a channel, you can//! make sure that the `tx` only creates the message and sends it when the `rx`//! has `poll()` for it, and the buffer was empty.//! ```nightly//! # //#![feature(async_await)]//! extern crate want;//! # fn spawn<T>(_t: T) {}//! # fn we_still_want_message() -> bool { true }//! # fn mpsc_channel() -> (Tx, Rx) { (Tx, Rx) }//! # struct Tx;//! # impl Tx { fn send<T>(&mut self, _: T) {} }//! # struct Rx;//! # impl Rx { async fn recv(&mut self) -> Option<Expensive> { Some(Expensive) } }//! // Some message that is expensive to produce.//! struct Expensive;//! // Some futures-aware MPSC channel...//! let (mut tx, mut rx) = mpsc_channel();//! // And our `want` channel!//! let (mut gv, mut tk) = want::new();//! // Our receiving task...//! spawn(async move {//!     // Maybe something comes up that prevents us from ever//!     // using the expensive message.//!     // Without `want`, the "send" task may have started to//!     // produce the expensive message even though we wouldn't//!     // be able to use it.//!     if !we_still_want_message() {//!     // But we can use it! So tell the `want` channel.//!     tk.want();//!     match rx.recv().await {//!         Some(_msg) => println!("got a message"),//!         None => println!("DONE"),//! // Our sending task//!     // It's expensive to create a new message, so we wait until the//!     // receiving end truly *wants* the message.//!     if let Err(_closed) = gv.want().await {//!         // Looks like they will never want it...//!     // They want it, let's go!//!     tx.send(Expensive);// ===== impl Giver ======// ===== impl SharedGiver ======// ===== impl Taker ======// ===== impl Closed ======// ===== impl Inner ======// ===== impl PollFn ======ObjectInfoclient_implNoWaylandLib/// Dispatch an event for the associated object/// If the event has a `NewId` argument, the callback must return the object data/// for the newly created object/// Notification that the object has been destroyed and is no longer active/// Helper for forwarding a Debug implementation of your `ObjectData` type/// By default will just print `ObjectData { ... }`data_as_any/// Helper for accessing user data/// This function is used to back the `Proxy::data()` function in `wayland_client`.  By default,/// it returns `self` (via [`Downcast`][downcast_rs::DowncastSync]), but this may be overridden to allow downcasting user data/// without needing to have access to the full type./// A trait representing your data associated to an object/// You will only be given access to it as a `&` reference, so you/// need to handle interior mutability by yourself./// The methods of this trait will be invoked internally every time a/// new object is created to initialize its data.r" Returns an `Arc`-ed object from an `Arc`-ed trait object if the underlying object is of"r" type `__T`. Returns the original `Arc`-ed trait if it isn't."downcast_arcInnerObjectId/// An ID representing a Wayland object/// The backend internally tracks which IDs are still valid, invalidates them when the protocol object they/// represent is destroyed. As such even though the Wayland protocol reuses IDs, you can confidently compare/// two `ObjectId` for equality, they will only compare as equal if they both represent the same protocol/// Check if this is a null ID/// **Note:** This is not the same as checking if the ID is still valid, which cannot be done without the/// [`Backend`]. A null ID is the ID equivalent of a null pointer: it never has been valid and never will/// be./// Create a null object ID/// This object ID is always invalid, and should be used as placeholder in requests that create objects,/// or for request with an optional `Object` argument./// See [`Backend::send_request()`] for details./// Interface of the represented objectprotocol_id/// Return the protocol-level numerical ID of this object/// Protocol IDs are reused after object destruction, so this should not be used as a unique identifier,/// instead use the [`ObjectId`] directly, it implements [`Clone`], [`PartialEq`], [`Eq`] and [`Hash`].InnerBackend/// A Wayland client backend/// This type hosts all the interface for interacting with the wayland protocol. It can be/// cloned, all clones refer to the same underlying connection.WeakInnerBackendWeakBackend/// A weak handle to a [`Backend`]/// This handle behaves similarly to [`Weak`][std::sync::Weak], and can be used to keep access to/// the backend without actually preventing it from being dropped./// Try to upgrade this weak handle to a [`Backend`]/// Returns [`None`] if the associated backend was already dropped./// Try to initialize a Wayland backend on the provided unix stream/// The provided stream should correspond to an already established unix connection with/// the Wayland server./// This method can only fail on the `sys` backend if the `dlopen` cargo feature was enabled/// and the system wayland library could not be found./// Get a [`WeakBackend`] from this backend/// Flush all pending outgoing requests to the server/// Most errors on this method mean that the Wayland connection is no longer valid, the only/// exception being an IO [`WouldBlock`] error. In that case it means that you should try flushing again/// later./// You can however expect this method returning [`WouldBlock`] to be very rare: it can only occur if/// either your client sent a lot of big messages at once, or the server is very laggy./// Access the Wayland socket FD for pollingdisplay_id/// Get the object ID for the `wl_display`/// Get the last error that occurred on this backend/// If this returns [`Some`], your Wayland connection is already dead./// Get the detailed protocol information about a wayland object/// Returns an error if the provided object ID is no longer valid./// Sends a request to the server/// Returns an error if the sender ID of the provided message is no longer valid./// **Panic:**/// Several checks against the protocol specification are done, and this method will panic if they do/// not pass:/// - the message opcode must be valid for the sender interface/// - the argument list must match the prototype for the message associated with this opcode/// - if the method creates a new object, a [`ObjectId::null()`] must be given///   in the argument list at the appropriate place, and a `child_spec` (interface and version)///   can be provided. If one is provided, it'll be checked against the protocol spec. If the///   protocol specification does not define the interface of the created object (notable example///   is `wl_registry.bind`), the `child_spec` must be provided./// Access the object data associated with a given object ID/// Returns an error if the object ID is not longer valid or if it corresponds to a Wayland/// object that is not managed by this backend (when multiple libraries share the same Wayland/// socket via `libwayland` if using the system backend)./// Set the object data associated with a given object ID/// Create a new reading guard/// This is the first step for actually reading events from the Wayland socket. See/// [`ReadEventsGuard`] for how to use it./// This call will not block, but may return [`None`] if the inner queue of the backend needs to/// be dispatched. In which case you should invoke/// [`dispatch_inner_queue()`][Self::dispatch_inner_queue()].dispatch_inner_queue/// Dispatches the inner queue of this backend if necessary/// This function actually only does something when using the system backend. It dispaches an inner/// queue that the backend uses to wrap `libwayland`. While this dispatching is generally done in/// [`ReadEventsGuard::read()`], if multiple threads are interacting with the/// Wayland socket it can happen that this queue was filled by another thread. In that case/// [`prepare_read()`][Self::prepare_read()] will return [`None`], and you should invoke/// this function instead of using the [`ReadEventsGuard`]/// Returns the number of messages that were dispatched to their [`ObjectData`] callbacks.InnerReadEventsGuard/// Guard for synchronizing event reading across multiple threads/// If multiple threads need to read events from the Wayland socket concurrently,/// it is necessary to synchronize their access. Failing to do so may cause some of the/// threads to not be notified of new events, and sleep much longer than appropriate./// This guard is provided to ensure the proper synchronization is done. The guard is created using/// the [`Backend::prepare_read()`] method. And the event reading is/// triggered by consuming the guard using the [`ReadEventsGuard::read()`] method, synchronizing/// with other threads as necessary so that only one of the threads will actually perform the socket read./// If you plan to poll the Wayland socket for readiness, the file descriptor can be retrieved via/// the [`ReadEventsGuard::connection_fd()`] method. Note that for the synchronization to/// correctly occur, you must *always* create the `ReadEventsGuard` *before* polling the socket./// Dropping the guard is valid and will cancel the prepared read.connection_fd/// Attempt to read events from the Wayland socket/// If multiple threads have a live reading guard, this method will block until all of them/// are either dropped or have their `read()` method invoked, at which point one of the threads/// will read events from the socket and invoke the callbacks for the received events. All/// threads will then resume their execution./// This returns the number of dispatched events, or `0` if an other thread handled the dispatching./// If no events are available to read from the socket, this returns a [`WouldBlock`] IO error.DumbObjectDataUninitObjectDataAllowNullArgumentTypeMessageDescANONYMOUS_INTERFACEWL_DISPLAY_INTERFACE/// Interface `wl_display`WL_REGISTRY_INTERFACE/// Interface `wl_registry`WL_CALLBACK_INTERFACE/// Interface `wl_callback`//! Core interfaces of the protocol//! This module contains hard-coded interfaces for `wl_display`, `wl_registry` and `wl_callback`.//! These interfaces are frozen in the protocol and can never change. They are the only interfaces//! which the backends need to be aware of in particular.has_debug_client_env/// The `WAYLAND_DEBUG` env variable is set to debug client.print_dispatched_message/// Print the dispatched message to stderr in a following format:/// `[timestamp] <- interface@id.msg_name(args)`print_send_message/// Print the send message to stderr in a following format:/// `[timestamp] -> interface@id.msg_name(args)`DisplaySliceprint_timestamp/// Print timestamp in seconds.microseconds format.//! Debugging helpers to handle `WAYLAND_DEBUG` env variable./// Reexport of the `smallvec` crate, which is part of `wayland-backend`'s public API./// Helper macro for quickly making a [`Message`][crate::protocol::Message]log_warnlog_infolog_debugrscore_interfaces//! Backend API for wayland crates//! This crate provide low-level APIs for interacting with the Wayland protocol,//! both client-side and server-side.//! Two possible backends are provided by this crate: the system backend ([`sys`] module)//! which relies on the system-provided wayland libraries, and the rust backend ([`rs`] module)//! which is an alternative rust implementation of the protocol. The rust backend is always//! available, and the system backend is controlled by the `client_system` and `server_system`//! cargo features. The `dlopen` cargo feature ensures that the system wayland//! libraries are loaded dynamically at runtime, so that your executable does not link them and//! can gracefully handle their absence (for example by falling back to X11).//! Additionally the default backends are reexported as toplevel `client` and `server` modules//! in this crate. For both client and server, the default backend is the system one if the//! associated cargo feature is enabled, and the rust one otherwise.//! Using these reexports is the recommended way to use the crate://! - If you don't need the `*_system` features, an other crate enabling them will not impact your code in//!   any way as both backends have the same API (the system backend only has more methods)//! - If your code needs to do FFI, you just need to directly depend on `wayland-backend` with the//!   appropriate `*_system` feature enabled, and all the other crates in your dependency tree will//!   automatically use the `sys` backend.//! Both the `wayland-client` and `wayland-server` crates follow this principle, so everything will "Just//! Work" when using them.//! This crate can generate some runtime error message (notably when a protocol error occurs). By default//! those messages are printed to stderr. If you activate the `log` cargo feature, they will instead be//! piped through the `log` crate.//! ## raw-window-handle integration//! The `rwh_06` feature activates the [`HasDisplayHandle`][raw_window_handle::HasDisplayHandle] implementation//! for the client module [`Backend`][client::Backend].//! ### Deprecated raw-window-handle versions//! While raw-window-handle 0.5 is supported via the `raw-window-handle` feature, it is deprecated and will be removed in the future.//! Note that the `client_system` feature must also be enabled for the implementation to be activated.// The api modules are imported two times each, this is not accidental// Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly doc -p <crate>/*
 * These trampoline functions need to always be here because the build script cannot
 * conditionally build their C counterparts on whether the crate is tested or not...
 * They'll be optimized out when unused.
 */wl_argumentwl_interfacewl_message/// Null values are allowed./// Null values are forbidden./// Describes whether an argument may have a null value./// An integer argument. Represented by a [`i32`]./// An unsigned integer argument. Represented by a [`u32`]./// A signed fixed point number with 1/256 precision/// A string. This is represented as a [`CString`] in a message./// Id of a wayland objectNewId/// Id of a newly created wayland object/// `Vec<u8>`/// A file descriptor argument. Represented by a [`RawFd`]./// Enum of possible argument types as recognized by the wire/// Returns true if the type of the argument is the same./// CString/// The value is boxed to reduce the stack size of Argument. The performance/// impact is negligible as `string` arguments are pretty rare in the protocol./// impact is negligible as `array` arguments are pretty rare in the protocol./// Enum of possible argument of the protocol/// Retrieve the type of a given argument instance/// The name of the interface./// The maximum supported version of the interface./// A list that describes every request this interface supports./// A list that describes every event this interface supports.c_ptr/// A C representation of this interface that may be used to interoperate with libwayland./// Description of wayland interface./// An interface describes the possible requests and events that a wayland client and compositor use to/// communicate./// Name of this message/// Signature of the message/// Minimum required version of the interface/// Whether this message is a destructorchild_interface/// The child interface created from this message./// In the wayland xml format, this corresponds to the `new_id` type.arg_interfaces/// The interfaces passed into this message as arguments./// Wire metadata of a given message/// Special interface representing an anonymous object/// The protocol ID/// The interface/// The version/// Description of the protocol-level information of an object/// The error code associated with the error/// It should be interpreted as an instance of the `Error` enum of the/// associated interface.object_id/// The id of the object that caused the error/// The interface of the object that caused the error/// The message sent by the server describing the error/// A protocol error/// This kind of error is generated by the server if your client didn't respect/// the protocol, after which the server will kill your connection.INLINE_ARGS/// Number of arguments that are stocked inline in a `Message` before allocating/// This is a ad-hoc number trying to reach a good balance between avoiding too many allocations/// and keeping the stack size of `Message` small.// Note: Keep in sync with `wayland_scanner::common::gen_write_body`.sender_id/// The id of the object that sent the message./// The opcode of the message./// The arguments of the message./// Represents a message that has been sent from some object./// Map some closure on all Fd contained in this message, to change the Fd generic parameter.same_interface/// Returns true if the two interfaces are the same.check_for_signaturesame_interface_or_anonymous/// The interpreted value/// The stored value does not match one defined by the protocol file/// An enum value in the protocol.WEnumError/// Error representing an unknown numeric variant for a [`WEnum`]/// Convert this [`WEnum`] into a result/// This can be used to take advantage of the numerous helper methods on [`Result`] if you/// don't plan to handle the unknown case of this enum./// You can also use the [`From`] and [`Into`] traits to perform the same conversion./// Constructs an enum from the integer format used by the wayland protocol./// Converts an enum into a numerical form used by the wayland protocol.//! Types and utilities for manipulating the Wayland protocolSERVER_ID_LIMITBufferedSocketMessageParseErrorclient_destroyedserver_destroyedProtocolStateprepared_readsread_condvarread_serialReadingStatelock_protocollock_read/// This call will not block, but event callbacks may be invoked in the process/// of preparing the guard./// are either dropped or have their `read()` method invoked, at which point on of the threads/// If no events are available to read from the socket, this returns a `WouldBlock` IO error.null_id// Nothing to do here, we don't have an inner queuenext_serialno_last_errorstore_and_return_errorstore_if_not_wouldblock_and_return_errorhandle_display_event//! Client-side rust implementation of a Wayland protocol backend/// Limit separating server-created from client-created objects IDs in the namespace/// Interface name of this object/// Version of this object/// ObjectData associated to this object (ex: its event queue client side)/// The representation of a protocol objectclient_objectsserver_objects/// A holder for the object store of a connection/// Keeps track of which object id is associated to which/// interface object, and which is currently unused./// Create a new empty object map/// Find an object in the store/// Remove an object from the store/// Does nothing if the object didn't previously exists/// Insert given object for given id/// Can fail if the requested id is not the next free id of this store./// (In which case this is a protocol error)client_insert_new/// Allocate a new id for an object in the client namespaceserver_insert_new/// Allocate a new id for an object in the server namespace/// Mutably access an object of the mapall_objectsinsert_in// insert a new object in a store at the first free placeinsert_in_at// insert an object at a given place in a store//! Wayland objects mapserver_impl"../client_api.rs"/// Client-side rust implementation of a Wayland protocol backend/// The main entrypoint is the [`Backend::connect()`][client::Backend::connect()] method."../server_api.rs"/// Server-side rust implementation of a Wayland protocol backend/// The main entrypoint is the [`Backend::new()`][server::Backend::new()] method.//! Rust implementations of the Wayland backendsDisconnectReasonPendingDestructorClientDataClientIdGlobalHandlerInnerClientIdInnerGlobalIdArgSmallVecInvalidObjectcreate_objectobject_infosend_delete_idget_object_dataset_object_datapost_display_errorpost_errorget_credentialsnext_requestobject_for_protocol_idqueue_all_destructorshandle_display_requesthandle_registry_requestprocess_requestclientsClientStoreget_client_mutclients_mutall_clients_idGlobalIdInnerHandledispatch_clientdispatch_all_clientsdispatch_events_forDispatchActioncreated_idGlobalInfopending_destructorsErasedStateWeakInnerHandleinsert_clientget_client_dataget_client_credentialswith_all_clientswith_all_objects_forget_object_data_anycreate_globaldisable_globalglobal_infoget_global_handlercommon_pollclient_idsame_client_as/// An id of a client connected to the server./// The ID of a global//! Server-side rust implementation of a Wayland protocol backendknown_registriesget_handlercheck_bindnew_registrysend_all_globals_tosend_global_to_allsend_global_tosend_global_remove_to/*
    GlobalId.id is the global protocol name (starting at 1), hence
    we must subtract 1 to it before indexing the vec
*/parse_messagewrite_to_buffersMessageWriteErrorMAX_FDS_OUT/// Maximum number of FD that can be sent in a single socket messageMAX_BYTES_OUT/// Maximum number of bytes that can be sent in a single socket message/// A wayland socket/// Send a single message to the socket/// A single socket message can contain several wayland messages/// The `fds` slice should not be longer than `MAX_FDS_OUT`, and the `bytes`/// slice should not be longer than `MAX_BYTES_OUT` otherwise the receiving/// end may lose some data.rcv_msg/// Receive a single message from the socket/// Return the number of bytes received and the number of Fds received./// Errors with `WouldBlock` is no message is available./// A single socket message can contain several wayland messages./// The `buffer` slice should be at least `MAX_BYTES_OUT` long and the `fds`/// slice `MAX_FDS_OUT` long, otherwise some data of the received message may/// be lost.in_datain_fdsout_dataout_fds/// An adapter around a raw Socket that directly handles buffering and/// conversion from/to wayland messages/// Wrap a Socket into a Buffered Socket/// Flush the contents of the outgoing buffer into the socketattempt_write_message// internal method// attempts to write a message in the internal out buffers,// returns true if successful// if false is returned, it means there is not enough space// in the buffer/// Write a message to the outgoing buffer/// This method may flush the internal buffer if necessary (if it is full)./// If the message is too big to fit in the buffer, the error `Error::Sys(E2BIG)`/// will be returned.fill_incoming_buffers/// Try to fill the incoming buffers of this socket, to prepare/// a new round of parsing.read_one_message/// Read and deserialize a single message from the incoming buffers socket/// This method requires one closure that given an object id and an opcode,/// must provide the signature of the associated request/event, in the form of/// a `&'static [ArgumentType]`./*
 * Buffer
 *//// Advance the internal counter of occupied space/// Advance the read offset of current occupied space/// Clears the contents of the buffer/// This only sets the counter of occupied space back to zero,/// allowing previous content to be overwritten./// Get the current contents of the occupied space of the bufferget_writable_storage/// Get mutable access to the unoccupied space of the buffermove_to_front/// Move the unread contents of the buffer to the front, to ensure/// maximal write space availabilityassert_eq_msgs// check if two messages are equal// if arguments contain FDs, check that the fd point to// the same file, rather than are the same number.write_read_cyclewrite_read_cycle_fdwrite_read_cycle_multipleparse_with_string_len_multiple_of_4//! Wayland socket manipulation/*
 * Socket
 *//*
 * BufferedSocket
 *//// The buffer is too small to hold the message contentsDupFdFailed/// The message contains a FD that could not be dup-ed/// Error generated when trying to serialize a message into buffersMissingFD/// The message references a FD but the buffer FD is empty/// More data is needed to deserialize the message/// The message is malformed and cannot be parsed/// Error generated when trying to deserialize a message from buffers/// Serialize the contents of this message into provided buffers/// Returns the number of elements written in each buffer/// Any serialized Fd will be `dup()`-ed in the process/// Attempts to parse a single wayland message with the given signature./// If the buffers contains several messages, only the first one will be parsed,/// and the unused tail of the buffers is returned. If a single message was present,/// the returned slices should thus be empty./// Errors if the message is malformed.// Stabalized in Rust 1.73into_from_raw_cycle//! Types and routines used to manipulate arguments from the wire format/// Dispatch a request for the associated object/// If the request has a `NewId` argument, the callback must return the object datacan_view/// Check if given client is allowed to interact with given global/// If this function returns false, the client will not be notified of the existence/// of this global, and any attempt to bind it will result in a protocol error as if/// the global did not exist./// Default implementation always return true./// A global has been bound/// Given client bound given global, creating given object./// The method must return the object data for the newly created object./// Helper for forwarding a Debug implementation of your `GlobalHandler` type/// By default will just print `GlobalHandler { ... }`/// A trait representing the handling of new bound globals/// Notification that the client was initialized/// Notification that the client is disconnected/// Helper for forwarding a Debug implementation of your `ClientData` type/// A trait representing your data associated to a client/// represent is destroyed. As such even though the Wayland protocol reuses IDs, you still confidently compare/// object from the same client./// Returns whether this object is a null object./// Returns an object id that represents a null object./// This object ID is always invalid, and should be used for events with an optional `Object` argument./// Returns the interface of this object./// Check if two object IDs are associated with the same client/// *Note:* This may spuriously return `false` if one (or both) of the objects to compare/// is no longer valid./// Protocol IDs are reused after object destruction and each client has its own ID space, so this should/// not be used as a unique identifier, instead use the `ObjectId` directly, it implements `Clone`,/// `PartialEq`, `Eq` and `Hash`./// An ID representing a Wayland client/// The backend internally tracks which IDs are still valid, invalidates them when the client they represent/// is disconnected. As such you can confidently compare two `ClientId` for equality, they will only compare/// as equal if they both represent the same client./// An Id representing a global/// Main handle of a backend to the Wayland protocol/// This type hosts most of the protocol-related functionality of the backend, and is the/// main entry point for manipulating Wayland objects. It can be retrieved from the backend via/// [`Backend::handle()`] and cloned, and is given to you as argument in many callbacks.WeakHandle/// A weak reference to a [`Handle`]/// the handle without actually preventing it from being dropped./// Try to upgrade this weak handle to a [`Handle`]/// Get a [`WeakHandle`] from this handle/// Initializes a connection with a client./// The `data` parameter contains data that will be associated with the client./// Returns the id of the client which owns the object./// Returns the data associated with a client./// Retrive the [`Credentials`] of a client/// Invokes a closure for all clients connected to this server/// Note that while this method is running, an internal lock of the backend is held,/// as a result invoking other methods of the `Handle` within the closure will deadlock./// You should thus store the relevant `ClientId` in a container of your choice and process/// them after this method has returned./// Invokes a closure for all objects owned by a client./// You should thus store the relevant `ObjectId` in a container of your choice and process/// Retrieve the `ObjectId` for a wayland object given its protocol numerical ID/// Create a new object for given client/// To ensure state coherence of the protocol, the created object should be immediately/// sent as a "New ID" argument in an event to the client./// This method will panic if the type parameter `D` is not same to the same type as the/// one the backend was initialized with./// Send an event to the client/// Checks against the protocol specification are done, and this method will panic if they do/// Returns the data associated with an object./// **Panic:** This method will panic if the type parameter `D` is not same to the same type as the/// Returns the data associated with an object as a `dyn Any`/// Sets the data associated with some object./// Posts a protocol error on an object. This will also disconnect the client which created the object./// Kills the connection to a client./// The disconnection reason determines the error message that is sent to the client (if any)./// Creates a global of the specified interface and version and then advertises it to clients./// The clients which the global is advertised to is determined by the implementation of the [`GlobalHandler`]./// Disables a global object that is currently active./// The global removal will be signaled to all currently connected clients. New clients will not know of/// the global, but the associated state and callbacks will not be freed. As such, clients that still try/// to bind the global afterwards (because they have not yet realized it was removed) will succeed./// Invoking this method on an already disabled or removed global does nothing. It is not possible to/// re-enable a disabled global, this method is meant to be invoked some time before actually removing/// the global, to avoid killing clients because of a race./// Removes a global object and free its ressources./// The global object will no longer be considered valid by the server, clients trying to bind it will be/// killed, and the global ID is freed for re-use./// It is advised to first disable a global and wait some amount of time before removing it, to ensure all/// clients are correctly aware of its removal. Note that clients will generally not expect globals that/// represent a capability of the server to be removed, as opposed to globals representing peripherals/// (like `wl_output` or `wl_seat`)./// This methods does nothing if the provided `GlobalId` corresponds to an already removed global./// Returns information about a global./// Returns the handler which manages the visibility and notifies when a client has bound the global./// Flushes pending events destined for a client./// If no client is specified, all pending events are flushed to all clients./// A backend object that represents the state of a wayland server./// A backend is used to drive a wayland server by receiving requests, dispatching messages to the appropriate/// handlers and flushes requests to be sent back to the client./// Initialize a new Wayland backend/// Returns a handle which represents the server side state of the backend./// The handle provides a variety of functionality, such as querying information about wayland objects,/// obtaining data associated with a client and it's objects, and creating globals./// Returns the underlying file descriptor./// The file descriptor may be monitored for activity with a polling mechanism such as epoll or kqueue./// When it becomes readable, this means there are pending messages that would be dispatched if you call/// [`Backend::dispatch_all_clients`]./// The file descriptor should not be used for any other purpose than monitoring it.dispatch_single_client/// Dispatches all pending messages from the specified client./// This method will not block if there are no pending messages./// The provided `data` will be provided to the handler of messages received from the client./// For performance reasons, use of this function should be integrated with an event loop, monitoring/// the file descriptor associated with the client and only calling this method when messages are/// **Note:** This functionality is currently only available on the rust backend, invoking this method on/// the system backend will do the same as invoking/// [`Backend::dispatch_all_clients()`]./// Dispatches all pending messages from all clients./// The provided `data` will be provided to the handler of messages received from the clients./// For performance reasons, use of this function should be integrated with an event loop, monitoring the/// file descriptor retrieved by [`Backend::poll_fd`] and only calling this method when messages are// Workaround: Some versions of rustc throw a `struct is never constructed`-warning here,// if the `server_system`-feature is enabled, even though the `rs`-module makes use if it.free_arraysRUST_MANAGEDwl_proxyProxyUserDatawl_displayowns_displayevqwl_event_queueknown_proxiesdispatch_locklock_statedisplay_ptrfrom_foreign_displaydispatch_pendingread_non_dispatchmanage_object/// Start managing a Wayland object./// Safety: This will change the event queue the proxy is associated with./// Changing the event queue of an existing proxy is not thread-safe./// If another thread is concurrently reading the wayland socket and the/// proxy already received an event it might get enqueued on the old event queue.manage_object_internal/// Opposed to [`Self::manage_object`], this does not acquire any guards.dispatcher_func//! Client-side implementation of a Wayland protocol backend using `libwayland`wl_array/// Magic static for wayland objects managed by wayland-client or wayland-server/// This static serves no purpose other than existing at a stable address./// Client-side implementation of a Wayland protocol backend using `libwayland`/// Entrypoints are:/// - [`Backend::connect()`][client::Backend::connect()] method if you're creating the Wayland connection/// - [`Backend::from_foreign_display()`][client::Backend::from_foreign_display()] if you're interacting with an///   already existing Wayland connection through FFI./// Creates an object id from a libwayland-client pointer./// This function returns an [`InvalidId`][client::InvalidId] error if the interface of the proxy does/// not match the provided interface./// The provided pointer must be a valid pointer to a `wl_resource` and remain valid for as/// long as the retrieved `ObjectId` is used./// Get the underlying libwayland pointer for this object/// Creates a Backend from a foreign `*mut wl_display`./// This is useful if you are writing a library that is expected to plug itself into an existing/// Wayland connection./// This will initialize the [`Backend`][Self] in "guest" mode, meaning it will not close the/// connection on drop. After the [`Backend`][Self] is dropped, if the server sends an event/// to an object that was created from it, that event will be silently discarded. This may lead to/// protocol errors if the server expects an answer to that event, as such you should make sure to/// cleanup your Wayland state before dropping the [`Backend`][Self]./// You need to ensure the `*mut wl_display` remains live as long as the  [`Backend`][Self]/// (or its clones) exist./// Returns the underlying `wl_display` pointer to this backend./// This pointer is needed to interface with EGL, Vulkan and other C libraries./// This pointer is only valid for the lifetime of the backend./// Take over handling for a proxy created by a third party./// There must never be more than one party managing an object. This is only/// safe to call when a third party gave you ownership of an unmanaged proxy./// The caller is also responsible for making sure the passed interface matches/// the proxy.read_without_dispatch/// The same as [`read`], but doesn't dispatch events./// To dispatch them, use [`dispatch_inner_queue`]./// [`read`]: client::ReadEventsGuard::read/// [`dispatch_inner_queue`]: client::Backend::dispatch_inner_queue/// Server-side implementation of a Wayland protocol backend using `libwayland`wl_resource/// Creates an object from a C pointer./// This function returns an [`InvalidId`][server::InvalidId] error if the interface of the/// resource does not match the provided interface./// Returns the pointer that represents this object./// The pointer may be used to interoperate with libwayland./// Access the underlying `*mut wl_display` pointer//! Implementations of the Wayland backends using the system `libwayland`// API complements for FFIPENDING_DESTRUCTORS// Pointer is &mut Vec<PendingDestructor<D>>/// An id of an object on a wayland server.ExternalResourceDataexternal_resource_destroy_notifywl_listenerwl_clientwl_globalResourceUserDataClientUserDataGlobalUserDatatimer_sourcewl_event_sourceknown_globalsis_known_globalinit_clientclient_id_from_ptrclient_user_dataclient_destroy_notifyglobal_bindglobal_filterinit_resourceresource_dispatcherresource_destructor//! Server-side implementation of a Wayland protocol backend using `libwayland`impl_server_objectdataserver_rsserver_sysimpl_client_objectdataclient_rsclient_sysexpand_testconcat_identsServerClientDataimpl_server_clientdataserverdata_implsclientdata_impls// create a global and send the many_args methodgenerate_interfacesmany_argsobject_argsprotocol_errorserver_created_objectsensure_bothsend_sync_client_rssend_sync_client_syssend_sync_server_rssend_sync_server_sysDoNothingData/*
 * A "do nothing" data as a helper
 *//*
 * Assertion of Send/Sync for all relevant objects
 */// Server Global Handler// Server Object Data// Client Object Data// create a global and create objectsProtocolErrorServerDataimpl_globalhandlerSyncData// send a wl_display.sync request and receive the response/// An error type representing the failure to load libwayland/// The connection encountered an IO error/// The connection encountered a protocol error/// An error that can occur when using a Wayland connection/// An error generated when trying to act on an invalid `ObjectId`./// The interface of the global./// The version of the global that is advertised to clients./// Whether the global is disabled./// Description of a global advertised to some clients./// The wayland system library could not be loaded/// Initialized failed due to an underlying I/O error/// An error type representing the failure to initialize a backend/// The connection has been closed by the server or client./// The server has sent the client a protocol error, terminating the connection./// Describes why a client has been disconnected from the server./// pid of the client/// uid of the client/// gid of the client/// Holds the client credentialsWlDisplay/// The Wayland connection/// This is the main type representing your connection to the Wayland server, though most of the interaction/// with the protocol are actually done using other types. The two main uses a simple app has for the/// [`Connection`] are:/// - Obtaining the initial [`WlDisplay`] through the [`display()`][Self::display()] method./// - Creating new [`EventQueue`]s with the [`new_event_queue()`][Self::new_event_queue()] method./// It can be created through the [`connect_to_env()`][Self::connect_to_env()] method to follow the/// configuration from the environment (which is what you'll do most of the time), or using the/// [`from_socket()`][Self::from_socket()] method if you retrieved your connected Wayland socket through/// other means./// In case you need to plug yourself into an external Wayland connection that you don't control, you'll/// likely get access to it as a [`Backend`], in which case you can create a [`Connection`] from it using/// the [`from_backend()`][Self::from_backend()] method.connect_to_env/// Try to connect to the Wayland server following the environment/// This is the standard way to initialize a Wayland connection./// Initialize a Wayland connection from an already existing Unix stream/// Get the `WlDisplay` associated with this connectionnew_event_queue/// Create a new event queuefrom_backend/// Wrap an existing [`Backend`] into a [`Connection`]/// Get the [`Backend`] underlying this [`Connection`]/// Flush pending outgoing events to the server/// This needs to be done regularly to ensure the server receives all your requests, though several/// dispatching methods do it implicitly (this is stated in their documentation when they do)./// Start a synchronized read from the socket/// This is needed if you plan to wait on readiness of the Wayland socket using an event loop. See/// [`ReadEventsGuard`] for details. Once the events are received, you'll then need to dispatch them from/// their event queues using [`EventQueue::dispatch_pending()`]./// If you don't need to manage multiple event sources, see/// [`EventQueue::blocking_dispatch()`] for a simpler mechanism./// Do a roundtrip to the server/// This method will block until the Wayland server has processed and answered all your/// preceding requests. This is notably useful during the initial setup of an app, to wait for/// the initial state from the server./// See [`EventQueue::roundtrip()`] for a version that includes the dispatching of the event queue./// Retrieve the protocol error that occured on the connection if any/// If this method returns [`Some`], it means your Wayland connection is already dead./// Send a request associated with the provided object/// This is a low-level interface used by the code generated by `wayland-scanner`, you will likely/// instead use the methods of the types representing each interface, or the [`Proxy::send_request()`] and/// [`Proxy::send_constructor()`]./// Get the protocol information related to given object ID/// Get the object data for a given object ID/// This is a low-level interface used by the code generated by `wayland-scanner`, a higher-level/// interface for manipulating the user-data assocated to [`Dispatch`][crate::Dispatch] implementations/// is given as [`Proxy::data()`]. Also see [`Proxy::object_data()`]./// The wayland library could not be loaded.NoCompositor/// Could not find wayland compositorInvalidFd/// `WAYLAND_SOCKET` was set but contained garbage/// An error when trying to establish a Wayland connection./// Provides fd from [`Backend::poll_fd()`] for polling./*
    wl_callback object data for wl_display.sync
*/UserData/// Called when an event from the server is processed/// This method contains your logic for processing events, which can vary wildly from an object to the/// other. You are given as argument:/// - a proxy representing the object that received this event/// - the event itself as the [`Proxy::Event`] enum (which you'll need to match against)/// - a reference to the `UserData` that was associated with that object on creation/// - a reference to the [`Connection`] in case you need to access it/// - a reference to a [`QueueHandle`] associated with the [`EventQueue`] currently processing events, in///   case you need to create new objects that you want associated to the same [`EventQueue`]./// Method used to initialize the user-data of objects created by events/// If the interface does not have any such event, you can ignore it. If not, the/// [`event_created_child!()`] macro is provided for overriding it./// [`event_created_child!()`]: crate::event_created_child!()/// A trait for handlers of proxies' events delivered to an [`EventQueue`]./// ## General usage/// You need to implement this trait on your `State` for every type of Wayland object that will be processed/// by the [`EventQueue`] working with your `State`./// You can have different implementations of the trait for the same interface but different `UserData` type./// This way the events for a given object will be processed by the adequate implementation depending on/// which `UserData` was assigned to it at creation./// The way this trait works is that the [`Dispatch::event()`] method will be invoked by the event queue for/// every event received by an object associated to this event queue. Your implementation can then match on/// the associated [`Proxy::Event`] enum and do any processing needed with that event./// In the rare case of an interface with *events* creating new objects (in the core protocol, the only/// instance of this is the `wl_data_device.data_offer` event), you'll need to implement the/// [`Dispatch::event_created_child()`] method. See the [`event_created_child!()`] macro/// for a simple way to do this./// ## Modularity/// To provide generic handlers for downstream usage, it is possible to make an implementation of the trait/// that is generic over the last type argument, as illustrated below. Users will then be able to/// automatically delegate their implementation to yours using the [`delegate_dispatch!()`] macro./// [`delegate_dispatch!()`]: crate::delegate_dispatch!()/// As a result, when your implementation is instantiated, the last type parameter `State` will be the state/// struct of the app using your generic implementation. You can put additional trait constraints on it to/// specify an interface between your module and downstream code, as illustrated in this example:/// # // Maintainers: If this example changes, please make sure you also carry those changes over to the delegate_dispatch macro./// use wayland_client::{protocol::wl_registry, Dispatch};/// /// The type we want to delegate to/// struct DelegateToMe;/// /// The user data relevant for your implementation./// /// When providing a delegate implementation, it is recommended to use your own type here, even if it is/// /// just a unit struct: using () would cause a risk of clashing with another such implementation./// struct MyUserData;/// // Now a generic implementation of Dispatch, we are generic over the last type argument instead of using/// // the default State=Self./// impl<State> Dispatch<wl_registry::WlRegistry, MyUserData, State> for DelegateToMe///     // State is the type which has delegated to this type, so it needs to have an impl of Dispatch itself///     State: Dispatch<wl_registry::WlRegistry, MyUserData>,///     // If your delegate type has some internal state, it'll need to access it, and you can///     // require it by adding custom trait bounds.///     // In this example, we just require an AsMut implementation///     State: AsMut<DelegateToMe>,///     fn event(///         state: &mut State,///         _proxy: &wl_registry::WlRegistry,///         _event: wl_registry::Event,///         _udata: &MyUserData,///         _conn: &wayland_client::Connection,///         _qhandle: &wayland_client::QueueHandle<State>,///         // Here the delegate may handle incoming events as it pleases.///         // For example, it retrives its state and does some processing with it///         let me: &mut DelegateToMe = state.as_mut();///         // do something with `me` .../// #       std::mem::drop(me) // use `me` to avoid a warning/// **Note:** Due to limitations in Rust's trait resolution algorithm, a type providing a generic/// implementation of [`Dispatch`] cannot be used directly as the dispatching state, as rustc/// currently fails to understand that it also provides `Dispatch<I, U, Self>` (assuming all other/// trait bounds are respected as well).// Must match `pat` to allow paths `wl_data_device::EVT_DONE_OPCODE` and expressions `0` to both work./// Macro used to override [`Dispatch::event_created_child()`]/// Use this macro inside the [`Dispatch`] implementation to override this method, to implement the/// initialization of the user data for event-created objects. The usage syntax is as follow:/// impl Dispatch<WlFoo, FooUserData> for MyState {///         &mut self,///         proxy: &WlFoo,///         event: FooEvent,///         data: &FooUserData,///         connhandle: &mut ConnectionHandle,///         qhandle: &QueueHandle<MyState>///     event_created_child!(MyState, WlFoo, [///     // there can be multiple lines if this interface has multiple object-creating event///         EVT_CREATE_BAR => (WlBar, BarUserData::new()),///     //  ~~~~~~~~~~~~~~     ~~~~~  ~~~~~~~~~~~~~~~~~~///     //    |                  |      |///     //    |                  |      +-- an expression whose evaluation produces the///     //    |                  |          user data value///     //    |                  +-- the type of the newly created object///     //    +-- the opcode of the event that creates a new object, constants for those are///     //        generated alongside the `WlFoo` type in the `wl_foo` moduleQueueCallbackQueueEvent/// An event queue/// This is an abstraction for handling event dispatching, that allows you to ensure/// access to some common state `&mut State` to your event handlers./// Event queues are created through [`Connection::new_event_queue()`]./// Upon creation, a wayland object is assigned to an event queue by passing the associated [`QueueHandle`]/// as argument to the method creating it. All events received by that object will be processed by that event/// queue, when [`dispatch_pending()`][Self::dispatch_pending()] or/// [`blocking_dispatch()`][Self::blocking_dispatch()] is invoked./// ### Single queue app/// If your app is simple enough that the only source of event to process is the Wayland socket and you only/// need a single event queue, your main loop can be as simple as this:/// use wayland_client::Connection;/// let connection = Connection::connect_to_env().unwrap();/// let mut event_queue = connection.new_event_queue();///  * Here your initial setup///  *//// # struct State {/// #     exit: bool/// # let mut state = State { exit: false };/// // And the main loop:/// while !state.exit {///     event_queue.blocking_dispatch(&mut state).unwrap();/// The [`blocking_dispatch()`][Self::blocking_dispatch()] call will wait (by putting the thread to sleep)/// until there are some events from the server that can be processed, and all your actual app logic can be/// done in the callbacks of the [`Dispatch`] implementations, and in the main `loop` after the/// [`blocking_dispatch()`][Self::blocking_dispatch()] call./// ### Multi-thread multi-queue app/// In a case where you app is multithreaded and you want to process events in multiple thread, a simple/// pattern is to have one [`EventQueue`] per thread processing Wayland events./// With this pattern, each thread can use [`EventQueue::blocking_dispatch()`]/// on its own event loop, and everything will "Just Work"./// ### Single-queue guest library/// If your code is some library code that will act on a Wayland connection shared by the main program, it is/// likely you should not trigger socket reads yourself and instead let the main app take care of it. In this/// case, to ensure your [`EventQueue`] still makes progress, you should regularly invoke/// [`EventQueue::dispatch_pending()`] which will process the events that were/// enqueued in the inner buffer of your [`EventQueue`] by the main app reading the socket./// ### Integrating the event queue with other sources of events/// If your program needs to monitor other sources of events alongside the Wayland socket using a monitoring/// system like `epoll`, you can integrate the Wayland socket into this system. This is done with the help/// of the [`EventQueue::prepare_read()`] method. You event loop will be a bit more/// explicit:/// # let connection = Connection::connect_to_env().unwrap();/// # let mut event_queue = connection.new_event_queue();/// # let mut state = ();///     // flush the outgoing buffers to ensure that the server does receive the messages///     // you've sent///     event_queue.flush().unwrap();///     // (this step is only relevant if other threads might be reading the socket as well)///     // make sure you don't have any pending events if the event queue that might have been///     // enqueued by other threads reading the socket///     event_queue.dispatch_pending(&mut state).unwrap();///     // This puts in place some internal synchronization to prepare for the fact that///     // you're going to wait for events on the socket and read them, in case other threads///     // are doing the same thing///     let read_guard = event_queue.prepare_read().unwrap();///     /*///      * At this point you can invoke epoll(..) to wait for readiness on the multiple FD you///      * are working with, and read_guard.connection_fd() will give you the FD to wait on for///      * the Wayland connection///      *//// # let wayland_socket_ready = true;///     if wayland_socket_ready {///         // If epoll notified readiness of the Wayland socket, you can now proceed to the read///         read_guard.read().unwrap();///         // And now, you must invoke dispatch_pending() to actually process the events///         event_queue.dispatch_pending(&mut state).unwrap();///         // otherwise, some of your other FD are ready, but you didn't receive Wayland events,///         // you can drop the guard to cancel the read preparation///         std::mem::drop(read_guard);///      * There you process all relevant events from your other event sourcesfreeze_countEventQueueInnerenqueue_event/// Provides fd from [`Backend::poll_fd`] for polling./// Get a [`QueueHandle`] for this event queue/// Dispatch pending events/// Events are accumulated in the event queue internal buffer when the Wayland socket is read using/// the read APIs on [`Connection`], or when reading is done from an other thread./// This method will dispatch all such pending events by sequentially invoking their associated handlers:/// the [`Dispatch`] implementations on the provided `&mut D`./// Note: this may block if another thread has frozen the queue.blocking_dispatch/// Block waiting for events and dispatch them/// This method is similar to [`dispatch_pending()`][Self::dispatch_pending], but if there are no/// pending events it will also flush the connection and block waiting for the Wayland server to send an/// A simple app event loop can consist of invoking this method in a loop./// Synchronous roundtrip/// This function will cause a synchronous round trip with the wayland server. This function will block/// until all requests in the queue are sent and processed by the server./// This function may be useful during initial setup of your app. This function may also be useful/// where you need to guarantee all requests prior to calling this function are completed./// This is needed if you plan to wait on readiness of the Wayland socket using an event/// loop. See the [`EventQueue`] and [`ReadEventsGuard`] docs for details. Once the events are received,/// you'll then need to dispatch them from the event queue using/// [`EventQueue::dispatch_pending()`]./// If this method returns [`None`], you should invoke ['dispatch_pending()`][Self::dispatch_pending]/// before trying to invoke it again./// [`blocking_dispatch()`][Self::blocking_dispatch()] for a simpler mechanism./// This method is identical to [`Connection::prepare_read()`]./// This needs to be done regularly to ensure the server receives all your requests./// /// This method is identical to [`Connection::flush()`].dispatching_implpoll_dispatch_pending/// Attempt to dispatch events from this queue, registering the current task for wakeup if no/// events are pending./// This method is similar to [`dispatch_pending()`][Self::dispatch_pending]; it will not/// perform reads on the Wayland socket.  Reads on the socket by other tasks or threads will/// cause the current task to wake up if events are pending on this queue./// use futures_channel::mpsc::Receiver;/// use futures_util::future::{poll_fn,select};/// use futures_util::stream::StreamExt;/// use wayland_client::EventQueue;/// struct Data;/// enum AppEvent {///     SomethingHappened(u32),/// impl Data {///     fn handle(&mut self, event: AppEvent) {///         // actual event handling goes here/// // An async task that is spawned on an executor in order to handle events that need access/// // to a specific data object./// async fn run(data: &mut Data, mut wl_queue: EventQueue<Data>, mut app_queue: Receiver<AppEvent>)///     -> Result<(), Box<dyn std::error::Error>>///     use futures_util::future::Either;///         match select(///             poll_fn(|cx| wl_queue.poll_dispatch_pending(cx, data)),///             app_queue.next(),///         ).await {///             Either::Left((res, _)) => match res? {},///             Either::Right((Some(event), _)) => {///                 data.handle(event);///             Either::Right((None, _)) => return Ok(()),DispatchWaker/// A handle representing an [`EventQueue`], used to assign objects upon creation.QueueFreezeGuard/// A handle that temporarily pauses event processing on an [`EventQueue`].make_data/// Create an object data associated with this event queue/// This creates an implementation of [`ObjectData`] fitting for direct use with `wayland-backend` APIs/// that forwards all events to the event queue associated with this token, integrating the object into/// the [`Dispatch`]-based logic of `wayland-client`./// Temporarily block processing on this queue./// This will cause the associated queue to block (or return `NotReady` to poll) until all/// [`QueueFreezeGuard`]s associated with the queue are dropped.queue_callback/// The user data associated with this objectQueueProxyData/// The [`ObjectData`] implementation used by Wayland proxies, integrating with [`Dispatch`]/// A helper macro which delegates a set of [`Dispatch`] implementations for proxies to some other type which/// provides a generic [`Dispatch`] implementation./// This macro allows more easily delegating smaller parts of the protocol an application may wish to handle/// in a modular fashion./// For example, say you want to delegate events for [`WlRegistry`][crate::protocol::wl_registry::WlRegistry]/// to the struct `DelegateToMe` for the [`Dispatch`] documentation example./// use wayland_client::{delegate_dispatch, protocol::wl_registry};/// # use wayland_client::Dispatch;/// # struct DelegateToMe;/// # struct MyUserData;/// # impl<State> Dispatch<wl_registry::WlRegistry, MyUserData, State> for DelegateToMe/// #     State: Dispatch<wl_registry::WlRegistry, MyUserData> + AsMut<DelegateToMe>,/// #     fn event(/// #         _state: &mut State,/// #         _proxy: &wl_registry::WlRegistry,/// #         _event: wl_registry::Event,/// #         _udata: &MyUserData,/// #         _conn: &wayland_client::Connection,/// #         _qhandle: &wayland_client::QueueHandle<State>,/// #     ) {/// // ExampleApp is the type events will be dispatched to./// /// The application state///     /// The delegate for handling wl_registry events.///     delegate: DelegateToMe,/// // Use delegate_dispatch to implement Dispatch<wl_registry::WlRegistry, MyUserData> for ExampleApp/// delegate_dispatch!(ExampleApp: [wl_registry::WlRegistry: MyUserData] => DelegateToMe);/// // DelegateToMe requires that ExampleApp implements AsMut<DelegateToMe>, so we provide the/// // trait implementation./// impl AsMut<DelegateToMe> for ExampleApp {///     fn as_mut(&mut self) -> &mut DelegateToMe {///         &mut self.delegate/// // To explain the macro above, you may read it as the following:/// // For ExampleApp, delegate WlRegistry to DelegateToMe./// // Assert ExampleApp can Dispatch events for wl_registry/// fn assert_is_registry_delegate<T>()///     T: Dispatch<wl_registry::WlRegistry, MyUserData>,/// assert_is_registry_delegate::<ExampleApp>();/// // This macro can also be applied to a generic type using the `@<>` syntax:/// struct GenericApp<T: Copy> {///     app_data: T,/// delegate_dispatch!(@<T: Copy> GenericApp<T>: [wl_registry::WlRegistry: MyUserData] => DelegateToMe);/// impl<T: Copy> AsMut<DelegateToMe> for GenericApp<T> {/// // Assert that the above setup applies to a concrete GenericApp type/// assert_is_registry_delegate::<GenericApp<u32>>();delegate_noop/// A helper macro which delegates a set of [`Dispatch`] implementations for proxies to a static handler./// This macro is useful to implement [`Dispatch`] for interfaces where events are unimportant to/// the current application and can be ignored./// use wayland_client::{delegate_noop, protocol::{wl_data_offer, wl_subcompositor}};/// // Ignore all events for this interface:/// delegate_noop!(ExampleApp: ignore wl_data_offer::WlDataOffer);/// // This interface should not emit events:/// delegate_noop!(ExampleApp: wl_subcompositor::WlSubcompositor);/// This last example will execute `unreachable!()` if the interface emits any events./*
 * Dispatch delegation helpers
 *//// Initialize a new event queue with its associated registry and retrieve the initial list of globals/// See [the module level documentation][self] for more./// A helper for global initialization./// Access the contents of the list of globals/// Binds a global, returning a new protocol object associated with the global./// The `version` specifies the range of versions that should be bound. This function will guarantee the/// version of the returned protocol object is the lower of the maximum requested version and the advertised/// If the lower bound of the `version` is less than the version advertised by the server, then/// [`BindError::UnsupportedVersion`] is returned./// ## Multi-instance/Device globals./// This function is not intended to be used with globals that have multiple instances such as `wl_output`/// and `wl_seat`. These types of globals need their own initialization mechanism because these/// multi-instance globals may be removed at runtime. To handle then, you should instead rely on the/// `Dispatch` implementation for `WlRegistry` of your `State`./// This function will panic if the maximum requested version is greater than the known maximum version of/// the interface. The known maximum version is determined by the code generated using wayland-scanner./// Returns the [`WlRegistry`][wl_registry] protocol object./// This may be used if more direct control when creating globals is needed./// The backend generated an error/// An invalid object id was acted upon./// An error that may occur when initializing the global list./// The requested version of the global is not supported./// The requested global was not found in the registry./// An error that occurs when a binding a global fails./// The name of the global./// This is an identifier used by the server to reference some specific global./// This describes what type of protocol object the global is./// The advertised version of the global./// This specifies the maximum version of the global that may be bound. This means any lower version of/// the global may be bound./// Description of a global./// A container representing the current contents of the list of globalswith_list/// Access the list of globals/// Your closure is invoked on the global list, and its return value is forwarded to the return value/// of this function. This allows you to process the list without making a copy.clone_list/// Get a copy of the contents of the list of globals.initial_roundtrip_done//! Helpers for handling the initialization of an app//! At the startup of your Wayland app, the initial step is generally to retrieve the list of globals//! advertized by the compositor from the registry. Using the [`Dispatch`] mechanism for this task can be//! very unpractical, this is why this module provides a special helper for handling the registry.//! The entry point of this helper is the [`registry_queue_init`] function. Given a reference to your//! [`Connection`] it will create an [`EventQueue`], retrieve the initial list of globals, and register a//! handler using your provided `Dispatch<WlRegistry,_>` implementation for handling dynamic registry events.//! use wayland_client::{//!     globals::{registry_queue_init, Global, GlobalListContents},//!     protocol::{wl_registry, wl_compositor},//! # use std::sync::Mutex;//! # struct State;//! // You need to provide a Dispatch<WlRegistry, GlobalListContents> impl for your app//! impl wayland_client::Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {//!     fn event(//!         state: &mut State,//!         proxy: &wl_registry::WlRegistry,//!         event: wl_registry::Event,//!         // This mutex contains an up-to-date list of the currently known globals//!         // including the one that was just added or destroyed//!         data: &GlobalListContents,//!         conn: &Connection,//!         qhandle: &QueueHandle<State>,//!         /* react to dynamic global events here *///! let conn = Connection::connect_to_env().unwrap();//! let (globals, queue) = registry_queue_init::<State>(&conn).unwrap();//! # impl wayland_client::Dispatch<wl_compositor::WlCompositor, ()> for State {//! #     fn event(//! #         state: &mut State,//! #         proxy: &wl_compositor::WlCompositor,//! #         event: wl_compositor::Event,//! #         data: &(),//! #         conn: &Connection,//! #         qhandle: &QueueHandle<State>,//! #     ) {}//! // now you can bind the globals you need for your app//! let compositor: wl_compositor::WlCompositor = globals.bind(&queue.handle(), 4..=5, ()).unwrap();/// Backend reexports__interfacestypes_nullwl_display_requests_sync_typeswl_display_requests_get_registry_typeswl_display_requestswl_display_eventswl_display_interfacewl_registry_requestswl_registry_eventswl_registry_interfacewl_callback_eventswl_callback_interfaceWL_COMPOSITOR_INTERFACEwl_compositor_requests_create_surface_typeswl_compositor_requests_create_region_typeswl_compositor_requestswl_compositor_interfaceWL_SHM_POOL_INTERFACEwl_shm_pool_requests_create_buffer_typeswl_shm_pool_requestswl_shm_pool_interfaceWL_SHM_INTERFACEwl_shm_requests_create_pool_typeswl_shm_requestswl_shm_eventswl_shm_interfaceWL_BUFFER_INTERFACEwl_buffer_requestswl_buffer_eventswl_buffer_interfaceWL_DATA_OFFER_INTERFACEwl_data_offer_requestswl_data_offer_eventswl_data_offer_interfaceWL_DATA_SOURCE_INTERFACEwl_data_source_requestswl_data_source_eventswl_data_source_interfaceWL_DATA_DEVICE_INTERFACEwl_data_device_requests_start_drag_typeswl_data_device_requests_set_selection_typeswl_data_device_requestswl_data_device_events_data_offer_typeswl_data_device_events_enter_typeswl_data_device_events_selection_typeswl_data_device_eventswl_data_device_interfaceWL_DATA_DEVICE_MANAGER_INTERFACEwl_data_device_manager_requests_create_data_source_typeswl_data_device_manager_requests_get_data_device_typeswl_data_device_manager_requestswl_data_device_manager_interfaceWL_SHELL_INTERFACEwl_shell_requests_get_shell_surface_typeswl_shell_requestswl_shell_interfaceWL_SHELL_SURFACE_INTERFACEwl_shell_surface_requests_move_typeswl_shell_surface_requests_resize_typeswl_shell_surface_requests_set_transient_typeswl_shell_surface_requests_set_fullscreen_typeswl_shell_surface_requests_set_popup_typeswl_shell_surface_requests_set_maximized_typeswl_shell_surface_requestswl_shell_surface_eventswl_shell_surface_interfaceWL_SURFACE_INTERFACEwl_surface_requests_attach_typeswl_surface_requests_frame_typeswl_surface_requests_set_opaque_region_typeswl_surface_requests_set_input_region_typeswl_surface_requestswl_surface_events_enter_typeswl_surface_events_leave_typeswl_surface_eventswl_surface_interfaceWL_SEAT_INTERFACEwl_seat_requests_get_pointer_typeswl_seat_requests_get_keyboard_typeswl_seat_requests_get_touch_typeswl_seat_requestswl_seat_eventswl_seat_interfaceWL_POINTER_INTERFACEwl_pointer_requests_set_cursor_typeswl_pointer_requestswl_pointer_events_enter_typeswl_pointer_events_leave_typeswl_pointer_eventswl_pointer_interfaceWL_KEYBOARD_INTERFACEwl_keyboard_requestswl_keyboard_events_enter_typeswl_keyboard_events_leave_typeswl_keyboard_eventswl_keyboard_interfaceWL_TOUCH_INTERFACEwl_touch_requestswl_touch_events_down_typeswl_touch_eventswl_touch_interfaceWL_OUTPUT_INTERFACEwl_output_requestswl_output_eventswl_output_interfaceWL_REGION_INTERFACEwl_region_requestswl_region_interfaceWL_SUBCOMPOSITOR_INTERFACEwl_subcompositor_requests_get_subsurface_typeswl_subcompositor_requestswl_subcompositor_interfaceWL_SUBSURFACE_INTERFACEwl_subsurface_requests_place_above_typeswl_subsurface_requests_place_below_typeswl_subsurface_requestswl_subsurface_interfaceWL_FIXES_INTERFACEwl_fixes_requests_destroy_registry_typeswl_fixes_requestswl_fixes_interfacegenerate_client_code"core global object\n\nThe core global object.  This is a special singleton object.  It\nis used for internal Wayland protocol features.""global error values\n\nThese errors are global and can be emitted in response to any\nserver request.""server couldn't find object""method doesn't exist on the specified interface or malformed request""server is out of memory""implementation error in compositor"r" The minimal object version supporting this request"REQ_SYNC_SINCEr" The wire opcode for this request"REQ_SYNC_OPCODEREQ_GET_REGISTRY_SINCEREQ_GET_REGISTRY_OPCODEr" The minimal object version supporting this event"EVT_ERROR_SINCEr" The wire opcode for this event"EVT_ERROR_OPCODEEVT_DELETE_ID_SINCEEVT_DELETE_ID_OPCODE"asynchronous roundtrip\n\nThe sync request asks the server to emit the 'done' event\non the returned wl_callback object.  Since requests are\nhandled in-order and events are delivered in-order, this can\nbe used as a barrier to ensure all previous requests and the\nresulting events have been handled.\n\nThe object returned by this request will be destroyed by the\ncompositor after the callback is fired and as such the client must not\nattempt to use it after that point.\n\nThe callback_data passed in the callback is undefined and should be ignored.""get global registry object\n\nThis request creates a registry object that allows the client\nto list and bind the global objects available from the\ncompositor.\n\nIt should be noted that the server side resources consumed in\nresponse to a get_registry request can only be released when the\nclient disconnects, not when the client side proxy is destroyed.\nTherefore, clients should invoke get_registry as infrequently as\npossible to avoid wasting memory."GetRegistry__phantom_lifetime"Get the opcode number of this message""fatal error event\n\nThe error event is sent out when a fatal (non-recoverable)\nerror has occurred.  The object_id argument is the object\nwhere the error occurred, most often in response to a request\nto that object.  The code identifies the error and is defined\nby the object interface.  As such, each interface defines its\nown set of error codes.  The message is a brief description\nof the error, for (debugging) convenience.""object where the error occurred""error code""error description""acknowledge object ID deletion\n\nThis event is used internally by the object ID management\nlogic. When a client deletes an object that it had created,\nthe server will send this event to acknowledge that it has\nseen the delete request. When the client receives this event,\nit will know that it can safely reuse the object ID.""deleted object ID"DeleteId"core global object\n\nThe core global object.  This is a special singleton object.  It\nis used for internal Wayland protocol features.\n\nSee also the [Event] enum for this interface."object_datasend_constructorfrom_idparse_eventwrite_requestget_registry"global registry object\n\nThe singleton global registry object.  The server has a number of\nglobal objects that are available to all clients.  These objects\ntypically represent an actual object in the server (for example,\nan input device) or they are singleton objects that provide\nextension functionality.\n\nWhen a client creates a registry object, the registry object\nwill emit a global event for each global currently in the\nregistry.  Globals come and go as a result of device or\nmonitor hotplugs, reconfiguration or other events, and the\nregistry will send out global and global_remove events to\nkeep the client up to date with the changes.  To mark the end\nof the initial burst of events, the client can use the\nwl_display.sync request immediately after calling\nwl_display.get_registry.\n\nA client can bind to a global object by using the bind\nrequest.  This creates a client-side handle that lets the object\nemit events to the client and lets the client invoke requests on\nthe object."REQ_BIND_SINCEREQ_BIND_OPCODEEVT_GLOBAL_SINCEEVT_GLOBAL_OPCODEEVT_GLOBAL_REMOVE_SINCEEVT_GLOBAL_REMOVE_OPCODE"bind an object to the display\n\nBinds a new, client-created object to the server using the\nspecified name as the identifier.""unique numeric name of the object""bounded object""announce global object\n\nNotify the client of global objects.\n\nThe event notifies the client that a global object with\nthe given name is now available, and it implements the\ngiven version of the given interface.""numeric name of the global object""interface implemented by the object""interface version""announce removal of global object\n\nNotify the client of removed global objects.\n\nThis event notifies the client that the global identified\nby name is no longer available.  If the client bound to\nthe global using the bind request, the client should now\ndestroy that object.\n\nThe object remains valid and requests to the object will be\nignored until the client destroys it, to avoid races between\nthe global going away and a client sending a request to it."GlobalRemove"global registry object\n\nThe singleton global registry object.  The server has a number of\nglobal objects that are available to all clients.  These objects\ntypically represent an actual object in the server (for example,\nan input device) or they are singleton objects that provide\nextension functionality.\n\nWhen a client creates a registry object, the registry object\nwill emit a global event for each global currently in the\nregistry.  Globals come and go as a result of device or\nmonitor hotplugs, reconfiguration or other events, and the\nregistry will send out global and global_remove events to\nkeep the client up to date with the changes.  To mark the end\nof the initial burst of events, the client can use the\nwl_display.sync request immediately after calling\nwl_display.get_registry.\n\nA client can bind to a global object by using the bind\nrequest.  This creates a client-side handle that lets the object\nemit events to the client and lets the client invoke requests on\nthe object.\n\nSee also the [Event] enum for this interface.""callback object\n\nClients can handle the 'done' event to get notified when\nthe related request is done.\n\nNote, because wl_callback objects are created from multiple independent\nfactory interfaces, the wl_callback interface is frozen at version 1."EVT_DONE_SINCEEVT_DONE_OPCODE"done event\n\nNotify the client when the related request is done.\n\nThis is a destructor, once received this object cannot be used any longer.""request-specific data for the callback""callback object\n\nClients can handle the 'done' event to get notified when\nthe related request is done.\n\nNote, because wl_callback objects are created from multiple independent\nfactory interfaces, the wl_callback interface is frozen at version 1.\n\nSee also the [Event] enum for this interface.""the compositor singleton\n\nA compositor.  This object is a singleton global.  The\ncompositor is in charge of combining the contents of multiple\nsurfaces into one displayable output."REQ_CREATE_SURFACE_SINCEREQ_CREATE_SURFACE_OPCODEREQ_CREATE_REGION_SINCEREQ_CREATE_REGION_OPCODE"create new surface\n\nAsk the compositor to create a new surface."CreateSurface"create new region\n\nAsk the compositor to create a new region."CreateRegion"the compositor singleton\n\nA compositor.  This object is a singleton global.  The\ncompositor is in charge of combining the contents of multiple\nsurfaces into one displayable output.\n\nThis interface has no events.""a shared memory pool\n\nThe wl_shm_pool object encapsulates a piece of memory shared\nbetween the compositor and client.  Through the wl_shm_pool\nobject, the client can allocate shared memory wl_buffer objects.\nAll objects created through the same pool share the same\nunderlying mapped memory. Reusing the mapped memory avoids the\nsetup/teardown overhead and is useful when interactively resizing\na surface or for many small buffers."REQ_CREATE_BUFFER_SINCEREQ_CREATE_BUFFER_OPCODEREQ_DESTROY_SINCEREQ_DESTROY_OPCODEREQ_RESIZE_SINCEREQ_RESIZE_OPCODE"create a buffer from the pool\n\nCreate a wl_buffer object from the pool.\n\nThe buffer is created offset bytes into the pool and has\nwidth and height as specified.  The stride argument specifies\nthe number of bytes from the beginning of one row to the beginning\nof the next.  The format is the pixel format of the buffer and\nmust be one of those advertised through the wl_shm.format event.\n\nA buffer will keep a reference to the pool it was created from\nso it is valid to destroy the pool immediately after creating\na buffer from it.""buffer byte offset within the pool""buffer width, in pixels""buffer height, in pixels""number of bytes from the beginning of one row to the beginning of the next row""buffer pixel format"CreateBuffer"destroy the pool\n\nDestroy the shared memory pool.\n\nThe mmapped memory will be released when all\nbuffers that have been created from this pool\nare gone.\n\nThis is a destructor, once sent this object cannot be used any longer.""change the size of the pool mapping\n\nThis request will cause the server to remap the backing memory\nfor the pool from the file descriptor passed when the pool was\ncreated, but using the new size.  This request can only be\nused to make the pool bigger.\n\nThis request only changes the amount of bytes that are mmapped\nby the server and does not touch the file corresponding to the\nfile descriptor passed at creation time. It is the client's\nresponsibility to ensure that the file is at least as big as\nthe new pool size.""new size of the pool, in bytes"Resize"a shared memory pool\n\nThe wl_shm_pool object encapsulates a piece of memory shared\nbetween the compositor and client.  Through the wl_shm_pool\nobject, the client can allocate shared memory wl_buffer objects.\nAll objects created through the same pool share the same\nunderlying mapped memory. Reusing the mapped memory avoids the\nsetup/teardown overhead and is useful when interactively resizing\na surface or for many small buffers.\n\nThis interface has no events.""destroy the pool\n\nDestroy the shared memory pool.\n\nThe mmapped memory will be released when all\nbuffers that have been created from this pool\nare gone.""shared memory support\n\nA singleton global object that provides support for shared\nmemory.\n\nClients can create wl_shm_pool objects using the create_pool\nrequest.\n\nOn binding the wl_shm object one or more format events\nare emitted to inform clients about the valid pixel formats\nthat can be used for buffers.""wl_shm error values\n\nThese errors can be emitted in response to wl_shm requests.""buffer format is not known""invalid size or stride during pool or buffer creation""mmapping the file descriptor failed""pixel formats\n\nThis describes the memory layout of an individual pixel.\n\nAll renderers should support argb8888 and xrgb8888 but any other\nformats are optional and may not be supported by the particular\nrenderer in use.\n\nThe drm format codes match the macros defined in drm_fourcc.h, except\nargb8888 and xrgb8888. The formats actually supported by the compositor\nwill be reported by the format event.\n\nFor all wl_shm formats and unless specified in another protocol\nextension, pre-multiplied alpha is used for pixel values.""32-bit ARGB format, [31:0] A:R:G:B 8:8:8:8 little endian""32-bit RGB format, [31:0] x:R:G:B 8:8:8:8 little endian""8-bit color index format, [7:0] C"538982467"8-bit RGB format, [7:0] R:G:B 3:3:2"943867730"8-bit BGR format, [7:0] B:G:R 2:3:3"944916290"16-bit xRGB format, [15:0] x:R:G:B 4:4:4:4 little endian"842093144"16-bit xBGR format, [15:0] x:B:G:R 4:4:4:4 little endian"842089048"16-bit RGBx format, [15:0] R:G:B:x 4:4:4:4 little endian"842094674"16-bit BGRx format, [15:0] B:G:R:x 4:4:4:4 little endian"842094658"16-bit ARGB format, [15:0] A:R:G:B 4:4:4:4 little endian"842093121"16-bit ABGR format, [15:0] A:B:G:R 4:4:4:4 little endian"842089025"16-bit RBGA format, [15:0] R:G:B:A 4:4:4:4 little endian"842088786"16-bit BGRA format, [15:0] B:G:R:A 4:4:4:4 little endian"842088770"16-bit xRGB format, [15:0] x:R:G:B 1:5:5:5 little endian"892424792"16-bit xBGR 1555 format, [15:0] x:B:G:R 1:5:5:5 little endian"892420696"16-bit RGBx 5551 format, [15:0] R:G:B:x 5:5:5:1 little endian"892426322"16-bit BGRx 5551 format, [15:0] B:G:R:x 5:5:5:1 little endian"892426306"16-bit ARGB 1555 format, [15:0] A:R:G:B 1:5:5:5 little endian"892424769"16-bit ABGR 1555 format, [15:0] A:B:G:R 1:5:5:5 little endian"892420673"16-bit RGBA 5551 format, [15:0] R:G:B:A 5:5:5:1 little endian"892420434"16-bit BGRA 5551 format, [15:0] B:G:R:A 5:5:5:1 little endian"892420418"16-bit RGB 565 format, [15:0] R:G:B 5:6:5 little endian"909199186"16-bit BGR 565 format, [15:0] B:G:R 5:6:5 little endian"909199170"24-bit RGB format, [23:0] R:G:B little endian"875710290"24-bit BGR format, [23:0] B:G:R little endian"875710274"32-bit xBGR format, [31:0] x:B:G:R 8:8:8:8 little endian"875709016"32-bit RGBx format, [31:0] R:G:B:x 8:8:8:8 little endian"875714642"32-bit BGRx format, [31:0] B:G:R:x 8:8:8:8 little endian"875714626"32-bit ABGR format, [31:0] A:B:G:R 8:8:8:8 little endian"875708993"32-bit RGBA format, [31:0] R:G:B:A 8:8:8:8 little endian"875708754"32-bit BGRA format, [31:0] B:G:R:A 8:8:8:8 little endian"875708738"32-bit xRGB format, [31:0] x:R:G:B 2:10:10:10 little endian"808669784"32-bit xBGR format, [31:0] x:B:G:R 2:10:10:10 little endian"808665688"32-bit RGBx format, [31:0] R:G:B:x 10:10:10:2 little endian"808671314"32-bit BGRx format, [31:0] B:G:R:x 10:10:10:2 little endian"808671298"32-bit ARGB format, [31:0] A:R:G:B 2:10:10:10 little endian"808669761"32-bit ABGR format, [31:0] A:B:G:R 2:10:10:10 little endian"808665665"32-bit RGBA format, [31:0] R:G:B:A 10:10:10:2 little endian"808665426"32-bit BGRA format, [31:0] B:G:R:A 10:10:10:2 little endian"808665410"packed YCbCr format, [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian"1448695129"packed YCbCr format, [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian"1431918169"packed YCbCr format, [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian"1498831189"packed YCbCr format, [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian"1498765654"packed AYCbCr format, [31:0] A:Y:Cb:Cr 8:8:8:8 little endian"1448433985"2 plane YCbCr Cr:Cb format, 2x2 subsampled Cr:Cb plane"842094158"2 plane YCbCr Cb:Cr format, 2x2 subsampled Cb:Cr plane"825382478"2 plane YCbCr Cr:Cb format, 2x1 subsampled Cr:Cb plane"909203022"2 plane YCbCr Cb:Cr format, 2x1 subsampled Cb:Cr plane"825644622"3 plane YCbCr format, 4x4 subsampled Cb (1) and Cr (2) planes"961959257"3 plane YCbCr format, 4x4 subsampled Cr (1) and Cb (2) planes"961893977"3 plane YCbCr format, 4x1 subsampled Cb (1) and Cr (2) planes"825316697"3 plane YCbCr format, 4x1 subsampled Cr (1) and Cb (2) planes"825316953"3 plane YCbCr format, 2x2 subsampled Cb (1) and Cr (2) planes"842093913"3 plane YCbCr format, 2x2 subsampled Cr (1) and Cb (2) planes"842094169"3 plane YCbCr format, 2x1 subsampled Cb (1) and Cr (2) planes"909202777"3 plane YCbCr format, 2x1 subsampled Cr (1) and Cb (2) planes"909203033"3 plane YCbCr format, non-subsampled Cb (1) and Cr (2) planes"875713881"3 plane YCbCr format, non-subsampled Cr (1) and Cb (2) planes"875714137"[7:0] R"538982482"[15:0] R little endian"540422482"[15:0] R:G 8:8 little endian"943212370"[15:0] G:R 8:8 little endian"943215175"[31:0] R:G 16:16 little endian"842221394"[31:0] G:R 16:16 little endian"842224199"[63:0] x:R:G:B 16:16:16:16 little endian"1211388504"[63:0] x:B:G:R 16:16:16:16 little endian"1211384408"[63:0] A:R:G:B 16:16:16:16 little endian"1211388481"[63:0] A:B:G:R 16:16:16:16 little endian"1211384385"[31:0] X:Y:Cb:Cr 8:8:8:8 little endian"1448434008"[23:0] Cr:Cb:Y 8:8:8 little endian"875713878"Y followed by U then V, 10:10:10. Non-linear modifier only"808670550"[63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 10:6:10:6:10:6:10:6 little endian per 2 Y pixels"808530521"[63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 12:4:12:4:12:4:12:4 little endian per 2 Y pixels"842084953"[63:0] Cr0:Y1:Cb0:Y0 16:16:16:16 little endian per 2 Y pixels"909193817"[31:0] A:Cr:Y:Cb 2:10:10:10 little endian"808531033"[63:0] A:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian"842085465"[63:0] A:Cr:Y:Cb 16:16:16:16 little endian"909194329"[31:0] X:Cr:Y:Cb 2:10:10:10 little endian"808670808"[63:0] X:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian"909334104Xvyu1216161616"[63:0] X:Cr:Y:Cb 16:16:16:16 little endian"942954072"[63:0] A3:A2:Y3:0:Cr0:0:Y2:0:A1:A0:Y1:0:Cb0:0:Y0:0 1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian"810299481"[63:0] X3:X2:Y3:0:Cr0:0:Y2:0:X1:X0:Y1:0:Cb0:0:Y0:0 1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian"810299480"[63:0] A3:A2:Y3:Cr0:Y2:A1:A0:Y1:Cb0:Y0 1:1:10:10:10:1:1:10:10:10 little endian"843853913"[63:0] X3:X2:Y3:Cr0:Y2:X1:X0:Y1:Cb0:Y0 1:1:10:10:10:1:1:10:10:10 little endian"843853912942691673Yuv4208bit808539481Yuv42010bit943805016Xrgb8888A8943800920Xbgr8888A8943806546Rgbx8888A8943806530Bgrx8888A8943798354Rgb888A8943798338Bgr888A8943797586Rgb565A8943797570Bgr565A8"non-subsampled Cr:Cb plane"875714126"non-subsampled Cb:Cr plane"842290766"2x1 subsampled Cr:Cb plane, 10 bit per channel"808530512"2x2 subsampled Cr:Cb plane 10 bits per channel"808530000"2x2 subsampled Cr:Cb plane 12 bits per channel"842084432"2x2 subsampled Cr:Cb plane 16 bits per channel"909193296"[63:0] A:x:B:x:G:x:R:x 10:6:10:6:10:6:10:6 little endian"808534593"2x2 subsampled Cr:Cb plane"892425806808531025825242705942953048Xrgb16161616942948952Xbgr16161616942953025Argb16161616942948929Abgr16161616"[7:0] C0:C1:C2:C3:C4:C5:C6:C7 1:1:1:1:1:1:1:1 eight pixels/byte"538980675"[7:0] C0:C1:C2:C3 2:2:2:2 four pixels/byte"538980931"[7:0] C0:C1 4:4 two pixels/byte"538981443"[7:0] D0:D1:D2:D3:D4:D5:D6:D7 1:1:1:1:1:1:1:1 eight pixels/byte"538980676"[7:0] D0:D1:D2:D3 2:2:2:2 four pixels/byte"538980932"[7:0] D0:D1 4:4 two pixels/byte"538981444"[7:0] D"538982468"[7:0] R0:R1:R2:R3:R4:R5:R6:R7 1:1:1:1:1:1:1:1 eight pixels/byte"538980690"[7:0] R0:R1:R2:R3 2:2:2:2 four pixels/byte"538980946"[7:0] R0:R1 4:4 two pixels/byte"538981458"[15:0] x:R 6:10 little endian"540029266"[15:0] x:R 4:12 little endian"540160338"[31:0] A:Cr:Cb:Y 8:8:8:8 little endian"1498764865Avuy8888"[31:0] X:Cr:Cb:Y 8:8:8:8 little endian"1498764888Xvuy8888"2x2 subsampled Cr:Cb plane 10 bits per channel packed"808661072P030REQ_CREATE_POOL_SINCEREQ_CREATE_POOL_OPCODEREQ_RELEASE_SINCEREQ_RELEASE_OPCODEEVT_FORMAT_SINCEEVT_FORMAT_OPCODE"create a shm pool\n\nCreate a new wl_shm_pool object.\n\nThe pool can be used to create shared memory based buffer\nobjects.  The server will mmap size bytes of the passed file\ndescriptor, to use as backing memory for the pool.""file descriptor for the pool""pool size, in bytes""release the shm object\n\nUsing this request a client can tell the server that it is not going to\nuse the shm object anymore.\n\nObjects created via this interface remain unaffected.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""pixel format description\n\nInforms the client about a valid pixel format that\ncan be used for buffers. Known formats include\nargb8888 and xrgb8888.""shared memory support\n\nA singleton global object that provides support for shared\nmemory.\n\nClients can create wl_shm_pool objects using the create_pool\nrequest.\n\nOn binding the wl_shm object one or more format events\nare emitted to inform clients about the valid pixel formats\nthat can be used for buffers.\n\nSee also the [Event] enum for this interface."create_pool"release the shm object\n\nUsing this request a client can tell the server that it is not going to\nuse the shm object anymore.\n\nObjects created via this interface remain unaffected.""content for a wl_surface\n\nA buffer provides the content for a wl_surface. Buffers are\ncreated through factory interfaces such as wl_shm, wp_linux_buffer_params\n(from the linux-dmabuf protocol extension) or similar. It has a width and\na height and can be attached to a wl_surface, but the mechanism by which a\nclient provides and updates the contents is defined by the buffer factory\ninterface.\n\nColor channels are assumed to be electrical rather than optical (in other\nwords, encoded with a transfer function) unless otherwise specified. If\nthe buffer uses a format that has an alpha channel, the alpha channel is\nassumed to be premultiplied into the electrical color channel values\n(after transfer function encoding) unless otherwise specified.\n\nNote, because wl_buffer objects are created from multiple independent\nfactory interfaces, the wl_buffer interface is frozen at version 1."EVT_RELEASE_SINCEEVT_RELEASE_OPCODE"destroy a buffer\n\nDestroy a buffer. If and how you need to release the backing\nstorage is defined by the buffer factory interface.\n\nFor possible side-effects to a surface, see wl_surface.attach.\n\nThis is a destructor, once sent this object cannot be used any longer.""compositor releases buffer\n\nSent when this wl_buffer is no longer used by the compositor.\n\nFor more information on when release events may or may not be sent,\nand what consequences it has, please see the description of\nwl_surface.attach.\n\nIf a client receives a release event before the frame callback\nrequested in the same wl_surface.commit that attaches this\nwl_buffer to a surface, then the client is immediately free to\nreuse the buffer and its backing storage, and does not need a\nsecond buffer for the next surface content update. Typically\nthis is possible, when the compositor maintains a copy of the\nwl_surface contents, e.g. as a GL texture. This is an important\noptimization for GL(ES) compositors with wl_shm clients.""content for a wl_surface\n\nA buffer provides the content for a wl_surface. Buffers are\ncreated through factory interfaces such as wl_shm, wp_linux_buffer_params\n(from the linux-dmabuf protocol extension) or similar. It has a width and\na height and can be attached to a wl_surface, but the mechanism by which a\nclient provides and updates the contents is defined by the buffer factory\ninterface.\n\nColor channels are assumed to be electrical rather than optical (in other\nwords, encoded with a transfer function) unless otherwise specified. If\nthe buffer uses a format that has an alpha channel, the alpha channel is\nassumed to be premultiplied into the electrical color channel values\n(after transfer function encoding) unless otherwise specified.\n\nNote, because wl_buffer objects are created from multiple independent\nfactory interfaces, the wl_buffer interface is frozen at version 1.\n\nSee also the [Event] enum for this interface.""destroy a buffer\n\nDestroy a buffer. If and how you need to release the backing\nstorage is defined by the buffer factory interface.\n\nFor possible side-effects to a surface, see wl_surface.attach.""offer to transfer data\n\nA wl_data_offer represents a piece of data offered for transfer\nby another client (the source client).  It is used by the\ncopy-and-paste and drag-and-drop mechanisms.  The offer\ndescribes the different mime types that the data can be\nconverted to and provides the mechanism for transferring the\ndata directly from the source client.""finish request was called untimely"InvalidFinish"action mask contains invalid values"InvalidActionMask"action argument has an invalid value"InvalidAction"offer doesn't accept this request"InvalidOfferREQ_ACCEPT_SINCEREQ_ACCEPT_OPCODEREQ_RECEIVE_SINCEREQ_RECEIVE_OPCODEREQ_FINISH_SINCEREQ_FINISH_OPCODEREQ_SET_ACTIONS_SINCEREQ_SET_ACTIONS_OPCODEEVT_OFFER_SINCEEVT_OFFER_OPCODEEVT_SOURCE_ACTIONS_SINCEEVT_SOURCE_ACTIONS_OPCODEEVT_ACTION_SINCEEVT_ACTION_OPCODE"accept one of the offered mime types\n\nIndicate that the client can accept the given mime type, or\nNULL for not accepted.\n\nFor objects of version 2 or older, this request is used by the\nclient to give feedback whether the client can receive the given\nmime type, or NULL if none is accepted; the feedback does not\ndetermine whether the drag-and-drop operation succeeds or not.\n\nFor objects of version 3 or newer, this request determines the\nfinal result of the drag-and-drop operation. If the end result\nis that no mime types were accepted, the drag-and-drop operation\nwill be cancelled and the corresponding drag source will receive\nwl_data_source.cancelled. Clients may still use this event in\nconjunction with wl_data_source.action for feedback.""serial number of the accept request""mime type accepted by the client""request that the data is transferred\n\nTo transfer the offered data, the client issues this request\nand indicates the mime type it wants to receive.  The transfer\nhappens through the passed file descriptor (typically created\nwith the pipe system call).  The source client writes the data\nin the mime type representation requested and then closes the\nfile descriptor.\n\nThe receiving client reads from the read end of the pipe until\nEOF and then closes its end, at which point the transfer is\ncomplete.\n\nThis request may happen multiple times for different mime types,\nboth before and after wl_data_device.drop. Drag-and-drop destination\nclients may preemptively fetch data or examine it more closely to\ndetermine acceptance.""mime type desired by receiver""file descriptor for data transfer""destroy data offer\n\nDestroy the data offer.\n\nThis is a destructor, once sent this object cannot be used any longer.""the offer will no longer be used\n\nNotifies the compositor that the drag destination successfully\nfinished the drag-and-drop operation.\n\nUpon receiving this request, the compositor will emit\nwl_data_source.dnd_finished on the drag source client.\n\nIt is a client error to perform other requests than\nwl_data_offer.destroy after this one. It is also an error to perform\nthis request after a NULL mime type has been set in\nwl_data_offer.accept or no action was received through\nwl_data_offer.action.\n\nIf wl_data_offer.finish request is received for a non drag and drop\noperation, the invalid_finish protocol error is raised.\n\nOnly available since version 3 of the interface""set the available/preferred drag-and-drop actions\n\nSets the actions that the destination side client supports for\nthis operation. This request may trigger the emission of\nwl_data_source.action and wl_data_offer.action events if the compositor\nneeds to change the selected action.\n\nThis request can be called multiple times throughout the\ndrag-and-drop operation, typically in response to wl_data_device.enter\nor wl_data_device.motion events.\n\nThis request determines the final result of the drag-and-drop\noperation. If the end result is that no action is accepted,\nthe drag source will receive wl_data_source.cancelled.\n\nThe dnd_actions argument must contain only values expressed in the\nwl_data_device_manager.dnd_actions enum, and the preferred_action\nargument must only contain one of those values set, otherwise it\nwill result in a protocol error.\n\nWhile managing an \"ask\" action, the destination drag-and-drop client\nmay perform further wl_data_offer.receive requests, and is expected\nto perform one last wl_data_offer.set_actions request with a preferred\naction other than \"ask\" (and optionally wl_data_offer.accept) before\nrequesting wl_data_offer.finish, in order to convey the action selected\nby the user. If the preferred action is not in the\nwl_data_offer.source_actions mask, an error will be raised.\n\nIf the \"ask\" action is dismissed (e.g. user cancellation), the client\nis expected to perform wl_data_offer.destroy right away.\n\nThis request can only be made on drag-and-drop offers, a protocol error\nwill be raised otherwise.\n\nOnly available since version 3 of the interface""actions supported by the destination client"dnd_actions"action preferred by the destination client"preferred_actionSetActions"advertise offered mime type\n\nSent immediately after creating the wl_data_offer object.  One\nevent per offered mime type.""offered mime type""notify the source-side available actions\n\nThis event indicates the actions offered by the data source. It\nwill be sent immediately after creating the wl_data_offer object,\nor anytime the source side changes its offered actions through\nwl_data_source.set_actions.\n\nOnly available since version 3 of the interface""actions offered by the data source"SourceActions"notify the selected action\n\nThis event indicates the action selected by the compositor after\nmatching the source/destination side actions. Only one action (or\nnone) will be offered here.\n\nThis event can be emitted multiple times during the drag-and-drop\noperation in response to destination side action changes through\nwl_data_offer.set_actions.\n\nThis event will no longer be emitted after wl_data_device.drop\nhappened on the drag-and-drop destination, the client must\nhonor the last action received, or the last preferred one set\nthrough wl_data_offer.set_actions when handling an \"ask\" action.\n\nCompositors may also change the selected action on the fly, mainly\nin response to keyboard modifier changes during the drag-and-drop\noperation.\n\nThe most recent action received is always the valid one. Prior to\nreceiving wl_data_device.drop, the chosen action may change (e.g.\ndue to keyboard modifiers being pressed). At the time of receiving\nwl_data_device.drop the drag-and-drop destination must honor the\nlast action received.\n\nAction changes may still happen after wl_data_device.drop,\nespecially on \"ask\" actions, where the drag-and-drop destination\nmay choose another action afterwards. Action changes happening\nat this stage are always the result of inter-client negotiation, the\ncompositor shall no longer be able to induce a different action.\n\nUpon \"ask\" actions, it is expected that the drag-and-drop destination\nmay potentially choose a different action and/or mime type,\nbased on wl_data_offer.source_actions and finally chosen by the\nuser (e.g. popping up a menu with the available options). The\nfinal wl_data_offer.set_actions and wl_data_offer.accept requests\nmust happen before the call to wl_data_offer.finish.\n\nOnly available since version 3 of the interface""action selected by the compositor"dnd_action"offer to transfer data\n\nA wl_data_offer represents a piece of data offered for transfer\nby another client (the source client).  It is used by the\ncopy-and-paste and drag-and-drop mechanisms.  The offer\ndescribes the different mime types that the data can be\nconverted to and provides the mechanism for transferring the\ndata directly from the source client.\n\nSee also the [Event] enum for this interface.""destroy data offer\n\nDestroy the data offer.""the offer will no longer be used\n\nNotifies the compositor that the drag destination successfully\nfinished the drag-and-drop operation.\n\nUpon receiving this request, the compositor will emit\nwl_data_source.dnd_finished on the drag source client.\n\nIt is a client error to perform other requests than\nwl_data_offer.destroy after this one. It is also an error to perform\nthis request after a NULL mime type has been set in\nwl_data_offer.accept or no action was received through\nwl_data_offer.action.\n\nIf wl_data_offer.finish request is received for a non drag and drop\noperation, the invalid_finish protocol error is raised.""set the available/preferred drag-and-drop actions\n\nSets the actions that the destination side client supports for\nthis operation. This request may trigger the emission of\nwl_data_source.action and wl_data_offer.action events if the compositor\nneeds to change the selected action.\n\nThis request can be called multiple times throughout the\ndrag-and-drop operation, typically in response to wl_data_device.enter\nor wl_data_device.motion events.\n\nThis request determines the final result of the drag-and-drop\noperation. If the end result is that no action is accepted,\nthe drag source will receive wl_data_source.cancelled.\n\nThe dnd_actions argument must contain only values expressed in the\nwl_data_device_manager.dnd_actions enum, and the preferred_action\nargument must only contain one of those values set, otherwise it\nwill result in a protocol error.\n\nWhile managing an \"ask\" action, the destination drag-and-drop client\nmay perform further wl_data_offer.receive requests, and is expected\nto perform one last wl_data_offer.set_actions request with a preferred\naction other than \"ask\" (and optionally wl_data_offer.accept) before\nrequesting wl_data_offer.finish, in order to convey the action selected\nby the user. If the preferred action is not in the\nwl_data_offer.source_actions mask, an error will be raised.\n\nIf the \"ask\" action is dismissed (e.g. user cancellation), the client\nis expected to perform wl_data_offer.destroy right away.\n\nThis request can only be made on drag-and-drop offers, a protocol error\nwill be raised otherwise.""offer to transfer data\n\nThe wl_data_source object is the source side of a wl_data_offer.\nIt is created by the source client in a data transfer and\nprovides a way to describe the offered data and a way to respond\nto requests to transfer the data.""source doesn't accept this request"InvalidSourceREQ_OFFER_SINCEREQ_OFFER_OPCODEEVT_TARGET_SINCEEVT_TARGET_OPCODEEVT_SEND_SINCEEVT_SEND_OPCODEEVT_CANCELLED_SINCEEVT_CANCELLED_OPCODEEVT_DND_DROP_PERFORMED_SINCEEVT_DND_DROP_PERFORMED_OPCODEEVT_DND_FINISHED_SINCEEVT_DND_FINISHED_OPCODE"add an offered mime type\n\nThis request adds a mime type to the set of mime types\nadvertised to targets.  Can be called several times to offer\nmultiple types.""mime type offered by the data source""destroy the data source\n\nDestroy the data source.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the available drag-and-drop actions\n\nSets the actions that the source side client supports for this\noperation. This request may trigger wl_data_source.action and\nwl_data_offer.action events if the compositor needs to change the\nselected action.\n\nThe dnd_actions argument must contain only values expressed in the\nwl_data_device_manager.dnd_actions enum, otherwise it will result\nin a protocol error.\n\nThis request must be made once only, and can only be made on sources\nused in drag-and-drop, so it must be performed before\nwl_data_device.start_drag. Attempting to use the source other than\nfor drag-and-drop will raise a protocol error.\n\nOnly available since version 3 of the interface""actions supported by the data source""a target accepts an offered mime type\n\nSent when a target accepts pointer_focus or motion events.  If\na target does not accept any of the offered types, type is NULL.\n\nUsed for feedback during drag-and-drop.""mime type accepted by the target""send the data\n\nRequest for data from the client.  Send the data as the\nspecified mime type over the passed file descriptor, then\nclose it.""mime type for the data""file descriptor for the data""selection was cancelled\n\nThis data source is no longer valid. There are several reasons why\nthis could happen:\n\n- The data source has been replaced by another data source.\n- The drag-and-drop operation was performed, but the drop destination\ndid not accept any of the mime types offered through\nwl_data_source.target.\n- The drag-and-drop operation was performed, but the drop destination\ndid not select any of the actions present in the mask offered through\nwl_data_source.action.\n- The drag-and-drop operation was performed but didn't happen over a\nsurface.\n- The compositor cancelled the drag-and-drop operation (e.g. compositor\ndependent timeouts to avoid stale drag-and-drop transfers).\n\nThe client should clean up and destroy this data source.\n\nFor objects of version 2 or older, wl_data_source.cancelled will\nonly be emitted if the data source was replaced by another data\nsource.""the drag-and-drop operation physically finished\n\nThe user performed the drop action. This event does not indicate\nacceptance, wl_data_source.cancelled may still be emitted afterwards\nif the drop destination does not accept any mime type.\n\nHowever, this event might however not be received if the compositor\ncancelled the drag-and-drop operation before this event could happen.\n\nNote that the data_source may still be used in the future and should\nnot be destroyed here.\n\nOnly available since version 3 of the interface"DndDropPerformed"the drag-and-drop operation concluded\n\nThe drop destination finished interoperating with this data\nsource, so the client is now free to destroy this data source and\nfree all associated data.\n\nIf the action used to perform the operation was \"move\", the\nsource can now delete the transferred data.\n\nOnly available since version 3 of the interface"DndFinished"notify the selected action\n\nThis event indicates the action selected by the compositor after\nmatching the source/destination side actions. Only one action (or\nnone) will be offered here.\n\nThis event can be emitted multiple times during the drag-and-drop\noperation, mainly in response to destination side changes through\nwl_data_offer.set_actions, and as the data device enters/leaves\nsurfaces.\n\nIt is only possible to receive this event after\nwl_data_source.dnd_drop_performed if the drag-and-drop operation\nended in an \"ask\" action, in which case the final wl_data_source.action\nevent will happen immediately before wl_data_source.dnd_finished.\n\nCompositors may also change the selected action on the fly, mainly\nin response to keyboard modifier changes during the drag-and-drop\noperation.\n\nThe most recent action received is always the valid one. The chosen\naction may change alongside negotiation (e.g. an \"ask\" action can turn\ninto a \"move\" operation), so the effects of the final action must\nalways be applied in wl_data_offer.dnd_finished.\n\nClients can trigger cursor surface changes from this point, so\nthey reflect the current action.\n\nOnly available since version 3 of the interface""offer to transfer data\n\nThe wl_data_source object is the source side of a wl_data_offer.\nIt is created by the source client in a data transfer and\nprovides a way to describe the offered data and a way to respond\nto requests to transfer the data.\n\nSee also the [Event] enum for this interface.""destroy the data source\n\nDestroy the data source.""set the available drag-and-drop actions\n\nSets the actions that the source side client supports for this\noperation. This request may trigger wl_data_source.action and\nwl_data_offer.action events if the compositor needs to change the\nselected action.\n\nThe dnd_actions argument must contain only values expressed in the\nwl_data_device_manager.dnd_actions enum, otherwise it will result\nin a protocol error.\n\nThis request must be made once only, and can only be made on sources\nused in drag-and-drop, so it must be performed before\nwl_data_device.start_drag. Attempting to use the source other than\nfor drag-and-drop will raise a protocol error.""data transfer device\n\nThere is one wl_data_device per seat which can be obtained\nfrom the global wl_data_device_manager singleton.\n\nA wl_data_device provides access to inter-client data transfer\nmechanisms such as copy-and-paste and drag-and-drop.""given wl_surface has another role""source has already been used"UsedSourceREQ_START_DRAG_SINCEREQ_START_DRAG_OPCODEREQ_SET_SELECTION_SINCEREQ_SET_SELECTION_OPCODEEVT_DATA_OFFER_SINCEEVT_DATA_OFFER_OPCODEEVT_ENTER_SINCEEVT_ENTER_OPCODEEVT_LEAVE_SINCEEVT_LEAVE_OPCODEEVT_MOTION_SINCEEVT_MOTION_OPCODEEVT_DROP_SINCEEVT_DROP_OPCODEEVT_SELECTION_SINCEEVT_SELECTION_OPCODE"start drag-and-drop operation\n\nThis request asks the compositor to start a drag-and-drop\noperation on behalf of the client.\n\nThe source argument is the data source that provides the data\nfor the eventual data transfer. If source is NULL, enter, leave\nand motion events are sent only to the client that initiated the\ndrag and the client is expected to handle the data passing\ninternally. If source is destroyed, the drag-and-drop session will be\ncancelled.\n\nThe origin surface is the surface where the drag originates and\nthe client must have an active implicit grab that matches the\nserial.\n\nThe icon surface is an optional (can be NULL) surface that\nprovides an icon to be moved around with the cursor.  Initially,\nthe top-left corner of the icon surface is placed at the cursor\nhotspot, but subsequent wl_surface.offset requests can move the\nrelative position. Attach requests must be confirmed with\nwl_surface.commit as usual. The icon surface is given the role of\na drag-and-drop icon. If the icon surface already has another role,\nit raises a protocol error.\n\nThe input region is ignored for wl_surfaces with the role of a\ndrag-and-drop icon.\n\nThe given source may not be used in any further set_selection or\nstart_drag requests. Attempting to reuse a previously-used source\nmay send a used_source error.""data source for the eventual transfer""surface where the drag originates""drag-and-drop icon surface""serial number of the implicit grab on the origin"StartDrag"copy data to the selection\n\nThis request asks the compositor to set the selection\nto the data from the source on behalf of the client.\n\nTo unset the selection, set the source to NULL.\n\nThe given source may not be used in any further set_selection or\nstart_drag requests. Attempting to reuse a previously-used source\nmay send a used_source error.""data source for the selection""serial number of the event that triggered this request"SetSelection"destroy data device\n\nThis request destroys the data device.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""introduce a new wl_data_offer\n\nThe data_offer event introduces a new wl_data_offer object,\nwhich will subsequently be used in either the\ndata_device.enter event (for drag-and-drop) or the\ndata_device.selection event (for selections).  Immediately\nfollowing the data_device.data_offer event, the new data_offer\nobject will send out data_offer.offer events to describe the\nmime types it offers.""the new data_offer object"DataOffer"initiate drag-and-drop session\n\nThis event is sent when an active drag-and-drop pointer enters\na surface owned by the client.  The position of the pointer at\nenter time is provided by the x and y arguments, in surface-local\ncoordinates.""serial number of the enter event""client surface entered""surface-local x coordinate""surface-local y coordinate""source data_offer object""end drag-and-drop session\n\nThis event is sent when the drag-and-drop pointer leaves the\nsurface and the session ends.  The client must destroy the\nwl_data_offer introduced at enter time at this point.""drag-and-drop session motion\n\nThis event is sent when the drag-and-drop pointer moves within\nthe currently focused surface. The new position of the pointer\nis provided by the x and y arguments, in surface-local\ncoordinates.""timestamp with millisecond granularity""end drag-and-drop session successfully\n\nThe event is sent when a drag-and-drop operation is ended\nbecause the implicit grab is removed.\n\nThe drag-and-drop destination is expected to honor the last action\nreceived through wl_data_offer.action, if the resulting action is\n\"copy\" or \"move\", the destination can still perform\nwl_data_offer.receive requests, and is expected to end all\ntransfers with a wl_data_offer.finish request.\n\nIf the resulting action is \"ask\", the action will not be considered\nfinal. The drag-and-drop destination is expected to perform one last\nwl_data_offer.set_actions request, or wl_data_offer.destroy in order\nto cancel the operation.""advertise new selection\n\nThe selection event is sent out to notify the client of a new\nwl_data_offer for the selection for this device.  The\ndata_device.data_offer and the data_offer.offer events are\nsent out immediately before this event to introduce the data\noffer object.  The selection event is sent to a client\nimmediately before receiving keyboard focus and when a new\nselection is set while the client has keyboard focus.  The\ndata_offer is valid until a new data_offer or NULL is received\nor until the client loses keyboard focus.  Switching surface with\nkeyboard focus within the same client doesn't mean a new selection\nwill be sent.  The client must destroy the previous selection\ndata_offer, if any, upon receiving this event.""selection data_offer object""data transfer device\n\nThere is one wl_data_device per seat which can be obtained\nfrom the global wl_data_device_manager singleton.\n\nA wl_data_device provides access to inter-client data transfer\nmechanisms such as copy-and-paste and drag-and-drop.\n\nSee also the [Event] enum for this interface.""destroy data device\n\nThis request destroys the data device.""data transfer interface\n\nThe wl_data_device_manager is a singleton global object that\nprovides access to inter-client data transfer mechanisms such as\ncopy-and-paste and drag-and-drop.  These mechanisms are tied to\na wl_seat and this interface lets a client get a wl_data_device\ncorresponding to a wl_seat.\n\nDepending on the version bound, the objects created from the bound\nwl_data_device_manager object will have different requirements for\nfunctioning properly. See wl_data_source.set_actions,\nwl_data_offer.accept and wl_data_offer.finish for details.""drag and drop actions\n\nThis is a bitmask of the available/preferred actions in a\ndrag-and-drop operation.\n\nIn the compositor, the selected action is a result of matching the\nactions offered by the source and destination sides.  \"action\" events\nwith a \"none\" action will be sent to both source and destination if\nthere is no match. All further checks will effectively happen on\n(source actions ∩ destination actions).\n\nIn addition, compositors may also pick different actions in\nreaction to key modifiers being pressed. One common design that\nis used in major toolkits (and the behavior recommended for\ncompositors) is:\n\n- If no modifiers are pressed, the first match (in bit order)\nwill be used.\n- Pressing Shift selects \"move\", if enabled in the mask.\n- Pressing Control selects \"copy\", if enabled in the mask.\n\nBehavior beyond that is considered implementation-dependent.\nCompositors may for example bind other modifiers (like Alt/Meta)\nor drags initiated with other buttons than BTN_LEFT to specific\nactions (e.g. \"ask\").""no action""copy action""move action""ask action"AskREQ_CREATE_DATA_SOURCE_SINCEREQ_CREATE_DATA_SOURCE_OPCODEREQ_GET_DATA_DEVICE_SINCEREQ_GET_DATA_DEVICE_OPCODE"create a new data source\n\nCreate a new data source."CreateDataSource"create a new data device\n\nCreate a new data device for a given seat.""seat associated with the data device"GetDataDevice"data transfer interface\n\nThe wl_data_device_manager is a singleton global object that\nprovides access to inter-client data transfer mechanisms such as\ncopy-and-paste and drag-and-drop.  These mechanisms are tied to\na wl_seat and this interface lets a client get a wl_data_device\ncorresponding to a wl_seat.\n\nDepending on the version bound, the objects created from the bound\nwl_data_device_manager object will have different requirements for\nfunctioning properly. See wl_data_source.set_actions,\nwl_data_offer.accept and wl_data_offer.finish for details.\n\nThis interface has no events.""create desktop-style surfaces\n\nThis interface is implemented by servers that provide\ndesktop-style user interfaces.\n\nIt allows clients to associate a wl_shell_surface with\na basic surface.\n\nNote! This protocol is deprecated and not intended for production use.\nFor desktop-style user interfaces, use xdg_shell. Compositors and clients\nshould not implement this interface."REQ_GET_SHELL_SURFACE_SINCEREQ_GET_SHELL_SURFACE_OPCODE"create a shell surface from a surface\n\nCreate a shell surface for an existing surface. This gives\nthe wl_surface the role of a shell surface. If the wl_surface\nalready has another role, it raises a protocol error.\n\nOnly one shell surface can be associated with a given surface.""surface to be given the shell surface role"GetShellSurface"create desktop-style surfaces\n\nThis interface is implemented by servers that provide\ndesktop-style user interfaces.\n\nIt allows clients to associate a wl_shell_surface with\na basic surface.\n\nNote! This protocol is deprecated and not intended for production use.\nFor desktop-style user interfaces, use xdg_shell. Compositors and clients\nshould not implement this interface.\n\nThis interface has no events."WlShellwl_shell_surfaceWlShellSurfaceget_shell_surfacewl_shell"desktop-style metadata interface\n\nAn interface that may be implemented by a wl_surface, for\nimplementations that provide a desktop-style user interface.\n\nIt provides requests to treat surfaces like toplevel, fullscreen\nor popup windows, move, resize or maximize them, associate\nmetadata like title and class, etc.\n\nOn the server side the object is automatically destroyed when\nthe related wl_surface is destroyed. On the client side,\nwl_shell_surface_destroy() must be called before destroying\nthe wl_surface object.""edge values for resizing\n\nThese values are used to indicate which edge of a surface\nis being dragged in a resize operation. The server may\nuse this information to adapt its behavior, e.g. choose\nan appropriate cursor image.""no edge""top edge""bottom edge""left edge""top and left edges""bottom and left edges""right edge""top and right edges""bottom and right edges""details of transient behaviour\n\nThese flags specify details of the expected behaviour\nof transient surfaces. Used in the set_transient request.""do not set keyboard focus""different method to set the surface fullscreen\n\nHints to indicate to the compositor how to deal with a conflict\nbetween the dimensions of the surface and the dimensions of the\noutput. The compositor is free to ignore this parameter."FullscreenMethod"no preference, apply default policy""scale, preserve the surface's aspect ratio and center on output""switch output mode to the smallest mode that can fit the surface, add black borders to compensate size mismatch""no upscaling, center on output and add black borders to compensate size mismatch"REQ_PONG_SINCEREQ_PONG_OPCODEREQ_MOVE_SINCEREQ_MOVE_OPCODEREQ_SET_TOPLEVEL_SINCEREQ_SET_TOPLEVEL_OPCODEREQ_SET_TRANSIENT_SINCEREQ_SET_TRANSIENT_OPCODEREQ_SET_FULLSCREEN_SINCEREQ_SET_FULLSCREEN_OPCODEREQ_SET_POPUP_SINCEREQ_SET_POPUP_OPCODEREQ_SET_MAXIMIZED_SINCEREQ_SET_MAXIMIZED_OPCODEREQ_SET_TITLE_SINCEREQ_SET_TITLE_OPCODEREQ_SET_CLASS_SINCEREQ_SET_CLASS_OPCODEEVT_PING_SINCEEVT_PING_OPCODEEVT_CONFIGURE_SINCEEVT_CONFIGURE_OPCODEEVT_POPUP_DONE_SINCEEVT_POPUP_DONE_OPCODE"respond to a ping event\n\nA client must respond to a ping event with a pong request or\nthe client may be deemed unresponsive.""serial number of the ping event""start an interactive move\n\nStart a pointer-driven move of the surface.\n\nThis request must be used in response to a button press event.\nThe server may ignore move requests depending on the state of\nthe surface (e.g. fullscreen or maximized).""seat whose pointer is used""serial number of the implicit grab on the pointer""start an interactive resize\n\nStart a pointer-driven resizing of the surface.\n\nThis request must be used in response to a button press event.\nThe server may ignore resize requests depending on the state of\nthe surface (e.g. fullscreen or maximized).""which edge or corner is being dragged""make the surface a toplevel surface\n\nMap the surface as a toplevel surface.\n\nA toplevel surface is not fullscreen, maximized or transient."SetToplevel"make the surface a transient surface\n\nMap the surface relative to an existing surface.\n\nThe x and y arguments specify the location of the upper left\ncorner of the surface relative to the upper left corner of the\nparent surface, in surface-local coordinates.\n\nThe flags argument controls details of the transient behaviour.""parent surface""transient surface behavior"SetTransient"make the surface a fullscreen surface\n\nMap the surface as a fullscreen surface.\n\nIf an output parameter is given then the surface will be made\nfullscreen on that output. If the client does not specify the\noutput then the compositor will apply its policy - usually\nchoosing the output on which the surface has the biggest surface\narea.\n\nThe client may specify a method to resolve a size conflict\nbetween the output size and the surface size - this is provided\nthrough the method parameter.\n\nThe framerate parameter is used only when the method is set\nto \"driver\", to indicate the preferred framerate. A value of 0\nindicates that the client does not care about framerate.  The\nframerate is specified in mHz, that is framerate of 60000 is 60Hz.\n\nA method of \"scale\" or \"driver\" implies a scaling operation of\nthe surface, either via a direct scaling operation or a change of\nthe output mode. This will override any kind of output scaling, so\nthat mapping a surface with a buffer size equal to the mode can\nfill the screen independent of buffer_scale.\n\nA method of \"fill\" means we don't scale up the buffer, however\nany output scale is applied. This means that you may run into\nan edge case where the application maps a buffer with the same\nsize of the output mode but buffer_scale 1 (thus making a\nsurface larger than the output). In this case it is allowed to\ndownscale the results to fit the screen.\n\nThe compositor must reply to this request with a configure event\nwith the dimensions for the output on which the surface will\nbe made fullscreen.""method for resolving size conflict""framerate in mHz""output on which the surface is to be fullscreen"SetFullscreen"make the surface a popup surface\n\nMap the surface as a popup.\n\nA popup surface is a transient surface with an added pointer\ngrab.\n\nAn existing implicit grab will be changed to owner-events mode,\nand the popup grab will continue after the implicit grab ends\n(i.e. releasing the mouse button does not cause the popup to\nbe unmapped).\n\nThe popup grab continues until the window is destroyed or a\nmouse button is pressed in any other client's window. A click\nin any of the client's surfaces is reported as normal, however,\nclicks in other clients' surfaces will be discarded and trigger\nthe callback.\n\nThe x and y arguments specify the location of the upper left\ncorner of the surface relative to the upper left corner of the\nparent surface, in surface-local coordinates."SetPopup"make the surface a maximized surface\n\nMap the surface as a maximized surface.\n\nIf an output parameter is given then the surface will be\nmaximized on that output. If the client does not specify the\noutput then the compositor will apply its policy - usually\nchoosing the output on which the surface has the biggest surface\narea.\n\nThe compositor will reply with a configure event telling\nthe expected new surface size. The operation is completed\non the next buffer attach to this surface.\n\nA maximized surface typically fills the entire output it is\nbound to, except for desktop elements such as panels. This is\nthe main difference between a maximized shell surface and a\nfullscreen shell surface.\n\nThe details depend on the compositor implementation.""output on which the surface is to be maximized"SetMaximized"set surface title\n\nSet a short title for the surface.\n\nThis string may be used to identify the surface in a task bar,\nwindow list, or other user interface elements provided by the\ncompositor.\n\nThe string must be encoded in UTF-8.""surface title"SetTitle"set surface class\n\nSet a class for the surface.\n\nThe surface class identifies the general class of applications\nto which the surface belongs. A common convention is to use the\nfile name (or the full path if it is a non-standard location) of\nthe application's .desktop file as the class.""surface class"class_SetClass"ping client\n\nPing a client to check if it is receiving events and sending\nrequests. A client is expected to reply with a pong request.""serial number of the ping""suggest resize\n\nThe configure event asks the client to resize its surface.\n\nThe size is a hint, in the sense that the client is free to\nignore it if it doesn't resize, pick a smaller size (to\nsatisfy aspect ratio or resize in steps of NxM pixels).\n\nThe edges parameter provides a hint about how the surface\nwas resized. The client may use this information to decide\nhow to adjust its content to the new size (e.g. a scrolling\narea might adjust its content position to leave the viewable\ncontent unmoved).\n\nThe client is free to dismiss all but the last configure\nevent it received.\n\nThe width and height arguments specify the size of the window\nin surface-local coordinates.""how the surface was resized""new width of the surface""new height of the surface""popup interaction is done\n\nThe popup_done event is sent out when a popup grab is broken,\nthat is, when the user clicks a surface that doesn't belong\nto the client owning the popup surface."PopupDone"desktop-style metadata interface\n\nAn interface that may be implemented by a wl_surface, for\nimplementations that provide a desktop-style user interface.\n\nIt provides requests to treat surfaces like toplevel, fullscreen\nor popup windows, move, resize or maximize them, associate\nmetadata like title and class, etc.\n\nOn the server side the object is automatically destroyed when\nthe related wl_surface is destroyed. On the client side,\nwl_shell_surface_destroy() must be called before destroying\nthe wl_surface object.\n\nSee also the [Event] enum for this interface."_moveset_toplevelset_transient"an onscreen surface\n\nA surface is a rectangular area that may be displayed on zero\nor more outputs, and shown any number of times at the compositor's\ndiscretion. They can present wl_buffers, receive user input, and\ndefine a local coordinate system.\n\nThe size of a surface (and relative positions on it) is described\nin surface-local coordinates, which may differ from the buffer\ncoordinates of the pixel content, in case a buffer_transform\nor a buffer_scale is used.\n\nA surface without a \"role\" is fairly useless: a compositor does\nnot know where, when or how to present it. The role is the\npurpose of a wl_surface. Examples of roles are a cursor for a\npointer (as set by wl_pointer.set_cursor), a drag icon\n(wl_data_device.start_drag), a sub-surface\n(wl_subcompositor.get_subsurface), and a window as defined by a\nshell protocol (e.g. wl_shell.get_shell_surface).\n\nA surface can have only one role at a time. Initially a\nwl_surface does not have a role. Once a wl_surface is given a\nrole, it is set permanently for the whole lifetime of the\nwl_surface object. Giving the current role again is allowed,\nunless explicitly forbidden by the relevant interface\nspecification.\n\nSurface roles are given by requests in other interfaces such as\nwl_pointer.set_cursor. The request should explicitly mention\nthat this request gives a role to a wl_surface. Often, this\nrequest also creates a new protocol object that represents the\nrole and adds additional functionality to wl_surface. When a\nclient wants to destroy a wl_surface, they must destroy this role\nobject before the wl_surface, otherwise a defunct_role_object error is\nsent.\n\nDestroying the role object does not remove the role from the\nwl_surface, but it may stop the wl_surface from \"playing the role\".\nFor instance, if a wl_subsurface object is destroyed, the wl_surface\nit was created for will be unmapped and forget its position and\nz-order. It is allowed to create a wl_subsurface for the same\nwl_surface again, but it is not allowed to use the wl_surface as\na cursor (cursor is a different role than sub-surface, and role\nswitching is not allowed).""wl_surface error values\n\nThese errors can be emitted in response to wl_surface requests.""buffer scale value is invalid"InvalidScale"buffer transform value is invalid"InvalidTransform"buffer size is invalid""buffer offset is invalid""surface was destroyed before its role object"DefunctRoleObjectREQ_ATTACH_SINCEREQ_ATTACH_OPCODEREQ_DAMAGE_SINCEREQ_DAMAGE_OPCODEREQ_FRAME_SINCEREQ_FRAME_OPCODEREQ_SET_OPAQUE_REGION_SINCEREQ_SET_OPAQUE_REGION_OPCODEREQ_SET_INPUT_REGION_SINCEREQ_SET_INPUT_REGION_OPCODEREQ_COMMIT_SINCEREQ_COMMIT_OPCODEREQ_SET_BUFFER_TRANSFORM_SINCEREQ_SET_BUFFER_TRANSFORM_OPCODEREQ_SET_BUFFER_SCALE_SINCEREQ_SET_BUFFER_SCALE_OPCODEREQ_DAMAGE_BUFFER_SINCEREQ_DAMAGE_BUFFER_OPCODEREQ_OFFSET_SINCEREQ_OFFSET_OPCODEEVT_PREFERRED_BUFFER_SCALE_SINCEEVT_PREFERRED_BUFFER_SCALE_OPCODEEVT_PREFERRED_BUFFER_TRANSFORM_SINCEEVT_PREFERRED_BUFFER_TRANSFORM_OPCODE"delete surface\n\nDeletes the surface and invalidates its object ID.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the surface contents\n\nSet a buffer as the content of this surface.\n\nThe new size of the surface is calculated based on the buffer\nsize transformed by the inverse buffer_transform and the\ninverse buffer_scale. This means that at commit time the supplied\nbuffer size must be an integer multiple of the buffer_scale. If\nthat's not the case, an invalid_size error is sent.\n\nThe x and y arguments specify the location of the new pending\nbuffer's upper left corner, relative to the current buffer's upper\nleft corner, in surface-local coordinates. In other words, the\nx and y, combined with the new surface size define in which\ndirections the surface's size changes. Setting anything other than 0\nas x and y arguments is discouraged, and should instead be replaced\nwith using the separate wl_surface.offset request.\n\nWhen the bound wl_surface version is 5 or higher, passing any\nnon-zero x or y is a protocol violation, and will result in an\n'invalid_offset' error being raised. The x and y arguments are ignored\nand do not change the pending state. To achieve equivalent semantics,\nuse wl_surface.offset.\n\nSurface contents are double-buffered state, see wl_surface.commit.\n\nThe initial surface contents are void; there is no content.\nwl_surface.attach assigns the given wl_buffer as the pending\nwl_buffer. wl_surface.commit makes the pending wl_buffer the new\nsurface contents, and the size of the surface becomes the size\ncalculated from the wl_buffer, as described above. After commit,\nthere is no pending buffer until the next attach.\n\nCommitting a pending wl_buffer allows the compositor to read the\npixels in the wl_buffer. The compositor may access the pixels at\nany time after the wl_surface.commit request. When the compositor\nwill not access the pixels anymore, it will send the\nwl_buffer.release event. Only after receiving wl_buffer.release,\nthe client may reuse the wl_buffer. A wl_buffer that has been\nattached and then replaced by another attach instead of committed\nwill not receive a release event, and is not used by the\ncompositor.\n\nIf a pending wl_buffer has been committed to more than one wl_surface,\nthe delivery of wl_buffer.release events becomes undefined. A well\nbehaved client should not rely on wl_buffer.release events in this\ncase. Alternatively, a client could create multiple wl_buffer objects\nfrom the same backing storage or use a protocol extension providing\nper-commit release notifications.\n\nDestroying the wl_buffer after wl_buffer.release does not change\nthe surface contents. Destroying the wl_buffer before wl_buffer.release\nis allowed as long as the underlying buffer storage isn't re-used (this\ncan happen e.g. on client process termination). However, if the client\ndestroys the wl_buffer before receiving the wl_buffer.release event and\nmutates the underlying buffer storage, the surface contents become\nundefined immediately.\n\nIf wl_surface.attach is sent with a NULL wl_buffer, the\nfollowing wl_surface.commit will remove the surface content.\n\nIf a pending wl_buffer has been destroyed, the result is not specified.\nMany compositors are known to remove the surface content on the following\nwl_surface.commit, but this behaviour is not universal. Clients seeking to\nmaximise compatibility should not destroy pending buffers and should\nensure that they explicitly remove content from surfaces, even after\ndestroying buffers.""buffer of surface contents"Attach"mark part of the surface damaged\n\nThis request is used to describe the regions where the pending\nbuffer is different from the current surface contents, and where\nthe surface therefore needs to be repainted. The compositor\nignores the parts of the damage that fall outside of the surface.\n\nDamage is double-buffered state, see wl_surface.commit.\n\nThe damage rectangle is specified in surface-local coordinates,\nwhere x and y specify the upper left corner of the damage rectangle.\n\nThe initial value for pending damage is empty: no damage.\nwl_surface.damage adds pending damage: the new pending damage\nis the union of old pending damage and the given rectangle.\n\nwl_surface.commit assigns pending damage as the current damage,\nand clears pending damage. The server will clear the current\ndamage as it repaints the surface.\n\nNote! New clients should not use this request. Instead damage can be\nposted with wl_surface.damage_buffer which uses buffer coordinates\ninstead of surface coordinates.""width of damage rectangle""height of damage rectangle""request a frame throttling hint\n\nRequest a notification when it is a good time to start drawing a new\nframe, by creating a frame callback. This is useful for throttling\nredrawing operations, and driving animations.\n\nWhen a client is animating on a wl_surface, it can use the 'frame'\nrequest to get notified when it is a good time to draw and commit the\nnext frame of animation. If the client commits an update earlier than\nthat, it is likely that some updates will not make it to the display,\nand the client is wasting resources by drawing too often.\n\nThe frame request will take effect on the next wl_surface.commit.\nThe notification will only be posted for one frame unless\nrequested again. For a wl_surface, the notifications are posted in\nthe order the frame requests were committed.\n\nThe server must send the notifications so that a client\nwill not send excessive updates, while still allowing\nthe highest possible update rate for clients that wait for the reply\nbefore drawing again. The server should give some time for the client\nto draw and commit after sending the frame callback events to let it\nhit the next output refresh.\n\nA server should avoid signaling the frame callbacks if the\nsurface is not visible in any way, e.g. the surface is off-screen,\nor completely obscured by other opaque surfaces.\n\nThe object returned by this request will be destroyed by the\ncompositor after the callback is fired and as such the client must not\nattempt to use it after that point.\n\nThe callback_data passed in the callback is the current time, in\nmilliseconds, with an undefined base.""set opaque region\n\nThis request sets the region of the surface that contains\nopaque content.\n\nThe opaque region is an optimization hint for the compositor\nthat lets it optimize the redrawing of content behind opaque\nregions.  Setting an opaque region is not required for correct\nbehaviour, but marking transparent content as opaque will result\nin repaint artifacts.\n\nThe opaque region is specified in surface-local coordinates.\n\nThe compositor ignores the parts of the opaque region that fall\noutside of the surface.\n\nOpaque region is double-buffered state, see wl_surface.commit.\n\nwl_surface.set_opaque_region changes the pending opaque region.\nwl_surface.commit copies the pending region to the current region.\nOtherwise, the pending and current regions are never changed.\n\nThe initial value for an opaque region is empty. Setting the pending\nopaque region has copy semantics, and the wl_region object can be\ndestroyed immediately. A NULL wl_region causes the pending opaque\nregion to be set to empty.""opaque region of the surface"SetOpaqueRegion"set input region\n\nThis request sets the region of the surface that can receive\npointer and touch events.\n\nInput events happening outside of this region will try the next\nsurface in the server surface stack. The compositor ignores the\nparts of the input region that fall outside of the surface.\n\nThe input region is specified in surface-local coordinates.\n\nInput region is double-buffered state, see wl_surface.commit.\n\nwl_surface.set_input_region changes the pending input region.\nwl_surface.commit copies the pending region to the current region.\nOtherwise the pending and current regions are never changed,\nexcept cursor and icon surfaces are special cases, see\nwl_pointer.set_cursor and wl_data_device.start_drag.\n\nThe initial value for an input region is infinite. That means the\nwhole surface will accept input. Setting the pending input region\nhas copy semantics, and the wl_region object can be destroyed\nimmediately. A NULL wl_region causes the input region to be set\nto infinite.""input region of the surface"SetInputRegion"commit pending surface state\n\nSurface state (input, opaque, and damage regions, attached buffers,\netc.) is double-buffered. Protocol requests modify the pending state,\nas opposed to the active state in use by the compositor.\n\nA commit request atomically creates a content update from the pending\nstate, even if the pending state has not been touched. The content\nupdate is placed in a queue until it becomes active. After commit, the\nnew pending state is as documented for each related request.\n\nWhen the content update is applied, the wl_buffer is applied before all\nother state. This means that all coordinates in double-buffered state\nare relative to the newly attached wl_buffers, except for\nwl_surface.attach itself. If there is no newly attached wl_buffer, the\ncoordinates are relative to the previous content update.\n\nAll requests that need a commit to become effective are documented\nto affect double-buffered state.\n\nOther interfaces may add further double-buffered surface state.""sets the buffer transformation\n\nThis request sets the transformation that the client has already applied\nto the content of the buffer. The accepted values for the transform\nparameter are the values for wl_output.transform.\n\nThe compositor applies the inverse of this transformation whenever it\nuses the buffer contents.\n\nBuffer transform is double-buffered state, see wl_surface.commit.\n\nA newly created surface has its buffer transformation set to normal.\n\nwl_surface.set_buffer_transform changes the pending buffer\ntransformation. wl_surface.commit copies the pending buffer\ntransformation to the current one. Otherwise, the pending and current\nvalues are never changed.\n\nThe purpose of this request is to allow clients to render content\naccording to the output transform, thus permitting the compositor to\nuse certain optimizations even if the display is rotated. Using\nhardware overlays and scanning out a client buffer for fullscreen\nsurfaces are examples of such optimizations. Those optimizations are\nhighly dependent on the compositor implementation, so the use of this\nrequest should be considered on a case-by-case basis.\n\nNote that if the transform value includes 90 or 270 degree rotation,\nthe width of the buffer will become the surface height and the height\nof the buffer will become the surface width.\n\nIf transform is not one of the values from the\nwl_output.transform enum the invalid_transform protocol error\nis raised.\n\nOnly available since version 2 of the interface""transform for interpreting buffer contents"SetBufferTransform"sets the buffer scaling factor\n\nThis request sets an optional scaling factor on how the compositor\ninterprets the contents of the buffer attached to the window.\n\nBuffer scale is double-buffered state, see wl_surface.commit.\n\nA newly created surface has its buffer scale set to 1.\n\nwl_surface.set_buffer_scale changes the pending buffer scale.\nwl_surface.commit copies the pending buffer scale to the current one.\nOtherwise, the pending and current values are never changed.\n\nThe purpose of this request is to allow clients to supply higher\nresolution buffer data for use on high resolution outputs. It is\nintended that you pick the same buffer scale as the scale of the\noutput that the surface is displayed on. This means the compositor\ncan avoid scaling when rendering the surface on that output.\n\nNote that if the scale is larger than 1, then you have to attach\na buffer that is larger (by a factor of scale in each dimension)\nthan the desired surface size.\n\nIf scale is not greater than 0 the invalid_scale protocol error is\nraised.\n\nOnly available since version 3 of the interface""scale for interpreting buffer contents"SetBufferScale"mark part of the surface damaged using buffer coordinates\n\nThis request is used to describe the regions where the pending\nbuffer is different from the current surface contents, and where\nthe surface therefore needs to be repainted. The compositor\nignores the parts of the damage that fall outside of the surface.\n\nDamage is double-buffered state, see wl_surface.commit.\n\nThe damage rectangle is specified in buffer coordinates,\nwhere x and y specify the upper left corner of the damage rectangle.\n\nThe initial value for pending damage is empty: no damage.\nwl_surface.damage_buffer adds pending damage: the new pending\ndamage is the union of old pending damage and the given rectangle.\n\nwl_surface.commit assigns pending damage as the current damage,\nand clears pending damage. The server will clear the current\ndamage as it repaints the surface.\n\nThis request differs from wl_surface.damage in only one way - it\ntakes damage in buffer coordinates instead of surface-local\ncoordinates. While this generally is more intuitive than surface\ncoordinates, it is especially desirable when using wp_viewport\nor when a drawing library (like EGL) is unaware of buffer scale\nand buffer transform.\n\nNote: Because buffer transformation changes and damage requests may\nbe interleaved in the protocol stream, it is impossible to determine\nthe actual mapping between surface and buffer damage until\nwl_surface.commit time. Therefore, compositors wishing to take both\nkinds of damage into account will have to accumulate damage from the\ntwo requests separately and only transform from one to the other\nafter receiving the wl_surface.commit.\n\nOnly available since version 4 of the interface""buffer-local x coordinate""buffer-local y coordinate"DamageBuffer"set the surface contents offset\n\nThe x and y arguments specify the location of the new pending\nbuffer's upper left corner, relative to the current buffer's upper\nleft corner, in surface-local coordinates. In other words, the\nx and y, combined with the new surface size define in which\ndirections the surface's size changes.\n\nThe exact semantics of wl_surface.offset are role-specific. Refer to\nthe documentation of specific roles for more information.\n\nSurface location offset is double-buffered state, see\nwl_surface.commit.\n\nThis request is semantically equivalent to and the replaces the x and y\narguments in the wl_surface.attach request in wl_surface versions prior\nto 5. See wl_surface.attach for details.\n\nOnly available since version 5 of the interface""surface enters an output\n\nThis is emitted whenever a surface's creation, movement, or resizing\nresults in some part of it being within the scanout region of an\noutput.\n\nNote that a surface may be overlapping with zero or more outputs.""output entered by the surface""surface leaves an output\n\nThis is emitted whenever a surface's creation, movement, or resizing\nresults in it no longer having any part of it within the scanout region\nof an output.\n\nClients should not use the number of outputs the surface is on for frame\nthrottling purposes. The surface might be hidden even if no leave event\nhas been sent, and the compositor might expect new surface content\nupdates even if no enter event has been sent. The frame event should be\nused instead.""output left by the surface""preferred buffer scale for the surface\n\nThis event indicates the preferred buffer scale for this surface. It is\nsent whenever the compositor's preference changes.\n\nBefore receiving this event the preferred buffer scale for this surface\nis 1.\n\nIt is intended that scaling aware clients use this event to scale their\ncontent and use wl_surface.set_buffer_scale to indicate the scale they\nhave rendered with. This allows clients to supply a higher detail\nbuffer.\n\nThe compositor shall emit a scale value greater than 0.\n\nOnly available since version 6 of the interface""preferred scaling factor"PreferredBufferScale"preferred buffer transform for the surface\n\nThis event indicates the preferred buffer transform for this surface.\nIt is sent whenever the compositor's preference changes.\n\nBefore receiving this event the preferred buffer transform for this\nsurface is normal.\n\nApplying this transformation to the surface buffer contents and using\nwl_surface.set_buffer_transform might allow the compositor to use the\nsurface buffer more efficiently.\n\nOnly available since version 6 of the interface""preferred transform"PreferredBufferTransform"an onscreen surface\n\nA surface is a rectangular area that may be displayed on zero\nor more outputs, and shown any number of times at the compositor's\ndiscretion. They can present wl_buffers, receive user input, and\ndefine a local coordinate system.\n\nThe size of a surface (and relative positions on it) is described\nin surface-local coordinates, which may differ from the buffer\ncoordinates of the pixel content, in case a buffer_transform\nor a buffer_scale is used.\n\nA surface without a \"role\" is fairly useless: a compositor does\nnot know where, when or how to present it. The role is the\npurpose of a wl_surface. Examples of roles are a cursor for a\npointer (as set by wl_pointer.set_cursor), a drag icon\n(wl_data_device.start_drag), a sub-surface\n(wl_subcompositor.get_subsurface), and a window as defined by a\nshell protocol (e.g. wl_shell.get_shell_surface).\n\nA surface can have only one role at a time. Initially a\nwl_surface does not have a role. Once a wl_surface is given a\nrole, it is set permanently for the whole lifetime of the\nwl_surface object. Giving the current role again is allowed,\nunless explicitly forbidden by the relevant interface\nspecification.\n\nSurface roles are given by requests in other interfaces such as\nwl_pointer.set_cursor. The request should explicitly mention\nthat this request gives a role to a wl_surface. Often, this\nrequest also creates a new protocol object that represents the\nrole and adds additional functionality to wl_surface. When a\nclient wants to destroy a wl_surface, they must destroy this role\nobject before the wl_surface, otherwise a defunct_role_object error is\nsent.\n\nDestroying the role object does not remove the role from the\nwl_surface, but it may stop the wl_surface from \"playing the role\".\nFor instance, if a wl_subsurface object is destroyed, the wl_surface\nit was created for will be unmapped and forget its position and\nz-order. It is allowed to create a wl_subsurface for the same\nwl_surface again, but it is not allowed to use the wl_surface as\na cursor (cursor is a different role than sub-surface, and role\nswitching is not allowed).\n\nSee also the [Event] enum for this interface.""delete surface\n\nDeletes the surface and invalidates its object ID."damage"sets the buffer transformation\n\nThis request sets the transformation that the client has already applied\nto the content of the buffer. The accepted values for the transform\nparameter are the values for wl_output.transform.\n\nThe compositor applies the inverse of this transformation whenever it\nuses the buffer contents.\n\nBuffer transform is double-buffered state, see wl_surface.commit.\n\nA newly created surface has its buffer transformation set to normal.\n\nwl_surface.set_buffer_transform changes the pending buffer\ntransformation. wl_surface.commit copies the pending buffer\ntransformation to the current one. Otherwise, the pending and current\nvalues are never changed.\n\nThe purpose of this request is to allow clients to render content\naccording to the output transform, thus permitting the compositor to\nuse certain optimizations even if the display is rotated. Using\nhardware overlays and scanning out a client buffer for fullscreen\nsurfaces are examples of such optimizations. Those optimizations are\nhighly dependent on the compositor implementation, so the use of this\nrequest should be considered on a case-by-case basis.\n\nNote that if the transform value includes 90 or 270 degree rotation,\nthe width of the buffer will become the surface height and the height\nof the buffer will become the surface width.\n\nIf transform is not one of the values from the\nwl_output.transform enum the invalid_transform protocol error\nis raised.""sets the buffer scaling factor\n\nThis request sets an optional scaling factor on how the compositor\ninterprets the contents of the buffer attached to the window.\n\nBuffer scale is double-buffered state, see wl_surface.commit.\n\nA newly created surface has its buffer scale set to 1.\n\nwl_surface.set_buffer_scale changes the pending buffer scale.\nwl_surface.commit copies the pending buffer scale to the current one.\nOtherwise, the pending and current values are never changed.\n\nThe purpose of this request is to allow clients to supply higher\nresolution buffer data for use on high resolution outputs. It is\nintended that you pick the same buffer scale as the scale of the\noutput that the surface is displayed on. This means the compositor\ncan avoid scaling when rendering the surface on that output.\n\nNote that if the scale is larger than 1, then you have to attach\na buffer that is larger (by a factor of scale in each dimension)\nthan the desired surface size.\n\nIf scale is not greater than 0 the invalid_scale protocol error is\nraised.""mark part of the surface damaged using buffer coordinates\n\nThis request is used to describe the regions where the pending\nbuffer is different from the current surface contents, and where\nthe surface therefore needs to be repainted. The compositor\nignores the parts of the damage that fall outside of the surface.\n\nDamage is double-buffered state, see wl_surface.commit.\n\nThe damage rectangle is specified in buffer coordinates,\nwhere x and y specify the upper left corner of the damage rectangle.\n\nThe initial value for pending damage is empty: no damage.\nwl_surface.damage_buffer adds pending damage: the new pending\ndamage is the union of old pending damage and the given rectangle.\n\nwl_surface.commit assigns pending damage as the current damage,\nand clears pending damage. The server will clear the current\ndamage as it repaints the surface.\n\nThis request differs from wl_surface.damage in only one way - it\ntakes damage in buffer coordinates instead of surface-local\ncoordinates. While this generally is more intuitive than surface\ncoordinates, it is especially desirable when using wp_viewport\nor when a drawing library (like EGL) is unaware of buffer scale\nand buffer transform.\n\nNote: Because buffer transformation changes and damage requests may\nbe interleaved in the protocol stream, it is impossible to determine\nthe actual mapping between surface and buffer damage until\nwl_surface.commit time. Therefore, compositors wishing to take both\nkinds of damage into account will have to accumulate damage from the\ntwo requests separately and only transform from one to the other\nafter receiving the wl_surface.commit."damage_buffer"set the surface contents offset\n\nThe x and y arguments specify the location of the new pending\nbuffer's upper left corner, relative to the current buffer's upper\nleft corner, in surface-local coordinates. In other words, the\nx and y, combined with the new surface size define in which\ndirections the surface's size changes.\n\nThe exact semantics of wl_surface.offset are role-specific. Refer to\nthe documentation of specific roles for more information.\n\nSurface location offset is double-buffered state, see\nwl_surface.commit.\n\nThis request is semantically equivalent to and the replaces the x and y\narguments in the wl_surface.attach request in wl_surface versions prior\nto 5. See wl_surface.attach for details.""group of input devices\n\nA seat is a group of keyboards, pointer and touch devices. This\nobject is published as a global during start up, or when such a\ndevice is hot plugged.  A seat typically has a pointer and\nmaintains a keyboard focus and a pointer focus.""seat capability bitmask\n\nThis is a bitmask of capabilities this seat has; if a member is\nset, then it is present on the seat.""the seat has pointer devices""the seat has one or more keyboards""the seat has touch devices""wl_seat error values\n\nThese errors can be emitted in response to wl_seat requests.""get_pointer, get_keyboard or get_touch called on seat without the matching capability"MissingCapabilityREQ_GET_POINTER_SINCEREQ_GET_POINTER_OPCODEREQ_GET_KEYBOARD_SINCEREQ_GET_KEYBOARD_OPCODEREQ_GET_TOUCH_SINCEREQ_GET_TOUCH_OPCODEEVT_CAPABILITIES_SINCEEVT_CAPABILITIES_OPCODEEVT_NAME_SINCEEVT_NAME_OPCODE"return pointer object\n\nThe ID provided will be initialized to the wl_pointer interface\nfor this seat.\n\nThis request only takes effect if the seat has the pointer\ncapability, or has had the pointer capability in the past.\nIt is a protocol violation to issue this request on a seat that has\nnever had the pointer capability. The missing_capability error will\nbe sent in this case."GetPointer"return keyboard object\n\nThe ID provided will be initialized to the wl_keyboard interface\nfor this seat.\n\nThis request only takes effect if the seat has the keyboard\ncapability, or has had the keyboard capability in the past.\nIt is a protocol violation to issue this request on a seat that has\nnever had the keyboard capability. The missing_capability error will\nbe sent in this case."GetKeyboard"return touch object\n\nThe ID provided will be initialized to the wl_touch interface\nfor this seat.\n\nThis request only takes effect if the seat has the touch\ncapability, or has had the touch capability in the past.\nIt is a protocol violation to issue this request on a seat that has\nnever had the touch capability. The missing_capability error will\nbe sent in this case."GetTouch"release the seat object\n\nUsing this request a client can tell the server that it is not going to\nuse the seat object anymore.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 5 of the interface""seat capabilities changed\n\nThis is sent on binding to the seat global or whenever a seat gains\nor loses the pointer, keyboard or touch capabilities.\nThe argument is a capability enum containing the complete set of\ncapabilities this seat has.\n\nWhen the pointer capability is added, a client may create a\nwl_pointer object using the wl_seat.get_pointer request. This object\nwill receive pointer events until the capability is removed in the\nfuture.\n\nWhen the pointer capability is removed, a client should destroy the\nwl_pointer objects associated with the seat where the capability was\nremoved, using the wl_pointer.release request. No further pointer\nevents will be received on these objects.\n\nIn some compositors, if a seat regains the pointer capability and a\nclient has a previously obtained wl_pointer object of version 4 or\nless, that object may start sending pointer events again. This\nbehavior is considered a misinterpretation of the intended behavior\nand must not be relied upon by the client. wl_pointer objects of\nversion 5 or later must not send events if created before the most\nrecent event notifying the client of an added pointer capability.\n\nThe above behavior also applies to wl_keyboard and wl_touch with the\nkeyboard and touch capabilities, respectively.""capabilities of the seat""unique identifier for this seat\n\nIn a multi-seat configuration the seat name can be used by clients to\nhelp identify which physical devices the seat represents.\n\nThe seat name is a UTF-8 string with no convention defined for its\ncontents. Each name is unique among all wl_seat globals. The name is\nonly guaranteed to be unique for the current compositor instance.\n\nThe same seat names are used for all clients. Thus, the name can be\nshared across processes to refer to a specific wl_seat global.\n\nThe name event is sent after binding to the seat global, and should be sent\nbefore announcing capabilities. This event only sent once per seat object,\nand the name does not change over the lifetime of the wl_seat global.\n\nCompositors may re-use the same seat name if the wl_seat global is\ndestroyed and re-created later.\n\nOnly available since version 2 of the interface""seat identifier""group of input devices\n\nA seat is a group of keyboards, pointer and touch devices. This\nobject is published as a global during start up, or when such a\ndevice is hot plugged.  A seat typically has a pointer and\nmaintains a keyboard focus and a pointer focus.\n\nSee also the [Event] enum for this interface.""release the seat object\n\nUsing this request a client can tell the server that it is not going to\nuse the seat object anymore.""pointer input device\n\nThe wl_pointer interface represents one or more input devices,\nsuch as mice, which control the pointer location and pointer_focus\nof a seat.\n\nThe wl_pointer interface generates motion, enter and leave\nevents for the surfaces that the pointer is located over,\nand button and axis events for button presses, button releases\nand scrolling.""physical button state\n\nDescribes the physical state of a button that produced the button\nevent."ButtonState"the button is not pressed""the button is pressed""axis types\n\nDescribes the axis types of scroll events.""vertical axis"VerticalScroll"horizontal axis"HorizontalScroll"axis source types\n\nDescribes the source types for axis events. This indicates to the\nclient how an axis event was physically generated; a client may\nadjust the user interface accordingly. For example, scroll events\nfrom a \"finger\" source may be in a smooth coordinate space with\nkinetic scrolling whereas a \"wheel\" source may be in discrete steps\nof a number of lines.\n\nThe \"continuous\" axis source is a device generating events in a\ncontinuous coordinate space, but using something other than a\nfinger. One example for this source is button-based scrolling where\nthe vertical motion of a device is converted to scroll events while\na button is held down.\n\nThe \"wheel tilt\" axis source indicates that the actual device is a\nwheel but the scroll event is not caused by a rotation but a\n(usually sideways) tilt of the wheel.""a physical wheel rotation""finger on a touch surface"Finger"continuous coordinate space""a physical wheel tilt"WheelTilt"axis relative direction\n\nThis specifies the direction of the physical motion that caused a\nwl_pointer.axis event, relative to the wl_pointer.axis direction.""physical motion matches axis direction"Identical"physical motion is the inverse of the axis direction"InvertedREQ_SET_CURSOR_SINCEREQ_SET_CURSOR_OPCODEEVT_BUTTON_SINCEEVT_BUTTON_OPCODEEVT_AXIS_SINCEEVT_AXIS_OPCODEEVT_FRAME_SINCEEVT_FRAME_OPCODEEVT_AXIS_SOURCE_SINCEEVT_AXIS_SOURCE_OPCODEEVT_AXIS_STOP_SINCEEVT_AXIS_STOP_OPCODEEVT_AXIS_DISCRETE_SINCEEVT_AXIS_DISCRETE_OPCODEEVT_AXIS_VALUE120_SINCEEVT_AXIS_VALUE120_OPCODEEVT_AXIS_RELATIVE_DIRECTION_SINCEEVT_AXIS_RELATIVE_DIRECTION_OPCODE"set the pointer surface\n\nSet the pointer surface, i.e., the surface that contains the\npointer image (cursor). This request gives the surface the role\nof a cursor. If the surface already has another role, it raises\na protocol error.\n\nThe cursor actually changes only if the pointer\nfocus for this device is one of the requesting client's surfaces\nor the surface parameter is the current pointer surface. If\nthere was a previous surface set with this request it is\nreplaced. If surface is NULL, the pointer image is hidden.\n\nThe parameters hotspot_x and hotspot_y define the position of\nthe pointer surface relative to the pointer location. Its\ntop-left corner is always at (x, y) - (hotspot_x, hotspot_y),\nwhere (x, y) are the coordinates of the pointer location, in\nsurface-local coordinates.\n\nOn wl_surface.offset requests to the pointer surface, hotspot_x\nand hotspot_y are decremented by the x and y parameters\npassed to the request. The offset must be applied by\nwl_surface.commit as usual.\n\nThe hotspot can also be updated by passing the currently set\npointer surface to this request with new values for hotspot_x\nand hotspot_y.\n\nThe input region is ignored for wl_surfaces with the role of\na cursor. When the use as a cursor ends, the wl_surface is\nunmapped.\n\nThe serial parameter must match the latest wl_pointer.enter\nserial number sent to the client. Otherwise the request will be\nignored.""pointer surface"hotspot_xhotspot_ySetCursor"release the pointer object\n\nUsing this request a client can tell the server that it is not going to\nuse the pointer object anymore.\n\nThis request destroys the pointer proxy object, so clients must not call\nwl_pointer_destroy() after using this request.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""enter event\n\nNotification that this seat's pointer is focused on a certain\nsurface.\n\nWhen a seat's focus enters a surface, the pointer image\nis undefined and a client should respond to this event by setting\nan appropriate pointer image with the set_cursor request.""surface entered by the pointer"surface_xsurface_y"leave event\n\nNotification that this seat's pointer is no longer focused on\na certain surface.\n\nThe leave notification is sent before the enter notification\nfor the new focus.""serial number of the leave event""surface left by the pointer""pointer motion event\n\nNotification of pointer location change. The arguments\nsurface_x and surface_y are the location relative to the\nfocused surface.""pointer button event\n\nMouse button click and release notifications.\n\nThe location of the click is given by the last motion or\nenter event.\nThe time argument is a timestamp with millisecond\ngranularity, with an undefined base.\n\nThe button is a button code as defined in the Linux kernel's\nlinux/input-event-codes.h header file, e.g. BTN_LEFT.\n\nAny 16-bit button code value is reserved for future additions to the\nkernel's event code list. All other button codes above 0xFFFF are\ncurrently undefined but may be used in future versions of this\nprotocol.""serial number of the button event""button that produced the event""physical state of the button""axis event\n\nScroll and other axis notifications.\n\nFor scroll events (vertical and horizontal scroll axes), the\nvalue parameter is the length of a vector along the specified\naxis in a coordinate space identical to those of motion events,\nrepresenting a relative movement along the specified axis.\n\nFor devices that support movements non-parallel to axes multiple\naxis events will be emitted.\n\nWhen applicable, for example for touch pads, the server can\nchoose to emit scroll events where the motion vector is\nequivalent to a motion event vector.\n\nWhen applicable, a client can transform its content relative to the\nscroll distance.""axis type""length of vector in surface-local coordinate space""end of a pointer event sequence\n\nIndicates the end of a set of events that logically belong together.\nA client is expected to accumulate the data in all events within the\nframe before proceeding.\n\nAll wl_pointer events before a wl_pointer.frame event belong\nlogically together. For example, in a diagonal scroll motion the\ncompositor will send an optional wl_pointer.axis_source event, two\nwl_pointer.axis events (horizontal and vertical) and finally a\nwl_pointer.frame event. The client may use this information to\ncalculate a diagonal vector for scrolling.\n\nWhen multiple wl_pointer.axis events occur within the same frame,\nthe motion vector is the combined motion of all events.\nWhen a wl_pointer.axis and a wl_pointer.axis_stop event occur within\nthe same frame, this indicates that axis movement in one axis has\nstopped but continues in the other axis.\nWhen multiple wl_pointer.axis_stop events occur within the same\nframe, this indicates that these axes stopped in the same instance.\n\nA wl_pointer.frame event is sent for every logical event group,\neven if the group only contains a single wl_pointer event.\nSpecifically, a client may get a sequence: motion, frame, button,\nframe, axis, frame, axis_stop, frame.\n\nThe wl_pointer.enter and wl_pointer.leave events are logical events\ngenerated by the compositor and not the hardware. These events are\nalso grouped by a wl_pointer.frame. When a pointer moves from one\nsurface to another, a compositor should group the\nwl_pointer.leave event within the same wl_pointer.frame.\nHowever, a client must not rely on wl_pointer.leave and\nwl_pointer.enter being in the same wl_pointer.frame.\nCompositor-specific policies may require the wl_pointer.leave and\nwl_pointer.enter event being split across multiple wl_pointer.frame\ngroups.\n\nOnly available since version 5 of the interface""axis source event\n\nSource information for scroll and other axes.\n\nThis event does not occur on its own. It is sent before a\nwl_pointer.frame event and carries the source information for\nall events within that frame.\n\nThe source specifies how this event was generated. If the source is\nwl_pointer.axis_source.finger, a wl_pointer.axis_stop event will be\nsent when the user lifts the finger off the device.\n\nIf the source is wl_pointer.axis_source.wheel,\nwl_pointer.axis_source.wheel_tilt or\nwl_pointer.axis_source.continuous, a wl_pointer.axis_stop event may\nor may not be sent. Whether a compositor sends an axis_stop event\nfor these sources is hardware-specific and implementation-dependent;\nclients must not rely on receiving an axis_stop event for these\nscroll sources and should treat scroll sequences from these scroll\nsources as unterminated by default.\n\nThis event is optional. If the source is unknown for a particular\naxis event sequence, no event is sent.\nOnly one wl_pointer.axis_source event is permitted per frame.\n\nThe order of wl_pointer.axis_discrete and wl_pointer.axis_source is\nnot guaranteed.\n\nOnly available since version 5 of the interface""source of the axis event"axis_source"axis stop event\n\nStop notification for scroll and other axes.\n\nFor some wl_pointer.axis_source types, a wl_pointer.axis_stop event\nis sent to notify a client that the axis sequence has terminated.\nThis enables the client to implement kinetic scrolling.\nSee the wl_pointer.axis_source documentation for information on when\nthis event may be generated.\n\nAny wl_pointer.axis events with the same axis_source after this\nevent should be considered as the start of a new axis motion.\n\nThe timestamp is to be interpreted identical to the timestamp in the\nwl_pointer.axis event. The timestamp value may be the same as a\npreceding wl_pointer.axis event.\n\nOnly available since version 5 of the interface""the axis stopped with this event"AxisStop"axis click event\n\nDiscrete step information for scroll and other axes.\n\nThis event carries the axis value of the wl_pointer.axis event in\ndiscrete steps (e.g. mouse wheel clicks).\n\nThis event is deprecated with wl_pointer version 8 - this event is not\nsent to clients supporting version 8 or later.\n\nThis event does not occur on its own, it is coupled with a\nwl_pointer.axis event that represents this axis value on a\ncontinuous scale. The protocol guarantees that each axis_discrete\nevent is always followed by exactly one axis event with the same\naxis number within the same wl_pointer.frame. Note that the protocol\nallows for other events to occur between the axis_discrete and\nits coupled axis event, including other axis_discrete or axis\nevents. A wl_pointer.frame must not contain more than one axis_discrete\nevent per axis type.\n\nThis event is optional; continuous scrolling devices\nlike two-finger scrolling on touchpads do not have discrete\nsteps and do not generate this event.\n\nThe discrete value carries the directional information. e.g. a value\nof -2 is two steps towards the negative direction of this axis.\n\nThe axis number is identical to the axis number in the associated\naxis event.\n\nThe order of wl_pointer.axis_discrete and wl_pointer.axis_source is\nnot guaranteed.\n\nOnly available since version 5 of the interface""number of steps"AxisDiscrete"axis high-resolution scroll event\n\nDiscrete high-resolution scroll information.\n\nThis event carries high-resolution wheel scroll information,\nwith each multiple of 120 representing one logical scroll step\n(a wheel detent). For example, an axis_value120 of 30 is one quarter of\na logical scroll step in the positive direction, a value120 of\n-240 are two logical scroll steps in the negative direction within the\nsame hardware event.\nClients that rely on discrete scrolling should accumulate the\nvalue120 to multiples of 120 before processing the event.\n\nThe value120 must not be zero.\n\nThis event replaces the wl_pointer.axis_discrete event in clients\nsupporting wl_pointer version 8 or later.\n\nWhere a wl_pointer.axis_source event occurs in the same\nwl_pointer.frame, the axis source applies to this event.\n\nThe order of wl_pointer.axis_value120 and wl_pointer.axis_source is\nnot guaranteed.\n\nOnly available since version 8 of the interface""scroll distance as fraction of 120"AxisValue120"axis relative physical direction event\n\nRelative directional information of the entity causing the axis\nmotion.\n\nFor a wl_pointer.axis event, the wl_pointer.axis_relative_direction\nevent specifies the movement direction of the entity causing the\nwl_pointer.axis event. For example:\n- if a user's fingers on a touchpad move down and this\ncauses a wl_pointer.axis vertical_scroll down event, the physical\ndirection is 'identical'\n- if a user's fingers on a touchpad move down and this causes a\nwl_pointer.axis vertical_scroll up scroll up event ('natural\nscrolling'), the physical direction is 'inverted'.\n\nA client may use this information to adjust scroll motion of\ncomponents. Specifically, enabling natural scrolling causes the\ncontent to change direction compared to traditional scrolling.\nSome widgets like volume control sliders should usually match the\nphysical direction regardless of whether natural scrolling is\nactive. This event enables clients to match the scroll direction of\na widget to the physical direction.\n\nThis event does not occur on its own, it is coupled with a\nwl_pointer.axis event that represents this axis value.\nThe protocol guarantees that each axis_relative_direction event is\nalways followed by exactly one axis event with the same\naxis number within the same wl_pointer.frame. Note that the protocol\nallows for other events to occur between the axis_relative_direction\nand its coupled axis event.\n\nThe axis number is identical to the axis number in the associated\naxis event.\n\nThe order of wl_pointer.axis_relative_direction,\nwl_pointer.axis_discrete and wl_pointer.axis_source is not\nguaranteed.\n\nOnly available since version 9 of the interface""physical direction relative to axis motion""pointer input device\n\nThe wl_pointer interface represents one or more input devices,\nsuch as mice, which control the pointer location and pointer_focus\nof a seat.\n\nThe wl_pointer interface generates motion, enter and leave\nevents for the surfaces that the pointer is located over,\nand button and axis events for button presses, button releases\nand scrolling.\n\nSee also the [Event] enum for this interface.""release the pointer object\n\nUsing this request a client can tell the server that it is not going to\nuse the pointer object anymore.\n\nThis request destroys the pointer proxy object, so clients must not call\nwl_pointer_destroy() after using this request.""keyboard input device\n\nThe wl_keyboard interface represents one or more keyboards\nassociated with a seat.\n\nEach wl_keyboard has the following logical state:\n\n- an active surface (possibly null),\n- the keys currently logically down,\n- the active modifiers,\n- the active group.\n\nBy default, the active surface is null, the keys currently logically down\nare empty, the active modifiers and the active group are 0.""keyboard mapping format\n\nThis specifies the format of the keymap provided to the\nclient with the wl_keyboard.keymap event."KeymapFormat"no keymap; client must understand how to interpret the raw keycode"NoKeymap"libxkbcommon compatible, null-terminated string; to determine the xkb keycode, clients must add 8 to the key event keycode"XkbV1"physical key state\n\nDescribes the physical state of a key that produced the key event.\n\nSince version 10, the key can be in a \"repeated\" pseudo-state which\nmeans the same as \"pressed\", but is used to signal repetition in the\nkey event.\n\nThe key may only enter the repeated state after entering the pressed\nstate and before entering the released state. This event may be\ngenerated multiple times while the key is down.""key is not pressed""key is pressed""key was repeated"EVT_KEYMAP_SINCEEVT_KEYMAP_OPCODEEVT_KEY_SINCEEVT_KEY_OPCODEEVT_MODIFIERS_SINCEEVT_MODIFIERS_OPCODEEVT_REPEAT_INFO_SINCEEVT_REPEAT_INFO_OPCODE"release the keyboard object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""keyboard mapping\n\nThis event provides a file descriptor to the client which can be\nmemory-mapped in read-only mode to provide a keyboard mapping\ndescription.\n\nFrom version 7 onwards, the fd must be mapped with MAP_PRIVATE by\nthe recipient, as MAP_SHARED may fail.""keymap format""keymap file descriptor""keymap size, in bytes""enter event\n\nNotification that this seat's keyboard focus is on a certain\nsurface.\n\nThe compositor must send the wl_keyboard.modifiers event after this\nevent.\n\nIn the wl_keyboard logical state, this event sets the active surface to\nthe surface argument and the keys currently logically down to the keys\nin the keys argument. The compositor must not send this event if the\nwl_keyboard already had an active surface immediately before this event.\n\nClients should not use the list of pressed keys to emulate key-press\nevents. The order of keys in the list is unspecified.""surface gaining keyboard focus""the keys currently logically down""leave event\n\nNotification that this seat's keyboard focus is no longer on\na certain surface.\n\nThe leave notification is sent before the enter notification\nfor the new focus.\n\nIn the wl_keyboard logical state, this event resets all values to their\ndefaults. The compositor must not send this event if the active surface\nof the wl_keyboard was not equal to the surface argument immediately\nbefore this event.""surface that lost keyboard focus""key event\n\nA key was pressed or released.\nThe time argument is a timestamp with millisecond\ngranularity, with an undefined base.\n\nThe key is a platform-specific key code that can be interpreted\nby feeding it to the keyboard mapping (see the keymap event).\n\nIf this event produces a change in modifiers, then the resulting\nwl_keyboard.modifiers event must be sent after this event.\n\nIn the wl_keyboard logical state, this event adds the key to the keys\ncurrently logically down (if the state argument is pressed) or removes\nthe key from the keys currently logically down (if the state argument is\nreleased). The compositor must not send this event if the wl_keyboard\ndid not have an active surface immediately before this event. The\ncompositor must not send this event if state is pressed (resp. released)\nand the key was already logically down (resp. was not logically down)\nimmediately before this event.\n\nSince version 10, compositors may send key events with the \"repeated\"\nkey state when a wl_keyboard.repeat_info event with a rate argument of\n0 has been received. This allows the compositor to take over the\nresponsibility of key repetition.""serial number of the key event""key that produced the event""physical state of the key""modifier and group state\n\nNotifies clients that the modifier and/or group state has\nchanged, and it should update its local state.\n\nThe compositor may send this event without a surface of the client\nhaving keyboard focus, for example to tie modifier information to\npointer focus instead. If a modifier event with pressed modifiers is sent\nwithout a prior enter event, the client can assume the modifier state is\nvalid until it receives the next wl_keyboard.modifiers event. In order to\nreset the modifier state again, the compositor can send a\nwl_keyboard.modifiers event with no pressed modifiers.\n\nIn the wl_keyboard logical state, this event updates the modifiers and\ngroup.""serial number of the modifiers event""depressed modifiers"mods_depressed"latched modifiers"mods_latched"locked modifiers"mods_locked"keyboard layout""repeat rate and delay\n\nInforms the client about the keyboard's repeat rate and delay.\n\nThis event is sent as soon as the wl_keyboard object has been created,\nand is guaranteed to be received by the client before any key press\nevent.\n\nNegative values for either rate or delay are illegal. A rate of zero\nwill disable any repeating (regardless of the value of delay).\n\nThis event can be sent later on as well with a new value if necessary,\nso clients should continue listening for the event past the creation\nof wl_keyboard.\n\nOnly available since version 4 of the interface""the rate of repeating keys in characters per second""delay in milliseconds since key down until repeating starts""keyboard input device\n\nThe wl_keyboard interface represents one or more keyboards\nassociated with a seat.\n\nEach wl_keyboard has the following logical state:\n\n- an active surface (possibly null),\n- the keys currently logically down,\n- the active modifiers,\n- the active group.\n\nBy default, the active surface is null, the keys currently logically down\nare empty, the active modifiers and the active group are 0.\n\nSee also the [Event] enum for this interface.""release the keyboard object""touchscreen input device\n\nThe wl_touch interface represents a touchscreen\nassociated with a seat.\n\nTouch interactions can consist of one or more contacts.\nFor each contact, a series of events is generated, starting\nwith a down event, followed by zero or more motion events,\nand ending with an up event. Events relating to the same\ncontact point can be identified by the ID of the sequence."EVT_DOWN_SINCEEVT_DOWN_OPCODEEVT_UP_SINCEEVT_UP_OPCODEEVT_CANCEL_SINCEEVT_CANCEL_OPCODEEVT_SHAPE_SINCEEVT_SHAPE_OPCODEEVT_ORIENTATION_SINCEEVT_ORIENTATION_OPCODE"release the touch object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""touch down event and beginning of a touch sequence\n\nA new touch point has appeared on the surface. This touch point is\nassigned a unique ID. Future events from this touch point reference\nthis ID. The ID ceases to be valid after a touch up event and may be\nreused in the future.""serial number of the touch down event""surface touched""the unique ID of this touch point""end of a touch event sequence\n\nThe touch point has disappeared. No further events will be sent for\nthis touch point and the touch point's ID is released and may be\nreused in a future touch down event.""serial number of the touch up event""update of touch point coordinates\n\nA touch point has changed coordinates.""end of touch frame event\n\nIndicates the end of a set of events that logically belong together.\nA client is expected to accumulate the data in all events within the\nframe before proceeding.\n\nA wl_touch.frame terminates at least one event but otherwise no\nguarantee is provided about the set of events within a frame. A client\nmust assume that any state not updated in a frame is unchanged from the\npreviously known state.""touch session cancelled\n\nSent if the compositor decides the touch stream is a global\ngesture. No further events are sent to the clients from that\nparticular gesture. Touch cancellation applies to all touch points\ncurrently active on this client's surface. The client is\nresponsible for finalizing the touch points, future touch points on\nthis surface may reuse the touch point ID.\n\nNo frame event is required after the cancel event.""update shape of touch point\n\nSent when a touchpoint has changed its shape.\n\nThis event does not occur on its own. It is sent before a\nwl_touch.frame event and carries the new shape information for\nany previously reported, or new touch points of that frame.\n\nOther events describing the touch point such as wl_touch.down,\nwl_touch.motion or wl_touch.orientation may be sent within the\nsame wl_touch.frame. A client should treat these events as a single\nlogical touch point update. The order of wl_touch.shape,\nwl_touch.orientation and wl_touch.motion is not guaranteed.\nA wl_touch.down event is guaranteed to occur before the first\nwl_touch.shape event for this touch ID but both events may occur within\nthe same wl_touch.frame.\n\nA touchpoint shape is approximated by an ellipse through the major and\nminor axis length. The major axis length describes the longer diameter\nof the ellipse, while the minor axis length describes the shorter\ndiameter. Major and minor are orthogonal and both are specified in\nsurface-local coordinates. The center of the ellipse is always at the\ntouchpoint location as reported by wl_touch.down or wl_touch.move.\n\nThis event is only sent by the compositor if the touch device supports\nshape reports. The client has to make reasonable assumptions about the\nshape if it did not receive this event.\n\nOnly available since version 6 of the interface""length of the major axis in surface-local coordinates""length of the minor axis in surface-local coordinates""update orientation of touch point\n\nSent when a touchpoint has changed its orientation.\n\nThis event does not occur on its own. It is sent before a\nwl_touch.frame event and carries the new shape information for\nany previously reported, or new touch points of that frame.\n\nOther events describing the touch point such as wl_touch.down,\nwl_touch.motion or wl_touch.shape may be sent within the\nsame wl_touch.frame. A client should treat these events as a single\nlogical touch point update. The order of wl_touch.shape,\nwl_touch.orientation and wl_touch.motion is not guaranteed.\nA wl_touch.down event is guaranteed to occur before the first\nwl_touch.orientation event for this touch ID but both events may occur\nwithin the same wl_touch.frame.\n\nThe orientation describes the clockwise angle of a touchpoint's major\naxis to the positive surface y-axis and is normalized to the -180 to\n+180 degree range. The granularity of orientation depends on the touch\ndevice, some devices only support binary rotation values between 0 and\n90 degrees.\n\nThis event is only sent by the compositor if the touch device supports\norientation reports.\n\nOnly available since version 6 of the interface""angle between major axis and positive surface y-axis in degrees""touchscreen input device\n\nThe wl_touch interface represents a touchscreen\nassociated with a seat.\n\nTouch interactions can consist of one or more contacts.\nFor each contact, a series of events is generated, starting\nwith a down event, followed by zero or more motion events,\nand ending with an up event. Events relating to the same\ncontact point can be identified by the ID of the sequence.\n\nSee also the [Event] enum for this interface.""release the touch object""compositor output region\n\nAn output describes part of the compositor geometry.  The\ncompositor works in the 'compositor coordinate system' and an\noutput corresponds to a rectangular area in that space that is\nactually visible.  This typically corresponds to a monitor that\ndisplays part of the compositor space.  This object is published\nas global during start up, or when a monitor is hotplugged.""subpixel geometry information\n\nThis enumeration describes how the physical\npixels on an output are laid out.""unknown geometry""no geometry""horizontal RGB""horizontal BGR""vertical RGB""vertical BGR""transformation applied to buffer contents\n\nThis describes transformations that clients and compositors apply to\nbuffer contents.\n\nThe flipped values correspond to an initial flip around a\nvertical axis followed by rotation.\n\nThe purpose is mainly to allow clients to render accordingly and\ntell the compositor, so that for fullscreen surfaces, the\ncompositor will still be able to scan out directly from client\nsurfaces.""no transform""90 degrees counter-clockwise"_90"180 degrees counter-clockwise"_180"270 degrees counter-clockwise"_270"180 degree flip around a vertical axis"Flipped"flip and rotate 90 degrees counter-clockwise"Flipped90"flip and rotate 180 degrees counter-clockwise"Flipped180"flip and rotate 270 degrees counter-clockwise"Flipped270"mode information\n\nThese flags describe properties of an output mode.\nThey are used in the flags bitfield of the mode event.""indicates this is the current mode""indicates this is the preferred mode"PreferredEVT_GEOMETRY_SINCEEVT_GEOMETRY_OPCODEEVT_MODE_SINCEEVT_MODE_OPCODEEVT_SCALE_SINCEEVT_SCALE_OPCODEEVT_DESCRIPTION_SINCEEVT_DESCRIPTION_OPCODE"release the output object\n\nUsing this request a client can tell the server that it is not going to\nuse the output object anymore.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""properties of the output\n\nThe geometry event describes geometric properties of the output.\nThe event is sent when binding to the output object and whenever\nany of the properties change.\n\nThe physical size can be set to zero if it doesn't make sense for this\noutput (e.g. for projectors or virtual outputs).\n\nThe geometry event will be followed by a done event (starting from\nversion 2).\n\nClients should use wl_surface.preferred_buffer_transform instead of the\ntransform advertised by this event to find the preferred buffer\ntransform to use for a surface.\n\nNote: wl_output only advertises partial information about the output\nposition and identification. Some compositors, for instance those not\nimplementing a desktop-style output layout or those exposing virtual\noutputs, might fake this information. Instead of using x and y, clients\nshould use xdg_output.logical_position. Instead of using make and model,\nclients should use name and description.""x position within the global compositor space""y position within the global compositor space""width in millimeters of the output"physical_width"height in millimeters of the output"physical_height"subpixel orientation of the output""textual description of the manufacturer""textual description of the model""additional transformation applied to buffer contents during presentation""advertise available modes for the output\n\nThe mode event describes an available mode for the output.\n\nThe event is sent when binding to the output object and there\nwill always be one mode, the current mode.  The event is sent\nagain if an output changes mode, for the mode that is now\ncurrent.  In other words, the current mode is always the last\nmode that was received with the current flag set.\n\nNon-current modes are deprecated. A compositor can decide to only\nadvertise the current mode and never send other modes. Clients\nshould not rely on non-current modes.\n\nThe size of a mode is given in physical hardware units of\nthe output device. This is not necessarily the same as\nthe output size in the global compositor space. For instance,\nthe output may be scaled, as described in wl_output.scale,\nor transformed, as described in wl_output.transform. Clients\nwilling to retrieve the output size in the global compositor\nspace should use xdg_output.logical_size instead.\n\nThe vertical refresh rate can be set to zero if it doesn't make\nsense for this output (e.g. for virtual outputs).\n\nThe mode event will be followed by a done event (starting from\nversion 2).\n\nClients should not use the refresh rate to schedule frames. Instead,\nthey should use the wl_surface.frame event or the presentation-time\nprotocol.\n\nNote: this information is not always meaningful for all outputs. Some\ncompositors, such as those exposing virtual outputs, might fake the\nrefresh rate or the size.""bitfield of mode flags""width of the mode in hardware units""height of the mode in hardware units""vertical refresh rate in mHz""sent all information about output\n\nThis event is sent after all other properties have been\nsent after binding to the output object and after any\nother property changes done after that. This allows\nchanges to the output properties to be seen as\natomic, even if they happen via multiple events.\n\nOnly available since version 2 of the interface""output scaling properties\n\nThis event contains scaling geometry information\nthat is not in the geometry event. It may be sent after\nbinding the output object or if the output scale changes\nlater. The compositor will emit a non-zero, positive\nvalue for scale. If it is not sent, the client should\nassume a scale of 1.\n\nA scale larger than 1 means that the compositor will\nautomatically scale surface buffers by this amount\nwhen rendering. This is used for very high resolution\ndisplays where applications rendering at the native\nresolution would be too small to be legible.\n\nClients should use wl_surface.preferred_buffer_scale\ninstead of this event to find the preferred buffer\nscale to use for a surface.\n\nThe scale event will be followed by a done event.\n\nOnly available since version 2 of the interface""scaling factor of output""name of this output\n\nMany compositors will assign user-friendly names to their outputs, show\nthem to the user, allow the user to refer to an output, etc. The client\nmay wish to know this name as well to offer the user similar behaviors.\n\nThe name is a UTF-8 string with no convention defined for its contents.\nEach name is unique among all wl_output globals. The name is only\nguaranteed to be unique for the compositor instance.\n\nThe same output name is used for all clients for a given wl_output\nglobal. Thus, the name can be shared across processes to refer to a\nspecific wl_output global.\n\nThe name is not guaranteed to be persistent across sessions, thus cannot\nbe used to reliably identify an output in e.g. configuration files.\n\nExamples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do\nnot assume that the name is a reflection of an underlying DRM connector,\nX11 connection, etc.\n\nThe name event is sent after binding the output object. This event is\nonly sent once per output object, and the name does not change over the\nlifetime of the wl_output global.\n\nCompositors may re-use the same output name if the wl_output global is\ndestroyed and re-created later. Compositors should avoid re-using the\nsame name if possible.\n\nThe name event will be followed by a done event.\n\nOnly available since version 4 of the interface""output name""human-readable description of this output\n\nMany compositors can produce human-readable descriptions of their\noutputs. The client may wish to know this description as well, e.g. for\noutput selection purposes.\n\nThe description is a UTF-8 string with no convention defined for its\ncontents. The description is not guaranteed to be unique among all\nwl_output globals. Examples might include 'Foocorp 11\" Display' or\n'Virtual X11 output via :1'.\n\nThe description event is sent after binding the output object and\nwhenever the description changes. The description is optional, and may\nnot be sent at all.\n\nThe description event will be followed by a done event.\n\nOnly available since version 4 of the interface""output description""compositor output region\n\nAn output describes part of the compositor geometry.  The\ncompositor works in the 'compositor coordinate system' and an\noutput corresponds to a rectangular area in that space that is\nactually visible.  This typically corresponds to a monitor that\ndisplays part of the compositor space.  This object is published\nas global during start up, or when a monitor is hotplugged.\n\nSee also the [Event] enum for this interface.""release the output object\n\nUsing this request a client can tell the server that it is not going to\nuse the output object anymore.""region interface\n\nA region object describes an area.\n\nRegion objects are used to describe the opaque and input\nregions of a surface."REQ_ADD_SINCEREQ_ADD_OPCODEREQ_SUBTRACT_SINCEREQ_SUBTRACT_OPCODE"destroy region\n\nDestroy the region.  This will invalidate the object ID.\n\nThis is a destructor, once sent this object cannot be used any longer.""add rectangle to region\n\nAdd the specified rectangle to the region.""region-local x coordinate""region-local y coordinate""rectangle width""rectangle height""subtract rectangle from region\n\nSubtract the specified rectangle from the region.""region interface\n\nA region object describes an area.\n\nRegion objects are used to describe the opaque and input\nregions of a surface.\n\nThis interface has no events.""destroy region\n\nDestroy the region.  This will invalidate the object ID.""sub-surface compositing\n\nThe global interface exposing sub-surface compositing capabilities.\nA wl_surface, that has sub-surfaces associated, is called the\nparent surface. Sub-surfaces can be arbitrarily nested and create\na tree of sub-surfaces.\n\nThe root surface in a tree of sub-surfaces is the main\nsurface. The main surface cannot be a sub-surface, because\nsub-surfaces must always have a parent.\n\nA main surface with its sub-surfaces forms a (compound) window.\nFor window management purposes, this set of wl_surface objects is\nto be considered as a single window, and it should also behave as\nsuch.\n\nThe aim of sub-surfaces is to offload some of the compositing work\nwithin a window from clients to the compositor. A prime example is\na video player with decorations and video in separate wl_surface\nobjects. This should allow the compositor to pass YUV video buffer\nprocessing to dedicated overlay hardware when possible.""the to-be sub-surface is invalid"BadSurface"the to-be sub-surface parent is invalid"BadParentREQ_GET_SUBSURFACE_SINCEREQ_GET_SUBSURFACE_OPCODE"unbind from the subcompositor interface\n\nInforms the server that the client will not be using this\nprotocol object anymore. This does not affect any other\nobjects, wl_subsurface objects included.\n\nThis is a destructor, once sent this object cannot be used any longer.""give a surface the role sub-surface\n\nCreate a sub-surface interface for the given surface, and\nassociate it with the given parent surface. This turns a\nplain wl_surface into a sub-surface.\n\nThe to-be sub-surface must not already have another role, and it\nmust not have an existing wl_subsurface object. Otherwise the\nbad_surface protocol error is raised.\n\nAdding sub-surfaces to a parent is a double-buffered operation on the\nparent (see wl_surface.commit). The effect of adding a sub-surface\nbecomes visible on the next time the state of the parent surface is\napplied.\n\nThe parent surface must not be one of the child surface's descendants,\nand the parent must be different from the child surface, otherwise the\nbad_parent protocol error is raised.\n\nThis request modifies the behaviour of wl_surface.commit request on\nthe sub-surface, see the documentation on wl_subsurface interface.""the surface to be turned into a sub-surface""the parent surface"GetSubsurface"sub-surface compositing\n\nThe global interface exposing sub-surface compositing capabilities.\nA wl_surface, that has sub-surfaces associated, is called the\nparent surface. Sub-surfaces can be arbitrarily nested and create\na tree of sub-surfaces.\n\nThe root surface in a tree of sub-surfaces is the main\nsurface. The main surface cannot be a sub-surface, because\nsub-surfaces must always have a parent.\n\nA main surface with its sub-surfaces forms a (compound) window.\nFor window management purposes, this set of wl_surface objects is\nto be considered as a single window, and it should also behave as\nsuch.\n\nThe aim of sub-surfaces is to offload some of the compositing work\nwithin a window from clients to the compositor. A prime example is\na video player with decorations and video in separate wl_surface\nobjects. This should allow the compositor to pass YUV video buffer\nprocessing to dedicated overlay hardware when possible.\n\nThis interface has no events.""unbind from the subcompositor interface\n\nInforms the server that the client will not be using this\nprotocol object anymore. This does not affect any other\nobjects, wl_subsurface objects included."get_subsurface"sub-surface interface to a wl_surface\n\nAn additional interface to a wl_surface object, which has been\nmade a sub-surface. A sub-surface has one parent surface. A\nsub-surface's size and position are not limited to that of the parent.\nParticularly, a sub-surface is not automatically clipped to its\nparent's area.\n\nA sub-surface becomes mapped, when a non-NULL wl_buffer is applied\nand the parent surface is mapped. The order of which one happens\nfirst is irrelevant. A sub-surface is hidden if the parent becomes\nhidden, or if a NULL wl_buffer is applied. These rules apply\nrecursively through the tree of surfaces.\n\nThe behaviour of a wl_surface.commit request on a sub-surface\ndepends on the sub-surface's mode. The possible modes are\nsynchronized and desynchronized, see methods\nwl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized\nmode caches the wl_surface state to be applied when the parent's\nstate gets applied, and desynchronized mode applies the pending\nwl_surface state directly. A sub-surface is initially in the\nsynchronized mode.\n\nSub-surfaces also have another kind of state, which is managed by\nwl_subsurface requests, as opposed to wl_surface requests. This\nstate includes the sub-surface position relative to the parent\nsurface (wl_subsurface.set_position), and the stacking order of\nthe parent and its sub-surfaces (wl_subsurface.place_above and\n.place_below). This state is applied when the parent surface's\nwl_surface state is applied, regardless of the sub-surface's mode.\nAs the exception, set_sync and set_desync are effective immediately.\n\nThe main surface can be thought to be always in desynchronized mode,\nsince it does not have a parent in the sub-surfaces sense.\n\nEven if a sub-surface is in desynchronized mode, it will behave as\nin synchronized mode, if its parent surface behaves as in\nsynchronized mode. This rule is applied recursively throughout the\ntree of surfaces. This means, that one can set a sub-surface into\nsynchronized mode, and then assume that all its child and grand-child\nsub-surfaces are synchronized, too, without explicitly setting them.\n\nDestroying a sub-surface takes effect immediately. If you need to\nsynchronize the removal of a sub-surface to the parent surface update,\nunmap the sub-surface first by attaching a NULL wl_buffer, update parent,\nand then destroy the sub-surface.\n\nIf the parent wl_surface object is destroyed, the sub-surface is\nunmapped.\n\nA sub-surface never has the keyboard focus of any seat.\n\nThe wl_surface.offset request is ignored: clients must use set_position\ninstead to move the sub-surface.""wl_surface is not a sibling or the parent"REQ_SET_POSITION_SINCEREQ_SET_POSITION_OPCODEREQ_PLACE_ABOVE_SINCEREQ_PLACE_ABOVE_OPCODEREQ_PLACE_BELOW_SINCEREQ_PLACE_BELOW_OPCODEREQ_SET_SYNC_SINCEREQ_SET_SYNC_OPCODEREQ_SET_DESYNC_SINCEREQ_SET_DESYNC_OPCODE"remove sub-surface interface\n\nThe sub-surface interface is removed from the wl_surface object\nthat was turned into a sub-surface with a\nwl_subcompositor.get_subsurface request. The wl_surface's association\nto the parent is deleted. The wl_surface is unmapped immediately.\n\nThis is a destructor, once sent this object cannot be used any longer.""reposition the sub-surface\n\nThis schedules a sub-surface position change.\nThe sub-surface will be moved so that its origin (top left\ncorner pixel) will be at the location x, y of the parent surface\ncoordinate system. The coordinates are not restricted to the parent\nsurface area. Negative values are allowed.\n\nThe scheduled coordinates will take effect whenever the state of the\nparent surface is applied.\n\nIf more than one set_position request is invoked by the client before\nthe commit of the parent surface, the position of a new request always\nreplaces the scheduled position from any previous request.\n\nThe initial position is 0, 0.""x coordinate in the parent surface""y coordinate in the parent surface"SetPosition"restack the sub-surface\n\nThis sub-surface is taken from the stack, and put back just\nabove the reference surface, changing the z-order of the sub-surfaces.\nThe reference surface must be one of the sibling surfaces, or the\nparent surface. Using any other surface, including this sub-surface,\nwill cause a protocol error.\n\nThe z-order is double-buffered. Requests are handled in order and\napplied immediately to a pending state. The final pending state is\ncopied to the active state the next time the state of the parent\nsurface is applied.\n\nA new sub-surface is initially added as the top-most in the stack\nof its siblings and parent.""the reference surface"PlaceAbove"restack the sub-surface\n\nThe sub-surface is placed just below the reference surface.\nSee wl_subsurface.place_above."PlaceBelow"set sub-surface to synchronized mode\n\nChange the commit behaviour of the sub-surface to synchronized\nmode, also described as the parent dependent mode.\n\nIn synchronized mode, wl_surface.commit on a sub-surface will\naccumulate the committed state in a cache, but the state will\nnot be applied and hence will not change the compositor output.\nThe cached state is applied to the sub-surface immediately after\nthe parent surface's state is applied. This ensures atomic\nupdates of the parent and all its synchronized sub-surfaces.\nApplying the cached state will invalidate the cache, so further\nparent surface commits do not (re-)apply old state.\n\nSee wl_subsurface for the recursive effect of this mode."SetSync"set sub-surface to desynchronized mode\n\nChange the commit behaviour of the sub-surface to desynchronized\nmode, also described as independent or freely running mode.\n\nIn desynchronized mode, wl_surface.commit on a sub-surface will\napply the pending state directly, without caching, as happens\nnormally with a wl_surface. Calling wl_surface.commit on the\nparent surface has no effect on the sub-surface's wl_surface\nstate. This mode allows a sub-surface to be updated on its own.\n\nIf cached state exists when wl_surface.commit is called in\ndesynchronized mode, the pending state is added to the cached\nstate, and applied as a whole. This invalidates the cache.\n\nNote: even if a sub-surface is set to desynchronized, a parent\nsub-surface may override it to behave as synchronized. For details,\nsee wl_subsurface.\n\nIf a surface's parent surface behaves as desynchronized, then\nthe cached state is applied on set_desync."SetDesync"sub-surface interface to a wl_surface\n\nAn additional interface to a wl_surface object, which has been\nmade a sub-surface. A sub-surface has one parent surface. A\nsub-surface's size and position are not limited to that of the parent.\nParticularly, a sub-surface is not automatically clipped to its\nparent's area.\n\nA sub-surface becomes mapped, when a non-NULL wl_buffer is applied\nand the parent surface is mapped. The order of which one happens\nfirst is irrelevant. A sub-surface is hidden if the parent becomes\nhidden, or if a NULL wl_buffer is applied. These rules apply\nrecursively through the tree of surfaces.\n\nThe behaviour of a wl_surface.commit request on a sub-surface\ndepends on the sub-surface's mode. The possible modes are\nsynchronized and desynchronized, see methods\nwl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized\nmode caches the wl_surface state to be applied when the parent's\nstate gets applied, and desynchronized mode applies the pending\nwl_surface state directly. A sub-surface is initially in the\nsynchronized mode.\n\nSub-surfaces also have another kind of state, which is managed by\nwl_subsurface requests, as opposed to wl_surface requests. This\nstate includes the sub-surface position relative to the parent\nsurface (wl_subsurface.set_position), and the stacking order of\nthe parent and its sub-surfaces (wl_subsurface.place_above and\n.place_below). This state is applied when the parent surface's\nwl_surface state is applied, regardless of the sub-surface's mode.\nAs the exception, set_sync and set_desync are effective immediately.\n\nThe main surface can be thought to be always in desynchronized mode,\nsince it does not have a parent in the sub-surfaces sense.\n\nEven if a sub-surface is in desynchronized mode, it will behave as\nin synchronized mode, if its parent surface behaves as in\nsynchronized mode. This rule is applied recursively throughout the\ntree of surfaces. This means, that one can set a sub-surface into\nsynchronized mode, and then assume that all its child and grand-child\nsub-surfaces are synchronized, too, without explicitly setting them.\n\nDestroying a sub-surface takes effect immediately. If you need to\nsynchronize the removal of a sub-surface to the parent surface update,\nunmap the sub-surface first by attaching a NULL wl_buffer, update parent,\nand then destroy the sub-surface.\n\nIf the parent wl_surface object is destroyed, the sub-surface is\nunmapped.\n\nA sub-surface never has the keyboard focus of any seat.\n\nThe wl_surface.offset request is ignored: clients must use set_position\ninstead to move the sub-surface.\n\nThis interface has no events.""remove sub-surface interface\n\nThe sub-surface interface is removed from the wl_surface object\nthat was turned into a sub-surface with a\nwl_subcompositor.get_subsurface request. The wl_surface's association\nto the parent is deleted. The wl_surface is unmapped immediately."place_aboveplace_belowset_desync"wayland protocol fixes\n\nThis global fixes problems with other core-protocol interfaces that\ncannot be fixed in these interfaces themselves."REQ_DESTROY_REGISTRY_SINCEREQ_DESTROY_REGISTRY_OPCODE"destroys this object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""destroy a wl_registry\n\nThis request destroys a wl_registry object.\n\nThe client should no longer use the wl_registry after making this\nrequest.\n\nThe compositor will emit a wl_display.delete_id event with the object ID\nof the registry and will no longer emit any events on the registry. The\nclient should re-use the object ID once it receives the\nwl_display.delete_id event.""the registry to destroy"DestroyRegistry"wayland protocol fixes\n\nThis global fixes problems with other core-protocol interfaces that\ncannot be fixed in these interfaces themselves.\n\nThis interface has no events."WlFixes"destroys this object"destroy_registrywl_fixes/// Generated protocol definitions/// This module is automatically generated from the `wayland.xml` protocol specification,/// and contains the interface definitions for the core Wayland protocol./// The event enum for this interface/// The request enum for this interface/// The interface description/// The ID of this object/// The version of this object/// Checks if the Wayland object associated with this proxy is still alive/// Access the user-data associated with this object/// Access the raw data associated with this object./// For objects created using the scanner-generated methods, this will be an instance of the/// [`QueueProxyData`] type./// Access the backend associated with this object/// Create an object proxy from its ID/// Returns an error this the provided object ID does not correspond to/// the `Self` interface./// **Note:** This method is mostly meant as an implementation detail to be/// used by code generated by wayland-scanner./// Create an inert object proxy/// Send a request for this object./// It is an error to use this function on requests that create objects; use/// [`send_constructor()`][Self::send_constructor()] for such requests./// Send a request for this object that creates another object./// It is an error to use this function on requests that do not create objects; use/// [`send_request()`][Self::send_request()] for such requests./// Parse a event for this object/// Serialize a request for this object/// Creates a weak handle to this object/// This weak handle will not keep the user-data associated with the object alive,/// and can be converted back to a full proxy using [`Weak::upgrade()`]./// This can be of use if you need to store proxies in the used data of other objects and want/// to be sure to avoid reference cycles that would cause memory leaks./// Trait representing a Wayland interface/// The id of the target object/// The interface of the target object/// The opcode numberBadMessage/// The received message does not match the specification for the object's interface./// Wayland dispatching error_iface/// A weak handle to a Wayland object/// This handle does not keep the underlying user data alive, and can be converted back to a full proxy/// using [`Weak::upgrade()`]./// Try to upgrade with weak handle back into a full proxy./// This will fail if either:/// - the object represented by this handle has already been destroyed at the protocol level/// - the Wayland connection has already been closed/// The underlying [`ObjectId`]//! Interface for interacting with the Wayland protocol, client-side.//! ## General concepts//! This crate is structured around four main objects: the [`Connection`] and [`EventQueue`] structs,//! proxies (objects implementing the [`Proxy`] trait), and the [`Dispatch`] trait.//! The [`Connection`] is the heart of this crate. It represents your connection to the Wayland server, and//! you'll generally initialize it using the [`Connection::connect_to_env()`] method, which will//! attempt to open a Wayland connection following the configuration specified by the ! environment.//! Once you have a [`Connection`], you can create an [`EventQueue`] from it. This [`EventQueue`] will take//! care of processing events from the Wayland server and delivering them to your processing logic, in the form//! of a state struct with several [`Dispatch`] implementations (see below).//! Each of the Wayland objects you can manipulate is represented by a struct implementing the [`Proxy`]//! trait. Those structs are automatically generated from the wayland XML protocol specification. This crate//! provides the types generated from the core protocol in the [`protocol`] module. For other standard//! protocols, see the `wayland-protocols` crate.//! ## Event dispatching//! The core event dispatching logic provided by this crate is built around the [`EventQueue`] struct. In//! this paradigm, receiving and processing events is a two-step process://! - First, events are read from the Wayland socket. For each event, the backend figures out which [`EventQueue`]//!   manages it, and enqueues the event in an internal buffer of that queue.//! - Then, the [`EventQueue`] empties its internal buffer by sequentially invoking the appropriate//!   [`Dispatch::event()`] method on the `State` value that was provided to it.//! The main goal of this structure is to make your `State` accessible without synchronization to most of//! your event-processing logic, to reduce the plumbing costs. See [`EventQueue`]'s documentation for//! explanations of how to use it to drive your event loop, and when and how to use multiple//! event queues in your app.//! ### The [`Dispatch`] trait and dispatch delegation//! In this paradigm, your `State` needs to implement `Dispatch<O, _>` for every Wayland object `O` it needs to//! process events for. This is ensured by the fact that, whenever creating an object using the methods on//! an other object, you need to pass a [`QueueHandle<State>`] from the [`EventQueue`] that will be//! managing the newly created object.//! However, implementing all those traits on your own is a lot of (often uninteresting) work. To make this//! easier a composition mechanism is provided using the [`delegate_dispatch!`] macro. This way, another//! library (such as Smithay's Client Toolkit) can provide generic [`Dispatch`] implementations that you//! can reuse in your own app by delegating those objects to that provided implementation. See the//! documentation of those traits and macro for details.//! ## Getting started example//! As an overview of how this crate is used, here is a commented example of a program that connects to the//! Wayland server and lists the globals this server advertised through the `wl_registry`://! use wayland_client::{protocol::wl_registry, Connection, Dispatch, QueueHandle};//! // This struct represents the state of our app. This simple app does not//! // need any state, but this type still supports the `Dispatch` implementations.//! struct AppData;//! // Implement `Dispatch<WlRegistry, ()> for our state. This provides the logic//! // to be able to process events for the wl_registry interface.//! // The second type parameter is the user-data of our implementation. It is a//! // mechanism that allows you to associate a value to each particular Wayland//! // object, and allow different dispatching logic depending on the type of the//! // associated value.//! // In this example, we just use () as we don't have any value to associate. See//! // the `Dispatch` documentation for more details about this.//! impl Dispatch<wl_registry::WlRegistry, ()> for AppData {//!         _state: &mut Self,//!         _: &wl_registry::WlRegistry,//!         _: &(),//!         _: &Connection,//!         _: &QueueHandle<AppData>,//!         // When receiving events from the wl_registry, we are only interested in the//!         // `global` event, which signals a new available global.//!         // When receiving this event, we just print its characteristics in this example.//!         if let wl_registry::Event::Global { name, interface, version } = event {//!             println!("[{}] {} (v{})", name, interface, version);//! // The main function of our program//!     // Create a Wayland connection by connecting to the server through the//!     // environment-provided configuration.//!     let conn = Connection::connect_to_env().unwrap();//!     // Retrieve the WlDisplay Wayland object from the connection. This object is//!     // the starting point of any Wayland program, from which all other objects will//!     // be created.//!     let display = conn.display();//!     // Create an event queue for our event processing//!     let mut event_queue = conn.new_event_queue();//!     // And get its handle to associate new objects to it//!     let qh = event_queue.handle();//!     // Create a wl_registry object by sending the wl_display.get_registry request.//!     // This method takes two arguments: a handle to the queue that the newly created//!     // wl_registry will be assigned to, and the user-data that should be associated//!     // with this registry (here it is () as we don't need user-data).//!     let _registry = display.get_registry(&qh, ());//!     // At this point everything is ready, and we just need to wait to receive the events//!     // from the wl_registry. Our callback will print the advertised globals.//!     println!("Advertised globals:");//!     // To actually receive the events, we invoke the `roundtrip` method. This method//!     // is special and you will generally only invoke it during the setup of your program://!     // it will block until the server has received and processed all the messages you've//!     // sent up to now.//!     // In our case, that means it'll block until the server has received our//!     // wl_display.get_registry request, and as a reaction has sent us a batch of//!     // wl_registry.global events.//!     // `roundtrip` will then empty the internal buffer of the queue it has been invoked//!     // on, and thus invoke our `Dispatch` implementation that prints the list of advertised//!     // globals.//!     event_queue.roundtrip(&mut AppData).unwrap();//! ## Advanced use//! ### Bypassing [`Dispatch`]//! It may be that for some of your objects, handling them via the [`EventQueue`] is impractical. For example,//! if processing the events from those objects doesn't require accessing some global state, and/or you need to//! handle them in a context where cranking an event loop is impractical.//! In those contexts, this crate also provides some escape hatches to directly interface with the low-level//! APIs from `wayland-backend`, allowing you to register callbacks for those objects that will be invoked//! whenever they receive an event and *any* event queue from the program is being dispatched. Those//! callbacks are more constrained: they don't get a `&mut State` reference, and must be threadsafe. See//! [`Proxy::send_constructor()`] and [`ObjectData`] for details about how to//! assign such callbacks to objects.//! ### Interaction with FFI//! It can happen that you'll need to interact with Wayland states accross FFI. A typical example would be if//! you need to use the [`raw-window-handle`](https://docs.rs/raw-window-handle/) crate.//! In this case, you'll need to do it in two steps, by explicitly working with `wayland-backend`, adding//! it to your dependencies and enabling its `client_system` feature.//! - If you need to send pointers to FFI, you can retrive the `*mut wl_proxy` pointers from the proxies by//!   first getting the [`ObjectId`] using the [`Proxy::id()`] method, and then//!   using the [`ObjectId::as_ptr()`] method.//  - If you need to receive pointers from FFI, you need to first create a//    [`Backend`][backend::Backend] from the `*mut wl_display` using//    [`Backend::from_external_display()`][backend::Backend::from_foreign_display()], and then//    make it into a [`Connection`] using [`Connection::from_backend()`]. Similarly, you can make//    [`ObjectId`]s from the `*mut wl_proxy` pointers using [`ObjectId::from_ptr()`], and then make//    the proxies using [`Proxy::from_id()`]./// Emulate click on the decorations./// The `click` is a variant of click to use, see [`FrameClick`] for more/// information. `timestamp` is the time when event happened./// The return value is a [`FrameAction`] you should apply, this action/// could be ignored./// The location of the click is the one passed to/// [`Self::click_point_moved`]./// Emulate pointer moved event on the decorations frame./// The `x` and `y` are location in the surface local coordinates relative/// to the `surface`. `timestamp` is the time when event happened./// The return value is the new cursor icon you should apply to provide/// better visual feedback for the user. However, you might want to/// ignore it, if you're using touch events to drive the movements./// All clicks left the decorations./// This function should be called when input leaves the decorations./// Update the state of the frame./// The state is usually obtained from the `xdg_toplevel::configure` event./// Update the window manager capabilites./// The capabilites are usually obtained from the/// `xdg_toplevel::wm_capabilities` event./// Resize the window to the new size./// The size must be without the borders, as in [`Self::subtract_borders]`/// were used on it./// **Note:** The [`Self::update_state`] and/// [`Self::update_wm_capabilities`] **must be** applied before calling/// Panics when resizing the hidden frame./// Set the scaling of the decorations frame./// If the decorations frame is not supporting fractional scaling it'll/// `ceil` the scaling factor./// Return the coordinates of the top-left corner of the borders relative to/// the content./// Values **must** thus be non-positive./// Subtract the borders from the given `width` and `height`./// `None` will be returned for the particular dimension when the given/// value for it was too small./// Add the borders to the given `width` and `height`./// Passing zero for both width and height could be used to get the size/// of the decorations frame./// Whether the given frame is dirty and should be redrawn./// Set the frame as hidden./// The frame **must be** visible by default./// Get the frame hidden state./// Get the state of the last [`DecorationsFrame::set_hidden`]./// Mark the frame as resizable./// By default the frame is resizable./// Draw the decorations frame./// Return `true` when the main surface must be redrawn as well. This/// usually happens when `sync` is being set on the internal subsurfaces and/// they've changed their size./// The user of the frame **must** commit the base surface afterwards./// Set the frames title./// The interface for the client side decorations./// The window should be minimized./// The window should be maximized.UnMaximize/// The window should be unmaximized./// The window should be closed./// An interactive move should be started./// An interactive resize should be started with the provided edge.ShowMenu/// Show window menu./// The coordinates are relative to the base surface, as in should be/// directly passed to the `xdg_toplevel::show_window_menu`./// The Frame action user should perform in responce to mouse click events./// The user done normal click, likely with left mouse button or single/// finger touch./// The user done right mouse click or some touch sequence that was treated/// as alternate click./// The alternate click exists solely to provide alternative action, like/// show window menu when doing right mouse button cilck on the header/// decorations, nothing more./// The user clicked or touched the decoractions frame.r" The configured state of the window."r" The surface is maximized. The window geometry specified in the"r" configure event must be obeyed by the client. The client should"r" draw without shadow or other decoration outside of the window"r" geometry."r" The surface is fullscreen. The window geometry specified in the"r" configure event is a maximum; the client cannot resize beyond it."r" For a surface to cover the whole fullscreened area, the geometry"r" dimensions must be obeyed by the client. For more details, see"r" xdg_toplevel.set_fullscreen."r" The surface is being resized. The window geometry specified in the"r" Clients that have aspect ratio or cell sizing configuration can use"r" a smaller size, however."RESIZINGr" Client window decorations should be painted as if the window is"r" active. Do not assume this means that the window actually has"r" keyboard or pointer focus."r" The window is currently in a tiled layout and the left edge is"r" considered to be adjacent to another part of the tiling grid."TILED_LEFTr" The window is currently in a tiled layout and the right edge is"TILED_RIGHTr" The window is currently in a tiled layout and the top edge is"TILED_TOPr" The window is currently in a tiled layout and the bottom edge is"TILED_BOTTOMr" An alias for all tiled bits set."r" The surface is currently not ordinarily being repainted; for example"r" because its content is occluded by another window, or its outputs are"r" switched off due to screen locking."SUSPENDEDr" The capabilities of the window manager."r" This is a hint to hide UI elements which provide functionality"r" not supported by compositor."r" `show_window_menu` is available."WINDOW_MENUr" Window can be maximized and unmaximized."r" Window can be fullscreened and unfullscreened."r" Window could be minimized."/// Nothing is being dragged./// The top edge is being dragged./// The bottom edge is being dragged./// The left edge is being dragged./// The top left corner is being dragged./// The bottom left corner is being dragged./// The right edge is being dragged./// The top right corner is being dragged./// The bottom right corner is being dragged./// Which edge or corner is being dragged.//! The interface for wayland client side decorations (CSD).//! The crate is intended to be used by libraries providing client//! side decorations for the xdg-shell protocol.//! Examples could be found in [`client toolkit`] and [`sctk-adwaita`].//! [`client toolkit`]: https://github.com/smithay/client-toolkit//! [`sctk-adwaita`]: https://github.com/PolyMeilex/sctk-adwaitaxparserXCursorThemeXCursorImageFallBack/// Represents a cursor theme loaded from the system.FallBackInner/// Load a cursor theme from system defaults./// Same as calling the following:/// # use wayland_cursor::CursorTheme;/// # use wayland_client::{Connection, backend::InvalidId, protocol::wl_shm};/// # fn example(conn: &Connection, shm: wl_shm::WlShm, size: u32) -> Result<CursorTheme, InvalidId> {/// CursorTheme::load_or(conn, shm, "default", size)load_or/// Load a cursor theme, using `name` as fallback./// The theme name and cursor size are read from the `XCURSOR_THEME` and/// `XCURSOR_SIZE` environment variables, respectively, or from the provided variables/// if those are invalid.load_from_name/// Create a new cursor theme, ignoring the system defaults./// Retrieve a cursor from the theme./// This method returns [`None`] if this cursor is not provided either by the theme, or by one of its parents./// If a [fallback is set], it will use the data returned by the fallback./// [fallback is set]: Self::set_fallback()/// Set a fallback to load the cursor data, in case the system theme is missing a cursor that you need./// Your fallback will be invoked with the name and size of the requested cursor and should return a byte/// array with the contents of an `xcursor` file, or [`None`] if you don't provide a fallback for this cursor./// For example, this defines a generic fallback cursor image and uses it for all missing cursors:/// use wayland_client::{Connection, backend::InvalidId, protocol::wl_shm};/// fn example(conn: &Connection, shm: wl_shm::WlShm, size: u32) -> Result<CursorTheme, InvalidId> {///   let mut theme = CursorTheme::load_or(conn, shm, "default", size)?;///   theme.set_fallback(|name, size| {///       include_bytes!("./icons/default")///   Ok(theme)load_cursor/// This function loads a cursor, parses it and pushes the images onto the shm pool./// Keep in mind that if the cursor is already loaded, the function will make a duplicate./// Grow the wl_shm_pool this theme is stored on./// This method does nothing if the provided size is smaller or equal to the pool's current size.CursorImageBuffertotal_duration/// A cursor from a theme. Can contain several images if animated./// Construct a new Cursor./// Each of the provided images will be written into `theme`./// This will also grow `theme.pool` if necessary.nearest_imagesframe_and_durationFrameAndDuration/// Given a time, calculate which frame to show, and how much time remains until the next frame./// Time will wrap, so if for instance the cursor has an animation lasting 100ms,/// then calling this function with 5ms and 105ms as input gives the same output.image_count/// Total number of images forming this cursor animation/// A buffer containing a cursor image./// You can access the `WlBuffer` via `Deref`./// Note that this buffer is internally managed by wayland-cursor, as such you should/// not try to act on it beyond assigning it to `wl_surface`s./// Construct a new CursorImageBuffer/// This function appends the pixels of the image to the provided file,/// and constructs a wl_buffer on that data./// Dimensions of this imagehotspot/// Location of the pointer hotspot in this image/// Time (in milliseconds) for which this image should be displayed/// The index of the frame which should be shown.frame_duration/// The duration that the frame should be shown for (in milliseconds)./// Which frame to show, and for how long./// This struct is output by `Cursor::frame_and_duration`/// Create a shared file descriptor in memory.IgnoreObjectData//! Wayland cursor utilities//! This crate aims to re-implement the functionality of the `libwayland-cursor` library in Rust.//! It allows you to load cursors from the system and display them correctly.//! First of all, you need to create a [`CursorTheme`], which represents the full cursor theme.//! From this theme, using the [`get_cursor()`][CursorTheme::get_cursor()] method, you can load a//! specific [`Cursor`], which can contain several images if the cursor is animated. It also provides//! you with the means of querying which frame of the animation should be displayed at what time, as//! well as handles to the buffers containing these frames, to attach them to a wayland surface.//! use wayland_cursor::CursorTheme;//! # use std::ops::Deref;//! # use std::thread::sleep;//! # use std::time::{Instant, Duration};//! # fn test(connection: &wayland_client::Connection, cursor_surface: &wayland_client::protocol::wl_surface::WlSurface, shm: wayland_client::protocol::wl_shm::WlShm) {//! // Load the default cursor theme.//! let mut cursor_theme = CursorTheme::load(&connection, shm, 32)//!     .expect("Could not load cursor theme");//! let cursor = cursor_theme.get_cursor("wait")//!     .expect("Cursor not provided by theme");//! let start_time = Instant::now();//!     // Obtain which frame we should show, and for how long.//!     let millis = start_time.elapsed().as_millis();//!     let fr_info = cursor.frame_and_duration(millis as u32);//!     // Here, we obtain the right cursor frame...//!     let buffer = &cursor[fr_info.frame_index];//!     // and attach it to a wl_surface.//!     cursor_surface.attach(Some(&buffer), 0, 0);//!     cursor_surface.commit();//!     sleep(Duration::from_millis(fr_info.frame_duration as u64));wayland_protocolr" Client-side API of this protocol"EXT_IDLE_NOTIFIER_V1_INTERFACEext_idle_notifier_v1_requests_get_idle_notification_typesext_idle_notifier_v1_requests_get_input_idle_notification_typesext_idle_notifier_v1_requestsext_idle_notifier_v1_interfaceEXT_IDLE_NOTIFICATION_V1_INTERFACEext_idle_notification_v1_requestsext_idle_notification_v1_eventsext_idle_notification_v1_interface"idle notification manager\n\nThis interface allows clients to monitor user idle status.\n\nAfter binding to this global, clients can create ext_idle_notification_v1\nobjects to get notified when the user is idle for a given amount of time."REQ_GET_IDLE_NOTIFICATION_SINCEREQ_GET_IDLE_NOTIFICATION_OPCODEREQ_GET_INPUT_IDLE_NOTIFICATION_SINCEREQ_GET_INPUT_IDLE_NOTIFICATION_OPCODE"destroy the manager\n\nDestroy the manager object. All objects created via this interface\nremain valid.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a notification object\n\nCreate a new idle notification object.\n\nThe notification object has a minimum timeout duration and is tied to a\nseat. The client will be notified if the seat is inactive for at least\nthe provided timeout. See ext_idle_notification_v1 for more details.\n\nA zero timeout is valid and means the client wants to be notified as\nsoon as possible when the seat is inactive.""minimum idle timeout in msec"GetIdleNotification"create a notification object\n\nCreate a new idle notification object to track input from the\nuser, such as keyboard and mouse movement. Because this object is\nmeant to track user input alone, it ignores idle inhibitors.\n\nThe notification object has a minimum timeout duration and is tied to a\nseat. The client will be notified if the seat is inactive for at least\nthe provided timeout. See ext_idle_notification_v1 for more details.\n\nA zero timeout is valid and means the client wants to be notified as\nsoon as possible when the seat is inactive.\n\nOnly available since version 2 of the interface"GetInputIdleNotification"idle notification manager\n\nThis interface allows clients to monitor user idle status.\n\nAfter binding to this global, clients can create ext_idle_notification_v1\nobjects to get notified when the user is idle for a given amount of time.\n\nThis interface has no events."ExtIdleNotifierV1"destroy the manager\n\nDestroy the manager object. All objects created via this interface\nremain valid."ext_idle_notification_v1ExtIdleNotificationV1get_idle_notification"create a notification object\n\nCreate a new idle notification object to track input from the\nuser, such as keyboard and mouse movement. Because this object is\nmeant to track user input alone, it ignores idle inhibitors.\n\nThe notification object has a minimum timeout duration and is tied to a\nseat. The client will be notified if the seat is inactive for at least\nthe provided timeout. See ext_idle_notification_v1 for more details.\n\nA zero timeout is valid and means the client wants to be notified as\nsoon as possible when the seat is inactive."get_input_idle_notificationext_idle_notifier_v1"idle notification\n\nThis interface is used by the compositor to send idle notification events\nto clients.\n\nInitially the notification object is not idle. The notification object\nbecomes idle when no user activity has happened for at least the timeout\nduration, starting from the creation of the notification object. User\nactivity may include input events or a presence sensor, but is\ncompositor-specific.\n\nHow this notification responds to idle inhibitors depends on how\nit was constructed. If constructed from the\nget_idle_notification request, then if an idle inhibitor is\nactive (e.g. another client has created a zwp_idle_inhibitor_v1\non a visible surface), the compositor must not make the\nnotification object idle. However, if constructed from the\nget_input_idle_notification request, then idle inhibitors are\nignored, and only input from the user, e.g. from a keyboard or\nmouse, counts as activity.\n\nWhen the notification object becomes idle, an idled event is sent. When\nuser activity starts again, the notification object stops being idle,\na resumed event is sent and the timeout is restarted."EVT_IDLED_SINCEEVT_IDLED_OPCODEEVT_RESUMED_SINCEEVT_RESUMED_OPCODE"destroy the notification object\n\nDestroy the notification object.\n\nThis is a destructor, once sent this object cannot be used any longer.""notification object is idle\n\nThis event is sent when the notification object becomes idle.\n\nIt's a compositor protocol error to send this event twice without a\nresumed event in-between."Idled"notification object is no longer idle\n\nThis event is sent when the notification object stops being idle.\n\nIt's a compositor protocol error to send this event twice without an\nidled event in-between. It's a compositor protocol error to send this\nevent prior to any idled event.""idle notification\n\nThis interface is used by the compositor to send idle notification events\nto clients.\n\nInitially the notification object is not idle. The notification object\nbecomes idle when no user activity has happened for at least the timeout\nduration, starting from the creation of the notification object. User\nactivity may include input events or a presence sensor, but is\ncompositor-specific.\n\nHow this notification responds to idle inhibitors depends on how\nit was constructed. If constructed from the\nget_idle_notification request, then if an idle inhibitor is\nactive (e.g. another client has created a zwp_idle_inhibitor_v1\non a visible surface), the compositor must not make the\nnotification object idle. However, if constructed from the\nget_input_idle_notification request, then idle inhibitors are\nignored, and only input from the user, e.g. from a keyboard or\nmouse, counts as activity.\n\nWhen the notification object becomes idle, an idled event is sent. When\nuser activity starts again, the notification object stops being idle,\na resumed event is sent and the timeout is restarted.\n\nSee also the [Event] enum for this interface.""destroy the notification object\n\nDestroy the notification object."//! This protocol allows clients to monitor user idle status.idle_notifyEXT_SESSION_LOCK_MANAGER_V1_INTERFACEext_session_lock_manager_v1_requests_lock_typesext_session_lock_manager_v1_requestsext_session_lock_manager_v1_interfaceEXT_SESSION_LOCK_V1_INTERFACEext_session_lock_v1_requests_get_lock_surface_typesext_session_lock_v1_requestsext_session_lock_v1_eventsext_session_lock_v1_interfaceEXT_SESSION_LOCK_SURFACE_V1_INTERFACEext_session_lock_surface_v1_requestsext_session_lock_surface_v1_eventsext_session_lock_surface_v1_interface"used to lock the session\n\nThis interface is used to request that the session be locked."REQ_LOCK_SINCEREQ_LOCK_OPCODE"destroy the session lock manager object\n\nThis informs the compositor that the session lock manager object will\nno longer be used. Existing objects created through this interface\nremain valid.\n\nThis is a destructor, once sent this object cannot be used any longer.""attempt to lock the session\n\nThis request creates a session lock and asks the compositor to lock the\nsession. The compositor will send either the ext_session_lock_v1.locked\nor ext_session_lock_v1.finished event on the created object in\nresponse to this request.""used to lock the session\n\nThis interface is used to request that the session be locked.\n\nThis interface has no events.""destroy the session lock manager object\n\nThis informs the compositor that the session lock manager object will\nno longer be used. Existing objects created through this interface\nremain valid.""manage lock state and create lock surfaces\n\nIn response to the creation of this object the compositor must send\neither the locked or finished event.\n\nThe locked event indicates that the session is locked. This means\nthat the compositor must stop rendering and providing input to normal\nclients. Instead the compositor must blank all outputs with an opaque\ncolor such that their normal content is fully hidden.\n\nThe only surfaces that should be rendered while the session is locked\nare the lock surfaces created through this interface and optionally,\nat the compositor's discretion, special privileged surfaces such as\ninput methods or portions of desktop shell UIs.\n\nThe locked event must not be sent until a new \"locked\" frame (either\nfrom a session lock surface or the compositor blanking the output) has\nbeen presented on all outputs and no security sensitive normal/unlocked\ncontent is possibly visible.\n\nThe finished event should be sent immediately on creation of this\nobject if the compositor decides that the locked event will not be sent.\n\nThe compositor may wait for the client to create and render session lock\nsurfaces before sending the locked event to avoid displaying intermediate\nblank frames. However, it must impose a reasonable time limit if\nwaiting and send the locked event as soon as the hard requirements\ndescribed above can be met if the time limit expires. Clients should\nimmediately create lock surfaces for all outputs on creation of this\nobject to make this possible.\n\nThis behavior of the locked event is required in order to prevent\npossible race conditions with clients that wish to suspend the system\nor similar after locking the session. Without these semantics, clients\ntriggering a suspend after receiving the locked event would race with\nthe first \"locked\" frame being presented and normal/unlocked frames\nmight be briefly visible as the system is resumed if the suspend\noperation wins the race.\n\nIf the client dies while the session is locked, the compositor must not\nunlock the session in response. It is acceptable for the session to be\npermanently locked if this happens. The compositor may choose to continue\nto display the lock surfaces the client had mapped before it died or\nalternatively fall back to a solid color, this is compositor policy.\n\nCompositors may also allow a secure way to recover the session, the\ndetails of this are compositor policy. Compositors may allow a new\nclient to create a ext_session_lock_v1 object and take responsibility\nfor unlocking the session, they may even start a new lock client\ninstance automatically.""attempted to destroy session lock while locked"InvalidDestroy"unlock requested but locked event was never sent"InvalidUnlock"given wl_surface already has a role""given output already has a lock surface"DuplicateOutput"given wl_surface has a buffer attached or committed"AlreadyConstructedREQ_GET_LOCK_SURFACE_SINCEREQ_GET_LOCK_SURFACE_OPCODEREQ_UNLOCK_AND_DESTROY_SINCEREQ_UNLOCK_AND_DESTROY_OPCODEEVT_LOCKED_SINCEEVT_LOCKED_OPCODEEVT_FINISHED_SINCEEVT_FINISHED_OPCODE"destroy the session lock\n\nThis informs the compositor that the lock object will no longer be\nused. Existing objects created through this interface remain valid.\n\nAfter this request is made, lock surfaces created through this object\nshould be destroyed by the client as they will no longer be used by\nthe compositor.\n\nIt is a protocol error to make this request if the locked event was\nsent, the unlock_and_destroy request must be used instead.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a lock surface for a given output\n\nThe client is expected to create lock surfaces for all outputs\ncurrently present and any new outputs as they are advertised. These\nwon't be displayed by the compositor unless the lock is successful\nand the locked event is sent.\n\nProviding a wl_surface which already has a role or already has a buffer\nattached or committed is a protocol error, as is attaching/committing\na buffer before the first ext_session_lock_surface_v1.configure event.\n\nAttempting to create more than one lock surface for a given output\nis a duplicate_output protocol error."GetLockSurface"unlock the session, destroying the object\n\nThis request indicates that the session should be unlocked, for\nexample because the user has entered their password and it has been\nverified by the client.\n\nThis request also informs the compositor that the lock object will\nno longer be used and should be destroyed. Existing objects created\nthrough this interface remain valid.\n\nAfter this request is made, lock surfaces created through this object\nshould be destroyed by the client as they will no longer be used by\nthe compositor.\n\nIt is a protocol error to make this request if the locked event has\nnot been sent. In that case, the lock object must be destroyed using\nthe destroy request.\n\nNote that a correct client that wishes to exit directly after unlocking\nthe session must use the wl_display.sync request to ensure the server\nreceives and processes the unlock_and_destroy request. Otherwise\nthere is no guarantee that the server has unlocked the session due\nto the asynchronous nature of the Wayland protocol. For example,\nthe server might terminate the client with a protocol error before\nit processes the unlock_and_destroy request.\n\nThis is a destructor, once sent this object cannot be used any longer."UnlockAndDestroy"session successfully locked\n\nThis client is now responsible for displaying graphics while the\nsession is locked and deciding when to unlock the session.\n\nThe locked event must not be sent until a new \"locked\" frame has been\npresented on all outputs and no security sensitive normal/unlocked\ncontent is possibly visible.\n\nIf this event is sent, making the destroy request is a protocol error,\nthe lock object must be destroyed using the unlock_and_destroy request.""the session lock object should be destroyed\n\nThe compositor has decided that the session lock should be destroyed\nas it will no longer be used by the compositor. Exactly when this\nevent is sent is compositor policy, but it must never be sent more\nthan once for a given session lock object.\n\nThis might be sent because there is already another ext_session_lock_v1\nobject held by a client, or the compositor has decided to deny the\nrequest to lock the session for some other reason. This might also\nbe sent because the compositor implements some alternative, secure\nway to authenticate and unlock the session.\n\nThe finished event should be sent immediately on creation of this\nobject if the compositor decides that the locked event will not\nbe sent.\n\nIf the locked event is sent on creation of this object the finished\nevent may still be sent at some later time in this object's\nlifetime. This is compositor policy.\n\nUpon receiving this event, the client should make either the destroy\nrequest or the unlock_and_destroy request, depending on whether or\nnot the locked event was received on this object.""manage lock state and create lock surfaces\n\nIn response to the creation of this object the compositor must send\neither the locked or finished event.\n\nThe locked event indicates that the session is locked. This means\nthat the compositor must stop rendering and providing input to normal\nclients. Instead the compositor must blank all outputs with an opaque\ncolor such that their normal content is fully hidden.\n\nThe only surfaces that should be rendered while the session is locked\nare the lock surfaces created through this interface and optionally,\nat the compositor's discretion, special privileged surfaces such as\ninput methods or portions of desktop shell UIs.\n\nThe locked event must not be sent until a new \"locked\" frame (either\nfrom a session lock surface or the compositor blanking the output) has\nbeen presented on all outputs and no security sensitive normal/unlocked\ncontent is possibly visible.\n\nThe finished event should be sent immediately on creation of this\nobject if the compositor decides that the locked event will not be sent.\n\nThe compositor may wait for the client to create and render session lock\nsurfaces before sending the locked event to avoid displaying intermediate\nblank frames. However, it must impose a reasonable time limit if\nwaiting and send the locked event as soon as the hard requirements\ndescribed above can be met if the time limit expires. Clients should\nimmediately create lock surfaces for all outputs on creation of this\nobject to make this possible.\n\nThis behavior of the locked event is required in order to prevent\npossible race conditions with clients that wish to suspend the system\nor similar after locking the session. Without these semantics, clients\ntriggering a suspend after receiving the locked event would race with\nthe first \"locked\" frame being presented and normal/unlocked frames\nmight be briefly visible as the system is resumed if the suspend\noperation wins the race.\n\nIf the client dies while the session is locked, the compositor must not\nunlock the session in response. It is acceptable for the session to be\npermanently locked if this happens. The compositor may choose to continue\nto display the lock surfaces the client had mapped before it died or\nalternatively fall back to a solid color, this is compositor policy.\n\nCompositors may also allow a secure way to recover the session, the\ndetails of this are compositor policy. Compositors may allow a new\nclient to create a ext_session_lock_v1 object and take responsibility\nfor unlocking the session, they may even start a new lock client\ninstance automatically.\n\nSee also the [Event] enum for this interface.""destroy the session lock\n\nThis informs the compositor that the lock object will no longer be\nused. Existing objects created through this interface remain valid.\n\nAfter this request is made, lock surfaces created through this object\nshould be destroyed by the client as they will no longer be used by\nthe compositor.\n\nIt is a protocol error to make this request if the locked event was\nsent, the unlock_and_destroy request must be used instead."get_lock_surface"unlock the session, destroying the object\n\nThis request indicates that the session should be unlocked, for\nexample because the user has entered their password and it has been\nverified by the client.\n\nThis request also informs the compositor that the lock object will\nno longer be used and should be destroyed. Existing objects created\nthrough this interface remain valid.\n\nAfter this request is made, lock surfaces created through this object\nshould be destroyed by the client as they will no longer be used by\nthe compositor.\n\nIt is a protocol error to make this request if the locked event has\nnot been sent. In that case, the lock object must be destroyed using\nthe destroy request.\n\nNote that a correct client that wishes to exit directly after unlocking\nthe session must use the wl_display.sync request to ensure the server\nreceives and processes the unlock_and_destroy request. Otherwise\nthere is no guarantee that the server has unlocked the session due\nto the asynchronous nature of the Wayland protocol. For example,\nthe server might terminate the client with a protocol error before\nit processes the unlock_and_destroy request."unlock_and_destroy"a surface displayed while the session is locked\n\nThe client may use lock surfaces to display a screensaver, render a\ndialog to enter a password and unlock the session, or however else it\nsees fit.\n\nOn binding this interface the compositor will immediately send the\nfirst configure event. After making the ack_configure request in\nresponse to this event the client should attach and commit the first\nbuffer. Committing the surface before acking the first configure is a\nprotocol error. Committing the surface with a null buffer at any time\nis a protocol error.\n\nThe compositor is free to handle keyboard/pointer focus for lock\nsurfaces however it chooses. A reasonable way to do this would be to\ngive the first lock surface created keyboard focus and change keyboard\nfocus if the user clicks on other surfaces.""surface committed before first ack_configure request"CommitBeforeFirstAck"surface committed with a null buffer"NullBuffer"failed to match ack'd width/height"DimensionsMismatch"serial provided in ack_configure is invalid"InvalidSerialREQ_ACK_CONFIGURE_SINCEREQ_ACK_CONFIGURE_OPCODE"destroy the lock surface object\n\nThis informs the compositor that the lock surface object will no\nlonger be used.\n\nIt is recommended for a lock client to destroy lock surfaces if\ntheir corresponding wl_output global is removed.\n\nIf a lock surface on an active output is destroyed before the\next_session_lock_v1.unlock_and_destroy event is sent, the compositor\nmust fall back to rendering a solid color.\n\nThis is a destructor, once sent this object cannot be used any longer.""ack a configure event\n\nWhen a configure event is received, if a client commits the surface\nin response to the configure event, then the client must make an\nack_configure request sometime before the commit request, passing\nalong the serial of the configure event.\n\nIf the client receives multiple configure events before it can\nrespond to one, it only has to ack the last configure event.\n\nA client is not required to commit immediately after sending an\nack_configure request - it may even ack_configure several times\nbefore its next surface commit.\n\nA client may send multiple ack_configure requests before committing,\nbut only the last request sent before a commit indicates which\nconfigure event the client really is responding to.\n\nSending an ack_configure request consumes the configure event\nreferenced by the given serial, as well as all older configure events\nsent on this object.\n\nIt is a protocol error to issue multiple ack_configure requests\nreferencing the same configure event or to issue an ack_configure\nrequest referencing a configure event older than the last configure\nevent acked for a given lock surface.""serial from the configure event"AckConfigure"the client should resize its surface\n\nThis event is sent once on binding the interface and may be sent again\nat the compositor's discretion, for example if output geometry changes.\n\nThe width and height are in surface-local coordinates and are exact\nrequirements. Failing to match these surface dimensions in the next\ncommit after acking a configure is a protocol error.""serial for use in ack_configure""a surface displayed while the session is locked\n\nThe client may use lock surfaces to display a screensaver, render a\ndialog to enter a password and unlock the session, or however else it\nsees fit.\n\nOn binding this interface the compositor will immediately send the\nfirst configure event. After making the ack_configure request in\nresponse to this event the client should attach and commit the first\nbuffer. Committing the surface before acking the first configure is a\nprotocol error. Committing the surface with a null buffer at any time\nis a protocol error.\n\nThe compositor is free to handle keyboard/pointer focus for lock\nsurfaces however it chooses. A reasonable way to do this would be to\ngive the first lock surface created keyboard focus and change keyboard\nfocus if the user clicks on other surfaces.\n\nSee also the [Event] enum for this interface.""destroy the lock surface object\n\nThis informs the compositor that the lock surface object will no\nlonger be used.\n\nIt is recommended for a lock client to destroy lock surfaces if\ntheir corresponding wl_output global is removed.\n\nIf a lock surface on an active output is destroyed before the\next_session_lock_v1.unlock_and_destroy event is sent, the compositor\nmust fall back to rendering a solid color."ack_configure//! This protocol allows for a privileged Wayland client to lock the session//! and display arbitrary graphics while the session is locked.//! The compositor may choose to restrict this protocol to a special client//! launched by the compositor itself or expose it to all privileged clients,//! this is compositor policy.//! The client is responsible for performing authentication and informing the//! compositor when the session should be unlocked. If the client dies while//! the session is locked the session remains locked, possibly permanently//! depending on compositor policy.EXT_FOREIGN_TOPLEVEL_LIST_V1_INTERFACEext_foreign_toplevel_list_v1_requestsext_foreign_toplevel_list_v1_events_toplevel_typesext_foreign_toplevel_list_v1_eventsext_foreign_toplevel_list_v1_interfaceEXT_FOREIGN_TOPLEVEL_HANDLE_V1_INTERFACEext_foreign_toplevel_handle_v1_requestsext_foreign_toplevel_handle_v1_eventsext_foreign_toplevel_handle_v1_interface"list toplevels\n\nA toplevel is defined as a surface with a role similar to xdg_toplevel.\nXWayland surfaces may be treated like toplevels in this protocol.\n\nAfter a client binds the ext_foreign_toplevel_list_v1, each mapped\ntoplevel window will be sent using the ext_foreign_toplevel_list_v1.toplevel\nevent.\n\nClients which only care about the current state can perform a roundtrip after\nbinding this global.\n\nFor each instance of ext_foreign_toplevel_list_v1, the compositor must\ncreate a new ext_foreign_toplevel_handle_v1 object for each mapped toplevel.\n\nIf a compositor implementation sends the ext_foreign_toplevel_list_v1.finished\nevent after the global is bound, the compositor must not send any\next_foreign_toplevel_list_v1.toplevel events."REQ_STOP_SINCEREQ_STOP_OPCODEEVT_TOPLEVEL_SINCEEVT_TOPLEVEL_OPCODE"stop sending events\n\nThis request indicates that the client no longer wishes to receive\nevents for new toplevels.\n\nThe Wayland protocol is asynchronous, meaning the compositor may send\nfurther toplevel events until the stop request is processed.\nThe client should wait for a ext_foreign_toplevel_list_v1.finished\nevent before destroying this object.""destroy the ext_foreign_toplevel_list_v1 object\n\nThis request should be called either when the client will no longer\nuse the ext_foreign_toplevel_list_v1 or after the finished event\nhas been received to allow destruction of the object.\n\nIf a client wishes to destroy this object it should send a\next_foreign_toplevel_list_v1.stop request and wait for a ext_foreign_toplevel_list_v1.finished\nevent, then destroy the handles and then this object.\n\nThis is a destructor, once sent this object cannot be used any longer.""a toplevel has been created\n\nThis event is emitted whenever a new toplevel window is created. It is\nemitted for all toplevels, regardless of the app that has created them.\n\nAll initial properties of the toplevel (identifier, title, app_id) will be sent\nimmediately after this event using the corresponding events for\next_foreign_toplevel_handle_v1. The compositor will use the\next_foreign_toplevel_handle_v1.done event to indicate when all data has\nbeen sent.""the compositor has finished with the toplevel manager\n\nThis event indicates that the compositor is done sending events\nto this object. The client should destroy the object.\nSee ext_foreign_toplevel_list_v1.destroy for more information.\n\nThe compositor must not send any more toplevel events after this event.""list toplevels\n\nA toplevel is defined as a surface with a role similar to xdg_toplevel.\nXWayland surfaces may be treated like toplevels in this protocol.\n\nAfter a client binds the ext_foreign_toplevel_list_v1, each mapped\ntoplevel window will be sent using the ext_foreign_toplevel_list_v1.toplevel\nevent.\n\nClients which only care about the current state can perform a roundtrip after\nbinding this global.\n\nFor each instance of ext_foreign_toplevel_list_v1, the compositor must\ncreate a new ext_foreign_toplevel_handle_v1 object for each mapped toplevel.\n\nIf a compositor implementation sends the ext_foreign_toplevel_list_v1.finished\nevent after the global is bound, the compositor must not send any\next_foreign_toplevel_list_v1.toplevel events.\n\nSee also the [Event] enum for this interface.""destroy the ext_foreign_toplevel_list_v1 object\n\nThis request should be called either when the client will no longer\nuse the ext_foreign_toplevel_list_v1 or after the finished event\nhas been received to allow destruction of the object.\n\nIf a client wishes to destroy this object it should send a\next_foreign_toplevel_list_v1.stop request and wait for a ext_foreign_toplevel_list_v1.finished\nevent, then destroy the handles and then this object.""a mapped toplevel\n\nA ext_foreign_toplevel_handle_v1 object represents a mapped toplevel\nwindow. A single app may have multiple mapped toplevels."EVT_CLOSED_SINCEEVT_CLOSED_OPCODEEVT_TITLE_SINCEEVT_TITLE_OPCODEEVT_APP_ID_SINCEEVT_APP_ID_OPCODEEVT_IDENTIFIER_SINCEEVT_IDENTIFIER_OPCODE"destroy the ext_foreign_toplevel_handle_v1 object\n\nThis request should be used when the client will no longer use the handle\nor after the closed event has been received to allow destruction of the\nobject.\n\nWhen a handle is destroyed, a new handle may not be created by the server\nuntil the toplevel is unmapped and then remapped. Destroying a toplevel handle\nis not recommended unless the client is cleaning up child objects\nbefore destroying the ext_foreign_toplevel_list_v1 object, the toplevel\nwas closed or the toplevel handle will not be used in the future.\n\nOther protocols which extend the ext_foreign_toplevel_handle_v1\ninterface should require destructors for extension interfaces be\ncalled before allowing the toplevel handle to be destroyed.\n\nThis is a destructor, once sent this object cannot be used any longer.""the toplevel has been closed\n\nThe server will emit no further events on the ext_foreign_toplevel_handle_v1\nafter this event. Any requests received aside from the destroy request must\nbe ignored. Upon receiving this event, the client should destroy the handle.\n\nOther protocols which extend the ext_foreign_toplevel_handle_v1\ninterface must also ignore requests other than destructors.""all information about the toplevel has been sent\n\nThis event is sent after all changes in the toplevel state have\nbeen sent.\n\nThis allows changes to the ext_foreign_toplevel_handle_v1 properties\nto be atomically applied. Other protocols which extend the\next_foreign_toplevel_handle_v1 interface may use this event to also\natomically apply any pending state.\n\nThis event must not be sent after the ext_foreign_toplevel_handle_v1.closed\nevent.""title change\n\nThe title of the toplevel has changed.\n\nThe configured state must not be applied immediately. See\next_foreign_toplevel_handle_v1.done for details.""app_id change\n\nThe app id of the toplevel has changed.\n\nThe configured state must not be applied immediately. See\next_foreign_toplevel_handle_v1.done for details."AppId"a stable identifier for a toplevel\n\nThis identifier is used to check if two or more toplevel handles belong\nto the same toplevel.\n\nThe identifier is useful for command line tools or privileged clients\nwhich may need to reference an exact toplevel across processes or\ninstances of the ext_foreign_toplevel_list_v1 global.\n\nThe compositor must only send this event when the handle is created.\n\nThe identifier must be unique per toplevel and it's handles. Two different\ntoplevels must not have the same identifier. The identifier is only valid\nas long as the toplevel is mapped. If the toplevel is unmapped the identifier\nmust not be reused. An identifier must not be reused by the compositor to\nensure there are no races when sharing identifiers between processes.\n\nAn identifier is a string that contains up to 32 printable ASCII bytes.\nAn identifier must not be an empty string. It is recommended that a\ncompositor includes an opaque generation value in identifiers. How the\ngeneration value is used when generating the identifier is implementation\ndependent.""a mapped toplevel\n\nA ext_foreign_toplevel_handle_v1 object represents a mapped toplevel\nwindow. A single app may have multiple mapped toplevels.\n\nSee also the [Event] enum for this interface.""destroy the ext_foreign_toplevel_handle_v1 object\n\nThis request should be used when the client will no longer use the handle\nor after the closed event has been received to allow destruction of the\nobject.\n\nWhen a handle is destroyed, a new handle may not be created by the server\nuntil the toplevel is unmapped and then remapped. Destroying a toplevel handle\nis not recommended unless the client is cleaning up child objects\nbefore destroying the ext_foreign_toplevel_list_v1 object, the toplevel\nwas closed or the toplevel handle will not be used in the future.\n\nOther protocols which extend the ext_foreign_toplevel_handle_v1\ninterface should require destructors for extension interfaces be\ncalled before allowing the toplevel handle to be destroyed."//! The purpose of this protocol is to provide protocol object handles for toplevels, possibly//! originating from another client.//! This protocol is intentionally minimalistic and expects additional functionality (e.g.//! creating a screencopy source from a toplevel handle, getting information about the state of//! the toplevel) to be implemented in extension protocols.//! The compositor may choose to restrict this protocol to a special client launched by the//! compositor itself or expose it to all clients, this is compositor policy.EXT_TRANSIENT_SEAT_MANAGER_V1_INTERFACEext_transient_seat_manager_v1_requests_create_typesext_transient_seat_manager_v1_requestsext_transient_seat_manager_v1_interfaceEXT_TRANSIENT_SEAT_V1_INTERFACEext_transient_seat_v1_requestsext_transient_seat_v1_eventsext_transient_seat_v1_interface"transient seat manager\n\nThe transient seat manager creates short-lived seats."REQ_CREATE_SINCEREQ_CREATE_OPCODE"create a transient seat\n\nCreate a new seat that is removed when the client side transient seat\nobject is destroyed.\n\nThe actual seat may be removed sooner, in which case the transient seat\nobject shall become inert.""destroy the manager\n\nDestroy the manager.\n\nAll objects created by the manager will remain valid until they are\ndestroyed themselves.\n\nThis is a destructor, once sent this object cannot be used any longer.""transient seat manager\n\nThe transient seat manager creates short-lived seats.\n\nThis interface has no events."ExtTransientSeatManagerV1ext_transient_seat_v1ExtTransientSeatV1"destroy the manager\n\nDestroy the manager.\n\nAll objects created by the manager will remain valid until they are\ndestroyed themselves."ext_transient_seat_manager_v1"transient seat handle\n\nWhen the transient seat handle is destroyed, the seat itself will also be\ndestroyed."EVT_READY_SINCEEVT_READY_OPCODEEVT_DENIED_SINCEEVT_DENIED_OPCODE"destroy transient seat\n\nWhen the transient seat object is destroyed by the client, the\nassociated seat created by the compositor is also destroyed.\n\nThis is a destructor, once sent this object cannot be used any longer.""transient seat is ready\n\nThis event advertises the global name for the wl_seat to be used with\nwl_registry_bind.\n\nIt is sent exactly once, immediately after the transient seat is created\nand the new \"wl_seat\" global is advertised, if and only if the creation\nof the transient seat was allowed."global_name"transient seat creation denied\n\nThe event informs the client that the compositor denied its request to\ncreate a transient seat.\n\nIt is sent exactly once, immediately after the transient seat object is\ncreated, if and only if the creation of the transient seat was denied.\n\nAfter receiving this event, the client should destroy the object.""transient seat handle\n\nWhen the transient seat handle is destroyed, the seat itself will also be\ndestroyed.\n\nSee also the [Event] enum for this interface.""destroy transient seat\n\nWhen the transient seat object is destroyed by the client, the\nassociated seat created by the compositor is also destroyed."//! The transient seat protocol can be used by privileged clients to create//! independent seats that will be removed from the compositor when the client//! destroys its transient seat.//! This protocol is intended for use with virtual input protocols such as//! "virtual_keyboard_unstable_v1" or "wlr_virtual_pointer_unstable_v1", both//! of which allow the user to select a seat.//! The "wl_seat" global created by this protocol does not generate input events//! on its own, or have any capabilities except those assigned to it by other//! protocol extensions, such as the ones mentioned above.//! For example, a remote desktop server can create a seat with virtual inputs//! for each remote user by following these steps for each new connection://!  * Create a transient seat//!  * Wait for the transient seat to be created//!  * Locate a "wl_seat" global with a matching name//!  * Create virtual inputs using the resulting "wl_seat" globaltransient_seatEXT_IMAGE_CAPTURE_SOURCE_V1_INTERFACEext_image_capture_source_v1_requestsext_image_capture_source_v1_interfaceEXT_OUTPUT_IMAGE_CAPTURE_SOURCE_MANAGER_V1_INTERFACEext_output_image_capture_source_manager_v1_requests_create_source_typesext_output_image_capture_source_manager_v1_requestsext_output_image_capture_source_manager_v1_interfaceEXT_FOREIGN_TOPLEVEL_IMAGE_CAPTURE_SOURCE_MANAGER_V1_INTERFACEext_foreign_toplevel_image_capture_source_manager_v1_requests_create_source_typesext_foreign_toplevel_image_capture_source_manager_v1_requestsext_foreign_toplevel_image_capture_source_manager_v1_interface"opaque image capture source object\n\nThe image capture source object is an opaque descriptor for a capturable\nresource.  This resource may be any sort of entity from which an image\nmay be derived.\n\nNote, because ext_image_capture_source_v1 objects are created from multiple\nindependent factory interfaces, the ext_image_capture_source_v1 interface is\nfrozen at version 1.""delete this object\n\nDestroys the image capture source. This request may be sent at any time\nby the client.\n\nThis is a destructor, once sent this object cannot be used any longer.""opaque image capture source object\n\nThe image capture source object is an opaque descriptor for a capturable\nresource.  This resource may be any sort of entity from which an image\nmay be derived.\n\nNote, because ext_image_capture_source_v1 objects are created from multiple\nindependent factory interfaces, the ext_image_capture_source_v1 interface is\nfrozen at version 1.\n\nThis interface has no events."ExtImageCaptureSourceV1"delete this object\n\nDestroys the image capture source. This request may be sent at any time\nby the client."ext_image_capture_source_v1"image capture source manager for outputs\n\nA manager for creating image capture source objects for wl_output objects."REQ_CREATE_SOURCE_SINCEREQ_CREATE_SOURCE_OPCODE"create source object for output\n\nCreates a source object for an output. Images captured from this source\nwill show the same content as the output. Some elements may be omitted,\nsuch as cursors and overlays that have been marked as transparent to\ncapturing."CreateSource"delete this object\n\nDestroys the manager. This request may be sent at any time by the client\nand objects created by the manager will remain valid after its\ndestruction.\n\nThis is a destructor, once sent this object cannot be used any longer.""image capture source manager for outputs\n\nA manager for creating image capture source objects for wl_output objects.\n\nThis interface has no events."ExtOutputImageCaptureSourceManagerV1"delete this object\n\nDestroys the manager. This request may be sent at any time by the client\nand objects created by the manager will remain valid after its\ndestruction."ext_output_image_capture_source_manager_v1"image capture source manager for foreign toplevels\n\nA manager for creating image capture source objects for\next_foreign_toplevel_handle_v1 objects.""create source object for foreign toplevel\n\nCreates a source object for a foreign toplevel handle. Images captured\nfrom this source will show the same content as the toplevel."toplevel_handle"image capture source manager for foreign toplevels\n\nA manager for creating image capture source objects for\next_foreign_toplevel_handle_v1 objects.\n\nThis interface has no events."ExtForeignToplevelImageCaptureSourceManagerV1ext_foreign_toplevel_image_capture_source_manager_v1//! This protocol serves as an intermediary between capturing protocols and//! potential image capture sources such as outputs and toplevels.//! This protocol may be extended to support more image capture sources in the//! future, thereby adding those image capture sources to other protocols that//! use the image capture source object without having to modify thoseimage_capture_sourceEXT_IMAGE_COPY_CAPTURE_MANAGER_V1_INTERFACEext_image_copy_capture_manager_v1_requests_create_session_typesext_image_copy_capture_manager_v1_requests_create_pointer_cursor_session_typesext_image_copy_capture_manager_v1_requestsext_image_copy_capture_manager_v1_interfaceEXT_IMAGE_COPY_CAPTURE_SESSION_V1_INTERFACEext_image_copy_capture_session_v1_requests_create_frame_typesext_image_copy_capture_session_v1_requestsext_image_copy_capture_session_v1_eventsext_image_copy_capture_session_v1_interfaceEXT_IMAGE_COPY_CAPTURE_FRAME_V1_INTERFACEext_image_copy_capture_frame_v1_requests_attach_buffer_typesext_image_copy_capture_frame_v1_requestsext_image_copy_capture_frame_v1_eventsext_image_copy_capture_frame_v1_interfaceEXT_IMAGE_COPY_CAPTURE_CURSOR_SESSION_V1_INTERFACEext_image_copy_capture_cursor_session_v1_requests_get_capture_session_typesext_image_copy_capture_cursor_session_v1_requestsext_image_copy_capture_cursor_session_v1_eventsext_image_copy_capture_cursor_session_v1_interface"manager to inform clients and begin capturing\n\nThis object is a manager which offers requests to start capturing from a\nsource.""invalid option flag"InvalidOption"paint cursors onto captured frames"PaintCursorsREQ_CREATE_SESSION_SINCEREQ_CREATE_SESSION_OPCODEREQ_CREATE_POINTER_CURSOR_SESSION_SINCEREQ_CREATE_POINTER_CURSOR_SESSION_OPCODE"capture an image capture source\n\nCreate a capturing session for an image capture source.\n\nIf the paint_cursors option is set, cursors shall be composited onto\nthe captured frame. The cursor must not be composited onto the frame\nif this flag is not set.\n\nIf the options bitfield is invalid, the invalid_option protocol error\nis sent."CreateSession"capture the pointer cursor of an image capture source\n\nCreate a cursor capturing session for the pointer of an image capture\nsource."CreatePointerCursorSession"destroy the manager\n\nDestroy the manager object.\n\nOther objects created via this interface are unaffected.\n\nThis is a destructor, once sent this object cannot be used any longer.""manager to inform clients and begin capturing\n\nThis object is a manager which offers requests to start capturing from a\nsource.\n\nThis interface has no events."ExtImageCopyCaptureManagerV1ext_image_copy_capture_session_v1ExtImageCopyCaptureSessionV1create_sessionext_image_copy_capture_cursor_session_v1ExtImageCopyCaptureCursorSessionV1create_pointer_cursor_session"destroy the manager\n\nDestroy the manager object.\n\nOther objects created via this interface are unaffected."ext_image_copy_capture_manager_v1"image copy capture session\n\nThis object represents an active image copy capture session.\n\nAfter a capture session is created, buffer constraint events will be\nemitted from the compositor to tell the client which buffer types and\nformats are supported for reading from the session. The compositor may\nre-send buffer constraint events whenever they change.\n\nTo advertise buffer constraints, the compositor must send in no\nparticular order: zero or more shm_format and dmabuf_format events, zero\nor one dmabuf_device event, and exactly one buffer_size event. Then the\ncompositor must send a done event.\n\nWhen the client has received all the buffer constraints, it can create a\nbuffer accordingly, attach it to the capture session using the\nattach_buffer request, set the buffer damage using the damage_buffer\nrequest and then send the capture request.""create_frame sent before destroying previous frame"DuplicateFrameREQ_CREATE_FRAME_SINCEREQ_CREATE_FRAME_OPCODEEVT_BUFFER_SIZE_SINCEEVT_BUFFER_SIZE_OPCODEEVT_SHM_FORMAT_SINCEEVT_SHM_FORMAT_OPCODEEVT_DMABUF_DEVICE_SINCEEVT_DMABUF_DEVICE_OPCODEEVT_DMABUF_FORMAT_SINCEEVT_DMABUF_FORMAT_OPCODEEVT_STOPPED_SINCEEVT_STOPPED_OPCODE"create a frame\n\nCreate a capture frame for this session.\n\nAt most one frame object can exist for a given session at any time. If\na client sends a create_frame request before a previous frame object\nhas been destroyed, the duplicate_frame protocol error is raised."CreateFrame"delete this object\n\nDestroys the session. This request can be sent at any time by the\nclient.\n\nThis request doesn't affect ext_image_copy_capture_frame_v1 objects created by\nthis object.\n\nThis is a destructor, once sent this object cannot be used any longer.""image capture source dimensions\n\nProvides the dimensions of the source image in buffer pixel coordinates.\n\nThe client must attach buffers that match this size.""buffer width""buffer height""shm buffer format\n\nProvides the format that must be used for shared-memory buffers.\n\nThis event may be emitted multiple times, in which case the client may\nchoose any given format.""shm format"ShmFormat"dma-buf device\n\nThis event advertises the device buffers must be allocated on for\ndma-buf buffers.\n\nIn general the device is a DRM node. The DRM node type (primary vs.\nrender) is unspecified. Clients must not rely on the compositor sending\na particular node type. Clients cannot check two devices for equality\nby comparing the dev_t value.""device dev_t value"DmabufDevice"dma-buf format\n\nProvides the format that must be used for dma-buf buffers.\n\nThe client may choose any of the modifiers advertised in the array of\n64-bit unsigned integers.\n\nThis event may be emitted multiple times, in which case the client may\nchoose any given format.""drm format code""drm format modifiers""all constraints have been sent\n\nThis event is sent once when all buffer constraint events have been\nsent.\n\nThe compositor must always end a batch of buffer constraint events with\nthis event, regardless of whether it sends the initial constraints or\nan update.""session is no longer available\n\nThis event indicates that the capture session has stopped and is no\nlonger available. This can happen in a number of cases, e.g. when the\nunderlying source is destroyed, if the user decides to end the image\ncapture, or if an unrecoverable runtime error has occurred.\n\nThe client should destroy the session after receiving this event.""image copy capture session\n\nThis object represents an active image copy capture session.\n\nAfter a capture session is created, buffer constraint events will be\nemitted from the compositor to tell the client which buffer types and\nformats are supported for reading from the session. The compositor may\nre-send buffer constraint events whenever they change.\n\nTo advertise buffer constraints, the compositor must send in no\nparticular order: zero or more shm_format and dmabuf_format events, zero\nor one dmabuf_device event, and exactly one buffer_size event. Then the\ncompositor must send a done event.\n\nWhen the client has received all the buffer constraints, it can create a\nbuffer accordingly, attach it to the capture session using the\nattach_buffer request, set the buffer damage using the damage_buffer\nrequest and then send the capture request.\n\nSee also the [Event] enum for this interface."ext_image_copy_capture_frame_v1ExtImageCopyCaptureFrameV1create_frame"delete this object\n\nDestroys the session. This request can be sent at any time by the\nclient.\n\nThis request doesn't affect ext_image_copy_capture_frame_v1 objects created by\nthis object.""image capture frame\n\nThis object represents an image capture frame.\n\nThe client should attach a buffer, damage the buffer, and then send a\ncapture request.\n\nIf the capture is successful, the compositor must send the frame metadata\n(transform, damage, presentation_time in any order) followed by the ready\nevent.\n\nIf the capture fails, the compositor must send the failed event.""capture sent without attach_buffer"NoBuffer"invalid buffer damage"InvalidBufferDamage"capture request has been sent"AlreadyCapturedFailureReason"unknown runtime error\n\nAn unspecified runtime error has occurred. The client may retry.""buffer constraints mismatch\n\nThe buffer submitted by the client doesn't match the latest session\nconstraints. The client should re-allocate its buffers and retry."BufferConstraints"session is no longer available\n\nThe session has stopped. See ext_image_copy_capture_session_v1.stopped."REQ_ATTACH_BUFFER_SINCEREQ_ATTACH_BUFFER_OPCODEREQ_CAPTURE_SINCEREQ_CAPTURE_OPCODEEVT_TRANSFORM_SINCEEVT_TRANSFORM_OPCODEEVT_DAMAGE_SINCEEVT_DAMAGE_OPCODEEVT_PRESENTATION_TIME_SINCEEVT_PRESENTATION_TIME_OPCODEEVT_FAILED_SINCEEVT_FAILED_OPCODE"destroy this object\n\nDestroys the frame. This request can be sent at any time by the\nclient.\n\nThis is a destructor, once sent this object cannot be used any longer.""attach buffer to session\n\nAttach a buffer to the session.\n\nThe wl_buffer.release request is unused.\n\nThe new buffer replaces any previously attached buffer.\n\nThis request must not be sent after capture, or else the\nalready_captured protocol error is raised."AttachBuffer"damage buffer\n\nApply damage to the buffer which is to be captured next. This request\nmay be sent multiple times to describe a region.\n\nThe client indicates the accumulated damage since this wl_buffer was\nlast captured. During capture, the compositor will update the buffer\nwith at least the union of the region passed by the client and the\nregion advertised by ext_image_copy_capture_frame_v1.damage.\n\nWhen a wl_buffer is captured for the first time, or when the client\ndoesn't track damage, the client must damage the whole buffer.\n\nThis is for optimisation purposes. The compositor may use this\ninformation to reduce copying.\n\nThese coordinates originate from the upper left corner of the buffer.\n\nIf x or y are strictly negative, or if width or height are negative or\nzero, the invalid_buffer_damage protocol error is raised.\n\nThis request must not be sent after capture, or else the\nalready_captured protocol error is raised.""region x coordinate""region y coordinate""region width""region height""capture a frame\n\nCapture a frame.\n\nUnless this is the first successful captured frame performed in this\nsession, the compositor may wait an indefinite amount of time for the\nsource content to change before performing the copy.\n\nThis request may only be sent once, or else the already_captured\nprotocol error is raised. A buffer must be attached before this request\nis sent, or else the no_buffer protocol error is raised.""buffer transform\n\nThis event is sent before the ready event and holds the transform that\nthe compositor has applied to the buffer contents.""buffer damaged region\n\nThis event is sent before the ready event. It may be generated multiple\ntimes to describe a region.\n\nThe first captured frame in a session will always carry full damage.\nSubsequent frames' damaged regions describe which parts of the buffer\nhave changed since the last ready event.\n\nThese coordinates originate in the upper left corner of the buffer.""damage x coordinate""damage y coordinate""damage width""damage height""presentation time of the frame\n\nThis event indicates the time at which the frame is presented to the\noutput in system monotonic time. This event is sent before the ready\nevent.\n\nThe timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,\neach component being an unsigned 32-bit value. Whole seconds are in\ntv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,\nand the additional fractional part in tv_nsec as nanoseconds. Hence,\nfor valid timestamps tv_nsec must be in [0, 999999999].""high 32 bits of the seconds part of the timestamp"tv_sec_hi"low 32 bits of the seconds part of the timestamp"tv_sec_lo"nanoseconds part of the timestamp"PresentationTime"frame is available for reading\n\nCalled as soon as the frame is copied, indicating it is available\nfor reading.\n\nThe buffer may be re-used by the client after this event.\n\nAfter receiving this event, the client must destroy the object.""capture failed\n\nThis event indicates that the attempted frame copy has failed.\n\nAfter receiving this event, the client must destroy the object.""image capture frame\n\nThis object represents an image capture frame.\n\nThe client should attach a buffer, damage the buffer, and then send a\ncapture request.\n\nIf the capture is successful, the compositor must send the frame metadata\n(transform, damage, presentation_time in any order) followed by the ready\nevent.\n\nIf the capture fails, the compositor must send the failed event.\n\nSee also the [Event] enum for this interface.""destroy this object\n\nDestroys the frame. This request can be sent at any time by the\nclient."attach_buffer"cursor capture session\n\nThis object represents a cursor capture session. It extends the base\ncapture session with cursor-specific metadata.""get_capture_session sent twice"DuplicateSessionREQ_GET_CAPTURE_SESSION_SINCEREQ_GET_CAPTURE_SESSION_OPCODEEVT_POSITION_SINCEEVT_POSITION_OPCODEEVT_HOTSPOT_SINCEEVT_HOTSPOT_OPCODE"get image copy capturer session\n\nGets the image copy capture session for this cursor session.\n\nThe session will produce frames of the cursor image. The compositor may\npause the session when the cursor leaves the captured area.\n\nThis request must not be sent more than once, or else the\nduplicate_session protocol error is raised."GetCaptureSession"cursor entered captured area\n\nSent when a cursor enters the captured area. It shall be generated\nbefore the \"position\" and \"hotspot\" events when and only when a cursor\nenters the area.\n\nThe cursor enters the captured area when the cursor image intersects\nwith the captured area. Note, this is different from e.g.\nwl_pointer.enter.""cursor left captured area\n\nSent when a cursor leaves the captured area. No \"position\" or \"hotspot\"\nevent is generated for the cursor until the cursor enters the captured\narea again.""position changed\n\nCursors outside the image capture source do not get captured and no\nevent will be generated for them.\n\nThe given position is the position of the cursor's hotspot and it is\nrelative to the main buffer's top left corner in transformed buffer\npixel coordinates. The coordinates may be negative or greater than the\nmain buffer size.""position x coordinates""position y coordinates""hotspot changed\n\nThe hotspot describes the offset between the cursor image and the\nposition of the input device.\n\nThe given coordinates are the hotspot's offset from the origin in\nbuffer coordinates.\n\nClients should not apply the hotspot immediately: the hotspot becomes\neffective when the next ext_image_copy_capture_frame_v1.ready event is received.\n\nCompositors may delay this event until the client captures a new frame.""hotspot x coordinates""hotspot y coordinates"Hotspot"cursor capture session\n\nThis object represents a cursor capture session. It extends the base\ncapture session with cursor-specific metadata.\n\nSee also the [Event] enum for this interface."get_capture_session//! This protocol allows clients to ask the compositor to capture image sources//! such as outputs and toplevels into user submitted buffers.image_copy_captureEXT_DATA_CONTROL_MANAGER_V1_INTERFACEext_data_control_manager_v1_requests_create_data_source_typesext_data_control_manager_v1_requests_get_data_device_typesext_data_control_manager_v1_requestsext_data_control_manager_v1_interfaceEXT_DATA_CONTROL_DEVICE_V1_INTERFACEext_data_control_device_v1_requests_set_selection_typesext_data_control_device_v1_requests_set_primary_selection_typesext_data_control_device_v1_requestsext_data_control_device_v1_events_data_offer_typesext_data_control_device_v1_events_selection_typesext_data_control_device_v1_events_primary_selection_typesext_data_control_device_v1_eventsext_data_control_device_v1_interfaceEXT_DATA_CONTROL_SOURCE_V1_INTERFACEext_data_control_source_v1_requestsext_data_control_source_v1_eventsext_data_control_source_v1_interfaceEXT_DATA_CONTROL_OFFER_V1_INTERFACEext_data_control_offer_v1_requestsext_data_control_offer_v1_eventsext_data_control_offer_v1_interface"manager to control data devices\n\nThis interface is a manager that allows creating per-seat data device\ncontrols.""get a data device for a seat\n\nCreate a data device that can be used to manage a seat's selection.""destroy the manager\n\nAll objects created by the manager will still remain valid, until their\nappropriate destroy request has been called.\n\nThis is a destructor, once sent this object cannot be used any longer.""manager to control data devices\n\nThis interface is a manager that allows creating per-seat data device\ncontrols.\n\nThis interface has no events."ExtDataControlManagerV1ext_data_control_source_v1ExtDataControlSourceV1ext_data_control_device_v1ExtDataControlDeviceV1"destroy the manager\n\nAll objects created by the manager will still remain valid, until their\nappropriate destroy request has been called."ext_data_control_manager_v1"manage a data device for a seat\n\nThis interface allows a client to manage a seat's selection.\n\nWhen the seat is destroyed, this object becomes inert.""source given to set_selection or set_primary_selection was already used before"REQ_SET_PRIMARY_SELECTION_SINCEREQ_SET_PRIMARY_SELECTION_OPCODEEVT_PRIMARY_SELECTION_SINCEEVT_PRIMARY_SELECTION_OPCODE"copy data to the selection\n\nThis request asks the compositor to set the selection to the data from\nthe source on behalf of the client.\n\nThe given source may not be used in any further set_selection or\nset_primary_selection requests. Attempting to use a previously used\nsource triggers the used_source protocol error.\n\nTo unset the selection, set the source to NULL.""destroy this data device\n\nDestroys the data device object.\n\nThis is a destructor, once sent this object cannot be used any longer.""copy data to the primary selection\n\nThis request asks the compositor to set the primary selection to the\ndata from the source on behalf of the client.\n\nThe given source may not be used in any further set_selection or\nset_primary_selection requests. Attempting to use a previously used\nsource triggers the used_source protocol error.\n\nTo unset the primary selection, set the source to NULL.\n\nThe compositor will ignore this request if it does not support primary\nselection."SetPrimarySelection"introduce a new ext_data_control_offer\n\nThe data_offer event introduces a new ext_data_control_offer object,\nwhich will subsequently be used in either the\next_data_control_device.selection event (for the regular clipboard\nselections) or the ext_data_control_device.primary_selection event (for\nthe primary clipboard selections). Immediately following the\next_data_control_device.data_offer event, the new data_offer object\nwill send out ext_data_control_offer.offer events to describe the MIME\ntypes it offers."ext_data_control_offer_v1ExtDataControlOfferV1"advertise new selection\n\nThe selection event is sent out to notify the client of a new\next_data_control_offer for the selection for this device. The\next_data_control_device.data_offer and the ext_data_control_offer.offer\nevents are sent out immediately before this event to introduce the data\noffer object. The selection event is sent to a client when a new\nselection is set. The ext_data_control_offer is valid until a new\next_data_control_offer or NULL is received. The client must destroy the\nprevious selection ext_data_control_offer, if any, upon receiving this\nevent. Regardless, the previous selection will be ignored once a new\nselection ext_data_control_offer is received.\n\nThe first selection event is sent upon binding the\next_data_control_device object.""this data control is no longer valid\n\nThis data control object is no longer valid and should be destroyed by\nthe client.""advertise new primary selection\n\nThe primary_selection event is sent out to notify the client of a new\next_data_control_offer for the primary selection for this device. The\next_data_control_device.data_offer and the ext_data_control_offer.offer\nevents are sent out immediately before this event to introduce the data\noffer object. The primary_selection event is sent to a client when a\nnew primary selection is set. The ext_data_control_offer is valid until\na new ext_data_control_offer or NULL is received. The client must\ndestroy the previous primary selection ext_data_control_offer, if any,\nupon receiving this event. Regardless, the previous primary selection\nwill be ignored once a new primary selection ext_data_control_offer is\nreceived.\n\nIf the compositor supports primary selection, the first\nprimary_selection event is sent upon binding the\next_data_control_device object."PrimarySelection"manage a data device for a seat\n\nThis interface allows a client to manage a seat's selection.\n\nWhen the seat is destroyed, this object becomes inert.\n\nSee also the [Event] enum for this interface.""destroy this data device\n\nDestroys the data device object."set_primary_selection"offer to transfer data\n\nThe ext_data_control_source object is the source side of a\next_data_control_offer. It is created by the source client in a data\ntransfer and provides a way to describe the offered data and a way to\nrespond to requests to transfer the data.""offer sent after ext_data_control_device.set_selection""add an offered MIME type\n\nThis request adds a MIME type to the set of MIME types advertised to\ntargets. Can be called several times to offer multiple types.\n\nCalling this after ext_data_control_device.set_selection is a protocol\nerror.""MIME type offered by the data source""destroy this source\n\nDestroys the data source object.\n\nThis is a destructor, once sent this object cannot be used any longer.""send the data\n\nRequest for data from the client. Send the data as the specified MIME\ntype over the passed file descriptor, then close it.""MIME type for the data""selection was cancelled\n\nThis data source is no longer valid. The data source has been replaced\nby another data source.\n\nThe client should clean up and destroy this data source.""offer to transfer data\n\nThe ext_data_control_source object is the source side of a\next_data_control_offer. It is created by the source client in a data\ntransfer and provides a way to describe the offered data and a way to\nrespond to requests to transfer the data.\n\nSee also the [Event] enum for this interface.""destroy this source\n\nDestroys the data source object.""offer to transfer data\n\nA ext_data_control_offer represents a piece of data offered for transfer\nby another client (the source client). The offer describes the different\nMIME types that the data can be converted to and provides the mechanism\nfor transferring the data directly from the source client.""request that the data is transferred\n\nTo transfer the offered data, the client issues this request and\nindicates the MIME type it wants to receive. The transfer happens\nthrough the passed file descriptor (typically created with the pipe\nsystem call). The source client writes the data in the MIME type\nrepresentation requested and then closes the file descriptor.\n\nThe receiving client reads from the read end of the pipe until EOF and\nthen closes its end, at which point the transfer is complete.\n\nThis request may happen multiple times for different MIME types.""MIME type desired by receiver""destroy this offer\n\nDestroys the data offer object.\n\nThis is a destructor, once sent this object cannot be used any longer.""advertise offered MIME type\n\nSent immediately after creating the ext_data_control_offer object.\nOne event per offered MIME type.""offered MIME type""offer to transfer data\n\nA ext_data_control_offer represents a piece of data offered for transfer\nby another client (the source client). The offer describes the different\nMIME types that the data can be converted to and provides the mechanism\nfor transferring the data directly from the source client.\n\nSee also the [Event] enum for this interface.""destroy this offer\n\nDestroys the data offer object."//! This protocol allows a privileged client to control data devices. In//! particular, the client will be able to manage the current selection and take//! the role of a clipboard manager.EXT_WORKSPACE_MANAGER_V1_INTERFACEext_workspace_manager_v1_requestsext_workspace_manager_v1_events_workspace_group_typesext_workspace_manager_v1_events_workspace_typesext_workspace_manager_v1_eventsext_workspace_manager_v1_interfaceEXT_WORKSPACE_GROUP_HANDLE_V1_INTERFACEext_workspace_group_handle_v1_requestsext_workspace_group_handle_v1_events_output_enter_typesext_workspace_group_handle_v1_events_output_leave_typesext_workspace_group_handle_v1_events_workspace_enter_typesext_workspace_group_handle_v1_events_workspace_leave_typesext_workspace_group_handle_v1_eventsext_workspace_group_handle_v1_interfaceEXT_WORKSPACE_HANDLE_V1_INTERFACEext_workspace_handle_v1_requests_assign_typesext_workspace_handle_v1_requestsext_workspace_handle_v1_eventsext_workspace_handle_v1_interface"list and control workspaces\n\nWorkspaces, also called virtual desktops, are groups of surfaces. A\ncompositor with a concept of workspaces may only show some such groups of\nsurfaces (those of 'active' workspaces) at a time.\u{a0}'Activating' a\nworkspace is a request for the compositor to display that workspace's\nsurfaces as normal, whereas the compositor may hide or otherwise\nde-emphasise surfaces that are associated only with 'inactive' workspaces.\nWorkspaces are grouped by which sets of outputs they correspond to, and\nmay contain surfaces only from those outputs. In this way, it is possible\nfor each output to have its own set of workspaces, or for all outputs (or\nany other arbitrary grouping) to share workspaces. Compositors may\noptionally conceptually arrange each group of workspaces in an\nN-dimensional grid.\n\nThe purpose of this protocol is to enable the creation of taskbars and\ndocks by providing them with a list of workspaces and their properties,\nand allowing them to activate and deactivate workspaces.\n\nAfter a client binds the ext_workspace_manager_v1, each workspace will be\nsent via the workspace event."EVT_WORKSPACE_GROUP_SINCEEVT_WORKSPACE_GROUP_OPCODEEVT_WORKSPACE_SINCEEVT_WORKSPACE_OPCODE"all requests about the workspaces have been sent\n\nThe client must send this request after it has finished sending other\nrequests. The compositor must process a series of requests preceding a\ncommit request atomically.\n\nThis allows changes to the workspace properties to be seen as atomic,\neven if they happen via multiple events, and even if they involve\nmultiple ext_workspace_handle_v1 objects, for example, deactivating one\nworkspace and activating another.""stop sending events\n\nIndicates the client no longer wishes to receive events for new\nworkspace groups. However the compositor may emit further workspace\nevents, until the finished event is emitted. The compositor is expected\nto send the finished event eventually once the stop request has been processed.\n\nThe client must not send any requests after this one, doing so will raise a wl_display\ninvalid_object error.""a workspace group has been created\n\nThis event is emitted whenever a new workspace group has been created.\n\nAll initial details of the workspace group (outputs) will be\nsent immediately after this event via the corresponding events in\next_workspace_group_handle_v1 and ext_workspace_handle_v1."workspace_groupext_workspace_group_handle_v1ExtWorkspaceGroupHandleV1WorkspaceGroup"workspace has been created\n\nThis event is emitted whenever a new workspace has been created.\n\nAll initial details of the workspace (name, coordinates, state) will\nbe sent immediately after this event via the corresponding events in\next_workspace_handle_v1.\n\nWorkspaces start off unassigned to any workspace group."workspaceext_workspace_handle_v1ExtWorkspaceHandleV1Workspace"all information about the workspaces and workspace groups has been sent\n\nThis event is sent after all changes in all workspaces and workspace groups have been\nsent.\n\nThis allows changes to one or more ext_workspace_group_handle_v1\nproperties and ext_workspace_handle_v1 properties\nto be seen as atomic, even if they happen via multiple events.\nIn particular, an output moving from one workspace group to\nanother sends an output_enter event and an output_leave event to the two\next_workspace_group_handle_v1 objects in question. The compositor sends\nthe done event only after updating the output information in both\nworkspace groups.""the compositor has finished with the workspace_manager\n\nThis event indicates that the compositor is done sending events to the\next_workspace_manager_v1. The server will destroy the object\nimmediately after sending this request.\n\nThis is a destructor, once received this object cannot be used any longer.""list and control workspaces\n\nWorkspaces, also called virtual desktops, are groups of surfaces. A\ncompositor with a concept of workspaces may only show some such groups of\nsurfaces (those of 'active' workspaces) at a time.\u{a0}'Activating' a\nworkspace is a request for the compositor to display that workspace's\nsurfaces as normal, whereas the compositor may hide or otherwise\nde-emphasise surfaces that are associated only with 'inactive' workspaces.\nWorkspaces are grouped by which sets of outputs they correspond to, and\nmay contain surfaces only from those outputs. In this way, it is possible\nfor each output to have its own set of workspaces, or for all outputs (or\nany other arbitrary grouping) to share workspaces. Compositors may\noptionally conceptually arrange each group of workspaces in an\nN-dimensional grid.\n\nThe purpose of this protocol is to enable the creation of taskbars and\ndocks by providing them with a list of workspaces and their properties,\nand allowing them to activate and deactivate workspaces.\n\nAfter a client binds the ext_workspace_manager_v1, each workspace will be\nsent via the workspace event.\n\nSee also the [Event] enum for this interface."ExtWorkspaceManagerV1ext_workspace_manager_v1"a workspace group assigned to a set of outputs\n\nA ext_workspace_group_handle_v1 object represents a workspace group\nthat is assigned a set of outputs and contains a number of workspaces.\n\nThe set of outputs assigned to the workspace group is conveyed to the client via\noutput_enter and output_leave events, and its workspaces are conveyed with\nworkspace events.\n\nFor example, a compositor which has a set of workspaces for each output may\nadvertise a workspace group (and its workspaces) per output, whereas a compositor\nwhere a workspace spans all outputs may advertise a single workspace group for all\noutputs."GroupCapabilities"create_workspace request is available"CreateWorkspaceREQ_CREATE_WORKSPACE_SINCEREQ_CREATE_WORKSPACE_OPCODEEVT_OUTPUT_ENTER_SINCEEVT_OUTPUT_ENTER_OPCODEEVT_OUTPUT_LEAVE_SINCEEVT_OUTPUT_LEAVE_OPCODEEVT_WORKSPACE_ENTER_SINCEEVT_WORKSPACE_ENTER_OPCODEEVT_WORKSPACE_LEAVE_SINCEEVT_WORKSPACE_LEAVE_OPCODEEVT_REMOVED_SINCEEVT_REMOVED_OPCODE"create a new workspace\n\nRequest that the compositor create a new workspace with the given name\nand assign it to this group.\n\nThere is no guarantee that the compositor will create a new workspace,\nor that the created workspace will have the provided name.""destroy the ext_workspace_group_handle_v1 object\n\nDestroys the ext_workspace_group_handle_v1 object.\n\nThis request should be send either when the client does not want to\nuse the workspace group object any more or after the removed event to finalize\nthe destruction of the object.\n\nThis is a destructor, once sent this object cannot be used any longer.""compositor capabilities\n\nThis event advertises the capabilities supported by the compositor. If\na capability isn't supported, clients should hide or disable the UI\nelements that expose this functionality. For instance, if the\ncompositor doesn't advertise support for creating workspaces, a button\ntriggering the create_workspace request should not be displayed.\n\nThe compositor will ignore requests it doesn't support. For instance,\na compositor which doesn't advertise support for creating workspaces will ignore\ncreate_workspace requests.\n\nCompositors must send this event once after creation of an\next_workspace_group_handle_v1. When the capabilities change, compositors\nmust send this event again.""capabilities""output assigned to workspace group\n\nThis event is emitted whenever an output is assigned to the workspace\ngroup or a new `wl_output` object is bound by the client, which was already\nassigned to this workspace_group."OutputEnter"output removed from workspace group\n\nThis event is emitted whenever an output is removed from the workspace\ngroup."OutputLeave"workspace added to workspace group\n\nThis event is emitted whenever a workspace is assigned to this group.\nA workspace may only ever be assigned to a single group at a single point\nin time, but can be re-assigned during it's lifetime."WorkspaceEnter"workspace removed from workspace group\n\nThis event is emitted whenever a workspace is removed from this group."WorkspaceLeave"this workspace group has been removed\n\nThis event is send when the group associated with the ext_workspace_group_handle_v1\nhas been removed. After sending this request the compositor will immediately consider\nthe object inert. Any requests will be ignored except the destroy request.\nIt is guaranteed there won't be any more events referencing this\next_workspace_group_handle_v1.\n\nThe compositor must remove all workspaces belonging to a workspace group\nvia a workspace_leave event before removing the workspace group.""a workspace group assigned to a set of outputs\n\nA ext_workspace_group_handle_v1 object represents a workspace group\nthat is assigned a set of outputs and contains a number of workspaces.\n\nThe set of outputs assigned to the workspace group is conveyed to the client via\noutput_enter and output_leave events, and its workspaces are conveyed with\nworkspace events.\n\nFor example, a compositor which has a set of workspaces for each output may\nadvertise a workspace group (and its workspaces) per output, whereas a compositor\nwhere a workspace spans all outputs may advertise a single workspace group for all\noutputs.\n\nSee also the [Event] enum for this interface."create_workspace"destroy the ext_workspace_group_handle_v1 object\n\nDestroys the ext_workspace_group_handle_v1 object.\n\nThis request should be send either when the client does not want to\nuse the workspace group object any more or after the removed event to finalize\nthe destruction of the object.""a workspace handing a group of surfaces\n\nA ext_workspace_handle_v1 object represents a workspace that handles a\ngroup of surfaces.\n\nEach workspace has:\n- a name, conveyed to the client with the name event\n- potentially an id conveyed with the id event\n- a list of states, conveyed to the client with the state event\n- and optionally a set of coordinates, conveyed to the client with the\ncoordinates event\n\nThe client may request that the compositor activate or deactivate the workspace.\n\nEach workspace can belong to only a single workspace group.\nDepending on the compositor policy, there might be workspaces with\nthe same name in different workspace groups, but these workspaces are still\nseparate (e.g. one of them might be active while the other is not).""types of states on the workspace\n\nThe different states that a workspace can have.""the workspace is active""the workspace requests attention""the workspace is not visible\n\nThe workspace is not visible in its workspace group, and clients\nattempting to visualize the compositor workspace state should not\ndisplay such workspaces."WorkspaceCapabilities"activate request is available"Activate"deactivate request is available"Deactivate"remove request is available""assign request is available"REQ_ACTIVATE_SINCEREQ_ACTIVATE_OPCODEREQ_DEACTIVATE_SINCEREQ_DEACTIVATE_OPCODEREQ_ASSIGN_SINCEREQ_ASSIGN_OPCODEREQ_REMOVE_SINCEREQ_REMOVE_OPCODEEVT_ID_SINCEEVT_ID_OPCODEEVT_COORDINATES_SINCEEVT_COORDINATES_OPCODEEVT_STATE_SINCEEVT_STATE_OPCODE"destroy the ext_workspace_handle_v1 object\n\nDestroys the ext_workspace_handle_v1 object.\n\nThis request should be made either when the client does not want to\nuse the workspace object any more or after the remove event to finalize\nthe destruction of the object.\n\nThis is a destructor, once sent this object cannot be used any longer.""activate the workspace\n\nRequest that this workspace be activated.\n\nThere is no guarantee the workspace will be actually activated, and\nbehaviour may be compositor-dependent. For example, activating a\nworkspace may or may not deactivate all other workspaces in the same\ngroup.""deactivate the workspace\n\nRequest that this workspace be deactivated.\n\nThere is no guarantee the workspace will be actually deactivated.""assign workspace to group\n\nRequests that this workspace is assigned to the given workspace group.\n\nThere is no guarantee the workspace will be assigned.""remove the workspace\n\nRequest that this workspace be removed.\n\nThere is no guarantee the workspace will be actually removed.""workspace id\n\nIf this event is emitted, it will be send immediately after the\next_workspace_handle_v1 is created or when an id is assigned to\na workspace (at most once during it's lifetime).\n\nAn id will never change during the lifetime of the `ext_workspace_handle_v1`\nand is guaranteed to be unique during it's lifetime.\n\nIds are not human-readable and shouldn't be displayed, use `name` for that purpose.\n\nCompositors are expected to only send ids for workspaces likely stable across multiple\nsessions and can be used by clients to store preferences for workspaces. Workspaces without\nids should be considered temporary and any data associated with them should be deleted once\nthe respective object is lost.""workspace name changed\n\nThis event is emitted immediately after the ext_workspace_handle_v1 is\ncreated and whenever the name of the workspace changes.\n\nA name is meant to be human-readable and can be displayed to a user.\nUnlike the id it is neither stable nor unique.""workspace coordinates changed\n\nThis event is used to organize workspaces into an N-dimensional grid\nwithin a workspace group, and if supported, is emitted immediately after\nthe ext_workspace_handle_v1 is created and whenever the coordinates of\nthe workspace change. Compositors may not send this event if they do not\nconceptually arrange workspaces in this way. If compositors simply\nnumber workspaces, without any geometric interpretation, they may send\n1D coordinates, which clients should not interpret as implying any\ngeometry. Sending an empty array means that the compositor no longer\norders the workspace geometrically.\n\nCoordinates have an arbitrary number of dimensions N with an uint32\nposition along each dimension. By convention if N > 1, the first\ndimension is X, the second Y, the third Z, and so on. The compositor may\nchose to utilize these events for a more novel workspace layout\nconvention, however. No guarantee is made about the grid being filled or\nbounded; there may be a workspace at coordinate 1 and another at\ncoordinate 1000 and none in between. Within a workspace group, however,\nworkspaces must have unique coordinates of equal dimensionality.""the state of the workspace changed\n\nThis event is emitted immediately after the ext_workspace_handle_v1 is\ncreated and each time the workspace state changes, either because of a\ncompositor action or because of a request in this protocol.\n\nMissing states convey the opposite meaning, e.g. an unset active bit\nmeans the workspace is currently inactive.""compositor capabilities\n\nThis event advertises the capabilities supported by the compositor. If\na capability isn't supported, clients should hide or disable the UI\nelements that expose this functionality. For instance, if the\ncompositor doesn't advertise support for removing workspaces, a button\ntriggering the remove request should not be displayed.\n\nThe compositor will ignore requests it doesn't support. For instance,\na compositor which doesn't advertise support for remove will ignore\nremove requests.\n\nCompositors must send this event once after creation of an\next_workspace_handle_v1 . When the capabilities change, compositors\nmust send this event again.""this workspace has been removed\n\nThis event is send when the workspace associated with the ext_workspace_handle_v1\nhas been removed. After sending this request, the compositor will immediately consider\nthe object inert. Any requests will be ignored except the destroy request.\n\nIt is guaranteed there won't be any more events referencing this\next_workspace_handle_v1.\n\nThe compositor must only remove a workspaces not currently belonging to any\nworkspace_group.""a workspace handing a group of surfaces\n\nA ext_workspace_handle_v1 object represents a workspace that handles a\ngroup of surfaces.\n\nEach workspace has:\n- a name, conveyed to the client with the name event\n- potentially an id conveyed with the id event\n- a list of states, conveyed to the client with the state event\n- and optionally a set of coordinates, conveyed to the client with the\ncoordinates event\n\nThe client may request that the compositor activate or deactivate the workspace.\n\nEach workspace can belong to only a single workspace group.\nDepending on the compositor policy, there might be workspaces with\nthe same name in different workspace groups, but these workspaces are still\nseparate (e.g. one of them might be active while the other is not).\n\nSee also the [Event] enum for this interface.""destroy the ext_workspace_handle_v1 object\n\nDestroys the ext_workspace_handle_v1 object.\n\nThis request should be made either when the client does not want to\nuse the workspace object any more or after the remove event to finalize\nthe destruction of the object."//! List and control workspacesEXT_BACKGROUND_EFFECT_MANAGER_V1_INTERFACEext_background_effect_manager_v1_requests_get_background_effect_typesext_background_effect_manager_v1_requestsext_background_effect_manager_v1_eventsext_background_effect_manager_v1_interfaceEXT_BACKGROUND_EFFECT_SURFACE_V1_INTERFACEext_background_effect_surface_v1_requests_set_blur_region_typesext_background_effect_surface_v1_requestsext_background_effect_surface_v1_interface"background effect factory\n\nThis protocol provides a way to improve visuals of translucent surfaces\nby applying effects like blur to the background behind them.\n\nThe capabilities are send when the global is bound, and every time they\nchange. Note that when the capability goes away, the corresponding effect\nis no longer applied by the compositor, even if it was set before.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""the surface already has a background effect object"BackgroundEffectExists"the compositor supports applying blur"BlurREQ_GET_BACKGROUND_EFFECT_SINCEREQ_GET_BACKGROUND_EFFECT_OPCODE"destroy the background effect manager\n\nInforms the server that the client will no longer be using this\nprotocol object. Existing objects created by this object are not\naffected.\n\nThis is a destructor, once sent this object cannot be used any longer.""get a background effects object\n\nInstantiate an interface extension for the given wl_surface to add\neffects like blur for the background behind it.\n\nIf the given wl_surface already has a ext_background_effect_surface_v1\nobject associated, the background_effect_exists protocol error will be\nraised.""the surface"GetBackgroundEffect"capabilities of the compositor""background effect factory\n\nThis protocol provides a way to improve visuals of translucent surfaces\nby applying effects like blur to the background behind them.\n\nThe capabilities are send when the global is bound, and every time they\nchange. Note that when the capability goes away, the corresponding effect\nis no longer applied by the compositor, even if it was set before.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nSee also the [Event] enum for this interface."ExtBackgroundEffectManagerV1"destroy the background effect manager\n\nInforms the server that the client will no longer be using this\nprotocol object. Existing objects created by this object are not\naffected."ext_background_effect_surface_v1ExtBackgroundEffectSurfaceV1get_background_effectext_background_effect_manager_v1"background effects for a surface\n\nThe background effect object provides a way to specify a region behind\na surface that should have background effects like blur applied.\n\nIf the wl_surface associated with the ext_background_effect_surface_v1\nobject has been destroyed, this object becomes inert.""the associated surface has been destroyed"SurfaceDestroyedREQ_SET_BLUR_REGION_SINCEREQ_SET_BLUR_REGION_OPCODE"release the blur object\n\nInforms the server that the client will no longer be using this protocol\nobject. The effect regions will be removed on the next commit.\n\nThis is a destructor, once sent this object cannot be used any longer.""set blur region\n\nThis request sets the region of the surface that will have its\nbackground blurred.\n\nThe blur region is specified in the surface-local coordinates, and\nclipped by the compositor to the surface size.\n\nThe initial value for the blur region is empty. Setting the pending\nblur region has copy semantics, and the wl_region object can be\ndestroyed immediately. A NULL wl_region removes the effect.\n\nThe blur region is double-buffered state, and will be applied on\nthe next wl_surface.commit.\n\nThe blur algorithm is subject to compositor policies.\n\nIf the associated surface has been destroyed, the surface_destroyed\nerror will be raised.""blur region of the surface"SetBlurRegion"background effects for a surface\n\nThe background effect object provides a way to specify a region behind\na surface that should have background effects like blur applied.\n\nIf the wl_surface associated with the ext_background_effect_surface_v1\nobject has been destroyed, this object becomes inert.\n\nThis interface has no events.""release the blur object\n\nInforms the server that the client will no longer be using this protocol\nobject. The effect regions will be removed on the next commit."set_blur_region//! This protocol provides a way to improve visuals of translucent surfaces//! by applying effects like blur to the background behind them.//! The capabilities are send when the global is bound, and every time they//! change. Note that when the capability goes away, the corresponding effect//! is no longer applied by the compositor, even if it was set before.//! Warning! The protocol described in this file is currently in the testing//! phase. Backward compatible changes may be added together with the//! corresponding interface version bump. Backward incompatible changes can//! only be done by creating a new major version of the extension.background_effect//! Miscellaneous protocolsprotocol_macroxwayland//! This crate provides bindings to the official wayland protocol extensions//! provided in <https://gitlab.freedesktop.org/wayland/wayland-protocols>//! These bindings are built on top of the crates wayland-client and wayland-server.//! Each protocol module contains a `client` and a `server` submodules, for each side of the//! protocol. The creation of these modules (and the dependency on the associated crate) is//! controlled by the two cargo features `client` and `server`.//! ## Protocol categories//! The protocols provided in this crate are grouped in 4 main categories://! - The [`wp`] module contains general purpose wayland protocols//! - The [`xdg`] module contains protocols specifically related to window management//! - The [`xwayland`] module contains protocols used by xwayland.//! - The [`ext`] module contains protocols that do not fit into the three previous categories.//! ## Staging protocols//! The cargo feature `staging` enables the generation of the staging protocols.//! These protocols are ready for wider adoption and clients and compositors are encouraged to//! implement staging protocol extensions where a protocol's functionality is desired.//! Although these protocols should be stable, the protocols may still be completely replaced in a new//! major version or with a completely different protocol.//! ## Unstable protocols//! The `wayland-protocols` project previously had a notion of "unstable protocols" representing protocols//! that are still being worked on and evolving. These protocols are recognized by the use of the prefix `z`//! in their interface names.//! This category has now been deprecated and is no longer supposed to be used, however several protocols//! are still under that umbrella. We can expect them to be replaced by staging and stable protocols in the//! long term, but in the meantime you can enable them with the `unstable` cargo feature.//! ## Other protocols//! Additionally, more protocol extensions are provided here://! - [wayland-protocols-wlr](https://docs.rs/wayland-protocols-wlr)//! - [wayland-protocols-plasma](https://docs.rs/wayland-protocols-plasma)//! - [wayland-protocols-misc](https://docs.rs/wayland-protocols-misc)WP_CONTENT_TYPE_MANAGER_V1_INTERFACEwp_content_type_manager_v1_requests_get_surface_content_type_typeswp_content_type_manager_v1_requestswp_content_type_manager_v1_interfaceWP_CONTENT_TYPE_V1_INTERFACEwp_content_type_v1_requestswp_content_type_v1_interface"surface content type manager\n\nThis interface allows a client to describe the kind of content a surface\nwill display, to allow the compositor to optimize its behavior for it.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""wl_surface already has a content type object"REQ_GET_SURFACE_CONTENT_TYPE_SINCEREQ_GET_SURFACE_CONTENT_TYPE_OPCODE"destroy the content type manager object\n\nDestroy the content type manager. This doesn't destroy objects created\nwith the manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new content type object\n\nCreate a new content type object associated with the given surface.\n\nCreating a wp_content_type_v1 from a wl_surface which already has one\nattached is a client error: already_constructed."GetSurfaceContentType"surface content type manager\n\nThis interface allows a client to describe the kind of content a surface\nwill display, to allow the compositor to optimize its behavior for it.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpContentTypeManagerV1"destroy the content type manager object\n\nDestroy the content type manager. This doesn't destroy objects created\nwith the manager."wp_content_type_v1WpContentTypeV1get_surface_content_typewp_content_type_manager_v1"content type object for a surface\n\nThe content type object allows the compositor to optimize for the kind\nof content shown on the surface. A compositor may for example use it to\nset relevant drm properties like \"content type\".\n\nThe client may request to switch to another content type at any time.\nWhen the associated surface gets destroyed, this object becomes inert and\nthe client should destroy it.""possible content types\n\nThese values describe the available content types for a surface.""no content type applies\n\nThe content type none means that either the application has no data\nabout the content type, or that the content doesn't fit into one of\nthe other categories.""photo content type\n\nThe content type photo describes content derived from digital still\npictures and may be presented with minimal processing."Photo"video content type\n\nThe content type video describes a video or animation and may be\npresented with more accurate timing to avoid stutter. Where scaling\nis needed, scaling methods more appropriate for video may be used.""game content type\n\nThe content type game describes a running game. Its content may be\npresented with reduced latency."REQ_SET_CONTENT_TYPE_SINCEREQ_SET_CONTENT_TYPE_OPCODE"destroy the content type object\n\nSwitch back to not specifying the content type of this surface. This is\nequivalent to setting the content type to none, including double\nbuffering semantics. See set_content_type for details.\n\nThis is a destructor, once sent this object cannot be used any longer.""specify the content type\n\nSet the surface content type. This informs the compositor that the\nclient believes it is displaying buffers matching this content type.\n\nThis is purely a hint for the compositor, which can be used to adjust\nits behavior or hardware settings to fit the presented content best.\n\nThe content type is double-buffered state, see wl_surface.commit for\ndetails.""the content type"SetContentType"content type object for a surface\n\nThe content type object allows the compositor to optimize for the kind\nof content shown on the surface. A compositor may for example use it to\nset relevant drm properties like \"content type\".\n\nThe client may request to switch to another content type at any time.\nWhen the associated surface gets destroyed, this object becomes inert and\nthe client should destroy it.\n\nThis interface has no events.""destroy the content type object\n\nSwitch back to not specifying the content type of this surface. This is\nequivalent to setting the content type to none, including double\nbuffering semantics. See set_content_type for details."//! This protocol allows a client to describe the kind of content a surface//! will display, to allow the compositor to optimize its behavior for it.WP_COLOR_MANAGER_V1_INTERFACEwp_color_manager_v1_requests_get_output_typeswp_color_manager_v1_requests_get_surface_typeswp_color_manager_v1_requests_get_surface_feedback_typeswp_color_manager_v1_requests_create_icc_creator_typeswp_color_manager_v1_requests_create_parametric_creator_typeswp_color_manager_v1_requests_create_windows_scrgb_typeswp_color_manager_v1_requestswp_color_manager_v1_eventswp_color_manager_v1_interfaceWP_COLOR_MANAGEMENT_OUTPUT_V1_INTERFACEwp_color_management_output_v1_requests_get_image_description_typeswp_color_management_output_v1_requestswp_color_management_output_v1_eventswp_color_management_output_v1_interfaceWP_COLOR_MANAGEMENT_SURFACE_V1_INTERFACEwp_color_management_surface_v1_requests_set_image_description_typeswp_color_management_surface_v1_requestswp_color_management_surface_v1_interfaceWP_COLOR_MANAGEMENT_SURFACE_FEEDBACK_V1_INTERFACEwp_color_management_surface_feedback_v1_requests_get_preferred_typeswp_color_management_surface_feedback_v1_requests_get_preferred_parametric_typeswp_color_management_surface_feedback_v1_requestswp_color_management_surface_feedback_v1_eventswp_color_management_surface_feedback_v1_interfaceWP_IMAGE_DESCRIPTION_CREATOR_ICC_V1_INTERFACEwp_image_description_creator_icc_v1_requests_create_typeswp_image_description_creator_icc_v1_requestswp_image_description_creator_icc_v1_interfaceWP_IMAGE_DESCRIPTION_CREATOR_PARAMS_V1_INTERFACEwp_image_description_creator_params_v1_requests_create_typeswp_image_description_creator_params_v1_requestswp_image_description_creator_params_v1_interfaceWP_IMAGE_DESCRIPTION_V1_INTERFACEwp_image_description_v1_requests_get_information_typeswp_image_description_v1_requestswp_image_description_v1_eventswp_image_description_v1_interfaceWP_IMAGE_DESCRIPTION_INFO_V1_INTERFACEwp_image_description_info_v1_eventswp_image_description_info_v1_interface"color manager singleton\n\nA singleton global interface used for getting color management extensions\nfor wl_surface and wl_output objects, and for creating client defined\nimage description objects. The extension interfaces allow\ngetting the image description of outputs and setting the image\ndescription of surfaces.\n\nCompositors should never remove this global.""request not supported""color management surface exists already"SurfaceExists"rendering intents\n\nSee the ICC.1:2022 specification from the International Color Consortium\nfor more details about rendering intents.\n\nThe principles of ICC defined rendering intents apply with all types of\nimage descriptions, not only those with ICC file profiles.\n\nCompositors must support the perceptual rendering intent. Other\nrendering intents are optional."RenderIntent"perceptual""media-relative colorimetric""saturation""ICC-absolute colorimetric""media-relative colorimetric + black point compensation"RelativeBpc"compositor supported features""create_icc_creator request"IccV2V4"create_parametric_creator request"Parametric"parametric set_primaries request"SetPrimaries"parametric set_tf_power request"SetTfPower"parametric set_luminances request"SetLuminances"parametric set_mastering_display_primaries request\n\nThe compositor supports set_mastering_display_primaries request with a\ntarget color volume fully contained inside the primary color volume."SetMasteringDisplayPrimaries"parametric target exceeds primary color volume\n\nThe compositor additionally supports target color volumes that\nextend outside of the primary color volume.\n\nThis can only be advertised if feature set_mastering_display_primaries\nis supported as well."ExtendedTargetVolume"create_windows_scrgb request"WindowsScrgb"named color primaries\n\nNamed color primaries used to encode well-known sets of primaries. H.273\nis the authority, when it comes to the exact values of primaries and\nauthoritative specifications, where an equivalent code point exists.\n\nA value of 0 is invalid and will never be present in the list of enums.\n\nDescriptions do list the specifications for convenience."Primaries"Color primaries for the sRGB color space as defined by the BT.709 standard\n\nColor primaries as defined by\n- Rec. ITU-R BT.709-6\n- Rec. ITU-R BT.1361-0 conventional colour gamut system and extended\ncolour gamut system (historical)\n- IEC 61966-2-1 sRGB or sYCC\n- IEC 61966-2-4\n- Society of Motion Picture and Television Engineers (SMPTE) RP 177\n(1993) Annex B\nEquivalent to H.273 ColourPrimaries code point 1.""Color primaries for PAL-M as defined by the BT.470 standard\n\nColor primaries as defined by\n- Rec. ITU-R BT.470-6 System M (historical)\n- United States National Television System Committee 1953\nRecommendation for transmission standards for color television\n- United States Federal Communications Commission (2003) Title 47 Code\nof Federal Regulations 73.682 (a)(20)\nEquivalent to H.273 ColourPrimaries code point 4."PalM"Color primaries for PAL as defined by the BT.601 standard\n\nColor primaries as defined by\n- Rec. ITU-R BT.470-6 System B, G (historical)\n- Rec. ITU-R BT.601-7 625\n- Rec. ITU-R BT.1358-0 625 (historical)\n- Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM\nEquivalent to H.273 ColourPrimaries code point 5."Pal"Color primaries for NTSC as defined by the BT.601 standard\n\nColor primaries as defined by\n- Rec. ITU-R BT.601-7 525\n- Rec. ITU-R BT.1358-1 525 or 625 (historical)\n- Rec. ITU-R BT.1700-0 NTSC\n- SMPTE 170M (2004)\n- SMPTE 240M (1999) (historical)\nEquivalent to H.273 ColourPrimaries code point 6 and 7."Ntsc"Generic film with colour filters using Illuminant C\n\nColor primaries as defined by H.273 for generic film.\nEquivalent to H.273 ColourPrimaries code point 8."GenericFilm"Color primaries as defined by the BT.2020 and BT.2100 standard\n\nColor primaries as defined by\n- Rec. ITU-R BT.2020-2\n- Rec. ITU-R BT.2100-0\nEquivalent to H.273 ColourPrimaries code point 9.""Color primaries of the full CIE 1931 XYZ color space\n\nColor primaries as defined as the maximum of the CIE 1931 XYZ color\nspace by\n- SMPTE ST 428-1\n- (CIE 1931 XYZ as in ISO 11664-1)\nEquivalent to H.273 ColourPrimaries code point 10."Cie1931Xyz"Color primaries of the DCI P3 color space as defined by the SMPTE RP 431 standard\n\nColor primaries as defined by Digital Cinema System and published in\nSMPTE RP 431-2 (2011). Equivalent to H.273 ColourPrimaries code point\n11."DciP3"Color primaries of Display P3 variant of the DCI-P3 color space as defined by the SMPTE EG 432 standard\n\nColor primaries as defined by Digital Cinema System and published in\nSMPTE EG 432-1 (2010).\nEquivalent to H.273 ColourPrimaries code point 12."DisplayP3"Color primaries of the Adobe RGB color space as defined by the ISO 12640 standard\n\nColor primaries as defined by Adobe as \"Adobe RGB\" and later published\nby ISO 12640-4 (2011)."AdobeRgb"named transfer functions\n\nNamed transfer functions used to represent well-known transfer\ncharacteristics. H.273 is the authority, when it comes to the exact\nformulas and authoritative specifications, where an equivalent code\npoint exists.\n\nA value of 0 is invalid and will never be present in the list of enums.\n\nDescriptions do list the specifications for convenience.""BT.1886 display transfer characteristic\n\nRec. ITU-R BT.1886 is the display transfer characteristic assumed by\n- Rec. ITU-R BT.601-7 525 and 625\n- Rec. ITU-R BT.709-6\n- Rec. ITU-R BT.2020-2\nThese recommendations are referred to by H.273 TransferCharacteristics\ncode points 1, 6, 14, and 15, which are all equivalent.\n\nThis TF implies these default luminances from Rec. ITU-R BT.2035:\n- primary color volume minimum: 0.01 cd/m²\n- primary color volume maximum: 100 cd/m²\n- reference white: 100 cd/m²"Bt1886"Assumed display gamma 2.2 transfer function\n\nTransfer characteristics as defined by\n- Rec. ITU-R BT.470-6 System M (historical)\n- United States National Television System Committee 1953\nRecommendation for transmission standards for color television\n- United States Federal Communications Commission (2003) Title 47 Code\nof Federal Regulations 73.682 (a) (20)\n- Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM\nEquivalent to H.273 TransferCharacteristics code point 4.\n\nNote: an sRGB display (IEC 61966-2-1) uses this transfer function.""Assumed display gamma 2.8 transfer function\n\nTransfer characteristics as defined by\n- Rec. ITU-R BT.470-6 System B, G (historical)\nEquivalent to H.273 TransferCharacteristics code point 5.""SMPTE ST 240 transfer function\n\nTransfer characteristics as defined by\n- SMPTE ST 240 (1999)\nEquivalent to H.273 TransferCharacteristics code point 7."St240"extended linear transfer function\n\nLinear transfer function defined over all real numbers.\nNormalised electrical values are equal the normalised optical values.\n\nThe differences to H.273 TransferCharacteristics code point 8 are\nthe definition over all real numbers."ExtLinear"logarithmic 100:1 transfer function\n\nLogarithmic transfer characteristic (100:1 range).\nEquivalent to H.273 TransferCharacteristics code point 9.""logarithmic (100*Sqrt(10) : 1) transfer function\n\nLogarithmic transfer characteristic (100 * Sqrt(10) : 1 range).\nEquivalent to H.273 TransferCharacteristics code point 10.""IEC 61966-2-4 transfer function\n\nTransfer characteristics as defined by\n- IEC 61966-2-4\nEquivalent to H.273 TransferCharacteristics code point 11."Xvycc"sRGB piece-wise transfer function\n\nTransfer characteristics as defined by\n- IEC 61966-2-1 sRGB\nEquivalent to H.273 TransferCharacteristics code point 13 with\nMatrixCoefficients set to 0.\n\nNote: This is not appropriate for describing sRGB material.\nsRGB material is intended to be viewed on an sRGB display, and\nthat is described by gamma22.""Extended sRGB piece-wise transfer function\n\nTransfer characteristics as defined by\n- IEC 61966-2-1 sYCC\nEquivalent to H.273 TransferCharacteristics code point 13 with\nMatrixCoefficients set to anything but 0."ExtSrgb"perceptual quantizer transfer function\n\nTransfer characteristics as defined by\n- SMPTE ST 2084 (2014) for 10-, 12-, 14- and 16-bit systems\n- Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system\nEquivalent to H.273 TransferCharacteristics code point 16.\n\nThis TF implies these default luminances\n- primary color volume minimum: 0.005 cd/m²\n- primary color volume maximum: 10000 cd/m²\n- reference white: 203 cd/m²\n\nThe difference between the primary color volume minimum and maximum\nmust be approximately 10000 cd/m² as that is the swing of the EOTF\ndefined by ST 2084 and BT.2100. The default value for the\nreference white is a protocol addition: it is suggested by\nReport ITU-R BT.2408-7 and is not part of ST 2084 or BT.2100."St2084Pq"SMPTE ST 428 transfer function\n\nTransfer characteristics as defined by\n- SMPTE ST 428-1 (2019)\nEquivalent to H.273 TransferCharacteristics code point 17."St428"hybrid log-gamma transfer function\n\nTransfer characteristics as defined by\n- ARIB STD-B67 (2015)\n- Rec. ITU-R BT.2100-2 hybrid log-gamma (HLG) system\nEquivalent to H.273 TransferCharacteristics code point 18.\n\nThis TF implies these default luminances\n- primary color volume minimum: 0.005 cd/m²\n- primary color volume maximum: 1000 cd/m²\n- reference white: 203 cd/m²\n\nHLG is a relative display-referred signal with a specified\nnon-linear mapping to the display peak luminance (the HLG OOTF).\nAll absolute luminance values used here for HLG assume a 1000 cd/m²\npeak display.\n\nThe default value for the reference white is a protocol addition:\nit is suggested by Report ITU-R BT.2408-7 and is not part of\nARIB STD-B67 or BT.2100."HlgREQ_GET_OUTPUT_SINCEREQ_GET_OUTPUT_OPCODEREQ_GET_SURFACE_SINCEREQ_GET_SURFACE_OPCODEREQ_GET_SURFACE_FEEDBACK_SINCEREQ_GET_SURFACE_FEEDBACK_OPCODEREQ_CREATE_ICC_CREATOR_SINCEREQ_CREATE_ICC_CREATOR_OPCODEREQ_CREATE_PARAMETRIC_CREATOR_SINCEREQ_CREATE_PARAMETRIC_CREATOR_OPCODEREQ_CREATE_WINDOWS_SCRGB_SINCEREQ_CREATE_WINDOWS_SCRGB_OPCODEEVT_SUPPORTED_INTENT_SINCEEVT_SUPPORTED_INTENT_OPCODEEVT_SUPPORTED_FEATURE_SINCEEVT_SUPPORTED_FEATURE_OPCODEEVT_SUPPORTED_TF_NAMED_SINCEEVT_SUPPORTED_TF_NAMED_OPCODEEVT_SUPPORTED_PRIMARIES_NAMED_SINCEEVT_SUPPORTED_PRIMARIES_NAMED_OPCODE"destroy the color manager\n\nDestroy the wp_color_manager_v1 object. This does not affect any other\nobjects in any way.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a color management interface for a wl_output\n\nThis creates a new wp_color_management_output_v1 object for the\ngiven wl_output.\n\nSee the wp_color_management_output_v1 interface for more details."GetOutput"create a color management interface for a wl_surface\n\nIf a wp_color_management_surface_v1 object already exists for the given\nwl_surface, the protocol error surface_exists is raised.\n\nThis creates a new color wp_color_management_surface_v1 object for the\ngiven wl_surface.\n\nSee the wp_color_management_surface_v1 interface for more details."GetSurface"create a color management feedback interface\n\nThis creates a new color wp_color_management_surface_feedback_v1 object\nfor the given wl_surface.\n\nSee the wp_color_management_surface_feedback_v1 interface for more\ndetails."GetSurfaceFeedback"make a new ICC-based image description creator object\n\nMakes a new ICC-based image description creator object with all\nproperties initially unset. The client can then use the object's\ninterface to define all the required properties for an image description\nand finally create a wp_image_description_v1 object.\n\nThis request can be used when the compositor advertises\nwp_color_manager_v1.feature.icc_v2_v4.\nOtherwise this request raises the protocol error unsupported_feature."CreateIccCreator"make a new parametric image description creator object\n\nMakes a new parametric image description creator object with all\nproperties initially unset. The client can then use the object's\ninterface to define all the required properties for an image description\nand finally create a wp_image_description_v1 object.\n\nThis request can be used when the compositor advertises\nwp_color_manager_v1.feature.parametric.\nOtherwise this request raises the protocol error unsupported_feature."CreateParametricCreator"create Windows-scRGB image description object\n\nThis creates a pre-defined image description for the so-called\nWindows-scRGB stimulus encoding. This comes from the Windows 10 handling\nof its own definition of an scRGB color space for an HDR screen\ndriven in BT.2100/PQ signalling mode.\n\nWindows-scRGB uses sRGB (BT.709) color primaries and white point.\nThe transfer characteristic is extended linear.\n\nThe nominal color channel value range is extended, meaning it includes\nnegative and greater than 1.0 values. Negative values are used to\nescape the sRGB color gamut boundaries. To make use of the extended\nrange, the client needs to use a pixel format that can represent those\nvalues, e.g. floating-point 16 bits per channel.\n\nNominal color value R=G=B=0.0 corresponds to BT.2100/PQ system\n0 cd/m², and R=G=B=1.0 corresponds to BT.2100/PQ system 80 cd/m².\nThe maximum is R=G=B=125.0 corresponding to 10k cd/m².\n\nWindows-scRGB is displayed by Windows 10 by converting it to\nBT.2100/PQ, maintaining the CIE 1931 chromaticity and mapping the\nluminance as above. No adjustment is made to the signal to account\nfor the viewing conditions.\n\nThe reference white level of Windows-scRGB is unknown. If a\nreference white level must be assumed for compositor processing, it\nshould be R=G=B=2.5375 corresponding to 203 cd/m² of Report ITU-R\nBT.2408-7.\n\nThe target color volume of Windows-scRGB is unknown. The color gamut\nmay be anything between sRGB and BT.2100.\n\nNote: EGL_EXT_gl_colorspace_scrgb_linear definition differs from\nWindows-scRGB by using R=G=B=1.0 as the reference white level, while\nWindows-scRGB reference white level is unknown or varies. However,\nit seems probable that Windows implements both\nEGL_EXT_gl_colorspace_scrgb_linear and Vulkan\nVK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT as Windows-scRGB.\n\nThis request can be used when the compositor advertises\nwp_color_manager_v1.feature.windows_scrgb.\nOtherwise this request raises the protocol error unsupported_feature.\n\nThe resulting image description object does not allow get_information\nrequest. The wp_image_description_v1.ready event shall be sent."CreateWindowsScrgb"supported rendering intent\n\nWhen this object is created, it shall immediately send this event once\nfor each rendering intent the compositor supports.""rendering intent"render_intentSupportedIntent"supported features\n\nWhen this object is created, it shall immediately send this event once\nfor each compositor supported feature listed in the enumeration.""supported feature"SupportedFeature"supported named transfer characteristic\n\nWhen this object is created, it shall immediately send this event once\nfor each named transfer function the compositor supports with the\nparametric image description creator.""Named transfer function"tfSupportedTfNamed"supported named primaries\n\nWhen this object is created, it shall immediately send this event once\nfor each named set of primaries the compositor supports with the\nparametric image description creator.""Named color primaries"SupportedPrimariesNamed"all features have been sent\n\nThis event is sent when all supported rendering intents, features,\ntransfer functions and named primaries have been sent.""color manager singleton\n\nA singleton global interface used for getting color management extensions\nfor wl_surface and wl_output objects, and for creating client defined\nimage description objects. The extension interfaces allow\ngetting the image description of outputs and setting the image\ndescription of surfaces.\n\nCompositors should never remove this global.\n\nSee also the [Event] enum for this interface."WpColorManagerV1"destroy the color manager\n\nDestroy the wp_color_manager_v1 object. This does not affect any other\nobjects in any way."wp_color_management_output_v1WpColorManagementOutputV1wp_color_management_surface_v1WpColorManagementSurfaceV1get_surfacewp_color_management_surface_feedback_v1WpColorManagementSurfaceFeedbackV1wp_image_description_creator_icc_v1WpImageDescriptionCreatorIccV1create_icc_creatorwp_image_description_creator_params_v1WpImageDescriptionCreatorParamsV1create_parametric_creatorwp_image_description_v1WpImageDescriptionV1create_windows_scrgbwp_color_manager_v1"output color properties\n\nA wp_color_management_output_v1 describes the color properties of an\noutput.\n\nThe wp_color_management_output_v1 is associated with the wl_output global\nunderlying the wl_output object. Therefore the client destroying the\nwl_output object has no impact, but the compositor removing the output\nglobal makes the wp_color_management_output_v1 object inert."REQ_GET_IMAGE_DESCRIPTION_SINCEREQ_GET_IMAGE_DESCRIPTION_OPCODEEVT_IMAGE_DESCRIPTION_CHANGED_SINCEEVT_IMAGE_DESCRIPTION_CHANGED_OPCODE"destroy the color management output\n\nDestroy the color wp_color_management_output_v1 object. This does not\naffect any remaining protocol objects.\n\nThis is a destructor, once sent this object cannot be used any longer.""get the image description of the output\n\nThis creates a new wp_image_description_v1 object for the current image\ndescription of the output. There always is exactly one image description\nactive for an output so the client should destroy the image description\ncreated by earlier invocations of this request. This request is usually\nsent as a reaction to the image_description_changed event or when\ncreating a wp_color_management_output_v1 object.\n\nThe image description of an output represents the color encoding the\noutput expects. There might be performance and power advantages, as well\nas improved color reproduction, if a content update matches the image\ndescription of the output it is being shown on. If a content update is\nshown on any other output than the one it matches the image description\nof, then the color reproduction on those outputs might be considerably\nworse.\n\nThe created wp_image_description_v1 object preserves the image\ndescription of the output from the time the object was created.\n\nThe resulting image description object allows get_information request.\n\nIf this protocol object is inert, the resulting image description object\nshall immediately deliver the wp_image_description_v1.failed event with\nthe no_output cause.\n\nIf the interface version is inadequate for the output's image\ndescription, meaning that the client does not support all the events\nneeded to deliver the crucial information, the resulting image\ndescription object shall immediately deliver the\nwp_image_description_v1.failed event with the low_version cause.\n\nOtherwise the object shall immediately deliver the ready event."GetImageDescription"image description changed\n\nThis event is sent whenever the image description of the output changed,\nfollowed by one wl_output.done event common to output events across all\nextensions.\n\nIf the client wants to use the updated image description, it needs to do\nget_image_description again, because image description objects are\nimmutable."ImageDescriptionChanged"output color properties\n\nA wp_color_management_output_v1 describes the color properties of an\noutput.\n\nThe wp_color_management_output_v1 is associated with the wl_output global\nunderlying the wl_output object. Therefore the client destroying the\nwl_output object has no impact, but the compositor removing the output\nglobal makes the wp_color_management_output_v1 object inert.\n\nSee also the [Event] enum for this interface.""destroy the color management output\n\nDestroy the color wp_color_management_output_v1 object. This does not\naffect any remaining protocol objects.""color management extension to a surface\n\nA wp_color_management_surface_v1 allows the client to set the color\nspace and HDR properties of a surface.\n\nIf the wl_surface associated with the wp_color_management_surface_v1 is\ndestroyed, the wp_color_management_surface_v1 object becomes inert.""protocol errors""unsupported rendering intent""invalid image description""forbidden request on inert object"REQ_SET_IMAGE_DESCRIPTION_SINCEREQ_SET_IMAGE_DESCRIPTION_OPCODEREQ_UNSET_IMAGE_DESCRIPTION_SINCEREQ_UNSET_IMAGE_DESCRIPTION_OPCODE"destroy the color management interface for a surface\n\nDestroy the wp_color_management_surface_v1 object and do the same as\nunset_image_description.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the surface image description\n\nIf this protocol object is inert, the protocol error inert is raised.\n\nSet the image description of the underlying surface. The image\ndescription and rendering intent are double-buffered state, see\nwl_surface.commit.\n\nIt is the client's responsibility to understand the image description\nit sets on a surface, and to provide content that matches that image\ndescription. Compositors might convert images to match their own or any\nother image descriptions.\n\nImage descriptions which are not ready (see wp_image_description_v1)\nare forbidden in this request, and in such case the protocol error\nimage_description is raised.\n\nAll image descriptions which are ready (see wp_image_description_v1)\nare allowed and must always be accepted by the compositor.\n\nA rendering intent provides the client's preference on how content\ncolors should be mapped to each output. The render_intent value must\nbe one advertised by the compositor with\nwp_color_manager_v1.render_intent event, otherwise the protocol error\nrender_intent is raised.\n\nWhen an image description is set on a surface, the Transfer\nCharacteristics of the image description defines the valid range of\nthe nominal (real-valued) color channel values. The processing of\nout-of-range color channel values is undefined, but compositors are\nrecommended to clamp the values to the valid range when possible.\n\nBy default, a surface does not have an associated image description\nnor a rendering intent. The handling of color on such surfaces is\ncompositor implementation defined. Compositors should handle such\nsurfaces as sRGB, but may handle them differently if they have specific\nrequirements.\n\nSetting the image description has copy semantics; after this request,\nthe image description can be immediately destroyed without affecting\nthe pending state of the surface."SetImageDescription"remove the surface image description\n\nIf this protocol object is inert, the protocol error inert is raised.\n\nThis request removes any image description from the surface. See\nset_image_description for how a compositor handles a surface without\nan image description. This is double-buffered state, see\nwl_surface.commit."UnsetImageDescription"color management extension to a surface\n\nA wp_color_management_surface_v1 allows the client to set the color\nspace and HDR properties of a surface.\n\nIf the wl_surface associated with the wp_color_management_surface_v1 is\ndestroyed, the wp_color_management_surface_v1 object becomes inert.\n\nThis interface has no events.""destroy the color management interface for a surface\n\nDestroy the wp_color_management_surface_v1 object and do the same as\nunset_image_description."unset_image_description"color management extension to a surface\n\nA wp_color_management_surface_feedback_v1 allows the client to get the\npreferred image description of a surface.\n\nIf the wl_surface associated with this object is destroyed, the\nwp_color_management_surface_feedback_v1 object becomes inert.""attempted to use an unsupported feature"REQ_GET_PREFERRED_SINCEREQ_GET_PREFERRED_OPCODEREQ_GET_PREFERRED_PARAMETRIC_SINCEREQ_GET_PREFERRED_PARAMETRIC_OPCODEEVT_PREFERRED_CHANGED_SINCEEVT_PREFERRED_CHANGED_OPCODE"destroy the color management interface for a surface\n\nDestroy the wp_color_management_surface_feedback_v1 object.\n\nThis is a destructor, once sent this object cannot be used any longer.""get the preferred image description\n\nIf this protocol object is inert, the protocol error inert is raised.\n\nThe preferred image description represents the compositor's preferred\ncolor encoding for this wl_surface at the current time. There might be\nperformance and power advantages, as well as improved color\nreproduction, if the image description of a content update matches the\npreferred image description.\n\nThis creates a new wp_image_description_v1 object for the currently\npreferred image description for the wl_surface. The client should\nstop using and destroy the image descriptions created by earlier\ninvocations of this request for the associated wl_surface.\nThis request is usually sent as a reaction to the preferred_changed\nevent or when creating a wp_color_management_surface_feedback_v1 object\nif the client is capable of adapting to image descriptions.\n\nThe created wp_image_description_v1 object preserves the preferred image\ndescription of the wl_surface from the time the object was created.\n\nThe resulting image description object allows get_information request.\n\nIf the image description is parametric, the client should set it on its\nwl_surface only if the image description is an exact match with the\nclient content. Particularly if everything else matches, but the target\ncolor volume is greater than what the client needs, the client should\ncreate its own parameric image description with its exact parameters.\n\nIf the interface version is inadequate for the preferred image\ndescription, meaning that the client does not support all the\nevents needed to deliver the crucial information, the resulting image\ndescription object shall immediately deliver the\nwp_image_description_v1.failed event with the low_version cause,\notherwise the object shall immediately deliver the ready event."GetPreferred"get the preferred image description\n\nThe same description as for get_preferred applies, except the returned\nimage description is guaranteed to be parametric. This is meant for\nclients that can only deal with parametric image descriptions.\n\nIf the compositor doesn't support parametric image descriptions, the\nunsupported_feature error is emitted."GetPreferredParametric"the preferred image description changed\n\nThe preferred image description is the one which likely has the most\nperformance and/or quality benefits for the compositor if used by the\nclient for its wl_surface contents. This event is sent whenever the\ncompositor changes the wl_surface's preferred image description.\n\nThis event sends the identity of the new preferred state as the argument,\nso clients who are aware of the image description already can reuse it.\nOtherwise, if the client client wants to know what the preferred image\ndescription is, it shall use the get_preferred request.\n\nThe preferred image description is not automatically used for anything.\nIt is only a hint, and clients may set any valid image description with\nset_image_description, but there might be performance and color accuracy\nimprovements by providing the wl_surface contents in the preferred\nimage description. Therefore clients that can, should render according\nto the preferred image description""image description id number"PreferredChanged"color management extension to a surface\n\nA wp_color_management_surface_feedback_v1 allows the client to get the\npreferred image description of a surface.\n\nIf the wl_surface associated with this object is destroyed, the\nwp_color_management_surface_feedback_v1 object becomes inert.\n\nSee also the [Event] enum for this interface.""destroy the color management interface for a surface\n\nDestroy the wp_color_management_surface_feedback_v1 object."get_preferredget_preferred_parametric"holder of image description ICC information\n\nThis type of object is used for collecting all the information required\nto create a wp_image_description_v1 object from an ICC file. A complete\nset of required parameters consists of these properties:\n- ICC file\n\nEach required property must be set exactly once if the client is to create\nan image description. The set requests verify that a property was not\nalready set. The create request verifies that all required properties are\nset. There may be several alternative requests for setting each property,\nand in that case the client must choose one of them.\n\nOnce all properties have been set, the create request must be used to\ncreate the image description object, destroying the creator in the\nprocess.""incomplete parameter set"IncompleteSet"property already set"AlreadySet"fd not seekable and readable"BadFd"no or too much data""offset + length exceeds file size"OutOfFileREQ_SET_ICC_FILE_SINCEREQ_SET_ICC_FILE_OPCODE"Create the image description object from ICC data\n\nCreate an image description object based on the ICC information\npreviously set on this object. A compositor must parse the ICC data in\nsome undefined but finite amount of time.\n\nThe completeness of the parameter set is verified. If the set is not\ncomplete, the protocol error incomplete_set is raised. For the\ndefinition of a complete set, see the description of this interface.\n\nIf the particular combination of the information is not supported\nby the compositor, the resulting image description object shall\nimmediately deliver the wp_image_description_v1.failed event with the\n'unsupported' cause. If a valid image description was created from the\ninformation, the wp_image_description_v1.ready event will eventually\nbe sent instead.\n\nThis request destroys the wp_image_description_creator_icc_v1 object.\n\nThe resulting image description object does not allow get_information\nrequest.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the ICC profile file\n\nSets the ICC profile file to be used as the basis of the image\ndescription.\n\nThe data shall be found through the given fd at the given offset, having\nthe given length. The fd must be seekable and readable. Violating these\nrequirements raises the bad_fd protocol error.\n\nIf reading the data fails due to an error independent of the client, the\ncompositor shall send the wp_image_description_v1.failed event on the\ncreated wp_image_description_v1 with the 'operating_system' cause.\n\nThe maximum size of the ICC profile is 32 MB. If length is greater than\nthat or zero, the protocol error bad_size is raised. If offset + length\nexceeds the file size, the protocol error out_of_file is raised.\n\nA compositor may read the file at any time starting from this request\nand only until whichever happens first:\n- If create request was issued, the wp_image_description_v1 object\ndelivers either failed or ready event; or\n- if create request was not issued, this\nwp_image_description_creator_icc_v1 object is destroyed.\n\nA compositor shall not modify the contents of the file, and the fd may\nbe sealed for writes and size changes. The client must ensure to its\nbest ability that the data does not change while the compositor is\nreading it.\n\nThe data must represent a valid ICC profile. The ICC profile version\nmust be 2 or 4, it must be a 3 channel profile and the class must be\nDisplay or ColorSpace. Violating these requirements will not result in a\nprotocol error, but will eventually send the\nwp_image_description_v1.failed event on the created\nwp_image_description_v1 with the 'unsupported' cause.\n\nSee the International Color Consortium specification ICC.1:2022 for more\ndetails about ICC profiles.\n\nIf ICC file has already been set on this object, the protocol error\nalready_set is raised.""ICC profile""byte offset in fd to start of ICC data""length of ICC data in bytes"SetIccFile"holder of image description ICC information\n\nThis type of object is used for collecting all the information required\nto create a wp_image_description_v1 object from an ICC file. A complete\nset of required parameters consists of these properties:\n- ICC file\n\nEach required property must be set exactly once if the client is to create\nan image description. The set requests verify that a property was not\nalready set. The create request verifies that all required properties are\nset. There may be several alternative requests for setting each property,\nand in that case the client must choose one of them.\n\nOnce all properties have been set, the create request must be used to\ncreate the image description object, destroying the creator in the\nprocess.\n\nThis interface has no events.""Create the image description object from ICC data\n\nCreate an image description object based on the ICC information\npreviously set on this object. A compositor must parse the ICC data in\nsome undefined but finite amount of time.\n\nThe completeness of the parameter set is verified. If the set is not\ncomplete, the protocol error incomplete_set is raised. For the\ndefinition of a complete set, see the description of this interface.\n\nIf the particular combination of the information is not supported\nby the compositor, the resulting image description object shall\nimmediately deliver the wp_image_description_v1.failed event with the\n'unsupported' cause. If a valid image description was created from the\ninformation, the wp_image_description_v1.ready event will eventually\nbe sent instead.\n\nThis request destroys the wp_image_description_creator_icc_v1 object.\n\nThe resulting image description object does not allow get_information\nrequest."set_icc_file"holder of image description parameters\n\nThis type of object is used for collecting all the parameters required\nto create a wp_image_description_v1 object. A complete set of required\nparameters consists of these properties:\n- transfer characteristic function (tf)\n- chromaticities of primaries and white point (primary color volume)\n\nThe following properties are optional and have a well-defined default\nif not explicitly set:\n- primary color volume luminance range\n- reference white luminance level\n- mastering display primaries and white point (target color volume)\n- mastering luminance range\n\nThe following properties are optional and will be ignored\nif not explicitly set:\n- maximum content light level\n- maximum frame-average light level\n\nEach required property must be set exactly once if the client is to create\nan image description. The set requests verify that a property was not\nalready set. The create request verifies that all required properties are\nset. There may be several alternative requests for setting each property,\nand in that case the client must choose one of them.\n\nOnce all properties have been set, the create request must be used to\ncreate the image description object, destroying the creator in the\nprocess.""invalid transfer characteristic"InvalidTf"invalid primaries named"InvalidPrimariesNamed"invalid luminance value or range"InvalidLuminanceREQ_SET_TF_NAMED_SINCEREQ_SET_TF_NAMED_OPCODEREQ_SET_TF_POWER_SINCEREQ_SET_TF_POWER_OPCODEREQ_SET_PRIMARIES_NAMED_SINCEREQ_SET_PRIMARIES_NAMED_OPCODEREQ_SET_PRIMARIES_SINCEREQ_SET_PRIMARIES_OPCODEREQ_SET_LUMINANCES_SINCEREQ_SET_LUMINANCES_OPCODEREQ_SET_MASTERING_DISPLAY_PRIMARIES_SINCEREQ_SET_MASTERING_DISPLAY_PRIMARIES_OPCODEREQ_SET_MASTERING_LUMINANCE_SINCEREQ_SET_MASTERING_LUMINANCE_OPCODEREQ_SET_MAX_CLL_SINCEREQ_SET_MAX_CLL_OPCODEREQ_SET_MAX_FALL_SINCEREQ_SET_MAX_FALL_OPCODE"Create the image description object using params\n\nCreate an image description object based on the parameters previously\nset on this object.\n\nThe completeness of the parameter set is verified. If the set is not\ncomplete, the protocol error incomplete_set is raised. For the\ndefinition of a complete set, see the description of this interface.\n\nThe protocol error invalid_luminance is raised if any of the following\nrequirements is not met:\n- When max_cll is set, it must be greater than min L and less or equal\nto max L of the mastering luminance range.\n- When max_fall is set, it must be greater than min L and less or equal\nto max L of the mastering luminance range.\n- When both max_cll and max_fall are set, max_fall must be less or equal\nto max_cll.\n\nIf the particular combination of the parameter set is not supported\nby the compositor, the resulting image description object shall\nimmediately deliver the wp_image_description_v1.failed event with the\n'unsupported' cause. If a valid image description was created from the\nparameter set, the wp_image_description_v1.ready event will eventually\nbe sent instead.\n\nThis request destroys the wp_image_description_creator_params_v1\nobject.\n\nThe resulting image description object does not allow get_information\nrequest.\n\nThis is a destructor, once sent this object cannot be used any longer.""named transfer characteristic\n\nSets the transfer characteristic using explicitly enumerated named\nfunctions.\n\nWhen the resulting image description is attached to an image, the\ncontent should be encoded and decoded according to the industry standard\npractices for the transfer characteristic.\n\nOnly names advertised with wp_color_manager_v1 event supported_tf_named\nare allowed. Other values shall raise the protocol error invalid_tf.\n\nIf transfer characteristic has already been set on this object, the\nprotocol error already_set is raised.""named transfer function"SetTfNamed"transfer characteristic as a power curve\n\nSets the color component transfer characteristic to a power curve with\nthe given exponent. Negative values are handled by mirroring the\npositive half of the curve through the origin. The valid domain and\nrange of the curve are all finite real numbers. This curve represents\nthe conversion from electrical to optical color channel values.\n\nWhen the resulting image description is attached to an image, the\ncontent should be encoded with the inverse of the power curve.\n\nThe curve exponent shall be multiplied by 10000 to get the argument eexp\nvalue to carry the precision of 4 decimals.\n\nThe curve exponent must be at least 1.0 and at most 10.0. Otherwise the\nprotocol error invalid_tf is raised.\n\nIf transfer characteristic has already been set on this object, the\nprotocol error already_set is raised.\n\nThis request can be used when the compositor advertises\nwp_color_manager_v1.feature.set_tf_power. Otherwise this request raises\nthe protocol error unsupported_feature.""the exponent * 10000"eexp"named primaries\n\nSets the color primaries and white point using explicitly named sets.\nThis describes the primary color volume which is the basis for color\nvalue encoding.\n\nOnly names advertised with wp_color_manager_v1 event\nsupported_primaries_named are allowed. Other values shall raise the\nprotocol error invalid_primaries_named.\n\nIf primaries have already been set on this object, the protocol error\nalready_set is raised.""named primaries"SetPrimariesNamed"primaries as chromaticity coordinates\n\nSets the color primaries and white point using CIE 1931 xy chromaticity\ncoordinates. This describes the primary color volume which is the basis\nfor color value encoding.\n\nEach coordinate value is multiplied by 1 million to get the argument\nvalue to carry precision of 6 decimals.\n\nIf primaries have already been set on this object, the protocol error\nalready_set is raised.\n\nThis request can be used if the compositor advertises\nwp_color_manager_v1.feature.set_primaries. Otherwise this request raises\nthe protocol error unsupported_feature.""Red x * 1M"r_x"Red y * 1M"r_y"Green x * 1M"g_x"Green y * 1M"g_y"Blue x * 1M"b_x"Blue y * 1M"b_y"White x * 1M"w_x"White y * 1M"w_y"primary color volume luminance range and reference white\n\nSets the primary color volume luminance range and the reference white\nluminance level. These values include the minimum display emission\nand ambient flare luminances, assumed to be optically additive and have\nthe chromaticity of the primary color volume white point.\n\nThe default luminances from\nhttps://www.color.org/chardata/rgb/srgb.xalter are\n- primary color volume minimum: 0.2 cd/m²\n- primary color volume maximum: 80 cd/m²\n- reference white: 80 cd/m²\n\nSetting a named transfer characteristic can imply other default\nluminances.\n\nThe default luminances get overwritten when this request is used.\nWith transfer_function.st2084_pq the given 'max_lum' value is ignored,\nand 'max_lum' is taken as 'min_lum' + 10000 cd/m².\n\n'min_lum' and 'max_lum' specify the minimum and maximum luminances of\nthe primary color volume as reproduced by the targeted display.\n\n'reference_lum' specifies the luminance of the reference white as\nreproduced by the targeted display, and reflects the targeted viewing\nenvironment.\n\nCompositors should make sure that all content is anchored, meaning that\nan input signal level of 'reference_lum' on one image description and\nanother input signal level of 'reference_lum' on another image\ndescription should produce the same output level, even though the\n'reference_lum' on both image representations can be different.\n\n'reference_lum' may be higher than 'max_lum'. In that case reaching\nthe reference white output level in image content requires the\n'extended_target_volume' feature support.\n\nIf 'max_lum' or 'reference_lum' are less than or equal to 'min_lum',\nthe protocol error invalid_luminance is raised.\n\nThe minimum luminance is multiplied by 10000 to get the argument\n'min_lum' value and carries precision of 4 decimals. The maximum\nluminance and reference white luminance values are unscaled.\n\nIf the primary color volume luminance range and the reference white\nluminance level have already been set on this object, the protocol error\nalready_set is raised.\n\nThis request can be used if the compositor advertises\nwp_color_manager_v1.feature.set_luminances. Otherwise this request\nraises the protocol error unsupported_feature.""minimum luminance (cd/m²) * 10000"min_lum"maximum luminance (cd/m²)"max_lum"reference white luminance (cd/m²)"reference_lum"mastering display primaries as chromaticity coordinates\n\nProvides the color primaries and white point of the mastering display\nusing CIE 1931 xy chromaticity coordinates. This is compatible with the\nSMPTE ST 2086 definition of HDR static metadata.\n\nThe mastering display primaries and mastering display luminances define\nthe target color volume.\n\nIf mastering display primaries are not explicitly set, the target color\nvolume is assumed to have the same primaries as the primary color volume.\n\nThe target color volume is defined by all tristimulus values between 0.0\nand 1.0 (inclusive) of the color space defined by the given mastering\ndisplay primaries and white point. The colorimetry is identical between\nthe container color space and the mastering display color space,\nincluding that no chromatic adaptation is applied even if the white\npoints differ.\n\nThe target color volume can exceed the primary color volume to allow for\na greater color volume with an existing color space definition (for\nexample scRGB). It can be smaller than the primary color volume to\nminimize gamut and tone mapping distances for big color spaces (HDR\nmetadata).\n\nTo make use of the entire target color volume a suitable pixel format\nhas to be chosen (e.g. floating point to exceed the primary color\nvolume, or abusing limited quantization range as with xvYCC).\n\nEach coordinate value is multiplied by 1 million to get the argument\nvalue to carry precision of 6 decimals.\n\nIf mastering display primaries have already been set on this object, the\nprotocol error already_set is raised.\n\nThis request can be used if the compositor advertises\nwp_color_manager_v1.feature.set_mastering_display_primaries. Otherwise\nthis request raises the protocol error unsupported_feature. The\nadvertisement implies support only for target color volumes fully\ncontained within the primary color volume.\n\nIf a compositor additionally supports target color volume exceeding the\nprimary color volume, it must advertise\nwp_color_manager_v1.feature.extended_target_volume. If a client uses\ntarget color volume exceeding the primary color volume and the\ncompositor does not support it, the result is implementation defined.\nCompositors are recommended to detect this case and fail the image\ndescription gracefully, but it may as well result in color artifacts.""display mastering luminance range\n\nSets the luminance range that was used during the content mastering\nprocess as the minimum and maximum absolute luminance L. These values\ninclude the minimum display emission and ambient flare luminances,\nassumed to be optically additive and have the chromaticity of the\nprimary color volume white point. This should be\ncompatible with the SMPTE ST 2086 definition of HDR static metadata.\n\nThe mastering display primaries and mastering display luminances define\nthe target color volume.\n\nIf mastering luminances are not explicitly set, the target color volume\nis assumed to have the same min and max luminances as the primary color\nvolume.\n\nIf max L is less than or equal to min L, the protocol error\ninvalid_luminance is raised.\n\nMin L value is multiplied by 10000 to get the argument min_lum value\nand carry precision of 4 decimals. Max L value is unscaled for max_lum.\n\nThis request can be used if the compositor advertises\nwp_color_manager_v1.feature.set_mastering_display_primaries. Otherwise\nthis request raises the protocol error unsupported_feature. The\nadvertisement implies support only for target color volumes fully\ncontained within the primary color volume.\n\nIf a compositor additionally supports target color volume exceeding the\nprimary color volume, it must advertise\nwp_color_manager_v1.feature.extended_target_volume. If a client uses\ntarget color volume exceeding the primary color volume and the\ncompositor does not support it, the result is implementation defined.\nCompositors are recommended to detect this case and fail the image\ndescription gracefully, but it may as well result in color artifacts.""min L (cd/m²) * 10000""max L (cd/m²)"SetMasteringLuminance"maximum content light level\n\nSets the maximum content light level (max_cll) as defined by CTA-861-H.\n\nmax_cll is undefined by default.""Maximum content light level (cd/m²)"SetMaxCll"maximum frame-average light level\n\nSets the maximum frame-average light level (max_fall) as defined by\nCTA-861-H.\n\nmax_fall is undefined by default.""Maximum frame-average light level (cd/m²)"SetMaxFall"holder of image description parameters\n\nThis type of object is used for collecting all the parameters required\nto create a wp_image_description_v1 object. A complete set of required\nparameters consists of these properties:\n- transfer characteristic function (tf)\n- chromaticities of primaries and white point (primary color volume)\n\nThe following properties are optional and have a well-defined default\nif not explicitly set:\n- primary color volume luminance range\n- reference white luminance level\n- mastering display primaries and white point (target color volume)\n- mastering luminance range\n\nThe following properties are optional and will be ignored\nif not explicitly set:\n- maximum content light level\n- maximum frame-average light level\n\nEach required property must be set exactly once if the client is to create\nan image description. The set requests verify that a property was not\nalready set. The create request verifies that all required properties are\nset. There may be several alternative requests for setting each property,\nand in that case the client must choose one of them.\n\nOnce all properties have been set, the create request must be used to\ncreate the image description object, destroying the creator in the\nprocess.\n\nThis interface has no events.""Create the image description object using params\n\nCreate an image description object based on the parameters previously\nset on this object.\n\nThe completeness of the parameter set is verified. If the set is not\ncomplete, the protocol error incomplete_set is raised. For the\ndefinition of a complete set, see the description of this interface.\n\nThe protocol error invalid_luminance is raised if any of the following\nrequirements is not met:\n- When max_cll is set, it must be greater than min L and less or equal\nto max L of the mastering luminance range.\n- When max_fall is set, it must be greater than min L and less or equal\nto max L of the mastering luminance range.\n- When both max_cll and max_fall are set, max_fall must be less or equal\nto max_cll.\n\nIf the particular combination of the parameter set is not supported\nby the compositor, the resulting image description object shall\nimmediately deliver the wp_image_description_v1.failed event with the\n'unsupported' cause. If a valid image description was created from the\nparameter set, the wp_image_description_v1.ready event will eventually\nbe sent instead.\n\nThis request destroys the wp_image_description_creator_params_v1\nobject.\n\nThe resulting image description object does not allow get_information\nrequest."set_tf_namedset_tf_powerset_primaries_namedset_primariesset_luminancesset_mastering_display_primariesset_mastering_luminanceset_max_cllset_max_fall"Colorimetric image description\n\nAn image description carries information about the color encoding used on\na surface when attached to a wl_surface via\nwp_color_management_surface_v1.set_image_description. A compositor can use\nthis information to decode pixel values into colorimetrically meaningful\nquantities.\n\nNote, that the wp_image_description_v1 object is not ready to be used\nimmediately after creation. The object eventually delivers either the\n'ready' or the 'failed' event, specified in all requests creating it. The\nobject is deemed \"ready\" after receiving the 'ready' event.\n\nAn object which is not ready is illegal to use, it can only be destroyed.\nAny other request in this interface shall result in the 'not_ready'\nprotocol error. Attempts to use an object which is not ready through other\ninterfaces shall raise protocol errors defined there.\n\nOnce created and regardless of how it was created, a\nwp_image_description_v1 object always refers to one fixed image\ndescription. It cannot change after creation.""attempted to use an object which is not ready""get_information not allowed"NoInformation"generic reason for failure""interface version too low"LowVersion"unsupported image description data""error independent of the client""the relevant output no longer exists"REQ_GET_INFORMATION_SINCEREQ_GET_INFORMATION_OPCODE"destroy the image description\n\nDestroy this object. It is safe to destroy an object which is not ready.\n\nDestroying a wp_image_description_v1 object has no side-effects, not\neven if a wp_color_management_surface_v1.set_image_description has not\nyet been followed by a wl_surface.commit.\n\nThis is a destructor, once sent this object cannot be used any longer.""get information about the image description\n\nCreates a wp_image_description_info_v1 object which delivers the\ninformation that makes up the image description.\n\nNot all image description protocol objects allow get_information\nrequest. Whether it is allowed or not is defined by the request that\ncreated the object. If get_information is not allowed, the protocol\nerror no_information is raised."GetInformation"graceful error on creating the image description\n\nIf creating a wp_image_description_v1 object fails for a reason that is\nnot defined as a protocol error, this event is sent.\n\nThe requests that create image description objects define whether and\nwhen this can occur. Only such creation requests can trigger this event.\nThis event cannot be triggered after the image description was\nsuccessfully formed.\n\nOnce this event has been sent, the wp_image_description_v1 object will\nnever become ready and it can only be destroyed.""generic reason""ad hoc human-readable explanation""indication that the object is ready to be used\n\nOnce this event has been sent, the wp_image_description_v1 object is\ndeemed \"ready\". Ready objects can be used to send requests and can be\nused through other interfaces.\n\nEvery ready wp_image_description_v1 protocol object refers to an\nunderlying image description record in the compositor. Multiple protocol\nobjects may end up referring to the same record. Clients may identify\nthese \"copies\" by comparing their id numbers: if the numbers from two\nprotocol objects are identical, the protocol objects refer to the same\nimage description record. Two different image description records\ncannot have the same id number simultaneously. The id number does not\nchange during the lifetime of the image description record.\n\nThe id number is valid only as long as the protocol object is alive. If\nall protocol objects referring to the same image description record are\ndestroyed, the id number may be recycled for a different image\ndescription record.\n\nImage description id number is not a protocol object id. Zero is\nreserved as an invalid id number. It shall not be possible for a client\nto refer to an image description by its id number in protocol. The id\nnumbers might not be portable between Wayland connections. A compositor\nshall not send an invalid id number.\n\nThis identity allows clients to de-duplicate image description records\nand avoid get_information request if they already have the image\ndescription information.""Colorimetric image description\n\nAn image description carries information about the color encoding used on\na surface when attached to a wl_surface via\nwp_color_management_surface_v1.set_image_description. A compositor can use\nthis information to decode pixel values into colorimetrically meaningful\nquantities.\n\nNote, that the wp_image_description_v1 object is not ready to be used\nimmediately after creation. The object eventually delivers either the\n'ready' or the 'failed' event, specified in all requests creating it. The\nobject is deemed \"ready\" after receiving the 'ready' event.\n\nAn object which is not ready is illegal to use, it can only be destroyed.\nAny other request in this interface shall result in the 'not_ready'\nprotocol error. Attempts to use an object which is not ready through other\ninterfaces shall raise protocol errors defined there.\n\nOnce created and regardless of how it was created, a\nwp_image_description_v1 object always refers to one fixed image\ndescription. It cannot change after creation.\n\nSee also the [Event] enum for this interface.""destroy the image description\n\nDestroy this object. It is safe to destroy an object which is not ready.\n\nDestroying a wp_image_description_v1 object has no side-effects, not\neven if a wp_color_management_surface_v1.set_image_description has not\nyet been followed by a wl_surface.commit."wp_image_description_info_v1WpImageDescriptionInfoV1get_information"Colorimetric image description information\n\nSends all matching events describing an image description object exactly\nonce and finally sends the 'done' event.\n\nThis means\n- if the image description is parametric, it must send\n- primaries\n- named_primaries, if applicable\n- at least one of tf_power and tf_named, as applicable\n- luminances\n- target_primaries\n- target_luminance\n- if the image description is parametric, it may send, if applicable,\n- target_max_cll\n- target_max_fall\n- if the image description contains an ICC profile, it must send the\nicc_file event\n\nOnce a wp_image_description_info_v1 object has delivered a 'done' event it\nis automatically destroyed.\n\nEvery wp_image_description_info_v1 created from the same\nwp_image_description_v1 shall always return the exact same data."EVT_ICC_FILE_SINCEEVT_ICC_FILE_OPCODEEVT_PRIMARIES_SINCEEVT_PRIMARIES_OPCODEEVT_PRIMARIES_NAMED_SINCEEVT_PRIMARIES_NAMED_OPCODEEVT_TF_POWER_SINCEEVT_TF_POWER_OPCODEEVT_TF_NAMED_SINCEEVT_TF_NAMED_OPCODEEVT_LUMINANCES_SINCEEVT_LUMINANCES_OPCODEEVT_TARGET_PRIMARIES_SINCEEVT_TARGET_PRIMARIES_OPCODEEVT_TARGET_LUMINANCE_SINCEEVT_TARGET_LUMINANCE_OPCODEEVT_TARGET_MAX_CLL_SINCEEVT_TARGET_MAX_CLL_OPCODEEVT_TARGET_MAX_FALL_SINCEEVT_TARGET_MAX_FALL_OPCODE"end of information\n\nSignals the end of information events and destroys the object.\n\nThis is a destructor, once received this object cannot be used any longer.""ICC profile matching the image description\n\nThe icc argument provides a file descriptor to the client which may be\nmemory-mapped to provide the ICC profile matching the image description.\nThe fd is read-only, and if mapped then it must be mapped with\nMAP_PRIVATE by the client.\n\nThe ICC profile version and other details are determined by the\ncompositor. There is no provision for a client to ask for a specific\nkind of a profile.""ICC profile file descriptor"icc"ICC profile size, in bytes"icc_sizeIccFile"primaries as chromaticity coordinates\n\nDelivers the primary color volume primaries and white point using CIE\n1931 xy chromaticity coordinates.\n\nEach coordinate value is multiplied by 1 million to get the argument\nvalue to carry precision of 6 decimals.""named primaries\n\nDelivers the primary color volume primaries and white point using an\nexplicitly enumerated named set."PrimariesNamed"transfer characteristic as a power curve\n\nThe color component transfer characteristic of this image description is\na pure power curve. This event provides the exponent of the power\nfunction. This curve represents the conversion from electrical to\noptical pixel or color values.\n\nThe curve exponent has been multiplied by 10000 to get the argument eexp\nvalue to carry the precision of 4 decimals."TfPower"named transfer characteristic\n\nDelivers the transfer characteristic using an explicitly enumerated\nnamed function."TfNamed"primary color volume luminance range and reference white\n\nDelivers the primary color volume luminance range and the reference\nwhite luminance level. These values include the minimum display emission\nand ambient flare luminances, assumed to be optically additive and have\nthe chromaticity of the primary color volume white point.\n\nThe minimum luminance is multiplied by 10000 to get the argument\n'min_lum' value and carries precision of 4 decimals. The maximum\nluminance and reference white luminance values are unscaled."Luminances"target primaries as chromaticity coordinates\n\nProvides the color primaries and white point of the target color volume\nusing CIE 1931 xy chromaticity coordinates. This is compatible with the\nSMPTE ST 2086 definition of HDR static metadata for mastering displays.\n\nWhile primary color volume is about how color is encoded, the target\ncolor volume is the actually displayable color volume. If target color\nvolume is equal to the primary color volume, then this event is not\nsent.\n\nEach coordinate value is multiplied by 1 million to get the argument\nvalue to carry precision of 6 decimals."TargetPrimaries"target luminance range\n\nProvides the luminance range that the image description is targeting as\nthe minimum and maximum absolute luminance L. These values include the\nminimum display emission and ambient flare luminances, assumed to be\noptically additive and have the chromaticity of the primary color\nvolume white point. This should be compatible with the SMPTE ST 2086\ndefinition of HDR static metadata.\n\nThis luminance range is only theoretical and may not correspond to the\nluminance of light emitted on an actual display.\n\nMin L value is multiplied by 10000 to get the argument min_lum value and\ncarry precision of 4 decimals. Max L value is unscaled for max_lum."TargetLuminance"target maximum content light level\n\nProvides the targeted max_cll of the image description. max_cll is\ndefined by CTA-861-H.\n\nThis luminance is only theoretical and may not correspond to the\nluminance of light emitted on an actual display.""Maximum content light-level (cd/m²)"TargetMaxCll"target maximum frame-average light level\n\nProvides the targeted max_fall of the image description. max_fall is\ndefined by CTA-861-H.\n\nThis luminance is only theoretical and may not correspond to the\nluminance of light emitted on an actual display."TargetMaxFall"Colorimetric image description information\n\nSends all matching events describing an image description object exactly\nonce and finally sends the 'done' event.\n\nThis means\n- if the image description is parametric, it must send\n- primaries\n- named_primaries, if applicable\n- at least one of tf_power and tf_named, as applicable\n- luminances\n- target_primaries\n- target_luminance\n- if the image description is parametric, it may send, if applicable,\n- target_max_cll\n- target_max_fall\n- if the image description contains an ICC profile, it must send the\nicc_file event\n\nOnce a wp_image_description_info_v1 object has delivered a 'done' event it\nis automatically destroyed.\n\nEvery wp_image_description_info_v1 created from the same\nwp_image_description_v1 shall always return the exact same data.\n\nSee also the [Event] enum for this interface."//! The aim of the color management extension is to allow clients to know//! the color properties of outputs, and to tell the compositor about the color//! properties of their content on surfaces. Doing this enables a compositor//! to perform automatic color management of content for different outputs//! according to how content is intended to look like.//! The color properties are represented as an image description object which//! is immutable after it has been created. A wl_output always has an//! associated image description that clients can observe. A wl_surface//! always has an associated preferred image description as a hint chosen by//! the compositor that clients can also observe. Clients can set an image//! description on a wl_surface to denote the color characteristics of the//! surface contents.//! An image description includes SDR and HDR colorimetry and encoding, HDR//! metadata, and viewing environment parameters. An image description does//! not include the properties set through color-representation extension.//! It is expected that the color-representation extension is used in//! conjunction with the color management extension when necessary,//! particularly with the YUV family of pixel formats.//! Recommendation ITU-T H.273//! "Coding-independent code points for video signal type identification"//! shall be referred to as simply H.273 here.//! The color-and-hdr repository//! (<https://gitlab.freedesktop.org/pq/color-and-hdr>) contains//! background information on the protocol design and legacy color management.//! It also contains a glossary, learning resources for digital color, tools,//! samples and more.//! The terminology used in this protocol is based on common color science and//! color encoding terminology where possible. The glossary in the color-and-hdr//! repository shall be the authority on the definition of terms in this//! protocol.color_managementWP_COLOR_REPRESENTATION_MANAGER_V1_INTERFACEwp_color_representation_manager_v1_requests_get_surface_typeswp_color_representation_manager_v1_requestswp_color_representation_manager_v1_eventswp_color_representation_manager_v1_interfaceWP_COLOR_REPRESENTATION_SURFACE_V1_INTERFACEwp_color_representation_surface_v1_requestswp_color_representation_surface_v1_interface"color representation manager singleton\n\nA singleton global interface used for getting color representation\nextensions for wl_surface. The extension interfaces allow setting the\ncolor representation of surfaces.\n\nCompositors should never remove this global.""color representation surface exists already"EVT_SUPPORTED_ALPHA_MODE_SINCEEVT_SUPPORTED_ALPHA_MODE_OPCODEEVT_SUPPORTED_COEFFICIENTS_AND_RANGES_SINCEEVT_SUPPORTED_COEFFICIENTS_AND_RANGES_OPCODE"destroy the manager\n\nDestroy the wp_color_representation_manager_v1 object. This does not\naffect any other objects in any way.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a color representation interface for a wl_surface\n\nIf a wp_color_representation_surface_v1 object already exists for the\ngiven wl_surface, the protocol error surface_exists is raised.\n\nThis creates a new color wp_color_representation_surface_v1 object for\nthe given wl_surface.\n\nSee the wp_color_representation_surface_v1 interface for more details.""supported alpha modes\n\nWhen this object is created, it shall immediately send this event once\nfor each alpha mode the compositor supports.\n\nFor the definition of the supported values, see the\nwp_color_representation_surface_v1::alpha_mode enum.""supported alpha mode"alpha_modewp_color_representation_surface_v1AlphaModeSupportedAlphaMode"supported matrix coefficients and ranges\n\nWhen this object is created, it shall immediately send this event once\nfor each matrix coefficient and color range combination the compositor\nsupports.\n\nFor the definition of the supported values, see the\nwp_color_representation_surface_v1::coefficients and\nwp_color_representation_surface_v1::range enums.""supported matrix coefficients"Coefficients"full range flag"SupportedCoefficientsAndRanges"all features have been sent\n\nThis event is sent when all supported features have been sent.""color representation manager singleton\n\nA singleton global interface used for getting color representation\nextensions for wl_surface. The extension interfaces allow setting the\ncolor representation of surfaces.\n\nCompositors should never remove this global.\n\nSee also the [Event] enum for this interface."WpColorRepresentationManagerV1"destroy the manager\n\nDestroy the wp_color_representation_manager_v1 object. This does not\naffect any other objects in any way."WpColorRepresentationSurfaceV1wp_color_representation_manager_v1"color representation extension to a surface\n\nA wp_color_representation_surface_v1 allows the client to set the color\nrepresentation metadata of a surface.\n\nBy default, a surface does not have any color representation metadata set.\nThe reconstruction of R, G, B signals on such surfaces is compositor\nimplementation defined. The alpha mode is assumed to be\npremultiplied_electrical when the alpha mode is unset.\n\nIf the wl_surface associated with the wp_color_representation_surface_v1\nis destroyed, the wp_color_representation_surface_v1 object becomes inert.""unsupported alpha mode""unsupported coefficients""the pixel format and a set value are incompatible""alpha mode\n\nSpecifies how the alpha channel affects the color channels.""premultiplied alpha in electrical values\n\nElectrical color channel values (after transfer function encoding)\nare already multiplied with the alpha channel value."PremultipliedElectrical"premultiplied alpha in optical values\n\nOptical color channel values (before transfer function encoding)\nare already multiplied with the alpha channel value."PremultipliedOptical"straight alpha\n\nAlpha channel has not been pre-multiplied into color channels."Straight"named coefficients\n\nNamed matrix coefficients used to encode well-known sets of\ncoefficients. H.273 is the authority, when it comes to the exact values\nof coefficients and authoritative specifications, where an equivalent\ncode point exists.\n\nA value of 0 is invalid and will never be present in the list of enums.\n\nDescriptions do list the specifications for convenience.""The identity matrix\n\nCoefficients as defined by\n- IEC 61966-2-1 sRGB\n- SMPTE ST 428-1 (2019)\n\nEquivalent to H.273 MatrixCoefficients code point 0.\nCompatible with pixel formats of the RGB family.""BT.709 matrix coefficients\n\nCoefficients as defined by\n- Rec. ITU-R BT.709-6\n- Rec. ITU-R BT.1361-0 conventional colour gamut system (historical)\n- Rec. ITU-R BT.1361-0 conventional colour gamut system and extended\ncolour gamut system (historical)\n- IEC 61966-2-4 xvYCC709\n- SMPTE RP 177 (1993) Annex B\n\nEquivalent to H.273 MatrixCoefficients code point 1.\nCompatible with pixel formats of the YCbCr family.""FCC matrix coefficients\n\nCoefficients as defined by\n- United States Federal Communications Commission (2003) Title 47\nCode of Federal Regulations 73.682 (a) (20)\n\nEquivalent to H.273 MatrixCoefficients code point 4.\nCompatible with pixel formats of the YCbCr family.""BT.601-7 matrix coefficients\n\nCoefficients as defined by\n- Rec. ITU-R BT.470-6 System B, G (historical)\n- Rec. ITU-R BT.601-7 625\n- Rec. ITU-R BT.601-7 525\n- Rec. ITU-R BT.1358-0 625 (historical)\n- Rec. ITU-R BT.1358-1 525 or 625 (historical)\n- Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM\n- Rec. ITU-R BT.1700-0 NTSC\n- IEC 61966-2-1 sYCC\n- IEC 61966-2-4 xvYCC601\n- SMPTE ST 170 (2004)\n\nEquivalent to H.273 MatrixCoefficients code point 5, 6.\nCompatible with pixel formats of the YCbCr family.""SMPTE ST 240 matrix coefficients\n\nCoefficients as defined by\n- SMPTE ST 240 (1999)\n\nEquivalent to H.273 MatrixCoefficients code point 7.\nCompatible with pixel formats of the YCbCr family."Smpte240"BT.2020 and BT.2100 YCbCr matrix coefficients\n\nCoefficients as defined by\n- Rec. ITU-R BT.2020-2 (non-constant luminance)\n- Rec. ITU-R BT.2100-2 Y′CbCr\n\nEquivalent to H.273 MatrixCoefficients code point 9.\nCompatible with pixel formats of the YCbCr family.""BT.2020 matrix coefficients for constant luminance\n\nCoefficients as defined by\n- Rec. ITU-R BT.2020-2 (constant luminance)\n\nEquivalent to H.273 MatrixCoefficients code point 10.\nCompatible with pixel formats of the YCbCr family."Bt2020Cl"BT.2100 ICtCp matrix coefficients\n\nCoefficients as defined by\n- Rec. ITU-R BT.2100-2 ICTCP\n\nEquivalent to H.273 MatrixCoefficients code point 14.\nCompatible with pixel formats of the YCbCr family."Ictcp"Color range values\n\nPossible color range values.\n\nA value of 0 is invalid and will never be present in the list of enums.""Full color range""Limited color range""Chroma sample location for 4:2:0 YCbCr\n\nChroma sample location as defined by H.273 Chroma420SampleLocType.\n\nA value of 0 is invalid and will never be present in the list of enums.\n\nThe descriptions list the matching Vulkan VkChromaLocation combinations\nfor convenience."ChromaLocation"Horizontal offset of 0, vertical offset of 0.5\n\nCorresponding to VkChromaLocations:\n- xChromaOffset: VK_CHROMA_LOCATION_COSITED_EVEN\n- yChromaOffset: VK_CHROMA_LOCATION_MIDPOINT\n\nEquivalent to H.273 Chroma420SampleLocType 0."Type0"Horizontal offset of 0.5, vertical offset of 0.5\n\nCorresponding to VkChromaLocations:\n- xChromaOffset: VK_CHROMA_LOCATION_MIDPOINT\n- yChromaOffset: VK_CHROMA_LOCATION_MIDPOINT\n\nEquivalent to H.273 Chroma420SampleLocType 1."Type1"Horizontal offset of 0, vertical offset of 0\n\nCorresponding to VkChromaLocations:\n- xChromaOffset: VK_CHROMA_LOCATION_COSITED_EVEN\n- yChromaOffset: VK_CHROMA_LOCATION_COSITED_EVEN\n\nEquivalent to H.273 Chroma420SampleLocType 2."Type2"Horizontal offset of 0.5, vertical offset of 0\n\nCorresponding to VkChromaLocations:\n- xChromaOffset: VK_CHROMA_LOCATION_MIDPOINT\n- yChromaOffset: VK_CHROMA_LOCATION_COSITED_EVEN\n\nEquivalent to H.273 Chroma420SampleLocType 3."Type3"Horizontal offset of 0, vertical offset of 1\n\nEquivalent to H.273 Chroma420SampleLocType 4."Type4"Horizontal offset of 0.5, vertical offset of 1\n\nEquivalent to H.273 Chroma420SampleLocType 5."Type5REQ_SET_ALPHA_MODE_SINCEREQ_SET_ALPHA_MODE_OPCODEREQ_SET_COEFFICIENTS_AND_RANGE_SINCEREQ_SET_COEFFICIENTS_AND_RANGE_OPCODEREQ_SET_CHROMA_LOCATION_SINCEREQ_SET_CHROMA_LOCATION_OPCODE"destroy the color representation\n\nDestroy the wp_color_representation_surface_v1 object.\n\nDestroying this object unsets all the color representation metadata from\nthe surface. See the wp_color_representation_surface_v1 interface\ndescription for how a compositor handles a surface without color\nrepresentation metadata. Unsetting is double-buffered state, see\nwl_surface.commit.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the surface alpha mode\n\nIf this protocol object is inert, the protocol error inert is raised.\n\nAssuming an alpha channel exists, it is always linear. The alpha mode\ndetermines whether and how the color channels include pre-multiplied\nalpha. Using straight alpha might have performance benefits.\n\nOnly alpha modes advertised by the compositor are allowed to be used as\nargument for this request. The \"alpha_mode\" protocol error is raised\notherwise.\n\nAlpha mode is double buffered, see wl_surface.commit.""alpha mode"SetAlphaMode"set the matrix coefficients and range\n\nIf this protocol object is inert, the protocol error inert is raised.\n\nSet the matrix coefficients and video range which defines the formula\nand the related constants used to derive red, green and blue signals.\nUsually coefficients correspond to MatrixCoefficients code points in\nH.273.\n\nOnly combinations advertised by the compositor are allowed to be used as\nargument for this request. The \"coefficients\" protocol error is raised\notherwise.\n\nA call to wl_surface.commit verifies that the pixel format and the\ncoefficients-range combination in the committed surface contents are\ncompatible, if contents exist. The \"pixel_format\" protocol error is\nraised otherwise.\n\nA pixel format is compatible with the coefficients-range combination if\nthe related equations and conventions as defined in H.273 can produce\nthe color channels (RGB or YCbCr) of the pixel format.\n\nFor the definition of the supported combination, see the\nwp_color_representation_surface_v1::coefficients and\nwp_color_representation_surface_v1::range enums.\n\nThe coefficients-range combination is double-buffered, see\nwl_surface.commit.""matrix coefficients""range"SetCoefficientsAndRange"set the chroma location\n\nIf this protocol object is inert, the protocol error inert is raised.\n\nSet the chroma location type which defines the position of downsampled\nchroma samples, corresponding to Chroma420SampleLocType code points in\nH.273.\n\nA call to wl_surface.commit verifies that the pixel format and chroma\nlocation type in the committed surface contents are compatible, if\ncontents exist. The \"pixel_format\" protocol error is raised otherwise.\n\nFor the definition of the supported chroma location types, see the\nwp_color_representation_surface_v1::chroma_location enum.\n\nThe chroma location type is double-buffered, see wl_surface.commit.""chroma sample location"chroma_locationSetChromaLocation"color representation extension to a surface\n\nA wp_color_representation_surface_v1 allows the client to set the color\nrepresentation metadata of a surface.\n\nBy default, a surface does not have any color representation metadata set.\nThe reconstruction of R, G, B signals on such surfaces is compositor\nimplementation defined. The alpha mode is assumed to be\npremultiplied_electrical when the alpha mode is unset.\n\nIf the wl_surface associated with the wp_color_representation_surface_v1\nis destroyed, the wp_color_representation_surface_v1 object becomes inert.\n\nThis interface has no events.""destroy the color representation\n\nDestroy the wp_color_representation_surface_v1 object.\n\nDestroying this object unsets all the color representation metadata from\nthe surface. See the wp_color_representation_surface_v1 interface\ndescription for how a compositor handles a surface without color\nrepresentation metadata. Unsetting is double-buffered state, see\nwl_surface.commit."set_coefficients_and_rangeset_chroma_location//! This protocol extension delivers the metadata required to define alpha mode,//! the color model, sub-sampling and quantization range used when interpreting//! buffer contents. The main use case is defining how the YCbCr family of pixel//! formats convert to RGB.//! Note that this protocol does not define the colorimetry of the resulting RGB//! channels / tristimulus values. Without the help of other extensions the//! resulting colorimetry is therefore implementation defined.//! If this extension is not used, the color representation used is compositor//! implementation defined.color_representationWP_DRM_LEASE_DEVICE_V1_INTERFACEwp_drm_lease_device_v1_requests_create_lease_request_typeswp_drm_lease_device_v1_requestswp_drm_lease_device_v1_events_connector_typeswp_drm_lease_device_v1_eventswp_drm_lease_device_v1_interfaceWP_DRM_LEASE_CONNECTOR_V1_INTERFACEwp_drm_lease_connector_v1_requestswp_drm_lease_connector_v1_eventswp_drm_lease_connector_v1_interfaceWP_DRM_LEASE_REQUEST_V1_INTERFACEwp_drm_lease_request_v1_requests_request_connector_typeswp_drm_lease_request_v1_requests_submit_typeswp_drm_lease_request_v1_requestswp_drm_lease_request_v1_interfaceWP_DRM_LEASE_V1_INTERFACEwp_drm_lease_v1_requestswp_drm_lease_v1_eventswp_drm_lease_v1_interface"lease device\n\nThis protocol is used by Wayland compositors which act as Direct\nRendering Manager (DRM) masters to lease DRM resources to Wayland\nclients.\n\nThe compositor will advertise one wp_drm_lease_device_v1 global for each\nDRM node. Some time after a client binds to the wp_drm_lease_device_v1\nglobal, the compositor will send a drm_fd event followed by zero, one or\nmore connector events. After all currently available connectors have been\nsent, the compositor will send a wp_drm_lease_device_v1.done event.\n\nWhen the list of connectors available for lease changes the compositor\nwill send wp_drm_lease_device_v1.connector events for added connectors and\nwp_drm_lease_connector_v1.withdrawn events for removed connectors,\nfollowed by a wp_drm_lease_device_v1.done event.\n\nThe compositor will indicate when a device is gone by removing the global\nvia a wl_registry.global_remove event. Upon receiving this event, the\nclient should destroy any matching wp_drm_lease_device_v1 object.\n\nTo destroy a wp_drm_lease_device_v1 object, the client must first issue\na release request. Upon receiving this request, the compositor will\nimmediately send a released event and destroy the object. The client must\ncontinue to process and discard drm_fd and connector events until it\nreceives the released event. Upon receiving the released event, the\nclient can safely cleanup any client-side resources.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension."REQ_CREATE_LEASE_REQUEST_SINCEREQ_CREATE_LEASE_REQUEST_OPCODEEVT_DRM_FD_SINCEEVT_DRM_FD_OPCODEEVT_CONNECTOR_SINCEEVT_CONNECTOR_OPCODEEVT_RELEASED_SINCEEVT_RELEASED_OPCODE"create a lease request object\n\nCreates a lease request object.\n\nSee the documentation for wp_drm_lease_request_v1 for details."CreateLeaseRequest"release this object\n\nIndicates the client no longer wishes to use this object. In response\nthe compositor will immediately send the released event and destroy\nthis object. It can however not guarantee that the client won't receive\nconnector events before the released event. The client must not send any\nrequests after this one, doing so will raise a wl_display error.\nExisting connectors, lease request and leases will not be affected.""open a non-master fd for this DRM node\n\nThe compositor will send this event when the wp_drm_lease_device_v1\nglobal is bound, although there are no guarantees as to how long this\ntakes - the compositor might need to wait until regaining DRM master.\nThe included fd is a non-master DRM file descriptor opened for this\ndevice and the compositor must not authenticate it.\nThe purpose of this event is to give the client the ability to\nquery DRM and discover information which may help them pick the\nappropriate DRM device or select the appropriate connectors therein.""DRM file descriptor"DrmFd"advertise connectors available for leases\n\nThe compositor will use this event to advertise connectors available for\nlease by clients. This object may be passed into a lease request to\nindicate the client would like to lease that connector, see\nwp_drm_lease_request_v1.request_connector for details. While the\ncompositor will make a best effort to not send disconnected connectors,\nno guarantees can be made.\n\nThe compositor must send the drm_fd event before sending connectors.\nAfter the drm_fd event it will send all available connectors but may\nsend additional connectors at any time."wp_drm_lease_connector_v1WpDrmLeaseConnectorV1"signals grouping of connectors\n\nThe compositor will send this event to indicate that it has sent all\ncurrently available connectors after the client binds to the global or\nwhen it updates the connector list, for example on hotplug, drm master\nchange or when a leased connector becomes available again. It will\nsimilarly send this event to group wp_drm_lease_connector_v1.withdrawn\nevents of connectors of this device.""the compositor has finished using the device\n\nThis event is sent in response to the release request and indicates\nthat the compositor is done sending connector events.\nThe compositor will destroy this object immediately after sending the\nevent and it will become invalid. The client should release any\nresources associated with this device after receiving this event.\n\nThis is a destructor, once received this object cannot be used any longer.""lease device\n\nThis protocol is used by Wayland compositors which act as Direct\nRendering Manager (DRM) masters to lease DRM resources to Wayland\nclients.\n\nThe compositor will advertise one wp_drm_lease_device_v1 global for each\nDRM node. Some time after a client binds to the wp_drm_lease_device_v1\nglobal, the compositor will send a drm_fd event followed by zero, one or\nmore connector events. After all currently available connectors have been\nsent, the compositor will send a wp_drm_lease_device_v1.done event.\n\nWhen the list of connectors available for lease changes the compositor\nwill send wp_drm_lease_device_v1.connector events for added connectors and\nwp_drm_lease_connector_v1.withdrawn events for removed connectors,\nfollowed by a wp_drm_lease_device_v1.done event.\n\nThe compositor will indicate when a device is gone by removing the global\nvia a wl_registry.global_remove event. Upon receiving this event, the\nclient should destroy any matching wp_drm_lease_device_v1 object.\n\nTo destroy a wp_drm_lease_device_v1 object, the client must first issue\na release request. Upon receiving this request, the compositor will\nimmediately send a released event and destroy the object. The client must\ncontinue to process and discard drm_fd and connector events until it\nreceives the released event. Upon receiving the released event, the\nclient can safely cleanup any client-side resources.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nSee also the [Event] enum for this interface."WpDrmLeaseDeviceV1wp_drm_lease_request_v1WpDrmLeaseRequestV1create_lease_requestwp_drm_lease_device_v1"a leasable DRM connector\n\nRepresents a DRM connector which is available for lease. These objects are\ncreated via wp_drm_lease_device_v1.connector events, and should be passed\nto lease requests via wp_drm_lease_request_v1.request_connector.\nImmediately after the wp_drm_lease_connector_v1 object is created the\ncompositor will send a name, a description, a connector_id and a done\nevent. When the description is updated the compositor will send a\ndescription event followed by a done event."EVT_CONNECTOR_ID_SINCEEVT_CONNECTOR_ID_OPCODEEVT_WITHDRAWN_SINCEEVT_WITHDRAWN_OPCODE"destroy connector\n\nThe client may send this request to indicate that it will not use this\nconnector. Clients are encouraged to send this after receiving the\n\"withdrawn\" event so that the server can release the resources\nassociated with this connector offer. Neither existing lease requests\nnor leases will be affected.\n\nThis is a destructor, once sent this object cannot be used any longer.""name\n\nThe compositor sends this event once the connector is created to\nindicate the name of this connector. This will not change for the\nduration of the Wayland session, but is not guaranteed to be consistent\nbetween sessions.\n\nIf the compositor supports wl_output version 4 and this connector\ncorresponds to a wl_output, the compositor should use the same name as\nfor the wl_output.""connector name""description\n\nThe compositor sends this event once the connector is created to provide\na human-readable description for this connector, which may be presented\nto the user. The compositor may send this event multiple times over the\nlifetime of this object to reflect changes in the description.""connector description""connector_id\n\nThe compositor sends this event once the connector is created to\nindicate the DRM object ID which represents the underlying connector\nthat is being offered. Note that the final lease may include additional\nobject IDs, such as CRTCs and planes.""DRM connector ID"ConnectorId"all properties have been sent\n\nThis event is sent after all properties of a connector have been sent.\nThis allows changes to the properties to be seen as atomic even if they\nhappen via multiple events.""lease offer withdrawn\n\nSent to indicate that the compositor will no longer honor requests for\nDRM leases which include this connector. The client may still issue a\nlease request including this connector, but the compositor will send\nwp_drm_lease_v1.finished without issuing a lease fd. Compositors are\nencouraged to send this event when they lose access to connector, for\nexample when the connector is hot-unplugged, when the connector gets\nleased to a client or when the compositor loses DRM master.\n\nIf a client holds a lease for the connector, the status of the lease\nremains the same. The client should destroy the object after receiving\nthis event."Withdrawn"a leasable DRM connector\n\nRepresents a DRM connector which is available for lease. These objects are\ncreated via wp_drm_lease_device_v1.connector events, and should be passed\nto lease requests via wp_drm_lease_request_v1.request_connector.\nImmediately after the wp_drm_lease_connector_v1 object is created the\ncompositor will send a name, a description, a connector_id and a done\nevent. When the description is updated the compositor will send a\ndescription event followed by a done event.\n\nSee also the [Event] enum for this interface.""destroy connector\n\nThe client may send this request to indicate that it will not use this\nconnector. Clients are encouraged to send this after receiving the\n\"withdrawn\" event so that the server can release the resources\nassociated with this connector offer. Neither existing lease requests\nnor leases will be affected.""DRM lease request\n\nA client that wishes to lease DRM resources will attach the list of\nconnectors advertised with wp_drm_lease_device_v1.connector that they\nwish to lease, then use wp_drm_lease_request_v1.submit to submit the\nrequest.""requested a connector from a different lease device"WrongDevice"requested a connector twice"DuplicateConnector"requested a lease without requesting a connector"EmptyLeaseREQ_REQUEST_CONNECTOR_SINCEREQ_REQUEST_CONNECTOR_OPCODEREQ_SUBMIT_SINCEREQ_SUBMIT_OPCODE"request a connector for this lease\n\nIndicates that the client would like to lease the given connector.\nThis is only used as a suggestion, the compositor may choose to\ninclude any resources in the lease it issues, or change the set of\nleased resources at any time. Compositors are however encouraged to\ninclude the requested connector and other resources necessary\nto drive the connected output in the lease.\n\nRequesting a connector that was created from a different lease device\nthan this lease request raises the wrong_device error. Requesting a\nconnector twice will raise the duplicate_connector error."RequestConnector"submit the lease request\n\nSubmits the lease request and creates a new wp_drm_lease_v1 object.\nAfter calling submit the compositor will immediately destroy this\nobject, issuing any more requests will cause a wl_display error.\nThe compositor doesn't make any guarantees about the events of the\nlease object, clients cannot expect an immediate response.\nNot requesting any connectors before submitting the lease request\nwill raise the empty_lease error.\n\nThis is a destructor, once sent this object cannot be used any longer.""DRM lease request\n\nA client that wishes to lease DRM resources will attach the list of\nconnectors advertised with wp_drm_lease_device_v1.connector that they\nwish to lease, then use wp_drm_lease_request_v1.submit to submit the\nrequest.\n\nThis interface has no events."request_connector"submit the lease request\n\nSubmits the lease request and creates a new wp_drm_lease_v1 object.\nAfter calling submit the compositor will immediately destroy this\nobject, issuing any more requests will cause a wl_display error.\nThe compositor doesn't make any guarantees about the events of the\nlease object, clients cannot expect an immediate response.\nNot requesting any connectors before submitting the lease request\nwill raise the empty_lease error."wp_drm_lease_v1WpDrmLeaseV1"a DRM lease\n\nA DRM lease object is used to transfer the DRM file descriptor to the\nclient and manage the lifetime of the lease.\n\nSome time after the wp_drm_lease_v1 object is created, the compositor\nwill reply with the lease request's result. If the lease request is\ngranted, the compositor will send a lease_fd event. If the lease request\nis denied, the compositor will send a finished event without a lease_fd\nevent."EVT_LEASE_FD_SINCEEVT_LEASE_FD_OPCODE"destroys the lease object\n\nThe client should send this to indicate that it no longer wishes to use\nthis lease. The compositor should use drmModeRevokeLease on the\nappropriate file descriptor, if necessary.\n\nUpon destruction, the compositor should advertise the connector for\nleasing again by sending the connector event through the\nwp_drm_lease_device_v1 interface.\n\nThis is a destructor, once sent this object cannot be used any longer.""shares the DRM file descriptor\n\nThis event returns a file descriptor suitable for use with DRM-related\nioctls. The client should use drmModeGetLease to enumerate the DRM\nobjects which have been leased to them. The compositor guarantees it\nwill not use the leased DRM objects itself until it sends the finished\nevent. If the compositor cannot or will not grant a lease for the\nrequested connectors, it will not send this event, instead sending the\nfinished event.\n\nThe compositor will send this event at most once during this objects\nlifetime.""leased DRM file descriptor"leased_fdLeaseFd"sent when the lease has been revoked\n\nThe compositor uses this event to either reject a lease request, or if\nit previously sent a lease_fd, to notify the client that the lease has\nbeen revoked. If the client requires a new lease, they should destroy\nthis object and submit a new lease request. The compositor will send\nno further events for this object after sending the finish event.\nCompositors should revoke the lease when any of the leased resources\nbecome unavailable, namely when a hot-unplug occurs or when the\ncompositor loses DRM master. Compositors may advertise the connector\nfor leasing again, if the resource is available, by sending the\nconnector event through the wp_drm_lease_device_v1 interface.""a DRM lease\n\nA DRM lease object is used to transfer the DRM file descriptor to the\nclient and manage the lifetime of the lease.\n\nSome time after the wp_drm_lease_v1 object is created, the compositor\nwill reply with the lease request's result. If the lease request is\ngranted, the compositor will send a lease_fd event. If the lease request\nis denied, the compositor will send a finished event without a lease_fd\nevent.\n\nSee also the [Event] enum for this interface.""destroys the lease object\n\nThe client should send this to indicate that it no longer wishes to use\nthis lease. The compositor should use drmModeRevokeLease on the\nappropriate file descriptor, if necessary.\n\nUpon destruction, the compositor should advertise the connector for\nleasing again by sending the connector event through the\nwp_drm_lease_device_v1 interface."//! This protocol is used by Wayland compositors which act as Direct//! Renderering Manager (DRM) masters to lease DRM resources to Wayland//! clients.//! The compositor will advertise one wp_drm_lease_device_v1 global for each//! DRM node. Some time after a client binds to the wp_drm_lease_device_v1//! global, the compositor will send a drm_fd event followed by zero, one or//! more connector events. After all currently available connectors have been//! sent, the compositor will send a wp_drm_lease_device_v1.done event.//! When the list of connectors available for lease changes the compositor//! will send wp_drm_lease_device_v1.connector events for added connectors and//! wp_drm_lease_connector_v1.withdrawn events for removed connectors,//! followed by a wp_drm_lease_device_v1.done event.//! The compositor will indicate when a device is gone by removing the global//! via a wl_registry.global_remove event. Upon receiving this event, the//! client should destroy any matching wp_drm_lease_device_v1 object.//! To destroy a wp_drm_lease_device_v1 object, the client must first issue//! a release request. Upon receiving this request, the compositor will//! immediately send a released event and destroy the object. The client must//! continue to process and discard drm_fd and connector events until it//! receives the released event. Upon receiving the released event, the//! client can safely cleanup any client-side resources.drm_leaseWP_TEARING_CONTROL_MANAGER_V1_INTERFACEwp_tearing_control_manager_v1_requests_get_tearing_control_typeswp_tearing_control_manager_v1_requestswp_tearing_control_manager_v1_interfaceWP_TEARING_CONTROL_V1_INTERFACEwp_tearing_control_v1_requestswp_tearing_control_v1_interface"protocol for tearing control\n\nFor some use cases like games or drawing tablets it can make sense to\nreduce latency by accepting tearing with the use of asynchronous page\nflips. This global is a factory interface, allowing clients to inform\nwhich type of presentation the content of their surfaces is suitable for.\n\nGraphics APIs like EGL or Vulkan, that manage the buffer queue and commits\nof a wl_surface themselves, are likely to be using this extension\ninternally. If a client is using such an API for a wl_surface, it should\nnot directly use this extension on that surface, to avoid raising a\ntearing_control_exists protocol error.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""the surface already has a tearing object associated"TearingControlExistsREQ_GET_TEARING_CONTROL_SINCEREQ_GET_TEARING_CONTROL_OPCODE"destroy tearing control factory object\n\nDestroy this tearing control factory object. Other objects, including\nwp_tearing_control_v1 objects created by this factory, are not affected\nby this request.\n\nThis is a destructor, once sent this object cannot be used any longer.""extend surface interface for tearing control\n\nInstantiate an interface extension for the given wl_surface to request\nasynchronous page flips for presentation.\n\nIf the given wl_surface already has a wp_tearing_control_v1 object\nassociated, the tearing_control_exists protocol error is raised."GetTearingControl"protocol for tearing control\n\nFor some use cases like games or drawing tablets it can make sense to\nreduce latency by accepting tearing with the use of asynchronous page\nflips. This global is a factory interface, allowing clients to inform\nwhich type of presentation the content of their surfaces is suitable for.\n\nGraphics APIs like EGL or Vulkan, that manage the buffer queue and commits\nof a wl_surface themselves, are likely to be using this extension\ninternally. If a client is using such an API for a wl_surface, it should\nnot directly use this extension on that surface, to avoid raising a\ntearing_control_exists protocol error.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpTearingControlManagerV1"destroy tearing control factory object\n\nDestroy this tearing control factory object. Other objects, including\nwp_tearing_control_v1 objects created by this factory, are not affected\nby this request."wp_tearing_control_v1WpTearingControlV1get_tearing_controlwp_tearing_control_manager_v1"per-surface tearing control interface\n\nAn additional interface to a wl_surface object, which allows the client\nto hint to the compositor if the content on the surface is suitable for\npresentation with tearing.\nThe default presentation hint is vsync. See presentation_hint for more\ndetails.\n\nIf the associated wl_surface is destroyed, this object becomes inert and\nshould be destroyed.""presentation hint values\n\nThis enum provides information for if submitted frames from the client\nmay be presented with tearing."PresentationHint"tearing-free presentation\n\nThe content of this surface is meant to be synchronized to the\nvertical blanking period. This should not result in visible tearing\nand may result in a delay before a surface commit is presented."Vsync"asynchronous presentation\n\nThe content of this surface is meant to be presented with minimal\nlatency and tearing is acceptable."REQ_SET_PRESENTATION_HINT_SINCEREQ_SET_PRESENTATION_HINT_OPCODE"set presentation hint\n\nSet the presentation hint for the associated wl_surface. This state is\ndouble-buffered, see wl_surface.commit.\n\nThe compositor is free to dynamically respect or ignore this hint based\non various conditions like hardware capabilities, surface state and\nuser preferences."SetPresentationHint"destroy tearing control object\n\nDestroy this surface tearing object and revert the presentation hint to\nvsync. The change will be applied on the next wl_surface.commit.\n\nThis is a destructor, once sent this object cannot be used any longer.""per-surface tearing control interface\n\nAn additional interface to a wl_surface object, which allows the client\nto hint to the compositor if the content on the surface is suitable for\npresentation with tearing.\nThe default presentation hint is vsync. See presentation_hint for more\ndetails.\n\nIf the associated wl_surface is destroyed, this object becomes inert and\nshould be destroyed.\n\nThis interface has no events."set_presentation_hint"destroy tearing control object\n\nDestroy this surface tearing object and revert the presentation hint to\nvsync. The change will be applied on the next wl_surface.commit."//! This protocol provides a way for clients to indicate whether//! or not their content is suitable for this kind of presentation.//! For some use cases like games or drawing tablets it can make sense to reduce//! latency by accepting tearing with the use of asynchronous page flips.tearing_controlWP_FRACTIONAL_SCALE_MANAGER_V1_INTERFACEwp_fractional_scale_manager_v1_requests_get_fractional_scale_typeswp_fractional_scale_manager_v1_requestswp_fractional_scale_manager_v1_interfaceWP_FRACTIONAL_SCALE_V1_INTERFACEwp_fractional_scale_v1_requestswp_fractional_scale_v1_eventswp_fractional_scale_v1_interface"fractional surface scale information\n\nA global interface for requesting surfaces to use fractional scales.""the surface already has a fractional_scale object associated"FractionalScaleExistsREQ_GET_FRACTIONAL_SCALE_SINCEREQ_GET_FRACTIONAL_SCALE_OPCODE"unbind the fractional surface scale interface\n\nInforms the server that the client will not be using this protocol\nobject anymore. This does not affect any other objects,\nwp_fractional_scale_v1 objects included.\n\nThis is a destructor, once sent this object cannot be used any longer.""extend surface interface for scale information\n\nCreate an add-on object for the the wl_surface to let the compositor\nrequest fractional scales. If the given wl_surface already has a\nwp_fractional_scale_v1 object associated, the fractional_scale_exists\nprotocol error is raised."GetFractionalScale"fractional surface scale information\n\nA global interface for requesting surfaces to use fractional scales.\n\nThis interface has no events."WpFractionalScaleManagerV1"unbind the fractional surface scale interface\n\nInforms the server that the client will not be using this protocol\nobject anymore. This does not affect any other objects,\nwp_fractional_scale_v1 objects included."wp_fractional_scale_v1WpFractionalScaleV1get_fractional_scalewp_fractional_scale_manager_v1"fractional scale interface to a wl_surface\n\nAn additional interface to a wl_surface object which allows the compositor\nto inform the client of the preferred scale."EVT_PREFERRED_SCALE_SINCEEVT_PREFERRED_SCALE_OPCODE"remove surface scale information for surface\n\nDestroy the fractional scale object. When this object is destroyed,\npreferred_scale events will no longer be sent.\n\nThis is a destructor, once sent this object cannot be used any longer.""notify of new preferred scale\n\nNotification of a new preferred scale for this surface that the\ncompositor suggests that the client should use.\n\nThe sent scale is the numerator of a fraction with a denominator of 120.""the new preferred scale"PreferredScale"fractional scale interface to a wl_surface\n\nAn additional interface to a wl_surface object which allows the compositor\nto inform the client of the preferred scale.\n\nSee also the [Event] enum for this interface.""remove surface scale information for surface\n\nDestroy the fractional scale object. When this object is destroyed,\npreferred_scale events will no longer be sent."//! This protocol allows a compositor to suggest for surfaces to render at//! fractional scales.//! A client can submit scaled content by utilizing wp_viewport. This is done by//! creating a wp_viewport object for the surface and setting the destination//! rectangle to the surface size before the scale factor is applied.//! The buffer size is calculated by multiplying the surface size by the//! intended scale.//! The wl_surface buffer scale should remain set to 1.//! If a surface has a surface-local size of 100 px by 50 px and wishes to//! submit buffers with a scale of 1.5, then a buffer of 150px by 75 px should//! be used and the wp_viewport destination rectangle should be 100 px by 50 px.//! For toplevel surfaces, the size is rounded halfway away from zero. The//! rounding algorithm for subsurface position and size is not defined.fractional_scaleZWP_FULLSCREEN_SHELL_V1_INTERFACEzwp_fullscreen_shell_v1_requests_present_surface_typeszwp_fullscreen_shell_v1_requests_present_surface_for_mode_typeszwp_fullscreen_shell_v1_requestszwp_fullscreen_shell_v1_eventszwp_fullscreen_shell_v1_interfaceZWP_FULLSCREEN_SHELL_MODE_FEEDBACK_V1_INTERFACEzwp_fullscreen_shell_mode_feedback_v1_eventszwp_fullscreen_shell_mode_feedback_v1_interface"displays a single surface per output\n\nDisplays a single surface per output.\n\nThis interface provides a mechanism for a single client to display\nsimple full-screen surfaces.  While there technically may be multiple\nclients bound to this interface, only one of those clients should be\nshown at a time.\n\nTo present a surface, the client uses either the present_surface or\npresent_surface_for_mode requests.  Presenting a surface takes effect\non the next wl_surface.commit.  See the individual requests for\ndetails about scaling and mode switches.\n\nThe client can have at most one surface per output at any time.\nRequesting a surface to be presented on an output that already has a\nsurface replaces the previously presented surface.  Presenting a null\nsurface removes its content and effectively disables the output.\nExactly what happens when an output is \"disabled\" is\ncompositor-specific.  The same surface may be presented on multiple\noutputs simultaneously.\n\nOnce a surface is presented on an output, it stays on that output\nuntil either the client removes it or the compositor destroys the\noutput.  This way, the client can update the output's contents by\nsimply attaching a new buffer.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.""capabilities advertised by the compositor\n\nVarious capabilities that can be advertised by the compositor.  They\nare advertised one-at-a-time when the wl_fullscreen_shell interface is\nbound.  See the wl_fullscreen_shell.capability event for more details.\n\nARBITRARY_MODES:\nThis is a hint to the client that indicates that the compositor is\ncapable of setting practically any mode on its outputs.  If this\ncapability is provided, wl_fullscreen_shell.present_surface_for_mode\nwill almost never fail and clients should feel free to set whatever\nmode they like.  If the compositor does not advertise this, it may\nstill support some modes that are not advertised through wl_global.mode\nbut it is less likely.\n\nCURSOR_PLANE:\nThis is a hint to the client that indicates that the compositor can\nhandle a cursor surface from the client without actually compositing.\nThis may be because of a hardware cursor plane or some other mechanism.\nIf the compositor does not advertise this capability then setting\nwl_pointer.cursor may degrade performance or be ignored entirely.  If\nCURSOR_PLANE is not advertised, it is recommended that the client draw\nits own cursor and set wl_pointer.cursor(NULL).""compositor is capable of almost any output mode"ArbitraryModes"compositor has a separate cursor plane"CursorPlanePresentMethod"center the surface on the output""scale the surface, preserving aspect ratio, to the largest size that will fit on the output""scale the surface, preserving aspect ratio, to fully fill the output cropping if needed"ZoomCrop"scale the surface to the size of the output ignoring aspect ratio""wl_fullscreen_shell error values\n\nThese errors can be emitted in response to wl_fullscreen_shell requests.""present_method is not known"REQ_PRESENT_SURFACE_SINCEREQ_PRESENT_SURFACE_OPCODEREQ_PRESENT_SURFACE_FOR_MODE_SINCEREQ_PRESENT_SURFACE_FOR_MODE_OPCODEEVT_CAPABILITY_SINCEEVT_CAPABILITY_OPCODE"release the wl_fullscreen_shell interface\n\nRelease the binding from the wl_fullscreen_shell interface.\n\nThis destroys the server-side object and frees this binding.  If\nthe client binds to wl_fullscreen_shell multiple times, it may wish\nto free some of those bindings.\n\nThis is a destructor, once sent this object cannot be used any longer.""present surface for display\n\nPresent a surface on the given output.\n\nIf the output is null, the compositor will present the surface on\nwhatever display (or displays) it thinks best.  In particular, this\nmay replace any or all surfaces currently presented so it should\nnot be used in combination with placing surfaces on specific\noutputs.\n\nThe method parameter is a hint to the compositor for how the surface\nis to be presented.  In particular, it tells the compositor how to\nhandle a size mismatch between the presented surface and the\noutput.  The compositor is free to ignore this parameter.\n\nThe \"zoom\", \"zoom_crop\", and \"stretch\" methods imply a scaling\noperation on the surface.  This will override any kind of output\nscaling, so the buffer_scale property of the surface is effectively\nignored.\n\nThis request gives the surface the role of a fullscreen shell surface.\nIf the surface already has another role, it raises a role protocol\nerror."PresentSurface"present surface for display at a particular mode\n\nPresents a surface on the given output for a particular mode.\n\nIf the current size of the output differs from that of the surface,\nthe compositor will attempt to change the size of the output to\nmatch the surface.  The result of the mode-switch operation will be\nreturned via the provided wl_fullscreen_shell_mode_feedback object.\n\nIf the current output mode matches the one requested or if the\ncompositor successfully switches the mode to match the surface,\nthen the mode_successful event will be sent and the output will\ncontain the contents of the given surface.  If the compositor\ncannot match the output size to the surface size, the mode_failed\nwill be sent and the output will contain the contents of the\npreviously presented surface (if any).  If another surface is\npresented on the given output before either of these has a chance\nto happen, the present_cancelled event will be sent.\n\nDue to race conditions and other issues unknown to the client, no\nmode-switch operation is guaranteed to succeed.  However, if the\nmode is one advertised by wl_output.mode or if the compositor\nadvertises the ARBITRARY_MODES capability, then the client should\nexpect that the mode-switch operation will usually succeed.\n\nIf the size of the presented surface changes, the resulting output\nis undefined.  The compositor may attempt to change the output mode\nto compensate.  However, there is no guarantee that a suitable mode\nwill be found and the client has no way to be notified of success\nor failure.\n\nThe framerate parameter specifies the desired framerate for the\noutput in mHz.  The compositor is free to ignore this parameter.  A\nvalue of 0 indicates that the client has no preference.\n\nIf the value of wl_output.scale differs from wl_surface.buffer_scale,\nthen the compositor may choose a mode that matches either the buffer\nsize or the surface size.  In either case, the surface will fill the\noutput.\n\nThis request gives the surface the role of a fullscreen shell surface.\nIf the surface already has another role, it raises a role protocol\nerror."PresentSurfaceForMode"advertises a capability of the compositor\n\nAdvertises a single capability of the compositor.\n\nWhen the wl_fullscreen_shell interface is bound, this event is emitted\nonce for each capability advertised.  Valid capabilities are given by\nthe wl_fullscreen_shell.capability enum.  If clients want to take\nadvantage of any of these capabilities, they should use a\nwl_display.sync request immediately after binding to ensure that they\nreceive all the capability events.""displays a single surface per output\n\nDisplays a single surface per output.\n\nThis interface provides a mechanism for a single client to display\nsimple full-screen surfaces.  While there technically may be multiple\nclients bound to this interface, only one of those clients should be\nshown at a time.\n\nTo present a surface, the client uses either the present_surface or\npresent_surface_for_mode requests.  Presenting a surface takes effect\non the next wl_surface.commit.  See the individual requests for\ndetails about scaling and mode switches.\n\nThe client can have at most one surface per output at any time.\nRequesting a surface to be presented on an output that already has a\nsurface replaces the previously presented surface.  Presenting a null\nsurface removes its content and effectively disables the output.\nExactly what happens when an output is \"disabled\" is\ncompositor-specific.  The same surface may be presented on multiple\noutputs simultaneously.\n\nOnce a surface is presented on an output, it stays on that output\nuntil either the client removes it or the compositor destroys the\noutput.  This way, the client can update the output's contents by\nsimply attaching a new buffer.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nSee also the [Event] enum for this interface."ZwpFullscreenShellV1"release the wl_fullscreen_shell interface\n\nRelease the binding from the wl_fullscreen_shell interface.\n\nThis destroys the server-side object and frees this binding.  If\nthe client binds to wl_fullscreen_shell multiple times, it may wish\nto free some of those bindings."present_surfacezwp_fullscreen_shell_mode_feedback_v1ZwpFullscreenShellModeFeedbackV1present_surface_for_modezwp_fullscreen_shell_v1EVT_MODE_SUCCESSFUL_SINCEEVT_MODE_SUCCESSFUL_OPCODEEVT_MODE_FAILED_SINCEEVT_MODE_FAILED_OPCODEEVT_PRESENT_CANCELLED_SINCEEVT_PRESENT_CANCELLED_OPCODE"mode switch succeeded\n\nThis event indicates that the attempted mode switch operation was\nsuccessful.  A surface of the size requested in the mode switch\nwill fill the output without scaling.\n\nUpon receiving this event, the client should destroy the\nwl_fullscreen_shell_mode_feedback object.\n\nThis is a destructor, once received this object cannot be used any longer."ModeSuccessful"mode switch failed\n\nThis event indicates that the attempted mode switch operation\nfailed.  This may be because the requested output mode is not\npossible or it may mean that the compositor does not want to allow it.\n\nUpon receiving this event, the client should destroy the\nwl_fullscreen_shell_mode_feedback object.\n\nThis is a destructor, once received this object cannot be used any longer."ModeFailed"mode switch cancelled\n\nThis event indicates that the attempted mode switch operation was\ncancelled.  Most likely this is because the client requested a\nsecond mode switch before the first one completed.\n\nUpon receiving this event, the client should destroy the\nwl_fullscreen_shell_mode_feedback object.\n\nThis is a destructor, once received this object cannot be used any longer."PresentCancelled"zwp_fullscreen_shell_mode_feedback_v1\n\nSee also the [Event] enum for this interface."/// Unstable version 1//! Fullscreen shell protocolfullscreen_shellZWP_IDLE_INHIBIT_MANAGER_V1_INTERFACEzwp_idle_inhibit_manager_v1_requests_create_inhibitor_typeszwp_idle_inhibit_manager_v1_requestszwp_idle_inhibit_manager_v1_interfaceZWP_IDLE_INHIBITOR_V1_INTERFACEzwp_idle_inhibitor_v1_requestszwp_idle_inhibitor_v1_interface"control behavior when display idles\n\nThis interface permits inhibiting the idle behavior such as screen\nblanking, locking, and screensaving.  The client binds the idle manager\nglobally, then creates idle-inhibitor objects for each surface.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset."REQ_CREATE_INHIBITOR_SINCEREQ_CREATE_INHIBITOR_OPCODE"destroy the idle inhibitor object\n\nDestroy the inhibit manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new inhibitor object\n\nCreate a new inhibitor object associated with the given surface.""the surface that inhibits the idle behavior"CreateInhibitor"control behavior when display idles\n\nThis interface permits inhibiting the idle behavior such as screen\nblanking, locking, and screensaving.  The client binds the idle manager\nglobally, then creates idle-inhibitor objects for each surface.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nThis interface has no events."ZwpIdleInhibitManagerV1"destroy the idle inhibitor object\n\nDestroy the inhibit manager."zwp_idle_inhibitor_v1ZwpIdleInhibitorV1create_inhibitorzwp_idle_inhibit_manager_v1"context object for inhibiting idle behavior\n\nAn idle inhibitor prevents the output that the associated surface is\nvisible on from being set to a state where it is not visually usable due\nto lack of user interaction (e.g. blanked, dimmed, locked, set to power\nsave, etc.)  Any screensaver processes are also blocked from displaying.\n\nIf the surface is destroyed, unmapped, becomes occluded, loses\nvisibility, or otherwise becomes not visually relevant for the user, the\nidle inhibitor will not be honored by the compositor; if the surface\nsubsequently regains visibility the inhibitor takes effect once again.\nLikewise, the inhibitor isn't honored if the system was already idled at\nthe time the inhibitor was established, although if the system later\nde-idles and re-idles the inhibitor will take effect.""destroy the idle inhibitor object\n\nRemove the inhibitor effect from the associated wl_surface.\n\nThis is a destructor, once sent this object cannot be used any longer.""context object for inhibiting idle behavior\n\nAn idle inhibitor prevents the output that the associated surface is\nvisible on from being set to a state where it is not visually usable due\nto lack of user interaction (e.g. blanked, dimmed, locked, set to power\nsave, etc.)  Any screensaver processes are also blocked from displaying.\n\nIf the surface is destroyed, unmapped, becomes occluded, loses\nvisibility, or otherwise becomes not visually relevant for the user, the\nidle inhibitor will not be honored by the compositor; if the surface\nsubsequently regains visibility the inhibitor takes effect once again.\nLikewise, the inhibitor isn't honored if the system was already idled at\nthe time the inhibitor was established, although if the system later\nde-idles and re-idles the inhibitor will take effect.\n\nThis interface has no events.""destroy the idle inhibitor object\n\nRemove the inhibitor effect from the associated wl_surface."//! Screensaver inhibition protocolidle_inhibitZWP_INPUT_METHOD_CONTEXT_V1_INTERFACEzwp_input_method_context_v1_requests_grab_keyboard_typeszwp_input_method_context_v1_requestszwp_input_method_context_v1_eventszwp_input_method_context_v1_interfaceZWP_INPUT_METHOD_V1_INTERFACEzwp_input_method_v1_events_activate_typeszwp_input_method_v1_events_deactivate_typeszwp_input_method_v1_eventszwp_input_method_v1_interfaceZWP_INPUT_PANEL_V1_INTERFACEzwp_input_panel_v1_requests_get_input_panel_surface_typeszwp_input_panel_v1_requestszwp_input_panel_v1_interfaceZWP_INPUT_PANEL_SURFACE_V1_INTERFACEzwp_input_panel_surface_v1_requests_set_toplevel_typeszwp_input_panel_surface_v1_requestszwp_input_panel_surface_v1_interface"input method context\n\nCorresponds to a text input on the input method side. An input method context\nis created on text input activation on the input method side. It allows\nreceiving information about the text input from the application via events.\nInput method contexts do not keep state after deactivation and should be\ndestroyed after deactivation is handled.\n\nText is generally UTF-8 encoded, indices and lengths are in bytes.\n\nSerials are used to synchronize the state between the text input and\nan input method. New serials are sent by the text input in the\ncommit_state request and are used by the input method to indicate\nthe known text input state in events like preedit_string, commit_string,\nand keysym. The text input can then ignore events from the input method\nwhich are based on an outdated state (for example after a reset).\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset."REQ_COMMIT_STRING_SINCEREQ_COMMIT_STRING_OPCODEREQ_PREEDIT_STRING_SINCEREQ_PREEDIT_STRING_OPCODEREQ_PREEDIT_STYLING_SINCEREQ_PREEDIT_STYLING_OPCODEREQ_PREEDIT_CURSOR_SINCEREQ_PREEDIT_CURSOR_OPCODEREQ_DELETE_SURROUNDING_TEXT_SINCEREQ_DELETE_SURROUNDING_TEXT_OPCODEREQ_CURSOR_POSITION_SINCEREQ_CURSOR_POSITION_OPCODEREQ_MODIFIERS_MAP_SINCEREQ_MODIFIERS_MAP_OPCODEREQ_KEYSYM_SINCEREQ_KEYSYM_OPCODEREQ_GRAB_KEYBOARD_SINCEREQ_GRAB_KEYBOARD_OPCODEREQ_KEY_SINCEREQ_KEY_OPCODEREQ_MODIFIERS_SINCEREQ_MODIFIERS_OPCODEREQ_LANGUAGE_SINCEREQ_LANGUAGE_OPCODEREQ_TEXT_DIRECTION_SINCEREQ_TEXT_DIRECTION_OPCODEEVT_SURROUNDING_TEXT_SINCEEVT_SURROUNDING_TEXT_OPCODEEVT_RESET_SINCEEVT_RESET_OPCODEEVT_CONTENT_TYPE_SINCEEVT_CONTENT_TYPE_OPCODEEVT_INVOKE_ACTION_SINCEEVT_INVOKE_ACTION_OPCODEEVT_COMMIT_STATE_SINCEEVT_COMMIT_STATE_OPCODEEVT_PREFERRED_LANGUAGE_SINCEEVT_PREFERRED_LANGUAGE_OPCODE"This is a destructor, once sent this object cannot be used any longer.""commit string\n\nSend the commit string text for insertion to the application.\n\nThe text to commit could be either just a single character after a key\npress or the result of some composing (pre-edit). It could be also an\nempty text when some text should be removed (see\ndelete_surrounding_text) or when the input cursor should be moved (see\ncursor_position).\n\nAny previously set composing text will be removed.""serial of the latest known text input state"CommitString"pre-edit string\n\nSend the pre-edit string text to the application text input.\n\nThe commit text can be used to replace the pre-edit text on reset (for\nexample on unfocus).\n\nPreviously sent preedit_style and preedit_cursor requests are also\nprocessed by the text_input."PreeditString"pre-edit styling\n\nSet the styling information on composing text. The style is applied for\nlength in bytes from index relative to the beginning of\nthe composing text (as byte offset). Multiple styles can\nbe applied to a composing text.\n\nThis request should be sent before sending a preedit_string request."PreeditStyling"pre-edit cursor\n\nSet the cursor position inside the composing text (as byte offset)\nrelative to the start of the composing text.\n\nWhen index is negative no cursor should be displayed.\n\nThis request should be sent before sending a preedit_string request."PreeditCursor"delete text\n\nRemove the surrounding text.\n\nThis request will be handled on the text_input side directly following\na commit_string request."DeleteSurroundingText"set cursor to a new position\n\nSet the cursor and anchor to a new position. Index is the new cursor\nposition in bytes (when >= 0 this is relative to the end of the inserted text,\notherwise it is relative to the beginning of the inserted text). Anchor is\nthe new anchor position in bytes (when >= 0 this is relative to the end of the\ninserted text, otherwise it is relative to the beginning of the inserted\ntext). When there should be no selected text, anchor should be the same\nas index.\n\nThis request will be handled on the text_input side directly following\na commit_string request."ModifiersMap"keysym\n\nNotify when a key event was sent. Key events should not be used for\nnormal text input operations, which should be done with commit_string,\ndelete_surrounding_text, etc. The key event follows the wl_keyboard key\nevent convention. Sym is an XKB keysym, state is a wl_keyboard key_state.""grab hardware keyboard\n\nAllow an input method to receive hardware keyboard input and process\nkey events to generate text events (with pre-edit) over the wire. This\nallows input methods which compose multiple key events for inputting\ntext like it is done for CJK languages."GrabKeyboard"forward key event\n\nForward a wl_keyboard::key event to the client that was not processed\nby the input method itself. Should be used when filtering key events\nwith grab_keyboard.  The arguments should be the ones from the\nwl_keyboard::key event.\n\nFor generating custom key events use the keysym request instead.""serial from wl_keyboard::key""time from wl_keyboard::key""key from wl_keyboard::key""state from wl_keyboard::key""forward modifiers event\n\nForward a wl_keyboard::modifiers event to the client that was not\nprocessed by the input method itself.  Should be used when filtering\nkey events with grab_keyboard. The arguments should be the ones\nfrom the wl_keyboard::modifiers event.""serial from wl_keyboard::modifiers""mods_depressed from wl_keyboard::modifiers""mods_latched from wl_keyboard::modifiers""mods_locked from wl_keyboard::modifiers""group from wl_keyboard::modifiers""surrounding text event\n\nThe plain surrounding text around the input position. Cursor is the\nposition in bytes within the surrounding text relative to the beginning\nof the text. Anchor is the position in bytes of the selection anchor\nwithin the surrounding text relative to the beginning of the text. If\nthere is no selected text then anchor is the same as cursor."InvokeAction"serial of text input state"CommitStatePreferredLanguage"input method context\n\nCorresponds to a text input on the input method side. An input method context\nis created on text input activation on the input method side. It allows\nreceiving information about the text input from the application via events.\nInput method contexts do not keep state after deactivation and should be\ndestroyed after deactivation is handled.\n\nText is generally UTF-8 encoded, indices and lengths are in bytes.\n\nSerials are used to synchronize the state between the text input and\nan input method. New serials are sent by the text input in the\ncommit_state request and are used by the input method to indicate\nthe known text input state in events like preedit_string, commit_string,\nand keysym. The text input can then ignore events from the input method\nwhich are based on an outdated state (for example after a reset).\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nSee also the [Event] enum for this interface."ZwpInputMethodContextV1preedit_stylingpreedit_cursormodifiers_mapgrab_keyboardtext_directionzwp_input_method_context_v1"input method\n\nAn input method object is responsible for composing text in response to\ninput from hardware or virtual keyboards. There is one input method\nobject per seat. On activate there is a new input method context object\ncreated which allows the input method to communicate with the text input."EVT_ACTIVATE_SINCEEVT_ACTIVATE_OPCODEEVT_DEACTIVATE_SINCEEVT_DEACTIVATE_OPCODE"activate event\n\nA text input was activated. Creates an input method context object\nwhich allows communication with the text input.""deactivate event\n\nThe text input corresponding to the context argument was deactivated.\nThe input method context should be destroyed after deactivation is\nhandled.""input method\n\nAn input method object is responsible for composing text in response to\ninput from hardware or virtual keyboards. There is one input method\nobject per seat. On activate there is a new input method context object\ncreated which allows the input method to communicate with the text input.\n\nSee also the [Event] enum for this interface."ZwpInputMethodV1zwp_input_method_v1"interface for implementing keyboards\n\nOnly one client can bind this interface at a time."REQ_GET_INPUT_PANEL_SURFACE_SINCEREQ_GET_INPUT_PANEL_SURFACE_OPCODEGetInputPanelSurface"interface for implementing keyboards\n\nOnly one client can bind this interface at a time.\n\nThis interface has no events."ZwpInputPanelV1zwp_input_panel_surface_v1ZwpInputPanelSurfaceV1get_input_panel_surfacezwp_input_panel_v1CenterBottomREQ_SET_OVERLAY_PANEL_SINCEREQ_SET_OVERLAY_PANEL_OPCODE"set the surface type as a keyboard\n\nSet the input_panel_surface type to keyboard.\n\nA keyboard surface is only shown when a text input is active.""set the surface type as an overlay panel\n\nSet the input_panel_surface to be an overlay panel.\n\nThis is shown near the input cursor above the application window when\na text input is active."SetOverlayPanel"zwp_input_panel_surface_v1\n\nThis interface has no events."set_overlay_panel//! Input method protocolZWP_INPUT_TIMESTAMPS_MANAGER_V1_INTERFACEzwp_input_timestamps_manager_v1_requests_get_keyboard_timestamps_typeszwp_input_timestamps_manager_v1_requests_get_pointer_timestamps_typeszwp_input_timestamps_manager_v1_requests_get_touch_timestamps_typeszwp_input_timestamps_manager_v1_requestszwp_input_timestamps_manager_v1_interfaceZWP_INPUT_TIMESTAMPS_V1_INTERFACEzwp_input_timestamps_v1_requestszwp_input_timestamps_v1_eventszwp_input_timestamps_v1_interface"context object for high-resolution input timestamps\n\nA global interface used for requesting high-resolution timestamps\nfor input events."REQ_GET_KEYBOARD_TIMESTAMPS_SINCEREQ_GET_KEYBOARD_TIMESTAMPS_OPCODEREQ_GET_POINTER_TIMESTAMPS_SINCEREQ_GET_POINTER_TIMESTAMPS_OPCODEREQ_GET_TOUCH_TIMESTAMPS_SINCEREQ_GET_TOUCH_TIMESTAMPS_OPCODE"destroy the input timestamps manager object\n\nInforms the server that the client will no longer be using this\nprotocol object. Existing objects created by this object are not\naffected.\n\nThis is a destructor, once sent this object cannot be used any longer.""subscribe to high-resolution keyboard timestamp events\n\nCreates a new input timestamps object that represents a subscription\nto high-resolution timestamp events for all wl_keyboard events that\ncarry a timestamp.\n\nIf the associated wl_keyboard object is invalidated, either through\nclient action (e.g. release) or server-side changes, the input\ntimestamps object becomes inert and the client should destroy it\nby calling zwp_input_timestamps_v1.destroy.""the wl_keyboard object for which to get timestamp events"GetKeyboardTimestamps"subscribe to high-resolution pointer timestamp events\n\nCreates a new input timestamps object that represents a subscription\nto high-resolution timestamp events for all wl_pointer events that\ncarry a timestamp.\n\nIf the associated wl_pointer object is invalidated, either through\nclient action (e.g. release) or server-side changes, the input\ntimestamps object becomes inert and the client should destroy it\nby calling zwp_input_timestamps_v1.destroy.""the wl_pointer object for which to get timestamp events"GetPointerTimestamps"subscribe to high-resolution touch timestamp events\n\nCreates a new input timestamps object that represents a subscription\nto high-resolution timestamp events for all wl_touch events that\ncarry a timestamp.\n\nIf the associated wl_touch object becomes invalid, either through\nclient action (e.g. release) or server-side changes, the input\ntimestamps object becomes inert and the client should destroy it\nby calling zwp_input_timestamps_v1.destroy.""the wl_touch object for which to get timestamp events"GetTouchTimestamps"context object for high-resolution input timestamps\n\nA global interface used for requesting high-resolution timestamps\nfor input events.\n\nThis interface has no events."ZwpInputTimestampsManagerV1"destroy the input timestamps manager object\n\nInforms the server that the client will no longer be using this\nprotocol object. Existing objects created by this object are not\naffected."zwp_input_timestamps_v1ZwpInputTimestampsV1get_keyboard_timestampsget_pointer_timestampsget_touch_timestampszwp_input_timestamps_manager_v1"context object for input timestamps\n\nProvides high-resolution timestamp events for a set of subscribed input\nevents. The set of subscribed input events is determined by the\nzwp_input_timestamps_manager_v1 request used to create this object."EVT_TIMESTAMP_SINCEEVT_TIMESTAMP_OPCODE"destroy the input timestamps object\n\nInforms the server that the client will no longer be using this\nprotocol object. After the server processes the request, no more\ntimestamp events will be emitted.\n\nThis is a destructor, once sent this object cannot be used any longer.""high-resolution timestamp event\n\nThe timestamp event is associated with the first subsequent input event\ncarrying a timestamp which belongs to the set of input events this\nobject is subscribed to.\n\nThe timestamp provided by this event is a high-resolution version of\nthe timestamp argument of the associated input event. The provided\ntimestamp is in the same clock domain and is at least as accurate as\nthe associated input event timestamp.\n\nThe timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,\neach component being an unsigned 32-bit value. Whole seconds are in\ntv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,\nand the additional fractional part in tv_nsec as nanoseconds. Hence,\nfor valid timestamps tv_nsec must be in [0, 999999999].""context object for input timestamps\n\nProvides high-resolution timestamp events for a set of subscribed input\nevents. The set of subscribed input events is determined by the\nzwp_input_timestamps_manager_v1 request used to create this object.\n\nSee also the [Event] enum for this interface.""destroy the input timestamps object\n\nInforms the server that the client will no longer be using this\nprotocol object. After the server processes the request, no more\ntimestamp events will be emitted."//! Input timestamps protocolinput_timestampsZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INTERFACEzwp_keyboard_shortcuts_inhibit_manager_v1_requests_inhibit_shortcuts_typeszwp_keyboard_shortcuts_inhibit_manager_v1_requestszwp_keyboard_shortcuts_inhibit_manager_v1_interfaceZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_INTERFACEzwp_keyboard_shortcuts_inhibitor_v1_requestszwp_keyboard_shortcuts_inhibitor_v1_eventszwp_keyboard_shortcuts_inhibitor_v1_interface"context object for keyboard grab_manager\n\nA global interface used for inhibiting the compositor keyboard shortcuts.""the shortcuts are already inhibited for this surface"AlreadyInhibitedREQ_INHIBIT_SHORTCUTS_SINCEREQ_INHIBIT_SHORTCUTS_OPCODE"destroy the keyboard shortcuts inhibitor object\n\nDestroy the keyboard shortcuts inhibitor manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new keyboard shortcuts inhibitor object\n\nCreate a new keyboard shortcuts inhibitor object associated with\nthe given surface for the given seat.\n\nIf shortcuts are already inhibited for the specified seat and surface,\na protocol error \"already_inhibited\" is raised by the compositor.""the surface that inhibits the keyboard shortcuts behavior""the wl_seat for which keyboard shortcuts should be disabled"InhibitShortcuts"context object for keyboard grab_manager\n\nA global interface used for inhibiting the compositor keyboard shortcuts.\n\nThis interface has no events."ZwpKeyboardShortcutsInhibitManagerV1"destroy the keyboard shortcuts inhibitor object\n\nDestroy the keyboard shortcuts inhibitor manager."zwp_keyboard_shortcuts_inhibitor_v1ZwpKeyboardShortcutsInhibitorV1inhibit_shortcutszwp_keyboard_shortcuts_inhibit_manager_v1"context object for keyboard shortcuts inhibitor\n\nA keyboard shortcuts inhibitor instructs the compositor to ignore\nits own keyboard shortcuts when the associated surface has keyboard\nfocus. As a result, when the surface has keyboard focus on the given\nseat, it will receive all key events originating from the specified\nseat, even those which would normally be caught by the compositor for\nits own shortcuts.\n\nThe Wayland compositor is however under no obligation to disable\nall of its shortcuts, and may keep some special key combo for its own\nuse, including but not limited to one allowing the user to forcibly\nrestore normal keyboard events routing in the case of an unwilling\nclient. The compositor may also use the same key combo to reactivate\nan existing shortcut inhibitor that was previously deactivated on\nuser request.\n\nWhen the compositor restores its own keyboard shortcuts, an\n\"inactive\" event is emitted to notify the client that the keyboard\nshortcuts inhibitor is not effectively active for the surface and\nseat any more, and the client should not expect to receive all\nkeyboard events.\n\nWhen the keyboard shortcuts inhibitor is inactive, the client has\nno way to forcibly reactivate the keyboard shortcuts inhibitor.\n\nThe user can chose to re-enable a previously deactivated keyboard\nshortcuts inhibitor using any mechanism the compositor may offer,\nin which case the compositor will send an \"active\" event to notify\nthe client.\n\nIf the surface is destroyed, unmapped, or loses the seat's keyboard\nfocus, the keyboard shortcuts inhibitor becomes irrelevant and the\ncompositor will restore its own keyboard shortcuts but no \"inactive\"\nevent is emitted in this case."EVT_ACTIVE_SINCEEVT_ACTIVE_OPCODEEVT_INACTIVE_SINCEEVT_INACTIVE_OPCODE"destroy the keyboard shortcuts inhibitor object\n\nRemove the keyboard shortcuts inhibitor from the associated wl_surface.\n\nThis is a destructor, once sent this object cannot be used any longer.""shortcuts are inhibited\n\nThis event indicates that the shortcut inhibitor is active.\n\nThe compositor sends this event every time compositor shortcuts\nare inhibited on behalf of the surface. When active, the client\nmay receive input events normally reserved by the compositor\n(see zwp_keyboard_shortcuts_inhibitor_v1).\n\nThis occurs typically when the initial request \"inhibit_shortcuts\"\nfirst becomes active or when the user instructs the compositor to\nre-enable and existing shortcuts inhibitor using any mechanism\noffered by the compositor.""shortcuts are restored\n\nThis event indicates that the shortcuts inhibitor is inactive,\nnormal shortcuts processing is restored by the compositor.""context object for keyboard shortcuts inhibitor\n\nA keyboard shortcuts inhibitor instructs the compositor to ignore\nits own keyboard shortcuts when the associated surface has keyboard\nfocus. As a result, when the surface has keyboard focus on the given\nseat, it will receive all key events originating from the specified\nseat, even those which would normally be caught by the compositor for\nits own shortcuts.\n\nThe Wayland compositor is however under no obligation to disable\nall of its shortcuts, and may keep some special key combo for its own\nuse, including but not limited to one allowing the user to forcibly\nrestore normal keyboard events routing in the case of an unwilling\nclient. The compositor may also use the same key combo to reactivate\nan existing shortcut inhibitor that was previously deactivated on\nuser request.\n\nWhen the compositor restores its own keyboard shortcuts, an\n\"inactive\" event is emitted to notify the client that the keyboard\nshortcuts inhibitor is not effectively active for the surface and\nseat any more, and the client should not expect to receive all\nkeyboard events.\n\nWhen the keyboard shortcuts inhibitor is inactive, the client has\nno way to forcibly reactivate the keyboard shortcuts inhibitor.\n\nThe user can chose to re-enable a previously deactivated keyboard\nshortcuts inhibitor using any mechanism the compositor may offer,\nin which case the compositor will send an \"active\" event to notify\nthe client.\n\nIf the surface is destroyed, unmapped, or loses the seat's keyboard\nfocus, the keyboard shortcuts inhibitor becomes irrelevant and the\ncompositor will restore its own keyboard shortcuts but no \"inactive\"\nevent is emitted in this case.\n\nSee also the [Event] enum for this interface.""destroy the keyboard shortcuts inhibitor object\n\nRemove the keyboard shortcuts inhibitor from the associated wl_surface."//! Protocol for inhibiting the compositor keyboard shortcuts//! This protocol specifies a way for a client to request the compositor//! to ignore its own keyboard shortcuts for a given seat, so that all//! key events from that seat get forwarded to a surface.keyboard_shortcuts_inhibitZWP_LINUX_DMABUF_V1_INTERFACEzwp_linux_dmabuf_v1_requests_create_params_typeszwp_linux_dmabuf_v1_requests_get_default_feedback_typeszwp_linux_dmabuf_v1_requests_get_surface_feedback_typeszwp_linux_dmabuf_v1_requestszwp_linux_dmabuf_v1_eventszwp_linux_dmabuf_v1_interfaceZWP_LINUX_BUFFER_PARAMS_V1_INTERFACEzwp_linux_buffer_params_v1_requests_create_immed_typeszwp_linux_buffer_params_v1_requestszwp_linux_buffer_params_v1_events_created_typeszwp_linux_buffer_params_v1_eventszwp_linux_buffer_params_v1_interfaceZWP_LINUX_DMABUF_FEEDBACK_V1_INTERFACEzwp_linux_dmabuf_feedback_v1_requestszwp_linux_dmabuf_feedback_v1_eventszwp_linux_dmabuf_feedback_v1_interface"factory for creating dmabuf-based wl_buffers\n\nThis interface offers ways to create generic dmabuf-based wl_buffers.\n\nFor more information about dmabuf, see:\nhttps://www.kernel.org/doc/html/next/userspace-api/dma-buf-alloc-exchange.html\n\nClients can use the get_surface_feedback request to get dmabuf feedback\nfor a particular surface. If the client wants to retrieve feedback not\ntied to a surface, they can use the get_default_feedback request.\n\nThe following are required from clients:\n\n- Clients must ensure that either all data in the dma-buf is\ncoherent for all subsequent read access or that coherency is\ncorrectly handled by the underlying kernel-side dma-buf\nimplementation.\n\n- Don't make any more attachments after sending the buffer to the\ncompositor. Making more attachments later increases the risk of\nthe compositor not being able to use (re-import) an existing\ndmabuf-based wl_buffer.\n\nThe underlying graphics stack must ensure the following:\n\n- The dmabuf file descriptors relayed to the server will stay valid\nfor the whole lifetime of the wl_buffer. This means the server may\nat any time use those fds to import the dmabuf into any kernel\nsub-system that might accept it.\n\nHowever, when the underlying graphics stack fails to deliver the\npromise, because of e.g. a device hot-unplug which raises internal\nerrors, after the wl_buffer has been successfully created the\ncompositor must not raise protocol errors to the client when dmabuf\nimport later fails.\n\nTo create a wl_buffer from one or more dmabufs, a client creates a\nzwp_linux_dmabuf_params_v1 object with a zwp_linux_dmabuf_v1.create_params\nrequest. All planes required by the intended format are added with\nthe 'add' request. Finally, a 'create' or 'create_immed' request is\nissued, which has the following outcome depending on the import success.\n\nThe 'create' request,\n- on success, triggers a 'created' event which provides the final\nwl_buffer to the client.\n- on failure, triggers a 'failed' event to convey that the server\ncannot use the dmabufs received from the client.\n\nFor the 'create_immed' request,\n- on success, the server immediately imports the added dmabufs to\ncreate a wl_buffer. No event is sent from the server in this case.\n- on failure, the server can choose to either:\n- terminate the client by raising a fatal error.\n- mark the wl_buffer as failed, and send a 'failed' event to the\nclient. If the client uses a failed wl_buffer as an argument to any\nrequest, the behaviour is compositor implementation-defined.\n\nFor all DRM formats and unless specified in another protocol extension,\npre-multiplied alpha is used for pixel values.\n\nUnless specified otherwise in another protocol extension, implicit\nsynchronization is used. In other words, compositors and clients must\nwait and signal fences implicitly passed via the DMA-BUF's reservation\nmechanism."REQ_CREATE_PARAMS_SINCEREQ_CREATE_PARAMS_OPCODEREQ_GET_DEFAULT_FEEDBACK_SINCEREQ_GET_DEFAULT_FEEDBACK_OPCODEEVT_MODIFIER_SINCEEVT_MODIFIER_OPCODE"unbind the factory\n\nObjects created through this interface, especially wl_buffers, will\nremain valid.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a temporary object for buffer parameters\n\nThis temporary object is used to collect multiple dmabuf handles into\na single batch to create a wl_buffer. It can only be used once and\nshould be destroyed after a 'created' or 'failed' event has been\nreceived."CreateParams"get default feedback\n\nThis request creates a new wp_linux_dmabuf_feedback object not bound\nto a particular surface. This object will deliver feedback about dmabuf\nparameters to use if the client doesn't support per-surface feedback\n(see get_surface_feedback).\n\nOnly available since version 4 of the interface"GetDefaultFeedback"get feedback for a surface\n\nThis request creates a new wp_linux_dmabuf_feedback object for the\nspecified wl_surface. This object will deliver feedback about dmabuf\nparameters to use for buffers attached to this surface.\n\nIf the surface is destroyed before the wp_linux_dmabuf_feedback object,\nthe feedback object becomes inert.\n\nOnly available since version 4 of the interface""supported buffer format\n\nThis event advertises one buffer format that the server supports.\nAll the supported formats are advertised once when the client\nbinds to this interface. A roundtrip after binding guarantees\nthat the client has received all supported formats.\n\nFor the definition of the format codes, see the\nzwp_linux_buffer_params_v1::create request.\n\nStarting version 4, the format event is deprecated and must not be\nsent by compositors. Instead, use get_default_feedback or\nget_surface_feedback.""DRM_FORMAT code""supported buffer format modifier\n\nThis event advertises the formats that the server supports, along with\nthe modifiers supported for each format. All the supported modifiers\nfor all the supported formats are advertised once when the client\nbinds to this interface. A roundtrip after binding guarantees that\nthe client has received all supported format-modifier pairs.\n\nFor legacy support, DRM_FORMAT_MOD_INVALID (that is, modifier_hi ==\n0x00ffffff and modifier_lo == 0xffffffff) is allowed in this event.\nIt indicates that the server can support the format with an implicit\nmodifier. When a plane has DRM_FORMAT_MOD_INVALID as its modifier, it\nis as if no explicit modifier is specified. The effective modifier\nwill be derived from the dmabuf.\n\nA compositor that sends valid modifiers and DRM_FORMAT_MOD_INVALID for\na given format supports both explicit modifiers and implicit modifiers.\n\nFor the definition of the format and modifier codes, see the\nzwp_linux_buffer_params_v1::create and zwp_linux_buffer_params_v1::add\nrequests.\n\nStarting version 4, the modifier event is deprecated and must not be\nsent by compositors. Instead, use get_default_feedback or\nget_surface_feedback.\n\nOnly available since version 3 of the interface""high 32 bits of layout modifier"modifier_hi"low 32 bits of layout modifier"modifier_lo"factory for creating dmabuf-based wl_buffers\n\nThis interface offers ways to create generic dmabuf-based wl_buffers.\n\nFor more information about dmabuf, see:\nhttps://www.kernel.org/doc/html/next/userspace-api/dma-buf-alloc-exchange.html\n\nClients can use the get_surface_feedback request to get dmabuf feedback\nfor a particular surface. If the client wants to retrieve feedback not\ntied to a surface, they can use the get_default_feedback request.\n\nThe following are required from clients:\n\n- Clients must ensure that either all data in the dma-buf is\ncoherent for all subsequent read access or that coherency is\ncorrectly handled by the underlying kernel-side dma-buf\nimplementation.\n\n- Don't make any more attachments after sending the buffer to the\ncompositor. Making more attachments later increases the risk of\nthe compositor not being able to use (re-import) an existing\ndmabuf-based wl_buffer.\n\nThe underlying graphics stack must ensure the following:\n\n- The dmabuf file descriptors relayed to the server will stay valid\nfor the whole lifetime of the wl_buffer. This means the server may\nat any time use those fds to import the dmabuf into any kernel\nsub-system that might accept it.\n\nHowever, when the underlying graphics stack fails to deliver the\npromise, because of e.g. a device hot-unplug which raises internal\nerrors, after the wl_buffer has been successfully created the\ncompositor must not raise protocol errors to the client when dmabuf\nimport later fails.\n\nTo create a wl_buffer from one or more dmabufs, a client creates a\nzwp_linux_dmabuf_params_v1 object with a zwp_linux_dmabuf_v1.create_params\nrequest. All planes required by the intended format are added with\nthe 'add' request. Finally, a 'create' or 'create_immed' request is\nissued, which has the following outcome depending on the import success.\n\nThe 'create' request,\n- on success, triggers a 'created' event which provides the final\nwl_buffer to the client.\n- on failure, triggers a 'failed' event to convey that the server\ncannot use the dmabufs received from the client.\n\nFor the 'create_immed' request,\n- on success, the server immediately imports the added dmabufs to\ncreate a wl_buffer. No event is sent from the server in this case.\n- on failure, the server can choose to either:\n- terminate the client by raising a fatal error.\n- mark the wl_buffer as failed, and send a 'failed' event to the\nclient. If the client uses a failed wl_buffer as an argument to any\nrequest, the behaviour is compositor implementation-defined.\n\nFor all DRM formats and unless specified in another protocol extension,\npre-multiplied alpha is used for pixel values.\n\nUnless specified otherwise in another protocol extension, implicit\nsynchronization is used. In other words, compositors and clients must\nwait and signal fences implicitly passed via the DMA-BUF's reservation\nmechanism.\n\nSee also the [Event] enum for this interface.""unbind the factory\n\nObjects created through this interface, especially wl_buffers, will\nremain valid.""get default feedback\n\nThis request creates a new wp_linux_dmabuf_feedback object not bound\nto a particular surface. This object will deliver feedback about dmabuf\nparameters to use if the client doesn't support per-surface feedback\n(see get_surface_feedback).""get feedback for a surface\n\nThis request creates a new wp_linux_dmabuf_feedback object for the\nspecified wl_surface. This object will deliver feedback about dmabuf\nparameters to use for buffers attached to this surface.\n\nIf the surface is destroyed before the wp_linux_dmabuf_feedback object,\nthe feedback object becomes inert.""parameters for creating a dmabuf-based wl_buffer\n\nThis temporary object is a collection of dmabufs and other\nparameters that together form a single logical buffer. The temporary\nobject may eventually create one wl_buffer unless cancelled by\ndestroying it before requesting 'create'.\n\nSingle-planar formats only require one dmabuf, however\nmulti-planar formats may require more than one dmabuf. For all\nformats, an 'add' request must be called once per plane (even if the\nunderlying dmabuf fd is identical).\n\nYou must use consecutive plane indices ('plane_idx' argument for 'add')\nfrom zero to the number of planes used by the drm_fourcc format code.\nAll planes required by the format must be given exactly once, but can\nbe given in any order. Each plane index can only be set once; subsequent\ncalls with a plane index which has already been set will result in a\nplane_set error being generated.""the dmabuf_batch object has already been used to create a wl_buffer"AlreadyUsed"plane index out of bounds"PlaneIdx"the plane index was already set"PlaneSet"missing or too many planes to create a buffer""format not supported""invalid width or height""offset + stride * height goes out of dmabuf bounds""invalid wl_buffer resulted from importing dmabufs via the create_immed request on given buffer_params"InvalidWlBuffer"contents are y-inverted"YInvert"content is interlaced""bottom field first"BottomFirstREQ_CREATE_IMMED_SINCEREQ_CREATE_IMMED_OPCODEEVT_CREATED_SINCEEVT_CREATED_OPCODE"delete this object, used or not\n\nCleans up the temporary data sent to the server for dmabuf-based\nwl_buffer creation.\n\nThis is a destructor, once sent this object cannot be used any longer.""add a dmabuf to the temporary set\n\nThis request adds one dmabuf to the set in this\nzwp_linux_buffer_params_v1.\n\nThe 64-bit unsigned value combined from modifier_hi and modifier_lo\nis the dmabuf layout modifier. DRM AddFB2 ioctl calls this the\nfb modifier, which is defined in drm_mode.h of Linux UAPI.\nThis is an opaque token. Drivers use this token to express tiling,\ncompression, etc. driver-specific modifications to the base format\ndefined by the DRM fourcc code.\n\nStarting from version 4, the invalid_format protocol error is sent if\nthe format + modifier pair was not advertised as supported.\n\nStarting from version 5, the invalid_format protocol error is sent if\nall planes don't use the same modifier.\n\nThis request raises the PLANE_IDX error if plane_idx is too large.\nThe error PLANE_SET is raised if attempting to set a plane that\nwas already set.""dmabuf fd""plane index"plane_idx"offset in bytes""stride in bytes""create a wl_buffer from the given dmabufs\n\nThis asks for creation of a wl_buffer from the added dmabuf\nbuffers. The wl_buffer is not created immediately but returned via\nthe 'created' event if the dmabuf sharing succeeds. The sharing\nmay fail at runtime for reasons a client cannot predict, in\nwhich case the 'failed' event is triggered.\n\nThe 'format' argument is a DRM_FORMAT code, as defined by the\nlibdrm's drm_fourcc.h. The Linux kernel's DRM sub-system is the\nauthoritative source on how the format codes should work.\n\nThe 'flags' is a bitfield of the flags defined in enum \"flags\".\n'y_invert' means the that the image needs to be y-flipped.\n\nFlag 'interlaced' means that the frame in the buffer is not\nprogressive as usual, but interlaced. An interlaced buffer as\nsupported here must always contain both top and bottom fields.\nThe top field always begins on the first pixel row. The temporal\nordering between the two fields is top field first, unless\n'bottom_first' is specified. It is undefined whether 'bottom_first'\nis ignored if 'interlaced' is not set.\n\nThis protocol does not convey any information about field rate,\nduration, or timing, other than the relative ordering between the\ntwo fields in one buffer. A compositor may have to estimate the\nintended field rate from the incoming buffer rate. It is undefined\nwhether the time of receiving wl_surface.commit with a new buffer\nattached, applying the wl_surface state, wl_surface.frame callback\ntrigger, presentation, or any other point in the compositor cycle\nis used to measure the frame or field times. There is no support\nfor detecting missed or late frames/fields/buffers either, and\nthere is no support whatsoever for cooperating with interlaced\ncompositor output.\n\nThe composited image quality resulting from the use of interlaced\nbuffers is explicitly undefined. A compositor may use elaborate\nhardware features or software to deinterlace and create progressive\noutput frames from a sequence of interlaced input buffers, or it\nmay produce substandard image quality. However, compositors that\ncannot guarantee reasonable image quality in all cases are recommended\nto just reject all interlaced buffers.\n\nAny argument errors, including non-positive width or height,\nmismatch between the number of planes and the format, bad\nformat, bad offset or stride, may be indicated by fatal protocol\nerrors: INCOMPLETE, INVALID_FORMAT, INVALID_DIMENSIONS,\nOUT_OF_BOUNDS.\n\nDmabuf import errors in the server that are not obvious client\nbugs are returned via the 'failed' event as non-fatal. This\nallows attempting dmabuf sharing and falling back in the client\nif it fails.\n\nThis request can be sent only once in the object's lifetime, after\nwhich the only legal request is destroy. This object should be\ndestroyed after issuing a 'create' request. Attempting to use this\nobject after issuing 'create' raises ALREADY_USED protocol error.\n\nIt is not mandatory to issue 'create'. If a client wants to\ncancel the buffer creation, it can just destroy this object.""base plane width in pixels""base plane height in pixels""see enum flags""immediately create a wl_buffer from the given dmabufs\n\nThis asks for immediate creation of a wl_buffer by importing the\nadded dmabufs.\n\nIn case of import success, no event is sent from the server, and the\nwl_buffer is ready to be used by the client.\n\nUpon import failure, either of the following may happen, as seen fit\nby the implementation:\n- the client is terminated with one of the following fatal protocol\nerrors:\n- INCOMPLETE, INVALID_FORMAT, INVALID_DIMENSIONS, OUT_OF_BOUNDS,\nin case of argument errors such as mismatch between the number\nof planes and the format, bad format, non-positive width or\nheight, or bad offset or stride.\n- INVALID_WL_BUFFER, in case the cause for failure is unknown or\nplatform specific.\n- the server creates an invalid wl_buffer, marks it as failed and\nsends a 'failed' event to the client. The result of using this\ninvalid wl_buffer as an argument in any request by the client is\ndefined by the compositor implementation.\n\nThis takes the same arguments as a 'create' request, and obeys the\nsame restrictions.\n\nOnly available since version 2 of the interface"CreateImmed"buffer creation succeeded\n\nThis event indicates that the attempted buffer creation was\nsuccessful. It provides the new wl_buffer referencing the dmabuf(s).\n\nUpon receiving this event, the client should destroy the\nzwp_linux_buffer_params_v1 object.""the newly created wl_buffer""buffer creation failed\n\nThis event indicates that the attempted buffer creation has\nfailed. It usually means that one of the dmabuf constraints\nhas not been fulfilled.\n\nUpon receiving this event, the client should destroy the\nzwp_linux_buffer_params_v1 object.""parameters for creating a dmabuf-based wl_buffer\n\nThis temporary object is a collection of dmabufs and other\nparameters that together form a single logical buffer. The temporary\nobject may eventually create one wl_buffer unless cancelled by\ndestroying it before requesting 'create'.\n\nSingle-planar formats only require one dmabuf, however\nmulti-planar formats may require more than one dmabuf. For all\nformats, an 'add' request must be called once per plane (even if the\nunderlying dmabuf fd is identical).\n\nYou must use consecutive plane indices ('plane_idx' argument for 'add')\nfrom zero to the number of planes used by the drm_fourcc format code.\nAll planes required by the format must be given exactly once, but can\nbe given in any order. Each plane index can only be set once; subsequent\ncalls with a plane index which has already been set will result in a\nplane_set error being generated.\n\nSee also the [Event] enum for this interface.""delete this object, used or not\n\nCleans up the temporary data sent to the server for dmabuf-based\nwl_buffer creation.""immediately create a wl_buffer from the given dmabufs\n\nThis asks for immediate creation of a wl_buffer by importing the\nadded dmabufs.\n\nIn case of import success, no event is sent from the server, and the\nwl_buffer is ready to be used by the client.\n\nUpon import failure, either of the following may happen, as seen fit\nby the implementation:\n- the client is terminated with one of the following fatal protocol\nerrors:\n- INCOMPLETE, INVALID_FORMAT, INVALID_DIMENSIONS, OUT_OF_BOUNDS,\nin case of argument errors such as mismatch between the number\nof planes and the format, bad format, non-positive width or\nheight, or bad offset or stride.\n- INVALID_WL_BUFFER, in case the cause for failure is unknown or\nplatform specific.\n- the server creates an invalid wl_buffer, marks it as failed and\nsends a 'failed' event to the client. The result of using this\ninvalid wl_buffer as an argument in any request by the client is\ndefined by the compositor implementation.\n\nThis takes the same arguments as a 'create' request, and obeys the\nsame restrictions.""dmabuf feedback\n\nThis object advertises dmabuf parameters feedback. This includes the\npreferred devices and the supported formats/modifiers.\n\nThe parameters are sent once when this object is created and whenever they\nchange. The done event is always sent once after all parameters have been\nsent. When a single parameter changes, all parameters are re-sent by the\ncompositor.\n\nCompositors can re-send the parameters when the current client buffer\nallocations are sub-optimal. Compositors should not re-send the\nparameters if re-allocating the buffers would not result in a more optimal\nconfiguration. In particular, compositors should avoid sending the exact\nsame parameters multiple times in a row.\n\nThe tranche_target_device and tranche_formats events are grouped by\ntranches of preference. For each tranche, a tranche_target_device, one\ntranche_flags and one or more tranche_formats events are sent, followed\nby a tranche_done event finishing the list. The tranches are sent in\ndescending order of preference. All formats and modifiers in the same\ntranche have the same preference.\n\nTo send parameters, the compositor sends one main_device event, tranches\n(each consisting of one tranche_target_device event, one tranche_flags\nevent, tranche_formats events and then a tranche_done event), then one\ndone event.""direct scan-out tranche"ScanoutEVT_FORMAT_TABLE_SINCEEVT_FORMAT_TABLE_OPCODEEVT_MAIN_DEVICE_SINCEEVT_MAIN_DEVICE_OPCODEEVT_TRANCHE_DONE_SINCEEVT_TRANCHE_DONE_OPCODEEVT_TRANCHE_TARGET_DEVICE_SINCEEVT_TRANCHE_TARGET_DEVICE_OPCODEEVT_TRANCHE_FORMATS_SINCEEVT_TRANCHE_FORMATS_OPCODEEVT_TRANCHE_FLAGS_SINCEEVT_TRANCHE_FLAGS_OPCODE"destroy the feedback object\n\nUsing this request a client can tell the server that it is not going to\nuse the wp_linux_dmabuf_feedback object anymore.\n\nThis is a destructor, once sent this object cannot be used any longer.""all feedback has been sent\n\nThis event is sent after all parameters of a wp_linux_dmabuf_feedback\nobject have been sent.\n\nThis allows changes to the wp_linux_dmabuf_feedback parameters to be\nseen as atomic, even if they happen via multiple events.""format and modifier table\n\nThis event provides a file descriptor which can be memory-mapped to\naccess the format and modifier table.\n\nThe table contains a tightly packed array of consecutive format +\nmodifier pairs. Each pair is 16 bytes wide. It contains a format as a\n32-bit unsigned integer, followed by 4 bytes of unused padding, and a\nmodifier as a 64-bit unsigned integer. The native endianness is used.\n\nThe client must map the file descriptor in read-only private mode.\n\nCompositors are not allowed to mutate the table file contents once this\nevent has been sent. Instead, compositors must create a new, separate\ntable file and re-send feedback parameters. Compositors are allowed to\nstore duplicate format + modifier pairs in the table.""table file descriptor""table size, in bytes"FormatTable"preferred main device\n\nThis event advertises the main device that the server prefers to use\nwhen direct scan-out to the target device isn't possible. The\nadvertised main device may be different for each\nwp_linux_dmabuf_feedback object, and may change over time.\n\nThere is exactly one main device. The compositor must send at least\none preference tranche with tranche_target_device equal to main_device.\n\nClients need to create buffers that the main device can import and\nread from, otherwise creating the dmabuf wl_buffer will fail (see the\nwp_linux_buffer_params.create and create_immed requests for details).\nThe main device will also likely be kept active by the compositor,\nso clients can use it instead of waking up another device for power\nsavings.\n\nIn general the device is a DRM node. The DRM node type (primary vs.\nrender) is unspecified. Clients must not rely on the compositor sending\na particular node type. Clients cannot check two devices for equality\nby comparing the dev_t value.\n\nIf explicit modifiers are not supported and the client performs buffer\nallocations on a different device than the main device, then the client\nmust force the buffer to have a linear layout."MainDevice"a preference tranche has been sent\n\nThis event splits tranche_target_device and tranche_formats events in\npreference tranches. It is sent after a set of tranche_target_device\nand tranche_formats events; it represents the end of a tranche. The\nnext tranche will have a lower preference."TrancheDone"target device\n\nThis event advertises the target device that the server prefers to use\nfor a buffer created given this tranche. The advertised target device\nmay be different for each preference tranche, and may change over time.\n\nThere is exactly one target device per tranche.\n\nThe target device may be a scan-out device, for example if the\ncompositor prefers to directly scan-out a buffer created given this\ntranche. The target device may be a rendering device, for example if\nthe compositor prefers to texture from said buffer.\n\nThe client can use this hint to allocate the buffer in a way that makes\nit accessible from the target device, ideally directly. The buffer must\nstill be accessible from the main device, either through direct import\nor through a potentially more expensive fallback path. If the buffer\ncan't be directly imported from the main device then clients must be\nprepared for the compositor changing the tranche priority or making\nwl_buffer creation fail (see the wp_linux_buffer_params.create and\ncreate_immed requests for details).\n\nIf the device is a DRM node, the DRM node type (primary vs. render) is\nunspecified. Clients must not rely on the compositor sending a\nparticular node type. Clients cannot check two devices for equality by\ncomparing the dev_t value.\n\nThis event is tied to a preference tranche, see the tranche_done event."TrancheTargetDevice"supported buffer format modifier\n\nThis event advertises the format + modifier combinations that the\ncompositor supports.\n\nIt carries an array of indices, each referring to a format + modifier\npair in the last received format table (see the format_table event).\nEach index is a 16-bit unsigned integer in native endianness.\n\nFor legacy support, DRM_FORMAT_MOD_INVALID is an allowed modifier.\nIt indicates that the server can support the format with an implicit\nmodifier. When a buffer has DRM_FORMAT_MOD_INVALID as its modifier, it\nis as if no explicit modifier is specified. The effective modifier\nwill be derived from the dmabuf.\n\nA compositor that sends valid modifiers and DRM_FORMAT_MOD_INVALID for\na given format supports both explicit modifiers and implicit modifiers.\n\nCompositors must not send duplicate format + modifier pairs within the\nsame tranche or across two different tranches with the same target\ndevice and flags.\n\nThis event is tied to a preference tranche, see the tranche_done event.\n\nFor the definition of the format and modifier codes, see the\nwp_linux_buffer_params.create request.""array of 16-bit indexes"TrancheFormats"tranche flags\n\nThis event sets tranche-specific flags.\n\nThe scanout flag is a hint that direct scan-out may be attempted by the\ncompositor on the target device if the client appropriately allocates a\nbuffer. How to allocate a buffer that can be scanned out on the target\ndevice is implementation-defined.\n\nThis event is tied to a preference tranche, see the tranche_done event.""tranche flags""dmabuf feedback\n\nThis object advertises dmabuf parameters feedback. This includes the\npreferred devices and the supported formats/modifiers.\n\nThe parameters are sent once when this object is created and whenever they\nchange. The done event is always sent once after all parameters have been\nsent. When a single parameter changes, all parameters are re-sent by the\ncompositor.\n\nCompositors can re-send the parameters when the current client buffer\nallocations are sub-optimal. Compositors should not re-send the\nparameters if re-allocating the buffers would not result in a more optimal\nconfiguration. In particular, compositors should avoid sending the exact\nsame parameters multiple times in a row.\n\nThe tranche_target_device and tranche_formats events are grouped by\ntranches of preference. For each tranche, a tranche_target_device, one\ntranche_flags and one or more tranche_formats events are sent, followed\nby a tranche_done event finishing the list. The tranches are sent in\ndescending order of preference. All formats and modifiers in the same\ntranche have the same preference.\n\nTo send parameters, the compositor sends one main_device event, tranches\n(each consisting of one tranche_target_device event, one tranche_flags\nevent, tranche_formats events and then a tranche_done event), then one\ndone event.\n\nSee also the [Event] enum for this interface.""destroy the feedback object\n\nUsing this request a client can tell the server that it is not going to\nuse the wp_linux_dmabuf_feedback object anymore."//! Linux DMA-BUF protocolZWP_LINUX_EXPLICIT_SYNCHRONIZATION_V1_INTERFACEzwp_linux_explicit_synchronization_v1_requests_get_synchronization_typeszwp_linux_explicit_synchronization_v1_requestszwp_linux_explicit_synchronization_v1_interfaceZWP_LINUX_SURFACE_SYNCHRONIZATION_V1_INTERFACEzwp_linux_surface_synchronization_v1_requests_get_release_typeszwp_linux_surface_synchronization_v1_requestszwp_linux_surface_synchronization_v1_interfaceZWP_LINUX_BUFFER_RELEASE_V1_INTERFACEzwp_linux_buffer_release_v1_eventszwp_linux_buffer_release_v1_interface"protocol for providing explicit synchronization\n\nThis global is a factory interface, allowing clients to request\nexplicit synchronization for buffers on a per-surface basis.\n\nSee zwp_linux_surface_synchronization_v1 for more information.\n\nThis interface is derived from Chromium's\nzcr_linux_explicit_synchronization_v1.\n\nNote: this protocol is superseded by linux-drm-syncobj.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.""the surface already has a synchronization object associated"SynchronizationExistsREQ_GET_SYNCHRONIZATION_SINCEREQ_GET_SYNCHRONIZATION_OPCODE"destroy explicit synchronization factory object\n\nDestroy this explicit synchronization factory object. Other objects,\nincluding zwp_linux_surface_synchronization_v1 objects created by this\nfactory, shall not be affected by this request.\n\nThis is a destructor, once sent this object cannot be used any longer.""extend surface interface for explicit synchronization\n\nInstantiate an interface extension for the given wl_surface to provide\nexplicit synchronization.\n\nIf the given wl_surface already has an explicit synchronization object\nassociated, the synchronization_exists protocol error is raised.\n\nGraphics APIs, like EGL or Vulkan, that manage the buffer queue and\ncommits of a wl_surface themselves, are likely to be using this\nextension internally. If a client is using such an API for a\nwl_surface, it should not directly use this extension on that surface,\nto avoid raising a synchronization_exists protocol error."GetSynchronization"protocol for providing explicit synchronization\n\nThis global is a factory interface, allowing clients to request\nexplicit synchronization for buffers on a per-surface basis.\n\nSee zwp_linux_surface_synchronization_v1 for more information.\n\nThis interface is derived from Chromium's\nzcr_linux_explicit_synchronization_v1.\n\nNote: this protocol is superseded by linux-drm-syncobj.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nThis interface has no events."ZwpLinuxExplicitSynchronizationV1"destroy explicit synchronization factory object\n\nDestroy this explicit synchronization factory object. Other objects,\nincluding zwp_linux_surface_synchronization_v1 objects created by this\nfactory, shall not be affected by this request."zwp_linux_surface_synchronization_v1ZwpLinuxSurfaceSynchronizationV1get_synchronizationzwp_linux_explicit_synchronization_v1"per-surface explicit synchronization support\n\nThis object implements per-surface explicit synchronization.\n\nSynchronization refers to co-ordination of pipelined operations performed\non buffers. Most GPU clients will schedule an asynchronous operation to\nrender to the buffer, then immediately send the buffer to the compositor\nto be attached to a surface.\n\nIn implicit synchronization, ensuring that the rendering operation is\ncomplete before the compositor displays the buffer is an implementation\ndetail handled by either the kernel or userspace graphics driver.\n\nBy contrast, in explicit synchronization, dma_fence objects mark when the\nasynchronous operations are complete. When submitting a buffer, the\nclient provides an acquire fence which will be waited on before the\ncompositor accesses the buffer. The Wayland server, through a\nzwp_linux_buffer_release_v1 object, will inform the client with an event\nwhich may be accompanied by a release fence, when the compositor will no\nlonger access the buffer contents due to the specific commit that\nrequested the release event.\n\nEach surface can be associated with only one object of this interface at\nany time.\n\nIn version 1 of this interface, explicit synchronization is only\nguaranteed to be supported for buffers created with any version of the\nwp_linux_dmabuf buffer factory. Version 2 additionally guarantees\nexplicit synchronization support for opaque EGL buffers, which is a type\nof platform specific buffers described in the EGL_WL_bind_wayland_display\nextension. Compositors are free to support explicit synchronization for\nadditional buffer types.""the fence specified by the client could not be imported"InvalidFence"multiple fences added for a single surface commit"DuplicateFence"multiple releases added for a single surface commit"DuplicateRelease"the associated wl_surface was destroyed"NoSurface"the buffer does not support explicit synchronization"UnsupportedBuffer"no buffer was attached"REQ_SET_ACQUIRE_FENCE_SINCEREQ_SET_ACQUIRE_FENCE_OPCODEREQ_GET_RELEASE_SINCEREQ_GET_RELEASE_OPCODE"destroy synchronization object\n\nDestroy this explicit synchronization object.\n\nAny fence set by this object with set_acquire_fence since the last\ncommit will be discarded by the server. Any fences set by this object\nbefore the last commit are not affected.\n\nzwp_linux_buffer_release_v1 objects created by this object are not\naffected by this request.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the acquire fence\n\nSet the acquire fence that must be signaled before the compositor\nmay sample from the buffer attached with wl_surface.attach. The fence\nis a dma_fence kernel object.\n\nThe acquire fence is double-buffered state, and will be applied on the\nnext wl_surface.commit request for the associated surface. Thus, it\napplies only to the buffer that is attached to the surface at commit\ntime.\n\nIf the provided fd is not a valid dma_fence fd, then an INVALID_FENCE\nerror is raised.\n\nIf a fence has already been attached during the same commit cycle, a\nDUPLICATE_FENCE error is raised.\n\nIf the associated wl_surface was destroyed, a NO_SURFACE error is\nraised.\n\nIf at surface commit time the attached buffer does not support explicit\nsynchronization, an UNSUPPORTED_BUFFER error is raised.\n\nIf at surface commit time there is no buffer attached, a NO_BUFFER\nerror is raised.""acquire fence fd"SetAcquireFence"release fence for last-attached buffer\n\nCreate a listener for the release of the buffer attached by the\nclient with wl_surface.attach. See zwp_linux_buffer_release_v1\ndocumentation for more information.\n\nThe release object is double-buffered state, and will be associated\nwith the buffer that is attached to the surface at wl_surface.commit\ntime.\n\nIf a zwp_linux_buffer_release_v1 object has already been requested for\nthe surface in the same commit cycle, a DUPLICATE_RELEASE error is\nraised.\n\nIf the associated wl_surface was destroyed, a NO_SURFACE error\nis raised.\n\nIf at surface commit time there is no buffer attached, a NO_BUFFER\nerror is raised."GetRelease"per-surface explicit synchronization support\n\nThis object implements per-surface explicit synchronization.\n\nSynchronization refers to co-ordination of pipelined operations performed\non buffers. Most GPU clients will schedule an asynchronous operation to\nrender to the buffer, then immediately send the buffer to the compositor\nto be attached to a surface.\n\nIn implicit synchronization, ensuring that the rendering operation is\ncomplete before the compositor displays the buffer is an implementation\ndetail handled by either the kernel or userspace graphics driver.\n\nBy contrast, in explicit synchronization, dma_fence objects mark when the\nasynchronous operations are complete. When submitting a buffer, the\nclient provides an acquire fence which will be waited on before the\ncompositor accesses the buffer. The Wayland server, through a\nzwp_linux_buffer_release_v1 object, will inform the client with an event\nwhich may be accompanied by a release fence, when the compositor will no\nlonger access the buffer contents due to the specific commit that\nrequested the release event.\n\nEach surface can be associated with only one object of this interface at\nany time.\n\nIn version 1 of this interface, explicit synchronization is only\nguaranteed to be supported for buffers created with any version of the\nwp_linux_dmabuf buffer factory. Version 2 additionally guarantees\nexplicit synchronization support for opaque EGL buffers, which is a type\nof platform specific buffers described in the EGL_WL_bind_wayland_display\nextension. Compositors are free to support explicit synchronization for\nadditional buffer types.\n\nThis interface has no events.""destroy synchronization object\n\nDestroy this explicit synchronization object.\n\nAny fence set by this object with set_acquire_fence since the last\ncommit will be discarded by the server. Any fences set by this object\nbefore the last commit are not affected.\n\nzwp_linux_buffer_release_v1 objects created by this object are not\naffected by this request."set_acquire_fencezwp_linux_buffer_release_v1ZwpLinuxBufferReleaseV1get_release"buffer release explicit synchronization\n\nThis object is instantiated in response to a\nzwp_linux_surface_synchronization_v1.get_release request.\n\nIt provides an alternative to wl_buffer.release events, providing a\nunique release from a single wl_surface.commit request. The release event\nalso supports explicit synchronization, providing a fence FD for the\nclient to synchronize against.\n\nExactly one event, either a fenced_release or an immediate_release, will\nbe emitted for the wl_surface.commit request. The compositor can choose\nrelease by release which event it uses.\n\nThis event does not replace wl_buffer.release events; servers are still\nrequired to send those events.\n\nOnce a buffer release object has delivered a 'fenced_release' or an\n'immediate_release' event it is automatically destroyed."EVT_FENCED_RELEASE_SINCEEVT_FENCED_RELEASE_OPCODEEVT_IMMEDIATE_RELEASE_SINCEEVT_IMMEDIATE_RELEASE_OPCODE"release buffer with fence\n\nSent when the compositor has finalised its usage of the associated\nbuffer for the relevant commit, providing a dma_fence which will be\nsignaled when all operations by the compositor on that buffer for that\ncommit have finished.\n\nOnce the fence has signaled, and assuming the associated buffer is not\npending release from other wl_surface.commit requests, no additional\nexplicit or implicit synchronization is required to safely reuse or\ndestroy the buffer.\n\nThis event destroys the zwp_linux_buffer_release_v1 object.\n\nThis is a destructor, once received this object cannot be used any longer.""fence for last operation on buffer"FencedRelease"release buffer immediately\n\nSent when the compositor has finalised its usage of the associated\nbuffer for the relevant commit, and either performed no operations\nusing it, or has a guarantee that all its operations on that buffer for\nthat commit have finished.\n\nOnce this event is received, and assuming the associated buffer is not\npending release from other wl_surface.commit requests, no additional\nexplicit or implicit synchronization is required to safely reuse or\ndestroy the buffer.\n\nThis event destroys the zwp_linux_buffer_release_v1 object.\n\nThis is a destructor, once received this object cannot be used any longer."ImmediateRelease"buffer release explicit synchronization\n\nThis object is instantiated in response to a\nzwp_linux_surface_synchronization_v1.get_release request.\n\nIt provides an alternative to wl_buffer.release events, providing a\nunique release from a single wl_surface.commit request. The release event\nalso supports explicit synchronization, providing a fence FD for the\nclient to synchronize against.\n\nExactly one event, either a fenced_release or an immediate_release, will\nbe emitted for the wl_surface.commit request. The compositor can choose\nrelease by release which event it uses.\n\nThis event does not replace wl_buffer.release events; servers are still\nrequired to send those events.\n\nOnce a buffer release object has delivered a 'fenced_release' or an\n'immediate_release' event it is automatically destroyed.\n\nSee also the [Event] enum for this interface."//! Linux explicit synchronization protocollinux_explicit_synchronizationWP_LINUX_DRM_SYNCOBJ_MANAGER_V1_INTERFACEwp_linux_drm_syncobj_manager_v1_requests_get_surface_typeswp_linux_drm_syncobj_manager_v1_requests_import_timeline_typeswp_linux_drm_syncobj_manager_v1_requestswp_linux_drm_syncobj_manager_v1_interfaceWP_LINUX_DRM_SYNCOBJ_TIMELINE_V1_INTERFACEwp_linux_drm_syncobj_timeline_v1_requestswp_linux_drm_syncobj_timeline_v1_interfaceWP_LINUX_DRM_SYNCOBJ_SURFACE_V1_INTERFACEwp_linux_drm_syncobj_surface_v1_requests_set_acquire_point_typeswp_linux_drm_syncobj_surface_v1_requests_set_release_point_typeswp_linux_drm_syncobj_surface_v1_requestswp_linux_drm_syncobj_surface_v1_interface"global for providing explicit synchronization\n\nThis global is a factory interface, allowing clients to request\nexplicit synchronization for buffers on a per-surface basis.\n\nSee wp_linux_drm_syncobj_surface_v1 for more information.""the timeline object could not be imported"InvalidTimelineREQ_IMPORT_TIMELINE_SINCEREQ_IMPORT_TIMELINE_OPCODE"destroy explicit synchronization factory object\n\nDestroy this explicit synchronization factory object. Other objects\nshall not be affected by this request.\n\nThis is a destructor, once sent this object cannot be used any longer.""extend surface interface for explicit synchronization\n\nInstantiate an interface extension for the given wl_surface to provide\nexplicit synchronization.\n\nIf the given wl_surface already has an explicit synchronization object\nassociated, the surface_exists protocol error is raised.\n\nGraphics APIs, like EGL or Vulkan, that manage the buffer queue and\ncommits of a wl_surface themselves, are likely to be using this\nextension internally. If a client is using such an API for a\nwl_surface, it should not directly use this extension on that surface,\nto avoid raising a surface_exists protocol error.""import a DRM syncobj timeline\n\nImport a DRM synchronization object timeline.\n\nIf the FD cannot be imported, the invalid_timeline error is raised.""drm_syncobj file descriptor"ImportTimeline"global for providing explicit synchronization\n\nThis global is a factory interface, allowing clients to request\nexplicit synchronization for buffers on a per-surface basis.\n\nSee wp_linux_drm_syncobj_surface_v1 for more information.\n\nThis interface has no events."WpLinuxDrmSyncobjManagerV1"destroy explicit synchronization factory object\n\nDestroy this explicit synchronization factory object. Other objects\nshall not be affected by this request."wp_linux_drm_syncobj_surface_v1WpLinuxDrmSyncobjSurfaceV1wp_linux_drm_syncobj_timeline_v1WpLinuxDrmSyncobjTimelineV1import_timelinewp_linux_drm_syncobj_manager_v1"synchronization object timeline\n\nThis object represents an explicit synchronization object timeline\nimported by the client to the compositor.""destroy the timeline\n\nDestroy the synchronization object timeline. Other objects are not\naffected by this request, in particular timeline points set by\nset_acquire_point and set_release_point are not unset.\n\nThis is a destructor, once sent this object cannot be used any longer.""synchronization object timeline\n\nThis object represents an explicit synchronization object timeline\nimported by the client to the compositor.\n\nThis interface has no events.""destroy the timeline\n\nDestroy the synchronization object timeline. Other objects are not\naffected by this request, in particular timeline points set by\nset_acquire_point and set_release_point are not unset.""per-surface explicit synchronization\n\nThis object is an add-on interface for wl_surface to enable explicit\nsynchronization.\n\nEach surface can be associated with only one object of this interface at\nany time.\n\nExplicit synchronization is guaranteed to be supported for buffers\ncreated with any version of the linux-dmabuf protocol. Compositors are\nfree to support explicit synchronization for additional buffer types.\nIf at surface commit time the attached buffer does not support explicit\nsynchronization, an unsupported_buffer error is raised.\n\nAs long as the wp_linux_drm_syncobj_surface_v1 object is alive, the\ncompositor may ignore implicit synchronization for buffers attached and\ncommitted to the wl_surface. The delivery of wl_buffer.release events\nfor buffers attached to the surface becomes undefined.\n\nClients must set both acquire and release points if and only if a\nnon-null buffer is attached in the same surface commit. See the\nno_buffer, no_acquire_point and no_release_point protocol errors.\n\nIf at surface commit time the acquire and release DRM syncobj timelines\nare identical, the acquire point value must be strictly less than the\nrelease point value, or else the conflicting_points protocol error is\nraised.""no acquire timeline point was set"NoAcquirePoint"no release timeline point was set"NoReleasePoint"acquire and release timeline points are in conflict"ConflictingPointsREQ_SET_ACQUIRE_POINT_SINCEREQ_SET_ACQUIRE_POINT_OPCODEREQ_SET_RELEASE_POINT_SINCEREQ_SET_RELEASE_POINT_OPCODE"destroy the surface synchronization object\n\nDestroy this surface synchronization object.\n\nAny timeline point set by this object with set_acquire_point or\nset_release_point since the last commit may be discarded by the\ncompositor. Any timeline point set by this object before the last\ncommit will not be affected.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the acquire timeline point\n\nSet the timeline point that must be signalled before the compositor may\nsample from the buffer attached with wl_surface.attach.\n\nThe 64-bit unsigned value combined from point_hi and point_lo is the\npoint value.\n\nThe acquire point is double-buffered state, and will be applied on the\nnext wl_surface.commit request for the associated surface. Thus, it\napplies only to the buffer that is attached to the surface at commit\ntime.\n\nIf an acquire point has already been attached during the same commit\ncycle, the new point replaces the old one.\n\nIf the associated wl_surface was destroyed, a no_surface error is\nraised.\n\nIf at surface commit time there is a pending acquire timeline point set\nbut no pending buffer attached, a no_buffer error is raised. If at\nsurface commit time there is a pending buffer attached but no pending\nacquire timeline point set, the no_acquire_point protocol error is\nraised."timeline"high 32 bits of the point value"point_hi"low 32 bits of the point value"point_loSetAcquirePoint"set the release timeline point\n\nSet the timeline point that must be signalled by the compositor when it\nhas finished its usage of the buffer attached with wl_surface.attach\nfor the relevant commit.\n\nOnce the timeline point is signaled, and assuming the associated buffer\nis not pending release from other wl_surface.commit requests, no\nadditional explicit or implicit synchronization with the compositor is\nrequired to safely re-use the buffer.\n\nNote that clients cannot rely on the release point being always\nsignaled after the acquire point: compositors may release buffers\nwithout ever reading from them. In addition, the compositor may use\ndifferent presentation paths for different commits, which may have\ndifferent release behavior. As a result, the compositor may signal the\nrelease points in a different order than the client committed them.\n\nBecause signaling a timeline point also signals every previous point,\nit is generally not safe to use the same timeline object for the\nrelease points of multiple buffers. The out-of-order signaling\ndescribed above may lead to a release point being signaled before the\ncompositor has finished reading. To avoid this, it is strongly\nrecommended that each buffer should use a separate timeline for its\nrelease points.\n\nThe 64-bit unsigned value combined from point_hi and point_lo is the\npoint value.\n\nThe release point is double-buffered state, and will be applied on the\nnext wl_surface.commit request for the associated surface. Thus, it\napplies only to the buffer that is attached to the surface at commit\ntime.\n\nIf a release point has already been attached during the same commit\ncycle, the new point replaces the old one.\n\nIf the associated wl_surface was destroyed, a no_surface error is\nraised.\n\nIf at surface commit time there is a pending release timeline point set\nbut no pending buffer attached, a no_buffer error is raised. If at\nsurface commit time there is a pending buffer attached but no pending\nrelease timeline point set, the no_release_point protocol error is\nraised."SetReleasePoint"per-surface explicit synchronization\n\nThis object is an add-on interface for wl_surface to enable explicit\nsynchronization.\n\nEach surface can be associated with only one object of this interface at\nany time.\n\nExplicit synchronization is guaranteed to be supported for buffers\ncreated with any version of the linux-dmabuf protocol. Compositors are\nfree to support explicit synchronization for additional buffer types.\nIf at surface commit time the attached buffer does not support explicit\nsynchronization, an unsupported_buffer error is raised.\n\nAs long as the wp_linux_drm_syncobj_surface_v1 object is alive, the\ncompositor may ignore implicit synchronization for buffers attached and\ncommitted to the wl_surface. The delivery of wl_buffer.release events\nfor buffers attached to the surface becomes undefined.\n\nClients must set both acquire and release points if and only if a\nnon-null buffer is attached in the same surface commit. See the\nno_buffer, no_acquire_point and no_release_point protocol errors.\n\nIf at surface commit time the acquire and release DRM syncobj timelines\nare identical, the acquire point value must be strictly less than the\nrelease point value, or else the conflicting_points protocol error is\nraised.\n\nThis interface has no events.""destroy the surface synchronization object\n\nDestroy this surface synchronization object.\n\nAny timeline point set by this object with set_acquire_point or\nset_release_point since the last commit may be discarded by the\ncompositor. Any timeline point set by this object before the last\ncommit will not be affected."set_acquire_pointset_release_point//! This protocol allows clients to request explicit synchronization for//! buffers. It is tied to the Linux DRM synchronization object framework.//! Synchronization refers to co-ordination of pipelined operations performed//! on buffers. Most GPU clients will schedule an asynchronous operation to//! render to the buffer, then immediately send the buffer to the compositor//! to be attached to a surface.//! With implicit synchronization, ensuring that the rendering operation is//! complete before the compositor displays the buffer is an implementation//! detail handled by either the kernel or userspace graphics driver.//! By contrast, with explicit synchronization, DRM synchronization object//! timeline points mark when the asynchronous operations are complete. When//! submitting a buffer, the client provides a timeline point which will be//! waited on before the compositor accesses the buffer, and another timeline//! point that the compositor will signal when it no longer needs to access the//! buffer contents for the purposes of the surface commit.//! Linux DRM synchronization objects are documented at://! <https://dri.freedesktop.org/docs/drm/gpu/drm-mm.html#drm-sync-objects>linux_drm_syncobjZWP_POINTER_CONSTRAINTS_V1_INTERFACEzwp_pointer_constraints_v1_requests_lock_pointer_typeszwp_pointer_constraints_v1_requests_confine_pointer_typeszwp_pointer_constraints_v1_requestszwp_pointer_constraints_v1_interfaceZWP_LOCKED_POINTER_V1_INTERFACEzwp_locked_pointer_v1_requests_set_region_typeszwp_locked_pointer_v1_requestszwp_locked_pointer_v1_eventszwp_locked_pointer_v1_interfaceZWP_CONFINED_POINTER_V1_INTERFACEzwp_confined_pointer_v1_requests_set_region_typeszwp_confined_pointer_v1_requestszwp_confined_pointer_v1_eventszwp_confined_pointer_v1_interface"constrain the movement of a pointer\n\nThe global interface exposing pointer constraining functionality. It\nexposes two requests: lock_pointer for locking the pointer to its\nposition, and confine_pointer for locking the pointer to a region.\n\nThe lock_pointer and confine_pointer requests create the objects\nwp_locked_pointer and wp_confined_pointer respectively, and the client can\nuse these objects to interact with the lock.\n\nFor any surface, only one lock or confinement may be active across all\nwl_pointer objects of the same seat. If a lock or confinement is requested\nwhen another lock or confinement is active or requested on the same surface\nand with any of the wl_pointer objects of the same seat, an\n'already_constrained' error will be raised.""wp_pointer_constraints error values\n\nThese errors can be emitted in response to wp_pointer_constraints\nrequests.""pointer constraint already requested on that surface"AlreadyConstrained"constraint lifetime\n\nThese values represent different lifetime semantics. They are passed\nas arguments to the factory requests to specify how the constraint\nlifetimes should be managed.""the pointer constraint is defunct once deactivated\n\nA oneshot pointer constraint will never reactivate once it has been\ndeactivated. See the corresponding deactivation event\n(wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) for\ndetails.""the pointer constraint may reactivate\n\nA persistent pointer constraint may again reactivate once it has\nbeen deactivated. See the corresponding deactivation event\n(wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) for\ndetails."PersistentREQ_LOCK_POINTER_SINCEREQ_LOCK_POINTER_OPCODEREQ_CONFINE_POINTER_SINCEREQ_CONFINE_POINTER_OPCODE"destroy the pointer constraints manager object\n\nUsed by the client to notify the server that it will no longer use this\npointer constraints object.\n\nThis is a destructor, once sent this object cannot be used any longer.""lock pointer to a position\n\nThe lock_pointer request lets the client request to disable movements of\nthe virtual pointer (i.e. the cursor), effectively locking the pointer\nto a position. This request may not take effect immediately; in the\nfuture, when the compositor deems implementation-specific constraints\nare satisfied, the pointer lock will be activated and the compositor\nsends a locked event.\n\nThe protocol provides no guarantee that the constraints are ever\nsatisfied, and does not require the compositor to send an error if the\nconstraints cannot ever be satisfied. It is thus possible to request a\nlock that will never activate.\n\nThere may not be another pointer constraint of any kind requested or\nactive on the surface for any of the wl_pointer objects of the seat of\nthe passed pointer when requesting a lock. If there is, an error will be\nraised. See general pointer lock documentation for more details.\n\nThe intersection of the region passed with this request and the input\nregion of the surface is used to determine where the pointer must be\nin order for the lock to activate. It is up to the compositor whether to\nwarp the pointer or require some kind of user interaction for the lock\nto activate. If the region is null the surface input region is used.\n\nA surface may receive pointer focus without the lock being activated.\n\nThe request creates a new object wp_locked_pointer which is used to\ninteract with the lock as well as receive updates about its state. See\nthe the description of wp_locked_pointer for further information.\n\nNote that while a pointer is locked, the wl_pointer objects of the\ncorresponding seat will not emit any wl_pointer.motion events, but\nrelative motion events will still be emitted via wp_relative_pointer\nobjects of the same seat. wl_pointer.axis and wl_pointer.button events\nare unaffected.""surface to lock pointer to""the pointer that should be locked""region of surface""lock lifetime"LockPointer"confine pointer to a region\n\nThe confine_pointer request lets the client request to confine the\npointer cursor to a given region. This request may not take effect\nimmediately; in the future, when the compositor deems implementation-\nspecific constraints are satisfied, the pointer confinement will be\nactivated and the compositor sends a confined event.\n\nThe intersection of the region passed with this request and the input\nregion of the surface is used to determine where the pointer must be\nin order for the confinement to activate. It is up to the compositor\nwhether to warp the pointer or require some kind of user interaction for\nthe confinement to activate. If the region is null the surface input\nregion is used.\n\nThe request will create a new object wp_confined_pointer which is used\nto interact with the confinement as well as receive updates about its\nstate. See the the description of wp_confined_pointer for further\ninformation.""the pointer that should be confined""confinement lifetime"ConfinePointer"constrain the movement of a pointer\n\nThe global interface exposing pointer constraining functionality. It\nexposes two requests: lock_pointer for locking the pointer to its\nposition, and confine_pointer for locking the pointer to a region.\n\nThe lock_pointer and confine_pointer requests create the objects\nwp_locked_pointer and wp_confined_pointer respectively, and the client can\nuse these objects to interact with the lock.\n\nFor any surface, only one lock or confinement may be active across all\nwl_pointer objects of the same seat. If a lock or confinement is requested\nwhen another lock or confinement is active or requested on the same surface\nand with any of the wl_pointer objects of the same seat, an\n'already_constrained' error will be raised.\n\nThis interface has no events.""destroy the pointer constraints manager object\n\nUsed by the client to notify the server that it will no longer use this\npointer constraints object.""receive relative pointer motion events\n\nThe wp_locked_pointer interface represents a locked pointer state.\n\nWhile the lock of this object is active, the wl_pointer objects of the\nassociated seat will not emit any wl_pointer.motion events.\n\nThis object will send the event 'locked' when the lock is activated.\nWhenever the lock is activated, it is guaranteed that the locked surface\nwill already have received pointer focus and that the pointer will be\nwithin the region passed to the request creating this object.\n\nTo unlock the pointer, send the destroy request. This will also destroy\nthe wp_locked_pointer object.\n\nIf the compositor decides to unlock the pointer the unlocked event is\nsent. See wp_locked_pointer.unlock for details.\n\nWhen unlocking, the compositor may warp the cursor position to the set\ncursor position hint. If it does, it will not result in any relative\nmotion events emitted via wp_relative_pointer.\n\nIf the surface the lock was requested on is destroyed and the lock is not\nyet activated, the wp_locked_pointer object is now defunct and must be\ndestroyed."REQ_SET_CURSOR_POSITION_HINT_SINCEREQ_SET_CURSOR_POSITION_HINT_OPCODEREQ_SET_REGION_SINCEREQ_SET_REGION_OPCODEEVT_UNLOCKED_SINCEEVT_UNLOCKED_OPCODE"destroy the locked pointer object\n\nDestroy the locked pointer object. If applicable, the compositor will\nunlock the pointer.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the pointer cursor position hint\n\nSet the cursor position hint relative to the top left corner of the\nsurface.\n\nIf the client is drawing its own cursor, it should update the position\nhint to the position of its own cursor. A compositor may use this\ninformation to warp the pointer upon unlock in order to avoid pointer\njumps.\n\nThe cursor position hint is double-buffered state, see\nwl_surface.commit."SetCursorPositionHint"set a new lock region\n\nSet a new region used to lock the pointer.\n\nThe new lock region is double-buffered, see wl_surface.commit.\n\nFor details about the lock region, see wp_locked_pointer."SetRegion"lock activation event\n\nNotification that the pointer lock of the seat's pointer is activated.""lock deactivation event\n\nNotification that the pointer lock of the seat's pointer is no longer\nactive. If this is a oneshot pointer lock (see\nwp_pointer_constraints.lifetime) this object is now defunct and should\nbe destroyed. If this is a persistent pointer lock (see\nwp_pointer_constraints.lifetime) this pointer lock may again\nreactivate in the future.""receive relative pointer motion events\n\nThe wp_locked_pointer interface represents a locked pointer state.\n\nWhile the lock of this object is active, the wl_pointer objects of the\nassociated seat will not emit any wl_pointer.motion events.\n\nThis object will send the event 'locked' when the lock is activated.\nWhenever the lock is activated, it is guaranteed that the locked surface\nwill already have received pointer focus and that the pointer will be\nwithin the region passed to the request creating this object.\n\nTo unlock the pointer, send the destroy request. This will also destroy\nthe wp_locked_pointer object.\n\nIf the compositor decides to unlock the pointer the unlocked event is\nsent. See wp_locked_pointer.unlock for details.\n\nWhen unlocking, the compositor may warp the cursor position to the set\ncursor position hint. If it does, it will not result in any relative\nmotion events emitted via wp_relative_pointer.\n\nIf the surface the lock was requested on is destroyed and the lock is not\nyet activated, the wp_locked_pointer object is now defunct and must be\ndestroyed.\n\nSee also the [Event] enum for this interface.""destroy the locked pointer object\n\nDestroy the locked pointer object. If applicable, the compositor will\nunlock the pointer."set_cursor_position_hintset_region"confined pointer object\n\nThe wp_confined_pointer interface represents a confined pointer state.\n\nThis object will send the event 'confined' when the confinement is\nactivated. Whenever the confinement is activated, it is guaranteed that\nthe surface the pointer is confined to will already have received pointer\nfocus and that the pointer will be within the region passed to the request\ncreating this object. It is up to the compositor to decide whether this\nrequires some user interaction and if the pointer will warp to within the\npassed region if outside.\n\nTo unconfine the pointer, send the destroy request. This will also destroy\nthe wp_confined_pointer object.\n\nIf the compositor decides to unconfine the pointer the unconfined event is\nsent. The wp_confined_pointer object is at this point defunct and should\nbe destroyed."EVT_CONFINED_SINCEEVT_CONFINED_OPCODEEVT_UNCONFINED_SINCEEVT_UNCONFINED_OPCODE"destroy the confined pointer object\n\nDestroy the confined pointer object. If applicable, the compositor will\nunconfine the pointer.\n\nThis is a destructor, once sent this object cannot be used any longer.""set a new confine region\n\nSet a new region used to confine the pointer.\n\nThe new confine region is double-buffered, see wl_surface.commit.\n\nIf the confinement is active when the new confinement region is applied\nand the pointer ends up outside of newly applied region, the pointer may\nwarped to a position within the new confinement region. If warped, a\nwl_pointer.motion event will be emitted, but no\nwp_relative_pointer.relative_motion event.\n\nThe compositor may also, instead of using the new region, unconfine the\npointer.\n\nFor details about the confine region, see wp_confined_pointer.""pointer confined\n\nNotification that the pointer confinement of the seat's pointer is\nactivated."Confined"pointer unconfined\n\nNotification that the pointer confinement of the seat's pointer is no\nlonger active. If this is a oneshot pointer confinement (see\nwp_pointer_constraints.lifetime) this object is now defunct and should\nbe destroyed. If this is a persistent pointer confinement (see\nwp_pointer_constraints.lifetime) this pointer confinement may again\nreactivate in the future."Unconfined"confined pointer object\n\nThe wp_confined_pointer interface represents a confined pointer state.\n\nThis object will send the event 'confined' when the confinement is\nactivated. Whenever the confinement is activated, it is guaranteed that\nthe surface the pointer is confined to will already have received pointer\nfocus and that the pointer will be within the region passed to the request\ncreating this object. It is up to the compositor to decide whether this\nrequires some user interaction and if the pointer will warp to within the\npassed region if outside.\n\nTo unconfine the pointer, send the destroy request. This will also destroy\nthe wp_confined_pointer object.\n\nIf the compositor decides to unconfine the pointer the unconfined event is\nsent. The wp_confined_pointer object is at this point defunct and should\nbe destroyed.\n\nSee also the [Event] enum for this interface.""destroy the confined pointer object\n\nDestroy the confined pointer object. If applicable, the compositor will\nunconfine the pointer."//! protocol for constraining pointer motions//! This protocol specifies a set of interfaces used for adding constraints to//! the motion of a pointer. Possible constraints include confining pointer//! motions to a given region, or locking it to its current position.//! In order to constrain the pointer, a client must first bind the global//! interface "wp_pointer_constraints" which, if a compositor supports pointer//! constraints, is exposed by the registry. Using the bound global object, the//! client uses the request that corresponds to the type of constraint it wants//! to make. See wp_pointer_constraints for more details.ZWP_POINTER_GESTURES_V1_INTERFACEzwp_pointer_gestures_v1_requests_get_swipe_gesture_typeszwp_pointer_gestures_v1_requests_get_pinch_gesture_typeszwp_pointer_gestures_v1_requests_get_hold_gesture_typeszwp_pointer_gestures_v1_requestszwp_pointer_gestures_v1_interfaceZWP_POINTER_GESTURE_SWIPE_V1_INTERFACEzwp_pointer_gesture_swipe_v1_requestszwp_pointer_gesture_swipe_v1_events_begin_typeszwp_pointer_gesture_swipe_v1_eventszwp_pointer_gesture_swipe_v1_interfaceZWP_POINTER_GESTURE_PINCH_V1_INTERFACEzwp_pointer_gesture_pinch_v1_requestszwp_pointer_gesture_pinch_v1_events_begin_typeszwp_pointer_gesture_pinch_v1_eventszwp_pointer_gesture_pinch_v1_interfaceZWP_POINTER_GESTURE_HOLD_V1_INTERFACEzwp_pointer_gesture_hold_v1_requestszwp_pointer_gesture_hold_v1_events_begin_typeszwp_pointer_gesture_hold_v1_eventszwp_pointer_gesture_hold_v1_interface"touchpad gestures\n\nA global interface to provide semantic touchpad gestures for a given\npointer.\n\nThree gestures are currently supported: swipe, pinch, and hold.\nPinch and swipe gestures follow a three-stage cycle: begin, update,\nend. Hold gestures follow a two-stage cycle: begin and end. All\ngestures are identified by a unique id.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset."REQ_GET_SWIPE_GESTURE_SINCEREQ_GET_SWIPE_GESTURE_OPCODEREQ_GET_PINCH_GESTURE_SINCEREQ_GET_PINCH_GESTURE_OPCODEREQ_GET_HOLD_GESTURE_SINCEREQ_GET_HOLD_GESTURE_OPCODE"get swipe gesture\n\nCreate a swipe gesture object. See the\nwl_pointer_gesture_swipe interface for details."GetSwipeGesture"get pinch gesture\n\nCreate a pinch gesture object. See the\nwl_pointer_gesture_pinch interface for details."GetPinchGesture"destroy the pointer gesture object\n\nDestroy the pointer gesture object. Swipe, pinch and hold objects\ncreated via this gesture object remain valid.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""get hold gesture\n\nCreate a hold gesture object. See the\nwl_pointer_gesture_hold interface for details.\n\nOnly available since version 3 of the interface"GetHoldGesture"touchpad gestures\n\nA global interface to provide semantic touchpad gestures for a given\npointer.\n\nThree gestures are currently supported: swipe, pinch, and hold.\nPinch and swipe gestures follow a three-stage cycle: begin, update,\nend. Hold gestures follow a two-stage cycle: begin and end. All\ngestures are identified by a unique id.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nThis interface has no events."ZwpPointerGesturesV1zwp_pointer_gesture_swipe_v1ZwpPointerGestureSwipeV1get_swipe_gesturezwp_pointer_gesture_pinch_v1ZwpPointerGesturePinchV1get_pinch_gesture"destroy the pointer gesture object\n\nDestroy the pointer gesture object. Swipe, pinch and hold objects\ncreated via this gesture object remain valid.""get hold gesture\n\nCreate a hold gesture object. See the\nwl_pointer_gesture_hold interface for details."zwp_pointer_gesture_hold_v1ZwpPointerGestureHoldV1get_hold_gesturezwp_pointer_gestures_v1"a swipe gesture object\n\nA swipe gesture object notifies a client about a multi-finger swipe\ngesture detected on an indirect input device such as a touchpad.\nThe gesture is usually initiated by multiple fingers moving in the\nsame direction but once initiated the direction may change.\nThe precise conditions of when such a gesture is detected are\nimplementation-dependent.\n\nA gesture consists of three stages: begin, update (optional) and end.\nThere cannot be multiple simultaneous hold, pinch or swipe gestures on a\nsame pointer/seat, how compositors prevent these situations is\nimplementation-dependent.\n\nA gesture may be cancelled by the compositor or the hardware.\nClients should not consider performing permanent or irreversible\nactions until the end of a gesture has been received."EVT_BEGIN_SINCEEVT_BEGIN_OPCODEEVT_UPDATE_SINCEEVT_UPDATE_OPCODEEVT_END_SINCEEVT_END_OPCODE"destroy the pointer swipe gesture object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""multi-finger swipe begin\n\nThis event is sent when a multi-finger swipe gesture is detected\non the device.""number of fingers"fingers"multi-finger swipe motion\n\nThis event is sent when a multi-finger swipe gesture changes the\nposition of the logical center.\n\nThe dx and dy coordinates are relative coordinates of the logical\ncenter of the gesture compared to the previous event.""delta x coordinate in surface coordinate space""delta y coordinate in surface coordinate space""multi-finger swipe end\n\nThis event is sent when a multi-finger swipe gesture ceases to\nbe valid. This may happen when one or more fingers are lifted or\nthe gesture is cancelled.\n\nWhen a gesture is cancelled, the client should undo state changes\ncaused by this gesture. What causes a gesture to be cancelled is\nimplementation-dependent.""1 if the gesture was cancelled, 0 otherwise""a swipe gesture object\n\nA swipe gesture object notifies a client about a multi-finger swipe\ngesture detected on an indirect input device such as a touchpad.\nThe gesture is usually initiated by multiple fingers moving in the\nsame direction but once initiated the direction may change.\nThe precise conditions of when such a gesture is detected are\nimplementation-dependent.\n\nA gesture consists of three stages: begin, update (optional) and end.\nThere cannot be multiple simultaneous hold, pinch or swipe gestures on a\nsame pointer/seat, how compositors prevent these situations is\nimplementation-dependent.\n\nA gesture may be cancelled by the compositor or the hardware.\nClients should not consider performing permanent or irreversible\nactions until the end of a gesture has been received.\n\nSee also the [Event] enum for this interface.""destroy the pointer swipe gesture object""a pinch gesture object\n\nA pinch gesture object notifies a client about a multi-finger pinch\ngesture detected on an indirect input device such as a touchpad.\nThe gesture is usually initiated by multiple fingers moving towards\neach other or away from each other, or by two or more fingers rotating\naround a logical center of gravity. The precise conditions of when\nsuch a gesture is detected are implementation-dependent.\n\nA gesture consists of three stages: begin, update (optional) and end.\nThere cannot be multiple simultaneous hold, pinch or swipe gestures on a\nsame pointer/seat, how compositors prevent these situations is\nimplementation-dependent.\n\nA gesture may be cancelled by the compositor or the hardware.\nClients should not consider performing permanent or irreversible\nactions until the end of a gesture has been received.""destroy the pinch gesture object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""multi-finger pinch begin\n\nThis event is sent when a multi-finger pinch gesture is detected\non the device.""multi-finger pinch motion\n\nThis event is sent when a multi-finger pinch gesture changes the\nposition of the logical center, the rotation or the relative scale.\n\nThe dx and dy coordinates are relative coordinates in the\nsurface coordinate space of the logical center of the gesture.\n\nThe scale factor is an absolute scale compared to the\npointer_gesture_pinch.begin event, e.g. a scale of 2 means the fingers\nare now twice as far apart as on pointer_gesture_pinch.begin.\n\nThe rotation is the relative angle in degrees clockwise compared to the previous\npointer_gesture_pinch.begin or pointer_gesture_pinch.update event.""scale relative to the initial finger position""angle in degrees cw relative to the previous event""multi-finger pinch end\n\nThis event is sent when a multi-finger pinch gesture ceases to\nbe valid. This may happen when one or more fingers are lifted or\nthe gesture is cancelled.\n\nWhen a gesture is cancelled, the client should undo state changes\ncaused by this gesture. What causes a gesture to be cancelled is\nimplementation-dependent.""a pinch gesture object\n\nA pinch gesture object notifies a client about a multi-finger pinch\ngesture detected on an indirect input device such as a touchpad.\nThe gesture is usually initiated by multiple fingers moving towards\neach other or away from each other, or by two or more fingers rotating\naround a logical center of gravity. The precise conditions of when\nsuch a gesture is detected are implementation-dependent.\n\nA gesture consists of three stages: begin, update (optional) and end.\nThere cannot be multiple simultaneous hold, pinch or swipe gestures on a\nsame pointer/seat, how compositors prevent these situations is\nimplementation-dependent.\n\nA gesture may be cancelled by the compositor or the hardware.\nClients should not consider performing permanent or irreversible\nactions until the end of a gesture has been received.\n\nSee also the [Event] enum for this interface.""destroy the pinch gesture object""a hold gesture object\n\nA hold gesture object notifies a client about a single- or\nmulti-finger hold gesture detected on an indirect input device such as\na touchpad. The gesture is usually initiated by one or more fingers\nbeing held down without significant movement. The precise conditions\nof when such a gesture is detected are implementation-dependent.\n\nIn particular, this gesture may be used to cancel kinetic scrolling.\n\nA hold gesture consists of two stages: begin and end. Unlike pinch and\nswipe there is no update stage.\nThere cannot be multiple simultaneous hold, pinch or swipe gestures on a\nsame pointer/seat, how compositors prevent these situations is\nimplementation-dependent.\n\nA gesture may be cancelled by the compositor or the hardware.\nClients should not consider performing permanent or irreversible\nactions until the end of a gesture has been received.""destroy the hold gesture object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""multi-finger hold begin\n\nThis event is sent when a hold gesture is detected on the device.\n\nOnly available since version 3 of the interface""multi-finger hold end\n\nThis event is sent when a hold gesture ceases to\nbe valid. This may happen when the holding fingers are lifted or\nthe gesture is cancelled, for example if the fingers move past an\nimplementation-defined threshold, the finger count changes or the hold\ngesture changes into a different type of gesture.\n\nWhen a gesture is cancelled, the client may need to undo state changes\ncaused by this gesture. What causes a gesture to be cancelled is\nimplementation-dependent.\n\nOnly available since version 3 of the interface""a hold gesture object\n\nA hold gesture object notifies a client about a single- or\nmulti-finger hold gesture detected on an indirect input device such as\na touchpad. The gesture is usually initiated by one or more fingers\nbeing held down without significant movement. The precise conditions\nof when such a gesture is detected are implementation-dependent.\n\nIn particular, this gesture may be used to cancel kinetic scrolling.\n\nA hold gesture consists of two stages: begin and end. Unlike pinch and\nswipe there is no update stage.\nThere cannot be multiple simultaneous hold, pinch or swipe gestures on a\nsame pointer/seat, how compositors prevent these situations is\nimplementation-dependent.\n\nA gesture may be cancelled by the compositor or the hardware.\nClients should not consider performing permanent or irreversible\nactions until the end of a gesture has been received.\n\nSee also the [Event] enum for this interface.""destroy the hold gesture object"//! Pointer gestures protocolpointer_gesturesWP_PRESENTATION_INTERFACEwp_presentation_requests_feedback_typeswp_presentation_requestswp_presentation_eventswp_presentation_interfaceWP_PRESENTATION_FEEDBACK_INTERFACEwp_presentation_feedback_events_sync_output_typeswp_presentation_feedback_eventswp_presentation_feedback_interface"timed presentation related wl_surface requests\n\nThe main feature of this interface is accurate presentation\ntiming feedback to ensure smooth video playback while maintaining\naudio/video synchronization. Some features use the concept of a\npresentation clock, which is defined in the\npresentation.clock_id event.\n\nA content update for a wl_surface is submitted by a\nwl_surface.commit request. Request 'feedback' associates with\nthe wl_surface.commit and provides feedback on the content\nupdate, particularly the final realized presentation time.\n\nWhen the final realized presentation time is available, e.g.\nafter a framebuffer flip completes, the requested\npresentation_feedback.presented events are sent. The final\npresentation time can differ from the compositor's predicted\ndisplay update time and the update's target time, especially\nwhen the compositor misses its target vertical blanking period.""fatal presentation errors\n\nThese fatal protocol errors may be emitted in response to\nillegal presentation requests.""invalid value in tv_nsec"InvalidTimestamp"invalid flag"REQ_FEEDBACK_SINCEREQ_FEEDBACK_OPCODEEVT_CLOCK_ID_SINCEEVT_CLOCK_ID_OPCODE"unbind from the presentation interface\n\nInforms the server that the client will no longer be using\nthis protocol object. Existing objects created by this object\nare not affected.\n\nThis is a destructor, once sent this object cannot be used any longer.""request presentation feedback information\n\nRequest presentation feedback for the current content submission\non the given surface. This creates a new presentation_feedback\nobject, which will deliver the feedback information once. If\nmultiple presentation_feedback objects are created for the same\nsubmission, they will all deliver the same information.\n\nFor details on what information is returned, see the\npresentation_feedback interface.""target surface""clock ID for timestamps\n\nThis event tells the client in which clock domain the\ncompositor interprets the timestamps used by the presentation\nextension. This clock is called the presentation clock.\n\nThe compositor sends this event when the client binds to the\npresentation interface. The presentation clock does not change\nduring the lifetime of the client connection.\n\nThe clock identifier is platform dependent. On POSIX platforms, the\nidentifier value is one of the clockid_t values accepted by\nclock_gettime(). clock_gettime() is defined by POSIX.1-2001.\n\nTimestamps in this clock domain are expressed as tv_sec_hi,\ntv_sec_lo, tv_nsec triples, each component being an unsigned\n32-bit value. Whole seconds are in tv_sec which is a 64-bit\nvalue combined from tv_sec_hi and tv_sec_lo, and the\nadditional fractional part in tv_nsec as nanoseconds. Hence,\nfor valid timestamps tv_nsec must be in [0, 999999999].\n\nNote that clock_id applies only to the presentation clock,\nand implies nothing about e.g. the timestamps used in the\nWayland core protocol input events.\n\nCompositors should prefer a clock which does not jump and is\nnot slewed e.g. by NTP. The absolute value of the clock is\nirrelevant. Precision of one millisecond or better is\nrecommended. Clients must be able to query the current clock\nvalue directly, not by asking the compositor.""platform clock identifier""timed presentation related wl_surface requests\n\nThe main feature of this interface is accurate presentation\ntiming feedback to ensure smooth video playback while maintaining\naudio/video synchronization. Some features use the concept of a\npresentation clock, which is defined in the\npresentation.clock_id event.\n\nA content update for a wl_surface is submitted by a\nwl_surface.commit request. Request 'feedback' associates with\nthe wl_surface.commit and provides feedback on the content\nupdate, particularly the final realized presentation time.\n\nWhen the final realized presentation time is available, e.g.\nafter a framebuffer flip completes, the requested\npresentation_feedback.presented events are sent. The final\npresentation time can differ from the compositor's predicted\ndisplay update time and the update's target time, especially\nwhen the compositor misses its target vertical blanking period.\n\nSee also the [Event] enum for this interface.""unbind from the presentation interface\n\nInforms the server that the client will no longer be using\nthis protocol object. Existing objects created by this object\nare not affected.""presentation time feedback event\n\nA presentation_feedback object returns an indication that a\nwl_surface content update has become visible to the user.\nOne object corresponds to one content update submission\n(wl_surface.commit). There are two possible outcomes: the\ncontent update is presented to the user, and a presentation\ntimestamp delivered; or, the user did not see the content\nupdate because it was superseded or its surface destroyed,\nand the content update is discarded.\n\nOnce a presentation_feedback object has delivered a 'presented'\nor 'discarded' event it is automatically destroyed.""bitmask of flags in presented event\n\nThese flags provide information about how the presentation of\nthe related content update was done. The intent is to help\nclients assess the reliability of the feedback and the visual\nquality with respect to possible tearing and timings.""presentation was vsync'd\n\nThe presentation was synchronized to the \"vertical retrace\" by\nthe display hardware such that tearing does not happen.\nRelying on software scheduling is not acceptable for this\nflag. If presentation is done by a copy to the active\nfrontbuffer, then it must guarantee that tearing cannot\nhappen.""hardware provided the presentation timestamp\n\nThe display hardware provided measurements that the hardware\ndriver converted into a presentation timestamp. Sampling a\nclock in software is not acceptable for this flag."HwClock"hardware signalled the start of the presentation\n\nThe display hardware signalled that it started using the new\nimage content. The opposite of this is e.g. a timer being used\nto guess when the display hardware has switched to the new\nimage content."HwCompletion"presentation was done zero-copy\n\nThe presentation of this update was done zero-copy. This means\nthe buffer from the client was given to display hardware as\nis, without copying it. Compositing with OpenGL counts as\ncopying, even if textured directly from the client buffer.\nPossible zero-copy cases include direct scanout of a\nfullscreen surface and a surface on a hardware overlay."ZeroCopyEVT_SYNC_OUTPUT_SINCEEVT_SYNC_OUTPUT_OPCODEEVT_PRESENTED_SINCEEVT_PRESENTED_OPCODEEVT_DISCARDED_SINCEEVT_DISCARDED_OPCODE"presentation synchronized to this output\n\nAs presentation can be synchronized to only one output at a\ntime, this event tells which output it was. This event is only\nsent prior to the presented event.\n\nAs clients may bind to the same global wl_output multiple\ntimes, this event is sent for each bound instance that matches\nthe synchronized output. If a client has not bound to the\nright wl_output global at all, this event is not sent.""presentation output"SyncOutput"the content update was displayed\n\nThe associated content update was displayed to the user at the\nindicated time (tv_sec_hi/lo, tv_nsec). For the interpretation of\nthe timestamp, see presentation.clock_id event.\n\nThe timestamp corresponds to the time when the content update\nturned into light the first time on the surface's main output.\nCompositors may approximate this from the framebuffer flip\ncompletion events from the system, and the latency of the\nphysical display path if known.\n\nThis event is preceded by all related sync_output events\ntelling which output's refresh cycle the feedback corresponds\nto, i.e. the main output for the surface. Compositors are\nrecommended to choose the output containing the largest part\nof the wl_surface, or keeping the output they previously\nchose. Having a stable presentation output association helps\nclients predict future output refreshes (vblank).\n\nThe 'refresh' argument gives the compositor's prediction of how\nmany nanoseconds after tv_sec, tv_nsec the very next output\nrefresh may occur. This is to further aid clients in\npredicting future refreshes, i.e., estimating the timestamps\ntargeting the next few vblanks. If such prediction cannot\nusefully be done, the argument is zero.\n\nFor version 2 and later, if the output does not have a constant\nrefresh rate, explicit video mode switches excluded, then the\nrefresh argument must be either an appropriate rate picked by the\ncompositor (e.g. fastest rate), or 0 if no such rate exists.\nFor version 1, if the output does not have a constant refresh rate,\nthe refresh argument must be zero.\n\nThe 64-bit value combined from seq_hi and seq_lo is the value\nof the output's vertical retrace counter when the content\nupdate was first scanned out to the display. This value must\nbe compatible with the definition of MSC in\nGLX_OML_sync_control specification. Note, that if the display\npath has a non-zero latency, the time instant specified by\nthis counter may differ from the timestamp's.\n\nIf the output does not have a concept of vertical retrace or a\nrefresh cycle, or the output device is self-refreshing without\na way to query the refresh count, then the arguments seq_hi\nand seq_lo must be zero.\n\nThis is a destructor, once received this object cannot be used any longer.""high 32 bits of the seconds part of the presentation timestamp""low 32 bits of the seconds part of the presentation timestamp""nanoseconds part of the presentation timestamp""nanoseconds till next refresh""high 32 bits of refresh counter"seq_hi"low 32 bits of refresh counter"seq_lo"combination of 'kind' values""the content update was not displayed\n\nThe content update was never displayed to the user.\n\nThis is a destructor, once received this object cannot be used any longer."Discarded"presentation time feedback event\n\nA presentation_feedback object returns an indication that a\nwl_surface content update has become visible to the user.\nOne object corresponds to one content update submission\n(wl_surface.commit). There are two possible outcomes: the\ncontent update is presented to the user, and a presentation\ntimestamp delivered; or, the user did not see the content\nupdate because it was superseded or its surface destroyed,\nand the content update is discarded.\n\nOnce a presentation_feedback object has delivered a 'presented'\nor 'discarded' event it is automatically destroyed.\n\nSee also the [Event] enum for this interface."//! Presentation time protocol//! Allows precise feedback on presentation timing, for example for smooth video playback.ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_INTERFACEzwp_primary_selection_device_manager_v1_requests_create_source_typeszwp_primary_selection_device_manager_v1_requests_get_device_typeszwp_primary_selection_device_manager_v1_requestszwp_primary_selection_device_manager_v1_interfaceZWP_PRIMARY_SELECTION_DEVICE_V1_INTERFACEzwp_primary_selection_device_v1_requests_set_selection_typeszwp_primary_selection_device_v1_requestszwp_primary_selection_device_v1_events_data_offer_typeszwp_primary_selection_device_v1_events_selection_typeszwp_primary_selection_device_v1_eventszwp_primary_selection_device_v1_interfaceZWP_PRIMARY_SELECTION_OFFER_V1_INTERFACEzwp_primary_selection_offer_v1_requestszwp_primary_selection_offer_v1_eventszwp_primary_selection_offer_v1_interfaceZWP_PRIMARY_SELECTION_SOURCE_V1_INTERFACEzwp_primary_selection_source_v1_requestszwp_primary_selection_source_v1_eventszwp_primary_selection_source_v1_interface"X primary selection emulation\n\nThe primary selection device manager is a singleton global object that\nprovides access to the primary selection. It allows to create\nwp_primary_selection_source objects, as well as retrieving the per-seat\nwp_primary_selection_device objects."REQ_GET_DEVICE_SINCEREQ_GET_DEVICE_OPCODE"create a new primary selection source\n\nCreate a new primary selection source.""create a new primary selection device\n\nCreate a new data device for a given seat."GetDevice"destroy the primary selection device manager\n\nDestroy the primary selection device manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""X primary selection emulation\n\nThe primary selection device manager is a singleton global object that\nprovides access to the primary selection. It allows to create\nwp_primary_selection_source objects, as well as retrieving the per-seat\nwp_primary_selection_device objects.\n\nThis interface has no events.""destroy the primary selection device manager\n\nDestroy the primary selection device manager.""set the primary selection\n\nReplaces the current selection. The previous owner of the primary\nselection will receive a wp_primary_selection_source.cancelled event.\n\nTo unset the selection, set the source to NULL.""serial of the event that triggered this request""destroy the primary selection device\n\nDestroy the primary selection device.\n\nThis is a destructor, once sent this object cannot be used any longer.""introduce a new wp_primary_selection_offer\n\nIntroduces a new wp_primary_selection_offer object that may be used\nto receive the current primary selection. Immediately following this\nevent, the new wp_primary_selection_offer object will send\nwp_primary_selection_offer.offer events to describe the offered mime\ntypes.""advertise a new primary selection\n\nThe wp_primary_selection_device.selection event is sent to notify the\nclient of a new primary selection. This event is sent after the\nwp_primary_selection.data_offer event introducing this object, and after\nthe offer has announced its mimetypes through\nwp_primary_selection_offer.offer.\n\nThe data_offer is valid until a new offer or NULL is received\nor until the client loses keyboard focus. The client must destroy the\nprevious selection data_offer, if any, upon receiving this event.""zwp_primary_selection_device_v1\n\nSee also the [Event] enum for this interface.""destroy the primary selection device\n\nDestroy the primary selection device.""offer to transfer primary selection contents\n\nA wp_primary_selection_offer represents an offer to transfer the contents\nof the primary selection clipboard to the client. Similar to\nwl_data_offer, the offer also describes the mime types that the data can\nbe converted to and provides the mechanisms for transferring the data\ndirectly to the client.""request that the data is transferred\n\nTo transfer the contents of the primary selection clipboard, the client\nissues this request and indicates the mime type that it wants to\nreceive. The transfer happens through the passed file descriptor\n(typically created with the pipe system call). The source client writes\nthe data in the mime type representation requested and then closes the\nfile descriptor.\n\nThe receiving client reads from the read end of the pipe until EOF and\ncloses its end, at which point the transfer is complete.""destroy the primary selection offer\n\nDestroy the primary selection offer.\n\nThis is a destructor, once sent this object cannot be used any longer.""advertise offered mime type\n\nSent immediately after creating announcing the\nwp_primary_selection_offer through\nwp_primary_selection_device.data_offer. One event is sent per offered\nmime type.""offer to transfer primary selection contents\n\nA wp_primary_selection_offer represents an offer to transfer the contents\nof the primary selection clipboard to the client. Similar to\nwl_data_offer, the offer also describes the mime types that the data can\nbe converted to and provides the mechanisms for transferring the data\ndirectly to the client.\n\nSee also the [Event] enum for this interface.""destroy the primary selection offer\n\nDestroy the primary selection offer.""offer to replace the contents of the primary selection\n\nThe source side of a wp_primary_selection_offer, it provides a way to\ndescribe the offered data and respond to requests to transfer the\nrequested contents of the primary selection clipboard.""add an offered mime type\n\nThis request adds a mime type to the set of mime types advertised to\ntargets. Can be called several times to offer multiple types.""destroy the primary selection source\n\nDestroy the primary selection source.\n\nThis is a destructor, once sent this object cannot be used any longer.""send the primary selection contents\n\nRequest for the current primary selection contents from the client.\nSend the specified mime type over the passed file descriptor, then\nclose it.""request for primary selection contents was canceled\n\nThis primary selection source is no longer valid. The client should\nclean up and destroy this primary selection source.""offer to replace the contents of the primary selection\n\nThe source side of a wp_primary_selection_offer, it provides a way to\ndescribe the offered data and respond to requests to transfer the\nrequested contents of the primary selection clipboard.\n\nSee also the [Event] enum for this interface.""destroy the primary selection source\n\nDestroy the primary selection source."//! Primary selection protocolZWP_RELATIVE_POINTER_MANAGER_V1_INTERFACEzwp_relative_pointer_manager_v1_requests_get_relative_pointer_typeszwp_relative_pointer_manager_v1_requestszwp_relative_pointer_manager_v1_interfaceZWP_RELATIVE_POINTER_V1_INTERFACEzwp_relative_pointer_v1_requestszwp_relative_pointer_v1_eventszwp_relative_pointer_v1_interface"get relative pointer objects\n\nA global interface used for getting the relative pointer object for a\ngiven pointer."REQ_GET_RELATIVE_POINTER_SINCEREQ_GET_RELATIVE_POINTER_OPCODE"destroy the relative pointer manager object\n\nUsed by the client to notify the server that it will no longer use this\nrelative pointer manager object.\n\nThis is a destructor, once sent this object cannot be used any longer.""get a relative pointer object\n\nCreate a relative pointer interface given a wl_pointer object. See the\nwp_relative_pointer interface for more details."GetRelativePointer"get relative pointer objects\n\nA global interface used for getting the relative pointer object for a\ngiven pointer.\n\nThis interface has no events.""destroy the relative pointer manager object\n\nUsed by the client to notify the server that it will no longer use this\nrelative pointer manager object.""relative pointer object\n\nA wp_relative_pointer object is an extension to the wl_pointer interface\nused for emitting relative pointer events. It shares the same focus as\nwl_pointer objects of the same seat and will only emit events when it has\nfocus."EVT_RELATIVE_MOTION_SINCEEVT_RELATIVE_MOTION_OPCODE"release the relative pointer object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""relative pointer motion\n\nRelative x/y pointer motion from the pointer of the seat associated with\nthis object.\n\nA relative motion is in the same dimension as regular wl_pointer motion\nevents, except they do not represent an absolute position. For example,\nmoving a pointer from (x, y) to (x', y') would have the equivalent\nrelative motion (x' - x, y' - y). If a pointer motion caused the\nabsolute pointer position to be clipped by for example the edge of the\nmonitor, the relative motion is unaffected by the clipping and will\nrepresent the unclipped motion.\n\nThis event also contains non-accelerated motion deltas. The\nnon-accelerated delta is, when applicable, the regular pointer motion\ndelta as it was before having applied motion acceleration and other\ntransformations such as normalization.\n\nNote that the non-accelerated delta does not represent 'raw' events as\nthey were read from some device. Pointer motion acceleration is device-\nand configuration-specific and non-accelerated deltas and accelerated\ndeltas may have the same value on some devices.\n\nRelative motions are not coupled to wl_pointer.motion events, and can be\nsent in combination with such events, but also independently. There may\nalso be scenarios where wl_pointer.motion is sent, but there is no\nrelative motion. The order of an absolute and relative motion event\noriginating from the same physical motion is not guaranteed.\n\nIf the client needs button events or focus state, it can receive them\nfrom a wl_pointer object of the same seat that the wp_relative_pointer\nobject is associated with.""high 32 bits of a 64 bit timestamp with microsecond granularity"utime_hi"low 32 bits of a 64 bit timestamp with microsecond granularity"utime_lo"the x component of the motion vector""the y component of the motion vector""the x component of the unaccelerated motion vector"dx_unaccel"the y component of the unaccelerated motion vector"dy_unaccelRelativeMotion"relative pointer object\n\nA wp_relative_pointer object is an extension to the wl_pointer interface\nused for emitting relative pointer events. It shares the same focus as\nwl_pointer objects of the same seat and will only emit events when it has\nfocus.\n\nSee also the [Event] enum for this interface.""release the relative pointer object"//! protocol for relative pointer motion events//! This protocol specifies a set of interfaces used for making clients able to//! receive relative pointer events not obstructed by barriers (such as the//! monitor edge or other pointer barriers).//! To start receiving relative pointer events, a client must first bind the//! global interface "wp_relative_pointer_manager" which, if a compositor//! supports relative pointer motion events, is exposed by the registry. After//! having created the relative pointer manager proxy object, the client uses//! it to create the actual relative pointer object using the//! "get_relative_pointer" request given a wl_pointer. The relative pointer//! motion events will then, when applicable, be transmitted via the proxy of//! the newly created relative pointer object. See the documentation of the//! relative pointer interface for more details.WP_SINGLE_PIXEL_BUFFER_MANAGER_V1_INTERFACEwp_single_pixel_buffer_manager_v1_requests_create_u32_rgba_buffer_typeswp_single_pixel_buffer_manager_v1_requestswp_single_pixel_buffer_manager_v1_interface"global factory for single-pixel buffers\n\nThe wp_single_pixel_buffer_manager_v1 interface is a factory for\nsingle-pixel buffers."REQ_CREATE_U32_RGBA_BUFFER_SINCEREQ_CREATE_U32_RGBA_BUFFER_OPCODE"destroy the manager\n\nDestroy the wp_single_pixel_buffer_manager_v1 object.\n\nThe child objects created via this interface are unaffected.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a 1×1 buffer from 32-bit RGBA values\n\nCreate a single-pixel buffer from four 32-bit RGBA values.\n\nUnless specified in another protocol extension, the RGBA values use\npre-multiplied alpha.\n\nThe width and height of the buffer are 1.\n\nThe r, g, b and a arguments valid range is from UINT32_MIN (0)\nto UINT32_MAX (0xffffffff).\n\nThese arguments should be interpreted as a percentage, i.e.\n- UINT32_MIN = 0% of the given color component\n- UINT32_MAX = 100% of the given color component""value of the buffer's red channel""value of the buffer's green channel""value of the buffer's blue channel""value of the buffer's alpha channel"CreateU32RgbaBuffer"global factory for single-pixel buffers\n\nThe wp_single_pixel_buffer_manager_v1 interface is a factory for\nsingle-pixel buffers.\n\nThis interface has no events."WpSinglePixelBufferManagerV1"destroy the manager\n\nDestroy the wp_single_pixel_buffer_manager_v1 object.\n\nThe child objects created via this interface are unaffected."create_u32_rgba_bufferwp_single_pixel_buffer_manager_v1//! This protocol extension allows clients to create single-pixel buffers.//! Compositors supporting this protocol extension should also support the//! viewporter protocol extension. Clients may use viewporter to scale a//! single-pixel buffer to a desired size.single_pixel_bufferzv2WP_CURSOR_SHAPE_MANAGER_V1_INTERFACEwp_cursor_shape_manager_v1_requests_get_pointer_typeswp_cursor_shape_manager_v1_requests_get_tablet_tool_v2_typeswp_cursor_shape_manager_v1_requestswp_cursor_shape_manager_v1_interfaceWP_CURSOR_SHAPE_DEVICE_V1_INTERFACEwp_cursor_shape_device_v1_requestswp_cursor_shape_device_v1_interface"cursor shape manager\n\nThis global offers an alternative, optional way to set cursor images. This\nnew way uses enumerated cursors instead of a wl_surface like\nwl_pointer.set_cursor does.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension."REQ_GET_TABLET_TOOL_V2_SINCEREQ_GET_TABLET_TOOL_V2_OPCODE"destroy the manager\n\nDestroy the cursor shape manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""manage the cursor shape of a pointer device\n\nObtain a wp_cursor_shape_device_v1 for a wl_pointer object.\n\nWhen the pointer capability is removed from the wl_seat, the\nwp_cursor_shape_device_v1 object becomes inert.""manage the cursor shape of a tablet tool device\n\nObtain a wp_cursor_shape_device_v1 for a zwp_tablet_tool_v2 object.\n\nWhen the zwp_tablet_tool_v2 is removed, the wp_cursor_shape_device_v1\nobject becomes inert."tablet_toolzwp_tablet_tool_v2ZwpTabletToolV2GetTabletToolV2"cursor shape manager\n\nThis global offers an alternative, optional way to set cursor images. This\nnew way uses enumerated cursors instead of a wl_surface like\nwl_pointer.set_cursor does.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events.""destroy the manager\n\nDestroy the cursor shape manager."get_tablet_tool_v2"cursor shape for a device\n\nThis interface allows clients to set the cursor shape.""cursor shapes\n\nThis enum describes cursor shapes.\n\nThe names are taken from the CSS W3C specification:\nhttps://w3c.github.io/csswg-drafts/css-ui/#cursor\nwith a few additions.\n\nNote that there are some groups of cursor shapes that are related:\nThe first group is drag-and-drop cursors which are used to indicate\nthe selected action during dnd operations. The second group is resize\ncursors which are used to indicate resizing and moving possibilities\non window borders. It is recommended that the shapes in these groups\nshould use visually compatible images and metaphors.""default cursor""a context menu is available for the object under the cursor""help is available for the object under the cursor""pointer that indicates a link or another interactive element""progress indicator""program is busy, user should wait""a cell or set of cells may be selected""simple crosshair""text may be selected""vertical text may be selected""drag-and-drop: alias of/shortcut to something is to be created""drag-and-drop: something is to be copied""drag-and-drop: something is to be moved""drag-and-drop: the dragged item cannot be dropped at the current cursor location""drag-and-drop: the requested action will not be carried out""drag-and-drop: something can be grabbed""drag-and-drop: something is being grabbed""resizing: the east border is to be moved""resizing: the north border is to be moved""resizing: the north-east corner is to be moved""resizing: the north-west corner is to be moved""resizing: the south border is to be moved""resizing: the south-east corner is to be moved""resizing: the south-west corner is to be moved""resizing: the west border is to be moved""resizing: the east and west borders are to be moved""resizing: the north and south borders are to be moved""resizing: the north-east and south-west corners are to be moved""resizing: the north-west and south-east corners are to be moved""resizing: that the item/column can be resized horizontally""resizing: that the item/row can be resized vertically""something can be scrolled in any direction""something can be zoomed in""something can be zoomed out""drag-and-drop: the user will select which action will be carried out (non-css value)""resizing: something can be moved or resized in any direction (non-css value)""the specified shape value is invalid"InvalidShapeREQ_SET_SHAPE_SINCEREQ_SET_SHAPE_OPCODE"destroy the cursor shape device\n\nDestroy the cursor shape device.\n\nThe device cursor shape remains unchanged.\n\nThis is a destructor, once sent this object cannot be used any longer.""set device cursor to the shape\n\nSets the device cursor to the specified shape. The compositor will\nchange the cursor image based on the specified shape.\n\nThe cursor actually changes only if the input device focus is one of\nthe requesting client's surfaces. If any, the previous cursor image\n(surface or shape) is replaced.\n\nThe \"shape\" argument must be a valid enum entry, otherwise the\ninvalid_shape protocol error is raised.\n\nThis is similar to the wl_pointer.set_cursor and\nzwp_tablet_tool_v2.set_cursor requests, but this request accepts a\nshape instead of contents in the form of a surface. Clients can mix\nset_cursor and set_shape requests.\n\nThe serial parameter must match the latest wl_pointer.enter or\nzwp_tablet_tool_v2.proximity_in serial number sent to the client.\nOtherwise the request will be ignored."SetShape"cursor shape for a device\n\nThis interface allows clients to set the cursor shape.\n\nThis interface has no events.""destroy the cursor shape device\n\nDestroy the cursor shape device.\n\nThe device cursor shape remains unchanged."set_shape//! This protocol extension offers a simpler way for clients to set a cursor.ZWP_TABLET_MANAGER_V1_INTERFACEzwp_tablet_manager_v1_requests_get_tablet_seat_typeszwp_tablet_manager_v1_requestszwp_tablet_manager_v1_interfaceZWP_TABLET_SEAT_V1_INTERFACEzwp_tablet_seat_v1_requestszwp_tablet_seat_v1_events_tablet_added_typeszwp_tablet_seat_v1_events_tool_added_typeszwp_tablet_seat_v1_eventszwp_tablet_seat_v1_interfaceZWP_TABLET_TOOL_V1_INTERFACEzwp_tablet_tool_v1_requests_set_cursor_typeszwp_tablet_tool_v1_requestszwp_tablet_tool_v1_events_proximity_in_typeszwp_tablet_tool_v1_eventszwp_tablet_tool_v1_interfaceZWP_TABLET_V1_INTERFACEzwp_tablet_v1_requestszwp_tablet_v1_eventszwp_tablet_v1_interface"controller object for graphic tablet devices\n\nAn object that provides access to the graphics tablets available on this\nsystem. All tablets are associated with a seat, to get access to the\nactual tablets, use wp_tablet_manager.get_tablet_seat."REQ_GET_TABLET_SEAT_SINCEREQ_GET_TABLET_SEAT_OPCODE"get the tablet seat\n\nGet the wp_tablet_seat object for the given seat. This object\nprovides access to all graphics tablets in this seat.""The wl_seat object to retrieve the tablets for"GetTabletSeat"release the memory for the tablet manager object\n\nDestroy the wp_tablet_manager object. Objects created from this\nobject are unaffected and should be destroyed separately.\n\nThis is a destructor, once sent this object cannot be used any longer.""controller object for graphic tablet devices\n\nAn object that provides access to the graphics tablets available on this\nsystem. All tablets are associated with a seat, to get access to the\nactual tablets, use wp_tablet_manager.get_tablet_seat.\n\nThis interface has no events."ZwpTabletManagerV1zwp_tablet_seat_v1ZwpTabletSeatV1get_tablet_seat"release the memory for the tablet manager object\n\nDestroy the wp_tablet_manager object. Objects created from this\nobject are unaffected and should be destroyed separately."zwp_tablet_manager_v1"controller object for graphic tablet devices of a seat\n\nAn object that provides access to the graphics tablets available on this\nseat. After binding to this interface, the compositor sends a set of\nwp_tablet_seat.tablet_added and wp_tablet_seat.tool_added events."EVT_TABLET_ADDED_SINCEEVT_TABLET_ADDED_OPCODEEVT_TOOL_ADDED_SINCEEVT_TOOL_ADDED_OPCODE"release the memory for the tablet seat object\n\nDestroy the wp_tablet_seat object. Objects created from this\nobject are unaffected and should be destroyed separately.\n\nThis is a destructor, once sent this object cannot be used any longer.""new device notification\n\nThis event is sent whenever a new tablet becomes available on this\nseat. This event only provides the object id of the tablet, any\nstatic information about the tablet (device name, vid/pid, etc.) is\nsent through the wp_tablet interface.""the newly added graphics tablet"zwp_tablet_v1ZwpTabletV1TabletAdded"a new tool has been used with a tablet\n\nThis event is sent whenever a tool that has not previously been used\nwith a tablet comes into use. This event only provides the object id\nof the tool; any static information about the tool (capabilities,\ntype, etc.) is sent through the wp_tablet_tool interface.""the newly added tablet tool"zwp_tablet_tool_v1ZwpTabletToolV1ToolAdded"controller object for graphic tablet devices of a seat\n\nAn object that provides access to the graphics tablets available on this\nseat. After binding to this interface, the compositor sends a set of\nwp_tablet_seat.tablet_added and wp_tablet_seat.tool_added events.\n\nSee also the [Event] enum for this interface.""release the memory for the tablet seat object\n\nDestroy the wp_tablet_seat object. Objects created from this\nobject are unaffected and should be destroyed separately.""a physical tablet tool\n\nAn object that represents a physical tool that has been, or is\ncurrently in use with a tablet in this seat. Each wp_tablet_tool\nobject stays valid until the client destroys it; the compositor\nreuses the wp_tablet_tool object to indicate that the object's\nrespective physical tool has come into proximity of a tablet again.\n\nA wp_tablet_tool object's relation to a physical tool depends on the\ntablet's ability to report serial numbers. If the tablet supports\nthis capability, then the object represents a specific physical tool\nand can be identified even when used on multiple tablets.\n\nA tablet tool has a number of static characteristics, e.g. tool type,\nhardware_serial and capabilities. These capabilities are sent in an\nevent sequence after the wp_tablet_seat.tool_added event before any\nactual events from this tool. This initial event sequence is\nterminated by a wp_tablet_tool.done event.\n\nTablet tool events are grouped by wp_tablet_tool.frame events.\nAny events received before a wp_tablet_tool.frame event should be\nconsidered part of the same hardware state change.""a physical tool type\n\nDescribes the physical type of a tool. The physical type of a tool\ngenerally defines its base usage.\n\nThe mouse tool represents a mouse-shaped tool that is not a relative\ndevice but bound to the tablet's surface, providing absolute\ncoordinates.\n\nThe lens tool is a mouse-shaped tool with an attached lens to\nprovide precision focus.""Pen""Eraser""Brush""Pencil""Airbrush""Finger""Mouse""Lens""capability flags for a tool\n\nDescribes extra capabilities on a tablet.\n\nAny tool must provide x and y values, extra axes are\ndevice-specific.""Tilt axes""Pressure axis""Distance axis""Z-rotation axis""Slider axis""Wheel axis""physical button state\n\nDescribes the physical state of a button that produced the button event.""button is not pressed""button is pressed"EVT_TYPE_SINCEEVT_TYPE_OPCODEEVT_HARDWARE_SERIAL_SINCEEVT_HARDWARE_SERIAL_OPCODEEVT_HARDWARE_ID_WACOM_SINCEEVT_HARDWARE_ID_WACOM_OPCODEEVT_PROXIMITY_IN_SINCEEVT_PROXIMITY_IN_OPCODEEVT_PROXIMITY_OUT_SINCEEVT_PROXIMITY_OUT_OPCODEEVT_PRESSURE_SINCEEVT_PRESSURE_OPCODEEVT_DISTANCE_SINCEEVT_DISTANCE_OPCODEEVT_TILT_SINCEEVT_TILT_OPCODEEVT_ROTATION_SINCEEVT_ROTATION_OPCODEEVT_SLIDER_SINCEEVT_SLIDER_OPCODEEVT_WHEEL_SINCEEVT_WHEEL_OPCODE"set the tablet tool's surface\n\nSets the surface of the cursor used for this tool on the given\ntablet. This request only takes effect if the tool is in proximity\nof one of the requesting client's surfaces or the surface parameter\nis the current pointer surface. If there was a previous surface set\nwith this request it is replaced. If surface is NULL, the cursor\nimage is hidden.\n\nThe parameters hotspot_x and hotspot_y define the position of the\npointer surface relative to the pointer location. Its top-left corner\nis always at (x, y) - (hotspot_x, hotspot_y), where (x, y) are the\ncoordinates of the pointer location, in surface-local coordinates.\n\nOn surface.attach requests to the pointer surface, hotspot_x and\nhotspot_y are decremented by the x and y parameters passed to the\nrequest. Attach must be confirmed by wl_surface.commit as usual.\n\nThe hotspot can also be updated by passing the currently set pointer\nsurface to this request with new values for hotspot_x and hotspot_y.\n\nThe current and pending input regions of the wl_surface are cleared,\nand wl_surface.set_input_region is ignored until the wl_surface is no\nlonger used as the cursor. When the use as a cursor ends, the current\nand pending input regions become undefined, and the wl_surface is\nunmapped.\n\nThis request gives the surface the role of a cursor. The role\nassigned by this request is the same as assigned by\nwl_pointer.set_cursor meaning the same surface can be\nused both as a wl_pointer cursor and a wp_tablet cursor. If the\nsurface already has another role, it raises a protocol error.\nThe surface may be used on multiple tablets and across multiple\nseats.""serial of the enter event""destroy the tool object\n\nThis destroys the client's resource for this tool object.\n\nThis is a destructor, once sent this object cannot be used any longer.""tool type\n\nThe tool type is the high-level type of the tool and usually decides\nthe interaction expected from this tool.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_tool.done event.""the physical tool type""unique hardware serial number of the tool\n\nIf the physical tool can be identified by a unique 64-bit serial\nnumber, this event notifies the client of this serial number.\n\nIf multiple tablets are available in the same seat and the tool is\nuniquely identifiable by the serial number, that tool may move\nbetween tablets.\n\nOtherwise, if the tool has no serial number and this event is\nmissing, the tool is tied to the tablet it first comes into\nproximity with. Even if the physical tool is used on multiple\ntablets, separate wp_tablet_tool objects will be created, one per\ntablet.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_tool.done event.""the unique serial number of the tool, most significant bits"hardware_serial_hi"the unique serial number of the tool, least significant bits"hardware_serial_loHardwareSerial"hardware id notification in Wacom's format\n\nThis event notifies the client of a hardware id available on this tool.\n\nThe hardware id is a device-specific 64-bit id that provides extra\ninformation about the tool in use, beyond the wl_tool.type\nenumeration. The format of the id is specific to tablets made by\nWacom Inc. For example, the hardware id of a Wacom Grip\nPen (a stylus) is 0x802.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_tool.done event.""the hardware id, most significant bits"hardware_id_hi"the hardware id, least significant bits"hardware_id_loHardwareIdWacom"tool capability notification\n\nThis event notifies the client of any capabilities of this tool,\nbeyond the main set of x/y axes and tip up/down detection.\n\nOne event is sent for each extra capability available on this tool.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_tool.done event.""the capability""tool description events sequence complete\n\nThis event signals the end of the initial burst of descriptive\nevents. A client may consider the static description of the tool to\nbe complete and finalize initialization of the tool.""tool removed\n\nThis event is sent when the tool is removed from the system and will\nsend no further events. Should the physical tool come back into\nproximity later, a new wp_tablet_tool object will be created.\n\nIt is compositor-dependent when a tool is removed. A compositor may\nremove a tool on proximity out, tablet removal or any other reason.\nA compositor may also keep a tool alive until shutdown.\n\nIf the tool is currently in proximity, a proximity_out event will be\nsent before the removed event. See wp_tablet_tool.proximity_out for\nthe handling of any buttons logically down.\n\nWhen this event is received, the client must wp_tablet_tool.destroy\nthe object.""proximity in event\n\nNotification that this tool is focused on a certain surface.\n\nThis event can be received when the tool has moved from one surface to\nanother, or when the tool has come back into proximity above the\nsurface.\n\nIf any button is logically down when the tool comes into proximity,\nthe respective button event is sent after the proximity_in event but\nwithin the same frame as the proximity_in event.""The tablet the tool is in proximity of""The current surface the tablet tool is over""proximity out event\n\nNotification that this tool has either left proximity, or is no\nlonger focused on a certain surface.\n\nWhen the tablet tool leaves proximity of the tablet, button release\nevents are sent for each button that was held down at the time of\nleaving proximity. These events are sent before the proximity_out\nevent but within the same wp_tablet.frame.\n\nIf the tool stays within proximity of the tablet, but the focus\nchanges from one surface to another, a button release event may not\nbe sent until the button is actually released or the tool leaves the\nproximity of the tablet.""tablet tool is making contact\n\nSent whenever the tablet tool comes in contact with the surface of the\ntablet.\n\nIf the tool is already in contact with the tablet when entering the\ninput region, the client owning said region will receive a\nwp_tablet.proximity_in event, followed by a wp_tablet.down\nevent and a wp_tablet.frame event.\n\nNote that this event describes logical contact, not physical\ncontact. On some devices, a compositor may not consider a tool in\nlogical contact until a minimum physical pressure threshold is\nexceeded.""tablet tool is no longer making contact\n\nSent whenever the tablet tool stops making contact with the surface of\nthe tablet, or when the tablet tool moves out of the input region\nand the compositor grab (if any) is dismissed.\n\nIf the tablet tool moves out of the input region while in contact\nwith the surface of the tablet and the compositor does not have an\nongoing grab on the surface, the client owning said region will\nreceive a wp_tablet.up event, followed by a wp_tablet.proximity_out\nevent and a wp_tablet.frame event. If the compositor has an ongoing\ngrab on this device, this event sequence is sent whenever the grab\nis dismissed in the future.\n\nNote that this event describes logical contact, not physical\ncontact. On some devices, a compositor may not consider a tool out\nof logical contact until physical pressure falls below a specific\nthreshold.""motion event\n\nSent whenever a tablet tool moves.""pressure change event\n\nSent whenever the pressure axis on a tool changes. The value of this\nevent is normalized to a value between 0 and 65535.\n\nNote that pressure may be nonzero even when a tool is not in logical\ncontact. See the down and up events for more details.""The current pressure value""distance change event\n\nSent whenever the distance axis on a tool changes. The value of this\nevent is normalized to a value between 0 and 65535.\n\nNote that distance may be nonzero even when a tool is not in logical\ncontact. See the down and up events for more details.""The current distance value""tilt change event\n\nSent whenever one or both of the tilt axes on a tool change. Each tilt\nvalue is in 0.01 of a degree, relative to the z-axis of the tablet.\nThe angle is positive when the top of a tool tilts along the\npositive x or y axis.""The current value of the X tilt axis"tilt_x"The current value of the Y tilt axis"tilt_y"z-rotation change event\n\nSent whenever the z-rotation axis on the tool changes. The\nrotation value is in 0.01 of a degree clockwise from the tool's\nlogical neutral position.""The current rotation of the Z axis"degrees"Slider position change event\n\nSent whenever the slider position on the tool changes. The\nvalue is normalized between -65535 and 65535, with 0 as the logical\nneutral position of the slider.\n\nThe slider is available on e.g. the Wacom Airbrush tool.""The current position of slider""Wheel delta event\n\nSent whenever the wheel on the tool emits an event. This event\ncontains two values for the same axis change. The degrees value is\nin 0.01 of a degree in the same orientation as the\nwl_pointer.vertical_scroll axis. The clicks value is in discrete\nlogical clicks of the mouse wheel. This value may be zero if the\nmovement of the wheel was less than one logical click.\n\nClients should choose either value and avoid mixing degrees and\nclicks. The compositor may accumulate values smaller than a logical\nclick and emulate click events when a certain threshold is met.\nThus, wl_tablet_tool.wheel events with non-zero clicks values may\nhave different degrees values.""The wheel delta in 0.01 of a degree""The wheel delta in discrete clicks"clicks"button event\n\nSent whenever a button on the tool is pressed or released.\n\nIf a button is held down when the tool moves in or out of proximity,\nbutton events are generated by the compositor. See\nwp_tablet_tool.proximity_in and wp_tablet_tool.proximity_out for\ndetails.""The button whose state has changed""Whether the button was pressed or released""frame event\n\nMarks the end of a series of axis and/or button updates from the\ntablet. The Wayland protocol requires axis updates to be sent\nsequentially, however all events within a frame should be considered\none hardware event.""The time of the event with millisecond granularity""a physical tablet tool\n\nAn object that represents a physical tool that has been, or is\ncurrently in use with a tablet in this seat. Each wp_tablet_tool\nobject stays valid until the client destroys it; the compositor\nreuses the wp_tablet_tool object to indicate that the object's\nrespective physical tool has come into proximity of a tablet again.\n\nA wp_tablet_tool object's relation to a physical tool depends on the\ntablet's ability to report serial numbers. If the tablet supports\nthis capability, then the object represents a specific physical tool\nand can be identified even when used on multiple tablets.\n\nA tablet tool has a number of static characteristics, e.g. tool type,\nhardware_serial and capabilities. These capabilities are sent in an\nevent sequence after the wp_tablet_seat.tool_added event before any\nactual events from this tool. This initial event sequence is\nterminated by a wp_tablet_tool.done event.\n\nTablet tool events are grouped by wp_tablet_tool.frame events.\nAny events received before a wp_tablet_tool.frame event should be\nconsidered part of the same hardware state change.\n\nSee also the [Event] enum for this interface.""destroy the tool object\n\nThis destroys the client's resource for this tool object.""graphics tablet device\n\nThe wp_tablet interface represents one graphics tablet device. The\ntablet interface itself does not generate events; all events are\ngenerated by wp_tablet_tool objects when in proximity above a tablet.\n\nA tablet has a number of static characteristics, e.g. device name and\npid/vid. These capabilities are sent in an event sequence after the\nwp_tablet_seat.tablet_added event. This initial event sequence is\nterminated by a wp_tablet.done event."EVT_PATH_SINCEEVT_PATH_OPCODE"destroy the tablet object\n\nThis destroys the client's resource for this tablet object.\n\nThis is a destructor, once sent this object cannot be used any longer.""tablet device name\n\nThis event is sent in the initial burst of events before the\nwp_tablet.done event.""the device name""tablet device USB vendor/product id\n\nThis event is sent in the initial burst of events before the\nwp_tablet.done event.""USB vendor id"vid"USB product id""path to the device\n\nA system-specific device path that indicates which device is behind\nthis wp_tablet. This information may be used to gather additional\ninformation about the device, e.g. through libwacom.\n\nA device may have more than one device path. If so, multiple\nwp_tablet.path events are sent. A device may be emulated and not\nhave a device path, and in that case this event will not be sent.\n\nThe format of the path is unspecified, it may be a device node, a\nsysfs path, or some other identifier. It is up to the client to\nidentify the string provided.\n\nThis event is sent in the initial burst of events before the\nwp_tablet.done event.""path to local device""tablet description events sequence complete\n\nThis event is sent immediately to signal the end of the initial\nburst of descriptive events. A client may consider the static\ndescription of the tablet to be complete and finalize initialization\nof the tablet.""tablet removed event\n\nSent when the tablet has been removed from the system. When a tablet\nis removed, some tools may be removed.\n\nWhen this event is received, the client must wp_tablet.destroy\nthe object.""graphics tablet device\n\nThe wp_tablet interface represents one graphics tablet device. The\ntablet interface itself does not generate events; all events are\ngenerated by wp_tablet_tool objects when in proximity above a tablet.\n\nA tablet has a number of static characteristics, e.g. device name and\npid/vid. These capabilities are sent in an event sequence after the\nwp_tablet_seat.tablet_added event. This initial event sequence is\nterminated by a wp_tablet.done event.\n\nSee also the [Event] enum for this interface.""destroy the tablet object\n\nThis destroys the client's resource for this tablet object."ZWP_TABLET_MANAGER_V2_INTERFACEzwp_tablet_manager_v2_requests_get_tablet_seat_typeszwp_tablet_manager_v2_requestszwp_tablet_manager_v2_interfaceZWP_TABLET_SEAT_V2_INTERFACEzwp_tablet_seat_v2_requestszwp_tablet_seat_v2_events_tablet_added_typeszwp_tablet_seat_v2_events_tool_added_typeszwp_tablet_seat_v2_events_pad_added_typeszwp_tablet_seat_v2_eventszwp_tablet_seat_v2_interfaceZWP_TABLET_TOOL_V2_INTERFACEzwp_tablet_tool_v2_requests_set_cursor_typeszwp_tablet_tool_v2_requestszwp_tablet_tool_v2_events_proximity_in_typeszwp_tablet_tool_v2_eventszwp_tablet_tool_v2_interfaceZWP_TABLET_V2_INTERFACEzwp_tablet_v2_requestszwp_tablet_v2_eventszwp_tablet_v2_interfaceZWP_TABLET_PAD_RING_V2_INTERFACEzwp_tablet_pad_ring_v2_requestszwp_tablet_pad_ring_v2_eventszwp_tablet_pad_ring_v2_interfaceZWP_TABLET_PAD_STRIP_V2_INTERFACEzwp_tablet_pad_strip_v2_requestszwp_tablet_pad_strip_v2_eventszwp_tablet_pad_strip_v2_interfaceZWP_TABLET_PAD_GROUP_V2_INTERFACEzwp_tablet_pad_group_v2_requestszwp_tablet_pad_group_v2_events_ring_typeszwp_tablet_pad_group_v2_events_strip_typeszwp_tablet_pad_group_v2_events_dial_typeszwp_tablet_pad_group_v2_eventszwp_tablet_pad_group_v2_interfaceZWP_TABLET_PAD_V2_INTERFACEzwp_tablet_pad_v2_requestszwp_tablet_pad_v2_events_group_typeszwp_tablet_pad_v2_events_enter_typeszwp_tablet_pad_v2_events_leave_typeszwp_tablet_pad_v2_eventszwp_tablet_pad_v2_interfaceZWP_TABLET_PAD_DIAL_V2_INTERFACEzwp_tablet_pad_dial_v2_requestszwp_tablet_pad_dial_v2_eventszwp_tablet_pad_dial_v2_interfaceZwpTabletManagerV2zwp_tablet_seat_v2ZwpTabletSeatV2zwp_tablet_manager_v2EVT_PAD_ADDED_SINCEEVT_PAD_ADDED_OPCODEzwp_tablet_v2ZwpTabletV2"new pad notification\n\nThis event is sent whenever a new pad is known to the system. Typically,\npads are physically attached to tablets and a pad_added event is\nsent immediately after the wp_tablet_seat.tablet_added.\nHowever, some standalone pad devices logically attach to tablets at\nruntime, and the client must wait for wp_tablet_pad.enter to know\nthe tablet a pad is attached to.\n\nThis event only provides the object id of the pad. All further\nfeatures (buttons, strips, rings) are sent through the wp_tablet_pad\ninterface.""the newly added pad"zwp_tablet_pad_v2ZwpTabletPadV2PadAdded"set the tablet tool's surface\n\nSets the surface of the cursor used for this tool on the given\ntablet. This request only takes effect if the tool is in proximity\nof one of the requesting client's surfaces or the surface parameter\nis the current pointer surface. If there was a previous surface set\nwith this request it is replaced. If surface is NULL, the cursor\nimage is hidden.\n\nThe parameters hotspot_x and hotspot_y define the position of the\npointer surface relative to the pointer location. Its top-left corner\nis always at (x, y) - (hotspot_x, hotspot_y), where (x, y) are the\ncoordinates of the pointer location, in surface-local coordinates.\n\nOn surface.attach requests to the pointer surface, hotspot_x and\nhotspot_y are decremented by the x and y parameters passed to the\nrequest. Attach must be confirmed by wl_surface.commit as usual.\n\nThe hotspot can also be updated by passing the currently set pointer\nsurface to this request with new values for hotspot_x and hotspot_y.\n\nThe current and pending input regions of the wl_surface are cleared,\nand wl_surface.set_input_region is ignored until the wl_surface is no\nlonger used as the cursor. When the use as a cursor ends, the current\nand pending input regions become undefined, and the wl_surface is\nunmapped.\n\nThis request gives the surface the role of a wp_tablet_tool cursor. A\nsurface may only ever be used as the cursor surface for one\nwp_tablet_tool. If the surface already has another role or has\npreviously been used as cursor surface for a different tool, a\nprotocol error is raised.""serial of the proximity_in event""tilt change event\n\nSent whenever one or both of the tilt axes on a tool change. Each tilt\nvalue is in degrees, relative to the z-axis of the tablet.\nThe angle is positive when the top of a tool tilts along the\npositive x or y axis.""z-rotation change event\n\nSent whenever the z-rotation axis on the tool changes. The\nrotation value is in degrees clockwise from the tool's\nlogical neutral position.""Wheel delta event\n\nSent whenever the wheel on the tool emits an event. This event\ncontains two values for the same axis change. The degrees value is\nin the same orientation as the wl_pointer.vertical_scroll axis. The\nclicks value is in discrete logical clicks of the mouse wheel. This\nvalue may be zero if the movement of the wheel was less\nthan one logical click.\n\nClients should choose either value and avoid mixing degrees and\nclicks. The compositor may accumulate values smaller than a logical\nclick and emulate click events when a certain threshold is met.\nThus, wl_tablet_tool.wheel events with non-zero clicks values may\nhave different degrees values.""The wheel delta in degrees""bus type\n\nDescribes the bus types this tablet is connected to."Bustype"USB"Usb"Bluetooth""Virtual""Serial""I2C"I2cEVT_BUSTYPE_SINCEEVT_BUSTYPE_OPCODE"tablet device name\n\nA descriptive name for the tablet device.\n\nIf the device has no descriptive name, this event is not sent.\n\nThis event is sent in the initial burst of events before the\nwp_tablet.done event.""tablet device vendor/product id\n\nThe vendor and product IDs for the tablet device.\n\nThe interpretation of the id depends on the wp_tablet.bustype.\nPrior to version v2 of this protocol, the id was implied to be a USB\nvendor and product ID. If no wp_tablet.bustype is sent, the ID\nis to be interpreted as USB vendor and product ID.\n\nIf the device has no vendor/product ID, this event is not sent.\nThis can happen for virtual devices or non-USB devices, for instance.\n\nThis event is sent in the initial burst of events before the\nwp_tablet.done event.""vendor id""product id""tablet device bus type\n\nThe bustype argument is one of the BUS_ defines in the Linux kernel's\nlinux/input.h\n\nIf the device has no known bustype or the bustype cannot be\nqueried, this event is not sent.\n\nThis event is sent in the initial burst of events before the\nwp_tablet.done event.\n\nOnly available since version 2 of the interface""bus type""pad ring\n\nA circular interaction area, such as the touch ring on the Wacom Intuos\nPro series tablets.\n\nEvents on a ring are logically grouped by the wl_tablet_pad_ring.frame\nevent.""ring axis source\n\nDescribes the source types for ring events. This indicates to the\nclient how a ring event was physically generated; a client may\nadjust the user interface accordingly. For example, events\nfrom a \"finger\" source may trigger kinetic scrolling.""finger"REQ_SET_FEEDBACK_SINCEREQ_SET_FEEDBACK_OPCODEEVT_SOURCE_SINCEEVT_SOURCE_OPCODEEVT_ANGLE_SINCEEVT_ANGLE_OPCODEEVT_STOP_SINCEEVT_STOP_OPCODE"set compositor feedback\n\nRequest that the compositor use the provided feedback string\nassociated with this ring. This request should be issued immediately\nafter a wp_tablet_pad_group.mode_switch event from the corresponding\ngroup is received, or whenever the ring is mapped to a different\naction. See wp_tablet_pad_group.mode_switch for more details.\n\nClients are encouraged to provide context-aware descriptions for\nthe actions associated with the ring; compositors may use this\ninformation to offer visual feedback about the button layout\n(eg. on-screen displays).\n\nThe provided string 'description' is a UTF-8 encoded string to be\nassociated with this ring, and is considered user-visible; general\ninternationalization rules apply.\n\nThe serial argument will be that of the last\nwp_tablet_pad_group.mode_switch event received for the group of this\nring. Requests providing other serials than the most recent one will be\nignored.""ring description""serial of the mode switch event"SetFeedback"destroy the ring object\n\nThis destroys the client's resource for this ring object.\n\nThis is a destructor, once sent this object cannot be used any longer.""ring event source\n\nSource information for ring events.\n\nThis event does not occur on its own. It is sent before a\nwp_tablet_pad_ring.frame event and carries the source information\nfor all events within that frame.\n\nThe source specifies how this event was generated. If the source is\nwp_tablet_pad_ring.source.finger, a wp_tablet_pad_ring.stop event\nwill be sent when the user lifts the finger off the device.\n\nThis event is optional. If the source is unknown for an interaction,\nno event is sent.""the event source""angle changed\n\nSent whenever the angle on a ring changes.\n\nThe angle is provided in degrees clockwise from the logical\nnorth of the ring in the pad's current rotation.""the current angle in degrees""interaction stopped\n\nStop notification for ring events.\n\nFor some wp_tablet_pad_ring.source types, a wp_tablet_pad_ring.stop\nevent is sent to notify a client that the interaction with the ring\nhas terminated. This enables the client to implement kinetic scrolling.\nSee the wp_tablet_pad_ring.source documentation for information on\nwhen this event may be generated.\n\nAny wp_tablet_pad_ring.angle events with the same source after this\nevent should be considered as the start of a new interaction.""end of a ring event sequence\n\nIndicates the end of a set of ring events that logically belong\ntogether. A client is expected to accumulate the data in all events\nwithin the frame before proceeding.\n\nAll wp_tablet_pad_ring events before a wp_tablet_pad_ring.frame event belong\nlogically together. For example, on termination of a finger interaction\non a ring the compositor will send a wp_tablet_pad_ring.source event,\na wp_tablet_pad_ring.stop event and a wp_tablet_pad_ring.frame event.\n\nA wp_tablet_pad_ring.frame event is sent for every logical event\ngroup, even if the group only contains a single wp_tablet_pad_ring\nevent. Specifically, a client may get a sequence: angle, frame,\nangle, frame, etc.""pad ring\n\nA circular interaction area, such as the touch ring on the Wacom Intuos\nPro series tablets.\n\nEvents on a ring are logically grouped by the wl_tablet_pad_ring.frame\nevent.\n\nSee also the [Event] enum for this interface."ZwpTabletPadRingV2set_feedback"destroy the ring object\n\nThis destroys the client's resource for this ring object."zwp_tablet_pad_ring_v2"pad strip\n\nA linear interaction area, such as the strips found in Wacom Cintiq\nmodels.\n\nEvents on a strip are logically grouped by the wl_tablet_pad_strip.frame\nevent.""strip axis source\n\nDescribes the source types for strip events. This indicates to the\nclient how a strip event was physically generated; a client may\nadjust the user interface accordingly. For example, events\nfrom a \"finger\" source may trigger kinetic scrolling.""set compositor feedback\n\nRequests the compositor to use the provided feedback string\nassociated with this strip. This request should be issued immediately\nafter a wp_tablet_pad_group.mode_switch event from the corresponding\ngroup is received, or whenever the strip is mapped to a different\naction. See wp_tablet_pad_group.mode_switch for more details.\n\nClients are encouraged to provide context-aware descriptions for\nthe actions associated with the strip, and compositors may use this\ninformation to offer visual feedback about the button layout\n(eg. on-screen displays).\n\nThe provided string 'description' is a UTF-8 encoded string to be\nassociated with this ring, and is considered user-visible; general\ninternationalization rules apply.\n\nThe serial argument will be that of the last\nwp_tablet_pad_group.mode_switch event received for the group of this\nstrip. Requests providing other serials than the most recent one will be\nignored.""strip description""destroy the strip object\n\nThis destroys the client's resource for this strip object.\n\nThis is a destructor, once sent this object cannot be used any longer.""strip event source\n\nSource information for strip events.\n\nThis event does not occur on its own. It is sent before a\nwp_tablet_pad_strip.frame event and carries the source information\nfor all events within that frame.\n\nThe source specifies how this event was generated. If the source is\nwp_tablet_pad_strip.source.finger, a wp_tablet_pad_strip.stop event\nwill be sent when the user lifts their finger off the device.\n\nThis event is optional. If the source is unknown for an interaction,\nno event is sent.""position changed\n\nSent whenever the position on a strip changes.\n\nThe position is normalized to a range of [0, 65535], the 0-value\nrepresents the top-most and/or left-most position of the strip in\nthe pad's current rotation.""the current position""interaction stopped\n\nStop notification for strip events.\n\nFor some wp_tablet_pad_strip.source types, a wp_tablet_pad_strip.stop\nevent is sent to notify a client that the interaction with the strip\nhas terminated. This enables the client to implement kinetic\nscrolling. See the wp_tablet_pad_strip.source documentation for\ninformation on when this event may be generated.\n\nAny wp_tablet_pad_strip.position events with the same source after this\nevent should be considered as the start of a new interaction.""end of a strip event sequence\n\nIndicates the end of a set of events that represent one logical\nhardware strip event. A client is expected to accumulate the data\nin all events within the frame before proceeding.\n\nAll wp_tablet_pad_strip events before a wp_tablet_pad_strip.frame event belong\nlogically together. For example, on termination of a finger interaction\non a strip the compositor will send a wp_tablet_pad_strip.source event,\na wp_tablet_pad_strip.stop event and a wp_tablet_pad_strip.frame\nevent.\n\nA wp_tablet_pad_strip.frame event is sent for every logical event\ngroup, even if the group only contains a single wp_tablet_pad_strip\nevent. Specifically, a client may get a sequence: position, frame,\nposition, frame, etc.""pad strip\n\nA linear interaction area, such as the strips found in Wacom Cintiq\nmodels.\n\nEvents on a strip are logically grouped by the wl_tablet_pad_strip.frame\nevent.\n\nSee also the [Event] enum for this interface."ZwpTabletPadStripV2"destroy the strip object\n\nThis destroys the client's resource for this strip object."zwp_tablet_pad_strip_v2"a set of buttons, rings and strips\n\nA pad group describes a distinct (sub)set of buttons, rings and strips\npresent in the tablet. The criteria of this grouping is usually positional,\neg. if a tablet has buttons on the left and right side, 2 groups will be\npresented. The physical arrangement of groups is undisclosed and may\nchange on the fly.\n\nPad groups will announce their features during pad initialization. Between\nthe corresponding wp_tablet_pad.group event and wp_tablet_pad_group.done, the\npad group will announce the buttons, rings and strips contained in it,\nplus the number of supported modes.\n\nModes are a mechanism to allow multiple groups of actions for every element\nin the pad group. The number of groups and available modes in each is\npersistent across device plugs. The current mode is user-switchable, it\nwill be announced through the wp_tablet_pad_group.mode_switch event both\nwhenever it is switched, and after wp_tablet_pad.enter.\n\nThe current mode logically applies to all elements in the pad group,\nalthough it is at clients' discretion whether to actually perform different\nactions, and/or issue the respective .set_feedback requests to notify the\ncompositor. See the wp_tablet_pad_group.mode_switch event for more details."EVT_BUTTONS_SINCEEVT_BUTTONS_OPCODEEVT_RING_SINCEEVT_RING_OPCODEEVT_STRIP_SINCEEVT_STRIP_OPCODEEVT_MODES_SINCEEVT_MODES_OPCODEEVT_MODE_SWITCH_SINCEEVT_MODE_SWITCH_OPCODEEVT_DIAL_SINCEEVT_DIAL_OPCODE"destroy the pad object\n\nDestroy the wp_tablet_pad_group object. Objects created from this object\nare unaffected and should be destroyed separately.\n\nThis is a destructor, once sent this object cannot be used any longer.""buttons announced\n\nSent on wp_tablet_pad_group initialization to announce the available\nbuttons in the group. Button indices start at 0, a button may only be\nin one group at a time.\n\nThis event is first sent in the initial burst of events before the\nwp_tablet_pad_group.done event.\n\nSome buttons are reserved by the compositor. These buttons may not be\nassigned to any wp_tablet_pad_group. Compositors may broadcast this\nevent in the case of changes to the mapping of these reserved buttons.\nIf the compositor happens to reserve all buttons in a group, this event\nwill be sent with an empty array.""buttons in this group""ring announced\n\nSent on wp_tablet_pad_group initialization to announce available rings.\nOne event is sent for each ring available on this pad group.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad_group.done event.""strip announced\n\nSent on wp_tablet_pad initialization to announce available strips.\nOne event is sent for each strip available on this pad group.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad_group.done event.""mode-switch ability announced\n\nSent on wp_tablet_pad_group initialization to announce that the pad\ngroup may switch between modes. A client may use a mode to store a\nspecific configuration for buttons, rings and strips and use the\nwl_tablet_pad_group.mode_switch event to toggle between these\nconfigurations. Mode indices start at 0.\n\nSwitching modes is compositor-dependent. See the\nwp_tablet_pad_group.mode_switch event for more details.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad_group.done event. This event is only sent when more than\nmore than one mode is available.""the number of modes""tablet group description events sequence complete\n\nThis event is sent immediately to signal the end of the initial\nburst of descriptive events. A client may consider the static\ndescription of the tablet to be complete and finalize initialization\nof the tablet group.""mode switch event\n\nNotification that the mode was switched.\n\nA mode applies to all buttons, rings, strips and dials in a group\nsimultaneously, but a client is not required to assign different actions\nfor each mode. For example, a client may have mode-specific button\nmappings but map the ring to vertical scrolling in all modes. Mode\nindices start at 0.\n\nSwitching modes is compositor-dependent. The compositor may provide\nvisual cues to the user about the mode, e.g. by toggling LEDs on\nthe tablet device. Mode-switching may be software-controlled or\ncontrolled by one or more physical buttons. For example, on a Wacom\nIntuos Pro, the button inside the ring may be assigned to switch\nbetween modes.\n\nThe compositor will also send this event after wp_tablet_pad.enter on\neach group in order to notify of the current mode. Groups that only\nfeature one mode will use mode=0 when emitting this event.\n\nIf a button action in the new mode differs from the action in the\nprevious mode, the client should immediately issue a\nwp_tablet_pad.set_feedback request for each changed button.\n\nIf a ring, strip or dial action in the new mode differs from the action\nin the previous mode, the client should immediately issue a\nwp_tablet_ring.set_feedback, wp_tablet_strip.set_feedback or\nwp_tablet_dial.set_feedback request for each changed ring, strip or dial.""the time of the event with millisecond granularity""the new mode of the pad"ModeSwitch"dial announced\n\nSent on wp_tablet_pad initialization to announce available dials.\nOne event is sent for each dial available on this pad group.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad_group.done event.\n\nOnly available since version 2 of the interface"dialzwp_tablet_pad_dial_v2ZwpTabletPadDialV2"a set of buttons, rings and strips\n\nA pad group describes a distinct (sub)set of buttons, rings and strips\npresent in the tablet. The criteria of this grouping is usually positional,\neg. if a tablet has buttons on the left and right side, 2 groups will be\npresented. The physical arrangement of groups is undisclosed and may\nchange on the fly.\n\nPad groups will announce their features during pad initialization. Between\nthe corresponding wp_tablet_pad.group event and wp_tablet_pad_group.done, the\npad group will announce the buttons, rings and strips contained in it,\nplus the number of supported modes.\n\nModes are a mechanism to allow multiple groups of actions for every element\nin the pad group. The number of groups and available modes in each is\npersistent across device plugs. The current mode is user-switchable, it\nwill be announced through the wp_tablet_pad_group.mode_switch event both\nwhenever it is switched, and after wp_tablet_pad.enter.\n\nThe current mode logically applies to all elements in the pad group,\nalthough it is at clients' discretion whether to actually perform different\nactions, and/or issue the respective .set_feedback requests to notify the\ncompositor. See the wp_tablet_pad_group.mode_switch event for more details.\n\nSee also the [Event] enum for this interface."ZwpTabletPadGroupV2"destroy the pad object\n\nDestroy the wp_tablet_pad_group object. Objects created from this object\nare unaffected and should be destroyed separately."zwp_tablet_pad_group_v2"a set of buttons, rings, strips and dials\n\nA pad device is a set of buttons, rings, strips and dials\nusually physically present on the tablet device itself. Some\nexceptions exist where the pad device is physically detached, e.g. the\nWacom ExpressKey Remote.\n\nPad devices have no axes that control the cursor and are generally\nauxiliary devices to the tool devices used on the tablet surface.\n\nA pad device has a number of static characteristics, e.g. the number\nof rings. These capabilities are sent in an event sequence after the\nwp_tablet_seat.pad_added event before any actual events from this pad.\nThis initial event sequence is terminated by a wp_tablet_pad.done\nevent.\n\nAll pad features (buttons, rings, strips and dials) are logically divided into\ngroups and all pads have at least one group. The available groups are\nnotified through the wp_tablet_pad.group event; the compositor will\nemit one event per group before emitting wp_tablet_pad.done.\n\nGroups may have multiple modes. Modes allow clients to map multiple\nactions to a single pad feature. Only one mode can be active per group,\nalthough different groups may have different active modes.""physical button state\n\nDescribes the physical state of a button that caused the button\nevent."EVT_GROUP_SINCEEVT_GROUP_OPCODE"set compositor feedback\n\nRequests the compositor to use the provided feedback string\nassociated with this button. This request should be issued immediately\nafter a wp_tablet_pad_group.mode_switch event from the corresponding\ngroup is received, or whenever a button is mapped to a different\naction. See wp_tablet_pad_group.mode_switch for more details.\n\nClients are encouraged to provide context-aware descriptions for\nthe actions associated with each button, and compositors may use\nthis information to offer visual feedback on the button layout\n(e.g. on-screen displays).\n\nButton indices start at 0. Setting the feedback string on a button\nthat is reserved by the compositor (i.e. not belonging to any\nwp_tablet_pad_group) does not generate an error but the compositor\nis free to ignore the request.\n\nThe provided string 'description' is a UTF-8 encoded string to be\nassociated with this ring, and is considered user-visible; general\ninternationalization rules apply.\n\nThe serial argument will be that of the last\nwp_tablet_pad_group.mode_switch event received for the group of this\nbutton. Requests providing other serials than the most recent one will\nbe ignored.""button index""button description""destroy the pad object\n\nDestroy the wp_tablet_pad object. Objects created from this object\nare unaffected and should be destroyed separately.\n\nThis is a destructor, once sent this object cannot be used any longer.""group announced\n\nSent on wp_tablet_pad initialization to announce available groups.\nOne event is sent for each pad group available.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad.done event. At least one group will be announced."pad_group"path to the device\n\nA system-specific device path that indicates which device is behind\nthis wp_tablet_pad. This information may be used to gather additional\ninformation about the device, e.g. through libwacom.\n\nThe format of the path is unspecified, it may be a device node, a\nsysfs path, or some other identifier. It is up to the client to\nidentify the string provided.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad.done event.""buttons announced\n\nSent on wp_tablet_pad initialization to announce the available\nbuttons.\n\nThis event is sent in the initial burst of events before the\nwp_tablet_pad.done event. This event is only sent when at least one\nbutton is available.""the number of buttons""pad description event sequence complete\n\nThis event signals the end of the initial burst of descriptive\nevents. A client may consider the static description of the pad to\nbe complete and finalize initialization of the pad.""physical button state\n\nSent whenever the physical state of a button changes.""the index of the button that changed state""enter event\n\nNotification that this pad is focused on the specified surface.""the tablet the pad is attached to""surface the pad is focused on""leave event\n\nNotification that this pad is no longer focused on the specified\nsurface.""surface the pad is no longer focused on""pad removed event\n\nSent when the pad has been removed from the system. When a tablet\nis removed its pad(s) will be removed too.\n\nWhen this event is received, the client must destroy all rings, strips\nand groups that were offered by this pad, and issue wp_tablet_pad.destroy\nthe pad itself.""a set of buttons, rings, strips and dials\n\nA pad device is a set of buttons, rings, strips and dials\nusually physically present on the tablet device itself. Some\nexceptions exist where the pad device is physically detached, e.g. the\nWacom ExpressKey Remote.\n\nPad devices have no axes that control the cursor and are generally\nauxiliary devices to the tool devices used on the tablet surface.\n\nA pad device has a number of static characteristics, e.g. the number\nof rings. These capabilities are sent in an event sequence after the\nwp_tablet_seat.pad_added event before any actual events from this pad.\nThis initial event sequence is terminated by a wp_tablet_pad.done\nevent.\n\nAll pad features (buttons, rings, strips and dials) are logically divided into\ngroups and all pads have at least one group. The available groups are\nnotified through the wp_tablet_pad.group event; the compositor will\nemit one event per group before emitting wp_tablet_pad.done.\n\nGroups may have multiple modes. Modes allow clients to map multiple\nactions to a single pad feature. Only one mode can be active per group,\nalthough different groups may have different active modes.\n\nSee also the [Event] enum for this interface.""destroy the pad object\n\nDestroy the wp_tablet_pad object. Objects created from this object\nare unaffected and should be destroyed separately.""pad dial\n\nA rotary control, e.g. a dial or a wheel.\n\nEvents on a dial are logically grouped by the wl_tablet_pad_dial.frame\nevent."EVT_DELTA_SINCEEVT_DELTA_OPCODE"set compositor feedback\n\nRequests the compositor to use the provided feedback string\nassociated with this dial. This request should be issued immediately\nafter a wp_tablet_pad_group.mode_switch event from the corresponding\ngroup is received, or whenever the dial is mapped to a different\naction. See wp_tablet_pad_group.mode_switch for more details.\n\nClients are encouraged to provide context-aware descriptions for\nthe actions associated with the dial, and compositors may use this\ninformation to offer visual feedback about the button layout\n(eg. on-screen displays).\n\nThe provided string 'description' is a UTF-8 encoded string to be\nassociated with this ring, and is considered user-visible; general\ninternationalization rules apply.\n\nThe serial argument will be that of the last\nwp_tablet_pad_group.mode_switch event received for the group of this\ndial. Requests providing other serials than the most recent one will be\nignored.""dial description""destroy the dial object\n\nThis destroys the client's resource for this dial object.\n\nThis is a destructor, once sent this object cannot be used any longer.""delta movement\n\nSent whenever the position on a dial changes.\n\nThis event carries the wheel delta as multiples or fractions\nof 120 with each multiple of 120 representing one logical wheel detent.\nFor example, an axis_value120 of 30 is one quarter of\na logical wheel step in the positive direction, a value120 of\n-240 are two logical wheel steps in the negative direction within the\nsame hardware event. See the wl_pointer.axis_value120 for more details.\n\nThe value120 must not be zero.""rotation distance as fraction of 120""end of a dial event sequence\n\nIndicates the end of a set of events that represent one logical\nhardware dial event. A client is expected to accumulate the data\nin all events within the frame before proceeding.\n\nAll wp_tablet_pad_dial events before a wp_tablet_pad_dial.frame event belong\nlogically together.\n\nA wp_tablet_pad_dial.frame event is sent for every logical event\ngroup, even if the group only contains a single wp_tablet_pad_dial\nevent. Specifically, a client may get a sequence: delta, frame,\ndelta, frame, etc.""pad dial\n\nA rotary control, e.g. a dial or a wheel.\n\nEvents on a dial are logically grouped by the wl_tablet_pad_dial.frame\nevent.\n\nSee also the [Event] enum for this interface.""destroy the dial object\n\nThis destroys the client's resource for this dial object."/// Unstable version 2//! Wayland protocol for graphics tablets//! This description provides a high-level overview of the interplay between//! the interfaces defined this protocol. For details, see the protocol//! specification.//! More than one tablet may exist, and device-specifics matter. Tablets are//! not represented by a single virtual device like wl_pointer. A client//! binds to the tablet manager object which is just a proxy object. From//! that, the client requests wp_tablet_manager.get_tablet_seat(wl_seat)//! and that returns the actual interface that has all the tablets. With//! this indirection, we can avoid merging wp_tablet into the actual Wayland//! protocol, a long-term benefit.//! The wp_tablet_seat sends a "tablet added" event for each tablet//! connected. That event is followed by descriptive events about the//! hardware; currently that includes events for name, vid/pid and//! a wp_tablet.path event that describes a local path. This path can be//! used to uniquely identify a tablet or get more information through//! libwacom. Emulated or nested tablets can skip any of those, e.g. a//! virtual tablet may not have a vid/pid. The sequence of descriptive//! events is terminated by a wp_tablet.done event to signal that a client//! may now finalize any initialization for that tablet.//! Events from tablets require a tool in proximity. Tools are also managed//! by the tablet seat; a "tool added" event is sent whenever a tool is new//! to the compositor. That event is followed by a number of descriptive//! events about the hardware; currently that includes capabilities,//! hardware id and serial number, and tool type. Similar to the tablet//! interface, a wp_tablet_tool.done event is sent to terminate that initial//! sequence.//! Any event from a tool happens on the wp_tablet_tool interface. When the//! tool gets into proximity of the tablet, a proximity_in event is sent on//! the wp_tablet_tool interface, listing the tablet and the surface. That//! event is followed by a motion event with the coordinates. After that,//! it's the usual motion, axis, button, etc. events. The protocol's//! serialisation means events are grouped by wp_tablet_tool.frame events.//! Two special events (that don't exist in X) are down and up. They signal//! "tip touching the surface". For tablets without real proximity//! detection, the sequence is: proximity_in, motion, down, frame.//! When the tool leaves proximity, a proximity_out event is sent. If any//! button is still down, a button release event is sent before this//! proximity event. These button events are sent in the same frame as the//! proximity event to signal to the client that the buttons were held when//! the tool left proximity.//! If the tool moves out of the surface but stays in proximity (i.e.//! between windows), compositor-specific grab policies apply. This usually//! means that the proximity-out is delayed until all buttons are released.//! Moving a tool physically from one tablet to the other has no real effect//! on the protocol, since we already have the tool object from the "tool//! added" event. All the information is already there and the proximity//! events on both tablets are all a client needs to reconstruct what//! happened.//! Some extra axes are normalized, i.e. the client knows the range as//! specified in the protocol (e.g. [0, 65535]), the granularity however is//! unknown. The current normalized axes are pressure, distance, and slider.//! Other extra axes are in physical units as specified in the protocol.//! The current extra axes with physical units are tilt, rotation and//! wheel rotation.//! Since tablets work independently of the pointer controlled by the mouse,//! the focus handling is independent too and controlled by proximity.//! The wp_tablet_tool.set_cursor request sets a tool-specific cursor.//! This cursor surface may be the same as the mouse cursor, and it may be//! the same across tools but it is possible to be more fine-grained. For//! example, a client may set different cursors for the pen and eraser.//! Tools are generally independent of tablets and it is//! compositor-specific policy when a tool can be removed. Common approaches//! will likely include some form of removing a tool when all tablets the//! tool was used on are removed.ZWP_TEXT_INPUT_V1_INTERFACEzwp_text_input_v1_requests_activate_typeszwp_text_input_v1_requests_deactivate_typeszwp_text_input_v1_requestszwp_text_input_v1_events_enter_typeszwp_text_input_v1_eventszwp_text_input_v1_interfaceZWP_TEXT_INPUT_MANAGER_V1_INTERFACEzwp_text_input_manager_v1_requests_create_text_input_typeszwp_text_input_manager_v1_requestszwp_text_input_manager_v1_interface"text input\n\nAn object used for text input. Adds support for text input and input\nmethods to applications. A text_input object is created from a\nwl_text_input_manager and corresponds typically to a text entry in an\napplication.\n\nRequests are used to activate/deactivate the text_input object and set\nstate information like surrounding and selected text or the content type.\nThe information about entered text is sent to the text_input object via\nthe pre-edit and commit events. Using this interface removes the need\nfor applications to directly process hardware key events and compose text\nout of them.\n\nText is generally UTF-8 encoded, indices and lengths are in bytes.\n\nSerials are used to synchronize the state between the text input and\nan input method. New serials are sent by the text input in the\ncommit_state request and are used by the input method to indicate\nthe known text input state in events like preedit_string, commit_string,\nand keysym. The text input can then ignore events from the input method\nwhich are based on an outdated state (for example after a reset).\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.""content hint\n\nContent hint is a bitmask to allow to modify the behavior of the text\ninput.""no special behaviour""auto completion, correction and capitalization""hidden and sensitive text""suggest word completions"AutoCompletion"suggest word corrections"AutoCorrection"switch to uppercase letters at the start of a sentence"AutoCapitalization"prefer lowercase letters"Lowercase"prefer uppercase letters"Uppercase"prefer casing for titles and headings (can be language dependent)"Titlecase"characters should be hidden"HiddenText"typed text should not be stored"SensitiveData"just latin characters should be entered""the text input is multiline"Multiline"content purpose\n\nThe content purpose allows to specify the primary purpose of a text\ninput.\n\nThis allows an input method to show special purpose input panels with\nextra characters or to disallow some characters.""default input, allowing all characters""allow only alphabetic characters""allow only digits""input a number (including decimal separator and sign)""input a phone number""input an URL""input an email address""input a name of a person""input a password (combine with password or sensitive_data hint)""input a date""input a time""input a date and time""input for a terminal"PreeditStyle"default style for composing text""style should be the same as in non-composing text"HighlightIncorrect"automatic text direction based on text and language""left-to-right""right-to-left"REQ_SHOW_INPUT_PANEL_SINCEREQ_SHOW_INPUT_PANEL_OPCODEREQ_HIDE_INPUT_PANEL_SINCEREQ_HIDE_INPUT_PANEL_OPCODEREQ_RESET_SINCEREQ_RESET_OPCODEREQ_SET_SURROUNDING_TEXT_SINCEREQ_SET_SURROUNDING_TEXT_OPCODEREQ_SET_CURSOR_RECTANGLE_SINCEREQ_SET_CURSOR_RECTANGLE_OPCODEREQ_SET_PREFERRED_LANGUAGE_SINCEREQ_SET_PREFERRED_LANGUAGE_OPCODEREQ_COMMIT_STATE_SINCEREQ_COMMIT_STATE_OPCODEREQ_INVOKE_ACTION_SINCEREQ_INVOKE_ACTION_OPCODEEVT_MODIFIERS_MAP_SINCEEVT_MODIFIERS_MAP_OPCODEEVT_INPUT_PANEL_STATE_SINCEEVT_INPUT_PANEL_STATE_OPCODEEVT_PREEDIT_STRING_SINCEEVT_PREEDIT_STRING_OPCODEEVT_PREEDIT_STYLING_SINCEEVT_PREEDIT_STYLING_OPCODEEVT_PREEDIT_CURSOR_SINCEEVT_PREEDIT_CURSOR_OPCODEEVT_COMMIT_STRING_SINCEEVT_COMMIT_STRING_OPCODEEVT_CURSOR_POSITION_SINCEEVT_CURSOR_POSITION_OPCODEEVT_DELETE_SURROUNDING_TEXT_SINCEEVT_DELETE_SURROUNDING_TEXT_OPCODEEVT_KEYSYM_SINCEEVT_KEYSYM_OPCODEEVT_LANGUAGE_SINCEEVT_LANGUAGE_OPCODEEVT_TEXT_DIRECTION_SINCEEVT_TEXT_DIRECTION_OPCODE"request activation\n\nRequests the text_input object to be activated (typically when the\ntext entry gets focus).\n\nThe seat argument is a wl_seat which maintains the focus for this\nactivation. The surface argument is a wl_surface assigned to the\ntext_input object and tracked for focus lost. The enter event\nis emitted on successful activation.""request deactivation\n\nRequests the text_input object to be deactivated (typically when the\ntext entry lost focus). The seat argument is a wl_seat which was used\nfor activation.""show input panels\n\nRequests input panels (virtual keyboard) to show."ShowInputPanel"hide input panels\n\nRequests input panels (virtual keyboard) to hide."HideInputPanel"reset\n\nShould be called by an editor widget when the input state should be\nreset, for example after the text was changed outside of the normal\ninput method flow.""sets the surrounding text\n\nSets the plain surrounding text around the input position. Text is\nUTF-8 encoded. Cursor is the byte offset within the\nsurrounding text. Anchor is the byte offset of the\nselection anchor within the surrounding text. If there is no selected\ntext anchor, then it is the same as cursor."SetSurroundingText"set content purpose and hint\n\nSets the content purpose and content hint. While the purpose is the\nbasic purpose of an input field, the hint flags allow to modify some\nof the behavior.\n\nWhen no content type is explicitly set, a normal content purpose with\ndefault hints (auto completion, auto correction, auto capitalization)\nshould be assumed."SetCursorRectangle"sets preferred language\n\nSets a specific language. This allows for example a virtual keyboard to\nshow a language specific layout. The \"language\" argument is an RFC-3066\nformat language tag.\n\nIt could be used for example in a word processor to indicate the\nlanguage of the currently edited document or in an instant message\napplication which tracks languages of contacts."SetPreferredLanguage"used to identify the known state""enter event\n\nNotify the text_input object when it received focus. Typically in\nresponse to an activate request.""leave event\n\nNotify the text_input object when it lost focus. Either in response\nto a deactivate request or when the assigned surface lost focus or was\ndestroyed.""modifiers map\n\nTransfer an array of 0-terminated modifier names. The position in\nthe array is the index of the modifier as used in the modifiers\nbitmask in the keysym event.""state of the input panel\n\nNotify when the visibility state of the input panel changed."InputPanelState"pre-edit\n\nNotify when a new composing text (pre-edit) should be set around the\ncurrent cursor position. Any previously set composing text should\nbe removed.\n\nThe commit text can be used to replace the preedit text on reset\n(for example on unfocus).\n\nThe text input should also handle all preedit_style and preedit_cursor\nevents occurring directly before preedit_string.""pre-edit styling\n\nSets styling information on composing text. The style is applied for\nlength bytes from index relative to the beginning of the composing\ntext (as byte offset). Multiple styles can\nbe applied to a composing text by sending multiple preedit_styling\nevents.\n\nThis event is handled as part of a following preedit_string event.""pre-edit cursor\n\nSets the cursor position inside the composing text (as byte\noffset) relative to the start of the composing text. When index is a\nnegative number no cursor is shown.\n\nThis event is handled as part of a following preedit_string event.""commit\n\nNotify when text should be inserted into the editor widget. The text to\ncommit could be either just a single character after a key press or the\nresult of some composing (pre-edit). It could also be an empty text\nwhen some text should be removed (see delete_surrounding_text) or when\nthe input cursor should be moved (see cursor_position).\n\nAny previously set composing text should be removed.""set cursor to new position\n\nNotify when the cursor or anchor position should be modified.\n\nThis event should be handled as part of a following commit_string\nevent.""delete surrounding text\n\nNotify when the text around the current cursor position should be\ndeleted.\n\nIndex is relative to the current cursor (in bytes).\nLength is the length of deleted text (in bytes).\n\nThis event should be handled as part of a following commit_string\nevent.""keysym\n\nNotify when a key event was sent. Key events should not be used\nfor normal text input operations, which should be done with\ncommit_string, delete_surrounding_text, etc. The key event follows\nthe wl_keyboard key event convention. Sym is an XKB keysym, state a\nwl_keyboard key_state. Modifiers are a mask for effective modifiers\n(where the modifier indices are set by the modifiers_map event)""language\n\nSets the language of the input text. The \"language\" argument is an\nRFC-3066 format language tag.""text direction\n\nSets the text direction of input text.\n\nIt is mainly needed for showing an input cursor on the correct side of\nthe editor when there is no input done yet and making sure neutral\ndirection text is laid out properly.""text input\n\nAn object used for text input. Adds support for text input and input\nmethods to applications. A text_input object is created from a\nwl_text_input_manager and corresponds typically to a text entry in an\napplication.\n\nRequests are used to activate/deactivate the text_input object and set\nstate information like surrounding and selected text or the content type.\nThe information about entered text is sent to the text_input object via\nthe pre-edit and commit events. Using this interface removes the need\nfor applications to directly process hardware key events and compose text\nout of them.\n\nText is generally UTF-8 encoded, indices and lengths are in bytes.\n\nSerials are used to synchronize the state between the text input and\nan input method. New serials are sent by the text input in the\ncommit_state request and are used by the input method to indicate\nthe known text input state in events like preedit_string, commit_string,\nand keysym. The text input can then ignore events from the input method\nwhich are based on an outdated state (for example after a reset).\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nSee also the [Event] enum for this interface."ZwpTextInputV1show_input_panelhide_input_panelset_surrounding_textset_cursor_rectangleset_preferred_languagecommit_stateinvoke_actionzwp_text_input_v1"text input manager\n\nA factory for text_input objects. This object is a global singleton."REQ_CREATE_TEXT_INPUT_SINCEREQ_CREATE_TEXT_INPUT_OPCODE"create text input\n\nCreates a new text_input object."CreateTextInput"text input manager\n\nA factory for text_input objects. This object is a global singleton.\n\nThis interface has no events."ZwpTextInputManagerV1create_text_inputzwp_text_input_manager_v1ZWP_TEXT_INPUT_V3_INTERFACEzwp_text_input_v3_requestszwp_text_input_v3_events_enter_typeszwp_text_input_v3_events_leave_typeszwp_text_input_v3_eventszwp_text_input_v3_interfaceZWP_TEXT_INPUT_MANAGER_V3_INTERFACEzwp_text_input_manager_v3_requests_get_text_input_typeszwp_text_input_manager_v3_requestszwp_text_input_manager_v3_interface"text input\n\nThe zwp_text_input_v3 interface represents text input and input methods\nassociated with a seat. It provides enter/leave events to follow the\ntext input focus for a seat.\n\nRequests are used to enable/disable the text-input object and set\nstate information like surrounding and selected text or the content type.\nThe information about the entered text is sent to the text-input object\nvia the preedit_string and commit_string events.\n\nText is valid UTF-8 encoded, indices and lengths are in bytes. Indices\nmust not point to middle bytes inside a code point: they must either\npoint to the first byte of a code point or to the end of the buffer.\nLengths must be measured between two valid indices.\n\nFocus moving throughout surfaces will result in the emission of\nzwp_text_input_v3.enter and zwp_text_input_v3.leave events. The focused\nsurface must commit zwp_text_input_v3.enable and\nzwp_text_input_v3.disable requests as the keyboard focus moves across\neditable and non-editable elements of the UI. Those two requests are not\nexpected to be paired with each other, the compositor must be able to\nhandle consecutive series of the same request.\n\nState is sent by the state requests (set_surrounding_text,\nset_content_type and set_cursor_rectangle) and a commit request. After an\nenter event or disable request all state information is invalidated and\nneeds to be resent by the client.""text change reason\n\nReason for the change of surrounding text or cursor posision.""input method caused the change""something else than the input method caused the change""no special behavior"Spellcheck"just Latin characters should be entered""input a password (combine with sensitive_data hint)""input is a numeric password (combine with sensitive_data hint)"REQ_ENABLE_SINCEREQ_ENABLE_OPCODEREQ_DISABLE_SINCEREQ_DISABLE_OPCODEREQ_SET_TEXT_CHANGE_CAUSE_SINCEREQ_SET_TEXT_CHANGE_CAUSE_OPCODE"Destroy the wp_text_input\n\nDestroy the wp_text_input object. Also disables all surfaces enabled\nthrough this wp_text_input object.\n\nThis is a destructor, once sent this object cannot be used any longer.""Request text input to be enabled\n\nRequests text input on the surface previously obtained from the enter\nevent.\n\nThis request must be issued every time the focused text input changes\nto a new one, including within the current surface. Use\nzwp_text_input_v3.disable when there is no longer any input focus on\nthe current surface.\n\nClients must not enable more than one text input on the single seat\nand should disable the current text input before enabling the new one.\nRequests to enable a text input when another text input is enabled\non the same seat must be ignored by compositor.\n\nThis request resets all state associated with previous enable, disable,\nset_surrounding_text, set_text_change_cause, set_content_type, and\nset_cursor_rectangle requests, as well as the state associated with\npreedit_string, commit_string, and delete_surrounding_text events.\n\nThe set_surrounding_text, set_content_type and set_cursor_rectangle\nrequests must follow if the text input supports the necessary\nfunctionality.\n\nState set with this request is double-buffered. It will get applied on\nthe next zwp_text_input_v3.commit request, and stay valid until the\nnext committed enable or disable request.\n\nThe changes must be applied by the compositor after issuing a\nzwp_text_input_v3.commit request.""Disable text input on a surface\n\nExplicitly disable text input on the current surface (typically when\nthere is no focus on any text entry inside the surface).\n\nState set with this request is double-buffered. It will get applied on\nthe next zwp_text_input_v3.commit request.""sets the surrounding text\n\nSets the surrounding plain text around the input, excluding the preedit\ntext.\n\nThe client should notify the compositor of any changes in any of the\nvalues carried with this request, including changes caused by handling\nincoming text-input events as well as changes caused by other\nmechanisms like keyboard typing.\n\nIf the client is unaware of the text around the cursor, it should not\nissue this request, to signify lack of support to the compositor.\n\nText is UTF-8 encoded, and should include the cursor position, the\ncomplete selection and additional characters before and after them.\nThere is a maximum length of wayland messages, so text can not be\nlonger than 4000 bytes.\n\nCursor is the byte offset of the cursor within text buffer.\n\nAnchor is the byte offset of the selection anchor within text buffer.\nIf there is no selected text, anchor is the same as cursor.\n\nIf any preedit text is present, it is replaced with a cursor for the\npurpose of this event.\n\nValues set with this request are double-buffered. They will get applied\non the next zwp_text_input_v3.commit request, and stay valid until the\nnext committed enable or disable request.\n\nThe initial state for affected fields is empty, meaning that the text\ninput does not support sending surrounding text. If the empty values\nget applied, subsequent attempts to change them may have no effect.""indicates the cause of surrounding text change\n\nTells the compositor why the text surrounding the cursor changed.\n\nWhenever the client detects an external change in text, cursor, or\nanchor posision, it must issue this request to the compositor. This\nrequest is intended to give the input method a chance to update the\npreedit text in an appropriate way, e.g. by removing it when the user\nstarts typing with a keyboard.\n\ncause describes the source of the change.\n\nThe value set with this request is double-buffered. It must be applied\nand reset to initial at the next zwp_text_input_v3.commit request.\n\nThe initial value of cause is input_method."SetTextChangeCause"set content purpose and hint\n\nSets the content purpose and content hint. While the purpose is the\nbasic purpose of an input field, the hint flags allow to modify some of\nthe behavior.\n\nValues set with this request are double-buffered. They will get applied\non the next zwp_text_input_v3.commit request.\nSubsequent attempts to update them may have no effect. The values\nremain valid until the next committed enable or disable request.\n\nThe initial value for hint is none, and the initial value for purpose\nis normal.""set cursor position\n\nMarks an area around the cursor as a x, y, width, height rectangle in\nsurface local coordinates.\n\nAllows the compositor to put a window with word suggestions near the\ncursor, without obstructing the text being input.\n\nIf the client is unaware of the position of edited text, it should not\nissue this request, to signify lack of support to the compositor.\n\nValues set with this request are double-buffered. They will get applied\non the next zwp_text_input_v3.commit request, and stay valid until the\nnext committed enable or disable request.\n\nThe initial values describing a cursor rectangle are empty. That means\nthe text input does not support describing the cursor area. If the\nempty values get applied, subsequent attempts to change them may have\nno effect.""commit state\n\nAtomically applies state changes recently sent to the compositor.\n\nThe commit request establishes and updates the state of the client, and\nmust be issued after any changes to apply them.\n\nText input state (enabled status, content purpose, content hint,\nsurrounding text and change cause, cursor rectangle) is conceptually\ndouble-buffered within the context of a text input, i.e. between a\ncommitted enable request and the following committed enable or disable\nrequest.\n\nProtocol requests modify the pending state, as opposed to the current\nstate in use by the input method. A commit request atomically applies\nall pending state, replacing the current state. After commit, the new\npending state is as documented for each related request.\n\nRequests are applied in the order of arrival.\n\nNeither current nor pending state are modified unless noted otherwise.\n\nThe compositor must count the number of commit requests coming from\neach zwp_text_input_v3 object and use the count as the serial in done\nevents.""enter event\n\nNotification that this seat's text-input focus is on a certain surface.\n\nIf client has created multiple text input objects, compositor must send\nthis event to all of them.\n\nWhen the seat has the keyboard capability the text-input focus follows\nthe keyboard focus. This event sets the current surface for the\ntext-input object.""leave event\n\nNotification that this seat's text-input focus is no longer on a\ncertain surface. The client should reset any preedit string previously\nset.\n\nThe leave notification clears the current surface. It is sent before\nthe enter notification for the new focus. After leave event, compositor\nmust ignore requests from any text input instances until next enter\nevent.\n\nWhen the seat has the keyboard capability the text-input focus follows\nthe keyboard focus.""pre-edit\n\nNotify when a new composing text (pre-edit) should be set at the\ncurrent cursor position. Any previously set composing text must be\nremoved. Any previously existing selected text must be removed.\n\nThe argument text contains the pre-edit string buffer.\n\nThe parameters cursor_begin and cursor_end are counted in bytes\nrelative to the beginning of the submitted text buffer. Cursor should\nbe hidden when both are equal to -1.\n\nThey could be represented by the client as a line if both values are\nthe same, or as a text highlight otherwise.\n\nValues set with this event are double-buffered. They must be applied\nand reset to initial on the next zwp_text_input_v3.done event.\n\nThe initial value of text is an empty string, and cursor_begin,\ncursor_end and cursor_hidden are all 0."cursor_begincursor_end"text commit\n\nNotify when text should be inserted into the editor widget. The text to\ncommit could be either just a single character after a key press or the\nresult of some composing (pre-edit).\n\nValues set with this event are double-buffered. They must be applied\nand reset to initial on the next zwp_text_input_v3.done event.\n\nThe initial value of text is an empty string.""delete surrounding text\n\nNotify when the text around the current cursor position should be\ndeleted.\n\nBefore_length and after_length are the number of bytes before and after\nthe current cursor index (excluding the selection) to delete.\n\nIf a preedit text is present, in effect before_length is counted from\nthe beginning of it, and after_length from its end (see done event\nsequence).\n\nValues set with this event are double-buffered. They must be applied\nand reset to initial on the next zwp_text_input_v3.done event.\n\nThe initial values of both before_length and after_length are 0.""length of text before current cursor position"before_length"length of text after current cursor position"after_length"apply changes\n\nInstruct the application to apply changes to state requested by the\npreedit_string, commit_string and delete_surrounding_text events. The\nstate relating to these events is double-buffered, and each one\nmodifies the pending state. This event replaces the current state with\nthe pending state.\n\nThe application must proceed by evaluating the changes in the following\norder:\n\n1. Replace existing preedit string with the cursor.\n2. Delete requested surrounding text.\n3. Insert commit string with the cursor at its end.\n4. Calculate surrounding text to send.\n5. Insert new preedit text in cursor position.\n6. Place cursor inside preedit text.\n\nThe serial number reflects the last state of the zwp_text_input_v3\nobject known to the compositor. The value of the serial argument must\nbe equal to the number of commit requests already issued on that object.\n\nWhen the client receives a done event with a serial different than the\nnumber of past commit requests, it must proceed with evaluating and\napplying the changes as normal, except it should not change the current\nstate of the zwp_text_input_v3 object. All pending state requests\n(set_surrounding_text, set_content_type and set_cursor_rectangle) on\nthe zwp_text_input_v3 object should be sent and committed after\nreceiving a zwp_text_input_v3.done event with a matching serial.""text input\n\nThe zwp_text_input_v3 interface represents text input and input methods\nassociated with a seat. It provides enter/leave events to follow the\ntext input focus for a seat.\n\nRequests are used to enable/disable the text-input object and set\nstate information like surrounding and selected text or the content type.\nThe information about the entered text is sent to the text-input object\nvia the preedit_string and commit_string events.\n\nText is valid UTF-8 encoded, indices and lengths are in bytes. Indices\nmust not point to middle bytes inside a code point: they must either\npoint to the first byte of a code point or to the end of the buffer.\nLengths must be measured between two valid indices.\n\nFocus moving throughout surfaces will result in the emission of\nzwp_text_input_v3.enter and zwp_text_input_v3.leave events. The focused\nsurface must commit zwp_text_input_v3.enable and\nzwp_text_input_v3.disable requests as the keyboard focus moves across\neditable and non-editable elements of the UI. Those two requests are not\nexpected to be paired with each other, the compositor must be able to\nhandle consecutive series of the same request.\n\nState is sent by the state requests (set_surrounding_text,\nset_content_type and set_cursor_rectangle) and a commit request. After an\nenter event or disable request all state information is invalidated and\nneeds to be resent by the client.\n\nSee also the [Event] enum for this interface."ZwpTextInputV3"Destroy the wp_text_input\n\nDestroy the wp_text_input object. Also disables all surfaces enabled\nthrough this wp_text_input object."set_text_change_cause"text input manager\n\nA factory for text-input objects. This object is a global singleton."REQ_GET_TEXT_INPUT_SINCEREQ_GET_TEXT_INPUT_OPCODE"Destroy the wp_text_input_manager\n\nDestroy the wp_text_input_manager object.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new text input object\n\nCreates a new text-input object for a given seat."GetTextInput"text input manager\n\nA factory for text-input objects. This object is a global singleton.\n\nThis interface has no events."ZwpTextInputManagerV3"Destroy the wp_text_input_manager\n\nDestroy the wp_text_input_manager object."get_text_inputzwp_text_input_manager_v3/// Unstable version 3//! Text input protocolWP_VIEWPORTER_INTERFACEwp_viewporter_requests_get_viewport_typeswp_viewporter_requestswp_viewporter_interfaceWP_VIEWPORT_INTERFACEwp_viewport_requestswp_viewport_interface"surface cropping and scaling\n\nThe global interface exposing surface cropping and scaling\ncapabilities is used to instantiate an interface extension for a\nwl_surface object. This extended interface will then allow\ncropping and scaling the surface contents, effectively\ndisconnecting the direct relationship between the buffer and the\nsurface size.""the surface already has a viewport object associated"ViewportExistsREQ_GET_VIEWPORT_SINCEREQ_GET_VIEWPORT_OPCODE"unbind from the cropping and scaling interface\n\nInforms the server that the client will not be using this\nprotocol object anymore. This does not affect any other objects,\nwp_viewport objects included.\n\nThis is a destructor, once sent this object cannot be used any longer.""extend surface interface for crop and scale\n\nInstantiate an interface extension for the given wl_surface to\ncrop and scale its content. If the given wl_surface already has\na wp_viewport object associated, the viewport_exists\nprotocol error is raised."GetViewport"surface cropping and scaling\n\nThe global interface exposing surface cropping and scaling\ncapabilities is used to instantiate an interface extension for a\nwl_surface object. This extended interface will then allow\ncropping and scaling the surface contents, effectively\ndisconnecting the direct relationship between the buffer and the\nsurface size.\n\nThis interface has no events."WpViewporter"unbind from the cropping and scaling interface\n\nInforms the server that the client will not be using this\nprotocol object anymore. This does not affect any other objects,\nwp_viewport objects included."wp_viewportWpViewportget_viewportwp_viewporter"crop and scale interface to a wl_surface\n\nAn additional interface to a wl_surface object, which allows the\nclient to specify the cropping and scaling of the surface\ncontents.\n\nThis interface works with two concepts: the source rectangle (src_x,\nsrc_y, src_width, src_height), and the destination size (dst_width,\ndst_height). The contents of the source rectangle are scaled to the\ndestination size, and content outside the source rectangle is ignored.\nThis state is double-buffered, see wl_surface.commit.\n\nThe two parts of crop and scale state are independent: the source\nrectangle, and the destination size. Initially both are unset, that\nis, no scaling is applied. The whole of the current wl_buffer is\nused as the source, and the surface size is as defined in\nwl_surface.attach.\n\nIf the destination size is set, it causes the surface size to become\ndst_width, dst_height. The source (rectangle) is scaled to exactly\nthis size. This overrides whatever the attached wl_buffer size is,\nunless the wl_buffer is NULL. If the wl_buffer is NULL, the surface\nhas no content and therefore no size. Otherwise, the size is always\nat least 1x1 in surface local coordinates.\n\nIf the source rectangle is set, it defines what area of the wl_buffer is\ntaken as the source. If the source rectangle is set and the destination\nsize is not set, then src_width and src_height must be integers, and the\nsurface size becomes the source rectangle size. This results in cropping\nwithout scaling. If src_width or src_height are not integers and\ndestination size is not set, the bad_size protocol error is raised when\nthe surface state is applied.\n\nThe coordinate transformations from buffer pixel coordinates up to\nthe surface-local coordinates happen in the following order:\n1. buffer_transform (wl_surface.set_buffer_transform)\n2. buffer_scale (wl_surface.set_buffer_scale)\n3. crop and scale (wp_viewport.set*)\nThis means, that the source rectangle coordinates of crop and scale\nare given in the coordinates after the buffer transform and scale,\ni.e. in the coordinates that would be the surface-local coordinates\nif the crop and scale was not applied.\n\nIf src_x or src_y are negative, the bad_value protocol error is raised.\nOtherwise, if the source rectangle is partially or completely outside of\nthe non-NULL wl_buffer, then the out_of_buffer protocol error is raised\nwhen the surface state is applied. A NULL wl_buffer does not raise the\nout_of_buffer error.\n\nIf the wl_surface associated with the wp_viewport is destroyed,\nall wp_viewport requests except 'destroy' raise the protocol error\nno_surface.\n\nIf the wp_viewport object is destroyed, the crop and scale\nstate is removed from the wl_surface. The change will be applied\non the next wl_surface.commit.""negative or zero values in width or height""destination size is not integer""source rectangle extends outside of the content area"OutOfBuffer"the wl_surface was destroyed"REQ_SET_SOURCE_SINCEREQ_SET_SOURCE_OPCODEREQ_SET_DESTINATION_SINCEREQ_SET_DESTINATION_OPCODE"remove scaling and cropping from the surface\n\nThe associated wl_surface's crop and scale state is removed.\nThe change is applied on the next wl_surface.commit.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the source rectangle for cropping\n\nSet the source rectangle of the associated wl_surface. See\nwp_viewport for the description, and relation to the wl_buffer\nsize.\n\nIf all of x, y, width and height are -1.0, the source rectangle is\nunset instead. Any other set of values where width or height are zero\nor negative, or x or y are negative, raise the bad_value protocol\nerror.\n\nThe crop and scale state is double-buffered, see wl_surface.commit.""source rectangle x""source rectangle y""source rectangle width""source rectangle height"SetSource"set the surface size for scaling\n\nSet the destination size of the associated wl_surface. See\nwp_viewport for the description, and relation to the wl_buffer\nsize.\n\nIf width is -1 and height is -1, the destination size is unset\ninstead. Any other pair of values for width and height that\ncontains zero or negative values raises the bad_value protocol\nerror.\n\nThe crop and scale state is double-buffered, see wl_surface.commit.""surface width""surface height"SetDestination"crop and scale interface to a wl_surface\n\nAn additional interface to a wl_surface object, which allows the\nclient to specify the cropping and scaling of the surface\ncontents.\n\nThis interface works with two concepts: the source rectangle (src_x,\nsrc_y, src_width, src_height), and the destination size (dst_width,\ndst_height). The contents of the source rectangle are scaled to the\ndestination size, and content outside the source rectangle is ignored.\nThis state is double-buffered, see wl_surface.commit.\n\nThe two parts of crop and scale state are independent: the source\nrectangle, and the destination size. Initially both are unset, that\nis, no scaling is applied. The whole of the current wl_buffer is\nused as the source, and the surface size is as defined in\nwl_surface.attach.\n\nIf the destination size is set, it causes the surface size to become\ndst_width, dst_height. The source (rectangle) is scaled to exactly\nthis size. This overrides whatever the attached wl_buffer size is,\nunless the wl_buffer is NULL. If the wl_buffer is NULL, the surface\nhas no content and therefore no size. Otherwise, the size is always\nat least 1x1 in surface local coordinates.\n\nIf the source rectangle is set, it defines what area of the wl_buffer is\ntaken as the source. If the source rectangle is set and the destination\nsize is not set, then src_width and src_height must be integers, and the\nsurface size becomes the source rectangle size. This results in cropping\nwithout scaling. If src_width or src_height are not integers and\ndestination size is not set, the bad_size protocol error is raised when\nthe surface state is applied.\n\nThe coordinate transformations from buffer pixel coordinates up to\nthe surface-local coordinates happen in the following order:\n1. buffer_transform (wl_surface.set_buffer_transform)\n2. buffer_scale (wl_surface.set_buffer_scale)\n3. crop and scale (wp_viewport.set*)\nThis means, that the source rectangle coordinates of crop and scale\nare given in the coordinates after the buffer transform and scale,\ni.e. in the coordinates that would be the surface-local coordinates\nif the crop and scale was not applied.\n\nIf src_x or src_y are negative, the bad_value protocol error is raised.\nOtherwise, if the source rectangle is partially or completely outside of\nthe non-NULL wl_buffer, then the out_of_buffer protocol error is raised\nwhen the surface state is applied. A NULL wl_buffer does not raise the\nout_of_buffer error.\n\nIf the wl_surface associated with the wp_viewport is destroyed,\nall wp_viewport requests except 'destroy' raise the protocol error\nno_surface.\n\nIf the wp_viewport object is destroyed, the crop and scale\nstate is removed from the wl_surface. The change will be applied\non the next wl_surface.commit.\n\nThis interface has no events.""remove scaling and cropping from the surface\n\nThe associated wl_surface's crop and scale state is removed.\nThe change is applied on the next wl_surface.commit."//! Viewporter protocol//! Provides the capability of scaling and cropping surfaces, decorrelating the surface//! dimensions from the size of the buffer.viewporterWP_SECURITY_CONTEXT_MANAGER_V1_INTERFACEwp_security_context_manager_v1_requests_create_listener_typeswp_security_context_manager_v1_requestswp_security_context_manager_v1_interfaceWP_SECURITY_CONTEXT_V1_INTERFACEwp_security_context_v1_requestswp_security_context_v1_interface"client security context manager\n\nThis interface allows a client to register a new Wayland connection to\nthe compositor and attach a security context to it.\n\nThis is intended to be used by sandboxes. Sandbox engines attach a\nsecurity context to all connections coming from inside the sandbox. The\ncompositor can then restrict the features that the sandboxed connections\ncan use.\n\nCompositors should forbid nesting multiple security contexts by not\nexposing wp_security_context_manager_v1 global to clients with a security\ncontext attached, or by sending the nested protocol error. Nested\nsecurity contexts are dangerous because they can potentially allow\nprivilege escalation of a sandboxed client.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""listening socket FD is invalid"InvalidListenFd"nested security contexts are forbidden"REQ_CREATE_LISTENER_SINCEREQ_CREATE_LISTENER_OPCODE"destroy the manager object\n\nDestroy the manager. This doesn't destroy objects created with the\nmanager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new security context\n\nCreates a new security context with a socket listening FD.\n\nThe compositor will accept new client connections on listen_fd.\nlisten_fd must be ready to accept new connections when this request is\nsent by the client. In other words, the client must call bind(2) and\nlisten(2) before sending the FD.\n\nclose_fd is a FD that will signal hangup when the compositor should stop\naccepting new connections on listen_fd.\n\nThe compositor must continue to accept connections on listen_fd when\nthe Wayland client which created the security context disconnects.\n\nAfter sending this request, closing listen_fd and close_fd remains the\nonly valid operation on them.""listening socket FD"listen_fd"FD signaling when done"close_fdCreateListener"client security context manager\n\nThis interface allows a client to register a new Wayland connection to\nthe compositor and attach a security context to it.\n\nThis is intended to be used by sandboxes. Sandbox engines attach a\nsecurity context to all connections coming from inside the sandbox. The\ncompositor can then restrict the features that the sandboxed connections\ncan use.\n\nCompositors should forbid nesting multiple security contexts by not\nexposing wp_security_context_manager_v1 global to clients with a security\ncontext attached, or by sending the nested protocol error. Nested\nsecurity contexts are dangerous because they can potentially allow\nprivilege escalation of a sandboxed client.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpSecurityContextManagerV1"destroy the manager object\n\nDestroy the manager. This doesn't destroy objects created with the\nmanager."wp_security_context_v1WpSecurityContextV1create_listenerwp_security_context_manager_v1"client security context\n\nThe security context allows a client to register a new client and attach\nsecurity context metadata to the connections.\n\nWhen both are set, the combination of the application ID and the sandbox\nengine must uniquely identify an application. The same application ID\nwill be used across instances (e.g. if the application is restarted, or\nif the application is started multiple times).\n\nWhen both are set, the combination of the instance ID and the sandbox\nengine must uniquely identify a running instance of an application.""security context has already been committed""metadata has already been set""metadata is invalid"REQ_SET_SANDBOX_ENGINE_SINCEREQ_SET_SANDBOX_ENGINE_OPCODEREQ_SET_APP_ID_SINCEREQ_SET_APP_ID_OPCODEREQ_SET_INSTANCE_ID_SINCEREQ_SET_INSTANCE_ID_OPCODE"destroy the security context object\n\nDestroy the security context object.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the sandbox engine\n\nAttach a unique sandbox engine name to the security context. The name\nshould follow the reverse-DNS style (e.g. \"org.flatpak\").\n\nA list of well-known engines is maintained at:\nhttps://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/security-context/engines.md\n\nIt is a protocol error to call this request twice. The already_set\nerror is sent in this case.""the sandbox engine name"SetSandboxEngine"set the application ID\n\nAttach an application ID to the security context.\n\nThe application ID is an opaque, sandbox-specific identifier for an\napplication. See the well-known engines document for more details:\nhttps://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/security-context/engines.md\n\nThe compositor may use the application ID to group clients belonging to\nthe same security context application.\n\nWhether this request is optional or not depends on the sandbox engine used.\n\nIt is a protocol error to call this request twice. The already_set\nerror is sent in this case.""the application ID"SetAppId"set the instance ID\n\nAttach an instance ID to the security context.\n\nThe instance ID is an opaque, sandbox-specific identifier for a running\ninstance of an application. See the well-known engines document for\nmore details:\nhttps://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/security-context/engines.md\n\nWhether this request is optional or not depends on the sandbox engine used.\n\nIt is a protocol error to call this request twice. The already_set\nerror is sent in this case.""the instance ID"SetInstanceId"register the security context\n\nAtomically register the new client and attach the security context\nmetadata.\n\nIf the provided metadata is inconsistent or does not match with out of\nband metadata (see\nhttps://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/security-context/engines.md),\nthe invalid_metadata error may be sent eventually.\n\nIt's a protocol error to send any request other than \"destroy\" after\nthis request. In this case, the already_used error is sent.""client security context\n\nThe security context allows a client to register a new client and attach\nsecurity context metadata to the connections.\n\nWhen both are set, the combination of the application ID and the sandbox\nengine must uniquely identify an application. The same application ID\nwill be used across instances (e.g. if the application is restarted, or\nif the application is started multiple times).\n\nWhen both are set, the combination of the instance ID and the sandbox\nengine must uniquely identify a running instance of an application.\n\nThis interface has no events.""destroy the security context object\n\nDestroy the security context object."set_sandbox_engineset_instance_id//! This interface allows a client to register a new Wayland connection to//! the compositor and attach a security context to it.//! This is intended to be used by sandboxes. Sandbox engines attach a//! security context to all connections coming from inside the sandbox. The//! compositor can then restrict the features that the sandboxed connections//! can use.//! Compositors should forbid nesting multiple security contexts by not//! exposing wp_security_context_manager_v1 global to clients with a security//! context attached, or by sending the nested protocol error. Nested//! security contexts are dangerous because they can potentially allow//! privilege escalation of a sandboxed client.security_contextWP_ALPHA_MODIFIER_V1_INTERFACEwp_alpha_modifier_v1_requests_get_surface_typeswp_alpha_modifier_v1_requestswp_alpha_modifier_v1_interfaceWP_ALPHA_MODIFIER_SURFACE_V1_INTERFACEwp_alpha_modifier_surface_v1_requestswp_alpha_modifier_surface_v1_interface"surface alpha modifier manager\n\nThis interface allows a client to set a factor for the alpha values on a\nsurface, which can be used to offload such operations to the compositor,\nwhich can in turn for example offload them to KMS.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""wl_surface already has a alpha modifier object""destroy the alpha modifier manager object\n\nDestroy the alpha modifier manager. This doesn't destroy objects\ncreated with the manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new alpha modifier surface object\n\nCreate a new alpha modifier surface object associated with the\ngiven wl_surface. If there is already such an object associated with\nthe wl_surface, the already_constructed error will be raised.""surface alpha modifier manager\n\nThis interface allows a client to set a factor for the alpha values on a\nsurface, which can be used to offload such operations to the compositor,\nwhich can in turn for example offload them to KMS.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpAlphaModifierV1"destroy the alpha modifier manager object\n\nDestroy the alpha modifier manager. This doesn't destroy objects\ncreated with the manager."wp_alpha_modifier_surface_v1WpAlphaModifierSurfaceV1wp_alpha_modifier_v1"alpha modifier object for a surface\n\nThis interface allows the client to set a factor for the alpha values on\na surface, which can be used to offload such operations to the compositor.\nThe default factor is UINT32_MAX.\n\nThis object has to be destroyed before the associated wl_surface. Once the\nwl_surface is destroyed, all request on this object will raise the\nno_surface error.""wl_surface was destroyed"REQ_SET_MULTIPLIER_SINCEREQ_SET_MULTIPLIER_OPCODE"destroy the alpha modifier object\n\nThis destroys the object, and is equivalent to set_multiplier with\na value of UINT32_MAX, with the same double-buffered semantics as\nset_multiplier.\n\nThis is a destructor, once sent this object cannot be used any longer.""specify the alpha multiplier\n\nSets the alpha multiplier for the surface. The alpha multiplier is\ndouble-buffered state, see wl_surface.commit for details.\n\nThis factor is applied in the compositor's blending space, as an\nadditional step after the processing of per-pixel alpha values for the\nwl_surface. The exact meaning of the factor is thus undefined, unless\nthe blending space is specified in a different extension.\n\nThis multiplier is applied even if the buffer attached to the\nwl_surface doesn't have an alpha channel; in that case an alpha value\nof one is used instead.\n\nZero means completely transparent, UINT32_MAX means completely opaque."SetMultiplier"alpha modifier object for a surface\n\nThis interface allows the client to set a factor for the alpha values on\na surface, which can be used to offload such operations to the compositor.\nThe default factor is UINT32_MAX.\n\nThis object has to be destroyed before the associated wl_surface. Once the\nwl_surface is destroyed, all request on this object will raise the\nno_surface error.\n\nThis interface has no events.""destroy the alpha modifier object\n\nThis destroys the object, and is equivalent to set_multiplier with\na value of UINT32_MAX, with the same double-buffered semantics as\nset_multiplier."set_multiplier//! This interface allows a client to set a factor for the alpha values on a//! surface, which can be used to offload such operations to the compositor,//! which can in turn for example offload them to KMS.alpha_modifierWP_FIFO_MANAGER_V1_INTERFACEwp_fifo_manager_v1_requests_get_fifo_typeswp_fifo_manager_v1_requestswp_fifo_manager_v1_interfaceWP_FIFO_V1_INTERFACEwp_fifo_v1_requestswp_fifo_v1_interface"protocol for fifo constraints\n\nWhen a Wayland compositor considers applying a content update,\nit must ensure all the update's readiness constraints (fences, etc)\nare met.\n\nThis protocol provides a way to use the completion of a display refresh\ncycle as an additional readiness constraint.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""fatal presentation error\n\nThese fatal protocol errors may be emitted in response to\nillegal requests.""fifo manager already exists for surface"REQ_GET_FIFO_SINCEREQ_GET_FIFO_OPCODE"unbind from the manager interface\n\nInforms the server that the client will no longer be using\nthis protocol object. Existing objects created by this object\nare not affected.\n\nThis is a destructor, once sent this object cannot be used any longer.""request fifo interface for surface\n\nEstablish a fifo object for a surface that may be used to add\ndisplay refresh constraints to content updates.\n\nOnly one such object may exist for a surface and attempting\nto create more than one will result in an already_exists\nprotocol error. If a surface is acted on by multiple software\ncomponents, general best practice is that only the component\nperforming wl_surface.attach operations should use this protocol."GetFifo"protocol for fifo constraints\n\nWhen a Wayland compositor considers applying a content update,\nit must ensure all the update's readiness constraints (fences, etc)\nare met.\n\nThis protocol provides a way to use the completion of a display refresh\ncycle as an additional readiness constraint.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpFifoManagerV1"unbind from the manager interface\n\nInforms the server that the client will no longer be using\nthis protocol object. Existing objects created by this object\nare not affected."wp_fifo_v1WpFifoV1get_fifowp_fifo_manager_v1"fifo interface\n\nA fifo object for a surface that may be used to add\ndisplay refresh constraints to content updates.""fatal error\n\nThese fatal protocol errors may be emitted in response to\nillegal requests.""the associated surface no longer exists"REQ_SET_BARRIER_SINCEREQ_SET_BARRIER_OPCODEREQ_WAIT_BARRIER_SINCEREQ_WAIT_BARRIER_OPCODE"sets the start point for a fifo constraint\n\nWhen the content update containing the \"set_barrier\" is applied,\nit sets a \"fifo_barrier\" condition on the surface associated with\nthe fifo object. The condition is cleared immediately after the\nfollowing latching deadline for non-tearing presentation.\n\nThe compositor may clear the condition early if it must do so to\nensure client forward progress assumptions.\n\nTo wait for this condition to clear, use the \"wait_barrier\" request.\n\n\"set_barrier\" is double-buffered state, see wl_surface.commit.\n\nRequesting set_barrier after the fifo object's surface is\ndestroyed will generate a \"surface_destroyed\" error."SetBarrier"adds a fifo constraint to a content update\n\nIndicate that this content update is not ready while a\n\"fifo_barrier\" condition is present on the surface.\n\nThis means that when the content update containing \"set_barrier\"\nwas made active at a latching deadline, it will be active for\nat least one refresh cycle. A content update which is allowed to\ntear might become active after a latching deadline if no content\nupdate became active at the deadline.\n\nThe constraint must be ignored if the surface is a subsurface in\nsynchronized mode. If the surface is not being updated by the\ncompositor (off-screen, occluded) the compositor may ignore the\nconstraint. Clients must use an additional mechanism such as\nframe callbacks or timestamps to ensure throttling occurs under\nall conditions.\n\n\"wait_barrier\" is double-buffered state, see wl_surface.commit.\n\nRequesting \"wait_barrier\" after the fifo object's surface is\ndestroyed will generate a \"surface_destroyed\" error."WaitBarrier"destroy the fifo interface\n\nInforms the server that the client will no longer be using\nthis protocol object.\n\nSurface state changes previously made by this protocol are\nunaffected by this object's destruction.\n\nThis is a destructor, once sent this object cannot be used any longer.""fifo interface\n\nA fifo object for a surface that may be used to add\ndisplay refresh constraints to content updates.\n\nThis interface has no events."set_barrierwait_barrier"destroy the fifo interface\n\nInforms the server that the client will no longer be using\nthis protocol object.\n\nSurface state changes previously made by this protocol are\nunaffected by this object's destruction."//! When a Wayland compositor considers applying a content update,//! it must ensure all the update's readiness constraints (fences, etc)//! are met.//! This protocol provides a way to use the completion of a display refresh//! cycle as an additional readiness constraint.WP_COMMIT_TIMING_MANAGER_V1_INTERFACEwp_commit_timing_manager_v1_requests_get_timer_typeswp_commit_timing_manager_v1_requestswp_commit_timing_manager_v1_interfaceWP_COMMIT_TIMER_V1_INTERFACEwp_commit_timer_v1_requestswp_commit_timer_v1_interface"commit timing\n\nWhen a compositor latches on to new content updates it will check for\nany number of requirements of the available content updates (such as\nfences of all buffers being signalled) to consider the update ready.\n\nThis protocol provides a method for adding a time constraint to surface\ncontent. This constraint indicates to the compositor that a content\nupdate should be presented as closely as possible to, but not before,\na specified time.\n\nThis protocol does not change the Wayland property that content\nupdates are applied in the order they are received, even when some\ncontent updates contain timestamps and others do not.\n\nTo provide timestamps, this global factory interface must be used to\nacquire a wp_commit_timing_v1 object for a surface, which may then be\nused to provide timestamp information for commits.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""commit timer already exists for surface"CommitTimerExistsREQ_GET_TIMER_SINCEREQ_GET_TIMER_OPCODE"unbind from the commit timing interface\n\nInforms the server that the client will no longer be using\nthis protocol object. Existing objects created by this object\nare not affected.\n\nThis is a destructor, once sent this object cannot be used any longer.""request commit timer interface for surface\n\nEstablish a timing controller for a surface.\n\nOnly one commit timer can be created for a surface, or a\ncommit_timer_exists protocol error will be generated."GetTimer"commit timing\n\nWhen a compositor latches on to new content updates it will check for\nany number of requirements of the available content updates (such as\nfences of all buffers being signalled) to consider the update ready.\n\nThis protocol provides a method for adding a time constraint to surface\ncontent. This constraint indicates to the compositor that a content\nupdate should be presented as closely as possible to, but not before,\na specified time.\n\nThis protocol does not change the Wayland property that content\nupdates are applied in the order they are received, even when some\ncontent updates contain timestamps and others do not.\n\nTo provide timestamps, this global factory interface must be used to\nacquire a wp_commit_timing_v1 object for a surface, which may then be\nused to provide timestamp information for commits.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpCommitTimingManagerV1"unbind from the commit timing interface\n\nInforms the server that the client will no longer be using\nthis protocol object. Existing objects created by this object\nare not affected."wp_commit_timer_v1WpCommitTimerV1get_timerwp_commit_timing_manager_v1"Surface commit timer\n\nAn object to set a time constraint for a content update on a surface.""timestamp contains an invalid value""timestamp exists"TimestampExistsREQ_SET_TIMESTAMP_SINCEREQ_SET_TIMESTAMP_OPCODE"Specify time the following commit takes effect\n\nProvide a timing constraint for a surface content update.\n\nA set_timestamp request may be made before a wl_surface.commit to\ntell the compositor that the content is intended to be presented\nas closely as possible to, but not before, the specified time.\nThe time is in the domain of the compositor's presentation clock.\n\nAn invalid_timestamp error will be generated for invalid tv_nsec.\n\nIf a timestamp already exists on the surface, a timestamp_exists\nerror is generated.\n\nRequesting set_timestamp after the commit_timer object's surface is\ndestroyed will generate a \"surface_destroyed\" error.""high 32 bits of the seconds part of target time""low 32 bits of the seconds part of target time""nanoseconds part of target time"SetTimestamp"Destroy the timer\n\nInforms the server that the client will no longer be using\nthis protocol object.\n\nExisting timing constraints are not affected by the destruction.\n\nThis is a destructor, once sent this object cannot be used any longer.""Surface commit timer\n\nAn object to set a time constraint for a content update on a surface.\n\nThis interface has no events.""Destroy the timer\n\nInforms the server that the client will no longer be using\nthis protocol object.\n\nExisting timing constraints are not affected by the destruction."//! When a compositor latches on to new content updates it will check for//! any number of requirements of the available content updates (such as//! fences of all buffers being signalled) to consider the update ready.//! This protocol provides a method for adding a time constraint to surface//! content. This constraint indicates to the compositor that a content//! update should be presented as closely as possible to, but not before,//! a specified time.//! This protocol does not change the Wayland property that content//! updates are applied in the order they are received, even when some//! content updates contain timestamps and others do not.//! To provide timestamps, this global factory interface must be used to//! acquire a `wp_commit_timing_v1` object for a surface, which may then be//! used to provide timestamp information for commits.commit_timingWP_POINTER_WARP_V1_INTERFACEwp_pointer_warp_v1_requests_warp_pointer_typeswp_pointer_warp_v1_requestswp_pointer_warp_v1_interface"reposition the pointer to a location on a surface\n\nThis global interface allows applications to request the pointer to be\nmoved to a position relative to a wl_surface.\n\nNote that if the desired behavior is to constrain the pointer to an area\nor lock it to a position, this protocol does not provide a reliable way\nto do that. The pointer constraint and pointer lock protocols should be\nused for those use cases instead.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension."REQ_WARP_POINTER_SINCEREQ_WARP_POINTER_OPCODE"destroy the warp manager\n\nDestroy the pointer warp manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""reposition the pointer\n\nRequest the compositor to move the pointer to a surface-local position.\nWhether or not the compositor honors the request is implementation defined,\nbut it should\n- honor it if the surface has pointer focus, including\nwhen it has an implicit pointer grab\n- reject it if the enter serial is incorrect\n- reject it if the requested position is outside of the surface\n\nNote that the enter serial is valid for any surface of the client,\nand does not have to be from the surface the pointer is warped to.""surface to position the pointer on""the pointer that should be repositioned"WarpPointer"reposition the pointer to a location on a surface\n\nThis global interface allows applications to request the pointer to be\nmoved to a position relative to a wl_surface.\n\nNote that if the desired behavior is to constrain the pointer to an area\nor lock it to a position, this protocol does not provide a reliable way\nto do that. The pointer constraint and pointer lock protocols should be\nused for those use cases instead.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."WpPointerWarpV1"destroy the warp manager\n\nDestroy the pointer warp manager."warp_pointerwp_pointer_warp_v1//! This global interface allows applications to request the pointer to be//! moved to a position relative to a wl_surface.//! Note that if the desired behavior is to constrain the pointer to an area//! or lock it to a position, this protocol does not provide a reliable way//! to do that. The pointer constraint and pointer lock protocols should be//! used for those use cases instead.pointer_warp//! Generic wayland protocolsXDG_ACTIVATION_V1_INTERFACExdg_activation_v1_requests_get_activation_token_typesxdg_activation_v1_requests_activate_typesxdg_activation_v1_requestsxdg_activation_v1_interfaceXDG_ACTIVATION_TOKEN_V1_INTERFACExdg_activation_token_v1_requests_set_serial_typesxdg_activation_token_v1_requests_set_surface_typesxdg_activation_token_v1_requestsxdg_activation_token_v1_eventsxdg_activation_token_v1_interface"interface for activating surfaces\n\nA global interface used for informing the compositor about applications\nbeing activated or started, or for applications to request to be\nactivated."REQ_GET_ACTIVATION_TOKEN_SINCEREQ_GET_ACTIVATION_TOKEN_OPCODE"destroy the xdg_activation object\n\nNotify the compositor that the xdg_activation object will no longer be\nused.\n\nThe child objects created via this interface are unaffected and should\nbe destroyed separately.\n\nThis is a destructor, once sent this object cannot be used any longer.""requests a token\n\nCreates an xdg_activation_token_v1 object that will provide\nthe initiating client with a unique token for this activation. This\ntoken should be offered to the clients to be activated."GetActivationToken"notify new interaction being available\n\nRequests surface activation. It's up to the compositor to display\nthis information as desired, for example by placing the surface above\nthe rest.\n\nThe compositor may know who requested this by checking the activation\ntoken and might decide not to follow through with the activation if it's\nconsidered unwanted.\n\nCompositors can ignore unknown activation tokens when an invalid\ntoken is passed.""the activation token of the initiating client""the wl_surface to activate""interface for activating surfaces\n\nA global interface used for informing the compositor about applications\nbeing activated or started, or for applications to request to be\nactivated.\n\nThis interface has no events.""destroy the xdg_activation object\n\nNotify the compositor that the xdg_activation object will no longer be\nused.\n\nThe child objects created via this interface are unaffected and should\nbe destroyed separately."get_activation_token"an exported activation handle\n\nAn object for setting up a token and receiving a token handle that can\nbe passed as an activation token to another client.\n\nThe object is created using the xdg_activation_v1.get_activation_token\nrequest. This object should then be populated with the app_id, surface\nand serial information and committed. The compositor shall then issue a\ndone event with the token. In case the request's parameters are invalid,\nthe compositor will provide an invalid token.""The token has already been used previously"REQ_SET_SERIAL_SINCEREQ_SET_SERIAL_OPCODEREQ_SET_SURFACE_SINCEREQ_SET_SURFACE_OPCODE"specifies the seat and serial of the activating event\n\nProvides information about the seat and serial event that requested the\ntoken.\n\nThe serial can come from an input or focus event. For instance, if a\nclick triggers the launch of a third-party client, the launcher client\nshould send a set_serial request with the serial and seat from the\nwl_pointer.button event.\n\nSome compositors might refuse to activate toplevels when the token\ndoesn't have a valid and recent enough event serial.\n\nMust be sent before commit. This information is optional.""the serial of the event that triggered the activation""the wl_seat of the event"SetSerial"specifies the application being activated\n\nThe requesting client can specify an app_id to associate the token\nbeing created with it.\n\nMust be sent before commit. This information is optional.""the application id of the client being activated.""specifies the surface requesting activation\n\nThis request sets the surface requesting the activation. Note, this is\ndifferent from the surface that will be activated.\n\nSome compositors might refuse to activate toplevels when the token\ndoesn't have a requesting surface.\n\nMust be sent before commit. This information is optional.""the requesting surface"SetSurface"issues the token request\n\nRequests an activation token based on the different parameters that\nhave been offered through set_serial, set_surface and set_app_id.""destroy the xdg_activation_token_v1 object\n\nNotify the compositor that the xdg_activation_token_v1 object will no\nlonger be used. The received token stays valid.\n\nThis is a destructor, once sent this object cannot be used any longer.""the exported activation token\n\nThe 'done' event contains the unique token of this activation request\nand notifies that the provider is done.""the exported activation token""an exported activation handle\n\nAn object for setting up a token and receiving a token handle that can\nbe passed as an activation token to another client.\n\nThe object is created using the xdg_activation_v1.get_activation_token\nrequest. This object should then be populated with the app_id, surface\nand serial information and committed. The compositor shall then issue a\ndone event with the token. In case the request's parameters are invalid,\nthe compositor will provide an invalid token.\n\nSee also the [Event] enum for this interface.""destroy the xdg_activation_token_v1 object\n\nNotify the compositor that the xdg_activation_token_v1 object will no\nlonger be used. The received token stays valid."//! The way for a client to pass focus to another toplevel is as follows.//! The client that intends to activate another toplevel uses the//! xdg_activation_v1.get_activation_token request to get an activation token.//! This token is then passed to the client to be activated through a separate//! band of communication. The client to be activated will then pass the token//! it received to the xdg_activation_v1.activate request. The compositor can//! then use this token to decide how to react to the activation request.//! The token the activating client gets may be ineffective either already at//! the time it receives it, for example if it was not focused, for focus//! stealing prevention. The activating client will have no way to discover//! the validity of the token, and may still forward it to the to be activated//! client.//! The created activation token may optionally get information attached to it//! that can be used by the compositor to identify the application that we//! intend to activate. This can for example be used to display a visual hint//! about what application is being started.ZXDG_DECORATION_MANAGER_V1_INTERFACEzxdg_decoration_manager_v1_requests_get_toplevel_decoration_typeszxdg_decoration_manager_v1_requestszxdg_decoration_manager_v1_interfaceZXDG_TOPLEVEL_DECORATION_V1_INTERFACEzxdg_toplevel_decoration_v1_requestszxdg_toplevel_decoration_v1_eventszxdg_toplevel_decoration_v1_interface"window decoration manager\n\nThis interface allows a compositor to announce support for server-side\ndecorations.\n\nA window decoration is a set of window controls as deemed appropriate by\nthe party managing them, such as user interface components used to move,\nresize and change a window's state.\n\nA client can use this protocol to request being decorated by a supporting\ncompositor.\n\nIf compositor and client do not negotiate the use of a server-side\ndecoration using this protocol, clients continue to self-decorate as they\nsee fit.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset."REQ_GET_TOPLEVEL_DECORATION_SINCEREQ_GET_TOPLEVEL_DECORATION_OPCODE"destroy the decoration manager object\n\nDestroy the decoration manager. This doesn't destroy objects created\nwith the manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new toplevel decoration object\n\nCreate a new decoration object associated with the given toplevel.\n\nCreating an xdg_toplevel_decoration from an xdg_toplevel which has a\nbuffer attached or committed is a client error, and any attempts by a\nclient to attach or manipulate a buffer prior to the first\nxdg_toplevel_decoration.configure event must also be treated as\nerrors."GetToplevelDecoration"window decoration manager\n\nThis interface allows a compositor to announce support for server-side\ndecorations.\n\nA window decoration is a set of window controls as deemed appropriate by\nthe party managing them, such as user interface components used to move,\nresize and change a window's state.\n\nA client can use this protocol to request being decorated by a supporting\ncompositor.\n\nIf compositor and client do not negotiate the use of a server-side\ndecoration using this protocol, clients continue to self-decorate as they\nsee fit.\n\nWarning! The protocol described in this file is experimental and\nbackward incompatible changes may be made. Backward compatible changes\nmay be added together with the corresponding interface version bump.\nBackward incompatible changes are done by bumping the version number in\nthe protocol and interface names and resetting the interface version.\nOnce the protocol is to be declared stable, the 'z' prefix and the\nversion number in the protocol and interface names are removed and the\ninterface version number is reset.\n\nThis interface has no events.""destroy the decoration manager object\n\nDestroy the decoration manager. This doesn't destroy objects created\nwith the manager."get_toplevel_decoration"decoration object for a toplevel surface\n\nThe decoration object allows the compositor to toggle server-side window\ndecorations for a toplevel surface. The client can request to switch to\nanother mode.\n\nThe xdg_toplevel_decoration object must be destroyed before its\nxdg_toplevel.""xdg_toplevel has a buffer attached before configure"UnconfiguredBuffer"xdg_toplevel already has a decoration object""xdg_toplevel destroyed before the decoration object"Orphaned"invalid mode"InvalidMode"window decoration modes\n\nThese values describe window decoration modes.""no server-side window decoration"ClientSide"server-side window decoration"ServerSideREQ_SET_MODE_SINCEREQ_SET_MODE_OPCODEREQ_UNSET_MODE_SINCEREQ_UNSET_MODE_OPCODE"destroy the decoration object\n\nSwitch back to a mode without any server-side decorations at the next\ncommit.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the decoration mode\n\nSet the toplevel surface decoration mode. This informs the compositor\nthat the client prefers the provided decoration mode.\n\nAfter requesting a decoration mode, the compositor will respond by\nemitting an xdg_surface.configure event. The client should then update\nits content, drawing it without decorations if the received mode is\nserver-side decorations. The client must also acknowledge the configure\nwhen committing the new content (see xdg_surface.ack_configure).\n\nThe compositor can decide not to use the client's mode and enforce a\ndifferent mode instead.\n\nClients whose decoration mode depend on the xdg_toplevel state may send\na set_mode request in response to an xdg_surface.configure event and wait\nfor the next xdg_surface.configure event to prevent unwanted state.\nSuch clients are responsible for preventing configure loops and must\nmake sure not to send multiple successive set_mode requests with the\nsame decoration mode.\n\nIf an invalid mode is supplied by the client, the invalid_mode protocol\nerror is raised by the compositor.""the decoration mode"SetMode"unset the decoration mode\n\nUnset the toplevel surface decoration mode. This informs the compositor\nthat the client doesn't prefer a particular decoration mode.\n\nThis request has the same semantics as set_mode."UnsetMode"notify a decoration mode change\n\nThe configure event configures the effective decoration mode. The\nconfigured state should not be applied immediately. Clients must send an\nack_configure in response to this event. See xdg_surface.configure and\nxdg_surface.ack_configure for details.\n\nA configure event can be sent at any time. The specified mode must be\nobeyed by the client.""decoration object for a toplevel surface\n\nThe decoration object allows the compositor to toggle server-side window\ndecorations for a toplevel surface. The client can request to switch to\nanother mode.\n\nThe xdg_toplevel_decoration object must be destroyed before its\nxdg_toplevel.\n\nSee also the [Event] enum for this interface.""destroy the decoration object\n\nSwitch back to a mode without any server-side decorations at the next\ncommit."unset_mode//! This interface allows a compositor to announce support for server-side//! decorations.//! A window decoration is a set of window controls as deemed appropriate by//! the party managing them, such as user interface components used to move,//! resize and change a window's state.//! A client can use this protocol to request being decorated by a supporting//! compositor.//! If compositor and client do not negotiate the use of a server-side//! decoration using this protocol, clients continue to self-decorate as they//! see fit.ZXDG_EXPORTER_V1_INTERFACEzxdg_exporter_v1_requests_export_typeszxdg_exporter_v1_requestszxdg_exporter_v1_interfaceZXDG_IMPORTER_V1_INTERFACEzxdg_importer_v1_requests_import_typeszxdg_importer_v1_requestszxdg_importer_v1_interfaceZXDG_EXPORTED_V1_INTERFACEzxdg_exported_v1_requestszxdg_exported_v1_eventszxdg_exported_v1_interfaceZXDG_IMPORTED_V1_INTERFACEzxdg_imported_v1_requests_set_parent_of_typeszxdg_imported_v1_requestszxdg_imported_v1_eventszxdg_imported_v1_interface"interface for exporting surfaces\n\nA global interface used for exporting surfaces that can later be imported\nusing xdg_importer."REQ_EXPORT_SINCEREQ_EXPORT_OPCODE"destroy the xdg_exporter object\n\nNotify the compositor that the xdg_exporter object will no longer be\nused.\n\nThis is a destructor, once sent this object cannot be used any longer.""export a surface\n\nThe export request exports the passed surface so that it can later be\nimported via xdg_importer. When called, a new xdg_exported object will\nbe created and xdg_exported.handle will be sent immediately. See the\ncorresponding interface and event for details.\n\nA surface may be exported multiple times, and each exported handle may\nbe used to create an xdg_imported multiple times. Only xdg_surface\nsurfaces may be exported.""the surface to export""interface for exporting surfaces\n\nA global interface used for exporting surfaces that can later be imported\nusing xdg_importer.\n\nThis interface has no events."ZxdgExporterV1"destroy the xdg_exporter object\n\nNotify the compositor that the xdg_exporter object will no longer be\nused."zxdg_exported_v1ZxdgExportedV1zxdg_exporter_v1"interface for importing surfaces\n\nA global interface used for importing surfaces exported by xdg_exporter.\nWith this interface, a client can create a reference to a surface of\nanother client."REQ_IMPORT_SINCEREQ_IMPORT_OPCODE"destroy the xdg_importer object\n\nNotify the compositor that the xdg_importer object will no longer be\nused.\n\nThis is a destructor, once sent this object cannot be used any longer.""import a surface\n\nThe import request imports a surface from any client given a handle\nretrieved by exporting said surface using xdg_exporter.export. When\ncalled, a new xdg_imported object will be created. This new object\nrepresents the imported surface, and the importing client can\nmanipulate its relationship using it. See xdg_imported for details.""the exported surface handle""interface for importing surfaces\n\nA global interface used for importing surfaces exported by xdg_exporter.\nWith this interface, a client can create a reference to a surface of\nanother client.\n\nThis interface has no events."ZxdgImporterV1"destroy the xdg_importer object\n\nNotify the compositor that the xdg_importer object will no longer be\nused."zxdg_imported_v1ZxdgImportedV1zxdg_importer_v1"an exported surface handle\n\nAn xdg_exported object represents an exported reference to a surface. The\nexported surface may be referenced as long as the xdg_exported object not\ndestroyed. Destroying the xdg_exported invalidates any relationship the\nimporter may have established using xdg_imported."EVT_HANDLE_SINCEEVT_HANDLE_OPCODE"unexport the exported surface\n\nRevoke the previously exported surface. This invalidates any\nrelationship the importer may have set up using the xdg_imported created\ngiven the handle sent via xdg_exported.handle.\n\nThis is a destructor, once sent this object cannot be used any longer.""the exported surface handle\n\nThe handle event contains the unique handle of this exported surface\nreference. It may be shared with any client, which then can use it to\nimport the surface by calling xdg_importer.import. A handle may be\nused to import the surface multiple times.""an exported surface handle\n\nAn xdg_exported object represents an exported reference to a surface. The\nexported surface may be referenced as long as the xdg_exported object not\ndestroyed. Destroying the xdg_exported invalidates any relationship the\nimporter may have established using xdg_imported.\n\nSee also the [Event] enum for this interface.""unexport the exported surface\n\nRevoke the previously exported surface. This invalidates any\nrelationship the importer may have set up using the xdg_imported created\ngiven the handle sent via xdg_exported.handle.""an imported surface handle\n\nAn xdg_imported object represents an imported reference to surface exported\nby some client. A client can use this interface to manipulate\nrelationships between its own surfaces and the imported surface."REQ_SET_PARENT_OF_SINCEREQ_SET_PARENT_OF_OPCODEEVT_DESTROYED_SINCEEVT_DESTROYED_OPCODE"destroy the xdg_imported object\n\nNotify the compositor that it will no longer use the xdg_imported\nobject. Any relationship that may have been set up will at this point\nbe invalidated.\n\nThis is a destructor, once sent this object cannot be used any longer.""set as the parent of some surface\n\nSet the imported surface as the parent of some surface of the client.\nThe passed surface must be a toplevel xdg_surface. Calling this function\nsets up a surface to surface relation with the same stacking and positioning\nsemantics as xdg_surface.set_parent.""the child surface"SetParentOf"the imported surface handle has been destroyed\n\nThe imported surface handle has been destroyed and any relationship set\nup has been invalidated. This may happen for various reasons, for\nexample if the exported surface or the exported surface handle has been\ndestroyed, if the handle used for importing was invalid.""an imported surface handle\n\nAn xdg_imported object represents an imported reference to surface exported\nby some client. A client can use this interface to manipulate\nrelationships between its own surfaces and the imported surface.\n\nSee also the [Event] enum for this interface.""destroy the xdg_imported object\n\nNotify the compositor that it will no longer use the xdg_imported\nobject. Any relationship that may have been set up will at this point\nbe invalidated."set_parent_ofZXDG_EXPORTER_V2_INTERFACEzxdg_exporter_v2_requests_export_toplevel_typeszxdg_exporter_v2_requestszxdg_exporter_v2_interfaceZXDG_IMPORTER_V2_INTERFACEzxdg_importer_v2_requests_import_toplevel_typeszxdg_importer_v2_requestszxdg_importer_v2_interfaceZXDG_EXPORTED_V2_INTERFACEzxdg_exported_v2_requestszxdg_exported_v2_eventszxdg_exported_v2_interfaceZXDG_IMPORTED_V2_INTERFACEzxdg_imported_v2_requests_set_parent_of_typeszxdg_imported_v2_requestszxdg_imported_v2_eventszxdg_imported_v2_interface"error values\n\nThese errors can be emitted in response to invalid xdg_exporter\nrequests.""surface is not an xdg_toplevel"InvalidSurfaceREQ_EXPORT_TOPLEVEL_SINCEREQ_EXPORT_TOPLEVEL_OPCODE"export a toplevel surface\n\nThe export_toplevel request exports the passed surface so that it can later be\nimported via xdg_importer. When called, a new xdg_exported object will\nbe created and xdg_exported.handle will be sent immediately. See the\ncorresponding interface and event for details.\n\nA surface may be exported multiple times, and each exported handle may\nbe used to create an xdg_imported multiple times. Only xdg_toplevel\nequivalent surfaces may be exported, otherwise an invalid_surface\nprotocol error is sent."ExportToplevelZxdgExporterV2zxdg_exported_v2ZxdgExportedV2export_toplevelzxdg_exporter_v2REQ_IMPORT_TOPLEVEL_SINCEREQ_IMPORT_TOPLEVEL_OPCODE"import a toplevel surface\n\nThe import_toplevel request imports a surface from any client given a handle\nretrieved by exporting said surface using xdg_exporter.export_toplevel.\nWhen called, a new xdg_imported object will be created. This new object\nrepresents the imported surface, and the importing client can\nmanipulate its relationship using it. See xdg_imported for details."ImportToplevelZxdgImporterV2zxdg_imported_v2ZxdgImportedV2import_toplevelzxdg_importer_v2"the exported surface handle\n\nThe handle event contains the unique handle of this exported surface\nreference. It may be shared with any client, which then can use it to\nimport the surface by calling xdg_importer.import_toplevel. A handle\nmay be used to import the surface multiple times.""error values\n\nThese errors can be emitted in response to invalid xdg_imported\nrequests.""set as the parent of some surface\n\nSet the imported surface as the parent of some surface of the client.\nThe passed surface must be an xdg_toplevel equivalent, otherwise an\ninvalid_surface protocol error is sent. Calling this function sets up\na surface to surface relation with the same stacking and positioning\nsemantics as xdg_toplevel.set_parent."//! Protocol for exporting xdg surface handles//! This protocol specifies a way for making it possible to reference a surface//! of a different client. With such a reference, a client can, by using the//! interfaces provided by this protocol, manipulate the relationship between//! its own surfaces and the surface of some other client. For example, stack//! some of its own surface above the other clients surface.//! In order for a client A to get a reference of a surface of client B, client//! B must first export its surface using xdg_exporter.export. Upon doing this,//! client B will receive a handle (a unique string) that it may share with//! client A in some way (for example D-Bus). After client A has received the//! handle from client B, it may use xdg_importer.import to create a reference//! to the surface client B just exported. See the corresponding requests for//! A possible use case for this is out-of-process dialogs. For example when a//! sandboxed client without file system access needs the user to select a file//! on the file system, given sandbox environment support, it can export its//! surface, passing the exported surface handle to an unsandboxed process that//! can show a file browser dialog and stack it above the sandboxed client's//! surface.foreignZXDG_OUTPUT_MANAGER_V1_INTERFACEzxdg_output_manager_v1_requests_get_xdg_output_typeszxdg_output_manager_v1_requestszxdg_output_manager_v1_interfaceZXDG_OUTPUT_V1_INTERFACEzxdg_output_v1_requestszxdg_output_v1_eventszxdg_output_v1_interface"manage xdg_output objects\n\nA global factory interface for xdg_output objects."REQ_GET_XDG_OUTPUT_SINCEREQ_GET_XDG_OUTPUT_OPCODE"destroy the xdg_output_manager object\n\nUsing this request a client can tell the server that it is not\ngoing to use the xdg_output_manager object anymore.\n\nAny objects already created through this instance are not affected.\n\nThis is a destructor, once sent this object cannot be used any longer.""create an xdg output from a wl_output\n\nThis creates a new xdg_output object for the given wl_output."GetXdgOutput"manage xdg_output objects\n\nA global factory interface for xdg_output objects.\n\nThis interface has no events.""destroy the xdg_output_manager object\n\nUsing this request a client can tell the server that it is not\ngoing to use the xdg_output_manager object anymore.\n\nAny objects already created through this instance are not affected."get_xdg_output"compositor logical output region\n\nAn xdg_output describes part of the compositor geometry.\n\nThis typically corresponds to a monitor that displays part of the\ncompositor space.\n\nFor objects version 3 onwards, after all xdg_output properties have been\nsent (when the object is created and when properties are updated), a\nwl_output.done event is sent. This allows changes to the output\nproperties to be seen as atomic, even if they happen via multiple events."EVT_LOGICAL_POSITION_SINCEEVT_LOGICAL_POSITION_OPCODEEVT_LOGICAL_SIZE_SINCEEVT_LOGICAL_SIZE_OPCODE"destroy the xdg_output object\n\nUsing this request a client can tell the server that it is not\ngoing to use the xdg_output object anymore.\n\nThis is a destructor, once sent this object cannot be used any longer.""position of the output within the global compositor space\n\nThe position event describes the location of the wl_output within\nthe global compositor space.\n\nThe logical_position event is sent after creating an xdg_output\n(see xdg_output_manager.get_xdg_output) and whenever the location\nof the output changes within the global compositor space.""size of the output in the global compositor space\n\nThe logical_size event describes the size of the output in the\nglobal compositor space.\n\nMost regular Wayland clients should not pay attention to the\nlogical size and would rather rely on xdg_shell interfaces.\n\nSome clients such as Xwayland, however, need this to configure\ntheir surfaces in the global compositor space as the compositor\nmay apply a different scale from what is advertised by the output\nscaling property (to achieve fractional scaling, for example).\n\nFor example, for a wl_output mode 3840×2160 and a scale factor 2:\n\n- A compositor not scaling the monitor viewport in its compositing space\nwill advertise a logical size of 3840×2160,\n\n- A compositor scaling the monitor viewport with scale factor 2 will\nadvertise a logical size of 1920×1080,\n\n- A compositor scaling the monitor viewport using a fractional scale of\n1.5 will advertise a logical size of 2560×1440.\n\nFor example, for a wl_output mode 1920×1080 and a 90 degree rotation,\nthe compositor will advertise a logical size of 1080x1920.\n\nThe logical_size event is sent after creating an xdg_output\n(see xdg_output_manager.get_xdg_output) and whenever the logical\nsize of the output changes, either as a result of a change in the\napplied scale or because of a change in the corresponding output\nmode(see wl_output.mode) or transform (see wl_output.transform).""width in global compositor space""height in global compositor space""all information about the output have been sent\n\nThis event is sent after all other properties of an xdg_output\nhave been sent.\n\nThis allows changes to the xdg_output properties to be seen as\natomic, even if they happen via multiple events.\n\nFor objects version 3 onwards, this event is deprecated. Compositors\nare not required to send it anymore and must send wl_output.done\ninstead.""name of this output\n\nMany compositors will assign names to their outputs, show them to the\nuser, allow them to be configured by name, etc. The client may wish to\nknow this name as well to offer the user similar behaviors.\n\nThe naming convention is compositor defined, but limited to\nalphanumeric characters and dashes (-). Each name is unique among all\nwl_output globals, but if a wl_output global is destroyed the same name\nmay be reused later. The names will also remain consistent across\nsessions with the same hardware and software configuration.\n\nExamples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do\nnot assume that the name is a reflection of an underlying DRM\nconnector, X11 connection, etc.\n\nThe name event is sent after creating an xdg_output (see\nxdg_output_manager.get_xdg_output). This event is only sent once per\nxdg_output, and the name does not change over the lifetime of the\nwl_output global.\n\nThis event is deprecated, instead clients should use wl_output.name.\nCompositors must still support this event.\n\nOnly available since version 2 of the interface""human-readable description of this output\n\nMany compositors can produce human-readable descriptions of their\noutputs.  The client may wish to know this description as well, to\ncommunicate the user for various purposes.\n\nThe description is a UTF-8 string with no convention defined for its\ncontents. Examples might include 'Foocorp 11\" Display' or 'Virtual X11\noutput via :1'.\n\nThe description event is sent after creating an xdg_output (see\nxdg_output_manager.get_xdg_output) and whenever the description\nchanges. The description is optional, and may not be sent at all.\n\nFor objects of version 2 and lower, this event is only sent once per\nxdg_output, and the description does not change over the lifetime of\nthe wl_output global.\n\nThis event is deprecated, instead clients should use\nwl_output.description. Compositors must still support this event.\n\nOnly available since version 2 of the interface""compositor logical output region\n\nAn xdg_output describes part of the compositor geometry.\n\nThis typically corresponds to a monitor that displays part of the\ncompositor space.\n\nFor objects version 3 onwards, after all xdg_output properties have been\nsent (when the object is created and when properties are updated), a\nwl_output.done event is sent. This allows changes to the output\nproperties to be seen as atomic, even if they happen via multiple events.\n\nSee also the [Event] enum for this interface.""destroy the xdg_output object\n\nUsing this request a client can tell the server that it is not\ngoing to use the xdg_output object anymore."//! Protocol to describe output regions//! This protocol aims at describing outputs in a way which is more in line//! with the concept of an output on desktop oriented systems.//! Some information are more specific to the concept of an output for//! a desktop oriented system and may not make sense in other applications,//! such as IVI systems for example.//! Typically, the global compositor space on a desktop system is made of//! a contiguous or overlapping set of rectangular regions.//! Some of the information provided in this protocol might be identical//! to their counterparts already available from wl_output, in which case//! the information provided by this protocol should be preferred to their//! equivalent in wl_output. The goal is to move the desktop specific//! concepts (such as output location within the global compositor space,//! the connector name and types, etc.) out of the core wl_output protocol.XDG_WM_BASE_INTERFACExdg_wm_base_requests_create_positioner_typesxdg_wm_base_requests_get_xdg_surface_typesxdg_wm_base_requestsxdg_wm_base_eventsxdg_wm_base_interfaceXDG_POSITIONER_INTERFACExdg_positioner_requestsxdg_positioner_interfaceXDG_SURFACE_INTERFACExdg_surface_requests_get_toplevel_typesxdg_surface_requests_get_popup_typesxdg_surface_requestsxdg_surface_eventsxdg_surface_interfaceXDG_TOPLEVEL_INTERFACExdg_toplevel_requests_set_parent_typesxdg_toplevel_requests_show_window_menu_typesxdg_toplevel_requests_move_typesxdg_toplevel_requests_resize_typesxdg_toplevel_requests_set_fullscreen_typesxdg_toplevel_requestsxdg_toplevel_eventsxdg_toplevel_interfaceXDG_POPUP_INTERFACExdg_popup_requests_grab_typesxdg_popup_requests_reposition_typesxdg_popup_requestsxdg_popup_eventsxdg_popup_interface"create desktop-style surfaces\n\nThe xdg_wm_base interface is exposed as a global object enabling clients\nto turn their wl_surfaces into windows in a desktop environment. It\ndefines the basic functionality needed for clients and the compositor to\ncreate windows that can be dragged, resized, maximized, etc, as well as\ncreating transient windows such as popup menus.""xdg_wm_base was destroyed before children"DefunctSurfaces"the client tried to map or destroy a non-topmost popup"NotTheTopmostPopup"the client specified an invalid popup parent surface"InvalidPopupParent"the client provided an invalid surface state"InvalidSurfaceState"the client provided an invalid positioner"InvalidPositioner"the client didn’t respond to a ping event in time"UnresponsiveREQ_CREATE_POSITIONER_SINCEREQ_CREATE_POSITIONER_OPCODEREQ_GET_XDG_SURFACE_SINCEREQ_GET_XDG_SURFACE_OPCODE"destroy xdg_wm_base\n\nDestroy this xdg_wm_base object.\n\nDestroying a bound xdg_wm_base object while there are surfaces\nstill alive created by this xdg_wm_base object instance is illegal\nand will result in a defunct_surfaces error.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a positioner object\n\nCreate a positioner object. A positioner object is used to position\nsurfaces relative to some parent surface. See the interface description\nand xdg_surface.get_popup for details."CreatePositioner"create a shell surface from a surface\n\nThis creates an xdg_surface for the given surface. While xdg_surface\nitself is not a role, the corresponding surface may only be assigned\na role extending xdg_surface, such as xdg_toplevel or xdg_popup. It is\nillegal to create an xdg_surface for a wl_surface which already has an\nassigned role and this will result in a role error.\n\nThis creates an xdg_surface for the given surface. An xdg_surface is\nused as basis to define a role to a given surface, such as xdg_toplevel\nor xdg_popup. It also manages functionality shared between xdg_surface\nbased surface roles.\n\nSee the documentation of xdg_surface for more details about what an\nxdg_surface is and how it is used."GetXdgSurface"respond to a ping event\n\nA client must respond to a ping event with a pong request or\nthe client may be deemed unresponsive. See xdg_wm_base.ping\nand xdg_wm_base.error.unresponsive.""serial of the ping event""check if the client is alive\n\nThe ping event asks the client if it's still alive. Pass the\nserial specified in the event back to the compositor by sending\na \"pong\" request back with the specified serial. See xdg_wm_base.pong.\n\nCompositors can use this to determine if the client is still\nalive. It's unspecified what will happen if the client doesn't\nrespond to the ping request, or in what timeframe. Clients should\ntry to respond in a reasonable amount of time. The “unresponsive”\nerror is provided for compositors that wish to disconnect unresponsive\nclients.\n\nA compositor is free to ping in any way it wants, but a client must\nalways respond to any xdg_wm_base object it created.""pass this to the pong request""create desktop-style surfaces\n\nThe xdg_wm_base interface is exposed as a global object enabling clients\nto turn their wl_surfaces into windows in a desktop environment. It\ndefines the basic functionality needed for clients and the compositor to\ncreate windows that can be dragged, resized, maximized, etc, as well as\ncreating transient windows such as popup menus.\n\nSee also the [Event] enum for this interface.""destroy xdg_wm_base\n\nDestroy this xdg_wm_base object.\n\nDestroying a bound xdg_wm_base object while there are surfaces\nstill alive created by this xdg_wm_base object instance is illegal\nand will result in a defunct_surfaces error."create_positionerget_xdg_surface"child surface positioner\n\nThe xdg_positioner provides a collection of rules for the placement of a\nchild surface relative to a parent surface. Rules can be defined to ensure\nthe child surface remains within the visible area's borders, and to\nspecify how the child surface changes its position, such as sliding along\nan axis, or flipping around a rectangle. These positioner-created rules are\nconstrained by the requirement that a child surface must intersect with or\nbe at least partially adjacent to its parent surface.\n\nSee the various requests for details about possible rules.\n\nAt the time of the request, the compositor makes a copy of the rules\nspecified by the xdg_positioner. Thus, after the request is complete the\nxdg_positioner object can be destroyed or reused; further changes to the\nobject will have no effect on previous usages.\n\nFor an xdg_positioner object to be considered complete, it must have a\nnon-zero size set by set_size, and a non-zero anchor rectangle set by\nset_anchor_rect. Passing an incomplete xdg_positioner object when\npositioning a surface raises an invalid_positioner error.""invalid input provided""constraint adjustments\n\nThe constraint adjustment value define ways the compositor will adjust\nthe position of the surface, if the unadjusted position would result\nin the surface being partly constrained.\n\nWhether a surface is considered 'constrained' is left to the compositor\nto determine. For example, the surface may be partly outside the\ncompositor's defined 'work area', thus necessitating the child surface's\nposition be adjusted until it is entirely inside the work area.\n\nThe adjustments can be combined, according to a defined precedence: 1)\nFlip, 2) Slide, 3) Resize."ConstraintAdjustment"don't move the child surface when constrained\n\nDon't alter the surface position even if it is constrained on some\naxis, for example partially outside the edge of an output.""move along the x axis until unconstrained\n\nSlide the surface along the x axis until it is no longer constrained.\n\nFirst try to slide towards the direction of the gravity on the x axis\nuntil either the edge in the opposite direction of the gravity is\nunconstrained or the edge in the direction of the gravity is\nconstrained.\n\nThen try to slide towards the opposite direction of the gravity on the\nx axis until either the edge in the direction of the gravity is\nunconstrained or the edge in the opposite direction of the gravity is\nconstrained."SlideX"move along the y axis until unconstrained\n\nSlide the surface along the y axis until it is no longer constrained.\n\nFirst try to slide towards the direction of the gravity on the y axis\nuntil either the edge in the opposite direction of the gravity is\nunconstrained or the edge in the direction of the gravity is\nconstrained.\n\nThen try to slide towards the opposite direction of the gravity on the\ny axis until either the edge in the direction of the gravity is\nunconstrained or the edge in the opposite direction of the gravity is\nconstrained."SlideY"invert the anchor and gravity on the x axis\n\nInvert the anchor and gravity on the x axis if the surface is\nconstrained on the x axis. For example, if the left edge of the\nsurface is constrained, the gravity is 'left' and the anchor is\n'left', change the gravity to 'right' and the anchor to 'right'.\n\nIf the adjusted position also ends up being constrained, the resulting\nposition of the flip_x adjustment will be the one before the\nadjustment."FlipX"invert the anchor and gravity on the y axis\n\nInvert the anchor and gravity on the y axis if the surface is\nconstrained on the y axis. For example, if the bottom edge of the\nsurface is constrained, the gravity is 'bottom' and the anchor is\n'bottom', change the gravity to 'top' and the anchor to 'top'.\n\nThe adjusted position is calculated given the original anchor\nrectangle and offset, but with the new flipped anchor and gravity\nvalues.\n\nIf the adjusted position also ends up being constrained, the resulting\nposition of the flip_y adjustment will be the one before the\nadjustment."FlipY"horizontally resize the surface\n\nResize the surface horizontally so that it is completely\nunconstrained."ResizeX"vertically resize the surface\n\nResize the surface vertically so that it is completely unconstrained."ResizeYREQ_SET_SIZE_SINCEREQ_SET_SIZE_OPCODEREQ_SET_ANCHOR_RECT_SINCEREQ_SET_ANCHOR_RECT_OPCODEREQ_SET_ANCHOR_SINCEREQ_SET_ANCHOR_OPCODEREQ_SET_GRAVITY_SINCEREQ_SET_GRAVITY_OPCODEREQ_SET_CONSTRAINT_ADJUSTMENT_SINCEREQ_SET_CONSTRAINT_ADJUSTMENT_OPCODEREQ_SET_OFFSET_SINCEREQ_SET_OFFSET_OPCODEREQ_SET_REACTIVE_SINCEREQ_SET_REACTIVE_OPCODEREQ_SET_PARENT_SIZE_SINCEREQ_SET_PARENT_SIZE_OPCODEREQ_SET_PARENT_CONFIGURE_SINCEREQ_SET_PARENT_CONFIGURE_OPCODE"destroy the xdg_positioner object\n\nNotify the compositor that the xdg_positioner will no longer be used.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the size of the to-be positioned rectangle\n\nSet the size of the surface that is to be positioned with the positioner\nobject. The size is in surface-local coordinates and corresponds to the\nwindow geometry. See xdg_surface.set_window_geometry.\n\nIf a zero or negative size is set the invalid_input error is raised.""width of positioned rectangle""height of positioned rectangle"SetSize"set the anchor rectangle within the parent surface\n\nSpecify the anchor rectangle within the parent surface that the child\nsurface will be placed relative to. The rectangle is relative to the\nwindow geometry as defined by xdg_surface.set_window_geometry of the\nparent surface.\n\nWhen the xdg_positioner object is used to position a child surface, the\nanchor rectangle may not extend outside the window geometry of the\npositioned child's parent surface.\n\nIf a negative size is set the invalid_input error is raised.""x position of anchor rectangle""y position of anchor rectangle""width of anchor rectangle""height of anchor rectangle"SetAnchorRect"set anchor rectangle anchor\n\nDefines the anchor point for the anchor rectangle. The specified anchor\nis used derive an anchor point that the child surface will be\npositioned relative to. If a corner anchor is set (e.g. 'top_left' or\n'bottom_right'), the anchor point will be at the specified corner;\notherwise, the derived anchor point will be centered on the specified\nedge, or in the center of the anchor rectangle if no edge is specified.""anchor"SetAnchor"set child surface gravity\n\nDefines in what direction a surface should be positioned, relative to\nthe anchor point of the parent surface. If a corner gravity is\nspecified (e.g. 'bottom_right' or 'top_left'), then the child surface\nwill be placed towards the specified gravity; otherwise, the child\nsurface will be centered over the anchor point on any axis that had no\ngravity specified. If the gravity is not in the ‘gravity’ enum, an\ninvalid_input error is raised.""gravity direction"SetGravity"set the adjustment to be done when constrained\n\nSpecify how the window should be positioned if the originally intended\nposition caused the surface to be constrained, meaning at least\npartially outside positioning boundaries set by the compositor. The\nadjustment is set by constructing a bitmask describing the adjustment to\nbe made when the surface is constrained on that axis.\n\nIf no bit for one axis is set, the compositor will assume that the child\nsurface should not change its position on that axis when constrained.\n\nIf more than one bit for one axis is set, the order of how adjustments\nare applied is specified in the corresponding adjustment descriptions.\n\nThe default adjustment is none.""bit mask of constraint adjustments"constraint_adjustmentSetConstraintAdjustment"set surface position offset\n\nSpecify the surface position offset relative to the position of the\nanchor on the anchor rectangle and the anchor on the surface. For\nexample if the anchor of the anchor rectangle is at (x, y), the surface\nhas the gravity bottom|right, and the offset is (ox, oy), the calculated\nsurface position will be (x + ox, y + oy). The offset position of the\nsurface is the one used for constraint testing. See\nset_constraint_adjustment.\n\nAn example use case is placing a popup menu on top of a user interface\nelement, while aligning the user interface element of the parent surface\nwith some user interface element placed somewhere in the popup surface.""surface position x offset""surface position y offset"SetOffset"continuously reconstrain the surface\n\nWhen set reactive, the surface is reconstrained if the conditions used\nfor constraining changed, e.g. the parent window moved.\n\nIf the conditions changed and the popup was reconstrained, an\nxdg_popup.configure event is sent with updated geometry, followed by an\nxdg_surface.configure event.\n\nOnly available since version 3 of the interface"SetReactive"Set the parent window geometry the compositor should use when\npositioning the popup. The compositor may use this information to\ndetermine the future state the popup should be constrained using. If\nthis doesn't match the dimension of the parent the popup is eventually\npositioned against, the behavior is undefined.\n\nThe arguments are given in the surface-local coordinate space.\n\nOnly available since version 3 of the interface""future window geometry width of parent"parent_width"future window geometry height of parent"parent_heightSetParentSize"set parent configure this is a response to\n\nSet the serial of an xdg_surface.configure event this positioner will be\nused in response to. The compositor may use this information together\nwith set_parent_size to determine what future state the popup should be\nconstrained using.\n\nOnly available since version 3 of the interface""serial of parent configure event"SetParentConfigure"child surface positioner\n\nThe xdg_positioner provides a collection of rules for the placement of a\nchild surface relative to a parent surface. Rules can be defined to ensure\nthe child surface remains within the visible area's borders, and to\nspecify how the child surface changes its position, such as sliding along\nan axis, or flipping around a rectangle. These positioner-created rules are\nconstrained by the requirement that a child surface must intersect with or\nbe at least partially adjacent to its parent surface.\n\nSee the various requests for details about possible rules.\n\nAt the time of the request, the compositor makes a copy of the rules\nspecified by the xdg_positioner. Thus, after the request is complete the\nxdg_positioner object can be destroyed or reused; further changes to the\nobject will have no effect on previous usages.\n\nFor an xdg_positioner object to be considered complete, it must have a\nnon-zero size set by set_size, and a non-zero anchor rectangle set by\nset_anchor_rect. Passing an incomplete xdg_positioner object when\npositioning a surface raises an invalid_positioner error.\n\nThis interface has no events.""destroy the xdg_positioner object\n\nNotify the compositor that the xdg_positioner will no longer be used."set_anchor_rectset_constraint_adjustment"continuously reconstrain the surface\n\nWhen set reactive, the surface is reconstrained if the conditions used\nfor constraining changed, e.g. the parent window moved.\n\nIf the conditions changed and the popup was reconstrained, an\nxdg_popup.configure event is sent with updated geometry, followed by an\nxdg_surface.configure event."set_reactive"Set the parent window geometry the compositor should use when\npositioning the popup. The compositor may use this information to\ndetermine the future state the popup should be constrained using. If\nthis doesn't match the dimension of the parent the popup is eventually\npositioned against, the behavior is undefined.\n\nThe arguments are given in the surface-local coordinate space."set_parent_size"set parent configure this is a response to\n\nSet the serial of an xdg_surface.configure event this positioner will be\nused in response to. The compositor may use this information together\nwith set_parent_size to determine what future state the popup should be\nconstrained using."set_parent_configure"desktop user interface surface base interface\n\nAn interface that may be implemented by a wl_surface, for\nimplementations that provide a desktop-style user interface.\n\nIt provides a base set of functionality required to construct user\ninterface elements requiring management by the compositor, such as\ntoplevel windows, menus, etc. The types of functionality are split into\nxdg_surface roles.\n\nCreating an xdg_surface does not set the role for a wl_surface. In order\nto map an xdg_surface, the client must create a role-specific object\nusing, e.g., get_toplevel, get_popup. The wl_surface for any given\nxdg_surface can have at most one role, and may not be assigned any role\nnot based on xdg_surface.\n\nA role must be assigned before any other requests are made to the\nxdg_surface object.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor the xdg_surface state to take effect.\n\nCreating an xdg_surface from a wl_surface which has a buffer attached or\ncommitted is a client error, and any attempts by a client to attach or\nmanipulate a buffer prior to the first xdg_surface.configure call must\nalso be treated as errors.\n\nAfter creating a role-specific object and setting it up (e.g. by sending\nthe title, app ID, size constraints, parent, etc), the client must\nperform an initial commit without any buffer attached. The compositor\nwill reply with initial wl_surface state such as\nwl_surface.preferred_buffer_scale followed by an xdg_surface.configure\nevent. The client must acknowledge it and is then allowed to attach a\nbuffer to map the surface.\n\nMapping an xdg_surface-based role surface is defined as making it\npossible for the surface to be shown by the compositor. Note that\na mapped surface is not guaranteed to be visible once it is mapped.\n\nFor an xdg_surface to be mapped by the compositor, the following\nconditions must be met:\n(1) the client has assigned an xdg_surface-based role to the surface\n(2) the client has set and committed the xdg_surface state and the\nrole-dependent state to the surface\n(3) the client has committed a buffer to the surface\n\nA newly-unmapped surface is considered to have met condition (1) out\nof the 3 required conditions for mapping a surface if its role surface\nhas not been destroyed, i.e. the client must perform the initial commit\nagain before attaching a buffer.""Surface was not fully constructed""Surface was already constructed""Attaching a buffer to an unconfigured surface""Invalid serial number when acking a configure event""Width or height was zero or negative""Surface was destroyed before its role object"REQ_GET_TOPLEVEL_SINCEREQ_GET_TOPLEVEL_OPCODEREQ_GET_POPUP_SINCEREQ_GET_POPUP_OPCODEREQ_SET_WINDOW_GEOMETRY_SINCEREQ_SET_WINDOW_GEOMETRY_OPCODE"destroy the xdg_surface\n\nDestroy the xdg_surface object. An xdg_surface must only be destroyed\nafter its role object has been destroyed, otherwise\na defunct_role_object error is raised.\n\nThis is a destructor, once sent this object cannot be used any longer.""assign the xdg_toplevel surface role\n\nThis creates an xdg_toplevel object for the given xdg_surface and gives\nthe associated wl_surface the xdg_toplevel role.\n\nSee the documentation of xdg_toplevel for more details about what an\nxdg_toplevel is and how it is used."GetToplevel"assign the xdg_popup surface role\n\nThis creates an xdg_popup object for the given xdg_surface and gives\nthe associated wl_surface the xdg_popup role.\n\nIf null is passed as a parent, a parent surface must be specified using\nsome other protocol, before committing the initial state.\n\nSee the documentation of xdg_popup for more details about what an\nxdg_popup is and how it is used."positionerGetPopup"set the new window geometry\n\nThe window geometry of a surface is its \"visible bounds\" from the\nuser's perspective. Client-side decorations often have invisible\nportions like drop-shadows which should be ignored for the\npurposes of aligning, placing and constraining windows.\n\nThe window geometry is double-buffered state, see wl_surface.commit.\n\nWhen maintaining a position, the compositor should treat the (x, y)\ncoordinate of the window geometry as the top left corner of the window.\nA client changing the (x, y) window geometry coordinate should in\ngeneral not alter the position of the window.\n\nOnce the window geometry of the surface is set, it is not possible to\nunset it, and it will remain the same until set_window_geometry is\ncalled again, even if a new subsurface or buffer is attached.\n\nIf never set, the value is the full bounds of the surface,\nincluding any subsurfaces. This updates dynamically on every\ncommit. This unset is meant for extremely simple clients.\n\nThe arguments are given in the surface-local coordinate space of\nthe wl_surface associated with this xdg_surface, and may extend outside\nof the wl_surface itself to mark parts of the subsurface tree as part of\nthe window geometry.\n\nWhen applied, the effective window geometry will be the set window\ngeometry clamped to the bounding rectangle of the combined\ngeometry of the surface of the xdg_surface and the associated\nsubsurfaces.\n\nThe effective geometry will not be recalculated unless a new call to\nset_window_geometry is done and the new pending surface state is\nsubsequently applied.\n\nThe width and height of the effective window geometry must be\ngreater than zero. Setting an invalid size will raise an\ninvalid_size error."SetWindowGeometry"ack a configure event\n\nWhen a configure event is received, if a client commits the\nsurface in response to the configure event, then the client\nmust make an ack_configure request sometime before the commit\nrequest, passing along the serial of the configure event.\n\nFor instance, for toplevel surfaces the compositor might use this\ninformation to move a surface to the top left only when the client has\ndrawn itself for the maximized or fullscreen state.\n\nIf the client receives multiple configure events before it\ncan respond to one, it only has to ack the last configure event.\nAcking a configure event that was never sent raises an invalid_serial\nerror.\n\nA client is not required to commit immediately after sending\nan ack_configure request - it may even ack_configure several times\nbefore its next surface commit.\n\nA client may send multiple ack_configure requests before committing, but\nonly the last request sent before a commit indicates which configure\nevent the client really is responding to.\n\nSending an ack_configure request consumes the serial number sent with\nthe request, as well as serial numbers sent by all configure events\nsent on this xdg_surface prior to the configure event referenced by\nthe committed serial.\n\nIt is an error to issue multiple ack_configure requests referencing a\nserial from the same configure event, or to issue an ack_configure\nrequest referencing a serial from a configure event issued before the\nevent identified by the last ack_configure request for the same\nxdg_surface. Doing so will raise an invalid_serial error.""the serial from the configure event""suggest a surface change\n\nThe configure event marks the end of a configure sequence. A configure\nsequence is a set of one or more events configuring the state of the\nxdg_surface, including the final xdg_surface.configure event.\n\nWhere applicable, xdg_surface surface roles will during a configure\nsequence extend this event as a latched state sent as events before the\nxdg_surface.configure event. Such events should be considered to make up\na set of atomically applied configuration states, where the\nxdg_surface.configure commits the accumulated state.\n\nClients should arrange their surface for the new states, and then send\nan ack_configure request with the serial sent in this configure event at\nsome point before committing the new surface.\n\nIf the client receives multiple configure events before it can respond\nto one, it is free to discard all but the last event it received.""serial of the configure event""desktop user interface surface base interface\n\nAn interface that may be implemented by a wl_surface, for\nimplementations that provide a desktop-style user interface.\n\nIt provides a base set of functionality required to construct user\ninterface elements requiring management by the compositor, such as\ntoplevel windows, menus, etc. The types of functionality are split into\nxdg_surface roles.\n\nCreating an xdg_surface does not set the role for a wl_surface. In order\nto map an xdg_surface, the client must create a role-specific object\nusing, e.g., get_toplevel, get_popup. The wl_surface for any given\nxdg_surface can have at most one role, and may not be assigned any role\nnot based on xdg_surface.\n\nA role must be assigned before any other requests are made to the\nxdg_surface object.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor the xdg_surface state to take effect.\n\nCreating an xdg_surface from a wl_surface which has a buffer attached or\ncommitted is a client error, and any attempts by a client to attach or\nmanipulate a buffer prior to the first xdg_surface.configure call must\nalso be treated as errors.\n\nAfter creating a role-specific object and setting it up (e.g. by sending\nthe title, app ID, size constraints, parent, etc), the client must\nperform an initial commit without any buffer attached. The compositor\nwill reply with initial wl_surface state such as\nwl_surface.preferred_buffer_scale followed by an xdg_surface.configure\nevent. The client must acknowledge it and is then allowed to attach a\nbuffer to map the surface.\n\nMapping an xdg_surface-based role surface is defined as making it\npossible for the surface to be shown by the compositor. Note that\na mapped surface is not guaranteed to be visible once it is mapped.\n\nFor an xdg_surface to be mapped by the compositor, the following\nconditions must be met:\n(1) the client has assigned an xdg_surface-based role to the surface\n(2) the client has set and committed the xdg_surface state and the\nrole-dependent state to the surface\n(3) the client has committed a buffer to the surface\n\nA newly-unmapped surface is considered to have met condition (1) out\nof the 3 required conditions for mapping a surface if its role surface\nhas not been destroyed, i.e. the client must perform the initial commit\nagain before attaching a buffer.\n\nSee also the [Event] enum for this interface.""destroy the xdg_surface\n\nDestroy the xdg_surface object. An xdg_surface must only be destroyed\nafter its role object has been destroyed, otherwise\na defunct_role_object error is raised."get_toplevel"toplevel surface\n\nThis interface defines an xdg_surface role which allows a surface to,\namong other things, set window-like properties such as maximize,\nfullscreen, and minimize, set application-specific metadata like title and\nid, and well as trigger user interactive operations such as interactive\nresize and move.\n\nA xdg_toplevel by default is responsible for providing the full intended\nvisual representation of the toplevel, which depending on the window\nstate, may mean things like a title bar, window controls and drop shadow.\n\nUnmapping an xdg_toplevel means that the surface cannot be shown\nby the compositor until it is explicitly mapped again.\nAll active operations (e.g., move, resize) are canceled and all\nattributes (e.g. title, state, stacking, ...) are discarded for\nan xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to\nthe state it had right after xdg_surface.get_toplevel. The client\ncan re-map the toplevel by performing a commit without any buffer\nattached, waiting for a configure event and handling it as usual (see\nxdg_surface description).\n\nAttaching a null buffer to a toplevel unmaps the surface.""provided value is not a valid variant of the resize_edge enum"InvalidResizeEdge"invalid parent toplevel"InvalidParent"client provided an invalid min or max size""edge values for resizing\n\nThese values are used to indicate which edge of a surface\nis being dragged in a resize operation.""types of state on the surface\n\nThe different state values used on the surface. This is designed for\nstate values like maximized, fullscreen. It is paired with the\nconfigure event to ensure that both the client and the compositor\nsetting the state can be synchronized.\n\nStates set in this way are double-buffered, see wl_surface.commit.""the surface is maximized\n\nThe surface is maximized. The window geometry specified in the configure\nevent must be obeyed by the client, or the xdg_wm_base.invalid_surface_state\nerror is raised.\n\nThe client should draw without shadow or other\ndecoration outside of the window geometry.""the surface is fullscreen\n\nThe surface is fullscreen. The window geometry specified in the\nconfigure event is a maximum; the client cannot resize beyond it. For\na surface to cover the whole fullscreened area, the geometry\ndimensions must be obeyed by the client. For more details, see\nxdg_toplevel.set_fullscreen.""the surface is being resized\n\nThe surface is being resized. The window geometry specified in the\nconfigure event is a maximum; the client cannot resize beyond it.\nClients that have aspect ratio or cell sizing configuration can use\na smaller size, however."Resizing"the surface is now activated\n\nClient window decorations should be painted as if the window is\nactive. Do not assume this means that the window actually has\nkeyboard or pointer focus."Activated"the surface’s left edge is tiled\n\nThe window is currently in a tiled layout and the left edge is\nconsidered to be adjacent to another part of the tiling grid.\n\nThe client should draw without shadow or other decoration outside of\nthe window geometry on the left edge."TiledLeft"the surface’s right edge is tiled\n\nThe window is currently in a tiled layout and the right edge is\nconsidered to be adjacent to another part of the tiling grid.\n\nThe client should draw without shadow or other decoration outside of\nthe window geometry on the right edge."TiledRight"the surface’s top edge is tiled\n\nThe window is currently in a tiled layout and the top edge is\nconsidered to be adjacent to another part of the tiling grid.\n\nThe client should draw without shadow or other decoration outside of\nthe window geometry on the top edge."TiledTop"the surface’s bottom edge is tiled\n\nThe window is currently in a tiled layout and the bottom edge is\nconsidered to be adjacent to another part of the tiling grid.\n\nThe client should draw without shadow or other decoration outside of\nthe window geometry on the bottom edge."TiledBottom"surface repaint is suspended\n\nThe surface is currently not ordinarily being repainted; for\nexample because its content is occluded by another window, or its\noutputs are switched off due to screen locking.""the surface’s left edge is constrained\n\nThe left edge of the window is currently constrained, meaning it\nshouldn't attempt to resize from that edge. It can for example mean\nit's tiled next to a monitor edge on the constrained side of the\nwindow."ConstrainedLeft"the surface’s right edge is constrained\n\nThe right edge of the window is currently constrained, meaning it\nshouldn't attempt to resize from that edge. It can for example mean\nit's tiled next to a monitor edge on the constrained side of the\nwindow."ConstrainedRight"the surface’s top edge is constrained\n\nThe top edge of the window is currently constrained, meaning it\nshouldn't attempt to resize from that edge. It can for example mean\nit's tiled next to a monitor edge on the constrained side of the\nwindow."ConstrainedTop"the surface’s bottom edge is constrained\n\nThe bottom edge of the window is currently constrained, meaning it\nshouldn't attempt to resize from that edge. It can for example mean\nit's tiled next to a monitor edge on the constrained side of the\nwindow."ConstrainedBottom"show_window_menu is available"WindowMenu"set_maximized and unset_maximized are available""set_fullscreen and unset_fullscreen are available""set_minimized is available"REQ_SET_PARENT_SINCEREQ_SET_PARENT_OPCODEREQ_SHOW_WINDOW_MENU_SINCEREQ_SHOW_WINDOW_MENU_OPCODEREQ_SET_MAX_SIZE_SINCEREQ_SET_MAX_SIZE_OPCODEREQ_SET_MIN_SIZE_SINCEREQ_SET_MIN_SIZE_OPCODEREQ_UNSET_MAXIMIZED_SINCEREQ_UNSET_MAXIMIZED_OPCODEREQ_UNSET_FULLSCREEN_SINCEREQ_UNSET_FULLSCREEN_OPCODEREQ_SET_MINIMIZED_SINCEREQ_SET_MINIMIZED_OPCODEEVT_CLOSE_SINCEEVT_CLOSE_OPCODEEVT_CONFIGURE_BOUNDS_SINCEEVT_CONFIGURE_BOUNDS_OPCODEEVT_WM_CAPABILITIES_SINCEEVT_WM_CAPABILITIES_OPCODE"destroy the xdg_toplevel\n\nThis request destroys the role surface and unmaps the surface;\nsee \"Unmapping\" behavior in interface section for details.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the parent of this surface\n\nSet the \"parent\" of this surface. This surface should be stacked\nabove the parent surface and all other ancestor surfaces.\n\nParent surfaces should be set on dialogs, toolboxes, or other\n\"auxiliary\" surfaces, so that the parent is raised when the dialog\nis raised.\n\nSetting a null parent for a child surface unsets its parent. Setting\na null parent for a surface which currently has no parent is a no-op.\n\nOnly mapped surfaces can have child surfaces. Setting a parent which\nis not mapped is equivalent to setting a null parent. If a surface\nbecomes unmapped, its children's parent is set to the parent of\nthe now-unmapped surface. If the now-unmapped surface has no parent,\nits children's parent is unset. If the now-unmapped surface becomes\nmapped again, its parent-child relationship is not restored.\n\nThe parent toplevel must not be one of the child toplevel's\ndescendants, and the parent must be different from the child toplevel,\notherwise the invalid_parent protocol error is raised."SetParent"set application ID\n\nSet an application identifier for the surface.\n\nThe app ID identifies the general class of applications to which\nthe surface belongs. The compositor can use this to group multiple\nsurfaces together, or to determine how to launch a new application.\n\nFor D-Bus activatable applications, the app ID is used as the D-Bus\nservice name.\n\nThe compositor shell will try to group application surfaces together\nby their app ID. As a best practice, it is suggested to select app\nID's that match the basename of the application's .desktop file.\nFor example, \"org.freedesktop.FooViewer\" where the .desktop file is\n\"org.freedesktop.FooViewer.desktop\".\n\nLike other properties, a set_app_id request can be sent after the\nxdg_toplevel has been mapped to update the property.\n\nSee the desktop-entry specification [0] for more details on\napplication identifiers and how they relate to well-known D-Bus\nnames and .desktop files.\n\n[0] https://standards.freedesktop.org/desktop-entry-spec/""show the window menu\n\nClients implementing client-side decorations might want to show\na context menu when right-clicking on the decorations, giving the\nuser a menu that they can use to maximize or minimize the window.\n\nThis request asks the compositor to pop up such a window menu at\nthe given position, relative to the local surface coordinates of\nthe parent surface. There are no guarantees as to what menu items\nthe window menu contains, or even if a window menu will be drawn\nat all.\n\nThis request must be used in response to some sort of user action\nlike a button press, key press, or touch down event.""the wl_seat of the user event""the serial of the user event""the x position to pop up the window menu at""the y position to pop up the window menu at"ShowWindowMenu"start an interactive move\n\nStart an interactive, user-driven move of the surface.\n\nThis request must be used in response to some sort of user action\nlike a button press, key press, or touch down event. The passed\nserial is used to determine the type of interactive move (touch,\npointer, etc).\n\nThe server may ignore move requests depending on the state of\nthe surface (e.g. fullscreen or maximized), or if the passed serial\nis no longer valid.\n\nIf triggered, the surface will lose the focus of the device\n(wl_pointer, wl_touch, etc) used for the move. It is up to the\ncompositor to visually indicate that the move is taking place, such as\nupdating a pointer cursor, during the move. There is no guarantee\nthat the device focus will return when the move is completed.""start an interactive resize\n\nStart a user-driven, interactive resize of the surface.\n\nThis request must be used in response to some sort of user action\nlike a button press, key press, or touch down event. The passed\nserial is used to determine the type of interactive resize (touch,\npointer, etc).\n\nThe server may ignore resize requests depending on the state of\nthe surface (e.g. fullscreen or maximized).\n\nIf triggered, the client will receive configure events with the\n\"resize\" state enum value and the expected sizes. See the \"resize\"\nenum value for more details about what is required. The client\nmust also acknowledge configure events using \"ack_configure\". After\nthe resize is completed, the client will receive another \"configure\"\nevent without the resize state.\n\nIf triggered, the surface also will lose the focus of the device\n(wl_pointer, wl_touch, etc) used for the resize. It is up to the\ncompositor to visually indicate that the resize is taking place,\nsuch as updating a pointer cursor, during the resize. There is no\nguarantee that the device focus will return when the resize is\ncompleted.\n\nThe edges parameter specifies how the surface should be resized, and\nis one of the values of the resize_edge enum. Values not matching\na variant of the enum will cause the invalid_resize_edge protocol error.\nThe compositor may use this information to update the surface position\nfor example when dragging the top left corner. The compositor may also\nuse this information to adapt its behavior, e.g. choose an appropriate\ncursor image.""set the maximum size\n\nSet a maximum size for the window.\n\nThe client can specify a maximum size so that the compositor does\nnot try to configure the window beyond this size.\n\nThe width and height arguments are in window geometry coordinates.\nSee xdg_surface.set_window_geometry.\n\nValues set in this way are double-buffered, see wl_surface.commit.\n\nThe compositor can use this information to allow or disallow\ndifferent states like maximize or fullscreen and draw accurate\nanimations.\n\nSimilarly, a tiling window manager may use this information to\nplace and resize client windows in a more effective way.\n\nThe client should not rely on the compositor to obey the maximum\nsize. The compositor may decide to ignore the values set by the\nclient and request a larger size.\n\nIf never set, or a value of zero in the request, means that the\nclient has no expected maximum size in the given dimension.\nAs a result, a client wishing to reset the maximum size\nto an unspecified state can use zero for width and height in the\nrequest.\n\nRequesting a maximum size to be smaller than the minimum size of\na surface is illegal and will result in an invalid_size error.\n\nThe width and height must be greater than or equal to zero. Using\nstrictly negative values for width or height will result in a\ninvalid_size error."SetMaxSize"set the minimum size\n\nSet a minimum size for the window.\n\nThe client can specify a minimum size so that the compositor does\nnot try to configure the window below this size.\n\nThe width and height arguments are in window geometry coordinates.\nSee xdg_surface.set_window_geometry.\n\nValues set in this way are double-buffered, see wl_surface.commit.\n\nThe compositor can use this information to allow or disallow\ndifferent states like maximize or fullscreen and draw accurate\nanimations.\n\nSimilarly, a tiling window manager may use this information to\nplace and resize client windows in a more effective way.\n\nThe client should not rely on the compositor to obey the minimum\nsize. The compositor may decide to ignore the values set by the\nclient and request a smaller size.\n\nIf never set, or a value of zero in the request, means that the\nclient has no expected minimum size in the given dimension.\nAs a result, a client wishing to reset the minimum size\nto an unspecified state can use zero for width and height in the\nrequest.\n\nRequesting a minimum size to be larger than the maximum size of\na surface is illegal and will result in an invalid_size error.\n\nThe width and height must be greater than or equal to zero. Using\nstrictly negative values for width and height will result in a\ninvalid_size error."SetMinSize"maximize the window\n\nMaximize the surface.\n\nAfter requesting that the surface should be maximized, the compositor\nwill respond by emitting a configure event. Whether this configure\nactually sets the window maximized is subject to compositor policies.\nThe client must then update its content, drawing in the configured\nstate. The client must also acknowledge the configure when committing\nthe new content (see ack_configure).\n\nIt is up to the compositor to decide how and where to maximize the\nsurface, for example which output and what region of the screen should\nbe used.\n\nIf the surface was already maximized, the compositor will still emit\na configure event with the \"maximized\" state.\n\nIf the surface is in a fullscreen state, this request has no direct\neffect. It may alter the state the surface is returned to when\nunmaximized unless overridden by the compositor.""unmaximize the window\n\nUnmaximize the surface.\n\nAfter requesting that the surface should be unmaximized, the compositor\nwill respond by emitting a configure event. Whether this actually\nun-maximizes the window is subject to compositor policies.\nIf available and applicable, the compositor will include the window\ngeometry dimensions the window had prior to being maximized in the\nconfigure event. The client must then update its content, drawing it in\nthe configured state. The client must also acknowledge the configure\nwhen committing the new content (see ack_configure).\n\nIt is up to the compositor to position the surface after it was\nunmaximized; usually the position the surface had before maximizing, if\napplicable.\n\nIf the surface was already not maximized, the compositor will still\nemit a configure event without the \"maximized\" state.\n\nIf the surface is in a fullscreen state, this request has no direct\neffect. It may alter the state the surface is returned to when\nunmaximized unless overridden by the compositor."UnsetMaximized"set the window as fullscreen on an output\n\nMake the surface fullscreen.\n\nAfter requesting that the surface should be fullscreened, the\ncompositor will respond by emitting a configure event. Whether the\nclient is actually put into a fullscreen state is subject to compositor\npolicies. The client must also acknowledge the configure when\ncommitting the new content (see ack_configure).\n\nThe output passed by the request indicates the client's preference as\nto which display it should be set fullscreen on. If this value is NULL,\nit's up to the compositor to choose which display will be used to map\nthis surface.\n\nIf the surface doesn't cover the whole output, the compositor will\nposition the surface in the center of the output and compensate with\nwith border fill covering the rest of the output. The content of the\nborder fill is undefined, but should be assumed to be in some way that\nattempts to blend into the surrounding area (e.g. solid black).\n\nIf the fullscreened surface is not opaque, the compositor must make\nsure that other screen content not part of the same surface tree (made\nup of subsurfaces, popups or similarly coupled surfaces) are not\nvisible below the fullscreened surface.""unset the window as fullscreen\n\nMake the surface no longer fullscreen.\n\nAfter requesting that the surface should be unfullscreened, the\ncompositor will respond by emitting a configure event.\nWhether this actually removes the fullscreen state of the client is\nsubject to compositor policies.\n\nMaking a surface unfullscreen sets states for the surface based on the following:\n* the state(s) it may have had before becoming fullscreen\n* any state(s) decided by the compositor\n* any state(s) requested by the client while the surface was fullscreen\n\nThe compositor may include the previous window geometry dimensions in\nthe configure event, if applicable.\n\nThe client must also acknowledge the configure when committing the new\ncontent (see ack_configure)."UnsetFullscreen"set the window as minimized\n\nRequest that the compositor minimize your surface. There is no\nway to know if the surface is currently minimized, nor is there\nany way to unset minimization on this surface.\n\nIf you are looking to throttle redrawing when minimized, please\ninstead use the wl_surface.frame event for this, as this will\nalso work with live previews on windows in Alt-Tab, Expose or\nsimilar compositor features."SetMinimized"suggest a surface change\n\nThis configure event asks the client to resize its toplevel surface or\nto change its state. The configured state should not be applied\nimmediately. See xdg_surface.configure for details.\n\nThe width and height arguments specify a hint to the window\nabout how its surface should be resized in window geometry\ncoordinates. See set_window_geometry.\n\nIf the width or height arguments are zero, it means the client\nshould decide its own window dimension. This may happen when the\ncompositor needs to configure the state of the surface but doesn't\nhave any information about any previous or expected dimension.\n\nThe states listed in the event specify how the width/height\narguments should be interpreted, and possibly how it should be\ndrawn.\n\nClients must send an ack_configure in response to this event. See\nxdg_surface.configure and xdg_surface.ack_configure for details.""surface wants to be closed\n\nThe close event is sent by the compositor when the user\nwants the surface to be closed. This should be equivalent to\nthe user clicking the close button in client-side decorations,\nif your application has any.\n\nThis is only a request that the user intends to close the\nwindow. The client may choose to ignore this request, or show\na dialog to ask the user to save their data, etc.""recommended window geometry bounds\n\nThe configure_bounds event may be sent prior to a xdg_toplevel.configure\nevent to communicate the bounds a window geometry size is recommended\nto constrain to.\n\nThe passed width and height are in surface coordinate space. If width\nand height are 0, it means bounds is unknown and equivalent to as if no\nconfigure_bounds event was ever sent for this surface.\n\nThe bounds can for example correspond to the size of a monitor excluding\nany panels or other shell components, so that a surface isn't created in\na way that it cannot fit.\n\nThe bounds may change at any point, and in such a case, a new\nxdg_toplevel.configure_bounds will be sent, followed by\nxdg_toplevel.configure and xdg_surface.configure.\n\nOnly available since version 4 of the interface"ConfigureBounds"compositor capabilities\n\nThis event advertises the capabilities supported by the compositor. If\na capability isn't supported, clients should hide or disable the UI\nelements that expose this functionality. For instance, if the\ncompositor doesn't advertise support for minimized toplevels, a button\ntriggering the set_minimized request should not be displayed.\n\nThe compositor will ignore requests it doesn't support. For instance,\na compositor which doesn't advertise support for minimized will ignore\nset_minimized requests.\n\nCompositors must send this event once before the first\nxdg_surface.configure event. When the capabilities change, compositors\nmust send this event again and then send an xdg_surface.configure\nevent.\n\nThe configured state should not be applied immediately. See\nxdg_surface.configure for details.\n\nThe capabilities are sent as an array of 32-bit unsigned integers in\nnative endianness.\n\nOnly available since version 5 of the interface""array of 32-bit capabilities""toplevel surface\n\nThis interface defines an xdg_surface role which allows a surface to,\namong other things, set window-like properties such as maximize,\nfullscreen, and minimize, set application-specific metadata like title and\nid, and well as trigger user interactive operations such as interactive\nresize and move.\n\nA xdg_toplevel by default is responsible for providing the full intended\nvisual representation of the toplevel, which depending on the window\nstate, may mean things like a title bar, window controls and drop shadow.\n\nUnmapping an xdg_toplevel means that the surface cannot be shown\nby the compositor until it is explicitly mapped again.\nAll active operations (e.g., move, resize) are canceled and all\nattributes (e.g. title, state, stacking, ...) are discarded for\nan xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to\nthe state it had right after xdg_surface.get_toplevel. The client\ncan re-map the toplevel by performing a commit without any buffer\nattached, waiting for a configure event and handling it as usual (see\nxdg_surface description).\n\nAttaching a null buffer to a toplevel unmaps the surface.\n\nSee also the [Event] enum for this interface.""destroy the xdg_toplevel\n\nThis request destroys the role surface and unmaps the surface;\nsee \"Unmapping\" behavior in interface section for details.""short-lived, popup surfaces for menus\n\nA popup surface is a short-lived, temporary surface. It can be used to\nimplement for example menus, popovers, tooltips and other similar user\ninterface concepts.\n\nA popup can be made to take an explicit grab. See xdg_popup.grab for\ndetails.\n\nWhen the popup is dismissed, a popup_done event will be sent out, and at\nthe same time the surface will be unmapped. See the xdg_popup.popup_done\nevent for details.\n\nExplicitly destroying the xdg_popup object will also dismiss the popup and\nunmap the surface. Clients that want to dismiss the popup when another\nsurface of their own is clicked should dismiss the popup using the destroy\nrequest.\n\nA newly created xdg_popup will be stacked on top of all previously created\nxdg_popup surfaces associated with the same xdg_toplevel.\n\nThe parent of an xdg_popup must be mapped (see the xdg_surface\ndescription) before the xdg_popup itself.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor the xdg_popup state to take effect.""tried to grab after being mapped"InvalidGrabREQ_GRAB_SINCEREQ_GRAB_OPCODEREQ_REPOSITION_SINCEREQ_REPOSITION_OPCODEEVT_REPOSITIONED_SINCEEVT_REPOSITIONED_OPCODE"remove xdg_popup interface\n\nThis destroys the popup. Explicitly destroying the xdg_popup\nobject will also dismiss the popup, and unmap the surface.\n\nIf this xdg_popup is not the \"topmost\" popup, the\nxdg_wm_base.not_the_topmost_popup protocol error will be sent.\n\nThis is a destructor, once sent this object cannot be used any longer.""make the popup take an explicit grab\n\nThis request makes the created popup take an explicit grab. An explicit\ngrab will be dismissed when the user dismisses the popup, or when the\nclient destroys the xdg_popup. This can be done by the user clicking\noutside the surface, using the keyboard, or even locking the screen\nthrough closing the lid or a timeout.\n\nIf the compositor denies the grab, the popup will be immediately\ndismissed.\n\nThis request must be used in response to some sort of user action like a\nbutton press, key press, or touch down event. The serial number of the\nevent should be passed as 'serial'.\n\nThe parent of a grabbing popup must either be an xdg_toplevel surface or\nanother xdg_popup with an explicit grab. If the parent is another\nxdg_popup it means that the popups are nested, with this popup now being\nthe topmost popup.\n\nNested popups must be destroyed in the reverse order they were created\nin, e.g. the only popup you are allowed to destroy at all times is the\ntopmost one.\n\nWhen compositors choose to dismiss a popup, they may dismiss every\nnested grabbing popup as well. When a compositor dismisses popups, it\nwill follow the same dismissing order as required from the client.\n\nIf the topmost grabbing popup is destroyed, the grab will be returned to\nthe parent of the popup, if that parent previously had an explicit grab.\n\nIf the parent is a grabbing popup which has already been dismissed, this\npopup will be immediately dismissed. If the parent is a popup that did\nnot take an explicit grab, an error will be raised.\n\nDuring a popup grab, the client owning the grab will receive pointer\nand touch events for all their surfaces as normal (similar to an\n\"owner-events\" grab in X11 parlance), while the top most grabbing popup\nwill always have keyboard focus.""recalculate the popup's location\n\nReposition an already-mapped popup. The popup will be placed given the\ndetails in the passed xdg_positioner object, and a\nxdg_popup.repositioned followed by xdg_popup.configure and\nxdg_surface.configure will be emitted in response. Any parameters set\nby the previous positioner will be discarded.\n\nThe passed token will be sent in the corresponding\nxdg_popup.repositioned event. The new popup position will not take\neffect until the corresponding configure event is acknowledged by the\nclient. See xdg_popup.repositioned for details. The token itself is\nopaque, and has no other special meaning.\n\nIf multiple reposition requests are sent, the compositor may skip all\nbut the last one.\n\nIf the popup is repositioned in response to a configure event for its\nparent, the client should send an xdg_positioner.set_parent_configure\nand possibly an xdg_positioner.set_parent_size request to allow the\ncompositor to properly constrain the popup.\n\nIf the popup is repositioned together with a parent that is being\nresized, but not in response to a configure event, the client should\nsend an xdg_positioner.set_parent_size request.\n\nOnly available since version 3 of the interface""reposition request token""configure the popup surface\n\nThis event asks the popup surface to configure itself given the\nconfiguration. The configured state should not be applied immediately.\nSee xdg_surface.configure for details.\n\nThe x and y arguments represent the position the popup was placed at\ngiven the xdg_positioner rule, relative to the upper left corner of the\nwindow geometry of the parent surface.\n\nFor version 2 or older, the configure event for an xdg_popup is only\never sent once for the initial configuration. Starting with version 3,\nit may be sent again if the popup is setup with an xdg_positioner with\nset_reactive requested, or in response to xdg_popup.reposition requests.""x position relative to parent surface window geometry""y position relative to parent surface window geometry""window geometry width""window geometry height""popup interaction is done\n\nThe popup_done event is sent out when a popup is dismissed by the\ncompositor. The client should destroy the xdg_popup object at this\npoint.""signal the completion of a repositioned request\n\nThe repositioned event is sent as part of a popup configuration\nsequence, together with xdg_popup.configure and lastly\nxdg_surface.configure to notify the completion of a reposition request.\n\nThe repositioned event is to notify about the completion of a\nxdg_popup.reposition request. The token argument is the token passed\nin the xdg_popup.reposition request.\n\nImmediately after this event is emitted, xdg_popup.configure and\nxdg_surface.configure will be sent with the updated size and position,\nas well as a new configure serial.\n\nThe client should optionally update the content of the popup, but must\nacknowledge the new popup configuration for the new position to take\neffect. See xdg_surface.ack_configure for details.\n\nOnly available since version 3 of the interface"Repositioned"short-lived, popup surfaces for menus\n\nA popup surface is a short-lived, temporary surface. It can be used to\nimplement for example menus, popovers, tooltips and other similar user\ninterface concepts.\n\nA popup can be made to take an explicit grab. See xdg_popup.grab for\ndetails.\n\nWhen the popup is dismissed, a popup_done event will be sent out, and at\nthe same time the surface will be unmapped. See the xdg_popup.popup_done\nevent for details.\n\nExplicitly destroying the xdg_popup object will also dismiss the popup and\nunmap the surface. Clients that want to dismiss the popup when another\nsurface of their own is clicked should dismiss the popup using the destroy\nrequest.\n\nA newly created xdg_popup will be stacked on top of all previously created\nxdg_popup surfaces associated with the same xdg_toplevel.\n\nThe parent of an xdg_popup must be mapped (see the xdg_surface\ndescription) before the xdg_popup itself.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor the xdg_popup state to take effect.\n\nSee also the [Event] enum for this interface.""remove xdg_popup interface\n\nThis destroys the popup. Explicitly destroying the xdg_popup\nobject will also dismiss the popup, and unmap the surface.\n\nIf this xdg_popup is not the \"topmost\" popup, the\nxdg_wm_base.not_the_topmost_popup protocol error will be sent.""recalculate the popup's location\n\nReposition an already-mapped popup. The popup will be placed given the\ndetails in the passed xdg_positioner object, and a\nxdg_popup.repositioned followed by xdg_popup.configure and\nxdg_surface.configure will be emitted in response. Any parameters set\nby the previous positioner will be discarded.\n\nThe passed token will be sent in the corresponding\nxdg_popup.repositioned event. The new popup position will not take\neffect until the corresponding configure event is acknowledged by the\nclient. See xdg_popup.repositioned for details. The token itself is\nopaque, and has no other special meaning.\n\nIf multiple reposition requests are sent, the compositor may skip all\nbut the last one.\n\nIf the popup is repositioned in response to a configure event for its\nparent, the client should send an xdg_positioner.set_parent_configure\nand possibly an xdg_positioner.set_parent_size request to allow the\ncompositor to properly constrain the popup.\n\nIf the popup is repositioned together with a parent that is being\nresized, but not in response to a configure event, the client should\nsend an xdg_positioner.set_parent_size request."//! XDG Shell protocol//! Exposes the `xdg_wm_base` global, which deprecates and replaces `wl_shell`.XDG_TOPLEVEL_DRAG_MANAGER_V1_INTERFACExdg_toplevel_drag_manager_v1_requests_get_xdg_toplevel_drag_typesxdg_toplevel_drag_manager_v1_requestsxdg_toplevel_drag_manager_v1_interfaceXDG_TOPLEVEL_DRAG_V1_INTERFACExdg_toplevel_drag_v1_requests_attach_typesxdg_toplevel_drag_v1_requestsxdg_toplevel_drag_v1_interface"Move a window during a drag\n\nThis protocol enhances normal drag and drop with the ability to move a\nwindow at the same time. This allows having detachable parts of a window\nthat when dragged out of it become a new window and can be dragged over\nan existing window to be reattached.\n\nA typical workflow would be when the user starts dragging on top of a\ndetachable part of a window, the client would create a wl_data_source and\na xdg_toplevel_drag_v1 object and start the drag as normal via\nwl_data_device.start_drag. Once the client determines that the detachable\nwindow contents should be detached from the originating window, it creates\na new xdg_toplevel with these contents and issues a\nxdg_toplevel_drag_v1.attach request before mapping it. From now on the new\nwindow is moved by the compositor during the drag as if the client called\nxdg_toplevel.move.\n\nDragging an existing window is similar. The client creates a\nxdg_toplevel_drag_v1 object and attaches the existing toplevel before\nstarting the drag.\n\nClients use the existing drag and drop mechanism to detect when a window\ncan be docked or undocked. If the client wants to snap a window into a\nparent window it should delete or unmap the dragged top-level. If the\ncontents should be detached again it attaches a new toplevel as described\nabove. If a drag operation is cancelled without being dropped, clients\nshould revert to the previous state, deleting any newly created windows\nas appropriate. When a drag operation ends as indicated by\nwl_data_source.dnd_drop_performed the dragged toplevel window's final\nposition is determined as if a xdg_toplevel_move operation ended.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""data_source already used for toplevel drag"REQ_GET_XDG_TOPLEVEL_DRAG_SINCEREQ_GET_XDG_TOPLEVEL_DRAG_OPCODE"destroy the xdg_toplevel_drag_manager_v1 object\n\nDestroy this xdg_toplevel_drag_manager_v1 object. Other objects,\nincluding xdg_toplevel_drag_v1 objects created by this factory, are not\naffected by this request.\n\nThis is a destructor, once sent this object cannot be used any longer.""get an xdg_toplevel_drag for a wl_data_source\n\nCreate an xdg_toplevel_drag for a drag and drop operation that is going\nto be started with data_source.\n\nThis request can only be made on sources used in drag-and-drop, so it\nmust be performed before wl_data_device.start_drag. Attempting to use\nthe source other than for drag-and-drop such as in\nwl_data_device.set_selection will raise an invalid_source error.\n\nDestroying data_source while a toplevel is attached to the\nxdg_toplevel_drag is undefined."GetXdgToplevelDrag"Move a window during a drag\n\nThis protocol enhances normal drag and drop with the ability to move a\nwindow at the same time. This allows having detachable parts of a window\nthat when dragged out of it become a new window and can be dragged over\nan existing window to be reattached.\n\nA typical workflow would be when the user starts dragging on top of a\ndetachable part of a window, the client would create a wl_data_source and\na xdg_toplevel_drag_v1 object and start the drag as normal via\nwl_data_device.start_drag. Once the client determines that the detachable\nwindow contents should be detached from the originating window, it creates\na new xdg_toplevel with these contents and issues a\nxdg_toplevel_drag_v1.attach request before mapping it. From now on the new\nwindow is moved by the compositor during the drag as if the client called\nxdg_toplevel.move.\n\nDragging an existing window is similar. The client creates a\nxdg_toplevel_drag_v1 object and attaches the existing toplevel before\nstarting the drag.\n\nClients use the existing drag and drop mechanism to detect when a window\ncan be docked or undocked. If the client wants to snap a window into a\nparent window it should delete or unmap the dragged top-level. If the\ncontents should be detached again it attaches a new toplevel as described\nabove. If a drag operation is cancelled without being dropped, clients\nshould revert to the previous state, deleting any newly created windows\nas appropriate. When a drag operation ends as indicated by\nwl_data_source.dnd_drop_performed the dragged toplevel window's final\nposition is determined as if a xdg_toplevel_move operation ended.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."XdgToplevelDragManagerV1"destroy the xdg_toplevel_drag_manager_v1 object\n\nDestroy this xdg_toplevel_drag_manager_v1 object. Other objects,\nincluding xdg_toplevel_drag_v1 objects created by this factory, are not\naffected by this request."xdg_toplevel_drag_v1XdgToplevelDragV1get_xdg_toplevel_dragxdg_toplevel_drag_manager_v1"Object representing a toplevel move during a drag""valid toplevel already attached"ToplevelAttached"drag has not ended"OngoingDrag"destroy an xdg_toplevel_drag_v1 object\n\nDestroy this xdg_toplevel_drag_v1 object. This request must only be\ncalled after the underlying wl_data_source drag has ended, as indicated\nby the dnd_drop_performed or cancelled events. In any other case an\nongoing_drag error is raised.\n\nThis is a destructor, once sent this object cannot be used any longer.""Move a toplevel with the drag operation\n\nRequest that the window will be moved with the cursor during the drag\noperation. The offset is a hint to the compositor how the toplevel\nshould be positioned relative to the cursor hotspot in surface local\ncoordinates and relative to the geometry of the toplevel being attached.\nSee xdg_surface.set_window_geometry. For example it might only\nbe used when an unmapped window is attached. The attached window\ndoes not participate in the selection of the drag target.\n\nIf the toplevel is unmapped while it is attached, it is automatically\ndetached from the drag. In this case this request has to be called again\nif the window should be attached after it is remapped.\n\nThis request can be called multiple times but issuing it while a\ntoplevel with an active role is attached raises a toplevel_attached\nerror.""dragged surface x offset""dragged surface y offset""Object representing a toplevel move during a drag\n\n\n\nThis interface has no events.""destroy an xdg_toplevel_drag_v1 object\n\nDestroy this xdg_toplevel_drag_v1 object. This request must only be\ncalled after the underlying wl_data_source drag has ended, as indicated\nby the dnd_drop_performed or cancelled events. In any other case an\nongoing_drag error is raised."//! This protocol enhances normal drag and drop with the ability to move a//! window at the same time. This allows having detachable parts of a window//! that when dragged out of it become a new window and can be dragged over//! an existing window to be reattached.//! A typical workflow would be when the user starts dragging on top of a//! detachable part of a window, the client would create a `wl_data_source` and//! a `xdg_toplevel_drag_v1` object and start the drag as normal via//! `wl_data_device.start_drag`. Once the client determines that the detachable//! window contents should be detached from the originating window, it creates//! a new `xdg_toplevel` with these contents and issues a//! `xdg_toplevel_drag_v1.attach` request before mapping it. From now on the new//! window is moved by the compositor during the drag as if the client called//! `xdg_toplevel.move`.//! Dragging an existing window is similar. The client creates a//! `xdg_toplevel_drag_v1` object and attaches the existing toplevel before//! starting the drag.//! Clients use the existing drag and drop mechanism to detect when a window//! can be docked or undocked. If the client wants to snap a window into a//! parent window it should delete or unmap the dragged top-level. If the//! contents should be detached again it attaches a new toplevel as described//! above. If a drag operation is cancelled without being dropped, clients//! should revert to the previous state, deleting any newly created windows//! as appropriate. When a drag operation ends as indicated by//! `wl_data_source.dnd_drop_performed` the dragged toplevel window's final//! position is determined as if a `xdg_toplevel_move` operation ended.toplevel_dragXDG_WM_DIALOG_V1_INTERFACExdg_wm_dialog_v1_requests_get_xdg_dialog_typesxdg_wm_dialog_v1_requestsxdg_wm_dialog_v1_interfaceXDG_DIALOG_V1_INTERFACExdg_dialog_v1_requestsxdg_dialog_v1_interface"create dialogs related to other toplevels\n\nThe xdg_wm_dialog_v1 interface is exposed as a global object allowing\nto register surfaces with a xdg_toplevel role as \"dialogs\" relative to\nanother toplevel.\n\nThe compositor may let this relation influence how the surface is\nplaced, displayed or interacted with.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.""the xdg_toplevel object has already been used to create a xdg_dialog_v1"REQ_GET_XDG_DIALOG_SINCEREQ_GET_XDG_DIALOG_OPCODE"destroy the dialog manager object\n\nDestroys the xdg_wm_dialog_v1 object. This does not affect\nthe xdg_dialog_v1 objects generated through it.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a dialog object\n\nCreates a xdg_dialog_v1 object for the given toplevel. See the interface\ndescription for more details.\n\nCompositors must raise an already_used error if clients attempt to\ncreate multiple xdg_dialog_v1 objects for the same xdg_toplevel."GetXdgDialog"create dialogs related to other toplevels\n\nThe xdg_wm_dialog_v1 interface is exposed as a global object allowing\nto register surfaces with a xdg_toplevel role as \"dialogs\" relative to\nanother toplevel.\n\nThe compositor may let this relation influence how the surface is\nplaced, displayed or interacted with.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."XdgWmDialogV1"destroy the dialog manager object\n\nDestroys the xdg_wm_dialog_v1 object. This does not affect\nthe xdg_dialog_v1 objects generated through it."xdg_dialog_v1XdgDialogV1get_xdg_dialogxdg_wm_dialog_v1"dialog object\n\nA xdg_dialog_v1 object is an ancillary object tied to a xdg_toplevel. Its\npurpose is hinting the compositor that the toplevel is a \"dialog\" (e.g. a\ntemporary window) relative to another toplevel (see\nxdg_toplevel.set_parent). If the xdg_toplevel is destroyed, the xdg_dialog_v1\nbecomes inert.\n\nThrough this object, the client may provide additional hints about\nthe purpose of the secondary toplevel. This interface has no effect\non toplevels that are not attached to a parent toplevel."REQ_SET_MODAL_SINCEREQ_SET_MODAL_OPCODEREQ_UNSET_MODAL_SINCEREQ_UNSET_MODAL_OPCODE"destroy the dialog object\n\nDestroys the xdg_dialog_v1 object. If this object is destroyed\nbefore the related xdg_toplevel, the compositor should unapply its\neffects.\n\nThis is a destructor, once sent this object cannot be used any longer.""mark dialog as modal\n\nHints that the dialog has \"modal\" behavior. Modal dialogs typically\nrequire to be fully addressed by the user (i.e. closed) before resuming\ninteraction with the parent toplevel, and may require a distinct\npresentation.\n\nClients must implement the logic to filter events in the parent\ntoplevel on their own.\n\nCompositors may choose any policy in event delivery to the parent\ntoplevel, from delivering all events unfiltered to using them for\ninternal consumption."SetModal"mark dialog as not modal\n\nDrops the hint that this dialog has \"modal\" behavior. See\nxdg_dialog_v1.set_modal for more details."UnsetModal"dialog object\n\nA xdg_dialog_v1 object is an ancillary object tied to a xdg_toplevel. Its\npurpose is hinting the compositor that the toplevel is a \"dialog\" (e.g. a\ntemporary window) relative to another toplevel (see\nxdg_toplevel.set_parent). If the xdg_toplevel is destroyed, the xdg_dialog_v1\nbecomes inert.\n\nThrough this object, the client may provide additional hints about\nthe purpose of the secondary toplevel. This interface has no effect\non toplevels that are not attached to a parent toplevel.\n\nThis interface has no events.""destroy the dialog object\n\nDestroys the xdg_dialog_v1 object. If this object is destroyed\nbefore the related xdg_toplevel, the compositor should unapply its\neffects."unset_modal//! The `xdg_wm_dialog_v1` interface is exposed as a global object allowing//! to register surfaces with a xdg_toplevel role as "dialogs" relative to//! another toplevel.//! The compositor may let this relation influence how the surface is//! placed, displayed or interacted with.XDG_TOPLEVEL_ICON_MANAGER_V1_INTERFACExdg_toplevel_icon_manager_v1_requests_create_icon_typesxdg_toplevel_icon_manager_v1_requests_set_icon_typesxdg_toplevel_icon_manager_v1_requestsxdg_toplevel_icon_manager_v1_eventsxdg_toplevel_icon_manager_v1_interfaceXDG_TOPLEVEL_ICON_V1_INTERFACExdg_toplevel_icon_v1_requests_add_buffer_typesxdg_toplevel_icon_v1_requestsxdg_toplevel_icon_v1_interface"interface to manage toplevel icons\n\nThis interface allows clients to create toplevel window icons and set\nthem on toplevel windows to be displayed to the user."REQ_CREATE_ICON_SINCEREQ_CREATE_ICON_OPCODEREQ_SET_ICON_SINCEREQ_SET_ICON_OPCODEEVT_ICON_SIZE_SINCEEVT_ICON_SIZE_OPCODE"destroy the toplevel icon manager\n\nDestroy the toplevel icon manager.\nThis does not destroy objects created with the manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""create a new icon instance\n\nCreates a new icon object. This icon can then be attached to a\nxdg_toplevel via the 'set_icon' request.""set an icon on a toplevel window\n\nThis request assigns the icon 'icon' to 'toplevel', or clears the\ntoplevel icon if 'icon' was null.\nThis state is double-buffered and is applied on the next\nwl_surface.commit of the toplevel.\n\nAfter making this call, the xdg_toplevel_icon_v1 provided as 'icon'\ncan be destroyed by the client without 'toplevel' losing its icon.\nThe xdg_toplevel_icon_v1 is immutable from this point, and any\nfuture attempts to change it must raise the\n'xdg_toplevel_icon_v1.immutable' protocol error.\n\nThe compositor must set the toplevel icon from either the pixel data\nthe icon provides, or by loading a stock icon using the icon name.\nSee the description of 'xdg_toplevel_icon_v1' for details.\n\nIf 'icon' is set to null, the icon of the respective toplevel is reset\nto its default icon (usually the icon of the application, derived from\nits desktop-entry file, or a placeholder icon).\nIf this request is passed an icon with no pixel buffers or icon name\nassigned, the icon must be reset just like if 'icon' was null.""the toplevel to act on"xdg_toplevel_icon_v1XdgToplevelIconV1SetIcon"describes a supported &amp; preferred icon size\n\nThis event indicates an icon size the compositor prefers to be\navailable if the client has scalable icons and can render to any size.\n\nWhen the 'xdg_toplevel_icon_manager_v1' object is created, the\ncompositor may send one or more 'icon_size' events to describe the list\nof preferred icon sizes. If the compositor has no size preference, it\nmay not send any 'icon_size' event, and it is up to the client to\ndecide a suitable icon size.\n\nA sequence of 'icon_size' events must be finished with a 'done' event.\nIf the compositor has no size preferences, it must still send the\n'done' event, without any preceding 'icon_size' events.""the edge size of the square icon in surface-local coordinates, e.g. 64""all information has been sent\n\nThis event is sent after all 'icon_size' events have been sent.""interface to manage toplevel icons\n\nThis interface allows clients to create toplevel window icons and set\nthem on toplevel windows to be displayed to the user.\n\nSee also the [Event] enum for this interface."XdgToplevelIconManagerV1"destroy the toplevel icon manager\n\nDestroy the toplevel icon manager.\nThis does not destroy objects created with the manager."create_iconxdg_toplevel_icon_manager_v1"a toplevel window icon\n\nThis interface defines a toplevel icon.\nAn icon can have a name, and multiple buffers.\nIn order to be applied, the icon must have either a name, or at least\none buffer assigned. Applying an empty icon (with no buffer or name) to\na toplevel should reset its icon to the default icon.\n\nIt is up to compositor policy whether to prefer using a buffer or loading\nan icon via its name. See 'set_name' and 'add_buffer' for details.""the provided buffer does not satisfy requirements"InvalidBuffer"the icon has already been assigned to a toplevel and must not be changed""the provided buffer has been destroyed before the toplevel icon"REQ_SET_NAME_SINCEREQ_SET_NAME_OPCODEREQ_ADD_BUFFER_SINCEREQ_ADD_BUFFER_OPCODE"destroy the icon object\n\nDestroys the 'xdg_toplevel_icon_v1' object.\nThe icon must still remain set on every toplevel it was assigned to,\nuntil the toplevel icon is reset explicitly.\n\nThis is a destructor, once sent this object cannot be used any longer.""set an icon name\n\nThis request assigns an icon name to this icon.\nAny previously set name is overridden.\n\nThe compositor must resolve 'icon_name' according to the lookup rules\ndescribed in the XDG icon theme specification[1] using the\nenvironment's current icon theme.\n\nIf the compositor does not support icon names or cannot resolve\n'icon_name' according to the XDG icon theme specification it must\nfall back to using pixel buffer data instead.\n\nIf this request is made after the icon has been assigned to a toplevel\nvia 'set_icon', a 'immutable' error must be raised.\n\n[1]: https://specifications.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html"SetName"add icon data from a pixel buffer\n\nThis request adds pixel data supplied as wl_buffer to the icon.\n\nThe client should add pixel data for all icon sizes and scales that\nit can provide, or which are explicitly requested by the compositor\nvia 'icon_size' events on xdg_toplevel_icon_manager_v1.\n\nThe wl_buffer supplying pixel data as 'buffer' must be backed by wl_shm\nand must be a square (width and height being equal).\nIf any of these buffer requirements are not fulfilled, a 'invalid_buffer'\nerror must be raised.\n\nIf this icon instance already has a buffer of the same size and scale\nfrom a previous 'add_buffer' request, data from the last request\noverrides the preexisting pixel data.\n\nThe wl_buffer must be kept alive for as long as the xdg_toplevel_icon\nit is associated with is not destroyed, otherwise a 'no_buffer' error\nis raised. The buffer contents must not be modified after it was\nassigned to the icon. As a result, the region of the wl_shm_pool's\nbacking storage used for the wl_buffer must not be modified after this\nrequest is sent. The wl_buffer.release event is unused.\n\nIf this request is made after the icon has been assigned to a toplevel\nvia 'set_icon', a 'immutable' error must be raised.""the scaling factor of the icon, e.g. 1"AddBuffer"a toplevel window icon\n\nThis interface defines a toplevel icon.\nAn icon can have a name, and multiple buffers.\nIn order to be applied, the icon must have either a name, or at least\none buffer assigned. Applying an empty icon (with no buffer or name) to\na toplevel should reset its icon to the default icon.\n\nIt is up to compositor policy whether to prefer using a buffer or loading\nan icon via its name. See 'set_name' and 'add_buffer' for details.\n\nThis interface has no events.""destroy the icon object\n\nDestroys the 'xdg_toplevel_icon_v1' object.\nThe icon must still remain set on every toplevel it was assigned to,\nuntil the toplevel icon is reset explicitly."add_buffer//! This protocol allows clients to set icons for their toplevel surfaces//! either via the XDG icon stock (using an icon name), or from pixel data.//! A toplevel icon represents the individual toplevel (unlike the application//! or launcher icon, which represents the application as a whole), and may be//! shown in window switchers, window overviews and taskbars that list//! individual windows.toplevel_iconXDG_TOPLEVEL_TAG_MANAGER_V1_INTERFACExdg_toplevel_tag_manager_v1_requests_set_toplevel_tag_typesxdg_toplevel_tag_manager_v1_requests_set_toplevel_description_typesxdg_toplevel_tag_manager_v1_requestsxdg_toplevel_tag_manager_v1_interface"protocol for setting toplevel tags\n\nIn order to make some window properties like position, size,\n\"always on top\" or user defined rules for window behavior persistent, the\ncompositor needs some way to identify windows even after the application\nhas been restarted.\nThis protocol allows clients to make this possible by setting a tag for\ntoplevels.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension."REQ_SET_TOPLEVEL_TAG_SINCEREQ_SET_TOPLEVEL_TAG_OPCODEREQ_SET_TOPLEVEL_DESCRIPTION_SINCEREQ_SET_TOPLEVEL_DESCRIPTION_OPCODE"destroy toplevel tag object\n\nDestroy this toplevel tag manager object. This request has no other\neffects.\n\nThis is a destructor, once sent this object cannot be used any longer.""set tag\n\nSet a tag for a toplevel. The tag may be shown to the user in UI, so\nit's preferable for it to be human readable, but it must be suitable\nfor configuration files and should not be translated.\nSuitable tags would for example be \"main window\", \"settings\",\n\"e-mail composer\" or similar.\n\nThe tag does not need to be unique across applications, and the client\nmay set the same tag for multiple windows, for example if the user has\nopened the same UI twice. How the potentially resulting conflicts are\nhandled is compositor policy.\n\nThe client should set the tag as part of the initial commit on the\nassociated toplevel, but it may set it at any time afterwards as well,\nfor example if the purpose of the toplevel changes.""untranslated tag"SetToplevelTag"set description\n\nSet a description for a toplevel. This description may be shown to the\nuser in UI or read by a screen reader for accessibility purposes, and\nshould be translated.\nIt is recommended to make the description the translation of the tag.\n\nThe client should set the description as part of the initial commit on\nthe associated toplevel, but it may set it at any time afterwards as\nwell, for example if the purpose of the toplevel changes.""translated description"SetToplevelDescription"protocol for setting toplevel tags\n\nIn order to make some window properties like position, size,\n\"always on top\" or user defined rules for window behavior persistent, the\ncompositor needs some way to identify windows even after the application\nhas been restarted.\nThis protocol allows clients to make this possible by setting a tag for\ntoplevels.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."XdgToplevelTagManagerV1"destroy toplevel tag object\n\nDestroy this toplevel tag manager object. This request has no other\neffects."set_toplevel_tagset_toplevel_descriptionxdg_toplevel_tag_manager_v1//! In order to make some window properties like position, size,//! "always on top" or user defined rules for window behavior persistent, the//! compositor needs some way to identify windows even after the application//! has been restarted.//! This protocol allows clients to make this possible by setting a tag for//! toplevels.toplevel_tagXDG_SYSTEM_BELL_V1_INTERFACExdg_system_bell_v1_requests_ring_typesxdg_system_bell_v1_requestsxdg_system_bell_v1_interface"system bell\n\nThis global interface enables clients to ring the system bell.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension."REQ_RING_SINCEREQ_RING_OPCODE"destroy the system bell object\n\nNotify that the object will no longer be used.\n\nThis is a destructor, once sent this object cannot be used any longer.""ring the system bell\n\nThis requests rings the system bell on behalf of a client. How ringing\nthe bell is implemented is up to the compositor. It may be an audible\nsound, a visual feedback of some kind, or any other thing including\nnothing.\n\nThe passed surface should correspond to a toplevel like surface role,\nor be null, meaning the client doesn't have a particular toplevel it\nwants to associate the bell ringing with. See the xdg-shell protocol\nextension for a toplevel like surface role.""associated surface""system bell\n\nThis global interface enables clients to ring the system bell.\n\nWarning! The protocol described in this file is currently in the testing\nphase. Backward compatible changes may be added together with the\ncorresponding interface version bump. Backward incompatible changes can\nonly be done by creating a new major version of the extension.\n\nThis interface has no events."XdgSystemBellV1"destroy the system bell object\n\nNotify that the object will no longer be used."xdg_system_bell_v1//! This global interface enables clients to ring the system bell.system_bell//! Protocols related to window managementXWAYLAND_SHELL_V1_INTERFACExwayland_shell_v1_requests_get_xwayland_surface_typesxwayland_shell_v1_requestsxwayland_shell_v1_interfaceXWAYLAND_SURFACE_V1_INTERFACExwayland_surface_v1_requestsxwayland_surface_v1_interface"context object for Xwayland shell\n\nxwayland_shell_v1 is a singleton global object that\nprovides the ability to create a xwayland_surface_v1 object\nfor a given wl_surface.\n\nThis interface is intended to be bound by the Xwayland server.\n\nA compositor must not allow clients other than Xwayland to\nbind to this interface. A compositor should hide this global\nfrom other clients' wl_registry.\nA client the compositor does not consider to be an Xwayland\nserver attempting to bind this interface will result in\nan implementation-defined error.\n\nAn Xwayland server that has bound this interface must not\nset the `WL_SURFACE_ID` atom on a window."REQ_GET_XWAYLAND_SURFACE_SINCEREQ_GET_XWAYLAND_SURFACE_OPCODE"destroy the Xwayland shell object\n\nDestroy the xwayland_shell_v1 object.\n\nThe child objects created via this interface are unaffected.\n\nThis is a destructor, once sent this object cannot be used any longer.""assign the xwayland_surface surface role\n\nCreate an xwayland_surface_v1 interface for a given wl_surface\nobject and gives it the xwayland_surface role.\n\nIt is illegal to create an xwayland_surface_v1 for a wl_surface\nwhich already has an assigned role and this will result in the\n`role` protocol error.\n\nSee the documentation of xwayland_surface_v1 for more details\nabout what an xwayland_surface_v1 is and how it is used."GetXwaylandSurface"context object for Xwayland shell\n\nxwayland_shell_v1 is a singleton global object that\nprovides the ability to create a xwayland_surface_v1 object\nfor a given wl_surface.\n\nThis interface is intended to be bound by the Xwayland server.\n\nA compositor must not allow clients other than Xwayland to\nbind to this interface. A compositor should hide this global\nfrom other clients' wl_registry.\nA client the compositor does not consider to be an Xwayland\nserver attempting to bind this interface will result in\nan implementation-defined error.\n\nAn Xwayland server that has bound this interface must not\nset the `WL_SURFACE_ID` atom on a window.\n\nThis interface has no events."XwaylandShellV1"destroy the Xwayland shell object\n\nDestroy the xwayland_shell_v1 object.\n\nThe child objects created via this interface are unaffected."xwayland_surface_v1XwaylandSurfaceV1get_xwayland_surfacexwayland_shell_v1"interface for associating Xwayland windows to wl_surfaces\n\nAn Xwayland surface is a surface managed by an Xwayland server.\nIt is used for associating surfaces to Xwayland windows.\n\nThe Xwayland server associated with actions in this interface is\ndetermined by the Wayland client making the request.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor the xwayland_surface_v1 state to take effect.""given wl_surface is already associated with an X11 window"AlreadyAssociated"serial was not valid""associates a Xwayland window to a wl_surface\n\nAssociates an Xwayland window to a wl_surface.\nThe association state is double-buffered, see wl_surface.commit.\n\nThe `serial_lo` and `serial_hi` parameters specify a non-zero\nmonotonic serial number which is entirely unique and provided by the\nXwayland server equal to the serial value provided by a client message\nwith a message type of the `WL_SURFACE_SERIAL` atom on the X11 window\nfor this surface to be associated to.\n\nThe serial value in the `WL_SURFACE_SERIAL` client message is specified\nas having the lo-bits specified in `l[0]` and the hi-bits specified\nin `l[1]`.\n\nIf the serial value provided by `serial_lo` and `serial_hi` is not\nvalid, the `invalid_serial` protocol error will be raised.\n\nAn X11 window may be associated with multiple surfaces throughout its\nlifespan. (eg. unmapping and remapping a window).\n\nFor each wl_surface, this state must not be committed more than once,\notherwise the `already_associated` protocol error will be raised.""The lower 32-bits of the serial number associated with the X11 window"serial_lo"The upper 32-bits of the serial number associated with the X11 window"serial_hi"destroy the Xwayland surface object\n\nDestroy the xwayland_surface_v1 object.\n\nAny already existing associations are unaffected by this action.\n\nThis is a destructor, once sent this object cannot be used any longer.""interface for associating Xwayland windows to wl_surfaces\n\nAn Xwayland surface is a surface managed by an Xwayland server.\nIt is used for associating surfaces to Xwayland windows.\n\nThe Xwayland server associated with actions in this interface is\ndetermined by the Wayland client making the request.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor the xwayland_surface_v1 state to take effect.\n\nThis interface has no events.""destroy the Xwayland surface object\n\nDestroy the xwayland_surface_v1 object.\n\nAny already existing associations are unaffected by this action."//! This protocol adds a xwayland_surface role which allows an Xwayland//! server to associate an X11 window to a wl_surface.//! Before this protocol, this would be done via the Xwayland server//! providing the wl_surface's resource id via the a client message with//! the WL_SURFACE_ID atom on the X window.//! This was problematic as a race could occur if the wl_surface//! associated with a WL_SURFACE_ID for a window was destroyed before the//! client message was processed by the compositor and another surface//! (or other object) had taken its id due to recycling.//! This protocol solves the problem by moving the X11 window to wl_surface//! association step to the Wayland side, which means that the association//! cannot happen out-of-sync with the resource lifetime of the wl_surface.//! This protocol avoids duplicating the race on the other side by adding a//! non-zero monotonic serial number which is entirely unique that is set on//! both the wl_surface (via. xwayland_surface_v1's set_serial method) and//! the X11 window (via. the `WL_SURFACE_SERIAL` client message) that can be//! used to associate them, and synchronize the two timelines.//! The key words "must", "must not", "required", "shall", "shall not",//! "should", "should not", "recommended",  "may", and "optional" in this//! document are to be interpreted as described in IETF RFC 2119.ZWP_XWAYLAND_KEYBOARD_GRAB_MANAGER_V1_INTERFACEzwp_xwayland_keyboard_grab_manager_v1_requests_grab_keyboard_typeszwp_xwayland_keyboard_grab_manager_v1_requestszwp_xwayland_keyboard_grab_manager_v1_interfaceZWP_XWAYLAND_KEYBOARD_GRAB_V1_INTERFACEzwp_xwayland_keyboard_grab_v1_requestszwp_xwayland_keyboard_grab_v1_interface"context object for keyboard grab manager\n\nA global interface used for grabbing the keyboard.""destroy the keyboard grab manager\n\nDestroy the keyboard grab manager.\n\nThis is a destructor, once sent this object cannot be used any longer.""grab the keyboard to a surface\n\nThe grab_keyboard request asks for a grab of the keyboard, forcing\nthe keyboard focus for the given seat upon the given surface.\n\nThe protocol provides no guarantee that the grab is ever satisfied,\nand does not require the compositor to send an error if the grab\ncannot ever be satisfied. It is thus possible to request a keyboard\ngrab that will never be effective.\n\nThe protocol:\n\n* does not guarantee that the grab itself is applied for a surface,\nthe grab request may be silently ignored by the compositor,\n* does not guarantee that any events are sent to this client even\nif the grab is applied to a surface,\n* does not guarantee that events sent to this client are exhaustive,\na compositor may filter some events for its own consumption,\n* does not guarantee that events sent to this client are continuous,\na compositor may change and reroute keyboard events while the grab\nis nominally active.""surface to report keyboard events to""the seat for which the keyboard should be grabbed""context object for keyboard grab manager\n\nA global interface used for grabbing the keyboard.\n\nThis interface has no events."ZwpXwaylandKeyboardGrabManagerV1"destroy the keyboard grab manager\n\nDestroy the keyboard grab manager."zwp_xwayland_keyboard_grab_v1ZwpXwaylandKeyboardGrabV1zwp_xwayland_keyboard_grab_manager_v1"interface for grabbing the keyboard\n\nA global interface used for grabbing the keyboard.""destroy the grabbed keyboard object\n\nDestroy the grabbed keyboard object. If applicable, the compositor\nwill ungrab the keyboard.\n\nThis is a destructor, once sent this object cannot be used any longer.""interface for grabbing the keyboard\n\nA global interface used for grabbing the keyboard.\n\nThis interface has no events.""destroy the grabbed keyboard object\n\nDestroy the grabbed keyboard object. If applicable, the compositor\nwill ungrab the keyboard."//! Protocol for grabbing the keyboard from Xwayland//! This protocol is application-specific to meet the needs of the X11//! protocol through Xwayland. It provides a way for Xwayland to request//! all keyboard events to be forwarded to a surface even when the//! surface does not have keyboard focus.//! In the X11 protocol, a client may request an "active grab" on the//! keyboard. On success, all key events are reported only to the//! grabbing X11 client. For details, see XGrabKeyboard(3).//! The core Wayland protocol does not have a notion of an active//! keyboard grab. When running in Xwayland, X11 applications may//! acquire an active grab inside Xwayland but that cannot be translated//! to the Wayland compositor who may set the input focus to some other//! surface. In doing so, it breaks the X11 client assumption that all//! key events are reported to the grabbing client.//! This protocol specifies a way for Xwayland to request all keyboard//! be directed to the given surface. The protocol does not guarantee//! that the compositor will honor this request and it does not//! prescribe user interfaces on how to handle the respond. For example,//! a compositor may inform the user that all key events are now//! forwarded to the given client surface, or it may ask the user for//! permission to do so.//! Compositors are required to restrict access to this application//! specific protocol to Xwayland alone.keyboard_grab//! XWayland related protocolsXX_SESSION_MANAGER_V1_INTERFACExx_session_manager_v1_requests_get_session_typesxx_session_manager_v1_requestsxx_session_manager_v1_interfaceXX_SESSION_V1_INTERFACExx_session_v1_requests_add_toplevel_typesxx_session_v1_requests_restore_toplevel_typesxx_session_v1_requestsxx_session_v1_eventsxx_session_v1_interfaceXX_TOPLEVEL_SESSION_V1_INTERFACExx_toplevel_session_v1_requestsxx_toplevel_session_v1_events_restored_typesxx_toplevel_session_v1_eventsxx_toplevel_session_v1_interface"manage sessions for applications\n\nThe xx_session_manager interface defines base requests for creating and\nmanaging a session for an application. Sessions persist across application\nand compositor restarts unless explicitly destroyed. A session is created\nfor the purpose of maintaining an application's xdg_toplevel surfaces\nacross compositor or application restarts. The compositor should remember\nas many states as possible for surfaces in a given session, but there is\nno requirement for which states must be remembered.""a requested session is already in use""reason for getting a session\n\nThe reason may determine in what way a session restores the window\nmanagement state of associated toplevels.\n\nFor example newly launched applications might be launched on the active\nworkspace with restored size and position, while a recovered\napplications might restore additional state such as active workspace and\nstacking order.""an app is newly launched\n\nA new app instance is launched, for example from an app launcher.""an app recovered\n\nA app instance is recovering from for example a compositor or app crash."Recover"an app restored\n\nA app instance is restored, for example part of a restored session, or\nrestored from having been temporarily terminated due to resource\nconstraints."SessionRestoreREQ_GET_SESSION_SINCEREQ_GET_SESSION_OPCODE"Destroy this object\n\nThis has no effect other than to destroy the xx_session_manager object.\n\nThis is a destructor, once sent this object cannot be used any longer.""create or restore a session\n\nCreate a session object corresponding to either an existing session\nidentified by the given session identifier string or a new session.\nWhile the session object exists, the session is considered to be \"in\nuse\".\n\nIf a identifier string represents a session that is currently actively\nin use by the the same client, an 'in_use' error is raised. If some\nother client is currently using the same session, the new session will\nreplace managing the associated state.\n\nNULL is passed to initiate a new session. If an id is passed which does\nnot represent a valid session, the compositor treats it as if NULL had\nbeen passed.\n\nA client is allowed to have any number of in use sessions at the same\ntime.""reason for session""the session to restore"GetSession"manage sessions for applications\n\nThe xx_session_manager interface defines base requests for creating and\nmanaging a session for an application. Sessions persist across application\nand compositor restarts unless explicitly destroyed. A session is created\nfor the purpose of maintaining an application's xdg_toplevel surfaces\nacross compositor or application restarts. The compositor should remember\nas many states as possible for surfaces in a given session, but there is\nno requirement for which states must be remembered.\n\nThis interface has no events."XxSessionManagerV1"Destroy this object\n\nThis has no effect other than to destroy the xx_session_manager object."xx_session_v1XxSessionV1get_sessionxx_session_manager_v1"A session for an application\n\nA xx_session_v1 object represents a session for an application. While the\nobject exists, all surfaces which have been added to the session will\nhave states stored by the compositor which can be reapplied at a later\ntime. Two sessions cannot exist for the same identifier string.\n\nStates for surfaces added to a session are automatically updated by the\ncompositor when they are changed.\n\nSurfaces which have been added to a session are automatically removed from\nthe session if xdg_toplevel.destroy is called for the surface.""restore cannot be performed after initial toplevel commit""toplevel name is already in used"NameInUse"toplevel was already mapped when restored"AlreadyMappedREQ_ADD_TOPLEVEL_SINCEREQ_ADD_TOPLEVEL_OPCODEREQ_RESTORE_TOPLEVEL_SINCEREQ_RESTORE_TOPLEVEL_OPCODEEVT_RESTORED_SINCEEVT_RESTORED_OPCODEEVT_REPLACED_SINCEEVT_REPLACED_OPCODE"Destroy the session\n\nDestroy a session object, preserving the current state but not continuing\nto make further updates if state changes occur. This makes the associated\nxx_toplevel_session_v1 objects inert.\n\nThis is a destructor, once sent this object cannot be used any longer.""Remove the session\n\nRemove the session, making it no longer available for restoration. A\ncompositor should in response to this request remove the data related to\nthis session from its storage.\n\nThis is a destructor, once sent this object cannot be used any longer.""add a new surface to the session\n\nAttempt to add a given surface to the session. The passed name is used\nto identify what window is being restored, and may be used store window\nspecific state within the session.\n\nCalling this with a toplevel that is already managed by the session with\nthe same associated will raise an in_use error."AddToplevel"restore a surface state\n\nInform the compositor that the toplevel associated with the passed name\nshould have its window management state restored.\n\nCalling this with a toplevel that is already managed by the session with\nthe same associated will raise an in_use error.\n\nThis request must be called prior to the first commit on the associated\nwl_surface, otherwise an already_mapped error is raised.\n\nAs part of the initial configure sequence, if the toplevel was\nsuccessfully restored, a xx_toplevel_session_v1.restored event is\nemitted. See the xx_toplevel_session_v1.restored event for further\ndetails."RestoreToplevel"newly-created session id\n\nEmitted at most once some time after getting a new session object. It\nmeans that no previous state was restored, and a new session was created.\nThe passed id can be used to restore previous sessions.""the session has been restored\n\nEmitted at most once some time after getting a new session object. It\nmeans that previous state was at least partially restored. The same id\ncan again be used to restore previous sessions."Restored"the session has been restored\n\nEmitted at most once, if the session was taken over by some other\nclient. When this happens, the session and all its toplevel session\nobjects become inert, and should be destroyed."Replaced"A session for an application\n\nA xx_session_v1 object represents a session for an application. While the\nobject exists, all surfaces which have been added to the session will\nhave states stored by the compositor which can be reapplied at a later\ntime. Two sessions cannot exist for the same identifier string.\n\nStates for surfaces added to a session are automatically updated by the\ncompositor when they are changed.\n\nSurfaces which have been added to a session are automatically removed from\nthe session if xdg_toplevel.destroy is called for the surface.\n\nSee also the [Event] enum for this interface.""Destroy the session\n\nDestroy a session object, preserving the current state but not continuing\nto make further updates if state changes occur. This makes the associated\nxx_toplevel_session_v1 objects inert.""Remove the session\n\nRemove the session, making it no longer available for restoration. A\ncompositor should in response to this request remove the data related to\nthis session from its storage."xx_toplevel_session_v1XxToplevelSessionV1add_toplevelrestore_toplevel"Destroy the object\n\nDestroy the object. This has no effect window management of the\nassociated toplevel.\n\nThis is a destructor, once sent this object cannot be used any longer.""remove a surface from the session\n\nRemove a specified surface from the session and render any corresponding\nxx_toplevel_session_v1 object inert. The compositor should remove any\ndata related to the toplevel in the corresponding session from its internal\nstorage.\n\nThis is a destructor, once sent this object cannot be used any longer.""a toplevel's session has been restored\n\nThe \"restored\" event is emitted prior to the first\nxdg_toplevel.configure for the toplevel. It will only be emitted after\nxx_session_v1.restore_toplevel, and the initial empty surface state has\nbeen applied, and it indicates that the surface's session is being\nrestored with this configure event.""xx_toplevel_session_v1\n\nSee also the [Event] enum for this interface.""Destroy the object\n\nDestroy the object. This has no effect window management of the\nassociated toplevel.""remove a surface from the session\n\nRemove a specified surface from the session and render any corresponding\nxx_toplevel_session_v1 object inert. The compositor should remove any\ndata related to the toplevel in the corresponding session from its internal\nstorage."//! The xx_session_manager protocol declares interfaces necessary to//! allow clients to restore toplevel state from previous executions.session_managementXX_INPUT_METHOD_V1_INTERFACExx_input_method_v1_requests_get_input_popup_surface_typesxx_input_method_v1_requestsxx_input_method_v1_eventsxx_input_method_v1_interfaceXX_INPUT_POPUP_SURFACE_V2_INTERFACExx_input_popup_surface_v2_requests_reposition_typesxx_input_popup_surface_v2_requestsxx_input_popup_surface_v2_eventsxx_input_popup_surface_v2_interfaceXX_INPUT_POPUP_POSITIONER_V1_INTERFACExx_input_popup_positioner_v1_requestsxx_input_popup_positioner_v1_interfaceXX_INPUT_METHOD_MANAGER_V2_INTERFACExx_input_method_manager_v2_requests_get_input_method_typesxx_input_method_manager_v2_requests_get_positioner_typesxx_input_method_manager_v2_requestsxx_input_method_manager_v2_interface"input method\n\nAn input method object allows for clients to compose text.\n\nThe objects connects the client to a text input in an application, and\nlets the client to serve as an input method for a seat.\n\nThe xx_input_method_v1 object can occupy two distinct states: active and\ninactive. In the active state, the object is associated to and\ncommunicates with a text input. In the inactive state, there is no\nassociated text input, and the only communication is with the compositor.\nInitially, the input method is in the inactive state.\n\nRequests issued in the inactive state must be accepted by the compositor.\nBecause of the serial mechanism, and the state reset on activate event,\nthey will not have any effect on the state of the next text input.\n\nThere must be no more than one input method object per seat.""surface already has a role"SurfaceHasRole"operation requires the input method to be active"REQ_SET_PREEDIT_STRING_SINCEREQ_SET_PREEDIT_STRING_OPCODEREQ_GET_INPUT_POPUP_SURFACE_SINCEREQ_GET_INPUT_POPUP_SURFACE_OPCODEEVT_TEXT_CHANGE_CAUSE_SINCEEVT_TEXT_CHANGE_CAUSE_OPCODEEVT_UNAVAILABLE_SINCEEVT_UNAVAILABLE_OPCODE"commit string\n\nSend the commit string text for insertion to the application.\n\nInserts a string at current cursor position (see commit event\nsequence). The string to commit could be either just a single character\nafter a key press or the result of some composing.\n\nThe argument text is a buffer containing the string to insert. There is\na maximum length of wayland messages, so text can not be longer than\n4000 bytes.\n\nValues set with this event are double-buffered. They must be applied\nand reset to initial on the next zwp_text_input_v3.commit request.\n\nThe initial value of text is an empty string.""pre-edit string\n\nSend the pre-edit string text to the application text input.\n\nPlace a new composing text (pre-edit) at the current cursor position.\nAny previously set composing text must be removed. Any previously\nexisting selected text must be removed. The cursor is moved to a new\nposition within the preedit string.\n\nThe argument text is a buffer containing the preedit string. There is\na maximum length of wayland messages, so text can not be longer than\n4000 bytes.\n\nThe arguments cursor_begin and cursor_end are counted in bytes relative\nto the beginning of the submitted string buffer. Cursor should be\nhidden by the text input when both are equal to -1.\n\ncursor_begin indicates the beginning of the cursor. cursor_end\nindicates the end of the cursor. It may be equal or different than\ncursor_begin.\n\nValues set with this event are double-buffered. They must be applied on\nthe next xx_input_method_v1.commit event.\n\nThe initial value of text is an empty string. The initial value of\ncursor_begin, and cursor_end are both 0."SetPreeditString"delete text\n\nRemove the surrounding text.\n\nbefore_length and after_length are the number of bytes before and after\nthe current cursor index (excluding the preedit text) to delete.\n\nIf any preedit text is present, it is replaced with the cursor for the\npurpose of this event. In effect before_length is counted from the\nbeginning of preedit text, and after_length from its end (see commit\nevent sequence).\n\nValues set with this event are double-buffered. They must be applied\nand reset to initial on the next xx_input_method_v1.commit request.\n\nThe initial values of both before_length and after_length are 0.""apply state\n\nApply state changes from commit_string, set_preedit_string and\ndelete_surrounding_text requests.\n\nThe state relating to these events is double-buffered, and each one\nmodifies the pending state. This request replaces the current state\nwith the pending state.\n\nThe connected text input is expected to proceed by evaluating the\nchanges in the following order:\n\n1. Replace existing preedit string with the cursor.\n2. Delete requested surrounding text.\n3. Insert commit string with the cursor at its end.\n4. Calculate surrounding text to send.\n5. Insert new preedit text in cursor position.\n6. Place cursor inside preedit text.\n\nThe serial number reflects the last state of the xx_input_method_v1\nobject known to the client. The value of the serial argument must be\nequal to the number of done events already issued by that object. When\nthe compositor receives a commit request with a serial different than\nthe number of past done events, it must proceed as normal, except it\nshould not change the current state of the xx_input_method_v1 object.""create popup surface\n\nCreates a new xx_input_popup_surface_v2 object wrapping a given\nsurface.\n\nThe surface gets assigned the \"input_popup\" role. If the surface\nalready has an assigned role, the compositor must issue a protocol\nerror.\n\nIssuing this request before receiving a committed .activate causes the \"inactive\" error.\n\nOnly available since version 2 of the interface"GetInputPopupSurface"destroy the text input\n\nDestroys the zwp_text_input_v2 object and any associated child\nobjects.\n\nThis is a destructor, once sent this object cannot be used any longer.""input method has been requested\n\nNotification that a text input focused on this seat requested the input\nmethod to be activated.\n\nThis event serves the purpose of providing the compositor with an\nactive input method.\n\nThis event resets all state associated with previous enable, disable,\nsurrounding_text, text_change_cause, and content_type events, as well\nas the state associated with set_preedit_string, commit_string, and\ndelete_surrounding_text requests, and destroys any existing input_popup_surface objects.\nIn addition, it marks the xx_input_method_v1 object as active.\n\nThe surrounding_text, and content_type events must follow before the\nnext done event if the text input supports the respective\nfunctionality.\n\nState set with this event is double-buffered. It will get applied on\nthe next xx_input_method_v1.done event, and stay valid until changed.""deactivate event\n\nNotification that no focused text input currently needs an active\ninput method on this seat.\n\nThis event marks the xx_input_method_v1 object as inactive. The\ncompositor must destroy all existing xx_input_popup_surface_v2 objects.\n\nState set with this event is double-buffered. It will get applied on\nthe next xx_input_method_v1.done event, and stay valid until changed.""surrounding text event\n\nUpdates the surrounding plain text around the cursor, excluding the\npreedit text.\n\nIf any preedit text is present, it is replaced with the cursor for the\npurpose of this event.\n\nThe argument text is a buffer containing the preedit string, and must\ninclude the cursor position, and the complete selection. It should\ncontain additional characters before and after these. There is a\nmaximum length of wayland messages, so text can not be longer than 4000\nbytes.\n\ncursor is the byte offset of the cursor within the text buffer.\n\nanchor is the byte offset of the selection anchor within the text\nbuffer. If there is no selected text, anchor must be the same as\ncursor.\n\nIf this event does not arrive before the first done event, the input\nmethod may assume that the text input does not support this\nfunctionality and ignore following surrounding_text events.\n\nValues set with this event are double-buffered. They will get applied\nand set to initial values on the next xx_input_method_v1.done\nevent.\n\nThe initial state for affected fields is empty, meaning that the text\ninput does not support sending surrounding text. If the empty values\nget applied, subsequent attempts to change them may have no effect.""indicates the cause of surrounding text change\n\nTells the input method why the text surrounding the cursor changed.\n\nWhenever the client detects an external change in text, cursor, or\nanchor position, it must issue this request to the compositor. This\nrequest is intended to give the input method a chance to update the\npreedit text in an appropriate way, e.g. by removing it when the user\nstarts typing with a keyboard.\n\ncause describes the source of the change.\n\nThe value set with this event is double-buffered. It will get applied\nand set to its initial value on the next xx_input_method_v1.done\nevent.\n\nThe initial value of cause is input_method."TextChangeCause"content purpose and hint\n\nIndicates the content type and hint for the current\nxx_input_method_v1 instance.\n\nValues set with this event are double-buffered. They will get applied\non the next xx_input_method_v1.done event.\n\nThe initial value for hint is none, and the initial value for purpose\nis normal.""apply state\n\nAtomically applies state changes recently sent to the client.\n\nThe done event establishes and updates the state of the client, and\nmust be issued after any changes to apply them.\n\nText input state (content purpose, content hint, surrounding text, and\nchange cause) is conceptually double-buffered within an input method\ncontext.\n\nEvents modify the pending state, as opposed to the current state in use\nby the input method. A done event atomically applies all pending state,\nreplacing the current state. After done, the new pending state is as\ndocumented for each related request.\n\nEvents must be applied in the order of arrival.\n\nNeither current nor pending state are modified unless noted otherwise.""input method unavailable\n\nThe input method ceased to be available.\n\nThe compositor must issue this event as the only event on the object if\nthere was another input_method object associated with the same seat at\nthe time of its creation.\n\nThe compositor must issue this request when the object is no longer\nuseable, e.g. due to seat removal.\n\nThe input method context becomes inert and should be destroyed after\ndeactivation is handled. Any further requests and events except for the\ndestroy request must be ignored.""input method\n\nAn input method object allows for clients to compose text.\n\nThe objects connects the client to a text input in an application, and\nlets the client to serve as an input method for a seat.\n\nThe xx_input_method_v1 object can occupy two distinct states: active and\ninactive. In the active state, the object is associated to and\ncommunicates with a text input. In the inactive state, there is no\nassociated text input, and the only communication is with the compositor.\nInitially, the input method is in the inactive state.\n\nRequests issued in the inactive state must be accepted by the compositor.\nBecause of the serial mechanism, and the state reset on activate event,\nthey will not have any effect on the state of the next text input.\n\nThere must be no more than one input method object per seat.\n\nSee also the [Event] enum for this interface.""create popup surface\n\nCreates a new xx_input_popup_surface_v2 object wrapping a given\nsurface.\n\nThe surface gets assigned the \"input_popup\" role. If the surface\nalready has an assigned role, the compositor must issue a protocol\nerror.\n\nIssuing this request before receiving a committed .activate causes the \"inactive\" error.""destroy the text input\n\nDestroys the zwp_text_input_v2 object and any associated child\nobjects.""popup surface\n\nAn input method popup surface is a short-lived, temporary surface.\nIt is meant as an area to show suggestions, candidates, or for other input-related uses.\n\nThe compositor should anchor it at the active text input cursor area.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor input_popup_surface state updates to take effect, unless otherwise noted.\n\nAfter the initial wl_surface.commit, the compositor must reply with a configure sequence (see .start_configure) initializing all the compositor-provided state of the popup. That means providing values for:\n\n- width\n- height\n- anchor_x\n- anchor_y\n- anchor_width\n- anchor_height\n- serial\n\nusing the appropriate events.\n\nThe popup will only be presented to the user after the client receives the configure sequence and replies with .ack_configure.\n\nAn example init sequence could look like this:\n\n1. client (Cl): popup = input_method.get_popup(wl_surface, positioner)\n2. Cl: wl_surface.commit()\n3. compositor (Co): popup.start_configure(150, 150, 10, -2, 5, 30)\n5. Co: input_method.done()\n6. Cl: ack_configure()\n7. Cl: wl_surface.commit()\n\nA newly created input_popup_surface will be stacked on top of all previously created\ninput_popup_surfaces associated with the same text input.\n\nA typical sequence resulting from the user selecting a new text field and typing some text:\n\n1. compositor (Co): input_method.enable()\n2. Co: input_method.done()\n3. [init sequence]\n4. Co: input_method.set_surrounding_text(\"new text\")\n5. Co: popup.start_configure(150, 150, -60, -2, 55, 30)\n6. Co: input_method.done()\n7. client (Cl): ack_configure()\n8. Cl: wl_surface.commit()\n\nWhen the corresponding input_method receives a commited .disable event, the popup gets destroyed and becomes invalid and its surface gets unmapped.\n\nThe client must not destroy the underlying wl_surface while the\nxx_input_popup_surface_v2 object exists.""received acknowledgement for a serial has already been acknowledged or has never been issued"EVT_START_CONFIGURE_SINCEEVT_START_CONFIGURE_OPCODE"acknowledge a configure sequence\n\nThis request notifies the compositor that the client updated its surface in response to a configure sequence.\n\nThe purpose of this request is to synchronize the updates of the surface geometry with the surface contents.\nFor example, when the compositor assigns a size larger than prevously, the client must fill the additional space before the popup gets displayed to the user with the new size. When the compositor receives .ack_configure, it can proceed to draw the new size.\n\n.ack_configure should be sent after every submitted configure sequence, passing along the serial received in it.\n\nAn .ack_configure request is conceptually double-buffered.\nEvery request overrides the previous one. The request takes effect once the .commit request is sent on the corresponding surface.\n\nIf the client receives multiple configure sequences before it\ncan respond to one, it may acknowledge only the last configure sequence by using its serial in the .ack_configure request.\n\nCommitting an .ack_configure request consumes the serial number sent with\nthe request, as well as serial numbers sent by all configure sequences\nsubmitted on this input_popup_surface prior to the configure sequence referenced by\nthe committed serial.\n\nCommitting this request with a serial that, for this surface, never appeared in a submitted configure sequence, or one that was already committed before, raises an invalid_serial\nerror.""the serial from the configure sequence""recalculate the popup's location\n\nReposition an already-mapped popup. The popup will be placed given the\ndetails in the passed input_popup_positioner object.\n\nThe request is processed immediately, without the need to issue wl_surface.commit, but the actual repositioning takes place later, after .ack_configure.\n\nThe compositor should reply with a configure sequence including:\n- input_popup_surface.start_configure,\n- input_popup_surface.repositioned, including the token passed in this request.\n\nThis will discard any parameters set by the previous positioner.\n\nIf multiple .reposition requests are sent before the .repositioned event is submitted as part of a configure sequence, the compositor may ignore all\nbut the last one.\n\nThe new popup position will not take\neffect until the corresponding configure sequence is acknowledged by the\nclient. See input_popup_surface.repositioned for details.\n\nThe token itself is opaque, and has no other special meaning.""remove the popup\n\nThis destroys the popup. Explicitly destroying the input_popup_surface\nobject will also dismiss the popup, and unmap the surface.\n\nThis is a destructor, once sent this object cannot be used any longer.""configure the popup surface\n\nThe start_configure event updates the popup geometry and marks the start of a configure sequence.\n\nThe anchor_* arguments represent the geometry of the anchor to which the popup was attached, relative to the upper left corner of the\npopup's surface. Note that this makes anchor_x, anchor_y the reverse of the what they represent in xdg_popup.\n\nA configure sequence is a set of one or more events configuring the state of the\ninput_popup_surface, starting with this event and ending with input_method.done. After the input_method.done event, the configure sequence is considered submitted.\n\nState set by event in a configure sequence is conceptually double-buffered.\nEvery argument overwrites its previous value. The state change should get applied atomically with the input_method.done ending the sequence, and the value of serial should return to the undefined value.\n\nEvents on the input_popup_surface object received outside a configure sequence (while serial is undefined) must be ignored by the client.\n\nA configure sequence shall be sent every time the compositor (re)positions the popup, or the shape of the anchor changes, for example after popup creation, or in response to text being typed and the text cursor moving.\n\nThe client may update the surface in response to input_method.done. Unless the popup is destroyed by the input_method.done, the client must reply with\nan .ack_configure request with the serial sent in the start_configure event at\nsome point after the sequence ends and before committing the new surface.\n\nIf the client receives multiple configure sequences before it can respond\nto one, it is free to discard all but the last event it received.""popup width""popup height""x position relative to anchor geometry"anchor_x"y position relative to anchor geometry"anchor_y"width of the anchor area"anchor_width"height of the anchor area"anchor_height"serial of the configure sequence"StartConfigure"signal the completion of a reposition request\n\nThe compositor sends the .repositioned event in response to the .reposition request to notify about its completion.\n\nThe new geometry of the popup can be communicated using additional events within a configure sequence including:\n- input_popup_surface.start_configure, and\n- the .anchor_position event to update the relative position to the anchor.\n\nWhen responding to a .reposition request, the token argument is the token passed in the that request.\n\nThis event is sent as part of a configure sequence.\nState set by this event is conceptually double-buffered.\nEvery argument overwrites its previous value. The state change should get applied atomically with the next input_method.done event.\n\nThe client should optionally update the content of the popup, but must\nacknowledge the new popup configuration for the new position to take\neffect. See input_popup_surface.ack_configure for details.""popup surface\n\nAn input method popup surface is a short-lived, temporary surface.\nIt is meant as an area to show suggestions, candidates, or for other input-related uses.\n\nThe compositor should anchor it at the active text input cursor area.\n\nThe client must call wl_surface.commit on the corresponding wl_surface\nfor input_popup_surface state updates to take effect, unless otherwise noted.\n\nAfter the initial wl_surface.commit, the compositor must reply with a configure sequence (see .start_configure) initializing all the compositor-provided state of the popup. That means providing values for:\n\n- width\n- height\n- anchor_x\n- anchor_y\n- anchor_width\n- anchor_height\n- serial\n\nusing the appropriate events.\n\nThe popup will only be presented to the user after the client receives the configure sequence and replies with .ack_configure.\n\nAn example init sequence could look like this:\n\n1. client (Cl): popup = input_method.get_popup(wl_surface, positioner)\n2. Cl: wl_surface.commit()\n3. compositor (Co): popup.start_configure(150, 150, 10, -2, 5, 30)\n5. Co: input_method.done()\n6. Cl: ack_configure()\n7. Cl: wl_surface.commit()\n\nA newly created input_popup_surface will be stacked on top of all previously created\ninput_popup_surfaces associated with the same text input.\n\nA typical sequence resulting from the user selecting a new text field and typing some text:\n\n1. compositor (Co): input_method.enable()\n2. Co: input_method.done()\n3. [init sequence]\n4. Co: input_method.set_surrounding_text(\"new text\")\n5. Co: popup.start_configure(150, 150, -60, -2, 55, 30)\n6. Co: input_method.done()\n7. client (Cl): ack_configure()\n8. Cl: wl_surface.commit()\n\nWhen the corresponding input_method receives a commited .disable event, the popup gets destroyed and becomes invalid and its surface gets unmapped.\n\nThe client must not destroy the underlying wl_surface while the\nxx_input_popup_surface_v2 object exists.\n\nSee also the [Event] enum for this interface.""remove the popup\n\nThis destroys the popup. Explicitly destroying the input_popup_surface\nobject will also dismiss the popup, and unmap the surface.""input method popup positioner\n\nThe input_popup_positioner provides a collection of rules for the placement of an input method popup surface relative to the cursor.\nRules can be defined to ensure\nthe text input area remains within the visible area's borders, and to\nspecify how the popup changes its position, such as sliding along\nan axis, or flipping around a rectangle. These positioner-created rules are\nconstrained by the requirement that a popup must intersect with or\nbe at least partially adjacent to the surface containing the text input.\n\nSee the various requests for details about possible rules.\n\nA newly created positioner has the following state:\n- 0 surface width\n- 0 surface height\n- anchor at the center (\"none\")\n- gravity towards the center (\"none\")\n- constraints adjustment set to none\n- offset at x = 0, y = 0\n- not reactive\n\nUpon receiving a request taking the positioner as an argument, the compositor makes a copy of the rules\nspecified by the input_popup_positioner. Thus, after the request is complete the\ninput_popup_positioner object can be destroyed or reused; further changes to the\nobject will have no effect on previous usages.\n\nFor an input_popup_positioner object to be considered complete, its state must contain a non-zero width and height. Passing an incomplete input_popup_positioner object when\npositioning a surface raises an invalid_positioner error.""no edge, specfies center""center to center""don't move the surface when constrained\n\nDon't alter the surface position even if it is constrained on some\naxis, for example partially outside the edge of an output.""destroy the input_popup_positioner object\n\nNotify the compositor that the positioner will no longer be used.\n\nThis is a destructor, once sent this object cannot be used any longer.""set the size of the to-be positioned rectangle\n\nSet the size of the surface that is to be positioned with the positioner\nobject. The size is in surface-local coordinates and corresponds to the\nwindow geometry. See xdg_surface.set_window_geometry.\n\nIf any dimension is set to zero, the invalid_input error is raised.""set anchor rectangle anchor\n\nDefines the anchor point for the anchor rectangle. The specified anchor\nis used to derive an anchor point that the popup surface will be\npositioned relative to. If a corner anchor is set (e.g. 'top_left' or\n'bottom_right'), the anchor point will be at the specified corner;\notherwise, the derived anchor point will be centered on the specified\nedge, or in the center of the anchor rectangle if no edge is specified.""set surface gravity\n\nDefines in what direction the surface should be positioned, relative to\nthe anchor point of the anchor rectangle. If a corner gravity is\nspecified (e.g. 'bottom_right' or 'top_left'), then the surface\nwill be placed towards the specified gravity; otherwise, the child\nsurface will be centered over the anchor point on any axis that had no\ngravity specified. If the gravity is not in the ‘gravity’ enum, an\ninvalid_input error is raised.""set the adjustment to be done when constrained\n\nSpecify how the popup should be positioned if the originally intended\nposition caused the surface to be constrained, meaning at least\npartially outside positioning boundaries set by the compositor. The\nadjustment is set by constructing a bitmask describing the adjustment to\nbe made when the surface is constrained on that axis.\n\nIf no bit for one axis is set, the compositor will assume that the child\nsurface should not change its position on that axis when constrained.\n\nIf more than one bit for one axis is set, the order of how adjustments\nare applied is specified in the corresponding adjustment descriptions.\n\nThe default adjustment is none.""continuously reconstrain the surface\n\nWhen set reactive, the surface is reconstrained if the conditions used\nfor constraining changed, e.g. the window containing the text input moved.\n\nWhenever the conditions change and the popup gets reconstrained, a\nconfigure sequence is sent with updated geometry.""input method popup positioner\n\nThe input_popup_positioner provides a collection of rules for the placement of an input method popup surface relative to the cursor.\nRules can be defined to ensure\nthe text input area remains within the visible area's borders, and to\nspecify how the popup changes its position, such as sliding along\nan axis, or flipping around a rectangle. These positioner-created rules are\nconstrained by the requirement that a popup must intersect with or\nbe at least partially adjacent to the surface containing the text input.\n\nSee the various requests for details about possible rules.\n\nA newly created positioner has the following state:\n- 0 surface width\n- 0 surface height\n- anchor at the center (\"none\")\n- gravity towards the center (\"none\")\n- constraints adjustment set to none\n- offset at x = 0, y = 0\n- not reactive\n\nUpon receiving a request taking the positioner as an argument, the compositor makes a copy of the rules\nspecified by the input_popup_positioner. Thus, after the request is complete the\ninput_popup_positioner object can be destroyed or reused; further changes to the\nobject will have no effect on previous usages.\n\nFor an input_popup_positioner object to be considered complete, its state must contain a non-zero width and height. Passing an incomplete input_popup_positioner object when\npositioning a surface raises an invalid_positioner error.\n\nThis interface has no events.""destroy the input_popup_positioner object\n\nNotify the compositor that the positioner will no longer be used.""input method manager\n\nThe input method manager allows the client to become the input method on\na chosen seat.\n\nNo more than one input method must be associated with any seat at any\ngiven time."REQ_GET_INPUT_METHOD_SINCEREQ_GET_INPUT_METHOD_OPCODEREQ_GET_POSITIONER_SINCEREQ_GET_POSITIONER_OPCODE"request an input method object\n\nRequest a new input xx_input_method_v1 object associated with a given\nseat."GetInputMethodGetPositioner"destroy the input method manager\n\nDestroys the xx_input_method_manager_v2 object.\n\nThe xx_input_method_v1 objects originating from it remain valid.\n\nThis is a destructor, once sent this object cannot be used any longer.""input method manager\n\nThe input method manager allows the client to become the input method on\na chosen seat.\n\nNo more than one input method must be associated with any seat at any\ngiven time.\n\nThis interface has no events.""destroy the input method manager\n\nDestroys the xx_input_method_manager_v2 object.\n\nThe xx_input_method_v1 objects originating from it remain valid."//! This crate provides Wayland object definitions for experimental protocol extensions.//! This crate provides bindings for protocols that are officially evaluated,//! but not recommended for use outside of testing.//! Experimental protocols.//! Those protocols are ready for wider testing, but they may change often and in incompatible ways, or disappear altogether. Software using them should implement the latest version only.//! It is expected that they eventually get promoted to staging or removed.GTK_PRIMARY_SELECTION_DEVICE_MANAGER_INTERFACEgtk_primary_selection_device_manager_requests_create_source_typesgtk_primary_selection_device_manager_requests_get_device_typesgtk_primary_selection_device_manager_requestsgtk_primary_selection_device_manager_interfaceGTK_PRIMARY_SELECTION_DEVICE_INTERFACEgtk_primary_selection_device_requests_set_selection_typesgtk_primary_selection_device_requestsgtk_primary_selection_device_events_data_offer_typesgtk_primary_selection_device_events_selection_typesgtk_primary_selection_device_eventsgtk_primary_selection_device_interfaceGTK_PRIMARY_SELECTION_OFFER_INTERFACEgtk_primary_selection_offer_requestsgtk_primary_selection_offer_eventsgtk_primary_selection_offer_interfaceGTK_PRIMARY_SELECTION_SOURCE_INTERFACEgtk_primary_selection_source_requestsgtk_primary_selection_source_eventsgtk_primary_selection_source_interfaceGtkPrimarySelectionDeviceManagergtk_primary_selection_sourceGtkPrimarySelectionSourcegtk_primary_selection_deviceGtkPrimarySelectionDevicegtk_primary_selection_device_manager"set the primary selection\n\nReplaces the current selection. The previous owner of the primary selection\nwill receive a wp_primary_selection_source.cancelled event.\n\nTo unset the selection, set the source to NULL."gtk_primary_selection_offerGtkPrimarySelectionOffer"gtk_primary_selection_device\n\nSee also the [Event] enum for this interface.""offer to transfer primary selection contents\n\nA wp_primary_selection_offer represents an offer to transfer the contents\nof the primary selection clipboard to the client. Similar to\nwl_data_offer, the offer also describes the mime types that the source\nwill transferthat the\ndata can be converted to and provides the mechanisms for transferring the\ndata directly to the client.""advertise offered mime type\n\nSent immediately after creating announcing the wp_primary_selection_offer\nthrough wp_primary_selection_device.data_offer. One event is sent per\noffered mime type.""offer to transfer primary selection contents\n\nA wp_primary_selection_offer represents an offer to transfer the contents\nof the primary selection clipboard to the client. Similar to\nwl_data_offer, the offer also describes the mime types that the source\nwill transferthat the\ndata can be converted to and provides the mechanisms for transferring the\ndata directly to the client.\n\nSee also the [Event] enum for this interface."//! Gtk primary selection protocol//! This protocol provides the ability to have a primary selection device to//! match that of the X server. This primary selection is a shortcut to the//! common clipboard selection, where text just needs to be selected in order//! to allow copying it elsewhere. The de facto way to perform this action//! is the middle mouse button, although it is not limited to this one.//! Clients wishing to honor primary selection should create a primary//! selection source and set it as the selection through//! `wp_primary_selection_device.set_selection` whenever the text selection//! changes. In order to minimize calls in pointer-driven text selection,//! it should happen only once after the operation finished. Similarly,//! a NULL source should be set when text is unselected.//! `wp_primary_selection_offer` objects are first announced through the//! `wp_primary_selection_device.data_offer` event. Immediately after this event,//! the primary data offer will emit `wp_primary_selection_offer.offer` events//! to let know of the mime types being offered.//! When the primary selection changes, the client with the keyboard focus//! will receive `wp_primary_selection_device.selection` events. Only the client//! with the keyboard focus will receive such events with a non-NULL//! `wp_primary_selection_offer`. Across keyboard focus changes, previously//! focused clients will receive `wp_primary_selection_device.events` with a//! NULL `wp_primary_selection_offer`.//! In order to request the primary selection data, the client must pass//! a recent serial pertaining to the press event that is triggering the//! operation, if the compositor deems the serial valid and recent, the//! `wp_primary_selection_source.send` event will happen in the other end//! to let the transfer begin. The client owning the primary selection//! should write the requested data, and close the file descriptor//! immediately.//! If the primary selection owner client disappeared during the transfer,//! the client reading the data will receive a//! `wp_primary_selection_device.selection` event with a NULL//! `wp_primary_selection_offer`, the client should take this as a hint//! to finish the reads related to the no longer existing offer.//! The primary selection owner should be checking for errors during//! writes, merely cancelling the ongoing transfer if any happened.gtk_primary_selectionZWP_INPUT_METHOD_V2_INTERFACEzwp_input_method_v2_requests_get_input_popup_surface_typeszwp_input_method_v2_requests_grab_keyboard_typeszwp_input_method_v2_requestszwp_input_method_v2_eventszwp_input_method_v2_interfaceZWP_INPUT_POPUP_SURFACE_V2_INTERFACEzwp_input_popup_surface_v2_requestszwp_input_popup_surface_v2_eventszwp_input_popup_surface_v2_interfaceZWP_INPUT_METHOD_KEYBOARD_GRAB_V2_INTERFACEzwp_input_method_keyboard_grab_v2_requestszwp_input_method_keyboard_grab_v2_eventszwp_input_method_keyboard_grab_v2_interfaceZWP_INPUT_METHOD_MANAGER_V2_INTERFACEzwp_input_method_manager_v2_requests_get_input_method_typeszwp_input_method_manager_v2_requestszwp_input_method_manager_v2_interface"input method\n\nAn input method object allows for clients to compose text.\n\nThe objects connects the client to a text input in an application, and\nlets the client to serve as an input method for a seat.\n\nThe zwp_input_method_v2 object can occupy two distinct states: active and\ninactive. In the active state, the object is associated to and\ncommunicates with a text input. In the inactive state, there is no\nassociated text input, and the only communication is with the compositor.\nInitially, the input method is in the inactive state.\n\nRequests issued in the inactive state must be accepted by the compositor.\nBecause of the serial mechanism, and the state reset on activate event,\nthey will not have any effect on the state of the next text input.\n\nThere must be no more than one input method object per seat.""pre-edit string\n\nSend the pre-edit string text to the application text input.\n\nPlace a new composing text (pre-edit) at the current cursor position.\nAny previously set composing text must be removed. Any previously\nexisting selected text must be removed. The cursor is moved to a new\nposition within the preedit string.\n\nThe argument text is a buffer containing the preedit string. There is\na maximum length of wayland messages, so text can not be longer than\n4000 bytes.\n\nThe arguments cursor_begin and cursor_end are counted in bytes relative\nto the beginning of the submitted string buffer. Cursor should be\nhidden by the text input when both are equal to -1.\n\ncursor_begin indicates the beginning of the cursor. cursor_end\nindicates the end of the cursor. It may be equal or different than\ncursor_begin.\n\nValues set with this event are double-buffered. They must be applied on\nthe next zwp_input_method_v2.commit event.\n\nThe initial value of text is an empty string. The initial value of\ncursor_begin, and cursor_end are both 0.""delete text\n\nRemove the surrounding text.\n\nbefore_length and after_length are the number of bytes before and after\nthe current cursor index (excluding the preedit text) to delete.\n\nIf any preedit text is present, it is replaced with the cursor for the\npurpose of this event. In effect before_length is counted from the\nbeginning of preedit text, and after_length from its end (see commit\nevent sequence).\n\nValues set with this event are double-buffered. They must be applied\nand reset to initial on the next zwp_input_method_v2.commit request.\n\nThe initial values of both before_length and after_length are 0.""apply state\n\nApply state changes from commit_string, set_preedit_string and\ndelete_surrounding_text requests.\n\nThe state relating to these events is double-buffered, and each one\nmodifies the pending state. This request replaces the current state\nwith the pending state.\n\nThe connected text input is expected to proceed by evaluating the\nchanges in the following order:\n\n1. Replace existing preedit string with the cursor.\n2. Delete requested surrounding text.\n3. Insert commit string with the cursor at its end.\n4. Calculate surrounding text to send.\n5. Insert new preedit text in cursor position.\n6. Place cursor inside preedit text.\n\nThe serial number reflects the last state of the zwp_input_method_v2\nobject known to the client. The value of the serial argument must be\nequal to the number of done events already issued by that object. When\nthe compositor receives a commit request with a serial different than\nthe number of past done events, it must proceed as normal, except it\nshould not change the current state of the zwp_input_method_v2 object.""create popup surface\n\nCreates a new zwp_input_popup_surface_v2 object wrapping a given\nsurface.\n\nThe surface gets assigned the \"input_popup\" role. If the surface\nalready has an assigned role, the compositor must issue a protocol\nerror.""grab hardware keyboard\n\nAllow an input method to receive hardware keyboard input and process\nkey events to generate text events (with pre-edit) over the wire. This\nallows input methods which compose multiple key events for inputting\ntext like it is done for CJK languages.\n\nThe compositor should send all keyboard events on the seat to the grab\nholder via the returned wl_keyboard object. Nevertheless, the\ncompositor may decide not to forward any particular event. The\ncompositor must not further process any event after it has been\nforwarded to the grab holder.\n\nReleasing the resulting wl_keyboard object releases the grab.""destroy the text input\n\nDestroys the zwp_text_input_v2 object and any associated child\nobjects, i.e. zwp_input_popup_surface_v2 and\nzwp_input_method_keyboard_grab_v2.\n\nThis is a destructor, once sent this object cannot be used any longer.""input method has been requested\n\nNotification that a text input focused on this seat requested the input\nmethod to be activated.\n\nThis event serves the purpose of providing the compositor with an\nactive input method.\n\nThis event resets all state associated with previous enable, disable,\nsurrounding_text, text_change_cause, and content_type events, as well\nas the state associated with set_preedit_string, commit_string, and\ndelete_surrounding_text requests. In addition, it marks the\nzwp_input_method_v2 object as active, and makes any existing\nzwp_input_popup_surface_v2 objects visible.\n\nThe surrounding_text, and content_type events must follow before the\nnext done event if the text input supports the respective\nfunctionality.\n\nState set with this event is double-buffered. It will get applied on\nthe next zwp_input_method_v2.done event, and stay valid until changed.""deactivate event\n\nNotification that no focused text input currently needs an active\ninput method on this seat.\n\nThis event marks the zwp_input_method_v2 object as inactive. The\ncompositor must make all existing zwp_input_popup_surface_v2 objects\ninvisible until the next activate event.\n\nState set with this event is double-buffered. It will get applied on\nthe next zwp_input_method_v2.done event, and stay valid until changed.""surrounding text event\n\nUpdates the surrounding plain text around the cursor, excluding the\npreedit text.\n\nIf any preedit text is present, it is replaced with the cursor for the\npurpose of this event.\n\nThe argument text is a buffer containing the preedit string, and must\ninclude the cursor position, and the complete selection. It should\ncontain additional characters before and after these. There is a\nmaximum length of wayland messages, so text can not be longer than 4000\nbytes.\n\ncursor is the byte offset of the cursor within the text buffer.\n\nanchor is the byte offset of the selection anchor within the text\nbuffer. If there is no selected text, anchor must be the same as\ncursor.\n\nIf this event does not arrive before the first done event, the input\nmethod may assume that the text input does not support this\nfunctionality and ignore following surrounding_text events.\n\nValues set with this event are double-buffered. They will get applied\nand set to initial values on the next zwp_input_method_v2.done\nevent.\n\nThe initial state for affected fields is empty, meaning that the text\ninput does not support sending surrounding text. If the empty values\nget applied, subsequent attempts to change them may have no effect.""indicates the cause of surrounding text change\n\nTells the input method why the text surrounding the cursor changed.\n\nWhenever the client detects an external change in text, cursor, or\nanchor position, it must issue this request to the compositor. This\nrequest is intended to give the input method a chance to update the\npreedit text in an appropriate way, e.g. by removing it when the user\nstarts typing with a keyboard.\n\ncause describes the source of the change.\n\nThe value set with this event is double-buffered. It will get applied\nand set to its initial value on the next zwp_input_method_v2.done\nevent.\n\nThe initial value of cause is input_method.""content purpose and hint\n\nIndicates the content type and hint for the current\nzwp_input_method_v2 instance.\n\nValues set with this event are double-buffered. They will get applied\non the next zwp_input_method_v2.done event.\n\nThe initial value for hint is none, and the initial value for purpose\nis normal.""input method\n\nAn input method object allows for clients to compose text.\n\nThe objects connects the client to a text input in an application, and\nlets the client to serve as an input method for a seat.\n\nThe zwp_input_method_v2 object can occupy two distinct states: active and\ninactive. In the active state, the object is associated to and\ncommunicates with a text input. In the inactive state, there is no\nassociated text input, and the only communication is with the compositor.\nInitially, the input method is in the inactive state.\n\nRequests issued in the inactive state must be accepted by the compositor.\nBecause of the serial mechanism, and the state reset on activate event,\nthey will not have any effect on the state of the next text input.\n\nThere must be no more than one input method object per seat.\n\nSee also the [Event] enum for this interface."zwp_input_popup_surface_v2ZwpInputPopupSurfaceV2zwp_input_method_keyboard_grab_v2ZwpInputMethodKeyboardGrabV2"destroy the text input\n\nDestroys the zwp_text_input_v2 object and any associated child\nobjects, i.e. zwp_input_popup_surface_v2 and\nzwp_input_method_keyboard_grab_v2.""popup surface\n\nThis interface marks a surface as a popup for interacting with an input\nmethod.\n\nThe compositor should place it near the active text input area. It must\nbe visible if and only if the input method is in the active state.\n\nThe client must not destroy the underlying wl_surface while the\nzwp_input_popup_surface_v2 object exists."EVT_TEXT_INPUT_RECTANGLE_SINCEEVT_TEXT_INPUT_RECTANGLE_OPCODE"set text input area position\n\nNotify about the position of the area of the text input expressed as a\nrectangle in surface local coordinates.\n\nThis is a hint to the input method telling it the relative position of\nthe text being entered."TextInputRectangle"popup surface\n\nThis interface marks a surface as a popup for interacting with an input\nmethod.\n\nThe compositor should place it near the active text input area. It must\nbe visible if and only if the input method is in the active state.\n\nThe client must not destroy the underlying wl_surface while the\nzwp_input_popup_surface_v2 object exists.\n\nSee also the [Event] enum for this interface.""keyboard grab\n\nThe zwp_input_method_keyboard_grab_v2 interface represents an exclusive\ngrab of the wl_keyboard interface associated with the seat.""release the grab object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""keyboard mapping\n\nThis event provides a file descriptor to the client which can be\nmemory-mapped to provide a keyboard mapping description.""key event\n\nA key was pressed or released.\nThe time argument is a timestamp with millisecond granularity, with an\nundefined base.""modifier and group state\n\nNotifies clients that the modifier and/or group state has changed, and\nit should update its local state.""repeat rate and delay\n\nInforms the client about the keyboard's repeat rate and delay.\n\nThis event is sent as soon as the zwp_input_method_keyboard_grab_v2\nobject has been created, and is guaranteed to be received by the\nclient before any key press event.\n\nNegative values for either rate or delay are illegal. A rate of zero\nwill disable any repeating (regardless of the value of delay).\n\nThis event can be sent later on as well with a new value if necessary,\nso clients should continue listening for the event past the creation\nof zwp_input_method_keyboard_grab_v2.""keyboard grab\n\nThe zwp_input_method_keyboard_grab_v2 interface represents an exclusive\ngrab of the wl_keyboard interface associated with the seat.\n\nSee also the [Event] enum for this interface.""release the grab object""request an input method object\n\nRequest a new input zwp_input_method_v2 object associated with a given\nseat.""destroy the input method manager\n\nDestroys the zwp_input_method_manager_v2 object.\n\nThe zwp_input_method_v2 objects originating from it remain valid.\n\nThis is a destructor, once sent this object cannot be used any longer.""destroy the input method manager\n\nDestroys the zwp_input_method_manager_v2 object.\n\nThe zwp_input_method_v2 objects originating from it remain valid."//! Input method v2 unstable//! An input method context is used to manage the state of the input method.//! Text strings are UTF-8 encoded, their indices and lengths are in bytes.//! This document adheres to the RFC 2119 when using words like "must",//! "should", "may", etc.//! Warning! The protocol described in this file is experimental and//! backward incompatible changes may be made. Backward compatible changes//! may be added together with the corresponding interface version bump.//! Backward incompatible changes are done by bumping the version number in//! the protocol and interface names and resetting the interface version.//! Once the protocol is to be declared stable, the 'z' prefix and the//! version number in the protocol and interface names are removed and the//! interface version number is reset.ZWP_VIRTUAL_KEYBOARD_V1_INTERFACEzwp_virtual_keyboard_v1_requestszwp_virtual_keyboard_v1_interfaceZWP_VIRTUAL_KEYBOARD_MANAGER_V1_INTERFACEzwp_virtual_keyboard_manager_v1_requests_create_virtual_keyboard_typeszwp_virtual_keyboard_manager_v1_requestszwp_virtual_keyboard_manager_v1_interface"virtual keyboard\n\nThe virtual keyboard provides an application with requests which emulate\nthe behaviour of a physical keyboard.\n\nThis interface can be used by clients on its own to provide raw input\nevents, or it can accompany the input method protocol.""No keymap was set"REQ_KEYMAP_SINCEREQ_KEYMAP_OPCODE"keyboard mapping\n\nProvide a file descriptor to the compositor which can be\nmemory-mapped to provide a keyboard mapping description.\n\nFormat carries a value from the keymap_format enumeration.""key event\n\nA key was pressed or released.\nThe time argument is a timestamp with millisecond granularity, with an\nundefined base. All requests regarding a single object must share the\nsame clock.\n\nKeymap must be set before issuing this request.\n\nState carries a value from the key_state enumeration.""modifier and group state\n\nNotifies the compositor that the modifier and/or group state has\nchanged, and it should update state.\n\nThe client should use wl_keyboard.modifiers event to synchronize its\ninternal state with seat state.\n\nKeymap must be set before issuing this request.""destroy the virtual keyboard keyboard object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""virtual keyboard\n\nThe virtual keyboard provides an application with requests which emulate\nthe behaviour of a physical keyboard.\n\nThis interface can be used by clients on its own to provide raw input\nevents, or it can accompany the input method protocol.\n\nThis interface has no events."ZwpVirtualKeyboardV1"destroy the virtual keyboard keyboard object"zwp_virtual_keyboard_v1"virtual keyboard manager\n\nA virtual keyboard manager allows an application to provide keyboard\ninput events as if they came from a physical keyboard.""client not authorized to use the interface"REQ_CREATE_VIRTUAL_KEYBOARD_SINCEREQ_CREATE_VIRTUAL_KEYBOARD_OPCODE"Create a new virtual keyboard\n\nCreates a new virtual keyboard associated to a seat.\n\nIf the compositor enables a keyboard to perform arbitrary actions, it\nshould present an error when an untrusted client requests a new\nkeyboard."CreateVirtualKeyboard"virtual keyboard manager\n\nA virtual keyboard manager allows an application to provide keyboard\ninput events as if they came from a physical keyboard.\n\nThis interface has no events."ZwpVirtualKeyboardManagerV1create_virtual_keyboardzwp_virtual_keyboard_manager_v1//! Virtual keyboard v1 unstable//! The virtual keyboard provides an application with requests which emulate//! the behaviour of a physical keyboard.//! This interface can be used by clients on its own to provide raw input//! events, or it can accompany the input method protocol.ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_INTERFACEorg_kde_kwin_server_decoration_manager_requests_create_typesorg_kde_kwin_server_decoration_manager_requestsorg_kde_kwin_server_decoration_manager_eventsorg_kde_kwin_server_decoration_manager_interfaceORG_KDE_KWIN_SERVER_DECORATION_INTERFACEorg_kde_kwin_server_decoration_requestsorg_kde_kwin_server_decoration_eventsorg_kde_kwin_server_decoration_interface"Server side window decoration manager\n\nThis interface allows to coordinate whether the server should create\na server-side window decoration around a wl_surface representing a\nshell surface (wl_shell_surface or similar). By announcing support\nfor this interface the server indicates that it supports server\nside decorations.\n\nUse in conjunction with zxdg_decoration_manager_v1 is undefined.""Possible values to use in request_mode and the event mode.""Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated.""Client-side decoration: The decoration is part of the surface and the client.""Server-side decoration: The server embeds the surface into a decoration frame."EVT_DEFAULT_MODE_SINCEEVT_DEFAULT_MODE_OPCODE"Create a server-side decoration object for a given surface\n\nWhen a client creates a server-side decoration object it indicates\nthat it supports the protocol. The client is supposed to tell the\nserver whether it wants server-side decorations or will provide\nclient-side decorations.\n\nIf the client does not create a server-side decoration object for\na surface the server interprets this as lack of support for this\nprotocol and considers it as client-side decorated. Nevertheless a\nclient-side decorated surface should use this protocol to indicate\nto the server that it does not want a server-side deco.""The default mode used on the server\n\nThis event is emitted directly after binding the interface. It contains\nthe default mode for the decoration. When a new server decoration object\nis created this new object will be in the default mode until the first\nrequest_mode is requested.\n\nThe server may change the default mode at any time.""The default decoration mode applied to newly created server decorations."DefaultMode"Server side window decoration manager\n\nThis interface allows to coordinate whether the server should create\na server-side window decoration around a wl_surface representing a\nshell surface (wl_shell_surface or similar). By announcing support\nfor this interface the server indicates that it supports server\nside decorations.\n\nUse in conjunction with zxdg_decoration_manager_v1 is undefined.\n\nSee also the [Event] enum for this interface."OrgKdeKwinServerDecorationManagerorg_kde_kwin_server_decorationOrgKdeKwinServerDecorationorg_kde_kwin_server_decoration_managerREQ_REQUEST_MODE_SINCEREQ_REQUEST_MODE_OPCODE"release the server decoration object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""The decoration mode the surface wants to use.""The mode this surface wants to use."RequestMode"The new decoration mode applied by the server\n\nThis event is emitted directly after the decoration is created and\nrepresents the base decoration policy by the server. E.g. a server\nwhich wants all surfaces to be client-side decorated will send Client,\na server which wants server-side decoration will send Server.\n\nThe client can request a different mode through the decoration request.\nThe server will acknowledge this by another event with the same mode. So\neven if a server prefers server-side decoration it's possible to force a\nclient-side decoration.\n\nThe server may emit this event at any time. In this case the client can\nagain request a different mode. It's the responsibility of the server to\nprevent a feedback loop.""The decoration mode applied to the surface by the server.""org_kde_kwin_server_decoration\n\nSee also the [Event] enum for this interface.""release the server decoration object"//! KDE server decoration protocol//! This interface allows to coordinate whether the server should create//! a server-side window decoration around a wl_surface representing a//! shell surface (wl_shell_surface or similar). By announcing support//! for this interface the server indicates that it supports server//! side decorations.//! Use in conjunction with zxdg_decoration_manager_v1 is undefined.server_decoration//! This crate provides Wayland object definitions for various orphan or deprecated protocol extensions.//! This crate provides bindings for protocols that are generally not officially supported,//! but are *de facto* used by a non-negligible number of projets in the wayland ecosystem.ORG_KDE_KWIN_APPMENU_MANAGER_INTERFACEorg_kde_kwin_appmenu_manager_requests_create_typesorg_kde_kwin_appmenu_manager_requestsorg_kde_kwin_appmenu_manager_interfaceORG_KDE_KWIN_APPMENU_INTERFACEorg_kde_kwin_appmenu_requestsorg_kde_kwin_appmenu_interface"appmenu dbus address interface\n\nThis interface allows a client to link a window (or wl_surface) to an com.canonical.dbusmenu\ninterface registered on DBus.""appmenu dbus address interface\n\nThis interface allows a client to link a window (or wl_surface) to an com.canonical.dbusmenu\ninterface registered on DBus.\n\nThis interface has no events."OrgKdeKwinAppmenuManagerorg_kde_kwin_appmenuOrgKdeKwinAppmenuorg_kde_kwin_appmenu_manager"appmenu dbus address interface\n\nThe DBus service name and object path where the appmenu interface is present\nThe object should be registered on the session bus before sending this request.\nIf not applicable, clients should remove this object."REQ_SET_ADDRESS_SINCEREQ_SET_ADDRESS_OPCODE"initialise or update the location of the AppMenu interface\n\nSet or update the service name and object path.\nStrings should be formatted in Latin-1 matching the relevant DBus specifications."service_name"release the appmenu object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""appmenu dbus address interface\n\nThe DBus service name and object path where the appmenu interface is present\nThe object should be registered on the session bus before sending this request.\nIf not applicable, clients should remove this object.\n\nThis interface has no events.""release the appmenu object"appmenuORG_KDE_KWIN_BLUR_MANAGER_INTERFACEorg_kde_kwin_blur_manager_requests_create_typesorg_kde_kwin_blur_manager_requests_unset_typesorg_kde_kwin_blur_manager_requestsorg_kde_kwin_blur_manager_interfaceORG_KDE_KWIN_BLUR_INTERFACEorg_kde_kwin_blur_requests_set_region_typesorg_kde_kwin_blur_requestsorg_kde_kwin_blur_interfaceREQ_UNSET_SINCEREQ_UNSET_OPCODE"org_kde_kwin_blur_manager\n\nThis interface has no events."OrgKdeKwinBlurManagerorg_kde_kwin_blurOrgKdeKwinBlurorg_kde_kwin_blur_manager"release the blur object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""org_kde_kwin_blur\n\nThis interface has no events.""release the blur object"ORG_KDE_KWIN_CONTRAST_MANAGER_INTERFACEorg_kde_kwin_contrast_manager_requests_create_typesorg_kde_kwin_contrast_manager_requests_unset_typesorg_kde_kwin_contrast_manager_requestsorg_kde_kwin_contrast_manager_interfaceORG_KDE_KWIN_CONTRAST_INTERFACEorg_kde_kwin_contrast_requests_set_region_typesorg_kde_kwin_contrast_requestsorg_kde_kwin_contrast_interface"org_kde_kwin_contrast_manager\n\nThis interface has no events."OrgKdeKwinContrastManagerorg_kde_kwin_contrastOrgKdeKwinContrastorg_kde_kwin_contrast_managerREQ_SET_CONTRAST_SINCEREQ_SET_CONTRAST_OPCODEREQ_SET_INTENSITY_SINCEREQ_SET_INTENSITY_OPCODEREQ_SET_SATURATION_SINCEREQ_SET_SATURATION_OPCODEREQ_SET_FROST_SINCEREQ_SET_FROST_OPCODEREQ_UNSET_FROST_SINCEREQ_UNSET_FROST_OPCODESetContrastintensitySetIntensitySetSaturation"release the contrast object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""opt into frost effect w/ given colour\n\nenables 'frost' variant of contrast effect.\n\n'frost' is an enhanced version of the contrast effect that\nuses different colour arithmetic to get backgrounds simultaneously\nhigher in contrast and (apparent) transparency.\n\nr, g, b, a are channels from 0-255, indicating a colour to use in contrast calculation.\nshould be based off of the \"main\" background colour of the surface.\n\nOnly available since version 2 of the interface"SetFrost"opts out of frost effect\n\n\n\nOnly available since version 2 of the interface"UnsetFrost"org_kde_kwin_contrast\n\nThis interface has no events."set_contrastset_intensityset_saturation"release the contrast object""opt into frost effect w/ given colour\n\nenables 'frost' variant of contrast effect.\n\n'frost' is an enhanced version of the contrast effect that\nuses different colour arithmetic to get backgrounds simultaneously\nhigher in contrast and (apparent) transparency.\n\nr, g, b, a are channels from 0-255, indicating a colour to use in contrast calculation.\nshould be based off of the \"main\" background colour of the surface."set_frost"opts out of frost effect"unset_frostORG_KDE_KWIN_DPMS_MANAGER_INTERFACEorg_kde_kwin_dpms_manager_requests_get_typesorg_kde_kwin_dpms_manager_requestsorg_kde_kwin_dpms_manager_interfaceORG_KDE_KWIN_DPMS_INTERFACEorg_kde_kwin_dpms_requestsorg_kde_kwin_dpms_eventsorg_kde_kwin_dpms_interface"Output dpms manager\n\nThe Dpms manager allows to get a org_kde_kwin_dpms for a given wl_output.\nThe org_kde_kwin_dpms provides the currently used VESA Display Power Management\nSignaling state (see https://en.wikipedia.org/wiki/VESA_Display_Power_Management_Signaling ).\nIn addition it allows to request a state change. A compositor is not obliged to honor it\nand will normally automatically switch back to on state."REQ_GET_SINCEREQ_GET_OPCODE"Get org_kde_kwin_dpms for wl_output\n\nFactory request to get the org_kde_kwin_dpms for a given wl_output.""Output dpms manager\n\nThe Dpms manager allows to get a org_kde_kwin_dpms for a given wl_output.\nThe org_kde_kwin_dpms provides the currently used VESA Display Power Management\nSignaling state (see https://en.wikipedia.org/wiki/VESA_Display_Power_Management_Signaling ).\nIn addition it allows to request a state change. A compositor is not obliged to honor it\nand will normally automatically switch back to on state.\n\nThis interface has no events."OrgKdeKwinDpmsManagerorg_kde_kwin_dpmsOrgKdeKwinDpmsorg_kde_kwin_dpms_manager"Dpms for a wl_output\n\nThis interface provides information about the VESA DPMS state for a wl_output.\nIt gets created through the request get on the org_kde_kwin_dpms_manager interface.\n\nOn creating the resource the server will push whether DPSM is supported for the output,\nthe currently used DPMS state and notifies the client through the done event once all\nstates are pushed. Whenever a state changes the set of changes is committed with the\ndone event."REQ_SET_SINCEREQ_SET_OPCODEEVT_SUPPORTED_SINCEEVT_SUPPORTED_OPCODE"Request DPMS state change for the wl_output\n\nRequests that the compositor puts the wl_output into the passed mode. The compositor\nis not obliged to change the state. In addition the compositor might leave the mode\nwhenever it seems suitable. E.g. the compositor might return to On state on user input.\n\nThe client should not assume that the mode changed after requesting a new mode.\nInstead the client should listen for the mode event.""Requested mode""release the dpms object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""Event indicating whether DPMS is supported on the wl_output\n\nThis event gets pushed on binding the resource and indicates whether the wl_output\nsupports DPMS. There are operation modes of a Wayland server where DPMS might not\nmake sense (e.g. nested compositors).""Boolean value whether DPMS is supported (1) for the wl_output or not (0)"Supported"Event indicating used DPMS mode\n\nThis mode gets pushed on binding the resource and provides the currently used\nDPMS mode. It also gets pushed if DPMS is not supported for the wl_output, in that\ncase the value will be On.\n\nThe event is also pushed whenever the state changes.""The new currently used mode""All changes are pushed\n\nThis event gets pushed on binding the resource once all other states are pushed.\n\nIn addition it gets pushed whenever a state changes to tell the client that all\nstate changes have been pushed.""Dpms for a wl_output\n\nThis interface provides information about the VESA DPMS state for a wl_output.\nIt gets created through the request get on the org_kde_kwin_dpms_manager interface.\n\nOn creating the resource the server will push whether DPSM is supported for the output,\nthe currently used DPMS state and notifies the client through the done event once all\nstates are pushed. Whenever a state changes the set of changes is committed with the\ndone event.\n\nSee also the [Event] enum for this interface.""release the dpms object"ORG_KDE_KWIN_FAKE_INPUT_INTERFACEorg_kde_kwin_fake_input_requestsorg_kde_kwin_fake_input_interface"Fake input manager\n\nThis interface allows other processes to provide fake input events.\nPurpose is on the one hand side to provide testing facilities like XTest on X11.\nBut also to support use case like kdeconnect's mouse pad interface.\n\nA compositor should not trust the input received from this interface.\nClients should not expect that the compositor honors the requests from this\ninterface."REQ_AUTHENTICATE_SINCEREQ_AUTHENTICATE_OPCODEREQ_POINTER_MOTION_SINCEREQ_POINTER_MOTION_OPCODEREQ_BUTTON_SINCEREQ_BUTTON_OPCODEREQ_AXIS_SINCEREQ_AXIS_OPCODEREQ_TOUCH_DOWN_SINCEREQ_TOUCH_DOWN_OPCODEREQ_TOUCH_MOTION_SINCEREQ_TOUCH_MOTION_OPCODEREQ_TOUCH_UP_SINCEREQ_TOUCH_UP_OPCODEREQ_TOUCH_CANCEL_SINCEREQ_TOUCH_CANCEL_OPCODEREQ_TOUCH_FRAME_SINCEREQ_TOUCH_FRAME_OPCODEREQ_POINTER_MOTION_ABSOLUTE_SINCEREQ_POINTER_MOTION_ABSOLUTE_OPCODEREQ_KEYBOARD_KEY_SINCEREQ_KEYBOARD_KEY_OPCODE"Information why the client wants to use the interface\n\nA client should use this request to tell the compositor why it wants to\nuse this interface. The compositor might use the information to decide\nwhether it wants to grant the request. The data might also be passed to\nthe user to decide whether the application should get granted access to\nthis very privileged interface.""user visible name of the application""reason why the application wants to use this interface"AuthenticatePointerMotion"touch down event\n\nA client should use this request to send touch down event at specific\ncoordinates.\n\nOnly available since version 2 of the interface""unique id for touch down event""x coordinate for touch down event""y coordinate for touch down event"TouchDown"touch motion event\n\nA client should use this request to send touch motion to specific position.\n\nOnly available since version 2 of the interface""unique id for touch motion event""x coordinate for touch motion event""y coordinate for touch motion event"TouchMotion"touch up event\n\nA client should use this request to send touch up event.\n\nOnly available since version 2 of the interface""unique id for touch up event"TouchUp"touch cancel event\n\nA client should use this request to cancel the current\ntouch event.\n\nOnly available since version 2 of the interface""touch frame event\n\nA client should use this request to send touch frame event.\n\nOnly available since version 2 of the interface"TouchFrame"Only available since version 3 of the interface"PointerMotionAbsolute"Only available since version 4 of the interface"KeyboardKey"Fake input manager\n\nThis interface allows other processes to provide fake input events.\nPurpose is on the one hand side to provide testing facilities like XTest on X11.\nBut also to support use case like kdeconnect's mouse pad interface.\n\nA compositor should not trust the input received from this interface.\nClients should not expect that the compositor honors the requests from this\ninterface.\n\nThis interface has no events."OrgKdeKwinFakeInputpointer_motion"touch down event\n\nA client should use this request to send touch down event at specific\ncoordinates."touch_down"touch motion event\n\nA client should use this request to send touch motion to specific position."touch_motion"touch up event\n\nA client should use this request to send touch up event."touch_up"touch cancel event\n\nA client should use this request to cancel the current\ntouch event."touch_cancel"touch frame event\n\nA client should use this request to send touch frame event."touch_framepointer_motion_absolutekeyboard_keyorg_kde_kwin_fake_inputfake_input_WL_FULLSCREEN_SHELL_INTERFACE_wl_fullscreen_shell_requests_present_surface_types_wl_fullscreen_shell_requests_present_surface_for_mode_types_wl_fullscreen_shell_requests_wl_fullscreen_shell_events_wl_fullscreen_shell_interface_WL_FULLSCREEN_SHELL_MODE_FEEDBACK_INTERFACE_wl_fullscreen_shell_mode_feedback_events_wl_fullscreen_shell_mode_feedback_interface"Displays a single surface per output\n\nDisplays a single surface per output.\n\nThis interface provides a mechanism for a single client to display\nsimple full-screen surfaces.  While there technically may be multiple\nclients bound to this interface, only one of those clients should be\nshown at a time.\n\nTo present a surface, the client uses either the present_surface or\npresent_surface_for_mode requests.  Presenting a surface takes effect\non the next wl_surface.commit.  See the individual requests for\ndetails about scaling and mode switches.\n\nThe client can have at most one surface per output at any time.\nRequesting a surface be presented on an output that already has a\nsurface replaces the previously presented surface.  Presenting a null\nsurface removes its content and effectively disables the output.\nExactly what happens when an output is \"disabled\" is\ncompositor-specific.  The same surface may be presented on multiple\noutputs simultaneously.\n\nOnce a surface is presented on an output, it stays on that output\nuntil either the client removes it or the compositor destroys the\noutput.  This way, the client can update the output's contents by\nsimply attaching a new buffer.""capabilities advertised by the compositor\n\nVarious capabilities that can be advertised by the compositor.  They\nare advertised one-at-a-time when the wl_fullscreen_shell interface is\nbound.  See the wl_fullscreen_shell.capability event for more details.\n\nARBITRARY_MODE:\nThis is a hint to the client that indicates that the compositor is\ncapable of setting practically any mode on its outputs.  If this\ncapability is provided, wl_fullscreen_shell.present_surface_for_mode\nwill almost never fail and clients should feel free to set whatever\nmode they like.  If the compositor does not advertise this, it may\nstill support some modes that are not advertised through wl_global.mode\nbut it is less likely.\n\nCURSOR_PLANE:\nThis is a hint to the client that indicates that the compositor can\nhandle a cursor surface from the client without actually compositing.\nThis may be because of a hardware cursor plane or some other mechanism.\nIf the compositor does not advertise this capability then setting\nwl_pointer.cursor may degrade performance or be ignored entirely.  If\nCURSOR_PLANE is not advertised, it is recommended that the client draw\nits own cursor and set wl_pointer.cursor(NULL).""wl_fullscreen_shell error values\n\nThese errors can be emitted in response to wl_fullscreen_shell requests""release the wl_fullscreen_shell interface\n\nRelease the binding from the wl_fullscreen_shell interface\n\nThis destroys the server-side object and frees this binding.  If\nthe client binds to wl_fullscreen_shell multiple times, it may wish\nto free some of those bindings.\n\nThis is a destructor, once sent this object cannot be used any longer.""present surface for display\n\nPresent a surface on the given output.\n\nIf the output is null, the compositor will present the surface on\nwhatever display (or displays) it thinks best.  In particular, this\nmay replace any or all surfaces currently presented so it should\nnot be used in combination with placing surfaces on specific\noutputs.\n\nThe method parameter is a hint to the compositor for how the surface\nis to be presented.  In particular, it tells the compostior how to\nhandle a size mismatch between the presented surface and the\noutput.  The compositor is free to ignore this parameter.\n\nThe \"zoom\", \"zoom_crop\", and \"stretch\" methods imply a scaling\noperation on the surface.  This will override any kind of output\nscaling, so the buffer_scale property of the surface is effectively\nignored.""present surface for display at a particular mode\n\nPresents a surface on the given output for a particular mode.\n\nIf the current size of the output differs from that of the surface,\nthe compositor will attempt to change the size of the output to\nmatch the surface.  The result of the mode-switch operation will be\nreturned via the provided wl_fullscreen_shell_mode_feedback object.\n\nIf the current output mode matches the one requested or if the\ncompositor successfully switches the mode to match the surface,\nthen the mode_successful event will be sent and the output will\ncontain the contents of the given surface.  If the compositor\ncannot match the output size to the surface size, the mode_failed\nwill be sent and the output will contain the contents of the\npreviously presented surface (if any).  If another surface is\npresented on the given output before either of these has a chance\nto happen, the present_cancelled event will be sent.\n\nDue to race conditions and other issues unknown to the client, no\nmode-switch operation is guaranteed to succeed.  However, if the\nmode is one advertised by wl_output.mode or if the compositor\nadvertises the ARBITRARY_MODES capability, then the client should\nexpect that the mode-switch operation will usually succeed.\n\nIf the size of the presented surface changes, the resulting output\nis undefined.  The compositor may attempt to change the output mode\nto compensate.  However, there is no guarantee that a suitable mode\nwill be found and the client has no way to be notified of success\nor failure.\n\nThe framerate parameter specifies the desired framerate for the\noutput in mHz.  The compositor is free to ignore this parameter.  A\nvalue of 0 indicates that the client has no preference.\n\nIf the value of wl_output.scale differs from wl_surface.buffer_scale,\nthen the compositor may choose a mode that matches either the buffer\nsize or the surface size.  In either case, the surface will fill the\noutput.""Displays a single surface per output\n\nDisplays a single surface per output.\n\nThis interface provides a mechanism for a single client to display\nsimple full-screen surfaces.  While there technically may be multiple\nclients bound to this interface, only one of those clients should be\nshown at a time.\n\nTo present a surface, the client uses either the present_surface or\npresent_surface_for_mode requests.  Presenting a surface takes effect\non the next wl_surface.commit.  See the individual requests for\ndetails about scaling and mode switches.\n\nThe client can have at most one surface per output at any time.\nRequesting a surface be presented on an output that already has a\nsurface replaces the previously presented surface.  Presenting a null\nsurface removes its content and effectively disables the output.\nExactly what happens when an output is \"disabled\" is\ncompositor-specific.  The same surface may be presented on multiple\noutputs simultaneously.\n\nOnce a surface is presented on an output, it stays on that output\nuntil either the client removes it or the compositor destroys the\noutput.  This way, the client can update the output's contents by\nsimply attaching a new buffer.\n\nSee also the [Event] enum for this interface."WlFullscreenShell"release the wl_fullscreen_shell interface\n\nRelease the binding from the wl_fullscreen_shell interface\n\nThis destroys the server-side object and frees this binding.  If\nthe client binds to wl_fullscreen_shell multiple times, it may wish\nto free some of those bindings."_wl_fullscreen_shell_mode_feedbackWlFullscreenShellModeFeedback_wl_fullscreen_shell"mode switch succeeded\n\nThis event indicates that the attempted mode switch operation was\nsuccessful.  A surface of the size requested in the mode switch\nwill fill the output without scaling.\n\nUpon receiving this event, the client should destroy the\nwl_fullscreen_shell_mode_feedback object.""mode switch failed\n\nThis event indicates that the attempted mode switch operation\nfailed. This may be because the requested output mode is not\npossible or it may mean that the compositor does not want to allow it.\n\nUpon receiving this event, the client should destroy the\nwl_fullscreen_shell_mode_feedback object.""mode switch cancelled\n\nThis event indicates that the attempted mode switch operation was\ncancelled.  Most likely this is because the client requested a\nsecond mode switch before the first one completed.\n\nUpon receiving this event, the client should destroy the\nwl_fullscreen_shell_mode_feedback object.""_wl_fullscreen_shell_mode_feedback\n\nSee also the [Event] enum for this interface."ORG_KDE_KWIN_IDLE_INTERFACEorg_kde_kwin_idle_requests_get_idle_timeout_typesorg_kde_kwin_idle_requestsorg_kde_kwin_idle_interfaceORG_KDE_KWIN_IDLE_TIMEOUT_INTERFACEorg_kde_kwin_idle_timeout_requestsorg_kde_kwin_idle_timeout_eventsorg_kde_kwin_idle_timeout_interface"User idle time manager\n\nThis interface allows to monitor user idle time on a given seat. The interface\nallows to register timers which trigger after no user activity was registered\non the seat for a given interval. It notifies when user activity resumes.\n\nThis is useful for applications wanting to perform actions when the user is not\ninteracting with the system, e.g. chat applications setting the user as away, power\nmanagement features to dim screen, etc.."REQ_GET_IDLE_TIMEOUT_SINCEREQ_GET_IDLE_TIMEOUT_OPCODE"The idle timeout in msec"GetIdleTimeout"User idle time manager\n\nThis interface allows to monitor user idle time on a given seat. The interface\nallows to register timers which trigger after no user activity was registered\non the seat for a given interval. It notifies when user activity resumes.\n\nThis is useful for applications wanting to perform actions when the user is not\ninteracting with the system, e.g. chat applications setting the user as away, power\nmanagement features to dim screen, etc..\n\nThis interface has no events."OrgKdeKwinIdleorg_kde_kwin_idle_timeoutOrgKdeKwinIdleTimeoutget_idle_timeoutorg_kde_kwin_idleREQ_SIMULATE_USER_ACTIVITY_SINCEREQ_SIMULATE_USER_ACTIVITY_OPCODEEVT_IDLE_SINCEEVT_IDLE_OPCODE"release the timeout object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""Simulates user activity for this timeout, behaves just like real user activity on the seat"SimulateUserActivity"Triggered when there has not been any user activity in the requested idle time interval""Triggered on the first user activity after an idle event""org_kde_kwin_idle_timeout\n\nSee also the [Event] enum for this interface.""release the timeout object"simulate_user_activityORG_KDE_KWIN_KEYSTATE_INTERFACEorg_kde_kwin_keystate_requestsorg_kde_kwin_keystate_eventsorg_kde_kwin_keystate_interface"Key States\n\nKeeps track of the states of the different keys that have a state attached to it."CapslockNumlockScrolllockLatchedREQ_FETCHSTATES_SINCEREQ_FETCHSTATES_OPCODEEVT_STATECHANGED_SINCEEVT_STATECHANGED_OPCODEFetchStates"This is a destructor, once sent this object cannot be used any longer.\nOnly available since version 4 of the interface""Updates the state for a said key""Key States\n\nKeeps track of the states of the different keys that have a state attached to it.\n\nSee also the [Event] enum for this interface."OrgKdeKwinKeystatefetchStatesorg_kde_kwin_keystatekeystateORG_KDE_KWIN_OUTPUTDEVICE_INTERFACEorg_kde_kwin_outputdevice_eventsorg_kde_kwin_outputdevice_interface"output configuration representation\n\nAn outputdevice describes a display device available to the compositor.\noutputdevice is similar to wl_output, but focuses on output\nconfiguration management.\n\nA client can query all global outputdevice objects to enlist all\navailable display devices, even those that may currently not be\nrepresented by the compositor as a wl_output.\n\nThe client sends configuration changes to the server through the\noutputconfiguration interface, and the server applies the configuration\nchanges to the hardware and signals changes to the outputdevices\naccordingly.\n\nThis object is published as global during start up for every available\ndisplay devices, or when one later becomes available, for example by\nbeing hotplugged via a physical connector.""subpixel geometry information\n\nThis enumeration describes how the physical pixels on an output are\nlaid out.""transform from framebuffer to output\n\nThis describes the transform, that a compositor will apply to a\nsurface to compensate for the rotation or mirroring of an\noutput device.\n\nThe flipped values correspond to an initial flip around a\nvertical axis followed by rotation.\n\nThe purpose is mainly to allow clients to render accordingly and\ntell the compositor, so that for fullscreen surfaces, the\ncompositor is still able to scan out directly client surfaces.""mode information\n\nThese flags describe properties of an output mode. They are\nused in the flags bitfield of the mode event.""describes enabled state\n\nDescribes whether a device is enabled, i.e. device is used to\ndisplay content by the compositor. This wraps a boolean around\nan int to avoid a boolean trap."Enablement"describes capabilities of the outputdevice\n\nDescribes what capabilities this device has.""if this outputdevice can use overscan"Overscan"if this outputdevice supports variable refresh rate"Vrr"describes vrr policy\n\nDescribes when the compositor may employ variable refresh rate"VrrPolicyEVT_EDID_SINCEEVT_EDID_OPCODEEVT_ENABLED_SINCEEVT_ENABLED_OPCODEEVT_UUID_SINCEEVT_UUID_OPCODEEVT_SCALEF_SINCEEVT_SCALEF_OPCODEEVT_COLORCURVES_SINCEEVT_COLORCURVES_OPCODEEVT_SERIAL_NUMBER_SINCEEVT_SERIAL_NUMBER_OPCODEEVT_EISA_ID_SINCEEVT_EISA_ID_OPCODEEVT_OVERSCAN_SINCEEVT_OVERSCAN_OPCODEEVT_VRR_POLICY_SINCEEVT_VRR_POLICY_OPCODE"geometric properties of the output\n\nThe geometry event describes geometric properties of the output.\nThe event is sent when binding to the output object and whenever\nany of the properties change.""transform that maps framebuffer to output""advertise available output modes and current one\n\nThe mode event describes an available mode for the output.\n\nWhen the client binds to the outputdevice object, the server sends this\nevent once for every available mode the outputdevice can be operated by.\n\nThere will always be at least one event sent out on initial binding,\nwhich represents the current mode.\n\nLater on if an output changes its mode the event is sent again, whereby\nthis event represents the mode that has now become current. In other\nwords, the current mode is always represented by the latest event sent\nwith the current flag set.\n\nThe size of a mode is given in physical hardware units of the output device.\nThis is not necessarily the same as the output size in the global compositor\nspace. For instance, the output may be scaled, as described in\norg_kde_kwin_outputdevice.scale, or transformed, as described in\norg_kde_kwin_outputdevice.transform.\n\nThe id can be used to refer to a mode when calling set_mode on an\norg_kde_kwin_outputconfiguration object.""Per outputdevice unique id to identify a mode"mode_id"sent all information about output\n\nThis event is sent after all other properties have been\nsent on binding to the output object as well as after any\nother output property change have been applied later on.\nThis allows to see changes to the output properties as atomic,\neven if multiple events successively announce them.""output scaling properties\n\nThis event contains scaling geometry information\nthat is not in the geometry event. It may be sent after\nbinding the output object or if the output scale changes\nlater. If it is not sent, the client should assume a\nscale of 1.\n\nA scale larger than 1 means that the compositor will\nautomatically scale surface buffers by this amount\nwhen rendering. This is used for high resolution\ndisplays where applications rendering at the native\nresolution would be too small to be legible.\n\nIt is intended that scaling aware clients track the\ncurrent output of a surface, and if it is on a scaled\noutput it should use wl_surface.set_buffer_scale with\nthe scale of the output. That way the compositor can\navoid scaling the surface, and the client can supply\na higher detail image.""advertise EDID data for the output\n\nThe edid event encapsulates the EDID data for the outputdevice.\n\nThe event is sent when binding to the output object. The EDID\ndata may be empty, in which case this event is sent anyway.\nIf the EDID information is empty, you can fall back to the name\net al. properties of the outputdevice.""base64-encoded EDID string"Edid"output is enabled or disabled\n\nThe enabled event notifies whether this output is currently\nenabled and used for displaying content by the server.\nThe event is sent when binding to the output object and\nwhenever later on an output changes its state by becoming\nenabled or disabled.""output enabled state""A unique id for this outputdevice\n\nThe uuid can be used to identify the output. It's controlled by\nthe server entirely. The server should make sure the uuid is\npersistent across restarts. An empty uuid is considered invalid.""output devices ID""output scaling properties\n\nThis event contains scaling geometry information\nthat is not in the geometry event. It may be sent after\nbinding the output object or if the output scale changes\nlater. If it is not sent, the client should assume a\nscale of 1.\n\nA scale larger than 1 means that the compositor will\nautomatically scale surface buffers by this amount\nwhen rendering. This is used for high resolution\ndisplays where applications rendering at the native\nresolution would be too small to be legible.\n\nIt is intended that scaling aware clients track the\ncurrent output of a surface, and if it is on a scaled\noutput it should use wl_surface.set_buffer_scale with\nthe scale of the output. That way the compositor can\navoid scaling the surface, and the client can supply\na higher detail image.\n\nwl_output will keep the output scale as an integer. In every situation except\nconfiguring the window manager you want to use that.\n\nOnly available since version 2 of the interface"Scalef"output color curves\n\nDescribes the color intensity profile of the output.\nCommonly used for gamma/color correction.\n\nThe array contains all color ramp values of the output.\nFor example on 8bit screens there are 256 of them.\n\nThe array elements are unsigned 16bit integers.\n\nOnly available since version 2 of the interface""red color ramp""green color ramp""blue color ramp"Colorcurves"Serial Number\n\nSerial ID of the monitor, sent on startup before the first done event.\n\nOnly available since version 2 of the interface""textual representation of serial number"serialNumber"EISA ID\n\nEISA ID of the monitor, sent on startup before the first done event.\n\nOnly available since version 2 of the interface""textual representation of EISA identifier"eisaIdEisaId"capability flags\n\nWhat capabilities this device has, sent on startup before the first\ndone event.\n\nOnly available since version 3 of the interface""overscan\n\nOverscan value of the monitor in percent, sent on startup before the\nfirst done event.\n\nOnly available since version 3 of the interface""amount of overscan of the monitor"overscan"Variable Refresh Rate Policy\n\nWhat policy the compositor will employ regarding its use of variable\nrefresh rate.\n\nOnly available since version 4 of the interface"vrr_policy"output configuration representation\n\nAn outputdevice describes a display device available to the compositor.\noutputdevice is similar to wl_output, but focuses on output\nconfiguration management.\n\nA client can query all global outputdevice objects to enlist all\navailable display devices, even those that may currently not be\nrepresented by the compositor as a wl_output.\n\nThe client sends configuration changes to the server through the\noutputconfiguration interface, and the server applies the configuration\nchanges to the hardware and signals changes to the outputdevices\naccordingly.\n\nThis object is published as global during start up for every available\ndisplay devices, or when one later becomes available, for example by\nbeing hotplugged via a physical connector.\n\nSee also the [Event] enum for this interface."OrgKdeKwinOutputdeviceorg_kde_kwin_outputdeviceKDE_OUTPUT_DEVICE_V2_INTERFACEkde_output_device_v2_events_current_mode_typeskde_output_device_v2_events_mode_typeskde_output_device_v2_eventskde_output_device_v2_interfaceKDE_OUTPUT_DEVICE_MODE_V2_INTERFACEkde_output_device_mode_v2_eventskde_output_device_mode_v2_interface"output configuration representation\n\nAn output device describes a display device available to the compositor.\noutput_device is similar to wl_output, but focuses on output\nconfiguration management.\n\nA client can query all global output_device objects to enlist all\navailable display devices, even those that may currently not be\nrepresented by the compositor as a wl_output.\n\nThe client sends configuration changes to the server through the\noutputconfiguration interface, and the server applies the configuration\nchanges to the hardware and signals changes to the output devices\naccordingly.\n\nThis object is published as global during start up for every available\ndisplay devices, or when one later becomes available, for example by\nbeing hotplugged via a physical connector.""if this output_device can use overscan""if setting the rgb range is possible"RgbRange"describes RGB range policy\n\nWhether full or limited color range should be used"EVT_CURRENT_MODE_SINCEEVT_CURRENT_MODE_OPCODEEVT_RGB_RANGE_SINCEEVT_RGB_RANGE_OPCODE"current mode\n\nThis event describes the mode currently in use for this head. It is only\nsent if the output is enabled."kde_output_device_mode_v2KdeOutputDeviceModeV2CurrentMode"advertise available output modes and current one\n\nThe mode event describes an available mode for the output.\n\nWhen the client binds to the output_device object, the server sends this\nevent once for every available mode the output_device can be operated by.\n\nThere will always be at least one event sent out on initial binding,\nwhich represents the current mode.\n\nLater if an output changes, its mode event is sent again for the\neventual added modes and lastly the current mode. In other words, the\ncurrent mode is always represented by the latest event sent with the current\nflag set.\n\nThe size of a mode is given in physical hardware units of the output device.\nThis is not necessarily the same as the output size in the global compositor\nspace. For instance, the output may be scaled, as described in\nkde_output_device_v2.scale, or transformed, as described in\nkde_output_device_v2.transform.""Serial Number\n\nSerial ID of the monitor, sent on startup before the first done event.""EISA ID\n\nEISA ID of the monitor, sent on startup before the first done event.""capability flags\n\nWhat capabilities this device has, sent on startup before the first\ndone event.""overscan\n\nOverscan value of the monitor in percent, sent on startup before the\nfirst done event.""Variable Refresh Rate Policy\n\nWhat policy the compositor will employ regarding its use of variable\nrefresh rate.""RGB range\n\nWhat rgb range the compositor is using for this output"rgb_range"Output's name\n\nName of the output, it's useful to cross-reference to an zxdg_output_v1 and ultimately QScreen\n\nOnly available since version 2 of the interface""output configuration representation\n\nAn output device describes a display device available to the compositor.\noutput_device is similar to wl_output, but focuses on output\nconfiguration management.\n\nA client can query all global output_device objects to enlist all\navailable display devices, even those that may currently not be\nrepresented by the compositor as a wl_output.\n\nThe client sends configuration changes to the server through the\noutputconfiguration interface, and the server applies the configuration\nchanges to the hardware and signals changes to the output devices\naccordingly.\n\nThis object is published as global during start up for every available\ndisplay devices, or when one later becomes available, for example by\nbeing hotplugged via a physical connector.\n\nSee also the [Event] enum for this interface."KdeOutputDeviceV2kde_output_device_v2"output mode\n\nThis object describes an output mode.\n\nSome heads don't support output modes, in which case modes won't be\nadvertised.\n\nProperties sent via this interface are applied atomically via the\nkde_output_device.done event. No guarantees are made regarding the order\nin which properties are sent."EVT_SIZE_SINCEEVT_SIZE_OPCODEEVT_REFRESH_SINCEEVT_REFRESH_OPCODEEVT_PREFERRED_SINCEEVT_PREFERRED_OPCODE"mode size\n\nThis event describes the mode size. The size is given in physical\nhardware units of the output device. This is not necessarily the same as\nthe output size in the global compositor space. For instance, the output\nmay be scaled or transformed.""mode refresh rate\n\nThis event describes the mode's fixed vertical refresh rate. It is only\nsent if the mode has a fixed refresh rate.""mode is preferred\n\nThis event advertises this mode as preferred.""the mode has been destroyed\n\nThe compositor will destroy the object immediately after sending this\nevent, so it will become invalid and the client should release any\nresources associated with it.""output mode\n\nThis object describes an output mode.\n\nSome heads don't support output modes, in which case modes won't be\nadvertised.\n\nProperties sent via this interface are applied atomically via the\nkde_output_device.done event. No guarantees are made regarding the order\nin which properties are sent.\n\nSee also the [Event] enum for this interface."output_deviceORG_KDE_KWIN_OUTPUTMANAGEMENT_INTERFACEorg_kde_kwin_outputmanagement_requests_create_configuration_typesorg_kde_kwin_outputmanagement_requestsorg_kde_kwin_outputmanagement_interfaceORG_KDE_KWIN_OUTPUTCONFIGURATION_INTERFACEorg_kde_kwin_outputconfiguration_requests_enable_typesorg_kde_kwin_outputconfiguration_requests_mode_typesorg_kde_kwin_outputconfiguration_requests_transform_typesorg_kde_kwin_outputconfiguration_requests_position_typesorg_kde_kwin_outputconfiguration_requests_scale_typesorg_kde_kwin_outputconfiguration_requests_scalef_typesorg_kde_kwin_outputconfiguration_requests_colorcurves_typesorg_kde_kwin_outputconfiguration_requests_overscan_typesorg_kde_kwin_outputconfiguration_requests_set_vrr_policy_typesorg_kde_kwin_outputconfiguration_requestsorg_kde_kwin_outputconfiguration_eventsorg_kde_kwin_outputconfiguration_interface"configuration of server outputs through clients\n\nThis interface enables clients to set properties of output devices for screen\nconfiguration purposes via the server. To this end output devices are referenced\nby global org_kde_kwin_outputdevice objects.\n\noutputmanagement (wl_global)\n--------------------------\nrequest:\n* create_configuration -> outputconfiguration (wl_resource)\n\noutputconfiguration (wl_resource)\n--------------------------\nrequests:\n* enable(outputdevice, bool)\n* mode(outputdevice, mode_id)\n* transformation(outputdevice, flag)\n* position(outputdevice, x, y)\n* apply\n\nevents:\n* applied\n* failed\n\nThe server registers one outputmanagement object as a global object. In order\nto configure outputs a client requests create_configuration, which provides a\nresource referencing an outputconfiguration for one-time configuration. That\nway the server knows which requests belong together and can group them by that.\n\nOn the outputconfiguration object the client calls for each output whether the\noutput should be enabled, which mode should be set (by referencing the mode from\nthe list of announced modes) and the output's global position. Once all outputs\nare configured that way, the client calls apply.\nAt that point and not earlier the server should try to apply the configuration.\nIf this succeeds the server emits the applied signal, otherwise the failed\nsignal, such that the configuring client is noticed about the success of its\nconfiguration request.\n\nThrough this design the interface enables atomic output configuration changes if\ninternally supported by the server."REQ_CREATE_CONFIGURATION_SINCEREQ_CREATE_CONFIGURATION_OPCODE"provide outputconfiguration object for configuring outputs\n\nRequest an outputconfiguration object through which the client can configure\noutput devices."CreateConfiguration"configuration of server outputs through clients\n\nThis interface enables clients to set properties of output devices for screen\nconfiguration purposes via the server. To this end output devices are referenced\nby global org_kde_kwin_outputdevice objects.\n\noutputmanagement (wl_global)\n--------------------------\nrequest:\n* create_configuration -> outputconfiguration (wl_resource)\n\noutputconfiguration (wl_resource)\n--------------------------\nrequests:\n* enable(outputdevice, bool)\n* mode(outputdevice, mode_id)\n* transformation(outputdevice, flag)\n* position(outputdevice, x, y)\n* apply\n\nevents:\n* applied\n* failed\n\nThe server registers one outputmanagement object as a global object. In order\nto configure outputs a client requests create_configuration, which provides a\nresource referencing an outputconfiguration for one-time configuration. That\nway the server knows which requests belong together and can group them by that.\n\nOn the outputconfiguration object the client calls for each output whether the\noutput should be enabled, which mode should be set (by referencing the mode from\nthe list of announced modes) and the output's global position. Once all outputs\nare configured that way, the client calls apply.\nAt that point and not earlier the server should try to apply the configuration.\nIf this succeeds the server emits the applied signal, otherwise the failed\nsignal, such that the configuring client is noticed about the success of its\nconfiguration request.\n\nThrough this design the interface enables atomic output configuration changes if\ninternally supported by the server.\n\nThis interface has no events."OrgKdeKwinOutputmanagementorg_kde_kwin_outputconfigurationOrgKdeKwinOutputconfigurationcreate_configurationorg_kde_kwin_outputmanagement"configure single output devices\n\noutputconfiguration is a client-specific resource that can be used to ask\nthe server to apply changes to available output devices.\n\nThe client receives a list of output devices from the registry. When it wants\nto apply new settings, it creates a configuration object from the\noutputmanagement global, writes changes through this object's enable, scale,\ntransform and mode calls. It then asks the server to apply these settings in\nan atomic fashion, for example through Linux' DRM interface.\n\nThe server signals back whether the new settings have applied successfully\nor failed to apply. outputdevice objects are updated after the changes have been\napplied to the hardware and before the server side sends the applied event."REQ_MODE_SINCEREQ_MODE_OPCODEREQ_TRANSFORM_SINCEREQ_TRANSFORM_OPCODEREQ_POSITION_SINCEREQ_POSITION_OPCODEREQ_SCALE_SINCEREQ_SCALE_OPCODEREQ_APPLY_SINCEREQ_APPLY_OPCODEREQ_SCALEF_SINCEREQ_SCALEF_OPCODEREQ_COLORCURVES_SINCEREQ_COLORCURVES_OPCODEREQ_OVERSCAN_SINCEREQ_OVERSCAN_OPCODEREQ_SET_VRR_POLICY_SINCEREQ_SET_VRR_POLICY_OPCODEEVT_APPLIED_SINCEEVT_APPLIED_OPCODE"enable or disable an output\n\nMark the output as enabled or disabled.""outputdevice to be en- or disabled"outputdevice"1 to enable or 0 to disable this output""switch outputdevice to mode\n\nSets the mode for a given output by its mode size (width and height) and refresh rate.""outputdevice this mode change applies to""aspired mode's id""transform outputdevice\n\nSets the transformation for a given output.""outputdevice this transformation change applies to""transform enum""position output in global space\n\nSets the position for this output device. (x,y) describe the top-left corner\nof the output in global space, whereby the origin (0,0) of the global space\nhas to be aligned with the top-left corner of the most left and in case this\ndoes not define a single one the top output.\n\nThere may be no gaps or overlaps between outputs, i.e. the outputs are\nstacked horizontally, vertically, or both on each other.""outputdevice this position applies to""position on the x-axis""position on the y-axis""set scaling factor of this output\n\nSets the scaling factor for this output device.""scaling factor""apply configuration changes to all output devices\n\nAsks the server to apply property changes requested through this outputconfiguration\nobject to all outputs on the server side.""set scaling factor of this output\n\nSets the scaling factor for this output device.\nSending both scale and scalef is undefined.\n\nOnly available since version 2 of the interface""set output color curves\n\nSet color curves of output devices through RGB color ramps. Allows color\ncorrection of output device from user space.\n\nThese are the raw values. A compositor might opt to adjust these values\ninternally, for example to shift color temperature at night.\n\nOnly available since version 2 of the interface""outputdevice curves apply to""release the outputconfiguration object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""set overscan value\n\nSet the overscan value of this output device with a value in percent.\n\nOnly available since version 3 of the interface""outputdevice overscan applies to""overscan value""set the VRR policy\n\nSet what policy the compositor should employ regarding its use of\nvariable refresh rate.\n\nOnly available since version 4 of the interface""outputdevice this VRR policy applies to""the vrr policy to apply"SetVrrPolicy"configuration changes have been applied\n\nSent after the server has successfully applied the changes.\n.""configuration changes failed to apply\n\nSent if the server rejects the changes or failed to apply them.""configure single output devices\n\noutputconfiguration is a client-specific resource that can be used to ask\nthe server to apply changes to available output devices.\n\nThe client receives a list of output devices from the registry. When it wants\nto apply new settings, it creates a configuration object from the\noutputmanagement global, writes changes through this object's enable, scale,\ntransform and mode calls. It then asks the server to apply these settings in\nan atomic fashion, for example through Linux' DRM interface.\n\nThe server signals back whether the new settings have applied successfully\nor failed to apply. outputdevice objects are updated after the changes have been\napplied to the hardware and before the server side sends the applied event.\n\nSee also the [Event] enum for this interface.""set scaling factor of this output\n\nSets the scaling factor for this output device.\nSending both scale and scalef is undefined."scalef"set output color curves\n\nSet color curves of output devices through RGB color ramps. Allows color\ncorrection of output device from user space.\n\nThese are the raw values. A compositor might opt to adjust these values\ninternally, for example to shift color temperature at night."colorcurves"release the outputconfiguration object""set overscan value\n\nSet the overscan value of this output device with a value in percent.""set the VRR policy\n\nSet what policy the compositor should employ regarding its use of\nvariable refresh rate."set_vrr_policyKDE_OUTPUT_MANAGEMENT_V2_INTERFACEkde_output_management_v2_requests_create_configuration_typeskde_output_management_v2_requestskde_output_management_v2_interfaceKDE_OUTPUT_CONFIGURATION_V2_INTERFACEkde_output_configuration_v2_requests_enable_typeskde_output_configuration_v2_requests_mode_typeskde_output_configuration_v2_requests_transform_typeskde_output_configuration_v2_requests_position_typeskde_output_configuration_v2_requests_scale_typeskde_output_configuration_v2_requests_overscan_typeskde_output_configuration_v2_requests_set_vrr_policy_typeskde_output_configuration_v2_requests_set_rgb_range_typeskde_output_configuration_v2_requests_set_primary_output_typeskde_output_configuration_v2_requests_set_priority_typeskde_output_configuration_v2_requestskde_output_configuration_v2_eventskde_output_configuration_v2_interface"configuration of server outputs through clients\n\nThis interface enables clients to set properties of output devices for screen\nconfiguration purposes via the server. To this end output devices are referenced\nby global kde_output_device_v2 objects.\n\noutputmanagement (wl_global)\n--------------------------\nrequest:\n* create_configuration -> outputconfiguration (wl_resource)\n\noutputconfiguration (wl_resource)\n--------------------------\nrequests:\n* enable(outputdevice, bool)\n* mode(outputdevice, mode)\n* transformation(outputdevice, flag)\n* position(outputdevice, x, y)\n* apply\n\nevents:\n* applied\n* failed\n\nThe server registers one outputmanagement object as a global object. In order\nto configure outputs a client requests create_configuration, which provides a\nresource referencing an outputconfiguration for one-time configuration. That\nway the server knows which requests belong together and can group them by that.\n\nOn the outputconfiguration object the client calls for each output whether the\noutput should be enabled, which mode should be set (by referencing the mode from\nthe list of announced modes) and the output's global position. Once all outputs\nare configured that way, the client calls apply.\nAt that point and not earlier the server should try to apply the configuration.\nIf this succeeds the server emits the applied signal, otherwise the failed\nsignal, such that the configuring client is noticed about the success of its\nconfiguration request.\n\nThrough this design the interface enables atomic output configuration changes if\ninternally supported by the server.""configuration of server outputs through clients\n\nThis interface enables clients to set properties of output devices for screen\nconfiguration purposes via the server. To this end output devices are referenced\nby global kde_output_device_v2 objects.\n\noutputmanagement (wl_global)\n--------------------------\nrequest:\n* create_configuration -> outputconfiguration (wl_resource)\n\noutputconfiguration (wl_resource)\n--------------------------\nrequests:\n* enable(outputdevice, bool)\n* mode(outputdevice, mode)\n* transformation(outputdevice, flag)\n* position(outputdevice, x, y)\n* apply\n\nevents:\n* applied\n* failed\n\nThe server registers one outputmanagement object as a global object. In order\nto configure outputs a client requests create_configuration, which provides a\nresource referencing an outputconfiguration for one-time configuration. That\nway the server knows which requests belong together and can group them by that.\n\nOn the outputconfiguration object the client calls for each output whether the\noutput should be enabled, which mode should be set (by referencing the mode from\nthe list of announced modes) and the output's global position. Once all outputs\nare configured that way, the client calls apply.\nAt that point and not earlier the server should try to apply the configuration.\nIf this succeeds the server emits the applied signal, otherwise the failed\nsignal, such that the configuring client is noticed about the success of its\nconfiguration request.\n\nThrough this design the interface enables atomic output configuration changes if\ninternally supported by the server.\n\nThis interface has no events."KdeOutputManagementV2kde_output_configuration_v2KdeOutputConfigurationV2kde_output_management_v2"kde_output_configuration_v2 error values\n\nThese error can be emitted in response to kde_output_configuration_v2 requests.""the config is already applied"AlreadyApplied"describes RGB range policy\n\nWhether this output should use full or limited rgb."REQ_SET_RGB_RANGE_SINCEREQ_SET_RGB_RANGE_OPCODEREQ_SET_PRIMARY_OUTPUT_SINCEREQ_SET_PRIMARY_OUTPUT_OPCODEREQ_SET_PRIORITY_SINCEREQ_SET_PRIORITY_OPCODE"switch output-device to mode\n\nSets the mode for a given output.""the mode to apply""transform output-device\n\nSets the transformation for a given output.""outputdevice this scale change applies to""apply configuration changes to all output devices\n\nAsks the server to apply property changes requested through this outputconfiguration\nobject to all outputs on the server side.\n\nThe output configuration can be applied only once. The already_applied protocol error\nwill be posted if the apply request is called the second time.""release the outputconfiguration object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""RGB range\n\nWhether full or limited color range should be used""outputdevice the rgb range applies to"SetRgbRange"Select which primary output to use\n\n\n\nOnly available since version 2 of the interface"SetPrimaryOutput"Set the order of outputs\n\nThe order of outputs can be used to assign desktop environment components to a specific screen,\nsee kde_output_order_v1 for details. The priority is 1-based for outputs that will be enabled after\nthis changeset is applied, all outputs that are disabled need to have the index set to zero.\n\nOnly available since version 3 of the interface""outputdevice the index applies to""the priority of the output"SetPriorityset_rgb_range"Select which primary output to use"set_primary_output"Set the order of outputs\n\nThe order of outputs can be used to assign desktop environment components to a specific screen,\nsee kde_output_order_v1 for details. The priority is 1-based for outputs that will be enabled after\nthis changeset is applied, all outputs that are disabled need to have the index set to zero."output_managementKDE_PRIMARY_OUTPUT_V1_INTERFACEkde_primary_output_v1_requestskde_primary_output_v1_eventskde_primary_output_v1_interface"expose which is the primary display\n\nProtocol for telling which is the primary display among the selection of enabled outputs."EVT_PRIMARY_OUTPUT_SINCEEVT_PRIMARY_OUTPUT_OPCODE"Destroy the primary output notifier.\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""Provide the current primary output's name\n\nSpecifies which output is the primary one identified by their uuid. See kde_output_device_v2 uuid event for more information about it.""the name of the output"output_namePrimaryOutput"expose which is the primary display\n\nProtocol for telling which is the primary display among the selection of enabled outputs.\n\nSee also the [Event] enum for this interface."KdePrimaryOutputV1"Destroy the primary output notifier."kde_primary_output_v1primary_outputORG_KDE_PLASMA_SHELL_INTERFACEorg_kde_plasma_shell_requests_get_surface_typesorg_kde_plasma_shell_requestsorg_kde_plasma_shell_interfaceORG_KDE_PLASMA_SURFACE_INTERFACEorg_kde_plasma_surface_requests_set_output_typesorg_kde_plasma_surface_requestsorg_kde_plasma_surface_eventsorg_kde_plasma_surface_interface"create shell windows and helpers\n\nThis interface is used by KF5 powered Wayland shells to communicate with\nthe compositor and can only be bound one time.""create a shell surface from a surface\n\nCreate a shell surface for an existing surface.\n\nOnly one shell surface can be associated with a given\nsurface.""create shell windows and helpers\n\nThis interface is used by KF5 powered Wayland shells to communicate with\nthe compositor and can only be bound one time.\n\nThis interface has no events."OrgKdePlasmaShellorg_kde_plasma_surfaceOrgKdePlasmaSurfaceorg_kde_plasma_shell"metadata interface\n\nAn interface that may be implemented by a wl_surface, for\nimplementations that provide the shell user interface.\n\nIt provides requests to set surface roles, assign an output\nor set the position in output coordinates.\n\nOn the server side the object is automatically destroyed when\nthe related wl_surface is destroyed.  On client side,\norg_kde_plasma_surface.destroy() must be called before\ndestroying the wl_surface object."OnscreendisplayCriticalnotificationAppletpopup"Behavior for panel surface"PanelBehavior"normal panel visibility\n\nThe panel is on top of other surfaces, windows cannot cover (full screen\nwindows excluded)."AlwaysVisible"hide automatically\n\nThe panel is hidden automatically and restored when the mouse is over."AutoHide"windows can cover\n\nWindows can cover the panel."WindowsCanCover"windows go below\n\nMaximized windows take the whole screen space but the panel is above\nthe windows."WindowsGoBelow"Request panel_auto_hide performed on a surface which does not correspond to an auto-hide panel."PanelNotAutoHideREQ_SET_OUTPUT_SINCEREQ_SET_OUTPUT_OPCODEREQ_SET_ROLE_SINCEREQ_SET_ROLE_OPCODEREQ_SET_PANEL_BEHAVIOR_SINCEREQ_SET_PANEL_BEHAVIOR_OPCODEREQ_SET_SKIP_TASKBAR_SINCEREQ_SET_SKIP_TASKBAR_OPCODEREQ_PANEL_AUTO_HIDE_HIDE_SINCEREQ_PANEL_AUTO_HIDE_HIDE_OPCODEREQ_PANEL_AUTO_HIDE_SHOW_SINCEREQ_PANEL_AUTO_HIDE_SHOW_OPCODEREQ_SET_PANEL_TAKES_FOCUS_SINCEREQ_SET_PANEL_TAKES_FOCUS_OPCODEREQ_SET_SKIP_SWITCHER_SINCEREQ_SET_SKIP_SWITCHER_OPCODEREQ_OPEN_UNDER_CURSOR_SINCEREQ_OPEN_UNDER_CURSOR_OPCODEEVT_AUTO_HIDDEN_PANEL_HIDDEN_SINCEEVT_AUTO_HIDDEN_PANEL_HIDDEN_OPCODEEVT_AUTO_HIDDEN_PANEL_SHOWN_SINCEEVT_AUTO_HIDDEN_PANEL_SHOWN_OPCODE"remove org_kde_plasma_surface interface\n\nThe org_kde_plasma_surface interface is removed from the\nwl_surface object that was turned into a shell surface with the\norg_kde_plasma_shell.get_surface request.\nThe shell surface role is lost and wl_surface is unmapped.\n\nThis is a destructor, once sent this object cannot be used any longer.""assign an output to this shell surface\n\nAssign an output to this shell surface.\nThe compositor will use this information to set the position\nwhen org_kde_plasma_surface.set_position request is\ncalled."SetOutput"change the shell surface position\n\nMove the surface to new coordinates.\n\nCoordinates are global, for example 50,50 for a 1920,0+1920x1080 output\nis 1970,50 in global coordinates space.\n\nUse org_kde_plasma_surface.set_output to assign an output\nto this surface.""x coordinate in global space""y coordinate in global space""assign a role to this surface\n\nAssign a role to a shell surface.\n\nThe compositor handles surfaces depending on their role.\nSee the explanation below.\n\nThis request fails if the surface already has a role, this means\nthe surface role may be assigned only once.\n\n== Surfaces with splash role ==\n\nSplash surfaces are placed above every other surface during the\nshell startup phase.\n\nThe surfaces are placed according to the output coordinates.\nNo size is imposed to those surfaces, the shell has to resize\nthem according to output size.\n\nThese surfaces are meant to hide the desktop during the startup\nphase so that the user will always see a ready to work desktop.\n\nA shell might not create splash surfaces if the compositor reveals\nthe desktop in an alternative fashion, for example with a fade\nin effect.\n\nThat depends on how much time the desktop usually need to prepare\nthe workspace or specific design decisions.\nThis specification doesn't impose any particular design.\n\nWhen the startup phase is finished, the shell will send the\norg_kde_plasma.desktop_ready request to the compositor.\n\n== Surfaces with desktop role ==\n\nDesktop surfaces are placed below all other surfaces and are used\nto show the actual desktop view with icons, search results or\ncontrols the user will interact with. What to show depends on the\nshell implementation.\n\nThe surfaces are placed according to the output coordinates.\nNo size is imposed to those surfaces, the shell has to resize\nthem according to output size.\n\nOnly one surface per output can have the desktop role.\n\n== Surfaces with dashboard role ==\n\nDashboard surfaces are placed above desktop surfaces and are used to\nshow additional widgets and controls.\n\nThe surfaces are placed according to the output coordinates.\nNo size is imposed to those surfaces, the shell has to resize\nthem according to output size.\n\nOnly one surface per output can have the dashboard role.\n\n== Surfaces with config role ==\n\nA configuration surface is shown when the user wants to configure\npanel or desktop views.\n\nOnly one surface per output can have the config role.\n\nTODO: This should grab the input like popup menus, right?\n\n== Surfaces with overlay role ==\n\nOverlays are special surfaces that shows for a limited amount\nof time.  Such surfaces are useful to display things like volume,\nbrightness and status changes.\n\nCompositors may decide to show those surfaces in a layer above\nall surfaces, even full screen ones if so is desired.\n\n== Surfaces with notification role ==\n\nNotification surfaces display informative content for a limited\namount of time.  The compositor may decide to show them in a corner\ndepending on the configuration.\n\nThese surfaces are shown in a layer above all other surfaces except\nfor full screen ones.\n\n== Surfaces with lock role ==\n\nThe lock surface is shown by the compositor when the session is\nlocked, users interact with it to unlock the session.\n\nCompositors should move lock surfaces to 0,0 in output\ncoordinates space and hide all other surfaces for security sake.\nFor the same reason it is recommended that clients make the\nlock surface as big as the screen.\n\nOnly one surface per output can have the lock role."SetRole"set or unset the panel\n\nSet flags bitmask as described by the flag enum.\nPass 0 to unset any flag, the surface will adjust its behavior to\nthe default.""panel_behavior enum value"SetPanelBehavior"make the window skip the taskbar\n\nSetting this bit to the window, will make it say it prefers to not be listed in the taskbar. Taskbar implementations may or may not follow this hint.\n\nOnly available since version 2 of the interface""Boolean value that sets whether to skip the taskbar""Hide the auto-hiding panel\n\nA panel surface with panel_behavior auto_hide can perform this request to hide the panel\non a screen edge without unmapping it. The compositor informs the client about the panel\nbeing hidden with the event auto_hidden_panel_hidden.\n\nThe compositor will restore the visibility state of the\nsurface when the pointer touches the screen edge the panel borders. Once the compositor restores\nthe visibility the event auto_hidden_panel_shown will be sent. This event will also be sent\nif the compositor is unable to hide the panel.\n\nThe client can also request to show the panel again with the request panel_auto_hide_show.\n\nOnly available since version 4 of the interface"PanelAutoHideHide"Show the auto-hiding panel\n\nA panel surface with panel_behavior auto_hide can perform this request to show the panel\nagain which got hidden with panel_auto_hide_hide.\n\nOnly available since version 4 of the interface"PanelAutoHideShow"Whether a panel takes focus\n\nBy default various org_kde_plasma_surface roles do not take focus and cannot be\nactivated. With this request the compositor can be instructed to pass focus also to this\norg_kde_plasma_surface.\n\nOnly available since version 4 of the interface""Boolean value that sets whether the panel takes focus"SetPanelTakesFocus"make the window not appear in a switcher\n\nSetting this bit will indicate that the window prefers not to be listed in a switcher.\n\nOnly available since version 5 of the interface""Boolean value that sets whether to skip the window switcher."SetSkipSwitcher"open under cursor\n\nRequest the initial position of this surface to be under the current\ncursor position. Has to be called before attaching any buffer to this surface.\n\nOnly available since version 7 of the interface"OpenUnderCursor"Auto-hiding panel is hidden\n\nAn auto-hiding panel got hidden by the compositor.\n\nOnly available since version 4 of the interface"AutoHiddenPanelHidden"Auto-hiding panel is shown\n\nAn auto-hiding panel got shown by the compositor.\n\nOnly available since version 4 of the interface"AutoHiddenPanelShown"metadata interface\n\nAn interface that may be implemented by a wl_surface, for\nimplementations that provide the shell user interface.\n\nIt provides requests to set surface roles, assign an output\nor set the position in output coordinates.\n\nOn the server side the object is automatically destroyed when\nthe related wl_surface is destroyed.  On client side,\norg_kde_plasma_surface.destroy() must be called before\ndestroying the wl_surface object.\n\nSee also the [Event] enum for this interface.""remove org_kde_plasma_surface interface\n\nThe org_kde_plasma_surface interface is removed from the\nwl_surface object that was turned into a shell surface with the\norg_kde_plasma_shell.get_surface request.\nThe shell surface role is lost and wl_surface is unmapped."set_outputset_panel_behavior"make the window skip the taskbar\n\nSetting this bit to the window, will make it say it prefers to not be listed in the taskbar. Taskbar implementations may or may not follow this hint.""Hide the auto-hiding panel\n\nA panel surface with panel_behavior auto_hide can perform this request to hide the panel\non a screen edge without unmapping it. The compositor informs the client about the panel\nbeing hidden with the event auto_hidden_panel_hidden.\n\nThe compositor will restore the visibility state of the\nsurface when the pointer touches the screen edge the panel borders. Once the compositor restores\nthe visibility the event auto_hidden_panel_shown will be sent. This event will also be sent\nif the compositor is unable to hide the panel.\n\nThe client can also request to show the panel again with the request panel_auto_hide_show."panel_auto_hide_hide"Show the auto-hiding panel\n\nA panel surface with panel_behavior auto_hide can perform this request to show the panel\nagain which got hidden with panel_auto_hide_hide."panel_auto_hide_show"Whether a panel takes focus\n\nBy default various org_kde_plasma_surface roles do not take focus and cannot be\nactivated. With this request the compositor can be instructed to pass focus also to this\norg_kde_plasma_surface."set_panel_takes_focus"make the window not appear in a switcher\n\nSetting this bit will indicate that the window prefers not to be listed in a switcher."set_skip_switcher"open under cursor\n\nRequest the initial position of this surface to be under the current\ncursor position. Has to be called before attaching any buffer to this surface."open_under_cursorplasma_shellORG_KDE_PLASMA_VIRTUAL_DESKTOP_MANAGEMENT_INTERFACEorg_kde_plasma_virtual_desktop_management_requests_get_virtual_desktop_typesorg_kde_plasma_virtual_desktop_management_requestsorg_kde_plasma_virtual_desktop_management_eventsorg_kde_plasma_virtual_desktop_management_interfaceORG_KDE_PLASMA_VIRTUAL_DESKTOP_INTERFACEorg_kde_plasma_virtual_desktop_requestsorg_kde_plasma_virtual_desktop_eventsorg_kde_plasma_virtual_desktop_interfaceREQ_GET_VIRTUAL_DESKTOP_SINCEREQ_GET_VIRTUAL_DESKTOP_OPCODEREQ_REQUEST_CREATE_VIRTUAL_DESKTOP_SINCEREQ_REQUEST_CREATE_VIRTUAL_DESKTOP_OPCODEREQ_REQUEST_REMOVE_VIRTUAL_DESKTOP_SINCEREQ_REQUEST_REMOVE_VIRTUAL_DESKTOP_OPCODEEVT_DESKTOP_CREATED_SINCEEVT_DESKTOP_CREATED_OPCODEEVT_DESKTOP_REMOVED_SINCEEVT_DESKTOP_REMOVED_OPCODEEVT_ROWS_SINCEEVT_ROWS_OPCODE"get the org_kde_plasma_virtual_desktop interface for a desktop\n\nGiven the id of a particular virtual desktop, get the corresponding org_kde_plasma_virtual_desktop which represents only the desktop with that id.""Unique id of the desktop"desktop_idGetVirtualDesktop"ask for the creation of a new desktop at a specified position\n\nAsk the server to create a new virtual desktop, and position it at a specified position. If the position is zero or less, it will be positioned at the beginning, if the position is the count or more, it will be positioned at the end.""The user readable name we want for the desktop""The position we want for the desktop"RequestCreateVirtualDesktop"ask for a desktop removal identified by id\n\nAsk the server to get rid of a virtual desktop, the server may or may not acconsent to the request."RequestRemoveVirtualDesktop"Emitted when a new desktop has been created""Position of this desktop, to ensure the client and the server will see desktops in the same order"DesktopCreated"Emitted when a desktop has been removed"DesktopRemoved"sent all information about desktops\n\nThis event is sent after all other properties has been\nsent after binding to the desktop manager object and after any\nother property changes done after that. This allows\nchanges to the org_kde_plasma_virtual_desktop_management properties to be seen as\natomic, even if they happen via multiple events.""Only available since version 2 of the interface""Number of rows the virtual desktops are laid out into.""org_kde_plasma_virtual_desktop_management\n\nSee also the [Event] enum for this interface."OrgKdePlasmaVirtualDesktopManagementorg_kde_plasma_virtual_desktopOrgKdePlasmaVirtualDesktopget_virtual_desktoprequest_create_virtual_desktoprequest_remove_virtual_desktoporg_kde_plasma_virtual_desktop_managementREQ_REQUEST_ACTIVATE_SINCEREQ_REQUEST_ACTIVATE_OPCODEEVT_DESKTOP_ID_SINCEEVT_DESKTOP_ID_OPCODEEVT_ACTIVATED_SINCEEVT_ACTIVATED_OPCODEEVT_DEACTIVATED_SINCEEVT_DEACTIVATED_OPCODE"Requests this desktop to be activated\n\nRequest the server to set the status of this desktop to active: The server is free to consent or deny the request. This will be the new \"current\" virtual desktop of the system."RequestActivate"The desktop got an id\n\nThe format of the id is decided by the compositor implementation. A desktop id univocally identifies a virtual desktop and must be guaranteed to never exist two desktops with the same id. The format of the string id is up to the server implementation."DesktopId"User readable descriptive name for the desktop""The desktop has been activated\n\nThe desktop will be the new \"current\" desktop of the system. The server may support either one virtual desktop active at a time, or other combinations such as one virtual desktop active per screen.\nWindows associated to this virtual desktop will be shown.""This desktop is no longer active\n\nWindows that were associated only to this desktop will be hidden."Deactivated"sent all information about desktops\n\nThis event is sent after all other properties has been\nsent after binding to the desktop object and after any\nother property changes done after that. This allows\nchanges to the org_kde_plasma_virtual_desktop properties to be seen as\natomic, even if they happen via multiple events.""This desktop has been removed\n\nThis virtual desktop has just been removed by the server:\nAll windows will lose the association to this desktop.""org_kde_plasma_virtual_desktop\n\nSee also the [Event] enum for this interface."request_activateplasma_virtual_desktopORG_KDE_PLASMA_WINDOW_MANAGEMENT_INTERFACEorg_kde_plasma_window_management_requests_get_window_typesorg_kde_plasma_window_management_requests_get_window_by_uuid_typesorg_kde_plasma_window_management_requestsorg_kde_plasma_window_management_eventsorg_kde_plasma_window_management_interfaceORG_KDE_PLASMA_WINDOW_INTERFACEorg_kde_plasma_window_requests_set_minimized_geometry_typesorg_kde_plasma_window_requests_unset_minimized_geometry_typesorg_kde_plasma_window_requests_send_to_output_typesorg_kde_plasma_window_requestsorg_kde_plasma_window_events_parent_window_typesorg_kde_plasma_window_eventsorg_kde_plasma_window_interfaceORG_KDE_PLASMA_ACTIVATION_FEEDBACK_INTERFACEorg_kde_plasma_activation_feedback_requestsorg_kde_plasma_activation_feedback_events_activation_typesorg_kde_plasma_activation_feedback_eventsorg_kde_plasma_activation_feedback_interfaceORG_KDE_PLASMA_ACTIVATION_INTERFACEorg_kde_plasma_activation_requestsorg_kde_plasma_activation_eventsorg_kde_plasma_activation_interface"application windows management\n\nThis interface manages application windows.\nIt provides requests to show and hide the desktop and emits\nan event every time a window is created so that the client can\nuse it to manage the window.\n\nOnly one client can bind this interface at a time."KeepAboveKeepBelowOnAllDesktopsDemandsAttentionCloseableMinimizableMaximizableFullscreenableSkiptaskbarShadeableShadedMovableVirtualDesktopChangeableSkipswitcherShowDesktopREQ_SHOW_DESKTOP_SINCEREQ_SHOW_DESKTOP_OPCODEREQ_GET_WINDOW_SINCEREQ_GET_WINDOW_OPCODEREQ_GET_WINDOW_BY_UUID_SINCEREQ_GET_WINDOW_BY_UUID_OPCODEEVT_SHOW_DESKTOP_CHANGED_SINCEEVT_SHOW_DESKTOP_CHANGED_OPCODEEVT_WINDOW_SINCEEVT_WINDOW_OPCODEEVT_STACKING_ORDER_CHANGED_SINCEEVT_STACKING_ORDER_CHANGED_OPCODEEVT_STACKING_ORDER_UUID_CHANGED_SINCEEVT_STACKING_ORDER_UUID_CHANGED_OPCODEEVT_WINDOW_WITH_UUID_SINCEEVT_WINDOW_WITH_UUID_OPCODE"show/hide the desktop\n\nTell the compositor to show/hide the desktop.""requested state""deprecated\n\nDeprecated: use get_window_by_uuid""The internal window id of the window to create"internal_window_idGetWindow"Only available since version 12 of the interface""The internal window uuiid of the window to create"internal_window_uuidGetWindowByUuid"notify the client when the show desktop mode is entered/left\n\nThis event will be sent whenever the show desktop mode changes. E.g. when it is entered\nor left.\n\nOn binding the interface the current state is sent.""new state"ShowDesktopChanged"notify the client that a window was mapped\n\nThis event will be sent immediately after a window is mapped.""Deprecated: internal window Id""notify the client when stacking order changed\n\nThis event will be sent when stacking order changed and on bind\n\nOnly available since version 11 of the interface""internal windows id array"StackingOrderChanged"notify the client when stacking order changed\n\nThis event will be sent when stacking order changed and on bind\n\nOnly available since version 12 of the interface""internal windows id ;-separated"uuidsStackingOrderUuidChanged"notify the client that a window was mapped\n\nThis event will be sent immediately after a window is mapped.\n\nOnly available since version 13 of the interface""internal window uuid"WindowWithUuid"application windows management\n\nThis interface manages application windows.\nIt provides requests to show and hide the desktop and emits\nan event every time a window is created so that the client can\nuse it to manage the window.\n\nOnly one client can bind this interface at a time.\n\nSee also the [Event] enum for this interface."OrgKdePlasmaWindowManagementorg_kde_plasma_windowOrgKdePlasmaWindowget_windowget_window_by_uuidorg_kde_plasma_window_management"interface to control application windows\n\nManages and control an application window.\n\nOnly one client can bind this interface at a time."REQ_SET_STATE_SINCEREQ_SET_STATE_OPCODEREQ_SET_VIRTUAL_DESKTOP_SINCEREQ_SET_VIRTUAL_DESKTOP_OPCODEREQ_SET_MINIMIZED_GEOMETRY_SINCEREQ_SET_MINIMIZED_GEOMETRY_OPCODEREQ_UNSET_MINIMIZED_GEOMETRY_SINCEREQ_UNSET_MINIMIZED_GEOMETRY_OPCODEREQ_CLOSE_SINCEREQ_CLOSE_OPCODEREQ_REQUEST_MOVE_SINCEREQ_REQUEST_MOVE_OPCODEREQ_REQUEST_RESIZE_SINCEREQ_REQUEST_RESIZE_OPCODEREQ_GET_ICON_SINCEREQ_GET_ICON_OPCODEREQ_REQUEST_ENTER_VIRTUAL_DESKTOP_SINCEREQ_REQUEST_ENTER_VIRTUAL_DESKTOP_OPCODEREQ_REQUEST_ENTER_NEW_VIRTUAL_DESKTOP_SINCEREQ_REQUEST_ENTER_NEW_VIRTUAL_DESKTOP_OPCODEREQ_REQUEST_LEAVE_VIRTUAL_DESKTOP_SINCEREQ_REQUEST_LEAVE_VIRTUAL_DESKTOP_OPCODEREQ_REQUEST_ENTER_ACTIVITY_SINCEREQ_REQUEST_ENTER_ACTIVITY_OPCODEREQ_REQUEST_LEAVE_ACTIVITY_SINCEREQ_REQUEST_LEAVE_ACTIVITY_OPCODEREQ_SEND_TO_OUTPUT_SINCEREQ_SEND_TO_OUTPUT_OPCODEEVT_TITLE_CHANGED_SINCEEVT_TITLE_CHANGED_OPCODEEVT_APP_ID_CHANGED_SINCEEVT_APP_ID_CHANGED_OPCODEEVT_STATE_CHANGED_SINCEEVT_STATE_CHANGED_OPCODEEVT_VIRTUAL_DESKTOP_CHANGED_SINCEEVT_VIRTUAL_DESKTOP_CHANGED_OPCODEEVT_THEMED_ICON_NAME_CHANGED_SINCEEVT_THEMED_ICON_NAME_CHANGED_OPCODEEVT_UNMAPPED_SINCEEVT_UNMAPPED_OPCODEEVT_INITIAL_STATE_SINCEEVT_INITIAL_STATE_OPCODEEVT_PARENT_WINDOW_SINCEEVT_PARENT_WINDOW_OPCODEEVT_ICON_CHANGED_SINCEEVT_ICON_CHANGED_OPCODEEVT_PID_CHANGED_SINCEEVT_PID_CHANGED_OPCODEEVT_VIRTUAL_DESKTOP_ENTERED_SINCEEVT_VIRTUAL_DESKTOP_ENTERED_OPCODEEVT_VIRTUAL_DESKTOP_LEFT_SINCEEVT_VIRTUAL_DESKTOP_LEFT_OPCODEEVT_APPLICATION_MENU_SINCEEVT_APPLICATION_MENU_OPCODEEVT_ACTIVITY_ENTERED_SINCEEVT_ACTIVITY_ENTERED_OPCODEEVT_ACTIVITY_LEFT_SINCEEVT_ACTIVITY_LEFT_OPCODEEVT_RESOURCE_NAME_CHANGED_SINCEEVT_RESOURCE_NAME_CHANGED_OPCODE"set window state\n\nSet window state.\n\nValues for state argument are described by org_kde_plasma_window_management.state\nand can be used together in a bitfield. The flags bitfield describes which flags are\nsupposed to be set, the state bitfield the value for the set flags""bitfield of set state flags""bitfield of state flags""map window on a virtual desktop\n\nDeprecated: use enter_virtual_desktop\nMaps the window to a different virtual desktop.\n\nTo show the window on all virtual desktops, call the\norg_kde_plasma_window.set_state request and specify a on_all_desktops\nstate in the bitfield.""zero based virtual desktop number"SetVirtualDesktop"set the geometry for a taskbar entry\n\nSets the geometry of the taskbar entry for this window.\nThe geometry is relative to a panel in particular."panelSetMinimizedGeometry"set the geometry for a taskbar entry\n\nRemove the task geometry information for a particular panel."UnsetMinimizedGeometry"close window\n\nClose this window.""request move\n\nRequest an interactive move for this window.\n\nOnly available since version 3 of the interface"RequestMove"request resize\n\nRequest an interactive resize for this window.\n\nOnly available since version 3 of the interface"RequestResize"remove resource for the org_kde_plasma_window\n\nRemoves the resource bound for this org_kde_plasma_window.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 4 of the interface""Requests to get the window icon\n\nThe compositor will write the window icon into the provided file descriptor.\nThe data is a serialized QIcon with QDataStream.\n\nOnly available since version 7 of the interface""file descriptor for the icon"GetIcon"map window on a virtual desktop\n\nMake the window enter a virtual desktop. A window can enter more\nthan one virtual desktop. if the id is empty or invalid, no action will be performed.\n\nOnly available since version 8 of the interface""desktop id"RequestEnterVirtualDesktop"map window on a virtual desktop\n\nRFC: do this with an empty id to request_enter_virtual_desktop?\nMake the window enter a new virtual desktop. If the server consents the request,\nit will create a new virtual desktop and assign the window to it.\n\nOnly available since version 8 of the interface"RequestEnterNewVirtualDesktop"remove a window from a virtual desktop\n\nMake the window exit a virtual desktop. If it exits all desktops it will be considered on all of them.\n\nOnly available since version 8 of the interface"RequestLeaveVirtualDesktop"map window on an activity\n\nMake the window enter an activity. A window can enter more activity. If the id is empty or invalid, no action will be performed.\n\nOnly available since version 14 of the interface""activity id"RequestEnterActivity"remove a window from an activity\n\nMake the window exit a an activity. If it exits all activities it will be considered on all of them.\n\nOnly available since version 14 of the interface"RequestLeaveActivity"send window to specified output\n\nRequests this window to be displayed in a specific output.\n\nOnly available since version 15 of the interface"SendToOutput"window title has been changed\n\nThis event will be sent as soon as the window title is changed.""window title"TitleChanged"application identifier has been changed\n\nThis event will be sent as soon as the application\nidentifier is changed."AppIdChanged"window state has been changed\n\nThis event will be sent as soon as the window state changes.\n\nValues for state argument are described by org_kde_plasma_window_management.state.""window was moved to another workspace\n\nDEPRECATED: use virtual_desktop_entered and virtual_desktop_left instead\nThis event will be sent when a window is moved to another\nvirtual desktop.\n\nIt is not sent if it becomes visible on all virtual desktops though."VirtualDesktopChanged"window's icon name changed\n\nThis event will be sent whenever the themed icon name changes. May be null.""the new themed icon name"ThemedIconNameChanged"window's surface was unmapped\n\nThis event will be sent immediately after the window is closed\nand its surface is unmapped."Unmapped"All initial known state is submitted\n\nThis event will be sent immediately after all initial state been sent to the client.\nIf the Plasma window is already unmapped, the unmapped event will be sent before the\ninitial_state event.\n\nOnly available since version 4 of the interface"InitialState"The parent window changed\n\nThis event will be sent whenever the parent window of this org_kde_plasma_window changes.\nThe passed parent is another org_kde_plasma_window and this org_kde_plasma_window is a\ntransient window to the parent window. If the parent argument is null, this\norg_kde_plasma_window does not have a parent window.\n\nOnly available since version 5 of the interface""The parent window"ParentWindow"The geometry of this window in absolute coordinates\n\nThis event will be sent whenever the window geometry of this org_kde_plasma_window changes.\nThe coordinates are in absolute coordinates of the windowing system.\n\nOnly available since version 6 of the interface""x position of the org_kde_plasma_window""y position of the org_kde_plasma_window""width of the org_kde_plasma_window""height of the org_kde_plasma_window""The icon of the window changed\n\nThis event will be sent whenever the icon of the window changes, but there is no themed\nicon name. Common examples are Xwayland windows which have a pixmap based icon.\n\nThe client can request the icon using get_icon.\n\nOnly available since version 7 of the interface"IconChanged"process id of application owning the window has changed\n\nThis event will be sent when the compositor has set the process id this window belongs to.\nThis should be set once before the initial_state is sent.""process id"PidChanged"the window entered a new virtual desktop\n\nThis event will be sent when the window has entered a new virtual desktop. The window can be on more than one desktop, or none: then is considered on all of them.\n\nOnly available since version 8 of the interface"VirtualDesktopEntered"the window left a virtual desktop\n\nThis event will be sent when the window left a virtual desktop. If the window leaves all desktops, it can be considered on all.\nIf the window gets manually added on all desktops, the server has to send virtual_desktop_left for every previous desktop it was in for the window to be really considered on all desktops.\n\nOnly available since version 8 of the interface"VirtualDesktopLeft"notify the client that the current appmenu changed\n\nThis event will be sent after the application menu\nfor the window has changed.\n\nOnly available since version 10 of the interface"ApplicationMenu"the window entered an activity\n\nThis event will be sent when the window has entered an activity. The window can be on more than one activity, or none: then is considered on all of them.\n\nOnly available since version 14 of the interface"ActivityEntered"the window left an activity\n\nThis event will be sent when the window left an activity. If the window leaves all activities, it will be considered on all.\nIf the window gets manually added on all activities, the server has to send activity_left for every previous activity it was in for the window to be really considered on all activities.\n\nOnly available since version 14 of the interface"ActivityLeft"X11 resource name has changed\n\nThis event will be sent when the X11 resource name of the window has changed.\nThis is only set for XWayland windows.\n\nOnly available since version 16 of the interface""resource name"resource_nameResourceNameChanged"interface to control application windows\n\nManages and control an application window.\n\nOnly one client can bind this interface at a time.\n\nSee also the [Event] enum for this interface."set_virtual_desktopset_minimized_geometryunset_minimized_geometry"request move\n\nRequest an interactive move for this window."request_move"request resize\n\nRequest an interactive resize for this window."request_resize"remove resource for the org_kde_plasma_window\n\nRemoves the resource bound for this org_kde_plasma_window.""Requests to get the window icon\n\nThe compositor will write the window icon into the provided file descriptor.\nThe data is a serialized QIcon with QDataStream.""map window on a virtual desktop\n\nMake the window enter a virtual desktop. A window can enter more\nthan one virtual desktop. if the id is empty or invalid, no action will be performed."request_enter_virtual_desktop"map window on a virtual desktop\n\nRFC: do this with an empty id to request_enter_virtual_desktop?\nMake the window enter a new virtual desktop. If the server consents the request,\nit will create a new virtual desktop and assign the window to it."request_enter_new_virtual_desktop"remove a window from a virtual desktop\n\nMake the window exit a virtual desktop. If it exits all desktops it will be considered on all of them."request_leave_virtual_desktop"map window on an activity\n\nMake the window enter an activity. A window can enter more activity. If the id is empty or invalid, no action will be performed."request_enter_activity"remove a window from an activity\n\nMake the window exit a an activity. If it exits all activities it will be considered on all of them."request_leave_activity"send window to specified output\n\nRequests this window to be displayed in a specific output."send_to_output"activation feedback\n\nThe activation manager interface provides a way to get notified\nwhen an application is about to be activated."EVT_ACTIVATION_SINCEEVT_ACTIVATION_OPCODE"destroy the activation manager object\n\nDestroy the activation manager object. The activation objects introduced\nby this manager object will be unaffected.\n\nThis is a destructor, once sent this object cannot be used any longer.""notify that an app is starting\n\nWill be issued when an app is set to be activated. It offers\nan instance of org_kde_plasma_activation that will tell us the app_id\nand the extent of the activation."org_kde_plasma_activationOrgKdePlasmaActivationActivation"activation feedback\n\nThe activation manager interface provides a way to get notified\nwhen an application is about to be activated.\n\nSee also the [Event] enum for this interface."OrgKdePlasmaActivationFeedback"destroy the activation manager object\n\nDestroy the activation manager object. The activation objects introduced\nby this manager object will be unaffected."org_kde_plasma_activation_feedback"destroy the org_kde_plasma_activation object\n\nNotify the compositor that the org_kde_plasma_activation object will no\nlonger be used.\n\nThis is a destructor, once sent this object cannot be used any longer.""Offers the app_id""application id, as described in xdg_activation_v1""Notifies about activation finished, either by activation or because it got invalidated""org_kde_plasma_activation\n\nSee also the [Event] enum for this interface.""destroy the org_kde_plasma_activation object\n\nNotify the compositor that the org_kde_plasma_activation object will no\nlonger be used."plasma_window_managementORG_KDE_KWIN_REMOTE_ACCESS_MANAGER_INTERFACEorg_kde_kwin_remote_access_manager_requests_get_buffer_typesorg_kde_kwin_remote_access_manager_requestsorg_kde_kwin_remote_access_manager_events_buffer_ready_typesorg_kde_kwin_remote_access_manager_eventsorg_kde_kwin_remote_access_manager_interfaceORG_KDE_KWIN_REMOTE_BUFFER_INTERFACEorg_kde_kwin_remote_buffer_requestsorg_kde_kwin_remote_buffer_eventsorg_kde_kwin_remote_buffer_interface"Protocol for managing rendered GBM buffers passing"REQ_GET_BUFFER_SINCEREQ_GET_BUFFER_OPCODEEVT_BUFFER_READY_SINCEEVT_BUFFER_READY_OPCODE"Answer on buffer_ready event, retrieves new buffer from server""The internal buffer id of the buffer to create"internal_buffer_idGetBuffer"release org_kde_kwin_remote_access_manager interface\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""Signals about buffer ready to be consumed by clients""unique id of created buffer (you can use server-side fd number)""screen that this buffer belongs to"BufferReady"Protocol for managing rendered GBM buffers passing\n\n\n\nSee also the [Event] enum for this interface."OrgKdeKwinRemoteAccessManagerorg_kde_kwin_remote_bufferOrgKdeKwinRemoteBuffer"release org_kde_kwin_remote_access_manager interface"org_kde_kwin_remote_access_manager"This interface allows finer control of remote buffer lifecycle"EVT_GBM_HANDLE_SINCEEVT_GBM_HANDLE_OPCODE"This request comes once client no longer needs this buffer.\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""This is sent after binding to remote access manager"GbmHandle"This interface allows finer control of remote buffer lifecycle\n\n\n\nSee also the [Event] enum for this interface.""This request comes once client no longer needs this buffer."remote_accessZKDE_SCREENCAST_UNSTABLE_V1_INTERFACEzkde_screencast_unstable_v1_requests_stream_output_typeszkde_screencast_unstable_v1_requests_stream_window_typeszkde_screencast_unstable_v1_requests_stream_virtual_output_typeszkde_screencast_unstable_v1_requests_stream_region_typeszkde_screencast_unstable_v1_requestszkde_screencast_unstable_v1_interfaceZKDE_SCREENCAST_STREAM_UNSTABLE_V1_INTERFACEzkde_screencast_stream_unstable_v1_requestszkde_screencast_stream_unstable_v1_eventszkde_screencast_stream_unstable_v1_interface"Protocol for managing PipeWire feeds of the different displays and windows.""Stream consumer attachment attributes""No cursor""Render the cursor on the stream""Send metadata about where the cursor is through PipeWire"REQ_STREAM_OUTPUT_SINCEREQ_STREAM_OUTPUT_OPCODEREQ_STREAM_WINDOW_SINCEREQ_STREAM_WINDOW_OPCODEREQ_STREAM_VIRTUAL_OUTPUT_SINCEREQ_STREAM_VIRTUAL_OUTPUT_OPCODEREQ_STREAM_REGION_SINCEREQ_STREAM_REGION_OPCODE"requests a feed from a given source""Requested pointer mode"StreamOutput"window Identifier"window_uuidStreamWindow"Destroy the zkde_screencast_unstable_v1\n\nDestroy the zkde_screencast_unstable_v1 object.\n\nThis is a destructor, once sent this object cannot be used any longer.""requests a feed from a new virtual output\n\n\n\nOnly available since version 2 of the interface""name of the created output""Logical width resolution""Logical height resolution""Scaling factor of the display where it's to be displayed"StreamVirtualOutput"requests a feed from region in the workspace\n\n\n\nOnly available since version 3 of the interface""Logical left position""Logical top position""Scaling factor of the output recording"StreamRegion"Protocol for managing PipeWire feeds of the different displays and windows.\n\n\n\nThis interface has no events."ZkdeScreencastUnstableV1zkde_screencast_stream_unstable_v1ZkdeScreencastStreamUnstableV1stream_outputstream_window"Destroy the zkde_screencast_unstable_v1\n\nDestroy the zkde_screencast_unstable_v1 object.""requests a feed from a new virtual output"stream_virtual_output"requests a feed from region in the workspace"stream_regionzkde_screencast_unstable_v1"Indicates we are done with the stream and the communication is over.\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""Notifies that the server has stopped the stream. Clients should now call close.""Notifies about a pipewire feed being created""node of the pipewire buffer""Offers an error message so the client knows the created event will not arrive, and the client should close the resource.""A human readable translated error message.""zkde_screencast_stream_unstable_v1\n\nSee also the [Event] enum for this interface.""Indicates we are done with the stream and the communication is over."screencastORG_KDE_KWIN_SERVER_DECORATION_PALETTE_MANAGER_INTERFACEorg_kde_kwin_server_decoration_palette_manager_requests_create_typesorg_kde_kwin_server_decoration_palette_manager_requestsorg_kde_kwin_server_decoration_palette_manager_interfaceORG_KDE_KWIN_SERVER_DECORATION_PALETTE_INTERFACEorg_kde_kwin_server_decoration_palette_requestsorg_kde_kwin_server_decoration_palette_interface"server side decoration palette manager interface\n\nThis interface allows a client to alter the palette of a server side decoration.""server side decoration palette manager interface\n\nThis interface allows a client to alter the palette of a server side decoration.\n\nThis interface has no events."OrgKdeKwinServerDecorationPaletteManagerorg_kde_kwin_server_decoration_paletteOrgKdeKwinServerDecorationPaletteorg_kde_kwin_server_decoration_palette_manager"server side decoration palette interface\n\nThis interface allows a client to alter the palette of a server side decoration."REQ_SET_PALETTE_SINCEREQ_SET_PALETTE_OPCODE"Set a on the server side window decoration\n\nColor scheme that should be applied to the window decoration.\nAbsolute file path, or name of palette in the user's config directory.\nThe server may choose not to follow the requested style.""Absolute file path, or name of palette in the user's config directory"SetPalette"release the palette object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""server side decoration palette interface\n\nThis interface allows a client to alter the palette of a server side decoration.\n\nThis interface has no events.""release the palette object"server_decoration_paletteORG_KDE_KWIN_SHADOW_MANAGER_INTERFACEorg_kde_kwin_shadow_manager_requests_create_typesorg_kde_kwin_shadow_manager_requests_unset_typesorg_kde_kwin_shadow_manager_requestsorg_kde_kwin_shadow_manager_interfaceORG_KDE_KWIN_SHADOW_INTERFACEorg_kde_kwin_shadow_requests_attach_left_typesorg_kde_kwin_shadow_requests_attach_top_left_typesorg_kde_kwin_shadow_requests_attach_top_typesorg_kde_kwin_shadow_requests_attach_top_right_typesorg_kde_kwin_shadow_requests_attach_right_typesorg_kde_kwin_shadow_requests_attach_bottom_right_typesorg_kde_kwin_shadow_requests_attach_bottom_typesorg_kde_kwin_shadow_requests_attach_bottom_left_typesorg_kde_kwin_shadow_requestsorg_kde_kwin_shadow_interface"Destroy the org_kde_kwin_shadow_manager\n\nDestroy the org_kde_kwin_shadow_manager object.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""org_kde_kwin_shadow_manager\n\nThis interface has no events."OrgKdeKwinShadowManagerorg_kde_kwin_shadowOrgKdeKwinShadow"Destroy the org_kde_kwin_shadow_manager\n\nDestroy the org_kde_kwin_shadow_manager object."org_kde_kwin_shadow_managerREQ_ATTACH_LEFT_SINCEREQ_ATTACH_LEFT_OPCODEREQ_ATTACH_TOP_LEFT_SINCEREQ_ATTACH_TOP_LEFT_OPCODEREQ_ATTACH_TOP_SINCEREQ_ATTACH_TOP_OPCODEREQ_ATTACH_TOP_RIGHT_SINCEREQ_ATTACH_TOP_RIGHT_OPCODEREQ_ATTACH_RIGHT_SINCEREQ_ATTACH_RIGHT_OPCODEREQ_ATTACH_BOTTOM_RIGHT_SINCEREQ_ATTACH_BOTTOM_RIGHT_OPCODEREQ_ATTACH_BOTTOM_SINCEREQ_ATTACH_BOTTOM_OPCODEREQ_ATTACH_BOTTOM_LEFT_SINCEREQ_ATTACH_BOTTOM_LEFT_OPCODEREQ_SET_LEFT_OFFSET_SINCEREQ_SET_LEFT_OFFSET_OPCODEREQ_SET_TOP_OFFSET_SINCEREQ_SET_TOP_OFFSET_OPCODEREQ_SET_RIGHT_OFFSET_SINCEREQ_SET_RIGHT_OFFSET_OPCODEREQ_SET_BOTTOM_OFFSET_SINCEREQ_SET_BOTTOM_OFFSET_OPCODEAttachLeftAttachTopLeftAttachTopAttachTopRightAttachRightAttachBottomRightAttachBottomAttachBottomLeftSetLeftOffsetSetTopOffsetSetRightOffsetSetBottomOffset"Destroy the org_kde_kwin_shadow\n\nDestroy the org_kde_kwin_shadow object. If the org_kde_kwin_shadow is\nstill set on a wl_surface the shadow will be immediately removed.\nPrefer to first call the request unset on the org_kde_kwin_shadow_manager and\ncommit the wl_surface to apply the change.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 2 of the interface""org_kde_kwin_shadow\n\nThis interface has no events."attach_leftattach_top_leftattach_topattach_top_rightattach_rightattach_bottom_rightattach_bottomattach_bottom_leftset_left_offsetset_top_offsetset_right_offsetset_bottom_offset"Destroy the org_kde_kwin_shadow\n\nDestroy the org_kde_kwin_shadow object. If the org_kde_kwin_shadow is\nstill set on a wl_surface the shadow will be immediately removed.\nPrefer to first call the request unset on the org_kde_kwin_shadow_manager and\ncommit the wl_surface to apply the change."ORG_KDE_KWIN_SLIDE_MANAGER_INTERFACEorg_kde_kwin_slide_manager_requests_create_typesorg_kde_kwin_slide_manager_requests_unset_typesorg_kde_kwin_slide_manager_requestsorg_kde_kwin_slide_manager_interfaceORG_KDE_KWIN_SLIDE_INTERFACEorg_kde_kwin_slide_requestsorg_kde_kwin_slide_interface"org_kde_kwin_slide_manager\n\nThis interface has no events."OrgKdeKwinSlideManagerorg_kde_kwin_slideOrgKdeKwinSlideorg_kde_kwin_slide_manager"slide a surface from a location to another\n\nAsk the compositor to move the surface from a location to another\nwith a slide animation.\n\nThe from argument provides a clue about where the slide animation\nbegins, offset is the distance from screen edge to begin the animation."REQ_SET_LOCATION_SINCEREQ_SET_LOCATION_OPCODESetLocation"release the slide object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""slide a surface from a location to another\n\nAsk the compositor to move the surface from a location to another\nwith a slide animation.\n\nThe from argument provides a clue about where the slide animation\nbegins, offset is the distance from screen edge to begin the animation.\n\nThis interface has no events.""release the slide object"slideQT_SURFACE_EXTENSION_INTERFACEqt_surface_extension_requests_get_extended_surface_typesqt_surface_extension_requestsqt_surface_extension_interfaceQT_EXTENDED_SURFACE_INTERFACEqt_extended_surface_requestsqt_extended_surface_eventsqt_extended_surface_interfaceREQ_GET_EXTENDED_SURFACE_SINCEREQ_GET_EXTENDED_SURFACE_OPCODEGetExtendedSurface"qt_surface_extension\n\nThis interface has no events."QtSurfaceExtensionqt_extended_surfaceQtExtendedSurfaceget_extended_surfaceqt_surface_extensionPrimaryOrientationPortraitOrientationLandscapeOrientationInvertedPortraitOrientationInvertedLandscapeOrientationWindowflagOverridesSystemGesturesStaysOnTopBypassWindowManagerREQ_UPDATE_GENERIC_PROPERTY_SINCEREQ_UPDATE_GENERIC_PROPERTY_OPCODEREQ_SET_CONTENT_ORIENTATION_MASK_SINCEREQ_SET_CONTENT_ORIENTATION_MASK_OPCODEREQ_SET_WINDOW_FLAGS_SINCEREQ_SET_WINDOW_FLAGS_OPCODEREQ_RAISE_SINCEREQ_RAISE_OPCODEREQ_LOWER_SINCEREQ_LOWER_OPCODEEVT_ONSCREEN_VISIBILITY_SINCEEVT_ONSCREEN_VISIBILITY_OPCODEEVT_SET_GENERIC_PROPERTY_SINCEEVT_SET_GENERIC_PROPERTY_OPCODEUpdateGenericPropertySetContentOrientationMaskSetWindowFlagsRaiseOnscreenVisibilitySetGenericProperty"qt_extended_surface\n\nSee also the [Event] enum for this interface."update_generic_propertyset_content_orientation_masksurface_extensionWL_TEXT_INPUT_INTERFACEwl_text_input_requests_activate_typeswl_text_input_requests_deactivate_typeswl_text_input_requestswl_text_input_events_enter_typeswl_text_input_eventswl_text_input_interfaceWL_TEXT_INPUT_MANAGER_INTERFACEwl_text_input_manager_requests_create_text_input_typeswl_text_input_manager_requestswl_text_input_manager_interface"text input\n\nAn object used for text input. Adds support for text input and input\nmethods to applications. A text-input object is created from a\nwl_text_input_manager and corresponds typically to a text entry in an\napplication.\nRequests are used to activate/deactivate the text-input object and set\nstate information like surrounding and selected text or the content type.\nThe information about entered text is sent to the text-input object via\nthe pre-edit and commit events. Using this interface removes the need\nfor applications to directly process hardware key events and compose text\nout of them.\n\nText is generally UTF-8 encoded, indices and lengths are in bytes.\n\nSerials are used to synchronize the state between the text input and\nan input method. New serials are sent by the text input in the\ncommit_state request and are used by the input method to indicate\nthe known text input state in events like preedit_string, commit_string,\nand keysym. The text input can then ignore events from the input method\nwhich are based on an outdated state (for example after a reset).""request activation\n\nRequests the text-input object to be activated (typically when the\ntext entry gets focus).\nThe seat argument is a wl_seat which maintains the focus for this\nactivation. The surface argument is a wl_surface assigned to the\ntext-input object and tracked for focus lost. The enter event\nis emitted on successful activation.""request deactivation\n\nRequests the text-input object to be deactivated (typically when the\ntext entry lost focus). The seat argument is a wl_seat which was used\nfor activation.""sets the surrounding text\n\nSets the plain surrounding text around the input position. Text is\nUTF-8 encoded. Cursor is the byte offset within the\nsurrounding text. Anchor is the byte offset of the\nselection anchor within the surrounding text. If there is no selected\ntext anchor is the same as cursor.""sets preferred language\n\nSets a specific language. This allows for example a virtual keyboard to\nshow a language specific layout. The \"language\" argument is a RFC-3066\nformat language tag.\n\nIt could be used for example in a word processor to indicate language of\ncurrently edited document or in an instant message application which tracks\nlanguages of contacts.""enter event\n\nNotify the text-input object when it received focus. Typically in\nresponse to an activate request.""leave event\n\nNotify the text-input object when it lost focus. Either in response\nto a deactivate request or when the assigned surface lost focus or was\ndestroyed.""modifiers map\n\nTransfer an array of 0-terminated modifiers names. The position in\nthe array is the index of the modifier as used in the modifiers\nbitmask in the keysym event.""commit\n\nNotify when text should be inserted into the editor widget. The text to\ncommit could be either just a single character after a key press or the\nresult of some composing (pre-edit). It could be also an empty text\nwhen some text should be removed (see delete_surrounding_text) or when\nthe input cursor should be moved (see cursor_position).\n\nAny previously set composing text should be removed.""keysym\n\nNotify when a key event was sent. Key events should not be used\nfor normal text input operations, which should be done with\ncommit_string, delete_surrounding_text, etc. The key event follows\nthe wl_keyboard key event convention. Sym is a XKB keysym, state a\nwl_keyboard key_state. Modifiers are a mask for effective modifiers\n(where the modifier indices are set by the modifiers_map event)""language\n\nSets the language of the input text. The \"language\" argument is a RFC-3066\nformat language tag.""text direction\n\nSets the text direction of input text.\n\nIt is mainly needed for showing input cursor on correct side of the\neditor when there is no input yet done and making sure neutral\ndirection text is laid out properly.""text input\n\nAn object used for text input. Adds support for text input and input\nmethods to applications. A text-input object is created from a\nwl_text_input_manager and corresponds typically to a text entry in an\napplication.\nRequests are used to activate/deactivate the text-input object and set\nstate information like surrounding and selected text or the content type.\nThe information about entered text is sent to the text-input object via\nthe pre-edit and commit events. Using this interface removes the need\nfor applications to directly process hardware key events and compose text\nout of them.\n\nText is generally UTF-8 encoded, indices and lengths are in bytes.\n\nSerials are used to synchronize the state between the text input and\nan input method. New serials are sent by the text input in the\ncommit_state request and are used by the input method to indicate\nthe known text input state in events like preedit_string, commit_string,\nand keysym. The text input can then ignore events from the input method\nwhich are based on an outdated state (for example after a reset).\n\nSee also the [Event] enum for this interface."WlTextInputwl_text_input"create text input\n\nCreates a new text-input object."WlTextInputManagerwl_text_input_managerZWP_TEXT_INPUT_V2_INTERFACEzwp_text_input_v2_requests_enable_typeszwp_text_input_v2_requests_disable_typeszwp_text_input_v2_requestszwp_text_input_v2_events_enter_typeszwp_text_input_v2_events_leave_typeszwp_text_input_v2_eventszwp_text_input_v2_interfaceZWP_TEXT_INPUT_MANAGER_V2_INTERFACEzwp_text_input_manager_v2_requests_get_text_input_typeszwp_text_input_manager_v2_requestszwp_text_input_manager_v2_interface"text input\n\nThe zwp_text_input_v2 interface represents text input and input methods\nassociated with a seat. It provides enter/leave events to follow the\ntext input focus for a seat.\n\nRequests are used to enable/disable the text-input object and set\nstate information like surrounding and selected text or the content type.\nThe information about the entered text is sent to the text-input object\nvia the pre-edit and commit events. Using this interface removes the need\nfor applications to directly process hardware key events and compose text\nout of them.\n\nText is valid UTF-8 encoded, indices and lengths are in bytes. Indices\nhave to always point to the first byte of an UTF-8 encoded code point.\nLengths are not allowed to contain just a part of an UTF-8 encoded code\npoint.\n\nState is sent by the state requests (set_surrounding_text,\nset_content_type, set_cursor_rectangle and set_preferred_language) and\nan update_state request. After an enter or an input_method_change event\nall state information is invalidated and needs to be resent from the\nclient. A reset or entering a new widget on client side also\ninvalidates all current state information.""update_state flags\n\nDefines the reason for sending an updated state."UpdateState"updated state because it changed""full state after enter or input_method_changed event""full state after reset""full state after switching focus to a different widget on client side"InputPanelVisibility"the input panel (virtual keyboard) is hidden""the input panel (virtual keyboard) is visible""composing text should be shown the same as non-composing text""composing text might be bold""composing text might be cursive""composing text might have a different background color""composing text might be underlined""composing text should be shown the same as selected text""composing text might be underlined with a red wavy line"REQ_UPDATE_STATE_SINCEREQ_UPDATE_STATE_OPCODEEVT_CONFIGURE_SURROUNDING_TEXT_SINCEEVT_CONFIGURE_SURROUNDING_TEXT_OPCODEEVT_INPUT_METHOD_CHANGED_SINCEEVT_INPUT_METHOD_CHANGED_OPCODE"Destroy the wp_text_input\n\nDestroy the wp_text_input object. Also disables all surfaces enabled\nthrough this wp_text_input object\n\nThis is a destructor, once sent this object cannot be used any longer.""enable text input for surface\n\nEnable text input in a surface (usually when a text entry inside of it\nhas focus).\n\nThis can be called before or after a surface gets text (or keyboard)\nfocus via the enter event. Text input to a surface is only active\nwhen it has the current text (or keyboard) focus and is enabled.""disable text input for surface\n\nDisable text input in a surface (typically when there is no focus on any\ntext entry inside the surface).""show input panels\n\nRequests input panels (virtual keyboard) to show.\n\nThis should be used for example to show a virtual keyboard again\n(with a tap) after it was closed by pressing on a close button on the\nkeyboard.""sets the surrounding text\n\nSets the plain surrounding text around the input position. Text is\nUTF-8 encoded. Cursor is the byte offset within the surrounding text.\nAnchor is the byte offset of the selection anchor within the\nsurrounding text. If there is no selected text, anchor is the same as\ncursor.\n\nMake sure to always send some text before and after the cursor\nexcept when the cursor is at the beginning or end of text.\n\nWhen there was a configure_surrounding_text event take the\nbefore_cursor and after_cursor arguments into account for picking how\nmuch surrounding text to send.\n\nThere is a maximum length of wayland messages so text can not be\nlonger than 4000 bytes.""set content purpose and hint\n\nSets the content purpose and content hint. While the purpose is the\nbasic purpose of an input field, the hint flags allow to modify some\nof the behavior.\n\nWhen no content type is explicitly set, a normal content purpose with\nnone hint should be assumed.""set cursor position\n\nSets the cursor outline as a x, y, width, height rectangle in surface\nlocal coordinates.\n\nAllows the compositor to put a window with word suggestions near the\ncursor.""sets preferred language\n\nSets a specific language. This allows for example a virtual keyboard to\nshow a language specific layout. The \"language\" argument is a RFC-3066\nformat language tag.\n\nIt could be used for example in a word processor to indicate language of\ncurrently edited document or in an instant message application which\ntracks languages of contacts.""update state\n\nAllows to atomically send state updates from client.\n\nThis request should follow after a batch of state updating requests\nlike set_surrounding_text, set_content_type, set_cursor_rectangle and\nset_preferred_language.\n\nThe flags field indicates why an updated state is sent to the input\nmethod.\n\nReset should be used by an editor widget after the text was changed\noutside of the normal input method flow.\n\nFor \"change\" it is enough to send the changed state, else the full\nstate should be send.\n\nSerial should be set to the serial from the last enter or\ninput_method_changed event.\n\nTo make sure to not receive outdated input method events after a\nreset or switching to a new widget wl_display_sync() should be used\nafter update_state in these cases.""serial of the enter or input_method_changed event""enter event\n\nNotification that this seat's text-input focus is on a certain surface.\n\nWhen the seat has the keyboard capability the text-input focus follows\nthe keyboard focus.""serial to be used by update_state""leave event\n\nNotification that this seat's text-input focus is no longer on\na certain surface.\n\nThe leave notification is sent before the enter notification\nfor the new focus.\n\nWhen the seat has the keyboard capability the text-input focus follows\nthe keyboard focus.""state of the input panel\n\nNotification that the visibility of the input panel (virtual keyboard)\nchanged.\n\nThe rectangle x, y, width, height defines the area overlapped by the\ninput panel (virtual keyboard) on the surface having the text\nfocus in surface local coordinates.\n\nThat can be used to make sure widgets are visible and not covered by\na virtual keyboard.""pre-edit\n\nNotify when a new composing text (pre-edit) should be set around the\ncurrent cursor position. Any previously set composing text should\nbe removed.\n\nThe commit text can be used to replace the composing text in some cases\n(for example when losing focus).\n\nThe text input should also handle all preedit_style and preedit_cursor\nevents occurring directly before preedit_string.""pre-edit styling\n\nSets styling information on composing text. The style is applied for\nlength bytes from index relative to the beginning of the composing\ntext (as byte offset). Multiple styles can be applied to a composing\ntext by sending multiple preedit_styling events.\n\nThis event is handled as part of a following preedit_string event.""pre-edit cursor\n\nSets the cursor position inside the composing text (as byte\noffset) relative to the start of the composing text. When index is a\nnegative number no cursor is shown.\n\nWhen no preedit_cursor event is sent the cursor will be at the end of\nthe composing text by default.\n\nThis event is handled as part of a following preedit_string event.""set cursor to new position\n\nNotify when the cursor or anchor position should be modified.\n\nThis event should be handled as part of a following commit_string\nevent.\n\nThe text between anchor and index should be selected.""position of cursor""position of selection anchor""delete surrounding text\n\nNotify when the text around the current cursor position should be\ndeleted. BeforeLength and afterLength is the length (in bytes) of text\nbefore and after the current cursor position (excluding the selection)\nto delete.\n\nThis event should be handled as part of a following commit_string\nor preedit_string event.""configure amount of surrounding text to be sent\n\nConfigure what amount of surrounding text is expected by the\ninput method. The surrounding text will be sent in the\nset_surrounding_text request on the following state information updates."before_cursorafter_cursorConfigureSurroundingText"Notifies about a changed input method\n\nThe input method changed on compositor side, which invalidates all\ncurrent state information. New state information should be sent from\nthe client via state requests (set_surrounding_text,\nset_content_hint, ...) and update_state.""currently unused"InputMethodChanged"text input\n\nThe zwp_text_input_v2 interface represents text input and input methods\nassociated with a seat. It provides enter/leave events to follow the\ntext input focus for a seat.\n\nRequests are used to enable/disable the text-input object and set\nstate information like surrounding and selected text or the content type.\nThe information about the entered text is sent to the text-input object\nvia the pre-edit and commit events. Using this interface removes the need\nfor applications to directly process hardware key events and compose text\nout of them.\n\nText is valid UTF-8 encoded, indices and lengths are in bytes. Indices\nhave to always point to the first byte of an UTF-8 encoded code point.\nLengths are not allowed to contain just a part of an UTF-8 encoded code\npoint.\n\nState is sent by the state requests (set_surrounding_text,\nset_content_type, set_cursor_rectangle and set_preferred_language) and\nan update_state request. After an enter or an input_method_change event\nall state information is invalidated and needs to be resent from the\nclient. A reset or entering a new widget on client side also\ninvalidates all current state information.\n\nSee also the [Event] enum for this interface."ZwpTextInputV2"Destroy the wp_text_input\n\nDestroy the wp_text_input object. Also disables all surfaces enabled\nthrough this wp_text_input object"zwp_text_input_v2ZwpTextInputManagerV2zwp_text_input_manager_v2WL_EGLSTREAM_CONTROLLER_INTERFACEwl_eglstream_controller_requests_attach_eglstream_consumer_typeswl_eglstream_controller_requests_attach_eglstream_consumer_attribs_typeswl_eglstream_controller_requestswl_eglstream_controller_interface"Stream present mode\n\n- dont_care: Using this enum will tell the server to make its own\ndecisions regarding present mode.\n\n- fifo:      Tells the server to use a fifo present mode. The decision to\nuse fifo synchronous is left up to the server.\n\n- mailbox:   Tells the server to use a mailbox present mode."PresentMode"Let the Server decide present mode"DontCare"Use a fifo present mode""Use a mailbox mode"Mailbox"Stream consumer attachment attributes\n\n- present_mode: Must be one of wl_eglstream_controller_present_mode. Tells the\nserver the desired present mode that should be used.\n\n- fifo_length:  Only valid when the present_mode attrib is provided and its\nvalue is specified as fifo. Tells the server the desired fifo\nlength to be used when the desired present_mode is fifo.""Tells the server the desired present mode""Tells the server the desired fifo length when the desired presenation_mode is fifo."FifoLengthREQ_ATTACH_EGLSTREAM_CONSUMER_SINCEREQ_ATTACH_EGLSTREAM_CONSUMER_OPCODEREQ_ATTACH_EGLSTREAM_CONSUMER_ATTRIBS_SINCEREQ_ATTACH_EGLSTREAM_CONSUMER_ATTRIBS_OPCODE"Create server stream and attach consumer\n\nCreates the corresponding server side EGLStream from the given wl_buffer\nand attaches a consumer to it.""wl_surface corresponds to the client surface associated with newly created eglstream""wl_resource corresponding to an EGLStream"AttachEglstreamConsumer"Create server stream and attach consumer using attributes\n\nCreates the corresponding server side EGLStream from the given wl_buffer\nand attaches a consumer to it using the given attributes.\n\nOnly available since version 2 of the interface""List of attributes with consumer attachment data\n\nIt contains key-value pairs compatible with intptr_t type. A key must\nbe one of wl_eglstream_controller_attrib enumeration values. What a value\nrepresents is attribute-specific."attribsAttachEglstreamConsumerAttribs"wl_eglstream_controller\n\nThis interface has no events."WlEglstreamControllerattach_eglstream_consumer"Create server stream and attach consumer using attributes\n\nCreates the corresponding server side EGLStream from the given wl_buffer\nand attaches a consumer to it using the given attributes."attach_eglstream_consumer_attribswl_eglstream_controllerwayland_eglstream_controller//! This crate provides bindings to the plasma wayland protocol extensions//! provided in <https://github.com/KDE/plasma-wayland-protocols>ZWLR_DATA_CONTROL_MANAGER_V1_INTERFACEzwlr_data_control_manager_v1_requests_create_data_source_typeszwlr_data_control_manager_v1_requests_get_data_device_typeszwlr_data_control_manager_v1_requestszwlr_data_control_manager_v1_interfaceZWLR_DATA_CONTROL_DEVICE_V1_INTERFACEzwlr_data_control_device_v1_requests_set_selection_typeszwlr_data_control_device_v1_requests_set_primary_selection_typeszwlr_data_control_device_v1_requestszwlr_data_control_device_v1_events_data_offer_typeszwlr_data_control_device_v1_events_selection_typeszwlr_data_control_device_v1_events_primary_selection_typeszwlr_data_control_device_v1_eventszwlr_data_control_device_v1_interfaceZWLR_DATA_CONTROL_SOURCE_V1_INTERFACEzwlr_data_control_source_v1_requestszwlr_data_control_source_v1_eventszwlr_data_control_source_v1_interfaceZWLR_DATA_CONTROL_OFFER_V1_INTERFACEzwlr_data_control_offer_v1_requestszwlr_data_control_offer_v1_eventszwlr_data_control_offer_v1_interface"copy data to the selection\n\nThis request asks the compositor to set the selection to the data from\nthe source on behalf of the client.\n\nThe given source may not be used in any further set_selection or\nset_primary_selection requests. Attempting to use a previously used\nsource is a protocol error.\n\nTo unset the selection, set the source to NULL.""copy data to the primary selection\n\nThis request asks the compositor to set the primary selection to the\ndata from the source on behalf of the client.\n\nThe given source may not be used in any further set_selection or\nset_primary_selection requests. Attempting to use a previously used\nsource is a protocol error.\n\nTo unset the primary selection, set the source to NULL.\n\nThe compositor will ignore this request if it does not support primary\nselection.\n\nOnly available since version 2 of the interface""introduce a new wlr_data_control_offer\n\nThe data_offer event introduces a new wlr_data_control_offer object,\nwhich will subsequently be used in either the\nwlr_data_control_device.selection event (for the regular clipboard\nselections) or the wlr_data_control_device.primary_selection event (for\nthe primary clipboard selections). Immediately following the\nwlr_data_control_device.data_offer event, the new data_offer object\nwill send out wlr_data_control_offer.offer events to describe the MIME\ntypes it offers.""advertise new selection\n\nThe selection event is sent out to notify the client of a new\nwlr_data_control_offer for the selection for this device. The\nwlr_data_control_device.data_offer and the wlr_data_control_offer.offer\nevents are sent out immediately before this event to introduce the data\noffer object. The selection event is sent to a client when a new\nselection is set. The wlr_data_control_offer is valid until a new\nwlr_data_control_offer or NULL is received. The client must destroy the\nprevious selection wlr_data_control_offer, if any, upon receiving this\nevent.\n\nThe first selection event is sent upon binding the\nwlr_data_control_device object.""advertise new primary selection\n\nThe primary_selection event is sent out to notify the client of a new\nwlr_data_control_offer for the primary selection for this device. The\nwlr_data_control_device.data_offer and the wlr_data_control_offer.offer\nevents are sent out immediately before this event to introduce the data\noffer object. The primary_selection event is sent to a client when a\nnew primary selection is set. The wlr_data_control_offer is valid until\na new wlr_data_control_offer or NULL is received. The client must\ndestroy the previous primary selection wlr_data_control_offer, if any,\nupon receiving this event.\n\nIf the compositor supports primary selection, the first\nprimary_selection event is sent upon binding the\nwlr_data_control_device object.\n\nOnly available since version 2 of the interface""copy data to the primary selection\n\nThis request asks the compositor to set the primary selection to the\ndata from the source on behalf of the client.\n\nThe given source may not be used in any further set_selection or\nset_primary_selection requests. Attempting to use a previously used\nsource is a protocol error.\n\nTo unset the primary selection, set the source to NULL.\n\nThe compositor will ignore this request if it does not support primary\nselection.""offer to transfer data\n\nThe wlr_data_control_source object is the source side of a\nwlr_data_control_offer. It is created by the source client in a data\ntransfer and provides a way to describe the offered data and a way to\nrespond to requests to transfer the data.""offer sent after wlr_data_control_device.set_selection""add an offered MIME type\n\nThis request adds a MIME type to the set of MIME types advertised to\ntargets. Can be called several times to offer multiple types.\n\nCalling this after wlr_data_control_device.set_selection is a protocol\nerror.""offer to transfer data\n\nThe wlr_data_control_source object is the source side of a\nwlr_data_control_offer. It is created by the source client in a data\ntransfer and provides a way to describe the offered data and a way to\nrespond to requests to transfer the data.\n\nSee also the [Event] enum for this interface.""offer to transfer data\n\nA wlr_data_control_offer represents a piece of data offered for transfer\nby another client (the source client). The offer describes the different\nMIME types that the data can be converted to and provides the mechanism\nfor transferring the data directly from the source client.""advertise offered MIME type\n\nSent immediately after creating the wlr_data_control_offer object.\nOne event per offered MIME type.""offer to transfer data\n\nA wlr_data_control_offer represents a piece of data offered for transfer\nby another client (the source client). The offer describes the different\nMIME types that the data can be converted to and provides the mechanism\nfor transferring the data directly from the source client.\n\nSee also the [Event] enum for this interface."//! Control data devices, particularly the clipboard.//! An interface to control data devices, particularly to manage the current selection and//! take the role of a clipboard manager.ZWLR_EXPORT_DMABUF_MANAGER_V1_INTERFACEzwlr_export_dmabuf_manager_v1_requests_capture_output_typeszwlr_export_dmabuf_manager_v1_requestszwlr_export_dmabuf_manager_v1_interfaceZWLR_EXPORT_DMABUF_FRAME_V1_INTERFACEzwlr_export_dmabuf_frame_v1_requestszwlr_export_dmabuf_frame_v1_eventszwlr_export_dmabuf_frame_v1_interface"manager to inform clients and begin capturing\n\nThis object is a manager with which to start capturing from sources."REQ_CAPTURE_OUTPUT_SINCEREQ_CAPTURE_OUTPUT_OPCODE"capture a frame from an output\n\nCapture the next frame of an entire output.""include custom client hardware cursor on top of the frame"overlay_cursorCaptureOutput"manager to inform clients and begin capturing\n\nThis object is a manager with which to start capturing from sources.\n\nThis interface has no events."ZwlrExportDmabufManagerV1zwlr_export_dmabuf_frame_v1ZwlrExportDmabufFrameV1capture_outputzwlr_export_dmabuf_manager_v1"a DMA-BUF frame\n\nThis object represents a single DMA-BUF frame.\n\nIf the capture is successful, the compositor will first send a \"frame\"\nevent, followed by one or several \"object\". When the frame is available\nfor readout, the \"ready\" event is sent.\n\nIf the capture failed, the \"cancel\" event is sent. This can happen anytime\nbefore the \"ready\" event.\n\nOnce either a \"ready\" or a \"cancel\" event is received, the client should\ndestroy the frame. Once an \"object\" event is received, the client is\nresponsible for closing the associated file descriptor.\n\nAll frames are read-only and may not be written into or altered.""frame flags\n\nSpecial flags that should be respected by the client.""clients should copy frame before processing""cancel reason\n\nIndicates reason for cancelling the frame."CancelReason"temporary error, source will produce more frames"Temporary"fatal error, source will not produce frames"PermanentEVT_OBJECT_SINCEEVT_OBJECT_OPCODE"delete this object, used or not\n\nUnreferences the frame. This request must be called as soon as its no\nlonger used.\n\nIt can be called at any time by the client. The client will still have\nto close any FDs it has been given.\n\nThis is a destructor, once sent this object cannot be used any longer.""a frame description\n\nMain event supplying the client with information about the frame. If the\ncapture didn't fail, this event is always emitted first before any other\nevents.\n\nThis event is followed by a number of \"object\" as specified by the\n\"num_objects\" argument.""frame width in pixels""frame height in pixels""crop offset for the x axis""crop offset for the y axis""flags which indicate properties (invert, interlacing), has the same values as zwp_linux_buffer_params_v1:flags"buffer_flags"indicates special frame features""format of the frame (DRM_FORMAT_*)""drm format modifier, high"mod_high"drm format modifier, low"mod_low"indicates how many objects (FDs) the frame has (max 4)"num_objects"an object description\n\nEvent which serves to supply the client with the file descriptors\ncontaining the data for each object.\n\nAfter receiving this event, the client must always close the file\ndescriptor as soon as they're done with it and even if the frame fails.""index of the current object""fd of the current object""size in bytes for the current object""starting point for the data in the object's fd""line size in bytes""index of the plane the data in the object applies to"plane_index"indicates frame is available for reading\n\nThis event is sent as soon as the frame is presented, indicating it is\navailable for reading. This event includes the time at which\npresentation happened at.\n\nThe timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,\neach component being an unsigned 32-bit value. Whole seconds are in\ntv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,\nand the additional fractional part in tv_nsec as nanoseconds. Hence,\nfor valid timestamps tv_nsec must be in [0, 999999999]. The seconds part\nmay have an arbitrary offset at start.\n\nAfter receiving this event, the client should destroy this object.""indicates the frame is no longer valid\n\nIf the capture failed or if the frame is no longer valid after the\n\"frame\" event has been emitted, this event will be used to inform the\nclient to scrap the frame.\n\nIf the failure is temporary, the client may capture again the same\nsource. If the failure is permanent, any further attempts to capture the\nsame source will fail again.\n\nAfter receiving this event, the client should destroy this object.""indicates a reason for cancelling this frame capture""a DMA-BUF frame\n\nThis object represents a single DMA-BUF frame.\n\nIf the capture is successful, the compositor will first send a \"frame\"\nevent, followed by one or several \"object\". When the frame is available\nfor readout, the \"ready\" event is sent.\n\nIf the capture failed, the \"cancel\" event is sent. This can happen anytime\nbefore the \"ready\" event.\n\nOnce either a \"ready\" or a \"cancel\" event is received, the client should\ndestroy the frame. Once an \"object\" event is received, the client is\nresponsible for closing the associated file descriptor.\n\nAll frames are read-only and may not be written into or altered.\n\nSee also the [Event] enum for this interface.""delete this object, used or not\n\nUnreferences the frame. This request must be called as soon as its no\nlonger used.\n\nIt can be called at any time by the client. The client will still have\nto close any FDs it has been given."//! A protocol for low overhead screen content capturing//! An interface to capture surfaces in an efficient way by exporting DMA-BUFs.export_dmabufZWLR_FOREIGN_TOPLEVEL_MANAGER_V1_INTERFACEzwlr_foreign_toplevel_manager_v1_requestszwlr_foreign_toplevel_manager_v1_events_toplevel_typeszwlr_foreign_toplevel_manager_v1_eventszwlr_foreign_toplevel_manager_v1_interfaceZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_INTERFACEzwlr_foreign_toplevel_handle_v1_requests_activate_typeszwlr_foreign_toplevel_handle_v1_requests_set_rectangle_typeszwlr_foreign_toplevel_handle_v1_requests_set_fullscreen_typeszwlr_foreign_toplevel_handle_v1_requestszwlr_foreign_toplevel_handle_v1_events_output_enter_typeszwlr_foreign_toplevel_handle_v1_events_output_leave_typeszwlr_foreign_toplevel_handle_v1_events_parent_typeszwlr_foreign_toplevel_handle_v1_eventszwlr_foreign_toplevel_handle_v1_interface"list and control opened apps\n\nThe purpose of this protocol is to enable the creation of taskbars\nand docks by providing them with a list of opened applications and\nletting them request certain actions on them, like maximizing, etc.\n\nAfter a client binds the zwlr_foreign_toplevel_manager_v1, each opened\ntoplevel window will be sent via the toplevel event""stop sending events\n\nIndicates the client no longer wishes to receive events for new toplevels.\nHowever the compositor may emit further toplevel_created events, until\nthe finished event is emitted.\n\nThe client must not send any more requests after this one.""a toplevel has been created\n\nThis event is emitted whenever a new toplevel window is created. It\nis emitted for all toplevels, regardless of the app that has created\nthem.\n\nAll initial details of the toplevel(title, app_id, states, etc.) will\nbe sent immediately after this event via the corresponding events in\nzwlr_foreign_toplevel_handle_v1."zwlr_foreign_toplevel_handle_v1ZwlrForeignToplevelHandleV1"the compositor has finished with the toplevel manager\n\nThis event indicates that the compositor is done sending events to the\nzwlr_foreign_toplevel_manager_v1. The server will destroy the object\nimmediately after sending this request, so it will become invalid and\nthe client should free any resources associated with it.\n\nThis is a destructor, once received this object cannot be used any longer.""list and control opened apps\n\nThe purpose of this protocol is to enable the creation of taskbars\nand docks by providing them with a list of opened applications and\nletting them request certain actions on them, like maximizing, etc.\n\nAfter a client binds the zwlr_foreign_toplevel_manager_v1, each opened\ntoplevel window will be sent via the toplevel event\n\nSee also the [Event] enum for this interface."ZwlrForeignToplevelManagerV1zwlr_foreign_toplevel_manager_v1"an opened toplevel\n\nA zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel\nwindow. Each app may have multiple opened toplevels.\n\nEach toplevel has a list of outputs it is visible on, conveyed to the\nclient with the output_enter and output_leave events.""types of states on the toplevel\n\nThe different states that a toplevel can have. These have the same meaning\nas the states with the same names defined in xdg-toplevel""the toplevel is maximized""the toplevel is minimized""the toplevel is active""the toplevel is fullscreen""the provided rectangle is invalid"InvalidRectangleREQ_UNSET_MINIMIZED_SINCEREQ_UNSET_MINIMIZED_OPCODEREQ_SET_RECTANGLE_SINCEREQ_SET_RECTANGLE_OPCODEEVT_PARENT_SINCEEVT_PARENT_OPCODE"requests that the toplevel be maximized\n\nRequests that the toplevel be maximized. If the maximized state actually\nchanges, this will be indicated by the state event.""requests that the toplevel be unmaximized\n\nRequests that the toplevel be unmaximized. If the maximized state actually\nchanges, this will be indicated by the state event.""requests that the toplevel be minimized\n\nRequests that the toplevel be minimized. If the minimized state actually\nchanges, this will be indicated by the state event.""requests that the toplevel be unminimized\n\nRequests that the toplevel be unminimized. If the minimized state actually\nchanges, this will be indicated by the state event."UnsetMinimized"activate the toplevel\n\nRequest that this toplevel be activated on the given seat.\nThere is no guarantee the toplevel will be actually activated.""request that the toplevel be closed\n\nSend a request to the toplevel to close itself. The compositor would\ntypically use a shell-specific method to carry out this request, for\nexample by sending the xdg_toplevel.close event. However, this gives\nno guarantees the toplevel will actually be destroyed. If and when\nthis happens, the zwlr_foreign_toplevel_handle_v1.closed event will\nbe emitted.""the rectangle which represents the toplevel\n\nThe rectangle of the surface specified in this request corresponds to\nthe place where the app using this protocol represents the given toplevel.\nIt can be used by the compositor as a hint for some operations, e.g\nminimizing. The client is however not required to set this, in which\ncase the compositor is free to decide some default value.\n\nIf the client specifies more than one rectangle, only the last one is\nconsidered.\n\nThe dimensions are given in surface-local coordinates.\nSetting width=height=0 removes the already-set rectangle."SetRectangle"destroy the zwlr_foreign_toplevel_handle_v1 object\n\nDestroys the zwlr_foreign_toplevel_handle_v1 object.\n\nThis request should be called either when the client does not want to\nuse the toplevel anymore or after the closed event to finalize the\ndestruction of the object.\n\nThis is a destructor, once sent this object cannot be used any longer.""request that the toplevel be fullscreened\n\nRequests that the toplevel be fullscreened on the given output. If the\nfullscreen state and/or the outputs the toplevel is visible on actually\nchange, this will be indicated by the state and output_enter/leave\nevents.\n\nThe output parameter is only a hint to the compositor. Also, if output\nis NULL, the compositor should decide which output the toplevel will be\nfullscreened on, if at all.\n\nOnly available since version 2 of the interface""request that the toplevel be unfullscreened\n\nRequests that the toplevel be unfullscreened. If the fullscreen state\nactually changes, this will be indicated by the state event.\n\nOnly available since version 2 of the interface""title change\n\nThis event is emitted whenever the title of the toplevel changes.""app-id change\n\nThis event is emitted whenever the app-id of the toplevel changes.""toplevel entered an output\n\nThis event is emitted whenever the toplevel becomes visible on\nthe given output. A toplevel may be visible on multiple outputs.""toplevel left an output\n\nThis event is emitted whenever the toplevel stops being visible on\nthe given output. It is guaranteed that an entered-output event\nwith the same output has been emitted before this event.""the toplevel state changed\n\nThis event is emitted immediately after the zlw_foreign_toplevel_handle_v1\nis created and each time the toplevel state changes, either because of a\ncompositor action or because of a request in this protocol.""all information about the toplevel has been sent\n\nThis event is sent after all changes in the toplevel state have been\nsent.\n\nThis allows changes to the zwlr_foreign_toplevel_handle_v1 properties\nto be seen as atomic, even if they happen via multiple events.""this toplevel has been destroyed\n\nThis event means the toplevel has been destroyed. It is guaranteed there\nwon't be any more events for this zwlr_foreign_toplevel_handle_v1. The\ntoplevel itself becomes inert so any requests will be ignored except the\ndestroy request.""parent change\n\nThis event is emitted whenever the parent of the toplevel changes.\n\nNo event is emitted when the parent handle is destroyed by the client.\n\nOnly available since version 3 of the interface""an opened toplevel\n\nA zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel\nwindow. Each app may have multiple opened toplevels.\n\nEach toplevel has a list of outputs it is visible on, conveyed to the\nclient with the output_enter and output_leave events.\n\nSee also the [Event] enum for this interface."unset_minimizedset_rectangle"destroy the zwlr_foreign_toplevel_handle_v1 object\n\nDestroys the zwlr_foreign_toplevel_handle_v1 object.\n\nThis request should be called either when the client does not want to\nuse the toplevel anymore or after the closed event to finalize the\ndestruction of the object.""request that the toplevel be fullscreened\n\nRequests that the toplevel be fullscreened on the given output. If the\nfullscreen state and/or the outputs the toplevel is visible on actually\nchange, this will be indicated by the state and output_enter/leave\nevents.\n\nThe output parameter is only a hint to the compositor. Also, if output\nis NULL, the compositor should decide which output the toplevel will be\nfullscreened on, if at all.""request that the toplevel be unfullscreened\n\nRequests that the toplevel be unfullscreened. If the fullscreen state\nactually changes, this will be indicated by the state event."//! List and control opened apps//! Use for creating taskbars and docks.foreign_toplevelZWLR_GAMMA_CONTROL_MANAGER_V1_INTERFACEzwlr_gamma_control_manager_v1_requests_get_gamma_control_typeszwlr_gamma_control_manager_v1_requestszwlr_gamma_control_manager_v1_interfaceZWLR_GAMMA_CONTROL_V1_INTERFACEzwlr_gamma_control_v1_requestszwlr_gamma_control_v1_eventszwlr_gamma_control_v1_interface"manager to create per-output gamma controls\n\nThis interface is a manager that allows creating per-output gamma\ncontrols."REQ_GET_GAMMA_CONTROL_SINCEREQ_GET_GAMMA_CONTROL_OPCODE"get a gamma control for an output\n\nCreate a gamma control that can be used to adjust gamma tables for the\nprovided output."GetGammaControl"manager to create per-output gamma controls\n\nThis interface is a manager that allows creating per-output gamma\ncontrols.\n\nThis interface has no events."ZwlrGammaControlManagerV1zwlr_gamma_control_v1ZwlrGammaControlV1get_gamma_controlzwlr_gamma_control_manager_v1"adjust gamma tables for an output\n\nThis interface allows a client to adjust gamma tables for a particular\noutput.\n\nThe client will receive the gamma size, and will then be able to set gamma\ntables. At any time the compositor can send a failed event indicating that\nthis object is no longer valid.\n\nThere can only be at most one gamma control object per output, which\nhas exclusive access to this particular output. When the gamma control\nobject is destroyed, the gamma table is restored to its original value.""invalid gamma tables"InvalidGammaREQ_SET_GAMMA_SINCEREQ_SET_GAMMA_OPCODEEVT_GAMMA_SIZE_SINCEEVT_GAMMA_SIZE_OPCODE"set the gamma table\n\nSet the gamma table. The file descriptor can be memory-mapped to provide\nthe raw gamma table, which contains successive gamma ramps for the red,\ngreen and blue channels. Each gamma ramp is an array of 16-byte unsigned\nintegers which has the same length as the gamma size.\n\nThe file descriptor data must have the same length as three times the\ngamma size.""gamma table file descriptor"SetGamma"destroy this control\n\nDestroys the gamma control object. If the object is still valid, this\nrestores the original gamma tables.\n\nThis is a destructor, once sent this object cannot be used any longer.""size of gamma ramps\n\nAdvertise the size of each gamma ramp.\n\nThis event is sent immediately when the gamma control object is created.""number of elements in a ramp"GammaSize"object no longer valid\n\nThis event indicates that the gamma control is no longer valid. This\ncan happen for a number of reasons, including:\n- The output doesn't support gamma tables\n- Setting the gamma tables failed\n- Another client already has exclusive gamma control for this output\n- The compositor has transferred gamma control to another client\n\nUpon receiving this event, the client should destroy this object.""adjust gamma tables for an output\n\nThis interface allows a client to adjust gamma tables for a particular\noutput.\n\nThe client will receive the gamma size, and will then be able to set gamma\ntables. At any time the compositor can send a failed event indicating that\nthis object is no longer valid.\n\nThere can only be at most one gamma control object per output, which\nhas exclusive access to this particular output. When the gamma control\nobject is destroyed, the gamma table is restored to its original value.\n\nSee also the [Event] enum for this interface.""destroy this control\n\nDestroys the gamma control object. If the object is still valid, this\nrestores the original gamma tables."//! Manage gamma tables of outputs.//! This protocol allows a privileged client to set the gamma tables for outputs.gamma_controlZWLR_INPUT_INHIBIT_MANAGER_V1_INTERFACEzwlr_input_inhibit_manager_v1_requests_get_inhibitor_typeszwlr_input_inhibit_manager_v1_requestszwlr_input_inhibit_manager_v1_interfaceZWLR_INPUT_INHIBITOR_V1_INTERFACEzwlr_input_inhibitor_v1_requestszwlr_input_inhibitor_v1_interface"inhibits input events to other clients\n\nClients can use this interface to prevent input events from being sent to\nany surfaces but its own, which is useful for example in lock screen\nsoftware. It is assumed that access to this interface will be locked down\nto whitelisted clients by the compositor.\n\nNote! This protocol is deprecated and not intended for production use.\nFor screen lockers, use the ext-session-lock-v1 protocol.""an input inhibitor is already in use on the compositor"REQ_GET_INHIBITOR_SINCEREQ_GET_INHIBITOR_OPCODE"inhibit input to other clients\n\nActivates the input inhibitor. As long as the inhibitor is active, the\ncompositor will not send input events to other clients."GetInhibitor"inhibits input events to other clients\n\nClients can use this interface to prevent input events from being sent to\nany surfaces but its own, which is useful for example in lock screen\nsoftware. It is assumed that access to this interface will be locked down\nto whitelisted clients by the compositor.\n\nNote! This protocol is deprecated and not intended for production use.\nFor screen lockers, use the ext-session-lock-v1 protocol.\n\nThis interface has no events."ZwlrInputInhibitManagerV1zwlr_input_inhibitor_v1ZwlrInputInhibitorV1get_inhibitorzwlr_input_inhibit_manager_v1"inhibits input to other clients\n\nWhile this resource exists, input to clients other than the owner of the\ninhibitor resource will not receive input events. Any client which\npreviously had focus will receive a leave event and will not be given\nfocus again. The client that owns this resource will receive all input\nevents normally. The compositor will also disable all of its own input\nprocessing (such as keyboard shortcuts) while the inhibitor is active.\n\nThe compositor may continue to send input events to selected clients,\nsuch as an on-screen keyboard (via the input-method protocol).""destroy the input inhibitor object\n\nDestroy the inhibitor and allow other clients to receive input.\n\nThis is a destructor, once sent this object cannot be used any longer.""inhibits input to other clients\n\nWhile this resource exists, input to clients other than the owner of the\ninhibitor resource will not receive input events. Any client which\npreviously had focus will receive a leave event and will not be given\nfocus again. The client that owns this resource will receive all input\nevents normally. The compositor will also disable all of its own input\nprocessing (such as keyboard shortcuts) while the inhibitor is active.\n\nThe compositor may continue to send input events to selected clients,\nsuch as an on-screen keyboard (via the input-method protocol).\n\nThis interface has no events.""destroy the input inhibitor object\n\nDestroy the inhibitor and allow other clients to receive input."//! Inhibits input events to other clientsinput_inhibitorZWLR_LAYER_SHELL_V1_INTERFACEzwlr_layer_shell_v1_requests_get_layer_surface_typeszwlr_layer_shell_v1_requestszwlr_layer_shell_v1_interfaceZWLR_LAYER_SURFACE_V1_INTERFACEzwlr_layer_surface_v1_requests_get_popup_typeszwlr_layer_surface_v1_requestszwlr_layer_surface_v1_eventszwlr_layer_surface_v1_interface"create surfaces that are layers of the desktop\n\nClients can use this interface to assign the surface_layer role to\nwl_surfaces. Such surfaces are assigned to a \"layer\" of the output and\nrendered with a defined z-depth respective to each other. They may also be\nanchored to the edges and corners of a screen and specify input handling\nsemantics. This interface should be suitable for the implementation of\nmany desktop shell components, and a broad number of other applications\nthat interact with the desktop.""wl_surface has another role""layer value is invalid"InvalidLayer"wl_surface has a buffer attached or committed""available layers for surfaces\n\nThese values indicate which layers a surface can be rendered in. They\nare ordered by z depth, bottom-most first. Traditional shell surfaces\nwill typically be rendered between the bottom and top layers.\nFullscreen shell surfaces are typically rendered at the top layer.\nMultiple surfaces can share a single layer, and ordering within a\nsingle layer is undefined."REQ_GET_LAYER_SURFACE_SINCEREQ_GET_LAYER_SURFACE_OPCODE"create a layer_surface from a surface\n\nCreate a layer surface for an existing surface. This assigns the role of\nlayer_surface, or raises a protocol error if another role is already\nassigned.\n\nCreating a layer surface from a wl_surface which has a buffer attached\nor committed is a client error, and any attempts by a client to attach\nor manipulate a buffer prior to the first layer_surface.configure call\nmust also be treated as errors.\n\nAfter creating a layer_surface object and setting it up, the client\nmust perform an initial commit without any buffer attached.\nThe compositor will reply with a layer_surface.configure event.\nThe client must acknowledge it and is then allowed to attach a buffer\nto map the surface.\n\nYou may pass NULL for output to allow the compositor to decide which\noutput to use. Generally this will be the one that the user most\nrecently interacted with.\n\nClients can specify a namespace that defines the purpose of the layer\nsurface.""layer to add this surface to""namespace for the layer surface"GetLayerSurface"destroy the layer_shell object\n\nThis request indicates that the client will not use the layer_shell\nobject any more. Objects that have been created through this instance\nare not affected.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""create surfaces that are layers of the desktop\n\nClients can use this interface to assign the surface_layer role to\nwl_surfaces. Such surfaces are assigned to a \"layer\" of the output and\nrendered with a defined z-depth respective to each other. They may also be\nanchored to the edges and corners of a screen and specify input handling\nsemantics. This interface should be suitable for the implementation of\nmany desktop shell components, and a broad number of other applications\nthat interact with the desktop.\n\nThis interface has no events."get_layer_surface"destroy the layer_shell object\n\nThis request indicates that the client will not use the layer_shell\nobject any more. Objects that have been created through this instance\nare not affected.""layer metadata interface\n\nAn interface that may be implemented by a wl_surface, for surfaces that\nare designed to be rendered as a layer of a stacked desktop-like\nenvironment.\n\nLayer surface state (layer, size, anchor, exclusive zone,\nmargin, interactivity) is double-buffered, and will be applied at the\ntime wl_surface.commit of the corresponding wl_surface is called.\n\nAttaching a null buffer to a layer surface unmaps it.\n\nUnmapping a layer_surface means that the surface cannot be shown by the\ncompositor until it is explicitly mapped again. The layer_surface\nreturns to the state it had right after layer_shell.get_layer_surface.\nThe client can re-map the surface by performing a commit without any\nbuffer attached, waiting for a configure event and handling it as usual.""types of keyboard interaction possible for a layer shell surface\n\nTypes of keyboard interaction possible for layer shell surfaces. The\nrationale for this is twofold: (1) some applications are not interested\nin keyboard events and not allowing them to be focused can improve the\ndesktop experience; (2) some applications will want to take exclusive\nkeyboard focus.""no keyboard focus is possible\n\nThis value indicates that this surface is not interested in keyboard\nevents and the compositor should never assign it the keyboard focus.\n\nThis is the default value, set for newly created layer shell surfaces.\n\nThis is useful for e.g. desktop widgets that display information or\nonly have interaction with non-keyboard input devices.""request exclusive keyboard focus\n\nRequest exclusive keyboard focus if this surface is above the shell surface layer.\n\nFor the top and overlay layers, the seat will always give\nexclusive keyboard focus to the top-most layer which has keyboard\ninteractivity set to exclusive. If this layer contains multiple\nsurfaces with keyboard interactivity set to exclusive, the compositor\ndetermines the one receiving keyboard events in an implementation-\ndefined manner. In this case, no guarantee is made when this surface\nwill receive keyboard focus (if ever).\n\nFor the bottom and background layers, the compositor is allowed to use\nnormal focus semantics.\n\nThis setting is mainly intended for applications that need to ensure\nthey receive all keyboard events, such as a lock screen or a password\nprompt.""request regular keyboard focus semantics\n\nThis requests the compositor to allow this surface to be focused and\nunfocused by the user in an implementation-defined manner. The user\nshould be able to unfocus this surface even regardless of the layer\nit is on.\n\nTypically, the compositor will want to use its normal mechanism to\nmanage keyboard focus between layer shell surfaces with this setting\nand regular toplevels on the desktop layer (e.g. click to focus).\nNevertheless, it is possible for a compositor to require a special\ninteraction to focus or unfocus layer shell surfaces (e.g. requiring\na click even if focus follows the mouse normally, or providing a\nkeybinding to switch focus between layers).\n\nThis setting is mainly intended for desktop shell components (e.g.\npanels) that allow keyboard interaction. Using this option can allow\nimplementing a desktop shell that can be fully usable without the\nmouse.""provided surface state is invalid""size is invalid""anchor bitfield is invalid"InvalidAnchor"keyboard interactivity is invalid"InvalidKeyboardInteractivity"the top edge of the anchor rectangle""the bottom edge of the anchor rectangle""the left edge of the anchor rectangle""the right edge of the anchor rectangle"REQ_SET_EXCLUSIVE_ZONE_SINCEREQ_SET_EXCLUSIVE_ZONE_OPCODEREQ_SET_MARGIN_SINCEREQ_SET_MARGIN_OPCODEREQ_SET_KEYBOARD_INTERACTIVITY_SINCEREQ_SET_KEYBOARD_INTERACTIVITY_OPCODEREQ_SET_LAYER_SINCEREQ_SET_LAYER_OPCODE"sets the size of the surface\n\nSets the size of the surface in surface-local coordinates. The\ncompositor will display the surface centered with respect to its\nanchors.\n\nIf you pass 0 for either value, the compositor will assign it and\ninform you of the assignment in the configure event. You must set your\nanchor to opposite edges in the dimensions you omit; not doing so is a\nprotocol error. Both values are 0 by default.\n\nSize is double-buffered, see wl_surface.commit.""configures the anchor point of the surface\n\nRequests that the compositor anchor the surface to the specified edges\nand corners. If two orthogonal edges are specified (e.g. 'top' and\n'left'), then the anchor point will be the intersection of the edges\n(e.g. the top left corner of the output); otherwise the anchor point\nwill be centered on that edge, or in the center if none is specified.\n\nAnchor is double-buffered, see wl_surface.commit.""configures the exclusive geometry of this surface\n\nRequests that the compositor avoids occluding an area with other\nsurfaces. The compositor's use of this information is\nimplementation-dependent - do not assume that this region will not\nactually be occluded.\n\nA positive value is only meaningful if the surface is anchored to one\nedge or an edge and both perpendicular edges. If the surface is not\nanchored, anchored to only two perpendicular edges (a corner), anchored\nto only two parallel edges or anchored to all edges, a positive value\nwill be treated the same as zero.\n\nA positive zone is the distance from the edge in surface-local\ncoordinates to consider exclusive.\n\nSurfaces that do not wish to have an exclusive zone may instead specify\nhow they should interact with surfaces that do. If set to zero, the\nsurface indicates that it would like to be moved to avoid occluding\nsurfaces with a positive exclusive zone. If set to -1, the surface\nindicates that it would not like to be moved to accommodate for other\nsurfaces, and the compositor should extend it all the way to the edges\nit is anchored to.\n\nFor example, a panel might set its exclusive zone to 10, so that\nmaximized shell surfaces are not shown on top of it. A notification\nmight set its exclusive zone to 0, so that it is moved to avoid\noccluding the panel, but shell surfaces are shown underneath it. A\nwallpaper or lock screen might set their exclusive zone to -1, so that\nthey stretch below or over the panel.\n\nThe default value is 0.\n\nExclusive zone is double-buffered, see wl_surface.commit."SetExclusiveZone"sets a margin from the anchor point\n\nRequests that the surface be placed some distance away from the anchor\npoint on the output, in surface-local coordinates. Setting this value\nfor edges you are not anchored to has no effect.\n\nThe exclusive zone includes the margin.\n\nMargin is double-buffered, see wl_surface.commit."SetMargin"requests keyboard events\n\nSet how keyboard events are delivered to this surface. By default,\nlayer shell surfaces do not receive keyboard events; this request can\nbe used to change this.\n\nThis setting is inherited by child surfaces set by the get_popup\nrequest.\n\nLayer surfaces receive pointer, touch, and tablet events normally. If\nyou do not want to receive them, set the input region on your surface\nto an empty region.\n\nKeyboard interactivity is double-buffered, see wl_surface.commit."keyboard_interactivitySetKeyboardInteractivity"assign this layer_surface as an xdg_popup parent\n\nThis assigns an xdg_popup's parent to this layer_surface.  This popup\nshould have been created via xdg_surface::get_popup with the parent set\nto NULL, and this request must be invoked before committing the popup's\ninitial state.\n\nSee the documentation of xdg_popup for more details about what an\nxdg_popup is and how it is used.""ack a configure event\n\nWhen a configure event is received, if a client commits the\nsurface in response to the configure event, then the client\nmust make an ack_configure request sometime before the commit\nrequest, passing along the serial of the configure event.\n\nIf the client receives multiple configure events before it\ncan respond to one, it only has to ack the last configure event.\n\nA client is not required to commit immediately after sending\nan ack_configure request - it may even ack_configure several times\nbefore its next surface commit.\n\nA client may send multiple ack_configure requests before committing, but\nonly the last request sent before a commit indicates which configure\nevent the client really is responding to.""destroy the layer_surface\n\nThis request destroys the layer surface.\n\nThis is a destructor, once sent this object cannot be used any longer.""change the layer of the surface\n\nChange the layer that the surface is rendered on.\n\nLayer is double-buffered, see wl_surface.commit.\n\nOnly available since version 2 of the interface""layer to move this surface to"SetLayer"suggest a surface change\n\nThe configure event asks the client to resize its surface.\n\nClients should arrange their surface for the new states, and then send\nan ack_configure request with the serial sent in this configure event at\nsome point before committing the new surface.\n\nThe client is free to dismiss all but the last configure event it\nreceived.\n\nThe width and height arguments specify the size of the window in\nsurface-local coordinates.\n\nThe size is a hint, in the sense that the client is free to ignore it if\nit doesn't resize, pick a smaller size (to satisfy aspect ratio or\nresize in steps of NxM pixels). If the client picks a smaller size and\nis anchored to two opposite anchors (e.g. 'top' and 'bottom'), the\nsurface will be centered on this axis.\n\nIf the width or height arguments are zero, it means the client should\ndecide its own window dimension.""surface should be closed\n\nThe closed event is sent by the compositor when the surface will no\nlonger be shown. The output may have been destroyed or the user may\nhave asked for it to be removed. Further changes to the surface will be\nignored. The client should destroy the resource after receiving this\nevent, and create a new surface if they so choose.""layer metadata interface\n\nAn interface that may be implemented by a wl_surface, for surfaces that\nare designed to be rendered as a layer of a stacked desktop-like\nenvironment.\n\nLayer surface state (layer, size, anchor, exclusive zone,\nmargin, interactivity) is double-buffered, and will be applied at the\ntime wl_surface.commit of the corresponding wl_surface is called.\n\nAttaching a null buffer to a layer surface unmaps it.\n\nUnmapping a layer_surface means that the surface cannot be shown by the\ncompositor until it is explicitly mapped again. The layer_surface\nreturns to the state it had right after layer_shell.get_layer_surface.\nThe client can re-map the surface by performing a commit without any\nbuffer attached, waiting for a configure event and handling it as usual.\n\nSee also the [Event] enum for this interface.""destroy the layer_surface\n\nThis request destroys the layer surface.""change the layer of the surface\n\nChange the layer that the surface is rendered on.\n\nLayer is double-buffered, see wl_surface.commit."//! Layered shell protocolZWLR_OUTPUT_MANAGER_V1_INTERFACEzwlr_output_manager_v1_requests_create_configuration_typeszwlr_output_manager_v1_requestszwlr_output_manager_v1_events_head_typeszwlr_output_manager_v1_eventszwlr_output_manager_v1_interfaceZWLR_OUTPUT_HEAD_V1_INTERFACEzwlr_output_head_v1_requestszwlr_output_head_v1_events_mode_typeszwlr_output_head_v1_events_current_mode_typeszwlr_output_head_v1_eventszwlr_output_head_v1_interfaceZWLR_OUTPUT_MODE_V1_INTERFACEzwlr_output_mode_v1_requestszwlr_output_mode_v1_eventszwlr_output_mode_v1_interfaceZWLR_OUTPUT_CONFIGURATION_V1_INTERFACEzwlr_output_configuration_v1_requests_enable_head_typeszwlr_output_configuration_v1_requests_disable_head_typeszwlr_output_configuration_v1_requestszwlr_output_configuration_v1_eventszwlr_output_configuration_v1_interfaceZWLR_OUTPUT_CONFIGURATION_HEAD_V1_INTERFACEzwlr_output_configuration_head_v1_requests_set_mode_typeszwlr_output_configuration_head_v1_requestszwlr_output_configuration_head_v1_interface"output device configuration manager\n\nThis interface is a manager that allows reading and writing the current\noutput device configuration.\n\nOutput devices that display pixels (e.g. a physical monitor or a virtual\noutput in a window) are represented as heads. Heads cannot be created nor\ndestroyed by the client, but they can be enabled or disabled and their\nproperties can be changed. Each head may have one or more available modes.\n\nWhenever a head appears (e.g. a monitor is plugged in), it will be\nadvertised via the head event. Immediately after the output manager is\nbound, all current heads are advertised.\n\nWhenever a head's properties change, the relevant wlr_output_head events\nwill be sent. Not all head properties will be sent: only properties that\nhave changed need to.\n\nWhenever a head disappears (e.g. a monitor is unplugged), a\nwlr_output_head.finished event will be sent.\n\nAfter one or more heads appear, change or disappear, the done event will\nbe sent. It carries a serial which can be used in a create_configuration\nrequest to update heads properties.\n\nThe information obtained from this protocol should only be used for output\nconfiguration purposes. This protocol is not designed to be a generic\noutput property advertisement protocol for regular clients. Instead,\nprotocols such as xdg-output should be used."EVT_HEAD_SINCEEVT_HEAD_OPCODE"create a new output configuration object\n\nCreate a new output configuration object. This allows to update head\nproperties.""stop sending events\n\nIndicates the client no longer wishes to receive events for output\nconfiguration changes. However the compositor may emit further events,\nuntil the finished event is emitted.\n\nThe client must not send any more requests after this one.""introduce a new head\n\nThis event introduces a new head. This happens whenever a new head\nappears (e.g. a monitor is plugged in) or after the output manager is\nbound."zwlr_output_head_v1ZwlrOutputHeadV1"sent all information about current configuration\n\nThis event is sent after all information has been sent after binding to\nthe output manager object and after any subsequent changes. This applies\nto child head and mode objects as well. In other words, this event is\nsent whenever a head or mode is created or destroyed and whenever one of\ntheir properties has been changed. Not all state is re-sent each time\nthe current configuration changes: only the actual changes are sent.\n\nThis allows changes to the output configuration to be seen as atomic,\neven if they happen via multiple events.\n\nA serial is sent to be used in a future create_configuration request.""current configuration serial""the compositor has finished with the manager\n\nThis event indicates that the compositor is done sending manager events.\nThe compositor will destroy the object immediately after sending this\nevent, so it will become invalid and the client should release any\nresources associated with it.\n\nThis is a destructor, once received this object cannot be used any longer.""output device configuration manager\n\nThis interface is a manager that allows reading and writing the current\noutput device configuration.\n\nOutput devices that display pixels (e.g. a physical monitor or a virtual\noutput in a window) are represented as heads. Heads cannot be created nor\ndestroyed by the client, but they can be enabled or disabled and their\nproperties can be changed. Each head may have one or more available modes.\n\nWhenever a head appears (e.g. a monitor is plugged in), it will be\nadvertised via the head event. Immediately after the output manager is\nbound, all current heads are advertised.\n\nWhenever a head's properties change, the relevant wlr_output_head events\nwill be sent. Not all head properties will be sent: only properties that\nhave changed need to.\n\nWhenever a head disappears (e.g. a monitor is unplugged), a\nwlr_output_head.finished event will be sent.\n\nAfter one or more heads appear, change or disappear, the done event will\nbe sent. It carries a serial which can be used in a create_configuration\nrequest to update heads properties.\n\nThe information obtained from this protocol should only be used for output\nconfiguration purposes. This protocol is not designed to be a generic\noutput property advertisement protocol for regular clients. Instead,\nprotocols such as xdg-output should be used.\n\nSee also the [Event] enum for this interface."ZwlrOutputManagerV1zwlr_output_configuration_v1ZwlrOutputConfigurationV1zwlr_output_manager_v1"output device\n\nA head is an output device. The difference between a wl_output object and\na head is that heads are advertised even if they are turned off. A head\nobject only advertises properties and cannot be used directly to change\nthem.\n\nA head has some read-only properties: modes, name, description and\nphysical_size. These cannot be changed by clients.\n\nOther properties can be updated via a wlr_output_configuration object.\n\nProperties sent via this interface are applied atomically via the\nwlr_output_manager.done event. No guarantees are made regarding the order\nin which properties are sent."AdaptiveSyncState"adaptive sync is disabled""adaptive sync is enabled"EVT_PHYSICAL_SIZE_SINCEEVT_PHYSICAL_SIZE_OPCODEEVT_MAKE_SINCEEVT_MAKE_OPCODEEVT_MODEL_SINCEEVT_MODEL_OPCODEEVT_ADAPTIVE_SYNC_SINCEEVT_ADAPTIVE_SYNC_OPCODE"destroy the head object\n\nThis request indicates that the client will no longer use this head\nobject.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""head name\n\nThis event describes the head name.\n\nThe naming convention is compositor defined, but limited to alphanumeric\ncharacters and dashes (-). Each name is unique among all wlr_output_head\nobjects, but if a wlr_output_head object is destroyed the same name may\nbe reused later. The names will also remain consistent across sessions\nwith the same hardware and software configuration.\n\nExamples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do\nnot assume that the name is a reflection of an underlying DRM\nconnector, X11 connection, etc.\n\nIf the compositor implements the xdg-output protocol and this head is\nenabled, the xdg_output.name event must report the same name.\n\nThe name event is sent after a wlr_output_head object is created. This\nevent is only sent once per object, and the name does not change over\nthe lifetime of the wlr_output_head object.""head description\n\nThis event describes a human-readable description of the head.\n\nThe description is a UTF-8 string with no convention defined for its\ncontents. Examples might include 'Foocorp 11\" Display' or 'Virtual X11\noutput via :1'. However, do not assume that the name is a reflection of\nthe make, model, serial of the underlying DRM connector or the display\nname of the underlying X11 connection, etc.\n\nIf the compositor implements xdg-output and this head is enabled,\nthe xdg_output.description must report the same description.\n\nThe description event is sent after a wlr_output_head object is created.\nThis event is only sent once per object, and the description does not\nchange over the lifetime of the wlr_output_head object.""head physical size\n\nThis event describes the physical size of the head. This event is only\nsent if the head has a physical size (e.g. is not a projector or a\nvirtual device).""introduce a mode\n\nThis event introduces a mode for this head. It is sent once per\nsupported mode."zwlr_output_mode_v1ZwlrOutputModeV1"head is enabled or disabled\n\nThis event describes whether the head is enabled. A disabled head is not\nmapped to a region of the global compositor space.\n\nWhen a head is disabled, some properties (current_mode, position,\ntransform and scale) are irrelevant.""zero if disabled, non-zero if enabled""current position\n\nThis events describes the position of the head in the global compositor\nspace. It is only sent if the output is enabled.""current transformation\n\nThis event describes the transformation currently applied to the head.\nIt is only sent if the output is enabled.""current scale\n\nThis events describes the scale of the head in the global compositor\nspace. It is only sent if the output is enabled.""the head has disappeared\n\nThis event indicates that the head is no longer available. The head\nobject becomes inert. Clients should send a destroy request and release\nany resources associated with it.""head manufacturer\n\nThis event describes the manufacturer of the head.\n\nThis must report the same make as the wl_output interface does in its\ngeometry event.\n\nTogether with the model and serial_number events the purpose is to\nallow clients to recognize heads from previous sessions and for example\nload head-specific configurations back.\n\nIt is not guaranteed this event will be ever sent. A reason for that\ncan be that the compositor does not have information about the make of\nthe head or the definition of a make is not sensible in the current\nsetup, for example in a virtual session. Clients can still try to\nidentify the head by available information from other events but should\nbe aware that there is an increased risk of false positives.\n\nIt is not recommended to display the make string in UI to users. For\nthat the string provided by the description event should be preferred.\n\nOnly available since version 2 of the interface""head model\n\nThis event describes the model of the head.\n\nThis must report the same model as the wl_output interface does in its\ngeometry event.\n\nTogether with the make and serial_number events the purpose is to\nallow clients to recognize heads from previous sessions and for example\nload head-specific configurations back.\n\nIt is not guaranteed this event will be ever sent. A reason for that\ncan be that the compositor does not have information about the model of\nthe head or the definition of a model is not sensible in the current\nsetup, for example in a virtual session. Clients can still try to\nidentify the head by available information from other events but should\nbe aware that there is an increased risk of false positives.\n\nIt is not recommended to display the model string in UI to users. For\nthat the string provided by the description event should be preferred.\n\nOnly available since version 2 of the interface""head serial number\n\nThis event describes the serial number of the head.\n\nTogether with the make and model events the purpose is to allow clients\nto recognize heads from previous sessions and for example load head-\nspecific configurations back.\n\nIt is not guaranteed this event will be ever sent. A reason for that\ncan be that the compositor does not have information about the serial\nnumber of the head or the definition of a serial number is not sensible\nin the current setup. Clients can still try to identify the head by\navailable information from other events but should be aware that there\nis an increased risk of false positives.\n\nIt is not recommended to display the serial_number string in UI to\nusers. For that the string provided by the description event should be\npreferred.\n\nOnly available since version 2 of the interface""current adaptive sync state\n\nThis event describes whether adaptive sync is currently enabled for\nthe head or not. Adaptive sync is also known as Variable Refresh\nRate or VRR.\n\nOnly available since version 4 of the interface"AdaptiveSync"output device\n\nA head is an output device. The difference between a wl_output object and\na head is that heads are advertised even if they are turned off. A head\nobject only advertises properties and cannot be used directly to change\nthem.\n\nA head has some read-only properties: modes, name, description and\nphysical_size. These cannot be changed by clients.\n\nOther properties can be updated via a wlr_output_configuration object.\n\nProperties sent via this interface are applied atomically via the\nwlr_output_manager.done event. No guarantees are made regarding the order\nin which properties are sent.\n\nSee also the [Event] enum for this interface.""destroy the head object\n\nThis request indicates that the client will no longer use this head\nobject.""output mode\n\nThis object describes an output mode.\n\nSome heads don't support output modes, in which case modes won't be\nadvertised.\n\nProperties sent via this interface are applied atomically via the\nwlr_output_manager.done event. No guarantees are made regarding the order\nin which properties are sent.""destroy the mode object\n\nThis request indicates that the client will no longer use this mode\nobject.\n\nThis is a destructor, once sent this object cannot be used any longer.\nOnly available since version 3 of the interface""the mode has disappeared\n\nThis event indicates that the mode is no longer available. The mode\nobject becomes inert. Clients should send a destroy request and release\nany resources associated with it.""output mode\n\nThis object describes an output mode.\n\nSome heads don't support output modes, in which case modes won't be\nadvertised.\n\nProperties sent via this interface are applied atomically via the\nwlr_output_manager.done event. No guarantees are made regarding the order\nin which properties are sent.\n\nSee also the [Event] enum for this interface.""destroy the mode object\n\nThis request indicates that the client will no longer use this mode\nobject.""output configuration\n\nThis object is used by the client to describe a full output configuration.\n\nFirst, the client needs to setup the output configuration. Each head can\nbe either enabled (and configured) or disabled. It is a protocol error to\nsend two enable_head or disable_head requests with the same head. It is a\nprotocol error to omit a head in a configuration.\n\nThen, the client can apply or test the configuration. The compositor will\nthen reply with a succeeded, failed or cancelled event. Finally the client\nshould destroy the configuration object.""head has been configured twice"AlreadyConfiguredHead"head has not been configured"UnconfiguredHead"request sent after configuration has been applied or tested"REQ_ENABLE_HEAD_SINCEREQ_ENABLE_HEAD_OPCODEREQ_DISABLE_HEAD_SINCEREQ_DISABLE_HEAD_OPCODEREQ_TEST_SINCEREQ_TEST_OPCODEEVT_SUCCEEDED_SINCEEVT_SUCCEEDED_OPCODE"enable and configure a head\n\nEnable a head. This request creates a head configuration object that can\nbe used to change the head's properties.""the head to be enabled"EnableHead"disable a head\n\nDisable a head.""the head to be disabled"DisableHead"apply the configuration\n\nApply the new output configuration.\n\nIn case the configuration is successfully applied, there is no guarantee\nthat the new output state matches completely the requested\nconfiguration. For instance, a compositor might round the scale if it\ndoesn't support fractional scaling.\n\nAfter this request has been sent, the compositor must respond with an\nsucceeded, failed or cancelled event. Sending a request that isn't the\ndestructor is a protocol error.""test the configuration\n\nTest the new output configuration. The configuration won't be applied,\nbut will only be validated.\n\nEven if the compositor succeeds to test a configuration, applying it may\nfail.\n\nAfter this request has been sent, the compositor must respond with an\nsucceeded, failed or cancelled event. Sending a request that isn't the\ndestructor is a protocol error.""destroy the output configuration\n\nUsing this request a client can tell the compositor that it is not going\nto use the configuration object anymore. Any changes to the outputs\nthat have not been applied will be discarded.\n\nThis request also destroys wlr_output_configuration_head objects created\nvia this object.\n\nThis is a destructor, once sent this object cannot be used any longer.""configuration changes succeeded\n\nSent after the compositor has successfully applied the changes or\ntested them.\n\nUpon receiving this event, the client should destroy this object.\n\nIf the current configuration has changed, events to describe the changes\nwill be sent followed by a wlr_output_manager.done event."Succeeded"configuration changes failed\n\nSent if the compositor rejects the changes or failed to apply them. The\ncompositor should revert any changes made by the apply request that\ntriggered this event.\n\nUpon receiving this event, the client should destroy this object.""configuration has been cancelled\n\nSent if the compositor cancels the configuration because the state of an\noutput changed and the client has outdated information (e.g. after an\noutput has been hotplugged).\n\nThe client can create a new configuration with a newer serial and try\nagain.\n\nUpon receiving this event, the client should destroy this object.""output configuration\n\nThis object is used by the client to describe a full output configuration.\n\nFirst, the client needs to setup the output configuration. Each head can\nbe either enabled (and configured) or disabled. It is a protocol error to\nsend two enable_head or disable_head requests with the same head. It is a\nprotocol error to omit a head in a configuration.\n\nThen, the client can apply or test the configuration. The compositor will\nthen reply with a succeeded, failed or cancelled event. Finally the client\nshould destroy the configuration object.\n\nSee also the [Event] enum for this interface."zwlr_output_configuration_head_v1ZwlrOutputConfigurationHeadV1enable_headdisable_head"destroy the output configuration\n\nUsing this request a client can tell the compositor that it is not going\nto use the configuration object anymore. Any changes to the outputs\nthat have not been applied will be discarded.\n\nThis request also destroys wlr_output_configuration_head objects created\nvia this object.""head configuration\n\nThis object is used by the client to update a single head's configuration.\n\nIt is a protocol error to set the same property twice.""property has already been set""mode doesn't belong to head""mode is invalid"InvalidCustomMode"transform value outside enum""scale negative or zero""invalid enum value used in the set_adaptive_sync request"InvalidAdaptiveSyncStateREQ_SET_CUSTOM_MODE_SINCEREQ_SET_CUSTOM_MODE_OPCODEREQ_SET_TRANSFORM_SINCEREQ_SET_TRANSFORM_OPCODEREQ_SET_SCALE_SINCEREQ_SET_SCALE_OPCODEREQ_SET_ADAPTIVE_SYNC_SINCEREQ_SET_ADAPTIVE_SYNC_OPCODE"set the mode\n\nThis request sets the head's mode.""set a custom mode\n\nThis request assigns a custom mode to the head. The size is given in\nphysical hardware units of the output device. If set to zero, the\nrefresh rate is unspecified.\n\nIt is a protocol error to set both a mode and a custom mode.""vertical refresh rate in mHz or zero"SetCustomMode"set the position\n\nThis request sets the head's position in the global compositor space.""x position in the global compositor space""y position in the global compositor space""set the transform\n\nThis request sets the head's transform."SetTransform"set the scale\n\nThis request sets the head's scale."SetScale"enable/disable adaptive sync\n\nThis request enables/disables adaptive sync. Adaptive sync is also\nknown as Variable Refresh Rate or VRR.\n\nOnly available since version 4 of the interface"SetAdaptiveSync"head configuration\n\nThis object is used by the client to update a single head's configuration.\n\nIt is a protocol error to set the same property twice.\n\nThis interface has no events."set_custom_modeset_transform"enable/disable adaptive sync\n\nThis request enables/disables adaptive sync. Adaptive sync is also\nknown as Variable Refresh Rate or VRR."set_adaptive_sync//! Output management protocol//! This protocol exposes interfaces to obtain and modify output device configuration.ZWLR_OUTPUT_POWER_MANAGER_V1_INTERFACEzwlr_output_power_manager_v1_requests_get_output_power_typeszwlr_output_power_manager_v1_requestszwlr_output_power_manager_v1_interfaceZWLR_OUTPUT_POWER_V1_INTERFACEzwlr_output_power_v1_requestszwlr_output_power_v1_eventszwlr_output_power_v1_interface"manager to create per-output power management\n\nThis interface is a manager that allows creating per-output power\nmanagement mode controls."REQ_GET_OUTPUT_POWER_SINCEREQ_GET_OUTPUT_POWER_OPCODE"get a power management for an output\n\nCreate an output power management mode control that can be used to\nadjust the power management mode for a given output."GetOutputPower"manager to create per-output power management\n\nThis interface is a manager that allows creating per-output power\nmanagement mode controls.\n\nThis interface has no events."ZwlrOutputPowerManagerV1zwlr_output_power_v1ZwlrOutputPowerV1get_output_powerzwlr_output_power_manager_v1"adjust power management mode for an output\n\nThis object offers requests to set the power management mode of\nan output.""Output is turned off.""Output is turned on, no power saving""nonexistent power save mode""Set an outputs power save mode\n\nSet an output's power save mode to the given mode. The mode change\nis effective immediately. If the output does not support the given\nmode a failed event is sent.""the power save mode to set""destroy this power management\n\nDestroys the output power management mode control object.\n\nThis is a destructor, once sent this object cannot be used any longer.""Report a power management mode change\n\nReport the power management mode change of an output.\n\nThe mode event is sent after an output changed its power\nmanagement mode. The reason can be a client using set_mode or the\ncompositor deciding to change an output's mode.\nThis event is also sent immediately when the object is created\nso the client is informed about the current power management mode.""the output's new power management mode""object no longer valid\n\nThis event indicates that the output power management mode control\nis no longer valid. This can happen for a number of reasons,\nincluding:\n- The output doesn't support power management\n- Another client already has exclusive power management mode control\nfor this output\n- The output disappeared\n\nUpon receiving this event, the client should destroy this object.""adjust power management mode for an output\n\nThis object offers requests to set the power management mode of\nan output.\n\nSee also the [Event] enum for this interface.""destroy this power management\n\nDestroys the output power management mode control object."//! Output power management protocol//! This protocol allows clients to control power management modes//! of outputs that are currently part of the compositor space. The//! intent is to allow special clients like desktop shells to power//! down outputs when the system is idle.output_power_managementZWLR_SCREENCOPY_MANAGER_V1_INTERFACEzwlr_screencopy_manager_v1_requests_capture_output_typeszwlr_screencopy_manager_v1_requests_capture_output_region_typeszwlr_screencopy_manager_v1_requestszwlr_screencopy_manager_v1_interfaceZWLR_SCREENCOPY_FRAME_V1_INTERFACEzwlr_screencopy_frame_v1_requests_copy_typeszwlr_screencopy_frame_v1_requests_copy_with_damage_typeszwlr_screencopy_frame_v1_requestszwlr_screencopy_frame_v1_eventszwlr_screencopy_frame_v1_interfaceREQ_CAPTURE_OUTPUT_REGION_SINCEREQ_CAPTURE_OUTPUT_REGION_OPCODE"capture an output\n\nCapture the next frame of an entire output.""composite cursor onto the frame""capture an output's region\n\nCapture the next frame of an output's region.\n\nThe region is given in output logical coordinates, see\nxdg_output.logical_size. The region will be clipped to the output's\nextents."CaptureOutputRegionZwlrScreencopyManagerV1zwlr_screencopy_frame_v1ZwlrScreencopyFrameV1capture_output_regionzwlr_screencopy_manager_v1"a frame ready for copy\n\nThis object represents a single frame.\n\nWhen created, a series of buffer events will be sent, each representing a\nsupported buffer type. The \"buffer_done\" event is sent afterwards to\nindicate that all supported buffer types have been enumerated. The client\nwill then be able to send a \"copy\" request. If the capture is successful,\nthe compositor will send a \"flags\" followed by a \"ready\" event.\n\nFor objects version 2 or lower, wl_shm buffers are always supported, ie.\nthe \"buffer\" event is guaranteed to be sent.\n\nIf the capture failed, the \"failed\" event is sent. This can happen anytime\nbefore the \"ready\" event.\n\nOnce either a \"ready\" or a \"failed\" event is received, the client should\ndestroy the frame.""the object has already been used to copy a wl_buffer""buffer attributes are invalid"REQ_COPY_SINCEREQ_COPY_OPCODEREQ_COPY_WITH_DAMAGE_SINCEREQ_COPY_WITH_DAMAGE_OPCODEEVT_BUFFER_SINCEEVT_BUFFER_OPCODEEVT_FLAGS_SINCEEVT_FLAGS_OPCODEEVT_LINUX_DMABUF_SINCEEVT_LINUX_DMABUF_OPCODEEVT_BUFFER_DONE_SINCEEVT_BUFFER_DONE_OPCODE"copy the frame\n\nCopy the frame to the supplied buffer. The buffer must have a the\ncorrect size, see zwlr_screencopy_frame_v1.buffer and\nzwlr_screencopy_frame_v1.linux_dmabuf. The buffer needs to have a\nsupported format.\n\nIf the frame is successfully copied, a \"flags\" and a \"ready\" events are\nsent. Otherwise, a \"failed\" event is sent.""delete this object, used or not\n\nDestroys the frame. This request can be sent at any time by the client.\n\nThis is a destructor, once sent this object cannot be used any longer.""copy the frame when it's damaged\n\nSame as copy, except it waits until there is damage to copy.\n\nOnly available since version 2 of the interface"CopyWithDamage"wl_shm buffer information\n\nProvides information about wl_shm buffer parameters that need to be\nused for this frame. This event is sent once after the frame is created\nif wl_shm buffers are supported.""buffer format""buffer stride""frame flags\n\nProvides flags about the frame. This event is sent once before the\n\"ready\" event.""frame flags""indicates frame is available for reading\n\nCalled as soon as the frame is copied, indicating it is available\nfor reading. This event includes the time at which presentation happened\nat.\n\nThe timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,\neach component being an unsigned 32-bit value. Whole seconds are in\ntv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,\nand the additional fractional part in tv_nsec as nanoseconds. Hence,\nfor valid timestamps tv_nsec must be in [0, 999999999]. The seconds part\nmay have an arbitrary offset at start.\n\nAfter receiving this event, the client should destroy the object.""frame copy failed\n\nThis event indicates that the attempted frame copy has failed.\n\nAfter receiving this event, the client should destroy the object.""carries the coordinates of the damaged region\n\nThis event is sent right before the ready event when copy_with_damage is\nrequested. It may be generated multiple times for each copy_with_damage\nrequest.\n\nThe arguments describe a box around an area that has changed since the\nlast copy request that was derived from the current screencopy manager\ninstance.\n\nThe union of all regions received between the call to copy_with_damage\nand a ready event is the total damage since the prior ready event.\n\nOnly available since version 2 of the interface""damaged x coordinates""damaged y coordinates""current width""current height""linux-dmabuf buffer information\n\nProvides information about linux-dmabuf buffer parameters that need to\nbe used for this frame. This event is sent once after the frame is\ncreated if linux-dmabuf buffers are supported.\n\nOnly available since version 3 of the interface""fourcc pixel format"LinuxDmabuf"all buffer types reported\n\nThis event is sent once after all buffer events have been sent.\n\nThe client should proceed to create a buffer of one of the supported\ntypes, and send a \"copy\" request.\n\nOnly available since version 3 of the interface"BufferDone"a frame ready for copy\n\nThis object represents a single frame.\n\nWhen created, a series of buffer events will be sent, each representing a\nsupported buffer type. The \"buffer_done\" event is sent afterwards to\nindicate that all supported buffer types have been enumerated. The client\nwill then be able to send a \"copy\" request. If the capture is successful,\nthe compositor will send a \"flags\" followed by a \"ready\" event.\n\nFor objects version 2 or lower, wl_shm buffers are always supported, ie.\nthe \"buffer\" event is guaranteed to be sent.\n\nIf the capture failed, the \"failed\" event is sent. This can happen anytime\nbefore the \"ready\" event.\n\nOnce either a \"ready\" or a \"failed\" event is received, the client should\ndestroy the frame.\n\nSee also the [Event] enum for this interface.""delete this object, used or not\n\nDestroys the frame. This request can be sent at any time by the client.""copy the frame when it's damaged\n\nSame as copy, except it waits until there is damage to copy."copy_with_damage//! Screen content capturing on client buffers//! This protocol allows clients to ask the compositor to copy part of the//! screen content to a client buffer.screencopyZWLR_VIRTUAL_POINTER_V1_INTERFACEzwlr_virtual_pointer_v1_requestszwlr_virtual_pointer_v1_interfaceZWLR_VIRTUAL_POINTER_MANAGER_V1_INTERFACEzwlr_virtual_pointer_manager_v1_requests_create_virtual_pointer_typeszwlr_virtual_pointer_manager_v1_requests_create_virtual_pointer_with_output_typeszwlr_virtual_pointer_manager_v1_requestszwlr_virtual_pointer_manager_v1_interface"virtual pointer\n\nThis protocol allows clients to emulate a physical pointer device. The\nrequests are mostly mirror opposites of those specified in wl_pointer.""client sent invalid axis enumeration value"InvalidAxis"client sent invalid axis source enumeration value"InvalidAxisSourceREQ_MOTION_SINCEREQ_MOTION_OPCODEREQ_MOTION_ABSOLUTE_SINCEREQ_MOTION_ABSOLUTE_OPCODEREQ_AXIS_SOURCE_SINCEREQ_AXIS_SOURCE_OPCODEREQ_AXIS_STOP_SINCEREQ_AXIS_STOP_OPCODEREQ_AXIS_DISCRETE_SINCEREQ_AXIS_DISCRETE_OPCODE"pointer relative motion event\n\nThe pointer has moved by a relative amount to the previous request.\n\nValues are in the global compositor space.""displacement on the x-axis""displacement on the y-axis""pointer absolute motion event\n\nThe pointer has moved in an absolute coordinate frame.\n\nValue of x can range from 0 to x_extent, value of y can range from 0\nto y_extent.""extent of the x-axis"x_extent"extent of the y-axis"y_extentMotionAbsolute"button event\n\nA button was pressed or released.""axis event\n\nScroll and other axis requests.""length of vector in touchpad coordinates""end of a pointer event sequence\n\nIndicates the set of events that logically belong together.""axis source event\n\nSource information for scroll and other axis.""axis stop event\n\nStop notification for scroll and other axes.""axis click event\n\nDiscrete step information for scroll and other axes.\n\nThis event allows the client to extend data normally sent using the axis\nevent with discrete value.""destroy the virtual pointer object\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""virtual pointer\n\nThis protocol allows clients to emulate a physical pointer device. The\nrequests are mostly mirror opposites of those specified in wl_pointer.\n\nThis interface has no events."ZwlrVirtualPointerV1motion_absoluteaxis_stopaxis_discrete"destroy the virtual pointer object"zwlr_virtual_pointer_v1"virtual pointer manager\n\nThis object allows clients to create individual virtual pointer objects."REQ_CREATE_VIRTUAL_POINTER_SINCEREQ_CREATE_VIRTUAL_POINTER_OPCODEREQ_CREATE_VIRTUAL_POINTER_WITH_OUTPUT_SINCEREQ_CREATE_VIRTUAL_POINTER_WITH_OUTPUT_OPCODE"Create a new virtual pointer\n\nCreates a new virtual pointer. The optional seat is a suggestion to the\ncompositor."CreateVirtualPointer"destroy the virtual pointer manager\n\n\n\nThis is a destructor, once sent this object cannot be used any longer.""Create a new virtual pointer\n\nCreates a new virtual pointer. The seat and the output arguments are\noptional. If the seat argument is set, the compositor should assign the\ninput device to the requested seat. If the output argument is set, the\ncompositor should map the input device to the requested output.\n\nOnly available since version 2 of the interface"CreateVirtualPointerWithOutput"virtual pointer manager\n\nThis object allows clients to create individual virtual pointer objects.\n\nThis interface has no events."ZwlrVirtualPointerManagerV1create_virtual_pointer"destroy the virtual pointer manager""Create a new virtual pointer\n\nCreates a new virtual pointer. The seat and the output arguments are\noptional. If the seat argument is set, the compositor should assign the\ninput device to the requested seat. If the output argument is set, the\ncompositor should map the input device to the requested output."create_virtual_pointer_with_outputzwlr_virtual_pointer_manager_v1//! Virtual pointer protocol//! This protocol allows clients to emulate a physical pointer device. The//! requests are mostly mirror opposites of those specified in wl_pointer.virtual_pointer//! This crate provides bindings to the wlroots wayland protocol extensions//! provided in <https://gitlab.freedesktop.org/wlroots/wlr-protocols>generate_interfaces_prefixgenerate_interfacegen_messagesmessage_signaturenull_terminated_byte_string_literaldescription_to_doc_attrdotted_to_relnamesnake_to_camelto_doc_attrgenerate_client_objectsgenerate_objects_forgen_methodsclient_gengenerate_enums_forgen_msg_constantsgen_message_enumgen_parse_bodygen_write_bodybuild_messagedesc_listinterface_genc_interfacesserver_gen/// Proc-macro for generating low-level interfaces associated with an XML specification/// Proc-macro for generating client-side API associated with an XML specificationgenerate_server_code/// Proc-macro for generating server-side API associated with an XML specificationformat_rust_code/// wayland client applications/// wayland compositors//! Wayland protocol code-generation machinnery//! This crate provides procedural macros for generating the rust code associated with a//! Wayland XML protocol specification, for use with the `wayland-client`, `wayland-server`//! and `wayland-backend` crates.//! Before trying to use this crate, you may check if the protocol extension you want to use//! is not already exposed in the `wayland-protocols` crate.//! ## Example usage//! Below is a template for generating the code for a custom protocol client-side. Server-side//! is identical, just replacing `client` by `server`. The path to the XML file is relative to the//! crate root.//! // Generate the bindings in their own module//! pub mod my_protocol {//!     use wayland_client;//!     // import objects from the core protocol if needed//!     use wayland_client::protocol::*;//!     // This module hosts a low-level representation of the protocol objects//!     // you will not need to interact with it yourself, but the code generated//!     // by the generate_client_code! macro will use it//!     pub mod __interfaces {//!         // import the interfaces from the core protocol if needed//!         use wayland_client::protocol::__interfaces::*;//!         wayland_scanner::generate_interfaces!("./path/to/the/protocol.xml");//!     use self::__interfaces::*;//!     // This macro generates the actual types that represent the wayland objects of//!     // your custom protocol//!     wayland_scanner::generate_client_code!("./path/to/the/protocol.xml");extract_fromextract_end_tagdecode_utf8_or_panicparse_or_panicinit_protocolparse_protocolparse_interfaceparse_descriptionparse_typexml_parseheaderless_xml_parseall_nullallow_nullcommon_typegenerate_server_objectsparse_lit_str_token// `bytes`, `next_chr`, `parse_lit_str`, `parse_lit_str_cooked` and `parse_lit_str_raw` are adapted// from syn:// https://github.com/dtolnay/syn/blob/362ee2d02df3f1b2e74c7b7a4cf2ed3c106404c9/src/lit.rs#L1062-L1167// https://github.com/dtolnay/syn/blob/362ee2d02df3f1b2e74c7b7a4cf2ed3c106404c9/src/lit.rs#L1327-L1388// End of code adapted from synis_camel_keyword__libwl_display_connect_to_fdwl_display_connectwl_display_disconnectwl_display_get_fdwl_display_roundtripwl_display_read_eventswl_display_prepare_readwl_display_cancel_readwl_display_dispatchwl_display_dispatch_pendingwl_display_get_errorwl_display_get_protocol_errorwl_display_flushwl_event_queue_destroywl_display_create_queuewl_display_roundtrip_queuewl_display_prepare_read_queuewl_display_dispatch_queuewl_display_dispatch_queue_pendingwl_proxy_createwl_proxy_destroywl_proxy_add_listenerwl_proxy_get_listenerwl_proxy_add_dispatcherwl_dispatcher_func_twl_proxy_marshal_array_constructorwl_proxy_marshal_array_constructor_versionedwl_proxy_marshal_arraywl_proxy_set_user_datawl_proxy_get_user_datawl_proxy_get_idwl_proxy_get_classwl_proxy_set_queuewl_proxy_get_versionwl_proxy_create_wrapperwl_proxy_wrapper_destroywl_log_set_handler_clientwl_log_func_twl_list_initwl_listwl_list_insertwl_list_removewl_list_lengthwl_list_emptywl_list_insert_listwl_array_initwl_array_releasewl_array_addwl_array_copywl_proxy_marshal_constructorwl_proxy_marshal_constructor_versionedwl_proxy_marshalWaylandClientwayland_client_optionwayland_client_handleis_lib_available//! Bindings to the client library `libwayland-client.so`//! The generated handle is named `wayland_client_handle()`event_countwl_fixed_twl_fixed_to_doublewl_fixed_from_doublewl_fixed_to_intwl_fixed_from_int// must be the appropriate size// can contain i32, u32 and pointers//! Various types and functions that are used by both the client and the serverwl_cursor_theme/// actual width/// actual height/// hot spot x (must be inside image)/// hot spot y (must be inside image)/// animation delay to next framewl_cursor_imagewl_cursorwayland_cursor_optionWaylandCursorwayland_cursor_handle//! Bindings to the `wayland-cursor.so` library//! The created handle is named `wayland_cursor_handle()`.wl_egl_windowwayland_egl_optionWaylandEglwayland_egl_handle//! Bindings to the EGL library `libwayland-egl.so`//! This lib allows to create EGL surfaces out of wayland surfaces.//! The created handle is named `wayland_egl_handle()`.// If compiling with neither the `client` or `server` feature (non-sensical but// it's what happens when running `cargo test --all` from the workspace root),// dlib isn't actually used. This is not an issue, so don't warn about it.//! FFI bindings to the wayland system libraries.//! The names exported by this crate should *not* be used directly, but through//! the `ffi_dispatch` macro, like this://! ffi_dispatch!(HANDLE_NAME, func_name, arg1, arg2, arg3);//! Where `HANDLE_NAME` is the name of the handle generated if the cargo feature `dlopen` is on.//! For this to work, you must ensure every needed symbol is in scope (aka the static handle//! if `dlopen` is on, the extern function if not). The easiest way to do this is to glob import//! the appropriate module. For example://! #[macro_use] extern crate wayland_sys;//! use wayland_sys::client::*;//! let display_ptr = unsafe {//!         ffi_dispatch!(wayland_client_handle(), wl_display_connect, ::std::ptr::null())//! Each module except `common` corresponds to a system library. They all define a function named//! `is_lib_available()` which returns whether the library could be loaded. They always return true//! if the feature `dlopen` is absent, as we link against the library directly in that case.// We cannot just reexport dlib::ffi_dispatch, because it'd then// use the "dlopen" feature *on the crate invoking it* rather than// the "dlopen" feature of wayland-sys.wl_event_loopwl_shm_bufferwl_event_loop_fd_func_twl_event_loop_timer_func_twl_event_loop_signal_func_twl_event_loop_idle_func_twl_global_bind_func_twl_notify_func_twl_resource_destroy_func_twl_display_global_filter_func_twl_client_for_each_resource_iterator_func_tlistener_listwl_signal//! Bindings to the client library `libwayland-server.so`//! The generated handle is named `wayland_server_handle()`TLS_SERVER_ROOTS//! A compiled-in copy of the root certificates trusted by Mozilla.//! To use this library with rustls 0.22://! let root_store = rustls::RootCertStore {//!   roots: webpki_roots::TLS_SERVER_ROOTS.to_vec(),//! This library is suitable for use in applications that can always be recompiled and instantly deployed.//! For applications that are deployed to end-users and cannot be recompiled, or which need certification//! before deployment, consider a library that uses the platform native certificate verifier such as//! [rustls-platform-verifier]. This has the additional benefit of supporting OS provided CA constraints//! and revocation data.//! [rustls-platform-verifier]: https://docs.rs/rustls-platform-verifier// This library is automatically generated from the Mozilla// IncludedCACertificateReportPEMCSV report via ccadb.org. Don't edit it.// The generation is done deterministically so you can verify it// yourself by inspecting and re-running the generation process.test_new_api/*TODO:
use super::*;
use crate::api::APIBuilder;
use crate::peer_connection::configuration::RTCConfiguration;

use bytes::Bytes;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

use interceptor::mock::mock_builder::MockBuilder;
use interceptor::mock::mock_interceptor::MockInterceptor;
use interceptor::stream_info::StreamInfo;
use interceptor::{Attributes, Interceptor, RTPWriter, RTPWriterFn};

// E2E test of the features of Interceptors
// * Assert an extension can be set on an outbound packet
// * Assert an extension can be read on an outbound packet
// * Assert that attributes set by an interceptor are returned to the Reader
#[tokio::test]
async fn test_peer_connection_interceptor() -> Result<()> {
    let create_pc = || async {
        let mut m = MediaEngine::default();
        m.register_default_codecs()?;

        let mut ir = Registry::new();

        let BindLocalStreamFn = |info: &StreamInfo,
                                 writer: Arc<dyn RTPWriter + Send + Sync>|
         -> Pin<
            Box<dyn Future<Output = Arc<dyn RTPWriter + Send + Sync>> + Send + Sync>,
        > {
            let writer2 = Arc::clone(&writer);
            Box::pin(async move {
                Arc::new(RTPWriterFn(Box::new(
                    move |in_pkt: &rtp::packet::Packet,
                          attributes: &Attributes|
                          -> Pin<
                        Box<
                            dyn Future<Output = std::result::Result<usize, interceptor::Error>>
                                + Send
                                + Sync,
                        >,
                    > {
                        let writer3 = Arc::clone(&writer2);
                        let a = attributes.clone();
                        // set extension on outgoing packet
                        let mut out_pkt = in_pkt.clone();
                        out_pkt.header.extension = true;
                        out_pkt.header.extension_profile = 0xBEDE;

                        Box::pin(async move {
                            out_pkt
                                .header
                                .set_extension(2, Bytes::from_static(b"foo"))?;
                            //writer3.write(&out_pkt, &a).await
                            Ok(0)
                        })
                    },
                ))) as Arc<dyn RTPWriter + Send + Sync>
            })
        };

        BindRemoteStreamFn: func(_ *interceptor.StreamInfo, reader interceptor.RTPReader) interceptor.RTPReader {
            return interceptor.RTPReaderFunc(func(b []byte, a interceptor.Attributes) (int, interceptor.Attributes, error) {
                if a == nil {
                    a = interceptor.Attributes{}
                }

                a.Set("attribute", "value")
                return reader.Read(b, a)
            })
        },
        let mock_builder = Box::new(MockBuilder {
            build:
                Box::new(
                    |_: &str| -> std::result::Result<
                        Arc<dyn Interceptor + Send + Sync>,
                        interceptor::Error,
                    > {
                        Ok(Arc::new(MockInterceptor {
                            ..Default::default()
                        }))
                    },
                ),
        });
        let mock_builder = MockBuilder::new(
                    |_: &str| -> std::result::Result<
                        Arc<dyn Interceptor + Send + Sync>,
                        interceptor::Error,
                    > {
                        Ok(Arc::new(MockInterceptor {
                            ..Default::default()
                        }))
                    },
                );
        ir.add(Box::new(mock_builder));

        let api = APIBuilder::new()
            .with_media_engine(m)
            .with_interceptor_registry(ir)
            .build();
        api.new_peer_connection(RTCConfiguration::default()).await
    };

    let offerer = create_pc().await?;
    let answerer = create_pc().await?;

    track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
    assert.NoError(t, err)

    _, err = offerer.AddTrack(track)
    assert.NoError(t, err)

    seenRTP, seenRTPCancel := context.WithCancel(context.Background())
    answerer.OnTrack(func(track *TrackRemote, receiver *RTPReceiver) {
        p, attributes, readErr := track.ReadRTP()
        assert.NoError(t, readErr)

        assert.Equal(t, p.Extension, true)
        assert.Equal(t, "foo", string(p.GetExtension(2)))
        assert.Equal(t, "value", attributes.Get("attribute"))

        seenRTPCancel()
    })

    assert.NoError(t, signalPair(offerer, answerer))

    func() {
        ticker := time.NewTicker(time.Millisecond * 20)
        for {
            select {
            case <-seenRTP.Done():
                return
            case <-ticker.C:
                assert.NoError(t, track.WriteSample(media.Sample{Data: []byte{0x00}, Duration: time.Second}))
            }
        }
    }()

    closePairNow(t, offerer, answerer)

    Ok(())
}

func Test_Interceptor_BindUnbind(t *testing.T) {
    lim := test.TimeOut(time.Second * 10)
    defer lim.Stop()

    report := test.CheckRoutines(t)
    defer report()

    m := &MediaEngine{}
    assert.NoError(t, m.RegisterDefaultCodecs())

    var (
        cntBindRTCPReader     uint32
        cntBindRTCPWriter     uint32
        cntBindLocalStream    uint32
        cntUnbindLocalStream  uint32
        cntBindRemoteStream   uint32
        cntUnbindRemoteStream uint32
        cntClose              uint32
    )
    mockInterceptor := &mock_interceptor.Interceptor{
        BindRTCPReaderFn: func(reader interceptor.RTCPReader) interceptor.RTCPReader {
            atomic.AddUint32(&cntBindRTCPReader, 1)
            return reader
        },
        BindRTCPWriterFn: func(writer interceptor.RTCPWriter) interceptor.RTCPWriter {
            atomic.AddUint32(&cntBindRTCPWriter, 1)
            return writer
        },
        BindLocalStreamFn: func(i *interceptor.StreamInfo, writer interceptor.RTPWriter) interceptor.RTPWriter {
            atomic.AddUint32(&cntBindLocalStream, 1)
            return writer
        },
        UnbindLocalStreamFn: func(i *interceptor.StreamInfo) {
            atomic.AddUint32(&cntUnbindLocalStream, 1)
        },
        BindRemoteStreamFn: func(i *interceptor.StreamInfo, reader interceptor.RTPReader) interceptor.RTPReader {
            atomic.AddUint32(&cntBindRemoteStream, 1)
            return reader
        },
        UnbindRemoteStreamFn: func(i *interceptor.StreamInfo) {
            atomic.AddUint32(&cntUnbindRemoteStream, 1)
        },
        CloseFn: func() error {
            atomic.AddUint32(&cntClose, 1)
            return nil
        },
    }
    ir := &interceptor.Registry{}
    ir.Add(&mock_interceptor.Factory{
        NewInterceptorFn: func(_ string) (interceptor.Interceptor, error) { return mockInterceptor, nil },
    })

    sender, receiver, err := NewAPI(WithMediaEngine(m), WithInterceptorRegistry(ir)).newPair(Configuration{})
    assert.NoError(t, err)

    track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
    assert.NoError(t, err)

    _, err = sender.AddTrack(track)
    assert.NoError(t, err)

    receiverReady, receiverReadyFn := context.WithCancel(context.Background())
    receiver.OnTrack(func(track *TrackRemote, _ *RTPReceiver) {
        _, _, readErr := track.ReadRTP()
        assert.NoError(t, readErr)
        receiverReadyFn()
    })

    assert.NoError(t, signalPair(sender, receiver))

    ticker := time.NewTicker(time.Millisecond * 20)
    defer ticker.Stop()
    func() {
        for {
            select {
            case <-receiverReady.Done():
                return
            case <-ticker.C:
                // Send packet to make receiver track actual creates RTPReceiver.
                assert.NoError(t, track.WriteSample(media.Sample{Data: []byte{0xAA}, Duration: time.Second}))
            }
        }
    }()

    closePairNow(t, sender, receiver)

    // Bind/UnbindLocal/RemoteStream should be called from one side.
    if cnt := atomic.LoadUint32(&cntBindLocalStream); cnt != 1 {
        t.Errorf("BindLocalStreamFn is expected to be called once, but called %d times", cnt)
    }
    if cnt := atomic.LoadUint32(&cntUnbindLocalStream); cnt != 1 {
        t.Errorf("UnbindLocalStreamFn is expected to be called once, but called %d times", cnt)
    }
    if cnt := atomic.LoadUint32(&cntBindRemoteStream); cnt != 1 {
        t.Errorf("BindRemoteStreamFn is expected to be called once, but called %d times", cnt)
    }
    if cnt := atomic.LoadUint32(&cntUnbindRemoteStream); cnt != 1 {
        t.Errorf("UnbindRemoteStreamFn is expected to be called once, but called %d times", cnt)
    }

    // BindRTCPWriter/Reader and Close should be called from both side.
    if cnt := atomic.LoadUint32(&cntBindRTCPWriter); cnt != 2 {
        t.Errorf("BindRTCPWriterFn is expected to be called twice, but called %d times", cnt)
    }
    if cnt := atomic.LoadUint32(&cntBindRTCPReader); cnt != 2 {
        t.Errorf("BindRTCPReaderFn is expected to be called twice, but called %d times", cnt)
    }
    if cnt := atomic.LoadUint32(&cntClose); cnt != 2 {
        t.Errorf("CloseFn is expected to be called twice, but called %d times", cnt)
    }
}

func Test_InterceptorRegistry_Build(t *testing.T) {
    registryBuildCount := 0

    ir := &interceptor.Registry{}
    ir.Add(&mock_interceptor.Factory{
        NewInterceptorFn: func(_ string) (interceptor.Interceptor, error) {
            registryBuildCount++
            return &interceptor.NoOp{}, nil
        },
    })

    peerConnectionA, err := NewAPI(WithInterceptorRegistry(ir)).NewPeerConnection(Configuration{})
    assert.NoError(t, err)

    peerConnectionB, err := NewAPI(WithInterceptorRegistry(ir)).NewPeerConnection(Configuration{})
    assert.NoError(t, err)

    assert.Equal(t, 2, registryBuildCount)
    closePairNow(t, peerConnectionA, peerConnectionB)
}
*/interceptor_registry_testmedia_engineMediaEnginertp_transceiverrtp_codecRTCRtpHeaderExtensionCapabilityRTPCodecTypeTYPE_RTCP_FB_TRANSPORT_CCregister_default_interceptors/// register_default_interceptors will register some useful interceptors./// If you want to customize which interceptors are loaded, you should copy the/// code from this method and remove unwanted interceptors.configure_rtcp_reports/// configure_rtcp_reports will setup everything necessary for generating Sender and Receiver Reportsconfigure_nack/// configure_nack will setup everything necessary for handling generating/responding to nack messages.configure_twcc/// configure_twcc will setup everything necessary for adding/// a TWCC header extension to outgoing RTP packets and generating TWCC reports.configure_twcc_sender_only/// configure_twcc_sender will setup everything necessary for adding/// a TWCC header extension to outgoing RTP packets. This will allow the remote peer to generate TWCC reports.configure_twcc_receiver_only/// configure_twcc_receiver will setup everything necessary for generating TWCC reports.MIME_TYPE_OPUSAPIBuilderpeer_connectionRTCConfigurationtest_opus_casetest_video_casetest_media_engine_remote_descriptiontest_media_engine_header_extension_direction" If a user attempts to register a codec twice we should just discard duplicate calls"test_media_engine_double_register" The cloned MediaEngine instance should be able to update negotiated header extensions."test_update_header_extension_to_cloned_media_enginetest_extension_id_collisionmedia_engine_testcodecs_from_media_descriptionrtp_extensions_from_media_descriptioncodec_parameters_fuzzy_searchCodecMatchRTCRtpCodecCapabilityRTCRtpCodecParametersRTCRtpHeaderExtensionParametersRTCRtpParametersrtp_transceiver_directionRTCRtpTransceiverDirectionPayloadTypestats_collectorStatsCollectorCodecStatsStatsReportTypeMIME_TYPE_H264/// MIME_TYPE_H264 H264 MIME type./// Note: Matching should be case insensitive.MIME_TYPE_HEVC/// MIME_TYPE_HEVC HEVC/H265 MIME type./// MIME_TYPE_OPUS Opus MIME typeMIME_TYPE_VP8/// MIME_TYPE_VP8 VP8 MIME typeMIME_TYPE_VP9/// MIME_TYPE_VP9 VP9 MIME typeMIME_TYPE_AV1/// MIME_TYPE_AV1 AV1 MIME typeMIME_TYPE_G722/// MIME_TYPE_G722 G722 MIME typeMIME_TYPE_PCMU/// MIME_TYPE_PCMU PCMU MIME typeMIME_TYPE_PCMA/// MIME_TYPE_PCMA PCMA MIME typeMIME_TYPE_TELEPHONE_EVENT/// MIME_TYPE_TELEPHONE_EVENT telephone-event MIME typeVALID_EXT_IDSallowed_directionMediaEngineHeaderExtensionis_matching_directionnegotiated_video// If we have attempted to negotiate a codec type yet.negotiated_audiovideo_codecsaudio_codecsnegotiated_video_codecsnegotiated_audio_codecsheader_extensionsproposed_header_extensionsnegotiated_header_extensions/// A MediaEngine defines the codecs supported by a PeerConnection, and the/// configuration of those codecs. A MediaEngine must not be shared between/// PeerConnections.register_default_codecs/// register_default_codecs registers the default codecs supported by Pion WebRTC./// register_default_codecs is not safe for concurrent use.add_codec/// add_codec will append codec if it not existsregister_codec/// register_codec adds codec to the MediaEngine/// These are the list of codecs supported by this PeerConnection./// register_codec is not safe for concurrent use.register_header_extension/// Adds a header extension to the MediaEngine/// To determine the negotiated value use [`MediaEngine::get_header_extension_id`] after signaling is complete./// The `allowed_direction` controls for which transceiver directions the extension matches. If/// set to `None` it matches all directions. The `SendRecv` direction would match all transceiver/// directions apart from `Inactive`. Inactive only matches inactive.register_feedback/// register_feedback adds feedback mechanism to already registered codecs.get_header_extension_id/// get_header_extension_id returns the negotiated ID for a header extension./// If the Header Extension isn't enabled ok will be false/// clone_to copies any user modifiable state of the MediaEngine/// all internal state is resetget_codec_by_payloadcollect_statsmatch_remote_codec/// Look up a codec and enable if it existsupdate_header_extension/// Look up a header extension and enable if it existspush_codecsupdate_from_remote_description/// Update the MediaEngine from a remote descriptionget_codecs_by_kindget_rtp_parameters_by_kindget_rtp_parameters_by_payload_typeapi_testinterceptor_registrysetting_enginedata_channeldata_channel_parametersDataChannelParametersRTCDataChanneldtls_transportRTCDtlsTransportice_transportice_gathererRTCIceGatherOptionsRTCIceGathererRTCIceTransportRTCCertificateRTCPeerConnectionrtp_receiverRTCRtpReceiverrtp_senderRTCRtpSendersctp_transportRTCSctpTransporttrack_localTrackLocalSettingEngineAPI/// API bundles the global functions of the WebRTC and ORTC API./// Some of these functions are also exported globally using the/// defaultAPI object. Note that the global version of the API/// may be phased out in the future.new_peer_connection/// new_peer_connection creates a new PeerConnection with the provided configuration against the received API objectnew_ice_gatherer/// new_ice_gatherer creates a new ice gatherer./// This constructor is part of the ORTC API. It is not/// meant to be used together with the basic WebRTC API.new_ice_transport/// new_ice_transport creates a new ice transport.new_dtls_transport/// new_dtls_transport creates a new dtls_transport transport.new_sctp_transport/// new_sctp_transport creates a new SCTPTransport.new_data_channel/// new_data_channel creates a new DataChannel.new_rtp_receiver/// new_rtp_receiver constructs a new RTPReceivernew_rtp_sender/// new_rtp_sender constructs a new RTPSender/// Returns the internal [`SettingEngine`]./// Returns the internal [`MediaEngine`].with_setting_engine/// WithSettingEngine allows providing a SettingEngine to the API./// Settings should not be changed after passing the engine to an API.with_media_engine/// WithMediaEngine allows providing a MediaEngine to the API./// Settings can be changed after passing the engine to an API.with_interceptor_registry/// with_interceptor_registry allows providing Interceptors to the API./// Settings should not be changed after passing the registry to an API.setting_engine_testagent_configInterfaceFilterFnIpFilterFnMulticastDnsModeNetworkTypeudp_networkUDPNetworkdtls_roleDTLSRoleice_candidate_typeRTCIceCandidateTypeRECEIVE_MTUdata_channelsDetachice_disconnected_timeoutice_failed_timeoutice_keepalive_intervalice_host_acceptance_min_waitice_srflx_acceptance_min_waitice_prflx_acceptance_min_waitice_relay_acceptance_min_waitice_liteice_network_typesinterface_filterip_filternat_1to1_ipsnat_1to1_ip_candidate_typemulticast_dns_modemulticast_dns_host_nameusername_fragmentinclude_loopback_candidateCandidatessrtcpReplayProtectionSctpMaxMessageSizeDEFAULT_MESSAGE_SIZEcandidatesreplay_protectionsdp_media_level_fingerprintsanswering_dtls_roledisable_certificate_fingerprint_verificationallow_insecure_verification_algorithmdisable_srtp_replay_protectiondisable_srtcp_replay_protection//BufferFactory                             :func(packetType packetio.BufferPacketType, ssrc uint32) io.ReadWriteCloser,//iceTCPMux                                 :ice.TCPMux,?//iceProxyDialer                            :proxy.Dialer,?disable_media_engine_copyreceive_mtumid_generatorenable_sender_rtxsctp_max_message_size_can_send/// Determines the max size of any message that may be sent through an SCTP transport./// SettingEngine allows influencing behavior in ways that are not/// supported by the WebRTC API. This allows us to support additional/// use-cases without deviating from the WebRTC API elsewhere.get_receive_mtu/// get_receive_mtu returns the configured MTU. If SettingEngine's MTU is configured to 0 it returns the defaultdetach_data_channels/// detach_data_channels enables detaching data channels. When enabled/// data channels have to be detached in the OnOpen callback using the/// DataChannel.Detach method.set_srtp_protection_profiles/// set_srtp_protection_profiles allows the user to override the default srtp Protection Profiles/// The default srtp protection profiles are provided by the function `defaultSrtpProtectionProfiles`set_ice_timeouts/// set_ice_timeouts sets the behavior around ICE Timeouts/// * disconnected_timeout is the duration without network activity before a Agent is considered disconnected. Default is 5 Seconds/// * failed_timeout is the duration without network activity before a Agent is considered failed after disconnected. Default is 25 Seconds/// * keep_alive_interval is how often the ICE Agent sends extra traffic if there is no activity, if media is flowing no traffic will be sent. Default is 2 secondsset_host_acceptance_min_wait/// set_host_acceptance_min_wait sets the icehost_acceptance_min_waitset_srflx_acceptance_min_wait/// set_srflx_acceptance_min_wait sets the icesrflx_acceptance_min_waitset_prflx_acceptance_min_wait/// set_prflx_acceptance_min_wait sets the iceprflx_acceptance_min_waitset_relay_acceptance_min_wait/// set_relay_acceptance_min_wait sets the icerelay_acceptance_min_waitset_udp_network/// set_udp_network allows ICE traffic to come through Ephemeral or UDPMux./// UDPMux drastically simplifying deployments where ports will need to be opened/forwarded./// UDPMux should be started prior to creating PeerConnections.set_lite/// set_lite configures whether or not the ice agent should be a lite agentset_network_types/// set_network_types configures what types of candidate networks are supported/// during local and server reflexive gathering.set_interface_filter/// set_interface_filter sets the filtering functions when gathering ICE candidates/// This can be used to exclude certain network interfaces from ICE. Which may be/// useful if you know a certain interface will never succeed, or if you wish to reduce/// the amount of information you wish to expose to the remote peerset_ip_filter/// set_ip_filter sets the filtering functions when gathering ICE candidates/// This can be used to exclude certain ip from ICE. Which may be/// useful if you know a certain ip will never succeed, or if you wish to reduceset_nat_1to1_ips/// set_nat_1to1_ips sets a list of external IP addresses of 1:1 (D)NAT/// and a candidate type for which the external IP address is used./// This is useful when you are host a server using Pion on an AWS EC2 instance/// which has a private address, behind a 1:1 DNAT with a public IP (e.g./// Elastic IP). In this case, you can give the public IP address so that/// Pion will use the public IP address in its candidate instead of the private/// IP address. The second argument, candidate_type, is used to tell Pion which/// type of candidate should use the given public IP address./// Two types of candidates are supported:/// ICECandidateTypeHost:///   The public IP address will be used for the host candidate in the SDP./// ICECandidateTypeSrflx:///   A server reflexive candidate with the given public IP address will be added/// to the SDP./// Please note that if you choose ICECandidateTypeHost, then the private IP address/// won't be advertised with the peer. Also, this option cannot be used along with mDNS./// If you choose ICECandidateTypeSrflx, it simply adds a server reflexive candidate/// with the public IP. The host candidate is still available along with mDNS/// capabilities unaffected. Also, you cannot give STUN server URL at the same time./// It will result in an error otherwise.set_answering_dtls_role/// set_answering_dtls_role sets the dtls_transport role that is selected when offering/// The dtls_transport role controls if the WebRTC Client as a client or server. This/// may be useful when interacting with non-compliant clients or debugging issues./// DTLSRoleActive:///   Act as dtls_transport Client, send the ClientHello and starts the handshake/// DTLSRolePassive:///   Act as dtls_transport Server, wait for ClientHelloset_vnet/// set_vnet sets the VNet instance that is passed to ice/// VNet is a virtual network layer, allowing users to simulate/// different topologies, latency, loss and jitter. This can be useful for/// learning WebRTC concepts or testing your application in a lab environmentset_ice_multicast_dns_mode/// set_ice_multicast_dns_mode controls if ice queries and generates mDNS ICE Candidatesset_multicast_dns_host_name/// set_multicast_dns_host_name sets a static HostName to be used by ice instead of generating one on startup/// This should only be used for a single PeerConnection. Having multiple PeerConnections with the same HostName will cause/// undefined behaviorset_ice_credentials/// set_ice_credentials sets a staic uFrag/uPwd to be used by ice/// This is useful if you want to do signalless WebRTC session, or having a reproducible environment with static credentials/// disable_certificate_fingerprint_verification disables fingerprint verification after dtls_transport Handshake has finished/// allow_insecure_verification_algorithm allows the usage of certain signature verification/// algorithm that are known to be vulnerable or deprecated.set_dtls_replay_protection_window/// set_dtls_replay_protection_window sets a replay attack protection window size of dtls_transport connection.set_srtp_replay_protection_window/// set_srtp_replay_protection_window sets a replay attack protection window size of srtp session.set_srtcp_replay_protection_window/// set_srtcp_replay_protection_window sets a replay attack protection window size of srtcp session./// disable_srtp_replay_protection disables srtp replay protection./// disable_srtcp_replay_protection disables srtcp replay protection.set_include_loopback_candidate/// set_include_loopback_candidate enables webrtc-rs to gather loopback candidates, it is/// useful for, e.g., some VMs that have public IP mapped to loopback interface./// Note that allowing loopback candidates to be gathered is technically inconsistent with the/// webRTC spec (see https://www.rfc-editor.org/rfc/rfc8445#section-5.1.1.1). This option is/// therefore disabled by default, and should be used with caution.set_sdp_media_level_fingerprints/// set_sdp_media_level_fingerprints configures the logic for dtls_transport Fingerprint insertion/// If true, fingerprints will be inserted in the sdp at the fingerprint/// level, instead of the session level. This helps with compatibility with/// some webrtc implementations./// disable_media_engine_copy stops the MediaEngine from being copied. This allows a user to modify/// the MediaEngine after the PeerConnection has been constructed. This is useful if you wish to/// modify codecs after signaling. Make sure not to share MediaEngines between PeerConnections.set_receive_mtu/// set_receive_mtu sets the size of read buffer that copies incoming packets. This is optional./// Leave this 0 for the default receive_mtuset_mid_generator/// Sets a callback used to generate mid for transceivers created by this side of the RTCPeerconnection./// By having separate "naming schemes" for mids generated by either side of a connection, it's/// possible to reduce complexity when handling SDP offers/answers clashing./// The `isize` argument is currently greatest seen _numeric_ mid. Since mids don't need to be numeric/// this doesn't necessarily indicating anything./// Note that the spec says: All MID values MUST be generated in a fashion that does not leak user/// information, e.g., randomly or using a per-PeerConnection counter, and SHOULD be 3 bytes or less,/// to allow them to efficiently fit into the RTP header extension/// enable_sender_rtx allows outgoing rtx streams to be created where applicable./// RTPSender will create an RTP retransmission stream for each source stream where a retransmission/// codec is configured.set_sctp_max_message_size_can_send// SetICETCPMux enables ICE-TCP when set to a non-nil value. Make sure that// NetworkTypeTCP4 or NetworkTypeTCP6 is enabled as well.//pub fn SetICETCPMux(&mut self, tcpMux ice.TCPMux) {//    self.iceTCPMux = tcpMux// SetICEProxyDialer sets the proxy dialer interface based on golang.org/x/net/proxy.//pub fn SetICEProxyDialer(&mut self, d proxy.Dialer) {//    self.iceProxyDialer = dpeer_connection_testtest_set_connection_timeouttest_detach_data_channelstest_set_nat_1to1_ipstest_set_answering_dtls_roletest_set_replay_protectiontest_setting_engine_set_disable_media_engine_copy/*TODO:#[test] fn test_setting_engine_set_ice_tcp_mux() ->Result<()> {

    listener, err := net.ListenTCP("tcp", &net.TCPAddr{})
    if err != nil {
        panic(err)
    }

    defer func() {
        _ = listener.Close()
    }()

    tcpMux := NewICETCPMux(nil, listener, 8)

    defer func() {
        _ = tcpMux.Close()
    }()

     let mut s = SettingEngine::default();
    settingEngine.SetICETCPMux(tcpMux)

    assert.Equal(t, tcpMux, settingEngine.iceTCPMux)

    Ok(())
}
*//// ordered indicates if data is allowed to be delivered out of order. The/// default value of true, guarantees that data will be delivered in order.max_packet_life_time/// max_packet_life_time limits the time (in milliseconds) during which the/// channel will transmit or retransmit data if not acknowledged. This value/// may be clamped if it exceeds the maximum value supported.max_retransmits/// max_retransmits limits the number of times a channel will retransmit data/// if not successfully delivered. This value may be clamped if it exceeds/// the maximum value supported./// protocol describes the subprotocol name used for this channel./// negotiated describes if the data channel is created by the local peer or/// the remote peer. The default value of None tells the user agent to/// announce the channel in-band and instruct the other peer to dispatch a/// corresponding DataChannel. If set to Some(id), it is up to the application/// to negotiate the channel and create an DataChannel with the same id/// at the other peer.RTCDataChannelInit/// DataChannelConfig can be used to configure properties of the underlying/// channel such as data reliability./// * [W3C]/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcdatachannelinitDataChannelMessage/// DataChannelMessage represents a message received from the/// data channel. IsString will be set to true if the incoming/// message is of the string type. Otherwise the message is of/// a binary type./// DataChannelParameters describes the configuration of the DataChannel.RTCDataChannelState/// DataChannelStateConnecting indicates that the data channel is being/// established. This is the initial state of DataChannel, whether created/// with create_data_channel, or dispatched as a part of an DataChannelEvent./// DataChannelStateOpen indicates that the underlying data transport is/// established and communication is possible./// DataChannelStateClosing indicates that the procedure to close down the/// underlying data transport has started./// DataChannelStateClosed indicates that the underlying data transport/// has been closed or could not be established./// DataChannelState indicates the state of a data channel./// * [MDN]/// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/readyState/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcdatachannelstateDATA_CHANNEL_STATE_CONNECTING_STRDATA_CHANNEL_STATE_OPEN_STRDATA_CHANNEL_STATE_CLOSING_STRDATA_CHANNEL_STATE_CLOSED_STRtest_new_data_channel_statetest_data_channel_state_stringdata_channel_initdtls_parametersDTLSParameters//use log::LevelFilter;ice_candidateRTCIceCandidateice_connection_stateRTCIceConnectionStateice_parametersRTCIceParametersice_roleRTCIceRolesctp_transport_capabilitiesSCTPTransportCapabilitiesEXPECTED_LABEL// EXPECTED_LABEL represents the label of the data channel we are trying to test.// Some other channels may have been created during initialization (in the Wasm// bindings this is a requirement).set_up_data_channel_parameters_testclose_reliability_param_testtest_data_channel_opentest_data_channel_send_before_signalingtest_data_channel_send_after_connectedtest_data_channel_closetest_data_channel_parameters_max_packet_life_time_exchangetest_data_channel_parameters_max_retransmits_exchangetest_data_channel_parameters_unreliable_unordered_exchangetest_data_channel_parameters_reliable_unordered_exchangetest_data_channel_parameters_protocol_exchangetest_data_channel_parameters_negotiated_exchangetest_data_channel_event_handlerstest_data_channel_messages_are_orderedtest_data_channel_parameters_gotest_data_channel_buffered_amount_set_before_opentest_data_channel_buffered_amount_set_after_opentest_eof_detachtest_eof_no_detachtest_data_channel_non_standard_session_descriptioncreate_data_channel_with_max_message_sizeEXPECTED_MAX_MESSAGE_SIZE// 128 KBtest_data_channel_max_message_size_respected_on_sendtest_given_remote_max_message_size_is_none_when_data_channel_can_send_max_message_size_respected_on_sendrun_data_channel_config_max_message_sizetest_data_channel_max_message_size_reflected_on_data_channel_configtest_can_send_max_message_size_unspecified_then_remote_default_value_is_respectedtest_given_can_send_channel_max_message_size_less_than_remote_max_message_size_respect_send_channel_max_message_sizetest_can_send_max_message_size_respected_on_data_channel_configtest_given_no_remote_message_size_or_can_send_max_message_size_max_size_is_65536test_respect_default_remote_max_message_size_when_can_send_max_message_size_is_greater_than_defaultgatherer//api      *APITestOrtcStackice_candidates//`json:"iceCandidates"`//`json:"iceParameters"`sctp_capabilities//`json:"dtlsParameters"`//`json:"sctpCapabilities"`TestOrtcSignalset_signalnew_ortc_pairsignal_ortc_pairtest_data_channel_ortc_e2e/*
TODO: #[tokio::test] async fnBenchmarkDataChannelSend2(b *testing.B)  { benchmarkDataChannelSend(b, 2) }
#[tokio::test] async fnBenchmarkDataChannelSend4(b *testing.B)  { benchmarkDataChannelSend(b, 4) }
#[tokio::test] async fnBenchmarkDataChannelSend8(b *testing.B)  { benchmarkDataChannelSend(b, 8) }
#[tokio::test] async fnBenchmarkDataChannelSend16(b *testing.B) { benchmarkDataChannelSend(b, 16) }
#[tokio::test] async fnBenchmarkDataChannelSend32(b *testing.B) { benchmarkDataChannelSend(b, 32) }

// See https://github.com/pion/webrtc/issues/1516
#[tokio::test] async fnbenchmarkDataChannelSend(b *testing.B, numChannels int) {
    offerPC, answerPC, err := newPair()
    if err != nil {
        b.Fatalf("Failed to create a PC pair for testing")
    }

    open := make(map[string]chan bool)
    answerPC.OnDataChannel(func(d *DataChannel) {
        if _, ok := open[d.Label()]; !ok {
            // Ignore anything unknown channel label.
            return
        }
        d.OnOpen(func() { open[d.Label()] <- true })
    })

    var wg sync.WaitGroup
    for i := 0; i < numChannels; i++ {
        label := fmt.Sprintf("dc-%d", i)
        open[label] = make(chan bool)
        wg.Add(1)
        dc, err := offerPC.CreateDataChannel(label, nil)
        assert.NoError(b, err)

        dc.OnOpen(func() {
            <-open[label]
            for n := 0; n < b.N/numChannels; n++ {
                if err := dc.SendText("Ping"); err != nil {
                    b.Fatalf("Unexpected error sending data (label=%q): %v", label, err)
                }
            }
            wg.Done()
        })
    }

    assert.NoError(b, signalPair(offerPC, answerPC))
    wg.Wait()
    close_pair_now(b, offerPC, answerPC)
}
*/data_channel_testdata_channel_messagedata_channel_statemessage_channel_openOnBufferedAmountLowFnOnErrorHdlrFnDataChannelStatsDATA_CHANNEL_BUFFER_SIZE/// message size limit for ChromiumOnMessageHdlrFnOnOpenHdlrFnOnCloseHdlrFnstats_idmax_packet_lifetimeready_statebuffered_amount_low_threshold// DataChannelStatedetach_calledon_message_handler// The binaryType represents attribute MUST, on getting, return the value to// which it was last set. On setting, if the new value is either the string// "blob" or the string "arraybuffer", then set the IDL attribute to this// new value. Otherwise, throw a SyntaxError. When an DataChannel object// is created, the binaryType attribute MUST be initialized to the string// "blob". This attribute controls how binary data is exposed to scripts.// binaryType                 stringon_open_handleron_close_handleron_error_handleron_buffered_amount_lowDataChannel// A reference to the associated api object used by this datachannel/// DataChannel represents a WebRTC DataChannel/// The DataChannel interface represents a network channel/// which can be used for bidirectional peer-to-peer transfers of arbitrary data/// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcdatachannel// create the DataChannel object before the networking is set up./// open opens the datachannel over the sctp transport/// transport returns the SCTPTransport instance the DataChannel is sending over.on_open/// on_open sets an event handler which is invoked when/// the underlying data transport has been established (or re-established).do_open/// on_close sets an event handler which is invoked when/// the underlying data transport has been closed.on_message/// on_message sets an event handler which is invoked on a binary/// message arrival over the sctp transport from a remote peer./// OnMessage can currently receive messages up to 16384 bytes/// in size. Check out the detach API if you want to use larger/// message sizes. Note that browser support for larger messages/// is also limited.do_messagehandle_open/// on_error sets an event handler which is invoked when/// the underlying data transport cannot be read./// send sends the binary message to the DataChannel peersend_text/// send_text sends the text message to the DataChannel peerensure_open/// detach allows you to detach the underlying datachannel. This provides/// an idiomatic API to work with, however it disables the OnMessage callback./// Before calling Detach you have to enable this behavior by calling/// webrtc.DetachDataChannels(). Combining detached and normal data channels/// is not supported./// Please refer to the data-channels-detach example and the/// pion/datachannel documentation for the correct way to handle the/// resulting DataChannel object./// Close Closes the DataChannel. It may be called regardless of whether/// the DataChannel object was created by this peer or the remote peer./// label represents a label that can be used to distinguish this/// DataChannel object from other DataChannel objects. Scripts are/// allowed to create multiple DataChannel objects with the same label./// Ordered returns true if the DataChannel is ordered, and false if/// out-of-order delivery is allowed./// max_packet_lifetime represents the length of the time window (msec) during/// which transmissions and retransmissions may occur in unreliable mode./// max_retransmits represents the maximum number of retransmissions that are/// attempted in unreliable mode./// protocol represents the name of the sub-protocol used with this/// DataChannel./// negotiated represents whether this DataChannel was negotiated by the/// application (true), or not (false)./// ID represents the ID for this DataChannel. The value is initially/// null, which is what will be returned if the ID was not provided at/// channel creation time, and the DTLS role of the SCTP transport has not/// yet been negotiated. Otherwise, it will return the ID that was either/// selected by the script or generated. After the ID is set to a non-null/// value, it will not change./// ready_state represents the state of the DataChannel object.buffered_amount/// buffered_amount represents the number of bytes of application data/// (UTF-8 text and binary data) that have been queued using send(). Even/// though the data transmission can occur in parallel, the returned value/// MUST NOT be decreased before the current task yielded back to the event/// loop to prevent race conditions. The value does not include framing/// overhead incurred by the protocol, or buffering done by the operating/// system or network hardware. The value of buffered_amount slot will only/// increase with each call to the send() method as long as the ready_state is/// open; however, buffered_amount does not reset to zero once the channel/// closes./// buffered_amount_low_threshold represents the threshold at which the/// bufferedAmount is considered to be low. When the bufferedAmount decreases/// from above this threshold to equal or below it, the bufferedamountlow/// event fires. buffered_amount_low_threshold is initially zero on each new/// DataChannel, but the application may change its value at any time./// The threshold is set to 0 by default.set_buffered_amount_low_threshold/// set_buffered_amount_low_threshold is used to update the threshold./// See buffered_amount_low_threshold()./// on_buffered_amount_low sets an event handler which is invoked when/// the number of bytes of outgoing data becomes lower than the/// buffered_amount_low_threshold.get_stats_idset_ready_state/// Algorithm specifies one of the the hash function algorithms defined in/// the 'Hash function Textual Names' registry./// Value specifies the value of the certificate fingerprint in lowercase/// hex string as expressed utilizing the syntax of 'fingerprint' in/// <https://tools.ietf.org/html/rfc4572#section-5>.RTCDtlsFingerprint/// DTLSFingerprint specifies the hash function algorithm and certificate/// fingerprint as described in [RFC 4572]./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcdtlsfingerprint/// [RFC 4572]: https://tools.ietf.org/html/rfc4572dtls_fingerprintfingerprints/// DTLSParameters holds information relating to DTLS configuration./// DTLSRoleAuto defines the DTLS role is determined based on/// the resolved ICE role: the ICE controlled role acts as the DTLS/// client and the ICE controlling role acts as the DTLS server./// DTLSRoleClient defines the DTLS client role./// DTLSRoleServer defines the DTLS server role./// DtlsRole indicates the role of the DTLS transport.DEFAULT_DTLS_ROLE_ANSWER/// <https://tools.ietf.org/html/rfc5763>/// The answerer MUST use either a/// setup attribute value of setup:active or setup:passive.  Note that/// if the answerer uses setup:passive, then the DTLS handshake will/// not begin until the answerer is received, which adds additional/// latency. setup:active allows the answer and the DTLS handshake to/// occur in parallel.  Thus, setup:active is RECOMMENDED.DEFAULT_DTLS_ROLE_OFFER/// The endpoint that is the offerer MUST use the setup attribute/// value of setup:actpass and be prepared to receive a client_hello/// before it receives the answer./// Iterate a SessionDescription from a remote to determine if an explicit/// role can been determined from it. The decision is made from the first role we we parse./// If no role can be found we return DTLSRoleAutoto_connection_roletest_dtls_role_stringtest_dtls_role_from_remote_sdpRTCDtlsTransportState/// DTLSTransportStateNew indicates that DTLS has not started negotiating/// yet./// DTLSTransportStateConnecting indicates that DTLS is in the process of/// negotiating a secure connection and verifying the remote fingerprint./// DTLSTransportStateConnected indicates that DTLS has completed/// negotiation of a secure connection and verified the remote fingerprint./// DTLSTransportStateClosed indicates that the transport has been closed/// intentionally as the result of receipt of a close_notify alert, or/// calling close()./// DTLSTransportStateFailed indicates that the transport has failed as/// the result of an error (such as receipt of an error alert or failure to/// validate the remote fingerprint)./// DTLSTransportState indicates the DTLS transport establishment state./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCDtlsTransport/state/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcdtlstransportstateDTLS_TRANSPORT_STATE_NEW_STRDTLS_TRANSPORT_STATE_CONNECTING_STRDTLS_TRANSPORT_STATE_CONNECTED_STRDTLS_TRANSPORT_STATE_CLOSED_STRDTLS_TRANSPORT_STATE_FAILED_STRtest_new_dtls_transport_statetest_dtls_transport_state_stringpeer_connection_stateRTCPeerConnectionStateclose_pair_nowsignal_pairuntil_connection_statetest_invalid_fingerprint_causes_failedtest_peer_connection_dtls_role_setting_engine_servertest_peer_connection_dtls_role_setting_engine_clientprotection_profileProtectionProfiledtls_transport_stateice_transport_stateRTCIceTransportStatemux_funcmatch_dtlsmatch_srtcpmatch_srtpMatchFuncSSRCdtls_transport_testdefault_srtp_protection_profilesOnDTLSTransportStateChangeHdlrFnremote_parametersremote_certificate//DTLSTransportState,on_state_change_handlersrtp_sessionsrtcp_sessionsrtp_endpointsrtcp_endpointsimulcast_streamssrtp_ready_signalsrtp_ready_txsrtp_ready_rxdtls_matcher/// DTLSTransport allows an application access to information about the DTLS/// transport over which RTP and RTCP packets are sent and received by/// RTPSender and RTPReceiver, as well other data such as SCTP packets sent/// and received by data channels./// returns the currently-configured ICETransport or None/// if one has not been configured/// state_change requires the caller holds the lockon_state_change/// on_state_change sets a handler that is fired when the DTLS/// connection state changes./// state returns the current dtls_transport transport state./// write_rtcp sends a user provided RTCP packet to the connected peer. If no peer is connected the/// packet is discarded.get_local_parameters/// get_local_parameters returns the DTLS parameters of the local DTLSTransport upon construction.get_remote_certificate/// get_remote_certificate returns the certificate chain in use by the remote side/// returns an empty list prior to selection of the remote certificatestart_srtpget_srtp_sessionget_srtcp_sessionprepare_transport/// start DTLS transport negotiation with the parameters of the remote DTLS transport/// stops and closes the DTLSTransport object.validate_fingerprintensure_ice_connstore_simulcast_streamremove_simulcast_streamstreams_for_ssrcsdp_typeRTCSdpTypesignaling_stateRTCSignalingStateErrUnknownType/// ErrUnknownType indicates an error with Unknown info.ErrConnectionClosed/// ErrConnectionClosed indicates an operation executed after connection/// has already been closed.ErrDataChannelNotOpen/// ErrDataChannelNotOpen indicates an operation executed when the data/// channel is not (yet) open.ErrCertificateExpired/// ErrCertificateExpired indicates that an x509 certificate has expired.ErrNoTurnCredentials/// ErrNoTurnCredentials indicates that a TURN server URL was provided/// without required credentials.ErrExistingTrack/// ErrExistingTrack indicates that a track already exists.ErrPrivateKeyType/// ErrPrivateKeyType indicates that a particular private key encryption/// chosen to generate a certificate is not supported.ErrModifyingPeerIdentity/// ErrModifyingPeerIdentity indicates that an attempt to modify/// PeerIdentity was made after PeerConnection has been initialized.ErrModifyingCertificates/// ErrModifyingCertificates indicates that an attempt to modify/// Certificates was made after PeerConnection has been initialized.ErrNonCertificate/// ErrNonCertificate indicates that there is no certificateErrModifyingBundlePolicy/// ErrModifyingBundlePolicy indicates that an attempt to modify/// BundlePolicy was made after PeerConnection has been initialized.ErrModifyingRTCPMuxPolicy/// ErrModifyingRTCPMuxPolicy indicates that an attempt to modify/// RTCPMuxPolicy was made after PeerConnection has been initialized.ErrModifyingICECandidatePoolSize/// ErrModifyingICECandidatePoolSize indicates that an attempt to modify/// ICECandidatePoolSize was made after PeerConnection has been initialized.ErrStringSizeLimit/// ErrStringSizeLimit indicates that the character size limit of string is/// exceeded. The limit is hardcoded to 65535 according to specifications.ErrMaxDataChannelID/// ErrMaxDataChannelID indicates that the maximum number ID that could be/// specified for a data channel has been exceeded.ErrNegotiatedWithoutID/// ErrNegotiatedWithoutID indicates that an attempt to create a data channel/// was made while setting the negotiated option to true without providing/// the negotiated channel ID.ErrRetransmitsOrPacketLifeTime/// ErrRetransmitsOrPacketLifeTime indicates that an attempt to create a data/// channel was made with both options max_packet_life_time and max_retransmits/// set together. Such configuration is not supported by the specification/// and is mutually exclusive.ErrCodecNotFound/// ErrCodecNotFound is returned when a codec search to the Media Engine failsErrNoRemoteDescription/// ErrNoRemoteDescription indicates that an operation was rejected because/// the remote description is not setErrIncorrectSDPSemantics/// ErrIncorrectSDPSemantics indicates that the PeerConnection was configured to/// generate SDP Answers with different SDP Semantics than the received OfferErrIncorrectSignalingState/// ErrIncorrectSignalingState indicates that the signaling state of PeerConnection is not correctErrProtocolTooLarge/// ErrProtocolTooLarge indicates that value given for a DataChannelInit protocol is/// longer then 65535 bytesErrSenderNotCreatedByConnection/// ErrSenderNotCreatedByConnection indicates remove_track was called with a/// [`rtp_sender::RTCRtpSender`] not created by this PeerConnectionErrSenderInitialTrackIdAlreadySet/// ErrSenderInitialTrackIdAlreadySet indicates a second call to/// `RTCRtpSender::set_initial_track_id` which is not allowed. Purely internal error, should not happen in practice.ErrSessionDescriptionNoFingerprint/// ErrSessionDescriptionNoFingerprint indicates set_remote_description was called with a SessionDescription that has no/// fingerprintErrSessionDescriptionInvalidFingerprint/// ErrSessionDescriptionInvalidFingerprint indicates set_remote_description was called with a SessionDescription that/// has an invalid fingerprintErrSessionDescriptionConflictingFingerprints/// ErrSessionDescriptionConflictingFingerprints indicates set_remote_description was called with a SessionDescription that/// has an conflicting fingerprintsErrSessionDescriptionMissingIceUfrag/// ErrSessionDescriptionMissingIceUfrag indicates set_remote_description was called with a SessionDescription that/// is missing an ice-ufrag valueErrSessionDescriptionMissingIcePwd/// ErrSessionDescriptionMissingIcePwd indicates set_remote_description was called with a SessionDescription that/// is missing an ice-pwd valueErrSessionDescriptionConflictingIceUfrag/// ErrSessionDescriptionConflictingIceUfrag  indicates set_remote_description was called with a SessionDescription that/// contains multiple conflicting ice-ufrag valuesErrSessionDescriptionConflictingIcePwd/// ErrSessionDescriptionConflictingIcePwd indicates set_remote_description was called with a SessionDescription that/// contains multiple conflicting ice-pwd valuesErrNoSRTPProtectionProfile/// ErrNoSRTPProtectionProfile indicates that the DTLS handshake completed and no SRTP Protection Profile was chosenErrFailedToGenerateCertificateFingerprint/// ErrFailedToGenerateCertificateFingerprint indicates that we failed to generate the fingerprint used for comparing certificatesErrNoCodecsAvailable/// ErrNoCodecsAvailable indicates that operation isn't possible because the MediaEngine has no codecs availableErrUnsupportedCodec/// ErrUnsupportedCodec indicates the remote peer doesn't support the requested codecErrSenderWithNoCodecs/// ErrSenderWithNoCodecs indicates that a RTPSender was created without any codecs. To send media the MediaEngine needs at/// least one configured codec.ErrRTPSenderNewTrackHasIncorrectKind/// ErrRTPSenderNewTrackHasIncorrectKind indicates that the new track is of a different kind than the previous/originalErrRTPSenderNewTrackHasIncorrectEnvelope/// ErrRTPSenderNewTrackHasIncorrectEnvelope indicates that the new track has a different envelope than the previous/originalErrRTPSenderDataSent/// ErrRTPSenderDataSent indicates that the sequence number transformer tries to be enabled after the data sending beganErrRTPSenderSeqTransEnabled/// ErrRTPSenderSeqTransEnabled indicates that the sequence number transformer has been already enabledErrUnbindFailed/// ErrUnbindFailed indicates that a TrackLocal was not able to be unbindErrNoPayloaderForCodec/// ErrNoPayloaderForCodec indicates that the requested codec does not have a payloaderErrRegisterHeaderExtensionInvalidDirection/// ErrRegisterHeaderExtensionInvalidDirection indicates that a extension was registered with different/// directions for two different calls.ErrRegisterHeaderExtensionNoFreeID/// ErrRegisterHeaderExtensionNoFreeID indicates that there was no extension ID available which/// in turn means that all 15 available id(1 through 14) have been used.ErrSimulcastProbeOverflow/// ErrSimulcastProbeOverflow indicates that too many Simulcast probe streams are in flight and the requested SSRC was ignoredErrDetachNotEnabledErrDetachBeforeOpenedErrDtlsTransportNotStartedErrDtlsKeyExtractionFailedErrFailedToStartSRTPErrFailedToStartSRTCPErrInvalidDTLSStartErrNoRemoteCertificateErrIdentityProviderNotImplementedErrNoMatchingCertificateFingerprintErrUnsupportedFingerprintAlgorithmErrICEConnectionNotStartedErrICECandidateTypeUnknownErrICEInvalidConvertCandidateTypeErrICEAgentNotExistErrICECandidatesConversionFailedErrICERoleUnknownErrICEProtocolUnknownErrICEGathererNotStartedErrNetworkTypeUnknownErrSDPDoesNotMatchOfferErrSDPDoesNotMatchAnswerErrPeerConnSDPTypeInvalidValueErrPeerConnStateChangeInvalidErrPeerConnStateChangeUnhandledErrPeerConnSDPTypeInvalidValueSetLocalDescriptionErrPeerConnRemoteDescriptionWithoutMidValueErrPeerConnRemoteDescriptionNilErrPeerConnSingleMediaSectionHasExplicitSSRCErrPeerConnRemoteSSRCAddTransceiverErrPeerConnSimulcastMidRTPExtensionRequiredErrPeerConnSimulcastStreamIDRTPExtensionRequiredErrPeerConnSimulcastIncomingSSRCFailedErrPeerConnStatsCollectionFailedErrPeerConnAddTransceiverFromKindOnlyAcceptsOneErrPeerConnAddTransceiverFromTrackOnlyAcceptsOneErrPeerConnAddTransceiverFromKindSupportErrPeerConnAddTransceiverFromTrackSupportErrPeerConnSetIdentityProviderNotImplementedErrPeerConnWriteRTCPOpenWriteStreamErrPeerConnTransceiverMidNilErrRTPReceiverDTLSTransportNilErrRTPReceiverReceiveAlreadyCalledErrRTPReceiverWithSSRCTrackStreamNotFoundErrRTPReceiverForSSRCTrackStreamNotFoundErrRTPReceiverForRIDTrackStreamNotFoundErrRTPReceiverStateChangeInvalidErrRTPSenderTrackNilErrRTPSenderStoppedErrRTPSenderTrackRemovedErrRTPSenderRidNilErrRTPSenderNoBaseEncodingErrRTPSenderBaseEncodingMismatchErrRTPSenderRIDCollisionErrRTPSenderNoTrackForRIDErrRTPSenderNilErrRTPReceiverNilErrRTPSenderDTLSTransportNilErrRTPSenderSendAlreadyCalledErrRTPTransceiverCannotChangeMidErrRTPTransceiverSetSendingInvalidStateErrRTPTransceiverCodecUnsupportedErrSCTPTransportDTLSErrSDPZeroTransceiversErrSDPMediaSectionMediaDataChanInvalidErrSDPMediaSectionMultipleTrackInvalidErrSettingEngineSetAnsweringDTLSRoleErrSignalingStateCannotRollbackapplyingErrSignalingStateProposedTransitionInvalidErrStatsICECandidateStateInvalidErrICETransportNotInNewErrCertificatePEMFormatErrorErrSCTPNotEstablishedErrClosedPipeErrInterceptorNotBindErrExcessiveRetriesErrRTPTooShortIceDtlsSdpcandidate_baseCandidateBaseConfigcandidate_hostCandidateHostConfigcandidate_peer_reflexiveCandidatePeerReflexiveConfigcandidate_relayCandidateRelayConfigcandidate_server_reflexiveCandidateServerReflexiveConfigice_protocolRTCIceProtocolrelated_addressrelated_porttcp_type/// ICECandidate represents a ice candidate/// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate/// [W3C]: https://w3c.github.io/webrtc-pc/#rtcicecandidate-interfacertc_ice_candidates_from_ice_candidates/// Conversion for ice_candidatesto_iceRTCIceCandidateInit/// to_json returns an ICECandidateInit/// as indicated by the spec <https://w3c.github.io/webrtc-pc/#dom-rtcicecandidate-tojson>sdp_midsdp_mline_index/// ICECandidateInit is used to serialize ice candidatestest_ice_candidate_serializationRTCIceCandidatePair/// ICECandidatePair represents an ICE Candidate pair/// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidatePair/// returns an initialized ICECandidatePair/// for the given pair of ICECandidate instancesCandidateType/// ICECandidateTypeHost indicates that the candidate is of Host type as/// described in <https://tools.ietf.org/html/rfc8445#section-5.1.1.1>. A/// candidate obtained by binding to a specific port from an IP address on/// the host. This includes IP addresses on physical interfaces and logical/// ones, such as ones obtained through VPNs.Srflx/// ICECandidateTypeSrflx indicates the the candidate is of Server/// Reflexive type as described/// <https://tools.ietf.org/html/rfc8445#section-5.1.1.2>. A candidate type/// whose IP address and port are a binding allocated by a NAT for an ICE/// agent after it sends a packet through the NAT to a server, such as a/// STUN server.Prflx/// ICECandidateTypePrflx indicates that the candidate is of Peer/// Reflexive type. A candidate type whose IP address and port are a binding/// allocated by a NAT for an ICE agent after it sends a packet through the/// NAT to its peer.Relay/// ICECandidateTypeRelay indicates the the candidate is of Relay type as/// described in <https://tools.ietf.org/html/rfc8445#section-5.1.1.2>. A/// candidate type obtained from a relay server, such as a TURN server./// ICECandidateType represents the type of the ICE candidate used./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidateStats/candidateType/// [W3C]: https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatestats-candidatetypeICE_CANDIDATE_TYPE_HOST_STRICE_CANDIDATE_TYPE_SRFLX_STRICE_CANDIDATE_TYPE_PRFLX_STRICE_CANDIDATE_TYPE_RELAY_STR///  takes a string and converts it into ICECandidateTypetest_ice_candidate_typetest_ice_candidate_type_string/// ICEConnectionStateNew indicates that any of the ICETransports are/// in the "new" state and none of them are in the "checking", "disconnected"/// or "failed" state, or all ICETransports are in the "closed" state, or/// there are no transports.Checking/// ICEConnectionStateChecking indicates that any of the ICETransports/// are in the "checking" state and none of them are in the "disconnected"/// or "failed" state./// ICEConnectionStateConnected indicates that all ICETransports are/// in the "connected", "completed" or "closed" state and at least one of/// them is in the "connected" state.Completed/// ICEConnectionStateCompleted indicates that all ICETransports are/// in the "completed" or "closed" state and at least one of them is in the/// "completed" state./// ICEConnectionStateDisconnected indicates that any of the/// ICETransports are in the "disconnected" state and none of them are/// in the "failed" state./// ICEConnectionStateFailed indicates that any of the ICETransports/// are in the "failed" state./// ICEConnectionStateClosed indicates that the PeerConnection's/// isClosed is true./// RTCIceConnectionState indicates signaling state of the ICE Connection./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceConnectionState/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-peerconnection-ice-connection-stateICE_CONNECTION_STATE_NEW_STRICE_CONNECTION_STATE_CHECKING_STRICE_CONNECTION_STATE_CONNECTED_STRICE_CONNECTION_STATE_COMPLETED_STRICE_CONNECTION_STATE_DISCONNECTED_STRICE_CONNECTION_STATE_FAILED_STRICE_CONNECTION_STATE_CLOSED_STR/// takes a string and converts it to iceconnection_statetest_new_ice_connection_statetest_ice_connection_state_stringice_gatherer_stateRTCIceGathererStateice_serverRTCIceServerice_transport_policyRTCIceTransportPolicySourceStatsTypeICECandidatePairStatsice_serversice_gather_policy/// ICEGatherOptions provides options relating to the gathering of ICE candidates.OnLocalCandidateHdlrFnOnICEGathererStateChangeHdlrFnOnGatheringCompleteHdlrFnvalidated_serversgather_policy//ICEGathererState,on_local_candidate_handleron_gathering_complete_handler// Used for gathering_complete_promise/// ICEGatherer gathers local host, server reflexive and relay/// candidates, as well as enabling the retrieval of local Interactive/// Connectivity Establishment (ICE) parameters which can be/// exchanged in signaling.create_agent/// Gather ICE candidates./// Close prunes all local candidates, and closes the ports./// get_local_parameters returns the ICE parameters of the ICEGatherer.get_local_candidates/// get_local_candidates returns the sequence of valid local candidates associated with the ICEGatherer.on_local_candidate/// on_local_candidate sets an event handler which fires when a new local ICE candidate is available/// Take note that the handler is gonna be called with a nil pointer when gathering is finished./// on_state_change sets an event handler which fires any time the ICEGatherer changeson_gathering_complete/// on_gathering_complete sets an event handler which fires any time the ICEGatherer changes/// State indicates the current state of the ICE gatherer.get_agenttest_new_ice_gatherer_successtest_ice_gather_mdns_candidate_gathering/// ICEGathererStateNew indicates object has been created but/// gather() has not been called.Gathering/// ICEGathererStateGathering indicates gather() has been called,/// and the ICEGatherer is in the process of gathering candidates./// ICEGathererStateComplete indicates the ICEGatherer has completed gathering./// ICEGathererStateClosed indicates the closed state can only be entered/// when the ICEGatherer has been closed intentionally by calling close()./// ICEGathererState represents the current state of the ICE gatherer./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcicegathererstateICE_GATHERED_STATE_NEW_STRICE_GATHERED_STATE_GATHERING_STRICE_GATHERED_STATE_COMPLETE_STRICE_GATHERED_STATE_CLOSED_STRtest_ice_gatherer_state_stringRTCIceGatheringState/// ICEGatheringStateNew indicates that any of the ICETransports are/// in the "new" gathering state and none of the transports are in the/// "gathering" state, or there are no transports./// ICEGatheringStateGathering indicates that any of the ICETransports/// are in the "gathering" state./// ICEGatheringStateComplete indicates that at least one ICETransport/// exists, and all ICETransports are in the "completed" gathering state./// ICEGatheringState describes the state of the candidate gathering process./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceGatheringState/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-peerconnection-ice-gathering-stateICE_GATHERING_STATE_NEW_STRICE_GATHERING_STATE_GATHERING_STRICE_GATHERING_STATE_COMPLETE_STR/// takes a string and converts it to ICEGatheringStatetest_new_ice_gathering_statetest_ice_gathering_state_string/// ICEParameters includes the ICE username fragment/// and password and other ICE-related parameters./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceParameters/// [W3C]: https://w3c.github.io/webrtc-pc/#rtciceparameters/// UDP indicates the URL uses a UDP transport./// TCP indicates the URL uses a TCP transport./// ICEProtocol indicates the transport protocol type that is used in the/// ice.URL structure./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate/protocol/// [W3C]: https://w3c.github.io/webrtc-pc/#rtciceprotocol-enumICE_PROTOCOL_UDP_STRICE_PROTOCOL_TCP_STR/// takes a string and converts it to ICEProtocoltest_new_ice_protocoltest_ice_protocol_stringControlling/// ICERoleControlling indicates that the ICE agent that is responsible/// for selecting the final choice of candidate pairs and signaling them/// through STUN and an updated offer, if needed. In any session, one agent/// is always controlling. The other is the controlled agent.Controlled/// ICERoleControlled indicates that an ICE agent that waits for the/// controlling agent to select the final choice of candidate pairs./// ICERole describes the role ice.Agent is playing in selecting the/// preferred the candidate pair./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceTransport/role/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtciceroleICE_ROLE_CONTROLLING_STRICE_ROLE_CONTROLLED_STRtest_new_ice_roletest_ice_role_stringcredential/// ICEServer describes a single STUN and TURN server that can be used by/// the ICEAgent to establish a connection with a peer./// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtciceservertest_ice_server_validate_successtest_ice_server_validate_failuretest_ice_server_validate_failure_err_stun_query/// ICETransportStateNew indicates the ICETransport is waiting/// for remote candidates to be supplied./// ICETransportStateChecking indicates the ICETransport has/// received at least one remote candidate, and a local and remote/// ICECandidateComplete dictionary was not added as the last candidate./// ICETransportStateConnected indicates the ICETransport has/// received a response to an outgoing connectivity check, or has/// received incoming DTLS/media after a successful response to an/// incoming connectivity check, but is still checking other candidate/// pairs to see if there is a better connection./// ICETransportStateCompleted indicates the ICETransport tested/// all appropriate candidate pairs and at least one functioning/// candidate pair has been found./// ICETransportStateFailed indicates the ICETransport the last/// candidate was added and all appropriate candidate pairs have either/// failed connectivity checks or have lost consent./// ICETransportStateDisconnected indicates the ICETransport has received/// at least one local and remote candidate, but the final candidate was/// received yet and all appropriate candidate pairs thus far have been/// tested and failed./// ICETransportStateClosed indicates the ICETransport has shut down/// and is no longer responding to STUN requests./// ICETransportState represents the current state of the ICE transport./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCIceTransport/state/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcicetransportstateICE_TRANSPORT_STATE_NEW_STRICE_TRANSPORT_STATE_CHECKING_STRICE_TRANSPORT_STATE_CONNECTED_STRICE_TRANSPORT_STATE_COMPLETED_STRICE_TRANSPORT_STATE_FAILED_STRICE_TRANSPORT_STATE_DISCONNECTED_STRICE_TRANSPORT_STATE_CLOSED_STRtest_ice_transport_state_stringtest_ice_transport_state_converttest_ice_transport_on_selected_candidate_pair_changetest_ice_transport_get_selected_candidate_pairice_candidate_pairICETransportStatsice_transport_testice_gathering_stateOnConnectionStateChangeHdlrFnOnSelectedCandidatePairChangeHdlrFn//AgentConncancel_txICETransportInternalon_connection_state_change_handleron_selected_candidate_pair_change_handler// ICETransportState/// ICETransport allows an application access to information about the ICE/// transport over which packets are sent and received./// creates a new new_icetransport.get_selected_candidate_pair/// get_selected_candidate_pair returns the selected candidate pair on which packets are sent/// if there is no selected pair nil is returned/// Start incoming connectivity checks based on its configured role./// restart is not exposed currently because ORTC has users create a whole new ICETransport/// so for now lets keep it private so we don't cause ORTC users to depend on non-standard APIs/// Stop irreversibly stops the ICETransport.on_selected_candidate_pair_change/// on_selected_candidate_pair_change sets a handler that is invoked when a new/// ICE candidate pair is selectedon_connection_state_change/// on_connection_state_change sets a handler that is fired when the ICE/// Role indicates the current role of the ICE transport.set_remote_candidates/// set_remote_candidates sets the sequence of candidates associated with the remote ICETransport.add_remote_candidate/// adds a candidate associated with the remote ICETransport./// State returns the current ice transport state.new_endpointensure_gathererhave_remote_credentials_changeset_remote_credentials/// [`peer_connection::RTCPeerConnection`] allows to establish connection between two peers given RTC configuration. Its API is similar to one in JavaScript./// The utilities defining transport between peers. Contains [`ice_transport::ice_server::RTCIceServer`] struct which describes how peer does ICE (Interactive Connectivity Establishment)./// WebRTC DataChannel can be used for peer-to-peer transmitting arbitrary binary data./// Module responsible for multiplexing data streams of different protocols on one socket. Custom [`mux::endpoint::Endpoint`] with [`mux::mux_func::MatchFunc`] can be used for parsing your application-specific byte stream./// Measuring connection statistics, such as amount of data transmitted or round trip time./// [`Error`] enumerates WebRTC problems, [`error::OnErrorHdlrFn`] defines type for callback-logger./// Set of constructors for WebRTC primitives. Subject to deprecation in future.UNSPECIFIED_STR/// Equal to UDP MTUSDP_ATTRIBUTE_RIDSDP_ATTRIBUTE_SIMULCASTGENERATED_CERTIFICATE_ORIGIN// TODO: why is this public? does someone really extend WebRTC stack?match_fnnext_conn/// Endpoint implements net.Conn. It is used to read muxed packets./// Close unregisters the endpoint from the Mux" reads a packet of len(p) bytes from the underlying conn"" that are matched by the associated MuxFunc"" writes bytes to the underlying conn"mux_test/// mux multiplexes packets on a single socket (RFC7983)/// The maximum amount of data that can be buffered before returning errors./// Config collects the arguments to mux.Mux construction into/// a single structureclosed_ch_tx/// Mux allows multiplexing/// creates a new Endpointremove_endpoint/// remove_endpoint removes an endpoint from the Mux/// Close closes the Mux and all associated Endpoints.// 1MB/// MatchFunc allows custom logic for mapping packets to an Endpointmatch_all/// match_all always returns truematch_range/// match_range is a MatchFunc that accepts packets with the first byte in [lower..upper]/// MatchFuncs as described in RFC7983/// <https://tools.ietf.org/html/rfc7983>///              +----------------+///              |        [0..3] -+--> forward to STUN///              |                |///              |      [16..19] -+--> forward to ZRTP///  packet -->  |      [20..63] -+--> forward to DTLS///              |      [64..79] -+--> forward to TURN Channel///              |    [128..191] -+--> forward to RTP/RTCP/// match_dtls is a MatchFunc that accepts packets with the first byte in [20..63]/// as defined in RFC7983match_srtp_or_srtcp// match_srtp_or_srtcp is a MatchFunc that accepts packets with the first byte in [128..191]// as defined in RFC7983is_rtcp/// match_srtp is a MatchFunc that only matches SRTP and not SRTCP/// match_srtcp is a MatchFunc that only matches SRTCP and not SRTPTEST_PIPE_BUFFER_SIZEtest_no_endpointsMuxErrorConntest_non_fatal_readtest_non_fatal_dispatchmath_rand_alphaCertificateStatsdtls_certificate/// DTLS certificate./// Timestamp after which this certificate is no longer valid./// Certificate's ID used for statistics./// Example: "certificate-1667202302853538793"/// See [`CertificateStats`]./// Certificate represents a X.509 certificate used to authenticate WebRTC communications./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtccertificate/// Generates a new certificate from the given parameters./// Generates a new certificate with default [`CertificateParams`] using the given keypair./// Builds a [`RTCCertificate`] using the existing DTLS certificate./// Use this method when you have a persistent certificate (i.e. you don't want to generate a/// new one for each DTLS connection)./// NOTE: ID used for statistics will be different as it's neither derived from the given/// certificate nor persisted along it when using [`RTCCertificate::serialize_pem`].get_fingerprints/// get_fingerprints returns a SHA-256 fingerprint of this certificate./// TODO: return a fingerprint computed with the digest algorithm used in the certificategen_stats_idtest_generate_certificate_rsatest_generate_certificate_ecdsatest_generate_certificate_eddsatest_certificate_equaltest_generate_certificate_expires_and_stats_idbundle_policyRTCBundlePolicyrtcp_mux_policyRTCRtcpMuxPolicy/// iceservers defines a slice describing servers available to be used by/// ICE, such as STUN and TURN servers./// icetransport_policy indicates which candidates the ICEAgent is allowed/// to use./// bundle_policy indicates which media-bundling policy to use when gathering/// ICE candidates./// rtcp_mux_policy indicates which rtcp-mux policy to use when gathering ICE/// peer_identity sets the target peer identity for the PeerConnection./// The PeerConnection will not establish a connection to a remote peer/// unless it can be successfully authenticated with the provided name./// Certificates describes a set of certificates that the PeerConnection/// uses to authenticate. Valid values for this parameter are created/// through calls to the generate_certificate function. Although any given/// DTLS connection will use only one certificate, this attribute allows the/// caller to provide multiple certificates that support different/// algorithms. The final certificate will be selected based on the DTLS/// handshake, which establishes which certificates are allowed. The/// PeerConnection implementation selects which of the certificates is/// used for a given connection; how certificates are selected is outside/// the scope of this specification. If this value is absent, then a default/// set of certificates is generated for each PeerConnection instance.ice_candidate_pool_size/// icecandidate_pool_size describes the size of the prefetched ICE pool./// A Configuration defines how peer-to-peer communication via PeerConnection/// is established or re-established./// Configurations may be set up once and reused across multiple connections./// Configurations are treated as readonly. As long as they are unmodified,/// they are safe for concurrent use./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcconfiguration-dictionaryget_ice_servers/// get_iceservers side-steps the strict parsing mode of the ice package/// (as defined in https://tools.ietf.org/html/rfc7064) by copying and then/// stripping any erroneous queries from "stun(s):" URLs before parsing.test_configuration_get_iceservers/*TODO:#[test] fn test_configuration_json() {

         let j = r#"
            {
                "iceServers": [{"URLs": ["turn:turn.example.org"],
                                "username": "jch",
                                "credential": "topsecret"
                              }],
                "iceTransportPolicy": "relay",
                "bundlePolicy": "balanced",
                "rtcpMuxPolicy": "require"
            }"#;

        conf := Configuration{
            ICEServers: []ICEServer{
                {
                    URLs:       []string{"turn:turn.example.org"},
                    Username:   "jch",
                    Credential: "topsecret",
                },
            },
            ICETransportPolicy: ICETransportPolicyRelay,
            BundlePolicy:       BundlePolicyBalanced,
            RTCPMuxPolicy:      RTCPMuxPolicyRequire,
        }

        var conf2 Configuration
        assert.NoError(t, json.Unmarshal([]byte(j), &conf2))
        assert.Equal(t, conf, conf2)

        j2, err := json.Marshal(conf2)
        assert.NoError(t, err)

        var conf3 Configuration
        assert.NoError(t, json.Unmarshal(j2, &conf3))
        assert.Equal(t, conf2, conf3)
    }*/offer_answer_options/// Custom media-related options, such as `voice_activity_detection`, which are negotiated while establishing connection./// [`RTCSessionDescription`] - wrapper for SDP text and negotiations stage ([`RTCSdpType`]: offer - pranswer - answer - rollback).peer_connection_internalunmarshal_candidateRTCAnswerOptionsRTCOfferOptionsOperationsNegotiationNeededStatesession_descriptionRTCSessionDescriptioncheck_next_signaling_stateStateChangeOpfind_by_midsatisfy_type_and_directionRTCRtpTransceiverRTCRtpTransceiverInitsctp_transport_stateRTCSctpTransportStateStatsReporttrack_remoteTrackRemoteSIMULCAST_PROBE_COUNT/// SIMULCAST_PROBE_COUNT is the amount of RTP Packets/// that handleUndeclaredSSRC will read and try to dispatch from/// mid and rid valuesSIMULCAST_MAX_PROBE_ROUTINES/// SIMULCAST_MAX_PROBE_ROUTINES is how many active routines can be used to probe/// If the total amount of incoming SSRCes exceeds this new requests will be ignoredMEDIA_SECTION_APPLICATIONRUNES_ALPHA/// math_rand_alpha generates a mathematical random alphabet sequence of the requested length.OnSignalingStateChangeHdlrFnOnICEConnectionStateChangeHdlrFnOnPeerConnectionStateChangeHdlrFnOnDataChannelHdlrFnOnTrackHdlrFnOnNegotiationNeededHdlrFnon_peer_connection_state_change_handlerStartTransportsParamsrtp_transceiverscurrent_local_descriptioncurrent_remote_descriptionCheckNegotiationNeededParamson_negotiation_needed_handlernegotiation_needed_stateis_negotiation_neededcheck_negotiation_needed_paramsNegotiationNeededParamsidp_login_urlinterceptor_rtcp_writerPeerConnectionInternal/// PeerConnection represents a WebRTC connection that establishes a/// peer-to-peer communications with another PeerConnection instance in a/// browser, or to another endpoint implementing the required protocols./// creates a PeerConnection with the default codecs and/// interceptors.  See register_default_codecs and register_default_interceptors./// If you wish to customize the set of available codecs or the set of/// active interceptors, create a MediaEngine and call api.new_peer_connectioninit_configuration/// init_configuration defines validation of the specified Configuration and/// its assignment to the internal configuration variable. This function differs/// from its set_configuration counterpart because most of the checks do not/// include verification statements related to the existing state. Thus the/// function describes only minor verification of some the struct variables.on_signaling_state_change/// on_signaling_state_change sets an event handler which is invoked when the/// peer connection's signaling state changesdo_signaling_state_changeon_data_channel/// on_data_channel sets an event handler which is invoked when a data/// channel message arrives from a remote peer.on_negotiation_needed/// on_negotiation_needed sets an event handler which is invoked when/// a change has occurred which requires session negotiationdo_negotiation_needed_innerdo_negotiation_needed/// do_negotiation_needed enqueues negotiation_needed_op if necessary/// caller of this method should hold `pc.mu` lockafter_negotiation_needed_opnegotiation_needed_opcheck_negotiation_neededon_ice_candidate/// on_ice_candidate sets an event handler which is invoked when a new ICE/// candidate is found./// Take note that the handler is gonna be called with a nil pointer when/// gathering is finished.on_ice_gathering_state_change/// on_ice_gathering_state_change sets an event handler which is invoked when the/// ICE candidate gathering state has changed.on_track/// on_track sets an event handler which is called when remote track/// arrives from a remote peer.do_trackon_ice_connection_state_change/// on_ice_connection_state_change sets an event handler which is called/// when an ICE connection state is changed.do_ice_connection_state_changeon_peer_connection_state_change/// on_peer_connection_state_change sets an event handler which is called/// when the PeerConnectionState has changeddo_peer_connection_state_changerestart_ice/// restart_ice restart ICE and triggers negotiation needed/// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-restartice>set_configuration// set_configuration updates the configuration of this PeerConnection object.get_configuration/// get_configuration returns a Configuration object representing the current/// configuration of this PeerConnection object. The returned object is a/// copy and direct mutation on it will not take affect until set_configuration/// has been called with Configuration passed as its only argument./// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-getconfiguration>create_offer/// create_offer starts the PeerConnection and generates the localDescription/// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-createoffer>update_connection_state/// Update the PeerConnectionState given the state of relevant transports/// <https://www.w3.org/TR/webrtc/#rtcpeerconnectionstate-enum>create_answer/// create_answer starts the PeerConnection and generates the localDescription// 4.4.1.6 Set the SessionDescriptionset_local_description/// set_local_description sets the SessionDescription of the local peerlocal_description/// local_description returns PendingLocalDescription if it is not null and/// otherwise it returns CurrentLocalDescription. This property is used to/// determine if set_local_description has already been called./// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-localdescription>is_lite_setset_remote_description/// set_remote_description sets the SessionDescription of the remote peerstart_rtp_senders/// start_rtp_senders starts all outbound RTP streamsremote_description/// remote_description returns pending_remote_description if it is not null and/// otherwise it returns current_remote_description. This property is used to/// determine if setRemoteDescription has already been called./// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-remotedescription>add_ice_candidate/// add_ice_candidate accepts an ICE candidate string and adds it/// to the existing set of candidates./// ice_connection_state returns the ICE connection state of the/// PeerConnection instance.get_senders/// get_senders returns the RTPSender that are currently attached to this PeerConnectionget_receivers/// get_receivers returns the RTPReceivers that are currently attached to this PeerConnectionget_transceivers/// get_transceivers returns the RtpTransceiver that are currently attached to this PeerConnectionadd_track/// add_track adds a Track to the PeerConnectionremove_track/// remove_track removes a Track from the PeerConnectionadd_transceiver_from_kind/// add_transceiver_from_kind Create a new RtpTransceiver and adds it to the set of transceivers.add_transceiver_from_track/// add_transceiver_from_track Create a new RtpTransceiver(SendRecv or SendOnly) and add it to the set of transceivers.create_data_channel/// create_data_channel creates a new DataChannel object with the given label/// and optional DataChannelInit used to configure properties of the/// underlying channel such as data reliability.set_identity_provider/// set_identity_provider is used to configure an identity provider to generate identity assertions/// packet is discarded. It also runs any configured interceptors./// close ends the PeerConnection/// CurrentLocalDescription represents the local description that was/// successfully negotiated the last time the PeerConnection transitioned/// into the stable state plus any local candidates that have been generated/// by the ICEAgent since the offer or answer was created.pending_local_description/// PendingLocalDescription represents a local description that is in the/// process of being negotiated plus any local candidates that have been/// generated by the ICEAgent since the offer or answer was created. If the/// PeerConnection is in the stable state, the value is null./// current_remote_description represents the last remote description that was/// into the stable state plus any remote candidates that have been supplied/// via add_icecandidate() since the offer or answer was created.pending_remote_description/// pending_remote_description represents a remote description that is in the/// process of being negotiated, complete with any remote candidates that/// have been supplied via add_icecandidate() since the offer or answer was/// created. If the PeerConnection is in the stable state, the value is/// null./// signaling_state attribute returns the signaling state of the/// icegathering_state attribute returns the ICE gathering state of the/// connection_state attribute returns the connection state of the/// sctp returns the SCTPTransport for this PeerConnection/// The SCTP transport over which SCTP data is sent and received. If SCTP has not been negotiated, the value is nil./// <https://www.w3.org/TR/webrtc/#attributes-15>gathering_complete_promise/// gathering_complete_promise is a Pion specific helper function that returns a channel that is closed when gathering is complete./// This function may be helpful in cases where you are unable to trickle your ICE Candidates./// It is better to not use this function, and instead trickle candidates. If you use this function you will see longer connection startup times./// When the call is connected you will see no impact however./// Returns the internal [`RTCDtlsTransport`].add_transceiver/// Adds the specified [`RTCRtpTransceiver`] to this [`RTCPeerConnection`].voice_activity_detection/// voice_activity_detection allows the application to provide information/// about whether it wishes voice detection feature to be enabled or disabled./// AnswerOptions structure describes the options used to control the answer/// creation process.ice_restart/// ice_restart forces the underlying ice gathering process to be restarted./// When this value is true, the generated description will have ICE/// credentials that are different from the current credentials/// OfferOptions structure describes the options used to control the offer/// creation process/// [W3C]: https://w3c.github.io/webrtc-pc/#dictionary-rtcofferoptions-membersoperation_test/// Operation is a functionops_tx/// Operations is a task executor./// enqueue adds a new action to be executed. If there are no actions scheduled,/// the execution will start immediately in a new goroutine.enqueue_inner/// is_empty checks if there are tasks in the queue/// Done blocks until all currently enqueued operations are finished executing./// For more complex synchronization, use Enqueue directly.test_operations_enqueuetest_operations_donecreate_stream_infoInboundRTPStatsOutboundRTPStatsRTCStatsTypeRemoteInboundRTPStatsRemoteOutboundRTPStatstrack_local_static_sampleTrackLocalStaticSampleTrackStreamgreater_mid/// a value containing the last known greater mid value/// we internally generate mids as numbers. Needed since JSEP/// requires that when reusing a media section a new unique mid/// should be defined (see JSEP 3.4.1).sdp_originlast_offerlast_answer/// ops is an operations queue which will ensure the enqueued actions are/// executed in order. It is used for asynchronously, but serially processing/// remote and local descriptionson_track_handleron_signaling_state_change_handleron_ice_connection_state_change_handleron_data_channel_handler// A reference to the associated API state used by this connectionstats_interceptorstart_rtpundeclared_media_processor/// undeclared_media_processor handles RTP/RTCP packets that don't match any a:ssrc linesstart_rtp_receiversTrackDetails/// start_rtp_receivers opens knows inbound SRTP streams from the remote_descriptionstart_sctp/// Start SCTP subsystemnew_transceiver_from_trackadd_rtp_transceiver/// add_rtp_transceiver appends t into rtp_transceivers/// and fires onNegotiationNeeded;/// caller of this method should hold `self.mu` locktrigger_negotiation_needed/// Helper to trigger a negotiation needed.create_negotiation_needed_params/// Creates the parameters needed to trigger a negotiation needed.make_negotiation_needed_triggerset_gather_complete_handlerstart_transports/// Start all transports. PeerConnection now has enough stategenerate_unmatched_sdp/// generate_unmatched_sdp generates an SDP that doesn't take remote state into account/// This is used for the initial call for CreateOffergenerate_matched_sdp/// generate_matched_sdp generates a SDP and takes the remote state into account/// this is used everytime we have a remote_descriptionhandle_undeclared_ssrchandle_incoming_rtp_streamstart_receiverhas_local_description_changed/// has_local_description_changed returns whether local media (rtp_transceivers) has changedcollect_inbound_statscollect_outbound_statsget_stream_mid_rid/// PeerConnectionStateNew indicates that any of the ICETransports or/// DTLSTransports are in the "new" state and none of the transports are/// in the "connecting", "checking", "failed" or "disconnected" state, or/// all transports are in the "closed" state, or there are no transports./// PeerConnectionStateConnecting indicates that any of the/// ICETransports or DTLSTransports are in the "connecting" or/// "checking" state and none of them is in the "failed" state./// PeerConnectionStateConnected indicates that all ICETransports and/// DTLSTransports are in the "connected", "completed" or "closed" state/// and at least one of them is in the "connected" or "completed" state./// PeerConnectionStateDisconnected indicates that any of the/// ICETransports or DTLSTransports are in the "disconnected" state/// and none of them are in the "failed" or "connecting" or "checking" state./// PeerConnectionStateFailed indicates that any of the ICETransports/// or DTLSTransports are in a "failed" state./// PeerConnectionStateClosed indicates the peer connection is closed/// and the isClosed member variable of PeerConnection is true./// PeerConnectionState indicates the state of the PeerConnection./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/connectionState/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-peerconnection-connection-statePEER_CONNECTION_STATE_NEW_STRPEER_CONNECTION_STATE_CONNECTING_STRPEER_CONNECTION_STATE_CONNECTED_STRPEER_CONNECTION_STATE_DISCONNECTED_STRPEER_CONNECTION_STATE_FAILED_STRPEER_CONNECTION_STATE_CLOSED_STR/// NegotiationNeededStateEmpty not running and queue is empty/// NegotiationNeededStateEmpty running and queue is empty/// NegotiationNeededStateEmpty running and queuetest_new_peer_connection_statetest_peer_connection_state_stringNetConfigRouterConfigtrack_local_static_rtpTrackLocalStaticRTPcreate_vnet_pair/// new_pair creates two new peer connections (an offerer and an answerer)/// *without* using an api (i.e. using the default settings).close_pairsend_video_until_donetest_get_statstest_peer_connection_close_is_sendtest_set_get_configurationtest_peer_connection_simulcast_no_data_channeltest_peer_connection_state/*
func offerMediaHasDirection(offer SessionDescription, kind RTPCodecType, direction RTPTransceiverDirection) bool {
    parsed := &sdp.SessionDescription{}
    if err := parsed.Unmarshal([]byte(offer.SDP)); err != nil {
        return false
    }

    for _, media := range parsed.MediaDescriptions {
        if media.MediaName.Media == kind.String() {
            _, exists := media.Attribute(direction.String())
            return exists
        }
    }
    return false
}*//// BundlePolicyBalanced indicates to gather ICE candidates for each/// media type in use (audio, video, and data). If the remote endpoint is/// not bundle-aware, negotiate only one audio and video track on separate/// transports.MaxCompat/// BundlePolicyMaxCompat indicates to gather ICE candidates for each/// track. If the remote endpoint is not bundle-aware, negotiate all media/// tracks on separate transports.MaxBundle/// BundlePolicyMaxBundle indicates to gather ICE candidates for only/// one track. If the remote endpoint is not bundle-aware, negotiate only/// one media track./// BundlePolicy affects which media tracks are negotiated if the remote/// endpoint is not bundle-aware, and what ICE candidates are gathered. If the/// remote endpoint is bundle-aware, all media tracks and data channels are/// bundled onto the same transport./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcbundlepolicy-enumBUNDLE_POLICY_BALANCED_STR/// This is done this way because of a linter.BUNDLE_POLICY_MAX_COMPAT_STRBUNDLE_POLICY_MAX_BUNDLE_STR/// NewSchemeType defines a procedure for creating a new SchemeType from a raw/// string naming the scheme type.test_new_bundle_policytest_bundle_policy_string/// ICETransportPolicyAll indicates any type of candidate is used./// ICETransportPolicyRelay indicates only media relay candidates such/// as candidates passing through a TURN server are used./// ICETransportPolicy defines the ICE candidate policy surface the/// permitted candidates. Only these candidates are used for connectivity checks./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcicetransportpolicy-enumICEGatherPolicy/// ICEGatherPolicy is the ORTC equivalent of ICETransportPolicyICE_TRANSPORT_POLICY_RELAY_STRICE_TRANSPORT_POLICY_ALL_STR/// takes a string and converts it to ICETransportPolicytest_new_ice_transport_policytest_ice_transport_policy_stringsdp_semanticsNegotiate/// RTCPMuxPolicyNegotiate indicates to gather ICE candidates for both/// RTP and RTCP candidates. If the remote-endpoint is capable of/// multiplexing RTCP, multiplex RTCP on the RTP candidates. If it is not,/// use both the RTP and RTCP candidates separately./// RTCPMuxPolicyRequire indicates to gather ICE candidates only for/// RTP and multiplex RTCP on the RTP candidates. If the remote endpoint is/// not capable of rtcp-mux, session negotiation will fail./// RTCPMuxPolicy affects what ICE candidates are gathered to support/// non-multiplexed RTCP./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcrtcpmuxpolicy-enumRTCP_MUX_POLICY_NEGOTIATE_STRRTCP_MUX_POLICY_REQUIRE_STRtest_new_rtcp_mux_policytest_rtcp_mux_policy_stringRTCSdpSemanticsUnifiedPlan/// UnifiedPlan uses unified-plan offers and answers/// (the default in Chrome since M72)/// <https://tools.ietf.org/html/draft-roach-mmusic-unified-plan-00>PlanB/// PlanB uses plan-b offers and answers/// NB: This format should be considered deprecated/// <https://tools.ietf.org/html/draft-uberti-rtcweb-plan-00>UnifiedPlanWithFallback/// UnifiedPlanWithFallback prefers unified-plan/// offers and answers, but will respond to a plan-b offer/// with a plan-b answer/// SDPSemantics determines which style of SDP offers and answers/// can be used./// This is unused, we only support UnifiedPlan.SDP_SEMANTICS_UNIFIED_PLAN_WITH_FALLBACKSDP_SEMANTICS_UNIFIED_PLANSDP_SEMANTICS_PLAN_Btest_sdp_semantics_stringget_md_names// The following tests are for non-standard SDP semantics// (i.e. not unified-unified)extract_ssrc_listsdp_testrepair_ssrcrids/// TrackDetails represents any media source that can be represented in a SDP/// This isn't keyed by SSRC because it also needs to support rid based sourcestrack_details_for_ssrctrack_details_for_ridfilter_track_with_ssrctrack_details_from_sdp/// extract all TrackDetails from an SDP.get_ridsSimulcastRidadd_candidates_to_media_descriptionsshould_add_candidatesmid_valueice_paramsAddDataMediaSectionParamsadd_data_media_sectionpopulate_local_candidatesoffered_directionAddTransceiverSdpParamsadd_transceiver_sdpMediaSectionSimulcastRidParseErrorSyntaxIdDirSplit/// SyntaxIdDirSplit indicates rid-syntax could not be parsed.UnknownDirection/// UnknownDirection indicates rid-dir was not parsed. Should be "send" or "recv".SimulcastDirectionpausedbundle_matchtransceiversrid_mapextmap_allow_mixedmedia_description_fingerprintis_iceliteconnection_rolematch_bundle_groupPopulateSdpParamspopulate_sdp/// populate_sdp serializes a PeerConnections state into an SDPget_mid_valueget_peer_directionextract_fingerprintextract_ice_detailsget_application_media_section_sctp_portget_application_media_section_max_message_sizeget_by_midget_application_mediahave_data_channel/// have_data_channel return MediaDescription with MediaName equal applicationupdate_sdp_origin/// update_sdp_origin saves sdp.Origin in PeerConnection when creating 1st local SDP;/// for subsequent calling, it updates Origin for SessionDescription from saved one/// and increments session version by one./// <https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-25#section-5.2.2>test_extract_fingerprinttest_extract_ice_detailstest_track_details_from_sdptest_have_application_media_sectiontest_media_description_fingerprintstest_populate_sdptest_populate_sdp_rejecttest_get_ridstest_codecs_from_media_descriptiontest_rtp_extensions_from_media_description/// indicates that a description MUST be treated as an SDP offer.Pranswer/// indicates that a description MUST be treated as an/// SDP answer, but not a final answer. A description used as an SDP/// pranswer may be applied as a response to an SDP offer, or an update to/// a previously sent SDP pranswer.Answer/// indicates that a description MUST be treated as an SDP/// final answer, and the offer-answer exchange MUST be considered complete./// A description used as an SDP answer may be applied as a response to an/// SDP offer or as an update to a previously sent SDP pranswer.    Rollback/// indicates that a description MUST be treated as/// canceling the current SDP negotiation and moving the SDP offer and/// answer back to what it was in the previous stable state. Note the/// local or remote SDP descriptions in the previous stable state could be/// null if there has not yet been a successful offer-answer negotiation./// SDPType describes the type of an SessionDescription./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCSessionDescription/type/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcsessiondescription-typeSDP_TYPE_OFFER_STRSDP_TYPE_PRANSWER_STRSDP_TYPE_ANSWER_STRSDP_TYPE_ROLLBACK_STR/// creates an SDPType from a stringtest_new_sdp_typetest_sdp_type_string/// This will never be initialized by callers, internal use only/// SessionDescription is used to expose local and remote session descriptions./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCSessionDescription/// [W3C]: https://w3c.github.io/webrtc-pc/#rtcsessiondescription-class/// Given SDP representing an answer, wrap it in an RTCSessionDescription/// that can be given to an RTCPeerConnection./// Given SDP representing an offer, wrap it in an RTCSessionDescriptionpranswer/// that can be given to an RTCPeerConnection. `pranswer` is used when the/// answer may not be final, or when updating a previously sent pranswer./// Unmarshal is a helper to deserialize the sdptest_session_description_jsontest_session_description_answertest_session_description_offertest_session_description_pranswertest_session_description_unmarshalSetLocalSetRemote/// SignalingStateStable indicates there is no offer/answer exchange in/// progress. This is also the initial state, in which case the local and/// remote descriptions are nil.HaveLocalOffer/// SignalingStateHaveLocalOffer indicates that a local description, of/// type "offer", has been successfully applied.HaveRemoteOffer/// SignalingStateHaveRemoteOffer indicates that a remote description, ofHaveLocalPranswer/// SignalingStateHaveLocalPranswer indicates that a remote description/// of type "offer" has been successfully applied and a local description/// of type "pranswer" has been successfully applied.HaveRemotePranswer/// SignalingStateHaveRemotePranswer indicates that a local description/// of type "offer" has been successfully applied and a remote description/// SignalingStateClosed indicates The PeerConnection has been closed./// SignalingState indicates the signaling state of the offer/answer process./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/signalingState/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-peerconnection-signaling-stateSIGNALING_STATE_STABLE_STRSIGNALING_STATE_HAVE_LOCAL_OFFER_STRSIGNALING_STATE_HAVE_REMOTE_OFFER_STRSIGNALING_STATE_HAVE_LOCAL_PRANSWER_STRSIGNALING_STATE_HAVE_REMOTE_PRANSWER_STRSIGNALING_STATE_CLOSED_STRtest_new_signaling_statetest_signaling_state_stringtest_signaling_state_transitionstest_generic_fmtp_parsetest_generic_fmtp_comparetest_generic_fmtp_compare_mime_type_case_mismatchgeneric_testfmtp_consist/// fmtp_consist checks that two FMTP parameters are not inconsistent.GenericFmtpmatch_fmtpFmtp/// Match returns true if g and b are compatible fmtp descriptions/// The generic implementation is used for MimeTypes that are not definedtest_h264_fmtp_parsetest_h264_fmtp_compareprofile_level_id_matchesH264Fmtp/// Match returns true if h and b are compatible fmtp descriptions/// Based on RFC6184 Section 8.2.2:///   The parameters identifying a media format configuration for H.264///   are profile-level-id and packetization-mode.  These media format///   configuration parameters (except for the level part of profile-///   level-id) MUST be used symmetrically; that is, the answerer MUST///   either maintain all configuration parameters or remove the media///   format (payload type) completely if one or more of the parameter///   values are not supported.///     Informative note: The requirement for symmetric use does not///     apply for the level part of profile-level-id and does not apply///     for the other stream properties and capability parameters./// mime_type returns the mime_type associated with/// the fmtp/// match_fmtp compares two fmtp descriptions for/// compatibility based on the mime_type    /// parameter returns a value for the associated key/// if contained in the parsed fmtp string/// Fmtp interface for implementing custom/// Fmtp parsers based on mime_type/// parse parses an fmtp string based on the MimeTypertp_transceiver_testRTPReceiverInternalsrtp_writer_future/// SSRC represents a synchronization source/// A synchronization source is a randomly chosen/// value meant to be globally unique within a particular/// RTP session. Used to identify a single stream of media./// <https://tools.ietf.org/html/rfc3550#section-3>/// PayloadType identifies the format of the RTP payload and determines/// its interpretation by the application. Each codec in a RTP Session/// will have a different PayloadType/// TYPE_RTCP_FBT_RANSPORT_CC ..TYPE_RTCP_FB_GOOG_REMB/// TYPE_RTCP_FB_GOOG_REMB ..TYPE_RTCP_FB_ACK/// TYPE_RTCP_FB_ACK ..TYPE_RTCP_FB_CCM/// TYPE_RTCP_FB_CCM ..TYPE_RTCP_FB_NACK/// TYPE_RTCP_FB_NACK ../// rtcpfeedback signals the connection to use additional RTCP packet types.RTCRtpCapabilities/// RTPCapabilities represents the capabilities of a transceiver/// <https://w3c.github.io/webrtc-pc/#rtcrtpcapabilities>RTCRtpRtxParameters/// RTPRtxParameters dictionary contains information relating to retransmission (RTX) settings./// <https://draft.ortc.org/#dom-rtcrtprtxparameters>rtxRTCRtpCodingParameters/// RTPCodingParameters provides information relating to both encoding and decoding./// This is a subset of the RFC since Pion WebRTC doesn't implement encoding/decoding itself/// <http://draft.ortc.org/#dom-rtcrtpcodingparameters>RTCRtpDecodingParameters/// RTPDecodingParameters provides information relating to both encoding and decoding./// This is a subset of the RFC since Pion WebRTC doesn't implement decoding itself/// <http://draft.ortc.org/#dom-rtcrtpdecodingparameters>RTCRtpEncodingParameters/// RTPEncodingParameters provides information relating to both encoding and decoding./// This is a subset of the RFC since Pion WebRTC doesn't implement encoding itself/// <http://draft.ortc.org/#dom-rtcrtpencodingparameters>RTCRtpReceiveParameters/// RTPReceiveParameters contains the RTP stack settings used by receiversrtp_parametersRTCRtpSendParameters/// RTPSendParameters contains the RTP stack settings used by receiverssend_encodings// Streams       []*Track/// RTPTransceiverInit dictionary is used when calling the WebRTC function addTransceiver() to provide configuration options for the new transceiver.TriggerNegotiationNeededFnOption//atomic.Valuecurrent_direction//RTPTransceiverDirection// User provided codecs via set_codec_preferences/// RTPTransceiver represents a combination of an RTPSender and an RTPReceiver that share a common mid.set_codec_preferences/// set_codec_preferences sets preferred list of supported codecs/// if codecs is empty or nil we reset to default from MediaEngineget_codecs/// Codecs returns list of supported codecs/// sender returns the RTPTransceiver's RTPSender if it has oneset_sender_track/// set_sender_track sets the RTPSender and Track to current transceiver/// receiver returns the RTPTransceiver's RTPReceiver if it has oneset_receiverset_mid/// set_mid sets the RTPTransceiver's mid. If it was already set, will return an error./// mid gets the Transceiver's mid value. When not already set, this value will be set in CreateOffer or create_answer./// kind returns RTPTransceiver's kind./// direction returns the RTPTransceiver's desired direction./// Set the direction of this transceiver. This might trigger a renegotiation.set_direction_internal/// current_direction returns the RTPTransceiver's current direction as negotiated./// If this transceiver has never been negotiated or if it's stopped this returns [`RTCRtpTransceiverDirection::Unspecified`].set_current_directionprocess_new_current_direction/// Perform any subsequent actions after altering the transceiver's direction./// After changing the transceiver's direction this method should be called to perform any/// side-effects that results from the new direction, such as pausing/resuming the RTP receiver./// stop irreversibly stops the RTPTransceiverset_sending_track/// Given a direction+type pluck a transceiver from the passed list/// if no entry satisfies the requested type+direction return a inactive Transceiver/// RTPCodecTypeAudio indicates this is an audio codec/// RTPCodecTypeVideo indicates this is a video codec/// RTPCodecType determines the type of a codec/// RTPCodecCapability provides information about codec capabilities./// [W3C]: https://w3c.github.io/webrtc-pc/#dictionary-rtcrtpcodeccapability-memberspayloader_for_codec/// Turn codec capability into a `packetizer::Payloader`/// RTPHeaderExtensionCapability is used to define a RFC5285 RTP header extension supported by the codec./// <https://w3c.github.io/webrtc-pc/#dom-rtcrtpcapabilities-headerextensions>/// RTPHeaderExtensionParameter represents a negotiated RFC5285 RTP header extension./// <https://w3c.github.io/webrtc-pc/#dictionary-rtcrtpheaderextensionparameters-members>/// RTPCodecParameters is a sequence containing the media codecs that an RtpSender/// will choose from, as well as entries for RTX, RED and FEC mechanisms. This also/// includes the PayloadType that has been negotiated/// <https://w3c.github.io/webrtc-pc/#rtcrtpcodecparameters>/// RTPParameters is a list of negotiated codecs and header extensions/// <https://w3c.github.io/webrtc-pc/#dictionary-rtcrtpparameters-members>/// Do a fuzzy find for a codec in the list of codecs/// Used for lookup up a codec in an existing list to find a match/// Returns codecMatchExact, codecMatchPartial, or codecMatchNonecodec_rtx_searchrtp_receiver_testTrackStreamsUnstarted/// We haven't started yet.UnstartedPaused/// We haven't started yet and additionally we've been paused./// We have started and are running./// We have been paused after starting./// We have been stopped.error_on_closeis_startedstate_tx// State is stored within the channelstate_rxtransceiver_codecs/// read reads incoming RTCP for this RTPReceiverread_simulcast/// read_simulcast reads incoming RTCP for this RTPReceiver for given rid/// read_rtcp is a convenience method that wraps Read and unmarshal for you./// It also runs any configured interceptors.read_simulcast_rtcp/// read_simulcast_rtcp is a convenience method that wraps ReadSimulcast and unmarshal for youget_parameters/// Get the current state and a receiver for the next state change.// State/// RTPReceiver allows an application to inspect the receipt of a TrackRemote/// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCRtpReceiver/// [W3C]: https://w3c.github.io/webrtc-pc/#rtcrtpreceiver-interfaceset_transceiver_codecs/// transport returns the currently-configured *DTLSTransport or nil/// if one has not yet been configured/// get_parameters describes the current configuration for the encoding and/// transmission of media on the receiver's track.set_rtp_parameters/// SetRTPParameters applies provided RTPParameters the RTPReceiver's tracks./// This method is part of the ORTC API. It is not/// The amount of provided codecs must match the number of tracks on the receiver./// tracks returns the RtpTransceiver traclockks/// A RTPReceiver to support Simulcast may now have multiple tracks/// receive initialize the track and starts all the transportshave_received/// Stop irreversibly stops the RTPReceiver/// read_rtp should only be called by a track, this only exists so we can keep state in one placereceive_for_rid/// receive_for_rid is the sibling of Receive expect for RIDs instead of SSRCs/// It populates all the internal state for the given RIDreceive_for_rtx/// receiveForRtx starts a routine that processes the repair stream/// These packets aren't exposed to the user yet, but we need to process them for/// TWCCtest_set_rtp_parameterstest_rtp_receiver_set_read_deadlinertp_sender_testgenerate_crypto_random_stringSequenceTransformerSrtpWriterFutureInterceptorToTrackLocalWriterTrackLocalContextstop_called_rxstop_called_signalRTPSenderInternalsrtp_streamrtcp_interceptorRtxEncodingTrackEncodingtrack_encodingsseq_transrtx_seq_transenable_rtx/// a transceiver sender since we can just check the/// transceiver negotiation statusinitial_track_id/// The id of the initial track, even if we later change to a different/// track id should be use when negotiating.associated_media_stream_ids/// AssociatedMediaStreamIds from the WebRTC specificationssend_calledstop_called_tx/// RTPSender allows an application to control how a given Track is encoded and transmitted to a remote peer/// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCRtpSender/// [W3C]: https://w3c.github.io/webrtc-pc/#rtcrtpsender-interfaceadd_encoding/// AddEncoding adds an encoding to RTPSender. Used by simulcast senders.add_encoding_internalis_negotiatedset_negotiatedset_rtp_transceiverset_paused/// transport returns the currently-configured DTLSTransport/// transmission of media on the sender's track./// track returns the RTCRtpTransceiver track, or nilreplace_track/// replace_track replaces the track currently being used as the sender's source with a new TrackLocal./// The new track must be of the same media kind (audio, video, etc) and switching the track should not/// require negotiation./// send Attempts to set the parameters controlling the sending of media.receive_rtcp_for_rtx/// starts a routine that reads the rtx rtcp stream/// These packets aren't exposed to the user, but we need to process them/// for TWCC/// stop irreversibly stops the RTPSender/// read_rtcp is a convenience method that wraps Read and unmarshals for you./// ReadSimulcast reads incoming RTCP for this RTPSender for given ridread_rtcp_simulcast/// ReadSimulcastRTCP is a convenience method that wraps ReadSimulcast and unmarshal for youenable_seq_transformer/// Enables overriding outgoing `RTP` packets' `sequence number`s./// Must be called once before any data sent or never called at all./// Errors if this [`RTCRtpSender`] has started to send data or sequence/// transforming has been already enabled.wait_for_send/// Will asynchronously block/wait until send() has been called/// Note that it could return if underlying channel is closed,/// however this shouldn't happen as we have a reference to self/// which again owns the underlying channel.has_sent/// has_sent tells if data has been ever sent for this instancehas_stopped/// has_stopped tells if stop has been calledset_initial_track_idassociate_media_stream_idtest_rtp_sender_replace_tracktest_rtp_sender_get_parameterstest_rtp_sender_get_parameters_with_ridtest_rtp_sender_set_read_deadlinetest_rtp_sender_replace_track_invalid_track_kind_changetest_rtp_sender_replace_track_invalid_codec_changetest_rtp_sender_get_parameters_replacedtest_rtp_sender_sendtest_rtp_sender_send_track_removedtest_rtp_sender_add_encodingTestInterceptorEventBindLocalBindRemoteUnbindLocalUnbindRemoteTestInterceptortest_rtp_sender_rtxSendrecv/// Sendrecv indicates the RTPSender will offer/// to send RTP and RTPReceiver the will offer to receive RTP.Sendonly/// Sendonly indicates the RTPSender will offer to send RTP.Recvonly/// Recvonly indicates the RTPReceiver the will offer to receive RTP./// Inactive indicates the RTPSender won't offer/// to send RTP and RTPReceiver the won't offer to receive RTP./// RTPTransceiverDirection indicates the direction of the RTPTransceiver./// [MDN]: https://developer.mozilla.org/en-US/docs/Web/API/RTCRtpTransceiver/direction/// [W3C]: https://w3c.github.io/webrtc-pc/#dom-rtcrtptransceiver-directionRTP_TRANSCEIVER_DIRECTION_SENDRECV_STRRTP_TRANSCEIVER_DIRECTION_SENDONLY_STRRTP_TRANSCEIVER_DIRECTION_RECVONLY_STRRTP_TRANSCEIVER_DIRECTION_INACTIVE_STR/// defines a procedure for creating a new/// RTPTransceiverDirection from a raw string naming the transceiver direction./// reverse indicate the opposite directionfrom_send_recvhas_sendhas_recvtest_new_rtp_transceiver_directiontest_rtp_transceiver_direction_stringtest_rtp_transceiver_has_sendtest_rtp_transceiver_has_recvtest_rtp_transceiver_from_send_recvtest_rtp_transceiver_intersecttest_rtp_transceiver_set_codec_preferencestest_rtp_transceiver_set_codec_preferences_payload_typetest_rtp_transceiver_direction_changetest_rtp_transceiver_set_direction_causing_negotiationtest_rtp_transceiver_stoppingSequenceTransformerInner/// `RTP` packet sequence number manager./// Used to override outgoing `RTP` packets' sequence numbers. On creating it is/// unabled and can be enabled before sending data beginning. Once data sending/// began it can not be enabled any more.last_sqreset_needed/// [`SequenceTransformer`] inner./// Creates a new [`SequenceTransformer`]./// Enables this [`SequenceTransformer`]./// With [`Error::ErrRTPSenderSeqTransEnabled`] on trying to enable already/// enabled [`SequenceTransformer`]./// With [`Error::ErrRTPSenderSeqTransEnabled`] on trying to enable/// [`SequenceTransformer`] after data sending began.reset_offset/// Indicates [`SequenceTransformer`] about necessity of recalculating/// `offset`.seq_number/// Gets [`Some`] consistent `sequence number` if this [`SequenceTransformer`] is/// enabled or [`None`] if it is not./// Once this method is called, considers data sending began.rtp_transportrtcp_read_streamrtp_write_session// atomic.Value // */// SrtpWriterFuture blocks Read/Write calls until/// the SRTP Session is availablesctp_transport_testassociationAssociationPeerConnectionSCTPTransportPeerConnectionStatsSCTP_MAX_CHANNELSOnDataChannelOpenedHdlrFnsctp_associationon_data_channel_opened_handlerdata_channels_openeddata_channels_acceptedAcceptDataChannelParams// State represents the current state of the SCTP transport.// SCTPTransportState doesn't have an enum to distinguish between New/Connecting// so we need a dedicated fieldmax_channels// max_channels represents the maximum amount of DataChannel's that can// be used simultaneously.// DataChannelsdata_channels_requested// RTCSctpTransportState/// SCTPTransport provides details about the SCTP transport./// transport returns the DTLSTransport instance the SCTPTransport is sending over.get_capabilities/// get_capabilities returns the SCTPCapabilities of the SCTPTransport./// Start the SCTPTransport. Since both local and remote parties must mutually/// create an SCTPTransport, SCTP SO (Simultaneous Open) is used to establish/// a connection over SCTP./// Stop stops the SCTPTransportaccept_data_channels/// the SCTP connection error occurs.on_data_channel_opened/// on_data_channel_opened sets an event handler which is invoked when a data/// channel is openedcalc_message_size/// max_channels is the maximum number of RTCDataChannels that can be open simultaneously./// state returns the current state of the SCTPTransportgenerate_and_set_data_channel_id/// SCTPTransportCapabilities indicates the capabilities of the SCTPTransport./// SCTPTransportStateConnecting indicates the SCTPTransport is in the/// process of negotiating an association. This is the initial state of the/// SCTPTransportState when an SCTPTransport is created./// SCTPTransportStateConnected indicates the negotiation of an/// association is completed./// SCTPTransportStateClosed indicates a SHUTDOWN or ABORT chunk is/// received or when the SCTP association has been closed intentionally,/// such as by closing the peer connection or applying a remote description/// that rejects data or changes the SCTP port./// SCTPTransportState indicates the state of the SCTP transport./// [W3C]: https://w3c.github.io/webrtc-pc/#rtcsctptransportstateSCTP_TRANSPORT_STATE_CONNECTING_STRSCTP_TRANSPORT_STATE_CONNECTED_STRSCTP_TRANSPORT_STATE_CLOSED_STRtest_new_sctp_transport_statetest_sctp_transport_state_stringtest_generate_data_channel_idagent_statsCandidatePairStatsCandidateStatsCandidatePairStateCandidatePairCSRCLocalCandidateRemoteCandidateRemoteInboundRTPRemoteOutboundRTPICECandidateStats// RTCStatsstats_typelocal_candidate_id// RTCIceCandidatePairStats// TODO: Add `transportId`remote_candidate_idnominatedtotal_round_trip_timecurrent_round_trip_timeavailable_outgoing_bitrateavailable_incoming_bitraterequests_receivedrequests_sentresponses_receivedresponses_sentconsent_requests_sentcircuit_breaker_trigger_count// Non-canonconsent_expired_timestampfirst_request_timestamplast_request_timestampretransmissions_sent// TODO: Add `packetsDiscardedOnSend`// TODO: Add `bytesDiscardedOnSend`candidate_type// RTCIceCandidateStatsrelay_protocol// RTCCertificateStatsfingerprint_algorithm// TODO: Add `base64Certificate` and `issuerCertificateId`.// RTCCodecStats// RTCDataChannelStatsdata_channel_identifiermessages_receivedmessages_sentdata_channels_closed// RTCPeerConnectionStats// RTCRtpStreamStats// RTCReceivedRtpStreamStatstrack_identifier// RTCInboundRtpStreamStats// TODO: `remoteId`// NB: `framesDecoded`, `frameWidth`, frameHeight`, `framesPerSecond`, `qpSum`,// `totalDecodeTime`, `totalInterFrameDelay`, and `totalSquaredInterFrameDelay` are all decoder// specific values and can't be produced since we aren't decoding.// TODO: `packetsDiscarded`. This value only makes sense if we have jitter buffer, which we// cannot assume.// TODO: `fecPacketsReceived`, `fecPacketsDiscarded`// Either "video" or "audio"// TODO: Add transportId// TODO: Add codecId// TODO: packetsLost// TODO: jitter(maybe, might be uattainable for the same reason as `framesDropped`)// NB: `framesDropped` can't be produced since we aren't decoding, might be worth introducing a// way for consumers to control this in the future.// NB: `totalProcessingDelay`, `estimatedPlayoutTimestamp`, `jitterBufferDelay`,// `jitterBufferTargetDelay`, `jitterBufferEmittedCount`, `jitterBufferMinimumDelay`,// `totalSamplesReceived`, `concealedSamples`, `silentConcealedSamples`, `concealmentEvents`,// `insertedSamplesForDeceleration`, `removedSamplesForAcceleration`, `audioLevel`,// `totalAudioEneregy`, `totalSampleDuration`, `framesReceived, and `decoderImplementation` are// all decoder specific and can't be produced since we aren't decoding.// RTCSentRtpStreamStats// RTCOutboundRtpStreamStats// NB: non-canon in browsers this is available via `RTCMediaSourceStats` which we are unlikely to implement// TODO: `mediaSourceId` and `remoteId`// NB: `qualityLimitationReason`, `qualityLimitationDurations`, and `qualityLimitationResolutionChanges` are all// encoder specific and can't be produced since we aren't encoding.// TODO: `retransmittedPacketsSent` and `retransmittedPacketsSent`// NB: `targetBitrate`, `totalEncodedBytesTarget`, `frameWidth` `frameHeight`, `framesPerSecond`, `framesSent`,// `hugeFramesSent`, `framesEncoded`, `keyFramesEncoded`, `qpSum`, and `totalEncodeTime` are// all encoder specific and can't be produced snce we aren't encoding.// TODO: `totalPacketSendDelay` time from `TrackLocalWriter::write_rtp` to being written to// socket.// NB: `encoderImplementation` is encoder specific and can't be produced since we aren't// encoding.packets_lost// RTCRemoteInboundRtpStreamStatsround_trip_timeround_trip_time_measurements// RTCRemoteOutboundRtpStreamStats// TODO: `remote_timestamp`reports_sentinstant_to_epoch_seconds/// Serializes a `tokio::time::Instant` to an approximation of epoch time in the form/// of an `f64` where the integer portion is seconds and the decimal portion is milliseconds./// For instance, `Monday, May 30, 2022 10:45:26.456 PM UTC` converts to `1653950726.456`./// Note that an `Instant` is not connected to real world time, so this conversion is/// approximate.into_reportsRTP_PAYLOAD_TYPE_BITMASKrtp_read_streamrtp_interceptorrepair_stream/// TrackStreams maintains a mapping of RTP/RTCP streams to a specific track/// a RTPReceiver may contain multiple streams if we are dealing with Simulcasttrack_local_static_test" write_rtp_with_attributes encrypts a RTP packet and writes to the connection."" attributes are delivered to the interceptor chain"write_rtp_with_attributes" write_rtp encrypts a RTP packet and writes to the connection"" write encrypts and writes a full RTP packet"" TrackLocalWriter is the Writer for outbound RTP Packets"TrackLocalWriter/// TrackLocalContext is the Context passed when a TrackLocal has been Binded/Unbinded from a PeerConnection, and used/// in Interceptors.codec_parameters/// codec_parameters returns the negotiated RTPCodecParameters. These are the codecs supported by both/// PeerConnections and the SSRC/PayloadTypes/// header_extensions returns the negotiated RTPHeaderExtensionParameters. These are the header extensions supported by/// both PeerConnections and the SSRC/PayloadTypes/// ssrc requires the negotiated SSRC of this track/// This track may have multiple if RTX is enabled/// write_stream returns the write_stream for this TrackLocal. The implementer writes the outbound/// media packets to it/// id is a unique identifier that is used for both bind/unbind/// mid returns the id of media associated with the RTP stream/// paused returns a boolean indicating whether the track is currently paused" bind should implement the way how the media data flows from the Track to the PeerConnection"" This will be called internally after signaling is complete and the list of available"" codecs has been determined"" unbind should implement the teardown logic when the track is no longer needed. This happens"" because a track has been stopped."" id is the unique identifier for this Track. This should be unique for the"" stream, but doesn\'t have to globally unique. A common example would be \'audio\' or \'video\'"" and stream_id would be \'desktop\' or \'webcam\'"" RID is the RTP Stream ID for this track."" stream_id is the group this track belongs too. This must be unique"" kind controls if this TrackLocal is audio or video"" TrackLocal is an interface that controls how the user can send media"" The user can provide their own TrackLocal implementations, or use"" the implementations in pkg/media"sender_pausedhdr_ext_idsTrackBinding/// TrackBinding is a single bind for a Track/// Bind can be called multiple times, this stores the/// result for a single bind call so that it can be used when writingis_sender_pausedinterceptor_rtp_writer/// TrackLocalStaticRTP  is a TrackLocal that has a pre-set codec and accepts RTP Packets./// If you wish to send a media.Sample use TrackLocalStaticSample/// returns a TrackLocalStaticRTP without rid.new_with_rid/// returns a TrackLocalStaticRTP with rid./// codec gets the Codec of the trackany_binding_pausedall_binding_pausedwrite_rtp_with_extensions/// write_rtp_with_extensions writes a RTP Packet to the TrackLocalStaticRTP/// If one PeerConnection fails the packets will still be sent to/// all PeerConnections. The error message will contain the ID of the failed/// PeerConnections so you can remove them/// If the RTCRtpSender direction is such that no packets should be sent, any call to this/// function are blocked internally. Care must be taken to not increase the sequence number/// while the sender is paused. While the actual _sending_ is blocked, the receiver will/// miss out when the sequence number "rolls over", which in turn will break SRTP./// Extensions that are already configured on the packet are overwritten by extensions in/// `extensions`.write_rtp_with_extensions_attributes" bind is called by the PeerConnection after negotiation is complete"" This asserts that the code requested is supported by the remote peer."" If so it setups all the state (SSRC and PayloadType) to have a call"" unbind implements the teardown logic when the track is no longer needed. This happens"" and StreamID would be \'desktop\' or \'webcam\'"" `write_rtp_with_attributes` writes a RTP Packet to the TrackLocalStaticRTP"" If one PeerConnection fails the packets will still be sent to"" all PeerConnections. The error message will contain the ID of the failed"" PeerConnections so you can remove them"" If the RTCRtpSender direction is such that no packets should be sent, any call to this"" function are blocked internally. Care must be taken to not increase the sequence number"" while the sender is paused. While the actual _sending_ is blocked, the receiver will"" miss out when the sequence number \"rolls over\", which in turn will break SRTP."" write writes a RTP Packet as a buffer to the TrackLocalStaticRTP"did_warn_about_wonky_pauseTrackLocalStaticSampleInternalrtp_track/// TrackLocalStaticSample is a TrackLocal that has a pre-set codec and accepts Samples./// If you wish to send a RTP Packet use TrackLocalStaticRTP/// returns a TrackLocalStaticSample without RID/// returns a TrackLocalStaticSample with RID/// write_sample writes a Sample to the TrackLocalStaticSamplewrite_sample_with_extensions/// Write a sample with provided RTP extensions./// Alternatively to this method [`TrackLocalStaticSample::sample_writer`] can be used instead./// See [`TrackLocalStaticSample::write_sample`]  for further details.sample_writer/// Create a builder for writing samples with additional data./// use rtp::extension::audio_level_extension::AudioLevelExtension;/// use webrtc::api::media_engine::MIME_TYPE_VP8;/// use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;/// use webrtc::track::track_local::track_local_static_sample::TrackLocalStaticSample;///     let track = TrackLocalStaticSample::new(///        RTCRtpCodecCapability {///            mime_type: MIME_TYPE_VP8.to_owned(),///            ..Default::default()///        },///        "video".to_owned(),///        "webrtc-rs".to_owned(),///     let result = track///         .sample_writer()///         .with_audio_level(AudioLevelExtension {///             level: 10,///             voice: true,///         .write_sample(&media::Sample{///              data: bytes::Bytes::new(),///              duration: Duration::from_secs(1),///              ..Default::default()///         .await;" Bind is called by the PeerConnection after negotiation is complete"'track/// Helper for writing Samples via [`TrackLocalStaticSample`] that carry extra RTP data./// Created via [`TrackLocalStaticSample::sample_writer`].with_audio_level/// Add a RTP audio level extension to all packets written for the sample./// This overwrites any previously configured audio level extension.with_video_orientation/// Add a RTP video orientation extension to all packets written for the sample./// This overwrites any previously configured video orientation extension./// Add any RTP extension to all packets written for the sample./// Write the sample to the track./// Creates one or more RTP packets with any extensions specified for each packet and sendstest_track_local_static_no_codec_intersectiontest_track_local_static_closedtest_track_local_static_payload_typetest_track_local_static_mutate_inputtest_track_local_static_binding_non_blocking/*
//TODO: func BenchmarkTrackLocalWrite(b *testing.B) {
    offerPC, answerPC, err := newPair()
    defer closePairNow(b, offerPC, answerPC)
    if err != nil {
        b.Fatalf("Failed to create a PC pair for testing")
    }

    track, err := NewTrackLocalStaticRTP(RTPCodecCapability{mime_type: MIME_TYPE_VP8}, "video", "pion")
    assert.NoError(b, err)

    _, err = offerPC.AddTrack(track)
    assert.NoError(b, err)

    _, err = answerPC.AddTransceiverFromKind(RTPCodecTypeVideo)
    assert.NoError(b, err)

    b.SetBytes(1024)

    buf := make([]byte, 1024)
    for i := 0; i < b.N; i++ {
        _, err := track.Write(buf)
        assert.NoError(b, err)
    }
}
*/TRACK_REMOTE_UNIQUE_IDOnMuteHdlrFnon_muteon_unmuteTrackRemoteInternal//PayloadType,//RTPCodecType,//SSRC,/// TrackRemote represents a single inbound source of media/// id is the unique identifier for this Track. This should be unique for the/// stream, but doesn't have to globally unique. A common example would be 'audio' or 'video'/// and StreamID would be 'desktop' or 'webcam'/// stream_id is the group this track belongs too. This must be uniqueset_stream_id/// rid gets the RTP Stream ID of this Track/// With Simulcast you will have multiple tracks with the same ID, but different RID values./// In many cases a TrackRemote will not have an RID, so it is important to assert it is non-zero/// payload_type gets the PayloadType of the trackset_payload_type/// kind gets the Kind of the trackset_kind/// ssrc gets the SSRC of the trackset_ssrcmsid/// msid gets the Msid of the trackset_codeconmuteonunmute/// Reads data from the track./// **Cancel Safety:** This method is not cancel safe. Dropping the resulting [`Future`] before/// it returns [`std::task::Poll::Ready`] will cause data loss.check_and_update_track/// check_and_update_track checks payloadType for every incoming packet/// once a different payloadType is detected the track will be updated/// read_rtp is a convenience method that wraps Read and unmarshals for you./// peek is like Read, but it doesn't discard the packet readprepopulate_peeked_data/// Set the initially peeked data for this track./// This is useful when a track is first created to populate data read from the track in the/// process of identifying the track as part of simulcast probing. Using this during other/// parts of the track's lifecycle is probably an error.fire_onmutefire_onunmuteconn_bridgebridge_process_at_least_onecreate_new_association_pairclose_association_pairpr_ordered_unordered_testtest_data_channel_channel_type_reliable_orderedtest_data_channel_channel_type_reliable_unorderedtest_data_channel_channel_type_partial_reliable_rexmittest_data_channel_channel_type_partial_reliable_rexmit_unorderedtest_data_channel_channel_type_partial_reliable_timedtest_data_channel_channel_type_partial_reliable_timed_unorderedtest_data_channel_buffered_amounttest_statstest_poll_data_channelchunk_payload_dataPayloadProtocolIdentifiermessage_channel_ackreliability_parameter/// Config is used to configure the data channel.// stats/// DataChannel represents a data channel/// Dial opens a data channels over SCTP/// Accept is used to accept incoming data channels over SCTP/// Client opens a data channel over an SCTP stream/// Server accepts a data channel over an SCTP stream/// Read reads a packet of len(p) bytes as binary data./// See [`sctp::stream::Stream::read_sctp`].read_data_channel/// ReadDataChannel reads a packet of len(p) bytes. It returns the number of bytes read and/// `true` if the data read is a string./// MessagesSent returns the number of messages sent/// MessagesReceived returns the number of messages received/// BytesSent returns the number of bytes sent/// BytesReceived returns the number of bytes receivedstream_identifier/// StreamIdentifier returns the Stream identifier associated to the stream.handle_dcep/// Write writes len(p) bytes from p as binary datawrite_data_channel/// WriteDataChannel writes len(p) bytes from pwrite_data_channel_ack/// Close closes the DataChannel and the underlying SCTP stream./// BufferedAmount returns the number of bytes of data currently queued to be/// sent over this stream./// BufferedAmountLowThreshold returns the number of bytes of buffered outgoing/// data that is considered "low." Defaults to 0./// SetBufferedAmountLowThreshold is used to update the threshold./// See BufferedAmountLowThreshold()./// OnBufferedAmountLow sets the callback handler which would be called when the/// number of bytes of outgoing data buffered is lower than the threshold.commit_reliability_paramsDEFAULT_READ_BUF_SIZE/// Default capacity of the temporary read buffer used by [`PollStream`].ReadFut/// Nothing in progress./// Reading data from the underlying stream.RemainingData/// Finished reading, but there's unread data in the temporary buffer./// State of the read `Future` in [`PollStream`].get_reading_mut/// Gets a mutable reference to the future stored inside `Reading(future)`./// Panics if `ReadFut` variant is not `Reading`.read_futwrite_futshutdown_futread_buf_capPollDataChannel/// A wrapper around around [`DataChannel`], which implements [`AsyncRead`] and/// [`AsyncWrite`]./// Both `poll_read` and `poll_write` calls allocate temporary buffers, which results in an/// additional overhead./// Constructs a new `PollDataChannel`./// Get back the inner data_channel./// Obtain a clone of the inner data_channel.set_read_buf_capacity/// Set the capacity of the temporary read buffer (default: 8192).UnexpectedEndOfBufferInvalidMessageTypeInvalidChannelTypeInvalidPayloadProtocolIdentifierErrStreamClosedDataChannelAck/// The data-part of an data-channel ACK message without the message type./// ```plain///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+///|  Message Type |///+-+-+-+-+-+-+-+-+test_channel_ack_unmarshaltest_channel_ack_marshal_sizetest_channel_ack_marshalCHANNEL_TYPE_RELIABLECHANNEL_TYPE_RELIABLE_UNORDEREDCHANNEL_TYPE_PARTIAL_RELIABLE_REXMITCHANNEL_TYPE_PARTIAL_RELIABLE_REXMIT_UNORDEREDCHANNEL_TYPE_PARTIAL_RELIABLE_TIMEDCHANNEL_TYPE_PARTIAL_RELIABLE_TIMED_UNORDEREDCHANNEL_TYPE_LENCHANNEL_PRIORITY_BELOW_NORMAL/// ChannelPriorityCHANNEL_PRIORITY_NORMALCHANNEL_PRIORITY_HIGHCHANNEL_PRIORITY_EXTRA_HIGHReliable// `Reliable` determines the Data Channel provides a// reliable in-order bi-directional communication.ReliableUnordered// `ReliableUnordered` determines the Data Channel// provides a reliable unordered bi-directional communication.PartialReliableRexmit// `PartialReliableRexmit` determines the Data Channel// provides a partially-reliable in-order bi-directional communication.// User messages will not be retransmitted more times than specified in the Reliability Parameter.PartialReliableRexmitUnordered// `PartialReliableRexmitUnordered` determines//  the Data Channel provides a partial reliable unordered bi-directional communication.PartialReliableTimed// `PartialReliableTimed` determines the Data Channel// provides a partial reliable in-order bi-directional communication.// User messages might not be transmitted or retransmitted after// a specified life-time given in milli- seconds in the Reliability Parameter.// This life-time starts when providing the user message to the protocol stack.PartialReliableTimedUnordered// The Data Channel provides a partial reliable unordered bi-directional// communication.  User messages might not be transmitted or retransmitted// after a specified life-time given in milli- seconds in the Reliability Parameter.CHANNEL_OPEN_HEADER_LENDataChannelOpen/// The data-part of an data-channel OPEN message without the message type./// | (Message Type)|  Channel Type |            Priority           |/// |                    Reliability Parameter                      |/// |         Label Length          |       Protocol Length         |/// |                             Label                             |/// |                            Protocol                           |test_channel_type_unmarshal_successtest_channel_type_unmarshal_invalidtest_channel_type_unmarshal_unexpected_end_of_buffertest_channel_type_marshal_sizetest_channel_type_marshalMARSHALED_BYTEStest_channel_open_unmarshal_successtest_channel_open_unmarshal_invalid_channel_typetest_channel_open_unmarshal_unexpected_end_of_buffertest_channel_open_unmarshal_unexpected_length_mismatchtest_channel_open_marshal_sizetest_channel_open_marshaltest_message_unmarshal_open_successtest_message_unmarshal_ack_successtest_message_unmarshal_invalid_message_typetest_message_marshal_sizetest_message_marshalMESSAGE_TYPE_ACK// The first byte in a `Message` that specifies its type:MESSAGE_TYPE_OPENMESSAGE_TYPE_LEN// A parsed DataChannel messagetest_message_type_unmarshal_open_successtest_message_type_unmarshal_ack_successtest_message_type_unmarshal_invalidtest_message_type_marshal_sizetest_message_type_marshal/// A parsed DataChannel messageDEFAULT_CHECK_INTERVAL/// The interval at which the agent performs candidate checks in the connecting phase.DEFAULT_KEEPALIVE_INTERVAL/// The interval used to keep candidates alive.DEFAULT_DISCONNECTED_TIMEOUT/// The default time till an Agent transitions disconnected.DEFAULT_FAILED_TIMEOUT/// The default time till an Agent transitions to failed after disconnected.DEFAULT_HOST_ACCEPTANCE_MIN_WAIT/// Wait time before nominating a host candidate.DEFAULT_SRFLX_ACCEPTANCE_MIN_WAIT/// Wait time before nominating a srflx candidate.DEFAULT_PRFLX_ACCEPTANCE_MIN_WAIT/// Wait time before nominating a prflx candidate.DEFAULT_RELAY_ACCEPTANCE_MIN_WAIT/// Wait time before nominating a relay candidate.DEFAULT_MAX_BINDING_REQUESTS/// Max binding request before considering a pair failed./// The number of bytes that can be buffered before we start to error.MAX_BINDING_REQUEST_TIMEOUT/// Wait time before binding requests can be deleted.default_candidate_types/// Controls how the UDP network stack works./// See [`UDPNetwork`]local_ufrag/// It is used to perform connectivity checks. The values MUST be unguessable, with at least/// 128 bits of random number generator output used to generate the password, and at least 24/// bits of output to generate the username fragment.local_pwd/// Controls mDNS behavior for the ICE agent./// Controls the hostname for this agent. If none is specified a random one will be generated.multicast_dns_dest_addr/// Control mDNS destination addressdisconnected_timeout/// Defaults to 5 seconds when this property is nil./// If the duration is 0, the ICE Agent will never go to disconnected.failed_timeout/// Defaults to 25 seconds when this property is nil./// If the duration is 0, we will never go to failed./// Determines how often should we send ICE keepalives (should be less then connectiontimeout/// above) when this is nil, it defaults to 10 seconds./// A keepalive interval of 0 means we never send keepalive packetsnetwork_types/// An optional configuration for disabling or enabling support for specific network types.candidate_types/// An optional configuration for disabling or enabling support for specific candidate types.check_interval//LoggerFactory logging.LoggerFactory/// Controls how often our internal task loop runs when in the connecting state./// Only useful for testing.max_binding_requests/// The max amount of binding requests the agent will send over a candidate pair for validation/// or nomination, if after max_binding_requests the candidate is yet to answer a binding/// request or a nomination we set the pair as failed.is_controlling/// lite agents do not perform connectivity check and only provide host candidates./// It is used along with nat1to1ips to specify which candidate type the 1:1 NAT IP addresses/// should be mapped to. If unspecified or CandidateTypeHost, nat1to1ips are used to replace/// host candidate IPs. If CandidateTypeServerReflexive, it will insert a srflx candidate (as/// if it was derived from a STUN server) with its port number being the one for the actual host/// candidate.  Other values will result in an error./// Contains a list of public IP addresses that are to be used as a host candidate or srflx/// candidate. This is used typically for servers that are behind 1:1 D-NAT (e.g. AWS EC2/// instances) and to eliminate the need of server reflexisive candidate gathering.host_acceptance_min_wait/// Specify a minimum wait time before selecting host candidates.srflx_acceptance_min_wait/// Specify a minimum wait time before selecting srflx candidates.prflx_acceptance_min_wait/// Specify a minimum wait time before selecting prflx candidates.relay_acceptance_min_wait/// Specify a minimum wait time before selecting relay candidates./// Net is the our abstracted network interface for internal development purpose only/// (see (github.com/pion/transport/vnet)[github.com/pion/transport/vnet])./// A function that you can use in order to whitelist or blacklist the interfaces which are/// used to gather ICE candidates./// A function that you can use in order to whitelist or blacklist/// the ips which are used to gather ICE candidates./// Controls if self-signed certificates are accepted when connecting to TURN servers via TLS or/// DTLS.include_loopback/// Include loopback addresses in the candidate list.AgentConfig/// Collects the arguments to `ice::Agent` construction into a single structure, for/// future-proofness of the interface.init_with_defaultsAgentInternal/// Populates an agent and falls back to defaults if fields are unset.init_ext_ip_mappingExternalIpMapperProtoTypeSTUN_GATHER_TIMEOUTmdns_modemdns_nameext_ip_mapperagent_internalgathering_statechan_candidate_txChanCandidateTxGatherCandidatesInternalParamsGatherCandidatesLocalParamsudp_muxUDPMuxGatherCandidatesLocalUDPMuxParamsport_maxport_minGatherCandidatesSrflxMappedParasmGatherCandidatesSrflxParamsgather_candidates_internalset_gathering_stateGatheringStategather_candidates_localgather_candidates_local_udp_muxgather_candidates_srflx_mappedgather_candidates_srflxgather_candidates_relayagent_vnet_testUDPMuxDefaultUDPMuxParamstest_vnet_gather_no_local_ip_addresstest_vnet_gather_dynamic_ip_addresstest_vnet_gather_listen_udptest_vnet_gather_with_nat_1to1_as_host_candidatestest_vnet_gather_with_nat_1to1_as_srflx_candidatestest_vnet_gather_with_interface_filtertest_vnet_gather_turn_connection_leaktest_vnet_gather_muxed_udpagent_transportremote_ufragremote_pwdUfragPwdon_connected_tx// State owned by the taskLoopon_connected_rxdone_tx// State for closingforce_candidate_contact_tx// force candidate to be contacted immediately (instead of waiting for task ticker)done_and_force_candidate_contact_rxchan_candidate_pair_txchan_state_txon_connection_state_change_hdlron_selected_candidate_pair_change_hdlron_candidate_hdlrOnCandidateHdlrFntie_breakernominated_pairstarted_ch_txufrag_pwdlocal_candidatesremote_candidatespending_binding_requestsBindingRequest// LRU of outbound Binding request Transaction IDsagent_connAgentConn// the following variables won't be changed after init_with_defaults()// How long connectivity checks can fail before the ICE Agent// goes to disconnected// goes to failed// How often should we send keepalive packets?// 0 means never// How often should we run our internal taskLoop to check for state changes when connecting//ConnectionState,ChanReceiversstart_connectivity_checkscontactconnectivity_checksset_selected_pairping_all_candidatesadd_pairfind_pairvalidate_selected_pair/// Checks if the selected pair is (still) valid./// Note: the caller should hold the agent lock.check_keepalive/// Sends STUN Binding Indications to the selected pair./// if no packet has been sent on that pair in the last keepaliveInterval.request_connectivity_check/// Assumes you are holding the lock (must be execute using a.run).add_candidatedelete_all_candidates/// Remove all candidates./// This closes any listening sockets and removes both the local and remote candidate lists./// This is used for restarts, failures and on close.find_remote_candidatesend_binding_successinvalidate_pending_binding_requests/// Removes pending binding requests that are over `maxBindingRequestTimeout` old Let HTO be the/// transaction timeout, which SHOULD be 2*RTT if RTT is known or 500 ms otherwise./// reference: (IETF ref-8445)[https://tools.ietf.org/html/rfc8445#appendix-B.1].handle_inbound_binding_success/// Assert that the passed `TransactionID` is in our `pendingBindingRequests` and returns the/// destination, If the bindingRequest was valid remove it from our pending cache./// Processes STUN traffic from a remote candidate.validate_non_stun_traffic/// Processes non STUN traffic from a remote candidate, and returns true if it is an actual/// remote candidate./// Sets the credentials of the remote agent.send_stunstart_candidate/// Runs the candidate using the provided connection.start_on_connection_state_change_routinerecv_loophandle_inbound_candidate_msguse_candidatecontact_candidatesping_candidatehandle_success_responseControllingSelectorControlledSelectoris_nominatablenominate_pair/// The timestamp associated with this struct./// The id of the local candidate./// The id of the remote candidate./// The state of the checklist for the local and remote candidates in a pair./// It is true when this valid pair that should be used for media,/// if it is the highest-priority one amongst those whose nominated flag is set./// The total number of packets sent on this candidate pair./// The total number of packets received on this candidate pair./// The total number of payload bytes sent on this candidate pair not including headers or/// padding./// The total number of payload bytes received on this candidate pair not including headers or/// The timestamp at which the last packet was sent on this particular candidate pair, excluding/// STUN packets./// The timestamp at which the last packet was received on this particular candidate pair,/// excluding STUN packets./// The timestamp at which the first STUN request was sent on this particular candidate pair./// The timestamp at which the last STUN request was sent on this particular candidate pair./// The average interval between two consecutive connectivity checks sent can be calculated with/// (last_request_timestamp - first_request_timestamp) / requests_sent.last_response_timestamp/// Timestamp at which the last STUN response was received on this particular candidate pair./// The sum of all round trip time measurements in seconds since the beginning of the session,/// based on STUN connectivity check responses (responses_received), including those that reply/// to requests that are sent in order to verify consent. The average round trip time can be/// computed from total_round_trip_time by dividing it by responses_received./// The latest round trip time measured in seconds, computed from both STUN connectivity checks,/// including those that are sent for consent verification./// It is calculated by the underlying congestion control by combining the available bitrate for/// all the outgoing RTP streams using this candidate pair. The bitrate measurement does not/// count the size of the IP or other transport layers like TCP or UDP. It is similar to the/// TIAS defined in RFC 3890, i.e., it is measured in bits per second and the bitrate is/// calculated over a 1 second window./// all the incoming RTP streams using this candidate pair. The bitrate measurement does not/// TIAS defined in  RFC 3890, i.e., it is measured in bits per second and the bitrate is/// The number of times the circuit breaker is triggered for this particular 5-tuple,/// ceasing transmission./// The total number of connectivity check requests received (including retransmissions)./// It is impossible for the receiver to tell whether the request was sent in order to check/// connectivity or check consent, so all connectivity checks requests are counted here./// The total number of connectivity check requests sent (not including retransmissions)./// The total number of connectivity check responses received./// The total number of connectivity check responses sent. Since we cannot distinguish/// connectivity check requests and consent requests, all responses are counted.retransmissions_received/// The total number of connectivity check request retransmissions received./// The total number of connectivity check request retransmissions sent./// The total number of consent requests sent./// The timestamp at which the latest valid STUN binding response expired./// Contains ICE candidate pair statistics.// The timestamp associated with this struct./// The candidate id./// The type of network interface used by the base of a local candidate (the address the ICE/// agent sends from). Only present for local candidates; it's not possible to know what type of/// network interface a remote candidate is using./// Note: This stat only tells you about the network interface used by the first "hop"; it's/// possible that a connection will be bottlenecked by another type of network.  For example,/// when using Wi-Fi tethering, the networkType of the relevant candidate would be "wifi", even/// when the next hop is over a cellular connection./// The IP address of the candidate, allowing for IPv4 addresses and IPv6 addresses, but fully/// qualified domain names (FQDNs) are not allowed./// The port number of the candidate./// The `Type` field of the ICECandidate./// The `priority` field of the ICECandidate./// The url of the TURN or STUN server indicated in the that translated this IP address./// It is the url address surfaced in an PeerConnectionICEEvent./// The protocol used by the endpoint to communicate with the TURN server. This is only present/// for local candidates. Valid values for the TURN url protocol is one of udp, tcp, or tls./// It is true if the candidate has been deleted/freed. For host candidates, this means that any/// network resources (typically a socket) associated with the candidate have been released. For/// TURN candidates, this means the TURN allocation is no longer active./// Only defined for local candidates. For remote candidates, this property is not applicable./// Contains ICE candidate statistics related to the `ICETransport` objects.get_candidate_pairs_stats/// Returns a list of candidate pair stats.get_local_candidates_stats/// Returns a list of local candidates stats.get_remote_candidates_stats/// Returns a list of remote candidates stats.agent_transport_testAttrControllingPriorityAttrUseCandidateAttrtest_pair_searchtest_pair_prioritytest_agent_get_statstest_on_selected_candidate_pair_changetest_handle_peer_reflexive_udp_pflx_candidatetest_handle_peer_reflexive_unknown_remotetest_connectivity_on_startuptest_connectivity_liteMockPacketConntest_inbound_validitytest_invalid_agent_startstest_connection_state_callbacktest_invalid_gathertest_candidate_pair_statstest_local_candidate_statstest_remote_candidate_statstest_init_ext_ip_mappingtest_binding_request_timeouttest_agent_credentialstest_connection_state_failed_delete_all_candidatestest_connection_state_connecting_to_failedtest_agent_restart_during_gathertest_agent_restart_when_closedtest_agent_restart_one_sidetest_agent_restart_both_sidetest_get_remote_credentialstest_close_in_connection_state_callbacktest_run_task_in_connection_state_callbacktest_run_task_in_selected_candidate_pair_change_callbacktest_lite_lifecycle/// Connects to the remote agent, acting as the controlling ice agent./// The method blocks until at least one ice candidate pair has successfully connected./// The operation will be cancelled if `cancel_rx` either receives a message or its channel/// Connects to the remote agent, acting as the controlled ice agent.selected_pairchecklistget_selected_pairget_best_available_candidate_pairget_best_valid_candidate_pair/// Returns the number of bytes sent./// Returns the number of bytes received.test_remote_local_addrtest_conn_statsMockConnVNET_GLOBAL_IPAVNET_LOCAL_IPAVNET_LOCAL_SUBNET_MASK_AVNET_GLOBAL_IPBVNET_LOCAL_IPBVNET_LOCAL_SUBNET_MASK_BVNET_STUN_SERVER_IPVNET_STUN_SERVER_PORTbuild_simple_vnetnatNatTypeadd_vnet_stunconnect_with_vnetAgentTestConfigpipe_with_vnetgather_and_exchange_candidatesstart_routerconnect_net2routerconnect_router2routertest_connectivity_simple_vnet_full_cone_nats_on_both_endstest_connectivity_vnet_full_cone_nats_on_both_endstest_connectivity_vnet_symmetric_nats_on_both_endstest_connectivity_vnet_1to1_nat_with_host_candidate_vs_symmetric_natstest_connectivity_vnet_1to1_nat_with_srflx_candidate_vs_symmetric_natsblock_until_state_seentest_disconnected_to_connectedtest_write_use_valid_pairagent_gather_testagent_gatheragent_selectorexternal_ip_mapperTcpTypeis_use_candidateGatherCandidateCancelFnchan_state_rxchan_candidate_rxchan_candidate_pair_rxmdns_connDnsConn// 1:1 D-NAT IP address mapping//GatheringState,gather_candidate_cancel/// Represents the ICE agent./// Creates a new Agent.get_bytes_receivedget_bytes_sent/// Sets a handler that is fired when the connection state changes./// Sets a handler that is fired when the final candidate pair is selected.on_candidate/// Sets a handler that is fired when new candidates gathered. When the gathering process/// complete the last candidate is nil./// Adds a new remote candidate./// Returns the local candidates.get_local_user_credentials/// Returns the local user credentials.get_remote_user_credentials/// Returns the remote user credentials./// Cleans up the Agent./// Returns the selected pair or nil if there is none/// Restarts the ICE Agent with the provided ufrag/pwd/// If no ufrag/pwd is provided the Agent will generate one itself./// Restart must only be called when `GatheringState` is `GatheringStateComplete`/// a user must then call `GatherCandidates` explicitly to start generating new ones.gather_candidates/// Initiates the trickle based gathering process.resolve_and_add_multicast_candidateclose_multicast_conncandidate_idinitialized_chCandidateRelatedAddressresolved_addrlast_sentlast_receivedclosed_chfoundation_overridepriority_override//CandidateHostrelay_client//CandidateRelayCandidateBase// String makes the candidateBase printable" Returns Candidate ID."" Returns candidate component."set_component" Returns a time indicating the last time this candidate was received."" Returns a time indicating the last time this candidate was sent."" Returns candidate NetworkType."" Returns Candidate Address."" Returns Candidate Port."" Computes the priority for this ICE Candidate."" Returns `Option<CandidateRelatedAddress>`."" Returns candidate type."" Returns the string representation of the ICECandidate."" Stops the recvLoop."" Used to compare two candidateBases."get_connget_closed_chset_last_receivedset_last_sentlocal_preference/// Returns the local preference for this candidate./// Creates a Candidate from its string representation.generate_cand_idbase_config/// The config required to create a new `CandidateHost`.new_candidate_host/// Creates a new host candidate.host_candidateprflx_candidatesrflx_candidaterelay_candidatetest_candidate_pair_prioritytest_candidate_pair_equalityrel_addrrel_port/// The config required to create a new `CandidatePeerReflexive`.new_candidate_peer_reflexive/// Creates a new peer reflective candidate./// The config required to create a new `CandidateRelay`.new_candidate_relay/// Creates a new relay candidate.OptimisticAuthHandlertest_relay_only_connection/// The config required to create a new `CandidateServerReflexive`.new_candidate_server_reflexive/// Creates a new server reflective candidate.candidate_relay_testtest_server_reflexive_only_connectiontest_candidate_prioritytest_candidate_last_senttest_candidate_last_receivedtest_candidate_foundationtest_candidate_pair_state_serializationtest_candidate_pair_state_to_stringtest_candidate_type_serializationtest_candidate_type_to_stringtest_candidate_marshalcandidate_pair_testcandidate_server_reflexive_testcandidate_testDEFAULT_LOCAL_PREFERENCECOMPONENT_RTP/// Indicates that the candidate is used for RTP.COMPONENT_RTCP/// Indicates that the candidate is used for RTCP." An arbitrary string used in the freezing algorithm to"" group similar candidates.  It is the same for two candidates that"" have the same type, base IP address, protocol (UDP, TCP, etc.),"" and STUN or TURN server."" A unique identifier for just this candidate"" Unlike the foundation this is different for each candidate."" A component is a piece of a data stream."" An example is one for RTP, and one for RTCP"" The last time this candidate received traffic"" The last time this candidate sent traffic"" A transport address related to candidate,"" which is useful for diagnostics and other purposes."" Candidate represents an ICE candidate"ServerReflexivePeerReflexive/// Represents the type of candidate `CandidateType` enum.// String makes CandidateType printablepreference/// Returns the preference weight of a `CandidateType`./// 4.1.2.2.  Guidelines for Choosing Type and Local Preferences/// The RECOMMENDED values are 126 for host candidates, 100/// for server reflexive candidates, 110 for peer reflexive candidates,/// and 0 for relayed candidates.contains_candidate_type/// Convey transport addresses related to the candidate, useful for diagnostics and other purposes.// String makes CandidateRelatedAddress printable/// Means a check has not been performed for this pair./// Means a check has been sent for this pair, but the transaction is in progress./// Means a check for this pair was already done and failed, either never producing any response/// or producing an unrecoverable failure response./// Means a check for this pair was already done and produced a successful result./// Represent the ICE candidate pair state.ice_role_controllingbinding_request_count// convert it to CandidatePairState,nominate_on_binding_success/// Represents a combination of a local and remote candidate./// RFC 5245 - 5.7.2.  Computing Pair Priority and Ordering Pairs/// Let G be the priority for the candidate provided by the controlling/// agent.  Let D be the priority for the candidate provided by the/// controlled agent./// pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)test_controlled_get_fromtest_controlling_get_fromtest_control_get_fromcontrol_testTieBreaker/// Common helper for ICE-{CONTROLLED,CONTROLLING} and represents the so-called Tiebreaker number.TIE_BREAKER_SIZE/// Adds Tiebreaker value to m as t attribute./// Decodes Tiebreaker value in message getting it as for t type.AttrControlled/// Represents ICE-CONTROLLED attribute./// Adds ICE-CONTROLLED to message./// Decodes ICE-CONTROLLED from message./// Represents ICE-CONTROLLING attribute.// add_to adds ICE-CONTROLLING to message.// get_from decodes ICE-CONTROLLING from message.AttrControl/// Helper that wraps ICE-{CONTROLLED,CONTROLLING}.// add_to adds ICE-CONTROLLED or ICE-CONTROLLING attribute depending on Role.// get_from decodes Role and Tiebreaker value from message./// Represents ICE agent role, which can be controlling or controlled./// Possible ICE agent roles.// 64 bit/// Indicates an error with Unknown info./// Indicates the scheme type could not be parsed.ErrStunQuery/// Indicates query arguments are provided in a STUN URL.ErrInvalidQuery/// Indicates an malformed query is provided./// Indicates malformed hostname is provided.ErrPort/// Indicates malformed port is provided.ErrLocalUfragInsufficientBits/// Indicates local username fragment insufficient bits are provided./// Have to be at least 24 bits long.ErrLocalPwdInsufficientBits/// Indicates local passoword insufficient bits are provided./// Have to be at least 128 bits long.ErrProtoType/// Indicates an unsupported transport type was provided./// Indicates the agent is closed.ErrNoCandidatePairs/// Indicates agent does not have a valid candidate pair.ErrCanceledByCaller/// Indicates agent connection was canceled by the caller.ErrMultipleStart/// Indicates agent was started twice.ErrRemoteUfragEmpty/// Indicates agent was started with an empty remote ufrag.ErrRemotePwdEmpty/// Indicates agent was started with an empty remote pwd.ErrNoOnCandidateHandler/// Indicates agent was started without on_candidate.ErrMultipleGatherAttempted/// Indicates GatherCandidates has been called multiple times.ErrUsernameEmpty/// Indicates agent was give TURN URL with an empty Username.ErrPasswordEmpty/// Indicates agent was give TURN URL with an empty Password.ErrAddressParseFailed/// Indicates we were unable to parse a candidate address.ErrLiteUsingNonHostCandidates/// Indicates that non host candidates were selected for a lite agent.ErrUselessUrlsProvided/// Indicates that one or more URL was provided to the agent but no host candidate required them.ErrUnsupportedNat1to1IpCandidateType/// Indicates that the specified NAT1To1IPCandidateType is unsupported.ErrInvalidNat1to1IpMapping/// Indicates that the given 1:1 NAT IP mapping is invalid.ErrExternalMappedIpNotFound/// IPNotFound in NAT1To1IPMapping.ErrMulticastDnsWithNat1to1IpMapping/// Indicates that the mDNS gathering cannot be used along with 1:1 NAT IP mapping for host/// candidate.ErrIneffectiveNat1to1IpMappingHost/// Indicates that 1:1 NAT IP mapping for host candidate is requested, but the host candidate/// type is disabled.ErrIneffectiveNat1to1IpMappingSrflx/// Indicates that 1:1 NAT IP mapping for srflx candidate is requested, but the srflx candidateErrInvalidMulticastDnshostName/// Indicates an invalid MulticastDNSHostName.ErrRestartWhenGathering/// Indicates Restart was called when Agent is in GatheringStateGathering.ErrRunCanceled/// Indicates a run operation was canceled by its individual done.ErrTcpMuxNotInitialized/// Initialized Indicates TCPMux is not initialized and that invalidTCPMux is used.ErrTcpRemoteAddrAlreadyExists/// Indicates we already have the connection with same remote addr.ErrSendPacketErrAttributeTooShortIceCandidateErrParseComponentErrParsePriorityErrParsePortErrParseRelatedAddrErrParseTypeErrUnknownCandidateTypeErrGetXorMappedAddrResponseErrConnectionAddrAlreadyExistErrReadingStreamingPacketErrWritingErrClosingConnectionErrDetermineNetworkTypeErrMissingProtocolSchemeErrTooManyColonsAddrErrReadErrUnknownRoleErrMismatchUsernameErrIceWriteStunMessageErrUrlParseErrCandidateIpNotFoundMdnsTurntest_external_ip_mapper_validate_ip_stringtest_external_ip_mapper_new_external_ip_mappertest_external_ip_mapper_new_external_ip_mapper_with_explicit_local_iptest_external_ip_mapper_new_external_ip_mapper_with_implicit_local_iptest_external_ip_mapper_find_external_ip_without_explicit_local_iptest_external_ip_mapper_find_external_ip_with_explicit_local_iptest_external_ip_mapper_find_external_ip_with_empty_mapexternal_ip_mapper_testvalidate_ip_stringip_soleip_map// when non-nil, this is the sole external IP for one local IP assumed// local-to-external IP mapping (k: local, v: external)IpMapping/// Holds the mapping of local and external IP address for a particular IP family.set_sole_ipadd_ip_mappingfind_external_ipipv4_mappingipv6_mappingtest_multicast_dns_only_connectiontest_multicast_dns_mixed_connectiontest_multicast_dns_static_host_nametest_generate_multicast_dnsnamemdns_test/// Means remote mDNS candidates will be discarded, and local host candidates will use IPs.QueryOnly/// Means remote mDNS candidates will be accepted, and local host candidates will use IPs.QueryAndGather/// Means remote mDNS candidates will be accepted, and local host candidates will use mDNS./// Represents the different Multicast modes that ICE can run.generate_multicast_dns_namecreate_multicast_dnsnetwork_type_testsupported_network_typesUdp4/// Indicates UDP over IPv4.Udp6/// Indicates UDP over IPv6.Tcp4/// Indicates TCP over IPv4.Tcp6/// Indicates TCP over IPv6./// Represents the type of network.is_udp/// Returns true when network is UDP4 or UDP6.is_tcp/// Returns true when network is TCP4 or TCP6.network_short/// Returns the short network description.is_reliable/// Returns true if the network is reliable./// Returns whether the network type is IPv4 or not./// Returns whether the network type is IPv6 or not.determine_network_type/// Determines the type of network based on the short network string and an IP address.test_network_type_parsing_successtest_network_type_parsing_failuretest_network_type_is_udptest_network_type_is_tcptest_network_type_serializationtest_network_type_to_stringpriority_test/// Represents PRIORITY attribute.PRIORITY_SIZE// add_to adds PRIORITY attribute to message./// Decodes PRIORITY attribute from message.test_priority_get_fromrand_testRUNES_CANDIDATE_ID_FOUNDATIONLEN_UFRAGLEN_PWD// TODO: cryptographically strong random source/// <https://tools.ietf.org/html/rfc5245#section-15.1>/// candidate-id = "candidate" ":" foundation/// foundation   = 1*32ice-char/// ice-char     = ALPHA / DIGIT / "+" / "/"generate_pwd/// Generates ICE pwd./// This internally uses `generate_crypto_random_string`.generate_ufrag/// ICE user fragment.test_random_generator_collisionstate_test/// ICE agent is gathering addresses./// ICE agent has been given local and remote candidates, and is attempting to find a match./// ICE agent has a pairing, but is still checking other pairs./// ICE agent has finished./// ICE agent never could successfully connect./// ICE agent connected successfully, but has entered a failed state./// ICE agent has finished and is no longer handling requests./// An enum showing the state of a ICE Connection List of supported States./// Indicates candidate gathering is not yet started./// Indicates candidate gathering is ongoing./// Indicates candidate gathering has been completed./// Describes the state of the candidate gathering process.test_connected_state_stringtest_gathering_state_string// timestamp is the timestamp associated with this object.// local_candidate_id is the id of the local candidate// remote_candidate_id is the id of the remote candidate// state represents the state of the checklist for the local and remote// candidates in a pair.// nominated is true when this valid pair that should be used for media// if it is the highest-priority one amongst those whose nominated flag is set// packets_sent represents the total number of packets sent on this candidate pair.// packets_received represents the total number of packets received on this candidate pair.// bytes_sent represents the total number of payload bytes sent on this candidate pair// not including headers or padding.// bytes_received represents the total number of payload bytes received on this candidate pair// last_packet_sent_timestamp represents the timestamp at which the last packet was// sent on this particular candidate pair, excluding STUN packets.// last_packet_received_timestamp represents the timestamp at which the last packet// was received on this particular candidate pair, excluding STUN packets.// first_request_timestamp represents the timestamp at which the first STUN request// was sent on this particular candidate pair.// last_request_timestamp represents the timestamp at which the last STUN request// was sent on this particular candidate pair. The average interval between two// consecutive connectivity checks sent can be calculated with// (last_request_timestamp - first_request_timestamp) / requests_sent.// last_response_timestamp represents the timestamp at which the last STUN response// was received on this particular candidate pair.// total_round_trip_time represents the sum of all round trip time measurements// in seconds since the beginning of the session, based on STUN connectivity// check responses (responses_received), including those that reply to requests// that are sent in order to verify consent. The average round trip time can// be computed from total_round_trip_time by dividing it by responses_received.// current_round_trip_time represents the latest round trip time measured in seconds,// computed from both STUN connectivity checks, including those that are sent// for consent verification.// available_outgoing_bitrate is calculated by the underlying congestion control// by combining the available bitrate for all the outgoing RTP streams using// this candidate pair. The bitrate measurement does not count the size of the// ip or other transport layers like TCP or UDP. It is similar to the TIAS defined// in RFC 3890, i.e., it is measured in bits per second and the bitrate is calculated// over a 1 second window.// available_incoming_bitrate is calculated by the underlying congestion control// by combining the available bitrate for all the incoming RTP streams using// in  RFC 3890, i.e., it is measured in bits per second and the bitrate is// calculated over a 1 second window.// circuit_breaker_trigger_count represents the number of times the circuit breaker// is triggered for this particular 5-tuple, ceasing transmission.// requests_received represents the total number of connectivity check requests// received (including retransmissions). It is impossible for the receiver to// tell whether the request was sent in order to check connectivity or check// consent, so all connectivity checks requests are counted here.// requests_sent represents the total number of connectivity check requests// sent (not including retransmissions).// responses_received represents the total number of connectivity check responses received.// responses_sent epresents the total number of connectivity check responses sent.// Since we cannot distinguish connectivity check requests and consent requests,// all responses are counted.// retransmissions_received represents the total number of connectivity check// request retransmissions received.// retransmissions_sent represents the total number of connectivity check// request retransmissions sent.// consent_requests_sent represents the total number of consent requests sent.// consent_expired_timestamp represents the timestamp at which the latest valid// STUN binding response expired.// CandidatePairStats contains ICE candidate pair statistics// id is the candidate id// network_type represents the type of network interface used by the base of a// local candidate (the address the ICE agent sends from). Only present for// local candidates; it's not possible to know what type of network interface// a remote candidate is using.// Note:// This stat only tells you about the network interface used by the first "hop";// it's possible that a connection will be bottlenecked by another type of network.// For example, when using Wi-Fi tethering, the networkType of the relevant candidate// would be "wifi", even when the next hop is over a cellular connection.// ip is the ip address of the candidate, allowing for IPv4 addresses and// IPv6 addresses, but fully qualified domain names (FQDNs) are not allowed.// port is the port number of the candidate.// candidate_type is the "Type" field of the ICECandidate.// priority is the "priority" field of the ICECandidate.// url is the url of the TURN or STUN server indicated in the that translated// this ip address. It is the url address surfaced in an PeerConnectionICEEvent.// relay_protocol is the protocol used by the endpoint to communicate with the// TURN server. This is only present for local candidates. Valid values for// the TURN url protocol is one of udp, tcp, or tls.// deleted is true if the candidate has been deleted/freed. For host candidates,// this means that any network resources (typically a socket) associated with the// candidate have been released. For TURN candidates, this means the TURN allocation// is no longer active.// Only defined for local candidates. For remote candidates, this property is not applicable.// CandidateStats contains ICE candidate statistics related to the ICETransport objects.tcp_type_test/// The default value. For example UDP candidates do not need this field./// Active TCP candidate, which initiates TCP connections./// Passive TCP candidate, only accepts TCP connections.SimultaneousOpen/// Like `Active` and `Passive` at the same time./// TCPType is the type of ICE TCP candidate/// * [RFC 6544 §4.5]/// [RFC 6544 §4.5]: https://tools.ietf.org/html/rfc6544#section-4.5// from creates a new TCPType from string.test_tcp_typeudp_mux_connUDPMuxConnUDPMuxConnParamsUDPMuxWriterudp_mux_testsocket_addr_extis_stun_messageSTUNMessagenormalize_socket_addr/// Normalize a target socket addr for sending over a given local socket addr. This is useful when/// a dual stack socket is used, in which case an IPv4 target needs to be mapped to an IPv6" Close the muxing."" Get the underlying connection for a given ufrag."" Remove the underlying connection for a given ufrag."remove_conn_by_ufrag/// The params this instance is configured with./// Contains the underlying UDP socket in useconns/// Maps from ufrag to the underlying connection.address_map/// Maps from ip address to the underlying connection.closed_watch_tx// Close senderclosed_watch_rx/// Close receivercreate_muxed_conn/// Create a muxed connection for a given ufrag.conn_from_stun_messagestart_conn_workerregister_conn_for_address///Encode a representation of `self` into the buffer and return the length of this encoded///version./// The buffer needs to be at least 27 bytes in length./// Decode a `SocketAddr` from a buffer. The encoding should have previously been done with/// [`SocketAddrExt::encode`].IPV4_MARKERIPV4_ADDRESS_SIZEIPV6_MARKERIPV6_ADDRESS_SIZEMAX_ADDR_SIZEtest_ipv4test_encode_ipv4_with_short_buffertest_encode_ipv6_with_short_buffertest_decode_ipv4_with_short_buffertest_decode_ipv6_with_short_buffer" Registers an address for the given connection."" Sends the content of the buffer to the given target."" Returns the number of bytes sent or an error, if any."" A trait for a [`UDPMuxConn`] to communicate with an UDP mux."/// Local socket address./// Static key identifying the connection./// A `std::sync::Weak` reference to the UDP mux./// NOTE: a non-owning reference should be used to prevent possible cycles./// Parameters for a [`UDPMuxConn`].ConnResult/// Close Receiver. A copy of this can be obtained via [`close_tx`].UDPMuxConnInner/// A UDP mux connection./// Creates a new [`UDPMuxConn`]./// Returns a key identifying this connection.write_packet/// Writes data to the given address. Returns an error if the buffer is too short or there's an/// encoding error./// Returns true if this connection is closed./// Gets a copy of the close [`tokio::sync::watch::Receiver`] that fires when this/// Closes this connection.get_addresses/// Gets the list of the addresses associated with this connection./// Registers a new address for this connection.remove_address/// Deregisters an address./// Returns true if the given address is associated with this connection./// Close Sender. We'll send a value on this channel when we close/// Remote addresses we've seen on this connection.// Sending/Recieving// Address related methodsmake_buffer/// Create a buffer of appropriate size to fit both a packet with max RECEIVE_MTU and the/// additional metadata used for muxing./// Bind the UDP socket for the "remote".connect_ip/// Connect ip from the "remote".test_udp_muxtest_mux_connectionverify_packetsha1_hashEphemeralUDPset_portsMuxed/// Configuration for the underlying UDP network stack./// There are two ways to configure this Ephemeral and Muxed./// **Ephemeral mode**/// In Ephemeral mode sockets are created and bound to random ports during ICE/// gathering. The ports to use can be restricted by setting [`EphemeralUDP::port_min`] and/// [`EphemeralUDP::port_max`] in which case only ports in this range will be used./// **Muxed**/// In muxed mode a single UDP socket is used and all connections are muxed over this single socket.is_ephemeralis_muxedtest_ephemeral_udp_constructortest_ephemeral_udp_set_portsurl_test/// The URL represents a STUN server.Stuns/// The URL represents a STUNS (secure) server./// The URL represents a TURN server.Turns/// The URL represents a TURNS (secure) server./// Default public constant to use for "enum" like struct comparisons when no value was defined./// The type of server used in the ice.URL structure./// Defines a procedure for creating a new `SchemeType` from a raw/// The URL uses a UDP transport./// The URL uses a TCP transport./// The transport protocol type that is used in the `ice::url::Url` structure.// NewSchemeType defines a procedure for creating a new SchemeType from a raw// string naming the scheme type.// defines a procedure for creating a new ProtoType from a raw// string naming the transport protocol type./// Represents a STUN (rfc7064) or TURN (rfc7065) URL./// Parses a STUN or TURN urls following the ABNF syntax described in/// [IETF rfc-7064](https://tools.ietf.org/html/rfc7064) and/// [IETF rfc-7065](https://tools.ietf.org/html/rfc7065) respectively./// Returns whether the this URL's scheme describes secure scheme or not./*
    fn parse_proto(raw:&str) ->Result<ProtoType> {
        let qArgs= raw.split('=');
        if qArgs.len() != 2 {
            return Err(Error::ErrInvalidQuery.into());
        }

        var proto ProtoType
        if rawProto := qArgs.Get("transport"); rawProto != "" {
            if proto = NewProtoType(rawProto); proto == ProtoType(0) {
                return ProtoType(Unknown), ErrProtoType
            }
            return proto, nil
        }

        if len(qArgs) > 0 {
            return ProtoType(Unknown), ErrInvalidQuery
        }

        return proto, nil
    }*/test_parse_url_successtest_parse_url_failureuse_candidate_test/// Represents USE-CANDIDATE attribute./// Adds USE-CANDIDATE attribute to message./// Returns true if USE-CANDIDATE attribute is set.test_use_candidate_attr_add_tocreate_addrassert_inbound_usernameassert_inbound_message_integrityget_xormapped_addr/// Initiates a stun requests to `server_addr` using conn, reads the response and returns the/// `XORMappedAddress` returned by the stun server./// Adapted from stun v0.2.stun_requestlocal_interfaceslisten_udp_in_port_rangetest_listen_udp_in_port_range_overflowtest_local_interfacesquery_interval// query_interval controls how often we sends Queries until we// get a response for the requested namelocal_names// local_names are the names that we will generate answers for// when we get questions// Config is used to configure a mDNS client or server.test_multiple_closetest_query_respect_timeoutDEFAULT_DEST_ADDRDEFAULT_QUERY_INTERVALMAX_MESSAGE_RECORDSRESPONSE_TTLqueriesis_server_closedclose_server// Conn represents a mDNS Servername_with_suffixquery_result_chanQueryResultResourceHeader/// server establishes a mDNS connection over an existing connection/// Close closes the mDNS Conn/// Query sends mDNS Queries for the following name until/// either there's a close signal or we get a resultsend_questionsend_answerget_interface_addr_for_ipErrJoiningMulticastGroupErrContextElapsedErrNilConfigErrNotStartedErrSectionDoneErrSectionHeaderErrBaseLenErrCalcLenErrReservedErrTooManyPtrErrInvalidPtrErrNilResourceBodyErrResourceLenErrSegTooLongErrZeroSegLenErrResTooLongErrTooManyQuestionsErrTooManyAnswersErrTooManyAuthoritiesErrTooManyAdditionalsErrNonCanonicalNameErrStringTooLongErrCompressedSrvErrEmptyBuilderMsg// msg is the storage for the message being built.// section keeps track of the current section being built.HeaderInternal// header keeps track of what should go in the header when Finish is// called.// start is the starting index of the bytes allocated in msg for header.// compression is a mapping from name suffixes to their starting index// in msg.// A Builder allows incrementally packing a DNS message.// Example usage://	b := NewBuilder(Header{...})//	b.enable_compression()//	// Optionally start a section and add things to that section.//	// Repeat adding sections as necessary.//	buf, err := b.Finish()//	// If err is nil, buf[2:] will contain the built bytes.// NewBuilder creates a new builder with compression disabled.// Note: Most users will want to immediately enable compression with the// enable_compression method. See that method's comment for why you may or may// not want to enable compression.// The DNS message is appended to the provided initial buffer buf (which may be// nil) as it is built. The final message is returned by the (*Builder).Finish// method, which may return the same underlying array if there was sufficient// capacity in the slice.enable_compression// enable_compression enables compression in the Builder.// Leaving compression disabled avoids compression related allocations, but can// result in larger message sizes. Be careful with this mode as it can cause// messages to exceed the UDP size limit.// According to RFC 1035, section 4.1.4, the use of compression is optional, but// all implementations must accept both compressed and uncompressed DNS// messages.// Compression should be enabled before any sections are added for best results.start_checkstart_questions// start_questions prepares the builder for packing Questions.start_answers// start_answers prepares the builder for packing Answers.start_authorities// start_authorities prepares the builder for packing Authorities.start_additionals// start_additionals prepares the builder for packing Additionals.increment_section_countadd_question// question adds a single question.check_resource_sectionadd_resource// Resource adds a single resource.// Finish ends message building and generates a binary message.op_codetruncatedrecursion_desiredrecursion_availablercodeRCode// Header is a representation of a DNS message header.NotStartedQuestionsAnswersAuthoritiesAdditionalsquestionsauthoritiesadditionals// header is the wire format for a DNS message header.// pack appends the wire format of the header to msg.aaaamxsoasrvtxtsmall_test_msglarge_test_msgmust_edns0_resource_headertest_name_stringtest_question_pack_unpacktest_name_pack_unpacktest_incompressible_nametest_header_unpack_errortest_parser_starttest_resource_not_startedtest_srv_pack_unpacktest_dns_pack_unpacktest_dns_append_pack_unpacktest_skip_alltest_skip_eachtest_skip_after_readtest_skip_not_startedtest_too_many_recordstest_very_long_txttest_too_long_txttest_start_errortest_builder_resource_errortest_finish_errortest_resource_packtest_resource_pack_lengthtest_option_pack_unpack// Silence warning on complex types:packerDnsType// ResourceHeader.Type and question.TypeCnameAaaaWks// question.TypeHinfoMinfoAxfr// A Type is a type of DNS request and response.// pack_type appends the wire format of field to msg.DnsClass// A Class is a type of network.DNSCLASS_INET// ResourceHeader.Class and question.ClassDNSCLASS_CSNETDNSCLASS_CHAOSDNSCLASS_HESIODDNSCLASS_ANY// question.Class// pack_class appends the wire format of field to msg.// An OpCode is a DNS operation code.// Message.RcodeServerFailure// An RCode is a DNS response status code.PACK_STARTING_CAP// PACK_STARTING_CAP is the default initial buffer size allocated during// packing.// The starting capacity doesn't matter too much, but most DNS responses// Will be <= 512 bytes as it is the limit for DNS over UDP.UINT16LEN// UINT16LEN is the length (in bytes) of a uint16.UINT32LEN// UINT32LEN is the length (in bytes) of a uint32.HEADER_LEN// HEADER_LEN is the length (in bytes) of a DNS header.// A header is comprised of 6 uint16s and no padding.HEADER_BIT_QRHEADER_BIT_AA// query/response (response=1)HEADER_BIT_TC// authoritativeHEADER_BIT_RD// truncatedHEADER_BIT_RA// recursion desired// Message is a representation of a DNS message.// Unpack parses a full Message.// Pack packs a full Message.append_pack// append_pack is like Pack but appends the full Message to b and returns the// extended buffer.// Message formats// Internal constants.// recursion availableNAME_LEN// A Name is a non-encoded domain name. It is used instead of strings to avoid// allocations.// String implements fmt.Stringer.String.// pack appends the wire format of the Name to msg.// Domain names are a sequence of counted strings split at the dots. They end// with a zero-length string. Compression can be used to reuse domain suffixes.// The compression map will be updated with new domain suffixes. If compression// is nil, compression will not be used.// unpack unpacks a domain name.unpack_compressedpack_bytes// pack_bytes appends the wire format of field to msg.unpack_bytespack_uint16// pack_uint16 appends the wire format of field to msg.unpack_uint16skip_uint16pack_uint32// pack_uint32 appends the wire format of field to msg.unpack_uint32skip_uint32pack_str// pack_text appends the wire format of field to msg.unpack_strunpack_resource_bodyResourceBodyres_header_validres_header// A Parser allows incrementally parsing a DNS message.// When parsing is started, the Header is parsed. Next, each question can be// either parsed or skipped. Alternatively, all Questions can be skipped at// once. When all Questions have been parsed, attempting to parse Questions// will return (nil, nil) and attempting to skip Questions will return// (true, nil). After all Questions have been either parsed or skipped, all// Answers, Authorities and Additionals can be either parsed or skipped in the// same way, and each type of Resource must be fully parsed or skipped before// proceeding to the next type of Resource.// Note that there is no requirement to fully skip or parse the message.// start parses the header and enables the parsing of Questions.check_advanceresource_headerskip_resource// question parses a single question.all_questions// all_questions parses all Questions.skip_question// skip_question skips a single question.skip_all_questions// skip_all_questions skips all Questions.answer_header// answer_header parses a single answer ResourceHeader.// answer parses a single answer Resource.all_answers// all_answers parses all answer Resources.skip_answer// skip_answer skips a single answer Resource.skip_all_answers// skip_all_answers skips all answer Resources.authority_header// authority_header parses a single authority ResourceHeader.// authority parses a single authority Resource.all_authorities// all_authorities parses all authority Resources.skip_authority// skip_authority skips a single authority Resource.skip_all_authorities// skip_all_authorities skips all authority Resources.additional_header// additional_header parses a single additional ResourceHeader.// additional parses a single additional Resource.all_additionals// all_additionals parses all additional Resources.skip_additional// skip_additional skips a single additional Resource.skip_all_additionals// skip_all_additionals skips all additional Resources.resource_body// resource_body parses a single resource_boy.// One of the XXXHeader methods must have been called before calling this// method.// A question is a DNS query.// pack appends the wire format of the question to msg.AResource// An AResource is an A Resource record.real_type// pack appends the wire format of the AResource to msg.AaaaResource// An AAAAResource is an aaaa Resource record.// pack appends the wire format of the AAAAResource to msg.CnameResource// A cnameresource is a cname Resource record.// pack appends the wire format of the cnameresource to msg.EDNS0_VERSIONEDNS0_DNSSEC_OKEDNS_VERSION_MASKEDNS0_DNSSEC_OK_MASK// A Resource is a DNS resource record.// pack appends the wire format of the Resource to msg.// Name is the domain name for which this resource record pertains.// Type is the type of DNS resource record.// This field will be set automatically during packing.// Class is the class of network to which this DNS resource record// pertains.// TTL is the length of time (measured in seconds) which this resource// record is valid for (time to live). All Resources in a set should// have the same TTL (RFC 2181 Section 5.2).// Length is the length of data in the resource record after the header.// A ResourceHeader is the header of a DNS resource record. There are// many types of DNS resource records, but they all share the same header.// pack appends the wire format of the ResourceHeader to oldMsg.// lenOff is the offset in msg where the Length field was packed.fix_len// fixLen updates a packed ResourceHeader to include the length of the// ResourceBody.// lenOff is the offset of the ResourceHeader.Length field in msg.// preLen is the length that msg was before the ResourceBody was packed.set_edns0// set_edns0 configures h for EDNS(0).// The provided ext_rcode must be an extended RCode.dnssec_allowed// dnssec_allowed reports whether the DNSSEC OK bit is set.extended_rcode// extended_rcode returns an extended RCode.// The provided rcode must be the RCode in DNS message header.// real_type returns the actual type of the Resource. This is used to// fill in the header Type field.// pack packs a Resource except for its header.// A ResourceBody is a DNS resource record minus the header.// EDNS(0) wire constants.prefMxResource// An MXResource is an mx Resource record.// pack appends the wire format of the MXResource to msg.NsResource// An NSResource is an NS Resource record.// pack appends the wire format of the NSResource to msg.DnsOptionOptResource// An OPTResource is an OPT pseudo Resource record.// The pseudo resource record is part of the extension mechanisms for DNS// as defined in RFC 6891.// option code// An Option represents a DNS message option within OPTResource.// The message option is part of the extension mechanisms for DNS as// defined in RFC 6891.PtrResource// A PTRResource is a PTR Resource record.// pack appends the wire format of the PTRResource to msg.mboxmin_ttl// min_ttl the is the default TTL of Resources records which did not// contain a TTL value and the TTL of negative responses. (RFC 2308// Section 4)SoaResource// An SOAResource is an SOA Resource record.// pack appends the wire format of the SOAResource to msg.// Not compressed as per RFC 2782.SrvResource// An SRVResource is an SRV Resource record.// pack appends the wire format of the SRVResource to msg.TxtResource// A TXTResource is a txt Resource record.// pack appends the wire format of the TXTResource to msg.DeinterleavedBufferInfo/// Get a reference to the buffer info's channels./// Set the buffer info's channels./// Get a reference to the buffer info's frames./// Set the buffer info's frames.impl_from_buffer_infoBufferLayoutdeinterleaveddeinterleaved_by/// De-interleaves an interleaved slice using a memory access pattern/// that's optimized for efficient cached (i.e. sequential) reads.interleavedinterleaved_by/// Interleaves an de-interleaved slice using a memory access patterninterleaved_1_channeldeinterleaved_1_channelinterleaved_2_channeldeinterleaved_2_channelinterleaved_3_channeldeinterleaved_3_channelToByteBufferRef/// Buffer multi-channel interlaced Audio.sub_rangeinit_vec/// Creates a vec with deferred initialization./// The closure `f` MUST initialize every single item in the provided slice.deinterleaved_from_interleavedinterleaved_from_deinterleaveddeinterleaved_from_deinterleaved_bytesdeinterleaved_from_interleaved_bytesinterleaved_from_interleaved_bytesinterleaved_from_deinterleaved_bytesnearly_eqNearlyEqimpl_from_sample_for_rawassert_nearly_eqsample_i16_from_i16sample_f32_from_f32sample_i16_from_sample_f32sample_f32_from_sample_i16// impl From<Sample<i16>> for Sample<i64> {//     fn from(sample: Sample<i16>) -> Self {//         // Fast but imprecise approach://         // Perform crude but fast upsample by bit-shifting the raw value://         Self::from((sample.0 as i64) << 16)//         // Slow but precise approach://         // Perform a proper but expensive lerp from//         // i16::MIN..i16::MAX to i32::MIN..i32::MAX://         // let value = sample.0 as i64;//         // let from = if value <= 0 { i16::MIN } else { i16::MAX } as i64;//         // let to = if value <= 0 { i32::MIN } else { i32::MAX } as i64;//         // Self::from((value * to + from / 2) / from)ErrNilStreamErrIncompleteFrameHeaderErrIncompleteFrameDataErrIncompleteFileHeaderErrSignatureMismatchErrUnknownIVFVersionErrFileNotOpenedErrInvalidNilPacketErrBadIDPageSignatureErrBadIDPageTypeErrBadIDPageLengthErrBadIDPagePayloadSignatureErrShortPageHeaderErrChecksumMismatchErrDataIsNotH264Streamtest_data_does_not_start_with_h264headertest_parse_headertest_eoftest_skip_seitest_issue1734_next_naltest_trailing01after_start_codeh264_reader_testNalUnitType/// UnspecifiedCodedSliceNonIdr/// Coded slice of a non-IDR pictureCodedSliceDataPartitionA/// Coded slice data partition ACodedSliceDataPartitionB/// Coded slice data partition BCodedSliceDataPartitionC/// Coded slice data partition CCodedSliceIdr/// Coded slice of an IDR picture/// Supplemental enhancement information (SEI)/// Sequence parameter set/// Picture parameter setAUD/// Access unit delimiterEndOfSequence/// End of sequenceEndOfStream/// End of stream/// Filler dataSpsExt/// Sequence parameter set extensionCodedSliceAux/// Coded slice of an auxiliary coded picture without partitioning///Reserved// 14..18                                            // Reserved// 20..23                                            // Reserved// 24..31                                            // Unspecified/// NalUnitType is the type of a NAL/// Enums for NalUnitTypespicture_order_countforbidden_zero_bit/// NAL headerref_idc/// header byte + rbspNAL/// NAL H.264 Network Abstraction LayerNAL_PREFIX_3BYTESNAL_PREFIX_4BYTESread_endfilled_end/// Wrapper class around reading buffer// reading buffersnal_prefix_parsed// for readingcount_of_consecutive_zero_bytesnal_bufferH264Reader/// H264Reader reads data from stream and constructs h264 nal units/// new creates new `H264Reader` with `capacity` sized read buffer.bit_stream_starts_with_h264prefixnext_nal/// next_nal reads from stream and returns then next NAL,/// and an error if there is incomplete frame data./// Returns all nil values when no more NALs are available.process_bytetest_is_key_frametest_write_rtptest_write_rtp_fuh264_writer_testNALU_TTYPE_STAP_ANALU_TTYPE_SPSis_key_framehas_key_framecached_packetH264Writer/// H264Writer is used to take RTP packets, parse them and/// write the data to an io.Writer./// Currently it only supports non-interleaved mode/// Therefore, only 1-23, 24 (STAP-A), 28 (FU-A) NAL types are allowed./// <https://tools.ietf.org/html/rfc6184#section-5.2>// new initializes a new H264 writer with an io.Writer output/// write_rtp adds a new packet and writes the appropriate headers for it/// close closes the underlying writerbuild_ivf_container/// build_ivf_container takes frames and prepends valid IVF file headertest_ivf_reader_parse_valid_file_headertest_ivf_reader_parse_valid_framestest_ivf_reader_parse_incomplete_frame_headertest_ivf_reader_parse_incomplete_frame_payloadtest_ivf_reader_eof_when_no_frames_leftivf_reader_testResetFnIVF_FILE_HEADER_SIGNATUREIVF_FILE_HEADER_SIZEIVF_FRAME_HEADER_SIZE// 0-3// 4-5four_cc// 6-7// 8-11// 12-13timebase_denominator// 14-15timebase_numerator// 16-19// 20-23// 24-27// 28-31IVFFileHeader/// IVFFileHeader 32-byte header for IVF files/// <https://wiki.multimedia.cx/index.php/IVF>// 4-11IVFFrameHeader/// IVFFrameHeader 12-byte header for IVF framesIVFReader/// IVFReader is used to read IVF files and return frame payloads/// new returns a new IVF reader and IVF file header/// with an io.Reader input/// reset_reader resets the internal stream of IVFReader. This is useful/// for live streams, where the end of the file might be read without the/// data being finished.parse_next_frame/// parse_next_frame reads from stream and returns IVF frame payload, header,/// Returns all nil values when no more frames are available.parse_file_header/// parse_file_header reads 32 bytes from stream and returns/// IVF file header. This is always called before parse_next_frame()test_ivf_writer_add_packet_and_closeivf_writer_testivf_readerseen_key_frameis_vp9IVFWriter/// IVFWriter is used to take RTP packets and write them to an IVF on disk/// new initialize a new IVF writer with an io.Writer output/// close stops the recordingh264_readerh264_writerivf_writerogg_readerogg_writersample_builder// Add the content of an RTP packet to the media// close the media// Note: close implementation must be idempotent// Writer defines an interface to handle// the creation of media filesogg_reader_testPAGE_HEADER_TYPE_CONTINUATION_OF_STREAMPAGE_HEADER_TYPE_BEGINNING_OF_STREAMPAGE_HEADER_TYPE_END_OF_STREAMDEFAULT_PRE_SKIPPAGE_HEADER_SIGNATURE// 3840 recommended in the RFCID_PAGE_SIGNATURECOMMENT_PAGE_SIGNATUREPAGE_HEADER_SIZEID_PAGE_PAYLOAD_SIZEchecksum_tabledo_checksumOggReader/// OggReader is used to read Ogg files and return page payloadsoutput_gainpre_skipOggHeader/// OggHeader is the metadata from the first two pages/// in the file (ID and Comment)/// <https://tools.ietf.org/html/rfc7845.html#section-3>granule_positionheader_typesegments_countOggPageHeader/// OggPageHeader is the metadata for a Page/// Pages are the fundamental unit of multiplexing in an Ogg stream/// <https://tools.ietf.org/html/rfc7845.html#section-1>/// new returns a new Ogg reader and Ogg headerread_headersparse_next_page// parse_next_page reads from stream and returns Ogg page payload, header,// and an error if there is incomplete page data./// reset_reader resets the internal stream of OggReader. This is usefulupdate_checksumgenerate_checksum_tablebuild_ogg_container// generates a valid ogg file that can be used for teststest_ogg_reader_parse_valid_headertest_ogg_reader_parse_next_pagetest_ogg_reader_parse_errorsogg_writer_testpage_indexprevious_granule_positionprevious_timestamplast_payload_sizelast_payloadOggWriter/// OggWriter is used to take RTP packets and write them to an OGG on disk/// new initialize a new OGG Opus writer with an io.Writer outputwrite_page/*
        ref: https://tools.ietf.org/html/rfc7845.html
        https://git.xiph.org/?p=opus-tools.git;a=blob;f=src/opus_header.c#l219

           Page 0         Pages 1 ... n        Pages (n+1) ...
        +------------+ +---+ +---+ ... +---+ +-----------+ +---------+ +--
        |            | |   | |   |     |   | |           | |         | |
        |+----------+| |+-----------------+| |+-------------------+ +-----
        |||ID Header|| ||  Comment Header || ||Audio Data Packet 1| | ...
        |+----------+| |+-----------------+| |+-------------------+ +-----
        |            | |   | |   |     |   | |           | |         | |
        +------------+ +---+ +---+ ... +---+ +-----------+ +---------+ +--
        ^      ^                           ^
        |      |                           |
        |      |                           Mandatory Page Break
        |      |
        |      ID header is contained on a single page
        |
        'Beginning Of Stream'

       Figure 1: Example Packet Organization for a Logical Ogg Opus Stream
    */test_ogg_writer_add_packet_and_closetest_ogg_writer_add_packettest_ogg_writer_add_packet_of_255test_ogg_writer_add_large_packettest_ogg_writer_add_large_packet_with_multiple_of_255sample_builder_testsample_sequence_location_testsample_sequence_locationComparisonSampleSequenceLocationmax_late/// how many packets to wait until we get a valid Samplemax_late_timestamp/// max timestamp between old and new timestamps before dropping packetsprepared_sampleslast_sample_timestampdepacketizer/// Interface that allows us to take RTP packets to samples/// sample_rate allows us to compute duration of media.SamplecA/// filled contains the head/tail of the packets inserted into the buffer/// active contains the active head/tail of the timestamp being actively processedprepared/// prepared contains the samples that have been processed to datedropped_packets/// number of packets forced to be droppedpadding_packets/// number of padding packets detected and dropped. This number will be a subset of/// `dropped_packets`/// SampleBuilder buffers packets until media frames are complete./// Constructs a new SampleBuilder./// `max_late` is how long to wait until we can construct a completed [`Sample`]./// `max_late` is measured in RTP packet sequence numbers./// A large max_late will result in less packet loss but higher latency./// The depacketizer extracts media samples from RTP packets./// Several depacketizers are available in package [github.com/pion/rtp/codecs](https://github.com/webrtc-rs/rtp/tree/main/src/codecs).with_max_time_delaytoo_oldfetch_timestamp/// Returns the timestamp associated with a given sample locationrelease_packetpurge_consumed_buffers/// Clears all buffers that have already been consumed by/// popping.purge_consumed_location/// Clears all buffers that have already been consumed/// during a sample building method.purge_buffers/// Flushes all buffers that are already consumed or those buffers/// that are too late to consume./// Adds an RTP Packet to self's buffer./// Push does not copy the input. If you wish to reuse/// this memory make sure to copy before calling pushbuild_sample/// Creates a sample from a valid collection of RTP Packets by/// walking forwards building a sample if everything looks good clear and/// update buffer+values/// Compiles pushed RTP packets into media samples and then/// returns the next valid sample (or None if no sample is compiled).pop_with_timestamp/// returns the next valid sample with its associated RTP timestamp (or `None` if/// no sample is compiled).seqnum_distanceNoActiveSegment/// There's no active segment of RTP packets to consider yet.NothingToConsume/// No sample partition could be found in the active segment.PendingTimestampPacket/// A segment to consume was identified, but a subsequent packet is needed to determine the/// duration of the sample.InvalidPartition/// The active segment's head was not aligned with a sample partition head. Some packets wereGapInSegment/// There was a gap in the active segment because of one or more missing RTP packets.DepacketizerFailed/// We failed to depacketize an RTP packet.// Computes the distance between two sequence numbers/*pub(crate) fn seqnum_distance(head: u16, tail: u16) -> u16 {
    if head > tail {
        head.wrapping_add(tail)
    } else {
        tail - head
    }
}*/// Turns u8 integers into Bytes Arraywith_head_checkerhead_bytesextra_pop_attemptsSampleBuilderTesthead_checkerFakeDepacketizertest_sample_buildertest_sample_builder_max_late// SampleBuilder should respect maxLate if we popped successfully but then have a gap larger then maxLatetest_seqnum_distancetest_sample_builder_clean_referencetest_sample_builder_push_max_zerotest_pop_with_timestamptest_too_old_timestamp_wrappingtest_too_old_ok_timestamp_wrappingtest_sample_builder_dataInside/// head is the first packet in a sequence/// tail is always set to one after the final sequence number,/// so if `head == tail` then the sequence is emptytest_sample_sequence_location_comparetest_sample_sequence_location_range/// The assembled data in the sample, as a bitstream./// The format is Codec dependant, but is always a bitstream format/// rather than the packetized format used when carried over RTP./// See: [`rtp::packetizer::Depacketizer`] and implementations of it for more details./// The wallclock time when this sample was generated./// The duration of this samplepacket_timestamp/// The RTP packet timestamp of this sample./// For all RTP packets that contributed to a single sample the timestamp is the same.prev_dropped_packets/// The number of packets that were dropped prior to building this sample./// Packets being dropped doesn't necessarily indicate something wrong, e.g., packets are sometimes/// dropped because they aren't relevant for sample building.prev_padding_packets/// The number of packets that were identified as padding prior to building this sample./// Some implementations, notably libWebRTC, send padding packets to keep the send rate steady./// These packets don't carry media and aren't useful for building samples./// This field can be combined with [`Sample::prev_dropped_packets`] to determine if any/// dropped packets are likely to have detrimental impact on the steadiness of the RTP stream./// ## Example adjustment/// # use bytes::Bytes;/// # use std::time::{SystemTime, Duration};/// # use webrtc_media::Sample;/// # let sample = Sample {/// #   data: Bytes::new(),/// #   timestamp: SystemTime::now(),/// #   duration: Duration::from_secs(0),/// #   packet_timestamp: 0,/// #   prev_dropped_packets: 10,/// #   prev_padding_packets: 15/// let adjusted_dropped =/// sample.prev_dropped_packets.saturating_sub(sample.prev_padding_packets);/// A Sample contains encoded media and timing informationDumbConncreate_association_internalAssociationInternaltest_create_forward_tsn_forward_one_abandonedtest_create_forward_tsn_forward_two_abandoned_with_the_same_sitest_handle_forward_tsn_forward_3unreceived_chunkstest_handle_forward_tsn_forward_1for1_missingtest_handle_forward_tsn_forward_1for2_missingtest_handle_forward_tsn_dup_forward_tsn_chunk_should_generate_sacktest_assoc_create_new_streamhandle_init_testAssociationStatetest_assoc_handle_inittest_assoc_max_message_size_defaulttest_assoc_max_message_size_explicitassociation_internal_testparam_forward_tsn_supportedParamForwardTsnSupportedParamTypeparam_unrecognizedParamUnrecognizedinflight_queue_lengthwill_send_shutdownawake_write_loop_chpeer_verification_tagmy_verification_tagmy_next_tsnpeer_last_tsn// nextTSNmin_tsn2measure_rtt// lastRcvdTSNwill_send_forward_tsn// for RTT measurementwill_retransmit_fastwill_retransmit_reconfigwill_send_shutdown_ackwill_send_shutdown_completemy_next_rsn// ReconfigreconfigsChunkReconfigreconfig_requestsParamOutgoingResetRequestsource_port// Non-RFC internal datamy_max_num_inbound_streamsmy_max_num_outbound_streamsmy_cookieParamStateCookiepayload_queuePayloadQueueinflight_queuepending_queuePendingQueuecontrol_queueControlQueuemax_payload_sizecumulative_tsn_ack_point// max DATA chunk payload sizeadvanced_peer_tsn_ack_pointuse_forward_tsnmax_receive_buffer_size// Congestion control parametersrwnd// my congestion window size// calculated peer's receiver windows sizepartial_bytes_acked// slow start thresholdin_fast_recoveryfast_recover_exit_pointrto_mgrRtoManager// RTX & Ack timert1initRtxTimert1cookiet2shutdownt3rtxtreconfigack_timerAckTimerstored_initChunkInit// Chunks stored for retransmissionstored_cookie_echoChunkCookieEchoclose_loop_ch_txaccept_ch_txhandshake_completed_ch_txdelayed_ack_triggered// per inbound packet contextimmediate_ack_triggeredAssociationStatsack_stateAckStateack_modeAckMode// for testingsend_init/// caller must hold self.locksend_cookie_echoclose_all_timersawake_write_loopunregister_stream/// unregister_stream un-registers a stream from the association/// The caller should hold the association write lock./// handle_inbound parses incoming raw packetsgather_data_packets_to_retransmitgather_outbound_data_and_reconfig_packetsgather_outbound_fast_retransmission_packetsgather_outbound_sack_packetsgather_outbound_forward_tsn_packetsgather_outbound_shutdown_packetsgather_outbound/// gather_outbound gathers outgoing packets. The returned bool value set to/// false means the association should be closed down after the final send./// set_state atomically sets the state of the Association./// get_state atomically returns the state of the Association.handle_inithandle_init_ackhandle_heartbeatChunkHeartbeathandle_cookie_echohandle_cookie_ackhandle_dataChunkPayloadDatahandle_peer_last_tsn_and_acknowledgement/// A common routine for handle_data and handle_forward_tsn routinesget_my_receiver_window_creditcreate_stream/// create_stream creates a stream. The caller should hold the lock and check no stream exists for this id.get_or_create_stream/// get_or_create_stream gets or creates a stream. The caller should hold the lock.process_selective_ackChunkSelectiveAckon_cumulative_tsn_ack_point_advancedprocess_fast_retransmissionhandle_sackpostprocess_sack/// The caller must hold the lock. This method was only added because the/// linter was complaining about the "cognitive complexity" of handle_sack.handle_shutdownChunkShutdownhandle_shutdown_ackChunkShutdownAckhandle_shutdown_completeChunkShutdownCompletecreate_forward_tsnChunkForwardTsn/// create_forward_tsn generates ForwardTSN chunk./// This method will be be called if use_forward_tsn is set to false.create_packet/// create_packet wraps chunks in a packet./// The caller should hold the read lock.handle_reconfighandle_forward_tsnsend_reset_requesthandle_reconfig_paramreset_streams_if_anymove_pending_data_chunk_to_inflight_queue/// Move the chunk peeked with self.pending_queue.peek() to the inflight_queue.pop_pending_data_chunks_to_send/// pop_pending_data_chunks_to_send pops chunks from the pending queues as many as/// the cwnd and rwnd allows to send.bundle_data_chunks_into_packets/// bundle_data_chunks_into_packets packs DATA chunks into packets. It tries to bundle/// DATA chunks into a packet so long as the resulting packet size does not exceed/// the path MTU.check_partial_reliability_statusget_data_packets_to_retransmit/// get_data_packets_to_retransmit is called when T3-rtx is timed out and retransmit outstanding data chunks/// that are not acked or abandoned yet.generate_next_tsn/// generate_next_tsn returns the my_next_tsn and increases it. The caller should hold the lock.generate_next_rsn/// generate_next_rsn returns the my_next_rsn and increases it. The caller should hold the lock.create_selective_ack_chunkhandle_chunk_starthandle_chunk_endhandle_chunk/// buffered_amount returns total amount (in bytes) of currently buffered user data./// This is used only by testing.on_ack_timeoutAckTimerObserveron_retransmission_timeoutRtxTimerIdon_retransmission_failureRtxTimerObservern_datasn_sacksn_t3timeoutsn_ack_timeoutsn_fast_retransinc_datasget_num_datasinc_sacksget_num_sacksinc_t3timeoutsget_num_t3timeoutsinc_ack_timeoutsget_num_ack_timeoutsinc_fast_retransget_num_fast_retranschunk_selective_ackGapAckBlockflush_buffersestablish_session_pairtest_assoc_reliable_simpletest_assoc_reliable_ordered_reorderedtest_assoc_reliable_ordered_fragmented_then_defragmentedtest_assoc_reliable_unordered_fragmented_then_defragmentedtest_assoc_reliable_unordered_orderedtest_assoc_reliable_retransmissiontest_assoc_reliable_short_buffertest_assoc_unreliable_rexmit_ordered_no_fragmenttest_assoc_unreliable_rexmit_ordered_fragmenttest_assoc_unreliable_rexmit_unordered_no_fragmenttest_assoc_unreliable_rexmit_unordered_fragmenttest_assoc_unreliable_rexmit_timed_orderedtest_assoc_unreliable_rexmit_timed_unorderedtest_assoc_congestion_control_fast_retransmissiontest_assoc_congestion_control_congestion_avoidancetest_assoc_congestion_control_slow_readertest_assoc_reset_close_one_waytest_assoc_reset_close_both_waystest_assoc_abortwr_txrd_rxFakeEchoConntype_erasedUResultcreate_assocstest_association_shutdowntest_association_shutdown_during_writetest_association_handle_packet_before_init//TODO: TestAssocT1InitTimer//TODO: TestAssocT1CookieTimer//TODO: TestAssocT3RtxTimer/*FIXME
use std::io::Write;

#[tokio::test]
async fn test_assoc_delayed_ack() -> Result<()> {
    env_logger::Builder::new()
        .format(|buf, record| {
            writeln!(
                buf,
                "{}:{} [{}] {} - {}",
                record.file().unwrap_or("unknown"),
                record.line().unwrap_or(0),
                record.level(),
                chrono::Local::now().format("%H:%M:%S.%6f"),
                record.args()
            )
        })
        .filter(None, log::LevelFilter::Trace)
        .init();

    const SI: u16 = 6;
    let mut sbuf = vec![0u8; 1000];
    let mut rbuf = vec![0u8; 1500];
    fill(&mut sbuf[..]);
    fill(&mut rbuf[..]);

    let (br, ca, cb) = Bridge::new(0, None, None);

    let (a0, mut a1) =
        create_new_association_pair(&br, Arc::new(ca), Arc::new(cb), AckMode::AlwaysDelay, 0)
            .await?;

    let (s0, s1) = establish_session_pair(&br, &a0, &mut a1, SI).await?;

    {
        let a = a0.association_internal.lock().await;
        let b = a1.association_internal.lock().await;
        a.stats.reset();
        b.stats.reset();
    }

    let n = s0
        .write_sctp(
            &Bytes::from(sbuf.clone()),
            PayloadProtocolIdentifier::Binary,
        )?;
    assert_eq!(n, sbuf.len(), "unexpected length of received data");

    // Repeat calling br.Tick() until the buffered amount becomes 0
    let since = SystemTime::now();
    let mut n_packets_received = 0;
    while s0.buffered_amount() > 0 {
        loop {
            let n = br.tick().await;
            if n == 0 {
                break;
            }
        }

        loop {
            let readable = {
                let q = s1.reassembly_queue.lock().await;
                q.is_readable()
            };
            if !readable {
                break;
            }
            let (n, ppi) = s1.read_sctp(&mut rbuf).await?;
            assert_eq!(n, sbuf.len(), "unexpected length of received data");
            assert_eq!(ppi, PayloadProtocolIdentifier::Binary, "unexpected ppi");

            n_packets_received += 1;
        }
    }
    let delay = (SystemTime::now().duration_since(since).unwrap().as_millis() as f64) / 1000.0;
    log::debug!("received in {} seconds", delay);
    assert!(delay >= 0.2, "should be >= 200msec");

    br.process().await;

    assert_eq!(n_packets_received, 1, "unexpected num of packets received");
    assert_eq!(
        s1.get_num_bytes_in_reassembly_queue().await,
        0,
        "reassembly queue should be empty"
    );

    {
        let a = a0.association_internal.lock().await;
        let b = a1.association_internal.lock().await;

        log::debug!("nDATAs      : {}", b.stats.get_num_datas());
        log::debug!("nSACKs      : {}", a.stats.get_num_sacks());
        log::debug!("nAckTimeouts: {}", b.stats.get_num_ack_timeouts());

        assert_eq!(b.stats.get_num_datas(), 1, "DATA chunk count mismatch");
        assert_eq!(
            a.stats.get_num_sacks(),
            b.stats.get_num_datas(),
            "sack count should be equal to the number of data chunks"
        );
        assert_eq!(
            b.stats.get_num_ack_timeouts(),
            1,
            "ackTimeout count mismatch"
        );
        assert_eq!(a.stats.get_num_t3timeouts(), 0, "should be no retransmit");
    }

    close_association_pair(&br, a0, a1).await;

    Ok(())
}
*/association_testassociation_internalassociation_statschunk_abortChunkAbortchunk_cookie_ackChunkCookieAckchunk_cookie_echochunk_errorChunkErrorchunk_forward_tsnChunkForwardTsnStreamchunk_heartbeatchunk_heartbeat_ackChunkHeartbeatAckchunk_initchunk_reconfigchunk_shutdownchunk_shutdown_ackchunk_shutdown_completeerror_causeparam_heartbeat_infoParamHeartbeatInfoparam_outgoing_reset_requestparam_reconfig_responseParamReconfigResponseReconfigResultparam_state_cookieparam_supported_extensionsParamSupportedExtensionsrtx_timer/// MTU for inbound packet (from DTLS)INITIAL_RECV_BUF_SIZE/// initial MTU for outgoing packets (to DTLS)COMMON_HEADER_SIZEDATA_CHUNK_HEADER_SIZEDEFAULT_MAX_MESSAGE_SIZEACCEPT_CH_SIZE/// other constantsCookieWaitCookieEchoedShutdownAckSentShutdownPendingShutdownReceivedShutdownSent/// association state enumsT1InitT1CookieT2ShutdownT3RTXReconfig/// retransmission timer IDsAlwaysDelay/// ack mode (for testing)// ack timer is off// will send ack immediately// ack timer is on (ack is being delayed)/// ack transmission statenet_connremote_portlocal_port/// Config collects the arguments to create_association construction into// TODO: Convert into `u32`, as there is no reason why the `max_message_size` should need to be// changed after the Assocaition has been created. Note that even if there was a use case for// this, it is not used anywhere in the code base.// Using atomics where not necessary -- especially in a hot path such as `prepare_write` -- may// negatively impact performance, and adds unneeded complexity to the code.close_loop_ch_rxaccept_ch_rx///Association represents an SCTP association///13.2.  Parameters Necessary per Association (i.e., the TCB)///Peer : Tag value to be sent in every packet and is received///Verification: in the INIT or INIT ACK chunk.///Tag :///My : Tag expected in every inbound packet and sent in the///Verification: INIT or INIT ACK chunk.///State : A state variable indicating what state the association/// : is in, i.e., COOKIE-WAIT, COOKIE-ECHOED, ESTABLISHED,/// : SHUTDOWN-PENDING, SHUTDOWN-SENT, SHUTDOWN-RECEIVED,/// : SHUTDOWN-ACK-SENT./// No Closed state is illustrated since if a/// association is Closed its TCB SHOULD be removed./// server accepts a SCTP stream over a conn/// Client opens a SCTP stream over a conn/// Shutdown initiates the shutdown sequence. The method blocks until the/// shutdown sequence is completed and the connection is closed, or until the/// passed context is done, in which case the context's error is returned./// Close ends the SCTP Association and cleans up any statewrite_loop/// bytes_sent returns the number of bytes sent/// bytes_received returns the number of bytes received/// open_stream opens a streamaccept_stream/// accept_stream accepts a stream/// max_message_size returns the maximum message size you can send.set_max_message_size/// set_max_message_size sets the maximum message size you can send.chunk_headererror_causesErrorCause///Abort represents an SCTP Chunk of type ABORT///The ABORT chunk is sent to the peer of an association to close the///association.  The ABORT chunk may contain Cause Parameters to inform///the receiver about the reason of the abort.  DATA chunks MUST NOT be///bundled with ABORT.  Control chunks (except for INIT, INIT ACK, and///SHUTDOWN COMPLETE) MAY be bundled with an ABORT, but they MUST be///placed before the ABORT in the SCTP packet or they will be ignored by///the receiver.///|   Type = 6    |Reserved     |T|           Length              |///|                                                               |///|                   zero or more Error Causes                   |/// String makes chunkAbort printablevalue_length/// chunkCookieAck represents an SCTP Chunk of type chunkCookieAck/// |   Type = 11   |Chunk  Flags   |     Length = 4                |/// makes ChunkCookieAck printable/// CookieEcho represents an SCTP Chunk of type CookieEcho/// |   Type = 10   |Chunk  Flags   |         Length                |/// |                     Cookie                                    |/// makes ChunkCookieEcho printable///Operation Error (ERROR) (9)///An endpoint sends this chunk to its peer endpoint to notify it of///certain error conditions.  It contains one or more error causes.  An///Operation Error is not considered fatal in and of itself, but may be///used with an ERROR chunk to report a fatal condition.  It has the///following parameters:///|   Type = 9    | Chunk  Flags  |           Length              |///|                    one or more Error Causes                   |///Chunk Flags: 8 bits///  Set to 0 on transmit and ignored on receipt.///Length: 16 bits (unsigned integer)///  Set to the size of the chunk in bytes, including the chunk header///  and all the Error Cause fields present./// makes ChunkError printablenew_cumulative_tsn/// This indicates the new cumulative TSN to the data receiver.  Upon/// the reception of this value, the data receiver MUST consider/// any missing TSNs earlier than or equal to this value as received,/// and stop reporting them as gaps in any subsequent SACKs.///This chunk shall be used by the data sender to inform the data///receiver to adjust its cumulative received TSN point forward because///some missing TSNs are associated with data chunks that SHOULD NOT be///transmitted or retransmitted by the sender.///|   Type = 192  |  Flags = 0x00 |        Length = Variable      |///|                      New Cumulative TSN                       |///|         Stream-1              |       Stream Sequence-1       |///|         Stream-N              |       Stream Sequence-N       |NEW_CUMULATIVE_TSN_LENGTHFORWARD_TSN_STREAM_LENGTH/// makes ChunkForwardTsn printable/// This field holds a stream number that was skipped by this/// FWD-TSN./// This field holds the sequence number associated with the stream/// that was skipped.  The stream sequence field holds the largest/// stream sequence number in this stream being skipped.  The receiver/// of the FWD-TSN's can use the Stream-N and Stream Sequence-N fields/// to enable delivery of any stranded TSN's that remain on the stream/// re-ordering queues.  This field MUST NOT report TSN's corresponding/// to DATA chunks that are marked as unordered.  For ordered DATA/// chunks this field MUST be filled in./// makes ChunkForwardTsnStream printable///chunkHeader represents a SCTP Chunk header, defined in https://tools.ietf.org/html/rfc4960#section-3.2///The figure below illustrates the field format for the chunks to be///transmitted in the SCTP packet.  Each chunk is formatted with a Chunk///Type field, a chunk-specific Flag field, a Chunk Length field, and a///Value field.///|   Chunk Type  | Chunk  Flags  |        Chunk Length           |///|                          Chunk Value                          |CHUNK_HEADER_SIZE/// makes ChunkHeader printableparam_header///chunkHeartbeat represents an SCTP Chunk of type HEARTBEAT///An endpoint should send this chunk to its peer endpoint to probe the///reachability of a particular destination transport address defined in///the present association.///The parameter field contains the Heartbeat Information, which is a///variable-length opaque data structure understood only by the sender.///|   Type = 4    | Chunk  Flags  |      Heartbeat Length         |///|            Heartbeat Information TLV (Variable-Length)        |///Defined as a variable-length parameter using the format described///in Section 3.2.1, i.e.:///Variable Parameters                  Status     Type Value///-------------------------------------------------------------///heartbeat Info                       Mandatory   1/// makes ChunkHeartbeat printable///chunkHeartbeatAck represents an SCTP Chunk of type HEARTBEAT ACK///An endpoint should send this chunk to its peer endpoint as a response///to a HEARTBEAT chunk (see Section 8.3).  A HEARTBEAT ACK is always///sent to the source IP address of the IP datagram containing the///HEARTBEAT chunk to which this ack is responding.///The parameter field contains a variable-length opaque data structure.///|   Type = 5    | Chunk  Flags  |    Heartbeat Ack Length       |///Heartbeat Info                       Mandatory   1/// makes ChunkHeartbeatAck printableinitiate_tagadvertised_receiver_window_creditnum_outbound_streamsnum_inbound_streamsinitial_tsn///chunkInitCommon represents an SCTP Chunk body of type INIT and INIT ACK///|   Type = 1    |  Chunk Flags  |      Chunk Length             |///|                         Initiate Tag                          |///|           Advertised Receiver Window Credit (a_rwnd)          |///|  Number of Outbound Streams   |  Number of Inbound Streams    |///|                          Initial TSN                          |///|              Optional/Variable-Length Parameters              |///The INIT chunk contains the following parameters.  Unless otherwise///noted, each parameter MUST only be included once in the INIT chunk.///Fixed Parameters                     Status///----------------------------------------------///Initiate Tag                        Mandatory///Advertised Receiver Window Credit   Mandatory///Number of Outbound Streams          Mandatory///Number of Inbound Streams           Mandatory///Initial TSN                         Mandatory///Init represents an SCTP Chunk of type INIT///See chunkInitCommon for the fixed headers///IPv4 IP (Note 1)               Optional    5///IPv6 IP (Note 1)               Optional    6///Cookie Preservative                 Optional    9///Reserved for ECN Capable (Note 2)   Optional    32768 (0x8000)///Host Name IP (Note 3)          Optional    11///Supported IP Types (Note 4)    Optional    12/// chunkInitAck represents an SCTP Chunk of type INIT ACK///State Cookie                        Mandatory   7///Unrecognized Parameter              Optional    8///Host Name IP (Note 3)          Optional    11<Paste>INIT_CHUNK_MIN_LENGTHINIT_OPTIONAL_VAR_HEADER_LENGTH/// makes chunkInitCommon printable/// Chunk values of SCTP control chunks consist of a chunk-type-specific/// header of required fields, followed by zero or more parameters.  The/// optional and variable-length parameters contained in a chunk are/// defined in a Type-Length-Value format as shown below./// |          Parameter Type       |       Parameter Length        |/// |                       Parameter Value                         |/// * [RFC 4960 §3.2.1]/// [RFC 4960 §3.2.1]: https://tools.ietf.org/html/rfc4960#section-3.2.1set_supported_extensionsPAYLOAD_DATA_ENDING_FRAGMENT_BITMASKPAYLOAD_DATA_BEGINNING_FRAGMENT_BITMASKPAYLOAD_DATA_UNORDERED_BITMASKPAYLOAD_DATA_IMMEDIATE_SACKPAYLOAD_DATA_HEADER_SIZEDcepStringEmptyBinaryEmpty/// PayloadProtocolIdentifier is an enum for DataChannel payload types/// PayloadProtocolIdentifier enums/// https://www.iana.org/assignments/sctp-parameters/sctp-parameters.xhtml#sctp-parameters-25beginning_fragmentending_fragmentimmediate_sacktsnstream_sequence_numberacked/// Whether this data chunk was acknowledged (received by peer)miss_indicator/// Partial-reliability parameters used only by sendernsent/// number of transmission made for this chunkabandoned/// valid only with the first fragmentall_inflight/// Retransmission flag set when T1-RTX timeout occurred and this/// chunk is still in the inflight queue///chunkPayloadData represents an SCTP Chunk of type DATA///|   Type = 0    | Reserved|U|B|E|    Length                     |///|                              TSN                              |///|      Stream Identifier S      |   Stream Sequence Number n    |///|                  Payload Protocol Identifier                  |///|                 User Data (seq n of Stream S)                 |///An unfragmented user message shall have both the B and E bits set to///'1'.  Setting both B and E bits to '0' indicates a middle fragment of///a multi-fragment user message, as summarized in the following table:///   B E                  Description///============================================================///|  1 0 | First piece of a fragmented user message          |///+----------------------------------------------------------+///|  0 0 | Middle piece of a fragmented user message         |///|  0 1 | Last piece of a fragmented user message           |///|  1 1 | Unfragmented message                              |///|             Table 1: Fragment Description Flags          |/// makes chunkPayloadData printableset_abandonedset_all_inflightparam_aparam_b///https://tools.ietf.org/html/rfc6525#section-3.1///chunkReconfig represents an SCTP Chunk used to reconfigure streams.///| Type = 130    |  Chunk Flags  |      Chunk Length             |///|                  Re-configuration Parameter                   |///|             Re-configuration Parameter (optional)             |/// makes chunkReconfig printable///chunkSelectiveAck represents an SCTP Chunk of type SACK///This chunk is sent to the peer endpoint to acknowledge received DATA///chunks and to inform the peer endpoint of gaps in the received///subsequences of DATA chunks as represented by their TSNs.///0                   1                   2                   3///0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1///|   Type = 3    |Chunk  Flags   |      Chunk Length             |///|                      Cumulative TSN Ack                       |///|          Advertised Receiver Window Credit (a_rwnd)           |///| Number of Gap Ack Blocks = N  |  Number of Duplicate TSNs = X |///|  Gap Ack Block #1 Start       |   Gap Ack Block #1 End        |///|                              ...                              |///|   Gap Ack Block #N Start      |  Gap Ack Block #N End         |///|                       Duplicate TSN 1                         |///|                       Duplicate TSN X                         |/// makes gapAckBlock printablecumulative_tsn_ackgap_ack_blocksduplicate_tsn/// makes chunkSelectiveAck printableSELECTIVE_ACK_HEADER_SIZE///chunkShutdown represents an SCTP Chunk of type chunkShutdown///|   Type = 7    | Chunk  Flags  |      Length = 8               |CUMULATIVE_TSN_ACK_LENGTH/// makes chunkShutdown printable///chunkShutdownAck represents an SCTP Chunk of type chunkShutdownAck///|   Type = 8    | Chunk  Flags  |      Length = 4               |/// makes chunkShutdownAck printable///chunkShutdownComplete represents an SCTP Chunk of type chunkShutdownComplete///|   Type = 14   |Reserved     |T|      Length = 4               |/// makes chunkShutdownComplete printable/////////////////////////////////////////////////////////////////////chunk_type_testtest_chunk_type_string//chunk_abort_testtest_abort_chunk_one_error_causetest_abort_chunk_many_error_causes//chunk_error_testCHUNK_FLAGSORG_UNRECOGNIZED_CHUNKtest_chunk_error_unrecognized_chunk_type_unmarshaltest_chunk_error_unrecognized_chunk_type_marshaltest_chunk_error_unrecognized_chunk_type_marshal_with_cause_value_being_nil//chunk_forward_tsn_testCHUNK_FORWARD_TSN_BYTEStest_chunk_forward_tsn_successtest_chunk_forward_tsn_unmarshal_failure//chunk_reconfig_testTEST_CHUNK_RECONFIG_PARAM_ATEST_CHUNK_RECONFIG_PARAM_BTEST_CHUNK_RECONFIG_RESPONSEtest_chunk_reconfig_successtest_chunk_reconfig_unmarshal_failure//chunk_shutdown_testtest_chunk_shutdown_successtest_chunk_shutdown_failure//chunk_shutdown_ack_testtest_chunk_shutdown_ack_successtest_chunk_shutdown_ack_failure//chunk_shutdown_complete_testtest_chunk_shutdown_complete_successtest_chunk_shutdown_complete_failure//chunk_testtest_init_chunktest_init_acktest_chrome_chunk1_inittest_chrome_chunk2_init_acktest_init_marshal_unmarshaltest_payload_data_marshal_unmarshaltest_select_ack_chunktest_reconfig_chunktest_forward_tsn_chunktest_select_ack_chunk_followed_by_a_payload_data_chunk// chunkType is an enum for SCTP Chunk Type field// This field identifies the type of information contained in the// Chunk Value field.CT_PAYLOAD_DATACT_INITCT_INIT_ACKCT_SACKCT_HEARTBEATCT_HEARTBEAT_ACKCT_ABORTCT_SHUTDOWNCT_SHUTDOWN_ACKCT_ERRORCT_COOKIE_ECHOCT_COOKIE_ACKCT_ECNECT_CWRCT_SHUTDOWN_COMPLETECT_RECONFIGCT_FORWARD_TSNChunkUnknownchunk_testchunk_unknownErrChunkHeaderTooSmallErrChunkHeaderNotEnoughSpaceErrChunkHeaderPaddingNonZeroErrChunkHeaderInvalidLengthErrChunkTypeNotAbortErrBuildAbortChunkFailedErrChunkTypeNotCookieAckErrChunkTypeNotCookieEchoErrChunkTypeNotCtErrorErrBuildErrorChunkFailedErrMarshalStreamFailedErrChunkTooShortErrChunkTypeNotForwardTsnErrChunkTypeNotHeartbeatErrChunkTypeNotHeartbeatAckErrHeartbeatNotLongEnoughInfoErrParseParamTypeFailedErrHeartbeatParamErrHeartbeatChunkUnmarshalErrUnimplementedErrHeartbeatAckParamsErrHeartbeatAckNotHeartbeatInfoErrHeartbeatAckMarshalParamErrErrorCauseTooSmallErrParamTypeUnhandledErrParamTypeUnexpectedErrParamHeaderTooShortErrParamHeaderSelfReportedLengthShorterErrParamHeaderSelfReportedLengthLongerErrParamHeaderParseFailedErrParamPacketTooShortErrSsnResetRequestParamTooShortErrReconfigRespParamTooShortErrInvalidAlgorithmTypeErrInitChunkParseParamTypeFailedErrInitChunkUnmarshalParamErrInitAckMarshalParamErrChunkTypeNotTypeInitErrChunkValueNotLongEnoughErrChunkTypeInitFlagZeroErrChunkTypeInitUnmarshalFailedErrChunkTypeInitMarshalFailedErrChunkTypeInitInitiateTagZeroErrInitInboundStreamRequestZeroErrInitOutboundStreamRequestZeroErrInitAdvertisedReceiver1500ErrChunkPayloadSmallErrChunkTypeNotPayloadDataErrChunkTypeNotReconfigErrChunkReconfigInvalidParamAErrChunkParseParamTypeFailedErrChunkMarshalParamAReconfigFailedErrChunkMarshalParamBReconfigFailedErrChunkTypeNotSackErrSackSizeNotLargeEnoughInfoErrInvalidChunkSizeErrChunkTypeNotShutdownErrChunkTypeNotShutdownAckErrChunkTypeNotShutdownCompleteErrPacketRawTooSmallErrParseSctpChunkNotEnoughDataErrUnmarshalUnknownChunkTypeErrUnexpectedChuckPoppedUnorderedErrUnexpectedChuckPoppedOrderedErrUnexpectedQStateErrChunkErrShutdownNonEstablishedErrAssociationClosedBeforeConnErrAssociationInitFailedErrAssociationHandshakeClosedErrSilentlyDiscardErrInitNotStoredToSendErrCookieEchoNotStoredToSendErrSctpPacketSourcePortZeroErrSctpPacketDestinationPortZeroErrInitChunkBundledErrInitChunkVerifyTagNotZeroErrHandleInitStateErrInitAckNoCookieErrStreamAlreadyExistErrStreamCreateFailedErrInflightQueueTsnPopErrTsnRequestNotExistErrResetPacketInStateNotExistErrParameterTypeErrPayloadDataStateNotExistErrChunkTypeUnhandledErrHandshakeInitAckErrHandshakeCookieEchoErrOutboundPacketTooLargeErrEofErrInvalidSystemTimeErrNetConnReadErrorErrorCauseCode/// errorCauseCode is a cause code that appears in either a ERROR or ABORT chunkINVALID_STREAM_IDENTIFIERMISSING_MANDATORY_PARAMETERSTALE_COOKIE_ERROROUT_OF_RESOURCEUNRESOLVABLE_ADDRESSUNRECOGNIZED_CHUNK_TYPEINVALID_MANDATORY_PARAMETERUNRECOGNIZED_PARAMETERSNO_USER_DATACOOKIE_RECEIVED_WHILE_SHUTTING_DOWNRESTART_OF_AN_ASSOCIATION_WITH_NEW_ADDRESSESUSER_INITIATED_ABORT/// ErrorCauseHeader represents the shared header that is shared by all error causesErrorCauseInvalidMandatoryParameter/// ErrorCauseInvalidMandatoryParameter represents an SCTP error causeErrorCauseUnrecognizedChunkType/// ErrorCauseUnrecognizedChunkType represents an SCTP error causeErrorCauseProtocolViolation/// This error cause MAY be included in ABORT chunks that are sent/// because an SCTP endpoint detects a protocol violation of the peer/// that is not covered by the error causes described in Section 3.3.10.1/// to Section 3.3.10.12.  An implementation MAY provide additional/// information specifying what kind of protocol violation has been/// detected.///      0                   1                   2                   3///      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1///     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+///     |         Cause Code=13         |      Cause Length=Variable    |///     /                    Additional Information                     ////     \                                                               \ERROR_CAUSE_HEADER_LENGTH/// makes ErrorCauseHeader printableerror_cause_codeparam_crash_artifactspacket_crash_artifacts//! # What are these tests?//! These tests ensure that regressions in the unmarshalling code are caught.//! They check all artifacts of the fuzzer that crashed this lib, and make sure they no longer crash the library.//! The content of the files is mostly garbage, but it triggers "interesting" behaviour in the unmarshalling code.//! So if your change fails one of these tests you probably made an error somewhere.//! Sadly these tests cannot really tell you where your error is specifically outside the standard backtrace rust will provide to you. Sorry.fuzz_artifact_testverification_tag/// Packet represents an SCTP packet/// An SCTP packet is composed of a common header and chunks.  A chunk/// contains either control information or user data.///SCTP Packet Format///|                        Common Header                          |///|                          Chunk #1                             |///|                           ...                                 |///|                          Chunk #n                             |///SCTP Common Header Format///|     Source Value Number        |     Destination Value Number |///|                      Verification Tag                         |///|                           Checksum                            |/// * [RFC 4960 §3]/// [RFC 4960 §3]: https://tools.ietf.org/html/rfc4960#section-3/// makes packet printablePACKET_HEADER_SIZEcheck_packettest_packet_marshal/*fn BenchmarkPacketGenerateChecksum(b *testing.B) {
        var data [1024]byte

        for i := 0; i < b.N; i++ {
            _ = generatePacketChecksum(data[:])
        }
    }*/param_testparam_chunk_listparam_randomparam_requested_hmac_algorithmparam_unknownParamChunkListParamRandomParamRequestedHmacAlgorithmParamUnknownParamHeaderbuild_paramchunk_types/// At the initialization of the association, the sender of the INIT or/// INIT ACK chunk MAY include this OPTIONAL parameter to inform its peer/// that it is able to support the Forward TSN chunk///|    Parameter Type = 49152     |  Parameter Length = 4         |PARAM_HEADER_LENGTH/// String makes paramHeader printableheartbeat_informationPARAM_OUTGOING_RESET_REQUEST_STREAM_IDENTIFIERS_OFFSETreconfig_request_sequence_number/// reconfig_request_sequence_number is used to identify the request.  It is a monotonically/// increasing number that is initialized to the same value as the/// initial TSN.  It is increased by 1 whenever sending a new Re-/// configuration Request Parameter.reconfig_response_sequence_number/// When this Outgoing SSN Reset Request Parameter is sent in response/// to an Incoming SSN Reset Request Parameter, this parameter is also/// an implicit response to the incoming request.  This field then/// holds the Re-configuration Request Sequence Number of the incoming/// request.  In other cases, it holds the next expected/// Re-configuration Request Sequence Number minus 1.sender_last_tsn/// This value holds the next TSN minus 1 -- in other words, the last/// TSN that this sender assigned.stream_identifiers/// This optional field, if included, is used to indicate specific/// streams that are to be reset.  If no streams are listed, then all/// streams are to be reset.///This parameter is used by the sender to request the reset of some or///all outgoing streams.///|     Parameter Type = 13       | Parameter Length = 16 + 2 * N |///|           Re-configuration Request Sequence Number            |///|           Re-configuration Response Sequence Number           |///|                Sender's Last Assigned TSN                     |///|  Stream Number 1 (optional)   |    Stream Number 2 (optional) |///|                            ......                             |///|  Stream Number N-1 (optional) |    Stream Number N (optional) |random_dataSuccessNopSuccessPerformedErrorWrongSsnErrorRequestAlreadyInProgressErrorBadSequenceNumber/// This value is copied from the request parameter and is used by the/// receiver of the Re-configuration Response Parameter to tie the/// response to the request./// This value describes the result of the processing of the request.///This parameter is used by the receiver of a Re-configuration Request///Parameter to respond to the request.///|     Parameter Type = 16       |      Parameter Length         |///|         Re-configuration Response Sequence Number             |///|                            Result                             |///|                   Sender's Next TSN (optional)                |///|                  Receiver's Next TSN (optional)               |HmacAlgorithmHmacResv1HmacSha128HmacResv2available_algorithms/// String makes paramStateCookie printable//param_type_testtest_parse_param_type_success//param_header_testPARAM_HEADER_BYTEStest_param_header_successtest_param_header_unmarshal_failure//param_forward_tsn_supported_testPARAM_FORWARD_TSN_SUPPORTED_BYTEStest_param_forward_tsn_supported_successtest_param_forward_tsn_supported_failure//param_outgoing_reset_request_testCHUNK_RECONFIG_PARAM_ACHUNK_RECONFIG_PARAM_Btest_param_outgoing_reset_request_successtest_param_outgoing_reset_request_failure//param_reconfig_response_testCHUNK_RECONFIG_RESPONSEtest_param_reconfig_response_successtest_param_reconfig_response_failuretest_reconfig_result_stringertest_build_param_successtest_build_param_failure//param_testHeartbeatInfo/// Heartbeat Info [RFCRFC4960]/// IPv4 IP [RFCRFC4960]StateCookie/// IPv6 IP [RFCRFC4960]UnrecognizedParam/// State Cookie [RFCRFC4960]CookiePreservative/// Unrecognized Parameters [RFCRFC4960]HostNameAddr/// Cookie Preservative [RFCRFC4960]SupportedAddrTypes/// Host Name IP [RFCRFC4960]OutSsnResetReq/// Supported IP Types [RFCRFC4960]IncSsnResetReq/// Outgoing SSN Reset Request Parameter [RFCRFC6525]SsnTsnResetReq/// Incoming SSN Reset Request Parameter [RFCRFC6525]ReconfigResp/// SSN/TSN Reset Request Parameter [RFCRFC6525]AddOutStreamsReq/// Re-configuration Response Parameter [RFCRFC6525]AddIncStreamsReq/// Add Outgoing Streams Request Parameter [RFCRFC6525]/// Add Incoming Streams Request Parameter [RFCRFC6525]ChunkList/// Random (0x8002) [RFCRFC4805]ReqHmacAlgo/// Chunk List (0x8003) [RFCRFC4895]/// Requested HMAC Algorithm Parameter (0x8004) [RFCRFC4895]SupportedExt/// Padding (0x8005)ForwardTsnSupp/// Supported Extensions (0x8008) [RFCRFC5061]AddIpAddr/// Forward TSN supported (0xC000) [RFCRFC3758]DelIpaddr/// Add IP IP (0xC001) [RFCRFC5061]ErrClauseInd/// Delete IP IP (0xC002) [RFCRFC5061]SetPriAddr/// Error Cause Indication (0xC003) [RFCRFC5061]SuccessInd/// Set Primary IP (0xC004) [RFCRFC5061]AdaptLayerInd/// Success Indication (0xC005) [RFCRFC5061]/// Adaptation Layer Indication (0xC006) [RFCRFC5061]/// paramType represents a SCTP INIT/INITACK parameter/// This type is meant to represent ANY parameter for un/remarshaling purposes, where we do not have a more specific type for it./// This means we do not really understand the semantics of the param but can represent it./// This is useful for usage in e.g.`ParamUnrecognized` where we want to report some unrecognized params back to the sender./// This is the parameter type used to report unrecognized parameters in e.g. init chunks back to the sender in the init ack./// The contained param is likely to be a `ParamUnknown` but might be something more specific./// control queuequeue_testreassembly_queuechunk_mapdup_tsnpush_no_check/// push pushes a payload data. If the payload data is already in our queue or/// older than our cumulative_tsn marker, it will be recorded as duplications,/// which can later be retrieved using popDuplicates./// pop pops only if the oldest chunk's TSN matches the given TSN./// get returns reference to chunkPayloadData with the given TSN value.pop_duplicates/// popDuplicates returns an array of TSN values that were found duplicate.get_gap_ack_blocksget_gap_ack_blocks_stringmark_as_ackedget_last_tsn_receivedmark_all_to_retrasmitget_num_bytesQUEUE_BYTES_LIMIT// Some tests push a lot of data before starting to process any data...QUEUE_APPEND_LARGE/// Total user data size, beyond which the packet will be split into chunks. The chunks will be/// added to the pending queue one by one.PendingBaseQueue/// Basic queue for either ordered or unordered chunks.semaphore_lock// These two fields limit appending bytes to the queue// This two step process is necessary because// A) We need backpressure which the semaphore applies by limiting the total amount of bytes via the permits// B) The chunks of one fragmented message need to be put in direct sequence into the queue which the lock guarantees// The semaphore is not inside the lock because the permits need to be returned without needing a lock on the semaphoreunordered_queueordered_queuequeue_lenunordered_is_selected/// A queue for both ordered and unordered chunks./// Appends a chunk to the back of the pending queue./// Appends chunks to the back of the pending queue./// If it's a mix of unordered and ordered chunks.append_large// If this is a very large message we append chunks one by one to allow progress while we are appendingappend_unlimited/// Assumes that A) enough permits have been acquired and forget from the semaphore and that the semaphore_lock is held// TODO: benchmark performance between multiple Atomic+Mutex vs one Mutex<PendingQueueInternal>//payload_queue_testmake_payloadtest_payload_queue_push_no_checktest_payload_queue_get_gap_ack_blocktest_payload_queue_get_last_tsn_receivedtest_payload_queue_mark_all_to_retrasmittest_payload_queue_reset_retransmit_flag_on_ack//pending_queue_testNO_FRAGMENTFRAG_BEGINFRAG_MIDDLEFRAG_ENDmake_data_chunktest_pending_base_queue_push_and_poptest_pending_base_queue_out_of_bouncetest_pending_queue_push_and_poptest_pending_queue_unordered_winstest_pending_queue_fragmentstest_pending_queue_selection_persistencetest_pending_queue_append//reassembly_queue_testtest_reassembly_queue_ordered_fragmentstest_reassembly_queue_unordered_fragmentstest_reassembly_queue_ordered_and_unordered_fragmentstest_reassembly_queue_unordered_complete_skips_incompletetest_reassembly_queue_ignores_chunk_with_wrong_sitest_reassembly_queue_ignores_chunk_with_stale_ssntest_reassembly_queue_should_fail_to_read_incomplete_chunktest_reassembly_queue_should_fail_to_read_if_the_nex_ssn_is_not_readytest_reassembly_queue_detect_buffer_too_shorttest_reassembly_queue_forward_tsn_for_ordered_fragmentstest_reassembly_queue_forward_tsn_for_unordered_fragmentstest_chunk_set_empty_chunk_settest_chunk_set_push_dup_chunks_to_chunk_settest_chunk_set_incomplete_chunk_set_no_beginningtest_chunk_set_incomplete_chunk_set_no_contiguous_tsnsort_chunks_by_tsnsort_chunks_by_ssnChunkSetssn/// used only with the ordered chunks/// chunkSet is a set of chunks that share the same SSNnext_ssn/// expected SSN for next ordered chunkunordered_chunksReassemblyQueue/// From RFC 4960 Sec 6.5:///   The Stream Sequence Number in all the streams MUST start from 0 when///   the association is Established.  Also, when the Stream Sequence///   Number reaches the value 65535 the next Stream Sequence Number MUST///   be set to 0.find_complete_unordered_chunk_setforward_tsn_for_ordered/// Use last_ssn to locate a chunkSet then remove it if the set has/// not been completeforward_tsn_for_unordered/// Remove all fragments in the unordered sets that contains chunks/// equal to or older than `new_cumulative_tsn`./// We know all sets in the r.unordered are complete ones./// Just remove chunks that are equal to or older than new_cumulative_tsn/// from the unordered_chunkssubtract_num_bytesstream_testReliabilityType/// ReliabilityTypeReliable is used for reliable transmissionRexmit/// ReliabilityTypeRexmit is used for partial reliability by retransmission countTimed/// ReliabilityTypeTimed is used for partial reliability by retransmission duration// clone from associationdefault_payload_type//PayloadProtocolIdentifier,read_notifierread_shutdownwrite_shutdownreliability_typereliability_value//ReliabilityType,buffered_amount_low/// Stream represents an SCTP stream/// stream_identifier returns the Stream identifier associated to the stream.set_default_payload_type/// set_default_payload_type sets the default payload type used by write.set_reliability_params/// set_reliability_params sets reliability parameters for this stream./// Reads a packet of len(p) bytes, dropping the Payload Protocol Identifier./// Returns `Error::ErrShortBuffer` if `p` is too short./// Returns `0` if the reading half of this stream is shutdown or it (the stream) was reset.read_sctp/// Reads a packet of len(p) bytes and returns the associated Payload Protocol Identifier./// Returns `(0, PayloadProtocolIdentifier::Unknown)` if the reading half of this stream is shutdown or it (the stream) was reset.handle_forward_tsn_for_orderedhandle_forward_tsn_for_unordered/// Writes `p` to the DTLS connection with the default Payload Protocol Identifier./// Returns an error if the write half of this stream is shutdown or `p` is too large.write_sctp/// Writes `p` to the DTLS connection with the given Payload Protocol Identifier.prepare_write/// common stuff for write and try_write/// Closes both read and write halves of this stream./// Use [`Stream::shutdown`] instead./// Shuts down the read, write, or both halves of this stream./// This function will cause all pending and future I/O on the specified portions to return/// immediately with an appropriate value (see the documentation of [`Shutdown`])./// Resets the stream when both halves of this stream are shutdown./// buffered_amount returns the number of bytes of data currently queued to be sent over this stream./// buffered_amount_low_threshold returns the number of bytes of buffered outgoing data that is/// considered "low." Defaults to 0./// on_buffered_amount_low sets the callback handler which would be called when the number of/// bytes of outgoing data buffered is lower than the threshold.on_buffer_released/// This method is called by association's read_loop (go-)routine to notify this stream/// of the specified amount of outgoing data has been delivered to the peer.get_num_bytes_in_reassembly_queue/// get_num_bytes_in_reassembly_queue returns the number of bytes of data currently queued to/// be read (once chunk is complete).send_payload_dataShutdownFut/// Shutdown future has runget_shutting_down_mut/// Gets a mutable reference to the future stored inside `ShuttingDown(future)`./// Panics if `ShutdownFut` variant is not `ShuttingDown`.PollStream/// A wrapper around around [`Stream`], which implements [`AsyncRead`] and/// Constructs a new `PollStream`./// Get back the inner stream./// Obtain a clone of the inner stream.// TODO: benchmark performance between multiple Atomic+Mutex vs one Mutex<StreamInternal>create_test_streamtest_stream_buffered_amounttest_stream_amount_on_buffered_amount_lowtest_poll_streamACK_INTERVAL" ackTimerObserver is the interface to an ack timer observer."timeout_observer/// ackTimer provides the retnransmission timer conforms with RFC 4960 Sec 6.3.1/// newAckTimer creates a new acknowledgement timer used to enable delayed ack./// start starts the timer./// stops the timer. this is similar to stop() but subsequent start() call/// will fail (the timer is no longer usable)/// isRunning tests if the timer is running./// Debug purpose onlytimer_testRTO_INITIALRTO_MIN// msecRTO_MAXRTO_ALPHARTO_BETARTO_BASEMAX_INIT_RETRANSPATH_MAX_RETRANSNO_MAX_RETRANSsrttrttvarno_update/// rtoManager manages Rtx timeout values./// This is an implementation of RFC 4960 sec 6.3.1./// newRTOManager creates a new rtoManager.set_new_rtt/// set_new_rtt takes a newly measured RTT then adjust the RTO in msec.get_rto/// get_rto simply returns the current RTO in msec./// reset resets the RTO variables to the initial values.set_rto/// set RTO value for testingcalculate_next_timeout" rtxTimerObserver is the interface to a timer observer."" NOTE: Observers MUST NOT call start() or stop() method on rtxTimer"" from within these callbacks."max_retrans/// rtxTimer provides the retnransmission timer conforms with RFC 4960 Sec 6.3.1/// newRTXTimer creates a new retransmission timer./// if max_retrans is set to 0, it will keep retransmitting until stop() is called./// (it will never make on_retransmission_failure() callback./// stop stops the timer.//ack_timer_testncbsTestAckTimerObservertest_ack_timer_start_and_stoptest_ack_timer//rtx_timer_testtest_rto_manager_initial_valuestest_rto_manager_rto_calculation_small_rtttest_rto_manager_rto_calculation_large_rtttest_rto_manager_calculate_next_timeouttest_rto_manager_resettest_rto_managertimer_idmax_rtosTestTimerObservertest_rtx_timer_callback_intervaltest_rtx_timer_last_start_winstest_rtx_timer_stop_right_after_starttest_rtx_timer_start_stop_then_starttest_rtx_timer_start_and_stop_in_atight_looptest_rtx_timer_should_stop_after_rtx_failuretest_rtx_timer_should_not_stop_if_max_retrans_is_zerotest_rtx_timer_stop_timer_that_is_not_running_is_nooptest_rtx_timer_closed_timer_wont_starttest_rtx_timer//TODO: remove this conditional testPADDING_MULTIPLEFOUR_ZEROES/// Allocate and zero this data once./// We need to use it for the checksum and don't want to allocate/clear each time.ISCSI_CRCgenerate_packet_checksum/// Fastest way to do a crc32 without allocating.sna32lt/// Serial Number Arithmetic (RFC 1982)sna32ltesna32gtsna32gtesna32eqsna16ltsna16ltesna16gtsna16gtesna16eqtest_serial_number_arithmetic32bittest_serial_number_arithmetic16bitkey_derivationCIPHER_AEAD_AES_GCM_AUTH_TAG_LENRTCP_ENCRYPTION_FLAGsrtp_ciphersrtcp_ciphersrtp_session_saltsrtcp_session_salt_tagCipherAeadAesGcm/// AEAD Cipher based on AES.rtp_auth_tag_lenrtcp_auth_tag_len/// Get RTCP authenticated tag length.aead_auth_tag_len/// Get AEAD auth key length of the cipher.encrypt_rtpdecrypt_rtpencrypt_rtcpdecrypt_rtcpget_rtcp_indexNS/// Create a new AEAD instance.rtp_initialization_vector/// The 12-octet IV used by AES-GCM SRTP is formed by first concatenating/// 2 octets of zeroes, the 4-octet SSRC, the 4-octet rollover counter/// (ROC), and the 2-octet sequence number (SEQ).  The resulting 12-octet/// value is then XORed to the 12-octet salt to form the 12-octet IV./// https://tools.ietf.org/html/rfc7714#section-8.1rtcp_initialization_vector/// The 12-octet IV used by AES-GCM SRTCP is formed by first/// concatenating 2 octets of zeroes, the 4-octet SSRC identifier,/// 2 octets of zeroes, a single "0" bit, and the 31-bit SRTCP index./// The resulting 12-octet value is then XORed to the 12-octet salt to/// form the 12-octet IV./// https://tools.ietf.org/html/rfc7714#section-9.1rtcp_additional_authenticated_data/// In an SRTCP packet, a 1-bit Encryption flag is prepended to the/// 31-bit SRTCP index to form a 32-bit value we shall call the/// "ESRTCP word"/// https://tools.ietf.org/html/rfc7714#section-17test_aead_aes_gcm_128test_aead_aes_gcm_256CipherInnerAes128Ctrsrtp_session_keysrtcp_session_keyCipherAesCmHmacSha1/// Get RTP authenticated tag length.ctrcipherCIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LENsrtp_session_authsrtcp_session_authgenerate_srtp_auth_tag/// https://tools.ietf.org/html/rfc3711#section-4.2/// In the case of SRTP, M SHALL consist of the Authenticated/// Portion of the packet (as specified in Figure 1) concatenated with/// the roc, M = Authenticated Portion || roc;/// The pre-defined authentication transform for SRTP is HMAC-SHA1/// [RFC2104].  With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL/// be 0.  For SRTP (respectively SRTCP), the HMAC SHALL be applied to/// the session authentication key and M as specified above, i.e.,/// HMAC(k_a, M).  The HMAC output SHALL then be truncated to the n_tag/// left-most bits./// - Authenticated portion of the packet is everything BEFORE MKI/// - k_a is the session message authentication key/// - n_tag is the bit-length of the output authentication taggenerate_srtcp_auth_tagrtp_ctxrtcp_ctxcipher_aead_aes_gcmcipher_aes_cm_hmac_sha1/// Retrieved RTCP index./// Encrypt RTP payload./// Decrypt RTP payload./// Encrypt RTCP payload./// Decrypt RTCP payload.///NOTE: Auth tag and AEAD auth tag are placed at the different position in SRTCP///In non-AEAD cipher, the authentication tag is placed *after* the ESRTCP word///(Encrypted-flag and SRTCP index).///> AES_128_CM_HMAC_SHA1_80///> | RTCP Header | Encrypted payload |E| SRTCP Index | Auth tag |///>                                   ^               |----------|///>                                   |                ^///>                                   |                authTagLen=10///>                                   aeadAuthTagLen=0///In AEAD cipher, the AEAD authentication tag is embedded in the ciphertext.///It is *before* the ESRTCP word (Encrypted-flag and SRTCP index).///> AEAD_AES_128_GCM///> | RTCP Header | Encrypted payload | AEAD auth tag |E| SRTCP Index |///>                                   |---------------|               ^///>                                    ^                              authTagLen=0///>                                    aeadAuthTagLen=16///See https://tools.ietf.org/html/rfc7714 for the full specifications./// Cipher represents a implementation of one/// of the SRTP Specific ciphers.LABEL_EXTRACTOR_DTLS_SRTPlocal_master_keylocal_master_saltremote_master_keyremote_master_saltSessionKeys/// SessionKeys bundles the keys required to setup an SRTP sessionlocal_rtp_optionsContextOption//LoggerFactory: logging.LoggerFactory/// List of local/remote context options./// ReplayProtection is enabled on remote context by default./// Default replay protection window size is 64.remote_rtp_optionslocal_rtcp_optionsremote_rtcp_options/// Config is used to configure a session./// You can provide either a KeyingMaterialExporter to export keys/// or directly pass the keys themselves./// After a Config is passed to a session it must not be modified.extract_session_keys_from_dtls/// ExtractSessionKeysFromDTLS allows setting the Config SessionKeys by/// extracting them from DTLS. This behavior is defined in RFC5764:/// <https://tools.ietf.org/html/rfc5764>CIPHER_CONTEXT_ALGODEFAULT_SSRCtest_context_roctest_context_indextest_key_lentest_valid_packet_countertest_rollover_counttest_rollover_count_overflowtest_rollover_count_2test_encrypt_rtptest_decrypt_rtptest_encrypt_rtcptest_decrypt_rtcpcontext_testsrtcp_testsrtp_testMAX_ROCSEQ_NUM_MEDIANSEQ_NUM_MAXrollover_has_processedSrtpSsrcState/// Encrypt/Decrypt state for a single SRTP SSRCsrtcp_indexSrtcpSsrcState/// Encrypt/Decrypt state for a single SRTCP SSRCnext_rollover_countupdate_rollover_count/// https://tools.ietf.org/html/rfc3550#appendix-A.1srtp_ssrc_statessrtcp_ssrc_statesnew_srtp_replay_detectornew_srtcp_replay_detector/// Context represents a SRTP cryptographic context/// Context can only be used for one-way operations/// it must either used ONLY for encryption or ONLY for decryption/// CreateContext creates a new SRTP Contextget_srtp_ssrc_stateget_srtcp_ssrc_stateget_roc/// roc returns SRTP rollover counter value of specified SSRC.set_roc/// set_roc sets SRTP rollover counter value of specified SSRC./// index returns SRTCP index value of specified SSRC./// set_index sets SRTCP index value of specified SSRC./// DecryptRTCP decrypts a RTCP packet with an encrypted payload/// EncryptRTCP marshals and encrypts an RTCP packet, writing to the dst buffer provided./// If the dst buffer does not have the capacity to hold `len(plaintext) + 14` bytes, a new one will be allocated and returned.decryptedRTCPTestCasetest_rtcp_lifecycletest_rtcp_invalid_auth_tagtest_rtcp_replay_detector_separationtest_encrypt_rtcp_separationtest_decrypt_invalid_srtcptest_encrypt_invalid_srtcpdecrypt_rtp_with_header/// DecryptRTP decrypts a RTP packet with an encrypted payloadencrypt_rtp_with_header/// EncryptRTP marshals and encrypts an RTP packet, writing to the dst buffer provided./// If the dst buffer does not have the capacity to hold `len(plaintext) + 10` bytes, a new one will be allocated and returned.RTPTestCasebuild_test_contexttest_rtp_invalid_authtest_rtp_lifecycletest_rtp_max_packetstest_rtp_burst_loss_with_set_roctest_decrypt_invalid_srtp//TODO: BenchmarkEncryptRTP//TODO: BenchmarkEncryptRTPInPlace//TODO: BenchmarkDecryptRTPErrDuplicatedErrShortSrtpMasterKeyErrShortSrtpMasterSaltErrNoSuchSrtpProfileErrNonZeroKdrNotSupportedErrExporterWrongLabelErrNoConfigErrNoConnErrFailedToVerifyAuthTagErrTooShortRtpErrTooShortRtcpErrPayloadDiffersErrStartedChannelUsedIncorrectlyErrExceededMaxPacketsErrStreamNotInitedErrStreamAlreadyClosedErrStreamAlreadyInitedErrFailedTypeAssertionUnsupportedIndexOverKdrInvalidMasterKeyLengthInvalidMasterSaltLengthUnsupportedOutLengthSrtpMasterKeyLengthSrtpSaltLengthExtMapParseSrtpSsrcDuplicatedSrtcpSsrcDuplicatedSsrcMissingFromSrtcpStreamWithSsrcExistsSessionRtpRtcpTypeMismatchSessionEofSrtpTooSmallSrtcpTooSmallRtpFailedToVerifyAuthTagRtcpInvalidLengthAuthTagRtcpFailedToVerifyAuthTagSessionSrtpAlreadyClosedInvalidRtpStreamInvalidRtcpStreamLABEL_SRTP_ENCRYPTIONLABEL_SRTP_AUTHENTICATION_TAGLABEL_SRTP_SALTLABEL_SRTCP_ENCRYPTIONLABEL_SRTCP_AUTHENTICATION_TAGLABEL_SRTCP_SALTSRTCP_INDEX_SIZEaes_cm_key_derivationAES_256_BS// As per https://datatracker.ietf.org/doc/html/rfc6188// The key derivation rate is zero as per https://datatracker.ietf.org/doc/html/rfc5764 hence index_over-kdr is 0aes_256_cm_key_derivationgenerate_counter/// Generate IV https://tools.ietf.org/html/rfc3711#section-4.1.1/// where the 128-bit integer value IV SHALL be defined by the SSRC, the/// SRTP packet index i, and the SRTP session salting key k_s, as below./// ROC = a 32-bit unsigned rollover counter (roc), which records how many/// times the 16-bit RTP sequence number has been reset to zero after/// passing through 65,535/// i = 2^16 * roc + SEQ/// IV = (salt*2 ^ 16) | (ssrc*2 ^ 64) | (i*2 ^ 16)test_valid_session_keystest_index_over_kdr// This test asserts that calling aesCmKeyDerivation with a non-zero indexOverKdr fails// Currently this isn't supported, but the API makes sure we can add this in the futuretest_aes_256_cm_key_derivationMAX_SRTCP_INDEXsrtp_replay_protection/// srtp_replay_protection sets SRTP replay protection window size.srtcp_replay_protection/// Sets SRTCP replay protection window size.srtp_no_replay_protection/// srtp_no_replay_protection disables SRTP replay protection.srtcp_no_replay_protection/// srtcp_no_replay_protection disables SRTCP replay protection.Aes128CmHmacSha1_80Aes128CmHmacSha1_32AeadAes128GcmAeadAes256Gcm/// ProtectionProfile specifies Cipher and AuthTag details, similar to TLS cipher suitesalt_lenauth_key_lensession_rtcp_testsession_rtp_testDEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOWDEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOWlocal_contextstreams_mapnew_stream_rxclose_stream_txclose_session_txis_rtp/// Session implements io.ReadWriteCloser and provides a bi-directional SRTP session/// SRTP itself does not have a design like this, but it is common in most applications/// for local/remote to each have their own keying material. This provides those patterns/// instead of making everyone re-implement/// open on the given SSRC to create a stream, it can be used/// if you want a certain SSRC, but don't want to wait for Accept/// accept returns a stream to handle RTCP for a single SSRC/// create a list of Destination SSRCs/// that's a superset of all Destinations in the slice.build_session_srtcp_pairTEST_SSRCtest_session_srtcp_accepttest_session_srtcp_listenencrypt_srtcpPLI_PACKET_SIZEget_sender_ssrctest_session_srtcp_replay_protectionbuild_session_srtp_pairRTP_HEADER_SIZEtest_session_srtp_accepttest_session_srtp_listentest_session_srtp_multi_ssrcencrypt_srtppayload_srtptest_session_srtp_replay_protectionSRTP_BUFFER_SIZE/// Limit the buffer size to 1MBSRTCP_BUFFER_SIZE/// Limit the buffer size to 100KB/// Stream handles decryption for a single RTP/RTCP SSRC/// Create a new streamget_ssrc/// GetSSRC returns the SSRC we are demuxing foris_rtp_stream/// Check if RTP is a stream./// Read reads and decrypts full RTP packet from the nextConn/// ReadRTP reads and decrypts full RTP packet and its header from the nextConn/// read_rtcp reads and decrypts full RTP packet and its header from the nextConn/// Close removes the ReadStream from the session and cleans up any associated statetest_buffertest_wraparoundtest_buffer_wraparoundtest_buffer_wraparound_growtest_buffer_asynctest_buffer_limit_counttest_buffer_limit_sizetest_buffer_limit_sizestest_buffer_miscbuffer_testCUTOFF_SIZElimit_countlimit_sizeBufferInternal/// Buffer allows writing packets to an intermediate buffer, which can then be read form./// This is verify similar to bytes.Buffer but avoids combining multiple writes into a single read./// available returns true if the buffer is large enough to fit a packet/// of the given size, taking overhead into account./// grow increases the size of the buffer.  If it returns nil, then the/// buffer has been grown.  It returns ErrFull if hits a limit./// Write appends a copy of the packet data to the buffer./// Returns ErrFull if the packet doesn't fit./// Note that the packet size is limited to 65536 bytes since v0.11.0/// due to the internal data structure.// Read populates the given byte slice, returning the number of bytes read.// Blocks until data is available or the buffer is closed.// Returns io.ErrShortBuffer is the packet is too small to copy the Write.// Returns io.EOF if the buffer is closed.// Close will unblock any readers and prevent future writes.// Data in the buffer can still be read, returning io.EOF when fully depleted.// Count returns the number of packets in the buffer.set_limit_count// set_limit_count controls the maximum number of packets that can be buffered.// Causes Write to return ErrFull when this limit is reached.// A zero value will disable this limit.// Size returns the total byte size of packets in the buffer.set_limit_size// set_limit_size controls the maximum number of bytes that can be buffered.// A zero value means 4MB since v0.11.0.// User can set packetioSizeHardlimit build tag to enable 4MB hardlimit.// When packetioSizeHardlimit build tag is set, set_limit_size exceeding// the hardlimit will be silently discarded.TICK_WAITloss_chanceBridgeConn/// BridgeConn is a Conn that represents an endpoint of the bridge.FilterCbFndrop_nwritesreorder_nwrites/// Bridge represents a network between the two endpoints./// Len returns number of queued packets./// Reorder inverses the order of packets currently in the specified queue.drop_offset/// Drop drops the specified number of packets from the given offset index/// of the specified queue.drop_next_nwrites/// drop_next_nwrites drops the next n packets that will be written/// to the specified queue.reorder_next_nwrites/// reorder_next_nwrites drops the next n packets that will be written/// Tick attempts to hand a packet from the queue for each directions, to readers,/// if there are waiting on the queue. If there's no reader, it will return/// Process repeats tick() calls until no more outstanding packet in the queues.inverseMSG1MSG2test_bridge_normaltest_bridge_drop_first_packet_from_conn0test_bridge_drop_second_packet_from_conn0test_bridge_drop_first_packet_from_conn1test_bridge_drop_second_packet_from_conn1test_bridge_reorder_packets_from_conn0test_bridge_reorder_packets_from_conn1test_bridge_inverse_errortest_bridge_drop_next_n_packetsraddrpconnDisconnectedPacketConn/// Since UDP is connectionless, as a server, it doesn't know how to reply/// simply using the `Write` method. So, to make it work, `disconnectedPacketConn`/// will infer the last packet that it reads as the reply address for `Write`test_conn_lookup_hostDEFAULT_LISTEN_BACKLOGAcceptFilterFnAcceptDoneChUdpConnacceptingdone_ch_txch_rxListenerImpl/// listener is used in the [DTLS](https://github.com/webrtc-rs/dtls) and/// [SCTP](https://github.com/webrtc-rs/sctp) transport to provide a connection-oriented/// listener over a UDP." accept waits for and returns the next connection to the listener."" close closes the listener."/// Backlog defines the maximum length of the queue of pending/// connections. It is equivalent of the backlog argument of/// POSIX listen function./// If a connection request arrives when the queue is full,/// the request will be silently discarded, unlike TCP./// Set zero to use default value 128 which is same as Linux default.accept_filter/// AcceptFilter determines whether the new conn should be made for/// the incoming packet. If not set, any packet creates new conn.ListenConfig/// ListenConfig stores options for listening to an address./// Listen creates a new listener based on the ListenConfig./// read_loop has to tasks:/// 1. Dispatching incoming packets to the correct Conn.///    It can therefore not be ended until all Conns are closed./// 2. Creating a new Conn when receiving from a new remote.get_udp_conn/// UdpConn augments a connection-oriented connection over a UdpSocket// same as Linux defaulttest_listener_close_timeouttest_listener_close_unacceptedtest_listener_accept_filtertest_listener_concurrentconn_disconnected_packetconn_udpconn_bridge_testconn_pipe_testconn_udp_listener_test" Any blocked accept operations will be unblocked and return errors."" addr returns the listener\'s network address."" A Listener is a generic network listener for connection-oriented protocols."" Multiple connections may invoke methods on a Listener simultaneously."ErrBufferFullErrBufferClosedErrBufferShortErrPacketTooBigErrTimeoutErrClosedListenerErrListenQueueExceededErrClosedListenerAcceptChErrObsCannotBeNilErrUseClosedNetworkConnErrAddrNotUdpAddrErrLocAddrErrNoRemAddrErrAddressAlreadyInUseErrNoSuchUdpConnErrCannotRemoveUnspecifiedIpErrNoAddressAssignedErrNatRequiresMappingErrMismatchLengthIpErrNonUdpTranslationNotSupportedErrNoAssociatedLocalAddressErrNoNatBindingFoundErrHasNoPermissionErrHostnameEmptyErrFailedToParseIpaddrErrNoInterfaceErrNotFoundErrUnexpectedNetworkErrCantAssignRequestedAddrErrUnknownNetworkErrNoRouterLinkedErrInvalidPortNumberErrUnexpectedTypeSwitchFailureErrBindFailedErrEndPortLessThanStartErrPortSpaceExhaustedErrVnetDisabledErrInvalidLocalIpInStaticIpsErrLocalIpBeyondStaticIpsSubsetErrLocalIpNoStaticsIpsAssociatedErrRouterAlreadyStartedErrRouterAlreadyStoppedErrStaticIpIsBeyondSubnetErrAddressSpaceExhaustedErrNoIpaddrEth0ErrInvalidMaskParseIpnet/// An escape hatch to preserve stack traces when we don't know the error./// This crate exports some traits such as `Conn` and `Listener`. The trait functions/// produce the local error `util::Error`. However when used in crates higher up the stack,/// we are forced to handle errors that are local to that crate. For example we use/// `Listener` the `dtls` crate and it needs to handle `dtls::Error`./// By using `util::Error::from_std` we can preserve the underlying error (and stack trace!).test_fixed_big_int_set_bitfixed_big_int_testmsb_maskFixedBigInt// FixedBigInt is the fix-sized multi-word integer.lsh// lsh is the left shift operation.// bit returns i-th bit of the fixedBigInt.// set_bit sets i-th bit to 1.NextHopss_to_netsa/// Query the local system for all interface addresses.UINT8ULONG64guiddefPULONGSOCKET_ADDRESSPCHARPWCHARMAX_ADAPTER_ADDRESS_LENGTHZONE_INDICES_LENGTHMAX_DHCPV6_DUID_LENGTHMAX_DNS_SUFFIX_STRING_LENGTHIP_ADAPTER_IPV4_ENABLEDIP_ADAPTER_IPV6_ENABLEDERROR_ADDRESS_NOT_ASSOCIATEDERROR_INVALID_PARAMETERERROR_NOT_ENOUGH_MEMORYPREALLOC_ADAPTERS_LENIpAdapterAddressesHeadIpAdaptersAddressesAllxpIpAdaptersAddressesXpvistaIpAdaptersAddressesVistaIpAdapterAddressesadapter_namefirst_unicast_addressIpAdapterUnicastAddressfirst_anycast_addressIpAdapterAnycastAddressfirst_multicast_addressIpAdapterMulticastAddressfirst_dns_server_addressIpAdapterDnsServerAddressdns_suffixphysical_addressphysical_address_lengthoper_statusIfOperStatus/// All Windows & Lateripv6_if_indexzone_indicesfirst_prefixIpAdapterPrefix/// Windows XP & Latertransmit_link_speedreceive_link_speedfirst_wins_server_addressIpAdapterWinsServerAddressfirst_gateway_addressIpAdapterGatewayAddressipv4_metricipv6_metricIfLuiddhcpv4_servercompartment_idnetwork_guidconnection_typeNetIfConnectionTypetunnel_typeTunnelTypedhcpv6_serverdhcpv6_client_duiddhcpv6_client_duid_lengthdhcpv6_iaidfirst_dns_suffixIpAdapterDnsSuffix/// Windows Vista & Laterprefix_originIpPrefixOriginsuffix_originIpSuffixOrigindad_stateIpDadStatevalid_lifetimepreferred_lifetimelease_lifetimeon_link_prefix_lengthprefix_lengthIpPrefixOriginOtherIpPrefixOriginManualIpPrefixOriginWellKnownIpPrefixOriginDhcpIpPrefixOriginRouterAdvertisementIpPrefixOriginUnchangedIpSuffixOriginOtherIpSuffixOriginManualIpSuffixOriginWellKnownIpSuffixOriginDhcpIpSuffixOriginLinkLayerAddressIpSuffixOriginRandomIpSuffixOriginUnchangedIpDadStateInvalidIpDadStateTentativeIpDadStateDuplicateIpDadStateDeprecatedIpDadStatePreferredIfOperStatusUpIfOperStatusDownIfOperStatusTestingIfOperStatusUnknownIfOperStatusDormantIfOperStatusNotPresentIfOperStatusLowerLayerDownNetIfConnectionDedicatedNetIfConnectionPassiveNetIfConnectionDemandNetIfConnectionMaximumTunnelTypeNoneTunnelTypeOtherTunnelTypeDirectTunnelType6To4TunnelTypeIsatapTunnelTypeTeredoTunnelTypeIpHttpsv4_socket_from_adapterv6_socket_from_adapterlocal_ifaces_with_buffermap_adapter_addressesis_ipv4_enabledis_ipv6_enabledUnknowfixed_big_int" KeyingMaterialExporter to extract keying material."" This trait sits here to avoid getting a direct dependency between"" the dtls and srtp crates."HandshakeInProgressContextUnsupportedReservedExportKeyingMaterialCipherSuiteUnset/// Possible errors while exporting keying material./// These errors might have been more logically kept in the dtls/// crate, but that would have required a direct dependency between/// srtp and dtls.exact_size_bufExactSizeBuf/// Returns the exact length of the buffer./// Returns `true` if the buffer is empty./// This method has a default implementation using `ExactSizeBuf::len()`,/// so you don't need to implement it yourself./// A trait for buffers that know their exact length.// FIXME(regexident):// Replace with `bytes::ExactSizeBuf` once merged:// https://github.com/tokio-rs/bytes/pull/496replay_detector_test// Check returns true if given sequence number is not replayed.// Call accept() to mark the packet is received properly.// ReplayDetector is the interface of sequence replay detector.latest_seqmax_seqSlidingWindowDetector// New creates ReplayDetector.// Created ReplayDetector doesn't allow wrapping.// It can handle monotonically increasing sequence number up to// full 64bit number. It is suitable for DTLS replay protection.WrappedSlidingWindowDetector// WithWrap creates ReplayDetector allowing sequence wrapping.// This is suitable for short bitwidth counter like SRTP and SRTCP.NoOpReplayDetectortest_replay_detector/// A synchronous mutual exclusion primitive useful for protecting shared data./// A synchronous reader-writer lock./// Locks this rwlock with exclusive write access, blocking the currenttest_tcp_frag_stringDEMO_IPtest_chunk_udpTAG_CTRbase36/// Encodes a u64 value to a lowercase base 36 string.assign_chunk_tag// Generate a base36-encoded unique tag// See: https://play.golang.org/p/0ZaAID1q-HNTcpFlagTCP_FLAG_ZERO// rhs is the "right-hand side" of the expression `a | b`// rhs is the "right-hand side" of the expression `a & b`// used by routerget_source_ipget_destination_ip// used by routeeset_source_addrset_destination_addr// used by natsource_addrdestination_addr// returns "udp" or "tcp"// Chunk represents a packet passed around in the vnetsource_ipdestination_ipChunkIpchunk_ipChunkUdp// control bits// only with PSH flag// seq             :u32,  // always starts with 0// ack             :u32,  // always starts with 0ChunkTcptest_chunk_queuechunk_queue_test// 0 or negative value: unlimitedChunkQueuenclosedDummyObserveron_closeddetermine_source_ipConnObservertest_udp_conn_send_to_recv_fromtest_udp_conn_send_recv" vNet implements this"ChunkChTxloc_addrrem_addr/// UDPConn is the implementation of the Conn and PacketConn interfaces for UDP network connections./// compatible with net.PacketConn and net.Connget_inbound_ch" recv_from reads a packet from the connection,"" copying the payload into p. It returns the number of"" bytes copied into p and the return address that"" It returns the number of bytes read (0 <= n <= len(p))"" the n > 0 bytes returned before considering the error err."" send_to writes a packet with payload p to addr."" send_to can be made to time out and return"test_udp_conn_map_insert_removetest_udp_conn_map_insert_0_removetest_udp_conn_map_find_0test_udp_conn_map_insert_many_ips_with_same_porttest_udp_conn_map_already_inuse_when_insert_0test_udp_conn_map_already_inuse_when_insert_a_specified_iptest_udp_conn_map_already_inuse_when_insert_same_specified_iptest_udp_conn_map_find_failure_1test_udp_conn_map_find_failure_2test_udp_conn_map_insert_two_on_same_port_then_removeconn_map_testPortMapport_mapUdpConnMapadd_addrchunk_queuetest_nat_type_defaulttest_nat_mapping_behavior_full_cone_nattest_nat_mapping_behavior_addr_restricted_cone_nattest_nat_mapping_behavior_port_restricted_cone_nattest_nat_mapping_behavior_symmetric_nat_addr_dependent_mappingtest_nat_mapping_behavior_symmetric_nat_port_dependent_mappingtest_nat_mapping_timeout_refresh_on_outboundtest_nat_mapping_timeout_outbound_detects_timeouttest_nat1to1_behavior_one_mappingtest_nat1to1_behavior_more_mappingtest_nat1to1_behavior_failure// oic: outbound internal chunk// oec: outbound external chunk// iic: inbound internal chunk// iec: inbound external chunknat_testUDP_STRDEFAULT_NAT_MAPPING_LIFE_TIMEEndpointDependencyTypeEndpointIndependent// EndpointIndependent means the behavior is independent of the endpoint's address or portEndpointAddrDependent// EndpointAddrDependent means the behavior is dependent on the endpoint's addressEndpointAddrPortDependent// EndpointAddrPortDependent means the behavior is dependent on the endpoint's address and port// EndpointDependencyType defines a type of behavioral dependency on the// remote endpoint's IP address or port number. This is used for the two// kinds of behaviors://  - Port Mapping behavior//  - Filtering behavior// See: https://tools.ietf.org/html/rfc4787NatMode// NATModeNormal means the NAT behaves as a standard NAPT (RFC 2663).Nat1To1// NATModeNAT1To1 exhibits 1:1 DNAT where the external IP address is statically mapped to// a specific local IP address with port number is preserved always between them.// When this mode is selected, mapping_behavior, filtering_behavior, port_preservation and// mapping_life_time of NATType are ignored.// NATMode defines basic behavior of the NATmapping_behaviorfiltering_behaviorhair_piningport_preservation// Not implemented yetmapping_life_time// NATType has a set of parameters that define the behavior of NAT.nat_typemapped_ipslocal_ips// mapped IPv4// local IPv4, required only when the mode is NATModeNAT1To1NatConfig// "udp" or "tcp"// "<local-ip>:<local-port>"// "<mapped-ip>:<mapped-port>"// key: "[<remote-ip>[:<remote-port>]]"// time to expireoutbound_mapinbound_map// key: "<proto>:<local-ip>:<local-port>[:remote-ip[:remote-port]]udp_port_counter// key: "<proto>:<mapped-ip>:<mapped-port>"NetworkAddressTranslatorget_paired_mapped_ipget_paired_local_iptranslate_outboundtranslate_inboundfind_outbound_mapping// caller must hold the mutexfind_inbound_mappingget_outbound_map_keyget_inbound_map_keyinbound_map_lenoutbound_map_lentest_net_native_interfacestest_net_native_resolve_addrtest_net_native_bindtest_net_native_dailtest_net_native_loopbacktest_net_native_unexpected_operationstest_net_virtual_interfacestest_net_virtual_interface_by_nametest_net_virtual_has_ipaddrtest_net_virtual_get_all_ipaddrstest_net_virtual_assign_porttest_net_virtual_determine_source_iptest_net_virtual_resolve_addrtest_net_virtual_loopback1test_net_virtual_bind_specific_porttest_net_virtual_dail_lo0test_net_virtual_dail_eth0test_net_virtual_resolvertest_net_virtual_loopback2get_ipaddrtest_net_virtual_end2endtest_net_virtual_two_ips_on_a_nicnet_testLO0_STRMAC_ADDR_COUNTERHardwareAddrnew_mac_address// read-onlyudp_connsVNetInternalstatic_ipsviadd_addrs_to_interfaceset_routeron_inbound_chunkget_static_ipsget_all_ipaddrshas_ipaddrallocate_local_addrassign_portdail// static_ips is an array of static IP addresses to be assigned for this Net.// If no static IP address is given, the router will automatically assign// an IP address.static_ip// static_ip is deprecated. Use static_ips.// NetConfig is a bag of configuration parameters passed to NewNet().Ifs// Net represents a local network stack equivalent to a set of layers from NIC// up to the transport (UDP / TCP) layer.// NewNet creates an instance of Net.// If config is nil, the virtual network is disabled. (uses corresponding// net.Xxxx() operations.// By design, it always have lo0 and eth0 interfaces.// The lo0 has the address 127.0.0.1 assigned by default.// IP address for eth0 will be assigned when this Net is added to a router.// Interfaces returns a list of the system's network interfaces.// InterfaceByName returns the interface specified by name.// IsVirtual tests if the virtual network is enabled.get_nictest_resolver_standalonetest_resolver_cascadedresolver_testadd_hoston_inbound_chunk_handlercbs0delay_resnpktsDummyNictest_router_standalone_cidr_parsingtest_router_standalone_assign_ip_addresstest_router_standalone_add_nettest_router_standalone_routingtest_router_standalone_add_chunk_filterdelay_sub_testtest_router_delaytest_router_one_childtest_router_static_ips_more_than_onetest_router_static_ips_static_ip_local_ip_mappingtest_router_static_ips_1to1_nattest_router_failures_stoptest_router_failures_add_nettest_router_failures_add_routerrouter_testDEFAULT_ROUTER_QUEUE_SIZEROUTER_ID_CTRassign_router_name// Generate a unique router name// name of router. If not specified, a unique name will be assigned.// cidr notation, like "192.0.2.0/24"// static_ips is an array of static IP addresses to be assigned for this router.// This will be ignored if this router is the root.queue_size// Internal queue size// Effective only when this router has a parent router// Minimum Delay// Max Jitter// RouterConfig ...ChunkFilterFn// ChunkFilter is a handler users can add to filter chunks.// If the filter returns false, the packet will be dropped.ipv4netnicschunk_filterslast_id// requires mutex [x]// requires mutex [x], used to assign the last digit of IPv4 addressRouterInternalstatic_local_ips// read-only,push_chrouter_internal// writer requires mutex// Router ...// Start ...// Stop ...start_childrenstop_childrenadd_router// AddRouter adds a chile Router.// after parent.add_router(child), also call child.set_router(parent) to set child's parent routeradd_net// AddNet ...// after router.add_net(nic), also call nic.set_router(router) to set nic's router// AddHost adds a mapping of hostname and an IP address to the local resolver.add_chunk_filter// AddChunkFilter adds a filter for chunks traversing this router.// You may add more than one filter. The filters are called in the order of this method call.// If a chunk is dropped by a filter, subsequent filter will not receive the chunk.process_chunksadd_nicassign_ip_address// caller should hold the mutex// unlimiteddelzwenlzwmin_codeParamErrorexplainBufferResultVectorResultStreamBufMAX_CODESIZESTREAM_BUF_SIZEStateful/// The state for decoding data with an LZW algorithm./// The same structure can be utilized with streams as well as your own buffers and driver logic./// It may even be possible to mix them if you are sufficiently careful not to lose or skip any/// already decode data in the process./// This is a sans-IO implementation, meaning that it only contains the state of the decoder and/// the caller will provide buffers for input and output data when calling the basic/// [`decode_bytes`] method. Nevertheless, a number of _adapters_ are provided in the `into_*`/// methods for decoding with a particular style of common IO./// * [`decode`] for decoding once without any IO-loop./// * [`into_async`] for decoding with the `futures` traits for asynchronous IO./// * [`into_stream`] for decoding with the standard `io` traits./// * [`into_vec`] for in-memory decoding./// [`decode_bytes`]: #method.decode_bytes/// [`decode`]: #method.decode/// [`into_async`]: #method.into_async/// [`into_stream`]: #method.into_stream/// [`into_vec`]: #method.into_vec/// A decoding stream sink./// See [`Decoder::into_stream`] on how to create this type./// [`Decoder::into_stream`]: struct.Decoder.html#method.into_stream/// A decoding sink into a vector./// See [`Decoder::into_vec`] on how to create this type./// [`Decoder::into_vec`]: struct.Decoder.html#method.into_vec/// Ignore an end code and continue decoding (no implied reset)./// Reset the decoder to the beginning, dropping all buffers etc./// A buffer of individual bits. The oldest code is kept in the high-order bits.code_mask/// A precomputed mask for this code./// The current code size./// The number of bits in the buffer.MsbBufferLsbBufferbump_code_size/// Retrieve the next symbol, refilling if necessary.refill_bits/// Refill the internal buffer./// Get the next buffered code word.max_codeCodeBuffer/// The original minimum code size./// The table of decoded codes./// The buffer of decoded data./// The link which we are still decoding and its original code.next_code/// The next code entry.clear_code/// Code to reset all tables./// Code to signal the end of the stream./// A stored flag if the end code has already appeared.is_tiff/// If tiff then bumps are a single code sooner.implicit_reset/// Do we allow stream to start without an explicit reset code?code_buffer/// The buffer for decoded words.read_markwrite_mark/// Create a new decoder with the specified bit order and symbol size./// The algorithm for dynamically increasing the code symbol bit width is compatible with the/// original specification. In particular you will need to specify an `Lsb` bit oder to decode/// the data portion of a compressed `gif` image./// The `size` needs to be in the interval `0..=12`.with_tiff_size_switch/// Create a TIFF compatible decoder with the specified bit order and symbol size./// TIFF specification, which is a misinterpretation of the original algorithm for increasing/// the code size. It switches one symbol sooner./// Decode some bytes from `inp` and write result to `out`./// This will consume a prefix of the input buffer and write decoded output into a prefix of/// the output buffer. See the respective fields of the return value for the count of consumed/// and written bytes. For the next call You should have adjusted the inputs accordingly./// The call will try to decode and write as many bytes of output as available. It will be/// much more optimized (and avoid intermediate buffering) if it is allowed to write a large/// contiguous chunk at once./// See [`into_stream`] for high-level functions (that are only available with the `std`/// feature)./// Decode a single chunk of lzw encoded data./// This method requires the data to contain an end marker, and returns an error otherwise./// This is a convenience wrapper around [`into_vec`]. Use the `into_vec` adapter to customize/// buffer size, to supply an existing vector, to control whether an end marker is required, or/// to preserve partial data in the case of a decoding error./// [`into_vec`]: #into_vec/// use weezl::{BitOrder, decode::Decoder};/// // Encoded that was created with an encoder./// let data = b"\x80\x04\x81\x94l\x1b\x06\xf0\xb0 \x1d\xc6\xf1\xc8l\x19 \x10";/// let decoded = Decoder::new(BitOrder::Msb, 9)///     .decode(data)/// assert_eq!(decoded, b"Hello, world");/// Construct a decoder into a writer.'lt/// Construct a decoder into a vector./// All decoded data is appended and the vector is __not__ cleared./// Compared to `into_stream` this interface allows a high-level access to decoding without/// requires the `std`-feature. Also, it can make full use of the extra buffer control that the/// special target exposes./// Check if the decoding has finished./// No more output is produced beyond the end code that marked the finish of the stream. The/// decoder may have read additional bytes, including padding bits beyond the last code word/// but also excess bytes provided./// Ignore an end code and continue./// This will _not_ reset any of the inner code tables and not have the effect of a clear code./// It will instead continue as if the end code had not been present. If no end code has/// occurred then this is a no-op./// You can test if an end code has occurred with [`has_ended`](#method.has_ended)./// FIXME: clarify how this interacts with padding introduced after end code./// Reset all internal state./// This produce a decoder as if just constructed with `new` but taking slightly less work. In/// particular it will not deallocate any internal allocations. It will also avoid some/// duplicate setup work./// Decode data from a reader./// This will read data until the stream is empty or an end marker is reached.decode_all/// Decode data from a reader, requiring an end marker./// Set the size of the intermediate decode buffer./// A buffer of this size is allocated to hold one part of the decoded stream when no buffer is/// available and any decoding method is called. No buffer is allocated if `set_buffer` has/// been called. The buffer is reused./// This method panics if `size` is `0`./// Use a particular buffer as an intermediate decode buffer./// Calling this sets or replaces the buffer. When a buffer has been set then it is used/// instead of dynamically allocating a buffer. Note that the size of the buffer is critical/// for efficient decoding. Some optimization techniques require the buffer to hold one or more/// previous decoded words. There is also additional overhead from `write` calls each time the/// buffer has been filled./// This method panics if the `buffer` is empty.decode_part/// Decode data from a slice./// This will read data until the slice is empty or an end marker is reached./// Decode data from a slice, requiring an end marker.grab_bufferinit_tablesreset_tablesfill_cscsc/// When encoding a sequence `cScSc` where `c` is any character and `S` is any string/// this results in two codes `AB`, `A` encoding `cS` and `B` encoding `cSc`. Supposing/// the buffer is already filled with the reconstruction of `A`, we can easily fill it/// with the reconstruction of `B`.fill_reconstruct// Fill the buffer by decoding from the tablereconstruct// TODO: this has self type to make it clear we might depend on the old in a future// optimization. However, that has no practical purpose right now.invalid_code_size_lowinvalid_code_size_highmake_encodedinto_stream_buffer_no_allocinto_stream_buffer_small_alloc//! A module for all decoding needs.IntoAsync/// Internally dispatch via a dynamic trait object. This did not have any significant/// performance impact as we batch data internally and this pointer does not change after/// creation!/// The state for encoding data with an LZW algorithm./// It may even be possible to mix them if you are sufficiently careful not to lose any written/// data in the process./// This is a sans-IO implementation, meaning that it only contains the state of the encoder and/// [`encode_bytes`] method. Nevertheless, a number of _adapters_ are provided in the `into_*`/// methods for enoding with a particular style of common IO./// * [`encode`] for encoding once without any IO-loop./// * [`into_async`] for encoding with the `futures` traits for asynchronous IO./// * [`into_stream`] for encoding with the standard `io` traits./// * [`into_vec`] for in-memory encoding./// [`encode_bytes`]: #method.encode_bytes/// [`encode`]: #method.encode/// A encoding stream sink./// See [`Encoder::into_stream`] on how to create this type./// [`Encoder::into_stream`]: struct.Encoder.html#method.into_stream/// A encoding sink into a vector./// See [`Encoder::into_vec`] on how to create this type./// [`Encoder::into_vec`]: struct.Encoder.html#method.into_vecmark_ended/// Reset the state tracking if end code has been written./// Reset the encoder to the beginning, dropping all buffers etc./// The configured minimal code size./// The current encoding symbol tree./// If we have pushed the end code.current_code/// The code corresponding to the currently read characters./// The clear code for resetting the dictionary./// The bit buffer for encoding.EncodeState/// The current code length./// The buffer bits.bits_in_buffer/// The number of valid buffer bits./// Reset the code size in the buffer./// Apply effects of a Clear Code.buffer_code/// Insert a code into the buffer.push_out/// Push bytes if the buffer space is getting small.flush_out/// Flush all full bytes, returning if at least one more byte remains.buffer_pad/// Pad the buffer to a full byte./// Increase the maximum code size./// Return the maximum code with the current code size./// Return the current code size in bits.simplesCompressedKey/// One tree node for at most each code./// To avoid using too much memory we keep nodes with few successors in optimized form. This form/// doesn't offer lookup by indexing but instead does a linear search.FullKeyNoSuccessorchar_continuation/// Create a new encoder with the specified bit order and symbol size./// original specification. In particular you will need to specify an `Lsb` bit oder to encode/// The `size` needs to be in the interval `2..=12`./// Create a TIFF compatible encoder with the specified bit order and symbol size./// Encode some bytes from `inp` into `out`./// See [`into_stream`] for high-level functions (this interface is only available with the/// `std` feature) and [`finish`] for marking the input data as complete./// When some input byte is invalid, i.e. is not smaller than `1 << size`, then that byte and/// all following ones will _not_ be consumed and the `status` of the result will signal an/// error. The result will also indicate that all bytes up to but not including the offending/// byte have been consumed. You may try again with a fixed byte./// [`finish`]: #method.finish/// Encode a single chunk of data./// This method will add an end marker to the encoded chunk./// use weezl::{BitOrder, encode::Encoder};/// let data = b"Hello, world";/// let encoded = Encoder::new(BitOrder::Msb, 9)///     .encode(data)///     .expect("All bytes valid for code size");/// Construct a encoder into a writer./// Construct an encoder into a vector./// All encoded data is appended and the vector is __not__ cleared./// Compared to `into_stream` this interface allows a high-level access to encoding without/// Mark the encoding as in the process of finishing./// The next following call to `encode_bytes` which is able to consume the complete input will/// also try to emit an end code. It's not recommended, but also not unsound, to use different/// byte slices in different calls from this point forward and thus to 'delay' the actual end/// of the data stream. The behaviour after the end marker has been written is unspecified but/// sound./// Undo marking this data stream as ending./// This produce an encoder as if just constructed with `new` but taking slightly less work. In/// Encode data from a reader./// This will drain the supplied reader. It will not encode an end marker after all data has/// been processed./// Encode data from a reader and an end marker./// Set the size of the intermediate encode buffer./// A buffer of this size is allocated to hold one part of the encoded stream when no buffer is/// available and any encoding method is called. No buffer is allocated if `set_buffer` has/// Use a particular buffer as an intermediate encode buffer./// instead of a dynamically allocating a buffer. Note that the size of the buffer is relevant/// for efficient encoding as there is additional overhead from `write` calls each time theencode_part/// Encode data from a slice./// Decode data from a reader, adding an end marker.at_key/// Iterate to the next char./// Return Ok when it was already in the tree or creates a new entry for it and returns Err.invalid_input_rejectedmake_decoded//! A module for all encoding needs."Contains a status with potential error information"consumed_in/// The number of bytes consumed from the input buffer.consumed_out/// The number of bytes written into the output buffer./// The status after returning from the write call./// The result of a coding operation on a pair of buffer./// The result of a coding operation into a vector./// The total number of bytes consumed from the reader./// The total number of bytes written into the writer./// The possible error that occurred./// Note that when writing into streams it is not in general possible to recover from an error./// The result of coding into an output stream./// Everything went well.NoProgress/// No bytes were read or written and no internal state advanced./// If this is returned but your application can not provide more input data then decoding is/// definitely stuck for good and it should stop trying and report some error of its own. In/// other situations this may be used as a signal to refill an internal buffer./// No more data will be produced because an end marker was reached./// The status after successful coding of an LZW stream./// The input contained an invalid code./// For decompression this refers to a code larger than those currently known through the prior/// decoding stages. For compression this refers to a byte that has no code representation due/// to being larger than permitted by the `size` parameter given to the Encoder./// The error kind after unsuccessful coding of an LZW stream./// Alias for a LZW code point/// A default buffer size for encoding/decoding buffer./// Note that this is larger than the default size for buffers (usually 4K) since each code word/// can expand to multiple bytes. Expanding one buffer would yield multiple and require a costly/// break in the decoding loop. Note that the decoded size can be up to quadratic in code block.Msb/// The most significant bit is processed first.Lsb/// The least significant bit is processed first./// The order of bits in bytes./// An owned or borrowed buffer for stream operations.assert_decode_sizeassert_encode_sizestable_send//! # LZW decoder and encoder//! This crates provides an `Encoder` and a `Decoder` in their respective modules. The code words//! are written from and to bit byte slices (or streams) where it is possible to write either the//! most or least significant bits first. The maximum possible code size is 12 bits, the smallest//! available code size is 2 bits.//! These two code blocks show the compression and corresponding decompression. Note that you must//! use the same arguments to `Encoder` and `Decoder`, otherwise the decoding might fail or produce//! bad results.//! use weezl::{BitOrder, encode::Encoder};//! let data = b"Hello, world";//! let compressed = Encoder::new(BitOrder::Msb, 9)//!     .encode(data)//! use weezl::{BitOrder, decode::Decoder};//! # let compressed = b"\x80\x04\x81\x94l\x1b\x06\xf0\xb0 \x1d\xc6\xf1\xc8l\x19 \x10".to_vec();//! # let data = b"Hello, world";//! let decompressed = Decoder::new(BitOrder::Msb, 9)//!     .decode(&compressed)//! assert_eq!(decompressed, data);//! ## LZW Details//! The de- and encoder expect the LZW stream to start with a clear code and end with an//! end code which are defined as follows://!  * `CLEAR_CODE == 1 << min_code_size`//!  * `END_CODE   == CLEAR_CODE + 1`//! For optimal performance, all buffers and input and output slices should be as large as possible//! and at least 2048 bytes long. This extends to input streams which should have similarly sized//! buffers. This library uses Rust's standard allocation interfaces (`Box` and `Vec` to be//! precise). Since there are no ways to handle allocation errors it is not recommended to operate//! it on 16-bit targets.//! ## Allocations and standard library//! The main algorithm can be used in `no_std` as well, although it requires an allocator. This//! restriction might be lifted at a later stage. For this you should deactivate the `std` feature.//! The main interfaces stay intact but the `into_stream` combinator is no available.ExecutableCheckerExistedCheckercheckersCompositeCheckeradd_checkerBadAbsolutePathBadRelativePathCannotFindBinaryPathCannotGetCurrentDirCannotCanonicalizechecker// Home dir shim, use home crate when possible. Otherwise, return Nonehas_separatorPathExtcwd_search_candidatespath_search_candidatestilde_expansioncorrect_casinghas_executable_extension/// Check if given path has extension which in the given vector.test_extension_in_extension_vectortest_extension_not_in_extension_vector/// Find an executable binary's path by name./// If given an absolute path, returns it if the file exists and is executable./// If given a relative path, returns an absolute path to the file if/// it exists and is executable./// If given a string without path separators, looks for a file named/// `binary_name` at each directory in `$PATH` and if it finds an executable/// file there, returns it./// use which::which;/// let result = which::which("rustc").unwrap();/// assert_eq!(result, PathBuf::from("/usr/bin/rustc"));which_global/// Find an executable binary's path by name, ignoring `cwd`./// Does not resolve relative paths./// let result = which::which_global("rustc").unwrap();which_all/// Find all binaries with `binary_name` using `cwd` to resolve relative paths.which_all_global/// Find all binaries with `binary_name` ignoring `cwd`.which_in/// Find `binary_name` in the path list `paths`, using `cwd` to resolve relative paths.which_in_all/// Find all binaries with `binary_name` in the path list `paths`, using `cwd` to resolve relative paths.which_in_global/// Find all binaries with `binary_name` in the path list `paths`, ignoring `cwd`.build_binary_checkercustom_path_listbinary_nameWhichConfig/// A wrapper containing all functionality in this crate.system_cwd/// Whether or not to use the current working directory. `true` by default./// If regex was set previously, and you've just passed in `use_cwd: true`, this will panic.custom_cwd/// Sets a custom path for resolving relative paths./// If regex was set previously, this will panic./// Sets the path name regex to search for. You ***MUST*** call this, or [`Self::binary_name`] prior to searching./// When `Regex` is disabled this function takes the unit type as a stand in. The parameter will change when/// `Regex` is enabled./// If the `regex` feature wasn't turned on for this crate this will always panic. Additionally if a/// `cwd` (aka current working directory) or `binary_name` was set previously, this will panic, as those options/// are incompatible with `regex`./// Sets the path name to search for. You ***MUST*** call this, or [`Self::regex`] prior to searching./// If a `regex` was set previously this will panic as this is not compatible with `regex`./// Uses the given string instead of the `PATH` env variable.system_path_list/// Uses the `PATH` env variable. Enabled by default.first_result/// Finishes configuring, runs the query and returns the first result.all_results/// Finishes configuring, runs the query and returns all results./// An owned, immutable wrapper around a `PathBuf` containing the path of an executable./// The constructed `PathBuf` is the output of `which` or `which_in`, but `which::Path` has the/// advantage of being a type distinct from `std::path::Path` and `std::path::PathBuf`./// It can be beneficial to use `which::Path` instead of `std::path::Path` when you want the type/// system to enforce the need for a path that exists and points to a binary that is executable./// Since `which::Path` implements `Deref` for `std::path::Path`, all methods on `&std::path::Path`/// are also available to `&which::Path` values./// Returns the path of an executable binary by name./// This calls `which` and maps the result into a `Path`./// Returns the paths of all executable binaries by a name./// this calls `which_all` and maps the results into `Path`s./// Returns the path of an executable binary by name in the path list `paths` and using the/// current working directory `cwd` to resolve relative paths./// This calls `which_in` and maps the result into a `Path`.all_in/// Returns all paths of an executable binary by name in the path list `paths` and using the/// This calls `which_in_all` and maps the results into a `Path`./// Returns a reference to a `std::path::Path`./// Consumes the `which::Path`, yielding its underlying `std::path::PathBuf`.CanonicalPath/// An owned, immutable wrapper around a `PathBuf` containing the _canonical_ path of an/// executable./// The constructed `PathBuf` is the result of `which` or `which_in` followed by/// `Path::canonicalize`, but `CanonicalPath` has the advantage of being a type distinct from/// `std::path::Path` and `std::path::PathBuf`./// It can be beneficial to use `CanonicalPath` instead of `std::path::Path` when you want the type/// system to enforce the need for a path that exists, points to a binary that is executable, is/// absolute, has all components normalized, and has all symbolic links resolved/// Since `CanonicalPath` implements `Deref` for `std::path::Path`, all methods on/// `&std::path::Path` are also available to `&CanonicalPath` values./// Returns the canonical path of an executable binary by name./// This calls `which` and `Path::canonicalize` and maps the result into a `CanonicalPath`./// Returns the canonical paths of an executable binary by name./// This calls `which_all` and `Path::canonicalize` and maps the results into `CanonicalPath`s./// Returns the canonical path of an executable binary by name in the path list `paths` and/// using the current working directory `cwd` to resolve relative paths./// This calls `which_in` and `Path::canonicalize` and maps the result into a `CanonicalPath`./// Returns all of the canonical paths of an executable binary by name in the path list `paths` and/// This calls `which_in_all` and `Path::canonicalize` and maps the result into a `CanonicalPath`./// Consumes the `which::CanonicalPath`, yielding its underlying `std::path::PathBuf`.//! which//! A Rust equivalent of Unix command `which(1)`.//! # Example://! To find which rustc executable binary is using://! use which::which;//! let result = which("rustc").unwrap();//! assert_eq!(result, PathBuf::from("/usr/bin/rustc"));DesktopEnvreport_messageDEFAULT_USERNAMEDEFAULT_HOSTNAME/// Get the CPU Architecture./// Get the user's username./// On unix-systems this differs from [`realname()`] most notably in that spaces/// are not allowed in the username.username_os/// On unix-systems this differs from [`realname_os()`] most notably in that/// spaces are not allowed in the username.realname/// Get the user's real (full) name.realname_osdevicename/// Get the device name (also known as "Pretty Name")./// Often used to identify device for bluetooth pairing.devicename_os/// Get the host device's hostname./// This method normalizes to lowercase.  Usually hostnames are/// case-insensitive, but it's not a hard requirement./// FIXME: Document platform-specific character limitations/// Use [`fallible::hostname()`] for case-sensitive hostname.hostname_os/// Usually hostnames are case-insensitive, but it's/// not a hard requirement./// Get the name of the operating system distribution and (possibly) version./// Example: "Windows 10" or "Fedora 26 (Workstation Edition)"distro_osdesktop_env/// Get the desktop environment./// Example: "gnome" or "windows"/// Get the platform./// Get the user's preferred language(s)./// Returned as iterator of two letter language codes (lowercase), optionally/// followed by a dash (-) and a two letter country code (uppercase).  The most/// preferred language is returned first, followed by next preferred, and so on.langs/// Returned as iterator of [`Language`]s.  The most preferred language is/// returned first, followed by next preferred, and so on.  Unrecognized/// languages may either return an error or be skipped.Bits32/// 32 bitsBits64/// 64 bits/// The address width of a CPU architectureArmV5/// ARMv5ArmV6/// ARMv6 (Sometimes just referred to as ARM)ArmV7/// ARMv7 (May or may not support Neon/Thumb)/// ARM64 (aarch64)/// i386 (x86)/// i586 (x86)/// i686 (x86)/// X86_64 / Amd64MipsEl/// MIPS (LE)/// MIPS64Mips64El/// MIPS64 (LE)/// PowerPC64PowerPc64Le/// PowerPC64LE/// 32-bit RISC-V/// 64-bit RISC-V/// S390x/// SPARC/// SPARC64/// 32-bit Web Assembly/// 64-bit Web Assembly/// Unknown Architecture/// The architecture of a CPU/// Get the width of this architecture.string_from_osGnome/// Popular GTK-based desktop environment on Linux/// One of the desktop environments for a specific version of WindowsLxde/// Linux desktop environment optimized for low resource requirementsOpenbox/// Stacking window manager for X Windows on LinuxMate/// Desktop environment for Linux, BSD and illumosXfce/// Lightweight desktop enivornment for unix-like operating systemsKde/// KDE Plasma desktop enviroment// FIXME: Rename to 'Plasma' in whoami 2.0.0Cinnamon/// Default desktop environment on Linux MintI3/// Tiling window manager for LinuxAqua/// Desktop environment for MacOS/// Desktop environment for iOS/// Desktop environment for AndroidWebBrowser/// Running as Web Assembly on a web page/// A desktop environment for a video game consoleUbuntu/// Ubuntu-branded GNOMEErmine/// Default shell for Fuchsia/// Default desktop environment for Redox/// Unknown desktop environment/// The desktop environment of a systemis_gtk/// Returns true if the desktop environment is based on GTK.is_kde/// Returns true if the desktop environment is based on KDE.// FIXME: V2: Move `Unknown` variants to the top of the enum.account/// Get the user's account name; usually just the username, but may include an/// account server hostname./// If you don't want the account server hostname, use [`username()`]./// Example: `username@example.com`account_os//! Fallible versions of the whoami APIs.//! Some of the functions in the root module will return "Unknown" or//! "localhost" on error.  This might not be desirable in some situations.  The//! functions in this module all return a [`Result`].Country// FIXME: V2: u32::from_ne_bytes for country codes, with `\0` for unused// FIXME: Add aliases up to 3-4 letters, but hidden/// Any dialectUs/// `US`: United States of America/// Country code for a [`Language`] dialect/// Uses <https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>/// `en`: English/// `es`: Spanish/// A spoken language/// Use [`ToString::to_string()`] to convert to string of two letter lowercase/// language code followed an forward slash and uppercase country code (example:/// `en/US`)./// Language codes defined in ISO 639 <https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>,/// Country codes defined in ISO 3166 <https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>// #[allow(variant_size_differences)]country/// Retrieve the country code for this language dialect.//! Crate for getting the user's username, realname and environment.//! Using the whoami crate is super easy!  All of the public items are simple//! functions with no parameters that return [`String`]s or [`OsString`]s (with//! the exception of [`desktop_env()`], [`platform()`], and [`arch()`], which//! return enums, and [`langs()`] that returns an iterator of [`String`]s).  The//! following example shows how to use all of the functions (except those that//! return [`OsString`])://! println!(//!     "User's Name            whoami::realname():    {}",//!     whoami::realname(),//!     "User's Username        whoami::username():    {}",//!     whoami::username(),//!     "User's Language        whoami::lang():        {:?}",//!     whoami::lang().collect::<Vec<String>>(),//!     "Device's Pretty Name   whoami::devicename():  {}",//!     whoami::devicename(),//!     "Device's Hostname      whoami::hostname():    {}",//!     whoami::hostname(),//!     "Device's Platform      whoami::platform():    {}",//!     whoami::platform(),//!     "Device's OS Distro     whoami::distro():      {}",//!     whoami::distro(),//!     "Device's Desktop Env.  whoami::desktop_env(): {}",//!     whoami::desktop_env(),//!     "Device's CPU Arch      whoami::arch():        {}",//!     whoami::arch(),//! [`OsString`]: std::ffi::OsString//! This is mostly the same as fake.rs for nowPasswd/// Row in the Redox /etc/passwd filemachine_archto_io_error// We don't need unsafe, yay!// Redox support has its own MSRV of 1.65, is nightly lint//! Unknown target, fake implementation.//! This can be used as a template when adding new target support.PassWdstrlen_gecosos_from_cstring_gecosos_from_cstring// This function must allocate, because a slice or `Cow<OsStr>` would still// reference `passwd` which is dropped when this function returns.// Buffer initialization// Get the user agentdocument_domain// Get the document domainos_version_info_sizebuild_numbersz_csd_versionservice_pack_majorservice_pack_minorsuite_maskproduct_typeOsVersionInfoExprocessor_architecturedw_page_sizeminimum_application_addressmaximum_application_addressactive_processor_masknumber_of_processorsprocessor_typeprocessor_levelprocessor_revision// Source:// https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info#syntaxExtendedNameFormatFullyQualifiedDN// NothingSamCompatible// Hostname Followed By UsernameUniqueId// Full NameUserPrincipalCanonicalExServicePrincipalDnsDomainGivenNameSurnameComputerNameFormatNetBIOSDnsHostname// All caps hostname// HostnameDnsFullyQualified// Nothing or domainPhysicalNetBIOS// Hostname with, for example, .comPhysicalDnsHostname// All caps namePhysicalDnsDomainPhysicalDnsFullyQualifiedERR_MORE_DATAERR_INSUFFICIENT_BUFFERERR_NONE_MAPPEDGetUserNameExWGetUserNameWGetNativeSystemInfoextended_name// Daku// Redox// Unix// Wasi// Web// Windows/// Implement `Target for Os` to add platform support for a target./// Return a semicolon-delimited string of language/COUNTRY codes./// Return the user's "real" / "full" name./// Return the user's username./// Return the computer's "fancy" / "pretty" name./// Return the computer's hostname./// Return the OS distribution's name./// Return the desktop environment./// Return the target platform./// Return the computer's CPU architecture./// Return the user's account name (usually just the username, but may/// include an account server hostname)./// Target platform supporterr_missing_record// This is only used on some platformserr_null_recorderr_empty_recordunix_lang// FIXME: Non-standard casing; Rename to 'Mac' rather than 'MacOs' in// whoami 2.0.0// FIXME: Separate for different Nintendo consoles in whoami 2.0.0,// currently only used for 3DSXbox// FIXME: Currently unused, remove in whoami 2.0.0PlayStationHurd/// The underlying platform for a system/// This crate's convenience type alias for [`Result`](std::result::Result)sMissingNulTerminator/// A terminating nul value was missing.ContainsNul/// An interior nul value was found./// An error returned to indicate a problem with nul values occurred./// The error will either being a [`MissingNulTerminator`] or [`ContainsNul`]./// The error optionally returns the ownership of the invalid vector whenever a vector was owned./// Consumes this error, returning the underlying vector of values which generated the error in/// the first place./// An error returned from to indicate that a terminating nul value was missing./// An error returned to indicate that an invalid nul value was found in a string./// The error indicates the position in the vector where the nul value was found, as well as/// returning the ownership of the invalid vector./// Returns the index of the invalid nul value in the slice./// If the sequence that generated the error was a reference to a slice instead of a [`Vec`],/// this will return [`None`].unpaired_surrogateDecodeUtf16Error/// An error that can be returned when decoding UTF-16 code points./// This struct is created when using the [`DecodeUtf16`][crate::iter::DecodeUtf16] iterator./// Returns the unpaired surrogate which caused this error.DecodeUtf32Error/// An error that can be returned when decoding UTF-32 code points./// This error occurs when a [`u32`] value is outside the 21-bit Unicode code point range/// (>`U+10FFFF`) or is a UTF-16 surrogate value.invalid_code_point/// Returns the invalid code point value which caused the error./// Errors which can occur when attempting to interpret a sequence of `u16` as UTF-16./// Returns the index in the given string at which the invalid UTF-16 value occurred.Utf32Error/// Errors which can occur when attempting to interpret a sequence of `u32` as UTF-32./// Returns the index in the given string at which the invalid UTF-32 value occurred.//! Errors returned by functions in this crate.decode_utf16_surrogate_pairis_utf16_high_surrogateis_utf16_low_surrogateis_utf16_surrogateforward_bufback_bufDecodeUtf16/// An iterator that decodes UTF-16 encoded code points from an iterator of [`u16`]s./// This struct is created by [`decode_utf16`][crate::decode_utf16]. See its documentation for more./// This struct is identical to [`char::DecodeUtf16`] except it is a [`DoubleEndedIterator`] if/// `I` is.DecodeUtf16Lossy/// An iterator that lossily decodes possibly ill-formed UTF-16 encoded code points from an iterator/// of [`u16`]s./// Any unpaired UTF-16 surrogate values are replaced by/// [`U+FFFD REPLACEMENT_CHARACTER`][char::REPLACEMENT_CHARACTER] (�).DecodeUtf32/// An iterator that decodes UTF-32 encoded code points from an iterator of `u32`s.DecodeUtf32Lossy/// An iterator that lossily decodes possibly ill-formed UTF-32 encoded code points from an iterator/// of `u32`s./// Any invalid UTF-32 values are replaced by/// [`U+FFFD REPLACEMENT_CHARACTER`][core::char::REPLACEMENT_CHARACTER] (�)./// An iterator that encodes an iterator of [`char`][prim@char]s into UTF-8 bytes./// This struct is created by [`encode_utf8`][crate::encode_utf8]. See its documentation for more./// An iterator that encodes an iterator of [`char`][prim@char]s into UTF-16 [`u16`] code units./// This struct is created by [`encode_utf16`][crate::encode_utf16]. See its documentation for more.EncodeUtf32/// An iterator that encodes an iterator of [`char`][prim@char]s into UTF-32 [`u32`] values./// This struct is created by [`encode_utf32`][crate::encode_utf32]. See its documentation for more.//! Iterators for encoding and decoding slices of string data.ucstrucstringustrustringutfstrutfstringU16CStrU32CStrWideCStrU16CStringU32CStringWideCStringU16StrU32StrWideStrU16StringU32StringWideStringUtf16StrUtf32StrWideUtfStrUtf16StringUtf32StringWideUtfStringWideChar/// Alias for [`u16`] or [`u32`] depending on platform. Intended to match typical C `wchar_t` size/// on platform.decode_utf16/// Creates an iterator over the UTF-16 encoded code points in `iter`, returning unpaired surrogates/// as `Err`s./// use std::char::decode_utf16;/// // 𝄞mus<invalid>ic<invalid>/// let v = [///     0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,///     decode_utf16(v.iter().cloned())///         .map(|r| r.map_err(|e| e.unpaired_surrogate()))///         Ok('𝄞'),///         Ok('m'), Ok('u'), Ok('s'),///         Err(0xDD1E),///         Ok('i'), Ok('c'),///         Err(0xD834)/// A lossy decoder can be obtained by replacing Err results with the replacement character:/// use std::char::{decode_utf16, REPLACEMENT_CHARACTER};///        .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))///        .collect::<String>(),///     "𝄞mus�ic�"decode_utf16_lossy/// Creates a lossy decoder iterator over the possibly ill-formed UTF-16 encoded code points in/// `iter`./// This is equivalent to [`char::decode_utf16`][core::char::decode_utf16] except that any unpaired/// UTF-16 surrogate values are replaced by/// [`U+FFFD REPLACEMENT_CHARACTER`][core::char::REPLACEMENT_CHARACTER] (�) instead of returning/// errors./// use widestring::decode_utf16_lossy;/// decode_utf16_lossy(v.iter().copied()).collect::<String>(),/// "𝄞mus�ic�"decode_utf32/// Creates a decoder iterator over UTF-32 encoded code points in `iter`, returning invalid values/// use widestring::decode_utf32;///     0x1D11E, 0x6d, 0x75, 0x73, 0xDD1E, 0x69, 0x63, 0x23FD5A,///     decode_utf32(v.iter().copied())///         .map(|r| r.map_err(|e| e.invalid_code_point()))///         Err(0x23FD5A)decode_utf32_lossy/// Creates a lossy decoder iterator over the possibly ill-formed UTF-32 encoded code points in/// This is equivalent to [`decode_utf32`] except that any invalid UTF-32 values are replaced by/// use widestring::decode_utf32_lossy;/// decode_utf32_lossy(v.iter().copied()).collect::<String>(),/// Creates an iterator that encodes an iterator over [`char`]s into UTF-8 bytes./// use widestring::encode_utf8;/// let music = "𝄞music";/// let encoded: Vec<u8> = encode_utf8(music.chars()).collect();/// assert_eq!(encoded, music.as_bytes());encode_utf16/// Creates an iterator that encodes an iterator over [`char`]s into UTF-16 [`u16`] code units./// use widestring::encode_utf16;/// let encoded: Vec<u16> = encode_utf16("𝄞music".chars()).collect();///     0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063,/// assert_eq!(encoded, v);encode_utf32/// Creates an iterator that encodes an iterator over [`char`]s into UTF-32 [`u32`] values./// This iterator is a simple type cast from [`char`] to [`u32`], as any sequence of [`char`]s is/// valid UTF-32./// use widestring::encode_utf32;/// let encoded: Vec<u32> = encode_utf32("𝄞music".chars()).collect();///     0x1D11E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063,debug_fmt_u16/// Debug implementation for any U16 string slice./// Properly encoded input data will output valid strings with escape sequences, however invalid/// encoding will purposefully output any unpaired surrogate as \<XXXX> which is not a valid escape/// sequence. This is intentional, as debug output is not meant to be parsed but read by humans.debug_fmt_utf16_iter/// Debug implementation for any U16 string iterator.debug_fmt_u32/// encoding will purposefully output any  invalid code point as \<XXXX> which is not a valid escapedebug_fmt_utf32_iterdebug_fmt_char_iter/// Debug implementation for any `char` iterator./// Returns whether the code unit a UTF-16 surrogate value./// Returns whether the code unit a UTF-16 high surrogate value./// Returns whether the code unit a UTF-16 low surrogate value./// Convert a UTF-16 surrogate pair to a `char`. Does not validate if the surrogates are valid.validate_utf16/// Validates whether a slice of 16-bit values is valid UTF-16, returning an error if it is not.validate_utf16_vec/// Validates whether a vector of 16-bit values is valid UTF-16, returning an error if it is not.validate_utf32/// Validates whether a slice of 32-bit values is valid UTF-32, returning an error if it is not.validate_utf32_vec/// Validates whether a vector of 32-bit values is valid UTF-32, returning an error if it is not./// Copy of unstable core::slice::range to soundly handle ranges/// TODO: Replace with core::slice::range when it is stabilized/// Similar to core::slice::range, but returns [`None`] instead of panicking.//! A wide string library for converting to and from wide string variants.//! This library provides multiple types of wide strings, each corresponding to a string types in//! the Rust standard library. [`Utf16String`] and [`Utf32String`] are analogous to the standard//! [`String`] type, providing a similar interface, and are always encoded as valid UTF-16 and//! UTF-32, respectively. They are the only type in this library that can losslessly and infallibly//! convert to and from [`String`], and are the easiest type to work with. They are not designed for//! working with FFI, but do support efficient conversions from the FFI types.//! [`U16String`] and [`U32String`], on the other hand, are similar to (but not the same as),//! [`OsString`], and are designed around working with FFI. Unlike the UTF variants, these strings//! do not have a defined encoding, and can work with any wide character strings, regardless of//! the encoding. They can be converted to and from [`OsString`] (but may require an encoding//! conversion depending on the platform), although that string type is an OS-specified//! encoding, so take special care.//! [`U16String`] and [`U32String`] also allow access and mutation that relies on the user//! to enforce any constraints on the data. Some methods do assume a UTF encoding, but do so in a//! way that handles malformed encoding data. For FFI, use [`U16String`] or [`U32String`] when you//! simply need to pass-through string data, or when you're not dealing with a nul-terminated data.//! Finally, [`U16CString`] and [`U32CString`] are wide version of the standard [`CString`] type.//! Like [`U16String`] and [`U32String`], they do not have defined encoding, but are designed to//! work with FFI, particularly C-style nul-terminated wide string data. These C-style strings are//! always terminated in a nul value, and are guaranteed to contain no interior nul values (unless//! unchecked methods are used). Again, these types may contain ill-formed encoding data, and//! methods handle it appropriately. Use [`U16CString`] or [`U32CString`] anytime you must properly//! handle nul values for when dealing with wide string C FFI.//! Like the standard Rust string types, each wide string type has its corresponding wide string//! slice type, as shown in the following table://! | String Type     | Slice Type   |//! |-----------------|--------------|//! | [`Utf16String`] | [`Utf16Str`] |//! | [`Utf32String`] | [`Utf32Str`] |//! | [`U16String`]   | [`U16Str`]   |//! | [`U32String`]   | [`U32Str`]   |//! | [`U16CString`]  | [`U16CStr`]  |//! | [`U32CString`]  | [`U32CStr`]  |//! All the string types in this library can be converted between string types of the same bit//! width, as well as appropriate standard Rust types, but be lossy and/or require knowledge of the//! underlying encoding. The UTF strings additionally can be converted between the two sizes of//! string, re-encoding the strings.//! # Wide string literals//! Macros are provided for each wide string slice type that convert standard Rust [`str`] literals//! into UTF-16 or UTF-32 encoded versions of the slice type at *compile time*.//! use widestring::u16str;//! let hello = u16str!("Hello, world!"); // `hello` will be a &U16Str value//! These can be used anywhere a `const` function can be used, and provide a convenient method of//! specifying wide string literals instead of coding values by hand. The resulting string slices//! are always valid UTF encoding, and the [`u16cstr!`] and [`u32cstr!`] macros are automatically//! nul-terminated.//! This crate supports `no_std` when default cargo features are disabled. The `std` and `alloc`//! cargo features (enabled by default) enable the owned string types: [`U16String`], [`U32String`],//! [`U16CString`], [`U32CString`], [`Utf16String`], and [`Utf32String`] types and their modules.//! Other types such as the string slices do not require allocation and can be used in a `no_std`//! environment, even without the [`alloc`](https://doc.rust-lang.org/stable/alloc/index.html)//! # Remarks on UTF-16 and UTF-32//! UTF-16 encoding is a variable-length encoding. The 16-bit code units can specificy Unicode code//! points either as single units or in _surrogate pairs_. Because every value might be part of a//! surrogate pair, many regular string operations on UTF-16 data, including indexing, writing, or//! even iterating, require considering either one or two values at a time. This library provides//! safe methods for these operations when the data is known to be UTF-16, such as with//! [`Utf16String`]. In those cases, keep in mind that the number of elements (`len()`) of the//! wide string is _not_ equivalent to the number of Unicode code points in the string, but is//! instead the number of code unit values.//! For [`U16String`] and [`U16CString`], which do not define an encoding, these same operations//! (indexing, mutating, iterating) do _not_ take into account UTF-16 encoding and may result in//! sequences that are ill-formed UTF-16. Some methods are provided that do make an exception to//! this and treat the strings as malformed UTF-16, which are specified in their documentation as to//! how they handle the invalid data.//! UTF-32 simply encodes Unicode code points as-is in 32-bit Unicode Scalar Values, but Unicode//! character code points are reserved only for 21-bits, and UTF-16 surrogates are invalid in//! UTF-32. Since UTF-32 is a fixed-width encoding, it is much easier to deal with, but equivalent//! methods to the 16-bit strings are provided for compatibility.//! All the 32-bit wide strings provide efficient methods to convert to and from sequences of//! [`char`] data, as the representation of UTF-32 strings is functionally equivalent to sequences//! of [`char`]s. Keep in mind that only [`Utf32String`] guaruntees this equivalence, however, since//! the other strings may contain invalid values.//! # FFI with C/C++ `wchar_t`//! C/C++'s `wchar_t` (and C++'s corresponding `widestring`) varies in size depending on compiler//! and platform. Typically, `wchar_t` is 16-bits on Windows and 32-bits on most Unix-based//! platforms. For convenience when using `wchar_t`-based FFI's, type aliases for the corresponding//! string types are provided: [`WideString`] aliases [`U16String`] on Windows or [`U32String`]//! elsewhere, [`WideCString`] aliases [`U16CString`] or [`U32CString`], and [`WideUtfString`]//! aliases [`Utf16String`] or [`Utf32String`]. [`WideStr`], [`WideCStr`], and [`WideUtfStr`] are//! provided for the string slice types. The [`WideChar`] alias is also provided, aliasing [`u16`]//! or [`u32`] depending on platform.//! When not interacting with a FFI that uses `wchar_t`, it is recommended to use the string types//! directly rather than via the wide alias.//! # Nul values//! This crate uses the term legacy ASCII term "nul" to refer to Unicode code point `U+0000 NULL`//! and its associated code unit representation as zero-value bytes. This is to disambiguate this//! zero value from null pointer values. C-style strings end in a nul value, while regular Rust//! strings allow interior nul values and are not terminated with nul.//! The following example uses [`U16String`] to get Windows error messages, since `FormatMessageW`//! returns a string length for us and we don't need to pass error messages into other FFI//! functions so we don't need to worry about nul values.//! # #[cfg(any(not(windows), not(feature = "alloc")))]//! # extern crate winapi;//! # extern crate widestring;//! # #[cfg(all(windows, feature = "alloc"))]//! use winapi::um::winbase::{FormatMessageW, LocalFree, FORMAT_MESSAGE_FROM_SYSTEM,//!                           FORMAT_MESSAGE_ALLOCATE_BUFFER, FORMAT_MESSAGE_IGNORE_INSERTS};//! use winapi::shared::ntdef::LPWSTR;//! use winapi::shared::minwindef::HLOCAL;//! use widestring::U16String;//! # use winapi::shared::minwindef::DWORD;//! # let error_code: DWORD = 0;//! let s: U16String;//!     // First, get a string buffer from some windows api such as FormatMessageW...//!     let mut buffer: LPWSTR = ptr::null_mut();//!     let strlen = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |//!                                 FORMAT_MESSAGE_ALLOCATE_BUFFER |//!                                 FORMAT_MESSAGE_IGNORE_INSERTS,//!                                 ptr::null(),//!                                 error_code, // error code from GetLastError()//!                                 0,//!                                 (&mut buffer as *mut LPWSTR) as LPWSTR,//!                                 ptr::null_mut());//!     // Get the buffer as a wide string//!     s = U16String::from_ptr(buffer, strlen as usize);//!     // Since U16String creates an owned copy, it's safe to free original buffer now//!     // If you didn't want an owned copy, you could use &U16Str.//!     LocalFree(buffer as HLOCAL);//! // Convert to a regular Rust String and use it to your heart's desire!//! let message = s.to_string_lossy();//! # assert_eq!(message, "The operation completed successfully.\r\n");//! The following example is the functionally the same, only using [`U16CString`] instead.//! use widestring::U16CString;//! let s: U16CString;//!     FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |//!                    FORMAT_MESSAGE_ALLOCATE_BUFFER |//!                    FORMAT_MESSAGE_IGNORE_INSERTS,//!                    ptr::null(),//!                    error_code, // error code from GetLastError()//!                    0,//!                    (&mut buffer as *mut LPWSTR) as LPWSTR,//!                    ptr::null_mut());//!     s = U16CString::from_ptr_str(buffer);//!     // Since U16CString creates an owned copy, it's safe to free original buffer now//!     // If you didn't want an owned copy, you could use &U16CStr.//! [`OsStr`]: std::ffi::OsStr//! [`CString`]: std::ffi::CString//! [`CStr`]: std::ffi::CStr// Until min version gets bumpedimplement_utf16_macror" Converts a string literal into a `const` UTF-16 string slice of type"r" [`Utf16Str`][crate::Utf16Str]."r" use widestring::{utf16str, Utf16Str, Utf16String};"r#" const STRING: &Utf16Str = utf16str!("My string");"#r#" assert_eq!(Utf16String::from_str("My string"), STRING);"#utf16strr" [`U16Str`][crate::U16Str]."r" The resulting `const` string slice will always be valid UTF-16."r" use widestring::{u16str, U16Str, U16String};"r#" const STRING: &U16Str = u16str!("My string");"#r#" assert_eq!(U16String::from_str("My string"), STRING);"#u16strr" [`U16CStr`][crate::U16CStr]."r" The resulting `const` string slice will always be valid UTF-16 and include a nul terminator."r" use widestring::{u16cstr, U16CStr, U16CString};"r#" const STRING: &U16CStr = u16cstr!("My string");"#r#" assert_eq!(U16CString::from_str("My string").unwrap(), STRING);"#u16cstrimplement_utf32_macror" Converts a string literal into a `const` UTF-32 string slice of type"r" [`Utf32Str`][crate::Utf32Str]."r" use widestring::{utf32str, Utf32Str, Utf32String};"r#" const STRING: &Utf32Str = utf32str!("My string");"#r#" assert_eq!(Utf32String::from_str("My string"), STRING);"#utf32strr" [`U32Str`][crate::U32Str]."r" The resulting `const` string slice will always be valid UTF-32."r" use widestring::{u32str, U32Str, U32String};"r#" const STRING: &U32Str = u32str!("My string");"#r#" assert_eq!(U32String::from_str("My string"), STRING);"#u32strr" [`U32CStr`][crate::U32CStr]."r" The resulting `const` string slice will always be valid UTF-32 and include a nul terminator."r" use widestring::{u32cstr, U32CStr, U32CString};"r#" const STRING: &U32CStr = u32cstr!("My string");"#r#" assert_eq!(U32CString::from_str("My string").unwrap(), STRING);"#u32cstrwidestr/// Alias for [`u16str`] or [`u32str`] macros depending on platform. Intended to be used when using/// [`WideStr`][crate::WideStr] type alias.wideutfstr/// Alias for [`utf16str`] or [`utf32str`] macros depending on platform. Intended to be used when/// using [`WideUtfStr`][crate::WideUtfStr] type alias.widecstr/// Alias for [`u16cstr`] or [`u32cstr`] macros depending on platform. Intended to be used when/// using [`WideCStr`][crate::WideCStr] type alias.include_utf16str/// Includes a UTF-16 encoded file as a [`Utf16Str`][crate::Utf16Str]./// This uses [`include_bytes`](core::include_bytes) to accomplish this./// use widestring::{include_utf16str, Utf16Str, Utf16String};/// const STRING: &Utf16Str = include_utf16str!("example.txt");/// assert_eq!(Utf16String::from_str("My string"), STRING);next_code_point// A const implementation of https://github.com/rust-lang/rust/blob/d902752866cbbdb331e3cf28ff6bba86ab0f6c62/library/core/src/str/mod.rs#L509-L537// Assumes `utf8` is a valid &strBoMbomlength_as_utf16// A const implementation of `s.chars().map(|ch| ch.len_utf16()).sum()`length_as_utf32// A const implementation of `s.chars().len()`UTF16STR_TESTUTF16STR_INCLUDE_LE_TESTUTF16STR_INCLUDE_BE_TESTU16STR_TESTU16CSTR_TESTUTF32STR_TESTU32STR_TESTU32CSTR_TESTWIDESTR_TESTWIDECSTR_TESTstr_macrosos_to_wideos_from_wideCharIndicesLossyUtf16CharIndicesLossyUtf32CharIndicesUtf16CharIndicesUtf32CharsLossyUtf16CharsLossyUtf32CharsUtf16CharsUtf32ucstr_common_implr" C-style 16-bit wide string slice for [`U16CString`][crate::U16CString]."r" [`U16CStr`] is to [`U16CString`][crate::U16CString] as [`CStr`][std::ffi::CStr] is to"r" [`CString`][std::ffi::CString]."r" [`U16CStr`] are string slices that do not have a defined encoding. While it is sometimes"r" assumed that they contain possibly invalid or ill-formed UTF-16 data, they may be used for"r" any wide encoded string."r" # Nul termination"r" [`U16CStr`] is aware of nul (`0`) values. Unless unchecked conversions are used, all"r" [`U16CStr`] strings end with a nul-terminator in the underlying buffer and contain no"r" internal nul values. These strings are intended to be used with C FFI functions that"r" require nul-terminated strings."r" Because of the nul termination requirement, multiple classes methods for provided for"r" construction a [`U16CStr`] under various scenarios. By default, methods such as"r" [`from_ptr`][Self::from_ptr] and [`from_slice`][Self::from_slice] return an error if the"r" input does not terminate with a nul value, or if it contains any interior nul values before"r" the terminator."r" `_truncate` methods on the other hand, such as"r" [`from_ptr_truncate`][Self::from_ptr_truncate] and"r" [`from_slice_truncate`][Self::from_slice_truncate], construct a slice that terminates with"r" the first nul value encountered in the string, only returning an error if the slice contains"r" no nul values at all. Use this to mimic the behavior of C functions such as `strlen` when"r" you don't know if the input is clean of interior nuls."r" Finally, unsafe `_unchecked` variants of these methods, such as"r" [`from_ptr_unchecked`][Self::from_ptr_unchecked] and"r" [`from_slice_unchecked`][Self::from_slice_unchecked] allow bypassing any checks for nul"r" values, when the input has already been ensured to have a nul terminator and no interior"r" nul values."r" The easiest way to use [`U16CStr`] outside of FFI is with the [`u16cstr!`][crate::u16cstr]"r" macro to convert string literals into nul-terminated UTF-16 string slices at compile time:"r" use widestring::u16cstr;"r#" let hello = u16cstr!("Hello, world!");"#r" You can also convert any [`u16`] slice directly, as long as it has a nul terminator:"r" use widestring::{u16cstr, U16CStr};"r" let sparkle_heart = [0xd83d, 0xdc96, 0x0];"r" let sparkle_heart = U16CStr::from_slice(&sparkle_heart).unwrap();"r#" assert_eq!(u16cstr!("💖"), sparkle_heart);"#r" // This unpaired UTf-16 surrogate is invalid UTF-16, but is perfectly valid in U16CStr"r" let malformed_utf16 = [0xd83d, 0x0];"r" let s = U16CStr::from_slice(&malformed_utf16).unwrap();"r" assert_eq!(s.len(), 1);"r" When working with a FFI, it is useful to create a [`U16CStr`] from a pointer:"r" let s = unsafe {"r"     // Note the string and pointer length does not include the nul terminator"r"     U16CStr::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len() - 1).unwrap()"r#" assert_eq!(u16cstr!("💖"), s);"#r" // Alternatively, if the length of the pointer is unknown but definitely terminates in nul,"r" // a C-style string version can be used"r" let s = unsafe { U16CStr::from_ptr_str(sparkle_heart.as_ptr()) };"r" The nul terminator character value."NUL_TERMINATORr" Coerces a value into a wide C string slice."r" Constructs a wide C string slice from a nul-terminated string pointer."r" This will scan for nul values beginning with `p`. The first nul value will be used"r" as the nul terminator for the string, similar to how libc string functions such as"r" `strlen` work."r" This function is unsafe as there is no guarantee that the given pointer is valid or"r" has a nul terminator, and the function could scan past the underlying buffer."r" In addition, the data must meet the safety conditions of"r" [std::slice::from_raw_parts]. In particular, the returned string reference *must not"r" be mutated* for the duration of lifetime `'a`, except inside an"r" [`UnsafeCell`][std::cell::UnsafeCell]."r" This function panics if `p` is null."r" # Caveat"r" The lifetime for the returned string is inferred from its usage. To prevent"r" accidental misuse, it's suggested to tie the lifetime to whichever source lifetime"r" is safe in the context, such as by providing a helper function taking the lifetime"r" of a host value for the string, or by explicit annotation."from_ptr_strr" Constructs a mutable wide C string slice from a mutable nul-terminated string"r" pointer."r" [std::slice::from_raw_parts_mut]."from_ptr_str_mutr" Constructs a wide C string slice from a pointer and a length."r" The `len` argument is the number of elements, **not** the number of bytes, and does"r" **not** include the nul terminator of the string. Thus, a `len` of 0 is valid and"r" means that `p` is a pointer directly to the nul terminator of the string."r" This will scan the pointer string for an interior nul value and error if one is"r" found before the nul terminator at `len` offset. To avoid scanning for interior"r" nuls, [`from_ptr_unchecked`][Self::from_ptr_unchecked] may be used instead."r" An error is returned if the value at `len` offset is not a nul terminator."r" This function is unsafe as there is no guarantee that the given pointer is valid for"r" `len + 1` elements."r" Constructs a mutable wide C string slice from a mutable pointer and a length."r" nuls, [`from_ptr_unchecked_mut`][Self::from_ptr_unchecked_mut] may be used instead."r" Constructs a wide C string slice from a pointer and a length, truncating at the"r" first nul terminator."r" The `len` argument is the number of elements, **not** the number of bytes. This will"r" scan for nul values beginning with `p` until offset `len`. The first nul value will"r" be used as the nul terminator for the string, ignoring any remaining values left"r" before `len`."r" If no nul terminator is found after `len` + 1 elements, an error is returned."r" of a host value for thev string, or by explicit annotation."from_ptr_truncater" Constructs a mutable wide C string slice from a mutable pointer and a length,"r" truncating at the first nul terminator."from_ptr_truncate_mutr" Constructs a wide C string slice from a pointer and a length without checking for"r" any nul values."r" `len + 1` elements, nor that it has a terminating nul value."r" The interior values of the pointer are not scanned for nul. Any interior nul values"r" or a missing nul terminator at pointer offset `len` + 1 will result in an invalid"r" string slice."from_ptr_uncheckedr" Constructs a mutable wide C string slice from a mutable pointer and a length without"r" checking for any nul values."r" `len + 1` elements, nor that is has a terminating nul value."from_ptr_unchecked_mutr" Constructs a wide C string slice from a slice of values with a terminating nul,"r" checking for invalid interior nul values."r" The slice must have at least one item, the nul terminator, even for an empty string."r" If there are nul values in the slice except for the last value, an error is"r" An error is also returned if the last value of the slice is not a nul terminator."r" Constructs a mutable wide C string slice from a mutable slice of values with a"r" terminating nul, checking for invalid interior nul values."r" Constructs a wide C string slice from a slice of values, truncating at the first nul"r" terminator."r" The slice will be scanned for nul values. When a nul value is found, it is treated"r" as the terminator for the string, and the string slice will be truncated to that"r" nul."r" If there are no nul values in the slice, an error is returned."from_slice_truncater" Constructs a mutable wide C string slice from a mutable slice of values, truncating"r" at the first nul terminator."from_slice_truncate_mutr" Constructs a wide C string slice from a slice of values without checking for a"r" terminating or interior nul values."r" This function is unsafe because it can lead to invalid string slice values when the"r" slice is missing a terminating nul value or there are non-terminating interior nul"r" values in the slice. In particular, an empty slice will result in an invalid"r" Constructs a mutable wide C string slice from a mutable slice of values without"r" checking for a terminating or interior nul values."r" Copies the string reference to a new owned wide C string."to_ucstringr" Copies the string reference to a new owned wide string."r" The resulting wide string will **not** have a nul terminator."r" use widestring::U16CString;"r#" let wcstr = U16CString::from_str("MyString").unwrap();"#r" // Convert U16CString to a U16String"r" let wstr = wcstr.to_ustring();"r" // U16CString will have a terminating nul"r" let wcvec = wcstr.into_vec_with_nul();"r" assert_eq!(wcvec[wcvec.len()-1], 0);"r" // The resulting U16String will not have the terminating nul"r" let wvec = wstr.into_vec();"r" assert_ne!(wvec[wvec.len()-1], 0);"to_ustringr" Converts to a slice of the underlying elements."r" The slice will **not** include the nul terminator."r" Converts to a mutable slice of the underlying elements."r" This method is unsafe because you can violate the invariants of this type when"r" mutating the slice (i.e. by adding interior nul values)."r" Converts to a slice of the underlying elements, including the nul terminator."as_slice_with_nulr" Returns a raw pointer to the string."r" The caller must ensure that the string outlives the pointer this function returns,"r" or else it will end up pointing to garbage."r" The caller must also ensure that the memory the pointer (non-transitively) points to"r" is never written to (except inside an `UnsafeCell`) using this pointer or any"r" pointer derived from it. If you need to mutate the contents of the string, use"r" [`as_mut_ptr`][Self::as_mut_ptr]."r" Modifying the container referenced by this string may cause its buffer to be"r" reallocated, which would also make any pointers to it invalid."r" Returns a mutable raw pointer to the string."r" Returns the two raw pointers spanning the string slice."r" The returned range is half-open, which means that the end pointer points one past"r" the last element of the slice. This way, an empty slice is represented by two equal"r" pointers, and the difference between the two pointers represents the size of the"r" See [`as_ptr`][Self::as_ptr] for warnings on using these pointers. The end pointer"r" requires extra caution, as it does not point to a valid element in the slice."r" This function is useful for interacting with foreign interfaces which use two"r" pointers to refer to a range of elements in memory, as is common in C++."r" Returns the two unsafe mutable pointers spanning the string slice."r" See [`as_mut_ptr`][Self::as_mut_ptr] for warnings on using these pointers. The end"r" pointer requires extra caution, as it does not point to a valid element in the"r" Returns the length of the string as number of elements (**not** number of bytes)"r" **not** including nul terminator."r" Returns whether this string contains no data (i.e. is only the nul terminator)."r" Converts a boxed wide C string slice into an wide C string without copying or"r" allocating."r#" let v = vec![102u16, 111u16, 111u16]; // "foo""#r" let c_string = U16CString::from_vec(v.clone()).unwrap();"r" let boxed = c_string.into_boxed_ucstr();"r" assert_eq!(boxed.into_ucstring(), U16CString::from_vec(v).unwrap());"into_ucstringr" Returns a wide string slice to this wide C string slice."r" The wide string slice will *not* include the nul-terminator."as_ustrr" The wide string slice will include the nul-terminator."as_ustr_with_nulr" Returns a mutable wide string slice to this wide C string slice."r" mutating the string (i.e. by adding interior nul values)."as_mut_ustrfrom_inner_mutr" Returns an object that implements [`Display`][std::fmt::Display] for printing"r" strings that may contain non-Unicode data."r" A wide C string might data of any encoding. This function assumes the string is encoded in"r" UTF-16, and returns a struct implements the"r" [`Display`][std::fmt::Display] trait in a way that decoding the string is lossy but"r" no heap allocations are performed, such as by"r" [`to_string_lossy`][Self::to_string_lossy]."r" By default, invalid Unicode data is replaced with"r" [`U+FFFD REPLACEMENT CHARACTER`][std::char::REPLACEMENT_CHARACTER] (�). If you wish"r" to simply skip any invalid Uncode data and forego the replacement, you may use the"r" [alternate formatting][std::fmt#sign0] with `{:#}`."r" use widestring::U16CStr;"r" // 𝄞mus<invalid>ic<invalid>"r" let s = U16CStr::from_slice(&["r"     0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834, 0x0000,"r" ]).unwrap();"r#" assert_eq!(format!("{}", s.display()),"#r#" "𝄞mus�ic�""#r" Using alternate formatting style to skip invalid values entirely:"r#" assert_eq!(format!("{:#}", s.display()),"#r#" "𝄞music""#r" Returns a subslice of the string."r" This is the non-panicking alternative to indexing the string. Returns [`None`]"r" whenever equivalent indexing operation would panic."r" Returns a mutable subslice of the string."r" mutating the memory the pointer points to (i.e. by adding interior nul values)."r" Returns an unchecked subslice of the string."r" This is the unchecked alternative to indexing the string."r" Callers of this function are responsible that these preconditions are satisfied:"r" - The starting index must not exceed the ending index;"r" - Indexes must be within bounds of the original slice."r" Failing that, the returned string slice may reference invalid memory."r" Returns aa mutable, unchecked subslice of the string."r" Divide one string slice into two at an index."r" The argument, `mid`, should be an offset from the start of the string."r" The two slices returned go from the start of the string slice to `mid`, and from"r" `mid` to the end of the string slice."r" To get mutable string slices instead, see the [`split_at_mut`][Self::split_at_mut]"r" Divide one mutable string slice into two at an index."r" To get immutable string slices instead, see the [`split_at`][Self::split_at] method."r" Creates a new owned string by repeating this string `n` times."r" This function will panic if the capacity would overflow."r" C-style 32-bit wide string slice for [`U32CString`][crate::U32CString]."r" [`U32CStr`] is to [`U32CString`][crate::U32CString] as [`CStr`][std::ffi::CStr] is to"r" [`U32CStr`] are string slices that do not have a defined encoding. While it is sometimes"r" assumed that they contain possibly invalid or ill-formed UTF-32 data, they may be used for"r" [`U32CStr`] is aware of nul (`0`) values. Unless unchecked conversions are used, all"r" [`U32CStr`] strings end with a nul-terminator in the underlying buffer and contain no"r" construction a [`U32CStr`] under various scenarios. By default, methods such as"r" The easiest way to use [`U32CStr`] outside of FFI is with the [`u32cstr!`][crate::u32cstr]"r" macro to convert string literals into nul-terminated UTF-32 string slices at compile time:"r" use widestring::u32cstr;"r#" let hello = u32cstr!("Hello, world!");"#r" You can also convert any [`u32`] slice directly, as long as it has a nul terminator:"r" use widestring::{u32cstr, U32CStr};"r" let sparkle_heart = [0x1f496, 0x0];"r" let sparkle_heart = U32CStr::from_slice(&sparkle_heart).unwrap();"r#" assert_eq!(u32cstr!("💖"), sparkle_heart);"#r" // This UTf-16 surrogate is invalid UTF-32, but is perfectly valid in U32CStr"r" let malformed_utf32 = [0xd83d, 0x0];"r" let s = U32CStr::from_slice(&malformed_utf32).unwrap();"r" When working with a FFI, it is useful to create a [`U32CStr`] from a pointer:"r"     U32CStr::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len() - 1).unwrap()"r#" assert_eq!(u32cstr!("💖"), s);"#r" let s = unsafe { U32CStr::from_ptr_str(sparkle_heart.as_ptr()) };"r" use widestring::U32CString;"r#" let wcstr = U32CString::from_str("MyString").unwrap();"#r" // Convert U32CString to a U32String"r" // U32CString will have a terminating nul"r" // The resulting U32String will not have the terminating nul"r" Converts a boxed wide C string slice into an owned wide C string without copying or"r#" let v = vec![102u32, 111u32, 111u32]; // "foo""#r" let c_string = U32CString::from_vec(v.clone()).unwrap();"r" assert_eq!(boxed.into_ucstring(), U32CString::from_vec(v).unwrap());"r" UTF-32, and returns a struct implements the"r" use widestring::U32CStr;"r" let s = U32CStr::from_slice(&["r"     0x1d11e, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834, 0x0000,"/// Copys a string to an owned [`OsString`][std::ffi::OsString]./// This makes a string copy of the [`U16CStr`]. Since [`U16CStr`] makes no guarantees that it/// is valid UTF-16, there is no guarantee that the resulting [`OsString`][std::ffi::OsString]/// will be valid data. The [`OsString`][std::ffi::OsString] will **not** have a nul/// Note that the encoding of [`OsString`][std::ffi::OsString] is platform-dependent, so on/// some platforms this may make an encoding conversions, while on other platforms (such as/// windows) no changes to the string will be made./// use widestring::U16CString;/// let s = "MyString";/// // Create a wide string from the string/// let wstr = U16CString::from_str(s).unwrap();/// // Create an OsString from the wide string/// let osstr = wstr.to_os_string();/// assert_eq!(osstr, OsString::from(s));/// Copies the string to a [`String`] if it contains valid UTF-16 data./// This method assumes this string is encoded as UTF-16 and attempts to decode it as such. It/// will **not* have a nul terminator./// Returns an error if the string contains any invalid UTF-16 data./// // Create a regular string from the wide string/// let s2 = wstr.to_string().unwrap();/// assert_eq!(s2, s);/// Decodes the string reference to a [`String`] even if it is invalid UTF-16 data./// This method assumes this string is encoded as UTF-16 and attempts to decode it as such. Any/// invalid sequences are replaced with/// [`U+FFFD REPLACEMENT CHARACTER`][core::char::REPLACEMENT_CHARACTER], which looks like this:/// �. It will **not* have a nul terminator./// let s2 = wstr.to_string_lossy();/// Returns an iterator over the [`char`][prim@char]s of a string slice./// As this string has no defined encoding, this method assumes the string is UTF-16. Since it/// may consist of invalid UTF-16, the iterator returned by this method/// is an iterator over `Result<char, DecodeUtf16Error>` instead of [`char`][prim@char]s/// directly. If you would like a lossy iterator over [`chars`][prim@char]s directly, instead/// use [`chars_lossy`][Self::chars_lossy]./// It's important to remember that [`char`][prim@char] represents a Unicode Scalar Value, and/// may not match your idea of what a 'character' is. Iteration over grapheme clusters may be/// what you actually want. That functionality is not provided by by this crate.chars_lossy/// Returns a lossy iterator over the [`char`][prim@char]s of a string slice./// may consist of invalid UTF-16, the iterator returned by this method will replace unpaired/// surrogates with/// [`U+FFFD REPLACEMENT CHARACTER`][std::char::REPLACEMENT_CHARACTER] (�). This is a lossy/// version of [`chars`][Self::chars]./// Returns an iterator over the chars of a string slice, and their positions./// may consist of invalid UTF-16, the iterator returned by this method is an iterator over/// is an iterator over `Result<char, DecodeUtf16Error>` as well as their positions, instead of/// [`char`][prim@char]s directly. If you would like a lossy indices iterator over/// [`chars`][prim@char]s directly, instead use/// [`char_indices_lossy`][Self::char_indices_lossy]./// The iterator yields tuples. The position is first, the [`char`][prim@char] is second.char_indices_lossy/// Returns a lossy iterator over the chars of a string slice, and their positions./// As this string slice may consist of invalid UTF-16, the iterator returned by this method/// will replace unpaired surrogates with/// [`U+FFFD REPLACEMENT CHARACTER`][std::char::REPLACEMENT_CHARACTER] (�), as well as the/// positions of all characters. This is a lossy version of/// [`char_indices`][Self::char_indices].from_char_ptr_str/// Constructs a string reference from a [`char`] nul-terminated string pointer./// This will scan for nul values beginning with `p`. The first nul value will be used as the/// nul terminator for the string, similar to how libc string functions such as `strlen` work./// This function is unsafe as there is no guarantee that the given pointer is valid or has a/// nul terminator, and the function could scan past the underlying buffer./// In addition, the data must meet the safety conditions of [std::slice::from_raw_parts]./// In particular, the returned string reference *must not be mutated* for the duration of/// lifetime `'a`, except inside an [`UnsafeCell`][std::cell::UnsafeCell]./// This function panics if `p` is null./// The lifetime for the returned string is inferred from its usage. To prevent accidental/// misuse, it's suggested to tie the lifetime to whichever source lifetime is safe in the/// context, such as by providing a helper function taking the lifetime of a host value for the/// string, or by explicit annotation.from_char_ptr_str_mut/// Constructs a mutable string reference from a mutable [`char`] nul-terminated string pointer./// In addition, the data must meet the safety conditions of [std::slice::from_raw_parts_mut].from_char_ptr/// Constructs a string reference from a [`char`] pointer and a length./// The `len` argument is the number of elements, **not** the number of bytes, and does/// **not** include the nul terminator of the string. Thus, a `len` of 0 is valid and means/// that `p` is a pointer directly to the nul terminator of the string./// This will scan the pointer string for an interior nul value and error if one is found/// before the nul terminator at `len` offset. To avoid scanning for interior nuls,/// [`from_ptr_unchecked`][Self::from_ptr_unchecked] may be used instead./// An error is returned if the value at `len` offset is not a nul terminator./// This function is unsafe as there is no guarantee that the given pointer is valid for `len +/// 1` elements.from_char_ptr_mut/// Constructs a mutable string reference from a mutable [`char`] pointer and a length./// [`from_ptr_unchecked_mut`][Self::from_ptr_unchecked_mut] may be used instead.from_char_ptr_truncate/// Constructs a string reference from a [`char`] pointer and a length, truncating at the first/// nul terminator./// The `len` argument is the number of elements, **not** the number of bytes. This will scan/// for nul values beginning with `p` until offset `len`. The first nul value will be used as/// the nul terminator for the string, ignoring any remaining values left before `len`./// If no nul terminator is found after `len` + 1 elements, an error is returned.from_char_ptr_truncate_mut/// Constructs a mutable string reference from a mutable [`char`] pointer and a length,/// truncating at the first nul terminator.from_char_ptr_unchecked/// Constructs a string reference from a [`char`] pointer and a length without checking for any/// nul values./// 1` elements, nor that is has a terminating nul value./// The interior values of the pointer are not scanned for nul. Any interior nul values or/// a missing nul terminator at pointer offset `len` + 1 will result in an invalid string slice.from_char_ptr_unchecked_mut/// Constructs a mutable string reference from a mutable [`char`] pointer and a length without/// checking for any nul values.from_char_slice/// Constructs a string reference from a [`char`] slice with a terminating nul, checking for/// invalid interior nul values./// The slice must have at least one item, the nul terminator, even for an empty string./// If there are nul values in the slice except for the last value, an error is returned./// An error is also returned if the last value of the slice is not a nul terminator.from_char_slice_mut/// Constructs a mutable string reference from a mutable [`char`] slice with a terminating nul,/// checking for invalid interior nul values.from_char_slice_truncate/// Constructs a string reference from a slice of [`char`] values, truncating at the first nul/// The slice will be scanned for nul values. When a nul value is found, it is treated as the/// terminator for the string, and the string slice will be truncated to that nul./// If there are no nul values in the slice, an error is returned.from_char_slice_truncate_mut/// Constructs a mutable string reference from a mutable slice of [`char`] values, truncating at/// the first nul terminator.from_char_slice_unchecked/// Constructs a string reference from a [`char`] slice without checking for a terminating or/// interior nul values./// This function is unsafe because it can lead to invalid C string slice values when the slice/// is missing a terminating nul value or there are non-terminating interior nul values/// in the slice. In particular, an empty slice will result in an invalid string slice.from_char_slice_unchecked_mut/// Constructs a mutable string reference from a mutable [`char`] slice without checking for a/// terminating or interior nul values./// Decodes a string reference to an owned [`OsString`][std::ffi::OsString]./// This makes a string copy of this reference. Since [`U32CStr`] makes no guarantees that it/// is valid UTF-32, there is no guarantee that the resulting [`OsString`][std::ffi::OsString]/// some platforms this may make an encoding conversions, while on other platforms no changes to/// the string will be made./// use widestring::U32CString;/// let wstr = U32CString::from_str(s).unwrap();/// Decodes the string reference to a [`String`] if it contains valid UTF-32 data./// This method assumes this string is encoded as UTF-32 and attempts to decode it as such. It/// Returns an error if the string contains any invalid UTF-32 data./// Decodes the string reference to a [`String`] even if it is invalid UTF-32 data./// As this string has no defined encoding, this method assumes the string is UTF-32. Since it/// may consist of invalid UTF-32, the iterator returned by this method/// is an iterator over `Result<char, DecodeUtf32Error>` instead of [`char`][prim@char]s/// may consist of invalid UTF-32, the iterator returned by this method will replace invalid/// data with/// may consist of invalid UTF-32, the iterator returned by this method is an iterator over/// `Result<char, DecodeUtf32Error>` as well as their positions, instead of/// As this string slice may consist of invalid UTF-32, the iterator returned by this method/// will replace invalid values with/// Alias for [`U16CStr`] or [`U32CStr`] depending on platform. Intended to match typical C/// `wchar_t` size on platform./// Helper struct for printing wide C string values with [`format!`] and `{}`./// A wide C string might contain ill-formed UTF encoding. This struct implements the/// [`Display`][std::fmt::Display] trait in a way that decoding the string is lossy but no heap/// allocations are performed, such as by [`to_string_lossy`][U16CStr::to_string_lossy]. It is/// created by the [`display`][U16CStr::display] method on [`U16CStr`] and [`U32CStr`]./// By default, invalid Unicode data is replaced with/// [`U+FFFD REPLACEMENT CHARACTER`][std::char::REPLACEMENT_CHARACTER] (�). If you wish to simply/// skip any invalid Uncode data and forego the replacement, you may use the/// [alternate formatting][std::fmt#sign0] with `{:#}`.//! C-style wide string slices.//! This module contains wide C string slices and related types.ucstring_common_implr" An owned, mutable C-style 16-bit wide string for FFI that is nul-aware and nul-terminated."r" The string slice of a [`U16CString`] is [`U16CStr`]."r" [`U16CString`] strings do not have a defined encoding. While it is sometimes"r" [`U16CString`] is aware of nul (`0`) values. Unless unchecked conversions are used, all"r" [`U16CString`] strings end with a nul-terminator in the underlying buffer and contain no"r" internal nul values. These strings are intended to be used with FFI functions that require"r" nul-terminated strings."r" construction a [`U16CString`] under various scenarios. By default, methods such as"r" [`from_ptr`][Self::from_ptr] and [`from_vec`][Self::from_vec] return an error if it contains"r" any interior nul values before the terminator. For these methods, the input does not need to"r" contain the terminating nul; it is added if it is does not exist."r" [`from_vec_truncate`][Self::from_vec_truncate], construct a string that terminates with"r" the first nul value encountered in the string, and do not return an error. They"r" automatically ensure the string is terminated in a nul value even if it was not originally."r" [`from_vec_unchecked`][Self::from_vec_unchecked] allow bypassing any checks for nul"r" values, when the input has already been ensured to no interior nul values. Again, any"r" missing nul terminator is automatically added if necessary."r" The easiest way to use [`U16CString`] outside of FFI is with the"r" [`u16cstr!`][crate::u16cstr] macro to convert string literals into nul-terminated UTF-16"r" strings at compile time:"r" use widestring::{u16cstr, U16CString};"r#" let hello = U16CString::from(u16cstr!("Hello, world!"));"#r" You can also convert any [`u16`] slice or vector directly:"r" let sparkle_heart = vec![0xd83d, 0xdc96];"r" let sparkle_heart = U16CString::from_vec(sparkle_heart).unwrap();"r" // The string will add the missing nul terminator"r" // This unpaired UTf-16 surrogate is invalid UTF-16, but is perfectly valid in U16CString"r" let malformed_utf16 = vec![0xd83d, 0x0];"r" let s = U16CString::from_vec(malformed_utf16).unwrap();"r" assert_eq!(s.len(), 1); // Note the terminating nul is not counted in the length"r" When working with a FFI, it is useful to create a [`U16CString`] from a pointer:"r"     U16CString::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len() - 1).unwrap()"r" let s = unsafe { U16CString::from_ptr_str(sparkle_heart.as_ptr()) };"r" Constructs a new empty wide C string."r" Constructs a wide C string from a container of wide character data."r" This method will consume the provided data and use the underlying elements to"r" construct a new string. The data will be scanned for invalid interior nul values."r" This function will return an error if the data contains a nul value that is not the"r" terminating nul."r" The returned error will contain the original [`Vec`] as well as the position of the"r" nul value."r" let v = vec![84u16, 104u16, 101u16]; // 'T' 'h' 'e'"r" # let cloned = v.clone();"r" // Create a wide string from the vector"r" let wcstr = U16CString::from_vec(v).unwrap();"r" # assert_eq!(wcstr.into_vec(), cloned);"r" Empty vectors are valid and will return an empty string with a nul terminator:"r" let wcstr = U16CString::from_vec(vec![]).unwrap();"r" assert_eq!(wcstr, U16CString::default());"r" The following example demonstrates errors from nul values in a vector."r" let v = vec![84u16, 0u16, 104u16, 101u16]; // 'T' NUL 'h' 'e'"r" let res = U16CString::from_vec(v);"r" assert!(res.is_err());"r" assert_eq!(res.err().unwrap().nul_position(), 1);"r" Constructs a wide C string from a container of wide character data, truncating at"r" the first nul terminator."r" The string will be truncated at the first nul value in the data."r" let v = vec![84u16, 104u16, 101u16, 0u16]; // 'T' 'h' 'e' NUL"r" # let cloned = v[..3].to_owned();"r" let wcstr = U16CString::from_vec_truncate(v);"from_vec_truncater" Constructs a wide C string from a vector without checking for interior nul values."r" A terminating nul value will be appended if the vector does not already have a"r" This method is equivalent to [`from_vec`][Self::from_vec] except that no runtime"r" assertion is made that `v` contains no interior nul values. Providing a vector with"r" any nul values that are not the last value in the vector will result in an invalid"r" C string."from_vec_uncheckedr" Constructs a wide C string from anything that can be converted to a wide string"r" The string will be scanned for invalid interior nul values."r" The returned error will contain a [`Vec`] as well as the position of the nul value."from_ustrr" slice, truncating at the first nul terminator."r" The string will be truncated at the first nul value in the string."from_ustr_truncater" slice, without scanning for invalid nul values."r" This method is equivalent to [`from_ustr`][Self::from_ustr] except that no runtime"r" assertion is made that `v` contains no interior nul values. Providing a string with"from_ustr_uncheckedr" Constructs a new wide C string copied from a nul-terminated string pointer."r" If you wish to avoid copying the string pointer, use [`U16CStr::from_ptr_str`] or"r" [`U32CStr::from_ptr_str`] instead."r" [std::slice::from_raw_parts]."r" Constructs a wide C string copied from a pointer and a length, checking for invalid"r" interior nul values."r" **not** include the nul terminator of the string. If `len` is `0`, `p` is allowed to"r" be a null pointer."r" The resulting string will always be nul-terminated even if the pointer data is not."r" found. To avoid scanning for interior nuls,"r" [`from_ptr_unchecked`][Self::from_ptr_unchecked] may be used instead."r" `len` elements."r" Panics if `len` is greater than 0 but `p` is a null pointer."r" Constructs a wide C string copied from a pointer and a length, truncating at the"r" before `len`. If no nul value is found, the whole string of length `len` is used,"r" and a new nul-terminator will be added to the resulting string. If `len` is `0`, `p`"r" is allowed to be a null pointer."r" Constructs a wide C string copied from a pointer and a length without checking for"r" or will result in an invalid C string."r" Converts to a wide C string slice."as_ucstrr" Converts to a mutable wide C string slice."as_mut_ucstrr" Converts this string into a wide string without a nul terminator."r" The resulting string will **not** contain a nul-terminator, and will contain no"r" other nul values."into_ustringr" Converts this string into a wide string with a nul terminator."r" The resulting vector will contain a nul-terminator and no interior nul values."into_ustring_with_nulr" Converts the string into a [`Vec`] without a nul terminator, consuming the string in"r" The resulting vector will **not** contain a nul-terminator, and will contain no"r" Converts the string into a [`Vec`], consuming the string in the process."into_vec_with_nulr" Transfers ownership of the string to a C caller."r" The pointer _must_ be returned to Rust and reconstituted using"r" [`from_raw`][Self::from_raw] to be properly deallocated. Specifically, one should"r" _not_ use the standard C `free` function to deallocate this string. Failure to call"r" [`from_raw`][Self::from_raw] will lead to a memory leak."r" Retakes ownership of a wide C string that was transferred to C."r" This should only be used in combination with [`into_raw`][Self::into_raw]. To"r" construct a new wide C string from a pointer, use"r" [`from_ptr_str`][Self::from_ptr_str]."r" This should only ever be called with a pointer that was earlier obtained by calling"r" [`into_raw`][Self::into_raw]. Additionally, the length of the string will be"r" recalculated from the pointer by scanning for the nul-terminator."r" Panics if `p` is a null pointer."r" Converts this wide C string into a boxed wide C string slice."r" use widestring::{U16CString, U16CStr};"r#" let mut v = vec![102u16, 111u16, 111u16]; // "foo""#r" v.push(0);"r" assert_eq!(&*boxed, U16CStr::from_slice(&v).unwrap());"into_boxed_ucstrr#" Bypass "move out of struct which implements [`Drop`] trait" restriction."#r" An owned, mutable C-style 32-bit wide string for FFI that is nul-aware and nul-terminated."r" The string slice of a [`U32CString`] is [`U32CStr`]."r" [`U32CString`] strings do not have a defined encoding. While it is sometimes"r" [`U32CString`] is aware of nul (`0`) values. Unless unchecked conversions are used, all"r" [`U32CString`] strings end with a nul-terminator in the underlying buffer and contain no"r" construction a [`U32CString`] under various scenarios. By default, methods such as"r" The easiest way to use [`U32CString`] outside of FFI is with the"r" [`u32cstr!`][crate::u32cstr] macro to convert string literals into nul-terminated UTF-32"r" use widestring::{u32cstr, U32CString};"r#" let hello = U32CString::from(u32cstr!("Hello, world!"));"#r" You can also convert any [`u32`] slice or vector directly:"r" let sparkle_heart = vec![0x1f496];"r" let sparkle_heart = U32CString::from_vec(sparkle_heart).unwrap();"r" // This UTf-16 surrogate is invalid UTF-32, but is perfectly valid in U32CString"r" let malformed_utf32 = vec![0xd83d, 0x0];"r" let s = U32CString::from_vec(malformed_utf32).unwrap();"r" When working with a FFI, it is useful to create a [`U32CString`] from a pointer:"r"     U32CString::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len() - 1).unwrap()"r" let s = unsafe { U32CString::from_ptr_str(sparkle_heart.as_ptr()) };"r" let v = vec![84u32, 104u32, 101u32]; // 'T' 'h' 'e'"r" let wcstr = U32CString::from_vec(v).unwrap();"r" let wcstr = U32CString::from_vec(vec![]).unwrap();"r" assert_eq!(wcstr, U32CString::default());"r" let v = vec![84u32, 0u32, 104u32, 101u32]; // 'T' NUL 'h' 'e'"r" let res = U32CString::from_vec(v);"r" let v = vec![84u32, 104u32, 101u32, 0u32]; // 'T' 'h' 'e' NUL"r" let wcstr = U32CString::from_vec_truncate(v);"r" use widestring::{U32CString, U32CStr};"r#" let mut v = vec![102u32, 111u32, 111u32]; // "foo""#r" assert_eq!(&*boxed, U32CStr::from_slice(&v).unwrap());"/// Constructs a [`U16CString`] copy from a [`str`], encoding it as UTF-16./// This makes a string copy of the [`str`]. Since [`str`] will always be valid UTF-8, the/// resulting [`U16CString`] will also be valid UTF-16./// The string will be scanned for nul values, which are invalid anywhere except the final/// The resulting string will always be nul-terminated even if the original string is not./// This function will return an error if the data contains a nul value anywhere except the/// final position./// The returned error will contain a [`Vec<u16>`] as well as the position of the nul value./// let wcstr = U16CString::from_str(s).unwrap();/// # assert_eq!(wcstr.to_string_lossy(), s);/// The following example demonstrates errors from nul values in a string./// let s = "My\u{0}String";/// let res = U16CString::from_str(s);/// assert_eq!(res.err().unwrap().nul_position(), 2);/// Constructs a [`U16CString`] copy from a [`str`], encoding it as UTF-16, without checking for/// This method is equivalent to [`from_str`][Self::from_str] except that no runtime assertion/// is made that `s` contains no interior nul values. Providing a string with nul values that/// are not the last character will result in an invalid [`U16CString`]./// let wcstr = unsafe { U16CString::from_str_unchecked(s) };/// Constructs a [`U16CString`] copy from a [`str`], encoding it as UTF-16, truncating at the/// first nul terminator./// The string will be truncated at the first nul value in the string./// let wcstr = U16CString::from_str_truncate(s);/// assert_eq!(wcstr.to_string_lossy(), "My");from_os_str/// Constructs a [`U16CString`] copy from an [`OsStr`][std::ffi::OsStr]./// This makes a string copy of the [`OsStr`][std::ffi::OsStr]. Since [`OsStr`][std::ffi::OsStr]/// makes no guarantees that it is valid data, there is no guarantee that the resulting/// [`U16CString`] will be valid UTF-16./// Note that the encoding of [`OsStr`][std::ffi::OsStr] is platform-dependent, so on/// last character./// let wcstr = U16CString::from_os_str(s).unwrap();/// The following example demonstrates errors from nul values in the string./// let res = U16CString::from_os_str(s);from_os_str_unchecked/// Constructs a [`U16CString`] copy from an [`OsStr`][std::ffi::OsStr], without checking for nul/// This method is equivalent to [`from_os_str`][Self::from_os_str] except that no runtime/// assertion is made that `s` contains no interior nul values. Providing a string with nul/// values anywhere but the last character will result in an invalid [`U16CString`]./// let wcstr = unsafe { U16CString::from_os_str_unchecked(s) };from_os_str_truncate/// Constructs a [`U16CString`] copy from an [`OsStr`][std::ffi::OsStr], truncating at the first/// let wcstr = U16CString::from_os_str_truncate(s);from_chars/// Constructs a [`U32CString`] from a container of character data, checking for invalid nul/// This method will consume the provided data and use the underlying elements to construct a/// new string. The data will be scanned for invalid nul values anywhere except the last/// The returned error will contain the [`Vec<u32>`] as well as the position of the nul value./// let v: Vec<char> = "Test".chars().collect();/// # let cloned: Vec<u32> = v.iter().map(|&c| c as u32).collect();/// // Create a wide string from the vector/// let wcstr = U32CString::from_chars(v).unwrap();/// # assert_eq!(wcstr.into_vec(), cloned);/// The following example demonstrates errors from nul values in a vector./// let v: Vec<char> = "T\u{0}est".chars().collect();/// let res = U32CString::from_chars(v);/// assert_eq!(res.err().unwrap().nul_position(), 1);from_chars_truncate/// Constructs a [`U32CString`] from a container of character data, truncating at the first nul/// new string. The string will be truncated at the first nul value in the string./// let v: Vec<char> = "Test\u{0}".chars().collect();/// # let cloned: Vec<u32> = v[..4].iter().map(|&c| c as u32).collect();/// let wcstr = U32CString::from_chars_truncate(v);from_chars_unchecked/// Constructs a [`U32CString`] from character data without checking for nul values./// A terminating nul value will be appended if the vector does not already have a terminating/// nul./// This method is equivalent to [`from_chars`][Self::from_chars] except that no runtime/// assertion is made that `v` contains no interior nul values. Providing a vector with nul/// values anywhere but the last character will result in an invalid [`U32CString`]./// Constructs a [`U32CString`] copy from a [`str`], encoding it as UTF-32 and checking for/// resulting [`U32CString`] will also be valid UTF-32./// The string will be scanned for nul values, which are invalid anywhere except the last/// The returned error will contain a [`Vec<u32>`] as well as the position of the nul value./// let wcstr = U32CString::from_str(s).unwrap();/// let res = U32CString::from_str(s);/// Constructs a [`U32CString`] copy from a [`str`], encoding it as UTF-32, without checking for/// is made that `s` contains invalid nul values. Providing a string with nul values anywhere/// except the last character will result in an invalid [`U32CString`]./// let wcstr = unsafe { U32CString::from_str_unchecked(s) };/// Constructs a [`U32CString`] copy from a [`str`], encoding it as UTF-32, truncating at the/// let wcstr = U32CString::from_str_truncate(s);/// Constructs a new wide C string copied from a nul-terminated [`char`] string pointer./// If you wish to avoid copying the string pointer, use [`U32CStr::from_char_ptr_str`] instead./// Constructs a wide C string copied from a [`char`] pointer and a length, checking for invalid/// **not** include the nul terminator of the string. If `len` is `0`, `p` is allowed to be a/// null pointer./// The resulting string will always be nul-terminated even if the pointer data is not./// This will scan the pointer string for an interior nul value and error if one is found. To/// avoid scanning for interior nuls, [`from_ptr_unchecked`][Self::from_ptr_unchecked] may be/// The returned error will contain a [`Vec`] as well as the position of the nul value./// This function is unsafe as there is no guarantee that the given pointer is valid for `len`/// Panics if `len` is greater than 0 but `p` is a null pointer./// Constructs a wide C string copied from a [`char`] pointer and a length, truncating at the/// the nul terminator for the string, ignoring any remaining values left before `len`. If no/// nul value is found, the whole string of length `len` is used, and a new nul-terminator/// will be added to the resulting string. If `len` is `0`, `p` is allowed to be a null pointer./// Constructs a wide C string copied from a [`char`] pointer and a length without checking for/// any nul values./// will result in an invalid C string./// Constructs a [`U32CString`] copy from an [`OsStr`][std::ffi::OsStr], checking for invalid/// [`U32CString`] will be valid UTF-32./// The string will be scanned for nul values, which are invlaid anywhere except the last/// The resulting string will always be nul-terminated even if the string is not./// let wcstr = U32CString::from_os_str(s).unwrap();/// let res = U32CString::from_os_str(s);/// Constructs a [`U32CString`] copy from an [`OsStr`][std::ffi::OsStr], without checking for/// assertion is made that `s` contains invalid nul values. Providing a string with nul values/// anywhere except the last character will result in an invalid [`U32CString`]./// let wcstr = unsafe { U32CString::from_os_str_unchecked(s) };/// Constructs a [`U32CString`] copy from an [`OsStr`][std::ffi::OsStr], truncating at the first/// let wcstr = U32CString::from_os_str_truncate(s);/// Alias for `U16String` or `U32String` depending on platform. Intended to match typical C//! C-style owned, growable wide strings.//! This module contains wide C strings and related types./// An iterator over UTF-16 decoded [`char`][prim@char]s of a string slice./// This struct is created by the `chars` method on strings. See its documentation for more./// An iterator over UTF-32 decoded [`char`][prim@char]s of a string slice./// A lossy iterator over UTF-16 decoded [`char`][prim@char]s of a string slice./// This struct is created by the `chars_lossy` method on strings. See its documentation for more./// A lossy iterator over UTF-32 decoded [`char`][prim@char]s of a string slice.back_offset/// An iterator over the decoded [`char`][prim@char]s of a string slice, and their positions./// This struct is created by the `char_indices` method on strings. See its documentation for/// more./// Returns the position of the next character, or the length of the underlying string if/// there are no more characters./// A lossy iterator over the [`char`][prim@char]s of a string slice, and their positions./// This struct is created by the `char_indices_lossy` method on strings. See its documentationustr_common_implr" 16-bit wide string slice with undefined encoding."r" [`U16Str`] is to [`U16String`][crate::U16String] as [`OsStr`][std::ffi::OsStr] is to"r" [`OsString`][std::ffi::OsString]."r" [`U16Str`] are string slices that do not have a defined encoding. While it is sometimes"r" any wide encoded string. This is because [`U16Str`] is intended to be used with FFI"r" functions, where proper encoding cannot be guaranteed. If you need string slices that are"r" always valid UTF-16 strings, use [`Utf16Str`][crate::Utf16Str] instead."r" Because [`U16Str`] does not have a defined encoding, no restrictions are placed on mutating"r" or indexing the slice. This means that even if the string contained properly encoded UTF-16"r" or other encoding data, mutationing or indexing may result in malformed data. Convert to a"r" [`Utf16Str`][crate::Utf16Str] if retaining proper UTF-16 encoding is desired."r" # FFI considerations"r" [`U16Str`] is not aware of nul values and may or may not be nul-terminated. It is intended"r" to be used with FFI functions that directly use string length, where the strings are known"r" to have proper nul-termination already, or where strings are merely being passed through"r" without modification."r" [`U16CStr`][crate::U16CStr] should be used instead if nul-aware strings are required."r" The easiest way to use [`U16Str`] outside of FFI is with the [`u16str!`][crate::u16str]"r" macro to convert string literals into UTF-16 string slices at compile time:"r" use widestring::u16str;"r#" let hello = u16str!("Hello, world!");"#r" You can also convert any [`u16`] slice directly:"r" use widestring::{u16str, U16Str};"r" let sparkle_heart = [0xd83d, 0xdc96];"r" let sparkle_heart = U16Str::from_slice(&sparkle_heart);"r#" assert_eq!(u16str!("💖"), sparkle_heart);"#r" // This unpaired UTf-16 surrogate is invalid UTF-16, but is perfectly valid in U16Str"r" let malformed_utf16 = [0x0, 0xd83d]; // Note that nul values are also valid an untouched"r" let s = U16Str::from_slice(&malformed_utf16);"r" assert_eq!(s.len(), 2);"r" When working with a FFI, it is useful to create a [`U16Str`] from a pointer and a length:"r" let sparkle_heart = unsafe {"r"     U16Str::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len())"r" Coerces a value into a wide string slice."r" Constructs a wide string slice from a pointer and a length."r" The `len` argument is the number of elements, **not** the number of bytes. No"r" copying or allocation is performed, the resulting value is a direct reference to the"r" pointer bytes."r" Constructs a mutable wide string slice from a mutable pointer and a length."r" Constructs a wide string slice from a slice of character data."r" No checks are performed on the slice. It may be of any encoding and may contain"r" invalid or malformed data for that encoding."r" Constructs a mutable wide string slice from a mutable slice of character data."r" Converts to a slice of the underlying elements of the string."r" Converts to a mutable slice of the underlying elements of the string."r" Returns an unsafe mutable raw pointer to the string."r" Returns the length of the string as number of elements (**not** number of bytes)."r" Returns whether this string contains no data."r" Converts a boxed wide string slice into an owned wide string without copying or"r" This method assumes this string is intended to be UTF-16 encoding, but handles"r" ill-formed UTF-16 sequences lossily. The returned struct implements"r" the [`Display`][std::fmt::Display] trait in a way that decoding the string is lossy"r" UTF-16 decoding but no heap allocations are performed, such as by"r" use widestring::U16Str;"r" let s = U16Str::from_slice(&["r"     0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,"r" ]);"r" 32-bit wide string slice with undefined encoding."r" [`U32Str`] is to [`U32String`][crate::U32String] as [`OsStr`][std::ffi::OsStr] is to"r" [`U32Str`] are string slices that do not have a defined encoding. While it is sometimes"r" any wide encoded string. This is because [`U32Str`] is intended to be used with FFI"r" always valid UTF-32 strings, use [`Utf32Str`][crate::Utf32Str] instead."r" Because [`U32Str`] does not have a defined encoding, no restrictions are placed on mutating"r" or indexing the slice. This means that even if the string contained properly encoded UTF-32"r" [`Utf32Str`][crate::Utf32Str] if retaining proper UTF-32 encoding is desired."r" [`U32Str`] is not aware of nul values and may or may not be nul-terminated. It is intended"r" [`U32CStr`][crate::U32CStr] should be used instead if nul-aware strings are required."r" The easiest way to use [`U32Str`] outside of FFI is with the [`u32str!`][crate::u32str]"r" macro to convert string literals into UTF-32 string slices at compile time:"r" use widestring::u32str;"r#" let hello = u32str!("Hello, world!");"#r" You can also convert any [`u32`] slice directly:"r" use widestring::{u32str, U32Str};"r" let sparkle_heart = [0x1f496];"r" let sparkle_heart = U32Str::from_slice(&sparkle_heart);"r#" assert_eq!(u32str!("💖"), sparkle_heart);"#r" // This UTf-16 surrogate is invalid UTF-32, but is perfectly valid in U32Str"r" let malformed_utf32 = [0x0, 0xd83d]; // Note that nul values are also valid an untouched"r" let s = U32Str::from_slice(&malformed_utf32);"r" When working with a FFI, it is useful to create a [`U32Str`] from a pointer and a length:"r"     U32Str::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len())"r" This method assumes this string is intended to be UTF-32 encoding, but handles"r" ill-formed UTF-32 sequences lossily. The returned struct implements"r" UTF-32 decoding but no heap allocations are performed, such as by"r" use widestring::U32Str;"r" let s = U32Str::from_slice(&["r"     0x1d11e, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,"/// This makes a string copy of the [`U16Str`]. Since [`U16Str`] makes no guarantees that its/// encoding is UTF-16 or that the data valid UTF-16, there is no guarantee that the resulting/// [`OsString`][std::ffi::OsString] will have a valid underlying encoding either./// use widestring::U16String;/// let wstr = U16String::from_str(s);/// Decodes this string to a [`String`] if it contains valid UTF-16 data./// This method assumes this string is encoded as UTF-16 and attempts to decode it as such./// Decodes the string to a [`String`] even if it is invalid UTF-16 data./// �/// let lossy = wstr.to_string_lossy();/// assert_eq!(lossy, s);/// `Result<char, DecodeUtf16Error>` as well as their positions, instead of/// Constructs a [`U32Str`] from a [`char`][prim@char] pointer and a length./// The `len` argument is the number of `char` elements, **not** the number of bytes. No copying/// or allocation is performed, the resulting value is a direct reference to the pointer bytes./// Constructs a mutable [`U32Str`] from a mutable [`char`][prim@char] pointer and a length./// Constructs a [`U32Str`] from a [`char`][prim@char] slice./// No checks are performed on the slice./// Constructs a mutable [`U32Str`] from a mutable [`char`][prim@char] slice./// Decodes a string to an owned [`OsString`][std::ffi::OsString]./// use widestring::U32String;/// let wstr = U32String::from_str(s);/// Decodes the string to a [`String`] if it contains valid UTF-32 data./// This method assumes this string is encoded as UTF-32 and attempts to decode it as such./// may consist of invalid UTF-32, the iterator returned by this method will replace unpaired/// Alias for [`U16Str`] or [`U32Str`] depending on platform. Intended to match typical C `wchar_t`/// size on platform./// Helper struct for printing wide string values with [`format!`] and `{}`./// A wide string might contain ill-formed UTF encoding. This struct implements the/// allocations are performed, such as by [`to_string_lossy`][U16Str::to_string_lossy]. It is/// created by the [`display`][U16Str::display] method on [`U16Str`] and [`U32Str`].//! Wide string slices with undefined encoding.//! This module contains wide string slices and related types./// A draining iterator for string data with unknown encoding.ustring_common_implr" An owned, mutable 16-bit wide string with undefined encoding."r" The string slice of a [`U16String`] is [`U16Str`]."r" [`U16String`] are strings that do not have a defined encoding. While it is sometimes"r" any wide encoded string. This is because [`U16String`] is intended to be used with FFI"r" always valid UTF-16 strings, use [`Utf16String`][crate::Utf16String] instead."r" Because [`U16String`] does not have a defined encoding, no restrictions are placed on"r" mutating or indexing the string. This means that even if the string contained properly"r" encoded UTF-16 or other encoding data, mutationing or indexing may result in malformed data."r" Convert to a [`Utf16String`][crate::Utf16String] if retaining proper UTF-16 encoding is"r" desired."r" [`U16String`] is not aware of nul values. Strings may or may not be nul-terminated, and may"r" contain invalid and ill-formed UTF-16. These strings are intended to be used with FFI functions"r" that directly use string length, where the strings are known to have proper nul-termination"r" already, or where strings are merely being passed through without modification."r" [`U16CString`][crate::U16CString] should be used instead if nul-aware strings are required."r" The easiest way to use [`U16String`] outside of FFI is with the [`u16str!`][crate::u16str]"r" use widestring::{u16str, U16String};"r#" let hello = U16String::from(u16str!("Hello, world!"));"#r" let sparkle_heart = U16String::from_vec(sparkle_heart);"r" // This unpaired UTf-16 surrogate is invalid UTF-16, but is perfectly valid in U16String"r" let malformed_utf16 = vec![0x0, 0xd83d]; // Note that nul values are also valid an untouched"r" let s = U16String::from_vec(malformed_utf16);"r" The following example constructs a [`U16String`] and shows how to convert a [`U16String`] to"r" a regular Rust [`String`]."r" use widestring::U16String;"r#" let s = "Test";"#r" // Create a wide string from the rust string"r" let wstr = U16String::from_str(s);"r" // Convert back to a rust string"r" let rust_str = wstr.to_string_lossy();"r#" assert_eq!(rust_str, "Test");"#r" Constructs a new empty wide string."r" Constructs a wide string from a vector."r" No checks are made on the contents of the vector. It may or may not be valid"r" character data."r" let wstr = U16String::from_vec(v);"r" # assert_eq!(wstr.into_vec(), cloned);"r" use widestring::U32String;"r" let wstr = U32String::from_vec(v);"r" Constructs a wide string copy from a pointer and a length."r" The `len` argument is the number of elements, **not** the number of bytes."r" Constructs a wide string with the given capacity."r" The string will be able to hold exactly `capacity` elements without reallocating."r" If `capacity` is set to 0, the string will not initially allocate."r" Returns the capacity this wide string can hold without reallocating."r" Truncates the wide string to zero length."r" Reserves the capacity for at least `additional` more capacity to be inserted in the"r" given wide string."r" More space may be reserved to avoid frequent allocations."r" Reserves the minimum capacity for exactly `additional` more capacity to be inserted"r" in the given wide string. Does nothing if the capacity is already sufficient."r" Note that the allocator may give more space than is requested. Therefore capacity"r" can not be relied upon to be precisely minimal. Prefer [`reserve`][Self::reserve] if"r" future insertions are expected."r" Converts to a wide string slice."r" Converts to a mutable wide string slice."r" Returns a [`Vec`] reference to the contents of this string."r" Returns a mutable reference to the contents of this string."r" Extends the string with the given string slice."r" No checks are performed on the strings. It is possible to end up nul values inside"r" the string, or invalid encoding, and it is up to the caller to determine if that is"r" acceptable."r#" let s = "MyString";"#r" let mut wstr = U16String::from_str(s);"r" let cloned = wstr.clone();"r" // Push the clone to the end, repeating the string twice."r" wstr.push(cloned);"r#" assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");"#r" Extends the string with the given slice."r" wstr.push_slice(cloned);"r" Shrinks the capacity of the wide string to match its length."r" Shrinks the capacity of this string with a lower bound."r" The capacity will remain at least as large as both the length and the supplied"r" If the current capacity is less than the lower limit, this is a no-op."r" Converts this wide string into a boxed string slice."r" use widestring::{U16String, U16Str};"r#" let s = U16String::from_str("hello");"#r" let b: Box<U16Str> = s.into_boxed_ustr();"into_boxed_ustrr" Shortens this string to the specified length."r" If `new_len` is greater than the string's current length, this has no effect."r" Note that this method has no effect on the allocated capacity of the string."r" Inserts a string slice into this string at a specified position."r" This is an _O(n)_ operation as it requires copying every element in the buffer."r" Panics if `idx` is larger than the string's length."insert_ustrr" Splits the string into two at the given index."r" Returns a newly allocated string. `self` contains values `[0, at)`, and the returned"r" string contains values `[at, len)`."r" Note that the capacity of `self` does not change."r" Panics if `at` is equal to or greater than the length of the string."r" Retains only the elements specified by the predicate."r" In other words, remove all elements `e` such that `f(e)` returns `false`. This"r" method operates in place, visiting each element exactly once in the original order,"r" and preserves the order of the retained elements."r" Creates a draining iterator that removes the specified range in the string and"r" yields the removed elements."r" Note: The element range is removed even if the iterator is not consumed until the"r" end."r" Panics if the starting point or end point are out of bounds."r" Removes the specified range in the string, and replaces it with the given string."r" The given string doesn't need to be the same length as the range."replace_ranger" An owned, mutable 32-bit wide string with undefined encoding."r" The string slice of a [`U32String`] is [`U32Str`]."r" [`U32String`] are strings that do not have a defined encoding. While it is sometimes"r" any wide encoded string. This is because [`U32String`] is intended to be used with FFI"r" always valid UTF-32 strings, use [`Utf32String`][crate::Utf32String] instead."r" Because [`U32String`] does not have a defined encoding, no restrictions are placed on"r" encoded UTF-32 or other encoding data, mutationing or indexing may result in malformed data."r" Convert to a [`Utf32String`][crate::Utf32String] if retaining proper UTF-16 encoding is"r" [`U32String`] is not aware of nul values. Strings may or may not be nul-terminated, and may"r" contain invalid and ill-formed UTF-32. These strings are intended to be used with FFI functions"r" [`U32CString`][crate::U32CString] should be used instead if nul-aware strings are required."r" The easiest way to use [`U32String`] outside of FFI is with the [`u32str!`][crate::u32str]"r" use widestring::{u32str, U32String};"r#" let hello = U32String::from(u32str!("Hello, world!"));"#r" let sparkle_heart = U32String::from_vec(sparkle_heart);"r" // This UTf-16 surrogate is invalid UTF-32, but is perfectly valid in U32String"r" let malformed_utf32 = vec![0x0, 0xd83d]; // Note that nul values are also valid an untouched"r" let s = U32String::from_vec(malformed_utf32);"r" The following example constructs a [`U32String`] and shows how to convert a [`U32String`] to"r" let wstr = U32String::from_str(s);"r" let mut wstr = U32String::from_str(s);"r" use widestring::{U32String, U32Str};"r#" let s = U32String::from_str("hello");"#r" let b: Box<U32Str> = s.into_boxed_ustr();"/// Constructs a [`U16String`] copy from a [`str`], encoding it as UTF-16./// resulting [`U16String`] will also be valid UTF-16./// assert_eq!(wstr.to_string().unwrap(), s);/// Constructs a [`U16String`] copy from an [`OsStr`][std::ffi::OsStr]./// [`U16String`] will be valid UTF-16./// let wstr = U16String::from_os_str(s);/// Extends the string with the given string slice, encoding it at UTF-16./// No checks are performed on the strings. It is possible to end up nul values inside the/// string, and it is up to the caller to determine if that is acceptable./// let mut wstr = U16String::from_str(s);/// // Push the original to the end, repeating the string twice./// wstr.push_str(s);/// assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");push_os_str/// Extends the string with the given string slice./// wstr.push_os_str(s);/// Appends the given [`char`][prim@char] encoded as UTF-16 to the end of this string.pop_char/// Removes the last character or unpaired surrogate from the string buffer and returns it./// This method assumes UTF-16 encoding, but handles invalid UTF-16 by returning unpaired/// surrogates./// Returns `None` if this String is empty. Otherwise, returns the character cast to a/// [`u32`][prim@u32] or the value of the unpaired surrogate as a [`u32`][prim@u32] value.remove_char/// Removes a [`char`][prim@char] or unpaired surrogate from this string at a position and/// returns it as a [`u32`][prim@u32]./// This is an _O(n)_ operation, as it requires copying every element in the buffer./// Panics if `idx` is larger than or equal to the string's length.insert_char/// Inserts a character encoded as UTF-16 into this string at a specified position./// This is an _O(n)_ operation as it requires copying every element in the buffer./// Panics if `idx` is larger than the string's length./// Constructs a [`U32String`] from a [`char`][prim@char] vector./// No checks are made on the contents of the vector./// let wstr = U32String::from_chars(v);/// # assert_eq!(wstr.into_vec(), cloned);/// Constructs a [`U16String`] copy from a [`str`], encoding it as UTF-32./// resulting [`U32String`] will also be valid UTF-32./// Constructs a [`U32String`] copy from an [`OsStr`][std::ffi::OsStr]./// [`U32String`] will be valid UTF-32./// let wstr = U32String::from_os_str(s);/// Constructs a [`U32String`] from a [`char`][prim@char] pointer and a length./// The `len` argument is the number of `char` elements, **not** the number of bytes./// Extends the string with the given string slice, encoding it at UTF-32./// let mut wstr = U32String::from_str(s);/// Appends the given [`char`][prim@char] encoded as UTF-32 to the end of this string./// Removes the last value from the string buffer and returns it./// This method assumes UTF-32 encoding./// Returns `None` if this String is empty./// Removes a value from this string at a position and returns it./// Inserts a character encoded as UTF-32 into this string at a specified position./// Alias for [`U16String`] or [`U32String`] depending on platform. Intended to match typical Cnumber_to_stringtruncated_with_surrogate//! Owned, growable wide strings with undefined encoding.//! This module contains wide strings and related types./// An iterator over the [`char`]s of a UTF-16 string slice/// This struct is created by the [`chars`][crate::Utf16Str::chars] method on/// [`Utf16Str`][crate::Utf16Str]. See its documentation for more./// An iterator over the [`char`]s of a UTF-32 string slice/// This struct is created by the [`chars`][crate::Utf32Str::chars] method on/// [`Utf32Str`][crate::Utf32Str]. See its documentation for more./// An iterator over the [`char`]s of a string slice, and their positions/// This struct is created by the [`char_indices`][crate::Utf16Str::char_indices] method on/// This struct is created by the [`char_indices`][crate::Utf32Str::char_indices] method onEscapeDebug/// The return type of [`Utf16Str::escape_debug`][crate::Utf16Str::escape_debug]./// The return type of [`Utf16Str::escape_default`][crate::Utf16Str::escape_default].EscapeUnicode/// The return type of [`Utf16Str::escape_unicode`][crate::Utf16Str::escape_unicode].escape_implsCodeUnits/// An iterator over the [`u16`] code units of a UTF-16 string slice/// This struct is created by the [`code_units`][crate::Utf16Str::code_units] method onutfstr_common_implr" UTF-16 string slice for [`Utf16String`][crate::Utf16String]."r" [`Utf16Str`] is to [`Utf16String`][crate::Utf16String] as [`str`] is to [`String`]."r" [`Utf16Str`] slices are string slices that are always valid UTF-16 encoding. This is unlike"r" the [`U16Str`][crate::U16Str] string slices, which may not have valid encoding. In this way,"r" [`Utf16Str`] string slices most resemble native [`str`] slices of all the types in this"r" The easiest way to use [`Utf16Str`] is with the [`utf16str!`][crate::utf16str] macro to"r" convert string literals into string slices at compile time:"r" use widestring::utf16str;"r#" let hello = utf16str!("Hello, world!");"#r" You can also convert a [`u16`] slice directly, provided it is valid UTF-16:"r" use widestring::Utf16Str;"r" let sparkle_heart = Utf16Str::from_slice(&sparkle_heart).unwrap();"r#" assert_eq!("💖", sparkle_heart);"#r" Converts a slice to a string slice without checking that the string contains valid UTF-16."r" See the safe version, [`from_slice`][Self::from_slice], for more information."r" This function is unsafe because it does not check that the slice passed to it is valid"r" UTF-16. If this constraint is violated, undefined behavior results as it is assumed the"r" [`Utf16Str`] is always valid UTF-16."r" let sparkle_heart = vec![0xd83d, 0xdc96]; // Raw surrogate pair"r" let sparkle_heart = unsafe { Utf16Str::from_slice_unchecked(&sparkle_heart) };"r" Converts a mutable slice to a mutable string slice without checking that the string contains"r" valid UTF-16."r" See the safe version, [`from_slice_mut`][Self::from_slice_mut], for more information."r" let mut sparkle_heart = vec![0xd83d, 0xdc96]; // Raw surrogate pair"r" let sparkle_heart = unsafe { Utf16Str::from_slice_unchecked_mut(&mut sparkle_heart) };"r" Converts a boxed slice to a boxed string slice without checking that the string contains"r" This function is unsafe because it does not check if the string slice is valid UTF-16, and"r" [`Utf16Str`] must always be valid UTF-16."from_boxed_slice_uncheckedr" Returns an unchecked subslice of this string slice."r" This is the unchecked alternative to indexing the string slice."r" - Indexes must be within bounds of the original slice;"r" - Indexes must lie on UTF-16 sequence boundaries."r" Failing that, the returned string slice may reference invalid memory or violate the"r" invariants communicated by the type."r" # use widestring::{utf16str};"r#" let v = utf16str!("⚧️🏳️‍⚧️➡️s");"#r#"     assert_eq!(utf16str!("⚧️"), v.get_unchecked(..2));"#r#"     assert_eq!(utf16str!("🏳️‍⚧️"), v.get_unchecked(2..8));"#r#"     assert_eq!(utf16str!("➡️"), v.get_unchecked(8..10));"#r#"     assert_eq!(utf16str!("s"), v.get_unchecked(10..));"#r" Returns a mutable, unchecked subslice of this string slice"r#" let mut v = utf16str!("⚧️🏳️‍⚧️➡️s").to_owned();"#r#"     assert_eq!(utf16str!("⚧️"), v.get_unchecked_mut(..2));"#r#"     assert_eq!(utf16str!("🏳️‍⚧️"), v.get_unchecked_mut(2..8));"#r#"     assert_eq!(utf16str!("➡️"), v.get_unchecked_mut(8..10));"#r#"     assert_eq!(utf16str!("s"), v.get_unchecked_mut(10..));"#r" Returns the length of `self`."r" This length is in `u16` values, not [`char`]s or graphemes. In other words, it may not be"r" what human considers the length of the string."r" # use widestring::utf16str;"r#" assert_eq!(utf16str!("foo").len(), 3);"#r#" let complex = utf16str!("⚧️🏳️‍⚧️➡️s");"#r" assert_eq!(complex.len(), 11);"r" assert_eq!(complex.chars().count(), 10);"r" Returns `true` if the string has a length of zero."r" Converts a string to a slice of its underlying elements."r" To convert the slice back into a string slice, use the"r" [`from_slice`][Self::from_slice] function."r" Converts a mutable string to a mutable slice of its underlying elements."r" This function is unsafe because you can violate the invariants of this type when"r" mutating the slice. The caller must ensure that the contents of the slice is valid"r" UTF before the borrow ends and the underlying string is used."r" Use of this string type whose contents have been mutated to invalid UTF is"r" undefined behavior."r" Converts a string slice to a raw pointer."r" This pointer will be pointing to the first element of the string slice."r" The caller must ensure that the returned pointer is never written to. If you need to"r" mutate the contents of the string slice, use [`as_mut_ptr`][Self::as_mut_ptr]."r" Converts a mutable string slice to a mutable pointer."r" Returns this string as a wide string slice of undefined encoding."r" Returns a string slice with leading and trailing whitespace removed."r" 'Whitespace' is defined according to the terms of the Unicode Derived Core Property"r" `White_Space`."r" Returns a string slice with leading whitespace removed."r" # Text directionality"r" A string is a sequence of elements. `start` in this context means the first position"r" of that sequence; for a left-to-right language like English or Russian, this will be"r" left side, and for right-to-left languages like Arabic or Hebrew, this will be the"r" right side."r" Returns a string slice with trailing whitespace removed."r" A string is a sequence of elements. `end` in this context means the last position of"r" that sequence; for a left-to-right language like English or Russian, this will be"r" right side, and for right-to-left languages like Arabic or Hebrew, this will be the"r" left side."r" Converts a boxed string into a boxed slice without copying or allocating."r" Converts a boxed string slice into an owned UTF string without copying or"into_utfstringr" UTF-32 string slice for [`Utf32String`][crate::Utf32String]."r" [`Utf32Str`] is to [`Utf32String`][crate::Utf32String] as [`str`] is to [`String`]."r" [`Utf32Str`] slices are string slices that are always valid UTF-32 encoding. This is unlike"r" the [`U32Str`][crate::U16Str] string slices, which may not have valid encoding. In this way,"r" [`Utf32Str`] string slices most resemble native [`str`] slices of all the types in this"r" The easiest way to use [`Utf32Str`] is with the [`utf32str!`][crate::utf32str] macro to"r" use widestring::utf32str;"r#" let hello = utf32str!("Hello, world!");"#r" You can also convert a [`u32`] slice directly, provided it is valid UTF-32:"r" use widestring::Utf32Str;"r" let sparkle_heart = Utf32Str::from_slice(&sparkle_heart).unwrap();"r" Since [`char`] slices are valid UTF-32, a slice of [`char`]s can be easily converted to a"r" string slice:"r" let sparkle_heart = ['💖'; 3];"r" let sparkle_heart = Utf32Str::from_char_slice(&sparkle_heart);"r#" assert_eq!("💖💖💖", sparkle_heart);"#r" Converts a slice to a string slice without checking that the string contains valid UTF-32."r" UTF-32. If this constraint is violated, undefined behavior results as it is assumed the"r" [`Utf32Str`] is always valid UTF-32."r" let sparkle_heart = unsafe { Utf32Str::from_slice_unchecked(&sparkle_heart) };"r" valid UTF-32."r" let mut sparkle_heart = vec![0x1f496];"r" let sparkle_heart = unsafe { Utf32Str::from_slice_unchecked_mut(&mut sparkle_heart) };"r" This function is unsafe because it does not check if the string slice is valid UTF-32, and"r" [`Utf32Str`] must always be valid UTF-32."r" # use widestring::utf32str;"r#" let v = utf32str!("⚧️🏳️‍⚧️➡️s");"#r#"     assert_eq!(utf32str!("⚧️"), v.get_unchecked(..2));"#r#"     assert_eq!(utf32str!("🏳️‍⚧️"), v.get_unchecked(2..7));"#r#"     assert_eq!(utf32str!("➡️"), v.get_unchecked(7..9));"#r#"     assert_eq!(utf32str!("s"), v.get_unchecked(9..))"#r#" let mut v = utf32str!("⚧️🏳️‍⚧️➡️s").to_owned();"#r#"     assert_eq!(utf32str!("⚧️"), v.get_unchecked_mut(..2));"#r#"     assert_eq!(utf32str!("🏳️‍⚧️"), v.get_unchecked_mut(2..7));"#r#"     assert_eq!(utf32str!("➡️"), v.get_unchecked_mut(7..9));"#r#"     assert_eq!(utf32str!("s"), v.get_unchecked_mut(9..))"#r" This length is in the number of [`char`]s in the slice, not graphemes. In other words, it"r" may not be what human considers the length of the string."r#" assert_eq!(utf32str!("foo").len(), 3);"#r#" let complex = utf32str!("⚧️🏳️‍⚧️➡️s");"#r" assert_eq!(complex.len(), 10);"/// Converts a slice of UTF-16 data to a string slice./// Not all slices of [`u16`] values are valid to convert, since [`Utf16Str`] requires that it/// is always valid UTF-16. This function checks to ensure that the values are valid UTF-16, and/// then does the conversion./// If you are sure that the slice is valid UTF-16, and you don't want to incur the overhead of/// the validity check, there is an unsafe version of this function,/// [`from_slice_unchecked`][Self::from_slice_unchecked], which has the same behavior but skips/// the check./// If you need an owned string, consider using [`Utf16String::from_vec`] instead./// Because you can stack-allocate a `[u16; N]`, this function is one way to have a/// stack-allocated string. Indeed, the [`utf16str!`][crate::utf16str] macro does exactly this/// after converting from UTF-8 to UTF-16./// Returns an error if the slice is not UTF-16 with a description as to why the provided slice/// is not UTF-16./// use widestring::Utf16Str;/// let sparkle_heart = vec![0xd83d, 0xdc96]; // Raw surrogate pair/// let sparkle_heart = Utf16Str::from_slice(&sparkle_heart).unwrap();/// assert_eq!("💖", sparkle_heart);/// With incorrect values that return an error:/// let sparkle_heart = vec![0xd83d, 0x0]; // This is an invalid unpaired surrogate/// assert!(Utf16Str::from_slice(&sparkle_heart).is_err());/// Converts a mutable slice of UTF-16 data to a mutable string slice./// [`from_slice_unchecked_mut`][Self::from_slice_unchecked_mut], which has the same behavior/// but skips the check./// let mut sparkle_heart = vec![0xd83d, 0xdc96]; // Raw surrogate pair/// let sparkle_heart = Utf16Str::from_slice_mut(&mut sparkle_heart).unwrap();/// let mut sparkle_heart = vec![0xd83d, 0x0]; // This is an invalid unpaired surrogate/// assert!(Utf16Str::from_slice_mut(&mut sparkle_heart).is_err());/// Converts a wide string slice of undefined encoding to a UTF-16 string slice without checking/// if the string slice is valid UTF-16./// See the safe version, [`from_ustr`][Self::from_ustr], for more information./// This function is unsafe because it does not check that the string slice passed to it is/// valid UTF-16. If this constraint is violated, undefined behavior results as it is assumed/// the [`Utf16Str`] is always valid UTF-16./// use widestring::{Utf16Str, u16str};/// let sparkle_heart = u16str!("💖");/// let sparkle_heart = unsafe { Utf16Str::from_ustr_unchecked(sparkle_heart) };from_ustr_unchecked_mut/// Converts a mutable wide string slice of undefined encoding to a mutable UTF-16 string slice/// without checking if the string slice is valid UTF-16./// See the safe version, [`from_ustr_mut`][Self::from_ustr_mut], for more information./// Converts a wide string slice of undefined encoding to a UTF-16 string slice./// Since [`U16Str`] does not have a specified encoding, this conversion may fail if the/// [`U16Str`] does not contain valid UTF-16 data./// [`from_ustr_unchecked`][Self::from_ustr_unchecked], which has the same behavior/// Returns an error if the string slice is not UTF-16 with a description as to why the/// provided string slice is not UTF-16./// let sparkle_heart = Utf16Str::from_ustr(sparkle_heart).unwrap();from_ustr_mut/// Converts a mutable wide string slice of undefined encoding to a mutable UTF-16 string slice./// [`from_ustr_unchecked_mut`][Self::from_ustr_unchecked_mut], which has the same behaviorfrom_ucstr_unchecked/// Converts a wide C string slice to a UTF-16 string slice without checking if the/// string slice is valid UTF-16./// The resulting string slice does *not* contain the nul terminator./// See the safe version, [`from_ucstr`][Self::from_ucstr], for more information./// use widestring::{Utf16Str, u16cstr};/// let sparkle_heart = u16cstr!("💖");/// let sparkle_heart = unsafe { Utf16Str::from_ucstr_unchecked(sparkle_heart) };from_ucstr_unchecked_mut/// Converts a mutable wide C string slice to a mutable UTF-16 string slice without/// checking if the string slice is valid UTF-16./// See the safe version, [`from_ucstr_mut`][Self::from_ucstr_mut], for more information.from_ucstr/// Converts a wide C string slice to a UTF-16 string slice./// Since [`U16CStr`][crate::U16CStr] does not have a specified encoding, this conversion may/// fail if the [`U16CStr`][crate::U16CStr] does not contain valid UTF-16 data./// [`from_ucstr_unchecked`][Self::from_ucstr_unchecked], which has the same behavior/// let sparkle_heart = Utf16Str::from_ucstr(sparkle_heart).unwrap();from_ucstr_mut/// Converts a mutable wide C string slice to a mutable UTF-16 string slice./// [`from_ucstr_unchecked_mut`][Self::from_ucstr_unchecked_mut], which has the same behavior/// This method is unsafe because you can violate the invariants of [`U16CStr`][crate::U16CStr]/// when mutating the slice (i.e. by adding interior nul values)./// Converts to a standard UTF-8 [`String`]./// Because this string is always valid UTF-16, the conversion is lossless and non-fallible./// Checks that `index`-th value is the value in a UTF-16 code point sequence or the end of the/// Returns `true` if the value at `index` is not a UTF-16 surrogate value, or if the value at/// `index` is the first value of a surrogate pair (the "high" surrogate). Returns `false` if/// the value at `index` is the second value of a surrogate pair (a.k.a the "low" surrogate)./// The start and end of the string (when `index == self.len()`) are considered to be/// Returns `false` if `index is greater than `self.len()`./// # use widestring::utf16str;/// let s = utf16str!("Sparkle 💖 Heart");/// assert!(s.is_char_boundary(0));/// // high surrogate of `💖`/// assert!(s.is_char_boundary(8));/// // low surrogate of `💖`/// assert!(!s.is_char_boundary(9));/// assert!(s.is_char_boundary(s.len()));/// Returns a subslice of this string./// This is the non-panicking alternative to indexing the string. Returns [`None`] whenever/// equivalent indexing operation would panic./// # use widestring::{utf16str};/// let v = utf16str!("⚧️🏳️‍⚧️➡️s");/// assert_eq!(Some(utf16str!("⚧️")), v.get(..2));/// assert_eq!(Some(utf16str!("🏳️‍⚧️")), v.get(2..8));/// assert_eq!(Some(utf16str!("➡️")), v.get(8..10));/// assert_eq!(Some(utf16str!("s")), v.get(10..));/// assert!(v.get(3..4).is_none());/// Returns a mutable subslice of this string./// let mut v = utf16str!("⚧️🏳️‍⚧️➡️s").to_owned();/// assert_eq!(utf16str!("⚧️"), v.get_mut(..2).unwrap());/// assert_eq!(utf16str!("🏳️‍⚧️"), v.get_mut(2..8).unwrap());/// assert_eq!(utf16str!("➡️"), v.get_mut(8..10).unwrap());/// assert_eq!(utf16str!("s"), v.get_mut(10..).unwrap());/// assert!(v.get_mut(3..4).is_none());/// Divide one string slice into two at an index./// The argument, `mid`, should be an offset from the start of the string. It must also be on/// the boundary of a UTF-16 code point./// The two slices returned go from the start of the string slice to `mid`, and from `mid` to/// the end of the string slice./// To get mutable string slices instead, see the [`split_at_mut`][Self::split_at_mut] method./// Panics if `mid` is not on a UTF-16 code point boundary, or if it is past the end of the last/// code point of the string slice./// let s = utf16str!("Per Martin-Löf");/// let (first, last) = s.split_at(3);/// assert_eq!("Per", first);/// assert_eq!(" Martin-Löf", last);/// Divide one mutable string slice into two at an index./// To get immutable string slices instead, see the [`split_at`][Self::split_at] method./// let mut s = utf16str!("Per Martin-Löf").to_owned();/// let (first, last) = s.split_at_mut(3);/// Returns an iterator over the [`char`]s of a string slice./// As this string slice consists of valid UTF-16, we can iterate through a string slice by/// [`char`]. This method returns such an iterator./// It's important to remember that [`char`] represents a Unicode Scalar Value, and might not/// match your idea of what a 'character' is. Iteration over grapheme clusters may be what you/// actually want. This functionality is not provided by this crate./// Returns an iterator over the [`char`]s of a string slice and their positions./// [`char`]. This method returns an iterator of both these [`char`]s as well as their offsets./// The iterator yields tuples. The position is first, the [`char`] is second.code_units/// An iterator over the [`u16`] code units of a string slice./// As a UTF-16 string slice consists of a sequence of [`u16`] code units, we can iterate/// through a string slice by each code unit. This method returns such an iterator./// Returns an iterator of bytes over the string encoded as UTF-8./// Returns an iterator of [`u32`] over the sting encoded as UTF-32.escape_debug/// Returns an iterator that escapes each [`char`] in `self` with [`char::escape_debug`].escape_default/// Returns an iterator that escapes each [`char`] in `self` with [`char::escape_default`]./// Returns an iterator that escapes each [`char`] in `self` with [`char::escape_unicode`].to_lowercase/// Returns the lowercase equivalent of this string slice, as a new [`Utf16String`]./// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property/// `Lowercase`./// Since some characters can expand into multiple characters when changing the case, this/// function returns a [`Utf16String`] instead of modifying the parameter in-place.to_uppercase/// Returns the uppercase equivalent of this string slice, as a new [`Utf16String`]./// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property/// `Uppercase`./// Converts a slice of UTF-32 data to a string slice./// Not all slices of [`u32`] values are valid to convert, since [`Utf32Str`] requires that it/// is always valid UTF-32. This function checks to ensure that the values are valid UTF-32, and/// If you are sure that the slice is valid UTF-32, and you don't want to incur the overhead of/// If you need an owned string, consider using [`Utf32String::from_vec`] instead./// Because you can stack-allocate a `[u32; N]`, this function is one way to have a/// stack-allocated string. Indeed, the [`utf32str!`][crate::utf32str] macro does exactly this/// after converting from UTF-8 to UTF-32./// Returns an error if the slice is not UTF-32 with a description as to why the provided slice/// is not UTF-32./// use widestring::Utf32Str;/// let sparkle_heart = vec![0x1f496];/// let sparkle_heart = Utf32Str::from_slice(&sparkle_heart).unwrap();/// let sparkle_heart = vec![0xd83d, 0xdc96]; // UTF-16 surrogates are invalid/// assert!(Utf32Str::from_slice(&sparkle_heart).is_err());/// Converts a mutable slice of UTF-32 data to a mutable string slice./// let mut sparkle_heart = vec![0x1f496];/// let sparkle_heart = Utf32Str::from_slice_mut(&mut sparkle_heart).unwrap();/// let mut sparkle_heart = vec![0xd83d, 0xdc96]; // UTF-16 surrogates are invalid/// assert!(Utf32Str::from_slice_mut(&mut sparkle_heart).is_err());/// Converts a wide string slice of undefined encoding to a UTF-32 string slice without checking/// if the string slice is valid UTF-32./// valid UTF-32. If this constraint is violated, undefined behavior results as it is assumed/// the [`Utf32Str`] is always valid UTF-32./// use widestring::{Utf32Str, u32str};/// let sparkle_heart = u32str!("💖");/// let sparkle_heart = unsafe { Utf32Str::from_ustr_unchecked(sparkle_heart) };/// Converts a mutable wide string slice of undefined encoding to a mutable UTF-32 string slice/// without checking if the string slice is valid UTF-32./// Converts a wide string slice of undefined encoding to a UTF-32 string slice./// Since [`U32Str`] does not have a specified encoding, this conversion may fail if the/// [`U32Str`] does not contain valid UTF-32 data./// Returns an error if the string slice is not UTF-32 with a description as to why the/// provided string slice is not UTF-32./// let sparkle_heart = Utf32Str::from_ustr(sparkle_heart).unwrap();/// Converts a mutable wide string slice of undefined encoding to a mutable UTF-32 string slice./// Converts a wide C string slice to a UTF-32 string slice without checking if the/// string slice is valid UTF-32./// use widestring::{Utf32Str, u32cstr};/// let sparkle_heart = u32cstr!("💖");/// let sparkle_heart = unsafe { Utf32Str::from_ucstr_unchecked(sparkle_heart) };/// Converts a mutable wide C string slice to a mutable UTF-32 string slice without/// checking if the string slice is valid UTF-32./// Converts a wide C string slice to a UTF-32 string slice./// Since [`U32CStr`][crate::U32CStr] does not have a specified encoding, this conversion may/// fail if the [`U32CStr`][crate::U32CStr] does not contain valid UTF-32 data./// let sparkle_heart = Utf32Str::from_ucstr(sparkle_heart).unwrap();/// Converts a mutable wide C string slice to a mutable UTF-32 string slice./// Converts a slice of [`char`]s to a string slice./// Since [`char`] slices are always valid UTF-32, this conversion always suceeds./// If you need an owned string, consider using [`Utf32String::from_chars`] instead./// let sparkle_heart = ['💖'];/// let sparkle_heart = Utf32Str::from_char_slice(&sparkle_heart);/// Converts a mutable slice of [`char`]s to a string slice./// let mut sparkle_heart = ['💖'];/// let sparkle_heart = Utf32Str::from_char_slice_mut(&mut sparkle_heart);as_char_slice/// Converts a string slice into a slice of [`char`]s.as_char_slice_mut/// Converts a mutable string slice into a mutable slice of [`char`]s./// Because this string is always valid UTF-32, the conversion is lossless and non-fallible./// # use widestring::{utf32str};/// let v = utf32str!("⚧️🏳️‍⚧️➡️s");/// assert_eq!(Some(utf32str!("⚧️")), v.get(..2));/// assert_eq!(Some(utf32str!("🏳️‍⚧️")), v.get(2..7));/// assert_eq!(Some(utf32str!("➡️")), v.get(7..9));/// assert_eq!(Some(utf32str!("s")), v.get(9..));/// let mut v = utf32str!("⚧️🏳️‍⚧️➡️s").to_owned();/// assert_eq!(utf32str!("⚧️"), v.get_mut(..2).unwrap());/// assert_eq!(utf32str!("🏳️‍⚧️"), v.get_mut(2..7).unwrap());/// assert_eq!(utf32str!("➡️"), v.get_mut(7..9).unwrap());/// assert_eq!(utf32str!("s"), v.get_mut(9..).unwrap());/// The argument, `mid`, should be an offset from the start of the string./// Panics if `mid` is past the end of the last code point of the string slice./// # use widestring::utf32str;/// let s = utf32str!("Per Martin-Löf");/// let mut s = utf32str!("Per Martin-Löf").to_owned();/// As this string slice consists of valid UTF-32, we can iterate through a string slice by/// Returns an iterator of [`u16`] over the sting encoded as UTF-16./// Returns the lowercase equivalent of this string slice, as a new [`Utf32String`]./// function returns a [`Utf32String`] instead of modifying the parameter in-place./// Returns the uppercase equivalent of this string slice, as a new [`Utf32String`]./// Alias for [`Utf16Str`] or [`Utf32Str`] depending on platform. Intended to match typical Cutf16_trimutf32_trim//! UTF string slices.//! This module contains UTF string slices and related types.DrainUtf16/// A draining iterator for [`Utf16String`]./// This struct is created by the [`drain`][Utf16String::drain] method on [`Utf16String`]. See itsDrainUtf32/// A draining iterator for [`Utf32String`]./// This struct is created by the [`drain`][Utf32String::drain] method on [`Utf32String`]. See itsutfstring_common_implr" A UTF-16 encoded, growable owned string."r" [`Utf16String`] is a version of [`String`] that uses UTF-16 encoding instead of UTF-8"r" encoding. The equivalent of [`str`] for [`Utf16String`] is [`Utf16Str`]."r" Unlike [`U16String`][crate::U16String] which does not specify a coding, [`Utf16String`] is"r" always valid UTF-16 encoding. Using unsafe methods to construct a [`Utf16String`] with"r" invalid UTF-16 encoding results in undefined behavior."r" # UTF-16"r" [`Utf16String`] is always UTF-16. This means if you need non-UTF-16 wide strings, you should"r" use [`U16String`][crate::U16String] instead. It is similar, but does not constrain the"r" encoding."r" This also means you cannot directly index a single element of the string, as UTF-16 encoding"r" may be a single `u16` value or a pair of `u16` surrogates. Instead, you can index subslices"r" of the string, or use the [`chars`][Utf16Str::chars] iterator instead."r" The easiest way to use [`Utf16String`] is with the [`utf16str!`][crate::utf16str] macro to"r" convert string literals into UTF-16 string slices at compile time:"r" use widestring::{Utf16String, utf16str};"r#" let hello = Utf16String::from(utf16str!("Hello, world!"));"#r" Because this string is always valid UTF-16, it is a non-fallible, lossless conversion to and"r" from standard Rust strings:"r" use widestring::Utf16String;"r" // Unlike the utf16str macro, this will do conversion at runtime instead of compile time"r#" let hello = Utf16String::from_str("Hello, world!");"#r" let hello_string: String = hello.to_string();"r" assert_eq!(hello, hello_string); // Can easily compare between string types"r" Creates a new empty string."r" Given that the string is empty, this will not allocate any initial buffer. While"r" that means this initial operation is very inexpensive, it may cause excessive"r" allocations later when you add data. If you have an idea of how much data the"r" string will hold, consider [`with_capacity`][Self::with_capacity] instead to"r" prevent excessive re-allocation."r" Creates a new empty string with a particular capacity."r" This string has an internal buffer to hold its data. The capacity is the length of"r" that buffer, and can be queried with the [`capacity`][Self::capacity] method. This"r" method creates and empty string, but one with an initial buffer that can hold"r" `capacity` elements. This is useful when you may be appending a bunch of data to"r" the string, reducing the number of reallocations it needs to do."r" If the given capacity is `0`, no allocation will occur, and this method is identical"r" to the [`new`][Self::new] method."r" Converts a [`u16`] vector to a string without checking that the string contains valid"r" UTF-16."r" See the safe version, [`from_vec`][Self::from_vec], for more information."r" This function is unsafe because it does not check that the vector passed to it is valid"r" [`Utf16String`] is always valid UTF-16."r" let sparkle_heart = unsafe { Utf16String::from_vec_unchecked(sparkle_heart) };"r" Re-encodes a UTF-8--encoded string slice into a UTF-16--encoded string."r" This operation is lossless and infallible, but requires a memory allocation."r#" let music = Utf16String::from_str("𝄞music");"#r#" assert_eq!(utf16str!("𝄞music"), music);"#r" Converts a string into a string slice."as_utfstrr" Converts a string into a mutable string slice."as_mut_utfstrr" Converts this string into a wide string of undefined encoding."r" Converts a string into a vector of its elements."r" This consumes the string without copying its contents."r" Appends a given string slice onto the end of this string."r#" let mut s = Utf16String::from_str("foo");"#r#" s.push_utfstr(utf16str!("bar"));"#r#" assert_eq!(utf16str!("foobar"), s);"#push_utfstrr" Returns this string's capacity, in number of elements."r" Ensures that this string's capacity is at least `additional` elements larger than"r" its length."r" The capacity may be increased by more than `additional` elements if it chooses, to"r" prevent frequent reallocations."r#" If you do not want this "at least" behavior, see the"#r" [`reserve_exact`][Self::reserve_exact] method."r" Panics if the new capacity overflows [`usize`]."r" Ensures that this string's capacity is `additional` elements larger than its length."r" Consider using the [`reserve`][Self::reserve] method unless you absolutely know"r" better than the allocator."r" Shrinks the capacity of this string to match its length."r" Returns a slice of this string's contents."insert_slicer" This function is unsafe because it does not check that the values in the vector are valid"r" UTF-16. If this constraint is violated, it may cause undefined beahvior with future"r" users of the string, as it is assumed that this string is always valid UTF-16."r" Returns the length of this string in number of elements, not [`char`]s or"r" graphemes."r" In other words, it might not be what a human considers the length of the string."r" Returns `true` if this string has a length of zero, and `false` otherwise."r" Truncates the string, removing all contents."r" While this means the string will have a length of zero, it does not touch its"r" capacity."r" Converts this string into a boxed string slice."r" This will drop excess capacity."into_boxed_utfstrr" Appends a given UTF-8 string slice onto the end of this string, converting it to"r" A UTF-32 encoded, growable owned string."r" [`Utf32String`] is a version of [`String`] that uses UTF-32 encoding instead of UTF-8"r" encoding. The equivalent of [`str`] for [`Utf32String`] is [`Utf32Str`]."r" Unlike [`U32String`][crate::U32String] which does not specify a coding, [`Utf32String`] is"r" always valid UTF-32 encoding. Using unsafe methods to construct a [`Utf32String`] with"r" invalid UTF-32 encoding results in undefined behavior."r" # UTF-32"r" [`Utf32String`] is always UTF-32. This means if you need non-UTF-32 wide strings, you should"r" use [`U32String`][crate::U32String] instead. It is similar, but does not constrain the"r" Unlike UTF-16 or UTF-8 strings, you may index single elements of UTF-32 strings in addition"r" to subslicing. This is due to it being a fixed-length encoding for [`char`]s. This also"r" means that [`Utf32String`] is the same representation as a `Vec<char>`; indeed conversions"r" between the two exist and are simple typecasts."r" The easiest way to use [`Utf32String`] is with the [`utf32str!`][crate::utf32str] macro to"r" convert string literals into UTF-32 string slices at compile time:"r" use widestring::{Utf32String, utf32str};"r#" let hello = Utf32String::from(utf32str!("Hello, world!"));"#r" Because this string is always valid UTF-32, it is a non-fallible, lossless conversion to and"r" use widestring::Utf32String;"r" // Unlike the utf32str macro, this will do conversion at runtime instead of compile time"r#" let hello = Utf32String::from_str("Hello, world!");"#r" Converts a [`u32`] vector to a string without checking that the string contains valid"r" UTF-32."r" [`Utf32String`] is always valid UTF-32."r" let sparkle_heart = unsafe { Utf32String::from_vec_unchecked(sparkle_heart) };"r" Re-encodes a UTF-8--encoded string slice into a UTF-32--encoded string."r#" let music = Utf32String::from_str("𝄞music");"#r#" assert_eq!(utf32str!("𝄞music"), music);"#r#" let mut s = Utf32String::from_str("foo");"#r#" s.push_utfstr(utf32str!("bar"));"#r#" assert_eq!(utf32str!("foobar"), s);"#/// Converts a [`u16`] vector of UTF-16 data to a string./// Not all slices of [`u16`] values are valid to convert, since [`Utf16String`] requires that/// it is always valid UTF-16. This function checks to ensure that the values are valid UTF-16,/// and then does the conversion. This does not do any copying./// [`from_vec_unchecked`][Self::from_vec_unchecked], which has the same behavior but skips/// If you need a string slice, consider using [`Utf16Str::from_slice`] instead./// The inverse of this method is [`into_vec`][Self::into_vec]./// Returns an error if the vector is not UTF-16 with a description as to why the provided/// vector is not UTF-16. The error will contain the original [`Vec`] that can be reclaimed with/// [`into_vec`][Utf16Error::into_vec]./// use widestring::Utf16String;/// let sparkle_heart = Utf16String::from_vec(sparkle_heart).unwrap();/// assert!(Utf16String::from_vec(sparkle_heart).is_err());from_slice_lossy/// Converts a slice of [`u16`] data to a string, including invalid characters./// Since the given [`u16`] slice may not be valid UTF-16, and [`Utf16String`] requires that/// it is always valid UTF-16, during the conversion this function replaces any invalid UTF-16/// sequences with [`U+FFFD REPLACEMENT CHARACTER`][core::char::REPLACEMENT_CHARACTER], which/// looks like this: �/// the conversion, there is an unsafe version of this function,/// the checks./// This function returns a [`Cow<'_, Utf16Str>`][std::borrow::Cow]. If the given slice is/// invalid UTF-16, then we need to insert our replacement characters which will change the size/// of the string, and hence, require an owned [`Utf16String`]. But if it's already valid/// UTF-16, we don't need a new allocation. This return type allows us to handle both cases./// let sparkle_heart = Utf16String::from_slice_lossy(&sparkle_heart);/// assert_eq!(utf16str!("💖"), sparkle_heart);/// assert_eq!(utf16str!("\u{fffd}\u{0000}"), sparkle_heart);from_ustring_unchecked/// Converts a wide string of undefined encoding to a UTF-16 string without checking that the/// string contains valid UTF-16./// See the safe version, [`from_ustring`][Self::from_ustring], for more information./// This function is unsafe because it does not check that the string passed to it is valid/// UTF-16. If this constraint is violated, undefined behavior results as it is assumed the/// [`Utf16String`] is always valid UTF-16./// use widestring::{U16String, Utf16String};/// let sparkle_heart = U16String::from_vec(sparkle_heart);/// let sparkle_heart = unsafe { Utf16String::from_ustring_unchecked(sparkle_heart) };from_ustring/// Converts a wide string of undefined encoding into a UTF-16 string./// Not all strings with undefined encoding are valid to convert, since [`Utf16String`] requires/// that it is always valid UTF-16. This function checks to ensure that the string is valid/// UTF-16, and then does the conversion. This does not do any copying./// If you are sure that the string is valid UTF-16, and you don't want to incur the overhead of/// [`from_ustring_unchecked`][Self::from_ustring_unchecked], which has the same behavior but/// skips the check./// If you need a string slice, consider using [`Utf16Str::from_ustr`] instead./// Returns an error if the string is not UTF-16 with a description as to why the provided/// string is not UTF-16./// let sparkle_heart = Utf16String::from_ustring(sparkle_heart).unwrap();/// let sparkle_heart = U16String::from_vec(sparkle_heart); // Valid for a U16String/// assert!(Utf16String::from_ustring(sparkle_heart).is_err()); // But not for a Utf16Stringfrom_ustr_lossy/// Converts a wide string slice of undefined encoding of to a UTF-16 string, including invalid/// Since the given string slice may not be valid UTF-16, and [`Utf16String`] requires that/// skips the checks./// use widestring::{U16Str, Utf16String};/// let sparkle_heart = U16Str::from_slice(&sparkle_heart);/// let sparkle_heart = Utf16String::from_ustr_lossy(sparkle_heart);from_ucstring_unchecked/// Converts a wide C string to a UTF-16 string without checking that the string contains/// valid UTF-16./// The resulting string does *not* contain the nul terminator./// See the safe version, [`from_ucstring`][Self::from_ucstring], for more information./// use widestring::{U16CString, Utf16String};/// let sparkle_heart = U16CString::from_vec(sparkle_heart).unwrap();/// let sparkle_heart = unsafe { Utf16String::from_ucstring_unchecked(sparkle_heart) };from_ucstring/// Converts a wide C string into a UTF-16 string./// Not all wide C strings are valid to convert, since [`Utf16String`] requires that/// it is always valid UTF-16. This function checks to ensure that the string is valid UTF-16,/// [`from_ucstring_unchecked`][Self::from_ucstring_unchecked], which has the same behavior but/// If you need a string slice, consider using [`Utf16Str::from_ucstr`] instead./// let sparkle_heart = Utf16String::from_ucstring(sparkle_heart).unwrap();/// let sparkle_heart = vec![0xd83d]; // This is an invalid unpaired surrogate/// let sparkle_heart = U16CString::from_vec(sparkle_heart).unwrap(); // Valid for a U16CString/// assert!(Utf16String::from_ucstring(sparkle_heart).is_err()); // But not for a Utf16Stringfrom_ucstr_lossy/// Converts a wide C string slice of to a UTF-16 string, including invalid characters./// use widestring::{U16CStr, Utf16String};/// let sparkle_heart = vec![0xd83d, 0xdc96, 0x0]; // Raw surrogate pair/// let sparkle_heart = U16CStr::from_slice(&sparkle_heart).unwrap();/// let sparkle_heart = Utf16String::from_ucstr_lossy(sparkle_heart);/// assert_eq!(utf16str!("\u{fffd}"), sparkle_heart);/// let mut s = Utf16String::from_str("abc");/// s.push('1');/// s.push('2');/// s.push('3');/// assert_eq!("abc123", s);/// If `new_len` is greater than the string's current length, this has no effect./// Panics if `new_len` does not lie on a [`char`] boundary./// let mut s = Utf16String::from_str("hello");/// s.truncate(2);/// assert_eq!("he", s);/// let mut s = Utf16String::from_str("foo𝄞");/// assert_eq!(s.pop(), Some('𝄞'));/// Removes a [`char`] from this string at an offset and returns it./// Panics if `idx` is larger than or equal to the string's length, or if it does not lie on a/// let mut s = Utf16String::from_str("𝄞foo");/// assert_eq!(s.remove(0), '𝄞');/// In other words, remove all characters `c` such that `f(c)` returns `false`. This method/// operates in place, visiting each character exactly once in the original order, and preserves/// the order of the retained characters./// let mut s = Utf16String::from_str("f_o_ob_ar");/// s.retain(|c| c != '_');/// assert_eq!(s, "foobar");/// Because the elements are visited exactly once in the original order, external state may be/// used to decide which elements to keep./// let mut s = Utf16String::from_str("abcde");/// let keep = [false, true, true, false, true];/// let mut iter = keep.iter();/// s.retain(|_| *iter.next().unwrap());/// assert_eq!(s, "bce");/// Inserts a character into this string at an offset./// Panics if `idx` is larger than the string's length, or if it does not lie on a [`char`]/// let mut s = Utf16String::with_capacity(5);/// s.insert(0, '𝄞');/// s.insert(0, 'f');/// s.insert(1, 'o');/// s.insert(4, 'o');/// assert_eq!("fo𝄞o", s);insert_utfstr/// Inserts a UTF-16 string slice into this string at an offset./// let mut s = Utf16String::from_str("bar");/// s.insert_utfstr(0, utf16str!("foo"));/// assert_eq!("foobar", s);/// Returns a newly allocated string. `self` contains elements [0, at), and the returned string/// contains elements [at, len). `at` must be on the boundary of a UTF-16 code point./// Panics if `at` is not on a UTF-16 code point boundary, or if it is beyond the last code/// point of the string./// let mut hello = Utf16String::from_str("Hello, World!");/// let world = hello.split_off(7);/// assert_eq!(hello, "Hello, ");/// assert_eq!(world, "World!");/// Creates a draining iterator that removes the specified range in the string and yields the/// removed [`char`]s./// Note: The element range is removed even if the iterator is not consumed until the end./// Panics if the starting point or end point do not lie on a [`char`] boundary, or if they're/// out of bounds./// let mut s = Utf16String::from_str("α is alpha, β is beta");/// let beta_offset = 12;/// // Remove the range up until the β from the string/// let t: Utf16String = s.drain(..beta_offset).collect();/// assert_eq!(t, "α is alpha, ");/// assert_eq!(s, "β is beta");/// // A full range clears the string/// s.drain(..);/// assert_eq!(s, "");/// Removes the specified range in the string, and replaces it with the given string./// The given string doesn't need to be the same length as the range./// use widestring::{utf16str, Utf16String};/// // Replace the range up until the β from the string/// s.replace_range(..beta_offset, utf16str!("Α is capital alpha; "));/// assert_eq!(s, "Α is capital alpha; β is beta");/// Converts a [`u32`] vector of UTF-32 data to a string./// Not all slices of [`u32`] values are valid to convert, since [`Utf32String`] requires that/// it is always valid UTF-32. This function checks to ensure that the values are valid UTF-32,/// If you need a string slice, consider using [`Utf32Str::from_slice`] instead./// Returns an error if the vector is not UTF-32 with a description as to why the provided/// vector is not UTF-32. The error will contain the original [`Vec`] that can be reclaimed with/// [`into_vec`][Utf32Error::into_vec]./// use widestring::Utf32String;/// let sparkle_heart = Utf32String::from_vec(sparkle_heart).unwrap();/// assert!(Utf32String::from_vec(sparkle_heart).is_err());/// Converts a slice of [`u32`] data to a string, including invalid characters./// Since the given [`u32`] slice may not be valid UTF-32, and [`Utf32String`] requires that/// it is always valid UTF-32, during the conversion this function replaces any invalid UTF-32/// This function returns a [`Cow<'_, Utf32Str>`][std::borrow::Cow]. If the given slice is/// invalid UTF-32, then we need to insert our replacement characters which will change the size/// of the string, and hence, require an owned [`Utf32String`]. But if it's already valid/// UTF-32, we don't need a new allocation. This return type allows us to handle both cases./// let sparkle_heart = Utf32String::from_slice_lossy(&sparkle_heart);/// assert_eq!(utf32str!("💖"), sparkle_heart);/// assert_eq!(utf32str!("\u{fffd}\u{fffd}"), sparkle_heart);/// Converts a wide string of undefined encoding to a UTF-32 string without checking that the/// string contains valid UTF-32./// UTF-32. If this constraint is violated, undefined behavior results as it is assumed the/// [`Utf32String`] is always valid UTF-32./// use widestring::{U32String, Utf32String};/// let sparkle_heart = U32String::from_vec(sparkle_heart);/// let sparkle_heart = unsafe { Utf32String::from_ustring_unchecked(sparkle_heart) };/// Converts a wide string of undefined encoding string into a UTF-32 string./// Not all strings of undefined encoding are valid to convert, since [`Utf32String`] requires/// that it is always valid UTF-32. This function checks to ensure that the string is valid/// UTF-32, and then does the conversion. This does not do any copying./// If you are sure that the string is valid UTF-32, and you don't want to incur the overhead of/// If you need a string slice, consider using [`Utf32Str::from_ustr`] instead./// Returns an error if the string is not UTF-32 with a description as to why the provided/// string is not UTF-32./// let sparkle_heart = Utf32String::from_ustring(sparkle_heart).unwrap();/// let sparkle_heart = U32String::from_vec(sparkle_heart); // Valid for a U32String/// assert!(Utf32String::from_ustring(sparkle_heart).is_err()); // But not for a Utf32String/// Converts a wide string slice of undefined encoding to a UTF-32 string, including invalid/// Since the given string slice may not be valid UTF-32, and [`Utf32String`] requires that/// use widestring::{U32Str, Utf32String};/// let sparkle_heart = U32Str::from_slice(&sparkle_heart);/// let sparkle_heart = Utf32String::from_ustr_lossy(sparkle_heart);/// Converts a wide C string to a UTF-32 string without checking that the string contains/// use widestring::{U32CString, Utf32String};/// let sparkle_heart = U32CString::from_vec(sparkle_heart).unwrap();/// let sparkle_heart = unsafe { Utf32String::from_ucstring_unchecked(sparkle_heart) };/// Converts a wide C string into a UTF-32 string./// Not all wide C strings are valid to convert, since [`Utf32String`] requires that/// it is always valid UTF-32. This function checks to ensure that the string is valid UTF-32,/// If you need a string slice, consider using [`Utf32Str::from_ucstr`] instead./// let sparkle_heart = Utf32String::from_ucstring(sparkle_heart).unwrap();/// let sparkle_heart = U32CString::from_vec(sparkle_heart).unwrap(); // Valid for a U32CString/// assert!(Utf32String::from_ucstring(sparkle_heart).is_err()); // But not for a Utf32String/// Converts a wide C string slice of to a UTF-32 string, including invalid characters./// use widestring::{U32CStr, Utf32String};/// let sparkle_heart = vec![0x1f496, 0x0];/// let sparkle_heart = U32CStr::from_slice(&sparkle_heart).unwrap();/// let sparkle_heart = Utf32String::from_ucstr_lossy(sparkle_heart);/// let sparkle_heart = vec![0xd83d, 0xdc96, 0x0]; // UTF-16 surrogates are invalid/// Converts a vector of [`char`]s into a UTF-32 string./// Since [`char`]s are always valid UTF-32, this is infallible and efficient./// If you need a string slice, consider using [`Utf32Str::from_char_slice`] instead./// let sparkle_heart = vec!['💖'];/// let sparkle_heart = Utf32String::from_chars(sparkle_heart);/// let mut s = Utf32String::from_str("abc");/// let mut s = Utf32String::from_str("hello");/// let mut s = Utf32String::from_str("foo");/// let mut s = Utf32String::from_str("f_o_ob_ar");/// let mut s = Utf32String::from_str("abcde");/// let mut s = Utf32String::with_capacity(3);/// assert_eq!("foo", s);/// Inserts a UTF-32 string slice into this string at an offset./// let mut s = Utf32String::from_str("bar");/// s.insert_utfstr(0, utf32str!("foo"));/// contains elements [at, len)./// Panics if `at`it is beyond the last code point of the string./// let mut hello = Utf32String::from_str("Hello, World!");/// Panics if the starting point or end point are out of bounds./// let mut s = Utf32String::from_str("α is alpha, β is beta");/// let t: Utf32String = s.drain(..beta_offset).collect();/// use widestring::{utf32str, Utf32String};/// s.replace_range(..beta_offset, utf32str!("Α is capital alpha; "));into_char_vec/// Converts string into a [`Vec`] of [`char`]s./// This consumes the string without copying its contents./// Alias for [`Utf16String`] or [`Utf32String`] depending on platform. Intended to match typical C//! Owned, growable UTF strings.//! This module contains UTF strings and related types.// <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.// (header name, &[header dependencies], &[library dependencies])includedidentify_requiredcheck_everythingresolve_dependenciesemit_featuresemit_librarieslibrary_prefixlibrary_kindtry_everythingd3dukmdtD3DDDICB_SIGNALFLAGSD3DDDI_ALLOCATIONLISTD3DDDI_CREATECONTEXTFLAGSD3DDDI_MAX_BROADCAST_CONTEXTD3DDDI_MAX_OBJECT_SIGNALEDD3DDDI_MAX_OBJECT_WAITED_OND3DDDI_PATCHLOCATIONLISTD3DDDI_SYNCHRONIZATIONOBJECTINFOD3DDDI_SYNCHRONIZATIONOBJECTINFO2D3DDDI_VIDEO_PRESENT_SOURCE_IDD3DGPU_VIRTUAL_ADDRESSD3DKMT_HANDLEUCHARSTRUCTBITFIELDUNION//1512//1617//1852DXGK_MAX_GPUVERSION_NAME_LENGTHMAX_ENUM_ADAPTERS//! longhorn display driver model kernel mode thunk interfacesd3dkmthk//! Headers for kernel modeDECLARE_HANDLEMAKE_HRESULTMAKE_SCODEHIDP_ERROR_CODESMAKEFOURCCDEFINE_BLUETOOTH_UUID128DEFINE_PROPERTYKEYDEFINE_DEVPROPKEYCTL_CODEBTH_CTLBTH_KERNEL_CTLHID_CTL_CODEHID_BUFFER_CTL_CODEHID_IN_CTL_CODEHID_OUT_CTL_CODEAUDCLNT_ERRAUDCLNT_SUCCESSBCRYPT_MAKE_INTERFACE_VERSIONMAKEINTRESOURCEIFDEF_WSAIO_WSAIOR_WSAIOW_WSAIORW//! Macros to make things easier to define__int64__uint64POINTER_64_INTPINT8PINT16PINT32PINT64PUINT8PUINT16PUINT32PUINT64LONG32PLONG32ULONG32PULONG32DWORD32PDWORD32INT_PTRPINT_PTRPUINT_PTRLONG_PTRPLONG_PTRPULONG_PTRSHANDLE_PTRHANDLE_PTRUHALF_PTRPUHALF_PTRHALF_PTRPHALF_PTRPSIZE_TSSIZE_TPSSIZE_TPDWORD_PTRLONG64PLONG64PULONG64KAFFINITYPKAFFINITY//! Type definitions for the basic sized types.PUCHARUSHORTPNTSTATUSBCRYPT_SUCCESSBCRYPT_OBJECT_ALIGNMENTBCRYPT_KDF_HASHBCRYPT_KDF_HMACBCRYPT_KDF_TLS_PRFBCRYPT_KDF_SP80056A_CONCATBCRYPT_KDF_RAW_SECRETKDF_HASH_ALGORITHMKDF_SECRET_PREPENDKDF_SECRET_APPENDKDF_HMAC_KEYKDF_TLS_PRF_LABELKDF_TLS_PRF_SEEDKDF_SECRET_HANDLEKDF_TLS_PRF_PROTOCOLKDF_ALGORITHMIDKDF_PARTYUINFOKDF_PARTYVINFOKDF_SUPPPUBINFOKDF_SUPPPRIVINFOKDF_LABELKDF_CONTEXTKDF_SALTKDF_ITERATION_COUNTKDF_GENERIC_PARAMETERKDF_KEYBITLENGTHKDF_USE_SECRET_AS_HMAC_KEY_FLAGBCRYPT_AUTH_TAG_LENGTHS_STRUCTBCRYPT_KEY_LENGTHS_STRUCTBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSIONBCRYPT_AUTH_MODE_CHAIN_CALLS_FLAGBCRYPT_AUTH_MODE_IN_PROGRESS_FLAGPBCRYPT_AUTHENTICATED_CIPHER_MODE_INFOBCRYPT_AUTHENTICATED_CIPHER_MODE_INFOBCRYPT_OPAQUE_KEY_BLOBBCRYPT_KEY_DATA_BLOBBCRYPT_AES_WRAP_KEY_BLOBBCRYPT_OBJECT_LENGTHBCRYPT_ALGORITHM_NAMEBCRYPT_PROVIDER_HANDLEBCRYPT_CHAINING_MODEBCRYPT_BLOCK_LENGTHBCRYPT_KEY_LENGTHBCRYPT_KEY_OBJECT_LENGTHBCRYPT_KEY_STRENGTHBCRYPT_KEY_LENGTHSBCRYPT_BLOCK_SIZE_LISTBCRYPT_EFFECTIVE_KEY_LENGTHBCRYPT_HASH_LENGTHBCRYPT_HASH_OID_LISTBCRYPT_PADDING_SCHEMESBCRYPT_SIGNATURE_LENGTHBCRYPT_HASH_BLOCK_LENGTHBCRYPT_AUTH_TAG_LENGTHBCRYPT_PRIMITIVE_TYPEBCRYPT_IS_KEYED_HASHBCRYPT_IS_REUSABLE_HASHBCRYPT_MESSAGE_BLOCK_LENGTHBCRYPT_PUBLIC_KEY_LENGTHBCRYPT_PCP_PLATFORM_TYPE_PROPERTYBCRYPT_PCP_PROVIDER_VERSION_PROPERTYBCRYPT_MULTI_OBJECT_LENGTHBCRYPT_INITIALIZATION_VECTORBCRYPT_CHAIN_MODE_NABCRYPT_CHAIN_MODE_CBCBCRYPT_CHAIN_MODE_ECBBCRYPT_CHAIN_MODE_CFBBCRYPT_CHAIN_MODE_CCMBCRYPT_CHAIN_MODE_GCMBCRYPT_PROV_DISPATCHBCRYPT_BLOCK_PADDINGBCRYPT_PAD_NONEBCRYPT_PAD_PKCS1BCRYPT_PAD_OAEPBCRYPT_PAD_PSSBCRYPT_PAD_PKCS1_OPTIONAL_HASH_OIDBCRYPTBUFFER_VERSIONPBCryptBufferBCryptBufferPBCryptBufferDescBCryptBufferDescBCRYPT_HANDLEBCRYPT_ALG_HANDLEBCRYPT_KEY_HANDLEBCRYPT_HASH_HANDLEBCRYPT_SECRET_HANDLEBCRYPT_PUBLIC_KEY_BLOBBCRYPT_PRIVATE_KEY_BLOBBCRYPT_RSAPUBLIC_BLOBBCRYPT_RSAPRIVATE_BLOBLEGACY_RSAPUBLIC_BLOBLEGACY_RSAPRIVATE_BLOBBCRYPT_RSAPUBLIC_MAGICBCRYPT_RSAPRIVATE_MAGICBCRYPT_RSAFULLPRIVATE_BLOBBCRYPT_RSAFULLPRIVATE_MAGICBCRYPT_GLOBAL_PARAMETERSBCRYPT_PRIVATE_KEYBCRYPT_ECCPUBLIC_BLOBBCRYPT_ECCPRIVATE_BLOBBCRYPT_ECCFULLPUBLIC_BLOBBCRYPT_ECCFULLPRIVATE_BLOBSSL_ECCPUBLIC_BLOBBCRYPT_ECDH_PUBLIC_P256_MAGICBCRYPT_ECDH_PRIVATE_P256_MAGICBCRYPT_ECDH_PUBLIC_P384_MAGICBCRYPT_ECDH_PRIVATE_P384_MAGICBCRYPT_ECDH_PUBLIC_P521_MAGICBCRYPT_ECDH_PRIVATE_P521_MAGICBCRYPT_ECDH_PUBLIC_GENERIC_MAGICBCRYPT_ECDH_PRIVATE_GENERIC_MAGICBCRYPT_ECDSA_PUBLIC_P256_MAGICBCRYPT_ECDSA_PRIVATE_P256_MAGICBCRYPT_ECDSA_PUBLIC_P384_MAGICBCRYPT_ECDSA_PRIVATE_P384_MAGICBCRYPT_ECDSA_PUBLIC_P521_MAGICBCRYPT_ECDSA_PRIVATE_P521_MAGICBCRYPT_ECDSA_PUBLIC_GENERIC_MAGICBCRYPT_ECDSA_PRIVATE_GENERIC_MAGICPBCRYPT_ECCKEY_BLOBBCRYPT_ECCKEY_BLOBPSSL_ECCKEY_BLOBSSL_ECCKEY_BLOBBCRYPT_ECC_FULLKEY_BLOB_V1PBCRYPT_ECCFULLKEY_BLOBBCRYPT_ECCFULLKEY_BLOBBCRYPT_DH_PUBLIC_BLOBBCRYPT_DH_PRIVATE_BLOBLEGACY_DH_PUBLIC_BLOBLEGACY_DH_PRIVATE_BLOBBCRYPT_DH_PUBLIC_MAGICBCRYPT_DH_PRIVATE_MAGICPBCRYPT_DH_KEY_BLOBBCRYPT_DH_KEY_BLOBBCRYPT_DH_PARAMETERSBCRYPT_DH_PARAMETERS_MAGICBCRYPT_DSA_PUBLIC_BLOBBCRYPT_DSA_PRIVATE_BLOBLEGACY_DSA_PUBLIC_BLOBLEGACY_DSA_PRIVATE_BLOBLEGACY_DSA_V2_PUBLIC_BLOBLEGACY_DSA_V2_PRIVATE_BLOBBCRYPT_DSA_PUBLIC_MAGICBCRYPT_DSA_PRIVATE_MAGICBCRYPT_DSA_PUBLIC_MAGIC_V2BCRYPT_DSA_PRIVATE_MAGIC_V2PBCRYPT_DSA_KEY_BLOBBCRYPT_DSA_KEY_BLOBPBCRYPT_DSA_KEY_BLOB_V2BCRYPT_DSA_KEY_BLOB_V2PBCRYPT_KEY_DATA_BLOB_HEADERBCRYPT_KEY_DATA_BLOB_HEADERBCRYPT_KEY_DATA_BLOB_MAGICBCRYPT_KEY_DATA_BLOB_VERSION1BCRYPT_DSA_PARAMETERSBCRYPT_DSA_PARAMETERS_MAGICBCRYPT_DSA_PARAMETERS_MAGIC_V2BCRYPT_ECC_PARAMETERSBCRYPT_ECC_CURVE_NAMEBCRYPT_ECC_CURVE_NAME_LISTBCRYPT_ECC_PARAMETERS_MAGICBCRYPT_ECC_CURVE_BRAINPOOLP160R1BCRYPT_ECC_CURVE_BRAINPOOLP160T1BCRYPT_ECC_CURVE_BRAINPOOLP192R1BCRYPT_ECC_CURVE_BRAINPOOLP192T1BCRYPT_ECC_CURVE_BRAINPOOLP224R1BCRYPT_ECC_CURVE_BRAINPOOLP224T1BCRYPT_ECC_CURVE_BRAINPOOLP256R1BCRYPT_ECC_CURVE_BRAINPOOLP256T1BCRYPT_ECC_CURVE_BRAINPOOLP320R1BCRYPT_ECC_CURVE_BRAINPOOLP320T1BCRYPT_ECC_CURVE_BRAINPOOLP384R1BCRYPT_ECC_CURVE_BRAINPOOLP384T1BCRYPT_ECC_CURVE_BRAINPOOLP512R1BCRYPT_ECC_CURVE_BRAINPOOLP512T1BCRYPT_ECC_CURVE_25519BCRYPT_ECC_CURVE_EC192WAPIBCRYPT_ECC_CURVE_NISTP192BCRYPT_ECC_CURVE_NISTP224BCRYPT_ECC_CURVE_NISTP256BCRYPT_ECC_CURVE_NISTP384BCRYPT_ECC_CURVE_NISTP521BCRYPT_ECC_CURVE_NUMSP256T1BCRYPT_ECC_CURVE_NUMSP384T1BCRYPT_ECC_CURVE_NUMSP512T1BCRYPT_ECC_CURVE_SECP160K1BCRYPT_ECC_CURVE_SECP160R1BCRYPT_ECC_CURVE_SECP160R2BCRYPT_ECC_CURVE_SECP192K1BCRYPT_ECC_CURVE_SECP192R1BCRYPT_ECC_CURVE_SECP224K1BCRYPT_ECC_CURVE_SECP224R1BCRYPT_ECC_CURVE_SECP256K1BCRYPT_ECC_CURVE_SECP256R1BCRYPT_ECC_CURVE_SECP384R1BCRYPT_ECC_CURVE_SECP521R1BCRYPT_ECC_CURVE_WTLS7BCRYPT_ECC_CURVE_WTLS9BCRYPT_ECC_CURVE_WTLS12BCRYPT_ECC_CURVE_X962P192V1BCRYPT_ECC_CURVE_X962P192V2BCRYPT_ECC_CURVE_X962P192V3BCRYPT_ECC_CURVE_X962P239V1BCRYPT_ECC_CURVE_X962P239V2BCRYPT_ECC_CURVE_X962P239V3BCRYPT_ECC_CURVE_X962P256V1MS_PRIMITIVE_PROVIDERMS_PLATFORM_CRYPTO_PROVIDERBCRYPT_RSA_ALGORITHMBCRYPT_RSA_SIGN_ALGORITHMBCRYPT_DH_ALGORITHMBCRYPT_DSA_ALGORITHMBCRYPT_RC2_ALGORITHMBCRYPT_RC4_ALGORITHMBCRYPT_AES_ALGORITHMBCRYPT_DES_ALGORITHMBCRYPT_DESX_ALGORITHMBCRYPT_3DES_ALGORITHMBCRYPT_3DES_112_ALGORITHMBCRYPT_MD2_ALGORITHMBCRYPT_MD4_ALGORITHMBCRYPT_MD5_ALGORITHMBCRYPT_SHA1_ALGORITHMBCRYPT_SHA256_ALGORITHMBCRYPT_SHA384_ALGORITHMBCRYPT_SHA512_ALGORITHMBCRYPT_AES_GMAC_ALGORITHMBCRYPT_AES_CMAC_ALGORITHMBCRYPT_ECDSA_P256_ALGORITHMBCRYPT_ECDSA_P384_ALGORITHMBCRYPT_ECDSA_P521_ALGORITHMBCRYPT_ECDH_P256_ALGORITHMBCRYPT_ECDH_P384_ALGORITHMBCRYPT_ECDH_P521_ALGORITHMBCRYPT_RNG_ALGORITHMBCRYPT_RNG_FIPS186_DSA_ALGORITHMBCRYPT_RNG_DUAL_EC_ALGORITHMBCRYPT_SP800108_CTR_HMAC_ALGORITHMBCRYPT_SP80056A_CONCAT_ALGORITHMBCRYPT_PBKDF2_ALGORITHMBCRYPT_CAPI_KDF_ALGORITHMBCRYPT_TLS1_1_KDF_ALGORITHMBCRYPT_TLS1_2_KDF_ALGORITHMBCRYPT_ECDSA_ALGORITHMBCRYPT_ECDH_ALGORITHMBCRYPT_XTS_AES_ALGORITHMBCRYPT_CIPHER_INTERFACEBCRYPT_HASH_INTERFACEBCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACEBCRYPT_SECRET_AGREEMENT_INTERFACEBCRYPT_SIGNATURE_INTERFACEBCRYPT_RNG_INTERFACEBCRYPT_KEY_DERIVATION_INTERFACEBCRYPT_MD2_ALG_HANDLEBCRYPT_MD4_ALG_HANDLEBCRYPT_MD5_ALG_HANDLEBCRYPT_SHA1_ALG_HANDLEBCRYPT_SHA256_ALG_HANDLEBCRYPT_SHA384_ALG_HANDLEBCRYPT_SHA512_ALG_HANDLEBCRYPT_RC4_ALG_HANDLEBCRYPT_RNG_ALG_HANDLEBCRYPT_HMAC_MD5_ALG_HANDLEBCRYPT_HMAC_SHA1_ALG_HANDLEBCRYPT_HMAC_SHA256_ALG_HANDLEBCRYPT_HMAC_SHA384_ALG_HANDLEBCRYPT_HMAC_SHA512_ALG_HANDLEBCRYPT_RSA_ALG_HANDLEBCRYPT_ECDSA_ALG_HANDLEBCRYPT_AES_CMAC_ALG_HANDLEBCRYPT_AES_GMAC_ALG_HANDLEBCRYPT_HMAC_MD2_ALG_HANDLEBCRYPT_HMAC_MD4_ALG_HANDLEBCRYPT_3DES_CBC_ALG_HANDLEBCRYPT_3DES_ECB_ALG_HANDLEBCRYPT_3DES_CFB_ALG_HANDLEBCRYPT_3DES_112_CBC_ALG_HANDLEBCRYPT_3DES_112_ECB_ALG_HANDLEBCRYPT_3DES_112_CFB_ALG_HANDLEBCRYPT_AES_CBC_ALG_HANDLEBCRYPT_AES_ECB_ALG_HANDLEBCRYPT_AES_CFB_ALG_HANDLEBCRYPT_AES_CCM_ALG_HANDLEBCRYPT_AES_GCM_ALG_HANDLEBCRYPT_DES_CBC_ALG_HANDLEBCRYPT_DES_ECB_ALG_HANDLEBCRYPT_DES_CFB_ALG_HANDLEBCRYPT_DESX_CBC_ALG_HANDLEBCRYPT_DESX_ECB_ALG_HANDLEBCRYPT_DESX_CFB_ALG_HANDLEBCRYPT_RC2_CBC_ALG_HANDLEBCRYPT_RC2_ECB_ALG_HANDLEBCRYPT_RC2_CFB_ALG_HANDLEBCRYPT_DH_ALG_HANDLEBCRYPT_ECDH_ALG_HANDLEBCRYPT_ECDH_P256_ALG_HANDLEBCRYPT_ECDH_P384_ALG_HANDLEBCRYPT_ECDH_P521_ALG_HANDLEBCRYPT_DSA_ALG_HANDLEBCRYPT_ECDSA_P256_ALG_HANDLEBCRYPT_ECDSA_P384_ALG_HANDLEBCRYPT_ECDSA_P521_ALG_HANDLEBCRYPT_RSA_SIGN_ALG_HANDLEBCRYPT_CAPI_KDF_ALG_HANDLEBCRYPT_PBKDF2_ALG_HANDLEBCRYPT_SP800108_CTR_HMAC_ALG_HANDLEBCRYPT_SP80056A_CONCAT_ALG_HANDLEBCRYPT_TLS1_1_KDF_ALG_HANDLEBCRYPT_TLS1_2_KDF_ALG_HANDLEBCRYPT_XTS_AES_ALG_HANDLEBCRYPT_ALG_HANDLE_HMAC_FLAGBCRYPT_CAPI_AES_FLAGBCRYPT_HASH_REUSABLE_FLAGBCRYPT_BUFFERS_LOCKED_FLAGBCRYPT_EXTENDED_KEYSIZEBCRYPT_ENABLE_INCOMPATIBLE_FIPS_CHECKSBCryptOpenAlgorithmProviderBCRYPT_CIPHER_OPERATIONBCRYPT_HASH_OPERATIONBCRYPT_ASYMMETRIC_ENCRYPTION_OPERATIONBCRYPT_SECRET_AGREEMENT_OPERATIONBCRYPT_SIGNATURE_OPERATIONBCRYPT_RNG_OPERATIONBCRYPT_KEY_DERIVATION_OPERATIONBCryptEnumAlgorithmsBCRYPT_ALGORITHM_IDENTIFIERBCryptEnumProvidersBCRYPT_PROVIDER_NAMEBCRYPT_PUBLIC_KEY_FLAGBCRYPT_PRIVATE_KEY_FLAGBCryptGetPropertyBCryptSetPropertyBCryptCloseAlgorithmProviderBCryptFreeBufferBCryptGenerateSymmetricKeyBCryptGenerateKeyPairBCryptEncryptBCryptDecryptBCryptExportKeyBCryptImportKeyBCRYPT_NO_KEY_VALIDATIONBCryptImportKeyPairBCryptDuplicateKeyBCryptFinalizeKeyPairBCryptDestroyKeyBCryptDestroySecretBCryptSignHashBCryptVerifySignatureBCryptSecretAgreementBCryptDeriveKeyBCryptKeyDerivationBCryptCreateHashBCryptHashDataBCryptFinishHashBCryptCreateMultiHashBCryptProcessMultiOperationsBCRYPT_MULTI_OPERATION_TYPEBCryptDuplicateHashBCryptDestroyHashBCryptHashBCRYPT_RNG_USE_ENTROPY_IN_BUFFERBCryptDeriveKeyCapiBCryptDeriveKeyPBKDF2PBCRYPT_INTERFACE_VERSIONBCRYPT_INTERFACE_VERSIONBCRYPT_IS_INTERFACE_VERSION_COMPATIBLEBCRYPT_CIPHER_INTERFACE_VERSION_1BCRYPT_HASH_INTERFACE_VERSION_1BCRYPT_HASH_INTERFACE_MAJORVERSION_2BCRYPT_HASH_INTERFACE_VERSION_2BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE_VERSION_1BCRYPT_SECRET_AGREEMENT_INTERFACE_VERSION_1BCRYPT_SIGNATURE_INTERFACE_VERSION_1BCRYPT_RNG_INTERFACE_VERSION_1CRYPT_MIN_DEPENDENCIESCRYPT_PROCESS_ISOLATECRYPT_UMCRYPT_KMCRYPT_MMCRYPT_ANYCRYPT_OVERWRITECRYPT_LOCALCRYPT_DOMAINCRYPT_EXCLUSIVECRYPT_OVERRIDECRYPT_ALL_FUNCTIONSCRYPT_ALL_PROVIDERSCRYPT_PRIORITY_TOPCRYPT_PRIORITY_BOTTOMCRYPT_DEFAULT_CONTEXTPCRYPT_INTERFACE_REGCRYPT_INTERFACE_REGPCRYPT_IMAGE_REGCRYPT_IMAGE_REGPCRYPT_PROVIDER_REGCRYPT_PROVIDER_REGPCRYPT_PROVIDERSCRYPT_PROVIDERSPCRYPT_CONTEXT_CONFIGCRYPT_CONTEXT_CONFIGPCRYPT_CONTEXT_FUNCTION_CONFIGCRYPT_CONTEXT_FUNCTION_CONFIGPCRYPT_CONTEXTSCRYPT_CONTEXTSPCRYPT_CONTEXT_FUNCTIONSCRYPT_CONTEXT_FUNCTIONSPCRYPT_CONTEXT_FUNCTION_PROVIDERSCRYPT_CONTEXT_FUNCTION_PROVIDERSPCRYPT_PROPERTY_REFCRYPT_PROPERTY_REFPCRYPT_IMAGE_REFCRYPT_IMAGE_REFPCRYPT_PROVIDER_REFCRYPT_PROVIDER_REFPCRYPT_PROVIDER_REFSCRYPT_PROVIDER_REFSBCryptQueryProviderRegistrationBCryptEnumRegisteredProvidersBCryptCreateContextBCryptDeleteContextBCryptEnumContextsBCryptConfigureContextBCryptQueryContextConfigurationBCryptAddContextFunctionBCryptRemoveContextFunctionBCryptEnumContextFunctionsBCryptConfigureContextFunctionBCryptQueryContextFunctionConfigurationBCryptEnumContextFunctionProvidersBCryptSetContextFunctionPropertyBCryptQueryContextFunctionPropertyBCryptRegisterConfigChangeNotifyBCryptUnregisterConfigChangeNotifyBCryptResolveProvidersBCryptGetFipsAlgorithmModeCngGetFipsAlgorithmMode//! Cryptographic Primitive API Prototypes and DefinitionsbthsdpdefSDP_ERRORBTH_MAJORVERSIONBTH_MINORVERSIONSDP_PROTOCOL_UUID16UDP_PROTOCOL_UUID16RFCOMM_PROTOCOL_UUID16TCP_PROTOCOL_UUID16TCSBIN_PROTOCOL_UUID16TCSAT_PROTOCOL_UUID16ATT_PROTOCOL_UUID16OBEX_PROTOCOL_UUID16IP_PROTOCOL_UUID16FTP_PROTOCOL_UUID16HTTP_PROTOCOL_UUID16WSP_PROTOCOL_UUID16BNEP_PROTOCOL_UUID16UPNP_PROTOCOL_UUID16HID_PROTOCOL_UUID16HCCC_PROTOCOL_UUID16HCDC_PROTOCOL_UUID16HCN_PROTOCOL_UUID16AVCTP_PROTOCOL_UUID16AVDTP_PROTOCOL_UUID16CMPT_PROTOCOL_UUID16UDI_C_PLANE_PROTOCOL_UUID16L2CAP_PROTOCOL_UUID16ServiceDiscoveryServerServiceClassID_UUID16BrowseGroupDescriptorServiceClassID_UUID16PublicBrowseGroupServiceClassID_UUID16SerialPortServiceClassID_UUID16LANAccessUsingPPPServiceClassID_UUID16DialupNetworkingServiceClassID_UUID16IrMCSyncServiceClassID_UUID16OBEXObjectPushServiceClassID_UUID16OBEXFileTransferServiceClassID_UUID16IrMcSyncCommandServiceClassID_UUID16HeadsetServiceClassID_UUID16CordlessTelephonyServiceClassID_UUID16AudioSourceServiceClassID_UUID16AudioSinkServiceClassID_UUID16AVRemoteControlTargetServiceClassID_UUID16AVRemoteControlServiceClassID_UUID16AVRemoteControlControllerServiceClass_UUID16IntercomServiceClassID_UUID16FaxServiceClassID_UUID16HeadsetAudioGatewayServiceClassID_UUID16WAPServiceClassID_UUID16WAPClientServiceClassID_UUID16PANUServiceClassID_UUID16NAPServiceClassID_UUID16GNServiceClassID_UUID16DirectPrintingServiceClassID_UUID16ReferencePrintingServiceClassID_UUID16ImagingResponderServiceClassID_UUID16ImagingAutomaticArchiveServiceClassID_UUID16ImagingReferenceObjectsServiceClassID_UUID16HandsfreeServiceClassID_UUID16HandsfreeAudioGatewayServiceClassID_UUID16DirectPrintingReferenceObjectsServiceClassID_UUID16ReflectsUIServiceClassID_UUID16PrintingStatusServiceClassID_UUID16HumanInterfaceDeviceServiceClassID_UUID16HCRPrintServiceClassID_UUID16HCRScanServiceClassID_UUID16CommonISDNAccessServiceClassID_UUID16VideoConferencingGWServiceClassID_UUID16UDIMTServiceClassID_UUID16UDITAServiceClassID_UUID16AudioVideoServiceClassID_UUID16SimAccessServiceClassID_UUID16PhonebookAccessPceServiceClassID_UUID16PhonebookAccessPseServiceClassID_UUID16HeadsetHSServiceClassID_UUID16MessageAccessServerServiceClassID_UUID16MessageNotificationServerServiceClassID_UUID16GNSSServerServiceClassID_UUID16ThreeDimensionalDisplayServiceClassID_UUID16ThreeDimensionalGlassesServiceClassID_UUID16MPSServiceClassID_UUID16CTNAccessServiceClassID_UUID16CTNNotificationServiceClassID_UUID16PnPInformationServiceClassID_UUID16GenericNetworkingServiceClassID_UUID16GenericFileTransferServiceClassID_UUID16GenericAudioServiceClassID_UUID16GenericTelephonyServiceClassID_UUID16UPnpServiceClassID_UUID16UPnpIpServiceClassID_UUID16ESdpUpnpIpPanServiceClassID_UUID16ESdpUpnpIpLapServiceClassID_UUID16ESdpUpnpL2capServiceClassID_UUID16VideoSourceServiceClassID_UUID16VideoSinkServiceClassID_UUID16HealthDeviceProfileSourceServiceClassID_UUID16HealthDeviceProfileSinkServiceClassID_UUID16AdvancedAudioDistributionProfileID_UUID16ImagingServiceProfileID_UUID16BasicPrintingProfileID_UUID16HardcopyCableReplacementProfileID_UUID16PhonebookAccessProfileID_UUID16MessageAccessProfileID_UUID16GNSSProfileID_UUID16ThreeDimensionalSynchronizationProfileID_UUID16MPSProfileID_UUID16CTNProfileID_UUID16VideoDistributionProfileID_UUID16HealthDeviceProfileID_UUID16VideoConferencingServiceClass_UUIDVideoConferencingServiceClassID_UUID16HN_PROTOCOL_UUIDBasicPringingServiceClass_UUIDCommonISDNAccessServiceClass_UUID16VideoConferencingGWServiceClass_UUID16UDIMTServiceClass_UUID16UDITAServiceClass_UUID16AudioVideoServiceClass_UUID16CordlessServiceClassID_UUID16AudioSinkSourceServiceClassID_UUID16AdvancedAudioDistributionServiceClassID_UUID16ImagingServiceClassID_UUID16BasicPrintingServiceClassID_UUID16HardcopyCableReplacementServiceClassID_UUID16AdvancedAudioDistributionServiceClass_UUIDImagingServiceClass_UUIDBasicPrintingServiceClass_UUIDHardcopyCableReplacementServiceClass_UUIDVideoDistributionServiceClass_UUIDBTH_MAX_NAME_SIZEBTH_MAX_PIN_SIZEBTH_LINK_KEY_LENGTHBTH_MFG_ERICSSONBTH_MFG_NOKIABTH_MFG_INTELBTH_MFG_IBMBTH_MFG_TOSHIBABTH_MFG_3COMBTH_MFG_MICROSOFTBTH_MFG_LUCENTBTH_MFG_MOTOROLABTH_MFG_INFINEONBTH_MFG_CSRBTH_MFG_SILICONWAVEBTH_MFG_DIGIANSWERBTH_MFG_TIBTH_MFG_PARTHUSBTH_MFG_BROADCOMBTH_MFG_MITELBTH_MFG_WIDCOMMBTH_MFG_ZEEVOBTH_MFG_ATMELBTH_MFG_MITSIBUSHIBTH_MFG_RTX_TELECOMBTH_MFG_KC_TECHNOLOGYBTH_MFG_NEWLOGICBTH_MFG_TRANSILICABTH_MFG_ROHDE_SCHWARZBTH_MFG_TTPCOMBTH_MFG_SIGNIABTH_MFG_CONEXANTBTH_MFG_QUALCOMMBTH_MFG_INVENTELBTH_MFG_AVM_BERLINBTH_MFG_BANDSPEEDBTH_MFG_MANSELLABTH_MFG_NECBTH_MFG_WAVEPLUS_TECHNOLOGY_COBTH_MFG_ALCATELBTH_MFG_PHILIPS_SEMICONDUCTORBTH_MFG_C_TECHNOLOGIESBTH_MFG_OPEN_INTERFACEBTH_MFG_RF_MICRO_DEVICESBTH_MFG_HITACHIBTH_MFG_SYMBOL_TECHNOLOGIESBTH_MFG_TENOVISBTH_MFG_MACRONIX_INTERNATIONALBTH_MFG_APPLEBTH_MFG_NORDIC_SEMICONDUCTORS_ASABTH_MFG_ARUBA_NETWORKSBTH_MFG_INTERNAL_USEBTH_ADDRPBTH_ADDRBTH_CODPBTH_CODBTH_LAPPBTH_LAPBTH_ADDR_NULLNAP_MASKSAP_MASKNAP_BIT_OFFSETSAP_BIT_OFFSETGET_NAPGET_SAPSET_NAPSET_SAPSET_NAP_SAPCOD_FORMAT_BIT_OFFSETCOD_MINOR_BIT_OFFSETCOD_MAJOR_BIT_OFFSETCOD_SERVICE_BIT_OFFSETCOD_FORMAT_MASKCOD_MINOR_MASKCOD_MAJOR_MASKCOD_SERVICE_MASKGET_COD_FORMATGET_COD_MINORGET_COD_MAJORGET_COD_SERVICESET_COD_MINORSET_COD_MAJORSET_COD_SERVICECOD_VERSIONCOD_SERVICE_LIMITEDCOD_SERVICE_POSITIONINGCOD_SERVICE_NETWORKINGCOD_SERVICE_RENDERINGCOD_SERVICE_CAPTURINGCOD_SERVICE_OBJECT_XFERCOD_SERVICE_AUDIOCOD_SERVICE_TELEPHONYCOD_SERVICE_INFORMATIONCOD_SERVICE_VALID_MASKCOD_SERVICE_MAX_COUNTCOD_MAJOR_MISCELLANEOUSCOD_MAJOR_COMPUTERCOD_MAJOR_PHONECOD_MAJOR_LAN_ACCESSCOD_MAJOR_AUDIOCOD_MAJOR_PERIPHERALCOD_MAJOR_IMAGINGCOD_MAJOR_WEARABLECOD_MAJOR_TOYCOD_MAJOR_HEALTHCOD_MAJOR_UNCLASSIFIEDCOD_COMPUTER_MINOR_UNCLASSIFIEDCOD_COMPUTER_MINOR_DESKTOPCOD_COMPUTER_MINOR_SERVERCOD_COMPUTER_MINOR_LAPTOPCOD_COMPUTER_MINOR_HANDHELDCOD_COMPUTER_MINOR_PALMCOD_COMPUTER_MINOR_WEARABLECOD_PHONE_MINOR_UNCLASSIFIEDCOD_PHONE_MINOR_CELLULARCOD_PHONE_MINOR_CORDLESSCOD_PHONE_MINOR_SMARTCOD_PHONE_MINOR_WIRED_MODEMCOD_AUDIO_MINOR_UNCLASSIFIEDCOD_AUDIO_MINOR_HEADSETCOD_AUDIO_MINOR_HANDS_FREECOD_AUDIO_MINOR_HEADSET_HANDS_FREECOD_AUDIO_MINOR_MICROPHONECOD_AUDIO_MINOR_LOUDSPEAKERCOD_AUDIO_MINOR_HEADPHONESCOD_AUDIO_MINOR_PORTABLE_AUDIOCOD_AUDIO_MINOR_CAR_AUDIOCOD_AUDIO_MINOR_SET_TOP_BOXCOD_AUDIO_MINOR_HIFI_AUDIOCOD_AUDIO_MINOR_VCRCOD_AUDIO_MINOR_VIDEO_CAMERACOD_AUDIO_MINOR_CAMCORDERCOD_AUDIO_MINOR_VIDEO_MONITORCOD_AUDIO_MINOR_VIDEO_DISPLAY_LOUDSPEAKERCOD_AUDIO_MINOR_VIDEO_DISPLAY_CONFERENCINGCOD_AUDIO_MINOR_GAMING_TOYCOD_PERIPHERAL_MINOR_KEYBOARD_MASKCOD_PERIPHERAL_MINOR_POINTER_MASKCOD_PERIPHERAL_MINOR_NO_CATEGORYCOD_PERIPHERAL_MINOR_JOYSTICKCOD_PERIPHERAL_MINOR_GAMEPADCOD_PERIPHERAL_MINOR_REMOTE_CONTROLCOD_PERIPHERAL_MINOR_SENSINGCOD_IMAGING_MINOR_DISPLAY_MASKCOD_IMAGING_MINOR_CAMERA_MASKCOD_IMAGING_MINOR_SCANNER_MASKCOD_IMAGING_MINOR_PRINTER_MASKCOD_WEARABLE_MINOR_WRIST_WATCHCOD_WEARABLE_MINOR_PAGERCOD_WEARABLE_MINOR_JACKETCOD_WEARABLE_MINOR_HELMETCOD_WEARABLE_MINOR_GLASSESCOD_TOY_MINOR_ROBOTCOD_TOY_MINOR_VEHICLECOD_TOY_MINOR_DOLL_ACTION_FIGURECOD_TOY_MINOR_CONTROLLERCOD_TOY_MINOR_GAMECOD_HEALTH_MINOR_BLOOD_PRESSURE_MONITORCOD_HEALTH_MINOR_THERMOMETERCOD_HEALTH_MINOR_WEIGHING_SCALECOD_HEALTH_MINOR_GLUCOSE_METERCOD_HEALTH_MINOR_PULSE_OXIMETERCOD_HEALTH_MINOR_HEART_PULSE_MONITORCOD_HEALTH_MINOR_HEALTH_DATA_DISPLAYCOD_HEALTH_MINOR_STEP_COUNTERCOD_LAN_ACCESS_BIT_OFFSETCOD_LAN_MINOR_MASKCOD_LAN_ACCESS_MASKGET_COD_LAN_MINORGET_COD_LAN_ACCESSCOD_LAN_MINOR_UNCLASSIFIEDCOD_LAN_ACCESS_0_USEDCOD_LAN_ACCESS_17_USEDCOD_LAN_ACCESS_33_USEDCOD_LAN_ACCESS_50_USEDCOD_LAN_ACCESS_67_USEDCOD_LAN_ACCESS_83_USEDCOD_LAN_ACCESS_99_USEDCOD_LAN_ACCESS_FULLBTH_EIR_FLAGS_IDBTH_EIR_16_UUIDS_PARTIAL_IDBTH_EIR_16_UUIDS_COMPLETE_IDBTH_EIR_32_UUIDS_PARTIAL_IDBTH_EIR_32_UUIDS_COMPLETE_IDBTH_EIR_128_UUIDS_PARTIAL_IDBTH_EIR_128_UUIDS_COMPLETE_IDBTH_EIR_LOCAL_NAME_PARTIAL_IDBTH_EIR_LOCAL_NAME_COMPLETE_IDBTH_EIR_TX_POWER_LEVEL_IDBTH_EIR_OOB_OPT_DATA_LEN_IDBTH_EIR_OOB_BD_ADDR_IDBTH_EIR_OOB_COD_IDBTH_EIR_OOB_SP_HASH_IDBTH_EIR_OOB_SP_RANDOMIZER_IDBTH_EIR_MANUFACTURER_IDBTH_EIR_SIZELAP_GIAC_VALUE// #define LAP_GIAC_INIT { 0x33, 0x8B, 0x9E }// #define LAP_LIAC_INIT { 0x00, 0x8B, 0x9E }LAP_LIAC_VALUEBTH_ADDR_IAC_FIRSTBTH_ADDR_IAC_LASTBTH_ADDR_LIACBTH_ADDR_GIACBTHSTATUSPBTHSTATUSBTH_ERRORBTH_SUCCESSBTH_ERROR_SUCCESSBTH_ERROR_UNKNOWN_HCI_COMMANDBTH_ERROR_NO_CONNECTIONBTH_ERROR_HARDWARE_FAILUREBTH_ERROR_PAGE_TIMEOUTBTH_ERROR_AUTHENTICATION_FAILUREBTH_ERROR_KEY_MISSINGBTH_ERROR_MEMORY_FULLBTH_ERROR_CONNECTION_TIMEOUTBTH_ERROR_MAX_NUMBER_OF_CONNECTIONSBTH_ERROR_MAX_NUMBER_OF_SCO_CONNECTIONSBTH_ERROR_ACL_CONNECTION_ALREADY_EXISTSBTH_ERROR_COMMAND_DISALLOWEDBTH_ERROR_HOST_REJECTED_LIMITED_RESOURCESBTH_ERROR_HOST_REJECTED_SECURITY_REASONSBTH_ERROR_HOST_REJECTED_PERSONAL_DEVICEBTH_ERROR_HOST_TIMEOUTBTH_ERROR_UNSUPPORTED_FEATURE_OR_PARAMETERBTH_ERROR_INVALID_HCI_PARAMETERBTH_ERROR_REMOTE_USER_ENDED_CONNECTIONBTH_ERROR_REMOTE_LOW_RESOURCESBTH_ERROR_REMOTE_POWERING_OFFBTH_ERROR_LOCAL_HOST_TERMINATED_CONNECTIONBTH_ERROR_REPEATED_ATTEMPTSBTH_ERROR_PAIRING_NOT_ALLOWEDBTH_ERROR_UKNOWN_LMP_PDUBTH_ERROR_UNSUPPORTED_REMOTE_FEATUREBTH_ERROR_SCO_OFFSET_REJECTEDBTH_ERROR_SCO_INTERVAL_REJECTEDBTH_ERROR_SCO_AIRMODE_REJECTEDBTH_ERROR_INVALID_LMP_PARAMETERSBTH_ERROR_UNSPECIFIED_ERRORBTH_ERROR_UNSUPPORTED_LMP_PARM_VALUEBTH_ERROR_ROLE_CHANGE_NOT_ALLOWEDBTH_ERROR_LMP_RESPONSE_TIMEOUTBTH_ERROR_LMP_TRANSACTION_COLLISIONBTH_ERROR_LMP_PDU_NOT_ALLOWEDBTH_ERROR_ENCRYPTION_MODE_NOT_ACCEPTABLEBTH_ERROR_UNIT_KEY_NOT_USEDBTH_ERROR_QOS_IS_NOT_SUPPORTEDBTH_ERROR_INSTANT_PASSEDBTH_ERROR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTEDBTH_ERROR_DIFFERENT_TRANSACTION_COLLISIONBTH_ERROR_QOS_UNACCEPTABLE_PARAMETERBTH_ERROR_QOS_REJECTEDBTH_ERROR_CHANNEL_CLASSIFICATION_NOT_SUPPORTEDBTH_ERROR_INSUFFICIENT_SECURITYBTH_ERROR_PARAMETER_OUT_OF_MANDATORY_RANGEBTH_ERROR_ROLE_SWITCH_PENDINGBTH_ERROR_RESERVED_SLOT_VIOLATIONBTH_ERROR_ROLE_SWITCH_FAILEDBTH_ERROR_EXTENDED_INQUIRY_RESPONSE_TOO_LARGEBTH_ERROR_SECURE_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOSTBTH_ERROR_HOST_BUSY_PAIRINGBTH_ERROR_CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUNDBTH_ERROR_CONTROLLER_BUSYBTH_ERROR_UNACCEPTABLE_CONNECTION_INTERVALBTH_ERROR_DIRECTED_ADVERTISING_TIMEOUTBTH_ERROR_CONNECTION_TERMINATED_DUE_TO_MIC_FAILUREBTH_ERROR_CONNECTION_FAILED_TO_BE_ESTABLISHEDBTH_ERROR_MAC_CONNECTION_FAILEDBTH_ERROR_UNSPECIFIEDL2CAP_MIN_MTUL2CAP_MAX_MTUL2CAP_DEFAULT_MTUMAX_L2CAP_PING_DATA_LENGTHMAX_L2CAP_INFO_DATA_LENGTHBDIF_ADDRESSBDIF_CODBDIF_NAMEBDIF_PAIREDBDIF_PERSONALBDIF_CONNECTEDBDIF_SHORT_NAMEBDIF_VISIBLEBDIF_SSP_SUPPORTEDBDIF_SSP_PAIREDBDIF_SSP_MITM_PROTECTEDBDIF_RSSIBDIF_EIRBDIF_BRBDIF_LEBDIF_LE_PAIREDBDIF_LE_PERSONALBDIF_LE_MITM_PROTECTEDBDIF_LE_PRIVACY_ENABLEDBDIF_LE_RANDOM_ADDRESS_TYPEBDIF_LE_DISCOVERABLEBDIF_LE_NAMEBDIF_LE_VISIBLEBDIF_LE_CONNECTEDBDIF_LE_CONNECTABLEBDIF_CONNECTION_INBOUNDBDIF_BR_SECURE_CONNECTION_PAIREDBDIF_LE_SECURE_CONNECTION_PAIREDBDIF_VALID_FLAGSPBTH_DEVICE_INFOBTH_DEVICE_INFOPBTH_RADIO_IN_RANGEBTH_RADIO_IN_RANGEPBTH_L2CAP_EVENT_INFOBTH_L2CAP_EVENT_INFOHCI_CONNECTION_TYPE_ACLHCI_CONNECTION_TYPE_SCOHCI_CONNECTION_TYPE_LEHCI_CONNNECTION_TYPE_ACLHCI_CONNNECTION_TYPE_SCOPBTH_HCI_EVENT_INFOBTH_HCI_EVENT_INFOIsMITMProtectionRequiredAUTHENTICATION_REQUIREMENTSBTH_MAX_SERVICE_NAME_SIZEMAX_UUIDS_IN_QUERYBTH_VID_DEFAULT_VALUESDP_ERROR_INVALID_SDP_VERSIONSDP_ERROR_INVALID_RECORD_HANDLESDP_ERROR_INVALID_REQUEST_SYNTAXSDP_ERROR_INVALID_PDU_SIZESDP_ERROR_INVALID_CONTINUATION_STATESDP_ERROR_INSUFFICIENT_RESOURCESSDP_ERROR_SUCCESSSDP_ERROR_SERVER_INVALID_RESPONSESDP_ERROR_SERVER_RESPONSE_DID_NOT_PARSESDP_ERROR_SERVER_BAD_FORMATSDP_ERROR_COULD_NOT_SEND_CONTINUESDP_ERROR_RESPONSE_TOO_LARGESDP_ATTRIB_RECORD_HANDLESDP_ATTRIB_CLASS_ID_LISTSDP_ATTRIB_RECORD_STATESDP_ATTRIB_SERVICE_IDSDP_ATTRIB_PROTOCOL_DESCRIPTOR_LISTSDP_ATTRIB_BROWSE_GROUP_LISTSDP_ATTRIB_LANG_BASE_ATTRIB_ID_LISTSDP_ATTRIB_INFO_TIME_TO_LIVESDP_ATTRIB_AVAILABILITYSDP_ATTRIB_PROFILE_DESCRIPTOR_LISTSDP_ATTRIB_DOCUMENTATION_URLSDP_ATTRIB_CLIENT_EXECUTABLE_URLSDP_ATTRIB_ICON_URLSDP_ATTRIB_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTSDP_ATTRIB_PROFILE_SPECIFICLANG_BASE_LANGUAGE_INDEXLANG_BASE_ENCODING_INDEXLANG_BASE_OFFSET_INDEXLANG_DEFAULT_IDLANGUAGE_EN_USENCODING_UTF_8STRING_NAME_OFFSETSTRING_DESCRIPTION_OFFSETSTRING_PROVIDER_NAME_OFFSETSDP_ATTRIB_SDP_VERSION_NUMBER_LISTSDP_ATTRIB_SDP_DATABASE_STATESDP_ATTRIB_BROWSE_GROUP_IDSDP_ATTRIB_CORDLESS_EXTERNAL_NETWORKSDP_ATTRIB_FAX_CLASS_1_SUPPORTSDP_ATTRIB_FAX_CLASS_2_0_SUPPORTSDP_ATTRIB_FAX_CLASS_2_SUPPORTSDP_ATTRIB_FAX_AUDIO_FEEDBACK_SUPPORTSDP_ATTRIB_HEADSET_REMOTE_AUDIO_VOLUME_CONTROLSDP_ATTRIB_LAN_LPSUBNETSDP_ATTRIB_OBJECT_PUSH_SUPPORTED_FORMATS_LISTSDP_ATTRIB_SYNCH_SUPPORTED_DATA_STORES_LISTSDP_ATTRIB_SERVICE_VERSIONSDP_ATTRIB_PAN_NETWORK_ADDRESSSDP_ATTRIB_PAN_WAP_GATEWAYSDP_ATTRIB_PAN_HOME_PAGE_URLSDP_ATTRIB_PAN_WAP_STACK_TYPESDP_ATTRIB_PAN_SECURITY_DESCRIPTIONSDP_ATTRIB_PAN_NET_ACCESS_TYPESDP_ATTRIB_PAN_MAX_NET_ACCESS_RATESDP_ATTRIB_IMAGING_SUPPORTED_CAPABILITIESSDP_ATTRIB_IMAGING_SUPPORTED_FEATURESSDP_ATTRIB_IMAGING_SUPPORTED_FUNCTIONSSDP_ATTRIB_IMAGING_TOTAL_DATA_CAPACITYSDP_ATTRIB_DI_SPECIFICATION_IDSDP_ATTRIB_DI_VENDOR_IDSDP_ATTRIB_DI_PRODUCT_IDSDP_ATTRIB_DI_VERSIONSDP_ATTRIB_DI_PRIMARY_RECORDSDP_ATTRIB_DI_VENDOR_ID_SOURCESDP_ATTRIB_HID_DEVICE_RELEASE_NUMBERSDP_ATTRIB_HID_PARSER_VERSIONSDP_ATTRIB_HID_DEVICE_SUBCLASSSDP_ATTRIB_HID_COUNTRY_CODESDP_ATTRIB_HID_VIRTUAL_CABLESDP_ATTRIB_HID_RECONNECT_INITIATESDP_ATTRIB_HID_DESCRIPTOR_LISTSDP_ATTRIB_HID_LANG_ID_BASE_LISTSDP_ATTRIB_HID_SDP_DISABLESDP_ATTRIB_HID_BATTERY_POWERSDP_ATTRIB_HID_REMOTE_WAKESDP_ATTRIB_HID_PROFILE_VERSIONSDP_ATTRIB_HID_SUPERVISION_TIMEOUTSDP_ATTRIB_HID_NORMALLY_CONNECTABLESDP_ATTRIB_HID_BOOT_DEVICESDP_ATTRIB_HID_SSR_HOST_MAX_LATENCYSDP_ATTRIB_HID_SSR_HOST_MIN_TIMEOUTCORDLESS_EXTERNAL_NETWORK_PSTNCORDLESS_EXTERNAL_NETWORK_ISDNCORDLESS_EXTERNAL_NETWORK_GSMCORDLESS_EXTERNAL_NETWORK_CDMACORDLESS_EXTERNAL_NETWORK_ANALOG_CELLULARCORDLESS_EXTERNAL_NETWORK_PACKET_SWITCHEDCORDLESS_EXTERNAL_NETWORK_OTHEROBJECT_PUSH_FORMAT_VCARD_2_1OBJECT_PUSH_FORMAT_VCARD_3_0OBJECT_PUSH_FORMAT_VCAL_1_0OBJECT_PUSH_FORMAT_ICAL_2_0OBJECT_PUSH_FORMAT_VNOTEOBJECT_PUSH_FORMAT_VMESSAGEOBJECT_PUSH_FORMAT_ANYSYNCH_DATA_STORE_PHONEBOOKSYNCH_DATA_STORE_CALENDARSYNCH_DATA_STORE_NOTESSYNCH_DATA_STORE_MESSAGESDI_VENDOR_ID_SOURCE_BLUETOOTH_SIGDI_VENDOR_ID_SOURCE_USB_IFPSM_SDPPSM_RFCOMMPSM_TCS_BINPSM_TCS_BIN_CORDLESSPSM_BNEPPSM_HID_CONTROLPSM_HID_INTERRUPTPSM_UPNPPSM_AVCTPPSM_AVDTPPSM_AVCTP_BROWSEPSM_UDI_C_PLANEPSM_ATTPSM_3DSPPSM_LE_IPSPSTR_ADDR_FMTASTR_ADDR_SHORT_FMTA// #define STR_ADDR_FMTW L"(%02x:%02x:%02x:%02x:%02x:%02x)"STR_USBHCI_CLASS_HARDWAREIDA// #define STR_ADDR_SHORT_FMTW L"%04x%08x"GET_BITS// #define STR_USBHCI_CLASS_HARDWAREIDW L"USB\\Class_E0&SubClass_01&Prot_01"GET_BITLMP_3_SLOT_PACKETSLMP_5_SLOT_PACKETSLMP_ENCRYPTIONLMP_SLOT_OFFSETLMP_TIMING_ACCURACYLMP_SWITCHLMP_HOLD_MODELMP_SNIFF_MODELMP_PARK_MODELMP_RSSILMP_CHANNEL_QUALITY_DRIVEN_MODELMP_SCO_LINKLMP_HV2_PACKETSLMP_HV3_PACKETSLMP_MU_LAW_LOGLMP_A_LAW_LOGLMP_CVSDLMP_PAGING_SCHEMELMP_POWER_CONTROLLMP_TRANSPARENT_SCO_DATALMP_FLOW_CONTROL_LAGLMP_BROADCAST_ENCRYPTIONLMP_ENHANCED_DATA_RATE_ACL_2MBPS_MODELMP_ENHANCED_DATA_RATE_ACL_3MBPS_MODELMP_ENHANCED_INQUIRY_SCANLMP_INTERLACED_INQUIRY_SCANLMP_INTERLACED_PAGE_SCANLMP_RSSI_WITH_INQUIRY_RESULTSLMP_ESCO_LINKLMP_EV4_PACKETSLMP_EV5_PACKETSLMP_AFH_CAPABLE_SLAVELMP_AFH_CLASSIFICATION_SLAVELMP_BR_EDR_NOT_SUPPORTEDLMP_LE_SUPPORTEDLMP_3SLOT_EDR_ACL_PACKETSLMP_5SLOT_EDR_ACL_PACKETSLMP_SNIFF_SUBRATINGLMP_PAUSE_ENCRYPTIONLMP_AFH_CAPABLE_MASTERLMP_AFH_CLASSIFICATION_MASTERLMP_EDR_ESCO_2MBPS_MODELMP_EDR_ESCO_3MBPS_MODELMP_3SLOT_EDR_ESCO_PACKETSLMP_EXTENDED_INQUIRY_RESPONSELMP_SIMULT_LE_BR_TO_SAME_DEVLMP_SECURE_SIMPLE_PAIRINGLMP_ENCAPSULATED_PDULMP_ERRONEOUS_DATA_REPORTINGLMP_NON_FLUSHABLE_PACKET_BOUNDARY_FLAGLMP_LINK_SUPERVISION_TIMEOUT_CHANGED_EVENTLMP_INQUIRY_RESPONSE_TX_POWER_LEVELLMP_EXTENDED_FEATURESbthdefSdpAttributeRangeSdpQueryUuidwinioctlFILE_ANY_ACCESSFILE_DEVICE_BLUETOOTHMETHOD_BUFFEREDMETHOD_NEITHERBTH_IOCTL_BASEIOCTL_INTERNAL_BTH_SUBMIT_BRBIOCTL_INTERNAL_BTHENUM_GET_ENUMINFOIOCTL_INTERNAL_BTHENUM_GET_DEVINFOIOCTL_BTH_GET_LOCAL_INFOIOCTL_BTH_GET_RADIO_INFOIOCTL_BTH_GET_DEVICE_INFOIOCTL_BTH_DISCONNECT_DEVICEIOCTL_BTH_HCI_VENDOR_COMMANDIOCTL_BTH_SDP_CONNECTIOCTL_BTH_SDP_DISCONNECTIOCTL_BTH_SDP_SERVICE_SEARCHIOCTL_BTH_SDP_ATTRIBUTE_SEARCHIOCTL_BTH_SDP_SERVICE_ATTRIBUTE_SEARCHIOCTL_BTH_SDP_SUBMIT_RECORDIOCTL_BTH_SDP_REMOVE_RECORDIOCTL_BTH_SDP_SUBMIT_RECORD_WITH_INFOIOCTL_BTH_GET_HOST_SUPPORTED_FEATURESPBTH_DEVICE_INFO_LISTBTH_DEVICE_INFO_LISTPBTH_RADIO_INFOBTH_RADIO_INFOPBTH_LOCAL_RADIO_INFOBTH_LOCAL_RADIO_INFOSDP_CONNECT_CACHESDP_CONNECT_ALLOW_PINSDP_REQUEST_TO_DEFAULTSDP_REQUEST_TO_MINSDP_REQUEST_TO_MAXSERVICE_OPTION_DO_NOT_PUBLISHSERVICE_OPTION_NO_PUBLIC_BROWSESERVICE_OPTION_DO_NOT_PUBLISH_EIRSERVICE_SECURITY_USE_DEFAULTSSERVICE_SECURITY_NONESERVICE_SECURITY_AUTHORIZESERVICE_SECURITY_AUTHENTICATESERVICE_SECURITY_ENCRYPT_REQUIREDSERVICE_SECURITY_ENCRYPT_OPTIONALSERVICE_SECURITY_DISABLEDSERVICE_SECURITY_NO_ASKSDP_SEARCH_NO_PARSE_CHECKSDP_SEARCH_NO_FORMAT_CHECKHANDLE_SDPPHANDLE_SDPHANDLE_SDP_TYPEHANDLE_SDP_NULLHANDLE_SDP_LOCALPBTH_SDP_CONNECTBTH_SDP_CONNECTPBTH_SDP_DISCONNECTBTH_SDP_DISCONNECTPBTH_SDP_RECORDBTH_SDP_RECORDPBTH_SDP_SERVICE_SEARCH_REQUESTBTH_SDP_SERVICE_SEARCH_REQUESTPBTH_SDP_ATTRIBUTE_SEARCH_REQUESTBTH_SDP_ATTRIBUTE_SEARCH_REQUESTPBTH_SDP_SERVICE_ATTRIBUTE_SEARCH_REQUESTBTH_SDP_SERVICE_ATTRIBUTE_SEARCH_REQUESTPBTH_SDP_STREAM_RESPONSEBTH_SDP_STREAM_RESPONSEPBTH_COMMAND_HEADERBTH_COMMAND_HEADERPBTH_VENDOR_SPECIFIC_COMMANDBTH_VENDOR_SPECIFIC_COMMANDPBTH_VENDOR_PATTERNBTH_VENDOR_PATTERNPBTH_VENDOR_EVENT_INFOBTH_VENDOR_EVENT_INFOBTH_HOST_FEATURE_ENHANCED_RETRANSMISSION_MODEBTH_HOST_FEATURE_STREAMING_MODEBTH_HOST_FEATURE_LOW_ENERGYBTH_HOST_FEATURE_SCO_HCIBTH_HOST_FEATURE_SCO_HCIBYPASSPBTH_HOST_FEATURE_MASKBTH_HOST_FEATURE_MASKLONGLONGPSDP_ULARGE_INTEGER_16SDP_ULARGE_INTEGER_16LPSDP_ULARGE_INTEGER_16PSDP_LARGE_INTEGER_16SDP_LARGE_INTEGER_16LPSDP_LARGE_INTEGER_16PSDP_ERRORHARDWARE_PROFILE_UNDOCKED_STRINGHARDWARE_PROFILE_DOCKED_STRINGHARDWARE_PROFILE_UNKNOWN_STRINGWINDOWS_NT_BANNERWINDOWS_NT_CSD_STRINGWINDOWS_NT_INFO_STRINGWINDOWS_NT_MP_STRINGTHREAD_TERMINATE_HELD_MUTEXWINDOWS_NT_INFO_STRING_PLURALWINDOWS_NT_RC_STRINGAPC_INDEX_MISMATCHDEVICE_QUEUE_NOT_BUSYINVALID_AFFINITY_SETINVALID_DATA_ACCESS_TRAPINVALID_PROCESS_ATTACH_ATTEMPTINVALID_PROCESS_DETACH_ATTEMPTINVALID_SOFTWARE_INTERRUPTIRQL_NOT_DISPATCH_LEVELIRQL_NOT_GREATER_OR_EQUALIRQL_NOT_LESS_OR_EQUALNO_EXCEPTION_HANDLING_SUPPORTMAXIMUM_WAIT_OBJECTS_EXCEEDEDMUTEX_LEVEL_NUMBER_VIOLATIONNO_USER_MODE_CONTEXTSPIN_LOCK_ALREADY_OWNEDSPIN_LOCK_NOT_OWNEDTHREAD_NOT_MUTEX_OWNERTRAP_CAUSE_UNKNOWNEMPTY_THREAD_REAPER_LISTCREATE_DELETE_LOCK_NOT_LOCKEDLAST_CHANCE_CALLED_FROM_KMODECID_HANDLE_CREATIONCID_HANDLE_DELETIONREFERENCE_BY_POINTERBAD_POOL_HEADERMEMORY_MANAGEMENTPFN_SHARE_COUNTPFN_REFERENCE_COUNTNO_SPIN_LOCK_AVAILABLEKMODE_EXCEPTION_NOT_HANDLEDSHARED_RESOURCE_CONV_ERRORKERNEL_APC_PENDING_DURING_EXITQUOTA_UNDERFLOWFILE_SYSTEMFAT_FILE_SYSTEMNTFS_FILE_SYSTEMNPFS_FILE_SYSTEMCDFS_FILE_SYSTEMRDR_FILE_SYSTEMCORRUPT_ACCESS_TOKENSECURITY_SYSTEMINCONSISTENT_IRPPANIC_STACK_SWITCHPORT_DRIVER_INTERNALSCSI_DISK_DRIVER_INTERNALDATA_BUS_ERRORINSTRUCTION_BUS_ERRORSET_OF_INVALID_CONTEXTPHASE0_INITIALIZATION_FAILEDPHASE1_INITIALIZATION_FAILEDUNEXPECTED_INITIALIZATION_CALLCACHE_MANAGERNO_MORE_IRP_STACK_LOCATIONSDEVICE_REFERENCE_COUNT_NOT_ZEROFLOPPY_INTERNAL_ERRORSERIAL_DRIVER_INTERNALSYSTEM_EXIT_OWNED_MUTEXSYSTEM_UNWIND_PREVIOUS_USERSYSTEM_SERVICE_EXCEPTIONINTERRUPT_UNWIND_ATTEMPTEDINTERRUPT_EXCEPTION_NOT_HANDLEDMULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTEDNO_MORE_SYSTEM_PTESTARGET_MDL_TOO_SMALLMUST_SUCCEED_POOL_EMPTYATDISK_DRIVER_INTERNALNO_SUCH_PARTITIONMULTIPLE_IRP_COMPLETE_REQUESTSINSUFFICIENT_SYSTEM_MAP_REGSDEREF_UNKNOWN_LOGON_SESSIONREF_UNKNOWN_LOGON_SESSIONCANCEL_STATE_IN_COMPLETED_IRPPAGE_FAULT_WITH_INTERRUPTS_OFFIRQL_GT_ZERO_AT_SYSTEM_SERVICESTREAMS_INTERNAL_ERRORFATAL_UNHANDLED_HARD_ERRORNO_PAGES_AVAILABLEPFN_LIST_CORRUPTNDIS_INTERNAL_ERRORPAGE_FAULT_IN_NONPAGED_AREAPAGE_FAULT_IN_NONPAGED_AREA_MREGISTRY_ERRORMAILSLOT_FILE_SYSTEMNO_BOOT_DEVICELM_SERVER_INTERNAL_ERRORDATA_COHERENCY_EXCEPTIONINSTRUCTION_COHERENCY_EXCEPTIONXNS_INTERNAL_ERRORVOLMGRX_INTERNAL_ERRORPINBALL_FILE_SYSTEMCRITICAL_SERVICE_FAILEDSET_ENV_VAR_FAILEDHAL_INITIALIZATION_FAILEDUNSUPPORTED_PROCESSOROBJECT_INITIALIZATION_FAILEDSECURITY_INITIALIZATION_FAILEDPROCESS_INITIALIZATION_FAILEDHAL1_INITIALIZATION_FAILEDOBJECT1_INITIALIZATION_FAILEDSECURITY1_INITIALIZATION_FAILEDSYMBOLIC_INITIALIZATION_FAILEDMEMORY1_INITIALIZATION_FAILEDCACHE_INITIALIZATION_FAILEDCONFIG_INITIALIZATION_FAILEDFILE_INITIALIZATION_FAILEDIO1_INITIALIZATION_FAILEDLPC_INITIALIZATION_FAILEDPROCESS1_INITIALIZATION_FAILEDREFMON_INITIALIZATION_FAILEDSESSION1_INITIALIZATION_FAILEDBOOTPROC_INITIALIZATION_FAILEDVSL_INITIALIZATION_FAILEDSOFT_RESTART_FATAL_ERRORASSIGN_DRIVE_LETTERS_FAILEDCONFIG_LIST_FAILEDBAD_SYSTEM_CONFIG_INFOCANNOT_WRITE_CONFIGURATIONPROCESS_HAS_LOCKED_PAGESKERNEL_STACK_INPAGE_ERRORPHASE0_EXCEPTIONMISMATCHED_HALKERNEL_DATA_INPAGE_ERRORINACCESSIBLE_BOOT_DEVICEBUGCODE_NDIS_DRIVERINSTALL_MORE_MEMORYSYSTEM_THREAD_EXCEPTION_NOT_HANDLEDSYSTEM_THREAD_EXCEPTION_NOT_HANDLED_MUNEXPECTED_KERNEL_MODE_TRAPUNEXPECTED_KERNEL_MODE_TRAP_MNMI_HARDWARE_FAILURESPIN_LOCK_INIT_FAILUREDFS_FILE_SYSTEMOFS_FILE_SYSTEMRECOM_DRIVERSETUP_FAILUREAUDIT_FAILUREMBR_CHECKSUM_MISMATCHKERNEL_MODE_EXCEPTION_NOT_HANDLEDKERNEL_MODE_EXCEPTION_NOT_HANDLED_MPP0_INITIALIZATION_FAILEDPP1_INITIALIZATION_FAILEDWIN32K_INIT_OR_RIT_FAILUREUP_DRIVER_ON_MP_SYSTEMINVALID_KERNEL_HANDLEKERNEL_STACK_LOCKED_AT_EXITPNP_INTERNAL_ERRORINVALID_WORK_QUEUE_ITEMBOUND_IMAGE_UNSUPPORTEDEND_OF_NT_EVALUATION_PERIODINVALID_REGION_OR_SEGMENTSYSTEM_LICENSE_VIOLATIONUDFS_FILE_SYSTEMMACHINE_CHECK_EXCEPTIONUSER_MODE_HEALTH_MONITORDRIVER_POWER_STATE_FAILUREINTERNAL_POWER_ERRORPCI_BUS_DRIVER_INTERNALMEMORY_IMAGE_CORRUPTACPI_DRIVER_INTERNALCNSS_FILE_SYSTEM_FILTERACPI_BIOS_ERRORFP_EMULATION_ERRORBAD_EXHANDLEBOOTING_IN_SAFEMODE_MINIMALBOOTING_IN_SAFEMODE_NETWORKBOOTING_IN_SAFEMODE_DSREPAIRSESSION_HAS_VALID_POOL_ON_EXITHAL_MEMORY_ALLOCATIONVIDEO_DRIVER_DEBUG_REPORT_REQUESTBGI_DETECTED_VIOLATIONVIDEO_DRIVER_INIT_FAILUREBOOTLOG_LOADEDBOOTLOG_NOT_LOADEDBOOTLOG_ENABLEDATTEMPTED_SWITCH_FROM_DPCCHIPSET_DETECTED_ERRORSESSION_HAS_VALID_VIEWS_ON_EXITNETWORK_BOOT_INITIALIZATION_FAILEDNETWORK_BOOT_DUPLICATE_ADDRESSINVALID_HIBERNATED_STATEATTEMPTED_WRITE_TO_READONLY_MEMORYMUTEX_ALREADY_OWNEDPCI_CONFIG_SPACE_ACCESS_FAILURESPECIAL_POOL_DETECTED_MEMORY_CORRUPTIONBAD_POOL_CALLERSYSTEM_IMAGE_BAD_SIGNATUREDRIVER_VERIFIER_DETECTED_VIOLATIONDRIVER_CORRUPTED_EXPOOLDRIVER_CAUGHT_MODIFYING_FREED_POOLTIMER_OR_DPC_INVALIDIRQL_UNEXPECTED_VALUEDRIVER_VERIFIER_IOMANAGER_VIOLATIONPNP_DETECTED_FATAL_ERRORDRIVER_LEFT_LOCKED_PAGES_IN_PROCESSPAGE_FAULT_IN_FREED_SPECIAL_POOLPAGE_FAULT_BEYOND_END_OF_ALLOCATIONDRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONSTERMINAL_SERVER_DRIVER_MADE_INCORRECT_MEMORY_REFERENCEDRIVER_CORRUPTED_MMPOOLDRIVER_IRQL_NOT_LESS_OR_EQUALBUGCODE_ID_DRIVERDRIVER_PORTION_MUST_BE_NONPAGEDSYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOADDRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOLDRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATIONDRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION_MDRIVER_UNMAPPING_INVALID_VIEWDRIVER_USED_EXCESSIVE_PTESLOCKED_PAGES_TRACKER_CORRUPTIONSYSTEM_PTE_MISUSEDRIVER_CORRUPTED_SYSPTESDRIVER_INVALID_STACK_ACCESSPOOL_CORRUPTION_IN_FILE_AREAIMPERSONATING_WORKER_THREADACPI_BIOS_FATAL_ERRORWORKER_THREAD_RETURNED_AT_BAD_IRQLMANUALLY_INITIATED_CRASHRESOURCE_NOT_OWNEDWORKER_INVALIDPOWER_FAILURE_SIMULATEDRIVER_VERIFIER_DMA_VIOLATIONINVALID_FLOATING_POINT_STATEINVALID_CANCEL_OF_FILE_OPENACTIVE_EX_WORKER_THREAD_TERMINATIONSAVER_UNSPECIFIEDSAVER_BLANKSCREENSAVER_INPUTSAVER_WATCHDOGSAVER_STARTNOTVISIBLESAVER_NAVIGATIONMODELSAVER_OUTOFMEMORYSAVER_GRAPHICSSAVER_NAVSERVERTIMEOUTSAVER_CHROMEPROCESSCRASHSAVER_NOTIFICATIONDISMISSALSAVER_SPEECHDISMISSALSAVER_CALLDISMISSALSAVER_APPBARDISMISSALSAVER_RILADAPTATIONCRASHSAVER_APPLISTUNREACHABLESAVER_REPORTNOTIFICATIONFAILURESAVER_UNEXPECTEDSHUTDOWNSAVER_RPCFAILURESAVER_AUXILIARYFULLDUMPSAVER_ACCOUNTPROVSVCINITFAILURESAVER_MTBFCOMMANDTIMEOUTSAVER_MTBFCOMMANDHANGSAVER_MTBFPASSBUGCHECKSAVER_MTBFIOERRORSAVER_RENDERTHREADHANGSAVER_RENDERMOBILEUIOOMSAVER_DEVICEUPDATEUNSPECIFIEDSAVER_AUDIODRIVERHANGSAVER_BATTERYPULLOUTSAVER_MEDIACORETESTHANGSAVER_RESOURCEMANAGEMENTSAVER_CAPTURESERVICESAVER_WAITFORSHELLREADYSAVER_NONRESPONSIVEPROCESSSAVER_SICKAPPLICATIONTHREAD_STUCK_IN_DEVICE_DRIVERTHREAD_STUCK_IN_DEVICE_DRIVER_MDIRTY_MAPPED_PAGES_CONGESTIONSESSION_HAS_VALID_SPECIAL_POOL_ON_EXITUNMOUNTABLE_BOOT_VOLUMECRITICAL_PROCESS_DIEDSTORAGE_MINIPORT_ERRORSCSI_VERIFIER_DETECTED_VIOLATIONHARDWARE_INTERRUPT_STORMDISORDERLY_SHUTDOWNCRITICAL_OBJECT_TERMINATIONFLTMGR_FILE_SYSTEMPCI_VERIFIER_DETECTED_VIOLATIONDRIVER_OVERRAN_STACK_BUFFERRAMDISK_BOOT_INITIALIZATION_FAILEDDRIVER_RETURNED_STATUS_REPARSE_FOR_VOLUME_OPENHTTP_DRIVER_CORRUPTEDRECURSIVE_MACHINE_CHECKATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORYDIRTY_NOWRITE_PAGES_CONGESTIONBUGCODE_USB_DRIVERBC_BLUETOOTH_VERIFIER_FAULTBC_BTHMINI_VERIFIER_FAULTRESERVE_QUEUE_OVERFLOWLOADER_BLOCK_MISMATCHCLOCK_WATCHDOG_TIMEOUTDPC_WATCHDOG_TIMEOUTMUP_FILE_SYSTEMAGP_INVALID_ACCESSAGP_GART_CORRUPTIONAGP_ILLEGALLY_REPROGRAMMEDKERNEL_EXPAND_STACK_ACTIVETHIRD_PARTY_FILE_SYSTEM_FAILURECRITICAL_STRUCTURE_CORRUPTIONAPP_TAGGING_INITIALIZATION_FAILEDDFSC_FILE_SYSTEMFSRTL_EXTRA_CREATE_PARAMETER_VIOLATIONWDF_VIOLATIONVIDEO_MEMORY_MANAGEMENT_INTERNALDRIVER_INVALID_CRUNTIME_PARAMETERRECURSIVE_NMIMSRPC_STATE_VIOLATIONVIDEO_DXGKRNL_FATAL_ERRORVIDEO_SHADOW_DRIVER_FATAL_ERRORAGP_INTERNALVIDEO_TDR_FAILUREVIDEO_TDR_TIMEOUT_DETECTEDNTHV_GUEST_ERRORVIDEO_SCHEDULER_INTERNAL_ERROREM_INITIALIZATION_ERRORDRIVER_RETURNED_HOLDING_CANCEL_LOCKATTEMPTED_WRITE_TO_CM_PROTECTED_STORAGEEVENT_TRACING_FATAL_ERRORTOO_MANY_RECURSIVE_FAULTSINVALID_DRIVER_HANDLEBITLOCKER_FATAL_ERRORDRIVER_VIOLATIONWHEA_INTERNAL_ERRORCRYPTO_SELF_TEST_FAILUREWHEA_UNCORRECTABLE_ERRORNMR_INVALID_STATENETIO_INVALID_POOL_CALLERPAGE_NOT_ZEROWORKER_THREAD_RETURNED_WITH_BAD_IO_PRIORITYWORKER_THREAD_RETURNED_WITH_BAD_PAGING_IO_PRIORITYMUI_NO_VALID_SYSTEM_LANGUAGEFAULTY_HARDWARE_CORRUPTED_PAGEEXFAT_FILE_SYSTEMVOLSNAP_OVERLAPPED_TABLE_ACCESSINVALID_MDL_RANGEVHD_BOOT_INITIALIZATION_FAILEDDYNAMIC_ADD_PROCESSOR_MISMATCHINVALID_EXTENDED_PROCESSOR_STATERESOURCE_OWNER_POINTER_INVALIDDPC_WATCHDOG_VIOLATIONDRIVE_EXTENDERREGISTRY_FILTER_DRIVER_EXCEPTIONVHD_BOOT_HOST_VOLUME_NOT_ENOUGH_SPACEWIN32K_HANDLE_MANAGERGPIO_CONTROLLER_DRIVER_ERRORKERNEL_SECURITY_CHECK_FAILUREKERNEL_MODE_HEAP_CORRUPTIONPASSIVE_INTERRUPT_ERRORINVALID_IO_BOOST_STATECRITICAL_INITIALIZATION_FAILUREERRATA_WORKAROUND_UNSUCCESSFULSTORAGE_DEVICE_ABNORMALITY_DETECTEDVIDEO_ENGINE_TIMEOUT_DETECTEDVIDEO_TDR_APPLICATION_BLOCKEDPROCESSOR_DRIVER_INTERNALBUGCODE_USB3_DRIVERSECURE_BOOT_VIOLATIONNDIS_NET_BUFFER_LIST_INFO_ILLEGALLY_TRANSFERREDABNORMAL_RESET_DETECTEDIO_OBJECT_INVALIDREFS_FILE_SYSTEMKERNEL_WMI_INTERNALSOC_SUBSYSTEM_FAILUREFATAL_ABNORMAL_RESET_ERROREXCEPTION_SCOPE_INVALIDSOC_CRITICAL_DEVICE_REMOVEDPDC_WATCHDOG_TIMEOUTTCPIP_AOAC_NIC_ACTIVE_REFERENCE_LEAKUNSUPPORTED_INSTRUCTION_MODEINVALID_PUSH_LOCK_FLAGSKERNEL_LOCK_ENTRY_LEAKED_ON_THREAD_TERMINATIONUNEXPECTED_STORE_EXCEPTIONOS_DATA_TAMPERINGWINSOCK_DETECTED_HUNG_CLOSESOCKET_LIVEDUMPKERNEL_THREAD_PRIORITY_FLOOR_VIOLATIONILLEGAL_IOMMU_PAGE_FAULTHAL_ILLEGAL_IOMMU_PAGE_FAULTSDBUS_INTERNAL_ERRORWORKER_THREAD_RETURNED_WITH_SYSTEM_PAGE_PRIORITY_ACTIVEPDC_WATCHDOG_TIMEOUT_LIVEDUMPSOC_SUBSYSTEM_FAILURE_LIVEDUMPBUGCODE_NDIS_DRIVER_LIVE_DUMPCONNECTED_STANDBY_WATCHDOG_TIMEOUT_LIVEDUMPWIN32K_ATOMIC_CHECK_FAILURELIVE_SYSTEM_DUMPKERNEL_AUTO_BOOST_INVALID_LOCK_RELEASEWORKER_THREAD_TEST_CONDITIONWIN32K_CRITICAL_FAILURECLUSTER_CSV_STATUS_IO_TIMEOUT_LIVEDUMPCLUSTER_RESOURCE_CALL_TIMEOUT_LIVEDUMPCLUSTER_CSV_SNAPSHOT_DEVICE_INFO_TIMEOUT_LIVEDUMPCLUSTER_CSV_STATE_TRANSITION_TIMEOUT_LIVEDUMPCLUSTER_CSV_VOLUME_ARRIVAL_LIVEDUMPCLUSTER_CSV_VOLUME_REMOVAL_LIVEDUMPCLUSTER_CSV_CLUSTER_WATCHDOG_LIVEDUMPINVALID_RUNDOWN_PROTECTION_FLAGSINVALID_SLOT_ALLOCATOR_FLAGSERESOURCE_INVALID_RELEASECLUSTER_CSV_STATE_TRANSITION_INTERVAL_TIMEOUT_LIVEDUMPCLUSTER_CSV_CLUSSVC_DISCONNECT_WATCHDOGCRYPTO_LIBRARY_INTERNAL_ERRORCOREMSGCALL_INTERNAL_ERRORCOREMSG_INTERNAL_ERRORPREVIOUS_FATAL_ABNORMAL_RESET_ERRORELAM_DRIVER_DETECTED_FATAL_ERRORPDC_LOCK_WATCHDOG_LIVEDUMPPDC_UNEXPECTED_REVOCATION_LIVEDUMPWVR_LIVEDUMP_REPLICATION_IOCONTEXT_TIMEOUTWVR_LIVEDUMP_STATE_TRANSITION_TIMEOUTWVR_LIVEDUMP_RECOVERY_IOCONTEXT_TIMEOUTWVR_LIVEDUMP_APP_IO_TIMEOUTWVR_LIVEDUMP_MANUALLY_INITIATEDWVR_LIVEDUMP_STATE_FAILUREWVR_LIVEDUMP_CRITICAL_ERRORVIDEO_DWMINIT_TIMEOUT_FALLBACK_BDDCLUSTER_CSVFS_LIVEDUMPBAD_OBJECT_HEADERSILO_CORRUPTSECURE_KERNEL_ERRORHYPERGUARD_VIOLATIONWIN32K_CRITICAL_FAILURE_LIVEDUMPPF_DETECTED_CORRUPTIONKERNEL_AUTO_BOOST_LOCK_ACQUISITION_WITH_RAISED_IRQLVIDEO_DXGKRNL_LIVEDUMPKERNEL_STORAGE_SLOT_IN_USESMB_SERVER_LIVEDUMPLOADER_ROLLBACK_DETECTEDWIN32K_SECURITY_FAILUREUFX_LIVEDUMPWORKER_THREAD_RETURNED_WHILE_ATTACHED_TO_SILOTTM_FATAL_ERRORWIN32K_POWER_WATCHDOG_TIMEOUTCLUSTER_SVHDX_LIVEDUMPDRIVER_VERIFIER_DETECTED_VIOLATION_LIVEDUMPIO_THREADPOOL_DEADLOCK_LIVEDUMPXBOX_CORRUPTED_IMAGEXBOX_INVERTED_FUNCTION_TABLE_OVERFLOWXBOX_CORRUPTED_IMAGE_BASEXBOX_360_SYSTEM_CRASHXBOX_360_SYSTEM_CRASH_RESERVEDHYPERVISOR_ERRORWINLOGON_FATAL_ERRORMANUALLY_INITIATED_CRASH1BUGCHECK_CONTEXT_MODIFIER//! Definitions of system bug check codesCDERR_DIALOGFAILURECDERR_GENERALCODESCDERR_STRUCTSIZECDERR_INITIALIZATIONCDERR_NOTEMPLATECDERR_NOHINSTANCECDERR_LOADSTRFAILURECDERR_FINDRESFAILURECDERR_LOADRESFAILURECDERR_LOCKRESFAILURECDERR_MEMALLOCFAILURECDERR_MEMLOCKFAILURECDERR_NOHOOKCDERR_REGISTERMSGFAILPDERR_PRINTERCODESPDERR_SETUPFAILUREPDERR_PARSEFAILUREPDERR_RETDEFFAILUREPDERR_LOADDRVFAILUREPDERR_GETDEVMODEFAILPDERR_INITFAILUREPDERR_NODEVICESPDERR_NODEFAULTPRNPDERR_DNDMMISMATCHPDERR_CREATEICFAILUREPDERR_PRINTERNOTFOUNDPDERR_DEFAULTDIFFERENTCFERR_CHOOSEFONTCODESCFERR_NOFONTSCFERR_MAXLESSTHANMINFNERR_FILENAMECODESFNERR_SUBCLASSFAILUREFNERR_INVALIDFILENAMEFNERR_BUFFERTOOSMALLFRERR_FINDREPLACECODESFRERR_BUFFERLENGTHZEROCCERR_CHOOSECOLORCODES//! Common dialog error return codesPPNP_VETO_TYPEPNP_VETO_TYPECM_PROB_NOT_CONFIGUREDCM_PROB_DEVLOADER_FAILEDCM_PROB_OUT_OF_MEMORYCM_PROB_ENTRY_IS_WRONG_TYPECM_PROB_LACKED_ARBITRATORCM_PROB_BOOT_CONFIG_CONFLICTCM_PROB_FAILED_FILTERCM_PROB_DEVLOADER_NOT_FOUNDCM_PROB_INVALID_DATACM_PROB_FAILED_STARTCM_PROB_LIARCM_PROB_NORMAL_CONFLICTCM_PROB_NOT_VERIFIEDCM_PROB_NEED_RESTARTCM_PROB_REENUMERATIONCM_PROB_PARTIAL_LOG_CONFCM_PROB_UNKNOWN_RESOURCECM_PROB_REINSTALLCM_PROB_REGISTRYCM_PROB_VXDLDRCM_PROB_WILL_BE_REMOVEDCM_PROB_DISABLEDCM_PROB_DEVLOADER_NOT_READYCM_PROB_DEVICE_NOT_THERECM_PROB_MOVEDCM_PROB_TOO_EARLYCM_PROB_NO_VALID_LOG_CONFCM_PROB_FAILED_INSTALLCM_PROB_HARDWARE_DISABLEDCM_PROB_CANT_SHARE_IRQCM_PROB_FAILED_ADDCM_PROB_DISABLED_SERVICECM_PROB_TRANSLATION_FAILEDCM_PROB_NO_SOFTCONFIGCM_PROB_BIOS_TABLECM_PROB_IRQ_TRANSLATION_FAILEDCM_PROB_FAILED_DRIVER_ENTRYCM_PROB_DRIVER_FAILED_PRIOR_UNLOADCM_PROB_DRIVER_FAILED_LOADCM_PROB_DRIVER_SERVICE_KEY_INVALIDCM_PROB_LEGACY_SERVICE_NO_DEVICESCM_PROB_DUPLICATE_DEVICECM_PROB_FAILED_POST_STARTCM_PROB_HALTEDCM_PROB_PHANTOMCM_PROB_SYSTEM_SHUTDOWNCM_PROB_HELD_FOR_EJECTCM_PROB_DRIVER_BLOCKEDCM_PROB_REGISTRY_TOO_LARGECM_PROB_SETPROPERTIES_FAILEDCM_PROB_WAITING_ON_DEPENDENCYCM_PROB_UNSIGNED_DRIVERCM_PROB_USED_BY_DEBUGGERNUM_CM_PROB_V1NUM_CM_PROB_V2NUM_CM_PROB_V3NUM_CM_PROB_V4NUM_CM_PROB_V5NUM_CM_PROB_V6DN_ROOT_ENUMERATEDDN_DRIVER_LOADEDDN_ENUM_LOADEDDN_STARTEDDN_MANUALDN_NEED_TO_ENUMDN_NOT_FIRST_TIMEDN_HARDWARE_ENUMDN_LIARDN_HAS_MARKDN_HAS_PROBLEMDN_FILTEREDDN_MOVEDDN_DISABLEABLEDN_REMOVABLEDN_PRIVATE_PROBLEMDN_MF_PARENTDN_MF_CHILDDN_WILL_BE_REMOVEDDN_NOT_FIRST_TIMEEDN_STOP_FREE_RESDN_REBAL_CANDIDATEDN_BAD_PARTIALDN_NT_ENUMERATORDN_NT_DRIVERDN_NEEDS_LOCKINGDN_ARM_WAKEUPDN_APM_ENUMERATORDN_APM_DRIVERDN_SILENT_INSTALLDN_NO_SHOW_IN_DMDN_BOOT_LOG_PROBDN_NEED_RESTARTDN_DRIVER_BLOCKEDDN_LEGACY_DRIVERDN_CHILD_WITH_INVALID_IDDN_DEVICE_DISCONNECTEDDN_CHANGEABLE_FLAGSLCPRI_FORCECONFIGLCPRI_BOOTCONFIGLCPRI_DESIREDLCPRI_NORMALLCPRI_LASTBESTCONFIGLCPRI_SUBOPTIMALLCPRI_LASTSOFTCONFIGLCPRI_RESTARTLCPRI_REBOOTLCPRI_POWEROFFLCPRI_HARDRECONFIGLCPRI_HARDWIREDLCPRI_IMPOSSIBLELCPRI_DISABLEDMAX_LCPRI//! common Configuration Manager definitions for both user mode and kernel mode coded3d9capsD3DCAPS9D3DCONTENTPROTECTIONCAPSD3DOVERLAYCAPSd3d9typesD3DADAPTER_IDENTIFIER9D3DAUTHENTICATEDCHANNELTYPED3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUTD3DBACKBUFFER_TYPED3DBOXD3DCLIPSTATUS9D3DCOLORD3DCOMPOSERECTSOPD3DCUBEMAP_FACESD3DDEVICE_CREATION_PARAMETERSD3DDEVTYPED3DDISPLAYMODED3DDISPLAYMODEEXD3DDISPLAYMODEFILTERD3DDISPLAYROTATIOND3DENCRYPTED_BLOCK_INFOD3DFORMATD3DGAMMARAMPD3DINDEXBUFFER_DESCD3DLIGHT9D3DLOCKED_BOXD3DLOCKED_RECTD3DMATERIAL9D3DMATRIXD3DMULTISAMPLE_TYPED3DPOOLD3DPRESENTSTATSD3DPRESENT_PARAMETERSD3DPRIMITIVETYPED3DQUERYTYPED3DRASTER_STATUSD3DRECTD3DRECTPATCH_INFOD3DRENDERSTATETYPED3DRESOURCETYPED3DSAMPLERSTATETYPED3DSTATEBLOCKTYPED3DSURFACE_DESCD3DTEXTUREFILTERTYPED3DTEXTURESTAGESTATETYPED3DTRANSFORMSTATETYPED3DTRIPATCH_INFOD3DVERTEXBUFFER_DESCD3DVERTEXELEMENT9D3DVIEWPORT9D3DVOLUME_DESCunknwnbasewingdiPALETTEENTRYRGNDATAD3D_SDK_VERSIOND3D9b_SDK_VERSIONDirect3DCreate9IDirect3D9D3DPERF_BeginEventD3DPERF_EndEventD3DPERF_SetMarkerD3DPERF_SetRegionD3DPERF_QueryRepeatFrameD3DPERF_SetOptionsD3DPERF_GetStatusLPDIRECT3D9PDIRECT3D9LPDIRECT3DDEVICE9IDirect3DDevice9PDIRECT3DDEVICE9LPDIRECT3DSTATEBLOCK9IDirect3DStateBlock9PDIRECT3DSTATEBLOCK9LPDIRECT3DSWAPCHAIN9IDirect3DSwapChain9PDIRECT3DSWAPCHAIN9LPDIRECT3DRESOURCE9IDirect3DResource9PDIRECT3DRESOURCE9LPDIRECT3DVERTEXDECLARATION9IDirect3DVertexDeclaration9PDIRECT3DVERTEXDECLARATION9LPDIRECT3DVERTEXSHADER9IDirect3DVertexShader9PDIRECT3DVERTEXSHADER9LPDIRECT3DPIXELSHADER9IDirect3DPixelShader9PDIRECT3DPIXELSHADER9LPDIRECT3DBASETEXTURE9IDirect3DBaseTexture9PDIRECT3DBASETEXTURE9LPDIRECT3DTEXTURE9IDirect3DTexture9PDIRECT3DTEXTURE9LPDIRECT3DVOLUMETEXTURE9IDirect3DVolumeTexture9PDIRECT3DVOLUMETEXTURE9LPDIRECT3DCUBETEXTURE9IDirect3DCubeTexture9PDIRECT3DCUBETEXTURE9LPDIRECT3DVERTEXBUFFER9IDirect3DVertexBuffer9PDIRECT3DVERTEXBUFFER9LPDIRECT3DINDEXBUFFER9IDirect3DIndexBuffer9PDIRECT3DINDEXBUFFER9LPDIRECT3DSURFACE9IDirect3DSurface9PDIRECT3DSURFACE9LPDIRECT3DVOLUME9IDirect3DVolume9PDIRECT3DVOLUME9LPDIRECT3DQUERY9IDirect3DQuery9PDIRECT3DQUERY9D3DCREATE_FPU_PRESERVED3DCREATE_MULTITHREADEDD3DCREATE_PUREDEVICED3DCREATE_SOFTWARE_VERTEXPROCESSINGD3DCREATE_HARDWARE_VERTEXPROCESSINGD3DCREATE_MIXED_VERTEXPROCESSINGD3DCREATE_DISABLE_DRIVER_MANAGEMENTD3DCREATE_ADAPTERGROUP_DEVICED3DCREATE_DISABLE_DRIVER_MANAGEMENT_EXD3DCREATE_NOWINDOWCHANGESD3DCREATE_DISABLE_PSGP_THREADINGD3DCREATE_ENABLE_PRESENTSTATSD3DCREATE_DISABLE_PRESENTSTATSD3DCREATE_SCREENSAVERD3DADAPTER_DEFAULTDirect3DCreate9ExIDirect3D9ExLPDIRECT3D9EXPDIRECT3D9EXLPDIRECT3DDEVICE9EXIDirect3DDevice9ExPDIRECT3DDEVICE9EXLPDIRECT3DSWAPCHAIN9EXIDirect3DSwapChain9ExPDIRECT3DSWAPCHAIN9EXLPDIRECT3D9EXOVERLAYEXTENSIONIDirect3D9ExOverlayExtensionPDIRECT3D9EXOVERLAYEXTENSIONLPDIRECT3DDEVICE9VIDEOIDirect3DDevice9VideoPDIRECT3DDEVICE9VIDEOLPDIRECT3DAUTHENTICATEDCHANNEL9IDirect3DAuthenticatedChannel9PDIRECT3DAUTHENTICATEDCHANNEL9LPDIRECT3DCRYPTOSESSION9IDirect3DCryptoSession9PDIRECT3DCRYPTOSESSION9//! Direct3D include fileD3DVS20CAPS_PREDICATIOND3DVS20_MAX_DYNAMICFLOWCONTROLDEPTHD3DVS20_MIN_DYNAMICFLOWCONTROLDEPTHD3DVS20_MAX_NUMTEMPSD3DVS20_MIN_NUMTEMPSD3DVS20_MAX_STATICFLOWCONTROLDEPTHD3DVS20_MIN_STATICFLOWCONTROLDEPTHD3DPS20CAPS_ARBITRARYSWIZZLED3DPS20CAPS_GRADIENTINSTRUCTIONSD3DPS20CAPS_PREDICATIOND3DPS20CAPS_NODEPENDENTREADLIMITD3DPS20CAPS_NOTEXINSTRUCTIONLIMITD3DPS20_MAX_DYNAMICFLOWCONTROLDEPTHD3DPS20_MIN_DYNAMICFLOWCONTROLDEPTHD3DPS20_MAX_NUMTEMPSD3DPS20_MIN_NUMTEMPSD3DPS20_MAX_STATICFLOWCONTROLDEPTHD3DPS20_MIN_STATICFLOWCONTROLDEPTHD3DPS20_MAX_NUMINSTRUCTIONSLOTSD3DPS20_MIN_NUMINSTRUCTIONSLOTSD3DMIN30SHADERINSTRUCTIONSD3DMAX30SHADERINSTRUCTIONSD3DOVERLAYCAPS_FULLRANGERGBD3DOVERLAYCAPS_LIMITEDRANGERGBD3DOVERLAYCAPS_YCbCr_BT601D3DOVERLAYCAPS_YCbCr_BT709D3DOVERLAYCAPS_YCbCr_BT601_xvYCCD3DOVERLAYCAPS_YCbCr_BT709_xvYCCD3DOVERLAYCAPS_STRETCHXD3DOVERLAYCAPS_STRETCHY// FIXME packed(4)D3DCPCAPS_SOFTWARED3DCPCAPS_HARDWARED3DCPCAPS_PROTECTIONALWAYSOND3DCPCAPS_PARTIALDECRYPTIOND3DCPCAPS_CONTENTKEYD3DCPCAPS_FRESHENSESSIONKEYD3DCPCAPS_ENCRYPTEDREADBACKD3DCPCAPS_ENCRYPTEDREADBACKKEYD3DCPCAPS_SEQUENTIAL_CTR_IVD3DCPCAPS_ENCRYPTSLICEDATAONLYD3DCAPS_OVERLAYD3DCAPS_READ_SCANLINED3DCAPS2_FULLSCREENGAMMAD3DCAPS2_CANCALIBRATEGAMMAD3DCAPS2_RESERVEDD3DCAPS2_CANMANAGERESOURCED3DCAPS2_DYNAMICTEXTURESD3DCAPS2_CANAUTOGENMIPMAPD3DCAPS2_CANSHARERESOURCED3DCAPS3_RESERVEDD3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARDD3DCAPS3_LINEAR_TO_SRGB_PRESENTATIOND3DCAPS3_COPY_TO_VIDMEMD3DCAPS3_COPY_TO_SYSTEMMEMD3DCAPS3_DXVAHDD3DCAPS3_DXVAHD_LIMITEDD3DPRESENT_INTERVAL_DEFAULTD3DPRESENT_INTERVAL_ONED3DPRESENT_INTERVAL_TWOD3DPRESENT_INTERVAL_THREED3DPRESENT_INTERVAL_FOURD3DPRESENT_INTERVAL_IMMEDIATED3DCURSORCAPS_COLORD3DCURSORCAPS_LOWRESD3DDEVCAPS_EXECUTESYSTEMMEMORYD3DDEVCAPS_EXECUTEVIDEOMEMORYD3DDEVCAPS_TLVERTEXSYSTEMMEMORYD3DDEVCAPS_TLVERTEXVIDEOMEMORYD3DDEVCAPS_TEXTURESYSTEMMEMORYD3DDEVCAPS_TEXTUREVIDEOMEMORYD3DDEVCAPS_DRAWPRIMTLVERTEXD3DDEVCAPS_CANRENDERAFTERFLIPD3DDEVCAPS_TEXTURENONLOCALVIDMEMD3DDEVCAPS_DRAWPRIMITIVES2D3DDEVCAPS_SEPARATETEXTUREMEMORIESD3DDEVCAPS_DRAWPRIMITIVES2EXD3DDEVCAPS_HWTRANSFORMANDLIGHTD3DDEVCAPS_CANBLTSYSTONONLOCALD3DDEVCAPS_HWRASTERIZATIOND3DDEVCAPS_PUREDEVICED3DDEVCAPS_QUINTICRTPATCHESD3DDEVCAPS_RTPATCHESD3DDEVCAPS_RTPATCHHANDLEZEROD3DDEVCAPS_NPATCHESD3DPMISCCAPS_MASKZD3DPMISCCAPS_CULLNONED3DPMISCCAPS_CULLCWD3DPMISCCAPS_CULLCCWD3DPMISCCAPS_COLORWRITEENABLED3DPMISCCAPS_CLIPPLANESCALEDPOINTSD3DPMISCCAPS_CLIPTLVERTSD3DPMISCCAPS_TSSARGTEMPD3DPMISCCAPS_BLENDOPD3DPMISCCAPS_NULLREFERENCED3DPMISCCAPS_INDEPENDENTWRITEMASKSD3DPMISCCAPS_PERSTAGECONSTANTD3DPMISCCAPS_FOGANDSPECULARALPHAD3DPMISCCAPS_SEPARATEALPHABLENDD3DPMISCCAPS_MRTINDEPENDENTBITDEPTHSD3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDINGD3DPMISCCAPS_FOGVERTEXCLAMPEDD3DPMISCCAPS_POSTBLENDSRGBCONVERTD3DLINECAPS_TEXTURED3DLINECAPS_ZTESTD3DLINECAPS_BLENDD3DLINECAPS_ALPHACMPD3DLINECAPS_FOGD3DLINECAPS_ANTIALIASD3DPRASTERCAPS_DITHERD3DPRASTERCAPS_ZTESTD3DPRASTERCAPS_FOGVERTEXD3DPRASTERCAPS_FOGTABLED3DPRASTERCAPS_MIPMAPLODBIASD3DPRASTERCAPS_ZBUFFERLESSHSRD3DPRASTERCAPS_FOGRANGED3DPRASTERCAPS_ANISOTROPYD3DPRASTERCAPS_WBUFFERD3DPRASTERCAPS_WFOGD3DPRASTERCAPS_ZFOGD3DPRASTERCAPS_COLORPERSPECTIVED3DPRASTERCAPS_SCISSORTESTD3DPRASTERCAPS_SLOPESCALEDEPTHBIASD3DPRASTERCAPS_DEPTHBIASD3DPRASTERCAPS_MULTISAMPLE_TOGGLED3DPCMPCAPS_NEVERD3DPCMPCAPS_LESSD3DPCMPCAPS_EQUALD3DPCMPCAPS_LESSEQUALD3DPCMPCAPS_GREATERD3DPCMPCAPS_NOTEQUALD3DPCMPCAPS_GREATEREQUALD3DPCMPCAPS_ALWAYSD3DPBLENDCAPS_ZEROD3DPBLENDCAPS_ONED3DPBLENDCAPS_SRCCOLORD3DPBLENDCAPS_INVSRCCOLORD3DPBLENDCAPS_SRCALPHAD3DPBLENDCAPS_INVSRCALPHAD3DPBLENDCAPS_DESTALPHAD3DPBLENDCAPS_INVDESTALPHAD3DPBLENDCAPS_DESTCOLORD3DPBLENDCAPS_INVDESTCOLORD3DPBLENDCAPS_SRCALPHASATD3DPBLENDCAPS_BOTHSRCALPHAD3DPBLENDCAPS_BOTHINVSRCALPHAD3DPBLENDCAPS_BLENDFACTORD3DPBLENDCAPS_SRCCOLOR2D3DPBLENDCAPS_INVSRCCOLOR2D3DPSHADECAPS_COLORGOURAUDRGBD3DPSHADECAPS_SPECULARGOURAUDRGBD3DPSHADECAPS_ALPHAGOURAUDBLENDD3DPSHADECAPS_FOGGOURAUDD3DPTEXTURECAPS_PERSPECTIVED3DPTEXTURECAPS_POW2D3DPTEXTURECAPS_ALPHAD3DPTEXTURECAPS_SQUAREONLYD3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZED3DPTEXTURECAPS_ALPHAPALETTED3DPTEXTURECAPS_NONPOW2CONDITIONALD3DPTEXTURECAPS_PROJECTEDD3DPTEXTURECAPS_CUBEMAPD3DPTEXTURECAPS_VOLUMEMAPD3DPTEXTURECAPS_MIPMAPD3DPTEXTURECAPS_MIPVOLUMEMAPD3DPTEXTURECAPS_MIPCUBEMAPD3DPTEXTURECAPS_CUBEMAP_POW2D3DPTEXTURECAPS_VOLUMEMAP_POW2D3DPTEXTURECAPS_NOPROJECTEDBUMPENVD3DPTFILTERCAPS_MINFPOINTD3DPTFILTERCAPS_MINFLINEARD3DPTFILTERCAPS_MINFANISOTROPICD3DPTFILTERCAPS_MINFPYRAMIDALQUADD3DPTFILTERCAPS_MINFGAUSSIANQUADD3DPTFILTERCAPS_MIPFPOINTD3DPTFILTERCAPS_MIPFLINEARD3DPTFILTERCAPS_CONVOLUTIONMONOD3DPTFILTERCAPS_MAGFPOINTD3DPTFILTERCAPS_MAGFLINEARD3DPTFILTERCAPS_MAGFANISOTROPICD3DPTFILTERCAPS_MAGFPYRAMIDALQUADD3DPTFILTERCAPS_MAGFGAUSSIANQUADD3DPTADDRESSCAPS_WRAPD3DPTADDRESSCAPS_MIRRORD3DPTADDRESSCAPS_CLAMPD3DPTADDRESSCAPS_BORDERD3DPTADDRESSCAPS_INDEPENDENTUVD3DPTADDRESSCAPS_MIRRORONCED3DSTENCILCAPS_KEEPD3DSTENCILCAPS_ZEROD3DSTENCILCAPS_REPLACED3DSTENCILCAPS_INCRSATD3DSTENCILCAPS_DECRSATD3DSTENCILCAPS_INVERTD3DSTENCILCAPS_INCRD3DSTENCILCAPS_DECRD3DSTENCILCAPS_TWOSIDEDD3DTEXOPCAPS_DISABLED3DTEXOPCAPS_SELECTARG1D3DTEXOPCAPS_SELECTARG2D3DTEXOPCAPS_MODULATED3DTEXOPCAPS_MODULATE2XD3DTEXOPCAPS_MODULATE4XD3DTEXOPCAPS_ADDD3DTEXOPCAPS_ADDSIGNEDD3DTEXOPCAPS_ADDSIGNED2XD3DTEXOPCAPS_SUBTRACTD3DTEXOPCAPS_ADDSMOOTHD3DTEXOPCAPS_BLENDDIFFUSEALPHAD3DTEXOPCAPS_BLENDTEXTUREALPHAD3DTEXOPCAPS_BLENDFACTORALPHAD3DTEXOPCAPS_BLENDTEXTUREALPHAPMD3DTEXOPCAPS_BLENDCURRENTALPHAD3DTEXOPCAPS_PREMODULATED3DTEXOPCAPS_MODULATEALPHA_ADDCOLORD3DTEXOPCAPS_MODULATECOLOR_ADDALPHAD3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLORD3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHAD3DTEXOPCAPS_BUMPENVMAPD3DTEXOPCAPS_BUMPENVMAPLUMINANCED3DTEXOPCAPS_DOTPRODUCT3D3DTEXOPCAPS_MULTIPLYADDD3DTEXOPCAPS_LERPD3DFVFCAPS_TEXCOORDCOUNTMASKD3DFVFCAPS_DONOTSTRIPELEMENTSD3DFVFCAPS_PSIZED3DVTXPCAPS_TEXGEND3DVTXPCAPS_MATERIALSOURCE7D3DVTXPCAPS_DIRECTIONALLIGHTSD3DVTXPCAPS_POSITIONALLIGHTSD3DVTXPCAPS_LOCALVIEWERD3DVTXPCAPS_TWEENINGD3DVTXPCAPS_TEXGEN_SPHEREMAPD3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWERD3DDEVCAPS2_STREAMOFFSETD3DDEVCAPS2_DMAPNPATCHD3DDEVCAPS2_ADAPTIVETESSRTPATCHD3DDEVCAPS2_ADAPTIVETESSNPATCHD3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURESD3DDEVCAPS2_PRESAMPLEDDMAPNPATCHD3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSETD3DDTCAPS_UBYTE4D3DDTCAPS_UBYTE4ND3DDTCAPS_SHORT2ND3DDTCAPS_SHORT4ND3DDTCAPS_USHORT2ND3DDTCAPS_USHORT4ND3DDTCAPS_UDEC3D3DDTCAPS_DEC3ND3DDTCAPS_FLOAT16_2D3DDTCAPS_FLOAT16_4//! Direct3D capabilities include fileLARGE_INTEGERD3DCOLOR_ARGBD3DCOLOR_RGBAD3DCOLOR_XRGBD3DCOLOR_XYUVD3DCOLOR_AYUVD3DCOLOR_COLORVALUED3DMAXUSERCLIPPLANESD3DCLIPPLANE0D3DCLIPPLANE1D3DCLIPPLANE2D3DCLIPPLANE3D3DCLIPPLANE4D3DCLIPPLANE5D3DCS_LEFTD3DCS_RIGHTD3DCS_TOPD3DCS_BOTTOMD3DCS_FRONTD3DCS_BACKD3DCS_PLANE0D3DCS_PLANE1D3DCS_PLANE2D3DCS_PLANE3D3DCS_PLANE4D3DCS_PLANE5D3DCS_ALLD3DCLEAR_TARGETD3DCLEAR_ZBUFFERD3DCLEAR_STENCILD3DTS_WORLDMATRIXD3DTS_WORLDD3DTS_WORLD1D3DTS_WORLD2D3DTS_WORLD3D3D_MAX_SIMULTANEOUS_RENDERTARGETSD3DRENDERSTATE_WRAPBIASD3DWRAP_UD3DWRAP_VD3DWRAP_WD3DWRAPCOORD_0D3DWRAPCOORD_1D3DWRAPCOORD_2D3DWRAPCOORD_3D3DCOLORWRITEENABLE_REDD3DCOLORWRITEENABLE_GREEND3DCOLORWRITEENABLE_BLUED3DCOLORWRITEENABLE_ALPHAD3DDMAPSAMPLERD3DVERTEXTEXTURESAMPLER0D3DVERTEXTEXTURESAMPLER1D3DVERTEXTEXTURESAMPLER2D3DVERTEXTEXTURESAMPLER3D3DTSS_TCI_PASSTHRUD3DTSS_TCI_CAMERASPACENORMALD3DTSS_TCI_CAMERASPACEPOSITIOND3DTSS_TCI_CAMERASPACEREFLECTIONVECTORD3DTSS_TCI_SPHEREMAPD3DTA_SELECTMASKD3DTA_DIFFUSED3DTA_CURRENTD3DTA_TEXTURED3DTA_TFACTORD3DTA_SPECULARD3DTA_TEMPD3DTA_CONSTANTD3DTA_COMPLEMENTD3DTA_ALPHAREPLICATED3DPV_DONOTCOPYDATAD3DFVF_RESERVED0D3DFVF_POSITION_MASKD3DFVF_XYZD3DFVF_XYZRHWD3DFVF_XYZB1D3DFVF_XYZB2D3DFVF_XYZB3D3DFVF_XYZB4D3DFVF_XYZB5D3DFVF_XYZWD3DFVF_NORMALD3DFVF_PSIZED3DFVF_DIFFUSED3DFVF_SPECULARD3DFVF_TEXCOUNT_MASKD3DFVF_TEXCOUNT_SHIFTD3DFVF_TEX0D3DFVF_TEX1D3DFVF_TEX2D3DFVF_TEX3D3DFVF_TEX4D3DFVF_TEX5D3DFVF_TEX6D3DFVF_TEX7D3DFVF_TEX8D3DFVF_LASTBETA_UBYTE4D3DFVF_LASTBETA_D3DCOLORD3DFVF_RESERVED2MAXD3DDECLUSAGED3DDECLUSAGEMAXD3DDECLUSAGEINDEXMAXD3DDECLLENGTHMAXD3DDECLMETHODD3DDECLMETHODMAXD3DDECLTYPED3DDECLTYPELPD3DVERTEXELEMENT9D3DDECL_ENDD3DDP_MAXTEXCOORDD3DSTREAMSOURCE_INDEXEDDATAD3DSTREAMSOURCE_INSTANCEDATAD3DSI_OPCODE_MASKD3DSI_INSTLENGTH_MASKD3DSI_INSTLENGTH_SHIFTD3DSI_COISSUED3DSP_OPCODESPECIFICCONTROL_MASKD3DSP_OPCODESPECIFICCONTROL_SHIFTD3DSI_TEXLD_PROJECTD3DSI_TEXLD_BIASD3DSHADER_COMPARISON_SHIFTD3DSHADER_COMPARISON_MASKD3DSHADER_INSTRUCTION_PREDICATEDD3DSP_DCL_USAGE_SHIFTD3DSP_DCL_USAGE_MASKD3DSP_DCL_USAGEINDEX_SHIFTD3DSP_DCL_USAGEINDEX_MASKD3DSP_TEXTURETYPE_SHIFTD3DSP_TEXTURETYPE_MASKD3DSP_REGNUM_MASKD3DSP_WRITEMASK_0D3DSP_WRITEMASK_1D3DSP_WRITEMASK_2D3DSP_WRITEMASK_3D3DSP_WRITEMASK_ALLD3DSP_DSTMOD_SHIFTD3DSP_DSTMOD_MASKD3DSPDM_NONED3DSPDM_SATURATED3DSPDM_PARTIALPRECISIOND3DSPDM_MSAMPCENTROIDD3DSP_DSTSHIFT_SHIFTD3DSP_DSTSHIFT_MASKD3DSP_REGTYPE_SHIFTD3DSP_REGTYPE_SHIFT2D3DSP_REGTYPE_MASKD3DSP_REGTYPE_MASK2D3DVS_ADDRESSMODE_SHIFTD3DVS_ADDRESSMODE_MASKD3DSHADER_ADDRESSMODE_SHIFTD3DSHADER_ADDRESSMODE_MASKD3DVS_SWIZZLE_SHIFTD3DVS_SWIZZLE_MASKD3DVS_X_XD3DVS_X_YD3DVS_X_ZD3DVS_X_WD3DVS_Y_XD3DVS_Y_YD3DVS_Y_ZD3DVS_Y_WD3DVS_Z_XD3DVS_Z_YD3DVS_Z_ZD3DVS_Z_WD3DVS_W_XD3DVS_W_YD3DVS_W_ZD3DVS_W_WD3DVS_NOSWIZZLED3DSP_SWIZZLE_SHIFTD3DSP_SWIZZLE_MASKD3DSP_NOSWIZZLED3DSP_REPLICATEREDD3DSP_REPLICATEGREEND3DSP_REPLICATEBLUED3DSP_REPLICATEALPHAD3DSP_SRCMOD_SHIFTD3DSP_SRCMOD_MASKD3DSP_MIN_PRECISION_SHIFTD3DSP_MIN_PRECISION_MASKD3DSI_COMMENTSIZE_SHIFTD3DSI_COMMENTSIZE_MASKD3DPS_ENDD3DVS_ENDD3DFVF_TEXTUREFORMAT2D3DFVF_TEXTUREFORMAT1D3DFVF_TEXTUREFORMAT3D3DFVF_TEXTUREFORMAT4D3DPRESENT_RATE_DEFAULTD3DPRESENTFLAG_LOCKABLE_BACKBUFFERD3DPRESENTFLAG_DISCARD_DEPTHSTENCILD3DPRESENTFLAG_DEVICECLIPD3DPRESENTFLAG_VIDEOD3DPRESENTFLAG_NOAUTOROTATED3DPRESENTFLAG_UNPRUNEDMODED3DPRESENTFLAG_OVERLAY_LIMITEDRGBD3DPRESENTFLAG_OVERLAY_YCbCr_BT709D3DPRESENTFLAG_OVERLAY_YCbCr_xvYCCD3DPRESENTFLAG_RESTRICTED_CONTENTD3DPRESENTFLAG_RESTRICT_SHARED_RESOURCE_DRIVERD3DUSAGE_RENDERTARGETD3DUSAGE_DEPTHSTENCILD3DUSAGE_DYNAMICD3DUSAGE_NONSECURED3DUSAGE_AUTOGENMIPMAPD3DUSAGE_DMAPD3DUSAGE_QUERY_LEGACYBUMPMAPD3DUSAGE_QUERY_SRGBREADD3DUSAGE_QUERY_FILTERD3DUSAGE_QUERY_SRGBWRITED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDINGD3DUSAGE_QUERY_VERTEXTEXTURED3DUSAGE_QUERY_WRAPANDMIPD3DUSAGE_WRITEONLYD3DUSAGE_SOFTWAREPROCESSINGD3DUSAGE_DONOTCLIPD3DUSAGE_POINTSD3DUSAGE_RTPATCHESD3DUSAGE_NPATCHESD3DUSAGE_TEXTAPID3DUSAGE_RESTRICTED_CONTENTD3DUSAGE_RESTRICT_SHARED_RESOURCED3DUSAGE_RESTRICT_SHARED_RESOURCE_DRIVERD3DLOCK_READONLYD3DLOCK_DISCARDD3DLOCK_NOOVERWRITED3DLOCK_NOSYSLOCKD3DLOCK_DONOTWAITD3DLOCK_NO_DIRTY_UPDATEMAX_DEVICE_IDENTIFIER_STRINGD3DISSUE_ENDD3DISSUE_BEGIND3DGETDATA_FLUSHD3DRTYPECOUNTLPD3DDEVINFO_RESOURCEMANAGERD3DDEVINFO_RESOURCEMANAGERLPD3DDEVINFO_D3DVERTEXSTATSD3DDEVINFO_D3DVERTEXSTATSLPD3DDEVINFO_VCACHED3DDEVINFO_VCACHED3DCOMPOSERECTS_MAXNUMRECTSD3DCONVOLUTIONMONO_MAXWIDTHD3DCONVOLUTIONMONO_MAXHEIGHTD3DFMT_A1_SURFACE_MAXWIDTHD3DFMT_A1_SURFACE_MAXHEIGHTD3D9_RESOURCE_PRIORITY_MINIMUMD3D9_RESOURCE_PRIORITY_LOWD3D9_RESOURCE_PRIORITY_NORMALD3D9_RESOURCE_PRIORITY_HIGHD3D9_RESOURCE_PRIORITY_MAXIMUMD3D_OMAC_SIZEDXGK_MAX_METADATA_NAME_LENGTH//1932//2100//! Longhorn Display Driver Model (LDDM) kernel mode data type definitionsDXGKDDI_INTERFACE_VERSION_VISTADXGKDDI_INTERFACE_VERSION_VISTA_SP1DXGKDDI_INTERFACE_VERSION_WIN7DXGKDDI_INTERFACE_VERSION_WIN8DXGKDDI_INTERFACE_VERSION_WDDM1_3DXGKDDI_INTERFACE_VERSION_WDDM1_3_PATH_INDEPENDENT_ROTATIONDXGKDDI_INTERFACE_VERSION_WDDM2_0DXGKDDI_INTERFACE_VERSION_WDDM2_1DXGKDDI_INTERFACE_VERSION_WDDM2_1_5DXGKDDI_INTERFACE_VERSION_WDDM2_2DXGKDDI_INTERFACE_VERSION_WDDM2_3DXGKDDI_INTERFACE_VERSION_WDDM2_4DXGKDDI_INTERFACE_VERSION_WDDM2_5IS_OFFICIAL_DDI_INTERFACE_VERSIONDXGKDDI_INTERFACE_VERSIOND3D_UMD_INTERFACE_VERSION_VISTAD3D_UMD_INTERFACE_VERSION_WIN7D3D_UMD_INTERFACE_VERSION_WIN8_M3D3D_UMD_INTERFACE_VERSION_WIN8_CPD3D_UMD_INTERFACE_VERSION_WIN8_RCD3D_UMD_INTERFACE_VERSION_WIN8D3D_UMD_INTERFACE_VERSION_WDDM1_3D3D_UMD_INTERFACE_VERSION_WDDM2_0_M1D3D_UMD_INTERFACE_VERSION_WDDM2_0_M1_3D3D_UMD_INTERFACE_VERSION_WDDM2_0_M2_2D3D_UMD_INTERFACE_VERSION_WDDM2_0D3D_UMD_INTERFACE_VERSION_WDDM2_1_1D3D_UMD_INTERFACE_VERSION_WDDM2_1_2D3D_UMD_INTERFACE_VERSION_WDDM2_1_3D3D_UMD_INTERFACE_VERSION_WDDM2_1_4D3D_UMD_INTERFACE_VERSION_WDDM2_1D3D_UMD_INTERFACE_VERSION_WDDM2_2_1D3D_UMD_INTERFACE_VERSION_WDDM2_2_2D3D_UMD_INTERFACE_VERSION_WDDM2_2D3D_UMD_INTERFACE_VERSION_WDDM2_3_1D3D_UMD_INTERFACE_VERSION_WDDM2_3_2D3D_UMD_INTERFACE_VERSION_WDDM2_3D3D_UMD_INTERFACE_VERSION_WDDM2_4_1D3D_UMD_INTERFACE_VERSION_WDDM2_4_2D3D_UMD_INTERFACE_VERSION_WDDM2_4D3D_UMD_INTERFACE_VERSION_WDDM2_5_1D3D_UMD_INTERFACE_VERSION_WDDM2_5_2D3D_UMD_INTERFACE_VERSION_WDDM2_5_3D3D_UMD_INTERFACE_VERSION_WDDM2_5D3D_UMD_INTERFACE_VERSIOND3DGPU_SIZE_TD3DGPU_UNIQUE_DRIVER_PROTECTIONDXGK_MAX_PAGE_TABLE_LEVEL_COUNTDXGK_MIN_PAGE_TABLE_LEVEL_COUNTPGPUP_DRIVER_ESCAPE_INPUTGPUP_DRIVER_ESCAPE_INPUTD3DGPU_NULLD3DDDI_MAX_WRITTEN_PRIMARIESD3DDDI_MAX_MPO_PRESENT_DIRTY_RECTSD3DDDI_VIDEO_PRESENT_TARGET_ID//1188//1553//1778//! Longhorn Display Driver Model (LDDM) user/kernel mode shared data type definitions.dxgitypeDXGI_RATIONALCOMPOSITIONOBJECT_READCOMPOSITIONOBJECT_WRITECOMPOSITIONOBJECT_ALL_ACCESS//! Mappings for the contents of dcomptypes.h//! Defines GUIDs for device classes used in Plug & Play.devpropdefDEVPROPKEYDEVPKEY_Numa_Proximity_DomainDEVPKEY_DeviceDisplay_DiscoveryMethodDEVPKEY_DeviceDisplay_IsShowInDisconnectedStateDEVPKEY_DeviceDisplay_IsNotInterestingForDisplayDEVPKEY_DeviceDisplay_IsNetworkDeviceDEVPKEY_DeviceDisplay_CategoryDEVPKEY_DeviceDisplay_UnpairUninstallDEVPKEY_DeviceDisplay_RequiresUninstallElevationDEVPKEY_DeviceDisplay_AlwaysShowDeviceAsConnected// except according to those terms//! Defines property keys for the Plug and Play Device Property API.IsEqualGUIDDEVPROPTYPEPDEVPROPTYPEDEVPROP_TYPEMOD_ARRAYDEVPROP_TYPEMOD_LISTDEVPROP_TYPE_EMPTYDEVPROP_TYPE_NULLDEVPROP_TYPE_SBYTEDEVPROP_TYPE_BYTEDEVPROP_TYPE_INT16DEVPROP_TYPE_UINT16DEVPROP_TYPE_INT32DEVPROP_TYPE_UINT32DEVPROP_TYPE_INT64DEVPROP_TYPE_UINT64DEVPROP_TYPE_FLOATDEVPROP_TYPE_DOUBLEDEVPROP_TYPE_DECIMALDEVPROP_TYPE_GUIDDEVPROP_TYPE_CURRENCYDEVPROP_TYPE_DATEDEVPROP_TYPE_FILETIMEDEVPROP_TYPE_BOOLEANDEVPROP_TYPE_STRINGDEVPROP_TYPE_STRING_LISTDEVPROP_TYPE_SECURITY_DESCRIPTORDEVPROP_TYPE_SECURITY_DESCRIPTOR_STRINGDEVPROP_TYPE_DEVPROPKEYDEVPROP_TYPE_DEVPROPTYPEDEVPROP_TYPE_BINARYDEVPROP_TYPE_ERRORDEVPROP_TYPE_NTSTATUSDEVPROP_TYPE_STRING_INDIRECTMAX_DEVPROP_TYPEMAX_DEVPROP_TYPEMODDEVPROP_MASK_TYPEDEVPROP_MASK_TYPEMODDEVPROP_BOOLEANPDEVPROP_BOOLEANDEVPROP_TRUEDEVPROP_FALSEDEVPROPGUIDPDEVPROPGUIDDEVPROPIDPDEVPROPIDPDEVPROPKEYIsEqualDevPropKeyPDEVPROPSTOREDEVPROPSTOREPDEVPROPCOMPKEYDEVPROPCOMPKEY// IsEqualLocaleName// IsEqualDevPropCompKeyPDEVPROPERTYDEVPROPERTYDEVPROPID_FIRST_USABLE//! Defines property types and keys for the Plug and Play Device Property APIdxgiformatDXGI_FORMATDXGI_GAMMA_CONTROLDXGI_GAMMA_CONTROL_CAPABILITIESDXGI_MODE_DESCDXGI_MODE_ROTATIONDXGI_SAMPLE_DESCDXGI_USAGEREFGUIDDXGI_RESOURCE_PRIORITY_MINIMUMDXGI_RESOURCE_PRIORITY_LOWDXGI_RESOURCE_PRIORITY_NORMALDXGI_RESOURCE_PRIORITY_HIGHDXGI_RESOURCE_PRIORITY_MAXIMUMDXGI_MAP_READDXGI_MAP_WRITEDXGI_MAP_DISCARDDXGI_MAX_SWAP_CHAIN_BUFFERSDXGI_PRESENT_TESTDXGI_PRESENT_DO_NOT_SEQUENCEDXGI_PRESENT_RESTARTDXGI_PRESENT_DO_NOT_WAITDXGI_PRESENT_STEREO_PREFER_RIGHTDXGI_PRESENT_STEREO_TEMPORARY_MONODXGI_PRESENT_RESTRICT_TO_OUTPUTDXGI_PRESENT_USE_DURATIONDXGI_PRESENT_ALLOW_TEARINGDXGI_ENUM_MODES_INTERLACEDDXGI_ENUM_MODES_SCALINGCreateDXGIFactoryCreateDXGIFactory1//! Mappings for the contents of dxgi.hDXGI_MAPPED_RECTDXGI_SWAP_EFFECTIDXGIAdapter1IDXGIAdapter1VtblIDXGIDevice1IDXGIDevice1VtblIDXGIFactory1IDXGIFactory1VtblIDXGIObjectIDXGIObjectVtblIDXGIOutputIDXGIOutputVtblIDXGIResourceIDXGIResourceVtblIDXGISurface1IDXGISurface1VtblIDXGISwapChainVtblDXGI_MODE_SCALINGDXGI_MODE_SCANLINE_ORDERDXGI_RGBADXGI_OFFER_RESOURCE_PRIORITY_DXGI_OFFER_RESOURCE_PRIORITYDXGI_ENUM_MODES_DISABLED_STEREODXGI_ENUM_MODES_STEREODXGI_SHARED_RESOURCE_READDXGI_SHARED_RESOURCE_WRITE//! Mappings for the contents of dxgi1_2.hdxgi1_2DXGI_SWAP_CHAIN_DESC1IDXGIDevice2IDXGIDevice2VtblIDXGIFactory2IDXGIFactory2VtblIDXGIOutput1IDXGIOutput1VtblIDXGISwapChain1IDXGISwapChain1VtblCreateDXGIFactory2DXGIGetDebugInterface1DXGI_CREATE_FACTORY_DEBUG//! Mappings for the contents of dxgi1_3.hIDXGIAdapter2IDXGIAdapter2Vtbldxgi1_3IDXGIFactory3IDXGIFactory3VtblIDXGIOutput3IDXGIOutput3VtblIDXGISwapChain2IDXGISwapChain2VtblDXGI_COLOR_SPACE_TYPE//! Mappings for the contents of dxgi1_4.hIDXGIOutputDuplicationIDXGIDevice3IDXGIDevice3Vtbldxgi1_4IDXGIFactory4IDXGIFactory4VtblIDXGIOutput4IDXGIOutput4VtblIDXGISwapChain3IDXGISwapChain3Vtbl//! Mappings for the contents of dxgi1_5.hDXGI_COMPUTE_PREEMPTION_GRANULARITYDXGI_GRAPHICS_PREEMPTION_GRANULARITYIDXGIAdapter3IDXGIAdapter3Vtbldxgi1_5IDXGIFactory5IDXGIFactory5VtblIDXGIOutput5IDXGIOutput5Vtbl//! Mappings for the contents of dxgi1_6.h//! Mappings for the contents of dxgiformat.hD3DCOLORVALUEDXGI_CPU_ACCESS_NONEDXGI_CPU_ACCESS_DYNAMICDXGI_CPU_ACCESS_READ_WRITEDXGI_CPU_ACCESS_SCRATCHDXGI_CPU_ACCESS_FIELDDXGI_CENTER_MULTISAMPLE_QUALITY_PATTERNDXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN//! Mappings for the contents of dxgitype.hLPCGUIDLPGUIDANYSIZE_ARRAYEVENT_MIN_LEVELEVENT_MAX_LEVELEVENT_ACTIVITY_CTRL_GET_IDEVENT_ACTIVITY_CTRL_SET_IDEVENT_ACTIVITY_CTRL_CREATE_IDEVENT_ACTIVITY_CTRL_GET_SET_IDEVENT_ACTIVITY_CTRL_CREATE_SET_IDMAX_EVENT_DATA_DESCRIPTORSMAX_EVENT_FILTER_DATA_SIZEMAX_EVENT_FILTER_PAYLOAD_SIZEMAX_EVENT_FILTER_EVENT_NAME_SIZEMAX_EVENT_FILTERS_COUNTMAX_EVENT_FILTER_PID_COUNTMAX_EVENT_FILTER_EVENT_ID_COUNTEVENT_FILTER_TYPE_NONEEVENT_FILTER_TYPE_SCHEMATIZEDEVENT_FILTER_TYPE_SYSTEM_FLAGSEVENT_FILTER_TYPE_TRACEHANDLEEVENT_FILTER_TYPE_PIDEVENT_FILTER_TYPE_EXECUTABLE_NAMEEVENT_FILTER_TYPE_PACKAGE_IDEVENT_FILTER_TYPE_PACKAGE_APP_IDEVENT_FILTER_TYPE_PAYLOADEVENT_FILTER_TYPE_EVENT_IDEVENT_FILTER_TYPE_EVENT_NAMEEVENT_FILTER_TYPE_STACKWALKEVENT_FILTER_TYPE_STACKWALK_NAMEEVENT_FILTER_TYPE_STACKWALK_LEVEL_KWEVENT_DATA_DESCRIPTOR_TYPE_NONEEVENT_DATA_DESCRIPTOR_TYPE_EVENT_METADATAEVENT_DATA_DESCRIPTOR_TYPE_PROVIDER_METADATAEVENT_DATA_DESCRIPTOR_TYPE_TIMESTAMP_OVERRIDEEVENT_WRITE_FLAG_NO_FAULTINGEVENT_WRITE_FLAG_INPRIVATEREGHANDLEPREGHANDLEPEVENT_DATA_DESCRIPTOREVENT_DATA_DESCRIPTORPEVENT_DESCRIPTOREVENT_DESCRIPTORPCEVENT_DESCRIPTORPEVENT_FILTER_DESCRIPTOREVENT_FILTER_DESCRIPTORPEVENT_FILTER_HEADEREVENT_FILTER_HEADERPEVENT_FILTER_EVENT_IDEVENT_FILTER_EVENT_IDPEVENT_FILTER_EVENT_NAMEEVENT_FILTER_EVENT_NAMEEventRegisterPENABLECALLBACKEventUnregisterEventSetInformationEVENT_INFO_CLASSEventEnabledEventProviderEnabledEventWriteEventWriteTransferEventWriteExEventWriteStringEventActivityIdControlEventDataDescCreateEventDescCreateEventDescZeroEventDescGetIdEventDescGetVersionEventDescGetTaskEventDescGetOpcodeEventDescGetChannelEventDescGetLevelEventDescGetKeywordEventDescSetIdEventDescSetVersionEventDescSetTaskEventDescSetOpcodeEventDescSetLevelEventDescSetChannelEventDescSetKeywordEventDescOrKeywordevntprovwmistrWMIDPREQUESTCODEWNODE_HEADERevntconsPEVENT_RECORDtimezoneapivcvadefsKERNEL_LOGGER_NAMEGLOBAL_LOGGER_NAMEEVENT_LOGGER_NAMEDIAG_LOGGER_NAMEMAX_MOF_FIELDSPTRACEHANDLETRACEHANDLEEVENT_TRACE_TYPE_INFOEVENT_TRACE_TYPE_STARTEVENT_TRACE_TYPE_ENDEVENT_TRACE_TYPE_STOPEVENT_TRACE_TYPE_DC_STARTEVENT_TRACE_TYPE_DC_ENDEVENT_TRACE_TYPE_EXTENSIONEVENT_TRACE_TYPE_REPLYEVENT_TRACE_TYPE_DEQUEUEEVENT_TRACE_TYPE_RESUMEEVENT_TRACE_TYPE_CHECKPOINTEVENT_TRACE_TYPE_SUSPENDEVENT_TRACE_TYPE_WINEVT_SENDEVENT_TRACE_TYPE_WINEVT_RECEIVETRACE_LEVEL_CRITICALTRACE_LEVEL_ERRORTRACE_LEVEL_WARNINGTRACE_LEVEL_INFORMATIONTRACE_LEVEL_VERBOSETRACE_LEVEL_RESERVED6TRACE_LEVEL_RESERVED7TRACE_LEVEL_RESERVED8TRACE_LEVEL_RESERVED9EVENT_TRACE_TYPE_LOADEVENT_TRACE_TYPE_TERMINATEEVENT_TRACE_TYPE_IO_READEVENT_TRACE_TYPE_IO_WRITEEVENT_TRACE_TYPE_IO_READ_INITEVENT_TRACE_TYPE_IO_WRITE_INITEVENT_TRACE_TYPE_IO_FLUSHEVENT_TRACE_TYPE_IO_FLUSH_INITEVENT_TRACE_TYPE_IO_REDIRECTED_INITEVENT_TRACE_TYPE_MM_TFEVENT_TRACE_TYPE_MM_DZFEVENT_TRACE_TYPE_MM_COWEVENT_TRACE_TYPE_MM_GPFEVENT_TRACE_TYPE_MM_HPFEVENT_TRACE_TYPE_MM_AVEVENT_TRACE_TYPE_SENDEVENT_TRACE_TYPE_RECEIVEEVENT_TRACE_TYPE_CONNECTEVENT_TRACE_TYPE_DISCONNECTEVENT_TRACE_TYPE_RETRANSMITEVENT_TRACE_TYPE_ACCEPTEVENT_TRACE_TYPE_RECONNECTEVENT_TRACE_TYPE_CONNFAILEVENT_TRACE_TYPE_COPY_TCPEVENT_TRACE_TYPE_COPY_ARPEVENT_TRACE_TYPE_ACKFULLEVENT_TRACE_TYPE_ACKPARTEVENT_TRACE_TYPE_ACKDUPEVENT_TRACE_TYPE_GUIDMAPEVENT_TRACE_TYPE_CONFIGEVENT_TRACE_TYPE_SIDINFOEVENT_TRACE_TYPE_SECURITYEVENT_TRACE_TYPE_DBGID_RSDSEVENT_TRACE_TYPE_REGCREATEEVENT_TRACE_TYPE_REGOPENEVENT_TRACE_TYPE_REGDELETEEVENT_TRACE_TYPE_REGQUERYEVENT_TRACE_TYPE_REGSETVALUEEVENT_TRACE_TYPE_REGDELETEVALUEEVENT_TRACE_TYPE_REGQUERYVALUEEVENT_TRACE_TYPE_REGENUMERATEKEYEVENT_TRACE_TYPE_REGENUMERATEVALUEKEYEVENT_TRACE_TYPE_REGQUERYMULTIPLEVALUEEVENT_TRACE_TYPE_REGSETINFORMATIONEVENT_TRACE_TYPE_REGFLUSHEVENT_TRACE_TYPE_REGKCBCREATEEVENT_TRACE_TYPE_REGKCBDELETEEVENT_TRACE_TYPE_REGKCBRUNDOWNBEGINEVENT_TRACE_TYPE_REGKCBRUNDOWNENDEVENT_TRACE_TYPE_REGVIRTUALIZEEVENT_TRACE_TYPE_REGCLOSEEVENT_TRACE_TYPE_REGSETSECURITYEVENT_TRACE_TYPE_REGQUERYSECURITYEVENT_TRACE_TYPE_REGCOMMITEVENT_TRACE_TYPE_REGPREPAREEVENT_TRACE_TYPE_REGROLLBACKEVENT_TRACE_TYPE_REGMOUNTHIVEEVENT_TRACE_TYPE_CONFIG_CPUEVENT_TRACE_TYPE_CONFIG_PHYSICALDISKEVENT_TRACE_TYPE_CONFIG_LOGICALDISKEVENT_TRACE_TYPE_CONFIG_NICEVENT_TRACE_TYPE_CONFIG_VIDEOEVENT_TRACE_TYPE_CONFIG_SERVICESEVENT_TRACE_TYPE_CONFIG_POWEREVENT_TRACE_TYPE_CONFIG_NETINFOEVENT_TRACE_TYPE_CONFIG_OPTICALMEDIAEVENT_TRACE_TYPE_CONFIG_IRQEVENT_TRACE_TYPE_CONFIG_PNPEVENT_TRACE_TYPE_CONFIG_IDECHANNELEVENT_TRACE_TYPE_CONFIG_NUMANODEEVENT_TRACE_TYPE_CONFIG_PLATFORMEVENT_TRACE_TYPE_CONFIG_PROCESSORGROUPEVENT_TRACE_TYPE_CONFIG_PROCESSORNUMBEREVENT_TRACE_TYPE_CONFIG_DPIEVENT_TRACE_TYPE_CONFIG_CI_INFOEVENT_TRACE_TYPE_CONFIG_MACHINEIDEVENT_TRACE_TYPE_CONFIG_DEFRAGEVENT_TRACE_TYPE_CONFIG_MOBILEPLATFORMEVENT_TRACE_TYPE_CONFIG_DEVICEFAMILYEVENT_TRACE_TYPE_CONFIG_FLIGHTIDEVENT_TRACE_TYPE_CONFIG_PROCESSOREVENT_TRACE_TYPE_OPTICAL_IO_READEVENT_TRACE_TYPE_OPTICAL_IO_WRITEEVENT_TRACE_TYPE_OPTICAL_IO_FLUSHEVENT_TRACE_TYPE_OPTICAL_IO_READ_INITEVENT_TRACE_TYPE_OPTICAL_IO_WRITE_INITEVENT_TRACE_TYPE_OPTICAL_IO_FLUSH_INITEVENT_TRACE_TYPE_FLT_PREOP_INITEVENT_TRACE_TYPE_FLT_POSTOP_INITEVENT_TRACE_TYPE_FLT_PREOP_COMPLETIONEVENT_TRACE_TYPE_FLT_POSTOP_COMPLETIONEVENT_TRACE_TYPE_FLT_PREOP_FAILUREEVENT_TRACE_TYPE_FLT_POSTOP_FAILUREEVENT_TRACE_FLAG_PROCESSEVENT_TRACE_FLAG_THREADEVENT_TRACE_FLAG_IMAGE_LOADEVENT_TRACE_FLAG_DISK_IOEVENT_TRACE_FLAG_DISK_FILE_IOEVENT_TRACE_FLAG_MEMORY_PAGE_FAULTSEVENT_TRACE_FLAG_MEMORY_HARD_FAULTSEVENT_TRACE_FLAG_NETWORK_TCPIPEVENT_TRACE_FLAG_REGISTRYEVENT_TRACE_FLAG_DBGPRINTEVENT_TRACE_FLAG_PROCESS_COUNTERSEVENT_TRACE_FLAG_CSWITCHEVENT_TRACE_FLAG_DPCEVENT_TRACE_FLAG_INTERRUPTEVENT_TRACE_FLAG_SYSTEMCALLEVENT_TRACE_FLAG_DISK_IO_INITEVENT_TRACE_FLAG_ALPCEVENT_TRACE_FLAG_SPLIT_IOEVENT_TRACE_FLAG_DRIVEREVENT_TRACE_FLAG_PROFILEEVENT_TRACE_FLAG_FILE_IOEVENT_TRACE_FLAG_FILE_IO_INITEVENT_TRACE_FLAG_DISPATCHEREVENT_TRACE_FLAG_VIRTUAL_ALLOCEVENT_TRACE_FLAG_VAMAPEVENT_TRACE_FLAG_NO_SYSCONFIGEVENT_TRACE_FLAG_JOBEVENT_TRACE_FLAG_DEBUG_EVENTSEVENT_TRACE_FLAG_EXTENSIONEVENT_TRACE_FLAG_FORWARD_WMIEVENT_TRACE_FLAG_ENABLE_RESERVEEVENT_TRACE_FILE_MODE_NONEEVENT_TRACE_FILE_MODE_SEQUENTIALEVENT_TRACE_FILE_MODE_CIRCULAREVENT_TRACE_FILE_MODE_APPENDEVENT_TRACE_REAL_TIME_MODEEVENT_TRACE_DELAY_OPEN_FILE_MODEEVENT_TRACE_BUFFERING_MODEEVENT_TRACE_PRIVATE_LOGGER_MODEEVENT_TRACE_ADD_HEADER_MODEEVENT_TRACE_USE_GLOBAL_SEQUENCEEVENT_TRACE_USE_LOCAL_SEQUENCEEVENT_TRACE_RELOG_MODEEVENT_TRACE_USE_PAGED_MEMORYEVENT_TRACE_FILE_MODE_NEWFILEEVENT_TRACE_FILE_MODE_PREALLOCATEEVENT_TRACE_NONSTOPPABLE_MODEEVENT_TRACE_SECURE_MODEEVENT_TRACE_USE_KBYTES_FOR_SIZEEVENT_TRACE_PRIVATE_IN_PROCEVENT_TRACE_MODE_RESERVEDEVENT_TRACE_NO_PER_PROCESSOR_BUFFERINGEVENT_TRACE_SYSTEM_LOGGER_MODEEVENT_TRACE_ADDTO_TRIAGE_DUMPEVENT_TRACE_STOP_ON_HYBRID_SHUTDOWNEVENT_TRACE_PERSIST_ON_HYBRID_SHUTDOWNEVENT_TRACE_INDEPENDENT_SESSION_MODEEVENT_TRACE_COMPRESSED_MODEEVENT_TRACE_CONTROL_QUERYEVENT_TRACE_CONTROL_STOPEVENT_TRACE_CONTROL_UPDATEEVENT_TRACE_CONTROL_FLUSHTRACE_MESSAGE_SEQUENCETRACE_MESSAGE_GUIDTRACE_MESSAGE_COMPONENTIDTRACE_MESSAGE_TIMESTAMPTRACE_MESSAGE_PERFORMANCE_TIMESTAMPTRACE_MESSAGE_SYSTEMINFOTRACE_MESSAGE_POINTER32TRACE_MESSAGE_POINTER64TRACE_MESSAGE_FLAG_MASKTRACE_MESSAGE_MAXIMUM_SIZEEVENT_TRACE_USE_PROCTIMEEVENT_TRACE_USE_NOCPUTIMETRACE_HEADER_FLAG_USE_TIMESTAMPTRACE_HEADER_FLAG_TRACED_GUIDTRACE_HEADER_FLAG_LOG_WNODETRACE_HEADER_FLAG_USE_GUID_PTRTRACE_HEADER_FLAG_USE_MOF_PTRPEVENT_TRACE_HEADEREVENT_TRACE_HEADERPEVENT_INSTANCE_HEADEREVENT_INSTANCE_HEADERETW_NULL_TYPE_VALUEETW_OBJECT_TYPE_VALUEETW_STRING_TYPE_VALUEETW_SBYTE_TYPE_VALUEETW_BYTE_TYPE_VALUEETW_INT16_TYPE_VALUEETW_UINT16_TYPE_VALUEETW_INT32_TYPE_VALUEETW_UINT32_TYPE_VALUEETW_INT64_TYPE_VALUEETW_UINT64_TYPE_VALUEETW_CHAR_TYPE_VALUEETW_SINGLE_TYPE_VALUEETW_DOUBLE_TYPE_VALUEETW_BOOLEAN_TYPE_VALUEETW_DECIMAL_TYPE_VALUEETW_GUID_TYPE_VALUEETW_ASCIICHAR_TYPE_VALUEETW_ASCIISTRING_TYPE_VALUEETW_COUNTED_STRING_TYPE_VALUEETW_POINTER_TYPE_VALUEETW_SIZET_TYPE_VALUEETW_HIDDEN_TYPE_VALUEETW_BOOL_TYPE_VALUEETW_COUNTED_ANSISTRING_TYPE_VALUEETW_REVERSED_COUNTED_STRING_TYPE_VALUEETW_REVERSED_COUNTED_ANSISTRING_TYPE_VALUEETW_NON_NULL_TERMINATED_STRING_TYPE_VALUEETW_REDUCED_ANSISTRING_TYPE_VALUEETW_REDUCED_STRING_TYPE_VALUEETW_SID_TYPE_VALUEETW_VARIANT_TYPE_VALUEETW_PTVECTOR_TYPE_VALUEETW_WMITIME_TYPE_VALUEETW_DATETIME_TYPE_VALUEETW_REFRENCE_TYPE_VALUE// TODO: DEFINE_TRACE_MOF_FIELDPMOF_FIELDMOF_FIELDPTRACE_LOGFILE_HEADERTRACE_LOGFILE_HEADERPTRACE_LOGFILE_HEADER32TRACE_LOGFILE_HEADER32PTRACE_LOGFILE_HEADER64TRACE_LOGFILE_HEADER64PEVENT_INSTANCE_INFOEVENT_INSTANCE_INFOPEVENT_TRACE_PROPERTIESEVENT_TRACE_PROPERTIESPEVENT_TRACE_PROPERTIES_V2EVENT_TRACE_PROPERTIES_V2PTRACE_GUID_REGISTRATIONTRACE_GUID_REGISTRATIONPTRACE_GUID_PROPERTIESTRACE_GUID_PROPERTIESPETW_BUFFER_CONTEXTETW_BUFFER_CONTEXTTRACE_PROVIDER_FLAG_LEGACYTRACE_PROVIDER_FLAG_PRE_ENABLEPTRACE_ENABLE_INFOTRACE_ENABLE_INFOPTRACE_PROVIDER_INSTANCE_INFOTRACE_PROVIDER_INSTANCE_INFOPTRACE_GUID_INFOTRACE_GUID_INFOPPROFILE_SOURCE_INFOPROFILE_SOURCE_INFOPEVENT_TRACEEVENT_TRACEEVENT_CONTROL_CODE_DISABLE_PROVIDEREVENT_CONTROL_CODE_ENABLE_PROVIDEREVENT_CONTROL_CODE_CAPTURE_STATEPEVENT_TRACE_LOGFILEWEVENT_TRACE_LOGFILEWPEVENT_TRACE_LOGFILEAEVENT_TRACE_LOGFILEAStartTraceWStartTraceAStopTraceWStopTraceAQueryTraceWQueryTraceAUpdateTraceWUpdateTraceAFlushTraceWFlushTraceAControlTraceWControlTraceAQueryAllTracesWQueryAllTracesAEnableTraceEnableTraceExENABLE_TRACE_PARAMETERS_VERSIONENABLE_TRACE_PARAMETERS_VERSION_2PENABLE_TRACE_PARAMETERS_V1ENABLE_TRACE_PARAMETERS_V1PENABLE_TRACE_PARAMETERSENABLE_TRACE_PARAMETERSEnableTraceEx2TRACE_INFO_CLASSTRACE_QUERY_INFO_CLASSEnumerateTraceGuidsExPCLASSIC_EVENT_IDCLASSIC_EVENT_IDPTRACE_PROFILE_INTERVALTRACE_PROFILE_INTERVALPTRACE_VERSION_INFOTRACE_VERSION_INFOPTRACE_PERIODIC_CAPTURE_STATE_INFOTRACE_PERIODIC_CAPTURE_STATE_INFOTraceSetInformationTraceQueryInformationCreateTraceInstanceIdTraceEventTraceEventInstanceRegisterTraceGuidsWWMIDPREQUESTRegisterTraceGuidsAEnumerateTraceGuidsUnregisterTraceGuidsGetTraceLoggerHandleGetTraceEnableLevelGetTraceEnableFlagsOpenTraceWProcessTraceCloseTracePETW_TRACE_PARTITION_INFORMATIONETW_TRACE_PARTITION_INFORMATIONQueryTraceProcessingHandleETW_PROCESS_HANDLE_INFO_TYPEOpenTraceASetTraceCallbackPEVENT_CALLBACKRemoveTraceCallbackTraceMessageTraceMessageVaINVALID_PROCESSTRACE_HANDLELPIIDIsEqualIIDCLSIDLPCLSIDIsEqualCLSIDFMTIDLPFMTIDIsEqualFMTIDREFCLSIDREFFMTID//! GUID definitionFILE_DEVICE_KEYBOARDMETHOD_IN_DIRECTMETHOD_OUT_DIRECTGUID_CLASS_INPUTHID_REVISION// FIXME devpropkey stuffIOCTL_HID_GET_DRIVER_CONFIGIOCTL_HID_SET_DRIVER_CONFIGIOCTL_HID_GET_POLL_FREQUENCY_MSECIOCTL_HID_SET_POLL_FREQUENCY_MSECIOCTL_GET_NUM_DEVICE_INPUT_BUFFERSIOCTL_SET_NUM_DEVICE_INPUT_BUFFERSIOCTL_HID_GET_COLLECTION_INFORMATIONIOCTL_HID_ENABLE_WAKE_ON_SXIOCTL_HID_SET_S0_IDLE_TIMEOUTIOCTL_HID_GET_COLLECTION_DESCRIPTORIOCTL_HID_FLUSH_QUEUEIOCTL_HID_SET_FEATUREIOCTL_HID_SET_OUTPUT_REPORTIOCTL_HID_GET_FEATUREIOCTL_GET_PHYSICAL_DESCRIPTORIOCTL_HID_GET_HARDWARE_IDIOCTL_HID_GET_INPUT_REPORTIOCTL_HID_GET_OUTPUT_REPORTIOCTL_HID_GET_MANUFACTURER_STRINGIOCTL_HID_GET_PRODUCT_STRINGIOCTL_HID_GET_SERIALNUMBER_STRINGIOCTL_HID_GET_INDEXED_STRINGIOCTL_HID_GET_MS_GENRE_DESCRIPTORIOCTL_HID_ENABLE_SECURE_READIOCTL_HID_DISABLE_SECURE_READIOCTL_HID_DEVICERESET_NOTIFICATIONPHID_XFER_PACKETHID_XFER_PACKET//FIXME Stuff for NT_INCLUDEDPHID_COLLECTION_INFORMATIONHID_COLLECTION_INFORMATIONPHID_DRIVER_CONFIGHID_DRIVER_CONFIGhidusagePUSAGEPUSHORTFACILITY_HID_ERROR_CODEPLONGHIDP_LINK_COLLECTION_ROOTHIDP_LINK_COLLECTION_UNSPECIFIEDPUSAGE_AND_PAGEUSAGE_AND_PAGE// HidP_IsSameUsageAndPagePHIDP_BUTTON_CAPSHIDP_BUTTON_CAPSPHIDP_VALUE_CAPSHIDP_VALUE_CAPSPHIDP_LINK_COLLECTION_NODEHIDP_LINK_COLLECTION_NODEPHIDP_REPORT_DESCRIPTORHIDP_PREPARSED_DATAPHIDP_PREPARSED_DATAPHIDP_CAPSHIDP_CAPSPHIDP_DATAHIDP_DATAPHIDP_UNKNOWN_TOKENHIDP_UNKNOWN_TOKENPHIDP_EXTENDED_ATTRIBUTESHIDP_EXTENDED_ATTRIBUTESHidP_GetCapsHidP_GetLinkCollectionNodesHidP_GetSpecificButtonCapsHIDP_REPORT_TYPEHidP_GetButtonCapsHidP_GetSpecificValueCapsHidP_GetValueCapsHidP_GetExtendedAttributesHidP_InitializeReportForIDHidP_SetDataHidP_GetDataHidP_MaxDataListLengthHidP_SetUsagesHidP_UnsetUsagesHidP_GetUsagesHidP_GetUsagesExHidP_MaxUsageListLengthHidP_SetUsageValueHidP_SetScaledUsageValueHidP_SetUsageValueArrayHidP_GetUsageValueHidP_GetScaledUsageValueHidP_GetUsageValueArrayHidP_UsageListDifferenceHidP_TranslateUsagesToI8042ScanCodesHIDP_KEYBOARD_DIRECTIONPHIDP_KEYBOARD_MODIFIER_STATEPHIDP_INSERT_SCANCODESHIDP_KEYBOARD_MODIFIER_STATEHIDP_STATUS_SUCCESSHIDP_STATUS_NULLHIDP_STATUS_INVALID_PREPARSED_DATAHIDP_STATUS_INVALID_REPORT_TYPEHIDP_STATUS_INVALID_REPORT_LENGTHHIDP_STATUS_USAGE_NOT_FOUNDHIDP_STATUS_VALUE_OUT_OF_RANGEHIDP_STATUS_BAD_LOG_PHY_VALUESHIDP_STATUS_BUFFER_TOO_SMALLHIDP_STATUS_INTERNAL_ERRORHIDP_STATUS_I8042_TRANS_UNKNOWNHIDP_STATUS_INCOMPATIBLE_REPORT_IDHIDP_STATUS_NOT_VALUE_ARRAYHIDP_STATUS_IS_VALUE_ARRAYHIDP_STATUS_DATA_INDEX_NOT_FOUNDHIDP_STATUS_DATA_INDEX_OUT_OF_RANGEHIDP_STATUS_BUTTON_NOT_PRESSEDHIDP_STATUS_REPORT_DOES_NOT_EXISTHIDP_STATUS_NOT_IMPLEMENTEDHIDP_STATUS_I8242_TRANS_UNKNOWNhidpiPHIDD_CONFIGURATIONHIDD_CONFIGURATIONPHIDD_ATTRIBUTESHIDD_ATTRIBUTESHidD_GetAttributesHidD_GetHidGuidHidD_GetPreparsedDataHidD_FreePreparsedDataHidD_FlushQueueHidD_GetConfigurationHidD_SetConfigurationHidD_GetFeatureHidD_SetFeatureHidD_GetInputReportHidD_SetOutputReportHidD_GetNumInputBuffersHidD_SetNumInputBuffersHidD_GetPhysicalDescriptorHidD_GetManufacturerStringHidD_GetProductStringHidD_GetIndexedStringHidD_GetSerialNumberStringHidD_GetMsGenreDescriptorHID_USAGE_PAGE_UNDEFINEDHID_USAGE_PAGE_GENERICHID_USAGE_PAGE_SIMULATIONHID_USAGE_PAGE_VRHID_USAGE_PAGE_SPORTHID_USAGE_PAGE_GAMEHID_USAGE_PAGE_KEYBOARDHID_USAGE_PAGE_LEDHID_USAGE_PAGE_BUTTONHID_USAGE_PAGE_ORDINALHID_USAGE_PAGE_TELEPHONYHID_USAGE_PAGE_CONSUMERHID_USAGE_PAGE_DIGITIZERHID_USAGE_PAGE_UNICODEHID_USAGE_PAGE_ALPHANUMERICHID_USAGE_PAGE_SENSORHID_USAGE_PAGE_BARCODE_SCANNERHID_USAGE_PAGE_WEIGHING_DEVICEHID_USAGE_PAGE_MAGNETIC_STRIPE_READERHID_USAGE_PAGE_CAMERA_CONTROLHID_USAGE_PAGE_MICROSOFT_BLUETOOTH_HANDSFREEHID_USAGE_PAGE_VENDOR_DEFINED_BEGINHID_USAGE_PAGE_VENDOR_DEFINED_ENDHID_USAGE_GENERIC_POINTERHID_USAGE_GENERIC_MOUSEHID_USAGE_GENERIC_JOYSTICKHID_USAGE_GENERIC_GAMEPADHID_USAGE_GENERIC_KEYBOARDHID_USAGE_GENERIC_KEYPADHID_USAGE_GENERIC_PORTABLE_DEVICE_CONTROLHID_USAGE_GENERIC_SYSTEM_CTLHID_USAGE_GENERIC_XHID_USAGE_GENERIC_YHID_USAGE_GENERIC_ZHID_USAGE_GENERIC_RXHID_USAGE_GENERIC_RYHID_USAGE_GENERIC_RZHID_USAGE_GENERIC_SLIDERHID_USAGE_GENERIC_DIALHID_USAGE_GENERIC_WHEELHID_USAGE_GENERIC_HATSWITCHHID_USAGE_GENERIC_COUNTED_BUFFERHID_USAGE_GENERIC_BYTE_COUNTHID_USAGE_GENERIC_MOTION_WAKEUPHID_USAGE_GENERIC_VXHID_USAGE_GENERIC_VYHID_USAGE_GENERIC_VZHID_USAGE_GENERIC_VBRXHID_USAGE_GENERIC_VBRYHID_USAGE_GENERIC_VBRZHID_USAGE_GENERIC_VNOHID_USAGE_GENERIC_RESOLUTION_MULTIPLIERHID_USAGE_GENERIC_SYSCTL_POWERHID_USAGE_GENERIC_SYSCTL_SLEEPHID_USAGE_GENERIC_SYSCTL_WAKEHID_USAGE_GENERIC_SYSCTL_CONTEXT_MENUHID_USAGE_GENERIC_SYSCTL_MAIN_MENUHID_USAGE_GENERIC_SYSCTL_APP_MENUHID_USAGE_GENERIC_SYSCTL_HELP_MENUHID_USAGE_GENERIC_SYSCTL_MENU_EXITHID_USAGE_GENERIC_SYSCTL_MENU_SELECTHID_USAGE_GENERIC_SYSCTL_MENU_RIGHTHID_USAGE_GENERIC_SYSCTL_MENU_LEFTHID_USAGE_GENERIC_SYSCTL_MENU_UPHID_USAGE_GENERIC_SYSCTL_MENU_DOWNHID_USAGE_GENERIC_SYSTEM_DISPLAY_ROTATION_LOCK_BUTTONHID_USAGE_GENERIC_SYSTEM_DISPLAY_ROTATION_LOCK_SLIDER_SWITCHHID_USAGE_GENERIC_CONTROL_ENABLEHID_USAGE_SIMULATION_RUDDERHID_USAGE_SIMULATION_THROTTLEHID_USAGE_KEYBOARD_NOEVENTHID_USAGE_KEYBOARD_ROLLOVERHID_USAGE_KEYBOARD_POSTFAILHID_USAGE_KEYBOARD_UNDEFINEDHID_USAGE_KEYBOARD_aAHID_USAGE_KEYBOARD_zZHID_USAGE_KEYBOARD_ONEHID_USAGE_KEYBOARD_ZEROHID_USAGE_KEYBOARD_LCTRLHID_USAGE_KEYBOARD_LSHFTHID_USAGE_KEYBOARD_LALTHID_USAGE_KEYBOARD_LGUIHID_USAGE_KEYBOARD_RCTRLHID_USAGE_KEYBOARD_RSHFTHID_USAGE_KEYBOARD_RALTHID_USAGE_KEYBOARD_RGUIHID_USAGE_KEYBOARD_SCROLL_LOCKHID_USAGE_KEYBOARD_NUM_LOCKHID_USAGE_KEYBOARD_CAPS_LOCKHID_USAGE_KEYBOARD_F1HID_USAGE_KEYBOARD_F2HID_USAGE_KEYBOARD_F3HID_USAGE_KEYBOARD_F4HID_USAGE_KEYBOARD_F5HID_USAGE_KEYBOARD_F6HID_USAGE_KEYBOARD_F7HID_USAGE_KEYBOARD_F8HID_USAGE_KEYBOARD_F9HID_USAGE_KEYBOARD_F10HID_USAGE_KEYBOARD_F11HID_USAGE_KEYBOARD_F12HID_USAGE_KEYBOARD_F13HID_USAGE_KEYBOARD_F14HID_USAGE_KEYBOARD_F15HID_USAGE_KEYBOARD_F16HID_USAGE_KEYBOARD_F17HID_USAGE_KEYBOARD_F18HID_USAGE_KEYBOARD_F19HID_USAGE_KEYBOARD_F20HID_USAGE_KEYBOARD_F21HID_USAGE_KEYBOARD_F22HID_USAGE_KEYBOARD_F23HID_USAGE_KEYBOARD_F24HID_USAGE_KEYBOARD_RETURNHID_USAGE_KEYBOARD_ESCAPEHID_USAGE_KEYBOARD_DELETEHID_USAGE_KEYBOARD_PRINT_SCREENHID_USAGE_KEYBOARD_DELETE_FORWARDHID_USAGE_LED_NUM_LOCKHID_USAGE_LED_CAPS_LOCKHID_USAGE_LED_SCROLL_LOCKHID_USAGE_LED_COMPOSEHID_USAGE_LED_KANAHID_USAGE_LED_POWERHID_USAGE_LED_SHIFTHID_USAGE_LED_DO_NOT_DISTURBHID_USAGE_LED_MUTEHID_USAGE_LED_TONE_ENABLEHID_USAGE_LED_HIGH_CUT_FILTERHID_USAGE_LED_LOW_CUT_FILTERHID_USAGE_LED_EQUALIZER_ENABLEHID_USAGE_LED_SOUND_FIELD_ONHID_USAGE_LED_SURROUND_FIELD_ONHID_USAGE_LED_REPEATHID_USAGE_LED_STEREOHID_USAGE_LED_SAMPLING_RATE_DETECTHID_USAGE_LED_SPINNINGHID_USAGE_LED_CAVHID_USAGE_LED_CLVHID_USAGE_LED_RECORDING_FORMAT_DETHID_USAGE_LED_OFF_HOOKHID_USAGE_LED_RINGHID_USAGE_LED_MESSAGE_WAITINGHID_USAGE_LED_DATA_MODEHID_USAGE_LED_BATTERY_OPERATIONHID_USAGE_LED_BATTERY_OKHID_USAGE_LED_BATTERY_LOWHID_USAGE_LED_SPEAKERHID_USAGE_LED_HEAD_SETHID_USAGE_LED_HOLDHID_USAGE_LED_MICROPHONEHID_USAGE_LED_COVERAGEHID_USAGE_LED_NIGHT_MODEHID_USAGE_LED_SEND_CALLSHID_USAGE_LED_CALL_PICKUPHID_USAGE_LED_CONFERENCEHID_USAGE_LED_STAND_BYHID_USAGE_LED_CAMERA_ONHID_USAGE_LED_CAMERA_OFFHID_USAGE_LED_ON_LINEHID_USAGE_LED_OFF_LINEHID_USAGE_LED_BUSYHID_USAGE_LED_READYHID_USAGE_LED_PAPER_OUTHID_USAGE_LED_PAPER_JAMHID_USAGE_LED_REMOTEHID_USAGE_LED_FORWARDHID_USAGE_LED_REVERSEHID_USAGE_LED_STOPHID_USAGE_LED_REWINDHID_USAGE_LED_FAST_FORWARDHID_USAGE_LED_PLAYHID_USAGE_LED_PAUSEHID_USAGE_LED_RECORDHID_USAGE_LED_ERRORHID_USAGE_LED_SELECTED_INDICATORHID_USAGE_LED_IN_USE_INDICATORHID_USAGE_LED_MULTI_MODE_INDICATORHID_USAGE_LED_INDICATOR_ONHID_USAGE_LED_INDICATOR_FLASHHID_USAGE_LED_INDICATOR_SLOW_BLINKHID_USAGE_LED_INDICATOR_FAST_BLINKHID_USAGE_LED_INDICATOR_OFFHID_USAGE_LED_FLASH_ON_TIMEHID_USAGE_LED_SLOW_BLINK_ON_TIMEHID_USAGE_LED_SLOW_BLINK_OFF_TIMEHID_USAGE_LED_FAST_BLINK_ON_TIMEHID_USAGE_LED_FAST_BLINK_OFF_TIMEHID_USAGE_LED_INDICATOR_COLORHID_USAGE_LED_REDHID_USAGE_LED_GREENHID_USAGE_LED_AMBERHID_USAGE_LED_GENERIC_INDICATORHID_USAGE_TELEPHONY_PHONEHID_USAGE_TELEPHONY_ANSWERING_MACHINEHID_USAGE_TELEPHONY_MESSAGE_CONTROLSHID_USAGE_TELEPHONY_HANDSETHID_USAGE_TELEPHONY_HEADSETHID_USAGE_TELEPHONY_KEYPADHID_USAGE_TELEPHONY_PROGRAMMABLE_BUTTONHID_USAGE_TELEPHONY_REDIALHID_USAGE_TELEPHONY_TRANSFERHID_USAGE_TELEPHONY_DROPHID_USAGE_TELEPHONY_LINEHID_USAGE_TELEPHONY_RING_ENABLEHID_USAGE_TELEPHONY_SENDHID_USAGE_TELEPHONY_KEYPAD_0HID_USAGE_TELEPHONY_KEYPAD_DHID_USAGE_TELEPHONY_HOST_AVAILABLEHID_USAGE_CONSUMERCTRLHID_USAGE_CONSUMER_CHANNEL_INCREMENTHID_USAGE_CONSUMER_CHANNEL_DECREMENTHID_USAGE_CONSUMER_PLAYHID_USAGE_CONSUMER_PAUSEHID_USAGE_CONSUMER_RECORDHID_USAGE_CONSUMER_FAST_FORWARDHID_USAGE_CONSUMER_REWINDHID_USAGE_CONSUMER_SCAN_NEXT_TRACKHID_USAGE_CONSUMER_SCAN_PREV_TRACKHID_USAGE_CONSUMER_STOPHID_USAGE_CONSUMER_PLAY_PAUSEHID_USAGE_CONSUMER_VOLUMEHID_USAGE_CONSUMER_BALANCEHID_USAGE_CONSUMER_MUTEHID_USAGE_CONSUMER_BASSHID_USAGE_CONSUMER_TREBLEHID_USAGE_CONSUMER_BASS_BOOSTHID_USAGE_CONSUMER_SURROUND_MODEHID_USAGE_CONSUMER_LOUDNESSHID_USAGE_CONSUMER_MPXHID_USAGE_CONSUMER_VOLUME_INCREMENTHID_USAGE_CONSUMER_VOLUME_DECREMENTHID_USAGE_CONSUMER_BASS_INCREMENTHID_USAGE_CONSUMER_BASS_DECREMENTHID_USAGE_CONSUMER_TREBLE_INCREMENTHID_USAGE_CONSUMER_TREBLE_DECREMENTHID_USAGE_CONSUMER_AL_CONFIGURATIONHID_USAGE_CONSUMER_AL_EMAILHID_USAGE_CONSUMER_AL_CALCULATORHID_USAGE_CONSUMER_AL_BROWSERHID_USAGE_CONSUMER_AC_SEARCHHID_USAGE_CONSUMER_AC_GOTOHID_USAGE_CONSUMER_AC_HOMEHID_USAGE_CONSUMER_AC_BACKHID_USAGE_CONSUMER_AC_FORWARDHID_USAGE_CONSUMER_AC_STOPHID_USAGE_CONSUMER_AC_REFRESHHID_USAGE_CONSUMER_AC_PREVIOUSHID_USAGE_CONSUMER_AC_NEXTHID_USAGE_CONSUMER_AC_BOOKMARKSHID_USAGE_CONSUMER_AC_PANHID_USAGE_CONSUMER_EXTENDED_KEYBOARD_ATTRIBUTES_COLLECTIONHID_USAGE_CONSUMER_KEYBOARD_FORM_FACTORHID_USAGE_CONSUMER_KEYBOARD_KEY_TYPEHID_USAGE_CONSUMER_KEYBOARD_PHYSICAL_LAYOUTHID_USAGE_CONSUMER_VENDOR_SPECIFIC_KEYBOARD_PHYSICAL_LAYOUTHID_USAGE_CONSUMER_KEYBOARD_IETF_LANGUAGE_TAG_INDEXHID_USAGE_CONSUMER_IMPLEMENTED_KEYBOARD_INPUT_ASSIST_CONTROLSHID_USAGE_DIGITIZER_PENHID_USAGE_DIGITIZER_IN_RANGEHID_USAGE_DIGITIZER_TIP_SWITCHHID_USAGE_DIGITIZER_BARREL_SWITCHHID_USAGE_CAMERA_AUTO_FOCUSHID_USAGE_CAMERA_SHUTTERHID_USAGE_MS_BTH_HF_DIALNUMBERHID_USAGE_MS_BTH_HF_DIALMEMORYNET_IF_COMPARTMENT_IDPNET_IF_COMPARTMENT_IDNET_IF_COMPARTMENT_ID_UNSPECIFIEDNET_IF_COMPARTMENT_ID_PRIMARYNET_IF_NETWORK_GUIDPNET_IF_NETWORK_GUIDPNET_IF_OPER_STATUSNET_IF_OPER_STATUSNET_IF_OBJECT_IDPNET_IF_OBJECT_IDPNET_IF_ADMIN_STATUSNET_IF_ADMIN_STATUSNET_IF_COMPARTMENT_SCOPEPNET_IF_COMPARTMENT_SCOPENET_IF_COMPARTMENT_SCOPE_UNSPECIFIEDNET_IF_COMPARTMENT_SCOPE_ALLPNET_IF_RCV_ADDRESS_TYPENET_IF_RCV_ADDRESS_TYPEPNET_IF_RCV_ADDRESS_LHNET_IF_RCV_ADDRESS_LHPNET_IF_ALIAS_LHNET_IF_ALIAS_LH// FIXME: Switch to union version in 0.4// STRUCT!{struct NET_LUID_LH_Info {//     bitfield: ULONG64,// }}// BITFIELD!{NET_LUID_LH_Info bitfield: ULONG64 [//     Reserved set_Reserved[0..24],//     NetLuidIndex set_NetLuidIndex[24..48],//     IfType set_IfType[48..64],// ]}// UNION!{struct NET_LUID_LH {//     [u64; 1],//     Value Value_mut: ULONG64,//     Info Info_mut: NET_LUID_LH_Info,PNET_LUID_LHNET_IF_RCV_ADDRESSPNET_IF_RCV_ADDRESSNET_IF_ALIASPNET_IF_ALIASNET_LUIDPNET_LUIDIF_LUIDPIF_LUIDNET_IFINDEXPNET_IFINDEXNET_IFTYPEPNET_IFTYPEIF_INDEXPIF_INDEXPNET_IF_CONNECTION_TYPENET_IF_CONNECTION_TYPEPTUNNEL_TYPETUNNEL_TYPEPNET_IF_ACCESS_TYPENET_IF_ACCESS_TYPEPNET_IF_DIRECTION_TYPENET_IF_DIRECTION_TYPEPNET_IF_MEDIA_CONNECT_STATENET_IF_MEDIA_CONNECT_STATEPNET_IF_MEDIA_DUPLEX_STATENET_IF_MEDIA_DUPLEX_STATEPNET_PHYSICAL_LOCATION_LHNET_PHYSICAL_LOCATION_LHIF_MAX_STRING_SIZEIF_MAX_PHYS_ADDRESS_LENGTHPIF_COUNTED_STRING_LHIF_COUNTED_STRING_LHPIF_PHYSICAL_ADDRESS_LHIF_PHYSICAL_ADDRESS_LHNET_PHYSICAL_LOCATIONPNET_PHYSICAL_LOCATIONIF_COUNTED_STRINGPIF_COUNTED_STRINGIF_PHYSICAL_ADDRESSPIF_PHYSICAL_ADDRESSPIF_ADMINISTRATIVE_STATEIF_ADMINISTRATIVE_STATEPNDIS_INTERFACE_INFORMATIONNDIS_INTERFACE_INFORMATIONifdef// #include <winapifamily.h>// #include <ifdef.h>ipifconsIFTYPEINTERNAL_IF_OPER_STATUSANY_SIZEPMIB_IFNUMBERMIB_IFNUMBERMAXLEN_PHYSADDRMAXLEN_IFDESCRMAX_INTERFACE_NAME_LENPMIB_IFROWMIB_IFROWPMIB_IFTABLEMIB_IFTABLE//! Contains the public definitions and structures for the non-TCP/IP specific parts of MIB-II.// FIXME: SIZEOF_IFTABLE(x)PIN6_ADDRLPIN6_ADDR//! IPv6 Internet address, 'on-wire' format structure.PIN_ADDRLPIN_ADDR//! IPv4 Internet address, 'on-wire' format structure.MIN_IF_TYPEIF_TYPE_OTHERIF_TYPE_REGULAR_1822IF_TYPE_HDH_1822IF_TYPE_DDN_X25IF_TYPE_RFC877_X25IF_TYPE_ETHERNET_CSMACDIF_TYPE_IS088023_CSMACDIF_TYPE_ISO88024_TOKENBUSIF_TYPE_ISO88025_TOKENRINGIF_TYPE_ISO88026_MANIF_TYPE_STARLANIF_TYPE_PROTEON_10MBITIF_TYPE_PROTEON_80MBITIF_TYPE_HYPERCHANNELIF_TYPE_FDDIIF_TYPE_LAP_BIF_TYPE_SDLCIF_TYPE_DS1IF_TYPE_E1IF_TYPE_BASIC_ISDNIF_TYPE_PRIMARY_ISDNIF_TYPE_PROP_POINT2POINT_SERIALIF_TYPE_PPPIF_TYPE_SOFTWARE_LOOPBACKIF_TYPE_EONIF_TYPE_ETHERNET_3MBITIF_TYPE_NSIPIF_TYPE_SLIPIF_TYPE_ULTRAIF_TYPE_DS3IF_TYPE_SIPIF_TYPE_FRAMERELAYIF_TYPE_RS232IF_TYPE_PARAIF_TYPE_ARCNETIF_TYPE_ARCNET_PLUSIF_TYPE_ATMIF_TYPE_MIO_X25IF_TYPE_SONETIF_TYPE_X25_PLEIF_TYPE_ISO88022_LLCIF_TYPE_LOCALTALKIF_TYPE_SMDS_DXIIF_TYPE_FRAMERELAY_SERVICEIF_TYPE_V35IF_TYPE_HSSIIF_TYPE_HIPPIIF_TYPE_MODEMIF_TYPE_AAL5IF_TYPE_SONET_PATHIF_TYPE_SONET_VTIF_TYPE_SMDS_ICIPIF_TYPE_PROP_VIRTUALIF_TYPE_PROP_MULTIPLEXORIF_TYPE_IEEE80212IF_TYPE_FIBRECHANNELIF_TYPE_HIPPIINTERFACEIF_TYPE_FRAMERELAY_INTERCONNECTIF_TYPE_AFLANE_8023IF_TYPE_AFLANE_8025IF_TYPE_CCTEMULIF_TYPE_FASTETHERIF_TYPE_ISDNIF_TYPE_V11IF_TYPE_V36IF_TYPE_G703_64KIF_TYPE_G703_2MBIF_TYPE_QLLCIF_TYPE_FASTETHER_FXIF_TYPE_CHANNELIF_TYPE_IEEE80211IF_TYPE_IBM370PARCHANIF_TYPE_ESCONIF_TYPE_DLSWIF_TYPE_ISDN_SIF_TYPE_ISDN_UIF_TYPE_LAP_DIF_TYPE_IPSWITCHIF_TYPE_RSRBIF_TYPE_ATM_LOGICALIF_TYPE_DS0IF_TYPE_DS0_BUNDLEIF_TYPE_BSCIF_TYPE_ASYNCIF_TYPE_CNRIF_TYPE_ISO88025R_DTRIF_TYPE_EPLRSIF_TYPE_ARAPIF_TYPE_PROP_CNLSIF_TYPE_HOSTPADIF_TYPE_TERMPADIF_TYPE_FRAMERELAY_MPIIF_TYPE_X213IF_TYPE_ADSLIF_TYPE_RADSLIF_TYPE_SDSLIF_TYPE_VDSLIF_TYPE_ISO88025_CRFPRINTIF_TYPE_MYRINETIF_TYPE_VOICE_EMIF_TYPE_VOICE_FXOIF_TYPE_VOICE_FXSIF_TYPE_VOICE_ENCAPIF_TYPE_VOICE_OVERIPIF_TYPE_ATM_DXIIF_TYPE_ATM_FUNIIF_TYPE_ATM_IMAIF_TYPE_PPPMULTILINKBUNDLEIF_TYPE_IPOVER_CDLCIF_TYPE_IPOVER_CLAWIF_TYPE_STACKTOSTACKIF_TYPE_VIRTUALIPADDRESSIF_TYPE_MPCIF_TYPE_IPOVER_ATMIF_TYPE_ISO88025_FIBERIF_TYPE_TDLCIF_TYPE_GIGABITETHERNETIF_TYPE_HDLCIF_TYPE_LAP_FIF_TYPE_V37IF_TYPE_X25_MLPIF_TYPE_X25_HUNTGROUPIF_TYPE_TRANSPHDLCIF_TYPE_INTERLEAVEIF_TYPE_FASTIF_TYPE_IPIF_TYPE_DOCSCABLE_MACLAYERIF_TYPE_DOCSCABLE_DOWNSTREAMIF_TYPE_DOCSCABLE_UPSTREAMIF_TYPE_A12MPPSWITCHIF_TYPE_TUNNELIF_TYPE_COFFEEIF_TYPE_CESIF_TYPE_ATM_SUBINTERFACEIF_TYPE_L2_VLANIF_TYPE_L3_IPVLANIF_TYPE_L3_IPXVLANIF_TYPE_DIGITALPOWERLINEIF_TYPE_MEDIAMAILOVERIPIF_TYPE_DTMIF_TYPE_DCNIF_TYPE_IPFORWARDIF_TYPE_MSDSLIF_TYPE_IEEE1394IF_TYPE_IF_GSNIF_TYPE_DVBRCC_MACLAYERIF_TYPE_DVBRCC_DOWNSTREAMIF_TYPE_DVBRCC_UPSTREAMIF_TYPE_ATM_VIRTUALIF_TYPE_MPLS_TUNNELIF_TYPE_SRPIF_TYPE_VOICEOVERATMIF_TYPE_VOICEOVERFRAMERELAYIF_TYPE_IDSLIF_TYPE_COMPOSITELINKIF_TYPE_SS7_SIGLINKIF_TYPE_PROP_WIRELESS_P2PIF_TYPE_FR_FORWARDIF_TYPE_RFC1483IF_TYPE_USBIF_TYPE_IEEE8023AD_LAGIF_TYPE_BGP_POLICY_ACCOUNTINGIF_TYPE_FRF16_MFR_BUNDLEIF_TYPE_H323_GATEKEEPERIF_TYPE_H323_PROXYIF_TYPE_MPLSIF_TYPE_MF_SIGLINKIF_TYPE_HDSL2IF_TYPE_SHDSLIF_TYPE_DS1_FDLIF_TYPE_POSIF_TYPE_DVB_ASI_INIF_TYPE_DVB_ASI_OUTIF_TYPE_PLCIF_TYPE_NFASIF_TYPE_TR008IF_TYPE_GR303_RDTIF_TYPE_GR303_IDTIF_TYPE_ISUPIF_TYPE_PROP_DOCS_WIRELESS_MACLAYERIF_TYPE_PROP_DOCS_WIRELESS_DOWNSTREAMIF_TYPE_PROP_DOCS_WIRELESS_UPSTREAMIF_TYPE_HIPERLAN2IF_TYPE_PROP_BWA_P2MPIF_TYPE_SONET_OVERHEAD_CHANNELIF_TYPE_DIGITAL_WRAPPER_OVERHEAD_CHANNELIF_TYPE_AAL2IF_TYPE_RADIO_MACIF_TYPE_ATM_RADIOIF_TYPE_IMTIF_TYPE_MVLIF_TYPE_REACH_DSLIF_TYPE_FR_DLCI_ENDPTIF_TYPE_ATM_VCI_ENDPTIF_TYPE_OPTICAL_CHANNELIF_TYPE_OPTICAL_TRANSPORTIF_TYPE_IEEE80216_WMANIF_TYPE_WWANPPIF_TYPE_WWANPP2IF_TYPE_IEEE802154IF_TYPE_XBOX_WIRELESSMAX_IF_TYPEMIB_IF_TYPE_OTHERMIB_IF_TYPE_ETHERNETMIB_IF_TYPE_TOKENRINGMIB_IF_TYPE_FDDIMIB_IF_TYPE_PPPMIB_IF_TYPE_LOOPBACKMIB_IF_TYPE_SLIPMIB_IF_ADMIN_STATUS_UPMIB_IF_ADMIN_STATUS_DOWNMIB_IF_ADMIN_STATUS_TESTINGMIB_IF_OPER_STATUS_NON_OPERATIONALMIB_IF_OPER_STATUS_UNREACHABLEMIB_IF_OPER_STATUS_DISCONNECTEDMIB_IF_OPER_STATUS_CONNECTINGMIB_IF_OPER_STATUS_CONNECTEDMIB_IF_OPER_STATUS_OPERATIONAL//! Constants needed for the Interface ObjectifmibnldefNL_ROUTE_PROTOCOLPMIB_IPADDRROW_XPMIB_IPADDRROW_XPPMIB_IPADDRROW_W2KMIB_IPADDRROW_W2KMIB_IPADDRROWPMIB_IPADDRROWPMIB_IPADDRTABLEMIB_IPADDRTABLE// FIXME: SIZEOF_IPADDRTABLE(x)PMIB_IPFORWARDNUMBERMIB_IPFORWARDNUMBERMIB_IPFORWARD_PROTOPMIB_IPFORWARDROWMIB_IPFORWARDROWPMIB_IPFORWARDTABLEMIB_IPFORWARDTABLE// FIXME: SIZEOF_IPFORWARDTABLE(x)PMIB_IPNETROW_LHMIB_IPNETROW_LHPMIB_IPNETROW_W2KMIB_IPNETROW_W2KMIB_IPNETROWPMIB_IPNETROWPMIB_IPNETTABLEMIB_IPNETTABLE// FIXME: SIZEOF_IPNETTABLE(x)PMIB_IPSTATS_FORWARDINGMIB_IPSTATS_FORWARDINGPMIB_IPSTATS_LHMIB_IPSTATS_LHPMIB_IPSTATS_W2KMIB_IPSTATS_W2KMIB_IPSTATSPMIB_IPSTATSPMIBICMPSTATSMIBICMPSTATSPMIB_ICMPMIB_ICMPPMIBICMPSTATS_EX_XPSP1MIBICMPSTATS_EX_XPSP1MIBICMPSTATS_EXPMIBICMPSTATS_EXPMIB_ICMP_EX_XPSP1MIB_ICMP_EX_XPSP1MIB_ICMP_EXPMIB_ICMP_EXPICMP6_TYPEICMP6_TYPEPICMP4_TYPEICMP4_TYPEPMIB_IPMCAST_OIF_XPMIB_IPMCAST_OIF_XPPMIB_IPMCAST_OIF_W2KMIB_IPMCAST_OIF_W2KMIB_IPMCAST_OIFPMIB_IPMCAST_OIFPMIB_IPMCAST_MFEMIB_IPMCAST_MFEPMIB_MFE_TABLEMIB_MFE_TABLE// FIXME: SIZEOF_BASIC_MIB_MFE// FIXME: SIZEOF_MIB_MFE(x)PMIB_IPMCAST_OIF_STATS_LHMIB_IPMCAST_OIF_STATS_LHPMIB_IPMCAST_OIF_STATS_W2KMIB_IPMCAST_OIF_STATS_W2KMIB_IPMCAST_OIF_STATSPMIB_IPMCAST_OIF_STATSPMIB_IPMCAST_MFE_STATSMIB_IPMCAST_MFE_STATSPMIB_MFE_STATS_TABLEMIB_MFE_STATS_TABLE// FIXME: SIZEOF_BASIC_MIB_MFE_STATS// FIXME: SIZEOF_MIB_MFE_STATS(x)PMIB_IPMCAST_MFE_STATS_EX_XPMIB_IPMCAST_MFE_STATS_EX_XPMIB_IPMCAST_MFE_STATS_EXPMIB_IPMCAST_MFE_STATS_EXPMIB_MFE_STATS_TABLE_EX_XPMIB_MFE_STATS_TABLE_EX_XPMIB_MFE_STATS_TABLE_EXPMIB_MFE_STATS_TABLE_EX// FIXME: SIZEOF_BASIC_MIB_MFE_STATS_EX// FIXME: SIZEOF_MIB_MFE_STATS_EX(x)PMIB_IPMCAST_GLOBALMIB_IPMCAST_GLOBALPMIB_IPMCAST_IF_ENTRYMIB_IPMCAST_IF_ENTRYPMIB_IPMCAST_IF_TABLEMIB_IPMCAST_IF_TABLE// FIXME: SIZEOF_MCAST_IF_TABLE(x)ipmib// #include <mprapidef.h>// #include <ipifcons.h>// #include <ipmib.h>// #include <tcpmib.h>// #include <udpmib.h>MAX_SCOPE_NAME_LENMAX_MIB_OFFSETPMIB_OPAQUE_QUERYMIB_OPAQUE_QUERYPTCP_TABLE_CLASSTCP_TABLE_CLASSPUDP_TABLE_CLASSUDP_TABLE_CLASSPTCPIP_OWNER_MODULE_INFO_CLASSTCPIP_OWNER_MODULE_INFO_CLASSPTCPIP_OWNER_MODULE_BASIC_INFOTCPIP_OWNER_MODULE_BASIC_INFOPMIB_IPMCAST_BOUNDARYMIB_IPMCAST_BOUNDARYPMIB_IPMCAST_BOUNDARY_TABLEMIB_IPMCAST_BOUNDARY_TABLEPMIB_BOUNDARYROWMIB_BOUNDARYROWPMIB_MCAST_LIMIT_ROWMIB_MCAST_LIMIT_ROWSN_CHARSCOPE_NAME_BUFFERSCOPE_NAMEPMIB_IPMCAST_SCOPEMIB_IPMCAST_SCOPEPMIB_IPDESTROWMIB_IPDESTROWPMIB_IPDESTTABLEMIB_IPDESTTABLEPMIB_BEST_IFMIB_BEST_IFPMIB_PROXYARPMIB_PROXYARPPMIB_IFSTATUSMIB_IFSTATUSPMIB_ROUTESTATEMIB_ROUTESTATEPMIB_OPAQUE_INFOMIB_OPAQUE_INFO// Licensed under the MIT License <LICENSE.md>//! Mappings for the contents of ks.hSPEAKER_FRONT_LEFT//1720SPEAKER_FRONT_RIGHTSPEAKER_FRONT_CENTERSPEAKER_LOW_FREQUENCYSPEAKER_BACK_LEFTSPEAKER_BACK_RIGHTSPEAKER_FRONT_LEFT_OF_CENTERSPEAKER_FRONT_RIGHT_OF_CENTERSPEAKER_BACK_CENTERSPEAKER_SIDE_LEFTSPEAKER_SIDE_RIGHTSPEAKER_TOP_CENTERSPEAKER_TOP_FRONT_LEFTSPEAKER_TOP_FRONT_CENTERSPEAKER_TOP_FRONT_RIGHTSPEAKER_TOP_BACK_LEFTSPEAKER_TOP_BACK_CENTERSPEAKER_TOP_BACK_RIGHTSPEAKER_RESERVEDSPEAKER_ALLKSAUDIO_SPEAKER_DIRECTOUTKSAUDIO_SPEAKER_MONOKSAUDIO_SPEAKER_1POINT1KSAUDIO_SPEAKER_STEREOKSAUDIO_SPEAKER_2POINT1KSAUDIO_SPEAKER_3POINT0KSAUDIO_SPEAKER_3POINT1KSAUDIO_SPEAKER_QUADKSAUDIO_SPEAKER_SURROUNDKSAUDIO_SPEAKER_5POINT0KSAUDIO_SPEAKER_5POINT1KSAUDIO_SPEAKER_7POINT0KSAUDIO_SPEAKER_7POINT1KSAUDIO_SPEAKER_5POINT1_SURROUNDKSAUDIO_SPEAKER_7POINT1_SURROUND//! Mappings for the contents of ksmedia.hUOWPUOWCRM_PROTOCOL_IDPCRM_PROTOCOL_IDTRANSACTION_MANAGER_VOLATILETRANSACTION_MANAGER_COMMIT_DEFAULTTRANSACTION_MANAGER_COMMIT_SYSTEM_VOLUMETRANSACTION_MANAGER_COMMIT_SYSTEM_HIVESTRANSACTION_MANAGER_COMMIT_LOWESTTRANSACTION_MANAGER_CORRUPT_FOR_RECOVERYTRANSACTION_MANAGER_CORRUPT_FOR_PROGRESSTRANSACTION_MANAGER_MAXIMUM_OPTIONTRANSACTION_DO_NOT_PROMOTETRANSACTION_MAXIMUM_OPTIONRESOURCE_MANAGER_VOLATILERESOURCE_MANAGER_COMMUNICATIONRESOURCE_MANAGER_MAXIMUM_OPTIONCRM_PROTOCOL_EXPLICIT_MARSHAL_ONLYCRM_PROTOCOL_DYNAMIC_MARSHAL_INFOCRM_PROTOCOL_MAXIMUM_OPTIONENLISTMENT_SUPERIORENLISTMENT_MAXIMUM_OPTIONNOTIFICATION_MASKTRANSACTION_NOTIFY_MASKTRANSACTION_NOTIFY_PREPREPARETRANSACTION_NOTIFY_PREPARETRANSACTION_NOTIFY_COMMITTRANSACTION_NOTIFY_ROLLBACKTRANSACTION_NOTIFY_PREPREPARE_COMPLETETRANSACTION_NOTIFY_PREPARE_COMPLETETRANSACTION_NOTIFY_COMMIT_COMPLETETRANSACTION_NOTIFY_ROLLBACK_COMPLETETRANSACTION_NOTIFY_RECOVERTRANSACTION_NOTIFY_SINGLE_PHASE_COMMITTRANSACTION_NOTIFY_DELEGATE_COMMITTRANSACTION_NOTIFY_RECOVER_QUERYTRANSACTION_NOTIFY_ENLIST_PREPREPARETRANSACTION_NOTIFY_LAST_RECOVERTRANSACTION_NOTIFY_INDOUBTTRANSACTION_NOTIFY_PROPAGATE_PULLTRANSACTION_NOTIFY_PROPAGATE_PUSHTRANSACTION_NOTIFY_MARSHALTRANSACTION_NOTIFY_ENLIST_MASKTRANSACTION_NOTIFY_RM_DISCONNECTEDTRANSACTION_NOTIFY_TM_ONLINETRANSACTION_NOTIFY_COMMIT_REQUESTTRANSACTION_NOTIFY_PROMOTETRANSACTION_NOTIFY_PROMOTE_NEWTRANSACTION_NOTIFY_REQUEST_OUTCOMETRANSACTION_NOTIFY_COMMIT_FINALIZETRANSACTIONMANAGER_OBJECT_PATHTRANSACTION_OBJECT_PATHENLISTMENT_OBJECT_PATHRESOURCE_MANAGER_OBJECT_PATHPTRANSACTION_NOTIFICATIONTRANSACTION_NOTIFICATIONPTRANSACTION_NOTIFICATION_RECOVERY_ARGUMENTTRANSACTION_NOTIFICATION_RECOVERY_ARGUMENTTRANSACTION_NOTIFICATION_TM_ONLINE_FLAG_IS_CLUSTEREDPTRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENTTRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENTSAVEPOINT_IDPSAVEPOINT_IDPTRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENTTRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENTPTRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENTTRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENTPTRANSACTION_NOTIFICATION_MARSHAL_ARGUMENTTRANSACTION_NOTIFICATION_MARSHAL_ARGUMENTTRANSACTION_NOTIFICATION_PROMOTE_ARGUMENTPTRANSACTION_NOTIFICATION_PROMOTE_ARGUMENTKTM_MARSHAL_BLOB_VERSION_MAJORKTM_MARSHAL_BLOB_VERSION_MINORMAX_TRANSACTION_DESCRIPTION_LENGTHMAX_RESOURCEMANAGER_DESCRIPTION_LENGTHPKCRM_MARSHAL_HEADERKCRM_MARSHAL_HEADERPRKCRM_MARSHAL_HEADERPKCRM_TRANSACTION_BLOBKCRM_TRANSACTION_BLOBPRKCRM_TRANSACTION_BLOBPKCRM_PROTOCOL_BLOBKCRM_PROTOCOL_BLOBPRKCRM_PROTOCOL_BLOB//! Common types for KTM exposed at both the Nt- and Win32-layerCNLENLM20_CNLENDNLENLM20_DNLENUNCLENLM20_UNCLENNNLENLM20_NNLENRMLENLM20_RMLENSNLENLM20_SNLENSTXTLENLM20_STXTLENPATHLENLM20_PATHLENDEVLENLM20_DEVLENEVLENUNLENLM20_UNLENGNLENLM20_GNLENPWLENLM20_PWLENSHPWLENCLTYPE_LENMAXCOMMENTSZLM20_MAXCOMMENTSZQNLENLM20_QNLENALERTSZMAXDEVENTRIESNETBIOS_NAME_LEN// FIXME: sizeof(int) instead of 4CRYPT_KEY_LENCRYPT_TXT_LENENCRYPTED_PWLENSESSION_PWLENSESSION_CRYPT_KLENPARM_ERROR_UNKNOWNPARM_ERROR_NONEPARMNUM_BASE_INFOLEVELLMSTRLMCSTRNET_API_STATUSAPI_RET_TYPEPLATFORM_ID_DOSPLATFORM_ID_OS2PLATFORM_ID_NTPLATFORM_ID_OSFPLATFORM_ID_VMS//! This file contains constants used throughout the LAN Manager API header files.PSZPFLOATLPBOOLPBYTELPBYTEPINTLPINTPWORDLPWORDLPLONGPUINTMAKEWORDMAKELONGLOBYTEHIBYTESPHANDLEGLOBALHANDLELOCALHANDLE__some_function/// Pointer to a function with unknown type signature.NEARPROCPROCPHKEYHFILEPFILETIME//! Basic Windows Type Definitions for minwin partitionWAVE_FORMAT_UNKNOWNWAVE_FORMAT_PCMWAVE_FORMAT_ADPCMWAVE_FORMAT_IEEE_FLOATWAVE_FORMAT_VSELPWAVE_FORMAT_IBM_CVSDWAVE_FORMAT_ALAWWAVE_FORMAT_MULAWWAVE_FORMAT_DTSWAVE_FORMAT_DRMWAVE_FORMAT_WMAVOICE9WAVE_FORMAT_WMAVOICE10WAVE_FORMAT_OKI_ADPCMWAVE_FORMAT_DVI_ADPCMWAVE_FORMAT_IMA_ADPCMWAVE_FORMAT_MEDIASPACE_ADPCMWAVE_FORMAT_SIERRA_ADPCMWAVE_FORMAT_G723_ADPCMWAVE_FORMAT_DIGISTDWAVE_FORMAT_DIGIFIXWAVE_FORMAT_DIALOGIC_OKI_ADPCMWAVE_FORMAT_MEDIAVISION_ADPCMWAVE_FORMAT_CU_CODECWAVE_FORMAT_HP_DYN_VOICEWAVE_FORMAT_YAMAHA_ADPCMWAVE_FORMAT_SONARCWAVE_FORMAT_DSPGROUP_TRUESPEECHWAVE_FORMAT_ECHOSC1WAVE_FORMAT_AUDIOFILE_AF36WAVE_FORMAT_APTXWAVE_FORMAT_AUDIOFILE_AF10WAVE_FORMAT_PROSODY_1612WAVE_FORMAT_LRCWAVE_FORMAT_DOLBY_AC2WAVE_FORMAT_GSM610WAVE_FORMAT_MSNAUDIOWAVE_FORMAT_ANTEX_ADPCMEWAVE_FORMAT_CONTROL_RES_VQLPCWAVE_FORMAT_DIGIREALWAVE_FORMAT_DIGIADPCMWAVE_FORMAT_CONTROL_RES_CR10WAVE_FORMAT_NMS_VBXADPCMWAVE_FORMAT_CS_IMAADPCMWAVE_FORMAT_ECHOSC3WAVE_FORMAT_ROCKWELL_ADPCMWAVE_FORMAT_ROCKWELL_DIGITALKWAVE_FORMAT_XEBECWAVE_FORMAT_G721_ADPCMWAVE_FORMAT_G728_CELPWAVE_FORMAT_MSG723WAVE_FORMAT_INTEL_G723_1WAVE_FORMAT_INTEL_G729WAVE_FORMAT_SHARP_G726WAVE_FORMAT_MPEGWAVE_FORMAT_RT24WAVE_FORMAT_PACWAVE_FORMAT_MPEGLAYER3WAVE_FORMAT_LUCENT_G723WAVE_FORMAT_CIRRUSWAVE_FORMAT_ESPCMWAVE_FORMAT_VOXWAREWAVE_FORMAT_CANOPUS_ATRACWAVE_FORMAT_G726_ADPCMWAVE_FORMAT_G722_ADPCMWAVE_FORMAT_DSATWAVE_FORMAT_DSAT_DISPLAYWAVE_FORMAT_VOXWARE_BYTE_ALIGNEDWAVE_FORMAT_VOXWARE_AC8WAVE_FORMAT_VOXWARE_AC10WAVE_FORMAT_VOXWARE_AC16WAVE_FORMAT_VOXWARE_AC20WAVE_FORMAT_VOXWARE_RT24WAVE_FORMAT_VOXWARE_RT29WAVE_FORMAT_VOXWARE_RT29HWWAVE_FORMAT_VOXWARE_VR12WAVE_FORMAT_VOXWARE_VR18WAVE_FORMAT_VOXWARE_TQ40WAVE_FORMAT_VOXWARE_SC3WAVE_FORMAT_VOXWARE_SC3_1WAVE_FORMAT_SOFTSOUNDWAVE_FORMAT_VOXWARE_TQ60WAVE_FORMAT_MSRT24WAVE_FORMAT_G729AWAVE_FORMAT_MVI_MVI2WAVE_FORMAT_DF_G726WAVE_FORMAT_DF_GSM610WAVE_FORMAT_ISIAUDIOWAVE_FORMAT_ONLIVEWAVE_FORMAT_MULTITUDE_FT_SX20WAVE_FORMAT_INFOCOM_ITS_G721_ADPCMWAVE_FORMAT_CONVEDIA_G729WAVE_FORMAT_CONGRUENCYWAVE_FORMAT_SBC24WAVE_FORMAT_DOLBY_AC3_SPDIFWAVE_FORMAT_MEDIASONIC_G723WAVE_FORMAT_PROSODY_8KBPSWAVE_FORMAT_ZYXEL_ADPCMWAVE_FORMAT_PHILIPS_LPCBBWAVE_FORMAT_PACKEDWAVE_FORMAT_MALDEN_PHONYTALKWAVE_FORMAT_RACAL_RECORDER_GSMWAVE_FORMAT_RACAL_RECORDER_G720_AWAVE_FORMAT_RACAL_RECORDER_G723_1WAVE_FORMAT_RACAL_RECORDER_TETRA_ACELPWAVE_FORMAT_NEC_AACWAVE_FORMAT_RAW_AAC1WAVE_FORMAT_RHETOREX_ADPCMWAVE_FORMAT_IRATWAVE_FORMAT_VIVO_G723WAVE_FORMAT_VIVO_SIRENWAVE_FORMAT_PHILIPS_CELPWAVE_FORMAT_PHILIPS_GRUNDIGWAVE_FORMAT_DIGITAL_G723WAVE_FORMAT_SANYO_LD_ADPCMWAVE_FORMAT_SIPROLAB_ACEPLNETWAVE_FORMAT_SIPROLAB_ACELP4800WAVE_FORMAT_SIPROLAB_ACELP8V3WAVE_FORMAT_SIPROLAB_G729WAVE_FORMAT_SIPROLAB_G729AWAVE_FORMAT_SIPROLAB_KELVINWAVE_FORMAT_VOICEAGE_AMRWAVE_FORMAT_G726ADPCMWAVE_FORMAT_DICTAPHONE_CELP68WAVE_FORMAT_DICTAPHONE_CELP54WAVE_FORMAT_QUALCOMM_PUREVOICEWAVE_FORMAT_QUALCOMM_HALFRATEWAVE_FORMAT_TUBGSMWAVE_FORMAT_MSAUDIO1WAVE_FORMAT_WMAUDIO2WAVE_FORMAT_WMAUDIO3WAVE_FORMAT_WMAUDIO_LOSSLESSWAVE_FORMAT_WMASPDIFWAVE_FORMAT_UNISYS_NAP_ADPCMWAVE_FORMAT_UNISYS_NAP_ULAWWAVE_FORMAT_UNISYS_NAP_ALAWWAVE_FORMAT_UNISYS_NAP_16KWAVE_FORMAT_SYCOM_ACM_SYC008WAVE_FORMAT_SYCOM_ACM_SYC701_G726LWAVE_FORMAT_SYCOM_ACM_SYC701_CELP54WAVE_FORMAT_SYCOM_ACM_SYC701_CELP68WAVE_FORMAT_KNOWLEDGE_ADVENTURE_ADPCMWAVE_FORMAT_FRAUNHOFER_IIS_MPEG2_AACWAVE_FORMAT_DTS_DSWAVE_FORMAT_CREATIVE_ADPCMWAVE_FORMAT_CREATIVE_FASTSPEECH8WAVE_FORMAT_CREATIVE_FASTSPEECH10WAVE_FORMAT_UHER_ADPCMWAVE_FORMAT_ULEAD_DV_AUDIOWAVE_FORMAT_ULEAD_DV_AUDIO_1WAVE_FORMAT_QUARTERDECKWAVE_FORMAT_ILINK_VCWAVE_FORMAT_RAW_SPORTWAVE_FORMAT_ESST_AC3WAVE_FORMAT_GENERIC_PASSTHRUWAVE_FORMAT_IPI_HSXWAVE_FORMAT_IPI_RPELPWAVE_FORMAT_CS2WAVE_FORMAT_SONY_SCXWAVE_FORMAT_SONY_SCYWAVE_FORMAT_SONY_ATRAC3WAVE_FORMAT_SONY_SPCWAVE_FORMAT_TELUM_AUDIOWAVE_FORMAT_TELUM_IA_AUDIOWAVE_FORMAT_NORCOM_VOICE_SYSTEMS_ADPCMWAVE_FORMAT_FM_TOWNS_SNDWAVE_FORMAT_MICRONASWAVE_FORMAT_MICRONAS_CELP833WAVE_FORMAT_BTV_DIGITALWAVE_FORMAT_INTEL_MUSIC_CODERWAVE_FORMAT_INDEO_AUDIOWAVE_FORMAT_QDESIGN_MUSICWAVE_FORMAT_ON2_VP7_AUDIOWAVE_FORMAT_ON2_VP6_AUDIOWAVE_FORMAT_VME_VMPCMWAVE_FORMAT_TPCWAVE_FORMAT_LIGHTWAVE_LOSSLESSWAVE_FORMAT_OLIGSMWAVE_FORMAT_OLIADPCMWAVE_FORMAT_OLICELPWAVE_FORMAT_OLISBCWAVE_FORMAT_OLIOPRWAVE_FORMAT_LH_CODECWAVE_FORMAT_LH_CODEC_CELPWAVE_FORMAT_LH_CODEC_SBC8WAVE_FORMAT_LH_CODEC_SBC12WAVE_FORMAT_LH_CODEC_SBC16WAVE_FORMAT_NORRISWAVE_FORMAT_ISIAUDIO_2WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESSWAVE_FORMAT_MPEG_ADTS_AACWAVE_FORMAT_MPEG_RAW_AACWAVE_FORMAT_MPEG_LOASWAVE_FORMAT_NOKIA_MPEG_ADTS_AACWAVE_FORMAT_NOKIA_MPEG_RAW_AACWAVE_FORMAT_VODAFONE_MPEG_ADTS_AACWAVE_FORMAT_VODAFONE_MPEG_RAW_AACWAVE_FORMAT_MPEG_HEAACWAVE_FORMAT_VOXWARE_RT24_SPEECHWAVE_FORMAT_SONICFOUNDRY_LOSSLESSWAVE_FORMAT_INNINGS_TELECOM_ADPCMWAVE_FORMAT_LUCENT_SX8300PWAVE_FORMAT_LUCENT_SX5363SWAVE_FORMAT_CUSEEMEWAVE_FORMAT_NTCSOFT_ALF2CM_ACMWAVE_FORMAT_DVMWAVE_FORMAT_DTS2WAVE_FORMAT_MAKEAVISWAVE_FORMAT_DIVIO_MPEG4_AACWAVE_FORMAT_NOKIA_ADAPTIVE_MULTIRATEWAVE_FORMAT_DIVIO_G726WAVE_FORMAT_LEAD_SPEECHWAVE_FORMAT_LEAD_VORBISWAVE_FORMAT_WAVPACK_AUDIOWAVE_FORMAT_OGG_VORBIS_MODE_1WAVE_FORMAT_OGG_VORBIS_MODE_2WAVE_FORMAT_OGG_VORBIS_MODE_3WAVE_FORMAT_OGG_VORBIS_MODE_1_PLUSWAVE_FORMAT_OGG_VORBIS_MODE_2_PLUSWAVE_FORMAT_OGG_VORBIS_MODE_3_PLUSWAVE_FORMAT_3COM_NBXWAVE_FORMAT_FAAD_AACWAVE_FORMAT_AMR_NBWAVE_FORMAT_AMR_WBWAVE_FORMAT_AMR_WPWAVE_FORMAT_GSM_AMR_CBRWAVE_FORMAT_GSM_AMR_VBR_SIDWAVE_FORMAT_COMVERSE_INFOSYS_G723_1WAVE_FORMAT_COMVERSE_INFOSYS_AVQSBCWAVE_FORMAT_COMVERSE_INFOSYS_SBCWAVE_FORMAT_SYMBOL_G729_AWAVE_FORMAT_VOICEAGE_AMR_WBWAVE_FORMAT_INGENIENT_G726WAVE_FORMAT_MPEG4_AACWAVE_FORMAT_ENCORE_G726WAVE_FORMAT_ZOLL_ASAOWAVE_FORMAT_SPEEX_VOICEWAVE_FORMAT_VIANIX_MASCWAVE_FORMAT_WM9_SPECTRUM_ANALYZERWAVE_FORMAT_WMF_SPECTRUM_ANAYZERWAVE_FORMAT_GSM_610WAVE_FORMAT_GSM_620WAVE_FORMAT_GSM_660WAVE_FORMAT_GSM_690WAVE_FORMAT_GSM_ADAPTIVE_MULTIRATE_WBWAVE_FORMAT_POLYCOM_G722WAVE_FORMAT_POLYCOM_G728WAVE_FORMAT_POLYCOM_G729_AWAVE_FORMAT_POLYCOM_SIRENWAVE_FORMAT_GLOBAL_IP_ILBCWAVE_FORMAT_RADIOTIME_TIME_SHIFT_RADIOWAVE_FORMAT_NICE_ACAWAVE_FORMAT_NICE_ADPCMWAVE_FORMAT_VOCORD_G721WAVE_FORMAT_VOCORD_G726WAVE_FORMAT_VOCORD_G722_1WAVE_FORMAT_VOCORD_G728WAVE_FORMAT_VOCORD_G729WAVE_FORMAT_VOCORD_G729_AWAVE_FORMAT_VOCORD_G723_1WAVE_FORMAT_VOCORD_LBCWAVE_FORMAT_NICE_G728WAVE_FORMAT_FRACE_TELECOM_G729WAVE_FORMAT_CODIANWAVE_FORMAT_FLACWAVE_FORMAT_EXTENSIBLEWAVE_FORMAT_DEVELOPMENT//2557bthioctlbugcodescderrd3d9d3dkmdtdcomptypesdevguiddevpkeydinputddxgi1_6evntracehidclasshidsdiintsafeiprtrmibksmediaktmtypeslmconsmmregmprapidefmswsockdefnetioapintddndisntddscsintddserrpcdcerpcndrsddlsspistraligntcpestatstcpmibtransportsettingcommontvoutudpmibusbioctlusbiodefusbscanusbspecwindot11windowsxwinusbiowlantypeswnncwtypeswtypesbase//! Headers shared between user mode and kernel mode// #include <lmcons.h>MAX_TRANSPORT_NAME_LENMAX_MEDIA_NAMEMAX_PORT_NAMEMAX_DEVICE_NAMEMAX_PHONE_NUMBER_LENMAX_DEVICETYPE_NAME//! MPR (Multiple Provider Router) definitionsIOC_VENDORPTRANSPORT_SETTING_IDTRANSPORT_SETTING_IDPCONTROL_CHANNEL_TRIGGER_STATUSCONTROL_CHANNEL_TRIGGER_STATUSCONTROL_CHANNEL_TRIGGER_STATUS_MAXPREAL_TIME_NOTIFICATION_SETTING_INPUTREAL_TIME_NOTIFICATION_SETTING_INPUTPREAL_TIME_NOTIFICATION_SETTING_INPUT_EXREAL_TIME_NOTIFICATION_SETTING_INPUT_EXPREAL_TIME_NOTIFICATION_SETTING_OUTPUTREAL_TIME_NOTIFICATION_SETTING_OUTPUTPASSOCIATE_NAMERES_CONTEXT_INPUTASSOCIATE_NAMERES_CONTEXT_INPUTSIO_RCVALLSIO_RCVALL_MCASTSIO_RCVALL_IGMPMCASTSIO_ABSORB_RTRALERTSIO_UCAST_IFSIO_LIMIT_BROADCASTSSIO_INDEX_BINDSIO_INDEX_MCASTIFSIO_INDEX_ADD_MCASTSIO_INDEX_DEL_MCASTSIO_RCVALL_MCAST_IFSIO_RCVALL_IFSIO_LOOPBACK_FAST_PATHSIO_TCP_INITIAL_RTOSIO_APPLY_TRANSPORT_SETTINGSIO_QUERY_TRANSPORT_SETTINGSIO_TCP_SET_ICWSIO_TCP_SET_ACK_FREQUENCYSIO_TCP_INFOPRCVALL_VALUERCVALL_VALUEPRCVALL_IFRCVALL_IFTCP_INITIAL_RTO_UNSPECIFIED_RTTTCP_INITIAL_RTO_UNSPECIFIED_MAX_SYN_RETRANSMISSIONSTCP_INITIAL_RTO_DEFAULT_RTTTCP_INITIAL_RTO_DEFAULT_MAX_SYN_RETRANSMISSIONSPTCP_INITIAL_RTO_PARAMETERSTCP_INITIAL_RTO_PARAMETERSPTCP_ICW_LEVELTCP_ICW_LEVELPTCP_ICW_PARAMETERSTCP_ICW_PARAMETERSPTCP_ACK_FREQUENCY_PARAMETERSTCP_ACK_FREQUENCY_PARAMETERSPTCP_INFO_v0TCP_INFO_v0SIO_ACQUIRE_PORT_RESERVATIONSIO_RELEASE_PORT_RESERVATIONSIO_ASSOCIATE_PORT_RESERVATIONPINET_PORT_RANGEINET_PORT_RANGEINET_PORT_RESERVATIONPINET_PORT_RESERVATIONPINET_PORT_RESERVATION_TOKENINET_PORT_RESERVATION_TOKENPINET_PORT_RESERVATION_INSTANCEINET_PORT_RESERVATION_INSTANCEPINET_PORT_RESERVATION_INFORMATIONINET_PORT_RESERVATION_INFORMATIONSIO_SET_SECURITYSIO_QUERY_SECURITYSIO_SET_PEER_TARGET_NAMESIO_DELETE_PEER_TARGET_NAMESIO_QUERY_WFP_CONNECTION_REDIRECT_RECORDSSIO_QUERY_WFP_CONNECTION_REDIRECT_CONTEXTSIO_SET_WFP_CONNECTION_REDIRECT_RECORDSSIO_SOCKET_USAGE_NOTIFICATIONSOCKET_SETTINGS_IPSEC_SKIP_FILTER_INSTANTIATIONSOCKET_SETTINGS_IPSEC_OPTIONAL_PEER_NAME_VERIFICATIONSOCKET_SETTINGS_IPSEC_ALLOW_FIRST_INBOUND_PKT_UNENCRYPTEDSOCKET_SETTINGS_IPSEC_PEER_NAME_IS_RAW_FORMATSOCKET_QUERY_IPSEC2_ABORT_CONNECTION_ON_FIELD_CHANGESOCKET_QUERY_IPSEC2_FIELD_MASK_MM_SA_IDSOCKET_QUERY_IPSEC2_FIELD_MASK_QM_SA_IDSOCKET_INFO_CONNECTION_SECUREDSOCKET_INFO_CONNECTION_ENCRYPTEDSOCKET_INFO_CONNECTION_IMPERSONATEDSIO_QUERY_WFP_ALE_ENDPOINT_HANDLESIO_QUERY_RSS_SCALABILITY_INFOPRSS_SCALABILITY_INFORSS_SCALABILITY_INFOIN4_CLASSAIN4_CLASSBIN4_CLASSCIN4_CLASSDIN4_MULTICASTIN4ADDR_ANYIN4ADDR_LOOPBACKIN4ADDR_BROADCASTIN4ADDR_NONEIN4ADDR_LOOPBACKPREFIX_LENGTHIN4ADDR_LINKLOCALPREFIX_LENGTHIN4ADDR_MULTICASTPREFIX_LENGTHIN4_ADDR_EQUALIN4_UNALIGNED_ADDR_EQUALIN4_IS_ADDR_UNSPECIFIEDIN4_IS_UNALIGNED_ADDR_UNSPECIFIEDIN4_IS_ADDR_LOOPBACKIN4_IS_UNALIGNED_ADDR_LOOPBACKIN4_IS_ADDR_BROADCASTIN4_IS_UNALIGNED_ADDR_BROADCASTIN4_IS_ADDR_MULTICASTIN4_IS_UNALIGNED_ADDR_MULTICASTIN4_IS_ADDR_LINKLOCALIN4_IS_UNALIGNED_ADDR_LINKLOCALIN4_IS_ADDR_SITELOCALIN4_IS_UNALIGNED_ADDR_SITELOCALIN4_IS_ADDR_RFC1918IN4_IS_UNALIGNED_ADDR_RFC1918IN4_IS_ADDR_MC_LINKLOCALIN4_IS_ADDR_MC_ADMINLOCALIN4_IS_ADDR_MC_SITELOCALIN4ADDR_ISANYIN4ADDR_ISLOOPBACKRtlIpv4AddressToStringARtlIpv4AddressToStringExARtlIpv4AddressToStringWRtlIpv4AddressToStringExWRtlIpv4StringToAddressARtlIpv4StringToAddressExARtlIpv4StringToAddressWRtlIpv4StringToAddressExWRtlIpv6AddressToStringARtlIpv6AddressToStringExARtlIpv6AddressToStringWRtlIpv6AddressToStringExWRtlIpv6StringToAddressARtlIpv6StringToAddressExARtlIpv6StringToAddressWRtlIpv6StringToAddressExWPDL_EUI48DL_EUI48RtlEthernetAddressToStringARtlEthernetAddressToStringWRtlEthernetStringToAddressARtlEthernetStringToAddressW//! This module contains Microsoft-specific extensions to the core Winsock definitions.SIO_SET_COMPATIBILITY_MODEPWSA_COMPATIBILITY_BEHAVIOR_IDWSA_COMPATIBILITY_BEHAVIOR_IDPWSA_COMPATIBILITY_MODEWSA_COMPATIBILITY_MODERIO_BUFFERIDPRIO_BUFFERIDRIO_CQPRIO_CQRIO_RQPRIO_RQPRIORESULTRIORESULTPRIO_BUFRIO_BUFRIO_MSG_DONT_NOTIFYRIO_MSG_DEFERRIO_MSG_WAITALLRIO_MSG_COMMIT_ONLYRIO_INVALID_BUFFERIDRIO_INVALID_CQRIO_INVALID_RQRIO_MAX_CQ_SIZERIO_CORRUPT_CQIF_OPER_STATUSNL_BANDWIDTH_INFORMATIONNL_DAD_STATENL_INTERFACE_OFFLOAD_RODNL_LINK_LOCAL_ADDRESS_BEHAVIORNL_NEIGHBOR_STATENL_PREFIX_ORIGINNL_ROUTER_DISCOVERY_BEHAVIORNL_ROUTE_ORIGINNL_SUFFIX_ORIGINNDIS_MEDIUMNDIS_PHYSICAL_MEDIUMSCOPE_IDScopeLevelCountPSOCKADDR_IN6_PAIRSOCKADDR_INETNETIO_STATUSNETIOAPI_APIPMIB_NOTIFICATION_TYPEMIB_NOTIFICATION_TYPEPMIB_IF_ROW2PMIB_IF_TABLE2PMIB_IF_ENTRY_LEVELMIB_IF_ENTRY_LEVELGetIfEntry2ExPMIB_IF_TABLE_LEVELMIB_IF_TABLE_LEVELGetIfTable2ExPMIB_IPINTERFACE_ROWMIB_IPINTERFACE_ROWPMIB_IPINTERFACE_TABLEMIB_IPINTERFACE_TABLEPMIB_IFSTACK_ROWMIB_IFSTACK_ROWPMIB_INVERTEDIFSTACK_ROWMIB_INVERTEDIFSTACK_ROWPMIB_IFSTACK_TABLEMIB_IFSTACK_TABLEPMIB_INVERTEDIFSTACK_TABLEMIB_INVERTEDIFSTACK_TABLEPMIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATESMIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATESGetIfStackTableGetInvertedIfStackTableGetIpInterfaceEntryGetIpInterfaceTableInitializeIpInterfaceEntryNotifyIpInterfaceChangePIPINTERFACE_CHANGE_CALLBACKSetIpInterfaceEntryGetIpNetworkConnectionBandwidthEstimatesPMIB_UNICASTIPADDRESS_ROWMIB_UNICASTIPADDRESS_ROWPMIB_UNICASTIPADDRESS_TABLEMIB_UNICASTIPADDRESS_TABLECreateUnicastIpAddressEntryDeleteUnicastIpAddressEntryGetUnicastIpAddressEntryGetUnicastIpAddressTableInitializeUnicastIpAddressEntryNotifyUnicastIpAddressChangePUNICAST_IPADDRESS_CHANGE_CALLBACKNotifyStableUnicastIpAddressTablePSTABLE_UNICAST_IPADDRESS_TABLE_CALLBACKSetUnicastIpAddressEntryPMIB_ANYCASTIPADDRESS_ROWMIB_ANYCASTIPADDRESS_ROWPMIB_ANYCASTIPADDRESS_TABLEMIB_ANYCASTIPADDRESS_TABLECreateAnycastIpAddressEntryDeleteAnycastIpAddressEntryGetAnycastIpAddressEntryGetAnycastIpAddressTablePMIB_MULTICASTIPADDRESS_ROWMIB_MULTICASTIPADDRESS_ROWPMIB_MULTICASTIPADDRESS_TABLEMIB_MULTICASTIPADDRESS_TABLEGetMulticastIpAddressEntryGetMulticastIpAddressTablePIP_ADDRESS_PREFIXIP_ADDRESS_PREFIXPMIB_IPFORWARD_ROW2MIB_IPFORWARD_ROW2PMIB_IPFORWARD_TABLE2MIB_IPFORWARD_TABLE2CreateIpForwardEntry2DeleteIpForwardEntry2GetBestRoute2GetIpForwardEntry2GetIpForwardTable2InitializeIpForwardEntryNotifyRouteChange2PIPFORWARD_CHANGE_CALLBACKSetIpForwardEntry2PMIB_IPPATH_ROWMIB_IPPATH_ROWPMIB_IPPATH_TABLEMIB_IPPATH_TABLEFlushIpPathTableGetIpPathEntryGetIpPathTablePMIB_IPNET_ROW2MIB_IPNET_ROW2PMIB_IPNET_TABLE2MIB_IPNET_TABLE2CreateIpNetEntry2DeleteIpNetEntry2FlushIpNetTable2GetIpNetEntry2GetIpNetTable2ResolveIpNetEntry2SetIpNetEntry2MIB_INVALID_TEREDO_PORT_NUMBERNotifyTeredoPortChangePTEREDO_PORT_CHANGE_CALLBACKGetTeredoPortCancelMibChangeNotify2CreateSortedAddressPairsConvertCompartmentGuidToIdConvertCompartmentIdToGuidConvertInterfaceNameToLuidAConvertInterfaceNameToLuidWConvertInterfaceLuidToNameAConvertInterfaceLuidToNameWConvertInterfaceLuidToIndexConvertInterfaceIndexToLuidConvertInterfaceLuidToAliasConvertInterfaceAliasToLuidConvertInterfaceLuidToGuidConvertInterfaceGuidToLuidGetCurrentThreadCompartmentIdSetCurrentThreadCompartmentIdGetCurrentThreadCompartmentScopeSetCurrentThreadCompartmentScopeGetJobCompartmentIdSetJobCompartmentIdGetSessionCompartmentIdSetSessionCompartmentIdGetDefaultCompartmentIdGetNetworkInformationSetNetworkInformationConvertLengthToIpv4MaskConvertIpv4MaskToLengthDNS_SETTINGS_VERSION1DNS_INTERFACE_SETTINGS_VERSION1DNS_SETTING_IPV6DNS_SETTING_NAMESERVERDNS_SETTING_SEARCHLISTDNS_SETTING_REGISTRATION_ENABLEDDNS_SETTING_REGISTER_ADAPTER_NAMEDNS_SETTING_DOMAINDNS_SETTING_HOSTNAMEDNS_SETTINGS_ENABLE_LLMNRDNS_SETTINGS_QUERY_ADAPTER_NAMEDNS_SETTING_PROFILE_NAMESERVERGetDnsSettingsDNS_SETTINGSFreeDnsSettingsSetDnsSettingsGetInterfaceDnsSettingsDNS_INTERFACE_SETTINGSFreeInterfaceDnsSettingsSetInterfaceDnsSettingsNlpoOtherNlpoManualNlpoWellKnownNlpoDhcpNlpoRouterAdvertisementNL_MAX_METRIC_COMPONENTPNL_ROUTE_PROTOCOLPNL_ADDRESS_TYPENL_ADDRESS_TYPEPNL_ROUTE_ORIGINPNL_NEIGHBOR_STATEPNL_INTERFACE_OFFLOAD_RODPNL_BANDWIDTH_FLAGNL_BANDWIDTH_FLAGPNL_PATH_BANDWIDTH_RODNL_PATH_BANDWIDTH_RODPNL_NETWORK_CATEGORYNL_NETWORK_CATEGORYPNL_INTERFACE_NETWORK_CATEGORY_STATENL_INTERFACE_NETWORK_CATEGORY_STATENET_IF_CURRENT_SESSIONPNL_BANDWIDTH_INFORMATION//290PNDIS_OBJECT_HEADERNDIS_OBJECT_HEADER//2274PNDIS_MEDIUMPNDIS_PHYSICAL_MEDIUMNDIS_STATUS//2691PNDIS_STATUSNDIS_PACKET_TYPE_DIRECTED//2736NDIS_PACKET_TYPE_MULTICASTNDIS_PACKET_TYPE_ALL_MULTICASTNDIS_PACKET_TYPE_BROADCASTNDIS_PACKET_TYPE_PROMISCUOUSNDIS_IF_MAX_STRING_SIZE//2835DEVICE_TYPEFILE_DEVICE_CONTROLLERFILE_READ_ACCESSFILE_WRITE_ACCESSPBOOLEANIOCTL_SCSI_BASEFILE_DEVICE_SCSIDD_SCSI_DEVICE_NAMEIOCTL_SCSI_PASS_THROUGHIOCTL_SCSI_MINIPORTIOCTL_SCSI_GET_INQUIRY_DATAIOCTL_SCSI_GET_CAPABILITIESIOCTL_SCSI_PASS_THROUGH_DIRECTIOCTL_SCSI_GET_ADDRESSIOCTL_SCSI_RESCAN_BUSIOCTL_SCSI_GET_DUMP_POINTERSIOCTL_SCSI_FREE_DUMP_POINTERSIOCTL_IDE_PASS_THROUGHIOCTL_ATA_PASS_THROUGHIOCTL_ATA_PASS_THROUGH_DIRECTIOCTL_ATA_MINIPORTIOCTL_MINIPORT_PROCESS_SERVICE_IRPIOCTL_MPIO_PASS_THROUGH_PATHIOCTL_MPIO_PASS_THROUGH_PATH_DIRECTIOCTL_SCSI_PASS_THROUGH_EXIOCTL_SCSI_PASS_THROUGH_DIRECT_EXIOCTL_MPIO_PASS_THROUGH_PATH_EXIOCTL_MPIO_PASS_THROUGH_PATH_DIRECT_EXIOCTL_SCSI_MINIPORT_NVCACHEIOCTL_SCSI_MINIPORT_HYBRIDIOCTL_SCSI_MINIPORT_FIRMWAREPSCSI_PASS_THROUGHSCSI_PASS_THROUGHPSCSI_PASS_THROUGH_DIRECTSCSI_PASS_THROUGH_DIRECTPSCSI_PASS_THROUGH_EXSCSI_PASS_THROUGH_EXPSCSI_PASS_THROUGH_DIRECT_EXSCSI_PASS_THROUGH_DIRECT_EXPATA_PASS_THROUGH_EXATA_PASS_THROUGH_EXPATA_PASS_THROUGH_DIRECTATA_PASS_THROUGH_DIRECTATA_FLAGS_DRDY_REQUIREDATA_FLAGS_DATA_INATA_FLAGS_DATA_OUTATA_FLAGS_48BIT_COMMANDATA_FLAGS_USE_DMAATA_FLAGS_NO_MULTIPLEPIDE_IO_CONTROLIDE_IO_CONTROLPMPIO_PASS_THROUGH_PATHMPIO_PASS_THROUGH_PATHPMPIO_PASS_THROUGH_PATH_DIRECTMPIO_PASS_THROUGH_PATH_DIRECTPMPIO_PASS_THROUGH_PATH_EXMPIO_PASS_THROUGH_PATH_EXPMPIO_PASS_THROUGH_PATH_DIRECT_EXMPIO_PASS_THROUGH_PATH_DIRECT_EXPSCSI_BUS_DATASCSI_BUS_DATAPSCSI_ADAPTER_BUS_INFOSCSI_ADAPTER_BUS_INFOPSCSI_INQUIRY_DATASCSI_INQUIRY_DATAIOCTL_MINIPORT_SIGNATURE_SCSIDISKIOCTL_MINIPORT_SIGNATURE_HYBRDISKIOCTL_MINIPORT_SIGNATURE_DSM_NOTIFICATIONIOCTL_MINIPORT_SIGNATURE_DSM_GENERALIOCTL_MINIPORT_SIGNATURE_FIRMWAREIOCTL_MINIPORT_SIGNATURE_QUERY_PROTOCOLIOCTL_MINIPORT_SIGNATURE_QUERY_TEMPERATUREIOCTL_MINIPORT_SIGNATURE_SET_TEMPERATURE_THRESHOLDIOCTL_MINIPORT_SIGNATURE_QUERY_PHYSICAL_TOPOLOGYPSRB_IO_CONTROLSRB_IO_CONTROLPNVCACHE_REQUEST_BLOCKNVCACHE_REQUEST_BLOCKNRB_FUNCTION_NVCACHE_INFONRB_FUNCTION_SPINDLE_STATUSNRB_FUNCTION_NVCACHE_POWER_MODE_SETNRB_FUNCTION_NVCACHE_POWER_MODE_RETURNNRB_FUNCTION_FLUSH_NVCACHENRB_FUNCTION_QUERY_PINNED_SETNRB_FUNCTION_QUERY_CACHE_MISSNRB_FUNCTION_ADD_LBAS_PINNED_SETNRB_FUNCTION_REMOVE_LBAS_PINNED_SETNRB_FUNCTION_QUERY_ASCENDER_STATUSNRB_FUNCTION_QUERY_HYBRID_DISK_STATUSNRB_FUNCTION_PASS_HINT_PAYLOADNRB_FUNCTION_NVSEPARATED_INFONRB_FUNCTION_NVSEPARATED_FLUSHNRB_FUNCTION_NVSEPARATED_WB_DISABLENRB_FUNCTION_NVSEPARATED_WB_REVERT_DEFAULTNRB_SUCCESSNRB_ILLEGAL_REQUESTNRB_INVALID_PARAMETERNRB_INPUT_DATA_OVERRUNNRB_INPUT_DATA_UNDERRUNNRB_OUTPUT_DATA_OVERRUNNRB_OUTPUT_DATA_UNDERRUNPNV_FEATURE_PARAMETERNV_FEATURE_PARAMETERPNVCACHE_HINT_PAYLOADNVCACHE_HINT_PAYLOADPNV_SEP_CACHE_PARAMETERNV_SEP_CACHE_PARAMETERNV_SEP_CACHE_PARAMETER_VERSION_1NV_SEP_CACHE_PARAMETER_VERSIONPNV_SEP_WRITE_CACHE_TYPENV_SEP_WRITE_CACHE_TYPEPMP_DEVICE_DATA_SET_RANGEMP_DEVICE_DATA_SET_RANGEPDSM_NOTIFICATION_REQUEST_BLOCKDSM_NOTIFICATION_REQUEST_BLOCKMINIPORT_DSM_NOTIFICATION_VERSION_1MINIPORT_DSM_NOTIFICATION_VERSIONMINIPORT_DSM_PROFILE_UNKNOWNMINIPORT_DSM_PROFILE_PAGE_FILEMINIPORT_DSM_PROFILE_HIBERNATION_FILEMINIPORT_DSM_PROFILE_CRASHDUMP_FILEMINIPORT_DSM_NOTIFY_FLAG_BEGINMINIPORT_DSM_NOTIFY_FLAG_ENDHYBRID_FUNCTION_GET_INFOHYBRID_FUNCTION_DISABLE_CACHING_MEDIUMHYBRID_FUNCTION_ENABLE_CACHING_MEDIUMHYBRID_FUNCTION_SET_DIRTY_THRESHOLDHYBRID_FUNCTION_DEMOTE_BY_SIZEHYBRID_STATUS_SUCCESSHYBRID_STATUS_ILLEGAL_REQUESTHYBRID_STATUS_INVALID_PARAMETERHYBRID_STATUS_OUTPUT_BUFFER_TOO_SMALLHYBRID_STATUS_ENABLE_REFCOUNT_HOLDHYBRID_REQUEST_BLOCK_STRUCTURE_VERSIONPHYBRID_REQUEST_BLOCKHYBRID_REQUEST_BLOCKPNVCACHE_PRIORITY_LEVEL_DESCRIPTORNVCACHE_PRIORITY_LEVEL_DESCRIPTORHYBRID_REQUEST_INFO_STRUCTURE_VERSIONPHYBRID_INFORMATIONHYBRID_INFORMATIONPHYBRID_DIRTY_THRESHOLDSHYBRID_DIRTY_THRESHOLDSPHYBRID_DEMOTE_BY_SIZEHYBRID_DEMOTE_BY_SIZEFIRMWARE_FUNCTION_GET_INFOFIRMWARE_FUNCTION_DOWNLOADFIRMWARE_FUNCTION_ACTIVATEFIRMWARE_STATUS_SUCCESSFIRMWARE_STATUS_ERRORFIRMWARE_STATUS_ILLEGAL_REQUESTFIRMWARE_STATUS_INVALID_PARAMETERFIRMWARE_STATUS_INPUT_BUFFER_TOO_BIGFIRMWARE_STATUS_OUTPUT_BUFFER_TOO_SMALLFIRMWARE_STATUS_INVALID_SLOTFIRMWARE_STATUS_INVALID_IMAGEFIRMWARE_STATUS_CONTROLLER_ERRORFIRMWARE_STATUS_POWER_CYCLE_REQUIREDFIRMWARE_STATUS_DEVICE_ERRORFIRMWARE_STATUS_INTERFACE_CRC_ERRORFIRMWARE_STATUS_UNCORRECTABLE_DATA_ERRORFIRMWARE_STATUS_MEDIA_CHANGEFIRMWARE_STATUS_ID_NOT_FOUNDFIRMWARE_STATUS_MEDIA_CHANGE_REQUESTFIRMWARE_STATUS_COMMAND_ABORTFIRMWARE_STATUS_END_OF_MEDIAFIRMWARE_STATUS_ILLEGAL_LENGTHFIRMWARE_REQUEST_BLOCK_STRUCTURE_VERSIONPFIRMWARE_REQUEST_BLOCKFIRMWARE_REQUEST_BLOCKFIRMWARE_REQUEST_FLAG_CONTROLLERFIRMWARE_REQUEST_FLAG_LAST_SEGMENTFIRMWARE_REQUEST_FLAG_SWITCH_TO_EXISTING_FIRMWARESTORAGE_FIRMWARE_INFO_STRUCTURE_VERSIONSTORAGE_FIRMWARE_INFO_STRUCTURE_VERSION_V2STORAGE_FIRMWARE_INFO_INVALID_SLOTPSTORAGE_FIRMWARE_SLOT_INFOSTORAGE_FIRMWARE_SLOT_INFOSTORAGE_FIRMWARE_SLOT_INFO_V2_REVISION_LENGTHPSTORAGE_FIRMWARE_SLOT_INFO_V2STORAGE_FIRMWARE_SLOT_INFO_V2PSTORAGE_FIRMWARE_INFOSTORAGE_FIRMWARE_INFOPSTORAGE_FIRMWARE_INFO_V2STORAGE_FIRMWARE_INFO_V2STORAGE_FIRMWARE_DOWNLOAD_STRUCTURE_VERSIONSTORAGE_FIRMWARE_DOWNLOAD_STRUCTURE_VERSION_V2PSTORAGE_FIRMWARE_DOWNLOADSTORAGE_FIRMWARE_DOWNLOADPSTORAGE_FIRMWARE_DOWNLOAD_V2STORAGE_FIRMWARE_DOWNLOAD_V2STORAGE_FIRMWARE_ACTIVATE_STRUCTURE_VERSIONPSTORAGE_FIRMWARE_ACTIVATESTORAGE_FIRMWARE_ACTIVATEPIO_SCSI_CAPABILITIESIO_SCSI_CAPABILITIESPSCSI_ADDRESSSCSI_ADDRESSDUMP_POINTERS_VERSION_1DUMP_POINTERS_VERSION_2DUMP_POINTERS_VERSION_3DUMP_POINTERS_VERSION_4DUMP_DRIVER_NAME_LENGTHPDUMP_DEVICE_POWERON_ROUTINEDUMP_DEVICE_POWERON_ROUTINEPDUMP_POINTERS_VERSIONDUMP_POINTERS_VERSIONPDUMP_POINTERSDUMP_POINTERSPDUMP_POINTERS_EXDUMP_POINTERS_EX// TODO: Revisit these definitions when const size_of and offset_of! arrive.DUMP_EX_FLAG_SUPPORT_64BITMEMORYDUMP_EX_FLAG_SUPPORT_DD_TELEMETRYDUMP_EX_FLAG_RESUME_SUPPORTPDUMP_DRIVERDUMP_DRIVERSCSI_IOCTL_DATA_OUTSCSI_IOCTL_DATA_INSCSI_IOCTL_DATA_UNSPECIFIEDSCSI_IOCTL_DATA_BIDIRECTIONALMPIO_IOCTL_FLAG_USE_PATHIDMPIO_IOCTL_FLAG_USE_SCSIADDRESSMPIO_IOCTL_FLAG_INVOLVE_DSM//! Constants and types for accessing SCSI port adapters.//! This is the include file that defines all constants and types for accessing the Serial device.SYSTEM_CACHE_ALIGNMENT_SIZEPVOID64// This is a 64-bit pointer, even when in 32-bitLPWCHPWCHLPCWCHPCWCHNWPSTRLPTSTRPZPWSTRPCZPWSTRLPUWSTRPUWSTR// Unaligned pointerPZPCWSTRPCZPCWSTRLPCUWSTRPCUWSTRPZZWSTRPCZZWSTRPUZZWSTRPCUZZWSTRPNZWCHPCNZWCHPUNZWCHPCUNZWCHLPCWCHARPCWCHARLPCUWCHARPCUWCHARUCSCHARUCSCHAR_INVALID_CHARACTERMIN_UCSCHARMAX_UCSCHARPUCSCHARPCUCSCHARPUCSSTRPUUCSSTRPCUCSSTRPCUUCSSTRPUUCSCHARPCUUCSCHARLPCHPCHLPCCHPCCHNPSTRPZPSTRPCZPSTRPZPCSTRPCZPCSTRPZZSTRPCZZSTRPNZCHPCNZCH// Skipping TCHAR thingsPSHORTPQUADQUADUQUADPUQUADPCUCHARPCUSHORTPCULONGPCUQUADSCHARPSCHARPCSCHARALL_PROCESSOR_GROUPSPPROCESSOR_NUMBERPROCESSOR_NUMBERPGROUP_AFFINITYGROUP_AFFINITYMAXIMUM_PROC_PER_GROUPMAXIMUM_PROCESSORSPHANDLEFCHARFSHORTFLONGOBJ_HANDLE_TAGBITSCCHARCSHORTCLONGPCCHARPCSHORTPCLONGPLCIDLANGIDPCOMPARTMENT_IDCOMPARTMENT_IDLOGICALPLOGICALPCNTSTATUSNT_SUCCESSNT_INFORMATIONNT_WARNINGNT_ERRORAPPLICATION_ERROR_MASKERROR_SEVERITY_SUCCESSERROR_SEVERITY_INFORMATIONALERROR_SEVERITY_WARNINGERROR_SEVERITY_ERRORSECURITY_STATUSPTIMEPFLOAT128FLOAT128MAXLONGLONGPLONGLONGUSNPLARGE_INTEGERPULARGE_INTEGERULARGE_INTEGERRTL_REFERENCE_COUNTPRTL_REFERENCE_COUNTPLUIDDWORDLONGPDWORDLONGPHYSICAL_ADDRESSPPHYSICAL_ADDRESSPCSZRTL_STRING_LENGTH_TYPEPSTRINGANSI_STRINGPANSI_STRINGOEM_STRINGPOEM_STRINGPCOEM_STRINGPCSTRINGCSTRINGANSI_NULLCANSI_STRINGPCANSI_STRINGPUNICODE_STRINGPCUNICODE_STRINGUNICODE_NULLUNICODE_STRING_MAX_BYTESUNICODE_STRING_MAX_CHARSPLIST_ENTRYLIST_ENTRYPRLIST_ENTRY// Restricted pointerPSINGLE_LIST_ENTRYSINGLE_LIST_ENTRYRTL_BALANCED_NODE_RESERVED_PARENT_MASKPRTL_BALANCED_NODERTL_BALANCED_NODERTL_BALANCED_NODE_GET_PARENT_POINTERPLIST_ENTRY32LIST_ENTRY32PLIST_ENTRY64LIST_ENTRY64PSINGLE_LIST_ENTRY32SINGLE_LIST_ENTRY32ListEntry32To64ListEntry64To32PWNF_STATE_NAMEWNF_STATE_NAMEPCWNF_STATE_NAMEPSTRING32STRING32UNICODE_STRING32PUNICODE_STRING32ANSI_STRING32PANSI_STRING32PSTRING64STRING64UNICODE_STRING64PUNICODE_STRING64ANSI_STRING64PANSI_STRING64OBJ_INHERITOBJ_PERMANENTOBJ_EXCLUSIVEOBJ_CASE_INSENSITIVEOBJ_OPENIFOBJ_OPENLINKOBJ_KERNEL_HANDLEOBJ_FORCE_ACCESS_CHECKOBJ_IGNORE_IMPERSONATED_DEVICEMAPOBJ_DONT_REPARSEOBJ_VALID_ATTRIBUTESPOBJECT_ATTRIBUTES64OBJECT_ATTRIBUTES64PCOBJECT_ATTRIBUTES64POBJECT_ATTRIBUTES32OBJECT_ATTRIBUTES32PCOBJECT_ATTRIBUTES32POBJECT_ATTRIBUTESPCOBJECT_ATTRIBUTESInitializeObjectAttributesNULL64MINCHARMAXCHARMINSHORTMAXSHORTMINLONGMAXLONGMAXUCHARMAXUSHORTMAXULONGKIRQL// PEXCEPTION_ROUTINE: Can't define here, because it needs EXCEPTION_RECORD and CONTEXT.PKIRQLPNT_PRODUCT_TYPENT_PRODUCT_TYPEVER_SERVER_NTVER_WORKSTATION_NTVER_SUITE_SMALLBUSINESSVER_SUITE_ENTERPRISEVER_SUITE_BACKOFFICEVER_SUITE_COMMUNICATIONSVER_SUITE_TERMINALVER_SUITE_SMALLBUSINESS_RESTRICTEDVER_SUITE_EMBEDDEDNTVER_SUITE_DATACENTERVER_SUITE_SINGLEUSERTSVER_SUITE_PERSONALVER_SUITE_BLADEVER_SUITE_EMBEDDED_RESTRICTEDVER_SUITE_SECURITY_APPLIANCEVER_SUITE_STORAGE_SERVERVER_SUITE_COMPUTE_SERVERPRODUCT_UNDEFINEDPRODUCT_ULTIMATEPRODUCT_HOME_BASICPRODUCT_HOME_PREMIUMPRODUCT_ENTERPRISEPRODUCT_HOME_BASIC_NPRODUCT_BUSINESSPRODUCT_STANDARD_SERVERPRODUCT_DATACENTER_SERVERPRODUCT_SMALLBUSINESS_SERVERPRODUCT_ENTERPRISE_SERVERPRODUCT_STARTERPRODUCT_DATACENTER_SERVER_COREPRODUCT_STANDARD_SERVER_COREPRODUCT_ENTERPRISE_SERVER_COREPRODUCT_ENTERPRISE_SERVER_IA64PRODUCT_BUSINESS_NPRODUCT_WEB_SERVERPRODUCT_CLUSTER_SERVERPRODUCT_HOME_SERVERPRODUCT_STORAGE_EXPRESS_SERVERPRODUCT_STORAGE_STANDARD_SERVERPRODUCT_STORAGE_WORKGROUP_SERVERPRODUCT_STORAGE_ENTERPRISE_SERVERPRODUCT_SERVER_FOR_SMALLBUSINESSPRODUCT_SMALLBUSINESS_SERVER_PREMIUMPRODUCT_HOME_PREMIUM_NPRODUCT_ENTERPRISE_NPRODUCT_ULTIMATE_NPRODUCT_WEB_SERVER_COREPRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENTPRODUCT_MEDIUMBUSINESS_SERVER_SECURITYPRODUCT_MEDIUMBUSINESS_SERVER_MESSAGINGPRODUCT_SERVER_FOUNDATIONPRODUCT_HOME_PREMIUM_SERVERPRODUCT_SERVER_FOR_SMALLBUSINESS_VPRODUCT_STANDARD_SERVER_VPRODUCT_DATACENTER_SERVER_VPRODUCT_ENTERPRISE_SERVER_VPRODUCT_DATACENTER_SERVER_CORE_VPRODUCT_STANDARD_SERVER_CORE_VPRODUCT_ENTERPRISE_SERVER_CORE_VPRODUCT_HYPERVPRODUCT_STORAGE_EXPRESS_SERVER_COREPRODUCT_STORAGE_STANDARD_SERVER_COREPRODUCT_STORAGE_WORKGROUP_SERVER_COREPRODUCT_STORAGE_ENTERPRISE_SERVER_COREPRODUCT_STARTER_NPRODUCT_PROFESSIONALPRODUCT_PROFESSIONAL_NPRODUCT_SB_SOLUTION_SERVERPRODUCT_SERVER_FOR_SB_SOLUTIONSPRODUCT_STANDARD_SERVER_SOLUTIONSPRODUCT_STANDARD_SERVER_SOLUTIONS_COREPRODUCT_SB_SOLUTION_SERVER_EMPRODUCT_SERVER_FOR_SB_SOLUTIONS_EMPRODUCT_SOLUTION_EMBEDDEDSERVERPRODUCT_SOLUTION_EMBEDDEDSERVER_COREPRODUCT_PROFESSIONAL_EMBEDDEDPRODUCT_ESSENTIALBUSINESS_SERVER_MGMTPRODUCT_ESSENTIALBUSINESS_SERVER_ADDLPRODUCT_ESSENTIALBUSINESS_SERVER_MGMTSVCPRODUCT_ESSENTIALBUSINESS_SERVER_ADDLSVCPRODUCT_SMALLBUSINESS_SERVER_PREMIUM_COREPRODUCT_CLUSTER_SERVER_VPRODUCT_EMBEDDEDPRODUCT_STARTER_EPRODUCT_HOME_BASIC_EPRODUCT_HOME_PREMIUM_EPRODUCT_PROFESSIONAL_EPRODUCT_ENTERPRISE_EPRODUCT_ULTIMATE_EPRODUCT_ENTERPRISE_EVALUATIONPRODUCT_MULTIPOINT_STANDARD_SERVERPRODUCT_MULTIPOINT_PREMIUM_SERVERPRODUCT_STANDARD_EVALUATION_SERVERPRODUCT_DATACENTER_EVALUATION_SERVERPRODUCT_ENTERPRISE_N_EVALUATIONPRODUCT_EMBEDDED_AUTOMOTIVEPRODUCT_EMBEDDED_INDUSTRY_APRODUCT_THINPCPRODUCT_EMBEDDED_APRODUCT_EMBEDDED_INDUSTRYPRODUCT_EMBEDDED_EPRODUCT_EMBEDDED_INDUSTRY_EPRODUCT_EMBEDDED_INDUSTRY_A_EPRODUCT_STORAGE_WORKGROUP_EVALUATION_SERVERPRODUCT_STORAGE_STANDARD_EVALUATION_SERVERPRODUCT_CORE_ARMPRODUCT_CORE_NPRODUCT_CORE_COUNTRYSPECIFICPRODUCT_CORE_SINGLELANGUAGEPRODUCT_COREPRODUCT_PROFESSIONAL_WMCPRODUCT_MOBILE_COREPRODUCT_EMBEDDED_INDUSTRY_EVALPRODUCT_EMBEDDED_INDUSTRY_E_EVALPRODUCT_EMBEDDED_EVALPRODUCT_EMBEDDED_E_EVALPRODUCT_NANO_SERVERPRODUCT_CLOUD_STORAGE_SERVERPRODUCT_CORE_CONNECTEDPRODUCT_PROFESSIONAL_STUDENTPRODUCT_CORE_CONNECTED_NPRODUCT_PROFESSIONAL_STUDENT_NPRODUCT_CORE_CONNECTED_SINGLELANGUAGEPRODUCT_CORE_CONNECTED_COUNTRYSPECIFICPRODUCT_CONNECTED_CARPRODUCT_INDUSTRY_HANDHELDPRODUCT_PPI_PROPRODUCT_ARM64_SERVERPRODUCT_EDUCATIONPRODUCT_EDUCATION_NPRODUCT_IOTUAPPRODUCT_CLOUD_HOST_INFRASTRUCTURE_SERVERPRODUCT_ENTERPRISE_SPRODUCT_ENTERPRISE_S_NPRODUCT_PROFESSIONAL_SPRODUCT_PROFESSIONAL_S_NPRODUCT_ENTERPRISE_S_EVALUATIONPRODUCT_ENTERPRISE_S_N_EVALUATIONPRODUCT_HOLOGRAPHICPRODUCT_PRO_SINGLE_LANGUAGEPRODUCT_PRO_CHINAPRODUCT_ENTERPRISE_SUBSCRIPTIONPRODUCT_ENTERPRISE_SUBSCRIPTION_NPRODUCT_DATACENTER_NANO_SERVERPRODUCT_STANDARD_NANO_SERVERPRODUCT_DATACENTER_A_SERVER_COREPRODUCT_STANDARD_A_SERVER_COREPRODUCT_DATACENTER_WS_SERVER_COREPRODUCT_STANDARD_WS_SERVER_COREPRODUCT_UTILITY_VMPRODUCT_DATACENTER_EVALUATION_SERVER_COREPRODUCT_STANDARD_EVALUATION_SERVER_COREPRODUCT_PRO_WORKSTATIONPRODUCT_PRO_WORKSTATION_NPRODUCT_PRO_FOR_EDUCATIONPRODUCT_PRO_FOR_EDUCATION_NPRODUCT_AZURE_SERVER_COREPRODUCT_AZURE_NANO_SERVERPRODUCT_UNLICENSEDLANG_NEUTRALLANG_INVARIANTLANG_AFRIKAANSLANG_ALBANIANLANG_ALSATIANLANG_AMHARICLANG_ARABICLANG_ARMENIANLANG_ASSAMESELANG_AZERILANG_AZERBAIJANILANG_BANGLALANG_BASHKIRLANG_BASQUELANG_BELARUSIANLANG_BENGALILANG_BRETONLANG_BOSNIANLANG_BOSNIAN_NEUTRALLANG_BULGARIANLANG_CATALANLANG_CENTRAL_KURDISHLANG_CHEROKEELANG_CHINESELANG_CHINESE_SIMPLIFIEDLANG_CHINESE_TRADITIONALLANG_CORSICANLANG_CROATIANLANG_CZECHLANG_DANISHLANG_DARILANG_DIVEHILANG_DUTCHLANG_ENGLISHLANG_ESTONIANLANG_FAEROESELANG_FARSILANG_FILIPINOLANG_FINNISHLANG_FRENCHLANG_FRISIANLANG_FULAHLANG_GALICIANLANG_GEORGIANLANG_GERMANLANG_GREEKLANG_GREENLANDICLANG_GUJARATILANG_HAUSALANG_HAWAIIANLANG_HEBREWLANG_HINDILANG_HUNGARIANLANG_ICELANDICLANG_IGBOLANG_INDONESIANLANG_INUKTITUTLANG_IRISHLANG_ITALIANLANG_KANNADALANG_KASHMIRILANG_KAZAKLANG_KHMERLANG_KICHELANG_KINYARWANDALANG_KONKANILANG_KYRGYZLANG_LAOLANG_LATVIANLANG_LITHUANIANLANG_LOWER_SORBIANLANG_LUXEMBOURGISHLANG_MACEDONIANLANG_MALAYLANG_MALAYALAMLANG_MALTESELANG_MANIPURILANG_MAORILANG_MAPUDUNGUNLANG_MARATHILANG_MOHAWKLANG_MONGOLIANLANG_NEPALILANG_NORWEGIANLANG_OCCITANLANG_ODIALANG_ORIYALANG_PASHTOLANG_PERSIANLANG_POLISHLANG_PORTUGUESELANG_PULARLANG_PUNJABILANG_QUECHUALANG_ROMANIANLANG_ROMANSHLANG_RUSSIANLANG_SAKHALANG_SAMILANG_SANSKRITLANG_SCOTTISH_GAELICLANG_SERBIANLANG_SERBIAN_NEUTRALLANG_SINDHILANG_SINHALESELANG_SLOVAKLANG_SLOVENIANLANG_SOTHOLANG_SPANISHLANG_SWAHILILANG_SWEDISHLANG_SYRIACLANG_TAJIKLANG_TAMAZIGHTLANG_TAMILLANG_TATARLANG_TELUGULANG_THAILANG_TIBETANLANG_TIGRIGNALANG_TIGRINYALANG_TSWANALANG_TURKISHLANG_TURKMENLANG_UIGHURLANG_UKRAINIANLANG_UPPER_SORBIANLANG_URDULANG_UZBEKLANG_VALENCIANLANG_VIETNAMESELANG_WELSHLANG_WOLOFLANG_XHOSALANG_YAKUTLANG_YILANG_YORUBALANG_ZULUSUBLANG_NEUTRALSUBLANG_DEFAULTSUBLANG_SYS_DEFAULTSUBLANG_CUSTOM_DEFAULTSUBLANG_CUSTOM_UNSPECIFIEDSUBLANG_UI_CUSTOM_DEFAULTSUBLANG_AFRIKAANS_SOUTH_AFRICASUBLANG_ALBANIAN_ALBANIASUBLANG_ALSATIAN_FRANCESUBLANG_AMHARIC_ETHIOPIASUBLANG_ARABIC_SAUDI_ARABIASUBLANG_ARABIC_IRAQSUBLANG_ARABIC_EGYPTSUBLANG_ARABIC_LIBYASUBLANG_ARABIC_ALGERIASUBLANG_ARABIC_MOROCCOSUBLANG_ARABIC_TUNISIASUBLANG_ARABIC_OMANSUBLANG_ARABIC_YEMENSUBLANG_ARABIC_SYRIASUBLANG_ARABIC_JORDANSUBLANG_ARABIC_LEBANONSUBLANG_ARABIC_KUWAITSUBLANG_ARABIC_UAESUBLANG_ARABIC_BAHRAINSUBLANG_ARABIC_QATARSUBLANG_ARMENIAN_ARMENIASUBLANG_ASSAMESE_INDIASUBLANG_AZERI_LATINSUBLANG_AZERI_CYRILLICSUBLANG_AZERBAIJANI_AZERBAIJAN_LATINSUBLANG_AZERBAIJANI_AZERBAIJAN_CYRILLICSUBLANG_BANGLA_INDIASUBLANG_BANGLA_BANGLADESHSUBLANG_BASHKIR_RUSSIASUBLANG_BASQUE_BASQUESUBLANG_BELARUSIAN_BELARUSSUBLANG_BENGALI_INDIASUBLANG_BENGALI_BANGLADESHSUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATINSUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLICSUBLANG_BRETON_FRANCESUBLANG_BULGARIAN_BULGARIASUBLANG_CATALAN_CATALANSUBLANG_CENTRAL_KURDISH_IRAQSUBLANG_CHEROKEE_CHEROKEESUBLANG_CHINESE_TRADITIONALSUBLANG_CHINESE_SIMPLIFIEDSUBLANG_CHINESE_HONGKONGSUBLANG_CHINESE_SINGAPORESUBLANG_CHINESE_MACAUSUBLANG_CORSICAN_FRANCESUBLANG_CZECH_CZECH_REPUBLICSUBLANG_CROATIAN_CROATIASUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATINSUBLANG_DANISH_DENMARKSUBLANG_DARI_AFGHANISTANSUBLANG_DIVEHI_MALDIVESSUBLANG_DUTCHSUBLANG_DUTCH_BELGIANSUBLANG_ENGLISH_USSUBLANG_ENGLISH_UKSUBLANG_ENGLISH_AUSSUBLANG_ENGLISH_CANSUBLANG_ENGLISH_NZSUBLANG_ENGLISH_EIRESUBLANG_ENGLISH_SOUTH_AFRICASUBLANG_ENGLISH_JAMAICASUBLANG_ENGLISH_CARIBBEANSUBLANG_ENGLISH_BELIZESUBLANG_ENGLISH_TRINIDADSUBLANG_ENGLISH_ZIMBABWESUBLANG_ENGLISH_PHILIPPINESSUBLANG_ENGLISH_INDIASUBLANG_ENGLISH_MALAYSIASUBLANG_ENGLISH_SINGAPORESUBLANG_ESTONIAN_ESTONIASUBLANG_FAEROESE_FAROE_ISLANDSSUBLANG_FILIPINO_PHILIPPINESSUBLANG_FINNISH_FINLANDSUBLANG_FRENCHSUBLANG_FRENCH_BELGIANSUBLANG_FRENCH_CANADIANSUBLANG_FRENCH_SWISSSUBLANG_FRENCH_LUXEMBOURGSUBLANG_FRENCH_MONACOSUBLANG_FRISIAN_NETHERLANDSSUBLANG_FULAH_SENEGALSUBLANG_GALICIAN_GALICIANSUBLANG_GEORGIAN_GEORGIASUBLANG_GERMANSUBLANG_GERMAN_SWISSSUBLANG_GERMAN_AUSTRIANSUBLANG_GERMAN_LUXEMBOURGSUBLANG_GERMAN_LIECHTENSTEINSUBLANG_GREEK_GREECESUBLANG_GREENLANDIC_GREENLANDSUBLANG_GUJARATI_INDIASUBLANG_HAUSA_NIGERIA_LATINSUBLANG_HAWAIIAN_USSUBLANG_HEBREW_ISRAELSUBLANG_HINDI_INDIASUBLANG_HUNGARIAN_HUNGARYSUBLANG_ICELANDIC_ICELANDSUBLANG_IGBO_NIGERIASUBLANG_INDONESIAN_INDONESIASUBLANG_INUKTITUT_CANADASUBLANG_INUKTITUT_CANADA_LATINSUBLANG_IRISH_IRELANDSUBLANG_ITALIANSUBLANG_ITALIAN_SWISSSUBLANG_JAPANESE_JAPANSUBLANG_KANNADA_INDIASUBLANG_KASHMIRI_SASIASUBLANG_KASHMIRI_INDIASUBLANG_KAZAK_KAZAKHSTANSUBLANG_KHMER_CAMBODIASUBLANG_KICHE_GUATEMALASUBLANG_KINYARWANDA_RWANDASUBLANG_KONKANI_INDIASUBLANG_KOREANSUBLANG_KYRGYZ_KYRGYZSTANSUBLANG_LAO_LAOSUBLANG_LATVIAN_LATVIASUBLANG_LITHUANIANSUBLANG_LOWER_SORBIAN_GERMANYSUBLANG_LUXEMBOURGISH_LUXEMBOURGSUBLANG_MACEDONIAN_MACEDONIASUBLANG_MALAY_MALAYSIASUBLANG_MALAY_BRUNEI_DARUSSALAMSUBLANG_MALAYALAM_INDIASUBLANG_MALTESE_MALTASUBLANG_MAORI_NEW_ZEALANDSUBLANG_MAPUDUNGUN_CHILESUBLANG_MARATHI_INDIASUBLANG_MOHAWK_MOHAWKSUBLANG_MONGOLIAN_CYRILLIC_MONGOLIASUBLANG_MONGOLIAN_PRCSUBLANG_NEPALI_INDIASUBLANG_NEPALI_NEPALSUBLANG_NORWEGIAN_BOKMALSUBLANG_NORWEGIAN_NYNORSKSUBLANG_OCCITAN_FRANCESUBLANG_ODIA_INDIASUBLANG_ORIYA_INDIASUBLANG_PASHTO_AFGHANISTANSUBLANG_PERSIAN_IRANSUBLANG_POLISH_POLANDSUBLANG_PORTUGUESESUBLANG_PORTUGUESE_BRAZILIANSUBLANG_PULAR_SENEGALSUBLANG_PUNJABI_INDIASUBLANG_PUNJABI_PAKISTANSUBLANG_QUECHUA_BOLIVIASUBLANG_QUECHUA_ECUADORSUBLANG_QUECHUA_PERUSUBLANG_ROMANIAN_ROMANIASUBLANG_ROMANSH_SWITZERLANDSUBLANG_RUSSIAN_RUSSIASUBLANG_SAKHA_RUSSIASUBLANG_SAMI_NORTHERN_NORWAYSUBLANG_SAMI_NORTHERN_SWEDENSUBLANG_SAMI_NORTHERN_FINLANDSUBLANG_SAMI_LULE_NORWAYSUBLANG_SAMI_LULE_SWEDENSUBLANG_SAMI_SOUTHERN_NORWAYSUBLANG_SAMI_SOUTHERN_SWEDENSUBLANG_SAMI_SKOLT_FINLANDSUBLANG_SAMI_INARI_FINLANDSUBLANG_SANSKRIT_INDIASUBLANG_SCOTTISH_GAELICSUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_LATINSUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_CYRILLICSUBLANG_SERBIAN_MONTENEGRO_LATINSUBLANG_SERBIAN_MONTENEGRO_CYRILLICSUBLANG_SERBIAN_SERBIA_LATINSUBLANG_SERBIAN_SERBIA_CYRILLICSUBLANG_SERBIAN_CROATIASUBLANG_SERBIAN_LATINSUBLANG_SERBIAN_CYRILLICSUBLANG_SINDHI_INDIASUBLANG_SINDHI_PAKISTANSUBLANG_SINDHI_AFGHANISTANSUBLANG_SINHALESE_SRI_LANKASUBLANG_SOTHO_NORTHERN_SOUTH_AFRICASUBLANG_SLOVAK_SLOVAKIASUBLANG_SLOVENIAN_SLOVENIASUBLANG_SPANISHSUBLANG_SPANISH_MEXICANSUBLANG_SPANISH_MODERNSUBLANG_SPANISH_GUATEMALASUBLANG_SPANISH_COSTA_RICASUBLANG_SPANISH_PANAMASUBLANG_SPANISH_DOMINICAN_REPUBLICSUBLANG_SPANISH_VENEZUELASUBLANG_SPANISH_COLOMBIASUBLANG_SPANISH_PERUSUBLANG_SPANISH_ARGENTINASUBLANG_SPANISH_ECUADORSUBLANG_SPANISH_CHILESUBLANG_SPANISH_URUGUAYSUBLANG_SPANISH_PARAGUAYSUBLANG_SPANISH_BOLIVIASUBLANG_SPANISH_EL_SALVADORSUBLANG_SPANISH_HONDURASSUBLANG_SPANISH_NICARAGUASUBLANG_SPANISH_PUERTO_RICOSUBLANG_SPANISH_USSUBLANG_SWAHILI_KENYASUBLANG_SWEDISHSUBLANG_SWEDISH_FINLANDSUBLANG_SYRIAC_SYRIASUBLANG_TAJIK_TAJIKISTANSUBLANG_TAMAZIGHT_ALGERIA_LATINSUBLANG_TAMAZIGHT_MOROCCO_TIFINAGHSUBLANG_TAMIL_INDIASUBLANG_TAMIL_SRI_LANKASUBLANG_TATAR_RUSSIASUBLANG_TELUGU_INDIASUBLANG_THAI_THAILANDSUBLANG_TIBETAN_PRCSUBLANG_TIGRIGNA_ERITREASUBLANG_TIGRINYA_ERITREASUBLANG_TIGRINYA_ETHIOPIASUBLANG_TSWANA_BOTSWANASUBLANG_TSWANA_SOUTH_AFRICASUBLANG_TURKISH_TURKEYSUBLANG_TURKMEN_TURKMENISTANSUBLANG_UIGHUR_PRCSUBLANG_UKRAINIAN_UKRAINESUBLANG_UPPER_SORBIAN_GERMANYSUBLANG_URDU_PAKISTANSUBLANG_URDU_INDIASUBLANG_UZBEK_LATINSUBLANG_UZBEK_CYRILLICSUBLANG_VALENCIAN_VALENCIASUBLANG_VIETNAMESE_VIETNAMSUBLANG_WELSH_UNITED_KINGDOMSUBLANG_WOLOF_SENEGALSUBLANG_XHOSA_SOUTH_AFRICASUBLANG_YAKUT_RUSSIASUBLANG_YI_PRCSUBLANG_YORUBA_NIGERIASUBLANG_ZULU_SOUTH_AFRICASORT_DEFAULTSORT_INVARIANT_MATHSORT_JAPANESE_XJISSORT_JAPANESE_UNICODESORT_JAPANESE_RADICALSTROKESORT_CHINESE_BIG5SORT_CHINESE_PRCPSORT_CHINESE_UNICODESORT_CHINESE_PRCSORT_CHINESE_BOPOMOFOSORT_CHINESE_RADICALSTROKESORT_KOREAN_KSCSORT_KOREAN_UNICODESORT_GERMAN_PHONE_BOOKSORT_HUNGARIAN_DEFAULTSORT_HUNGARIAN_TECHNICALSORT_GEORGIAN_TRADITIONALSORT_GEORGIAN_MODERNMAKELANGIDSUBLANGIDNLS_VALID_LOCALE_MASKMAKELCIDMAKESORTLCIDLANGIDFROMLCIDSORTIDFROMLCIDSORTVERSIONFROMLCIDLOCALE_NAME_MAX_LENGTHLANG_SYSTEM_DEFAULTLANG_USER_DEFAULTLOCALE_SYSTEM_DEFAULTLOCALE_USER_DEFAULTLOCALE_CUSTOM_DEFAULTLOCALE_CUSTOM_UNSPECIFIEDLOCALE_CUSTOM_UI_DEFAULTLOCALE_NEUTRALLOCALE_INVARIANTLOCALE_TRANSIENT_KEYBOARD1LOCALE_TRANSIENT_KEYBOARD2LOCALE_TRANSIENT_KEYBOARD3LOCALE_TRANSIENT_KEYBOARD4LOCALE_UNASSIGNED_LCID//! Type definitions for the basic types.STATUS_WAIT_0FACILITY_VSMFACILITY_VOLSNAPFACILITY_VOLMGRFACILITY_VIRTUALIZATIONFACILITY_VIDEOFACILITY_USB_ERROR_CODEFACILITY_TRANSACTIONFACILITY_TPMFACILITY_TERMINAL_SERVERFACILITY_SXS_ERROR_CODEFACILITY_NTSSPIFACILITY_SPACESFACILITY_SMBFACILITY_SYSTEM_INTEGRITYFACILITY_SHARED_VHDXFACILITY_SECUREBOOTFACILITY_SECURITY_COREFACILITY_SDBUSFACILITY_RTPMFACILITY_RPC_STUBSFACILITY_RPC_RUNTIMEFACILITY_RESUME_KEY_FILTERFACILITY_RDBSSFACILITY_PLATFORM_MANIFESTFACILITY_NTWIN32FACILITY_WIN32K_NTUSERFACILITY_WIN32K_NTGDIFACILITY_NDIS_ERROR_CODEFACILTIY_MUI_ERROR_CODEFACILITY_MONITORFACILITY_MAXIMUM_VALUEFACILITY_LICENSINGFACILITY_IPSECFACILITY_IO_ERROR_CODEFACILITY_INTERIXFACILITY_HYPERVISORFACILITY_GRAPHICS_KERNELFACILITY_FWP_ERROR_CODEFACILITY_FVE_ERROR_CODEFACILITY_FIREWIRE_ERROR_CODEFACILITY_FILTER_MANAGERFACILITY_DRIVER_FRAMEWORKFACILITY_DEBUGGERFACILITY_COMMONLOGFACILITY_CODCLASS_ERROR_CODEFACILITY_CLUSTER_ERROR_CODEFACILITY_NTCERTFACILITY_BTH_ATTFACILITY_BCD_ERROR_CODEFACILITY_AUDIO_KERNELFACILITY_ACPI_ERROR_CODESTATUS_SEVERITY_WARNINGSTATUS_SEVERITY_SUCCESSSTATUS_SEVERITY_INFORMATIONALSTATUS_SEVERITY_ERRORSTATUS_WAIT_1STATUS_WAIT_2STATUS_WAIT_3STATUS_WAIT_63STATUS_ABANDONEDSTATUS_ABANDONED_WAIT_0STATUS_ABANDONED_WAIT_63STATUS_USER_APCSTATUS_ALREADY_COMPLETESTATUS_KERNEL_APCSTATUS_ALERTEDSTATUS_REPARSESTATUS_MORE_ENTRIESSTATUS_NOT_ALL_ASSIGNEDSTATUS_SOME_NOT_MAPPEDSTATUS_OPLOCK_BREAK_IN_PROGRESSSTATUS_VOLUME_MOUNTEDSTATUS_RXACT_COMMITTEDSTATUS_NOTIFY_CLEANUPSTATUS_NOTIFY_ENUM_DIRSTATUS_NO_QUOTAS_FOR_ACCOUNTSTATUS_PRIMARY_TRANSPORT_CONNECT_FAILEDSTATUS_PAGE_FAULT_TRANSITIONSTATUS_PAGE_FAULT_DEMAND_ZEROSTATUS_PAGE_FAULT_COPY_ON_WRITESTATUS_PAGE_FAULT_GUARD_PAGESTATUS_PAGE_FAULT_PAGING_FILESTATUS_CACHE_PAGE_LOCKEDSTATUS_CRASH_DUMPSTATUS_BUFFER_ALL_ZEROSSTATUS_REPARSE_OBJECTSTATUS_RESOURCE_REQUIREMENTS_CHANGEDSTATUS_TRANSLATION_COMPLETESTATUS_DS_MEMBERSHIP_EVALUATED_LOCALLYSTATUS_NOTHING_TO_TERMINATESTATUS_PROCESS_NOT_IN_JOBSTATUS_PROCESS_IN_JOBSTATUS_VOLSNAP_HIBERNATE_READYSTATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLYSTATUS_INTERRUPT_VECTOR_ALREADY_CONNECTEDSTATUS_INTERRUPT_STILL_CONNECTEDSTATUS_PROCESS_CLONEDSTATUS_FILE_LOCKED_WITH_ONLY_READERSSTATUS_FILE_LOCKED_WITH_WRITERSSTATUS_VALID_IMAGE_HASHSTATUS_VALID_CATALOG_HASHSTATUS_VALID_STRONG_CODE_HASHSTATUS_GHOSTEDSTATUS_RESOURCEMANAGER_READ_ONLYSTATUS_RING_PREVIOUSLY_EMPTYSTATUS_RING_PREVIOUSLY_FULLSTATUS_RING_PREVIOUSLY_ABOVE_QUOTASTATUS_RING_NEWLY_EMPTYSTATUS_RING_SIGNAL_OPPOSITE_ENDPOINTSTATUS_OPLOCK_SWITCHED_TO_NEW_HANDLESTATUS_OPLOCK_HANDLE_CLOSEDSTATUS_WAIT_FOR_OPLOCKSTATUS_REPARSE_GLOBALDBG_EXCEPTION_HANDLEDDBG_CONTINUESTATUS_FLT_IO_COMPLETESTATUS_OBJECT_NAME_EXISTSSTATUS_THREAD_WAS_SUSPENDEDSTATUS_WORKING_SET_LIMIT_RANGESTATUS_IMAGE_NOT_AT_BASESTATUS_RXACT_STATE_CREATEDSTATUS_SEGMENT_NOTIFICATIONSTATUS_LOCAL_USER_SESSION_KEYSTATUS_BAD_CURRENT_DIRECTORYSTATUS_SERIAL_MORE_WRITESSTATUS_REGISTRY_RECOVEREDSTATUS_FT_READ_RECOVERY_FROM_BACKUPSTATUS_FT_WRITE_RECOVERYSTATUS_SERIAL_COUNTER_TIMEOUTSTATUS_NULL_LM_PASSWORDSTATUS_IMAGE_MACHINE_TYPE_MISMATCHSTATUS_RECEIVE_PARTIALSTATUS_RECEIVE_EXPEDITEDSTATUS_RECEIVE_PARTIAL_EXPEDITEDSTATUS_EVENT_DONESTATUS_EVENT_PENDINGSTATUS_CHECKING_FILE_SYSTEMSTATUS_FATAL_APP_EXITSTATUS_PREDEFINED_HANDLESTATUS_WAS_UNLOCKEDSTATUS_SERVICE_NOTIFICATIONSTATUS_WAS_LOCKEDSTATUS_LOG_HARD_ERRORSTATUS_ALREADY_WIN32STATUS_WX86_UNSIMULATESTATUS_WX86_CONTINUESTATUS_WX86_SINGLE_STEPSTATUS_WX86_BREAKPOINTSTATUS_WX86_EXCEPTION_CONTINUESTATUS_WX86_EXCEPTION_LASTCHANCESTATUS_WX86_EXCEPTION_CHAINSTATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXESTATUS_NO_YIELD_PERFORMEDSTATUS_TIMER_RESUME_IGNOREDSTATUS_ARBITRATION_UNHANDLEDSTATUS_CARDBUS_NOT_SUPPORTEDSTATUS_WX86_CREATEWX86TIBSTATUS_MP_PROCESSOR_MISMATCHSTATUS_HIBERNATEDSTATUS_RESUME_HIBERNATIONSTATUS_FIRMWARE_UPDATEDSTATUS_DRIVERS_LEAKING_LOCKED_PAGESSTATUS_MESSAGE_RETRIEVEDSTATUS_SYSTEM_POWERSTATE_TRANSITIONSTATUS_ALPC_CHECK_COMPLETION_LISTSTATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITIONSTATUS_ACCESS_AUDIT_BY_POLICYSTATUS_ABANDON_HIBERFILESTATUS_BIZRULES_NOT_ENABLEDSTATUS_FT_READ_FROM_COPYSTATUS_IMAGE_AT_DIFFERENT_BASEDBG_REPLY_LATERDBG_UNABLE_TO_PROVIDE_HANDLEDBG_TERMINATE_THREADDBG_TERMINATE_PROCESSDBG_CONTROL_CDBG_PRINTEXCEPTION_CDBG_RIPEXCEPTIONDBG_CONTROL_BREAKDBG_COMMAND_EXCEPTIONDBG_PRINTEXCEPTION_WIDE_CSTATUS_HEURISTIC_DAMAGE_POSSIBLESTATUS_GUARD_PAGE_VIOLATIONSTATUS_DATATYPE_MISALIGNMENTSTATUS_BREAKPOINTSTATUS_SINGLE_STEPSTATUS_NO_MORE_FILESSTATUS_WAKE_SYSTEM_DEBUGGERSTATUS_HANDLES_CLOSEDSTATUS_NO_INHERITANCESTATUS_GUID_SUBSTITUTION_MADESTATUS_PARTIAL_COPYSTATUS_DEVICE_PAPER_EMPTYSTATUS_DEVICE_POWERED_OFFSTATUS_DEVICE_OFF_LINESTATUS_DEVICE_BUSYSTATUS_NO_MORE_EASSTATUS_INVALID_EA_NAMESTATUS_EA_LIST_INCONSISTENTSTATUS_INVALID_EA_FLAGSTATUS_VERIFY_REQUIREDSTATUS_EXTRANEOUS_INFORMATIONSTATUS_RXACT_COMMIT_NECESSARYSTATUS_NO_MORE_ENTRIESSTATUS_FILEMARK_DETECTEDSTATUS_MEDIA_CHANGEDSTATUS_BUS_RESETSTATUS_END_OF_MEDIASTATUS_BEGINNING_OF_MEDIASTATUS_MEDIA_CHECKSTATUS_SETMARK_DETECTEDSTATUS_NO_DATA_DETECTEDSTATUS_REDIRECTOR_HAS_OPEN_HANDLESSTATUS_SERVER_HAS_OPEN_HANDLESSTATUS_ALREADY_DISCONNECTEDSTATUS_LONGJUMPSTATUS_CLEANER_CARTRIDGE_INSTALLEDSTATUS_PLUGPLAY_QUERY_VETOEDSTATUS_UNWIND_CONSOLIDATESTATUS_REGISTRY_HIVE_RECOVEREDSTATUS_DLL_MIGHT_BE_INSECURESTATUS_DLL_MIGHT_BE_INCOMPATIBLESTATUS_STOPPED_ON_SYMLINKSTATUS_CANNOT_GRANT_REQUESTED_OPLOCKSTATUS_NO_ACE_CONDITIONSTATUS_DEVICE_SUPPORT_IN_PROGRESSSTATUS_DEVICE_POWER_CYCLE_REQUIREDSTATUS_NO_WORK_DONEDBG_EXCEPTION_NOT_HANDLEDSTATUS_CLUSTER_NODE_ALREADY_UPSTATUS_CLUSTER_NODE_ALREADY_DOWNSTATUS_CLUSTER_NETWORK_ALREADY_ONLINESTATUS_CLUSTER_NETWORK_ALREADY_OFFLINESTATUS_CLUSTER_NODE_ALREADY_MEMBERSTATUS_FLT_BUFFER_TOO_SMALLSTATUS_FVE_PARTIAL_METADATASTATUS_FVE_TRANSIENT_STATESTATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCHSTATUS_UNSUCCESSFULSTATUS_NOT_IMPLEMENTEDSTATUS_INVALID_INFO_CLASSSTATUS_ACCESS_VIOLATIONSTATUS_IN_PAGE_ERRORSTATUS_PAGEFILE_QUOTASTATUS_INVALID_HANDLESTATUS_BAD_INITIAL_STACKSTATUS_BAD_INITIAL_PCSTATUS_INVALID_CIDSTATUS_TIMER_NOT_CANCELEDSTATUS_INVALID_PARAMETERSTATUS_NO_SUCH_DEVICESTATUS_NO_SUCH_FILESTATUS_INVALID_DEVICE_REQUESTSTATUS_END_OF_FILESTATUS_WRONG_VOLUMESTATUS_NO_MEDIA_IN_DEVICESTATUS_UNRECOGNIZED_MEDIASTATUS_NONEXISTENT_SECTORSTATUS_MORE_PROCESSING_REQUIREDSTATUS_CONFLICTING_ADDRESSESSTATUS_NOT_MAPPED_VIEWSTATUS_UNABLE_TO_FREE_VMSTATUS_UNABLE_TO_DELETE_SECTIONSTATUS_INVALID_SYSTEM_SERVICESTATUS_ILLEGAL_INSTRUCTIONSTATUS_INVALID_LOCK_SEQUENCESTATUS_INVALID_VIEW_SIZESTATUS_INVALID_FILE_FOR_SECTIONSTATUS_ALREADY_COMMITTEDSTATUS_ACCESS_DENIEDSTATUS_OBJECT_TYPE_MISMATCHSTATUS_NONCONTINUABLE_EXCEPTIONSTATUS_INVALID_DISPOSITIONSTATUS_UNWINDSTATUS_BAD_STACKSTATUS_INVALID_UNWIND_TARGETSTATUS_NOT_LOCKEDSTATUS_PARITY_ERRORSTATUS_UNABLE_TO_DECOMMIT_VMSTATUS_NOT_COMMITTEDSTATUS_INVALID_PORT_ATTRIBUTESSTATUS_PORT_MESSAGE_TOO_LONGSTATUS_INVALID_PARAMETER_MIXSTATUS_INVALID_QUOTA_LOWERSTATUS_DISK_CORRUPT_ERRORSTATUS_OBJECT_NAME_INVALIDSTATUS_OBJECT_NAME_NOT_FOUNDSTATUS_OBJECT_NAME_COLLISIONSTATUS_PORT_DO_NOT_DISTURBSTATUS_PORT_DISCONNECTEDSTATUS_DEVICE_ALREADY_ATTACHEDSTATUS_OBJECT_PATH_INVALIDSTATUS_OBJECT_PATH_NOT_FOUNDSTATUS_OBJECT_PATH_SYNTAX_BADSTATUS_DATA_OVERRUNSTATUS_DATA_LATE_ERRORSTATUS_DATA_ERRORSTATUS_CRC_ERRORSTATUS_SECTION_TOO_BIGSTATUS_PORT_CONNECTION_REFUSEDSTATUS_INVALID_PORT_HANDLESTATUS_SHARING_VIOLATIONSTATUS_QUOTA_EXCEEDEDSTATUS_INVALID_PAGE_PROTECTIONSTATUS_MUTANT_NOT_OWNEDSTATUS_SEMAPHORE_LIMIT_EXCEEDEDSTATUS_PORT_ALREADY_SETSTATUS_SECTION_NOT_IMAGESTATUS_SUSPEND_COUNT_EXCEEDEDSTATUS_THREAD_IS_TERMINATINGSTATUS_BAD_WORKING_SET_LIMITSTATUS_INCOMPATIBLE_FILE_MAPSTATUS_SECTION_PROTECTIONSTATUS_EAS_NOT_SUPPORTEDSTATUS_EA_TOO_LARGESTATUS_NONEXISTENT_EA_ENTRYSTATUS_NO_EAS_ON_FILESTATUS_EA_CORRUPT_ERRORSTATUS_FILE_LOCK_CONFLICTSTATUS_LOCK_NOT_GRANTEDSTATUS_DELETE_PENDINGSTATUS_CTL_FILE_NOT_SUPPORTEDSTATUS_UNKNOWN_REVISIONSTATUS_REVISION_MISMATCHSTATUS_INVALID_OWNERSTATUS_INVALID_PRIMARY_GROUPSTATUS_NO_IMPERSONATION_TOKENSTATUS_CANT_DISABLE_MANDATORYSTATUS_NO_LOGON_SERVERSSTATUS_NO_SUCH_LOGON_SESSIONSTATUS_NO_SUCH_PRIVILEGESTATUS_PRIVILEGE_NOT_HELDSTATUS_INVALID_ACCOUNT_NAMESTATUS_USER_EXISTSSTATUS_NO_SUCH_USERSTATUS_GROUP_EXISTSSTATUS_NO_SUCH_GROUPSTATUS_MEMBER_IN_GROUPSTATUS_MEMBER_NOT_IN_GROUPSTATUS_LAST_ADMINSTATUS_WRONG_PASSWORDSTATUS_ILL_FORMED_PASSWORDSTATUS_PASSWORD_RESTRICTIONSTATUS_LOGON_FAILURESTATUS_ACCOUNT_RESTRICTIONSTATUS_INVALID_LOGON_HOURSSTATUS_INVALID_WORKSTATIONSTATUS_PASSWORD_EXPIREDSTATUS_ACCOUNT_DISABLEDSTATUS_NONE_MAPPEDSTATUS_TOO_MANY_LUIDS_REQUESTEDSTATUS_LUIDS_EXHAUSTEDSTATUS_INVALID_SUB_AUTHORITYSTATUS_INVALID_ACLSTATUS_INVALID_SIDSTATUS_INVALID_SECURITY_DESCRSTATUS_PROCEDURE_NOT_FOUNDSTATUS_INVALID_IMAGE_FORMATSTATUS_NO_TOKENSTATUS_BAD_INHERITANCE_ACLSTATUS_RANGE_NOT_LOCKEDSTATUS_DISK_FULLSTATUS_SERVER_DISABLEDSTATUS_SERVER_NOT_DISABLEDSTATUS_TOO_MANY_GUIDS_REQUESTEDSTATUS_GUIDS_EXHAUSTEDSTATUS_INVALID_ID_AUTHORITYSTATUS_AGENTS_EXHAUSTEDSTATUS_INVALID_VOLUME_LABELSTATUS_SECTION_NOT_EXTENDEDSTATUS_NOT_MAPPED_DATASTATUS_RESOURCE_DATA_NOT_FOUNDSTATUS_RESOURCE_TYPE_NOT_FOUNDSTATUS_RESOURCE_NAME_NOT_FOUNDSTATUS_ARRAY_BOUNDS_EXCEEDEDSTATUS_FLOAT_DENORMAL_OPERANDSTATUS_FLOAT_DIVIDE_BY_ZEROSTATUS_FLOAT_INEXACT_RESULTSTATUS_FLOAT_INVALID_OPERATIONSTATUS_FLOAT_OVERFLOWSTATUS_FLOAT_STACK_CHECKSTATUS_FLOAT_UNDERFLOWSTATUS_INTEGER_DIVIDE_BY_ZEROSTATUS_INTEGER_OVERFLOWSTATUS_PRIVILEGED_INSTRUCTIONSTATUS_TOO_MANY_PAGING_FILESSTATUS_FILE_INVALIDSTATUS_ALLOTTED_SPACE_EXCEEDEDSTATUS_INSUFFICIENT_RESOURCESSTATUS_DFS_EXIT_PATH_FOUNDSTATUS_DEVICE_DATA_ERRORSTATUS_DEVICE_NOT_CONNECTEDSTATUS_DEVICE_POWER_FAILURESTATUS_FREE_VM_NOT_AT_BASESTATUS_MEMORY_NOT_ALLOCATEDSTATUS_WORKING_SET_QUOTASTATUS_MEDIA_WRITE_PROTECTEDSTATUS_DEVICE_NOT_READYSTATUS_INVALID_GROUP_ATTRIBUTESSTATUS_BAD_IMPERSONATION_LEVELSTATUS_CANT_OPEN_ANONYMOUSSTATUS_BAD_VALIDATION_CLASSSTATUS_BAD_TOKEN_TYPESTATUS_BAD_MASTER_BOOT_RECORDSTATUS_INSTRUCTION_MISALIGNMENTSTATUS_INSTANCE_NOT_AVAILABLESTATUS_PIPE_NOT_AVAILABLESTATUS_INVALID_PIPE_STATESTATUS_PIPE_BUSYSTATUS_ILLEGAL_FUNCTIONSTATUS_PIPE_DISCONNECTEDSTATUS_PIPE_CLOSINGSTATUS_PIPE_CONNECTEDSTATUS_PIPE_LISTENINGSTATUS_INVALID_READ_MODESTATUS_IO_TIMEOUTSTATUS_FILE_FORCED_CLOSEDSTATUS_PROFILING_NOT_STARTEDSTATUS_PROFILING_NOT_STOPPEDSTATUS_COULD_NOT_INTERPRETSTATUS_FILE_IS_A_DIRECTORYSTATUS_NOT_SUPPORTEDSTATUS_REMOTE_NOT_LISTENINGSTATUS_DUPLICATE_NAMESTATUS_BAD_NETWORK_PATHSTATUS_NETWORK_BUSYSTATUS_DEVICE_DOES_NOT_EXISTSTATUS_TOO_MANY_COMMANDSSTATUS_ADAPTER_HARDWARE_ERRORSTATUS_INVALID_NETWORK_RESPONSESTATUS_UNEXPECTED_NETWORK_ERRORSTATUS_BAD_REMOTE_ADAPTERSTATUS_PRINT_QUEUE_FULLSTATUS_NO_SPOOL_SPACESTATUS_PRINT_CANCELLEDSTATUS_NETWORK_NAME_DELETEDSTATUS_NETWORK_ACCESS_DENIEDSTATUS_BAD_DEVICE_TYPESTATUS_BAD_NETWORK_NAMESTATUS_TOO_MANY_NAMESSTATUS_TOO_MANY_SESSIONSSTATUS_SHARING_PAUSEDSTATUS_REQUEST_NOT_ACCEPTEDSTATUS_REDIRECTOR_PAUSEDSTATUS_NET_WRITE_FAULTSTATUS_PROFILING_AT_LIMITSTATUS_NOT_SAME_DEVICESTATUS_FILE_RENAMEDSTATUS_VIRTUAL_CIRCUIT_CLOSEDSTATUS_NO_SECURITY_ON_OBJECTSTATUS_CANT_WAITSTATUS_PIPE_EMPTYSTATUS_CANT_ACCESS_DOMAIN_INFOSTATUS_CANT_TERMINATE_SELFSTATUS_INVALID_SERVER_STATESTATUS_INVALID_DOMAIN_STATESTATUS_INVALID_DOMAIN_ROLESTATUS_NO_SUCH_DOMAINSTATUS_DOMAIN_EXISTSSTATUS_DOMAIN_LIMIT_EXCEEDEDSTATUS_OPLOCK_NOT_GRANTEDSTATUS_INVALID_OPLOCK_PROTOCOLSTATUS_INTERNAL_DB_CORRUPTIONSTATUS_INTERNAL_ERRORSTATUS_GENERIC_NOT_MAPPEDSTATUS_BAD_DESCRIPTOR_FORMATSTATUS_INVALID_USER_BUFFERSTATUS_UNEXPECTED_IO_ERRORSTATUS_UNEXPECTED_MM_CREATE_ERRSTATUS_UNEXPECTED_MM_MAP_ERRORSTATUS_UNEXPECTED_MM_EXTEND_ERRSTATUS_NOT_LOGON_PROCESSSTATUS_LOGON_SESSION_EXISTSSTATUS_INVALID_PARAMETER_1STATUS_INVALID_PARAMETER_2STATUS_INVALID_PARAMETER_3STATUS_INVALID_PARAMETER_4STATUS_INVALID_PARAMETER_5STATUS_INVALID_PARAMETER_6STATUS_INVALID_PARAMETER_7STATUS_INVALID_PARAMETER_8STATUS_INVALID_PARAMETER_9STATUS_INVALID_PARAMETER_10STATUS_INVALID_PARAMETER_11STATUS_INVALID_PARAMETER_12STATUS_REDIRECTOR_NOT_STARTEDSTATUS_REDIRECTOR_STARTEDSTATUS_STACK_OVERFLOWSTATUS_NO_SUCH_PACKAGESTATUS_BAD_FUNCTION_TABLESTATUS_VARIABLE_NOT_FOUNDSTATUS_DIRECTORY_NOT_EMPTYSTATUS_FILE_CORRUPT_ERRORSTATUS_NOT_A_DIRECTORYSTATUS_BAD_LOGON_SESSION_STATESTATUS_LOGON_SESSION_COLLISIONSTATUS_NAME_TOO_LONGSTATUS_FILES_OPENSTATUS_CONNECTION_IN_USESTATUS_MESSAGE_NOT_FOUNDSTATUS_PROCESS_IS_TERMINATINGSTATUS_INVALID_LOGON_TYPESTATUS_NO_GUID_TRANSLATIONSTATUS_CANNOT_IMPERSONATESTATUS_IMAGE_ALREADY_LOADEDSTATUS_ABIOS_NOT_PRESENTSTATUS_ABIOS_LID_NOT_EXISTSTATUS_ABIOS_LID_ALREADY_OWNEDSTATUS_ABIOS_NOT_LID_OWNERSTATUS_ABIOS_INVALID_COMMANDSTATUS_ABIOS_INVALID_LIDSTATUS_ABIOS_SELECTOR_NOT_AVAILABLESTATUS_ABIOS_INVALID_SELECTORSTATUS_NO_LDTSTATUS_INVALID_LDT_SIZESTATUS_INVALID_LDT_OFFSETSTATUS_INVALID_LDT_DESCRIPTORSTATUS_INVALID_IMAGE_NE_FORMATSTATUS_RXACT_INVALID_STATESTATUS_RXACT_COMMIT_FAILURESTATUS_MAPPED_FILE_SIZE_ZEROSTATUS_TOO_MANY_OPENED_FILESSTATUS_CANNOT_DELETESTATUS_INVALID_COMPUTER_NAMESTATUS_FILE_DELETEDSTATUS_SPECIAL_ACCOUNTSTATUS_SPECIAL_GROUPSTATUS_SPECIAL_USERSTATUS_MEMBERS_PRIMARY_GROUPSTATUS_FILE_CLOSEDSTATUS_TOO_MANY_THREADSSTATUS_THREAD_NOT_IN_PROCESSSTATUS_TOKEN_ALREADY_IN_USESTATUS_PAGEFILE_QUOTA_EXCEEDEDSTATUS_COMMITMENT_LIMITSTATUS_INVALID_IMAGE_LE_FORMATSTATUS_INVALID_IMAGE_NOT_MZSTATUS_INVALID_IMAGE_PROTECTSTATUS_INVALID_IMAGE_WIN_16STATUS_LOGON_SERVER_CONFLICTSTATUS_TIME_DIFFERENCE_AT_DCSTATUS_SYNCHRONIZATION_REQUIREDSTATUS_DLL_NOT_FOUNDSTATUS_OPEN_FAILEDSTATUS_IO_PRIVILEGE_FAILEDSTATUS_ORDINAL_NOT_FOUNDSTATUS_ENTRYPOINT_NOT_FOUNDSTATUS_CONTROL_C_EXITSTATUS_LOCAL_DISCONNECTSTATUS_REMOTE_DISCONNECTSTATUS_REMOTE_RESOURCESSTATUS_LINK_FAILEDSTATUS_LINK_TIMEOUTSTATUS_INVALID_CONNECTIONSTATUS_INVALID_ADDRESSSTATUS_DLL_INIT_FAILEDSTATUS_MISSING_SYSTEMFILESTATUS_UNHANDLED_EXCEPTIONSTATUS_APP_INIT_FAILURESTATUS_PAGEFILE_CREATE_FAILEDSTATUS_NO_PAGEFILESTATUS_INVALID_LEVELSTATUS_WRONG_PASSWORD_CORESTATUS_ILLEGAL_FLOAT_CONTEXTSTATUS_PIPE_BROKENSTATUS_REGISTRY_CORRUPTSTATUS_REGISTRY_IO_FAILEDSTATUS_NO_EVENT_PAIRSTATUS_UNRECOGNIZED_VOLUMESTATUS_SERIAL_NO_DEVICE_INITEDSTATUS_NO_SUCH_ALIASSTATUS_MEMBER_NOT_IN_ALIASSTATUS_MEMBER_IN_ALIASSTATUS_ALIAS_EXISTSSTATUS_LOGON_NOT_GRANTEDSTATUS_TOO_MANY_SECRETSSTATUS_SECRET_TOO_LONGSTATUS_INTERNAL_DB_ERRORSTATUS_FULLSCREEN_MODESTATUS_TOO_MANY_CONTEXT_IDSSTATUS_LOGON_TYPE_NOT_GRANTEDSTATUS_NOT_REGISTRY_FILESTATUS_NT_CROSS_ENCRYPTION_REQUIREDSTATUS_DOMAIN_CTRLR_CONFIG_ERRORSTATUS_FT_MISSING_MEMBERSTATUS_ILL_FORMED_SERVICE_ENTRYSTATUS_ILLEGAL_CHARACTERSTATUS_UNMAPPABLE_CHARACTERSTATUS_UNDEFINED_CHARACTERSTATUS_FLOPPY_VOLUMESTATUS_FLOPPY_ID_MARK_NOT_FOUNDSTATUS_FLOPPY_WRONG_CYLINDERSTATUS_FLOPPY_UNKNOWN_ERRORSTATUS_FLOPPY_BAD_REGISTERSSTATUS_DISK_RECALIBRATE_FAILEDSTATUS_DISK_OPERATION_FAILEDSTATUS_DISK_RESET_FAILEDSTATUS_SHARED_IRQ_BUSYSTATUS_FT_ORPHANINGSTATUS_BIOS_FAILED_TO_CONNECT_INTERRUPTSTATUS_PARTITION_FAILURESTATUS_INVALID_BLOCK_LENGTHSTATUS_DEVICE_NOT_PARTITIONEDSTATUS_UNABLE_TO_LOCK_MEDIASTATUS_UNABLE_TO_UNLOAD_MEDIASTATUS_EOM_OVERFLOWSTATUS_NO_MEDIASTATUS_NO_SUCH_MEMBERSTATUS_INVALID_MEMBERSTATUS_KEY_DELETEDSTATUS_NO_LOG_SPACESTATUS_TOO_MANY_SIDSSTATUS_LM_CROSS_ENCRYPTION_REQUIREDSTATUS_KEY_HAS_CHILDRENSTATUS_CHILD_MUST_BE_VOLATILESTATUS_DEVICE_CONFIGURATION_ERRORSTATUS_DRIVER_INTERNAL_ERRORSTATUS_INVALID_DEVICE_STATESTATUS_IO_DEVICE_ERRORSTATUS_DEVICE_PROTOCOL_ERRORSTATUS_BACKUP_CONTROLLERSTATUS_LOG_FILE_FULLSTATUS_TOO_LATESTATUS_NO_TRUST_LSA_SECRETSTATUS_NO_TRUST_SAM_ACCOUNTSTATUS_TRUSTED_DOMAIN_FAILURESTATUS_TRUSTED_RELATIONSHIP_FAILURESTATUS_EVENTLOG_FILE_CORRUPTSTATUS_EVENTLOG_CANT_STARTSTATUS_TRUST_FAILURESTATUS_MUTANT_LIMIT_EXCEEDEDSTATUS_NETLOGON_NOT_STARTEDSTATUS_ACCOUNT_EXPIREDSTATUS_POSSIBLE_DEADLOCKSTATUS_NETWORK_CREDENTIAL_CONFLICTSTATUS_REMOTE_SESSION_LIMITSTATUS_EVENTLOG_FILE_CHANGEDSTATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNTSTATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNTSTATUS_NOLOGON_SERVER_TRUST_ACCOUNTSTATUS_DOMAIN_TRUST_INCONSISTENTSTATUS_FS_DRIVER_REQUIREDSTATUS_IMAGE_ALREADY_LOADED_AS_DLLSTATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTINGSTATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUMESTATUS_SECURITY_STREAM_IS_INCONSISTENTSTATUS_INVALID_LOCK_RANGESTATUS_INVALID_ACE_CONDITIONSTATUS_IMAGE_SUBSYSTEM_NOT_PRESENTSTATUS_NOTIFICATION_GUID_ALREADY_DEFINEDSTATUS_INVALID_EXCEPTION_HANDLERSTATUS_DUPLICATE_PRIVILEGESSTATUS_NOT_ALLOWED_ON_SYSTEM_FILESTATUS_REPAIR_NEEDEDSTATUS_QUOTA_NOT_ENABLEDSTATUS_NO_APPLICATION_PACKAGESTATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESSSTATUS_NOT_SAME_OBJECTSTATUS_FATAL_MEMORY_EXHAUSTIONSTATUS_ERROR_PROCESS_NOT_IN_JOBSTATUS_CPU_SET_INVALIDSTATUS_NETWORK_OPEN_RESTRICTIONSTATUS_NO_USER_SESSION_KEYSTATUS_USER_SESSION_DELETEDSTATUS_RESOURCE_LANG_NOT_FOUNDSTATUS_INSUFF_SERVER_RESOURCESSTATUS_INVALID_BUFFER_SIZESTATUS_INVALID_ADDRESS_COMPONENTSTATUS_INVALID_ADDRESS_WILDCARDSTATUS_TOO_MANY_ADDRESSESSTATUS_ADDRESS_ALREADY_EXISTSSTATUS_ADDRESS_CLOSEDSTATUS_CONNECTION_DISCONNECTEDSTATUS_CONNECTION_RESETSTATUS_TOO_MANY_NODESSTATUS_TRANSACTION_ABORTEDSTATUS_TRANSACTION_TIMED_OUTSTATUS_TRANSACTION_NO_RELEASESTATUS_TRANSACTION_NO_MATCHSTATUS_TRANSACTION_RESPONDEDSTATUS_TRANSACTION_INVALID_IDSTATUS_TRANSACTION_INVALID_TYPESTATUS_NOT_SERVER_SESSIONSTATUS_NOT_CLIENT_SESSIONSTATUS_CANNOT_LOAD_REGISTRY_FILESTATUS_DEBUG_ATTACH_FAILEDSTATUS_SYSTEM_PROCESS_TERMINATEDSTATUS_DATA_NOT_ACCEPTEDSTATUS_NO_BROWSER_SERVERS_FOUNDSTATUS_VDM_HARD_ERRORSTATUS_DRIVER_CANCEL_TIMEOUTSTATUS_REPLY_MESSAGE_MISMATCHSTATUS_MAPPED_ALIGNMENTSTATUS_IMAGE_CHECKSUM_MISMATCHSTATUS_LOST_WRITEBEHIND_DATASTATUS_CLIENT_SERVER_PARAMETERS_INVALIDSTATUS_PASSWORD_MUST_CHANGESTATUS_NOT_TINY_STREAMSTATUS_RECOVERY_FAILURESTATUS_STACK_OVERFLOW_READSTATUS_FAIL_CHECKSTATUS_DUPLICATE_OBJECTIDSTATUS_OBJECTID_EXISTSSTATUS_CONVERT_TO_LARGESTATUS_RETRYSTATUS_FOUND_OUT_OF_SCOPESTATUS_ALLOCATE_BUCKETSTATUS_PROPSET_NOT_FOUNDSTATUS_MARSHALL_OVERFLOWSTATUS_INVALID_VARIANTSTATUS_DOMAIN_CONTROLLER_NOT_FOUNDSTATUS_ACCOUNT_LOCKED_OUTSTATUS_HANDLE_NOT_CLOSABLESTATUS_CONNECTION_REFUSEDSTATUS_GRACEFUL_DISCONNECTSTATUS_ADDRESS_ALREADY_ASSOCIATEDSTATUS_ADDRESS_NOT_ASSOCIATEDSTATUS_CONNECTION_INVALIDSTATUS_CONNECTION_ACTIVESTATUS_NETWORK_UNREACHABLESTATUS_HOST_UNREACHABLESTATUS_PROTOCOL_UNREACHABLESTATUS_PORT_UNREACHABLESTATUS_REQUEST_ABORTEDSTATUS_CONNECTION_ABORTEDSTATUS_BAD_COMPRESSION_BUFFERSTATUS_USER_MAPPED_FILESTATUS_AUDIT_FAILEDSTATUS_TIMER_RESOLUTION_NOT_SETSTATUS_CONNECTION_COUNT_LIMITSTATUS_LOGIN_TIME_RESTRICTIONSTATUS_LOGIN_WKSTA_RESTRICTIONSTATUS_IMAGE_MP_UP_MISMATCHSTATUS_INSUFFICIENT_LOGON_INFOSTATUS_BAD_DLL_ENTRYPOINTSTATUS_BAD_SERVICE_ENTRYPOINTSTATUS_LPC_REPLY_LOSTSTATUS_IP_ADDRESS_CONFLICT1STATUS_IP_ADDRESS_CONFLICT2STATUS_REGISTRY_QUOTA_LIMITSTATUS_PATH_NOT_COVEREDSTATUS_NO_CALLBACK_ACTIVESTATUS_LICENSE_QUOTA_EXCEEDEDSTATUS_PWD_TOO_SHORTSTATUS_PWD_TOO_RECENTSTATUS_PWD_HISTORY_CONFLICTSTATUS_PLUGPLAY_NO_DEVICESTATUS_UNSUPPORTED_COMPRESSIONSTATUS_INVALID_HW_PROFILESTATUS_INVALID_PLUGPLAY_DEVICE_PATHSTATUS_DRIVER_ORDINAL_NOT_FOUNDSTATUS_DRIVER_ENTRYPOINT_NOT_FOUNDSTATUS_RESOURCE_NOT_OWNEDSTATUS_TOO_MANY_LINKSSTATUS_QUOTA_LIST_INCONSISTENTSTATUS_FILE_IS_OFFLINESTATUS_EVALUATION_EXPIRATIONSTATUS_ILLEGAL_DLL_RELOCATIONSTATUS_LICENSE_VIOLATIONSTATUS_DLL_INIT_FAILED_LOGOFFSTATUS_DRIVER_UNABLE_TO_LOADSTATUS_DFS_UNAVAILABLESTATUS_VOLUME_DISMOUNTEDSTATUS_WX86_INTERNAL_ERRORSTATUS_WX86_FLOAT_STACK_CHECKSTATUS_VALIDATE_CONTINUESTATUS_NO_MATCHSTATUS_NO_MORE_MATCHESSTATUS_NOT_A_REPARSE_POINTSTATUS_IO_REPARSE_TAG_INVALIDSTATUS_IO_REPARSE_TAG_MISMATCHSTATUS_IO_REPARSE_DATA_INVALIDSTATUS_IO_REPARSE_TAG_NOT_HANDLEDSTATUS_PWD_TOO_LONGSTATUS_STOWED_EXCEPTIONSTATUS_REPARSE_POINT_NOT_RESOLVEDSTATUS_DIRECTORY_IS_A_REPARSE_POINTSTATUS_RANGE_LIST_CONFLICTSTATUS_SOURCE_ELEMENT_EMPTYSTATUS_DESTINATION_ELEMENT_FULLSTATUS_ILLEGAL_ELEMENT_ADDRESSSTATUS_MAGAZINE_NOT_PRESENTSTATUS_REINITIALIZATION_NEEDEDSTATUS_DEVICE_REQUIRES_CLEANINGSTATUS_DEVICE_DOOR_OPENSTATUS_ENCRYPTION_FAILEDSTATUS_DECRYPTION_FAILEDSTATUS_RANGE_NOT_FOUNDSTATUS_NO_RECOVERY_POLICYSTATUS_NO_EFSSTATUS_WRONG_EFSSTATUS_NO_USER_KEYSSTATUS_FILE_NOT_ENCRYPTEDSTATUS_NOT_EXPORT_FORMATSTATUS_FILE_ENCRYPTEDSTATUS_WAKE_SYSTEMSTATUS_WMI_GUID_NOT_FOUNDSTATUS_WMI_INSTANCE_NOT_FOUNDSTATUS_WMI_ITEMID_NOT_FOUNDSTATUS_WMI_TRY_AGAINSTATUS_SHARED_POLICYSTATUS_POLICY_OBJECT_NOT_FOUNDSTATUS_POLICY_ONLY_IN_DSSTATUS_VOLUME_NOT_UPGRADEDSTATUS_REMOTE_STORAGE_NOT_ACTIVESTATUS_REMOTE_STORAGE_MEDIA_ERRORSTATUS_NO_TRACKING_SERVICESTATUS_SERVER_SID_MISMATCHSTATUS_DS_NO_ATTRIBUTE_OR_VALUESTATUS_DS_INVALID_ATTRIBUTE_SYNTAXSTATUS_DS_ATTRIBUTE_TYPE_UNDEFINEDSTATUS_DS_ATTRIBUTE_OR_VALUE_EXISTSSTATUS_DS_BUSYSTATUS_DS_UNAVAILABLESTATUS_DS_NO_RIDS_ALLOCATEDSTATUS_DS_NO_MORE_RIDSSTATUS_DS_INCORRECT_ROLE_OWNERSTATUS_DS_RIDMGR_INIT_ERRORSTATUS_DS_OBJ_CLASS_VIOLATIONSTATUS_DS_CANT_ON_NON_LEAFSTATUS_DS_CANT_ON_RDNSTATUS_DS_CANT_MOD_OBJ_CLASSSTATUS_DS_CROSS_DOM_MOVE_FAILEDSTATUS_DS_GC_NOT_AVAILABLESTATUS_DIRECTORY_SERVICE_REQUIREDSTATUS_REPARSE_ATTRIBUTE_CONFLICTSTATUS_CANT_ENABLE_DENY_ONLYSTATUS_FLOAT_MULTIPLE_FAULTSSTATUS_FLOAT_MULTIPLE_TRAPSSTATUS_DEVICE_REMOVEDSTATUS_JOURNAL_DELETE_IN_PROGRESSSTATUS_JOURNAL_NOT_ACTIVESTATUS_NOINTERFACESTATUS_DS_RIDMGR_DISABLEDSTATUS_DS_ADMIN_LIMIT_EXCEEDEDSTATUS_DRIVER_FAILED_SLEEPSTATUS_MUTUAL_AUTHENTICATION_FAILEDSTATUS_CORRUPT_SYSTEM_FILESTATUS_DATATYPE_MISALIGNMENT_ERRORSTATUS_WMI_READ_ONLYSTATUS_WMI_SET_FAILURESTATUS_COMMITMENT_MINIMUMSTATUS_REG_NAT_CONSUMPTIONSTATUS_TRANSPORT_FULLSTATUS_DS_SAM_INIT_FAILURESTATUS_ONLY_IF_CONNECTEDSTATUS_DS_SENSITIVE_GROUP_VIOLATIONSTATUS_PNP_RESTART_ENUMERATIONSTATUS_JOURNAL_ENTRY_DELETEDSTATUS_DS_CANT_MOD_PRIMARYGROUPIDSTATUS_SYSTEM_IMAGE_BAD_SIGNATURESTATUS_PNP_REBOOT_REQUIREDSTATUS_POWER_STATE_INVALIDSTATUS_DS_INVALID_GROUP_TYPESTATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAINSTATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAINSTATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBERSTATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBERSTATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBERSTATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBERSTATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBERSTATUS_DS_HAVE_PRIMARY_MEMBERSSTATUS_WMI_NOT_SUPPORTEDSTATUS_INSUFFICIENT_POWERSTATUS_SAM_NEED_BOOTKEY_PASSWORDSTATUS_SAM_NEED_BOOTKEY_FLOPPYSTATUS_DS_CANT_STARTSTATUS_DS_INIT_FAILURESTATUS_SAM_INIT_FAILURESTATUS_DS_GC_REQUIREDSTATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLYSTATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPSSTATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDEDSTATUS_MULTIPLE_FAULT_VIOLATIONSTATUS_CURRENT_DOMAIN_NOT_ALLOWEDSTATUS_CANNOT_MAKESTATUS_SYSTEM_SHUTDOWNSTATUS_DS_INIT_FAILURE_CONSOLESTATUS_DS_SAM_INIT_FAILURE_CONSOLESTATUS_UNFINISHED_CONTEXT_DELETEDSTATUS_NO_TGT_REPLYSTATUS_OBJECTID_NOT_FOUNDSTATUS_NO_IP_ADDRESSESSTATUS_WRONG_CREDENTIAL_HANDLESTATUS_CRYPTO_SYSTEM_INVALIDSTATUS_MAX_REFERRALS_EXCEEDEDSTATUS_MUST_BE_KDCSTATUS_STRONG_CRYPTO_NOT_SUPPORTEDSTATUS_TOO_MANY_PRINCIPALSSTATUS_NO_PA_DATASTATUS_PKINIT_NAME_MISMATCHSTATUS_SMARTCARD_LOGON_REQUIREDSTATUS_KDC_INVALID_REQUESTSTATUS_KDC_UNABLE_TO_REFERSTATUS_KDC_UNKNOWN_ETYPESTATUS_SHUTDOWN_IN_PROGRESSSTATUS_SERVER_SHUTDOWN_IN_PROGRESSSTATUS_NOT_SUPPORTED_ON_SBSSTATUS_WMI_GUID_DISCONNECTEDSTATUS_WMI_ALREADY_DISABLEDSTATUS_WMI_ALREADY_ENABLEDSTATUS_MFT_TOO_FRAGMENTEDSTATUS_COPY_PROTECTION_FAILURESTATUS_CSS_AUTHENTICATION_FAILURESTATUS_CSS_KEY_NOT_PRESENTSTATUS_CSS_KEY_NOT_ESTABLISHEDSTATUS_CSS_SCRAMBLED_SECTORSTATUS_CSS_REGION_MISMATCHSTATUS_CSS_RESETS_EXHAUSTEDSTATUS_PASSWORD_CHANGE_REQUIREDSTATUS_PKINIT_FAILURESTATUS_SMARTCARD_SUBSYSTEM_FAILURESTATUS_NO_KERB_KEYSTATUS_HOST_DOWNSTATUS_UNSUPPORTED_PREAUTHSTATUS_EFS_ALG_BLOB_TOO_BIGSTATUS_PORT_NOT_SETSTATUS_DEBUGGER_INACTIVESTATUS_DS_VERSION_CHECK_FAILURESTATUS_AUDITING_DISABLEDSTATUS_PRENT4_MACHINE_ACCOUNTSTATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBERSTATUS_INVALID_IMAGE_WIN_32STATUS_INVALID_IMAGE_WIN_64STATUS_BAD_BINDINGSSTATUS_NETWORK_SESSION_EXPIREDSTATUS_APPHELP_BLOCKSTATUS_ALL_SIDS_FILTEREDSTATUS_NOT_SAFE_MODE_DRIVERSTATUS_ACCESS_DISABLED_BY_POLICY_DEFAULTSTATUS_ACCESS_DISABLED_BY_POLICY_PATHSTATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHERSTATUS_ACCESS_DISABLED_BY_POLICY_OTHERSTATUS_FAILED_DRIVER_ENTRYSTATUS_DEVICE_ENUMERATION_ERRORSTATUS_MOUNT_POINT_NOT_RESOLVEDSTATUS_INVALID_DEVICE_OBJECT_PARAMETERSTATUS_MCA_OCCUREDSTATUS_DRIVER_BLOCKED_CRITICALSTATUS_DRIVER_BLOCKEDSTATUS_DRIVER_DATABASE_ERRORSTATUS_SYSTEM_HIVE_TOO_LARGESTATUS_INVALID_IMPORT_OF_NON_DLLSTATUS_DS_SHUTTING_DOWNSTATUS_NO_SECRETSSTATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICYSTATUS_FAILED_STACK_SWITCHSTATUS_HEAP_CORRUPTIONSTATUS_SMARTCARD_WRONG_PINSTATUS_SMARTCARD_CARD_BLOCKEDSTATUS_SMARTCARD_CARD_NOT_AUTHENTICATEDSTATUS_SMARTCARD_NO_CARDSTATUS_SMARTCARD_NO_KEY_CONTAINERSTATUS_SMARTCARD_NO_CERTIFICATESTATUS_SMARTCARD_NO_KEYSETSTATUS_SMARTCARD_IO_ERRORSTATUS_DOWNGRADE_DETECTEDSTATUS_SMARTCARD_CERT_REVOKEDSTATUS_ISSUING_CA_UNTRUSTEDSTATUS_REVOCATION_OFFLINE_CSTATUS_PKINIT_CLIENT_FAILURESTATUS_SMARTCARD_CERT_EXPIREDSTATUS_DRIVER_FAILED_PRIOR_UNLOADSTATUS_SMARTCARD_SILENT_CONTEXTSTATUS_PER_USER_TRUST_QUOTA_EXCEEDEDSTATUS_ALL_USER_TRUST_QUOTA_EXCEEDEDSTATUS_USER_DELETE_TRUST_QUOTA_EXCEEDEDSTATUS_DS_NAME_NOT_UNIQUESTATUS_DS_DUPLICATE_ID_FOUNDSTATUS_DS_GROUP_CONVERSION_ERRORSTATUS_VOLSNAP_PREPARE_HIBERNATESTATUS_USER2USER_REQUIREDSTATUS_STACK_BUFFER_OVERRUNSTATUS_NO_S4U_PROT_SUPPORTSTATUS_CROSSREALM_DELEGATION_FAILURESTATUS_REVOCATION_OFFLINE_KDCSTATUS_ISSUING_CA_UNTRUSTED_KDCSTATUS_KDC_CERT_EXPIREDSTATUS_KDC_CERT_REVOKEDSTATUS_PARAMETER_QUOTA_EXCEEDEDSTATUS_HIBERNATION_FAILURESTATUS_DELAY_LOAD_FAILEDSTATUS_AUTHENTICATION_FIREWALL_FAILEDSTATUS_VDM_DISALLOWEDSTATUS_HUNG_DISPLAY_DRIVER_THREADSTATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZESTATUS_INVALID_CRUNTIME_PARAMETERSTATUS_NTLM_BLOCKEDSTATUS_DS_SRC_SID_EXISTS_IN_FORESTSTATUS_DS_DOMAIN_NAME_EXISTS_IN_FORESTSTATUS_DS_FLAT_NAME_EXISTS_IN_FORESTSTATUS_INVALID_USER_PRINCIPAL_NAMESTATUS_FATAL_USER_CALLBACK_EXCEPTIONSTATUS_ASSERTION_FAILURESTATUS_VERIFIER_STOPSTATUS_CALLBACK_POP_STACKSTATUS_INCOMPATIBLE_DRIVER_BLOCKEDSTATUS_HIVE_UNLOADEDSTATUS_COMPRESSION_DISABLEDSTATUS_FILE_SYSTEM_LIMITATIONSTATUS_INVALID_IMAGE_HASHSTATUS_NOT_CAPABLESTATUS_REQUEST_OUT_OF_SEQUENCESTATUS_IMPLEMENTATION_LIMITSTATUS_ELEVATION_REQUIREDSTATUS_NO_SECURITY_CONTEXTSTATUS_PKU2U_CERT_FAILURESTATUS_BEYOND_VDLSTATUS_ENCOUNTERED_WRITE_IN_PROGRESSSTATUS_PTE_CHANGEDSTATUS_PURGE_FAILEDSTATUS_CRED_REQUIRES_CONFIRMATIONSTATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSESTATUS_CS_ENCRYPTION_UNSUPPORTED_SERVERSTATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILESTATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILESTATUS_CS_ENCRYPTION_FILE_NOT_CSESTATUS_INVALID_LABELSTATUS_DRIVER_PROCESS_TERMINATEDSTATUS_AMBIGUOUS_SYSTEM_DEVICESTATUS_SYSTEM_DEVICE_NOT_FOUNDSTATUS_RESTART_BOOT_APPLICATIONSTATUS_INSUFFICIENT_NVRAM_RESOURCESSTATUS_INVALID_SESSIONSTATUS_THREAD_ALREADY_IN_SESSIONSTATUS_THREAD_NOT_IN_SESSIONSTATUS_REQUEST_PAUSEDSTATUS_NO_RANGES_PROCESSEDSTATUS_DISK_RESOURCES_EXHAUSTEDSTATUS_NEEDS_REMEDIATIONSTATUS_DEVICE_FEATURE_NOT_SUPPORTEDSTATUS_DEVICE_UNREACHABLESTATUS_INVALID_TOKENSTATUS_SERVER_UNAVAILABLESTATUS_FILE_NOT_AVAILABLESTATUS_DEVICE_INSUFFICIENT_RESOURCESSTATUS_PACKAGE_UPDATINGSTATUS_NOT_READ_FROM_COPYSTATUS_FT_WRITE_FAILURESTATUS_FT_DI_SCAN_REQUIREDSTATUS_OBJECT_NOT_EXTERNALLY_BACKEDSTATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWNSTATUS_COMPRESSION_NOT_BENEFICIALSTATUS_DATA_CHECKSUM_ERRORSTATUS_INTERMIXED_KERNEL_EA_OPERATIONSTATUS_TRIM_READ_ZERO_NOT_SUPPORTEDSTATUS_TOO_MANY_SEGMENT_DESCRIPTORSSTATUS_INVALID_OFFSET_ALIGNMENTSTATUS_INVALID_FIELD_IN_PARAMETER_LISTSTATUS_OPERATION_IN_PROGRESSSTATUS_INVALID_INITIATOR_TARGET_PATHSTATUS_SCRUB_DATA_DISABLEDSTATUS_NOT_REDUNDANT_STORAGESTATUS_RESIDENT_FILE_NOT_SUPPORTEDSTATUS_COMPRESSED_FILE_NOT_SUPPORTEDSTATUS_DIRECTORY_NOT_SUPPORTEDSTATUS_IO_OPERATION_TIMEOUTSTATUS_SYSTEM_NEEDS_REMEDIATIONSTATUS_APPX_INTEGRITY_FAILURE_CLR_NGENSTATUS_SHARE_UNAVAILABLESTATUS_APISET_NOT_HOSTEDSTATUS_APISET_NOT_PRESENTSTATUS_DEVICE_HARDWARE_ERRORSTATUS_FIRMWARE_SLOT_INVALIDSTATUS_FIRMWARE_IMAGE_INVALIDSTATUS_STORAGE_TOPOLOGY_ID_MISMATCHSTATUS_WIM_NOT_BOOTABLESTATUS_BLOCKED_BY_PARENTAL_CONTROLSSTATUS_NEEDS_REGISTRATIONSTATUS_QUOTA_ACTIVITYSTATUS_CALLBACK_INVOKE_INLINESTATUS_BLOCK_TOO_MANY_REFERENCESSTATUS_MARKED_TO_DISALLOW_WRITESSTATUS_NETWORK_ACCESS_DENIED_EDPSTATUS_ENCLAVE_FAILURESTATUS_PNP_NO_COMPAT_DRIVERSSTATUS_PNP_DRIVER_PACKAGE_NOT_FOUNDSTATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUNDSTATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETESTATUS_PNP_FUNCTION_DRIVER_REQUIREDSTATUS_PNP_DEVICE_CONFIGURATION_PENDINGSTATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALLSTATUS_PACKAGE_NOT_AVAILABLESTATUS_DEVICE_IN_MAINTENANCESTATUS_NOT_SUPPORTED_ON_DAXSTATUS_FREE_SPACE_TOO_FRAGMENTEDSTATUS_DAX_MAPPING_EXISTSSTATUS_CHILD_PROCESS_BLOCKEDSTATUS_STORAGE_LOST_DATA_PERSISTENCESTATUS_INVALID_TASK_NAMESTATUS_INVALID_TASK_INDEXSTATUS_THREAD_ALREADY_IN_TASKSTATUS_CALLBACK_BYPASSSTATUS_UNDEFINED_SCOPESTATUS_INVALID_CAPSTATUS_NOT_GUI_PROCESSSTATUS_DEVICE_HUNGSTATUS_CONTAINER_ASSIGNEDSTATUS_JOB_NO_CONTAINERSTATUS_DEVICE_UNRESPONSIVESTATUS_REPARSE_POINT_ENCOUNTEREDSTATUS_FAIL_FAST_EXCEPTIONSTATUS_IMAGE_CERT_REVOKEDSTATUS_DYNAMIC_CODE_BLOCKEDSTATUS_IMAGE_CERT_EXPIREDSTATUS_PORT_CLOSEDSTATUS_MESSAGE_LOSTSTATUS_INVALID_MESSAGESTATUS_REQUEST_CANCELEDSTATUS_RECURSIVE_DISPATCHSTATUS_LPC_RECEIVE_BUFFER_EXPECTEDSTATUS_LPC_INVALID_CONNECTION_USAGESTATUS_LPC_REQUESTS_NOT_ALLOWEDSTATUS_RESOURCE_IN_USESTATUS_HARDWARE_MEMORY_ERRORSTATUS_THREADPOOL_HANDLE_EXCEPTIONSTATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILEDSTATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILEDSTATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILEDSTATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILEDSTATUS_THREADPOOL_RELEASED_DURING_OPERATIONSTATUS_CALLBACK_RETURNED_WHILE_IMPERSONATINGSTATUS_APC_RETURNED_WHILE_IMPERSONATINGSTATUS_PROCESS_IS_PROTECTEDSTATUS_MCA_EXCEPTIONSTATUS_CERTIFICATE_MAPPING_NOT_UNIQUESTATUS_SYMLINK_CLASS_DISABLEDSTATUS_INVALID_IDN_NORMALIZATIONSTATUS_NO_UNICODE_TRANSLATIONSTATUS_ALREADY_REGISTEREDSTATUS_CONTEXT_MISMATCHSTATUS_PORT_ALREADY_HAS_COMPLETION_LISTSTATUS_CALLBACK_RETURNED_THREAD_PRIORITYSTATUS_INVALID_THREADSTATUS_CALLBACK_RETURNED_TRANSACTIONSTATUS_CALLBACK_RETURNED_LDR_LOCKSTATUS_CALLBACK_RETURNED_LANGSTATUS_CALLBACK_RETURNED_PRI_BACKSTATUS_CALLBACK_RETURNED_THREAD_AFFINITYSTATUS_LPC_HANDLE_COUNT_EXCEEDEDSTATUS_DISK_REPAIR_DISABLEDSTATUS_DS_DOMAIN_RENAME_IN_PROGRESSSTATUS_DISK_QUOTA_EXCEEDEDSTATUS_DATA_LOST_REPAIRSTATUS_CONTENT_BLOCKEDSTATUS_BAD_CLUSTERSSTATUS_VOLUME_DIRTYSTATUS_DISK_REPAIR_REDIRECTEDSTATUS_DISK_REPAIR_UNSUCCESSFULSTATUS_CORRUPT_LOG_OVERFULLSTATUS_CORRUPT_LOG_CORRUPTEDSTATUS_CORRUPT_LOG_UNAVAILABLESTATUS_CORRUPT_LOG_DELETED_FULLSTATUS_CORRUPT_LOG_CLEAREDSTATUS_ORPHAN_NAME_EXHAUSTEDSTATUS_PROACTIVE_SCAN_IN_PROGRESSSTATUS_ENCRYPTED_IO_NOT_POSSIBLESTATUS_CORRUPT_LOG_UPLEVEL_RECORDSSTATUS_FILE_CHECKED_OUTSTATUS_CHECKOUT_REQUIREDSTATUS_BAD_FILE_TYPESTATUS_FILE_TOO_LARGESTATUS_FORMS_AUTH_REQUIREDSTATUS_VIRUS_INFECTEDSTATUS_VIRUS_DELETEDSTATUS_BAD_MCFG_TABLESTATUS_CANNOT_BREAK_OPLOCKSTATUS_BAD_KEYSTATUS_BAD_DATASTATUS_NO_KEYSTATUS_FILE_HANDLE_REVOKEDSTATUS_WOW_ASSERTIONSTATUS_INVALID_SIGNATURESTATUS_HMAC_NOT_SUPPORTEDSTATUS_AUTH_TAG_MISMATCHSTATUS_INVALID_STATE_TRANSITIONSTATUS_INVALID_KERNEL_INFO_VERSIONSTATUS_INVALID_PEP_INFO_VERSIONSTATUS_HANDLE_REVOKEDSTATUS_EOF_ON_GHOSTED_RANGESTATUS_IPSEC_QUEUE_OVERFLOWSTATUS_ND_QUEUE_OVERFLOWSTATUS_HOPLIMIT_EXCEEDEDSTATUS_PROTOCOL_NOT_SUPPORTEDSTATUS_FASTPATH_REJECTEDSTATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTEDSTATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERRORSTATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERRORSTATUS_XML_PARSE_ERRORSTATUS_XMLDSIG_ERRORSTATUS_WRONG_COMPARTMENTSTATUS_AUTHIP_FAILURESTATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERSSTATUS_DS_OID_NOT_FOUNDSTATUS_INCORRECT_ACCOUNT_TYPESTATUS_HASH_NOT_SUPPORTEDSTATUS_HASH_NOT_PRESENTSTATUS_SECONDARY_IC_PROVIDER_NOT_REGISTEREDSTATUS_GPIO_CLIENT_INFORMATION_INVALIDSTATUS_GPIO_VERSION_NOT_SUPPORTEDSTATUS_GPIO_INVALID_REGISTRATION_PACKETSTATUS_GPIO_OPERATION_DENIEDSTATUS_GPIO_INCOMPATIBLE_CONNECT_MODESTATUS_GPIO_INTERRUPT_ALREADY_UNMASKEDSTATUS_CANNOT_SWITCH_RUNLEVELSTATUS_INVALID_RUNLEVEL_SETTINGSTATUS_RUNLEVEL_SWITCH_TIMEOUTSTATUS_SERVICES_FAILED_AUTOSTARTSTATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUTSTATUS_RUNLEVEL_SWITCH_IN_PROGRESSSTATUS_NOT_APPCONTAINERSTATUS_NOT_SUPPORTED_IN_APPCONTAINERSTATUS_INVALID_PACKAGE_SID_LENGTHSTATUS_APP_DATA_NOT_FOUNDSTATUS_APP_DATA_EXPIREDSTATUS_APP_DATA_CORRUPTSTATUS_APP_DATA_LIMIT_EXCEEDEDSTATUS_APP_DATA_REBOOT_REQUIREDSTATUS_OFFLOAD_READ_FLT_NOT_SUPPORTEDSTATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTEDSTATUS_OFFLOAD_READ_FILE_NOT_SUPPORTEDSTATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTEDSTATUS_CLOUD_FILE_PROVIDER_UNKNOWNSTATUS_CLOUD_FILE_PROVIDER_NOT_RUNNINGSTATUS_CLOUD_FILE_METADATA_CORRUPTSTATUS_CLOUD_FILE_METADATA_TOO_LARGESTATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGEDBG_NO_STATE_CHANGEDBG_APP_NOT_IDLERPC_NT_INVALID_STRING_BINDINGRPC_NT_WRONG_KIND_OF_BINDINGRPC_NT_INVALID_BINDINGRPC_NT_PROTSEQ_NOT_SUPPORTEDRPC_NT_INVALID_RPC_PROTSEQRPC_NT_INVALID_STRING_UUIDRPC_NT_INVALID_ENDPOINT_FORMATRPC_NT_INVALID_NET_ADDRRPC_NT_NO_ENDPOINT_FOUNDRPC_NT_INVALID_TIMEOUTRPC_NT_OBJECT_NOT_FOUNDRPC_NT_ALREADY_REGISTEREDRPC_NT_TYPE_ALREADY_REGISTEREDRPC_NT_ALREADY_LISTENINGRPC_NT_NO_PROTSEQS_REGISTEREDRPC_NT_NOT_LISTENINGRPC_NT_UNKNOWN_MGR_TYPERPC_NT_UNKNOWN_IFRPC_NT_NO_BINDINGSRPC_NT_NO_PROTSEQSRPC_NT_CANT_CREATE_ENDPOINTRPC_NT_OUT_OF_RESOURCESRPC_NT_SERVER_UNAVAILABLERPC_NT_SERVER_TOO_BUSYRPC_NT_INVALID_NETWORK_OPTIONSRPC_NT_NO_CALL_ACTIVERPC_NT_CALL_FAILEDRPC_NT_CALL_FAILED_DNERPC_NT_PROTOCOL_ERRORRPC_NT_UNSUPPORTED_TRANS_SYNRPC_NT_UNSUPPORTED_TYPERPC_NT_INVALID_TAGRPC_NT_INVALID_BOUNDRPC_NT_NO_ENTRY_NAMERPC_NT_INVALID_NAME_SYNTAXRPC_NT_UNSUPPORTED_NAME_SYNTAXRPC_NT_UUID_NO_ADDRESSRPC_NT_DUPLICATE_ENDPOINTRPC_NT_UNKNOWN_AUTHN_TYPERPC_NT_MAX_CALLS_TOO_SMALLRPC_NT_STRING_TOO_LONGRPC_NT_PROTSEQ_NOT_FOUNDRPC_NT_PROCNUM_OUT_OF_RANGERPC_NT_BINDING_HAS_NO_AUTHRPC_NT_UNKNOWN_AUTHN_SERVICERPC_NT_UNKNOWN_AUTHN_LEVELRPC_NT_INVALID_AUTH_IDENTITYRPC_NT_UNKNOWN_AUTHZ_SERVICEEPT_NT_INVALID_ENTRYEPT_NT_CANT_PERFORM_OPEPT_NT_NOT_REGISTEREDRPC_NT_NOTHING_TO_EXPORTRPC_NT_INCOMPLETE_NAMERPC_NT_INVALID_VERS_OPTIONRPC_NT_NO_MORE_MEMBERSRPC_NT_NOT_ALL_OBJS_UNEXPORTEDRPC_NT_INTERFACE_NOT_FOUNDRPC_NT_ENTRY_ALREADY_EXISTSRPC_NT_ENTRY_NOT_FOUNDRPC_NT_NAME_SERVICE_UNAVAILABLERPC_NT_INVALID_NAF_IDRPC_NT_CANNOT_SUPPORTRPC_NT_NO_CONTEXT_AVAILABLERPC_NT_INTERNAL_ERRORRPC_NT_ZERO_DIVIDERPC_NT_ADDRESS_ERRORRPC_NT_FP_DIV_ZERORPC_NT_FP_UNDERFLOWRPC_NT_FP_OVERFLOWRPC_NT_NO_MORE_ENTRIESRPC_NT_SS_CHAR_TRANS_OPEN_FAILRPC_NT_SS_CHAR_TRANS_SHORT_FILERPC_NT_SS_IN_NULL_CONTEXTRPC_NT_SS_CONTEXT_MISMATCHRPC_NT_SS_CONTEXT_DAMAGEDRPC_NT_SS_HANDLES_MISMATCHRPC_NT_SS_CANNOT_GET_CALL_HANDLERPC_NT_NULL_REF_POINTERRPC_NT_ENUM_VALUE_OUT_OF_RANGERPC_NT_BYTE_COUNT_TOO_SMALLRPC_NT_BAD_STUB_DATARPC_NT_CALL_IN_PROGRESSRPC_NT_NO_MORE_BINDINGSRPC_NT_GROUP_MEMBER_NOT_FOUNDEPT_NT_CANT_CREATERPC_NT_INVALID_OBJECTRPC_NT_NO_INTERFACESRPC_NT_CALL_CANCELLEDRPC_NT_BINDING_INCOMPLETERPC_NT_COMM_FAILURERPC_NT_UNSUPPORTED_AUTHN_LEVELRPC_NT_NO_PRINC_NAMERPC_NT_NOT_RPC_ERRORRPC_NT_UUID_LOCAL_ONLYRPC_NT_SEC_PKG_ERRORRPC_NT_NOT_CANCELLEDRPC_NT_INVALID_ES_ACTIONRPC_NT_WRONG_ES_VERSIONRPC_NT_WRONG_STUB_VERSIONRPC_NT_INVALID_PIPE_OBJECTRPC_NT_INVALID_PIPE_OPERATIONRPC_NT_WRONG_PIPE_VERSIONRPC_NT_PIPE_CLOSEDRPC_NT_PIPE_DISCIPLINE_ERRORRPC_NT_PIPE_EMPTYRPC_NT_INVALID_ASYNC_HANDLERPC_NT_INVALID_ASYNC_CALLRPC_NT_PROXY_ACCESS_DENIEDRPC_NT_COOKIE_AUTH_FAILEDRPC_NT_SEND_INCOMPLETESTATUS_ACPI_INVALID_OPCODESTATUS_ACPI_STACK_OVERFLOWSTATUS_ACPI_ASSERT_FAILEDSTATUS_ACPI_INVALID_INDEXSTATUS_ACPI_INVALID_ARGUMENTSTATUS_ACPI_FATALSTATUS_ACPI_INVALID_SUPERNAMESTATUS_ACPI_INVALID_ARGTYPESTATUS_ACPI_INVALID_OBJTYPESTATUS_ACPI_INVALID_TARGETTYPESTATUS_ACPI_INCORRECT_ARGUMENT_COUNTSTATUS_ACPI_ADDRESS_NOT_MAPPEDSTATUS_ACPI_INVALID_EVENTTYPESTATUS_ACPI_HANDLER_COLLISIONSTATUS_ACPI_INVALID_DATASTATUS_ACPI_INVALID_REGIONSTATUS_ACPI_INVALID_ACCESS_SIZESTATUS_ACPI_ACQUIRE_GLOBAL_LOCKSTATUS_ACPI_ALREADY_INITIALIZEDSTATUS_ACPI_NOT_INITIALIZEDSTATUS_ACPI_INVALID_MUTEX_LEVELSTATUS_ACPI_MUTEX_NOT_OWNEDSTATUS_ACPI_MUTEX_NOT_OWNERSTATUS_ACPI_RS_ACCESSSTATUS_ACPI_INVALID_TABLESTATUS_ACPI_REG_HANDLER_FAILEDSTATUS_ACPI_POWER_REQUEST_FAILEDSTATUS_CTX_WINSTATION_NAME_INVALIDSTATUS_CTX_INVALID_PDSTATUS_CTX_PD_NOT_FOUNDSTATUS_CTX_CDM_CONNECTSTATUS_CTX_CDM_DISCONNECTSTATUS_CTX_CLOSE_PENDINGSTATUS_CTX_NO_OUTBUFSTATUS_CTX_MODEM_INF_NOT_FOUNDSTATUS_CTX_INVALID_MODEMNAMESTATUS_CTX_RESPONSE_ERRORSTATUS_CTX_MODEM_RESPONSE_TIMEOUTSTATUS_CTX_MODEM_RESPONSE_NO_CARRIERSTATUS_CTX_MODEM_RESPONSE_NO_DIALTONESTATUS_CTX_MODEM_RESPONSE_BUSYSTATUS_CTX_MODEM_RESPONSE_VOICESTATUS_CTX_TD_ERRORSTATUS_CTX_LICENSE_CLIENT_INVALIDSTATUS_CTX_LICENSE_NOT_AVAILABLESTATUS_CTX_LICENSE_EXPIREDSTATUS_CTX_WINSTATION_NOT_FOUNDSTATUS_CTX_WINSTATION_NAME_COLLISIONSTATUS_CTX_WINSTATION_BUSYSTATUS_CTX_BAD_VIDEO_MODESTATUS_CTX_GRAPHICS_INVALIDSTATUS_CTX_NOT_CONSOLESTATUS_CTX_CLIENT_QUERY_TIMEOUTSTATUS_CTX_CONSOLE_DISCONNECTSTATUS_CTX_CONSOLE_CONNECTSTATUS_CTX_SHADOW_DENIEDSTATUS_CTX_WINSTATION_ACCESS_DENIEDSTATUS_CTX_INVALID_WDSTATUS_CTX_WD_NOT_FOUNDSTATUS_CTX_SHADOW_INVALIDSTATUS_CTX_SHADOW_DISABLEDSTATUS_RDP_PROTOCOL_ERRORSTATUS_CTX_CLIENT_LICENSE_NOT_SETSTATUS_CTX_CLIENT_LICENSE_IN_USESTATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGESTATUS_CTX_SHADOW_NOT_RUNNINGSTATUS_CTX_LOGON_DISABLEDSTATUS_CTX_SECURITY_LAYER_ERRORSTATUS_TS_INCOMPATIBLE_SESSIONSSTATUS_TS_VIDEO_SUBSYSTEM_ERRORSTATUS_PNP_BAD_MPS_TABLESTATUS_PNP_TRANSLATION_FAILEDSTATUS_PNP_IRQ_TRANSLATION_FAILEDSTATUS_PNP_INVALID_IDSTATUS_IO_REISSUE_AS_CACHEDSTATUS_MUI_FILE_NOT_FOUNDSTATUS_MUI_INVALID_FILESTATUS_MUI_INVALID_RC_CONFIGSTATUS_MUI_INVALID_LOCALE_NAMESTATUS_MUI_INVALID_ULTIMATEFALLBACK_NAMESTATUS_MUI_FILE_NOT_LOADEDSTATUS_RESOURCE_ENUM_USER_STOPSTATUS_FLT_NO_HANDLER_DEFINED//FILTER_FLT_NTSTATUS_FROM_HRESULTSTATUS_FLT_CONTEXT_ALREADY_DEFINEDSTATUS_FLT_INVALID_ASYNCHRONOUS_REQUESTSTATUS_FLT_DISALLOW_FAST_IOSTATUS_FLT_INVALID_NAME_REQUESTSTATUS_FLT_NOT_SAFE_TO_POST_OPERATIONSTATUS_FLT_NOT_INITIALIZEDSTATUS_FLT_FILTER_NOT_READYSTATUS_FLT_POST_OPERATION_CLEANUPSTATUS_FLT_INTERNAL_ERRORSTATUS_FLT_DELETING_OBJECTSTATUS_FLT_MUST_BE_NONPAGED_POOLSTATUS_FLT_DUPLICATE_ENTRYSTATUS_FLT_CBDQ_DISABLEDSTATUS_FLT_DO_NOT_ATTACHSTATUS_FLT_DO_NOT_DETACHSTATUS_FLT_INSTANCE_ALTITUDE_COLLISIONSTATUS_FLT_INSTANCE_NAME_COLLISIONSTATUS_FLT_FILTER_NOT_FOUNDSTATUS_FLT_VOLUME_NOT_FOUNDSTATUS_FLT_INSTANCE_NOT_FOUNDSTATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUNDSTATUS_FLT_INVALID_CONTEXT_REGISTRATIONSTATUS_FLT_NAME_CACHE_MISSSTATUS_FLT_NO_DEVICE_OBJECTSTATUS_FLT_VOLUME_ALREADY_MOUNTEDSTATUS_FLT_ALREADY_ENLISTEDSTATUS_FLT_CONTEXT_ALREADY_LINKEDSTATUS_FLT_NO_WAITER_FOR_REPLYSTATUS_FLT_REGISTRATION_BUSYSTATUS_SXS_SECTION_NOT_FOUNDSTATUS_SXS_CANT_GEN_ACTCTXSTATUS_SXS_INVALID_ACTCTXDATA_FORMATSTATUS_SXS_ASSEMBLY_NOT_FOUNDSTATUS_SXS_MANIFEST_FORMAT_ERRORSTATUS_SXS_MANIFEST_PARSE_ERRORSTATUS_SXS_ACTIVATION_CONTEXT_DISABLEDSTATUS_SXS_KEY_NOT_FOUNDSTATUS_SXS_VERSION_CONFLICTSTATUS_SXS_WRONG_SECTION_TYPESTATUS_SXS_THREAD_QUERIES_DISABLEDSTATUS_SXS_ASSEMBLY_MISSINGSTATUS_SXS_RELEASE_ACTIVATION_CONTEXTSTATUS_SXS_PROCESS_DEFAULT_ALREADY_SETSTATUS_SXS_EARLY_DEACTIVATIONSTATUS_SXS_INVALID_DEACTIVATIONSTATUS_SXS_MULTIPLE_DEACTIVATIONSTATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTYSTATUS_SXS_PROCESS_TERMINATION_REQUESTEDSTATUS_SXS_CORRUPT_ACTIVATION_STACKSTATUS_SXS_CORRUPTIONSTATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUESTATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAMESTATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTESTATUS_SXS_IDENTITY_PARSE_ERRORSTATUS_SXS_COMPONENT_STORE_CORRUPTSTATUS_SXS_FILE_HASH_MISMATCHSTATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENTSTATUS_SXS_IDENTITIES_DIFFERENTSTATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENTSTATUS_SXS_FILE_NOT_PART_OF_ASSEMBLYSTATUS_ADVANCED_INSTALLER_FAILEDSTATUS_XML_ENCODING_MISMATCHSTATUS_SXS_MANIFEST_TOO_BIGSTATUS_SXS_SETTING_NOT_REGISTEREDSTATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETESTATUS_SMI_PRIMITIVE_INSTALLER_FAILEDSTATUS_GENERIC_COMMAND_FAILEDSTATUS_SXS_FILE_HASH_MISSINGSTATUS_CLUSTER_INVALID_NODESTATUS_CLUSTER_NODE_EXISTSSTATUS_CLUSTER_JOIN_IN_PROGRESSSTATUS_CLUSTER_NODE_NOT_FOUNDSTATUS_CLUSTER_LOCAL_NODE_NOT_FOUNDSTATUS_CLUSTER_NETWORK_EXISTSSTATUS_CLUSTER_NETWORK_NOT_FOUNDSTATUS_CLUSTER_NETINTERFACE_EXISTSSTATUS_CLUSTER_NETINTERFACE_NOT_FOUNDSTATUS_CLUSTER_INVALID_REQUESTSTATUS_CLUSTER_INVALID_NETWORK_PROVIDERSTATUS_CLUSTER_NODE_DOWNSTATUS_CLUSTER_NODE_UNREACHABLESTATUS_CLUSTER_NODE_NOT_MEMBERSTATUS_CLUSTER_JOIN_NOT_IN_PROGRESSSTATUS_CLUSTER_INVALID_NETWORKSTATUS_CLUSTER_NO_NET_ADAPTERSSTATUS_CLUSTER_NODE_UPSTATUS_CLUSTER_NODE_PAUSEDSTATUS_CLUSTER_NODE_NOT_PAUSEDSTATUS_CLUSTER_NO_SECURITY_CONTEXTSTATUS_CLUSTER_NETWORK_NOT_INTERNALSTATUS_CLUSTER_POISONEDSTATUS_CLUSTER_NON_CSV_PATHSTATUS_CLUSTER_CSV_VOLUME_NOT_LOCALSTATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESSSTATUS_CLUSTER_CSV_AUTO_PAUSE_ERRORSTATUS_CLUSTER_CSV_REDIRECTEDSTATUS_CLUSTER_CSV_NOT_REDIRECTEDSTATUS_CLUSTER_CSV_VOLUME_DRAININGSTATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESSSTATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVELSTATUS_CLUSTER_CSV_NO_SNAPSHOTSSTATUS_CSV_IO_PAUSE_TIMEOUTSTATUS_CLUSTER_CSV_INVALID_HANDLESTATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATORSTATUS_TRANSACTIONAL_CONFLICTSTATUS_INVALID_TRANSACTIONSTATUS_TRANSACTION_NOT_ACTIVESTATUS_TM_INITIALIZATION_FAILEDSTATUS_RM_NOT_ACTIVESTATUS_RM_METADATA_CORRUPTSTATUS_TRANSACTION_NOT_JOINEDSTATUS_DIRECTORY_NOT_RMSTATUS_COULD_NOT_RESIZE_LOGSTATUS_TRANSACTIONS_UNSUPPORTED_REMOTESTATUS_LOG_RESIZE_INVALID_SIZESTATUS_REMOTE_FILE_VERSION_MISMATCHSTATUS_CRM_PROTOCOL_ALREADY_EXISTSSTATUS_TRANSACTION_PROPAGATION_FAILEDSTATUS_CRM_PROTOCOL_NOT_FOUNDSTATUS_TRANSACTION_SUPERIOR_EXISTSSTATUS_TRANSACTION_REQUEST_NOT_VALIDSTATUS_TRANSACTION_NOT_REQUESTEDSTATUS_TRANSACTION_ALREADY_ABORTEDSTATUS_TRANSACTION_ALREADY_COMMITTEDSTATUS_TRANSACTION_INVALID_MARSHALL_BUFFERSTATUS_CURRENT_TRANSACTION_NOT_VALIDSTATUS_LOG_GROWTH_FAILEDSTATUS_OBJECT_NO_LONGER_EXISTSSTATUS_STREAM_MINIVERSION_NOT_FOUNDSTATUS_STREAM_MINIVERSION_NOT_VALIDSTATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTIONSTATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENTSTATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONSSTATUS_HANDLE_NO_LONGER_VALIDSTATUS_NO_TXF_METADATASTATUS_LOG_CORRUPTION_DETECTEDSTATUS_CANT_RECOVER_WITH_HANDLE_OPENSTATUS_RM_DISCONNECTEDSTATUS_ENLISTMENT_NOT_SUPERIORSTATUS_RECOVERY_NOT_NEEDEDSTATUS_RM_ALREADY_STARTEDSTATUS_FILE_IDENTITY_NOT_PERSISTENTSTATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCYSTATUS_CANT_CROSS_RM_BOUNDARYSTATUS_TXF_DIR_NOT_EMPTYSTATUS_INDOUBT_TRANSACTIONS_EXISTSTATUS_TM_VOLATILESTATUS_ROLLBACK_TIMER_EXPIREDSTATUS_TXF_ATTRIBUTE_CORRUPTSTATUS_EFS_NOT_ALLOWED_IN_TRANSACTIONSTATUS_TRANSACTIONAL_OPEN_NOT_ALLOWEDSTATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTESTATUS_TXF_METADATA_ALREADY_PRESENTSTATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SETSTATUS_TRANSACTION_REQUIRED_PROMOTIONSTATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTIONSTATUS_TRANSACTIONS_NOT_FROZENSTATUS_TRANSACTION_FREEZE_IN_PROGRESSSTATUS_NOT_SNAPSHOT_VOLUMESTATUS_NO_SAVEPOINT_WITH_OPEN_FILESSTATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTIONSTATUS_TM_IDENTITY_MISMATCHSTATUS_FLOATED_SECTIONSTATUS_CANNOT_ACCEPT_TRANSACTED_WORKSTATUS_CANNOT_ABORT_TRANSACTIONSSTATUS_TRANSACTION_NOT_FOUNDSTATUS_RESOURCEMANAGER_NOT_FOUNDSTATUS_ENLISTMENT_NOT_FOUNDSTATUS_TRANSACTIONMANAGER_NOT_FOUNDSTATUS_TRANSACTIONMANAGER_NOT_ONLINESTATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISIONSTATUS_TRANSACTION_NOT_ROOTSTATUS_TRANSACTION_OBJECT_EXPIREDSTATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTIONSTATUS_TRANSACTION_RESPONSE_NOT_ENLISTEDSTATUS_TRANSACTION_RECORD_TOO_LONGSTATUS_NO_LINK_TRACKING_IN_TRANSACTIONSTATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTIONSTATUS_TRANSACTION_INTEGRITY_VIOLATEDSTATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCHSTATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOTSTATUS_TRANSACTION_MUST_WRITETHROUGHSTATUS_TRANSACTION_NO_SUPERIORSTATUS_EXPIRED_HANDLESTATUS_TRANSACTION_NOT_ENLISTEDSTATUS_LOG_SECTOR_INVALIDSTATUS_LOG_SECTOR_PARITY_INVALIDSTATUS_LOG_SECTOR_REMAPPEDSTATUS_LOG_BLOCK_INCOMPLETESTATUS_LOG_INVALID_RANGESTATUS_LOG_BLOCKS_EXHAUSTEDSTATUS_LOG_READ_CONTEXT_INVALIDSTATUS_LOG_RESTART_INVALIDSTATUS_LOG_BLOCK_VERSIONSTATUS_LOG_BLOCK_INVALIDSTATUS_LOG_READ_MODE_INVALIDSTATUS_LOG_NO_RESTARTSTATUS_LOG_METADATA_CORRUPTSTATUS_LOG_METADATA_INVALIDSTATUS_LOG_METADATA_INCONSISTENTSTATUS_LOG_RESERVATION_INVALIDSTATUS_LOG_CANT_DELETESTATUS_LOG_CONTAINER_LIMIT_EXCEEDEDSTATUS_LOG_START_OF_LOGSTATUS_LOG_POLICY_ALREADY_INSTALLEDSTATUS_LOG_POLICY_NOT_INSTALLEDSTATUS_LOG_POLICY_INVALIDSTATUS_LOG_POLICY_CONFLICTSTATUS_LOG_PINNED_ARCHIVE_TAILSTATUS_LOG_RECORD_NONEXISTENTSTATUS_LOG_RECORDS_RESERVED_INVALIDSTATUS_LOG_SPACE_RESERVED_INVALIDSTATUS_LOG_TAIL_INVALIDSTATUS_LOG_FULLSTATUS_LOG_MULTIPLEXEDSTATUS_LOG_DEDICATEDSTATUS_LOG_ARCHIVE_NOT_IN_PROGRESSSTATUS_LOG_ARCHIVE_IN_PROGRESSSTATUS_LOG_EPHEMERALSTATUS_LOG_NOT_ENOUGH_CONTAINERSSTATUS_LOG_CLIENT_ALREADY_REGISTEREDSTATUS_LOG_CLIENT_NOT_REGISTEREDSTATUS_LOG_FULL_HANDLER_IN_PROGRESSSTATUS_LOG_CONTAINER_READ_FAILEDSTATUS_LOG_CONTAINER_WRITE_FAILEDSTATUS_LOG_CONTAINER_OPEN_FAILEDSTATUS_LOG_CONTAINER_STATE_INVALIDSTATUS_LOG_STATE_INVALIDSTATUS_LOG_PINNEDSTATUS_LOG_METADATA_FLUSH_FAILEDSTATUS_LOG_INCONSISTENT_SECURITYSTATUS_LOG_APPENDED_FLUSH_FAILEDSTATUS_LOG_PINNED_RESERVATIONSTATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREADSTATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVEREDSTATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUESTSTATUS_MONITOR_NO_DESCRIPTORSTATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMATSTATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUMSTATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCKSTATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILEDSTATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCKSTATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCKSTATUS_MONITOR_NO_MORE_DESCRIPTOR_DATASTATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCKSTATUS_MONITOR_INVALID_MANUFACTURE_DATESTATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNERSTATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFERSTATUS_GRAPHICS_INVALID_DISPLAY_ADAPTERSTATUS_GRAPHICS_ADAPTER_WAS_RESETSTATUS_GRAPHICS_INVALID_DRIVER_MODELSTATUS_GRAPHICS_PRESENT_MODE_CHANGEDSTATUS_GRAPHICS_PRESENT_OCCLUDEDSTATUS_GRAPHICS_PRESENT_DENIEDSTATUS_GRAPHICS_CANNOTCOLORCONVERTSTATUS_GRAPHICS_DRIVER_MISMATCHSTATUS_GRAPHICS_PARTIAL_DATA_POPULATEDSTATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLEDSTATUS_GRAPHICS_PRESENT_UNOCCLUDEDSTATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLESTATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLEDSTATUS_GRAPHICS_NO_VIDEO_MEMORYSTATUS_GRAPHICS_CANT_LOCK_MEMORYSTATUS_GRAPHICS_ALLOCATION_BUSYSTATUS_GRAPHICS_TOO_MANY_REFERENCESSTATUS_GRAPHICS_TRY_AGAIN_LATERSTATUS_GRAPHICS_TRY_AGAIN_NOWSTATUS_GRAPHICS_ALLOCATION_INVALIDSTATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLESTATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTEDSTATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATIONSTATUS_GRAPHICS_INVALID_ALLOCATION_USAGESTATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATIONSTATUS_GRAPHICS_ALLOCATION_CLOSEDSTATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCESTATUS_GRAPHICS_INVALID_ALLOCATION_HANDLESTATUS_GRAPHICS_WRONG_ALLOCATION_DEVICESTATUS_GRAPHICS_ALLOCATION_CONTENT_LOSTSTATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICESTATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATIONSTATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGYSTATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTEDSTATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTEDSTATUS_GRAPHICS_INVALID_VIDPNSTATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCESTATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGETSTATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTEDSTATUS_GRAPHICS_MODE_NOT_PINNEDSTATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESETSTATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESETSTATUS_GRAPHICS_INVALID_FREQUENCYSTATUS_GRAPHICS_INVALID_ACTIVE_REGIONSTATUS_GRAPHICS_INVALID_TOTAL_REGIONSTATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODESTATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODESTATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SETSTATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGYSTATUS_GRAPHICS_MODE_ALREADY_IN_MODESETSTATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESETSTATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSETSTATUS_GRAPHICS_SOURCE_ALREADY_IN_SETSTATUS_GRAPHICS_TARGET_ALREADY_IN_SETSTATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATHSTATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGYSTATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESETSTATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESTATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SETSTATUS_GRAPHICS_NO_PREFERRED_MODESTATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SETSTATUS_GRAPHICS_STALE_MODESETSTATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESETSTATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODESTATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPNSTATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUESTATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTIONSTATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCESSTATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGYSTATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCESTATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGETSTATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSETSTATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSTATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SETSTATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SETSTATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUESTATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPESTATUS_GRAPHICS_RESOURCES_NOT_RELATEDSTATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUESTATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUESTATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGETSTATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTERSTATUS_GRAPHICS_NO_VIDPNMGRSTATUS_GRAPHICS_NO_ACTIVE_VIDPNSTATUS_GRAPHICS_STALE_VIDPN_TOPOLOGYSTATUS_GRAPHICS_MONITOR_NOT_CONNECTEDSTATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGYSTATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZESTATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZESTATUS_GRAPHICS_INVALID_STRIDESTATUS_GRAPHICS_INVALID_PIXELFORMATSTATUS_GRAPHICS_INVALID_COLORBASISSTATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODESTATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGYSTATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORTSTATUS_GRAPHICS_VIDPN_SOURCE_IN_USESTATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPNSTATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINALSTATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATIONSTATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTEDSTATUS_GRAPHICS_INVALID_GAMMA_RAMPSTATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTEDSTATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTEDSTATUS_GRAPHICS_MODE_NOT_IN_MODESETSTATUS_GRAPHICS_DATASET_IS_EMPTYSTATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASETSTATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASONSTATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPESTATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPESTATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTSSTATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNEDSTATUS_GRAPHICS_INVALID_SCANLINE_ORDERINGSTATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWEDSTATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALSSTATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMATSTATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHMSTATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGINSTATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINTSTATUS_GRAPHICS_MAX_NUM_PATHS_REACHEDSTATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATIONSTATUS_GRAPHICS_INVALID_CLIENT_TYPESTATUS_GRAPHICS_CLIENTVIDPN_NOT_SETSTATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTEDSTATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTEDSTATUS_GRAPHICS_UNKNOWN_CHILD_STATUSSTATUS_GRAPHICS_NOT_A_LINKED_ADAPTERSTATUS_GRAPHICS_LEADLINK_NOT_ENUMERATEDSTATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATEDSTATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READYSTATUS_GRAPHICS_CHAINLINKS_NOT_STARTEDSTATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ONSTATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATESTATUS_GRAPHICS_LEADLINK_START_DEFERREDSTATUS_GRAPHICS_NOT_POST_DEVICE_DRIVERSTATUS_GRAPHICS_POLLING_TOO_FREQUENTLYSTATUS_GRAPHICS_START_DEFERREDSTATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDEDSTATUS_GRAPHICS_DEPENDABLE_CHILD_STATUSSTATUS_GRAPHICS_OPM_NOT_SUPPORTEDSTATUS_GRAPHICS_COPP_NOT_SUPPORTEDSTATUS_GRAPHICS_UAB_NOT_SUPPORTEDSTATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERSSTATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXISTSTATUS_GRAPHICS_OPM_INTERNAL_ERRORSTATUS_GRAPHICS_OPM_INVALID_HANDLESTATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTHSTATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLEDSTATUS_GRAPHICS_OPM_THEATER_MODE_ENABLEDSTATUS_GRAPHICS_PVP_HFS_FAILEDSTATUS_GRAPHICS_OPM_INVALID_SRMSTATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCPSTATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACPSTATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSASTATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SETSTATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGHSTATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USESTATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTSSTATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICSSTATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUESTSTATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERRORSTATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICSSTATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTEDSTATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUESTSTATUS_GRAPHICS_I2C_NOT_SUPPORTEDSTATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXISTSTATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATASTATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATASTATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTEDSTATUS_GRAPHICS_DDCCI_INVALID_DATASTATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTESTATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRINGSTATUS_GRAPHICS_MCA_INTERNAL_ERRORSTATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMANDSTATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTHSTATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUMSTATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLESTATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTSSTATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTEDSTATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAMESTATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOPSTATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTEDSTATUS_GRAPHICS_INVALID_POINTERSTATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICESTATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALLSTATUS_GRAPHICS_INTERNAL_ERRORSTATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESSSTATUS_FVE_LOCKED_VOLUMESTATUS_FVE_NOT_ENCRYPTEDSTATUS_FVE_BAD_INFORMATIONSTATUS_FVE_TOO_SMALLSTATUS_FVE_FAILED_WRONG_FSSTATUS_FVE_BAD_PARTITION_SIZESTATUS_FVE_FS_NOT_EXTENDEDSTATUS_FVE_FS_MOUNTEDSTATUS_FVE_NO_LICENSESTATUS_FVE_ACTION_NOT_ALLOWEDSTATUS_FVE_BAD_DATASTATUS_FVE_VOLUME_NOT_BOUNDSTATUS_FVE_NOT_DATA_VOLUMESTATUS_FVE_CONV_READ_ERRORSTATUS_FVE_CONV_WRITE_ERRORSTATUS_FVE_OVERLAPPED_UPDATESTATUS_FVE_FAILED_SECTOR_SIZESTATUS_FVE_FAILED_AUTHENTICATIONSTATUS_FVE_NOT_OS_VOLUMESTATUS_FVE_KEYFILE_NOT_FOUNDSTATUS_FVE_KEYFILE_INVALIDSTATUS_FVE_KEYFILE_NO_VMKSTATUS_FVE_TPM_DISABLEDSTATUS_FVE_TPM_SRK_AUTH_NOT_ZEROSTATUS_FVE_TPM_INVALID_PCRSTATUS_FVE_TPM_NO_VMKSTATUS_FVE_PIN_INVALIDSTATUS_FVE_AUTH_INVALID_APPLICATIONSTATUS_FVE_AUTH_INVALID_CONFIGSTATUS_FVE_DEBUGGER_ENABLEDSTATUS_FVE_DRY_RUN_FAILEDSTATUS_FVE_BAD_METADATA_POINTERSTATUS_FVE_OLD_METADATA_COPYSTATUS_FVE_REBOOT_REQUIREDSTATUS_FVE_RAW_ACCESSSTATUS_FVE_RAW_BLOCKEDSTATUS_FVE_NO_AUTOUNLOCK_MASTER_KEYSTATUS_FVE_MOR_FAILEDSTATUS_FVE_NO_FEATURE_LICENSESTATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWEDSTATUS_FVE_CONV_RECOVERY_FAILEDSTATUS_FVE_VIRTUALIZED_SPACE_TOO_BIGSTATUS_FVE_INVALID_DATUM_TYPESTATUS_FVE_VOLUME_TOO_SMALLSTATUS_FVE_ENH_PIN_INVALIDSTATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGESTATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGESTATUS_FVE_NOT_ALLOWED_ON_CSV_STACKSTATUS_FVE_NOT_ALLOWED_ON_CLUSTERSTATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTINGSTATUS_FVE_WIPE_CANCEL_NOT_APPLICABLESTATUS_FVE_EDRIVE_DRY_RUN_FAILEDSTATUS_FVE_SECUREBOOT_DISABLEDSTATUS_FVE_SECUREBOOT_CONFIG_CHANGESTATUS_FVE_DEVICE_LOCKEDOUTSTATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPTSTATUS_FVE_NOT_DE_VOLUMESTATUS_FVE_PROTECTION_DISABLEDSTATUS_FVE_PROTECTION_CANNOT_BE_DISABLEDSTATUS_FWP_CALLOUT_NOT_FOUNDSTATUS_FWP_CONDITION_NOT_FOUNDSTATUS_FWP_FILTER_NOT_FOUNDSTATUS_FWP_LAYER_NOT_FOUNDSTATUS_FWP_PROVIDER_NOT_FOUNDSTATUS_FWP_PROVIDER_CONTEXT_NOT_FOUNDSTATUS_FWP_SUBLAYER_NOT_FOUNDSTATUS_FWP_NOT_FOUNDSTATUS_FWP_ALREADY_EXISTSSTATUS_FWP_IN_USESTATUS_FWP_DYNAMIC_SESSION_IN_PROGRESSSTATUS_FWP_WRONG_SESSIONSTATUS_FWP_NO_TXN_IN_PROGRESSSTATUS_FWP_TXN_IN_PROGRESSSTATUS_FWP_TXN_ABORTEDSTATUS_FWP_SESSION_ABORTEDSTATUS_FWP_INCOMPATIBLE_TXNSTATUS_FWP_TIMEOUTSTATUS_FWP_NET_EVENTS_DISABLEDSTATUS_FWP_INCOMPATIBLE_LAYERSTATUS_FWP_KM_CLIENTS_ONLYSTATUS_FWP_LIFETIME_MISMATCHSTATUS_FWP_BUILTIN_OBJECTSTATUS_FWP_TOO_MANY_CALLOUTSSTATUS_FWP_NOTIFICATION_DROPPEDSTATUS_FWP_TRAFFIC_MISMATCHSTATUS_FWP_INCOMPATIBLE_SA_STATESTATUS_FWP_NULL_POINTERSTATUS_FWP_INVALID_ENUMERATORSTATUS_FWP_INVALID_FLAGSSTATUS_FWP_INVALID_NET_MASKSTATUS_FWP_INVALID_RANGESTATUS_FWP_INVALID_INTERVALSTATUS_FWP_ZERO_LENGTH_ARRAYSTATUS_FWP_NULL_DISPLAY_NAMESTATUS_FWP_INVALID_ACTION_TYPESTATUS_FWP_INVALID_WEIGHTSTATUS_FWP_MATCH_TYPE_MISMATCHSTATUS_FWP_TYPE_MISMATCHSTATUS_FWP_OUT_OF_BOUNDSSTATUS_FWP_RESERVEDSTATUS_FWP_DUPLICATE_CONDITIONSTATUS_FWP_DUPLICATE_KEYMODSTATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYERSTATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYERSTATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYERSTATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUTSTATUS_FWP_INCOMPATIBLE_AUTH_METHODSTATUS_FWP_INCOMPATIBLE_DH_GROUPSTATUS_FWP_EM_NOT_SUPPORTEDSTATUS_FWP_NEVER_MATCHSTATUS_FWP_PROVIDER_CONTEXT_MISMATCHSTATUS_FWP_INVALID_PARAMETERSTATUS_FWP_TOO_MANY_SUBLAYERSSTATUS_FWP_CALLOUT_NOTIFICATION_FAILEDSTATUS_FWP_INVALID_AUTH_TRANSFORMSTATUS_FWP_INVALID_CIPHER_TRANSFORMSTATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORMSTATUS_FWP_INVALID_TRANSFORM_COMBINATIONSTATUS_FWP_DUPLICATE_AUTH_METHODSTATUS_FWP_INVALID_TUNNEL_ENDPOINTSTATUS_FWP_L2_DRIVER_NOT_READYSTATUS_FWP_KEY_DICTATOR_ALREADY_REGISTEREDSTATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIALSTATUS_FWP_CONNECTIONS_DISABLEDSTATUS_FWP_INVALID_DNS_NAMESTATUS_FWP_STILL_ONSTATUS_FWP_IKEEXT_NOT_RUNNINGSTATUS_FWP_TCPIP_NOT_READYSTATUS_FWP_INJECT_HANDLE_CLOSINGSTATUS_FWP_INJECT_HANDLE_STALESTATUS_FWP_CANNOT_PENDSTATUS_FWP_DROP_NOICMPSTATUS_NDIS_CLOSINGSTATUS_NDIS_BAD_VERSIONSTATUS_NDIS_BAD_CHARACTERISTICSSTATUS_NDIS_ADAPTER_NOT_FOUNDSTATUS_NDIS_OPEN_FAILEDSTATUS_NDIS_DEVICE_FAILEDSTATUS_NDIS_MULTICAST_FULLSTATUS_NDIS_MULTICAST_EXISTSSTATUS_NDIS_MULTICAST_NOT_FOUNDSTATUS_NDIS_REQUEST_ABORTEDSTATUS_NDIS_RESET_IN_PROGRESSSTATUS_NDIS_NOT_SUPPORTEDSTATUS_NDIS_INVALID_PACKETSTATUS_NDIS_ADAPTER_NOT_READYSTATUS_NDIS_INVALID_LENGTHSTATUS_NDIS_INVALID_DATASTATUS_NDIS_BUFFER_TOO_SHORTSTATUS_NDIS_INVALID_OIDSTATUS_NDIS_ADAPTER_REMOVEDSTATUS_NDIS_UNSUPPORTED_MEDIASTATUS_NDIS_GROUP_ADDRESS_IN_USESTATUS_NDIS_FILE_NOT_FOUNDSTATUS_NDIS_ERROR_READING_FILESTATUS_NDIS_ALREADY_MAPPEDSTATUS_NDIS_RESOURCE_CONFLICTSTATUS_NDIS_MEDIA_DISCONNECTEDSTATUS_NDIS_INVALID_ADDRESSSTATUS_NDIS_INVALID_DEVICE_REQUESTSTATUS_NDIS_PAUSEDSTATUS_NDIS_INTERFACE_NOT_FOUNDSTATUS_NDIS_UNSUPPORTED_REVISIONSTATUS_NDIS_INVALID_PORTSTATUS_NDIS_INVALID_PORT_STATESTATUS_NDIS_LOW_POWER_STATESTATUS_NDIS_REINIT_REQUIREDSTATUS_NDIS_DOT11_AUTO_CONFIG_ENABLEDSTATUS_NDIS_DOT11_MEDIA_IN_USESTATUS_NDIS_DOT11_POWER_STATE_INVALIDSTATUS_NDIS_PM_WOL_PATTERN_LIST_FULLSTATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULLSTATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLESTATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLESTATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWEDSTATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWEDSTATUS_NDIS_INDICATION_REQUIREDSTATUS_NDIS_OFFLOAD_POLICYSTATUS_NDIS_OFFLOAD_CONNECTION_REJECTEDSTATUS_NDIS_OFFLOAD_PATH_REJECTEDSTATUS_TPM_ERROR_MASKSTATUS_TPM_AUTHFAILSTATUS_TPM_BADINDEXSTATUS_TPM_BAD_PARAMETERSTATUS_TPM_AUDITFAILURESTATUS_TPM_CLEAR_DISABLEDSTATUS_TPM_DEACTIVATEDSTATUS_TPM_DISABLEDSTATUS_TPM_DISABLED_CMDSTATUS_TPM_FAILSTATUS_TPM_BAD_ORDINALSTATUS_TPM_INSTALL_DISABLEDSTATUS_TPM_INVALID_KEYHANDLESTATUS_TPM_KEYNOTFOUNDSTATUS_TPM_INAPPROPRIATE_ENCSTATUS_TPM_MIGRATEFAILSTATUS_TPM_INVALID_PCR_INFOSTATUS_TPM_NOSPACESTATUS_TPM_NOSRKSTATUS_TPM_NOTSEALED_BLOBSTATUS_TPM_OWNER_SETSTATUS_TPM_RESOURCESSTATUS_TPM_SHORTRANDOMSTATUS_TPM_SIZESTATUS_TPM_WRONGPCRVALSTATUS_TPM_BAD_PARAM_SIZESTATUS_TPM_SHA_THREADSTATUS_TPM_SHA_ERRORSTATUS_TPM_FAILEDSELFTESTSTATUS_TPM_AUTH2FAILSTATUS_TPM_BADTAGSTATUS_TPM_IOERRORSTATUS_TPM_ENCRYPT_ERRORSTATUS_TPM_DECRYPT_ERRORSTATUS_TPM_INVALID_AUTHHANDLESTATUS_TPM_NO_ENDORSEMENTSTATUS_TPM_INVALID_KEYUSAGESTATUS_TPM_WRONG_ENTITYTYPESTATUS_TPM_INVALID_POSTINITSTATUS_TPM_INAPPROPRIATE_SIGSTATUS_TPM_BAD_KEY_PROPERTYSTATUS_TPM_BAD_MIGRATIONSTATUS_TPM_BAD_SCHEMESTATUS_TPM_BAD_DATASIZESTATUS_TPM_BAD_MODESTATUS_TPM_BAD_PRESENCESTATUS_TPM_BAD_VERSIONSTATUS_TPM_NO_WRAP_TRANSPORTSTATUS_TPM_AUDITFAIL_UNSUCCESSFULSTATUS_TPM_AUDITFAIL_SUCCESSFULSTATUS_TPM_NOTRESETABLESTATUS_TPM_NOTLOCALSTATUS_TPM_BAD_TYPESTATUS_TPM_INVALID_RESOURCESTATUS_TPM_NOTFIPSSTATUS_TPM_INVALID_FAMILYSTATUS_TPM_NO_NV_PERMISSIONSTATUS_TPM_REQUIRES_SIGNSTATUS_TPM_KEY_NOTSUPPORTEDSTATUS_TPM_AUTH_CONFLICTSTATUS_TPM_AREA_LOCKEDSTATUS_TPM_BAD_LOCALITYSTATUS_TPM_READ_ONLYSTATUS_TPM_PER_NOWRITESTATUS_TPM_FAMILYCOUNTSTATUS_TPM_WRITE_LOCKEDSTATUS_TPM_BAD_ATTRIBUTESSTATUS_TPM_INVALID_STRUCTURESTATUS_TPM_KEY_OWNER_CONTROLSTATUS_TPM_BAD_COUNTERSTATUS_TPM_NOT_FULLWRITESTATUS_TPM_CONTEXT_GAPSTATUS_TPM_MAXNVWRITESSTATUS_TPM_NOOPERATORSTATUS_TPM_RESOURCEMISSINGSTATUS_TPM_DELEGATE_LOCKSTATUS_TPM_DELEGATE_FAMILYSTATUS_TPM_DELEGATE_ADMINSTATUS_TPM_TRANSPORT_NOTEXCLUSIVESTATUS_TPM_OWNER_CONTROLSTATUS_TPM_DAA_RESOURCESSTATUS_TPM_DAA_INPUT_DATA0STATUS_TPM_DAA_INPUT_DATA1STATUS_TPM_DAA_ISSUER_SETTINGSSTATUS_TPM_DAA_TPM_SETTINGSSTATUS_TPM_DAA_STAGESTATUS_TPM_DAA_ISSUER_VALIDITYSTATUS_TPM_DAA_WRONG_WSTATUS_TPM_BAD_HANDLESTATUS_TPM_BAD_DELEGATESTATUS_TPM_BADCONTEXTSTATUS_TPM_TOOMANYCONTEXTSSTATUS_TPM_MA_TICKET_SIGNATURESTATUS_TPM_MA_DESTINATIONSTATUS_TPM_MA_SOURCESTATUS_TPM_MA_AUTHORITYSTATUS_TPM_PERMANENTEKSTATUS_TPM_BAD_SIGNATURESTATUS_TPM_NOCONTEXTSPACESTATUS_TPM_COMMAND_BLOCKEDSTATUS_TPM_INVALID_HANDLESTATUS_TPM_DUPLICATE_VHANDLESTATUS_TPM_EMBEDDED_COMMAND_BLOCKEDSTATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTEDSTATUS_TPM_RETRYSTATUS_TPM_NEEDS_SELFTESTSTATUS_TPM_DOING_SELFTESTSTATUS_TPM_DEFEND_LOCK_RUNNINGSTATUS_TPM_COMMAND_CANCELEDSTATUS_TPM_TOO_MANY_CONTEXTSSTATUS_TPM_NOT_FOUNDSTATUS_TPM_ACCESS_DENIEDSTATUS_TPM_INSUFFICIENT_BUFFERSTATUS_TPM_PPI_FUNCTION_UNSUPPORTEDSTATUS_PCP_ERROR_MASKSTATUS_PCP_DEVICE_NOT_READYSTATUS_PCP_INVALID_HANDLESTATUS_PCP_INVALID_PARAMETERSTATUS_PCP_FLAG_NOT_SUPPORTEDSTATUS_PCP_NOT_SUPPORTEDSTATUS_PCP_BUFFER_TOO_SMALLSTATUS_PCP_INTERNAL_ERRORSTATUS_PCP_AUTHENTICATION_FAILEDSTATUS_PCP_AUTHENTICATION_IGNOREDSTATUS_PCP_POLICY_NOT_FOUNDSTATUS_PCP_PROFILE_NOT_FOUNDSTATUS_PCP_VALIDATION_FAILEDSTATUS_PCP_DEVICE_NOT_FOUNDSTATUS_RTPM_CONTEXT_CONTINUESTATUS_RTPM_CONTEXT_COMPLETESTATUS_RTPM_NO_RESULTSTATUS_RTPM_PCR_READ_INCOMPLETESTATUS_RTPM_INVALID_CONTEXTSTATUS_RTPM_UNSUPPORTED_CMDSTATUS_HV_INVALID_HYPERCALL_CODESTATUS_HV_INVALID_HYPERCALL_INPUTSTATUS_HV_INVALID_ALIGNMENTSTATUS_HV_INVALID_PARAMETERSTATUS_HV_ACCESS_DENIEDSTATUS_HV_INVALID_PARTITION_STATESTATUS_HV_OPERATION_DENIEDSTATUS_HV_UNKNOWN_PROPERTYSTATUS_HV_PROPERTY_VALUE_OUT_OF_RANGESTATUS_HV_INSUFFICIENT_MEMORYSTATUS_HV_PARTITION_TOO_DEEPSTATUS_HV_INVALID_PARTITION_IDSTATUS_HV_INVALID_VP_INDEXSTATUS_HV_INVALID_PORT_IDSTATUS_HV_INVALID_CONNECTION_IDSTATUS_HV_INSUFFICIENT_BUFFERSSTATUS_HV_NOT_ACKNOWLEDGEDSTATUS_HV_INVALID_VP_STATESTATUS_HV_ACKNOWLEDGEDSTATUS_HV_INVALID_SAVE_RESTORE_STATESTATUS_HV_INVALID_SYNIC_STATESTATUS_HV_OBJECT_IN_USESTATUS_HV_INVALID_PROXIMITY_DOMAIN_INFOSTATUS_HV_NO_DATASTATUS_HV_INACTIVESTATUS_HV_NO_RESOURCESSTATUS_HV_FEATURE_UNAVAILABLESTATUS_HV_INSUFFICIENT_BUFFERSTATUS_HV_INSUFFICIENT_DEVICE_DOMAINSSTATUS_HV_CPUID_FEATURE_VALIDATION_ERRORSTATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERRORSTATUS_HV_PROCESSOR_STARTUP_TIMEOUTSTATUS_HV_SMX_ENABLEDSTATUS_HV_INVALID_LP_INDEXSTATUS_HV_INVALID_REGISTER_VALUESTATUS_HV_INVALID_VTL_STATESTATUS_HV_NX_NOT_DETECTEDSTATUS_HV_INVALID_DEVICE_IDSTATUS_HV_INVALID_DEVICE_STATESTATUS_HV_PENDING_PAGE_REQUESTSSTATUS_HV_PAGE_REQUEST_INVALIDSTATUS_HV_INVALID_CPU_GROUP_IDSTATUS_HV_INVALID_CPU_GROUP_STATESTATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVESTATUS_HV_NOT_PRESENTSTATUS_VID_DUPLICATE_HANDLERSTATUS_VID_TOO_MANY_HANDLERSSTATUS_VID_QUEUE_FULLSTATUS_VID_HANDLER_NOT_PRESENTSTATUS_VID_INVALID_OBJECT_NAMESTATUS_VID_PARTITION_NAME_TOO_LONGSTATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONGSTATUS_VID_PARTITION_ALREADY_EXISTSSTATUS_VID_PARTITION_DOES_NOT_EXISTSTATUS_VID_PARTITION_NAME_NOT_FOUNDSTATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTSSTATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMITSTATUS_VID_MB_STILL_REFERENCEDSTATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTEDSTATUS_VID_INVALID_NUMA_SETTINGSSTATUS_VID_INVALID_NUMA_NODE_INDEXSTATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATEDSTATUS_VID_INVALID_MEMORY_BLOCK_HANDLESTATUS_VID_PAGE_RANGE_OVERFLOWSTATUS_VID_INVALID_MESSAGE_QUEUE_HANDLESTATUS_VID_INVALID_GPA_RANGE_HANDLESTATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUESTATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDEDSTATUS_VID_INVALID_PPM_HANDLESTATUS_VID_MBPS_ARE_LOCKEDSTATUS_VID_MESSAGE_QUEUE_CLOSEDSTATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDEDSTATUS_VID_STOP_PENDINGSTATUS_VID_INVALID_PROCESSOR_STATESTATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMITSTATUS_VID_KM_INTERFACE_ALREADY_INITIALIZEDSTATUS_VID_MB_PROPERTY_ALREADY_SET_RESETSTATUS_VID_MMIO_RANGE_DESTROYEDSTATUS_VID_INVALID_CHILD_GPA_PAGE_SETSTATUS_VID_RESERVE_PAGE_SET_IS_BEING_USEDSTATUS_VID_RESERVE_PAGE_SET_TOO_SMALLSTATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGESTATUS_VID_MBP_COUNT_EXCEEDED_LIMITSTATUS_VID_SAVED_STATE_CORRUPTSTATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEMSTATUS_VID_SAVED_STATE_INCOMPATIBLESTATUS_VID_VTL_ACCESS_DENIEDSTATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USEDSTATUS_IPSEC_BAD_SPISTATUS_IPSEC_SA_LIFETIME_EXPIREDSTATUS_IPSEC_WRONG_SASTATUS_IPSEC_REPLAY_CHECK_FAILEDSTATUS_IPSEC_INVALID_PACKETSTATUS_IPSEC_INTEGRITY_CHECK_FAILEDSTATUS_IPSEC_CLEAR_TEXT_DROPSTATUS_IPSEC_AUTH_FIREWALL_DROPSTATUS_IPSEC_THROTTLE_DROPSTATUS_IPSEC_DOSP_BLOCKSTATUS_IPSEC_DOSP_RECEIVED_MULTICASTSTATUS_IPSEC_DOSP_INVALID_PACKETSTATUS_IPSEC_DOSP_STATE_LOOKUP_FAILEDSTATUS_IPSEC_DOSP_MAX_ENTRIESSTATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWEDSTATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUESSTATUS_VOLMGR_INCOMPLETE_REGENERATIONSTATUS_VOLMGR_INCOMPLETE_DISK_MIGRATIONSTATUS_VOLMGR_DATABASE_FULLSTATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTEDSTATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNCSTATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILEDSTATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUMESTATUS_VOLMGR_DISK_DUPLICATESTATUS_VOLMGR_DISK_DYNAMICSTATUS_VOLMGR_DISK_ID_INVALIDSTATUS_VOLMGR_DISK_INVALIDSTATUS_VOLMGR_DISK_LAST_VOTERSTATUS_VOLMGR_DISK_LAYOUT_INVALIDSTATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONSSTATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNEDSTATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALLSTATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONSSTATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONSSTATUS_VOLMGR_DISK_MISSINGSTATUS_VOLMGR_DISK_NOT_EMPTYSTATUS_VOLMGR_DISK_NOT_ENOUGH_SPACESTATUS_VOLMGR_DISK_REVECTORING_FAILEDSTATUS_VOLMGR_DISK_SECTOR_SIZE_INVALIDSTATUS_VOLMGR_DISK_SET_NOT_CONTAINEDSTATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERSSTATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXESSTATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTEDSTATUS_VOLMGR_EXTENT_ALREADY_USEDSTATUS_VOLMGR_EXTENT_NOT_CONTIGUOUSSTATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGIONSTATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNEDSTATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITIONSTATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCHSTATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTEDSTATUS_VOLMGR_INTERLEAVE_LENGTH_INVALIDSTATUS_VOLMGR_MAXIMUM_REGISTERED_USERSSTATUS_VOLMGR_MEMBER_IN_SYNCSTATUS_VOLMGR_MEMBER_INDEX_DUPLICATESTATUS_VOLMGR_MEMBER_INDEX_INVALIDSTATUS_VOLMGR_MEMBER_MISSINGSTATUS_VOLMGR_MEMBER_NOT_DETACHEDSTATUS_VOLMGR_MEMBER_REGENERATINGSTATUS_VOLMGR_ALL_DISKS_FAILEDSTATUS_VOLMGR_NO_REGISTERED_USERSSTATUS_VOLMGR_NO_SUCH_USERSTATUS_VOLMGR_NOTIFICATION_RESETSTATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALIDSTATUS_VOLMGR_NUMBER_OF_PLEXES_INVALIDSTATUS_VOLMGR_PACK_DUPLICATESTATUS_VOLMGR_PACK_ID_INVALIDSTATUS_VOLMGR_PACK_INVALIDSTATUS_VOLMGR_PACK_NAME_INVALIDSTATUS_VOLMGR_PACK_OFFLINESTATUS_VOLMGR_PACK_HAS_QUORUMSTATUS_VOLMGR_PACK_WITHOUT_QUORUMSTATUS_VOLMGR_PARTITION_STYLE_INVALIDSTATUS_VOLMGR_PARTITION_UPDATE_FAILEDSTATUS_VOLMGR_PLEX_IN_SYNCSTATUS_VOLMGR_PLEX_INDEX_DUPLICATESTATUS_VOLMGR_PLEX_INDEX_INVALIDSTATUS_VOLMGR_PLEX_LAST_ACTIVESTATUS_VOLMGR_PLEX_MISSINGSTATUS_VOLMGR_PLEX_REGENERATINGSTATUS_VOLMGR_PLEX_TYPE_INVALIDSTATUS_VOLMGR_PLEX_NOT_RAID5STATUS_VOLMGR_PLEX_NOT_SIMPLESTATUS_VOLMGR_STRUCTURE_SIZE_INVALIDSTATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTSSTATUS_VOLMGR_TRANSACTION_IN_PROGRESSSTATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGESTATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISKSTATUS_VOLMGR_VOLUME_ID_INVALIDSTATUS_VOLMGR_VOLUME_LENGTH_INVALIDSTATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLESTATUS_VOLMGR_VOLUME_NOT_MIRROREDSTATUS_VOLMGR_VOLUME_NOT_RETAINEDSTATUS_VOLMGR_VOLUME_OFFLINESTATUS_VOLMGR_VOLUME_RETAINEDSTATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALIDSTATUS_VOLMGR_DIFFERENT_SECTOR_SIZESTATUS_VOLMGR_BAD_BOOT_DISKSTATUS_VOLMGR_PACK_CONFIG_OFFLINESTATUS_VOLMGR_PACK_CONFIG_ONLINESTATUS_VOLMGR_NOT_PRIMARY_PACKSTATUS_VOLMGR_PACK_LOG_UPDATE_FAILEDSTATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALIDSTATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALIDSTATUS_VOLMGR_VOLUME_MIRROREDSTATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNEDSTATUS_VOLMGR_NO_VALID_LOG_COPIESSTATUS_VOLMGR_PRIMARY_PACK_PRESENTSTATUS_VOLMGR_NUMBER_OF_DISKS_INVALIDSTATUS_VOLMGR_MIRROR_NOT_SUPPORTEDSTATUS_VOLMGR_RAID5_NOT_SUPPORTEDSTATUS_BCD_NOT_ALL_ENTRIES_IMPORTEDSTATUS_BCD_TOO_MANY_ELEMENTSSTATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZEDSTATUS_VHD_DRIVE_FOOTER_MISSINGSTATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCHSTATUS_VHD_DRIVE_FOOTER_CORRUPTSTATUS_VHD_FORMAT_UNKNOWNSTATUS_VHD_FORMAT_UNSUPPORTED_VERSIONSTATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCHSTATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSIONSTATUS_VHD_SPARSE_HEADER_CORRUPTSTATUS_VHD_BLOCK_ALLOCATION_FAILURESTATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPTSTATUS_VHD_INVALID_BLOCK_SIZESTATUS_VHD_BITMAP_MISMATCHSTATUS_VHD_PARENT_VHD_NOT_FOUNDSTATUS_VHD_CHILD_PARENT_ID_MISMATCHSTATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCHSTATUS_VHD_METADATA_READ_FAILURESTATUS_VHD_METADATA_WRITE_FAILURESTATUS_VHD_INVALID_SIZESTATUS_VHD_INVALID_FILE_SIZESTATUS_VIRTDISK_PROVIDER_NOT_FOUNDSTATUS_VIRTDISK_NOT_VIRTUAL_DISKSTATUS_VHD_PARENT_VHD_ACCESS_DENIEDSTATUS_VHD_CHILD_PARENT_SIZE_MISMATCHSTATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTEDSTATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENTSTATUS_VIRTUAL_DISK_LIMITATIONSTATUS_VHD_INVALID_TYPESTATUS_VHD_INVALID_STATESTATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZESTATUS_VIRTDISK_DISK_ALREADY_OWNEDSTATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLESTATUS_CTLOG_TRACKING_NOT_INITIALIZEDSTATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZESTATUS_CTLOG_VHD_CHANGED_OFFLINESTATUS_CTLOG_INVALID_TRACKING_STATESTATUS_CTLOG_INCONSISTENT_TRACKING_FILESTATUS_VHD_METADATA_FULLSTATUS_VHD_INVALID_CHANGE_TRACKING_IDSTATUS_VHD_CHANGE_TRACKING_DISABLEDSTATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATIONSTATUS_VHD_RESIZE_WOULD_TRUNCATE_DATASTATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZESTATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZESTATUS_QUERY_STORAGE_ERRORSTATUS_RKF_KEY_NOT_FOUNDSTATUS_RKF_DUPLICATE_KEYSTATUS_RKF_BLOB_FULLSTATUS_RKF_STORE_FULLSTATUS_RKF_FILE_BLOCKEDSTATUS_RKF_ACTIVE_KEYSTATUS_RDBSS_RESTART_OPERATIONSTATUS_RDBSS_CONTINUE_OPERATIONSTATUS_RDBSS_POST_OPERATIONSTATUS_BTH_ATT_INVALID_HANDLESTATUS_BTH_ATT_READ_NOT_PERMITTEDSTATUS_BTH_ATT_WRITE_NOT_PERMITTEDSTATUS_BTH_ATT_INVALID_PDUSTATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATIONSTATUS_BTH_ATT_REQUEST_NOT_SUPPORTEDSTATUS_BTH_ATT_INVALID_OFFSETSTATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATIONSTATUS_BTH_ATT_PREPARE_QUEUE_FULLSTATUS_BTH_ATT_ATTRIBUTE_NOT_FOUNDSTATUS_BTH_ATT_ATTRIBUTE_NOT_LONGSTATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZESTATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTHSTATUS_BTH_ATT_UNLIKELYSTATUS_BTH_ATT_INSUFFICIENT_ENCRYPTIONSTATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPESTATUS_BTH_ATT_INSUFFICIENT_RESOURCESSTATUS_BTH_ATT_UNKNOWN_ERRORSTATUS_SECUREBOOT_ROLLBACK_DETECTEDSTATUS_SECUREBOOT_POLICY_VIOLATIONSTATUS_SECUREBOOT_INVALID_POLICYSTATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUNDSTATUS_SECUREBOOT_POLICY_NOT_SIGNEDSTATUS_SECUREBOOT_NOT_ENABLEDSTATUS_SECUREBOOT_FILE_REPLACEDSTATUS_SECUREBOOT_POLICY_NOT_AUTHORIZEDSTATUS_SECUREBOOT_POLICY_UNKNOWNSTATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSIONSTATUS_SECUREBOOT_PLATFORM_ID_MISMATCHSTATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTEDSTATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCHSTATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSINGSTATUS_SECUREBOOT_NOT_BASE_POLICYSTATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICYSTATUS_PLATFORM_MANIFEST_NOT_AUTHORIZEDSTATUS_PLATFORM_MANIFEST_INVALIDSTATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZEDSTATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZEDSTATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUNDSTATUS_PLATFORM_MANIFEST_NOT_ACTIVESTATUS_PLATFORM_MANIFEST_NOT_SIGNEDSTATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTEDSTATUS_SYSTEM_INTEGRITY_POLICY_VIOLATIONSTATUS_SYSTEM_INTEGRITY_INVALID_POLICYSTATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNEDSTATUS_NO_APPLICABLE_APP_LICENSES_FOUNDSTATUS_CLIP_LICENSE_NOT_FOUNDSTATUS_CLIP_DEVICE_LICENSE_MISSINGSTATUS_CLIP_LICENSE_INVALID_SIGNATURESTATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALIDSTATUS_CLIP_LICENSE_EXPIREDSTATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCESTATUS_CLIP_LICENSE_NOT_SIGNEDSTATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCESTATUS_CLIP_LICENSE_DEVICE_ID_MISMATCHSTATUS_AUDIO_ENGINE_NODE_NOT_FOUNDSTATUS_HDAUDIO_EMPTY_CONNECTION_LISTSTATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTEDSTATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATEDSTATUS_HDAUDIO_NULL_LINKED_LIST_ENTRYSTATUS_SPACES_REPAIREDSTATUS_SPACES_PAUSESTATUS_SPACES_COMPLETESTATUS_SPACES_FAULT_DOMAIN_TYPE_INVALIDSTATUS_SPACES_RESILIENCY_TYPE_INVALIDSTATUS_SPACES_DRIVE_SECTOR_SIZE_INVALIDSTATUS_SPACES_DRIVE_REDUNDANCY_INVALIDSTATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALIDSTATUS_SPACES_INTERLEAVE_LENGTH_INVALIDSTATUS_SPACES_NUMBER_OF_COLUMNS_INVALIDSTATUS_SPACES_NOT_ENOUGH_DRIVESSTATUS_SPACES_EXTENDED_ERRORSTATUS_SPACES_PROVISIONING_TYPE_INVALIDSTATUS_SPACES_ALLOCATION_SIZE_INVALIDSTATUS_SPACES_ENCLOSURE_AWARE_INVALIDSTATUS_SPACES_WRITE_CACHE_SIZE_INVALIDSTATUS_SPACES_NUMBER_OF_GROUPS_INVALIDSTATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALIDSTATUS_SPACES_UPDATE_COLUMN_STATESTATUS_SPACES_MAP_REQUIREDSTATUS_SPACES_UNSUPPORTED_VERSIONSTATUS_SPACES_CORRUPT_METADATASTATUS_SPACES_DRT_FULLSTATUS_SPACES_INCONSISTENCYSTATUS_SPACES_LOG_NOT_READYSTATUS_SPACES_NO_REDUNDANCYSTATUS_SPACES_DRIVE_NOT_READYSTATUS_SPACES_DRIVE_SPLITSTATUS_SPACES_DRIVE_LOST_DATASTATUS_VOLSNAP_BOOTFILE_NOT_VALIDSTATUS_VOLSNAP_ACTIVATION_TIMEOUTSTATUS_IO_PREEMPTEDSTATUS_SVHDX_ERROR_STOREDSTATUS_SVHDX_ERROR_NOT_AVAILABLESTATUS_SVHDX_UNIT_ATTENTION_AVAILABLESTATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGEDSTATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTEDSTATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASEDSTATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTEDSTATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGEDSTATUS_SVHDX_RESERVATION_CONFLICTSTATUS_SVHDX_WRONG_FILE_TYPESTATUS_SVHDX_VERSION_MISMATCHSTATUS_VHD_SHAREDSTATUS_SVHDX_NO_INITIATORSTATUS_VHDSET_BACKING_STORAGE_NOT_FOUNDSTATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAPSTATUS_SMB_BAD_CLUSTER_DIALECTSTATUS_SMB_GUEST_LOGON_BLOCKEDSTATUS_SECCORE_INVALID_COMMANDSTATUS_VSM_NOT_INITIALIZEDSTATUS_VSM_DMA_PROTECTION_NOT_IN_USE//! Constant definitions for the NTSTATUS values.SERVICETYPEPFLOWSPECFLOWSPECLPFLOWSPEC//! QoS definitions for NDIS components.I_RPC_HANDLERPC_STATUS//! Master include file for RPC applications.RPC_CSTRRPC_WSTRRPC_CWSTRRPC_BINDING_HANDLEhandle_trpc_binding_handle_tUUIDrpc_binding_vector_tRPC_BINDING_VECTORuuid_vector_tUUID_VECTORRPC_IF_HANDLERPC_C_BINDING_INFINITE_TIMEOUTRPC_C_BINDING_MIN_TIMEOUTRPC_C_BINDING_DEFAULT_TIMEOUTRPC_C_BINDING_MAX_TIMEOUTRPC_C_CANCEL_INFINITE_TIMEOUTRPC_C_LISTEN_MAX_CALLS_DEFAULTRPC_C_PROTSEQ_MAX_REQS_DEFAULTRPC_C_BIND_TO_ALL_NICSRPC_C_USE_INTERNET_PORTRPC_C_USE_INTRANET_PORTRPC_C_DONT_FAILRPC_C_RPCHTTP_USE_LOAD_BALANCERPC_C_MQ_TEMPORARYRPC_C_MQ_PERMANENTRPC_C_MQ_CLEAR_ON_OPENRPC_C_MQ_USE_EXISTING_SECURITYRPC_C_MQ_AUTHN_LEVEL_NONERPC_C_MQ_AUTHN_LEVEL_PKT_INTEGRITYRPC_C_MQ_AUTHN_LEVEL_PKT_PRIVACYRPC_C_OPT_MQ_DELIVERYRPC_C_OPT_MQ_PRIORITYRPC_C_OPT_MQ_JOURNALRPC_C_OPT_MQ_ACKNOWLEDGERPC_C_OPT_MQ_AUTHN_SERVICERPC_C_OPT_MQ_AUTHN_LEVELRPC_C_OPT_MQ_TIME_TO_REACH_QUEUERPC_C_OPT_MQ_TIME_TO_BE_RECEIVEDRPC_C_OPT_BINDING_NONCAUSALRPC_C_OPT_SECURITY_CALLBACKRPC_C_OPT_UNIQUE_BINDINGRPC_C_OPT_CALL_TIMEOUTRPC_C_OPT_DONT_LINGERRPC_C_OPT_TRUST_PEERRPC_C_OPT_ASYNC_BLOCKRPC_C_OPT_OPTIMIZE_TIMERPC_C_OPT_MAX_OPTIONSRPC_C_MQ_EXPRESSRPC_C_MQ_RECOVERABLERPC_C_MQ_JOURNAL_NONERPC_C_MQ_JOURNAL_DEADLETTERRPC_C_MQ_JOURNAL_ALWAYSRPC_C_FULL_CERT_CHAINPRPC_POLICYRPC_POLICYRPC_MGR_EPVRPC_C_STATS_CALLS_INRPC_C_STATS_CALLS_OUTRPC_C_STATS_PKTS_INRPC_C_STATS_PKTS_OUTRPC_AUTH_IDENTITY_HANDLERPC_AUTHZ_HANDLERPC_C_AUTHN_LEVEL_NONERPC_C_AUTHN_LEVEL_CONNECTRPC_C_AUTHN_LEVEL_PKTRPC_C_AUTHN_LEVEL_PKT_INTEGRITYRPC_C_AUTHN_LEVEL_PKT_PRIVACYRPC_C_IMP_LEVEL_DEFAULTRPC_C_IMP_LEVEL_ANONYMOUSRPC_C_IMP_LEVEL_IDENTIFYRPC_C_IMP_LEVEL_DELEGATERPC_C_QOS_IDENTITY_STATICRPC_C_QOS_IDENTITY_DYNAMICRPC_C_QOS_CAPABILITIES_DEFAULTRPC_C_QOS_CAPABILITIES_MUTUAL_AUTHRPC_C_QOS_CAPABILITIES_MAKE_FULLSICRPC_C_QOS_CAPABILITIES_ANY_AUTHORITYRPC_C_QOS_CAPABILITIES_IGNORE_DELEGATE_FAILURERPC_C_QOS_CAPABILITIES_LOCAL_MA_HINTRPC_C_QOS_CAPABILITIES_SCHANNEL_FULL_AUTH_IDENTITYRPC_C_PROTECT_LEVEL_DEFAULTRPC_C_PROTECT_LEVEL_NONERPC_C_PROTECT_LEVEL_CONNECTRPC_C_PROTECT_LEVEL_CALLRPC_C_PROTECT_LEVEL_PKTRPC_C_PROTECT_LEVEL_PKT_INTEGRITYRPC_C_PROTECT_LEVEL_PKT_PRIVACYRPC_C_AUTHN_NONERPC_C_AUTHN_DCE_PRIVATERPC_C_AUTHN_DCE_PUBLICRPC_C_AUTHN_DEC_PUBLICRPC_C_AUTHN_GSS_NEGOTIATERPC_C_AUTHN_GSS_SCHANNELRPC_C_AUTHN_GSS_KERBEROSRPC_C_AUTHN_DPARPC_C_AUTHN_MSNRPC_C_AUTHN_DIGESTRPC_C_AUTHN_KERNELRPC_C_AUTHN_NEGO_EXTENDERRPC_C_AUTHN_PKU2URPC_C_AUTHN_LIVE_SSPRPC_C_AUTHN_LIVEXP_SSPRPC_C_AUTHN_MSONLINERPC_C_AUTHN_MQRPC_C_AUTHN_DEFAULTRPC_C_NO_CREDENTIALSRPC_C_SECURITY_QOS_VERSIONRPC_C_SECURITY_QOS_VERSION_1PRPC_SECURITY_QOSRPC_SECURITY_QOSPSEC_WINNT_AUTH_IDENTITY_WSEC_WINNT_AUTH_IDENTITY_WPSEC_WINNT_AUTH_IDENTITY_ASEC_WINNT_AUTH_IDENTITY_ARPC_C_AUTHN_INFO_TYPE_HTTPRPC_C_HTTP_AUTHN_TARGET_SERVERRPC_C_HTTP_AUTHN_TARGET_PROXYRPC_C_HTTP_AUTHN_SCHEME_BASICRPC_C_HTTP_AUTHN_SCHEME_NTLMRPC_C_HTTP_AUTHN_SCHEME_PASSPORTRPC_C_HTTP_AUTHN_SCHEME_DIGESTRPC_C_HTTP_AUTHN_SCHEME_NEGOTIATERPC_C_HTTP_AUTHN_SCHEME_CERTRPC_C_HTTP_FLAG_USE_SSLRPC_C_HTTP_FLAG_USE_FIRST_AUTH_SCHEMERPC_C_HTTP_FLAG_IGNORE_CERT_CN_INVALIDRPC_C_HTTP_FLAG_ENABLE_CERT_REVOCATION_CHECKPRPC_HTTP_TRANSPORT_CREDENTIALS_WRPC_HTTP_TRANSPORT_CREDENTIALS_WPRPC_HTTP_TRANSPORT_CREDENTIALS_ARPC_HTTP_TRANSPORT_CREDENTIALS_APRPC_HTTP_TRANSPORT_CREDENTIALS_V2_WRPC_HTTP_TRANSPORT_CREDENTIALS_V2_WPRPC_HTTP_TRANSPORT_CREDENTIALS_V2_ARPC_HTTP_TRANSPORT_CREDENTIALS_V2_APRPC_HTTP_TRANSPORT_CREDENTIALS_V3_WRPC_HTTP_TRANSPORT_CREDENTIALS_V3_WPRPC_HTTP_TRANSPORT_CREDENTIALS_V3_ARPC_HTTP_TRANSPORT_CREDENTIALS_V3_APRPC_SECURITY_QOS_V2_WRPC_SECURITY_QOS_V2_WPRPC_SECURITY_QOS_V2_ARPC_SECURITY_QOS_V2_APRPC_SECURITY_QOS_V3_WRPC_SECURITY_QOS_V3_WPRPC_SECURITY_QOS_V3_ARPC_SECURITY_QOS_V3_APRPC_SECURITY_QOS_V4_WRPC_SECURITY_QOS_V4_WPRPC_SECURITY_QOS_V4_ARPC_SECURITY_QOS_V4_APRPC_SECURITY_QOS_V5_WRPC_SECURITY_QOS_V5_WPRPC_SECURITY_QOS_V5_ARPC_SECURITY_QOS_V5_ARPC_PROTSEQ_TCPRPC_PROTSEQ_NMPRPC_PROTSEQ_LRPCRPC_PROTSEQ_HTTPRPC_BHT_OBJECT_UUID_VALIDRPC_BHO_NONCAUSALRPC_BHO_DONTLINGERRPC_BHO_EXCLUSIVE_AND_GUARANTEEDPRPC_BINDING_HANDLE_TEMPLATE_V1_WRPC_BINDING_HANDLE_TEMPLATE_V1_WPRPC_BINDING_HANDLE_TEMPLATE_V1_ARPC_BINDING_HANDLE_TEMPLATE_V1_APRPC_BINDING_HANDLE_SECURITY_V1_WRPC_BINDING_HANDLE_SECURITY_V1_WPRPC_BINDING_HANDLE_SECURITY_V1_ARPC_BINDING_HANDLE_SECURITY_V1_APRPC_BINDING_HANDLE_OPTIONS_V1RPC_BINDING_HANDLE_OPTIONS_V1RPC_C_AUTHZ_NAMERPC_C_AUTHZ_DCERPC_C_AUTHZ_DEFAULTPRPC_CLIENT_INFORMATION1RPC_CLIENT_INFORMATION1RPC_EP_INQ_HANDLERPC_C_EP_ALL_ELTSRPC_C_EP_MATCH_BY_IFRPC_C_EP_MATCH_BY_OBJRPC_C_EP_MATCH_BY_BOTHRPC_C_VERS_ALLRPC_C_VERS_COMPATIBLERPC_C_VERS_EXACTRPC_C_VERS_MAJOR_ONLYRPC_C_VERS_UPTORPC_C_MGMT_INQ_IF_IDSRPC_C_MGMT_INQ_PRINC_NAMERPC_C_MGMT_INQ_STATSRPC_C_MGMT_IS_SERVER_LISTENRPC_C_MGMT_STOP_SERVER_LISTENRPC_IF_AUTOLISTENRPC_IF_OLERPC_IF_ALLOW_UNKNOWN_AUTHORITYRPC_IF_ALLOW_SECURE_ONLYRPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTHRPC_IF_ALLOW_LOCAL_ONLYRPC_IF_SEC_NO_CACHERPC_IF_SEC_CACHE_PER_PROCRPC_IF_ASYNC_CALLBACKRPC_FW_IF_FLAG_DCOMRPC_INTERFACE_GROUPPRPC_INTERFACE_GROUPPRPC_ENDPOINT_TEMPLATEWRPC_ENDPOINT_TEMPLATEWPRPC_ENDPOINT_TEMPLATEARPC_ENDPOINT_TEMPLATEAPRPC_INTERFACE_TEMPLATEARPC_INTERFACE_TEMPLATEAPRPC_INTERFACE_TEMPLATEWRPC_INTERFACE_TEMPLATEW//! This module contains the DCE RPC runtime APIs.NDR_CHAR_REP_MASKNDR_INT_REP_MASKNDR_FLOAT_REP_MASKNDR_LITTLE_ENDIANNDR_BIG_ENDIANNDR_IEEE_FLOATNDR_VAX_FLOATNDR_IBM_FLOATNDR_ASCII_CHARNDR_EBCDIC_CHARNDR_LOCAL_DATA_REPRESENTATIONNDR_LOCAL_ENDIANcs_byteMIDL_uhyper// TODO Finish the restSECURITY_INFORMATIONSDDL_REVISION_1SDDL_REVISIONSDDL_OWNERSDDL_GROUPSDDL_DACLSDDL_SACLSDDL_PROTECTEDSDDL_AUTO_INHERIT_REQSDDL_AUTO_INHERITEDSDDL_NULL_ACLSDDL_ACCESS_ALLOWEDSDDL_ACCESS_DENIEDSDDL_OBJECT_ACCESS_ALLOWEDSDDL_OBJECT_ACCESS_DENIEDSDDL_AUDITSDDL_ALARMSDDL_OBJECT_AUDITSDDL_OBJECT_ALARMSDDL_MANDATORY_LABELSDDL_PROCESS_TRUST_LABELSDDL_CALLBACK_ACCESS_ALLOWEDSDDL_CALLBACK_ACCESS_DENIEDSDDL_RESOURCE_ATTRIBUTESDDL_SCOPED_POLICY_IDSDDL_CALLBACK_AUDITSDDL_CALLBACK_OBJECT_ACCESS_ALLOWEDSDDL_ACCESS_FILTERSDDL_INTSDDL_UINTSDDL_WSTRINGSDDL_SIDSDDL_BLOBSDDL_BOOLEANSDDL_CONTAINER_INHERITSDDL_OBJECT_INHERITSDDL_NO_PROPAGATESDDL_INHERIT_ONLYSDDL_INHERITEDSDDL_TRUST_PROTECTED_FILTERSDDL_AUDIT_SUCCESSSDDL_AUDIT_FAILURESDDL_READ_PROPERTYSDDL_WRITE_PROPERTYSDDL_CREATE_CHILDSDDL_DELETE_CHILDSDDL_LIST_CHILDRENSDDL_SELF_WRITESDDL_LIST_OBJECTSDDL_DELETE_TREESDDL_CONTROL_ACCESSSDDL_READ_CONTROLSDDL_WRITE_DACSDDL_WRITE_OWNERSDDL_STANDARD_DELETESDDL_GENERIC_ALLSDDL_GENERIC_READSDDL_GENERIC_WRITESDDL_GENERIC_EXECUTESDDL_FILE_ALLSDDL_FILE_READSDDL_FILE_WRITESDDL_FILE_EXECUTESDDL_KEY_ALLSDDL_KEY_READSDDL_KEY_WRITESDDL_KEY_EXECUTESDDL_NO_WRITE_UPSDDL_NO_READ_UPSDDL_NO_EXECUTE_UPSDDL_ALIAS_SIZESDDL_DOMAIN_ADMINISTRATORSSDDL_DOMAIN_GUESTSSDDL_DOMAIN_USERSSDDL_ENTERPRISE_DOMAIN_CONTROLLERSSDDL_DOMAIN_DOMAIN_CONTROLLERSSDDL_DOMAIN_COMPUTERSSDDL_BUILTIN_ADMINISTRATORSSDDL_BUILTIN_GUESTSSDDL_BUILTIN_USERSSDDL_LOCAL_ADMINSDDL_LOCAL_GUESTSDDL_ACCOUNT_OPERATORSSDDL_BACKUP_OPERATORSSDDL_PRINTER_OPERATORSSDDL_SERVER_OPERATORSSDDL_AUTHENTICATED_USERSSDDL_PERSONAL_SELFSDDL_CREATOR_OWNERSDDL_CREATOR_GROUPSDDL_LOCAL_SYSTEMSDDL_POWER_USERSSDDL_EVERYONESDDL_REPLICATORSDDL_INTERACTIVESDDL_NETWORKSDDL_SERVICESDDL_RESTRICTED_CODESDDL_WRITE_RESTRICTED_CODESDDL_ANONYMOUSSDDL_SCHEMA_ADMINISTRATORSSDDL_CERT_SERV_ADMINISTRATORSSDDL_RAS_SERVERSSDDL_ENTERPRISE_ADMINSSDDL_GROUP_POLICY_ADMINSSDDL_ALIAS_PREW2KCOMPACCSDDL_LOCAL_SERVICESDDL_NETWORK_SERVICESDDL_REMOTE_DESKTOPSDDL_NETWORK_CONFIGURATION_OPSSDDL_PERFMON_USERSSDDL_PERFLOG_USERSSDDL_IIS_USERSSDDL_CRYPTO_OPERATORSSDDL_OWNER_RIGHTSSDDL_EVENT_LOG_READERSSDDL_ENTERPRISE_RO_DCsSDDL_CERTSVC_DCOM_ACCESSSDDL_ALL_APP_PACKAGESSDDL_RDS_REMOTE_ACCESS_SERVERSSDDL_RDS_ENDPOINT_SERVERSSDDL_RDS_MANAGEMENT_SERVERSSDDL_USER_MODE_DRIVERSSDDL_HYPER_V_ADMINSSDDL_CLONEABLE_CONTROLLERSSDDL_ACCESS_CONTROL_ASSISTANCE_OPSSDDL_REMOTE_MANAGEMENT_USERSSDDL_AUTHORITY_ASSERTEDSDDL_SERVICE_ASSERTEDSDDL_PROTECTED_USERSSDDL_KEY_ADMINSSDDL_ENTERPRISE_KEY_ADMINSSDDL_ML_LOWSDDL_ML_MEDIUMSDDL_ML_MEDIUM_PLUSSDDL_ML_HIGHSDDL_ML_SYSTEMSDDL_SEPERATORCSDDL_DELIMINATORCSDDL_ACE_BEGINCSDDL_ACE_ENDCSDDL_SPACECSDDL_ACE_COND_BEGINCSDDL_ACE_COND_ENDCSDDL_ACE_COND_STRING_BEGINCSDDL_ACE_COND_STRING_ENDCSDDL_ACE_COND_COMPOSITEVALUE_BEGINCSDDL_ACE_COND_COMPOSITEVALUE_ENDCSDDL_ACE_COND_COMPOSITEVALUE_SEPERATORCSDDL_ACE_COND_BLOB_PREFIXCSDDL_ACE_COND_SID_BEGINCSDDL_ACE_COND_SID_ENDCSDDL_SEPERATORSDDL_DELIMINATORSDDL_ACE_BEGINSDDL_ACE_ENDSDDL_ACE_COND_BEGINSDDL_ACE_COND_ENDSDDL_SPACESDDL_ACE_COND_BLOB_PREFIXSDDL_ACE_COND_SID_PREFIXSDDL_ACE_COND_ATTRIBUTE_PREFIXSDDL_ACE_COND_USER_ATTRIBUTE_PREFIXSDDL_ACE_COND_RESOURCE_ATTRIBUTE_PREFIXSDDL_ACE_COND_DEVICE_ATTRIBUTE_PREFIXSDDL_ACE_COND_TOKEN_ATTRIBUTE_PREFIXConvertSidToStringSidAConvertStringSidToSidAConvertStringSecurityDescriptorToSecurityDescriptorAConvertStringSecurityDescriptorToSecurityDescriptorWConvertSecurityDescriptorToStringSecurityDescriptorAConvertSecurityDescriptorToStringSecurityDescriptorWsubauthwincredPCREDUI_INFOAPCREDUI_INFOWSEC_WCHARSEC_CHARPSecHandleSecHandleSEC_DELETED_HANDLECredHandlePCredHandleCtxtHandlePCtxtHandleSECURITY_INTEGERPSECURITY_INTEGERPTimeStampPSECURITY_STRINGSECURITY_STRINGPSecPkgInfoWSecPkgInfoWPSecPkgInfoASecPkgInfoASECPKG_FLAG_INTEGRITYSECPKG_FLAG_PRIVACYSECPKG_FLAG_TOKEN_ONLYSECPKG_FLAG_DATAGRAMSECPKG_FLAG_CONNECTIONSECPKG_FLAG_MULTI_REQUIREDSECPKG_FLAG_CLIENT_ONLYSECPKG_FLAG_EXTENDED_ERRORSECPKG_FLAG_IMPERSONATIONSECPKG_FLAG_ACCEPT_WIN32_NAMESECPKG_FLAG_STREAMSECPKG_FLAG_NEGOTIABLESECPKG_FLAG_GSS_COMPATIBLESECPKG_FLAG_LOGONSECPKG_FLAG_ASCII_BUFFERSSECPKG_FLAG_FRAGMENTSECPKG_FLAG_MUTUAL_AUTHSECPKG_FLAG_DELEGATIONSECPKG_FLAG_READONLY_WITH_CHECKSUMSECPKG_FLAG_RESTRICTED_TOKENSSECPKG_FLAG_NEGO_EXTENDERSECPKG_FLAG_NEGOTIABLE2SECPKG_FLAG_APPCONTAINER_PASSTHROUGHSECPKG_FLAG_APPCONTAINER_CHECKSSECPKG_ID_NONESECPKG_CALLFLAGS_APPCONTAINERSECPKG_CALLFLAGS_APPCONTAINER_AUTHCAPABLESECPKG_CALLFLAGS_FORCE_SUPPLIEDPSecBufferSecBufferPSecBufferDescSecBufferDescSECBUFFER_VERSIONSECBUFFER_EMPTYSECBUFFER_DATASECBUFFER_TOKENSECBUFFER_PKG_PARAMSSECBUFFER_MISSINGSECBUFFER_EXTRASECBUFFER_STREAM_TRAILERSECBUFFER_STREAM_HEADERSECBUFFER_NEGOTIATION_INFOSECBUFFER_PADDINGSECBUFFER_STREAMSECBUFFER_MECHLISTSECBUFFER_MECHLIST_SIGNATURESECBUFFER_TARGETSECBUFFER_CHANNEL_BINDINGSSECBUFFER_CHANGE_PASS_RESPONSESECBUFFER_TARGET_HOSTSECBUFFER_ALERTSECBUFFER_APPLICATION_PROTOCOLSSECBUFFER_ATTRMASKSECBUFFER_READONLYSECBUFFER_READONLY_WITH_CHECKSUMSECBUFFER_RESERVEDPSEC_NEGOTIATION_INFOSEC_NEGOTIATION_INFOPSEC_CHANNEL_BINDINGSSEC_CHANNEL_BINDINGSPSEC_APPLICATION_PROTOCOL_NEGOTIATION_EXTSEC_APPLICATION_PROTOCOL_NEGOTIATION_EXTPSEC_APPLICATION_PROTOCOL_LISTSEC_APPLICATION_PROTOCOL_LISTPSEC_APPLICATION_PROTOCOLSSEC_APPLICATION_PROTOCOLSSECURITY_NATIVE_DREPSECURITY_NETWORK_DREPSECPKG_CRED_INBOUNDSECPKG_CRED_OUTBOUNDSECPKG_CRED_BOTHSECPKG_CRED_DEFAULTSECPKG_CRED_RESERVEDSECPKG_CRED_AUTOLOGON_RESTRICTEDSECPKG_CRED_PROCESS_POLICY_ONLYISC_REQ_DELEGATEISC_REQ_MUTUAL_AUTHISC_REQ_REPLAY_DETECTISC_REQ_SEQUENCE_DETECTISC_REQ_CONFIDENTIALITYISC_REQ_USE_SESSION_KEYISC_REQ_PROMPT_FOR_CREDSISC_REQ_USE_SUPPLIED_CREDSISC_REQ_ALLOCATE_MEMORYISC_REQ_USE_DCE_STYLEISC_REQ_DATAGRAMISC_REQ_CONNECTIONISC_REQ_CALL_LEVELISC_REQ_FRAGMENT_SUPPLIEDISC_REQ_EXTENDED_ERRORISC_REQ_STREAMISC_REQ_INTEGRITYISC_REQ_IDENTIFYISC_REQ_NULL_SESSIONISC_REQ_MANUAL_CRED_VALIDATIONISC_REQ_RESERVED1ISC_REQ_FRAGMENT_TO_FITISC_REQ_FORWARD_CREDENTIALSISC_REQ_NO_INTEGRITYISC_REQ_USE_HTTP_STYLEISC_REQ_UNVERIFIED_TARGET_NAMEISC_REQ_CONFIDENTIALITY_ONLYISC_RET_DELEGATEISC_RET_MUTUAL_AUTHISC_RET_REPLAY_DETECTISC_RET_SEQUENCE_DETECTISC_RET_CONFIDENTIALITYISC_RET_USE_SESSION_KEYISC_RET_USED_COLLECTED_CREDSISC_RET_USED_SUPPLIED_CREDSISC_RET_ALLOCATED_MEMORYISC_RET_USED_DCE_STYLEISC_RET_DATAGRAMISC_RET_CONNECTIONISC_RET_INTERMEDIATE_RETURNISC_RET_CALL_LEVELISC_RET_EXTENDED_ERRORISC_RET_STREAMISC_RET_INTEGRITYISC_RET_IDENTIFYISC_RET_NULL_SESSIONISC_RET_MANUAL_CRED_VALIDATIONISC_RET_RESERVED1ISC_RET_FRAGMENT_ONLYISC_RET_FORWARD_CREDENTIALSISC_RET_USED_HTTP_STYLEISC_RET_NO_ADDITIONAL_TOKENISC_RET_REAUTHENTICATIONISC_RET_CONFIDENTIALITY_ONLYASC_REQ_DELEGATEASC_REQ_MUTUAL_AUTHASC_REQ_REPLAY_DETECTASC_REQ_SEQUENCE_DETECTASC_REQ_CONFIDENTIALITYASC_REQ_USE_SESSION_KEYASC_REQ_SESSION_TICKETASC_REQ_ALLOCATE_MEMORYASC_REQ_USE_DCE_STYLEASC_REQ_DATAGRAMASC_REQ_CONNECTIONASC_REQ_CALL_LEVELASC_REQ_EXTENDED_ERRORASC_REQ_STREAMASC_REQ_INTEGRITYASC_REQ_LICENSINGASC_REQ_IDENTIFYASC_REQ_ALLOW_NULL_SESSIONASC_REQ_ALLOW_NON_USER_LOGONSASC_REQ_ALLOW_CONTEXT_REPLAYASC_REQ_FRAGMENT_TO_FITASC_REQ_FRAGMENT_SUPPLIEDASC_REQ_NO_TOKENASC_REQ_PROXY_BINDINGSASC_REQ_ALLOW_MISSING_BINDINGSASC_RET_DELEGATEASC_RET_MUTUAL_AUTHASC_RET_REPLAY_DETECTASC_RET_SEQUENCE_DETECTASC_RET_CONFIDENTIALITYASC_RET_USE_SESSION_KEYASC_RET_SESSION_TICKETASC_RET_ALLOCATED_MEMORYASC_RET_USED_DCE_STYLEASC_RET_DATAGRAMASC_RET_CONNECTIONASC_RET_CALL_LEVELASC_RET_THIRD_LEG_FAILEDASC_RET_EXTENDED_ERRORASC_RET_STREAMASC_RET_INTEGRITYASC_RET_LICENSINGASC_RET_IDENTIFYASC_RET_NULL_SESSIONASC_RET_ALLOW_NON_USER_LOGONSASC_RET_ALLOW_CONTEXT_REPLAYASC_RET_FRAGMENT_ONLYASC_RET_NO_TOKENASC_RET_NO_ADDITIONAL_TOKENSECPKG_CRED_ATTR_NAMESSECPKG_CRED_ATTR_SSI_PROVIDERSECPKG_CRED_ATTR_KDC_PROXY_SETTINGSSECPKG_CRED_ATTR_CERTPSecPkgCredentials_NamesWSecPkgCredentials_NamesWPSecPkgCredentials_NamesASecPkgCredentials_NamesAPSecPkgCredentials_SSIProviderWSecPkgCredentials_SSIProviderWPSecPkgCredentials_SSIProviderASecPkgCredentials_SSIProviderAKDC_PROXY_SETTINGS_V1KDC_PROXY_SETTINGS_FLAGS_FORCEPROXYPSecPkgCredentials_KdcProxySettingsWSecPkgCredentials_KdcProxySettingsWPSecPkgCredentials_CertSecPkgCredentials_CertSECPKG_ATTR_SIZESSECPKG_ATTR_NAMESSECPKG_ATTR_LIFESPANSECPKG_ATTR_DCE_INFOSECPKG_ATTR_STREAM_SIZESSECPKG_ATTR_KEY_INFOSECPKG_ATTR_AUTHORITYSECPKG_ATTR_PROTO_INFOSECPKG_ATTR_PASSWORD_EXPIRYSECPKG_ATTR_SESSION_KEYSECPKG_ATTR_PACKAGE_INFOSECPKG_ATTR_USER_FLAGSSECPKG_ATTR_NEGOTIATION_INFOSECPKG_ATTR_NATIVE_NAMESSECPKG_ATTR_FLAGSSECPKG_ATTR_USE_VALIDATEDSECPKG_ATTR_CREDENTIAL_NAMESECPKG_ATTR_TARGET_INFORMATIONSECPKG_ATTR_ACCESS_TOKENSECPKG_ATTR_TARGETSECPKG_ATTR_AUTHENTICATION_IDSECPKG_ATTR_LOGOFF_TIMESECPKG_ATTR_NEGO_KEYSSECPKG_ATTR_PROMPTING_NEEDEDSECPKG_ATTR_UNIQUE_BINDINGSSECPKG_ATTR_ENDPOINT_BINDINGSSECPKG_ATTR_CLIENT_SPECIFIED_TARGETSECPKG_ATTR_LAST_CLIENT_TOKEN_STATUSSECPKG_ATTR_NEGO_PKG_INFOSECPKG_ATTR_NEGO_STATUSSECPKG_ATTR_CONTEXT_DELETEDSECPKG_ATTR_DTLS_MTUSECPKG_ATTR_DATAGRAM_SIZESSECPKG_ATTR_SUBJECT_SECURITY_ATTRIBUTESSECPKG_ATTR_APPLICATION_PROTOCOLPSecPkgContext_SubjectAttributesSecPkgContext_SubjectAttributesSECPKG_ATTR_NEGO_INFO_FLAG_NO_KERBEROSSECPKG_ATTR_NEGO_INFO_FLAG_NO_NTLMPSECPKG_CRED_CLASSSECPKG_CRED_CLASSPSecPkgContext_CredInfoSecPkgContext_CredInfoPSecPkgContext_NegoPackageInfoSecPkgContext_NegoPackageInfoPSecPkgContext_NegoStatusSecPkgContext_NegoStatusPSecPkgContext_SizesSecPkgContext_SizesPSecPkgContext_StreamSizesSecPkgContext_StreamSizesSecPkgContext_DatagramSizesPSecPkgContext_DatagramSizesPSecPkgContext_NamesWSecPkgContext_NamesWPSECPKG_ATTR_LCT_STATUSSECPKG_ATTR_LCT_STATUSPSecPkgContext_LastClientTokenStatusSecPkgContext_LastClientTokenStatusPSecPkgContext_NamesASecPkgContext_NamesAPSecPkgContext_LifespanSecPkgContext_LifespanPSecPkgContext_DceInfoSecPkgContext_DceInfoPSecPkgContext_KeyInfoASecPkgContext_KeyInfoAPSecPkgContext_KeyInfoWSecPkgContext_KeyInfoWPSecPkgContext_AuthorityASecPkgContext_AuthorityAPSecPkgContext_AuthorityWSecPkgContext_AuthorityWPSecPkgContext_ProtoInfoASecPkgContext_ProtoInfoAPSecPkgContext_ProtoInfoWSecPkgContext_ProtoInfoWPSecPkgContext_PasswordExpirySecPkgContext_PasswordExpiryPSecPkgContext_LogoffTimeSecPkgContext_LogoffTimePSecPkgContext_SessionKeySecPkgContext_SessionKeyPSecPkgContext_NegoKeysSecPkgContext_NegoKeysPSecPkgContext_PackageInfoWSecPkgContext_PackageInfoWPSecPkgContext_PackageInfoASecPkgContext_PackageInfoAPSecPkgContext_UserFlagsSecPkgContext_UserFlagsPSecPkgContext_FlagsSecPkgContext_FlagsPSecPkgContext_NegotiationInfoASecPkgContext_NegotiationInfoAPSecPkgContext_NegotiationInfoWSecPkgContext_NegotiationInfoWSECPKG_NEGOTIATION_COMPLETESECPKG_NEGOTIATION_OPTIMISTICSECPKG_NEGOTIATION_IN_PROGRESSSECPKG_NEGOTIATION_DIRECTSECPKG_NEGOTIATION_TRY_MULTICREDPSecPkgContext_NativeNamesWSecPkgContext_NativeNamesWPSecPkgContext_NativeNamesASecPkgContext_NativeNamesAPSecPkgContext_CredentialNameWSecPkgContext_CredentialNameWPSecPkgContext_CredentialNameASecPkgContext_CredentialNameAPSecPkgContext_AccessTokenSecPkgContext_AccessTokenPSecPkgContext_TargetInformationSecPkgContext_TargetInformationPSecPkgContext_AuthzIDSecPkgContext_AuthzIDPSecPkgContext_TargetSecPkgContext_TargetPSecPkgContext_ClientSpecifiedTargetSecPkgContext_ClientSpecifiedTargetPSecPkgContext_BindingsSecPkgContext_BindingsPSEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUSSEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUSMAX_PROTOCOL_ID_SIZEPSecPkgContext_ApplicationProtocolSecPkgContext_ApplicationProtocolSECPKG_CONTEXT_EXPORT_RESET_NEWSECPKG_CONTEXT_EXPORT_DELETE_OLDSECPKG_CONTEXT_EXPORT_TO_KERNELAcquireCredentialsHandleWSEC_GET_KEY_FNAcquireCredentialsHandleAFreeCredentialsHandleAddCredentialsWAddCredentialsAChangeAccountPasswordW// pub fn spiCreateAsyncContext();// pub fn SspiFreeAsyncContext();// pub fn SspiReinitAsyncContext();// pub fn SspiSetAsyncNotifyCallback();// pub fn SspiAsyncContextRequiresNotify();// pub fn SspiGetAsyncCallStatus();// pub fn SspiAcquireCredentialsHandleAsyncW();// pub fn SspiAcquireCredentialsHandleAsyncA();// pub fn SspiInitializeSecurityContextAsyncW();// pub fn SspiInitializeSecurityContextAsyncA();// pub fn SspiAcceptSecurityContextAsync();// pub fn SspiFreeCredentialsHandleAsync();// pub fn SspiDeleteSecurityContextAsync();ChangeAccountPasswordAInitializeSecurityContextWInitializeSecurityContextAAcceptSecurityContextCompleteAuthTokenImpersonateSecurityContextRevertSecurityContextQuerySecurityContextTokenDeleteSecurityContextApplyControlTokenQueryContextAttributesWQueryContextAttributesA// pub fn QueryContextAttributesExW();SetContextAttributesW// pub fn QueryContextAttributesExA();SetContextAttributesAQueryCredentialsAttributesWQueryCredentialsAttributesA// pub fn QueryCredentialsAttributesExW();SetCredentialsAttributesW// pub fn QueryCredentialsAttributesExA();SetCredentialsAttributesAFreeContextBufferMakeSignatureVerifySignatureEncryptMessageDecryptMessageEnumerateSecurityPackagesWEnumerateSecurityPackagesAQuerySecurityPackageInfoWQuerySecurityPackageInfoAPSecDelegationTypeSecDelegationTypeExportSecurityContext// pub fn DelegateSecurityContext();ImportSecurityContextWImportSecurityContextA// pub fn SecMakeSPN();// pub fn SecMakeSPNEx();// pub fn SecMakeSPNEx2();// pub fn SecLookupAccountSid();// pub fn SecLookupAccountName();// pub fn SecLookupWellKnownSid();// pub fn InitSecurityInterfaceA();// pub fn InitSecurityInterfaceW();// pub fn SaslEnumerateProfilesA();// pub fn SaslEnumerateProfilesW();// pub fn SaslGetProfilePackageA();// pub fn SaslGetProfilePackageW();// pub fn SaslIdentifyPackageA();// pub fn SaslIdentifyPackageW();// pub fn SaslInitializeSecurityContextW();// pub fn SaslInitializeSecurityContextA();// pub fn SaslAcceptSecurityContext();// pub fn SaslSetContextOption();// pub fn SaslGetContextOption();PSEC_WINNT_AUTH_IDENTITY_OPAQUESspiPromptForCredentialsWSspiPromptForCredentialsAPSEC_WINNT_AUTH_BYTE_VECTORSEC_WINNT_AUTH_BYTE_VECTORPSEC_WINNT_AUTH_DATASEC_WINNT_AUTH_DATAPSEC_WINNT_AUTH_PACKED_CREDENTIALSSEC_WINNT_AUTH_PACKED_CREDENTIALSPSEC_WINNT_AUTH_DATA_PASSWORDSEC_WINNT_AUTH_DATA_PASSWORD// GUID SEC_WINNT_AUTH_DATA_TYPE_SMARTCARD_CONTEXTSPSEC_WINNT_AUTH_CERTIFICATE_DATASEC_WINNT_AUTH_CERTIFICATE_DATAPSEC_WINNT_CREDUI_CONTEXT_VECTORSEC_WINNT_CREDUI_CONTEXT_VECTORPSEC_WINNT_AUTH_SHORT_VECTORSEC_WINNT_AUTH_SHORT_VECTORSspiGetCredUIContextSspiUpdateCredentialsPCREDUIWIN_MARSHALED_CONTEXTCREDUIWIN_MARSHALED_CONTEXTPSEC_WINNT_CREDUI_CONTEXTSEC_WINNT_CREDUI_CONTEXTSspiUnmarshalCredUIContextSspiIsPromptingNeeded// pub fn SspiPrepareForCredRead();// pub fn SspiPrepareForCredWrite();// pub fn SspiEncryptAuthIdentity();// pub fn SspiEncryptAuthIdentityEx();// pub fn SspiDecryptAuthIdentity();// pub fn SspiDecryptAuthIdentityEx();// pub fn SspiIsAuthIdentityEncrypted();// pub fn SspiEncodeAuthIdentityAsStrings();// pub fn SspiValidateAuthIdentity();// pub fn SspiCopyAuthIdentity();// pub fn SspiFreeAuthIdentity();// pub fn SspiZeroAuthIdentity();// pub fn SspiLocalFree();// pub fn SspiEncodeStringsAsAuthIdentity();// pub fn SspiCompareAuthIdentities();// pub fn SspiMarshalAuthIdentity();// pub fn SspiUnmarshalAuthIdentity();// pub fn SspiGetTargetHostName();// pub fn SspiExcludePackage();// pub fn AddSecurityPackageA();// pub fn AddSecurityPackageW();// pub fn DeleteSecurityPackageA();// pub fn DeleteSecurityPackageW();//! Security Support Provider Interface Prototypes and structure definitions// INITIALIZE_SECURITY_CONTEXT_FN_W// GUID CREDUIWIN_STRUCTURE_TYPE_SSPIPFC// GUID SSPIPFC_STRUCTURE_TYPE_CREDUI_CONTEXTvcruntimeuaw_lstrcmpWuaw_lstrcmpiWuaw_lstrlenWuaw_wcschruaw_wcscpyuaw_wcsicmpuaw_wcslenuaw_wcsrchrPTCP_ESTATS_TYPETCP_ESTATS_TYPEPTCP_BOOLEAN_OPTIONALTCP_BOOLEAN_OPTIONALPTCP_ESTATS_SYN_OPTS_ROS_v0TCP_ESTATS_SYN_OPTS_ROS_v0PTCP_SOFT_ERRORTCP_SOFT_ERRORPTCP_ESTATS_DATA_ROD_v0TCP_ESTATS_DATA_ROD_v0PTCP_ESTATS_DATA_RW_v0TCP_ESTATS_DATA_RW_v0PTCP_ESTATS_SND_CONG_ROD_v0TCP_ESTATS_SND_CONG_ROD_v0PTCP_ESTATS_SND_CONG_ROS_v0TCP_ESTATS_SND_CONG_ROS_v0PTCP_ESTATS_SND_CONG_RW_v0TCP_ESTATS_SND_CONG_RW_v0PTCP_ESTATS_PATH_ROD_v0TCP_ESTATS_PATH_ROD_v0PTCP_ESTATS_PATH_RW_v0TCP_ESTATS_PATH_RW_v0PTCP_ESTATS_SEND_BUFF_ROD_v0TCP_ESTATS_SEND_BUFF_ROD_v0PTCP_ESTATS_SEND_BUFF_RW_v0TCP_ESTATS_SEND_BUFF_RW_v0PTCP_ESTATS_REC_ROD_v0TCP_ESTATS_REC_ROD_v0PTCP_ESTATS_REC_RW_v0TCP_ESTATS_REC_RW_v0PTCP_ESTATS_OBS_REC_ROD_v0TCP_ESTATS_OBS_REC_ROD_v0PTCP_ESTATS_OBS_REC_RW_v0TCP_ESTATS_OBS_REC_RW_v0PTCP_ESTATS_BANDWIDTH_RW_v0TCP_ESTATS_BANDWIDTH_RW_v0PTCP_ESTATS_BANDWIDTH_ROD_v0TCP_ESTATS_BANDWIDTH_ROD_v0PTCP_ESTATS_FINE_RTT_RW_v0TCP_ESTATS_FINE_RTT_RW_v0PTCP_ESTATS_FINE_RTT_ROD_v0TCP_ESTATS_FINE_RTT_ROD_v0TCPIP_OWNING_MODULE_SIZEPTCP_CONNECTION_OFFLOAD_STATETCP_CONNECTION_OFFLOAD_STATEPMIB_TCPROW_LHMIB_TCPROW_LHPMIB_TCPROW_W2KMIB_TCPROW_W2KMIB_TCPROWPMIB_TCPROWPMIB_TCPTABLEMIB_TCPTABLE// FIXME: SIZEOF_TCPTABLE(x)PMIB_TCPROW2MIB_TCPROW2PMIB_TCPTABLE2MIB_TCPTABLE2// FIXME: SIZEOF_TCPTABLE2(x)PMIB_TCPROW_OWNER_PIDMIB_TCPROW_OWNER_PIDPMIB_TCPTABLE_OWNER_PIDMIB_TCPTABLE_OWNER_PID// FIXME: SIZEOF_TCPTABLE_OWNER_PID(x)PMIB_TCPROW_OWNER_MODULEMIB_TCPROW_OWNER_MODULEPMIB_TCPTABLE_OWNER_MODULEMIB_TCPTABLE_OWNER_MODULE// FIXME: SIZEOF_TCPTABLE_OWNER_MODULE(x)PMIB_TCP6ROWMIB_TCP6ROWPMIB_TCP6TABLEMIB_TCP6TABLE// FIXME: SIZEOF_TCP6TABLE(x)PMIB_TCP6ROW2MIB_TCP6ROW2PMIB_TCP6TABLE2MIB_TCP6TABLE2// FIXME: SIZEOF_TCP6TABLE2(x)PMIB_TCP6ROW_OWNER_PIDMIB_TCP6ROW_OWNER_PIDPMIB_TCP6TABLE_OWNER_PIDMIB_TCP6TABLE_OWNER_PID// FIXME: SIZEOF_TCP6TABLE_OWNER_PID(x)PMIB_TCP6ROW_OWNER_MODULEMIB_TCP6ROW_OWNER_MODULEPMIB_TCP6TABLE_OWNER_MODULEMIB_TCP6TABLE_OWNER_MODULE// FIXME: SIZEOF_TCP6TABLE_OWNER_MODULE(x)PTCP_RTO_ALGORITHMTCP_RTO_ALGORITHMPMIB_TCPSTATS_LHMIB_TCPSTATS_LHPMIB_TCPSTATS_W2KMIB_TCPSTATS_W2KMIB_TCPSTATSPMIB_TCPSTATSPMIB_TCPSTATS2MIB_TCPSTATS2PVIDEOPARAMETERSVIDEOPARAMETERSLPVIDEOPARAMETERSVP_COMMAND_GETVP_COMMAND_SETVP_FLAGS_TV_MODEVP_FLAGS_TV_STANDARDVP_FLAGS_FLICKERVP_FLAGS_OVERSCANVP_FLAGS_MAX_UNSCALEDVP_FLAGS_POSITIONVP_FLAGS_BRIGHTNESSVP_FLAGS_CONTRASTVP_FLAGS_COPYPROTECTVP_MODE_WIN_GRAPHICSVP_MODE_TV_PLAYBACKVP_TV_STANDARD_NTSC_MVP_TV_STANDARD_NTSC_M_JVP_TV_STANDARD_PAL_BVP_TV_STANDARD_PAL_DVP_TV_STANDARD_PAL_HVP_TV_STANDARD_PAL_IVP_TV_STANDARD_PAL_MVP_TV_STANDARD_PAL_NVP_TV_STANDARD_SECAM_BVP_TV_STANDARD_SECAM_DVP_TV_STANDARD_SECAM_GVP_TV_STANDARD_SECAM_HVP_TV_STANDARD_SECAM_KVP_TV_STANDARD_SECAM_K1VP_TV_STANDARD_SECAM_LVP_TV_STANDARD_WIN_VGAVP_TV_STANDARD_NTSC_433VP_TV_STANDARD_PAL_GVP_TV_STANDARD_PAL_60VP_TV_STANDARD_SECAM_L1VP_CP_TYPE_APS_TRIGGERVP_CP_TYPE_MACROVISIONVP_CP_CMD_ACTIVATEVP_CP_CMD_DEACTIVATEVP_CP_CMD_CHANGEPMIB_UDPROWMIB_UDPROWPMIB_UDPTABLEMIB_UDPTABLE// FIXME: SIZEOF_UDPTABLE(x)PMIB_UDPROW_OWNER_PIDMIB_UDPROW_OWNER_PIDPMIB_UDPTABLE_OWNER_PIDMIB_UDPTABLE_OWNER_PID// FIXME: SIZEOF_UDPTABLE_OWNER_PID(x)PMIB_UDPROW_OWNER_MODULEMIB_UDPROW_OWNER_MODULEPMIB_UDPTABLE_OWNER_MODULEMIB_UDPTABLE_OWNER_MODULE// FIXME: SIZEOF_UDPTABLE_OWNER_MODULE(x)PMIB_UDP6ROWMIB_UDP6ROWPMIB_UDP6TABLEMIB_UDP6TABLE// FIXME: SIZEOF_UDP6TABLE(x)PMIB_UDP6ROW_OWNER_PIDMIB_UDP6ROW_OWNER_PIDPMIB_UDP6TABLE_OWNER_PIDMIB_UDP6TABLE_OWNER_PID// FIXME: SIZEOF_UDP6TABLE_OWNER_PID(x)PMIB_UDP6ROW_OWNER_MODULEMIB_UDP6ROW_OWNER_MODULEPMIB_UDP6TABLE_OWNER_MODULEMIB_UDP6TABLE_OWNER_MODULE// FIXME: SIZEOF_UDP6TABLE_OWNER_MODULE(x)PMIB_UDPSTATSMIB_UDPSTATSPMIB_UDPSTATS2MIB_UDPSTATS2//! Contains the public definitions and structures for the UDP-specific parts of MIB-IIPUSB_CONFIGURATION_DESCRIPTORUSB_DEVICE_DESCRIPTORUSB_ENDPOINT_DIRECTION_MASKPRIPPMDLUSBDI_VERSIONUSB_PORTATTR_NO_CONNECTORUSB_PORTATTR_SHARED_USB2USB_PORTATTR_MINI_CONNECTORUSB_PORTATTR_OEM_CONNECTORUSB_PORTATTR_OWNED_BY_CCUSB_PORTATTR_NO_OVERCURRENT_UIUSB_DEFAULT_DEVICE_ADDRESSUSB_DEFAULT_ENDPOINT_ADDRESSUSB_DEFAULT_MAX_PACKETURB_FUNCTION_SELECT_CONFIGURATIONURB_FUNCTION_SELECT_INTERFACEURB_FUNCTION_ABORT_PIPEURB_FUNCTION_TAKE_FRAME_LENGTH_CONTROLURB_FUNCTION_RELEASE_FRAME_LENGTH_CONTROLURB_FUNCTION_GET_FRAME_LENGTHURB_FUNCTION_SET_FRAME_LENGTHURB_FUNCTION_GET_CURRENT_FRAME_NUMBERURB_FUNCTION_CONTROL_TRANSFERURB_FUNCTION_BULK_OR_INTERRUPT_TRANSFERURB_FUNCTION_ISOCH_TRANSFERURB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICEURB_FUNCTION_SET_DESCRIPTOR_TO_DEVICEURB_FUNCTION_SET_FEATURE_TO_DEVICEURB_FUNCTION_SET_FEATURE_TO_INTERFACEURB_FUNCTION_SET_FEATURE_TO_ENDPOINTURB_FUNCTION_CLEAR_FEATURE_TO_DEVICEURB_FUNCTION_CLEAR_FEATURE_TO_INTERFACEURB_FUNCTION_CLEAR_FEATURE_TO_ENDPOINTURB_FUNCTION_GET_STATUS_FROM_DEVICEURB_FUNCTION_GET_STATUS_FROM_INTERFACEURB_FUNCTION_GET_STATUS_FROM_ENDPOINTURB_FUNCTION_RESERVED_0X0016URB_FUNCTION_VENDOR_DEVICEURB_FUNCTION_VENDOR_INTERFACEURB_FUNCTION_VENDOR_ENDPOINTURB_FUNCTION_CLASS_DEVICEURB_FUNCTION_CLASS_INTERFACEURB_FUNCTION_CLASS_ENDPOINTURB_FUNCTION_RESERVE_0X001DURB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALLURB_FUNCTION_CLASS_OTHERURB_FUNCTION_VENDOR_OTHERURB_FUNCTION_GET_STATUS_FROM_OTHERURB_FUNCTION_CLEAR_FEATURE_TO_OTHERURB_FUNCTION_SET_FEATURE_TO_OTHERURB_FUNCTION_GET_DESCRIPTOR_FROM_ENDPOINTURB_FUNCTION_SET_DESCRIPTOR_TO_ENDPOINTURB_FUNCTION_GET_CONFIGURATIONURB_FUNCTION_GET_INTERFACEURB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACEURB_FUNCTION_SET_DESCRIPTOR_TO_INTERFACEURB_FUNCTION_GET_MS_FEATURE_DESCRIPTORURB_FUNCTION_SYNC_RESET_PIPEURB_FUNCTION_SYNC_CLEAR_STALLURB_FUNCTION_CONTROL_TRANSFER_EXURB_FUNCTION_RESERVE_0X0033URB_FUNCTION_RESERVE_0X0034URB_FUNCTION_OPEN_STATIC_STREAMSURB_FUNCTION_CLOSE_STATIC_STREAMSURB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER_USING_CHAINED_MDLURB_FUNCTION_ISOCH_TRANSFER_USING_CHAINED_MDLURB_FUNCTION_RESERVE_0X002BURB_FUNCTION_RESERVE_0X002CURB_FUNCTION_RESERVE_0X002DURB_FUNCTION_RESERVE_0X002EURB_FUNCTION_RESERVE_0X002FURB_FUNCTION_RESET_PIPEUSBD_SHORT_TRANSFER_OKUSBD_START_ISO_TRANSFER_ASAPUSBD_DEFAULT_PIPE_TRANSFERUSBD_TRANSFER_DIRECTION_OUTUSBD_TRANSFER_DIRECTION_INUSBD_TRANSFER_DIRECTIONUSBD_TRANSFER_DIRECTION_FLAGVALID_TRANSFER_FLAGS_MASKUSBD_ISO_START_FRAME_RANGEUSBD_STATUSUSBD_SUCCESSUSBD_PENDINGUSBD_STATUS_SUCCESSUSBD_STATUS_PORT_OPERATION_PENDINGUSBD_STATUS_PENDINGUSBD_STATUS_CRCUSBD_STATUS_BTSTUFFUSBD_STATUS_DATA_TOGGLE_MISMATCHUSBD_STATUS_STALL_PIDUSBD_STATUS_DEV_NOT_RESPONDINGUSBD_STATUS_PID_CHECK_FAILUREUSBD_STATUS_UNEXPECTED_PIDUSBD_STATUS_DATA_OVERRUNUSBD_STATUS_DATA_UNDERRUNUSBD_STATUS_RESERVED1USBD_STATUS_RESERVED2USBD_STATUS_BUFFER_OVERRUNUSBD_STATUS_BUFFER_UNDERRUNUSBD_STATUS_NOT_ACCESSEDUSBD_STATUS_FIFOUSBD_STATUS_XACT_ERRORUSBD_STATUS_BABBLE_DETECTEDUSBD_STATUS_DATA_BUFFER_ERRORUSBD_STATUS_NO_PING_RESPONSEUSBD_STATUS_INVALID_STREAM_TYPEUSBD_STATUS_INVALID_STREAM_IDUSBD_STATUS_ENDPOINT_HALTEDUSBD_STATUS_INVALID_URB_FUNCTIONUSBD_STATUS_INVALID_PARAMETERUSBD_STATUS_ERROR_BUSYUSBD_STATUS_INVALID_PIPE_HANDLEUSBD_STATUS_NO_BANDWIDTHUSBD_STATUS_INTERNAL_HC_ERRORUSBD_STATUS_ERROR_SHORT_TRANSFERUSBD_STATUS_BAD_START_FRAMEUSBD_STATUS_ISOCH_REQUEST_FAILEDUSBD_STATUS_FRAME_CONTROL_OWNEDUSBD_STATUS_FRAME_CONTROL_NOT_OWNEDUSBD_STATUS_NOT_SUPPORTEDUSBD_STATUS_INAVLID_CONFIGURATION_DESCRIPTORUSBD_STATUS_INVALID_CONFIGURATION_DESCRIPTORUSBD_STATUS_INSUFFICIENT_RESOURCESUSBD_STATUS_SET_CONFIG_FAILEDUSBD_STATUS_BUFFER_TOO_SMALLUSBD_STATUS_INTERFACE_NOT_FOUNDUSBD_STATUS_INAVLID_PIPE_FLAGSUSBD_STATUS_TIMEOUTUSBD_STATUS_DEVICE_GONEUSBD_STATUS_STATUS_NOT_MAPPEDUSBD_STATUS_HUB_INTERNAL_ERRORUSBD_STATUS_CANCELEDUSBD_STATUS_ISO_NOT_ACCESSED_BY_HWUSBD_STATUS_ISO_TD_ERRORUSBD_STATUS_ISO_NA_LATE_USBPORTUSBD_STATUS_ISO_NOT_ACCESSED_LATEUSBD_STATUS_BAD_DESCRIPTORUSBD_STATUS_BAD_DESCRIPTOR_BLENUSBD_STATUS_BAD_DESCRIPTOR_TYPEUSBD_STATUS_BAD_INTERFACE_DESCRIPTORUSBD_STATUS_BAD_ENDPOINT_DESCRIPTORUSBD_STATUS_BAD_INTERFACE_ASSOC_DESCRIPTORUSBD_STATUS_BAD_CONFIG_DESC_LENGTHUSBD_STATUS_BAD_NUMBER_OF_INTERFACESUSBD_STATUS_BAD_NUMBER_OF_ENDPOINTSUSBD_STATUS_BAD_ENDPOINT_ADDRESSUSBD_PIPE_HANDLEUSBD_CONFIGURATION_HANDLEUSBD_INTERFACE_HANDLEUSBD_DEFAULT_MAXIMUM_TRANSFER_SIZEPUSBD_VERSION_INFORMATIONUSBD_VERSION_INFORMATIONUSBD_PIPE_DIRECTION_INUSBD_PIPE_INFORMATIONPUSBD_DEVICE_INFORMATIONUSBD_DEVICE_INFORMATIONPUSBD_PIPE_INFORMATIONUSBD_PF_CHANGE_MAX_PACKETUSBD_PF_SHORT_PACKET_OPTUSBD_PF_ENABLE_RT_THREAD_ACCESSUSBD_PF_MAP_ADD_TRANSFERSUSBD_PF_VALID_MASKPUSBD_INTERFACE_INFORMATIONUSBD_INTERFACE_INFORMATIONOS_STRING_DESCRIPTOR_INDEXMS_GENRE_DESCRIPTOR_INDEXMS_POWER_DESCRIPTOR_INDEXMS_OS_STRING_SIGNATUREMS_OS_FLAGS_CONTAINERIDPOS_STRINGOS_STRINGPUSBD_ISO_PACKET_DESCRIPTORUSBD_ISO_PACKET_DESCRIPTORURB_OPEN_STATIC_STREAMS_VERSION_100PUSBD_STREAM_INFORMATIONUSBD_STREAM_INFORMATIONPURBURB//! USB Definitions.FILE_DEVICE_USBHCD_DIAGNOSTIC_MODE_OFFHCD_DIAGNOSTIC_MODE_ONHCD_DISABLE_PORTHCD_ENABLE_PORTHCD_GET_DRIVERKEY_NAMEHCD_GET_ROOT_HUB_NAMEHCD_GET_STATS_1HCD_GET_STATS_2USB_CYCLE_PORTUSB_DIAG_IGNORE_HUBS_OFFUSB_DIAG_IGNORE_HUBS_ONUSB_ENABLE_PORTUSB_FAIL_GET_STATUSUSB_GET_BUSGUID_INFOUSB_GET_BUS_INFOUSB_GET_CONTROLLER_NAMEUSB_GET_DESCRIPTOR_FROM_NODE_CONNECTIONUSB_GET_DEVICE_CHARACTERISTICSUSB_GET_DEVICE_HANDLEUSB_GET_DEVICE_HANDLE_EXUSB_GET_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNCUSB_GET_HUB_CAPABILITIESUSB_GET_HUB_CAPABILITIES_EXUSB_GET_HUB_CONFIG_INFOUSB_GET_HUB_COUNTUSB_GET_HUB_INFORMATION_EXUSB_GET_HUB_NAMEUSB_GET_NODE_CONNECTION_ATTRIBUTESUSB_GET_NODE_CONNECTION_DRIVERKEY_NAMEUSB_GET_NODE_CONNECTION_INFORMATIONUSB_GET_NODE_CONNECTION_INFORMATION_EXUSB_GET_NODE_CONNECTION_INFORMATION_EX_V2USB_GET_NODE_CONNECTION_NAMEUSB_GET_NODE_INFORMATIONUSB_GET_PARENT_HUB_INFOUSB_GET_PORT_CONNECTOR_PROPERTIESUSB_GET_PORT_STATUSUSB_GET_ROOTHUB_PDOUSB_GET_TOPOLOGY_ADDRESSUSB_GET_TRANSPORT_CHARACTERISTICSUSB_GET_TT_DEVICE_HANDLEUSB_HUB_CYCLE_PORTUSB_IDLE_NOTIFICATIONUSB_IDLE_NOTIFICATION_EXUSB_NOTIFY_ON_TRANSPORT_CHARACTERISTICS_CHANGEUSB_RECORD_FAILUREUSB_REGISTER_COMPOSITE_DEVICEUSB_REGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGEUSB_REQUEST_REMOTE_WAKE_NOTIFICATIONUSB_REQ_GLOBAL_RESUMEUSB_REQ_GLOBAL_SUSPENDUSB_RESET_HUBUSB_RESET_PORTUSB_START_TRACKING_FOR_TIME_SYNCUSB_STOP_TRACKING_FOR_TIME_SYNCUSB_SUBMIT_URBUSB_UNREGISTER_COMPOSITE_DEVICEUSB_UNREGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGEUSB_30_HUB_DESCRIPTORUSB_CONFIGURATION_DESCRIPTORUSB_DEVICE_SPEEDUSB_ENDPOINT_DESCRIPTORUSB_HUB_DESCRIPTORFILE_DEVICE_USBEXIOCTL_INTERNAL_USB_SUBMIT_URBIOCTL_INTERNAL_USB_RESET_PORTIOCTL_INTERNAL_USB_GET_ROOTHUB_PDOUSBD_PORT_ENABLEDUSBD_PORT_CONNECTEDIOCTL_INTERNAL_USB_GET_PORT_STATUSIOCTL_INTERNAL_USB_ENABLE_PORTIOCTL_INTERNAL_USB_GET_HUB_COUNTIOCTL_INTERNAL_USB_CYCLE_PORTIOCTL_INTERNAL_USB_GET_HUB_NAMEIOCTL_INTERNAL_USB_GET_BUS_INFOIOCTL_INTERNAL_USB_GET_CONTROLLER_NAMEIOCTL_INTERNAL_USB_GET_BUSGUID_INFOIOCTL_INTERNAL_USB_GET_PARENT_HUB_INFOIOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATIONIOCTL_INTERNAL_USB_GET_DEVICE_HANDLEIOCTL_INTERNAL_USB_NOTIFY_IDLE_READYIOCTL_INTERNAL_USB_REQ_GLOBAL_SUSPENDIOCTL_INTERNAL_USB_REQ_GLOBAL_RESUMEPUSB_START_FAILDATAUSB_START_FAILDATAIOCTL_INTERNAL_USB_RECORD_FAILUREIOCTL_INTERNAL_USB_GET_DEVICE_HANDLE_EXIOCTL_INTERNAL_USB_GET_TT_DEVICE_HANDLEPUSB_TOPOLOGY_ADDRESSUSB_TOPOLOGY_ADDRESSIOCTL_INTERNAL_USB_GET_TOPOLOGY_ADDRESSIOCTL_INTERNAL_USB_GET_DEVICE_CONFIG_INFOIOCTL_INTERNAL_USB_REGISTER_COMPOSITE_DEVICEIOCTL_INTERNAL_USB_UNREGISTER_COMPOSITE_DEVICEIOCTL_INTERNAL_USB_REQUEST_REMOTE_WAKE_NOTIFICATIONIOCTL_INTERNAL_USB_FAIL_GET_STATUS_FROM_DEVICEIOCTL_USB_HCD_GET_STATS_1IOCTL_USB_HCD_GET_STATS_2IOCTL_USB_HCD_DISABLE_PORTIOCTL_USB_HCD_ENABLE_PORTIOCTL_USB_DIAGNOSTIC_MODE_ONIOCTL_USB_DIAGNOSTIC_MODE_OFFIOCTL_USB_GET_ROOT_HUB_NAMEIOCTL_GET_HCD_DRIVERKEY_NAMEIOCTL_USB_GET_NODE_INFORMATIONIOCTL_USB_GET_NODE_CONNECTION_INFORMATIONIOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTIONIOCTL_USB_GET_NODE_CONNECTION_NAMEIOCTL_USB_DIAG_IGNORE_HUBS_ONIOCTL_USB_DIAG_IGNORE_HUBS_OFFIOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAMEIOCTL_USB_GET_HUB_CAPABILITIESIOCTL_USB_HUB_CYCLE_PORTIOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTESIOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EXIOCTL_USB_RESET_HUBIOCTL_USB_GET_HUB_CAPABILITIES_EXIOCTL_USB_GET_HUB_INFORMATION_EXIOCTL_USB_GET_PORT_CONNECTOR_PROPERTIESIOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2IOCTL_USB_GET_TRANSPORT_CHARACTERISTICSIOCTL_USB_REGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGEIOCTL_USB_NOTIFY_ON_TRANSPORT_CHARACTERISTICS_CHANGEIOCTL_USB_UNREGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGEIOCTL_USB_START_TRACKING_FOR_TIME_SYNCIOCTL_USB_GET_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNCIOCTL_USB_STOP_TRACKING_FOR_TIME_SYNCIOCTL_USB_GET_DEVICE_CHARACTERISTICSPUSB_HUB_INFORMATIONUSB_HUB_INFORMATIONPUSB_MI_PARENT_INFORMATIONUSB_MI_PARENT_INFORMATIONPUSB_NODE_INFORMATIONUSB_NODE_INFORMATIONPUSB_PIPE_INFOUSB_PIPE_INFOPUSB_CONNECTION_STATUSUSB_CONNECTION_STATUSPUSB_NODE_CONNECTION_INFORMATIONUSB_NODE_CONNECTION_INFORMATIONPUSB_NODE_CONNECTION_DRIVERKEY_NAMEUSB_NODE_CONNECTION_DRIVERKEY_NAMEPUSB_NODE_CONNECTION_NAMEUSB_NODE_CONNECTION_NAMEPUSB_HUB_NAMEUSB_HUB_NAMEPUSB_ROOT_HUB_NAMEUSB_ROOT_HUB_NAMEPUSB_HCD_DRIVERKEY_NAMEUSB_HCD_DRIVERKEY_NAMEPUSB_DESCRIPTOR_REQUESTUSB_DESCRIPTOR_REQUESTPUSB_HUB_CAPABILITIESUSB_HUB_CAPABILITIESPUSB_NODE_CONNECTION_ATTRIBUTESUSB_NODE_CONNECTION_ATTRIBUTESPUSB_NODE_CONNECTION_INFORMATION_EXUSB_NODE_CONNECTION_INFORMATION_EXPUSB_HUB_CAP_FLAGSUSB_HUB_CAP_FLAGSPUSB_HUB_CAPABILITIES_EXUSB_HUB_CAPABILITIES_EXPUSB_CYCLE_PORT_PARAMSUSB_CYCLE_PORT_PARAMSPUSB_ID_STRINGUSB_ID_STRINGPUSB_HUB_DEVICE_UXD_SETTINGSUSB_HUB_DEVICE_UXD_SETTINGSPHUB_DEVICE_CONFIG_INFOHUB_DEVICE_CONFIG_INFOPHCD_STAT_COUNTERSHCD_STAT_COUNTERSPHCD_ISO_STAT_COUNTERSHCD_ISO_STAT_COUNTERSPHCD_STAT_INFORMATION_1HCD_STAT_INFORMATION_1PHCD_STAT_INFORMATION_2HCD_STAT_INFORMATION_2WMI_USB_DRIVER_INFORMATIONWMI_USB_DRIVER_NOTIFICATIONWMI_USB_POWER_DEVICE_ENABLEWMI_USB_HUB_NODE_INFORMATIONWMI_USB_PERFORMANCE_INFORMATIONWMI_USB_DEVICE_NODE_INFORMATIONPUSB_NOTIFICATIONUSB_NOTIFICATIONPUSB_CONNECTION_NOTIFICATIONUSB_CONNECTION_NOTIFICATIONPUSB_BUS_NOTIFICATIONUSB_BUS_NOTIFICATIONPUSB_ACQUIRE_INFOUSB_ACQUIRE_INFOPUSB_WMI_DEVICE_NODE_TYPEUSB_WMI_DEVICE_NODE_TYPEPUSB_DEVICE_STATEUSB_DEVICE_STATEPUSB_HUB_PORT_INFORMATIONUSB_HUB_PORT_INFORMATIONPUSB_HUB_DEVICE_INFOUSB_HUB_DEVICE_INFOPUSB_COMPOSITE_FUNCTION_INFOUSB_COMPOSITE_FUNCTION_INFOPUSB_COMPOSITE_DEVICE_INFOUSB_COMPOSITE_DEVICE_INFOPUSB_CONTROLLER_DEVICE_INFOUSB_CONTROLLER_DEVICE_INFOPUSB_DEVICE_INFOUSB_DEVICE_INFOPUSB_DEVICE_NODE_INFOUSB_DEVICE_NODE_INFOPUSB_DEVICE_PERFORMANCE_INFOUSB_DEVICE_PERFORMANCE_INFOPUSB_HUB_INFORMATION_EXUSB_HUB_INFORMATION_EXPUSB_PORT_PROPERTIESUSB_PORT_PROPERTIESPUSB_PORT_CONNECTOR_PROPERTIESUSB_PORT_CONNECTOR_PROPERTIESPUSB_PROTOCOLSUSB_PROTOCOLSPUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGSUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGSPUSB_NODE_CONNECTION_INFORMATION_EX_V2USB_NODE_CONNECTION_INFORMATION_EX_V2USB_TRANSPORT_CHARACTERISTICS_VERSION_1USB_TRANSPORT_CHARACTERISTICS_LATENCY_AVAILABLEUSB_TRANSPORT_CHARACTERISTICS_BANDWIDTH_AVAILABLEPUSB_TRANSPORT_CHARACTERISTICSUSB_TRANSPORT_CHARACTERISTICSUSB_REGISTER_FOR_TRANSPORT_LATENCY_CHANGEUSB_REGISTER_FOR_TRANSPORT_BANDWIDTH_CHANGEPUSB_TRANSPORT_CHARACTERISTICS_CHANGE_REGISTRATIONUSB_TRANSPORT_CHARACTERISTICS_CHANGE_REGISTRATIONPUSB_TRANSPORT_CHARACTERISTICS_CHANGE_NOTIFICATIONUSB_TRANSPORT_CHARACTERISTICS_CHANGE_NOTIFICATIONPUSB_TRANSPORT_CHARACTERISTICS_CHANGE_UNREGISTRATIONUSB_TRANSPORT_CHARACTERISTICS_CHANGE_UNREGISTRATIONUSB_DEVICE_CHARACTERISTICS_VERSION_1USB_DEVICE_CHARACTERISTICS_MAXIMUM_PATH_DELAYS_AVAILABLEPUSB_DEVICE_CHARACTERISTICSUSB_DEVICE_CHARACTERISTICSPUSB_START_TRACKING_FOR_TIME_SYNC_INFORMATIONUSB_START_TRACKING_FOR_TIME_SYNC_INFORMATIONPUSB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATIONUSB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATIONPUSB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATIONUSB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATIONFILE_DEVICE_UNKNOWNHCD_USER_REQUESTHCD_TRACE_READ_REQUESTGUID_CLASS_USBHUBGUID_CLASS_USB_DEVICEGUID_CLASS_USB_HOST_CONTROLLERUSB_CTLUSB_KERNEL_CTLUSB_KERNEL_CTL_BUFFERED// No calling convention was specified in the codePUSB_IDLE_CALLBACK_INFOUSB_IDLE_CALLBACK_INFO//! Common header file for all USB IOCTLs defined for//! the core stack. We define them in this single header file//! so that we can maintain backward compatibilty with older//! versions of the stack.//98PDEVICE_DESCRIPTORDEVICE_DESCRIPTORFILE_DEVICE_USB_SCAN//132IOCTL_INDEXIOCTL_GET_USB_DESCRIPTOR//143PBM_REQUEST_TYPEBM_REQUEST_TYPEPUSB_DEFAULT_PIPE_SETUP_PACKETUSB_DEFAULT_PIPE_SETUP_PACKETBMREQUEST_HOST_TO_DEVICEBMREQUEST_DEVICE_TO_HOSTBMREQUEST_STANDARDBMREQUEST_CLASSBMREQUEST_VENDORBMREQUEST_TO_DEVICEBMREQUEST_TO_INTERFACEBMREQUEST_TO_ENDPOINTBMREQUEST_TO_OTHERUSB_DESCRIPTOR_MAKE_TYPE_AND_INDEXUSB_REQUEST_GET_STATUSUSB_REQUEST_CLEAR_FEATUREUSB_REQUEST_SET_FEATUREUSB_REQUEST_SET_ADDRESSUSB_REQUEST_GET_DESCRIPTORUSB_REQUEST_SET_DESCRIPTORUSB_REQUEST_GET_CONFIGURATIONUSB_REQUEST_SET_CONFIGURATIONUSB_REQUEST_GET_INTERFACEUSB_REQUEST_SET_INTERFACEUSB_REQUEST_SYNC_FRAMEUSB_REQUEST_SET_SELUSB_REQUEST_ISOCH_DELAYUSB_DEVICE_DESCRIPTOR_TYPEUSB_CONFIGURATION_DESCRIPTOR_TYPEUSB_STRING_DESCRIPTOR_TYPEUSB_INTERFACE_DESCRIPTOR_TYPEUSB_ENDPOINT_DESCRIPTOR_TYPEUSB_DEVICE_QUALIFIER_DESCRIPTOR_TYPEUSB_OTHER_SPEED_CONFIGURATION_DESCRIPTOR_TYPEUSB_INTERFACE_POWER_DESCRIPTOR_TYPEUSB_OTG_DESCRIPTOR_TYPEUSB_DEBUG_DESCRIPTOR_TYPEUSB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPEUSB_BOS_DESCRIPTOR_TYPEUSB_DEVICE_CAPABILITY_DESCRIPTOR_TYPEUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR_TYPEUSB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR_TYPEUSB_RESERVED_DESCRIPTOR_TYPEUSB_CONFIG_POWER_DESCRIPTOR_TYPEUSB_FEATURE_ENDPOINT_STALLUSB_FEATURE_REMOTE_WAKEUPUSB_FEATURE_TEST_MODEUSB_FEATURE_FUNCTION_SUSPENDUSB_FEATURE_U1_ENABLEUSB_FEATURE_U2_ENABLEUSB_FEATURE_LTM_ENABLEUSB_FEATURE_LDM_ENABLEUSB_FEATURE_BATTERY_WAKE_MASKUSB_FEATURE_OS_IS_PD_AWAREUSB_FEATURE_POLICY_MODEUSB_FEATURE_CHARGING_POLICYUSB_CHARGING_POLICY_DEFAULTUSB_CHARGING_POLICY_ICCHPFUSB_CHARGING_POLICY_ICCLPFUSB_CHARGING_POLICY_NO_POWERUSB_STATUS_PORT_STATUSUSB_STATUS_PD_STATUSUSB_STATUS_EXT_PORT_STATUSUSB_GETSTATUS_SELF_POWEREDUSB_GETSTATUS_REMOTE_WAKEUP_ENABLEDUSB_GETSTATUS_U1_ENABLEUSB_GETSTATUS_U2_ENABLEUSB_GETSTATUS_LTM_ENABLEPUSB_DEVICE_STATUSUSB_DEVICE_STATUSPUSB_INTERFACE_STATUSUSB_INTERFACE_STATUSPUSB_ENDPOINT_STATUSUSB_ENDPOINT_STATUSPUSB_COMMON_DESCRIPTORUSB_COMMON_DESCRIPTORPUSB_DEVICE_DESCRIPTORUSB_DEVICE_CLASS_RESERVEDUSB_DEVICE_CLASS_AUDIOUSB_DEVICE_CLASS_COMMUNICATIONSUSB_DEVICE_CLASS_HUMAN_INTERFACEUSB_DEVICE_CLASS_MONITORUSB_DEVICE_CLASS_PHYSICAL_INTERFACEUSB_DEVICE_CLASS_POWERUSB_DEVICE_CLASS_IMAGEUSB_DEVICE_CLASS_PRINTERUSB_DEVICE_CLASS_STORAGEUSB_DEVICE_CLASS_HUBUSB_DEVICE_CLASS_CDC_DATAUSB_DEVICE_CLASS_SMART_CARDUSB_DEVICE_CLASS_CONTENT_SECURITYUSB_DEVICE_CLASS_VIDEOUSB_DEVICE_CLASS_PERSONAL_HEALTHCAREUSB_DEVICE_CLASS_AUDIO_VIDEOUSB_DEVICE_CLASS_BILLBOARDUSB_DEVICE_CLASS_DIAGNOSTIC_DEVICEUSB_DEVICE_CLASS_WIRELESS_CONTROLLERUSB_DEVICE_CLASS_MISCELLANEOUSUSB_DEVICE_CLASS_APPLICATION_SPECIFICUSB_DEVICE_CLASS_VENDOR_SPECIFICPUSB_DEVICE_QUALIFIER_DESCRIPTORUSB_DEVICE_QUALIFIER_DESCRIPTORPUSB_BOS_DESCRIPTORUSB_BOS_DESCRIPTORUSB_DEVICE_CAPABILITY_WIRELESS_USBUSB_DEVICE_CAPABILITY_USB20_EXTENSIONUSB_DEVICE_CAPABILITY_SUPERSPEED_USBUSB_DEVICE_CAPABILITY_CONTAINER_IDUSB_DEVICE_CAPABILITY_PLATFORMUSB_DEVICE_CAPABILITY_POWER_DELIVERYUSB_DEVICE_CAPABILITY_BATTERY_INFOUSB_DEVICE_CAPABILITY_PD_CONSUMER_PORTUSB_DEVICE_CAPABILITY_PD_PROVIDER_PORTUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USBUSB_DEVICE_CAPABILITY_PRECISION_TIME_MEASUREMENTUSB_DEVICE_CAPABILITY_BILLBOARDUSB_DEVICE_CAPABILITY_CONFIGURATION_SUMMARYPUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTORUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTORUSB_DEVICE_CAPABILITY_USB20_EXTENSION_BMATTRIBUTES_RESERVED_MASKPUSB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTORUSB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTORPUSB_DEVICE_CAPABILITY_PD_CONSUMER_PORT_DESCRIPTORUSB_DEVICE_CAPABILITY_PD_CONSUMER_PORT_DESCRIPTORPUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTORUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTORUSB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_RESERVED_MASKUSB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_LTM_CAPABLEUSB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_RESERVED_MASKUSB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_LOWUSB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_FULLUSB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_HIGHUSB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_SUPERUSB_DEVICE_CAPABILITY_SUPERSPEED_U1_DEVICE_EXIT_MAX_VALUEUSB_DEVICE_CAPABILITY_SUPERSPEED_U2_DEVICE_EXIT_MAX_VALUEUSB_DEVICE_CAPABILITY_MAX_U1_LATENCYUSB_DEVICE_CAPABILITY_MAX_U2_LATENCYUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_BPSUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_KBPSUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_MBPSUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_GBPSUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_SYMMETRICUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_ASYMMETRICUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_RXUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_TXUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_PROTOCOL_SSUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_PROTOCOL_SSPPUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTORUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTORPUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTORUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTORPUSB_DEVICE_CAPABILITY_CONFIGURATION_SUMMARY_DESCRIPTORUSB_DEVICE_CAPABILITY_CONFIGURATION_SUMMARY_DESCRIPTORPUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTORUSB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTORPUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTORUSB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTORPUSB_DEVICE_CAPABILITY_DESCRIPTORUSB_DEVICE_CAPABILITY_DESCRIPTORUSB_CONFIG_POWERED_MASKUSB_CONFIG_BUS_POWEREDUSB_CONFIG_SELF_POWEREDUSB_CONFIG_REMOTE_WAKEUPUSB_CONFIG_RESERVEDPUSB_INTERFACE_ASSOCIATION_DESCRIPTORUSB_INTERFACE_ASSOCIATION_DESCRIPTORPUSB_INTERFACE_DESCRIPTORUSB_INTERFACE_DESCRIPTORPUSB_ENDPOINT_DESCRIPTORUSB_ENDPOINT_DIRECTION_OUTUSB_ENDPOINT_DIRECTION_INUSB_ENDPOINT_ADDRESS_MASKUSB_ENDPOINT_TYPE_MASKUSB_ENDPOINT_TYPE_CONTROLUSB_ENDPOINT_TYPE_ISOCHRONOUSUSB_ENDPOINT_TYPE_BULKUSB_ENDPOINT_TYPE_INTERRUPTUSB_ENDPOINT_TYPE_BULK_RESERVED_MASKUSB_ENDPOINT_TYPE_CONTROL_RESERVED_MASKUSB_20_ENDPOINT_TYPE_INTERRUPT_RESERVED_MASKUSB_30_ENDPOINT_TYPE_INTERRUPT_RESERVED_MASKUSB_ENDPOINT_TYPE_ISOCHRONOUS_RESERVED_MASKUSB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_MASKUSB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_PERIODICUSB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_NOTIFICATIONUSB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_RESERVED10USB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_RESERVED11USB_30_ENDPOINT_TYPE_INTERRUPT_USAGEUSB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_MASKUSB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_NO_SYNCHRONIZATIONUSB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_ASYNCHRONOUSUSB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_ADAPTIVEUSB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_SYNCHRONOUSUSB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATIONUSB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_MASKUSB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_DATA_ENDOINTUSB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_FEEDBACK_ENDPOINTUSB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_IMPLICIT_FEEDBACK_DATA_ENDPOINTUSB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_RESERVEDUSB_ENDPOINT_TYPE_ISOCHRONOUS_USAGEPUSB_HIGH_SPEED_MAXPACKETUSB_HIGH_SPEED_MAXPACKETUSB_ENDPOINT_SUPERSPEED_BULK_MAX_PACKET_SIZEUSB_ENDPOINT_SUPERSPEED_CONTROL_MAX_PACKET_SIZEUSB_ENDPOINT_SUPERSPEED_ISO_MAX_PACKET_SIZEUSB_ENDPOINT_SUPERSPEED_INTERRUPT_MAX_PACKET_SIZEPUSB_STRING_DESCRIPTORUSB_STRING_DESCRIPTORMAXIMUM_USB_STRING_LENGTHPUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTORUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTORUSB_SUPERSPEED_ISOCHRONOUS_MAX_MULTIPLIERPUSB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTORUSB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTORUSB_SUPERSPEEDPLUS_ISOCHRONOUS_MIN_BYTESPERINTERVALUSB_SUPERSPEEDPLUS_ISOCHRONOUS_MAX_BYTESPERINTERVALPUSB_HUB_DESCRIPTORUSB_20_HUB_DESCRIPTOR_TYPEPUSB_30_HUB_DESCRIPTORUSB_30_HUB_DESCRIPTOR_TYPEUSB_REQUEST_GET_STATEUSB_REQUEST_CLEAR_TT_BUFFERUSB_REQUEST_RESET_TTUSB_REQUEST_GET_TT_STATEUSB_REQUEST_STOP_TTUSB_REQUEST_SET_HUB_DEPTHUSB_REQUEST_GET_PORT_ERR_COUNTPUSB_HUB_STATUSUSB_HUB_STATUSPUSB_HUB_CHANGEUSB_HUB_CHANGEPUSB_HUB_STATUS_AND_CHANGEUSB_HUB_STATUS_AND_CHANGEPUSB_20_PORT_STATUSUSB_20_PORT_STATUSUSB_PORT_STATUS_CONNECTUSB_PORT_STATUS_ENABLEUSB_PORT_STATUS_SUSPENDUSB_PORT_STATUS_OVER_CURRENTUSB_PORT_STATUS_RESETUSB_PORT_STATUS_POWERUSB_PORT_STATUS_LOW_SPEEDUSB_PORT_STATUS_HIGH_SPEEDPUSB_20_PORT_CHANGEUSB_20_PORT_CHANGEPUSB_30_PORT_STATUSUSB_30_PORT_STATUSPORT_LINK_STATE_U0PORT_LINK_STATE_U1PORT_LINK_STATE_U2PORT_LINK_STATE_U3PORT_LINK_STATE_DISABLEDPORT_LINK_STATE_RX_DETECTPORT_LINK_STATE_INACTIVEPORT_LINK_STATE_POLLINGPORT_LINK_STATE_RECOVERYPORT_LINK_STATE_HOT_RESETPORT_LINK_STATE_COMPLIANCE_MODEPORT_LINK_STATE_LOOPBACKPORT_LINK_STATE_TEST_MODEPUSB_30_PORT_CHANGEUSB_30_PORT_CHANGEPUSB_PORT_STATUSUSB_PORT_STATUSPUSB_PORT_CHANGEUSB_PORT_CHANGEPUSB_PORT_EXT_STATUSUSB_PORT_EXT_STATUSPUSB_PORT_STATUS_AND_CHANGEUSB_PORT_STATUS_AND_CHANGEPUSB_PORT_EXT_STATUS_AND_CHANGEUSB_PORT_EXT_STATUS_AND_CHANGEPUSB_HUB_30_PORT_REMOTE_WAKE_MASKUSB_HUB_30_PORT_REMOTE_WAKE_MASKPUSB_FUNCTION_SUSPEND_OPTIONSUSB_FUNCTION_SUSPEND_OPTIONSUSB_FEATURE_INTERFACE_POWER_D0USB_FEATURE_INTERFACE_POWER_D1USB_FEATURE_INTERFACE_POWER_D2USB_FEATURE_INTERFACE_POWER_D3USB_SUPPORT_D0_COMMANDUSB_SUPPORT_D1_COMMANDUSB_SUPPORT_D2_COMMANDUSB_SUPPORT_D3_COMMANDUSB_SUPPORT_D1_WAKEUPUSB_SUPPORT_D2_WAKEUPPUSB_CONFIGURATION_POWER_DESCRIPTORUSB_CONFIGURATION_POWER_DESCRIPTORPUSB_INTERFACE_POWER_DESCRIPTORUSB_INTERFACE_POWER_DESCRIPTOR//! USB Spec Definitions.HGDIOBJHCURSORCOLORREFLPCOLORREFHFILE_ERRORPRECTNPRECTPRECTLRECTLLPRECTLLPCRECTLPPOINTNPPOINTPPOINTLPSIZESIZELPSIZELLPSIZELPPOINTSLPPOINTSDM_UPDATEDM_COPYDM_PROMPTDM_MODIFYDM_IN_BUFFERDM_IN_PROMPTDM_OUT_BUFFERDM_OUT_DEFAULTDC_FIELDSDC_PAPERSDC_PAPERSIZEDC_MINEXTENTDC_MAXEXTENTDC_BINSDC_DUPLEXDC_SIZEDC_EXTRADC_VERSIONDC_DRIVERDC_BINNAMESDC_ENUMRESOLUTIONSDC_FILEDEPENDENCIESDC_TRUETYPEDC_PAPERNAMESDC_ORIENTATIONDC_COPIESDPI_AWARENESS_CONTEXT_UNAWAREDPI_AWARENESS_CONTEXT_SYSTEM_AWAREDPI_AWARENESS_CONTEXT_PER_MONITOR_AWAREDPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED//! Basic Windows Type DefinitionsDOT11_AUTH_ALGORITHMDOT11_AUTH_CIPHER_PAIRDOT11_BSS_TYPEDOT11_CIPHER_ALGORITHMDOT11_SSIDPDOT11_AUTH_CIPHER_PAIRDOT11_MAC_ADDRESSPDOT11_MAC_ADDRESSPDOT11_BSSID_LISTDOT11_BSSID_LISTDOT11_BSSID_LIST_REVISION_1DOT11_HESSID_LENGTHDOT11_HESSIDPDOT11_HESSIDPDOT11_PHY_TYPEDOT11_PHY_TYPEDOT11_RATE_SET_MAX_LENGTHPDOT11_RATE_SETDOT11_RATE_SETDOT11_COUNTRY_OR_REGION_STRINGPDOT11_COUNTRY_OR_REGION_STRINGDOT11_DIALOG_TOKENDOT11_WFD_STATUS_CODEDOT11_WFD_MINOR_REASON_CODEDOT11_WFD_SERVICE_HASHDOT11_WFD_SERVICE_NAME_MAX_LENGTHDOT11_WFD_APS2_SERVICE_TYPE_MAX_LENGTHDOT11_WFD_ASP2_INSTANCE_NAME_MAX_LENGTHDOT11_WFD_SERVICE_INFORMATION_MAX_LENGTHDOT11_MAX_REQUESTED_SERVICE_INFORMATION_LENGTHDOT11_WFD_SESSION_INFO_MAX_LENGTHPDOT11_WFD_SESSION_INFODOT11_WFD_SESSION_INFONDIS_PACKET_TYPE_MEDIA_SPECIFIC_MASKNDIS_PACKET_TYPE_802_11_DIRECTED_DATANDIS_PACKET_TYPE_802_11_BROADCAST_DATANDIS_PACKET_TYPE_802_11_MULTICAST_DATANDIS_PACKET_TYPE_802_11_ALL_MULTICAST_DATANDIS_PACKET_TYPE_802_11_PROMISCUOUS_DATANDIS_PACKET_TYPE_802_11_RAW_DATANDIS_PACKET_TYPE_802_11_DIRECTED_MGMTNDIS_PACKET_TYPE_802_11_BROADCAST_MGMTNDIS_PACKET_TYPE_802_11_MULTICAST_MGMTNDIS_PACKET_TYPE_802_11_ALL_MULTICAST_MGMTNDIS_PACKET_TYPE_802_11_PROMISCUOUS_MGMTNDIS_PACKET_TYPE_802_11_RAW_MGMTNDIS_PACKET_TYPE_802_11_DIRECTED_CTRLNDIS_PACKET_TYPE_802_11_BROADCAST_CTRLNDIS_PACKET_TYPE_802_11_PROMISCUOUS_CTRLNDIS_PACKET_TYPE_ALL_802_11_FILTERSDOT11_MAX_PDU_SIZEDOT11_MIN_PDU_SIZEDOT11_MAX_NUM_DEFAULT_KEYDOT11_MAX_NUM_DEFAULT_KEY_MFPOID_DOT11_NDIS_STARTNWF_MANDATORY_OIDNWF_OPTIONAL_OIDNWF_OPERATIONAL_OIDNWF_STATISTICS_OIDNWF_DEFINE_OIDOID_DOT11_OFFLOAD_CAPABILITYDOT11_HW_WEP_SUPPORTED_TXDOT11_HW_WEP_SUPPORTED_RXDOT11_HW_FRAGMENTATION_SUPPORTEDDOT11_HW_DEFRAGMENTATION_SUPPORTEDDOT11_HW_MSDU_AUTH_SUPPORTED_TXDOT11_HW_MSDU_AUTH_SUPPORTED_RXDOT11_CONF_ALGO_WEP_RC4DOT11_CONF_ALGO_TKIPDOT11_AUTH_ALGO_MICHAELPDOT11_OFFLOAD_CAPABILITYDOT11_OFFLOAD_CAPABILITYOID_DOT11_CURRENT_OFFLOAD_CAPABILITYPDOT11_CURRENT_OFFLOAD_CAPABILITYDOT11_CURRENT_OFFLOAD_CAPABILITYOID_DOT11_WEP_OFFLOADPDOT11_OFFLOAD_TYPEDOT11_OFFLOAD_TYPEPDOT11_IV48_COUNTERDOT11_IV48_COUNTERPDOT11_WEP_OFFLOADDOT11_WEP_OFFLOADOID_DOT11_WEP_UPLOADPDOT11_WEP_UPLOADDOT11_WEP_UPLOADOID_DOT11_DEFAULT_WEP_OFFLOADPDOT11_KEY_DIRECTIONDOT11_KEY_DIRECTIONPDOT11_DEFAULT_WEP_OFFLOADDOT11_DEFAULT_WEP_OFFLOADOID_DOT11_DEFAULT_WEP_UPLOADPDOT11_DEFAULT_WEP_UPLOADDOT11_DEFAULT_WEP_UPLOADOID_DOT11_MPDU_MAX_LENGTHOID_DOT11_OPERATION_MODE_CAPABILITYDOT11_OPERATION_MODE_UNKNOWNDOT11_OPERATION_MODE_STATIONDOT11_OPERATION_MODE_APDOT11_OPERATION_MODE_EXTENSIBLE_STATIONDOT11_OPERATION_MODE_EXTENSIBLE_APDOT11_OPERATION_MODE_WFD_DEVICEDOT11_OPERATION_MODE_WFD_GROUP_OWNERDOT11_OPERATION_MODE_WFD_CLIENTDOT11_OPERATION_MODE_MANUFACTURINGDOT11_OPERATION_MODE_NETWORK_MONITORPDOT11_OPERATION_MODE_CAPABILITYDOT11_OPERATION_MODE_CAPABILITYOID_DOT11_CURRENT_OPERATION_MODEPDOT11_CURRENT_OPERATION_MODEDOT11_CURRENT_OPERATION_MODEOID_DOT11_CURRENT_PACKET_FILTERDOT11_PACKET_TYPE_DIRECTED_CTRLDOT11_PACKET_TYPE_DIRECTED_MGMTDOT11_PACKET_TYPE_DIRECTED_DATADOT11_PACKET_TYPE_MULTICAST_CTRLDOT11_PACKET_TYPE_MULTICAST_MGMTDOT11_PACKET_TYPE_MULTICAST_DATADOT11_PACKET_TYPE_BROADCAST_CTRLDOT11_PACKET_TYPE_BROADCAST_MGMTDOT11_PACKET_TYPE_BROADCAST_DATADOT11_PACKET_TYPE_PROMISCUOUS_CTRLDOT11_PACKET_TYPE_PROMISCUOUS_MGMTDOT11_PACKET_TYPE_PROMISCUOUS_DATADOT11_PACKET_TYPE_ALL_MULTICAST_CTRLDOT11_PACKET_TYPE_ALL_MULTICAST_MGMTDOT11_PACKET_TYPE_ALL_MULTICAST_DATADOT11_PACKET_TYPE_RESERVEDOID_DOT11_ATIM_WINDOWOID_DOT11_SCAN_REQUESTPDOT11_SCAN_TYPEDOT11_SCAN_TYPEPDOT11_SCAN_REQUESTDOT11_SCAN_REQUESTPCH_DESCRIPTION_TYPECH_DESCRIPTION_TYPEPDOT11_PHY_TYPE_INFODOT11_PHY_TYPE_INFOPDOT11_SCAN_REQUEST_V2DOT11_SCAN_REQUEST_V2OID_DOT11_CURRENT_PHY_TYPEPDOT11_PHY_TYPE_LISTDOT11_PHY_TYPE_LISTDOT11_PHY_TYPE_LIST_REVISION_1OID_DOT11_JOIN_REQUESTDOT11_CAPABILITY_INFO_ESSDOT11_CAPABILITY_INFO_IBSSDOT11_CAPABILITY_INFO_CF_POLLABLEDOT11_CAPABILITY_INFO_CF_POLL_REQDOT11_CAPABILITY_INFO_PRIVACYDOT11_CAPABILITY_SHORT_PREAMBLEDOT11_CAPABILITY_PBCCDOT11_CAPABILITY_CHANNEL_AGILITYDOT11_CAPABILITY_SHORT_SLOT_TIMEDOT11_CAPABILITY_DSSSOFDMPDOT11_BSS_DESCRIPTIONDOT11_BSS_DESCRIPTIONPDOT11_JOIN_REQUESTDOT11_JOIN_REQUESTOID_DOT11_START_REQUESTPDOT11_START_REQUESTDOT11_START_REQUESTOID_DOT11_UPDATE_IEPDOT11_UPDATE_IE_OPDOT11_UPDATE_IE_OPPDOT11_UPDATE_IEDOT11_UPDATE_IEOID_DOT11_RESET_REQUESTPDOT11_RESET_TYPEDOT11_RESET_TYPEPDOT11_RESET_REQUESTDOT11_RESET_REQUESTOID_DOT11_NIC_POWER_STATEOID_DOT11_OPTIONAL_CAPABILITYPDOT11_OPTIONAL_CAPABILITYDOT11_OPTIONAL_CAPABILITYOID_DOT11_CURRENT_OPTIONAL_CAPABILITYPDOT11_CURRENT_OPTIONAL_CAPABILITYDOT11_CURRENT_OPTIONAL_CAPABILITYOID_DOT11_STATION_IDOID_DOT11_MEDIUM_OCCUPANCY_LIMITOID_DOT11_CF_POLLABLEOID_DOT11_CFP_PERIODOID_DOT11_CFP_MAX_DURATIONOID_DOT11_POWER_MGMT_MODEPDOT11_POWER_MODEDOT11_POWER_MODEDOT11_POWER_SAVE_LEVEL_MAX_PSPDOT11_POWER_SAVE_LEVEL_FAST_PSPPDOT11_POWER_MGMT_MODEDOT11_POWER_MGMT_MODEOID_DOT11_OPERATIONAL_RATE_SETOID_DOT11_BEACON_PERIODOID_DOT11_DTIM_PERIODOID_DOT11_WEP_ICV_ERROR_COUNTOID_DOT11_MAC_ADDRESSOID_DOT11_RTS_THRESHOLDOID_DOT11_SHORT_RETRY_LIMITOID_DOT11_LONG_RETRY_LIMITOID_DOT11_FRAGMENTATION_THRESHOLDOID_DOT11_MAX_TRANSMIT_MSDU_LIFETIMEOID_DOT11_MAX_RECEIVE_LIFETIMEOID_DOT11_COUNTERS_ENTRYPDOT11_COUNTERS_ENTRYDOT11_COUNTERS_ENTRYOID_DOT11_SUPPORTED_PHY_TYPESPDOT11_SUPPORTED_PHY_TYPESDOT11_SUPPORTED_PHY_TYPESOID_DOT11_CURRENT_REG_DOMAINDOT11_REG_DOMAIN_OTHERDOT11_REG_DOMAIN_FCCDOT11_REG_DOMAIN_DOCDOT11_REG_DOMAIN_ETSIDOT11_REG_DOMAIN_SPAINDOT11_REG_DOMAIN_FRANCEDOT11_REG_DOMAIN_MKKOID_DOT11_TEMP_TYPEPDOT11_TEMP_TYPEDOT11_TEMP_TYPEOID_DOT11_CURRENT_TX_ANTENNAOID_DOT11_DIVERSITY_SUPPORTPDOT11_DIVERSITY_SUPPORTDOT11_DIVERSITY_SUPPORTOID_DOT11_CURRENT_RX_ANTENNAOID_DOT11_SUPPORTED_POWER_LEVELSPDOT11_SUPPORTED_POWER_LEVELSDOT11_SUPPORTED_POWER_LEVELSOID_DOT11_CURRENT_TX_POWER_LEVELOID_DOT11_HOP_TIMEOID_DOT11_CURRENT_CHANNEL_NUMBEROID_DOT11_MAX_DWELL_TIMEOID_DOT11_CURRENT_DWELL_TIMEOID_DOT11_CURRENT_SETOID_DOT11_CURRENT_PATTERNOID_DOT11_CURRENT_INDEXOID_DOT11_CURRENT_CHANNELOID_DOT11_CCA_MODE_SUPPORTEDDOT11_CCA_MODE_ED_ONLYDOT11_CCA_MODE_CS_ONLYDOT11_CCA_MODE_ED_and_CSDOT11_CCA_MODE_CS_WITH_TIMERDOT11_CCA_MODE_HRCS_AND_EDOID_DOT11_CURRENT_CCA_MODEOID_DOT11_ED_THRESHOLDOID_DOT11_CCA_WATCHDOG_TIMER_MAXOID_DOT11_CCA_WATCHDOG_COUNT_MAXOID_DOT11_CCA_WATCHDOG_TIMER_MINOID_DOT11_CCA_WATCHDOG_COUNT_MINOID_DOT11_REG_DOMAINS_SUPPORT_VALUEPDOT11_REG_DOMAIN_VALUEDOT11_REG_DOMAIN_VALUEPDOT11_REG_DOMAINS_SUPPORT_VALUEDOT11_REG_DOMAINS_SUPPORT_VALUEOID_DOT11_SUPPORTED_TX_ANTENNAPDOT11_SUPPORTED_ANTENNADOT11_SUPPORTED_ANTENNAPDOT11_SUPPORTED_ANTENNA_LISTDOT11_SUPPORTED_ANTENNA_LISTOID_DOT11_SUPPORTED_RX_ANTENNAOID_DOT11_DIVERSITY_SELECTION_RXPDOT11_DIVERSITY_SELECTION_RXDOT11_DIVERSITY_SELECTION_RXPDOT11_DIVERSITY_SELECTION_RX_LISTDOT11_DIVERSITY_SELECTION_RX_LISTOID_DOT11_SUPPORTED_DATA_RATES_VALUEMAX_NUM_SUPPORTED_RATESMAX_NUM_SUPPORTED_RATES_V2PDOT11_SUPPORTED_DATA_RATES_VALUEDOT11_SUPPORTED_DATA_RATES_VALUEPDOT11_SUPPORTED_DATA_RATES_VALUE_V2DOT11_SUPPORTED_DATA_RATES_VALUE_V2DOT11_SUPPORTED_DATA_RATES_VALUE_V1PDOT11_SUPPORTED_DATA_RATES_VALUE_V1OID_DOT11_CURRENT_FREQUENCYOID_DOT11_TI_THRESHOLDOID_DOT11_FREQUENCY_BANDS_SUPPORTEDDOT11_FREQUENCY_BANDS_LOWERDOT11_FREQUENCY_BANDS_MIDDLEDOT11_FREQUENCY_BANDS_UPPEROID_DOT11_SHORT_PREAMBLE_OPTION_IMPLEMENTEDOID_DOT11_PBCC_OPTION_IMPLEMENTEDOID_DOT11_CHANNEL_AGILITY_PRESENTOID_DOT11_CHANNEL_AGILITY_ENABLEDOID_DOT11_HR_CCA_MODE_SUPPORTEDDOT11_HR_CCA_MODE_ED_ONLYDOT11_HR_CCA_MODE_CS_ONLYDOT11_HR_CCA_MODE_CS_AND_EDDOT11_HR_CCA_MODE_CS_WITH_TIMERDOT11_HR_CCA_MODE_HRCS_AND_EDOID_DOT11_MULTI_DOMAIN_CAPABILITY_IMPLEMENTEDOID_DOT11_MULTI_DOMAIN_CAPABILITY_ENABLEDOID_DOT11_COUNTRY_STRINGPDOT11_MULTI_DOMAIN_CAPABILITY_ENTRYDOT11_MULTI_DOMAIN_CAPABILITY_ENTRYPDOT11_MD_CAPABILITY_ENTRY_LISTDOT11_MD_CAPABILITY_ENTRY_LISTOID_DOT11_MULTI_DOMAIN_CAPABILITYOID_DOT11_EHCC_PRIME_RADIXOID_DOT11_EHCC_NUMBER_OF_CHANNELS_FAMILY_INDEXOID_DOT11_EHCC_CAPABILITY_IMPLEMENTEDOID_DOT11_EHCC_CAPABILITY_ENABLEDOID_DOT11_HOP_ALGORITHM_ADOPTEDPDOT11_HOP_ALGO_ADOPTEDDOT11_HOP_ALGO_ADOPTEDOID_DOT11_RANDOM_TABLE_FLAGOID_DOT11_NUMBER_OF_HOPPING_SETSOID_DOT11_HOP_MODULUSOID_DOT11_HOP_OFFSETOID_DOT11_HOPPING_PATTERNPDOT11_HOPPING_PATTERN_ENTRYDOT11_HOPPING_PATTERN_ENTRYPDOT11_HOPPING_PATTERN_ENTRY_LISTDOT11_HOPPING_PATTERN_ENTRY_LISTOID_DOT11_RANDOM_TABLE_FIELD_NUMBEROID_DOT11_WPA_TSCPDOT11_WPA_TSCDOT11_WPA_TSCOID_DOT11_RSSI_RANGEPDOT11_RSSI_RANGEDOT11_RSSI_RANGEOID_DOT11_RF_USAGEOID_DOT11_NIC_SPECIFIC_EXTENSIONPDOT11_NIC_SPECIFIC_EXTENSIONDOT11_NIC_SPECIFIC_EXTENSIONOID_DOT11_AP_JOIN_REQUESTPDOT11_AP_JOIN_REQUESTDOT11_AP_JOIN_REQUESTOID_DOT11_ERP_PBCC_OPTION_IMPLEMENTEDOID_DOT11_ERP_PBCC_OPTION_ENABLEDOID_DOT11_DSSS_OFDM_OPTION_IMPLEMENTEDOID_DOT11_DSSS_OFDM_OPTION_ENABLEDOID_DOT11_SHORT_SLOT_TIME_OPTION_IMPLEMENTEDOID_DOT11_SHORT_SLOT_TIME_OPTION_ENABLEDOID_DOT11_MAX_MAC_ADDRESS_STATESOID_DOT11_RECV_SENSITIVITY_LISTPDOT11_RECV_SENSITIVITYDOT11_RECV_SENSITIVITYPDOT11_RECV_SENSITIVITY_LISTDOT11_RECV_SENSITIVITY_LISTOID_DOT11_WME_IMPLEMENTEDOID_DOT11_WME_ENABLEDOID_DOT11_WME_AC_PARAMETERSPDOT11_AC_PARAMDOT11_AC_PARAMPDOT11_WME_AC_PARAMETERSDOT11_WME_AC_PARAMETERSPDOT11_WME_AC_PARAMETERS_LISTDOT11_WME_AC_PARAMETERS_LISTOID_DOT11_WME_UPDATE_IEPDOT11_WME_UPDATE_IEDOT11_WME_UPDATE_IEOID_DOT11_QOS_TX_QUEUES_SUPPORTEDOID_DOT11_QOS_TX_DURATIONPDOT11_QOS_TX_DURATIONDOT11_QOS_TX_DURATIONOID_DOT11_QOS_TX_MEDIUM_TIMEPDOT11_QOS_TX_MEDIUM_TIMEDOT11_QOS_TX_MEDIUM_TIMEOID_DOT11_SUPPORTED_OFDM_FREQUENCY_LISTPDOT11_SUPPORTED_OFDM_FREQUENCYDOT11_SUPPORTED_OFDM_FREQUENCYPDOT11_SUPPORTED_OFDM_FREQUENCY_LISTDOT11_SUPPORTED_OFDM_FREQUENCY_LISTOID_DOT11_SUPPORTED_DSSS_CHANNEL_LISTPDOT11_SUPPORTED_DSSS_CHANNELDOT11_SUPPORTED_DSSS_CHANNELPDOT11_SUPPORTED_DSSS_CHANNEL_LISTDOT11_SUPPORTED_DSSS_CHANNEL_LISTPDOT11_BYTE_ARRAYDOT11_BYTE_ARRAYOID_DOT11_AUTO_CONFIG_ENABLEDDOT11_PHY_AUTO_CONFIG_ENABLED_FLAGDOT11_MAC_AUTO_CONFIG_ENABLED_FLAGOID_DOT11_ENUM_BSS_LISTDOT11_BSS_ENTRY_BYTE_ARRAY_REVISION_1PDOT11_BSS_ENTRY_PHY_SPECIFIC_INFODOT11_BSS_ENTRY_PHY_SPECIFIC_INFOPDOT11_BSS_ENTRYDOT11_BSS_ENTRYOID_DOT11_FLUSH_BSS_LISTOID_DOT11_POWER_MGMT_REQUESTDOT11_POWER_SAVING_NO_POWER_SAVINGDOT11_POWER_SAVING_FAST_PSPDOT11_POWER_SAVING_MAX_PSPDOT11_POWER_SAVING_MAXIMUM_LEVELOID_DOT11_DESIRED_SSID_LISTPDOT11_SSID_LISTDOT11_SSID_LISTDOT11_SSID_LIST_REVISION_1OID_DOT11_EXCLUDED_MAC_ADDRESS_LISTPDOT11_MAC_ADDRESS_LISTDOT11_MAC_ADDRESS_LISTDOT11_MAC_ADDRESS_LIST_REVISION_1OID_DOT11_DESIRED_BSSID_LISTOID_DOT11_DESIRED_BSS_TYPEOID_DOT11_PMKID_LISTDOT11_PMKID_VALUEPDOT11_PMKID_ENTRYDOT11_PMKID_ENTRYPDOT11_PMKID_LISTDOT11_PMKID_LISTDOT11_PMKID_LIST_REVISION_1OID_DOT11_CONNECT_REQUESTOID_DOT11_EXCLUDE_UNENCRYPTEDOID_DOT11_STATISTICSDOT11_STATISTICS_UNKNOWNPDOT11_PHY_FRAME_STATISTICSDOT11_PHY_FRAME_STATISTICSPDOT11_MAC_FRAME_STATISTICSDOT11_MAC_FRAME_STATISTICSPDOT11_STATISTICSDOT11_STATISTICSDOT11_STATISTICS_REVISION_1OID_DOT11_PRIVACY_EXEMPTION_LISTPDOT11_PRIVACY_EXEMPTIONDOT11_PRIVACY_EXEMPTIONDOT11_EXEMPT_NO_EXEMPTIONDOT11_EXEMPT_ALWAYSDOT11_EXEMPT_ON_KEY_MAPPING_KEY_UNAVAILABLEDOT11_EXEMPT_UNICASTDOT11_EXEMPT_MULTICASTDOT11_EXEMPT_BOTHPDOT11_PRIVACY_EXEMPTION_LISTDOT11_PRIVACY_EXEMPTION_LISTDOT11_PRIVACY_EXEMPTION_LIST_REVISION_1OID_DOT11_ENABLED_AUTHENTICATION_ALGORITHMPDOT11_AUTH_ALGORITHM_LISTDOT11_AUTH_ALGORITHM_LISTDOT11_AUTH_ALGORITHM_LIST_REVISION_1OID_DOT11_SUPPORTED_UNICAST_ALGORITHM_PAIRPDOT11_AUTH_CIPHER_PAIR_LISTDOT11_AUTH_CIPHER_PAIR_LISTDOT11_AUTH_CIPHER_PAIR_LIST_REVISION_1OID_DOT11_ENABLED_UNICAST_CIPHER_ALGORITHMPDOT11_CIPHER_ALGORITHM_LISTDOT11_CIPHER_ALGORITHM_LISTDOT11_CIPHER_ALGORITHM_LIST_REVISION_1OID_DOT11_SUPPORTED_MULTICAST_ALGORITHM_PAIROID_DOT11_ENABLED_MULTICAST_CIPHER_ALGORITHMOID_DOT11_CIPHER_DEFAULT_KEY_IDOID_DOT11_CIPHER_DEFAULT_KEYPDOT11_CIPHER_DEFAULT_KEY_VALUEDOT11_CIPHER_DEFAULT_KEY_VALUEDOT11_CIPHER_DEFAULT_KEY_VALUE_REVISION_1PDOT11_KEY_ALGO_TKIP_MICDOT11_KEY_ALGO_TKIP_MICPDOT11_KEY_ALGO_CCMPDOT11_KEY_ALGO_CCMPPDOT11_KEY_ALGO_GCMPDOT11_KEY_ALGO_GCMPPDOT11_KEY_ALGO_BIPDOT11_KEY_ALGO_BIPOID_DOT11_CIPHER_KEY_MAPPING_KEYPDOT11_DIRECTIONDOT11_DIRECTIONDOT11_CIPHER_KEY_MAPPING_KEY_VALUE_BYTE_ARRAY_REVISION_1PDOT11_CIPHER_KEY_MAPPING_KEY_VALUEDOT11_CIPHER_KEY_MAPPING_KEY_VALUEOID_DOT11_ENUM_ASSOCIATION_INFOPDOT11_ASSOCIATION_STATEDOT11_ASSOCIATION_STATEPDOT11_ASSOCIATION_INFO_EXDOT11_ASSOCIATION_INFO_EXPDOT11_ASSOCIATION_INFO_LISTDOT11_ASSOCIATION_INFO_LISTDOT11_ASSOCIATION_INFO_LIST_REVISION_1OID_DOT11_DISCONNECT_REQUESTOID_DOT11_UNICAST_USE_GROUP_ENABLEDOID_DOT11_HARDWARE_PHY_STATEOID_DOT11_DESIRED_PHY_LISTPDOT11_PHY_ID_LISTDOT11_PHY_ID_LISTDOT11_PHY_ID_LIST_REVISION_1DOT11_PHY_ID_ANYOID_DOT11_CURRENT_PHY_IDOID_DOT11_MEDIA_STREAMING_ENABLEDOID_DOT11_UNREACHABLE_DETECTION_THRESHOLDOID_DOT11_ACTIVE_PHY_LISTOID_DOT11_EXTSTA_CAPABILITYPDOT11_EXTSTA_CAPABILITYDOT11_EXTSTA_CAPABILITYDOT11_EXTSTA_CAPABILITY_REVISION_1OID_DOT11_DATA_RATE_MAPPING_TABLEPDOT11_DATA_RATE_MAPPING_ENTRYDOT11_DATA_RATE_MAPPING_ENTRYPDOT11_DATA_RATE_MAPPING_TABLEDOT11_DATA_RATE_MAPPING_TABLEDOT11_DATA_RATE_MAPPING_TABLE_REVISION_1DOT11_DATA_RATE_NON_STANDARDDOT11_DATA_RATE_INDEX_MASKOID_DOT11_SUPPORTED_COUNTRY_OR_REGION_STRINGPDOT11_COUNTRY_OR_REGION_STRING_LISTDOT11_COUNTRY_OR_REGION_STRING_LISTDOT11_COUNTRY_OR_REGION_STRING_LIST_REVISION_1OID_DOT11_DESIRED_COUNTRY_OR_REGION_STRINGOID_DOT11_PORT_STATE_NOTIFICATIONPDOT11_PORT_STATE_NOTIFICATIONDOT11_PORT_STATE_NOTIFICATIONDOT11_PORT_STATE_NOTIFICATION_REVISION_1OID_DOT11_IBSS_PARAMSPDOT11_IBSS_PARAMSDOT11_IBSS_PARAMSDOT11_IBSS_PARAMS_REVISION_1OID_DOT11_QOS_PARAMSPDOT11_QOS_PARAMSDOT11_QOS_PARAMSDOT11_QOS_PARAMS_REVISION_1DOT11_QOS_PROTOCOL_FLAG_WMMDOT11_QOS_PROTOCOL_FLAG_11EOID_DOT11_SAFE_MODE_ENABLEDOID_DOT11_HIDDEN_NETWORK_ENABLEDOID_DOT11_ASSOCIATION_PARAMSPDOT11_ASSOCIATION_PARAMSDOT11_ASSOCIATION_PARAMSDOT11_ASSOCIATION_PARAMS_REVISION_1OID_DOT11_SAFE_MODE_HT_ENABLEDDOT11_MAX_NUM_OF_FRAGMENTSDOT11_PRIORITY_CONTENTIONDOT11_PRIORITY_CONTENTION_FREEDOT11_SERVICE_CLASS_REORDERABLE_MULTICASTDOT11_SERVICE_CLASS_STRICTLY_ORDEREDDOT11_FLAGS_80211B_SHORT_PREAMBLEDOT11_FLAGS_80211B_PBCCDOT11_FLAGS_80211B_CHANNEL_AGILITYDOT11_FLAGS_PS_ONDOT11_FLAGS_80211G_DSSS_OFDMDOT11_FLAGS_80211G_USE_PROTECTIONDOT11_FLAGS_80211G_NON_ERP_PRESENTDOT11_FLAGS_80211G_BARKER_PREAMBLE_MODEDOT11_WME_PACKETPDOT11_FRAGMENT_DESCRIPTORDOT11_FRAGMENT_DESCRIPTORPDOT11_PER_MSDU_COUNTERSDOT11_PER_MSDU_COUNTERSPDOT11_HRDSSS_PHY_ATTRIBUTESDOT11_HRDSSS_PHY_ATTRIBUTESPDOT11_OFDM_PHY_ATTRIBUTESDOT11_OFDM_PHY_ATTRIBUTESPDOT11_ERP_PHY_ATTRIBUTESDOT11_ERP_PHY_ATTRIBUTESDOT11_PHY_ATTRIBUTES_REVISION_1PDOT11_PHY_ATTRIBUTESDOT11_PHY_ATTRIBUTESDOT11_EXTSTA_ATTRIBUTES_SAFEMODE_OID_SUPPORTEDDOT11_EXTSTA_ATTRIBUTES_SAFEMODE_CERTIFIEDDOT11_EXTSTA_ATTRIBUTES_SAFEMODE_RESERVEDDOT11_EXTSTA_ATTRIBUTES_REVISION_1DOT11_EXTSTA_ATTRIBUTES_REVISION_2DOT11_EXTSTA_ATTRIBUTES_REVISION_3DOT11_EXTSTA_ATTRIBUTES_REVISION_4PDOT11_EXTSTA_ATTRIBUTESDOT11_EXTSTA_ATTRIBUTESPDOT11_RECV_EXTENSION_INFODOT11_RECV_EXTENSION_INFOPDOT11_RECV_EXTENSION_INFO_V2DOT11_RECV_EXTENSION_INFO_V2DOT11_STATUS_SUCCESSDOT11_STATUS_RETRY_LIMIT_EXCEEDEDDOT11_STATUS_UNSUPPORTED_PRIORITYDOT11_STATUS_UNSUPPORTED_SERVICE_CLASSDOT11_STATUS_UNAVAILABLE_PRIORITYDOT11_STATUS_UNAVAILABLE_SERVICE_CLASSDOT11_STATUS_XMIT_MSDU_TIMER_EXPIREDDOT11_STATUS_UNAVAILABLE_BSSDOT11_STATUS_EXCESSIVE_DATA_LENGTHDOT11_STATUS_ENCRYPTION_FAILEDDOT11_STATUS_WEP_KEY_UNAVAILABLEDOT11_STATUS_ICV_VERIFIEDDOT11_STATUS_PACKET_REASSEMBLEDDOT11_STATUS_PACKET_NOT_REASSEMBLEDDOT11_STATUS_GENERATE_AUTH_FAILEDDOT11_STATUS_AUTH_NOT_VERIFIEDDOT11_STATUS_AUTH_VERIFIEDDOT11_STATUS_AUTH_FAILEDDOT11_STATUS_PS_LIFETIME_EXPIREDPDOT11_STATUS_INDICATIONDOT11_STATUS_INDICATIONDOT11_STATUS_RESET_CONFIRMDOT11_STATUS_SCAN_CONFIRMDOT11_STATUS_JOIN_CONFIRMDOT11_STATUS_START_CONFIRMDOT11_STATUS_AP_JOIN_CONFIRMDOT11_STATUS_MPDU_MAX_LENGTH_CHANGEDPDOT11_MPDU_MAX_LENGTH_INDICATIONDOT11_MPDU_MAX_LENGTH_INDICATIONDOT11_MPDU_MAX_LENGTH_INDICATION_REVISION_1PDOT11_ASSOCIATION_START_PARAMETERSDOT11_ASSOCIATION_START_PARAMETERSDOT11_ASSOCIATION_START_PARAMETERS_REVISION_1DOT11_ENCAP_RFC_1042DOT11_ENCAP_802_1HPDOT11_ENCAP_ENTRYDOT11_ENCAP_ENTRYPDOT11_DS_INFODOT11_DS_INFODOT11_ASSOC_STATUSDOT11_ASSOC_STATUS_SUCCESSDOT11_ASSOC_STATUS_FAILUREDOT11_ASSOC_STATUS_UNREACHABLEDOT11_ASSOC_STATUS_RADIO_OFFDOT11_ASSOC_STATUS_PHY_DISABLEDDOT11_ASSOC_STATUS_CANCELLEDDOT11_ASSOC_STATUS_CANDIDATE_LIST_EXHAUSTEDDOT11_ASSOC_STATUS_DISASSOCIATED_BY_OSDOT11_ASSOC_STATUS_DISASSOCIATED_BY_ROAMINGDOT11_ASSOC_STATUS_DISASSOCIATED_BY_RESETDOT11_ASSOC_STATUS_SYSTEM_ERRORDOT11_ASSOC_STATUS_ROAMING_BETTER_AP_FOUNDDOT11_ASSOC_STATUS_ROAMING_ASSOCIATION_LOSTDOT11_ASSOC_STATUS_ROAMING_ADHOCDOT11_ASSOC_STATUS_PEER_DEAUTHENTICATEDDOT11_ASSOC_STATUS_PEER_DEAUTHENTICATED_STARTDOT11_ASSOC_STATUS_PEER_DEAUTHENTICATED_ENDDOT11_ASSOC_STATUS_PEER_DISASSOCIATEDDOT11_ASSOC_STATUS_PEER_DISASSOCIATED_STARTDOT11_ASSOC_STATUS_PEER_DISASSOCIATED_ENDDOT11_ASSOC_STATUS_ASSOCIATION_RESPONSEDOT11_ASSOC_STATUS_ASSOCIATION_RESPONSE_STARTDOT11_ASSOC_STATUS_ASSOCIATION_RESPONSE_ENDDOT11_ASSOC_STATUS_REASON_CODE_MASKDOT11_ASSOC_STATUS_IHV_STARTDOT11_ASSOC_STATUS_IHV_ENDPDOT11_ASSOCIATION_COMPLETION_PARAMETERSDOT11_ASSOCIATION_COMPLETION_PARAMETERSDOT11_ASSOCIATION_COMPLETION_PARAMETERS_REVISION_1DOT11_ASSOCIATION_COMPLETION_PARAMETERS_REVISION_2PDOT11_CONNECTION_START_PARAMETERSDOT11_CONNECTION_START_PARAMETERSDOT11_CONNECTION_START_PARAMETERS_REVISION_1DOT11_CONNECTION_STATUS_SUCCESSDOT11_CONNECTION_STATUS_FAILUREDOT11_CONNECTION_STATUS_CANDIDATE_LIST_EXHAUSTEDDOT11_CONNECTION_STATUS_PHY_POWER_DOWNDOT11_CONNECTION_STATUS_CANCELLEDDOT11_CONNECTION_STATUS_IHV_STARTDOT11_CONNECTION_STATUS_IHV_ENDPDOT11_CONNECTION_COMPLETION_PARAMETERSDOT11_CONNECTION_COMPLETION_PARAMETERSDOT11_CONNECTION_COMPLETION_PARAMETERS_REVISION_1DOT11_ROAMING_REASON_BETTER_AP_FOUNDDOT11_ROAMING_REASON_ASSOCIATION_LOSTDOT11_ROAMING_REASON_ADHOCDOT11_ROAMING_REASON_IHV_STARTDOT11_ROAMING_REASON_IHV_ENDPDOT11_ROAMING_START_PARAMETERSDOT11_ROAMING_START_PARAMETERSDOT11_ROAMING_START_PARAMETERS_REVISION_1PDOT11_ROAMING_COMPLETION_PARAMETERSDOT11_ROAMING_COMPLETION_PARAMETERSDOT11_ROAMING_COMPLETION_PARAMETERS_REVISION_1DOT11_DISASSOC_REASON_OSDOT11_DISASSOC_REASON_PEER_UNREACHABLEDOT11_DISASSOC_REASON_PEER_DEAUTHENTICATEDDOT11_DISASSOC_REASON_PEER_DISASSOCIATEDDOT11_DISASSOC_REASON_RADIO_OFFDOT11_DISASSOC_REASON_PHY_DISABLEDDOT11_DISASSOC_REASON_IHV_STARTDOT11_DISASSOC_REASON_IHV_ENDPDOT11_DISASSOCIATION_PARAMETERSDOT11_DISASSOCIATION_PARAMETERSDOT11_DISASSOCIATION_PARAMETERS_REVISION_1PDOT11_TKIPMIC_FAILURE_PARAMETERSDOT11_TKIPMIC_FAILURE_PARAMETERSDOT11_TKIPMIC_FAILURE_PARAMETERS_REVISION_1PDOT11_PMKID_CANDIDATE_LIST_PARAMETERSDOT11_PMKID_CANDIDATE_LIST_PARAMETERSDOT11_PMKID_CANDIDATE_LIST_PARAMETERS_REVISION_1PDOT11_BSSID_CANDIDATEDOT11_BSSID_CANDIDATEDOT11_PMKID_CANDIDATE_PREAUTH_ENABLEDPDOT11_PHY_STATE_PARAMETERSDOT11_PHY_STATE_PARAMETERSDOT11_PHY_STATE_PARAMETERS_REVISION_1PDOT11_LINK_QUALITY_ENTRYDOT11_LINK_QUALITY_ENTRYPDOT11_LINK_QUALITY_PARAMETERSDOT11_LINK_QUALITY_PARAMETERSDOT11_LINK_QUALITY_PARAMETERS_REVISION_1PDOT11_EXTSTA_SEND_CONTEXTDOT11_EXTSTA_SEND_CONTEXTDOT11_EXTAP_SEND_CONTEXTPDOT11_EXTAP_SEND_CONTEXTDOT11_EXTSTA_SEND_CONTEXT_REVISION_1DOT11_RECV_FLAG_RAW_PACKETDOT11_RECV_FLAG_RAW_PACKET_FCS_FAILUREDOT11_RECV_FLAG_RAW_PACKET_TIMESTAMPDOT11_EXTSTA_RECV_CONTEXT_REVISION_1PDOT11_EXTSTA_RECV_CONTEXTDOT11_EXTSTA_RECV_CONTEXTDOT11_EXTAP_RECV_CONTEXTPDOT11_EXTAP_RECV_CONTEXTOID_DOT11_PRIVATE_OIDS_STARTOID_DOT11_CURRENT_ADDRESSOID_DOT11_PERMANENT_ADDRESSOID_DOT11_MULTICAST_LISTOID_DOT11_MAXIMUM_LIST_SIZEDEFINE_NWF_GUIDDOT11_EXTAP_ATTRIBUTES_REVISION_1PDOT11_EXTAP_ATTRIBUTESDOT11_EXTAP_ATTRIBUTESDOT11_INCOMING_ASSOC_STARTED_PARAMETERS_REVISION_1PDOT11_INCOMING_ASSOC_STARTED_PARAMETERSDOT11_INCOMING_ASSOC_STARTED_PARAMETERSDOT11_INCOMING_ASSOC_REQUEST_RECEIVED_PARAMETERS_REVISION_1PDOT11_INCOMING_ASSOC_REQUEST_RECEIVED_PARAMETERSDOT11_INCOMING_ASSOC_REQUEST_RECEIVED_PARAMETERSDOT11_ASSOC_ERROR_SOURCE_OSDOT11_ASSOC_ERROR_SOURCE_REMOTEDOT11_ASSOC_ERROR_SOURCE_OTHERDOT11_INCOMING_ASSOC_COMPLETION_PARAMETERS_REVISION_1PDOT11_INCOMING_ASSOC_COMPLETION_PARAMETERSDOT11_INCOMING_ASSOC_COMPLETION_PARAMETERSDOT11_STOP_AP_PARAMETERS_REVISION_1PDOT11_STOP_AP_PARAMETERSDOT11_STOP_AP_PARAMETERSDOT11_STOP_AP_REASON_FREQUENCY_NOT_AVAILABLEDOT11_STOP_AP_REASON_CHANNEL_NOT_AVAILABLEDOT11_STOP_AP_REASON_AP_ACTIVEDOT11_STOP_AP_REASON_IHV_STARTDOT11_STOP_AP_REASON_IHV_ENDDOT11_PHY_FREQUENCY_ADOPTED_PARAMETERS_REVISION_1PDOT11_PHY_FREQUENCY_ADOPTED_PARAMETERSDOT11_PHY_FREQUENCY_ADOPTED_PARAMETERSDOT11_CAN_SUSTAIN_AP_PARAMETERS_REVISION_1PDOT11_CAN_SUSTAIN_AP_PARAMETERSDOT11_CAN_SUSTAIN_AP_PARAMETERSDOT11_CAN_SUSTAIN_AP_REASON_IHV_STARTDOT11_CAN_SUSTAIN_AP_REASON_IHV_ENDNWF_EXTAP_OIDOID_DOT11_WPS_ENABLEDOID_DOT11_START_AP_REQUESTOID_DOT11_AVAILABLE_CHANNEL_LISTDOT11_AVAILABLE_CHANNEL_LIST_REVISION_1PDOT11_AVAILABLE_CHANNEL_LISTDOT11_AVAILABLE_CHANNEL_LISTOID_DOT11_AVAILABLE_FREQUENCY_LISTDOT11_AVAILABLE_FREQUENCY_LIST_REVISION_1PDOT11_AVAILABLE_FREQUENCY_LISTDOT11_AVAILABLE_FREQUENCY_LISTOID_DOT11_DISASSOCIATE_PEER_REQUESTDOT11_DISASSOCIATE_PEER_REQUEST_REVISION_1PDOT11_DISASSOCIATE_PEER_REQUESTDOT11_DISASSOCIATE_PEER_REQUESTOID_DOT11_INCOMING_ASSOCIATION_DECISIONDOT11_INCOMING_ASSOC_DECISION_REVISION_1PDOT11_INCOMING_ASSOC_DECISIONDOT11_INCOMING_ASSOC_DECISIONDOT11_INCOMING_ASSOC_DECISION_REVISION_2PDOT11_INCOMING_ASSOC_DECISION_V2DOT11_INCOMING_ASSOC_DECISION_V2OID_DOT11_ADDITIONAL_IEDOT11_ADDITIONAL_IE_REVISION_1PDOT11_ADDITIONAL_IEDOT11_ADDITIONAL_IEDOT11_EXTAP_SEND_CONTEXT_REVISION_1DOT11_EXTAP_RECV_CONTEXT_REVISION_1OID_DOT11_ENUM_PEER_INFOPDOT11_PEER_STATISTICSDOT11_PEER_STATISTICSPDOT11_PEER_INFODOT11_PEER_INFODOT11_PEER_INFO_LIST_REVISION_1PDOT11_PEER_INFO_LISTDOT11_PEER_INFO_LISTDOT11_VWIFI_COMBINATION_REVISION_1PDOT11_VWIFI_COMBINATIONDOT11_VWIFI_COMBINATIONDOT11_VWIFI_COMBINATION_REVISION_2PDOT11_VWIFI_COMBINATION_V2DOT11_VWIFI_COMBINATION_V2DOT11_VWIFI_COMBINATION_REVISION_3PDOT11_VWIFI_COMBINATION_V3DOT11_VWIFI_COMBINATION_V3DOT11_VWIFI_ATTRIBUTES_REVISION_1PDOT11_VWIFI_ATTRIBUTESDOT11_VWIFI_ATTRIBUTESNWF_VWIFI_OIDOID_DOT11_CREATE_MACDOT11_MAC_PARAMETERS_REVISION_1PDOT11_MAC_PARAMETERSDOT11_MAC_PARAMETERSPDOT11_MAC_INFODOT11_MAC_INFOOID_DOT11_DELETE_MACOID_DOT11_PREFERRED_MACOID_DOT11_VIRTUAL_STATION_CAPABILITYDOT11_WFD_ATTRIBUTES_REVISION_1PDOT11_WFD_ATTRIBUTESDOT11_WFD_ATTRIBUTESDOT11_WFD_GROUP_CAPABILITYDOT11_WFD_STATUS_SUCCESSDOT11_WFD_STATUS_FAILED_INFORMATION_IS_UNAVAILABLEDOT11_WFD_STATUS_FAILED_INCOMPATIBLE_PARAMETERSDOT11_WFD_STATUS_FAILED_LIMIT_REACHEDDOT11_WFD_STATUS_FAILED_INVALID_PARAMETERSDOT11_WFD_STATUS_FAILED_UNABLE_TO_ACCOMODATE_REQUESTDOT11_WFD_STATUS_FAILED_PREVIOUS_PROTOCOL_ERRORDOT11_WFD_STATUS_FAILED_NO_COMMON_CHANNELSDOT11_WFD_STATUS_FAILED_UNKNOWN_WFD_GROUPDOT11_WFD_STATUS_FAILED_MATCHING_MAX_INTENTDOT11_WFD_STATUS_FAILED_INCOMPATIBLE_PROVISIONING_METHODDOT11_WFD_STATUS_FAILED_REJECTED_BY_USERDOT11_WFD_STATUS_SUCCESS_ACCEPTED_BY_USERWFD_STATUS_SUCCEEDEDWFD_STATUS_FAILEDDOT11_WFD_MINOR_REASON_SUCCESSDOT11_WFD_MINOR_REASON_DISASSOCIATED_FROM_WLAN_CROSS_CONNECTION_POLICYDOT11_WFD_MINOR_REASON_DISASSOCIATED_NOT_MANAGED_INFRASTRUCTURE_CAPABLEDOT11_WFD_MINOR_REASON_DISASSOCIATED_WFD_COEXISTENCE_POLICYDOT11_WFD_MINOR_REASON_DISASSOCIATED_INFRASTRUCTURE_MANAGED_POLICYDOT11_WPS_VERSION_1_0DOT11_WPS_VERSION_2_0DOT11_WFD_DEVICE_CAPABILITY_SERVICE_DISCOVERYDOT11_WFD_DEVICE_CAPABILITY_P2P_CLIENT_DISCOVERABILITYDOT11_WFD_DEVICE_CAPABILITY_CONCURRENT_OPERATIONDOT11_WFD_DEVICE_CAPABILITY_P2P_INFRASTRUCTURE_MANAGEDDOT11_WFD_DEVICE_CAPABILITY_P2P_DEVICE_LIMITDOT11_WFD_DEVICE_CAPABILITY_P2P_INVITATION_PROCEDUREDOT11_WFD_DEVICE_CAPABILITY_RESERVED_6DOT11_WFD_DEVICE_CAPABILITY_RESERVED_7DOT11_WFD_GROUP_CAPABILITY_NONEDOT11_WFD_GROUP_CAPABILITY_GROUP_OWNERDOT11_WFD_GROUP_CAPABILITY_PERSISTENT_GROUPDOT11_WFD_GROUP_CAPABILITY_GROUP_LIMIT_REACHEDDOT11_WFD_GROUP_CAPABILITY_INTRABSS_DISTRIBUTION_SUPPORTEDDOT11_WFD_GROUP_CAPABILITY_CROSS_CONNECTION_SUPPORTEDDOT11_WFD_GROUP_CAPABILITY_PERSISTENT_RECONNECT_SUPPORTEDDOT11_WFD_GROUP_CAPABILITY_IN_GROUP_FORMATIONDOT11_WFD_GROUP_CAPABILITY_RESERVED_7DOT11_WFD_GROUP_CAPABILITY_EAPOL_KEY_IP_ADDRESS_ALLOCATION_SUPPORTEDDOT11_WPS_DEVICE_NAME_MAX_LENGTHDOT11_WPS_MAX_PASSKEY_LENGTHDOT11_WPS_MAX_MODEL_NAME_LENGTHDOT11_WPS_MAX_MODEL_NUMBER_LENGTHPDOT11_WFD_DEVICE_TYPEDOT11_WFD_DEVICE_TYPEPDOT11_WPS_DEVICE_NAMEDOT11_WPS_DEVICE_NAMEPDOT11_WFD_CONFIGURATION_TIMEOUTDOT11_WFD_CONFIGURATION_TIMEOUTPDOT11_WFD_GROUP_IDDOT11_WFD_GROUP_IDPDOT11_WFD_GO_INTENTDOT11_WFD_GO_INTENTPDOT11_WFD_CHANNELDOT11_WFD_CHANNELPDOT11_WPS_CONFIG_METHODDOT11_WPS_CONFIG_METHODPDOT11_WPS_DEVICE_PASSWORD_IDDOT11_WPS_DEVICE_PASSWORD_IDPWFDSVC_CONNECTION_CAPABILITYWFDSVC_CONNECTION_CAPABILITYWFDSVC_CONNECTION_CAPABILITY_NEWWFDSVC_CONNECTION_CAPABILITY_CLIENTWFDSVC_CONNECTION_CAPABILITY_GOPDOT11_WFD_SERVICE_HASH_LISTDOT11_WFD_SERVICE_HASH_LISTPDOT11_WFD_ADVERTISEMENT_IDDOT11_WFD_ADVERTISEMENT_IDPDOT11_WFD_SESSION_IDDOT11_WFD_SESSION_IDPDOT11_WFD_ADVERTISED_SERVICE_DESCRIPTORDOT11_WFD_ADVERTISED_SERVICE_DESCRIPTORPDOT11_WFD_ADVERTISED_SERVICE_LISTDOT11_WFD_ADVERTISED_SERVICE_LISTDOT11_WFD_DISCOVER_COMPLETE_PARAMETERS_REVISION_1DOT11_WFD_DISCOVER_COMPLETE_MAX_LIST_SIZEPDOT11_WFD_DISCOVER_COMPLETE_PARAMETERSDOT11_WFD_DISCOVER_COMPLETE_PARAMETERSDOT11_GO_NEGOTIATION_REQUEST_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_GO_NEGOTIATION_REQUEST_SEND_COMPLETE_PARAMETERSDOT11_GO_NEGOTIATION_REQUEST_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_GO_NEGOTIATION_REQUEST_PARAMETERS_REVISION_1PDOT11_RECEIVED_GO_NEGOTIATION_REQUEST_PARAMETERSDOT11_RECEIVED_GO_NEGOTIATION_REQUEST_PARAMETERSDOT11_GO_NEGOTIATION_RESPONSE_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_GO_NEGOTIATION_RESPONSE_SEND_COMPLETE_PARAMETERSDOT11_GO_NEGOTIATION_RESPONSE_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_GO_NEGOTIATION_RESPONSE_PARAMETERS_REVISION_1PDOT11_RECEIVED_GO_NEGOTIATION_RESPONSE_PARAMETERSDOT11_RECEIVED_GO_NEGOTIATION_RESPONSE_PARAMETERSDOT11_GO_NEGOTIATION_CONFIRMATION_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_GO_NEGOTIATION_CONFIRMATION_SEND_COMPLETE_PARAMETERSDOT11_GO_NEGOTIATION_CONFIRMATION_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_REVISION_1PDOT11_RECEIVED_GO_NEGOTIATION_CONFIRMATION_PARAMETERSDOT11_RECEIVED_GO_NEGOTIATION_CONFIRMATION_PARAMETERSDOT11_INVITATION_REQUEST_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_INVITATION_REQUEST_SEND_COMPLETE_PARAMETERSDOT11_INVITATION_REQUEST_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_INVITATION_REQUEST_PARAMETERS_REVISION_1PDOT11_RECEIVED_INVITATION_REQUEST_PARAMETERSDOT11_RECEIVED_INVITATION_REQUEST_PARAMETERSDOT11_INVITATION_RESPONSE_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_INVITATION_RESPONSE_SEND_COMPLETE_PARAMETERSDOT11_INVITATION_RESPONSE_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_INVITATION_RESPONSE_PARAMETERS_REVISION_1PDOT11_RECEIVED_INVITATION_RESPONSE_PARAMETERSDOT11_RECEIVED_INVITATION_RESPONSE_PARAMETERSDOT11_PROVISION_DISCOVERY_REQUEST_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_PROVISION_DISCOVERY_REQUEST_SEND_COMPLETE_PARAMETERSDOT11_PROVISION_DISCOVERY_REQUEST_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_PROVISION_DISCOVERY_REQUEST_PARAMETERS_REVISION_1PDOT11_RECEIVED_PROVISION_DISCOVERY_REQUEST_PARAMETERSDOT11_RECEIVED_PROVISION_DISCOVERY_REQUEST_PARAMETERSDOT11_PROVISION_DISCOVERY_RESPONSE_SEND_COMPLETE_PARAMETERS_REVISION_1PDOT11_PROVISION_DISCOVERY_RESPONSE_SEND_COMPLETE_PARAMETERSDOT11_PROVISION_DISCOVERY_RESPONSE_SEND_COMPLETE_PARAMETERSDOT11_RECEIVED_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_REVISION_1PDOT11_RECEIVED_PROVISION_DISCOVERY_RESPONSE_PARAMETERSDOT11_RECEIVED_PROVISION_DISCOVERY_RESPONSE_PARAMETERSDOT11_ANQP_QUERY_COMPLETE_PARAMETERS_REVISION_1PDOT11_ANQP_QUERY_RESULTDOT11_ANQP_QUERY_RESULTPDOT11_ANQP_QUERY_COMPLETE_PARAMETERSDOT11_ANQP_QUERY_COMPLETE_PARAMETERSNWF_WFD_DEVICE_OIDNWF_WFD_ROLE_OIDOID_DOT11_WFD_DEVICE_CAPABILITYDOT11_WFD_DEVICE_CAPABILITY_CONFIG_REVISION_1PDOT11_WFD_DEVICE_CAPABILITY_CONFIGDOT11_WFD_DEVICE_CAPABILITY_CONFIGOID_DOT11_WFD_GROUP_OWNER_CAPABILITYDOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG_REVISION_1PDOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIGDOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIGDOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG_REVISION_2PDOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG_V2DOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG_V2OID_DOT11_WFD_DEVICE_INFODOT11_WFD_DEVICE_INFO_REVISION_1PDOT11_WFD_DEVICE_INFODOT11_WFD_DEVICE_INFOOID_DOT11_WFD_SECONDARY_DEVICE_TYPE_LISTDOT11_WFD_SECONDARY_DEVICE_TYPE_LIST_REVISION_1PDOT11_WFD_SECONDARY_DEVICE_TYPE_LISTDOT11_WFD_SECONDARY_DEVICE_TYPE_LISTOID_DOT11_WFD_DISCOVER_REQUEST// pub const DOT11_SIZEOF_WFD_SECONDARY_DEVICE_TYPE_LIST_REVISION_1: usize =//    FIELD_OFFSET(DOT11_WFD_SECONDARY_DEVICE_TYPE_LIST, SecondaryDeviceTypes);PDOT11_WFD_DISCOVER_TYPEDOT11_WFD_DISCOVER_TYPEPDOT11_WFD_SCAN_TYPEDOT11_WFD_SCAN_TYPEDISCOVERY_FILTER_BITMASK_DEVICEDISCOVERY_FILTER_BITMASK_GODISCOVERY_FILTER_BITMASK_ANYPDOT11_WFD_DISCOVER_DEVICE_FILTERDOT11_WFD_DISCOVER_DEVICE_FILTERDOT11_WFD_DISCOVER_REQUEST_REVISION_1PDOT11_WFD_DISCOVER_REQUESTDOT11_WFD_DISCOVER_REQUESTOID_DOT11_WFD_ENUM_DEVICE_LISTDOT11_DEVICE_ENTRY_BYTE_ARRAY_REVISION_1PDOT11_WFD_DEVICE_ENTRYDOT11_WFD_DEVICE_ENTRYOID_DOT11_WFD_LISTEN_STATE_DISCOVERABILITYDOT11_WFD_DEVICE_NOT_DISCOVERABLEDOT11_WFD_DEVICE_AUTO_AVAILABILITYDOT11_WFD_DEVICE_HIGH_AVAILABILITYOID_DOT11_WFD_ADDITIONAL_IEDOT11_WFD_ADDITIONAL_IE_REVISION_1PDOT11_WFD_ADDITIONAL_IEDOT11_WFD_ADDITIONAL_IEOID_DOT11_WFD_FLUSH_DEVICE_LISTOID_DOT11_WFD_SEND_GO_NEGOTIATION_REQUESTDOT11_SEND_GO_NEGOTIATION_REQUEST_PARAMETERS_REVISION_1PDOT11_SEND_GO_NEGOTIATION_REQUEST_PARAMETERSDOT11_SEND_GO_NEGOTIATION_REQUEST_PARAMETERSOID_DOT11_WFD_SEND_GO_NEGOTIATION_RESPONSEDOT11_SEND_GO_NEGOTIATION_RESPONSE_PARAMETERS_REVISION_1PDOT11_SEND_GO_NEGOTIATION_RESPONSE_PARAMETERSDOT11_SEND_GO_NEGOTIATION_RESPONSE_PARAMETERSOID_DOT11_WFD_SEND_GO_NEGOTIATION_CONFIRMATIONDOT11_SEND_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_REVISION_1PDOT11_SEND_GO_NEGOTIATION_CONFIRMATION_PARAMETERSDOT11_SEND_GO_NEGOTIATION_CONFIRMATION_PARAMETERSOID_DOT11_WFD_SEND_INVITATION_REQUESTPDOT11_WFD_INVITATION_FLAGSDOT11_WFD_INVITATION_FLAGSDOT11_SEND_INVITATION_REQUEST_PARAMETERS_REVISION_1PDOT11_SEND_INVITATION_REQUEST_PARAMETERSDOT11_SEND_INVITATION_REQUEST_PARAMETERSOID_DOT11_WFD_SEND_INVITATION_RESPONSEDOT11_SEND_INVITATION_RESPONSE_PARAMETERS_REVISION_1PDOT11_SEND_INVITATION_RESPONSE_PARAMETERSDOT11_SEND_INVITATION_RESPONSE_PARAMETERSOID_DOT11_WFD_SEND_PROVISION_DISCOVERY_REQUESTDOT11_SEND_PROVISION_DISCOVERY_REQUEST_PARAMETERS_REVISION_1PDOT11_SEND_PROVISION_DISCOVERY_REQUEST_PARAMETERSDOT11_SEND_PROVISION_DISCOVERY_REQUEST_PARAMETERSOID_DOT11_WFD_SEND_PROVISION_DISCOVERY_RESPONSEDOT11_SEND_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_REVISION_1PDOT11_SEND_PROVISION_DISCOVERY_RESPONSE_PARAMETERSDOT11_SEND_PROVISION_DISCOVERY_RESPONSE_PARAMETERSOID_DOT11_WFD_GET_DIALOG_TOKENOID_DOT11_WFD_STOP_DISCOVERYOID_DOT11_WFD_ENABLE_HRDSSS_DEVICESOID_DOT11_WFD_DEVICE_LISTEN_CHANNELDOT11_WFD_DEVICE_LISTEN_CHANNEL_REVISION_1PDOT11_WFD_DEVICE_LISTEN_CHANNELDOT11_WFD_DEVICE_LISTEN_CHANNELOID_DOT11_WFD_DESIRED_GROUP_IDOID_DOT11_WFD_START_GO_REQUESTOID_DOT11_WFD_GROUP_START_PARAMETERSDOT11_WFD_GROUP_START_PARAMETERS_REVISION_1PDOT11_WFD_GROUP_START_PARAMETERSDOT11_WFD_GROUP_START_PARAMETERSOID_DOT11_WFD_CONNECT_TO_GROUP_REQUESTOID_DOT11_WFD_DISCONNECT_FROM_GROUP_REQUESTOID_DOT11_WFD_GROUP_JOIN_PARAMETERSDOT11_WFD_GROUP_JOIN_PARAMETERS_REVISION_1PDOT11_WFD_GROUP_JOIN_PARAMETERSDOT11_WFD_GROUP_JOIN_PARAMETERSNWF_POWER_SAVE_OIDOID_DOT11_POWER_MGMT_MODE_AUTO_ENABLEDDOT11_POWER_MGMT_AUTO_MODE_ENABLED_REVISION_1PDOT11_POWER_MGMT_AUTO_MODE_ENABLED_INFODOT11_POWER_MGMT_AUTO_MODE_ENABLED_INFOOID_DOT11_POWER_MGMT_MODE_STATUSDOT11_POWER_MGMT_MODE_STATUS_INFO_REVISION_1PDOT11_POWER_MGMT_MODE_STATUSINFODOT11_POWER_MGMT_MODE_STATUS_INFOOID_DOT11_OFFLOAD_NETWORK_LISTDOT11_MAX_CHANNEL_HINTSDOT11_INVALID_CHANNEL_NUMBERPDOT11_CHANNEL_HINTDOT11_CHANNEL_HINTPDOT11_OFFLOAD_NETWORKDOT11_OFFLOAD_NETWORKDOT11_NLO_FLAG_STOP_NLO_INDICATIONDOT11_NLO_FLAG_SCAN_ON_AOAC_PLATFORMDOT11_NLO_FLAG_SCAN_AT_SYSTEM_RESUMEDOT11_OFFLOAD_NETWORK_LIST_REVISION_1PDOT11_OFFLOAD_NETWORK_LIST_INFODOT11_OFFLOAD_NETWORK_LIST_INFODOT11_OFFLOAD_NETWORK_STATUS_PARAMETERS_REVISION_1PDOT11_OFFLOAD_NETWORK_STATUS_PARAMETERSDOT11_OFFLOAD_NETWORK_STATUS_PARAMETERSNWF_MANUFACTURING_OIDOID_DOT11_MANUFACTURING_TESTDOT11_MANUFACTURING_TEST_REVISION_1PDOT11_MANUFACTURING_TEST_TYPEDOT11_MANUFACTURING_TEST_TYPEPDOT11_MANUFACTURING_TESTDOT11_MANUFACTURING_TESTPDOT11_MANUFACTURING_SELF_TEST_TYPEDOT11_MANUFACTURING_SELF_TEST_TYPEPDOT11_MANUFACTURING_SELF_TEST_SET_PARAMSDOT11_MANUFACTURING_SELF_TEST_SET_PARAMSPDOT11_MANUFACTURING_SELF_TEST_QUERY_RESULTSDOT11_MANUFACTURING_SELF_TEST_QUERY_RESULTSPDOT11_BANDDOT11_BANDPDOT11_MANUFACTURING_FUNCTIONAL_TEST_RXDOT11_MANUFACTURING_FUNCTIONAL_TEST_RXPDOT11_MANUFACTURING_FUNCTIONAL_TEST_TXDOT11_MANUFACTURING_FUNCTIONAL_TEST_TXPDOT11_MANUFACTURING_FUNCTIONAL_TEST_QUERY_ADCDOT11_MANUFACTURING_FUNCTIONAL_TEST_QUERY_ADCPDOT11_MANUFACTURING_TEST_SET_DATADOT11_MANUFACTURING_TEST_SET_DATAPDOT11_MANUFACTURING_TEST_QUERY_DATADOT11_MANUFACTURING_TEST_QUERY_DATAPDOT11_MANUFACTURING_TEST_SLEEPDOT11_MANUFACTURING_TEST_SLEEPPDOT11_MANUFACTURING_CALLBACK_TYPEDOT11_MANUFACTURING_CALLBACK_TYPEPDOT11_MANUFACTURING_CALLBACK_PARAMETERSDOT11_MANUFACTURING_CALLBACK_PARAMETERSDOT11_MANUFACTURING_CALLBACK_REVISION_1OID_DOT11_SET_FT_REASSOCIATION_PARAMETERS//! Definitions for native 802.11 miniport driver specifications.//1233//! Macro APIs, window message crackers, and control APIsSCODEFACILITY_XPSFACILITY_XAMLFACILITY_USNFACILITY_BLBUIFACILITY_SPPFACILITY_WSB_ONLINEFACILITY_DLSFACILITY_BLB_CLIFACILITY_BLBFACILITY_WSBAPPFACILITY_WPNFACILITY_WMAAECMAFACILITY_WINRMFACILITY_WINPEFACILITY_WINDOWSUPDATEFACILITY_WINDOWS_STOREFACILITY_WINDOWS_SETUPFACILITY_WINDOWS_DEFENDERFACILITY_WINDOWS_CEFACILITY_WINDOWSFACILITY_WINCODEC_DWRITE_DWMFACILITY_WIAFACILITY_WERFACILITY_WEPFACILITY_WEB_SOCKETFACILITY_WEBFACILITY_USERMODE_VOLSNAPFACILITY_USERMODE_VOLMGRFACILITY_VISUALCPPFACILITY_USERMODE_VIRTUALIZATIONFACILITY_USERMODE_VHDFACILITY_URTFACILITY_UMIFACILITY_UIFACILITY_TPM_SOFTWAREFACILITY_TPM_SERVICESFACILITY_TIERINGFACILITY_SYNCENGINEFACILITY_SXSFACILITY_STORAGEFACILITY_STATE_MANAGEMENTFACILITY_SSPIFACILITY_USERMODE_SPACESFACILITY_SOSFACILITY_SCARDFACILITY_SHELLFACILITY_SETUPAPIFACILITY_SECURITYFACILITY_SDIAGFACILITY_USERMODE_SDBUSFACILITY_RPCFACILITY_RESTOREFACILITY_SCRIPTFACILITY_PARSEFACILITY_RASFACILITY_POWERSHELLFACILITY_PLAFACILITY_PIDGENXFACILITY_P2P_INTFACILITY_P2PFACILITY_OPCFACILITY_ONLINE_IDFACILITY_WIN32FACILITY_CONTROLFACILITY_WEBSERVICESFACILITY_NULLFACILITY_NDISFACILITY_NAPFACILITY_MOBILEFACILITY_METADIRECTORYFACILITY_MSMQFACILITY_MEDIASERVERFACILITY_MBNFACILITY_LINGUISTIC_SERVICESFACILITY_LEAPFACILITY_JSCRIPTFACILITY_INTERNETFACILITY_ITFFACILITY_INPUTFACILITY_USERMODE_HYPERVISORFACILITY_ACCELERATORFACILITY_HTTPFACILITY_GRAPHICSFACILITY_FWPFACILITY_FVEFACILITY_USERMODE_FILTER_MANAGERFACILITY_EASFACILITY_EAPFACILITY_DXGI_DDIFACILITY_DXGIFACILITY_DPLAYFACILITY_DMSERVERFACILITY_DISPATCHFACILITY_DIRECTORYSERVICEFACILITY_DIRECTMUSICFACILITY_DIRECT3D11FACILITY_DIRECT3D10FACILITY_DIRECT2DFACILITY_DAFFACILITY_DEPLOYMENT_SERVICES_UTILFACILITY_DEPLOYMENT_SERVICES_TRANSPORT_MANAGEMENTFACILITY_DEPLOYMENT_SERVICES_TFTPFACILITY_DEPLOYMENT_SERVICES_PXEFACILITY_DEPLOYMENT_SERVICES_MULTICAST_SERVERFACILITY_DEPLOYMENT_SERVICES_MULTICAST_CLIENTFACILITY_DEPLOYMENT_SERVICES_MANAGEMENTFACILITY_DEPLOYMENT_SERVICES_IMAGINGFACILITY_DEPLOYMENT_SERVICES_DRIVER_PROVISIONINGFACILITY_DEPLOYMENT_SERVICES_SERVERFACILITY_DEPLOYMENT_SERVICES_CONTENT_PROVIDERFACILITY_DEPLOYMENT_SERVICES_BINLSVCFACILITY_DEFRAGFACILITY_DEBUGGERSFACILITY_CONFIGURATIONFACILITY_COMPLUSFACILITY_USERMODE_COMMONLOGFACILITY_CMIFACILITY_CERTFACILITY_BLUETOOTH_ATTFACILITY_BCDFACILITY_BACKGROUNDCOPYFACILITY_AUDIOSTREAMINGFACILITY_AUDCLNTFACILITY_AUDIOFACILITY_ACTION_QUEUEFACILITY_ACSFACILITY_AAFSEC_E_OKERROR_INVALID_FUNCTIONERROR_FILE_NOT_FOUNDERROR_PATH_NOT_FOUNDERROR_TOO_MANY_OPEN_FILESERROR_ACCESS_DENIEDERROR_ARENA_TRASHEDERROR_INVALID_BLOCKERROR_BAD_ENVIRONMENTERROR_BAD_FORMATERROR_INVALID_ACCESSERROR_INVALID_DATAERROR_OUTOFMEMORYERROR_INVALID_DRIVEERROR_CURRENT_DIRECTORYERROR_NOT_SAME_DEVICEERROR_WRITE_PROTECTERROR_BAD_UNITERROR_NOT_READYERROR_BAD_COMMANDERROR_CRCERROR_BAD_LENGTHERROR_SEEKERROR_NOT_DOS_DISKERROR_SECTOR_NOT_FOUNDERROR_OUT_OF_PAPERERROR_WRITE_FAULTERROR_READ_FAULTERROR_GEN_FAILUREERROR_SHARING_VIOLATIONERROR_LOCK_VIOLATIONERROR_WRONG_DISKERROR_SHARING_BUFFER_EXCEEDEDERROR_HANDLE_EOFERROR_HANDLE_DISK_FULLERROR_NOT_SUPPORTEDERROR_REM_NOT_LISTERROR_DUP_NAMEERROR_BAD_NETPATHERROR_NETWORK_BUSYERROR_DEV_NOT_EXISTERROR_TOO_MANY_CMDSERROR_ADAP_HDW_ERRERROR_BAD_NET_RESPERROR_UNEXP_NET_ERRERROR_BAD_REM_ADAPERROR_PRINTQ_FULLERROR_NO_SPOOL_SPACEERROR_PRINT_CANCELLEDERROR_NETNAME_DELETEDERROR_NETWORK_ACCESS_DENIEDERROR_BAD_DEV_TYPEERROR_BAD_NET_NAMEERROR_TOO_MANY_NAMESERROR_TOO_MANY_SESSERROR_SHARING_PAUSEDERROR_REQ_NOT_ACCEPERROR_REDIR_PAUSEDERROR_FILE_EXISTSERROR_CANNOT_MAKEERROR_FAIL_I24ERROR_OUT_OF_STRUCTURESERROR_ALREADY_ASSIGNEDERROR_INVALID_PASSWORDERROR_NET_WRITE_FAULTERROR_NO_PROC_SLOTSERROR_TOO_MANY_SEMAPHORESERROR_EXCL_SEM_ALREADY_OWNEDERROR_SEM_IS_SETERROR_TOO_MANY_SEM_REQUESTSERROR_INVALID_AT_INTERRUPT_TIMEERROR_SEM_OWNER_DIEDERROR_SEM_USER_LIMITERROR_DISK_CHANGEERROR_DRIVE_LOCKEDERROR_OPEN_FAILEDERROR_DISK_FULLERROR_NO_MORE_SEARCH_HANDLESERROR_INVALID_TARGET_HANDLEERROR_INVALID_CATEGORYERROR_INVALID_VERIFY_SWITCHERROR_BAD_DRIVER_LEVELERROR_SEM_TIMEOUTERROR_INVALID_NAMEERROR_INVALID_LEVELERROR_NO_VOLUME_LABELERROR_MOD_NOT_FOUNDERROR_PROC_NOT_FOUNDERROR_WAIT_NO_CHILDRENERROR_CHILD_NOT_COMPLETEERROR_DIRECT_ACCESS_HANDLEERROR_NEGATIVE_SEEKERROR_SEEK_ON_DEVICEERROR_IS_JOIN_TARGETERROR_IS_JOINEDERROR_IS_SUBSTEDERROR_NOT_JOINEDERROR_NOT_SUBSTEDERROR_JOIN_TO_JOINERROR_SUBST_TO_SUBSTERROR_JOIN_TO_SUBSTERROR_SUBST_TO_JOINERROR_BUSY_DRIVEERROR_SAME_DRIVEERROR_DIR_NOT_ROOTERROR_DIR_NOT_EMPTYERROR_IS_SUBST_PATHERROR_IS_JOIN_PATHERROR_PATH_BUSYERROR_IS_SUBST_TARGETERROR_SYSTEM_TRACEERROR_INVALID_EVENT_COUNTERROR_TOO_MANY_MUXWAITERSERROR_INVALID_LIST_FORMATERROR_LABEL_TOO_LONGERROR_TOO_MANY_TCBSERROR_SIGNAL_REFUSEDERROR_DISCARDEDERROR_NOT_LOCKEDERROR_BAD_THREADID_ADDRERROR_BAD_ARGUMENTSERROR_BAD_PATHNAMEERROR_SIGNAL_PENDINGERROR_MAX_THRDS_REACHEDERROR_LOCK_FAILEDERROR_BUSYERROR_DEVICE_SUPPORT_IN_PROGRESSERROR_CANCEL_VIOLATIONERROR_ATOMIC_LOCKS_NOT_SUPPORTEDERROR_INVALID_SEGMENT_NUMBERERROR_INVALID_ORDINALERROR_INVALID_FLAG_NUMBERERROR_SEM_NOT_FOUNDERROR_INVALID_STARTING_CODESEGERROR_INVALID_STACKSEGERROR_INVALID_MODULETYPEERROR_INVALID_EXE_SIGNATUREERROR_EXE_MARKED_INVALIDERROR_BAD_EXE_FORMATERROR_ITERATED_DATA_EXCEEDS_64kERROR_INVALID_MINALLOCSIZEERROR_DYNLINK_FROM_INVALID_RINGERROR_IOPL_NOT_ENABLEDERROR_INVALID_SEGDPLERROR_AUTODATASEG_EXCEEDS_64kERROR_RING2SEG_MUST_BE_MOVABLEERROR_RELOC_CHAIN_XEEDS_SEGLIMERROR_INFLOOP_IN_RELOC_CHAINERROR_ENVVAR_NOT_FOUNDERROR_NO_SIGNAL_SENTERROR_FILENAME_EXCED_RANGEERROR_RING2_STACK_IN_USEERROR_META_EXPANSION_TOO_LONGERROR_INVALID_SIGNAL_NUMBERERROR_THREAD_1_INACTIVEERROR_LOCKEDERROR_TOO_MANY_MODULESERROR_NESTING_NOT_ALLOWEDERROR_EXE_MACHINE_TYPE_MISMATCHERROR_EXE_CANNOT_MODIFY_SIGNED_BINARYERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARYERROR_FILE_CHECKED_OUTERROR_CHECKOUT_REQUIREDERROR_BAD_FILE_TYPEERROR_FILE_TOO_LARGEERROR_FORMS_AUTH_REQUIREDERROR_VIRUS_INFECTEDERROR_VIRUS_DELETEDERROR_PIPE_LOCALERROR_BAD_PIPEERROR_PIPE_BUSYERROR_PIPE_NOT_CONNECTEDERROR_VC_DISCONNECTEDERROR_INVALID_EA_NAMEERROR_EA_LIST_INCONSISTENTERROR_CANNOT_COPYERROR_DIRECTORYERROR_EAS_DIDNT_FITERROR_EA_FILE_CORRUPTERROR_EA_TABLE_FULLERROR_INVALID_EA_HANDLEERROR_EAS_NOT_SUPPORTEDERROR_NOT_OWNERERROR_TOO_MANY_POSTSERROR_PARTIAL_COPYERROR_OPLOCK_NOT_GRANTEDERROR_INVALID_OPLOCK_PROTOCOLERROR_DISK_TOO_FRAGMENTEDERROR_DELETE_PENDINGERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTINGERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUMEERROR_SECURITY_STREAM_IS_INCONSISTENTERROR_INVALID_LOCK_RANGEERROR_IMAGE_SUBSYSTEM_NOT_PRESENTERROR_NOTIFICATION_GUID_ALREADY_DEFINEDERROR_INVALID_EXCEPTION_HANDLERERROR_DUPLICATE_PRIVILEGESERROR_NO_RANGES_PROCESSEDERROR_NOT_ALLOWED_ON_SYSTEM_FILEERROR_DISK_RESOURCES_EXHAUSTEDERROR_INVALID_TOKENERROR_DEVICE_FEATURE_NOT_SUPPORTEDERROR_MR_MID_NOT_FOUNDERROR_SCOPE_NOT_FOUNDERROR_UNDEFINED_SCOPEERROR_INVALID_CAPERROR_DEVICE_UNREACHABLEERROR_DEVICE_NO_RESOURCESERROR_DATA_CHECKSUM_ERRORERROR_INTERMIXED_KERNEL_EA_OPERATIONERROR_FILE_LEVEL_TRIM_NOT_SUPPORTEDERROR_OFFSET_ALIGNMENT_VIOLATIONERROR_INVALID_FIELD_IN_PARAMETER_LISTERROR_OPERATION_IN_PROGRESSERROR_BAD_DEVICE_PATHERROR_TOO_MANY_DESCRIPTORSERROR_SCRUB_DATA_DISABLEDERROR_NOT_REDUNDANT_STORAGEERROR_RESIDENT_FILE_NOT_SUPPORTEDERROR_COMPRESSED_FILE_NOT_SUPPORTEDERROR_DIRECTORY_NOT_SUPPORTEDERROR_NOT_READ_FROM_COPYERROR_FT_WRITE_FAILUREERROR_FT_DI_SCAN_REQUIREDERROR_INVALID_KERNEL_INFO_VERSIONERROR_INVALID_PEP_INFO_VERSIONERROR_OBJECT_NOT_EXTERNALLY_BACKEDERROR_EXTERNAL_BACKING_PROVIDER_UNKNOWNERROR_ENCLAVE_FAILUREERROR_FAIL_NOACTION_REBOOTERROR_FAIL_SHUTDOWNERROR_FAIL_RESTARTERROR_MAX_SESSIONS_REACHEDERROR_THREAD_MODE_ALREADY_BACKGROUNDERROR_THREAD_MODE_NOT_BACKGROUNDERROR_PROCESS_MODE_ALREADY_BACKGROUNDERROR_PROCESS_MODE_NOT_BACKGROUNDERROR_DEVICE_HARDWARE_ERRORERROR_INVALID_ADDRESSERROR_USER_PROFILE_LOADERROR_ARITHMETIC_OVERFLOWERROR_VERIFIER_STOPERROR_ABIOS_ERRORERROR_WX86_WARNINGERROR_WX86_ERRORERROR_TIMER_NOT_CANCELEDERROR_UNWINDERROR_BAD_STACKERROR_INVALID_UNWIND_TARGETERROR_INVALID_PORT_ATTRIBUTESERROR_PORT_MESSAGE_TOO_LONGERROR_INVALID_QUOTA_LOWERERROR_DEVICE_ALREADY_ATTACHEDERROR_INSTRUCTION_MISALIGNMENTERROR_PROFILING_NOT_STARTEDERROR_PROFILING_NOT_STOPPEDERROR_COULD_NOT_INTERPRETERROR_PROFILING_AT_LIMITERROR_CANT_WAITERROR_CANT_TERMINATE_SELFERROR_UNEXPECTED_MM_CREATE_ERRERROR_UNEXPECTED_MM_MAP_ERRORERROR_UNEXPECTED_MM_EXTEND_ERRERROR_BAD_FUNCTION_TABLEERROR_NO_GUID_TRANSLATIONERROR_INVALID_LDT_SIZEERROR_INVALID_LDT_OFFSETERROR_INVALID_LDT_DESCRIPTORERROR_TOO_MANY_THREADSERROR_THREAD_NOT_IN_PROCESSERROR_PAGEFILE_QUOTA_EXCEEDEDERROR_LOGON_SERVER_CONFLICTERROR_SYNCHRONIZATION_REQUIREDERROR_NET_OPEN_FAILEDERROR_IO_PRIVILEGE_FAILEDERROR_CONTROL_C_EXITERROR_MISSING_SYSTEMFILEERROR_UNHANDLED_EXCEPTIONERROR_APP_INIT_FAILUREERROR_PAGEFILE_CREATE_FAILEDERROR_INVALID_IMAGE_HASHERROR_NO_PAGEFILEERROR_ILLEGAL_FLOAT_CONTEXTERROR_NO_EVENT_PAIRERROR_DOMAIN_CTRLR_CONFIG_ERRORERROR_ILLEGAL_CHARACTERERROR_UNDEFINED_CHARACTERERROR_FLOPPY_VOLUMEERROR_BIOS_FAILED_TO_CONNECT_INTERRUPTERROR_BACKUP_CONTROLLERERROR_MUTANT_LIMIT_EXCEEDEDERROR_FS_DRIVER_REQUIREDERROR_CANNOT_LOAD_REGISTRY_FILEERROR_DEBUG_ATTACH_FAILEDERROR_SYSTEM_PROCESS_TERMINATEDERROR_DATA_NOT_ACCEPTEDERROR_VDM_HARD_ERRORERROR_DRIVER_CANCEL_TIMEOUTERROR_REPLY_MESSAGE_MISMATCHERROR_LOST_WRITEBEHIND_DATAERROR_CLIENT_SERVER_PARAMETERS_INVALIDERROR_NOT_TINY_STREAMERROR_STACK_OVERFLOW_READERROR_CONVERT_TO_LARGEERROR_FOUND_OUT_OF_SCOPEERROR_ALLOCATE_BUCKETERROR_MARSHALL_OVERFLOWERROR_INVALID_VARIANTERROR_BAD_COMPRESSION_BUFFERERROR_AUDIT_FAILEDERROR_TIMER_RESOLUTION_NOT_SETERROR_INSUFFICIENT_LOGON_INFOERROR_BAD_DLL_ENTRYPOINTERROR_BAD_SERVICE_ENTRYPOINTERROR_IP_ADDRESS_CONFLICT1ERROR_IP_ADDRESS_CONFLICT2ERROR_REGISTRY_QUOTA_LIMITERROR_NO_CALLBACK_ACTIVEERROR_PWD_TOO_SHORTERROR_PWD_TOO_RECENTERROR_PWD_HISTORY_CONFLICTERROR_UNSUPPORTED_COMPRESSIONERROR_INVALID_HW_PROFILEERROR_INVALID_PLUGPLAY_DEVICE_PATHERROR_QUOTA_LIST_INCONSISTENTERROR_EVALUATION_EXPIRATIONERROR_ILLEGAL_DLL_RELOCATIONERROR_DLL_INIT_FAILED_LOGOFFERROR_VALIDATE_CONTINUEERROR_NO_MORE_MATCHESERROR_RANGE_LIST_CONFLICTERROR_SERVER_SID_MISMATCHERROR_CANT_ENABLE_DENY_ONLYERROR_FLOAT_MULTIPLE_FAULTSERROR_FLOAT_MULTIPLE_TRAPSERROR_NOINTERFACEERROR_DRIVER_FAILED_SLEEPERROR_CORRUPT_SYSTEM_FILEERROR_COMMITMENT_MINIMUMERROR_PNP_RESTART_ENUMERATIONERROR_SYSTEM_IMAGE_BAD_SIGNATUREERROR_PNP_REBOOT_REQUIREDERROR_INSUFFICIENT_POWERERROR_MULTIPLE_FAULT_VIOLATIONERROR_SYSTEM_SHUTDOWNERROR_PORT_NOT_SETERROR_DS_VERSION_CHECK_FAILUREERROR_RANGE_NOT_FOUNDERROR_NOT_SAFE_MODE_DRIVERERROR_FAILED_DRIVER_ENTRYERROR_DEVICE_ENUMERATION_ERRORERROR_MOUNT_POINT_NOT_RESOLVEDERROR_INVALID_DEVICE_OBJECT_PARAMETERERROR_MCA_OCCUREDERROR_DRIVER_DATABASE_ERRORERROR_SYSTEM_HIVE_TOO_LARGEERROR_DRIVER_FAILED_PRIOR_UNLOADERROR_VOLSNAP_PREPARE_HIBERNATEERROR_HIBERNATION_FAILUREERROR_PWD_TOO_LONGERROR_FILE_SYSTEM_LIMITATIONERROR_ASSERTION_FAILUREERROR_ACPI_ERRORERROR_WOW_ASSERTIONERROR_PNP_BAD_MPS_TABLEERROR_PNP_TRANSLATION_FAILEDERROR_PNP_IRQ_TRANSLATION_FAILEDERROR_PNP_INVALID_IDERROR_WAKE_SYSTEM_DEBUGGERERROR_HANDLES_CLOSEDERROR_EXTRANEOUS_INFORMATIONERROR_RXACT_COMMIT_NECESSARYERROR_MEDIA_CHECKERROR_GUID_SUBSTITUTION_MADEERROR_STOPPED_ON_SYMLINKERROR_LONGJUMPERROR_PLUGPLAY_QUERY_VETOEDERROR_UNWIND_CONSOLIDATEERROR_REGISTRY_HIVE_RECOVEREDERROR_DLL_MIGHT_BE_INSECUREERROR_DLL_MIGHT_BE_INCOMPATIBLEERROR_DBG_EXCEPTION_NOT_HANDLEDERROR_DBG_REPLY_LATERERROR_DBG_UNABLE_TO_PROVIDE_HANDLEERROR_DBG_TERMINATE_THREADERROR_DBG_TERMINATE_PROCESSERROR_DBG_CONTROL_CERROR_DBG_PRINTEXCEPTION_CERROR_DBG_RIPEXCEPTIONERROR_DBG_CONTROL_BREAKERROR_DBG_COMMAND_EXCEPTIONERROR_OBJECT_NAME_EXISTSERROR_THREAD_WAS_SUSPENDEDERROR_IMAGE_NOT_AT_BASEERROR_RXACT_STATE_CREATEDERROR_SEGMENT_NOTIFICATIONERROR_BAD_CURRENT_DIRECTORYERROR_FT_READ_RECOVERY_FROM_BACKUPERROR_FT_WRITE_RECOVERYERROR_IMAGE_MACHINE_TYPE_MISMATCHERROR_RECEIVE_PARTIALERROR_RECEIVE_EXPEDITEDERROR_RECEIVE_PARTIAL_EXPEDITEDERROR_EVENT_DONEERROR_EVENT_PENDINGERROR_CHECKING_FILE_SYSTEMERROR_FATAL_APP_EXITERROR_PREDEFINED_HANDLEERROR_WAS_UNLOCKEDERROR_SERVICE_NOTIFICATIONERROR_WAS_LOCKEDERROR_LOG_HARD_ERRORERROR_ALREADY_WIN32ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXEERROR_NO_YIELD_PERFORMEDERROR_TIMER_RESUME_IGNOREDERROR_ARBITRATION_UNHANDLEDERROR_CARDBUS_NOT_SUPPORTEDERROR_MP_PROCESSOR_MISMATCHERROR_HIBERNATEDERROR_RESUME_HIBERNATIONERROR_FIRMWARE_UPDATEDERROR_DRIVERS_LEAKING_LOCKED_PAGESERROR_WAKE_SYSTEMERROR_WAIT_1ERROR_WAIT_2ERROR_WAIT_3ERROR_WAIT_63ERROR_ABANDONED_WAIT_0ERROR_ABANDONED_WAIT_63ERROR_USER_APCERROR_KERNEL_APCERROR_ALERTEDERROR_ELEVATION_REQUIREDERROR_REPARSEERROR_OPLOCK_BREAK_IN_PROGRESSERROR_VOLUME_MOUNTEDERROR_RXACT_COMMITTEDERROR_NOTIFY_CLEANUPERROR_PRIMARY_TRANSPORT_CONNECT_FAILEDERROR_PAGE_FAULT_TRANSITIONERROR_PAGE_FAULT_DEMAND_ZEROERROR_PAGE_FAULT_COPY_ON_WRITEERROR_PAGE_FAULT_GUARD_PAGEERROR_PAGE_FAULT_PAGING_FILEERROR_CACHE_PAGE_LOCKEDERROR_CRASH_DUMPERROR_BUFFER_ALL_ZEROSERROR_REPARSE_OBJECTERROR_RESOURCE_REQUIREMENTS_CHANGEDERROR_TRANSLATION_COMPLETEERROR_NOTHING_TO_TERMINATEERROR_PROCESS_NOT_IN_JOBERROR_PROCESS_IN_JOBERROR_VOLSNAP_HIBERNATE_READYERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLYERROR_INTERRUPT_VECTOR_ALREADY_CONNECTEDERROR_INTERRUPT_STILL_CONNECTEDERROR_WAIT_FOR_OPLOCKERROR_DBG_EXCEPTION_HANDLEDERROR_DBG_CONTINUEERROR_CALLBACK_POP_STACKERROR_COMPRESSION_DISABLEDERROR_CANTFETCHBACKWARDSERROR_CANTSCROLLBACKWARDSERROR_ROWSNOTRELEASEDERROR_BAD_ACCESSOR_FLAGSERROR_ERRORS_ENCOUNTEREDERROR_NOT_CAPABLEERROR_REQUEST_OUT_OF_SEQUENCEERROR_VERSION_PARSE_ERRORERROR_BADSTARTPOSITIONERROR_MEMORY_HARDWAREERROR_DISK_REPAIR_DISABLEDERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZEERROR_SYSTEM_POWERSTATE_TRANSITIONERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITIONERROR_MCA_EXCEPTIONERROR_ACCESS_AUDIT_BY_POLICYERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICYERROR_ABANDON_HIBERFILEERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTEDERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERRORERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERRORERROR_BAD_MCFG_TABLEERROR_DISK_REPAIR_REDIRECTEDERROR_DISK_REPAIR_UNSUCCESSFULERROR_CORRUPT_LOG_OVERFULLERROR_CORRUPT_LOG_CORRUPTEDERROR_CORRUPT_LOG_UNAVAILABLEERROR_CORRUPT_LOG_DELETED_FULLERROR_CORRUPT_LOG_CLEAREDERROR_ORPHAN_NAME_EXHAUSTEDERROR_OPLOCK_SWITCHED_TO_NEW_HANDLEERROR_CANNOT_GRANT_REQUESTED_OPLOCKERROR_CANNOT_BREAK_OPLOCKERROR_OPLOCK_HANDLE_CLOSEDERROR_NO_ACE_CONDITIONERROR_INVALID_ACE_CONDITIONERROR_FILE_HANDLE_REVOKEDERROR_IMAGE_AT_DIFFERENT_BASEERROR_ENCRYPTED_IO_NOT_POSSIBLEERROR_EA_ACCESS_DENIEDERROR_OPERATION_ABORTEDERROR_NOACCESSERROR_SWAPERRORERROR_STACK_OVERFLOWERROR_INVALID_MESSAGEERROR_CAN_NOT_COMPLETEERROR_INVALID_FLAGSERROR_UNRECOGNIZED_VOLUMEERROR_FILE_INVALIDERROR_FULLSCREEN_MODEERROR_NO_TOKENERROR_BADDBERROR_BADKEYERROR_CANTOPENERROR_CANTREADERROR_CANTWRITEERROR_REGISTRY_RECOVEREDERROR_REGISTRY_CORRUPTERROR_REGISTRY_IO_FAILEDERROR_NOT_REGISTRY_FILEERROR_KEY_DELETEDERROR_NO_LOG_SPACEERROR_KEY_HAS_CHILDRENERROR_CHILD_MUST_BE_VOLATILEERROR_NOTIFY_ENUM_DIRERROR_DEPENDENT_SERVICES_RUNNINGERROR_INVALID_SERVICE_CONTROLERROR_SERVICE_REQUEST_TIMEOUTERROR_SERVICE_NO_THREADERROR_SERVICE_DATABASE_LOCKEDERROR_SERVICE_ALREADY_RUNNINGERROR_INVALID_SERVICE_ACCOUNTERROR_SERVICE_DISABLEDERROR_CIRCULAR_DEPENDENCYERROR_SERVICE_DOES_NOT_EXISTERROR_SERVICE_CANNOT_ACCEPT_CTRLERROR_SERVICE_NOT_ACTIVEERROR_FAILED_SERVICE_CONTROLLER_CONNECTERROR_EXCEPTION_IN_SERVICEERROR_DATABASE_DOES_NOT_EXISTERROR_SERVICE_SPECIFIC_ERRORERROR_PROCESS_ABORTEDERROR_SERVICE_DEPENDENCY_FAILERROR_SERVICE_LOGON_FAILEDERROR_SERVICE_START_HANGERROR_INVALID_SERVICE_LOCKERROR_SERVICE_MARKED_FOR_DELETEERROR_SERVICE_EXISTSERROR_ALREADY_RUNNING_LKGERROR_SERVICE_DEPENDENCY_DELETEDERROR_BOOT_ALREADY_ACCEPTEDERROR_SERVICE_NEVER_STARTEDERROR_DUPLICATE_SERVICE_NAMEERROR_DIFFERENT_SERVICE_ACCOUNTERROR_CANNOT_DETECT_DRIVER_FAILUREERROR_CANNOT_DETECT_PROCESS_ABORTERROR_NO_RECOVERY_PROGRAMERROR_SERVICE_NOT_IN_EXEERROR_NOT_SAFEBOOT_SERVICEERROR_END_OF_MEDIAERROR_FILEMARK_DETECTEDERROR_BEGINNING_OF_MEDIAERROR_SETMARK_DETECTEDERROR_NO_DATA_DETECTEDERROR_PARTITION_FAILUREERROR_INVALID_BLOCK_LENGTHERROR_DEVICE_NOT_PARTITIONEDERROR_UNABLE_TO_LOCK_MEDIAERROR_UNABLE_TO_UNLOAD_MEDIAERROR_MEDIA_CHANGEDERROR_BUS_RESETERROR_NO_MEDIA_IN_DRIVEERROR_NO_UNICODE_TRANSLATIONERROR_DLL_INIT_FAILEDERROR_SHUTDOWN_IN_PROGRESSERROR_NO_SHUTDOWN_IN_PROGRESSERROR_IO_DEVICEERROR_SERIAL_NO_DEVICEERROR_IRQ_BUSYERROR_MORE_WRITESERROR_COUNTER_TIMEOUTERROR_FLOPPY_ID_MARK_NOT_FOUNDERROR_FLOPPY_WRONG_CYLINDERERROR_FLOPPY_UNKNOWN_ERRORERROR_FLOPPY_BAD_REGISTERSERROR_DISK_RECALIBRATE_FAILEDERROR_DISK_OPERATION_FAILEDERROR_DISK_RESET_FAILEDERROR_EOM_OVERFLOWERROR_NOT_ENOUGH_SERVER_MEMORYERROR_POSSIBLE_DEADLOCKERROR_MAPPED_ALIGNMENTERROR_SET_POWER_STATE_VETOEDERROR_SET_POWER_STATE_FAILEDERROR_TOO_MANY_LINKSERROR_OLD_WIN_VERSIONERROR_APP_WRONG_OSERROR_SINGLE_INSTANCE_APPERROR_RMODE_APPERROR_INVALID_DLLERROR_NO_ASSOCIATIONERROR_DDE_FAILERROR_DLL_NOT_FOUNDERROR_NO_MORE_USER_HANDLESERROR_MESSAGE_SYNC_ONLYERROR_SOURCE_ELEMENT_EMPTYERROR_DESTINATION_ELEMENT_FULLERROR_ILLEGAL_ELEMENT_ADDRESSERROR_MAGAZINE_NOT_PRESENTERROR_DEVICE_REINITIALIZATION_NEEDEDERROR_DEVICE_REQUIRES_CLEANINGERROR_DEVICE_DOOR_OPENERROR_DEVICE_NOT_CONNECTEDERROR_NO_MATCHERROR_SET_NOT_FOUNDERROR_POINT_NOT_FOUNDERROR_NO_TRACKING_SERVICEERROR_NO_VOLUME_IDERROR_UNABLE_TO_REMOVE_REPLACEDERROR_UNABLE_TO_MOVE_REPLACEMENTERROR_UNABLE_TO_MOVE_REPLACEMENT_2ERROR_JOURNAL_DELETE_IN_PROGRESSERROR_JOURNAL_NOT_ACTIVEERROR_POTENTIAL_FILE_FOUNDERROR_JOURNAL_ENTRY_DELETEDERROR_SHUTDOWN_IS_SCHEDULEDERROR_SHUTDOWN_USERS_LOGGED_ONERROR_BAD_DEVICEERROR_CONNECTION_UNAVAILERROR_DEVICE_ALREADY_REMEMBEREDERROR_NO_NET_OR_BAD_PATHERROR_BAD_PROVIDERERROR_CANNOT_OPEN_PROFILEERROR_BAD_PROFILEERROR_NOT_CONTAINERERROR_EXTENDED_ERRORERROR_INVALID_GROUPNAMEERROR_INVALID_COMPUTERNAMEERROR_INVALID_EVENTNAMEERROR_INVALID_DOMAINNAMEERROR_INVALID_SERVICENAMEERROR_INVALID_NETNAMEERROR_INVALID_SHARENAMEERROR_INVALID_PASSWORDNAMEERROR_INVALID_MESSAGENAMEERROR_INVALID_MESSAGEDESTERROR_SESSION_CREDENTIAL_CONFLICTERROR_REMOTE_SESSION_LIMIT_EXCEEDEDERROR_DUP_DOMAINNAMEERROR_NO_NETWORKERROR_CANCELLEDERROR_USER_MAPPED_FILEERROR_CONNECTION_REFUSEDERROR_GRACEFUL_DISCONNECTERROR_ADDRESS_ALREADY_ASSOCIATEDERROR_CONNECTION_INVALIDERROR_CONNECTION_ACTIVEERROR_NETWORK_UNREACHABLEERROR_HOST_UNREACHABLEERROR_PROTOCOL_UNREACHABLEERROR_PORT_UNREACHABLEERROR_REQUEST_ABORTEDERROR_CONNECTION_ABORTEDERROR_RETRYERROR_CONNECTION_COUNT_LIMITERROR_LOGIN_TIME_RESTRICTIONERROR_LOGIN_WKSTA_RESTRICTIONERROR_INCORRECT_ADDRESSERROR_ALREADY_REGISTEREDERROR_SERVICE_NOT_FOUNDERROR_NOT_AUTHENTICATEDERROR_NOT_LOGGED_ONERROR_CONTINUEERROR_ALREADY_INITIALIZEDERROR_NO_MORE_DEVICESERROR_NO_SUCH_SITEERROR_DOMAIN_CONTROLLER_EXISTSERROR_ONLY_IF_CONNECTEDERROR_OVERRIDE_NOCHANGESERROR_BAD_USER_PROFILEERROR_NOT_SUPPORTED_ON_SBSERROR_SERVER_SHUTDOWN_IN_PROGRESSERROR_HOST_DOWNERROR_NON_ACCOUNT_SIDERROR_NON_DOMAIN_SIDERROR_APPHELP_BLOCKERROR_ACCESS_DISABLED_BY_POLICYERROR_REG_NAT_CONSUMPTIONERROR_CSCSHARE_OFFLINEERROR_PKINIT_FAILUREERROR_SMARTCARD_SUBSYSTEM_FAILUREERROR_DOWNGRADE_DETECTEDERROR_MACHINE_LOCKEDERROR_CALLBACK_SUPPLIED_INVALID_DATAERROR_SYNC_FOREGROUND_REFRESH_REQUIREDERROR_DRIVER_BLOCKEDERROR_INVALID_IMPORT_OF_NON_DLLERROR_ACCESS_DISABLED_WEBBLADEERROR_ACCESS_DISABLED_WEBBLADE_TAMPERERROR_RECOVERY_FAILUREERROR_ALREADY_FIBERERROR_ALREADY_THREADERROR_STACK_BUFFER_OVERRUNERROR_PARAMETER_QUOTA_EXCEEDEDERROR_DEBUGGER_INACTIVEERROR_DELAY_LOAD_FAILEDERROR_VDM_DISALLOWEDERROR_UNIDENTIFIED_ERRORERROR_INVALID_CRUNTIME_PARAMETERERROR_BEYOND_VDLERROR_INCOMPATIBLE_SERVICE_SID_TYPEERROR_DRIVER_PROCESS_TERMINATEDERROR_IMPLEMENTATION_LIMITERROR_PROCESS_IS_PROTECTEDERROR_SERVICE_NOTIFY_CLIENT_LAGGINGERROR_DISK_QUOTA_EXCEEDEDERROR_CONTENT_BLOCKEDERROR_INCOMPATIBLE_SERVICE_PRIVILEGEERROR_APP_HANGERROR_INVALID_LABELERROR_NOT_ALL_ASSIGNEDERROR_SOME_NOT_MAPPEDERROR_NO_QUOTAS_FOR_ACCOUNTERROR_LOCAL_USER_SESSION_KEYERROR_NULL_LM_PASSWORDERROR_UNKNOWN_REVISIONERROR_REVISION_MISMATCHERROR_INVALID_OWNERERROR_INVALID_PRIMARY_GROUPERROR_NO_IMPERSONATION_TOKENERROR_CANT_DISABLE_MANDATORYERROR_NO_LOGON_SERVERSERROR_NO_SUCH_LOGON_SESSIONERROR_NO_SUCH_PRIVILEGEERROR_PRIVILEGE_NOT_HELDERROR_INVALID_ACCOUNT_NAMEERROR_USER_EXISTSERROR_NO_SUCH_USERERROR_GROUP_EXISTSERROR_NO_SUCH_GROUPERROR_MEMBER_IN_GROUPERROR_MEMBER_NOT_IN_GROUPERROR_LAST_ADMINERROR_WRONG_PASSWORDERROR_ILL_FORMED_PASSWORDERROR_PASSWORD_RESTRICTIONERROR_LOGON_FAILUREERROR_ACCOUNT_RESTRICTIONERROR_INVALID_LOGON_HOURSERROR_INVALID_WORKSTATIONERROR_PASSWORD_EXPIREDERROR_ACCOUNT_DISABLEDERROR_NONE_MAPPEDERROR_TOO_MANY_LUIDS_REQUESTEDERROR_LUIDS_EXHAUSTEDERROR_INVALID_SUB_AUTHORITYERROR_INVALID_ACLERROR_INVALID_SIDERROR_INVALID_SECURITY_DESCRERROR_BAD_INHERITANCE_ACLERROR_SERVER_DISABLEDERROR_SERVER_NOT_DISABLEDERROR_INVALID_ID_AUTHORITYERROR_ALLOTTED_SPACE_EXCEEDEDERROR_INVALID_GROUP_ATTRIBUTESERROR_BAD_IMPERSONATION_LEVELERROR_CANT_OPEN_ANONYMOUSERROR_BAD_VALIDATION_CLASSERROR_BAD_TOKEN_TYPEERROR_NO_SECURITY_ON_OBJECTERROR_CANT_ACCESS_DOMAIN_INFOERROR_INVALID_SERVER_STATEERROR_INVALID_DOMAIN_STATEERROR_INVALID_DOMAIN_ROLEERROR_NO_SUCH_DOMAINERROR_DOMAIN_EXISTSERROR_DOMAIN_LIMIT_EXCEEDEDERROR_INTERNAL_DB_CORRUPTIONERROR_INTERNAL_ERRORERROR_GENERIC_NOT_MAPPEDERROR_BAD_DESCRIPTOR_FORMATERROR_NOT_LOGON_PROCESSERROR_LOGON_SESSION_EXISTSERROR_NO_SUCH_PACKAGEERROR_BAD_LOGON_SESSION_STATEERROR_LOGON_SESSION_COLLISIONERROR_INVALID_LOGON_TYPEERROR_CANNOT_IMPERSONATEERROR_RXACT_INVALID_STATEERROR_RXACT_COMMIT_FAILUREERROR_SPECIAL_ACCOUNTERROR_SPECIAL_GROUPERROR_SPECIAL_USERERROR_MEMBERS_PRIMARY_GROUPERROR_TOKEN_ALREADY_IN_USEERROR_NO_SUCH_ALIASERROR_MEMBER_NOT_IN_ALIASERROR_MEMBER_IN_ALIASERROR_ALIAS_EXISTSERROR_LOGON_NOT_GRANTEDERROR_TOO_MANY_SECRETSERROR_SECRET_TOO_LONGERROR_INTERNAL_DB_ERRORERROR_TOO_MANY_CONTEXT_IDSERROR_LOGON_TYPE_NOT_GRANTEDERROR_NT_CROSS_ENCRYPTION_REQUIREDERROR_NO_SUCH_MEMBERERROR_INVALID_MEMBERERROR_TOO_MANY_SIDSERROR_LM_CROSS_ENCRYPTION_REQUIREDERROR_NO_INHERITANCEERROR_FILE_CORRUPTERROR_DISK_CORRUPTERROR_NO_USER_SESSION_KEYERROR_LICENSE_QUOTA_EXCEEDEDERROR_WRONG_TARGET_NAMEERROR_MUTUAL_AUTH_FAILEDERROR_TIME_SKEWERROR_CURRENT_DOMAIN_NOT_ALLOWEDERROR_INVALID_WINDOW_HANDLEERROR_INVALID_MENU_HANDLEERROR_INVALID_CURSOR_HANDLEERROR_INVALID_ACCEL_HANDLEERROR_INVALID_HOOK_HANDLEERROR_INVALID_DWP_HANDLEERROR_TLW_WITH_WSCHILDERROR_CANNOT_FIND_WND_CLASSERROR_WINDOW_OF_OTHER_THREADERROR_HOTKEY_ALREADY_REGISTEREDERROR_CLASS_ALREADY_EXISTSERROR_CLASS_DOES_NOT_EXISTERROR_CLASS_HAS_WINDOWSERROR_INVALID_INDEXERROR_INVALID_ICON_HANDLEERROR_PRIVATE_DIALOG_INDEXERROR_LISTBOX_ID_NOT_FOUNDERROR_NO_WILDCARD_CHARACTERSERROR_HOTKEY_NOT_REGISTEREDERROR_WINDOW_NOT_DIALOGERROR_CONTROL_ID_NOT_FOUNDERROR_INVALID_COMBOBOX_MESSAGEERROR_WINDOW_NOT_COMBOBOXERROR_INVALID_EDIT_HEIGHTERROR_DC_NOT_FOUNDERROR_INVALID_HOOK_FILTERERROR_INVALID_FILTER_PROCERROR_HOOK_NEEDS_HMODERROR_GLOBAL_ONLY_HOOKERROR_JOURNAL_HOOK_SETERROR_HOOK_NOT_INSTALLEDERROR_INVALID_LB_MESSAGEERROR_SETCOUNT_ON_BAD_LBERROR_LB_WITHOUT_TABSTOPSERROR_DESTROY_OBJECT_OF_OTHER_THREADERROR_CHILD_WINDOW_MENUERROR_NO_SYSTEM_MENUERROR_INVALID_MSGBOX_STYLEERROR_INVALID_SPI_VALUEERROR_SCREEN_ALREADY_LOCKEDERROR_HWNDS_HAVE_DIFF_PARENTERROR_NOT_CHILD_WINDOWERROR_INVALID_GW_COMMANDERROR_INVALID_THREAD_IDERROR_NON_MDICHILD_WINDOWERROR_POPUP_ALREADY_ACTIVEERROR_NO_SCROLLBARSERROR_INVALID_SCROLLBAR_RANGEERROR_INVALID_SHOWWIN_COMMANDERROR_NO_SYSTEM_RESOURCESERROR_NONPAGED_SYSTEM_RESOURCESERROR_PAGED_SYSTEM_RESOURCESERROR_WORKING_SET_QUOTAERROR_PAGEFILE_QUOTAERROR_COMMITMENT_LIMITERROR_MENU_ITEM_NOT_FOUNDERROR_INVALID_KEYBOARD_HANDLEERROR_HOOK_TYPE_NOT_ALLOWEDERROR_REQUIRES_INTERACTIVE_WINDOWSTATIONERROR_INVALID_MONITOR_HANDLEERROR_INCORRECT_SIZEERROR_SYMLINK_CLASS_DISABLEDERROR_SYMLINK_NOT_SUPPORTEDERROR_XML_PARSE_ERRORERROR_XMLDSIG_ERRORERROR_RESTART_APPLICATIONERROR_WRONG_COMPARTMENTERROR_AUTHIP_FAILUREERROR_NO_NVRAM_RESOURCESERROR_NOT_GUI_PROCESSERROR_EVENTLOG_FILE_CORRUPTERROR_EVENTLOG_CANT_STARTERROR_LOG_FILE_FULLERROR_EVENTLOG_FILE_CHANGEDERROR_INVALID_TASK_NAMEERROR_INVALID_TASK_INDEXERROR_THREAD_ALREADY_IN_TASKERROR_INSTALL_SERVICE_FAILUREERROR_INSTALL_USEREXITERROR_INSTALL_FAILUREERROR_INSTALL_SUSPENDERROR_UNKNOWN_PRODUCTERROR_UNKNOWN_FEATUREERROR_UNKNOWN_COMPONENTERROR_UNKNOWN_PROPERTYERROR_INVALID_HANDLE_STATEERROR_BAD_CONFIGURATIONERROR_INDEX_ABSENTERROR_INSTALL_SOURCE_ABSENTERROR_INSTALL_PACKAGE_VERSIONERROR_PRODUCT_UNINSTALLEDERROR_BAD_QUERY_SYNTAXERROR_INVALID_FIELDERROR_DEVICE_REMOVEDERROR_INSTALL_ALREADY_RUNNINGERROR_INSTALL_PACKAGE_OPEN_FAILEDERROR_INSTALL_PACKAGE_INVALIDERROR_INSTALL_UI_FAILUREERROR_INSTALL_LOG_FAILUREERROR_INSTALL_LANGUAGE_UNSUPPORTEDERROR_INSTALL_TRANSFORM_FAILUREERROR_INSTALL_PACKAGE_REJECTEDERROR_FUNCTION_NOT_CALLEDERROR_FUNCTION_FAILEDERROR_INVALID_TABLEERROR_DATATYPE_MISMATCHERROR_UNSUPPORTED_TYPEERROR_CREATE_FAILEDERROR_INSTALL_TEMP_UNWRITABLEERROR_INSTALL_PLATFORM_UNSUPPORTEDERROR_INSTALL_NOTUSEDERROR_PATCH_PACKAGE_OPEN_FAILEDERROR_PATCH_PACKAGE_INVALIDERROR_PATCH_PACKAGE_UNSUPPORTEDERROR_PRODUCT_VERSIONERROR_INVALID_COMMAND_LINEERROR_INSTALL_REMOTE_DISALLOWEDERROR_SUCCESS_REBOOT_INITIATEDERROR_PATCH_TARGET_NOT_FOUNDERROR_PATCH_PACKAGE_REJECTEDERROR_INSTALL_TRANSFORM_REJECTEDERROR_INSTALL_REMOTE_PROHIBITEDERROR_PATCH_REMOVAL_UNSUPPORTEDERROR_UNKNOWN_PATCHERROR_PATCH_NO_SEQUENCEERROR_PATCH_REMOVAL_DISALLOWEDERROR_INVALID_PATCH_XMLERROR_PATCH_MANAGED_ADVERTISED_PRODUCTERROR_INSTALL_SERVICE_SAFEBOOTERROR_FAIL_FAST_EXCEPTIONERROR_INSTALL_REJECTEDERROR_DYNAMIC_CODE_BLOCKEDRPC_S_INVALID_STRING_BINDINGRPC_S_WRONG_KIND_OF_BINDINGRPC_S_INVALID_BINDINGRPC_S_PROTSEQ_NOT_SUPPORTEDRPC_S_INVALID_RPC_PROTSEQRPC_S_INVALID_STRING_UUIDRPC_S_INVALID_ENDPOINT_FORMATRPC_S_INVALID_NET_ADDRRPC_S_NO_ENDPOINT_FOUNDRPC_S_INVALID_TIMEOUTRPC_S_OBJECT_NOT_FOUNDRPC_S_ALREADY_REGISTEREDRPC_S_TYPE_ALREADY_REGISTEREDRPC_S_ALREADY_LISTENINGRPC_S_NO_PROTSEQS_REGISTEREDRPC_S_NOT_LISTENINGRPC_S_UNKNOWN_MGR_TYPERPC_S_UNKNOWN_IFRPC_S_NO_BINDINGSRPC_S_NO_PROTSEQSRPC_S_CANT_CREATE_ENDPOINTRPC_S_OUT_OF_RESOURCESRPC_S_SERVER_UNAVAILABLERPC_S_SERVER_TOO_BUSYRPC_S_INVALID_NETWORK_OPTIONSRPC_S_NO_CALL_ACTIVERPC_S_CALL_FAILEDRPC_S_CALL_FAILED_DNERPC_S_PROTOCOL_ERRORRPC_S_PROXY_ACCESS_DENIEDRPC_S_UNSUPPORTED_TRANS_SYNRPC_S_UNSUPPORTED_TYPERPC_S_INVALID_TAGRPC_S_INVALID_BOUNDRPC_S_NO_ENTRY_NAMERPC_S_INVALID_NAME_SYNTAXRPC_S_UNSUPPORTED_NAME_SYNTAXRPC_S_UUID_NO_ADDRESSRPC_S_DUPLICATE_ENDPOINTRPC_S_UNKNOWN_AUTHN_TYPERPC_S_MAX_CALLS_TOO_SMALLRPC_S_STRING_TOO_LONGRPC_S_PROTSEQ_NOT_FOUNDRPC_S_PROCNUM_OUT_OF_RANGERPC_S_BINDING_HAS_NO_AUTHRPC_S_UNKNOWN_AUTHN_SERVICERPC_S_UNKNOWN_AUTHN_LEVELRPC_S_INVALID_AUTH_IDENTITYRPC_S_UNKNOWN_AUTHZ_SERVICEEPT_S_INVALID_ENTRYEPT_S_CANT_PERFORM_OPEPT_S_NOT_REGISTEREDRPC_S_NOTHING_TO_EXPORTRPC_S_INCOMPLETE_NAMERPC_S_INVALID_VERS_OPTIONRPC_S_NO_MORE_MEMBERSRPC_S_NOT_ALL_OBJS_UNEXPORTEDRPC_S_INTERFACE_NOT_FOUNDRPC_S_ENTRY_ALREADY_EXISTSRPC_S_ENTRY_NOT_FOUNDRPC_S_NAME_SERVICE_UNAVAILABLERPC_S_INVALID_NAF_IDRPC_S_CANNOT_SUPPORTRPC_S_NO_CONTEXT_AVAILABLERPC_S_INTERNAL_ERRORRPC_S_ZERO_DIVIDERPC_S_ADDRESS_ERRORRPC_S_FP_DIV_ZERORPC_S_FP_UNDERFLOWRPC_S_FP_OVERFLOWRPC_X_NO_MORE_ENTRIESRPC_X_SS_CHAR_TRANS_OPEN_FAILRPC_X_SS_CHAR_TRANS_SHORT_FILERPC_X_SS_IN_NULL_CONTEXTRPC_X_SS_CONTEXT_DAMAGEDRPC_X_SS_HANDLES_MISMATCHRPC_X_SS_CANNOT_GET_CALL_HANDLERPC_X_NULL_REF_POINTERRPC_X_ENUM_VALUE_OUT_OF_RANGERPC_X_BYTE_COUNT_TOO_SMALLRPC_X_BAD_STUB_DATAERROR_INVALID_USER_BUFFERERROR_UNRECOGNIZED_MEDIAERROR_NO_TRUST_LSA_SECRETERROR_NO_TRUST_SAM_ACCOUNTERROR_TRUSTED_DOMAIN_FAILUREERROR_TRUSTED_RELATIONSHIP_FAILUREERROR_TRUST_FAILURERPC_S_CALL_IN_PROGRESSERROR_NETLOGON_NOT_STARTEDERROR_ACCOUNT_EXPIREDERROR_REDIRECTOR_HAS_OPEN_HANDLESERROR_PRINTER_DRIVER_ALREADY_INSTALLEDERROR_UNKNOWN_PORTERROR_UNKNOWN_PRINTER_DRIVERERROR_UNKNOWN_PRINTPROCESSORERROR_INVALID_SEPARATOR_FILEERROR_INVALID_PRIORITYERROR_INVALID_PRINTER_NAMEERROR_PRINTER_ALREADY_EXISTSERROR_INVALID_PRINTER_COMMANDERROR_INVALID_DATATYPEERROR_INVALID_ENVIRONMENTRPC_S_NO_MORE_BINDINGSERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNTERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNTERROR_NOLOGON_SERVER_TRUST_ACCOUNTERROR_DOMAIN_TRUST_INCONSISTENTERROR_SERVER_HAS_OPEN_HANDLESERROR_RESOURCE_DATA_NOT_FOUNDERROR_RESOURCE_TYPE_NOT_FOUNDERROR_RESOURCE_NAME_NOT_FOUNDERROR_RESOURCE_LANG_NOT_FOUNDERROR_NOT_ENOUGH_QUOTARPC_S_NO_INTERFACESRPC_S_CALL_CANCELLEDRPC_S_BINDING_INCOMPLETERPC_S_COMM_FAILURERPC_S_UNSUPPORTED_AUTHN_LEVELRPC_S_NO_PRINC_NAMERPC_S_NOT_RPC_ERRORRPC_S_UUID_LOCAL_ONLYRPC_S_SEC_PKG_ERRORRPC_S_NOT_CANCELLEDRPC_X_INVALID_ES_ACTIONRPC_X_WRONG_ES_VERSIONRPC_X_WRONG_STUB_VERSIONRPC_X_INVALID_PIPE_OBJECTRPC_X_WRONG_PIPE_ORDERRPC_X_WRONG_PIPE_VERSIONRPC_S_COOKIE_AUTH_FAILEDRPC_S_GROUP_MEMBER_NOT_FOUNDEPT_S_CANT_CREATERPC_S_INVALID_OBJECTERROR_INVALID_TIMEERROR_INVALID_FORM_NAMEERROR_INVALID_FORM_SIZEERROR_ALREADY_WAITINGERROR_PRINTER_DELETEDERROR_INVALID_PRINTER_STATEERROR_PASSWORD_MUST_CHANGEERROR_DOMAIN_CONTROLLER_NOT_FOUNDERROR_ACCOUNT_LOCKED_OUTOR_INVALID_OXIDOR_INVALID_OIDOR_INVALID_SETRPC_S_SEND_INCOMPLETERPC_S_INVALID_ASYNC_HANDLERPC_S_INVALID_ASYNC_CALLRPC_X_PIPE_CLOSEDRPC_X_PIPE_DISCIPLINE_ERRORRPC_X_PIPE_EMPTYERROR_NO_SITENAMEERROR_CANT_ACCESS_FILEERROR_CANT_RESOLVE_FILENAMERPC_S_ENTRY_TYPE_MISMATCHRPC_S_NOT_ALL_OBJS_EXPORTEDRPC_S_INTERFACE_NOT_EXPORTEDRPC_S_PROFILE_NOT_ADDEDRPC_S_PRF_ELT_NOT_ADDEDRPC_S_PRF_ELT_NOT_REMOVEDRPC_S_GRP_ELT_NOT_ADDEDRPC_S_GRP_ELT_NOT_REMOVEDERROR_KM_DRIVER_BLOCKEDERROR_CONTEXT_EXPIREDERROR_PER_USER_TRUST_QUOTA_EXCEEDEDERROR_ALL_USER_TRUST_QUOTA_EXCEEDEDERROR_USER_DELETE_TRUST_QUOTA_EXCEEDEDERROR_AUTHENTICATION_FIREWALL_FAILEDERROR_REMOTE_PRINT_CONNECTIONS_BLOCKEDERROR_NTLM_BLOCKEDERROR_PASSWORD_CHANGE_REQUIREDERROR_INVALID_PIXEL_FORMATERROR_BAD_DRIVERERROR_INVALID_WINDOW_STYLEERROR_METAFILE_NOT_SUPPORTEDERROR_TRANSFORM_NOT_SUPPORTEDERROR_CLIPPING_NOT_SUPPORTEDERROR_INVALID_CMMERROR_INVALID_PROFILEERROR_TAG_NOT_FOUNDERROR_TAG_NOT_PRESENTERROR_DUPLICATE_TAGERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICEERROR_PROFILE_NOT_FOUNDERROR_INVALID_COLORSPACEERROR_ICM_NOT_ENABLEDERROR_DELETING_ICM_XFORMERROR_INVALID_TRANSFORMERROR_COLORSPACE_MISMATCHERROR_INVALID_COLORINDEXERROR_PROFILE_DOES_NOT_MATCH_DEVICEERROR_CONNECTED_OTHER_PASSWORDERROR_CONNECTED_OTHER_PASSWORD_DEFAULTERROR_BAD_USERNAMEERROR_NOT_CONNECTEDERROR_OPEN_FILESERROR_ACTIVE_CONNECTIONSERROR_DEVICE_IN_USEERROR_UNKNOWN_PRINT_MONITORERROR_PRINTER_DRIVER_IN_USEERROR_SPOOL_FILE_NOT_FOUNDERROR_SPL_NO_STARTDOCERROR_SPL_NO_ADDJOBERROR_PRINT_PROCESSOR_ALREADY_INSTALLEDERROR_PRINT_MONITOR_ALREADY_INSTALLEDERROR_INVALID_PRINT_MONITORERROR_PRINT_MONITOR_IN_USEERROR_PRINTER_HAS_JOBS_QUEUEDERROR_SUCCESS_REBOOT_REQUIREDERROR_SUCCESS_RESTART_REQUIREDERROR_PRINTER_NOT_FOUNDERROR_PRINTER_DRIVER_WARNEDERROR_PRINTER_DRIVER_BLOCKEDERROR_PRINTER_DRIVER_PACKAGE_IN_USEERROR_CORE_DRIVER_PACKAGE_NOT_FOUNDERROR_FAIL_REBOOT_REQUIREDERROR_FAIL_REBOOT_INITIATEDERROR_PRINTER_DRIVER_DOWNLOAD_NEEDEDERROR_PRINT_JOB_RESTART_REQUIREDERROR_INVALID_PRINTER_DRIVER_MANIFESTERROR_PRINTER_NOT_SHAREABLEERROR_REQUEST_PAUSEDERROR_IO_REISSUE_AS_CACHEDERROR_WINS_INTERNALERROR_CAN_NOT_DEL_LOCAL_WINSERROR_STATIC_INITERROR_INC_BACKUPERROR_FULL_BACKUPERROR_REC_NON_EXISTENTERROR_RPL_NOT_ALLOWEDPEERDIST_ERROR_CONTENTINFO_VERSION_UNSUPPORTEDPEERDIST_ERROR_CANNOT_PARSE_CONTENTINFOPEERDIST_ERROR_MISSING_DATAPEERDIST_ERROR_NO_MOREPEERDIST_ERROR_NOT_INITIALIZEDPEERDIST_ERROR_ALREADY_INITIALIZEDPEERDIST_ERROR_SHUTDOWN_IN_PROGRESSPEERDIST_ERROR_INVALIDATEDPEERDIST_ERROR_ALREADY_EXISTSPEERDIST_ERROR_OPERATION_NOTFOUNDPEERDIST_ERROR_ALREADY_COMPLETEDPEERDIST_ERROR_OUT_OF_BOUNDSPEERDIST_ERROR_VERSION_UNSUPPORTEDPEERDIST_ERROR_INVALID_CONFIGURATIONPEERDIST_ERROR_NOT_LICENSEDPEERDIST_ERROR_SERVICE_UNAVAILABLEPEERDIST_ERROR_TRUST_FAILUREERROR_DHCP_ADDRESS_CONFLICTERROR_WMI_GUID_NOT_FOUNDERROR_WMI_INSTANCE_NOT_FOUNDERROR_WMI_ITEMID_NOT_FOUNDERROR_WMI_TRY_AGAINERROR_WMI_DP_NOT_FOUNDERROR_WMI_UNRESOLVED_INSTANCE_REFERROR_WMI_ALREADY_ENABLEDERROR_WMI_GUID_DISCONNECTEDERROR_WMI_SERVER_UNAVAILABLEERROR_WMI_DP_FAILEDERROR_WMI_INVALID_MOFERROR_WMI_INVALID_REGINFOERROR_WMI_ALREADY_DISABLEDERROR_WMI_READ_ONLYERROR_WMI_SET_FAILUREERROR_NOT_APPCONTAINERERROR_APPCONTAINER_REQUIREDERROR_NOT_SUPPORTED_IN_APPCONTAINERERROR_INVALID_PACKAGE_SID_LENGTHERROR_INVALID_MEDIAERROR_INVALID_LIBRARYERROR_INVALID_MEDIA_POOLERROR_DRIVE_MEDIA_MISMATCHERROR_MEDIA_OFFLINEERROR_LIBRARY_OFFLINEERROR_EMPTYERROR_NOT_EMPTYERROR_MEDIA_UNAVAILABLEERROR_RESOURCE_DISABLEDERROR_INVALID_CLEANERERROR_UNABLE_TO_CLEANERROR_OBJECT_NOT_FOUNDERROR_DATABASE_FAILUREERROR_DATABASE_FULLERROR_MEDIA_INCOMPATIBLEERROR_RESOURCE_NOT_PRESENTERROR_INVALID_OPERATIONERROR_MEDIA_NOT_AVAILABLEERROR_DEVICE_NOT_AVAILABLEERROR_REQUEST_REFUSEDERROR_INVALID_DRIVE_OBJECTERROR_LIBRARY_FULLERROR_MEDIUM_NOT_ACCESSIBLEERROR_UNABLE_TO_LOAD_MEDIUMERROR_UNABLE_TO_INVENTORY_DRIVEERROR_UNABLE_TO_INVENTORY_SLOTERROR_UNABLE_TO_INVENTORY_TRANSPORTERROR_TRANSPORT_FULLERROR_CONTROLLING_IEPORTERROR_UNABLE_TO_EJECT_MOUNTED_MEDIAERROR_CLEANER_SLOT_SETERROR_CLEANER_SLOT_NOT_SETERROR_CLEANER_CARTRIDGE_SPENTERROR_UNEXPECTED_OMIDERROR_CANT_DELETE_LAST_ITEMERROR_MESSAGE_EXCEEDS_MAX_SIZEERROR_VOLUME_CONTAINS_SYS_FILESERROR_INDIGENOUS_TYPEERROR_NO_SUPPORTING_DRIVESERROR_CLEANER_CARTRIDGE_INSTALLEDERROR_IEPORT_FULLERROR_FILE_OFFLINEERROR_REMOTE_STORAGE_NOT_ACTIVEERROR_REMOTE_STORAGE_MEDIA_ERRORERROR_NOT_A_REPARSE_POINTERROR_REPARSE_ATTRIBUTE_CONFLICTERROR_INVALID_REPARSE_DATAERROR_REPARSE_TAG_INVALIDERROR_REPARSE_TAG_MISMATCHERROR_APP_DATA_NOT_FOUNDERROR_APP_DATA_EXPIREDERROR_APP_DATA_CORRUPTERROR_APP_DATA_LIMIT_EXCEEDEDERROR_APP_DATA_REBOOT_REQUIREDERROR_SECUREBOOT_ROLLBACK_DETECTEDERROR_SECUREBOOT_POLICY_VIOLATIONERROR_SECUREBOOT_INVALID_POLICYERROR_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUNDERROR_SECUREBOOT_POLICY_NOT_SIGNEDERROR_SECUREBOOT_NOT_ENABLEDERROR_SECUREBOOT_FILE_REPLACEDERROR_OFFLOAD_READ_FLT_NOT_SUPPORTEDERROR_OFFLOAD_WRITE_FLT_NOT_SUPPORTEDERROR_OFFLOAD_READ_FILE_NOT_SUPPORTEDERROR_OFFLOAD_WRITE_FILE_NOT_SUPPORTEDERROR_VOLUME_NOT_SIS_ENABLEDERROR_DEPENDENT_RESOURCE_EXISTSERROR_DEPENDENCY_NOT_FOUNDERROR_DEPENDENCY_ALREADY_EXISTSERROR_RESOURCE_NOT_ONLINEERROR_HOST_NODE_NOT_AVAILABLEERROR_RESOURCE_NOT_AVAILABLEERROR_RESOURCE_NOT_FOUNDERROR_SHUTDOWN_CLUSTERERROR_CANT_EVICT_ACTIVE_NODEERROR_OBJECT_ALREADY_EXISTSERROR_OBJECT_IN_LISTERROR_GROUP_NOT_AVAILABLEERROR_GROUP_NOT_FOUNDERROR_GROUP_NOT_ONLINEERROR_HOST_NODE_NOT_RESOURCE_OWNERERROR_HOST_NODE_NOT_GROUP_OWNERERROR_RESMON_CREATE_FAILEDERROR_RESMON_ONLINE_FAILEDERROR_RESOURCE_ONLINEERROR_QUORUM_RESOURCEERROR_NOT_QUORUM_CAPABLEERROR_CLUSTER_SHUTTING_DOWNERROR_INVALID_STATEERROR_RESOURCE_PROPERTIES_STOREDERROR_NOT_QUORUM_CLASSERROR_CORE_RESOURCEERROR_QUORUM_RESOURCE_ONLINE_FAILEDERROR_QUORUMLOG_OPEN_FAILEDERROR_CLUSTERLOG_CORRUPTERROR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZEERROR_CLUSTERLOG_EXCEEDS_MAXSIZEERROR_CLUSTERLOG_CHKPOINT_NOT_FOUNDERROR_CLUSTERLOG_NOT_ENOUGH_SPACEERROR_QUORUM_OWNER_ALIVEERROR_NETWORK_NOT_AVAILABLEERROR_NODE_NOT_AVAILABLEERROR_ALL_NODES_NOT_AVAILABLEERROR_RESOURCE_FAILEDERROR_CLUSTER_INVALID_NODEERROR_CLUSTER_NODE_EXISTSERROR_CLUSTER_JOIN_IN_PROGRESSERROR_CLUSTER_NODE_NOT_FOUNDERROR_CLUSTER_LOCAL_NODE_NOT_FOUNDERROR_CLUSTER_NETWORK_EXISTSERROR_CLUSTER_NETWORK_NOT_FOUNDERROR_CLUSTER_NETINTERFACE_EXISTSERROR_CLUSTER_NETINTERFACE_NOT_FOUNDERROR_CLUSTER_INVALID_REQUESTERROR_CLUSTER_INVALID_NETWORK_PROVIDERERROR_CLUSTER_NODE_DOWNERROR_CLUSTER_NODE_UNREACHABLEERROR_CLUSTER_NODE_NOT_MEMBERERROR_CLUSTER_JOIN_NOT_IN_PROGRESSERROR_CLUSTER_INVALID_NETWORKERROR_CLUSTER_NODE_UPERROR_CLUSTER_IPADDR_IN_USEERROR_CLUSTER_NODE_NOT_PAUSEDERROR_CLUSTER_NO_SECURITY_CONTEXTERROR_CLUSTER_NETWORK_NOT_INTERNALERROR_CLUSTER_NODE_ALREADY_UPERROR_CLUSTER_NODE_ALREADY_DOWNERROR_CLUSTER_NETWORK_ALREADY_ONLINEERROR_CLUSTER_NETWORK_ALREADY_OFFLINEERROR_CLUSTER_NODE_ALREADY_MEMBERERROR_CLUSTER_LAST_INTERNAL_NETWORKERROR_CLUSTER_NETWORK_HAS_DEPENDENTSERROR_INVALID_OPERATION_ON_QUORUMERROR_DEPENDENCY_NOT_ALLOWEDERROR_CLUSTER_NODE_PAUSEDERROR_NODE_CANT_HOST_RESOURCEERROR_CLUSTER_NODE_NOT_READYERROR_CLUSTER_NODE_SHUTTING_DOWNERROR_CLUSTER_JOIN_ABORTEDERROR_CLUSTER_INCOMPATIBLE_VERSIONSERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDEDERROR_CLUSTER_SYSTEM_CONFIG_CHANGEDERROR_CLUSTER_RESOURCE_TYPE_NOT_FOUNDERROR_CLUSTER_RESTYPE_NOT_SUPPORTEDERROR_CLUSTER_RESNAME_NOT_FOUNDERROR_CLUSTER_NO_RPC_PACKAGES_REGISTEREDERROR_CLUSTER_OWNER_NOT_IN_PREFLISTERROR_CLUSTER_DATABASE_SEQMISMATCHERROR_RESMON_INVALID_STATEERROR_CLUSTER_GUM_NOT_LOCKERERROR_QUORUM_DISK_NOT_FOUNDERROR_DATABASE_BACKUP_CORRUPTERROR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOTERROR_RESOURCE_PROPERTY_UNCHANGEABLEERROR_NO_ADMIN_ACCESS_POINTERROR_CLUSTER_MEMBERSHIP_INVALID_STATEERROR_CLUSTER_QUORUMLOG_NOT_FOUNDERROR_CLUSTER_MEMBERSHIP_HALTERROR_CLUSTER_INSTANCE_ID_MISMATCHERROR_CLUSTER_NETWORK_NOT_FOUND_FOR_IPERROR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCHERROR_CLUSTER_EVICT_WITHOUT_CLEANUPERROR_CLUSTER_PARAMETER_MISMATCHERROR_NODE_CANNOT_BE_CLUSTEREDERROR_CLUSTER_WRONG_OS_VERSIONERROR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAMEERROR_CLUSCFG_ALREADY_COMMITTEDERROR_CLUSCFG_ROLLBACK_FAILEDERROR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICTERROR_CLUSTER_OLD_VERSIONERROR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAMEERROR_CLUSTER_NO_NET_ADAPTERSERROR_CLUSTER_POISONEDERROR_CLUSTER_GROUP_MOVINGERROR_CLUSTER_RESOURCE_TYPE_BUSYERROR_RESOURCE_CALL_TIMED_OUTERROR_INVALID_CLUSTER_IPV6_ADDRESSERROR_CLUSTER_INTERNAL_INVALID_FUNCTIONERROR_CLUSTER_PARAMETER_OUT_OF_BOUNDSERROR_CLUSTER_PARTIAL_SENDERROR_CLUSTER_REGISTRY_INVALID_FUNCTIONERROR_CLUSTER_INVALID_STRING_TERMINATIONERROR_CLUSTER_INVALID_STRING_FORMATERROR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESSERROR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESSERROR_CLUSTER_NULL_DATAERROR_CLUSTER_PARTIAL_READERROR_CLUSTER_PARTIAL_WRITEERROR_CLUSTER_CANT_DESERIALIZE_DATAERROR_DEPENDENT_RESOURCE_PROPERTY_CONFLICTERROR_CLUSTER_NO_QUORUMERROR_CLUSTER_INVALID_IPV6_NETWORKERROR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORKERROR_QUORUM_NOT_ALLOWED_IN_THIS_GROUPERROR_DEPENDENCY_TREE_TOO_COMPLEXERROR_EXCEPTION_IN_RESOURCE_CALLERROR_CLUSTER_RHS_FAILED_INITIALIZATIONERROR_CLUSTER_NOT_INSTALLEDERROR_CLUSTER_RESOURCES_MUST_BE_ONLINE_ON_THE_SAME_NODEERROR_CLUSTER_MAX_NODES_IN_CLUSTERERROR_CLUSTER_TOO_MANY_NODESERROR_CLUSTER_OBJECT_ALREADY_USEDERROR_NONCORE_GROUPS_FOUNDERROR_FILE_SHARE_RESOURCE_CONFLICTERROR_CLUSTER_EVICT_INVALID_REQUESTERROR_CLUSTER_SINGLETON_RESOURCEERROR_CLUSTER_GROUP_SINGLETON_RESOURCEERROR_CLUSTER_RESOURCE_PROVIDER_FAILEDERROR_CLUSTER_RESOURCE_CONFIGURATION_ERRORERROR_CLUSTER_GROUP_BUSYERROR_CLUSTER_NOT_SHARED_VOLUMEERROR_CLUSTER_INVALID_SECURITY_DESCRIPTORERROR_CLUSTER_SHARED_VOLUMES_IN_USEERROR_CLUSTER_USE_SHARED_VOLUMES_APIERROR_CLUSTER_BACKUP_IN_PROGRESSERROR_NON_CSV_PATHERROR_CSV_VOLUME_NOT_LOCALERROR_CLUSTER_WATCHDOG_TERMINATINGERROR_CLUSTER_RESOURCE_VETOED_MOVE_INCOMPATIBLE_NODESERROR_CLUSTER_INVALID_NODE_WEIGHTERROR_CLUSTER_RESOURCE_VETOED_CALLERROR_RESMON_SYSTEM_RESOURCES_LACKINGERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_DESTINATIONERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_SOURCEERROR_CLUSTER_GROUP_QUEUEDERROR_CLUSTER_RESOURCE_LOCKED_STATUSERROR_CLUSTER_SHARED_VOLUME_FAILOVER_NOT_ALLOWEDERROR_CLUSTER_NODE_DRAIN_IN_PROGRESSERROR_CLUSTER_DISK_NOT_CONNECTEDERROR_DISK_NOT_CSV_CAPABLEERROR_RESOURCE_NOT_IN_AVAILABLE_STORAGEERROR_CLUSTER_SHARED_VOLUME_REDIRECTEDERROR_CLUSTER_SHARED_VOLUME_NOT_REDIRECTEDERROR_CLUSTER_CANNOT_RETURN_PROPERTIESERROR_CLUSTER_RESOURCE_CONTAINS_UNSUPPORTED_DIFF_AREA_FOR_SHARED_VOLUMESERROR_CLUSTER_RESOURCE_IS_IN_MAINTENANCE_MODEERROR_CLUSTER_AFFINITY_CONFLICTERROR_CLUSTER_RESOURCE_IS_REPLICA_VIRTUAL_MACHINEERROR_ENCRYPTION_FAILEDERROR_DECRYPTION_FAILEDERROR_FILE_ENCRYPTEDERROR_NO_RECOVERY_POLICYERROR_NO_EFSERROR_WRONG_EFSERROR_NO_USER_KEYSERROR_FILE_NOT_ENCRYPTEDERROR_NOT_EXPORT_FORMATERROR_FILE_READ_ONLYERROR_DIR_EFS_DISALLOWEDERROR_EFS_SERVER_NOT_TRUSTEDERROR_BAD_RECOVERY_POLICYERROR_EFS_ALG_BLOB_TOO_BIGERROR_VOLUME_NOT_SUPPORT_EFSERROR_EFS_DISABLEDERROR_EFS_VERSION_NOT_SUPPORTERROR_CS_ENCRYPTION_INVALID_SERVER_RESPONSEERROR_CS_ENCRYPTION_UNSUPPORTED_SERVERERROR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILEERROR_CS_ENCRYPTION_NEW_ENCRYPTED_FILEERROR_CS_ENCRYPTION_FILE_NOT_CSEERROR_ENCRYPTION_POLICY_DENIES_OPERATIONERROR_NO_BROWSER_SERVERS_FOUNDSCHED_E_SERVICE_NOT_LOCALSYSTEMERROR_LOG_SECTOR_INVALIDERROR_LOG_SECTOR_PARITY_INVALIDERROR_LOG_SECTOR_REMAPPEDERROR_LOG_BLOCK_INCOMPLETEERROR_LOG_INVALID_RANGEERROR_LOG_BLOCKS_EXHAUSTEDERROR_LOG_READ_CONTEXT_INVALIDERROR_LOG_RESTART_INVALIDERROR_LOG_BLOCK_VERSIONERROR_LOG_BLOCK_INVALIDERROR_LOG_READ_MODE_INVALIDERROR_LOG_NO_RESTARTERROR_LOG_METADATA_CORRUPTERROR_LOG_METADATA_INVALIDERROR_LOG_METADATA_INCONSISTENTERROR_LOG_RESERVATION_INVALIDERROR_LOG_CANT_DELETEERROR_LOG_CONTAINER_LIMIT_EXCEEDEDERROR_LOG_START_OF_LOGERROR_LOG_POLICY_ALREADY_INSTALLEDERROR_LOG_POLICY_NOT_INSTALLEDERROR_LOG_POLICY_INVALIDERROR_LOG_POLICY_CONFLICTERROR_LOG_PINNED_ARCHIVE_TAILERROR_LOG_RECORD_NONEXISTENTERROR_LOG_RECORDS_RESERVED_INVALIDERROR_LOG_SPACE_RESERVED_INVALIDERROR_LOG_TAIL_INVALIDERROR_LOG_FULLERROR_COULD_NOT_RESIZE_LOGERROR_LOG_MULTIPLEXEDERROR_LOG_DEDICATEDERROR_LOG_ARCHIVE_NOT_IN_PROGRESSERROR_LOG_ARCHIVE_IN_PROGRESSERROR_LOG_EPHEMERALERROR_LOG_NOT_ENOUGH_CONTAINERSERROR_LOG_CLIENT_ALREADY_REGISTEREDERROR_LOG_CLIENT_NOT_REGISTEREDERROR_LOG_FULL_HANDLER_IN_PROGRESSERROR_LOG_CONTAINER_READ_FAILEDERROR_LOG_CONTAINER_WRITE_FAILEDERROR_LOG_CONTAINER_OPEN_FAILEDERROR_LOG_CONTAINER_STATE_INVALIDERROR_LOG_STATE_INVALIDERROR_LOG_PINNEDERROR_LOG_METADATA_FLUSH_FAILEDERROR_LOG_INCONSISTENT_SECURITYERROR_LOG_APPENDED_FLUSH_FAILEDERROR_LOG_PINNED_RESERVATIONERROR_INVALID_TRANSACTIONERROR_TRANSACTION_NOT_ACTIVEERROR_TRANSACTION_REQUEST_NOT_VALIDERROR_TRANSACTION_NOT_REQUESTEDERROR_TRANSACTION_ALREADY_ABORTEDERROR_TRANSACTION_ALREADY_COMMITTEDERROR_TM_INITIALIZATION_FAILEDERROR_RESOURCEMANAGER_READ_ONLYERROR_TRANSACTION_NOT_JOINEDERROR_TRANSACTION_SUPERIOR_EXISTSERROR_CRM_PROTOCOL_ALREADY_EXISTSERROR_TRANSACTION_PROPAGATION_FAILEDERROR_CRM_PROTOCOL_NOT_FOUNDERROR_TRANSACTION_INVALID_MARSHALL_BUFFERERROR_CURRENT_TRANSACTION_NOT_VALIDERROR_TRANSACTION_NOT_FOUNDERROR_RESOURCEMANAGER_NOT_FOUNDERROR_ENLISTMENT_NOT_FOUNDERROR_TRANSACTIONMANAGER_NOT_FOUNDERROR_TRANSACTIONMANAGER_NOT_ONLINEERROR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISIONERROR_TRANSACTION_NOT_ROOTERROR_TRANSACTION_OBJECT_EXPIREDERROR_TRANSACTION_RESPONSE_NOT_ENLISTEDERROR_TRANSACTION_RECORD_TOO_LONGERROR_IMPLICIT_TRANSACTION_NOT_SUPPORTEDERROR_TRANSACTION_INTEGRITY_VIOLATEDERROR_TRANSACTIONMANAGER_IDENTITY_MISMATCHERROR_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOTERROR_TRANSACTION_MUST_WRITETHROUGHERROR_TRANSACTION_NO_SUPERIORERROR_HEURISTIC_DAMAGE_POSSIBLEERROR_TRANSACTIONAL_CONFLICTERROR_RM_NOT_ACTIVEERROR_RM_METADATA_CORRUPTERROR_DIRECTORY_NOT_RMERROR_TRANSACTIONS_UNSUPPORTED_REMOTEERROR_LOG_RESIZE_INVALID_SIZEERROR_OBJECT_NO_LONGER_EXISTSERROR_STREAM_MINIVERSION_NOT_FOUNDERROR_STREAM_MINIVERSION_NOT_VALIDERROR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTIONERROR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENTERROR_CANT_CREATE_MORE_STREAM_MINIVERSIONSERROR_REMOTE_FILE_VERSION_MISMATCHERROR_HANDLE_NO_LONGER_VALIDERROR_NO_TXF_METADATAERROR_LOG_CORRUPTION_DETECTEDERROR_CANT_RECOVER_WITH_HANDLE_OPENERROR_RM_DISCONNECTEDERROR_ENLISTMENT_NOT_SUPERIORERROR_RECOVERY_NOT_NEEDEDERROR_RM_ALREADY_STARTEDERROR_FILE_IDENTITY_NOT_PERSISTENTERROR_CANT_BREAK_TRANSACTIONAL_DEPENDENCYERROR_CANT_CROSS_RM_BOUNDARYERROR_TXF_DIR_NOT_EMPTYERROR_INDOUBT_TRANSACTIONS_EXISTERROR_TM_VOLATILEERROR_ROLLBACK_TIMER_EXPIREDERROR_TXF_ATTRIBUTE_CORRUPTERROR_EFS_NOT_ALLOWED_IN_TRANSACTIONERROR_TRANSACTIONAL_OPEN_NOT_ALLOWEDERROR_LOG_GROWTH_FAILEDERROR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTEERROR_TXF_METADATA_ALREADY_PRESENTERROR_TRANSACTION_SCOPE_CALLBACKS_NOT_SETERROR_TRANSACTION_REQUIRED_PROMOTIONERROR_CANNOT_EXECUTE_FILE_IN_TRANSACTIONERROR_TRANSACTIONS_NOT_FROZENERROR_TRANSACTION_FREEZE_IN_PROGRESSERROR_NOT_SNAPSHOT_VOLUMEERROR_NO_SAVEPOINT_WITH_OPEN_FILESERROR_DATA_LOST_REPAIRERROR_SPARSE_NOT_ALLOWED_IN_TRANSACTIONERROR_TM_IDENTITY_MISMATCHERROR_FLOATED_SECTIONERROR_CANNOT_ACCEPT_TRANSACTED_WORKERROR_CANNOT_ABORT_TRANSACTIONSERROR_BAD_CLUSTERSERROR_COMPRESSION_NOT_ALLOWED_IN_TRANSACTIONERROR_VOLUME_DIRTYERROR_NO_LINK_TRACKING_IN_TRANSACTIONERROR_OPERATION_NOT_SUPPORTED_IN_TRANSACTIONERROR_EXPIRED_HANDLEERROR_TRANSACTION_NOT_ENLISTEDERROR_CTX_WINSTATION_NAME_INVALIDERROR_CTX_INVALID_PDERROR_CTX_PD_NOT_FOUNDERROR_CTX_WD_NOT_FOUNDERROR_CTX_CANNOT_MAKE_EVENTLOG_ENTRYERROR_CTX_SERVICE_NAME_COLLISIONERROR_CTX_CLOSE_PENDINGERROR_CTX_NO_OUTBUFERROR_CTX_MODEM_INF_NOT_FOUNDERROR_CTX_INVALID_MODEMNAMEERROR_CTX_MODEM_RESPONSE_ERRORERROR_CTX_MODEM_RESPONSE_TIMEOUTERROR_CTX_MODEM_RESPONSE_NO_CARRIERERROR_CTX_MODEM_RESPONSE_NO_DIALTONEERROR_CTX_MODEM_RESPONSE_BUSYERROR_CTX_MODEM_RESPONSE_VOICEERROR_CTX_TD_ERRORERROR_CTX_WINSTATION_NOT_FOUNDERROR_CTX_WINSTATION_ALREADY_EXISTSERROR_CTX_WINSTATION_BUSYERROR_CTX_BAD_VIDEO_MODEERROR_CTX_GRAPHICS_INVALIDERROR_CTX_LOGON_DISABLEDERROR_CTX_NOT_CONSOLEERROR_CTX_CLIENT_QUERY_TIMEOUTERROR_CTX_CONSOLE_DISCONNECTERROR_CTX_CONSOLE_CONNECTERROR_CTX_SHADOW_DENIEDERROR_CTX_WINSTATION_ACCESS_DENIEDERROR_CTX_INVALID_WDERROR_CTX_SHADOW_INVALIDERROR_CTX_SHADOW_DISABLEDERROR_CTX_CLIENT_LICENSE_IN_USEERROR_CTX_CLIENT_LICENSE_NOT_SETERROR_CTX_LICENSE_NOT_AVAILABLEERROR_CTX_LICENSE_CLIENT_INVALIDERROR_CTX_LICENSE_EXPIREDERROR_CTX_SHADOW_NOT_RUNNINGERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGEERROR_ACTIVATION_COUNT_EXCEEDEDERROR_CTX_WINSTATIONS_DISABLEDERROR_CTX_ENCRYPTION_LEVEL_REQUIREDERROR_CTX_SESSION_IN_USEERROR_CTX_NO_FORCE_LOGOFFERROR_CTX_ACCOUNT_RESTRICTIONERROR_RDP_PROTOCOL_ERRORERROR_CTX_CDM_CONNECTERROR_CTX_CDM_DISCONNECTERROR_CTX_SECURITY_LAYER_ERRORERROR_TS_INCOMPATIBLE_SESSIONSERROR_TS_VIDEO_SUBSYSTEM_ERRORFRS_ERR_INVALID_API_SEQUENCEFRS_ERR_STARTING_SERVICEFRS_ERR_STOPPING_SERVICEFRS_ERR_INTERNAL_APIFRS_ERR_INTERNALFRS_ERR_SERVICE_COMMFRS_ERR_INSUFFICIENT_PRIVFRS_ERR_AUTHENTICATIONFRS_ERR_PARENT_INSUFFICIENT_PRIVFRS_ERR_PARENT_AUTHENTICATIONFRS_ERR_CHILD_TO_PARENT_COMMFRS_ERR_PARENT_TO_CHILD_COMMFRS_ERR_SYSVOL_POPULATEFRS_ERR_SYSVOL_POPULATE_TIMEOUTFRS_ERR_SYSVOL_IS_BUSYFRS_ERR_SYSVOL_DEMOTEFRS_ERR_INVALID_SERVICE_PARAMETERDS_S_SUCCESSERROR_DS_NOT_INSTALLEDERROR_DS_MEMBERSHIP_EVALUATED_LOCALLYERROR_DS_NO_ATTRIBUTE_OR_VALUEERROR_DS_INVALID_ATTRIBUTE_SYNTAXERROR_DS_ATTRIBUTE_TYPE_UNDEFINEDERROR_DS_ATTRIBUTE_OR_VALUE_EXISTSERROR_DS_BUSYERROR_DS_UNAVAILABLEERROR_DS_NO_RIDS_ALLOCATEDERROR_DS_NO_MORE_RIDSERROR_DS_INCORRECT_ROLE_OWNERERROR_DS_RIDMGR_INIT_ERRORERROR_DS_OBJ_CLASS_VIOLATIONERROR_DS_CANT_ON_NON_LEAFERROR_DS_CANT_ON_RDNERROR_DS_CANT_MOD_OBJ_CLASSERROR_DS_CROSS_DOM_MOVE_ERRORERROR_DS_GC_NOT_AVAILABLEERROR_SHARED_POLICYERROR_POLICY_OBJECT_NOT_FOUNDERROR_POLICY_ONLY_IN_DSERROR_PROMOTION_ACTIVEERROR_NO_PROMOTION_ACTIVEERROR_DS_OPERATIONS_ERRORERROR_DS_PROTOCOL_ERRORERROR_DS_TIMELIMIT_EXCEEDEDERROR_DS_SIZELIMIT_EXCEEDEDERROR_DS_ADMIN_LIMIT_EXCEEDEDERROR_DS_COMPARE_FALSEERROR_DS_COMPARE_TRUEERROR_DS_AUTH_METHOD_NOT_SUPPORTEDERROR_DS_STRONG_AUTH_REQUIREDERROR_DS_INAPPROPRIATE_AUTHERROR_DS_AUTH_UNKNOWNERROR_DS_REFERRALERROR_DS_UNAVAILABLE_CRIT_EXTENSIONERROR_DS_CONFIDENTIALITY_REQUIREDERROR_DS_INAPPROPRIATE_MATCHINGERROR_DS_CONSTRAINT_VIOLATIONERROR_DS_NO_SUCH_OBJECTERROR_DS_ALIAS_PROBLEMERROR_DS_INVALID_DN_SYNTAXERROR_DS_IS_LEAFERROR_DS_ALIAS_DEREF_PROBLEMERROR_DS_UNWILLING_TO_PERFORMERROR_DS_LOOP_DETECTERROR_DS_NAMING_VIOLATIONERROR_DS_OBJECT_RESULTS_TOO_LARGEERROR_DS_AFFECTS_MULTIPLE_DSASERROR_DS_SERVER_DOWNERROR_DS_LOCAL_ERRORERROR_DS_ENCODING_ERRORERROR_DS_DECODING_ERRORERROR_DS_FILTER_UNKNOWNERROR_DS_PARAM_ERRORERROR_DS_NOT_SUPPORTEDERROR_DS_NO_RESULTS_RETURNEDERROR_DS_CONTROL_NOT_FOUNDERROR_DS_CLIENT_LOOPERROR_DS_REFERRAL_LIMIT_EXCEEDEDERROR_DS_SORT_CONTROL_MISSINGERROR_DS_OFFSET_RANGE_ERRORERROR_DS_RIDMGR_DISABLEDERROR_DS_ROOT_MUST_BE_NCERROR_DS_ADD_REPLICA_INHIBITEDERROR_DS_ATT_NOT_DEF_IN_SCHEMAERROR_DS_MAX_OBJ_SIZE_EXCEEDEDERROR_DS_OBJ_STRING_NAME_EXISTSERROR_DS_NO_RDN_DEFINED_IN_SCHEMAERROR_DS_RDN_DOESNT_MATCH_SCHEMAERROR_DS_NO_REQUESTED_ATTS_FOUNDERROR_DS_USER_BUFFER_TO_SMALLERROR_DS_ATT_IS_NOT_ON_OBJERROR_DS_ILLEGAL_MOD_OPERATIONERROR_DS_OBJ_TOO_LARGEERROR_DS_BAD_INSTANCE_TYPEERROR_DS_MASTERDSA_REQUIREDERROR_DS_OBJECT_CLASS_REQUIREDERROR_DS_MISSING_REQUIRED_ATTERROR_DS_ATT_NOT_DEF_FOR_CLASSERROR_DS_ATT_ALREADY_EXISTSERROR_DS_CANT_ADD_ATT_VALUESERROR_DS_SINGLE_VALUE_CONSTRAINTERROR_DS_RANGE_CONSTRAINTERROR_DS_ATT_VAL_ALREADY_EXISTSERROR_DS_CANT_REM_MISSING_ATTERROR_DS_CANT_REM_MISSING_ATT_VALERROR_DS_ROOT_CANT_BE_SUBREFERROR_DS_NO_CHAININGERROR_DS_NO_CHAINED_EVALERROR_DS_NO_PARENT_OBJECTERROR_DS_PARENT_IS_AN_ALIASERROR_DS_CANT_MIX_MASTER_AND_REPSERROR_DS_CHILDREN_EXISTERROR_DS_OBJ_NOT_FOUNDERROR_DS_ALIASED_OBJ_MISSINGERROR_DS_BAD_NAME_SYNTAXERROR_DS_ALIAS_POINTS_TO_ALIASERROR_DS_CANT_DEREF_ALIASERROR_DS_OUT_OF_SCOPEERROR_DS_OBJECT_BEING_REMOVEDERROR_DS_CANT_DELETE_DSA_OBJERROR_DS_GENERIC_ERRORERROR_DS_DSA_MUST_BE_INT_MASTERERROR_DS_CLASS_NOT_DSAERROR_DS_INSUFF_ACCESS_RIGHTSERROR_DS_ILLEGAL_SUPERIORERROR_DS_ATTRIBUTE_OWNED_BY_SAMERROR_DS_NAME_TOO_MANY_PARTSERROR_DS_NAME_TOO_LONGERROR_DS_NAME_VALUE_TOO_LONGERROR_DS_NAME_UNPARSEABLEERROR_DS_NAME_TYPE_UNKNOWNERROR_DS_NOT_AN_OBJECTERROR_DS_SEC_DESC_TOO_SHORTERROR_DS_SEC_DESC_INVALIDERROR_DS_NO_DELETED_NAMEERROR_DS_SUBREF_MUST_HAVE_PARENTERROR_DS_NCNAME_MUST_BE_NCERROR_DS_CANT_ADD_SYSTEM_ONLYERROR_DS_CLASS_MUST_BE_CONCRETEERROR_DS_INVALID_DMDERROR_DS_OBJ_GUID_EXISTSERROR_DS_NOT_ON_BACKLINKERROR_DS_NO_CROSSREF_FOR_NCERROR_DS_SHUTTING_DOWNERROR_DS_UNKNOWN_OPERATIONERROR_DS_INVALID_ROLE_OWNERERROR_DS_COULDNT_CONTACT_FSMOERROR_DS_CROSS_NC_DN_RENAMEERROR_DS_CANT_MOD_SYSTEM_ONLYERROR_DS_REPLICATOR_ONLYERROR_DS_OBJ_CLASS_NOT_DEFINEDERROR_DS_OBJ_CLASS_NOT_SUBCLASSERROR_DS_NAME_REFERENCE_INVALIDERROR_DS_CROSS_REF_EXISTSERROR_DS_CANT_DEL_MASTER_CROSSREFERROR_DS_SUBTREE_NOTIFY_NOT_NC_HEADERROR_DS_NOTIFY_FILTER_TOO_COMPLEXERROR_DS_DUP_RDNERROR_DS_DUP_OIDERROR_DS_DUP_MAPI_IDERROR_DS_DUP_SCHEMA_ID_GUIDERROR_DS_DUP_LDAP_DISPLAY_NAMEERROR_DS_SEMANTIC_ATT_TESTERROR_DS_SYNTAX_MISMATCHERROR_DS_EXISTS_IN_MUST_HAVEERROR_DS_EXISTS_IN_MAY_HAVEERROR_DS_NONEXISTENT_MAY_HAVEERROR_DS_NONEXISTENT_MUST_HAVEERROR_DS_AUX_CLS_TEST_FAILERROR_DS_NONEXISTENT_POSS_SUPERROR_DS_SUB_CLS_TEST_FAILERROR_DS_BAD_RDN_ATT_ID_SYNTAXERROR_DS_EXISTS_IN_AUX_CLSERROR_DS_EXISTS_IN_SUB_CLSERROR_DS_EXISTS_IN_POSS_SUPERROR_DS_RECALCSCHEMA_FAILEDERROR_DS_TREE_DELETE_NOT_FINISHEDERROR_DS_CANT_DELETEERROR_DS_ATT_SCHEMA_REQ_IDERROR_DS_BAD_ATT_SCHEMA_SYNTAXERROR_DS_CANT_CACHE_ATTERROR_DS_CANT_CACHE_CLASSERROR_DS_CANT_REMOVE_ATT_CACHEERROR_DS_CANT_REMOVE_CLASS_CACHEERROR_DS_CANT_RETRIEVE_DNERROR_DS_MISSING_SUPREFERROR_DS_CANT_RETRIEVE_INSTANCEERROR_DS_CODE_INCONSISTENCYERROR_DS_DATABASE_ERRORERROR_DS_GOVERNSID_MISSINGERROR_DS_MISSING_EXPECTED_ATTERROR_DS_NCNAME_MISSING_CR_REFERROR_DS_SECURITY_CHECKING_ERRORERROR_DS_SCHEMA_NOT_LOADEDERROR_DS_SCHEMA_ALLOC_FAILEDERROR_DS_ATT_SCHEMA_REQ_SYNTAXERROR_DS_GCVERIFY_ERRORERROR_DS_DRA_SCHEMA_MISMATCHERROR_DS_CANT_FIND_DSA_OBJERROR_DS_CANT_FIND_EXPECTED_NCERROR_DS_CANT_FIND_NC_IN_CACHEERROR_DS_CANT_RETRIEVE_CHILDERROR_DS_SECURITY_ILLEGAL_MODIFYERROR_DS_CANT_REPLACE_HIDDEN_RECERROR_DS_BAD_HIERARCHY_FILEERROR_DS_BUILD_HIERARCHY_TABLE_FAILEDERROR_DS_CONFIG_PARAM_MISSINGERROR_DS_COUNTING_AB_INDICES_FAILEDERROR_DS_HIERARCHY_TABLE_MALLOC_FAILEDERROR_DS_INTERNAL_FAILUREERROR_DS_UNKNOWN_ERRORERROR_DS_ROOT_REQUIRES_CLASS_TOPERROR_DS_REFUSING_FSMO_ROLESERROR_DS_MISSING_FSMO_SETTINGSERROR_DS_UNABLE_TO_SURRENDER_ROLESERROR_DS_DRA_GENERICERROR_DS_DRA_INVALID_PARAMETERERROR_DS_DRA_BUSYERROR_DS_DRA_BAD_DNERROR_DS_DRA_BAD_NCERROR_DS_DRA_DN_EXISTSERROR_DS_DRA_INTERNAL_ERRORERROR_DS_DRA_INCONSISTENT_DITERROR_DS_DRA_CONNECTION_FAILEDERROR_DS_DRA_BAD_INSTANCE_TYPEERROR_DS_DRA_OUT_OF_MEMERROR_DS_DRA_MAIL_PROBLEMERROR_DS_DRA_REF_ALREADY_EXISTSERROR_DS_DRA_REF_NOT_FOUNDERROR_DS_DRA_OBJ_IS_REP_SOURCEERROR_DS_DRA_DB_ERRORERROR_DS_DRA_NO_REPLICAERROR_DS_DRA_ACCESS_DENIEDERROR_DS_DRA_NOT_SUPPORTEDERROR_DS_DRA_RPC_CANCELLEDERROR_DS_DRA_SOURCE_DISABLEDERROR_DS_DRA_SINK_DISABLEDERROR_DS_DRA_NAME_COLLISIONERROR_DS_DRA_SOURCE_REINSTALLEDERROR_DS_DRA_MISSING_PARENTERROR_DS_DRA_PREEMPTEDERROR_DS_DRA_ABANDON_SYNCERROR_DS_DRA_SHUTDOWNERROR_DS_DRA_INCOMPATIBLE_PARTIAL_SETERROR_DS_DRA_SOURCE_IS_PARTIAL_REPLICAERROR_DS_DRA_EXTN_CONNECTION_FAILEDERROR_DS_INSTALL_SCHEMA_MISMATCHERROR_DS_DUP_LINK_IDERROR_DS_NAME_ERROR_RESOLVINGERROR_DS_NAME_ERROR_NOT_FOUNDERROR_DS_NAME_ERROR_NOT_UNIQUEERROR_DS_NAME_ERROR_NO_MAPPINGERROR_DS_NAME_ERROR_DOMAIN_ONLYERROR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPINGERROR_DS_CONSTRUCTED_ATT_MODERROR_DS_WRONG_OM_OBJ_CLASSERROR_DS_DRA_REPL_PENDINGERROR_DS_DS_REQUIREDERROR_DS_INVALID_LDAP_DISPLAY_NAMEERROR_DS_NON_BASE_SEARCHERROR_DS_CANT_RETRIEVE_ATTSERROR_DS_BACKLINK_WITHOUT_LINKERROR_DS_EPOCH_MISMATCHERROR_DS_SRC_NAME_MISMATCHERROR_DS_SRC_AND_DST_NC_IDENTICALERROR_DS_DST_NC_MISMATCHERROR_DS_NOT_AUTHORITIVE_FOR_DST_NCERROR_DS_SRC_GUID_MISMATCHERROR_DS_CANT_MOVE_DELETED_OBJECTERROR_DS_PDC_OPERATION_IN_PROGRESSERROR_DS_CROSS_DOMAIN_CLEANUP_REQDERROR_DS_ILLEGAL_XDOM_MOVE_OPERATIONERROR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPSERROR_DS_NC_MUST_HAVE_NC_PARENTERROR_DS_CR_IMPOSSIBLE_TO_VALIDATEERROR_DS_DST_DOMAIN_NOT_NATIVEERROR_DS_MISSING_INFRASTRUCTURE_CONTAINERERROR_DS_CANT_MOVE_ACCOUNT_GROUPERROR_DS_CANT_MOVE_RESOURCE_GROUPERROR_DS_INVALID_SEARCH_FLAGERROR_DS_NO_TREE_DELETE_ABOVE_NCERROR_DS_COULDNT_LOCK_TREE_FOR_DELETEERROR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETEERROR_DS_SAM_INIT_FAILUREERROR_DS_SENSITIVE_GROUP_VIOLATIONERROR_DS_CANT_MOD_PRIMARYGROUPIDERROR_DS_ILLEGAL_BASE_SCHEMA_MODERROR_DS_NONSAFE_SCHEMA_CHANGEERROR_DS_SCHEMA_UPDATE_DISALLOWEDERROR_DS_CANT_CREATE_UNDER_SCHEMAERROR_DS_INSTALL_NO_SRC_SCH_VERSIONERROR_DS_INSTALL_NO_SCH_VERSION_IN_INIFILEERROR_DS_INVALID_GROUP_TYPEERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAINERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAINERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBERERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBERERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBERERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBERERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBERERROR_DS_HAVE_PRIMARY_MEMBERSERROR_DS_STRING_SD_CONVERSION_FAILEDERROR_DS_NAMING_MASTER_GCERROR_DS_DNS_LOOKUP_FAILUREERROR_DS_COULDNT_UPDATE_SPNSERROR_DS_CANT_RETRIEVE_SDERROR_DS_KEY_NOT_UNIQUEERROR_DS_WRONG_LINKED_ATT_SYNTAXERROR_DS_SAM_NEED_BOOTKEY_PASSWORDERROR_DS_SAM_NEED_BOOTKEY_FLOPPYERROR_DS_CANT_STARTERROR_DS_INIT_FAILUREERROR_DS_NO_PKT_PRIVACY_ON_CONNECTIONERROR_DS_SOURCE_DOMAIN_IN_FORESTERROR_DS_DESTINATION_DOMAIN_NOT_IN_FORESTERROR_DS_DESTINATION_AUDITING_NOT_ENABLEDERROR_DS_CANT_FIND_DC_FOR_SRC_DOMAINERROR_DS_SRC_OBJ_NOT_GROUP_OR_USERERROR_DS_SRC_SID_EXISTS_IN_FORESTERROR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCHERROR_SAM_INIT_FAILUREERROR_DS_DRA_SCHEMA_INFO_SHIPERROR_DS_DRA_SCHEMA_CONFLICTERROR_DS_DRA_EARLIER_SCHEMA_CONFLICTERROR_DS_DRA_OBJ_NC_MISMATCHERROR_DS_NC_STILL_HAS_DSASERROR_DS_GC_REQUIREDERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLYERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPSERROR_DS_CANT_ADD_TO_GCERROR_DS_NO_CHECKPOINT_WITH_PDCERROR_DS_SOURCE_AUDITING_NOT_ENABLEDERROR_DS_CANT_CREATE_IN_NONDOMAIN_NCERROR_DS_INVALID_NAME_FOR_SPNERROR_DS_FILTER_USES_CONTRUCTED_ATTRSERROR_DS_UNICODEPWD_NOT_IN_QUOTESERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDEDERROR_DS_MUST_BE_RUN_ON_DST_DCERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATERERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJERROR_DS_INIT_FAILURE_CONSOLEERROR_DS_SAM_INIT_FAILURE_CONSOLEERROR_DS_FOREST_VERSION_TOO_HIGHERROR_DS_DOMAIN_VERSION_TOO_HIGHERROR_DS_FOREST_VERSION_TOO_LOWERROR_DS_DOMAIN_VERSION_TOO_LOWERROR_DS_INCOMPATIBLE_VERSIONERROR_DS_LOW_DSA_VERSIONERROR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAINERROR_DS_NOT_SUPPORTED_SORT_ORDERERROR_DS_NAME_NOT_UNIQUEERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4ERROR_DS_OUT_OF_VERSION_STOREERROR_DS_INCOMPATIBLE_CONTROLS_USEDERROR_DS_NO_REF_DOMAINERROR_DS_RESERVED_LINK_IDERROR_DS_LINK_ID_NOT_AVAILABLEERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBERERROR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPEERROR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NCERROR_DS_MODIFYDN_DISALLOWED_BY_FLAGERROR_DS_MODIFYDN_WRONG_GRANDPARENTERROR_DS_NAME_ERROR_TRUST_REFERRALERROR_NOT_SUPPORTED_ON_STANDARD_SERVERERROR_DS_CANT_ACCESS_REMOTE_PART_OF_ADERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2ERROR_DS_THREAD_LIMIT_EXCEEDEDERROR_DS_NOT_CLOSESTERROR_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REFERROR_DS_SINGLE_USER_MODE_FAILEDERROR_DS_NTDSCRIPT_SYNTAX_ERRORERROR_DS_NTDSCRIPT_PROCESS_ERRORERROR_DS_DIFFERENT_REPL_EPOCHSERROR_DS_DRS_EXTENSIONS_CHANGEDERROR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CRERROR_DS_NO_MSDS_INTIDERROR_DS_DUP_MSDS_INTIDERROR_DS_EXISTS_IN_RDNATTIDERROR_DS_AUTHORIZATION_FAILEDERROR_DS_INVALID_SCRIPTERROR_DS_REMOTE_CROSSREF_OP_FAILEDERROR_DS_CROSS_REF_BUSYERROR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAINERROR_DS_CANT_DEMOTE_WITH_WRITEABLE_NCERROR_DS_DUPLICATE_ID_FOUNDERROR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECTERROR_DS_GROUP_CONVERSION_ERRORERROR_DS_CANT_MOVE_APP_BASIC_GROUPERROR_DS_CANT_MOVE_APP_QUERY_GROUPERROR_DS_ROLE_NOT_VERIFIEDERROR_DS_WKO_CONTAINER_CANNOT_BE_SPECIALERROR_DS_DOMAIN_RENAME_IN_PROGRESSERROR_DS_EXISTING_AD_CHILD_NCERROR_DS_REPL_LIFETIME_EXCEEDEDERROR_DS_DISALLOWED_IN_SYSTEM_CONTAINERERROR_DS_LDAP_SEND_QUEUE_FULLERROR_DS_DRA_OUT_SCHEDULE_WINDOWERROR_DS_POLICY_NOT_KNOWNERROR_NO_SITE_SETTINGS_OBJECTERROR_NO_SECRETSERROR_NO_WRITABLE_DC_FOUNDERROR_DS_NO_SERVER_OBJECTERROR_DS_NO_NTDSA_OBJECTERROR_DS_NON_ASQ_SEARCHERROR_DS_AUDIT_FAILUREERROR_DS_INVALID_SEARCH_FLAG_SUBTREEERROR_DS_INVALID_SEARCH_FLAG_TUPLEERROR_DS_HIERARCHY_TABLE_TOO_DEEPERROR_DS_DRA_CORRUPT_UTD_VECTORERROR_DS_DRA_SECRETS_DENIEDERROR_DS_RESERVED_MAPI_IDERROR_DS_MAPI_ID_NOT_AVAILABLEERROR_DS_DRA_MISSING_KRBTGT_SECRETERROR_DS_DOMAIN_NAME_EXISTS_IN_FORESTERROR_DS_FLAT_NAME_EXISTS_IN_FORESTERROR_INVALID_USER_PRINCIPAL_NAMEERROR_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERSERROR_DS_OID_NOT_FOUNDERROR_DS_DRA_RECYCLED_TARGETERROR_DS_DISALLOWED_NC_REDIRECTERROR_DS_HIGH_ADLDS_FFLERROR_DS_HIGH_DSA_VERSIONERROR_DS_LOW_ADLDS_FFLERROR_DOMAIN_SID_SAME_AS_LOCAL_WORKSTATIONERROR_DS_UNDELETE_SAM_VALIDATION_FAILEDERROR_INCORRECT_ACCOUNT_TYPEERROR_DS_SPN_VALUE_NOT_UNIQUE_IN_FORESTERROR_DS_UPN_VALUE_NOT_UNIQUE_IN_FORESTDNS_ERROR_RESPONSE_CODES_BASEDNS_ERROR_RCODE_NO_ERRORDNS_ERROR_MASKDNS_ERROR_RCODE_FORMAT_ERRORDNS_ERROR_RCODE_SERVER_FAILUREDNS_ERROR_RCODE_NAME_ERRORDNS_ERROR_RCODE_NOT_IMPLEMENTEDDNS_ERROR_RCODE_REFUSEDDNS_ERROR_RCODE_YXDOMAINDNS_ERROR_RCODE_YXRRSETDNS_ERROR_RCODE_NXRRSETDNS_ERROR_RCODE_NOTAUTHDNS_ERROR_RCODE_NOTZONEDNS_ERROR_RCODE_BADSIGDNS_ERROR_RCODE_BADKEYDNS_ERROR_RCODE_BADTIMEDNS_ERROR_RCODE_LASTDNS_ERROR_DNSSEC_BASEDNS_ERROR_KEYMASTER_REQUIREDDNS_ERROR_NOT_ALLOWED_ON_SIGNED_ZONEDNS_ERROR_NSEC3_INCOMPATIBLE_WITH_RSA_SHA1DNS_ERROR_NOT_ENOUGH_SIGNING_KEY_DESCRIPTORSDNS_ERROR_UNSUPPORTED_ALGORITHMDNS_ERROR_INVALID_KEY_SIZEDNS_ERROR_SIGNING_KEY_NOT_ACCESSIBLEDNS_ERROR_KSP_DOES_NOT_SUPPORT_PROTECTIONDNS_ERROR_UNEXPECTED_DATA_PROTECTION_ERRORDNS_ERROR_UNEXPECTED_CNG_ERRORDNS_ERROR_UNKNOWN_SIGNING_PARAMETER_VERSIONDNS_ERROR_KSP_NOT_ACCESSIBLEDNS_ERROR_TOO_MANY_SKDSDNS_ERROR_INVALID_ROLLOVER_PERIODDNS_ERROR_INVALID_INITIAL_ROLLOVER_OFFSETDNS_ERROR_ROLLOVER_IN_PROGRESSDNS_ERROR_STANDBY_KEY_NOT_PRESENTDNS_ERROR_NOT_ALLOWED_ON_ZSKDNS_ERROR_NOT_ALLOWED_ON_ACTIVE_SKDDNS_ERROR_ROLLOVER_ALREADY_QUEUEDDNS_ERROR_NOT_ALLOWED_ON_UNSIGNED_ZONEDNS_ERROR_BAD_KEYMASTERDNS_ERROR_INVALID_SIGNATURE_VALIDITY_PERIODDNS_ERROR_INVALID_NSEC3_ITERATION_COUNTDNS_ERROR_DNSSEC_IS_DISABLEDDNS_ERROR_INVALID_XMLDNS_ERROR_NO_VALID_TRUST_ANCHORSDNS_ERROR_ROLLOVER_NOT_POKEABLEDNS_ERROR_NSEC3_NAME_COLLISIONDNS_ERROR_NSEC_INCOMPATIBLE_WITH_NSEC3_RSA_SHA1DNS_ERROR_PACKET_FMT_BASEDNS_INFO_NO_RECORDSDNS_ERROR_BAD_PACKETDNS_ERROR_NO_PACKETDNS_ERROR_RCODEDNS_ERROR_UNSECURE_PACKETDNS_STATUS_PACKET_UNSECUREDNS_REQUEST_PENDINGDNS_ERROR_NO_MEMORYDNS_ERROR_INVALID_NAMEDNS_ERROR_INVALID_DATADNS_ERROR_GENERAL_API_BASEDNS_ERROR_INVALID_TYPEDNS_ERROR_INVALID_IP_ADDRESSDNS_ERROR_INVALID_PROPERTYDNS_ERROR_TRY_AGAIN_LATERDNS_ERROR_NOT_UNIQUEDNS_ERROR_NON_RFC_NAMEDNS_STATUS_FQDNDNS_STATUS_DOTTED_NAMEDNS_STATUS_SINGLE_PART_NAMEDNS_ERROR_INVALID_NAME_CHARDNS_ERROR_NUMERIC_NAMEDNS_ERROR_NOT_ALLOWED_ON_ROOT_SERVERDNS_ERROR_NOT_ALLOWED_UNDER_DELEGATIONDNS_ERROR_CANNOT_FIND_ROOT_HINTSDNS_ERROR_INCONSISTENT_ROOT_HINTSDNS_ERROR_DWORD_VALUE_TOO_SMALLDNS_ERROR_DWORD_VALUE_TOO_LARGEDNS_ERROR_BACKGROUND_LOADINGDNS_ERROR_NOT_ALLOWED_ON_RODCDNS_ERROR_NOT_ALLOWED_UNDER_DNAMEDNS_ERROR_DELEGATION_REQUIREDDNS_ERROR_INVALID_POLICY_TABLEDNS_ERROR_ZONE_BASEDNS_ERROR_ZONE_DOES_NOT_EXISTDNS_ERROR_NO_ZONE_INFODNS_ERROR_INVALID_ZONE_OPERATIONDNS_ERROR_ZONE_CONFIGURATION_ERRORDNS_ERROR_ZONE_HAS_NO_SOA_RECORDDNS_ERROR_ZONE_HAS_NO_NS_RECORDSDNS_ERROR_ZONE_LOCKEDDNS_ERROR_ZONE_CREATION_FAILEDDNS_ERROR_ZONE_ALREADY_EXISTSDNS_ERROR_AUTOZONE_ALREADY_EXISTSDNS_ERROR_INVALID_ZONE_TYPEDNS_ERROR_SECONDARY_REQUIRES_MASTER_IPDNS_ERROR_ZONE_NOT_SECONDARYDNS_ERROR_NEED_SECONDARY_ADDRESSESDNS_ERROR_WINS_INIT_FAILEDDNS_ERROR_NEED_WINS_SERVERSDNS_ERROR_NBSTAT_INIT_FAILEDDNS_ERROR_SOA_DELETE_INVALIDDNS_ERROR_FORWARDER_ALREADY_EXISTSDNS_ERROR_ZONE_REQUIRES_MASTER_IPDNS_ERROR_ZONE_IS_SHUTDOWNDNS_ERROR_ZONE_LOCKED_FOR_SIGNINGDNS_ERROR_DATAFILE_BASEDNS_ERROR_PRIMARY_REQUIRES_DATAFILEDNS_ERROR_INVALID_DATAFILE_NAMEDNS_ERROR_DATAFILE_OPEN_FAILUREDNS_ERROR_FILE_WRITEBACK_FAILEDDNS_ERROR_DATAFILE_PARSINGDNS_ERROR_DATABASE_BASEDNS_ERROR_RECORD_DOES_NOT_EXISTDNS_ERROR_RECORD_FORMATDNS_ERROR_NODE_CREATION_FAILEDDNS_ERROR_UNKNOWN_RECORD_TYPEDNS_ERROR_RECORD_TIMED_OUTDNS_ERROR_NAME_NOT_IN_ZONEDNS_ERROR_CNAME_LOOPDNS_ERROR_NODE_IS_CNAMEDNS_ERROR_CNAME_COLLISIONDNS_ERROR_RECORD_ONLY_AT_ZONE_ROOTDNS_ERROR_RECORD_ALREADY_EXISTSDNS_ERROR_SECONDARY_DATADNS_ERROR_NO_CREATE_CACHE_DATADNS_ERROR_NAME_DOES_NOT_EXISTDNS_WARNING_PTR_CREATE_FAILEDDNS_WARNING_DOMAIN_UNDELETEDDNS_ERROR_DS_UNAVAILABLEDNS_ERROR_DS_ZONE_ALREADY_EXISTSDNS_ERROR_NO_BOOTFILE_IF_DS_ZONEDNS_ERROR_NODE_IS_DNAMEDNS_ERROR_DNAME_COLLISIONDNS_ERROR_ALIAS_LOOPDNS_ERROR_OPERATION_BASEDNS_INFO_AXFR_COMPLETEDNS_ERROR_AXFRDNS_INFO_ADDED_LOCAL_WINSDNS_ERROR_SECURE_BASEDNS_STATUS_CONTINUE_NEEDEDDNS_ERROR_SETUP_BASEDNS_ERROR_NO_TCPIPDNS_ERROR_NO_DNS_SERVERSDNS_ERROR_DP_BASEDNS_ERROR_DP_DOES_NOT_EXISTDNS_ERROR_DP_ALREADY_EXISTSDNS_ERROR_DP_NOT_ENLISTEDDNS_ERROR_DP_ALREADY_ENLISTEDDNS_ERROR_DP_NOT_AVAILABLEDNS_ERROR_DP_FSMO_ERRORDNS_ERROR_ZONESCOPE_ALREADY_EXISTSDNS_ERROR_ZONESCOPE_DOES_NOT_EXISTDNS_ERROR_DEFAULT_ZONESCOPEDNS_ERROR_INVALID_ZONESCOPE_NAMEDNS_ERROR_NOT_ALLOWED_WITH_ZONESCOPESDNS_ERROR_LOAD_ZONESCOPE_FAILEDDNS_ERROR_ZONESCOPE_FILE_WRITEBACK_FAILEDDNS_ERROR_INVALID_SCOPE_NAMEDNS_ERROR_SCOPE_DOES_NOT_EXISTDNS_ERROR_DEFAULT_SCOPEDNS_ERROR_INVALID_SCOPE_OPERATIONDNS_ERROR_SCOPE_LOCKEDDNS_ERROR_SCOPE_ALREADY_EXISTSWSABASEERRWSASYSNOTREADYWSAVERNOTSUPPORTEDWSANOTINITIALISEDWSAECANCELLEDWSASYSCALLFAILUREWSASERVICE_NOT_FOUNDWSATYPE_NOT_FOUNDWSA_E_NO_MOREWSAHOST_NOT_FOUNDWSATRY_AGAINWSANO_RECOVERYWSANO_DATAWSA_QOS_RECEIVERSWSA_QOS_SENDERSWSA_QOS_NO_SENDERSWSA_QOS_NO_RECEIVERSWSA_QOS_REQUEST_CONFIRMEDWSA_QOS_ADMISSION_FAILUREWSA_QOS_POLICY_FAILUREWSA_QOS_BAD_STYLEWSA_QOS_BAD_OBJECTWSA_QOS_TRAFFIC_CTRL_ERRORWSA_QOS_GENERIC_ERRORWSA_QOS_ESERVICETYPEWSA_QOS_EFLOWSPECWSA_QOS_EPROVSPECBUFWSA_QOS_EFILTERSTYLEWSA_QOS_EFILTERTYPEWSA_QOS_EFILTERCOUNTWSA_QOS_EOBJLENGTHWSA_QOS_EFLOWCOUNTWSA_QOS_EUNKOWNPSOBJWSA_QOS_EPOLICYOBJWSA_QOS_EFLOWDESCWSA_QOS_EPSFLOWSPECWSA_QOS_EPSFILTERSPECWSA_QOS_ESDMODEOBJWSA_QOS_ESHAPERATEOBJWSA_QOS_RESERVED_PETYPEWSA_SECURE_HOST_NOT_FOUNDWSA_IPSEC_NAME_POLICY_ERRORERROR_IPSEC_QM_POLICY_EXISTSERROR_IPSEC_QM_POLICY_NOT_FOUNDERROR_IPSEC_QM_POLICY_IN_USEERROR_IPSEC_MM_POLICY_EXISTSERROR_IPSEC_MM_POLICY_NOT_FOUNDERROR_IPSEC_MM_POLICY_IN_USEERROR_IPSEC_MM_FILTER_EXISTSERROR_IPSEC_MM_FILTER_NOT_FOUNDERROR_IPSEC_TRANSPORT_FILTER_EXISTSERROR_IPSEC_TRANSPORT_FILTER_NOT_FOUNDERROR_IPSEC_MM_AUTH_EXISTSERROR_IPSEC_MM_AUTH_NOT_FOUNDERROR_IPSEC_MM_AUTH_IN_USEERROR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUNDERROR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUNDERROR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUNDERROR_IPSEC_TUNNEL_FILTER_EXISTSERROR_IPSEC_TUNNEL_FILTER_NOT_FOUNDERROR_IPSEC_MM_FILTER_PENDING_DELETIONERROR_IPSEC_TRANSPORT_FILTER_PENDING_DELETIONERROR_IPSEC_TUNNEL_FILTER_PENDING_DELETIONERROR_IPSEC_MM_POLICY_PENDING_DELETIONERROR_IPSEC_MM_AUTH_PENDING_DELETIONERROR_IPSEC_QM_POLICY_PENDING_DELETIONWARNING_IPSEC_MM_POLICY_PRUNEDWARNING_IPSEC_QM_POLICY_PRUNEDERROR_IPSEC_IKE_NEG_STATUS_BEGINERROR_IPSEC_IKE_AUTH_FAILERROR_IPSEC_IKE_ATTRIB_FAILERROR_IPSEC_IKE_NEGOTIATION_PENDINGERROR_IPSEC_IKE_GENERAL_PROCESSING_ERRORERROR_IPSEC_IKE_TIMED_OUTERROR_IPSEC_IKE_NO_CERTERROR_IPSEC_IKE_SA_DELETEDERROR_IPSEC_IKE_SA_REAPEDERROR_IPSEC_IKE_MM_ACQUIRE_DROPERROR_IPSEC_IKE_QM_ACQUIRE_DROPERROR_IPSEC_IKE_QUEUE_DROP_MMERROR_IPSEC_IKE_QUEUE_DROP_NO_MMERROR_IPSEC_IKE_DROP_NO_RESPONSEERROR_IPSEC_IKE_MM_DELAY_DROPERROR_IPSEC_IKE_QM_DELAY_DROPERROR_IPSEC_IKE_ERRORERROR_IPSEC_IKE_CRL_FAILEDERROR_IPSEC_IKE_INVALID_KEY_USAGEERROR_IPSEC_IKE_INVALID_CERT_TYPEERROR_IPSEC_IKE_NO_PRIVATE_KEYERROR_IPSEC_IKE_SIMULTANEOUS_REKEYERROR_IPSEC_IKE_DH_FAILERROR_IPSEC_IKE_CRITICAL_PAYLOAD_NOT_RECOGNIZEDERROR_IPSEC_IKE_INVALID_HEADERERROR_IPSEC_IKE_NO_POLICYERROR_IPSEC_IKE_INVALID_SIGNATUREERROR_IPSEC_IKE_KERBEROS_ERRORERROR_IPSEC_IKE_NO_PUBLIC_KEYERROR_IPSEC_IKE_PROCESS_ERRERROR_IPSEC_IKE_PROCESS_ERR_SAERROR_IPSEC_IKE_PROCESS_ERR_PROPERROR_IPSEC_IKE_PROCESS_ERR_TRANSERROR_IPSEC_IKE_PROCESS_ERR_KEERROR_IPSEC_IKE_PROCESS_ERR_IDERROR_IPSEC_IKE_PROCESS_ERR_CERTERROR_IPSEC_IKE_PROCESS_ERR_CERT_REQERROR_IPSEC_IKE_PROCESS_ERR_HASHERROR_IPSEC_IKE_PROCESS_ERR_SIGERROR_IPSEC_IKE_PROCESS_ERR_NONCEERROR_IPSEC_IKE_PROCESS_ERR_NOTIFYERROR_IPSEC_IKE_PROCESS_ERR_DELETEERROR_IPSEC_IKE_PROCESS_ERR_VENDORERROR_IPSEC_IKE_INVALID_PAYLOADERROR_IPSEC_IKE_LOAD_SOFT_SAERROR_IPSEC_IKE_SOFT_SA_TORN_DOWNERROR_IPSEC_IKE_INVALID_COOKIEERROR_IPSEC_IKE_NO_PEER_CERTERROR_IPSEC_IKE_PEER_CRL_FAILEDERROR_IPSEC_IKE_POLICY_CHANGEERROR_IPSEC_IKE_NO_MM_POLICYERROR_IPSEC_IKE_NOTCBPRIVERROR_IPSEC_IKE_SECLOADFAILERROR_IPSEC_IKE_FAILSSPINITERROR_IPSEC_IKE_FAILQUERYSSPERROR_IPSEC_IKE_SRVACQFAILERROR_IPSEC_IKE_SRVQUERYCREDERROR_IPSEC_IKE_GETSPIFAILERROR_IPSEC_IKE_INVALID_FILTERERROR_IPSEC_IKE_OUT_OF_MEMORYERROR_IPSEC_IKE_ADD_UPDATE_KEY_FAILEDERROR_IPSEC_IKE_INVALID_POLICYERROR_IPSEC_IKE_UNKNOWN_DOIERROR_IPSEC_IKE_INVALID_SITUATIONERROR_IPSEC_IKE_DH_FAILUREERROR_IPSEC_IKE_INVALID_GROUPERROR_IPSEC_IKE_ENCRYPTERROR_IPSEC_IKE_DECRYPTERROR_IPSEC_IKE_POLICY_MATCHERROR_IPSEC_IKE_UNSUPPORTED_IDERROR_IPSEC_IKE_INVALID_HASHERROR_IPSEC_IKE_INVALID_HASH_ALGERROR_IPSEC_IKE_INVALID_HASH_SIZEERROR_IPSEC_IKE_INVALID_ENCRYPT_ALGERROR_IPSEC_IKE_INVALID_AUTH_ALGERROR_IPSEC_IKE_INVALID_SIGERROR_IPSEC_IKE_LOAD_FAILEDERROR_IPSEC_IKE_RPC_DELETEERROR_IPSEC_IKE_BENIGN_REINITERROR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFYERROR_IPSEC_IKE_INVALID_MAJOR_VERSIONERROR_IPSEC_IKE_INVALID_CERT_KEYLENERROR_IPSEC_IKE_MM_LIMITERROR_IPSEC_IKE_NEGOTIATION_DISABLEDERROR_IPSEC_IKE_QM_LIMITERROR_IPSEC_IKE_MM_EXPIREDERROR_IPSEC_IKE_PEER_MM_ASSUMED_INVALIDERROR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCHERROR_IPSEC_IKE_UNEXPECTED_MESSAGE_IDERROR_IPSEC_IKE_INVALID_AUTH_PAYLOADERROR_IPSEC_IKE_DOS_COOKIE_SENTERROR_IPSEC_IKE_SHUTTING_DOWNERROR_IPSEC_IKE_CGA_AUTH_FAILEDERROR_IPSEC_IKE_PROCESS_ERR_NATOAERROR_IPSEC_IKE_INVALID_MM_FOR_QMERROR_IPSEC_IKE_QM_EXPIREDERROR_IPSEC_IKE_TOO_MANY_FILTERSERROR_IPSEC_IKE_NEG_STATUS_ENDERROR_IPSEC_IKE_KILL_DUMMY_NAP_TUNNELERROR_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILUREERROR_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSINGERROR_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDINGERROR_IPSEC_IKE_COEXISTENCE_SUPPRESSERROR_IPSEC_IKE_RATELIMIT_DROPERROR_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKEERROR_IPSEC_IKE_AUTHORIZATION_FAILUREERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILUREERROR_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRYERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILUREERROR_IPSEC_IKE_NEG_STATUS_EXTENDED_ENDERROR_IPSEC_BAD_SPIERROR_IPSEC_SA_LIFETIME_EXPIREDERROR_IPSEC_WRONG_SAERROR_IPSEC_REPLAY_CHECK_FAILEDERROR_IPSEC_INVALID_PACKETERROR_IPSEC_INTEGRITY_CHECK_FAILEDERROR_IPSEC_CLEAR_TEXT_DROPERROR_IPSEC_AUTH_FIREWALL_DROPERROR_IPSEC_THROTTLE_DROPERROR_IPSEC_DOSP_BLOCKERROR_IPSEC_DOSP_RECEIVED_MULTICASTERROR_IPSEC_DOSP_INVALID_PACKETERROR_IPSEC_DOSP_STATE_LOOKUP_FAILEDERROR_IPSEC_DOSP_MAX_ENTRIESERROR_IPSEC_DOSP_KEYMOD_NOT_ALLOWEDERROR_IPSEC_DOSP_NOT_INSTALLEDERROR_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUESERROR_SXS_SECTION_NOT_FOUNDERROR_SXS_CANT_GEN_ACTCTXERROR_SXS_INVALID_ACTCTXDATA_FORMATERROR_SXS_ASSEMBLY_NOT_FOUNDERROR_SXS_MANIFEST_FORMAT_ERRORERROR_SXS_MANIFEST_PARSE_ERRORERROR_SXS_ACTIVATION_CONTEXT_DISABLEDERROR_SXS_KEY_NOT_FOUNDERROR_SXS_VERSION_CONFLICTERROR_SXS_WRONG_SECTION_TYPEERROR_SXS_THREAD_QUERIES_DISABLEDERROR_SXS_PROCESS_DEFAULT_ALREADY_SETERROR_SXS_UNKNOWN_ENCODING_GROUPERROR_SXS_UNKNOWN_ENCODINGERROR_SXS_INVALID_XML_NAMESPACE_URIERROR_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLEDERROR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLEDERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTEERROR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACEERROR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACEERROR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINTERROR_SXS_DUPLICATE_DLL_NAMEERROR_SXS_DUPLICATE_WINDOWCLASS_NAMEERROR_SXS_DUPLICATE_CLSIDERROR_SXS_DUPLICATE_IIDERROR_SXS_DUPLICATE_TLBIDERROR_SXS_DUPLICATE_PROGIDERROR_SXS_DUPLICATE_ASSEMBLY_NAMEERROR_SXS_FILE_HASH_MISMATCHERROR_SXS_POLICY_PARSE_ERRORERROR_SXS_XML_E_MISSINGQUOTEERROR_SXS_XML_E_COMMENTSYNTAXERROR_SXS_XML_E_BADSTARTNAMECHARERROR_SXS_XML_E_BADNAMECHARERROR_SXS_XML_E_BADCHARINSTRINGERROR_SXS_XML_E_XMLDECLSYNTAXERROR_SXS_XML_E_BADCHARDATAERROR_SXS_XML_E_MISSINGWHITESPACEERROR_SXS_XML_E_EXPECTINGTAGENDERROR_SXS_XML_E_MISSINGSEMICOLONERROR_SXS_XML_E_UNBALANCEDPARENERROR_SXS_XML_E_INTERNALERRORERROR_SXS_XML_E_UNEXPECTED_WHITESPACEERROR_SXS_XML_E_INCOMPLETE_ENCODINGERROR_SXS_XML_E_MISSING_PARENERROR_SXS_XML_E_EXPECTINGCLOSEQUOTEERROR_SXS_XML_E_MULTIPLE_COLONSERROR_SXS_XML_E_INVALID_DECIMALERROR_SXS_XML_E_INVALID_HEXIDECIMALERROR_SXS_XML_E_INVALID_UNICODEERROR_SXS_XML_E_WHITESPACEORQUESTIONMARKERROR_SXS_XML_E_UNEXPECTEDENDTAGERROR_SXS_XML_E_UNCLOSEDTAGERROR_SXS_XML_E_DUPLICATEATTRIBUTEERROR_SXS_XML_E_MULTIPLEROOTSERROR_SXS_XML_E_INVALIDATROOTLEVELERROR_SXS_XML_E_BADXMLDECLERROR_SXS_XML_E_MISSINGROOTERROR_SXS_XML_E_UNEXPECTEDEOFERROR_SXS_XML_E_BADPEREFINSUBSETERROR_SXS_XML_E_UNCLOSEDSTARTTAGERROR_SXS_XML_E_UNCLOSEDENDTAGERROR_SXS_XML_E_UNCLOSEDSTRINGERROR_SXS_XML_E_UNCLOSEDCOMMENTERROR_SXS_XML_E_UNCLOSEDDECLERROR_SXS_XML_E_UNCLOSEDCDATAERROR_SXS_XML_E_RESERVEDNAMESPACEERROR_SXS_XML_E_INVALIDENCODINGERROR_SXS_XML_E_INVALIDSWITCHERROR_SXS_XML_E_BADXMLCASEERROR_SXS_XML_E_INVALID_STANDALONEERROR_SXS_XML_E_UNEXPECTED_STANDALONEERROR_SXS_XML_E_INVALID_VERSIONERROR_SXS_XML_E_MISSINGEQUALSERROR_SXS_PROTECTION_RECOVERY_FAILEDERROR_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORTERROR_SXS_PROTECTION_CATALOG_NOT_VALIDERROR_SXS_UNTRANSLATABLE_HRESULTERROR_SXS_PROTECTION_CATALOG_FILE_MISSINGERROR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTEERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAMEERROR_SXS_ASSEMBLY_MISSINGERROR_SXS_CORRUPT_ACTIVATION_STACKERROR_SXS_CORRUPTIONERROR_SXS_EARLY_DEACTIVATIONERROR_SXS_INVALID_DEACTIVATIONERROR_SXS_MULTIPLE_DEACTIVATIONERROR_SXS_PROCESS_TERMINATION_REQUESTEDERROR_SXS_RELEASE_ACTIVATION_CONTEXTERROR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTYERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUEERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAMEERROR_SXS_IDENTITY_DUPLICATE_ATTRIBUTEERROR_SXS_IDENTITY_PARSE_ERRORERROR_MALFORMED_SUBSTITUTION_STRINGERROR_SXS_INCORRECT_PUBLIC_KEY_TOKENERROR_UNMAPPED_SUBSTITUTION_STRINGERROR_SXS_ASSEMBLY_NOT_LOCKEDERROR_SXS_COMPONENT_STORE_CORRUPTERROR_ADVANCED_INSTALLER_FAILEDERROR_XML_ENCODING_MISMATCHERROR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENTERROR_SXS_IDENTITIES_DIFFERENTERROR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENTERROR_SXS_FILE_NOT_PART_OF_ASSEMBLYERROR_SXS_MANIFEST_TOO_BIGERROR_SXS_SETTING_NOT_REGISTEREDERROR_SXS_TRANSACTION_CLOSURE_INCOMPLETEERROR_SMI_PRIMITIVE_INSTALLER_FAILEDERROR_GENERIC_COMMAND_FAILEDERROR_SXS_FILE_HASH_MISSINGERROR_EVT_INVALID_CHANNEL_PATHERROR_EVT_INVALID_QUERYERROR_EVT_PUBLISHER_METADATA_NOT_FOUNDERROR_EVT_EVENT_TEMPLATE_NOT_FOUNDERROR_EVT_INVALID_PUBLISHER_NAMEERROR_EVT_INVALID_EVENT_DATAERROR_EVT_CHANNEL_NOT_FOUNDERROR_EVT_MALFORMED_XML_TEXTERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNELERROR_EVT_CONFIGURATION_ERRORERROR_EVT_QUERY_RESULT_STALEERROR_EVT_QUERY_RESULT_INVALID_POSITIONERROR_EVT_NON_VALIDATING_MSXMLERROR_EVT_FILTER_ALREADYSCOPEDERROR_EVT_FILTER_NOTELTSETERROR_EVT_FILTER_INVARGERROR_EVT_FILTER_INVTESTERROR_EVT_FILTER_INVTYPEERROR_EVT_FILTER_PARSEERRERROR_EVT_FILTER_UNSUPPORTEDOPERROR_EVT_FILTER_UNEXPECTEDTOKENERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNELERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUEERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUEERROR_EVT_CHANNEL_CANNOT_ACTIVATEERROR_EVT_FILTER_TOO_COMPLEXERROR_EVT_MESSAGE_NOT_FOUNDERROR_EVT_MESSAGE_ID_NOT_FOUNDERROR_EVT_UNRESOLVED_VALUE_INSERTERROR_EVT_UNRESOLVED_PARAMETER_INSERTERROR_EVT_MAX_INSERTS_REACHEDERROR_EVT_EVENT_DEFINITION_NOT_FOUNDERROR_EVT_MESSAGE_LOCALE_NOT_FOUNDERROR_EVT_VERSION_TOO_OLDERROR_EVT_VERSION_TOO_NEWERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERYERROR_EVT_PUBLISHER_DISABLEDERROR_EVT_FILTER_OUT_OF_RANGEERROR_EC_SUBSCRIPTION_CANNOT_ACTIVATEERROR_EC_LOG_DISABLEDERROR_EC_CIRCULAR_FORWARDINGERROR_EC_CREDSTORE_FULLERROR_EC_CRED_NOT_FOUNDERROR_EC_NO_ACTIVE_CHANNELERROR_MUI_FILE_NOT_FOUNDERROR_MUI_INVALID_FILEERROR_MUI_INVALID_RC_CONFIGERROR_MUI_INVALID_LOCALE_NAMEERROR_MUI_INVALID_ULTIMATEFALLBACK_NAMEERROR_MUI_FILE_NOT_LOADEDERROR_RESOURCE_ENUM_USER_STOPERROR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLEDERROR_MUI_INTLSETTINGS_INVALID_LOCALE_NAMEERROR_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCEERROR_MRM_INVALID_PRICONFIGERROR_MRM_INVALID_FILE_TYPEERROR_MRM_UNKNOWN_QUALIFIERERROR_MRM_INVALID_QUALIFIER_VALUEERROR_MRM_NO_CANDIDATEERROR_MRM_NO_MATCH_OR_DEFAULT_CANDIDATEERROR_MRM_RESOURCE_TYPE_MISMATCHERROR_MRM_DUPLICATE_MAP_NAMEERROR_MRM_DUPLICATE_ENTRYERROR_MRM_INVALID_RESOURCE_IDENTIFIERERROR_MRM_FILEPATH_TOO_LONGERROR_MRM_UNSUPPORTED_DIRECTORY_TYPEERROR_MRM_INVALID_PRI_FILEERROR_MRM_NAMED_RESOURCE_NOT_FOUNDERROR_MRM_MAP_NOT_FOUNDERROR_MRM_UNSUPPORTED_PROFILE_TYPEERROR_MRM_INVALID_QUALIFIER_OPERATORERROR_MRM_INDETERMINATE_QUALIFIER_VALUEERROR_MRM_AUTOMERGE_ENABLEDERROR_MRM_TOO_MANY_RESOURCESERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_MERGEERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_LOAD_UNLOAD_PRI_FILEERROR_MRM_NO_CURRENT_VIEW_ON_THREADERROR_DIFFERENT_PROFILE_RESOURCE_MANAGER_EXISTERROR_OPERATION_NOT_ALLOWED_FROM_SYSTEM_COMPONENTERROR_MRM_DIRECT_REF_TO_NON_DEFAULT_RESOURCEERROR_MRM_GENERATION_COUNT_MISMATCHERROR_MCA_INVALID_CAPABILITIES_STRINGERROR_MCA_INVALID_VCP_VERSIONERROR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATIONERROR_MCA_MCCS_VERSION_MISMATCHERROR_MCA_UNSUPPORTED_MCCS_VERSIONERROR_MCA_INTERNAL_ERRORERROR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNEDERROR_MCA_UNSUPPORTED_COLOR_TEMPERATUREERROR_AMBIGUOUS_SYSTEM_DEVICEERROR_SYSTEM_DEVICE_NOT_FOUNDERROR_HASH_NOT_SUPPORTEDERROR_HASH_NOT_PRESENTERROR_SECONDARY_IC_PROVIDER_NOT_REGISTEREDERROR_GPIO_CLIENT_INFORMATION_INVALIDERROR_GPIO_VERSION_NOT_SUPPORTEDERROR_GPIO_INVALID_REGISTRATION_PACKETERROR_GPIO_OPERATION_DENIEDERROR_GPIO_INCOMPATIBLE_CONNECT_MODEERROR_GPIO_INTERRUPT_ALREADY_UNMASKEDERROR_CANNOT_SWITCH_RUNLEVELERROR_INVALID_RUNLEVEL_SETTINGERROR_RUNLEVEL_SWITCH_TIMEOUTERROR_RUNLEVEL_SWITCH_AGENT_TIMEOUTERROR_RUNLEVEL_SWITCH_IN_PROGRESSERROR_SERVICES_FAILED_AUTOSTARTERROR_COM_TASK_STOP_PENDINGERROR_INSTALL_OPEN_PACKAGE_FAILEDERROR_INSTALL_PACKAGE_NOT_FOUNDERROR_INSTALL_INVALID_PACKAGEERROR_INSTALL_RESOLVE_DEPENDENCY_FAILEDERROR_INSTALL_OUT_OF_DISK_SPACEERROR_INSTALL_NETWORK_FAILUREERROR_INSTALL_REGISTRATION_FAILUREERROR_INSTALL_DEREGISTRATION_FAILUREERROR_INSTALL_CANCELERROR_INSTALL_FAILEDERROR_REMOVE_FAILEDERROR_PACKAGE_ALREADY_EXISTSERROR_NEEDS_REMEDIATIONERROR_INSTALL_PREREQUISITE_FAILEDERROR_PACKAGE_REPOSITORY_CORRUPTEDERROR_INSTALL_POLICY_FAILUREERROR_PACKAGE_UPDATINGERROR_DEPLOYMENT_BLOCKED_BY_POLICYERROR_PACKAGES_IN_USEERROR_RECOVERY_FILE_CORRUPTERROR_INVALID_STAGED_SIGNATUREERROR_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILEDERROR_INSTALL_PACKAGE_DOWNGRADEERROR_SYSTEM_NEEDS_REMEDIATIONERROR_APPX_INTEGRITY_FAILURE_CLR_NGENERROR_RESILIENCY_FILE_CORRUPTERROR_INSTALL_FIREWALL_SERVICE_NOT_RUNNINGAPPMODEL_ERROR_NO_PACKAGEAPPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPTAPPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPTAPPMODEL_ERROR_NO_APPLICATIONAPPMODEL_ERROR_DYNAMIC_PROPERTY_READ_FAILEDAPPMODEL_ERROR_DYNAMIC_PROPERTY_INVALIDERROR_STATE_LOAD_STORE_FAILEDERROR_STATE_GET_VERSION_FAILEDERROR_STATE_SET_VERSION_FAILEDERROR_STATE_STRUCTURED_RESET_FAILEDERROR_STATE_OPEN_CONTAINER_FAILEDERROR_STATE_CREATE_CONTAINER_FAILEDERROR_STATE_DELETE_CONTAINER_FAILEDERROR_STATE_READ_SETTING_FAILEDERROR_STATE_WRITE_SETTING_FAILEDERROR_STATE_DELETE_SETTING_FAILEDERROR_STATE_QUERY_SETTING_FAILEDERROR_STATE_READ_COMPOSITE_SETTING_FAILEDERROR_STATE_WRITE_COMPOSITE_SETTING_FAILEDERROR_STATE_ENUMERATE_CONTAINER_FAILEDERROR_STATE_ENUMERATE_SETTINGS_FAILEDERROR_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDEDERROR_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDEDERROR_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDEDERROR_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDEDERROR_API_UNAVAILABLESTORE_ERROR_UNLICENSEDSTORE_ERROR_UNLICENSED_USERSTORE_ERROR_PENDING_COM_TRANSACTIONSTORE_ERROR_LICENSE_REVOKEDSEVERITY_SUCCESSSEVERITY_ERRORSUCCEEDEDFAILEDIS_ERRORHRESULT_CODESCODE_CODEHRESULT_FACILITYSCODE_FACILITYHRESULT_SEVERITYSCODE_SEVERITYFACILITY_NT_BITHRESULT_FROM_WIN32HRESULT_FROM_NTNOERRORE_UNEXPECTEDE_NOTIMPLE_OUTOFMEMORYE_INVALIDARGE_NOINTERFACEE_POINTERE_HANDLEE_ABORTE_FAILE_ACCESSDENIEDE_PENDINGE_BOUNDSE_CHANGED_STATEE_ILLEGAL_STATE_CHANGEE_ILLEGAL_METHOD_CALLRO_E_METADATA_NAME_NOT_FOUNDRO_E_METADATA_NAME_IS_NAMESPACERO_E_METADATA_INVALID_TYPE_FORMATRO_E_INVALID_METADATA_FILERO_E_CLOSEDRO_E_EXCLUSIVE_WRITERO_E_CHANGE_NOTIFICATION_IN_PROGRESSRO_E_ERROR_STRING_NOT_FOUNDE_STRING_NOT_NULL_TERMINATEDE_ILLEGAL_DELEGATE_ASSIGNMENTE_ASYNC_OPERATION_NOT_STARTEDE_APPLICATION_EXITINGE_APPLICATION_VIEW_EXITINGRO_E_MUST_BE_AGILERO_E_UNSUPPORTED_FROM_MTARO_E_COMMITTEDRO_E_BLOCKED_CROSS_ASTA_CALLCO_E_INIT_TLSCO_E_INIT_SHARED_ALLOCATORCO_E_INIT_MEMORY_ALLOCATORCO_E_INIT_CLASS_CACHECO_E_INIT_RPC_CHANNELCO_E_INIT_TLS_SET_CHANNEL_CONTROLCO_E_INIT_TLS_CHANNEL_CONTROLCO_E_INIT_UNACCEPTED_USER_ALLOCATORCO_E_INIT_SCM_MUTEX_EXISTSCO_E_INIT_SCM_FILE_MAPPING_EXISTSCO_E_INIT_SCM_MAP_VIEW_OF_FILECO_E_INIT_SCM_EXEC_FAILURECO_E_INIT_ONLY_SINGLE_THREADEDCO_E_CANT_REMOTECO_E_BAD_SERVER_NAMECO_E_WRONG_SERVER_IDENTITYCO_E_OLE1DDE_DISABLEDCO_E_RUNAS_SYNTAXCO_E_CREATEPROCESS_FAILURECO_E_RUNAS_CREATEPROCESS_FAILURECO_E_RUNAS_LOGON_FAILURECO_E_LAUNCH_PERMSSION_DENIEDCO_E_START_SERVICE_FAILURECO_E_REMOTE_COMMUNICATION_FAILURECO_E_SERVER_START_TIMEOUTCO_E_CLSREG_INCONSISTENTCO_E_IIDREG_INCONSISTENTCO_E_NOT_SUPPORTEDCO_E_RELOAD_DLLCO_E_MSI_ERRORCO_E_ATTEMPT_TO_CREATE_OUTSIDE_CLIENT_CONTEXTCO_E_SERVER_PAUSEDCO_E_SERVER_NOT_PAUSEDCO_E_CLASS_DISABLEDCO_E_CLRNOTAVAILABLECO_E_ASYNC_WORK_REJECTEDCO_E_SERVER_INIT_TIMEOUTCO_E_NO_SECCTX_IN_ACTIVATECO_E_TRACKER_CONFIGCO_E_THREADPOOL_CONFIGCO_E_SXS_CONFIGCO_E_MALFORMED_SPNCO_E_UNREVOKED_REGISTRATION_ON_APARTMENT_SHUTDOWNCO_E_PREMATURE_STUB_RUNDOWNOLE_E_FIRSTOLE_E_LASTOLE_S_FIRSTOLE_S_LASTOLE_E_OLEVERBOLE_E_ADVFOLE_E_ENUM_NOMOREOLE_E_ADVISENOTSUPPORTEDOLE_E_NOCONNECTIONOLE_E_NOTRUNNINGOLE_E_NOCACHEOLE_E_BLANKOLE_E_CLASSDIFFOLE_E_CANT_GETMONIKEROLE_E_CANT_BINDTOSOURCEOLE_E_STATICOLE_E_PROMPTSAVECANCELLEDOLE_E_INVALIDRECTOLE_E_WRONGCOMPOBJOLE_E_INVALIDHWNDOLE_E_NOT_INPLACEACTIVEOLE_E_CANTCONVERTOLE_E_NOSTORAGEDV_E_FORMATETCDV_E_DVTARGETDEVICEDV_E_STGMEDIUMDV_E_STATDATADV_E_LINDEXDV_E_TYMEDDV_E_CLIPFORMATDV_E_DVASPECTDV_E_DVTARGETDEVICE_SIZEDV_E_NOIVIEWOBJECTDRAGDROP_E_FIRSTDRAGDROP_E_LASTDRAGDROP_S_FIRSTDRAGDROP_S_LASTDRAGDROP_E_NOTREGISTEREDDRAGDROP_E_ALREADYREGISTEREDDRAGDROP_E_INVALIDHWNDDRAGDROP_E_CONCURRENT_DRAG_ATTEMPTEDCLASSFACTORY_E_FIRSTCLASSFACTORY_E_LASTCLASSFACTORY_S_FIRSTCLASSFACTORY_S_LASTCLASS_E_NOAGGREGATIONCLASS_E_CLASSNOTAVAILABLECLASS_E_NOTLICENSEDMARSHAL_E_FIRSTMARSHAL_E_LASTMARSHAL_S_FIRSTMARSHAL_S_LASTDATA_E_FIRSTDATA_E_LASTDATA_S_FIRSTDATA_S_LASTVIEW_E_FIRSTVIEW_E_LASTVIEW_S_FIRSTVIEW_S_LASTVIEW_E_DRAWREGDB_E_FIRSTREGDB_E_LASTREGDB_S_FIRSTREGDB_S_LASTREGDB_E_READREGDBREGDB_E_WRITEREGDBREGDB_E_KEYMISSINGREGDB_E_INVALIDVALUEREGDB_E_CLASSNOTREGREGDB_E_IIDNOTREGREGDB_E_BADTHREADINGMODELCAT_E_FIRSTCAT_E_LASTCAT_E_CATIDNOEXISTCAT_E_NODESCRIPTIONCS_E_FIRSTCS_E_LASTCS_E_PACKAGE_NOTFOUNDCS_E_NOT_DELETABLECS_E_CLASS_NOTFOUNDCS_E_INVALID_VERSIONCS_E_NO_CLASSSTORECS_E_OBJECT_NOTFOUNDCS_E_OBJECT_ALREADY_EXISTSCS_E_INVALID_PATHCS_E_NETWORK_ERRORCS_E_ADMIN_LIMIT_EXCEEDEDCS_E_SCHEMA_MISMATCHCS_E_INTERNAL_ERRORCACHE_E_FIRSTCACHE_E_LASTCACHE_S_FIRSTCACHE_S_LASTCACHE_E_NOCACHE_UPDATEDOLEOBJ_E_FIRSTOLEOBJ_E_LASTOLEOBJ_S_FIRSTOLEOBJ_S_LASTOLEOBJ_E_NOVERBSOLEOBJ_E_INVALIDVERBCLIENTSITE_E_FIRSTCLIENTSITE_E_LASTCLIENTSITE_S_FIRSTCLIENTSITE_S_LASTINPLACE_E_NOTUNDOABLEINPLACE_E_NOTOOLSPACEINPLACE_E_FIRSTINPLACE_E_LASTINPLACE_S_FIRSTINPLACE_S_LASTENUM_E_FIRSTENUM_E_LASTENUM_S_FIRSTENUM_S_LASTCONVERT10_E_FIRSTCONVERT10_E_LASTCONVERT10_S_FIRSTCONVERT10_S_LASTCONVERT10_E_OLESTREAM_GETCONVERT10_E_OLESTREAM_PUTCONVERT10_E_OLESTREAM_FMTCONVERT10_E_OLESTREAM_BITMAP_TO_DIBCONVERT10_E_STG_FMTCONVERT10_E_STG_NO_STD_STREAMCONVERT10_E_STG_DIB_TO_BITMAPCLIPBRD_E_FIRSTCLIPBRD_E_LASTCLIPBRD_S_FIRSTCLIPBRD_S_LASTCLIPBRD_E_CANT_OPENCLIPBRD_E_CANT_EMPTYCLIPBRD_E_CANT_SETCLIPBRD_E_BAD_DATACLIPBRD_E_CANT_CLOSEMK_E_FIRSTMK_E_LASTMK_S_FIRSTMK_S_LASTMK_E_CONNECTMANUALLYMK_E_EXCEEDEDDEADLINEMK_E_NEEDGENERICMK_E_UNAVAILABLEMK_E_SYNTAXMK_E_NOOBJECTMK_E_INVALIDEXTENSIONMK_E_INTERMEDIATEINTERFACENOTSUPPORTEDMK_E_NOTBINDABLEMK_E_NOTBOUNDMK_E_CANTOPENFILEMK_E_MUSTBOTHERUSERMK_E_NOINVERSEMK_E_NOSTORAGEMK_E_NOPREFIXMK_E_ENUMERATION_FAILEDCO_E_FIRSTCO_E_LASTCO_S_FIRSTCO_S_LASTCO_E_NOTINITIALIZEDCO_E_ALREADYINITIALIZEDCO_E_CANTDETERMINECLASSCO_E_CLASSSTRINGCO_E_IIDSTRINGCO_E_APPNOTFOUNDCO_E_APPSINGLEUSECO_E_ERRORINAPPCO_E_DLLNOTFOUNDCO_E_ERRORINDLLCO_E_WRONGOSFORAPPCO_E_OBJNOTREGCO_E_OBJISREGCO_E_OBJNOTCONNECTEDCO_E_APPDIDNTREGCO_E_RELEASEDEVENT_E_FIRSTEVENT_E_LASTEVENT_S_FIRSTEVENT_S_LASTEVENT_S_SOME_SUBSCRIBERS_FAILEDEVENT_E_ALL_SUBSCRIBERS_FAILEDEVENT_S_NOSUBSCRIBERSEVENT_E_QUERYSYNTAXEVENT_E_QUERYFIELDEVENT_E_INTERNALEXCEPTIONEVENT_E_INTERNALERROREVENT_E_INVALID_PER_USER_SIDEVENT_E_USER_EXCEPTIONEVENT_E_TOO_MANY_METHODSEVENT_E_MISSING_EVENTCLASSEVENT_E_NOT_ALL_REMOVEDEVENT_E_COMPLUS_NOT_INSTALLEDEVENT_E_CANT_MODIFY_OR_DELETE_UNCONFIGURED_OBJECTEVENT_E_CANT_MODIFY_OR_DELETE_CONFIGURED_OBJECTEVENT_E_INVALID_EVENT_CLASS_PARTITIONEVENT_E_PER_USER_SID_NOT_LOGGED_ONTPC_E_INVALID_PROPERTYTPC_E_NO_DEFAULT_TABLETTPC_E_UNKNOWN_PROPERTYTPC_E_INVALID_INPUT_RECTTPC_E_INVALID_STROKETPC_E_INITIALIZE_FAILTPC_E_NOT_RELEVANTTPC_E_INVALID_PACKET_DESCRIPTIONTPC_E_RECOGNIZER_NOT_REGISTEREDTPC_E_INVALID_RIGHTSTPC_E_OUT_OF_ORDER_CALLTPC_E_QUEUE_FULLTPC_E_INVALID_CONFIGURATIONTPC_E_INVALID_DATA_FROM_RECOGNIZERTPC_S_TRUNCATEDTPC_S_INTERRUPTEDTPC_S_NO_DATA_TO_PROCESSXACT_E_FIRSTXACT_E_LASTXACT_S_FIRSTXACT_S_LASTXACT_E_ALREADYOTHERSINGLEPHASEXACT_E_CANTRETAINXACT_E_COMMITFAILEDXACT_E_COMMITPREVENTEDXACT_E_HEURISTICABORTXACT_E_HEURISTICCOMMITXACT_E_HEURISTICDAMAGEXACT_E_HEURISTICDANGERXACT_E_ISOLATIONLEVELXACT_E_NOASYNCXACT_E_NOENLISTXACT_E_NOISORETAINXACT_E_NORESOURCEXACT_E_NOTCURRENTXACT_E_NOTRANSACTIONXACT_E_NOTSUPPORTEDXACT_E_UNKNOWNRMGRIDXACT_E_WRONGSTATEXACT_E_WRONGUOWXACT_E_XTIONEXISTSXACT_E_NOIMPORTOBJECTXACT_E_INVALIDCOOKIEXACT_E_INDOUBTXACT_E_NOTIMEOUTXACT_E_ALREADYINPROGRESSXACT_E_ABORTEDXACT_E_LOGFULLXACT_E_TMNOTAVAILABLEXACT_E_CONNECTION_DOWNXACT_E_CONNECTION_DENIEDXACT_E_REENLISTTIMEOUTXACT_E_TIP_CONNECT_FAILEDXACT_E_TIP_PROTOCOL_ERRORXACT_E_TIP_PULL_FAILEDXACT_E_DEST_TMNOTAVAILABLEXACT_E_TIP_DISABLEDXACT_E_NETWORK_TX_DISABLEDXACT_E_PARTNER_NETWORK_TX_DISABLEDXACT_E_XA_TX_DISABLEDXACT_E_UNABLE_TO_READ_DTC_CONFIGXACT_E_UNABLE_TO_LOAD_DTC_PROXYXACT_E_ABORTINGXACT_E_PUSH_COMM_FAILUREXACT_E_PULL_COMM_FAILUREXACT_E_LU_TX_DISABLEDXACT_E_CLERKNOTFOUNDXACT_E_CLERKEXISTSXACT_E_RECOVERYINPROGRESSXACT_E_TRANSACTIONCLOSEDXACT_E_INVALIDLSNXACT_E_REPLAYREQUESTXACT_S_ASYNCXACT_S_DEFECTXACT_S_READONLYXACT_S_SOMENORETAINXACT_S_OKINFORMXACT_S_MADECHANGESCONTENTXACT_S_MADECHANGESINFORMXACT_S_ALLNORETAINXACT_S_ABORTINGXACT_S_SINGLEPHASEXACT_S_LOCALLY_OKXACT_S_LASTRESOURCEMANAGERCONTEXT_E_FIRSTCONTEXT_E_LASTCONTEXT_S_FIRSTCONTEXT_S_LASTCONTEXT_E_ABORTEDCONTEXT_E_ABORTINGCONTEXT_E_NOCONTEXTCONTEXT_E_WOULD_DEADLOCKCONTEXT_E_SYNCH_TIMEOUTCONTEXT_E_OLDREFCONTEXT_E_ROLENOTFOUNDCONTEXT_E_TMNOTAVAILABLECO_E_ACTIVATIONFAILEDCO_E_ACTIVATIONFAILED_EVENTLOGGEDCO_E_ACTIVATIONFAILED_CATALOGERRORCO_E_ACTIVATIONFAILED_TIMEOUTCO_E_INITIALIZATIONFAILEDCONTEXT_E_NOJITCONTEXT_E_NOTRANSACTIONCO_E_THREADINGMODEL_CHANGEDCO_E_NOIISINTRINSICSCO_E_NOCOOKIESCO_E_DBERRORCO_E_NOTPOOLEDCO_E_NOTCONSTRUCTEDCO_E_NOSYNCHRONIZATIONCO_E_ISOLEVELMISMATCHCO_E_CALL_OUT_OF_TX_SCOPE_NOT_ALLOWEDCO_E_EXIT_TRANSACTION_SCOPE_NOT_CALLEDOLE_S_USEREGOLE_S_STATICOLE_S_MAC_CLIPFORMATDRAGDROP_S_DROPDRAGDROP_S_CANCELDRAGDROP_S_USEDEFAULTCURSORSDATA_S_SAMEFORMATETCVIEW_S_ALREADY_FROZENCACHE_S_FORMATETC_NOTSUPPORTEDCACHE_S_SAMECACHECACHE_S_SOMECACHES_NOTUPDATEDOLEOBJ_S_INVALIDVERBOLEOBJ_S_CANNOT_DOVERB_NOWOLEOBJ_S_INVALIDHWNDINPLACE_S_TRUNCATEDCONVERT10_S_NO_PRESENTATIONMK_S_REDUCED_TO_SELFMK_S_MEMK_S_HIMMK_S_USMK_S_MONIKERALREADYREGISTEREDSCHED_S_TASK_READYSCHED_S_TASK_RUNNINGSCHED_S_TASK_DISABLEDSCHED_S_TASK_HAS_NOT_RUNSCHED_S_TASK_NO_MORE_RUNSSCHED_S_TASK_NOT_SCHEDULEDSCHED_S_TASK_TERMINATEDSCHED_S_TASK_NO_VALID_TRIGGERSSCHED_S_EVENT_TRIGGERSCHED_E_TRIGGER_NOT_FOUNDSCHED_E_TASK_NOT_READYSCHED_E_TASK_NOT_RUNNINGSCHED_E_SERVICE_NOT_INSTALLEDSCHED_E_CANNOT_OPEN_TASKSCHED_E_INVALID_TASKSCHED_E_ACCOUNT_INFORMATION_NOT_SETSCHED_E_ACCOUNT_NAME_NOT_FOUNDSCHED_E_ACCOUNT_DBASE_CORRUPTSCHED_E_NO_SECURITY_SERVICESSCHED_E_UNKNOWN_OBJECT_VERSIONSCHED_E_UNSUPPORTED_ACCOUNT_OPTIONSCHED_E_SERVICE_NOT_RUNNINGSCHED_E_UNEXPECTEDNODESCHED_E_NAMESPACESCHED_E_INVALIDVALUESCHED_E_MISSINGNODESCHED_E_MALFORMEDXMLSCHED_S_SOME_TRIGGERS_FAILEDSCHED_S_BATCH_LOGON_PROBLEMSCHED_E_TOO_MANY_NODESSCHED_E_PAST_END_BOUNDARYSCHED_E_ALREADY_RUNNINGSCHED_E_USER_NOT_LOGGED_ONSCHED_E_INVALID_TASK_HASHSCHED_E_SERVICE_NOT_AVAILABLESCHED_E_SERVICE_TOO_BUSYSCHED_E_TASK_ATTEMPTEDSCHED_S_TASK_QUEUEDSCHED_E_TASK_DISABLEDSCHED_E_TASK_NOT_V1_COMPATSCHED_E_START_ON_DEMANDSCHED_E_TASK_NOT_UBPM_COMPATSCHED_E_DEPRECATED_FEATURE_USEDCO_E_CLASS_CREATE_FAILEDCO_E_SCM_ERRORCO_E_SCM_RPC_FAILURECO_E_BAD_PATHCO_E_SERVER_EXEC_FAILURECO_E_OBJSRV_RPC_FAILUREMK_E_NO_NORMALIZEDCO_E_SERVER_STOPPINGMEM_E_INVALID_ROOTMEM_E_INVALID_LINKMEM_E_INVALID_SIZECO_S_NOTALLINTERFACESCO_S_MACHINENAMENOTFOUNDCO_E_MISSING_DISPLAYNAMECO_E_RUNAS_VALUE_MUST_BE_AAACO_E_ELEVATION_DISABLEDAPPX_E_PACKAGING_INTERNALAPPX_E_INTERLEAVING_NOT_ALLOWEDAPPX_E_RELATIONSHIPS_NOT_ALLOWEDAPPX_E_MISSING_REQUIRED_FILEAPPX_E_INVALID_MANIFESTAPPX_E_INVALID_BLOCKMAPAPPX_E_CORRUPT_CONTENTAPPX_E_BLOCK_HASH_INVALIDAPPX_E_REQUESTED_RANGE_TOO_LARGEAPPX_E_INVALID_SIP_CLIENT_DATABT_E_SPURIOUS_ACTIVATIONDISP_E_UNKNOWNINTERFACEDISP_E_MEMBERNOTFOUNDDISP_E_PARAMNOTFOUNDDISP_E_TYPEMISMATCHDISP_E_UNKNOWNNAMEDISP_E_NONAMEDARGSDISP_E_BADVARTYPEDISP_E_EXCEPTIONDISP_E_OVERFLOWDISP_E_BADINDEXDISP_E_UNKNOWNLCIDDISP_E_ARRAYISLOCKEDDISP_E_BADPARAMCOUNTDISP_E_PARAMNOTOPTIONALDISP_E_BADCALLEEDISP_E_NOTACOLLECTIONDISP_E_DIVBYZERODISP_E_BUFFERTOOSMALLTYPE_E_BUFFERTOOSMALLTYPE_E_FIELDNOTFOUNDTYPE_E_INVDATAREADTYPE_E_UNSUPFORMATTYPE_E_REGISTRYACCESSTYPE_E_LIBNOTREGISTEREDTYPE_E_UNDEFINEDTYPETYPE_E_QUALIFIEDNAMEDISALLOWEDTYPE_E_INVALIDSTATETYPE_E_WRONGTYPEKINDTYPE_E_ELEMENTNOTFOUNDTYPE_E_AMBIGUOUSNAMETYPE_E_NAMECONFLICTTYPE_E_UNKNOWNLCIDTYPE_E_DLLFUNCTIONNOTFOUNDTYPE_E_BADMODULEKINDTYPE_E_SIZETOOBIGTYPE_E_DUPLICATEIDTYPE_E_INVALIDIDTYPE_E_TYPEMISMATCHTYPE_E_OUTOFBOUNDSTYPE_E_IOERRORTYPE_E_CANTCREATETMPFILETYPE_E_CANTLOADLIBRARYTYPE_E_INCONSISTENTPROPFUNCSTYPE_E_CIRCULARTYPESTG_E_INVALIDFUNCTIONSTG_E_FILENOTFOUNDSTG_E_PATHNOTFOUNDSTG_E_TOOMANYOPENFILESSTG_E_ACCESSDENIEDSTG_E_INVALIDHANDLESTG_E_INSUFFICIENTMEMORYSTG_E_INVALIDPOINTERSTG_E_NOMOREFILESSTG_E_DISKISWRITEPROTECTEDSTG_E_SEEKERRORSTG_E_WRITEFAULTSTG_E_READFAULTSTG_E_SHAREVIOLATIONSTG_E_LOCKVIOLATIONSTG_E_FILEALREADYEXISTSSTG_E_INVALIDPARAMETERSTG_E_MEDIUMFULLSTG_E_PROPSETMISMATCHEDSTG_E_ABNORMALAPIEXITSTG_E_INVALIDHEADERSTG_E_INVALIDNAMESTG_E_UNKNOWNSTG_E_UNIMPLEMENTEDFUNCTIONSTG_E_INVALIDFLAGSTG_E_INUSESTG_E_NOTCURRENTSTG_E_REVERTEDSTG_E_CANTSAVESTG_E_OLDFORMATSTG_E_OLDDLLSTG_E_SHAREREQUIREDSTG_E_NOTFILEBASEDSTORAGESTG_E_EXTANTMARSHALLINGSSTG_E_DOCFILECORRUPTSTG_E_BADBASEADDRESSSTG_E_DOCFILETOOLARGESTG_E_NOTSIMPLEFORMATSTG_E_INCOMPLETESTG_E_TERMINATEDSTG_S_CONVERTEDSTG_S_BLOCKSTG_S_RETRYNOWSTG_S_MONITORINGSTG_S_MULTIPLEOPENSSTG_S_CONSOLIDATIONFAILEDSTG_S_CANNOTCONSOLIDATESTG_E_STATUS_COPY_PROTECTION_FAILURESTG_E_CSS_AUTHENTICATION_FAILURESTG_E_CSS_KEY_NOT_PRESENTSTG_E_CSS_KEY_NOT_ESTABLISHEDSTG_E_CSS_SCRAMBLED_SECTORSTG_E_CSS_REGION_MISMATCHSTG_E_RESETS_EXHAUSTEDRPC_E_CALL_REJECTEDRPC_E_CALL_CANCELEDRPC_E_CANTPOST_INSENDCALLRPC_E_CANTCALLOUT_INASYNCCALLRPC_E_CANTCALLOUT_INEXTERNALCALLRPC_E_CONNECTION_TERMINATEDRPC_E_SERVER_DIEDRPC_E_CLIENT_DIEDRPC_E_INVALID_DATAPACKETRPC_E_CANTTRANSMIT_CALLRPC_E_CLIENT_CANTMARSHAL_DATARPC_E_CLIENT_CANTUNMARSHAL_DATARPC_E_SERVER_CANTMARSHAL_DATARPC_E_SERVER_CANTUNMARSHAL_DATARPC_E_INVALID_DATARPC_E_INVALID_PARAMETERRPC_E_CANTCALLOUT_AGAINRPC_E_SERVER_DIED_DNERPC_E_SYS_CALL_FAILEDRPC_E_OUT_OF_RESOURCESRPC_E_ATTEMPTED_MULTITHREADRPC_E_NOT_REGISTEREDRPC_E_FAULTRPC_E_SERVERFAULTRPC_E_CHANGED_MODERPC_E_INVALIDMETHODRPC_E_DISCONNECTEDRPC_E_RETRYRPC_E_SERVERCALL_RETRYLATERRPC_E_SERVERCALL_REJECTEDRPC_E_INVALID_CALLDATARPC_E_CANTCALLOUT_ININPUTSYNCCALLRPC_E_WRONG_THREADRPC_E_THREAD_NOT_INITRPC_E_VERSION_MISMATCHRPC_E_INVALID_HEADERRPC_E_INVALID_EXTENSIONRPC_E_INVALID_IPIDRPC_E_INVALID_OBJECTRPC_S_CALLPENDINGRPC_S_WAITONTIMERRPC_E_CALL_COMPLETERPC_E_UNSECURE_CALLRPC_E_TOO_LATERPC_E_NO_GOOD_SECURITY_PACKAGESRPC_E_ACCESS_DENIEDRPC_E_REMOTE_DISABLEDRPC_E_INVALID_OBJREFRPC_E_NO_CONTEXTRPC_E_TIMEOUTRPC_E_NO_SYNCRPC_E_FULLSIC_REQUIREDRPC_E_INVALID_STD_NAMECO_E_FAILEDTOIMPERSONATECO_E_FAILEDTOGETSECCTXCO_E_FAILEDTOOPENTHREADTOKENCO_E_FAILEDTOGETTOKENINFOCO_E_TRUSTEEDOESNTMATCHCLIENTCO_E_FAILEDTOQUERYCLIENTBLANKETCO_E_FAILEDTOSETDACLCO_E_ACCESSCHECKFAILEDCO_E_NETACCESSAPIFAILEDCO_E_WRONGTRUSTEENAMESYNTAXCO_E_INVALIDSIDCO_E_CONVERSIONFAILEDCO_E_NOMATCHINGSIDFOUNDCO_E_LOOKUPACCSIDFAILEDCO_E_NOMATCHINGNAMEFOUNDCO_E_LOOKUPACCNAMEFAILEDCO_E_SETSERLHNDLFAILEDCO_E_FAILEDTOGETWINDIRCO_E_PATHTOOLONGCO_E_FAILEDTOGENUUIDCO_E_FAILEDTOCREATEFILECO_E_FAILEDTOCLOSEHANDLECO_E_EXCEEDSYSACLLIMITCO_E_ACESINWRONGORDERCO_E_INCOMPATIBLESTREAMVERSIONCO_E_FAILEDTOOPENPROCESSTOKENCO_E_DECODEFAILEDCO_E_ACNOTINITIALIZEDCO_E_CANCEL_DISABLEDRPC_E_UNEXPECTEDERROR_AUDITING_DISABLEDERROR_ALL_SIDS_FILTEREDERROR_BIZRULES_NOT_ENABLEDNTE_BAD_UIDNTE_BAD_HASHNTE_BAD_KEYNTE_BAD_LENNTE_BAD_DATANTE_BAD_SIGNATURENTE_BAD_VERNTE_BAD_ALGIDNTE_BAD_FLAGSNTE_BAD_TYPENTE_BAD_KEY_STATENTE_BAD_HASH_STATENTE_NO_KEYNTE_NO_MEMORYNTE_EXISTSNTE_PERMNTE_NOT_FOUNDNTE_DOUBLE_ENCRYPTNTE_BAD_PROVIDERNTE_BAD_PROV_TYPENTE_BAD_PUBLIC_KEYNTE_BAD_KEYSETNTE_PROV_TYPE_NOT_DEFNTE_PROV_TYPE_ENTRY_BADNTE_KEYSET_NOT_DEFNTE_KEYSET_ENTRY_BADNTE_PROV_TYPE_NO_MATCHNTE_SIGNATURE_FILE_BADNTE_PROVIDER_DLL_FAILNTE_PROV_DLL_NOT_FOUNDNTE_BAD_KEYSET_PARAMNTE_FAILNTE_SYS_ERRNTE_SILENT_CONTEXTNTE_TOKEN_KEYSET_STORAGE_FULLNTE_TEMPORARY_PROFILENTE_FIXEDPARAMETERNTE_INVALID_HANDLENTE_INVALID_PARAMETERNTE_BUFFER_TOO_SMALLNTE_NOT_SUPPORTEDNTE_NO_MORE_ITEMSNTE_BUFFERS_OVERLAPNTE_DECRYPTION_FAILURENTE_INTERNAL_ERRORNTE_UI_REQUIREDNTE_HMAC_NOT_SUPPORTEDNTE_DEVICE_NOT_READYNTE_AUTHENTICATION_IGNOREDNTE_VALIDATION_FAILEDNTE_INCORRECT_PASSWORDNTE_ENCRYPTION_FAILURENTE_DEVICE_NOT_FOUNDSEC_E_INSUFFICIENT_MEMORYSEC_E_INVALID_HANDLESEC_E_UNSUPPORTED_FUNCTIONSEC_E_TARGET_UNKNOWNSEC_E_INTERNAL_ERRORSEC_E_SECPKG_NOT_FOUNDSEC_E_NOT_OWNERSEC_E_CANNOT_INSTALLSEC_E_INVALID_TOKENSEC_E_CANNOT_PACKSEC_E_QOP_NOT_SUPPORTEDSEC_E_NO_IMPERSONATIONSEC_E_LOGON_DENIEDSEC_E_UNKNOWN_CREDENTIALSSEC_E_MESSAGE_ALTEREDSEC_E_OUT_OF_SEQUENCESEC_E_NO_AUTHENTICATING_AUTHORITYSEC_I_CONTINUE_NEEDEDSEC_I_COMPLETE_NEEDEDSEC_I_COMPLETE_AND_CONTINUESEC_I_LOCAL_LOGONSEC_E_BAD_PKGIDSEC_E_CONTEXT_EXPIREDSEC_I_CONTEXT_EXPIREDSEC_E_INCOMPLETE_MESSAGESEC_E_INCOMPLETE_CREDENTIALSSEC_E_BUFFER_TOO_SMALLSEC_I_INCOMPLETE_CREDENTIALSSEC_I_RENEGOTIATESEC_E_WRONG_PRINCIPALSEC_I_NO_LSA_CONTEXTSEC_E_TIME_SKEWSEC_E_UNTRUSTED_ROOTSEC_E_ILLEGAL_MESSAGESEC_E_CERT_UNKNOWNSEC_E_CERT_EXPIREDSEC_E_ENCRYPT_FAILURESEC_E_DECRYPT_FAILURESEC_E_ALGORITHM_MISMATCHSEC_E_SECURITY_QOS_FAILEDSEC_E_UNFINISHED_CONTEXT_DELETEDSEC_E_NO_TGT_REPLYSEC_E_NO_IP_ADDRESSESSEC_E_WRONG_CREDENTIAL_HANDLESEC_E_CRYPTO_SYSTEM_INVALIDSEC_E_MAX_REFERRALS_EXCEEDEDSEC_E_MUST_BE_KDCSEC_E_STRONG_CRYPTO_NOT_SUPPORTEDSEC_E_TOO_MANY_PRINCIPALSSEC_E_NO_PA_DATASEC_E_PKINIT_NAME_MISMATCHSEC_E_SMARTCARD_LOGON_REQUIREDSEC_E_SHUTDOWN_IN_PROGRESSSEC_E_KDC_INVALID_REQUESTSEC_E_KDC_UNABLE_TO_REFERSEC_E_KDC_UNKNOWN_ETYPESEC_E_UNSUPPORTED_PREAUTHSEC_E_DELEGATION_REQUIREDSEC_E_BAD_BINDINGSSEC_E_MULTIPLE_ACCOUNTSSEC_E_NO_KERB_KEYSEC_E_CERT_WRONG_USAGESEC_E_DOWNGRADE_DETECTEDSEC_E_SMARTCARD_CERT_REVOKEDSEC_E_ISSUING_CA_UNTRUSTEDSEC_E_REVOCATION_OFFLINE_CSEC_E_PKINIT_CLIENT_FAILURESEC_E_SMARTCARD_CERT_EXPIREDSEC_E_NO_S4U_PROT_SUPPORTSEC_E_CROSSREALM_DELEGATION_FAILURESEC_E_REVOCATION_OFFLINE_KDCSEC_E_ISSUING_CA_UNTRUSTED_KDCSEC_E_KDC_CERT_EXPIREDSEC_E_KDC_CERT_REVOKEDSEC_I_SIGNATURE_NEEDEDSEC_E_INVALID_PARAMETERSEC_E_DELEGATION_POLICYSEC_E_POLICY_NLTM_ONLYSEC_I_NO_RENEGOTIATIONSEC_E_NO_CONTEXTSEC_E_PKU2U_CERT_FAILURESEC_E_MUTUAL_AUTH_FAILEDSEC_I_MESSAGE_FRAGMENTSEC_E_ONLY_HTTPS_ALLOWEDSEC_I_CONTINUE_NEEDED_MESSAGE_OKSEC_E_APPLICATION_PROTOCOL_MISMATCHSEC_E_NO_SPMSEC_E_NOT_SUPPORTEDCRYPT_E_MSG_ERRORCRYPT_E_UNKNOWN_ALGOCRYPT_E_OID_FORMATCRYPT_E_INVALID_MSG_TYPECRYPT_E_UNEXPECTED_ENCODINGCRYPT_E_AUTH_ATTR_MISSINGCRYPT_E_HASH_VALUECRYPT_E_INVALID_INDEXCRYPT_E_ALREADY_DECRYPTEDCRYPT_E_NOT_DECRYPTEDCRYPT_E_RECIPIENT_NOT_FOUNDCRYPT_E_CONTROL_TYPECRYPT_E_ISSUER_SERIALNUMBERCRYPT_E_SIGNER_NOT_FOUNDCRYPT_E_ATTRIBUTES_MISSINGCRYPT_E_STREAM_MSG_NOT_READYCRYPT_E_STREAM_INSUFFICIENT_DATACRYPT_I_NEW_PROTECTION_REQUIREDCRYPT_E_BAD_LENCRYPT_E_BAD_ENCODECRYPT_E_FILE_ERRORCRYPT_E_NOT_FOUNDCRYPT_E_EXISTSCRYPT_E_NO_PROVIDERCRYPT_E_SELF_SIGNEDCRYPT_E_DELETED_PREVCRYPT_E_NO_MATCHCRYPT_E_UNEXPECTED_MSG_TYPECRYPT_E_NO_KEY_PROPERTYCRYPT_E_NO_DECRYPT_CERTCRYPT_E_BAD_MSGCRYPT_E_NO_SIGNERCRYPT_E_PENDING_CLOSECRYPT_E_NO_REVOCATION_DLLCRYPT_E_NO_REVOCATION_CHECKCRYPT_E_REVOCATION_OFFLINECRYPT_E_NOT_IN_REVOCATION_DATABASECRYPT_E_INVALID_NUMERIC_STRINGCRYPT_E_INVALID_PRINTABLE_STRINGCRYPT_E_INVALID_IA5_STRINGCRYPT_E_INVALID_X500_STRINGCRYPT_E_NOT_CHAR_STRINGCRYPT_E_FILERESIZEDCRYPT_E_SECURITY_SETTINGSCRYPT_E_NO_VERIFY_USAGE_DLLCRYPT_E_NO_VERIFY_USAGE_CHECKCRYPT_E_VERIFY_USAGE_OFFLINECRYPT_E_NOT_IN_CTLCRYPT_E_NO_TRUSTED_SIGNERCRYPT_E_MISSING_PUBKEY_PARACRYPT_E_OBJECT_LOCATOR_OBJECT_NOT_FOUNDCRYPT_E_OSS_ERROROSS_MORE_BUFOSS_NEGATIVE_UINTEGEROSS_PDU_RANGEOSS_MORE_INPUTOSS_DATA_ERROROSS_BAD_ARGOSS_BAD_VERSIONOSS_OUT_MEMORYOSS_PDU_MISMATCHOSS_LIMITEDOSS_BAD_PTROSS_BAD_TIMEOSS_INDEFINITE_NOT_SUPPORTEDOSS_MEM_ERROROSS_BAD_TABLEOSS_TOO_LONGOSS_CONSTRAINT_VIOLATEDOSS_FATAL_ERROROSS_ACCESS_SERIALIZATION_ERROROSS_NULL_TBLOSS_NULL_FCNOSS_BAD_ENCRULESOSS_UNAVAIL_ENCRULESOSS_CANT_OPEN_TRACE_WINDOWOSS_UNIMPLEMENTEDOSS_OID_DLL_NOT_LINKEDOSS_CANT_OPEN_TRACE_FILEOSS_TRACE_FILE_ALREADY_OPENOSS_TABLE_MISMATCHOSS_TYPE_NOT_SUPPORTEDOSS_REAL_DLL_NOT_LINKEDOSS_REAL_CODE_NOT_LINKEDOSS_OUT_OF_RANGEOSS_COPIER_DLL_NOT_LINKEDOSS_CONSTRAINT_DLL_NOT_LINKEDOSS_COMPARATOR_DLL_NOT_LINKEDOSS_COMPARATOR_CODE_NOT_LINKEDOSS_MEM_MGR_DLL_NOT_LINKEDOSS_PDV_DLL_NOT_LINKEDOSS_PDV_CODE_NOT_LINKEDOSS_API_DLL_NOT_LINKEDOSS_BERDER_DLL_NOT_LINKEDOSS_PER_DLL_NOT_LINKEDOSS_OPEN_TYPE_ERROROSS_MUTEX_NOT_CREATEDOSS_CANT_CLOSE_TRACE_FILECRYPT_E_ASN1_ERRORCRYPT_E_ASN1_INTERNALCRYPT_E_ASN1_EODCRYPT_E_ASN1_CORRUPTCRYPT_E_ASN1_LARGECRYPT_E_ASN1_CONSTRAINTCRYPT_E_ASN1_MEMORYCRYPT_E_ASN1_OVERFLOWCRYPT_E_ASN1_BADPDUCRYPT_E_ASN1_BADARGSCRYPT_E_ASN1_BADREALCRYPT_E_ASN1_BADTAGCRYPT_E_ASN1_CHOICECRYPT_E_ASN1_RULECRYPT_E_ASN1_UTF8CRYPT_E_ASN1_PDU_TYPECRYPT_E_ASN1_NYICRYPT_E_ASN1_EXTENDEDCRYPT_E_ASN1_NOEODCERTSRV_E_BAD_REQUESTSUBJECTCERTSRV_E_NO_REQUESTCERTSRV_E_BAD_REQUESTSTATUSCERTSRV_E_PROPERTY_EMPTYCERTSRV_E_INVALID_CA_CERTIFICATECERTSRV_E_SERVER_SUSPENDEDCERTSRV_E_ENCODING_LENGTHCERTSRV_E_ROLECONFLICTCERTSRV_E_RESTRICTEDOFFICERCERTSRV_E_KEY_ARCHIVAL_NOT_CONFIGUREDCERTSRV_E_NO_VALID_KRACERTSRV_E_BAD_REQUEST_KEY_ARCHIVALCERTSRV_E_NO_CAADMIN_DEFINEDCERTSRV_E_BAD_RENEWAL_CERT_ATTRIBUTECERTSRV_E_NO_DB_SESSIONSCERTSRV_E_ALIGNMENT_FAULTCERTSRV_E_ENROLL_DENIEDCERTSRV_E_TEMPLATE_DENIEDCERTSRV_E_DOWNLEVEL_DC_SSL_OR_UPGRADECERTSRV_E_ADMIN_DENIED_REQUESTCERTSRV_E_NO_POLICY_SERVERCERTSRV_E_WEAK_SIGNATURE_OR_KEYCERTSRV_E_KEY_ATTESTATION_NOT_SUPPORTEDCERTSRV_E_ENCRYPTION_CERT_REQUIREDCERTSRV_E_UNSUPPORTED_CERT_TYPECERTSRV_E_NO_CERT_TYPECERTSRV_E_TEMPLATE_CONFLICTCERTSRV_E_SUBJECT_ALT_NAME_REQUIREDCERTSRV_E_ARCHIVED_KEY_REQUIREDCERTSRV_E_SMIME_REQUIREDCERTSRV_E_BAD_RENEWAL_SUBJECTCERTSRV_E_BAD_TEMPLATE_VERSIONCERTSRV_E_TEMPLATE_POLICY_REQUIREDCERTSRV_E_SIGNATURE_POLICY_REQUIREDCERTSRV_E_SIGNATURE_COUNTCERTSRV_E_SIGNATURE_REJECTEDCERTSRV_E_ISSUANCE_POLICY_REQUIREDCERTSRV_E_SUBJECT_UPN_REQUIREDCERTSRV_E_SUBJECT_DIRECTORY_GUID_REQUIREDCERTSRV_E_SUBJECT_DNS_REQUIREDCERTSRV_E_ARCHIVED_KEY_UNEXPECTEDCERTSRV_E_KEY_LENGTHCERTSRV_E_SUBJECT_EMAIL_REQUIREDCERTSRV_E_UNKNOWN_CERT_TYPECERTSRV_E_CERT_TYPE_OVERLAPCERTSRV_E_TOO_MANY_SIGNATURESCERTSRV_E_RENEWAL_BAD_PUBLIC_KEYCERTSRV_E_INVALID_EKCERTSRV_E_INVALID_IDBINDINGCERTSRV_E_INVALID_ATTESTATIONCERTSRV_E_KEY_ATTESTATIONCERTSRV_E_CORRUPT_KEY_ATTESTATIONCERTSRV_E_EXPIRED_CHALLENGECERTSRV_E_INVALID_RESPONSECERTSRV_E_INVALID_REQUESTIDXENROLL_E_KEY_NOT_EXPORTABLEXENROLL_E_CANNOT_ADD_ROOT_CERTXENROLL_E_RESPONSE_KA_HASH_NOT_FOUNDXENROLL_E_RESPONSE_UNEXPECTED_KA_HASHXENROLL_E_RESPONSE_KA_HASH_MISMATCHXENROLL_E_KEYSPEC_SMIME_MISMATCHTRUST_E_SYSTEM_ERRORTRUST_E_NO_SIGNER_CERTTRUST_E_COUNTER_SIGNERTRUST_E_CERT_SIGNATURETRUST_E_TIME_STAMPTRUST_E_BAD_DIGESTTRUST_E_BASIC_CONSTRAINTSTRUST_E_FINANCIAL_CRITERIAMSSIPOTF_E_OUTOFMEMRANGEMSSIPOTF_E_CANTGETOBJECTMSSIPOTF_E_NOHEADTABLEMSSIPOTF_E_BAD_MAGICNUMBERMSSIPOTF_E_BAD_OFFSET_TABLEMSSIPOTF_E_TABLE_TAGORDERMSSIPOTF_E_TABLE_LONGWORDMSSIPOTF_E_BAD_FIRST_TABLE_PLACEMENTMSSIPOTF_E_TABLES_OVERLAPMSSIPOTF_E_TABLE_PADBYTESMSSIPOTF_E_FILETOOSMALLMSSIPOTF_E_TABLE_CHECKSUMMSSIPOTF_E_FILE_CHECKSUMMSSIPOTF_E_FAILED_POLICYMSSIPOTF_E_FAILED_HINTS_CHECKMSSIPOTF_E_NOT_OPENTYPEMSSIPOTF_E_FILEMSSIPOTF_E_CRYPTMSSIPOTF_E_BADVERSIONMSSIPOTF_E_DSIG_STRUCTUREMSSIPOTF_E_PCONST_CHECKMSSIPOTF_E_STRUCTUREERROR_CRED_REQUIRES_CONFIRMATIONNTE_OP_OKTRUST_E_PROVIDER_UNKNOWNTRUST_E_ACTION_UNKNOWNTRUST_E_SUBJECT_FORM_UNKNOWNTRUST_E_SUBJECT_NOT_TRUSTEDDIGSIG_E_ENCODEDIGSIG_E_DECODEDIGSIG_E_EXTENSIBILITYDIGSIG_E_CRYPTOPERSIST_E_SIZEDEFINITEPERSIST_E_SIZEINDEFINITEPERSIST_E_NOTSELFSIZINGTRUST_E_NOSIGNATURECERT_E_VALIDITYPERIODNESTINGCERT_E_ROLECERT_E_PATHLENCONSTCERT_E_CRITICALCERT_E_PURPOSECERT_E_ISSUERCHAININGCERT_E_MALFORMEDCERT_E_CHAININGTRUST_E_FAILCERT_E_REVOKEDCERT_E_UNTRUSTEDTESTROOTCERT_E_REVOCATION_FAILURETRUST_E_EXPLICIT_DISTRUSTCERT_E_UNTRUSTEDCACERT_E_INVALID_POLICYSPAPI_E_EXPECTED_SECTION_NAMESPAPI_E_BAD_SECTION_NAME_LINESPAPI_E_SECTION_NAME_TOO_LONGSPAPI_E_GENERAL_SYNTAXSPAPI_E_WRONG_INF_STYLESPAPI_E_SECTION_NOT_FOUNDSPAPI_E_LINE_NOT_FOUNDSPAPI_E_NO_BACKUPSPAPI_E_NO_ASSOCIATED_CLASSSPAPI_E_CLASS_MISMATCHSPAPI_E_DUPLICATE_FOUNDSPAPI_E_NO_DRIVER_SELECTEDSPAPI_E_KEY_DOES_NOT_EXISTSPAPI_E_INVALID_DEVINST_NAMESPAPI_E_INVALID_CLASSSPAPI_E_DEVINST_ALREADY_EXISTSSPAPI_E_DEVINFO_NOT_REGISTEREDSPAPI_E_INVALID_REG_PROPERTYSPAPI_E_NO_INFSPAPI_E_NO_SUCH_DEVINSTSPAPI_E_CANT_LOAD_CLASS_ICONSPAPI_E_INVALID_CLASS_INSTALLERSPAPI_E_DI_DO_DEFAULTSPAPI_E_DI_NOFILECOPYSPAPI_E_INVALID_HWPROFILESPAPI_E_NO_DEVICE_SELECTEDSPAPI_E_DEVINFO_LIST_LOCKEDSPAPI_E_DEVINFO_DATA_LOCKEDSPAPI_E_DI_BAD_PATHSPAPI_E_NO_CLASSINSTALL_PARAMSSPAPI_E_FILEQUEUE_LOCKEDSPAPI_E_BAD_SERVICE_INSTALLSECTSPAPI_E_NO_CLASS_DRIVER_LISTSPAPI_E_NO_ASSOCIATED_SERVICESPAPI_E_NO_DEFAULT_DEVICE_INTERFACESPAPI_E_DEVICE_INTERFACE_ACTIVESPAPI_E_DEVICE_INTERFACE_REMOVEDSPAPI_E_BAD_INTERFACE_INSTALLSECTSPAPI_E_NO_SUCH_INTERFACE_CLASSSPAPI_E_INVALID_REFERENCE_STRINGSPAPI_E_INVALID_MACHINENAMESPAPI_E_REMOTE_COMM_FAILURESPAPI_E_MACHINE_UNAVAILABLESPAPI_E_NO_CONFIGMGR_SERVICESSPAPI_E_INVALID_PROPPAGE_PROVIDERSPAPI_E_NO_SUCH_DEVICE_INTERFACESPAPI_E_DI_POSTPROCESSING_REQUIREDSPAPI_E_INVALID_COINSTALLERSPAPI_E_NO_COMPAT_DRIVERSSPAPI_E_NO_DEVICE_ICONSPAPI_E_INVALID_INF_LOGCONFIGSPAPI_E_DI_DONT_INSTALLSPAPI_E_INVALID_FILTER_DRIVERSPAPI_E_NON_WINDOWS_NT_DRIVERSPAPI_E_NON_WINDOWS_DRIVERSPAPI_E_NO_CATALOG_FOR_OEM_INFSPAPI_E_DEVINSTALL_QUEUE_NONNATIVESPAPI_E_NOT_DISABLEABLESPAPI_E_CANT_REMOVE_DEVINSTSPAPI_E_INVALID_TARGETSPAPI_E_DRIVER_NONNATIVESPAPI_E_IN_WOW64SPAPI_E_SET_SYSTEM_RESTORE_POINTSPAPI_E_INCORRECTLY_COPIED_INFSPAPI_E_SCE_DISABLEDSPAPI_E_UNKNOWN_EXCEPTIONSPAPI_E_PNP_REGISTRY_ERRORSPAPI_E_REMOTE_REQUEST_UNSUPPORTEDSPAPI_E_NOT_AN_INSTALLED_OEM_INFSPAPI_E_INF_IN_USE_BY_DEVICESSPAPI_E_DI_FUNCTION_OBSOLETESPAPI_E_NO_AUTHENTICODE_CATALOGSPAPI_E_AUTHENTICODE_DISALLOWEDSPAPI_E_AUTHENTICODE_TRUSTED_PUBLISHERSPAPI_E_AUTHENTICODE_TRUST_NOT_ESTABLISHEDSPAPI_E_AUTHENTICODE_PUBLISHER_NOT_TRUSTEDSPAPI_E_SIGNATURE_OSATTRIBUTE_MISMATCHSPAPI_E_ONLY_VALIDATE_VIA_AUTHENTICODESPAPI_E_DEVICE_INSTALLER_NOT_READYSPAPI_E_DRIVER_STORE_ADD_FAILEDSPAPI_E_DEVICE_INSTALL_BLOCKEDSPAPI_E_DRIVER_INSTALL_BLOCKEDSPAPI_E_WRONG_INF_TYPESPAPI_E_FILE_HASH_NOT_IN_CATALOGSPAPI_E_DRIVER_STORE_DELETE_FAILEDSPAPI_E_UNRECOVERABLE_STACK_OVERFLOWSPAPI_E_ERROR_NOT_INSTALLEDSCARD_S_SUCCESSSCARD_F_INTERNAL_ERRORSCARD_E_CANCELLEDSCARD_E_INVALID_HANDLESCARD_E_INVALID_PARAMETERSCARD_E_INVALID_TARGETSCARD_E_NO_MEMORYSCARD_F_WAITED_TOO_LONGSCARD_E_INSUFFICIENT_BUFFERSCARD_E_UNKNOWN_READERSCARD_E_TIMEOUTSCARD_E_SHARING_VIOLATIONSCARD_E_NO_SMARTCARDSCARD_E_UNKNOWN_CARDSCARD_E_CANT_DISPOSESCARD_E_PROTO_MISMATCHSCARD_E_NOT_READYSCARD_E_INVALID_VALUESCARD_E_SYSTEM_CANCELLEDSCARD_F_COMM_ERRORSCARD_F_UNKNOWN_ERRORSCARD_E_INVALID_ATRSCARD_E_NOT_TRANSACTEDSCARD_E_READER_UNAVAILABLESCARD_P_SHUTDOWNSCARD_E_PCI_TOO_SMALLSCARD_E_READER_UNSUPPORTEDSCARD_E_DUPLICATE_READERSCARD_E_CARD_UNSUPPORTEDSCARD_E_NO_SERVICESCARD_E_SERVICE_STOPPEDSCARD_E_UNEXPECTEDSCARD_E_ICC_INSTALLATIONSCARD_E_ICC_CREATEORDERSCARD_E_UNSUPPORTED_FEATURESCARD_E_DIR_NOT_FOUNDSCARD_E_FILE_NOT_FOUNDSCARD_E_NO_DIRSCARD_E_NO_FILESCARD_E_NO_ACCESSSCARD_E_WRITE_TOO_MANYSCARD_E_BAD_SEEKSCARD_E_INVALID_CHVSCARD_E_UNKNOWN_RES_MNGSCARD_E_NO_SUCH_CERTIFICATESCARD_E_CERTIFICATE_UNAVAILABLESCARD_E_NO_READERS_AVAILABLESCARD_E_COMM_DATA_LOSTSCARD_E_NO_KEY_CONTAINERSCARD_E_SERVER_TOO_BUSYSCARD_E_PIN_CACHE_EXPIREDSCARD_E_NO_PIN_CACHESCARD_E_READ_ONLY_CARDSCARD_W_UNSUPPORTED_CARDSCARD_W_UNRESPONSIVE_CARDSCARD_W_UNPOWERED_CARDSCARD_W_RESET_CARDSCARD_W_REMOVED_CARDSCARD_W_SECURITY_VIOLATIONSCARD_W_WRONG_CHVSCARD_W_CHV_BLOCKEDSCARD_W_EOFSCARD_W_CANCELLED_BY_USERSCARD_W_CARD_NOT_AUTHENTICATEDSCARD_W_CACHE_ITEM_NOT_FOUNDSCARD_W_CACHE_ITEM_STALESCARD_W_CACHE_ITEM_TOO_BIGCOMADMIN_E_OBJECTERRORSCOMADMIN_E_OBJECTINVALIDCOMADMIN_E_KEYMISSINGCOMADMIN_E_ALREADYINSTALLEDCOMADMIN_E_APP_FILE_WRITEFAILCOMADMIN_E_APP_FILE_READFAILCOMADMIN_E_APP_FILE_VERSIONCOMADMIN_E_BADPATHCOMADMIN_E_APPLICATIONEXISTSCOMADMIN_E_ROLEEXISTSCOMADMIN_E_CANTCOPYFILECOMADMIN_E_NOUSERCOMADMIN_E_INVALIDUSERIDSCOMADMIN_E_NOREGISTRYCLSIDCOMADMIN_E_BADREGISTRYPROGIDCOMADMIN_E_AUTHENTICATIONLEVELCOMADMIN_E_USERPASSWDNOTVALIDCOMADMIN_E_CLSIDORIIDMISMATCHCOMADMIN_E_REMOTEINTERFACECOMADMIN_E_DLLREGISTERSERVERCOMADMIN_E_NOSERVERSHARECOMADMIN_E_DLLLOADFAILEDCOMADMIN_E_BADREGISTRYLIBIDCOMADMIN_E_APPDIRNOTFOUNDCOMADMIN_E_REGISTRARFAILEDCOMADMIN_E_COMPFILE_DOESNOTEXISTCOMADMIN_E_COMPFILE_LOADDLLFAILCOMADMIN_E_COMPFILE_GETCLASSOBJCOMADMIN_E_COMPFILE_CLASSNOTAVAILCOMADMIN_E_COMPFILE_BADTLBCOMADMIN_E_COMPFILE_NOTINSTALLABLECOMADMIN_E_NOTCHANGEABLECOMADMIN_E_NOTDELETEABLECOMADMIN_E_SESSIONCOMADMIN_E_COMP_MOVE_LOCKEDCOMADMIN_E_COMP_MOVE_BAD_DESTCOMADMIN_E_REGISTERTLBCOMADMIN_E_SYSTEMAPPCOMADMIN_E_COMPFILE_NOREGISTRARCOMADMIN_E_COREQCOMPINSTALLEDCOMADMIN_E_SERVICENOTINSTALLEDCOMADMIN_E_PROPERTYSAVEFAILEDCOMADMIN_E_OBJECTEXISTSCOMADMIN_E_COMPONENTEXISTSCOMADMIN_E_REGFILE_CORRUPTCOMADMIN_E_PROPERTY_OVERFLOWCOMADMIN_E_NOTINREGISTRYCOMADMIN_E_OBJECTNOTPOOLABLECOMADMIN_E_APPLID_MATCHES_CLSIDCOMADMIN_E_ROLE_DOES_NOT_EXISTCOMADMIN_E_START_APP_NEEDS_COMPONENTSCOMADMIN_E_REQUIRES_DIFFERENT_PLATFORMCOMADMIN_E_CAN_NOT_EXPORT_APP_PROXYCOMADMIN_E_CAN_NOT_START_APPCOMADMIN_E_CAN_NOT_EXPORT_SYS_APPCOMADMIN_E_CANT_SUBSCRIBE_TO_COMPONENTCOMADMIN_E_EVENTCLASS_CANT_BE_SUBSCRIBERCOMADMIN_E_LIB_APP_PROXY_INCOMPATIBLECOMADMIN_E_BASE_PARTITION_ONLYCOMADMIN_E_START_APP_DISABLEDCOMADMIN_E_CAT_DUPLICATE_PARTITION_NAMECOMADMIN_E_CAT_INVALID_PARTITION_NAMECOMADMIN_E_CAT_PARTITION_IN_USECOMADMIN_E_FILE_PARTITION_DUPLICATE_FILESCOMADMIN_E_CAT_IMPORTED_COMPONENTS_NOT_ALLOWEDCOMADMIN_E_AMBIGUOUS_APPLICATION_NAMECOMADMIN_E_AMBIGUOUS_PARTITION_NAMECOMADMIN_E_REGDB_NOTINITIALIZEDCOMADMIN_E_REGDB_NOTOPENCOMADMIN_E_REGDB_SYSTEMERRCOMADMIN_E_REGDB_ALREADYRUNNINGCOMADMIN_E_MIG_VERSIONNOTSUPPORTEDCOMADMIN_E_MIG_SCHEMANOTFOUNDCOMADMIN_E_CAT_BITNESSMISMATCHCOMADMIN_E_CAT_UNACCEPTABLEBITNESSCOMADMIN_E_CAT_WRONGAPPBITNESSCOMADMIN_E_CAT_PAUSE_RESUME_NOT_SUPPORTEDCOMADMIN_E_CAT_SERVERFAULTCOMQC_E_APPLICATION_NOT_QUEUEDCOMQC_E_NO_QUEUEABLE_INTERFACESCOMQC_E_QUEUING_SERVICE_NOT_AVAILABLECOMQC_E_NO_IPERSISTSTREAMCOMQC_E_BAD_MESSAGECOMQC_E_UNAUTHENTICATEDCOMQC_E_UNTRUSTED_ENQUEUERMSDTC_E_DUPLICATE_RESOURCECOMADMIN_E_OBJECT_PARENT_MISSINGCOMADMIN_E_OBJECT_DOES_NOT_EXISTCOMADMIN_E_APP_NOT_RUNNINGCOMADMIN_E_INVALID_PARTITIONCOMADMIN_E_SVCAPP_NOT_POOLABLE_OR_RECYCLABLECOMADMIN_E_USER_IN_SETCOMADMIN_E_CANTRECYCLELIBRARYAPPSCOMADMIN_E_CANTRECYCLESERVICEAPPSCOMADMIN_E_PROCESSALREADYRECYCLEDCOMADMIN_E_PAUSEDPROCESSMAYNOTBERECYCLEDCOMADMIN_E_CANTMAKEINPROCSERVICECOMADMIN_E_PROGIDINUSEBYCLSIDCOMADMIN_E_DEFAULT_PARTITION_NOT_IN_SETCOMADMIN_E_RECYCLEDPROCESSMAYNOTBEPAUSEDCOMADMIN_E_PARTITION_ACCESSDENIEDCOMADMIN_E_PARTITION_MSI_ONLYCOMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_1_0_FORMATCOMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_NONBASE_PARTITIONSCOMADMIN_E_COMP_MOVE_SOURCECOMADMIN_E_COMP_MOVE_DESTCOMADMIN_E_COMP_MOVE_PRIVATECOMADMIN_E_BASEPARTITION_REQUIRED_IN_SETCOMADMIN_E_CANNOT_ALIAS_EVENTCLASSCOMADMIN_E_PRIVATE_ACCESSDENIEDCOMADMIN_E_SAFERINVALIDCOMADMIN_E_REGISTRY_ACCESSDENIEDCOMADMIN_E_PARTITIONS_DISABLEDWER_S_REPORT_DEBUGWER_S_REPORT_UPLOADEDWER_S_REPORT_QUEUEDWER_S_DISABLEDWER_S_SUSPENDED_UPLOADWER_S_DISABLED_QUEUEWER_S_DISABLED_ARCHIVEWER_S_REPORT_ASYNCWER_S_IGNORE_ASSERT_INSTANCEWER_S_IGNORE_ALL_ASSERTSWER_S_ASSERT_CONTINUEWER_S_THROTTLEDWER_E_CRASH_FAILUREWER_E_CANCELEDWER_E_NETWORK_FAILUREWER_E_NOT_INITIALIZEDWER_E_ALREADY_REPORTINGWER_E_DUMP_THROTTLEDERROR_FLT_IO_COMPLETEERROR_FLT_NO_HANDLER_DEFINEDERROR_FLT_CONTEXT_ALREADY_DEFINEDERROR_FLT_INVALID_ASYNCHRONOUS_REQUESTERROR_FLT_DISALLOW_FAST_IOERROR_FLT_INVALID_NAME_REQUESTERROR_FLT_NOT_SAFE_TO_POST_OPERATIONERROR_FLT_NOT_INITIALIZEDERROR_FLT_FILTER_NOT_READYERROR_FLT_POST_OPERATION_CLEANUPERROR_FLT_INTERNAL_ERRORERROR_FLT_DELETING_OBJECTERROR_FLT_MUST_BE_NONPAGED_POOLERROR_FLT_DUPLICATE_ENTRYERROR_FLT_CBDQ_DISABLEDERROR_FLT_DO_NOT_ATTACHERROR_FLT_DO_NOT_DETACHERROR_FLT_INSTANCE_ALTITUDE_COLLISIONERROR_FLT_INSTANCE_NAME_COLLISIONERROR_FLT_FILTER_NOT_FOUNDERROR_FLT_VOLUME_NOT_FOUNDERROR_FLT_INSTANCE_NOT_FOUNDERROR_FLT_CONTEXT_ALLOCATION_NOT_FOUNDERROR_FLT_INVALID_CONTEXT_REGISTRATIONERROR_FLT_NAME_CACHE_MISSERROR_FLT_NO_DEVICE_OBJECTERROR_FLT_VOLUME_ALREADY_MOUNTEDERROR_FLT_ALREADY_ENLISTEDERROR_FLT_CONTEXT_ALREADY_LINKEDERROR_FLT_NO_WAITER_FOR_REPLYERROR_FLT_REGISTRATION_BUSYERROR_HUNG_DISPLAY_DRIVER_THREADDWM_E_COMPOSITIONDISABLEDDWM_E_REMOTING_NOT_SUPPORTEDDWM_E_NO_REDIRECTION_SURFACE_AVAILABLEDWM_E_NOT_QUEUING_PRESENTSDWM_E_ADAPTER_NOT_FOUNDDWM_S_GDI_REDIRECTION_SURFACEDWM_E_TEXTURE_TOO_LARGEERROR_MONITOR_NO_DESCRIPTORERROR_MONITOR_UNKNOWN_DESCRIPTOR_FORMATERROR_MONITOR_INVALID_DESCRIPTOR_CHECKSUMERROR_MONITOR_INVALID_STANDARD_TIMING_BLOCKERROR_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILEDERROR_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCKERROR_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCKERROR_MONITOR_NO_MORE_DESCRIPTOR_DATAERROR_MONITOR_INVALID_DETAILED_TIMING_BLOCKERROR_MONITOR_INVALID_MANUFACTURE_DATEERROR_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNERERROR_GRAPHICS_INSUFFICIENT_DMA_BUFFERERROR_GRAPHICS_INVALID_DISPLAY_ADAPTERERROR_GRAPHICS_ADAPTER_WAS_RESETERROR_GRAPHICS_INVALID_DRIVER_MODELERROR_GRAPHICS_PRESENT_MODE_CHANGEDERROR_GRAPHICS_PRESENT_OCCLUDEDERROR_GRAPHICS_PRESENT_DENIEDERROR_GRAPHICS_CANNOTCOLORCONVERTERROR_GRAPHICS_DRIVER_MISMATCHERROR_GRAPHICS_PARTIAL_DATA_POPULATEDERROR_GRAPHICS_PRESENT_REDIRECTION_DISABLEDERROR_GRAPHICS_PRESENT_UNOCCLUDEDERROR_GRAPHICS_WINDOWDC_NOT_AVAILABLEERROR_GRAPHICS_WINDOWLESS_PRESENT_DISABLEDERROR_GRAPHICS_NO_VIDEO_MEMORYERROR_GRAPHICS_CANT_LOCK_MEMORYERROR_GRAPHICS_ALLOCATION_BUSYERROR_GRAPHICS_TOO_MANY_REFERENCESERROR_GRAPHICS_TRY_AGAIN_LATERERROR_GRAPHICS_TRY_AGAIN_NOWERROR_GRAPHICS_ALLOCATION_INVALIDERROR_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLEERROR_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTEDERROR_GRAPHICS_CANT_EVICT_PINNED_ALLOCATIONERROR_GRAPHICS_INVALID_ALLOCATION_USAGEERROR_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATIONERROR_GRAPHICS_ALLOCATION_CLOSEDERROR_GRAPHICS_INVALID_ALLOCATION_INSTANCEERROR_GRAPHICS_INVALID_ALLOCATION_HANDLEERROR_GRAPHICS_WRONG_ALLOCATION_DEVICEERROR_GRAPHICS_ALLOCATION_CONTENT_LOSTERROR_GRAPHICS_GPU_EXCEPTION_ON_DEVICEERROR_GRAPHICS_SKIP_ALLOCATION_PREPARATIONERROR_GRAPHICS_INVALID_VIDPN_TOPOLOGYERROR_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTEDERROR_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTEDERROR_GRAPHICS_INVALID_VIDPNERROR_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCEERROR_GRAPHICS_INVALID_VIDEO_PRESENT_TARGETERROR_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTEDERROR_GRAPHICS_MODE_NOT_PINNEDERROR_GRAPHICS_INVALID_VIDPN_SOURCEMODESETERROR_GRAPHICS_INVALID_VIDPN_TARGETMODESETERROR_GRAPHICS_INVALID_FREQUENCYERROR_GRAPHICS_INVALID_ACTIVE_REGIONERROR_GRAPHICS_INVALID_TOTAL_REGIONERROR_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODEERROR_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODEERROR_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SETERROR_GRAPHICS_PATH_ALREADY_IN_TOPOLOGYERROR_GRAPHICS_MODE_ALREADY_IN_MODESETERROR_GRAPHICS_INVALID_VIDEOPRESENTSOURCESETERROR_GRAPHICS_INVALID_VIDEOPRESENTTARGETSETERROR_GRAPHICS_SOURCE_ALREADY_IN_SETERROR_GRAPHICS_TARGET_ALREADY_IN_SETERROR_GRAPHICS_INVALID_VIDPN_PRESENT_PATHERROR_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGYERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESETERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGEERROR_GRAPHICS_FREQUENCYRANGE_NOT_IN_SETERROR_GRAPHICS_NO_PREFERRED_MODEERROR_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SETERROR_GRAPHICS_STALE_MODESETERROR_GRAPHICS_INVALID_MONITOR_SOURCEMODESETERROR_GRAPHICS_INVALID_MONITOR_SOURCE_MODEERROR_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPNERROR_GRAPHICS_MODE_ID_MUST_BE_UNIQUEERROR_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTIONERROR_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCESERROR_GRAPHICS_PATH_NOT_IN_TOPOLOGYERROR_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCEERROR_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGETERROR_GRAPHICS_INVALID_MONITORDESCRIPTORSETERROR_GRAPHICS_INVALID_MONITORDESCRIPTORERROR_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SETERROR_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SETERROR_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUEERROR_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPEERROR_GRAPHICS_RESOURCES_NOT_RELATEDERROR_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUEERROR_GRAPHICS_TARGET_ID_MUST_BE_UNIQUEERROR_GRAPHICS_NO_AVAILABLE_VIDPN_TARGETERROR_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTERERROR_GRAPHICS_NO_VIDPNMGRERROR_GRAPHICS_NO_ACTIVE_VIDPNERROR_GRAPHICS_STALE_VIDPN_TOPOLOGYERROR_GRAPHICS_MONITOR_NOT_CONNECTEDERROR_GRAPHICS_SOURCE_NOT_IN_TOPOLOGYERROR_GRAPHICS_INVALID_PRIMARYSURFACE_SIZEERROR_GRAPHICS_INVALID_VISIBLEREGION_SIZEERROR_GRAPHICS_INVALID_STRIDEERROR_GRAPHICS_INVALID_PIXELFORMATERROR_GRAPHICS_INVALID_COLORBASISERROR_GRAPHICS_INVALID_PIXELVALUEACCESSMODEERROR_GRAPHICS_TARGET_NOT_IN_TOPOLOGYERROR_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORTERROR_GRAPHICS_VIDPN_SOURCE_IN_USEERROR_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPNERROR_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINALERROR_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATIONERROR_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTEDERROR_GRAPHICS_INVALID_GAMMA_RAMPERROR_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTEDERROR_GRAPHICS_MULTISAMPLING_NOT_SUPPORTEDERROR_GRAPHICS_MODE_NOT_IN_MODESETERROR_GRAPHICS_DATASET_IS_EMPTYERROR_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASETERROR_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASONERROR_GRAPHICS_INVALID_PATH_CONTENT_TYPEERROR_GRAPHICS_INVALID_COPYPROTECTION_TYPEERROR_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTSERROR_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNEDERROR_GRAPHICS_INVALID_SCANLINE_ORDERINGERROR_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWEDERROR_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALSERROR_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMATERROR_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHMERROR_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGINERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINTERROR_GRAPHICS_MAX_NUM_PATHS_REACHEDERROR_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATIONERROR_GRAPHICS_INVALID_CLIENT_TYPEERROR_GRAPHICS_CLIENTVIDPN_NOT_SETERROR_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTEDERROR_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTEDERROR_GRAPHICS_UNKNOWN_CHILD_STATUSERROR_GRAPHICS_NOT_A_LINKED_ADAPTERERROR_GRAPHICS_LEADLINK_NOT_ENUMERATEDERROR_GRAPHICS_CHAINLINKS_NOT_ENUMERATEDERROR_GRAPHICS_ADAPTER_CHAIN_NOT_READYERROR_GRAPHICS_CHAINLINKS_NOT_STARTEDERROR_GRAPHICS_CHAINLINKS_NOT_POWERED_ONERROR_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATEERROR_GRAPHICS_LEADLINK_START_DEFERREDERROR_GRAPHICS_NOT_POST_DEVICE_DRIVERERROR_GRAPHICS_POLLING_TOO_FREQUENTLYERROR_GRAPHICS_START_DEFERREDERROR_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDEDERROR_GRAPHICS_OPM_NOT_SUPPORTEDERROR_GRAPHICS_COPP_NOT_SUPPORTEDERROR_GRAPHICS_UAB_NOT_SUPPORTEDERROR_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERSERROR_GRAPHICS_OPM_NO_VIDEO_OUTPUTS_EXISTERROR_GRAPHICS_OPM_INTERNAL_ERRORERROR_GRAPHICS_OPM_INVALID_HANDLEERROR_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTHERROR_GRAPHICS_OPM_SPANNING_MODE_ENABLEDERROR_GRAPHICS_OPM_THEATER_MODE_ENABLEDERROR_GRAPHICS_PVP_HFS_FAILEDERROR_GRAPHICS_OPM_INVALID_SRMERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCPERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACPERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSAERROR_GRAPHICS_OPM_HDCP_SRM_NEVER_SETERROR_GRAPHICS_OPM_RESOLUTION_TOO_HIGHERROR_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USEERROR_GRAPHICS_OPM_VIDEO_OUTPUT_NO_LONGER_EXISTSERROR_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESSERROR_GRAPHICS_OPM_VIDEO_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICSERROR_GRAPHICS_OPM_INVALID_INFORMATION_REQUESTERROR_GRAPHICS_OPM_DRIVER_INTERNAL_ERRORERROR_GRAPHICS_OPM_VIDEO_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICSERROR_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTEDERROR_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUESTERROR_GRAPHICS_I2C_NOT_SUPPORTEDERROR_GRAPHICS_I2C_DEVICE_DOES_NOT_EXISTERROR_GRAPHICS_I2C_ERROR_TRANSMITTING_DATAERROR_GRAPHICS_I2C_ERROR_RECEIVING_DATAERROR_GRAPHICS_DDCCI_VCP_NOT_SUPPORTEDERROR_GRAPHICS_DDCCI_INVALID_DATAERROR_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTEERROR_GRAPHICS_MCA_INVALID_CAPABILITIES_STRINGERROR_GRAPHICS_MCA_INTERNAL_ERRORERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMANDERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTHERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUMERROR_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLEERROR_GRAPHICS_MONITOR_NO_LONGER_EXISTSERROR_GRAPHICS_DDCCI_CURRENT_CURRENT_VALUE_GREATER_THAN_MAXIMUM_VALUEERROR_GRAPHICS_MCA_INVALID_VCP_VERSIONERROR_GRAPHICS_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATIONERROR_GRAPHICS_MCA_MCCS_VERSION_MISMATCHERROR_GRAPHICS_MCA_UNSUPPORTED_MCCS_VERSIONERROR_GRAPHICS_MCA_INVALID_TECHNOLOGY_TYPE_RETURNEDERROR_GRAPHICS_MCA_UNSUPPORTED_COLOR_TEMPERATUREERROR_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTEDERROR_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAMEERROR_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOPERROR_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTEDERROR_GRAPHICS_INVALID_POINTERERROR_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICEERROR_GRAPHICS_PARAMETER_ARRAY_TOO_SMALLERROR_GRAPHICS_INTERNAL_ERRORERROR_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESSNAP_E_INVALID_PACKETNAP_E_MISSING_SOHNAP_E_CONFLICTING_IDNAP_E_NO_CACHED_SOHNAP_E_STILL_BOUNDNAP_E_NOT_REGISTEREDNAP_E_NOT_INITIALIZEDNAP_E_MISMATCHED_IDNAP_E_NOT_PENDINGNAP_E_ID_NOT_FOUNDNAP_E_MAXSIZE_TOO_SMALLNAP_E_SERVICE_NOT_RUNNINGNAP_S_CERT_ALREADY_PRESENTNAP_E_ENTITY_DISABLEDNAP_E_NETSH_GROUPPOLICY_ERRORNAP_E_TOO_MANY_CALLSNAP_E_SHV_CONFIG_EXISTEDNAP_E_SHV_CONFIG_NOT_FOUNDNAP_E_SHV_TIMEOUTTPM_E_ERROR_MASKTPM_E_AUTHFAILTPM_E_BADINDEXTPM_E_BAD_PARAMETERTPM_E_AUDITFAILURETPM_E_CLEAR_DISABLEDTPM_E_DEACTIVATEDTPM_E_DISABLEDTPM_E_DISABLED_CMDTPM_E_FAILTPM_E_BAD_ORDINALTPM_E_INSTALL_DISABLEDTPM_E_INVALID_KEYHANDLETPM_E_KEYNOTFOUNDTPM_E_INAPPROPRIATE_ENCTPM_E_MIGRATEFAILTPM_E_INVALID_PCR_INFOTPM_E_NOSPACETPM_E_NOSRKTPM_E_NOTSEALED_BLOBTPM_E_OWNER_SETTPM_E_RESOURCESTPM_E_SHORTRANDOMTPM_E_SIZETPM_E_WRONGPCRVALTPM_E_BAD_PARAM_SIZETPM_E_SHA_THREADTPM_E_SHA_ERRORTPM_E_FAILEDSELFTESTTPM_E_AUTH2FAILTPM_E_BADTAGTPM_E_IOERRORTPM_E_ENCRYPT_ERRORTPM_E_DECRYPT_ERRORTPM_E_INVALID_AUTHHANDLETPM_E_NO_ENDORSEMENTTPM_E_INVALID_KEYUSAGETPM_E_WRONG_ENTITYTYPETPM_E_INVALID_POSTINITTPM_E_INAPPROPRIATE_SIGTPM_E_BAD_KEY_PROPERTYTPM_E_BAD_MIGRATIONTPM_E_BAD_SCHEMETPM_E_BAD_DATASIZETPM_E_BAD_MODETPM_E_BAD_PRESENCETPM_E_BAD_VERSIONTPM_E_NO_WRAP_TRANSPORTTPM_E_AUDITFAIL_UNSUCCESSFULTPM_E_AUDITFAIL_SUCCESSFULTPM_E_NOTRESETABLETPM_E_NOTLOCALTPM_E_BAD_TYPETPM_E_INVALID_RESOURCETPM_E_NOTFIPSTPM_E_INVALID_FAMILYTPM_E_NO_NV_PERMISSIONTPM_E_REQUIRES_SIGNTPM_E_KEY_NOTSUPPORTEDTPM_E_AUTH_CONFLICTTPM_E_AREA_LOCKEDTPM_E_BAD_LOCALITYTPM_E_READ_ONLYTPM_E_PER_NOWRITETPM_E_FAMILYCOUNTTPM_E_WRITE_LOCKEDTPM_E_BAD_ATTRIBUTESTPM_E_INVALID_STRUCTURETPM_E_KEY_OWNER_CONTROLTPM_E_BAD_COUNTERTPM_E_NOT_FULLWRITETPM_E_CONTEXT_GAPTPM_E_MAXNVWRITESTPM_E_NOOPERATORTPM_E_RESOURCEMISSINGTPM_E_DELEGATE_LOCKTPM_E_DELEGATE_FAMILYTPM_E_DELEGATE_ADMINTPM_E_TRANSPORT_NOTEXCLUSIVETPM_E_OWNER_CONTROLTPM_E_DAA_RESOURCESTPM_E_DAA_INPUT_DATA0TPM_E_DAA_INPUT_DATA1TPM_E_DAA_ISSUER_SETTINGSTPM_E_DAA_TPM_SETTINGSTPM_E_DAA_STAGETPM_E_DAA_ISSUER_VALIDITYTPM_E_DAA_WRONG_WTPM_E_BAD_HANDLETPM_E_BAD_DELEGATETPM_E_BADCONTEXTTPM_E_TOOMANYCONTEXTSTPM_E_MA_TICKET_SIGNATURETPM_E_MA_DESTINATIONTPM_E_MA_SOURCETPM_E_MA_AUTHORITYTPM_E_PERMANENTEKTPM_E_BAD_SIGNATURETPM_E_NOCONTEXTSPACETPM_E_COMMAND_BLOCKEDTPM_E_INVALID_HANDLETPM_E_DUPLICATE_VHANDLETPM_E_EMBEDDED_COMMAND_BLOCKEDTPM_E_EMBEDDED_COMMAND_UNSUPPORTEDTPM_E_RETRYTPM_E_NEEDS_SELFTESTTPM_E_DOING_SELFTESTTPM_E_DEFEND_LOCK_RUNNINGTBS_E_INTERNAL_ERRORTBS_E_BAD_PARAMETERTBS_E_INVALID_OUTPUT_POINTERTBS_E_INVALID_CONTEXTTBS_E_INSUFFICIENT_BUFFERTBS_E_IOERRORTBS_E_INVALID_CONTEXT_PARAMTBS_E_SERVICE_NOT_RUNNINGTBS_E_TOO_MANY_TBS_CONTEXTSTBS_E_TOO_MANY_RESOURCESTBS_E_SERVICE_START_PENDINGTBS_E_PPI_NOT_SUPPORTEDTBS_E_COMMAND_CANCELEDTBS_E_BUFFER_TOO_LARGETBS_E_TPM_NOT_FOUNDTBS_E_SERVICE_DISABLEDTBS_E_NO_EVENT_LOGTBS_E_ACCESS_DENIEDTBS_E_PROVISIONING_NOT_ALLOWEDTBS_E_PPI_FUNCTION_UNSUPPORTEDTBS_E_OWNERAUTH_NOT_FOUNDTBS_E_PROVISIONING_INCOMPLETETPMAPI_E_INVALID_STATETPMAPI_E_NOT_ENOUGH_DATATPMAPI_E_TOO_MUCH_DATATPMAPI_E_INVALID_OUTPUT_POINTERTPMAPI_E_INVALID_PARAMETERTPMAPI_E_OUT_OF_MEMORYTPMAPI_E_BUFFER_TOO_SMALLTPMAPI_E_INTERNAL_ERRORTPMAPI_E_ACCESS_DENIEDTPMAPI_E_AUTHORIZATION_FAILEDTPMAPI_E_INVALID_CONTEXT_HANDLETPMAPI_E_TBS_COMMUNICATION_ERRORTPMAPI_E_TPM_COMMAND_ERRORTPMAPI_E_MESSAGE_TOO_LARGETPMAPI_E_INVALID_ENCODINGTPMAPI_E_INVALID_KEY_SIZETPMAPI_E_ENCRYPTION_FAILEDTPMAPI_E_INVALID_KEY_PARAMSTPMAPI_E_INVALID_MIGRATION_AUTHORIZATION_BLOBTPMAPI_E_INVALID_PCR_INDEXTPMAPI_E_INVALID_DELEGATE_BLOBTPMAPI_E_INVALID_CONTEXT_PARAMSTPMAPI_E_INVALID_KEY_BLOBTPMAPI_E_INVALID_PCR_DATATPMAPI_E_INVALID_OWNER_AUTHTPMAPI_E_FIPS_RNG_CHECK_FAILEDTPMAPI_E_EMPTY_TCG_LOGTPMAPI_E_INVALID_TCG_LOG_ENTRYTPMAPI_E_TCG_SEPARATOR_ABSENTTPMAPI_E_TCG_INVALID_DIGEST_ENTRYTPMAPI_E_POLICY_DENIES_OPERATIONTBSIMP_E_BUFFER_TOO_SMALLTBSIMP_E_CLEANUP_FAILEDTBSIMP_E_INVALID_CONTEXT_HANDLETBSIMP_E_INVALID_CONTEXT_PARAMTBSIMP_E_TPM_ERRORTBSIMP_E_HASH_BAD_KEYTBSIMP_E_DUPLICATE_VHANDLETBSIMP_E_INVALID_OUTPUT_POINTERTBSIMP_E_INVALID_PARAMETERTBSIMP_E_RPC_INIT_FAILEDTBSIMP_E_SCHEDULER_NOT_RUNNINGTBSIMP_E_COMMAND_CANCELEDTBSIMP_E_OUT_OF_MEMORYTBSIMP_E_LIST_NO_MORE_ITEMSTBSIMP_E_LIST_NOT_FOUNDTBSIMP_E_NOT_ENOUGH_SPACETBSIMP_E_NOT_ENOUGH_TPM_CONTEXTSTBSIMP_E_COMMAND_FAILEDTBSIMP_E_UNKNOWN_ORDINALTBSIMP_E_RESOURCE_EXPIREDTBSIMP_E_INVALID_RESOURCETBSIMP_E_NOTHING_TO_UNLOADTBSIMP_E_HASH_TABLE_FULLTBSIMP_E_TOO_MANY_TBS_CONTEXTSTBSIMP_E_TOO_MANY_RESOURCESTBSIMP_E_PPI_NOT_SUPPORTEDTBSIMP_E_TPM_INCOMPATIBLETBSIMP_E_NO_EVENT_LOGTPM_E_PPI_ACPI_FAILURETPM_E_PPI_USER_ABORTTPM_E_PPI_BIOS_FAILURETPM_E_PPI_NOT_SUPPORTEDTPM_E_PPI_BLOCKED_IN_BIOSTPM_E_PCP_ERROR_MASKTPM_E_PCP_DEVICE_NOT_READYTPM_E_PCP_INVALID_HANDLETPM_E_PCP_INVALID_PARAMETERTPM_E_PCP_FLAG_NOT_SUPPORTEDTPM_E_PCP_NOT_SUPPORTEDTPM_E_PCP_BUFFER_TOO_SMALLTPM_E_PCP_INTERNAL_ERRORTPM_E_PCP_AUTHENTICATION_FAILEDTPM_E_PCP_AUTHENTICATION_IGNOREDTPM_E_PCP_POLICY_NOT_FOUNDTPM_E_PCP_PROFILE_NOT_FOUNDTPM_E_PCP_VALIDATION_FAILEDPLA_E_DCS_NOT_FOUNDPLA_E_DCS_IN_USEPLA_E_TOO_MANY_FOLDERSPLA_E_NO_MIN_DISKPLA_E_DCS_ALREADY_EXISTSPLA_S_PROPERTY_IGNOREDPLA_E_PROPERTY_CONFLICTPLA_E_DCS_SINGLETON_REQUIREDPLA_E_CREDENTIALS_REQUIREDPLA_E_DCS_NOT_RUNNINGPLA_E_CONFLICT_INCL_EXCL_APIPLA_E_NETWORK_EXE_NOT_VALIDPLA_E_EXE_ALREADY_CONFIGUREDPLA_E_EXE_PATH_NOT_VALIDPLA_E_DC_ALREADY_EXISTSPLA_E_DCS_START_WAIT_TIMEOUTPLA_E_DC_START_WAIT_TIMEOUTPLA_E_REPORT_WAIT_TIMEOUTPLA_E_NO_DUPLICATESPLA_E_EXE_FULL_PATH_REQUIREDPLA_E_INVALID_SESSION_NAMEPLA_E_PLA_CHANNEL_NOT_ENABLEDPLA_E_TASKSCHED_CHANNEL_NOT_ENABLEDPLA_E_RULES_MANAGER_FAILEDPLA_E_CABAPI_FAILUREFVE_E_LOCKED_VOLUMEFVE_E_NOT_ENCRYPTEDFVE_E_NO_TPM_BIOSFVE_E_NO_MBR_METRICFVE_E_NO_BOOTSECTOR_METRICFVE_E_NO_BOOTMGR_METRICFVE_E_WRONG_BOOTMGRFVE_E_SECURE_KEY_REQUIREDFVE_E_NOT_ACTIVATEDFVE_E_ACTION_NOT_ALLOWEDFVE_E_AD_SCHEMA_NOT_INSTALLEDFVE_E_AD_INVALID_DATATYPEFVE_E_AD_INVALID_DATASIZEFVE_E_AD_NO_VALUESFVE_E_AD_ATTR_NOT_SETFVE_E_AD_GUID_NOT_FOUNDFVE_E_BAD_INFORMATIONFVE_E_TOO_SMALLFVE_E_SYSTEM_VOLUMEFVE_E_FAILED_WRONG_FSFVE_E_BAD_PARTITION_SIZEFVE_E_NOT_SUPPORTEDFVE_E_BAD_DATAFVE_E_VOLUME_NOT_BOUNDFVE_E_TPM_NOT_OWNEDFVE_E_NOT_DATA_VOLUMEFVE_E_AD_INSUFFICIENT_BUFFERFVE_E_CONV_READFVE_E_CONV_WRITEFVE_E_KEY_REQUIREDFVE_E_CLUSTERING_NOT_SUPPORTEDFVE_E_VOLUME_BOUND_ALREADYFVE_E_OS_NOT_PROTECTEDFVE_E_PROTECTION_DISABLEDFVE_E_RECOVERY_KEY_REQUIREDFVE_E_FOREIGN_VOLUMEFVE_E_OVERLAPPED_UPDATEFVE_E_TPM_SRK_AUTH_NOT_ZEROFVE_E_FAILED_SECTOR_SIZEFVE_E_FAILED_AUTHENTICATIONFVE_E_NOT_OS_VOLUMEFVE_E_AUTOUNLOCK_ENABLEDFVE_E_WRONG_BOOTSECTORFVE_E_WRONG_SYSTEM_FSFVE_E_POLICY_PASSWORD_REQUIREDFVE_E_CANNOT_SET_FVEK_ENCRYPTEDFVE_E_CANNOT_ENCRYPT_NO_KEYFVE_E_BOOTABLE_CDDVDFVE_E_PROTECTOR_EXISTSFVE_E_RELATIVE_PATHFVE_E_PROTECTOR_NOT_FOUNDFVE_E_INVALID_KEY_FORMATFVE_E_INVALID_PASSWORD_FORMATFVE_E_FIPS_RNG_CHECK_FAILEDFVE_E_FIPS_PREVENTS_RECOVERY_PASSWORDFVE_E_FIPS_PREVENTS_EXTERNAL_KEY_EXPORTFVE_E_NOT_DECRYPTEDFVE_E_INVALID_PROTECTOR_TYPEFVE_E_NO_PROTECTORS_TO_TESTFVE_E_KEYFILE_NOT_FOUNDFVE_E_KEYFILE_INVALIDFVE_E_KEYFILE_NO_VMKFVE_E_TPM_DISABLEDFVE_E_NOT_ALLOWED_IN_SAFE_MODEFVE_E_TPM_INVALID_PCRFVE_E_TPM_NO_VMKFVE_E_PIN_INVALIDFVE_E_AUTH_INVALID_APPLICATIONFVE_E_AUTH_INVALID_CONFIGFVE_E_FIPS_DISABLE_PROTECTION_NOT_ALLOWEDFVE_E_FS_NOT_EXTENDEDFVE_E_FIRMWARE_TYPE_NOT_SUPPORTEDFVE_E_NO_LICENSEFVE_E_NOT_ON_STACKFVE_E_FS_MOUNTEDFVE_E_TOKEN_NOT_IMPERSONATEDFVE_E_DRY_RUN_FAILEDFVE_E_REBOOT_REQUIREDFVE_E_DEBUGGER_ENABLEDFVE_E_RAW_ACCESSFVE_E_RAW_BLOCKEDFVE_E_BCD_APPLICATIONS_PATH_INCORRECTFVE_E_NOT_ALLOWED_IN_VERSIONFVE_E_NO_AUTOUNLOCK_MASTER_KEYFVE_E_MOR_FAILEDFVE_E_HIDDEN_VOLUMEFVE_E_TRANSIENT_STATEFVE_E_PUBKEY_NOT_ALLOWEDFVE_E_VOLUME_HANDLE_OPENFVE_E_NO_FEATURE_LICENSEFVE_E_INVALID_STARTUP_OPTIONSFVE_E_POLICY_RECOVERY_PASSWORD_NOT_ALLOWEDFVE_E_POLICY_RECOVERY_PASSWORD_REQUIREDFVE_E_POLICY_RECOVERY_KEY_NOT_ALLOWEDFVE_E_POLICY_RECOVERY_KEY_REQUIREDFVE_E_POLICY_STARTUP_PIN_NOT_ALLOWEDFVE_E_POLICY_STARTUP_PIN_REQUIREDFVE_E_POLICY_STARTUP_KEY_NOT_ALLOWEDFVE_E_POLICY_STARTUP_KEY_REQUIREDFVE_E_POLICY_STARTUP_PIN_KEY_NOT_ALLOWEDFVE_E_POLICY_STARTUP_PIN_KEY_REQUIREDFVE_E_POLICY_STARTUP_TPM_NOT_ALLOWEDFVE_E_POLICY_STARTUP_TPM_REQUIREDFVE_E_POLICY_INVALID_PIN_LENGTHFVE_E_KEY_PROTECTOR_NOT_SUPPORTEDFVE_E_POLICY_PASSPHRASE_NOT_ALLOWEDFVE_E_POLICY_PASSPHRASE_REQUIREDFVE_E_FIPS_PREVENTS_PASSPHRASEFVE_E_OS_VOLUME_PASSPHRASE_NOT_ALLOWEDFVE_E_INVALID_BITLOCKER_OIDFVE_E_VOLUME_TOO_SMALLFVE_E_DV_NOT_SUPPORTED_ON_FSFVE_E_DV_NOT_ALLOWED_BY_GPFVE_E_POLICY_USER_CERTIFICATE_NOT_ALLOWEDFVE_E_POLICY_USER_CERTIFICATE_REQUIREDFVE_E_POLICY_USER_CERT_MUST_BE_HWFVE_E_POLICY_USER_CONFIGURE_FDV_AUTOUNLOCK_NOT_ALLOWEDFVE_E_POLICY_USER_CONFIGURE_RDV_AUTOUNLOCK_NOT_ALLOWEDFVE_E_POLICY_USER_CONFIGURE_RDV_NOT_ALLOWEDFVE_E_POLICY_USER_ENABLE_RDV_NOT_ALLOWEDFVE_E_POLICY_USER_DISABLE_RDV_NOT_ALLOWEDFVE_E_POLICY_INVALID_PASSPHRASE_LENGTHFVE_E_POLICY_PASSPHRASE_TOO_SIMPLEFVE_E_RECOVERY_PARTITIONFVE_E_POLICY_CONFLICT_FDV_RK_OFF_AUK_ONFVE_E_POLICY_CONFLICT_RDV_RK_OFF_AUK_ONFVE_E_NON_BITLOCKER_OIDFVE_E_POLICY_PROHIBITS_SELFSIGNEDFVE_E_POLICY_CONFLICT_RO_AND_STARTUP_KEY_REQUIREDFVE_E_CONV_RECOVERY_FAILEDFVE_E_VIRTUALIZED_SPACE_TOO_BIGFVE_E_POLICY_CONFLICT_OSV_RP_OFF_ADB_ONFVE_E_POLICY_CONFLICT_FDV_RP_OFF_ADB_ONFVE_E_POLICY_CONFLICT_RDV_RP_OFF_ADB_ONFVE_E_NON_BITLOCKER_KUFVE_E_PRIVATEKEY_AUTH_FAILEDFVE_E_REMOVAL_OF_DRA_FAILEDFVE_E_OPERATION_NOT_SUPPORTED_ON_VISTA_VOLUMEFVE_E_CANT_LOCK_AUTOUNLOCK_ENABLED_VOLUMEFVE_E_FIPS_HASH_KDF_NOT_ALLOWEDFVE_E_ENH_PIN_INVALIDFVE_E_INVALID_PIN_CHARSFVE_E_INVALID_DATUM_TYPEFVE_E_EFI_ONLYFVE_E_MULTIPLE_NKP_CERTSFVE_E_REMOVAL_OF_NKP_FAILEDFVE_E_INVALID_NKP_CERTFVE_E_NO_EXISTING_PINFVE_E_PROTECTOR_CHANGE_PIN_MISMATCHFVE_E_PIN_PROTECTOR_CHANGE_BY_STD_USER_DISALLOWEDFVE_E_PROTECTOR_CHANGE_MAX_PIN_CHANGE_ATTEMPTS_REACHEDFVE_E_POLICY_PASSPHRASE_REQUIRES_ASCIIFVE_E_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGEFVE_E_WIPE_NOT_ALLOWED_ON_TP_STORAGEFVE_E_KEY_LENGTH_NOT_SUPPORTED_BY_EDRIVEFVE_E_NO_EXISTING_PASSPHRASEFVE_E_PROTECTOR_CHANGE_PASSPHRASE_MISMATCHFVE_E_PASSPHRASE_TOO_LONGFVE_E_NO_PASSPHRASE_WITH_TPMFVE_E_NO_TPM_WITH_PASSPHRASEFVE_E_NOT_ALLOWED_ON_CSV_STACKFVE_E_NOT_ALLOWED_ON_CLUSTERFVE_E_EDRIVE_NO_FAILOVER_TO_SWFVE_E_EDRIVE_BAND_IN_USEFVE_E_EDRIVE_DISALLOWED_BY_GPFVE_E_EDRIVE_INCOMPATIBLE_VOLUMEFVE_E_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTINGFVE_E_EDRIVE_DV_NOT_SUPPORTEDFVE_E_NO_PREBOOT_KEYBOARD_DETECTEDFVE_E_NO_PREBOOT_KEYBOARD_OR_WINRE_DETECTEDFVE_E_POLICY_REQUIRES_STARTUP_PIN_ON_TOUCH_DEVICEFVE_E_POLICY_REQUIRES_RECOVERY_PASSWORD_ON_TOUCH_DEVICEFVE_E_WIPE_CANCEL_NOT_APPLICABLEFVE_E_SECUREBOOT_DISABLEDFVE_E_SECUREBOOT_CONFIGURATION_INVALIDFVE_E_EDRIVE_DRY_RUN_FAILEDFVE_E_SHADOW_COPY_PRESENTFVE_E_POLICY_INVALID_ENHANCED_BCD_SETTINGSFVE_E_EDRIVE_INCOMPATIBLE_FIRMWAREFVE_E_PROTECTOR_CHANGE_MAX_PASSPHRASE_CHANGE_ATTEMPTS_REACHEDFVE_E_PASSPHRASE_PROTECTOR_CHANGE_BY_STD_USER_DISALLOWEDFVE_E_LIVEID_ACCOUNT_SUSPENDEDFVE_E_LIVEID_ACCOUNT_BLOCKEDFVE_E_NOT_PROVISIONED_ON_ALL_VOLUMESFVE_E_DE_FIXED_DATA_NOT_SUPPORTEDFVE_E_DE_HARDWARE_NOT_COMPLIANTFVE_E_DE_WINRE_NOT_CONFIGUREDFVE_E_DE_PROTECTION_SUSPENDEDFVE_E_DE_OS_VOLUME_NOT_PROTECTEDFVE_E_DE_DEVICE_LOCKEDOUTFVE_E_DE_PROTECTION_NOT_YET_ENABLEDFVE_E_INVALID_PIN_CHARS_DETAILEDFVE_E_DEVICE_LOCKOUT_COUNTER_UNAVAILABLEFVE_E_DEVICELOCKOUT_COUNTER_MISMATCHFVE_E_BUFFER_TOO_LARGEFVE_E_NO_SUCH_CAPABILITY_ON_TARGETFVE_E_DE_PREVENTED_FOR_OSFVE_E_DE_VOLUME_OPTED_OUTFVE_E_DE_VOLUME_NOT_SUPPORTEDFVE_E_EOW_NOT_SUPPORTED_IN_VERSIONFVE_E_ADBACKUP_NOT_ENABLEDFVE_E_VOLUME_EXTEND_PREVENTS_EOW_DECRYPTFVE_E_NOT_DE_VOLUMEFVE_E_PROTECTION_CANNOT_BE_DISABLEDFWP_E_CALLOUT_NOT_FOUNDFWP_E_CONDITION_NOT_FOUNDFWP_E_FILTER_NOT_FOUNDFWP_E_LAYER_NOT_FOUNDFWP_E_PROVIDER_NOT_FOUNDFWP_E_PROVIDER_CONTEXT_NOT_FOUNDFWP_E_SUBLAYER_NOT_FOUNDFWP_E_NOT_FOUNDFWP_E_ALREADY_EXISTSFWP_E_IN_USEFWP_E_DYNAMIC_SESSION_IN_PROGRESSFWP_E_WRONG_SESSIONFWP_E_NO_TXN_IN_PROGRESSFWP_E_TXN_IN_PROGRESSFWP_E_TXN_ABORTEDFWP_E_SESSION_ABORTEDFWP_E_INCOMPATIBLE_TXNFWP_E_TIMEOUTFWP_E_NET_EVENTS_DISABLEDFWP_E_INCOMPATIBLE_LAYERFWP_E_KM_CLIENTS_ONLYFWP_E_LIFETIME_MISMATCHFWP_E_BUILTIN_OBJECTFWP_E_TOO_MANY_CALLOUTSFWP_E_NOTIFICATION_DROPPEDFWP_E_TRAFFIC_MISMATCHFWP_E_INCOMPATIBLE_SA_STATEFWP_E_NULL_POINTERFWP_E_INVALID_ENUMERATORFWP_E_INVALID_FLAGSFWP_E_INVALID_NET_MASKFWP_E_INVALID_RANGEFWP_E_INVALID_INTERVALFWP_E_ZERO_LENGTH_ARRAYFWP_E_NULL_DISPLAY_NAMEFWP_E_INVALID_ACTION_TYPEFWP_E_INVALID_WEIGHTFWP_E_MATCH_TYPE_MISMATCHFWP_E_TYPE_MISMATCHFWP_E_OUT_OF_BOUNDSFWP_E_RESERVEDFWP_E_DUPLICATE_CONDITIONFWP_E_DUPLICATE_KEYMODFWP_E_ACTION_INCOMPATIBLE_WITH_LAYERFWP_E_ACTION_INCOMPATIBLE_WITH_SUBLAYERFWP_E_CONTEXT_INCOMPATIBLE_WITH_LAYERFWP_E_CONTEXT_INCOMPATIBLE_WITH_CALLOUTFWP_E_INCOMPATIBLE_AUTH_METHODFWP_E_INCOMPATIBLE_DH_GROUPFWP_E_EM_NOT_SUPPORTEDFWP_E_NEVER_MATCHFWP_E_PROVIDER_CONTEXT_MISMATCHFWP_E_INVALID_PARAMETERFWP_E_TOO_MANY_SUBLAYERSFWP_E_CALLOUT_NOTIFICATION_FAILEDFWP_E_INVALID_AUTH_TRANSFORMFWP_E_INVALID_CIPHER_TRANSFORMFWP_E_INCOMPATIBLE_CIPHER_TRANSFORMFWP_E_INVALID_TRANSFORM_COMBINATIONFWP_E_DUPLICATE_AUTH_METHODFWP_E_INVALID_TUNNEL_ENDPOINTFWP_E_L2_DRIVER_NOT_READYFWP_E_KEY_DICTATOR_ALREADY_REGISTEREDFWP_E_KEY_DICTATION_INVALID_KEYING_MATERIALFWP_E_CONNECTIONS_DISABLEDFWP_E_INVALID_DNS_NAMEFWP_E_STILL_ONFWP_E_IKEEXT_NOT_RUNNINGFWP_E_DROP_NOICMPWS_S_ASYNCWS_S_ENDWS_E_INVALID_FORMATWS_E_OBJECT_FAULTEDWS_E_NUMERIC_OVERFLOWWS_E_INVALID_OPERATIONWS_E_OPERATION_ABORTEDWS_E_ENDPOINT_ACCESS_DENIEDWS_E_OPERATION_TIMED_OUTWS_E_OPERATION_ABANDONEDWS_E_QUOTA_EXCEEDEDWS_E_NO_TRANSLATION_AVAILABLEWS_E_SECURITY_VERIFICATION_FAILUREWS_E_ADDRESS_IN_USEWS_E_ADDRESS_NOT_AVAILABLEWS_E_ENDPOINT_NOT_FOUNDWS_E_ENDPOINT_NOT_AVAILABLEWS_E_ENDPOINT_FAILUREWS_E_ENDPOINT_UNREACHABLEWS_E_ENDPOINT_ACTION_NOT_SUPPORTEDWS_E_ENDPOINT_TOO_BUSYWS_E_ENDPOINT_FAULT_RECEIVEDWS_E_ENDPOINT_DISCONNECTEDWS_E_PROXY_FAILUREWS_E_PROXY_ACCESS_DENIEDWS_E_NOT_SUPPORTEDWS_E_PROXY_REQUIRES_BASIC_AUTHWS_E_PROXY_REQUIRES_DIGEST_AUTHWS_E_PROXY_REQUIRES_NTLM_AUTHWS_E_PROXY_REQUIRES_NEGOTIATE_AUTHWS_E_SERVER_REQUIRES_BASIC_AUTHWS_E_SERVER_REQUIRES_DIGEST_AUTHWS_E_SERVER_REQUIRES_NTLM_AUTHWS_E_SERVER_REQUIRES_NEGOTIATE_AUTHWS_E_INVALID_ENDPOINT_URLWS_E_OTHERWS_E_SECURITY_TOKEN_EXPIREDWS_E_SECURITY_SYSTEM_FAILUREERROR_NDIS_INTERFACE_CLOSINGERROR_NDIS_BAD_VERSIONERROR_NDIS_BAD_CHARACTERISTICSERROR_NDIS_ADAPTER_NOT_FOUNDERROR_NDIS_OPEN_FAILEDERROR_NDIS_DEVICE_FAILEDERROR_NDIS_MULTICAST_FULLERROR_NDIS_MULTICAST_EXISTSERROR_NDIS_MULTICAST_NOT_FOUNDERROR_NDIS_REQUEST_ABORTEDERROR_NDIS_RESET_IN_PROGRESSERROR_NDIS_NOT_SUPPORTEDERROR_NDIS_INVALID_PACKETERROR_NDIS_ADAPTER_NOT_READYERROR_NDIS_INVALID_LENGTHERROR_NDIS_INVALID_DATAERROR_NDIS_BUFFER_TOO_SHORTERROR_NDIS_INVALID_OIDERROR_NDIS_ADAPTER_REMOVEDERROR_NDIS_UNSUPPORTED_MEDIAERROR_NDIS_GROUP_ADDRESS_IN_USEERROR_NDIS_FILE_NOT_FOUNDERROR_NDIS_ERROR_READING_FILEERROR_NDIS_ALREADY_MAPPEDERROR_NDIS_RESOURCE_CONFLICTERROR_NDIS_MEDIA_DISCONNECTEDERROR_NDIS_INVALID_ADDRESSERROR_NDIS_INVALID_DEVICE_REQUESTERROR_NDIS_PAUSEDERROR_NDIS_INTERFACE_NOT_FOUNDERROR_NDIS_UNSUPPORTED_REVISIONERROR_NDIS_INVALID_PORTERROR_NDIS_INVALID_PORT_STATEERROR_NDIS_LOW_POWER_STATEERROR_NDIS_REINIT_REQUIREDERROR_NDIS_DOT11_AUTO_CONFIG_ENABLEDERROR_NDIS_DOT11_MEDIA_IN_USEERROR_NDIS_DOT11_POWER_STATE_INVALIDERROR_NDIS_PM_WOL_PATTERN_LIST_FULLERROR_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULLERROR_NDIS_INDICATION_REQUIREDERROR_NDIS_OFFLOAD_POLICYERROR_NDIS_OFFLOAD_CONNECTION_REJECTEDERROR_NDIS_OFFLOAD_PATH_REJECTEDERROR_HV_INVALID_HYPERCALL_CODEERROR_HV_INVALID_HYPERCALL_INPUTERROR_HV_INVALID_ALIGNMENTERROR_HV_INVALID_PARAMETERERROR_HV_ACCESS_DENIEDERROR_HV_INVALID_PARTITION_STATEERROR_HV_OPERATION_DENIEDERROR_HV_UNKNOWN_PROPERTYERROR_HV_PROPERTY_VALUE_OUT_OF_RANGEERROR_HV_INSUFFICIENT_MEMORYERROR_HV_PARTITION_TOO_DEEPERROR_HV_INVALID_PARTITION_IDERROR_HV_INVALID_VP_INDEXERROR_HV_INVALID_PORT_IDERROR_HV_INVALID_CONNECTION_IDERROR_HV_INSUFFICIENT_BUFFERSERROR_HV_NOT_ACKNOWLEDGEDERROR_HV_ACKNOWLEDGEDERROR_HV_INVALID_SAVE_RESTORE_STATEERROR_HV_INVALID_SYNIC_STATEERROR_HV_OBJECT_IN_USEERROR_HV_INVALID_PROXIMITY_DOMAIN_INFOERROR_HV_NO_DATAERROR_HV_INACTIVEERROR_HV_NO_RESOURCESERROR_HV_FEATURE_UNAVAILABLEERROR_HV_INSUFFICIENT_BUFFERERROR_HV_INSUFFICIENT_DEVICE_DOMAINSERROR_HV_INVALID_LP_INDEXERROR_HV_NOT_PRESENTERROR_VID_DUPLICATE_HANDLERERROR_VID_TOO_MANY_HANDLERSERROR_VID_QUEUE_FULLERROR_VID_HANDLER_NOT_PRESENTERROR_VID_INVALID_OBJECT_NAMEERROR_VID_PARTITION_NAME_TOO_LONGERROR_VID_MESSAGE_QUEUE_NAME_TOO_LONGERROR_VID_PARTITION_ALREADY_EXISTSERROR_VID_PARTITION_DOES_NOT_EXISTERROR_VID_PARTITION_NAME_NOT_FOUNDERROR_VID_MESSAGE_QUEUE_ALREADY_EXISTSERROR_VID_EXCEEDED_MBP_ENTRY_MAP_LIMITERROR_VID_MB_STILL_REFERENCEDERROR_VID_CHILD_GPA_PAGE_SET_CORRUPTEDERROR_VID_INVALID_NUMA_SETTINGSERROR_VID_INVALID_NUMA_NODE_INDEXERROR_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATEDERROR_VID_INVALID_MEMORY_BLOCK_HANDLEERROR_VID_PAGE_RANGE_OVERFLOWERROR_VID_INVALID_MESSAGE_QUEUE_HANDLEERROR_VID_INVALID_GPA_RANGE_HANDLEERROR_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUEERROR_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDEDERROR_VID_INVALID_PPM_HANDLEERROR_VID_MBPS_ARE_LOCKEDERROR_VID_MESSAGE_QUEUE_CLOSEDERROR_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDEDERROR_VID_STOP_PENDINGERROR_VID_INVALID_PROCESSOR_STATEERROR_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMITERROR_VID_KM_INTERFACE_ALREADY_INITIALIZEDERROR_VID_MB_PROPERTY_ALREADY_SET_RESETERROR_VID_MMIO_RANGE_DESTROYEDERROR_VID_INVALID_CHILD_GPA_PAGE_SETERROR_VID_RESERVE_PAGE_SET_IS_BEING_USEDERROR_VID_RESERVE_PAGE_SET_TOO_SMALLERROR_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGEERROR_VID_MBP_COUNT_EXCEEDED_LIMITERROR_VID_SAVED_STATE_CORRUPTERROR_VID_SAVED_STATE_UNRECOGNIZED_ITEMERROR_VID_SAVED_STATE_INCOMPATIBLEERROR_VID_REMOTE_NODE_PARENT_GPA_PAGES_USEDERROR_VOLMGR_INCOMPLETE_REGENERATIONERROR_VOLMGR_INCOMPLETE_DISK_MIGRATIONERROR_VOLMGR_DATABASE_FULLERROR_VOLMGR_DISK_CONFIGURATION_CORRUPTEDERROR_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNCERROR_VOLMGR_PACK_CONFIG_UPDATE_FAILEDERROR_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUMEERROR_VOLMGR_DISK_DUPLICATEERROR_VOLMGR_DISK_DYNAMICERROR_VOLMGR_DISK_ID_INVALIDERROR_VOLMGR_DISK_INVALIDERROR_VOLMGR_DISK_LAST_VOTERERROR_VOLMGR_DISK_LAYOUT_INVALIDERROR_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONSERROR_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNEDERROR_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALLERROR_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONSERROR_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONSERROR_VOLMGR_DISK_MISSINGERROR_VOLMGR_DISK_NOT_EMPTYERROR_VOLMGR_DISK_NOT_ENOUGH_SPACEERROR_VOLMGR_DISK_REVECTORING_FAILEDERROR_VOLMGR_DISK_SECTOR_SIZE_INVALIDERROR_VOLMGR_DISK_SET_NOT_CONTAINEDERROR_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERSERROR_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXESERROR_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTEDERROR_VOLMGR_EXTENT_ALREADY_USEDERROR_VOLMGR_EXTENT_NOT_CONTIGUOUSERROR_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGIONERROR_VOLMGR_EXTENT_NOT_SECTOR_ALIGNEDERROR_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITIONERROR_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCHERROR_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTEDERROR_VOLMGR_INTERLEAVE_LENGTH_INVALIDERROR_VOLMGR_MAXIMUM_REGISTERED_USERSERROR_VOLMGR_MEMBER_IN_SYNCERROR_VOLMGR_MEMBER_INDEX_DUPLICATEERROR_VOLMGR_MEMBER_INDEX_INVALIDERROR_VOLMGR_MEMBER_MISSINGERROR_VOLMGR_MEMBER_NOT_DETACHEDERROR_VOLMGR_MEMBER_REGENERATINGERROR_VOLMGR_ALL_DISKS_FAILEDERROR_VOLMGR_NO_REGISTERED_USERSERROR_VOLMGR_NO_SUCH_USERERROR_VOLMGR_NOTIFICATION_RESETERROR_VOLMGR_NUMBER_OF_MEMBERS_INVALIDERROR_VOLMGR_NUMBER_OF_PLEXES_INVALIDERROR_VOLMGR_PACK_DUPLICATEERROR_VOLMGR_PACK_ID_INVALIDERROR_VOLMGR_PACK_INVALIDERROR_VOLMGR_PACK_NAME_INVALIDERROR_VOLMGR_PACK_OFFLINEERROR_VOLMGR_PACK_HAS_QUORUMERROR_VOLMGR_PACK_WITHOUT_QUORUMERROR_VOLMGR_PARTITION_STYLE_INVALIDERROR_VOLMGR_PARTITION_UPDATE_FAILEDERROR_VOLMGR_PLEX_IN_SYNCERROR_VOLMGR_PLEX_INDEX_DUPLICATEERROR_VOLMGR_PLEX_INDEX_INVALIDERROR_VOLMGR_PLEX_LAST_ACTIVEERROR_VOLMGR_PLEX_MISSINGERROR_VOLMGR_PLEX_REGENERATINGERROR_VOLMGR_PLEX_TYPE_INVALIDERROR_VOLMGR_PLEX_NOT_RAID5ERROR_VOLMGR_PLEX_NOT_SIMPLEERROR_VOLMGR_STRUCTURE_SIZE_INVALIDERROR_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTSERROR_VOLMGR_TRANSACTION_IN_PROGRESSERROR_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGEERROR_VOLMGR_VOLUME_CONTAINS_MISSING_DISKERROR_VOLMGR_VOLUME_ID_INVALIDERROR_VOLMGR_VOLUME_LENGTH_INVALIDERROR_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLEERROR_VOLMGR_VOLUME_NOT_MIRROREDERROR_VOLMGR_VOLUME_NOT_RETAINEDERROR_VOLMGR_VOLUME_OFFLINEERROR_VOLMGR_VOLUME_RETAINEDERROR_VOLMGR_NUMBER_OF_EXTENTS_INVALIDERROR_VOLMGR_DIFFERENT_SECTOR_SIZEERROR_VOLMGR_BAD_BOOT_DISKERROR_VOLMGR_PACK_CONFIG_OFFLINEERROR_VOLMGR_PACK_CONFIG_ONLINEERROR_VOLMGR_NOT_PRIMARY_PACKERROR_VOLMGR_PACK_LOG_UPDATE_FAILEDERROR_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALIDERROR_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALIDERROR_VOLMGR_VOLUME_MIRROREDERROR_VOLMGR_PLEX_NOT_SIMPLE_SPANNEDERROR_VOLMGR_NO_VALID_LOG_COPIESERROR_VOLMGR_PRIMARY_PACK_PRESENTERROR_VOLMGR_NUMBER_OF_DISKS_INVALIDERROR_VOLMGR_MIRROR_NOT_SUPPORTEDERROR_VOLMGR_RAID5_NOT_SUPPORTEDERROR_BCD_NOT_ALL_ENTRIES_IMPORTEDERROR_BCD_TOO_MANY_ELEMENTSERROR_BCD_NOT_ALL_ENTRIES_SYNCHRONIZEDERROR_VHD_DRIVE_FOOTER_MISSINGERROR_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCHERROR_VHD_DRIVE_FOOTER_CORRUPTERROR_VHD_FORMAT_UNKNOWNERROR_VHD_FORMAT_UNSUPPORTED_VERSIONERROR_VHD_SPARSE_HEADER_CHECKSUM_MISMATCHERROR_VHD_SPARSE_HEADER_UNSUPPORTED_VERSIONERROR_VHD_SPARSE_HEADER_CORRUPTERROR_VHD_BLOCK_ALLOCATION_FAILUREERROR_VHD_BLOCK_ALLOCATION_TABLE_CORRUPTERROR_VHD_INVALID_BLOCK_SIZEERROR_VHD_BITMAP_MISMATCHERROR_VHD_PARENT_VHD_NOT_FOUNDERROR_VHD_CHILD_PARENT_ID_MISMATCHERROR_VHD_CHILD_PARENT_TIMESTAMP_MISMATCHERROR_VHD_METADATA_READ_FAILUREERROR_VHD_METADATA_WRITE_FAILUREERROR_VHD_INVALID_SIZEERROR_VHD_INVALID_FILE_SIZEERROR_VIRTDISK_PROVIDER_NOT_FOUNDERROR_VIRTDISK_NOT_VIRTUAL_DISKERROR_VHD_PARENT_VHD_ACCESS_DENIEDERROR_VHD_CHILD_PARENT_SIZE_MISMATCHERROR_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTEDERROR_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENTERROR_VIRTUAL_DISK_LIMITATIONERROR_VHD_INVALID_TYPEERROR_VHD_INVALID_STATEERROR_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZEERROR_VIRTDISK_DISK_ALREADY_OWNEDERROR_VIRTDISK_DISK_ONLINE_AND_WRITABLEERROR_CTLOG_TRACKING_NOT_INITIALIZEDERROR_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZEERROR_CTLOG_VHD_CHANGED_OFFLINEERROR_CTLOG_INVALID_TRACKING_STATEERROR_CTLOG_INCONSISTENT_TRACKING_FILEERROR_VHD_RESIZE_WOULD_TRUNCATE_DATAERROR_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZEERROR_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZEERROR_VHD_METADATA_FULLERROR_QUERY_STORAGE_ERRORSDIAG_E_CANCELLEDSDIAG_E_SCRIPTSDIAG_E_POWERSHELLSDIAG_E_MANAGEDHOSTSDIAG_E_NOVERIFIERSDIAG_S_CANNOTRUNSDIAG_E_DISABLEDSDIAG_E_TRUSTSDIAG_E_CANNOTRUNSDIAG_E_VERSIONSDIAG_E_RESOURCESDIAG_E_ROOTCAUSEWPN_E_CHANNEL_CLOSEDWPN_E_CHANNEL_REQUEST_NOT_COMPLETEWPN_E_INVALID_APPWPN_E_OUTSTANDING_CHANNEL_REQUESTWPN_E_DUPLICATE_CHANNELWPN_E_PLATFORM_UNAVAILABLEWPN_E_NOTIFICATION_POSTEDWPN_E_NOTIFICATION_HIDDENWPN_E_NOTIFICATION_NOT_POSTEDWPN_E_CLOUD_DISABLEDWPN_E_CLOUD_INCAPABLEWPN_E_CLOUD_AUTH_UNAVAILABLEWPN_E_CLOUD_SERVICE_UNAVAILABLEWPN_E_FAILED_LOCK_SCREEN_UPDATE_INTIALIZATIONWPN_E_NOTIFICATION_DISABLEDWPN_E_NOTIFICATION_INCAPABLEWPN_E_INTERNET_INCAPABLEWPN_E_NOTIFICATION_TYPE_DISABLEDWPN_E_NOTIFICATION_SIZEWPN_E_TAG_SIZEWPN_E_ACCESS_DENIEDWPN_E_DUPLICATE_REGISTRATIONWPN_E_PUSH_NOTIFICATION_INCAPABLEWPN_E_DEV_ID_SIZEWPN_E_TAG_ALPHANUMERICWPN_E_INVALID_HTTP_STATUS_CODEWPN_E_OUT_OF_SESSIONWPN_E_POWER_SAVEWPN_E_IMAGE_NOT_FOUND_IN_CACHEWPN_E_ALL_URL_NOT_COMPLETEDWPN_E_INVALID_CLOUD_IMAGEWPN_E_NOTIFICATION_ID_MATCHEDWPN_E_CALLBACK_ALREADY_REGISTEREDWPN_E_TOAST_NOTIFICATION_DROPPEDWPN_E_STORAGE_LOCKEDE_MBN_CONTEXT_NOT_ACTIVATEDE_MBN_BAD_SIME_MBN_DATA_CLASS_NOT_AVAILABLEE_MBN_INVALID_ACCESS_STRINGE_MBN_MAX_ACTIVATED_CONTEXTSE_MBN_PACKET_SVC_DETACHEDE_MBN_PROVIDER_NOT_VISIBLEE_MBN_RADIO_POWER_OFFE_MBN_SERVICE_NOT_ACTIVATEDE_MBN_SIM_NOT_INSERTEDE_MBN_VOICE_CALL_IN_PROGRESSE_MBN_INVALID_CACHEE_MBN_NOT_REGISTEREDE_MBN_PROVIDERS_NOT_FOUNDE_MBN_PIN_NOT_SUPPORTEDE_MBN_PIN_REQUIREDE_MBN_PIN_DISABLEDE_MBN_FAILUREE_MBN_INVALID_PROFILEE_MBN_DEFAULT_PROFILE_EXISTE_MBN_SMS_ENCODING_NOT_SUPPORTEDE_MBN_SMS_FILTER_NOT_SUPPORTEDE_MBN_SMS_INVALID_MEMORY_INDEXE_MBN_SMS_LANG_NOT_SUPPORTEDE_MBN_SMS_MEMORY_FAILUREE_MBN_SMS_NETWORK_TIMEOUTE_MBN_SMS_UNKNOWN_SMSC_ADDRESSE_MBN_SMS_FORMAT_NOT_SUPPORTEDE_MBN_SMS_OPERATION_NOT_ALLOWEDE_MBN_SMS_MEMORY_FULLPEER_E_IPV6_NOT_INSTALLEDPEER_E_NOT_INITIALIZEDPEER_E_CANNOT_START_SERVICEPEER_E_NOT_LICENSEDPEER_E_INVALID_GRAPHPEER_E_DBNAME_CHANGEDPEER_E_DUPLICATE_GRAPHPEER_E_GRAPH_NOT_READYPEER_E_GRAPH_SHUTTING_DOWNPEER_E_GRAPH_IN_USEPEER_E_INVALID_DATABASEPEER_E_TOO_MANY_ATTRIBUTESPEER_E_CONNECTION_NOT_FOUNDPEER_E_CONNECT_SELFPEER_E_ALREADY_LISTENINGPEER_E_NODE_NOT_FOUNDPEER_E_CONNECTION_FAILEDPEER_E_CONNECTION_NOT_AUTHENTICATEDPEER_E_CONNECTION_REFUSEDPEER_E_CLASSIFIER_TOO_LONGPEER_E_TOO_MANY_IDENTITIESPEER_E_NO_KEY_ACCESSPEER_E_GROUPS_EXISTPEER_E_RECORD_NOT_FOUNDPEER_E_DATABASE_ACCESSDENIEDPEER_E_DBINITIALIZATION_FAILEDPEER_E_MAX_RECORD_SIZE_EXCEEDEDPEER_E_DATABASE_ALREADY_PRESENTPEER_E_DATABASE_NOT_PRESENTPEER_E_IDENTITY_NOT_FOUNDPEER_E_EVENT_HANDLE_NOT_FOUNDPEER_E_INVALID_SEARCHPEER_E_INVALID_ATTRIBUTESPEER_E_INVITATION_NOT_TRUSTEDPEER_E_CHAIN_TOO_LONGPEER_E_INVALID_TIME_PERIODPEER_E_CIRCULAR_CHAIN_DETECTEDPEER_E_CERT_STORE_CORRUPTEDPEER_E_NO_CLOUDPEER_E_CLOUD_NAME_AMBIGUOUSPEER_E_INVALID_RECORDPEER_E_NOT_AUTHORIZEDPEER_E_PASSWORD_DOES_NOT_MEET_POLICYPEER_E_DEFERRED_VALIDATIONPEER_E_INVALID_GROUP_PROPERTIESPEER_E_INVALID_PEER_NAMEPEER_E_INVALID_CLASSIFIERPEER_E_INVALID_FRIENDLY_NAMEPEER_E_INVALID_ROLE_PROPERTYPEER_E_INVALID_CLASSIFIER_PROPERTYPEER_E_INVALID_RECORD_EXPIRATIONPEER_E_INVALID_CREDENTIAL_INFOPEER_E_INVALID_CREDENTIALPEER_E_INVALID_RECORD_SIZEPEER_E_UNSUPPORTED_VERSIONPEER_E_GROUP_NOT_READYPEER_E_GROUP_IN_USEPEER_E_INVALID_GROUPPEER_E_NO_MEMBERS_FOUNDPEER_E_NO_MEMBER_CONNECTIONSPEER_E_UNABLE_TO_LISTENPEER_E_IDENTITY_DELETEDPEER_E_SERVICE_NOT_AVAILABLEPEER_E_CONTACT_NOT_FOUNDPEER_S_GRAPH_DATA_CREATEDPEER_S_NO_EVENT_DATAPEER_S_ALREADY_CONNECTEDPEER_S_SUBSCRIPTION_EXISTSPEER_S_NO_CONNECTIVITYPEER_S_ALREADY_A_MEMBERPEER_E_CANNOT_CONVERT_PEER_NAMEPEER_E_INVALID_PEER_HOST_NAMEPEER_E_NO_MOREPEER_E_PNRP_DUPLICATE_PEER_NAMEPEER_E_INVITE_CANCELLEDPEER_E_INVITE_RESPONSE_NOT_AVAILABLEPEER_E_NOT_SIGNED_INPEER_E_PRIVACY_DECLINEDPEER_E_TIMEOUTPEER_E_INVALID_ADDRESSPEER_E_FW_EXCEPTION_DISABLEDPEER_E_FW_BLOCKED_BY_POLICYPEER_E_FW_BLOCKED_BY_SHIELDS_UPPEER_E_FW_DECLINEDUI_E_CREATE_FAILEDUI_E_SHUTDOWN_CALLEDUI_E_ILLEGAL_REENTRANCYUI_E_OBJECT_SEALEDUI_E_VALUE_NOT_SETUI_E_VALUE_NOT_DETERMINEDUI_E_INVALID_OUTPUTUI_E_BOOLEAN_EXPECTEDUI_E_DIFFERENT_OWNERUI_E_AMBIGUOUS_MATCHUI_E_FP_OVERFLOWUI_E_WRONG_THREADUI_E_STORYBOARD_ACTIVEUI_E_STORYBOARD_NOT_PLAYINGUI_E_START_KEYFRAME_AFTER_ENDUI_E_END_KEYFRAME_NOT_DETERMINEDUI_E_LOOPS_OVERLAPUI_E_TRANSITION_ALREADY_USEDUI_E_TRANSITION_NOT_IN_STORYBOARDUI_E_TRANSITION_ECLIPSEDUI_E_TIME_BEFORE_LAST_UPDATEUI_E_TIMER_CLIENT_ALREADY_CONNECTEDUI_E_INVALID_DIMENSIONUI_E_PRIMITIVE_OUT_OF_BOUNDSUI_E_WINDOW_CLOSEDE_BLUETOOTH_ATT_INVALID_HANDLEE_BLUETOOTH_ATT_READ_NOT_PERMITTEDE_BLUETOOTH_ATT_WRITE_NOT_PERMITTEDE_BLUETOOTH_ATT_INVALID_PDUE_BLUETOOTH_ATT_INSUFFICIENT_AUTHENTICATIONE_BLUETOOTH_ATT_REQUEST_NOT_SUPPORTEDE_BLUETOOTH_ATT_INVALID_OFFSETE_BLUETOOTH_ATT_INSUFFICIENT_AUTHORIZATIONE_BLUETOOTH_ATT_PREPARE_QUEUE_FULLE_BLUETOOTH_ATT_ATTRIBUTE_NOT_FOUNDE_BLUETOOTH_ATT_ATTRIBUTE_NOT_LONGE_BLUETOOTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZEE_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTHE_BLUETOOTH_ATT_UNLIKELYE_BLUETOOTH_ATT_INSUFFICIENT_ENCRYPTIONE_BLUETOOTH_ATT_UNSUPPORTED_GROUP_TYPEE_BLUETOOTH_ATT_INSUFFICIENT_RESOURCESE_BLUETOOTH_ATT_UNKNOWN_ERRORE_AUDIO_ENGINE_NODE_NOT_FOUNDE_HDAUDIO_EMPTY_CONNECTION_LISTE_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTEDE_HDAUDIO_NO_LOGICAL_DEVICES_CREATEDE_HDAUDIO_NULL_LINKED_LIST_ENTRYERROR_SPACES_POOL_WAS_DELETEDERROR_SPACES_RESILIENCY_TYPE_INVALIDERROR_SPACES_DRIVE_SECTOR_SIZE_INVALIDERROR_SPACES_DRIVE_REDUNDANCY_INVALIDERROR_SPACES_NUMBER_OF_DATA_COPIES_INVALIDERROR_SPACES_PARITY_LAYOUT_INVALIDERROR_SPACES_INTERLEAVE_LENGTH_INVALIDERROR_SPACES_NUMBER_OF_COLUMNS_INVALIDERROR_SPACES_NOT_ENOUGH_DRIVESERROR_VOLSNAP_BOOTFILE_NOT_VALIDERROR_TIERING_NOT_SUPPORTED_ON_VOLUMEERROR_TIERING_VOLUME_DISMOUNT_IN_PROGRESSERROR_TIERING_STORAGE_TIER_NOT_FOUNDERROR_TIERING_INVALID_FILE_IDERROR_TIERING_WRONG_CLUSTER_NODEERROR_TIERING_ALREADY_PROCESSINGERROR_TIERING_CANNOT_PIN_OBJECTDXGI_STATUS_OCCLUDEDDXGI_STATUS_CLIPPEDDXGI_STATUS_NO_REDIRECTIONDXGI_STATUS_NO_DESKTOP_ACCESSDXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USEDXGI_STATUS_MODE_CHANGEDDXGI_STATUS_MODE_CHANGE_IN_PROGRESSDXGI_ERROR_INVALID_CALLDXGI_ERROR_NOT_FOUNDDXGI_ERROR_MORE_DATADXGI_ERROR_UNSUPPORTEDDXGI_ERROR_DEVICE_REMOVEDDXGI_ERROR_DEVICE_HUNGDXGI_ERROR_DEVICE_RESETDXGI_ERROR_WAS_STILL_DRAWINGDXGI_ERROR_FRAME_STATISTICS_DISJOINTDXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USEDXGI_ERROR_DRIVER_INTERNAL_ERRORDXGI_ERROR_NONEXCLUSIVEDXGI_ERROR_NOT_CURRENTLY_AVAILABLEDXGI_ERROR_REMOTE_CLIENT_DISCONNECTEDDXGI_ERROR_REMOTE_OUTOFMEMORYDXGI_ERROR_ACCESS_LOSTDXGI_ERROR_WAIT_TIMEOUTDXGI_ERROR_SESSION_DISCONNECTEDDXGI_ERROR_RESTRICT_TO_OUTPUT_STALEDXGI_ERROR_CANNOT_PROTECT_CONTENTDXGI_ERROR_ACCESS_DENIEDDXGI_ERROR_NAME_ALREADY_EXISTSDXGI_ERROR_SDK_COMPONENT_MISSINGDXGI_STATUS_UNOCCLUDEDDXGI_STATUS_DDA_WAS_STILL_DRAWINGDXGI_ERROR_MODE_CHANGE_IN_PROGRESSDXGI_DDI_ERR_WASSTILLDRAWINGDXGI_DDI_ERR_UNSUPPORTEDDXGI_DDI_ERR_NONEXCLUSIVED3D10_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTSD3D10_ERROR_FILE_NOT_FOUNDD3D11_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTSD3D11_ERROR_FILE_NOT_FOUNDD3D11_ERROR_TOO_MANY_UNIQUE_VIEW_OBJECTSD3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARDD2DERR_WRONG_STATED2DERR_NOT_INITIALIZEDD2DERR_UNSUPPORTED_OPERATIOND2DERR_SCANNER_FAILEDD2DERR_SCREEN_ACCESS_DENIEDD2DERR_DISPLAY_STATE_INVALIDD2DERR_ZERO_VECTORD2DERR_INTERNAL_ERRORD2DERR_DISPLAY_FORMAT_NOT_SUPPORTEDD2DERR_INVALID_CALLD2DERR_NO_HARDWARE_DEVICED2DERR_RECREATE_TARGETD2DERR_TOO_MANY_SHADER_ELEMENTSD2DERR_SHADER_COMPILE_FAILEDD2DERR_MAX_TEXTURE_SIZE_EXCEEDEDD2DERR_UNSUPPORTED_VERSIOND2DERR_BAD_NUMBERD2DERR_WRONG_FACTORYD2DERR_LAYER_ALREADY_IN_USED2DERR_POP_CALL_DID_NOT_MATCH_PUSHD2DERR_WRONG_RESOURCE_DOMAIND2DERR_PUSH_POP_UNBALANCEDD2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECTD2DERR_INCOMPATIBLE_BRUSH_TYPESD2DERR_WIN32_ERRORD2DERR_TARGET_NOT_GDI_COMPATIBLED2DERR_TEXT_EFFECT_IS_WRONG_TYPED2DERR_TEXT_RENDERER_NOT_RELEASEDD2DERR_EXCEEDS_MAX_BITMAP_SIZED2DERR_INVALID_GRAPH_CONFIGURATIOND2DERR_INVALID_INTERNAL_GRAPH_CONFIGURATIOND2DERR_CYCLIC_GRAPHD2DERR_BITMAP_CANNOT_DRAWD2DERR_OUTSTANDING_BITMAP_REFERENCESD2DERR_ORIGINAL_TARGET_NOT_BOUNDD2DERR_INVALID_TARGETD2DERR_BITMAP_BOUND_AS_TARGETD2DERR_INSUFFICIENT_DEVICE_CAPABILITIESD2DERR_INTERMEDIATE_TOO_LARGED2DERR_EFFECT_IS_NOT_REGISTEREDD2DERR_INVALID_PROPERTYD2DERR_NO_SUBPROPERTIESD2DERR_PRINT_JOB_CLOSEDD2DERR_PRINT_FORMAT_NOT_SUPPORTEDD2DERR_TOO_MANY_TRANSFORM_INPUTSDWRITE_E_FILEFORMATDWRITE_E_UNEXPECTEDDWRITE_E_NOFONTDWRITE_E_FILENOTFOUNDDWRITE_E_FILEACCESSDWRITE_E_FONTCOLLECTIONOBSOLETEDWRITE_E_ALREADYREGISTEREDDWRITE_E_CACHEFORMATDWRITE_E_CACHEVERSIONDWRITE_E_UNSUPPORTEDOPERATIONDWRITE_E_TEXTRENDERERINCOMPATIBLEDWRITE_E_FLOWDIRECTIONCONFLICTSDWRITE_E_NOCOLORWINCODEC_ERR_WRONGSTATEWINCODEC_ERR_VALUEOUTOFRANGEWINCODEC_ERR_UNKNOWNIMAGEFORMATWINCODEC_ERR_UNSUPPORTEDVERSIONWINCODEC_ERR_NOTINITIALIZEDWINCODEC_ERR_ALREADYLOCKEDWINCODEC_ERR_PROPERTYNOTFOUNDWINCODEC_ERR_PROPERTYNOTSUPPORTEDWINCODEC_ERR_PROPERTYSIZEWINCODEC_ERR_CODECPRESENTWINCODEC_ERR_CODECNOTHUMBNAILWINCODEC_ERR_PALETTEUNAVAILABLEWINCODEC_ERR_CODECTOOMANYSCANLINESWINCODEC_ERR_INTERNALERRORWINCODEC_ERR_SOURCERECTDOESNOTMATCHDIMENSIONSWINCODEC_ERR_COMPONENTNOTFOUNDWINCODEC_ERR_IMAGESIZEOUTOFRANGEWINCODEC_ERR_TOOMUCHMETADATAWINCODEC_ERR_BADIMAGEWINCODEC_ERR_BADHEADERWINCODEC_ERR_FRAMEMISSINGWINCODEC_ERR_BADMETADATAHEADERWINCODEC_ERR_BADSTREAMDATAWINCODEC_ERR_STREAMWRITEWINCODEC_ERR_STREAMREADWINCODEC_ERR_STREAMNOTAVAILABLEWINCODEC_ERR_UNSUPPORTEDPIXELFORMATWINCODEC_ERR_UNSUPPORTEDOPERATIONWINCODEC_ERR_INVALIDREGISTRATIONWINCODEC_ERR_COMPONENTINITIALIZEFAILUREWINCODEC_ERR_INSUFFICIENTBUFFERWINCODEC_ERR_DUPLICATEMETADATAPRESENTWINCODEC_ERR_PROPERTYUNEXPECTEDTYPEWINCODEC_ERR_UNEXPECTEDSIZEWINCODEC_ERR_INVALIDQUERYREQUESTWINCODEC_ERR_UNEXPECTEDMETADATATYPEWINCODEC_ERR_REQUESTONLYVALIDATMETADATAROOTWINCODEC_ERR_INVALIDQUERYCHARACTERWINCODEC_ERR_WIN32ERRORWINCODEC_ERR_INVALIDPROGRESSIVELEVELMILERR_OBJECTBUSYMILERR_INSUFFICIENTBUFFERMILERR_WIN32ERRORMILERR_SCANNER_FAILEDMILERR_SCREENACCESSDENIEDMILERR_DISPLAYSTATEINVALIDMILERR_NONINVERTIBLEMATRIXMILERR_ZEROVECTORMILERR_TERMINATEDMILERR_BADNUMBERMILERR_INTERNALERRORMILERR_DISPLAYFORMATNOTSUPPORTEDMILERR_INVALIDCALLMILERR_ALREADYLOCKEDMILERR_NOTLOCKEDMILERR_DEVICECANNOTRENDERTEXTMILERR_GLYPHBITMAPMISSEDMILERR_MALFORMEDGLYPHCACHEMILERR_GENERIC_IGNOREMILERR_MALFORMED_GUIDELINE_DATAMILERR_NO_HARDWARE_DEVICEMILERR_NEED_RECREATE_AND_PRESENTMILERR_ALREADY_INITIALIZEDMILERR_MISMATCHED_SIZEMILERR_NO_REDIRECTION_SURFACE_AVAILABLEMILERR_REMOTING_NOT_SUPPORTEDMILERR_QUEUED_PRESENT_NOT_SUPPORTEDMILERR_NOT_QUEUING_PRESENTSMILERR_NO_REDIRECTION_SURFACE_RETRY_LATERMILERR_TOOMANYSHADERELEMNTSMILERR_MROW_READLOCK_FAILEDMILERR_MROW_UPDATE_FAILEDMILERR_SHADER_COMPILE_FAILEDMILERR_MAX_TEXTURE_SIZE_EXCEEDEDMILERR_QPC_TIME_WENT_BACKWARDMILERR_DXGI_ENUMERATION_OUT_OF_SYNCMILERR_ADAPTER_NOT_FOUNDMILERR_COLORSPACE_NOT_SUPPORTEDMILERR_PREFILTER_NOT_SUPPORTEDMILERR_DISPLAYID_ACCESS_DENIEDUCEERR_INVALIDPACKETHEADERUCEERR_UNKNOWNPACKETUCEERR_ILLEGALPACKETUCEERR_MALFORMEDPACKETUCEERR_ILLEGALHANDLEUCEERR_HANDLELOOKUPFAILEDUCEERR_RENDERTHREADFAILUREUCEERR_CTXSTACKFRSTTARGETNULLUCEERR_CONNECTIONIDLOOKUPFAILEDUCEERR_BLOCKSFULLUCEERR_MEMORYFAILUREUCEERR_PACKETRECORDOUTOFRANGEUCEERR_ILLEGALRECORDTYPEUCEERR_OUTOFHANDLESUCEERR_UNCHANGABLE_UPDATE_ATTEMPTEDUCEERR_NO_MULTIPLE_WORKER_THREADSUCEERR_REMOTINGNOTSUPPORTEDUCEERR_MISSINGENDCOMMANDUCEERR_MISSINGBEGINCOMMANDUCEERR_CHANNELSYNCTIMEDOUTUCEERR_CHANNELSYNCABANDONEDUCEERR_UNSUPPORTEDTRANSPORTVERSIONUCEERR_TRANSPORTUNAVAILABLEUCEERR_FEEDBACK_UNSUPPORTEDUCEERR_COMMANDTRANSPORTDENIEDUCEERR_GRAPHICSSTREAMUNAVAILABLEUCEERR_GRAPHICSSTREAMALREADYOPENUCEERR_TRANSPORTDISCONNECTEDUCEERR_TRANSPORTOVERLOADEDUCEERR_PARTITION_ZOMBIEDMILAVERR_NOCLOCKMILAVERR_NOMEDIATYPEMILAVERR_NOVIDEOMIXERMILAVERR_NOVIDEOPRESENTERMILAVERR_NOREADYFRAMESMILAVERR_MODULENOTLOADEDMILAVERR_WMPFACTORYNOTREGISTEREDMILAVERR_INVALIDWMPVERSIONMILAVERR_INSUFFICIENTVIDEORESOURCESMILAVERR_VIDEOACCELERATIONNOTAVAILABLEMILAVERR_REQUESTEDTEXTURETOOBIGMILAVERR_SEEKFAILEDMILAVERR_UNEXPECTEDWMPFAILUREMILAVERR_MEDIAPLAYERCLOSEDMILAVERR_UNKNOWNHARDWAREERRORMILEFFECTSERR_UNKNOWNPROPERTYMILEFFECTSERR_EFFECTNOTPARTOFGROUPMILEFFECTSERR_NOINPUTSOURCEATTACHEDMILEFFECTSERR_CONNECTORNOTCONNECTEDMILEFFECTSERR_CONNECTORNOTASSOCIATEDWITHEFFECTMILEFFECTSERR_RESERVEDMILEFFECTSERR_CYCLEDETECTEDMILEFFECTSERR_EFFECTINMORETHANONEGRAPHMILEFFECTSERR_EFFECTALREADYINAGRAPHMILEFFECTSERR_EFFECTHASNOCHILDRENMILEFFECTSERR_ALREADYATTACHEDTOLISTENERMILEFFECTSERR_NOTAFFINETRANSFORMMILEFFECTSERR_EMPTYBOUNDSMILEFFECTSERR_OUTPUTSIZETOOLARGEDWMERR_STATE_TRANSITION_FAILEDDWMERR_THEME_FAILEDDWMERR_CATASTROPHIC_FAILUREDCOMPOSITION_ERROR_WINDOW_ALREADY_COMPOSEDDCOMPOSITION_ERROR_SURFACE_BEING_RENDEREDDCOMPOSITION_ERROR_SURFACE_NOT_BEING_RENDEREDONL_E_INVALID_AUTHENTICATION_TARGETONL_E_ACCESS_DENIED_BY_TOUONL_E_INVALID_APPLICATIONONL_E_PASSWORD_UPDATE_REQUIREDONL_E_ACCOUNT_UPDATE_REQUIREDONL_E_FORCESIGNINONL_E_ACCOUNT_LOCKEDONL_E_PARENTAL_CONSENT_REQUIREDONL_E_EMAIL_VERIFICATION_REQUIREDONL_E_ACCOUNT_SUSPENDED_COMPROIMISEONL_E_ACCOUNT_SUSPENDED_ABUSEONL_E_ACTION_REQUIREDONL_CONNECTION_COUNT_LIMITONL_E_CONNECTED_ACCOUNT_CAN_NOT_SIGNOUTONL_E_USER_AUTHENTICATION_REQUIREDONL_E_REQUEST_THROTTLEDFA_E_MAX_PERSISTED_ITEMS_REACHEDFA_E_HOMEGROUP_NOT_AVAILABLEE_MONITOR_RESOLUTION_TOO_LOWE_ELEVATED_ACTIVATION_NOT_SUPPORTEDE_UAC_DISABLEDE_FULL_ADMIN_NOT_SUPPORTEDE_APPLICATION_NOT_REGISTEREDE_MULTIPLE_EXTENSIONS_FOR_APPLICATIONE_MULTIPLE_PACKAGES_FOR_FAMILYE_APPLICATION_MANAGER_NOT_RUNNINGS_STORE_LAUNCHED_FOR_REMEDIATIONS_APPLICATION_ACTIVATION_ERROR_HANDLED_BY_DIALOGE_APPLICATION_ACTIVATION_TIMED_OUTE_APPLICATION_ACTIVATION_EXEC_FAILUREE_APPLICATION_TEMPORARY_LICENSE_ERRORE_APPLICATION_TRIAL_LICENSE_EXPIREDE_SKYDRIVE_ROOT_TARGET_FILE_SYSTEM_NOT_SUPPORTEDE_SKYDRIVE_ROOT_TARGET_OVERLAPE_SKYDRIVE_ROOT_TARGET_CANNOT_INDEXE_SKYDRIVE_FILE_NOT_UPLOADEDE_SKYDRIVE_UPDATE_AVAILABILITY_FAILE_SKYDRIVE_ROOT_TARGET_VOLUME_ROOT_NOT_SUPPORTEDE_SYNCENGINE_FILE_SIZE_OVER_LIMITE_SYNCENGINE_FILE_SIZE_EXCEEDS_REMAINING_QUOTAE_SYNCENGINE_UNSUPPORTED_FILE_NAMEE_SYNCENGINE_FOLDER_ITEM_COUNT_LIMIT_EXCEEDEDE_SYNCENGINE_FILE_SYNC_PARTNER_ERRORE_SYNCENGINE_SYNC_PAUSED_BY_SERVICEE_SYNCENGINE_FILE_IDENTIFIER_UNKNOWNE_SYNCENGINE_SERVICE_AUTHENTICATION_FAILEDE_SYNCENGINE_UNKNOWN_SERVICE_ERRORE_SYNCENGINE_SERVICE_RETURNED_UNEXPECTED_SIZEE_SYNCENGINE_REQUEST_BLOCKED_BY_SERVICEE_SYNCENGINE_REQUEST_BLOCKED_DUE_TO_CLIENT_ERRORE_SYNCENGINE_FOLDER_INACCESSIBLEE_SYNCENGINE_UNSUPPORTED_FOLDER_NAMEE_SYNCENGINE_UNSUPPORTED_MARKETE_SYNCENGINE_PATH_LENGTH_LIMIT_EXCEEDEDE_SYNCENGINE_REMOTE_PATH_LENGTH_LIMIT_EXCEEDEDE_SYNCENGINE_CLIENT_UPDATE_NEEDEDE_SYNCENGINE_PROXY_AUTHENTICATION_REQUIREDE_SYNCENGINE_STORAGE_SERVICE_PROVISIONING_FAILEDE_SYNCENGINE_UNSUPPORTED_REPARSE_POINTE_SYNCENGINE_STORAGE_SERVICE_BLOCKEDE_SYNCENGINE_FOLDER_IN_REDIRECTIONEAS_E_POLICY_NOT_MANAGED_BY_OSEAS_E_POLICY_COMPLIANT_WITH_ACTIONSEAS_E_REQUESTED_POLICY_NOT_ENFORCEABLEEAS_E_CURRENT_USER_HAS_BLANK_PASSWORDEAS_E_REQUESTED_POLICY_PASSWORD_EXPIRATION_INCOMPATIBLEEAS_E_USER_CANNOT_CHANGE_PASSWORDEAS_E_ADMINS_HAVE_BLANK_PASSWORDEAS_E_ADMINS_CANNOT_CHANGE_PASSWORDEAS_E_LOCAL_CONTROLLED_USERS_CANNOT_CHANGE_PASSWORDEAS_E_PASSWORD_POLICY_NOT_ENFORCEABLE_FOR_CONNECTED_ADMINSEAS_E_CONNECTED_ADMINS_NEED_TO_CHANGE_PASSWORDEAS_E_PASSWORD_POLICY_NOT_ENFORCEABLE_FOR_CURRENT_CONNECTED_USEREAS_E_CURRENT_CONNECTED_USER_NEED_TO_CHANGE_PASSWORDWEB_E_UNSUPPORTED_FORMATWEB_E_INVALID_XMLWEB_E_MISSING_REQUIRED_ELEMENTWEB_E_MISSING_REQUIRED_ATTRIBUTEWEB_E_UNEXPECTED_CONTENTWEB_E_RESOURCE_TOO_LARGEWEB_E_INVALID_JSON_STRINGWEB_E_INVALID_JSON_NUMBERWEB_E_JSON_VALUE_NOT_FOUNDHTTP_E_STATUS_UNEXPECTEDHTTP_E_STATUS_UNEXPECTED_REDIRECTIONHTTP_E_STATUS_UNEXPECTED_CLIENT_ERRORHTTP_E_STATUS_UNEXPECTED_SERVER_ERRORHTTP_E_STATUS_AMBIGUOUSHTTP_E_STATUS_MOVEDHTTP_E_STATUS_REDIRECTHTTP_E_STATUS_REDIRECT_METHODHTTP_E_STATUS_NOT_MODIFIEDHTTP_E_STATUS_USE_PROXYHTTP_E_STATUS_REDIRECT_KEEP_VERBHTTP_E_STATUS_BAD_REQUESTHTTP_E_STATUS_DENIEDHTTP_E_STATUS_PAYMENT_REQHTTP_E_STATUS_FORBIDDENHTTP_E_STATUS_NOT_FOUNDHTTP_E_STATUS_BAD_METHODHTTP_E_STATUS_NONE_ACCEPTABLEHTTP_E_STATUS_PROXY_AUTH_REQHTTP_E_STATUS_REQUEST_TIMEOUTHTTP_E_STATUS_CONFLICTHTTP_E_STATUS_GONEHTTP_E_STATUS_LENGTH_REQUIREDHTTP_E_STATUS_PRECOND_FAILEDHTTP_E_STATUS_REQUEST_TOO_LARGEHTTP_E_STATUS_URI_TOO_LONGHTTP_E_STATUS_UNSUPPORTED_MEDIAHTTP_E_STATUS_RANGE_NOT_SATISFIABLEHTTP_E_STATUS_EXPECTATION_FAILEDHTTP_E_STATUS_SERVER_ERRORHTTP_E_STATUS_NOT_SUPPORTEDHTTP_E_STATUS_BAD_GATEWAYHTTP_E_STATUS_SERVICE_UNAVAILHTTP_E_STATUS_GATEWAY_TIMEOUTHTTP_E_STATUS_VERSION_NOT_SUPE_INVALID_PROTOCOL_OPERATIONE_INVALID_PROTOCOL_FORMATE_PROTOCOL_EXTENSIONS_NOT_SUPPORTEDE_SUBPROTOCOL_NOT_SUPPORTEDE_PROTOCOL_VERSION_NOT_SUPPORTEDINPUT_E_OUT_OF_ORDERINPUT_E_REENTRANCYINPUT_E_MULTIMODALINPUT_E_PACKETINPUT_E_FRAMEINPUT_E_HISTORYINPUT_E_DEVICE_INFOINPUT_E_TRANSFORMINPUT_E_DEVICE_PROPERTYINET_E_INVALID_URLINET_E_NO_SESSIONINET_E_CANNOT_CONNECTINET_E_RESOURCE_NOT_FOUNDINET_E_OBJECT_NOT_FOUNDINET_E_DATA_NOT_AVAILABLEINET_E_DOWNLOAD_FAILUREINET_E_AUTHENTICATION_REQUIREDINET_E_NO_VALID_MEDIAINET_E_CONNECTION_TIMEOUTINET_E_INVALID_REQUESTINET_E_UNKNOWN_PROTOCOLINET_E_SECURITY_PROBLEMINET_E_CANNOT_LOAD_DATAINET_E_CANNOT_INSTANTIATE_OBJECTINET_E_INVALID_CERTIFICATEINET_E_REDIRECT_FAILEDINET_E_REDIRECT_TO_DIRERROR_DBG_CREATE_PROCESS_FAILURE_LOCKDOWNERROR_DBG_ATTACH_PROCESS_FAILURE_LOCKDOWNERROR_DBG_CONNECT_SERVER_FAILURE_LOCKDOWNERROR_DBG_START_SERVER_FAILURE_LOCKDOWNERROR_IO_PREEMPTEDJSCRIPT_E_CANTEXECUTEWEP_E_NOT_PROVISIONED_ON_ALL_VOLUMESWEP_E_FIXED_DATA_NOT_SUPPORTEDWEP_E_HARDWARE_NOT_COMPLIANTWEP_E_LOCK_NOT_CONFIGUREDWEP_E_PROTECTION_SUSPENDEDWEP_E_NO_LICENSEWEP_E_OS_NOT_PROTECTEDWEP_E_UNEXPECTED_FAILWEP_E_BUFFER_TOO_LARGEERROR_SVHDX_ERROR_STOREDERROR_SVHDX_ERROR_NOT_AVAILABLEERROR_SVHDX_UNIT_ATTENTION_AVAILABLEERROR_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGEDERROR_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTEDERROR_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASEDERROR_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTEDERROR_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGEDERROR_SVHDX_RESERVATION_CONFLICTERROR_SVHDX_WRONG_FILE_TYPEERROR_SVHDX_VERSION_MISMATCHERROR_VHD_SHAREDWININET_E_OUT_OF_HANDLESWININET_E_TIMEOUTWININET_E_EXTENDED_ERRORWININET_E_INTERNAL_ERRORWININET_E_INVALID_URLWININET_E_UNRECOGNIZED_SCHEMEWININET_E_NAME_NOT_RESOLVEDWININET_E_PROTOCOL_NOT_FOUNDWININET_E_INVALID_OPTIONWININET_E_BAD_OPTION_LENGTHWININET_E_OPTION_NOT_SETTABLEWININET_E_SHUTDOWNWININET_E_INCORRECT_USER_NAMEWININET_E_INCORRECT_PASSWORDWININET_E_LOGIN_FAILUREWININET_E_INVALID_OPERATIONWININET_E_OPERATION_CANCELLEDWININET_E_INCORRECT_HANDLE_TYPEWININET_E_INCORRECT_HANDLE_STATEWININET_E_NOT_PROXY_REQUESTWININET_E_REGISTRY_VALUE_NOT_FOUNDWININET_E_BAD_REGISTRY_PARAMETERWININET_E_NO_DIRECT_ACCESSWININET_E_NO_CONTEXTWININET_E_NO_CALLBACKWININET_E_REQUEST_PENDINGWININET_E_INCORRECT_FORMATWININET_E_ITEM_NOT_FOUNDWININET_E_CANNOT_CONNECTWININET_E_CONNECTION_ABORTEDWININET_E_CONNECTION_RESETWININET_E_FORCE_RETRYWININET_E_INVALID_PROXY_REQUESTWININET_E_NEED_UIWININET_E_HANDLE_EXISTSWININET_E_SEC_CERT_DATE_INVALIDWININET_E_SEC_CERT_CN_INVALIDWININET_E_HTTP_TO_HTTPS_ON_REDIRWININET_E_HTTPS_TO_HTTP_ON_REDIRWININET_E_MIXED_SECURITYWININET_E_CHG_POST_IS_NON_SECUREWININET_E_POST_IS_NON_SECUREWININET_E_CLIENT_AUTH_CERT_NEEDEDWININET_E_INVALID_CAWININET_E_CLIENT_AUTH_NOT_SETUPWININET_E_ASYNC_THREAD_FAILEDWININET_E_REDIRECT_SCHEME_CHANGEWININET_E_DIALOG_PENDINGWININET_E_RETRY_DIALOGWININET_E_NO_NEW_CONTAINERSWININET_E_HTTPS_HTTP_SUBMIT_REDIRWININET_E_SEC_CERT_ERRORSWININET_E_SEC_CERT_REV_FAILEDWININET_E_HEADER_NOT_FOUNDWININET_E_DOWNLEVEL_SERVERWININET_E_INVALID_SERVER_RESPONSEWININET_E_INVALID_HEADERWININET_E_INVALID_QUERY_REQUESTWININET_E_HEADER_ALREADY_EXISTSWININET_E_REDIRECT_FAILEDWININET_E_SECURITY_CHANNEL_ERRORWININET_E_UNABLE_TO_CACHE_FILEWININET_E_TCPIP_NOT_INSTALLEDWININET_E_DISCONNECTEDWININET_E_SERVER_UNREACHABLEWININET_E_PROXY_SERVER_UNREACHABLEWININET_E_BAD_AUTO_PROXY_SCRIPTWININET_E_UNABLE_TO_DOWNLOAD_SCRIPTWININET_E_SEC_INVALID_CERTWININET_E_SEC_CERT_REVOKEDWININET_E_FAILED_DUETOSECURITYCHECKWININET_E_NOT_INITIALIZEDWININET_E_LOGIN_FAILURE_DISPLAY_ENTITY_BODYWININET_E_DECODING_FAILEDWININET_E_NOT_REDIRECTEDWININET_E_COOKIE_NEEDS_CONFIRMATIONWININET_E_COOKIE_DECLINEDWININET_E_REDIRECT_NEEDS_CONFIRMATION//! error code definitions for the Win32 API functionsUSBD_PIPE_TYPESHORT_PACKET_TERMINATEAUTO_CLEAR_STALLPIPE_TRANSFER_TIMEOUTIGNORE_SHORT_PACKETSALLOW_PARTIAL_READSAUTO_FLUSHRAW_IOMAXIMUM_TRANSFER_SIZERESET_PIPE_ON_RESUMEDEVICE_SPEEDLowSpeedFullSpeedHighSpeedPWINUSB_PIPE_INFORMATIONWINUSB_PIPE_INFORMATIONPWINUSB_PIPE_INFORMATION_EXWINUSB_PIPE_INFORMATION_EX//! Public header for WINUSBPDOT11_BSS_TYPEDOT11_SSID_MAX_LENGTHPDOT11_SSIDPDOT11_AUTH_ALGORITHMDOT11_AUTH_ALGORITHM_OPEN_SYSTEMDOT11_AUTH_ALGORITHM_SHARED_KEYDOT11_AUTH_ALGORITHM_WPADOT11_AUTH_ALGORITHM_WPA_PSKDOT11_AUTH_ALGORITHM_WPA_NONEDOT11_AUTH_ALGORITHM_RSNADOT11_AUTH_ALGORITHM_RSNA_PSKPDOT11_CIPHER_ALGORITHMDOT11_OI_MAX_LENGTHDOT11_OI_MIN_LENGTHPDOT11_OIDOT11_OIPDOT11_ACCESSNETWORKOPTIONSDOT11_ACCESSNETWORKOPTIONSPDOT11_VENUEINFODOT11_VENUEINFO//! Structures used to hold wlan information.STANDARD_RIGHTS_READPWNODE_HEADERWNODE_FLAG_ALL_DATAWNODE_FLAG_SINGLE_INSTANCEWNODE_FLAG_SINGLE_ITEMWNODE_FLAG_EVENT_ITEMWNODE_FLAG_FIXED_INSTANCE_SIZEWNODE_FLAG_TOO_SMALLWNODE_FLAG_INSTANCES_SAMEWNODE_FLAG_STATIC_INSTANCE_NAMESWNODE_FLAG_INTERNALWNODE_FLAG_USE_TIMESTAMPWNODE_FLAG_PERSIST_EVENTWNODE_FLAG_EVENT_REFERENCEWNODE_FLAG_ANSI_INSTANCENAMESWNODE_FLAG_METHOD_ITEMWNODE_FLAG_PDO_INSTANCE_NAMESWNODE_FLAG_TRACED_GUIDWNODE_FLAG_LOG_WNODEWNODE_FLAG_USE_GUID_PTRWNODE_FLAG_USE_MOF_PTRWNODE_FLAG_NO_HEADERWNODE_FLAG_SEND_DATA_BLOCKWNODE_FLAG_VERSIONED_PROPERTIESWNODE_FLAG_SEVERITY_MASKPOFFSETINSTANCEDATAANDLENGTHOFFSETINSTANCEDATAANDLENGTHPWNODE_ALL_DATAWNODE_ALL_DATAPWNODE_SINGLE_INSTANCEWNODE_SINGLE_INSTANCEPWNODE_SINGLE_ITEMWNODE_SINGLE_ITEMPWNODE_METHOD_ITEMWNODE_METHOD_ITEMPWNODE_EVENT_ITEMWNODE_EVENT_ITEMPWNODE_EVENT_REFERENCEWNODE_EVENT_REFERENCEPWNODE_TOO_SMALLWNODE_TOO_SMALLPWMIREGGUIDWWMIREGGUIDWWMIREG_FLAG_EXPENSIVEWMIREG_FLAG_INSTANCE_LISTWMIREG_FLAG_INSTANCE_BASENAMEWMIREG_FLAG_INSTANCE_PDOWMIREG_FLAG_REMOVE_GUIDWMIREG_FLAG_RESERVED1WMIREG_FLAG_RESERVED2WMIREG_FLAG_TRACED_GUIDWMIREG_FLAG_TRACE_CONTROL_GUIDWMIREG_FLAG_EVENT_ONLY_GUIDPWMIREGINFOWWMIREGINFOWWMI_GUIDTYPE_TRACECONTROLWMI_GUIDTYPE_TRACEWMI_GUIDTYPE_DATAWMI_GUIDTYPE_EVENTWMIGUID_QUERYWMIGUID_SETWMIGUID_NOTIFICATIONWMIGUID_READ_DESCRIPTIONWMIGUID_EXECUTETRACELOG_CREATE_REALTIMETRACELOG_CREATE_ONDISKTRACELOG_GUID_ENABLETRACELOG_ACCESS_KERNEL_LOGGERTRACELOG_LOG_EVENTTRACELOG_CREATE_INPROCTRACELOG_ACCESS_REALTIMETRACELOG_REGISTER_GUIDSTRACELOG_JOIN_GROUPWMIGUID_ALL_ACCESS_WIN2KWMIGUID_ALL_ACCESS_WINXPWMIGUID_ALL_ACCESS_RS1WMIGUID_ALL_ACCESSWMI_GLOBAL_LOGGER_IDWNNC_NET_MSNETWNNC_NET_SMBWNNC_NET_NETWAREWNNC_NET_VINESWNNC_NET_10NETWNNC_NET_LOCUSWNNC_NET_SUN_PC_NFSWNNC_NET_LANSTEPWNNC_NET_9TILESWNNC_NET_LANTASTICWNNC_NET_AS400WNNC_NET_FTP_NFSWNNC_NET_PATHWORKSWNNC_NET_LIFENETWNNC_NET_POWERLANWNNC_NET_BWNFSWNNC_NET_COGENTWNNC_NET_FARALLONWNNC_NET_APPLETALKWNNC_NET_INTERGRAPHWNNC_NET_SYMFONETWNNC_NET_CLEARCASEWNNC_NET_FRONTIERWNNC_NET_BMCWNNC_NET_DCEWNNC_NET_AVIDWNNC_NET_DOCUSPACEWNNC_NET_MANGOSOFTWNNC_NET_SERNETWNNC_NET_RIVERFRONT1WNNC_NET_RIVERFRONT2WNNC_NET_DECORBWNNC_NET_PROTSTORWNNC_NET_FJ_REDIRWNNC_NET_DISTINCTWNNC_NET_TWINSWNNC_NET_RDR2SAMPLEWNNC_NET_CSCWNNC_NET_3IN1WNNC_NET_EXTENDNETWNNC_NET_STACWNNC_NET_FOXBATWNNC_NET_YAHOOWNNC_NET_EXIFSWNNC_NET_DAVWNNC_NET_KNOWAREWNNC_NET_OBJECT_DIREWNNC_NET_MASFAXWNNC_NET_HOB_NFSWNNC_NET_SHIVAWNNC_NET_IBMALWNNC_NET_LOCKWNNC_NET_TERMSRVWNNC_NET_SRTWNNC_NET_QUINCYWNNC_NET_OPENAFSWNNC_NET_AVID1WNNC_NET_DFSWNNC_NET_KWNPWNNC_NET_ZENWORKSWNNC_NET_DRIVEONWEBWNNC_NET_VMWAREWNNC_NET_RSFXWNNC_NET_MFILESWNNC_NET_MS_NFSWNNC_NET_GOOGLEWNNC_NET_NDFSWNNC_NET_DOCUSHAREWNNC_CRED_MANAGERWNNC_NET_LANMAN//! Provides the Windows Networking WNNC_NET definitions to winnetwk.h and the IFS Kit.AF_VOICEVIEWAF_FIREFOXAF_UNKNOWN1AF_BANAF_CLUSTERAF_12844AF_NETDESAF_TCNPROCESSAF_TCNMESSAGEAF_ICLFXBMAF_BTHAF_HYPERVSO_DONTLINGERSO_EXCLUSIVEADDRUSESO_BSP_STATESO_GROUP_IDSO_GROUP_PRIORITYSO_MAX_MSG_SIZESO_CONDITIONAL_ACCEPTSO_PAUSE_ACCEPTSO_COMPARTMENT_IDSO_RANDOMIZE_PORTSO_PORT_SCALABILITYSO_REUSE_UNICASTPORTSO_REUSE_MULTICASTPORTWSK_SO_BASEPSOCKADDRLPSOCKADDRPSOCKET_ADDRESSLPSOCKET_ADDRESSPSOCKET_ADDRESS_LISTSOCKET_ADDRESS_LISTLPSOCKET_ADDRESS_LISTPCSADDR_INFOCSADDR_INFOLPCSADDR_INFOPSOCKADDR_STORAGE_LHSOCKADDR_STORAGE_LHLPSOCKADDR_STORAGE_LHPSOCKADDR_STORAGE_XPSOCKADDR_STORAGE_XPLPSOCKADDR_STORAGE_XPPSOCKADDR_STORAGELPSOCKADDR_STORAGEPSOCKET_PROCESSOR_AFFINITYSOCKET_PROCESSOR_AFFINITYIOC_UNIXIOC_WS2IOC_PROTOCOLIOC_WSKSIO_ASSOCIATE_HANDLESIO_ENABLE_CIRCULAR_QUEUEINGSIO_FIND_ROUTESIO_FLUSHSIO_GET_BROADCAST_ADDRESSSIO_GET_EXTENSION_FUNCTION_POINTERSIO_GET_QOSSIO_GET_GROUP_QOSSIO_MULTIPOINT_LOOPBACKSIO_MULTICAST_SCOPESIO_SET_QOSSIO_SET_GROUP_QOSSIO_TRANSLATE_HANDLESIO_ROUTING_INTERFACE_QUERYSIO_ROUTING_INTERFACE_CHANGESIO_ADDRESS_LIST_QUERYSIO_ADDRESS_LIST_CHANGESIO_QUERY_TARGET_PNP_HANDLESIO_QUERY_RSS_PROCESSOR_INFOSIO_ADDRESS_LIST_SORTSIO_RESERVED_1SIO_RESERVED_2SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTERPIPPROTOIPPROTOIPPORT_TCPMUXIPPORT_QOTDIPPORT_MSPIPPORT_CHARGENIPPORT_FTP_DATAIPPORT_POP3IPPORT_NTPIPPORT_EPMAPIPPORT_NETBIOS_NSIPPORT_NETBIOS_DGMIPPORT_NETBIOS_SSNIPPORT_IMAPIPPORT_SNMPIPPORT_SNMP_TRAPIPPORT_IMAP3IPPORT_LDAPIPPORT_HTTPSIPPORT_MICROSOFT_DSIPPORT_REGISTERED_MINIPPORT_REGISTERED_MAXIPPORT_DYNAMIC_MINIPPORT_DYNAMIC_MAXIN_CLASSAIN_CLASSBIN_CLASSCIN_CLASSDIN_CLASSD_NETIN_CLASSD_NSHIFTIN_CLASSD_HOSTIN_MULTICASTPSCOPE_IDPSOCKADDR_INPSOCKADDR_DLSOCKADDR_DLLPWSABUFPWSAMSGLPWSAMSGPWSACMSGHDRWSACMSGHDRLPWSACMSGHDRPCMSGHDRAI_DNS_ONLYAI_NON_AUTHORITATIVEAI_SECUREAI_RETURN_PREFERRED_NAMESAI_FILESERVERAI_DISABLE_IDN_ENCODINGAI_EXTENDEDAI_RESOLUTION_HANDLEPADDRINFOAPADDRINFOWADDRINFOWPADDRINFOEXAADDRINFOEXALPADDRINFOEXAPADDRINFOEXWADDRINFOEXWLPADDRINFOEXWADDRINFOEX_VERSION_2ADDRINFOEX_VERSION_3ADDRINFOEX_VERSION_4PADDRINFOEX2AADDRINFOEX2ALPADDRINFOEX2APADDRINFOEX2WADDRINFOEX2WLPADDRINFOEX2WPADDRINFOEX3AADDRINFOEX3ALPADDRINFOEX3APADDRINFOEX3WADDRINFOEX3WLPADDRINFOEX3WPADDRINFOEX4ADDRINFOEX4LPADDRINFOEX4NS_ALLNS_SAPNS_NDSNS_PEER_BROWSENS_SLPNS_DHCPNS_TCPIP_LOCALNS_TCPIP_HOSTSNS_DNSNS_NETBTNS_WINSNS_NLANS_BTHNS_NBPNS_MSNS_STDANS_NTDSNS_EMAILNS_PNRPNAMENS_PNRPCLOUDNS_X500NS_NISNS_NISPLUSNS_WRQNS_NETDES//! Core definitions for the Winsock2 specificationIFF_POINTTOPOINTIP_DONTFRAGMENTIP_RECEIVE_BROADCASTPSOCKADDR_IN6_LHPSOCKADDR_IN6SOCKADDR_IN6_PAIRPSOCKADDR_INETPIP_MREQPIP_MREQ_SOURCEIPV6_PROTECTION_LEVELIPV6_RECVIFIPV6_RECVDSTADDRIPV6_IFLISTIPV6_ADD_IFLISTIPV6_DEL_IFLISTPIPV6_MREQPIN_PKTINFOIN_PKTINFOPIN6_PKTINFOIN6_PKTINFO//! TCP/IP specific information for use by WinSock2 compatible applications.BYTE_BLOBDWORD_BLOBFLAGGED_BYTE_BLOBFLAGGED_WORD_BLOBLPOLESTRLOGPALETTE// extern RPC_IF_HANDLE __MIDL_itf_wtypes_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wtypes_0000_0000_v0_0_s_ifspec;ROTFLAGS_REGISTRATIONKEEPSALIVEROTFLAGS_ALLOWANYCLIENTROT_COMPARE_MAXHCONTEXTWDT_INPROC_CALLWDT_REMOTE_CALLWDT_INPROC64_CALLwireCLIPFORMATuserCLIPFORMATCLIPFORMATwireHGLOBALuserHGLOBALwireHWNDRemotableHandlewireHMENUwireHACCELwireHBRUSHwireHFONTwireHDCwireHICONwireHRGNwireHMONITORwireHBITMAPuserHBITMAPwireHPALETTEuserHPALETTEwireHENHMETAFILEuserHENHMETAFILEwireHMETAFILEuserHMETAFILEwireHMETAFILEPICTuserHMETAFILEPICTHMETAFILEPICT// extern RPC_IF_HANDLE IWinTypes_v0_1_c_ifspec;// extern RPC_IF_HANDLE IWinTypes_v0_1_s_ifspec;LPCYCYDECIMAL_NEGDECIMAL_SETZERODECIMALLPDECIMALwireBSTRLPBSTRVARIANT_BOOLLPBSTRBLOBBSTRBLOBVARIANT_TRUEVARIANT_FALSECBPCLIPDATACLIPDATAVARTYPEPROPID// extern RPC_IF_HANDLE __MIDL_itf_wtypes_0000_0001_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wtypes_0000_0001_v0_0_s_ifspec;PSCODEROTREGFLAGS_ALLOWANYCLIENTAPPIDREGFLAGS_ACTIVATE_IUSERVER_INDESKTOPAPPIDREGFLAGS_SECURE_SERVER_PROCESS_SD_AND_BINDAPPIDREGFLAGS_ISSUE_ACTIVATION_RPC_AT_IDENTIFYAPPIDREGFLAGS_IUSERVER_UNMODIFIED_LOGON_TOKENAPPIDREGFLAGS_IUSERVER_SELF_SID_IN_LAUNCH_PERMISSIONAPPIDREGFLAGS_IUSERVER_ACTIVATE_IN_CLIENT_SESSION_ONLYAPPIDREGFLAGS_RESERVED1APPIDREGFLAGS_RESERVED2APPIDREGFLAGS_RESERVED3APPIDREGFLAGS_RESERVED4APPIDREGFLAGS_RESERVED5APPIDREGFLAGS_RESERVED6DCOMSCM_ACTIVATION_USE_ALL_AUTHNSERVICESDCOMSCM_ACTIVATION_DISALLOW_UNSECURE_CALLDCOMSCM_RESOLVE_USE_ALL_AUTHNSERVICESDCOMSCM_RESOLVE_DISALLOW_UNSECURE_CALLDCOMSCM_PING_USE_MID_AUTHNSERVICEDCOMSCM_PING_DISALLOW_UNSECURE_CALLCLSCTX_VALID_MASKUP_BYTE_BLOBUP_WORD_BLOBWORD_BLOBUP_DWORD_BLOBUP_FLAGGED_BYTE_BLOBUP_FLAGGED_WORD_BLOBLPBLOB// #include <time.h>// #include <vcruntime.h>corecrt// Headers for the universal C RuntimeAccFreePOBJECTS_AND_SIDOBJECTS_AND_SIDPOBJECTS_AND_NAME_AOBJECTS_AND_NAME_APOBJECTS_AND_NAME_WOBJECTS_AND_NAME_WPTRUSTEE_ATRUSTEE_ATRUSTEEAPTRUSTEEAPTRUSTEE_WTRUSTEE_WTRUSTEEWPTRUSTEEWNO_INHERITANCESUB_OBJECTS_ONLY_INHERITSUB_CONTAINERS_ONLY_INHERITSUB_CONTAINERS_AND_OBJECTS_INHERITINHERIT_NO_PROPAGATEINHERIT_ONLYINHERITED_ACCESS_ENTRYINHERITED_PARENTINHERITED_GRANDPARENTPEXPLICIT_ACCESS_AEXPLICIT_ACCESS_AEXPLICIT_ACCESSAPEXPLICIT_ACCESSAPEXPLICIT_ACCESS_WEXPLICIT_ACCESSWPEXPLICIT_ACCESSWACCCTRL_DEFAULT_PROVIDERACCESS_RIGHTSPACCESS_RIGHTSINHERIT_FLAGSPINHERIT_FLAGSPACTRL_ACCESS_ENTRYAACTRL_ACCESS_ENTRYAPACTRL_ACCESS_ENTRYWACTRL_ACCESS_ENTRYWPACTRL_ACCESS_ENTRY_LISTAACTRL_ACCESS_ENTRY_LISTAPACTRL_ACCESS_ENTRY_LISTWACTRL_ACCESS_ENTRY_LISTWPACTRL_PROPERTY_ENTRYAACTRL_PROPERTY_ENTRYAPACTRL_PROPERTY_ENTRYWACTRL_PROPERTY_ENTRYWPACTRL_ACCESSAACTRL_ACCESSAACTRL_AUDITAPACTRL_AUDITAPACTRL_ACCESSWACTRL_ACCESSWACTRL_AUDITWPACTRL_AUDITWTRUSTEE_ACCESS_ALLOWEDTRUSTEE_ACCESS_READTRUSTEE_ACCESS_WRITETRUSTEE_ACCESS_EXPLICITTRUSTEE_ACCESS_READ_WRITETRUSTEE_ACCESS_ALLPTRUSTEE_ACCESSATRUSTEE_ACCESSAPTRUSTEE_ACCESSWTRUSTEE_ACCESSWACTRL_RESERVEDACTRL_PERM_1ACTRL_PERM_2ACTRL_PERM_3ACTRL_PERM_4ACTRL_PERM_5ACTRL_PERM_6ACTRL_PERM_7ACTRL_PERM_8ACTRL_PERM_9ACTRL_PERM_10ACTRL_PERM_11ACTRL_PERM_12ACTRL_PERM_13ACTRL_PERM_14ACTRL_PERM_15ACTRL_PERM_16ACTRL_PERM_17ACTRL_PERM_18ACTRL_PERM_19ACTRL_PERM_20ACTRL_ACCESS_ALLOWEDACTRL_ACCESS_DENIEDACTRL_AUDIT_SUCCESSACTRL_AUDIT_FAILUREACTRL_ACCESS_PROTECTEDACTRL_SYSTEM_ACCESSACTRL_DELETEACTRL_READ_CONTROLACTRL_CHANGE_ACCESSACTRL_CHANGE_OWNERACTRL_SYNCHRONIZEACTRL_STD_RIGHTS_ALLACTRL_STD_RIGHT_REQUIREDACTRL_DS_OPENACTRL_DS_CREATE_CHILDACTRL_DS_DELETE_CHILDACTRL_DS_LISTACTRL_DS_SELFACTRL_DS_READ_PROPACTRL_DS_WRITE_PROPACTRL_DS_DELETE_TREEACTRL_DS_LIST_OBJECTACTRL_DS_CONTROL_ACCESSACTRL_FILE_READACTRL_FILE_WRITEACTRL_FILE_APPENDACTRL_FILE_READ_PROPACTRL_FILE_WRITE_PROPACTRL_FILE_EXECUTEACTRL_FILE_READ_ATTRIBACTRL_FILE_WRITE_ATTRIBACTRL_FILE_CREATE_PIPEACTRL_DIR_LISTACTRL_DIR_CREATE_OBJECTACTRL_DIR_CREATE_CHILDACTRL_DIR_DELETE_CHILDACTRL_DIR_TRAVERSEACTRL_KERNEL_TERMINATEACTRL_KERNEL_THREADACTRL_KERNEL_VMACTRL_KERNEL_VM_READACTRL_KERNEL_VM_WRITEACTRL_KERNEL_DUP_HANDLEACTRL_KERNEL_PROCESSACTRL_KERNEL_SET_INFOACTRL_KERNEL_GET_INFOACTRL_KERNEL_CONTROLACTRL_KERNEL_ALERTACTRL_KERNEL_GET_CONTEXTACTRL_KERNEL_SET_CONTEXTACTRL_KERNEL_TOKENACTRL_KERNEL_IMPERSONATEACTRL_KERNEL_DIMPERSONATEACTRL_PRINT_SADMINACTRL_PRINT_SLISTACTRL_PRINT_PADMINACTRL_PRINT_PUSEACTRL_PRINT_JADMINACTRL_SVC_GET_INFOACTRL_SVC_SET_INFOACTRL_SVC_STATUSACTRL_SVC_LISTACTRL_SVC_STARTACTRL_SVC_STOPACTRL_SVC_PAUSEACTRL_SVC_INTERROGATEACTRL_SVC_UCONTROLACTRL_REG_QUERYACTRL_REG_SETACTRL_REG_CREATE_CHILDACTRL_REG_LISTACTRL_REG_NOTIFYACTRL_REG_LINKACTRL_WIN_CLIPBRDACTRL_WIN_GLOBAL_ATOMSACTRL_WIN_CREATEACTRL_WIN_LIST_DESKACTRL_WIN_LISTACTRL_WIN_READ_ATTRIBSACTRL_WIN_WRITE_ATTRIBSACTRL_WIN_SCREENACTRL_WIN_EXITPACTRL_OVERLAPPEDACTRL_OVERLAPPEDPACTRL_ACCESS_INFOAACTRL_ACCESS_INFOAPACTRL_ACCESS_INFOWACTRL_ACCESS_INFOWPACTRL_CONTROL_INFOAACTRL_CONTROL_INFOAPACTRL_CONTROL_INFOWACTRL_CONTROL_INFOWACTRL_ACCESS_NO_OPTIONSACTRL_ACCESS_SUPPORTS_OBJECT_ENTRIESTREE_SEC_INFO_SETTREE_SEC_INFO_RESETTREE_SEC_INFO_RESET_KEEP_EXPLICITPPROG_INVOKE_SETTINGPROG_INVOKE_SETTINGPFN_OBJECT_MGR_FUNCTSFN_OBJECT_MGR_FUNCTSPINHERITED_FROMAINHERITED_FROMAPINHERITED_FROMWINHERITED_FROMWACCESS_MODEMULTIPLE_TRUSTEE_OPERATIONSE_OBJECT_TYPETRUSTEE_FORMTRUSTEE_TYPEPACCESS_MASKPGENERIC_MAPPINGSetEntriesInAclASetEntriesInAclWGetExplicitEntriesFromAclAGetExplicitEntriesFromAclWGetEffectiveRightsFromAclAGetEffectiveRightsFromAclWGetAuditedPermissionsFromAclAGetAuditedPermissionsFromAclWGetNamedSecurityInfoAGetNamedSecurityInfoWGetSecurityInfoSetNamedSecurityInfoASetNamedSecurityInfoWSetSecurityInfoGetInheritanceSourceAGetInheritanceSourceWFreeInheritedFromArrayTreeResetNamedSecurityInfoAFN_PROGRESSTreeResetNamedSecurityInfoWTreeSetNamedSecurityInfoATreeSetNamedSecurityInfoWBuildSecurityDescriptorABuildSecurityDescriptorWLookupSecurityDescriptorPartsALookupSecurityDescriptorPartsWBuildExplicitAccessWithNameABuildExplicitAccessWithNameWBuildImpersonateExplicitAccessWithNameABuildImpersonateExplicitAccessWithNameWBuildTrusteeWithNameABuildTrusteeWithNameWBuildImpersonateTrusteeABuildImpersonateTrusteeWBuildTrusteeWithSidABuildTrusteeWithSidWBuildTrusteeWithObjectsAndSidABuildTrusteeWithObjectsAndSidWBuildTrusteeWithObjectsAndNameABuildTrusteeWithObjectsAndNameWGetTrusteeNameAGetTrusteeNameWGetTrusteeTypeAGetTrusteeTypeWGetTrusteeFormAGetTrusteeFormWGetMultipleTrusteeOperationAGetMultipleTrusteeOperationWGetMultipleTrusteeAGetMultipleTrusteeWPINSTALLDATAINSTALLDATALOCALSTATE_ASSIGNEDLOCALSTATE_PUBLISHEDLOCALSTATE_UNINSTALL_UNMANAGEDLOCALSTATE_POLICYREMOVE_ORPHANLOCALSTATE_POLICYREMOVE_UNINSTALLLOCALSTATE_ORPHANEDLOCALSTATE_UNINSTALLEDPLOCALMANAGEDAPPLICATIONLOCALMANAGEDAPPLICATIONMANAGED_APPS_USERAPPLICATIONSMANAGED_APPS_FROMCATEGORYMANAGED_APPS_INFOLEVEL_DEFAULTMANAGED_APPTYPE_WINDOWSINSTALLERMANAGED_APPTYPE_SETUPEXEMANAGED_APPTYPE_UNSUPPORTEDPMANAGEDAPPLICATIONMANAGEDAPPLICATIONInstallApplicationUninstallApplicationCommandLineFromMsiDescriptorGetManagedApplicationsGetLocalManagedApplicationsGetLocalManagedApplicationDataGetManagedApplicationCategoriesAPPCATEGORYINFOLISTWAVEFORMATEXaudiosessiontypesAUDCLNT_SHAREMODEstrmifREFERENCE_TIMEAUDCLNT_E_NOT_INITIALIZED//1627AUDCLNT_E_ALREADY_INITIALIZEDAUDCLNT_E_WRONG_ENDPOINT_TYPEAUDCLNT_E_DEVICE_INVALIDATEDAUDCLNT_E_NOT_STOPPEDAUDCLNT_E_BUFFER_TOO_LARGEAUDCLNT_E_OUT_OF_ORDERAUDCLNT_E_UNSUPPORTED_FORMATAUDCLNT_E_INVALID_SIZEAUDCLNT_E_DEVICE_IN_USEAUDCLNT_E_BUFFER_OPERATION_PENDINGAUDCLNT_E_THREAD_NOT_REGISTEREDAUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWEDAUDCLNT_E_ENDPOINT_CREATE_FAILEDAUDCLNT_E_SERVICE_NOT_RUNNINGAUDCLNT_E_EVENTHANDLE_NOT_EXPECTEDAUDCLNT_E_EXCLUSIVE_MODE_ONLYAUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUALAUDCLNT_E_EVENTHANDLE_NOT_SETAUDCLNT_E_INCORRECT_BUFFER_SIZEAUDCLNT_E_BUFFER_SIZE_ERRORAUDCLNT_E_CPUUSAGE_EXCEEDEDAUDCLNT_E_BUFFER_ERRORAUDCLNT_E_BUFFER_SIZE_NOT_ALIGNEDAUDCLNT_E_INVALID_DEVICE_PERIODAUDCLNT_E_INVALID_STREAM_FLAGAUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLEAUDCLNT_E_OUT_OF_OFFLOAD_RESOURCESAUDCLNT_E_OFFLOAD_MODE_ONLYAUDCLNT_E_NONOFFLOAD_MODE_ONLYAUDCLNT_E_RESOURCES_INVALIDATEDAUDCLNT_E_RAW_MODE_UNSUPPORTEDAUDCLNT_S_BUFFER_EMPTYAUDCLNT_S_THREAD_ALREADY_REGISTEREDAUDCLNT_S_POSITION_STALLED//! this ALWAYS GENERATED file contains the definitions for the interfacesAUDCLNT_STREAMFLAGS_CROSSPROCESSAUDCLNT_STREAMFLAGS_LOOPBACKAUDCLNT_STREAMFLAGS_EVENTCALLBACKAUDCLNT_STREAMFLAGS_NOPERSISTAUDCLNT_STREAMFLAGS_RATEADJUSTAUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNEDAUDCLNT_SESSIONFLAGS_DISPLAY_HIDEAUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIREDTHREAD_ORDER_GROUP_INFINITE_TIMEOUTAvSetMmThreadCharacteristicsAAvSetMmThreadCharacteristicsWAvSetMmMaxThreadCharacteristicsAAvSetMmMaxThreadCharacteristicsWAvRevertMmThreadCharacteristicsAvSetMmThreadPriorityAVRT_PRIORITYAvRtCreateThreadOrderingGroupAvRtCreateThreadOrderingGroupExAAvRtCreateThreadOrderingGroupExWAvRtJoinThreadOrderingGroupAvRtWaitOnThreadOrderingGroupAvRtLeaveThreadOrderingGroupAvRtDeleteThreadOrderingGroupAvQuerySystemResponsivenessBG_SIZE_UNKNOWNBG_NOTIFY_JOB_TRANSFERREDBG_NOTIFY_JOB_ERRORBG_NOTIFY_DISABLEBG_NOTIFY_JOB_MODIFICATIONBG_NOTIFY_FILE_TRANSFERREDBG_NOTIFY_FILE_RANGES_TRANSFERREDBG_JOB_ENUM_ALL_USERSIBackgroundCopyFileIBackgroundCopyJobbits2_0BG_FILE_RANGEbits3_0IBackgroundCopyCallback2IBackgroundCopyCallback2Vtblbits5_0IBackgroundCopyFile5IBackgroundCopyFile5VtblIBackgroundCopyJobVtblPBG_AUTH_CREDENTIALSBG_AUTH_CREDENTIALSIBackgroundCopyFileVtblbits1_5IBackgroundCopyJob2IBackgroundCopyJob2VtblBG_LENGTH_TO_EOFBG_COPY_FILE_OWNERBG_COPY_FILE_GROUPBG_COPY_FILE_DACLBG_COPY_FILE_SACLBG_COPY_FILE_ALLBG_SSL_ENABLE_CRL_CHECKBG_SSL_IGNORE_CERT_CN_INVALIDBG_SSL_IGNORE_CERT_DATE_INVALIDBG_SSL_IGNORE_UNKNOWN_CABG_SSL_IGNORE_CERT_WRONG_USAGEBG_HTTP_REDIRECT_POLICY_MASKBG_HTTP_REDIRECT_POLICY_ALLOW_SILENTBG_HTTP_REDIRECT_POLICY_ALLOW_REPORTBG_HTTP_REDIRECT_POLICY_DISALLOWBG_HTTP_REDIRECT_POLICY_ALLOW_HTTPS_TO_HTTPIBackgroundCopyCallbackIBackgroundCopyCallbackVtblIBackgroundCopyFile2IBackgroundCopyFile2VtblIBackgroundCopyJob3IBackgroundCopyJob3VtblBG_ENABLE_PEERCACHING_CLIENTBG_ENABLE_PEERCACHING_SERVERBG_DISABLE_BRANCH_CACHEBG_JOB_ENABLE_PEERCACHING_CLIENTBG_JOB_ENABLE_PEERCACHING_SERVERBG_JOB_DISABLE_BRANCH_CACHEIBackgroundCopyFile3IBackgroundCopyFile3VtblBG_AUTH_TARGETIBackgroundCopyJob4IBackgroundCopyJob4Vtblbits4_0IBackgroundCopyFile4IBackgroundCopyFile4VtblBITS_COST_STATE_UNRESTRICTEDBITS_COST_STATE_CAPPED_USAGE_UNKNOWNBITS_COST_STATE_BELOW_CAPBITS_COST_STATE_NEAR_CAPBITS_COST_STATE_OVERCAP_CHARGEDBITS_COST_STATE_OVERCAP_THROTTLEDBITS_COST_STATE_USAGE_BASEDBITS_COST_STATE_ROAMINGBITS_COST_OPTION_IGNORE_CONGESTIONBITS_COST_STATE_RESERVEDBITS_COST_STATE_TRANSFER_NOT_ROAMINGBITS_COST_STATE_TRANSFER_NO_SURCHARGEBITS_COST_STATE_TRANSFER_STANDARDBITS_COST_STATE_TRANSFER_UNRESTRICTEDBITS_COST_STATE_TRANSFER_ALWAYSoaidlIDispatchIDispatchVtblBSTR_UserSizeBSTR_UserMarshalBSTR_UserUnmarshalBSTR_UserFreeBSTR_UserSize64BSTR_UserMarshal64BSTR_UserUnmarshal64BSTR_UserFree64BG_E_NOT_FOUNDBG_E_INVALID_STATEBG_E_EMPTYBG_E_FILE_NOT_AVAILABLEBG_E_PROTOCOL_NOT_AVAILABLEBG_S_ERROR_CONTEXT_NONEBG_E_ERROR_CONTEXT_UNKNOWNBG_E_ERROR_CONTEXT_GENERAL_QUEUE_MANAGERBG_E_ERROR_CONTEXT_LOCAL_FILEBG_E_ERROR_CONTEXT_REMOTE_FILEBG_E_ERROR_CONTEXT_GENERAL_TRANSPORTBG_E_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATIONBG_E_DESTINATION_LOCKEDBG_E_VOLUME_CHANGEDBG_E_ERROR_INFORMATION_UNAVAILABLEBG_E_NETWORK_DISCONNECTEDBG_E_MISSING_FILE_SIZEBG_E_INSUFFICIENT_HTTP_SUPPORTBG_E_INSUFFICIENT_RANGE_SUPPORTBG_E_REMOTE_NOT_SUPPORTEDBG_E_NEW_OWNER_DIFF_MAPPINGBG_E_NEW_OWNER_NO_FILE_ACCESSBG_S_PARTIAL_COMPLETEBG_E_PROXY_LIST_TOO_LARGEBG_E_PROXY_BYPASS_LIST_TOO_LARGEBG_S_UNABLE_TO_DELETE_FILESBG_E_INVALID_SERVER_RESPONSEBG_E_TOO_MANY_FILESBG_E_LOCAL_FILE_CHANGEDBG_E_ERROR_CONTEXT_REMOTE_APPLICATIONBG_E_SESSION_NOT_FOUNDBG_E_TOO_LARGEBG_E_STRING_TOO_LONGBG_E_CLIENT_SERVER_PROTOCOL_MISMATCHBG_E_SERVER_EXECUTE_ENABLEBG_E_NO_PROGRESSBG_E_USERNAME_TOO_LARGEBG_E_PASSWORD_TOO_LARGEBG_E_INVALID_AUTH_TARGETBG_E_INVALID_AUTH_SCHEMEBG_E_FILE_NOT_FOUNDBG_S_PROXY_CHANGEDBG_E_INVALID_RANGEBG_E_OVERLAPPING_RANGESBG_E_CONNECT_FAILUREBG_E_CONNECTION_CLOSEDBG_E_BLOCKED_BY_POLICYBG_E_INVALID_PROXY_INFOBG_E_INVALID_CREDENTIALSBG_E_INVALID_HASH_ALGORITHMBG_E_RECORD_DELETEDBG_E_COMMIT_IN_PROGRESSBG_E_DISCOVERY_IN_PROGRESSBG_E_UPNP_ERRORBG_E_TEST_OPTION_BLOCKED_DOWNLOADBG_E_PEERCACHING_DISABLEDBG_E_BUSYCACHERECORDBG_E_TOO_MANY_JOBS_PER_USERBG_E_TOO_MANY_JOBS_PER_MACHINEBG_E_TOO_MANY_FILES_IN_JOBBG_E_TOO_MANY_RANGES_IN_FILEBG_E_VALIDATION_FAILEDBG_E_MAXDOWNLOAD_TIMEOUTBG_S_OVERRIDDEN_BY_POLICYBG_E_TOKEN_REQUIREDBG_E_UNKNOWN_PROPERTY_IDBG_E_READ_ONLY_PROPERTYBG_E_BLOCKED_BY_COST_TRANSFER_POLICYBG_E_PROPERTY_SUPPORTED_FOR_DOWNLOAD_JOBS_ONLYBG_E_READ_ONLY_PROPERTY_AFTER_ADDFILEBG_E_READ_ONLY_PROPERTY_AFTER_RESUMEBG_E_MAX_DOWNLOAD_SIZE_INVALID_VALUEBG_E_MAX_DOWNLOAD_SIZE_LIMIT_REACHEDBG_E_STANDBY_MODEBG_E_USE_STORED_CREDENTIALS_NOT_SUPPORTEDBG_E_BLOCKED_BY_BATTERY_POLICYBG_E_BLOCKED_BY_BATTERY_SAVERBG_E_WATCHDOG_TIMEOUTBG_E_APP_PACKAGE_NOT_FOUNDBG_E_APP_PACKAGE_SCENARIO_NOT_SUPPORTEDBG_E_DATABASE_CORRUPTBG_E_RANDOM_ACCESS_NOT_SUPPORTEDBG_E_HTTP_ERROR_100BG_E_HTTP_ERROR_101BG_E_HTTP_ERROR_200BG_E_HTTP_ERROR_201BG_E_HTTP_ERROR_202BG_E_HTTP_ERROR_203BG_E_HTTP_ERROR_204BG_E_HTTP_ERROR_205BG_E_HTTP_ERROR_206BG_E_HTTP_ERROR_300BG_E_HTTP_ERROR_301BG_E_HTTP_ERROR_302BG_E_HTTP_ERROR_303BG_E_HTTP_ERROR_304BG_E_HTTP_ERROR_305BG_E_HTTP_ERROR_307BG_E_HTTP_ERROR_400BG_E_HTTP_ERROR_401BG_E_HTTP_ERROR_402BG_E_HTTP_ERROR_403BG_E_HTTP_ERROR_404BG_E_HTTP_ERROR_405BG_E_HTTP_ERROR_406BG_E_HTTP_ERROR_407BG_E_HTTP_ERROR_408BG_E_HTTP_ERROR_409BG_E_HTTP_ERROR_410BG_E_HTTP_ERROR_411BG_E_HTTP_ERROR_412BG_E_HTTP_ERROR_413BG_E_HTTP_ERROR_414BG_E_HTTP_ERROR_415BG_E_HTTP_ERROR_416BG_E_HTTP_ERROR_417BG_E_HTTP_ERROR_449BG_E_HTTP_ERROR_500BG_E_HTTP_ERROR_501BG_E_HTTP_ERROR_502BG_E_HTTP_ERROR_503BG_E_HTTP_ERROR_504BG_E_HTTP_ERROR_505BITS_MC_JOB_CANCELLEDBITS_MC_FILE_DELETION_FAILEDBITS_MC_FILE_DELETION_FAILED_MOREBITS_MC_JOB_PROPERTY_CHANGEBITS_MC_JOB_TAKE_OWNERSHIPBITS_MC_JOB_SCAVENGEDBITS_MC_JOB_NOTIFICATION_FAILUREBITS_MC_STATE_FILE_CORRUPTBITS_MC_FAILED_TO_STARTBITS_MC_FATAL_IGD_ERRORBITS_MC_PEERCACHING_PORTBITS_MC_WSD_PORT//! error code definitions for the background file copierSDP_SPECIFICTYPESDP_TYPEBLUETOOTH_MAX_NAME_SIZEBLUETOOTH_MAX_PASSKEY_SIZEBLUETOOTH_MAX_PASSKEY_BUFFER_SIZEBLUETOOTH_MAX_SERVICE_NAME_SIZEBLUETOOTH_DEVICE_NAME_SIZEBLUETOOTH_ADDRESSBLUETOOTH_NULL_ADDRESSPBLUETOOTH_LOCAL_SERVICE_INFOBLUETOOTH_LOCAL_SERVICE_INFOHBLUETOOTH_RADIO_FINDBluetoothFindFirstRadioBLUETOOTH_FIND_RADIO_PARAMSBluetoothFindNextRadioBluetoothFindRadioClosePBLUETOOTH_RADIO_INFOBLUETOOTH_RADIO_INFOBluetoothGetRadioInfoPBLUETOOTH_DEVICE_INFOBLUETOOTH_DEVICE_INFOPBLUETOOTH_AUTHENTICATION_METHODBLUETOOTH_AUTHENTICATION_METHODPBLUETOOTH_AUTHENTICATION_CALLBACK_PARAMSBLUETOOTH_AUTHENTICATION_CALLBACK_PARAMSHBLUETOOTH_DEVICE_FINDBluetoothFindFirstDeviceBLUETOOTH_DEVICE_SEARCH_PARAMSBluetoothFindNextDeviceBluetoothFindDeviceCloseBluetoothGetDeviceInfoBluetoothUpdateDeviceRecordBluetoothRemoveDeviceBluetoothSelectDevicesBLUETOOTH_SELECT_DEVICE_PARAMSBluetoothSelectDevicesFreeBluetoothDisplayDevicePropertiesBluetoothAuthenticateDevicePBLUETOOTH_PIN_INFOBLUETOOTH_PIN_INFOPBLUETOOTH_OOB_DATA_INFOBLUETOOTH_OOB_DATA_INFOPBLUETOOTH_NUMERIC_COMPARISON_INFOBLUETOOTH_NUMERIC_COMPARISON_INFOPBLUETOOTH_PASSKEY_INFOBLUETOOTH_PASSKEY_INFOBluetoothAuthenticateDeviceExBluetoothAuthenticateMultipleDevicesBLUETOOTH_SERVICE_DISABLEBLUETOOTH_SERVICE_ENABLEBLUETOOTH_SERVICE_MASKBluetoothSetServiceStateBluetoothEnumerateInstalledServicesBluetoothEnableDiscoveryBluetoothIsDiscoverableBluetoothEnableIncomingConnectionsBluetoothIsConnectableHBLUETOOTH_AUTHENTICATION_REGISTRATIONBluetoothRegisterForAuthenticationPFN_AUTHENTICATION_CALLBACKBluetoothRegisterForAuthenticationExPFN_AUTHENTICATION_CALLBACK_EXBluetoothUnregisterAuthenticationBluetoothSendAuthenticationResponsePBLUETOOTH_AUTHENTICATE_RESPONSEBLUETOOTH_AUTHENTICATE_RESPONSEBluetoothSendAuthenticationResponseExPSDP_ELEMENT_DATASDP_ELEMENT_DATABluetoothSdpGetElementDataHBLUETOOTH_CONTAINER_ELEMENTBluetoothSdpGetContainerElementDataBluetoothSdpGetAttributeValuePSDP_STRING_TYPE_DATASDP_STRING_TYPE_DATABluetoothSdpGetStringBluetoothSdpEnumAttributesBluetoothEnumAttributesPFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACKBluetoothSetLocalServiceInfoBluetoothIsVersionAvailablebthledefBLUETOOTH_GATT_EVENT_HANDLEBTH_LE_GATT_EVENT_TYPEBTH_LE_GATT_RELIABLE_WRITE_CONTEXTPBTH_LE_GATT_CHARACTERISTICPBTH_LE_GATT_CHARACTERISTIC_VALUEPBTH_LE_GATT_DESCRIPTORPBTH_LE_GATT_DESCRIPTOR_VALUEPBTH_LE_GATT_RELIABLE_WRITE_CONTEXTPBTH_LE_GATT_SERVICEPFNBLUETOOTH_GATT_EVENT_CALLBACKBluetoothGATTGetServicesBluetoothGATTGetIncludedServicesBluetoothGATTGetCharacteristicsBluetoothGATTGetDescriptorsBluetoothGATTGetCharacteristicValueBluetoothGATTGetDescriptorValueBluetoothGATTBeginReliableWriteBluetoothGATTSetCharacteristicValueBluetoothGATTEndReliableWriteBluetoothGATTAbortReliableWriteBluetoothGATTSetDescriptorValueBluetoothGATTRegisterEventBluetoothGATTUnregisterEventBTH_LE_SERVICE_GAPBTH_LE_SERVICE_GATTBTH_LE_GATT_ATTRIBUTE_TYPE_PRIMARY_SERVICEBTH_LE_GATT_ATTRIBUTE_TYPE_SECONDARY_SERVICEBTH_LE_GATT_ATTRIBUTE_TYPE_INCLUDEBTH_LE_GATT_ATTRIBUTE_TYPE_CHARACTERISTICBTH_LE_GATT_CHARACTERISTIC_DESCRIPTOR_EXTENDED_PROPERTIESBTH_LE_GATT_CHARACTERISTIC_DESCRIPTOR_USER_DESCRIPTIONBTH_LE_GATT_CHARACTERISTIC_DESCRIPTOR_CLIENT_CONFIGURATIONBTH_LE_GATT_CHARACTERISTIC_DESCRIPTOR_SERVER_CONFIGURATIONBTH_LE_GATT_CHARACTERISTIC_DESCRIPTOR_FORMATBTH_LE_GATT_CHARACTERISTIC_DESCRIPTOR_AGGREGATE_FORMATBTH_LE_GATT_CHARACTERISTIC_TYPE_DEVICE_NAMEBTH_LE_GATT_CHARACTERISTIC_TYPE_APPEARANCEBTH_LE_GATT_CHARACTERISTIC_TYPE_PERIPHERAL_PRIVACY_FLAGBTH_LE_GATT_CHARACTERISTIC_TYPE_RECONNECTION_ADDRESSBTH_LE_GATT_CHARACTERISTIC_TYPE_PERIPHERAL_PREFERED_CONNECTION_PARAMETERBTH_LE_GATT_CHARACTERISTIC_TYPE_SERVICE_CHANGEDBTH_LE_GAP_APPEARANCE_CATEGORY_OFFSETBTH_LE_GAP_APPEARANCE_CATEGORY_MASKBTH_LE_GAP_APPEARANCE_GET_CATEGORYBTH_LE_GAP_APPEARANCE_SET_CATEGORYBTH_LE_GAP_APPEARANCE_SUB_CATEGORY_MASKBTH_LE_GAP_APPEARANCE_GET_SUB_CATEGORYBTH_LE_GAP_APPEARANCE_SET_SUB_CATEGORYBTH_LE_GAP_APPEARANCE_CATEGORY_UNCATEGORIZEDBTH_LE_GAP_APPEARANCE_CATEGORY_PHONEBTH_LE_GAP_APPEARANCE_CATEGORY_COMPUTERBTH_LE_GAP_APPEARANCE_CATEGORY_WATCHBTH_LE_GAP_APPEARANCE_CATEGORY_CLOCKBTH_LE_GAP_APPEARANCE_CATEGORY_DISPLAYBTH_LE_GAP_APPEARANCE_CATEGORY_REMOTE_CONTROLBTH_LE_GAP_APPEARANCE_CATEGORY_EYE_GLASSESBTH_LE_GAP_APPEARANCE_CATEGORY_TAGBTH_LE_GAP_APPEARANCE_CATEGORY_KEYRINGBTH_LE_GAP_APPEARANCE_CATEGORY_MEDIA_PLAYERBTH_LE_GAP_APPEARANCE_CATEGORY_BARCODE_SCANNERBTH_LE_GAP_APPEARANCE_CATEGORY_THERMOMETERBTH_LE_GAP_APPEARANCE_CATEGORY_HEART_RATEBTH_LE_GAP_APPEARANCE_CATEGORY_BLOOD_PRESSUREBTH_LE_GAP_APPEARANCE_CATEGORY_HIDBTH_LE_GAP_APPEARANCE_CATEGORY_GLUCOSE_METERBTH_LE_GAP_APPEARANCE_CATEGORY_RUNNING_WALKING_SENSORBTH_LE_GAP_APPEARANCE_CATEGORY_CYCLINGBTH_LE_GAP_APPEARANCE_CATEGORY_PLUSE_OXIMETERBTH_LE_GAP_APPEARANCE_CATEGORY_WEIGHT_SCALEBTH_LE_GAP_APPEARANCE_CATEGORY_OUTDOOR_SPORTS_ACTIVITYBTH_LE_GAP_APPEARANCE_SUBCATEGORY_GENERICBTH_LE_GAP_APPEARANCE_WATCH_SUBCATEGORY_SPORTS_WATCHBTH_LE_GAP_APPEARANCE_THERMOMETER_SUBCATEGORY_EARBTH_LE_GAP_APPEARANCE_HEART_RATE_SUBCATEGORY_HEART_RATE_BELTBTH_LE_GAP_APPEARANCE_BLOOD_PRESSURE_SUBCATEGORY_ARMBTH_LE_GAP_APPEARANCE_BLOOD_PRESSURE_SUBCATEGORY_WRISTBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_KEYBOARDBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_MOUSEBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_JOYSTICKBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_GAMEPADBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_DIGITIZER_TABLETBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_CARD_READERBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_DIGITAL_PENBTH_LE_GAP_APPEARANCE_HID_SUBCATEGORY_BARCODE_SCANNERBTH_LE_GAP_APPEARANCE_RUNNING_WALKING_SENSOR_SUBCATEGORY_IN_SHOEBTH_LE_GAP_APPEARANCE_RUNNING_WALKING_SENSOR_SUBCATEGORY_ON_SHOEBTH_LE_GAP_APPEARANCE_RUNNING_WALKING_SENSOR_SUBCATEGORY_ON_HIPBTH_LE_GAP_APPEARANCE_CYCLING_SUBCATEGORY_CYCLING_COMPUTERBTH_LE_GAP_APPEARANCE_CYCLING_SUBCATEGORY_SPEED_SENSORBTH_LE_GAP_APPEARANCE_CYCLING_SUBCATEGORY_CADENCE_SENSORBTH_LE_GAP_APPEARANCE_CYCLING_SUBCATEGORY_POWER_SENSORBTH_LE_GAP_APPEARANCE_CYCLING_SUBCATEGORY_SPEED_AND_CADENCE_SENSORBTH_LE_GAP_APPEARANCE_PULSE_OXIMETER_SUBCATEGORY_FINGERTIPBTH_LE_GAP_APPEARANCE_PULSE_OXIMETER_SUBCATEGORY_WRIST_WORNBTH_LE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACTIVITY_SUBCATEGORY_LOCATION_DISPLAY_DEVICEBTH_LE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACTIVITY_SUBCATEGORY_LOCATION_NAVIGATION_DISPLAY_DEVICEBTH_LE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACTIVITY_SUBCATEGORY_LOCATION_PODBTH_LE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACTIVITY_SUBCATEGORY_LOCATION_NAVIGATION_PODBTH_LE_GATT_DEFAULT_MAX_INCLUDED_SERVICES_DEPTHBTH_LE_ATT_TRANSACTION_TIMEOUTBTH_LE_ATT_MAX_VALUE_SIZEBTH_LE_ATT_CIDBTHLEENUM_ATT_MTU_MINBTHLEENUM_ATT_MTU_DEFAULT// #define BTHLEENUM_ATT_MTU_MAX (MAX_USHORT)BTHLEENUM_ATT_MTU_INITIAL_NEGOTIATIONBTH_LE_ERROR_INVALID_HANDLEBTH_LE_ERROR_READ_NOT_PERMITTEDBTH_LE_ERROR_WRITE_NOT_PERMITTEDBTH_LE_ERROR_INVALID_PDUBTH_LE_ERROR_INSUFFICIENT_AUTHENTICATIONBTH_LE_ERROR_REQUEST_NOT_SUPPORTEDBTH_LE_ERROR_INVALID_OFFSETBTH_LE_ERROR_INSUFFICIENT_AUTHORIZATIONBTH_LE_ERROR_PREPARE_QUEUE_FULLBTH_LE_ERROR_ATTRIBUTE_NOT_FOUNDBTH_LE_ERROR_ATTRIBUTE_NOT_LONGBTH_LE_ERROR_INSUFFICIENT_ENCRYPTION_KEY_SIZEBTH_LE_ERROR_INVALID_ATTRIBUTE_VALUE_LENGTHBTH_LE_ERROR_UNLIKELYBTH_LE_ERROR_INSUFFICIENT_ENCRYPTIONBTH_LE_ERROR_UNSUPPORTED_GROUP_TYPEBTH_LE_ERROR_INSUFFICIENT_RESOURCESBTH_LE_ERROR_UNKNOWNBLUETOOTH_GATT_FLAG_NONEBLUETOOTH_GATT_FLAG_CONNECTION_ENCRYPTEDBLUETOOTH_GATT_FLAG_CONNECTION_AUTHENTICATEDBLUETOOTH_GATT_FLAG_FORCE_READ_FROM_DEVICEBLUETOOTH_GATT_FLAG_FORCE_READ_FROM_CACHEBLUETOOTH_GATT_FLAG_SIGNED_WRITEBLUETOOTH_GATT_FLAG_WRITE_WITHOUT_RESPONSEBLUETOOTH_GATT_FLAG_RETURN_ALLBLUETOOTH_GATT_FLAG_VALID_MASKIS_BLUETOOTH_GATT_FLAG_VALIDPBTH_LE_UUIDBTH_LE_UUIDBTH_LE_GATT_SERVICEPBTH_LE_GATT_DESCRIPTOR_TYPEBTH_LE_GATT_DESCRIPTOR_TYPEBTH_LE_GATT_CHARACTERISTICBTH_LE_GATT_CHARACTERISTIC_VALUEBTH_LE_GATT_DESCRIPTORBTH_LE_GATT_DESCRIPTOR_VALUEPBLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATIONBLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATIONPBLUETOOTH_GATT_VALUE_CHANGED_EVENTBLUETOOTH_GATT_VALUE_CHANGED_EVENTIsBthLEUuidMatchREGSAMPCVOIDMAX_DEVICE_ID_LENMAX_DEVNODE_ID_LENMAX_GUID_STRING_LENMAX_CLASS_NAME_LENMAX_PROFILE_LENMAX_CONFIG_VALUEMAX_INSTANCE_VALUEMAX_MEM_REGISTERSMAX_IO_PORTSMAX_IRQSMAX_DMA_CHANNELSDWORD_MAXDWORDLONG_MAXCONFIGMG_VERSIONRETURN_TYPECONFIGRETDEVNODEDEVINSTPDEVNODEPDEVINSTDEVNODEID_ADEVINSTID_ADEVNODEID_WDEVINSTID_WLOG_CONFPLOG_CONFRES_DESPRES_DESRESOURCEIDPRESOURCEIDPPRIORITYRANGE_LISTPRANGE_LISTRANGE_ELEMENTPRANGE_ELEMENTHMACHINEPHMACHINECONFLICT_LISTPCONFLICT_LISTPCONFLICT_DETAILS_ACONFLICT_DETAILS_APCONFLICT_DETAILS_WCONFLICT_DETAILS_WCM_CDMASK_DEVINSTCM_CDMASK_RESDESCM_CDMASK_FLAGSCM_CDMASK_DESCRIPTIONCM_CDMASK_VALIDCM_CDFLAGS_DRIVERCM_CDFLAGS_ROOT_OWNEDCM_CDFLAGS_RESERVEDREGDISPOSITIONmMD_MemoryTypefMD_MemoryTypefMD_ROMfMD_RAMmMD_32_24fMD_32_24fMD_24fMD_32mMD_PrefetchablefMD_PrefetchablefMD_PreffMD_PrefetchDisallowedfMD_PrefetchAllowedmMD_ReadablefMD_ReadablefMD_ReadAllowedfMD_ReadDisallowedmMD_CombinedWritefMD_CombinedWritefMD_CombinedWriteDisallowedfMD_CombinedWriteAllowedmMD_CacheablefMD_NonCacheablefMD_CacheablefMD_WINDOW_DECODEfMD_MEMORY_BARPMEM_RANGEMEM_RANGEPMEM_DESMEM_DESPMEM_RESOURCEMEM_RESOURCEPMEM_LARGE_RANGEMEM_LARGE_RANGEPMEM_LARGE_DESMEM_LARGE_DESPMEM_LARGE_RESOURCEMEM_LARGE_RESOURCEfIOD_PortTypefIOD_MemoryfIOD_IOfIOD_DECODEfIOD_10_BIT_DECODEfIOD_12_BIT_DECODEfIOD_16_BIT_DECODEfIOD_POSITIVE_DECODEfIOD_PASSIVE_DECODEfIOD_WINDOW_DECODEfIOD_PORT_BARIO_ALIAS_10_BIT_DECODEIO_ALIAS_12_BIT_DECODEIO_ALIAS_16_BIT_DECODEIO_ALIAS_POSITIVE_DECODEPIO_RANGEIO_RANGEPIO_DESIO_DESPIO_RESOURCEIO_RESOURCEmDD_WidthfDD_BYTEfDD_WORDfDD_DWORDfDD_BYTE_AND_WORDmDD_BusMasterfDD_NoBusMasterfDD_BusMastermDD_TypefDD_TypeStandardfDD_TypeAfDD_TypeBfDD_TypeFPDMA_RANGEDMA_RANGEPDMA_DESDMA_DESPDMA_RESOURCEDMA_RESOURCEmIRQD_SharefIRQD_ExclusivefIRQD_SharefIRQD_Share_BitfIRQD_Level_BitmIRQD_Edge_LevelfIRQD_LevelfIRQD_EdgePIRQ_RANGEIRQ_RANGEPIRQ_DES_32IRQ_DES_32PIRQ_DES_64IRQ_DES_64PIRQ_RESOURCE_32IRQ_RESOURCE_32PIRQ_RESOURCE_64IRQ_RESOURCE_64PDEVPRIVATE_RANGEDEVPRIVATE_RANGEPDEVPRIVATE_DESDEVPRIVATE_DESPDEVPRIVATE_RESOURCEDEVPRIVATE_RESOURCEPCS_DESCS_DESPCS_RESOURCECS_RESOURCEmPCD_IO_8_16fPCD_IO_8fPCD_IO_16mPCD_MEM_8_16fPCD_MEM_8fPCD_MEM_16mPCD_MEM_A_CfPCD_MEM1_AfPCD_MEM2_AfPCD_IO_ZW_8fPCD_IO_SRC_16fPCD_IO_WS_16mPCD_MEM_WSfPCD_MEM_WS_ONEfPCD_MEM_WS_TWOfPCD_MEM_WS_THREEfPCD_MEM_AfPCD_ATTRIBUTES_PER_WINDOWfPCD_IO1_16fPCD_IO1_ZW_8fPCD_IO1_SRC_16fPCD_IO1_WS_16fPCD_IO2_16fPCD_IO2_ZW_8fPCD_IO2_SRC_16fPCD_IO2_WS_16mPCD_MEM1_WSfPCD_MEM1_WS_TWOfPCD_MEM1_WS_THREEfPCD_MEM1_16mPCD_MEM2_WSfPCD_MEM2_WS_ONEfPCD_MEM2_WS_TWOfPCD_MEM2_WS_THREEfPCD_MEM2_16PCD_MAX_MEMORYPCD_MAX_IOPPCCARD_DESPCCARD_DESPPCCARD_RESOURCEPCCARD_RESOURCEmPMF_AUDIO_ENABLEfPMF_AUDIO_ENABLEPMFCARD_DESMFCARD_DESPMFCARD_RESOURCEMFCARD_RESOURCEPBUSNUMBER_RANGEBUSNUMBER_RANGEPBUSNUMBER_DESBUSNUMBER_DESPBUSNUMBER_RESOURCEBUSNUMBER_RESOURCEPCONNECTION_DESCONNECTION_DESPCONNECTION_RESOURCECONNECTION_RESOURCECM_HWPI_NOT_DOCKABLECM_HWPI_UNDOCKEDCM_HWPI_DOCKEDPHWPROFILEINFO_AHWPROFILEINFO_APHWPROFILEINFO_WHWPROFILEINFO_WResType_AllResType_NoneResType_MemResType_IOResType_DMAResType_IRQResType_DoNotUseResType_BusNumberResType_MemLargeResType_MAXResType_Ignored_BitResType_ClassSpecificResType_ReservedResType_DevicePrivateResType_PcCardConfigResType_MfCardConfigResType_ConnectionCM_ADD_RANGE_ADDIFCONFLICTCM_ADD_RANGE_DONOTADDIFCONFLICTCM_ADD_RANGE_BITSBASIC_LOG_CONFFILTERED_LOG_CONFALLOC_LOG_CONFBOOT_LOG_CONFFORCED_LOG_CONFOVERRIDE_LOG_CONFNUM_LOG_CONFLOG_CONF_BITSPRIORITY_EQUAL_FIRSTPRIORITY_EQUAL_LASTPRIORITY_BITRegDisposition_OpenAlwaysRegDisposition_OpenExistingRegDisposition_BitsCM_ADD_ID_HARDWARECM_ADD_ID_COMPATIBLECM_ADD_ID_BITSCM_CREATE_DEVNODE_NORMALCM_CREATE_DEVNODE_NO_WAIT_INSTALLCM_CREATE_DEVNODE_PHANTOMCM_CREATE_DEVNODE_GENERATE_IDCM_CREATE_DEVNODE_DO_NOT_INSTALLCM_CREATE_DEVNODE_BITSCM_CREATE_DEVINST_NORMALCM_CREATE_DEVINST_NO_WAIT_INSTALLCM_CREATE_DEVINST_PHANTOMCM_CREATE_DEVINST_GENERATE_IDCM_CREATE_DEVINST_DO_NOT_INSTALLCM_CREATE_DEVINST_BITSCM_DELETE_CLASS_ONLYCM_DELETE_CLASS_SUBKEYSCM_DELETE_CLASS_INTERFACECM_DELETE_CLASS_BITSCM_ENUMERATE_CLASSES_INSTALLERCM_ENUMERATE_CLASSES_INTERFACECM_ENUMERATE_CLASSES_BITSCM_DETECT_NEW_PROFILECM_DETECT_CRASHEDCM_DETECT_HWPROF_FIRST_BOOTCM_DETECT_RUNCM_DETECT_BITSCM_DISABLE_POLITECM_DISABLE_ABSOLUTECM_DISABLE_HARDWARECM_DISABLE_UI_NOT_OKCM_DISABLE_BITSCM_GETIDLIST_FILTER_NONECM_GETIDLIST_FILTER_ENUMERATORCM_GETIDLIST_FILTER_SERVICECM_GETIDLIST_FILTER_EJECTRELATIONSCM_GETIDLIST_FILTER_REMOVALRELATIONSCM_GETIDLIST_FILTER_POWERRELATIONSCM_GETIDLIST_FILTER_BUSRELATIONSCM_GETIDLIST_DONOTGENERATECM_GETIDLIST_FILTER_TRANSPORTRELATIONSCM_GETIDLIST_FILTER_PRESENTCM_GETIDLIST_FILTER_CLASSCM_GETIDLIST_FILTER_BITSCM_GET_DEVICE_INTERFACE_LIST_PRESENTCM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICESCM_GET_DEVICE_INTERFACE_LIST_BITSCM_DRP_DEVICEDESCCM_DRP_HARDWAREIDCM_DRP_COMPATIBLEIDSCM_DRP_UNUSED0CM_DRP_SERVICECM_DRP_UNUSED1CM_DRP_UNUSED2CM_DRP_CLASSCM_DRP_CLASSGUIDCM_DRP_DRIVERCM_DRP_CONFIGFLAGSCM_DRP_MFGCM_DRP_FRIENDLYNAMECM_DRP_LOCATION_INFORMATIONCM_DRP_PHYSICAL_DEVICE_OBJECT_NAMECM_DRP_CAPABILITIESCM_DRP_UI_NUMBERCM_DRP_UPPERFILTERSCM_CRP_UPPERFILTERSCM_DRP_LOWERFILTERSCM_CRP_LOWERFILTERSCM_DRP_BUSTYPEGUIDCM_DRP_LEGACYBUSTYPECM_DRP_BUSNUMBERCM_DRP_ENUMERATOR_NAMECM_DRP_SECURITYCM_CRP_SECURITYCM_DRP_SECURITY_SDSCM_CRP_SECURITY_SDSCM_DRP_DEVTYPECM_CRP_DEVTYPECM_DRP_EXCLUSIVECM_CRP_EXCLUSIVECM_DRP_CHARACTERISTICSCM_CRP_CHARACTERISTICSCM_DRP_ADDRESSCM_DRP_UI_NUMBER_DESC_FORMATCM_DRP_DEVICE_POWER_DATACM_DRP_REMOVAL_POLICYCM_DRP_REMOVAL_POLICY_HW_DEFAULTCM_DRP_REMOVAL_POLICY_OVERRIDECM_DRP_INSTALL_STATECM_DRP_LOCATION_PATHSCM_DRP_BASE_CONTAINERIDCM_DRP_MINCM_CRP_MINCM_DRP_MAXCM_CRP_MAXCM_DEVCAP_LOCKSUPPORTEDCM_DEVCAP_EJECTSUPPORTEDCM_DEVCAP_REMOVABLECM_DEVCAP_DOCKDEVICECM_DEVCAP_UNIQUEIDCM_DEVCAP_SILENTINSTALLCM_DEVCAP_RAWDEVICEOKCM_DEVCAP_SURPRISEREMOVALOKCM_DEVCAP_HARDWAREDISABLEDCM_DEVCAP_NONDYNAMICCM_REMOVAL_POLICY_EXPECT_NO_REMOVALCM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVALCM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVALCM_INSTALL_STATE_INSTALLEDCM_INSTALL_STATE_NEEDS_REINSTALLCM_INSTALL_STATE_FAILED_INSTALLCM_INSTALL_STATE_FINISH_INSTALLCM_LOCATE_DEVNODE_NORMALCM_LOCATE_DEVNODE_PHANTOMCM_LOCATE_DEVNODE_CANCELREMOVECM_LOCATE_DEVNODE_NOVALIDATIONCM_LOCATE_DEVNODE_BITSCM_LOCATE_DEVINST_NORMALCM_LOCATE_DEVINST_PHANTOMCM_LOCATE_DEVINST_CANCELREMOVECM_LOCATE_DEVINST_NOVALIDATIONCM_LOCATE_DEVINST_BITSCM_OPEN_CLASS_KEY_INSTALLERCM_OPEN_CLASS_KEY_INTERFACECM_OPEN_CLASS_KEY_BITSCM_REMOVE_UI_OKCM_REMOVE_UI_NOT_OKCM_REMOVE_NO_RESTARTCM_REMOVE_BITSCM_QUERY_REMOVE_UI_OKCM_QUERY_REMOVE_UI_NOT_OKCM_QUERY_REMOVE_BITSCM_REENUMERATE_NORMALCM_REENUMERATE_SYNCHRONOUSCM_REENUMERATE_RETRY_INSTALLATIONCM_REENUMERATE_ASYNCHRONOUSCM_REENUMERATE_BITSCM_REGISTER_DEVICE_DRIVER_STATICCM_REGISTER_DEVICE_DRIVER_DISABLEABLECM_REGISTER_DEVICE_DRIVER_REMOVABLECM_REGISTER_DEVICE_DRIVER_BITSCM_REGISTRY_HARDWARECM_REGISTRY_SOFTWARECM_REGISTRY_USERCM_REGISTRY_CONFIGCM_REGISTRY_BITSCM_SET_DEVNODE_PROBLEM_NORMALCM_SET_DEVNODE_PROBLEM_OVERRIDECM_SET_DEVNODE_PROBLEM_BITSCM_SET_DEVINST_PROBLEM_NORMALCM_SET_DEVINST_PROBLEM_OVERRIDECM_SET_DEVINST_PROBLEM_BITSCM_SET_HW_PROF_FLAGS_UI_NOT_OKCM_SET_HW_PROF_FLAGS_BITSCM_SETUP_DEVNODE_READYCM_SETUP_DEVINST_READYCM_SETUP_DOWNLOADCM_SETUP_WRITE_LOG_CONFSCM_SETUP_PROP_CHANGECM_SETUP_DEVNODE_RESETCM_SETUP_DEVINST_RESETCM_SETUP_DEVNODE_CONFIGCM_SETUP_DEVINST_CONFIGCM_SETUP_DEVNODE_CONFIG_CLASSCM_SETUP_DEVINST_CONFIG_CLASSCM_SETUP_DEVNODE_CONFIG_EXTENSIONSCM_SETUP_DEVINST_CONFIG_EXTENSIONSCM_SETUP_BITSCM_QUERY_ARBITRATOR_RAWCM_QUERY_ARBITRATOR_TRANSLATEDCM_QUERY_ARBITRATOR_BITSCM_CUSTOMDEVPROP_MERGE_MULTISZCM_CUSTOMDEVPROP_BITSCM_NAME_ATTRIBUTE_NAME_RETRIEVED_FROM_DEVICECM_NAME_ATTRIBUTE_USER_ASSIGNED_NAMECM_CLASS_PROPERTY_INSTALLERCM_CLASS_PROPERTY_INTERFACECM_CLASS_PROPERTY_BITSPHCMNOTIFICATIONHCMNOTIFICATIONCM_NOTIFY_FILTER_FLAG_ALL_INTERFACE_CLASSESCM_NOTIFY_FILTER_FLAG_ALL_DEVICE_INSTANCESCM_NOTIFY_FILTER_VALID_FLAGSPCM_NOTIFY_FILTER_TYPECM_NOTIFY_FILTER_TYPEPCM_NOTIFY_FILTERCM_NOTIFY_FILTERPCM_NOTIFY_ACTIONCM_NOTIFY_ACTIONPCM_NOTIFY_EVENT_DATACM_NOTIFY_EVENT_DATACM_Add_Empty_Log_ConfCM_Add_Empty_Log_Conf_ExCM_Add_IDACM_Add_IDWCM_Add_ID_ExACM_Add_ID_ExWCM_Add_RangeCM_Add_Res_DesCM_Add_Res_Des_ExCM_Connect_MachineACM_Connect_MachineWCM_Create_DevNodeACM_Create_DevNodeWCM_Create_DevNode_ExACM_Create_DevNode_ExWCM_Create_Range_ListCM_Delete_Class_KeyCM_Delete_Class_Key_ExCM_Delete_DevNode_KeyCM_Delete_DevNode_Key_ExCM_Delete_RangeCM_Detect_Resource_ConflictCM_Detect_Resource_Conflict_ExCM_Disable_DevNodeCM_Disable_DevNode_ExCM_Disconnect_MachineCM_Dup_Range_ListCM_Enable_DevNodeCM_Enable_DevNode_ExCM_Enumerate_ClassesCM_Enumerate_Classes_ExCM_Enumerate_EnumeratorsACM_Enumerate_EnumeratorsWCM_Enumerate_Enumerators_ExACM_Enumerate_Enumerators_ExWCM_Find_RangeCM_First_RangeCM_Free_Log_ConfCM_Free_Log_Conf_ExCM_Free_Log_Conf_HandleCM_Free_Range_ListCM_Free_Res_DesCM_Free_Res_Des_ExCM_Free_Res_Des_HandleCM_Get_ChildCM_Get_Child_ExCM_Get_Class_Key_NameACM_Get_Class_Key_NameWCM_Get_Class_Key_Name_ExACM_Get_Class_Key_Name_ExWCM_Get_Class_NameACM_Get_Class_NameWCM_Get_Class_Name_ExACM_Get_Class_Name_ExWCM_Get_DepthCM_Get_Depth_ExCM_Get_Device_IDACM_Get_Device_IDWCM_Get_Device_ID_ExACM_Get_Device_ID_ExWCM_Get_Device_ID_ListACM_Get_Device_ID_ListWCM_Get_Device_ID_List_ExACM_Get_Device_ID_List_ExWCM_Get_Device_ID_List_SizeACM_Get_Device_ID_List_SizeWCM_Get_Device_ID_List_Size_ExACM_Get_Device_ID_List_Size_ExWCM_Get_Device_ID_SizeCM_Get_Device_ID_Size_ExCM_Get_DevNode_PropertyWCM_Get_DevNode_PropertyExWCM_Get_DevNode_Registry_PropertyACM_Get_DevNode_Registry_PropertyWCM_Get_DevNode_Registry_Property_ExACM_Get_DevNode_Registry_Property_ExWCM_Get_DevNode_Custom_PropertyACM_Get_DevNode_Custom_PropertyWCM_Get_DevNode_Custom_Property_ExACM_Get_DevNode_Custom_Property_ExWCM_Get_DevNode_StatusCM_Get_DevNode_Status_ExCM_Get_First_Log_ConfCM_Get_First_Log_Conf_ExCM_Get_Global_StateCM_Get_Global_State_ExCM_Get_Hardware_Profile_InfoACM_Get_Hardware_Profile_Info_ExACM_Get_Hardware_Profile_InfoWCM_Get_Hardware_Profile_Info_ExWCM_Get_HW_Prof_FlagsACM_Get_HW_Prof_FlagsWCM_Get_HW_Prof_Flags_ExACM_Get_HW_Prof_Flags_ExWCM_Get_Device_Interface_AliasACM_Get_Device_Interface_AliasWCM_Get_Device_Interface_Alias_ExACM_Get_Device_Interface_Alias_ExWCM_Get_Device_Interface_ListACM_Get_Device_Interface_ListWCM_Get_Device_Interface_List_ExACM_Get_Device_Interface_List_ExWCM_Get_Device_Interface_List_SizeACM_Get_Device_Interface_List_SizeWCM_Get_Device_Interface_List_Size_ExACM_Get_Device_Interface_List_Size_ExWCM_Get_Device_Interface_PropertyWCM_Get_Device_Interface_PropertyExWCM_Get_Log_Conf_PriorityCM_Get_Log_Conf_Priority_ExCM_Get_Next_Log_ConfCM_Get_Next_Log_Conf_ExCM_Get_ParentCM_Get_Parent_ExCM_Get_Res_Des_DataCM_Get_Res_Des_Data_ExCM_Get_Res_Des_Data_SizeCM_Get_Res_Des_Data_Size_ExCM_Get_SiblingCM_Get_Sibling_ExCM_Get_VersionCM_Get_Version_ExCM_Is_Version_AvailableCM_Is_Version_Available_ExCM_Intersect_Range_ListCM_Invert_Range_ListCM_Locate_DevNodeACM_Locate_DevNodeWCM_Locate_DevNode_ExACM_Locate_DevNode_ExWCM_Merge_Range_ListCM_Modify_Res_DesCM_Modify_Res_Des_ExCM_Move_DevNodeCM_Move_DevNode_ExCM_Next_RangeCM_Get_Next_Res_DesCM_Get_Next_Res_Des_ExCM_Open_Class_KeyACM_Open_Class_KeyWCM_Open_Class_Key_ExACM_Open_Class_Key_ExWCM_Open_DevNode_KeyCM_Open_DevNode_Key_ExCM_Open_Device_Interface_KeyACM_Open_Device_Interface_KeyWCM_Open_Device_Interface_Key_ExACM_Open_Device_Interface_Key_ExWCM_Delete_Device_Interface_KeyACM_Delete_Device_Interface_KeyWCM_Delete_Device_Interface_Key_ExACM_Delete_Device_Interface_Key_ExWCM_Query_Arbitrator_Free_DataCM_Query_Arbitrator_Free_Data_ExCM_Query_Arbitrator_Free_SizeCM_Query_Arbitrator_Free_Size_ExCM_Query_Remove_SubTreeCM_Query_Remove_SubTree_ExCM_Query_And_Remove_SubTreeACM_Query_And_Remove_SubTree_ExACM_Query_And_Remove_SubTreeWCM_Query_And_Remove_SubTree_ExWCM_Request_Device_EjectACM_Request_Device_Eject_ExACM_Request_Device_EjectWCM_Request_Device_Eject_ExWCM_Reenumerate_DevNodeCM_Reenumerate_DevNode_ExCM_Register_Device_InterfaceACM_Register_Device_InterfaceWCM_Register_Device_Interface_ExACM_Register_Device_Interface_ExWCM_Set_DevNode_Problem_ExCM_Set_DevNode_ProblemCM_Unregister_Device_InterfaceACM_Unregister_Device_InterfaceWCM_Unregister_Device_Interface_ExACM_Unregister_Device_Interface_ExWCM_Register_Device_DriverCM_Register_Device_Driver_ExCM_Remove_SubTreeCM_Remove_SubTree_ExCM_Set_DevNode_Registry_PropertyACM_Set_DevNode_Registry_PropertyWCM_Set_DevNode_Registry_Property_ExACM_Set_DevNode_Registry_Property_ExWCM_Is_Dock_Station_PresentCM_Is_Dock_Station_Present_ExCM_Request_Eject_PCCM_Request_Eject_PC_ExCM_Set_HW_Prof_FlagsACM_Set_HW_Prof_FlagsWCM_Set_HW_Prof_Flags_ExACM_Set_HW_Prof_Flags_ExWCM_Setup_DevNodeCM_Setup_DevNode_ExCM_Test_Range_AvailableCM_Uninstall_DevNodeCM_Uninstall_DevNode_ExCM_Run_DetectionCM_Run_Detection_ExCM_Set_HW_ProfCM_Set_HW_Prof_ExCM_Query_Resource_Conflict_ListCM_Free_Resource_Conflict_HandleCM_Get_Resource_Conflict_CountCM_Get_Resource_Conflict_DetailsACM_Get_Resource_Conflict_DetailsWCM_Get_Class_Registry_PropertyWCM_Set_Class_Registry_PropertyWCM_Get_Class_Registry_PropertyACM_Set_Class_Registry_PropertyACMP_WaitNoPendingInstallEventsCR_SUCCESSCR_DEFAULTCR_OUT_OF_MEMORYCR_INVALID_POINTERCR_INVALID_FLAGCR_INVALID_DEVNODECR_INVALID_DEVINSTCR_INVALID_RES_DESCR_INVALID_LOG_CONFCR_INVALID_ARBITRATORCR_INVALID_NODELISTCR_DEVNODE_HAS_REQSCR_DEVINST_HAS_REQSCR_INVALID_RESOURCEIDCR_DLVXD_NOT_FOUNDCR_NO_SUCH_DEVNODECR_NO_SUCH_DEVINSTCR_NO_MORE_LOG_CONFCR_NO_MORE_RES_DESCR_ALREADY_SUCH_DEVNODECR_ALREADY_SUCH_DEVINSTCR_INVALID_RANGE_LISTCR_INVALID_RANGECR_FAILURECR_NO_SUCH_LOGICAL_DEVCR_CREATE_BLOCKEDCR_NOT_SYSTEM_VMCR_REMOVE_VETOEDCR_APM_VETOEDCR_INVALID_LOAD_TYPECR_BUFFER_SMALLCR_NO_ARBITRATORCR_NO_REGISTRY_HANDLECR_REGISTRY_ERRORCR_INVALID_DEVICE_IDCR_INVALID_DATACR_INVALID_APICR_DEVLOADER_NOT_READYCR_NEED_RESTARTCR_NO_MORE_HW_PROFILESCR_DEVICE_NOT_THERECR_NO_SUCH_VALUECR_WRONG_TYPECR_INVALID_PRIORITYCR_NOT_DISABLEABLECR_FREE_RESOURCESCR_QUERY_VETOEDCR_CANT_SHARE_IRQCR_NO_DEPENDENTCR_SAME_RESOURCESCR_NO_SUCH_REGISTRY_KEYCR_INVALID_MACHINENAMECR_REMOTE_COMM_FAILURECR_MACHINE_UNAVAILABLECR_NO_CM_SERVICESCR_ACCESS_DENIEDCR_CALL_NOT_IMPLEMENTEDCR_INVALID_PROPERTYCR_DEVICE_INTERFACE_ACTIVECR_NO_SUCH_DEVICE_INTERFACECR_INVALID_REFERENCE_STRINGCR_INVALID_CONFLICT_LISTCR_INVALID_INDEXCR_INVALID_STRUCTURE_SIZENUM_CR_RESULTS//! user APIs for the Configuration Manager// Some of these definitions are commented out because I could not find their value// extern const CLSID CLSID_AggStdMarshal;// extern const CLSID CID_CDfsVolume;// extern const CLSID CLSID_CCDFormKrnl;// extern const CLSID CLSID_CCDPropertyPage;// extern const CLSID CLSID_CCDFormDialog;// extern const CLSID CLSID_CCDCommandButton;// extern const CLSID CLSID_CCDComboBox;// extern const CLSID CLSID_CCDTextBox;// extern const CLSID CLSID_CCDCheckBox;// extern const CLSID CLSID_CCDLabel;// extern const CLSID CLSID_CCDOptionButton;// extern const CLSID CLSID_CCDListBox;// extern const CLSID CLSID_CCDScrollBar;// extern const CLSID CLSID_CCDGroupBox;// extern const CLSID CLSID_CCDGeneralPropertyPage;// extern const CLSID CLSID_CCDGenericPropertyPage;// extern const CLSID CLSID_CCDFontPropertyPage;// extern const CLSID CLSID_CCDColorPropertyPage;// extern const CLSID CLSID_CCDLabelPropertyPage;// extern const CLSID CLSID_CCDCheckBoxPropertyPage;// extern const CLSID CLSID_CCDTextBoxPropertyPage;// extern const CLSID CLSID_CCDOptionButtonPropertyPage;// extern const CLSID CLSID_CCDListBoxPropertyPage;// extern const CLSID CLSID_CCDCommandButtonPropertyPage;// extern const CLSID CLSID_CCDComboBoxPropertyPage;// extern const CLSID CLSID_CCDScrollBarPropertyPage;// extern const CLSID CLSID_CCDGroupBoxPropertyPage;// extern const CLSID CLSID_CCDXObjectPropertyPage;// extern const CLSID CLSID_CStdPropertyFrame;// extern const CLSID CLSID_CFormPropertyPage;// extern const CLSID CLSID_CGridPropertyPage;// extern const CLSID CLSID_CWSJArticlePage;// extern const CLSID CLSID_CSystemPage;// extern const CLSID CLSID_IdentityUnmarshal;CLSCTX_INPROC_HANDLERCLSCTX_LOCAL_SERVERCLSCTX_REMOTE_SERVERobjidlSOLE_AUTHENTICATION_SERVICEobjidlbaseAPTTYPEAPTTYPEQUALIFIERCOSERVERINFOIActivationFilterIAgileReferenceLPMALLOCLPMARSHALLPSTREAMLPSURROGATEMULTI_QIpropidlPROPVARIANTLPUNKNOWNLISet32ULISet32CLSCTX_INPROCCLSCTX_SERVERCoGetMallocCreateStreamOnHGlobalGetHGlobalFromStreamCoGetCurrentProcessCoGetCallerTIDCoGetCurrentLogicalThreadIdCoGetContextTokenCoGetDefaultContextCoGetApartmentTypePServerInformationServerInformationCoDecodeProxyCoIncrementMTAUsageCO_MTA_USAGE_COOKIECoDecrementMTAUsageCoAllowUnmarshalerCLSIDCoGetObjectContextCoGetClassObjectCoRegisterClassObjectCoRevokeClassObjectCoResumeClassObjectsCoSuspendClassObjectsCoAddRefServerProcessCoReleaseServerProcessCoGetPSClsidCoRegisterPSClsidCoRegisterSurrogateCoGetMarshalSizeMaxCoMarshalInterfaceCoUnmarshalInterfaceCoMarshalHresultCoUnmarshalHresultCoReleaseMarshalDataCoDisconnectObjectCoLockObjectExternalCoGetStandardMarshalCoGetStdMarshalExCoIsHandlerConnectedCoMarshalInterThreadInterfaceInStreamCoGetInterfaceAndReleaseStreamCoCreateFreeThreadedMarshalerCoFreeUnusedLibrariesCoFreeUnusedLibrariesExCoDisconnectContextCoGetCallContextCoQueryProxyBlanketCoCopyProxyCoQueryClientBlanketCoImpersonateClientCoRevertToSelfCoQueryAuthenticationServicesCoSwitchCallContextCOM_RIGHTS_EXECUTECOM_RIGHTS_EXECUTE_LOCALCOM_RIGHTS_EXECUTE_REMOTECOM_RIGHTS_ACTIVATE_LOCALCOM_RIGHTS_ACTIVATE_REMOTECoCreateInstanceExCoRegisterActivationFilterCoCreateInstanceFromAppCoGetCancelObjectCoSetCancelObjectCoCancelCallCoTestCancelCoEnableCallCancellationCoDisableCallCancellationStringFromCLSIDCLSIDFromStringStringFromIIDIIDFromStringProgIDFromCLSIDCLSIDFromProgIDStringFromGUID2CoCreateGuidPropVariantCopyPropVariantClearFreePropVariantArrayCoWaitForMultipleHandlesCoWaitForMultipleObjectsCWMO_MAX_HANDLESCoGetTreatAsClassCoInvalidateRemoteMachineBindingsRoGetAgileReferenceAgileReferenceOptionsDllGetClassObjectDllCanUnloadNowCoTaskMemAllocCoTaskMemReallocCoFileTimeNowCLSIDFromProgIDEx//! Base Component Object Model defintions.STGM_READSTGM_WRITESTGM_READWRITE//! Structured storage, property sets, and related APIs.LPOVERLAPPEDLPCOMMCONFIGLPCOMMPROPLPCOMMTIMEOUTSLPCOMSTATLPDCBClearCommBreakClearCommErrorSetupCommEscapeCommFunctionGetCommConfigGetCommMaskGetCommModemStatusGetCommPropertiesGetCommStateGetCommTimeoutsPurgeCommSetCommBreakSetCommConfigSetCommMaskSetCommStateSetCommTimeoutsTransmitCommCharWaitCommEventHPENcommoncontrolsIImageListCB_DELETESTRINGIMAGE_BITMAPLPSCROLLINFOLPTRACKMOUSEEVENTNMHDRWINDOWPOSInitCommonControls//138LPINITCOMMONCONTROLSEXINITCOMMONCONTROLSEXICC_LISTVIEW_CLASSESICC_TREEVIEW_CLASSESICC_BAR_CLASSESICC_TAB_CLASSESICC_UPDOWN_CLASSICC_PROGRESS_CLASSICC_HOTKEY_CLASSICC_ANIMATE_CLASSICC_WIN95_CLASSESICC_DATE_CLASSESICC_USEREX_CLASSESICC_COOL_CLASSESICC_INTERNET_CLASSESICC_PAGESCROLLER_CLASSICC_NATIVEFNTCTL_CLASSICC_STANDARD_CLASSESICC_LINK_CLASSInitCommonControlsExODT_HEADERODT_TABODT_LISTVIEWLVM_FIRSTTV_FIRSTHDM_FIRSTTCM_FIRSTPGM_FIRSTECM_FIRSTBCM_FIRSTCBM_FIRSTCCM_FIRSTCCM_LASTCCM_SETBKCOLORLPCOLORSCHEMECOLORSCHEMECCM_SETCOLORSCHEMECCM_GETCOLORSCHEMECCM_GETDROPTARGETCCM_SETUNICODEFORMATCCM_GETUNICODEFORMATCCM_SETVERSIONCCM_GETVERSIONCCM_SETNOTIFYWINDOWCCM_SETWINDOWTHEMECCM_DPISCALEINFOTIPSIZENM_OUTOFMEMORYNM_CLICKNM_DBLCLKNM_RETURNNM_RCLICKNM_RDBLCLKNM_SETFOCUSNM_KILLFOCUSNM_CUSTOMDRAWNM_HOVERNM_NCHITTESTNM_KEYDOWNNM_RELEASEDCAPTURENM_SETCURSORNM_CHARNM_TOOLTIPSCREATEDNM_LDOWNNM_RDOWNNM_THEMECHANGEDNM_FONTCHANGEDNM_CUSTOMTEXTNM_TVSTATEIMAGECHANGINGLPNMTOOLTIPSCREATEDNMTOOLTIPSCREATEDLPNMMOUSENMMOUSENMCLICKLPNMCLICKLPNMOBJECTNOTIFYNMOBJECTNOTIFYLPNMKEYNMKEYLPNMCHARNMCHARLPNMCUSTOMTEXTNMCUSTOMTEXTNM_FIRSTNM_LASTLVN_FIRSTLVN_LASTHDN_FIRSTHDN_LASTTVN_FIRSTTVN_LASTTTN_FIRSTTTN_LASTTCN_FIRSTTCN_LASTCDN_FIRSTCDN_LASTTBN_FIRSTTBN_LASTUDN_FIRSTUDN_LASTDTN_FIRSTDTN_LASTMCN_FIRSTMCN_LASTDTN_FIRST2DTN_LAST2CBEN_FIRSTCBEN_LASTRBN_FIRSTRBN_LASTIPN_FIRSTIPN_LASTSBN_FIRSTSBN_LASTPGN_FIRSTPGN_LASTWMN_FIRSTWMN_LASTBCN_FIRSTBCN_LASTTRBN_FIRSTTRBN_LASTMSGF_COMMCTRL_BEGINDRAGMSGF_COMMCTRL_SIZEHEADERMSGF_COMMCTRL_DRAGSELECTMSGF_COMMCTRL_TOOLBARCUSTCDRF_DODEFAULTCDRF_NEWFONTCDRF_SKIPDEFAULTCDRF_DOERASECDRF_SKIPPOSTPAINTCDRF_NOTIFYPOSTPAINTCDRF_NOTIFYITEMDRAWCDRF_NOTIFYSUBITEMDRAWCDRF_NOTIFYPOSTERASECDDS_PREPAINTCDDS_POSTPAINTCDDS_PREERASECDDS_POSTERASECDDS_ITEMCDDS_ITEMPREPAINTCDDS_ITEMPOSTPAINTCDDS_ITEMPREERASECDDS_ITEMPOSTERASECDDS_SUBITEMCDIS_SELECTEDCDIS_GRAYEDCDIS_DISABLEDCDIS_CHECKEDCDIS_FOCUSCDIS_DEFAULTCDIS_HOTCDIS_MARKEDCDIS_INDETERMINATECDIS_SHOWKEYBOARDCUESCDIS_NEARHOTCDIS_OTHERSIDEHOTCDIS_DROPHILITEDLPNMCUSTOMDRAWNMCUSTOMDRAWLPNMTTCUSTOMDRAWNMTTCUSTOMDRAWLPNMCUSTOMSPLITRECTINFONMCUSTOMSPLITRECTINFONM_GETCUSTOMSPLITRECTCLR_NONECLR_DEFAULTIMAGELISTHIMAGELISTLPIMAGELISTDRAWPARAMSIMAGELISTDRAWPARAMSILC_MASKILC_COLORILC_COLORDDBILC_COLOR4ILC_COLOR8ILC_COLOR16ILC_COLOR24ILC_COLOR32ILC_PALETTEILC_MIRRORILC_PERITEMMIRRORILC_ORIGINALSIZEILC_HIGHQUALITYSCALEImageList_CreateImageList_DestroyImageList_GetImageCountImageList_SetImageCountImageList_AddImageList_ReplaceIconImageList_SetBkColorImageList_GetBkColorImageList_SetOverlayImageImageList_AddIconILD_NORMALILD_TRANSPARENTILD_MASKILD_IMAGEILD_ROPILD_BLEND25ILD_BLEND50ILD_OVERLAYMASKINDEXTOOVERLAYMASKILD_PRESERVEALPHAILD_SCALEILD_DPISCALEILD_ASYNCILD_SELECTEDILD_FOCUSILD_BLENDCLR_HILIGHTILS_NORMALILS_GLOWILS_SHADOWILS_SATURATEILS_ALPHAILGT_NORMALILGT_ASYNCImageList_DrawHBITMAP_CALLBACKImageList_ReplaceImageList_AddMaskedImageList_DrawExImageList_DrawIndirectImageList_RemoveImageList_GetIconImageList_LoadImageAImageList_LoadImageWILCF_MOVEILCF_SWAPImageList_CopyImageList_BeginDragImageList_EndDragImageList_DragEnterImageList_DragLeaveImageList_DragMoveImageList_SetDragCursorImageImageList_DragShowNolockImageList_GetDragImageImageList_RemoveAllImageList_ExtractIconImageList_LoadBitmapIStreamImageList_ReadImageList_WriteILP_NORMALILP_DOWNLEVELImageList_ReadExImageList_WriteExLPIMAGEINFOIMAGEINFOImageList_GetIconSizeImageList_SetIconSizeImageList_GetImageInfoImageList_MergeImageList_DuplicateHIMAGELIST_QueryInterfaceIImageListToHIMAGELISTWC_HEADERHDS_HORZHDS_BUTTONSHDS_HOTTRACKHDS_HIDDENHDS_DRAGDROPHDS_FULLDRAGHDS_FILTERBARHDS_FLATHDS_CHECKBOXESHDS_NOSIZINGHDS_OVERFLOWHDFT_ISSTRINGHDFT_ISNUMBERHDFT_ISDATEHDFT_HASNOVALUELPHD_TEXTFILTERAHD_TEXTFILTERALPHD_TEXTFILTERWHD_TEXTFILTERWLPHDITEMAHDITEMALPHDITEMWHDITEMWHDI_WIDTHHDI_HEIGHTHDI_TEXTHDI_FORMATHDI_LPARAMHDI_BITMAPHDI_IMAGEHDI_DI_SETITEMHDI_ORDERHDI_FILTERHDI_STATEHDF_LEFTHDF_RIGHTHDF_CENTERHDF_JUSTIFYMASKHDF_RTLREADINGHDF_BITMAPHDF_STRINGHDF_OWNERDRAWHDF_IMAGEHDF_BITMAP_ON_RIGHTHDF_SORTUPHDF_SORTDOWNHDF_CHECKBOXHDF_CHECKEDHDF_FIXEDWIDTHHDF_SPLITBUTTONHDIS_FOCUSEDHDM_GETITEMCOUNTHDM_INSERTITEMAHDM_INSERTITEMWHDM_DELETEITEMHDM_GETITEMAHDM_GETITEMWHDM_SETITEMAHDM_SETITEMWLPHDLAYOUTHDLAYOUTHDM_LAYOUTHHT_NOWHEREHHT_ONHEADERHHT_ONDIVIDERHHT_ONDIVOPENHHT_ONFILTERHHT_ONFILTERBUTTONHHT_ABOVEHHT_BELOWHHT_TORIGHTHHT_TOLEFTHHT_ONITEMSTATEICONHHT_ONDROPDOWNHHT_ONOVERFLOWLPHDHITTESTINFOHDHITTESTINFOHD_HITTESTINFOHDSIL_NORMALHDSIL_STATEHDM_HITTESTHDM_GETITEMRECTHDM_SETIMAGELISTHDM_GETIMAGELISTHDM_ORDERTOINDEXHDM_CREATEDRAGIMAGEHDM_GETORDERARRAYHDM_SETORDERARRAYHDM_SETHOTDIVIDERHDM_SETBITMAPMARGINHDM_GETBITMAPMARGINHDM_SETUNICODEFORMATHDM_GETUNICODEFORMATHDM_SETFILTERCHANGETIMEOUTHDM_EDITFILTERHDM_CLEARFILTERHDM_GETITEMDROPDOWNRECTHDM_GETOVERFLOWRECTHDM_GETFOCUSEDITEMHDM_SETFOCUSEDITEMHDN_ITEMCHANGINGAHDN_ITEMCHANGINGWHDN_ITEMCHANGEDAHDN_ITEMCHANGEDWHDN_ITEMCLICKAHDN_ITEMCLICKWHDN_ITEMDBLCLICKAHDN_ITEMDBLCLICKWHDN_DIVIDERDBLCLICKAHDN_DIVIDERDBLCLICKWHDN_BEGINTRACKAHDN_BEGINTRACKWHDN_ENDTRACKAHDN_ENDTRACKWHDN_TRACKAHDN_TRACKWHDN_GETDISPINFOAHDN_GETDISPINFOWHDN_BEGINDRAGHDN_ENDDRAGHDN_FILTERCHANGEHDN_FILTERBTNCLICKHDN_BEGINFILTEREDITHDN_ENDFILTEREDITHDN_ITEMSTATEICONCLICKHDN_ITEMKEYDOWNHDN_DROPDOWNHDN_OVERFLOWCLICKLPNMHEADERANMHEADERAHD_NOTIFYALPNMHEADERWNMHEADERWHD_NOTIFYWLPNMHDDISPINFOWNMHDDISPINFOWLPNMHDDISPINFOANMHDDISPINFOALPNMHDFILTERBTNCLICKNMHDFILTERBTNCLICKTOOLBARCLASSNAMEPTBBUTTONTBBUTTONLPTBBUTTONLPCTBBUTTONLPCOLORMAPCOLORMAPCreateToolbarExCreateMappedBitmapCMB_MASKEDTBSTATE_CHECKEDTBSTATE_PRESSEDTBSTATE_ENABLEDTBSTATE_HIDDENTBSTATE_INDETERMINATETBSTATE_WRAPTBSTATE_ELLIPSESTBSTATE_MARKEDTBSTYLE_BUTTONTBSTYLE_SEPTBSTYLE_CHECKTBSTYLE_GROUPTBSTYLE_CHECKGROUPTBSTYLE_DROPDOWNTBSTYLE_AUTOSIZETBSTYLE_NOPREFIXTBSTYLE_TOOLTIPSTBSTYLE_WRAPABLETBSTYLE_ALTDRAGTBSTYLE_FLATTBSTYLE_LISTTBSTYLE_CUSTOMERASETBSTYLE_REGISTERDROPTBSTYLE_TRANSPARENTTBSTYLE_EX_DRAWDDARROWSBTNS_BUTTONBTNS_SEPBTNS_CHECKBTNS_GROUPBTNS_CHECKGROUPBTNS_DROPDOWNBTNS_AUTOSIZEBTNS_NOPREFIXBTNS_SHOWTEXTBTNS_WHOLEDROPDOWNTBSTYLE_EX_MIXEDBUTTONSTBSTYLE_EX_HIDECLIPPEDBUTTONSTBSTYLE_EX_MULTICOLUMNTBSTYLE_EX_VERTICALTBSTYLE_EX_DOUBLEBUFFERLPNMTBCUSTOMDRAWNMTBCUSTOMDRAWTBCDRF_NOEDGESTBCDRF_HILITEHOTTRACKTBCDRF_NOOFFSETTBCDRF_NOMARKTBCDRF_NOETCHEDEFFECTTBCDRF_BLENDICONTBCDRF_NOBACKGROUNDTBCDRF_USECDCOLORSTB_ENABLEBUTTONTB_CHECKBUTTONTB_PRESSBUTTONTB_HIDEBUTTONTB_INDETERMINATETB_MARKBUTTONTB_ISBUTTONENABLEDTB_ISBUTTONCHECKEDTB_ISBUTTONPRESSEDTB_ISBUTTONHIDDENTB_ISBUTTONINDETERMINATETB_ISBUTTONHIGHLIGHTEDTB_SETSTATETB_GETSTATETB_ADDBITMAPLPTBADDBITMAPTBADDBITMAPHINST_COMMCTRLIDB_STD_SMALL_COLORIDB_STD_LARGE_COLORIDB_VIEW_SMALL_COLORIDB_VIEW_LARGE_COLORIDB_HIST_SMALL_COLORIDB_HIST_LARGE_COLORIDB_HIST_NORMALIDB_HIST_HOTIDB_HIST_DISABLEDIDB_HIST_PRESSEDSTD_CUTSTD_COPYSTD_PASTESTD_UNDOSTD_REDOWSTD_DELETESTD_FILENEWSTD_FILEOPENSTD_FILESAVESTD_PRINTPRESTD_PROPERTIESSTD_HELPSTD_FINDSTD_REPLACESTD_PRINTVIEW_LARGEICONSVIEW_SMALLICONSVIEW_LISTVIEW_DETAILSVIEW_SORTNAMEVIEW_SORTSIZEVIEW_SORTDATEVIEW_SORTTYPEVIEW_PARENTFOLDERVIEW_NETCONNECTVIEW_NETDISCONNECTVIEW_NEWFOLDERVIEW_VIEWMENUHIST_BACKHIST_FORWARDHIST_FAVORITESHIST_ADDTOFAVORITESHIST_VIEWTREETB_ADDBUTTONSATB_INSERTBUTTONATB_DELETEBUTTONTB_GETBUTTONTB_BUTTONCOUNTTB_COMMANDTOINDEXLPTBSAVEPARAMSATBSAVEPARAMSALPTBSAVEPARAMSWTBSAVEPARAMSWTB_SAVERESTOREATB_SAVERESTOREWTB_CUSTOMIZETB_ADDSTRINGATB_ADDSTRINGWTB_GETITEMRECTTB_BUTTONSTRUCTSIZETB_SETBUTTONSIZETB_SETBITMAPSIZETB_AUTOSIZETB_GETTOOLTIPSTB_SETTOOLTIPSTB_SETPARENTTB_SETROWSTB_GETROWSTB_SETCMDIDTB_CHANGEBITMAPTB_GETBITMAPTB_GETBUTTONTEXTATB_GETBUTTONTEXTWTB_REPLACEBITMAPTB_SETINDENTTB_SETIMAGELISTTB_GETIMAGELISTTB_LOADIMAGESTB_GETRECTTB_SETHOTIMAGELISTTB_GETHOTIMAGELISTTB_SETDISABLEDIMAGELISTTB_GETDISABLEDIMAGELISTTB_SETSTYLETB_GETSTYLETB_GETBUTTONSIZETB_SETBUTTONWIDTHTB_SETMAXTEXTROWSTB_GETTEXTROWSTB_GETOBJECTTB_GETHOTITEMTB_SETHOTITEMTB_SETANCHORHIGHLIGHTTB_GETANCHORHIGHLIGHTTB_MAPACCELERATORALPTBINSERTMARKTBINSERTMARKTBIMHT_AFTERTBIMHT_BACKGROUNDTB_GETINSERTMARKTB_SETINSERTMARKTB_INSERTMARKHITTESTTB_MOVEBUTTONTB_GETMAXSIZETB_SETEXTENDEDSTYLETB_GETEXTENDEDSTYLETB_GETPADDINGTB_SETPADDINGTB_SETINSERTMARKCOLORTB_GETINSERTMARKCOLORTB_SETCOLORSCHEMETB_GETCOLORSCHEMETB_SETUNICODEFORMATTB_GETUNICODEFORMATTB_MAPACCELERATORWLPTBREPLACEBITMAPTBREPLACEBITMAPTBBF_LARGETB_GETBITMAPFLAGSTBIF_IMAGETBIF_TEXTTBIF_STATETBIF_STYLETBIF_LPARAMTBIF_COMMANDTBIF_SIZETBIF_BYINDEXLPTBBUTTONINFOATBBUTTONINFOALPTBBUTTONINFOWTBBUTTONINFOWTB_GETBUTTONINFOWTB_SETBUTTONINFOWTB_GETBUTTONINFOATB_SETBUTTONINFOATB_INSERTBUTTONWTB_ADDBUTTONSWTB_HITTESTTB_SETDRAWTEXTFLAGSTB_GETSTRINGWTB_GETSTRINGATB_SETBOUNDINGSIZETB_SETHOTITEM2TB_HASACCELERATORTB_SETLISTGAPTB_GETIMAGELISTCOUNTTB_GETIDEALSIZETBMF_PADTBMF_BARPADTBMF_BUTTONSPACINGLPTBMETRICSTBMETRICSTB_GETMETRICSTB_SETMETRICSTB_GETITEMDROPDOWNRECTTB_SETPRESSEDIMAGELISTTB_GETPRESSEDIMAGELISTTB_SETWINDOWTHEMETBN_GETBUTTONINFOATBN_BEGINDRAGTBN_ENDDRAGTBN_BEGINADJUSTTBN_ENDADJUSTTBN_RESETTBN_QUERYINSERTTBN_QUERYDELETETBN_TOOLBARCHANGETBN_CUSTHELPTBN_DROPDOWNTBN_GETOBJECTLPNMTBHOTITEMNMTBHOTITEMHICF_OTHERHICF_MOUSEHICF_ARROWKEYSHICF_ACCELERATORHICF_DUPACCELHICF_ENTERINGHICF_LEAVINGHICF_RESELECTHICF_LMOUSEHICF_TOGGLEDROPDOWNTBN_HOTITEMCHANGETBN_DRAGOUTTBN_DELETINGBUTTONTBN_GETDISPINFOATBN_GETDISPINFOWTBN_GETINFOTIPATBN_GETINFOTIPWTBN_GETBUTTONINFOWTBN_RESTORETBN_SAVETBN_INITCUSTOMIZETBNRF_HIDEHELPTBNRF_ENDCUSTOMIZETBN_WRAPHOTITEMTBN_DUPACCELERATORTBN_WRAPACCELERATORTBN_DRAGOVERTBN_MAPACCELERATORLPNMTBSAVENMTBSAVELPNMTBRESTORENMTBRESTORELPNMTBGETINFOTIPANMTBGETINFOTIPALPNMTBGETINFOTIPWNMTBGETINFOTIPWTBNF_IMAGETBNF_TEXTTBNF_DI_SETITEMLPNMTBDISPINFOANMTBDISPINFOALPNMTBDISPINFOWNMTBDISPINFOWTBDDRET_DEFAULTTBDDRET_NODEFAULTTBDDRET_TREATPRESSEDTBNOTIFYANMTOOLBARATBNOTIFYWNMTOOLBARWLPTBNOTIFYALPNMTOOLBARALPTBNOTIFYWLPNMTOOLBARWREBARCLASSNAMERBIM_IMAGELISTRBS_TOOLTIPSRBS_VARHEIGHTRBS_BANDBORDERSRBS_FIXEDORDERRBS_REGISTERDROPRBS_AUTOSIZERBS_VERTICALGRIPPERRBS_DBLCLKTOGGLELPREBARINFOREBARINFORBBS_BREAKRBBS_FIXEDSIZERBBS_CHILDEDGERBBS_HIDDENRBBS_NOVERTRBBS_FIXEDBMPRBBS_VARIABLEHEIGHTRBBS_GRIPPERALWAYSRBBS_NOGRIPPERRBBS_USECHEVRONRBBS_HIDETITLERBBS_TOPALIGNRBBIM_STYLERBBIM_COLORSRBBIM_TEXTRBBIM_IMAGERBBIM_CHILDRBBIM_CHILDSIZERBBIM_SIZERBBIM_BACKGROUNDRBBIM_IDRBBIM_IDEALSIZERBBIM_LPARAMRBBIM_HEADERSIZERBBIM_CHEVRONLOCATIONRBBIM_CHEVRONSTATELPREBARBANDINFOAREBARBANDINFOALPCREBARBANDINFOALPREBARBANDINFOWREBARBANDINFOWLPCREBARBANDINFOWRB_INSERTBANDARB_DELETEBANDRB_GETBARINFORB_SETBARINFORB_SETBANDINFOARB_SETPARENTRB_HITTESTRB_GETRECTRB_INSERTBANDWRB_SETBANDINFOWRB_GETBANDCOUNTRB_GETROWCOUNTRB_GETROWHEIGHTRB_IDTOINDEXRB_GETTOOLTIPSRB_SETTOOLTIPSRB_SETBKCOLORRB_GETBKCOLORRB_SETTEXTCOLORRB_GETTEXTCOLORRBSTR_CHANGERECTRB_SIZETORECTRB_SETCOLORSCHEMERB_GETCOLORSCHEMERB_BEGINDRAGRB_ENDDRAGRB_DRAGMOVERB_GETBARHEIGHTRB_GETBANDINFOWRB_GETBANDINFOARB_MINIMIZEBANDRB_MAXIMIZEBANDRB_GETDROPTARGETRB_GETBANDBORDERSRB_SHOWBANDRB_SETPALETTERB_GETPALETTERB_MOVEBANDRB_SETUNICODEFORMATRB_GETUNICODEFORMATRB_GETBANDMARGINSRB_SETWINDOWTHEMERB_SETEXTENDEDSTYLERB_GETEXTENDEDSTYLERB_PUSHCHEVRONRB_SETBANDWIDTHRBN_HEIGHTCHANGERBN_GETOBJECTRBN_LAYOUTCHANGEDRBN_AUTOSIZERBN_BEGINDRAGRBN_ENDDRAGRBN_DELETINGBANDRBN_DELETEDBANDRBN_CHILDSIZERBN_CHEVRONPUSHEDRBN_SPLITTERDRAGRBN_MINMAXRBN_AUTOBREAKLPNMREBARCHILDSIZENMREBARCHILDSIZELPNMREBARNMREBARRBNM_IDRBNM_STYLERBNM_LPARAMLPNMRBAUTOSIZENMRBAUTOSIZELPNMREBARCHEVRONNMREBARCHEVRONLPNMREBARSPLITTERNMREBARSPLITTERRBAB_AUTOSIZERBAB_ADDBANDLPNMREBARAUTOBREAKNMREBARAUTOBREAKRBHT_NOWHERERBHT_CAPTIONRBHT_CLIENTRBHT_GRABBERRBHT_CHEVRONRBHT_SPLITTERLPRBHITTESTINFORBHITTESTINFOTOOLTIPS_CLASSLPTOOLINFOALPTTTOOLINFOALPTOOLINFOWLPTTTOOLINFOWTOOLINFOATTTOOLINFOATOOLINFOWTTTOOLINFOWPTTTOOLINFOAPTTTOOLINFOWTTS_ALWAYSTIPTTS_NOPREFIXTTS_NOANIMATETTS_NOFADETTS_BALLOONTTS_CLOSETTS_USEVISUALSTYLETTF_IDISHWNDTTF_CENTERTIPTTF_RTLREADINGTTF_SUBCLASSTTF_TRACKTTF_ABSOLUTETTF_TRANSPARENTTTF_PARSELINKSTTF_DI_SETITEMTTDT_AUTOMATICTTDT_RESHOWTTDT_AUTOPOPTTDT_INITIALTTI_NONETTI_INFOTTI_WARNINGTTI_ERRORTTI_INFO_LARGETTI_WARNING_LARGETTI_ERROR_LARGETTM_ACTIVATETTM_SETDELAYTIMETTM_ADDTOOLATTM_ADDTOOLWTTM_DELTOOLATTM_DELTOOLWTTM_NEWTOOLRECTATTM_NEWTOOLRECTWTTM_RELAYEVENTTTM_GETTOOLINFOATTM_GETTOOLINFOWTTM_SETTOOLINFOATTM_SETTOOLINFOWTTM_HITTESTATTM_HITTESTWTTM_GETTEXTATTM_GETTEXTWTTM_UPDATETIPTEXTATTM_UPDATETIPTEXTWTTM_GETTOOLCOUNTTTM_ENUMTOOLSATTM_ENUMTOOLSWTTM_GETCURRENTTOOLATTM_GETCURRENTTOOLWTTM_WINDOWFROMPOINTTTM_TRACKACTIVATETTM_TRACKPOSITIONTTM_SETTIPBKCOLORTTM_SETTIPTEXTCOLORTTM_GETDELAYTIMETTM_GETTIPBKCOLORTTM_GETTIPTEXTCOLORTTM_SETMAXTIPWIDTHTTM_GETMAXTIPWIDTHTTM_SETMARGINTTM_GETMARGINTTM_POPTTM_UPDATETTM_GETBUBBLESIZETTM_ADJUSTRECTTTM_SETTITLEATTM_SETTITLEWTTM_POPUPTTM_GETTITLELPTTGETTITLETTGETTITLETTM_SETWINDOWTHEMELPHITTESTINFOWLPTTHITTESTINFOWLPHITTESTINFOALPTTHITTESTINFOATTHITTESTINFOATTHITTESTINFOWTTN_GETDISPINFOATTN_GETDISPINFOWTTN_SHOWTTN_POPTTN_LINKCLICKTTN_NEEDTEXTATTN_NEEDTEXTWTOOLTIPTEXTWNMTTDISPINFOWTOOLTIPTEXTANMTTDISPINFOALPTOOLTIPTEXTALPNMTTDISPINFOALPTOOLTIPTEXTWLPNMTTDISPINFOWSBARS_SIZEGRIPSBARS_TOOLTIPSSBT_TOOLTIPSDrawStatusTextADrawStatusTextWCreateStatusWindowACreateStatusWindowWSTATUSCLASSNAMESB_SETTEXTASB_SETTEXTWSB_GETTEXTASB_GETTEXTWSB_GETTEXTLENGTHASB_GETTEXTLENGTHWSB_SETPARTSSB_GETPARTSSB_GETBORDERSSB_SETMINHEIGHTSB_SIMPLESB_GETRECTSB_ISSIMPLESB_SETICONSB_SETTIPTEXTASB_SETTIPTEXTWSB_GETTIPTEXTASB_GETTIPTEXTWSB_GETICONSB_SETUNICODEFORMATSB_GETUNICODEFORMATSBT_OWNERDRAWSBT_NOBORDERSSBT_POPOUTSBT_RTLREADINGSBT_NOTABPARSINGSB_SETBKCOLORSBN_SIMPLEMODECHANGESB_SIMPLEIDMenuHelpShowHideMenuCtlGetEffectiveClientRectTRACKBAR_CLASSTBS_AUTOTICKSTBS_VERTTBS_HORZTBS_TOPTBS_BOTTOMTBS_LEFTTBS_RIGHTTBS_BOTHTBS_NOTICKSTBS_ENABLESELRANGETBS_FIXEDLENGTHTBS_NOTHUMBTBS_TOOLTIPSTBS_REVERSEDTBS_DOWNISLEFTTBS_NOTIFYBEFOREMOVETBS_TRANSPARENTBKGNDTBM_GETPOSTBM_GETRANGEMINTBM_GETRANGEMAXTBM_GETTICTBM_SETTICTBM_SETPOSTBM_SETRANGETBM_SETRANGEMINTBM_SETRANGEMAXTBM_CLEARTICSTBM_SETSELTBM_SETSELSTARTTBM_SETSELENDTBM_GETPTICSTBM_GETTICPOSTBM_GETNUMTICSTBM_GETSELSTARTTBM_GETSELENDTBM_CLEARSELTBM_SETTICFREQTBM_SETPAGESIZETBM_GETPAGESIZETBM_SETLINESIZETBM_GETLINESIZETBM_GETTHUMBRECTTBM_GETCHANNELRECTTBM_SETTHUMBLENGTHTBM_GETTHUMBLENGTHTBM_SETTOOLTIPSTBM_GETTOOLTIPSTBM_SETTIPSIDETBTS_TOPTBTS_LEFTTBTS_BOTTOMTBTS_RIGHTTBM_SETBUDDYTBM_GETBUDDYTBM_SETPOSNOTIFYTBM_SETUNICODEFORMATTBM_GETUNICODEFORMATTB_LINEUPTB_LINEDOWNTB_PAGEUPTB_PAGEDOWNTB_THUMBPOSITIONTB_THUMBTRACKTB_TOPTB_BOTTOMTB_ENDTRACKTBCD_TICSTBCD_THUMBTBCD_CHANNELTRBN_THUMBPOSCHANGINGLPDRAGLISTINFODRAGLISTINFODL_BEGINDRAGDL_DRAGGINGDL_DROPPEDDL_CANCELDRAGDL_CURSORSETDL_STOPCURSORDL_COPYCURSORDL_MOVECURSORDRAGLISTMSGSTRINGMakeDragListDrawInsertLBItemFromPtUPDOWN_CLASSLPUDACCELUDACCELUD_MAXVALUD_MINVALUDS_WRAPUDS_SETBUDDYINTUDS_ALIGNRIGHTUDS_ALIGNLEFTUDS_AUTOBUDDYUDS_ARROWKEYSUDS_HORZUDS_NOTHOUSANDSUDS_HOTTRACKUDM_SETRANGEUDM_GETRANGEUDM_SETPOSUDM_GETPOSUDM_SETBUDDYUDM_GETBUDDYUDM_SETACCELUDM_GETACCELUDM_SETBASEUDM_GETBASEUDM_SETRANGE32UDM_GETRANGE32UDM_SETUNICODEFORMATUDM_GETUNICODEFORMATUDM_SETPOS32UDM_GETPOS32CreateUpDownControlNM_UPDOWNNMUPDOWNLPNM_UPDOWNLPNMUPDOWNUDN_DELTAPOSPROGRESS_CLASSPBS_SMOOTHPBS_VERTICALPBM_SETRANGEPBM_SETPOSPBM_DELTAPOSPBM_SETSTEPPBM_STEPITPBM_SETRANGE32LPPBRANGEPBRANGEPBM_GETRANGEPBM_GETPOSPBM_SETBARCOLORPBM_SETBKCOLORPBS_MARQUEEPBM_SETMARQUEEPBS_SMOOTHREVERSEPBM_GETSTEPPBM_GETBKCOLORPBM_GETBARCOLORPBM_SETSTATEPBM_GETSTATEPBST_NORMALPBST_ERRORPBST_PAUSEDHOTKEYF_SHIFTHOTKEYF_CONTROLHOTKEYF_ALTHOTKEYF_EXTHKCOMB_NONEHKCOMB_SHKCOMB_CHKCOMB_AHKCOMB_SCHKCOMB_SAHKCOMB_CAHKCOMB_SCAHKM_SETHOTKEYHKM_GETHOTKEYHKM_SETRULESHOTKEY_CLASSCCS_TOPCCS_NOMOVEYCCS_BOTTOMCCS_NORESIZECCS_NOPARENTALIGNCCS_ADJUSTABLECCS_NODIVIDERCCS_VERTCCS_LEFTCCS_RIGHTCCS_NOMOVEXINVALID_LINK_INDEXMAX_LINKID_TEXTL_MAX_URL_LENGTHWC_LINKLWS_TRANSPARENTLWS_IGNORERETURNLWS_NOPREFIXLWS_USEVISUALSTYLELWS_USECUSTOMTEXTLWS_RIGHTLIF_ITEMINDEXLIF_STATELIF_ITEMIDLIF_URLLIS_FOCUSEDLIS_ENABLEDLIS_VISITEDLIS_HOTTRACKLIS_DEFAULTCOLORSPLITEMLITEMPLHITTESTINFOLHITTESTINFOPNMLINKNMLINKLM_HITTESTLM_GETIDEALHEIGHTLM_SETITEMLM_GETITEMLM_GETIDEALSIZEWC_LISTVIEWLVS_ICONLVS_REPORTLVS_SMALLICONLVS_LISTLVS_TYPEMASKLVS_SINGLESELLVS_SHOWSELALWAYSLVS_SORTASCENDINGLVS_SORTDESCENDINGLVS_SHAREIMAGELISTSLVS_NOLABELWRAPLVS_AUTOARRANGELVS_EDITLABELSLVS_OWNERDATALVS_NOSCROLLLVS_TYPESTYLEMASKLVS_ALIGNTOPLVS_ALIGNLEFTLVS_ALIGNMASKLVS_OWNERDRAWFIXEDLVS_NOCOLUMNHEADERLVS_NOSORTHEADERLVM_SETUNICODEFORMATLVM_GETUNICODEFORMATLVM_GETBKCOLORLVM_SETBKCOLORLVM_GETIMAGELISTLVSIL_NORMALLVSIL_SMALLLVSIL_STATELVSIL_GROUPHEADERLVM_SETIMAGELISTLVM_GETITEMCOUNTLVIF_TEXTLVIF_IMAGELVIF_PARAMLVIF_STATELVIF_INDENTLVIF_NORECOMPUTELVIF_GROUPIDLVIF_COLUMNSLVIF_COLFMTLVIS_FOCUSEDLVIS_SELECTEDLVIS_CUTLVIS_DROPHILITEDLVIS_GLOWLVIS_ACTIVATINGLVIS_OVERLAYMASKLVIS_STATEIMAGEMASKINDEXTOSTATEIMAGEMASKI_INDENTCALLBACKLV_ITEMALVITEMALV_ITEMWLVITEMWI_GROUPIDCALLBACKI_GROUPIDNONELPLVITEMALPLVITEMWLPSTR_TEXTCALLBACKWLPSTR_TEXTCALLBACKAI_IMAGECALLBACKI_IMAGENONEI_COLUMNSCALLBACKLVM_GETITEMALVM_GETITEMWLVM_SETITEMALVM_SETITEMWLVM_INSERTITEMALVM_INSERTITEMWLVM_DELETEITEMLVM_DELETEALLITEMSLVM_GETCALLBACKMASKLVM_SETCALLBACKMASKLVNI_ALLLVNI_FOCUSEDLVNI_SELECTEDLVNI_CUTLVNI_DROPHILITEDLVNI_STATEMASKLVNI_VISIBLEORDERLVNI_PREVIOUSLVNI_VISIBLEONLYLVNI_SAMEGROUPONLYLVNI_ABOVELVNI_BELOWLVNI_TOLEFTLVNI_TORIGHTLVNI_DIRECTIONMASKLVM_GETNEXTITEMLVFI_PARAMLVFI_STRINGLVFI_SUBSTRINGLVFI_PARTIALLVFI_WRAPLVFI_NEARESTXYLV_FINDINFOALVFINDINFOALV_FINDINFOWLVFINDINFOWLPFINDINFOALPFINDINFOWLVM_FINDITEMALVM_FINDITEMWLVIR_BOUNDSLVIR_ICONLVIR_LABELLVIR_SELECTBOUNDSLVM_GETITEMRECTLVM_SETITEMPOSITIONLVM_GETITEMPOSITIONLVM_GETSTRINGWIDTHALVM_GETSTRINGWIDTHWLVHT_NOWHERELVHT_ONITEMICONLVHT_ONITEMLABELLVHT_ONITEMSTATEICONLVHT_ONITEMLVHT_ABOVELVHT_BELOWLVHT_TORIGHTLVHT_TOLEFTLVHT_EX_GROUP_HEADERLVHT_EX_GROUP_FOOTERLVHT_EX_GROUP_COLLAPSELVHT_EX_GROUP_BACKGROUNDLVHT_EX_GROUP_STATEICONLVHT_EX_GROUP_SUBSETLINKLVHT_EX_GROUPLVHT_EX_ONCONTENTSLVHT_EX_FOOTERLV_HITTESTINFOLVHITTESTINFOLPLVHITTESTINFOLVM_HITTESTLVM_ENSUREVISIBLELVM_SCROLLLVM_REDRAWITEMSLVA_DEFAULTLVA_ALIGNLEFTLVA_ALIGNTOPLVA_SNAPTOGRIDLVM_ARRANGELVM_EDITLABELALVM_EDITLABELWLVM_GETEDITCONTROLLV_COLUMNALVCOLUMNALV_COLUMNWLVCOLUMNWLPLVCOLUMNALPLVCOLUMNWLVCF_FMTLVCF_WIDTHLVCF_TEXTLVCF_SUBITEMLVCF_IMAGELVCF_ORDERLVCF_MINWIDTHLVCF_DEFAULTWIDTHLVCF_IDEALWIDTHLVCFMT_LEFTLVCFMT_RIGHTLVCFMT_CENTERLVCFMT_JUSTIFYMASKLVCFMT_IMAGELVCFMT_BITMAP_ON_RIGHTLVCFMT_COL_HAS_IMAGESLVCFMT_FIXED_WIDTHLVCFMT_NO_DPI_SCALELVCFMT_FIXED_RATIOLVCFMT_LINE_BREAKLVCFMT_FILLLVCFMT_WRAPLVCFMT_NO_TITLELVCFMT_TILE_PLACEMENTMASKLVCFMT_SPLITBUTTONLVM_GETCOLUMNALVM_GETCOLUMNWLVM_SETCOLUMNALVM_SETCOLUMNWLVM_INSERTCOLUMNALVM_INSERTCOLUMNWLVM_DELETECOLUMNLVM_GETCOLUMNWIDTHLVSCW_AUTOSIZELVSCW_AUTOSIZE_USEHEADERLVM_SETCOLUMNWIDTHLVM_GETHEADERLVM_CREATEDRAGIMAGELVM_GETVIEWRECTLVM_GETTEXTCOLORLVM_SETTEXTCOLORLVM_GETTEXTBKCOLORLVM_SETTEXTBKCOLORLVM_GETTOPINDEXLVM_GETCOUNTPERPAGELVM_GETORIGINLVM_UPDATELVM_SETITEMSTATELVM_GETITEMSTATELVM_GETITEMTEXTALVM_GETITEMTEXTWLVM_SETITEMTEXTALVM_SETITEMTEXTWLVSICF_NOINVALIDATEALLLVSICF_NOSCROLLLVM_SETITEMCOUNTLVM_SORTITEMSLVM_SETITEMPOSITION32LVM_GETSELECTEDCOUNTLVM_GETITEMSPACINGLVM_GETISEARCHSTRINGALVM_GETISEARCHSTRINGWLVM_SETICONSPACINGLVM_SETEXTENDEDLISTVIEWSTYLELVM_GETEXTENDEDLISTVIEWSTYLELVS_EX_GRIDLINESLVS_EX_SUBITEMIMAGESLVS_EX_CHECKBOXESLVS_EX_TRACKSELECTLVS_EX_HEADERDRAGDROPLVS_EX_FULLROWSELECTLVS_EX_ONECLICKACTIVATELVS_EX_TWOCLICKACTIVATELVS_EX_FLATSBLVS_EX_REGIONALLVS_EX_INFOTIPLVS_EX_UNDERLINEHOTLVS_EX_UNDERLINECOLDLVS_EX_MULTIWORKAREASLVS_EX_LABELTIPLVS_EX_BORDERSELECTLVS_EX_DOUBLEBUFFERLVS_EX_HIDELABELSLVS_EX_SINGLEROWLVS_EX_SNAPTOGRIDLVS_EX_SIMPLESELECTLVS_EX_JUSTIFYCOLUMNSLVS_EX_TRANSPARENTBKGNDLVS_EX_TRANSPARENTSHADOWTEXTLVS_EX_AUTOAUTOARRANGELVS_EX_HEADERINALLVIEWSLVS_EX_AUTOCHECKSELECTLVS_EX_AUTOSIZECOLUMNSLVS_EX_COLUMNSNAPPOINTSLVS_EX_COLUMNOVERFLOWLVM_GETSUBITEMRECTLVM_SUBITEMHITTESTLVM_SETCOLUMNORDERARRAYLVM_GETCOLUMNORDERARRAYLVM_SETHOTITEMLVM_GETHOTITEMLVM_SETHOTCURSORLVM_GETHOTCURSORLVM_APPROXIMATEVIEWRECTLV_MAX_WORKAREASLVM_SETWORKAREASLVM_GETWORKAREASLVM_GETNUMBEROFWORKAREASLVM_GETSELECTIONMARKLVM_SETSELECTIONMARKLVM_SETHOVERTIMELVM_GETHOVERTIMELVM_SETTOOLTIPSLVM_GETTOOLTIPSLVM_SORTITEMSEXLPLVBKIMAGEALVBKIMAGEALPLVBKIMAGEWLVBKIMAGEWLVBKIF_SOURCE_NONELVBKIF_SOURCE_HBITMAPLVBKIF_SOURCE_URLLVBKIF_SOURCE_MASKLVBKIF_STYLE_NORMALLVBKIF_STYLE_TILELVBKIF_STYLE_MASKLVBKIF_FLAG_TILEOFFSETLVBKIF_TYPE_WATERMARKLVBKIF_FLAG_ALPHABLENDLVM_SETBKIMAGEALVM_SETBKIMAGEWLVM_GETBKIMAGEALVM_GETBKIMAGEWLVM_SETSELECTEDCOLUMNLV_VIEW_ICONLV_VIEW_DETAILSLV_VIEW_SMALLICONLV_VIEW_LISTLV_VIEW_TILELV_VIEW_MAXLVM_SETVIEWLVM_GETVIEWLVGF_NONELVGF_HEADERLVGF_FOOTERLVGF_STATELVGF_ALIGNLVGF_GROUPIDLVGF_SUBTITLELVGF_TASKLVGF_DESCRIPTIONTOPLVGF_DESCRIPTIONBOTTOMLVGF_TITLEIMAGELVGF_EXTENDEDIMAGELVGF_ITEMSLVGF_SUBSETLVGF_SUBSETITEMSLVGS_NORMALLVGS_COLLAPSEDLVGS_HIDDENLVGS_NOHEADERLVGS_COLLAPSIBLELVGS_FOCUSEDLVGS_SELECTEDLVGS_SUBSETEDLVGS_SUBSETLINKFOCUSEDLVGA_HEADER_LEFTLVGA_HEADER_CENTERLVGA_HEADER_RIGHTLVGA_FOOTER_LEFTLVGA_FOOTER_CENTERLVGA_FOOTER_RIGHTPLVGROUPLVGROUPLVM_INSERTGROUPLVM_SETGROUPINFOLVM_GETGROUPINFOLVM_REMOVEGROUPLVM_MOVEGROUPLVM_GETGROUPCOUNTLVM_GETGROUPINFOBYINDEXLVM_MOVEITEMTOGROUPLVGGR_GROUPLVGGR_HEADERLVGGR_LABELLVGGR_SUBSETLINKLVM_GETGROUPRECTLVGMF_NONELVGMF_BORDERSIZELVGMF_BORDERCOLORLVGMF_TEXTCOLORPLVGROUPMETRICSLVGROUPMETRICSLVM_SETGROUPMETRICSLVM_GETGROUPMETRICSLVM_ENABLEGROUPVIEWLVM_SORTGROUPSPLVINSERTGROUPSORTEDLVINSERTGROUPSORTEDLVM_INSERTGROUPSORTEDLVM_REMOVEALLGROUPSLVM_HASGROUPLVM_GETGROUPSTATELVM_GETFOCUSEDGROUPLVTVIF_AUTOSIZELVTVIF_FIXEDWIDTHLVTVIF_FIXEDHEIGHTLVTVIF_FIXEDSIZELVTVIF_EXTENDEDLVTVIM_TILESIZELVTVIM_COLUMNSLVTVIM_LABELMARGINPLVTILEVIEWINFOLVTILEVIEWINFOPLVTILEINFOLVTILEINFOLVM_SETTILEVIEWINFOLVM_GETTILEVIEWINFOLVM_SETTILEINFOLVM_GETTILEINFOLPLVINSERTMARKLVINSERTMARKLVIM_AFTERLVM_SETINSERTMARKLVM_GETINSERTMARKLVM_INSERTMARKHITTESTLVM_GETINSERTMARKRECTLVM_SETINSERTMARKCOLORLVM_GETINSERTMARKCOLORPLVSETINFOTIPLVSETINFOTIPLVM_SETINFOTIPLVM_GETSELECTEDCOLUMNLVM_ISGROUPVIEWENABLEDLVM_GETOUTLINECOLORLVM_SETOUTLINECOLORLVM_CANCELEDITLABELLVM_MAPINDEXTOIDLVM_MAPIDTOINDEXLVM_ISITEMVISIBLELVM_GETEMPTYTEXTLVM_GETFOOTERRECTLVFF_ITEMCOUNTLPLVFOOTERINFOLVFOOTERINFOLVM_GETFOOTERINFOLVM_GETFOOTERITEMRECTLVFIF_TEXTLVFIF_STATELVFIS_FOCUSEDLPLVFOOTERITEMLVFOOTERITEMLVM_GETFOOTERITEMPLVITEMINDEXLVITEMINDEXLVM_GETITEMINDEXRECTLVM_SETITEMINDEXSTATELVM_GETNEXTITEMINDEXLPNM_LISTVIEWLPNMLISTVIEWNM_LISTVIEWNMLISTVIEWLPNMITEMACTIVATENMITEMACTIVATELVKF_ALTLVKF_CONTROLLVKF_SHIFTLPNMLVCUSTOMDRAWNMLVCUSTOMDRAWLVCDI_ITEMLVCDI_GROUPLVCDI_ITEMSLISTLVCDRF_NOSELECTLVCDRF_NOGROUPFRAMELPNMLVCACHEHINTNMLVCACHEHINTLPNM_CACHEHINTPNM_CACHEHINTNM_CACHEHINTLPNMLVFINDITEMANMLVFINDITEMALPNMLVFINDITEMWNMLVFINDITEMWPNM_FINDITEMALPNM_FINDITEMANM_FINDITEMAPNM_FINDITEMWLPNM_FINDITEMWNM_FINDITEMWLPNMLVODSTATECHANGENMLVODSTATECHANGEPNM_ODSTATECHANGELPNM_ODSTATECHANGENM_ODSTATECHANGELVN_ITEMCHANGINGLVN_ITEMCHANGEDLVN_INSERTITEMLVN_DELETEITEMLVN_DELETEALLITEMSLVN_BEGINLABELEDITALVN_BEGINLABELEDITWLVN_ENDLABELEDITALVN_ENDLABELEDITWLVN_COLUMNCLICKLVN_BEGINDRAGLVN_BEGINRDRAGLVN_ODCACHEHINTLVN_ODFINDITEMALVN_ODFINDITEMWLVN_ITEMACTIVATELVN_ODSTATECHANGEDLVN_HOTTRACKLVN_GETDISPINFOALVN_GETDISPINFOWLVN_SETDISPINFOALVN_SETDISPINFOWLVIF_DI_SETITEMLV_DISPINFOANMLVDISPINFOALV_DISPINFOWNMLVDISPINFOWLPNMLVDISPINFOALPNMLVDISPINFOWLVN_KEYDOWNLV_KEYDOWNNMLVKEYDOWNLPNMLVKEYDOWNLVN_MARQUEEBEGINPNMLVLINKNMLVLINKLPNMLVGETINFOTIPANMLVGETINFOTIPALPNMLVGETINFOTIPWNMLVGETINFOTIPWLVGIT_UNFOLDEDLVN_GETINFOTIPALVN_GETINFOTIPWLVNSCH_DEFAULTLVNSCH_ERRORLVNSCH_IGNORELVN_INCREMENTALSEARCHALVN_INCREMENTALSEARCHWLVN_COLUMNDROPDOWNLVN_COLUMNOVERFLOWCLICKLPNMLVSCROLLNMLVSCROLLLVN_BEGINSCROLLLVN_ENDSCROLLLVN_LINKCLICKEMF_CENTEREDLVN_GETEMPTYMARKUPWC_TREEVIEWTVS_HASBUTTONSTVS_HASLINESTVS_LINESATROOTTVS_EDITLABELSTVS_DISABLEDRAGDROPTVS_SHOWSELALWAYSTVS_RTLREADINGTVS_NOTOOLTIPSTVS_CHECKBOXESTVS_TRACKSELECTTVS_SINGLEEXPANDTVS_INFOTIPTVS_FULLROWSELECTTVS_NOSCROLLTVS_NONEVENHEIGHTTVS_NOHSCROLLTVS_EX_NOSINGLECOLLAPSETVS_EX_MULTISELECTTVS_EX_DOUBLEBUFFERTVS_EX_NOINDENTSTATETVS_EX_RICHTOOLTIPTVS_EX_AUTOHSCROLLTVS_EX_FADEINOUTEXPANDOSTVS_EX_PARTIALCHECKBOXESTVS_EX_EXCLUSIONCHECKBOXESTVS_EX_DIMMEDCHECKBOXESTVS_EX_DRAWIMAGEASYNCTREEITEMHTREEITEMTVIF_TEXTTVIF_IMAGETVIF_PARAMTVIF_STATETVIF_HANDLETVIF_SELECTEDIMAGETVIF_CHILDRENTVIF_INTEGRALTVIF_STATEEXTVIF_EXPANDEDIMAGETVIS_SELECTEDTVIS_CUTTVIS_DROPHILITEDTVIS_BOLDTVIS_EXPANDEDTVIS_EXPANDEDONCETVIS_EXPANDPARTIALTVIS_OVERLAYMASKTVIS_STATEIMAGEMASKTVIS_USERMASKTVIS_EX_FLATTVIS_EX_DISABLEDTVIS_EX_ALLLPNMTVSTATEIMAGECHANGINGNMTVSTATEIMAGECHANGINGI_CHILDRENCALLBACKI_CHILDRENAUTOLPTV_ITEMWLPTVITEMWLPTV_ITEMALPTVITEMATV_ITEMWTVITEMWTV_ITEMATVITEMALPTVITEMEXATVITEMEXALPTVITEMEXWTVITEMEXWTVI_ROOTTVI_FIRSTTVI_LASTTVI_SORTLPTV_INSERTSTRUCTALPTVINSERTSTRUCTALPTV_INSERTSTRUCTWLPTVINSERTSTRUCTWTV_INSERTSTRUCTATVINSERTSTRUCTATV_INSERTSTRUCTWTVINSERTSTRUCTWTVM_INSERTITEMATVM_INSERTITEMWTVM_DELETEITEMTVM_EXPANDTVE_COLLAPSETVE_EXPANDTVE_TOGGLETVE_EXPANDPARTIALTVE_COLLAPSERESETTVM_GETITEMRECTTVM_GETCOUNTTVM_GETINDENTTVM_SETINDENTTVM_GETIMAGELISTTVSIL_NORMALTVSIL_STATETVM_SETIMAGELISTTVM_GETNEXTITEMTVGN_ROOTTVGN_NEXTTVGN_PREVIOUSTVGN_PARENTTVGN_CHILDTVGN_FIRSTVISIBLETVGN_NEXTVISIBLETVGN_PREVIOUSVISIBLETVGN_DROPHILITETVGN_CARETTVGN_LASTVISIBLETVGN_NEXTSELECTEDTVSI_NOSINGLEEXPANDTVM_SELECTITEMTVM_GETITEMATVM_GETITEMWTVM_SETITEMATVM_SETITEMWTVM_EDITLABELATVM_EDITLABELWTVM_GETEDITCONTROLTVM_GETVISIBLECOUNTTVM_HITTESTLPTV_HITTESTINFOLPTVHITTESTINFOTV_HITTESTINFOTVHITTESTINFOTVHT_NOWHERETVHT_ONITEMICONTVHT_ONITEMLABELTVHT_ONITEMTVHT_ONITEMINDENTTVHT_ONITEMBUTTONTVHT_ONITEMRIGHTTVHT_ONITEMSTATEICONTVHT_ABOVETVHT_BELOWTVHT_TORIGHTTVHT_TOLEFTTVM_CREATEDRAGIMAGETVM_SORTCHILDRENTVM_ENSUREVISIBLETVM_SORTCHILDRENCBTVM_ENDEDITLABELNOWTVM_GETISEARCHSTRINGATVM_GETISEARCHSTRINGWTVM_SETTOOLTIPSTVM_GETTOOLTIPSTVM_SETINSERTMARKTVM_SETUNICODEFORMATTVM_GETUNICODEFORMATTVM_SETITEMHEIGHTTVM_GETITEMHEIGHTTVM_SETBKCOLORTVM_SETTEXTCOLORTVM_GETBKCOLORTVM_GETTEXTCOLORTVM_SETSCROLLTIMETVM_GETSCROLLTIMETVM_SETINSERTMARKCOLORTVM_GETINSERTMARKCOLORTVM_SETBORDERTVSBF_XBORDERTVSBF_YBORDERTVM_GETITEMSTATETVM_SETLINECOLORTVM_GETLINECOLORTVM_MAPACCIDTOHTREEITEMTVM_MAPHTREEITEMTOACCIDTVM_SETEXTENDEDSTYLETVM_GETEXTENDEDSTYLETVM_SETAUTOSCROLLINFOTVM_SETHOTTVM_GETSELECTEDCOUNTTVM_SHOWINFOTIPTVM_GETITEMPARTRECTLPTV_SORTCBLPTVSORTCBTV_SORTCBTVSORTCBLPNM_TREEVIEWALPNMTREEVIEWALPNM_TREEVIEWWLPNMTREEVIEWWNM_TREEVIEWANMTREEVIEWANM_TREEVIEWWNMTREEVIEWWTVN_SELCHANGINGATVN_SELCHANGINGWTVN_SELCHANGEDATVN_SELCHANGEDWTVC_UNKNOWNTVC_BYMOUSETVC_BYKEYBOARDTVN_GETDISPINFOATVN_GETDISPINFOWTVN_SETDISPINFOATVN_SETDISPINFOWTVIF_DI_SETITEMTV_DISPINFOANMTVDISPINFOATV_DISPINFOWNMTVDISPINFOWLPNMTVDISPINFOALPNMTVDISPINFOWLPNMTVDISPINFOEXANMTVDISPINFOEXALPNMTVDISPINFOEXWNMTVDISPINFOEXWTV_DISPINFOEXATV_DISPINFOEXWTVN_ITEMEXPANDINGATVN_ITEMEXPANDINGWTVN_ITEMEXPANDEDATVN_ITEMEXPANDEDWTVN_BEGINDRAGATVN_BEGINDRAGWTVN_BEGINRDRAGATVN_BEGINRDRAGWTVN_DELETEITEMATVN_DELETEITEMWTVN_BEGINLABELEDITATVN_BEGINLABELEDITWTVN_ENDLABELEDITATVN_ENDLABELEDITWTVN_KEYDOWNTVN_GETINFOTIPATVN_GETINFOTIPWTVN_SINGLEEXPANDTVNRET_DEFAULTTVNRET_SKIPOLDTVNRET_SKIPNEWTVN_ITEMCHANGINGATVN_ITEMCHANGINGWTVN_ITEMCHANGEDATVN_ITEMCHANGEDWTVN_ASYNCDRAWTV_KEYDOWNNMTVKEYDOWNLPNMTVKEYDOWNLPNMTVCUSTOMDRAWNMTVCUSTOMDRAWLPNMTVGETINFOTIPANMTVGETINFOTIPALPNMTVGETINFOTIPWNMTVGETINFOTIPWTVCDRF_NOIMAGESWC_COMBOBOXEXCBEIF_TEXTCBEIF_IMAGECBEIF_SELECTEDIMAGECBEIF_OVERLAYCBEIF_INDENTCBEIF_LPARAMCBEIF_DI_SETITEMPCOMBOBOXEXITEMACOMBOBOXEXITEMAPCCOMBOBOXEXITEMAPCOMBOBOXEXITEMWCOMBOBOXEXITEMWPCCOMBOBOXEXITEMWCBEM_INSERTITEMACBEM_SETIMAGELISTCBEM_GETIMAGELISTCBEM_GETITEMACBEM_SETITEMACBEM_DELETEITEMCBEM_GETCOMBOCONTROLCBEM_GETEDITCONTROLCBEM_SETEXSTYLECBEM_SETEXTENDEDSTYLECBEM_GETEXSTYLECBEM_GETEXTENDEDSTYLECBEM_SETUNICODEFORMATCBEM_GETUNICODEFORMATCBEM_HASEDITCHANGEDCBEM_INSERTITEMWCBEM_SETITEMWCBEM_GETITEMWCBEM_SETWINDOWTHEMECBES_EX_NOEDITIMAGECBES_EX_NOEDITIMAGEINDENTCBES_EX_PATHWORDBREAKPROCCBES_EX_NOSIZELIMITCBES_EX_CASESENSITIVECBES_EX_TEXTENDELLIPSISPNMCOMBOBOXEXANMCOMBOBOXEXAPNMCOMBOBOXEXWNMCOMBOBOXEXWCBEN_GETDISPINFOACBEN_INSERTITEMCBEN_DELETEITEMCBEN_BEGINEDITCBEN_ENDEDITACBEN_ENDEDITWCBEN_GETDISPINFOWCBEN_DRAGBEGINACBEN_DRAGBEGINWCBENF_KILLFOCUSCBENF_RETURNCBENF_ESCAPECBENF_DROPDOWNCBEMAXSTRLENPNMCBEDRAGBEGINWNMCBEDRAGBEGINWLPNMCBEDRAGBEGINWPNMCBEDRAGBEGINANMCBEDRAGBEGINALPNMCBEDRAGBEGINAPNMCBEENDEDITWNMCBEENDEDITWLPNMCBEENDEDITWPNMCBEENDEDITANMCBEENDEDITALPNMCBEENDEDITAWC_TABCONTROLTCS_SCROLLOPPOSITETCS_BOTTOMTCS_RIGHTTCS_MULTISELECTTCS_FLATBUTTONSTCS_FORCEICONLEFTTCS_FORCELABELLEFTTCS_HOTTRACKTCS_VERTICALTCS_TABSTCS_BUTTONSTCS_SINGLELINETCS_MULTILINETCS_RIGHTJUSTIFYTCS_FIXEDWIDTHTCS_RAGGEDRIGHTTCS_FOCUSONBUTTONDOWNTCS_OWNERDRAWFIXEDTCS_TOOLTIPSTCS_FOCUSNEVERTCS_EX_FLATSEPARATORSTCS_EX_REGISTERDROPTCM_GETIMAGELISTTCM_SETIMAGELISTTCM_GETITEMCOUNTTCIF_TEXTTCIF_IMAGETCIF_RTLREADINGTCIF_PARAMTCIF_STATETCIS_BUTTONPRESSEDTCIS_HIGHLIGHTEDTC_ITEMHEADERATCITEMHEADERATC_ITEMHEADERWTCITEMHEADERWLPTCITEMHEADERALPTCITEMHEADERWTC_ITEMATCITEMATC_ITEMWTCITEMWLPTCITEMALPTCITEMWTCM_GETITEMATCM_GETITEMWTCM_SETITEMATCM_SETITEMWTCM_INSERTITEMATCM_INSERTITEMWTCM_DELETEITEMTCM_DELETEALLITEMSTCM_GETITEMRECTTCM_GETCURSELTCM_SETCURSELTCHT_NOWHERETCHT_ONITEMICONTCHT_ONITEMLABELTCHT_ONITEMLPTC_HITTESTINFOLPTCHITTESTINFOTC_HITTESTINFOTCHITTESTINFOTCM_HITTESTTCM_SETITEMEXTRATCM_ADJUSTRECTTCM_SETITEMSIZETCM_REMOVEIMAGETCM_SETPADDINGTCM_GETROWCOUNTTCM_GETTOOLTIPSTCM_SETTOOLTIPSTCM_GETCURFOCUSTCM_SETCURFOCUSTCM_SETMINTABWIDTHTCM_DESELECTALLTCM_HIGHLIGHTITEMTCM_SETEXTENDEDSTYLETCM_GETEXTENDEDSTYLETCM_SETUNICODEFORMATTCM_GETUNICODEFORMATTCN_KEYDOWNTC_KEYDOWNNMTCKEYDOWNTCN_SELCHANGETCN_SELCHANGINGTCN_GETOBJECTTCN_FOCUSCHANGEANIMATE_CLASSACS_CENTERACS_TRANSPARENTACS_AUTOPLAYACS_TIMERACM_OPENAACM_OPENWACM_PLAYACM_STOPACM_ISPLAYINGACN_STARTACN_STOPMONTHCAL_CLASSMONTHDAYSTATELPMONTHDAYSTATEMCM_FIRSTMCM_GETCURSELMCM_SETCURSELMCM_GETMAXSELCOUNTMCM_SETMAXSELCOUNTMCM_GETSELRANGEMCM_SETSELRANGEMCM_GETMONTHRANGEMCM_SETDAYSTATEMCM_GETMINREQRECTMCM_SETCOLORMCM_GETCOLORMCSC_BACKGROUNDMCSC_TEXTMCSC_TITLEBKMCSC_TITLETEXTMCSC_MONTHBKMCSC_TRAILINGTEXTMCM_SETTODAYMCM_GETTODAYMCM_HITTESTPMCHITTESTINFOMCHITTESTINFOMCHT_TITLEMCHT_CALENDARMCHT_TODAYLINKMCHT_CALENDARCONTROLMCHT_NEXTMCHT_PREVMCHT_NOWHEREMCHT_TITLEBKMCHT_TITLEMONTHMCHT_TITLEYEARMCHT_TITLEBTNNEXTMCHT_TITLEBTNPREVMCHT_CALENDARBKMCHT_CALENDARDATEMCHT_CALENDARDATENEXTMCHT_CALENDARDATEPREVMCHT_CALENDARDAYMCHT_CALENDARWEEKNUMMCHT_CALENDARDATEMINMCHT_CALENDARDATEMAXMCM_SETFIRSTDAYOFWEEKMCM_GETFIRSTDAYOFWEEKMCM_GETRANGEMCM_SETRANGEMCM_GETMONTHDELTAMCM_SETMONTHDELTAMCM_GETMAXTODAYWIDTHMCM_SETUNICODEFORMATMCM_GETUNICODEFORMATMCMV_MONTHMCMV_YEARMCMV_DECADEMCMV_CENTURYMCMV_MAXMCM_GETCURRENTVIEWMCM_GETCALENDARCOUNTMCGIP_CALENDARCONTROLMCGIP_NEXTMCGIP_PREVMCGIP_FOOTERMCGIP_CALENDARMCGIP_CALENDARHEADERMCGIP_CALENDARBODYMCGIP_CALENDARROWMCGIP_CALENDARCELLMCGIF_DATEMCGIF_RECTMCGIF_NAMEPMCGRIDINFOMCGRIDINFOMCM_GETCALENDARGRIDINFOMCM_GETCALIDMCM_SETCALIDMCM_SIZERECTTOMINMCM_SETCALENDARBORDERMCM_GETCALENDARBORDERMCM_SETCURRENTVIEWLPNMSELCHANGENMSELCHANGEMCN_SELCHANGELPNMDAYSTATENMDAYSTATEMCN_GETDAYSTATENMSELECTLPNMSELECTMCN_SELECTLPNMVIEWCHANGENMVIEWCHANGEMCN_VIEWCHANGEMCS_DAYSTATEMCS_MULTISELECTMCS_WEEKNUMBERSMCS_NOTODAYCIRCLEMCS_NOTODAYMCS_NOTRAILINGDATESMCS_SHORTDAYSOFWEEKMCS_NOSELCHANGEONNAVGMR_VISIBLEGMR_DAYSTATEDATETIMEPICK_CLASSLPDATETIMEPICKERINFODATETIMEPICKERINFODTM_FIRSTDTM_GETSYSTEMTIMEDTM_SETSYSTEMTIMEDTM_GETRANGEDTM_SETRANGEDTM_SETFORMATADTM_SETFORMATWDTM_SETMCCOLORDTM_GETMCCOLORDTM_GETMONTHCALDTM_SETMCFONTDTM_GETMCFONTDTM_SETMCSTYLEDTM_GETMCSTYLEDTM_CLOSEMONTHCALDTM_GETDATETIMEPICKERINFODTM_GETIDEALSIZEDTS_UPDOWNDTS_SHOWNONEDTS_SHORTDATEFORMATDTS_LONGDATEFORMATDTS_SHORTDATECENTURYFORMATDTS_TIMEFORMATDTS_APPCANPARSEDTS_RIGHTALIGNDTN_DATETIMECHANGELPNMDATETIMECHANGENMDATETIMECHANGEDTN_USERSTRINGADTN_USERSTRINGWLPNMDATETIMESTRINGANMDATETIMESTRINGALPNMDATETIMESTRINGWNMDATETIMESTRINGWDTN_WMKEYDOWNADTN_WMKEYDOWNWLPNMDATETIMEWMKEYDOWNANMDATETIMEWMKEYDOWNALPNMDATETIMEWMKEYDOWNWNMDATETIMEWMKEYDOWNWDTN_FORMATADTN_FORMATWLPNMDATETIMEFORMATANMDATETIMEFORMATALPNMDATETIMEFORMATWNMDATETIMEFORMATWDTN_FORMATQUERYADTN_FORMATQUERYWLPNMDATETIMEFORMATQUERYANMDATETIMEFORMATQUERYALPNMDATETIMEFORMATQUERYWNMDATETIMEFORMATQUERYWDTN_DROPDOWNDTN_CLOSEUPGDTR_MINGDTR_MAXGDT_ERRORGDT_VALIDGDT_NONEIPM_CLEARADDRESSIPM_SETADDRESSIPM_GETADDRESSIPM_SETRANGEIPM_SETFOCUSIPM_ISBLANKWC_IPADDRESSIPN_FIELDCHANGEDLPNMIPADDRESSNMIPADDRESSMAKEIPRANGEMAKEIPADDRESSFIRST_IPADDRESSSECOND_IPADDRESSTHIRD_IPADDRESSFOURTH_IPADDRESSWC_PAGESCROLLERPGS_VERTPGS_HORZPGS_AUTOSCROLLPGS_DRAGNDROPPGF_INVISIBLEPGF_NORMALPGF_GRAYEDPGF_DEPRESSEDPGF_HOTPGB_TOPORLEFTPGB_BOTTOMORRIGHTPGM_SETCHILDPGM_RECALCSIZEPGM_FORWARDMOUSEPGM_SETBKCOLORPGM_GETBKCOLORPGM_SETBORDERPGM_GETBORDERPGM_SETPOSPGM_GETPOSPGM_SETBUTTONSIZEPGM_GETBUTTONSIZEPGM_GETBUTTONSTATEPGM_GETDROPTARGETPGM_SETSCROLLINFOPGN_SCROLLPGF_SCROLLUPPGF_SCROLLDOWNPGF_SCROLLLEFTPGF_SCROLLRIGHTPGK_SHIFTPGK_CONTROLPGK_MENULPNMPGSCROLLNMPGSCROLLPGN_CALCSIZEPGF_CALCWIDTHPGF_CALCHEIGHTLPNMPGCALCSIZENMPGCALCSIZEPGN_HOTITEMCHANGELPNMPGHOTITEMNMPGHOTITEMWC_NATIVEFONTCTLNFS_EDITNFS_STATICNFS_LISTCOMBONFS_BUTTONNFS_ALLNFS_USEFONTASSOCWC_BUTTONABUTTON_IMAGELIST_ALIGN_LEFTBUTTON_IMAGELIST_ALIGN_RIGHTBUTTON_IMAGELIST_ALIGN_TOPBUTTON_IMAGELIST_ALIGN_BOTTOMBUTTON_IMAGELIST_ALIGN_CENTERPBUTTON_IMAGELISTBUTTON_IMAGELISTBCM_GETIDEALSIZEBCM_SETIMAGELISTBCM_GETIMAGELISTBCM_SETTEXTMARGINBCM_GETTEXTMARGINLPNMBCHOTITEMNMBCHOTITEMBCN_HOTITEMCHANGEBS_SPLITBUTTONBS_DEFSPLITBUTTONBS_COMMANDLINKBS_DEFCOMMANDLINKBCSIF_GLYPHBCSIF_IMAGEBCSIF_STYLEBCSIF_SIZEBCSS_NOSPLITBCSS_STRETCHBCSS_ALIGNLEFTBCSS_IMAGEPBUTTON_SPLITINFOBUTTON_SPLITINFOBCM_SETDROPDOWNSTATEBCM_SETSPLITINFOBCM_GETSPLITINFOBCM_SETNOTEBCM_GETNOTEBCM_GETNOTELENGTHBCM_SETSHIELDBCCL_NOGLYPHLPNMBCDROPDOWNNMBCDROPDOWNBCN_DROPDOWNWC_STATICWC_EDITEM_SETCUEBANNEREM_GETCUEBANNERPEDITBALLOONTIPEDITBALLOONTIPEM_SHOWBALLOONTIPEM_HIDEBALLOONTIPEM_SETHILITEEM_GETHILITEEM_NOSETFOCUSEM_TAKEFOCUSWC_LISTBOXWC_COMBOBOXCB_SETMINVISIBLECB_GETMINVISIBLECB_SETCUEBANNERCB_GETCUEBANNERWC_SCROLLBARTD_WARNING_ICONTD_ERROR_ICONTD_INFORMATION_ICONTD_SHIELD_ICONTaskDialogIndirectTASKDIALOGCONFIGTaskDialogTASKDIALOG_COMMON_BUTTON_FLAGSInitMUILanguageGetMUILanguage_TrackMouseEventWSB_PROP_CYVSCROLLWSB_PROP_CXHSCROLLWSB_PROP_CYHSCROLLWSB_PROP_CXVSCROLLWSB_PROP_CXHTHUMBWSB_PROP_CYVTHUMBWSB_PROP_VBKGCOLORWSB_PROP_HBKGCOLORWSB_PROP_VSTYLEWSB_PROP_HSTYLEWSB_PROP_WINSTYLEWSB_PROP_PALETTEWSB_PROP_MASKFSB_FLAT_MODEFSB_ENCARTA_MODEFSB_REGULAR_MODEFlatSB_EnableScrollBarFlatSB_ShowScrollBarFlatSB_GetScrollRangeFlatSB_GetScrollInfoFlatSB_GetScrollPosFlatSB_GetScrollPropFlatSB_GetScrollPropPtrFlatSB_SetScrollPosFlatSB_SetScrollInfoFlatSB_SetScrollRangeFlatSB_SetScrollPropInitializeFlatSBUninitializeFlatSBSUBCLASSPROCGetWindowSubclassLoadIconMetricLoadIconWithScaleDownDrawShadowTextprshtHPROPSHEETPAGEDM_COLLATEDM_COPIESLPDEVMODEWLPLOGFONTALPLOGFONTWLPOPENFILENAME_NT4AOPENFILENAME_NT4ALPOPENFILENAME_NT4WOPENFILENAME_NT4WLPOPENFILENAMEAOPENFILENAMEALPOPENFILENAMEWOPENFILENAMEWGetOpenFileNameAGetOpenFileNameWGetSaveFileNameAGetSaveFileNameWGetFileTitleAGetFileTitleWOFN_READONLYOFN_OVERWRITEPROMPTOFN_HIDEREADONLYOFN_NOCHANGEDIROFN_SHOWHELPOFN_ENABLEHOOKOFN_ENABLETEMPLATEOFN_ENABLETEMPLATEHANDLEOFN_NOVALIDATEOFN_ALLOWMULTISELECTOFN_EXTENSIONDIFFERENTOFN_PATHMUSTEXISTOFN_FILEMUSTEXISTOFN_CREATEPROMPTOFN_SHAREAWAREOFN_NOREADONLYRETURNOFN_NOTESTFILECREATEOFN_NONETWORKBUTTONOFN_NOLONGNAMESOFN_EXPLOREROFN_NODEREFERENCELINKSOFN_LONGNAMESOFN_ENABLEINCLUDENOTIFYOFN_ENABLESIZINGOFN_DONTADDTORECENTOFN_FORCESHOWHIDDENOFN_EX_NOPLACESBAROFN_SHAREFALLTHROUGHOFN_SHARENOWARNOFN_SHAREWARNLPOFNOTIFYAOFNOTIFYALPOFNOTIFYWOFNOTIFYWLPOFNOTIFYEXAOFNOTIFYEXALPOFNOTIFYEXWOFNOTIFYEXWCDN_INITDONECDN_SELCHANGECDN_FOLDERCHANGECDN_SHAREVIOLATIONCDN_HELPCDN_FILEOKCDN_TYPECHANGECDN_INCLUDEITEMCDM_FIRSTCDM_LASTCDM_GETSPECCDM_GETFILEPATHCDM_GETFOLDERPATHCDM_GETFOLDERIDLISTCDM_SETCONTROLTEXTCDM_HIDECONTROLCDM_SETDEFEXTLPCHOOSECOLORACHOOSECOLORALPCHOOSECOLORWCHOOSECOLORWChooseColorAChooseColorWCC_RGBINITCC_FULLOPENCC_PREVENTFULLOPENCC_SHOWHELPCC_ENABLEHOOKCC_ENABLETEMPLATECC_ENABLETEMPLATEHANDLECC_SOLIDCOLORCC_ANYCOLORLPFINDREPLACEAFINDREPLACEALPFINDREPLACEWFINDREPLACEWFR_DOWNFR_WHOLEWORDFR_MATCHCASEFR_FINDNEXTFR_REPLACEFR_REPLACEALLFR_DIALOGTERMFR_SHOWHELPFR_ENABLEHOOKFR_ENABLETEMPLATEFR_NOUPDOWNFR_NOMATCHCASEFR_NOWHOLEWORDFR_ENABLETEMPLATEHANDLEFR_HIDEUPDOWNFR_HIDEMATCHCASEFR_HIDEWHOLEWORDFR_RAWFR_MATCHDIACFR_MATCHKASHIDAFR_MATCHALEFHAMZAFindTextAFindTextWReplaceTextAReplaceTextWLPCHOOSEFONTACHOOSEFONTALPCHOOSEFONTWCHOOSEFONTWChooseFontAChooseFontWCF_SCREENFONTSCF_PRINTERFONTSCF_BOTHCF_SHOWHELPCF_ENABLEHOOKCF_ENABLETEMPLATECF_ENABLETEMPLATEHANDLECF_INITTOLOGFONTSTRUCTCF_USESTYLECF_EFFECTSCF_APPLYCF_ANSIONLYCF_SCRIPTSONLYCF_NOVECTORFONTSCF_NOOEMFONTSCF_NOSIMULATIONSCF_LIMITSIZECF_FIXEDPITCHONLYCF_WYSIWYGCF_FORCEFONTEXISTCF_SCALABLEONLYCF_TTONLYCF_NOFACESELCF_NOSTYLESELCF_NOSIZESELCF_SELECTSCRIPTCF_NOSCRIPTSELCF_NOVERTFONTSCF_INACTIVEFONTSSIMULATED_FONTTYPEPRINTER_FONTTYPESCREEN_FONTTYPEBOLD_FONTTYPEITALIC_FONTTYPEREGULAR_FONTTYPEPS_OPENTYPE_FONTTYPETT_OPENTYPE_FONTTYPETYPE1_FONTTYPESYMBOL_FONTTYPEWM_CHOOSEFONT_GETLOGFONTWM_CHOOSEFONT_SETLOGFONTWM_CHOOSEFONT_SETFLAGSCD_LBSELNOITEMSCD_LBSELCHANGECD_LBSELSUBCD_LBSELADDLPPRINTDLGAPRINTDLGALPPRINTDLGWPRINTDLGWPrintDlgAPrintDlgWLPPRINTPAGERANGEPRINTPAGERANGEPCPRINTPAGERANGELPPRINTDLGEXAPRINTDLGEXALPPRINTDLGEXWPRINTDLGEXWPrintDlgExAPrintDlgExWPD_ALLPAGESPD_SELECTIONPD_PAGENUMSPD_NOSELECTIONPD_NOPAGENUMSPD_COLLATEPD_PRINTTOFILEPD_PRINTSETUPPD_NOWARNINGPD_RETURNDCPD_RETURNICPD_RETURNDEFAULTPD_SHOWHELPPD_ENABLEPRINTHOOKPD_ENABLESETUPHOOKPD_ENABLEPRINTTEMPLATEPD_ENABLESETUPTEMPLATEPD_ENABLEPRINTTEMPLATEHANDLEPD_ENABLESETUPTEMPLATEHANDLEPD_USEDEVMODECOPIESPD_USEDEVMODECOPIESANDCOLLATEPD_DISABLEPRINTTOFILEPD_HIDEPRINTTOFILEPD_NONETWORKBUTTONPD_CURRENTPAGEPD_NOCURRENTPAGEPD_EXCLUSIONFLAGSPD_USELARGETEMPLATEPD_EXCL_COPIESANDCOLLATESTART_PAGE_GENERALPD_RESULT_CANCELPD_RESULT_PRINTPD_RESULT_APPLYLPDEVNAMESDEVNAMESPCDEVNAMESDN_DEFAULTPRNCommDlgExtendedErrorWM_PSD_PAGESETUPDLGWM_PSD_FULLPAGERECTWM_PSD_MINMARGINRECTWM_PSD_MARGINRECTWM_PSD_GREEKTEXTRECTWM_PSD_ENVSTAMPRECTWM_PSD_YAFULLPAGERECTLPPAGESETUPDLGAPAGESETUPDLGALPPAGESETUPDLGWPAGESETUPDLGWPageSetupDlgAPageSetupDlgWPSD_DEFAULTMINMARGINSPSD_INWININIINTLMEASUREPSD_MINMARGINSPSD_MARGINSPSD_INTHOUSANDTHSOFINCHESPSD_INHUNDREDTHSOFMILLIMETERSPSD_DISABLEMARGINSPSD_DISABLEPRINTERPSD_NOWARNINGPSD_DISABLEORIENTATIONPSD_RETURNDEFAULTPSD_DISABLEPAPERPSD_SHOWHELPPSD_ENABLEPAGESETUPHOOKPSD_ENABLEPAGESETUPTEMPLATEPSD_ENABLEPAGESETUPTEMPLATEHANDLEPSD_ENABLEPAGEPAINTHOOKPSD_DISABLEPAGEPAINTINGPSD_NONETWORKBUTTON//! 32-Bit Common Dialog APIscommctrlImageList_CoCreateInstanceILIF_ALPHAILIF_LOWQUALITYILDRF_IMAGELOWQUALITYILDRF_OVERLAYLOWQUALITYILR_DEFAULTILR_HORIZONTAL_LEFTILR_HORIZONTAL_CENTERILR_HORIZONTAL_RIGHTILR_VERTICAL_TOPILR_VERTICAL_CENTERILR_VERTICAL_BOTTOMILR_SCALE_CLIPILR_SCALE_ASPECTRATIOILGOS_ALWAYSILGOS_FROMSTANDBYILFIP_ALWAYSILFIP_FROMSTANDBYILDI_PURGEILDI_STANDBYILDI_RESETACCESSILDI_QUERYACCESSPCONSOLE_READCONSOLE_CONTROLPHANDLER_ROUTINEwincontypesPINPUT_RECORDAllocConsoleGetConsoleCPGetConsoleOutputCPGetNumberOfConsoleInputEventsPeekConsoleInputAReadConsoleAReadConsoleWReadConsoleInputAReadConsoleInputWWriteConsoleAWriteConsoleWCreatePseudoConsoleResizePseudoConsoleClosePseudoConsole//! ApiSet Contract for api-ms-win-core-console-l1ISymUnmanagedReader//! Common Language Runtime Debugging Symbol Reader/Writer/Binder Interfacesd2dbasetypesD2D_COLOR_FD2D_MATRIX_3X2_FD2D_POINT_2FD2D_POINT_2UD2D_RECT_FD2D_RECT_UD2D_SIZE_FD2D_SIZE_Ud3dcommonD3D_FEATURE_LEVEL_10_0D3D_FEATURE_LEVEL_9_1dcommonD2D1_PIXEL_FORMATDWRITE_MEASURING_MODEdwriteDWRITE_GLYPH_RUNIDWriteRenderingParamsIDWriteTextFormatIDWriteTextLayoutwincodecIWICBitmapIWICBitmapSourceD2D1_DEFAULT_FLATTENING_TOLERANCE// Types confirmed affected by the ABI issue:// D2D1_SIZE_F, D2D1_SIZE_U, D2D1_COLOR_F, D2D1_PIXEL_FORMAT, D2D1_POINT_2FD2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBORD2D1_INTERPOLATION_MODE_DEFINITION_LINEARD2D1_INTERPOLATION_MODE_DEFINITION_CUBICD2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEARD2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPICD2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBICD2D1_INTERPOLATION_MODE_DEFINITION_FANTD2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEARD2D1_POINT_2UD2D1_POINT_2FD2D1_RECT_FD2D1_RECT_UD2D1_SIZE_FD2D1_SIZE_UD2D1_COLOR_FD2D1_MATRIX_3X2_FD2D1_TAGD2D1CreateFactoryD2D1_FACTORY_TYPED2D1_FACTORY_OPTIONSD2D1MakeRotateMatrixD2D1MakeSkewMatrixD2D1IsMatrixInvertibleD2D1InvertMatrixD2D1ComputeMaximumScaleFactor//! Mappings for the contents of d2d1.hIDXGIDeviced2d1D2D1_ANTIALIAS_MODED2D1_BRUSH_PROPERTIESD2D1_CAP_STYLED2D1_DASH_STYLED2D1_DEBUG_LEVELD2D1_EXTEND_MODED2D1_GRADIENT_STOPD2D1_LINE_JOIND2D1_TEXT_ANTIALIAS_MODEID2D1BitmapID2D1BitmapBrushID2D1BitmapBrushVtblID2D1BitmapVtblID2D1BrushID2D1BrushVtblID2D1DrawingStateBlockID2D1DrawingStateBlockVtblID2D1FactoryVtblID2D1GeometryID2D1GradientStopCollectionID2D1GradientStopCollectionVtblID2D1ImageID2D1ImageVtblID2D1LayerID2D1MeshID2D1PathGeometryID2D1PathGeometryVtblID2D1RenderTargetVtblID2D1ResourceID2D1ResourceVtblID2D1StrokeStyleID2D1StrokeStyleVtbld2d1effectauthorD2D1_PROPERTY_BINDINGdocumenttargetIPrintDocumentPackageTargetDWRITE_GLYPH_RUN_DESCRIPTIONIWICColorContextIWICImagingFactoryD2D_RECT_LD2D1_RECT_LD2D_POINT_2LD2D1_POINT_2L// DEFINE_ENUM_FLAG_OPERATORS(D2D1_BITMAP_OPTIONS);//DEFINE_ENUM_FLAG_OPERATORS(D2D1_MAP_OPTIONS);//DEFINE_ENUM_FLAG_OPERATORS(D2D1_DEVICE_CONTEXT_OPTIONS);D2D_VECTOR_2FD2D1_VECTOR_2FD2D_VECTOR_3FD2D1_VECTOR_3FD2D_VECTOR_4FD2D1_VECTOR_4FD2D_MATRIX_4X3_FD2D1_MATRIX_4X3_FD2D_MATRIX_4X4_FD2D1_MATRIX_4X4_FD2D_MATRIX_5X4_FD2D1_MATRIX_5X4_F//DEFINE_ENUM_FLAG_OPERATORS(D2D1_LAYER_OPTIONS1);D2D1CreateDeviceD2D1_CREATION_PROPERTIESID2D1DeviceD2D1CreateDeviceContextID2D1DeviceContextD2D1ConvertColorSpaceD2D1_COLOR_SPACED2D1SinCosD2D1TanD2D1Vec3Length//! Mappings for the contents of d2d1_1.hd2d1_1D2D1_DEVICE_CONTEXT_OPTIONSD2D1_PRIMITIVE_BLENDID2D1DeviceContextVtblID2D1DeviceVtblID2D1Factory1ID2D1Factory1VtblID2D1CommandSinkID2D1CommandSinkVtbl//! Mappings for the contents of d2d1_2.hD2D1_BITMAP_INTERPOLATION_MODED2D1_DRAW_TEXT_OPTIONSD2D1_GAMMA_1_0D2D1_GAMMA_2_2ID2D1SimplifiedGeometrySinkD2D1_BUFFER_PRECISIOND2D1_INTERPOLATION_MODEID2D1ColorContextID2D1ColorContextVtblID2D1CommandListID2D1GdiMetafileID2D1GdiMetafileSinkID2D1GdiMetafileSinkVtblID2D1GdiMetafileVtbld2d1_2ID2D1CommandSink1ID2D1CommandSink1VtblID2D1Device1ID2D1Device1VtblID2D1DeviceContext1ID2D1DeviceContext1VtblID2D1Factory2ID2D1Factory2Vtbld2d1effectsD2D1_BLEND_MODEd2d1svgID2D1SvgDocumentD2D1_ALPHA_MODEDWRITE_GLYPH_IMAGE_FORMATSIDWriteFontFaceD2D1GetGradientMeshInteriorPointsFromCoonsPatch//! Mappings for the contents of d2d1_3.hID2D1Bitmap1ID2D1EffectD3D_FEATURE_LEVELD2D1_APPEND_ALIGNED_ELEMENT//! Mappings for the contents of d2d1effects.h// Mappings for the contents of d2d1effects_1.h//! Mappings for the contents of d2d1effects_2.hD2D1_CAP_STYLE_FLATD2D1_CAP_STYLE_ROUNDD2D1_CAP_STYLE_SQUARED2D1_FILL_MODED2D1_LINE_JOIN_BEVELD2D1_LINE_JOIN_MITER_OR_BEVELD2D1_LINE_JOIN_ROUNDID2D1PathGeometry1//! Mappings for the contents of d2d1svg.h// FIXME: Remove in next major version//! Mappings for the contents of d2dbasetypes.hD3D_PRIMITIVED3D_PRIMITIVE_TOPOLOGYD3D_SRV_DIMENSIOND3D10_PRIMITIVE_TOPOLOGYD3D10_PRIMITIVED3D10_SRV_DIMENSIONd3d10D3D_CBUFFER_TYPED3D_INCLUDE_TYPED3D_NAMED3D_REGISTER_COMPONENT_TYPED3D_RESOURCE_RETURN_TYPED3D_SHADER_CBUFFER_FLAGSD3D_SHADER_INPUT_FLAGSD3D_SHADER_INPUT_TYPED3D_SHADER_MACROD3D_SHADER_VARIABLE_CLASSD3D_SHADER_VARIABLE_FLAGSD3D_SHADER_VARIABLE_TYPEID3DIncludeD3D10_SHADER_DEBUGD3D10_SHADER_SKIP_VALIDATIOND3D10_SHADER_SKIP_OPTIMIZATIOND3D10_SHADER_PACK_MATRIX_ROW_MAJORD3D10_SHADER_PACK_MATRIX_COLUMN_MAJORD3D10_SHADER_PARTIAL_PRECISIOND3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPTD3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPTD3D10_SHADER_NO_PRESHADERD3D10_SHADER_AVOID_FLOW_CONTROLD3D10_SHADER_PREFER_FLOW_CONTROLD3D10_SHADER_ENABLE_STRICTNESSD3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITYD3D10_SHADER_IEEE_STRICTNESSD3D10_SHADER_WARNINGS_ARE_ERRORSD3D10_SHADER_RESOURCES_MAY_ALIASD3D10_ENABLE_UNBOUNDED_DESCRIPTOR_TABLESD3D10_ALL_RESOURCES_BOUNDD3D10_SHADER_OPTIMIZATION_LEVEL0D3D10_SHADER_OPTIMIZATION_LEVEL1D3D10_SHADER_OPTIMIZATION_LEVEL2D3D10_SHADER_OPTIMIZATION_LEVEL3D3D10_SHADER_FLAGS2_FORCE_ROOT_SIGNATURE_LATESTD3D10_SHADER_FLAGS2_FORCE_ROOT_SIGNATURE_1_0D3D10_SHADER_FLAGS2_FORCE_ROOT_SIGNATURE_1_1D3D10_SHADER_MACROLPD3D10_SHADER_MACROD3D10_SHADER_VARIABLE_CLASSLPD3D10_SHADER_VARIABLE_CLASSD3D10_SHADER_VARIABLE_FLAGSLPD3D10_SHADER_VARIABLE_FLAGSD3D10_SHADER_VARIABLE_TYPELPD3D10_SHADER_VARIABLE_TYPED3D10_SHADER_INPUT_FLAGSLPD3D10_SHADER_INPUT_FLAGSD3D10_SHADER_INPUT_TYPELPD3D10_SHADER_INPUT_TYPED3D10_SHADER_CBUFFER_FLAGSLPD3D10_SHADER_CBUFFER_FLAGSD3D10_CBUFFER_TYPELPD3D10_CBUFFER_TYPED3D10_NAMED3D10_RESOURCE_RETURN_TYPED3D10_REGISTER_COMPONENT_TYPED3D10_INCLUDE_TYPEID3D10IncludeLPD3D10INCLUDE// const IID_ID3D10Include: IID = IID_ID3DInclude;LPD3D10SHADERREFLECTIONTYPEID3D10ShaderReflectionTypeLPD3D10SHADERREFLECTIONVARIABLEID3D10ShaderReflectionVariableLPD3D10SHADERREFLECTIONCONSTANTBUFFERID3D10ShaderReflectionConstantBufferLPD3D10SHADERREFLECTIONID3D10ShaderReflection// TODO Some functionsDXGI_SWAP_CHAIN_DESCIDXGIAdapterD3D_DRIVER_TYPED3D11_16BIT_INDEX_STRIP_CUT_VALUED3D11_32BIT_INDEX_STRIP_CUT_VALUED3D11_8BIT_INDEX_STRIP_CUT_VALUED3D11_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNTD3D11_CLIP_OR_CULL_DISTANCE_COUNTD3D11_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNTD3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNTD3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENTSD3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNTD3D11_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNTD3D11_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENTD3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTSD3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNTD3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INSTD3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTSD3D11_COMMONSHADER_FLOWCONTROL_NESTING_LIMITD3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTSD3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNTD3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INSTD3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTSD3D11_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNTD3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTSD3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNTD3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INSTD3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTSD3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNTD3D11_COMMONSHADER_SAMPLER_REGISTER_COMPONENTSD3D11_COMMONSHADER_SAMPLER_REGISTER_COUNTD3D11_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INSTD3D11_COMMONSHADER_SAMPLER_REGISTER_READ_PORTSD3D11_COMMONSHADER_SAMPLER_SLOT_COUNTD3D11_COMMONSHADER_SUBROUTINE_NESTING_LIMITD3D11_COMMONSHADER_TEMP_REGISTER_COMPONENTSD3D11_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNTD3D11_COMMONSHADER_TEMP_REGISTER_COUNTD3D11_COMMONSHADER_TEMP_REGISTER_READS_PER_INSTD3D11_COMMONSHADER_TEMP_REGISTER_READ_PORTSD3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAXD3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIND3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVED3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVED3D11_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D11_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUPD3D11_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSIOND3D11_CS_4_X_RAW_UAV_BYTE_ALIGNMENTD3D11_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUPD3D11_CS_4_X_THREAD_GROUP_MAX_XD3D11_CS_4_X_THREAD_GROUP_MAX_YD3D11_CS_4_X_UAV_REGISTER_COUNTD3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSIOND3D11_CS_TGSM_REGISTER_COUNTD3D11_CS_TGSM_REGISTER_READS_PER_INSTD3D11_CS_TGSM_RESOURCE_REGISTER_COMPONENTSD3D11_CS_TGSM_RESOURCE_REGISTER_READ_PORTSD3D11_CS_THREADGROUPID_REGISTER_COMPONENTSD3D11_CS_THREADGROUPID_REGISTER_COUNTD3D11_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTSD3D11_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNTD3D11_CS_THREADIDINGROUP_REGISTER_COMPONENTSD3D11_CS_THREADIDINGROUP_REGISTER_COUNTD3D11_CS_THREADID_REGISTER_COMPONENTSD3D11_CS_THREADID_REGISTER_COUNTD3D11_CS_THREAD_GROUP_MAX_THREADS_PER_GROUPD3D11_CS_THREAD_GROUP_MAX_XD3D11_CS_THREAD_GROUP_MAX_YD3D11_CS_THREAD_GROUP_MAX_ZD3D11_CS_THREAD_GROUP_MIN_XD3D11_CS_THREAD_GROUP_MIN_YD3D11_CS_THREAD_GROUP_MIN_ZD3D11_CS_THREAD_LOCAL_TEMP_REGISTER_POOLD3D11_DEFAULT_BLEND_FACTOR_ALPHAD3D11_DEFAULT_BLEND_FACTOR_BLUED3D11_DEFAULT_BLEND_FACTOR_GREEND3D11_DEFAULT_BLEND_FACTOR_REDD3D11_DEFAULT_BORDER_COLOR_COMPONENTD3D11_DEFAULT_DEPTH_BIASD3D11_DEFAULT_DEPTH_BIAS_CLAMPD3D11_DEFAULT_MAX_ANISOTROPYD3D11_DEFAULT_MIP_LOD_BIASD3D11_DEFAULT_RENDER_TARGET_ARRAY_INDEXD3D11_DEFAULT_SAMPLE_MASKD3D11_DEFAULT_SCISSOR_ENDXD3D11_DEFAULT_SCISSOR_ENDYD3D11_DEFAULT_SCISSOR_STARTXD3D11_DEFAULT_SCISSOR_STARTYD3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIASD3D11_DEFAULT_STENCIL_READ_MASKD3D11_DEFAULT_STENCIL_REFERENCED3D11_DEFAULT_STENCIL_WRITE_MASKD3D11_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEXD3D11_DEFAULT_VIEWPORT_HEIGHTD3D11_DEFAULT_VIEWPORT_MAX_DEPTHD3D11_DEFAULT_VIEWPORT_MIN_DEPTHD3D11_DEFAULT_VIEWPORT_TOPLEFTXD3D11_DEFAULT_VIEWPORT_TOPLEFTYD3D11_DEFAULT_VIEWPORT_WIDTHD3D11_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARSD3D11_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTSD3D11_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNTD3D11_DS_INPUT_CONTROL_POINT_REGISTER_COUNTD3D11_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INSTD3D11_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTSD3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTSD3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNTD3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COUNTD3D11_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INSTD3D11_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTSD3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTSD3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNTD3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNTD3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INSTD3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTSD3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTSD3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNTD3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNTD3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INSTD3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTSD3D11_DS_OUTPUT_REGISTER_COMPONENTSD3D11_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_DS_OUTPUT_REGISTER_COUNTD3D11_FLOAT16_FUSED_TOLERANCE_IN_ULPD3D11_FLOAT32_MAXD3D11_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULPD3D11_FLOAT_TO_SRGB_EXPONENT_DENOMINATORD3D11_FLOAT_TO_SRGB_EXPONENT_NUMERATORD3D11_FLOAT_TO_SRGB_OFFSETD3D11_FLOAT_TO_SRGB_SCALE_1D3D11_FLOAT_TO_SRGB_SCALE_2D3D11_FLOAT_TO_SRGB_THRESHOLDD3D11_FTOI_INSTRUCTION_MAX_INPUTD3D11_FTOI_INSTRUCTION_MIN_INPUTD3D11_FTOU_INSTRUCTION_MAX_INPUTD3D11_FTOU_INSTRUCTION_MIN_INPUTD3D11_GS_INPUT_INSTANCE_ID_READS_PER_INSTD3D11_GS_INPUT_INSTANCE_ID_READ_PORTSD3D11_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTSD3D11_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNTD3D11_GS_INPUT_INSTANCE_ID_REGISTER_COUNTD3D11_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTSD3D11_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNTD3D11_GS_INPUT_PRIM_CONST_REGISTER_COUNTD3D11_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INSTD3D11_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTSD3D11_GS_INPUT_REGISTER_COMPONENTSD3D11_GS_INPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_GS_INPUT_REGISTER_COUNTD3D11_GS_INPUT_REGISTER_READS_PER_INSTD3D11_GS_INPUT_REGISTER_READ_PORTSD3D11_GS_INPUT_REGISTER_VERTICESD3D11_GS_MAX_INSTANCE_COUNTD3D11_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCESD3D11_GS_OUTPUT_ELEMENTSD3D11_GS_OUTPUT_REGISTER_COMPONENTSD3D11_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_GS_OUTPUT_REGISTER_COUNTD3D11_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNTD3D11_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNTD3D11_HS_CONTROL_POINT_REGISTER_COMPONENTSD3D11_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNTD3D11_HS_CONTROL_POINT_REGISTER_READS_PER_INSTD3D11_HS_CONTROL_POINT_REGISTER_READ_PORTSD3D11_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUNDD3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTSD3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNTD3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNTD3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INSTD3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTSD3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTSD3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNTD3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNTD3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INSTD3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTSD3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTSD3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNTD3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNTD3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INSTD3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTSD3D11_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUNDD3D11_HS_MAXTESSFACTOR_LOWER_BOUNDD3D11_HS_MAXTESSFACTOR_UPPER_BOUNDD3D11_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARSD3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTSD3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNTD3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNTD3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INSTD3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTSD3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTSD3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNTD3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNTD3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INSTD3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTSD3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTSD3D11_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTESD3D11_IA_DEFAULT_PRIMITIVE_TOPOLOGYD3D11_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTESD3D11_IA_INDEX_INPUT_RESOURCE_SLOT_COUNTD3D11_IA_INSTANCE_ID_BIT_COUNTD3D11_IA_INTEGER_ARITHMETIC_BIT_COUNTD3D11_IA_PATCH_MAX_CONTROL_POINT_COUNTD3D11_IA_PRIMITIVE_ID_BIT_COUNTD3D11_IA_VERTEX_ID_BIT_COUNTD3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNTD3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTSD3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNTD3D11_INTEGER_DIVIDE_BY_ZERO_QUOTIENTD3D11_INTEGER_DIVIDE_BY_ZERO_REMAINDERD3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCILD3D11_KEEP_UNORDERED_ACCESS_VIEWSD3D11_LINEAR_GAMMAD3D11_MAJOR_VERSIOND3D11_MAX_BORDER_COLOR_COMPONENTD3D11_MAX_DEPTHD3D11_MAX_MAXANISOTROPYD3D11_MAX_MULTISAMPLE_SAMPLE_COUNTD3D11_MAX_POSITION_VALUED3D11_MAX_TEXTURE_DIMENSION_2_TO_EXPD3D11_MINOR_VERSIOND3D11_MIN_BORDER_COLOR_COMPONENTD3D11_MIN_DEPTHD3D11_MIN_MAXANISOTROPYD3D11_MIP_LOD_BIAS_MAXD3D11_MIP_LOD_BIAS_MIND3D11_MIP_LOD_FRACTIONAL_BIT_COUNTD3D11_MIP_LOD_RANGE_BIT_COUNTD3D11_MULTISAMPLE_ANTIALIAS_LINE_WIDTHD3D11_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULTD3D11_PIXEL_ADDRESS_RANGE_BIT_COUNTD3D11_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNTD3D11_PS_CS_UAV_REGISTER_COMPONENTSD3D11_PS_CS_UAV_REGISTER_COUNTD3D11_PS_CS_UAV_REGISTER_READS_PER_INSTD3D11_PS_CS_UAV_REGISTER_READ_PORTSD3D11_PS_FRONTFACING_DEFAULT_VALUED3D11_PS_FRONTFACING_FALSE_VALUED3D11_PS_FRONTFACING_TRUE_VALUED3D11_PS_INPUT_REGISTER_COMPONENTSD3D11_PS_INPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_PS_INPUT_REGISTER_COUNTD3D11_PS_INPUT_REGISTER_READS_PER_INSTD3D11_PS_INPUT_REGISTER_READ_PORTSD3D11_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENTD3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENTSD3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNTD3D11_PS_OUTPUT_DEPTH_REGISTER_COUNTD3D11_PS_OUTPUT_MASK_REGISTER_COMPONENTSD3D11_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNTD3D11_PS_OUTPUT_MASK_REGISTER_COUNTD3D11_PS_OUTPUT_REGISTER_COMPONENTSD3D11_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_PS_OUTPUT_REGISTER_COUNTD3D11_PS_PIXEL_CENTER_FRACTIONAL_COMPONENTD3D11_RAW_UAV_SRV_BYTE_ALIGNMENTD3D11_REQ_BLEND_OBJECT_COUNT_PER_DEVICED3D11_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXPD3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNTD3D11_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICED3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXPD3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXPD3D11_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSIOND3D11_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMITD3D11_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNTD3D11_REQ_MAXANISOTROPYD3D11_REQ_MIP_LEVELSD3D11_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTESD3D11_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICED3D11_REQ_RENDER_TO_BUFFER_WINDOW_WIDTHD3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERMD3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERMD3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERMD3D11_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXPD3D11_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICED3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSIOND3D11_REQ_TEXTURE1D_U_DIMENSIOND3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSIOND3D11_REQ_TEXTURE2D_U_OR_V_DIMENSIOND3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSIOND3D11_REQ_TEXTURECUBE_DIMENSIOND3D11_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVALD3D11_SHADER_MAJOR_VERSIOND3D11_SHADER_MAX_INSTANCESD3D11_SHADER_MAX_INTERFACESD3D11_SHADER_MAX_INTERFACE_CALL_SITESD3D11_SHADER_MAX_TYPESD3D11_SHADER_MINOR_VERSIOND3D11_SHIFT_INSTRUCTION_PAD_VALUED3D11_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNTD3D11_SIMULTANEOUS_RENDER_TARGET_COUNTD3D11_SO_BUFFER_MAX_STRIDE_IN_BYTESD3D11_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTESD3D11_SO_BUFFER_SLOT_COUNTD3D11_SO_DDI_REGISTER_INDEX_DENOTING_GAPD3D11_SO_NO_RASTERIZED_STREAMD3D11_SO_OUTPUT_COMPONENT_COUNTD3D11_SO_STREAM_COUNTD3D11_SPEC_DATE_DAYD3D11_SPEC_DATE_MONTHD3D11_SPEC_DATE_YEARD3D11_SPEC_VERSIOND3D11_SRGB_GAMMAD3D11_SRGB_TO_FLOAT_DENOMINATOR_1D3D11_SRGB_TO_FLOAT_DENOMINATOR_2D3D11_SRGB_TO_FLOAT_EXPONENTD3D11_SRGB_TO_FLOAT_OFFSETD3D11_SRGB_TO_FLOAT_THRESHOLDD3D11_SRGB_TO_FLOAT_TOLERANCE_IN_ULPD3D11_STANDARD_COMPONENT_BIT_COUNTD3D11_STANDARD_COMPONENT_BIT_COUNT_DOUBLEDD3D11_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLED3D11_STANDARD_PIXEL_COMPONENT_COUNTD3D11_STANDARD_PIXEL_ELEMENT_COUNTD3D11_STANDARD_VECTOR_SIZED3D11_STANDARD_VERTEX_ELEMENT_COUNTD3D11_STANDARD_VERTEX_TOTAL_COMPONENT_COUNTD3D11_SUBPIXEL_FRACTIONAL_BIT_COUNTD3D11_SUBTEXEL_FRACTIONAL_BIT_COUNTD3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTORD3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTORD3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTORD3D11_TESSELLATOR_MAX_TESSELLATION_FACTORD3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTORD3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTORD3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTORD3D11_TEXEL_ADDRESS_RANGE_BIT_COUNTD3D11_UNBOUND_MEMORY_ACCESS_RESULTD3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEXD3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINED3D11_VIEWPORT_BOUNDS_MAXD3D11_VIEWPORT_BOUNDS_MIND3D11_VS_INPUT_REGISTER_COMPONENTSD3D11_VS_INPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_VS_INPUT_REGISTER_COUNTD3D11_VS_INPUT_REGISTER_READS_PER_INSTD3D11_VS_INPUT_REGISTER_READ_PORTSD3D11_VS_OUTPUT_REGISTER_COMPONENTSD3D11_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D11_VS_OUTPUT_REGISTER_COUNTD3D11_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMITD3D11_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXPD3D11_WHQL_DRAW_VERTEX_COUNT_2_TO_EXPD3D11_1_UAV_SLOT_COUNTD3D11_2_TILED_RESOURCE_TILE_SIZE_IN_BYTESD3D11_APPEND_ALIGNED_ELEMENTD3D11_PRIMITIVE_TOPOLOGYD3D11_PRIMITIVED3D11_SRV_DIMENSIOND3D11_RECTD3D11_FILTER_REDUCTION_TYPE_MASKD3D11_FILTER_REDUCTION_TYPE_SHIFTD3D11_FILTER_TYPE_MASKD3D11_MIN_FILTER_SHIFTD3D11_MAG_FILTER_SHIFTD3D11_MIP_FILTER_SHIFTD3D11_COMPARISON_FILTERING_BITD3D11_ANISOTROPIC_FILTERING_BIT//FIXME bitfieldD3D11_SDK_VERSIOND3D11CalcSubresourceD3D11CreateDeviceID3D11DeviceID3D11DeviceContextD3D11CreateDeviceAndSwapChaind3d11D3D11_BLENDD3D11_BLEND_OPD3D11_BOXD3D11_CULL_MODED3D11_FILL_MODED3D11_VIDEO_DECODER_BUFFER_TYPED3D11_VIDEO_DECODER_CONFIGD3D11_VIDEO_DECODER_DESCID3D11BlendStateID3D11BlendStateVtblID3D11BufferID3D11CryptoSessionID3D11DeviceChildID3D11DeviceChildVtblID3D11DeviceContextVtblID3D11DeviceVtblID3D11RasterizerStateID3D11RasterizerStateVtblID3D11ResourceID3D11VideoContextID3D11VideoContextVtblID3D11VideoDecoderID3D11VideoDeviceID3D11VideoDeviceVtblID3D11VideoProcessorID3D11VideoProcessorEnumeratorID3D11VideoProcessorEnumeratorVtblID3D11Viewd3d11_1ID3D11Device1ID3D11Device1VtblID3D11DeviceContext1ID3D11DeviceContext1Vtbld3d12D3D12_RESOURCE_STATESD3D11On12CreateDevice//! Mappings for the content of d3d11on12.hD3D11_SDK_LAYERS_VERSIOND3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OPD3D11_DEBUG_FEATURE_FINISH_PER_RENDER_OPD3D11_DEBUG_FEATURE_PRESENT_PER_RENDER_OPD3D11_DEBUG_FEATURE_ALWAYS_DISCARD_OFFERED_RESOURCED3D11_DEBUG_FEATURE_NEVER_DISCARD_OFFERED_RESOURCED3D11_DEBUG_FEATURE_AVOID_BEHAVIOR_CHANGING_DEBUG_AIDSD3D11_DEBUG_FEATURE_DISABLE_TILED_RESOURCE_MAPPING_TRACKING_AND_VALIDATIOND3D11_REGKEY_PATHD3D11_MUTE_DEBUG_OUTPUTD3D11_ENABLE_BREAK_ON_MESSAGED3D11_INFOQUEUE_STORAGE_FILTER_OVERRIDED3D11_MUTE_CATEGORYD3D11_MUTE_SEVERITYD3D11_MUTE_ID_STRINGD3D11_MUTE_ID_DECIMALD3D11_UNMUTE_SEVERITY_INFOD3D11_BREAKON_CATEGORYD3D11_BREAKON_SEVERITYD3D11_BREAKON_ID_STRINGD3D11_BREAKON_ID_DECIMALD3D11_APPSIZE_STRINGD3D11_APPNAME_STRINGD3D11_FORCE_DEBUGGABLED3D11_FORCE_SHADER_SKIP_OPTIMIZATIOND3D11_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMITD3D_INTERPOLATION_MODED3D_MIN_PRECISIOND3D_PARAMETER_FLAGSD3D_TESSELLATOR_DOMAIND3D_TESSELLATOR_OUTPUT_PRIMITIVED3D_TESSELLATOR_PARTITIONINGID3DBlobD3D_RETURN_PARAMETER_INDEXD3D11_RESOURCE_RETURN_TYPED3D11_CBUFFER_TYPED3D11_TESSELLATOR_DOMAIND3D11_TESSELLATOR_PARTITIONINGD3D11_TESSELLATOR_OUTPUT_PRIMITIVED3D_SHADER_REQUIRES_DOUBLESD3D_SHADER_REQUIRES_EARLY_DEPTH_STENCILD3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGED3D_SHADER_REQUIRES_64_UAVSD3D_SHADER_REQUIRES_MINIMUM_PRECISIOND3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONSD3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONSD3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERINGD3D_SHADER_REQUIRES_TILED_RESOURCESD3D10_SB_TOKENIZED_PROGRAM_TYPE_MASKD3D10_SB_TOKENIZED_PROGRAM_TYPE_SHIFTDECODE_D3D10_SB_TOKENIZED_PROGRAM_TYPED3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_MASKD3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_SHIFTD3D10_SB_TOKENIZED_PROGRAM_MINOR_VERSION_MASKDECODE_D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSIONDECODE_D3D10_SB_TOKENIZED_PROGRAM_MINOR_VERSIONENCODE_D3D10_SB_TOKENIZED_PROGRAM_VERSION_TOKENDECODE_D3D10_SB_TOKENIZED_PROGRAM_LENGTHENCODE_D3D10_SB_TOKENIZED_PROGRAM_LENGTHMAX_D3D10_SB_TOKENIZED_PROGRAM_LENGTHD3D10_SB_OPCODE_TYPE_MASKDECODE_D3D10_SB_OPCODE_TYPED3D10_SB_OPCODE_TYPEENCODE_D3D10_SB_OPCODE_TYPED3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_MASKD3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_SHIFTDECODE_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTHENCODE_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTHMAX_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTHD3D10_SB_INSTRUCTION_SATURATE_MASKDECODE_IS_D3D10_SB_INSTRUCTION_SATURATE_ENABLEDENCODE_D3D10_SB_INSTRUCTION_SATURATED3D10_SB_INSTRUCTION_TEST_BOOLEAN_MASKD3D10_SB_INSTRUCTION_TEST_BOOLEAN_SHIFTDECODE_D3D10_SB_INSTRUCTION_TEST_BOOLEAND3D10_SB_INSTRUCTION_TEST_BOOLEANENCODE_D3D10_SB_INSTRUCTION_TEST_BOOLEAND3D11_SB_INSTRUCTION_PRECISE_VALUES_MASKD3D11_SB_INSTRUCTION_PRECISE_VALUES_SHIFTDECODE_D3D11_SB_INSTRUCTION_PRECISE_VALUESENCODE_D3D11_SB_INSTRUCTION_PRECISE_VALUESD3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_MASKD3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_SHIFTDECODE_D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPED3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPEENCODE_D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPED3D11_SB_SYNC_THREADS_IN_GROUPD3D11_SB_SYNC_THREAD_GROUP_SHARED_MEMORYD3D11_SB_SYNC_UNORDERED_ACCESS_VIEW_MEMORY_GROUPD3D11_SB_SYNC_UNORDERED_ACCESS_VIEW_MEMORY_GLOBALD3D11_SB_SYNC_FLAGS_MASKDECODE_D3D11_SB_SYNC_FLAGSENCODE_D3D11_SB_SYNC_FLAGSD3D10_SB_OPCODE_EXTENDED_MASKD3D10_SB_OPCODE_EXTENDED_SHIFTDECODE_IS_D3D10_SB_OPCODE_EXTENDEDENCODE_D3D10_SB_OPCODE_EXTENDEDD3D11_SB_MAX_SIMULTANEOUS_EXTENDED_OPCODESD3D10_SB_EXTENDED_OPCODE_TYPE_MASKDECODE_D3D10_SB_EXTENDED_OPCODE_TYPED3D10_SB_EXTENDED_OPCODE_TYPEENCODE_D3D10_SB_EXTENDED_OPCODE_TYPED3D10_SB_IMMEDIATE_ADDRESS_OFFSET_COORD_MASKD3D10_SB_IMMEDIATE_ADDRESS_OFFSET_SHIFTD3D10_SB_IMMEDIATE_ADDRESS_OFFSET_MASKDECODE_IMMEDIATE_D3D10_SB_ADDRESS_OFFSETENCODE_IMMEDIATE_D3D10_SB_ADDRESS_OFFSETD3D11_SB_EXTENDED_RESOURCE_DIMENSION_MASKD3D11_SB_EXTENDED_RESOURCE_DIMENSION_SHIFTDECODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSIOND3D10_SB_RESOURCE_DIMENSIONENCODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSIOND3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_MASKD3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_SHIFTDECODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDEENCODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDED3D10_SB_RESOURCE_RETURN_TYPE_MASKD3D10_SB_RESOURCE_RETURN_TYPE_NUMBITSD3D11_SB_EXTENDED_RESOURCE_RETURN_TYPE_SHIFTDECODE_D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPEENCODE_D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPED3D10_SB_CUSTOMDATA_CLASS_MASKD3D10_SB_CUSTOMDATA_CLASS_SHIFTDECODE_D3D10_SB_CUSTOMDATA_CLASSD3D10_SB_CUSTOMDATA_CLASSENCODE_D3D10_SB_CUSTOMDATA_CLASSD3D10_SB_OPERAND_NUM_COMPONENTS_MASKDECODE_D3D10_SB_OPERAND_NUM_COMPONENTSENCODE_D3D10_SB_OPERAND_NUM_COMPONENTSD3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_MASKD3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_SHIFTDECODE_D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODED3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODEENCODE_D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODED3D10_SB_4_COMPONENT_NAME_MASKD3D10_SB_OPERAND_4_COMPONENT_MASK_MASKD3D10_SB_OPERAND_4_COMPONENT_MASK_SHIFTD3D10_SB_OPERAND_4_COMPONENT_MASK_XD3D10_SB_OPERAND_4_COMPONENT_MASK_YD3D10_SB_OPERAND_4_COMPONENT_MASK_ZD3D10_SB_OPERAND_4_COMPONENT_MASK_WD3D10_SB_OPERAND_4_COMPONENT_MASK_RD3D10_SB_OPERAND_4_COMPONENT_MASK_GD3D10_SB_OPERAND_4_COMPONENT_MASK_BD3D10_SB_OPERAND_4_COMPONENT_MASK_AD3D10_SB_OPERAND_4_COMPONENT_MASK_ALLDECODE_D3D10_SB_OPERAND_4_COMPONENT_MASKENCODE_D3D10_SB_OPERAND_4_COMPONENT_MASKD3D10_SB_OPERAND_4_COMPONENT_MASKD3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MASKD3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_SHIFTDECODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLEDECODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_SOURCED3D10_SB_4_COMPONENT_NAMEENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLED3D10_SB_OPERAND_4_COMPONENT_NOSWIZZLED3D10_SB_OPERAND_4_COMPONENT_REPLICATEXD3D10_SB_OPERAND_4_COMPONENT_REPLICATEYD3D10_SB_OPERAND_4_COMPONENT_REPLICATEZD3D10_SB_OPERAND_4_COMPONENT_REPLICATEWD3D10_SB_OPERAND_4_COMPONENT_REPLICATEREDD3D10_SB_OPERAND_4_COMPONENT_REPLICATEGREEND3D10_SB_OPERAND_4_COMPONENT_REPLICATEBLUED3D10_SB_OPERAND_4_COMPONENT_REPLICATEALPHAD3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MASKD3D10_SB_OPERAND_4_COMPONENT_SELECT_1_SHIFTDECODE_D3D10_SB_OPERAND_4_COMPONENT_SELECT_1ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SELECT_1D3D10_SB_OPERAND_TYPE_MASKD3D10_SB_OPERAND_TYPE_SHIFTDECODE_D3D10_SB_OPERAND_TYPED3D10_SB_OPERAND_TYPEENCODE_D3D10_SB_OPERAND_TYPED3D10_SB_OPERAND_INDEX_DIMENSION_MASKD3D10_SB_OPERAND_INDEX_DIMENSION_SHIFTDECODE_D3D10_SB_OPERAND_INDEX_DIMENSIOND3D10_SB_OPERAND_INDEX_DIMENSIONENCODE_D3D10_SB_OPERAND_INDEX_DIMENSIOND3D10_SB_OPERAND_INDEX_REPRESENTATION_SHIFTD3D10_SB_OPERAND_INDEX_REPRESENTATION_MASKDECODE_D3D10_SB_OPERAND_INDEX_REPRESENTATIOND3D10_SB_OPERAND_INDEX_REPRESENTATIONENCODE_D3D10_SB_OPERAND_INDEX_REPRESENTATIOND3D10_SB_OPERAND_EXTENDED_MASKD3D10_SB_OPERAND_EXTENDED_SHIFTDECODE_IS_D3D10_SB_OPERAND_EXTENDEDENCODE_D3D10_SB_OPERAND_EXTENDEDD3D10_SB_EXTENDED_OPERAND_TYPE_MASKDECODE_D3D10_SB_EXTENDED_OPERAND_TYPED3D10_SB_EXTENDED_OPERAND_TYPEENCODE_D3D10_SB_EXTENDED_OPERAND_TYPED3D10_SB_OPERAND_MODIFIER_MASKD3D10_SB_OPERAND_MODIFIER_SHIFTDECODE_D3D10_SB_OPERAND_MODIFIERD3D10_SB_OPERAND_MODIFIERENCODE_D3D10_SB_EXTENDED_OPERAND_MODIFIERD3D11_SB_OPERAND_MIN_PRECISION_MASKD3D11_SB_OPERAND_MIN_PRECISION_SHIFTDECODE_D3D11_SB_OPERAND_MIN_PRECISIOND3D11_SB_OPERAND_MIN_PRECISIONENCODE_D3D11_SB_OPERAND_MIN_PRECISIOND3D10_SB_OPERAND_DOUBLE_EXTENDED_MASKD3D10_SB_OPERAND_DOUBLE_EXTENDED_SHIFTDECODE_IS_D3D10_SB_OPERAND_DOUBLE_EXTENDEDENCODE_D3D10_SB_OPERAND_DOUBLE_EXTENDEDD3D10_SB_NAME_MASKDECODE_D3D10_SB_NAMED3D10_SB_NAMEENCODE_D3D10_SB_NAMED3D10_SB_GLOBAL_FLAG_REFACTORING_ALLOWEDD3D11_SB_GLOBAL_FLAG_ENABLE_DOUBLE_PRECISION_FLOAT_OPSD3D11_SB_GLOBAL_FLAG_FORCE_EARLY_DEPTH_STENCILD3D11_SB_GLOBAL_FLAG_ENABLE_RAW_AND_STRUCTURED_BUFFERSD3D11_1_SB_GLOBAL_FLAG_SKIP_OPTIMIZATIOND3D11_1_SB_GLOBAL_FLAG_ENABLE_MINIMUM_PRECISIOND3D11_1_SB_GLOBAL_FLAG_ENABLE_DOUBLE_EXTENSIONSD3D11_1_SB_GLOBAL_FLAG_ENABLE_SHADER_EXTENSIONSD3D10_SB_GLOBAL_FLAGS_MASKDECODE_D3D10_SB_GLOBAL_FLAGSENCODE_D3D10_SB_GLOBAL_FLAGSD3D10_SB_RESOURCE_DIMENSION_MASKD3D10_SB_RESOURCE_DIMENSION_SHIFTDECODE_D3D10_SB_RESOURCE_DIMENSIONENCODE_D3D10_SB_RESOURCE_DIMENSIOND3D10_SB_RESOURCE_SAMPLE_COUNT_MASKD3D10_SB_RESOURCE_SAMPLE_COUNT_SHIFTDECODE_D3D10_SB_RESOURCE_SAMPLE_COUNTENCODE_D3D10_SB_RESOURCE_SAMPLE_COUNTDECODE_D3D10_SB_RESOURCE_RETURN_TYPED3D10_SB_RESOURCE_RETURN_TYPEENCODE_D3D10_SB_RESOURCE_RETURN_TYPED3D10_SB_SAMPLER_MODE_MASKD3D10_SB_SAMPLER_MODE_SHIFTDECODE_D3D10_SB_SAMPLER_MODED3D10_SB_SAMPLER_MODEENCODE_D3D10_SB_SAMPLER_MODED3D10_SB_INPUT_INTERPOLATION_MODE_MASKD3D10_SB_INPUT_INTERPOLATION_MODE_SHIFTDECODE_D3D10_SB_INPUT_INTERPOLATION_MODED3D10_SB_INTERPOLATION_MODEENCODE_D3D10_SB_INPUT_INTERPOLATION_MODED3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_MASKD3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_SHIFTDECODE_D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERND3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERNENCODE_D3D10_SB_D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERND3D10_SB_GS_INPUT_PRIMITIVE_MASKD3D10_SB_GS_INPUT_PRIMITIVE_SHIFTDECODE_D3D10_SB_GS_INPUT_PRIMITIVED3D10_SB_PRIMITIVEENCODE_D3D10_SB_GS_INPUT_PRIMITIVED3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_MASKD3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_SHIFTDECODE_D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGYD3D10_SB_PRIMITIVE_TOPOLOGYENCODE_D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGYD3D11_SB_INPUT_CONTROL_POINT_COUNT_MASKD3D11_SB_INPUT_CONTROL_POINT_COUNT_SHIFTDECODE_D3D11_SB_INPUT_CONTROL_POINT_COUNTENCODE_D3D11_SB_INPUT_CONTROL_POINT_COUNTD3D11_SB_OUTPUT_CONTROL_POINT_COUNT_MASKD3D11_SB_OUTPUT_CONTROL_POINT_COUNT_SHIFTDECODE_D3D11_SB_OUTPUT_CONTROL_POINT_COUNTENCODE_D3D11_SB_OUTPUT_CONTROL_POINT_COUNTD3D11_SB_TESS_DOMAIN_MASKD3D11_SB_TESS_DOMAIN_SHIFTDECODE_D3D11_SB_TESS_DOMAIND3D11_SB_TESSELLATOR_DOMAINENCODE_D3D11_SB_TESS_DOMAIND3D11_SB_TESS_PARTITIONING_MASKD3D11_SB_TESS_PARTITIONING_SHIFTDECODE_D3D11_SB_TESS_PARTITIONINGD3D11_SB_TESSELLATOR_PARTITIONINGENCODE_D3D11_SB_TESS_PARTITIONINGD3D11_SB_TESS_OUTPUT_PRIMITIVE_MASKD3D11_SB_TESS_OUTPUT_PRIMITIVE_SHIFTDECODE_D3D11_SB_TESS_OUTPUT_PRIMITIVED3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVEENCODE_D3D11_SB_TESS_OUTPUT_PRIMITIVED3D10_SB_INSTRUCTION_RETURN_TYPE_MASKD3D10_SB_INSTRUCTION_RETURN_TYPE_SHIFTDECODE_D3D10_SB_INSTRUCTION_RETURN_TYPED3D10_SB_INSTRUCTION_RETURN_TYPEENCODE_D3D10_SB_INSTRUCTION_RETURN_TYPED3D11_SB_INTERFACE_INDEXED_BIT_MASKD3D11_SB_INTERFACE_INDEXED_BIT_SHIFTD3D11_SB_INTERFACE_TABLE_LENGTH_MASKD3D11_SB_INTERFACE_TABLE_LENGTH_SHIFTD3D11_SB_INTERFACE_ARRAY_LENGTH_MASKD3D11_SB_INTERFACE_ARRAY_LENGTH_SHIFTDECODE_D3D11_SB_INTERFACE_INDEXED_BITENCODE_D3D11_SB_INTERFACE_INDEXED_BITDECODE_D3D11_SB_INTERFACE_TABLE_LENGTHENCODE_D3D11_SB_INTERFACE_TABLE_LENGTHDECODE_D3D11_SB_INTERFACE_ARRAY_LENGTHENCODE_D3D11_SB_INTERFACE_ARRAY_LENGTHD3D11_SB_GLOBALLY_COHERENT_ACCESSD3D11_SB_ACCESS_COHERENCY_MASKDECODE_D3D11_SB_ACCESS_COHERENCY_FLAGSENCODE_D3D11_SB_ACCESS_COHERENCY_FLAGSD3D11_SB_UAV_HAS_ORDER_PRESERVING_COUNTERD3D11_SB_UAV_FLAGS_MASKDECODE_D3D11_SB_UAV_FLAGSENCODE_D3D11_SB_UAV_FLAGSD3D12_16BIT_INDEX_STRIP_CUT_VALUED3D12_32BIT_INDEX_STRIP_CUT_VALUED3D12_8BIT_INDEX_STRIP_CUT_VALUED3D12_APPEND_ALIGNED_ELEMENTD3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNTD3D12_CLIP_OR_CULL_DISTANCE_COUNTD3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNTD3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNTD3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTSD3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNTD3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNTD3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENTD3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTSD3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNTD3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INSTD3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTSD3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMITD3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTSD3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNTD3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INSTD3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTSD3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNTD3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTSD3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNTD3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INSTD3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTSD3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNTD3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTSD3D12_COMMONSHADER_SAMPLER_REGISTER_COUNTD3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INSTD3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTSD3D12_COMMONSHADER_SAMPLER_SLOT_COUNTD3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMITD3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTSD3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNTD3D12_COMMONSHADER_TEMP_REGISTER_COUNTD3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INSTD3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTSD3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAXD3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIND3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVED3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVED3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENTD3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREADD3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUPD3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSIOND3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENTD3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUPD3D12_CS_4_X_THREAD_GROUP_MAX_XD3D12_CS_4_X_THREAD_GROUP_MAX_YD3D12_CS_4_X_UAV_REGISTER_COUNTD3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSIOND3D12_CS_TGSM_REGISTER_COUNTD3D12_CS_TGSM_REGISTER_READS_PER_INSTD3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTSD3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTSD3D12_CS_THREADGROUPID_REGISTER_COMPONENTSD3D12_CS_THREADGROUPID_REGISTER_COUNTD3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTSD3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNTD3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTSD3D12_CS_THREADIDINGROUP_REGISTER_COUNTD3D12_CS_THREADID_REGISTER_COMPONENTSD3D12_CS_THREADID_REGISTER_COUNTD3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUPD3D12_CS_THREAD_GROUP_MAX_XD3D12_CS_THREAD_GROUP_MAX_YD3D12_CS_THREAD_GROUP_MAX_ZD3D12_CS_THREAD_GROUP_MIN_XD3D12_CS_THREAD_GROUP_MIN_YD3D12_CS_THREAD_GROUP_MIN_ZD3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOLD3D12_DEFAULT_BLEND_FACTOR_ALPHAD3D12_DEFAULT_BLEND_FACTOR_BLUED3D12_DEFAULT_BLEND_FACTOR_GREEND3D12_DEFAULT_BLEND_FACTOR_REDD3D12_DEFAULT_BORDER_COLOR_COMPONENTD3D12_DEFAULT_DEPTH_BIASD3D12_DEFAULT_DEPTH_BIAS_CLAMPD3D12_DEFAULT_MAX_ANISOTROPYD3D12_DEFAULT_MIP_LOD_BIASD3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENTD3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEXD3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENTD3D12_DEFAULT_SAMPLE_MASKD3D12_DEFAULT_SCISSOR_ENDXD3D12_DEFAULT_SCISSOR_ENDYD3D12_DEFAULT_SCISSOR_STARTXD3D12_DEFAULT_SCISSOR_STARTYD3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIASD3D12_DEFAULT_STENCIL_READ_MASKD3D12_DEFAULT_STENCIL_REFERENCED3D12_DEFAULT_STENCIL_WRITE_MASKD3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEXD3D12_DEFAULT_VIEWPORT_HEIGHTD3D12_DEFAULT_VIEWPORT_MAX_DEPTHD3D12_DEFAULT_VIEWPORT_MIN_DEPTHD3D12_DEFAULT_VIEWPORT_TOPLEFTXD3D12_DEFAULT_VIEWPORT_TOPLEFTYD3D12_DEFAULT_VIEWPORT_WIDTHD3D12_DESCRIPTOR_RANGE_OFFSET_APPENDD3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_ENDD3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_STARTD3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARSD3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTSD3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNTD3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNTD3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INSTD3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTSD3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTSD3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNTD3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNTD3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INSTD3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTSD3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTSD3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNTD3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNTD3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INSTD3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTSD3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTSD3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNTD3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNTD3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INSTD3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTSD3D12_DS_OUTPUT_REGISTER_COMPONENTSD3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_DS_OUTPUT_REGISTER_COUNTD3D12_FLOAT16_FUSED_TOLERANCE_IN_ULPD3D12_FLOAT32_MAXD3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULPD3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATORD3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATORD3D12_FLOAT_TO_SRGB_OFFSETD3D12_FLOAT_TO_SRGB_SCALE_1D3D12_FLOAT_TO_SRGB_SCALE_2D3D12_FLOAT_TO_SRGB_THRESHOLDD3D12_FTOI_INSTRUCTION_MAX_INPUTD3D12_FTOI_INSTRUCTION_MIN_INPUTD3D12_FTOU_INSTRUCTION_MAX_INPUTD3D12_FTOU_INSTRUCTION_MIN_INPUTD3D12_GS_INPUT_INSTANCE_ID_READS_PER_INSTD3D12_GS_INPUT_INSTANCE_ID_READ_PORTSD3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTSD3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNTD3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNTD3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTSD3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNTD3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNTD3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INSTD3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTSD3D12_GS_INPUT_REGISTER_COMPONENTSD3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_GS_INPUT_REGISTER_COUNTD3D12_GS_INPUT_REGISTER_READS_PER_INSTD3D12_GS_INPUT_REGISTER_READ_PORTSD3D12_GS_INPUT_REGISTER_VERTICESD3D12_GS_MAX_INSTANCE_COUNTD3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCESD3D12_GS_OUTPUT_ELEMENTSD3D12_GS_OUTPUT_REGISTER_COMPONENTSD3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_GS_OUTPUT_REGISTER_COUNTD3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNTD3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNTD3D12_HS_CONTROL_POINT_REGISTER_COMPONENTSD3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNTD3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INSTD3D12_HS_CONTROL_POINT_REGISTER_READ_PORTSD3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUNDD3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTSD3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNTD3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNTD3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INSTD3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTSD3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTSD3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNTD3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNTD3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INSTD3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTSD3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTSD3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNTD3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNTD3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INSTD3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTSD3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUNDD3D12_HS_MAXTESSFACTOR_LOWER_BOUNDD3D12_HS_MAXTESSFACTOR_UPPER_BOUNDD3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARSD3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTSD3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNTD3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNTD3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INSTD3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTSD3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTSD3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNTD3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNTD3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INSTD3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTSD3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTSD3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTESD3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGYD3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTESD3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNTD3D12_IA_INSTANCE_ID_BIT_COUNTD3D12_IA_INTEGER_ARITHMETIC_BIT_COUNTD3D12_IA_PATCH_MAX_CONTROL_POINT_COUNTD3D12_IA_PRIMITIVE_ID_BIT_COUNTD3D12_IA_VERTEX_ID_BIT_COUNTD3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNTD3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTSD3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNTD3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENTD3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDERD3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCILD3D12_KEEP_UNORDERED_ACCESS_VIEWSD3D12_LINEAR_GAMMAD3D12_MAJOR_VERSIOND3D12_MAX_BORDER_COLOR_COMPONENTD3D12_MAX_DEPTHD3D12_MAX_LIVE_STATIC_SAMPLERSD3D12_MAX_MAXANISOTROPYD3D12_MAX_MULTISAMPLE_SAMPLE_COUNTD3D12_MAX_POSITION_VALUED3D12_MAX_ROOT_COSTD3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZED3D12_MAX_TEXTURE_DIMENSION_2_TO_EXPD3D12_MINOR_VERSIOND3D12_MIN_BORDER_COLOR_COMPONENTD3D12_MIN_DEPTHD3D12_MIN_MAXANISOTROPYD3D12_MIP_LOD_BIAS_MAXD3D12_MIP_LOD_BIAS_MIND3D12_MIP_LOD_FRACTIONAL_BIT_COUNTD3D12_MIP_LOD_RANGE_BIT_COUNTD3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTHD3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULTD3D12_OS_RESERVED_REGISTER_SPACE_VALUES_ENDD3D12_OS_RESERVED_REGISTER_SPACE_VALUES_STARTD3D12_PACKED_TILED3D12_PIXEL_ADDRESS_RANGE_BIT_COUNTD3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNTD3D12_PS_CS_UAV_REGISTER_COMPONENTSD3D12_PS_CS_UAV_REGISTER_COUNTD3D12_PS_CS_UAV_REGISTER_READS_PER_INSTD3D12_PS_CS_UAV_REGISTER_READ_PORTSD3D12_PS_FRONTFACING_DEFAULT_VALUED3D12_PS_FRONTFACING_FALSE_VALUED3D12_PS_FRONTFACING_TRUE_VALUED3D12_PS_INPUT_REGISTER_COMPONENTSD3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_PS_INPUT_REGISTER_COUNTD3D12_PS_INPUT_REGISTER_READS_PER_INSTD3D12_PS_INPUT_REGISTER_READ_PORTSD3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENTD3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTSD3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNTD3D12_PS_OUTPUT_DEPTH_REGISTER_COUNTD3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTSD3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNTD3D12_PS_OUTPUT_MASK_REGISTER_COUNTD3D12_PS_OUTPUT_REGISTER_COMPONENTSD3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_PS_OUTPUT_REGISTER_COUNTD3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENTD3D12_RAW_UAV_SRV_BYTE_ALIGNMENTD3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICED3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXPD3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNTD3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICED3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXPD3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXPD3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSIOND3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMITD3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNTD3D12_REQ_MAXANISOTROPYD3D12_REQ_MIP_LEVELSD3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTESD3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICED3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTHD3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERMD3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERMD3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERMD3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXPD3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICED3D12_REQ_SUBRESOURCESD3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSIOND3D12_REQ_TEXTURE1D_U_DIMENSIOND3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSIOND3D12_REQ_TEXTURE2D_U_OR_V_DIMENSIOND3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSIOND3D12_REQ_TEXTURECUBE_DIMENSIOND3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVALD3D12_RESOURCE_BARRIER_ALL_SUBRESOURCESD3D12_SHADER_MAJOR_VERSIOND3D12_SHADER_MAX_INSTANCESD3D12_SHADER_MAX_INTERFACESD3D12_SHADER_MAX_INTERFACE_CALL_SITESD3D12_SHADER_MAX_TYPESD3D12_SHADER_MINOR_VERSIOND3D12_SHIFT_INSTRUCTION_PAD_VALUED3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNTD3D12_SIMULTANEOUS_RENDER_TARGET_COUNTD3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENTD3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENTD3D12_SO_BUFFER_MAX_STRIDE_IN_BYTESD3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTESD3D12_SO_BUFFER_SLOT_COUNTD3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAPD3D12_SO_NO_RASTERIZED_STREAMD3D12_SO_OUTPUT_COMPONENT_COUNTD3D12_SO_STREAM_COUNTD3D12_SPEC_DATE_DAYD3D12_SPEC_DATE_MONTHD3D12_SPEC_DATE_YEARD3D12_SPEC_VERSIOND3D12_SRGB_GAMMAD3D12_SRGB_TO_FLOAT_DENOMINATOR_1D3D12_SRGB_TO_FLOAT_DENOMINATOR_2D3D12_SRGB_TO_FLOAT_EXPONENTD3D12_SRGB_TO_FLOAT_OFFSETD3D12_SRGB_TO_FLOAT_THRESHOLDD3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULPD3D12_STANDARD_COMPONENT_BIT_COUNTD3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLEDD3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLED3D12_STANDARD_PIXEL_COMPONENT_COUNTD3D12_STANDARD_PIXEL_ELEMENT_COUNTD3D12_STANDARD_VECTOR_SIZED3D12_STANDARD_VERTEX_ELEMENT_COUNTD3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNTD3D12_SUBPIXEL_FRACTIONAL_BIT_COUNTD3D12_SUBTEXEL_FRACTIONAL_BIT_COUNTD3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_ENDD3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_STARTD3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTORD3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTORD3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTORD3D12_TESSELLATOR_MAX_TESSELLATION_FACTORD3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTORD3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTORD3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTORD3D12_TEXEL_ADDRESS_RANGE_BIT_COUNTD3D12_TEXTURE_DATA_PITCH_ALIGNMENTD3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENTD3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTESD3D12_UAV_COUNTER_PLACEMENT_ALIGNMENTD3D12_UAV_SLOT_COUNTD3D12_UNBOUND_MEMORY_ACCESS_RESULTD3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEXD3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINED3D12_VIEWPORT_BOUNDS_MAXD3D12_VIEWPORT_BOUNDS_MIND3D12_VS_INPUT_REGISTER_COMPONENTSD3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_VS_INPUT_REGISTER_COUNTD3D12_VS_INPUT_REGISTER_READS_PER_INSTD3D12_VS_INPUT_REGISTER_READ_PORTSD3D12_VS_OUTPUT_REGISTER_COMPONENTSD3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNTD3D12_VS_OUTPUT_REGISTER_COUNTD3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMITD3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXPD3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXPD3D12_GPU_VIRTUAL_ADDRESSD3D12_PRIMITIVE_TOPOLOGYD3D12_PRIMITIVED3D12_RECTD3D12_SHADER_COMPONENT_MAPPING_MASKD3D12_SHADER_COMPONENT_MAPPING_SHIFTD3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES// D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING// D3D12_DECODE_SHADER_4_COMPONENT_MAPPING// D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPINGD3D12_FILTER_REDUCTION_TYPE_MASKD3D12_FILTER_REDUCTION_TYPE_SHIFTD3D12_FILTER_TYPE_MASKD3D12_MIN_FILTER_SHIFTD3D12_MAG_FILTER_SHIFTD3D12_MIP_FILTER_SHIFTD3D12_ANISOTROPIC_FILTERING_BIT// D3D12_ENCODE_BASIC_FILTER// D3D12_ENCODE_ANISOTROPIC_FILTER// D3D12_DECODE_MIN_FILTER// D3D12_DECODE_MAG_FILTER// D3D12_DECODE_MIP_FILTER// D3D12_DECODE_FILTER_REDUCTION// D3D12_DECODE_IS_COMPARISON_FILTER// D3D12_DECODE_IS_ANISOTROPIC_FILTERD3D12SerializeRootSignatureD3D12_ROOT_SIGNATURE_DESCD3D_ROOT_SIGNATURE_VERSIOND3D12CreateRootSignatureDeserializerD3D12SerializeVersionedRootSignatureD3D12_VERSIONED_ROOT_SIGNATURE_DESCD3D12CreateVersionedRootSignatureDeserializerD3D12CreateDeviceD3D12GetDebugInterfaceD3D12EnableExperimentalFeaturesID3D12ResourceD3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMITD3D12_CBUFFER_TYPED3D12_RESOURCE_RETURN_TYPED3D12_TESSELLATOR_DOMAIND3D12_TESSELLATOR_OUTPUT_PRIMITIVED3D12_TESSELLATOR_PARTITIONINGLPD3D12FUNCTIONPARAMETERREFLECTIONID3D12FunctionParameterReflectionLPD3D12FUNCTIONREFLECTIONID3D12FunctionReflectionLPD3D12LIBRARYREFLECTIONID3D12LibraryReflectionLPD3D12SHADERREFLECTIONID3D12ShaderReflectionLPD3D12SHADERREFLECTIONCONSTANTBUFFERID3D12ShaderReflectionConstantBufferLPD3D12SHADERREFLECTIONTYPEID3D12ShaderReflectionTypeLPD3D12SHADERREFLECTIONVARIABLEID3D12ShaderReflectionVariableD3D_SHADER_REQUIRES_INNER_COVERAGED3D_SHADER_REQUIRES_ROVSD3D_SHADER_REQUIRES_STENCIL_REFD3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATSD3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZERD3D10_PRIMITIVE_TOPOLOGY_UNDEFINEDD3D10_PRIMITIVE_TOPOLOGY_POINTLISTD3D10_PRIMITIVE_TOPOLOGY_LINELISTD3D10_PRIMITIVE_TOPOLOGY_LINESTRIPD3D10_PRIMITIVE_TOPOLOGY_TRIANGLELISTD3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIPD3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJD3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJD3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJD3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJD3D11_PRIMITIVE_TOPOLOGY_UNDEFINEDD3D11_PRIMITIVE_TOPOLOGY_POINTLISTD3D11_PRIMITIVE_TOPOLOGY_LINELISTD3D11_PRIMITIVE_TOPOLOGY_LINESTRIPD3D11_PRIMITIVE_TOPOLOGY_TRIANGLELISTD3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIPD3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJD3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJD3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJD3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJD3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLISTD3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLISTD3D10_PRIMITIVE_UNDEFINEDD3D10_PRIMITIVE_POINTD3D10_PRIMITIVE_LINED3D10_PRIMITIVE_TRIANGLED3D10_PRIMITIVE_LINE_ADJD3D10_PRIMITIVE_TRIANGLE_ADJD3D11_PRIMITIVE_UNDEFINEDD3D11_PRIMITIVE_POINTD3D11_PRIMITIVE_LINED3D11_PRIMITIVE_TRIANGLED3D11_PRIMITIVE_LINE_ADJD3D11_PRIMITIVE_TRIANGLE_ADJD3D11_PRIMITIVE_1_CONTROL_POINT_PATCHD3D11_PRIMITIVE_2_CONTROL_POINT_PATCHD3D11_PRIMITIVE_3_CONTROL_POINT_PATCHD3D11_PRIMITIVE_4_CONTROL_POINT_PATCHD3D11_PRIMITIVE_5_CONTROL_POINT_PATCHD3D11_PRIMITIVE_6_CONTROL_POINT_PATCHD3D11_PRIMITIVE_7_CONTROL_POINT_PATCHD3D11_PRIMITIVE_8_CONTROL_POINT_PATCHD3D11_PRIMITIVE_9_CONTROL_POINT_PATCHD3D11_PRIMITIVE_10_CONTROL_POINT_PATCHD3D11_PRIMITIVE_11_CONTROL_POINT_PATCHD3D11_PRIMITIVE_12_CONTROL_POINT_PATCHD3D11_PRIMITIVE_13_CONTROL_POINT_PATCHD3D11_PRIMITIVE_14_CONTROL_POINT_PATCHD3D11_PRIMITIVE_15_CONTROL_POINT_PATCHD3D11_PRIMITIVE_16_CONTROL_POINT_PATCHD3D11_PRIMITIVE_17_CONTROL_POINT_PATCHD3D11_PRIMITIVE_18_CONTROL_POINT_PATCHD3D11_PRIMITIVE_19_CONTROL_POINT_PATCHD3D11_PRIMITIVE_20_CONTROL_POINT_PATCHD3D11_PRIMITIVE_21_CONTROL_POINT_PATCHD3D11_PRIMITIVE_22_CONTROL_POINT_PATCHD3D11_PRIMITIVE_23_CONTROL_POINT_PATCHD3D11_PRIMITIVE_24_CONTROL_POINT_PATCHD3D11_PRIMITIVE_25_CONTROL_POINT_PATCHD3D11_PRIMITIVE_26_CONTROL_POINT_PATCHD3D11_PRIMITIVE_27_CONTROL_POINT_PATCHD3D11_PRIMITIVE_28_CONTROL_POINT_PATCHD3D11_PRIMITIVE_29_CONTROL_POINT_PATCHD3D11_PRIMITIVE_30_CONTROL_POINT_PATCHD3D11_PRIMITIVE_31_CONTROL_POINT_PATCHD3D11_PRIMITIVE_32_CONTROL_POINT_PATCHD3D10_SRV_DIMENSION_UNKNOWND3D10_SRV_DIMENSION_BUFFERD3D10_SRV_DIMENSION_TEXTURE1DD3D10_SRV_DIMENSION_TEXTURE1DARRAYD3D10_SRV_DIMENSION_TEXTURE2DD3D10_SRV_DIMENSION_TEXTURE2DARRAYD3D10_SRV_DIMENSION_TEXTURE2DMSD3D10_SRV_DIMENSION_TEXTURE2DMSARRAYD3D10_SRV_DIMENSION_TEXTURE3DD3D10_SRV_DIMENSION_TEXTURECUBED3D10_1_SRV_DIMENSION_UNKNOWND3D10_1_SRV_DIMENSION_BUFFERD3D10_1_SRV_DIMENSION_TEXTURE1DD3D10_1_SRV_DIMENSION_TEXTURE1DARRAYD3D10_1_SRV_DIMENSION_TEXTURE2DD3D10_1_SRV_DIMENSION_TEXTURE2DARRAYD3D10_1_SRV_DIMENSION_TEXTURE2DMSD3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAYD3D10_1_SRV_DIMENSION_TEXTURE3DD3D10_1_SRV_DIMENSION_TEXTURECUBED3D10_1_SRV_DIMENSION_TEXTURECUBEARRAYD3D11_SRV_DIMENSION_UNKNOWND3D11_SRV_DIMENSION_BUFFERD3D11_SRV_DIMENSION_TEXTURE1DD3D11_SRV_DIMENSION_TEXTURE1DARRAYD3D11_SRV_DIMENSION_TEXTURE2DD3D11_SRV_DIMENSION_TEXTURE2DARRAYD3D11_SRV_DIMENSION_TEXTURE2DMSD3D11_SRV_DIMENSION_TEXTURE2DMSARRAYD3D11_SRV_DIMENSION_TEXTURE3DD3D11_SRV_DIMENSION_TEXTURECUBED3D11_SRV_DIMENSION_TEXTURECUBEARRAYD3D11_SRV_DIMENSION_BUFFEREXLPD3D_SHADER_MACROLPD3D10BLOBID3D10BlobLPD3DBLOBD3D10_INCLUDE_LOCALD3D10_INCLUDE_SYSTEMLPD3DINCLUDED3D10_SVC_SCALARD3D10_SVC_VECTORD3D10_SVC_MATRIX_ROWSD3D10_SVC_MATRIX_COLUMNSD3D10_SVC_OBJECTD3D10_SVC_STRUCTD3D11_SVC_INTERFACE_CLASSD3D11_SVC_INTERFACE_POINTERD3D10_SVF_USERPACKEDD3D10_SVF_USEDD3D11_SVF_INTERFACE_POINTERD3D11_SVF_INTERFACE_PARAMETERD3D10_SVT_VOIDD3D10_SVT_BOOLD3D10_SVT_INTD3D10_SVT_FLOATD3D10_SVT_STRINGD3D10_SVT_TEXTURED3D10_SVT_TEXTURE1DD3D10_SVT_TEXTURE2DD3D10_SVT_TEXTURE3DD3D10_SVT_TEXTURECUBED3D10_SVT_SAMPLERD3D10_SVT_SAMPLER1DD3D10_SVT_SAMPLER2DD3D10_SVT_SAMPLER3DD3D10_SVT_SAMPLERCUBED3D10_SVT_PIXELSHADERD3D10_SVT_VERTEXSHADERD3D10_SVT_PIXELFRAGMENTD3D10_SVT_VERTEXFRAGMENTD3D10_SVT_UINTD3D10_SVT_UINT8D3D10_SVT_GEOMETRYSHADERD3D10_SVT_RASTERIZERD3D10_SVT_DEPTHSTENCILD3D10_SVT_BLENDD3D10_SVT_BUFFERD3D10_SVT_CBUFFERD3D10_SVT_TBUFFERD3D10_SVT_TEXTURE1DARRAYD3D10_SVT_TEXTURE2DARRAYD3D10_SVT_RENDERTARGETVIEWD3D10_SVT_DEPTHSTENCILVIEWD3D10_SVT_TEXTURE2DMSD3D10_SVT_TEXTURE2DMSARRAYD3D10_SVT_TEXTURECUBEARRAYD3D11_SVT_HULLSHADERD3D11_SVT_DOMAINSHADERD3D11_SVT_INTERFACE_POINTERD3D11_SVT_COMPUTESHADERD3D11_SVT_DOUBLED3D11_SVT_RWTEXTURE1DD3D11_SVT_RWTEXTURE1DARRAYD3D11_SVT_RWTEXTURE2DD3D11_SVT_RWTEXTURE2DARRAYD3D11_SVT_RWTEXTURE3DD3D11_SVT_RWBUFFERD3D11_SVT_BYTEADDRESS_BUFFERD3D11_SVT_RWBYTEADDRESS_BUFFERD3D11_SVT_STRUCTURED_BUFFERD3D11_SVT_RWSTRUCTURED_BUFFERD3D11_SVT_APPEND_STRUCTURED_BUFFERD3D11_SVT_CONSUME_STRUCTURED_BUFFERD3D10_SIF_USERPACKEDD3D10_SIF_COMPARISON_SAMPLERD3D10_SIF_TEXTURE_COMPONENT_0D3D10_SIF_TEXTURE_COMPONENT_1D3D10_SIF_TEXTURE_COMPONENTSD3D10_SIT_CBUFFERD3D10_SIT_TBUFFERD3D10_SIT_TEXTURED3D10_SIT_SAMPLERD3D11_SIT_UAV_RWTYPEDD3D11_SIT_STRUCTUREDD3D11_SIT_UAV_RWSTRUCTUREDD3D11_SIT_BYTEADDRESSD3D11_SIT_UAV_RWBYTEADDRESSD3D11_SIT_UAV_APPEND_STRUCTUREDD3D11_SIT_UAV_CONSUME_STRUCTUREDD3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTERD3D10_CBF_USERPACKEDD3D10_CT_CBUFFERD3D10_CT_TBUFFERD3D11_CT_CBUFFERD3D11_CT_TBUFFERD3D11_CT_INTERFACE_POINTERSD3D11_CT_RESOURCE_BIND_INFOD3D10_NAME_UNDEFINEDD3D10_NAME_POSITIOND3D10_NAME_CLIP_DISTANCED3D10_NAME_CULL_DISTANCED3D10_NAME_RENDER_TARGET_ARRAY_INDEXD3D10_NAME_VIEWPORT_ARRAY_INDEXD3D10_NAME_VERTEX_IDD3D10_NAME_PRIMITIVE_IDD3D10_NAME_INSTANCE_IDD3D10_NAME_IS_FRONT_FACED3D10_NAME_SAMPLE_INDEXD3D10_NAME_TARGETD3D10_NAME_DEPTHD3D10_NAME_COVERAGED3D11_NAME_FINAL_QUAD_EDGE_TESSFACTORD3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTORD3D11_NAME_FINAL_TRI_EDGE_TESSFACTORD3D11_NAME_FINAL_TRI_INSIDE_TESSFACTORD3D11_NAME_FINAL_LINE_DETAIL_TESSFACTORD3D11_NAME_FINAL_LINE_DENSITY_TESSFACTORD3D11_NAME_DEPTH_GREATER_EQUALD3D11_NAME_DEPTH_LESS_EQUALD3D10_RETURN_TYPE_UNORMD3D10_RETURN_TYPE_SNORMD3D10_RETURN_TYPE_SINTD3D10_RETURN_TYPE_UINTD3D10_RETURN_TYPE_FLOATD3D10_RETURN_TYPE_MIXEDD3D11_RETURN_TYPE_UNORMD3D11_RETURN_TYPE_SNORMD3D11_RETURN_TYPE_SINTD3D11_RETURN_TYPE_UINTD3D11_RETURN_TYPE_FLOATD3D11_RETURN_TYPE_MIXEDD3D11_RETURN_TYPE_DOUBLED3D11_RETURN_TYPE_CONTINUEDD3D10_REGISTER_COMPONENT_UNKNOWND3D10_REGISTER_COMPONENT_UINT32D3D10_REGISTER_COMPONENT_SINT32D3D10_REGISTER_COMPONENT_FLOAT32D3D11_TESSELLATOR_DOMAIN_UNDEFINEDD3D11_TESSELLATOR_DOMAIN_ISOLINED3D11_TESSELLATOR_DOMAIN_TRID3D11_TESSELLATOR_DOMAIN_QUADD3D11_TESSELLATOR_PARTITIONING_UNDEFINEDD3D11_TESSELLATOR_PARTITIONING_INTEGERD3D11_TESSELLATOR_PARTITIONING_POW2D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODDD3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEND3D11_TESSELLATOR_OUTPUT_UNDEFINEDD3D11_TESSELLATOR_OUTPUT_POINTD3D11_TESSELLATOR_OUTPUT_LINED3D11_TESSELLATOR_OUTPUT_TRIANGLE_CWD3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW//! Mappings for the contents of d3dcommon.hd3d11shaderID3D11FunctionLinkingGraphID3D11LinkerID3D11ModuleD3DCOMPILER_DLLD3D_COMPILER_VERSIOND3DReadFileToBlobD3DWriteBlobToFileD3DCOMPILE_DEBUGD3DCOMPILE_SKIP_VALIDATIOND3DCOMPILE_SKIP_OPTIMIZATIOND3DCOMPILE_PACK_MATRIX_ROW_MAJORD3DCOMPILE_PACK_MATRIX_COLUMN_MAJORD3DCOMPILE_PARTIAL_PRECISIOND3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPTD3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPTD3DCOMPILE_NO_PRESHADERD3DCOMPILE_AVOID_FLOW_CONTROLD3DCOMPILE_PREFER_FLOW_CONTROLD3DCOMPILE_ENABLE_STRICTNESSD3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITYD3DCOMPILE_IEEE_STRICTNESSD3DCOMPILE_OPTIMIZATION_LEVEL0D3DCOMPILE_OPTIMIZATION_LEVEL1D3DCOMPILE_OPTIMIZATION_LEVEL2D3DCOMPILE_OPTIMIZATION_LEVEL3D3DCOMPILE_RESERVED16D3DCOMPILE_RESERVED17D3DCOMPILE_WARNINGS_ARE_ERRORSD3DCOMPILE_RESOURCES_MAY_ALIASD3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLESD3DCOMPILE_ALL_RESOURCES_BOUNDD3DCOMPILE_EFFECT_CHILD_EFFECTD3DCOMPILE_EFFECT_ALLOW_SLOW_OPSD3D_COMPILE_STANDARD_FILE_INCLUDED3DCompileD3DCOMPILE_SECDATA_MERGE_UAV_SLOTSD3DCOMPILE_SECDATA_PRESERVE_TEMPLATE_SLOTSD3DCOMPILE_SECDATA_REQUIRE_TEMPLATE_MATCHD3DCompile2D3DCompileFromFileD3DPreprocessD3DGetDebugInfoD3DReflectD3DReflectLibraryD3D_DISASM_ENABLE_COLOR_CODED3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTSD3D_DISASM_ENABLE_INSTRUCTION_NUMBERINGD3D_DISASM_ENABLE_INSTRUCTION_CYCLED3D_DISASM_DISABLE_DEBUG_INFOD3D_DISASM_ENABLE_INSTRUCTION_OFFSETD3D_DISASM_INSTRUCTION_ONLYD3D_DISASM_PRINT_HEX_LITERALSD3DDisassembleD3DDisassembleRegionD3DCreateLinkerD3DLoadModuleD3DCreateFunctionLinkingGraphD3D_GET_INST_OFFSETS_INCLUDE_NON_EXECUTABLED3DGetTraceInstructionOffsetsD3DGetInputSignatureBlobD3DGetOutputSignatureBlobD3DGetInputAndOutputSignatureBlobD3DStripShaderD3DGetBlobPartD3D_BLOB_PARTD3DSetBlobPartD3DCreateBlobD3DCompressShadersD3D_SHADER_DATAD3DDecompressShaders// pub fn D3DDisassemble10Effect(//     pEffect: *mut ID3D10Effect,//     Flags: UINT,//     ppDisassembly: *mut *mut ID3DBlob,// ) -> HRESULT;GetDateFormatAGetDateFormatWGetTimeFormatAGetTimeFormatWGetTimeFormatExGetDateFormatExOPAQUE_HANDLEPDAV_CALLBACK_AUTH_BLOBDAV_CALLBACK_AUTH_BLOBPDAV_CALLBACK_AUTH_UNPDAV_CALLBACK_AUTH_UNPPDAV_CALLBACK_CREDDAV_CALLBACK_CREDDAV_AUTHN_SCHEME_BASICDAV_AUTHN_SCHEME_NTLMDAV_AUTHN_SCHEME_PASSPORTDAV_AUTHN_SCHEME_DIGESTDAV_AUTHN_SCHEME_NEGOTIATEDAV_AUTHN_SCHEME_CERTDAV_AUTHN_SCHEME_FBADavAddConnectionDavDeleteConnectionDavGetUNCFromHTTPPathDavGetHTTPFromUNCPathDavGetTheLockOwnerOfTheFileDavGetExtendedErrorDavFlushFileDavInvalidateCacheDavCancelConnectionsToServerDavRegisterAuthCallbackPFNDAVAUTHCALLBACKDavUnregisterAuthCallback//! This module defines the DAV specific functions that are exposed to the userPIMAGE_NT_HEADERSPIMAGE_SECTION_HEADERPFPO_DATAPIMAGE_COFF_SYMBOLS_HEADERPIMAGE_DEBUG_DIRECTORYPIMAGE_FUNCTION_ENTRYPIMAGE_NT_HEADERS32PIMAGE_NT_HEADERS64MAX_SYM_NAMEERROR_IMAGE_NOT_STRIPPEDERROR_NO_DBG_POINTERERROR_NO_PDB_POINTERPIMAGE_DEBUG_INFORMATIONIMAGE_DEBUG_INFORMATIONUNDNAME_COMPLETEUNDNAME_NO_LEADING_UNDERSCORESUNDNAME_NO_MS_KEYWORDSUNDNAME_NO_FUNCTION_RETURNSUNDNAME_NO_ALLOCATION_MODELUNDNAME_NO_ALLOCATION_LANGUAGEUNDNAME_NO_MS_THISTYPEUNDNAME_NO_CV_THISTYPEUNDNAME_NO_THISTYPEUNDNAME_NO_ACCESS_SPECIFIERSUNDNAME_NO_THROW_SIGNATURESUNDNAME_NO_MEMBER_TYPEUNDNAME_NO_RETURN_UDT_MODELUNDNAME_32_BIT_DECODEUNDNAME_NAME_ONLYUNDNAME_NO_ARGUMENTSUNDNAME_NO_SPECIAL_SYMSDBHHEADER_DEBUGDIRSDBHHEADER_CVMISCDBHHEADER_PDBGUIDPMODLOAD_DATAMODLOAD_DATAPMODLOAD_CVMISCMODLOAD_CVMISCPMODLOAD_PDBGUID_PDBAGEMODLOAD_PDBGUID_PDBAGELPADDRESS64ADDRESSLPADDRESSPKDHELP64KDHELP64KDHELPPKDHELPLPSTACKFRAME64INLINE_FRAME_CONTEXT_INITINLINE_FRAME_CONTEXT_IGNORELPSTACKFRAME_EXSTACKFRAMELPSTACKFRAMESYM_STKWALK_DEFAULTSYM_STKWALK_FORCE_FRAMEPTRPREAD_PROCESS_MEMORY_ROUTINEPREAD_PROCESS_MEMORY_ROUTINE64PFUNCTION_TABLE_ACCESS_ROUTINEPFUNCTION_TABLE_ACCESS_ROUTINE64PGET_MODULE_BASE_ROUTINEPGET_MODULE_BASE_ROUTINE64PTRANSLATE_ADDRESS_ROUTINEPTRANSLATE_ADDRESS_ROUTINE64API_VERSION_NUMBERLPAPI_VERSIONPIMAGEHLP_SYMBOL64IMAGEHLP_SYMBOL64PIMAGEHLP_MODULEW64IMAGEHLP_MODULEW64EnumDirTreePENUMDIRTREE_CALLBACKEnumDirTreeWPENUMDIRTREE_CALLBACKWImagehlpApiVersionImagehlpApiVersionExMakeSureDirectoryPathExistsSearchTreeForFileSearchTreeForFileWFindDebugInfoFileFindDebugInfoFileExPFIND_DEBUG_FILE_CALLBACKFindDebugInfoFileExWPFIND_DEBUG_FILE_CALLBACKWFindExecutableImageFindExecutableImageExPFIND_EXE_FILE_CALLBACKFindExecutableImageExWPFIND_EXE_FILE_CALLBACKWStackWalkUnDecorateSymbolNameUnDecorateSymbolNameWGetTimestampForLoadedLibraryImageDirectoryEntryToDataImageDirectoryEntryToDataExImageNtHeaderImageRvaToSectionImageRvaToVaSYMOPT_CASE_INSENSITIVESYMOPT_UNDNAMESYMOPT_NO_CPPSYMOPT_LOAD_LINESSYMOPT_OMAP_FIND_NEARESTSYMOPT_LOAD_ANYTHINGSYMOPT_IGNORE_CVRECSYMOPT_NO_UNQUALIFIED_LOADSSYMOPT_FAIL_CRITICAL_ERRORSSYMOPT_EXACT_SYMBOLSSYMOPT_ALLOW_ABSOLUTE_SYMBOLSSYMOPT_IGNORE_NT_SYMPATHSYMOPT_INCLUDE_32BIT_MODULESSYMOPT_PUBLICS_ONLYSYMOPT_NO_PUBLICSSYMOPT_AUTO_PUBLICSSYMOPT_NO_IMAGE_SEARCHSYMOPT_SECURESYMOPT_NO_PROMPTSSYMOPT_OVERWRITESYMOPT_IGNORE_IMAGEDIRSYMOPT_FLAT_DIRECTORYSYMOPT_FAVOR_COMPRESSEDSYMOPT_ALLOW_ZERO_ADDRESSSYMOPT_DISABLE_SYMSRV_AUTODETECTSYMOPT_READONLY_CACHESYMOPT_SYMPATH_LASTSYMOPT_DISABLE_FAST_SYMBOLSSYMOPT_DISABLE_SYMSRV_TIMEOUTSYMOPT_DISABLE_SRVSTAR_ON_STARTUPSYMOPT_DEBUGSymEnumSymbolsWPSYM_ENUMERATESYMBOLS_CALLBACKWSymFindDebugInfoFileSymFindDebugInfoFileWSymFindExecutableImageSymFindExecutableImageWSymFindFileInPathPFINDFILEINPATHCALLBACKSymFindFileInPathWPFINDFILEINPATHCALLBACKWSymFromNameWSymGetModuleInfoW64SymGetSymFromAddr64SymLoadModuleExWSymUnloadModuleSymUnloadModule64MapDebugInformationUnmapDebugInformation//! DbgHelp include fileHDEVNOTIFYWM_DEVICECHANGEBSF_QUERYBSF_IGNORECURRENTTASKBSF_FLUSHDISKBSF_NOHANGBSF_POSTMESSAGEBSF_FORCEIFHUNGBSF_NOTIMEOUTIFNOTHUNGBSF_MSGSRV32ISOKBSF_MSGSRV32ISOK_BITBSM_ALLCOMPONENTSBSM_VXDSBSM_NETDRIVERBSM_INSTALLABLEDRIVERSBSM_APPLICATIONSDBT_APPYBEGINDBT_APPYENDDBT_DEVNODES_CHANGEDDBT_QUERYCHANGECONFIGDBT_CONFIGCHANGEDDBT_CONFIGCHANGECANCELEDDBT_MONITORCHANGEDBT_SHELLLOGGEDONDBT_CONFIGMGAPI32DBT_VXDINITCOMPLETEDBT_VOLLOCKQUERYLOCKDBT_VOLLOCKLOCKTAKENDBT_VOLLOCKLOCKFAILEDDBT_VOLLOCKQUERYUNLOCKDBT_VOLLOCKLOCKRELEASEDDBT_VOLLOCKUNLOCKFAILEDPDEV_BROADCAST_HDRDEV_BROADCAST_HDRpVolLockBroadcastVolLockBroadcastLOCKP_ALLOW_WRITESLOCKP_FAIL_WRITESLOCKP_FAIL_MEM_MAPPINGLOCKP_ALLOW_MEM_MAPPINGLOCKP_USER_MASKLOCKP_LOCK_FOR_FORMATLOCKF_LOGICAL_LOCKLOCKF_PHYSICAL_LOCKDBT_NO_DISK_SPACEDBT_LOW_DISK_SPACEDBT_CONFIGMGPRIVATEDBT_DEVICEARRIVALDBT_DEVICEQUERYREMOVEDBT_DEVICEQUERYREMOVEFAILEDDBT_DEVICEREMOVEPENDINGDBT_DEVICEREMOVECOMPLETEDBT_DEVICETYPESPECIFICDBT_CUSTOMEVENTDBT_DEVTYP_OEMDBT_DEVTYP_DEVNODEDBT_DEVTYP_VOLUMEDBT_DEVTYP_PORTDBT_DEVTYP_NETDBT_DEVTYP_DEVICEINTERFACEDBT_DEVTYP_HANDLEPDEV_BROADCAST_OEMDEV_BROADCAST_OEMPDEV_BROADCAST_DEVNODEDEV_BROADCAST_DEVNODEPDEV_BROADCAST_VOLUMEDEV_BROADCAST_VOLUMEDBTF_MEDIADBTF_NETPDEV_BROADCAST_PORT_ADEV_BROADCAST_PORT_APDEV_BROADCAST_PORT_WDEV_BROADCAST_PORT_WPDEV_BROADCAST_NETDEV_BROADCAST_NETPDEV_BROADCAST_DEVICEINTERFACE_ADEV_BROADCAST_DEVICEINTERFACE_APDEV_BROADCAST_DEVICEINTERFACE_WDEV_BROADCAST_DEVICEINTERFACE_WPDEV_BROADCAST_HANDLEDEV_BROADCAST_HANDLEPDEV_BROADCAST_HANDLE32DEV_BROADCAST_HANDLE32PDEV_BROADCAST_HANDLE64DEV_BROADCAST_HANDLE64DBTF_RESOURCEDBTF_XPORTDBTF_SLOWNETDBT_VPOWERDAPIDBT_USERDEFINED//! Mappings for the contents of dcommon.hDCOMPOSITION_BACKFACE_VISIBILITYDCOMPOSITION_BITMAP_INTERPOLATION_MODEDCOMPOSITION_BORDER_MODEDCOMPOSITION_COMPOSITE_MODEDCOMPOSITION_DEPTH_MODEDCOMPOSITION_FRAME_STATISTICSDCOMPOSITION_OPACITY_MODEDXGI_ALPHA_MODED2D1_COMPOSITE_MODED2D1_2DAFFINETRANSFORM_INTERPOLATION_MODED2D1_BORDER_MODED2D1_COLORMATRIX_ALPHA_MODED2D1_TURBULENCE_NOISEdcompanimationIDCompositionAnimationDCompositionCreateDeviceDCompositionCreateDevice2DCompositionCreateDevice3DCompositionGetFrameStatisticsDCompositionCreateSurfaceHandleDCompositionAttachMouseWheelToHwndIDCompositionVisualDCompositionAttachMouseDragToHwnd//! Mappings for the contents of dcomp.h//! Mappings for the contents of dcompanimation.hPackDDElParamUnpackDDElParamLPDEBUG_EVENTIsDebuggerPresentDebugBreakOutputDebugStringAOutputDebugStringWContinueDebugEventWaitForDebugEventDebugActiveProcessDebugActiveProcessStopCheckRemoteDebuggerPresentWaitForDebugEventExPKSDATAFORMATKSDATAFORMATKSPROPERTYKSIDENTIFIERPKSPROPERTYKSMETHODPKSMETHODKSEVENTPKSEVENTPKSJACK_DESCRIPTIONKSJACK_DESCRIPTIONPKSJACK_DESCRIPTION2KSJACK_DESCRIPTION2//! The DeviceTopology API gives clients control over a variety of internal functions of audio//! adapters that they cannot access through the MMDevice API, WASAPI, or the EndpointVolume API.DISPIDDISPID_UNKNOWNDISPPARAMSEXCEPINFOservprovIServiceProviderfdexNameCaseSensitive// pub const SID_GetScriptSite = IID_IActiveScriptSite;fdexNameEnsurefdexNameImplicitfdexNameCaseInsensitivefdexNameInternalfdexNameNoDynamicPropertiesfdexPropCanGetfdexPropCannotGetfdexPropCanPutfdexPropCannotPutfdexPropCanPutReffdexPropCannotPutReffdexPropNoSideEffectsfdexPropDynamicTypefdexPropCanCallfdexPropCannotCallfdexPropCanConstructfdexPropCannotConstructfdexPropCanSourceEventsfdexPropCannotSourceEventsgrfdexPropCanAllgrfdexPropCannotAllgrfdexPropExtraAllgrfdexPropAllfdexEnumDefaultfdexEnumAllDISPATCH_CONSTRUCTDISPID_THISDISPID_STARTENUM// extern RPC_IF_HANDLE __MIDL_itf_dispex_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_dispex_0000_0000_v0_0_s_ifspec;// EXTERN_C const IID IID_IDispatchEx;// HRESULT STDMETHODCALLTYPE IDispatchEx_RemoteInvokeEx_Proxy(//     IDispatchEx * This,//     DISPID id,//     LCID lcid,//     DWORD dwFlags,//     DISPPARAMS *pdp,//     VARIANT *pvarRes,//     EXCEPINFO *pei,//     IServiceProvider *pspCaller,//     UINT cvarRefArg,//     UINT *rgiRefArg,//     VARIANT *rgvarRefArg);// void __RPC_STUB IDispatchEx_RemoteInvokeEx_Stub(//     IRpcStubBuffer *This,//     IRpcChannelBuffer *_pRpcChannelBuffer,//     PRPC_MESSAGE _pRpcMessage,//     DWORD *_pdwStubPhase);// EXTERN_C const IID IID_IDispError;// EXTERN_C const IID IID_IVariantChangeType;// EXTERN_C const IID IID_IObjectIdentity;// EXTERN_C const IID IID_ICanHandleException;// EXTERN_C const IID IID_IProvideRuntimeContext;// extern RPC_IF_HANDLE __MIDL_itf_dispex_0000_0006_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_dispex_0000_0006_v0_0_s_ifspec;// unsigned long __RPC_USER BSTR_UserSize( __RPC__in unsigned long *, unsigned long, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void __RPC_USER BSTR_UserFree( __RPC__in unsigned long *, __RPC__in BSTR * );// unsigned long __RPC_USER VARIANT_UserSize( __RPC__in unsigned long *, unsigned long, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out VARIANT * );// void __RPC_USER VARIANT_UserFree( __RPC__in unsigned long *, __RPC__in VARIANT * );// unsigned long __RPC_USER BSTR_UserSize64( __RPC__in unsigned long *, unsigned long, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void __RPC_USER BSTR_UserFree64( __RPC__in unsigned long *, __RPC__in BSTR * );// unsigned long __RPC_USER VARIANT_UserSize64( __RPC__in unsigned long *, unsigned long, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out VARIANT * );// void __RPC_USER VARIANT_UserFree64( __RPC__in unsigned long *, __RPC__in VARIANT * );// HRESULT STDMETHODCALLTYPE IDispatchEx_InvokeEx_Proxy(//     WORD wFlags,//     IServiceProvider *pspCaller);// HRESULT STDMETHODCALLTYPE IDispatchEx_InvokeEx_Stub(// TODO:It is a minimal implementation.eaptypesEAP_METHOD_TYPEl2cmnL2_REASON_CODE_ONEX_BASEPONEX_AUTH_IDENTITYONEX_AUTH_IDENTITYPONEX_AUTH_STATUSONEX_AUTH_STATUSPONEX_REASON_CODEONEX_REASON_CODEPONEX_NOTIFICATION_TYPEONEX_NOTIFICATION_TYPEPONEX_AUTH_RESTART_REASONONEX_AUTH_RESTART_REASONPONEX_VARIABLE_BLOBONEX_VARIABLE_BLOBPONEX_AUTH_PARAMSONEX_AUTH_PARAMSPONEX_EAP_ERRORONEX_EAP_ERRORPONEX_STATUSONEX_STATUSPONEX_RESULT_UPDATE_DATAONEX_RESULT_UPDATE_DATAPONEX_USER_INFOONEX_USER_INFODA_LASTDA_ERRHDSADSA_CreateDSA_DestroyDSA_DestroyCallbackPFNDAENUMCALLBACKDSA_DeleteItemDSA_DeleteAllItemsDSA_EnumCallbackDSA_InsertItemDSA_GetItemPtrDSA_GetItemDSA_SetItemDSA_GetItemCountDSA_AppendItemDSA_CloneDSA_GetSizeDSA_SortPFNDACOMPAREDSA_APPENDDSA_ERRPFNDSAENUMCALLBACKPFNDSAENUMCALLBACKCONSTPFNDAENUMCALLBACKCONSTPFNDSACOMPAREPFNDSACOMPARECONSTPFNDACOMPARECONSTDPAHDPADPA_CreateDPA_CreateExDPA_CloneDPA_DestroyDPA_DestroyCallbackDPA_DeletePtrDPA_DeleteAllPtrsDPA_EnumCallbackDPA_GrowDPA_InsertPtrDPA_SetPtrDPA_GetPtrDPA_GetPtrIndexDPA_GetPtrCountDPA_SetPtrCountDPA_FastDeleteLastPtrDPA_AppendPtrDPA_GetSizeDPA_SortDPA_LoadStreamPFNDPASTREAMDPA_SaveStreamDPAM_SORTEDDPAM_NORMALDPAM_UNIONDPAM_INTERSECTDPAMM_MERGEDPAMM_DELETEDPAMM_INSERTDPA_MergePFNDPAMERGEDPAS_SORTEDDPAS_INSERTBEFOREDPAS_INSERTAFTERDPA_SearchDPA_SortedInsertPtrDPA_APPENDDPA_ERRPFNDPAENUMCALLBACKPFNDPAENUMCALLBACKCONSTPFNDPACOMPAREPFNDPACOMPARECONSTStr_SetPtrWwincryptDATA_BLOBszFORCE_KEY_PROTECTIONdwFORCE_KEY_PROTECTION_DISABLEDdwFORCE_KEY_PROTECTION_USER_SELECTdwFORCE_KEY_PROTECTION_HIGHPCRYPTPROTECT_PROMPTSTRUCTCRYPTPROTECT_PROMPTSTRUCTCRYPTPROTECT_PROMPT_ON_UNPROTECTCRYPTPROTECT_PROMPT_ON_PROTECTCRYPTPROTECT_PROMPT_RESERVEDCRYPTPROTECT_PROMPT_STRONGCRYPTPROTECT_PROMPT_REQUIRE_STRONGCRYPTPROTECT_UI_FORBIDDENCRYPTPROTECT_LOCAL_MACHINECRYPTPROTECT_CRED_SYNCCRYPTPROTECT_AUDITCRYPTPROTECT_NO_RECOVERYCRYPTPROTECT_VERIFY_PROTECTIONCRYPTPROTECT_CRED_REGENERATECRYPTPROTECT_FIRST_RESERVED_FLAGVALCRYPTPROTECT_LAST_RESERVED_FLAGVALCryptProtectDataCryptUnprotectDataCryptProtectDataNoUICryptUnprotectDataNoUICryptUpdateProtectedStateCRYPTPROTECTMEMORY_BLOCK_SIZECRYPTPROTECTMEMORY_SAME_PROCESSCRYPTPROTECTMEMORY_CROSS_PROCESSCRYPTPROTECTMEMORY_SAME_LOGONCryptProtectMemoryCryptUnprotectMemory//! Data Protection API Prototypes and DefinitionsPLSA_FOREST_TRUST_INFORMATIONDS_FORCE_REDISCOVERYDS_DIRECTORY_SERVICE_REQUIREDDS_DIRECTORY_SERVICE_PREFERREDDS_GC_SERVER_REQUIREDDS_PDC_REQUIREDDS_BACKGROUND_ONLYDS_IP_REQUIREDDS_KDC_REQUIREDDS_TIMESERV_REQUIREDDS_WRITABLE_REQUIREDDS_GOOD_TIMESERV_PREFERREDDS_AVOID_SELFDS_ONLY_LDAP_NEEDEDDS_IS_FLAT_NAMEDS_IS_DNS_NAMEDS_TRY_NEXTCLOSEST_SITEDS_DIRECTORY_SERVICE_6_REQUIREDDS_WEB_SERVICE_REQUIREDDS_DIRECTORY_SERVICE_8_REQUIREDDS_DIRECTORY_SERVICE_9_REQUIREDDS_DIRECTORY_SERVICE_10_REQUIREDDS_RETURN_DNS_NAMEDS_RETURN_FLAT_NAMEDSGETDC_VALID_FLAGSPDOMAIN_CONTROLLER_INFOADOMAIN_CONTROLLER_INFOAPDOMAIN_CONTROLLER_INFOWDOMAIN_CONTROLLER_INFOWDS_INET_ADDRESSDS_NETBIOS_ADDRESSDS_PDC_FLAGDS_GC_FLAGDS_LDAP_FLAGDS_DS_FLAGDS_KDC_FLAGDS_TIMESERV_FLAGDS_CLOSEST_FLAGDS_WRITABLE_FLAGDS_GOOD_TIMESERV_FLAGDS_NDNC_FLAGDS_SELECT_SECRET_DOMAIN_6_FLAGDS_FULL_SECRET_DOMAIN_6_FLAGDS_WS_FLAGDS_DS_8_FLAGDS_DS_9_FLAGDS_DS_10_FLAGDS_PING_FLAGSDS_DNS_CONTROLLER_FLAGDS_DNS_DOMAIN_FLAGDS_DNS_FOREST_FLAGDsGetDcNameADsGetDcNameWDsGetSiteNameADsGetSiteNameWDsValidateSubnetNameWDsValidateSubnetNameADsAddressToSiteNamesWDsAddressToSiteNamesADsAddressToSiteNamesExWDsAddressToSiteNamesExADS_DOMAIN_IN_FORESTDS_DOMAIN_DIRECT_OUTBOUNDDS_DOMAIN_TREE_ROOTDS_DOMAIN_PRIMARYDS_DOMAIN_NATIVE_MODEDS_DOMAIN_DIRECT_INBOUNDDS_DOMAIN_VALID_FLAGSPDS_DOMAIN_TRUSTSWDS_DOMAIN_TRUSTSWPDS_DOMAIN_TRUSTSADS_DOMAIN_TRUSTSADsEnumerateDomainTrustsWDsEnumerateDomainTrustsADsGetForestTrustInformationWDsMergeForestTrustInformationWDsGetDcSiteCoverageWDsGetDcSiteCoverageADsDeregisterDnsHostRecordsWDsDeregisterDnsHostRecordsADS_ONLY_DO_SITE_NAMEDS_NOTIFY_AFTER_SITE_RECORDSDS_OPEN_VALID_OPTION_FLAGSDS_OPEN_VALID_FLAGSDsGetDcOpenWDsGetDcOpenADsGetDcNextADsGetDcNextWDsGetDcCloseW//! This file contains structures, function prototypes, and definitions for the DsGetDcName API.mmsystemLPCWAVEFORMATEXLPWAVEFORMATEXLPDSCAPSDSCAPSLPDSBCAPSDSBCAPSLPCDSBUFFERDESCDSBUFFERDESCLPDIRECTSOUNDBUFFERIDirectSoundBufferLPDIRECTSOUNDIDirectSoundDS_OKDSERR_GENERICDSSCL_NORMALDSSCL_PRIORITYDSSCL_EXCLUSIVEDSSCL_WRITEPRIMARYDSBCAPS_PRIMARYBUFFERDSBCAPS_STATICDSBCAPS_LOCHARDWAREDSBCAPS_LOCSOFTWAREDSBCAPS_CTRL3DDSBCAPS_CTRLFREQUENCYDSBCAPS_CTRLPANDSBCAPS_CTRLVOLUMEDSBCAPS_CTRLPOSITIONNOTIFYDSBCAPS_CTRLFXDSBCAPS_STICKYFOCUSDSBCAPS_GLOBALFOCUSDSBCAPS_GETCURRENTPOSITION2DSBCAPS_MUTE3DATMAXDISTANCEDSBCAPS_LOCDEFERDSBCAPS_TRUEPLAYPOSITIONDSBPLAY_LOOPINGDSBPLAY_LOCHARDWAREDSBPLAY_LOCSOFTWAREDSBPLAY_TERMINATEBY_TIMEDSBPLAY_TERMINATEBY_DISTANCEDSBPLAY_TERMINATEBY_PRIORITYDirectSoundCreateGetDeviceID// pub fn DirectSoundEnumerateA(//     pDSEnumCallback: LPDSENUMCALLBACKA,//     pContext: LPVOID,// pub fn DirectSoundEnumerateW(//     pDSEnumCallback: LPDSENUMCALLBACKW,// pub fn DirectSoundCaptureCreate(//     pcGuidDevice: LPCGUID,//     ppDSC: *mut LPDIRECTSOUNDCAPTURE,//     pUnkOuter: LPUNKNOWN,// pub fn DirectSoundCaptureEnumerateA(// pub fn DirectSoundCaptureEnumerateW(// pub fn DirectSoundCreate8(//     ppDS8: *mut LPDIRECTSOUND8,// pub fn DirectSoundCaptureCreate8(//     ppDSC8: *mut LPDIRECTSOUNDCAPTURE8,// pub fn DirectSoundFullDuplexCreate(//     pcGuidCaptureDevice: LPCGUID,//     pcGuidRenderDevice: LPCGUID,//     pcDSCBufferDesc: LPCDSCBUFFERDESC,//     pcDSBufferDesc: LPCDSBUFFERDESC,//     hWnd: HWND,//     dwLevel: DWORD,//     ppDSFD: *mut LPDIRECTSOUNDFULLDUPLEX,//     ppDSCBuffer8: *mut LPDIRECTSOUNDCAPTUREBUFFER8,//     ppDSBuffer8: *mut LPDIRECTSOUNDBUFFER8,//! DSound procedure declarations, constant definitions and macrosPDSROLE_SERVER_STATEDSROLE_SERVER_STATEDSROLE_PRIMARY_DS_RUNNINGDSROLE_PRIMARY_DS_MIXED_MODEDSROLE_UPGRADE_IN_PROGRESSDSROLE_PRIMARY_DS_READONLYDSROLE_PRIMARY_DOMAIN_GUID_PRESENTPDSROLE_PRIMARY_DOMAIN_INFO_BASICDSROLE_PRIMARY_DOMAIN_INFO_BASICPDSROLE_UPGRADE_STATUS_INFODSROLE_UPGRADE_STATUS_INFOPDSROLE_OPERATION_STATE_INFODSROLE_OPERATION_STATE_INFODsRoleGetPrimaryDomainInformationDSROLE_PRIMARY_DOMAIN_INFO_LEVELDsRoleFreeMemory//! Contains public interfaces to query the network roles of workstations, servers, and DCsuxthemeMARGINSDWM_BB_TRANSITIONONMAXIMIZEDDWM_CLOAKED_APPDWM_CLOAKED_SHELLDWM_CLOAKED_INHERITEDHTHUMBNAILPHTHUMBNAILDWM_TNP_RECTDESTINATIONDWM_TNP_RECTSOURCEDWM_TNP_OPACITYDWM_TNP_VISIBLEDWM_TNP_SOURCECLIENTAREAONLYPDWM_THUMBNAIL_PROPERTIESDWM_THUMBNAIL_PROPERTIESDWM_FRAME_COUNTQPC_TIME// pub const c_DwmMaxQueuedBuffers: UINT = 8;// pub const c_DwmMaxMonitors: UINT = 16;// pub const c_DwmMaxAdapters: UINT = 16;DwmDefWindowProcDWM_EC_DISABLECOMPOSITIONDWM_EC_ENABLECOMPOSITIONDwmEnableCompositionDwmEnableMMCSSDwmExtendFrameIntoClientAreaDwmGetColorizationColorDwmGetCompositionTimingInfoDWM_TIMING_INFODwmGetWindowAttributeDwmIsCompositionEnabledDwmModifyPreviousDxFrameDurationDwmQueryThumbnailSourceSizeDwmRegisterThumbnailDwmSetDxFrameDurationDwmSetPresentParametersDWM_PRESENT_PARAMETERSDwmSetWindowAttributeDwmUnregisterThumbnailDwmUpdateThumbnailPropertiesDWM_SIT_DISPLAYFRAMEDwmSetIconicThumbnailDwmSetIconicLivePreviewBitmapDwmInvalidateIconicBitmapsDwmFlush// pub fn DwmAttachMilContent(hwnd: HWND) -> HRESULT;// pub fn DwmDetachMilContent(hwnd: HWND) -> HRESULT;DwmGetTransportAttributes// pub fn DwmGetGraphicsStreamTransformHint();// pub fn DwmGetGraphicsStreamClient();DwmTransitionOwnedWindowDWMTRANSITION_OWNEDWINDOW_TARGETDwmRenderGestureGESTURE_TYPEDwmTetherContactDwmShowContactDWM_SHOWCONTACT//! Procedure declarations, constant definitions, and macros for the NLS component.// pub const DWM_FRAME_DURATION_DEFAULT: i32 = -1;LOGFONTWDWRITE_MAKE_OPENTYPE_TAGIDWriteGeometrySinkDWRITE_ALPHA_MAXFACILITY_DWRITEDWRITE_ERR_BASEMAKE_DWRITE_HRMAKE_DWRITE_HR_ERRDWriteCreateFactoryDWRITE_FACTORY_TYPE//! DirectX Typography Services public API definitions.DWRITE_GLYPH_OFFSETDWRITE_MATRIXDWRITE_PIXEL_GEOMETRYDWRITE_RENDERING_MODEDWRITE_SCRIPT_ANALYSISDWRITE_SHAPING_GLYPH_PROPERTIESDWRITE_TEXT_RANGEIDWriteBitmapRenderTargetIDWriteBitmapRenderTargetVtblIDWriteFactoryVtblIDWriteFontIDWriteFontCollectionIDWriteFontFaceVtblIDWriteFontVtblIDWriteRenderingParamsVtblIDWriteTextAnalysisSinkIDWriteTextAnalysisSinkVtblIDWriteTextAnalysisSourceIDWriteTextAnalysisSourceVtblIDWriteTextAnalyzerIDWriteTextAnalyzerVtblIDWriteTextLayoutVtbl//! Mappings for the content of dwrite_1.hDWRITE_FONT_FEATURE_TAGDWRITE_FONT_STRETCHDWRITE_FONT_STYLEDWRITE_FONT_WEIGHTDWRITE_STRIKETHROUGHDWRITE_UNDERLINEIDWriteGlyphRunAnalysisIDWriteInlineObjectIDWriteTextFormatVtblIDWriteTextRendererIDWriteTextRendererVtbldwrite_1DWRITE_GLYPH_ORIENTATION_ANGLEDWRITE_OUTLINE_THRESHOLDDWRITE_TEXT_ANTIALIAS_MODEDWRITE_UNICODE_RANGEDWRITE_VERTICAL_GLYPH_ORIENTATIONIDWriteFactory1IDWriteFactory1VtblIDWriteFont1IDWriteFont1VtblIDWriteFontFace1IDWriteFontFace1VtblIDWriteRenderingParams1IDWriteRenderingParams1VtblIDWriteTextAnalyzer1IDWriteTextAnalyzer1VtblIDWriteTextLayout1IDWriteTextLayout1VtblDWRITE_COLOR_F//! Mappings for the content of dwrite_2.hDWRITE_GLYPH_IMAGE_DATADWRITE_FONT_SIMULATIONSDWRITE_INFORMATIONAL_STRING_IDDWRITE_LINE_SPACING_METHODDWRITE_RENDERING_MODE_ALIASEDDWRITE_RENDERING_MODE_DEFAULTDWRITE_RENDERING_MODE_GDI_CLASSICDWRITE_RENDERING_MODE_GDI_NATURALDWRITE_RENDERING_MODE_NATURALDWRITE_RENDERING_MODE_NATURAL_SYMMETRICDWRITE_RENDERING_MODE_OUTLINEIDWriteFontCollectionVtblIDWriteFontFamilyIDWriteFontFamilyVtblIDWriteFontFileIDWriteFontListIDWriteFontListVtblIDWriteGdiInteropIDWriteGdiInteropVtblIDWriteLocalizedStringsDWRITE_PANOSEdwrite_2DWRITE_GRID_FIT_MODEIDWriteFactory2IDWriteFactory2VtblIDWriteFont2IDWriteFont2VtblIDWriteFontFace2IDWriteFontFace2VtblIDWriteRenderingParams2IDWriteRenderingParams2VtblIDWriteTextFormat1IDWriteTextFormat1VtblIDWriteTextLayout2IDWriteTextLayout2VtblFONTSIGNATUREDWRITE_E_REMOTEFONTDWRITE_E_DOWNLOADCANCELLEDDWRITE_E_DOWNLOADFAILEDDWRITE_E_TOOMANYDOWNLOADS//! Mappings for the content of dwrite_3.hDXGI_DEBUG_BINARY_VERSIONDXGI_DEBUG_IDDXGI_INFO_QUEUE_MESSAGE_IDDXGI_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMITDXGIGetDebugInterfaceDXVA2_ModeMPEG2_MOCOMPDXVA2_ModeWMV8_PostProcDXVA2_ModeWMV8_MoCompDXVA2_ModeWMV9_PostProcDXVA2_ModeWMV9_MoCompDXVA2_ModeWMV9_IDCTDXVA2_ModeVC1_PostProcDXVA2_ModeVC1_MoCompDXVA2_ModeVC1_IDCTDXVA2_ModeVC1_VLDDXVA2_ModeH264_MoComp_NoFGTDXVA2_ModeH264_MoComp_FGTDXVA2_ModeH264_IDCT_NoFGTDXVA2_ModeH264_IDCT_FGTDXVA2_ModeH264_VLD_NoFGTDXVA2_ModeH264_VLD_FGTDXVA2_E_NOT_INITIALIZEDDXVA2_E_NEW_VIDEO_DEVICEDXVA2_E_VIDEO_DEVICE_LOCKEDDXVA2_E_NOT_AVAILABLEMAX_DEINTERLACE_SURFACESMAX_SUBSTREAMSDXVA2_VideoTransFunc_22_709DXVA2_VideoTransFunc_22_240MDXVA2_VideoTransFunc_22_8bit_sRGBDXVA2_DECODE_GET_DRIVER_HANDLEDXVA2_DECODE_SPECIFY_ENCRYPTED_BLOCKSDXVA2CreateDirect3DDeviceManager9IDirect3DDeviceManager9DXVA2CreateVideoServiceDXVA2FloatToFixedDXVA2_Fixed32DXVA2FixedToFloatDXVA2_Fixed32TransparentAlphaDXVA2_Fixed32OpaqueAlphaDXVAHD_CreateDeviceDXVAHD_CONTENT_DESCDXVAHD_DEVICE_USAGEPDXVAHDSW_PluginIDXVAHD_DeviceeapPropCipherSuiteNegotiationeapPropMutualAutheapPropIntegrityeapPropReplayProtectioneapPropConfidentialityeapPropKeyDerivationeapPropKeyStrength64eapPropKeyStrength128eapPropKeyStrength256eapPropKeyStrength512eapPropKeyStrength1024eapPropDictionaryAttackResistanceeapPropFastReconnecteapPropCryptoBindingeapPropSessionIndependenceeapPropFragmentationeapPropChannelBindingeapPropNapeapPropStandaloneeapPropMppeEncryptioneapPropTunnelMethodeapPropSupportsConfigeapPropCertifiedMethodeapPropHiddenMethodeapPropMachineAutheapPropUserAutheapPropIdentityPrivacyeapPropMethodChainingeapPropSharedStateEquivalenceeapPropReservedEAP_VALUENAME_PROPERTIESEAP_SESSIONIDEapAttributeTypeEAP_ATTRIBUTE_TYPEEapAttributeEAP_ATTRIBUTEEapAttributesEAP_ATTRIBUTESEAP_FLAG_Reserved1EAP_FLAG_NON_INTERACTIVEEAP_FLAG_LOGONEAP_FLAG_PREVIEWEAP_FLAG_Reserved2EAP_FLAG_MACHINE_AUTHEAP_FLAG_GUEST_ACCESSEAP_FLAG_Reserved3EAP_FLAG_Reserved4EAP_FLAG_RESUME_FROM_HIBERNATEEAP_FLAG_Reserved5EAP_FLAG_Reserved6EAP_FLAG_FULL_AUTHEAP_FLAG_PREFER_ALT_CREDENTIALSEAP_FLAG_Reserved7EAP_PEER_FLAG_HEALTH_STATE_CHANGEEAP_FLAG_SUPRESS_UIEAP_FLAG_PRE_LOGONEAP_FLAG_USER_AUTHEAP_FLAG_CONFG_READONLYEAP_FLAG_Reserved8EAP_FLAG_Reserved9EAP_FLAG_VPNEAP_CONFIG_INPUT_FIELD_PROPS_DEFAULTEAP_CONFIG_INPUT_FIELD_PROPS_NON_DISPLAYABLEEAP_CONFIG_INPUT_FIELD_PROPS_NON_PERSISTEAP_UI_INPUT_FIELD_PROPS_DEFAULTEAP_UI_INPUT_FIELD_PROPS_NON_DISPLAYABLEEAP_UI_INPUT_FIELD_PROPS_NON_PERSISTEAP_UI_INPUT_FIELD_PROPS_READ_ONLYPEAP_CONFIG_INPUT_FIELD_TYPEEAP_CONFIG_INPUT_FIELD_TYPEEAP_CREDENTIAL_VERSIONEAP_INTERACTIVE_UI_DATA_VERSIONEAPHOST_PEER_API_VERSIONEAPHOST_METHOD_API_VERSIONMAX_EAP_CONFIG_INPUT_FIELD_LENGTHMAX_EAP_CONFIG_INPUT_FIELD_VALUE_LENGTHPEAP_CONFIG_INPUT_FIELD_DATAEAP_CONFIG_INPUT_FIELD_DATAPEAP_CONFIG_INPUT_FIELD_ARRAYEAP_CONFIG_INPUT_FIELD_ARRAYEAP_CRED_REQEAP_CRED_RESPEAP_CRED_LOGON_REQEAP_CRED_LOGON_RESPEAP_CRED_EXPIRY_RESPEAP_CRED_EXPIRY_REQCERTIFICATE_HASH_LENGTHLPENCLAVE_ROUTINEIsEnclaveTypeSupportedCreateEnclaveLoadEnclaveDataInitializeEnclaveLoadEnclaveImageALoadEnclaveImageWCallEnclaveTerminateEnclaveDeleteEnclavePAUDIO_VOLUME_NOTIFICATION_DATAAUDIO_VOLUME_NOTIFICATION_DATAENDPOINT_HARDWARE_SUPPORT_VOLUMEENDPOINT_HARDWARE_SUPPORT_MUTEENDPOINT_HARDWARE_SUPPORT_METEREXCEPTION_POINTERSPCONTEXTPEXCEPTION_RECORDPVECTORED_EXCEPTION_HANDLERLPTOP_LEVEL_EXCEPTION_FILTERPTOP_LEVEL_EXCEPTION_FILTERRaiseExceptionUnhandledExceptionFilterSetUnhandledExceptionFilterGetErrorModeAddVectoredExceptionHandlerRemoveVectoredExceptionHandlerAddVectoredContinueHandlerRemoveVectoredContinueHandlerRaiseFailFastExceptionFatalAppExitAFatalAppExitWGetThreadErrorMode//! ApiSet Contract for api-ms-win-core-errorhandling-l1// RestoreLastError// What library provides this function?// TerminateProcessOnMemoryExhaustionEVENT_HEADER_EXT_TYPE_RELATED_ACTIVITYIDEVENT_HEADER_EXT_TYPE_SIDEVENT_HEADER_EXT_TYPE_TS_IDEVENT_HEADER_EXT_TYPE_INSTANCE_INFOEVENT_HEADER_EXT_TYPE_STACK_TRACE32EVENT_HEADER_EXT_TYPE_STACK_TRACE64EVENT_HEADER_EXT_TYPE_PEBS_INDEXEVENT_HEADER_EXT_TYPE_PMC_COUNTERSEVENT_HEADER_EXT_TYPE_PSM_KEYEVENT_HEADER_EXT_TYPE_EVENT_KEYEVENT_HEADER_EXT_TYPE_EVENT_SCHEMA_TLEVENT_HEADER_EXT_TYPE_PROV_TRAITSEVENT_HEADER_EXT_TYPE_PROCESS_START_KEYEVENT_HEADER_EXT_TYPE_CONTROL_GUIDEVENT_HEADER_EXT_TYPE_MAXPEVENT_HEADER_EXTENDED_DATA_ITEMEVENT_HEADER_EXTENDED_DATA_ITEMPEVENT_EXTENDED_ITEM_INSTANCEEVENT_EXTENDED_ITEM_INSTANCEPEVENT_EXTENDED_ITEM_RELATED_ACTIVITYIDEVENT_EXTENDED_ITEM_RELATED_ACTIVITYIDPEVENT_EXTENDED_ITEM_TS_IDEVENT_EXTENDED_ITEM_TS_IDPEVENT_EXTENDED_ITEM_STACK_TRACE32EVENT_EXTENDED_ITEM_STACK_TRACE32PEVENT_EXTENDED_ITEM_STACK_TRACE64EVENT_EXTENDED_ITEM_STACK_TRACE64PEVENT_EXTENDED_ITEM_PEBS_INDEXEVENT_EXTENDED_ITEM_PEBS_INDEXPEVENT_EXTENDED_ITEM_PMC_COUNTERSEVENT_EXTENDED_ITEM_PMC_COUNTERSPEVENT_EXTENDED_ITEM_PROCESS_START_KEYEVENT_EXTENDED_ITEM_PROCESS_START_KEYPEVENT_EXTENDED_ITEM_EVENT_KEYEVENT_EXTENDED_ITEM_EVENT_KEYEVENT_HEADER_PROPERTY_XMLEVENT_HEADER_PROPERTY_FORWARDED_XMLEVENT_HEADER_PROPERTY_LEGACY_EVENTLOGEVENT_HEADER_PROPERTY_RELOGGABLEEVENT_HEADER_FLAG_EXTENDED_INFOEVENT_HEADER_FLAG_PRIVATE_SESSIONEVENT_HEADER_FLAG_STRING_ONLYEVENT_HEADER_FLAG_TRACE_MESSAGEEVENT_HEADER_FLAG_NO_CPUTIMEEVENT_HEADER_FLAG_32_BIT_HEADEREVENT_HEADER_FLAG_64_BIT_HEADEREVENT_HEADER_FLAG_CLASSIC_HEADEREVENT_HEADER_FLAG_PROCESSOR_INDEXPEVENT_HEADEREVENT_HEADEREVENT_RECORDPCEVENT_RECORDEVENT_ENABLE_PROPERTY_SIDEVENT_ENABLE_PROPERTY_TS_IDEVENT_ENABLE_PROPERTY_STACK_TRACEEVENT_ENABLE_PROPERTY_PSM_KEYEVENT_ENABLE_PROPERTY_IGNORE_KEYWORD_0EVENT_ENABLE_PROPERTY_PROVIDER_GROUPEVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0EVENT_ENABLE_PROPERTY_PROCESS_START_KEYEVENT_ENABLE_PROPERTY_EVENT_KEYEVENT_ENABLE_PROPERTY_EXCLUDE_INPRIVATEPROCESS_TRACE_MODE_REAL_TIMEPROCESS_TRACE_MODE_RAW_TIMESTAMPPROCESS_TRACE_MODE_EVENT_RECORDGetEventProcessorIndex// Taken from Rust 1.17.0 sourcesEtwGetTraitFromProviderTraitsEventAccessControlEventAccessQueryEventAccessRemovedocobjOLECMDEXECOPTOLECMDFOLECMDIDocidlREADYSTATE//! Mappings for the contents of ExDisp.hPFLS_CALLBACK_FUNCTIONFlsAllocFlsGetValueFlsSetValueFlsFreeIsThreadAFiberFILE_INFO_BY_HANDLE_CLASSFINDEX_INFO_LEVELSFINDEX_SEARCH_OPSGET_FILEEX_INFO_LEVELSLPOVERLAPPED_COMPLETION_ROUTINELPWIN32_FIND_DATAALPWIN32_FIND_DATAWFILE_ID_128FILE_SEGMENT_ELEMENTCREATE_NEWCREATE_ALWAYSOPEN_ALWAYSTRUNCATE_EXISTINGINVALID_FILE_SIZEINVALID_SET_FILE_POINTERINVALID_FILE_ATTRIBUTESLPWIN32_FILE_ATTRIBUTE_DATAWIN32_FILE_ATTRIBUTE_DATAPBY_HANDLE_FILE_INFORMATIONBY_HANDLE_FILE_INFORMATIONLPBY_HANDLE_FILE_INFORMATIONPCREATEFILE2_EXTENDED_PARAMETERSCREATEFILE2_EXTENDED_PARAMETERSLPCREATEFILE2_EXTENDED_PARAMETERSCompareFileTimeCreateDirectoryACreateDirectoryWCreateFileADefineDosDeviceWDeleteFileADeleteFileWDeleteVolumeMountPointWFileTimeToLocalFileTimeFindCloseFindCloseChangeNotificationFindFirstChangeNotificationAFindFirstChangeNotificationWFindFirstFileAFindFirstFileWFindFirstFileExAFindFirstFileExWFindNextChangeNotificationFindNextFileAFindNextFileWGetDiskFreeSpaceAGetDiskFreeSpaceWGetDiskFreeSpaceExAGetDriveTypeAGetFileAttributesAGetFileAttributesWGetFileAttributesExAGetFileAttributesExWGetFileInformationByHandleGetFileSizeGetFileSizeExGetFileTypeGetFinalPathNameByHandleAGetFinalPathNameByHandleWGetFileTimeGetFullPathNameWGetFullPathNameAGetLogicalDrivesGetLogicalDriveStringsWGetLongPathNameAGetLongPathNameWGetShortPathNameWGetTempFileNameWGetVolumeInformationByHandleWGetVolumePathNameWLocalFileTimeToFileTimeLockFileLockFileExQueryDosDeviceWReadFileExReadFileScatterRemoveDirectoryARemoveDirectoryWSetEndOfFileSetFileAttributesASetFileInformationByHandleSetFilePointerSetFilePointerExSetFileTimeSetFileValidDataUnlockFileUnlockFileExWriteFileExWriteFileGatherGetTempPathWGetVolumeNameForVolumeMountPointWCreateFile2SetFileIoOverlappedRangeGetCompressedFileSizeAGetCompressedFileSizeWFindFirstStreamWSTREAM_INFO_LEVELSFindNextStreamWAreFileApisANSIGetTempPathAFindFirstFileNameWFindNextFileNameWGetVolumeInformationAGetTempFileNameASetFileApisToOEMSetFileApisToANSI//! ApiSet Contract for api-ms-win-core-file-l1PROPERTYKEY//52//137//209GLenum//48GLbooleanGLbitfieldGLbyteGLshortGLintGLsizeiGLubyteGLushortGLuintGLfloatGLclampfGLdoubleGLclampdGLvoidGL_ACCUM//63//68//AccumOpGL_LOADGL_RETURNGL_MULTGL_ADDGL_NEVER//AlphaFunctionGL_LESSGL_EQUALGL_LEQUALGL_GREATERGL_NOTEQUALGL_GEQUALGL_ALWAYSglAccumglAlphaFunc// TODO: we're missing about 1500 lines of defines and methods// until that time, you can use the excellent GL crate// https://github.com/brendanzab/gl-rsgl//! Headers for user mode onlyCompareObjectHandlesGetHandleInformation//! handleapi include fileLPPROCESS_HEAP_ENTRYHEAP_INFORMATION_CLASSPHEAP_SUMMARYHEAP_SUMMARYLPHEAP_SUMMARYHeapCreateHeapDestroyHeapReAllocHeapSizeHeapCompactHeapSetInformationHeapValidateHeapSummaryGetProcessHeapsHeapLockHeapUnlockHeapWalkHeapQueryInformation//! ApiSet Contract for api-ms-win-core-heap-l1physicalmonitorenumerationapi_BOOLMC_CAPS_NONEMC_CAPS_MONITOR_TECHNOLOGY_TYPEMC_CAPS_BRIGHTNESSMC_CAPS_CONTRASTMC_CAPS_COLOR_TEMPERATUREMC_CAPS_RED_GREEN_BLUE_GAINMC_CAPS_RED_GREEN_BLUE_DRIVEMC_CAPS_DEGAUSSMC_CAPS_DISPLAY_AREA_POSITIONMC_CAPS_DISPLAY_AREA_SIZEMC_CAPS_RESTORE_FACTORY_DEFAULTSMC_CAPS_RESTORE_FACTORY_COLOR_DEFAULTSMC_RESTORE_FACTORY_DEFAULTS_ENABLES_MONITOR_SETTINGSMC_SUPPORTED_COLOR_TEMPERATURE_NONEMC_SUPPORTED_COLOR_TEMPERATURE_4000KMC_SUPPORTED_COLOR_TEMPERATURE_5000KMC_SUPPORTED_COLOR_TEMPERATURE_6500KMC_SUPPORTED_COLOR_TEMPERATURE_7500KMC_SUPPORTED_COLOR_TEMPERATURE_8200KMC_SUPPORTED_COLOR_TEMPERATURE_9300KMC_SUPPORTED_COLOR_TEMPERATURE_10000KMC_SUPPORTED_COLOR_TEMPERATURE_11500KLPMC_DISPLAY_TECHNOLOGY_TYPEMC_DISPLAY_TECHNOLOGY_TYPELPMC_COLOR_TEMPERATUREMC_COLOR_TEMPERATUREGetMonitorCapabilitiesSaveCurrentMonitorSettingsGetMonitorTechnologyTypeGetMonitorBrightnessGetMonitorContrastGetMonitorColorTemperatureGetMonitorRedGreenOrBlueDriveMC_DRIVE_TYPEGetMonitorRedGreenOrBlueGainMC_GAIN_TYPESetMonitorBrightnessSetMonitorContrastSetMonitorColorTemperatureSetMonitorRedGreenOrBlueDriveSetMonitorRedGreenOrBlueGainDegaussMonitorGetMonitorDisplayAreaSizeMC_SIZE_TYPEGetMonitorDisplayAreaPositionMC_POSITION_TYPESetMonitorDisplayAreaSizeSetMonitorDisplayAreaPositionRestoreMonitorFactoryColorDefaultsRestoreMonitorFactoryDefaultsHTTP_INITIALIZE_SERVERHTTP_INITIALIZE_CONFIGHTTP_DEMAND_CBTPHTTP_SERVER_PROPERTYHTTP_SERVER_PROPERTYPHTTP_PROPERTY_FLAGSHTTP_PROPERTY_FLAGSPHTTP_ENABLED_STATEHTTP_ENABLED_STATEPHTTP_STATE_INFOHTTP_STATE_INFOPHTTP_503_RESPONSE_VERBOSITYHTTP_503_RESPONSE_VERBOSITYPHTTP_QOS_SETTING_TYPEHTTP_QOS_SETTING_TYPEPHTTP_QOS_SETTING_INFOHTTP_QOS_SETTING_INFOPHTTP_CONNECTION_LIMIT_INFOHTTP_CONNECTION_LIMIT_INFOPHTTP_BANDWIDTH_LIMIT_INFOHTTP_BANDWIDTH_LIMIT_INFOPHTTP_FLOWRATE_INFOHTTP_FLOWRATE_INFOHTTP_MIN_ALLOWED_BANDWIDTH_THROTTLING_RATEHTTP_LIMIT_INFINITEPHTTP_SERVICE_CONFIG_TIMEOUT_KEYHTTP_SERVICE_CONFIG_TIMEOUT_KEYHTTP_SERVICE_CONFIG_TIMEOUT_PARAMPHTTP_SERVICE_CONFIG_TIMEOUT_PARAMPHTTP_SERVICE_CONFIG_TIMEOUT_SETHTTP_SERVICE_CONFIG_TIMEOUT_SETPHTTP_TIMEOUT_LIMIT_INFOHTTP_TIMEOUT_LIMIT_INFOPHTTP_LISTEN_ENDPOINT_INFOHTTP_LISTEN_ENDPOINT_INFOPHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMSHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMSPHTTP_SERVER_AUTHENTICATION_BASIC_PARAMSHTTP_SERVER_AUTHENTICATION_BASIC_PARAMSHTTP_AUTH_ENABLE_BASICHTTP_AUTH_ENABLE_DIGESTHTTP_AUTH_ENABLE_NTLMHTTP_AUTH_ENABLE_NEGOTIATEHTTP_AUTH_ENABLE_KERBEROSHTTP_AUTH_ENABLE_ALLHTTP_AUTH_EX_FLAG_ENABLE_KERBEROS_CREDENTIAL_CACHINGHTTP_AUTH_EX_FLAG_CAPTURE_CREDENTIALPHTTP_SERVER_AUTHENTICATION_INFOHTTP_SERVER_AUTHENTICATION_INFOPHTTP_SERVICE_BINDING_BASEHTTP_SERVICE_BINDING_BASEPHTTP_SERVICE_BINDING_AHTTP_SERVICE_BINDING_APHTTP_SERVICE_BINDING_WHTTP_SERVICE_BINDING_WHTTP_CHANNEL_BIND_PROXYHTTP_CHANNEL_BIND_PROXY_COHOSTINGHTTP_CHANNEL_BIND_NO_SERVICE_NAME_CHECKHTTP_CHANNEL_BIND_DOTLESS_SERVICEHTTP_CHANNEL_BIND_SECURE_CHANNEL_TOKENHTTP_CHANNEL_BIND_CLIENT_SERVICEPHTTP_CHANNEL_BIND_INFOHTTP_CHANNEL_BIND_INFOPHTTP_REQUEST_CHANNEL_BIND_STATUSHTTP_REQUEST_CHANNEL_BIND_STATUSHTTP_LOG_FIELD_DATEHTTP_LOG_FIELD_TIMEHTTP_LOG_FIELD_CLIENT_IPHTTP_LOG_FIELD_USER_NAMEHTTP_LOG_FIELD_SITE_NAMEHTTP_LOG_FIELD_COMPUTER_NAMEHTTP_LOG_FIELD_SERVER_IPHTTP_LOG_FIELD_METHODHTTP_LOG_FIELD_URI_STEMHTTP_LOG_FIELD_URI_QUERYHTTP_LOG_FIELD_STATUSHTTP_LOG_FIELD_WIN32_STATUSHTTP_LOG_FIELD_BYTES_SENTHTTP_LOG_FIELD_BYTES_RECVHTTP_LOG_FIELD_TIME_TAKENHTTP_LOG_FIELD_SERVER_PORTHTTP_LOG_FIELD_USER_AGENTHTTP_LOG_FIELD_COOKIEHTTP_LOG_FIELD_REFERERHTTP_LOG_FIELD_VERSIONHTTP_LOG_FIELD_HOSTHTTP_LOG_FIELD_SUB_STATUSHTTP_LOG_FIELD_CLIENT_PORTHTTP_LOG_FIELD_URIHTTP_LOG_FIELD_SITE_IDHTTP_LOG_FIELD_REASONHTTP_LOG_FIELD_QUEUE_NAMEHTTP_MIN_ALLOWED_LOG_FILE_ROLLOVER_SIZEHTTP_LOGGING_FLAG_LOCAL_TIME_ROLLOVERHTTP_LOGGING_FLAG_USE_UTF8_CONVERSIONHTTP_LOGGING_FLAG_LOG_ERRORS_ONLYHTTP_LOGGING_FLAG_LOG_SUCCESS_ONLYPHTTP_LOGGING_INFOHTTP_LOGGING_INFOPHTTP_BINDING_INFOHTTP_BINDING_INFOPHTTP_PROTECTION_LEVEL_TYPEHTTP_PROTECTION_LEVEL_TYPEPHTTP_PROTECTION_LEVEL_INFOHTTP_PROTECTION_LEVEL_INFOHTTP_CREATE_REQUEST_QUEUE_FLAG_OPEN_EXISTINGHTTP_CREATE_REQUEST_QUEUE_FLAG_CONTROLLERHTTP_RECEIVE_REQUEST_FLAG_COPY_BODYHTTP_RECEIVE_REQUEST_FLAG_FLUSH_BODYHTTP_RECEIVE_REQUEST_ENTITY_BODY_FLAG_FILL_BUFFERHTTP_SEND_RESPONSE_FLAG_DISCONNECTHTTP_SEND_RESPONSE_FLAG_MORE_DATAHTTP_SEND_RESPONSE_FLAG_BUFFER_DATAHTTP_SEND_RESPONSE_FLAG_ENABLE_NAGLINGHTTP_SEND_RESPONSE_FLAG_PROCESS_RANGESHTTP_SEND_RESPONSE_FLAG_OPAQUEHTTP_FLUSH_RESPONSE_FLAG_RECURSIVEHTTP_OPAQUE_IDPHTTP_OPAQUE_IDHTTP_REQUEST_IDPHTTP_REQUEST_IDHTTP_CONNECTION_IDPHTTP_CONNECTION_IDHTTP_RAW_CONNECTION_IDPHTTP_RAW_CONNECTION_IDHTTP_URL_GROUP_IDPHTTP_URL_GROUP_IDHTTP_SERVER_SESSION_IDPHTTP_SERVER_SESSION_IDHTTP_BYTE_RANGE_TO_EOFPHTTP_BYTE_RANGEHTTP_BYTE_RANGEPHTTP_VERSIONHTTP_VERSIONHTTP_VERSION_UNKNOWNHTTP_VERSION_0_9HTTP_VERSION_1_0HTTP_VERSION_1_1HTTP_SET_VERSIONHTTP_EQUAL_VERSIONHTTP_GREATER_VERSIONHTTP_LESS_VERSIONHTTP_NOT_EQUAL_VERSIONHTTP_GREATER_EQUAL_VERSIONHTTP_LESS_EQUAL_VERSIONPHTTP_VERBHTTP_VERBPHTTP_HEADER_IDHTTP_HEADER_IDPHTTP_KNOWN_HEADERHTTP_KNOWN_HEADERPHTTP_UNKNOWN_HEADERHTTP_UNKNOWN_HEADERPHTTP_LOG_DATA_TYPEHTTP_LOG_DATA_TYPEPHTTP_LOG_DATAHTTP_LOG_DATAPHTTP_LOG_FIELDS_DATAHTTP_LOG_FIELDS_DATAPHTTP_DATA_CHUNK_TYPEHTTP_DATA_CHUNK_TYPEPHTTP_DATA_CHUNKHTTP_DATA_CHUNKPHTTP_REQUEST_HEADERSHTTP_REQUEST_HEADERSPHTTP_RESPONSE_HEADERSHTTP_RESPONSE_HEADERSPHTTP_TRANSPORT_ADDRESSHTTP_TRANSPORT_ADDRESSPHTTP_COOKED_URLHTTP_COOKED_URLHTTP_URL_CONTEXTHTTP_URL_FLAG_REMOVE_ALLPHTTP_AUTH_STATUSHTTP_AUTH_STATUSPHTTP_REQUEST_AUTH_TYPEHTTP_REQUEST_AUTH_TYPEPHTTP_SSL_CLIENT_CERT_INFOHTTP_SSL_CLIENT_CERT_INFOHTTP_RECEIVE_SECURE_CHANNEL_TOKENPHTTP_SSL_INFOHTTP_SSL_INFOPHTTP_REQUEST_INFOHTTP_REQUEST_INFOHTTP_REQUEST_AUTH_FLAG_TOKEN_FOR_CACHED_CREDPHTTP_REQUEST_AUTH_INFOHTTP_REQUEST_AUTH_INFOPHTTP_REQUEST_V1HTTP_REQUEST_V1PHTTP_REQUEST_V2HTTP_REQUEST_V2HTTP_REQUESTPHTTP_REQUESTHTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTSHTTP_REQUEST_FLAG_IP_ROUTEDPHTTP_RESPONSE_V1HTTP_RESPONSE_V1HTTP_RESPONSE_FLAG_MULTIPLE_ENCODINGS_AVAILABLEPHTTP_RESPONSE_INFO_TYPEHTTP_RESPONSE_INFO_TYPEPHTTP_RESPONSE_INFOHTTP_RESPONSE_INFOHTTP_RESPONSE_INFO_FLAGS_PRESERVE_ORDERPHTTP_MULTIPLE_KNOWN_HEADERSHTTP_MULTIPLE_KNOWN_HEADERSPHTTP_RESPONSE_V2HTTP_RESPONSE_V2HTTP_RESPONSEPHTTP_RESPONSEPHTTPAPI_VERSIONHTTPAPI_VERSIONHTTPAPI_VERSION_2HTTPAPI_VERSION_1HTTPAPI_EQUAL_VERSIONHTTPAPI_GREATER_VERSIONHTTPAPI_LESS_VERSIONHTTPAPI_VERSION_GREATER_OR_EQUALPHTTP_CACHE_POLICY_TYPEHTTP_CACHE_POLICY_TYPEPHTTP_CACHE_POLICYHTTP_CACHE_POLICYPHTTP_SERVICE_CONFIG_IDHTTP_SERVICE_CONFIG_IDPHTTP_SERVICE_CONFIG_QUERY_TYPEHTTP_SERVICE_CONFIG_QUERY_TYPEPHTTP_SERVICE_CONFIG_SSL_KEYHTTP_SERVICE_CONFIG_SSL_KEYPHTTP_SERVICE_CONFIG_SSL_SNI_KEYHTTP_SERVICE_CONFIG_SSL_SNI_KEYPHTTP_SERVICE_CONFIG_SSL_CCS_KEYHTTP_SERVICE_CONFIG_SSL_CCS_KEYPHTTP_SERVICE_CONFIG_SSL_PARAMHTTP_SERVICE_CONFIG_SSL_PARAMHTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPERHTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERTHTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTERPHTTP_SERVICE_CONFIG_SSL_SETHTTP_SERVICE_CONFIG_SSL_SETPHTTP_SERVICE_CONFIG_SSL_SNI_SETHTTP_SERVICE_CONFIG_SSL_SNI_SETPHTTP_SERVICE_CONFIG_SSL_CCS_SETHTTP_SERVICE_CONFIG_SSL_CCS_SETPHTTP_SERVICE_CONFIG_SSL_QUERYHTTP_SERVICE_CONFIG_SSL_QUERYPHTTP_SERVICE_CONFIG_SSL_SNI_QUERYHTTP_SERVICE_CONFIG_SSL_SNI_QUERYPHTTP_SERVICE_CONFIG_SSL_CCS_QUERYHTTP_SERVICE_CONFIG_SSL_CCS_QUERYPHTTP_SERVICE_CONFIG_IP_LISTEN_PARAMHTTP_SERVICE_CONFIG_IP_LISTEN_PARAMPHTTP_SERVICE_CONFIG_IP_LISTEN_QUERYHTTP_SERVICE_CONFIG_IP_LISTEN_QUERYPHTTP_SERVICE_CONFIG_URLACL_KEYHTTP_SERVICE_CONFIG_URLACL_KEYPHTTP_SERVICE_CONFIG_URLACL_PARAMHTTP_SERVICE_CONFIG_URLACL_PARAMPHTTP_SERVICE_CONFIG_URLACL_SETHTTP_SERVICE_CONFIG_URLACL_SETPHTTP_SERVICE_CONFIG_URLACL_QUERYHTTP_SERVICE_CONFIG_URLACL_QUERYPHTTP_SERVICE_CONFIG_CACHE_KEYHTTP_SERVICE_CONFIG_CACHE_KEYHTTP_SERVICE_CONFIG_CACHE_PARAMPHTTP_SERVICE_CONFIG_CACHE_PARAMPHTTP_SERVICE_CONFIG_CACHE_SETHTTP_SERVICE_CONFIG_CACHE_SETHTTP_NULL_IDHTTP_IS_NULL_IDHTTP_SET_NULL_IDHttpInitializeHttpTerminateHttpCreateHttpHandleHttpCreateRequestQueueHttpCloseRequestQueueHttpSetRequestQueuePropertyHttpQueryRequestQueuePropertyHttpShutdownRequestQueueHttpReceiveClientCertificateHttpCreateServerSessionHttpCloseServerSessionHttpQueryServerSessionPropertyHttpSetServerSessionPropertyHttpAddUrlHttpRemoveUrlHttpCreateUrlGroupHttpCloseUrlGroupHttpAddUrlToUrlGroupHttpRemoveUrlFromUrlGroupHttpSetUrlGroupPropertyHttpQueryUrlGroupPropertyHttpPrepareUrlHttpReceiveHttpRequestHttpReceiveRequestEntityBodyHttpSendHttpResponseHttpSendResponseEntityBodyHttpWaitForDisconnectHttpWaitForDisconnectExHttpCancelHttpRequestHttpWaitForDemandStartHttpFlushResponseCacheHttpAddFragmentToCacheHttpReadFragmentFromCacheHttpSetServiceConfigurationHttpDeleteServiceConfigurationHttpQueryServiceConfigurationHttpDeclarePushHttpUpdateServiceConfiguration//! HTTP API specificationLPCOMPOSITIONFORMCOMPOSITIONFORMImmGetContextHIMCImmGetOpenStatusImmSetOpenStatusImmSetCompositionWindowImmReleaseContextCFS_DEFAULTCFS_RECTCFS_POINTCFS_FORCE_POSITIONCFS_CANDIDATEPOSCFS_EXCLUDEPSLIST_ENTRYPSLIST_HEADERInitializeSListHeadInterlockedPopEntrySListInterlockedPushEntrySListInterlockedPushListSListExInterlockedFlushSListQueryDepthSListLPOVERLAPPED_ENTRYGetQueuedCompletionStatusCancelIoGetOverlappedResultExCancelSynchronousIo// #include <in6addr.h>// #include <inaddr.h>MAX_ADAPTER_NAMEMAX_OPT_SIZEIPAddrIPMaskIP_STATUSIPv6AddrPIP_OPTION_INFORMATIONIP_OPTION_INFORMATIONPIP_OPTION_INFORMATION32IP_OPTION_INFORMATION32PICMP_ECHO_REPLYICMP_ECHO_REPLYPICMP_ECHO_REPLY32ICMP_ECHO_REPLY32PIPV6_ADDRESS_EXIPV6_ADDRESS_EX// #include <packoff.h>PICMPV6_ECHO_REPLY_LHICMPV6_ECHO_REPLY_LHICMPV6_ECHO_REPLYPICMPV6_ECHO_REPLYPARP_SEND_REPLYARP_SEND_REPLYPTCP_RESERVE_PORT_RANGETCP_RESERVE_PORT_RANGEPIP_ADAPTER_INDEX_MAPIP_ADAPTER_INDEX_MAPPIP_INTERFACE_INFOIP_INTERFACE_INFOPIP_UNIDIRECTIONAL_ADAPTER_ADDRESSIP_UNIDIRECTIONAL_ADAPTER_ADDRESSPIP_ADAPTER_ORDER_MAPIP_ADAPTER_ORDER_MAPPIP_MCAST_COUNTER_INFOIP_MCAST_COUNTER_INFOIP_STATUS_BASE// IP_STATUS codes returned from IP APIsIP_SUCCESSIP_BUF_TOO_SMALLIP_DEST_NET_UNREACHABLEIP_DEST_HOST_UNREACHABLEIP_DEST_PROT_UNREACHABLEIP_DEST_PORT_UNREACHABLEIP_NO_RESOURCESIP_BAD_OPTIONIP_HW_ERRORIP_PACKET_TOO_BIGIP_REQ_TIMED_OUTIP_BAD_REQIP_BAD_ROUTEIP_TTL_EXPIRED_TRANSITIP_TTL_EXPIRED_REASSEMIP_PARAM_PROBLEMIP_SOURCE_QUENCHIP_OPTION_TOO_BIGIP_BAD_DESTINATIONIP_DEST_NO_ROUTEIP_DEST_ADDR_UNREACHABLEIP_DEST_PROHIBITEDIP_HOP_LIMIT_EXCEEDEDIP_REASSEMBLY_TIME_EXCEEDEDIP_PARAMETER_PROBLEMIP_DEST_UNREACHABLEIP_TIME_EXCEEDEDIP_BAD_HEADERIP_UNRECOGNIZED_NEXT_HEADERIP_ICMP_ERRORIP_DEST_SCOPE_MISMATCHIP_ADDR_DELETEDIP_SPEC_MTU_CHANGEIP_MTU_CHANGEIP_UNLOADIP_ADDR_ADDEDIP_MEDIA_CONNECTIP_MEDIA_DISCONNECTIP_BIND_ADAPTERIP_UNBIND_ADAPTERIP_DEVICE_DOES_NOT_EXISTIP_DUPLICATE_ADDRESSIP_INTERFACE_METRIC_CHANGEIP_RECONFIG_SECFLTRIP_NEGOTIATING_IPSECIP_INTERFACE_WOL_CAPABILITY_CHANGEIP_DUPLICATE_IPADDIP_GENERAL_FAILUREMAX_IP_STATUSIP_PENDINGIP_FLAG_REVERSEIP_FLAG_DFIP_OPT_EOLIP_OPT_NOPIP_OPT_SECURITYIP_OPT_LSRRIP_OPT_SSRRIP_OPT_RRIP_OPT_TSIP_OPT_SIDIP_OPT_ROUTER_ALERT// #include <iprtrmib.h>// #include <ipexport.h>// #include <iptypes.h>// #include <tcpestats.h>ipexportPFIXED_INFOPIP_ADAPTER_INFOPIP_INTERFACE_NAME_INFOPIP_PER_ADAPTER_INFOGetNumberOfInterfacesGetIfEntryGetIfTableGetIpAddrTableGetIpNetTableGetIpForwardTableGetTcpTableGetExtendedTcpTable// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365928(v=vs.85).aspxGetOwnerModuleFromTcpEntryGetUdpTableGetExtendedUdpTableGetOwnerModuleFromUdpEntryGetTcpTable2GetTcp6Table// Deprecated APIs, Added for documentation.// pub fn AllocateAndGetTcpExTableFromStack() -> DWORD;// pub fn AllocateAndGetUdpExTableFromStack() -> DWORD;GetTcp6Table2GetPerTcpConnectionEStatsSetPerTcpConnectionEStatsGetPerTcp6ConnectionEStatsSetPerTcp6ConnectionEStatsGetOwnerModuleFromTcp6EntryGetUdp6TableGetOwnerModuleFromUdp6EntryGetOwnerModuleFromPidAndInfoGetIpStatisticsGetIcmpStatisticsGetTcpStatisticsGetUdpStatisticsSetIpStatisticsExGetIpStatisticsExGetIcmpStatisticsExGetTcpStatisticsExGetUdpStatisticsExGetTcpStatisticsEx2GetUdpStatisticsEx2SetIfEntryCreateIpForwardEntrySetIpForwardEntryDeleteIpForwardEntrySetIpStatisticsSetIpTTLCreateIpNetEntrySetIpNetEntryDeleteIpNetEntryFlushIpNetTableCreateProxyArpEntryDeleteProxyArpEntrySetTcpEntryGetInterfaceInfoGetUniDirectionalAdapterInfoNhpAllocateAndGetInterfaceInfoFromStackGetBestInterfaceExGetBestRouteNotifyAddrChangeNotifyRouteChangeCancelIPChangeNotifyGetAdapterIndexAddIPAddressDeleteIPAddressGetNetworkParamsGetAdaptersInfoGetAdapterOrderMapGetPerAdapterInfoPINTERFACE_TIMESTAMP_CAPABILITY_FLAGSINTERFACE_TIMESTAMP_CAPABILITY_FLAGSPINTERFACE_TIMESTAMP_CAPABILITIESINTERFACE_TIMESTAMP_CAPABILITIESPINTERFACE_HARDWARE_CROSSTIMESTAMPINTERFACE_HARDWARE_CROSSTIMESTAMPGetInterfaceCurrentTimestampCapabilitiesGetInterfaceHardwareTimestampCapabilitiesCaptureInterfaceHardwareCrossTimestampPINTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACKINTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACKNotifyIfTimestampConfigChangeHIFTIMESTAMPCHANGECancelIfTimestampConfigChangeIpReleaseAddressIpRenewAddressGetRTTAndHopCountGetFriendlyIfIndexEnableRouterUnenableRouterDisableMediaSenseRestoreMediaSenseGetIpErrorStringResolveNeighborCreatePersistentTcpPortReservationCreatePersistentUdpPortReservationDeletePersistentTcpPortReservationDeletePersistentUdpPortReservationLookupPersistentTcpPortReservationLookupPersistentUdpPortReservationDNS_MAX_NAME_BUFFER_LENGTHPNET_ADDRESS_INFONET_ADDRESS_INFOParseNetworkString// #if defined (_WS2DEF_) && defined (_WS2IPDEF_) && defined(_WINDNS_INCLUDED_)ucrtMAX_ADAPTER_DESCRIPTION_LENGTHMAX_ADAPTER_NAME_LENGTHDEFAULT_MINIMUM_ENTITIESMAX_HOSTNAME_LENMAX_DOMAIN_NAME_LENMAX_SCOPE_ID_LENBROADCAST_NODETYPEPEER_TO_PEER_NODETYPEMIXED_NODETYPEHYBRID_NODETYPEPIP_ADDRESS_STRINGIP_ADDRESS_STRINGIP_MASK_STRINGPIP_MASK_STRINGPIP_ADDR_STRINGIP_ADDR_STRINGIP_ADAPTER_INFOIP_PREFIX_ORIGINIP_SUFFIX_ORIGINIP_DAD_STATEPIP_ADAPTER_UNICAST_ADDRESS_LHIP_ADAPTER_UNICAST_ADDRESS_LHPIP_ADAPTER_UNICAST_ADDRESS_XPIP_ADAPTER_UNICAST_ADDRESS_XPIP_ADAPTER_UNICAST_ADDRESSPIP_ADAPTER_UNICAST_ADDRESS// pub type IP_ADAPTER_UNICAST_ADDRESS = IP_ADAPTER_UNICAST_ADDRESS_XP;IP_ADAPTER_ADDRESS_DNS_ELIGIBLEIP_ADAPTER_ADDRESS_TRANSIENTPIP_ADAPTER_ANYCAST_ADDRESS_XPIP_ADAPTER_ANYCAST_ADDRESS_XPIP_ADAPTER_ANYCAST_ADDRESSPIP_ADAPTER_ANYCAST_ADDRESSPIP_ADAPTER_MULTICAST_ADDRESS_XPIP_ADAPTER_MULTICAST_ADDRESS_XPIP_ADAPTER_MULTICAST_ADDRESSPIP_ADAPTER_MULTICAST_ADDRESSPIP_ADAPTER_DNS_SERVER_ADDRESS_XPIP_ADAPTER_DNS_SERVER_ADDRESS_XPIP_ADAPTER_DNS_SERVER_ADDRESSPIP_ADAPTER_DNS_SERVER_ADDRESSPIP_ADAPTER_WINS_SERVER_ADDRESS_LHIP_ADAPTER_WINS_SERVER_ADDRESS_LHIP_ADAPTER_WINS_SERVER_ADDRESSPIP_ADAPTER_WINS_SERVER_ADDRESSPIP_ADAPTER_GATEWAY_ADDRESS_LHIP_ADAPTER_GATEWAY_ADDRESS_LHIP_ADAPTER_GATEWAY_ADDRESSPIP_ADAPTER_GATEWAY_ADDRESSPIP_ADAPTER_PREFIX_XPIP_ADAPTER_PREFIX_XPIP_ADAPTER_PREFIXPIP_ADAPTER_PREFIXPIP_ADAPTER_DNS_SUFFIXIP_ADAPTER_DNS_SUFFIXIP_ADAPTER_DDNS_ENABLEDIP_ADAPTER_REGISTER_ADAPTER_SUFFIXIP_ADAPTER_DHCP_ENABLEDIP_ADAPTER_RECEIVE_ONLYIP_ADAPTER_NO_MULTICASTIP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIGIP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLEDIP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIGPIP_ADAPTER_ADDRESSES_LHPIP_ADAPTER_ADDRESSES_XPIP_ADAPTER_ADDRESSES_XPIP_ADAPTER_ADDRESSES// pub type IP_ADAPTER_ADDRESSES = IP_ADAPTER_ADDRESSES_XP;GAA_FLAG_SKIP_UNICASTGAA_FLAG_INCLUDE_PREFIXGAA_FLAG_SKIP_FRIENDLY_NAMEGAA_FLAG_INCLUDE_WINS_INFOGAA_FLAG_INCLUDE_ALL_INTERFACESGAA_FLAG_INCLUDE_ALL_COMPARTMENTSGAA_FLAG_INCLUDE_TUNNEL_BINDINGORDERPIP_PER_ADAPTER_INFO_W2KSP1IP_PER_ADAPTER_INFO_W2KSP1IP_PER_ADAPTER_INFOPFIXED_INFO_W2KSP1FIXED_INFO_W2KSP1FIXED_INFOPIP_INTERFACE_NAME_INFO_W2KSP1IP_INTERFACE_NAME_INFO_W2KSP1IP_INTERFACE_NAME_INFOIsProcessInJobJOBOBJECTINFOCLASSCreateJobObjectWFreeMemoryJobObjectOpenJobObjectWAssignProcessToJobObjectTerminateJobObjectSetInformationJobObjectSetIoRateControlInformationJobObjectJOBOBJECT_IO_RATE_CONTROL_INFORMATIONQueryInformationJobObjectQueryIoRateControlInformationJobObjectCreateTransactionCommitTransaction// pub fn OpenTransaction();RollbackTransaction// pub fn CommitTransactionAsync();// pub fn RollbackTransactionAsync();// pub fn GetTransactionId();// pub fn GetTransactionInformation();// pub fn SetTransactionInformation();// pub fn CreateTransactionManager();// pub fn OpenTransactionManager();// pub fn OpenTransactionManagerById();// pub fn RenameTransactionManager();// pub fn RollforwardTransactionManager();// pub fn RecoverTransactionManager();// pub fn GetCurrentClockTransactionManager();// pub fn GetTransactionManagerId();// pub fn CreateResourceManager();// pub fn OpenResourceManager();// pub fn RecoverResourceManager();// pub fn GetNotificationResourceManager();// pub fn GetNotificationResourceManagerAsync();// pub fn SetResourceManagerCompletionPort();// pub fn CreateEnlistment();// pub fn OpenEnlistment();// pub fn RecoverEnlistment();// pub fn GetEnlistmentRecoveryInformation();// pub fn GetEnlistmentId();// pub fn SetEnlistmentRecoveryInformation();// pub fn PrepareEnlistment();// pub fn PrePrepareEnlistment();// pub fn CommitEnlistment();// pub fn RollbackEnlistment();// pub fn PrePrepareComplete();// pub fn PrepareComplete();// pub fn ReadOnlyEnlistment();// pub fn CommitComplete();// pub fn RollbackComplete();// pub fn SinglePhaseReject();//! FFI bindings to ktmw32.L2_PROFILE_MAX_NAME_LENGTHL2_NOTIFICATION_SOURCE_NONEL2_NOTIFICATION_SOURCE_DOT3_AUTO_CONFIGL2_NOTIFICATION_SOURCE_SECURITYL2_NOTIFICATION_SOURCE_ONEXL2_NOTIFICATION_SOURCE_WLAN_ACML2_NOTIFICATION_SOURCE_WLAN_MSML2_NOTIFICATION_SOURCE_WLAN_SECURITYL2_NOTIFICATION_SOURCE_WLAN_IHVL2_NOTIFICATION_SOURCE_WLAN_HNWKL2_NOTIFICATION_SOURCE_WCML2_NOTIFICATION_SOURCE_WCM_CSPL2_NOTIFICATION_SOURCE_WFDL2_NOTIFICATION_SOURCE_ALLL2_NOTIFICATION_CODE_PUBLIC_BEGINL2_NOTIFICATION_CODE_GROUP_SIZEL2_NOTIFICATION_CODE_V2_BEGINL2_REASON_CODE_GROUP_SIZEL2_REASON_CODE_GEN_BASEL2_REASON_CODE_DOT11_AC_BASEL2_REASON_CODE_DOT11_MSM_BASEL2_REASON_CODE_DOT11_SECURITY_BASEL2_REASON_CODE_DOT3_AC_BASEL2_REASON_CODE_DOT3_MSM_BASEL2_REASON_CODE_PROFILE_BASEL2_REASON_CODE_IHV_BASEL2_REASON_CODE_WIMAX_BASEL2_REASON_CODE_SUCCESSL2_REASON_CODE_UNKNOWNL2_REASON_CODE_PROFILE_MISSINGPL2_NOTIFICATION_DATAL2_NOTIFICATION_DATA//! Definitions and data structures for common layer 2.HRSRCGET_MODULE_HANDLE_EX_FLAG_PINGET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNTGET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESSDONT_RESOLVE_DLL_REFERENCESLOAD_LIBRARY_SEARCH_SYSTEM32_NO_FORWARDERLOAD_LIBRARY_OS_INTEGRITY_CONTINUITYDisableThreadLibraryCallsFindResourceExWFindStringOrdinalFreeLibraryAndExitThreadFreeResourceGetModuleFileNameAGetModuleHandleExALoadLibraryExALoadResourceLoadStringALoadStringWLockResourceSizeofResourceDLL_DIRECTORY_COOKIEPDLL_DIRECTORY_COOKIEAddDllDirectoryRemoveDllDirectorySetDefaultDllDirectoriesEnumResourceLanguagesExAENUMRESLANGPROCAEnumResourceLanguagesExWENUMRESLANGPROCWEnumResourceNamesExAENUMRESNAMEPROCAEnumResourceNamesExWENUMRESNAMEPROCWEnumResourceTypesExAENUMRESTYPEPROCAEnumResourceTypesExWENUMRESTYPEPROCWFindResourceWEnumResourceNamesW//! ApiSet Contract for api-ms-win-core-libraryloader-l1// This file contains structures, function prototypes, and definitions// for the NetUser, NetUserModals, NetGroup, NetAccess, and NetLogon API.SID_NAME_USENetUserAddNetUserSetInfoNetUserDelNetUserGetGroupsNetUserSetGroupsNetUserModalsGetNetUserModalsSetNetUserChangePasswordPUSER_INFO_0LPUSER_INFO_0PUSER_INFO_1USER_INFO_1LPUSER_INFO_1PUSER_INFO_2USER_INFO_2LPUSER_INFO_2PUSER_INFO_3USER_INFO_3LPUSER_INFO_3PUSER_INFO_4USER_INFO_4LPUSER_INFO_4PUSER_INFO_10USER_INFO_10LPUSER_INFO_10PUSER_INFO_11USER_INFO_11LPUSER_INFO_11PUSER_INFO_20USER_INFO_20LPUSER_INFO_20PUSER_INFO_21USER_INFO_21LPUSER_INFO_21PUSER_INFO_22USER_INFO_22LPUSER_INFO_22PUSER_INFO_23LPUSER_INFO_23PUSER_INFO_24USER_INFO_24LPUSER_INFO_24PUSER_INFO_1003USER_INFO_1003LPUSER_INFO_1003PUSER_INFO_1005USER_INFO_1005LPUSER_INFO_1005PUSER_INFO_1006USER_INFO_1006LPUSER_INFO_1006PUSER_INFO_1007USER_INFO_1007LPUSER_INFO_1007PUSER_INFO_1008USER_INFO_1008LPUSER_INFO_1008PUSER_INFO_1009USER_INFO_1009LPUSER_INFO_1009PUSER_INFO_1010USER_INFO_1010LPUSER_INFO_1010PUSER_INFO_1011USER_INFO_1011LPUSER_INFO_1011PUSER_INFO_1012USER_INFO_1012LPUSER_INFO_1012PUSER_INFO_1013USER_INFO_1013LPUSER_INFO_1013PUSER_INFO_1014USER_INFO_1014LPUSER_INFO_1014PUSER_INFO_1017USER_INFO_1017LPUSER_INFO_1017PUSER_INFO_1018USER_INFO_1018LPUSER_INFO_1018PUSER_INFO_1020USER_INFO_1020LPUSER_INFO_1020PUSER_INFO_1023USER_INFO_1023LPUSER_INFO_1023PUSER_INFO_1024USER_INFO_1024LPUSER_INFO_1024PUSER_INFO_1025USER_INFO_1025LPUSER_INFO_1025PUSER_INFO_1051USER_INFO_1051LPUSER_INFO_1051PUSER_INFO_1052USER_INFO_1052LPUSER_INFO_1052PUSER_INFO_1053USER_INFO_1053LPUSER_INFO_1053PUSER_MODALS_INFO_0USER_MODALS_INFO_0LPUSER_MODALS_INFO_0PUSER_MODALS_INFO_1USER_MODALS_INFO_1LPUSER_MODALS_INFO_1PUSER_MODALS_INFO_2USER_MODALS_INFO_2LPUSER_MODALS_INFO_2PUSER_MODALS_INFO_3USER_MODALS_INFO_3LPUSER_MODALS_INFO_3PUSER_MODALS_INFO_1001USER_MODALS_INFO_1001LPUSER_MODALS_INFO_1001PUSER_MODALS_INFO_1002USER_MODALS_INFO_1002LPUSER_MODALS_INFO_1002PUSER_MODALS_INFO_1003USER_MODALS_INFO_1003LPUSER_MODALS_INFO_1003PUSER_MODALS_INFO_1004USER_MODALS_INFO_1004LPUSER_MODALS_INFO_1004PUSER_MODALS_INFO_1005USER_MODALS_INFO_1005LPUSER_MODALS_INFO_1005PUSER_MODALS_INFO_1006USER_MODALS_INFO_1006LPUSER_MODALS_INFO_1006PUSER_MODALS_INFO_1007USER_MODALS_INFO_1007LPUSER_MODALS_INFO_1007UF_SCRIPTUF_ACCOUNTDISABLEUF_HOMEDIR_REQUIREDUF_LOCKOUTUF_PASSWD_NOTREQDUF_PASSWD_CANT_CHANGEUF_ENCRYPTED_TEXT_PASSWORD_ALLOWEDUF_TEMP_DUPLICATE_ACCOUNTUF_NORMAL_ACCOUNTUF_INTERDOMAIN_TRUST_ACCOUNTUF_WORKSTATION_TRUST_ACCOUNTUF_SERVER_TRUST_ACCOUNTUF_MACHINE_ACCOUNT_MASKUF_ACCOUNT_TYPE_MASKUF_DONT_EXPIRE_PASSWDUF_MNS_LOGON_ACCOUNTUF_SMARTCARD_REQUIREDUF_TRUSTED_FOR_DELEGATIONUF_NOT_DELEGATEDUF_USE_DES_KEY_ONLYUF_DONT_REQUIRE_PREAUTHUF_PASSWORD_EXPIREDUF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATIONUF_NO_AUTH_DATA_REQUIREDUF_PARTIAL_SECRETS_ACCOUNTUF_USE_AES_KEYSUF_SETTABLE_BITSFILTER_TEMP_DUPLICATE_ACCOUNTFILTER_INTERDOMAIN_TRUST_ACCOUNTFILTER_WORKSTATION_TRUST_ACCOUNTFILTER_SERVER_TRUST_ACCOUNTAF_OP_PRINTAF_OP_COMMAF_OP_SERVERAF_OP_ACCOUNTSAF_SETTABLE_BITSUAS_ROLE_STANDALONEUAS_ROLE_MEMBERUAS_ROLE_BACKUPUAS_ROLE_PRIMARYUSER_NAME_PARMNUMUSER_PASSWORD_PARMNUMUSER_PASSWORD_AGE_PARMNUMUSER_PRIV_PARMNUMUSER_HOME_DIR_PARMNUMUSER_COMMENT_PARMNUMUSER_FLAGS_PARMNUMUSER_SCRIPT_PATH_PARMNUMUSER_AUTH_FLAGS_PARMNUMUSER_FULL_NAME_PARMNUMUSER_USR_COMMENT_PARMNUMUSER_PARMS_PARMNUMUSER_WORKSTATIONS_PARMNUMUSER_LAST_LOGON_PARMNUMUSER_LAST_LOGOFF_PARMNUMUSER_ACCT_EXPIRES_PARMNUMUSER_MAX_STORAGE_PARMNUMUSER_UNITS_PER_WEEK_PARMNUMUSER_LOGON_HOURS_PARMNUMUSER_PAD_PW_COUNT_PARMNUMUSER_NUM_LOGONS_PARMNUMUSER_LOGON_SERVER_PARMNUMUSER_COUNTRY_CODE_PARMNUMUSER_CODE_PAGE_PARMNUMUSER_PRIMARY_GROUP_PARMNUMUSER_PROFILEUSER_PROFILE_PARMNUMUSER_HOME_DIR_DRIVE_PARMNUMUSER_NAME_INFOLEVELUSER_PASSWORD_INFOLEVELUSER_PASSWORD_AGE_INFOLEVELUSER_PRIV_INFOLEVELUSER_HOME_DIR_INFOLEVELUSER_COMMENT_INFOLEVELUSER_FLAGS_INFOLEVELUSER_SCRIPT_PATH_INFOLEVELUSER_AUTH_FLAGS_INFOLEVELUSER_FULL_NAME_INFOLEVELUSER_USR_COMMENT_INFOLEVELUSER_PARMS_INFOLEVELUSER_WORKSTATIONS_INFOLEVELUSER_LAST_LOGON_INFOLEVELUSER_LAST_LOGOFF_INFOLEVELUSER_ACCT_EXPIRES_INFOLEVELUSER_MAX_STORAGE_INFOLEVELUSER_UNITS_PER_WEEK_INFOLEVELUSER_LOGON_HOURS_INFOLEVELUSER_PAD_PW_COUNT_INFOLEVELUSER_NUM_LOGONS_INFOLEVELUSER_LOGON_SERVER_INFOLEVELUSER_COUNTRY_CODE_INFOLEVELUSER_CODE_PAGE_INFOLEVELUSER_PRIMARY_GROUP_INFOLEVELUSER_HOME_DIR_DRIVE_INFOLEVELNULL_USERSETINFO_PASSWDTIMEQ_FOREVERUSER_MAXSTORAGE_UNLIMITEDUSER_NO_LOGOFFUNITS_PER_DAYUNITS_PER_WEEKUSER_PRIV_MASKUSER_PRIV_GUESTUSER_PRIV_USERUSER_PRIV_ADMINMAX_PASSWD_LENDEF_MIN_PWLENDEF_PWUNIQUENESSDEF_MAX_PWHISTDEF_MAX_PWAGEDEF_MIN_PWAGEDEF_FORCE_LOGOFFDEF_MAX_BADPWONE_DAYVALIDATED_LOGONPASSWORD_EXPIREDNON_VALIDATED_LOGONVALID_LOGOFFMODALS_MIN_PASSWD_LEN_PARMNUMMODALS_MAX_PASSWD_AGE_PARMNUMMODALS_MIN_PASSWD_AGE_PARMNUMMODALS_FORCE_LOGOFF_PARMNUMMODALS_PASSWD_HIST_LEN_PARMNUMMODALS_ROLE_PARMNUMMODALS_PRIMARY_PARMNUMMODALS_DOMAIN_NAME_PARMNUMMODALS_DOMAIN_ID_PARMNUMMODALS_LOCKOUT_DURATION_PARMNUMMODALS_LOCKOUT_OBSERVATION_WINDOW_PARMNUMMODALS_LOCKOUT_THRESHOLD_PARMNUMMODALS_MIN_PASSWD_LEN_INFOLEVELMODALS_MAX_PASSWD_AGE_INFOLEVELMODALS_MIN_PASSWD_AGE_INFOLEVELMODALS_FORCE_LOGOFF_INFOLEVELMODALS_PASSWD_HIST_LEN_INFOLEVELMODALS_ROLE_INFOLEVELMODALS_PRIMARY_INFOLEVELMODALS_DOMAIN_NAME_INFOLEVELMODALS_DOMAIN_ID_INFOLEVELNetGroupAddNetGroupAddUserNetGroupEnumNetGroupGetInfoNetGroupSetInfoNetGroupDelNetGroupDelUserNetGroupGetUsersNetGroupSetUsersPGROUP_INFO_0GROUP_INFO_0LPGROUP_INFO_0PGROUP_INFO_1GROUP_INFO_1LPGROUP_INFO_1PGROUP_INFO_2GROUP_INFO_2PGROUP_INFO_3GROUP_INFO_3PGROUP_INFO_1002GROUP_INFO_1002LPGROUP_INFO_1002PGROUP_INFO_1005GROUP_INFO_1005LPGROUP_INFO_1005PGROUP_USERS_INFO_0GROUP_USERS_INFO_0LPGROUP_USERS_INFO_0PGROUP_USERS_INFO_1GROUP_USERS_INFO_1LPGROUP_USERS_INFO_1GROUPIDMASKGROUP_SPECIALGRP_USERSGROUP_SPECIALGRP_ADMINSGROUP_SPECIALGRP_GUESTSGROUP_SPECIALGRP_LOCALGROUP_ALL_PARMNUMGROUP_NAME_PARMNUMGROUP_COMMENT_PARMNUMGROUP_ATTRIBUTES_PARMNUMGROUP_ALL_INFOLEVELGROUP_NAME_INFOLEVELGROUP_COMMENT_INFOLEVELGROUP_ATTRIBUTES_INFOLEVELNetLocalGroupAddNetLocalGroupAddMemberNetLocalGroupEnumNetLocalGroupGetInfoNetLocalGroupSetInfoNetLocalGroupDelNetLocalGroupDelMemberNetLocalGroupGetMembersNetLocalGroupSetMembersNetLocalGroupAddMembersNetLocalGroupDelMembersPLOCALGROUP_INFO_0LOCALGROUP_INFO_0LPLOCALGROUP_INFO_0PLOCALGROUP_INFO_1LOCALGROUP_INFO_1LPLOCALGROUP_INFO_1PLOCALGROUP_INFO_1002LOCALGROUP_INFO_1002LPLOCALGROUP_INFO_1002PLOCALGROUP_MEMBERS_INFO_0LOCALGROUP_MEMBERS_INFO_0LPLOCALGROUP_MEMBERS_INFO_0PLOCALGROUP_MEMBERS_INFO_1LOCALGROUP_MEMBERS_INFO_1LPLOCALGROUP_MEMBERS_INFO_1PLOCALGROUP_MEMBERS_INFO_2LOCALGROUP_MEMBERS_INFO_2LPLOCALGROUP_MEMBERS_INFO_2PLOCALGROUP_MEMBERS_INFO_3LOCALGROUP_MEMBERS_INFO_3LPLOCALGROUP_MEMBERS_INFO_3PLOCALGROUP_USERS_INFO_0LPLOCALGROUP_USERS_INFO_0LOCALGROUP_NAME_PARMNUMLOCALGROUP_COMMENT_PARMNUMNetQueryDisplayInformationNetGetDisplayInformationIndexPNET_DISPLAY_USERNET_DISPLAY_USERPNET_DISPLAY_MACHINENET_DISPLAY_MACHINEPNET_DISPLAY_GROUPNET_DISPLAY_GROUPNetAccessAddNetAccessEnumNetAccessGetInfoNetAccessSetInfoNetAccessDelNetAccessGetUserPermsPACCESS_INFO_0ACCESS_INFO_0LPACCESS_INFO_0PACCESS_INFO_1ACCESS_INFO_1LPACCESS_INFO_1PACCESS_INFO_1002ACCESS_INFO_1002LPACCESS_INFO_1002PACCESS_LISTACCESS_LISTLPACCESS_LISTMAXPERMENTRIESACCESS_NONEACCESS_ALLACCESS_READACCESS_WRITEACCESS_CREATEACCESS_EXECACCESS_DELETEACCESS_ATRIBACCESS_PERMACCESS_GROUPACCESS_AUDITACCESS_SUCCESS_OPENACCESS_SUCCESS_WRITEACCESS_SUCCESS_DELETEACCESS_SUCCESS_ACLACCESS_SUCCESS_MASKACCESS_FAIL_OPENACCESS_FAIL_WRITEACCESS_FAIL_DELETEACCESS_FAIL_ACLACCESS_FAIL_MASKACCESS_FAIL_SHIFTACCESS_RESOURCE_NAME_PARMNUMACCESS_ATTR_PARMNUMACCESS_COUNT_PARMNUMACCESS_ACCESS_LIST_PARMNUMACCESS_RESOURCE_NAME_INFOLEVELACCESS_ATTR_INFOLEVELACCESS_COUNT_INFOLEVELACCESS_ACCESS_LIST_INFOLEVELACCESS_LETTERSPNET_VALIDATE_PASSWORD_TYPENET_VALIDATE_PASSWORD_TYPEPNET_VALIDATE_PASSWORD_HASHNET_VALIDATE_PASSWORD_HASHNET_VALIDATE_PASSWORD_LAST_SETNET_VALIDATE_BAD_PASSWORD_TIMENET_VALIDATE_LOCKOUT_TIMENET_VALIDATE_BAD_PASSWORD_COUNTNET_VALIDATE_PASSWORD_HISTORY_LENGTHNET_VALIDATE_PASSWORD_HISTORYPNET_VALIDATE_PERSISTED_FIELDSNET_VALIDATE_PERSISTED_FIELDSPNET_VALIDATE_OUTPUT_ARGNET_VALIDATE_OUTPUT_ARGPNET_VALIDATE_AUTHENTICATION_INPUT_ARGNET_VALIDATE_AUTHENTICATION_INPUT_ARGPNET_VALIDATE_PASSWORD_CHANGE_INPUT_ARGNET_VALIDATE_PASSWORD_CHANGE_INPUT_ARGPNET_VALIDATE_PASSWORD_RESET_INPUT_ARGNET_VALIDATE_PASSWORD_RESET_INPUT_ARGNetValidatePasswordPolicyNetValidatePasswordPolicyFreeNetGetDCNameNetGetAnyDCNameI_NetLogonControlI_NetLogonControl2NetEnumerateTrustedDomainsNETLOGON_CONTROL_QUERYNETLOGON_CONTROL_REPLICATENETLOGON_CONTROL_SYNCHRONIZENETLOGON_CONTROL_PDC_REPLICATENETLOGON_CONTROL_REDISCOVERNETLOGON_CONTROL_TC_QUERYNETLOGON_CONTROL_TRANSPORT_NOTIFYNETLOGON_CONTROL_FIND_USERNETLOGON_CONTROL_CHANGE_PASSWORDNETLOGON_CONTROL_TC_VERIFYNETLOGON_CONTROL_FORCE_DNS_REGNETLOGON_CONTROL_QUERY_DNS_REGNETLOGON_CONTROL_QUERY_ENC_TYPESNETLOGON_CONTROL_UNLOAD_NETLOGON_DLLNETLOGON_CONTROL_BACKUP_CHANGE_LOGNETLOGON_CONTROL_TRUNCATE_LOGNETLOGON_CONTROL_SET_DBFLAGNETLOGON_CONTROL_BREAKPOINTPNETLOGON_INFO_1NETLOGON_INFO_1PNETLOGON_INFO_2NETLOGON_INFO_2PNETLOGON_INFO_3NETLOGON_INFO_3PNETLOGON_INFO_4NETLOGON_INFO_4NETLOGON_REPLICATION_NEEDEDNETLOGON_REPLICATION_IN_PROGRESSNETLOGON_FULL_SYNC_REPLICATIONNETLOGON_REDO_NEEDEDNETLOGON_HAS_IPNETLOGON_HAS_TIMESERVNETLOGON_DNS_UPDATE_FAILURENETLOGON_VERIFY_STATUS_RETURNEDSERVICE_ACCOUNT_PASSWORDSERVICE_ACCOUNT_SECRET_PREFIXNetAddServiceAccountSERVICE_ACCOUNT_FLAG_LINK_TO_HOST_ONLYSERVICE_ACCOUNT_FLAG_ADD_AGAINST_RODCSERVICE_ACCOUNT_FLAG_UNLINK_FROM_HOST_ONLYSERVICE_ACCOUNT_FLAG_REMOVE_OFFLINENetRemoveServiceAccountNetEnumerateServiceAccountsNetIsServiceAccountNetQueryServiceAccountPMSA_INFO_LEVELMSA_INFO_LEVELPMSA_INFO_STATEMSA_INFO_STATEPMSA_INFO_0MSA_INFO_0LPMSA_INFO_0NetAlertRaiseNetAlertRaiseExPSTD_ALERTSTD_ALERTLPSTD_ALERTPADMIN_OTHER_INFOADMIN_OTHER_INFOLPADMIN_OTHER_INFOPERRLOG_OTHER_INFOERRLOG_OTHER_INFOLPERRLOG_OTHER_INFOPPRINT_OTHER_INFOPRINT_OTHER_INFOLPPRINT_OTHER_INFOPUSER_OTHER_INFOUSER_OTHER_INFOLPUSER_OTHER_INFOALERTER_MAILSLOTALERT_PRINT_EVENTALERT_MESSAGE_EVENTALERT_ERRORLOG_EVENTALERT_ADMIN_EVENTALERT_USER_EVENTPRJOB_QSTATUSPRJOB_DEVSTATUSPRJOB_COMPLETEPRJOB_INTERVPRJOB_ERRORPRJOB_DESTOFFLINEPRJOB_DESTPAUSEDPRJOB_NOTIFYPRJOB_DESTNOPAPERPRJOB_DELETEDPRJOB_QS_QUEUEDPRJOB_QS_PAUSEDPRJOB_QS_SPOOLINGPRJOB_QS_PRINTING//! This file contains structures for communication with the Alerter serviceNetApiBufferAllocateNetApiBufferReallocateNetApiBufferSizeNetapipBufferAllocate//! This file contains information about NetApiBuffer APIsJOB_RUN_PERIODICALLYJOB_EXEC_ERRORJOB_RUNS_TODAYJOB_ADD_CURRENT_DATEJOB_NONINTERACTIVEJOB_INPUT_FLAGSJOB_OUTPUT_FLAGSPAT_INFOAT_INFOLPAT_INFOPAT_ENUMAT_ENUMLPAT_ENUMNetScheduleJobAddNetScheduleJobDelNetScheduleJobEnumNetScheduleJobGetInfo// This file contains structures, function prototypes, and definitions for the NetDfs APIDFS_VOLUME_STATESDFS_VOLUME_STATE_OKDFS_VOLUME_STATE_INCONSISTENTDFS_VOLUME_STATE_OFFLINEDFS_VOLUME_STATE_ONLINEDFS_VOLUME_STATE_RESYNCHRONIZEDFS_VOLUME_STATE_STANDBYDFS_VOLUME_STATE_FORCE_SYNCDFS_VOLUME_FLAVORSDFS_VOLUME_FLAVOR_UNUSED1DFS_VOLUME_FLAVOR_STANDALONEDFS_VOLUME_FLAVOR_AD_BLOBDFS_STORAGE_FLAVOR_UNUSED2DFS_STORAGE_STATESDFS_STORAGE_STATE_OFFLINEDFS_STORAGE_STATE_ONLINEDFS_STORAGE_STATE_ACTIVEPDFS_TARGET_PRIORITYDFS_TARGET_PRIORITYPDFS_INFO_1DFS_INFO_1LPDFS_INFO_1PDFS_INFO_2DFS_INFO_2LPDFS_INFO_2PDFS_STORAGE_INFODFS_STORAGE_INFOLPDFS_STORAGE_INFOPDFS_STORAGE_INFO_1DFS_STORAGE_INFO_1LPDFS_STORAGE_INFO_1PDFS_INFO_3DFS_INFO_3LPDFS_INFO_3PDFS_INFO_4DFS_INFO_4LPDFS_INFO_4PDFS_INFO_5DFS_INFO_5LPDFS_INFO_5PDFS_INFO_6DFS_INFO_6LPDFS_INFO_6PDFS_INFO_7DFS_INFO_7LPDFS_INFO_7PDFS_INFO_8DFS_INFO_8LPDFS_INFO_8PDFS_INFO_9DFS_INFO_9LPDFS_INFO_9DFS_VALID_PROPERTY_FLAGSDFS_PROPERTY_FLAG_INSITE_REFERRALSDFS_PROPERTY_FLAG_ROOT_SCALABILITYDFS_PROPERTY_FLAG_SITE_COSTINGDFS_PROPERTY_FLAG_TARGET_FAILBACKDFS_PROPERTY_FLAG_CLUSTER_ENABLEDDFS_PROPERTY_FLAG_ABDEPDFS_INFO_50DFS_INFO_50LPDFS_INFO_50PDFS_INFO_100DFS_INFO_100LPDFS_INFO_100PDFS_INFO_101DFS_INFO_101LPDFS_INFO_101PDFS_INFO_102DFS_INFO_102LPDFS_INFO_102PDFS_INFO_103DFS_INFO_103LPDFS_INFO_103PDFS_INFO_104DFS_INFO_104LPDFS_INFO_104PDFS_INFO_105DFS_INFO_105LPDFS_INFO_105PDFS_INFO_106DFS_INFO_106LPDFS_INFO_106PDFS_INFO_107DFS_INFO_107LPDFS_INFO_107PDFS_INFO_150DFS_INFO_150LPDFS_INFO_150PDFS_INFO_200DFS_INFO_200LPDFS_INFO_200PDFS_INFO_300DFS_INFO_300LPDFS_INFO_300NetDfsAddDFS_ADD_VOLUMEDFS_RESTORE_VOLUMENetDfsAddStdRootNetDfsRemoveStdRootNetDfsAddFtRootNetDfsRemoveFtRootNetDfsRemoveFtRootForcedNET_DFS_SETDC_FLAGSNET_DFS_SETDC_TIMEOUTNET_DFS_SETDC_INITPKTPDFS_SITENAME_INFODFS_SITENAME_INFOLPDFS_SITENAME_INFODFS_SITE_PRIMARYPDFS_SITELIST_INFODFS_SITELIST_INFOLPDFS_SITELIST_INFONetDfsRemoveNetDfsEnumNetDfsGetInfoNetDfsSetInfoNetDfsGetClientInfoNetDfsSetClientInfoNetDfsMoveDFS_MOVE_FLAG_REPLACE_IF_EXISTSNetDfsRenameNetDfsAddRootTargetDFS_FORCE_REMOVENetDfsRemoveRootTargetNetDfsGetSecurityNetDfsSetSecurityNetDfsGetStdContainerSecurityNetDfsSetStdContainerSecurityNetDfsGetFtContainerSecurityNetDfsSetFtContainerSecurityPDFS_NAMESPACE_VERSION_ORIGINDFS_NAMESPACE_VERSION_ORIGINDFS_NAMESPACE_CAPABILITY_ABDEPDFS_SUPPORTED_NAMESPACE_VERSION_INFODFS_SUPPORTED_NAMESPACE_VERSION_INFONetDfsGetSupportedNamespaceVersionPDFS_GET_PKT_ENTRY_STATE_ARGDFS_GET_PKT_ENTRY_STATE_ARGPERROR_LOGERROR_LOGLPERROR_LOGPHLOGHLOGLPHLOGLOGFLAGS_FORWARDLOGFLAGS_BACKWARDLOGFLAGS_SEEKERRLOG_BASENELOG_Internal_ErrorNELOG_Resource_ShortageNELOG_Unable_To_Lock_SegmentNELOG_Unable_To_Unlock_SegmentNELOG_Uninstall_ServiceNELOG_Init_Exec_FailNELOG_Ncb_ErrorNELOG_Net_Not_StartedNELOG_Ioctl_ErrorNELOG_System_SemaphoreNELOG_Init_OpenCreate_ErrNELOG_NetBiosNELOG_SMB_IllegalNELOG_Service_FailNELOG_Entries_LostNELOG_Init_Seg_OverflowNELOG_Srv_No_Mem_GrowNELOG_Access_File_BadNELOG_Srvnet_Not_StartedNELOG_Init_Chardev_ErrNELOG_Remote_APINELOG_Ncb_TooManyErrNELOG_Mailslot_errNELOG_ReleaseMem_AlertNELOG_AT_cannot_writeNELOG_Cant_Make_Msg_FileNELOG_Exec_Netservr_NoMemNELOG_Server_Lock_FailureNELOG_Msg_ShutdownNELOG_Msg_Sem_ShutdownNELOG_Msg_Log_ErrNELOG_VIO_POPUP_ERRNELOG_Msg_Unexpected_SMB_TypeNELOG_Wksta_InfosegNELOG_Wksta_CompnameNELOG_Wksta_BiosThreadFailureNELOG_Wksta_IniSegNELOG_Wksta_HostTab_FullNELOG_Wksta_Bad_Mailslot_SMBNELOG_Wksta_UASInitNELOG_Wksta_SSIRelogonNELOG_Build_NameNELOG_Name_ExpansionNELOG_Message_SendNELOG_Mail_Slt_ErrNELOG_AT_cannot_readNELOG_AT_sched_errNELOG_AT_schedule_file_createdNELOG_Srvnet_NB_OpenNELOG_AT_Exec_ErrNELOG_Lazy_Write_ErrNELOG_HotFixNELOG_HardErr_From_ServerNELOG_LocalSecFail1NELOG_LocalSecFail2NELOG_LocalSecFail3NELOG_LocalSecGeneralFailNELOG_NetWkSta_Internal_ErrorNELOG_NetWkSta_No_ResourceNELOG_NetWkSta_SMB_ErrNELOG_NetWkSta_VC_ErrNELOG_NetWkSta_Stuck_VC_ErrNELOG_NetWkSta_NCB_ErrNELOG_NetWkSta_Write_Behind_ErrNELOG_NetWkSta_Reset_ErrNELOG_NetWkSta_Too_ManyNELOG_Srv_Thread_FailureNELOG_Srv_Close_FailureNELOG_ReplUserCurDirNELOG_ReplCannotMasterDirNELOG_ReplUpdateErrorNELOG_ReplLostMasterNELOG_NetlogonAuthDCFailNELOG_ReplLogonFailedNELOG_ReplNetErrNELOG_ReplMaxFilesNELOG_ReplMaxTreeDepthNELOG_ReplBadMsgNELOG_ReplSysErrNELOG_ReplUserLogedNELOG_ReplBadImportNELOG_ReplBadExportNELOG_ReplSignalFileErrNELOG_DiskFTNELOG_ReplAccessDeniedNELOG_NetlogonFailedPrimaryNELOG_NetlogonPasswdSetFailedNELOG_NetlogonTrackingErrorNELOG_NetlogonSyncErrorNELOG_NetlogonRequireSignOrSealErrorNELOG_UPS_PowerOutNELOG_UPS_ShutdownNELOG_UPS_CmdFileErrorNELOG_UPS_CannotOpenDriverNELOG_UPS_PowerBackNELOG_UPS_CmdFileConfigNELOG_UPS_CmdFileExecNELOG_Missing_ParameterNELOG_Invalid_Config_LineNELOG_Invalid_Config_FileNELOG_File_ChangedNELOG_Files_Dont_FitNELOG_Wrong_DLL_VersionNELOG_Error_in_DLLNELOG_System_ErrorNELOG_FT_ErrLog_Too_LargeNELOG_FT_Update_In_ProgressNELOG_Joined_DomainNELOG_Joined_WorkgroupNELOG_OEM_CodeERRLOG2_BASENELOG_NetlogonSSIInitErrorNELOG_NetlogonFailedToUpdateTrustListNELOG_NetlogonFailedToAddRpcInterfaceNELOG_NetlogonFailedToReadMailslotNELOG_NetlogonFailedToRegisterSCNELOG_NetlogonChangeLogCorruptNELOG_NetlogonFailedToCreateShareNELOG_NetlogonDownLevelLogonFailedNELOG_NetlogonDownLevelLogoffFailedNELOG_NetlogonNTLogonFailedNELOG_NetlogonNTLogoffFailedNELOG_NetlogonPartialSyncCallSuccessNELOG_NetlogonPartialSyncCallFailedNELOG_NetlogonFullSyncCallSuccessNELOG_NetlogonFullSyncCallFailedNELOG_NetlogonPartialSyncSuccessNELOG_NetlogonPartialSyncFailedNELOG_NetlogonFullSyncSuccessNELOG_NetlogonFullSyncFailedNELOG_NetlogonAuthNoDomainControllerNELOG_NetlogonAuthNoTrustLsaSecretNELOG_NetlogonAuthNoTrustSamAccountNELOG_NetlogonServerAuthFailedNELOG_NetlogonServerAuthNoTrustSamAccountNELOG_FailedToRegisterSCNELOG_FailedToSetServiceStatusNELOG_FailedToGetComputerNameNELOG_DriverNotLoadedNELOG_NoTranportLoadedNELOG_NetlogonFailedDomainDeltaNELOG_NetlogonFailedGlobalGroupDeltaNELOG_NetlogonFailedLocalGroupDeltaNELOG_NetlogonFailedUserDeltaNELOG_NetlogonFailedPolicyDeltaNELOG_NetlogonFailedTrustedDomainDeltaNELOG_NetlogonFailedAccountDeltaNELOG_NetlogonFailedSecretDeltaNELOG_NetlogonSystemErrorNELOG_NetlogonDuplicateMachineAccountsNELOG_NetlogonTooManyGlobalGroupsNELOG_NetlogonBrowserDriverNELOG_NetlogonAddNameFailureNELOG_RplMessagesNELOG_RplXnsBootNELOG_RplSystemNELOG_RplWkstaTimeoutNELOG_RplWkstaFileOpenNELOG_RplWkstaFileReadNELOG_RplWkstaMemoryNELOG_RplWkstaFileChecksumNELOG_RplWkstaFileLineCountNELOG_RplWkstaBbcFileNELOG_RplWkstaFileSizeNELOG_RplWkstaInternalNELOG_RplWkstaWrongVersionNELOG_RplWkstaNetworkNELOG_RplAdapterResourceNELOG_RplFileCopyNELOG_RplFileDeleteNELOG_RplFilePermsNELOG_RplCheckConfigsNELOG_RplCreateProfilesNELOG_RplRegistryNELOG_RplReplaceRPLDISKNELOG_RplCheckSecurityNELOG_RplBackupDatabaseNELOG_RplInitDatabaseNELOG_RplRestoreDatabaseFailureNELOG_RplRestoreDatabaseSuccessNELOG_RplInitRestoredDatabaseNELOG_NetlogonSessionTypeWrongNELOG_RplUpgradeDBTo40NELOG_NetlogonLanmanBdcsNotAllowedNELOG_NetlogonNoDynamicDnsNELOG_NetlogonDynamicDnsRegisterFailureNELOG_NetlogonDynamicDnsDeregisterFailureNELOG_NetlogonFailedFileCreateNELOG_NetlogonGetSubnetToSiteNELOG_NetlogonNoSiteForClientNELOG_NetlogonBadSiteNameNELOG_NetlogonBadSubnetNameNELOG_NetlogonDynamicDnsServerFailureNELOG_NetlogonDynamicDnsFailureNELOG_NetlogonRpcCallCancelledNELOG_NetlogonDcSiteCoveredNELOG_NetlogonDcSiteNotCoveredNELOG_NetlogonGcSiteCoveredNELOG_NetlogonGcSiteNotCoveredNELOG_NetlogonFailedSpnUpdateNELOG_NetlogonFailedDnsHostNameUpdateNELOG_NetlogonAuthNoUplevelDomainControllerNELOG_NetlogonAuthDomainDowngradedNELOG_NetlogonNdncSiteCoveredNELOG_NetlogonNdncSiteNotCoveredNELOG_NetlogonDcOldSiteCoveredNELOG_NetlogonDcSiteNotCoveredAutoNELOG_NetlogonGcOldSiteCoveredNELOG_NetlogonGcSiteNotCoveredAutoNELOG_NetlogonNdncOldSiteCoveredNELOG_NetlogonNdncSiteNotCoveredAutoNELOG_NetlogonSpnMultipleSamAccountNamesNELOG_NetlogonSpnCrackNamesFailureNELOG_NetlogonNoAddressToSiteMappingNELOG_NetlogonInvalidGenericParameterValueNELOG_NetlogonInvalidDwordParameterValueNELOG_NetlogonServerAuthFailedNoAccountNELOG_NetlogonNoDynamicDnsManualNELOG_NetlogonNoSiteForClientsNELOG_NetlogonDnsDeregAbortedNELOG_NetlogonRpcPortRequestFailureNELOG_NetlogonPartialSiteMappingForClientsNELOG_NetlogonRemoteDynamicDnsRegisterFailureNELOG_NetlogonRemoteDynamicDnsDeregisterFailureNELOG_NetlogonRejectedRemoteDynamicDnsRegisterNELOG_NetlogonRejectedRemoteDynamicDnsDeregisterNELOG_NetlogonRemoteDynamicDnsUpdateRequestFailureNELOG_NetlogonUserValidationReqInitialTimeOutNELOG_NetlogonUserValidationReqRecurringTimeOutNELOG_NetlogonUserValidationReqWaitInitialWarningNELOG_NetlogonUserValidationReqWaitRecurringWarningNELOG_NetlogonFailedToAddAuthzRpcInterfaceNELOG_NetLogonFailedToInitializeAuthzRmNELOG_NetLogonFailedToInitializeRPCSDNELOG_NetlogonMachinePasswdSetSucceededNELOG_NetlogonMsaPasswdSetSucceeded// Definitions and prototypes for the Net setup apisPCCERT_CONTEXTPNETSETUP_NAME_TYPENETSETUP_NAME_TYPEPDSREG_JOIN_TYPEDSREG_JOIN_TYPEPDSREG_USER_INFODSREG_USER_INFOPDSREG_JOIN_INFODSREG_JOIN_INFONETSETUP_JOIN_DOMAINNETSETUP_ACCT_CREATENETSETUP_ACCT_DELETENETSETUP_WIN9X_UPGRADENETSETUP_DOMAIN_JOIN_IF_JOINEDNETSETUP_JOIN_UNSECURENETSETUP_MACHINE_PWD_PASSEDNETSETUP_DEFER_SPN_SETNETSETUP_JOIN_DC_ACCOUNTNETSETUP_JOIN_WITH_NEW_NAMENETSETUP_JOIN_READONLYNETSETUP_DNS_NAME_CHANGES_ONLYNETSETUP_INSTALL_INVOCATIONNETSETUP_AMBIGUOUS_DCNETSETUP_NO_NETLOGON_CACHENETSETUP_DONT_CONTROL_SERVICESNETSETUP_SET_MACHINE_NAMENETSETUP_FORCE_SPN_SETNETSETUP_NO_ACCT_REUSENETSETUP_ALT_SAMACCOUNTNAMENETSETUP_IGNORE_UNSUPPORTED_FLAGSNETSETUP_VALID_UNJOIN_FLAGSNETSETUP_PROCESS_OFFLINE_FLAGSNetJoinDomainNetUnjoinDomainNetRenameMachineInDomainNetValidateNameNetGetJoinableOUsNET_IGNORE_UNSUPPORTED_FLAGSNetAddAlternateComputerNameNetRemoveAlternateComputerNameNetSetPrimaryComputerNamePNET_COMPUTER_NAME_TYPENET_COMPUTER_NAME_TYPENetEnumerateComputerNamesNETSETUP_PROVISION_DOWNLEVEL_PRIV_SUPPORTNETSETUP_PROVISION_REUSE_ACCOUNTNETSETUP_PROVISION_USE_DEFAULT_PASSWORDNETSETUP_PROVISION_SKIP_ACCOUNT_SEARCHNETSETUP_PROVISION_ROOT_CA_CERTSNETSETUP_PROVISION_PERSISTENTSITENETSETUP_PROVISION_ONLINE_CALLERNETSETUP_PROVISION_CHECK_PWD_ONLYNetProvisionComputerAccountNetRequestOfflineDomainJoinNETSETUP_PROVISIONING_PARAMS_WIN8_VERSIONNETSETUP_PROVISIONING_PARAMS_CURRENT_VERSIONPNETSETUP_PROVISIONING_PARAMSNETSETUP_PROVISIONING_PARAMSNetCreateProvisioningPackageNetRequestProvisioningPackageInstallNetGetAadJoinInformationNetFreeAadJoinInformationPNETSETUP_JOIN_STATUSNETSETUP_JOIN_STATUSNetGetJoinInformationNetMessageNameAddNetMessageNameEnumNetMessageNameGetInfoNetMessageNameDelNetMessageBufferSendPMSG_INFO_0MSG_INFO_0LPMSG_INFO_0PMSG_INFO_1MSG_INFO_1LPMSG_INFO_1MSGNAME_NOT_FORWARDEDMSGNAME_FORWARDED_TOMSGNAME_FORWARDED_FROM//! This file contains structures, function prototypes, and definitions for the NetMessage APIDESC_CHARLPDESCNetRemoteTODNetRemoteComputerSupportsRxRemoteApiPTIME_OF_DAY_INFOTIME_OF_DAY_INFOLPTIME_OF_DAY_INFOSUPPORTS_REMOTE_ADMIN_PROTOCOLSUPPORTS_RPCSUPPORTS_SAM_PROTOCOLSUPPORTS_UNICODESUPPORTS_LOCALSUPPORTS_ANYNO_PERMISSION_REQUIREDALLOCATE_RESPONSEUSE_SPECIFIC_TRANSPORT//! This file contains structures, function prototypes, and definitions for the NetRemote APIREPL_ROLE_EXPORTREPL_ROLE_IMPORTREPL_ROLE_BOTHREPL_INTERVAL_INFOLEVELREPL_PULSE_INFOLEVELREPL_GUARDTIME_INFOLEVELREPL_RANDOM_INFOLEVELPREPL_INFO_0REPL_INFO_0LPREPL_INFO_0PREPL_INFO_1000REPL_INFO_1000LPREPL_INFO_1000PREPL_INFO_1001REPL_INFO_1001LPREPL_INFO_1001PREPL_INFO_1002REPL_INFO_1002LPREPL_INFO_1002PREPL_INFO_1003REPL_INFO_1003LPREPL_INFO_1003NetReplGetInfoNetReplSetInfoREPL_INTEGRITY_FILEREPL_INTEGRITY_TREEREPL_EXTENT_FILEREPL_EXTENT_TREEREPL_EXPORT_INTEGRITY_INFOLEVELREPL_EXPORT_EXTENT_INFOLEVELPREPL_EDIR_INFO_0REPL_EDIR_INFO_0LPREPL_EDIR_INFO_0PREPL_EDIR_INFO_1REPL_EDIR_INFO_1LPREPL_EDIR_INFO_1PREPL_EDIR_INFO_2REPL_EDIR_INFO_2LPREPL_EDIR_INFO_2PREPL_EDIR_INFO_1000REPL_EDIR_INFO_1000LPREPL_EDIR_INFO_1000PREPL_EDIR_INFO_1001REPL_EDIR_INFO_1001LPREPL_EDIR_INFO_1001NetReplExportDirAddNetReplExportDirDelNetReplExportDirEnumNetReplExportDirGetInfoNetReplExportDirSetInfoNetReplExportDirLockNetReplExportDirUnlockREPL_UNLOCK_NOFORCEREPL_UNLOCK_FORCEPREPL_IDIR_INFO_0REPL_IDIR_INFO_0LPREPL_IDIR_INFO_0PREPL_IDIR_INFO_1REPL_IDIR_INFO_1LPREPL_IDIR_INFO_1NetReplImportDirAddNetReplImportDirDelNetReplImportDirEnumNetReplImportDirGetInfoNetReplImportDirLockNetReplImportDirUnlockREPL_STATE_OKREPL_STATE_NO_MASTERREPL_STATE_NO_SYNCREPL_STATE_NEVER_REPLICATED//! This file contains structures, function prototypes, and definitions for the replicator APIswinsvcSERVICE_STATUS_HANDLENetServerEnumNetServerEnumExNetServerGetInfoNetServerSetInfoNetServerDiskEnumNetServerComputerNameAddNetServerComputerNameDelNetServerTransportAddNetServerTransportAddExNetServerTransportDelNetServerTransportEnumSetServiceBitsPSERVER_INFO_100SERVER_INFO_100LPSERVER_INFO_100PSERVER_INFO_101SERVER_INFO_101LPSERVER_INFO_101PSERVER_INFO_102SERVER_INFO_102LPSERVER_INFO_102PSERVER_INFO_103SERVER_INFO_103LPSERVER_INFO_103PSERVER_INFO_402SERVER_INFO_402LPSERVER_INFO_402PSERVER_INFO_403SERVER_INFO_403LPSERVER_INFO_403PSERVER_INFO_502SERVER_INFO_502LPSERVER_INFO_502PSERVER_INFO_503SERVER_INFO_503LPSERVER_INFO_503PSERVER_INFO_599SERVER_INFO_599LPSERVER_INFO_599PSERVER_INFO_598SERVER_INFO_598LPSERVER_INFO_598PSERVER_INFO_1005SERVER_INFO_1005LPSERVER_INFO_1005PSERVER_INFO_1107SERVER_INFO_1107LPSERVER_INFO_1107PSERVER_INFO_1010SERVER_INFO_1010LPSERVER_INFO_1010PSERVER_INFO_1016SERVER_INFO_1016LPSERVER_INFO_1016PSERVER_INFO_1017SERVER_INFO_1017LPSERVER_INFO_1017PSERVER_INFO_1018SERVER_INFO_1018LPSERVER_INFO_1018PSERVER_INFO_1501SERVER_INFO_1501LPSERVER_INFO_1501PSERVER_INFO_1502SERVER_INFO_1502LPSERVER_INFO_1502PSERVER_INFO_1503SERVER_INFO_1503LPSERVER_INFO_1503PSERVER_INFO_1506SERVER_INFO_1506LPSERVER_INFO_1506PSERVER_INFO_1509SERVER_INFO_1509LPSERVER_INFO_1509PSERVER_INFO_1510SERVER_INFO_1510LPSERVER_INFO_1510PSERVER_INFO_1511SERVER_INFO_1511LPSERVER_INFO_1511PSERVER_INFO_1512SERVER_INFO_1512LPSERVER_INFO_1512PSERVER_INFO_1513SERVER_INFO_1513LPSERVER_INFO_1513PSERVER_INFO_1514SERVER_INFO_1514LPSERVER_INFO_1514PSERVER_INFO_1515SERVER_INFO_1515LPSERVER_INFO_1515PSERVER_INFO_1516SERVER_INFO_1516LPSERVER_INFO_1516PSERVER_INFO_1518SERVER_INFO_1518LPSERVER_INFO_1518PSERVER_INFO_1520SERVER_INFO_1520LPSERVER_INFO_1520PSERVER_INFO_1521SERVER_INFO_1521LPSERVER_INFO_1521PSERVER_INFO_1522SERVER_INFO_1522LPSERVER_INFO_1522PSERVER_INFO_1523SERVER_INFO_1523LPSERVER_INFO_1523PSERVER_INFO_1524SERVER_INFO_1524LPSERVER_INFO_1524PSERVER_INFO_1525SERVER_INFO_1525LPSERVER_INFO_1525PSERVER_INFO_1528SERVER_INFO_1528LPSERVER_INFO_1528PSERVER_INFO_1529SERVER_INFO_1529LPSERVER_INFO_1529PSERVER_INFO_1530SERVER_INFO_1530LPSERVER_INFO_1530PSERVER_INFO_1533SERVER_INFO_1533LPSERVER_INFO_1533PSERVER_INFO_1534SERVER_INFO_1534LPSERVER_INFO_1534PSERVER_INFO_1535SERVER_INFO_1535LPSERVER_INFO_1535PSERVER_INFO_1536SERVER_INFO_1536LPSERVER_INFO_1536PSERVER_INFO_1537SERVER_INFO_1537LPSERVER_INFO_1537PSERVER_INFO_1538SERVER_INFO_1538LPSERVER_INFO_1538PSERVER_INFO_1539SERVER_INFO_1539LPSERVER_INFO_1539PSERVER_INFO_1540SERVER_INFO_1540LPSERVER_INFO_1540PSERVER_INFO_1541SERVER_INFO_1541LPSERVER_INFO_1541PSERVER_INFO_1542SERVER_INFO_1542LPSERVER_INFO_1542PSERVER_INFO_1543SERVER_INFO_1543LPSERVER_INFO_1543PSERVER_INFO_1544SERVER_INFO_1544LPSERVER_INFO_1544PSERVER_INFO_1545SERVER_INFO_1545LPSERVER_INFO_1545PSERVER_INFO_1546SERVER_INFO_1546LPSERVER_INFO_1546PSERVER_INFO_1547SERVER_INFO_1547LPSERVER_INFO_1547PSERVER_INFO_1548SERVER_INFO_1548LPSERVER_INFO_1548PSERVER_INFO_1549SERVER_INFO_1549LPSERVER_INFO_1549PSERVER_INFO_1550SERVER_INFO_1550LPSERVER_INFO_1550PSERVER_INFO_1552SERVER_INFO_1552LPSERVER_INFO_1552PSERVER_INFO_1553SERVER_INFO_1553LPSERVER_INFO_1553PSERVER_INFO_1554SERVER_INFO_1554LPSERVER_INFO_1554PSERVER_INFO_1555SERVER_INFO_1555LPSERVER_INFO_1555PSERVER_INFO_1556SERVER_INFO_1556LPSERVER_INFO_1556PSERVER_INFO_1557SERVER_INFO_1557LPSERVER_INFO_1557PSERVER_INFO_1560SERVER_INFO_1560LPSERVER_INFO_1560PSERVER_INFO_1561SERVER_INFO_1561LPSERVER_INFO_1561PSERVER_INFO_1562SERVER_INFO_1562LPSERVER_INFO_1562PSERVER_INFO_1563SERVER_INFO_1563LPSERVER_INFO_1563PSERVER_INFO_1564SERVER_INFO_1564LPSERVER_INFO_1564PSERVER_INFO_1565SERVER_INFO_1565LPSERVER_INFO_1565PSERVER_INFO_1566SERVER_INFO_1566LPSERVER_INFO_1566PSERVER_INFO_1567SERVER_INFO_1567LPSERVER_INFO_1567PSERVER_INFO_1568SERVER_INFO_1568LPSERVER_INFO_1568PSERVER_INFO_1569SERVER_INFO_1569LPSERVER_INFO_1569PSERVER_INFO_1570SERVER_INFO_1570LPSERVER_INFO_1570PSERVER_INFO_1571SERVER_INFO_1571LPSERVER_INFO_1571PSERVER_INFO_1572SERVER_INFO_1572LPSERVER_INFO_1572PSERVER_INFO_1573SERVER_INFO_1573LPSERVER_INFO_1573PSERVER_INFO_1574SERVER_INFO_1574LPSERVER_INFO_1574PSERVER_INFO_1575SERVER_INFO_1575LPSERVER_INFO_1575PSERVER_INFO_1576SERVER_INFO_1576LPSERVER_INFO_1576PSERVER_INFO_1577SERVER_INFO_1577LPSERVER_INFO_1577PSERVER_INFO_1578SERVER_INFO_1578LPSERVER_INFO_1578PSERVER_INFO_1579SERVER_INFO_1579LPSERVER_INFO_1579PSERVER_INFO_1580SERVER_INFO_1580LPSERVER_INFO_1580PSERVER_INFO_1581SERVER_INFO_1581LPSERVER_INFO_1581PSERVER_INFO_1582SERVER_INFO_1582LPSERVER_INFO_1582PSERVER_INFO_1583SERVER_INFO_1583LPSERVER_INFO_1583PSERVER_INFO_1584SERVER_INFO_1584LPSERVER_INFO_1584PSERVER_INFO_1585SERVER_INFO_1585LPSERVER_INFO_1585PSERVER_INFO_1586SERVER_INFO_1586LPSERVER_INFO_1586PSERVER_INFO_1587SERVER_INFO_1587LPSERVER_INFO_1587PSERVER_INFO_1588SERVER_INFO_1588LPSERVER_INFO_1588PSERVER_INFO_1590SERVER_INFO_1590LPSERVER_INFO_1590PSERVER_INFO_1591SERVER_INFO_1591LPSERVER_INFO_1591PSERVER_INFO_1592SERVER_INFO_1592LPSERVER_INFO_1592PSERVER_INFO_1593SERVER_INFO_1593LPSERVER_INFO_1593PSERVER_INFO_1594SERVER_INFO_1594LPSERVER_INFO_1594PSERVER_INFO_1595SERVER_INFO_1595LPSERVER_INFO_1595PSERVER_INFO_1596SERVER_INFO_1596LPSERVER_INFO_1596PSERVER_INFO_1597SERVER_INFO_1597LPSERVER_INFO_1597PSERVER_INFO_1598SERVER_INFO_1598LPSERVER_INFO_1598PSERVER_INFO_1599SERVER_INFO_1599LPSERVER_INFO_1599PSERVER_INFO_1600SERVER_INFO_1600LPSERVER_INFO_1600PSERVER_INFO_1601SERVER_INFO_1601LPSERVER_INFO_1601PSERVER_INFO_1602SERVER_INFO_1602LPSERVER_INFO_1602PSERVER_TRANSPORT_INFO_0SERVER_TRANSPORT_INFO_0LPSERVER_TRANSPORT_INFO_0PSERVER_TRANSPORT_INFO_1SERVER_TRANSPORT_INFO_1LPSERVER_TRANSPORT_INFO_1PSERVER_TRANSPORT_INFO_2SERVER_TRANSPORT_INFO_2LPSERVER_TRANSPORT_INFO_2PSERVER_TRANSPORT_INFO_3SERVER_TRANSPORT_INFO_3LPSERVER_TRANSPORT_INFO_3SV_PLATFORM_ID_OS2SV_PLATFORM_ID_NTMAJOR_VERSION_MASKSV_TYPE_WORKSTATIONSV_TYPE_SERVERSV_TYPE_SQLSERVERSV_TYPE_DOMAIN_CTRLSV_TYPE_DOMAIN_BAKCTRLSV_TYPE_TIME_SOURCESV_TYPE_AFPSV_TYPE_NOVELLSV_TYPE_DOMAIN_MEMBERSV_TYPE_PRINTQ_SERVERSV_TYPE_DIALIN_SERVERSV_TYPE_XENIX_SERVERSV_TYPE_SERVER_UNIXSV_TYPE_NTSV_TYPE_WFWSV_TYPE_SERVER_MFPNSV_TYPE_SERVER_NTSV_TYPE_POTENTIAL_BROWSERSV_TYPE_BACKUP_BROWSERSV_TYPE_MASTER_BROWSERSV_TYPE_DOMAIN_MASTERSV_TYPE_SERVER_OSFSV_TYPE_SERVER_VMSSV_TYPE_WINDOWSSV_TYPE_DFSSV_TYPE_CLUSTER_NTSV_TYPE_TERMINALSERVERSV_TYPE_CLUSTER_VS_NTSV_TYPE_DCESV_TYPE_ALTERNATE_XPORTSV_TYPE_LOCAL_LIST_ONLYSV_TYPE_DOMAIN_ENUMSV_TYPE_ALLSV_NODISCSV_USERSECURITYSV_SHARESECURITYSV_HIDDENSV_VISIBLESV_PLATFORM_ID_PARMNUMSV_NAME_PARMNUMSV_VERSION_MAJOR_PARMNUMSV_VERSION_MINOR_PARMNUMSV_TYPE_PARMNUMSV_COMMENT_PARMNUMSV_USERS_PARMNUMSV_DISC_PARMNUMSV_HIDDEN_PARMNUMSV_ANNOUNCE_PARMNUMSV_ANNDELTA_PARMNUMSV_USERPATH_PARMNUMSV_ULIST_MTIME_PARMNUMSV_GLIST_MTIME_PARMNUMSV_ALIST_MTIME_PARMNUMSV_ALERTS_PARMNUMSV_SECURITY_PARMNUMSV_NUMADMIN_PARMNUMSV_LANMASK_PARMNUMSV_GUESTACC_PARMNUMSV_CHDEVQ_PARMNUMSV_CHDEVJOBS_PARMNUMSV_CONNECTIONS_PARMNUMSV_SHARES_PARMNUMSV_OPENFILES_PARMNUMSV_SESSREQS_PARMNUMSV_ACTIVELOCKS_PARMNUMSV_NUMREQBUF_PARMNUMSV_NUMBIGBUF_PARMNUMSV_NUMFILETASKS_PARMNUMSV_ALERTSCHED_PARMNUMSV_ERRORALERT_PARMNUMSV_LOGONALERT_PARMNUMSV_ACCESSALERT_PARMNUMSV_DISKALERT_PARMNUMSV_NETIOALERT_PARMNUMSV_MAXAUDITSZ_PARMNUMSV_SRVHEURISTICS_PARMNUMSV_SESSOPENS_PARMNUMSV_SESSVCS_PARMNUMSV_OPENSEARCH_PARMNUMSV_SIZREQBUF_PARMNUMSV_INITWORKITEMS_PARMNUMSV_MAXWORKITEMS_PARMNUMSV_RAWWORKITEMS_PARMNUMSV_IRPSTACKSIZE_PARMNUMSV_MAXRAWBUFLEN_PARMNUMSV_SESSUSERS_PARMNUMSV_SESSCONNS_PARMNUMSV_MAXNONPAGEDMEMORYUSAGE_PARMNUMSV_MAXPAGEDMEMORYUSAGE_PARMNUMSV_ENABLESOFTCOMPAT_PARMNUMSV_ENABLEFORCEDLOGOFF_PARMNUMSV_TIMESOURCE_PARMNUMSV_ACCEPTDOWNLEVELAPIS_PARMNUMSV_LMANNOUNCE_PARMNUMSV_DOMAIN_PARMNUMSV_MAXCOPYREADLEN_PARMNUMSV_MAXCOPYWRITELEN_PARMNUMSV_MINKEEPSEARCH_PARMNUMSV_MAXKEEPSEARCH_PARMNUMSV_MINKEEPCOMPLSEARCH_PARMNUMSV_MAXKEEPCOMPLSEARCH_PARMNUMSV_THREADCOUNTADD_PARMNUMSV_NUMBLOCKTHREADS_PARMNUMSV_SCAVTIMEOUT_PARMNUMSV_MINRCVQUEUE_PARMNUMSV_MINFREEWORKITEMS_PARMNUMSV_XACTMEMSIZE_PARMNUMSV_THREADPRIORITY_PARMNUMSV_MAXMPXCT_PARMNUMSV_OPLOCKBREAKWAIT_PARMNUMSV_OPLOCKBREAKRESPONSEWAIT_PARMNUMSV_ENABLEOPLOCKS_PARMNUMSV_ENABLEOPLOCKFORCECLOSE_PARMNUMSV_ENABLEFCBOPENS_PARMNUMSV_ENABLERAW_PARMNUMSV_ENABLESHAREDNETDRIVES_PARMNUMSV_MINFREECONNECTIONS_PARMNUMSV_MAXFREECONNECTIONS_PARMNUMSV_INITSESSTABLE_PARMNUMSV_INITCONNTABLE_PARMNUMSV_INITFILETABLE_PARMNUMSV_INITSEARCHTABLE_PARMNUMSV_ALERTSCHEDULE_PARMNUMSV_ERRORTHRESHOLD_PARMNUMSV_NETWORKERRORTHRESHOLD_PARMNUMSV_DISKSPACETHRESHOLD_PARMNUMSV_MAXLINKDELAY_PARMNUMSV_MINLINKTHROUGHPUT_PARMNUMSV_LINKINFOVALIDTIME_PARMNUMSV_SCAVQOSINFOUPDATETIME_PARMNUMSV_MAXWORKITEMIDLETIME_PARMNUMSV_MAXRAWWORKITEMS_PARMNUMSV_PRODUCTTYPE_PARMNUMSV_SERVERSIZE_PARMNUMSV_CONNECTIONLESSAUTODISC_PARMNUMSV_SHARINGVIOLATIONRETRIES_PARMNUMSV_SHARINGVIOLATIONDELAY_PARMNUMSV_MAXGLOBALOPENSEARCH_PARMNUMSV_REMOVEDUPLICATESEARCHES_PARMNUMSV_LOCKVIOLATIONRETRIES_PARMNUMSV_LOCKVIOLATIONOFFSET_PARMNUMSV_LOCKVIOLATIONDELAY_PARMNUMSV_MDLREADSWITCHOVER_PARMNUMSV_CACHEDOPENLIMIT_PARMNUMSV_CRITICALTHREADS_PARMNUMSV_RESTRICTNULLSESSACCESS_PARMNUMSV_ENABLEWFW311DIRECTIPX_PARMNUMSV_OTHERQUEUEAFFINITY_PARMNUMSV_QUEUESAMPLESECS_PARMNUMSV_BALANCECOUNT_PARMNUMSV_PREFERREDAFFINITY_PARMNUMSV_MAXFREERFCBS_PARMNUMSV_MAXFREEMFCBS_PARMNUMSV_MAXFREELFCBS_PARMNUMSV_MAXFREEPAGEDPOOLCHUNKS_PARMNUMSV_MINPAGEDPOOLCHUNKSIZE_PARMNUMSV_MAXPAGEDPOOLCHUNKSIZE_PARMNUMSV_SENDSFROMPREFERREDPROCESSOR_PARMNUMSV_MAXTHREADSPERQUEUE_PARMNUMSV_CACHEDDIRECTORYLIMIT_PARMNUMSV_MAXCOPYLENGTH_PARMNUMSV_ENABLECOMPRESSION_PARMNUMSV_AUTOSHAREWKS_PARMNUMSV_AUTOSHARESERVER_PARMNUMSV_ENABLESECURITYSIGNATURE_PARMNUMSV_REQUIRESECURITYSIGNATURE_PARMNUMSV_MINCLIENTBUFFERSIZE_PARMNUMSV_CONNECTIONNOSESSIONSTIMEOUT_PARMNUMSV_IDLETHREADTIMEOUT_PARMNUMSV_ENABLEW9XSECURITYSIGNATURE_PARMNUMSV_ENFORCEKERBEROSREAUTHENTICATION_PARMNUMSV_DISABLEDOS_PARMNUMSV_LOWDISKSPACEMINIMUM_PARMNUMSV_DISABLESTRICTNAMECHECKING_PARMNUMSV_ENABLEAUTHENTICATEUSERSHARING_PARMNUMSV_COMMENT_INFOLEVELSV_USERS_INFOLEVELSV_DISC_INFOLEVELSV_HIDDEN_INFOLEVELSV_ANNOUNCE_INFOLEVELSV_ANNDELTA_INFOLEVELSV_SESSOPENS_INFOLEVELSV_SESSVCS_INFOLEVELSV_OPENSEARCH_INFOLEVELSV_MAXWORKITEMS_INFOLEVELSV_MAXRAWBUFLEN_INFOLEVELSV_SESSUSERS_INFOLEVELSV_SESSCONNS_INFOLEVELSV_MAXNONPAGEDMEMORYUSAGE_INFOLEVELSV_MAXPAGEDMEMORYUSAGE_INFOLEVELSV_ENABLESOFTCOMPAT_INFOLEVELSV_ENABLEFORCEDLOGOFF_INFOLEVELSV_TIMESOURCE_INFOLEVELSV_LMANNOUNCE_INFOLEVELSV_MAXCOPYREADLEN_INFOLEVELSV_MAXCOPYWRITELEN_INFOLEVELSV_MINKEEPSEARCH_INFOLEVELSV_MAXKEEPSEARCH_INFOLEVELSV_MINKEEPCOMPLSEARCH_INFOLEVELSV_MAXKEEPCOMPLSEARCH_INFOLEVELSV_SCAVTIMEOUT_INFOLEVELSV_MINRCVQUEUE_INFOLEVELSV_MINFREEWORKITEMS_INFOLEVELSV_MAXMPXCT_INFOLEVELSV_OPLOCKBREAKWAIT_INFOLEVELSV_OPLOCKBREAKRESPONSEWAIT_INFOLEVELSV_ENABLEOPLOCKS_INFOLEVELSV_ENABLEOPLOCKFORCECLOSE_INFOLEVELSV_ENABLEFCBOPENS_INFOLEVELSV_ENABLERAW_INFOLEVELSV_ENABLESHAREDNETDRIVES_INFOLEVELSV_MINFREECONNECTIONS_INFOLEVELSV_MAXFREECONNECTIONS_INFOLEVELSV_INITSESSTABLE_INFOLEVELSV_INITCONNTABLE_INFOLEVELSV_INITFILETABLE_INFOLEVELSV_INITSEARCHTABLE_INFOLEVELSV_ALERTSCHEDULE_INFOLEVELSV_ERRORTHRESHOLD_INFOLEVELSV_NETWORKERRORTHRESHOLD_INFOLEVELSV_DISKSPACETHRESHOLD_INFOLEVELSV_MAXLINKDELAY_INFOLEVELSV_MINLINKTHROUGHPUT_INFOLEVELSV_LINKINFOVALIDTIME_INFOLEVELSV_SCAVQOSINFOUPDATETIME_INFOLEVELSV_MAXWORKITEMIDLETIME_INFOLEVELSV_MAXRAWWORKITEMS_INFOLOEVELSV_PRODUCTTYPE_INFOLOEVELSV_SERVERSIZE_INFOLOEVELSV_CONNECTIONLESSAUTODISC_INFOLOEVELSV_SHARINGVIOLATIONRETRIES_INFOLOEVELSV_SHARINGVIOLATIONDELAY_INFOLOEVELSV_MAXGLOBALOPENSEARCH_INFOLOEVELSV_REMOVEDUPLICATESEARCHES_INFOLOEVELSV_LOCKVIOLATIONRETRIES_INFOLOEVELSV_LOCKVIOLATIONOFFSET_INFOLOEVELSV_LOCKVIOLATIONDELAY_INFOLOEVELSV_MDLREADSWITCHOVER_INFOLOEVELSV_CACHEDOPENLIMIT_INFOLOEVELSV_CRITICALTHREADS_INFOLOEVELSV_RESTRICTNULLSESSACCESS_INFOLOEVELSV_ENABLEWFW311DIRECTIPX_INFOLOEVELSV_OTHERQUEUEAFFINITY_INFOLEVELSV_QUEUESAMPLESECS_INFOLEVELSV_BALANCECOUNT_INFOLEVELSV_PREFERREDAFFINITY_INFOLEVELSV_MAXFREERFCBS_INFOLEVELSV_MAXFREEMFCBS_INFOLEVELSV_MAXFREELFCBS_INFOLEVELSV_MAXFREEPAGEDPOOLCHUNKS_INFOLEVELSV_MINPAGEDPOOLCHUNKSIZE_INFOLEVELSV_MAXPAGEDPOOLCHUNKSIZE_INFOLEVELSV_SENDSFROMPREFERREDPROCESSOR_INFOLEVELSV_MAXTHREADSPERQUEUE_INFOLEVELSV_CACHEDDIRECTORYLIMIT_INFOLEVELSV_MAXCOPYLENGTH_INFOLEVELSV_ENABLECOMPRESSION_INFOLEVELSV_AUTOSHAREWKS_INFOLEVELSV_AUTOSHARESERVER_INFOLEVELSV_ENABLESECURITYSIGNATURE_INFOLEVELSV_REQUIRESECURITYSIGNATURE_INFOLEVELSV_MINCLIENTBUFFERSIZE_INFOLEVELSV_CONNECTIONNOSESSIONSTIMEOUT_INFOLEVELSV_IDLETHREADTIMEOUT_INFOLEVELSV_ENABLEW9XSECURITYSIGNATURE_INFOLEVELSV_ENFORCEKERBEROSREAUTHENTICATION_INFOLEVELSV_DISABLEDOS_INFOLEVELSV_LOWDISKSPACEMINIMUM_INFOLEVELSV_DISABLESTRICTNAMECHECKING_INFOLEVELSV_ENABLEAUTHENTICATEUSERSHARING_INFOLEVELSVI1_NUM_ELEMENTSSVI2_NUM_ELEMENTSSVI3_NUM_ELEMENTSSV_MAX_CMD_LENSW_AUTOPROF_LOAD_MASKSW_AUTOPROF_SAVE_MASKSV_MAX_SRV_HEUR_LENSV_USERS_PER_LICENSESVTI2_REMAP_PIPE_NAMESSVTI2_SCOPED_NAMESVTI2_CLUSTER_NAMESVTI2_CLUSTER_DNN_NAMESVTI2_UNICODE_TRANSPORT_ADDRESSSVTI2_RESERVED1SVTI2_RESERVED2SVTI2_RESERVED3SVTI2_VALID_FLAGSSRV_SUPPORT_HASH_GENERATIONSRV_HASH_GENERATION_ACTIVE//! This file contains information about NetServer APIsNetShareAddNetShareEnumNetShareEnumStickyNetShareGetInfoNetShareSetInfoNetShareDelNetShareDelStickyNetShareCheckNetShareDelExPSHARE_INFO_0SHARE_INFO_0LPSHARE_INFO_0PSHARE_INFO_1SHARE_INFO_1LPSHARE_INFO_1PSHARE_INFO_2SHARE_INFO_2LPSHARE_INFO_2PSHARE_INFO_501SHARE_INFO_501LPSHARE_INFO_501PSHARE_INFO_502SHARE_INFO_502LPSHARE_INFO_502PSHARE_INFO_503SHARE_INFO_503LPSHARE_INFO_503PSHARE_INFO_1004SHARE_INFO_1004LPSHARE_INFO_1004PSHARE_INFO_1005SHARE_INFO_1005LPSHARE_INFO_1005PSHARE_INFO_1006SHARE_INFO_1006LPSHARE_INFO_1006PSHARE_INFO_1501SHARE_INFO_1501LPSHARE_INFO_1501PSHARE_INFO_1503SHARE_INFO_1503LPSHARE_INFO_1503NetServerAliasAddNetServerAliasDelNetServerAliasEnumPSERVER_ALIAS_INFO_0SERVER_ALIAS_INFO_0LPSERVER_ALIAS_INFO_0SHARE_NETNAME_PARMNUMSHARE_TYPE_PARMNUMSHARE_REMARK_PARMNUMSHARE_PERMISSIONS_PARMNUMSHARE_MAX_USES_PARMNUMSHARE_CURRENT_USES_PARMNUMSHARE_PATH_PARMNUMSHARE_PASSWD_PARMNUMSHARE_FILE_SD_PARMNUMSHARE_SERVER_PARMNUMSHARE_REMARK_INFOLEVELSHARE_MAX_USES_INFOLEVELSHARE_FILE_SD_INFOLEVELSHI1_NUM_ELEMENTSSHI2_NUM_ELEMENTSSTYPE_DISKTREESTYPE_PRINTQSTYPE_DEVICESTYPE_IPCSTYPE_MASKSTYPE_RESERVED1STYPE_RESERVED2STYPE_RESERVED3STYPE_RESERVED4STYPE_RESERVED_ALLSTYPE_TEMPORARYSTYPE_SPECIALSHI_USES_UNLIMITEDSHI1005_FLAGS_DFSSHI1005_FLAGS_DFS_ROOTCSC_MASK_EXTCSC_MASKCSC_CACHE_MANUAL_REINTCSC_CACHE_AUTO_REINTCSC_CACHE_VDOCSC_CACHE_NONESHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENSSHI1005_FLAGS_FORCE_SHARED_DELETESHI1005_FLAGS_ALLOW_NAMESPACE_CACHINGSHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUMSHI1005_FLAGS_FORCE_LEVELII_OPLOCKSHI1005_FLAGS_ENABLE_HASHSHI1005_FLAGS_ENABLE_CASHI1005_FLAGS_ENCRYPT_DATASHI1005_FLAGS_RESERVEDSHI1005_VALID_FLAGS_SETNetSessionEnumNetSessionDelNetSessionGetInfoPSESSION_INFO_0SESSION_INFO_0LPSESSION_INFO_0PSESSION_INFO_1SESSION_INFO_1LPSESSION_INFO_1PSESSION_INFO_2SESSION_INFO_2LPSESSION_INFO_2PSESSION_INFO_10SESSION_INFO_10LPSESSION_INFO_10PSESSION_INFO_502SESSION_INFO_502LPSESSION_INFO_502SESS_GUESTSESS_NOENCRYPTIONSESI1_NUM_ELEMENTSSESI2_NUM_ELEMENTSNetConnectionEnumPCONNECTION_INFO_0CONNECTION_INFO_0LPCONNECTION_INFO_0PCONNECTION_INFO_1CONNECTION_INFO_1LPCONNECTION_INFO_1NetFileCloseNetFileEnumNetFileGetInfoPFILE_INFO_2FILE_INFO_2LPFILE_INFO_2PFILE_INFO_3FILE_INFO_3LPFILE_INFO_3PERM_FILE_READPERM_FILE_WRITEPERM_FILE_CREATE//! This module defines the API function prototypes and data structuresNetStatisticsGetPSTAT_WORKSTATION_0STAT_WORKSTATION_0LPSTAT_WORKSTATION_0PSTAT_SERVER_0STAT_SERVER_0LPSTAT_SERVER_0STATSOPT_CLRSTATS_NO_VALUESTATS_OVERFLOWPSERVICE_INFO_0SERVICE_INFO_0LPSERVICE_INFO_0PSERVICE_INFO_1SERVICE_INFO_1LPSERVICE_INFO_1PSERVICE_INFO_2SERVICE_INFO_2LPSERVICE_INFO_2NetServiceControlNetServiceEnumNetServiceGetInfoNetServiceInstallSERVICE_INSTALL_STATESERVICE_UNINSTALLEDSERVICE_INSTALL_PENDINGSERVICE_UNINSTALL_PENDINGSERVICE_INSTALLEDSERVICE_PAUSE_STATELM20_SERVICE_ACTIVELM20_SERVICE_CONTINUE_PENDINGLM20_SERVICE_PAUSE_PENDINGLM20_SERVICE_PAUSEDSERVICE_NOT_UNINSTALLABLESERVICE_UNINSTALLABLESERVICE_NOT_PAUSABLESERVICE_PAUSABLESERVICE_REDIR_PAUSEDSERVICE_REDIR_DISK_PAUSEDSERVICE_REDIR_PRINT_PAUSEDSERVICE_REDIR_COMM_PAUSEDSERVICE_DOS_ENCRYPTIONSERVICE_CTRL_INTERROGATESERVICE_CTRL_PAUSESERVICE_CTRL_CONTINUESERVICE_CTRL_UNINSTALLSERVICE_CTRL_REDIR_DISKSERVICE_CTRL_REDIR_PRINTSERVICE_CTRL_REDIR_COMMSERVICE_IP_NO_HINTSERVICE_CCP_NO_HINTSERVICE_IP_QUERY_HINTSERVICE_CCP_QUERY_HINTSERVICE_IP_CHKPT_NUMSERVICE_CCP_CHKPT_NUMSERVICE_IP_WAIT_TIMESERVICE_CCP_WAIT_TIMESERVICE_IP_WAITTIME_SHIFTSERVICE_NTIP_WAITTIME_SHIFTUPPER_HINT_MASKLOWER_HINT_MASKUPPER_GET_HINT_MASKLOWER_GET_HINT_MASKSERVICE_NT_MAXTIMESERVICE_RESRV_MASKSERVICE_MAXTIMESERVICE_BASESERVICE_UIC_NORMALSERVICE_UIC_BADPARMVALSERVICE_UIC_MISSPARMSERVICE_UIC_UNKPARMSERVICE_UIC_RESOURCESERVICE_UIC_CONFIGSERVICE_UIC_SYSTEMSERVICE_UIC_INTERNALSERVICE_UIC_AMBIGPARMSERVICE_UIC_DUPPARMSERVICE_UIC_KILLSERVICE_UIC_EXECSERVICE_UIC_SUBSERVSERVICE_UIC_CONFLPARMSERVICE_UIC_FILESERVICE_UIC_M_NULLSERVICE_UIC_M_MEMORYSERVICE_UIC_M_DISKSERVICE_UIC_M_THREADSSERVICE_UIC_M_PROCESSESSERVICE_UIC_M_SECURITYSERVICE_UIC_M_LANROOTSERVICE_UIC_M_REDIRSERVICE_UIC_M_SERVERSERVICE_UIC_M_SEC_FILE_ERRSERVICE_UIC_M_FILESSERVICE_UIC_M_LOGSSERVICE_UIC_M_LANGROUPSERVICE_UIC_M_MSGNAMESERVICE_UIC_M_ANNOUNCESERVICE_UIC_M_UASSERVICE_UIC_M_SERVER_SEC_ERRSERVICE_UIC_M_WKSTASERVICE_UIC_M_ERRLOGSERVICE_UIC_M_FILE_UWSERVICE_UIC_M_ADDPAKSERVICE_UIC_M_LAZYSERVICE_UIC_M_UAS_MACHINE_ACCTSERVICE_UIC_M_UAS_SERVERS_NMEMBSERVICE_UIC_M_UAS_SERVERS_NOGRPSERVICE_UIC_M_UAS_INVALID_ROLESERVICE_UIC_M_NETLOGON_NO_DCSERVICE_UIC_M_NETLOGON_DC_CFLCTSERVICE_UIC_M_NETLOGON_AUTHSERVICE_UIC_M_UAS_PROLOGSERVICE2_BASESERVICE_UIC_M_NETLOGON_MPATHSERVICE_UIC_M_LSA_MACHINE_ACCTSERVICE_UIC_M_DATABASE_ERRORSERVICE_IP_CODESERVICE_CCP_CODESERVICE_UIC_CODESERVICE_NT_CCP_CODESERVICE_NT_WAIT_GET//! This file contains structures, function prototypes, and definitions for the NetService APINetUseAddNetUseDelNetUseEnumNetUseGetInfoPUSE_INFO_0USE_INFO_0LPUSE_INFO_0PUSE_INFO_1USE_INFO_1LPUSE_INFO_1PUSE_INFO_2USE_INFO_2LPUSE_INFO_2PUSE_INFO_3USE_INFO_3PUSE_INFO_4USE_INFO_4LPUSE_INFO_4USE_LOCAL_PARMNUMUSE_REMOTE_PARMNUMUSE_PASSWORD_PARMNUMUSE_ASGTYPE_PARMNUMUSE_USERNAME_PARMNUMUSE_DOMAINNAME_PARMNUMUSE_OKUSE_PAUSEDUSE_SESSLOSTUSE_DISCONNUSE_NETERRUSE_CONNUSE_RECONNUSE_WILDCARDUSE_DISKDEVUSE_SPOOLDEVUSE_CHARDEVUSE_IPCCREATE_NO_CONNECTCREATE_BYPASS_CSCCREATE_CRED_RESETUSE_DEFAULT_CREDENTIALS//! This file contains structures, function prototypes, and definitions for the NetUse APINetWkstaGetInfoNetWkstaSetInfoNetWkstaUserGetInfoNetWkstaUserSetInfoNetWkstaUserEnumNetWkstaTransportAddNetWkstaTransportDelNetWkstaTransportEnumPWKSTA_INFO_100WKSTA_INFO_100LPWKSTA_INFO_100PWKSTA_INFO_101WKSTA_INFO_101LPWKSTA_INFO_101PWKSTA_INFO_102WKSTA_INFO_102LPWKSTA_INFO_102PWKSTA_INFO_302WKSTA_INFO_302LPWKSTA_INFO_302PWKSTA_INFO_402WKSTA_INFO_402LPWKSTA_INFO_402PWKSTA_INFO_502WKSTA_INFO_502LPWKSTA_INFO_502PWKSTA_INFO_1010WKSTA_INFO_1010LPWKSTA_INFO_1010PWKSTA_INFO_1011WKSTA_INFO_1011LPWKSTA_INFO_1011PWKSTA_INFO_1012WKSTA_INFO_1012LPWKSTA_INFO_1012PWKSTA_INFO_1027WKSTA_INFO_1027LPWKSTA_INFO_1027PWKSTA_INFO_1028WKSTA_INFO_1028LPWKSTA_INFO_1028PWKSTA_INFO_1032WKSTA_INFO_1032LPWKSTA_INFO_1032PWKSTA_INFO_1013WKSTA_INFO_1013LPWKSTA_INFO_1013PWKSTA_INFO_1018WKSTA_INFO_1018LPWKSTA_INFO_1018PWKSTA_INFO_1023WKSTA_INFO_1023LPWKSTA_INFO_1023PWKSTA_INFO_1033WKSTA_INFO_1033LPWKSTA_INFO_1033PWKSTA_INFO_1041WKSTA_INFO_1041LPWKSTA_INFO_1041PWKSTA_INFO_1042WKSTA_INFO_1042LPWKSTA_INFO_1042PWKSTA_INFO_1043WKSTA_INFO_1043LPWKSTA_INFO_1043PWKSTA_INFO_1044WKSTA_INFO_1044LPWKSTA_INFO_1044PWKSTA_INFO_1045WKSTA_INFO_1045LPWKSTA_INFO_1045PWKSTA_INFO_1046WKSTA_INFO_1046LPWKSTA_INFO_1046PWKSTA_INFO_1047WKSTA_INFO_1047LPWKSTA_INFO_1047PWKSTA_INFO_1048WKSTA_INFO_1048LPWKSTA_INFO_1048PWKSTA_INFO_1049WKSTA_INFO_1049LPWKSTA_INFO_1049PWKSTA_INFO_1050WKSTA_INFO_1050LPWKSTA_INFO_1050PWKSTA_INFO_1051WKSTA_INFO_1051LPWKSTA_INFO_1051PWKSTA_INFO_1052WKSTA_INFO_1052LPWKSTA_INFO_1052PWKSTA_INFO_1053WKSTA_INFO_1053LPWKSTA_INFO_1053PWKSTA_INFO_1054WKSTA_INFO_1054LPWKSTA_INFO_1054PWKSTA_INFO_1055WKSTA_INFO_1055LPWKSTA_INFO_1055PWKSTA_INFO_1056WKSTA_INFO_1056LPWKSTA_INFO_1056PWKSTA_INFO_1057WKSTA_INFO_1057LPWKSTA_INFO_1057PWKSTA_INFO_1058WKSTA_INFO_1058LPWKSTA_INFO_1058PWKSTA_INFO_1059WKSTA_INFO_1059LPWKSTA_INFO_1059PWKSTA_INFO_1060WKSTA_INFO_1060LPWKSTA_INFO_1060PWKSTA_INFO_1061WKSTA_INFO_1061LPWKSTA_INFO_1061PWKSTA_INFO_1062WKSTA_INFO_1062LPWKSTA_INFO_1062PWKSTA_USER_INFO_0WKSTA_USER_INFO_0LPWKSTA_USER_INFO_0PWKSTA_USER_INFO_1WKSTA_USER_INFO_1LPWKSTA_USER_INFO_1PWKSTA_USER_INFO_1101WKSTA_USER_INFO_1101LPWKSTA_USER_INFO_1101PWKSTA_TRANSPORT_INFO_0WKSTA_TRANSPORT_INFO_0LPWKSTA_TRANSPORT_INFO_0WKSTA_PLATFORM_ID_PARMNUMWKSTA_COMPUTERNAME_PARMNUMWKSTA_LANGROUP_PARMNUMWKSTA_VER_MAJOR_PARMNUMWKSTA_VER_MINOR_PARMNUMWKSTA_LOGGED_ON_USERS_PARMNUMWKSTA_LANROOT_PARMNUMWKSTA_LOGON_DOMAIN_PARMNUMWKSTA_LOGON_SERVER_PARMNUMWKSTA_CHARWAIT_PARMNUMWKSTA_CHARTIME_PARMNUMWKSTA_CHARCOUNT_PARMNUMWKSTA_KEEPCONN_PARMNUMWKSTA_KEEPSEARCH_PARMNUMWKSTA_MAXCMDS_PARMNUMWKSTA_NUMWORKBUF_PARMNUMWKSTA_MAXWRKCACHE_PARMNUMWKSTA_SESSTIMEOUT_PARMNUMWKSTA_SIZERROR_PARMNUMWKSTA_NUMALERTS_PARMNUMWKSTA_NUMSERVICES_PARMNUMWKSTA_NUMCHARBUF_PARMNUMWKSTA_SIZCHARBUF_PARMNUMWKSTA_ERRLOGSZ_PARMNUMWKSTA_PRINTBUFTIME_PARMNUMWKSTA_SIZWORKBUF_PARMNUMWKSTA_MAILSLOTS_PARMNUMWKSTA_NUMDGRAMBUF_PARMNUMWKSTA_WRKHEURISTICS_PARMNUMWKSTA_MAXTHREADS_PARMNUMWKSTA_LOCKQUOTA_PARMNUMWKSTA_LOCKINCREMENT_PARMNUMWKSTA_LOCKMAXIMUM_PARMNUMWKSTA_PIPEINCREMENT_PARMNUMWKSTA_PIPEMAXIMUM_PARMNUMWKSTA_DORMANTFILELIMIT_PARMNUMWKSTA_CACHEFILETIMEOUT_PARMNUMWKSTA_USEOPPORTUNISTICLOCKING_PARMNUMWKSTA_USEUNLOCKBEHIND_PARMNUMWKSTA_USECLOSEBEHIND_PARMNUMWKSTA_BUFFERNAMEDPIPES_PARMNUMWKSTA_USELOCKANDREADANDUNLOCK_PARMNUMWKSTA_UTILIZENTCACHING_PARMNUMWKSTA_USERAWREAD_PARMNUMWKSTA_USERAWWRITE_PARMNUMWKSTA_USEWRITERAWWITHDATA_PARMNUMWKSTA_USEENCRYPTION_PARMNUMWKSTA_BUFFILESWITHDENYWRITE_PARMNUMWKSTA_BUFFERREADONLYFILES_PARMNUMWKSTA_FORCECORECREATEMODE_PARMNUMWKSTA_USE512BYTESMAXTRANSFER_PARMNUMWKSTA_READAHEADTHRUPUT_PARMNUMWKSTA_OTH_DOMAINS_PARMNUMTRANSPORT_QUALITYOFSERVICE_PARMNUMTRANSPORT_NAME_PARMNUMLPMC_TIMING_REPORTMC_TIMING_REPORTLPMC_VCP_CODE_TYPEMC_VCP_CODE_TYPEGetVCPFeatureAndVCPFeatureReplySetVCPFeatureSaveCurrentSettingsGetCapabilitiesStringLengthCapabilitiesRequestAndCapabilitiesReplyGetTimingReportACCESS_MASKPLSA_UNICODE_STRINGLSA_UNICODE_STRINGPLSA_STRINGLSA_STRINGPLSA_OBJECT_ATTRIBUTESLSA_OBJECT_ATTRIBUTESPLSA_TRUST_INFORMATIONLSA_TRUST_INFORMATIONPLSA_REFERENCED_DOMAIN_LISTLSA_REFERENCED_DOMAIN_LISTPLSA_TRANSLATED_SID2LSA_TRANSLATED_SID2PLSA_TRANSLATED_NAMELSA_TRANSLATED_NAMEPPOLICY_ACCOUNT_DOMAIN_INFOPOLICY_ACCOUNT_DOMAIN_INFOPPOLICY_DNS_DOMAIN_INFOPOLICY_DNS_DOMAIN_INFOLOOKUP_VIEW_LOCAL_INFORMATIONLOOKUP_TRANSLATE_NAMESPLSA_LOOKUP_DOMAIN_INFO_CLASSLSA_LOOKUP_DOMAIN_INFO_CLASSLSA_LOOKUP_HANDLEPLSA_LOOKUP_HANDLELsaLookupOpenLocalPolicyLsaLookupCloseLsaLookupTranslateSidsLsaLookupTranslateNamesLsaLookupGetDomainInfoLsaLookupFreeMemory//! LSA Policy Lookup APIPMEMORY_BASIC_INFORMATIONFILE_MAP_RESERVEFILE_MAP_TARGETS_INVALIDFILE_MAP_LARGE_PAGESVirtualAllocVirtualFreeVirtualQueryVirtualAllocExVirtualFreeExVirtualProtectExWriteProcessMemoryOpenFileMappingWMapViewOfFileExGetLargePageMinimumGetProcessWorkingSetSizeExSetProcessWorkingSetSizeExVirtualLockVirtualUnlockGetWriteWatchResetWriteWatchCreateMemoryResourceNotificationMEMORY_RESOURCE_NOTIFICATION_TYPEQueryMemoryResourceNotificationFILE_CACHE_MAX_HARD_ENABLEFILE_CACHE_MAX_HARD_DISABLEFILE_CACHE_MIN_HARD_ENABLEFILE_CACHE_MIN_HARD_DISABLEGetSystemFileCacheSizeSetSystemFileCacheSizeCreateFileMappingNumaWPWIN32_MEMORY_RANGE_ENTRYWIN32_MEMORY_RANGE_ENTRYPrefetchVirtualMemoryCreateFileMappingFromAppMapViewOfFileFromAppUnmapViewOfFileExAllocateUserPhysicalPagesFreeUserPhysicalPagesMapUserPhysicalPagesAllocateUserPhysicalPagesNumaVirtualAllocExNumaMEHC_PATROL_SCRUBBER_PRESENTGetMemoryErrorHandlingCapabilitiesRegisterBadMemoryNotificationPBAD_MEMORY_CALLBACK_ROUTINEUnregisterBadMemoryNotificationOfferVirtualMemoryOFFER_PRIORITYReclaimVirtualMemoryDiscardVirtualMemoryVirtualAllocFromApp// TODO: Needs winnt::PCFG_CALL_TARGET_INFO./*  pub fn SetProcessValidCallTargets(
        hProcess: HANDLE,
        VirtualAddress: PVOID,
        RegionSize: SIZE_T,
        NumberOfOffsets: ULONG,
        OffsetInformation: PCFG_CALL_TARGET_INFO,
    ) -> BOOL; */VirtualProtectFromAppOpenFileMappingFromApp// TODO: Under WINAPI_PARTITION_APP, define CreateFileMappingW, MapViewOfFile, VirtualAlloc,// VirtualProtect, and OpenFileMappingW as wrappers around the *FromApp functions.UnmapViewOfFile2//! ApiSet Contract for api-ms-win-core-memory-l1-1-0// TODO: Need to resolve issue #323 first./*extern "system" {
    pub fn QueryVirtualMemoryInformation(
        Process: HANDLE,
        VirtualAddress: *const VOID,
        MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS,
        MemoryInformation: PVOID,
        MemoryInformationSize: SIZE_T,
        ReturnSize: PSIZE_T,
    ) -> BOOL;
    pub fn MapViewOfFileNuma2(
        FileMappingHandle: HANDLE,
        ProcessHandle: HANDLE,
        Offset: ULONG64,
        BaseAddress: PVOID,
        ViewSize: SIZE_T,
        AllocationType: ULONG,
        PageProtection: ULONG,
        PreferredNode: ULONG,
    ) -> PVOID;
}
#[inline]
pub unsafe fn MapViewOfFile2(
    FileMappingHandle: HANDLE,
    ProcessHandle: HANDLE,
    Offset: ULONG64,
    BaseAddress: PVOID,
    ViewSize: SIZE_T,
    AllocationType: ULONG,
    PageProtection: ULONG,
) -> PVOID {
    MapViewOfFileNuma2(FileMappingHandle,
        ProcessHandle,
        Offset,
        BaseAddress,
        ViewSize,
        AllocationType,
        PageProtection,
        NUMA_NO_PREFERRED_NODE)
}*/ALG_IDSECPKG_ATTR_ISSUER_LISTSECPKG_ATTR_REMOTE_CREDSECPKG_ATTR_LOCAL_CREDSECPKG_ATTR_REMOTE_CERT_CONTEXTSECPKG_ATTR_LOCAL_CERT_CONTEXTSECPKG_ATTR_ROOT_STORESECPKG_ATTR_SUPPORTED_ALGSSECPKG_ATTR_CIPHER_STRENGTHSSECPKG_ATTR_SUPPORTED_PROTOCOLSSECPKG_ATTR_ISSUER_LIST_EXSECPKG_ATTR_CONNECTION_INFOSECPKG_ATTR_EAP_KEY_BLOCKSECPKG_ATTR_MAPPED_CRED_ATTRSECPKG_ATTR_SESSION_INFOSECPKG_ATTR_APP_DATASECPKG_ATTR_REMOTE_CERTIFICATESSECPKG_ATTR_CLIENT_CERT_POLICYSECPKG_ATTR_CC_POLICY_RESULTSECPKG_ATTR_USE_NCRYPTSECPKG_ATTR_LOCAL_CERT_INFOSECPKG_ATTR_CIPHER_INFOSECPKG_ATTR_EAP_PRF_INFOSECPKG_ATTR_SUPPORTED_SIGNATURESSECPKG_ATTR_REMOTE_CERT_CHAINSECPKG_ATTR_UI_INFOSECPKG_ATTR_EARLY_START//! Public Definitions for MIN SCHANNEL Security ProviderEXCEPTION_RECORDPRTL_CRITICAL_SECTIONPRTL_CRITICAL_SECTION_DEBUGRTL_CRITICAL_SECTIONRTL_CRITICAL_SECTION_DEBUG//MoveMemory//CopyMemory//FillMemory//ZeroMemoryPSYSTEMTIMELPSYSTEMTIMEPWIN32_FIND_DATAAWIN32_FIND_DATAAPWIN32_FIND_DATAWWIN32_FIND_DATAWFIND_FIRST_EX_CASE_SENSITIVEFIND_FIRST_EX_LARGE_FETCHPFILE_INFO_BY_HANDLE_CLASSCRITICAL_SECTIONPCRITICAL_SECTIONLPCRITICAL_SECTIONCRITICAL_SECTION_DEBUGPCRITICAL_SECTION_DEBUGLPCRITICAL_SECTION_DEBUGLOCKFILE_FAIL_IMMEDIATELYLOCKFILE_EXCLUSIVE_LOCKPROCESS_HEAP_ENTRYPPROCESS_HEAP_ENTRYPROCESS_HEAP_REGIONPROCESS_HEAP_UNCOMMITTED_RANGEPROCESS_HEAP_ENTRY_BUSYPROCESS_HEAP_SEG_ALLOCPROCESS_HEAP_ENTRY_MOVEABLEPROCESS_HEAP_ENTRY_DDESHAREPREASON_CONTEXTREASON_CONTEXTEXCEPTION_DEBUG_EVENTCREATE_THREAD_DEBUG_EVENTCREATE_PROCESS_DEBUG_EVENTEXIT_THREAD_DEBUG_EVENTEXIT_PROCESS_DEBUG_EVENTLOAD_DLL_DEBUG_EVENTUNLOAD_DLL_DEBUG_EVENTOUTPUT_DEBUG_STRING_EVENTRIP_EVENTLPTHREAD_START_ROUTINEPTHREAD_START_ROUTINEPENCLAVE_ROUTINELPEXCEPTION_DEBUG_INFOEXCEPTION_DEBUG_INFOLPCREATE_THREAD_DEBUG_INFOCREATE_THREAD_DEBUG_INFOLPCREATE_PROCESS_DEBUG_INFOCREATE_PROCESS_DEBUG_INFOLPEXIT_THREAD_DEBUG_INFOEXIT_THREAD_DEBUG_INFOLPEXIT_PROCESS_DEBUG_INFOEXIT_PROCESS_DEBUG_INFOLPLOAD_DLL_DEBUG_INFOLOAD_DLL_DEBUG_INFOLPUNLOAD_DLL_DEBUG_INFOUNLOAD_DLL_DEBUG_INFOLPOUTPUT_DEBUG_STRING_INFOOUTPUT_DEBUG_STRING_INFOLPRIP_INFORIP_INFODEBUG_EVENTLPCONTEXTEXCEPTION_ACCESS_VIOLATIONEXCEPTION_DATATYPE_MISALIGNMENTEXCEPTION_BREAKPOINTEXCEPTION_SINGLE_STEPEXCEPTION_ARRAY_BOUNDS_EXCEEDEDEXCEPTION_FLT_DENORMAL_OPERANDEXCEPTION_FLT_DIVIDE_BY_ZEROEXCEPTION_FLT_INEXACT_RESULTEXCEPTION_FLT_INVALID_OPERATIONEXCEPTION_FLT_OVERFLOWEXCEPTION_FLT_STACK_CHECKEXCEPTION_FLT_UNDERFLOWEXCEPTION_INT_DIVIDE_BY_ZEROEXCEPTION_INT_OVERFLOWEXCEPTION_PRIV_INSTRUCTIONEXCEPTION_IN_PAGE_ERROREXCEPTION_ILLEGAL_INSTRUCTIONEXCEPTION_NONCONTINUABLE_EXCEPTIONEXCEPTION_STACK_OVERFLOWEXCEPTION_INVALID_DISPOSITIONEXCEPTION_GUARD_PAGEEXCEPTION_INVALID_HANDLEEXCEPTION_POSSIBLE_DEADLOCKCONTROL_C_EXITLMEM_MOVEABLELMEM_NOCOMPACTLMEM_NODISCARDLMEM_MODIFYLMEM_DISCARDABLELMEM_VALID_FLAGSLMEM_INVALID_HANDLELHNDNONZEROLHNDNONZEROLPTRLMEM_DISCARDED//LocalDiscardLMEM_LOCKCOUNTNUMA_NO_PREFERRED_NODE//! This module defines the 32-Bit Windows Base APIs// use shared::winerror::{ERROR_NOT_FOUND, ERROR_UNSUPPORTED_TYPE, HRESULT_FROM_WIN32};propsysIPropertyStoreDEVICE_STATE_ACTIVE// pub const E_NOTFOUND: HRESULT = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);// pub const E_UNSUPPORTED_TYPE: HRESULT = HRESULT_FROM_WIN32(ERROR_UNSUPPORTED_TYPE);DEVICE_STATE_DISABLEDDEVICE_STATE_NOTPRESENTDEVICE_STATE_UNPLUGGEDDEVICE_STATEMASK_ALLENDPOINT_SYSFX_ENABLEDENDPOINT_SYSFX_DISABLEDPDIRECTX_AUDIO_ACTIVATION_PARAMSDIRECTX_AUDIO_ACTIVATION_PARAMSEndpointFormFactorActivateAudioInterfaceAsyncIActivateAudioInterfaceCompletionHandlerIActivateAudioInterfaceAsyncOperationimmHMIDIHMIDIINHMIDIOUTHMIDISTRMHWAVEINHWAVEOUTLPHMIDIINLPHMIDIOUTLPHMIDISTRMLPHWAVEINLPHWAVEOUTLPMIDIHDRLPMIDIINCAPSWLPMIDIOUTCAPSWLPMMTIMELPWAVEHDRLPWAVEINCAPSWLPWAVEOUTCAPSWMMRESULTwaveOutGetNumDevswaveOutGetDevCapsW// pub fn waveOutGetDevCapsA();waveOutGetVolumewaveOutSetVolumewaveOutGetErrorTextW// pub fn waveOutGetErrorTextA();waveOutOpenwaveOutClosewaveOutPrepareHeaderwaveOutUnprepareHeaderwaveOutWritewaveOutPausewaveOutRestartwaveOutResetwaveOutBreakLoopwaveOutGetPositionwaveOutGetPitchwaveOutSetPitchwaveOutGetPlaybackRatewaveOutSetPlaybackRatewaveOutMessage// pub fn waveOutGetID();waveInGetNumDevswaveInGetDevCapsW// pub fn waveInGetDevCapsA();waveInGetErrorTextW// pub fn waveInGetErrorTextA();waveInOpenwaveInClosewaveInPrepareHeaderwaveInUnprepareHeaderwaveInAddBufferwaveInStartwaveInStopwaveInResetwaveInGetPositionwaveInMessage// pub fn waveInGetID();midiOutGetNumDevsmidiStreamOpenmidiStreamClosemidiStreamPropertymidiStreamPositionmidiStreamOutmidiStreamPausemidiStreamRestartmidiStreamStopmidiConnectmidiDisconnectmidiOutGetDevCapsWmidiOutGetVolumemidiOutSetVolumemidiOutGetErrorTextWmidiOutOpenmidiOutClosemidiOutPrepareHeadermidiOutUnprepareHeadermidiOutShortMsgmidiOutLongMsgmidiOutResetmidiOutCachePatchesmidiOutCacheDrumPatchesmidiOutGetIDmidiOutMessagemidiInGetNumDevsmidiInGetDevCapsWmidiInGetErrorTextWmidiInOpenmidiInClosemidiInPrepareHeadermidiInUnprepareHeadermidiInAddBuffermidiInStartmidiInStopmidiInResetmidiInGetIDmidiInMessageMMVERSION//109 (Win 7 SDK)PMMTIMEMMTIMENPMMTIMETIME_MSTIME_SAMPLESTIME_BYTESTIME_SMPTETIME_MIDITIME_TICKSMM_JOY1MOVEMM_JOY2MOVEMM_JOY1ZMOVEMM_JOY2ZMOVEMM_JOY1BUTTONDOWNMM_JOY2BUTTONDOWNMM_JOY1BUTTONUPMM_JOY2BUTTONUPMM_MCINOTIFYMM_WOM_OPENMM_WOM_CLOSEMM_WOM_DONEMM_WIM_OPENMM_WIM_CLOSEMM_WIM_DATAMM_MIM_OPENMM_MIM_CLOSEMM_MIM_DATAMM_MIM_LONGDATAMM_MIM_ERRORMM_MIM_LONGERRORMM_MOM_OPENMM_MOM_CLOSEMM_MOM_DONEMMSYSERR_BASEWAVERR_BASEMIDIERR_BASETIMERR_BASEJOYERR_BASEMCIERR_BASEMIXERR_BASEMMSYSERR_NOERRORMMSYSERR_ERRORMMSYSERR_BADDEVICEIDMMSYSERR_NOTENABLEDMMSYSERR_ALLOCATEDMMSYSERR_INVALHANDLEMMSYSERR_NODRIVERMMSYSERR_NOMEMMMSYSERR_NOTSUPPORTEDMMSYSERR_BADERRNUMMMSYSERR_INVALFLAGMMSYSERR_INVALPARAMMMSYSERR_HANDLEBUSYMMSYSERR_INVALIDALIASMMSYSERR_BADDBMMSYSERR_KEYNOTFOUNDMMSYSERR_READERRORMMSYSERR_WRITEERRORMMSYSERR_DELETEERRORMMSYSERR_VALNOTFOUNDMMSYSERR_NODRIVERCBMMSYSERR_MOREDATAMMSYSERR_LASTERRORMIDIERR_UNPREPAREDMIDIERR_STILLPLAYINGMIDIERR_NOMAPMIDIERR_NOTREADYMIDIERR_NODEVICEMIDIERR_INVALIDSETUPMIDIERR_BADOPENMODEMIDIERR_DONT_CONTINUEMIDIERR_LASTERRORCALLBACK_TYPEMASKCALLBACK_NULLCALLBACK_WINDOWCALLBACK_TASKCALLBACK_FUNCTIONCALLBACK_THREADCALLBACK_EVENTWAVERR_BADFORMAT//497 (Win 7 SDK)WAVERR_STILLPLAYINGWAVERR_UNPREPAREDWAVERR_SYNCWAVERR_LASTERRORWOM_OPENWOM_CLOSEWOM_DONEWIM_OPENWIM_CLOSEWIM_DATAWAVE_MAPPERWAVE_FORMAT_QUERYWAVE_ALLOWSYNCWAVE_MAPPEDWAVE_FORMAT_DIRECTWAVE_FORMAT_DIRECT_QUERYWAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICEPWAVEHDRWAVEHDRNPWAVEHDRPWAVEOUTCAPSWWAVEOUTCAPSWNPWAVEOUTCAPSWPWAVEINCAPSWWAVEINCAPSWNPWAVEINCAPSWWAVE_INVALIDFORMATWAVE_FORMAT_1M08WAVE_FORMAT_1S08WAVE_FORMAT_1M16WAVE_FORMAT_1S16WAVE_FORMAT_2M08WAVE_FORMAT_2S08WAVE_FORMAT_2M16WAVE_FORMAT_2S16WAVE_FORMAT_4M08WAVE_FORMAT_4S08WAVE_FORMAT_4M16WAVE_FORMAT_4S16WAVE_FORMAT_44M08WAVE_FORMAT_44S08WAVE_FORMAT_44M16WAVE_FORMAT_44S16WAVE_FORMAT_48M08WAVE_FORMAT_48S08WAVE_FORMAT_48M16WAVE_FORMAT_48S16WAVE_FORMAT_96M08WAVE_FORMAT_96S08WAVE_FORMAT_96M16WAVE_FORMAT_96S16PWAVEFORMATEX//782 (Win 7 SDK)NPWAVEFORMATEXTIMERR_NOERROR//2170 (Win 7 SDK)TIMERR_NOCANDOTIMERR_STRUCT//2198 (Win 7 SDK)PTIMECAPSTIMECAPSNPTIMECAPSLPTIMECAPSPMIDIHDRMIDIHDRNPMIDIHDRPMIDIINCAPSWMIDIINCAPSWNPMIDIINCAPSWPMIDIOUTCAPSWMIDIOUTCAPSWNPMIDIOUTCAPSWLPHMIDI//! MM procedure declarations, constant definitions and macrosadhocappmgmtaudioclientavrtbits10_1bits2_5bitscfgbitsmsgbluetoothapisbluetoothleapiscfgmgr32cguidcombaseapicoml2apicommapicommdlgcorsymd2d1_3d2d1effects_1d2d1effects_2d3dd3d10_1d3d10_1shaderd3d10effectd3d10miscd3d10sdklayersd3d10shaderd3d11_2d3d11_3d3d11_4d3d11on12d3d11sdklayersd3d11tokenizedprogramformatd3d12sdklayersd3d12shaderd3dcompilerd3dcsxd3dx10cored3dx10mathd3dx10meshdatetimeapidavclntdbtdcompddeddrawddrawiddrawintdebugapidevicetopologydinputdispexdmksctldmusiccdot1xdpa_dsadpapidsgetdcdsounddsroledvpdwmapidwrite_3dxdiagdxfiledxgidebugdxva2apidxvahdenclaveapiendpointvolumeexdispfibersapifunctiondiscoverykeys_devpkeyheapapihighlevelmonitorconfigurationapiinterlockedapiioapisetjobapijobapi2knownfoldersktmw32lmaccesslmalertlmapibuflmatlmdfslmerrloglmjoinlmmsglmremutllmrepllmserverlmsharelmstatslmsvclmuselmwkstalowlevelmonitorconfigurationapilsalookupmemoryapiminschannelmmdeviceapimmeapimsaatextmscatmschappmssipmswsocknamespaceapinb30ncryptntlsaobjbaseole2oleautoolectloleidlopmapipdhperflibplaysoundapiportabledeviceportabledeviceapiportabledevicetypespowerbasepowersettingpowrprofprocesssnapshotprocesstopologyapiprofileapipropkeypropkeydefpsapirealtimeapisetrestartmanagerrestrictederrorinformxfguidrtinfosapisapi51sapi53sapiddksapiddk51securityappcontainersetupapishellapishellscalingapishlobjshobjidlshobjidl_coreshtypessoftpubspapidefspellcheckspordersqlsqlextsqltypessqlucodestringapisetsystemtopologyapitaskschdtextstorthreadpoolapisetthreadpoollegacyapisettimeapitlhelp32urlhisturlmonusp10utilapisetvsbackupvssvsserrorvswriterwbemadswbemcliwbemdispwbemprovwbemtranwctwerapiwincodecsdkwindowsceipwinefswinevtwinhttpwininetwininetiwinnetwkwinnlswinsaferwinscardwinsmcrdwinspoolwintrustwinusbwinverwlanapiwlanihvwlanihvtypeswlclientwow64apisetwpdmtpextensionsws2bthws2spiwtsapi32SIP_INDIRECT_DATACRYPT_ATTR_BLOBHCRYPTMSGHCRYPTPROV//! Microsoft Internet Security Catalog API Prototypes and DefinitionsCYPHER_BLOCK_LENGTHPLM_OWF_PASSWORDLM_OWF_PASSWORDNT_OWF_PASSWORDPNT_OWF_PASSWORDPSAMPR_ENCRYPTED_USER_PASSWORDSAMPR_ENCRYPTED_USER_PASSWORDPENCRYPTED_LM_OWF_PASSWORDENCRYPTED_LM_OWF_PASSWORDENCRYPTED_NT_OWF_PASSWORDPENCRYPTED_NT_OWF_PASSWORDMSChapSrvChangePasswordMSChapSrvChangePassword2CRYPTCATMEMBERCRYPTCATSTORECRYPT_ALGORITHM_IDENTIFIERCRYPT_ATTRIBUTE_TYPE_VALUECRYPT_HASH_BLOBCRYPT_DIGEST_DATAMSSIP_FLAGS_PROHIBIT_RESIZE_ON_CREATEMSSIP_FLAGS_USE_CATALOGMSSIP_FLAGS_MULTI_HASHSPC_INC_PE_RESOURCES_FLAGSPC_INC_PE_DEBUG_INFO_FLAGSPC_INC_PE_IMPORT_ADDR_TABLE_FLAGSPC_EXC_PE_PAGE_HASHES_FLAGSPC_INC_PE_PAGE_HASHES_FLAGSPC_DIGEST_GENERATE_FLAGSPC_DIGEST_SIGN_FLAGSPC_RELAXED_PE_MARKER_CHECKSPC_MARKER_CHECK_SKIP_SIP_INDIRECT_DATA_FLAGSPC_MARKER_CHECK_CURRENTLY_SUPPORTED_FLAGSMSSIP_ADDINFO_NONEMSSIP_ADDINFO_FLATMSSIP_ADDINFO_CATMEMBERMSSIP_ADDINFO_BLOBMSSIP_ADDINFO_NONMSSIPLPSIP_SUBJECTINFOSIP_SUBJECTINFOPMS_ADDINFO_FLATMS_ADDINFO_FLATPMS_ADDINFO_CATALOGMEMBERMS_ADDINFO_CATALOGMEMBERPMS_ADDINFO_BLOBMS_ADDINFO_BLOBPSIP_CAP_SET_V2SIP_CAP_SET_V2PSIP_CAP_SET_V3SIP_CAP_SET_V3SIP_CAP_SETPSIP_CAP_SETSIP_CAP_SET_VERSION_2SIP_CAP_SET_VERSION_3SIP_CAP_SET_CUR_VERSIP_CAP_FLAG_SEALINGPSIP_INDIRECT_DATACryptSIPGetSignedDataMsgCryptSIPPutSignedDataMsgCryptSIPCreateIndirectDataCryptSIPVerifyIndirectDataCryptSIPRemoveSignedDataMsgLPSIP_DISPATCH_INFOSIP_DISPATCH_INFOPSIP_ADD_NEWPROVIDERSIP_ADD_NEWPROVIDERSIP_MAX_MAGIC_NUMBERCryptSIPLoadCryptSIPRetrieveSubjectGuidCryptSIPRetrieveSubjectGuidForCatalogFileCryptSIPAddProviderCryptSIPRemoveProviderCryptSIPGetCapsCryptSIPGetSealedDigest//! Microsoft SIP Provider Prototypes and DefinitionsLPWSAOVERLAPPEDLPWSAOVERLAPPED_COMPLETION_ROUTINELPWSAPOLLFDWSAESETSERVICEOPSO_CONNDATASO_CONNOPTSO_DISCDATASO_DISCOPTSO_CONNDATALENSO_CONNOPTLENSO_DISCDATALENSO_DISCOPTLENSO_OPENTYPESO_SYNCHRONOUS_ALERTSO_SYNCHRONOUS_NONALERTSO_MAXDGSO_MAXPATHDGSO_UPDATE_ACCEPT_CONTEXTSO_CONNECT_TIMESO_UPDATE_CONNECT_CONTEXTTCP_BSDURGENTSIO_UDP_CONNRESETSIO_SOCKET_CLOSE_NOTIFYSIO_UDP_NETRESETWSARecvExPTRANSMIT_FILE_BUFFERSTRANSMIT_FILE_BUFFERSLPTRANSMIT_FILE_BUFFERSTF_DISCONNECTTF_REUSE_SOCKETTF_WRITE_BEHINDTF_USE_DEFAULT_WORKERTF_USE_SYSTEM_THREADTF_USE_KERNEL_APCTransmitFileAcceptExGetAcceptExSockaddrsTP_ELEMENT_MEMORYTP_ELEMENT_FILETP_ELEMENT_EOPPTRANSMIT_PACKETS_ELEMENTTRANSMIT_PACKETS_ELEMENTLPTRANSMIT_PACKETS_ELEMENTTP_DISCONNECTTP_REUSE_SOCKETTP_USE_DEFAULT_WORKERTP_USE_SYSTEM_THREADTP_USE_KERNEL_APCDE_REUSE_SOCKETNLA_ALLUSERS_NETWORKNLA_FRIENDLY_NAMEPNLA_BLOB_DATA_TYPENLA_BLOB_DATA_TYPEPNLA_CONNECTIVITY_TYPENLA_CONNECTIVITY_TYPEPNLA_INTERNETNLA_INTERNETPNLA_BLOBNLA_BLOBLPNLA_BLOBSIO_BSP_HANDLESIO_BSP_HANDLE_SELECTSIO_EXT_SELECTSIO_EXT_POLLSIO_EXT_SENDMSGLPWSAPOLLDATAWSAPOLLDATALPWSASENDMSGWSASENDMSGPRIO_NOTIFICATION_COMPLETION_TYPERIO_NOTIFICATION_COMPLETION_TYPEPRIO_NOTIFICATION_COMPLETIONRIO_NOTIFICATION_COMPLETIONPRIO_EXTENSION_FUNCTION_TABLERIO_EXTENSION_FUNCTION_TABLESetNamedPipeHandleStatePeekNamedPipeTransactNamedPipeWaitNamedPipeWGetNamedPipeClientComputerNameWImpersonateNamedPipeClientGetNamedPipeHandleStateWCallNamedPipeWPRIVATE_NAMESPACE_FLAG_DESTROYCreatePrivateNamespaceWOpenPrivateNamespaceWClosePrivateNamespaceCreateBoundaryDescriptorWAddSIDToBoundaryDescriptorDeleteBoundaryDescriptorNCBNAMSZMAX_LANAPNCBNCBPADAPTER_STATUSADAPTER_STATUSPNAME_BUFFERNAME_BUFFERNAME_FLAGS_MASKGROUP_NAMEUNIQUE_NAMEDEREGISTEREDDUPLICATEDUPLICATE_DEREGPSESSION_HEADERSESSION_HEADERPSESSION_BUFFERSESSION_BUFFERLISTEN_OUTSTANDINGCALL_PENDINGSESSION_ESTABLISHEDHANGUP_PENDINGHANGUP_COMPLETESESSION_ABORTEDPLANA_ENUMLANA_ENUMPFIND_NAME_HEADERFIND_NAME_HEADERPFIND_NAME_BUFFERFIND_NAME_BUFFERPACTION_HEADERACTION_HEADERALL_TRANSPORTSMS_NBFNCBCALLNCBLISTENNCBHANGUPNCBSENDNCBRECVNCBRECVANYNCBCHAINSENDNCBDGSENDNCBDGRECVNCBDGSENDBCNCBADDNAMENCBDELNAMENCBRESETNCBASTATNCBSSTATNCBCANCELNCBADDGRNAMENCBENUMNCBUNLINKNCBSENDNANCBCHAINSENDNANCBLANSTALERTNCBACTIONNCBFINDNAMENCBTRACEASYNCHNRC_GOODRETNRC_BUFLENNRC_ILLCMDNRC_CMDTMONRC_INCOMPNRC_BADDRNRC_SNUMOUTNRC_NORESNRC_SCLOSEDNRC_CMDCANNRC_DUPNAMENRC_NAMTFULNRC_ACTSESNRC_LOCTFULNRC_REMTFULNRC_ILLNNNRC_NOCALLNRC_NOWILDNRC_INUSENRC_NAMERRNRC_SABORTNRC_NAMCONFNRC_IFBUSYNRC_TOOMANYNRC_BRIDGENRC_CANOCCRNRC_CANCELNRC_DUPENVNRC_ENVNOTDEFNRC_OSRESNOTAVNRC_MAXAPPSNRC_NOSAPSNRC_NORESOURCESNRC_INVADDRESSNRC_INVDDIDNRC_LOCKFAILNRC_OPENERRNRC_SYSTEMNRC_PENDINGNetbios//! This module contains the definitions for portable NetBIOS 3.0 support.HCRYPTKEYHCRYPTHASHNCryptBufferDescNCRYPT_HANDLENCRYPT_PROV_HANDLENCRYPT_KEY_HANDLENCRYPT_HASH_HANDLENCRYPT_SECRET_HANDLENCRYPT_NO_PADDING_FLAGNCRYPT_PAD_PKCS1_FLAGNCRYPT_PAD_OAEP_FLAGNCRYPT_PAD_PSS_FLAGNCRYPT_PAD_CIPHER_FLAGNCRYPT_ATTESTATION_FLAGNCRYPT_SEALING_FLAGNCRYPT_REGISTER_NOTIFY_FLAGNCRYPT_UNREGISTER_NOTIFY_FLAGNCRYPT_NO_KEY_VALIDATIONNCRYPT_MACHINE_KEY_FLAGNCRYPT_SILENT_FLAGNCRYPT_OVERWRITE_KEY_FLAGNCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAGNCRYPT_DO_NOT_FINALIZE_FLAGNCRYPT_EXPORT_LEGACY_FLAGNCRYPT_IGNORE_DEVICE_STATE_FLAGNCRYPT_TREAT_NIST_AS_GENERIC_ECC_FLAGNCRYPT_NO_CACHED_PASSWORDNCRYPT_PROTECT_TO_LOCAL_SYSTEMNCRYPT_PERSIST_ONLY_FLAGNCRYPT_PERSIST_FLAGNCRYPT_PREFER_VIRTUAL_ISOLATION_FLAGNCRYPT_USE_VIRTUAL_ISOLATION_FLAGNCRYPT_USE_PER_BOOT_KEY_FLAGNCryptOpenStorageProviderNCRYPT_ALLOW_EXPORT_FLAGNCRYPT_ALLOW_PLAINTEXT_EXPORT_FLAGNCRYPT_ALLOW_ARCHIVING_FLAGNCRYPT_ALLOW_PLAINTEXT_ARCHIVING_FLAGNCryptSetPropertyNCryptImportKeyNCryptFreeObjectPLSA_HANDLEPCLAIMS_BLOBPPRIVILEGE_SETPQUOTA_LIMITSPTOKEN_GROUPSPTOKEN_PRIVILEGESPTOKEN_SOURCEQUOTA_LIMITSSTANDARD_RIGHTS_EXECUTESTANDARD_RIGHTS_WRITETOKEN_DEFAULT_DACLTOKEN_DEVICE_CLAIMSTOKEN_OWNERTOKEN_PRIMARY_GROUPTOKEN_USER_CLAIMSLSA_OPERATIONAL_MODEPLSA_OPERATIONAL_MODELSA_MODE_PASSWORD_PROTECTEDLSA_MODE_INDIVIDUAL_ACCOUNTSLSA_MODE_MANDATORY_ACCESSLSA_MODE_LOG_FULLLSA_MAXIMUM_SID_COUNTLSA_MAXIMUM_ENUMERATION_LENGTHLSA_CALL_LICENSE_SERVERPSECURITY_LOGON_TYPESECURITY_ACCESS_INTERACTIVE_LOGONSECURITY_ACCESS_NETWORK_LOGONSECURITY_ACCESS_BATCH_LOGONSECURITY_ACCESS_SERVICE_LOGONSECURITY_ACCESS_PROXY_LOGONSECURITY_ACCESS_DENY_INTERACTIVE_LOGONSECURITY_ACCESS_DENY_NETWORK_LOGONSECURITY_ACCESS_DENY_BATCH_LOGONSECURITY_ACCESS_DENY_SERVICE_LOGONSECURITY_ACCESS_REMOTE_INTERACTIVE_LOGONSECURITY_ACCESS_DENY_REMOTE_INTERACTIVE_LOGONPSE_ADT_PARAMETER_TYPESE_ADT_PARAMETER_TYPESE_ADT_OBJECT_ONLYPSE_ADT_OBJECT_TYPESE_ADT_OBJECT_TYPEPSE_ADT_PARAMETER_ARRAY_ENTRYSE_ADT_PARAMETER_ARRAY_ENTRYPSE_ADT_ACCESS_REASONSE_ADT_ACCESS_REASONPSE_ADT_CLAIMSSE_ADT_CLAIMSSE_MAX_AUDIT_PARAMETERSSE_MAX_GENERIC_AUDIT_PARAMETERSPSE_ADT_PARAMETER_ARRAYSE_ADT_PARAMETER_ARRAYPSE_ADT_PARAMETER_ARRAY_EXSE_ADT_PARAMETER_ARRAY_EXSE_ADT_PARAMETERS_SELF_RELATIVESE_ADT_PARAMETERS_SEND_TO_LSASE_ADT_PARAMETER_EXTENSIBLE_AUDITSE_ADT_PARAMETER_GENERIC_AUDITSE_ADT_PARAMETER_WRITE_SYNCHRONOUSLSAP_SE_ADT_PARAMETER_ARRAY_TRUE_SIZEPLSA_ADT_STRING_LIST_ENTRYLSA_ADT_STRING_LIST_ENTRYPLSA_ADT_STRING_LISTLSA_ADT_STRING_LISTPLSA_ADT_SID_LIST_ENTRYLSA_ADT_SID_LIST_ENTRYPLSA_ADT_SID_LISTLSA_ADT_SID_LISTLSA_ADT_SECURITY_SOURCE_NAMELSA_ADT_LEGACY_SECURITY_SOURCE_NAMESE_ADT_POLICY_AUDIT_EVENT_TYPE_EX_BEGINPPOLICY_AUDIT_EVENT_TYPE_EXPOLICY_AUDIT_EVENT_TYPE_EXPPOLICY_AUDIT_EVENT_TYPEPOLICY_AUDIT_EVENT_TYPEPOLICY_AUDIT_EVENT_UNCHANGEDPOLICY_AUDIT_EVENT_SUCCESSPOLICY_AUDIT_EVENT_FAILUREPOLICY_AUDIT_EVENT_NONEPOLICY_AUDIT_EVENT_MASKLSA_SUCCESSLsaRegisterLogonProcessLsaLogonUserLsaLookupAuthenticationPackageLsaCallAuthenticationPackageLsaDeregisterLogonProcessLsaConnectUntrustedLsaInsertProtectedProcessAddressLsaRemoveProtectedProcessAddressPLSA_AUTH_CALLBACKSLSA_AUTH_CALLBACKSPCLSA_AUTH_CALLBACKSPLSA_CLIENT_REQUESTPLSA_TOKEN_INFORMATION_TYPELSA_TOKEN_INFORMATION_TYPEPLSA_TOKEN_INFORMATION_NULLLSA_TOKEN_INFORMATION_NULLPLSA_TOKEN_INFORMATION_V1LSA_TOKEN_INFORMATION_V1LSA_TOKEN_INFORMATION_V2PLSA_TOKEN_INFORMATION_V2PLSA_TOKEN_INFORMATION_V3LSA_TOKEN_INFORMATION_V3PLSA_DISPATCH_TABLELSA_DISPATCH_TABLELSA_AP_NAME_INITIALIZE_PACKAGELSA_AP_NAME_LOGON_USERLSA_AP_NAME_LOGON_USER_EXLSA_AP_NAME_CALL_PACKAGELSA_AP_NAME_LOGON_TERMINATEDLSA_AP_NAME_CALL_PACKAGE_UNTRUSTEDLSA_AP_NAME_CALL_PACKAGE_PASSTHROUGHPOLICY_VIEW_LOCAL_INFORMATIONPOLICY_VIEW_AUDIT_INFORMATIONPOLICY_GET_PRIVATE_INFORMATIONPOLICY_TRUST_ADMINPOLICY_CREATE_ACCOUNTPOLICY_CREATE_SECRETPOLICY_CREATE_PRIVILEGEPOLICY_SET_DEFAULT_QUOTA_LIMITSPOLICY_SET_AUDIT_REQUIREMENTSPOLICY_AUDIT_LOG_ADMINPOLICY_SERVER_ADMINPOLICY_LOOKUP_NAMESPOLICY_NOTIFICATIONPOLICY_ALL_ACCESSPOLICY_READPOLICY_WRITEPOLICY_EXECUTEPLSA_TRANSLATED_SIDLSA_TRANSLATED_SIDPOLICY_SYSTEM_ACCESS_MODEPPOLICY_SYSTEM_ACCESS_MODEPOLICY_MODE_INTERACTIVEPOLICY_MODE_NETWORKPOLICY_MODE_BATCHPOLICY_MODE_SERVICEPOLICY_MODE_PROXYPOLICY_MODE_DENY_INTERACTIVEPOLICY_MODE_DENY_NETWORKPOLICY_MODE_DENY_BATCHPOLICY_MODE_DENY_SERVICEPOLICY_MODE_REMOTE_INTERACTIVEPOLICY_MODE_DENY_REMOTE_INTERACTIVEPOLICY_MODE_ALLPOLICY_MODE_ALL_NT4PPOLICY_LSA_SERVER_ROLEPOLICY_LSA_SERVER_ROLEPPOLICY_SERVER_ENABLE_STATEPOLICY_SERVER_ENABLE_STATEPOLICY_AUDIT_EVENT_OPTIONSPPOLICY_AUDIT_EVENT_OPTIONSPPOLICY_PRIVILEGE_DEFINITIONPOLICY_PRIVILEGE_DEFINITIONLSA_LOOKUP_ISOLATED_AS_LOCALLSA_LOOKUP_DISALLOW_CONNECTED_ACCOUNT_INTERNET_SIDLSA_LOOKUP_PREFER_INTERNET_NAMESPPOLICY_INFORMATION_CLASSPOLICY_INFORMATION_CLASSPPOLICY_AUDIT_LOG_INFOPOLICY_AUDIT_LOG_INFOPPOLICY_AUDIT_EVENTS_INFOPOLICY_AUDIT_EVENTS_INFOPPOLICY_AUDIT_SUBCATEGORIES_INFOPOLICY_AUDIT_SUBCATEGORIES_INFOPPOLICY_AUDIT_CATEGORIES_INFOPOLICY_AUDIT_CATEGORIES_INFOPER_USER_POLICY_UNCHANGEDPER_USER_AUDIT_SUCCESS_INCLUDEPER_USER_AUDIT_SUCCESS_EXCLUDEPER_USER_AUDIT_FAILURE_INCLUDEPER_USER_AUDIT_FAILURE_EXCLUDEPER_USER_AUDIT_NONEVALID_PER_USER_AUDIT_POLICY_FLAGPPOLICY_PRIMARY_DOMAIN_INFOPOLICY_PRIMARY_DOMAIN_INFOPPOLICY_PD_ACCOUNT_INFOPOLICY_PD_ACCOUNT_INFOPPOLICY_LSA_SERVER_ROLE_INFOPOLICY_LSA_SERVER_ROLE_INFOPPOLICY_REPLICA_SOURCE_INFOPOLICY_REPLICA_SOURCE_INFOPPOLICY_DEFAULT_QUOTA_INFOPOLICY_DEFAULT_QUOTA_INFOPPOLICY_MODIFICATION_INFOPOLICY_MODIFICATION_INFOPPOLICY_AUDIT_FULL_SET_INFOPOLICY_AUDIT_FULL_SET_INFOPPOLICY_AUDIT_FULL_QUERY_INFOPOLICY_AUDIT_FULL_QUERY_INFOPPOLICY_DOMAIN_INFORMATION_CLASSPOLICY_DOMAIN_INFORMATION_CLASSPOLICY_QOS_SCHANNEL_REQUIREDPOLICY_QOS_OUTBOUND_INTEGRITYPOLICY_QOS_OUTBOUND_CONFIDENTIALITYPOLICY_QOS_INBOUND_INTEGRITYPOLICY_QOS_INBOUND_CONFIDENTIALITYPOLICY_QOS_ALLOW_LOCAL_ROOT_CERT_STOREPOLICY_QOS_RAS_SERVER_ALLOWEDPOLICY_QOS_DHCP_SERVER_ALLOWEDPPOLICY_DOMAIN_EFS_INFOPOLICY_DOMAIN_EFS_INFOPOLICY_KERBEROS_VALIDATE_CLIENTPPOLICY_DOMAIN_KERBEROS_TICKET_INFOPOLICY_DOMAIN_KERBEROS_TICKET_INFOPPOLICY_NOTIFICATION_INFORMATION_CLASSPOLICY_NOTIFICATION_INFORMATION_CLASSACCOUNT_VIEWACCOUNT_ADJUST_PRIVILEGESACCOUNT_ADJUST_QUOTASACCOUNT_ADJUST_SYSTEM_ACCESSACCOUNT_ALL_ACCESSACCOUNT_READACCOUNT_WRITEACCOUNT_EXECUTETRUSTED_QUERY_DOMAIN_NAMETRUSTED_QUERY_CONTROLLERSTRUSTED_SET_CONTROLLERSTRUSTED_QUERY_POSIXTRUSTED_SET_POSIXTRUSTED_SET_AUTHTRUSTED_QUERY_AUTHTRUSTED_ALL_ACCESSTRUSTED_READTRUSTED_WRITETRUSTED_EXECUTEPTRUSTED_INFORMATION_CLASSTRUSTED_INFORMATION_CLASSPTRUSTED_DOMAIN_NAME_INFOTRUSTED_DOMAIN_NAME_INFOPTRUSTED_CONTROLLERS_INFOTRUSTED_CONTROLLERS_INFOPTRUSTED_POSIX_OFFSET_INFOTRUSTED_POSIX_OFFSET_INFOPTRUSTED_PASSWORD_INFOTRUSTED_PASSWORD_INFOTRUSTED_DOMAIN_INFORMATION_BASICPTRUSTED_DOMAIN_INFORMATION_BASICTRUST_DIRECTION_DISABLED// NOTE: Ignoring Win XP constantsTRUST_DIRECTION_INBOUNDTRUST_DIRECTION_OUTBOUNDTRUST_DIRECTION_BIDIRECTIONALTRUST_TYPE_DOWNLEVELTRUST_TYPE_UPLEVELTRUST_TYPE_MITTRUST_ATTRIBUTE_NON_TRANSITIVETRUST_ATTRIBUTE_UPLEVEL_ONLYTRUST_ATTRIBUTE_QUARANTINED_DOMAINTRUST_ATTRIBUTE_FOREST_TRANSITIVETRUST_ATTRIBUTE_CROSS_ORGANIZATIONTRUST_ATTRIBUTE_WITHIN_FORESTTRUST_ATTRIBUTE_TREAT_AS_EXTERNALTRUST_ATTRIBUTE_TRUST_USES_RC4_ENCRYPTIONTRUST_ATTRIBUTE_TRUST_USES_AES_KEYSTRUST_ATTRIBUTE_CROSS_ORGANIZATION_NO_TGT_DELEGATIONTRUST_ATTRIBUTE_PIM_TRUSTTRUST_ATTRIBUTES_VALIDTRUST_ATTRIBUTES_USERPTRUSTED_DOMAIN_INFORMATION_EXTRUSTED_DOMAIN_INFORMATION_EXPTRUSTED_DOMAIN_INFORMATION_EX2TRUSTED_DOMAIN_INFORMATION_EX2TRUST_AUTH_TYPE_NONETRUST_AUTH_TYPE_NT4OWFTRUST_AUTH_TYPE_CLEARTRUST_AUTH_TYPE_VERSIONPLSA_AUTH_INFORMATIONLSA_AUTH_INFORMATIONPTRUSTED_DOMAIN_AUTH_INFORMATIONTRUSTED_DOMAIN_AUTH_INFORMATIONPTRUSTED_DOMAIN_FULL_INFORMATIONTRUSTED_DOMAIN_FULL_INFORMATIONPTRUSTED_DOMAIN_FULL_INFORMATION2TRUSTED_DOMAIN_FULL_INFORMATION2PTRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPESTRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPESLSA_FTRECORD_DISABLED_REASONSLSA_TLN_DISABLED_NEWLSA_TLN_DISABLED_ADMINLSA_TLN_DISABLED_CONFLICTLSA_SID_DISABLED_ADMINLSA_SID_DISABLED_CONFLICTLSA_NB_DISABLED_ADMINLSA_NB_DISABLED_CONFLICTPLSA_FOREST_TRUST_DOMAIN_INFOLSA_FOREST_TRUST_DOMAIN_INFOMAX_FOREST_TRUST_BINARY_DATA_SIZEPLSA_FOREST_TRUST_BINARY_DATALSA_FOREST_TRUST_BINARY_DATAPLSA_FOREST_TRUST_RECORDLSA_FOREST_TRUST_RECORDMAX_RECORDS_IN_FOREST_TRUST_INFOLSA_FOREST_TRUST_INFORMATIONPLSA_FOREST_TRUST_COLLISION_RECORDLSA_FOREST_TRUST_COLLISION_RECORDPLSA_FOREST_TRUST_COLLISION_INFORMATIONLSA_FOREST_TRUST_COLLISION_INFORMATIONSECRET_SET_VALUESECRET_QUERY_VALUESECRET_ALL_ACCESSSECRET_READSECRET_WRITESECRET_EXECUTELSA_GLOBAL_SECRET_PREFIXLSA_GLOBAL_SECRET_PREFIX_LENGTHLSA_LOCAL_SECRET_PREFIXLSA_LOCAL_SECRET_PREFIX_LENGTHLSA_MACHINE_SECRET_PREFIXLSA_MACHINE_SECRET_PREFIX_LENGTHLSA_SECRET_MAXIMUM_COUNTLSA_SECRET_MAXIMUM_LENGTHPLSA_ENUMERATION_HANDLELSA_ENUMERATION_HANDLEPLSA_ENUMERATION_INFORMATIONLSA_ENUMERATION_INFORMATIONLsaFreeMemoryLsaCloseLSA_HANDLELsaDeleteLsaQuerySecurityObjectLsaSetSecurityObjectLsaChangePasswordPLSA_LAST_INTER_LOGON_INFOLSA_LAST_INTER_LOGON_INFOPSECURITY_LOGON_SESSION_DATALsaOpenPolicyLsaOpenPolicySceMAXIMUM_CAPES_PER_CAPCENTRAL_ACCESS_POLICY_OWNER_RIGHTS_PRESENT_FLAGCENTRAL_ACCESS_POLICY_STAGED_OWNER_RIGHTS_PRESENT_FLAGSTAGING_FLAGCENTRAL_ACCESS_POLICY_STAGED_FLAGCENTRAL_ACCESS_POLICY_VALID_FLAG_MASKLSASETCAPS_RELOAD_FLAGLSASETCAPS_VALID_FLAG_MASKPCENTRAL_ACCESS_POLICY_ENTRYCENTRAL_ACCESS_POLICY_ENTRYPCCENTRAL_ACCESS_POLICY_ENTRYPCENTRAL_ACCESS_POLICYCENTRAL_ACCESS_POLICYPCCENTRAL_ACCESS_POLICYLsaSetCAPsLsaGetAppliedCAPIDsLsaQueryCAPsLsaQueryInformationPolicyLsaSetInformationPolicyLsaQueryDomainInformationPolicyLsaSetDomainInformationPolicyLsaRegisterPolicyChangeNotificationLsaUnregisterPolicyChangeNotificationLsaClearAuditLogLsaCreateAccountLsaEnumerateAccountsLsaCreateTrustedDomainLsaEnumerateTrustedDomainsLsaEnumeratePrivilegesLsaLookupNamesLsaLookupNames2LsaLookupSidsLsaLookupSids2LsaCreateSecretLsaOpenAccountLsaEnumeratePrivilegesOfAccountLsaAddPrivilegesToAccountLsaRemovePrivilegesFromAccountLsaGetQuotasForAccountLsaSetQuotasForAccountLsaGetSystemAccessAccountLsaSetSystemAccessAccountLsaOpenTrustedDomainLsaQueryInfoTrustedDomainLsaSetInformationTrustedDomainLsaOpenSecretLsaSetSecretLsaQuerySecretLsaLookupPrivilegeValueLsaLookupPrivilegeNameLsaLookupPrivilegeDisplayNameLsaGetUserNameLsaGetRemoteUserNameSE_INTERACTIVE_LOGON_NAMESE_NETWORK_LOGON_NAMESE_BATCH_LOGON_NAMESE_SERVICE_LOGON_NAMESE_DENY_INTERACTIVE_LOGON_NAMESE_DENY_NETWORK_LOGON_NAMESE_DENY_BATCH_LOGON_NAMESE_DENY_SERVICE_LOGON_NAMESE_REMOTE_INTERACTIVE_LOGON_NAMESE_DENY_REMOTE_INTERACTIVE_LOGON_NAMELsaEnumerateAccountsWithUserRightLsaEnumerateAccountRightsLsaAddAccountRightsLsaRemoveAccountRightsLsaOpenTrustedDomainByNameLsaQueryTrustedDomainInfoLsaSetTrustedDomainInformationLsaDeleteTrustedDomainLsaQueryTrustedDomainInfoByNameLsaSetTrustedDomainInfoByNameLsaEnumerateTrustedDomainsExLsaCreateTrustedDomainExLsaQueryForestTrustInformationLsaSetForestTrustInformationLsaForestTrustFindMatchLsaStorePrivateDataLsaRetrievePrivateDataLsaNtStatusToWinErrorNEGOTIATE_MAX_PREFIXPNEGOTIATE_PACKAGE_PREFIXNEGOTIATE_PACKAGE_PREFIXPNEGOTIATE_PACKAGE_PREFIXESNEGOTIATE_PACKAGE_PREFIXESPNEGOTIATE_CALLER_NAME_REQUESTNEGOTIATE_CALLER_NAME_REQUESTPNEGOTIATE_CALLER_NAME_RESPONSENEGOTIATE_CALLER_NAME_RESPONSEPNEGOTIATE_PACKAGE_NAMESNEGOTIATE_PACKAGE_NAMESNEGOTIATE_ALLOW_NTLMNEGOTIATE_NEG_NTLMPNEGOTIATE_PACKAGE_PREFIX_WOWNEGOTIATE_PACKAGE_PREFIX_WOWPNEGOTIATE_CALLER_NAME_RESPONSE_WOWNEGOTIATE_CALLER_NAME_RESPONSE_WOWLsaSetPolicyReplicationHandleMAX_USER_RECORDSPLSA_USER_REGISTRATION_INFOLSA_USER_REGISTRATION_INFOPLSA_REGISTRATION_INFOLSA_REGISTRATION_INFOLsaGetDeviceRegistrationInfoPLSA_CREDENTIAL_KEY_SOURCE_TYPELSA_CREDENTIAL_KEY_SOURCE_TYPESeciIsProtectedUserPDOMAIN_PASSWORD_INFORMATIONDOMAIN_PASSWORD_INFORMATIONDOMAIN_PASSWORD_COMPLEXDOMAIN_PASSWORD_NO_ANON_CHANGEDOMAIN_PASSWORD_NO_CLEAR_CHANGEDOMAIN_LOCKOUT_ADMINSDOMAIN_PASSWORD_STORE_CLEARTEXTDOMAIN_REFUSE_PASSWORD_CHANGEDOMAIN_NO_LM_OWF_CHANGEPMSV1_0_LOGON_SUBMIT_TYPEMSV1_0_LOGON_SUBMIT_TYPEPMSV1_0_PROFILE_BUFFER_TYPEMSV1_0_PROFILE_BUFFER_TYPEPMSV1_0_INTERACTIVE_LOGONMSV1_0_INTERACTIVE_LOGONPMSV1_0_INTERACTIVE_PROFILEMSV1_0_INTERACTIVE_PROFILEMSV1_0_CHALLENGE_LENGTHMSV1_0_USER_SESSION_KEY_LENGTHMSV1_0_LANMAN_SESSION_KEY_LENGTHMSV1_0_CLEARTEXT_PASSWORD_ALLOWEDMSV1_0_UPDATE_LOGON_STATISTICSMSV1_0_RETURN_USER_PARAMETERSMSV1_0_DONT_TRY_GUEST_ACCOUNTMSV1_0_ALLOW_SERVER_TRUST_ACCOUNTMSV1_0_RETURN_PASSWORD_EXPIRYMSV1_0_USE_CLIENT_CHALLENGEMSV1_0_TRY_GUEST_ACCOUNT_ONLYMSV1_0_RETURN_PROFILE_PATHMSV1_0_TRY_SPECIFIED_DOMAIN_ONLYMSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNTMSV1_0_DISABLE_PERSONAL_FALLBACKMSV1_0_ALLOW_FORCE_GUESTMSV1_0_CLEARTEXT_PASSWORD_SUPPLIEDMSV1_0_USE_DOMAIN_FOR_ROUTING_ONLYMSV1_0_SUBAUTHENTICATION_DLL_EXMSV1_0_ALLOW_MSVCHAPV2MSV1_0_S4U2SELFMSV1_0_CHECK_LOGONHOURS_FOR_S4UMSV1_0_INTERNET_DOMAINMSV1_0_SUBAUTHENTICATION_DLLMSV1_0_SUBAUTHENTICATION_DLL_SHIFTMSV1_0_MNS_LOGONMSV1_0_SUBAUTHENTICATION_DLL_RASMSV1_0_SUBAUTHENTICATION_DLL_IISPMSV1_0_LM20_LOGONMSV1_0_LM20_LOGONPMSV1_0_SUBAUTH_LOGONMSV1_0_SUBAUTH_LOGONPMSV1_0_S4U_LOGONMSV1_0_S4U_LOGONLOGON_GUESTLOGON_NOENCRYPTIONLOGON_CACHED_ACCOUNTLOGON_USED_LM_PASSWORDLOGON_EXTRA_SIDSLOGON_SUBAUTH_SESSION_KEYLOGON_SERVER_TRUST_ACCOUNTLOGON_NTLMV2_ENABLEDLOGON_RESOURCE_GROUPSLOGON_PROFILE_PATH_RETURNEDLOGON_NT_V2LOGON_LM_V2LOGON_NTLM_V2LOGON_OPTIMIZEDLOGON_WINLOGONLOGON_PKINITLOGON_NO_OPTIMIZEDLOGON_NO_ELEVATIONLOGON_MANAGED_SERVICELOGON_GRACE_LOGONPMSV1_0_LM20_LOGON_PROFILEMSV1_0_LM20_LOGON_PROFILEMSV1_0_OWF_PASSWORD_LENGTHPMSV1_0_SUPPLEMENTAL_CREDENTIALMSV1_0_SUPPLEMENTAL_CREDENTIALMSV1_0_NTLM3_RESPONSE_LENGTHMSV1_0_NTLM3_OWF_LENGTHPMSV1_0_NTLM3_RESPONSEMSV1_0_NTLM3_RESPONSEPMSV1_0_AV_PAIRMSV1_0_AV_PAIRPMSV1_0_PROTOCOL_MESSAGE_TYPEMSV1_0_PROTOCOL_MESSAGE_TYPEPMSV1_0_CHANGEPASSWORD_REQUESTMSV1_0_CHANGEPASSWORD_REQUESTPMSV1_0_CHANGEPASSWORD_RESPONSEMSV1_0_CHANGEPASSWORD_RESPONSEPMSV1_0_PASSTHROUGH_REQUESTMSV1_0_PASSTHROUGH_REQUESTPMSV1_0_PASSTHROUGH_RESPONSEMSV1_0_PASSTHROUGH_RESPONSEPMSV1_0_SUBAUTH_REQUESTMSV1_0_SUBAUTH_REQUESTPMSV1_0_SUBAUTH_RESPONSEMSV1_0_SUBAUTH_RESPONSESystemFunction036SystemFunction040RtlEncryptMemorySystemFunction041RtlDecryptMemoryRTL_ENCRYPT_MEMORY_SIZERTL_ENCRYPT_OPTION_CROSS_PROCESSRTL_ENCRYPT_OPTION_SAME_LOGONKERBEROS_VERSIONKERBEROS_REVISIONKERB_ETYPE_NULLKERB_ETYPE_DES_CBC_CRCKERB_ETYPE_DES_CBC_MD4KERB_ETYPE_DES_CBC_MD5KERB_ETYPE_AES128_CTS_HMAC_SHA1_96KERB_ETYPE_AES256_CTS_HMAC_SHA1_96KERB_ETYPE_RC4_MD4KERB_ETYPE_RC4_PLAIN2KERB_ETYPE_RC4_LMKERB_ETYPE_RC4_SHAKERB_ETYPE_DES_PLAINKERB_ETYPE_RC4_HMAC_OLDKERB_ETYPE_RC4_PLAIN_OLDKERB_ETYPE_RC4_HMAC_OLD_EXPKERB_ETYPE_RC4_PLAIN_OLD_EXPKERB_ETYPE_RC4_PLAINKERB_ETYPE_RC4_PLAIN_EXPKERB_ETYPE_AES128_CTS_HMAC_SHA1_96_PLAINKERB_ETYPE_AES256_CTS_HMAC_SHA1_96_PLAINKERB_ETYPE_DSA_SHA1_CMSKERB_ETYPE_RSA_MD5_CMSKERB_ETYPE_RSA_SHA1_CMSKERB_ETYPE_RC2_CBC_ENVKERB_ETYPE_RSA_ENVKERB_ETYPE_RSA_ES_OEAP_ENVKERB_ETYPE_DES_EDE3_CBC_ENVKERB_ETYPE_DSA_SIGNKERB_ETYPE_RSA_PRIVKERB_ETYPE_RSA_PUBKERB_ETYPE_RSA_PUB_MD5KERB_ETYPE_RSA_PUB_SHA1KERB_ETYPE_PKCS7_PUBKERB_ETYPE_DES3_CBC_MD5KERB_ETYPE_DES3_CBC_SHA1KERB_ETYPE_DES3_CBC_SHA1_KDKERB_ETYPE_DES_CBC_MD5_NTKERB_ETYPE_RC4_HMAC_NTKERB_ETYPE_RC4_HMAC_NT_EXPKERB_CHECKSUM_NONEKERB_CHECKSUM_CRC32KERB_CHECKSUM_MD4KERB_CHECKSUM_KRB_DES_MACKERB_CHECKSUM_KRB_DES_MAC_KKERB_CHECKSUM_MD5KERB_CHECKSUM_MD5_DESKERB_CHECKSUM_SHA1_NEWKERB_CHECKSUM_HMAC_SHA1_96_AES128KERB_CHECKSUM_HMAC_SHA1_96_AES256KERB_CHECKSUM_LMKERB_CHECKSUM_SHA1KERB_CHECKSUM_REAL_CRC32KERB_CHECKSUM_DES_MACKERB_CHECKSUM_DES_MAC_MD5KERB_CHECKSUM_MD25KERB_CHECKSUM_RC4_MD5KERB_CHECKSUM_MD5_HMACKERB_CHECKSUM_HMAC_MD5KERB_CHECKSUM_HMAC_SHA1_96_AES128_KiKERB_CHECKSUM_HMAC_SHA1_96_AES256_KiKERB_TICKET_FLAGS_reservedKERB_TICKET_FLAGS_forwardableKERB_TICKET_FLAGS_forwardedKERB_TICKET_FLAGS_proxiableKERB_TICKET_FLAGS_proxyKERB_TICKET_FLAGS_may_postdateKERB_TICKET_FLAGS_postdatedKERB_TICKET_FLAGS_invalidKERB_TICKET_FLAGS_renewableKERB_TICKET_FLAGS_initialKERB_TICKET_FLAGS_pre_authentKERB_TICKET_FLAGS_hw_authentKERB_TICKET_FLAGS_ok_as_delegateKERB_TICKET_FLAGS_name_canonicalizeKERB_TICKET_FLAGS_cname_in_pa_dataKERB_TICKET_FLAGS_enc_pa_repKERB_TICKET_FLAGS_reserved1KRB_NT_UNKNOWNKRB_NT_PRINCIPALKRB_NT_PRINCIPAL_AND_IDKRB_NT_SRV_INSTKRB_NT_SRV_INST_AND_IDKRB_NT_SRV_HSTKRB_NT_SRV_XHSTKRB_NT_UIDKRB_NT_ENTERPRISE_PRINCIPALKRB_NT_WELLKNOWNKRB_NT_ENT_PRINCIPAL_AND_IDKRB_NT_MS_PRINCIPALKRB_NT_MS_PRINCIPAL_AND_IDKRB_NT_MS_BRANCH_IDKRB_NT_X500_PRINCIPALKERB_WRAP_NO_ENCRYPTPKERB_LOGON_SUBMIT_TYPEKERB_LOGON_SUBMIT_TYPEPKERB_INTERACTIVE_LOGONKERB_INTERACTIVE_LOGONPKERB_INTERACTIVE_UNLOCK_LOGONKERB_INTERACTIVE_UNLOCK_LOGONPKERB_SMART_CARD_LOGONKERB_SMART_CARD_LOGONPKERB_SMART_CARD_UNLOCK_LOGONKERB_SMART_CARD_UNLOCK_LOGONKERB_CERTIFICATE_LOGON_FLAG_CHECK_DUPLICATESKERB_CERTIFICATE_LOGON_FLAG_USE_CERTIFICATE_INFOPKERB_CERTIFICATE_LOGONKERB_CERTIFICATE_LOGONPKERB_CERTIFICATE_UNLOCK_LOGONKERB_CERTIFICATE_UNLOCK_LOGONKERB_CERTIFICATE_S4U_LOGON_FLAG_CHECK_DUPLICATESKERB_CERTIFICATE_S4U_LOGON_FLAG_CHECK_LOGONHOURSKERB_CERTIFICATE_S4U_LOGON_FLAG_FAIL_IF_NT_AUTH_POLICY_REQUIREDKERB_CERTIFICATE_S4U_LOGON_FLAG_IDENTIFYPKERB_CERTIFICATE_S4U_LOGONKERB_CERTIFICATE_S4U_LOGONPKERB_TICKET_LOGONKERB_TICKET_LOGONPKERB_TICKET_UNLOCK_LOGONKERB_TICKET_UNLOCK_LOGONKERB_S4U_LOGON_FLAG_CHECK_LOGONHOURSKERB_S4U_LOGON_FLAG_IDENTIFYPKERB_S4U_LOGONKERB_S4U_LOGONPKERB_PROFILE_BUFFER_TYPEKERB_PROFILE_BUFFER_TYPEPKERB_INTERACTIVE_PROFILEKERB_INTERACTIVE_PROFILEPKERB_SMART_CARD_PROFILEKERB_SMART_CARD_PROFILEPKERB_CRYPTO_KEYKERB_CRYPTO_KEYPKERB_CRYPTO_KEY32KERB_CRYPTO_KEY32PKERB_TICKET_PROFILEKERB_TICKET_PROFILEPKERB_PROTOCOL_MESSAGE_TYPEKERB_PROTOCOL_MESSAGE_TYPEPKERB_QUERY_TKT_CACHE_REQUESTKERB_QUERY_TKT_CACHE_REQUESTPKERB_TICKET_CACHE_INFOKERB_TICKET_CACHE_INFOPKERB_TICKET_CACHE_INFO_EXKERB_TICKET_CACHE_INFO_EXPKERB_TICKET_CACHE_INFO_EX2KERB_TICKET_CACHE_INFO_EX2PKERB_TICKET_CACHE_INFO_EX3KERB_TICKET_CACHE_INFO_EX3PKERB_QUERY_TKT_CACHE_RESPONSEKERB_QUERY_TKT_CACHE_RESPONSEPKERB_QUERY_TKT_CACHE_EX_RESPONSEKERB_QUERY_TKT_CACHE_EX_RESPONSEPKERB_QUERY_TKT_CACHE_EX2_RESPONSEKERB_QUERY_TKT_CACHE_EX2_RESPONSEPKERB_QUERY_TKT_CACHE_EX3_RESPONSEKERB_QUERY_TKT_CACHE_EX3_RESPONSEKERB_USE_DEFAULT_TICKET_FLAGSKERB_RETRIEVE_TICKET_DEFAULTKERB_RETRIEVE_TICKET_DONT_USE_CACHEKERB_RETRIEVE_TICKET_USE_CACHE_ONLYKERB_RETRIEVE_TICKET_USE_CREDHANDLEKERB_RETRIEVE_TICKET_AS_KERB_CREDKERB_RETRIEVE_TICKET_WITH_SEC_CREDKERB_RETRIEVE_TICKET_CACHE_TICKETKERB_RETRIEVE_TICKET_MAX_LIFETIMEPKERB_AUTH_DATAKERB_AUTH_DATAPKERB_NET_ADDRESSKERB_NET_ADDRESSPKERB_NET_ADDRESSESKERB_NET_ADDRESSESPKERB_EXTERNAL_NAMEKERB_EXTERNAL_NAMEPKERB_EXTERNAL_TICKETKERB_EXTERNAL_TICKETPKERB_RETRIEVE_TKT_REQUESTKERB_RETRIEVE_TKT_REQUESTPKERB_RETRIEVE_TKT_RESPONSEKERB_RETRIEVE_TKT_RESPONSEPKERB_PURGE_TKT_CACHE_REQUESTKERB_PURGE_TKT_CACHE_REQUESTKERB_PURGE_ALL_TICKETSPKERB_PURGE_TKT_CACHE_EX_REQUESTKERB_PURGE_TKT_CACHE_EX_REQUESTPKERB_SUBMIT_TKT_REQUESTKERB_SUBMIT_TKT_REQUESTPKERB_QUERY_KDC_PROXY_CACHE_REQUESTKERB_QUERY_KDC_PROXY_CACHE_REQUESTPKDC_PROXY_CACHE_ENTRY_DATAKDC_PROXY_CACHE_ENTRY_DATAPKERB_QUERY_KDC_PROXY_CACHE_RESPONSEKERB_QUERY_KDC_PROXY_CACHE_RESPONSEPKERB_PURGE_KDC_PROXY_CACHE_REQUESTKERB_PURGE_KDC_PROXY_CACHE_REQUESTPKERB_PURGE_KDC_PROXY_CACHE_RESPONSEKERB_PURGE_KDC_PROXY_CACHE_RESPONSEKERB_S4U2PROXY_CACHE_ENTRY_INFO_FLAG_NEGATIVEPKERB_S4U2PROXY_CACHE_ENTRY_INFOKERB_S4U2PROXY_CACHE_ENTRY_INFOKERB_S4U2PROXY_CRED_FLAG_NEGATIVEPKERB_S4U2PROXY_CREDKERB_S4U2PROXY_CREDPKERB_QUERY_S4U2PROXY_CACHE_REQUESTKERB_QUERY_S4U2PROXY_CACHE_REQUESTPKERB_QUERY_S4U2PROXY_CACHE_RESPONSEKERB_QUERY_S4U2PROXY_CACHE_RESPONSEPKERB_CHANGEPASSWORD_REQUESTKERB_CHANGEPASSWORD_REQUESTPKERB_SETPASSWORD_REQUESTKERB_SETPASSWORD_REQUESTPKERB_SETPASSWORD_EX_REQUESTKERB_SETPASSWORD_EX_REQUESTDS_UNKNOWN_ADDRESS_TYPEKERB_SETPASS_USE_LOGONIDKERB_SETPASS_USE_CREDHANDLEPKERB_DECRYPT_REQUESTKERB_DECRYPT_REQUESTKERB_DECRYPT_FLAG_DEFAULT_KEYPKERB_DECRYPT_RESPONSEKERB_DECRYPT_RESPONSEPKERB_ADD_BINDING_CACHE_ENTRY_REQUESTKERB_ADD_BINDING_CACHE_ENTRY_REQUESTPKERB_REFRESH_SCCRED_REQUESTKERB_REFRESH_SCCRED_REQUESTKERB_REFRESH_SCCRED_RELEASEKERB_REFRESH_SCCRED_GETTGTPKERB_ADD_CREDENTIALS_REQUESTKERB_ADD_CREDENTIALS_REQUESTKERB_REQUEST_ADD_CREDENTIALKERB_REQUEST_REPLACE_CREDENTIALKERB_REQUEST_REMOVE_CREDENTIALPKERB_ADD_CREDENTIALS_REQUEST_EXKERB_ADD_CREDENTIALS_REQUEST_EXPKERB_TRANSFER_CRED_REQUESTKERB_TRANSFER_CRED_REQUESTKERB_TRANSFER_CRED_WITH_TICKETSKERB_TRANSFER_CRED_CLEANUP_CREDENTIALSPKERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUESTKERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUESTPKERB_BINDING_CACHE_ENTRY_DATAKERB_BINDING_CACHE_ENTRY_DATAPKERB_QUERY_BINDING_CACHE_RESPONSEKERB_QUERY_BINDING_CACHE_RESPONSEPKERB_ADD_BINDING_CACHE_ENTRY_EX_REQUESTKERB_ADD_BINDING_CACHE_ENTRY_EX_REQUESTPKERB_QUERY_BINDING_CACHE_REQUESTKERB_QUERY_BINDING_CACHE_REQUESTPKERB_PURGE_BINDING_CACHE_REQUESTKERB_PURGE_BINDING_CACHE_REQUESTPKERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUESTKERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUESTPKERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSEKERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSEPKERB_CERTIFICATE_INFO_TYPEKERB_CERTIFICATE_INFO_TYPEPKERB_CERTIFICATE_HASHINFOKERB_CERTIFICATE_HASHINFOPKERB_CERTIFICATE_INFOKERB_CERTIFICATE_INFOPPOLICY_AUDIT_SID_ARRAYPOLICY_AUDIT_SID_ARRAYPAUDIT_POLICY_INFORMATIONAUDIT_POLICY_INFORMATIONLPAUDIT_POLICY_INFORMATIONPCAUDIT_POLICY_INFORMATIONAUDIT_SET_SYSTEM_POLICYAUDIT_QUERY_SYSTEM_POLICYAUDIT_SET_USER_POLICYAUDIT_QUERY_USER_POLICYAUDIT_ENUMERATE_USERSAUDIT_SET_MISC_POLICYAUDIT_QUERY_MISC_POLICYAUDIT_GENERIC_ALLAUDIT_GENERIC_READAUDIT_GENERIC_WRITEAUDIT_GENERIC_EXECUTEAuditSetSystemPolicyAuditSetPerUserPolicyAuditQuerySystemPolicyAuditQueryPerUserPolicyAuditEnumeratePerUserPolicyAuditComputeEffectivePolicyBySidAuditComputeEffectivePolicyByTokenAuditEnumerateCategoriesAuditEnumerateSubCategoriesAuditLookupCategoryNameWAuditLookupCategoryNameAAuditLookupSubCategoryNameWAuditLookupSubCategoryNameAAuditLookupCategoryIdFromCategoryGuidAuditLookupCategoryGuidFromCategoryIdAuditSetSecurityAuditQuerySecurityAuditSetGlobalSaclWAuditSetGlobalSaclAAuditQueryGlobalSaclWAuditQueryGlobalSaclAAuditFreePPKU2U_CERT_BLOBPKU2U_CERT_BLOBPKU2U_CREDUI_CONTEXT_VERSIONPPKU2U_CREDUI_CONTEXTPKU2U_CREDUI_CONTEXTPPKU2U_LOGON_SUBMIT_TYPEPKU2U_LOGON_SUBMIT_TYPEPPKU2U_CERTIFICATE_S4U_LOGONPKU2U_CERTIFICATE_S4U_LOGON//! This module defines the Local Security Authority APIs.VT_BSTRVT_DISPATCHVT_ERRORVT_I1VT_I2VT_I4VT_I8VT_RECORDVT_RESERVEDVT_UNKNOWNVT_VARIANTBYTE_SIZEDARRDWORD_SIZEDARRHYPER_SIZEDARRWORD_SIZEDARRCURRENCYLPSAFEARRAYBOUNDwireBRECORD_wireBRECORDwireVARIANT_wireVARIANTwireSAFEARRAY_wireSAFEARRAYwirePSAFEARRAYFADF_AUTOFADF_STATICFADF_EMBEDDEDFADF_FIXEDSIZEFADF_RECORDFADF_HAVEIIDFADF_HAVEVARTYPEFADF_BSTRFADF_UNKNOWNFADF_DISPATCHFADF_VARIANTFADF_RESERVEDLPVARIANTVARIANTARGLPVARIANTARGREFVARIANTMEMBERIDHREFTYPELPPARAMDESCEXPARAMDESCEXLPPARAMDESCPARAMDESCPARAMFLAG_NONEPARAMFLAG_FINPARAMFLAG_FOUTPARAMFLAG_FLCIDPARAMFLAG_FRETVALPARAMFLAG_FOPTPARAMFLAG_FHASDEFAULTPARAMFLAG_FHASCUSTDATALPIDLDESCIDLDESCIDLFLAG_NONEIDLFLAG_FINIDLFLAG_FOUTIDLFLAG_FLCIDIDLFLAG_FRETVALLPELEMDESCELEMDESCLPTYPEATTRTYPEATTRLPFUNCDESCFUNCDESCIMPLTYPEFLAG_FDEFAULTIMPLTYPEFLAG_FSOURCEIMPLTYPEFLAG_FRESTRICTEDIMPLTYPEFLAG_FDEFAULTVTABLELPVARDESCVARDESCLPCUSTDATAITEMCUSTDATAITEMLPCUSTDATACUSTDATALPCREATETYPEINFOICreateTypeInfoLPDISPATCH// LPCREATETYPEINFO2// ICreateTypeInfo2// LPCREATETYPELIB// ICreateTypeLib// LPCREATETYPELIB2// ICreateTypeLib2DISPID_VALUEDISPID_PROPERTYPUTDISPID_NEWENUMDISPID_EVALUATEDISPID_CONSTRUCTORDISPID_DESTRUCTORDISPID_COLLECT// IDispatch_RemoteInvoke_Proxy// IDispatch_RemoteInvoke_Stub// LPENUMVARIANT// IEnumVARIANT// IEnumVARIANT_RemoteNext_Proxy// IEnumVARIANT_RemoteNext_StubLPTYPECOMPITypeCompLPBINDPTRBINDPTRLPERRORLOGIErrorLog//! Mappings for the contents of OAIdl.hCOINITBASE_MULTITHREADEDCoInitialize//! Component object model defintions// pub fn CoBuildVersion();// pub fn CoRegisterMallocSpy();// pub fn CoRevokeMallocSpy();// pub fn CoRegisterInitializeSpy();// pub fn CoRevokeInitializeSpy();// pub fn CoGetSystemSecurityPermissions();// pub fn CoLoadLibrary();// pub fn CoFreeLibrary();// pub fn CoFreeAllLibraries();// pub fn CoGetInstanceFromFile();// pub fn CoGetInstanceFromIStorage();// pub fn CoAllowSetForegroundWindow();// pub fn DcomChannelSetHResult();// pub fn CoIsOle1Class();// pub fn CLSIDFromProgIDEx();// pub fn CoFileTimeToDosDateTime();// pub fn CoDosDateTimeToFileTime();// pub fn CoFileTimeNow();// pub fn CoRegisterMessageFilter();// pub fn CoRegisterChannelHook();// pub fn CoTreatAsClass();// pub fn CreateDataAdviseHolder();// pub fn CreateDataCache();// pub fn StgOpenAsyncDocfileOnIFillLockBytes();// pub fn StgGetIFillLockBytesOnILockBytes();// pub fn StgGetIFillLockBytesOnFile();// pub fn StgOpenLayoutDocfile();// pub fn CoInstall();// pub fn BindMoniker();// pub fn CoGetObject();// pub fn MkParseDisplayName();// pub fn MonikerRelativePathTo();// pub fn MonikerCommonPrefixWith();// pub fn CreateBindCtx();// pub fn CreateGenericComposite();// pub fn GetClassFile();// pub fn CreateClassMoniker();// pub fn CreateFileMoniker();// pub fn CreateItemMoniker();// pub fn CreateAntiMoniker();// pub fn CreatePointerMoniker();// pub fn CreateObjrefMoniker();// pub fn GetRunningObjectTable();// pub fn CreateStdProgressIndicator();HENHMETAFILEIEnumStringSTATSTG//8402LPBIND_OPTSBIND_OPTS//8479//8681//8958//9125//9207//9350SNBLPDATAOBJECTCOAUTHINFOIMarshalLPMARSHAL2IMarshal2IMallocLPSTDMARSHALINFOIStdMarshalInfoLPMULTIQIIMultiQIRPCOLEDATAREPPRPCOLEMESSAGERPCOLEMESSAGEPSOLE_AUTHENTICATION_SERVICECOLE_DEFAULT_PRINCIPALCOLE_DEFAULT_AUTHINFOPSOLE_AUTHENTICATION_INFOSOLE_AUTHENTICATION_INFOPSOLE_AUTHENTICATION_LISTSOLE_AUTHENTICATION_LISTISurrogateLPGLOBALINTERFACETABLEIGlobalInterfaceTableLPCANCELMETHODCALLSICancelMethodCallsLPADDRTRACKINGCONTROLIAddrTrackingControlLPADDREXCLUSIONCONTROLIAddrExclusionControlCPFLAGSLPENUMCONTEXTPROPSIEnumContextPropsAPARTMENTIDLPPROPERTYBAG2IPropertyBag2LPDROPTARGETOleInitializeRegisterDragDropICreateErrorInfoIErrorInfoITypeLibSysReAllocStringSysAllocStringLenSysReAllocStringLenSysStringByteLenSysAllocStringByteLenDosDateTimeToVariantTimeVariantTimeToDosDateTimeSystemTimeToVariantTimeVariantTimeToSystemTimeSafeArrayAccessDataSafeArrayUnaccessDataSafeArrayCreateVectorSafeArrayGetLBoundSafeArrayGetUBoundSafeArrayDestroyVariantInitVariantCopyVariantCopyIndVariantChangeTypeVariantChangeTypeExVarUI1FromI2VarUI1FromI4VarUI1FromI8VarUI1FromR4VarUI1FromR8VarUI1FromDateVarUI1FromStrVarUI1FromI1VarUI1FromUI2VarUI1FromUI4VarUI1FromUI8VarUI1FromDecVarI2FromUI1VarI2FromI4VarI2FromI8VarI2FromR4VarI2FromR8VarI2FromDateVarI2FromStrVarI2FromI1VarI2FromUI2VarI2FromUI4VarI2FromUI8VarI2FromDecVarI4FromUI1VarI4FromI2VarI4FromI8VarI4FromR4VarI4FromR8VarI4FromDateVarI4FromStrVarI4FromI1VarI4FromUI2VarI4FromUI4VarI4FromUI8VarI4FromDecVarI8FromUI1VarI8FromI2VarI8FromR4VarI8FromR8VarI8FromDateVarI8FromStrVarI8FromI1VarI8FromUI2VarI8FromUI4VarI8FromUI8VarI8FromDecVarR4FromUI1VarR4FromI2VarR4FromI4VarR4FromI8VarR4FromR8VarR4FromDateVarR4FromStrVarR4FromI1VarR4FromUI2VarR4FromUI4VarR4FromUI8VarR4FromDecVarR8FromUI1VarR8FromI2VarR8FromI4VarR8FromI8VarR8FromR4VarR8FromDateVarR8FromStrVarR8FromI1VarR8FromUI2VarR8FromUI4VarR8FromUI8VarR8FromDecVarDateFromUI1VarDateFromI2VarDateFromI4VarDateFromI8VarDateFromR4VarDateFromR8VarDateFromStrVarDateFromI1VarDateFromUI2VarDateFromUI4VarDateFromUI8VarDateFromDecVarBstrFromUI1VarBstrFromI2VarBstrFromI4VarBstrFromI8VarBstrFromR4VarBstrFromR8VarBstrFromDateVarBstrFromI1VarBstrFromUI2VarBstrFromUI4VarBstrFromUI8VarBstrFromDecVarUI2FromUI1VarUI2FromI2VarUI2FromI4VarUI2FromI8VarUI2FromR4VarUI2FromR8VarUI2FromDateVarUI2FromStrVarUI2FromI1VarUI2FromUI4VarUI2FromUI8VarUI2FromDecVarUI4FromUI1VarUI4FromI2VarUI4FromI4VarUI4FromI8VarUI4FromR4VarUI4FromR8VarUI4FromDateVarUI4FromStrVarUI4FromI1VarUI4FromUI2VarUI4FromUI8VarUI4FromDecVarUI8FromUI1VarUI8FromI2VarUI8FromI4VarUI8FromI8VarUI8FromR4VarUI8FromR8VarUI8FromDateVarUI8FromStrVarUI8FromI1VarUI8FromUI2VarUI8FromUI4VarUI8FromDecVarDecFromUI1VarDecFromI2VarDecFromI4VarDecFromI8VarDecFromR4VarDecFromR8VarDecFromDateVarDecFromStrVarDecFromI1VarDecFromUI2VarDecFromUI4VarDecFromUI8VarDecAddVarDecDivVarDecMulVarDecSubVarDecAbsVarDecFixVarDecIntVarDecNegVarDecRoundVarDecCmpVarDecCmpR8VarBstrCatVarBstrCmpVarR8PowVarR4CmpR8VarR8RoundGetAltMonthNamesMEMBERID_NILDISPATCH_METHODDISPATCH_PROPERTYGETDISPATCH_PROPERTYPUTDISPATCH_PROPERTYPUTREFLoadTypeLibExREGKINDRevokeActiveObjectSetErrorInfoGetErrorInfoCreateErrorInfoOaBuildVersionOaEnablePerUserTLibRegistration//! Mappings for the contents of OleAuto.hSELFREG_E_FIRSTSELFREG_E_LASTSELFREG_S_FIRSTSELFREG_S_LASTSELFREG_E_TYPELIBSELFREG_E_CLASS//! OLE Control interfacesMK_ALTDROPEFFECT_MOVEDROPEFFECT_LINKDROPEFFECT_SCROLLDD_DEFSCROLLINSETDD_DEFSCROLLDELAYDD_DEFSCROLLINTERVALDD_DEFDRAGDELAYDD_DEFDRAGMINDISTDXVA2_SampleFormatGetBusTypeGetBusImplementationIsNonStandardBusImplementationOPMGetVideoOutputsFromHMONITOROPM_VIDEO_OUTPUT_SEMANTICSIOPMVideoOutputOPMGetVideoOutputForTargetOPMGetVideoOutputsFromIDirect3DDevice9ObjectPDH_FMT_RAWPDH_FMT_ANSIPDH_FMT_UNICODEPDH_FMT_LONGPDH_FMT_LARGEPDH_FMT_NOSCALEPDH_FMT_1000PDH_FMT_NODATAPDH_FMT_NOCAP100PERF_DETAIL_COSTLYPERF_DETAIL_STANDARDPDH_STATUSPDH_HQUERYHQUERYPDH_HCOUNTERHCOUNTERPPDH_BROWSE_DLG_CONFIG_APDH_BROWSE_DLG_CONFIG_APPDH_BROWSE_DLG_CONFIG_WPDH_BROWSE_DLG_CONFIG_WPDH_HLOGPPDH_RAW_LOG_RECORDPDH_RAW_LOG_RECORDPPDH_TIME_INFOPDH_TIME_INFOPPDH_RAW_COUNTERPDH_RAW_COUNTERPPDH_COUNTER_INFO_APDH_COUNTER_INFO_APPDH_COUNTER_INFO_WPDH_COUNTER_INFO_WPPDH_STATISTICSPDH_STATISTICSPPDH_FMT_COUNTERVALUE_ITEM_APDH_FMT_COUNTERVALUE_ITEM_APPDH_FMT_COUNTERVALUE_ITEM_WPDH_FMT_COUNTERVALUE_ITEM_WPPDH_DATA_ITEM_PATH_ELEMENTS_APDH_DATA_ITEM_PATH_ELEMENTS_APPDH_DATA_ITEM_PATH_ELEMENTS_WPDH_DATA_ITEM_PATH_ELEMENTS_WPPDH_FMT_COUNTERVALUEPPDH_COUNTER_PATH_ELEMENTS_APDH_COUNTER_PATH_ELEMENTS_APPDH_COUNTER_PATH_ELEMENTS_WPDH_COUNTER_PATH_ELEMENTS_WPPDH_BROWSE_DLG_CONFIG_HAPDH_BROWSE_DLG_CONFIG_HAPPDH_BROWSE_DLG_CONFIG_HWPDH_BROWSE_DLG_CONFIG_HWPdhGetDllVersionPdhOpenQueryWPdhAddCounterWPdhAddCounterAPdhCollectQueryDataWithTimePdhValidatePathExWPdhValidatePathExAPdhGetFormattedCounterArrayAPdhGetFormattedCounterArrayWPdhGetRawCounterValuePdhGetRawCounterArrayAPdhGetRawCounterArrayWPdhCalculateCounterFromRawValuePdhComputeCounterStatisticsPdhGetCounterInfoWPdhGetCounterInfoAPdhSetCounterScaleFactorPdhConnectMachineWPdhConnectMachineAPdhEnumMachinesWPdhEnumMachinesAPdhEnumObjectsWPdhEnumObjectsAPdhEnumObjectItemsWPdhEnumObjectItemsAPdhMakeCounterPathWPdhMakeCounterPathAPdhParseCounterPathWPdhParseCounterPathAPdhParseInstanceNameWPdhParseInstanceNameAPdhValidatePathWPdhValidatePathAPdhGetDefaultPerfObjectWPdhGetDefaultPerfObjectAPdhGetDefaultPerfCounterWPdhGetDefaultPerfCounterAPdhBrowseCountersWPdhBrowseCountersAPdhExpandCounterPathWPdhExpandCounterPathAPdhLookupPerfNameByIndexWPdhLookupPerfNameByIndexAPdhLookupPerfIndexByNameWPdhLookupPerfIndexByNameAPdhExpandWildCardPathWPdhExpandWildCardPathAPdhOpenLogWPdhOpenLogAPdhUpdateLogWPdhUpdateLogAPdhUpdateLogFileCatalogPdhGetLogFileSizePdhCloseLogPdhSelectDataSourceWPdhSelectDataSourceAPdhIsRealTimeQueryPdhSetQueryTimeRangePdhGetDataSourceTimeRangeWPdhGetDataSourceTimeRangeAPdhFormatFromRawValuePdhGetCounterTimeBasePdhReadRawLogRecordPdhSetDefaultRealTimeDataSourcePdhBindInputDataSourceWPdhBindInputDataSourceAPdhOpenQueryHPdhEnumMachinesHWPdhEnumMachinesHAPdhEnumObjectsHWPdhEnumObjectsHAPdhEnumObjectItemsHWPdhEnumObjectItemsHAPdhExpandWildCardPathHWPdhExpandWildCardPathHAPdhGetDataSourceTimeRangeHPdhGetDefaultPerfObjectHWPdhGetDefaultPerfObjectHAPdhGetDefaultPerfCounterHWPdhGetDefaultPerfCounterHAPdhBrowseCountersHWPdhBrowseCountersHAPdhEnumLogSetNamesWPdhEnumLogSetNamesA//! Common Performance Data Helper definitions// pub fn PdhVerifySQLDBW() -> PDH_STATUS;// pub fn PdhVerifySQLDBA() -> PDH_STATUS;// pub fn PdhCreateSQLTablesW() -> PDH_STATUS;// pub fn PdhCreateSQLTablesA() -> PDH_STATUS;//pub fn PdhGetLogSetGUID() -> PDH_STATUS;// pub fn PdhSetLogSetRunID() -> PDH_STATUS;PERF_PROVIDER_USER_MODEPERF_PROVIDER_KERNEL_MODEPERF_PROVIDER_DRIVERPERF_COUNTERSET_FLAG_MULTIPLEPERF_COUNTERSET_FLAG_AGGREGATEPERF_COUNTERSET_FLAG_HISTORYPERF_COUNTERSET_FLAG_INSTANCEPERF_COUNTERSET_SINGLE_INSTANCEPERF_COUNTERSET_MULTI_INSTANCESPERF_COUNTERSET_SINGLE_AGGREGATEPERF_COUNTERSET_MULTI_AGGREGATEPERF_COUNTERSET_SINGLE_AGGREGATE_HISTORYPERF_COUNTERSET_INSTANCE_AGGREGATEPERF_AGGREGATE_UNDEFINEDPERF_AGGREGATE_TOTALPERF_AGGREGATE_AVGPERF_AGGREGATE_MINPERF_AGGREGATE_MAXPERF_ATTRIB_BY_REFERENCEPERF_ATTRIB_NO_DISPLAYABLEPERF_ATTRIB_NO_GROUP_SEPARATORPERF_ATTRIB_DISPLAY_AS_REALPERF_ATTRIB_DISPLAY_AS_HEXPPERF_COUNTERSET_INFOPERF_COUNTERSET_INFOPPERF_COUNTER_INFOPERF_COUNTER_INFOPPERF_COUNTERSET_INSTANCEPERF_COUNTERSET_INSTANCEPPERF_COUNTER_IDENTITYPERF_COUNTER_IDENTITYPERF_WILDCARD_COUNTERPERF_WILDCARD_INSTANCEPERF_AGGREGATE_INSTANCEPERF_MAX_INSTANCE_NAMEPERF_ADD_COUNTERPERF_REMOVE_COUNTERPERF_ENUM_INSTANCESPERF_COLLECT_STARTPERF_COLLECT_ENDPERF_FILTERPPERF_PROVIDER_CONTEXTPERF_PROVIDER_CONTEXTPerfStartProviderExPerfStartProviderPERFLIBREQUESTPerfStopProviderPerfSetCounterSetInfoPerfCreateInstancePerfDeleteInstancePerfQueryInstancePerfSetCounterRefValuePerfSetULongCounterValuePerfSetULongLongCounterValuePerfIncrementULongCounterValuePerfIncrementULongLongCounterValuePerfDecrementULongCounterValuePerfDecrementULongLongCounterValuePPERF_INSTANCE_HEADERPERF_INSTANCE_HEADERPPERF_COUNTERSET_REG_INFOPERF_COUNTERSET_REG_INFOPPERF_COUNTER_REG_INFOPERF_COUNTER_REG_INFOPPERF_STRING_BUFFER_HEADERPERF_STRING_BUFFER_HEADERPPERF_STRING_COUNTER_HEADERPERF_STRING_COUNTER_HEADERPPERF_COUNTER_IDENTIFIERPERF_COUNTER_IDENTIFIERPPERF_DATA_HEADERPERF_DATA_HEADERPPERF_COUNTER_HEADERPERF_COUNTER_HEADERPPERF_MULTI_INSTANCESPERF_MULTI_INSTANCESPPERF_MULTI_COUNTERSPERF_MULTI_COUNTERSPPERF_COUNTER_DATAPERF_COUNTER_DATAPerfEnumerateCounterSetPerfEnumerateCounterSetInstancesPerfQueryCounterSetRegistrationInfoPerfRegInfoTypePerfOpenQueryHandlePerfCloseQueryHandlePerfQueryCounterInfoPerfQueryCounterDataPerfAddCountersPerfDeleteCountersPHYSICAL_MONITOR_DESCRIPTION_SIZELPPHYSICAL_MONITORPHYSICAL_MONITORGetNumberOfPhysicalMonitorsFromHMONITORGetNumberOfPhysicalMonitorsFromIDirect3DDevice9GetPhysicalMonitorsFromHMONITORGetPhysicalMonitorsFromIDirect3DDevice9DestroyPhysicalMonitorDestroyPhysicalMonitorssndPlaySoundAsndPlaySoundWSND_SYNCSND_ASYNCSND_NODEFAULTSND_MEMORYSND_LOOPSND_NOSTOPSND_NOWAITSND_ALIASSND_ALIAS_IDSND_FILENAMESND_RESOURCESND_PURGESND_APPLICATIONSND_SENTRYSND_RINGSND_SYSTEMPlaySoundAPlaySoundW//! ApiSet Contract for api-ms-win-mm-playsound-l1-1-0WPD_DEVICE_OBJECT_ID//51WMDRMDEVICEAPP_USE_WPD_DEVICE_PTRPORTABLE_DEVICE_TYPEPORTABLE_DEVICE_ICONPORTABLE_DEVICE_NAMESPACE_TIMEOUTPORTABLE_DEVICE_NAMESPACE_EXCLUDE_FROM_SHELLPORTABLE_DEVICE_NAMESPACE_THUMBNAIL_CONTENT_TYPESPORTABLE_DEVICE_IS_MASS_STORAGEPORTABLE_DEVICE_DRM_SCHEME_WMDRM10_PDPORTABLE_DEVICE_DRM_SCHEME_PDDRM//101//133//175//696//1140//1488//3440//! Mappings for the contents of PortableDevice.hIPortableDeviceKeyCollectionIPortableDevicePropVariantCollectionIPortableDeviceValuesREFPROPERTYKEY// 328//! Mappings for the contents of PortableDeviceApi.h//330//! Mappings for the contents of PortableDeviceTypes.hPOWER_INFORMATION_LEVELPOWER_PLATFORM_ROLEPSYSTEM_POWER_CAPABILITIESHPOWERNOTIFYPHPOWERNOTIFYGetPwrCapabilitiesPowerDeterminePlatformRoleExPowerRegisterSuspendResumeNotificationPowerUnregisterSuspendResumeNotificationPowerReadACValuePowerReadDCValuePowerWriteACValueIndexPowerWriteDCValueIndexPowerGetActiveSchemePowerSetActiveSchemePowerSettingRegisterNotificationPowerSettingUnregisterNotificationNUM_DISCHARGE_POLICIESPADMINISTRATOR_POWER_POLICYPOWER_ACTION_POLICYPROCESSOR_POWER_POLICYSYSTEM_POWER_LEVELSYSTEM_POWER_STATEPGLOBAL_MACHINE_POWER_POLICYGLOBAL_MACHINE_POWER_POLICYPGLOBAL_USER_POWER_POLICYGLOBAL_USER_POWER_POLICYPGLOBAL_POWER_POLICYGLOBAL_POWER_POLICYPMACHINE_POWER_POLICYMACHINE_POWER_POLICYPMACHINE_PROCESSOR_POWER_POLICYMACHINE_PROCESSOR_POWER_POLICYPUSER_POWER_POLICYUSER_POWER_POLICYPPOWER_POLICYPOWER_POLICYEnableSysTrayBatteryMeterEnableMultiBatteryDisplayEnablePasswordLogonEnableWakeOnRingEnableVideoDimDisplayPOWER_ATTRIBUTE_HIDEPOWER_ATTRIBUTE_SHOW_AOACNEWSCHEMEPWRSCHEMESENUMPROCPWRSCHEMESENUMPROC_V2GetPwrDiskSpindownRangeEnumPwrSchemesReadGlobalPwrPolicyReadPwrSchemeWritePwrSchemeWriteGlobalPwrPolicyDeletePwrSchemeGetActivePwrSchemeSetActivePwrSchemeIsPwrSuspendAllowedIsPwrHibernateAllowedIsPwrShutdownAllowedIsAdminOverrideActiveGetCurrentPowerPoliciesCanUserWritePwrSchemeReadProcessorPwrSchemeWriteProcessorPwrSchemeValidatePowerPoliciesPPOWER_DATA_ACCESSORPOWER_DATA_ACCESSORDEVICE_NOTIFY_CALLBACKPDEVICE_NOTIFY_CALLBACK_ROUTINEDEVICE_NOTIFY_CALLBACK_ROUTINEPDEVICE_NOTIFY_SUBSCRIBE_PARAMETERSDEVICE_NOTIFY_SUBSCRIBE_PARAMETERSPowerIsSettingRangeDefinedPowerSettingAccessCheckExPowerSettingAccessCheckPowerReadACValueIndexPowerReadDCValueIndexPowerReadFriendlyNamePowerReadDescriptionPowerReadPossibleValuePowerReadPossibleFriendlyNamePowerReadPossibleDescriptionPowerReadValueMinPowerReadValueMaxPowerReadValueIncrementPowerReadValueUnitsSpecifierPowerReadACDefaultIndexPowerReadDCDefaultIndexPowerReadIconResourceSpecifierPowerReadSettingAttributesPowerWriteFriendlyNamePowerWriteDescriptionPowerWritePossibleValuePowerWritePossibleFriendlyNamePowerWritePossibleDescriptionPowerWriteValueMinPowerWriteValueMaxPowerWriteValueIncrementPowerWriteValueUnitsSpecifierPowerWriteACDefaultIndexPowerWriteDCDefaultIndexPowerWriteIconResourceSpecifierPowerWriteSettingAttributesPowerDuplicateSchemePowerImportPowerSchemePowerDeleteSchemePowerRemovePowerSettingPowerCreateSettingPowerCreatePossibleSettingPowerEnumeratePowerOpenUserPowerKeyPowerOpenSystemPowerKeyPowerCanRestoreIndividualDefaultPowerSchemePowerRestoreIndividualDefaultPowerSchemePowerRestoreDefaultPowerSchemesPowerReplaceDefaultPowerSchemesPowerDeterminePlatformRoleDEVICEPOWER_HARDWAREIDDEVICEPOWER_AND_OPERATIONDEVICEPOWER_FILTER_DEVICES_PRESENTDEVICEPOWER_FILTER_HARDWAREDEVICEPOWER_FILTER_WAKEENABLEDDEVICEPOWER_FILTER_WAKEPROGRAMMABLEDEVICEPOWER_FILTER_ON_NAMEDEVICEPOWER_SET_WAKEENABLEDDEVICEPOWER_CLEAR_WAKEENABLEDPDCAP_S0_SUPPORTEDPDCAP_S1_SUPPORTEDPDCAP_S2_SUPPORTEDPDCAP_S3_SUPPORTEDPDCAP_WAKE_FROM_S0_SUPPORTEDPDCAP_WAKE_FROM_S1_SUPPORTEDPDCAP_WAKE_FROM_S2_SUPPORTEDPDCAP_WAKE_FROM_S3_SUPPORTEDPDCAP_S4_SUPPORTEDPDCAP_S5_SUPPORTEDDevicePowerEnumDevicesDevicePowerSetDeviceStateDevicePowerOpenDevicePowerClosePTHERMAL_EVENTTHERMAL_EVENTPowerReportThermalEvent//! Interface for powrprof.dll, the power policy applicatorGetEnvironmentStringsGetEnvironmentStringsWSetEnvironmentStringsWFreeEnvironmentStringsAFreeEnvironmentStringsWSetStdHandleExGetCommandLineAGetCommandLineWGetEnvironmentVariableAGetEnvironmentVariableWSetEnvironmentVariableASetEnvironmentVariableWExpandEnvironmentStringsAExpandEnvironmentStringsWSetCurrentDirectoryASetCurrentDirectoryWGetCurrentDirectoryAGetCurrentDirectoryWSearchPathWSearchPathANeedCurrentDirectoryForExePathANeedCurrentDirectoryForExePathWPssCaptureSnapshotPSS_CAPTURE_FLAGSHPSSPssDuplicateSnapshotPSS_DUPLICATE_FLAGSPssFreeSnapshotPssQuerySnapshotPSS_QUERY_INFORMATION_CLASSPssWalkMarkerCreatePSS_ALLOCATORHPSSWALKPssWalkMarkerFreePssWalkMarkerGetPositionPssWalkMarkerSeekToBeginning// pub fn PssWalkMarkerRewind();// pub fn PssWalkMarkerSeek();PssWalkMarkerSetPositionPssWalkSnapshotPSS_WALK_INFORMATION_CLASS// pub fn PssWalkMarkerTell();//! Defines the process snapshot APIPAPCFUNCPROCESS_MITIGATION_POLICYPPROCESS_INFORMATIONPROCESS_INFORMATIONLPPROCESS_INFORMATIONLPSTARTUPINFOASTARTUPINFOALPSTARTUPINFOWSTARTUPINFOWQueueUserAPCExitProcessTerminateProcessSwitchToThreadCreateThreadCreateRemoteThreadGetCurrentThreadOpenThreadSetThreadPrioritySetThreadPriorityBoostGetThreadPriorityBoostGetThreadPriorityExitThreadTerminateThreadGetExitCodeThreadSuspendThreadResumeThreadTLS_OUT_OF_INDEXESTlsAllocTlsGetValueTlsSetValueTlsFreeCreateProcessACreateProcessWSetProcessShutdownParametersGetProcessVersionGetStartupInfoWCreateProcessAsUserWSetThreadToken// pub fn GetCurrentProcessToken();// pub fn GetCurrentThreadToken();// pub fn GetCurrentThreadEffectiveToken();OpenThreadTokenSetPriorityClassSetThreadStackGuaranteeGetPriorityClassGetProcessIdPPROC_THREAD_ATTRIBUTE_LISTPROC_THREAD_ATTRIBUTE_LISTFlushProcessWriteBuffersGetProcessIdOfThreadInitializeProcThreadAttributeListDeleteProcThreadAttributeListSetProcessAffinityUpdateModeQueryProcessAffinityUpdateModeUpdateProcThreadAttributeCreateRemoteThreadExGetCurrentThreadStackLimitsGetThreadContextSetThreadContextSetProcessMitigationPolicyGetProcessMitigationPolicyFlushInstructionCacheGetThreadTimesGetProcessHandleCountGetCurrentProcessorNumberSetThreadIdealProcessorExGetThreadIdealProcessorExGetCurrentProcessorNumberExGetProcessPriorityBoostSetProcessPriorityBoostGetThreadIOPendingFlagGetThreadInformationTHREAD_INFORMATION_CLASSSetThreadInformationIsProcessCriticalSetProtectedPolicyQueryProtectedPolicySetThreadIdealProcessorSetProcessInformationPROCESS_INFORMATION_CLASSGetProcessInformationGetProcessShutdownParameters// pub fn GetSystemCpuSetInformation();// pub fn GetProcessDefaultCpuSets();// pub fn SetProcessDefaultCpuSets();// pub fn GetThreadSelectedCpuSets();// pub fn SetThreadSelectedCpuSets();// pub fn CreateProcessAsUserA();// pub fn SetThreadDescription();// pub fn GetThreadDescription();//! ApiSet Contract for api-ms-win-core-processthreads-l1// MEMORY_PRIORITY_INFORMATIONGetProcessGroupAffinityGetThreadGroupAffinitySetThreadGroupAffinityQueryPerformanceCounterQueryPerformanceFrequencyPROPSETFLAG_DEFAULTPROPSETFLAG_NONSIMPLEPROPSETFLAG_ANSIPROPSETFLAG_UNBUFFEREDPROPSET_BEHAVIOR_CASE_SENSITIVELPVERSIONEDSTREAMVERSIONEDSTREAMTYPEDEF_CA// This is actually defined as a union between this struct// and DECIMAL. I don't this we need to do that.LPPROPVARIANTREFPROPVARIANTPID_DICTIONARYPID_CODEPAGEPID_FIRST_USABLEPID_FIRST_NAME_DEFAULTPID_LOCALEPID_MODIFY_TIMEPID_SECURITYPID_BEHAVIORPID_ILLEGALPID_MIN_READONLYPID_MAX_READONLYPRSPEC_INVALIDPRSPEC_LPWSTRPRSPEC_PROPIDPROPSETHDR_OSVER_KINDPROPSETHDR_OSVER_MAJORPROPSETHDR_OSVER_MINORPROPSETHDR_OSVERSION_UNKNOWNLPPROPERTYSETSTORAGEIPropertySetStorageLPENUMSTATPROPSTGIEnumSTATPROPSTGLPENUMSTATPROPSETSTGIEnumSTATPROPSETSTGLPPROPERTYSTORAGEIPropertyStoragePIDDI_THUMBNAILPIDSI_TITLEPIDSI_SUBJECTPIDSI_AUTHORPIDSI_KEYWORDSPIDSI_COMMENTSPIDSI_TEMPLATEPIDSI_LASTAUTHORPIDSI_REVNUMBERPIDSI_EDITTIMEPIDSI_LASTPRINTEDPIDSI_CREATE_DTMPIDSI_LASTSAVE_DTMPIDSI_PAGECOUNTPIDSI_WORDCOUNTPIDSI_CHARCOUNTPIDSI_THUMBNAILPIDSI_APPNAMEPIDSI_DOC_SECURITYPIDDSI_CATEGORYPIDDSI_PRESFORMATPIDDSI_BYTECOUNTPIDDSI_LINECOUNTPIDDSI_PARCOUNTPIDDSI_SLIDECOUNTPIDDSI_NOTECOUNTPIDDSI_HIDDENCOUNTPIDDSI_MMCLIPCOUNTPIDDSI_SCALEPIDDSI_HEADINGPAIRPIDDSI_DOCPARTSPIDDSI_MANAGERPIDDSI_COMPANYPIDDSI_LINKSDIRTYPIDMSI_EDITORPIDMSI_SUPPLIERPIDMSI_SOURCEPIDMSI_SEQUENCE_NOPIDMSI_PROJECTPIDMSI_STATUSPIDMSI_OWNERPIDMSI_RATINGPIDMSI_PRODUCTIONPIDMSI_COPYRIGHT// pub fn PropVariantInit(pvar: *mut PROPVARIANT) {//     memset(pvar, 0, sizeof(PROPVARIANT))PMemoryAllocatorStgConvertVariantToPropertySERIALIZEDPROPERTYVALUEStgConvertPropertyToVariantAUDIO_CHANNELCOUNT_MONOAUDIO_CHANNELCOUNT_STEREOCALENDAR_RESPONSESTATUS_NONECALENDAR_RESPONSESTATUS_ORGANIZEDCALENDAR_RESPONSESTATUS_TENTATIVECALENDAR_RESPONSESTATUS_ACCEPTEDCALENDAR_RESPONSESTATUS_DECLINEDCALENDAR_RESPONSESTATUS_NOTRESPONDEDCALENDAR_SHOWTIMEAS_FREECALENDAR_SHOWTIMEAS_TENTATIVECALENDAR_SHOWTIMEAS_BUSYCALENDAR_SHOWTIMEAS_OOFCOMMUNICATION_DIRECTION_UNKNOWNCOMMUNICATION_DIRECTION_INCOMINGCOMMUNICATION_DIRECTION_OUTGOINGTASKSTATUS_NOTSTARTEDTASKSTATUS_INPROGRESSTASKSTATUS_COMPLETETASKSTATUS_WAITINGTASKSTATUS_DEFERREDGENDERVALUE_UNSPECIFIEDGENDERVALUE_FEMALEGENDERVALUE_MALECREATOROPENWITHUIOPTION_HIDDENCREATOROPENWITHUIOPTION_VISIBLEISDEFAULTSAVE_NONEISDEFAULTSAVE_OWNERISDEFAULTSAVE_NONOWNERISDEFAULTSAVE_BOTHFILEOFFLINEAVAILABILITYSTATUS_PROP_NOTAVAILABLEOFFLINEFILEOFFLINEAVAILABILITYSTATUS_PROP_PARTIALLYAVAILABLEOFFLINEFLAGCOLOR_PURPLEFLAGCOLOR_ORANGEFLAGCOLOR_GREENFLAGCOLOR_YELLOWFLAGCOLOR_BLUEFLAGCOLOR_REDFLAGSTATUS_NOTFLAGGEDFLAGSTATUS_COMPLETEDFLAGSTATUS_FOLLOWUPIMPORTANCE_LOW_MINIMPORTANCE_LOW_SETIMPORTANCE_LOW_MAXIMPORTANCE_NORMAL_MINIMPORTANCE_NORMAL_SETIMPORTANCE_NORMAL_MAXIMPORTANCE_HIGH_MINIMPORTANCE_HIGH_SETIMPORTANCE_HIGH_MAXKIND_CALENDARKIND_COMMUNICATIONKIND_CONTACTKIND_DOCUMENTKIND_EMAILKIND_FEEDKIND_FOLDERKIND_GAMEKIND_INSTANTMESSAGEKIND_JOURNALKIND_LINKKIND_MOVIEKIND_MUSICKIND_NOTEKIND_PICTUREKIND_PLAYLISTKIND_PROGRAMKIND_RECORDEDTVKIND_SEARCHFOLDERKIND_TASKKIND_VIDEOKIND_WEBHISTORYKIND_UNKNOWNOFFLINEAVAILABILITY_NOT_AVAILABLEOFFLINEAVAILABILITY_AVAILABLEOFFLINEAVAILABILITY_ALWAYS_AVAILABLEOFFLINESTATUS_ONLINEOFFLINESTATUS_OFFLINEOFFLINESTATUS_OFFLINE_FORCEDOFFLINESTATUS_OFFLINE_SLOWOFFLINESTATUS_OFFLINE_ERROROFFLINESTATUS_OFFLINE_ITEM_VERSION_CONFLICTOFFLINESTATUS_OFFLINE_SUSPENDEDPRIORITY_PROP_LOWPRIORITY_PROP_NORMALPRIORITY_PROP_HIGHRATING_ONE_STAR_MINRATING_ONE_STAR_SETRATING_ONE_STAR_MAXRATING_TWO_STARS_MINRATING_TWO_STARS_SETRATING_TWO_STARS_MAXRATING_THREE_STARS_MINRATING_THREE_STARS_SETRATING_THREE_STARS_MAXRATING_FOUR_STARS_MINRATING_FOUR_STARS_SETRATING_FOUR_STARS_MAXRATING_FIVE_STARS_MINRATING_FIVE_STARS_SETRATING_FIVE_STARS_MAXSENSITIVITY_PROP_NORMALSENSITIVITY_PROP_PERSONALSENSITIVITY_PROP_PRIVATESENSITIVITY_PROP_CONFIDENTIALSHARINGSTATUS_NOTSHAREDSHARINGSTATUS_SHAREDSHARINGSTATUS_PRIVATESTORAGE_PROVIDER_SHARE_STATUS_PRIVATESTORAGE_PROVIDER_SHARE_STATUS_SHAREDSTORAGE_PROVIDER_SHARE_STATUS_PUBLICSTORAGE_PROVIDER_SHARE_STATUS_GROUPSTORAGE_PROVIDER_SHARE_STATUS_OWNERSTORAGE_PROVIDER_SHARINGSTATUS_NOTSHAREDSTORAGE_PROVIDER_SHARINGSTATUS_SHAREDSTORAGE_PROVIDER_SHARINGSTATUS_PRIVATESTORAGE_PROVIDER_SHARINGSTATUS_PUBLICSTORAGE_PROVIDER_SHARINGSTATUS_SHARED_OWNEDSTORAGE_PROVIDER_SHARINGSTATUS_SHARED_COOWNEDSTORAGE_PROVIDER_SHARINGSTATUS_PUBLIC_OWNEDSTORAGE_PROVIDER_SHARINGSTATUS_PUBLIC_COOWNEDBLUETOOTH_ADDRESS_TYPE_PUBLICBLUETOOTH_ADDRESS_TYPE_RANDOMBLUETOOTH_CACHE_MODE_CACHEDBLUETOOTH_CACHED_MODE_UNCACHEDPLAYBACKSTATE_UNKNOWNPLAYBACKSTATE_STOPPEDPLAYBACKSTATE_PLAYINGPLAYBACKSTATE_TRANSITIONINGPLAYBACKSTATE_PAUSEDPLAYBACKSTATE_RECORDINGPAUSEDPLAYBACKSTATE_RECORDINGPLAYBACKSTATE_NOMEDIAIMAGE_COLORSPACE_SRGBIMAGE_COLORSPACE_UNCALIBRATEDIMAGE_COMPRESSION_UNCOMPRESSEDIMAGE_COMPRESSION_CCITT_T3IMAGE_COMPRESSION_CCITT_T4IMAGE_COMPRESSION_CCITT_T6IMAGE_COMPRESSION_LZWIMAGE_COMPRESSION_JPEGIMAGE_COMPRESSION_PACKBITSLAYOUTPATTERN_CVMFB_ALPHALAYOUTPATTERN_CVMFB_BETALAYOUTPATTERN_CVMFB_GAMMALAYOUTPATTERN_CVMFB_DELTALAYOUTPATTERN_CVMFS_ALPHALAYOUTPATTERN_CVMFS_BETALAYOUTPATTERN_CVMFS_GAMMALAYOUTPATTERN_CVMFS_DELTALINK_STATUS_RESOLVEDLINK_STATUS_BROKENNOTE_COLOR_BLUENOTE_COLOR_GREENNOTE_COLOR_PINKNOTE_COLOR_YELLOWNOTE_COLOR_WHITENOTE_COLOR_LIGHTGREENPHOTO_CONTRAST_NORMALPHOTO_CONTRAST_SOFTPHOTO_CONTRAST_HARDPHOTO_EXPOSUREPROGRAM_UNKNOWNPHOTO_EXPOSUREPROGRAM_MANUALPHOTO_EXPOSUREPROGRAM_NORMALPHOTO_EXPOSUREPROGRAM_APERTUREPHOTO_EXPOSUREPROGRAM_SHUTTERPHOTO_EXPOSUREPROGRAM_CREATIVEPHOTO_EXPOSUREPROGRAM_ACTIONPHOTO_EXPOSUREPROGRAM_PORTRAITPHOTO_EXPOSUREPROGRAM_LANDSCAPEPHOTO_FLASH_NONEPHOTO_FLASH_FLASHPHOTO_FLASH_WITHOUTSTROBEPHOTO_FLASH_WITHSTROBEPHOTO_FLASH_FLASH_COMPULSORYPHOTO_FLASH_FLASH_COMPULSORY_NORETURNLIGHTPHOTO_FLASH_FLASH_COMPULSORY_RETURNLIGHTPHOTO_FLASH_NONE_COMPULSORYPHOTO_FLASH_NONE_AUTOPHOTO_FLASH_FLASH_AUTOPHOTO_FLASH_FLASH_AUTO_NORETURNLIGHTPHOTO_FLASH_FLASH_AUTO_RETURNLIGHTPHOTO_FLASH_NOFUNCTIONPHOTO_FLASH_FLASH_REDEYEPHOTO_FLASH_FLASH_REDEYE_NORETURNLIGHTPHOTO_FLASH_FLASH_REDEYE_RETURNLIGHTPHOTO_FLASH_FLASH_COMPULSORY_REDEYEPHOTO_FLASH_FLASH_COMPULSORY_REDEYE_NORETURNLIGHTPHOTO_FLASH_FLASH_COMPULSORY_REDEYE_RETURNLIGHTPHOTO_FLASH_FLASH_AUTO_REDEYEPHOTO_FLASH_FLASH_AUTO_REDEYE_NORETURNLIGHTPHOTO_FLASH_FLASH_AUTO_REDEYE_RETURNLIGHTPHOTO_GAINCONTROL_NONEPHOTO_GAINCONTROL_LOWGAINUPPHOTO_GAINCONTROL_HIGHGAINUPPHOTO_GAINCONTROL_LOWGAINDOWNPHOTO_GAINCONTROL_HIGHGAINDOWNPHOTO_LIGHTSOURCE_UNKNOWNPHOTO_LIGHTSOURCE_DAYLIGHTPHOTO_LIGHTSOURCE_FLUORESCENTPHOTO_LIGHTSOURCE_TUNGSTENPHOTO_LIGHTSOURCE_STANDARD_APHOTO_LIGHTSOURCE_STANDARD_BPHOTO_LIGHTSOURCE_STANDARD_CPHOTO_LIGHTSOURCE_D55PHOTO_LIGHTSOURCE_D65PHOTO_LIGHTSOURCE_D75PHOTO_METERINGMODE_UNKNOWNPHOTO_METERINGMODE_AVERAGEPHOTO_METERINGMODE_CENTERPHOTO_METERINGMODE_SPOTPHOTO_METERINGMODE_MULTISPOTPHOTO_METERINGMODE_PATTERNPHOTO_METERINGMODE_PARTIALPHOTO_ORIENTATION_NORMALPHOTO_ORIENTATION_FLIPHORIZONTALPHOTO_ORIENTATION_ROTATE180PHOTO_ORIENTATION_FLIPVERTICALPHOTO_ORIENTATION_TRANSPOSEPHOTO_ORIENTATION_ROTATE270PHOTO_ORIENTATION_TRANSVERSEPHOTO_ORIENTATION_ROTATE90PHOTO_PHOTOMETRIC_RGBPHOTO_PHOTOMETRIC_YCBCRPHOTO_PROGRAMMODE_NOTDEFINEDPHOTO_PROGRAMMODE_MANUALPHOTO_PROGRAMMODE_NORMALPHOTO_PROGRAMMODE_APERTUREPHOTO_PROGRAMMODE_SHUTTERPHOTO_PROGRAMMODE_CREATIVEPHOTO_PROGRAMMODE_ACTIONPHOTO_PROGRAMMODE_PORTRAITPHOTO_PROGRAMMODE_LANDSCAPEPHOTO_SATURATION_NORMALPHOTO_SATURATION_LOWPHOTO_SATURATION_HIGHPHOTO_SHARPNESS_NORMALPHOTO_SHARPNESS_SOFTPHOTO_SHARPNESS_HARDPHOTO_WHITEBALANCE_AUTOPHOTO_WHITEBALANCE_MANUALSFGAOSTR_FILESYSSFGAOSTR_FILEANCSFGAOSTR_STORAGEANCSFGAOSTR_STREAMSFGAOSTR_LINKSFGAOSTR_HIDDENSFGAOSTR_SUPERHIDDENSFGAOSTR_FOLDERSFGAOSTR_NONENUMSFGAOSTR_BROWSABLESFGAOSTR_SYSTEMAPPUSERMODEL_STARTPINOPTION_DEFAULTAPPUSERMODEL_STARTPINOPTION_NOPINONINSTALLAPPUSERMODEL_STARTPINOPTION_USERPINNEDSYNC_HANDLERTYPE_OTHERSYNC_HANDLERTYPE_PROGRAMSSYNC_HANDLERTYPE_DEVICESSYNC_HANDLERTYPE_FOLDERSSYNC_HANDLERTYPE_WEBSERVICESSYNC_HANDLERTYPE_COMPUTERSSYNC_STATE_NOTSETUPSYNC_STATE_SYNCNOTRUNSYNC_STATE_IDLESYNC_STATE_ERRORSYNC_STATE_PENDINGSYNC_STATE_SYNCINGIsEqualPropertyKeyIPropertyDescriptionListHPALETTEDLGPROCLPCDLGTEMPLATEAPSPPSP_DEFAULTPSP_DLGINDIRECTPSP_USEHICONPSP_USEICONIDPSP_USETITLEPSP_RTLREADINGPSP_HASHELPPSP_USEREFPARENTPSP_USECALLBACKPSP_PREMATUREPSP_HIDEHEADERPSP_USEHEADERTITLEPSP_USEHEADERSUBTITLEPSP_USEFUSIONCONTEXTPSPCB_ADDREFPSPCB_RELEASEPSPCB_CREATEPROPSHEETPAGE_RESOURCELPPROPSHEETPAGEA_V4PROPSHEETPAGEA_V4LPCPROPSHEETPAGEA_V4LPPROPSHEETPAGEW_V4PROPSHEETPAGEW_V4LPCPROPSHEETPAGEW_V4PROPSHEETPAGEA_LATESTPROPSHEETPAGEW_LATESTLPPROPSHEETPAGEA_LATESTLPPROPSHEETPAGEW_LATESTLPCPROPSHEETPAGEA_LATESTLPCPROPSHEETPAGEW_LATESTPROPSHEETPAGEAPROPSHEETPAGEWLPPROPSHEETPAGEALPPROPSHEETPAGEWLPCPROPSHEETPAGEALPCPROPSHEETPAGEWPSH_DEFAULTPSH_PROPTITLEPSH_USEHICONPSH_USEICONIDPSH_PROPSHEETPAGEPSH_WIZARDHASFINISHPSH_WIZARDPSH_USEPSTARTPAGEPSH_NOAPPLYNOWPSH_USECALLBACKPSH_HASHELPPSH_MODELESSPSH_RTLREADINGPSH_WIZARDCONTEXTHELPPSH_WIZARD97PSH_WATERMARKPSH_USEHBMWATERMARKPSH_USEHPLWATERMARKPSH_STRETCHWATERMARKPSH_HEADERPSH_USEHBMHEADERPSH_USEPAGELANGPSH_WIZARD_LITEPSH_NOCONTEXTHELPPSH_AEROWIZARDPSH_RESIZABLEPSH_HEADERBITMAPPSH_NOMARGINLPPROPSHEETHEADERA_V2PROPSHEETHEADERA_V2LPCPROPSHEETHEADERA_V2LPPROPSHEETHEADERW_V2PROPSHEETHEADERW_V2LPCPROPSHEETHEADERW_V2PROPSHEETHEADERAPROPSHEETHEADERWLPPROPSHEETHEADERALPPROPSHEETHEADERWLPCPROPSHEETHEADERALPCPROPSHEETHEADERWPSCB_INITIALIZEDPSCB_PRECREATEPSCB_BUTTONPRESSEDCreatePropertySheetPageACreatePropertySheetPageWDestroyPropertySheetPagePropertySheetAPropertySheetWLPPSHNOTIFYPSHNOTIFYPSN_FIRSTPSN_LASTPSN_SETACTIVEPSN_KILLACTIVEPSN_APPLYPSN_RESETPSN_HELPPSN_WIZBACKPSN_WIZNEXTPSN_WIZFINISHPSN_QUERYCANCELPSN_GETOBJECTPSN_TRANSLATEACCELERATORPSN_QUERYINITIALFOCUSPSNRET_NOERRORPSNRET_INVALIDPSNRET_INVALID_NOCHANGEPAGEPSNRET_MESSAGEHANDLEDPSM_SETCURSELPSM_REMOVEPAGEPSM_ADDPAGEPSM_CHANGEDPSM_RESTARTWINDOWSPSM_REBOOTSYSTEMPSM_CANCELTOCLOSEPSM_QUERYSIBLINGSPSM_UNCHANGEDPSM_APPLYPSM_SETTITLEAPSM_SETTITLEWPSM_SETWIZBUTTONSPSWIZB_BACKPSWIZB_NEXTPSWIZB_FINISHPSWIZB_DISABLEDFINISHPSWIZBF_ELEVATIONREQUIREDPSWIZB_CANCELPSM_PRESSBUTTONPSBTN_BACKPSBTN_NEXTPSBTN_FINISHPSBTN_OKPSBTN_APPLYNOWPSBTN_CANCELPSBTN_HELPPSBTN_MAXPSM_SETCURSELIDPSM_SETFINISHTEXTAPSM_SETFINISHTEXTWPSM_GETTABCONTROLPSM_ISDIALOGMESSAGEPSM_GETCURRENTPAGEHWNDPSM_INSERTPAGEPSM_SETHEADERTITLEAPSM_SETHEADERTITLEWPSWIZF_SETCOLORPSM_SETHEADERSUBTITLEAPSM_SETHEADERSUBTITLEWPSM_HWNDTOINDEXPSM_INDEXTOHWNDPSM_PAGETOINDEXPSM_INDEXTOPAGEPSM_IDTOINDEXPSM_INDEXTOIDPSM_GETRESULTPSM_RECALCPAGESIZESPSM_SETNEXTTEXTWPSM_SHOWWIZBUTTONSPSM_ENABLEWIZBUTTONSPSM_SETBUTTONTEXTWPSM_SETBUTTONTEXTID_PSRESTARTWINDOWSID_PSREBOOTSYSTEMWIZ_CXDLGWIZ_CYDLGWIZ_CXBMPWIZ_BODYXWIZ_BODYCXPROP_SM_CXDLGPROP_SM_CYDLGPROP_MED_CXDLGPROP_MED_CYDLGPROP_LG_CXDLGPROP_LG_CYDLG//! Interface for the Windows Property Sheet PagesLIST_MODULES_DEFAULTLIST_MODULES_32BITLIST_MODULES_64BITLIST_MODULES_ALLK32EnumProcessesK32EnumProcessModulesK32EnumProcessModulesExK32GetModuleBaseNameAK32GetModuleBaseNameWK32GetModuleFileNameExAK32GetModuleFileNameExWK32EmptyWorkingSetK32QueryWorkingSetK32QueryWorkingSetExK32InitializeProcessForWsWatchK32GetWsChangesPPSAPI_WS_WATCH_INFORMATIONK32GetWsChangesExPPSAPI_WS_WATCH_INFORMATION_EXK32GetMappedFileNameWK32GetMappedFileNameAK32EnumDeviceDriversK32GetDeviceDriverBaseNameAK32GetDeviceDriverBaseNameWK32GetDeviceDriverFileNameAK32GetDeviceDriverFileNameWPPERFORMANCE_INFORMATIONK32EnumPageFilesWPENUM_PAGE_FILE_CALLBACKWK32EnumPageFilesAPENUM_PAGE_FILE_CALLBACKAK32GetProcessImageFileNameAK32GetProcessImageFileNameWEnumProcessesK32GetProcessMemoryInfoPPROCESS_MEMORY_COUNTERSK32GetModuleInformationLPMODULEINFOMODULEINFOPPSAPI_WORKING_SET_INFORMATIONPSAPI_WORKING_SET_INFORMATIONPPSAPI_WORKING_SET_EX_INFORMATIONPSAPI_WORKING_SET_EX_INFORMATIONPSAPI_WS_WATCH_INFORMATIONPSAPI_WS_WATCH_INFORMATION_EXPENUM_PAGE_FILE_INFORMATIONENUM_PAGE_FILE_INFORMATIONPROCESS_MEMORY_COUNTERSPPROCESS_MEMORY_COUNTERS_EXPPSAPI_WORKING_SET_BLOCKPSAPI_WORKING_SET_BLOCKPPSAPI_WORKING_SET_EX_BLOCKPSAPI_WORKING_SET_EX_BLOCKEmptyWorkingSetEnumDeviceDriversEnumPageFilesAEnumPageFilesWEnumProcessModulesEnumProcessModulesExGetDeviceDriverBaseNameAGetDeviceDriverBaseNameWGetDeviceDriverFileNameAGetDeviceDriverFileNameWGetMappedFileNameAGetMappedFileNameWGetModuleBaseNameAGetModuleBaseNameWGetModuleFileNameExAGetModuleInformationGetPerformanceInfoGetProcessImageFileNameAGetProcessImageFileNameWGetWsChangesGetWsChangesExInitializeProcessForWsWatchQueryWorkingSetQueryWorkingSetEx//! FFI bindings to psapi.QueryThreadCycleTimeQueryProcessCycleTimeQueryIdleProcessorCycleTimeQueryIdleProcessorCycleTimeExQueryUnbiasedInterruptTimeSHTDN_REASON_FLAG_COMMENT_REQUIREDSHTDN_REASON_FLAG_DIRTY_PROBLEM_ID_REQUIREDSHTDN_REASON_FLAG_CLEAN_UISHTDN_REASON_FLAG_DIRTY_UISHTDN_REASON_FLAG_USER_DEFINEDSHTDN_REASON_MAJOR_OTHERSHTDN_REASON_MAJOR_NONESHTDN_REASON_MAJOR_HARDWARESHTDN_REASON_MAJOR_SOFTWARESHTDN_REASON_MAJOR_APPLICATIONSHTDN_REASON_MAJOR_SYSTEMSHTDN_REASON_MAJOR_POWERSHTDN_REASON_MAJOR_LEGACY_APISHTDN_REASON_MINOR_OTHERSHTDN_REASON_MINOR_NONESHTDN_REASON_MINOR_MAINTENANCESHTDN_REASON_MINOR_INSTALLATIONSHTDN_REASON_MINOR_RECONFIGSHTDN_REASON_MINOR_HUNGSHTDN_REASON_MINOR_UNSTABLESHTDN_REASON_MINOR_DISKSHTDN_REASON_MINOR_PROCESSORSHTDN_REASON_MINOR_NETWORKCARDSHTDN_REASON_MINOR_POWER_SUPPLYSHTDN_REASON_MINOR_CORDUNPLUGGEDSHTDN_REASON_MINOR_ENVIRONMENTSHTDN_REASON_MINOR_HARDWARE_DRIVERSHTDN_REASON_MINOR_OTHERDRIVERSHTDN_REASON_MINOR_BLUESCREENSHTDN_REASON_MINOR_SERVICEPACKSHTDN_REASON_MINOR_HOTFIXSHTDN_REASON_MINOR_SECURITYFIXSHTDN_REASON_MINOR_SECURITYSHTDN_REASON_MINOR_NETWORK_CONNECTIVITYSHTDN_REASON_MINOR_WMISHTDN_REASON_MINOR_SERVICEPACK_UNINSTALLSHTDN_REASON_MINOR_HOTFIX_UNINSTALLSHTDN_REASON_MINOR_SECURITYFIX_UNINSTALLSHTDN_REASON_MINOR_MMCSHTDN_REASON_MINOR_SYSTEMRESTORESHTDN_REASON_MINOR_TERMSRVSHTDN_REASON_MINOR_DC_PROMOTIONSHTDN_REASON_MINOR_DC_DEMOTIONSHTDN_REASON_UNKNOWNSHTDN_REASON_LEGACY_APISHTDN_REASON_VALID_BIT_MASKPCLEANUIUCLEANUIPDIRTYUIUDIRTYUIRM_SESSION_KEY_LENCCH_RM_SESSION_KEY// mem::size_of::<GUID>()CCH_RM_MAX_APP_NAMECCH_RM_MAX_SVC_NAMERM_INVALID_TS_SESSIONRM_INVALID_PROCESSPRM_UNIQUE_PROCESSRM_UNIQUE_PROCESSPRM_PROCESS_INFORM_PROCESS_INFOPRM_FILTER_INFORM_FILTER_INFORmStartSessionRmJoinSessionRmEndSessionRmRegisterResourcesRmGetListRmShutdownRM_WRITE_STATUS_CALLBACKRmRestartRmCancelCurrentTaskRmAddFilterRM_FILTER_ACTIONRmRemoveFilterRmGetFilterList//! RestartManager include fileALIGN_SIZESPDATAKEYLOCATIONSPDKL_DefaultLocationSPDKL_CurrentUserSPDKL_LocalMachineSPDKL_CurrentConfigSPDUI_EnginePropertiesSPDUI_AddRemoveWordSPDUI_UserTrainingSPDUI_MicTrainingSPDUI_RecoProfilePropertiesSPDUI_AudioPropertiesSPDUI_AudioVolumeSPDUI_UserEnrollmentSPDUI_ShareDataSPDUI_TutorialSPSTREAMFORMATSPSF_DefaultSPSF_NoAssignedFormatSPSF_TextSPSF_NonStandardFormatSPSF_ExtendedAudioFormatSPSF_8kHz8BitMonoSPSF_8kHz8BitStereoSPSF_8kHz16BitMonoSPSF_8kHz16BitStereoSPSF_11kHz8BitMonoSPSF_11kHz8BitStereoSPSF_11kHz16BitMonoSPSF_11kHz16BitStereoSPSF_12kHz8BitMonoSPSF_12kHz8BitStereoSPSF_12kHz16BitMonoSPSF_12kHz16BitStereoSPSF_16kHz8BitMonoSPSF_16kHz8BitStereoSPSF_16kHz16BitMonoSPSF_16kHz16BitStereoSPSF_22kHz8BitMonoSPSF_22kHz8BitStereoSPSF_22kHz16BitMonoSPSF_22kHz16BitStereoSPSF_24kHz8BitMonoSPSF_24kHz8BitStereoSPSF_24kHz16BitMonoSPSF_24kHz16BitStereoSPSF_32kHz8BitMonoSPSF_32kHz8BitStereoSPSF_32kHz16BitMonoSPSF_32kHz16BitStereoSPSF_44kHz8BitMonoSPSF_44kHz8BitStereoSPSF_44kHz16BitMonoSPSF_44kHz16BitStereoSPSF_48kHz8BitMonoSPSF_48kHz8BitStereoSPSF_48kHz16BitMonoSPSF_48kHz16BitStereoSPSF_TrueSpeech_8kHz1BitMonoSPSF_CCITT_ALaw_8kHzMonoSPSF_CCITT_ALaw_8kHzStereoSPSF_CCITT_ALaw_11kHzMonoSPSF_CCITT_ALaw_11kHzStereoSPSF_CCITT_ALaw_22kHzMonoSPSF_CCITT_ALaw_22kHzStereoSPSF_CCITT_ALaw_44kHzMonoSPSF_CCITT_ALaw_44kHzStereoSPSF_CCITT_uLaw_8kHzMonoSPSF_CCITT_uLaw_8kHzStereoSPSF_CCITT_uLaw_11kHzMonoSPSF_CCITT_uLaw_11kHzStereoSPSF_CCITT_uLaw_22kHzMonoSPSF_CCITT_uLaw_22kHzStereoSPSF_CCITT_uLaw_44kHzMonoSPSF_CCITT_uLaw_44kHzStereoSPSF_ADPCM_8kHzMonoSPSF_ADPCM_8kHzStereoSPSF_ADPCM_11kHzMonoSPSF_ADPCM_11kHzStereoSPSF_ADPCM_22kHzMonoSPSF_ADPCM_22kHzStereoSPSF_ADPCM_44kHzMonoSPSF_ADPCM_44kHzStereoSPSF_GSM610_8kHzMonoSPSF_GSM610_11kHzMonoSPSF_GSM610_22kHzMonoSPSF_GSM610_44kHzMonoSPSF_NUM_FORMATSSPDFID_TextSPDFID_WaveFormatExSPREG_USER_ROOTSPREG_LOCAL_MACHINE_ROOTSPCAT_AUDIOOUTSPCAT_AUDIOINSPCAT_VOICESSPCAT_RECOGNIZERSSPCAT_APPLEXICONSSPCAT_PHONECONVERTERSSPCAT_TEXTNORMALIZERSSPCAT_RECOPROFILESSPMMSYS_AUDIO_IN_TOKEN_IDSPMMSYS_AUDIO_OUT_TOKEN_IDSPCURRENT_USER_LEXICON_TOKEN_IDSPTOKENVALUE_CLSIDSPTOKENKEY_FILESSPTOKENKEY_UISPTOKENKEY_ATTRIBUTESSPTOKENKEY_RETAINEDAUDIOSPTOKENKEY_AUDIO_LATENCY_WARNINGSPTOKENKEY_AUDIO_LATENCY_TRUNCATESPTOKENKEY_AUDIO_LATENCY_UPDATE_INTERVALSPVOICECATEGORY_TTSRATESPPROP_RESOURCE_USAGESPPROP_HIGH_CONFIDENCE_THRESHOLDSPPROP_NORMAL_CONFIDENCE_THRESHOLDSPPROP_LOW_CONFIDENCE_THRESHOLDSPPROP_RESPONSE_SPEEDSPPROP_COMPLEX_RESPONSE_SPEEDSPPROP_ADAPTATION_ONSPPROP_PERSISTED_BACKGROUND_ADAPTATIONSPPROP_PERSISTED_LANGUAGE_MODEL_ADAPTATIONSPPROP_UX_IS_LISTENINGSPTOPIC_SPELLINGSPWILDCARDSPDICTATIONSPREG_SAFE_USER_TOKENSSPINFDICTATIONSP_LOW_CONFIDENCESP_NORMAL_CONFIDENCESP_HIGH_CONFIDENCEDEFAULT_WEIGHTSP_MAX_WORD_LENGTHSP_MAX_PRON_LENGTHSP_EMULATE_RESULTISpNotifyCallbackSPNOTIFYCALLBACKISpNotifySourceISpNotifySourceVtblISpNotifySinkISpNotifySinkVtblISpNotifyTranslatorISpNotifyTranslatorVtblISpDataKeyISpDataKeyVtblISpRegDataKeyISpRegDataKeyVtblISpObjectTokenCategoryISpObjectTokenCategoryVtblISpObjectTokenISpObjectTokenVtblISpObjectTokenInitISpObjectTokenInitVtblIEnumSpObjectTokensIEnumSpObjectTokensVtblISpObjectWithTokenISpObjectWithTokenVtblISpResourceManagerISpResourceManagerVtblSPEVENTLPARAMTYPESPET_LPARAM_IS_UNDEFINEDSPET_LPARAM_IS_TOKENSPET_LPARAM_IS_OBJECTSPET_LPARAM_IS_POINTERSPET_LPARAM_IS_STRINGSPEVENTENUMSPEI_UNDEFINEDSPEI_START_INPUT_STREAMSPEI_END_INPUT_STREAMSPEI_VOICE_CHANGESPEI_TTS_BOOKMARKSPEI_WORD_BOUNDARYSPEI_PHONEMESPEI_SENTENCE_BOUNDARYSPEI_VISEMESPEI_TTS_AUDIO_LEVELSPEI_TTS_PRIVATESPEI_MIN_TTSSPEI_MAX_TTSSPEI_END_SR_STREAMSPEI_SOUND_STARTSPEI_SOUND_ENDSPEI_PHRASE_STARTSPEI_RECOGNITIONSPEI_HYPOTHESISSPEI_SR_BOOKMARKSPEI_PROPERTY_NUM_CHANGESPEI_PROPERTY_STRING_CHANGESPEI_FALSE_RECOGNITIONSPEI_INTERFERENCESPEI_REQUEST_UISPEI_RECO_STATE_CHANGESPEI_ADAPTATIONSPEI_START_SR_STREAMSPEI_RECO_OTHER_CONTEXTSPEI_SR_AUDIO_LEVELSPEI_SR_RETAINEDAUDIOSPEI_SR_PRIVATEACTIVE_CATEGORY_CHANGEDSPEI_RESERVED5SPEI_RESERVED6SPEI_MIN_SRSPEI_MAX_SRSPEI_RESERVED1SPEI_RESERVED2SPEI_RESERVED3SPFEI_FLAGCHECKSPFEI_ALL_TTS_EVENTSSPFEI_ALL_SR_EVENTSSPFEI_ALL_EVENTSSPFEISPEVENTSPSERIALIZEDEVENTSPSERIALIZEDEVENT64SPEVENTEXSPINTERFERENCESPINTERFERENCE_NONESPINTERFERENCE_NOISESPINTERFERENCE_NOSIGNALSPINTERFERENCE_TOOLOUDSPINTERFERENCE_TOOQUIETSPINTERFERENCE_TOOFASTSPINTERFERENCE_TOOSLOWSPINTERFERENCE_LATENCY_WARNINGSPINTERFERENCE_LATENCY_TRUNCATE_BEGINSPINTERFERENCE_LATENCY_TRUNCATE_ENDSPENDSRSTREAMFLAGSSPESF_NONESPESF_STREAM_RELEASEDSPESF_EMULATEDSPVFEATURESPVFEATURE_STRESSEDSPVFEATURE_EMPHASISSPVISEMESSP_VISEME_0SP_VISEME_1SP_VISEME_2SP_VISEME_3SP_VISEME_4SP_VISEME_5SP_VISEME_6SP_VISEME_7SP_VISEME_8SP_VISEME_9SP_VISEME_10SP_VISEME_11SP_VISEME_12SP_VISEME_13SP_VISEME_14SP_VISEME_15SP_VISEME_16SP_VISEME_17SP_VISEME_18SP_VISEME_19SP_VISEME_20SP_VISEME_21SPEVENTSOURCEINFOISpEventSourceISpEventSourceVtblISpEventSource2ISpEventSource2VtblISpEventSinkISpEventSinkVtblISpStreamFormatISpStreamFormatVtblSPFILEMODESPFM_OPEN_READONLYSPFM_OPEN_READWRITESPFM_CREATESPFM_CREATE_ALWAYSSPFM_NUM_MODESISpStreamISpStreamVtblISpStreamFormatConverterISpStreamFormatConverterVtblSPAUDIOSTATESPAS_CLOSEDSPAS_STOPSPAS_PAUSESPAS_RUNSPAUDIOSTATUSSPAUDIOBUFFERINFOISpAudioISpAudioVtblISpMMSysAudioISpMMSysAudioVtblISpTranscriptISpTranscriptVtblSPDISPLAYATTRIBUTESSPAF_ONE_TRAILING_SPACESPAF_TWO_TRAILING_SPACESSPAF_CONSUME_LEADING_SPACESSPAF_BUFFER_POSITIONSPAF_ALLSPAF_USER_SPECIFIEDSPPHONEIDPSPPHONEIDPCSPPHONEIDSPPHRASEELEMENTSPPHRASERULESPPHRASEPROPERTYUNIONTYPESPPPUT_UNUSEDSPPPUT_ARRAY_INDEXSPPHRASEPROPERTYSPPHRASEREPLACEMENTSPSEMANTICERRORINFOSPSEMANTICFORMATSPPHRASE_50// SPPHRASESIZE_500,SPPHRASESPPHRASE_53SPSERIALIZEDPHRASESPRULESPVALUETYPESPDF_PROPERTYSPDF_REPLACEMENTSPDF_RULESPDF_DISPLAYTEXTSPDF_LEXICALFORMSPDF_PRONUNCIATIONSPDF_AUDIOSPDF_ALTERNATESSPDF_ALLSPBINARYGRAMMARSPPHRASERNGSPPR_ALL_ELEMENTSSP_GETWHOLEPHRASESPRR_ALL_ELEMENTSSPSTATEHANDLESPRECOEVENTFLAGSSPREF_AutoPauseSPREF_EmulatedSPREF_SMLTimeoutSPREF_ExtendableParseSPREF_ReSentSPREF_HypothesisSPREF_FalseRecognitionSPPARTOFSPEECHSPPS_NotOverridenSPPS_UnknownSPPS_NounSPPS_VerbSPPS_ModifierSPPS_FunctionSPPS_InterjectionSPPS_NoncontentSPPS_LMASPPS_SuppressWordSPLEXICONTYPEeLEXTYPE_USEReLEXTYPE_APPeLEXTYPE_VENDORLEXICONeLEXTYPE_LETTERTOSOUNDeLEXTYPE_MORPHOLOGYeLEXTYPE_RESERVED4eLEXTYPE_USER_SHORTCUTeLEXTYPE_RESERVED6eLEXTYPE_RESERVED7eLEXTYPE_RESERVED8eLEXTYPE_RESERVED9eLEXTYPE_RESERVED10eLEXTYPE_PRIVATE1eLEXTYPE_PRIVATE2eLEXTYPE_PRIVATE3eLEXTYPE_PRIVATE4eLEXTYPE_PRIVATE5eLEXTYPE_PRIVATE6eLEXTYPE_PRIVATE7eLEXTYPE_PRIVATE8eLEXTYPE_PRIVATE9eLEXTYPE_PRIVATE10eLEXTYPE_PRIVATE11eLEXTYPE_PRIVATE12eLEXTYPE_PRIVATE13eLEXTYPE_PRIVATE14eLEXTYPE_PRIVATE15eLEXTYPE_PRIVATE16eLEXTYPE_PRIVATE17eLEXTYPE_PRIVATE18eLEXTYPE_PRIVATE19eLEXTYPE_PRIVATE20SPWORDTYPEeWORDTYPE_ADDEDeWORDTYPE_DELETEDSPPRONUNCIATIONFLAGSePRONFLAG_USEDSPWORDPRONUNCIATIONSPWORDPRONUNCIATIONLISTSPWORDSPWORDLISTISpLexiconISpLexiconVtblISpContainerLexiconISpContainerLexiconVtblSPSHORTCUTTYPESPSHT_NotOverridenSPSHT_UnknownSPSHT_EMAILSPSHT_OTHERSPPS_RESERVED1SPPS_RESERVED2SPPS_RESERVED3SPPS_RESERVED4SPSHORTCUTPAIRSPSHORTCUTPAIRLISTISpShortcutISpShortcutVtblISpPhoneConverterISpPhoneConverterVtblISpPhoneticAlphabetConverterISpPhoneticAlphabetConverterVtblISpPhoneticAlphabetSelectionISpPhoneticAlphabetSelectionVtblSPVPITCHSPVACTIONSSPVA_SpeakSPVA_SilenceSPVA_PronounceSPVA_BookmarkSPVA_SpellOutSPVA_SectionSPVA_ParseUnknownTagSPVCONTEXTSPVSTATESPRUNSTATESPRS_DONESPRS_IS_SPEAKINGSPVLIMITSSPMIN_VOLUMESPMAX_VOLUMESPMIN_RATESPMAX_RATESPVPRIORITYSPVPRI_NORMALSPVPRI_ALERTSPVPRI_OVERSPVOICESTATUSSPEAKFLAGSSPF_DEFAULTSPF_ASYNCSPF_PURGEBEFORESPEAKSPF_IS_FILENAMESPF_IS_XMLSPF_IS_NOT_XMLSPF_PERSIST_XMLSPF_NLP_SPEAK_PUNCSPF_PARSE_SAPISPF_PARSE_SSMLSPF_PARSE_AUTODETECTSPF_NLP_MASKSPF_PARSE_MASKSPF_VOICE_MASKSPF_UNUSED_FLAGSISpVoiceISpVoiceVtblISpPhraseISpPhraseVtblISpPhraseAltISpPhraseAltVtblSPXMLRESULTOPTIONSSPXRO_SMLSPXRO_Alternates_SMLISpPhrase2ISpPhrase2VtblSPRECORESULTTIMESSPSERIALIZEDRESULTISpRecoResultISpRecoResultVtblSPCOMMITFLAGSSPCF_NONESPCF_ADD_TO_USER_LEXICONSPCF_DEFINITE_CORRECTIONISpRecoResult2ISpRecoResult2VtblISpXMLRecoResultISpXMLRecoResultVtblSPTEXTSELECTIONINFOSPWORDPRONOUNCEABLESPWP_UNKNOWN_WORD_UNPRONOUNCEABLESPWP_UNKNOWN_WORD_PRONOUNCEABLESPWP_KNOWN_WORD_PRONOUNCEABLESPGRAMMARSTATESPGS_DISABLEDSPGS_ENABLEDSPGS_EXCLUSIVESPCONTEXTSTATESPCS_DISABLEDSPCS_ENABLEDSPRULESTATESPRS_INACTIVESPRS_ACTIVESPRS_ACTIVE_WITH_AUTO_PAUSESPWT_LEXICAL_NO_SPECIAL_CHARSSPPROPERTYINFOSPCFGRULEATTRIBUTESSPRAF_TopLevelSPRAF_ActiveSPRAF_ExportSPRAF_ImportSPRAF_InterpreterSPRAF_DynamicSPRAF_RootSPRAF_AutoPauseSPRAF_UserDelimitedISpGrammarBuilderISpGrammarBuilderVtblSPLOADOPTIONSSPLO_STATICSPLO_DYNAMICISpRecoGrammarISpRecoGrammarVtblSPMATCHINGMODEAllWordsSubsequenceOrderedSubsetSubsequenceContentRequiredOrderedSubsetContentRequiredPHONETICALPHABETPA_IpaPA_UpsPA_SapiISpGrammarBuilder2ISpGrammarBuilder2VtblSPRP_NORMALISpRecoGrammar2ISpRecoGrammar2VtblISpeechResourceLoaderISpeechResourceLoaderVtblSPRECOCONTEXTSTATUSSPBOOKMARKOPTIONSSPBO_NONESPBO_PAUSESPBO_AHEADSPBO_TIME_UNITSSPAUDIOOPTIONSSPAO_NONESPAO_RETAIN_AUDIOISpRecoContextISpRecoContextVtblSPGRAMMAROPTIONSSPGO_SAPISPGO_SRGSSPGO_UPSSPGO_SRGS_MS_SCRIPTSPGO_SRGS_W3C_SCRIPTSPGO_SRGS_STG_SCRIPTSPGO_SRGS_SCRIPTSPGO_FILESPGO_HTTPSPGO_RESSPGO_OBJECTSPGO_DEFAULTSPGO_ALLSPADAPTATIONSETTINGSSPADS_DefaultSPADS_CurrentRecognizerSPADS_RecoProfileSPADS_ImmediateSPADS_ResetSPADS_HighVolumeDataSourceSPADAPTATIONRELEVANCESPAR_UnknownSPAR_LowSPAR_MediumSPAR_HighISpRecoContext2ISpRecoContext2VtblISpPropertiesISpPropertiesVtblSP_MAX_LANGIDSSPRECOGNIZERSTATUSSPWAVEFORMATTYPESPWF_INPUTSPWF_SRENGINESPSTREAMFORMATTYPESPRECOSTATESPRST_INACTIVESPRST_ACTIVESPRST_ACTIVE_ALWAYSSPRST_INACTIVE_WITH_PURGESPRST_NUM_STATESISpRecognizerISpRecognizerVtblISpSerializeStateISpSerializeStateVtblISpRecognizer2ISpRecognizer2VtblSPNORMALIZATIONLISTISpEnginePronunciationISpEnginePronunciationVtblSPDISPLAYTOKENSPDISPLAYPHRASEISpDisplayAlternatesISpDisplayAlternatesVtblSpeechLanguageIdDISPID_SpeechDataKeyDISPID_SDKSetBinaryValueDISPID_SDKGetBinaryValueDISPID_SDKSetStringValueDISPID_SDKGetStringValueDISPID_SDKSetLongValueDISPID_SDKGetlongValueDISPID_SDKOpenKeyDISPID_SDKCreateKeyDISPID_SDKDeleteKeyDISPID_SDKDeleteValueDISPID_SDKEnumKeysDISPID_SDKEnumValuesDISPID_SpeechObjectTokenDISPID_SOTIdDISPID_SOTDataKeyDISPID_SOTCategoryDISPID_SOTGetDescriptionDISPID_SOTSetIdDISPID_SOTGetAttributeDISPID_SOTCreateInstanceDISPID_SOTRemoveDISPID_SOTGetStorageFileNameDISPID_SOTRemoveStorageFileNameDISPID_SOTIsUISupportedDISPID_SOTDisplayUIDISPID_SOTMatchesAttributesSpeechDataKeyLocationSDKLDefaultLocationSDKLCurrentUserSDKLLocalMachineSDKLCurrentConfigSpeechTokenContextSTCInprocServerSTCInprocHandlerSTCLocalServerSTCRemoteServerSTCAllSpeechTokenShellFolderSTSF_AppDataSTSF_LocalAppDataSTSF_CommonAppDataSTSF_FlagCreateDISPID_SpeechObjectTokensDISPID_SOTsCountDISPID_SOTsItemDISPID_SOTs_NewEnumDISPID_SpeechObjectTokenCategoryDISPID_SOTCIdDISPID_SOTCDefaultDISPID_SOTCSetIdDISPID_SOTCGetDataKeyDISPID_SOTCEnumerateTokensSpeechAudioFormatTypeSAFTDefaultSAFTNoAssignedFormatSAFTTextSAFTNonStandardFormatSAFTExtendedAudioFormatSAFT8kHz8BitMonoSAFT8kHz8BitStereoSAFT8kHz16BitMonoSAFT8kHz16BitStereoSAFT11kHz8BitMonoSAFT11kHz8BitStereoSAFT11kHz16BitMonoSAFT11kHz16BitStereoSAFT12kHz8BitMonoSAFT12kHz8BitStereoSAFT12kHz16BitMonoSAFT12kHz16BitStereoSAFT16kHz8BitMonoSAFT16kHz8BitStereoSAFT16kHz16BitMonoSAFT16kHz16BitStereoSAFT22kHz8BitMonoSAFT22kHz8BitStereoSAFT22kHz16BitMonoSAFT22kHz16BitStereoSAFT24kHz8BitMonoSAFT24kHz8BitStereoSAFT24kHz16BitMonoSAFT24kHz16BitStereoSAFT32kHz8BitMonoSAFT32kHz8BitStereoSAFT32kHz16BitMonoSAFT32kHz16BitStereoSAFT44kHz8BitMonoSAFT44kHz8BitStereoSAFT44kHz16BitMonoSAFT44kHz16BitStereoSAFT48kHz8BitMonoSAFT48kHz8BitStereoSAFT48kHz16BitMonoSAFT48kHz16BitStereoSAFTTrueSpeech_8kHz1BitMonoSAFTCCITT_ALaw_8kHzMonoSAFTCCITT_ALaw_8kHzStereoSAFTCCITT_ALaw_11kHzMonoSAFTCCITT_ALaw_11kHzStereoSAFTCCITT_ALaw_22kHzMonoSAFTCCITT_ALaw_22kHzStereoSAFTCCITT_ALaw_44kHzMonoSAFTCCITT_ALaw_44kHzStereoSAFTCCITT_uLaw_8kHzMonoSAFTCCITT_uLaw_8kHzStereoSAFTCCITT_uLaw_11kHzMonoSAFTCCITT_uLaw_11kHzStereoSAFTCCITT_uLaw_22kHzMonoSAFTCCITT_uLaw_22kHzStereoSAFTCCITT_uLaw_44kHzMonoSAFTCCITT_uLaw_44kHzStereoSAFTADPCM_8kHzMonoSAFTADPCM_8kHzStereoSAFTADPCM_11kHzMonoSAFTADPCM_11kHzStereoSAFTADPCM_22kHzMonoSAFTADPCM_22kHzStereoSAFTADPCM_44kHzMonoSAFTADPCM_44kHzStereoSAFTGSM610_8kHzMonoSAFTGSM610_11kHzMonoSAFTGSM610_22kHzMonoSAFTGSM610_44kHzMonoDISPID_SpeechAudioFormatDISPID_SAFTypeDISPID_SAFGuidDISPID_SAFGetWaveFormatExDISPID_SAFSetWaveFormatExDISPID_SpeechBaseStreamDISPID_SBSFormatDISPID_SBSReadDISPID_SBSWriteDISPID_SBSSeekSpeechStreamSeekPositionTypeSSSPTRelativeToStartSSSPTRelativeToCurrentPositionSSSPTRelativeToEndDISPID_SpeechAudioDISPID_SAStatusDISPID_SABufferInfoDISPID_SADefaultFormatDISPID_SAVolumeDISPID_SABufferNotifySizeDISPID_SAEventHandleDISPID_SASetStateSpeechAudioStateSASClosedSASStopSASPauseSASRunDISPID_SpeechMMSysAudioDISPID_SMSADeviceIdDISPID_SMSALineIdDISPID_SMSAMMHandleDISPID_SpeechFileStreamDISPID_SFSOpenDISPID_SFSCloseSpeechStreamFileModeSSFMOpenForReadSSFMOpenReadWriteSSFMCreateSSFMCreateForWriteDISPID_SpeechCustomStreamDISPID_SCSBaseStreamDISPID_SpeechMemoryStreamDISPID_SMSSetDataDISPID_SMSGetDataDISPID_SpeechAudioStatusDISPID_SASFreeBufferSpaceDISPID_SASNonBlockingIODISPID_SASStateDISPID_SASCurrentSeekPositionDISPID_SASCurrentDevicePositionDISPID_SpeechAudioBufferInfoDISPID_SABIMinNotificationDISPID_SABIBufferSizeDISPID_SABIEventBiasDISPID_SpeechWaveFormatExDISPID_SWFEFormatTagDISPID_SWFEChannelsDISPID_SWFESamplesPerSecDISPID_SWFEAvgBytesPerSecDISPID_SWFEBlockAlignDISPID_SWFEBitsPerSampleDISPID_SWFEExtraDataDISPID_SpeechVoiceDISPID_SVStatusDISPID_SVVoiceDISPID_SVAudioOutputDISPID_SVAudioOutputStreamDISPID_SVRateDISPID_SVVolumeDISPID_SVAllowAudioOuputFormatChangesOnNextSetDISPID_SVEventInterestsDISPID_SVPriorityDISPID_SVAlertBoundaryDISPID_SVSyncronousSpeakTimeoutDISPID_SVSpeakDISPID_SVSpeakStreamDISPID_SVPauseDISPID_SVResumeDISPID_SVSkipDISPID_SVGetVoicesDISPID_SVGetAudioOutputsDISPID_SVWaitUntilDoneDISPID_SVSpeakCompleteEventDISPID_SVIsUISupportedDISPID_SVDisplayUISpeechVoicePrioritySVPNormalSVPAlertSVPOverSpeechVoiceSpeakFlagsSVSFDefaultSVSFlagsAsyncSVSFPurgeBeforeSpeakSVSFIsFilenameSVSFIsXMLSVSFIsNotXMLSVSFPersistXMLSVSFNLPSpeakPuncSVSFParseSapiSVSFParseSsmlSVSFParseAutodetectSVSFNLPMaskSVSFParseMaskSVSFVoiceMaskSVSFUnusedFlagsSpeechVoiceEventsSVEStartInputStreamSVEEndInputStreamSVEVoiceChangeSVEBookmarkSVEWordBoundarySVEPhonemeSVESentenceBoundarySVEVisemeSVEAudioLevelSVEPrivateSVEAllEventsDISPID_SpeechVoiceStatusDISPID_SVSCurrentStreamNumberDISPID_SVSLastStreamNumberQueuedDISPID_SVSLastResultDISPID_SVSRunningStateDISPID_SVSInputWordPositionDISPID_SVSInputWordLengthDISPID_SVSInputSentencePositionDISPID_SVSInputSentenceLengthDISPID_SVSLastBookmarkDISPID_SVSLastBookmarkIdDISPID_SVSPhonemeIdDISPID_SVSVisemeIdSpeechRunStateSRSEDoneSRSEIsSpeakingSpeechVisemeTypeSVP_0SVP_1SVP_2SVP_3SVP_4SVP_5SVP_6SVP_7SVP_8SVP_9SVP_10SVP_11SVP_12SVP_13SVP_14SVP_15SVP_16SVP_17SVP_18SVP_19SVP_20SVP_21SpeechVisemeFeatureSVF_NoneSVF_StressedSVF_EmphasisDISPID_SpeechVoiceEventDISPID_SVEStreamStartDISPID_SVEStreamEndDISPID_SVEVoiceChangeDISPID_SVEBookmarkDISPID_SVEWordDISPID_SVEPhonemeDISPID_SVESentenceBoundaryDISPID_SVEVisemeDISPID_SVEAudioLevelDISPID_SVEEnginePrivateDISPID_SpeechRecognizerDISPID_SRRecognizerDISPID_SRAllowAudioInputFormatChangesOnNextSetDISPID_SRAudioInputDISPID_SRAudioInputStreamDISPID_SRIsSharedDISPID_SRStateDISPID_SRStatusDISPID_SRProfileDISPID_SREmulateRecognitionDISPID_SRCreateRecoContextDISPID_SRGetFormatDISPID_SRSetPropertyNumberDISPID_SRGetPropertyNumberDISPID_SRSetPropertyStringDISPID_SRGetPropertyStringDISPID_SRIsUISupportedDISPID_SRDisplayUIDISPID_SRGetRecognizersDISPID_SVGetAudioInputsDISPID_SVGetProfilesSpeechRecognizerStateSRSInactiveSRSActiveSRSActiveAlwaysSRSInactiveWithPurgeSpeechDisplayAttributesSDA_No_Trailing_SpaceSDA_One_Trailing_SpaceSDA_Two_Trailing_SpacesSDA_Consume_Leading_SpacesSpeechFormatTypeSFTInputSFTSREngineSpeechEmulationCompareFlagsSECFIgnoreCaseSECFIgnoreKanaTypeSECFIgnoreWidthSECFNoSpecialCharsSECFEmulateResultSECFDefaultDISPID_SpeechRecognizerStatusDISPID_SRSAudioStatusDISPID_SRSCurrentStreamPositionDISPID_SRSCurrentStreamNumberDISPID_SRSNumberOfActiveRulesDISPID_SRSClsidEngineDISPID_SRSSupportedLanguagesDISPID_SpeechRecoContextDISPID_SRCRecognizerDISPID_SRCAudioInInterferenceStatusDISPID_SRCRequestedUITypeDISPID_SRCVoiceDISPID_SRAllowVoiceFormatMatchingOnNextSetDISPID_SRCVoicePurgeEventDISPID_SRCEventInterestsDISPID_SRCCmdMaxAlternatesDISPID_SRCStateDISPID_SRCRetainedAudioDISPID_SRCRetainedAudioFormatDISPID_SRCPauseDISPID_SRCResumeDISPID_SRCCreateGrammarDISPID_SRCCreateResultFromMemoryDISPID_SRCBookmarkDISPID_SRCSetAdaptationDataSpeechRetainedAudioOptionsSRAONoneSRAORetainAudioSpeechBookmarkOptionsSBONoneSBOPauseSpeechInterferenceSINoneSINoiseSINoSignalSITooLoudSITooQuietSITooFastSITooSlowSpeechRecoEventsSREStreamEndSRESoundStartSRESoundEndSREPhraseStartSRERecognitionSREHypothesisSREBookmarkSREPropertyNumChangeSREPropertyStringChangeSREFalseRecognitionSREInterferenceSRERequestUISREStateChangeSREAdaptationSREStreamStartSRERecoOtherContextSREAudioLevelSREPrivateSREAllEventsSpeechRecoContextStateSRCS_DisabledSRCS_EnabledDISPIDSPRGDISPID_SRGIdDISPID_SRGRecoContextDISPID_SRGStateDISPID_SRGRulesDISPID_SRGResetDISPID_SRGCommitDISPID_SRGCmdLoadFromFileDISPID_SRGCmdLoadFromObjectDISPID_SRGCmdLoadFromResourceDISPID_SRGCmdLoadFromMemoryDISPID_SRGCmdLoadFromProprietaryGrammarDISPID_SRGCmdSetRuleStateDISPID_SRGCmdSetRuleIdStateDISPID_SRGDictationLoadDISPID_SRGDictationUnloadDISPID_SRGDictationSetStateDISPID_SRGSetWordSequenceDataDISPID_SRGSetTextSelectionDISPID_SRGIsPronounceableSpeechLoadOptionSLOStaticSLODynamicSpeechWordPronounceableSWPUnknownWordUnpronounceableSWPUnknownWordPronounceableSWPKnownWordPronounceableSpeechGrammarStateSGSEnabledSGSDisabledSGSExclusiveSpeechRuleStateSGDSInactiveSGDSActiveSGDSActiveWithAutoPauseSGDSActiveUserDelimitedSpeechRuleAttributesSRATopLevelSRADefaultToActiveSRAExportSRAImportSRAInterpreterSRADynamicSRARootSpeechGrammarWordTypeSGDisplaySGLexicalSGPronounciationSGLexicalNoSpecialCharsDISPID_SpeechRecoContextEventsDISPID_SRCEStartStreamDISPID_SRCEEndStreamDISPID_SRCEBookmarkDISPID_SRCESoundStartDISPID_SRCESoundEndDISPID_SRCEPhraseStartDISPID_SRCERecognitionDISPID_SRCEHypothesisDISPID_SRCEPropertyNumberChangeDISPID_SRCEPropertyStringChangeDISPID_SRCEFalseRecognitionDISPID_SRCEInterferenceDISPID_SRCERequestUIDISPID_SRCERecognizerStateChangeDISPID_SRCEAdaptationDISPID_SRCERecognitionForOtherContextDISPID_SRCEAudioLevelDISPID_SRCEEnginePrivateSpeechRecognitionTypeSRTStandardSRTAutopauseSRTEmulatedSRTSMLTimeoutSRTExtendableParseSRTReSentDISPID_SpeechGrammarRuleDISPID_SGRAttributesDISPID_SGRInitialStateDISPID_SGRNameDISPID_SGRIdDISPID_SGRClearDISPID_SGRAddResourceDISPID_SGRAddStateDISPID_SpeechGrammarRulesDISPID_SGRsCountDISPID_SGRsDynamicDISPID_SGRsAddDISPID_SGRsCommitDISPID_SGRsCommitAndSaveDISPID_SGRsFindRuleDISPID_SGRsItemDISPID_SGRs_NewEnumDISPID_SpeechGrammarRuleStateDISPID_SGRSRuleDISPID_SGRSTransitionsDISPID_SGRSAddWordTransitionDISPID_SGRSAddRuleTransitionDISPID_SGRSAddSpecialTransitionSpeechSpecialTransitionTypeSSTTWildcardSSTTDictationSSTTTextBufferDISPID_SpeechGrammarRuleStateTransitionsDISPID_SGRSTsCountDISPID_SGRSTsItemDISPID_SGRSTs_NewEnumDISPID_SpeechGrammarRuleStateTransitionDISPID_SGRSTTypeDISPID_SGRSTTextDISPID_SGRSTRuleDISPID_SGRSTWeightDISPID_SGRSTPropertyNameDISPID_SGRSTPropertyIdDISPID_SGRSTPropertyValueDISPID_SGRSTNextStateSpeechGrammarRuleStateTransitionTypeSGRSTTEpsilonSGRSTTWordSGRSTTRuleSGRSTTDictationSGRSTTWildcardSGRSTTTextBufferDISPIDSPTSIDISPIDSPTSI_ActiveOffsetDISPIDSPTSI_ActiveLengthDISPIDSPTSI_SelectionOffsetDISPIDSPTSI_SelectionLengthDISPID_SpeechRecoResultDISPID_SRRRecoContextDISPID_SRRTimesDISPID_SRRAudioFormatDISPID_SRRPhraseInfoDISPID_SRRAlternatesDISPID_SRRAudioDISPID_SRRSpeakAudioDISPID_SRRSaveToMemoryDISPID_SRRDiscardResultInfoSpeechDiscardTypeSDTPropertySDTReplacementSDTRuleSDTDisplayTextSDTLexicalFormSDTPronunciationSDTAudioSDTAlternatesSDTAllDISPID_SpeechXMLRecoResultDISPID_SRRGetXMLResultDISPID_SRRGetXMLErrorInfoDISPID_SpeechRecoResult2DISPID_SRRSetTextFeedbackDISPID_SpeechPhraseBuilderDISPID_SPPBRestorePhraseFromMemoryDISPID_SpeechRecoResultTimesDISPID_SRRTStreamTimeDISPID_SRRTLengthDISPID_SRRTTickCountDISPID_SRRTOffsetFromStartDISPID_SpeechPhraseAlternateDISPID_SPARecoResultDISPID_SPAStartElementInResultDISPID_SPANumberOfElementsInResultDISPID_SPAPhraseInfoDISPID_SPACommitDISPID_SpeechPhraseAlternatesDISPID_SPAsCountDISPID_SPAsItemDISPID_SPAs_NewEnumDISPID_SpeechPhraseInfoDISPID_SPILanguageIdDISPID_SPIGrammarIdDISPID_SPIStartTimeDISPID_SPIAudioStreamPositionDISPID_SPIAudioSizeBytesDISPID_SPIRetainedSizeBytesDISPID_SPIAudioSizeTimeDISPID_SPIRuleDISPID_SPIPropertiesDISPID_SPIElementsDISPID_SPIReplacementsDISPID_SPIEngineIdDISPID_SPIEnginePrivateDataDISPID_SPISaveToMemoryDISPID_SPIGetTextDISPID_SPIGetDisplayAttributesDISPID_SpeechPhraseElementDISPID_SPEAudioTimeOffsetDISPID_SPEAudioSizeTimeDISPID_SPEAudioStreamOffsetDISPID_SPEAudioSizeBytesDISPID_SPERetainedStreamOffsetDISPID_SPERetainedSizeBytesDISPID_SPEDisplayTextDISPID_SPELexicalFormDISPID_SPEPronunciationDISPID_SPEDisplayAttributesDISPID_SPERequiredConfidenceDISPID_SPEActualConfidenceDISPID_SPEEngineConfidenceSpeechEngineConfidenceSECLowConfidenceSECNormalConfidenceSECHighConfidenceDISPID_SpeechPhraseElementsDISPID_SPEsCountDISPID_SPEsItemDISPID_SPEs_NewEnumDISPID_SpeechPhraseReplacementDISPID_SPRDisplayAttributesDISPID_SPRTextDISPID_SPRFirstElementDISPID_SPRNumberOfElementsDISPID_SpeechPhraseReplacementsDISPID_SPRsCountDISPID_SPRsItemDISPID_SPRs_NewEnumDISPID_SpeechPhrasePropertyDISPID_SPPNameDISPID_SPPIdDISPID_SPPValueDISPID_SPPFirstElementDISPID_SPPNumberOfElementsDISPID_SPPEngineConfidenceDISPID_SPPConfidenceDISPID_SPPParentDISPID_SPPChildrenDISPID_SpeechPhrasePropertiesDISPID_SPPsCountDISPID_SPPsItemDISPID_SPPs_NewEnumDISPID_SpeechPhraseRuleDISPID_SPRuleNameDISPID_SPRuleIdDISPID_SPRuleFirstElementDISPID_SPRuleNumberOfElementsDISPID_SPRuleParentDISPID_SPRuleChildrenDISPID_SPRuleConfidenceDISPID_SPRuleEngineConfidenceDISPID_SpeechPhraseRulesDISPID_SPRulesCountDISPID_SPRulesItemDISPID_SPRules_NewEnumDISPID_SpeechLexiconDISPID_SLGenerationIdDISPID_SLGetWordsDISPID_SLAddPronunciationDISPID_SLAddPronunciationByPhoneIdsDISPID_SLRemovePronunciationDISPID_SLRemovePronunciationByPhoneIdsDISPID_SLGetPronunciationsDISPID_SLGetGenerationChangeSpeechLexiconTypeSLTUserSLTAppSpeechPartOfSpeechSPSNotOverridenSPSUnknownSPSNounSPSVerbSPSModifierSPSFunctionSPSInterjectionSPSLMASPSSuppressWordDISPID_SpeechLexiconWordsDISPID_SLWsCountDISPID_SLWsItemDISPID_SLWs_NewEnumSpeechWordTypeSWTAddedSWTDeletedDISPID_SpeechLexiconWordDISPID_SLWLangIdDISPID_SLWTypeDISPID_SLWWordDISPID_SLWPronunciationsDISPID_SpeechLexiconPronsDISPID_SLPsCountDISPID_SLPsItemDISPID_SLPs_NewEnumDISPID_SpeechLexiconPronunciationDISPID_SLPTypeDISPID_SLPLangIdDISPID_SLPPartOfSpeechDISPID_SLPPhoneIdsDISPID_SLPSymbolicDISPID_SpeechPhoneConverterDISPID_SPCLangIdDISPID_SPCPhoneToIdDISPID_SPCIdToPhoneLIBID_SpeechLibISpeechDataKeyISpeechDataKeyVtblISpeechObjectTokenISpeechObjectTokenVtblISpeechObjectTokensISpeechObjectTokensVtblISpeechObjectTokenCategoryISpeechObjectTokenCategoryVtblISpeechAudioBufferInfoISpeechAudioBufferInfoVtblISpeechAudioStatusISpeechAudioStatusVtblISpeechAudioFormatISpeechAudioFormatVtblISpeechWaveFormatExISpeechWaveFormatExVtblISpeechBaseStreamISpeechBaseStreamVtblISpeechFileStreamISpeechFileStreamVtblISpeechMemoryStreamISpeechMemoryStreamVtblISpeechCustomStreamISpeechCustomStreamVtblISpeechAudioISpeechAudioVtblISpeechMMSysAudioISpeechMMSysAudioVtblISpeechVoiceISpeechVoiceVtblISpeechVoiceStatusISpeechVoiceStatusVtbl_ISpeechVoiceEvents_ISpeechVoiceEventsVtblISpeechRecognizerISpeechRecognizerVtblISpeechRecognizerStatusISpeechRecognizerStatusVtblISpeechRecoContextISpeechRecoContextVtblISpeechRecoGrammarISpeechRecoGrammarVtbl_ISpeechRecoContextEvents_ISpeechRecoContextEventsVtblISpeechGrammarRuleISpeechGrammarRuleVtblISpeechGrammarRulesISpeechGrammarRulesVtblISpeechGrammarRuleStateISpeechGrammarRuleStateVtblISpeechGrammarRuleStateTransitionISpeechGrammarRuleStateTransitionVtblISpeechGrammarRuleStateTransitionsISpeechGrammarRuleStateTransitionsVtblISpeechTextSelectionInformationISpeechTextSelectionInformationVtblISpeechRecoResultISpeechRecoResultVtblISpeechRecoResult2ISpeechRecoResult2VtblISpeechRecoResultTimesISpeechRecoResultTimesVtblISpeechPhraseAlternateISpeechPhraseAlternateVtblISpeechPhraseAlternatesISpeechPhraseAlternatesVtblISpeechPhraseInfoISpeechPhraseInfoVtblISpeechPhraseElementISpeechPhraseElementVtblISpeechPhraseElementsISpeechPhraseElementsVtblISpeechPhraseReplacementISpeechPhraseReplacementVtblISpeechPhraseReplacementsISpeechPhraseReplacementsVtblISpeechPhrasePropertyISpeechPhrasePropertyVtblISpeechPhrasePropertiesISpeechPhrasePropertiesVtblISpeechPhraseRuleISpeechPhraseRuleVtblISpeechPhraseRulesISpeechPhraseRulesVtblISpeechLexiconISpeechLexiconVtblISpeechLexiconWordsISpeechLexiconWordsVtblISpeechLexiconWordISpeechLexiconWordVtblISpeechLexiconPronunciationsISpeechLexiconPronunciationsVtblISpeechLexiconPronunciationISpeechLexiconPronunciationVtblSpeech_Default_WeightSpeech_Max_Word_LengthSpeech_Max_Pron_LengthSpeech_StreamPos_AsapSpeech_StreamPos_RealTimeSpeechAllElementsISpeechXMLRecoResultISpeechXMLRecoResultVtblISpeechRecoResultDispatchISpeechRecoResultDispatchVtblISpeechPhraseInfoBuilderISpeechPhraseInfoBuilderVtblISpeechPhoneConverterISpeechPhoneConverterVtblCLSID_SpNotifyTranslatorCLSID_SpObjectTokenCategoryCLSID_SpObjectTokenCLSID_SpResourceManagerCLSID_SpStreamFormatConverterCLSID_SpMMAudioEnumCLSID_SpMMAudioInCLSID_SpMMAudioOutCLSID_SpStreamCLSID_SpVoiceCLSID_SpSharedRecoContextCLSID_SpInprocRecognizerCLSID_SpSharedRecognizerCLSID_SpLexiconCLSID_SpUnCompressedLexiconCLSID_SpCompressedLexiconCLSID_SpShortcutCLSID_SpPhoneConverterCLSID_SpPhoneticAlphabetConverterCLSID_SpNullPhoneConverterCLSID_SpTextSelectionInformationCLSID_SpPhraseInfoBuilderCLSID_SpAudioFormatCLSID_SpWaveFormatExCLSID_SpInProcRecoContextCLSID_SpCustomStreamCLSID_SpFileStreamCLSID_SpMemoryStream//! SAPI 5.4 definitionsIStreamVtblSTREAM_SEEK_CURSTREAM_SEEK_ENDSTREAM_SEEK_SETIServiceProviderVtblSPCURRENT_USER_SHORTCUT_TOKEN_IDSP_STREAMPOS_ASAPSP_STREAMPOS_REALTIMESPRULETRANS_TEXTBUFFERSPRULETRANS_WILDCARDSPRULETRANS_DICTATION//! SAPI 5.1 definitionsIInternetSecurityManagerSPEI_RESERVED4// TODO: pub const SP_SPPHRASESIZE_500: usize = mem::size_of::<SPPHRASE_50>();SPRS_ACTIVE_USER_DELIMITEDSPGRAMMARWORDTYPESPWT_DISPLAYSPWT_LEXICALSPWT_PRONUNCIATION// TODO: Unknown purpose and type//! SAPI 5.3 definitionsSPRECOEXTENSIONSPALTERNATESCLSIDSR_LOCALIZED_DESCRIPTIONISpTokenUIISpTokenUIVtblISpObjectTokenEnumBuilderISpObjectTokenEnumBuilderVtblSPWORDHANDLESPRULEHANDLESPGRAMMARHANDLESPRECOCONTEXTHANDLESPPHRASERULEHANDLESPPHRASEPROPERTYHANDLESPTRANSITIONIDISpErrorLogISpErrorLogVtblISpGrammarCompilerISpGrammarCompilerVtblISpGramCompBackendISpGramCompBackendVtblISpITNProcessorISpITNProcessorVtblISpPhraseBuilderISpPhraseBuilderVtblISpTaskISpThreadTaskISpThreadControlISpThreadControlVtblSPTMTHREADINFOISpTaskManagerISpTaskManagerVtblSPVSKIPTYPESPVST_SENTENCESPVESACTIONSSPVES_CONTINUESPVES_ABORTSPVES_SKIPSPVES_RATESPVES_VOLUMEISpTTSEngineSiteISpTTSEngineSiteVtblSPVTEXTFRAGISpTTSEngineISpTTSEngineVtblSPWORDENTRYSPRULEENTRYSPTRANSITIONTYPESPTRANSEPSILONSPTRANSWORDSPTRANSRULESPTRANSTEXTBUFSPTRANSWILDCARDSPTRANSDICTATIONSPTRANSITIONENTRYSPTRANSITIONPROPERTYSPSTATEINFOSPPATHENTRYISpCFGInterpreterSiteISpCFGInterpreterSiteVtblISpCFGInterpreterISpCFGInterpreterVtblSPCFGNOTIFYSPCFGN_ADDSPCFGN_REMOVESPCFGN_INVALIDATESPCFGN_ACTIVATESPCFGN_DEACTIVATESPRESULTTYPESPRT_CFGSPRT_SLMSPRT_PROPRIETARYSPRT_FALSE_RECOGNITIONSPRT_TYPE_MASKSPRT_EMULATEDSPRT_EXTENDABLE_PARSESPPHRASEALTSPRECORESULTINFOSPWORDINFOOPTSPWIO_NONESPWIO_WANT_TEXTSPRULEINFOOPTSPRIO_NONESPPARSEINFOISpSREngineSiteISpSREngineSiteVtblSPPROPSRCSPPROPSRC_RECO_INSTSPPROPSRC_RECO_CTXSPPROPSRC_RECO_GRAMMARISpSREngineISpSREngineVtblSPPHRASEALTREQUEST_ISpPrivateEngineCall_ISpPrivateEngineCallVtblLIBID_SpeechDDKLibCLSID_SpDataKeyCLSID_SpObjectTokenEnumCLSID_SpPhraseBuilderCLSID_SpITNProcessorCLSID_SpGrammarCompilerCLSID_SpW3CGrammarCompilerCLSID_SpGramCompBackendHCERTSTOREPCERT_NAME_BLOBUNISP_NAMESSL2SP_NAMESSL3SP_NAMETLS1SP_NAMEPCT1SP_NAMESCHANNEL_NAMEUNISP_RPC_IDPSecPkgContext_RemoteCredentialInfoSecPkgContext_RemoteCredentialInfoSecPkgContext_RemoteCredenitalInfoPSecPkgContext_RemoteCredenitalInfoRCRED_STATUS_NOCREDRCRED_CRED_EXISTSRCRED_STATUS_UNKNOWN_ISSUERPSecPkgContext_LocalCredentialInfoSecPkgContext_LocalCredentialInfoSecPkgContext_LocalCredenitalInfoPSecPkgContext_LocalCredenitalInfoLCRED_STATUS_NOCREDLCRED_CRED_EXISTSLCRED_STATUS_UNKNOWN_ISSUERPSecPkgContext_ClientCertPolicyResultSecPkgContext_ClientCertPolicyResultPSecPkgContext_IssuerListInfoExSecPkgContext_IssuerListInfoExPSecPkgContext_ConnectionInfoSecPkgContext_ConnectionInfoSZ_ALG_MAX_SIZESECPKGCONTEXT_CIPHERINFO_V1PSecPkgContext_CipherInfoSecPkgContext_CipherInfoPSecPkgContext_EapKeyBlockSecPkgContext_EapKeyBlockPSecPkgContext_MappedCredAttrSecPkgContext_MappedCredAttrSSL_SESSION_RECONNECTPSecPkgContext_SessionInfoSecPkgContext_SessionInfoPSecPkgContext_SessionAppDataSecPkgContext_SessionAppDataPSecPkgContext_EapPrfInfoSecPkgContext_EapPrfInfoPSecPkgContext_SupportedSignaturesSecPkgContext_SupportedSignaturesPSecPkgContext_CertificatesSecPkgContext_CertificatesPSecPkgContext_CertInfoSecPkgContext_CertInfoKERN_CONTEXT_CERT_INFO_V1PSecPkgContext_UiInfoSecPkgContext_UiInfoPSecPkgContext_EarlyStartSecPkgContext_EarlyStartENABLE_TLS_CLIENT_EARLY_STARTSCH_CRED_V1SCH_CRED_V2SCH_CRED_VERSIONSCH_CRED_V3SCHANNEL_CRED_VERSIONSCHANNEL_SECRET_TYPE_CAPISCHANNEL_SECRET_PRIVKEYSCH_CRED_X509_CERTCHAINSCH_CRED_X509_CAPISCH_CRED_CERT_CONTEXT_HMAPPERPSCHANNEL_CREDSCHANNEL_CREDSCH_CRED_FORMAT_CERT_CONTEXTSCH_CRED_FORMAT_CERT_HASHSCH_CRED_FORMAT_CERT_HASH_STORESCH_CRED_MAX_STORE_NAME_SIZESCH_CRED_MAX_SUPPORTED_ALGSSCH_CRED_MAX_SUPPORTED_CERTSPSCHANNEL_CERT_HASHSCHANNEL_CERT_HASHPSCHANNEL_CERT_HASH_STORESCHANNEL_CERT_HASH_STORESCH_MACHINE_CERT_HASHSCH_CRED_NO_SYSTEM_MAPPERSCH_CRED_NO_SERVERNAME_CHECKSCH_CRED_MANUAL_CRED_VALIDATIONSCH_CRED_NO_DEFAULT_CREDSSCH_CRED_AUTO_CRED_VALIDATIONSCH_CRED_USE_DEFAULT_CREDSSCH_CRED_DISABLE_RECONNECTSSCH_CRED_REVOCATION_CHECK_END_CERTSCH_CRED_REVOCATION_CHECK_CHAINSCH_CRED_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOTSCH_CRED_IGNORE_NO_REVOCATION_CHECKSCH_CRED_IGNORE_REVOCATION_OFFLINESCH_CRED_RESTRICTED_ROOTSSCH_CRED_REVOCATION_CHECK_CACHE_ONLYSCH_CRED_CACHE_ONLY_URL_RETRIEVALSCH_CRED_MEMORY_STORE_CERTSCH_CRED_CACHE_ONLY_URL_RETRIEVAL_ON_CREATESCH_SEND_ROOT_CERTSCH_CRED_SNI_CREDENTIALSCH_CRED_SNI_ENABLE_OCSPSCH_SEND_AUX_RECORDSCH_USE_STRONG_CRYPTOSCHANNEL_RENEGOTIATESCHANNEL_SHUTDOWNSCHANNEL_ALERTSCHANNEL_SESSIONTLS1_ALERT_WARNINGTLS1_ALERT_FATALTLS1_ALERT_CLOSE_NOTIFYTLS1_ALERT_UNEXPECTED_MESSAGETLS1_ALERT_BAD_RECORD_MACTLS1_ALERT_DECRYPTION_FAILEDTLS1_ALERT_RECORD_OVERFLOWTLS1_ALERT_DECOMPRESSION_FAILTLS1_ALERT_HANDSHAKE_FAILURETLS1_ALERT_BAD_CERTIFICATETLS1_ALERT_UNSUPPORTED_CERTTLS1_ALERT_CERTIFICATE_REVOKEDTLS1_ALERT_CERTIFICATE_EXPIREDTLS1_ALERT_CERTIFICATE_UNKNOWNTLS1_ALERT_ILLEGAL_PARAMETERTLS1_ALERT_UNKNOWN_CATLS1_ALERT_ACCESS_DENIEDTLS1_ALERT_DECODE_ERRORTLS1_ALERT_DECRYPT_ERRORTLS1_ALERT_EXPORT_RESTRICTIONTLS1_ALERT_PROTOCOL_VERSIONTLS1_ALERT_INSUFFIENT_SECURITYTLS1_ALERT_INTERNAL_ERRORTLS1_ALERT_USER_CANCELEDTLS1_ALERT_NO_RENEGOTIATIONTLS1_ALERT_UNSUPPORTED_EXTTLS1_ALERT_NO_APP_PROTOCOLSSL_SESSION_ENABLE_RECONNECTSSSL_SESSION_DISABLE_RECONNECTSPSCHANNEL_CLIENT_SIGNATURESCHANNEL_CLIENT_SIGNATURESP_PROT_PCT1_SERVERSP_PROT_PCT1_CLIENTSP_PROT_PCT1SP_PROT_SSL2_SERVERSP_PROT_SSL2_CLIENTSP_PROT_SSL2SP_PROT_SSL3_SERVERSP_PROT_SSL3_CLIENTSP_PROT_SSL3SP_PROT_TLS1_SERVERSP_PROT_TLS1_CLIENTSP_PROT_TLS1SP_PROT_SSL3TLS1_CLIENTSSP_PROT_SSL3TLS1_SERVERSSP_PROT_SSL3TLS1SP_PROT_UNI_SERVERSP_PROT_UNI_CLIENTSP_PROT_UNISP_PROT_ALLSP_PROT_NONESP_PROT_CLIENTSSP_PROT_SERVERSSP_PROT_TLS1_0_SERVERSP_PROT_TLS1_0_CLIENTSP_PROT_TLS1_0SP_PROT_TLS1_1_SERVERSP_PROT_TLS1_1_CLIENTSP_PROT_TLS1_1SP_PROT_TLS1_2_SERVERSP_PROT_TLS1_2_CLIENTSP_PROT_TLS1_2SP_PROT_DTLS_SERVERSP_PROT_DTLS_CLIENTSP_PROT_DTLSSP_PROT_DTLS1_0_SERVERSP_PROT_DTLS1_0_CLIENTSP_PROT_DTLS1_0SP_PROT_DTLS1_X_SERVERSP_PROT_DTLS1_X_CLIENTSP_PROT_DTLS1_XSP_PROT_TLS1_1PLUS_SERVERSP_PROT_TLS1_1PLUS_CLIENTSP_PROT_TLS1_1PLUSSP_PROT_TLS1_X_SERVERSP_PROT_TLS1_X_CLIENTSP_PROT_TLS1_XSP_PROT_SSL3TLS1_X_CLIENTSSP_PROT_SSL3TLS1_X_SERVERSSP_PROT_SSL3TLS1_XSP_PROT_X_CLIENTSSP_PROT_X_SERVERSSSL_CRACK_CERTIFICATE_NAMESSL_FREE_CERTIFICATE_NAME//! Public Definitions for SCHANNEL Security ProviderGetAppContainerNamedObjectPathACL_INFORMATION_CLASSAUDIT_EVENT_TYPEPCLAIM_SECURITY_ATTRIBUTES_INFORMATIONPLUID_AND_ATTRIBUTESPOBJECT_TYPE_LISTPSECURITY_DESCRIPTOR_CONTROLPSID_AND_ATTRIBUTESPSID_IDENTIFIER_AUTHORITYSECURITY_DESCRIPTOR_CONTROLSECURITY_IMPERSONATION_LEVELTOKEN_INFORMATION_CLASSTOKEN_TYPEWELL_KNOWN_SID_TYPEAccessCheckAccessCheckAndAuditAlarmWAccessCheckByTypeAccessCheckByTypeResultListAccessCheckByTypeAndAuditAlarmWAccessCheckByTypeResultListAndAuditAlarmWAccessCheckByTypeResultListAndAuditAlarmByHandleWAddAccessAllowedAceAddAccessAllowedAceExAddAccessAllowedObjectAceAddAccessDeniedAceAddAccessDeniedAceExAddAccessDeniedObjectAceAddAceAddAuditAccessAceAddAuditAccessAceExAddAuditAccessObjectAceAddMandatoryAceAddResourceAttributeAceAddScopedPolicyIDAceAdjustTokenGroupsAllocateAndInitializeSidAllocateLocallyUniqueIdAreAllAccessesGrantedAreAnyAccessesGrantedCheckTokenMembershipCheckTokenCapabilityGetAppContainerAceCheckTokenMembershipExConvertToAutoInheritPrivateObjectSecurityCreatePrivateObjectSecurityCreatePrivateObjectSecurityExCreatePrivateObjectSecurityWithMultipleInheritanceCreateRestrictedTokenCreateWellKnownSidEqualDomainSidDeleteAceDestroyPrivateObjectSecurityDuplicateTokenDuplicateTokenExEqualPrefixSidEqualSidFindFirstFreeAceFreeSidGetAceGetAclInformationGetFileSecurityWGetKernelObjectSecurityGetPrivateObjectSecurityGetSecurityDescriptorControlGetSecurityDescriptorDaclGetSecurityDescriptorGroupGetSecurityDescriptorLengthGetSecurityDescriptorOwnerGetSecurityDescriptorRMControlGetSecurityDescriptorSaclGetSidIdentifierAuthorityGetSidLengthRequiredGetSidSubAuthorityGetSidSubAuthorityCountGetWindowsAccountDomainSidImpersonateAnonymousTokenImpersonateLoggedOnUserImpersonateSelfInitializeAclInitializeSecurityDescriptorInitializeSidIsTokenRestrictedIsValidAclIsValidSecurityDescriptorIsWellKnownSidMakeAbsoluteSDMakeSelfRelativeSDMapGenericMaskObjectCloseAuditAlarmWObjectDeleteAuditAlarmWObjectOpenAuditAlarmWObjectPrivilegeAuditAlarmWPrivilegeCheckPrivilegedServiceAuditAlarmWQuerySecurityAccessMaskRevertToSelfSetAclInformationSetFileSecurityWSetKernelObjectSecuritySetPrivateObjectSecuritySetPrivateObjectSecurityExSetSecurityAccessMaskSetSecurityDescriptorControlSetSecurityDescriptorDaclSetSecurityDescriptorGroupSetSecurityDescriptorOwnerSetSecurityDescriptorRMControlSetSecurityDescriptorSaclSetTokenInformationSetCachedSigningLevelGetCachedSigningLevelCveEventWriteDeriveCapabilitySidsFromNameLPSERVICEPROVIDERSP_LOG_TOKENLINE_LENMAX_INF_STRING_LENGTHMAX_INF_SECTION_NAME_LENGTHMAX_TITLE_LENMAX_INSTRUCTION_LENMAX_LABEL_LENMAX_SERVICE_NAME_LENMAX_SUBTITLE_LENSP_MAX_MACHINENAME_LENGTHHINFPINFCONTEXTINFCONTEXTPSP_INF_INFORMATIONSP_INF_INFORMATIONPSP_ALTPLATFORM_INFO_V3SP_ALTPLATFORM_INFO_V3PSP_ALTPLATFORM_INFO_V2SP_ALTPLATFORM_INFO_V2PSP_ALTPLATFORM_INFO_V1SP_ALTPLATFORM_INFO_V1SP_ALTPLATFORM_INFOPSP_ALTPLATFORM_INFOSP_ALTPLATFORM_FLAGS_VERSION_RANGESP_ALTPLATFORM_FLAGS_SUITE_MASKPSP_ORIGINAL_FILE_INFO_ASP_ORIGINAL_FILE_INFO_APSP_ORIGINAL_FILE_INFO_WSP_ORIGINAL_FILE_INFO_WINF_STYLE_NONEINF_STYLE_OLDNTINF_STYLE_WIN4INF_STYLE_CACHE_ENABLEINF_STYLE_CACHE_DISABLEINF_STYLE_CACHE_IGNOREDIRID_ABSOLUTEDIRID_ABSOLUTE_16BITDIRID_NULLDIRID_SRCPATHDIRID_WINDOWSDIRID_SYSTEMDIRID_DRIVERSDIRID_IOSUBSYSDIRID_DRIVER_STOREDIRID_INFDIRID_HELPDIRID_FONTSDIRID_VIEWERSDIRID_COLORDIRID_APPSDIRID_SHAREDDIRID_BOOTDIRID_SYSTEM16DIRID_SPOOLDIRID_SPOOLDRIVERSDIRID_USERPROFILEDIRID_LOADERDIRID_PRINTPROCESSORDIRID_DEFAULTDIRID_COMMON_STARTMENUDIRID_COMMON_PROGRAMSDIRID_COMMON_STARTUPDIRID_COMMON_DESKTOPDIRECTORYDIRID_COMMON_FAVORITESDIRID_COMMON_APPDATADIRID_PROGRAM_FILESDIRID_SYSTEM_X86DIRID_PROGRAM_FILES_X86DIRID_PROGRAM_FILES_COMMONDIRID_PROGRAM_FILES_COMMONX86DIRID_COMMON_TEMPLATESDIRID_COMMON_DOCUMENTSDIRID_USERSPFILENOTIFY_STARTQUEUESPFILENOTIFY_ENDQUEUESPFILENOTIFY_STARTSUBQUEUESPFILENOTIFY_ENDSUBQUEUESPFILENOTIFY_STARTDELETESPFILENOTIFY_ENDDELETESPFILENOTIFY_DELETEERRORSPFILENOTIFY_STARTRENAMESPFILENOTIFY_ENDRENAMESPFILENOTIFY_RENAMEERRORSPFILENOTIFY_STARTCOPYSPFILENOTIFY_ENDCOPYSPFILENOTIFY_COPYERRORSPFILENOTIFY_NEEDMEDIASPFILENOTIFY_QUEUESCANSPFILENOTIFY_CABINETINFOSPFILENOTIFY_FILEINCABINETSPFILENOTIFY_NEEDNEWCABINETSPFILENOTIFY_FILEEXTRACTEDSPFILENOTIFY_FILEOPDELAYEDSPFILENOTIFY_STARTBACKUPSPFILENOTIFY_BACKUPERRORSPFILENOTIFY_ENDBACKUPSPFILENOTIFY_QUEUESCAN_EXSPFILENOTIFY_STARTREGISTRATIONSPFILENOTIFY_ENDREGISTRATIONSPFILENOTIFY_QUEUESCAN_SIGNERINFOSPFILENOTIFY_LANGMISMATCHSPFILENOTIFY_TARGETEXISTSSPFILENOTIFY_TARGETNEWERFILEOP_COPYFILEOP_RENAMEFILEOP_DELETEFILEOP_BACKUPFILEOP_ABORTFILEOP_DOITFILEOP_SKIPFILEOP_RETRYFILEOP_NEWPATHCOPYFLG_WARN_IF_SKIPCOPYFLG_NOSKIPCOPYFLG_NOVERSIONCHECKCOPYFLG_FORCE_FILE_IN_USECOPYFLG_NO_OVERWRITECOPYFLG_NO_VERSION_DIALOGCOPYFLG_OVERWRITE_OLDER_ONLYCOPYFLG_PROTECTED_WINDOWS_DRIVER_FILECOPYFLG_REPLACEONLYCOPYFLG_NODECOMPCOPYFLG_REPLACE_BOOT_FILECOPYFLG_NOPRUNECOPYFLG_IN_USE_TRY_RENAMEDELFLG_IN_USEDELFLG_IN_USE1PFILEPATHS_AFILEPATHS_APFILEPATHS_WFILEPATHS_WPFILEPATHS_SIGNERINFO_AFILEPATHS_SIGNERINFO_APFILEPATHS_SIGNERINFO_WFILEPATHS_SIGNERINFO_WPSOURCE_MEDIA_ASOURCE_MEDIA_APSOURCE_MEDIA_WSOURCE_MEDIA_WPCABINET_INFO_ACABINET_INFO_APCABINET_INFO_WCABINET_INFO_WPFILE_IN_CABINET_INFO_AFILE_IN_CABINET_INFO_APFILE_IN_CABINET_INFO_WFILE_IN_CABINET_INFO_WPSP_REGISTER_CONTROL_STATUSASP_REGISTER_CONTROL_STATUSAPSP_REGISTER_CONTROL_STATUSWSP_REGISTER_CONTROL_STATUSWSPREG_SUCCESSSPREG_LOADLIBRARYSPREG_GETPROCADDRSPREG_REGSVRSPREG_DLLINSTALLSPREG_TIMEOUTSPREG_UNKNOWNHSPFILEQPSP_FILE_COPY_PARAMS_ASP_FILE_COPY_PARAMS_APSP_FILE_COPY_PARAMS_WSP_FILE_COPY_PARAMS_WHDSKSPCHDEVINFOPSP_DEVINFO_DATASP_DEVINFO_DATAPSP_DEVICE_INTERFACE_DATASP_DEVICE_INTERFACE_DATASPINT_ACTIVESPINT_DEFAULTSPINT_REMOVEDSP_INTERFACE_DEVICE_DATAPSP_INTERFACE_DEVICE_DATASPID_ACTIVESPID_DEFAULTSPID_REMOVEDPSP_DEVICE_INTERFACE_DETAIL_DATA_ASP_DEVICE_INTERFACE_DETAIL_DATA_APSP_DEVICE_INTERFACE_DETAIL_DATA_WSP_DEVICE_INTERFACE_DETAIL_DATA_WPSP_DEVINFO_LIST_DETAIL_DATA_ASP_DEVINFO_LIST_DETAIL_DATA_APSP_DEVINFO_LIST_DETAIL_DATA_WSP_DEVINFO_LIST_DETAIL_DATA_WDIF_SELECTDEVICEDI_FUNCTIONDIF_INSTALLDEVICEDIF_ASSIGNRESOURCESDIF_PROPERTIESDIF_REMOVEDIF_FIRSTTIMESETUPDIF_FOUNDDEVICEDIF_SELECTCLASSDRIVERSDIF_VALIDATECLASSDRIVERSDIF_INSTALLCLASSDRIVERSDIF_CALCDISKSPACEDIF_DESTROYPRIVATEDATADIF_VALIDATEDRIVERDIF_DETECTDIF_INSTALLWIZARDDIF_DESTROYWIZARDDATADIF_PROPERTYCHANGEDIF_ENABLECLASSDIF_DETECTVERIFYDIF_INSTALLDEVICEFILESDIF_UNREMOVEDIF_SELECTBESTCOMPATDRVDIF_ALLOW_INSTALLDIF_REGISTERDEVICEDIF_NEWDEVICEWIZARD_PRESELECTDIF_NEWDEVICEWIZARD_SELECTDIF_NEWDEVICEWIZARD_PREANALYZEDIF_NEWDEVICEWIZARD_POSTANALYZEDIF_NEWDEVICEWIZARD_FINISHINSTALLDIF_UNUSED1DIF_INSTALLINTERFACESDIF_DETECTCANCELDIF_REGISTER_COINSTALLERSDIF_ADDPROPERTYPAGE_ADVANCEDDIF_ADDPROPERTYPAGE_BASICDIF_RESERVED1DIF_TROUBLESHOOTERDIF_POWERMESSAGEWAKEDIF_ADDREMOTEPROPERTYPAGE_ADVANCEDDIF_UPDATEDRIVER_UIDIF_FINISHINSTALL_ACTIONDIF_RESERVED2DIF_MOVEDEVICEPSP_DEVINSTALL_PARAMS_ASP_DEVINSTALL_PARAMS_APSP_DEVINSTALL_PARAMS_WSP_DEVINSTALL_PARAMS_WDI_SHOWOEMDI_SHOWCOMPATDI_SHOWCLASSDI_SHOWALLDI_NOVCPDI_DIDCOMPATDI_DIDCLASSDI_AUTOASSIGNRESDI_NEEDRESTARTDI_NEEDREBOOTDI_NOBROWSEDI_MULTMFGSDI_DISABLEDDI_GENERALPAGE_ADDEDDI_RESOURCEPAGE_ADDEDDI_PROPERTIES_CHANGEDI_INF_IS_SORTEDDI_ENUMSINGLEINFDI_DONOTCALLCONFIGMGDI_INSTALLDISABLEDDI_COMPAT_FROM_CLASSDI_CLASSINSTALLPARAMSDI_NODI_DEFAULTACTIONDI_QUIETINSTALLDI_NOFILECOPYDI_FORCECOPYDI_DRIVERPAGE_ADDEDDI_USECI_SELECTSTRINGSDI_OVERRIDE_INFFLAGSDI_PROPS_NOCHANGEUSAGEDI_NOSELECTICONSDI_NOWRITE_IDSDI_FLAGSEX_RESERVED2DI_FLAGSEX_RESERVED3DI_FLAGSEX_CI_FAILEDDI_FLAGSEX_FINISHINSTALL_ACTIONDI_FLAGSEX_DIDINFOLISTDI_FLAGSEX_DIDCOMPATINFODI_FLAGSEX_FILTERCLASSESDI_FLAGSEX_SETFAILEDINSTALLDI_FLAGSEX_DEVICECHANGEDI_FLAGSEX_ALWAYSWRITEIDSDI_FLAGSEX_PROPCHANGE_PENDINGDI_FLAGSEX_ALLOWEXCLUDEDDRVSDI_FLAGSEX_NOUIONQUERYREMOVEDI_FLAGSEX_USECLASSFORCOMPATDI_FLAGSEX_RESERVED4DI_FLAGSEX_NO_DRVREG_MODIFYDI_FLAGSEX_IN_SYSTEM_SETUPDI_FLAGSEX_INET_DRIVERDI_FLAGSEX_APPENDDRIVERLISTDI_FLAGSEX_PREINSTALLBACKUPDI_FLAGSEX_BACKUPONREPLACEDI_FLAGSEX_DRIVERLIST_FROM_URLDI_FLAGSEX_RESERVED1DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERSDI_FLAGSEX_POWERPAGE_ADDEDDI_FLAGSEX_FILTERSIMILARDRIVERSDI_FLAGSEX_INSTALLEDDRIVERDI_FLAGSEX_NO_CLASSLIST_NODE_MERGEDI_FLAGSEX_ALTPLATFORM_DRVSEARCHDI_FLAGSEX_RESTART_DEVICE_ONLYDI_FLAGSEX_RECURSIVESEARCHDI_FLAGSEX_SEARCH_PUBLISHED_INFSPSP_CLASSINSTALL_HEADERSP_CLASSINSTALL_HEADERPSP_ENABLECLASS_PARAMSSP_ENABLECLASS_PARAMSENABLECLASS_QUERYENABLECLASS_SUCCESSENABLECLASS_FAILUREDICS_ENABLEDICS_DISABLEDICS_PROPCHANGEDICS_STARTDICS_STOPDICS_FLAG_GLOBALDICS_FLAG_CONFIGSPECIFICDICS_FLAG_CONFIGGENERALPSP_PROPCHANGE_PARAMSSP_PROPCHANGE_PARAMSPSP_REMOVEDEVICE_PARAMSSP_REMOVEDEVICE_PARAMSDI_REMOVEDEVICE_GLOBALDI_REMOVEDEVICE_CONFIGSPECIFICPSP_UNREMOVEDEVICE_PARAMSSP_UNREMOVEDEVICE_PARAMSDI_UNREMOVEDEVICE_CONFIGSPECIFICPSP_SELECTDEVICE_PARAMS_ASP_SELECTDEVICE_PARAMS_APSP_SELECTDEVICE_PARAMS_WSP_SELECTDEVICE_PARAMS_WPSP_DETECTDEVICE_PARAMSSP_DETECTDEVICE_PARAMSMAX_INSTALLWIZARD_DYNAPAGESPSP_INSTALLWIZARD_DATASP_INSTALLWIZARD_DATANDW_INSTALLFLAG_DIDFACTDEFSNDW_INSTALLFLAG_HARDWAREALLREADYINNDW_INSTALLFLAG_NEEDRESTARTNDW_INSTALLFLAG_NEEDREBOOTNDW_INSTALLFLAG_NEEDSHUTDOWNNDW_INSTALLFLAG_EXPRESSINTRONDW_INSTALLFLAG_SKIPISDEVINSTALLEDNDW_INSTALLFLAG_NODETECTEDDEVSNDW_INSTALLFLAG_INSTALLSPECIFICNDW_INSTALLFLAG_SKIPCLASSLISTNDW_INSTALLFLAG_CI_PICKED_OEMNDW_INSTALLFLAG_PCMCIAMODENDW_INSTALLFLAG_PCMCIADEVICENDW_INSTALLFLAG_USERCANCELNDW_INSTALLFLAG_KNOWNCLASSDYNAWIZ_FLAG_PAGESADDEDDYNAWIZ_FLAG_ANALYZE_HANDLECONFLICTDYNAWIZ_FLAG_INSTALLDET_NEXTDYNAWIZ_FLAG_INSTALLDET_PREVMIN_IDD_DYNAWIZ_RESOURCE_IDMAX_IDD_DYNAWIZ_RESOURCE_IDIDD_DYNAWIZ_FIRSTPAGEIDD_DYNAWIZ_SELECT_PREVPAGEIDD_DYNAWIZ_SELECT_NEXTPAGEIDD_DYNAWIZ_ANALYZE_PREVPAGEIDD_DYNAWIZ_ANALYZE_NEXTPAGEIDD_DYNAWIZ_SELECTDEV_PAGEIDD_DYNAWIZ_ANALYZEDEV_PAGEIDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGEIDD_DYNAWIZ_SELECTCLASS_PAGEIDD_DYNAWIZ_INSTALLDETECTED_PREVPAGEIDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGEIDD_DYNAWIZ_INSTALLDETECTED_NODEVSPSP_NEWDEVICEWIZARD_DATASP_NEWDEVICEWIZARD_DATASP_ADDPROPERTYPAGE_DATAPSP_ADDPROPERTYPAGE_DATAPSP_TROUBLESHOOTER_PARAMS_ASP_TROUBLESHOOTER_PARAMS_APSP_TROUBLESHOOTER_PARAMS_WSP_TROUBLESHOOTER_PARAMS_WPSP_POWERMESSAGEWAKE_PARAMS_ASP_POWERMESSAGEWAKE_PARAMS_APSP_POWERMESSAGEWAKE_PARAMS_WSP_POWERMESSAGEWAKE_PARAMS_WPSP_DRVINFO_DATA_V2_ASP_DRVINFO_DATA_V2_APSP_DRVINFO_DATA_V2_WSP_DRVINFO_DATA_V2_WPSP_DRVINFO_DATA_V1_ASP_DRVINFO_DATA_V1_APSP_DRVINFO_DATA_V1_WSP_DRVINFO_DATA_V1_WSP_DRVINFO_DATA_APSP_DRVINFO_DATA_ASP_DRVINFO_DATA_WPSP_DRVINFO_DATA_WPSP_DRVINFO_DETAIL_DATA_ASP_DRVINFO_DETAIL_DATA_APSP_DRVINFO_DETAIL_DATA_WSP_DRVINFO_DETAIL_DATA_WPSP_DRVINSTALL_PARAMSSP_DRVINSTALL_PARAMSDNF_DUPDESCDNF_OLDDRIVERDNF_EXCLUDEFROMLISTDNF_NODRIVERDNF_LEGACYINFDNF_CLASS_DRIVERDNF_COMPATIBLE_DRIVERDNF_INET_DRIVERDNF_UNUSED1DNF_UNUSED2DNF_OLD_INET_DRIVERDNF_BAD_DRIVERDNF_DUPPROVIDERDNF_INF_IS_SIGNEDDNF_OEM_F6_INFDNF_DUPDRIVERVERDNF_BASIC_DRIVERDNF_AUTHENTICODE_SIGNEDDNF_INSTALLEDDRIVERDNF_ALWAYSEXCLUDEFROMLISTDNF_INBOX_DRIVERDNF_REQUESTADDITIONALSOFTWAREDNF_UNUSED_22DNF_UNUSED_23DNF_UNUSED_24DNF_UNUSED_25DNF_UNUSED_26DNF_UNUSED_27DNF_UNUSED_28DNF_UNUSED_29DNF_UNUSED_30DNF_UNUSED_31DRIVER_HARDWAREID_RANKDRIVER_HARDWAREID_MASKDRIVER_UNTRUSTED_RANKDRIVER_W9X_SUSPECT_RANKPCOINSTALLER_CONTEXT_DATACOINSTALLER_CONTEXT_DATAPSP_CLASSIMAGELIST_DATASP_CLASSIMAGELIST_DATAPSP_PROPSHEETPAGE_REQUESTSP_PROPSHEETPAGE_REQUESTSPPSR_SELECT_DEVICE_RESOURCESSPPSR_ENUM_BASIC_DEVICE_PROPERTIESSPPSR_ENUM_ADV_DEVICE_PROPERTIESPSP_BACKUP_QUEUE_PARAMS_V2_ASP_BACKUP_QUEUE_PARAMS_V2_APSP_BACKUP_QUEUE_PARAMS_V2_WSP_BACKUP_QUEUE_PARAMS_V2_WPSP_BACKUP_QUEUE_PARAMS_V1_ASP_BACKUP_QUEUE_PARAMS_V1_APSP_BACKUP_QUEUE_PARAMS_V1_WSP_BACKUP_QUEUE_PARAMS_V1_WSP_BACKUP_QUEUE_PARAMS_APSP_BACKUP_QUEUE_PARAMS_ASP_BACKUP_QUEUE_PARAMS_WPSP_BACKUP_QUEUE_PARAMS_WERROR_EXPECTED_SECTION_NAMEERROR_BAD_SECTION_NAME_LINEERROR_SECTION_NAME_TOO_LONGERROR_GENERAL_SYNTAXERROR_WRONG_INF_STYLEERROR_SECTION_NOT_FOUNDERROR_LINE_NOT_FOUNDERROR_NO_BACKUPERROR_NO_ASSOCIATED_CLASSERROR_CLASS_MISMATCHERROR_DUPLICATE_FOUNDERROR_NO_DRIVER_SELECTEDERROR_KEY_DOES_NOT_EXISTERROR_INVALID_DEVINST_NAMEERROR_INVALID_CLASSERROR_DEVINST_ALREADY_EXISTSERROR_DEVINFO_NOT_REGISTEREDERROR_INVALID_REG_PROPERTYERROR_NO_INFERROR_NO_SUCH_DEVINSTERROR_CANT_LOAD_CLASS_ICONERROR_INVALID_CLASS_INSTALLERERROR_DI_DO_DEFAULTERROR_DI_NOFILECOPYERROR_INVALID_HWPROFILEERROR_NO_DEVICE_SELECTEDERROR_DEVINFO_LIST_LOCKEDERROR_DEVINFO_DATA_LOCKEDERROR_DI_BAD_PATHERROR_NO_CLASSINSTALL_PARAMSERROR_FILEQUEUE_LOCKEDERROR_BAD_SERVICE_INSTALLSECTERROR_NO_CLASS_DRIVER_LISTERROR_NO_ASSOCIATED_SERVICEERROR_NO_DEFAULT_DEVICE_INTERFACEERROR_DEVICE_INTERFACE_ACTIVEERROR_DEVICE_INTERFACE_REMOVEDERROR_BAD_INTERFACE_INSTALLSECTERROR_NO_SUCH_INTERFACE_CLASSERROR_INVALID_REFERENCE_STRINGERROR_INVALID_MACHINENAMEERROR_REMOTE_COMM_FAILUREERROR_MACHINE_UNAVAILABLEERROR_NO_CONFIGMGR_SERVICESERROR_INVALID_PROPPAGE_PROVIDERERROR_NO_SUCH_DEVICE_INTERFACEERROR_DI_POSTPROCESSING_REQUIREDERROR_INVALID_COINSTALLERERROR_NO_COMPAT_DRIVERSERROR_NO_DEVICE_ICONERROR_INVALID_INF_LOGCONFIGERROR_DI_DONT_INSTALLERROR_INVALID_FILTER_DRIVERERROR_NON_WINDOWS_NT_DRIVERERROR_NON_WINDOWS_DRIVERERROR_NO_CATALOG_FOR_OEM_INFERROR_DEVINSTALL_QUEUE_NONNATIVEERROR_NOT_DISABLEABLEERROR_CANT_REMOVE_DEVINSTERROR_INVALID_TARGETERROR_DRIVER_NONNATIVEERROR_IN_WOW64ERROR_SET_SYSTEM_RESTORE_POINTERROR_SCE_DISABLEDERROR_UNKNOWN_EXCEPTIONERROR_PNP_REGISTRY_ERRORERROR_REMOTE_REQUEST_UNSUPPORTEDERROR_NOT_AN_INSTALLED_OEM_INFERROR_INF_IN_USE_BY_DEVICESERROR_DI_FUNCTION_OBSOLETEERROR_NO_AUTHENTICODE_CATALOGERROR_AUTHENTICODE_DISALLOWEDERROR_AUTHENTICODE_TRUSTED_PUBLISHERERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHEDERROR_AUTHENTICODE_PUBLISHER_NOT_TRUSTEDERROR_SIGNATURE_OSATTRIBUTE_MISMATCHERROR_ONLY_VALIDATE_VIA_AUTHENTICODEERROR_DEVICE_INSTALLER_NOT_READYERROR_DRIVER_STORE_ADD_FAILEDERROR_DEVICE_INSTALL_BLOCKEDERROR_DRIVER_INSTALL_BLOCKEDERROR_WRONG_INF_TYPEERROR_FILE_HASH_NOT_IN_CATALOGERROR_DRIVER_STORE_DELETE_FAILEDERROR_UNRECOVERABLE_STACK_OVERFLOWEXCEPTION_SPAPI_UNRECOVERABLE_STACK_OVERFLOWERROR_NO_DEFAULT_INTERFACE_DEVICEERROR_INTERFACE_DEVICE_ACTIVEERROR_INTERFACE_DEVICE_REMOVEDERROR_NO_SUCH_INTERFACE_DEVICEERROR_NOT_INSTALLEDSetupGetInfInformationASetupGetInfInformationWINFINFO_INF_SPEC_IS_HINFINFINFO_INF_NAME_IS_ABSOLUTEINFINFO_DEFAULT_SEARCHINFINFO_REVERSE_DEFAULT_SEARCHINFINFO_INF_PATH_LIST_SEARCHSetupQueryInfFileInformationASetupQueryInfFileInformationWSetupQueryInfOriginalFileInformationASetupQueryInfOriginalFileInformationWSetupQueryInfVersionInformationASetupQueryInfVersionInformationWSetupGetInfDriverStoreLocationASetupGetInfDriverStoreLocationWSetupGetInfPublishedNameASetupGetInfPublishedNameWSetupGetInfFileListASetupGetInfFileListWSetupOpenInfFileWSetupOpenInfFileASetupOpenMasterInfSetupOpenAppendInfFileWSetupOpenAppendInfFileASetupCloseInfFileSetupFindFirstLineASetupFindFirstLineWSetupFindNextLineSetupFindNextMatchLineASetupFindNextMatchLineWSetupGetLineByIndexASetupGetLineByIndexWSetupGetLineCountASetupGetLineCountWSetupGetLineTextASetupGetLineTextWSetupGetFieldCountSetupGetStringFieldASetupGetStringFieldWSetupGetIntFieldSetupGetMultiSzFieldASetupGetMultiSzFieldWSetupGetBinaryFieldSetupGetFileCompressionInfoASetupGetFileCompressionInfoWSetupGetFileCompressionInfoExASetupGetFileCompressionInfoExWFILE_COMPRESSION_NONEFILE_COMPRESSION_WINLZAFILE_COMPRESSION_MSZIPFILE_COMPRESSION_NTCABSetupDecompressOrCopyFileASetupDecompressOrCopyFileWSetupGetSourceFileLocationASetupGetSourceFileLocationWSetupGetSourceFileSizeASetupGetSourceFileSizeWSetupGetTargetPathASetupGetTargetPathWSRCLIST_TEMPORARYSRCLIST_NOBROWSESRCLIST_SYSTEMSRCLIST_USERSRCLIST_SYSIFADMINSRCLIST_SUBDIRSSRCLIST_APPENDSRCLIST_NOSTRIPPLATFORMSetupSetSourceListASetupSetSourceListWSetupCancelTemporarySourceListSetupAddToSourceListASetupAddToSourceListWSetupRemoveFromSourceListASetupRemoveFromSourceListWSetupQuerySourceListASetupQuerySourceListWSetupFreeSourceListASetupFreeSourceListWSetupPromptForDiskASetupPromptForDiskWSetupCopyErrorASetupCopyErrorWSetupRenameErrorASetupRenameErrorWSetupDeleteErrorASetupDeleteErrorWSetupBackupErrorASetupBackupErrorWIDF_NOBROWSEIDF_NOSKIPIDF_NODETAILSIDF_NOCOMPRESSEDIDF_CHECKFIRSTIDF_NOBEEPIDF_NOFOREGROUNDIDF_WARNIFSKIPIDF_NOREMOVABLEMEDIAPROMPTIDF_USEDISKNAMEASPROMPTIDF_OEMDISKDPROMPT_SUCCESSDPROMPT_CANCELDPROMPT_SKIPFILEDPROMPT_BUFFERTOOSMALLDPROMPT_OUTOFMEMORYSetupSetDirectoryIdASetupSetDirectoryIdWSetupSetDirectoryIdExASetupSetDirectoryIdExWSETDIRID_NOT_FULL_PATHSetupGetSourceInfoASetupGetSourceInfoWSRCINFO_PATHSRCINFO_TAGFILESRCINFO_DESCRIPTIONSRCINFO_FLAGSSRCINFO_TAGFILE2SRC_FLAGS_CABFILESetupInstallFileAPSP_FILE_CALLBACK_ASetupInstallFileWPSP_FILE_CALLBACK_WSetupInstallFileExASetupInstallFileExWSP_COPY_DELETESOURCESP_COPY_REPLACEONLYSP_COPY_NEWERSP_COPY_NEWER_OR_SAMESP_COPY_NOOVERWRITESP_COPY_NODECOMPSP_COPY_LANGUAGEAWARESP_COPY_SOURCE_ABSOLUTESP_COPY_SOURCEPATH_ABSOLUTESP_COPY_IN_USE_NEEDS_REBOOTSP_COPY_FORCE_IN_USESP_COPY_NOSKIPSP_FLAG_CABINETCONTINUATIONSP_COPY_FORCE_NOOVERWRITESP_COPY_FORCE_NEWERSP_COPY_WARNIFSKIPSP_COPY_NOBROWSESP_COPY_NEWER_ONLYSP_COPY_RESERVEDSP_COPY_OEMINF_CATALOG_ONLYSP_COPY_REPLACE_BOOT_FILESP_COPY_NOPRUNESP_COPY_OEM_F6_INFSP_COPY_ALREADYDECOMPSP_COPY_WINDOWS_SIGNEDSP_COPY_PNPLOCKEDSP_COPY_IN_USE_TRY_RENAMESP_COPY_INBOX_INFSP_COPY_HARDLINKSP_BACKUP_BACKUPPASSSP_BACKUP_DEMANDPASSSP_BACKUP_SPECIALSP_BACKUP_BOOTFILESetupOpenFileQueueSetupCloseFileQueueSetupSetFileQueueAlternatePlatformASetupSetFileQueueAlternatePlatformWSetupSetPlatformPathOverrideASetupSetPlatformPathOverrideWSetupQueueCopyASetupQueueCopyWSetupQueueCopyIndirectASetupQueueCopyIndirectWSetupQueueDefaultCopyASetupQueueDefaultCopyWSetupQueueCopySectionASetupQueueCopySectionWSetupQueueDeleteASetupQueueDeleteWSetupQueueDeleteSectionASetupQueueDeleteSectionWSetupQueueRenameASetupQueueRenameWSetupQueueRenameSectionASetupQueueRenameSectionWSetupCommitFileQueueASetupCommitFileQueueWSetupScanFileQueueASetupScanFileQueueWSPQ_SCAN_FILE_PRESENCESPQ_SCAN_FILE_VALIDITYSPQ_SCAN_USE_CALLBACKSPQ_SCAN_USE_CALLBACKEXSPQ_SCAN_INFORM_USERSPQ_SCAN_PRUNE_COPY_QUEUESPQ_SCAN_USE_CALLBACK_SIGNERINFOSPQ_SCAN_PRUNE_DELRENSPQ_SCAN_FILE_PRESENCE_WITHOUT_SOURCESPQ_SCAN_FILE_COMPARISONSPQ_SCAN_ACTIVATE_DRPSPQ_DELAYED_COPYSetupGetFileQueueCountSetupGetFileQueueFlagsSetupSetFileQueueFlagsSPQ_FLAG_BACKUP_AWARESPQ_FLAG_ABORT_IF_UNSIGNEDSPQ_FLAG_FILES_MODIFIEDSPQ_FLAG_DO_SHUFFLEMOVESPQ_FLAG_VALIDSPOST_NONESPOST_PATHSPOST_URLSPOST_MAXSetupCopyOEMInfASetupCopyOEMInfWSUOI_FORCEDELETESUOI_INTERNAL1SetupUninstallOEMInfASetupUninstallOEMInfWSetupUninstallNewlyCopiedInfsSetupCreateDiskSpaceListASetupCreateDiskSpaceListWSPDSL_IGNORE_DISKSPDSL_DISALLOW_NEGATIVE_ADJUSTSetupDuplicateDiskSpaceListASetupDuplicateDiskSpaceListWSetupDestroyDiskSpaceListSetupQueryDrivesInDiskSpaceListASetupQueryDrivesInDiskSpaceListWSetupQuerySpaceRequiredOnDriveASetupQuerySpaceRequiredOnDriveWSetupAdjustDiskSpaceListASetupAdjustDiskSpaceListWSetupAddToDiskSpaceListASetupAddToDiskSpaceListWSetupAddSectionToDiskSpaceListASetupAddSectionToDiskSpaceListWSetupAddInstallSectionToDiskSpaceListASetupAddInstallSectionToDiskSpaceListWSetupRemoveFromDiskSpaceListASetupRemoveFromDiskSpaceListWSetupRemoveSectionFromDiskSpaceListASetupRemoveSectionFromDiskSpaceListWSetupRemoveInstallSectionFromDiskSpaceListASetupRemoveInstallSectionFromDiskSpaceListWSetupIterateCabinetASetupIterateCabinetWSetupPromptRebootSPFILEQ_FILE_IN_USESPFILEQ_REBOOT_RECOMMENDEDSPFILEQ_REBOOT_IN_PROGRESSSetupInitDefaultQueueCallbackSetupInitDefaultQueueCallbackExSetupTermDefaultQueueCallbackSetupDefaultQueueCallbackASetupDefaultQueueCallbackWFLG_ADDREG_DELREG_BITFLG_ADDREG_BINVALUETYPEFLG_ADDREG_NOCLOBBERFLG_ADDREG_DELVALFLG_ADDREG_APPENDFLG_ADDREG_KEYONLYFLG_ADDREG_OVERWRITEONLYFLG_ADDREG_64BITKEYFLG_ADDREG_KEYONLY_COMMONFLG_ADDREG_32BITKEYFLG_ADDREG_TYPE_MASKFLG_ADDREG_TYPE_SZFLG_ADDREG_TYPE_MULTI_SZFLG_ADDREG_TYPE_EXPAND_SZFLG_ADDREG_TYPE_BINARYFLG_ADDREG_TYPE_DWORDFLG_ADDREG_TYPE_NONEFLG_DELREG_VALUEFLG_DELREG_TYPE_MASKFLG_DELREG_TYPE_SZFLG_DELREG_TYPE_MULTI_SZFLG_DELREG_TYPE_EXPAND_SZFLG_DELREG_TYPE_BINARYFLG_DELREG_TYPE_DWORDFLG_DELREG_TYPE_NONEFLG_DELREG_64BITKEYFLG_DELREG_KEYONLY_COMMONFLG_DELREG_32BITKEYFLG_DELREG_OPERATION_MASKFLG_DELREG_MULTI_SZ_DELSTRINGFLG_BITREG_CLEARBITSFLG_BITREG_SETBITSFLG_BITREG_64BITKEYFLG_BITREG_32BITKEYFLG_INI2REG_64BITKEYFLG_INI2REG_32BITKEYFLG_REGSVR_DLLREGISTERFLG_REGSVR_DLLINSTALLFLG_PROFITEM_CURRENTUSERFLG_PROFITEM_DELETEFLG_PROFITEM_GROUPFLG_PROFITEM_CSIDLFLG_ADDPROPERTY_NOCLOBBERFLG_ADDPROPERTY_OVERWRITEONLYFLG_ADDPROPERTY_APPENDFLG_ADDPROPERTY_ORFLG_ADDPROPERTY_ANDFLG_DELPROPERTY_MULTI_SZ_DELSTRINGSetupInstallFromInfSectionASetupInstallFromInfSectionWSPINST_LOGCONFIGSPINST_INIFILESSPINST_REGISTRYSPINST_INI2REGSPINST_FILESSPINST_BITREGSPINST_REGSVRSPINST_UNREGSVRSPINST_PROFILEITEMSSPINST_COPYINFSPINST_PROPERTIESSPINST_ALLSPINST_SINGLESECTIONSPINST_LOGCONFIG_IS_FORCEDSPINST_LOGCONFIGS_ARE_OVERRIDESSPINST_REGISTERCALLBACKAWARESPINST_DEVICEINSTALLSetupInstallFilesFromInfSectionASetupInstallFilesFromInfSectionWSPSVCINST_TAGTOFRONTSPSVCINST_ASSOCSERVICESPSVCINST_DELETEEVENTLOGENTRYSPSVCINST_NOCLOBBER_DISPLAYNAMESPSVCINST_NOCLOBBER_STARTTYPESPSVCINST_NOCLOBBER_ERRORCONTROLSPSVCINST_NOCLOBBER_LOADORDERGROUPSPSVCINST_NOCLOBBER_DEPENDENCIESSPSVCINST_NOCLOBBER_DESCRIPTIONSPSVCINST_STOPSERVICESPSVCINST_CLOBBER_SECURITYSPSVCINST_STARTSERVICESPSVCINST_NOCLOBBER_REQUIREDPRIVILEGESSetupInstallServicesFromInfSectionASetupInstallServicesFromInfSectionWSetupInstallServicesFromInfSectionExASetupInstallServicesFromInfSectionExWInstallHinfSectionAInstallHinfSectionWHSPFILELOGSetupInitializeFileLogASetupInitializeFileLogWSPFILELOG_SYSTEMLOGSPFILELOG_FORCENEWSPFILELOG_QUERYONLYSetupTerminateFileLogSetupLogFileASetupLogFileWSPFILELOG_OEMFILESetupRemoveFileLogEntryASetupRemoveFileLogEntryWSetupQueryFileLogASetupFileLogInfoSetupQueryFileLogWLogSeverityLogSevInformationLogSevWarningLogSevErrorLogSevFatalErrorLogSevMaximumSetupOpenLogSetupLogErrorASetupLogErrorWSetupCloseLogSetupGetThreadLogTokenSetupSetThreadLogTokenSetupWriteTextLogInfLineSetupGetBackupInformationASetupGetBackupInformationWSetupPrepareQueueForRestoreASetupPrepareQueueForRestoreWSetupSetNonInteractiveModeSetupGetNonInteractiveModeSetupDiCreateDeviceInfoListSetupDiCreateDeviceInfoListExASetupDiCreateDeviceInfoListExWSetupDiGetDeviceInfoListClassSetupDiGetDeviceInfoListDetailASetupDiGetDeviceInfoListDetailWDICD_GENERATE_IDDICD_INHERIT_CLASSDRVSSetupDiCreateDeviceInfoASetupDiCreateDeviceInfoWDIOD_INHERIT_CLASSDRVSDIOD_CANCEL_REMOVESetupDiOpenDeviceInfoASetupDiOpenDeviceInfoWSetupDiGetDeviceInstanceIdASetupDiGetDeviceInstanceIdWSetupDiDeleteDeviceInfoSetupDiEnumDeviceInfoSetupDiDestroyDeviceInfoListSetupDiEnumDeviceInterfacesSetupDiCreateDeviceInterfaceASetupDiCreateDeviceInterfaceWDIODI_NO_ADDSetupDiOpenDeviceInterfaceASetupDiOpenDeviceInterfaceWSetupDiGetDeviceInterfaceAliasSetupDiDeleteDeviceInterfaceDataSetupDiRemoveDeviceInterfaceSetupDiGetDeviceInterfaceDetailASetupDiGetDeviceInterfaceDetailWSetupDiInstallDeviceInterfacesSetupDiSetDeviceInterfaceDefaultSPRDI_FIND_DUPSSetupDiRegisterDeviceInfoPSP_DETSIG_CMPPROCSPDIT_NODRIVERSPDIT_CLASSDRIVERSPDIT_COMPATDRIVERSetupDiBuildDriverInfoListSetupDiCancelDriverInfoSearchSetupDiEnumDriverInfoASetupDiEnumDriverInfoWSetupDiGetSelectedDriverASetupDiGetSelectedDriverWSetupDiSetSelectedDriverASetupDiSetSelectedDriverWSetupDiGetDriverInfoDetailASetupDiGetDriverInfoDetailWSetupDiDestroyDriverInfoListDIGCF_DEFAULTDIGCF_PRESENTDIGCF_ALLCLASSESDIGCF_PROFILEDIGCF_DEVICEINTERFACESetupDiGetClassDevsASetupDiGetClassDevsWSetupDiGetClassDevsExASetupDiGetClassDevsExWSetupDiGetINFClassASetupDiGetINFClassWDIBCI_NOINSTALLCLASSDIBCI_NODISPLAYCLASSSetupDiBuildClassInfoListSetupDiBuildClassInfoListExASetupDiBuildClassInfoListExWSetupDiGetClassDescriptionASetupDiGetClassDescriptionWSetupDiGetClassDescriptionExASetupDiGetClassDescriptionExWSetupDiCallClassInstallerSetupDiSelectDeviceSetupDiSelectBestCompatDrvSetupDiInstallDeviceSetupDiInstallDriverFilesSetupDiRegisterCoDeviceInstallersSetupDiRemoveDeviceSetupDiUnremoveDeviceSetupDiRestartDevicesSetupDiChangeStateSetupDiInstallClassASetupDiInstallClassWSetupDiInstallClassExASetupDiInstallClassExWSetupDiOpenClassRegKeyDIOCR_INSTALLERDIOCR_INTERFACESetupDiOpenClassRegKeyExASetupDiOpenClassRegKeyExWSetupDiCreateDeviceInterfaceRegKeyASetupDiCreateDeviceInterfaceRegKeyWSetupDiOpenDeviceInterfaceRegKeySetupDiDeleteDeviceInterfaceRegKeyDIREG_DEVDIREG_DRVDIREG_BOTHSetupDiCreateDevRegKeyASetupDiCreateDevRegKeyWSetupDiOpenDevRegKeySetupDiDeleteDevRegKeySetupDiGetHwProfileListSetupDiGetHwProfileListExASetupDiGetHwProfileListExWSetupDiGetDevicePropertyKeysSetupDiGetDevicePropertyWSetupDiSetDevicePropertyWSetupDiGetDeviceInterfacePropertyKeysSetupDiGetDeviceInterfacePropertyWSetupDiSetDeviceInterfacePropertyWDICLASSPROP_INSTALLERDICLASSPROP_INTERFACESetupDiGetClassPropertyKeysSetupDiGetClassPropertyKeysExWSetupDiGetClassPropertyWSetupDiGetClassPropertyExWSetupDiSetClassPropertyWSetupDiSetClassPropertyExWSPDRP_DEVICEDESCSPDRP_HARDWAREIDSPDRP_COMPATIBLEIDSSPDRP_UNUSED0SPDRP_SERVICESPDRP_UNUSED1SPDRP_UNUSED2SPDRP_CLASSSPDRP_CLASSGUIDSPDRP_DRIVERSPDRP_CONFIGFLAGSSPDRP_MFGSPDRP_FRIENDLYNAMESPDRP_LOCATION_INFORMATIONSPDRP_PHYSICAL_DEVICE_OBJECT_NAMESPDRP_CAPABILITIESSPDRP_UI_NUMBERSPDRP_UPPERFILTERSSPDRP_LOWERFILTERSSPDRP_BUSTYPEGUIDSPDRP_LEGACYBUSTYPESPDRP_BUSNUMBERSPDRP_ENUMERATOR_NAMESPDRP_SECURITYSPDRP_SECURITY_SDSSPDRP_DEVTYPESPDRP_EXCLUSIVESPDRP_CHARACTERISTICSSPDRP_ADDRESSSPDRP_UI_NUMBER_DESC_FORMATSPDRP_DEVICE_POWER_DATASPDRP_REMOVAL_POLICYSPDRP_REMOVAL_POLICY_HW_DEFAULTSPDRP_REMOVAL_POLICY_OVERRIDESPDRP_INSTALL_STATESPDRP_LOCATION_PATHSSPDRP_BASE_CONTAINERIDSPDRP_MAXIMUM_PROPERTYSPCRP_UPPERFILTERSSPCRP_LOWERFILTERSSPCRP_SECURITYSPCRP_SECURITY_SDSSPCRP_DEVTYPESPCRP_EXCLUSIVESPCRP_CHARACTERISTICSSPCRP_MAXIMUM_PROPERTYSetupDiGetDeviceRegistryPropertyASetupDiGetDeviceRegistryPropertyWSetupDiGetClassRegistryPropertyASetupDiGetClassRegistryPropertyWSetupDiSetDeviceRegistryPropertyASetupDiSetDeviceRegistryPropertyWSetupDiSetClassRegistryPropertyASetupDiSetClassRegistryPropertyWSetupDiGetDeviceInstallParamsASetupDiGetDeviceInstallParamsWSetupDiGetClassInstallParamsASetupDiGetClassInstallParamsWSetupDiSetDeviceInstallParamsASetupDiSetDeviceInstallParamsWSetupDiSetClassInstallParamsASetupDiSetClassInstallParamsWSetupDiGetDriverInstallParamsASetupDiGetDriverInstallParamsWSetupDiSetDriverInstallParamsASetupDiSetDriverInstallParamsWSetupDiLoadClassIconSetupDiLoadDeviceIconDMI_MASKDMI_BKCOLORDMI_USERECTSetupDiDrawMiniIconSetupDiGetClassBitmapIndexSetupDiGetClassImageListSetupDiGetClassImageListExASetupDiGetClassImageListExWSetupDiGetClassImageIndexSetupDiDestroyClassImageListDIGCDP_FLAG_BASICDIGCDP_FLAG_ADVANCEDDIGCDP_FLAG_REMOTE_BASICDIGCDP_FLAG_REMOTE_ADVANCEDSetupDiGetClassDevPropertySheetsASetupDiGetClassDevPropertySheetsWIDI_RESOURCEFIRSTIDI_RESOURCEIDI_RESOURCELASTIDI_RESOURCEOVERLAYFIRSTIDI_RESOURCEOVERLAYLASTIDI_CONFLICTIDI_CLASSICON_OVERLAYFIRSTIDI_CLASSICON_OVERLAYLASTIDI_PROBLEM_OVLIDI_DISABLED_OVLIDI_FORCED_OVLSetupDiAskForOEMDiskSetupDiSelectOEMDrvSetupDiClassNameFromGuidASetupDiClassNameFromGuidWSetupDiClassNameFromGuidExASetupDiClassNameFromGuidExWSetupDiClassGuidsFromNameASetupDiClassGuidsFromNameWSetupDiClassGuidsFromNameExASetupDiClassGuidsFromNameExWSetupDiGetHwProfileFriendlyNameASetupDiGetHwProfileFriendlyNameWSetupDiGetHwProfileFriendlyNameExASetupDiGetHwProfileFriendlyNameExWSPWPT_SELECTDEVICESPWP_USE_DEVINFO_DATASetupDiGetWizardPageSetupDiGetSelectedDeviceSetupDiSetSelectedDeviceSetupDiGetActualModelsSectionASetupDiGetActualModelsSectionWSetupDiGetActualSectionToInstallASetupDiGetActualSectionToInstallWSetupDiGetActualSectionToInstallExASetupDiGetActualSectionToInstallExWSetupEnumInfSectionsASetupEnumInfSectionsWPSP_INF_SIGNER_INFO_V1_ASP_INF_SIGNER_INFO_V1_APSP_INF_SIGNER_INFO_V1_WSP_INF_SIGNER_INFO_V1_WPSP_INF_SIGNER_INFO_V2_ASP_INF_SIGNER_INFO_V2_APSP_INF_SIGNER_INFO_V2_WSP_INF_SIGNER_INFO_V2_WSIGNERSCORE_UNKNOWNSIGNERSCORE_W9X_SUSPECTSIGNERSCORE_UNSIGNEDSIGNERSCORE_AUTHENTICODESIGNERSCORE_WHQLSIGNERSCORE_UNCLASSIFIEDSIGNERSCORE_INBOXSIGNERSCORE_LOGO_STANDARDSIGNERSCORE_LOGO_PREMIUMSIGNERSCORE_MASKSIGNERSCORE_SIGNED_MASKSP_INF_SIGNER_INFO_APSP_INF_SIGNER_INFO_ASP_INF_SIGNER_INFO_WPSP_INF_SIGNER_INFO_WSetupVerifyInfFileASetupVerifyInfFileWDICUSTOMDEVPROP_MERGE_MULTISZSetupDiGetCustomDevicePropertyASetupDiGetCustomDevicePropertyWSCWMI_CLOBBER_SECURITYSetupConfigureWmiFromInfSectionASetupConfigureWmiFromInfSectionW//! Public header file for Windows NT Setup and Device Installer services Dll.//pub fn SetupWriteTextLog() -> ();//pub fn SetupWriteTextLogError() -> ();DragQueryFileADragQueryPointDragAcceptFilesShellExecuteAShellExecuteWFindExecutableAFindExecutableWShellAboutAShellAboutWDuplicateIconExtractAssociatedIconAExtractAssociatedIconWExtractAssociatedIconExAExtractAssociatedIconExWExtractIconAExtractIconWLPDRAGINFOADRAGINFOALPDRAGINFOWDRAGINFOWABM_NEWABM_REMOVEABM_QUERYPOSABM_SETPOSABM_GETSTATEABM_GETTASKBARPOSABM_ACTIVATEABM_SETAUTOHIDEBARABM_WINDOWPOSCHANGEDABM_SETSTATEABM_GETAUTOHIDEBAREXABM_SETAUTOHIDEBAREXABN_STATECHANGEABN_POSCHANGEDABN_FULLSCREENAPPABN_WINDOWARRANGEABS_AUTOHIDEABS_ALWAYSONTOPPAPPBARDATADoEnvironmentSubstADoEnvironmentSubstWExtractIconExAExtractIconExWFO_MOVEFO_COPYFO_DELETEFO_RENAMEFOF_MULTIDESTFILESFOF_CONFIRMMOUSEFOF_SILENTFOF_RENAMEONCOLLISIONFOF_NOCONFIRMATIONFOF_WANTMAPPINGHANDLEFOF_ALLOWUNDOFOF_FILESONLYFOF_SIMPLEPROGRESSFOF_NOCONFIRMMKDIRFOF_NOERRORUIFOF_NOCOPYSECURITYATTRIBSFOF_NORECURSIONFOF_NO_CONNECTED_ELEMENTSFOF_WANTNUKEWARNINGFOF_NORECURSEREPARSEFOF_NO_UIFILEOP_FLAGSPO_DELETEPO_RENAMEPO_PORTCHANGEPO_REN_PORTPRINTEROP_FLAGSLPSHFILEOPSTRUCTASHFILEOPSTRUCTALPSHFILEOPSTRUCTWSHFILEOPSTRUCTWSHFileOperationASHFileOperationWSHFreeNameMappingsLPSHNAMEMAPPINGASHNAMEMAPPINGALPSHNAMEMAPPINGWSHNAMEMAPPINGWSE_ERR_FNFSE_ERR_PNFSE_ERR_ACCESSDENIEDSE_ERR_OOMSE_ERR_DLLNOTFOUNDSE_ERR_SHARESE_ERR_ASSOCINCOMPLETESE_ERR_DDETIMEOUTSE_ERR_DDEFAILSE_ERR_DDEBUSYSE_ERR_NOASSOCSEE_MASK_DEFAULTSEE_MASK_CLASSNAMESEE_MASK_CLASSKEYSEE_MASK_IDLISTSEE_MASK_INVOKEIDLISTSEE_MASK_ICONSEE_MASK_HOTKEYSEE_MASK_NOCLOSEPROCESSSEE_MASK_CONNECTNETDRVSEE_MASK_NOASYNCSEE_MASK_FLAG_DDEWAITSEE_MASK_DOENVSUBSTSEE_MASK_FLAG_NO_UISEE_MASK_UNICODESEE_MASK_NO_CONSOLESEE_MASK_ASYNCOKSEE_MASK_HMONITORSEE_MASK_NOZONECHECKSSEE_MASK_NOQUERYCLASSSTORESEE_MASK_WAITFORINPUTIDLESEE_MASK_FLAG_LOG_USAGESEE_MASK_FLAG_HINST_IS_SITELPSHELLEXECUTEINFOASHELLEXECUTEINFOALPSHELLEXECUTEINFOWSHELLEXECUTEINFOWShellExecuteExAShellExecuteExWPSHCREATEPROCESSINFOWSHCREATEPROCESSINFOWSHCreateProcessAsUserWSHEvaluateSystemCommandTemplateAssocCreateForClassesASSOCIATIONELEMENTLPSHQUERYRBINFOSHQUERYRBINFOSHERB_NOCONFIRMATIONSHERB_NOPROGRESSUISHERB_NOSOUNDSHQueryRecycleBinASHQueryRecycleBinWSHEmptyRecycleBinASHEmptyRecycleBinWSHQueryUserNotificationStateQUERY_USER_NOTIFICATION_STATESHGetPropertyStoreForWindowPNOTIFYICONDATAANOTIFYICONDATAAPNOTIFYICONDATAWNIN_SELECTNINF_KEYNIN_KEYSELECTNIN_BALLOONSHOWNIN_BALLOONHIDENIN_BALLOONTIMEOUTNIN_BALLOONUSERCLICKNIN_POPUPOPENNIN_POPUPCLOSENIM_SETFOCUSNIM_SETVERSIONNOTIFYICON_VERSIONNOTIFYICON_VERSION_4NIF_STATENIF_INFONIF_GUIDNIF_REALTIMENIF_SHOWTIPNIS_HIDDENNIS_SHAREDICONNIIF_NONENIIF_INFONIIF_WARNINGNIIF_ERRORNIIF_USERNIIF_ICON_MASKNIIF_NOSOUNDNIIF_LARGE_ICONNIIF_RESPECT_QUIET_TIMEPNOTIFYICONIDENTIFIERShell_NotifyIconASHGFI_ICONSHGFI_DISPLAYNAMESHGFI_TYPENAMESHGFI_ATTRIBUTESSHGFI_ICONLOCATIONSHGFI_EXETYPESHGFI_SYSICONINDEXSHGFI_LINKOVERLAYSHGFI_SELECTEDSHGFI_ATTR_SPECIFIEDSHGFI_LARGEICONSHGFI_SMALLICONSHGFI_OPENICONSHGFI_SHELLICONSIZESHGFI_PIDLSHGFI_USEFILEATTRIBUTESSHGFI_ADDOVERLAYSSHGFI_OVERLAYINDEXSHGetFileInfoASHFILEINFOASHGetFileInfoWSHFILEINFOWSHGSI_ICONLOCATIONSHGSI_ICONSHGSI_SYSICONINDEXSHGSI_LINKOVERLAYSHGSI_SELECTEDSHGSI_LARGEICONSHGSI_SMALLICONSHGSI_SHELLICONSIZESIID_INVALIDSHSTOCKICONIDSHGetStockIconInfoSHSTOCKICONINFOSHGetDiskFreeSpaceExASHGetDiskFreeSpaceExWSHGetNewLinkInfoASHGetNewLinkInfoWSHGNLI_PIDLSHGNLI_PREFIXNAMESHGNLI_NOUNIQUESHGNLI_NOLNKSHGNLI_NOLOCNAMESHGNLI_USEURLEXTPRINTACTION_OPENPRINTACTION_PROPERTIESPRINTACTION_NETINSTALLPRINTACTION_NETINSTALLLINKPRINTACTION_TESTPAGEPRINTACTION_OPENNETPRNPRINTACTION_DOCUMENTDEFAULTSPRINTACTION_SERVERPROPERTIESSHInvokePrinterCommandASHInvokePrinterCommandWPOPEN_PRINTER_PROPS_INFOAOPEN_PRINTER_PROPS_INFOAPOPEN_PRINTER_PROPS_INFOWOPEN_PRINTER_PROPS_INFOWPRINT_PROP_FORCE_NAMESHLoadNonloadedIconOverlayIdentifiersSHIsFileAvailableOfflineOFFLINE_STATUS_LOCALOFFLINE_STATUS_REMOTEOFFLINE_STATUS_INCOMPLETESHSetLocalizedNameSHRemoveLocalizedNameSHGetLocalizedNameShellMessageBoxAShellMessageBoxWIsLFNDriveAIsLFNDriveWSHEnumerateUnreadMailAccountsASHEnumerateUnreadMailAccountsWSHGetUnreadMailCountASHGetUnreadMailCountWSHSetUnreadMailCountASHSetUnreadMailCountWSHTestTokenMembershipSHGetImageListSHIL_LARGESHIL_SMALLSHIL_EXTRALARGESHIL_SYSSMALLSHIL_JUMBOSHIL_LASTWC_NETADDRESSInitNetworkAddressControlSHGetDriveMedia//! SHELL.DLL functions, types, and definitions// STRUCT!{struct NC_ADDRESS {//     pAddrInfo: *mut NET_ADDRESS_INFO,//     PortNumber: USHORT,//     PrefixLength: BYTE,// pub type PNC_ADDRESS = *mut NC_ADDRESS;GetProcessDpiAwarenessGetDpiForShellUIComponentSHELL_UI_COMPONENTPCIDLIST_ABSOLUTEPCUITEMID_CHILD_ARRAYPIDLIST_ABSOLUTEREFKNOWNFOLDERIDIDO_SHGIOI_SHAREIDO_SHGIOI_LINKIDO_SHGIOI_SLOWFILE// Yes, these values are supposed to be 9 digitsIDO_SHGIOI_DEFAULTSHGetIconOverlayIndexASHGetIconOverlayIndexWGPFIDL_DEFAULTGPFIDL_FLAGSGPFIDL_ALTNAMEGPFIDL_UNCPRINTERSHGetPathFromIDListExSHGetPathFromIDListASHGetPathFromIDListWSHCreateDirectorySHCreateDirectoryExASHCreateDirectoryExWOFASI_EDITOFASI_OPENDESKTOPSHOpenFolderAndSelectItems//pub fn SHCreateShellItem(//    pidlParent: PCIDLIST_ABSOLUTE,//    psfParent: *mut IShellFolder,//    pidl: PCUITEMID_CHILD,//    ppsi: *mut *mut IShellItem,//) -> HRESULT;CSIDL_DESKTOPCSIDL_INTERNETCSIDL_PROGRAMSCSIDL_CONTROLSCSIDL_PRINTERSCSIDL_PERSONALCSIDL_FAVORITESCSIDL_STARTUPCSIDL_RECENTCSIDL_SENDTOCSIDL_BITBUCKETCSIDL_STARTMENUCSIDL_MYDOCUMENTSCSIDL_MYMUSICCSIDL_MYVIDEOCSIDL_DESKTOPDIRECTORYCSIDL_DRIVESCSIDL_NETWORKCSIDL_NETHOODCSIDL_FONTSCSIDL_TEMPLATESCSIDL_COMMON_STARTMENUCSIDL_COMMON_PROGRAMSCSIDL_COMMON_STARTUPCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_PRINTHOODCSIDL_LOCAL_APPDATACSIDL_ALTSTARTUPCSIDL_COMMON_ALTSTARTUPCSIDL_COMMON_FAVORITESCSIDL_INTERNET_CACHECSIDL_COOKIESCSIDL_HISTORYCSIDL_COMMON_APPDATACSIDL_WINDOWSCSIDL_SYSTEMCSIDL_PROGRAM_FILESCSIDL_MYPICTURESCSIDL_PROFILECSIDL_SYSTEMX86CSIDL_PROGRAM_FILESX86CSIDL_PROGRAM_FILES_COMMONCSIDL_PROGRAM_FILES_COMMONX86CSIDL_COMMON_TEMPLATESCSIDL_COMMON_DOCUMENTSCSIDL_COMMON_ADMINTOOLSCSIDL_ADMINTOOLSCSIDL_CONNECTIONSCSIDL_COMMON_MUSICCSIDL_COMMON_PICTURESCSIDL_COMMON_VIDEOCSIDL_RESOURCESCSIDL_RESOURCES_LOCALIZEDCSIDL_COMMON_OEM_LINKSCSIDL_CDBURN_AREACSIDL_COMPUTERSNEARMECSIDL_FLAG_CREATECSIDL_FLAG_DONT_VERIFYCSIDL_FLAG_DONT_UNEXPANDCSIDL_FLAG_NO_ALIASCSIDL_FLAG_PER_USER_INITCSIDL_FLAG_MASKSHGetSpecialFolderLocationSHCloneSpecialIDListSHGetSpecialFolderPathASHGetSpecialFolderPathWSHFlushSFCacheSHGetFolderPathASHGetFolderPathWSHGetFolderLocationSHSetFolderPathASHSetFolderPathWSHGetFolderPathAndSubDirASHGetFolderPathAndSubDirWSHGetKnownFolderIDListSHSetKnownFolderPathSHGetKnownFolderItemKNOWN_FOLDER_FLAGIModalWindowIModalWindowVtblIShellItemIShellItemFilterCOMDLG_FILTERSPECIFileOperationProgressSinkIShellItemArraySIATTRIBFLAGS// FIXME: Remove these in the next major releaseIBindCtxGETPROPERTYSTOREFLAGS//4498SFGAOF//9466//20869//22307//27457LPTHUMBBUTTONTHUMBBUTTONTHBN_CLICKEDSHCreateItemFromParsingNameLPSHITEMIDSHITEMIDLPCSHITEMIDITEMIDLIST_RELATIVEITEMIDLISTITEMID_CHILDITEMIDLIST_ABSOLUTELPITEMIDLISTLPCITEMIDLISTPCUIDLIST_ABSOLUTEPIDLIST_RELATIVEPCIDLIST_RELATIVEPUIDLIST_RELATIVEPCUIDLIST_RELATIVEPITEMID_CHILDPCITEMID_CHILDPUITEMID_CHILDPCUITEMID_CHILDPCUIDLIST_RELATIVE_ARRAYPCIDLIST_ABSOLUTE_ARRAYPCUIDLIST_ABSOLUTE_ARRAYKNOWNFOLDERID//50PSP_LOG_TOKENLOGTOKEN_TYPE_MASKLOGTOKEN_UNSPECIFIEDLOGTOKEN_NO_LOGLOGTOKEN_SETUPAPI_APPLOGLOGTOKEN_SETUPAPI_DEVLOGTXTLOG_SETUPAPI_DEVLOGTXTLOG_SETUPAPI_CMDLINETXTLOG_SETUPAPI_BITSTXTLOG_ERRORTXTLOG_WARNINGTXTLOG_SYSTEM_STATE_CHANGETXTLOG_SUMMARYTXTLOG_DETAILSTXTLOG_VERBOSETXTLOG_VERY_VERBOSETXTLOG_RESERVED_FLAGSTXTLOG_TIMESTAMPTXTLOG_DEPTH_INCRTXTLOG_DEPTH_DECRTXTLOG_TAB_1TXTLOG_FLUSH_FILETXTLOG_LEVELTXTLOG_DEVINSTTXTLOG_INFTXTLOG_FILEQTXTLOG_COPYFILESTXTLOG_SIGVERIFTXTLOG_BACKUPTXTLOG_UITXTLOG_UTILTXTLOG_INFDBTXTLOG_POLICYTXTLOG_NEWDEVTXTLOG_UMPNPMGRTXTLOG_DRIVER_STORETXTLOG_SETUPTXTLOG_CMITXTLOG_DEVMGRTXTLOG_INSTALLERTXTLOG_VENDOR//! Public header file for Windows NT Setup and Device Installer services DllsWSCWriteProviderOrderWSCWriteProviderOrder32WSCWriteNameSpaceOrderWSCWriteNameSpaceOrder32//! Service Provider OrderSQLHANDLESQLHDBCSQLHENVSQLHSTMTSQLINTEGERSQLLENSQLPOINTERSQLRETURNSQLSMALLINTSQLUSMALLINTSQL_NULL_DATASQL_DATA_AT_EXECSQL_SUCCESSSQL_SUCCESS_WITH_INFOSQL_NO_DATASQL_PARAM_DATA_AVAILABLESQL_ERRORSQL_INVALID_HANDLESQL_STILL_EXECUTINGSQL_NEED_DATASQL_NTSSQL_MAX_MESSAGE_LENGTHSQL_DATE_LENSQL_TIME_LENSQL_TIMESTAMP_LENSQL_HANDLE_ENVSQL_HANDLE_DBCSQL_HANDLE_STMTSQL_HANDLE_DESCSQL_ATTR_OUTPUT_NTSSQL_ATTR_AUTO_IPDSQL_ATTR_METADATA_IDSQL_ATTR_APP_ROW_DESCSQL_ATTR_APP_PARAM_DESCSQL_ATTR_IMP_ROW_DESCSQL_ATTR_IMP_PARAM_DESCSQL_ATTR_CURSOR_SCROLLABLESQL_ATTR_CURSOR_SENSITIVITYSQL_UNKNOWN_TYPESQL_CHARSQL_NUMERICSQL_DECIMALSQL_INTEGERSQL_SMALLINTSQL_FLOATSQL_REALSQL_DOUBLESQL_DATETIMESQL_VARCHARSQL_TYPE_DATESQL_TYPE_TIMESQL_TYPE_TIMESTAMPSQL_NO_NULLSSQL_NULLABLESQL_NULLABLE_UNKNOWNSQL_CLOSESQL_DROPSQL_UNBINDSQL_RESET_PARAMSSQL_NULL_HANDLESQLAllocHandleSQLDisconnectSQLFetchSQLFreeHandleSQLFreeStmtSQLGetDataSQLNumResultColsSQLRowCountSQLSetConnectAttrSQLSetEnvAttrSQL_ATTR_ODBC_VERSIONSQL_ATTR_CONNECTION_POOLINGSQL_ATTR_CP_MATCHSQL_OV_ODBC2SQL_OV_ODBC3SQL_OV_ODBC3_80SQL_ACCESS_MODESQL_AUTOCOMMITSQL_LOGIN_TIMEOUTSQL_OPT_TRACESQL_OPT_TRACEFILESQL_TRANSLATE_DLLSQL_TRANSLATE_OPTIONSQL_TXN_ISOLATIONSQL_CURRENT_QUALIFIERSQL_ODBC_CURSORSSQL_QUIET_MODESQL_PACKET_SIZESQL_ATTR_ACCESS_MODESQL_ATTR_AUTOCOMMITSQL_ATTR_CONNECTION_TIMEOUTSQL_ATTR_CURRENT_CATALOGSQL_ATTR_DISCONNECT_BEHAVIORSQL_ATTR_ENLIST_IN_DTCSQL_ATTR_ENLIST_IN_XASQL_ATTR_LOGIN_TIMEOUTSQL_ATTR_ODBC_CURSORSSQL_ATTR_PACKET_SIZESQL_ATTR_QUIET_MODESQL_ATTR_TRACESQL_ATTR_TRACEFILESQL_ATTR_TRANSLATE_LIBSQL_ATTR_TRANSLATE_OPTIONSQL_ATTR_TXN_ISOLATIONSQL_ATTR_CONNECTION_DEADSQL_IS_POINTERSQL_IS_UINTEGERSQL_IS_INTEGERSQL_IS_USMALLINTSQL_IS_SMALLINTSQL_DATESQL_INTERVALSQL_TIMESQL_TIMESTAMPSQL_LONGVARCHARSQL_BINARYSQL_VARBINARYSQL_LONGVARBINARYSQL_BIGINTSQL_TINYINTSQL_BITSQL_GUIDSQL_C_CHARSQL_C_LONGSQL_C_SHORTSQL_C_FLOATSQL_C_DOUBLESQL_C_NUMERICSQL_C_DEFAULTSQL_SIGNED_OFFSETSQL_UNSIGNED_OFFSETSQL_C_DATESQL_C_TIMESQL_C_TIMESTAMPSQL_C_TYPE_DATESQL_C_TYPE_TIMESQL_C_TYPE_TIMESTAMPSQL_C_BINARYSQL_C_BITSQL_C_SBIGINTSQL_C_UBIGINTSQL_C_TINYINTSQL_C_SLONGSQL_C_SSHORTSQL_C_STINYINTSQL_C_ULONGSQL_C_USHORTSQL_C_UTINYINTSQL_C_GUIDSQL_TYPE_NULLSQL_DRIVER_NOPROMPTSQL_DRIVER_COMPLETESQL_DRIVER_PROMPTSQL_DRIVER_COMPLETE_REQUIRED//! This module defines the SQL extension APIsSQLCHARSQLSCHARSQLDATESQLDECIMALSQLDOUBLESQLFLOATSQLUINTEGERSQLULENSQLSETPOSIROWSQLROWCOUNTSQLROWSETSIZESQLTRANSIDSQLROWOFFSETSQLNUMERICSQLREALSQLTIMESQLTIMESTAMPSQLVARCHARSQLHDESC//pub type UCHAR = c_uchar;SDWORD//pub type SQLSCHAR = SCHAR;SWORDUDWORD//pub type UWORD = c_ushort;//#[cfg(target_pointer_width = "32")]//pub type SQLUINTEGER = UDWORD;SDOUBLE//pub type ULONG = c_ulong;//pub type USHORT = c_ushort;LDOUBLESFLOATHENVHDBCHSTMTRETCODESQLHWNDSQL_DATE_STRUCTDATE_STRUCTSQL_TIME_STRUCTTIME_STRUCTSQL_TIMESTAMP_STRUCTTIMESTAMP_STRUCTODBCINT64SQLBIGINTSQLUBIGINTSQL_MAX_NUMERIC_LENSQLGUIDBOOKMARKSQLWCHAR//! This module defines the types used in ODBCSQL_WCHARSQL_WVARCHARSQL_WLONGVARCHARSQL_C_WCHARSQLConnectWSQLDescribeColWSQLExecDirectWSQLGetDiagRecWSQLDriverConnectWSQLConnectASQLDescribeColASQLExecDirectASQLGetDiagRecASQLDriverConnectA//! This module defines the ODBC Core unicode functionsLPNLSVERSIONINFOCompareStringExCompareStringOrdinalCompareStringWFoldStringWGetStringTypeExWGetStringTypeWMultiByteToWideCharWideCharToMultiBytePOLD_LARGE_INTEGEROLD_LARGE_INTEGERSAM_HANDLEPSAM_HANDLEUSER_ACCOUNT_DISABLEDUSER_HOME_DIRECTORY_REQUIREDUSER_PASSWORD_NOT_REQUIREDUSER_TEMP_DUPLICATE_ACCOUNTUSER_NORMAL_ACCOUNTUSER_MNS_LOGON_ACCOUNTUSER_INTERDOMAIN_TRUST_ACCOUNTUSER_WORKSTATION_TRUST_ACCOUNTUSER_SERVER_TRUST_ACCOUNTUSER_DONT_EXPIRE_PASSWORDUSER_ACCOUNT_AUTO_LOCKEDUSER_ENCRYPTED_TEXT_PASSWORD_ALLOWEDUSER_SMARTCARD_REQUIREDUSER_TRUSTED_FOR_DELEGATIONUSER_NOT_DELEGATEDUSER_USE_DES_KEY_ONLYUSER_DONT_REQUIRE_PREAUTHUSER_PASSWORD_EXPIREDUSER_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATIONUSER_NO_AUTH_DATA_REQUIREDUSER_PARTIAL_SECRETS_ACCOUNTUSER_USE_AES_KEYSNEXT_FREE_ACCOUNT_CONTROL_BITUSER_MACHINE_ACCOUNT_MASKUSER_ACCOUNT_TYPE_MASKUSER_COMPUTED_ACCOUNT_CONTROL_BITSSAM_DAYS_PER_WEEKSAM_HOURS_PER_WEEKSAM_MINUTES_PER_WEEKPLOGON_HOURSLOGON_HOURSPSR_SECURITY_DESCRIPTORSR_SECURITY_DESCRIPTORPUSER_ALL_INFORMATIONUSER_ALL_INFORMATIONUSER_ALL_PARAMETERSCLEAR_BLOCK_LENGTHPCLEAR_BLOCKCLEAR_BLOCKPCYPHER_BLOCKCYPHER_BLOCKLM_CHALLENGEPLM_CHALLENGENT_CHALLENGEPNT_CHALLENGEUSER_SESSION_KEY_LENGTHPUSER_SESSION_KEYUSER_SESSION_KEYPNETLOGON_LOGON_IDENTITY_INFONETLOGON_LOGON_IDENTITY_INFOPNETLOGON_INTERACTIVE_INFONETLOGON_INTERACTIVE_INFOPNETLOGON_SERVICE_INFONETLOGON_SERVICE_INFOPNETLOGON_NETWORK_INFONETLOGON_NETWORK_INFOPNETLOGON_GENERIC_INFONETLOGON_GENERIC_INFOMSV1_0_PASSTHRUMSV1_0_GUEST_LOGONPMSV1_0_VALIDATION_INFOMSV1_0_VALIDATION_INFOMSV1_0_VALIDATION_LOGOFF_TIMEMSV1_0_VALIDATION_KICKOFF_TIMEMSV1_0_VALIDATION_LOGON_SERVERMSV1_0_VALIDATION_LOGON_DOMAINMSV1_0_VALIDATION_SESSION_KEYMSV1_0_VALIDATION_USER_FLAGSMSV1_0_VALIDATION_USER_IDMSV1_0_SUBAUTH_ACCOUNT_DISABLEDMSV1_0_SUBAUTH_PASSWORDMSV1_0_SUBAUTH_WORKSTATIONSMSV1_0_SUBAUTH_LOGON_HOURSMSV1_0_SUBAUTH_ACCOUNT_EXPIRYMSV1_0_SUBAUTH_PASSWORD_EXPIRYMSV1_0_SUBAUTH_ACCOUNT_TYPEMSV1_0_SUBAUTH_LOCKOUT//! Types and macros for Subauthentication Packages.// STATUS_*PRTL_BARRIERPRTL_RUN_ONCERTL_BARRIERRTL_CONDITION_VARIABLERTL_CONDITION_VARIABLE_INITRTL_RUN_ONCERTL_SRWLOCKRTL_SRWLOCK_INITSRWLOCK_INITSRWLOCKPSRWLOCKInitializeSRWLockReleaseSRWLockExclusiveReleaseSRWLockSharedAcquireSRWLockExclusiveAcquireSRWLockSharedTryAcquireSRWLockExclusiveTryAcquireSRWLockSharedInitializeCriticalSectionEnterCriticalSectionLeaveCriticalSectionInitializeCriticalSectionAndSpinCountInitializeCriticalSectionExSetCriticalSectionSpinCountTryEnterCriticalSectionDeleteCriticalSectionINIT_ONCEPINIT_ONCELPINIT_ONCE//pub const INIT_ONCE_STATIC_INIT: INIT_ONCE = RTL_RUN_ONCE_INIT;//pub const INIT_ONCE_CHECK_ONLY: ULONG = RTL_RUN_ONCE_CHECK_ONLY;//pub const INIT_ONCE_ASYNC: ULONG = RTL_RUN_ONCE_ASYNC;//pub const INIT_ONCE_INIT_FAILED: ULONG = RTL_RUN_ONCE_INIT_FAILED;//pub const INIT_ONCE_CTX_RESERVED_BITS: usize = RTL_RUN_ONCE_CTX_RESERVED_BITS;InitOnceInitializeInitOnceExecuteOncePINIT_ONCE_FNInitOnceBeginInitializeInitOnceCompleteCONDITION_VARIABLEPCONDITION_VARIABLECONDITION_VARIABLE_INITInitializeConditionVariableWakeConditionVariableWakeAllConditionVariableSleepConditionVariableCSSleepConditionVariableSRWResetEventReleaseMutexSleepExWaitForSingleObjectExWaitForMultipleObjectsExCreateMutexACreateMutexWOpenMutexWCreateEventWOpenEventAOpenEventWOpenSemaphoreWOpenWaitableTimerWSetWaitableTimerExPTIMERAPCROUTINESetWaitableTimerCancelWaitableTimerCREATE_MUTEX_INITIAL_OWNERCreateMutexExACreateMutexExWCREATE_EVENT_MANUAL_RESETCREATE_EVENT_INITIAL_SETCreateEventExACreateEventExWCreateSemaphoreExWCREATE_WAITABLE_TIMER_MANUAL_RESETCreateWaitableTimerExWSYNCHRONIZATION_BARRIERPSYNCHRONIZATION_BARRIERLPSYNCHRONIZATION_BARRIERSYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLYSYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLYSYNCHRONIZATION_BARRIER_FLAGS_NO_DELETEEnterSynchronizationBarrierInitializeSynchronizationBarrierDeleteSynchronizationBarrierWakeByAddressAllSignalObjectAndWaitCreateSemaphoreWCreateWaitableTimerW//! ApiSet Contract for api-ms-win-core-synch-l1//pub const CONDITION_VARIABLE_LOCKMODE_SHARED: ULONG = RTL_CONDITION_VARIABLE_LOCKMODE_SHARED;//pub const MUTEX_MODIFY_STATE: DWORD = MUTANT_QUERY_STATE;//pub const MUTEX_ALL_ACCESS: DWORD = MUTANT_ALL_ACCESS;LOGICAL_PROCESSOR_RELATIONSHIPLPOSVERSIONINFOALPOSVERSIONINFOWPSYSTEM_LOGICAL_PROCESSOR_INFORMATIONPSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATIONLPMEMORYSTATUSEXGetSystemTimeGetSystemTimeAsFileTimeGetLocalTimeGetVersionSetLocalTimeGetTickCountGetSystemTimeAdjustmentGetSystemDirectoryAGetSystemDirectoryWGetWindowsDirectoryAGetWindowsDirectoryWGetSystemWindowsDirectoryAGetSystemWindowsDirectoryWGetComputerNameExACOMPUTER_NAME_FORMATSetComputerNameExWSetSystemTimeGetVersionExAGetVersionExWGetLogicalProcessorInformationGetSystemTimePreciseAsFileTimeGetProductInfoVerSetConditionMaskEnumSystemFirmwareTables// pub fn GetOsSafeBootMode();GetSystemFirmwareTableDnsHostnameToComputerNameExWGetPhysicallyInstalledSystemMemorySCEX2_ALT_NETBIOS_NAMESetComputerNameEx2WSetSystemTimeAdjustmentInstallELAMCertificateInfoGetProcessorSystemCycleTimeSetComputerNameA// pub fn GetOsManufacturingMode();// pub fn GetIntegratedDisplaySize();SetComputerNameWSetComputerNameExA//! ApiSet Contract for api-ms-win-core-sysinfo-l1.GetNumaHighestNodeNumberGetNumaNodeProcessorMaskExGetNumaProximityNodeExPTP_CALLBACK_ENVIRONPTP_CALLBACK_INSTANCEPTP_CLEANUP_GROUPPTP_IOPTP_POOLPTP_POOL_STACK_INFORMATIONPTP_SIMPLE_CALLBACKPTP_TIMERPTP_TIMER_CALLBACKPTP_WAITPTP_WAIT_CALLBACKPTP_WORKPTP_WORK_CALLBACKCreateThreadpoolSetThreadpoolThreadMaximumSetThreadpoolThreadMinimumSetThreadpoolStackInformationQueryThreadpoolStackInformationCloseThreadpoolCreateThreadpoolCleanupGroupCloseThreadpoolCleanupGroupMembersCloseThreadpoolCleanupGroupSetEventWhenCallbackReturnsReleaseSemaphoreWhenCallbackReturnsReleaseMutexWhenCallbackReturnsLeaveCriticalSectionWhenCallbackReturnsFreeLibraryWhenCallbackReturnsCallbackMayRunLongDisassociateCurrentThreadFromCallbackTrySubmitThreadpoolCallbackCreateThreadpoolWorkSubmitThreadpoolWorkWaitForThreadpoolWorkCallbacksCloseThreadpoolWorkCreateThreadpoolTimerSetThreadpoolTimerIsThreadpoolTimerSetWaitForThreadpoolTimerCallbacksCloseThreadpoolTimerCreateThreadpoolWaitSetThreadpoolWaitWaitForThreadpoolWaitCallbacksCloseThreadpoolWaitCreateThreadpoolIoPTP_WIN32_IO_CALLBACKStartThreadpoolIoCancelThreadpoolIoWaitForThreadpoolIoCallbacksCloseThreadpoolIoSetThreadpoolTimerExSetThreadpoolWaitEx//! ApiSet Contract for api-ms-win-core-threadpool-l1.WAITORTIMERCALLBACKQueueUserWorkItemCreateTimerQueueCreateTimerQueueTimerChangeTimerQueueTimerDeleteTimerQueueTimerDeleteTimerQueueExtimeGetTimetimeGetDevCapstimeBeginPeriodtimeEndPeriodTIME_ZONE_ID_INVALIDPTIME_ZONE_INFORMATIONLPTIME_ZONE_INFORMATIONPDYNAMIC_TIME_ZONE_INFORMATIONFileTimeToSystemTimeGetTimeZoneInformationSetTimeZoneInformationSetDynamicTimeZoneInformationGetDynamicTimeZoneInformationEnumDynamicTimeZoneInformationGetDynamicTimeZoneInformationEffectiveYearsSystemTimeToTzSpecificLocalTimeExTzSpecificLocalTimeToSystemTimeEx//! ApiSet Contract for api-ms-win-core-timezone-l1MAX_MODULE_NAME32CreateToolhelp32SnapshotTH32CS_SNAPHEAPLISTTH32CS_SNAPPROCESSTH32CS_SNAPTHREADTH32CS_SNAPMODULETH32CS_SNAPMODULE32TH32CS_SNAPALLTH32CS_INHERITPHEAPLIST32HEAPLIST32LPHEAPLIST32HF32_DEFAULTHF32_SHAREDHeap32ListFirstHeap32ListNextPHEAPENTRY32HEAPENTRY32LPHEAPENTRY32LF32_FIXEDLF32_FREELF32_MOVEABLEHeap32FirstHeap32NextToolhelp32ReadProcessMemoryPPROCESSENTRY32WPROCESSENTRY32WLPPROCESSENTRY32WProcess32FirstWProcess32NextWPPROCESSENTRY32PROCESSENTRY32LPPROCESSENTRY32Process32FirstProcess32NextPTHREADENTRY32THREADENTRY32LPTHREADENTRY32Thread32FirstThread32NextPMODULEENTRY32WLPMODULEENTRY32WModule32FirstWModule32NextWPMODULEENTRY32MODULEENTRY32LPMODULEENTRY32Module32FirstModule32Next//! WIN32 tool help functions, types, and definitionsIOleCommandTargetIOleCommandTargetVtblSTATURL_QUERYFLAG_ISCACHEDSTATURL_QUERYFLAG_NOURLSTATURL_QUERYFLAG_NOTITLESTATURL_QUERYFLAG_TOPLEVELSTATURLFLAG_ISCACHEDSTATURLFLAG_ISTOPLEVELLPENUMSTATURLIEnumSTATURLLPSTATURLSTATURLLPURLHISTORYSTGIUrlHistoryStgLPURLHISTORYSTG2IUrlHistoryStg2LPURLHISTORYNOTIFYIUrlHistoryNotify//! Url History Interfaces//! URL Moniker interfaces// TODO: the restUnloadUserProfile// pub fn LoadUserProfileA(//     hToken: HANDLE,//     lpProfileInfo: LPPROFILEINFOA,// ) -> BOOL;// pub fn LoadUserProfileW(//     lpProfileInfo: LPPROFILEINFOW,GetProfilesDirectoryAGetProfilesDirectoryWGetProfileTypeDeleteProfileADeleteProfileWCreateProfileGetDefaultUserProfileDirectoryAGetDefaultUserProfileDirectoryWGetAllUsersProfileDirectoryAGetAllUsersProfileDirectoryWGetUserProfileDirectoryAExpandEnvironmentStringsForUserAExpandEnvironmentStringsForUserWRefreshPolicyRefreshPolicyExEnterCriticalPolicySectionLeaveCriticalPolicySectionRegisterGPNotificationUnregisterGPNotificationCreateAppContainerProfile// pub fn GetGPOListA();// pub fn GetGPOListW();// pub fn FreeGPOListA();// pub fn FreeGPOListW();// pub fn GetAppliedGPOListA();// pub fn GetAppliedGPOListW();// pub fn ProcessGroupPolicyCompleted();// pub fn ProcessGroupPolicyCompletedEx();// pub fn RsopAccessCheckByType();// pub fn RsopFileAccessCheck();// pub fn RsopSetPolicySettingStatus();// pub fn RsopResetPolicySettingStatus();// pub fn GenerateGPNotification();DeleteAppContainerProfileGetAppContainerRegistryLocationGetAppContainerFolderPathDeriveAppContainerSidFromAppContainerNameDeriveRestrictedAppContainerSidFromAppContainerSidAndRestrictedName//! Definitions for the user environment APISCRIPT_UNDEFINEDUSP_E_SCRIPT_NOT_IN_FONTScriptFreeCacheSCRIPT_CACHEScriptItemizeSCRIPT_CONTROLSCRIPT_STATESCRIPT_ITEMScriptLayoutSCRIPT_JUSTIFY_NONESCRIPT_JUSTIFY_ARABIC_BLANKSCRIPT_JUSTIFY_CHARACTERSCRIPT_JUSTIFY_RESERVED1SCRIPT_JUSTIFY_BLANKSCRIPT_JUSTIFY_RESERVED2SCRIPT_JUSTIFY_RESERVED3SCRIPT_JUSTIFY_ARABIC_NORMALSCRIPT_JUSTIFY_ARABIC_KASHIDASCRIPT_JUSTIFY_ARABIC_ALEFSCRIPT_JUSTIFY_ARABIC_HASCRIPT_JUSTIFY_ARABIC_RASCRIPT_JUSTIFY_ARABIC_BASCRIPT_JUSTIFY_ARABIC_BARASCRIPT_JUSTIFY_ARABIC_SEENSCRIPT_JUSTIFY_ARABIC_SEEN_MScriptShapeSCRIPT_ANALYSISSCRIPT_VISATTRScriptPlaceGOFFSETScriptTextOutScriptJustifyScriptBreakSCRIPT_LOGATTRScriptCPtoXScriptXtoCPScriptGetLogicalWidthsScriptApplyLogicalWidthSGCM_RTLScriptGetCMapScriptGetGlyphABCWidthScriptGetPropertiesSCRIPT_PROPERTIESScriptGetFontPropertiesSCRIPT_FONTPROPERTIESScriptCacheGetHeightSSA_PASSWORDSSA_TABSSA_CLIPSSA_FITSSA_DZWGSSA_FALLBACKSSA_BREAKSSA_GLYPHSSSA_RTLSSA_GCPSSA_HOTKEYSSA_METAFILESSA_LINKSSA_HIDEHOTKEYSSA_HOTKEYONLYSSA_FULLMEASURESSA_LPKANSIFALLBACKSSA_PIDXSSA_LAYOUTRTLSSA_DONTGLYPHSSA_NOKASHIDAScriptStringAnalyseSCRIPT_TABDEFSCRIPT_STRING_ANALYSISScriptStringFreeScriptString_pSizeScriptString_pcOutCharsScriptString_pLogAttrScriptStringGetOrderScriptStringCPtoXScriptStringXtoCPScriptStringGetLogicalWidthsScriptStringValidateScriptStringOutSIC_COMPLEXSIC_ASCIIDIGITSIC_NEUTRALScriptIsComplexScriptRecordDigitSubstitutionSCRIPT_DIGITSUBSTITUTESCRIPT_DIGITSUBSTITUTE_CONTEXTSCRIPT_DIGITSUBSTITUTE_NONESCRIPT_DIGITSUBSTITUTE_NATIONALSCRIPT_DIGITSUBSTITUTE_TRADITIONALScriptApplyDigitSubstitutionOPENTYPE_TAGSCRIPT_TAG_UNKNOWNScriptShapeOpenTypeTEXTRANGE_PROPERTIESSCRIPT_CHARPROPSCRIPT_GLYPHPROPScriptPlaceOpenTypeScriptItemizeOpenTypeScriptGetFontScriptTagsScriptGetFontLanguageTagsScriptGetFontFeatureTagsScriptGetFontAlternateGlyphsScriptSubstituteSingleGlyphScriptPositionSingleGlyph//! Unicode Complex Script processor API declarationsEncodePointerDecodePointerEncodeSystemPointerDecodeSystemPointerBeepBLENDFUNCTIONTEXTMETRICWHTHEMEBeginPanningFeedbackUpdatePanningFeedbackEndPanningFeedbackGetThemeAnimationPropertyTA_PROPERTYPTA_TRANSFORMTA_TRANSFORMPTA_TRANSFORM_2DTA_TRANSFORM_2DPTA_TRANSFORM_OPACITYTA_TRANSFORM_OPACITYPTA_TRANSFORM_CLIPTA_TRANSFORM_CLIPGetThemeAnimationTransformPTA_TIMINGFUNCTIONTA_TIMINGFUNCTIONPTA_CUBIC_BEZIERTA_CUBIC_BEZIERGetThemeTimingFunctionOpenThemeDataOTD_FORCE_RECT_SIZINGOTD_NONCLIENTOTD_VALIDBITSOpenThemeDataForDpiOpenThemeDataExCloseThemeDataDrawThemeBackgroundDTBG_CLIPRECTDTBG_DRAWSOLIDDTBG_OMITBORDERDTBG_OMITCONTENTDTBG_COMPUTINGREGIONDTBG_MIRRORDCDTBG_NOMIRRORDTBG_VALIDBITSPDTBGOPTSDTBGOPTSDrawThemeBackgroundExDrawThemeTextGetThemeBackgroundContentRectGetThemeBackgroundExtentGetThemeBackgroundRegionGetThemePartSizeTHEMESIZEGetThemeTextExtentGetThemeTextMetricsHTTB_BACKGROUNDSEGHTTB_FIXEDBORDERHTTB_CAPTIONHTTB_RESIZINGBORDER_LEFTHTTB_RESIZINGBORDER_TOPHTTB_RESIZINGBORDER_RIGHTHTTB_RESIZINGBORDER_BOTTOMHTTB_RESIZINGBORDERHTTB_SIZINGTEMPLATEHTTB_SYSTEMSIZINGMARGINSHitTestThemeBackgroundDrawThemeEdgeDrawThemeIconIsThemePartDefinedIsThemeBackgroundPartiallyTransparentGetThemeColorGetThemeMetricGetThemeStringGetThemeBoolGetThemeIntGetThemeEnumValueGetThemePositionGetThemeFontGetThemeRectPMARGINSGetThemeMarginsMAX_INTLIST_COUNTPINTLISTINTLISTGetThemeIntListGetThemePropertyOriginPROPERTYORIGINSetWindowThemeGetThemeFilenameGetThemeSysColorGetThemeSysColorBrushGetThemeSysBoolGetThemeSysSizeGetThemeSysFontGetThemeSysStringGetThemeSysIntIsThemeActiveIsAppThemedGetWindowThemeETDT_DISABLEETDT_ENABLEETDT_USETABTEXTUREETDT_ENABLETABETDT_USEAEROWIZARDTABTEXTUREETDT_ENABLEAEROWIZARDTABETDT_VALIDBITSEnableThemeDialogTextureIsThemeDialogTextureEnabledSTAP_ALLOW_NONCLIENTSTAP_ALLOW_CONTROLSSTAP_ALLOW_WEBCONTENTSTAP_VALIDBITSGetThemeAppPropertiesSetThemeAppPropertiesGetCurrentThemeNameSZ_THDOCPROP_DISPLAYNAMESZ_THDOCPROP_CANONICALNAMESZ_THDOCPROP_TOOLTIPSZ_THDOCPROP_AUTHORGetThemeDocumentationPropertyDrawThemeParentBackgroundEnableThemingGBF_DIRECTGBF_COPYGBF_VALIDBITSDTPB_WINDOWDCDTPB_USECTLCOLORSTATICDTPB_USEERASEBKGNDDrawThemeParentBackgroundExPWTA_OPTIONSWTA_OPTIONSWTNCA_NODRAWCAPTIONWTNCA_NODRAWICONWTNCA_NOSYSMENUWTNCA_NOMIRRORHELPWTNCA_VALIDBITSSetWindowThemeAttributeWINDOWTHEMEATTRIBUTETYPESetWindowThemeNonClientAttributesDTT_TEXTCOLORDTT_BORDERCOLORDTT_SHADOWCOLORDTT_SHADOWTYPEDTT_SHADOWOFFSETDTT_BORDERSIZEDTT_FONTPROPDTT_COLORPROPDTT_STATEIDDTT_CALCRECTDTT_APPLYOVERLAYDTT_GLOWSIZEDTT_CALLBACKDTT_COMPOSITEDDTT_VALIDBITSPDTTOPTSDTTOPTSDrawThemeTextExGetThemeBitmapGetThemeStreamBufferedPaintInitBufferedPaintUnInitHPAINTBUFFERBPBF_COMPOSITEDBP_BUFFERFORMATPBP_ANIMATIONPARAMSBP_ANIMATIONPARAMSBPPF_ERASEBPPF_NOCLIPBPPF_NONCLIENTPBP_PAINTPARAMSBP_PAINTPARAMSBeginBufferedPaintEndBufferedPaintGetBufferedPaintTargetRectGetBufferedPaintTargetDCGetBufferedPaintDCGetBufferedPaintBitsBufferedPaintClearBufferedPaintSetAlphaBufferedPaintStopAllAnimationsHANIMATIONBUFFERBeginBufferedAnimationEndBufferedAnimationBufferedPaintRenderAnimationIsCompositionActiveGetThemeTransitionDuration//! theming API//pub const MAX_THEMECOLOR: u32 = 64;//pub const MAX_THEMESIZE: u32 = 64;//pub const DTT_GRAYED: u32 = 0x00000001;//pub const DTT_FLAGS2VALIDBITS: u32 = DTT_GRAYED;IVssAsyncIVssEnumObjectVSS_BACKUP_TYPEVSS_IDVSS_OBJECT_TYPEVSS_PWSZVSS_RESTORE_TYPEVSS_ROLLFORWARD_TYPEVSS_SNAPSHOT_PROPVSS_WRITER_STATEIVssWMDependencyIVssWMFiledescIVssWriterComponentsVtblVSS_COMPONENT_TYPEVSS_FILE_RESTORE_STATUSVSS_RESTOREMETHOD_ENUMVSS_SOURCE_TYPEVSS_USAGE_TYPEVSS_WRITERRESTORE_ENUMPVSSCOMPONENTINFOVSS_COMPONENTINFOlpVtblIVssWriterComponentsExtVtblIVssWriterComponentsExtVSS_SW_BOOTABLE_STATE"CreateVssBackupComponentsInternal"CreateVssBackupComponentsIVssBackupComponents"CreateVssExamineWriterMetadataInternal"CreateVssExamineWriterMetadataIVssExamineWriterMetadata"IsVolumeSnapshottedInternal"IsVolumeSnapshotted"VssFreeSnapshotPropertiesInternal"VssFreeSnapshotProperties"GetProviderMgmtInterfaceInternal"GetProviderMgmtInterface"ShouldBlockRevertInternal"ShouldBlockRevert//! Declaration of backup interfaces.PVSS_OBJECT_TYPEPVSS_SNAPSHOT_STATEVSS_SNAPSHOT_STATEPVSS_VOLUME_SNAPSHOT_ATTRIBUTESVSS_VOLUME_SNAPSHOT_ATTRIBUTESPVSS_SNAPSHOT_CONTEXTVSS_SNAPSHOT_CONTEXTPVSS_PROVIDER_CAPABILITIESVSS_PROVIDER_CAPABILITIESPVSS_HARDWARE_OPTIONSVSS_HARDWARE_OPTIONSPVSS_RECOVERY_OPTIONSVSS_RECOVERY_OPTIONSPVSS_WRITER_STATEPVSS_BACKUP_TYPEPVSS_RESTORE_TYPEPVSS_ROLLFORWARD_TYPEPVSS_PROVIDER_TYPEVSS_PROVIDER_TYPEPVSS_APPLICATION_LEVELVSS_APPLICATION_LEVELPVSS_SNAPSHOT_PROPERTY_IDVSS_SNAPSHOT_PROPERTY_IDPVSS_FILE_SPEC_BACKUP_TYPEVSS_FILE_SPEC_BACKUP_TYPEPVSS_BACKUP_SCHEMAVSS_BACKUP_SCHEMAVSS_TIMESTAMPPVSS_SNAPSHOT_PROPPVSS_PROVIDER_PROPVSS_PROVIDER_PROPPVSS_OBJECT_PROPVSS_OBJECT_PROP//! VSS header fileVSS_E_BAD_STATEVSS_E_UNEXPECTEDVSS_E_PROVIDER_ALREADY_REGISTEREDVSS_E_PROVIDER_NOT_REGISTEREDVSS_E_PROVIDER_VETOVSS_E_PROVIDER_IN_USEVSS_E_OBJECT_NOT_FOUNDVSS_S_ASYNC_PENDINGVSS_S_ASYNC_FINISHEDVSS_S_ASYNC_CANCELLEDVSS_E_VOLUME_NOT_SUPPORTEDVSS_E_VOLUME_NOT_SUPPORTED_BY_PROVIDERVSS_E_OBJECT_ALREADY_EXISTSVSS_E_UNEXPECTED_PROVIDER_ERRORVSS_E_CORRUPT_XML_DOCUMENTVSS_E_INVALID_XML_DOCUMENTVSS_E_MAXIMUM_NUMBER_OF_VOLUMES_REACHEDVSS_E_FLUSH_WRITES_TIMEOUTVSS_E_HOLD_WRITES_TIMEOUTVSS_E_UNEXPECTED_WRITER_ERRORVSS_E_SNAPSHOT_SET_IN_PROGRESSVSS_E_MAXIMUM_NUMBER_OF_SNAPSHOTS_REACHEDVSS_E_WRITER_INFRASTRUCTUREVSS_E_WRITER_NOT_RESPONDINGVSS_E_WRITER_ALREADY_SUBSCRIBEDVSS_E_UNSUPPORTED_CONTEXTVSS_E_VOLUME_IN_USEVSS_E_MAXIMUM_DIFFAREA_ASSOCIATIONS_REACHEDVSS_E_INSUFFICIENT_STORAGEVSS_E_NO_SNAPSHOTS_IMPORTEDVSS_S_SOME_SNAPSHOTS_NOT_IMPORTEDVSS_E_SOME_SNAPSHOTS_NOT_IMPORTEDVSS_E_MAXIMUM_NUMBER_OF_REMOTE_MACHINES_REACHEDVSS_E_REMOTE_SERVER_UNAVAILABLEVSS_E_REMOTE_SERVER_UNSUPPORTEDVSS_E_REVERT_IN_PROGRESSVSS_E_REVERT_VOLUME_LOSTVSS_E_REBOOT_REQUIREDVSS_E_TRANSACTION_FREEZE_TIMEOUTVSS_E_TRANSACTION_THAW_TIMEOUTVSS_E_VOLUME_NOT_LOCALVSS_E_CLUSTER_TIMEOUTVSS_E_WRITERERROR_INCONSISTENTSNAPSHOTVSS_E_WRITERERROR_OUTOFRESOURCESVSS_E_WRITERERROR_TIMEOUTVSS_E_WRITERERROR_RETRYABLEVSS_E_WRITERERROR_NONRETRYABLEVSS_E_WRITERERROR_RECOVERY_FAILEDVSS_E_BREAK_REVERT_ID_FAILEDVSS_E_LEGACY_PROVIDERVSS_E_MISSING_DISKVSS_E_MISSING_HIDDEN_VOLUMEVSS_E_MISSING_VOLUMEVSS_E_AUTORECOVERY_FAILEDVSS_E_DYNAMIC_DISK_ERRORVSS_E_NONTRANSPORTABLE_BCDVSS_E_CANNOT_REVERT_DISKIDVSS_E_RESYNC_IN_PROGRESSVSS_E_CLUSTER_ERRORVSS_E_UNSELECTED_VOLUMEVSS_E_SNAPSHOT_NOT_IN_SETVSS_E_NESTED_VOLUME_LIMITVSS_E_NOT_SUPPORTEDVSS_E_WRITERERROR_PARTIAL_FAILUREVSS_E_ASRERROR_DISK_ASSIGNMENT_FAILEDVSS_E_ASRERROR_DISK_RECREATION_FAILEDVSS_E_ASRERROR_NO_ARCPATHVSS_E_ASRERROR_MISSING_DYNDISKVSS_E_ASRERROR_SHARED_CRIDISKVSS_E_ASRERROR_DATADISK_RDISK0VSS_E_ASRERROR_RDISK0_TOOSMALLVSS_E_ASRERROR_CRITICAL_DISKS_TOO_SMALLVSS_E_WRITER_STATUS_NOT_AVAILABLEVSS_E_ASRERROR_DYNAMIC_VHD_NOT_SUPPORTEDVSS_E_CRITICAL_VOLUME_ON_INVALID_DISKVSS_E_ASRERROR_RDISK_FOR_SYSTEM_DISK_NOT_FOUNDVSS_E_ASRERROR_NO_PHYSICAL_DISK_AVAILABLEVSS_E_ASRERROR_FIXED_PHYSICAL_DISK_AVAILABLE_AFTER_DISK_EXCLUSIONVSS_E_ASRERROR_CRITICAL_DISK_CANNOT_BE_EXCLUDEDVSS_E_ASRERROR_SYSTEM_PARTITION_HIDDENVSS_E_FSS_TIMEOUT//! VSS Error header file//! Declaration of Writer//IVssCreateWriterMetadataEx//IVssWriterImpl//IVssCreateExpressWriterMetadata//IVssExpressWriter//CVssWriter//CVssWriterEx//CVssWriterEx2ISWbemObjectISWbemServices// extern RPC_IF_HANDLE __MIDL_itf_wbemads_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemads_0000_0000_v0_0_s_ifspec;// EXTERN_C const IID LIBID_WMIEXTENSIONLib;// EXTERN_C const IID IID_IWMIExtension;// class DECLSPEC_UUID("f0975afe-5c7f-11d2-8b74-00104b2afb41")// WMIExtension;// extern RPC_IF_HANDLE __MIDL_itf_wbemads_0000_0002_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemads_0000_0002_v0_0_s_ifspec;// unsigned long             __RPC_USER  BSTR_UserSize( __RPC__in unsigned long *, unsigned long            , __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void                      __RPC_USER  BSTR_UserFree( __RPC__in unsigned long *, __RPC__in BSTR * );// unsigned long             __RPC_USER  BSTR_UserSize64( __RPC__in unsigned long *, unsigned long            , __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void                      __RPC_USER  BSTR_UserFree64( __RPC__in unsigned long *, __RPC__in BSTR * );// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0000_v0_0_s_ifspec;CIMTYPE// EXTERN_C const IID LIBID_WbemClient_v1;// EXTERN_C const IID IID_IWbemClassObject;// EXTERN_C const IID IID_IWbemObjectAccess;// EXTERN_C const IID IID_IWbemQualifierSet;// EXTERN_C const IID IID_IWbemServices;// EXTERN_C const IID IID_IWbemLocator;// EXTERN_C const IID IID_IWbemObjectSink;// EXTERN_C const IID IID_IEnumWbemClassObject;// EXTERN_C const IID IID_IWbemCallResult;// EXTERN_C const IID IID_IWbemContext;// EXTERN_C const IID IID_IUnsecuredApartment;// EXTERN_C const IID IID_IWbemUnsecuredApartment;// EXTERN_C const IID IID_IWbemStatusCodeText;// EXTERN_C const IID IID_IWbemBackupRestore;// EXTERN_C const IID IID_IWbemBackupRestoreEx;// EXTERN_C const IID IID_IWbemRefresher;// EXTERN_C const IID IID_IWbemHiPerfEnum;// EXTERN_C const IID IID_IWbemConfigureRefresher;// class DECLSPEC_UUID("674B6698-EE92-11d0-AD71-00C04FD8FDFF")// WbemContext;// class DECLSPEC_UUID("49bd2028-1523-11d1-ad79-00c04fd8fdff")// UnsecuredApartment;// class DECLSPEC_UUID("9A653086-174F-11d2-B5F9-00104B703EFD")// WbemClassObject;// class DECLSPEC_UUID("6daf9757-2e37-11d2-aec9-00c04fb68820")// MofCompiler;// class DECLSPEC_UUID("eb87e1bd-3233-11d2-aec9-00c04fb68820")// WbemStatusCodeText;// class DECLSPEC_UUID("C49E32C6-BC8B-11d2-85D4-00105A1F8304")// WbemBackupRestore;// class DECLSPEC_UUID("c71566f2-561e-11d1-ad87-00c04fd8fdff")// WbemRefresher;// class DECLSPEC_UUID("8D1C559D-84F0-4bb3-A7D5-56A7435A9BA6")// WbemObjectTextSrc;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0001_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0001_v0_0_s_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0003_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0003_v0_0_s_ifspec;// EXTERN_C const IID IID_IWbemObjectSinkEx;// EXTERN_C const IID IID_IWbemShutdown;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0011_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0011_v0_0_s_ifspec;// EXTERN_C const IID IID_IWbemObjectTextSrc;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0013_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0013_v0_0_s_ifspec;// EXTERN_C const IID IID_IMofCompiler;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0015_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0015_v0_0_s_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0016_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0016_v0_0_s_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0022_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemcli_0000_0022_v0_0_s_ifspec;// unsigned c_long             __RPC_USER  BSTR_UserSize( __RPC__in unsigned c_long *, unsigned c_long            , __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserMarshal( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserUnmarshal(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void                      __RPC_USER  BSTR_UserFree( __RPC__in unsigned c_long *, __RPC__in BSTR * );// unsigned c_long             __RPC_USER  VARIANT_UserSize( __RPC__in unsigned c_long *, unsigned c_long            , __RPC__in VARIANT * );// unsigned char * __RPC_USER  VARIANT_UserMarshal( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in VARIANT * );// unsigned char * __RPC_USER  VARIANT_UserUnmarshal(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out VARIANT * );// void                      __RPC_USER  VARIANT_UserFree( __RPC__in unsigned c_long *, __RPC__in VARIANT * );// unsigned c_long             __RPC_USER  BSTR_UserSize64( __RPC__in unsigned c_long *, unsigned c_long            , __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserMarshal64( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER  BSTR_UserUnmarshal64(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void                      __RPC_USER  BSTR_UserFree64( __RPC__in unsigned c_long *, __RPC__in BSTR * );// unsigned c_long             __RPC_USER  VARIANT_UserSize64( __RPC__in unsigned c_long *, unsigned c_long            , __RPC__in VARIANT * );// unsigned char * __RPC_USER  VARIANT_UserMarshal64( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in VARIANT * );// unsigned char * __RPC_USER  VARIANT_UserUnmarshal64(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out VARIANT * );// void                      __RPC_USER  VARIANT_UserFree64( __RPC__in unsigned c_long *, __RPC__in VARIANT * );// extern RPC_IF_HANDLE __MIDL_itf_wbemdisp_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemdisp_0000_0000_v0_0_s_ifspec;// EXTERN_C const IID LIBID_WbemScripting;// EXTERN_C const IID IID_ISWbemServices;// EXTERN_C const IID IID_ISWbemLocator;WBEMS_DISPID_DERIVATION// EXTERN_C const IID IID_ISWbemObject;// EXTERN_C const IID IID_ISWbemObjectSet;// EXTERN_C const IID IID_ISWbemNamedValue;// EXTERN_C const IID IID_ISWbemNamedValueSet;// EXTERN_C const IID IID_ISWbemQualifier;// EXTERN_C const IID IID_ISWbemQualifierSet;// EXTERN_C const IID IID_ISWbemProperty;// EXTERN_C const IID IID_ISWbemPropertySet;// EXTERN_C const IID IID_ISWbemMethod;// EXTERN_C const IID IID_ISWbemMethodSet;// EXTERN_C const IID IID_ISWbemEventSource;// EXTERN_C const IID IID_ISWbemObjectPath;// EXTERN_C const IID IID_ISWbemLastError;// EXTERN_C const IID DIID_ISWbemSinkEvents;// EXTERN_C const IID IID_ISWbemSink;// EXTERN_C const IID IID_ISWbemSecurity;// EXTERN_C const IID IID_ISWbemPrivilege;// EXTERN_C const IID IID_ISWbemPrivilegeSet;// EXTERN_C const IID IID_ISWbemServicesEx;// EXTERN_C const IID IID_ISWbemObjectEx;// EXTERN_C const IID IID_ISWbemDateTime;// EXTERN_C const IID IID_ISWbemRefresher;// EXTERN_C const IID IID_ISWbemRefreshableItem;// class DECLSPEC_UUID("76A64158-CB41-11d1-8B02-00600806D9B6")// SWbemLocator;// class DECLSPEC_UUID("9AED384E-CE8B-11d1-8B05-00600806D9B6")// SWbemNamedValueSet;// class DECLSPEC_UUID("5791BC26-CE9C-11d1-97BF-0000F81E849C")// SWbemObjectPath;// class DECLSPEC_UUID("C2FEEEAC-CFCD-11d1-8B05-00600806D9B6")// SWbemLastError;// class DECLSPEC_UUID("75718C9A-F029-11d1-A1AC-00C04FB6C223")// SWbemSink;// class DECLSPEC_UUID("47DFBE54-CF76-11d3-B38F-00105A1F473A")// SWbemDateTime;// class DECLSPEC_UUID("D269BF5C-D9C1-11d3-B38F-00105A1F473A")// SWbemRefresher;// class DECLSPEC_UUID("04B83D63-21AE-11d2-8B33-00600806D9B6")// SWbemServices;// class DECLSPEC_UUID("62E522DC-8CF3-40a8-8B2E-37D595651E40")// SWbemServicesEx;// class DECLSPEC_UUID("04B83D62-21AE-11d2-8B33-00600806D9B6")// SWbemObject;// class DECLSPEC_UUID("D6BDAFB2-9435-491f-BB87-6AA0F0BC31A2")// SWbemObjectEx;// class DECLSPEC_UUID("04B83D61-21AE-11d2-8B33-00600806D9B6")// SWbemObjectSet;// class DECLSPEC_UUID("04B83D60-21AE-11d2-8B33-00600806D9B6")// SWbemNamedValue;// class DECLSPEC_UUID("04B83D5F-21AE-11d2-8B33-00600806D9B6")// SWbemQualifier;// class DECLSPEC_UUID("04B83D5E-21AE-11d2-8B33-00600806D9B6")// SWbemQualifierSet;// class DECLSPEC_UUID("04B83D5D-21AE-11d2-8B33-00600806D9B6")// SWbemProperty;// class DECLSPEC_UUID("04B83D5C-21AE-11d2-8B33-00600806D9B6")// SWbemPropertySet;// class DECLSPEC_UUID("04B83D5B-21AE-11d2-8B33-00600806D9B6")// SWbemMethod;// class DECLSPEC_UUID("04B83D5A-21AE-11d2-8B33-00600806D9B6")// SWbemMethodSet;// class DECLSPEC_UUID("04B83D58-21AE-11d2-8B33-00600806D9B6")// SWbemEventSource;// class DECLSPEC_UUID("B54D66E9-2287-11d2-8B33-00600806D9B6")// SWbemSecurity;// class DECLSPEC_UUID("26EE67BC-5804-11d2-8B4A-00600806D9B6")// SWbemPrivilege;// class DECLSPEC_UUID("26EE67BE-5804-11d2-8B4A-00600806D9B6")// SWbemPrivilegeSet;WBEMS_DISPID_OBJECT_READY// class DECLSPEC_UUID("8C6854BC-DE4B-11d3-B390-00105A1F473A")// SWbemRefreshableItem;WBEMS_DISPID_COMPLETEDWBEMS_DISPID_PROGRESSWBEMS_DISPID_OBJECT_PUTWBEMS_DISPID_CONNECTION_READY// extern RPC_IF_HANDLE __MIDL_itf_wbemdisp_0000_0018_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemdisp_0000_0018_v0_0_s_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemdisp_0000_0026_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemdisp_0000_0026_v0_0_s_ifspec;IWbemClassObjectIWbemContextIWbemHiPerfEnumIWbemObjectAccessIWbemObjectSinkIWbemObjectSinkVtblIWbemRefresherWBEM_VARIANTWBEM_WSTRWBEM_CWSTR// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0000_v0_0_s_ifspec;// EXTERN_C const IID LIBID_WbemProviders_v1;// EXTERN_C const IID IID_IWbemPropertyProvider;// EXTERN_C const IID IID_IWbemUnboundObjectSink;// EXTERN_C const IID IID_IWbemEventProvider;// EXTERN_C const IID IID_IWbemEventProviderQuerySink;// EXTERN_C const IID IID_IWbemEventProviderSecurity;// EXTERN_C const IID IID_IWbemEventConsumerProvider;// EXTERN_C const IID IID_IWbemProviderInitSink;// EXTERN_C const IID IID_IWbemProviderInit;// EXTERN_C const IID IID_IWbemHiPerfProvider;// EXTERN_C const IID IID_IWbemDecoupledRegistrar;// class DECLSPEC_UUID("cb8555cc-9128-11d1-ad9b-00c04fd8fdff")// WbemAdministrativeLocator;// class DECLSPEC_UUID("cd184336-9128-11d1-ad9b-00c04fd8fdff")// WbemAuthenticatedLocator;// class DECLSPEC_UUID("443E7B79-DE31-11d2-B340-00104BCC4B4A")// WbemUnauthenticatedLocator;// class DECLSPEC_UUID("4cfc7932-0f9d-4bef-9c32-8ea2a6b56fcb")// WbemDecoupledRegistrar;// class DECLSPEC_UUID("f5f75737-2843-4f22-933d-c76a97cda62f")// WbemDecoupledBasicEventProvider;// EXTERN_C const IID IID_IWbemProviderIdentity;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0008_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0008_v0_0_s_ifspec;// EXTERN_C const IID IID_IWbemDecoupledBasicEventProvider;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0013_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0013_v0_0_s_ifspec;// EXTERN_C const IID IID_IWbemEventSink;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0014_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemprov_0000_0014_v0_0_s_ifspec;// unsigned c_long __RPC_USER BSTR_UserSize( __RPC__in unsigned c_long *, unsigned c_long, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserMarshal( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserUnmarshal(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void __RPC_USER BSTR_UserFree( __RPC__in unsigned c_long *, __RPC__in BSTR * );// unsigned c_long __RPC_USER VARIANT_UserSize( __RPC__in unsigned c_long *, unsigned c_long, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserMarshal( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserUnmarshal(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out VARIANT * );// void __RPC_USER VARIANT_UserFree( __RPC__in unsigned c_long *, __RPC__in VARIANT * );// unsigned c_long __RPC_USER BSTR_UserSize64( __RPC__in unsigned c_long *, unsigned c_long, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserMarshal64( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );// unsigned char * __RPC_USER BSTR_UserUnmarshal64(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );// void __RPC_USER BSTR_UserFree64( __RPC__in unsigned c_long *, __RPC__in BSTR * );// unsigned c_long __RPC_USER VARIANT_UserSize64( __RPC__in unsigned c_long *, unsigned c_long, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserMarshal64( __RPC__in unsigned c_long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in VARIANT * );// unsigned char * __RPC_USER VARIANT_UserUnmarshal64(__RPC__in unsigned c_long *, __RPC__in_xcount(0) unsigned char *, __RPC__out VARIANT * );// void __RPC_USER VARIANT_UserFree64( __RPC__in unsigned c_long *, __RPC__in VARIANT * );IWbemCallResult// extern RPC_IF_HANDLE __MIDL_itf_wbemtran_0000_0000_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemtran_0000_0000_v0_0_s_ifspec;WBEM_128BITS// EXTERN_C const IID LIBID_WbemTransports_v1;// EXTERN_C const IID IID_IWbemTransport;// EXTERN_C const IID IID_IWbemLevel1Login;// EXTERN_C const IID IID_IWbemConnectorLogin;// EXTERN_C const IID IID_IWbemAddressResolution;// class DECLSPEC_UUID("8BC3F05E-D86B-11d0-A075-00C04FB68820")// WbemLevel1Login;// class DECLSPEC_UUID("A1044801-8F7E-11d1-9E7C-00C04FC324A8")// WbemLocalAddrRes;// class DECLSPEC_UUID("7a0227f6-7108-11d1-ad90-00c04fd8fdff")// WbemUninitializedClassObject;// EXTERN_C const IID IID_IWbemClientTransport;// EXTERN_C const IID IID_IWbemClientConnectionTransport;// class DECLSPEC_UUID("F7CE2E13-8C90-11d1-9E7B-00C04FC324A8")// WbemDCOMTransport;// EXTERN_C const IID IID_IWbemConstructClassObject;// extern RPC_IF_HANDLE __MIDL_itf_wbemtran_0000_0008_v0_0_c_ifspec;// extern RPC_IF_HANDLE __MIDL_itf_wbemtran_0000_0008_v0_0_s_ifspec;WCT_MAX_NODE_COUNTWCT_OBJNAME_LENGTHPWAITCHAIN_NODE_INFOWAITCHAIN_NODE_INFOWCT_ASYNC_OPEN_FLAGWCTP_OPEN_ALL_FLAGSOpenThreadWaitChainSessionPWAITCHAINCALLBACKHWCTCloseThreadWaitChainSessionWCT_OUT_OF_PROC_FLAGWCT_OUT_OF_PROC_COM_FLAGWCT_OUT_OF_PROC_CS_FLAGWCT_NETWORK_IO_FLAGWCTP_GETINFO_ALL_FLAGSGetThreadWaitChainRegisterWaitChainCOMCallbackPCOGETCALLSTATEPCOGETACTIVATIONSTATEWER_FAULT_REPORTING_FLAG_NOHEAPWER_FAULT_REPORTING_FLAG_QUEUEWER_FAULT_REPORTING_FLAG_DISABLE_THREAD_SUSPENSIONWER_FAULT_REPORTING_FLAG_QUEUE_UPLOADWER_FAULT_REPORTING_ALWAYS_SHOW_UIWER_FAULT_REPORTING_NO_UIWER_FAULT_REPORTING_FLAG_NO_HEAP_ON_QUEUEWER_FAULT_REPORTING_DISABLE_SNAPSHOT_CRASHWER_FAULT_REPORTING_DISABLE_SNAPSHOT_HANGWER_FAULT_REPORTING_CRITICALWER_FAULT_REPORTING_DURABLEWerRegisterFileWER_REGISTER_FILE_TYPEWerUnregisterFileWerRegisterMemoryBlockWerUnregisterMemoryBlockWerSetFlagsWerGetFlagsWerAddExcludedApplicationWerRemoveExcludedApplicationWerRegisterRuntimeExceptionModuleWerUnregisterRuntimeExceptionModule//! Function prototypes for Windows Error Reporting (WER)LATENCY_TIMELPOSVERSIONINFOEXALPOSVERSIONINFOEXWPFIRMWARE_TYPEPIO_COUNTERSPJOB_SET_ARRAYPOWER_REQUEST_TYPEPPERFORMANCE_DATAPRTL_UMS_SCHEDULER_ENTRY_POINTPSECURE_MEMORY_CACHE_CALLBACKPSID_NAME_USEPWOW64_CONTEXTPWOW64_LDT_ENTRYRTL_UMS_THREAD_INFO_CLASSSecurityAnonymousSecurityDelegationSecurityIdentificationSecurityImpersonationTHREAD_BASE_PRIORITY_IDLETHREAD_BASE_PRIORITY_LOWRTTHREAD_BASE_PRIORITY_MAXTHREAD_BASE_PRIORITY_MINWOW64_CONTEXTPLDT_ENTRYFILE_BEGINFILE_CURRENTFILE_ENDWAIT_ABANDONED_0WAIT_IO_COMPLETIONFILE_FLAG_WRITE_THROUGHFILE_FLAG_NO_BUFFERINGFILE_FLAG_RANDOM_ACCESSFILE_FLAG_SEQUENTIAL_SCANFILE_FLAG_BACKUP_SEMANTICSFILE_FLAG_POSIX_SEMANTICSFILE_FLAG_SESSION_AWAREFILE_FLAG_OPEN_REPARSE_POINTFILE_FLAG_OPEN_NO_RECALLFILE_FLAG_OPEN_REQUIRING_OPLOCKPROGRESS_CONTINUEPROGRESS_CANCELPROGRESS_STOPPROGRESS_QUIETCALLBACK_CHUNK_FINISHEDCALLBACK_STREAM_SWITCHCOPY_FILE_FAIL_IF_EXISTSCOPY_FILE_RESTARTABLECOPY_FILE_OPEN_SOURCE_FOR_WRITECOPY_FILE_ALLOW_DECRYPTED_DESTINATIONCOPY_FILE_COPY_SYMLINKCOPY_FILE_NO_BUFFERINGCOPY_FILE_REQUEST_SECURITY_PRIVILEGESCOPY_FILE_RESUME_FROM_PAUSECOPY_FILE_NO_OFFLOADCOPY_FILE_IGNORE_EDP_BLOCKCOPY_FILE_IGNORE_SOURCE_ENCRYPTIONREPLACEFILE_WRITE_THROUGHREPLACEFILE_IGNORE_MERGE_ERRORSREPLACEFILE_IGNORE_ACL_ERRORSPIPE_ACCESS_INBOUNDPIPE_ACCESS_OUTBOUNDPIPE_CLIENT_ENDPIPE_SERVER_ENDPIPE_WAITPIPE_NOWAITPIPE_READMODE_BYTEPIPE_READMODE_MESSAGEPIPE_TYPE_MESSAGEPIPE_ACCEPT_REMOTE_CLIENTSPIPE_REJECT_REMOTE_CLIENTSSECURITY_ANONYMOUSSECURITY_IDENTIFICATIONSECURITY_IMPERSONATIONSECURITY_DELEGATIONSECURITY_CONTEXT_TRACKINGSECURITY_EFFECTIVE_ONLYSECURITY_SQOS_PRESENTSECURITY_VALID_SQOS_FLAGSLPFIBER_START_ROUTINEPFIBER_START_ROUTINELPLDT_ENTRY// FAIL_FAST_*// TODO - fix this for 32-bit//SP_SERIALCOMM//PST_*// PCF_*// SP_*// BAUD_*// DATABITS_*// STOPBITS_*// PARITY_*COMMPROPCOMSTATDTR_CONTROL_DISABLEDTR_CONTROL_ENABLEDTR_CONTROL_HANDSHAKERTS_CONTROL_DISABLERTS_CONTROL_ENABLERTS_CONTROL_HANDSHAKERTS_CONTROL_TOGGLEDCBCOMMTIMEOUTSCOMMCONFIGGMEM_FIXEDGMEM_MOVEABLEGMEM_NOCOMPACTGMEM_NODISCARDGMEM_ZEROINITGMEM_MODIFYGMEM_DISCARDABLEGMEM_NOT_BANKEDGMEM_SHAREGMEM_DDESHAREGMEM_NOTIFYGMEM_LOWERGMEM_VALID_FLAGSGMEM_INVALID_HANDLEGPTRGMEM_DISCARDEDGMEM_LOCKCOUNTLPMEMORYSTATUSMEMORYSTATUSDEBUG_PROCESS// NUMA_NO_PREFERRED_NODEDEBUG_ONLY_THIS_PROCESSCREATE_SUSPENDEDDETACHED_PROCESSCREATE_NEW_CONSOLENORMAL_PRIORITY_CLASSIDLE_PRIORITY_CLASSHIGH_PRIORITY_CLASSREALTIME_PRIORITY_CLASSCREATE_NEW_PROCESS_GROUPCREATE_SEPARATE_WOW_VDMCREATE_SHARED_WOW_VDMCREATE_FORCEDOSBELOW_NORMAL_PRIORITY_CLASSABOVE_NORMAL_PRIORITY_CLASSINHERIT_PARENT_AFFINITYINHERIT_CALLER_PRIORITYCREATE_PROTECTED_PROCESSPROCESS_MODE_BACKGROUND_BEGINPROCESS_MODE_BACKGROUND_ENDCREATE_BREAKAWAY_FROM_JOBCREATE_PRESERVE_CODE_AUTHZ_LEVELCREATE_DEFAULT_ERROR_MODEPROFILE_USERPROFILE_KERNELPROFILE_SERVERCREATE_IGNORE_SYSTEM_DEFAULTTHREAD_PRIORITY_LOWEST// STACK_SIZE_PARAM_IS_A_RESERVATIONTHREAD_PRIORITY_BELOW_NORMALTHREAD_PRIORITY_NORMALTHREAD_PRIORITY_HIGHESTTHREAD_PRIORITY_ABOVE_NORMALTHREAD_PRIORITY_ERROR_RETURNTHREAD_PRIORITY_TIME_CRITICALTHREAD_PRIORITY_IDLETHREAD_MODE_BACKGROUND_BEGINTHREAD_MODE_BACKGROUND_ENDVOLUME_NAME_DOSDRIVE_UNKNOWN// VOLUME_NAME_*// FILE_NAME_*// JIT_DEBUG_*DRIVE_NO_ROOT_DIRDRIVE_REMOTEDRIVE_CDROMDRIVE_RAMDISKFILE_TYPE_UNKNOWN// pub fn GetFreeSpace();FILE_TYPE_REMOTENOPARITYODDPARITYEVENPARITYMARKPARITYSPACEPARITYONESTOPBITONE5STOPBITSTWOSTOPBITSCBR_110CBR_300CBR_600CBR_1200CBR_2400CBR_4800CBR_9600CBR_14400CBR_19200CBR_38400CBR_56000CBR_57600CBR_115200CBR_128000CBR_256000SETXOFF// CE_*// IE_*// EV_*SETXONSETRTSCLRRTSSETDTRCLRDTRRESETDEVSETBREAKCLRBREAKPURGE_TXABORTPURGE_RXABORTPURGE_TXCLEARPURGE_RXCLEARMS_CTS_ONMS_DSR_ONMS_RING_ONMS_RLSD_ONOFS_MAXPATHNAME// S_*// NMPWAIT_*// FS_*// OF_*POFSTRUCTOFSTRUCTLPOFSTRUCTGlobalReAllocGlobalSizeGlobalHandleGlobalFreeGlobalCompactGlobalFixGlobalUnfixGlobalWireGlobalUnWireGlobalMemoryStatusLocalReAllocLocalLockLocalUnlockLocalSizeLocalShrinkLocalCompactGetBinaryTypeAGetBinaryTypeWGetShortPathNameAGetLongPathNameTransactedAGetLongPathNameTransactedWGetProcessAffinityMaskSetProcessAffinityMaskGetProcessWorkingSetSizeSetProcessWorkingSetSizeFatalExitSetEnvironmentStringsASwitchToFiberDeleteFiberConvertFiberToThreadCreateFiberExConvertThreadToFiberExCreateFiberConvertThreadToFiberPUMS_CONTEXTPUMS_COMPLETION_LISTUMS_THREAD_INFO_CLASSPUMS_THREAD_INFO_CLASSPUMS_SCHEDULER_ENTRY_POINTPUMS_SCHEDULER_STARTUP_INFOUMS_SCHEDULER_STARTUP_INFOPUMS_SYSTEM_THREAD_INFORMATIONUMS_SYSTEM_THREAD_INFORMATIONCreateUmsCompletionListDequeueUmsCompletionListItemsGetUmsCompletionListEventExecuteUmsThreadUmsThreadYieldDeleteUmsCompletionListGetCurrentUmsThreadGetNextUmsListItemQueryUmsThreadInformationSetUmsThreadInformationDeleteUmsThreadContextCreateUmsThreadContextEnterUmsSchedulingModeGetUmsSystemThreadInformationSetThreadAffinityMaskSetProcessDEPPolicyGetProcessDEPPolicyRequestWakeupLatencyIsSystemResumeAutomaticGetThreadSelectorEntryPowerCreateRequestPowerSetRequestPowerClearRequestRestoreLastErrorFILE_SKIP_COMPLETION_PORT_ON_SUCCESSSEM_NOGPFAULTERRORBOXSEM_NOALIGNMENTFAULTEXCEPTSEM_NOOPENFILEERRORBOXWow64GetThreadContextWow64SetThreadContextWow64GetThreadSelectorEntryWow64SuspendThreadDebugSetProcessKillOnExitDebugBreakProcessPulseEventGlobalDeleteAtomInitAtomTableDeleteAtomSetHandleCountRequestDeviceWakeupCancelDeviceWakeupRequestGetDevicePowerStateSetMessageWaitingIndicatorSetFileShortNameASetFileShortNameWHANDLE_FLAG_PROTECT_FROM_CLOSELoadModuleWinExecSetTapePosition// ClearCommBreak// ClearCommError// SetupComm// EscapeCommFunction// GetCommConfig// GetCommMask// GetCommProperties// GetCommModemStatus// GetCommState// GetCommTimeouts// PurgeComm// SetCommBreak// SetCommConfig// SetCommMask// SetCommState// SetCommTimeouts// TransmitCommChar// WaitCommEventGetTapePositionPrepareTapeEraseTapeCreateTapePartitionWriteTapemarkGetTapeStatusGetTapeParametersSetTapeParametersGetSystemDEPPolicyDEP_SYSTEM_POLICY_TYPEGetSystemRegistryQuotaFileTimeToDosDateTimeDosDateTimeToFileTimeFormatMessageACreateMailslotACreateMailslotWGetMailslotInfoSetMailslotInfolstrcmpA// pub fn EncryptFileA();// pub fn EncryptFileW();// pub fn DecryptFileA();// pub fn DecryptFileW();// pub fn FileEncryptionStatusA();// pub fn FileEncryptionStatusW();// pub fn OpenEncryptedFileRawA();// pub fn OpenEncryptedFileRawW();// pub fn ReadEncryptedFileRaw();// pub fn WriteEncryptedFileRaw();// pub fn CloseEncryptedFileRaw();lstrcmpWlstrcmpiAlstrcmpiWlstrcpynAlstrcpynWlstrcpyAlstrcpyWlstrcatAlstrcatWlstrlenAOpenFile_lopen_lcreat_lread_lwrite_hread_hwrite_lclose_llseekBackupRead// pub fn IsTextUnicode();// pub fn SignalObjectAndWait();BackupSeekBackupWriteSTARTF_USESHOWWINDOW//2886STARTF_USESIZESTARTF_USEPOSITIONSTARTF_USECOUNTCHARSSTARTF_USEFILLATTRIBUTESTARTF_RUNFULLSCREENSTARTF_FORCEONFEEDBACKSTARTF_FORCEOFFFEEDBACKSTARTF_USEHOTKEYSTARTF_TITLEISLINKNAMESTARTF_TITLEISAPPIDSTARTF_PREVENTPINNINGSTARTF_UNTRUSTEDSOURCELPSTARTUPINFOEXASTARTUPINFOEXALPSTARTUPINFOEXWOpenMutexACreateWaitableTimerAOpenWaitableTimerACreateSemaphoreExACreateWaitableTimerExACreateFileMappingACreateFileMappingNumaAOpenFileMappingAGetLogicalDriveStringsALoadPackagedLibraryQueryFullProcessImageNameAQueryFullProcessImageNameWGetStartupInfoAGetFirmwareEnvironmentVariableAGetFirmwareEnvironmentVariableWGetFirmwareEnvironmentVariableExAGetFirmwareEnvironmentVariableExWSetFirmwareEnvironmentVariableASetFirmwareEnvironmentVariableWSetFirmwareEnvironmentVariableExASetFirmwareEnvironmentVariableExWGetFirmwareTypeIsNativeVhdBootFindResourceAFindResourceExAEnumResourceTypesAEnumResourceTypesWEnumResourceNamesAEnumResourceLanguagesAEnumResourceLanguagesWBeginUpdateResourceABeginUpdateResourceWUpdateResourceAUpdateResourceWEndUpdateResourceAEndUpdateResourceWGlobalAddAtomAGlobalAddAtomWGlobalAddAtomExAGlobalAddAtomExWGlobalFindAtomAGlobalFindAtomWGlobalGetAtomNameAGlobalGetAtomNameWAddAtomAAddAtomWFindAtomAFindAtomWGetAtomNameAGetAtomNameWGetProfileIntAGetProfileIntWGetProfileStringAGetProfileStringWWriteProfileStringAWriteProfileStringWGetProfileSectionAGetProfileSectionWWriteProfileSectionAWriteProfileSectionWGetPrivateProfileIntAGetPrivateProfileIntWGetPrivateProfileStringAGetPrivateProfileStringWWritePrivateProfileStringAWritePrivateProfileStringWGetPrivateProfileSectionAGetPrivateProfileSectionWWritePrivateProfileSectionAWritePrivateProfileSectionWGetPrivateProfileSectionNamesAGetPrivateProfileSectionNamesWGetPrivateProfileStructAGetPrivateProfileStructWWritePrivateProfileStructAWritePrivateProfileStructWWow64EnableWow64FsRedirectionSetDllDirectoryASetDllDirectoryWGetDllDirectoryAGetDllDirectoryWSetSearchPathModeCreateDirectoryExACreateDirectoryExWCreateDirectoryTransactedACreateDirectoryTransactedWRemoveDirectoryTransactedARemoveDirectoryTransactedWGetFullPathNameTransactedAGetFullPathNameTransactedWDefineDosDeviceAQueryDosDeviceACreateFileTransactedACreateFileTransactedWSetFileAttributesTransactedASetFileAttributesTransactedWGetFileAttributesTransactedAGetFileAttributesTransactedWGetCompressedFileSizeTransactedAGetCompressedFileSizeTransactedWDeleteFileTransactedADeleteFileTransactedWCheckNameLegalDOS8Dot3ACheckNameLegalDOS8Dot3WFindFirstFileTransactedAFindFirstFileTransactedWCopyFileACopyFileWCopyFileExALPPROGRESS_ROUTINECopyFileExWCopyFileTransactedACopyFileTransactedWCopyFile2COPYFILE2_EXTENDED_PARAMETERSMoveFileAMoveFileWMoveFileExAMoveFileWithProgressAMoveFileWithProgressWMoveFileTransactedAMoveFileTransactedWMOVEFILE_COPY_ALLOWEDMOVEFILE_DELAY_UNTIL_REBOOTMOVEFILE_WRITE_THROUGHMOVEFILE_CREATE_HARDLINKMOVEFILE_FAIL_IF_NOT_TRACKABLEReplaceFileAReplaceFileWCreateHardLinkACreateHardLinkWCreateHardLinkTransactedACreateHardLinkTransactedWFindFirstStreamTransactedWFindFirstFileNameTransactedWCreateNamedPipeAGetNamedPipeHandleStateACallNamedPipeAWaitNamedPipeAGetNamedPipeClientComputerNameAGetNamedPipeClientProcessIdGetNamedPipeClientSessionIdGetNamedPipeServerProcessIdGetNamedPipeServerSessionIdSetVolumeLabelASetVolumeLabelWSetFileBandwidthReservationGetFileBandwidthReservationDeregisterEventSource// pub fn ClearEventLogA();// pub fn ClearEventLogW();// pub fn BackupEventLogA();// pub fn BackupEventLogW();// pub fn CloseEventLog();RegisterEventSourceA// pub fn NotifyChangeEventLog();// pub fn GetNumberOfEventLogRecords();// pub fn GetOldestEventLogRecord();// pub fn OpenEventLogA();// pub fn OpenEventLogW();RegisterEventSourceWReportEventA// pub fn OpenBackupEventLogA();// pub fn OpenBackupEventLogW();// pub fn ReadEventLogA();// pub fn ReadEventLogW();ReportEventWReadDirectoryChangesW// pub fn GetEventLogInformation();// pub fn OperationStart();// pub fn OperationEnd();// pub fn AccessCheckAndAuditAlarmA();// pub fn AccessCheckByTypeAndAuditAlarmA();// pub fn AccessCheckByTypeResultListAndAuditAlarmA();// pub fn AccessCheckByTypeResultListAndAuditAlarmByHandleA();// pub fn ObjectOpenAuditAlarmA();// pub fn ObjectPrivilegeAuditAlarmA();// pub fn ObjectCloseAuditAlarmA();// pub fn ObjectDeleteAuditAlarmA();// pub fn PrivilegedServiceAuditAlarmA();// pub fn AddConditionalAce();// pub fn SetFileSecurityA();// pub fn GetFileSecurityA();MapViewOfFileExNumaIsBadReadPtrIsBadWritePtrIsBadHugeReadPtrIsBadHugeWritePtrIsBadCodePtrIsBadStringPtrAIsBadStringPtrWLookupAccountSidALookupAccountNameALookupAccountNameWLookupPrivilegeValueA// pub fn LookupAccountNameLocalA();// pub fn LookupAccountNameLocalW();// pub fn LookupAccountSidLocalA();// pub fn LookupAccountSidLocalW();LookupPrivilegeNameALookupPrivilegeNameWBuildCommDCBA// pub fn LookupPrivilegeDisplayNameA();// pub fn LookupPrivilegeDisplayNameW();BuildCommDCBWBuildCommDCBAndTimeoutsABuildCommDCBAndTimeoutsWCommConfigDialogACommConfigDialogWGetDefaultCommConfigAGetDefaultCommConfigWSetDefaultCommConfigASetDefaultCommConfigWGetComputerNameAGetComputerNameWDnsHostnameToComputerNameADnsHostnameToComputerNameWGetUserNameALOGON32_LOGON_INTERACTIVELOGON32_LOGON_NETWORKLOGON32_LOGON_BATCHLOGON32_LOGON_SERVICELOGON32_LOGON_UNLOCKLOGON32_LOGON_NETWORK_CLEARTEXTLOGON32_LOGON_NEW_CREDENTIALSLOGON32_PROVIDER_DEFAULTLOGON32_PROVIDER_WINNT35LOGON32_PROVIDER_WINNT40LOGON32_PROVIDER_WINNT50LOGON32_PROVIDER_VIRTUALLogonUserALogonUserWLogonUserExALogonUserExWLOGON_WITH_PROFILELOGON_NETCREDENTIALS_ONLYCreateProcessWithLogonWCreateProcessWithTokenWIsTokenUntrustedBindIoCompletionCallbackSetTimerQueueTimerCancelTimerQueueTimerDeleteTimerQueueCreatePrivateNamespaceA// pub fn InitializeThreadpoolEnvironment();// pub fn SetThreadpoolCallbackPool();// pub fn SetThreadpoolCallbackCleanupGroup();// pub fn SetThreadpoolCallbackRunsLong();// pub fn SetThreadpoolCallbackLibrary();// pub fn SetThreadpoolCallbackPriority();// pub fn DestroyThreadpoolEnvironment();// pub fn SetThreadpoolCallbackPersistent();OpenPrivateNamespaceACreateBoundaryDescriptorAAddIntegrityLabelToBoundaryDescriptorHW_PROFILE_GUIDLENDOCKINFO_UNDOCKED// MAX_PROFILE_LENDOCKINFO_DOCKEDDOCKINFO_USER_SUPPLIEDDOCKINFO_USER_UNDOCKEDDOCKINFO_USER_DOCKEDLPHW_PROFILE_INFOAHW_PROFILE_INFOALPHW_PROFILE_INFOWHW_PROFILE_INFOWGetCurrentHwProfileAGetCurrentHwProfileWVerifyVersionInfoAVerifyVersionInfoWLPSYSTEM_POWER_STATUSSYSTEM_POWER_STATUSGetSystemPowerStatusSetSystemPowerStateMapUserPhysicalPagesScatterCreateJobObjectAOpenJobObjectACreateJobSetFindFirstVolumeAFindNextVolumeAFindFirstVolumeMountPointAFindFirstVolumeMountPointWFindNextVolumeMountPointAFindNextVolumeMountPointWFindVolumeMountPointCloseSetVolumeMountPointASetVolumeMountPointWDeleteVolumeMountPointAGetVolumeNameForVolumeMountPointAGetVolumePathNameAGetVolumePathNamesForVolumeNameA// ACTCTX_FLAG_*PACTCTXAACTCTXAPACTCTXWACTCTXWPCACTCTXAPCACTCTXWCreateActCtxACreateActCtxWAddRefActCtxReleaseActCtxZombifyActCtxActivateActCtxDeactivateActCtxGetCurrentActCtxPACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATAACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATAPCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATAPACTCTX_SECTION_KEYED_DATAACTCTX_SECTION_KEYED_DATAPCACTCTX_SECTION_KEYED_DATAFindActCtxSectionStringAFindActCtxSectionStringWFindActCtxSectionGuidQueryActCtxWWTSGetActiveConsoleSessionIdGetActiveProcessorGroupCount// pub fn WTSGetServiceSessionId();// pub fn WTSIsServerContainer();GetMaximumProcessorGroupCountGetActiveProcessorCountGetMaximumProcessorCountGetNumaProcessorNodeGetNumaNodeNumberFromHandleGetNumaProcessorNodeExGetNumaNodeProcessorMaskGetNumaAvailableMemoryNodeGetNumaAvailableMemoryNodeExGetNumaProximityNodeRegisterApplicationRecoveryCallbackAPPLICATION_RECOVERY_CALLBACKUnregisterApplicationRecoveryCallbackRegisterApplicationRestartUnregisterApplicationRestartGetApplicationRecoveryCallbackGetApplicationRestartSettingsApplicationRecoveryInProgressApplicationRecoveryFinishedGetFileInformationByHandleExLPFILE_ID_DESCRIPTORFILE_ID_DESCRIPTOROpenFileByIdCreateSymbolicLinkACreateSymbolicLinkWQueryActCtxSettingsWCreateSymbolicLinkTransactedACreateSymbolicLinkTransactedWReplacePartitionUnitAddSecureMemoryCacheCallbackRemoveSecureMemoryCacheCallbackCopyContextInitializeContextGetEnabledXStateFeaturesGetXStateFeaturesMaskLocateXStateFeatureSetXStateFeaturesMaskEnableThreadProfilingDisableThreadProfilingQueryThreadProfilingReadThreadProfilingData// intrinsic InterlockedIncrement// intrinsic InterlockedDecrement// intrinsic InterlockedExchange// intrinsic InterlockedExchangeAdd// intrinsic InterlockedExchangeSubtract// intrinsic InterlockedCompareExchange// intrinsic InterlockedAnd// intrinsic InterlockedOr// intrinsic InterlockedXor// SCS_*//3233// RESTART_*// RECOVERY_*// FILE_BASIC_INFO, etc.DXGI_JPEG_AC_HUFFMAN_TABLEDXGI_JPEG_DC_HUFFMAN_TABLEDXGI_JPEG_QUANTIZATION_TABLEIEnumUnknownWICColorWICInProcPointerCODEC_FORCE_DWORDWIC_JPEG_MAX_COMPONENT_COUNTWIC_JPEG_MAX_TABLE_INDEXWIC_JPEG_SAMPLE_FACTORS_ONEWIC_JPEG_SAMPLE_FACTORS_THREE_420WIC_JPEG_SAMPLE_FACTORS_THREE_422WIC_JPEG_SAMPLE_FACTORS_THREE_440WIC_JPEG_SAMPLE_FACTORS_THREE_444WIC_JPEG_QUANTIZATION_BASELINE_ONEWIC_JPEG_QUANTIZATION_BASELINE_THREEWIC_JPEG_HUFFMAN_BASELINE_ONEWIC_JPEG_HUFFMAN_BASELINE_THREEREFWICPixelFormatGUIDWICPixelFormatGUIDWICConvertBitmapSourceWICCreateBitmapFromSectionWICCreateBitmapFromSectionExWICSectionAccessLevelWICMapGuidToShortNameWICMapShortNameToGuidWICMapSchemaToNameFACILITY_WINCODEC_ERRWINCODEC_ERR_BASEINTSAFE_E_ARITHMETIC_OVERFLOW/// intsafe.h, 0x216 = 534 = ERROR_ARITHMETIC_OVERFLOWMAKE_WINCODECHRMAKE_WINCODECHR_ERRWINCODEC_ERR_GENERIC_ERRORWINCODEC_ERR_INVALIDPARAMETERWINCODEC_ERR_OUTOFMEMORYWINCODEC_ERR_NOTIMPLEMENTEDWINCODEC_ERR_ABORTEDWINCODEC_ERR_ACCESSDENIEDWINCODEC_ERR_VALUEOVERFLOWWICRawChangeNotification_ExposureCompensationWICRawChangeNotification_NamedWhitePointWICRawChangeNotification_KelvinWhitePointWICRawChangeNotification_RGBWhitePointWICRawChangeNotification_ContrastWICRawChangeNotification_GammaWICRawChangeNotification_SharpnessWICRawChangeNotification_SaturationWICRawChangeNotification_TintWICRawChangeNotification_NoiseReductionWICRawChangeNotification_DestinationColorContextWICRawChangeNotification_ToneCurveWICRawChangeNotification_RotationWICRawChangeNotification_RenderMode//! Mappings for the contents of wincodec.hIPersistStreamIPersistStreamVtblPROPBAG2IWICComponentInfoIWICComponentInfoVtblIWICEnumMetadataItemIWICImagingFactoryVtblIWICMetadataQueryReaderIWICMetadataQueryWriterWICMatchMetadataContentWICSerializeMetadataContentIWICMetadataWriterWICGetMetadataContentSizeCLIPFORMAT_UserSizeCLIPFORMAT_UserMarshalCLIPFORMAT_UserUnmarshalCLIPFORMAT_UserFreeLPSAFEARRAY_UserSizeLPSAFEARRAY_UserMarshalLPSAFEARRAY_UserUnmarshalLPSAFEARRAY_UserFreeLF_FACESIZEPCOORDSMALL_RECTPSMALL_RECTKEY_EVENT_RECORD_uCharKEY_EVENT_RECORDPKEY_EVENT_RECORDRIGHT_ALT_PRESSEDLEFT_ALT_PRESSEDRIGHT_CTRL_PRESSEDLEFT_CTRL_PRESSEDSHIFT_PRESSEDNUMLOCK_ONSCROLLLOCK_ONCAPSLOCK_ONENHANCED_KEYNLS_DBCSCHARNLS_ALPHANUMERICNLS_KATAKANANLS_HIRAGANANLS_ROMANNLS_IME_CONVERSIONNLS_IME_DISABLEMOUSE_EVENT_RECORDPMOUSE_EVENT_RECORDFROM_LEFT_1ST_BUTTON_PRESSEDRIGHTMOST_BUTTON_PRESSEDFROM_LEFT_2ND_BUTTON_PRESSEDFROM_LEFT_3RD_BUTTON_PRESSEDFROM_LEFT_4TH_BUTTON_PRESSEDMOUSE_MOVEDDOUBLE_CLICKMOUSE_WHEELEDMOUSE_HWHEELEDWINDOW_BUFFER_SIZE_RECORDPWINDOW_BUFFER_SIZE_RECORDMENU_EVENT_RECORDPMENU_EVENT_RECORDFOCUS_EVENT_RECORDPFOCUS_EVENT_RECORDINPUT_RECORD_EventINPUT_RECORDKEY_EVENTMOUSE_EVENTWINDOW_BUFFER_SIZE_EVENTMENU_EVENTFOCUS_EVENTCHAR_INFO_CharCHAR_INFOPCHAR_INFOCONSOLE_FONT_INFOPCONSOLE_FONT_INFO// Many definitions in wincontypes used to be defined in this file, so reexport them to avoid// breakage. For clarity they are imported in the order they are defined in that file rather// than winapi's usual alphabetical ordering, with some newlines and indentation to match their// grouping in the file.FOREGROUND_BLUEFOREGROUND_GREENFOREGROUND_REDFOREGROUND_INTENSITYBACKGROUND_BLUEBACKGROUND_GREENBACKGROUND_REDBACKGROUND_INTENSITYCOMMON_LVB_LEADING_BYTECOMMON_LVB_TRAILING_BYTECOMMON_LVB_GRID_HORIZONTALCOMMON_LVB_GRID_LVERTICALCOMMON_LVB_GRID_RVERTICALCOMMON_LVB_REVERSE_VIDEOCOMMON_LVB_UNDERSCORECOMMON_LVB_SBCSDBCSPCONSOLE_SCREEN_BUFFER_INFOCONSOLE_SCREEN_BUFFER_INFOPCONSOLE_SCREEN_BUFFER_INFOEXCONSOLE_SCREEN_BUFFER_INFOEXPCONSOLE_CURSOR_INFOCONSOLE_CURSOR_INFOPCONSOLE_FONT_INFOEXCONSOLE_FONT_INFOEXHISTORY_NO_DUP_FLAGPCONSOLE_HISTORY_INFOCONSOLE_HISTORY_INFOPCONSOLE_SELECTION_INFOCONSOLE_SELECTION_INFOCONSOLE_NO_SELECTIONCONSOLE_SELECTION_IN_PROGRESSCONSOLE_SELECTION_NOT_EMPTYCONSOLE_MOUSE_SELECTIONCONSOLE_MOUSE_DOWNCTRL_BREAK_EVENTCTRL_CLOSE_EVENTCTRL_LOGOFF_EVENTCTRL_SHUTDOWN_EVENTENABLE_PROCESSED_INPUTENABLE_LINE_INPUTENABLE_ECHO_INPUTENABLE_WINDOW_INPUTENABLE_MOUSE_INPUTENABLE_INSERT_MODEENABLE_QUICK_EDIT_MODEENABLE_EXTENDED_FLAGSENABLE_AUTO_POSITIONENABLE_VIRTUAL_TERMINAL_INPUTENABLE_PROCESSED_OUTPUTENABLE_WRAP_AT_EOL_OUTPUTENABLE_VIRTUAL_TERMINAL_PROCESSINGDISABLE_NEWLINE_AUTO_RETURNENABLE_LVB_GRID_WORLDWIDEPeekConsoleInputWWriteConsoleInputAWriteConsoleInputWReadConsoleOutputAReadConsoleOutputWWriteConsoleOutputAWriteConsoleOutputWReadConsoleOutputCharacterAReadConsoleOutputCharacterWReadConsoleOutputAttributeWriteConsoleOutputCharacterAWriteConsoleOutputCharacterWWriteConsoleOutputAttributeFillConsoleOutputCharacterAFillConsoleOutputCharacterWFillConsoleOutputAttributeCONSOLE_REAL_OUTPUT_HANDLECONSOLE_REAL_INPUT_HANDLEGetConsoleScreenBufferInfoGetConsoleScreenBufferInfoExSetConsoleScreenBufferInfoExGetLargestConsoleWindowSizeGetConsoleCursorInfoGetCurrentConsoleFontGetCurrentConsoleFontExSetCurrentConsoleFontExGetConsoleHistoryInfoSetConsoleHistoryInfoGetConsoleFontSizeGetConsoleSelectionInfoGetNumberOfConsoleMouseButtonsSetConsoleActiveScreenBufferFlushConsoleInputBufferSetConsoleScreenBufferSizeSetConsoleCursorPositionSetConsoleCursorInfoScrollConsoleScreenBufferAScrollConsoleScreenBufferWSetConsoleWindowInfoSetConsoleTextAttributeGenerateConsoleCtrlEventFreeConsoleAttachConsoleATTACH_PARENT_PROCESSGetConsoleTitleAGetConsoleTitleWGetConsoleOriginalTitleAGetConsoleOriginalTitleWSetConsoleTitleASetConsoleTitleWCONSOLE_READCONSOLE_CONTROLCONSOLE_TEXTMODE_BUFFERCreateConsoleScreenBufferSetConsoleCPSetConsoleOutputCPCONSOLE_FULLSCREENCONSOLE_FULLSCREEN_HARDWAREGetConsoleDisplayModeCONSOLE_FULLSCREEN_MODECONSOLE_WINDOWED_MODESetConsoleDisplayModeGetConsoleWindowGetConsoleProcessListAddConsoleAliasAAddConsoleAliasWGetConsoleAliasAGetConsoleAliasWGetConsoleAliasesLengthAGetConsoleAliasesLengthWGetConsoleAliasExesLengthAGetConsoleAliasExesLengthWGetConsoleAliasesAGetConsoleAliasesWGetConsoleAliasExesAGetConsoleAliasExesW//! This module contains the public data structures, data types, and procedures exported by the NT//! console subsystem.NERR_BASENERR_PasswordExpiredCRED_MAX_STRING_LENGTHCRED_MAX_USERNAME_LENGTHCRED_MAX_GENERIC_TARGET_NAME_LENGTHCRED_MAX_DOMAIN_TARGET_NAME_LENGTHCRED_MAX_TARGETNAME_NAMESPACE_LENGTHCRED_MAX_TARGETNAME_ATTRIBUTE_LENGTHCRED_MAX_VALUE_SIZECRED_MAX_ATTRIBUTESPCREDENTIAL_ATTRIBUTEACREDENTIAL_ATTRIBUTEAPCREDENTIAL_ATTRIBUTEWCREDENTIAL_ATTRIBUTEWCRED_LOGON_TYPES_MASKCRED_FLAGS_PASSWORD_FOR_CERTCRED_FLAGS_PROMPT_NOWCRED_FLAGS_USERNAME_TARGETCRED_FLAGS_OWF_CRED_BLOBCRED_FLAGS_REQUIRE_CONFIRMATIONCRED_FLAGS_WILDCARD_MATCHCRED_FLAGS_VALID_FLAGSCRED_FLAGS_VALID_INPUT_FLAGSCRED_TYPE_GENERICCRED_TYPE_DOMAIN_PASSWORDCRED_TYPE_DOMAIN_CERTIFICATECRED_TYPE_DOMAIN_VISIBLE_PASSWORDCRED_TYPE_GENERIC_CERTIFICATECRED_TYPE_DOMAIN_EXTENDEDCRED_TYPE_MAXIMUMCRED_TYPE_MAXIMUM_EXCRED_MAX_CREDENTIAL_BLOB_SIZECRED_PERSIST_NONECRED_PERSIST_SESSIONCRED_PERSIST_LOCAL_MACHINECRED_PERSIST_ENTERPRISEPCREDENTIALACREDENTIALAPCREDENTIALWCREDENTIALWCRED_TI_SERVER_FORMAT_UNKNOWNCRED_TI_DOMAIN_FORMAT_UNKNOWNCRED_TI_ONLY_PASSWORD_REQUIREDCRED_TI_USERNAME_TARGETCRED_TI_CREATE_EXPLICIT_CREDCRED_TI_WORKGROUP_MEMBERCRED_TI_VALID_FLAGSPCREDENTIAL_TARGET_INFORMATIONACREDENTIAL_TARGET_INFORMATIONAPCREDENTIAL_TARGET_INFORMATIONWCREDENTIAL_TARGET_INFORMATIONWCERT_HASH_LENGTHPCERT_CREDENTIAL_INFOCERT_CREDENTIAL_INFOPUSERNAME_TARGET_CREDENTIAL_INFOUSERNAME_TARGET_CREDENTIAL_INFOPBINARY_BLOB_CREDENTIAL_INFOBINARY_BLOB_CREDENTIAL_INFOPCRED_MARSHAL_TYPECRED_MARSHAL_TYPEPCRED_PROTECTION_TYPECRED_PROTECTION_TYPECRED_PACK_PROTECTED_CREDENTIALSCRED_PACK_WOW_BUFFERCRED_PACK_GENERIC_CREDENTIALSCRED_PACK_ID_PROVIDER_CREDENTIALSCREDUI_INFOACREDUI_INFOWCREDUI_MAX_MESSAGE_LENGTHCREDUI_MAX_CAPTION_LENGTHCREDUI_MAX_GENERIC_TARGET_LENGTHCREDUI_MAX_DOMAIN_TARGET_LENGTHCREDUI_MAX_USERNAME_LENGTHCREDUI_MAX_PASSWORD_LENGTHCREDUI_FLAGS_INCORRECT_PASSWORDCREDUI_FLAGS_DO_NOT_PERSISTCREDUI_FLAGS_REQUEST_ADMINISTRATORCREDUI_FLAGS_EXCLUDE_CERTIFICATESCREDUI_FLAGS_REQUIRE_CERTIFICATECREDUI_FLAGS_SHOW_SAVE_CHECK_BOXCREDUI_FLAGS_ALWAYS_SHOW_UICREDUI_FLAGS_REQUIRE_SMARTCARDCREDUI_FLAGS_PASSWORD_ONLY_OKCREDUI_FLAGS_VALIDATE_USERNAMECREDUI_FLAGS_COMPLETE_USERNAMECREDUI_FLAGS_PERSISTCREDUI_FLAGS_SERVER_CREDENTIALCREDUI_FLAGS_EXPECT_CONFIRMATIONCREDUI_FLAGS_GENERIC_CREDENTIALSCREDUI_FLAGS_USERNAME_TARGET_CREDENTIALSCREDUI_FLAGS_KEEP_USERNAMECREDUI_FLAGS_PROMPT_VALIDCREDUIWIN_GENERICCREDUIWIN_CHECKBOXCREDUIWIN_AUTHPACKAGE_ONLYCREDUIWIN_IN_CRED_ONLYCREDUIWIN_ENUMERATE_ADMINSCREDUIWIN_ENUMERATE_CURRENT_USERCREDUIWIN_SECURE_PROMPTCREDUIWIN_PREPROMPTINGCREDUIWIN_PACK_32_WOWCREDUIWIN_VALID_FLAGSCRED_PRESERVE_CREDENTIAL_BLOBCredWriteWCredWriteACredReadWCredReadACRED_ENUMERATE_ALL_CREDENTIALSCredEnumerateWCredEnumerateACredWriteDomainCredentialsWCredWriteDomainCredentialsACRED_CACHE_TARGET_INFORMATIONCredReadDomainCredentialsWCredReadDomainCredentialsACredDeleteWCredDeleteACredRenameWCredRenameACRED_ALLOW_NAME_RESOLUTIONCredGetTargetInfoWCredGetTargetInfoACredMarshalCredentialWCredMarshalCredentialACredUnmarshalCredentialWCredUnmarshalCredentialACredIsMarshaledCredentialWCredIsMarshaledCredentialACredUnPackAuthenticationBufferWCredUnPackAuthenticationBufferACredPackAuthenticationBufferWCredPackAuthenticationBufferACredProtectWCredProtectACredUnprotectWCredUnprotectACredIsProtectedWCredIsProtectedACredFindBestCredentialWCredFindBestCredentialACredGetSessionTypesCredFreeCredUIPromptForCredentialsWCredUIPromptForCredentialsACredUIPromptForWindowsCredentialsWCredUIPromptForWindowsCredentialsACredUIParseUserNameWCredUIParseUserNameACredUICmdLinePromptForCredentialsWCredUICmdLinePromptForCredentialsACredUIConfirmCredentialsWCredUIConfirmCredentialsACredUIStoreSSOCredWCredUIReadSSOCredW//! Authentication API Prototypes and DefinitionsGET_ALG_CLASS//108GET_ALG_TYPEGET_ALG_SIDALG_CLASS_ANYALG_CLASS_SIGNATUREALG_CLASS_MSG_ENCRYPTALG_CLASS_DATA_ENCRYPTALG_CLASS_HASHALG_CLASS_KEY_EXCHANGEALG_CLASS_ALLALG_TYPE_ANYALG_TYPE_DSSALG_TYPE_RSAALG_TYPE_BLOCKALG_TYPE_STREAMALG_TYPE_DHALG_TYPE_SECURECHANNELALG_TYPE_ECDHALG_TYPE_THIRDPARTYALG_SID_ANYALG_SID_THIRDPARTY_ANYALG_SID_RSA_ANYALG_SID_RSA_PKCSALG_SID_RSA_MSATWORKALG_SID_RSA_ENTRUSTALG_SID_RSA_PGPALG_SID_DSS_ANYALG_SID_DSS_PKCSALG_SID_DSS_DMSALG_SID_ECDSAALG_SID_DESALG_SID_3DESALG_SID_DESXALG_SID_IDEAALG_SID_CASTALG_SID_SAFERSK64ALG_SID_SAFERSK128ALG_SID_3DES_112ALG_SID_CYLINK_MEKALG_SID_RC5ALG_SID_AES_128ALG_SID_AES_192ALG_SID_AES_256ALG_SID_AESALG_SID_SKIPJACKALG_SID_TEKCRYPT_MODE_CBCICRYPT_MODE_CFBPCRYPT_MODE_OFBPCRYPT_MODE_CBCOFMCRYPT_MODE_CBCOFMIALG_SID_RC2ALG_SID_RC4ALG_SID_SEALALG_SID_DH_SANDFALG_SID_DH_EPHEMALG_SID_AGREED_KEY_ANYALG_SID_KEAALG_SID_ECDHALG_SID_ECDH_EPHEMALG_SID_MD2ALG_SID_MD4ALG_SID_MD5ALG_SID_SHAALG_SID_SHA1ALG_SID_MACALG_SID_RIPEMDALG_SID_RIPEMD160ALG_SID_SSL3SHAMD5ALG_SID_HMACALG_SID_TLS1PRFALG_SID_HASH_REPLACE_OWFALG_SID_SHA_256ALG_SID_SHA_384ALG_SID_SHA_512ALG_SID_SSL3_MASTERALG_SID_SCHANNEL_MASTER_HASHALG_SID_SCHANNEL_MAC_KEYALG_SID_PCT1_MASTERALG_SID_SSL2_MASTERALG_SID_TLS1_MASTERALG_SID_SCHANNEL_ENC_KEYALG_SID_ECMQVALG_SID_EXAMPLECALG_MD2CALG_MD4CALG_MD5CALG_SHACALG_SHA1CALG_MACCALG_RSA_SIGNCALG_DSS_SIGNCALG_NO_SIGNCALG_RSA_KEYXCALG_DESCALG_3DES_112CALG_3DESCALG_DESXCALG_RC2CALG_RC4CALG_SEALCALG_DH_SFCALG_DH_EPHEMCALG_AGREEDKEY_ANYCALG_KEA_KEYXCALG_HUGHES_MD5CALG_SKIPJACKCALG_TEKCALG_CYLINK_MEKCALG_SSL3_SHAMD5CALG_SSL3_MASTERCALG_SCHANNEL_MASTER_HASHCALG_SCHANNEL_MAC_KEYCALG_SCHANNEL_ENC_KEYCALG_PCT1_MASTERCALG_SSL2_MASTERCALG_TLS1_MASTERCALG_RC5CALG_HMACCALG_TLS1PRFCALG_HASH_REPLACE_OWFCALG_AES_128CALG_AES_192CALG_AES_256CALG_AESCALG_SHA_256CALG_SHA_384CALG_SHA_512CALG_ECDHCALG_ECDH_EPHEMCALG_ECMQVCALG_ECDSACALG_NULLCIPHERCALG_THIRDPARTY_KEY_EXCHANGECALG_THIRDPARTY_SIGNATURECALG_THIRDPARTY_CIPHERCALG_THIRDPARTY_HASHCRYPT_VERIFYCONTEXTCRYPT_NEWKEYSETCRYPT_DELETEKEYSETCRYPT_MACHINE_KEYSETCRYPT_SILENTCRYPT_DEFAULT_CONTAINER_OPTIONALCRYPT_EXPORTABLECRYPT_USER_PROTECTEDCRYPT_CREATE_SALTCRYPT_UPDATE_KEYCRYPT_NO_SALTCRYPT_PREGENCRYPT_RECIPIENTCRYPT_INITIATORCRYPT_ONLINECRYPT_SFCRYPT_CREATE_IVCRYPT_KEKCRYPT_DATA_KEYCRYPT_VOLATILECRYPT_SGCKEYCRYPT_USER_PROTECTED_STRONGCRYPT_ARCHIVABLECRYPT_FORCE_KEY_PROTECTION_HIGHRSA1024BIT_KEYCRYPT_SERVERKEY_LENGTH_MASKCRYPT_Y_ONLYCRYPT_SSL2_FALLBACKCRYPT_DESTROYKEYCRYPT_OAEPCRYPT_BLOB_VER3CRYPT_IPSEC_HMAC_KEYCRYPT_DECRYPT_RSA_NO_PADDING_CHECKCRYPT_SECRETDIGESTCRYPT_OWF_REPL_LM_HASHCRYPT_LITTLE_ENDIANCRYPT_NOHASHOIDCRYPT_TYPE2_FORMATCRYPT_X931_FORMATCRYPT_MACHINE_DEFAULTCRYPT_USER_DEFAULTCRYPT_DELETE_DEFAULTSIMPLEBLOBPUBLICKEYBLOBPRIVATEKEYBLOBPLAINTEXTKEYBLOBOPAQUEKEYBLOBPUBLICKEYBLOBEXSYMMETRICWRAPKEYBLOBKEYSTATEBLOBAT_KEYEXCHANGEAT_SIGNATURECRYPT_USERDATAKP_IVKP_SALTKP_PADDINGKP_MODEKP_MODE_BITSKP_PERMISSIONSKP_ALGIDKP_BLOCKLENKP_KEYLENKP_SALT_EXKP_PKP_GKP_QKP_XKP_YKP_RAKP_RBKP_INFOKP_EFFECTIVE_KEYLENKP_SCHANNEL_ALGKP_CLIENT_RANDOMKP_SERVER_RANDOMKP_RPKP_PRECOMP_MD5KP_PRECOMP_SHAKP_CERTIFICATEKP_CLEAR_KEYKP_PUB_EX_LENKP_PUB_EX_VALKP_KEYVALKP_ADMIN_PINKP_KEYEXCHANGE_PINKP_SIGNATURE_PINKP_PREHASHKP_ROUNDSKP_OAEP_PARAMSKP_CMS_KEY_INFOKP_CMS_DH_KEY_INFOKP_PUB_PARAMSKP_VERIFY_PARAMSKP_HIGHEST_VERSIONKP_GET_USE_COUNTKP_PIN_IDKP_PIN_INFOPKCS5_PADDINGRANDOM_PADDINGZERO_PADDINGCRYPT_MODE_CBCCRYPT_MODE_ECBCRYPT_MODE_OFBCRYPT_MODE_CFBCRYPT_MODE_CTSCRYPT_ENCRYPTCRYPT_DECRYPTCRYPT_EXPORTCRYPT_READCRYPT_WRITECRYPT_MACCRYPT_EXPORT_KEYCRYPT_IMPORT_KEYCRYPT_ARCHIVEHP_ALGIDHP_HASHVALHP_HASHSIZEHP_HMAC_INFOHP_TLS1PRF_LABELHP_TLS1PRF_SEEDCRYPT_FAILEDCRYPT_SUCCEEDRCRYPT_SUCCEEDEDRCRYPT_FAILEDPP_ENUMALGSPP_ENUMCONTAINERSPP_IMPTYPEPP_NAMEPP_VERSIONPP_CONTAINERPP_CHANGE_PASSWORDPP_KEYSET_SEC_DESCRPP_CERTCHAINPP_KEY_TYPE_SUBTYPEPP_PROVTYPEPP_KEYSTORAGEPP_APPLI_CERTPP_SYM_KEYSIZEPP_SESSION_KEYSIZEPP_UI_PROMPTPP_ENUMALGS_EXPP_ENUMMANDROOTSPP_ENUMELECTROOTSPP_KEYSET_TYPEPP_ADMIN_PINPP_KEYEXCHANGE_PINPP_SIGNATURE_PINPP_SIG_KEYSIZE_INCPP_KEYX_KEYSIZE_INCPP_UNIQUE_CONTAINERPP_SGC_INFOPP_USE_HARDWARE_RNGPP_KEYSPECPP_ENUMEX_SIGNING_PROTPP_CRYPT_COUNT_KEY_USEPP_USER_CERTSTOREPP_SMARTCARD_READERPP_SMARTCARD_GUIDPP_ROOT_CERTSTOREPP_SMARTCARD_READER_ICONCRYPT_FIRSTCRYPT_NEXTCRYPT_SGC_ENUMCRYPT_IMPL_HARDWARECRYPT_IMPL_SOFTWARECRYPT_IMPL_MIXEDCRYPT_IMPL_UNKNOWNCRYPT_IMPL_REMOVABLECRYPT_SEC_DESCRCRYPT_PSTORECRYPT_UI_PROMPTCRYPT_FLAG_PCT1CRYPT_FLAG_SSL2CRYPT_FLAG_SSL3CRYPT_FLAG_TLS1CRYPT_FLAG_IPSECCRYPT_FLAG_SIGNINGCRYPT_SGCCRYPT_FASTSGCPP_CLIENT_HWNDPP_CONTEXT_INFOPP_KEYEXCHANGE_KEYSIZEPP_SIGNATURE_KEYSIZEPP_KEYEXCHANGE_ALGPP_SIGNATURE_ALGPP_DELETEKEYPP_PIN_PROMPT_STRINGPP_SECURE_KEYEXCHANGE_PINPP_SECURE_SIGNATURE_PINPROV_RSA_FULLPROV_RSA_SIGPROV_DSSPROV_FORTEZZAPROV_MS_EXCHANGEPROV_SSLPROV_RSA_SCHANNELPROV_DSS_DHPROV_EC_ECDSA_SIGPROV_EC_ECNRA_SIGPROV_EC_ECDSA_FULLPROV_EC_ECNRA_FULLPROV_DH_SCHANNELPROV_SPYRUS_LYNKSPROV_RNGPROV_INTEL_SECPROV_REPLACE_OWFPROV_RSA_AESMS_DEF_PROVMS_ENHANCED_PROVMS_STRONG_PROVMS_DEF_RSA_SIG_PROVMS_DEF_RSA_SCHANNEL_PROVMS_DEF_DSS_PROVMS_DEF_DSS_DH_PROVMS_ENH_DSS_DH_PROVMS_DEF_DH_SCHANNEL_PROVMS_SCARD_PROVMS_ENH_RSA_AES_PROVMS_ENH_RSA_AES_PROV_XPMAXUIDLENEXPO_OFFLOAD_REG_VALUEEXPO_OFFLOAD_FUNC_NAMEszKEY_CRYPTOAPI_PRIVATE_KEY_OPTIONSszKEY_CACHE_ENABLEDszKEY_CACHE_SECONDSszPRIV_KEY_CACHE_MAX_ITEMScPRIV_KEY_CACHE_MAX_ITEMS_DEFAULTszPRIV_KEY_CACHE_PURGE_INTERVAL_SECONDScPRIV_KEY_CACHE_PURGE_INTERVAL_SECONDS_DEFAULTCUR_BLOB_VERSIONPCMS_KEY_INFOCMS_KEY_INFOPHMAC_INFOHMAC_INFOPSCHANNEL_ALGSCHANNEL_ALGSCHANNEL_MAC_KEYSCHANNEL_ENC_KEYINTERNATIONAL_USAGEPUBLICKEYSTRUCBLOBHEADERDSSPUBKEYDHPUBKEYKEAPUBKEYTEKPUBKEYDSSPUBKEY_VER3DHPUBKEY_VER3DSSPRIVKEY_VER3DHPRIVKEY_VER3PKEY_TYPE_SUBTYPEKEY_TYPE_SUBTYPEPCRYPT_RC4_KEY_STATECRYPT_RC4_KEY_STATEPCRYPT_DES_KEY_STATECRYPT_DES_KEY_STATEPCRYPT_3DES_KEY_STATECRYPT_3DES_KEY_STATEPCRYPT_AES_128_KEY_STATECRYPT_AES_128_KEY_STATEPCRYPT_AES_256_KEY_STATECRYPT_AES_256_KEY_STATECRYPTOAPI_BLOBPCRYPT_INTEGER_BLOBCRYPT_UINT_BLOBPCRYPT_UINT_BLOBCRYPT_OBJID_BLOBPCRYPT_OBJID_BLOBCERT_NAME_BLOBCERT_RDN_VALUE_BLOBPCERT_RDN_VALUE_BLOBCERT_BLOBPCERT_BLOBCRL_BLOBPCRL_BLOBPDATA_BLOBCRYPT_DATA_BLOBPCRYPT_DATA_BLOBPCRYPT_HASH_BLOBCRYPT_DIGEST_BLOBPCRYPT_DIGEST_BLOBCRYPT_DER_BLOBPCRYPT_DER_BLOBPCRYPT_ATTR_BLOBPCMS_DH_KEY_INFOCMS_DH_KEY_INFOCryptAcquireContextACryptAcquireContextWCryptReleaseContextCryptGenKeyCryptDeriveKeyCryptDestroyKeyCryptSetKeyParamCryptGetKeyParamCryptSetHashParamCryptGetHashParamCryptSetProvParamCryptGetProvParamCryptGenRandomCryptGetUserKeyCryptExportKeyCryptImportKeyCryptEncryptCryptDecryptCryptCreateHashCryptHashDataCryptHashSessionKeyCryptDestroyHashCryptSignHashACryptSignHashWCryptVerifySignatureACryptVerifySignatureWCryptSetProviderACryptSetProviderWCryptSetProviderExACryptSetProviderExWCryptGetDefaultProviderACryptGetDefaultProviderWCryptEnumProviderTypesACryptEnumProviderTypesWCryptEnumProvidersACryptEnumProvidersWCryptContextAddRefCryptDuplicateKeyCryptDuplicateHashGetEncSChannelHCRYPTPROV_OR_NCRYPT_KEY_HANDLEHCRYPTPROV_LEGACYPCRYPT_BIT_BLOBCRYPT_BIT_BLOBPCRYPT_ALGORITHM_IDENTIFIERszOID_RSAszOID_PKCSszOID_RSA_HASHszOID_RSA_ENCRYPTszOID_PKCS_1szOID_PKCS_2szOID_PKCS_3szOID_PKCS_4szOID_PKCS_5szOID_PKCS_6szOID_PKCS_7szOID_PKCS_8szOID_PKCS_9szOID_PKCS_10szOID_PKCS_12szOID_RSA_RSAszOID_RSA_MD2RSAszOID_RSA_MD4RSAszOID_RSA_MD5RSAszOID_RSA_SHA1RSAszOID_RSA_SETOAEP_RSAszOID_RSAES_OAEPszOID_RSA_MGF1szOID_RSA_PSPECIFIEDszOID_RSA_SSA_PSSszOID_RSA_SHA256RSAszOID_RSA_SHA384RSAszOID_RSA_SHA512RSAszOID_RSA_DHszOID_RSA_dataszOID_RSA_signedDataszOID_RSA_envelopedDataszOID_RSA_signEnvDataszOID_RSA_digestedDataszOID_RSA_hashedDataszOID_RSA_encryptedDataszOID_RSA_emailAddrszOID_RSA_unstructNameszOID_RSA_contentTypeszOID_RSA_messageDigestszOID_RSA_signingTimeszOID_RSA_counterSignszOID_RSA_challengePwdszOID_RSA_unstructAddrszOID_RSA_extCertAttrsszOID_RSA_certExtensionsszOID_RSA_SMIMECapabilitiesszOID_RSA_preferSignedDataszOID_TIMESTAMP_TOKENszOID_RFC3161_counterSignszOID_RSA_SMIMEalgszOID_RSA_SMIMEalgESDHszOID_RSA_SMIMEalgCMS3DESwrapszOID_RSA_SMIMEalgCMSRC2wrapszOID_RSA_MD2szOID_RSA_MD4szOID_RSA_MD5szOID_RSA_RC2CBCszOID_RSA_RC4szOID_RSA_DES_EDE3_CBCszOID_RSA_RC5_CBCPadszOID_ANSI_X942szOID_ANSI_X942_DHszOID_X957szOID_X957_DSAszOID_X957_SHA1DSAszOID_ECC_PUBLIC_KEYszOID_ECC_CURVE_P256szOID_ECC_CURVE_P384szOID_ECC_CURVE_P521szOID_ECC_CURVE_BRAINPOOLP160R1szOID_ECC_CURVE_BRAINPOOLP160T1szOID_ECC_CURVE_BRAINPOOLP192R1szOID_ECC_CURVE_BRAINPOOLP192T1szOID_ECC_CURVE_BRAINPOOLP224R1szOID_ECC_CURVE_BRAINPOOLP224T1szOID_ECC_CURVE_BRAINPOOLP256R1szOID_ECC_CURVE_BRAINPOOLP256T1szOID_ECC_CURVE_BRAINPOOLP320R1szOID_ECC_CURVE_BRAINPOOLP320T1szOID_ECC_CURVE_BRAINPOOLP384R1szOID_ECC_CURVE_BRAINPOOLP384T1szOID_ECC_CURVE_BRAINPOOLP512R1szOID_ECC_CURVE_BRAINPOOLP512T1szOID_ECC_CURVE_EC192WAPIszOID_CN_ECDSA_SHA256szOID_ECC_CURVE_NISTP192szOID_ECC_CURVE_NISTP224szOID_ECC_CURVE_NISTP256szOID_ECC_CURVE_NISTP384szOID_ECC_CURVE_NISTP521szOID_ECC_CURVE_SECP160K1szOID_ECC_CURVE_SECP160R1szOID_ECC_CURVE_SECP160R2szOID_ECC_CURVE_SECP192K1szOID_ECC_CURVE_SECP192R1szOID_ECC_CURVE_SECP224K1szOID_ECC_CURVE_SECP224R1szOID_ECC_CURVE_SECP256K1szOID_ECC_CURVE_SECP256R1szOID_ECC_CURVE_SECP384R1szOID_ECC_CURVE_SECP521R1szOID_ECC_CURVE_WTLS7szOID_ECC_CURVE_WTLS9szOID_ECC_CURVE_WTLS12szOID_ECC_CURVE_X962P192V1szOID_ECC_CURVE_X962P192V2szOID_ECC_CURVE_X962P192V3szOID_ECC_CURVE_X962P239V1szOID_ECC_CURVE_X962P239V2szOID_ECC_CURVE_X962P239V3szOID_ECC_CURVE_X962P256V1szOID_ECDSA_SHA1szOID_ECDSA_SPECIFIEDszOID_ECDSA_SHA256szOID_ECDSA_SHA384szOID_ECDSA_SHA512szOID_NIST_AES128_CBCszOID_NIST_AES192_CBCszOID_NIST_AES256_CBCszOID_NIST_AES128_WRAPszOID_NIST_AES192_WRAPszOID_NIST_AES256_WRAPszOID_DH_SINGLE_PASS_STDDH_SHA1_KDFszOID_DH_SINGLE_PASS_STDDH_SHA256_KDFszOID_DH_SINGLE_PASS_STDDH_SHA384_KDFszOID_DSszOID_DSALGszOID_DSALG_CRPTszOID_DSALG_HASHszOID_DSALG_SIGNszOID_DSALG_RSAszOID_OIWszOID_OIWSECszOID_OIWSEC_md4RSAszOID_OIWSEC_md5RSAszOID_OIWSEC_md4RSA2szOID_OIWSEC_desECBszOID_OIWSEC_desCBCszOID_OIWSEC_desOFBszOID_OIWSEC_desCFBszOID_OIWSEC_desMACszOID_OIWSEC_rsaSignszOID_OIWSEC_dsaszOID_OIWSEC_shaDSAszOID_OIWSEC_mdc2RSAszOID_OIWSEC_shaRSAszOID_OIWSEC_dhCommModszOID_OIWSEC_desEDEszOID_OIWSEC_shaszOID_OIWSEC_mdc2szOID_OIWSEC_dsaCommszOID_OIWSEC_dsaCommSHAszOID_OIWSEC_rsaXchgszOID_OIWSEC_keyHashSealszOID_OIWSEC_md2RSASignszOID_OIWSEC_md5RSASignszOID_OIWSEC_sha1szOID_OIWSEC_dsaSHA1szOID_OIWSEC_dsaCommSHA1szOID_OIWSEC_sha1RSASignszOID_OIWDIRszOID_OIWDIR_CRPTszOID_OIWDIR_HASHszOID_OIWDIR_SIGNszOID_OIWDIR_md2szOID_OIWDIR_md2RSAszOID_INFOSECszOID_INFOSEC_sdnsSignatureszOID_INFOSEC_mosaicSignatureszOID_INFOSEC_sdnsConfidentialityszOID_INFOSEC_mosaicConfidentialityszOID_INFOSEC_sdnsIntegrityszOID_INFOSEC_mosaicIntegrityszOID_INFOSEC_sdnsTokenProtectionszOID_INFOSEC_mosaicTokenProtectionszOID_INFOSEC_sdnsKeyManagementszOID_INFOSEC_mosaicKeyManagementszOID_INFOSEC_sdnsKMandSigszOID_INFOSEC_mosaicKMandSigszOID_INFOSEC_SuiteASignatureszOID_INFOSEC_SuiteAConfidentialityszOID_INFOSEC_SuiteAIntegrityszOID_INFOSEC_SuiteATokenProtectionszOID_INFOSEC_SuiteAKeyManagementszOID_INFOSEC_SuiteAKMandSigszOID_INFOSEC_mosaicUpdatedSigszOID_INFOSEC_mosaicKMandUpdSigszOID_INFOSEC_mosaicUpdatedIntegszOID_NIST_sha256szOID_NIST_sha384szOID_NIST_sha512PCRYPT_OBJID_TABLECRYPT_OBJID_TABLEPCRYPT_HASH_INFOCRYPT_HASH_INFOPCERT_EXTENSIONCERT_EXTENSIONPCCERT_EXTENSIONPCRYPT_ATTRIBUTE_TYPE_VALUEPCRYPT_ATTRIBUTECRYPT_ATTRIBUTEPCRYPT_ATTRIBUTESCRYPT_ATTRIBUTESPCERT_RDN_ATTRCERT_RDN_ATTRszOID_COMMON_NAMEszOID_SUR_NAMEszOID_DEVICE_SERIAL_NUMBERszOID_COUNTRY_NAMEszOID_LOCALITY_NAMEszOID_STATE_OR_PROVINCE_NAMEszOID_STREET_ADDRESSszOID_ORGANIZATION_NAMEszOID_ORGANIZATIONAL_UNIT_NAMEszOID_TITLEszOID_DESCRIPTIONszOID_SEARCH_GUIDEszOID_BUSINESS_CATEGORYszOID_POSTAL_ADDRESSszOID_POSTAL_CODEszOID_POST_OFFICE_BOXszOID_PHYSICAL_DELIVERY_OFFICE_NAMEszOID_TELEPHONE_NUMBERszOID_TELEX_NUMBERszOID_TELETEXT_TERMINAL_IDENTIFIERszOID_FACSIMILE_TELEPHONE_NUMBERszOID_X21_ADDRESSszOID_INTERNATIONAL_ISDN_NUMBERszOID_REGISTERED_ADDRESSszOID_DESTINATION_INDICATORszOID_PREFERRED_DELIVERY_METHODszOID_PRESENTATION_ADDRESSszOID_SUPPORTED_APPLICATION_CONTEXTszOID_MEMBERszOID_OWNERszOID_ROLE_OCCUPANTszOID_SEE_ALSOszOID_USER_PASSWORDszOID_USER_CERTIFICATEszOID_CA_CERTIFICATEszOID_AUTHORITY_REVOCATION_LISTszOID_CERTIFICATE_REVOCATION_LISTszOID_CROSS_CERTIFICATE_PAIRszOID_GIVEN_NAMEszOID_INITIALSszOID_DN_QUALIFIERszOID_DOMAIN_COMPONENTszOID_PKCS_12_FRIENDLY_NAME_ATTRszOID_PKCS_12_LOCAL_KEY_IDszOID_PKCS_12_KEY_PROVIDER_NAME_ATTRszOID_LOCAL_MACHINE_KEYSETszOID_PKCS_12_EXTENDED_ATTRIBUTESszOID_PKCS_12_PROTECTED_PASSWORD_SECRET_BAG_TYPE_IDszOID_KEYID_RDNszOID_EV_RDN_LOCALEszOID_EV_RDN_STATE_OR_PROVINCEszOID_EV_RDN_COUNTRYCERT_RDN_ANY_TYPECERT_RDN_ENCODED_BLOBCERT_RDN_OCTET_STRINGCERT_RDN_NUMERIC_STRINGCERT_RDN_PRINTABLE_STRINGCERT_RDN_TELETEX_STRINGCERT_RDN_T61_STRINGCERT_RDN_VIDEOTEX_STRINGCERT_RDN_IA5_STRINGCERT_RDN_GRAPHIC_STRINGCERT_RDN_VISIBLE_STRINGCERT_RDN_ISO646_STRINGCERT_RDN_GENERAL_STRINGCERT_RDN_UNIVERSAL_STRINGCERT_RDN_INT4_STRINGCERT_RDN_BMP_STRINGCERT_RDN_UNICODE_STRINGCERT_RDN_UTF8_STRINGCERT_RDN_TYPE_MASKCERT_RDN_FLAGS_MASKCERT_RDN_ENABLE_T61_UNICODE_FLAGCERT_RDN_ENABLE_UTF8_UNICODE_FLAGCERT_RDN_FORCE_UTF8_UNICODE_FLAGCERT_RDN_DISABLE_CHECK_TYPE_FLAGCERT_RDN_DISABLE_IE4_UTF8_FLAGCERT_RDN_ENABLE_PUNYCODE_FLAGIS_CERT_RDN_CHAR_STRINGPCERT_RDNCERT_RDNPCERT_NAME_INFOCERT_NAME_INFOPCERT_NAME_VALUECERT_NAME_VALUEPCERT_PUBLIC_KEY_INFOCERT_PUBLIC_KEY_INFOCERT_RSA_PUBLIC_KEY_OBJIDCERT_DEFAULT_OID_PUBLIC_KEY_SIGNCERT_DEFAULT_OID_PUBLIC_KEY_XCHGPCRYPT_ECC_PRIVATE_KEY_INFOCRYPT_ECC_PRIVATE_KEY_INFOCRYPT_ECC_PRIVATE_KEY_INFO_v1PCRYPT_PRIVATE_KEY_INFOCRYPT_PRIVATE_KEY_INFOPCRYPT_ENCRYPTED_PRIVATE_KEY_INFOCRYPT_ENCRYPTED_PRIVATE_KEY_INFOPCRYPT_PKCS8_IMPORT_PARAMSCRYPT_PKCS8_IMPORT_PARAMSCRYPT_PRIVATE_KEY_BLOB_AND_PARAMSPPCRYPT_PRIVATE_KEY_BLOB_AND_PARAMSPCRYPT_PKCS8_EXPORT_PARAMSCRYPT_PKCS8_EXPORT_PARAMSPCERT_INFOCERT_INFOCERT_V1CERT_V2CERT_V3CERT_INFO_VERSION_FLAGCERT_INFO_SERIAL_NUMBER_FLAGCERT_INFO_SIGNATURE_ALGORITHM_FLAGCERT_INFO_ISSUER_FLAGCERT_INFO_NOT_BEFORE_FLAGCERT_INFO_NOT_AFTER_FLAGCERT_INFO_SUBJECT_FLAGCERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAGCERT_INFO_ISSUER_UNIQUE_ID_FLAGCERT_INFO_SUBJECT_UNIQUE_ID_FLAGCERT_INFO_EXTENSION_FLAGPCRL_ENTRYCRL_ENTRYPCRL_INFOCRL_INFOCRL_V1CRL_V2CERT_BUNDLE_CERTIFICATECERT_BUNDLE_CRLPCERT_OR_CRL_BLOBCERT_OR_CRL_BLOBPCERT_OR_CRL_BUNDLECERT_OR_CRL_BUNDLEPCERT_REQUEST_INFOCERT_REQUEST_INFOCERT_REQUEST_V1PCERT_KEYGEN_REQUEST_INFOCERT_KEYGEN_REQUEST_INFOCERT_KEYGEN_REQUEST_V1PCERT_SIGNED_CONTENT_INFOCERT_SIGNED_CONTENT_INFOPCTL_USAGECERT_ENHKEY_USAGEPCERT_ENHKEY_USAGEPCCTL_USAGEPCCERT_ENHKEY_USAGEPCTL_ENTRYCTL_ENTRYPCTL_INFOCTL_INFOCTL_V1PCRYPT_TIME_STAMP_REQUEST_INFOCRYPT_TIME_STAMP_REQUEST_INFOPCRYPT_ENROLLMENT_NAME_VALUE_PAIRCRYPT_ENROLLMENT_NAME_VALUE_PAIRPCRYPT_CSP_PROVIDERCRYPT_CSP_PROVIDERCERT_ENCODING_TYPE_MASKCMSG_ENCODING_TYPE_MASKGET_CERT_ENCODING_TYPEGET_CMSG_ENCODING_TYPECRYPT_ASN_ENCODINGCRYPT_NDR_ENCODINGX509_NDR_ENCODINGPKCS_7_ASN_ENCODINGPKCS_7_NDR_ENCODINGCryptFormatObjectCRYPT_FORMAT_STR_MULTI_LINECRYPT_FORMAT_STR_NO_HEXCRYPT_FORMAT_SIMPLECRYPT_FORMAT_X509CRYPT_FORMAT_OIDCRYPT_FORMAT_RDN_SEMICOLONCRYPT_FORMAT_RDN_CRLFCRYPT_FORMAT_RDN_UNQUOTECRYPT_FORMAT_RDN_REVERSECRYPT_FORMAT_COMMACRYPT_FORMAT_SEMICOLONCRYPT_FORMAT_CRLFPCRYPT_ENCODE_PARACRYPT_ENCODE_PARACryptEncodeObjectExCryptEncodeObjectCRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAGCRYPT_ENCODE_ALLOC_FLAGCRYPT_UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAGCRYPT_UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAGCRYPT_UNICODE_NAME_ENCODE_FORCE_UTF8_UNICODE_FLAGCRYPT_UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAGCRYPT_SORTED_CTL_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAGCRYPT_ENCODE_ENABLE_PUNYCODE_FLAGCRYPT_ENCODE_ENABLE_UTF8PERCENT_FLAGCRYPT_ENCODE_ENABLE_IA5CONVERSION_FLAGPCRYPT_DECODE_PARACRYPT_DECODE_PARACryptDecodeObjectExCryptDecodeObjectCRYPT_DECODE_NOCOPY_FLAGCRYPT_DECODE_TO_BE_SIGNED_FLAGCRYPT_DECODE_SHARE_OID_STRING_FLAGCRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAGCRYPT_DECODE_ALLOC_FLAGCRYPT_UNICODE_NAME_DECODE_DISABLE_IE4_UTF8_FLAGCRYPT_DECODE_ENABLE_PUNYCODE_FLAGCRYPT_DECODE_ENABLE_UTF8PERCENT_FLAGCRYPT_DECODE_ENABLE_IA5CONVERSION_FLAGCRYPT_ENCODE_DECODE_NONEX509_CERTX509_CERT_TO_BE_SIGNEDX509_CERT_CRL_TO_BE_SIGNEDX509_CERT_REQUEST_TO_BE_SIGNEDX509_EXTENSIONSX509_NAME_VALUEX509_PUBLIC_KEY_INFOX509_AUTHORITY_KEY_IDX509_KEY_ATTRIBUTESX509_KEY_USAGE_RESTRICTIONX509_ALTERNATE_NAMEX509_BASIC_CONSTRAINTSX509_KEY_USAGEX509_BASIC_CONSTRAINTS2X509_CERT_POLICIESPKCS_UTC_TIMEPKCS_TIME_REQUESTRSA_CSP_PUBLICKEYBLOBX509_UNICODE_NAMEX509_KEYGEN_REQUEST_TO_BE_SIGNEDPKCS_ATTRIBUTEPKCS_CONTENT_INFO_SEQUENCE_OF_ANYX509_UNICODE_NAME_VALUEX509_ANY_STRINGX509_UNICODE_ANY_STRINGX509_OCTET_STRINGX509_BITSX509_INTEGERX509_MULTI_BYTE_INTEGERX509_ENUMERATEDX509_CHOICE_OF_TIMEX509_AUTHORITY_KEY_ID2X509_AUTHORITY_INFO_ACCESSX509_SUBJECT_INFO_ACCESSX509_CRL_REASON_CODEPKCS_CONTENT_INFOX509_SEQUENCE_OF_ANYX509_CRL_DIST_POINTSX509_ENHANCED_KEY_USAGEPKCS_CTLX509_MULTI_BYTE_UINTX509_DSS_PUBLICKEYX509_DSS_PARAMETERSX509_DSS_SIGNATUREPKCS_RC2_CBC_PARAMETERSPKCS_SMIME_CAPABILITIESX509_QC_STATEMENTS_EXTPKCS_RSA_PRIVATE_KEYPKCS_PRIVATE_KEY_INFOPKCS_ENCRYPTED_PRIVATE_KEY_INFOX509_PKIX_POLICY_QUALIFIER_USERNOTICEX509_DH_PUBLICKEYX509_DH_PARAMETERSPKCS_ATTRIBUTESPKCS_SORTED_CTLX509_ECC_SIGNATUREX942_DH_PARAMETERSX509_BITS_WITHOUT_TRAILING_ZEROESX942_OTHER_INFOX509_CERT_PAIRX509_ISSUING_DIST_POINTX509_NAME_CONSTRAINTSX509_POLICY_MAPPINGSX509_POLICY_CONSTRAINTSX509_CROSS_CERT_DIST_POINTSCMC_DATACMC_RESPONSECMC_STATUSCMC_ADD_EXTENSIONSCMC_ADD_ATTRIBUTESX509_CERTIFICATE_TEMPLATEOCSP_SIGNED_REQUESTOCSP_BASIC_SIGNED_RESPONSEOCSP_BASIC_RESPONSEX509_LOGOTYPE_EXTX509_BIOMETRIC_EXTCNG_RSA_PUBLIC_KEY_BLOBX509_OBJECT_IDENTIFIERX509_ALGORITHM_IDENTIFIERPKCS_RSA_SSA_PSS_PARAMETERSPKCS_RSAES_OAEP_PARAMETERSECC_CMS_SHARED_INFOTIMESTAMP_REQUESTTIMESTAMP_RESPONSETIMESTAMP_INFOX509_CERT_BUNDLEX509_ECC_PRIVATE_KEYCNG_RSA_PRIVATE_KEY_BLOBX509_SUBJECT_DIR_ATTRSX509_ECC_PARAMETERSCMS_SIGNER_INFOszOID_AUTHORITY_KEY_IDENTIFIERszOID_KEY_ATTRIBUTESszOID_CERT_POLICIES_95szOID_KEY_USAGE_RESTRICTIONszOID_SUBJECT_ALT_NAMEszOID_ISSUER_ALT_NAMEszOID_BASIC_CONSTRAINTSszOID_KEY_USAGEszOID_PRIVATEKEY_USAGE_PERIODszOID_BASIC_CONSTRAINTS2szOID_CERT_POLICIESszOID_ANY_CERT_POLICYszOID_INHIBIT_ANY_POLICYszOID_AUTHORITY_KEY_IDENTIFIER2szOID_SUBJECT_KEY_IDENTIFIERszOID_SUBJECT_ALT_NAME2szOID_ISSUER_ALT_NAME2szOID_CRL_REASON_CODEszOID_REASON_CODE_HOLDszOID_CRL_DIST_POINTSszOID_ENHANCED_KEY_USAGEszOID_ANY_ENHANCED_KEY_USAGEszOID_CRL_NUMBERszOID_DELTA_CRL_INDICATORszOID_ISSUING_DIST_POINTszOID_FRESHEST_CRLszOID_NAME_CONSTRAINTSszOID_POLICY_MAPPINGSszOID_LEGACY_POLICY_MAPPINGSszOID_POLICY_CONSTRAINTSszOID_RENEWAL_CERTIFICATEszOID_ENROLLMENT_NAME_VALUE_PAIRszOID_ENROLLMENT_CSP_PROVIDERszOID_OS_VERSIONszOID_ENROLLMENT_AGENTszOID_PKIXszOID_PKIX_PEszOID_AUTHORITY_INFO_ACCESSszOID_SUBJECT_INFO_ACCESSszOID_BIOMETRIC_EXTszOID_QC_STATEMENTS_EXTszOID_LOGOTYPE_EXTszOID_TLS_FEATURES_EXTszOID_CERT_EXTENSIONSszOID_NEXT_UPDATE_LOCATIONszOID_REMOVE_CERTIFICATEszOID_CROSS_CERT_DIST_POINTSszOID_CTLszOID_SORTED_CTLszOID_SERIALIZEDszOID_NT_PRINCIPAL_NAMEszOID_INTERNATIONALIZED_EMAIL_ADDRESSszOID_PRODUCT_UPDATEszOID_ANY_APPLICATION_POLICYszOID_AUTO_ENROLL_CTL_USAGEszOID_ENROLL_CERTTYPE_EXTENSIONszOID_CERT_MANIFOLDszOID_CERTSRV_CA_VERSIONszOID_CERTSRV_PREVIOUS_CERT_HASHszOID_CRL_VIRTUAL_BASEszOID_CRL_NEXT_PUBLISHszOID_KP_CA_EXCHANGEszOID_KP_PRIVACY_CAszOID_KP_KEY_RECOVERY_AGENTszOID_CERTIFICATE_TEMPLATEszOID_ENTERPRISE_OID_ROOTszOID_RDN_DUMMY_SIGNERszOID_APPLICATION_CERT_POLICIESszOID_APPLICATION_POLICY_MAPPINGSszOID_APPLICATION_POLICY_CONSTRAINTSszOID_ARCHIVED_KEY_ATTRszOID_CRL_SELF_CDPszOID_REQUIRE_CERT_CHAIN_POLICYszOID_ARCHIVED_KEY_CERT_HASHszOID_ISSUED_CERT_HASHszOID_DS_EMAIL_REPLICATIONszOID_REQUEST_CLIENT_INFOszOID_ENCRYPTED_KEY_HASHszOID_CERTSRV_CROSSCA_VERSIONszOID_NTDS_REPLICATIONszOID_SUBJECT_DIR_ATTRSszOID_PKIX_KPszOID_PKIX_KP_SERVER_AUTHszOID_PKIX_KP_CLIENT_AUTHszOID_PKIX_KP_CODE_SIGNINGszOID_PKIX_KP_EMAIL_PROTECTIONszOID_PKIX_KP_IPSEC_END_SYSTEMszOID_PKIX_KP_IPSEC_TUNNELszOID_PKIX_KP_IPSEC_USERszOID_PKIX_KP_TIMESTAMP_SIGNINGszOID_PKIX_KP_OCSP_SIGNINGszOID_PKIX_OCSP_NOCHECKszOID_PKIX_OCSP_NONCEszOID_IPSEC_KP_IKE_INTERMEDIATEszOID_PKINIT_KP_KDCszOID_KP_CTL_USAGE_SIGNINGszOID_KP_TIME_STAMP_SIGNINGszOID_SERVER_GATED_CRYPTOszOID_SGC_NETSCAPEszOID_KP_EFSszOID_EFS_RECOVERYszOID_WHQL_CRYPTOszOID_ATTEST_WHQL_CRYPTOszOID_NT5_CRYPTOszOID_OEM_WHQL_CRYPTOszOID_EMBEDDED_NT_CRYPTOszOID_ROOT_LIST_SIGNERszOID_KP_QUALIFIED_SUBORDINATIONszOID_KP_KEY_RECOVERYszOID_KP_DOCUMENT_SIGNINGszOID_KP_LIFETIME_SIGNINGszOID_KP_MOBILE_DEVICE_SOFTWAREszOID_KP_SMART_DISPLAYszOID_KP_CSP_SIGNATUREszOID_KP_FLIGHT_SIGNINGszOID_PLATFORM_MANIFEST_BINARY_IDszOID_DRMszOID_DRM_INDIVIDUALIZATIONszOID_LICENSESszOID_LICENSE_SERVERszOID_KP_SMARTCARD_LOGONszOID_KP_KERNEL_MODE_CODE_SIGNINGszOID_KP_KERNEL_MODE_TRUSTED_BOOT_SIGNINGszOID_REVOKED_LIST_SIGNERszOID_WINDOWS_KITS_SIGNERszOID_WINDOWS_RT_SIGNERszOID_PROTECTED_PROCESS_LIGHT_SIGNERszOID_WINDOWS_TCB_SIGNERszOID_PROTECTED_PROCESS_SIGNERszOID_WINDOWS_THIRD_PARTY_COMPONENT_SIGNERszOID_WINDOWS_SOFTWARE_EXTENSION_SIGNERszOID_DISALLOWED_LISTszOID_PIN_RULES_SIGNERszOID_PIN_RULES_CTLszOID_PIN_RULES_EXTszOID_PIN_RULES_DOMAIN_NAMEszOID_PIN_RULES_LOG_END_DATE_EXTszOID_IUM_SIGNINGszOID_EV_WHQL_CRYPTOszOID_SYNC_ROOT_CTL_EXTszOID_HPKP_DOMAIN_NAME_CTLszOID_HPKP_HEADER_VALUE_CTLszOID_KP_KERNEL_MODE_HAL_EXTENSION_SIGNINGszOID_WINDOWS_STORE_SIGNERszOID_DYNAMIC_CODE_GEN_SIGNERszOID_MICROSOFT_PUBLISHER_SIGNERszOID_YESNO_TRUST_ATTRszOID_SITE_PIN_RULES_INDEX_ATTRszOID_SITE_PIN_RULES_FLAGS_ATTRszOID_PKIX_POLICY_QUALIFIER_CPSszOID_PKIX_POLICY_QUALIFIER_USERNOTICEszOID_ROOT_PROGRAM_FLAGSCERT_ROOT_PROGRAM_FLAG_ORGCERT_ROOT_PROGRAM_FLAG_LSCCERT_ROOT_PROGRAM_FLAG_SUBJECT_LOGOCERT_ROOT_PROGRAM_FLAG_OUCERT_ROOT_PROGRAM_FLAG_ADDRESSszOID_CERT_POLICIES_95_QUALIFIER1szOID_RDN_TPM_MANUFACTURERszOID_RDN_TPM_MODELszOID_RDN_TPM_VERSIONszOID_RDN_TCG_PLATFORM_MANUFACTURERszOID_RDN_TCG_PLATFORM_MODELszOID_RDN_TCG_PLATFORM_VERSIONszOID_ENROLL_EK_INFOszOID_ENROLL_AIK_INFOszOID_ENROLL_ATTESTATION_STATEMENTszOID_ENROLL_KSP_NAMEszOID_ENROLL_EKPUB_CHALLENGEszOID_ENROLL_CAXCHGCERT_HASHszOID_ENROLL_ATTESTATION_CHALLENGEszOID_ENROLL_ENCRYPTION_ALGORITHMszOID_KP_TPM_EK_CERTIFICATEszOID_KP_TPM_PLATFORM_CERTIFICATEszOID_KP_TPM_AIK_CERTIFICATEszOID_ENROLL_EKVERIFYKEYszOID_ENROLL_EKVERIFYCERTszOID_ENROLL_EKVERIFYCREDSszOID_ENROLL_SCEP_ERRORszOID_ENROLL_SCEP_SERVER_STATEszOID_ENROLL_SCEP_CHALLENGE_ANSWERszOID_ENROLL_SCEP_CLIENT_REQUESTszOID_ENROLL_SCEP_SERVER_MESSAGEszOID_ENROLL_SCEP_SERVER_SECRETszOID_ENROLL_KEY_AFFINITYszOID_ENROLL_SCEP_SIGNER_HASHszOID_ENROLL_EK_CA_KEYIDszOID_ATTR_SUPPORTED_ALGORITHMSszOID_ATTR_TPM_SPECIFICATIONszOID_ATTR_PLATFORM_SPECIFICATIONszOID_ATTR_TPM_SECURITY_ASSERTIONSPCERT_EXTENSIONSCERT_EXTENSIONSCERT_UNICODE_RDN_ERR_INDEX_MASKCERT_UNICODE_RDN_ERR_INDEX_SHIFTCERT_UNICODE_ATTR_ERR_INDEX_MASKCERT_UNICODE_ATTR_ERR_INDEX_SHIFTCERT_UNICODE_VALUE_ERR_INDEX_MASKCERT_UNICODE_VALUE_ERR_INDEX_SHIFTGET_CERT_UNICODE_RDN_ERR_INDEXGET_CERT_UNICODE_ATTR_ERR_INDEXGET_CERT_UNICODE_VALUE_ERR_INDEXPCERT_AUTHORITY_KEY_ID_INFOCERT_AUTHORITY_KEY_ID_INFOPCERT_PRIVATE_KEY_VALIDITYCERT_PRIVATE_KEY_VALIDITYPCERT_KEY_ATTRIBUTES_INFOCERT_KEY_ATTRIBUTES_INFOCERT_DIGITAL_SIGNATURE_KEY_USAGECERT_NON_REPUDIATION_KEY_USAGECERT_KEY_ENCIPHERMENT_KEY_USAGECERT_DATA_ENCIPHERMENT_KEY_USAGECERT_KEY_AGREEMENT_KEY_USAGECERT_KEY_CERT_SIGN_KEY_USAGECERT_OFFLINE_CRL_SIGN_KEY_USAGECERT_CRL_SIGN_KEY_USAGECERT_ENCIPHER_ONLY_KEY_USAGECERT_DECIPHER_ONLY_KEY_USAGEPCERT_POLICY_IDCERT_POLICY_IDPCERT_KEY_USAGE_RESTRICTION_INFOCERT_KEY_USAGE_RESTRICTION_INFOPCERT_OTHER_NAMECERT_OTHER_NAMEPCERT_ALT_NAME_ENTRYCERT_ALT_NAME_ENTRYCERT_ALT_NAME_OTHER_NAMECERT_ALT_NAME_RFC822_NAMECERT_ALT_NAME_DNS_NAMECERT_ALT_NAME_X400_ADDRESSCERT_ALT_NAME_DIRECTORY_NAMECERT_ALT_NAME_EDI_PARTY_NAMECERT_ALT_NAME_URLCERT_ALT_NAME_IP_ADDRESSCERT_ALT_NAME_REGISTERED_IDPCERT_ALT_NAME_INFOCERT_ALT_NAME_INFOCERT_ALT_NAME_ENTRY_ERR_INDEX_MASKCERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFTCERT_ALT_NAME_VALUE_ERR_INDEX_MASKCERT_ALT_NAME_VALUE_ERR_INDEX_SHIFTGET_CERT_ALT_NAME_ENTRY_ERR_INDEXGET_CERT_ALT_NAME_VALUE_ERR_INDEXPCERT_BASIC_CONSTRAINTS_INFOCERT_BASIC_CONSTRAINTS_INFOCERT_CA_SUBJECT_FLAGCERT_END_ENTITY_SUBJECT_FLAGPCERT_BASIC_CONSTRAINTS2_INFOCERT_BASIC_CONSTRAINTS2_INFOPCERT_POLICY_QUALIFIER_INFOCERT_POLICY_QUALIFIER_INFOPCERT_POLICY_INFOCERT_POLICY_INFOPCERT_POLICIES_INFOCERT_POLICIES_INFOPCERT_POLICY_QUALIFIER_NOTICE_REFERENCECERT_POLICY_QUALIFIER_NOTICE_REFERENCEPCERT_POLICY_QUALIFIER_USER_NOTICECERT_POLICY_QUALIFIER_USER_NOTICEPCPS_URLSCPS_URLSPCERT_POLICY95_QUALIFIER1CERT_POLICY95_QUALIFIER1PCERT_POLICY_MAPPINGCERT_POLICY_MAPPINGPCERT_POLICY_MAPPINGS_INFOCERT_POLICY_MAPPINGS_INFOPCERT_POLICY_CONSTRAINTS_INFOCERT_POLICY_CONSTRAINTS_INFOPCRYPT_CONTENT_INFO_SEQUENCE_OF_ANYCRYPT_CONTENT_INFO_SEQUENCE_OF_ANYPCRYPT_CONTENT_INFOCRYPT_CONTENT_INFOPCRYPT_SEQUENCE_OF_ANYCRYPT_SEQUENCE_OF_ANYPCERT_AUTHORITY_KEY_ID2_INFOCERT_AUTHORITY_KEY_ID2_INFOPCERT_ACCESS_DESCRIPTIONCERT_ACCESS_DESCRIPTIONPCERT_AUTHORITY_INFO_ACCESSCERT_AUTHORITY_INFO_ACCESSCERT_SUBJECT_INFO_ACCESSPCERT_SUBJECT_INFO_ACCESSszOID_PKIX_ACC_DESCRszOID_PKIX_OCSPszOID_PKIX_CA_ISSUERSszOID_PKIX_TIME_STAMPINGszOID_PKIX_CA_REPOSITORYPCRL_DIST_POINT_NAMECRL_DIST_POINT_NAMECRL_DIST_POINT_NO_NAMECRL_DIST_POINT_FULL_NAMECRL_DIST_POINT_ISSUER_RDN_NAMEPCRL_DIST_POINTCRL_DIST_POINTCRL_REASON_UNUSED_FLAGCRL_REASON_KEY_COMPROMISE_FLAGCRL_REASON_CA_COMPROMISE_FLAGCRL_REASON_AFFILIATION_CHANGED_FLAGCRL_REASON_SUPERSEDED_FLAGCRL_REASON_CESSATION_OF_OPERATION_FLAGCRL_REASON_CERTIFICATE_HOLD_FLAGCRL_REASON_PRIVILEGE_WITHDRAWN_FLAGCRL_REASON_AA_COMPROMISE_FLAGPCRL_DIST_POINTS_INFOCRL_DIST_POINTS_INFOCRL_DIST_POINT_ERR_INDEX_MASKCRL_DIST_POINT_ERR_INDEX_SHIFTGET_CRL_DIST_POINT_ERR_INDEXCRL_DIST_POINT_ERR_CRL_ISSUER_BITIS_CRL_DIST_POINT_ERR_CRL_ISSUERPCROSS_CERT_DIST_POINTS_INFOCROSS_CERT_DIST_POINTS_INFOCROSS_CERT_DIST_POINT_ERR_INDEX_MASKCROSS_CERT_DIST_POINT_ERR_INDEX_SHIFTGET_CROSS_CERT_DIST_POINT_ERR_INDEXPCERT_PAIRCERT_PAIRPCRL_ISSUING_DIST_POINTCRL_ISSUING_DIST_POINTPCERT_GENERAL_SUBTREECERT_GENERAL_SUBTREEPCERT_NAME_CONSTRAINTS_INFOCERT_NAME_CONSTRAINTS_INFOCERT_EXCLUDED_SUBTREE_BITIS_CERT_EXCLUDED_SUBTREESORTED_CTL_EXT_FLAGS_OFFSETSORTED_CTL_EXT_COUNT_OFFSETSORTED_CTL_EXT_MAX_COLLISION_OFFSETSORTED_CTL_EXT_HASH_BUCKET_OFFSETSORTED_CTL_EXT_HASHED_SUBJECT_IDENTIFIER_FLAGPCERT_DSS_PARAMETERSCERT_DSS_PARAMETERSCERT_DSS_R_LENCERT_DSS_S_LENCERT_DSS_SIGNATURE_LENCERT_MAX_ASN_ENCODED_DSS_SIGNATURE_LENPCERT_DH_PARAMETERSCERT_DH_PARAMETERSPCERT_ECC_SIGNATURECERT_ECC_SIGNATUREPCERT_X942_DH_VALIDATION_PARAMSCERT_X942_DH_VALIDATION_PARAMSPCERT_X942_DH_PARAMETERSCERT_X942_DH_PARAMETERSCRYPT_X942_COUNTER_BYTE_LENGTHCRYPT_X942_KEY_LENGTH_BYTE_LENGTHCRYPT_X942_PUB_INFO_BYTE_LENGTHPCRYPT_X942_OTHER_INFOCRYPT_X942_OTHER_INFOCRYPT_ECC_CMS_SHARED_INFO_SUPPPUBINFO_BYTE_LENGTHPCRYPT_ECC_CMS_SHARED_INFOCRYPT_ECC_CMS_SHARED_INFOPCRYPT_RC2_CBC_PARAMETERSCRYPT_RC2_CBC_PARAMETERSCRYPT_RC2_40BIT_VERSIONCRYPT_RC2_56BIT_VERSIONCRYPT_RC2_64BIT_VERSIONCRYPT_RC2_128BIT_VERSIONPCRYPT_SMIME_CAPABILITYCRYPT_SMIME_CAPABILITYPCRYPT_SMIME_CAPABILITIESCRYPT_SMIME_CAPABILITIESPCERT_QC_STATEMENTCERT_QC_STATEMENTPCERT_QC_STATEMENTS_EXT_INFOCERT_QC_STATEMENTS_EXT_INFOszOID_QC_EU_COMPLIANCEszOID_QC_SSCDPCRYPT_MASK_GEN_ALGORITHMCRYPT_MASK_GEN_ALGORITHMPCRYPT_RSA_SSA_PSS_PARAMETERSCRYPT_RSA_SSA_PSS_PARAMETERSPKCS_RSA_SSA_PSS_TRAILER_FIELD_BCPCRYPT_PSOURCE_ALGORITHMCRYPT_PSOURCE_ALGORITHMPCRYPT_RSAES_OAEP_PARAMETERSCRYPT_RSAES_OAEP_PARAMETERSszOID_VERISIGN_PRIVATE_6_9szOID_VERISIGN_ONSITE_JURISDICTION_HASHszOID_VERISIGN_BITSTRING_6_13szOID_VERISIGN_ISS_STRONG_CRYPTOszOIDVerisign_MessageTypeszOIDVerisign_PkiStatusszOIDVerisign_FailInfoszOIDVerisign_SenderNonceszOIDVerisign_RecipientNonceszOIDVerisign_TransactionIDszOID_NETSCAPEszOID_NETSCAPE_CERT_EXTENSIONszOID_NETSCAPE_CERT_TYPEszOID_NETSCAPE_BASE_URLszOID_NETSCAPE_REVOCATION_URLszOID_NETSCAPE_CA_REVOCATION_URLszOID_NETSCAPE_CERT_RENEWAL_URLszOID_NETSCAPE_CA_POLICY_URLszOID_NETSCAPE_SSL_SERVER_NAMEszOID_NETSCAPE_COMMENTszOID_NETSCAPE_DATA_TYPEszOID_NETSCAPE_CERT_SEQUENCENETSCAPE_SSL_CLIENT_AUTH_CERT_TYPENETSCAPE_SSL_SERVER_AUTH_CERT_TYPENETSCAPE_SMIME_CERT_TYPENETSCAPE_SIGN_CERT_TYPENETSCAPE_SSL_CA_CERT_TYPENETSCAPE_SMIME_CA_CERT_TYPENETSCAPE_SIGN_CA_CERT_TYPEszOID_CT_PKI_DATAszOID_CT_PKI_RESPONSEszOID_PKIX_NO_SIGNATUREszOID_CMCszOID_CMC_STATUS_INFOszOID_CMC_IDENTIFICATIONszOID_CMC_IDENTITY_PROOFszOID_CMC_DATA_RETURNszOID_CMC_TRANSACTION_IDszOID_CMC_SENDER_NONCEszOID_CMC_RECIPIENT_NONCEszOID_CMC_ADD_EXTENSIONSszOID_CMC_ENCRYPTED_POPszOID_CMC_DECRYPTED_POPszOID_CMC_LRA_POP_WITNESSszOID_CMC_GET_CERTszOID_CMC_GET_CRLszOID_CMC_REVOKE_REQUESTszOID_CMC_REG_INFOszOID_CMC_RESPONSE_INFOszOID_CMC_QUERY_PENDINGszOID_CMC_ID_POP_LINK_RANDOMszOID_CMC_ID_POP_LINK_WITNESSszOID_CMC_ID_CONFIRM_CERT_ACCEPTANCEszOID_CMC_ADD_ATTRIBUTESPCMC_TAGGED_ATTRIBUTECMC_TAGGED_ATTRIBUTEPCMC_TAGGED_CERT_REQUESTCMC_TAGGED_CERT_REQUESTPCMC_TAGGED_REQUESTCMC_TAGGED_REQUESTPCMC_TAGGED_CONTENT_INFOCMC_TAGGED_CONTENT_INFOPCMC_TAGGED_OTHER_MSGCMC_TAGGED_OTHER_MSGPCMC_DATA_INFOCMC_DATA_INFOPCMC_RESPONSE_INFOCMC_RESPONSE_INFOPCMC_PEND_INFOCMC_PEND_INFOPCMC_STATUS_INFOCMC_STATUS_INFOCMC_OTHER_INFO_NO_CHOICECMC_OTHER_INFO_FAIL_CHOICECMC_OTHER_INFO_PEND_CHOICECMC_STATUS_SUCCESSCMC_STATUS_FAILEDCMC_STATUS_PENDINGCMC_STATUS_NO_SUPPORTCMC_STATUS_CONFIRM_REQUIREDCMC_FAIL_BAD_ALGCMC_FAIL_BAD_MESSAGE_CHECKCMC_FAIL_BAD_REQUESTCMC_FAIL_BAD_TIMECMC_FAIL_BAD_CERT_IDCMC_FAIL_UNSUPORTED_EXTCMC_FAIL_MUST_ARCHIVE_KEYSCMC_FAIL_BAD_IDENTITYCMC_FAIL_POP_REQUIREDCMC_FAIL_POP_FAILEDCMC_FAIL_NO_KEY_REUSECMC_FAIL_INTERNAL_CA_ERRORCMC_FAIL_TRY_LATERPCMC_ADD_EXTENSIONS_INFOCMC_ADD_EXTENSIONS_INFOPCMC_ADD_ATTRIBUTES_INFOCMC_ADD_ATTRIBUTES_INFOPCERT_TEMPLATE_EXTCERT_TEMPLATE_EXTPCERT_HASHED_URLCERT_HASHED_URLPCERT_LOGOTYPE_DETAILSCERT_LOGOTYPE_DETAILSPCERT_LOGOTYPE_REFERENCECERT_LOGOTYPE_REFERENCEPCERT_LOGOTYPE_IMAGE_INFOCERT_LOGOTYPE_IMAGE_INFOCERT_LOGOTYPE_GRAY_SCALE_IMAGE_INFO_CHOICECERT_LOGOTYPE_COLOR_IMAGE_INFO_CHOICECERT_LOGOTYPE_NO_IMAGE_RESOLUTION_CHOICECERT_LOGOTYPE_BITS_IMAGE_RESOLUTION_CHOICECERT_LOGOTYPE_TABLE_SIZE_IMAGE_RESOLUTION_CHOICEPCERT_LOGOTYPE_IMAGECERT_LOGOTYPE_IMAGEPCERT_LOGOTYPE_AUDIO_INFOCERT_LOGOTYPE_AUDIO_INFOPCERT_LOGOTYPE_AUDIOCERT_LOGOTYPE_AUDIOPCERT_LOGOTYPE_DATACERT_LOGOTYPE_DATAPCERT_LOGOTYPE_INFOCERT_LOGOTYPE_INFOCERT_LOGOTYPE_DIRECT_INFO_CHOICECERT_LOGOTYPE_INDIRECT_INFO_CHOICEPCERT_OTHER_LOGOTYPE_INFOCERT_OTHER_LOGOTYPE_INFOszOID_LOYALTY_OTHER_LOGOTYPEszOID_BACKGROUND_OTHER_LOGOTYPEPCERT_LOGOTYPE_EXT_INFOCERT_LOGOTYPE_EXT_INFOPCERT_BIOMETRIC_DATACERT_BIOMETRIC_DATACERT_BIOMETRIC_PREDEFINED_DATA_CHOICECERT_BIOMETRIC_OID_DATA_CHOICECERT_BIOMETRIC_PICTURE_TYPECERT_BIOMETRIC_SIGNATURE_TYPEPCERT_BIOMETRIC_EXT_INFOCERT_BIOMETRIC_EXT_INFOPOCSP_SIGNATURE_INFOOCSP_SIGNATURE_INFOPOCSP_SIGNED_REQUEST_INFOOCSP_SIGNED_REQUEST_INFOPOCSP_CERT_IDOCSP_CERT_IDPOCSP_REQUEST_ENTRYOCSP_REQUEST_ENTRYPOCSP_REQUEST_INFOOCSP_REQUEST_INFOOCSP_REQUEST_V1POCSP_RESPONSE_INFOOCSP_RESPONSE_INFOOCSP_SUCCESSFUL_RESPONSEOCSP_MALFORMED_REQUEST_RESPONSEOCSP_INTERNAL_ERROR_RESPONSEOCSP_TRY_LATER_RESPONSEOCSP_SIG_REQUIRED_RESPONSEOCSP_UNAUTHORIZED_RESPONSEszOID_PKIX_OCSP_BASIC_SIGNED_RESPONSEPOCSP_BASIC_SIGNED_RESPONSE_INFOOCSP_BASIC_SIGNED_RESPONSE_INFOPOCSP_BASIC_REVOKED_INFOOCSP_BASIC_REVOKED_INFOPOCSP_BASIC_RESPONSE_ENTRYOCSP_BASIC_RESPONSE_ENTRYOCSP_BASIC_GOOD_CERT_STATUSOCSP_BASIC_REVOKED_CERT_STATUSOCSP_BASIC_UNKNOWN_CERT_STATUSPOCSP_BASIC_RESPONSE_INFOOCSP_BASIC_RESPONSE_INFOOCSP_BASIC_RESPONSE_V1OCSP_BASIC_BY_NAME_RESPONDER_IDOCSP_BASIC_BY_KEY_RESPONDER_IDPCERT_SUPPORTED_ALGORITHM_INFOCERT_SUPPORTED_ALGORITHM_INFOPCERT_TPM_SPECIFICATION_INFOCERT_TPM_SPECIFICATION_INFOHCRYPTOIDFUNCSETHCRYPTOIDFUNCADDRCRYPT_OID_ENCODE_OBJECT_FUNCCRYPT_OID_DECODE_OBJECT_FUNCCRYPT_OID_ENCODE_OBJECT_EX_FUNCCRYPT_OID_DECODE_OBJECT_EX_FUNCCRYPT_OID_CREATE_COM_OBJECT_FUNCCRYPT_OID_VERIFY_REVOCATION_FUNCCRYPT_OID_VERIFY_CTL_USAGE_FUNCCRYPT_OID_FORMAT_OBJECT_FUNCCRYPT_OID_FIND_OID_INFO_FUNCCRYPT_OID_FIND_LOCALIZED_NAME_FUNCCRYPT_OID_REGPATHCRYPT_OID_REG_ENCODING_TYPE_PREFIXCRYPT_OID_REG_DLL_VALUE_NAMECRYPT_OID_REG_FUNC_NAME_VALUE_NAMECRYPT_OID_REG_FLAGS_VALUE_NAMECRYPT_DEFAULT_OIDPCRYPT_OID_FUNC_ENTRYCRYPT_OID_FUNC_ENTRYCRYPT_INSTALL_OID_FUNC_BEFORE_FLAGCryptInstallOIDFunctionAddressCryptInitOIDFunctionSetCryptGetOIDFunctionAddressCRYPT_GET_INSTALLED_OID_FUNC_FLAGCryptGetDefaultOIDDllListCryptGetDefaultOIDFunctionAddressCryptFreeOIDFunctionAddressCryptRegisterOIDFunctionCryptUnregisterOIDFunctionCryptRegisterDefaultOIDFunctionCRYPT_REGISTER_FIRST_INDEXCRYPT_REGISTER_LAST_INDEXCryptUnregisterDefaultOIDFunctionCryptSetOIDFunctionValueCryptGetOIDFunctionValueCryptEnumOIDFunctionPFN_CRYPT_ENUM_OID_FUNCCRYPT_MATCH_ANY_ENCODING_TYPECALG_OID_INFO_CNG_ONLYCALG_OID_INFO_PARAMETERSIS_SPECIAL_OID_INFO_ALGIDCRYPT_OID_INFO_HASH_PARAMETERS_ALGORITHMCRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHMCRYPT_OID_INFO_MGF1_PARAMETERS_ALGORITHMCRYPT_OID_INFO_NO_SIGN_ALGORITHMCRYPT_OID_INFO_OAEP_PARAMETERS_ALGORITHMCRYPT_OID_INFO_ECC_WRAP_PARAMETERS_ALGORITHMCRYPT_OID_INFO_NO_PARAMETERS_ALGORITHMPCRYPT_OID_INFOCRYPT_OID_INFOPCCRYPT_OID_INFOCRYPT_HASH_ALG_OID_GROUP_IDCRYPT_ENCRYPT_ALG_OID_GROUP_IDCRYPT_PUBKEY_ALG_OID_GROUP_IDCRYPT_SIGN_ALG_OID_GROUP_IDCRYPT_RDN_ATTR_OID_GROUP_IDCRYPT_EXT_OR_ATTR_OID_GROUP_IDCRYPT_ENHKEY_USAGE_OID_GROUP_IDCRYPT_POLICY_OID_GROUP_IDCRYPT_TEMPLATE_OID_GROUP_IDCRYPT_KDF_OID_GROUP_IDCRYPT_LAST_OID_GROUP_IDCRYPT_FIRST_ALG_OID_GROUP_IDCRYPT_LAST_ALG_OID_GROUP_IDCRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAGCRYPT_OID_USE_PUBKEY_PARA_FOR_PKCS7_FLAGCRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAGCRYPT_OID_PUBKEY_SIGN_ONLY_FLAGCRYPT_OID_PUBKEY_ENCRYPT_ONLY_FLAGCRYPT_OID_USE_CURVE_NAME_FOR_ENCODE_FLAGCRYPT_OID_USE_CURVE_PARAMETERS_FOR_ENCODE_FLAGCryptFindOIDInfoCRYPT_OID_INFO_OID_KEYCRYPT_OID_INFO_NAME_KEYCRYPT_OID_INFO_ALGID_KEYCRYPT_OID_INFO_SIGN_KEYCRYPT_OID_INFO_CNG_ALGID_KEYCRYPT_OID_INFO_CNG_SIGN_KEYCRYPT_OID_INFO_OID_KEY_FLAGS_MASKCRYPT_OID_INFO_PUBKEY_SIGN_KEY_FLAGCRYPT_OID_INFO_PUBKEY_ENCRYPT_KEY_FLAGCRYPT_OID_DISABLE_SEARCH_DS_FLAGCRYPT_OID_PREFER_CNG_ALGID_FLAGCRYPT_OID_INFO_OID_GROUP_BIT_LEN_MASKCRYPT_OID_INFO_OID_GROUP_BIT_LEN_SHIFTCryptRegisterOIDInfoCryptUnregisterOIDInfoCryptEnumOIDInfoPFN_CRYPT_ENUM_OID_INFOCryptFindLocalizedNameCRYPT_LOCALIZED_NAME_ENCODING_TYPECRYPT_LOCALIZED_NAME_OIDPCERT_STRONG_SIGN_SERIALIZED_INFOCERT_STRONG_SIGN_SERIALIZED_INFOCERT_STRONG_SIGN_ECDSA_ALGORITHMPCERT_STRONG_SIGN_PARAPCCERT_STRONG_SIGN_PARACERT_STRONG_SIGN_SERIALIZED_INFO_CHOICECERT_STRONG_SIGN_OID_INFO_CHOICECERT_STRONG_SIGN_ENABLE_CRL_CHECKCERT_STRONG_SIGN_ENABLE_OCSP_CHECKszOID_CERT_STRONG_SIGN_OS_PREFIXszOID_CERT_STRONG_SIGN_OS_1szOID_CERT_STRONG_SIGN_OS_CURRENTszOID_CERT_STRONG_KEY_OS_PREFIXszOID_CERT_STRONG_KEY_OS_1szOID_CERT_STRONG_KEY_OS_CURRENTszOID_PKCS_7_DATAszOID_PKCS_7_SIGNEDszOID_PKCS_7_ENVELOPEDszOID_PKCS_7_SIGNEDANDENVELOPEDszOID_PKCS_7_DIGESTEDszOID_PKCS_7_ENCRYPTEDszOID_PKCS_9_CONTENT_TYPEszOID_PKCS_9_MESSAGE_DIGESTCMSG_SIGNEDCMSG_ENVELOPEDCMSG_SIGNED_AND_ENVELOPEDCMSG_HASHEDCMSG_ENCRYPTEDCMSG_ALL_FLAGSCMSG_DATA_FLAGCMSG_SIGNED_FLAGCMSG_ENVELOPED_FLAGCMSG_SIGNED_AND_ENVELOPED_FLAGCMSG_HASHED_FLAGCMSG_ENCRYPTED_FLAGPCERT_ISSUER_SERIAL_NUMBERCERT_ISSUER_SERIAL_NUMBERPCERT_IDCERT_IDCERT_ID_ISSUER_SERIAL_NUMBERCERT_ID_KEY_IDENTIFIERCERT_ID_SHA1_HASHPCMSG_SIGNER_ENCODE_INFOCMSG_SIGNER_ENCODE_INFOPCMSG_SIGNED_ENCODE_INFOCMSG_SIGNED_ENCODE_INFOPCMSG_RECIPIENT_ENCODE_INFOCMSG_RECIPIENT_ENCODE_INFOPCMSG_ENVELOPED_ENCODE_INFOCMSG_ENVELOPED_ENCODE_INFOPCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFOCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFOPCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFOCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFOPCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFOCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFOCMSG_KEY_AGREE_EPHEMERAL_KEY_CHOICECMSG_KEY_AGREE_STATIC_KEY_CHOICEPCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFOCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFOCMSG_MAIL_LIST_HANDLE_KEY_CHOICECMSG_KEY_TRANS_RECIPIENTCMSG_KEY_AGREE_RECIPIENTCMSG_MAIL_LIST_RECIPIENTPCMSG_RC2_AUX_INFOCMSG_RC2_AUX_INFOPCMSG_SP3_COMPATIBLE_AUX_INFOCMSG_SP3_COMPATIBLE_AUX_INFOCMSG_SP3_COMPATIBLE_ENCRYPT_FLAGPCMSG_RC4_AUX_INFOCMSG_RC4_AUX_INFOCMSG_RC4_NO_SALT_FLAGPCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFOCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFOPCMSG_HASHED_ENCODE_INFOCMSG_HASHED_ENCODE_INFOPCMSG_ENCRYPTED_ENCODE_INFOCMSG_ENCRYPTED_ENCODE_INFOCMSG_INDEFINITE_LENGTHPCMSG_STREAM_INFOCMSG_STREAM_INFOCMSG_BARE_CONTENT_FLAGCMSG_LENGTH_ONLY_FLAGCMSG_DETACHED_FLAGCMSG_AUTHENTICATED_ATTRIBUTES_FLAGCMSG_CONTENTS_OCTETS_FLAGCMSG_MAX_LENGTH_FLAGCMSG_CMS_ENCAPSULATED_CONTENT_FLAGCMSG_SIGNED_DATA_NO_SIGN_FLAGCMSG_CRYPT_RELEASE_CONTEXT_FLAGCryptMsgOpenToEncodeCryptMsgCalculateEncodedLengthCryptMsgOpenToDecodeCryptMsgDuplicateCryptMsgCloseCryptMsgUpdateCryptMsgGetParamCMSG_TYPE_PARAMCMSG_CONTENT_PARAMCMSG_BARE_CONTENT_PARAMCMSG_INNER_CONTENT_TYPE_PARAMCMSG_SIGNER_COUNT_PARAMCMSG_SIGNER_INFO_PARAMCMSG_SIGNER_CERT_INFO_PARAMCMSG_SIGNER_HASH_ALGORITHM_PARAMCMSG_SIGNER_AUTH_ATTR_PARAMCMSG_SIGNER_UNAUTH_ATTR_PARAMCMSG_CERT_COUNT_PARAMCMSG_CERT_PARAMCMSG_CRL_COUNT_PARAMCMSG_CRL_PARAMCMSG_ENVELOPE_ALGORITHM_PARAMCMSG_RECIPIENT_COUNT_PARAMCMSG_RECIPIENT_INDEX_PARAMCMSG_RECIPIENT_INFO_PARAMCMSG_HASH_ALGORITHM_PARAMCMSG_HASH_DATA_PARAMCMSG_COMPUTED_HASH_PARAMCMSG_ENCRYPT_PARAMCMSG_ENCRYPTED_DIGESTCMSG_ENCODED_SIGNERCMSG_ENCODED_MESSAGECMSG_VERSION_PARAMCMSG_ATTR_CERT_COUNT_PARAMCMSG_ATTR_CERT_PARAMCMSG_CMS_RECIPIENT_COUNT_PARAMCMSG_CMS_RECIPIENT_INDEX_PARAMCMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAMCMSG_CMS_RECIPIENT_INFO_PARAMCMSG_UNPROTECTED_ATTR_PARAMCMSG_SIGNER_CERT_ID_PARAMCMSG_CMS_SIGNER_INFO_PARAMPCMSG_SIGNER_INFOCMSG_SIGNER_INFOPCMSG_CMS_SIGNER_INFOCMSG_CMS_SIGNER_INFOCMSG_ATTRPCMSG_ATTRCMSG_SIGNED_DATA_V1CMSG_SIGNED_DATA_V3CMSG_SIGNED_DATA_PKCS_1_5_VERSIONCMSG_SIGNED_DATA_CMS_VERSIONCMSG_SIGNER_INFO_V1CMSG_SIGNER_INFO_V3CMSG_SIGNER_INFO_PKCS_1_5_VERSIONCMSG_SIGNER_INFO_CMS_VERSIONCMSG_HASHED_DATA_V0CMSG_HASHED_DATA_V2CMSG_HASHED_DATA_PKCS_1_5_VERSIONCMSG_HASHED_DATA_CMS_VERSIONCMSG_ENVELOPED_DATA_V0CMSG_ENVELOPED_DATA_V2CMSG_ENVELOPED_DATA_PKCS_1_5_VERSIONCMSG_ENVELOPED_DATA_CMS_VERSIONPCMSG_KEY_TRANS_RECIPIENT_INFOCMSG_KEY_TRANS_RECIPIENT_INFOPCMSG_RECIPIENT_ENCRYPTED_KEY_INFOCMSG_RECIPIENT_ENCRYPTED_KEY_INFOPCMSG_KEY_AGREE_RECIPIENT_INFOCMSG_KEY_AGREE_RECIPIENT_INFOCMSG_KEY_AGREE_ORIGINATOR_CERTCMSG_KEY_AGREE_ORIGINATOR_PUBLIC_KEYPCMSG_MAIL_LIST_RECIPIENT_INFOCMSG_MAIL_LIST_RECIPIENT_INFOPCMSG_CMS_RECIPIENT_INFOCMSG_CMS_RECIPIENT_INFOCMSG_ENVELOPED_RECIPIENT_V0CMSG_ENVELOPED_RECIPIENT_V2CMSG_ENVELOPED_RECIPIENT_V3CMSG_ENVELOPED_RECIPIENT_V4CMSG_KEY_TRANS_PKCS_1_5_VERSIONCMSG_KEY_TRANS_CMS_VERSIONCMSG_KEY_AGREE_VERSIONCMSG_MAIL_LIST_VERSIONCryptMsgControlCMSG_CTRL_VERIFY_SIGNATURECMSG_CTRL_DECRYPTCMSG_CTRL_VERIFY_HASHCMSG_CTRL_ADD_SIGNERCMSG_CTRL_DEL_SIGNERCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTRCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTRCMSG_CTRL_ADD_CERTCMSG_CTRL_DEL_CERTCMSG_CTRL_ADD_CRLCMSG_CTRL_DEL_CRLCMSG_CTRL_ADD_ATTR_CERTCMSG_CTRL_DEL_ATTR_CERTCMSG_CTRL_KEY_TRANS_DECRYPTCMSG_CTRL_KEY_AGREE_DECRYPTCMSG_CTRL_MAIL_LIST_DECRYPTCMSG_CTRL_VERIFY_SIGNATURE_EXCMSG_CTRL_ADD_CMS_SIGNER_INFOCMSG_CTRL_ENABLE_STRONG_SIGNATUREPCMSG_CTRL_VERIFY_SIGNATURE_EX_PARACMSG_CTRL_VERIFY_SIGNATURE_EX_PARACMSG_VERIFY_SIGNER_PUBKEYCMSG_VERIFY_SIGNER_CERTCMSG_VERIFY_SIGNER_CHAINCMSG_VERIFY_SIGNER_NULLPCMSG_CTRL_DECRYPT_PARACMSG_CTRL_DECRYPT_PARAPCMSG_CTRL_KEY_TRANS_DECRYPT_PARACMSG_CTRL_KEY_TRANS_DECRYPT_PARAPCMSG_CTRL_KEY_AGREE_DECRYPT_PARACMSG_CTRL_KEY_AGREE_DECRYPT_PARAPCMSG_CTRL_MAIL_LIST_DECRYPT_PARACMSG_CTRL_MAIL_LIST_DECRYPT_PARAPCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARACMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARAPCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARACMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARACryptMsgVerifyCountersignatureEncodedCryptMsgVerifyCountersignatureEncodedExCMSG_VERIFY_COUNTER_SIGN_ENABLE_STRONG_FLAGCryptMsgCountersignCryptMsgCountersignEncodedCMSG_OID_GEN_ENCRYPT_KEY_FUNCCMSG_OID_EXPORT_ENCRYPT_KEY_FUNCCMSG_OID_IMPORT_ENCRYPT_KEY_FUNCCMSG_DEFAULT_INSTALLABLE_FUNC_OIDPCMSG_CONTENT_ENCRYPT_INFOCMSG_CONTENT_ENCRYPT_INFOCMSG_CONTENT_ENCRYPT_PAD_ENCODED_LEN_FLAGCMSG_CONTENT_ENCRYPT_FREE_PARA_FLAGCMSG_CONTENT_ENCRYPT_FREE_OBJID_FLAGCMSG_CONTENT_ENCRYPT_RELEASE_CONTEXT_FLAGCMSG_OID_GEN_CONTENT_ENCRYPT_KEY_FUNCCMSG_OID_CAPI1_GEN_CONTENT_ENCRYPT_KEY_FUNCCMSG_OID_CNG_GEN_CONTENT_ENCRYPT_KEY_FUNCPCMSG_KEY_TRANS_ENCRYPT_INFOCMSG_KEY_TRANS_ENCRYPT_INFOCMSG_KEY_TRANS_ENCRYPT_FREE_PARA_FLAGCMSG_KEY_TRANS_ENCRYPT_FREE_OBJID_FLAGCMSG_OID_EXPORT_KEY_TRANS_FUNCCMSG_OID_CAPI1_EXPORT_KEY_TRANS_FUNCCMSG_OID_CNG_EXPORT_KEY_TRANS_FUNCPCMSG_KEY_AGREE_KEY_ENCRYPT_INFOCMSG_KEY_AGREE_KEY_ENCRYPT_INFOPCMSG_KEY_AGREE_ENCRYPT_INFOCMSG_KEY_AGREE_ENCRYPT_INFOCMSG_KEY_AGREE_ENCRYPT_FREE_PARA_FLAGCMSG_KEY_AGREE_ENCRYPT_FREE_MATERIAL_FLAGCMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_ALG_FLAGCMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_PARA_FLAGCMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_BITS_FLAGCMSG_KEY_AGREE_ENCRYPT_FREE_OBJID_FLAGCMSG_OID_EXPORT_KEY_AGREE_FUNCCMSG_OID_CAPI1_EXPORT_KEY_AGREE_FUNCCMSG_OID_CNG_EXPORT_KEY_AGREE_FUNCPCMSG_MAIL_LIST_ENCRYPT_INFOCMSG_MAIL_LIST_ENCRYPT_INFOCMSG_MAIL_LIST_ENCRYPT_FREE_PARA_FLAGCMSG_MAIL_LIST_ENCRYPT_FREE_OBJID_FLAGCMSG_OID_EXPORT_MAIL_LIST_FUNCCMSG_OID_CAPI1_EXPORT_MAIL_LIST_FUNCCMSG_OID_IMPORT_KEY_TRANS_FUNCCMSG_OID_CAPI1_IMPORT_KEY_TRANS_FUNCCMSG_OID_IMPORT_KEY_AGREE_FUNCCMSG_OID_CAPI1_IMPORT_KEY_AGREE_FUNCCMSG_OID_IMPORT_MAIL_LIST_FUNCCMSG_OID_CAPI1_IMPORT_MAIL_LIST_FUNCPCMSG_CNG_CONTENT_DECRYPT_INFOCMSG_CNG_CONTENT_DECRYPT_INFOCMSG_OID_CNG_IMPORT_KEY_TRANS_FUNCCMSG_OID_CNG_IMPORT_KEY_AGREE_FUNCCMSG_OID_CNG_IMPORT_CONTENT_ENCRYPT_KEY_FUNCPCERT_CONTEXTPCRL_CONTEXTCRL_CONTEXTPCCRL_CONTEXTPCTL_CONTEXTCTL_CONTEXTPCCTL_CONTEXTCERT_KEY_PROV_HANDLE_PROP_IDCERT_KEY_PROV_INFO_PROP_IDCERT_SHA1_HASH_PROP_IDCERT_MD5_HASH_PROP_IDCERT_HASH_PROP_IDCERT_KEY_CONTEXT_PROP_IDCERT_KEY_SPEC_PROP_IDCERT_IE30_RESERVED_PROP_IDCERT_PUBKEY_HASH_RESERVED_PROP_IDCERT_ENHKEY_USAGE_PROP_IDCERT_CTL_USAGE_PROP_IDCERT_NEXT_UPDATE_LOCATION_PROP_IDCERT_FRIENDLY_NAME_PROP_IDCERT_PVK_FILE_PROP_IDCERT_DESCRIPTION_PROP_IDCERT_ACCESS_STATE_PROP_IDCERT_SIGNATURE_HASH_PROP_IDCERT_SMART_CARD_DATA_PROP_IDCERT_EFS_PROP_IDCERT_FORTEZZA_DATA_PROP_IDCERT_ARCHIVED_PROP_IDCERT_KEY_IDENTIFIER_PROP_IDCERT_AUTO_ENROLL_PROP_IDCERT_PUBKEY_ALG_PARA_PROP_IDCERT_CROSS_CERT_DIST_POINTS_PROP_IDCERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_IDCERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_IDCERT_ENROLLMENT_PROP_IDCERT_DATE_STAMP_PROP_IDCERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_IDCERT_SUBJECT_NAME_MD5_HASH_PROP_IDCERT_EXTENDED_ERROR_INFO_PROP_IDCERT_RENEWAL_PROP_IDCERT_ARCHIVED_KEY_HASH_PROP_IDCERT_AUTO_ENROLL_RETRY_PROP_IDCERT_AIA_URL_RETRIEVED_PROP_IDCERT_AUTHORITY_INFO_ACCESS_PROP_IDCERT_BACKED_UP_PROP_IDCERT_REQUEST_ORIGINATOR_PROP_IDCERT_SOURCE_LOCATION_PROP_IDCERT_SOURCE_URL_PROP_IDCERT_NEW_KEY_PROP_IDCERT_OCSP_CACHE_PREFIX_PROP_IDCERT_SMART_CARD_ROOT_INFO_PROP_IDCERT_NO_AUTO_EXPIRE_CHECK_PROP_IDCERT_NCRYPT_KEY_HANDLE_PROP_IDCERT_HCRYPTPROV_OR_NCRYPT_KEY_HANDLE_PROP_IDCERT_SUBJECT_INFO_ACCESS_PROP_IDCERT_CA_OCSP_AUTHORITY_INFO_ACCESS_PROP_IDCERT_CA_DISABLE_CRL_PROP_IDCERT_ROOT_PROGRAM_CERT_POLICIES_PROP_IDCERT_ROOT_PROGRAM_NAME_CONSTRAINTS_PROP_IDCERT_SUBJECT_OCSP_AUTHORITY_INFO_ACCESS_PROP_IDCERT_SUBJECT_DISABLE_CRL_PROP_IDCERT_CEP_PROP_IDCERT_SIGN_HASH_CNG_ALG_PROP_IDCERT_SCARD_PIN_ID_PROP_IDCERT_SCARD_PIN_INFO_PROP_IDCERT_SUBJECT_PUB_KEY_BIT_LENGTH_PROP_IDCERT_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_IDCERT_ISSUER_PUB_KEY_BIT_LENGTH_PROP_IDCERT_ISSUER_CHAIN_SIGN_HASH_CNG_ALG_PROP_IDCERT_ISSUER_CHAIN_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_IDCERT_NO_EXPIRE_NOTIFICATION_PROP_IDCERT_AUTH_ROOT_SHA256_HASH_PROP_IDCERT_NCRYPT_KEY_HANDLE_TRANSFER_PROP_IDCERT_HCRYPTPROV_TRANSFER_PROP_IDCERT_SMART_CARD_READER_PROP_IDCERT_SEND_AS_TRUSTED_ISSUER_PROP_IDCERT_KEY_REPAIR_ATTEMPTED_PROP_IDCERT_DISALLOWED_FILETIME_PROP_IDCERT_ROOT_PROGRAM_CHAIN_POLICIES_PROP_IDCERT_SMART_CARD_READER_NON_REMOVABLE_PROP_IDCERT_SHA256_HASH_PROP_IDCERT_SCEP_SERVER_CERTS_PROP_IDCERT_SCEP_RA_SIGNATURE_CERT_PROP_IDCERT_SCEP_RA_ENCRYPTION_CERT_PROP_IDCERT_SCEP_CA_CERT_PROP_IDCERT_SCEP_SIGNER_CERT_PROP_IDCERT_SCEP_NONCE_PROP_IDCERT_SCEP_ENCRYPT_HASH_CNG_ALG_PROP_IDCERT_SCEP_FLAGS_PROP_IDCERT_SCEP_GUID_PROP_IDCERT_SERIALIZABLE_KEY_CONTEXT_PROP_IDCERT_ISOLATED_KEY_PROP_IDCERT_SERIAL_CHAIN_PROP_IDCERT_KEY_CLASSIFICATION_PROP_IDCERT_OCSP_MUST_STAPLE_PROP_IDCERT_DISALLOWED_ENHKEY_USAGE_PROP_IDCERT_NONCOMPLIANT_ROOT_URL_PROP_IDCERT_PIN_SHA256_HASH_PROP_IDCERT_CLR_DELETE_KEY_PROP_IDCERT_NOT_BEFORE_FILETIME_PROP_IDCERT_NOT_BEFORE_ENHKEY_USAGE_PROP_IDCERT_FIRST_RESERVED_PROP_IDCERT_LAST_RESERVED_PROP_IDCERT_FIRST_USER_PROP_IDCERT_LAST_USER_PROP_IDIS_CERT_HASH_PROP_IDIS_PUBKEY_HASH_PROP_IDIS_CHAIN_HASH_PROP_IDIS_STRONG_SIGN_PROP_IDszOID_CERT_PROP_ID_PREFIXszOID_CERT_KEY_IDENTIFIER_PROP_IDszOID_CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_IDszOID_CERT_SUBJECT_NAME_MD5_HASH_PROP_IDszOID_CERT_MD5_HASH_PROP_IDszOID_CERT_SIGNATURE_HASH_PROP_IDszOID_DISALLOWED_HASHszOID_CERT_DISALLOWED_FILETIME_PROP_IDCERT_ACCESS_STATE_WRITE_PERSIST_FLAGCERT_ACCESS_STATE_SYSTEM_STORE_FLAGCERT_ACCESS_STATE_LM_SYSTEM_STORE_FLAGCERT_ACCESS_STATE_GP_SYSTEM_STORE_FLAGCERT_ACCESS_STATE_SHARED_USER_FLAGszOID_ROOT_PROGRAM_AUTO_UPDATE_CA_REVOCATIONszOID_ROOT_PROGRAM_AUTO_UPDATE_END_REVOCATIONszOID_ROOT_PROGRAM_NO_OCSP_FAILOVER_TO_CRLPCRYPT_KEY_PROV_PARAMCRYPT_KEY_PROV_PARAMPCRYPT_KEY_PROV_INFOCRYPT_KEY_PROV_INFOCERT_SET_KEY_PROV_HANDLE_PROP_IDCERT_SET_KEY_CONTEXT_PROP_IDCERT_NCRYPT_KEY_SPECPCERT_KEY_CONTEXTCERT_KEY_CONTEXTPROOT_INFO_LUIDROOT_INFO_LUIDPCRYPT_SMART_CARD_ROOT_INFOCRYPT_SMART_CARD_ROOT_INFOCERT_STORE_PROV_MSGCERT_STORE_PROV_FILECERT_STORE_PROV_REGCERT_STORE_PROV_PKCS7CERT_STORE_PROV_SERIALIZEDCERT_STORE_PROV_FILENAME_ACERT_STORE_PROV_FILENAME_WCERT_STORE_PROV_FILENAMECERT_STORE_PROV_SYSTEM_ACERT_STORE_PROV_SYSTEM_WCERT_STORE_PROV_SYSTEMCERT_STORE_PROV_COLLECTIONCERT_STORE_PROV_SYSTEM_REGISTRY_ACERT_STORE_PROV_SYSTEM_REGISTRY_WCERT_STORE_PROV_SYSTEM_REGISTRYCERT_STORE_PROV_PHYSICAL_WCERT_STORE_PROV_PHYSICALCERT_STORE_PROV_SMART_CARD_WCERT_STORE_PROV_SMART_CARDCERT_STORE_PROV_LDAP_WCERT_STORE_PROV_LDAPCERT_STORE_PROV_PKCS12sz_CERT_STORE_PROV_MEMORYsz_CERT_STORE_PROV_FILENAME_Wsz_CERT_STORE_PROV_FILENAMEsz_CERT_STORE_PROV_SYSTEM_Wsz_CERT_STORE_PROV_SYSTEMsz_CERT_STORE_PROV_PKCS7sz_CERT_STORE_PROV_PKCS12sz_CERT_STORE_PROV_SERIALIZEDsz_CERT_STORE_PROV_COLLECTIONsz_CERT_STORE_PROV_SYSTEM_REGISTRY_Wsz_CERT_STORE_PROV_SYSTEM_REGISTRYsz_CERT_STORE_PROV_PHYSICAL_Wsz_CERT_STORE_PROV_PHYSICALsz_CERT_STORE_PROV_SMART_CARD_Wsz_CERT_STORE_PROV_SMART_CARDsz_CERT_STORE_PROV_LDAP_Wsz_CERT_STORE_PROV_LDAPCERT_STORE_SIGNATURE_FLAGCERT_STORE_TIME_VALIDITY_FLAGCERT_STORE_REVOCATION_FLAGCERT_STORE_NO_CRL_FLAGCERT_STORE_NO_ISSUER_FLAGCERT_STORE_BASE_CRL_FLAGCERT_STORE_DELTA_CRL_FLAGCERT_STORE_NO_CRYPT_RELEASE_FLAGCERT_STORE_SET_LOCALIZED_NAME_FLAGCERT_STORE_DELETE_FLAGCERT_STORE_SHARE_STORE_FLAGCERT_STORE_SHARE_CONTEXT_FLAGCERT_STORE_MANIFOLD_FLAGCERT_STORE_ENUM_ARCHIVED_FLAGCERT_STORE_UPDATE_KEYID_FLAGCERT_STORE_BACKUP_RESTORE_FLAGCERT_STORE_READONLY_FLAGCERT_STORE_OPEN_EXISTING_FLAGCERT_STORE_CREATE_NEW_FLAGCERT_STORE_MAXIMUM_ALLOWED_FLAGCERT_SYSTEM_STORE_MASKCERT_SYSTEM_STORE_RELOCATE_FLAGPCERT_SYSTEM_STORE_RELOCATE_PARACERT_SYSTEM_STORE_RELOCATE_PARACERT_SYSTEM_STORE_UNPROTECTED_FLAGCERT_SYSTEM_STORE_LOCATION_MASKCERT_SYSTEM_STORE_LOCATION_SHIFTCERT_SYSTEM_STORE_CURRENT_USER_IDCERT_SYSTEM_STORE_LOCAL_MACHINE_IDCERT_SYSTEM_STORE_CURRENT_SERVICE_IDCERT_SYSTEM_STORE_SERVICES_IDCERT_SYSTEM_STORE_USERS_IDCERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_IDCERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_IDCERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_IDCERT_SYSTEM_STORE_CURRENT_USERCERT_SYSTEM_STORE_LOCAL_MACHINECERT_SYSTEM_STORE_CURRENT_SERVICECERT_SYSTEM_STORE_SERVICESCERT_SYSTEM_STORE_USERSCERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICYCERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICYCERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISECERT_GROUP_POLICY_SYSTEM_STORE_REGPATHCERT_EFSBLOB_REGPATHCERT_EFSBLOB_VALUE_NAMECERT_PROT_ROOT_FLAGS_REGPATHCERT_PROT_ROOT_FLAGS_VALUE_NAMECERT_PROT_ROOT_DISABLE_CURRENT_USER_FLAGCERT_PROT_ROOT_INHIBIT_ADD_AT_INIT_FLAGCERT_PROT_ROOT_INHIBIT_PURGE_LM_FLAGCERT_PROT_ROOT_DISABLE_LM_AUTH_FLAGCERT_PROT_ROOT_ONLY_LM_GPT_FLAGCERT_PROT_ROOT_DISABLE_NT_AUTH_REQUIRED_FLAGCERT_PROT_ROOT_DISABLE_NOT_DEFINED_NAME_CONSTRAINT_FLAGCERT_PROT_ROOT_DISABLE_PEER_TRUSTCERT_PROT_ROOT_PEER_USAGES_VALUE_NAMECERT_PROT_ROOT_PEER_USAGES_VALUE_NAME_ACERT_PROT_ROOT_PEER_USAGES_DEFAULT_ACERT_TRUST_PUB_SAFER_GROUP_POLICY_REGPATHCERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATHCERT_TRUST_PUB_SAFER_LOCAL_MACHINE_REGPATHCERT_TRUST_PUB_AUTHENTICODE_FLAGS_VALUE_NAMECERT_TRUST_PUB_ALLOW_TRUST_MASKCERT_TRUST_PUB_ALLOW_END_USER_TRUSTCERT_TRUST_PUB_ALLOW_MACHINE_ADMIN_TRUSTCERT_TRUST_PUB_ALLOW_ENTERPRISE_ADMIN_TRUSTCERT_TRUST_PUB_CHECK_PUBLISHER_REV_FLAGCERT_TRUST_PUB_CHECK_TIMESTAMP_REV_FLAGCERT_OCM_SUBCOMPONENTS_LOCAL_MACHINE_REGPATHCERT_OCM_SUBCOMPONENTS_ROOT_AUTO_UPDATE_VALUE_NAMECERT_DISABLE_ROOT_AUTO_UPDATE_REGPATHCERT_DISABLE_ROOT_AUTO_UPDATE_VALUE_NAMECERT_ENABLE_DISALLOWED_CERT_AUTO_UPDATE_VALUE_NAMECERT_DISABLE_PIN_RULES_AUTO_UPDATE_VALUE_NAMECERT_AUTO_UPDATE_LOCAL_MACHINE_REGPATHCERT_AUTO_UPDATE_ROOT_DIR_URL_VALUE_NAMECERT_AUTO_UPDATE_SYNC_FROM_DIR_URL_VALUE_NAMECERT_AUTH_ROOT_AUTO_UPDATE_LOCAL_MACHINE_REGPATHCERT_AUTH_ROOT_AUTO_UPDATE_ROOT_DIR_URL_VALUE_NAMECERT_AUTH_ROOT_AUTO_UPDATE_SYNC_DELTA_TIME_VALUE_NAMECERT_AUTH_ROOT_AUTO_UPDATE_FLAGS_VALUE_NAMECERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_UNTRUSTED_ROOT_LOGGING_FLAGCERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_PARTIAL_CHAIN_LOGGING_FLAGCERT_AUTO_UPDATE_DISABLE_RANDOM_QUERY_STRING_FLAGCERT_AUTH_ROOT_AUTO_UPDATE_LAST_SYNC_TIME_VALUE_NAMECERT_AUTH_ROOT_AUTO_UPDATE_ENCODED_CTL_VALUE_NAMECERT_AUTH_ROOT_CTL_FILENAMECERT_AUTH_ROOT_CTL_FILENAME_ACERT_AUTH_ROOT_CAB_FILENAMECERT_AUTH_ROOT_SEQ_FILENAMECERT_AUTH_ROOT_CERT_EXTCERT_DISALLOWED_CERT_AUTO_UPDATE_SYNC_DELTA_TIME_VALUE_NAMECERT_DISALLOWED_CERT_AUTO_UPDATE_LAST_SYNC_TIME_VALUE_NAMECERT_DISALLOWED_CERT_AUTO_UPDATE_ENCODED_CTL_VALUE_NAMECERT_DISALLOWED_CERT_CTL_FILENAMECERT_DISALLOWED_CERT_CTL_FILENAME_ACERT_DISALLOWED_CERT_CAB_FILENAMECERT_DISALLOWED_CERT_AUTO_UPDATE_LIST_IDENTIFIERCERT_PIN_RULES_AUTO_UPDATE_SYNC_DELTA_TIME_VALUE_NAMECERT_PIN_RULES_AUTO_UPDATE_LAST_SYNC_TIME_VALUE_NAMECERT_PIN_RULES_AUTO_UPDATE_ENCODED_CTL_VALUE_NAMECERT_PIN_RULES_CTL_FILENAMECERT_PIN_RULES_CTL_FILENAME_ACERT_PIN_RULES_CAB_FILENAMECERT_PIN_RULES_AUTO_UPDATE_LIST_IDENTIFIERCERT_REGISTRY_STORE_REMOTE_FLAGCERT_REGISTRY_STORE_SERIALIZED_FLAGCERT_REGISTRY_STORE_CLIENT_GPT_FLAGCERT_REGISTRY_STORE_LM_GPT_FLAGPCERT_REGISTRY_STORE_CLIENT_GPT_PARACERT_REGISTRY_STORE_CLIENT_GPT_PARACERT_REGISTRY_STORE_ROAMING_FLAGPCERT_REGISTRY_STORE_ROAMING_PARACERT_REGISTRY_STORE_ROAMING_PARACERT_REGISTRY_STORE_MY_IE_DIRTY_FLAGCERT_REGISTRY_STORE_EXTERNAL_FLAGCERT_IE_DIRTY_FLAGS_REGPATHCERT_FILE_STORE_COMMIT_ENABLE_FLAGCERT_LDAP_STORE_SIGN_FLAGCERT_LDAP_STORE_AREC_EXCLUSIVE_FLAGCERT_LDAP_STORE_OPENED_FLAGPCERT_LDAP_STORE_OPENED_PARACERT_LDAP_STORE_OPENED_PARACERT_LDAP_STORE_UNBIND_FLAGHCERTSTOREPROVCRYPT_OID_OPEN_STORE_PROV_FUNCPCERT_STORE_PROV_INFOCERT_STORE_PROV_INFOCERT_STORE_PROV_EXTERNAL_FLAGCERT_STORE_PROV_DELETED_FLAGCERT_STORE_PROV_NO_PERSIST_FLAGCERT_STORE_PROV_SYSTEM_STORE_FLAGCERT_STORE_PROV_LM_SYSTEM_STORE_FLAGCERT_STORE_PROV_GP_SYSTEM_STORE_FLAGCERT_STORE_PROV_SHARED_USER_FLAGCERT_STORE_PROV_CLOSE_FUNCCERT_STORE_PROV_READ_CERT_FUNCCERT_STORE_PROV_WRITE_CERT_FUNCCERT_STORE_PROV_DELETE_CERT_FUNCCERT_STORE_PROV_SET_CERT_PROPERTY_FUNCCERT_STORE_PROV_READ_CRL_FUNCCERT_STORE_PROV_WRITE_CRL_FUNCCERT_STORE_PROV_DELETE_CRL_FUNCCERT_STORE_PROV_SET_CRL_PROPERTY_FUNCCERT_STORE_PROV_READ_CTL_FUNCCERT_STORE_PROV_WRITE_CTL_FUNCCERT_STORE_PROV_DELETE_CTL_FUNCCERT_STORE_PROV_SET_CTL_PROPERTY_FUNCCERT_STORE_PROV_CONTROL_FUNCCERT_STORE_PROV_FIND_CERT_FUNCCERT_STORE_PROV_FREE_FIND_CERT_FUNCCERT_STORE_PROV_GET_CERT_PROPERTY_FUNCCERT_STORE_PROV_FIND_CRL_FUNCCERT_STORE_PROV_FREE_FIND_CRL_FUNCCERT_STORE_PROV_GET_CRL_PROPERTY_FUNCCERT_STORE_PROV_FIND_CTL_FUNCCERT_STORE_PROV_FREE_FIND_CTL_FUNCCERT_STORE_PROV_GET_CTL_PROPERTY_FUNCCERT_STORE_PROV_WRITE_ADD_FLAGPCERT_STORE_PROV_FIND_INFOCERT_STORE_PROV_FIND_INFOCCERT_STORE_PROV_FIND_INFOPCCERT_STORE_PROV_FIND_INFOCertDuplicateStoreCERT_STORE_SAVE_AS_STORECERT_STORE_SAVE_AS_PKCS7CERT_STORE_SAVE_AS_PKCS12CERT_STORE_SAVE_TO_FILECERT_STORE_SAVE_TO_MEMORYCERT_STORE_SAVE_TO_FILENAME_ACERT_STORE_SAVE_TO_FILENAME_WCERT_STORE_SAVE_TO_FILENAMECertSaveStoreCERT_CLOSE_STORE_FORCE_FLAGCERT_CLOSE_STORE_CHECK_FLAGCertGetSubjectCertificateFromStoreCertEnumCertificatesInStoreCertFindCertificateInStoreCERT_COMPARE_MASKCERT_COMPARE_SHIFTCERT_COMPARE_ANYCERT_COMPARE_SHA1_HASHCERT_COMPARE_NAMECERT_COMPARE_ATTRCERT_COMPARE_MD5_HASHCERT_COMPARE_PROPERTYCERT_COMPARE_PUBLIC_KEYCERT_COMPARE_HASHCERT_COMPARE_NAME_STR_ACERT_COMPARE_NAME_STR_WCERT_COMPARE_KEY_SPECCERT_COMPARE_ENHKEY_USAGECERT_COMPARE_CTL_USAGECERT_COMPARE_SUBJECT_CERTCERT_COMPARE_ISSUER_OFCERT_COMPARE_EXISTINGCERT_COMPARE_SIGNATURE_HASHCERT_COMPARE_KEY_IDENTIFIERCERT_COMPARE_CERT_IDCERT_COMPARE_CROSS_CERT_DIST_POINTSCERT_COMPARE_PUBKEY_MD5_HASHCERT_COMPARE_SUBJECT_INFO_ACCESSCERT_COMPARE_HASH_STRCERT_COMPARE_HAS_PRIVATE_KEYCERT_FIND_ANYCERT_FIND_SHA1_HASHCERT_FIND_MD5_HASHCERT_FIND_SIGNATURE_HASHCERT_FIND_KEY_IDENTIFIERCERT_FIND_HASHCERT_FIND_PROPERTYCERT_FIND_PUBLIC_KEYCERT_FIND_SUBJECT_NAMECERT_FIND_SUBJECT_ATTRCERT_FIND_ISSUER_NAMECERT_FIND_ISSUER_ATTRCERT_FIND_SUBJECT_STR_ACERT_FIND_SUBJECT_STR_WCERT_FIND_SUBJECT_STRCERT_FIND_ISSUER_STR_ACERT_FIND_ISSUER_STR_WCERT_FIND_ISSUER_STRCERT_FIND_KEY_SPECCERT_FIND_ENHKEY_USAGECERT_FIND_CTL_USAGECERT_FIND_SUBJECT_CERTCERT_FIND_ISSUER_OFCERT_FIND_EXISTINGCERT_FIND_CERT_IDCERT_FIND_CROSS_CERT_DIST_POINTSCERT_FIND_PUBKEY_MD5_HASHCERT_FIND_SUBJECT_INFO_ACCESSCERT_FIND_HASH_STRCERT_FIND_HAS_PRIVATE_KEYCERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAGCERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAGCERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAGCERT_FIND_NO_ENHKEY_USAGE_FLAGCERT_FIND_OR_ENHKEY_USAGE_FLAGCERT_FIND_VALID_ENHKEY_USAGE_FLAGCERT_FIND_OPTIONAL_CTL_USAGE_FLAGCERT_FIND_EXT_ONLY_CTL_USAGE_FLAGCERT_FIND_PROP_ONLY_CTL_USAGE_FLAGCERT_FIND_NO_CTL_USAGE_FLAGCERT_FIND_OR_CTL_USAGE_FLAGCERT_FIND_VALID_CTL_USAGE_FLAGCertGetIssuerCertificateFromStoreCertVerifySubjectCertificateContextCertDuplicateCertificateContextCertCreateCertificateContextCERT_SET_PROPERTY_INHIBIT_PERSIST_FLAGCertGetCertificateContextPropertyCertEnumCertificateContextPropertiesCertCreateCTLEntryFromCertificateContextPropertiesCertSetCertificateContextPropertiesFromCTLEntryCertGetCRLFromStoreCertEnumCRLsInStoreCertFindCRLInStoreCRL_FIND_ANYCRL_FIND_ISSUED_BYCRL_FIND_EXISTINGCRL_FIND_ISSUED_FORCRL_FIND_ISSUED_BY_AKI_FLAGCRL_FIND_ISSUED_BY_SIGNATURE_FLAGCRL_FIND_ISSUED_BY_DELTA_FLAGCRL_FIND_ISSUED_BY_BASE_FLAGPCRL_FIND_ISSUED_FOR_PARACRL_FIND_ISSUED_FOR_PARACRL_FIND_ISSUED_FOR_SET_STRONG_PROPERTIES_FLAGCertDuplicateCRLContextCertCreateCRLContextCertFreeCRLContextCertSetCRLContextPropertyCertGetCRLContextPropertyCertEnumCRLContextPropertiesCertFindCertificateInCRLCertIsValidCRLForCertificateCERT_STORE_ADD_NEWCERT_STORE_ADD_USE_EXISTINGCERT_STORE_ADD_REPLACE_EXISTINGCERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIESCERT_STORE_ADD_NEWERCERT_STORE_ADD_NEWER_INHERIT_PROPERTIESCertAddCertificateContextToStoreCERT_STORE_CERTIFICATE_CONTEXTCERT_STORE_CRL_CONTEXTCERT_STORE_CTL_CONTEXTCERT_STORE_ALL_CONTEXT_FLAGCERT_STORE_CERTIFICATE_CONTEXT_FLAGCERT_STORE_CRL_CONTEXT_FLAGCERT_STORE_CTL_CONTEXT_FLAGCertAddSerializedElementToStoreCertDeleteCertificateFromStoreCertAddEncodedCRLToStoreCertAddCRLContextToStoreCertDeleteCRLFromStoreCertSerializeCertificateStoreElementCertSerializeCRLStoreElementCertDuplicateCTLContextCertCreateCTLContextCertFreeCTLContextCertSetCTLContextPropertyCertGetCTLContextPropertyCertEnumCTLContextPropertiesCertEnumCTLsInStoreCertFindSubjectInCTLCTL_ANY_SUBJECT_TYPECTL_CERT_SUBJECT_TYPEPCTL_ANY_SUBJECT_INFOCTL_ANY_SUBJECT_INFOCertFindCTLInStoreCTL_FIND_ANYCTL_FIND_SHA1_HASHCTL_FIND_MD5_HASHCTL_FIND_USAGECTL_FIND_SUBJECTCTL_FIND_EXISTINGPCTL_FIND_USAGE_PARACTL_FIND_USAGE_PARACTL_FIND_NO_LIST_ID_CBDATACTL_FIND_NO_SIGNER_PTRCTL_FIND_SAME_USAGE_FLAGPCTL_FIND_SUBJECT_PARACTL_FIND_SUBJECT_PARACertAddEncodedCTLToStoreCertAddCTLContextToStoreCertSerializeCTLStoreElementCertDeleteCTLFromStoreCertAddCertificateLinkToStoreCertAddCRLLinkToStoreCertAddCTLLinkToStoreCertAddStoreToCollectionCertRemoveStoreFromCollectionCertControlStoreCERT_STORE_CTRL_RESYNCCERT_STORE_CTRL_NOTIFY_CHANGECERT_STORE_CTRL_COMMITCERT_STORE_CTRL_AUTO_RESYNCCERT_STORE_CTRL_CANCEL_NOTIFYCERT_STORE_CTRL_INHIBIT_DUPLICATE_HANDLE_FLAGCERT_STORE_CTRL_COMMIT_FORCE_FLAGCERT_STORE_CTRL_COMMIT_CLEAR_FLAGCERT_STORE_LOCALIZED_NAME_PROP_IDCertSetStorePropertyCertGetStorePropertyPCERT_CREATE_CONTEXT_PARACERT_CREATE_CONTEXT_PARACertCreateContextCERT_CREATE_CONTEXT_NOCOPY_FLAGCERT_CREATE_CONTEXT_SORTED_FLAGCERT_CREATE_CONTEXT_NO_HCRYPTMSG_FLAGCERT_CREATE_CONTEXT_NO_ENTRY_FLAGPCERT_SYSTEM_STORE_INFOCERT_SYSTEM_STORE_INFOPCERT_PHYSICAL_STORE_INFOCERT_PHYSICAL_STORE_INFOCERT_PHYSICAL_STORE_ADD_ENABLE_FLAGCERT_PHYSICAL_STORE_OPEN_DISABLE_FLAGCERT_PHYSICAL_STORE_REMOTE_OPEN_DISABLE_FLAGCERT_PHYSICAL_STORE_INSERT_COMPUTER_NAME_ENABLE_FLAGCertRegisterSystemStoreCertRegisterPhysicalStoreCertUnregisterSystemStoreCertUnregisterPhysicalStoreCERT_PHYSICAL_STORE_PREDEFINED_ENUM_FLAGCERT_PHYSICAL_STORE_DEFAULT_NAMECERT_PHYSICAL_STORE_GROUP_POLICY_NAMECERT_PHYSICAL_STORE_LOCAL_MACHINE_NAMECERT_PHYSICAL_STORE_DS_USER_CERTIFICATE_NAMECERT_PHYSICAL_STORE_LOCAL_MACHINE_GROUP_POLICY_NAMECERT_PHYSICAL_STORE_ENTERPRISE_NAMECERT_PHYSICAL_STORE_AUTH_ROOT_NAMECERT_PHYSICAL_STORE_SMART_CARD_NAMECertEnumSystemStoreLocationPFN_CERT_ENUM_SYSTEM_STORE_LOCATIONCertEnumSystemStorePFN_CERT_ENUM_SYSTEM_STORECertEnumPhysicalStorePFN_CERT_ENUM_PHYSICAL_STORECRYPT_OID_OPEN_SYSTEM_STORE_PROV_FUNCCRYPT_OID_REGISTER_SYSTEM_STORE_FUNCCRYPT_OID_UNREGISTER_SYSTEM_STORE_FUNCCRYPT_OID_ENUM_SYSTEM_STORE_FUNCCRYPT_OID_REGISTER_PHYSICAL_STORE_FUNCCRYPT_OID_UNREGISTER_PHYSICAL_STORE_FUNCCRYPT_OID_ENUM_PHYSICAL_STORE_FUNCCRYPT_OID_SYSTEM_STORE_LOCATION_VALUE_NAMECertGetEnhancedKeyUsageCertSetEnhancedKeyUsageCertAddEnhancedKeyUsageIdentifierCertRemoveEnhancedKeyUsageIdentifierCertGetValidUsagesCryptMsgGetAndVerifySignerCMSG_TRUSTED_SIGNER_FLAGCMSG_SIGNER_ONLY_FLAGCMSG_USE_SIGNER_INDEX_FLAGCryptMsgSignCTLCryptMsgEncodeAndSignCTLCMSG_ENCODE_SORTED_CTL_FLAGCMSG_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAGCertFindSubjectInSortedCTLCertEnumSubjectInSortedCTLPCTL_VERIFY_USAGE_PARACTL_VERIFY_USAGE_PARAPCTL_VERIFY_USAGE_STATUSCTL_VERIFY_USAGE_STATUSCERT_VERIFY_INHIBIT_CTL_UPDATE_FLAGCERT_VERIFY_TRUSTED_SIGNERS_FLAGCERT_VERIFY_NO_TIME_CHECK_FLAGCERT_VERIFY_ALLOW_MORE_USAGE_FLAGCERT_VERIFY_UPDATED_CTL_FLAGCertVerifyCTLUsagePCERT_REVOCATION_CRL_INFOCERT_REVOCATION_CRL_INFOPCERT_REVOCATION_CHAIN_PARACERT_REVOCATION_CHAIN_PARAPCERT_REVOCATION_PARACERT_REVOCATION_PARAPCERT_REVOCATION_STATUSCERT_REVOCATION_STATUSCertVerifyRevocationCERT_CONTEXT_REVOCATION_TYPECERT_VERIFY_REV_CHAIN_FLAGCERT_VERIFY_CACHE_ONLY_BASED_REVOCATIONCERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAGCERT_VERIFY_REV_SERVER_OCSP_FLAGCERT_VERIFY_REV_NO_OCSP_FAILOVER_TO_CRL_FLAGCertCompareIntegerBlobCertCompareCertificateCertCompareCertificateNameCertIsRDNAttrsInCertificateNameCertComparePublicKeyInfoCertGetPublicKeyLengthCryptVerifyCertificateSignatureCryptVerifyCertificateSignatureExCRYPT_VERIFY_CERT_SIGN_SUBJECT_BLOBCRYPT_VERIFY_CERT_SIGN_SUBJECT_CERTCRYPT_VERIFY_CERT_SIGN_SUBJECT_CRLCRYPT_VERIFY_CERT_SIGN_SUBJECT_OCSP_BASIC_SIGNED_RESPONSECRYPT_VERIFY_CERT_SIGN_ISSUER_PUBKEYCRYPT_VERIFY_CERT_SIGN_ISSUER_CERTCRYPT_VERIFY_CERT_SIGN_ISSUER_CHAINCRYPT_VERIFY_CERT_SIGN_ISSUER_NULLCRYPT_VERIFY_CERT_SIGN_DISABLE_MD2_MD4_FLAGCRYPT_VERIFY_CERT_SIGN_SET_STRONG_PROPERTIES_FLAGCRYPT_VERIFY_CERT_SIGN_RETURN_STRONG_PROPERTIES_FLAGPCRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFOCRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFOPCRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFOCRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFOCertIsStrongHashToSignCryptHashToBeSignedCryptHashCertificateCryptHashCertificate2CryptSignCertificateCryptSignAndEncodeCertificateCRYPT_OID_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNCCRYPT_OID_SIGN_AND_ENCODE_HASH_FUNCCRYPT_OID_VERIFY_ENCODED_SIGNATURE_FUNCCertVerifyTimeValidityCertVerifyCRLTimeValidityCertVerifyValidityNestingCertVerifyCRLRevocationCertAlgIdToOIDCertOIDToAlgIdCertFindExtensionCertFindAttributeCertFindRDNAttrCertGetIntendedKeyUsageHCRYPTDEFAULTCONTEXTCryptInstallDefaultContextCRYPT_DEFAULT_CONTEXT_AUTO_RELEASE_FLAGCRYPT_DEFAULT_CONTEXT_PROCESS_FLAGCRYPT_DEFAULT_CONTEXT_CERT_SIGN_OIDCRYPT_DEFAULT_CONTEXT_MULTI_CERT_SIGN_OIDPCRYPT_DEFAULT_CONTEXT_MULTI_OID_PARACRYPT_DEFAULT_CONTEXT_MULTI_OID_PARACryptUninstallDefaultContextCryptExportPublicKeyInfoCryptExportPublicKeyInfoExCRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNCCRYPT_OID_EXPORT_PUBLIC_KEY_INFO_EX2_FUNCCryptExportPublicKeyInfoFromBCryptKeyHandleCRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNCCryptImportPublicKeyInfoCRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNCCryptImportPublicKeyInfoExCryptImportPublicKeyInfoEx2CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_EX2_FUNCCryptAcquireCertificatePrivateKeyCRYPT_ACQUIRE_CACHE_FLAGCRYPT_ACQUIRE_USE_PROV_INFO_FLAGCRYPT_ACQUIRE_COMPARE_KEY_FLAGCRYPT_ACQUIRE_NO_HEALINGCRYPT_ACQUIRE_SILENT_FLAGCRYPT_ACQUIRE_WINDOW_HANDLE_FLAGCRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASKCRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAGCRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAGCRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAGCryptFindCertificateKeyProvInfoCRYPT_FIND_USER_KEYSET_FLAGCRYPT_FIND_MACHINE_KEYSET_FLAGCRYPT_FIND_SILENT_KEYSET_FLAGCRYPT_OID_IMPORT_PRIVATE_KEY_INFO_FUNCCryptImportPKCS8CRYPT_OID_EXPORT_PRIVATE_KEY_INFO_FUNCCRYPT_DELETE_KEYSETCryptExportPKCS8CryptExportPKCS8ExCryptHashPublicKeyInfoCertRDNValueToStrACertRDNValueToStrWCertNameToStrACertNameToStrWCERT_SIMPLE_NAME_STRCERT_OID_NAME_STRCERT_X500_NAME_STRCERT_XML_NAME_STRCERT_NAME_STR_SEMICOLON_FLAGCERT_NAME_STR_NO_PLUS_FLAGCERT_NAME_STR_NO_QUOTING_FLAGCERT_NAME_STR_CRLF_FLAGCERT_NAME_STR_COMMA_FLAGCERT_NAME_STR_REVERSE_FLAGCERT_NAME_STR_FORWARD_FLAGCERT_NAME_STR_DISABLE_IE4_UTF8_FLAGCERT_NAME_STR_ENABLE_T61_UNICODE_FLAGCERT_NAME_STR_ENABLE_UTF8_UNICODE_FLAGCERT_NAME_STR_FORCE_UTF8_DIR_STR_FLAGCERT_NAME_STR_DISABLE_UTF8_DIR_STR_FLAGCERT_NAME_STR_ENABLE_PUNYCODE_FLAGCertStrToNameACertStrToNameWCertGetNameStringACertGetNameStringWCERT_NAME_EMAIL_TYPECERT_NAME_RDN_TYPECERT_NAME_ATTR_TYPECERT_NAME_SIMPLE_DISPLAY_TYPECERT_NAME_FRIENDLY_DISPLAY_TYPECERT_NAME_DNS_TYPECERT_NAME_URL_TYPECERT_NAME_UPN_TYPECERT_NAME_ISSUER_FLAGCERT_NAME_DISABLE_IE4_UTF8_FLAGCERT_NAME_SEARCH_ALL_NAMES_FLAGPCRYPT_SIGN_MESSAGE_PARACRYPT_SIGN_MESSAGE_PARACRYPT_MESSAGE_BARE_CONTENT_OUT_FLAGCRYPT_MESSAGE_ENCAPSULATED_CONTENT_OUT_FLAGCRYPT_MESSAGE_KEYID_SIGNER_FLAGCRYPT_MESSAGE_SILENT_KEYSET_FLAGPCRYPT_VERIFY_MESSAGE_PARACRYPT_VERIFY_MESSAGE_PARAPCRYPT_ENCRYPT_MESSAGE_PARACRYPT_DECRYPT_MESSAGE_PARACRYPT_MESSAGE_KEYID_RECIPIENT_FLAGPCRYPT_DECRYPT_MESSAGE_PARAPCRYPT_HASH_MESSAGE_PARACRYPT_HASH_MESSAGE_PARAPCRYPT_KEY_SIGN_MESSAGE_PARACRYPT_KEY_SIGN_MESSAGE_PARAPCRYPT_KEY_VERIFY_MESSAGE_PARACRYPT_KEY_VERIFY_MESSAGE_PARACryptSignMessageCryptVerifyMessageSignatureCryptGetMessageSignerCountCryptGetMessageCertificatesCryptVerifyDetachedMessageSignatureCryptEncryptMessageCryptDecryptMessageCryptSignAndEncryptMessageCryptDecryptAndVerifyMessageSignatureCryptDecodeMessageCryptHashMessageCryptVerifyMessageHashCryptVerifyDetachedMessageHashCryptSignMessageWithKeyCryptVerifyMessageSignatureWithKeyCertOpenSystemStoreACertOpenSystemStoreWCertAddEncodedCertificateToSystemStoreACertAddEncodedCertificateToSystemStoreWPCERT_CHAINCERT_CHAINFindCertsByIssuerCryptQueryObjectCERT_QUERY_OBJECT_FILECERT_QUERY_OBJECT_BLOBCERT_QUERY_CONTENT_CERTCERT_QUERY_CONTENT_CTLCERT_QUERY_CONTENT_CRLCERT_QUERY_CONTENT_SERIALIZED_STORECERT_QUERY_CONTENT_SERIALIZED_CERTCERT_QUERY_CONTENT_SERIALIZED_CTLCERT_QUERY_CONTENT_SERIALIZED_CRLCERT_QUERY_CONTENT_PKCS7_SIGNEDCERT_QUERY_CONTENT_PKCS7_UNSIGNEDCERT_QUERY_CONTENT_PKCS7_SIGNED_EMBEDCERT_QUERY_CONTENT_PKCS10CERT_QUERY_CONTENT_PFXCERT_QUERY_CONTENT_CERT_PAIRCERT_QUERY_CONTENT_PFX_AND_LOADCERT_QUERY_CONTENT_FLAG_CERTCERT_QUERY_CONTENT_FLAG_CTLCERT_QUERY_CONTENT_FLAG_CRLCERT_QUERY_CONTENT_FLAG_SERIALIZED_STORECERT_QUERY_CONTENT_FLAG_SERIALIZED_CERTCERT_QUERY_CONTENT_FLAG_SERIALIZED_CTLCERT_QUERY_CONTENT_FLAG_SERIALIZED_CRLCERT_QUERY_CONTENT_FLAG_PKCS7_SIGNEDCERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNEDCERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBEDCERT_QUERY_CONTENT_FLAG_PKCS10CERT_QUERY_CONTENT_FLAG_PFXCERT_QUERY_CONTENT_FLAG_CERT_PAIRCERT_QUERY_CONTENT_FLAG_PFX_AND_LOADCERT_QUERY_CONTENT_FLAG_ALLCERT_QUERY_CONTENT_FLAG_ALL_ISSUER_CERTCERT_QUERY_FORMAT_BINARYCERT_QUERY_FORMAT_BASE64_ENCODEDCERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODEDCERT_QUERY_FORMAT_FLAG_BINARYCERT_QUERY_FORMAT_FLAG_BASE64_ENCODEDCERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODEDCERT_QUERY_FORMAT_FLAG_ALLCryptMemAllocCryptMemReallocCryptMemFreeHCRYPTASYNCPHCRYPTASYNCCryptCreateAsyncHandleCryptSetAsyncParamPFN_CRYPT_ASYNC_PARAM_FREE_FUNCCryptGetAsyncParamCryptCloseAsyncHandlePCRYPT_BLOB_ARRAYCRYPT_BLOB_ARRAYPCRYPT_CREDENTIALSCRYPT_CREDENTIALSCREDENTIAL_OID_PASSWORD_CREDENTIALS_ACREDENTIAL_OID_PASSWORD_CREDENTIALS_WPCRYPT_PASSWORD_CREDENTIALSACRYPT_PASSWORD_CREDENTIALSAPCRYPT_PASSWORD_CREDENTIALSWCRYPT_PASSWORD_CREDENTIALSWSCHEME_OID_RETRIEVE_ENCODED_OBJECT_FUNCSCHEME_OID_RETRIEVE_ENCODED_OBJECTW_FUNCCONTEXT_OID_CREATE_OBJECT_CONTEXT_FUNCCONTEXT_OID_CERTIFICATECONTEXT_OID_CRLCONTEXT_OID_CTLCONTEXT_OID_PKCS7CONTEXT_OID_CAPI2_ANYCONTEXT_OID_OCSP_RESPCRYPT_RETRIEVE_MULTIPLE_OBJECTSCRYPT_CACHE_ONLY_RETRIEVALCRYPT_WIRE_ONLY_RETRIEVALCRYPT_DONT_CACHE_RESULTCRYPT_ASYNC_RETRIEVALCRYPT_STICKY_CACHE_RETRIEVALCRYPT_LDAP_SCOPE_BASE_ONLY_RETRIEVALCRYPT_OFFLINE_CHECK_RETRIEVALCRYPT_LDAP_INSERT_ENTRY_ATTRIBUTECRYPT_LDAP_SIGN_RETRIEVALCRYPT_NO_AUTH_RETRIEVALCRYPT_LDAP_AREC_EXCLUSIVE_RETRIEVALCRYPT_AIA_RETRIEVALCRYPT_HTTP_POST_RETRIEVALCRYPT_PROXY_CACHE_RETRIEVALCRYPT_NOT_MODIFIED_RETRIEVALCRYPT_ENABLE_SSL_REVOCATION_RETRIEVALCRYPT_RANDOM_QUERY_STRING_RETRIEVALCRYPT_ENABLE_FILE_RETRIEVALCRYPT_CREATE_NEW_FLUSH_ENTRYCRYPT_VERIFY_CONTEXT_SIGNATURECRYPT_VERIFY_DATA_HASHCRYPT_KEEP_TIME_VALIDCRYPT_DONT_VERIFY_SIGNATURECRYPT_DONT_CHECK_TIME_VALIDITYCRYPT_CHECK_FRESHNESS_TIME_VALIDITYCRYPT_ACCUMULATIVE_TIMEOUTCRYPT_OCSP_ONLY_RETRIEVALCRYPT_NO_OCSP_FAILOVER_TO_CRL_RETRIEVALPCRYPTNET_URL_CACHE_PRE_FETCH_INFOCRYPTNET_URL_CACHE_PRE_FETCH_INFOCRYPTNET_URL_CACHE_PRE_FETCH_NONECRYPTNET_URL_CACHE_PRE_FETCH_BLOBCRYPTNET_URL_CACHE_PRE_FETCH_CRLCRYPTNET_URL_CACHE_PRE_FETCH_OCSPCRYPTNET_URL_CACHE_PRE_FETCH_AUTOROOT_CABCRYPTNET_URL_CACHE_PRE_FETCH_DISALLOWED_CERT_CABCRYPTNET_URL_CACHE_PRE_FETCH_PIN_RULES_CABPCRYPTNET_URL_CACHE_FLUSH_INFOCRYPTNET_URL_CACHE_FLUSH_INFOCRYPTNET_URL_CACHE_DEFAULT_FLUSHCRYPTNET_URL_CACHE_DISABLE_FLUSHPCRYPTNET_URL_CACHE_RESPONSE_INFOCRYPTNET_URL_CACHE_RESPONSE_INFOCRYPTNET_URL_CACHE_RESPONSE_NONECRYPTNET_URL_CACHE_RESPONSE_HTTPCRYPTNET_URL_CACHE_RESPONSE_VALIDATEDPCRYPT_RETRIEVE_AUX_INFOCRYPT_RETRIEVE_AUX_INFOCRYPT_RETRIEVE_MAX_ERROR_CONTENT_LENGTHCryptRetrieveObjectByUrlACryptRetrieveObjectByUrlWCryptInstallCancelRetrievalPFN_CRYPT_CANCEL_RETRIEVALCryptUninstallCancelRetrievalCryptCancelAsyncRetrievalCRYPT_PARAM_ASYNC_RETRIEVAL_COMPLETIONPCRYPT_ASYNC_RETRIEVAL_COMPLETIONCRYPT_ASYNC_RETRIEVAL_COMPLETIONCRYPT_PARAM_CANCEL_ASYNC_RETRIEVALCRYPT_GET_URL_FROM_PROPERTYCRYPT_GET_URL_FROM_EXTENSIONCRYPT_GET_URL_FROM_UNAUTH_ATTRIBUTECRYPT_GET_URL_FROM_AUTH_ATTRIBUTEPCRYPT_URL_ARRAYCRYPT_URL_ARRAYPCRYPT_URL_INFOCRYPT_URL_INFOCryptGetObjectUrlURL_OID_GET_OBJECT_URL_FUNCURL_OID_CERTIFICATE_ISSUERURL_OID_CERTIFICATE_CRL_DIST_POINTURL_OID_CTL_ISSUERURL_OID_CTL_NEXT_UPDATEURL_OID_CRL_ISSUERURL_OID_CERTIFICATE_FRESHEST_CRLURL_OID_CRL_FRESHEST_CRLURL_OID_CROSS_CERT_DIST_POINTURL_OID_CERTIFICATE_OCSPURL_OID_CERTIFICATE_OCSP_AND_CRL_DIST_POINTURL_OID_CERTIFICATE_CRL_DIST_POINT_AND_OCSPURL_OID_CROSS_CERT_SUBJECT_INFO_ACCESSURL_OID_CERTIFICATE_ONLY_OCSPPCERT_CRL_CONTEXT_PAIRCERT_CRL_CONTEXT_PAIRPCCERT_CRL_CONTEXT_PAIRPCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFOCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFOCryptGetTimeValidObjectTIME_VALID_OID_GET_OBJECT_FUNCTIME_VALID_OID_GET_CTLTIME_VALID_OID_GET_CRLTIME_VALID_OID_GET_CRL_FROM_CERTTIME_VALID_OID_GET_FRESHEST_CRL_FROM_CERTTIME_VALID_OID_GET_FRESHEST_CRL_FROM_CRLCryptFlushTimeValidObjectTIME_VALID_OID_FLUSH_OBJECT_FUNCTIME_VALID_OID_FLUSH_CTLTIME_VALID_OID_FLUSH_CRLTIME_VALID_OID_FLUSH_CRL_FROM_CERTTIME_VALID_OID_FLUSH_FRESHEST_CRL_FROM_CERTTIME_VALID_OID_FLUSH_FRESHEST_CRL_FROM_CRLCertCreateSelfSignCertificateCERT_CREATE_SELFSIGN_NO_SIGNCERT_CREATE_SELFSIGN_NO_KEY_INFOCryptGetKeyIdentifierPropertyCRYPT_KEYID_MACHINE_FLAGCRYPT_KEYID_ALLOC_FLAGCryptSetKeyIdentifierPropertyCRYPT_KEYID_DELETE_FLAGCRYPT_KEYID_SET_NEW_FLAGCryptEnumKeyIdentifierPropertiesPFN_CRYPT_ENUM_KEYID_PROPCryptCreateKeyIdentifierFromCSPCERT_CHAIN_CONFIG_REGPATHCERT_CHAIN_MAX_URL_RETRIEVAL_BYTE_COUNT_VALUE_NAMECERT_CHAIN_MAX_URL_RETRIEVAL_BYTE_COUNT_DEFAULTCERT_CHAIN_CACHE_RESYNC_FILETIME_VALUE_NAMECERT_CHAIN_DISABLE_MANDATORY_BASIC_CONSTRAINTS_VALUE_NAMECERT_CHAIN_DISABLE_CA_NAME_CONSTRAINTS_VALUE_NAMECERT_CHAIN_DISABLE_UNSUPPORTED_CRITICAL_EXTENSIONS_VALUE_NAMECERT_CHAIN_MAX_AIA_URL_COUNT_IN_CERT_VALUE_NAMECERT_CHAIN_MAX_AIA_URL_COUNT_IN_CERT_DEFAULTCERT_CHAIN_MAX_AIA_URL_RETRIEVAL_COUNT_PER_CHAIN_VALUE_NAMECERT_CHAIN_MAX_AIA_URL_RETRIEVAL_COUNT_PER_CHAIN_DEFAULTCERT_CHAIN_MAX_AIA_URL_RETRIEVAL_BYTE_COUNT_VALUE_NAMECERT_CHAIN_MAX_AIA_URL_RETRIEVAL_BYTE_COUNT_DEFAULTCERT_CHAIN_MAX_AIA_URL_RETRIEVAL_CERT_COUNT_VALUE_NAMECERT_CHAIN_MAX_AIA_URL_RETRIEVAL_CERT_COUNT_DEFAULTCERT_CHAIN_OCSP_VALIDITY_SECONDS_VALUE_NAMECERT_CHAIN_OCSP_VALIDITY_SECONDS_DEFAULTCERT_CHAIN_DISABLE_SERIAL_CHAIN_VALUE_NAMECERT_CHAIN_SERIAL_CHAIN_LOG_FILE_NAME_VALUE_NAMECERT_CHAIN_DISABLE_SYNC_WITH_SSL_TIME_VALUE_NAMECERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_VALUE_NAMECERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_DEFAULTCERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_DISABLECERT_CHAIN_SSL_HANDSHAKE_LOG_FILE_NAME_VALUE_NAMECERT_CHAIN_ENABLE_WEAK_SIGNATURE_FLAGS_VALUE_NAMECERT_CHAIN_ENABLE_MD2_MD4_FLAGCERT_CHAIN_ENABLE_WEAK_RSA_ROOT_FLAGCERT_CHAIN_ENABLE_WEAK_LOGGING_FLAGCERT_CHAIN_ENABLE_ONLY_WEAK_LOGGING_FLAGCERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_VALUE_NAMECERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DEFAULTCERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DISABLECERT_CHAIN_WEAK_RSA_PUB_KEY_TIME_VALUE_NAMECERT_CHAIN_WEAK_RSA_PUB_KEY_TIME_DEFAULTCERT_CHAIN_WEAK_SIGNATURE_LOG_DIR_VALUE_NAMECERT_CHAIN_DEFAULT_CONFIG_SUBDIRCERT_CHAIN_WEAK_PREFIX_NAMECERT_CHAIN_WEAK_THIRD_PARTY_CONFIG_NAMECERT_CHAIN_WEAK_ALL_CONFIG_NAMECERT_CHAIN_WEAK_FLAGS_NAMECERT_CHAIN_WEAK_HYGIENE_NAMECERT_CHAIN_WEAK_AFTER_TIME_NAMECERT_CHAIN_WEAK_FILE_HASH_AFTER_TIME_NAMECERT_CHAIN_WEAK_TIMESTAMP_HASH_AFTER_TIME_NAMECERT_CHAIN_WEAK_MIN_BIT_LENGTH_NAMECERT_CHAIN_WEAK_SHA256_ALLOW_NAMECERT_CHAIN_MIN_PUB_KEY_BIT_LENGTH_DISABLECERT_CHAIN_ENABLE_WEAK_SETTINGS_FLAGCERT_CHAIN_DISABLE_ALL_EKU_WEAK_FLAGCERT_CHAIN_ENABLE_ALL_EKU_HYGIENE_FLAGCERT_CHAIN_DISABLE_OPT_IN_SERVER_AUTH_WEAK_FLAGCERT_CHAIN_DISABLE_SERVER_AUTH_WEAK_FLAGCERT_CHAIN_ENABLE_SERVER_AUTH_HYGIENE_FLAGCERT_CHAIN_DISABLE_CODE_SIGNING_WEAK_FLAGCERT_CHAIN_DISABLE_MOTW_CODE_SIGNING_WEAK_FLAGCERT_CHAIN_ENABLE_CODE_SIGNING_HYGIENE_FLAGCERT_CHAIN_ENABLE_MOTW_CODE_SIGNING_HYGIENE_FLAGCERT_CHAIN_DISABLE_TIMESTAMP_WEAK_FLAGCERT_CHAIN_DISABLE_MOTW_TIMESTAMP_WEAK_FLAGCERT_CHAIN_ENABLE_TIMESTAMP_HYGIENE_FLAGCERT_CHAIN_ENABLE_MOTW_TIMESTAMP_HYGIENE_FLAGCERT_CHAIN_MOTW_IGNORE_AFTER_TIME_WEAK_FLAGCERT_CHAIN_DISABLE_FILE_HASH_WEAK_FLAGCERT_CHAIN_DISABLE_MOTW_FILE_HASH_WEAK_FLAGCERT_CHAIN_DISABLE_TIMESTAMP_HASH_WEAK_FLAGCERT_CHAIN_DISABLE_MOTW_TIMESTAMP_HASH_WEAK_FLAGCERT_CHAIN_DISABLE_WEAK_FLAGSCERT_CHAIN_DISABLE_FILE_HASH_WEAK_FLAGSCERT_CHAIN_DISABLE_TIMESTAMP_HASH_WEAK_FLAGSCERT_CHAIN_ENABLE_HYGIENE_FLAGSCERT_CHAIN_MOTW_WEAK_FLAGSCERT_CHAIN_OPT_IN_WEAK_FLAGSCERT_CHAIN_AUTO_CURRENT_USERCERT_CHAIN_AUTO_LOCAL_MACHINECERT_CHAIN_AUTO_IMPERSONATEDCERT_CHAIN_AUTO_PROCESS_INFOCERT_CHAIN_AUTO_PINRULE_INFOCERT_CHAIN_AUTO_NETWORK_INFOCERT_CHAIN_AUTO_SERIAL_LOCAL_MACHINECERT_CHAIN_AUTO_HPKP_RULE_INFOCERT_CHAIN_AUTO_FLAGS_VALUE_NAMECERT_CHAIN_AUTO_FLUSH_DISABLE_FLAGCERT_CHAIN_AUTO_LOG_CREATE_FLAGCERT_CHAIN_AUTO_LOG_FREE_FLAGCERT_CHAIN_AUTO_LOG_FLUSH_FLAGCERT_CHAIN_AUTO_LOG_FLAGSCERT_CHAIN_AUTO_FLUSH_FIRST_DELTA_SECONDS_VALUE_NAMECERT_CHAIN_AUTO_FLUSH_FIRST_DELTA_SECONDS_DEFAULTCERT_CHAIN_AUTO_FLUSH_NEXT_DELTA_SECONDS_VALUE_NAMECERT_CHAIN_AUTO_FLUSH_NEXT_DELTA_SECONDS_DEFAULTCERT_CHAIN_AUTO_LOG_FILE_NAME_VALUE_NAMECERT_CHAIN_DISABLE_AUTO_FLUSH_PROCESS_NAME_LIST_VALUE_NAMECERT_SRV_OCSP_RESP_MIN_VALIDITY_SECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_MIN_VALIDITY_SECONDS_DEFAULTCERT_SRV_OCSP_RESP_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_DEFAULTCERT_SRV_OCSP_RESP_MAX_BEFORE_NEXT_UPDATE_SECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_MAX_BEFORE_NEXT_UPDATE_SECONDS_DEFAULTCERT_SRV_OCSP_RESP_MIN_BEFORE_NEXT_UPDATE_SECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_MIN_BEFORE_NEXT_UPDATE_SECONDS_DEFAULTCERT_SRV_OCSP_RESP_MIN_AFTER_NEXT_UPDATE_SECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_MIN_AFTER_NEXT_UPDATE_SECONDS_DEFAULTCERT_SRV_OCSP_RESP_MIN_SYNC_CERT_FILE_SECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_MIN_SYNC_CERT_FILE_SECONDS_DEFAULTCERT_SRV_OCSP_RESP_MAX_SYNC_CERT_FILE_SECONDS_VALUE_NAMECERT_SRV_OCSP_RESP_MAX_SYNC_CERT_FILE_SECONDS_DEFAULTCRYPTNET_MAX_CACHED_OCSP_PER_CRL_COUNT_VALUE_NAMECRYPTNET_MAX_CACHED_OCSP_PER_CRL_COUNT_DEFAULTCRYPTNET_OCSP_AFTER_CRL_DISABLECRYPTNET_URL_CACHE_DEFAULT_FLUSH_EXEMPT_SECONDS_VALUE_NAMECRYPTNET_URL_CACHE_DEFAULT_FLUSH_EXEMPT_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_MIN_MAX_AGE_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_MIN_MAX_AGE_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_MAX_MAX_AGE_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_MAX_MAX_AGE_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_MIN_OCSP_VALIDITY_PERIOD_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_MIN_OCSP_VALIDITY_PERIOD_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_AFTER_PUBLISH_PRE_FETCH_DIVISOR_VALUE_NAMECRYPTNET_PRE_FETCH_AFTER_PUBLISH_PRE_FETCH_DIVISOR_DEFAULTCRYPTNET_PRE_FETCH_BEFORE_NEXT_UPDATE_PRE_FETCH_DIVISOR_VALUE_NAMECRYPTNET_PRE_FETCH_BEFORE_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULTCRYPTNET_PRE_FETCH_MIN_BEFORE_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_MIN_BEFORE_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_VALIDITY_PERIOD_AFTER_NEXT_UPDATE_PRE_FETCH_DIVISOR_VALUE_NAMECRYPTNET_PRE_FETCH_VALIDITY_PERIOD_AFTER_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULTCRYPTNET_PRE_FETCH_MAX_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_MAX_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_MIN_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_MIN_AFTER_NEXT_UPDATE_PRE_FETCH_PERIOD_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_AFTER_CURRENT_TIME_PRE_FETCH_PERIOD_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_AFTER_CURRENT_TIME_PRE_FETCH_PERIOD_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_TRIGGER_PERIOD_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_TRIGGER_PERIOD_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_TRIGGER_DISABLECRYPTNET_PRE_FETCH_SCAN_AFTER_TRIGGER_DELAY_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_SCAN_AFTER_TRIGGER_DELAY_SECONDS_DEFAULTCRYPTNET_PRE_FETCH_RETRIEVAL_TIMEOUT_SECONDS_VALUE_NAMECRYPTNET_PRE_FETCH_RETRIEVAL_TIMEOUT_SECONDS_DEFAULTCRYPTNET_CRL_PRE_FETCH_CONFIG_REGPATHCRYPTNET_CRL_PRE_FETCH_PROCESS_NAME_LIST_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_URL_LIST_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_DISABLE_INFORMATION_EVENTS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_LOG_FILE_NAME_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_TIMEOUT_SECONDS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_TIMEOUT_SECONDS_DEFAULTCRYPTNET_CRL_PRE_FETCH_MAX_AGE_SECONDS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_MAX_AGE_SECONDS_DEFAULTCRYPTNET_CRL_PRE_FETCH_MAX_AGE_SECONDS_MINCRYPTNET_CRL_PRE_FETCH_PUBLISH_BEFORE_NEXT_UPDATE_SECONDS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_PUBLISH_BEFORE_NEXT_UPDATE_SECONDS_DEFAULTCRYPTNET_CRL_PRE_FETCH_PUBLISH_RANDOM_INTERVAL_SECONDS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_PUBLISH_RANDOM_INTERVAL_SECONDS_DEFAULTCRYPTNET_CRL_PRE_FETCH_MIN_BEFORE_NEXT_UPDATE_SECONDS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_MIN_BEFORE_NEXT_UPDATE_SECONDS_DEFAULTCRYPTNET_CRL_PRE_FETCH_MIN_AFTER_NEXT_UPDATE_SECONDS_VALUE_NAMECRYPTNET_CRL_PRE_FETCH_MIN_AFTER_NEXT_UPDATE_SECONDS_DEFAULTCERT_GROUP_POLICY_CHAIN_CONFIG_REGPATHCERT_CHAIN_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_VALUE_NAMECERT_CHAIN_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_DEFAULTCERT_CHAIN_REV_ACCUMULATIVE_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_VALUE_NAMECERT_CHAIN_REV_ACCUMULATIVE_URL_RETRIEVAL_TIMEOUT_MILLISECONDS_DEFAULTCERT_RETR_BEHAVIOR_INET_AUTH_VALUE_NAMECERT_RETR_BEHAVIOR_INET_STATUS_VALUE_NAMECERT_RETR_BEHAVIOR_FILE_VALUE_NAMECERT_RETR_BEHAVIOR_LDAP_VALUE_NAMECRYPTNET_CACHED_OCSP_SWITCH_TO_CRL_COUNT_VALUE_NAMECRYPTNET_CACHED_OCSP_SWITCH_TO_CRL_COUNT_DEFAULTCRYPTNET_CRL_BEFORE_OCSP_ENABLECERT_CHAIN_DISABLE_AIA_URL_RETRIEVAL_VALUE_NAMECERT_CHAIN_OPTIONS_VALUE_NAMECERT_CHAIN_OPTION_DISABLE_AIA_URL_RETRIEVALCERT_CHAIN_OPTION_ENABLE_SIA_URL_RETRIEVALCERT_CHAIN_CROSS_CERT_DOWNLOAD_INTERVAL_HOURS_VALUE_NAMECERT_CHAIN_CROSS_CERT_DOWNLOAD_INTERVAL_HOURS_DEFAULTCERT_CHAIN_CRL_VALIDITY_EXT_PERIOD_HOURS_VALUE_NAMECERT_CHAIN_CRL_VALIDITY_EXT_PERIOD_HOURS_DEFAULTHCERTCHAINENGINEHCCE_CURRENT_USERHCCE_LOCAL_MACHINEHCCE_SERIAL_LOCAL_MACHINECERT_CHAIN_THREAD_STORE_SYNCCERT_CHAIN_CACHE_ONLY_URL_RETRIEVALCERT_CHAIN_USE_LOCAL_MACHINE_STORECERT_CHAIN_ENABLE_CACHE_AUTO_UPDATECERT_CHAIN_ENABLE_SHARE_STOREPCERT_CHAIN_ENGINE_CONFIGCertResyncCertificateChainEnginePCERT_TRUST_STATUSCERT_TRUST_STATUSCERT_TRUST_NO_ERRORCERT_TRUST_IS_NOT_TIME_VALIDCERT_TRUST_IS_NOT_TIME_NESTEDCERT_TRUST_IS_REVOKEDCERT_TRUST_IS_NOT_SIGNATURE_VALIDCERT_TRUST_IS_NOT_VALID_FOR_USAGECERT_TRUST_IS_UNTRUSTED_ROOTCERT_TRUST_REVOCATION_STATUS_UNKNOWNCERT_TRUST_IS_CYCLICCERT_TRUST_INVALID_EXTENSIONCERT_TRUST_INVALID_POLICY_CONSTRAINTSCERT_TRUST_INVALID_BASIC_CONSTRAINTSCERT_TRUST_INVALID_NAME_CONSTRAINTSCERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINTCERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINTCERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINTCERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINTCERT_TRUST_IS_OFFLINE_REVOCATIONCERT_TRUST_NO_ISSUANCE_CHAIN_POLICYCERT_TRUST_CTL_IS_NOT_TIME_VALIDCERT_TRUST_CTL_IS_NOT_SIGNATURE_VALIDCERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGECERT_TRUST_HAS_EXACT_MATCH_ISSUERCERT_TRUST_HAS_KEY_MATCH_ISSUERCERT_TRUST_HAS_NAME_MATCH_ISSUERCERT_TRUST_IS_SELF_SIGNEDCERT_TRUST_AUTO_UPDATE_CA_REVOCATIONCERT_TRUST_AUTO_UPDATE_END_REVOCATIONCERT_TRUST_NO_OCSP_FAILOVER_TO_CRLCERT_TRUST_IS_KEY_ROLLOVERCERT_TRUST_SSL_HANDSHAKE_OCSPCERT_TRUST_SSL_TIME_VALID_OCSPCERT_TRUST_SSL_RECONNECT_OCSPCERT_TRUST_HAS_PREFERRED_ISSUERCERT_TRUST_HAS_ISSUANCE_CHAIN_POLICYCERT_TRUST_HAS_VALID_NAME_CONSTRAINTSCERT_TRUST_IS_PEER_TRUSTEDCERT_TRUST_HAS_CRL_VALIDITY_EXTENDEDCERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORECERT_TRUST_IS_CA_TRUSTEDCERT_TRUST_HAS_AUTO_UPDATE_WEAK_SIGNATURECERT_TRUST_HAS_ALLOW_WEAK_SIGNATURECERT_TRUST_IS_COMPLEX_CHAINCERT_TRUST_SSL_TIME_VALIDCERT_TRUST_NO_TIME_CHECKPCERT_REVOCATION_INFOCERT_REVOCATION_INFOPCERT_TRUST_LIST_INFOCERT_TRUST_LIST_INFOPCERT_CHAIN_ELEMENTCERT_CHAIN_ELEMENTPCCERT_CHAIN_ELEMENTPCERT_SIMPLE_CHAINCERT_SIMPLE_CHAINPCCERT_SIMPLE_CHAINPCERT_CHAIN_CONTEXTPCCERT_CHAIN_CONTEXTUSAGE_MATCH_TYPE_ORPCERT_USAGE_MATCHPCTL_USAGE_MATCHCTL_USAGE_MATCHPCERT_CHAIN_PARACERT_CHAIN_STRONG_SIGN_DISABLE_END_CHECK_FLAGCERT_CHAIN_REVOCATION_CHECK_CHAINCERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOTCERT_CHAIN_REVOCATION_CHECK_CACHE_ONLYCERT_CHAIN_REVOCATION_CHECK_OCSP_CERTCERT_CHAIN_DISABLE_PASS1_QUALITY_FILTERINGCERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTSCERT_CHAIN_DISABLE_AUTH_ROOT_AUTO_UPDATECERT_CHAIN_TIMESTAMP_TIMECERT_CHAIN_ENABLE_PEER_TRUSTCERT_CHAIN_DISABLE_MY_PEER_TRUSTCERT_CHAIN_DISABLE_MD2_MD4CERT_CHAIN_DISABLE_AIACERT_CHAIN_HAS_MOTWCERT_CHAIN_ONLY_ADDITIONAL_AND_AUTH_ROOTCERT_CHAIN_OPT_IN_WEAK_SIGNATURECertDuplicateCertificateChainREVOCATION_OID_CRL_REVOCATIONPCRL_REVOCATION_INFOCRL_REVOCATION_INFOCertFindChainInStoreCERT_CHAIN_FIND_BY_ISSUERPCERT_CHAIN_FIND_ISSUER_PARACERT_CHAIN_FIND_ISSUER_PARACERT_CHAIN_FIND_BY_ISSUER_PARAPCERT_CHAIN_FIND_BY_ISSUER_PARACERT_CHAIN_FIND_BY_ISSUER_COMPARE_KEY_FLAGCERT_CHAIN_FIND_BY_ISSUER_COMPLEX_CHAIN_FLAGCERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_URL_FLAGCERT_CHAIN_FIND_BY_ISSUER_LOCAL_MACHINE_FLAGCERT_CHAIN_FIND_BY_ISSUER_NO_KEY_FLAGCERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_FLAGPCERT_CHAIN_POLICY_PARAPCERT_CHAIN_POLICY_STATUSCERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAGCERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAGCERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAGCERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAGCERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGSCERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAGCERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAGCERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAGCERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAGCERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAGCERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAGCERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAGCERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAGCERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAGCERT_CHAIN_POLICY_TRUST_TESTROOT_FLAGCERT_CHAIN_POLICY_IGNORE_NOT_SUPPORTED_CRITICAL_EXT_FLAGCERT_CHAIN_POLICY_IGNORE_PEER_TRUST_FLAGCERT_CHAIN_POLICY_IGNORE_WEAK_SIGNATURE_FLAGCRYPT_OID_VERIFY_CERTIFICATE_CHAIN_POLICY_FUNCCERT_CHAIN_POLICY_BASECERT_CHAIN_POLICY_AUTHENTICODECERT_CHAIN_POLICY_AUTHENTICODE_TSCERT_CHAIN_POLICY_BASIC_CONSTRAINTSCERT_CHAIN_POLICY_NT_AUTHCERT_CHAIN_POLICY_MICROSOFT_ROOTCERT_CHAIN_POLICY_EVCERT_CHAIN_POLICY_SSL_F12CERT_CHAIN_POLICY_SSL_HPKP_HEADERCERT_CHAIN_POLICY_THIRD_PARTY_ROOTCERT_CHAIN_POLICY_SSL_KEY_PINPAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARAAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARAPAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUSAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUSPAUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARAAUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARAPHTTPSPolicyCallbackDataSSL_EXTRA_CERT_CHAIN_POLICY_PARAPSSL_EXTRA_CERT_CHAIN_POLICY_PARAAUTHTYPE_CLIENTBASIC_CONSTRAINTS_CERT_CHAIN_POLICY_CA_FLAGBASIC_CONSTRAINTS_CERT_CHAIN_POLICY_END_ENTITY_FLAGMICROSOFT_ROOT_CERT_CHAIN_POLICY_ENABLE_TEST_ROOT_FLAGMICROSOFT_ROOT_CERT_CHAIN_POLICY_CHECK_APPLICATION_ROOT_FLAGMICROSOFT_ROOT_CERT_CHAIN_POLICY_DISABLE_FLIGHT_ROOT_FLAGPEV_EXTRA_CERT_CHAIN_POLICY_PARAEV_EXTRA_CERT_CHAIN_POLICY_PARAPEV_EXTRA_CERT_CHAIN_POLICY_STATUSEV_EXTRA_CERT_CHAIN_POLICY_STATUSSSL_F12_ERROR_TEXT_LENGTHPSSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUSSSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUSCERT_CHAIN_POLICY_SSL_F12_SUCCESS_LEVELCERT_CHAIN_POLICY_SSL_F12_WARNING_LEVELCERT_CHAIN_POLICY_SSL_F12_ERROR_LEVELCERT_CHAIN_POLICY_SSL_F12_NONE_CATEGORYCERT_CHAIN_POLICY_SSL_F12_WEAK_CRYPTO_CATEGORYCERT_CHAIN_POLICY_SSL_F12_ROOT_PROGRAM_CATEGORYSSL_HPKP_PKP_HEADER_INDEXSSL_HPKP_PKP_RO_HEADER_INDEXSSL_HPKP_HEADER_COUNTPSSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARASSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARAPSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARASSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARASSL_KEY_PIN_ERROR_TEXT_LENGTHPSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUSSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUSCERT_CHAIN_POLICY_SSL_KEY_PIN_MISMATCH_ERRORCERT_CHAIN_POLICY_SSL_KEY_PIN_MITM_ERRORCERT_CHAIN_POLICY_SSL_KEY_PIN_SUCCESSCERT_CHAIN_POLICY_SSL_KEY_PIN_MITM_WARNINGCERT_CHAIN_POLICY_SSL_KEY_PIN_MISMATCH_WARNINGCryptStringToBinaryACryptStringToBinaryWCryptBinaryToStringACryptBinaryToStringWCRYPT_STRING_BASE64HEADERCRYPT_STRING_BASE64CRYPT_STRING_BINARYCRYPT_STRING_BASE64REQUESTHEADERCRYPT_STRING_HEXCRYPT_STRING_HEXASCIICRYPT_STRING_BASE64_ANYCRYPT_STRING_ANYCRYPT_STRING_HEX_ANYCRYPT_STRING_BASE64X509CRLHEADERCRYPT_STRING_HEXADDRCRYPT_STRING_HEXASCIIADDRCRYPT_STRING_HEXRAWCRYPT_STRING_BASE64URICRYPT_STRING_ENCODEMASKCRYPT_STRING_RESERVED100CRYPT_STRING_RESERVED200CRYPT_STRING_PERCENTESCAPECRYPT_STRING_HASHDATACRYPT_STRING_STRICTCRYPT_STRING_NOCRLFCRYPT_STRING_NOCRszOID_PKCS_12_PbeIdsszOID_PKCS_12_pbeWithSHA1And128BitRC4szOID_PKCS_12_pbeWithSHA1And40BitRC4szOID_PKCS_12_pbeWithSHA1And3KeyTripleDESszOID_PKCS_12_pbeWithSHA1And2KeyTripleDESszOID_PKCS_12_pbeWithSHA1And128BitRC2szOID_PKCS_12_pbeWithSHA1And40BitRC2PFXImportCertStorePKCS12_IMPORT_SILENTCRYPT_USER_KEYSETPKCS12_PREFER_CNG_KSPPKCS12_ALWAYS_CNG_KSPPKCS12_ONLY_CERTIFICATESPKCS12_ONLY_NOT_ENCRYPTED_CERTIFICATESPKCS12_ALLOW_OVERWRITE_KEYPKCS12_NO_PERSIST_KEYPKCS12_IMPORT_RESERVED_MASKPKCS12_OBJECT_LOCATOR_ALL_IMPORT_FLAGSPKCS12_ONLY_CERTIFICATES_PROVIDER_TYPEPKCS12_ONLY_CERTIFICATES_PROVIDER_NAMEPKCS12_ONLY_CERTIFICATES_CONTAINER_NAMEPFXIsPFXBlobPFXVerifyPasswordPFXExportCertStoreExREPORT_NO_PRIVATE_KEYREPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEYEXPORT_PRIVATE_KEYSPKCS12_INCLUDE_EXTENDED_PROPERTIESPKCS12_PROTECT_TO_DOMAIN_SIDSPKCS12_EXPORT_SILENTPKCS12_DISABLE_ENCRYPT_CERTIFICATESPKCS12_ENCRYPT_CERTIFICATESPKCS12_EXPORT_ECC_CURVE_PARAMETERSPKCS12_EXPORT_ECC_CURVE_OIDPKCS12_EXPORT_RESERVED_MASKPKCS12_CONFIG_REGPATHPKCS12_ENCRYPT_CERTIFICATES_VALUE_NAMEPFXExportCertStoreHCERT_SERVER_OCSP_RESPONSEPCERT_SERVER_OCSP_RESPONSE_CONTEXTCERT_SERVER_OCSP_RESPONSE_CONTEXTPCCERT_SERVER_OCSP_RESPONSE_CONTEXTPCERT_SERVER_OCSP_RESPONSE_OPEN_PARACERT_SERVER_OCSP_RESPONSE_OPEN_PARACERT_SERVER_OCSP_RESPONSE_OPEN_PARA_READ_FLAGCERT_SERVER_OCSP_RESPONSE_OPEN_PARA_WRITE_FLAGCertOpenServerOcspResponseCERT_SERVER_OCSP_RESPONSE_ASYNC_FLAGCertAddRefServerOcspResponseCertCloseServerOcspResponseCertGetServerOcspResponseContextCertAddRefServerOcspResponseContextCertFreeServerOcspResponseContextCertRetrieveLogoOrBiometricInfoCERT_RETRIEVE_ISSUER_LOGOCERT_RETRIEVE_SUBJECT_LOGOCERT_RETRIEVE_COMMUNITY_LOGOCERT_RETRIEVE_BIOMETRIC_PREDEFINED_BASE_TYPECERT_RETRIEVE_BIOMETRIC_PICTURE_TYPECERT_RETRIEVE_BIOMETRIC_SIGNATURE_TYPEPCERT_SELECT_CHAIN_PARACERT_SELECT_CHAIN_PARAPCCERT_SELECT_CHAIN_PARACERT_SELECT_MAX_PARAPCERT_SELECT_CRITERIACERT_SELECT_CRITERIAPCCERT_SELECT_CRITERIACERT_SELECT_BY_ENHKEY_USAGECERT_SELECT_BY_KEY_USAGECERT_SELECT_BY_POLICY_OIDCERT_SELECT_BY_PROV_NAMECERT_SELECT_BY_EXTENSIONCERT_SELECT_BY_SUBJECT_HOST_NAMECERT_SELECT_BY_ISSUER_ATTRCERT_SELECT_BY_SUBJECT_ATTRCERT_SELECT_BY_ISSUER_NAMECERT_SELECT_BY_PUBLIC_KEYCERT_SELECT_BY_TLS_SIGNATURESCERT_SELECT_BY_ISSUER_DISPLAYNAMECERT_SELECT_BY_FRIENDLYNAMECERT_SELECT_BY_THUMBPRINTCERT_SELECT_LASTCERT_SELECT_MAXCERT_SELECT_ALLOW_EXPIREDCERT_SELECT_TRUSTED_ROOTCERT_SELECT_DISALLOW_SELFSIGNEDCERT_SELECT_HAS_PRIVATE_KEYCERT_SELECT_HAS_KEY_FOR_SIGNATURECERT_SELECT_HAS_KEY_FOR_KEY_EXCHANGECERT_SELECT_HARDWARE_ONLYCERT_SELECT_ALLOW_DUPLICATESCERT_SELECT_IGNORE_AUTOSELECTCertSelectCertificateChainsCertFreeCertificateChainListTIMESTAMP_VERSIONPCRYPT_TIMESTAMP_REQUESTCRYPT_TIMESTAMP_REQUESTPCRYPT_TIMESTAMP_RESPONSECRYPT_TIMESTAMP_RESPONSETIMESTAMP_STATUS_GRANTEDTIMESTAMP_STATUS_GRANTED_WITH_MODSTIMESTAMP_STATUS_REJECTEDTIMESTAMP_STATUS_WAITINGTIMESTAMP_STATUS_REVOCATION_WARNINGTIMESTAMP_STATUS_REVOKEDTIMESTAMP_FAILURE_BAD_ALGTIMESTAMP_FAILURE_BAD_REQUESTTIMESTAMP_FAILURE_BAD_FORMATTIMESTAMP_FAILURE_TIME_NOT_AVAILABLETIMESTAMP_FAILURE_POLICY_NOT_SUPPORTEDTIMESTAMP_FAILURE_EXTENSION_NOT_SUPPORTEDTIMESTAMP_FAILURE_INFO_NOT_AVAILABLETIMESTAMP_FAILURE_SYSTEM_FAILUREPCRYPT_TIMESTAMP_ACCURACYCRYPT_TIMESTAMP_ACCURACYPCRYPT_TIMESTAMP_INFOCRYPT_TIMESTAMP_INFOPCRYPT_TIMESTAMP_CONTEXTCRYPT_TIMESTAMP_CONTEXTPCRYPT_TIMESTAMP_PARACRYPT_TIMESTAMP_PARACryptRetrieveTimeStampTIMESTAMP_DONT_HASH_DATATIMESTAMP_VERIFY_CONTEXT_SIGNATURETIMESTAMP_NO_AUTH_RETRIEVALCryptVerifyTimeStampSignatureCRYPT_OBJECT_LOCATOR_SPN_NAME_TYPECRYPT_OBJECT_LOCATOR_LAST_RESERVED_NAME_TYPECRYPT_OBJECT_LOCATOR_FIRST_RESERVED_USER_NAME_TYPECRYPT_OBJECT_LOCATOR_LAST_RESERVED_USER_NAME_TYPESSL_OBJECT_LOCATOR_PFX_FUNCSSL_OBJECT_LOCATOR_ISSUER_LIST_FUNCSSL_OBJECT_LOCATOR_CERT_VALIDATION_CONFIG_FUNCCRYPT_OBJECT_LOCATOR_RELEASE_SYSTEM_SHUTDOWNCRYPT_OBJECT_LOCATOR_RELEASE_SERVICE_STOPCRYPT_OBJECT_LOCATOR_RELEASE_PROCESS_EXITCRYPT_OBJECT_LOCATOR_RELEASE_DLL_UNLOADPCRYPT_OBJECT_LOCATOR_PROVIDER_TABLECRYPT_OBJECT_LOCATOR_PROVIDER_TABLECertIsWeakHashCERT_FILE_HASH_USE_TYPECERT_TIMESTAMP_HASH_USE_TYPE//! Cryptographic API Prototypes and DefinitionsCeipIsOptedInWINEFS_SETUSERKEY_SET_CAPABILITIESPEFS_CERTIFICATE_BLOBEFS_CERTIFICATE_BLOBPEFS_HASH_BLOBEFS_HASH_BLOBPEFS_RPC_BLOBEFS_RPC_BLOBPEFS_PIN_BLOBEFS_PIN_BLOBPEFS_KEY_INFOEFS_KEY_INFOPEFS_COMPATIBILITY_INFOEFS_COMPATIBILITY_INFOEFS_COMPATIBILITY_VERSION_NCRYPT_PROTECTOREFS_COMPATIBILITY_VERSION_PFILE_PROTECTOREFS_IS_DESCRIPTOR_VERSIONEFS_SUBVER_UNKNOWNEFS_EFS_SUBVER_EFS_CERTEFS_PFILE_SUBVER_RMSEFS_PFILE_SUBVER_APPXPEFS_VERSION_INFOEFS_VERSION_INFOEFS_IS_APPX_VERSIONPEFS_DECRYPTION_STATUS_INFOEFS_DECRYPTION_STATUS_INFOPEFS_ENCRYPTION_STATUS_INFOEFS_ENCRYPTION_STATUS_INFOPENCRYPTION_CERTIFICATEENCRYPTION_CERTIFICATEMAX_SID_SIZEPENCRYPTION_CERTIFICATE_HASHENCRYPTION_CERTIFICATE_HASHPENCRYPTION_CERTIFICATE_HASH_LISTENCRYPTION_CERTIFICATE_HASH_LISTPENCRYPTION_CERTIFICATE_LISTENCRYPTION_CERTIFICATE_LISTEFS_METADATA_ADD_USEREFS_METADATA_REMOVE_USEREFS_METADATA_REPLACE_USEREFS_METADATA_GENERAL_OPPENCRYPTED_FILE_METADATA_SIGNATUREENCRYPTED_FILE_METADATA_SIGNATUREPENCRYPTION_PROTECTORENCRYPTION_PROTECTORPENCRYPTION_PROTECTOR_LISTENCRYPTION_PROTECTOR_LISTQueryUsersOnEncryptedFileQueryRecoveryAgentsOnEncryptedFileRemoveUsersFromEncryptedFileAddUsersToEncryptedFileSetUserFileEncryptionKeySetUserFileEncryptionKeyExFreeEncryptionCertificateHashListEncryptionDisableDuplicateEncryptionInfoFileGetEncryptedFileMetadataSetEncryptedFileMetadataFreeEncryptedFileMetadataEVT_HANDLEPEVT_HANDLEEVT_VARIANT_TYPE_MASKEVT_VARIANT_TYPE_ARRAYPEVT_VARIANTEVT_VARIANTEvtOpenSessionEVT_LOGIN_CLASSEvtCloseEvtCancelEvtGetExtendedStatusEvtQueryEvtNextEvtSeekEvtSubscribeEVT_SUBSCRIBE_CALLBACKEvtCreateRenderContextEvtRenderEvtFormatMessageEvtOpenLogEvtGetLogInfoEVT_LOG_PROPERTY_IDEvtClearLogEvtExportLogEvtArchiveExportedLogEvtOpenChannelEnumEvtNextChannelPathEvtOpenChannelConfigEvtSaveChannelConfigEvtSetChannelConfigPropertyEVT_CHANNEL_CONFIG_PROPERTY_IDEvtGetChannelConfigPropertyEvtOpenPublisherEnumEvtNextPublisherIdEvtOpenPublisherMetadataEvtGetPublisherMetadataPropertyEVT_PUBLISHER_METADATA_PROPERTY_IDEvtOpenEventMetadataEnumEvtNextEventMetadataEvtGetEventMetadataPropertyEVT_EVENT_METADATA_PROPERTY_IDEVT_OBJECT_ARRAY_PROPERTY_HANDLEEvtGetObjectArraySizeEvtGetObjectArrayPropertyEvtGetQueryInfoEVT_QUERY_PROPERTY_IDEvtCreateBookmarkEvtUpdateBookmarkEvtGetEventInfoEVT_EVENT_PROPERTY_IDEVT_READ_ACCESSEVT_WRITE_ACCESSEVT_CLEAR_ACCESSEVT_ALL_ACCESS//! Windows Events APIHMETAFILEHCOLORSPACEHFONTHGLRCR2_BLACKR2_NOTMERGEPENR2_MASKNOTPENR2_NOTCOPYPENR2_MASKPENNOTR2_NOTR2_XORPENR2_NOTMASKPENR2_MASKPENR2_NOTXORPENR2_NOPR2_MERGENOTPENR2_COPYPENR2_MERGEPENNOTR2_MERGEPENR2_WHITER2_LASTSRCCOPYSRCPAINTSRCANDSRCINVERTSRCERASENOTSRCCOPYNOTSRCERASEMERGECOPYMERGEPAINTPATCOPYPATPAINTPATINVERTDSTINVERTBLACKNESSWHITENESSNOMIRRORBITMAPCAPTUREBLTMAKEROP4GDI_ERRORHGDI_ERRORNULLREGIONSIMPLEREGIONCOMPLEXREGIONRGN_ERRORRGN_ANDRGN_ORRGN_XORRGN_DIFFRGN_COPYRGN_MINRGN_MAXBLACKONWHITEWHITEONBLACKCOLORONCOLORHALFTONEMAXSTRETCHBLTMODESTRETCH_ANDSCANSSTRETCH_ORSCANSSTRETCH_DELETESCANSSTRETCH_HALFTONEALTERNATEWINDINGPOLYFILL_LASTLAYOUT_RTLLAYOUT_BTTLAYOUT_VBHLAYOUT_ORIENTATIONMASKLAYOUT_BITMAPORIENTATIONPRESERVEDTA_NOUPDATECPTA_UPDATECPTA_LEFTTA_RIGHTTA_CENTERTA_TOPTA_BOTTOMTA_BASELINETA_RTLREADINGTA_MASKVTA_BASELINEVTA_LEFTVTA_RIGHTVTA_CENTERVTA_BOTTOMVTA_TOPETO_OPAQUEETO_CLIPPEDETO_GLYPH_INDEXETO_RTLREADINGETO_NUMERICSLOCALETO_NUMERICSLATINETO_IGNORELANGUAGEETO_PDYETO_REVERSE_INDEX_MAPASPECT_FILTERINGDCB_RESETDCB_ACCUMULATEDCB_DIRTYDCB_SETDCB_ENABLEDCB_DISABLEMETA_SETBKCOLORMETA_SETBKMODEMETA_SETMAPMODEMETA_SETROP2META_SETRELABSMETA_SETPOLYFILLMODEMETA_SETSTRETCHBLTMODEMETA_SETTEXTCHAREXTRAMETA_SETTEXTCOLORMETA_SETTEXTJUSTIFICATIONMETA_SETWINDOWORGMETA_SETWINDOWEXTMETA_SETVIEWPORTORGMETA_SETVIEWPORTEXTMETA_OFFSETWINDOWORGMETA_SCALEWINDOWEXTMETA_OFFSETVIEWPORTORGMETA_SCALEVIEWPORTEXTMETA_LINETOMETA_MOVETOMETA_EXCLUDECLIPRECTMETA_INTERSECTCLIPRECTMETA_ARCMETA_ELLIPSEMETA_FLOODFILLMETA_PIEMETA_RECTANGLEMETA_ROUNDRECTMETA_PATBLTMETA_SAVEDCMETA_SETPIXELMETA_OFFSETCLIPRGNMETA_TEXTOUTMETA_BITBLTMETA_STRETCHBLTMETA_POLYGONMETA_POLYLINEMETA_ESCAPEMETA_RESTOREDCMETA_FILLREGIONMETA_FRAMEREGIONMETA_INVERTREGIONMETA_PAINTREGIONMETA_SELECTCLIPREGIONMETA_SELECTOBJECTMETA_SETTEXTALIGNMETA_CHORDMETA_SETMAPPERFLAGSMETA_EXTTEXTOUTMETA_SETDIBTODEVMETA_SELECTPALETTEMETA_REALIZEPALETTEMETA_ANIMATEPALETTEMETA_SETPALENTRIESMETA_POLYPOLYGONMETA_RESIZEPALETTEMETA_DIBBITBLTMETA_DIBSTRETCHBLTMETA_DIBCREATEPATTERNBRUSHMETA_STRETCHDIBMETA_EXTFLOODFILLMETA_SETLAYOUTMETA_DELETEOBJECTMETA_CREATEPALETTEMETA_CREATEPATTERNBRUSHMETA_CREATEPENINDIRECTMETA_CREATEFONTINDIRECTMETA_CREATEBRUSHINDIRECTMETA_CREATEREGIONPDRAWPATRECTDRAWPATRECTNEWFRAMEABORTDOCNEXTBANDSETCOLORTABLEGETCOLORTABLEFLUSHOUTPUTDRAFTMODEQUERYESCSUPPORTSETABORTPROCSTARTDOCENDDOCGETPHYSPAGESIZEGETPRINTINGOFFSETGETSCALINGFACTORMFCOMMENTGETPENWIDTHSETCOPYCOUNTSELECTPAPERSOURCEDEVICEDATAGETTECHNOLGYGETTECHNOLOGYSETLINECAPSETLINEJOINSETMITERLIMITBANDINFODRAWPATTERNRECTGETVECTORPENSIZEGETVECTORBRUSHSIZEENABLEDUPLEXGETSETPAPERBINSGETSETPRINTORIENTENUMPAPERBINSSETDIBSCALINGEPSPRINTINGENUMPAPERMETRICSGETSETPAPERMETRICSPOSTSCRIPT_DATAPOSTSCRIPT_IGNOREMOUSETRAILSGETDEVICEUNITSGETEXTENDEDTEXTMETRICSGETEXTENTTABLEGETPAIRKERNTABLEGETTRACKKERNTABLEEXTTEXTOUTGETFACENAMEDOWNLOADFACEENABLERELATIVEWIDTHSENABLEPAIRKERNINGSETKERNTRACKSETALLJUSTVALUESSETCHARSETSTRETCHBLTMETAFILE_DRIVERGETSETSCREENPARAMSQUERYDIBSUPPORTBEGIN_PATHCLIP_TO_PATHEND_PATHEXT_DEVICE_CAPSRESTORE_CTMSAVE_CTMSET_ARC_DIRECTIONSET_BACKGROUND_COLORSET_POLY_MODESET_SCREEN_ANGLESET_SPREADTRANSFORM_CTMSET_CLIP_BOXSET_BOUNDSSET_MIRROR_MODEOPENCHANNELDOWNLOADHEADERCLOSECHANNELPOSTSCRIPT_PASSTHROUGHENCAPSULATED_POSTSCRIPTPOSTSCRIPT_IDENTIFYPOSTSCRIPT_INJECTIONCHECKJPEGFORMATCHECKPNGFORMATGET_PS_FEATURESETTINGGDIPLUS_TS_QUERYVERGDIPLUS_TS_RECORDMILCORE_TS_QUERYVER_RESULT_FALSEMILCORE_TS_QUERYVER_RESULT_TRUESPCLPASSTHROUGH2PSIDENT_GDICENTRICPSIDENT_PSCENTRICPPSINJECTDATAPSINJECTDATAPSINJECT_BEGINSTREAMPSINJECT_PSADOBEPSINJECT_PAGESATENDPSINJECT_PAGESPSINJECT_DOCNEEDEDRESPSINJECT_DOCSUPPLIEDRESPSINJECT_PAGEORDERPSINJECT_ORIENTATIONPSINJECT_BOUNDINGBOXPSINJECT_DOCUMENTPROCESSCOLORSPSINJECT_COMMENTSPSINJECT_BEGINDEFAULTSPSINJECT_ENDDEFAULTSPSINJECT_BEGINPROLOGPSINJECT_ENDPROLOGPSINJECT_BEGINSETUPPSINJECT_ENDSETUPPSINJECT_TRAILERPSINJECT_EOFPSINJECT_ENDSTREAMPSINJECT_DOCUMENTPROCESSCOLORSATENDPSINJECT_PAGENUMBERPSINJECT_BEGINPAGESETUPPSINJECT_ENDPAGESETUPPSINJECT_PAGETRAILERPSINJECT_PLATECOLORPSINJECT_SHOWPAGEPSINJECT_PAGEBBOXPSINJECT_ENDPAGECOMMENTSPSINJECT_VMSAVEPSINJECT_VMRESTOREPSINJECT_DLFONTFEATURESETTING_NUPFEATURESETTING_OUTPUTFEATURESETTING_PSLEVELFEATURESETTING_CUSTPAPERFEATURESETTING_MIRRORFEATURESETTING_NEGATIVEFEATURESETTING_PROTOCOLFEATURESETTING_PRIVATE_BEGINFEATURESETTING_PRIVATE_ENDPPSFEATURE_OUTPUTPSFEATURE_OUTPUTPPSFEATURE_CUSTPAPERPSFEATURE_CUSTPAPERPSPROTOCOL_ASCIIPSPROTOCOL_BCPPSPROTOCOL_TBCPPSPROTOCOL_BINARYQDI_SETDIBITSQDI_GETDIBITSQDI_DIBTOSCREENQDI_STRETCHDIBSP_NOTREPORTEDSP_ERRORSP_APPABORTSP_USERABORTSP_OUTOFDISKSP_OUTOFMEMORYPR_JOBSTATUSOBJ_PENOBJ_BRUSHOBJ_DCOBJ_METADCOBJ_PALOBJ_FONTOBJ_BITMAPOBJ_REGIONOBJ_METAFILEOBJ_MEMDCOBJ_EXTPENOBJ_ENHMETADCOBJ_ENHMETAFILEOBJ_COLORSPACEGDI_OBJ_LASTMWT_IDENTITYMWT_LEFTMULTIPLYMWT_RIGHTMULTIPLYMWT_MINMWT_MAXPXFORMXFORMLPXFORMPBITMAPBITMAPNPBITMAPLPBITMAPPRGBTRIPLERGBTRIPLENPRGBTRIPLELPRGBTRIPLELPRGBQUADCS_ENABLECS_DISABLECS_DELETE_TRANSFORMLCS_SIGNATURELCS_sRGBLCSCSTYPE// 'PSOC'LCS_WINDOWS_COLOR_SPACE// 'sRGB'// 'Win 'LCS_CALIBRATED_RGBLCSGAMUTMATCHLCS_GM_BUSINESSLCS_GM_GRAPHICSLCS_GM_ABS_COLORIMETRICCM_OUT_OF_GAMUTCM_IN_GAMUTICM_ADDPROFILEICM_DELETEPROFILEICM_QUERYPROFILEICM_SETDEFAULTPROFILEICM_REGISTERICMATCHERICM_UNREGISTERICMATCHERICM_QUERYMATCHGetKValueGetYValueGetMValueGetCValueFXPT16DOT16LPFXPT16DOT16FXPT2DOT30LPFXPT2DOT30LPCIEXYZCIEXYZLPCIEXYZTRIPLECIEXYZTRIPLELPLOGCOLORSPACEALOGCOLORSPACEALPLOGCOLORSPACEWLOGCOLORSPACEWLPBITMAPCOREHEADERBITMAPCOREHEADERPBITMAPCOREHEADERLPBITMAPINFOHEADERPBITMAPINFOHEADERLPBITMAPV4HEADERBITMAPV4HEADERPBITMAPV4HEADERLPBITMAPV5HEADERPBITMAPV5HEADERPROFILE_LINKEDPROFILE_EMBEDDED// 'LINK'// 'MBED'BI_RLE8BI_RLE4BI_JPEGBI_PNGLPBITMAPINFOPBITMAPINFOLPBITMAPCOREINFOBITMAPCOREINFOPBITMAPCOREINFOLPBITMAPFILEHEADERBITMAPFILEHEADERPBITMAPFILEHEADERMAKEPOINTSLPFONTSIGNATUREPFONTSIGNATUREPCHARSETINFOCHARSETINFONPCHARSETINFOLPCHARSETINFOTCI_SRCCHARSETTCI_SRCCODEPAGETCI_SRCFONTSIGTCI_SRCLOCALEPLOCALESIGNATURELOCALESIGNATURELPLOCALESIGNATURELPHANDLETABLEHANDLETABLEPHANDLETABLEPMETARECORDMETARECORDLPMETARECORDLPMETAFILEPICTMETAFILEPICTPMETAHEADERMETAHEADERLPMETAHEADERPENHMETARECORDENHMETARECORDLPENHMETARECORDPENHMETAHEADERENHMETAHEADERLPENHMETAHEADERTMPF_FIXED_PITCHTMPF_VECTORTMPF_DEVICETMPF_TRUETYPE// BCHARPTEXTMETRICATEXTMETRICANPTEXTMETRICALPTEXTMETRICAPTEXTMETRICWNPTEXTMETRICWLPTEXTMETRICWNTM_REGULARNTM_BOLDNTM_ITALICNTM_NONNEGATIVE_ACNTM_PS_OPENTYPENTM_TT_OPENTYPENTM_MULTIPLEMASTERNTM_TYPE1NTM_DSIGPNEWTEXTMETRICANEWTEXTMETRICANPNEWTEXTMETRICALPNEWTEXTMETRICAPNEWTEXTMETRICWNEWTEXTMETRICWNPNEWTEXTMETRICWLPNEWTEXTMETRICWPPELARRAYPELARRAYNPPELARRAYLPPELARRAYPLOGBRUSHLOGBRUSHNPLOGBRUSHLPLOGBRUSHPLOGBRUSH32LOGBRUSH32NPLOGBRUSH32LPLOGBRUSH32PPATTERNNPPATTERNLPPATTERNPLOGPENLOGPENNPLOGPENLPLOGPENPEXTLOGPENEXTLOGPENNPEXTLOGPENLPEXTLOGPENPEXTLOGPEN32EXTLOGPEN32NPEXTLOGPEN32LPEXTLOGPEN32PPALETTEENTRYLPPALETTEENTRYPLOGPALETTENPLOGPALETTELPLOGPALETTEPLOGFONTALOGFONTANPLOGFONTAPLOGFONTWNPLOGFONTWLF_FULLFACESIZELPENUMLOGFONTAENUMLOGFONTALPENUMLOGFONTWENUMLOGFONTWLPENUMLOGFONTEXAENUMLOGFONTEXALPENUMLOGFONTEXWENUMLOGFONTEXWOUT_DEFAULT_PRECISOUT_STRING_PRECISOUT_CHARACTER_PRECISOUT_STROKE_PRECISOUT_TT_PRECISOUT_DEVICE_PRECISOUT_RASTER_PRECISOUT_TT_ONLY_PRECISOUT_OUTLINE_PRECISOUT_SCREEN_OUTLINE_PRECISOUT_PS_ONLY_PRECISCLIP_DEFAULT_PRECISCLIP_CHARACTER_PRECISCLIP_STROKE_PRECISCLIP_MASKCLIP_LH_ANGLESCLIP_TT_ALWAYSCLIP_DFA_DISABLECLIP_EMBEDDEDDEFAULT_QUALITYDRAFT_QUALITYPROOF_QUALITYNONANTIALIASED_QUALITYANTIALIASED_QUALITYCLEARTYPE_QUALITYCLEARTYPE_NATURAL_QUALITYDEFAULT_PITCHFIXED_PITCHVARIABLE_PITCHMONO_FONTANSI_CHARSETDEFAULT_CHARSETSYMBOL_CHARSETSHIFTJIS_CHARSETHANGEUL_CHARSETHANGUL_CHARSETGB2312_CHARSETCHINESEBIG5_CHARSETOEM_CHARSETJOHAB_CHARSETHEBREW_CHARSETARABIC_CHARSETGREEK_CHARSETTURKISH_CHARSETVIETNAMESE_CHARSETTHAI_CHARSETEASTEUROPE_CHARSETRUSSIAN_CHARSETMAC_CHARSETBALTIC_CHARSETFS_LATIN1FS_LATIN2FS_CYRILLICFS_GREEKFS_TURKISHFS_HEBREWFS_ARABICFS_BALTICFS_VIETNAMESEFS_THAIFS_JISJAPANFS_CHINESESIMPFS_WANSUNGFS_CHINESETRADFS_JOHABFS_SYMBOLFF_DONTCAREFF_ROMANFF_SWISSFF_MODERNFF_SCRIPTFF_DECORATIVEFW_DONTCAREFW_THINFW_EXTRALIGHTFW_LIGHTFW_NORMALFW_MEDIUMFW_SEMIBOLDFW_BOLDFW_EXTRABOLDFW_HEAVYFW_ULTRALIGHTFW_REGULARFW_DEMIBOLDFW_ULTRABOLDFW_BLACKPANOSE_COUNTPAN_FAMILYTYPE_INDEXPAN_SERIFSTYLE_INDEXPAN_WEIGHT_INDEXPAN_PROPORTION_INDEXPAN_CONTRAST_INDEXPAN_STROKEVARIATION_INDEXPAN_ARMSTYLE_INDEXPAN_LETTERFORM_INDEXPAN_MIDLINE_INDEXPAN_XHEIGHT_INDEXPAN_CULTURE_LATINLPPANOSEPANOSEPAN_ANYPAN_NO_FITPAN_FAMILY_TEXT_DISPLAYPAN_FAMILY_SCRIPTPAN_FAMILY_DECORATIVEPAN_FAMILY_PICTORIALPAN_SERIF_COVEPAN_SERIF_OBTUSE_COVEPAN_SERIF_SQUARE_COVEPAN_SERIF_OBTUSE_SQUARE_COVEPAN_SERIF_SQUAREPAN_SERIF_THINPAN_SERIF_BONEPAN_SERIF_EXAGGERATEDPAN_SERIF_TRIANGLEPAN_SERIF_NORMAL_SANSPAN_SERIF_OBTUSE_SANSPAN_SERIF_PERP_SANSPAN_SERIF_FLAREDPAN_SERIF_ROUNDEDPAN_WEIGHT_VERY_LIGHTPAN_WEIGHT_LIGHTPAN_WEIGHT_THINPAN_WEIGHT_BOOKPAN_WEIGHT_MEDIUMPAN_WEIGHT_DEMIPAN_WEIGHT_BOLDPAN_WEIGHT_HEAVYPAN_WEIGHT_BLACKPAN_WEIGHT_NORDPAN_PROP_OLD_STYLEPAN_PROP_MODERNPAN_PROP_EVEN_WIDTHPAN_PROP_EXPANDEDPAN_PROP_CONDENSEDPAN_PROP_VERY_EXPANDEDPAN_PROP_VERY_CONDENSEDPAN_PROP_MONOSPACEDPAN_CONTRAST_NONEPAN_CONTRAST_VERY_LOWPAN_CONTRAST_LOWPAN_CONTRAST_MEDIUM_LOWPAN_CONTRAST_MEDIUMPAN_CONTRAST_MEDIUM_HIGHPAN_CONTRAST_HIGHPAN_CONTRAST_VERY_HIGHPAN_STROKE_GRADUAL_DIAGPAN_STROKE_GRADUAL_TRANPAN_STROKE_GRADUAL_VERTPAN_STROKE_GRADUAL_HORZPAN_STROKE_RAPID_VERTPAN_STROKE_RAPID_HORZPAN_STROKE_INSTANT_VERTPAN_STRAIGHT_ARMS_HORZPAN_STRAIGHT_ARMS_WEDGEPAN_STRAIGHT_ARMS_VERTPAN_STRAIGHT_ARMS_SINGLE_SERIFPAN_STRAIGHT_ARMS_DOUBLE_SERIFPAN_BENT_ARMS_HORZPAN_BENT_ARMS_WEDGEPAN_BENT_ARMS_VERTPAN_BENT_ARMS_SINGLE_SERIFPAN_BENT_ARMS_DOUBLE_SERIFPAN_LETT_NORMAL_CONTACTPAN_LETT_NORMAL_WEIGHTEDPAN_LETT_NORMAL_BOXEDPAN_LETT_NORMAL_FLATTENEDPAN_LETT_NORMAL_ROUNDEDPAN_LETT_NORMAL_OFF_CENTERPAN_LETT_NORMAL_SQUAREPAN_LETT_OBLIQUE_CONTACTPAN_LETT_OBLIQUE_WEIGHTEDPAN_LETT_OBLIQUE_BOXEDPAN_LETT_OBLIQUE_FLATTENEDPAN_LETT_OBLIQUE_ROUNDEDPAN_LETT_OBLIQUE_OFF_CENTERPAN_LETT_OBLIQUE_SQUAREPAN_MIDLINE_STANDARD_TRIMMEDPAN_MIDLINE_STANDARD_POINTEDPAN_MIDLINE_STANDARD_SERIFEDPAN_MIDLINE_HIGH_TRIMMEDPAN_MIDLINE_HIGH_POINTEDPAN_MIDLINE_HIGH_SERIFEDPAN_MIDLINE_CONSTANT_TRIMMEDPAN_MIDLINE_CONSTANT_POINTEDPAN_MIDLINE_CONSTANT_SERIFEDPAN_MIDLINE_LOW_TRIMMEDPAN_MIDLINE_LOW_POINTEDPAN_MIDLINE_LOW_SERIFEDPAN_XHEIGHT_CONSTANT_SMALLPAN_XHEIGHT_CONSTANT_STDPAN_XHEIGHT_CONSTANT_LARGEPAN_XHEIGHT_DUCKING_SMALLPAN_XHEIGHT_DUCKING_STDPAN_XHEIGHT_DUCKING_LARGEELF_VENDOR_SIZEPEXTLOGFONTAEXTLOGFONTANPEXTLOGFONTALPEXTLOGFONTAPEXTLOGFONTWEXTLOGFONTWNPEXTLOGFONTWLPEXTLOGFONTWELF_VERSIONELF_CULTURE_LATINRASTER_FONTTYPEDEVICE_FONTTYPETRUETYPE_FONTTYPEPALETTERGBPALETTEINDEXPC_RESERVEDPC_EXPLICITPC_NOCOLLAPSEGetRValueGetGValueGetBValueOPAQUEBKMODE_LASTGM_COMPATIBLEGM_ADVANCEDGM_LASTPT_CLOSEFIGUREPT_LINETOPT_BEZIERTOPT_MOVETOMM_TEXTMM_LOMETRICMM_HIMETRICMM_LOENGLISHMM_HIENGLISHMM_TWIPSMM_ISOTROPICMM_ANISOTROPICMM_MINMM_MAXMM_MAX_FIXEDSCALEWHITE_BRUSHLTGRAY_BRUSHGRAY_BRUSHDKGRAY_BRUSHBLACK_BRUSHNULL_BRUSHHOLLOW_BRUSHWHITE_PENBLACK_PENNULL_PENOEM_FIXED_FONTANSI_FIXED_FONTANSI_VAR_FONTSYSTEM_FONTDEVICE_DEFAULT_FONTDEFAULT_PALETTESYSTEM_FIXED_FONTDEFAULT_GUI_FONTDC_BRUSHDC_PENSTOCK_LASTCLR_INVALIDBS_SOLIDBS_NULLBS_HOLLOWBS_HATCHEDBS_PATTERNBS_INDEXEDBS_DIBPATTERNBS_DIBPATTERNPTBS_PATTERN8X8BS_DIBPATTERN8X8BS_MONOPATTERNHS_HORIZONTALHS_VERTICALHS_FDIAGONALHS_BDIAGONALHS_CROSSHS_DIAGCROSSHS_API_MAXPS_SOLIDPS_DASHPS_DOTPS_DASHDOTPS_DASHDOTDOTPS_NULLPS_INSIDEFRAMEPS_USERSTYLEPS_ALTERNATEPS_STYLE_MASKPS_ENDCAP_ROUNDPS_ENDCAP_SQUAREPS_ENDCAP_FLATPS_ENDCAP_MASKPS_JOIN_ROUNDPS_JOIN_BEVELPS_JOIN_MITERPS_JOIN_MASKPS_COSMETICPS_GEOMETRICPS_TYPE_MASKAD_COUNTERCLOCKWISEAD_CLOCKWISEDRIVERVERSIONTECHNOLOGYHORZSIZEVERTSIZEHORZRESVERTRESBITSPIXELPLANESNUMBRUSHESNUMPENSNUMMARKERSNUMFONTSNUMCOLORSPDEVICESIZECURVECAPSLINECAPSPOLYGONALCAPSTEXTCAPSCLIPCAPSRASTERCAPSASPECTXASPECTYASPECTXYLOGPIXELSYSIZEPALETTENUMRESERVEDCOLORRESPHYSICALWIDTHPHYSICALHEIGHTPHYSICALOFFSETXPHYSICALOFFSETYSCALINGFACTORXSCALINGFACTORYVREFRESHDESKTOPVERTRESDESKTOPHORZRESBLTALIGNMENTSHADEBLENDCAPSCOLORMGMTCAPSDT_PLOTTERDT_RASDISPLAYDT_RASPRINTERDT_RASCAMERADT_CHARSTREAMDT_METAFILEDT_DISPFILECC_NONECC_CIRCLESCC_PIECC_CHORDCC_ELLIPSESCC_WIDECC_STYLEDCC_WIDESTYLEDCC_INTERIORSCC_ROUNDRECTLC_NONELC_POLYLINELC_MARKERLC_POLYMARKERLC_WIDELC_STYLEDLC_WIDESTYLEDLC_INTERIORSPC_NONEPC_POLYGONPC_RECTANGLEPC_WINDPOLYGONPC_TRAPEZOIDPC_SCANLINEPC_WIDEPC_STYLEDPC_WIDESTYLEDPC_INTERIORSPC_POLYPOLYGONPC_PATHSCP_NONECP_RECTANGLECP_REGIONTC_OP_CHARACTERTC_OP_STROKETC_CP_STROKETC_CR_90TC_CR_ANYTC_SF_X_YINDEPTC_SA_DOUBLETC_SA_INTEGERTC_SA_CONTINTC_EA_DOUBLETC_IA_ABLETC_UA_ABLETC_SO_ABLETC_RA_ABLETC_VA_ABLETC_RESERVEDTC_SCROLLBLTRC_BITBLTRC_BANDINGRC_SCALINGRC_BITMAP64RC_GDI20_OUTPUTRC_GDI20_STATERC_SAVEBITMAPRC_DI_BITMAPRC_PALETTERC_DIBTODEVRC_BIGFONTRC_STRETCHBLTRC_FLOODFILLRC_STRETCHDIBRC_OP_DX_OUTPUTRC_DEVBITSSB_NONESB_CONST_ALPHASB_PIXEL_ALPHASB_PREMULT_ALPHASB_GRAD_RECTSB_GRAD_TRICM_NONECM_DEVICE_ICMCM_GAMMA_RAMPCM_CMYK_COLORDIB_PAL_COLORSSYSPAL_ERRORSYSPAL_STATICSYSPAL_NOSTATICSYSPAL_NOSTATIC256FLOODFILLBORDERFLOODFILLSURFACECCHDEVICENAMECCHFORMNAMEPDEVMODEADEVMODEANPDEVMODEALPDEVMODEAPDEVMODEWNPDEVMODEWDM_SPECVERSIONDM_ORIENTATIONDM_PAPERSIZEDM_PAPERLENGTHDM_PAPERWIDTHDM_SCALEDM_POSITIONDM_NUPDM_DISPLAYORIENTATIONDM_DEFAULTSOURCEDM_PRINTQUALITYDM_COLORDM_DUPLEXDM_YRESOLUTIONDM_TTOPTIONDM_FORMNAMEDM_LOGPIXELSDM_BITSPERPELDM_PELSWIDTHDM_PELSHEIGHTDM_DISPLAYFLAGSDM_DISPLAYFREQUENCYDM_ICMMETHODDM_ICMINTENTDM_MEDIATYPEDM_DITHERTYPEDM_PANNINGWIDTHDM_PANNINGHEIGHTDM_DISPLAYFIXEDOUTPUTDMORIENT_PORTRAITDMORIENT_LANDSCAPEDMPAPER_FIRSTDMPAPER_LETTERDMPAPER_LETTERSMALLDMPAPER_TABLOIDDMPAPER_LEDGERDMPAPER_LEGALDMPAPER_STATEMENTDMPAPER_EXECUTIVEDMPAPER_A3DMPAPER_A4DMPAPER_A4SMALLDMPAPER_A5DMPAPER_B4DMPAPER_B5DMPAPER_FOLIODMPAPER_QUARTODMPAPER_10X14DMPAPER_11X17DMPAPER_NOTEDMPAPER_ENV_9DMPAPER_ENV_10DMPAPER_ENV_11DMPAPER_ENV_12DMPAPER_ENV_14DMPAPER_CSHEETDMPAPER_DSHEETDMPAPER_ESHEETDMPAPER_ENV_DLDMPAPER_ENV_C5DMPAPER_ENV_C3DMPAPER_ENV_C4DMPAPER_ENV_C6DMPAPER_ENV_C65DMPAPER_ENV_B4DMPAPER_ENV_B5DMPAPER_ENV_B6DMPAPER_ENV_ITALYDMPAPER_ENV_MONARCHDMPAPER_ENV_PERSONALDMPAPER_FANFOLD_USDMPAPER_FANFOLD_STD_GERMANDMPAPER_FANFOLD_LGL_GERMANDMPAPER_ISO_B4DMPAPER_JAPANESE_POSTCARDDMPAPER_9X11DMPAPER_10X11DMPAPER_15X11DMPAPER_ENV_INVITEDMPAPER_RESERVED_48DMPAPER_RESERVED_49DMPAPER_LETTER_EXTRADMPAPER_LEGAL_EXTRADMPAPER_TABLOID_EXTRADMPAPER_A4_EXTRADMPAPER_LETTER_TRANSVERSEDMPAPER_A4_TRANSVERSEDMPAPER_LETTER_EXTRA_TRANSVERSEDMPAPER_A_PLUSDMPAPER_B_PLUSDMPAPER_LETTER_PLUSDMPAPER_A4_PLUSDMPAPER_A5_TRANSVERSEDMPAPER_B5_TRANSVERSEDMPAPER_A3_EXTRADMPAPER_A5_EXTRADMPAPER_B5_EXTRADMPAPER_A2DMPAPER_A3_TRANSVERSEDMPAPER_A3_EXTRA_TRANSVERSEDMPAPER_DBL_JAPANESE_POSTCARDDMPAPER_A6DMPAPER_JENV_KAKU2DMPAPER_JENV_KAKU3DMPAPER_JENV_CHOU3DMPAPER_JENV_CHOU4DMPAPER_LETTER_ROTATEDDMPAPER_A3_ROTATEDDMPAPER_A4_ROTATEDDMPAPER_A5_ROTATEDDMPAPER_B4_JIS_ROTATEDDMPAPER_B5_JIS_ROTATEDDMPAPER_JAPANESE_POSTCARD_ROTATEDDMPAPER_DBL_JAPANESE_POSTCARD_ROTATEDDMPAPER_A6_ROTATEDDMPAPER_JENV_KAKU2_ROTATEDDMPAPER_JENV_KAKU3_ROTATEDDMPAPER_JENV_CHOU3_ROTATEDDMPAPER_JENV_CHOU4_ROTATEDDMPAPER_B6_JISDMPAPER_B6_JIS_ROTATEDDMPAPER_12X11DMPAPER_JENV_YOU4DMPAPER_JENV_YOU4_ROTATEDDMPAPER_P16KDMPAPER_P32KDMPAPER_P32KBIGDMPAPER_PENV_1DMPAPER_PENV_2DMPAPER_PENV_3DMPAPER_PENV_4DMPAPER_PENV_5DMPAPER_PENV_6DMPAPER_PENV_7DMPAPER_PENV_8DMPAPER_PENV_9DMPAPER_PENV_10DMPAPER_P16K_ROTATEDDMPAPER_P32K_ROTATEDDMPAPER_P32KBIG_ROTATEDDMPAPER_PENV_1_ROTATEDDMPAPER_PENV_2_ROTATEDDMPAPER_PENV_3_ROTATEDDMPAPER_PENV_4_ROTATEDDMPAPER_PENV_5_ROTATEDDMPAPER_PENV_6_ROTATEDDMPAPER_PENV_7_ROTATEDDMPAPER_PENV_8_ROTATEDDMPAPER_PENV_9_ROTATEDDMPAPER_PENV_10_ROTATEDDMPAPER_LASTDMPAPER_USERDMBIN_FIRSTDMBIN_UPPERDMBIN_ONLYONEDMBIN_LOWERDMBIN_MIDDLEDMBIN_MANUALDMBIN_ENVELOPEDMBIN_ENVMANUALDMBIN_AUTODMBIN_TRACTORDMBIN_SMALLFMTDMBIN_LARGEFMTDMBIN_LARGECAPACITYDMBIN_CASSETTEDMBIN_FORMSOURCEDMBIN_LASTDMBIN_USERDMRES_DRAFTDMRES_LOWDMRES_MEDIUMDMRES_HIGHDMCOLOR_MONOCHROMEDMCOLOR_COLORDMDUP_SIMPLEXDMDUP_VERTICALDMDUP_HORIZONTALDMTT_BITMAPDMTT_DOWNLOADDMTT_SUBDEVDMTT_DOWNLOAD_OUTLINEDMCOLLATE_FALSEDMCOLLATE_TRUEDMDO_DEFAULTDMDO_90DMDO_180DMDO_270DMDFO_DEFAULTDMDFO_STRETCHDMDFO_CENTERDM_INTERLACEDDMDISPLAYFLAGS_TEXTMODEDMNUP_SYSTEMDMNUP_ONEUPDMICMMETHOD_NONEDMICMMETHOD_SYSTEMDMICMMETHOD_DRIVERDMICMMETHOD_DEVICEDMICMMETHOD_USERDMICM_SATURATEDMICM_CONTRASTDMICM_COLORIMETRICDMICM_ABS_COLORIMETRICDMICM_USERDMMEDIA_STANDARDDMMEDIA_TRANSPARENCYDMMEDIA_GLOSSYDMMEDIA_USERDMDITHER_NONEDMDITHER_COARSEDMDITHER_FINEDMDITHER_LINEARTDMDITHER_ERRORDIFFUSIONDMDITHER_RESERVED6DMDITHER_RESERVED7DMDITHER_RESERVED8DMDITHER_RESERVED9DMDITHER_GRAYSCALEDMDITHER_USERPDISPLAY_DEVICEADISPLAY_DEVICEALPDISPLAY_DEVICEAPDISPLAY_DEVICEWDISPLAY_DEVICEWLPDISPLAY_DEVICEWDISPLAY_DEVICE_ATTACHED_TO_DESKTOPDISPLAY_DEVICE_MULTI_DRIVERDISPLAY_DEVICE_PRIMARY_DEVICEDISPLAY_DEVICE_MIRRORING_DRIVERDISPLAY_DEVICE_VGA_COMPATIBLEDISPLAY_DEVICE_REMOVABLEDISPLAY_DEVICE_ACC_DRIVERDISPLAY_DEVICE_MODESPRUNEDDISPLAY_DEVICE_RDPUDDDISPLAY_DEVICE_REMOTEDISPLAY_DEVICE_DISCONNECTDISPLAY_DEVICE_TS_COMPATIBLEDISPLAY_DEVICE_UNSAFE_MODES_ONDISPLAY_DEVICE_ACTIVEDISPLAY_DEVICE_ATTACHEDDISPLAYCONFIG_MAXPATHDISPLAYCONFIG_PATH_MODE_IDX_INVALIDDISPLAYCONFIG_PATH_TARGET_MODE_IDX_INVALIDDISPLAYCONFIG_PATH_DESKTOP_IMAGE_IDX_INVALIDDISPLAYCONFIG_PATH_SOURCE_MODE_IDX_INVALIDDISPLAYCONFIG_PATH_CLONE_GROUP_INVALIDDISPLAYCONFIG_SOURCE_IN_USEDISPLAYCONFIG_TARGET_IN_USEDISPLAYCONFIG_TARGET_FORCIBLEDISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_BOOTDISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_PATHDISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_SYSTEMDISPLAYCONFIG_TARGET_IS_HMDDISPLAYCONFIG_PATH_ACTIVEDISPLAYCONFIG_PATH_PREFERRED_UNSCALEDDISPLAYCONFIG_PATH_SUPPORT_VIRTUAL_MODEDISPLAYCONFIG_PATH_VALID_FLAGSQDC_ALL_PATHSQDC_ONLY_ACTIVE_PATHSQDC_DATABASE_CURRENTQDC_VIRTUAL_MODE_AWAREQDC_INCLUDE_HMDSDC_TOPOLOGY_INTERNALSDC_TOPOLOGY_CLONESDC_TOPOLOGY_EXTENDSDC_TOPOLOGY_EXTERNALSDC_TOPOLOGY_SUPPLIEDSDC_USE_DATABASE_CURRENTSDC_USE_SUPPLIED_DISPLAY_CONFIGSDC_VALIDATESDC_APPLYSDC_NO_OPTIMIZATIONSDC_SAVE_TO_DATABASESDC_ALLOW_CHANGESSDC_PATH_PERSIST_IF_REQUIREDSDC_FORCE_MODE_ENUMERATIONSDC_ALLOW_PATH_ORDER_CHANGESSDC_VIRTUAL_MODE_AWARERDH_RECTANGLESPRGNDATAHEADERRGNDATAHEADERPRGNDATANPRGNDATALPRGNDATASYSRGNPABCNPABCLPABCPABCFLOATABCFLOATNPABCFLOATLPABCFLOATPOUTLINETEXTMETRICAOUTLINETEXTMETRICANPOUTLINETEXTMETRICALPOUTLINETEXTMETRICAPOUTLINETEXTMETRICWOUTLINETEXTMETRICWNPOUTLINETEXTMETRICWLPOUTLINETEXTMETRICWPPOLYTEXTAPOLYTEXTANPPOLYTEXTALPPOLYTEXTAPPOLYTEXTWPOLYTEXTWNPPOLYTEXTWLPPOLYTEXTWLPMAT2MAT2LPGLYPHMETRICSGLYPHMETRICSGGO_METRICSGGO_BITMAPGGO_NATIVEGGO_BEZIERGGO_GRAY2_BITMAPGGO_GRAY4_BITMAPGGO_GRAY8_BITMAPGGO_GLYPH_INDEXGGO_UNHINTEDTT_POLYGON_TYPETT_PRIM_LINETT_PRIM_QSPLINETT_PRIM_CSPLINELPPOINTFXPOINTFXLPTTPOLYCURVETTPOLYCURVELPTTPOLYGONHEADERTTPOLYGONHEADERGCP_DBCSGCP_REORDERGCP_USEKERNINGGCP_GLYPHSHAPEGCP_LIGATEGCP_DIACRITICGCP_KASHIDAGCP_ERRORFLI_MASKGCP_JUSTIFYFLI_GLYPHSGCP_CLASSINGCP_MAXEXTENTGCP_JUSTIFYINGCP_DISPLAYZWGGCP_SYMSWAPOFFGCP_NUMERICOVERRIDEGCP_NEUTRALOVERRIDEGCP_NUMERICSLATINGCP_NUMERICSLOCALGCPCLASS_LATINGCPCLASS_HEBREWGCPCLASS_ARABICGCPCLASS_NEUTRALGCPCLASS_LOCALNUMBERGCPCLASS_LATINNUMBERGCPCLASS_LATINNUMERICTERMINATORGCPCLASS_LATINNUMERICSEPARATORGCPCLASS_NUMERICSEPARATORGCPCLASS_PREBOUNDLTRGCPCLASS_PREBOUNDRTLGCPCLASS_POSTBOUNDLTRGCPCLASS_POSTBOUNDRTLGCPGLYPH_LINKBEFOREGCPGLYPH_LINKAFTERLPGCP_RESULTSAGCP_RESULTSALPGCP_RESULTSWGCP_RESULTSWLPRASTERIZER_STATUSRASTERIZER_STATUSTT_AVAILABLETT_ENABLEDPPIXELFORMATDESCRIPTORPIXELFORMATDESCRIPTORLPPIXELFORMATDESCRIPTORPFD_TYPE_RGBAPFD_TYPE_COLORINDEXPFD_MAIN_PLANEPFD_OVERLAY_PLANEPFD_UNDERLAY_PLANEPFD_DOUBLEBUFFERPFD_STEREOPFD_DRAW_TO_WINDOWPFD_DRAW_TO_BITMAPPFD_SUPPORT_GDIPFD_SUPPORT_OPENGLPFD_GENERIC_FORMATPFD_NEED_PALETTEPFD_NEED_SYSTEM_PALETTEPFD_SWAP_EXCHANGEPFD_SWAP_COPYPFD_SWAP_LAYER_BUFFERSPFD_GENERIC_ACCELERATEDPFD_SUPPORT_DIRECTDRAWPFD_DIRECT3D_ACCELERATEDPFD_SUPPORT_COMPOSITIONPFD_DEPTH_DONTCAREPFD_DOUBLEBUFFER_DONTCAREPFD_STEREO_DONTCAREFONTENUMPROCAOLDFONTENUMPROCAFONTENUMPROCWOLDFONTENUMPROCWAddFontResourceAAddFontResourceWAnimatePaletteBitBltCancelDCChordChoosePixelFormatCloseMetaFileCombineRgnCopyMetaFileACopyMetaFileWCreateBitmapCreateBitmapIndirectCreateBrushIndirectCreateCompatibleBitmapCreateDiscardableBitmapCreateDCACreateDCWCreateDIBPatternBrushCreateDIBPatternBrushPtCreateEllipticRgnCreateEllipticRgnIndirectCreateFontIndirectACreateFontIndirectWCreateFontACreateFontWCreateHatchBrushCreateICACreateICWCreateMetaFileACreateMetaFileWCreatePaletteCreatePenCreatePenIndirectCreatePolyPolygonRgnCreatePatternBrushCreateRectRgnCreateRectRgnIndirectCreateRoundRectRgnCreateScalableFontResourceACreateScalableFontResourceWCreateSolidBrushDeleteMetaFileDescribePixelFormatDC_BINADJUSTDC_EMF_COMPLIANTDC_DATATYPE_PRODUCEDDC_COLLATEDC_MANUFACTURERDC_MODELDC_PERSONALITYDC_PRINTRATEDC_PRINTRATEUNITPRINTRATEUNIT_PPMPRINTRATEUNIT_CPSPRINTRATEUNIT_LPMPRINTRATEUNIT_IPMDC_PRINTERMEMDC_MEDIAREADYDC_STAPLEDC_PRINTRATEPPMDC_COLORDEVICEDC_NUPDC_MEDIATYPENAMESDC_MEDIATYPESDCTT_BITMAPDCTT_DOWNLOADDCTT_SUBDEVDCTT_DOWNLOAD_OUTLINEDCBA_FACEUPNONEDCBA_FACEUPCENTERDCBA_FACEUPLEFTDCBA_FACEUPRIGHTDCBA_FACEDOWNNONEDCBA_FACEDOWNCENTERDCBA_FACEDOWNLEFTDCBA_FACEDOWNRIGHTDeviceCapabilitiesADeviceCapabilitiesWDrawEscapeEllipseEnumFontFamiliesExAEnumFontFamiliesExWEnumFontFamiliesAEnumFontFamiliesWEnumFontsAEnumFontsWEnumObjectsGOBJENUMPROCEqualRgnExtEscapeExcludeClipRectExtCreateRegionExtFloodFillFillRgnFloodFillFrameRgnGetROP2GetAspectRatioFilterExGetBkColorGetDCBrushColorGetDCPenColorGetBkModeGetBitmapBitsGetBitmapDimensionExGetBoundsRectGetBrushOrgExGetCharWidthAGetCharWidthWGetCharWidth32AGetCharWidth32WGetCharWidthFloatAGetCharWidthFloatWGetCharABCWidthsAGetCharABCWidthsWGetCharABCWidthsFloatAGetCharABCWidthsFloatWGetClipBoxGetClipRgnGetMetaRgnGetCurrentObjectGetCurrentPositionExGetFontDataGetGlyphOutlineAGetGlyphOutlineWGetGraphicsModeGetMapModeGetMetaFileBitsExGetMetaFileAGetMetaFileWGetNearestColorGetNearestPaletteIndexGetObjectTypeGetOutlineTextMetricsAGetOutlineTextMetricsWGetPaletteEntriesGetPixelFormatGetPolyFillModeGetRasterizerCapsGetRandomRgnGetRegionDataGetRgnBoxGetStockObjectGetStretchBltModeGetSystemPaletteEntriesGetSystemPaletteUseGetTextCharacterExtraGetTextAlignGetTextColorGetTextExtentPointAGetTextExtentPointWGetTextExtentPoint32AGetTextExtentPoint32WGetTextExtentExPointAGetTextExtentExPointWGetTextCharsetGetTextCharsetInfoTranslateCharsetInfoGetFontLanguageInfoGetCharacterPlacementAGetCharacterPlacementWPWCRANGEWCRANGELPWCRANGEPGLYPHSETGLYPHSETLPGLYPHSETGS_8BIT_INDICESGGI_MARK_NONEXISTING_GLYPHSGetFontUnicodeRangesGetGlyphIndicesAGetGlyphIndicesWGetTextExtentPointIGetTextExtentExPointIGetCharWidthIGetCharABCWidthsISTAMP_DESIGNVECTORSTAMP_AXESLISTSTAMP_TRUETYPE_VARIATIONMM_MAX_NUMAXESPDESIGNVECTORDESIGNVECTORLPDESIGNVECTORAddFontResourceExAAddFontResourceExWRemoveFontResourceExARemoveFontResourceExWAddFontMemResourceExRemoveFontMemResourceExFR_PRIVATEFR_NOT_ENUMMM_MAX_AXES_NAMELENPAXISINFOAAXISINFOALPAXISINFOAPAXISINFOWAXISINFOWLPAXISINFOWPAXESLISTAAXESLISTALPAXESLISTAPAXESLISTWAXESLISTWLPAXESLISTWPENUMLOGFONTEXDVAENUMLOGFONTEXDVALPENUMLOGFONTEXDVAPENUMLOGFONTEXDVWENUMLOGFONTEXDVWLPENUMLOGFONTEXDVWCreateFontIndirectExACreateFontIndirectExWPENUMTEXTMETRICAENUMTEXTMETRICALPENUMTEXTMETRICAPENUMTEXTMETRICWENUMTEXTMETRICWLPENUMTEXTMETRICWGetViewportExtExGetViewportOrgExGetWindowExtExGetWindowOrgExIntersectClipRectInvertRgnLineDDALINEDDAPROCMaskBltPlgBltOffsetClipRgnOffsetRgnPatBltPiePlayMetaFilePaintRgnPolyPolygonPtInRegionPtVisibleRectInRegionRectVisibleRestoreDCResetDCAResetDCWRealizePaletteRemoveFontResourceARemoveFontResourceWRoundRectResizePaletteSaveDCSelectClipRgnExtSelectClipRgnSetMetaRgnSelectPaletteSetBkColorSetDCBrushColorSetDCPenColorSetBkModeSetBitmapBitsSetBoundsRectSetDIBitsSetDIBitsToDeviceSetMapperFlagsSetGraphicsModeSetMapModeSetLayoutGetLayoutSetMetaFileBitsExSetPaletteEntriesSetPixelVSetPixelFormatSetPolyFillModeStretchBltSetRectRgnStretchDIBitsSetROP2SetStretchBltModeSetSystemPaletteUseSetTextCharacterExtraSetTextColorSetTextAlignSetTextJustificationUpdateColorsCOLOR16PTRIVERTEXTRIVERTEXLPTRIVERTEXPGRADIENT_RECTGRADIENT_RECTLPGRADIENT_RECTPBLENDFUNCTIONAC_SRC_OVERAC_SRC_ALPHAAlphaBlendTransparentBltGRADIENT_FILL_RECT_HGRADIENT_FILL_RECT_VGRADIENT_FILL_TRIANGLEGRADIENT_FILL_OP_FLAGGradientFillGdiAlphaBlendGdiTransparentBltGdiGradientFillPlayMetaFileRecordEnumMetaFileMFENUMPROCCloseEnhMetaFileCopyEnhMetaFileACopyEnhMetaFileWCreateEnhMetaFileACreateEnhMetaFileWDeleteEnhMetaFileEnumEnhMetaFileENHMFENUMPROCGetEnhMetaFileAGetEnhMetaFileWGetEnhMetaFileBitsGetEnhMetaFileDescriptionAGetEnhMetaFileDescriptionWGetEnhMetaFileHeaderGetEnhMetaFilePaletteEntriesGetEnhMetaFilePixelFormatGetWinMetaFileBitsPlayEnhMetaFilePlayEnhMetaFileRecordSetEnhMetaFileBitsSetWinMetaFileBitsGdiCommentGetTextMetricsAGetTextMetricsWPDIBSECTIONDIBSECTIONLPDIBSECTIONAngleArcPolyPolylineGetWorldTransformSetWorldTransformModifyWorldTransformCombineTransformGDI_WIDTHBYTESGDI_DIBWIDTHBYTESGDI__DIBSIZEGDI_DIBSIZEGetDIBColorTableSetDIBColorTableCA_NEGATIVECA_LOG_FILTERILLUMINANT_DEVICE_DEFAULTILLUMINANT_AILLUMINANT_BILLUMINANT_CILLUMINANT_D50ILLUMINANT_D55ILLUMINANT_D65ILLUMINANT_D75ILLUMINANT_F2ILLUMINANT_MAX_INDEXILLUMINANT_TUNGSTENILLUMINANT_DAYLIGHTILLUMINANT_FLUORESCENTILLUMINANT_NTSCRGB_GAMMA_MINRGB_GAMMA_MAX// FIXME It is octal in the headers but are the headers actually right?REFERENCE_WHITE_MINREFERENCE_WHITE_MAXREFERENCE_BLACK_MINREFERENCE_BLACK_MAXCOLOR_ADJ_MINCOLOR_ADJ_MAXPCOLORADJUSTMENTCOLORADJUSTMENTLPCOLORADJUSTMENTSetColorAdjustmentGetColorAdjustmentCreateHalftonePaletteLPDOCINFOADOCINFOALPDOCINFOWDOCINFOWDI_APPBANDINGDI_ROPS_READ_DESTINATIONStartDocAStartDocWEndDocStartPageEndPageAbortDocSetAbortProcABORTPROCAbortPathArcToBeginPathCloseFigureEndPathFillPathFlattenPathGetPathPathToRegionPolyDrawSelectClipPathSetArcDirectionSetMiterLimitStrokeAndFillPathStrokePathWidenPathExtCreatePenGetMiterLimitGetArcDirectionGetObjectAGetObjectWMoveToExTextOutATextOutWExtTextOutAExtTextOutWPolyTextOutAPolyTextOutWCreatePolygonRgnDPtoLPLPtoDPPolygonPolylinePolyBezierPolyBezierToPolylineToSetViewportExtExSetViewportOrgExSetWindowExtExSetWindowOrgExOffsetViewportOrgExOffsetWindowOrgExScaleViewportExtExScaleWindowExtExSetBitmapDimensionExSetBrushOrgExGetTextFaceAGetTextFaceWLPKERNINGPAIRKERNINGPAIRGetKerningPairsAGetKerningPairsWGetDCOrgExFixBrushOrgExUnrealizeObjectGdiFlushGdiSetBatchLimitGdiGetBatchLimitICM_OFFICM_ONICM_QUERYICM_DONE_OUTSIDEDCSetICMModeCheckColorsInGamutGetColorSpaceGetLogColorSpaceAGetLogColorSpaceWCreateColorSpaceACreateColorSpaceWSetColorSpaceDeleteColorSpaceGetICMProfileAGetICMProfileWSetICMProfileASetICMProfileWGetDeviceGammaRampSetDeviceGammaRampColorMatchToTargetEnumICMProfilesAICMENUMPROCAEnumICMProfilesWICMENUMPROCWUpdateICMRegKeyAUpdateICMRegKeyWColorCorrectPaletteENHMETA_SIGNATUREENHMETA_STOCK_OBJECTEMR_HEADEREMR_POLYBEZIEREMR_POLYGONEMR_POLYLINEEMR_POLYBEZIERTOEMR_POLYLINETOEMR_POLYPOLYLINEEMR_POLYPOLYGONEMR_SETWINDOWEXTEXEMR_SETWINDOWORGEXEMR_SETVIEWPORTEXTEXEMR_SETVIEWPORTORGEXEMR_SETBRUSHORGEXEMR_EOFEMR_SETPIXELVEMR_SETMAPPERFLAGSEMR_SETMAPMODEEMR_SETBKMODEEMR_SETPOLYFILLMODEEMR_SETROP2EMR_SETSTRETCHBLTMODEEMR_SETTEXTALIGNEMR_SETCOLORADJUSTMENTEMR_SETTEXTCOLOREMR_SETBKCOLOREMR_OFFSETCLIPRGNEMR_MOVETOEXEMR_SETMETARGNEMR_EXCLUDECLIPRECTEMR_INTERSECTCLIPRECTEMR_SCALEVIEWPORTEXTEXEMR_SCALEWINDOWEXTEXEMR_SAVEDCEMR_RESTOREDCEMR_SETWORLDTRANSFORMEMR_MODIFYWORLDTRANSFORMEMR_SELECTOBJECTEMR_CREATEPENEMR_CREATEBRUSHINDIRECTEMR_DELETEOBJECTEMR_ANGLEARCEMR_ELLIPSEEMR_RECTANGLEEMR_ROUNDRECTEMR_ARCEMR_CHORDEMR_PIEEMR_SELECTPALETTEEMR_CREATEPALETTEEMR_SETPALETTEENTRIESEMR_RESIZEPALETTEEMR_REALIZEPALETTEEMR_EXTFLOODFILLEMR_LINETOEMR_ARCTOEMR_POLYDRAWEMR_SETARCDIRECTIONEMR_SETMITERLIMITEMR_BEGINPATHEMR_ENDPATHEMR_CLOSEFIGUREEMR_FILLPATHEMR_STROKEANDFILLPATHEMR_STROKEPATHEMR_FLATTENPATHEMR_WIDENPATHEMR_SELECTCLIPPATHEMR_ABORTPATHEMR_GDICOMMENTEMR_FILLRGNEMR_FRAMERGNEMR_INVERTRGNEMR_PAINTRGNEMR_EXTSELECTCLIPRGNEMR_BITBLTEMR_STRETCHBLTEMR_MASKBLTEMR_PLGBLTEMR_SETDIBITSTODEVICEEMR_STRETCHDIBITSEMR_EXTCREATEFONTINDIRECTWEMR_EXTTEXTOUTAEMR_EXTTEXTOUTWEMR_POLYBEZIER16EMR_POLYGON16EMR_POLYLINE16EMR_POLYBEZIERTO16EMR_POLYLINETO16EMR_POLYPOLYLINE16EMR_POLYPOLYGON16EMR_POLYDRAW16EMR_CREATEMONOBRUSHEMR_CREATEDIBPATTERNBRUSHPTEMR_EXTCREATEPENEMR_POLYTEXTOUTAEMR_POLYTEXTOUTWEMR_SETICMMODEEMR_CREATECOLORSPACEEMR_SETCOLORSPACEEMR_DELETECOLORSPACEEMR_GLSRECORDEMR_GLSBOUNDEDRECORDEMR_PIXELFORMATEMR_RESERVED_105EMR_RESERVED_106EMR_RESERVED_107EMR_RESERVED_108EMR_RESERVED_109EMR_RESERVED_110EMR_COLORCORRECTPALETTEEMR_SETICMPROFILEAEMR_SETICMPROFILEWEMR_ALPHABLENDEMR_SETLAYOUTEMR_TRANSPARENTBLTEMR_RESERVED_117EMR_GRADIENTFILLEMR_RESERVED_119EMR_RESERVED_120EMR_COLORMATCHTOTARGETWEMR_CREATECOLORSPACEWEMR_MINEMR_MAXPEMREMRPEMRTEXTEMRTEXTPEMRABORTPATHEMRABORTPATHEMRBEGINPATHPEMRBEGINPATHEMRENDPATHPEMRENDPATHEMRCLOSEFIGUREPEMRCLOSEFIGUREEMRFLATTENPATHPEMRFLATTENPATHEMRWIDENPATHPEMRWIDENPATHEMRSETMETARGNPEMRSETMETARGNEMRSAVEDCPEMRSAVEDCEMRREALIZEPALETTEPEMRREALIZEPALETTEPEMRSELECTCLIPPATHEMRSELECTCLIPPATHEMRSETBKMODEPEMRSETBKMODEEMRSETMAPMODEPEMRSETMAPMODEEMRSETLAYOUTPEMRSETLAYOUTEMRSETPOLYFILLMODEPEMRSETPOLYFILLMODEEMRSETROP2PEMRSETROP2EMRSETSTRETCHBLTMODEPEMRSETSTRETCHBLTMODEEMRSETICMMODEPEMRSETICMMODEEMRSETTEXTALIGNPEMRSETTEXTALIGNPEMRSETMITERLIMITEMRSETMITERLIMITPEMRRESTOREDCEMRRESTOREDCPEMRSETARCDIRECTIONEMRSETARCDIRECTIONPEMRSETMAPPERFLAGSEMRSETMAPPERFLAGSPEMRSETBKCOLOREMRSETBKCOLOREMRSETTEXTCOLORPEMRSETTEXTCOLORPEMRSELECTOBJECTEMRSELECTOBJECTEMRDELETEOBJECTPEMRDELETEOBJECTPEMRSELECTPALETTEEMRSELECTPALETTEPEMRRESIZEPALETTEEMRRESIZEPALETTEPEMRSETPALETTEENTRIESEMRSETPALETTEENTRIESPEMRSETCOLORADJUSTMENTEMRSETCOLORADJUSTMENTPEMRGDICOMMENTEMRGDICOMMENTPEMREOFEMREOFPEMRLINETOEMRLINETOEMRMOVETOEXPEMRMOVETOEXPEMROFFSETCLIPRGNEMROFFSETCLIPRGNPEMRFILLPATHEMRFILLPATHEMRSTROKEANDFILLPATHPEMRSTROKEANDFILLPATHEMRSTROKEPATHPEMRSTROKEPATHPEMREXCLUDECLIPRECTEMREXCLUDECLIPRECTEMRINTERSECTCLIPRECTPEMRINTERSECTCLIPRECTPEMRSETVIEWPORTORGEXEMRSETVIEWPORTORGEXEMRSETWINDOWORGEXPEMRSETWINDOWORGEXEMRSETBRUSHORGEXPEMRSETBRUSHORGEXPEMRSETVIEWPORTEXTEXEMRSETVIEWPORTEXTEXEMRSETWINDOWEXTEXPEMRSETWINDOWEXTEXPEMRSCALEVIEWPORTEXTEXEMRSCALEVIEWPORTEXTEXEMRSCALEWINDOWEXTEXPEMRSCALEWINDOWEXTEXPEMRSETWORLDTRANSFORMEMRSETWORLDTRANSFORMPEMRMODIFYWORLDTRANSFORMEMRMODIFYWORLDTRANSFORMPEMRSETPIXELVEMRSETPIXELVPEMREXTFLOODFILLEMREXTFLOODFILLPEMRELLIPSEEMRELLIPSEEMRRECTANGLEPEMRRECTANGLEPEMRROUNDRECTEMRROUNDRECTPEMRARCEMRARCEMRARCTOPEMRARCTOEMRCHORDPEMRCHORDEMRPIEPEMRPIEPEMRANGLEARCEMRANGLEARCPEMRPOLYLINEEMRPOLYLINEEMRPOLYBEZIERPEMRPOLYBEZIEREMRPOLYGONPEMRPOLYGONEMRPOLYBEZIERTOPEMRPOLYBEZIERTOEMRPOLYLINETOPEMRPOLYLINETOPEMRPOLYLINE16EMRPOLYLINE16EMRPOLYBEZIER16PEMRPOLYBEZIER16EMRPOLYGON16PEMRPOLYGON16EMRPOLYBEZIERTO16PEMRPOLYBEZIERTO16EMRPOLYLINETO16PEMRPOLYLINETO16PEMRPOLYDRAWEMRPOLYDRAWPEMRPOLYDRAW16EMRPOLYDRAW16PEMRPOLYPOLYLINEEMRPOLYPOLYLINEEMRPOLYPOLYGONPEMRPOLYPOLYGONPEMRPOLYPOLYLINE16EMRPOLYPOLYLINE16EMRPOLYPOLYGON16PEMRPOLYPOLYGON16PEMRINVERTRGNEMRINVERTRGNEMRPAINTRGNPEMRPAINTRGNPEMRFILLRGNEMRFILLRGNPEMRFRAMERGNEMRFRAMERGNPEMREXTSELECTCLIPRGNEMREXTSELECTCLIPRGNPEMREXTTEXTOUTAEMREXTTEXTOUTAEMREXTTEXTOUTWPEMREXTTEXTOUTWPEMRPOLYTEXTOUTAEMRPOLYTEXTOUTAEMRPOLYTEXTOUTWPEMRPOLYTEXTOUTWPEMRBITBLTEMRBITBLTPEMRSTRETCHBLTEMRSTRETCHBLTPEMRMASKBLTEMRMASKBLTPEMRPLGBLTEMRPLGBLTPEMRSETDIBITSTODEVICEEMRSETDIBITSTODEVICEPEMRSTRETCHDIBITSEMRSTRETCHDIBITSPEMREXTCREATEFONTINDIRECTWEMREXTCREATEFONTINDIRECTWPEMRCREATEPALETTEEMRCREATEPALETTEPEMRCREATEPENEMRCREATEPENPEMREXTCREATEPENEMREXTCREATEPENPEMRCREATEBRUSHINDIRECTEMRCREATEBRUSHINDIRECTPEMRCREATEMONOBRUSHEMRCREATEMONOBRUSHPEMRCREATEDIBPATTERNBRUSHPTEMRCREATEDIBPATTERNBRUSHPTPEMRFORMATEMRFORMATPEMRGLSRECORDEMRGLSRECORDPEMRGLSBOUNDEDRECORDEMRGLSBOUNDEDRECORDPEMRPIXELFORMATEMRPIXELFORMATPEMRCREATECOLORSPACEEMRCREATECOLORSPACEPEMRSETCOLORSPACEEMRSETCOLORSPACEEMRSELECTCOLORSPACEPEMRSELECTCOLORSPACEEMRDELETECOLORSPACEPEMRDELETECOLORSPACEPEMREXTESCAPEEMREXTESCAPEEMRDRAWESCAPEPEMRDRAWESCAPEPEMRNAMEDESCAPEEMRNAMEDESCAPESETICMPROFILE_EMBEDEDPEMRSETICMPROFILEEMRSETICMPROFILEEMRSETICMPROFILEAPEMRSETICMPROFILEAEMRSETICMPROFILEWPEMRSETICMPROFILEWCREATECOLORSPACE_EMBEDEDPEMRCREATECOLORSPACEWEMRCREATECOLORSPACEWCOLORMATCHTOTARGET_EMBEDEDPEMRCOLORMATCHTOTARGETEMRCOLORMATCHTOTARGETPEMRCOLORCORRECTPALETTEEMRCOLORCORRECTPALETTEPEMRALPHABLENDEMRALPHABLENDPEMRGRADIENTFILLEMRGRADIENTFILLPEMRTRANSPARENTBLTEMRTRANSPARENTBLTGDICOMMENT_IDENTIFIERGDICOMMENT_WINDOWS_METAFILEGDICOMMENT_BEGINGROUPGDICOMMENT_ENDGROUPGDICOMMENT_MULTIFORMATSEPS_SIGNATUREGDICOMMENT_UNICODE_STRINGGDICOMMENT_UNICODE_ENDwglCopyContextwglCreateContextwglCreateLayerContextwglDeleteContextwglGetCurrentContextwglGetCurrentDCwglGetProcAddresswglMakeCurrentwglShareListswglUseFontBitmapsAwglUseFontBitmapsWSwapBuffersPPOINTFLOATPOINTFLOATPGLYPHMETRICSFLOATGLYPHMETRICSFLOATLPGLYPHMETRICSFLOATWGL_FONT_LINESWGL_FONT_POLYGONSwglUseFontOutlinesAwglUseFontOutlinesWPLAYERPLANEDESCRIPTORLAYERPLANEDESCRIPTORLPLAYERPLANEDESCRIPTORLPD_DOUBLEBUFFERLPD_STEREOLPD_SUPPORT_GDILPD_SUPPORT_OPENGLLPD_SHARE_DEPTHLPD_SHARE_STENCILLPD_SHARE_ACCUMLPD_SWAP_EXCHANGELPD_SWAP_COPYLPD_TRANSPARENTLPD_TYPE_RGBALPD_TYPE_COLORINDEXWGL_SWAP_MAIN_PLANEWGL_SWAP_OVERLAY1WGL_SWAP_OVERLAY2WGL_SWAP_OVERLAY3WGL_SWAP_OVERLAY4WGL_SWAP_OVERLAY5WGL_SWAP_OVERLAY6WGL_SWAP_OVERLAY7WGL_SWAP_OVERLAY8WGL_SWAP_OVERLAY9WGL_SWAP_OVERLAY10WGL_SWAP_OVERLAY11WGL_SWAP_OVERLAY12WGL_SWAP_OVERLAY13WGL_SWAP_OVERLAY14WGL_SWAP_OVERLAY15WGL_SWAP_UNDERLAY1WGL_SWAP_UNDERLAY2WGL_SWAP_UNDERLAY3WGL_SWAP_UNDERLAY4WGL_SWAP_UNDERLAY5WGL_SWAP_UNDERLAY6WGL_SWAP_UNDERLAY7WGL_SWAP_UNDERLAY8WGL_SWAP_UNDERLAY9WGL_SWAP_UNDERLAY10WGL_SWAP_UNDERLAY11WGL_SWAP_UNDERLAY12WGL_SWAP_UNDERLAY13WGL_SWAP_UNDERLAY14WGL_SWAP_UNDERLAY15wglDescribeLayerPlanewglSetLayerPaletteEntrieswglGetLayerPaletteEntrieswglRealizeLayerPalettewglSwapLayerBuffersPWGLSWAPWGLSWAPLPWGLSWAPWGL_SWAPMULTIPLE_MAXwglSwapMultipleBuffers//! GDI procedure declarations, constant definitions and macrosHINTERNETLPHINTERNETINTERNET_PORTLPINTERNET_PORTINTERNET_DEFAULT_PORTINTERNET_DEFAULT_HTTP_PORTINTERNET_DEFAULT_HTTPS_PORTWINHTTP_FLAG_ASYNCWINHTTP_FLAG_SECUREWINHTTP_FLAG_ESCAPE_PERCENTWINHTTP_FLAG_NULL_CODEPAGEWINHTTP_FLAG_BYPASS_PROXY_CACHEWINHTTP_FLAG_REFRESHWINHTTP_FLAG_ESCAPE_DISABLEWINHTTP_FLAG_ESCAPE_DISABLE_QUERYLPWINHTTP_ASYNC_RESULTWINHTTP_ASYNC_RESULTINTERNET_SCHEMELPINTERNET_SCHEMEINTERNET_SCHEME_HTTPINTERNET_SCHEME_HTTPSINTERNET_SCHEME_FTPINTERNET_SCHEME_SOCKSLPURL_COMPONENTSURL_COMPONENTSURL_COMPONENTSWLPURL_COMPONENTSWLPWINHTTP_PROXY_INFOWINHTTP_PROXY_INFOWINHTTP_PROXY_INFOWLPWINHTTP_PROXY_INFOWWINHTTP_AUTOPROXY_AUTO_DETECTWINHTTP_AUTOPROXY_CONFIG_URLWINHTTP_AUTOPROXY_HOST_KEEPCASEWINHTTP_AUTOPROXY_HOST_LOWERCASEWINHTTP_AUTOPROXY_RUN_INPROCESSWINHTTP_AUTOPROXY_RUN_OUTPROCESS_ONLYWINHTTP_AUTOPROXY_NO_DIRECTACCESSWINHTTP_AUTOPROXY_NO_CACHE_CLIENTWINHTTP_AUTOPROXY_NO_CACHE_SVCWINHTTP_AUTOPROXY_SORT_RESULTSWINHTTP_AUTO_DETECT_TYPE_DHCPWINHTTP_AUTO_DETECT_TYPE_DNS_AWINHTTP_FIRST_OPTIONWINHTTP_OPTION_CALLBACKWINHTTP_OPTION_RESOLVE_TIMEOUTWINHTTP_OPTION_CONNECT_TIMEOUTWINHTTP_OPTION_CONNECT_RETRIESWINHTTP_OPTION_SEND_TIMEOUTWINHTTP_OPTION_RECEIVE_TIMEOUTWINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUTWINHTTP_OPTION_HANDLE_TYPEWINHTTP_OPTION_READ_BUFFER_SIZEWINHTTP_OPTION_WRITE_BUFFER_SIZEWINHTTP_OPTION_PARENT_HANDLEWINHTTP_OPTION_EXTENDED_ERRORWINHTTP_OPTION_SECURITY_FLAGSWINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCTWINHTTP_OPTION_URLWINHTTP_OPTION_SECURITY_KEY_BITNESSWINHTTP_OPTION_PROXYWINHTTP_OPTION_PROXY_RESULT_ENTRYWINHTTP_OPTION_USER_AGENTWINHTTP_OPTION_CONTEXT_VALUEWINHTTP_OPTION_CLIENT_CERT_CONTEXTWINHTTP_OPTION_REQUEST_PRIORITYWINHTTP_OPTION_HTTP_VERSIONWINHTTP_OPTION_DISABLE_FEATUREWINHTTP_OPTION_CODEPAGEWINHTTP_OPTION_MAX_CONNS_PER_SERVERWINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVERWINHTTP_OPTION_AUTOLOGON_POLICYWINHTTP_OPTION_SERVER_CERT_CONTEXTWINHTTP_OPTION_ENABLE_FEATUREWINHTTP_OPTION_WORKER_THREAD_COUNTWINHTTP_OPTION_PASSPORT_COBRANDING_TEXTWINHTTP_OPTION_PASSPORT_COBRANDING_URLWINHTTP_OPTION_CONFIGURE_PASSPORT_AUTHWINHTTP_OPTION_SECURE_PROTOCOLSWINHTTP_OPTION_ENABLETRACINGWINHTTP_OPTION_PASSPORT_SIGN_OUTWINHTTP_OPTION_PASSPORT_RETURN_URLWINHTTP_OPTION_REDIRECT_POLICYWINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTSWINHTTP_OPTION_MAX_HTTP_STATUS_CONTINUEWINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZEWINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZEWINHTTP_OPTION_CONNECTION_INFOWINHTTP_OPTION_CLIENT_CERT_ISSUER_LISTWINHTTP_OPTION_SPNWINHTTP_OPTION_GLOBAL_PROXY_CREDSWINHTTP_OPTION_GLOBAL_SERVER_CREDSWINHTTP_OPTION_UNLOAD_NOTIFY_EVENTWINHTTP_OPTION_REJECT_USERPWD_IN_URLWINHTTP_OPTION_USE_GLOBAL_SERVER_CREDENTIALSWINHTTP_OPTION_RECEIVE_PROXY_CONNECT_RESPONSEWINHTTP_OPTION_IS_PROXY_CONNECT_RESPONSEWINHTTP_OPTION_SERVER_SPN_USEDWINHTTP_OPTION_PROXY_SPN_USEDWINHTTP_OPTION_SERVER_CBTWINHTTP_OPTION_UNSAFE_HEADER_PARSINGWINHTTP_OPTION_ASSURED_NON_BLOCKING_CALLBACKSWINHTTP_OPTION_UPGRADE_TO_WEB_SOCKETWINHTTP_OPTION_WEB_SOCKET_CLOSE_TIMEOUTWINHTTP_OPTION_WEB_SOCKET_KEEPALIVE_INTERVALWINHTTP_OPTION_DECOMPRESSIONWINHTTP_OPTION_WEB_SOCKET_RECEIVE_BUFFER_SIZEWINHTTP_OPTION_WEB_SOCKET_SEND_BUFFER_SIZEWINHTTP_LAST_OPTIONWINHTTP_OPTION_USERNAMEWINHTTP_OPTION_PASSWORDWINHTTP_OPTION_PROXY_USERNAMEWINHTTP_OPTION_PROXY_PASSWORD//569LPWINHTTP_STATUS_CALLBACKWINHTTP_STATUS_CALLBACKWINHTTP_CALLBACK_STATUS_RESOLVING_NAMEWINHTTP_CALLBACK_STATUS_NAME_RESOLVEDWINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVERWINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVERWINHTTP_CALLBACK_STATUS_SENDING_REQUESTWINHTTP_CALLBACK_STATUS_REQUEST_SENTWINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSEWINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVEDWINHTTP_CALLBACK_STATUS_CLOSING_CONNECTIONWINHTTP_CALLBACK_STATUS_CONNECTION_CLOSEDWINHTTP_CALLBACK_STATUS_HANDLE_CREATEDWINHTTP_CALLBACK_STATUS_HANDLE_CLOSINGWINHTTP_CALLBACK_STATUS_DETECTING_PROXYWINHTTP_CALLBACK_STATUS_REDIRECTWINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSEWINHTTP_CALLBACK_STATUS_SECURE_FAILUREWINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLEWINHTTP_CALLBACK_STATUS_DATA_AVAILABLEWINHTTP_CALLBACK_STATUS_READ_COMPLETEWINHTTP_CALLBACK_STATUS_WRITE_COMPLETEWINHTTP_CALLBACK_STATUS_REQUEST_ERRORWINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETEWINHTTP_CALLBACK_STATUS_GETPROXYFORURL_COMPLETEWINHTTP_CALLBACK_STATUS_CLOSE_COMPLETEWINHTTP_CALLBACK_STATUS_SHUTDOWN_COMPLETEWINHTTP_CALLBACK_FLAG_RESOLVE_NAMEWINHTTP_CALLBACK_FLAG_CONNECT_TO_SERVERWINHTTP_CALLBACK_FLAG_SEND_REQUESTWINHTTP_CALLBACK_FLAG_RECEIVE_RESPONSEWINHTTP_CALLBACK_FLAG_CLOSE_CONNECTIONWINHTTP_CALLBACK_FLAG_HANDLESWINHTTP_CALLBACK_FLAG_DETECTING_PROXYWINHTTP_CALLBACK_FLAG_REDIRECTWINHTTP_CALLBACK_FLAG_INTERMEDIATE_RESPONSEWINHTTP_CALLBACK_FLAG_SECURE_FAILUREWINHTTP_CALLBACK_FLAG_SENDREQUEST_COMPLETEWINHTTP_CALLBACK_FLAG_HEADERS_AVAILABLEWINHTTP_CALLBACK_FLAG_DATA_AVAILABLEWINHTTP_CALLBACK_FLAG_READ_COMPLETEWINHTTP_CALLBACK_FLAG_WRITE_COMPLETEWINHTTP_CALLBACK_FLAG_REQUEST_ERRORWINHTTP_CALLBACK_FLAG_GETPROXYFORURL_COMPLETEWINHTTP_CALLBACK_FLAG_ALL_COMPLETIONSWINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONSWINHTTP_QUERY_MIME_VERSIONWINHTTP_QUERY_CONTENT_TYPEWINHTTP_QUERY_CONTENT_TRANSFER_ENCODINGWINHTTP_QUERY_CONTENT_IDWINHTTP_QUERY_CONTENT_DESCRIPTIONWINHTTP_QUERY_CONTENT_LENGTHWINHTTP_QUERY_CONTENT_LANGUAGEWINHTTP_QUERY_ALLOWWINHTTP_QUERY_PUBLICWINHTTP_QUERY_DATEWINHTTP_QUERY_EXPIRESWINHTTP_QUERY_LAST_MODIFIEDWINHTTP_QUERY_MESSAGE_IDWINHTTP_QUERY_URIWINHTTP_QUERY_DERIVED_FROMWINHTTP_QUERY_COSTWINHTTP_QUERY_LINKWINHTTP_QUERY_PRAGMAWINHTTP_QUERY_VERSIONWINHTTP_QUERY_STATUS_CODEWINHTTP_QUERY_STATUS_TEXTWINHTTP_QUERY_RAW_HEADERSWINHTTP_QUERY_RAW_HEADERS_CRLFWINHTTP_QUERY_CONNECTIONWINHTTP_QUERY_ACCEPTWINHTTP_QUERY_ACCEPT_CHARSETWINHTTP_QUERY_ACCEPT_ENCODINGWINHTTP_QUERY_ACCEPT_LANGUAGEWINHTTP_QUERY_AUTHORIZATIONWINHTTP_QUERY_CONTENT_ENCODINGWINHTTP_QUERY_FORWARDEDWINHTTP_QUERY_FROMWINHTTP_QUERY_IF_MODIFIED_SINCEWINHTTP_QUERY_LOCATIONWINHTTP_QUERY_ORIG_URIWINHTTP_QUERY_REFERERWINHTTP_QUERY_RETRY_AFTERWINHTTP_QUERY_SERVERWINHTTP_QUERY_TITLEWINHTTP_QUERY_USER_AGENTWINHTTP_QUERY_WWW_AUTHENTICATEWINHTTP_QUERY_PROXY_AUTHENTICATEWINHTTP_QUERY_ACCEPT_RANGESWINHTTP_QUERY_SET_COOKIEWINHTTP_QUERY_COOKIEWINHTTP_QUERY_REQUEST_METHODWINHTTP_QUERY_REFRESHWINHTTP_QUERY_CONTENT_DISPOSITIONWINHTTP_QUERY_AGEWINHTTP_QUERY_CACHE_CONTROLWINHTTP_QUERY_CONTENT_BASEWINHTTP_QUERY_CONTENT_LOCATIONWINHTTP_QUERY_CONTENT_MD5WINHTTP_QUERY_CONTENT_RANGEWINHTTP_QUERY_ETAGWINHTTP_QUERY_HOSTWINHTTP_QUERY_IF_MATCHWINHTTP_QUERY_IF_NONE_MATCHWINHTTP_QUERY_IF_RANGEWINHTTP_QUERY_IF_UNMODIFIED_SINCEWINHTTP_QUERY_MAX_FORWARDSWINHTTP_QUERY_PROXY_AUTHORIZATIONWINHTTP_QUERY_RANGEWINHTTP_QUERY_TRANSFER_ENCODINGWINHTTP_QUERY_UPGRADEWINHTTP_QUERY_VARYWINHTTP_QUERY_VIAWINHTTP_QUERY_WARNINGWINHTTP_QUERY_EXPECTWINHTTP_QUERY_PROXY_CONNECTIONWINHTTP_QUERY_UNLESS_MODIFIED_SINCEWINHTTP_QUERY_PROXY_SUPPORTWINHTTP_QUERY_AUTHENTICATION_INFOWINHTTP_QUERY_PASSPORT_URLSWINHTTP_QUERY_PASSPORT_CONFIGWINHTTP_QUERY_MAXWINHTTP_QUERY_CUSTOMWINHTTP_QUERY_FLAG_REQUEST_HEADERSWINHTTP_QUERY_FLAG_SYSTEMTIMEWINHTTP_QUERY_FLAG_NUMBERHTTP_STATUS_CONTINUEHTTP_STATUS_SWITCH_PROTOCOLSHTTP_STATUS_OKHTTP_STATUS_CREATEDHTTP_STATUS_ACCEPTEDHTTP_STATUS_PARTIALHTTP_STATUS_NO_CONTENTHTTP_STATUS_RESET_CONTENTHTTP_STATUS_PARTIAL_CONTENTHTTP_STATUS_WEBDAV_MULTI_STATUSHTTP_STATUS_AMBIGUOUSHTTP_STATUS_MOVEDHTTP_STATUS_REDIRECTHTTP_STATUS_REDIRECT_METHODHTTP_STATUS_NOT_MODIFIEDHTTP_STATUS_USE_PROXYHTTP_STATUS_REDIRECT_KEEP_VERBHTTP_STATUS_BAD_REQUESTHTTP_STATUS_DENIEDHTTP_STATUS_PAYMENT_REQHTTP_STATUS_FORBIDDENHTTP_STATUS_NOT_FOUNDHTTP_STATUS_BAD_METHODHTTP_STATUS_NONE_ACCEPTABLEHTTP_STATUS_PROXY_AUTH_REQHTTP_STATUS_REQUEST_TIMEOUTHTTP_STATUS_CONFLICTHTTP_STATUS_GONEHTTP_STATUS_LENGTH_REQUIREDHTTP_STATUS_PRECOND_FAILEDHTTP_STATUS_REQUEST_TOO_LARGEHTTP_STATUS_URI_TOO_LONGHTTP_STATUS_UNSUPPORTED_MEDIAHTTP_STATUS_RETRY_WITHHTTP_STATUS_SERVER_ERRORHTTP_STATUS_NOT_SUPPORTEDHTTP_STATUS_BAD_GATEWAYHTTP_STATUS_SERVICE_UNAVAILHTTP_STATUS_GATEWAY_TIMEOUTHTTP_STATUS_VERSION_NOT_SUPHTTP_STATUS_FIRSTHTTP_STATUS_LASTWINHTTP_ACCESS_TYPE_DEFAULT_PROXYWINHTTP_ACCESS_TYPE_NO_PROXYWINHTTP_ACCESS_TYPE_NAMED_PROXYWINHTTP_ACCESS_TYPE_AUTOMATIC_PROXYWINHTTP_ERROR_BASEERROR_WINHTTP_OUT_OF_HANDLESERROR_WINHTTP_TIMEOUTERROR_WINHTTP_INTERNAL_ERRORERROR_WINHTTP_INVALID_URLERROR_WINHTTP_UNRECOGNIZED_SCHEMEERROR_WINHTTP_NAME_NOT_RESOLVEDERROR_WINHTTP_INVALID_OPTIONERROR_WINHTTP_OPTION_NOT_SETTABLEERROR_WINHTTP_SHUTDOWNERROR_WINHTTP_LOGIN_FAILUREERROR_WINHTTP_OPERATION_CANCELLEDERROR_WINHTTP_INCORRECT_HANDLE_TYPEERROR_WINHTTP_INCORRECT_HANDLE_STATEERROR_WINHTTP_CANNOT_CONNECTERROR_WINHTTP_CONNECTION_ERRORERROR_WINHTTP_RESEND_REQUESTERROR_WINHTTP_CLIENT_AUTH_CERT_NEEDEDERROR_WINHTTP_CANNOT_CALL_BEFORE_OPENERROR_WINHTTP_CANNOT_CALL_BEFORE_SENDERROR_WINHTTP_CANNOT_CALL_AFTER_SENDERROR_WINHTTP_CANNOT_CALL_AFTER_OPENERROR_WINHTTP_HEADER_NOT_FOUNDERROR_WINHTTP_INVALID_SERVER_RESPONSEERROR_WINHTTP_INVALID_HEADERERROR_WINHTTP_INVALID_QUERY_REQUESTERROR_WINHTTP_HEADER_ALREADY_EXISTSERROR_WINHTTP_REDIRECT_FAILEDERROR_WINHTTP_AUTO_PROXY_SERVICE_ERRORERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPTERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPTERROR_WINHTTP_UNHANDLED_SCRIPT_TYPEERROR_WINHTTP_SCRIPT_EXECUTION_ERRORERROR_WINHTTP_NOT_INITIALIZEDERROR_WINHTTP_SECURE_FAILUREERROR_WINHTTP_SECURE_CERT_DATE_INVALIDERROR_WINHTTP_SECURE_CERT_CN_INVALIDERROR_WINHTTP_SECURE_INVALID_CAERROR_WINHTTP_SECURE_CERT_REV_FAILEDERROR_WINHTTP_SECURE_CHANNEL_ERRORERROR_WINHTTP_SECURE_INVALID_CERTERROR_WINHTTP_SECURE_CERT_REVOKEDERROR_WINHTTP_SECURE_CERT_WRONG_USAGEERROR_WINHTTP_AUTODETECTION_FAILEDERROR_WINHTTP_HEADER_COUNT_EXCEEDEDERROR_WINHTTP_HEADER_SIZE_OVERFLOWERROR_WINHTTP_CHUNKED_ENCODING_HEADER_SIZE_OVERFLOWERROR_WINHTTP_RESPONSE_DRAIN_OVERFLOWERROR_WINHTTP_CLIENT_CERT_NO_PRIVATE_KEYERROR_WINHTTP_CLIENT_CERT_NO_ACCESS_PRIVATE_KEYWINHTTP_ERROR_LASTWINHTTP_RESET_STATEWINHTTP_RESET_SWPAD_CURRENT_NETWORKWINHTTP_RESET_SWPAD_ALLWINHTTP_RESET_SCRIPT_CACHEWINHTTP_RESET_ALLWINHTTP_RESET_NOTIFY_NETWORK_CHANGEDWINHTTP_RESET_OUT_OF_PROCWinHttpSetStatusCallbackWinHttpTimeFromSystemTimeWinHttpTimeToSystemTimeWinHttpCrackUrlWinHttpCreateUrlWinHttpCheckPlatformWinHttpGetDefaultProxyConfigurationWinHttpSetDefaultProxyConfigurationWinHttpOpenWinHttpCloseHandleWinHttpConnectWinHttpReadDataWinHttpWriteDataWinHttpQueryDataAvailableWinHttpQueryOptionWinHttpSetOptionWinHttpSetTimeoutsWinHttpOpenRequestWinHttpAddRequestHeadersWinHttpSendRequestWinHttpSetCredentialsWinHttpQueryAuthSchemesWinHttpReceiveResponseWinHttpQueryHeadersWinHttpDetectAutoProxyConfigUrlWinHttpGetProxyForUrlWINHTTP_AUTOPROXY_OPTIONSWinHttpCreateProxyResolverWinHttpGetProxyForUrlExWinHttpGetProxyResultWINHTTP_PROXY_RESULTWinHttpFreeProxyResultWinHttpResetAutoProxyWinHttpGetIEProxyConfigForCurrentUserWINHTTP_CURRENT_USER_IE_PROXY_CONFIGWinHttpWebSocketCompleteUpgradeWinHttpWebSocketSendWINHTTP_WEB_SOCKET_BUFFER_TYPEWinHttpWebSocketReceiveWinHttpWebSocketShutdownWinHttpWebSocketCloseWinHttpWebSocketQueryCloseStatus//! Windows HTTP Services API constant definitions and macrosINTERNET_FLAG_BGUPDATEINTERNET_INVALID_PORT_NUMBERINTERNET_DEFAULT_FTP_PORTINTERNET_DEFAULT_GOPHER_PORTINTERNET_DEFAULT_SOCKS_PORTINTERNET_MAX_HOST_NAME_LENGTHINTERNET_MAX_USER_NAME_LENGTHINTERNET_MAX_PASSWORD_LENGTHINTERNET_MAX_PORT_NUMBER_LENGTHINTERNET_MAX_PORT_NUMBER_VALUEINTERNET_MAX_PATH_LENGTHINTERNET_MAX_SCHEME_LENGTHINTERNET_MAX_URL_LENGTHINTERNET_KEEP_ALIVE_UNKNOWNINTERNET_KEEP_ALIVE_ENABLEDINTERNET_KEEP_ALIVE_DISABLEDINTERNET_REQFLAG_FROM_CACHEINTERNET_REQFLAG_ASYNCINTERNET_REQFLAG_VIA_PROXYINTERNET_REQFLAG_NO_HEADERSINTERNET_REQFLAG_PASSIVEINTERNET_REQFLAG_CACHE_WRITE_DISABLEDINTERNET_REQFLAG_NET_TIMEOUTINTERNET_FLAG_IDN_DIRECTINTERNET_FLAG_IDN_PROXYINTERNET_FLAG_RELOADINTERNET_FLAG_RAW_DATAINTERNET_FLAG_EXISTING_CONNECTINTERNET_FLAG_ASYNCINTERNET_FLAG_PASSIVEINTERNET_FLAG_NO_CACHE_WRITEINTERNET_FLAG_DONT_CACHEINTERNET_FLAG_MAKE_PERSISTENTINTERNET_FLAG_FROM_CACHEINTERNET_FLAG_OFFLINEINTERNET_FLAG_SECUREINTERNET_FLAG_KEEP_CONNECTIONINTERNET_FLAG_NO_AUTO_REDIRECTINTERNET_FLAG_READ_PREFETCHINTERNET_FLAG_NO_COOKIESINTERNET_FLAG_NO_AUTHINTERNET_FLAG_RESTRICTED_ZONEINTERNET_FLAG_CACHE_IF_NET_FAILINTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPINTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPSINTERNET_FLAG_IGNORE_CERT_DATE_INVALIDINTERNET_FLAG_IGNORE_CERT_CN_INVALIDINTERNET_FLAG_RESYNCHRONIZEINTERNET_FLAG_HYPERLINKINTERNET_FLAG_NO_UIINTERNET_FLAG_PRAGMA_NOCACHEINTERNET_FLAG_CACHE_ASYNCINTERNET_FLAG_FORMS_SUBMITINTERNET_FLAG_FWD_BACKINTERNET_FLAG_NEED_FILEINTERNET_FLAG_MUST_CACHE_REQUESTINTERNET_FLAG_TRANSFER_ASCIIINTERNET_FLAG_TRANSFER_BINARYSECURITY_INTERNET_MASKSECURITY_IGNORE_ERROR_MASKINTERNET_FLAGS_MASKINTERNET_ERROR_MASK_INSERT_CDROMINTERNET_ERROR_MASK_COMBINED_SEC_CERTINTERNET_ERROR_MASK_NEED_MSN_SSPI_PKGINTERNET_ERROR_MASK_LOGIN_FAILURE_DISPLAY_ENTITY_BODYINTERNET_OPTIONS_MASKWININET_API_FLAG_ASYNCWININET_API_FLAG_SYNCWININET_API_FLAG_USE_CONTEXTINTERNET_NO_CALLBACKLPINTERNET_ASYNC_RESULTINTERNET_ASYNC_RESULTLPINTERNET_DIAGNOSTIC_SOCKET_INFOINTERNET_DIAGNOSTIC_SOCKET_INFOIDSI_FLAG_KEEP_ALIVEIDSI_FLAG_SECUREIDSI_FLAG_PROXYIDSI_FLAG_TUNNELLPINTERNET_PROXY_INFOINTERNET_PROXY_INFOLPINTERNET_PER_CONN_OPTIONAINTERNET_PER_CONN_OPTIONALPINTERNET_PER_CONN_OPTIONWINTERNET_PER_CONN_OPTIONWLPINTERNET_PER_CONN_OPTION_LISTAINTERNET_PER_CONN_OPTION_LISTALPINTERNET_PER_CONN_OPTION_LISTWINTERNET_PER_CONN_OPTION_LISTWINTERNET_PER_CONN_FLAGSINTERNET_PER_CONN_PROXY_SERVERINTERNET_PER_CONN_PROXY_BYPASSINTERNET_PER_CONN_AUTOCONFIG_URLINTERNET_PER_CONN_AUTODISCOVERY_FLAGSINTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URLINTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINSINTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIMEINTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URLINTERNET_PER_CONN_FLAGS_UIPROXY_TYPE_DIRECTPROXY_TYPE_PROXYPROXY_TYPE_AUTO_PROXY_URLPROXY_TYPE_AUTO_DETECTAUTO_PROXY_FLAG_USER_SETAUTO_PROXY_FLAG_ALWAYS_DETECTAUTO_PROXY_FLAG_DETECTION_RUNAUTO_PROXY_FLAG_MIGRATEDAUTO_PROXY_FLAG_DONT_CACHE_PROXY_RESULTAUTO_PROXY_FLAG_CACHE_INIT_RUNAUTO_PROXY_FLAG_DETECTION_SUSPECTLPINTERNET_VERSION_INFOINTERNET_VERSION_INFOLPHTTP_VERSION_INFOHTTP_VERSION_INFOLPINTERNET_CONNECTED_INFOINTERNET_CONNECTED_INFOISO_FORCE_DISCONNECTEDLPURL_COMPONENTSAURL_COMPONENTSALPINTERNET_CERTIFICATE_INFOINTERNET_CERTIFICATE_INFOLPINTERNET_BUFFERSAINTERNET_BUFFERSALPINTERNET_BUFFERSWINTERNET_BUFFERSWINTERNET_RFC1123_FORMATINTERNET_RFC1123_BUFSIZEICU_ESCAPEICU_USERNAMEICU_NO_ENCODEICU_DECODEICU_NO_METAICU_ENCODE_SPACES_ONLYICU_BROWSER_MODEICU_ENCODE_PERCENTINTERNET_OPEN_TYPE_PRECONFIGINTERNET_OPEN_TYPE_DIRECTINTERNET_OPEN_TYPE_PROXYINTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXYPRE_CONFIG_INTERNET_ACCESSLOCAL_INTERNET_ACCESSCERN_PROXY_INTERNET_ACCESSINTERNET_SERVICE_FTPINTERNET_SERVICE_GOPHERINTERNET_SERVICE_HTTPIRF_ASYNCIRF_SYNCIRF_USE_CONTEXTIRF_NO_WAITISO_GLOBALISO_REGISTRYISO_VALID_FLAGSINTERNET_OPTION_CALLBACKINTERNET_OPTION_CONNECT_TIMEOUTINTERNET_OPTION_CONNECT_RETRIESINTERNET_OPTION_CONNECT_BACKOFFINTERNET_OPTION_SEND_TIMEOUTINTERNET_OPTION_CONTROL_SEND_TIMEOUTINTERNET_OPTION_RECEIVE_TIMEOUTINTERNET_OPTION_CONTROL_RECEIVE_TIMEOUTINTERNET_OPTION_DATA_SEND_TIMEOUTINTERNET_OPTION_DATA_RECEIVE_TIMEOUTINTERNET_OPTION_HANDLE_TYPEINTERNET_OPTION_LISTEN_TIMEOUTINTERNET_OPTION_READ_BUFFER_SIZEINTERNET_OPTION_WRITE_BUFFER_SIZEINTERNET_OPTION_ASYNC_IDINTERNET_OPTION_ASYNC_PRIORITYINTERNET_OPTION_PARENT_HANDLEINTERNET_OPTION_KEEP_CONNECTIONINTERNET_OPTION_REQUEST_FLAGSINTERNET_OPTION_EXTENDED_ERRORINTERNET_OPTION_OFFLINE_MODEINTERNET_OPTION_CACHE_STREAM_HANDLEINTERNET_OPTION_USERNAMEINTERNET_OPTION_PASSWORDINTERNET_OPTION_ASYNCINTERNET_OPTION_SECURITY_FLAGSINTERNET_OPTION_SECURITY_CERTIFICATE_STRUCTINTERNET_OPTION_DATAFILE_NAMEINTERNET_OPTION_URLINTERNET_OPTION_SECURITY_CERTIFICATEINTERNET_OPTION_SECURITY_KEY_BITNESSINTERNET_OPTION_REFRESHINTERNET_OPTION_PROXYINTERNET_OPTION_SETTINGS_CHANGEDINTERNET_OPTION_VERSIONINTERNET_OPTION_USER_AGENTINTERNET_OPTION_END_BROWSER_SESSIONINTERNET_OPTION_PROXY_USERNAMEINTERNET_OPTION_PROXY_PASSWORDINTERNET_OPTION_CONTEXT_VALUEINTERNET_OPTION_CONNECT_LIMITINTERNET_OPTION_SECURITY_SELECT_CLIENT_CERTINTERNET_OPTION_POLICYINTERNET_OPTION_DISCONNECTED_TIMEOUTINTERNET_OPTION_CONNECTED_STATEINTERNET_OPTION_IDLE_STATEINTERNET_OPTION_OFFLINE_SEMANTICSINTERNET_OPTION_SECONDARY_CACHE_KEYINTERNET_OPTION_CALLBACK_FILTERINTERNET_OPTION_CONNECT_TIMEINTERNET_OPTION_SEND_THROUGHPUTINTERNET_OPTION_RECEIVE_THROUGHPUTINTERNET_OPTION_REQUEST_PRIORITYINTERNET_OPTION_HTTP_VERSIONINTERNET_OPTION_RESET_URLCACHE_SESSIONINTERNET_OPTION_ERROR_MASKINTERNET_OPTION_FROM_CACHE_TIMEOUTINTERNET_OPTION_BYPASS_EDITED_ENTRYINTERNET_OPTION_HTTP_DECODINGINTERNET_OPTION_DIAGNOSTIC_SOCKET_INFOINTERNET_OPTION_CODEPAGEINTERNET_OPTION_CACHE_TIMESTAMPSINTERNET_OPTION_DISABLE_AUTODIALINTERNET_OPTION_MAX_CONNS_PER_SERVERINTERNET_OPTION_MAX_CONNS_PER_1_0_SERVERINTERNET_OPTION_PER_CONNECTION_OPTIONINTERNET_OPTION_DIGEST_AUTH_UNLOADINTERNET_OPTION_IGNORE_OFFLINEINTERNET_OPTION_IDENTITYINTERNET_OPTION_REMOVE_IDENTITYINTERNET_OPTION_ALTER_IDENTITYINTERNET_OPTION_SUPPRESS_BEHAVIORINTERNET_OPTION_AUTODIAL_MODEINTERNET_OPTION_AUTODIAL_CONNECTIONINTERNET_OPTION_CLIENT_CERT_CONTEXTINTERNET_OPTION_AUTH_FLAGSINTERNET_OPTION_COOKIES_3RD_PARTYINTERNET_OPTION_DISABLE_PASSPORT_AUTHINTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXYINTERNET_OPTION_EXEMPT_CONNECTION_LIMITINTERNET_OPTION_ENABLE_PASSPORT_AUTHINTERNET_OPTION_HIBERNATE_INACTIVE_WORKER_THREADSINTERNET_OPTION_ACTIVATE_WORKER_THREADSINTERNET_OPTION_RESTORE_WORKER_THREAD_DEFAULTSINTERNET_OPTION_SOCKET_SEND_BUFFER_LENGTHINTERNET_OPTION_PROXY_SETTINGS_CHANGEDINTERNET_OPTION_DATAFILE_EXTINTERNET_OPTION_CODEPAGE_PATHINTERNET_OPTION_CODEPAGE_EXTRAINTERNET_OPTION_IDNINTERNET_OPTION_MAX_CONNS_PER_PROXYINTERNET_OPTION_SUPPRESS_SERVER_AUTHINTERNET_OPTION_SERVER_CERT_CHAIN_CONTEXTINTERNET_OPTION_ENABLE_REDIRECT_CACHE_READINTERNET_OPTION_ENCODE_EXTRAINTERNET_FIRST_OPTIONINTERNET_LAST_OPTIONINTERNET_PRIORITY_FOREGROUNDINTERNET_HANDLE_TYPE_INTERNETINTERNET_HANDLE_TYPE_CONNECT_FTPINTERNET_HANDLE_TYPE_CONNECT_GOPHERINTERNET_HANDLE_TYPE_CONNECT_HTTPINTERNET_HANDLE_TYPE_FTP_FINDINTERNET_HANDLE_TYPE_FTP_FIND_HTMLINTERNET_HANDLE_TYPE_FTP_FILEINTERNET_HANDLE_TYPE_FTP_FILE_HTMLINTERNET_HANDLE_TYPE_GOPHER_FINDINTERNET_HANDLE_TYPE_GOPHER_FIND_HTMLINTERNET_HANDLE_TYPE_GOPHER_FILEINTERNET_HANDLE_TYPE_GOPHER_FILE_HTMLINTERNET_HANDLE_TYPE_HTTP_REQUESTINTERNET_HANDLE_TYPE_FILE_REQUESTAUTH_FLAG_DISABLE_NEGOTIATEAUTH_FLAG_ENABLE_NEGOTIATEAUTH_FLAG_DISABLE_BASIC_CLEARCHANNELAUTH_FLAG_DISABLE_SERVER_AUTHSECURITY_FLAG_SECURESECURITY_FLAG_STRENGTH_WEAKSECURITY_FLAG_STRENGTH_MEDIUMSECURITY_FLAG_STRENGTH_STRONGSECURITY_FLAG_UNKNOWNBITSECURITY_FLAG_FORTEZZASECURITY_FLAG_NORMALBITNESSSECURITY_FLAG_SSLSECURITY_FLAG_SSL3SECURITY_FLAG_PCTSECURITY_FLAG_PCT4SECURITY_FLAG_IETFSSL4SECURITY_FLAG_40BITSECURITY_FLAG_128BITSECURITY_FLAG_56BITSECURITY_FLAG_IGNORE_REVOCATIONSECURITY_FLAG_IGNORE_UNKNOWN_CASECURITY_FLAG_IGNORE_WRONG_USAGESECURITY_FLAG_IGNORE_CERT_CN_INVALIDSECURITY_FLAG_IGNORE_CERT_DATE_INVALIDSECURITY_FLAG_IGNORE_REDIRECT_TO_HTTPSSECURITY_FLAG_IGNORE_REDIRECT_TO_HTTPSECURITY_SET_MASKAUTODIAL_MODE_NEVERAUTODIAL_MODE_ALWAYSAUTODIAL_MODE_NO_NETWORK_PRESENTLPINTERNET_STATUS_CALLBACKINTERNET_STATUS_CALLBACKINTERNET_STATUS_RESOLVING_NAMEINTERNET_STATUS_NAME_RESOLVEDINTERNET_STATUS_CONNECTING_TO_SERVERINTERNET_STATUS_CONNECTED_TO_SERVERINTERNET_STATUS_SENDING_REQUESTINTERNET_STATUS_REQUEST_SENTINTERNET_STATUS_RECEIVING_RESPONSEINTERNET_STATUS_RESPONSE_RECEIVEDINTERNET_STATUS_CTL_RESPONSE_RECEIVEDINTERNET_STATUS_PREFETCHINTERNET_STATUS_CLOSING_CONNECTIONINTERNET_STATUS_CONNECTION_CLOSEDINTERNET_STATUS_HANDLE_CREATEDINTERNET_STATUS_HANDLE_CLOSINGINTERNET_STATUS_DETECTING_PROXYINTERNET_STATUS_REQUEST_COMPLETEINTERNET_STATUS_REDIRECTINTERNET_STATUS_INTERMEDIATE_RESPONSEINTERNET_STATUS_USER_INPUT_REQUIREDINTERNET_STATUS_STATE_CHANGEINTERNET_STATUS_COOKIE_SENTINTERNET_STATUS_COOKIE_RECEIVEDINTERNET_STATUS_PRIVACY_IMPACTEDINTERNET_STATUS_P3P_HEADERINTERNET_STATUS_P3P_POLICYREFINTERNET_STATUS_COOKIE_HISTORYINTERNET_STATE_CONNECTEDINTERNET_STATE_DISCONNECTEDINTERNET_STATE_DISCONNECTED_BY_USERINTERNET_STATE_IDLEINTERNET_STATE_BUSYINTERNET_INVALID_STATUS_CALLBACKFTP_TRANSFER_TYPE_UNKNOWNFTP_TRANSFER_TYPE_ASCIIFTP_TRANSFER_TYPE_BINARYFTP_TRANSFER_TYPE_MASKMAX_GOPHER_DISPLAY_TEXTMAX_GOPHER_SELECTOR_TEXTMAX_GOPHER_HOST_NAMEMAX_GOPHER_LOCATOR_LENGTHLPGOPHER_FIND_DATAAGOPHER_FIND_DATAALPGOPHER_FIND_DATAWGOPHER_FIND_DATAWGOPHER_TYPE_TEXT_FILEGOPHER_TYPE_DIRECTORYGOPHER_TYPE_CSOGOPHER_TYPE_ERRORGOPHER_TYPE_MAC_BINHEXGOPHER_TYPE_DOS_ARCHIVEGOPHER_TYPE_UNIX_UUENCODEDGOPHER_TYPE_INDEX_SERVERGOPHER_TYPE_TELNETGOPHER_TYPE_BINARYGOPHER_TYPE_REDUNDANTGOPHER_TYPE_TN3270GOPHER_TYPE_GIFGOPHER_TYPE_IMAGEGOPHER_TYPE_BITMAPGOPHER_TYPE_MOVIEGOPHER_TYPE_SOUNDGOPHER_TYPE_HTMLGOPHER_TYPE_PDFGOPHER_TYPE_CALENDARGOPHER_TYPE_INLINEGOPHER_TYPE_UNKNOWNGOPHER_TYPE_ASKGOPHER_TYPE_GOPHER_PLUSIS_GOPHER_FILEIS_GOPHER_DIRECTORYIS_GOPHER_PHONE_SERVERIS_GOPHER_ERRORIS_GOPHER_INDEX_SERVERIS_GOPHER_TELNET_SESSIONIS_GOPHER_BACKUP_SERVERIS_GOPHER_TN3270_SESSIONIS_GOPHER_ASKIS_GOPHER_PLUSIS_GOPHER_TYPE_KNOWNGOPHER_TYPE_FILE_MASKLPGOPHER_ADMIN_ATTRIBUTE_TYPEGOPHER_ADMIN_ATTRIBUTE_TYPELPGOPHER_MOD_DATE_ATTRIBUTE_TYPEGOPHER_MOD_DATE_ATTRIBUTE_TYPELPGOPHER_TTL_ATTRIBUTE_TYPEGOPHER_TTL_ATTRIBUTE_TYPELPGOPHER_SCORE_ATTRIBUTE_TYPEGOPHER_SCORE_ATTRIBUTE_TYPELPGOPHER_SCORE_RANGE_ATTRIBUTE_TYPEGOPHER_SCORE_RANGE_ATTRIBUTE_TYPELPGOPHER_SITE_ATTRIBUTE_TYPEGOPHER_SITE_ATTRIBUTE_TYPELPGOPHER_ORGANIZATION_ATTRIBUTE_TYPEGOPHER_ORGANIZATION_ATTRIBUTE_TYPELPGOPHER_LOCATION_ATTRIBUTE_TYPEGOPHER_LOCATION_ATTRIBUTE_TYPELPGOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPEGOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPELPGOPHER_TIMEZONE_ATTRIBUTE_TYPEGOPHER_TIMEZONE_ATTRIBUTE_TYPELPGOPHER_PROVIDER_ATTRIBUTE_TYPEGOPHER_PROVIDER_ATTRIBUTE_TYPELPGOPHER_VERSION_ATTRIBUTE_TYPEGOPHER_VERSION_ATTRIBUTE_TYPELPGOPHER_ABSTRACT_ATTRIBUTE_TYPEGOPHER_ABSTRACT_ATTRIBUTE_TYPELPGOPHER_VIEW_ATTRIBUTE_TYPEGOPHER_VIEW_ATTRIBUTE_TYPELPGOPHER_VERONICA_ATTRIBUTE_TYPEGOPHER_VERONICA_ATTRIBUTE_TYPELPGOPHER_ASK_ATTRIBUTE_TYPEGOPHER_ASK_ATTRIBUTE_TYPELPGOPHER_UNKNOWN_ATTRIBUTE_TYPEGOPHER_UNKNOWN_ATTRIBUTE_TYPELPGOPHER_ATTRIBUTE_TYPEGOPHER_ATTRIBUTE_TYPEMAX_GOPHER_CATEGORY_NAMEMAX_GOPHER_ATTRIBUTE_NAMEMIN_GOPHER_ATTRIBUTE_LENGTHGOPHER_INFO_CATEGORYGOPHER_ADMIN_CATEGORYGOPHER_VIEWS_CATEGORYGOPHER_ABSTRACT_CATEGORYGOPHER_VERONICA_CATEGORYGOPHER_ADMIN_ATTRIBUTEGOPHER_MOD_DATE_ATTRIBUTEGOPHER_TTL_ATTRIBUTEGOPHER_SCORE_ATTRIBUTEGOPHER_RANGE_ATTRIBUTEGOPHER_SITE_ATTRIBUTEGOPHER_ORG_ATTRIBUTEGOPHER_LOCATION_ATTRIBUTEGOPHER_GEOG_ATTRIBUTEGOPHER_TIMEZONE_ATTRIBUTEGOPHER_PROVIDER_ATTRIBUTEGOPHER_VERSION_ATTRIBUTEGOPHER_ABSTRACT_ATTRIBUTEGOPHER_VIEW_ATTRIBUTEGOPHER_TREEWALK_ATTRIBUTEGOPHER_ATTRIBUTE_ID_BASEGOPHER_CATEGORY_ID_ALLGOPHER_CATEGORY_ID_INFOGOPHER_CATEGORY_ID_ADMINGOPHER_CATEGORY_ID_VIEWSGOPHER_CATEGORY_ID_ABSTRACTGOPHER_CATEGORY_ID_VERONICAGOPHER_CATEGORY_ID_ASKGOPHER_CATEGORY_ID_UNKNOWNGOPHER_ATTRIBUTE_ID_ALLGOPHER_ATTRIBUTE_ID_ADMINGOPHER_ATTRIBUTE_ID_MOD_DATEGOPHER_ATTRIBUTE_ID_TTLGOPHER_ATTRIBUTE_ID_SCOREGOPHER_ATTRIBUTE_ID_RANGEGOPHER_ATTRIBUTE_ID_SITEGOPHER_ATTRIBUTE_ID_ORGGOPHER_ATTRIBUTE_ID_LOCATIONGOPHER_ATTRIBUTE_ID_GEOGGOPHER_ATTRIBUTE_ID_TIMEZONEGOPHER_ATTRIBUTE_ID_PROVIDERGOPHER_ATTRIBUTE_ID_VERSIONGOPHER_ATTRIBUTE_ID_ABSTRACTGOPHER_ATTRIBUTE_ID_VIEWGOPHER_ATTRIBUTE_ID_TREEWALKGOPHER_ATTRIBUTE_ID_UNKNOWNHTTP_MAJOR_VERSIONHTTP_MINOR_VERSIONHTTP_QUERY_MIME_VERSIONHTTP_QUERY_CONTENT_TYPEHTTP_QUERY_CONTENT_TRANSFER_ENCODINGHTTP_QUERY_CONTENT_IDHTTP_QUERY_CONTENT_DESCRIPTIONHTTP_QUERY_CONTENT_LENGTHHTTP_QUERY_CONTENT_LANGUAGEHTTP_QUERY_ALLOWHTTP_QUERY_PUBLICHTTP_QUERY_DATEHTTP_QUERY_EXPIRESHTTP_QUERY_LAST_MODIFIEDHTTP_QUERY_MESSAGE_IDHTTP_QUERY_URIHTTP_QUERY_DERIVED_FROMHTTP_QUERY_COSTHTTP_QUERY_LINKHTTP_QUERY_PRAGMAHTTP_QUERY_VERSIONHTTP_QUERY_STATUS_CODEHTTP_QUERY_STATUS_TEXTHTTP_QUERY_RAW_HEADERSHTTP_QUERY_RAW_HEADERS_CRLFHTTP_QUERY_CONNECTIONHTTP_QUERY_ACCEPTHTTP_QUERY_ACCEPT_CHARSETHTTP_QUERY_ACCEPT_ENCODINGHTTP_QUERY_ACCEPT_LANGUAGEHTTP_QUERY_AUTHORIZATIONHTTP_QUERY_CONTENT_ENCODINGHTTP_QUERY_FORWARDEDHTTP_QUERY_FROMHTTP_QUERY_IF_MODIFIED_SINCEHTTP_QUERY_LOCATIONHTTP_QUERY_ORIG_URIHTTP_QUERY_REFERERHTTP_QUERY_RETRY_AFTERHTTP_QUERY_SERVERHTTP_QUERY_TITLEHTTP_QUERY_USER_AGENTHTTP_QUERY_WWW_AUTHENTICATEHTTP_QUERY_PROXY_AUTHENTICATEHTTP_QUERY_ACCEPT_RANGESHTTP_QUERY_SET_COOKIEHTTP_QUERY_COOKIEHTTP_QUERY_REQUEST_METHODHTTP_QUERY_REFRESHHTTP_QUERY_CONTENT_DISPOSITIONHTTP_QUERY_AGEHTTP_QUERY_CACHE_CONTROLHTTP_QUERY_CONTENT_BASEHTTP_QUERY_CONTENT_LOCATIONHTTP_QUERY_CONTENT_MD5HTTP_QUERY_CONTENT_RANGEHTTP_QUERY_ETAGHTTP_QUERY_HOSTHTTP_QUERY_IF_MATCHHTTP_QUERY_IF_NONE_MATCHHTTP_QUERY_IF_RANGEHTTP_QUERY_IF_UNMODIFIED_SINCEHTTP_QUERY_MAX_FORWARDSHTTP_QUERY_PROXY_AUTHORIZATIONHTTP_QUERY_RANGEHTTP_QUERY_TRANSFER_ENCODINGHTTP_QUERY_UPGRADEHTTP_QUERY_VARYHTTP_QUERY_VIAHTTP_QUERY_WARNINGHTTP_QUERY_EXPECTHTTP_QUERY_PROXY_CONNECTIONHTTP_QUERY_UNLESS_MODIFIED_SINCEHTTP_QUERY_ECHO_REQUESTHTTP_QUERY_ECHO_REPLYHTTP_QUERY_ECHO_HEADERSHTTP_QUERY_ECHO_HEADERS_CRLFHTTP_QUERY_PROXY_SUPPORTHTTP_QUERY_AUTHENTICATION_INFOHTTP_QUERY_PASSPORT_URLSHTTP_QUERY_PASSPORT_CONFIGHTTP_QUERY_X_CONTENT_TYPE_OPTIONSHTTP_QUERY_P3PHTTP_QUERY_X_P2P_PEERDISTHTTP_QUERY_TRANSLATEHTTP_QUERY_X_UA_COMPATIBLEHTTP_QUERY_DEFAULT_STYLEHTTP_QUERY_X_FRAME_OPTIONSHTTP_QUERY_X_XSS_PROTECTIONHTTP_QUERY_SET_COOKIE2HTTP_QUERY_DO_NOT_TRACKHTTP_QUERY_KEEP_ALIVEHTTP_QUERY_MAXHTTP_QUERY_CUSTOMHTTP_QUERY_FLAG_REQUEST_HEADERSHTTP_QUERY_FLAG_SYSTEMTIMEHTTP_QUERY_FLAG_NUMBERHTTP_QUERY_FLAG_COALESCEHTTP_QUERY_FLAG_NUMBER64HTTP_QUERY_MODIFIER_FLAGS_MASKHTTP_QUERY_HEADER_MASKHTTP_ADDREQ_INDEX_MASKHTTP_ADDREQ_FLAGS_MASKHTTP_ADDREQ_FLAG_ADD_IF_NEWHTTP_ADDREQ_FLAG_ADDHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMAHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLONHTTP_ADDREQ_FLAG_COALESCEHTTP_ADDREQ_FLAG_REPLACEHSR_ASYNCHSR_SYNCHSR_USE_CONTEXTHSR_INITIATEHSR_DOWNLOADHSR_CHUNKEDINTERNET_COOKIE_IS_SECUREINTERNET_COOKIE_IS_SESSIONINTERNET_COOKIE_THIRD_PARTYINTERNET_COOKIE_PROMPT_REQUIREDINTERNET_COOKIE_EVALUATE_P3PINTERNET_COOKIE_APPLY_P3PINTERNET_COOKIE_P3P_ENABLEDINTERNET_COOKIE_IS_RESTRICTEDINTERNET_COOKIE_IE6INTERNET_COOKIE_IS_LEGACYINTERNET_COOKIE_NON_SCRIPTINTERNET_COOKIE_HTTPONLYFLAG_ICC_FORCE_CONNECTIONFLAGS_ERROR_UI_FILTER_FOR_ERRORSFLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONSFLAGS_ERROR_UI_FLAGS_GENERATE_DATAFLAGS_ERROR_UI_FLAGS_NO_UIFLAGS_ERROR_UI_SERIALIZE_DIALOGSINTERNET_ERROR_BASEERROR_INTERNET_OUT_OF_HANDLESERROR_INTERNET_TIMEOUTERROR_INTERNET_EXTENDED_ERRORERROR_INTERNET_INTERNAL_ERRORERROR_INTERNET_INVALID_URLERROR_INTERNET_UNRECOGNIZED_SCHEMEERROR_INTERNET_NAME_NOT_RESOLVEDERROR_INTERNET_PROTOCOL_NOT_FOUNDERROR_INTERNET_INVALID_OPTIONERROR_INTERNET_BAD_OPTION_LENGTHERROR_INTERNET_OPTION_NOT_SETTABLEERROR_INTERNET_SHUTDOWNERROR_INTERNET_INCORRECT_USER_NAMEERROR_INTERNET_INCORRECT_PASSWORDERROR_INTERNET_LOGIN_FAILUREERROR_INTERNET_INVALID_OPERATIONERROR_INTERNET_OPERATION_CANCELLEDERROR_INTERNET_INCORRECT_HANDLE_TYPEERROR_INTERNET_INCORRECT_HANDLE_STATEERROR_INTERNET_NOT_PROXY_REQUESTERROR_INTERNET_REGISTRY_VALUE_NOT_FOUNDERROR_INTERNET_BAD_REGISTRY_PARAMETERERROR_INTERNET_NO_DIRECT_ACCESSERROR_INTERNET_NO_CONTEXTERROR_INTERNET_NO_CALLBACKERROR_INTERNET_REQUEST_PENDINGERROR_INTERNET_INCORRECT_FORMATERROR_INTERNET_ITEM_NOT_FOUNDERROR_INTERNET_CANNOT_CONNECTERROR_INTERNET_CONNECTION_ABORTEDERROR_INTERNET_CONNECTION_RESETERROR_INTERNET_FORCE_RETRYERROR_INTERNET_INVALID_PROXY_REQUESTERROR_INTERNET_NEED_UIERROR_INTERNET_HANDLE_EXISTSERROR_INTERNET_SEC_CERT_DATE_INVALIDERROR_INTERNET_SEC_CERT_CN_INVALIDERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIRERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIRERROR_INTERNET_MIXED_SECURITYERROR_INTERNET_CHG_POST_IS_NON_SECUREERROR_INTERNET_POST_IS_NON_SECUREERROR_INTERNET_CLIENT_AUTH_CERT_NEEDEDERROR_INTERNET_INVALID_CAERROR_INTERNET_CLIENT_AUTH_NOT_SETUPERROR_INTERNET_ASYNC_THREAD_FAILEDERROR_INTERNET_REDIRECT_SCHEME_CHANGEERROR_INTERNET_DIALOG_PENDINGERROR_INTERNET_RETRY_DIALOGERROR_INTERNET_HTTPS_HTTP_SUBMIT_REDIRERROR_INTERNET_INSERT_CDROMERROR_INTERNET_FORTEZZA_LOGIN_NEEDEDERROR_INTERNET_SEC_CERT_ERRORSERROR_INTERNET_SEC_CERT_NO_REVERROR_INTERNET_SEC_CERT_REV_FAILEDERROR_FTP_TRANSFER_IN_PROGRESSERROR_FTP_DROPPEDERROR_FTP_NO_PASSIVE_MODEERROR_GOPHER_PROTOCOL_ERRORERROR_GOPHER_NOT_FILEERROR_GOPHER_DATA_ERRORERROR_GOPHER_END_OF_DATAERROR_GOPHER_INVALID_LOCATORERROR_GOPHER_INCORRECT_LOCATOR_TYPEERROR_GOPHER_NOT_GOPHER_PLUSERROR_GOPHER_ATTRIBUTE_NOT_FOUNDERROR_GOPHER_UNKNOWN_LOCATORERROR_HTTP_HEADER_NOT_FOUNDERROR_HTTP_DOWNLEVEL_SERVERERROR_HTTP_INVALID_SERVER_RESPONSEERROR_HTTP_INVALID_HEADERERROR_HTTP_INVALID_QUERY_REQUESTERROR_HTTP_HEADER_ALREADY_EXISTSERROR_HTTP_REDIRECT_FAILEDERROR_HTTP_NOT_REDIRECTEDERROR_HTTP_COOKIE_NEEDS_CONFIRMATIONERROR_HTTP_COOKIE_DECLINEDERROR_HTTP_REDIRECT_NEEDS_CONFIRMATIONERROR_INTERNET_SECURITY_CHANNEL_ERRORERROR_INTERNET_UNABLE_TO_CACHE_FILEERROR_INTERNET_TCPIP_NOT_INSTALLEDERROR_INTERNET_DISCONNECTEDERROR_INTERNET_SERVER_UNREACHABLEERROR_INTERNET_PROXY_SERVER_UNREACHABLEERROR_INTERNET_BAD_AUTO_PROXY_SCRIPTERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPTERROR_INTERNET_SEC_INVALID_CERTERROR_INTERNET_SEC_CERT_REVOKEDERROR_INTERNET_FAILED_DUETOSECURITYCHECKERROR_INTERNET_NOT_INITIALIZEDERROR_INTERNET_NEED_MSN_SSPI_PKGERROR_INTERNET_LOGIN_FAILURE_DISPLAY_ENTITY_BODYERROR_INTERNET_DECODING_FAILEDINTERNET_ERROR_LASTNORMAL_CACHE_ENTRYSTICKY_CACHE_ENTRYEDITED_CACHE_ENTRYTRACK_OFFLINE_CACHE_ENTRYTRACK_ONLINE_CACHE_ENTRYSPARSE_CACHE_ENTRYCOOKIE_CACHE_ENTRYURLHISTORY_CACHE_ENTRYURLCACHE_FIND_DEFAULT_FILTERLPINTERNET_CACHE_ENTRY_INFOAINTERNET_CACHE_ENTRY_INFOALPINTERNET_CACHE_ENTRY_INFOWINTERNET_CACHE_ENTRY_INFOWLPINTERNET_CACHE_TIMESTAMPSINTERNET_CACHE_TIMESTAMPSGROUPIDCACHEGROUP_ATTRIBUTE_GET_ALLCACHEGROUP_ATTRIBUTE_BASICCACHEGROUP_ATTRIBUTE_FLAGCACHEGROUP_ATTRIBUTE_TYPECACHEGROUP_ATTRIBUTE_QUOTACACHEGROUP_ATTRIBUTE_GROUPNAMECACHEGROUP_ATTRIBUTE_STORAGECACHEGROUP_FLAG_NONPURGEABLECACHEGROUP_FLAG_GIDONLYCACHEGROUP_FLAG_FLUSHURL_ONDELETECACHEGROUP_SEARCH_ALLCACHEGROUP_SEARCH_BYURLCACHEGROUP_TYPE_INVALIDCACHEGROUP_READWRITE_MASKGROUPNAME_MAX_LENGTHGROUP_OWNER_STORAGE_SIZELPINTERNET_CACHE_GROUP_INFOAINTERNET_CACHE_GROUP_INFOALPINTERNET_CACHE_GROUP_INFOWINTERNET_CACHE_GROUP_INFOWCACHE_ENTRY_ATTRIBUTE_FCCACHE_ENTRY_HITRATE_FCCACHE_ENTRY_MODTIME_FCCACHE_ENTRY_EXPTIME_FCCACHE_ENTRY_ACCTIME_FCCACHE_ENTRY_SYNCTIME_FCCACHE_ENTRY_HEADERINFO_FCCACHE_ENTRY_EXEMPT_DELTA_FCINTERNET_CACHE_GROUP_ADDINTERNET_CACHE_GROUP_REMOVEINTERNET_DIAL_FORCE_PROMPTINTERNET_DIAL_SHOW_OFFLINEINTERNET_DIAL_UNATTENDEDINTERENT_GOONLINE_REFRESHINTERENT_GOONLINE_NOPROMPTINTERENT_GOONLINE_MASKINTERNET_AUTODIAL_FORCE_ONLINEINTERNET_AUTODIAL_FORCE_UNATTENDEDINTERNET_AUTODIAL_FAILIFSECURITYCHECKINTERNET_AUTODIAL_OVERRIDE_NET_PRESENTINTERNET_AUTODIAL_FLAGS_MASKPROXY_AUTO_DETECT_TYPE_DHCPPROXY_AUTO_DETECT_TYPE_DNS_ALPAUTO_PROXY_SCRIPT_BUFFERAUTO_PROXY_SCRIPT_BUFFERINTERNET_CONNECTION_MODEMINTERNET_CONNECTION_LANINTERNET_CONNECTION_PROXYINTERNET_CONNECTION_MODEM_BUSYINTERNET_RAS_INSTALLEDINTERNET_CONNECTION_OFFLINEINTERNET_CONNECTION_CONFIGUREDINTERNET_CUSTOMDIAL_CONNECTINTERNET_CUSTOMDIAL_UNATTENDEDINTERNET_CUSTOMDIAL_DISCONNECTINTERNET_CUSTOMDIAL_SHOWOFFLINEINTERNET_CUSTOMDIAL_SAFE_FOR_UNATTENDEDINTERNET_CUSTOMDIAL_WILL_SUPPLY_STATEINTERNET_CUSTOMDIAL_CAN_HANGUPINTERNET_DIALSTATE_DISCONNECTEDINTERNET_IDENTITY_FLAG_PRIVATE_CACHEINTERNET_IDENTITY_FLAG_SHARED_CACHEINTERNET_IDENTITY_FLAG_CLEAR_DATAINTERNET_IDENTITY_FLAG_CLEAR_COOKIESINTERNET_IDENTITY_FLAG_CLEAR_HISTORYINTERNET_IDENTITY_FLAG_CLEAR_CONTENTINTERNET_SUPPRESS_RESET_ALLINTERNET_SUPPRESS_COOKIE_POLICYINTERNET_SUPPRESS_COOKIE_POLICY_RESETPRIVACY_TEMPLATE_NO_COOKIESPRIVACY_TEMPLATE_HIGHPRIVACY_TEMPLATE_MEDIUM_HIGHPRIVACY_TEMPLATE_MEDIUMPRIVACY_TEMPLATE_MEDIUM_LOWPRIVACY_TEMPLATE_LOWPRIVACY_TEMPLATE_CUSTOMPRIVACY_TEMPLATE_ADVANCEDPRIVACY_TEMPLATE_MAXPRIVACY_TYPE_FIRST_PARTYPRIVACY_TYPE_THIRD_PARTYCommitUrlCacheEntryACommitUrlCacheEntryWCreateMD5SSOHashCreateUrlCacheEntryACreateUrlCacheEntryWCreateUrlCacheGroupDeleteUrlCacheEntryADeleteUrlCacheEntryWDeleteUrlCacheGroupDeleteWpadCacheForNetworksWPAD_CACHE_DELETEDetectAutoProxyUrlFindCloseUrlCacheFindFirstUrlCacheEntryAFindFirstUrlCacheEntryExAFindFirstUrlCacheEntryExWFindFirstUrlCacheEntryWFindFirstUrlCacheGroupFindNextUrlCacheEntryAFindNextUrlCacheEntryExAFindNextUrlCacheEntryExWFindNextUrlCacheEntryWFindNextUrlCacheGroupFtpCommandAFtpCommandWFtpCreateDirectoryAFtpCreateDirectoryWFtpDeleteFileAFtpDeleteFileWFtpFindFirstFileAFtpFindFirstFileWFtpGetCurrentDirectoryAFtpGetCurrentDirectoryWFtpGetFileAFtpGetFileExFtpGetFileSizeFtpGetFileWFtpOpenFileAFtpOpenFileWFtpPutFileAFtpPutFileExFtpPutFileWFtpRemoveDirectoryAFtpRemoveDirectoryWFtpRenameFileAFtpRenameFileWFtpSetCurrentDirectoryAFtpSetCurrentDirectoryWGetUrlCacheEntryInfoAGetUrlCacheEntryInfoExAGetUrlCacheEntryInfoExWGetUrlCacheEntryInfoWGetUrlCacheGroupAttributeAGetUrlCacheGroupAttributeWGopherCreateLocatorAGopherCreateLocatorWGopherFindFirstFileAGopherFindFirstFileWGopherGetAttributeAGOPHER_ATTRIBUTE_ENUMERATORGopherGetAttributeWGopherGetLocatorTypeAGopherGetLocatorTypeWGopherOpenFileAGopherOpenFileWHttpAddRequestHeadersAHttpAddRequestHeadersWHttpEndRequestAHttpEndRequestWHttpOpenRequestAHttpOpenRequestWHttpQueryInfoAHttpQueryInfoWHttpSendRequestAHttpSendRequestExAHttpSendRequestExWHttpSendRequestWInternetAttemptConnectInternetAutodialInternetAutodialHangupInternetCanonicalizeUrlAInternetCanonicalizeUrlWInternetCheckConnectionAInternetCheckConnectionWInternetClearAllPerSiteCookieDecisionsInternetCloseHandleInternetCombineUrlAInternetCombineUrlWInternetConfirmZoneCrossingAInternetConfirmZoneCrossingWInternetConnectAInternetConnectWInternetCrackUrlAInternetCrackUrlWInternetCreateUrlAInternetCreateUrlWInternetDialAInternetDialWInternetEnumPerSiteCookieDecisionAInternetEnumPerSiteCookieDecisionWInternetErrorDlgInternetFindNextFileAInternetFindNextFileWInternetFreeCookiesINTERNET_COOKIE2InternetGetConnectedStateInternetGetConnectedStateExAInternetGetConnectedStateExWInternetGetCookieAInternetGetCookieEx2InternetGetCookieExAInternetGetCookieExWInternetGetCookieWInternetGetLastResponseInfoAInternetGetLastResponseInfoWInternetGetPerSiteCookieDecisionAInternetGetPerSiteCookieDecisionWInternetGoOnlineAInternetGoOnlineWInternetHangUpInternetInitializeAutoProxyDllInternetLockRequestFileInternetOpenAInternetOpenUrlAInternetOpenUrlWInternetOpenWInternetQueryDataAvailableInternetQueryOptionAInternetQueryOptionWInternetReadFileInternetReadFileExAInternetReadFileExWInternetSetCookieAInternetSetCookieEx2InternetSetCookieExAInternetSetCookieExWInternetSetCookieWInternetSetDialStateAInternetSetDialStateWInternetSetFilePointerInternetSetOptionAInternetSetOptionExAInternetSetOptionExWInternetSetOptionWInternetSetPerSiteCookieDecisionAInternetSetPerSiteCookieDecisionWInternetSetStatusCallbackAInternetSetStatusCallbackWInternetTimeFromSystemTimeAInternetTimeFromSystemTimeWInternetTimeToSystemTimeAInternetTimeToSystemTimeWInternetUnlockRequestFileInternetWriteFilePrivacyGetZonePreferenceWPrivacySetZonePreferenceWReadUrlCacheEntryStreamReadUrlCacheEntryStreamExResumeSuspendedDownloadRetrieveUrlCacheEntryFileARetrieveUrlCacheEntryFileWRetrieveUrlCacheEntryStreamARetrieveUrlCacheEntryStreamWSetUrlCacheEntryGroupASetUrlCacheEntryGroupWSetUrlCacheEntryInfoASetUrlCacheEntryInfoWSetUrlCacheGroupAttributeASetUrlCacheGroupAttributeWUnlockUrlCacheEntryFileAUnlockUrlCacheEntryFileWUnlockUrlCacheEntryStream//! Windows Internet Services API procedure declarations, types and constants.// Currently, this only contains `INTERNET_FLAG_BGUPDATE`, which is needed to correctly define// `wininet::INTERNET_FLAGS_MASK`.// Functions from wininet.dll that *should* be in this header.// pub fn AppCacheCheckManifest();// pub fn AppCacheCloseHandle();// pub fn AppCacheCreateAndCommitFile();// pub fn AppCacheDeleteGroup();// pub fn AppCacheDeleteIEGroup();// pub fn AppCacheDuplicateHandle();// pub fn AppCacheFinalize();// pub fn AppCacheFreeDownloadList();// pub fn AppCacheFreeGroupList();// pub fn AppCacheFreeIESpace();// pub fn AppCacheFreeSpace();// pub fn AppCacheGetDownloadList();// pub fn AppCacheGetFallbackUrl();// pub fn AppCacheGetGroupList();// pub fn AppCacheGetIEGroupList();// pub fn AppCacheGetInfo();// pub fn AppCacheGetManifestUrl();// pub fn AppCacheLookup();// pub fn CommitUrlCacheEntryBinaryBlob();// pub fn CreateCacheServerRpcBinding();// pub fn CreateUrlCacheContainerA();// pub fn CreateUrlCacheContainerW();// pub fn CreateUrlCacheEntryExW();// pub fn DeleteIE3Cache();// pub fn DeleteUrlCacheContainerA();// pub fn DeleteUrlCacheContainerW();// pub fn DoConnectoidsExist();// pub fn ExportCookieFileA();// pub fn ExportCookieFileW();// pub fn FindFirstUrlCacheContainerA();// pub fn FindFirstUrlCacheContainerW();// pub fn FindNextUrlCacheContainerA();// pub fn FindNextUrlCacheContainerW();// pub fn FindP3PPolicySymbol();// pub fn ForceNexusLookupExW();// pub fn FreeP3PObject();// pub fn FreeUrlCacheSpaceA();// pub fn FreeUrlCacheSpaceW();// pub fn GetCacheServerConnection();// pub fn GetDiskInfoA();// pub fn GetP3PPolicy();// pub fn GetP3PRequestStatus();// pub fn GetUrlCacheConfigInfoA();// pub fn GetUrlCacheConfigInfoW();// pub fn GetUrlCacheEntryBinaryBlob();// pub fn GetUrlCacheHeaderData();// pub fn HttpCheckDavComplianceA();// pub fn HttpCheckDavComplianceW();// pub fn HttpCloseDependencyHandle();// pub fn HttpDuplicateDependencyHandle();// pub fn HttpGetServerCredentials();// pub fn HttpGetTunnelSocket();// pub fn HttpIsHostHstsEnabled();// pub fn HttpOpenDependencyHandle();// pub fn HttpPushClose();// pub fn HttpPushEnable();// pub fn HttpPushWait();// pub fn HttpWebSocketClose();// pub fn HttpWebSocketCompleteUpgrade();// pub fn HttpWebSocketQueryCloseStatus();// pub fn HttpWebSocketReceive();// pub fn HttpWebSocketSend();// pub fn HttpWebSocketShutdown();// pub fn ImportCookieFileA();// pub fn ImportCookieFileW();// pub fn IncrementUrlCacheHeaderData();// pub fn InternalInternetGetCookie();// pub fn InternetAlgIdToStringA();// pub fn InternetAlgIdToStringW();// pub fn InternetAutodialCallback();// pub fn InternetAutoProxyGetProxyForUrl();// pub fn InternetAutoProxyOnSendRequestComplete();// pub fn InternetFortezzaCommand();// pub fn InternetFreeProxyInfoList();// pub fn InternetGetCertByURLA();// pub fn InternetGetProxyForUrl();// pub fn InternetGetSecurityInfoByURLA();// pub fn InternetGetSecurityInfoByURLW();// pub fn InternetQueryFortezzaStatus();// pub fn InternetSecurityProtocolToStringA();// pub fn InternetSecurityProtocolToStringW();// pub fn InternetShowSecurityInfoByURLA();// pub fn InternetShowSecurityInfoByURLW();// pub fn InternetWriteFileExA();// pub fn InternetWriteFileExW();// pub fn IsDialUpConnection();// pub fn IsDomainLegalCookieDomainA();// pub fn IsDomainLegalCookieDomainW();// pub fn IsHostInProxyBypassList();// pub fn IsLanConnection();// pub fn IsProfilesEnabled();// pub fn IsUrlCacheEntryExpiredA();// pub fn IsUrlCacheEntryExpiredW();// pub fn LoadUrlCacheContent();// pub fn MapResourceToPolicy();// pub fn ParseX509EncodedCertificateForListBoxEntry();// pub fn PerformOperationOverUrlCacheA();// pub fn ReadGuidsForConnectedNetworks();// pub fn RegisterForNetworkChangeNotification();// pub fn RegisterUrlCacheNotification();// pub fn RunOnceUrlCache();// pub fn SetGlobalJetParameters();// pub fn SetUrlCacheConfigInfoA();// pub fn SetUrlCacheConfigInfoW();// pub fn SetUrlCacheHeaderData();// pub fn ShowCertificate();// pub fn ShowClientAuthCerts();// pub fn ShowSecurityInfo();// pub fn ShowX509EncodedCertificate();// pub fn UnRegisterNetworkChangeNotification();// pub fn UpdateUrlCacheContentPath();// pub fn UrlCacheCheckEntriesExist();// pub fn UrlCacheCloseEntryHandle();// pub fn UrlCacheContainerSetEntryMaximumAge();// pub fn UrlCacheCreateContainer();// pub fn UrlCacheFindFirstEntry();// pub fn UrlCacheFindNextEntry();// pub fn UrlCacheFreeEntryInfo();// pub fn UrlCacheFreeGlobalSpace();// pub fn UrlCacheGetContentPaths();// pub fn UrlCacheGetEntryInfo();// pub fn UrlCacheGetGlobalCacheSize();// pub fn UrlCacheGetGlobalLimit();// pub fn UrlCacheReadEntryStream();// pub fn UrlCacheReloadSettings();// pub fn UrlCacheRetrieveEntryFile();// pub fn UrlCacheRetrieveEntryStream();// pub fn UrlCacheServer();// pub fn UrlCacheSetGlobalLimit();// pub fn UrlCacheUpdateEntryExtraData();// pub fn UrlZonesDetach();FILE_READ_DATAFILE_WRITE_DATA//146//177FILE_DEVICE_BEEPFILE_DEVICE_CD_ROMFILE_DEVICE_CD_ROM_FILE_SYSTEMFILE_DEVICE_DATALINKFILE_DEVICE_DFSFILE_DEVICE_DISKFILE_DEVICE_DISK_FILE_SYSTEMFILE_DEVICE_FILE_SYSTEMFILE_DEVICE_INPORT_PORTFILE_DEVICE_MAILSLOTFILE_DEVICE_MIDI_INFILE_DEVICE_MIDI_OUTFILE_DEVICE_MOUSEFILE_DEVICE_MULTI_UNC_PROVIDERFILE_DEVICE_NAMED_PIPEFILE_DEVICE_NETWORKFILE_DEVICE_NETWORK_BROWSERFILE_DEVICE_NETWORK_FILE_SYSTEMFILE_DEVICE_NULLFILE_DEVICE_PARALLEL_PORTFILE_DEVICE_PHYSICAL_NETCARDFILE_DEVICE_PRINTERFILE_DEVICE_SCANNERFILE_DEVICE_SERIAL_MOUSE_PORTFILE_DEVICE_SERIAL_PORTFILE_DEVICE_SCREENFILE_DEVICE_SOUNDFILE_DEVICE_STREAMSFILE_DEVICE_TAPEFILE_DEVICE_TAPE_FILE_SYSTEMFILE_DEVICE_TRANSPORTFILE_DEVICE_VIDEOFILE_DEVICE_VIRTUAL_DISKFILE_DEVICE_WAVE_INFILE_DEVICE_WAVE_OUTFILE_DEVICE_8042_PORTFILE_DEVICE_NETWORK_REDIRECTORFILE_DEVICE_BATTERYFILE_DEVICE_BUS_EXTENDERFILE_DEVICE_MODEMFILE_DEVICE_VDMFILE_DEVICE_MASS_STORAGEFILE_DEVICE_SMBFILE_DEVICE_KSFILE_DEVICE_CHANGERFILE_DEVICE_SMARTCARDFILE_DEVICE_ACPIFILE_DEVICE_DVDFILE_DEVICE_FULLSCREEN_VIDEOFILE_DEVICE_DFS_FILE_SYSTEMFILE_DEVICE_DFS_VOLUMEFILE_DEVICE_SERENUMFILE_DEVICE_TERMSRVFILE_DEVICE_KSECFILE_DEVICE_FIPSFILE_DEVICE_INFINIBANDFILE_DEVICE_VMBUSFILE_DEVICE_CRYPT_PROVIDERFILE_DEVICE_WPDFILE_DEVICE_MT_COMPOSITEFILE_DEVICE_MT_TRANSPORTFILE_DEVICE_BIOMETRICFILE_DEVICE_PMIFILE_DEVICE_EHSTORFILE_DEVICE_DEVAPIFILE_DEVICE_GPIOFILE_DEVICE_CONSOLEFILE_DEVICE_NFPFILE_DEVICE_SYSENVFILE_DEVICE_VIRTUAL_BLOCKFILE_DEVICE_POINT_OF_SERVICEFILE_DEVICE_STORAGE_REPLICATIONFILE_DEVICE_TRUST_ENVFILE_DEVICE_UCMFILE_DEVICE_UCMTCPCI//288//317FILE_SPECIAL_ACCESSIOCTL_STORAGE_BASE//347IOCTL_STORAGE_CHECK_VERIFYIOCTL_STORAGE_CHECK_VERIFY2IOCTL_STORAGE_MEDIA_REMOVALIOCTL_STORAGE_EJECT_MEDIAIOCTL_STORAGE_LOAD_MEDIAIOCTL_STORAGE_LOAD_MEDIA2IOCTL_STORAGE_RESERVEIOCTL_STORAGE_RELEASEIOCTL_STORAGE_FIND_NEW_DEVICESIOCTL_STORAGE_EJECTION_CONTROLIOCTL_STORAGE_MCN_CONTROLIOCTL_STORAGE_GET_MEDIA_TYPESIOCTL_STORAGE_GET_MEDIA_TYPES_EXIOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBERIOCTL_STORAGE_GET_HOTPLUG_INFOIOCTL_STORAGE_SET_HOTPLUG_INFOIOCTL_STORAGE_RESET_BUSIOCTL_STORAGE_RESET_DEVICEIOCTL_STORAGE_BREAK_RESERVATIONIOCTL_STORAGE_PERSISTENT_RESERVE_INIOCTL_STORAGE_PERSISTENT_RESERVE_OUTIOCTL_STORAGE_GET_DEVICE_NUMBERIOCTL_STORAGE_PREDICT_FAILUREIOCTL_STORAGE_FAILURE_PREDICTION_CONFIGIOCTL_STORAGE_READ_CAPACITYIOCTL_STORAGE_GET_DEVICE_TELEMETRYIOCTL_STORAGE_DEVICE_TELEMETRY_NOTIFYIOCTL_STORAGE_DEVICE_TELEMETRY_QUERY_CAPSIOCTL_STORAGE_GET_DEVICE_TELEMETRY_RAWIOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTESIOCTL_STORAGE_GET_LB_PROVISIONING_MAP_RESOURCESIOCTL_STORAGE_GET_BC_PROPERTIESIOCTL_STORAGE_ALLOCATE_BC_STREAMIOCTL_STORAGE_FREE_BC_STREAMIOCTL_STORAGE_CHECK_PRIORITY_HINT_SUPPORTIOCTL_STORAGE_START_DATA_INTEGRITY_CHECKIOCTL_STORAGE_STOP_DATA_INTEGRITY_CHECKOBSOLETE_IOCTL_STORAGE_RESET_BUSOBSOLETE_IOCTL_STORAGE_RESET_DEVICEIOCTL_STORAGE_ENABLE_IDLE_POWERIOCTL_STORAGE_GET_IDLE_POWERUP_REASONIOCTL_STORAGE_POWER_ACTIVEIOCTL_STORAGE_POWER_IDLEIOCTL_STORAGE_EVENT_NOTIFICATION//565PSTORAGE_DEVICE_NUMBERSTORAGE_DEVICE_NUMBERPSTORAGE_DEVICE_NUMBERSSTORAGE_DEVICE_NUMBERS//1040PSTORAGE_QUERY_TYPESTORAGE_QUERY_TYPEPSTORAGE_PROPERTY_IDSTORAGE_PROPERTY_IDPSTORAGE_PROPERTY_QUERY//1574PDEVICE_TRIM_DESCRIPTORDEVICE_TRIM_DESCRIPTORIOCTL_DISK_BASE//7540IOCTL_DISK_GET_DRIVE_GEOMETRYIOCTL_DISK_GET_PARTITION_INFOIOCTL_DISK_SET_PARTITION_INFOIOCTL_DISK_GET_DRIVE_LAYOUTIOCTL_DISK_SET_DRIVE_LAYOUTIOCTL_DISK_VERIFYIOCTL_DISK_FORMAT_TRACKSIOCTL_DISK_REASSIGN_BLOCKSIOCTL_DISK_PERFORMANCEIOCTL_DISK_IS_WRITABLEIOCTL_DISK_LOGGINGIOCTL_DISK_FORMAT_TRACKS_EXIOCTL_DISK_HISTOGRAM_STRUCTUREIOCTL_DISK_HISTOGRAM_DATAIOCTL_DISK_HISTOGRAM_RESETIOCTL_DISK_REQUEST_STRUCTUREIOCTL_DISK_REQUEST_DATAIOCTL_DISK_PERFORMANCE_OFFIOCTL_DISK_CONTROLLER_NUMBERSMART_GET_VERSIONSMART_SEND_DRIVE_COMMANDSMART_RCV_DRIVE_DATAIOCTL_DISK_GET_PARTITION_INFO_EXIOCTL_DISK_SET_PARTITION_INFO_EXIOCTL_DISK_GET_DRIVE_LAYOUT_EXIOCTL_DISK_SET_DRIVE_LAYOUT_EXIOCTL_DISK_CREATE_DISKIOCTL_DISK_GET_LENGTH_INFOIOCTL_DISK_GET_DRIVE_GEOMETRY_EXIOCTL_DISK_REASSIGN_BLOCKS_EXIOCTL_DISK_UPDATE_DRIVE_SIZEIOCTL_DISK_GROW_PARTITIONIOCTL_DISK_GET_CACHE_INFORMATIONIOCTL_DISK_SET_CACHE_INFORMATIONIOCTL_DISK_GET_WRITE_CACHE_STATEOBSOLETE_DISK_GET_WRITE_CACHE_STATEIOCTL_DISK_DELETE_DRIVE_LAYOUTIOCTL_DISK_UPDATE_PROPERTIESIOCTL_DISK_FORMAT_DRIVEIOCTL_DISK_SENSE_DEVICEIOCTL_DISK_CHECK_VERIFYIOCTL_DISK_MEDIA_REMOVALIOCTL_DISK_EJECT_MEDIAIOCTL_DISK_LOAD_MEDIAIOCTL_DISK_RESERVEIOCTL_DISK_RELEASEIOCTL_DISK_FIND_NEW_DEVICESIOCTL_DISK_GET_MEDIA_TYPESIOCTL_DISK_GET_DISK_ATTRIBUTESIOCTL_DISK_SET_DISK_ATTRIBUTESIOCTL_DISK_RESET_SNAPSHOT_INFO//7810PMEDIA_TYPE//7884PDISK_GEOMETRYDISK_GEOMETRYPPARTITION_INFORMATIONPARTITION_INFORMATIONPSET_PARTITION_INFORMATIONSET_PARTITION_INFORMATIONPDRIVE_LAYOUT_INFORMATIONDRIVE_LAYOUT_INFORMATIONPVERIFY_INFORMATIONVERIFY_INFORMATIONPREASSIGN_BLOCKSREASSIGN_BLOCKSPREASSIGN_BLOCKS_EXREASSIGN_BLOCKS_EXPPARTITION_INFORMATION_GPTPARTITION_INFORMATION_GPT//8059PPARTITION_INFORMATION_MBRPARTITION_INFORMATION_MBRSET_PARTITION_INFORMATION_MBRSET_PARTITION_INFORMATION_GPTPCREATE_DISK_GPTCREATE_DISK_GPTPCREATE_DISK_MBRCREATE_DISK_MBRPCREATE_DISKCREATE_DISKPGET_LENGTH_INFORMATIONGET_LENGTH_INFORMATIONPPARTITION_INFORMATION_EXPARTITION_INFORMATION_EXPDRIVE_LAYOUT_INFORMATION_GPTDRIVE_LAYOUT_INFORMATION_GPTPDRIVE_LAYOUT_INFORMATION_MBRDRIVE_LAYOUT_INFORMATION_MBRPDRIVE_LAYOUT_INFORMATION_EXDRIVE_LAYOUT_INFORMATION_EX//8350IOCTL_CHANGER_BASE//8933IOCTL_CHANGER_GET_PARAMETERSIOCTL_CHANGER_GET_STATUSIOCTL_CHANGER_GET_PRODUCT_DATAIOCTL_CHANGER_SET_ACCESSIOCTL_CHANGER_GET_ELEMENT_STATUSIOCTL_CHANGER_INITIALIZE_ELEMENT_STATUSIOCTL_CHANGER_SET_POSITIONIOCTL_CHANGER_EXCHANGE_MEDIUMIOCTL_CHANGER_MOVE_MEDIUMIOCTL_CHANGER_REINITIALIZE_TRANSPORTIOCTL_CHANGER_QUERY_VOLUME_TAGSIOCTL_SERIAL_LSRMST_INSERTIOCTL_SERENUM_EXPOSE_HARDWAREIOCTL_SERENUM_REMOVE_HARDWAREIOCTL_SERENUM_PORT_DESCIOCTL_SERENUM_GET_PORT_NAMEFSCTL_REQUEST_OPLOCK_LEVEL_1//9717FSCTL_REQUEST_OPLOCK_LEVEL_2FSCTL_REQUEST_BATCH_OPLOCKFSCTL_OPLOCK_BREAK_ACKNOWLEDGEFSCTL_OPBATCH_ACK_CLOSE_PENDINGFSCTL_OPLOCK_BREAK_NOTIFYFSCTL_LOCK_VOLUMEFSCTL_UNLOCK_VOLUMEFSCTL_DISMOUNT_VOLUMEFSCTL_IS_VOLUME_MOUNTEDFSCTL_IS_PATHNAME_VALIDFSCTL_MARK_VOLUME_DIRTYFSCTL_QUERY_RETRIEVAL_POINTERSFSCTL_GET_COMPRESSIONFSCTL_SET_COMPRESSIONFSCTL_SET_BOOTLOADER_ACCESSEDFSCTL_MARK_AS_SYSTEM_HIVEFSCTL_OPLOCK_BREAK_ACK_NO_2FSCTL_INVALIDATE_VOLUMESFSCTL_QUERY_FAT_BPBFSCTL_REQUEST_FILTER_OPLOCKFSCTL_FILESYSTEM_GET_STATISTICSFSCTL_GET_NTFS_VOLUME_DATAFSCTL_GET_NTFS_FILE_RECORDFSCTL_GET_VOLUME_BITMAPFSCTL_GET_RETRIEVAL_POINTERSFSCTL_MOVE_FILEFSCTL_IS_VOLUME_DIRTYFSCTL_ALLOW_EXTENDED_DASD_IOFSCTL_FIND_FILES_BY_SIDFSCTL_SET_OBJECT_IDFSCTL_GET_OBJECT_IDFSCTL_DELETE_OBJECT_IDFSCTL_SET_REPARSE_POINTFSCTL_GET_REPARSE_POINTFSCTL_DELETE_REPARSE_POINTFSCTL_ENUM_USN_DATAFSCTL_SECURITY_ID_CHECKFSCTL_READ_USN_JOURNALFSCTL_SET_OBJECT_ID_EXTENDEDFSCTL_CREATE_OR_GET_OBJECT_IDFSCTL_SET_SPARSEFSCTL_SET_ZERO_DATAFSCTL_QUERY_ALLOCATED_RANGESFSCTL_ENABLE_UPGRADEFSCTL_SET_ENCRYPTIONFSCTL_ENCRYPTION_FSCTL_IOFSCTL_WRITE_RAW_ENCRYPTEDFSCTL_READ_RAW_ENCRYPTEDFSCTL_CREATE_USN_JOURNALFSCTL_READ_FILE_USN_DATAFSCTL_WRITE_USN_CLOSE_RECORDFSCTL_EXTEND_VOLUMEFSCTL_QUERY_USN_JOURNALFSCTL_DELETE_USN_JOURNALFSCTL_MARK_HANDLEFSCTL_SIS_COPYFILEFSCTL_SIS_LINK_FILESFSCTL_RECALL_FILEFSCTL_READ_FROM_PLEXFSCTL_FILE_PREFETCHFSCTL_MAKE_MEDIA_COMPATIBLEFSCTL_SET_DEFECT_MANAGEMENTFSCTL_QUERY_SPARING_INFOFSCTL_QUERY_ON_DISK_VOLUME_INFOFSCTL_SET_VOLUME_COMPRESSION_STATEFSCTL_TXFS_MODIFY_RMFSCTL_TXFS_QUERY_RM_INFORMATIONFSCTL_TXFS_ROLLFORWARD_REDOFSCTL_TXFS_ROLLFORWARD_UNDOFSCTL_TXFS_START_RMFSCTL_TXFS_SHUTDOWN_RMFSCTL_TXFS_READ_BACKUP_INFORMATIONFSCTL_TXFS_WRITE_BACKUP_INFORMATIONFSCTL_TXFS_CREATE_SECONDARY_RMFSCTL_TXFS_GET_METADATA_INFOFSCTL_TXFS_GET_TRANSACTED_VERSIONFSCTL_TXFS_SAVEPOINT_INFORMATIONFSCTL_TXFS_CREATE_MINIVERSIONFSCTL_TXFS_TRANSACTION_ACTIVEFSCTL_SET_ZERO_ON_DEALLOCATIONFSCTL_SET_REPAIRFSCTL_GET_REPAIRFSCTL_WAIT_FOR_REPAIRFSCTL_INITIATE_REPAIRFSCTL_CSC_INTERNALFSCTL_SHRINK_VOLUMEFSCTL_SET_SHORT_NAME_BEHAVIORFSCTL_DFSR_SET_GHOST_HANDLE_STATEFSCTL_TXFS_LIST_TRANSACTION_LOCKED_FILESFSCTL_TXFS_LIST_TRANSACTIONSFSCTL_QUERY_PAGEFILE_ENCRYPTIONFSCTL_RESET_VOLUME_ALLOCATION_HINTSFSCTL_QUERY_DEPENDENT_VOLUMEFSCTL_SD_GLOBAL_CHANGEFSCTL_TXFS_READ_BACKUP_INFORMATION2FSCTL_LOOKUP_STREAM_FROM_CLUSTERFSCTL_TXFS_WRITE_BACKUP_INFORMATION2FSCTL_FILE_TYPE_NOTIFICATIONFSCTL_FILE_LEVEL_TRIMFSCTL_GET_BOOT_AREA_INFOFSCTL_GET_RETRIEVAL_POINTER_BASEFSCTL_SET_PERSISTENT_VOLUME_STATEFSCTL_QUERY_PERSISTENT_VOLUME_STATEFSCTL_REQUEST_OPLOCKFSCTL_CSV_TUNNEL_REQUESTFSCTL_IS_CSV_FILEFSCTL_QUERY_FILE_SYSTEM_RECOGNITIONFSCTL_CSV_GET_VOLUME_PATH_NAMEFSCTL_CSV_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINTFSCTL_CSV_GET_VOLUME_PATH_NAMES_FOR_VOLUME_NAMEFSCTL_IS_FILE_ON_CSV_VOLUMEFSCTL_CORRUPTION_HANDLINGFSCTL_OFFLOAD_READFSCTL_OFFLOAD_WRITEFSCTL_CSV_INTERNALFSCTL_SET_PURGE_FAILURE_MODEFSCTL_QUERY_FILE_LAYOUTFSCTL_IS_VOLUME_OWNED_BYCSVFSFSCTL_GET_INTEGRITY_INFORMATIONFSCTL_SET_INTEGRITY_INFORMATIONFSCTL_QUERY_FILE_REGIONSFSCTL_DEDUP_FILEFSCTL_DEDUP_QUERY_FILE_HASHESFSCTL_DEDUP_QUERY_RANGE_STATEFSCTL_DEDUP_QUERY_REPARSE_INFOFSCTL_RKF_INTERNALFSCTL_SCRUB_DATAFSCTL_REPAIR_COPIESFSCTL_DISABLE_LOCAL_BUFFERINGFSCTL_CSV_MGMT_LOCKFSCTL_CSV_QUERY_DOWN_LEVEL_FILE_SYSTEM_CHARACTERISTICSFSCTL_ADVANCE_FILE_IDFSCTL_CSV_SYNC_TUNNEL_REQUESTFSCTL_CSV_QUERY_VETO_FILE_DIRECT_IOFSCTL_WRITE_USN_REASONFSCTL_CSV_CONTROLFSCTL_GET_REFS_VOLUME_DATAFSCTL_CSV_H_BREAKING_SYNC_TUNNEL_REQUESTFSCTL_QUERY_STORAGE_CLASSESFSCTL_QUERY_REGION_INFOFSCTL_USN_TRACK_MODIFIED_RANGESFSCTL_QUERY_SHARED_VIRTUAL_DISK_SUPPORTFSCTL_SVHDX_SYNC_TUNNEL_REQUESTFSCTL_SVHDX_SET_INITIATOR_INFORMATIONFSCTL_SET_EXTERNAL_BACKINGFSCTL_GET_EXTERNAL_BACKINGFSCTL_DELETE_EXTERNAL_BACKINGFSCTL_ENUM_EXTERNAL_BACKINGFSCTL_ENUM_OVERLAYFSCTL_ADD_OVERLAYFSCTL_REMOVE_OVERLAYFSCTL_UPDATE_OVERLAY// FILE_DEVICE_AVIO is defined nowhere//pub const IOCTL_AVIO_ALLOCATE_STREAM: DWORD = CTL_CODE!(FILE_DEVICE_AVIO, 1, METHOD_BUFFERED,//    FILE_SPECIAL_ACCESS);//pub const IOCTL_AVIO_FREE_STREAM: DWORD = CTL_CODE!(FILE_DEVICE_AVIO, 2, METHOD_BUFFERED,//pub const IOCTL_AVIO_MODIFY_STREAM: DWORD = CTL_CODE!(FILE_DEVICE_AVIO, 3, METHOD_BUFFERED,PPATHNAME_BUFFERPATHNAME_BUFFERPFSCTL_QUERY_FAT_BPB_BUFFERFSCTL_QUERY_FAT_BPB_BUFFERPNTFS_VOLUME_DATA_BUFFERNTFS_VOLUME_DATA_BUFFERPNTFS_EXTENDED_VOLUME_DATANTFS_EXTENDED_VOLUME_DATAPREFS_VOLUME_DATA_BUFFERREFS_VOLUME_DATA_BUFFERPSTARTING_LCN_INPUT_BUFFERSTARTING_LCN_INPUT_BUFFERPVOLUME_BITMAP_BUFFERVOLUME_BITMAP_BUFFERPSTARTING_VCN_INPUT_BUFFERSTARTING_VCN_INPUT_BUFFERPRETRIEVAL_POINTERS_BUFFERRETRIEVAL_POINTERS_BUFFERPNTFS_FILE_RECORD_INPUT_BUFFERNTFS_FILE_RECORD_INPUT_BUFFERPNTFS_FILE_RECORD_OUTPUT_BUFFERNTFS_FILE_RECORD_OUTPUT_BUFFERPMOVE_FILE_DATAMOVE_FILE_DATAPMOVE_FILE_RECORD_DATAMOVE_FILE_RECORD_DATAIOCTL_VOLUME_BASE//15468IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTSPDISK_EXTENTDISK_EXTENTPVOLUME_DISK_EXTENTSVOLUME_DISK_EXTENTSIOCTL_VOLUME_ONLINEIOCTL_VOLUME_OFFLINEIOCTL_VOLUME_IS_CLUSTEREDIOCTL_VOLUME_GET_GPT_ATTRIBUTESPDISK_PERFORMANCEDISK_PERFORMANCE//! This module defines the 32-Bit Windows Device I/O control codes.RESOURCE_CONNECTEDRESOURCE_GLOBALNETRESOURCE_REMEMBEREDRESOURCE_RECENTRESOURCE_CONTEXTRESOURCETYPE_ANYRESOURCETYPE_DISKRESOURCETYPE_PRINTRESOURCETYPE_RESERVEDRESOURCETYPE_UNKNOWNRESOURCEUSAGE_CONNECTABLERESOURCEUSAGE_CONTAINERRESOURCEUSAGE_NOLOCALDEVICERESOURCEUSAGE_SIBLINGRESOURCEUSAGE_ATTACHEDRESOURCEUSAGE_ALLRESOURCEUSAGE_RESERVEDRESOURCEDISPLAYTYPE_GENERICRESOURCEDISPLAYTYPE_DOMAINRESOURCEDISPLAYTYPE_SERVERRESOURCEDISPLAYTYPE_SHARERESOURCEDISPLAYTYPE_FILERESOURCEDISPLAYTYPE_GROUPRESOURCEDISPLAYTYPE_NETWORKRESOURCEDISPLAYTYPE_ROOTRESOURCEDISPLAYTYPE_SHAREADMINRESOURCEDISPLAYTYPE_DIRECTORYRESOURCEDISPLAYTYPE_TREERESOURCEDISPLAYTYPE_NDSCONTAINERLPNETRESOURCEANETRESOURCEALPNETRESOURCEWNETRESOURCEWNETPROPERTY_PERSISTENTCONNECT_UPDATE_PROFILECONNECT_UPDATE_RECENTCONNECT_TEMPORARYCONNECT_INTERACTIVECONNECT_PROMPTCONNECT_NEED_DRIVECONNECT_REFCOUNTCONNECT_REDIRECTCONNECT_LOCALDRIVECONNECT_CURRENT_MEDIACONNECT_DEFERREDCONNECT_RESERVEDCONNECT_COMMANDLINECONNECT_CMD_SAVECREDCONNECT_CRED_RESETWNetAddConnection2AWNetAddConnection2WWNetAddConnection3AWNetAddConnection3WWNetCancelConnectionAWNetCancelConnectionWWNetCancelConnection2AWNetCancelConnection2WWNetGetConnectionAWNetGetConnectionWWNetUseConnectionAWNetUseConnectionWWNetConnectionDialogWNetDisconnectDialogLPCONNECTDLGSTRUCTACONNECTDLGSTRUCTALPCONNECTDLGSTRUCTWCONNECTDLGSTRUCTWCONNDLG_RO_PATHCONNDLG_CONN_POINTCONNDLG_USE_MRUCONNDLG_HIDE_BOXCONNDLG_PERSISTCONNDLG_NOT_PERSISTWNetConnectionDialog1AWNetConnectionDialog1WLPDISCDLGSTRUCTADISCDLGSTRUCTALPDISCDLGSTRUCTWDISCDLGSTRUCTWDISC_UPDATE_PROFILEDISC_NO_FORCEWNetDisconnectDialog1AWNetDisconnectDialog1WWNetOpenEnumAWNetOpenEnumWWNetEnumResourceAWNetEnumResourceWWNetCloseEnumWNetGetResourceParentAWNetGetResourceParentWWNetGetResourceInformationAWNetGetResourceInformationWUNIVERSAL_NAME_INFO_LEVELREMOTE_NAME_INFO_LEVELLPUNIVERSAL_NAME_INFOAUNIVERSAL_NAME_INFOALPUNIVERSAL_NAME_INFOWUNIVERSAL_NAME_INFOWLPREMOTE_NAME_INFOAREMOTE_NAME_INFOALPREMOTE_NAME_INFOWREMOTE_NAME_INFOWWNetGetUniversalNameAWNetGetUniversalNameWWNetGetUserAWNetGetUserWWNFMT_MULTILINEWNFMT_ABBREVIATEDWNFMT_INENUMWNFMT_CONNECTIONWNetGetProviderNameAWNetGetProviderNameWLPNETINFOSTRUCTNETINFOSTRUCTNETINFO_DLL16NETINFO_DISKREDNETINFO_PRINTERREDWNetGetNetworkInformationAWNetGetNetworkInformationWWNetGetLastErrorAWNetGetLastErrorWWN_SUCCESSWN_NO_ERRORWN_NOT_SUPPORTEDWN_CANCELWN_RETRYWN_NET_ERRORWN_MORE_DATAWN_BAD_POINTERWN_BAD_VALUEWN_BAD_USERWN_BAD_PASSWORDWN_ACCESS_DENIEDWN_FUNCTION_BUSYWN_WINDOWS_ERRORWN_OUT_OF_MEMORYWN_NO_NETWORKWN_EXTENDED_ERRORWN_BAD_LEVELWN_BAD_HANDLEWN_NOT_INITIALIZINGWN_NO_MORE_DEVICESWN_NOT_CONNECTEDWN_OPEN_FILESWN_DEVICE_IN_USEWN_BAD_NETNAMEWN_BAD_LOCALNAMEWN_ALREADY_CONNECTEDWN_DEVICE_ERRORWN_CONNECTION_CLOSEDWN_NO_NET_OR_BAD_PATHWN_BAD_PROVIDERWN_CANNOT_OPEN_PROFILEWN_BAD_PROFILEWN_BAD_DEV_TYPEWN_DEVICE_ALREADY_REMEMBEREDWN_CONNECTED_OTHER_PASSWORDWN_CONNECTED_OTHER_PASSWORD_DEFAULTWN_NO_MORE_ENTRIESWN_NOT_CONTAINERWN_NOT_AUTHENTICATEDWN_NOT_LOGGED_ONWN_NOT_VALIDATEDLPNETCONNECTINFOSTRUCTNETCONNECTINFOSTRUCTWNCON_FORNETCARDWNCON_NOTROUTEDWNCON_SLOWLINKWNCON_DYNAMICMultinetGetConnectionPerformanceAMultinetGetConnectionPerformanceW//! Standard WINNET Header File for WIN32MAX_LEADBYTESMAX_DEFAULTCHARMB_PRECOMPOSEDMB_COMPOSITEMB_USEGLYPHCHARSMB_ERR_INVALID_CHARSWC_COMPOSITECHECKWC_DISCARDNSWC_SEPCHARSWC_DEFAULTCHARWC_ERR_INVALID_CHARSWC_NO_BEST_FIT_CHARSCP_ACPCP_OEMCPCP_MACCPCP_THREAD_ACPCP_SYMBOLCP_UTF7CP_UTF8LGRPIDLCTYPECALTYPECALIDLPCPINFOCPINFOLPCPINFOEXACPINFOEXALPCPINFOEXWCPINFOEXWLPNUMBERFMTANUMBERFMTALPNUMBERFMTWNUMBERFMTWLPCURRENCYFMTACURRENCYFMTALPCURRENCYFMTWCURRENCYFMTWNLS_FUNCTIONNLSVERSIONINFOLPNLSVERSIONINFOEXNLSVERSIONINFOEXGEOIDGEOTYPEGEOCLASSPFILEMUIINFOFILEMUIINFOCompareStringAConvertDefaultLocaleEnumCalendarInfoACALINFO_ENUMPROCAEnumCalendarInfoExACALINFO_ENUMPROCEXAEnumCalendarInfoExExCALINFO_ENUMPROCEXEXEnumCalendarInfoExWCALINFO_ENUMPROCEXWEnumCalendarInfoWCALINFO_ENUMPROCWEnumDateFormatsADATEFMT_ENUMPROCAEnumDateFormatsExADATEFMT_ENUMPROCEXAEnumDateFormatsExExDATEFMT_ENUMPROCEXEXEnumDateFormatsExWDATEFMT_ENUMPROCEXWEnumDateFormatsWDATEFMT_ENUMPROCWEnumLanguageGroupLocalesALANGGROUPLOCALE_ENUMPROCAEnumLanguageGroupLocalesWLANGGROUPLOCALE_ENUMPROCWEnumSystemCodePagesACODEPAGE_ENUMPROCAEnumSystemCodePagesWCODEPAGE_ENUMPROCWEnumSystemGeoIDGEO_ENUMPROCEnumSystemLanguageGroupsALANGUAGEGROUP_ENUMPROCAEnumSystemLanguageGroupsWLANGUAGEGROUP_ENUMPROCWEnumSystemLocalesALOCALE_ENUMPROCAEnumSystemLocalesExLOCALE_ENUMPROCEXEnumSystemLocalesWLOCALE_ENUMPROCWEnumTimeFormatsATIMEFMT_ENUMPROCAEnumTimeFormatsExTIMEFMT_ENUMPROCEXEnumTimeFormatsWTIMEFMT_ENUMPROCWEnumUILanguagesAUILANGUAGE_ENUMPROCAEnumUILanguagesWUILANGUAGE_ENUMPROCWFindNLSStringFindNLSStringExFoldStringAGetACPGetCPInfoGetCPInfoExAGetCPInfoExWGetCalendarInfoAGetCalendarInfoExGetCalendarInfoWGetCurrencyFormatAGetCurrencyFormatExGetCurrencyFormatWGetDurationFormatGetDurationFormatExGetFileMUIInfoGetFileMUIPathGetGeoInfoAGetGeoInfoWGetLocaleInfoAGetLocaleInfoExGetLocaleInfoWGetNLSVersionGetNLSVersionExGetNumberFormatAGetNumberFormatExGetNumberFormatWGetOEMCPGetProcessPreferredUILanguagesGetStringScriptsGetStringTypeAGetStringTypeExAGetSystemDefaultLCIDGetSystemDefaultLangIDGetSystemDefaultLocaleNameGetSystemDefaultUILanguageGetSystemPreferredUILanguagesGetThreadLocaleGetThreadPreferredUILanguagesGetThreadUILanguageGetUILanguageInfoGetUserDefaultLCIDGetUserDefaultLangIDGetUserDefaultLocaleNameGetUserDefaultUILanguageGetUserGeoIDIsDBCSLeadByteIsDBCSLeadByteExIsNLSDefinedStringIsNormalizedStringNORM_FORMIsValidCodePageIsValidLanguageGroupIsValidLocaleIsValidLocaleNameIsValidNLSVersionLCIDToLocaleNameLCMapStringALCMapStringExLCMapStringWLocaleNameToLCIDNormalizeStringNotifyUILanguageChangeResolveLocaleNameSetCalendarInfoASetCalendarInfoWSetLocaleInfoASetLocaleInfoWSetProcessPreferredUILanguagesSetThreadLocaleSetThreadPreferredUILanguagesSetThreadUILanguageSetUserGeoIDVerifyScriptsexcptEXCEPTION_DISPOSITIONRTL_REFERENCE_COUNT32PRTL_REFERENCE_COUNT32MAXBYTEMAXWORDMAXDWORDPRODUCT_ENTERPRISEGPRODUCT_ENTERPRISEGNPRODUCT_CLOUDPRODUCT_CLOUDNMAXIMUM_WAIT_OBJECTSMAXIMUM_SUSPEND_COUNTKSPIN_LOCKPKSPIN_LOCKPM128AM128APXSAVE_FORMATXSAVE_FORMATPXSAVE_AREA_HEADERXSAVE_AREA_HEADERPXSAVE_AREAXSAVE_AREAPXSTATE_CONTEXTXSTATE_CONTEXTPSCOPE_TABLE_AMD64SCOPE_TABLE_AMD64PSCOPE_TABLE_ARM64SCOPE_TABLE_ARM64// Skip interlocked and bit manipulation stuff because it is all intrinsics// Use the native Rust equivalents instead// IFDEF(x86_64)// IFDEF(x86)LDT_ENTRY// IFDEF(aarch64)WOW64_CONTEXT_i386WOW64_CONTEXT_i486WOW64_CONTEXT_CONTROLWOW64_CONTEXT_INTEGERWOW64_CONTEXT_SEGMENTSWOW64_CONTEXT_FLOATING_POINTWOW64_CONTEXT_DEBUG_REGISTERSWOW64_CONTEXT_EXTENDED_REGISTERSWOW64_CONTEXT_FULLWOW64_CONTEXT_ALLWOW64_CONTEXT_XSTATEWOW64_CONTEXT_EXCEPTION_ACTIVEWOW64_CONTEXT_SERVICE_ACTIVEWOW64_CONTEXT_EXCEPTION_REQUESTWOW64_CONTEXT_EXCEPTION_REPORTINGWOW64_SIZE_OF_80387_REGISTERSWOW64_MAXIMUM_SUPPORTED_EXTENSIONPWOW64_FLOATING_SAVE_AREAWOW64_FLOATING_SAVE_AREAWOW64_LDT_ENTRYPWOW64_DESCRIPTOR_TABLE_ENTRYWOW64_DESCRIPTOR_TABLE_ENTRYEXCEPTION_NONCONTINUABLEEXCEPTION_UNWINDINGEXCEPTION_EXIT_UNWINDEXCEPTION_STACK_INVALIDEXCEPTION_NESTED_CALLEXCEPTION_TARGET_UNWINDEXCEPTION_COLLIDED_UNWINDEXCEPTION_UNWINDIS_UNWINDINGIS_DISPATCHINGIS_TARGET_UNWINDEXCEPTION_MAXIMUM_PARAMETERSPEXCEPTION_RECORD32EXCEPTION_RECORD32PEXCEPTION_RECORD64EXCEPTION_RECORD64PEXCEPTION_POINTERSPACCESS_TOKENREAD_CONTROLWRITE_DACWRITE_OWNERSTANDARD_RIGHTS_ALLSPECIFIC_RIGHTS_ALLACCESS_SYSTEM_SECURITYMAXIMUM_ALLOWEDGENERIC_EXECUTEGENERIC_ALLGENERIC_MAPPINGLUID_AND_ATTRIBUTESLUID_AND_ATTRIBUTES_ARRAYPLUID_AND_ATTRIBUTES_ARRAYSID_IDENTIFIER_AUTHORITYPISIDSID_REVISIONSID_MAX_SUB_AUTHORITIESSID_RECOMMENDED_SUB_AUTHORITIESSECURITY_MAX_SID_SIZESECURITY_MAX_SID_STRING_CHARACTERSPSE_SIDSE_SIDSID_AND_ATTRIBUTESSID_AND_ATTRIBUTES_ARRAYPSID_AND_ATTRIBUTES_ARRAYSID_HASH_SIZESID_HASH_ENTRYPSID_HASH_ENTRYPSID_AND_ATTRIBUTES_HASHSID_AND_ATTRIBUTES_HASHSECURITY_NULL_SID_AUTHORITYSECURITY_WORLD_SID_AUTHORITYSECURITY_LOCAL_SID_AUTHORITYSECURITY_CREATOR_SID_AUTHORITYSECURITY_NON_UNIQUE_AUTHORITYSECURITY_RESOURCE_MANAGER_AUTHORITYSECURITY_NULL_RIDSECURITY_WORLD_RIDSECURITY_LOCAL_RIDSECURITY_LOCAL_LOGON_RIDSECURITY_CREATOR_OWNER_RIDSECURITY_CREATOR_GROUP_RIDSECURITY_CREATOR_OWNER_SERVER_RIDSECURITY_CREATOR_GROUP_SERVER_RIDSECURITY_CREATOR_OWNER_RIGHTS_RIDSECURITY_NT_AUTHORITYSECURITY_DIALUP_RIDSECURITY_NETWORK_RIDSECURITY_BATCH_RIDSECURITY_INTERACTIVE_RIDSECURITY_LOGON_IDS_RIDSECURITY_LOGON_IDS_RID_COUNTSECURITY_SERVICE_RIDSECURITY_ANONYMOUS_LOGON_RIDSECURITY_PROXY_RIDSECURITY_ENTERPRISE_CONTROLLERS_RIDSECURITY_SERVER_LOGON_RIDSECURITY_PRINCIPAL_SELF_RIDSECURITY_AUTHENTICATED_USER_RIDSECURITY_RESTRICTED_CODE_RIDSECURITY_TERMINAL_SERVER_RIDSECURITY_REMOTE_LOGON_RIDSECURITY_THIS_ORGANIZATION_RIDSECURITY_IUSER_RIDSECURITY_LOCAL_SYSTEM_RIDSECURITY_LOCAL_SERVICE_RIDSECURITY_NETWORK_SERVICE_RIDSECURITY_NT_NON_UNIQUESECURITY_NT_NON_UNIQUE_SUB_AUTH_COUNTSECURITY_ENTERPRISE_READONLY_CONTROLLERS_RIDSECURITY_BUILTIN_DOMAIN_RIDSECURITY_WRITE_RESTRICTED_CODE_RIDSECURITY_PACKAGE_BASE_RIDSECURITY_PACKAGE_RID_COUNTSECURITY_PACKAGE_NTLM_RIDSECURITY_PACKAGE_SCHANNEL_RIDSECURITY_PACKAGE_DIGEST_RIDSECURITY_CRED_TYPE_BASE_RIDSECURITY_CRED_TYPE_RID_COUNTSECURITY_CRED_TYPE_THIS_ORG_CERT_RIDSECURITY_MIN_BASE_RIDSECURITY_SERVICE_ID_BASE_RIDSECURITY_SERVICE_ID_RID_COUNTSECURITY_RESERVED_ID_BASE_RIDSECURITY_APPPOOL_ID_BASE_RIDSECURITY_APPPOOL_ID_RID_COUNTSECURITY_VIRTUALSERVER_ID_BASE_RIDSECURITY_VIRTUALSERVER_ID_RID_COUNTSECURITY_USERMODEDRIVERHOST_ID_BASE_RIDSECURITY_USERMODEDRIVERHOST_ID_RID_COUNTSECURITY_CLOUD_INFRASTRUCTURE_SERVICES_ID_BASE_RIDSECURITY_CLOUD_INFRASTRUCTURE_SERVICES_ID_RID_COUNTSECURITY_WMIHOST_ID_BASE_RIDSECURITY_WMIHOST_ID_RID_COUNTSECURITY_TASK_ID_BASE_RIDSECURITY_NFS_ID_BASE_RIDSECURITY_COM_ID_BASE_RIDSECURITY_WINDOW_MANAGER_BASE_RIDSECURITY_RDV_GFX_BASE_RIDSECURITY_DASHOST_ID_BASE_RIDSECURITY_DASHOST_ID_RID_COUNTSECURITY_USERMANAGER_ID_BASE_RIDSECURITY_USERMANAGER_ID_RID_COUNTSECURITY_WINRM_ID_BASE_RIDSECURITY_WINRM_ID_RID_COUNTSECURITY_CCG_ID_BASE_RIDSECURITY_UMFD_BASE_RIDSECURITY_VIRTUALACCOUNT_ID_RID_COUNTSECURITY_MAX_BASE_RIDSECURITY_MAX_ALWAYS_FILTEREDSECURITY_MIN_NEVER_FILTEREDSECURITY_OTHER_ORGANIZATION_RIDSECURITY_WINDOWSMOBILE_ID_BASE_RIDSECURITY_INSTALLER_GROUP_CAPABILITY_BASESECURITY_INSTALLER_GROUP_CAPABILITY_RID_COUNTSECURITY_INSTALLER_CAPABILITY_RID_COUNTSECURITY_LOCAL_ACCOUNT_RIDSECURITY_LOCAL_ACCOUNT_AND_ADMIN_RIDDOMAIN_GROUP_RID_AUTHORIZATION_DATA_IS_COMPOUNDEDDOMAIN_GROUP_RID_AUTHORIZATION_DATA_CONTAINS_CLAIMSDOMAIN_GROUP_RID_ENTERPRISE_READONLY_DOMAIN_CONTROLLERSFOREST_USER_RID_MAXDOMAIN_USER_RID_ADMINDOMAIN_USER_RID_GUESTDOMAIN_USER_RID_KRBTGTDOMAIN_USER_RID_DEFAULT_ACCOUNTDOMAIN_USER_RID_MAXDOMAIN_GROUP_RID_ADMINSDOMAIN_GROUP_RID_USERSDOMAIN_GROUP_RID_GUESTSDOMAIN_GROUP_RID_COMPUTERSDOMAIN_GROUP_RID_CONTROLLERSDOMAIN_GROUP_RID_CERT_ADMINSDOMAIN_GROUP_RID_SCHEMA_ADMINSDOMAIN_GROUP_RID_ENTERPRISE_ADMINSDOMAIN_GROUP_RID_POLICY_ADMINSDOMAIN_GROUP_RID_READONLY_CONTROLLERSDOMAIN_GROUP_RID_CLONEABLE_CONTROLLERSDOMAIN_GROUP_RID_CDC_RESERVEDDOMAIN_GROUP_RID_PROTECTED_USERSDOMAIN_GROUP_RID_KEY_ADMINSDOMAIN_GROUP_RID_ENTERPRISE_KEY_ADMINSDOMAIN_ALIAS_RID_ADMINSDOMAIN_ALIAS_RID_USERSDOMAIN_ALIAS_RID_GUESTSDOMAIN_ALIAS_RID_POWER_USERSDOMAIN_ALIAS_RID_ACCOUNT_OPSDOMAIN_ALIAS_RID_SYSTEM_OPSDOMAIN_ALIAS_RID_PRINT_OPSDOMAIN_ALIAS_RID_BACKUP_OPSDOMAIN_ALIAS_RID_REPLICATORDOMAIN_ALIAS_RID_RAS_SERVERSDOMAIN_ALIAS_RID_PREW2KCOMPACCESSDOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERSDOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPSDOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERSDOMAIN_ALIAS_RID_MONITORING_USERSDOMAIN_ALIAS_RID_LOGGING_USERSDOMAIN_ALIAS_RID_AUTHORIZATIONACCESSDOMAIN_ALIAS_RID_TS_LICENSE_SERVERSDOMAIN_ALIAS_RID_DCOM_USERSDOMAIN_ALIAS_RID_IUSERSDOMAIN_ALIAS_RID_CRYPTO_OPERATORSDOMAIN_ALIAS_RID_CACHEABLE_PRINCIPALS_GROUPDOMAIN_ALIAS_RID_NON_CACHEABLE_PRINCIPALS_GROUPDOMAIN_ALIAS_RID_EVENT_LOG_READERS_GROUPDOMAIN_ALIAS_RID_CERTSVC_DCOM_ACCESS_GROUPDOMAIN_ALIAS_RID_RDS_REMOTE_ACCESS_SERVERSDOMAIN_ALIAS_RID_RDS_ENDPOINT_SERVERSDOMAIN_ALIAS_RID_RDS_MANAGEMENT_SERVERSDOMAIN_ALIAS_RID_HYPER_V_ADMINSDOMAIN_ALIAS_RID_ACCESS_CONTROL_ASSISTANCE_OPSDOMAIN_ALIAS_RID_REMOTE_MANAGEMENT_USERSDOMAIN_ALIAS_RID_DEFAULT_ACCOUNTDOMAIN_ALIAS_RID_STORAGE_REPLICA_ADMINSSECURITY_APP_PACKAGE_AUTHORITYSECURITY_APP_PACKAGE_BASE_RIDSECURITY_BUILTIN_APP_PACKAGE_RID_COUNTSECURITY_APP_PACKAGE_RID_COUNTSECURITY_CAPABILITY_BASE_RIDSECURITY_CAPABILITY_APP_RIDSECURITY_BUILTIN_CAPABILITY_RID_COUNTSECURITY_CAPABILITY_RID_COUNTSECURITY_PARENT_PACKAGE_RID_COUNTSECURITY_CHILD_PACKAGE_RID_COUNTSECURITY_BUILTIN_PACKAGE_ANY_PACKAGESECURITY_BUILTIN_PACKAGE_ANY_RESTRICTED_PACKAGESECURITY_CAPABILITY_INTERNET_CLIENTSECURITY_CAPABILITY_INTERNET_CLIENT_SERVERSECURITY_CAPABILITY_PRIVATE_NETWORK_CLIENT_SERVERSECURITY_CAPABILITY_PICTURES_LIBRARYSECURITY_CAPABILITY_VIDEOS_LIBRARYSECURITY_CAPABILITY_MUSIC_LIBRARYSECURITY_CAPABILITY_DOCUMENTS_LIBRARYSECURITY_CAPABILITY_ENTERPRISE_AUTHENTICATIONSECURITY_CAPABILITY_SHARED_USER_CERTIFICATESSECURITY_CAPABILITY_REMOVABLE_STORAGESECURITY_CAPABILITY_APPOINTMENTSSECURITY_CAPABILITY_CONTACTSSECURITY_CAPABILITY_INTERNET_EXPLORERSECURITY_MANDATORY_LABEL_AUTHORITYSECURITY_MANDATORY_UNTRUSTED_RIDSECURITY_MANDATORY_LOW_RIDSECURITY_MANDATORY_MEDIUM_RIDSECURITY_MANDATORY_MEDIUM_PLUS_RIDSECURITY_MANDATORY_HIGH_RIDSECURITY_MANDATORY_SYSTEM_RIDSECURITY_MANDATORY_MAXIMUM_USER_RIDMANDATORY_LEVEL_TO_MANDATORY_RIDSECURITY_SCOPED_POLICY_ID_AUTHORITYSECURITY_AUTHENTICATION_AUTHORITYSECURITY_AUTHENTICATION_AUTHORITY_RID_COUNTSECURITY_AUTHENTICATION_AUTHORITY_ASSERTED_RIDSECURITY_AUTHENTICATION_SERVICE_ASSERTED_RIDSECURITY_AUTHENTICATION_FRESH_KEY_AUTH_RIDSECURITY_AUTHENTICATION_KEY_TRUST_RIDSECURITY_AUTHENTICATION_KEY_PROPERTY_MFA_RIDSECURITY_AUTHENTICATION_KEY_PROPERTY_ATTESTATION_RIDSECURITY_PROCESS_TRUST_AUTHORITYSECURITY_PROCESS_TRUST_AUTHORITY_RID_COUNTSECURITY_PROCESS_PROTECTION_TYPE_FULL_RIDSECURITY_PROCESS_PROTECTION_TYPE_LITE_RIDSECURITY_PROCESS_PROTECTION_TYPE_NONE_RIDSECURITY_PROCESS_PROTECTION_LEVEL_WINTCB_RIDSECURITY_PROCESS_PROTECTION_LEVEL_WINDOWS_RIDSECURITY_PROCESS_PROTECTION_LEVEL_APP_RIDSECURITY_PROCESS_PROTECTION_LEVEL_NONE_RIDSECURITY_TRUSTED_INSTALLER_RID1SECURITY_TRUSTED_INSTALLER_RID2SECURITY_TRUSTED_INSTALLER_RID3SECURITY_TRUSTED_INSTALLER_RID4SECURITY_TRUSTED_INSTALLER_RID5SYSTEM_LUIDANONYMOUS_LOGON_LUIDLOCALSERVICE_LUIDNETWORKSERVICE_LUIDIUSER_LUIDSE_GROUP_MANDATORYSE_GROUP_ENABLED_BY_DEFAULTSE_GROUP_ENABLEDSE_GROUP_OWNERSE_GROUP_USE_FOR_DENY_ONLYSE_GROUP_INTEGRITYSE_GROUP_INTEGRITY_ENABLEDSE_GROUP_LOGON_IDSE_GROUP_RESOURCESE_GROUP_VALID_ATTRIBUTESACL_REVISIONACL_REVISION_DSACL_REVISION1MIN_ACL_REVISIONACL_REVISION2ACL_REVISION3ACL_REVISION4MAX_ACL_REVISIONPACE_HEADERACE_HEADERACCESS_MIN_MS_ACE_TYPEACCESS_ALLOWED_ACE_TYPEACCESS_DENIED_ACE_TYPESYSTEM_AUDIT_ACE_TYPESYSTEM_ALARM_ACE_TYPEACCESS_MAX_MS_V2_ACE_TYPEACCESS_ALLOWED_COMPOUND_ACE_TYPEACCESS_MAX_MS_V3_ACE_TYPEACCESS_MIN_MS_OBJECT_ACE_TYPEACCESS_ALLOWED_OBJECT_ACE_TYPEACCESS_DENIED_OBJECT_ACE_TYPESYSTEM_AUDIT_OBJECT_ACE_TYPESYSTEM_ALARM_OBJECT_ACE_TYPEACCESS_MAX_MS_OBJECT_ACE_TYPEACCESS_MAX_MS_V4_ACE_TYPEACCESS_MAX_MS_ACE_TYPEACCESS_ALLOWED_CALLBACK_ACE_TYPEACCESS_DENIED_CALLBACK_ACE_TYPEACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPEACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPESYSTEM_AUDIT_CALLBACK_ACE_TYPESYSTEM_ALARM_CALLBACK_ACE_TYPESYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPESYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPESYSTEM_MANDATORY_LABEL_ACE_TYPESYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPESYSTEM_SCOPED_POLICY_ID_ACE_TYPESYSTEM_PROCESS_TRUST_LABEL_ACE_TYPESYSTEM_ACCESS_FILTER_ACE_TYPEACCESS_MAX_MS_V5_ACE_TYPEOBJECT_INHERIT_ACECONTAINER_INHERIT_ACENO_PROPAGATE_INHERIT_ACEINHERIT_ONLY_ACEINHERITED_ACEVALID_INHERIT_FLAGSSUCCESSFUL_ACCESS_ACE_FLAGFAILED_ACCESS_ACE_FLAGTRUST_PROTECTED_FILTER_ACE_FLAGPACCESS_ALLOWED_ACEACCESS_ALLOWED_ACEPACCESS_DENIED_ACEACCESS_DENIED_ACEPSYSTEM_AUDIT_ACESYSTEM_AUDIT_ACEPSYSTEM_ALARM_ACESYSTEM_ALARM_ACEPSYSTEM_RESOURCE_ATTRIBUTE_ACESYSTEM_RESOURCE_ATTRIBUTE_ACEPSYSTEM_SCOPED_POLICY_ID_ACESYSTEM_SCOPED_POLICY_ID_ACEPSYSTEM_MANDATORY_LABEL_ACESYSTEM_MANDATORY_LABEL_ACEPSYSTEM_PROCESS_TRUST_LABEL_ACESYSTEM_PROCESS_TRUST_LABEL_ACEPSYSTEM_ACCESS_FILTER_ACESYSTEM_ACCESS_FILTER_ACESYSTEM_MANDATORY_LABEL_NO_WRITE_UPSYSTEM_MANDATORY_LABEL_NO_READ_UPSYSTEM_MANDATORY_LABEL_NO_EXECUTE_UPSYSTEM_MANDATORY_LABEL_VALID_MASKSYSTEM_PROCESS_TRUST_LABEL_VALID_MASKSYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASKSYSTEM_ACCESS_FILTER_VALID_MASKSYSTEM_ACCESS_FILTER_NOCONSTRAINT_MASKPACCESS_ALLOWED_OBJECT_ACEACCESS_ALLOWED_OBJECT_ACEPACCESS_DENIED_OBJECT_ACEACCESS_DENIED_OBJECT_ACEPSYSTEM_AUDIT_OBJECT_ACESYSTEM_AUDIT_OBJECT_ACEPSYSTEM_ALARM_OBJECT_ACESYSTEM_ALARM_OBJECT_ACEPACCESS_ALLOWED_CALLBACK_ACEACCESS_ALLOWED_CALLBACK_ACEPACCESS_DENIED_CALLBACK_ACEACCESS_DENIED_CALLBACK_ACEPSYSTEM_AUDIT_CALLBACK_ACESYSTEM_AUDIT_CALLBACK_ACEPSYSTEM_ALARM_CALLBACK_ACESYSTEM_ALARM_CALLBACK_ACEPACCESS_ALLOWED_CALLBACK_OBJECT_ACEACCESS_ALLOWED_CALLBACK_OBJECT_ACEPACCESS_DENIED_CALLBACK_OBJECT_ACEACCESS_DENIED_CALLBACK_OBJECT_ACEPSYSTEM_AUDIT_CALLBACK_OBJECT_ACESYSTEM_AUDIT_CALLBACK_OBJECT_ACEPSYSTEM_ALARM_CALLBACK_OBJECT_ACESYSTEM_ALARM_CALLBACK_OBJECT_ACEACE_OBJECT_TYPE_PRESENTACE_INHERITED_OBJECT_TYPE_PRESENTPACL_REVISION_INFORMATIONACL_REVISION_INFORMATIONPACL_SIZE_INFORMATIONACL_SIZE_INFORMATIONSECURITY_DESCRIPTOR_REVISIONSECURITY_DESCRIPTOR_REVISION1SECURITY_DESCRIPTOR_MIN_LENGTHSE_OWNER_DEFAULTEDSE_GROUP_DEFAULTEDSE_DACL_PRESENTSE_DACL_DEFAULTEDSE_SACL_PRESENTSE_SACL_DEFAULTEDSE_DACL_AUTO_INHERIT_REQSE_SACL_AUTO_INHERIT_REQSE_DACL_AUTO_INHERITEDSE_SACL_AUTO_INHERITEDSE_DACL_PROTECTEDSE_SACL_PROTECTEDSE_RM_CONTROL_VALIDSE_SELF_RELATIVEPISECURITY_DESCRIPTOR_RELATIVESECURITY_DESCRIPTOR_RELATIVEPISECURITY_DESCRIPTORSECURITY_DESCRIPTORPSECURITY_OBJECT_AI_PARAMSSECURITY_OBJECT_AI_PARAMSOBJECT_TYPE_LISTACCESS_OBJECT_GUIDACCESS_PROPERTY_SET_GUIDACCESS_PROPERTY_GUIDACCESS_MAX_LEVELAUDIT_ALLOW_NO_PRIVILEGEACCESS_DS_SOURCEACCESS_DS_OBJECT_TYPE_NAMESE_PRIVILEGE_ENABLED_BY_DEFAULTSE_PRIVILEGE_REMOVEDSE_PRIVILEGE_USED_FOR_ACCESSSE_PRIVILEGE_VALID_ATTRIBUTESPRIVILEGE_SET_ALL_NECESSARYPRIVILEGE_SETACCESS_REASON_TYPE_MASKACCESS_REASONACCESS_REASON_DATA_MASKACCESS_REASON_STAGING_MASKACCESS_REASON_EXDATA_MASKPACCESS_REASONSACCESS_REASONSSE_SECURITY_DESCRIPTOR_FLAG_NO_OWNER_ACESE_SECURITY_DESCRIPTOR_FLAG_NO_LABEL_ACESE_SECURITY_DESCRIPTOR_FLAG_NO_ACCESS_FILTER_ACESE_SECURITY_DESCRIPTOR_VALID_FLAGSPSE_SECURITY_DESCRIPTORSE_SECURITY_DESCRIPTORPSE_ACCESS_REQUESTSE_ACCESS_REQUESTPSE_ACCESS_REPLYSE_ACCESS_REPLYSE_CREATE_TOKEN_NAMESE_ASSIGNPRIMARYTOKEN_NAMESE_LOCK_MEMORY_NAMESE_INCREASE_QUOTA_NAMESE_UNSOLICITED_INPUT_NAMESE_MACHINE_ACCOUNT_NAMESE_TCB_NAMESE_SECURITY_NAMESE_TAKE_OWNERSHIP_NAMESE_LOAD_DRIVER_NAMESE_SYSTEM_PROFILE_NAMESE_SYSTEMTIME_NAMESE_PROF_SINGLE_PROCESS_NAMESE_INC_BASE_PRIORITY_NAMESE_CREATE_PAGEFILE_NAMESE_CREATE_PERMANENT_NAMESE_BACKUP_NAMESE_RESTORE_NAMESE_DEBUG_NAMESE_AUDIT_NAMESE_SYSTEM_ENVIRONMENT_NAMESE_CHANGE_NOTIFY_NAMESE_REMOTE_SHUTDOWN_NAMESE_UNDOCK_NAMESE_SYNC_AGENT_NAMESE_ENABLE_DELEGATION_NAMESE_MANAGE_VOLUME_NAMESE_IMPERSONATE_NAMESE_CREATE_GLOBAL_NAMESE_TRUSTED_CREDMAN_ACCESS_NAMESE_RELABEL_NAMESE_INC_WORKING_SET_NAMESE_TIME_ZONE_NAMESE_CREATE_SYMBOLIC_LINK_NAMESE_DELEGATE_SESSION_USER_IMPERSONATE_NAMESE_ACTIVATE_AS_USER_CAPABILITYSE_CONSTRAINED_IMPERSONATION_CAPABILITYSE_SESSION_IMPERSONATION_CAPABILITYSE_MUMA_CAPABILITYSE_DEVELOPMENT_MODE_NETWORK_CAPABILITYPSECURITY_IMPERSONATION_LEVELSECURITY_MAX_IMPERSONATION_LEVELSECURITY_MIN_IMPERSONATION_LEVELDEFAULT_IMPERSONATION_LEVELVALID_IMPERSONATION_LEVELTOKEN_ASSIGN_PRIMARYTOKEN_DUPLICATETOKEN_IMPERSONATETOKEN_QUERY_SOURCETOKEN_ADJUST_GROUPSTOKEN_ADJUST_DEFAULTTOKEN_ADJUST_SESSIONIDTOKEN_ALL_ACCESS_PTOKEN_ALL_ACCESSTOKEN_READTOKEN_WRITETOKEN_EXECUTETOKEN_TRUST_CONSTRAINT_MASKTOKEN_ACCESS_PSEUDO_HANDLE_WIN8TOKEN_ACCESS_PSEUDO_HANDLEPTOKEN_TYPEPTOKEN_ELEVATION_TYPETOKEN_ELEVATION_TYPEPTOKEN_INFORMATION_CLASSPTOKEN_USERPSE_TOKEN_USERSE_TOKEN_USERTOKEN_GROUPSPTOKEN_OWNERPTOKEN_PRIMARY_GROUPPTOKEN_DEFAULT_DACLPTOKEN_USER_CLAIMSPTOKEN_DEVICE_CLAIMSPTOKEN_GROUPS_AND_PRIVILEGESTOKEN_GROUPS_AND_PRIVILEGESPTOKEN_LINKED_TOKENTOKEN_LINKED_TOKENPTOKEN_ELEVATIONTOKEN_ELEVATIONPTOKEN_MANDATORY_LABELTOKEN_MANDATORY_LABELTOKEN_MANDATORY_POLICY_OFFTOKEN_MANDATORY_POLICY_NO_WRITE_UPTOKEN_MANDATORY_POLICY_NEW_PROCESS_MINTOKEN_MANDATORY_POLICY_VALID_MASKPTOKEN_MANDATORY_POLICYTOKEN_MANDATORY_POLICYPSECURITY_ATTRIBUTES_OPAQUEPTOKEN_ACCESS_INFORMATIONTOKEN_ACCESS_INFORMATIONPOLICY_AUDIT_SUBCATEGORY_COUNTPTOKEN_AUDIT_POLICYTOKEN_AUDIT_POLICYTOKEN_SOURCE_LENGTHTOKEN_SOURCEPTOKEN_STATISTICSTOKEN_STATISTICSPTOKEN_CONTROLTOKEN_CONTROLPTOKEN_ORIGINTOKEN_ORIGINPMANDATORY_LEVELMANDATORY_LEVELPTOKEN_APPCONTAINER_INFORMATIONTOKEN_APPCONTAINER_INFORMATIONPTOKEN_SID_INFORMATIONTOKEN_SID_INFORMATIONPTOKEN_BNO_ISOLATION_INFORMATIONTOKEN_BNO_ISOLATION_INFORMATIONCLAIM_SECURITY_ATTRIBUTE_TYPE_INVALIDCLAIM_SECURITY_ATTRIBUTE_TYPE_INT64CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64CLAIM_SECURITY_ATTRIBUTE_TYPE_STRINGPCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUECLAIM_SECURITY_ATTRIBUTE_FQBN_VALUECLAIM_SECURITY_ATTRIBUTE_TYPE_FQBNCLAIM_SECURITY_ATTRIBUTE_TYPE_SIDCLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEANPCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUECLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUECLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRINGCLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLECLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVECLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLYCLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULTCLAIM_SECURITY_ATTRIBUTE_DISABLEDCLAIM_SECURITY_ATTRIBUTE_MANDATORYCLAIM_SECURITY_ATTRIBUTE_VALID_FLAGSCLAIM_SECURITY_ATTRIBUTE_CUSTOM_FLAGSPCLAIM_SECURITY_ATTRIBUTE_V1CLAIM_SECURITY_ATTRIBUTE_V1PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSIONCLAIM_SECURITY_ATTRIBUTES_INFORMATIONSECURITY_DYNAMIC_TRACKINGSECURITY_STATIC_TRACKINGSECURITY_CONTEXT_TRACKING_MODEPSECURITY_CONTEXT_TRACKING_MODEPSECURITY_QUALITY_OF_SERVICESECURITY_QUALITY_OF_SERVICEPSE_IMPERSONATION_STATESE_IMPERSONATION_STATEDISABLE_MAX_PRIVILEGESANDBOX_INERTLUA_TOKENWRITE_RESTRICTEDPSECURITY_INFORMATIONOWNER_SECURITY_INFORMATIONGROUP_SECURITY_INFORMATIONDACL_SECURITY_INFORMATIONSACL_SECURITY_INFORMATIONLABEL_SECURITY_INFORMATIONATTRIBUTE_SECURITY_INFORMATIONSCOPE_SECURITY_INFORMATIONPROCESS_TRUST_LABEL_SECURITY_INFORMATIONACCESS_FILTER_SECURITY_INFORMATIONBACKUP_SECURITY_INFORMATIONPROTECTED_DACL_SECURITY_INFORMATIONPROTECTED_SACL_SECURITY_INFORMATIONUNPROTECTED_DACL_SECURITY_INFORMATIONUNPROTECTED_SACL_SECURITY_INFORMATIONSE_SIGNING_LEVELPSE_SIGNING_LEVELSE_SIGNING_LEVEL_UNCHECKEDSE_SIGNING_LEVEL_UNSIGNEDSE_SIGNING_LEVEL_ENTERPRISESE_SIGNING_LEVEL_CUSTOM_1SE_SIGNING_LEVEL_AUTHENTICODESE_SIGNING_LEVEL_CUSTOM_2SE_SIGNING_LEVEL_STORESE_SIGNING_LEVEL_CUSTOM_3SE_SIGNING_LEVEL_ANTIMALWARESE_SIGNING_LEVEL_MICROSOFTSE_SIGNING_LEVEL_CUSTOM_4SE_SIGNING_LEVEL_CUSTOM_5SE_SIGNING_LEVEL_DYNAMIC_CODEGENSE_SIGNING_LEVEL_WINDOWSSE_SIGNING_LEVEL_CUSTOM_7SE_SIGNING_LEVEL_WINDOWS_TCBSE_SIGNING_LEVEL_CUSTOM_6PSE_IMAGE_SIGNATURE_TYPESE_IMAGE_SIGNATURE_TYPEPSECURITY_CAPABILITIESSECURITY_CAPABILITIESLPSECURITY_CAPABILITIESPROCESS_TERMINATEPROCESS_CREATE_THREADPROCESS_SET_SESSIONIDPROCESS_VM_OPERATIONPROCESS_VM_WRITEPROCESS_DUP_HANDLEPROCESS_CREATE_PROCESSPROCESS_SET_QUOTAPROCESS_SET_INFORMATIONPROCESS_SUSPEND_RESUMEPROCESS_SET_LIMITED_INFORMATIONPROCESS_ALL_ACCESSTHREAD_TERMINATETHREAD_SUSPEND_RESUMETHREAD_GET_CONTEXTTHREAD_SET_CONTEXTTHREAD_QUERY_INFORMATIONTHREAD_SET_INFORMATIONTHREAD_SET_THREAD_TOKENTHREAD_IMPERSONATETHREAD_DIRECT_IMPERSONATIONTHREAD_SET_LIMITED_INFORMATIONTHREAD_QUERY_LIMITED_INFORMATIONTHREAD_RESUMETHREAD_ALL_ACCESSJOB_OBJECT_ASSIGN_PROCESSJOB_OBJECT_SET_ATTRIBUTESJOB_OBJECT_QUERYJOB_OBJECT_TERMINATEJOB_OBJECT_SET_SECURITY_ATTRIBUTESJOB_OBJECT_IMPERSONATEJOB_OBJECT_ALL_ACCESSJOB_SET_ARRAYFLS_MAXIMUM_AVAILABLETLS_MINIMUM_AVAILABLEPEXCEPTION_REGISTRATION_RECORDEXCEPTION_REGISTRATION_RECORDPNT_TIBNT_TIBPNT_TIB32NT_TIB32PNT_TIB64NT_TIB64THREAD_DYNAMIC_CODE_ALLOWPUMS_CREATE_THREAD_ATTRIBUTESUMS_CREATE_THREAD_ATTRIBUTESPWOW64_ARCHITECTURE_INFORMATIONWOW64_ARCHITECTURE_INFORMATIONMEMORY_PRIORITY_LOWESTMEMORY_PRIORITY_VERY_LOWMEMORY_PRIORITY_LOWMEMORY_PRIORITY_MEDIUMMEMORY_PRIORITY_BELOW_NORMALMEMORY_PRIORITY_NORMALQUOTA_LIMITS_HARDWS_MIN_ENABLEQUOTA_LIMITS_HARDWS_MIN_DISABLEQUOTA_LIMITS_HARDWS_MAX_ENABLEQUOTA_LIMITS_HARDWS_MAX_DISABLEQUOTA_LIMITS_USE_DEFAULT_LIMITSPRATE_QUOTA_LIMITRATE_QUOTA_LIMITPQUOTA_LIMITS_EXQUOTA_LIMITS_EXMAX_HW_COUNTERSTHREAD_PROFILING_FLAG_DISPATCHPHARDWARE_COUNTER_TYPEHARDWARE_COUNTER_TYPEPPROCESS_MITIGATION_POLICYPPROCESS_MITIGATION_ASLR_POLICYPROCESS_MITIGATION_ASLR_POLICYPPROCESS_MITIGATION_DEP_POLICYPROCESS_MITIGATION_DEP_POLICYPPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICYPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICYPPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICYPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICYPPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICYPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICYPPROCESS_MITIGATION_DYNAMIC_CODE_POLICYPROCESS_MITIGATION_DYNAMIC_CODE_POLICYPPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICYPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICYPPROCESS_MITIGATION_BINARY_SIGNATURE_POLICYPROCESS_MITIGATION_BINARY_SIGNATURE_POLICYPPROCESS_MITIGATION_FONT_DISABLE_POLICYPROCESS_MITIGATION_FONT_DISABLE_POLICYPPROCESS_MITIGATION_IMAGE_LOAD_POLICYPROCESS_MITIGATION_IMAGE_LOAD_POLICYPPPROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICYPROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICYPPROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICYPROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICYPPROCESS_MITIGATION_CHILD_PROCESS_POLICYPROCESS_MITIGATION_CHILD_PROCESS_POLICYPJOBOBJECT_BASIC_ACCOUNTING_INFORMATIONJOBOBJECT_BASIC_ACCOUNTING_INFORMATIONPJOBOBJECT_BASIC_LIMIT_INFORMATIONJOBOBJECT_BASIC_LIMIT_INFORMATIONPJOBOBJECT_EXTENDED_LIMIT_INFORMATIONJOBOBJECT_EXTENDED_LIMIT_INFORMATIONPJOBOBJECT_BASIC_PROCESS_ID_LISTJOBOBJECT_BASIC_PROCESS_ID_LISTPJOBOBJECT_BASIC_UI_RESTRICTIONSJOBOBJECT_BASIC_UI_RESTRICTIONSPJOBOBJECT_SECURITY_LIMIT_INFORMATIONJOBOBJECT_SECURITY_LIMIT_INFORMATIONPJOBOBJECT_END_OF_JOB_TIME_INFORMATIONJOBOBJECT_END_OF_JOB_TIME_INFORMATIONPJOBOBJECT_ASSOCIATE_COMPLETION_PORTJOBOBJECT_ASSOCIATE_COMPLETION_PORTPJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATIONJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATIONPJOBOBJECT_JOBSET_INFORMATIONJOBOBJECT_JOBSET_INFORMATIONPJOBOBJECT_RATE_CONTROL_TOLERANCEJOBOBJECT_RATE_CONTROL_TOLERANCEPJOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVALJOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVALPJOBOBJECT_NOTIFICATION_LIMIT_INFORMATIONJOBOBJECT_NOTIFICATION_LIMIT_INFORMATIONPJOBOBJECT_LIMIT_VIOLATION_INFORMATIONJOBOBJECT_LIMIT_VIOLATION_INFORMATIONPJOBOBJECT_CPU_RATE_CONTROL_INFORMATIONJOBOBJECT_CPU_RATE_CONTROL_INFORMATIONJOB_OBJECT_NET_RATE_CONTROL_MAX_DSCP_TAGJOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V1JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVEPJOBOBJECT_IO_ATTRIBUTION_STATSJOBOBJECT_IO_ATTRIBUTION_STATSPJOBOBJECT_IO_ATTRIBUTION_INFORMATIONJOBOBJECT_IO_ATTRIBUTION_INFORMATIONJOB_OBJECT_TERMINATE_AT_END_OF_JOBJOB_OBJECT_POST_AT_END_OF_JOBJOB_OBJECT_MSG_END_OF_JOB_TIMEJOB_OBJECT_MSG_END_OF_PROCESS_TIMEJOB_OBJECT_MSG_ACTIVE_PROCESS_LIMITJOB_OBJECT_MSG_ACTIVE_PROCESS_ZEROJOB_OBJECT_MSG_NEW_PROCESSJOB_OBJECT_MSG_EXIT_PROCESSJOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESSJOB_OBJECT_MSG_PROCESS_MEMORY_LIMITJOB_OBJECT_MSG_JOB_MEMORY_LIMITJOB_OBJECT_MSG_NOTIFICATION_LIMITJOB_OBJECT_MSG_JOB_CYCLE_TIME_LIMITJOB_OBJECT_MSG_SILO_TERMINATEDJOB_OBJECT_MSG_MINIMUMJOB_OBJECT_MSG_MAXIMUMJOB_OBJECT_VALID_COMPLETION_FILTERJOB_OBJECT_LIMIT_WORKINGSETJOB_OBJECT_LIMIT_PROCESS_TIMEJOB_OBJECT_LIMIT_JOB_TIMEJOB_OBJECT_LIMIT_ACTIVE_PROCESSJOB_OBJECT_LIMIT_AFFINITYJOB_OBJECT_LIMIT_PRIORITY_CLASSJOB_OBJECT_LIMIT_PRESERVE_JOB_TIMEJOB_OBJECT_LIMIT_SCHEDULING_CLASSJOB_OBJECT_LIMIT_PROCESS_MEMORYJOB_OBJECT_LIMIT_JOB_MEMORYJOB_OBJECT_LIMIT_JOB_MEMORY_HIGHJOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTIONJOB_OBJECT_LIMIT_BREAKAWAY_OKJOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OKJOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSEJOB_OBJECT_LIMIT_SUBSET_AFFINITYJOB_OBJECT_LIMIT_JOB_MEMORY_LOWJOB_OBJECT_LIMIT_JOB_READ_BYTESJOB_OBJECT_LIMIT_JOB_WRITE_BYTESJOB_OBJECT_LIMIT_RATE_CONTROLJOB_OBJECT_LIMIT_CPU_RATE_CONTROLJOB_OBJECT_LIMIT_IO_RATE_CONTROLJOB_OBJECT_LIMIT_NET_RATE_CONTROLJOB_OBJECT_LIMIT_VALID_FLAGSJOB_OBJECT_BASIC_LIMIT_VALID_FLAGSJOB_OBJECT_EXTENDED_LIMIT_VALID_FLAGSJOB_OBJECT_NOTIFICATION_LIMIT_VALID_FLAGSJOB_OBJECT_UILIMIT_NONEJOB_OBJECT_UILIMIT_HANDLESJOB_OBJECT_UILIMIT_READCLIPBOARDJOB_OBJECT_UILIMIT_WRITECLIPBOARDJOB_OBJECT_UILIMIT_SYSTEMPARAMETERSJOB_OBJECT_UILIMIT_DISPLAYSETTINGSJOB_OBJECT_UILIMIT_GLOBALATOMSJOB_OBJECT_UILIMIT_DESKTOPJOB_OBJECT_UILIMIT_EXITWINDOWSJOB_OBJECT_UILIMIT_ALLJOB_OBJECT_UI_VALID_FLAGSJOB_OBJECT_SECURITY_NO_ADMINJOB_OBJECT_SECURITY_RESTRICTED_TOKENJOB_OBJECT_SECURITY_ONLY_TOKENJOB_OBJECT_SECURITY_FILTER_TOKENSJOB_OBJECT_SECURITY_VALID_FLAGSJOB_OBJECT_CPU_RATE_CONTROL_ENABLEJOB_OBJECT_CPU_RATE_CONTROL_WEIGHT_BASEDJOB_OBJECT_CPU_RATE_CONTROL_HARD_CAPJOB_OBJECT_CPU_RATE_CONTROL_NOTIFYJOB_OBJECT_CPU_RATE_CONTROL_MIN_MAX_RATEJOB_OBJECT_CPU_RATE_CONTROL_VALID_FLAGSPSILOOBJECT_BASIC_INFORMATIONSILOOBJECT_BASIC_INFORMATIONPSERVERSILO_STATESERVERSILO_STATEPSERVERSILO_BASIC_INFORMATIONSERVERSILO_BASIC_INFORMATIONFIRMWARE_TYPEEVENT_MODIFY_STATEEVENT_ALL_ACCESSMUTANT_QUERY_STATEMUTANT_ALL_ACCESSSEMAPHORE_ALL_ACCESSTIMER_QUERY_STATETIMER_MODIFY_STATETIMER_ALL_ACCESSTIME_ZONE_ID_UNKNOWNTIME_ZONE_ID_STANDARDTIME_ZONE_ID_DAYLIGHTLTP_PC_SMTCACHE_FULLY_ASSOCIATIVEPCACHE_DESCRIPTORCACHE_DESCRIPTORSYSTEM_LOGICAL_PROCESSOR_INFORMATIONPPROCESSOR_RELATIONSHIPPROCESSOR_RELATIONSHIPPNUMA_NODE_RELATIONSHIPNUMA_NODE_RELATIONSHIPPCACHE_RELATIONSHIPCACHE_RELATIONSHIPPPROCESSOR_GROUP_INFOPROCESSOR_GROUP_INFOPGROUP_RELATIONSHIPGROUP_RELATIONSHIPPSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EXPCPU_SET_INFORMATION_TYPECPU_SET_INFORMATION_TYPESYSTEM_CPU_SET_INFORMATION_PARKEDSYSTEM_CPU_SET_INFORMATION_ALLOCATEDSYSTEM_CPU_SET_INFORMATION_ALLOCATED_TO_TARGET_PROCESSSYSTEM_CPU_SET_INFORMATION_REALTIMEPSYSTEM_CPU_SET_INFORMATIONSYSTEM_CPU_SET_INFORMATIONSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATIONPROCESSOR_INTEL_386PROCESSOR_INTEL_486PROCESSOR_INTEL_PENTIUMPROCESSOR_INTEL_IA64PROCESSOR_AMD_X8664PROCESSOR_MIPS_R4000PROCESSOR_ALPHA_21064PROCESSOR_PPC_601PROCESSOR_PPC_603PROCESSOR_PPC_604PROCESSOR_PPC_620PROCESSOR_HITACHI_SH3PROCESSOR_HITACHI_SH3EPROCESSOR_HITACHI_SH4PROCESSOR_MOTOROLA_821PROCESSOR_SHx_SH3PROCESSOR_SHx_SH4PROCESSOR_STRONGARMPROCESSOR_ARM720PROCESSOR_ARM820PROCESSOR_ARM920PROCESSOR_ARM_7TDMIPROCESSOR_OPTILPROCESSOR_ARCHITECTURE_MIPSPROCESSOR_ARCHITECTURE_ALPHAPROCESSOR_ARCHITECTURE_PPCPROCESSOR_ARCHITECTURE_SHXPROCESSOR_ARCHITECTURE_ARMPROCESSOR_ARCHITECTURE_IA64PROCESSOR_ARCHITECTURE_ALPHA64PROCESSOR_ARCHITECTURE_MSILPROCESSOR_ARCHITECTURE_IA32_ON_WIN64PROCESSOR_ARCHITECTURE_NEUTRALPROCESSOR_ARCHITECTURE_ARM32_ON_WIN64PROCESSOR_ARCHITECTURE_IA32_ON_ARM64PROCESSOR_ARCHITECTURE_UNKNOWNPF_FLOATING_POINT_PRECISION_ERRATAPF_FLOATING_POINT_EMULATEDPF_COMPARE_EXCHANGE_DOUBLEPF_MMX_INSTRUCTIONS_AVAILABLEPF_PPC_MOVEMEM_64BIT_OKPF_ALPHA_BYTE_INSTRUCTIONSPF_XMMI_INSTRUCTIONS_AVAILABLEPF_3DNOW_INSTRUCTIONS_AVAILABLEPF_RDTSC_INSTRUCTION_AVAILABLEPF_PAE_ENABLEDPF_XMMI64_INSTRUCTIONS_AVAILABLEPF_SSE_DAZ_MODE_AVAILABLEPF_NX_ENABLEDPF_SSE3_INSTRUCTIONS_AVAILABLEPF_COMPARE_EXCHANGE128PF_COMPARE64_EXCHANGE128PF_CHANNELS_ENABLEDPF_XSAVE_ENABLEDPF_ARM_VFP_32_REGISTERS_AVAILABLEPF_ARM_NEON_INSTRUCTIONS_AVAILABLEPF_SECOND_LEVEL_ADDRESS_TRANSLATIONPF_VIRT_FIRMWARE_ENABLEDPF_RDWRFSGSBASE_AVAILABLEPF_FASTFAIL_AVAILABLEPF_ARM_DIVIDE_INSTRUCTION_AVAILABLEPF_ARM_64BIT_LOADSTORE_ATOMICPF_ARM_EXTERNAL_CACHE_AVAILABLEPF_ARM_FMAC_INSTRUCTIONS_AVAILABLEPF_RDRAND_INSTRUCTION_AVAILABLEPF_ARM_V8_INSTRUCTIONS_AVAILABLEPF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLEPF_RDTSCP_INSTRUCTION_AVAILABLEXSTATE_LEGACY_FLOATING_POINTXSTATE_LEGACY_SSEXSTATE_GSSEXSTATE_AVXXSTATE_MPX_BNDREGSXSTATE_MPX_BNDCSRXSTATE_AVX512_KMASKXSTATE_AVX512_ZMM_HXSTATE_AVX512_ZMMXSTATE_IPTXSTATE_LWPMAXIMUM_XSTATE_FEATURESXSTATE_MASK_LEGACY_FLOATING_POINTXSTATE_MASK_LEGACY_SSEXSTATE_MASK_LEGACYXSTATE_MASK_GSSEXSTATE_MASK_AVXXSTATE_MASK_MPXXSTATE_MASK_AVX512XSTATE_MASK_IPTXSTATE_MASK_LWPXSTATE_MASK_ALLOWEDXSTATE_MASK_PERSISTENTXSTATE_COMPACTION_ENABLEXSTATE_COMPACTION_ENABLE_MASKXSTATE_ALIGN_BITXSTATE_ALIGN_MASKXSTATE_CONTROLFLAG_XSAVEOPT_MASKXSTATE_CONTROLFLAG_XSAVEC_MASKXSTATE_CONTROLFLAG_VALID_MASKPXSTATE_FEATUREXSTATE_FEATUREPXSTATE_CONFIGURATIONXSTATE_CONFIGURATIONPMEMORY_BASIC_INFORMATION32MEMORY_BASIC_INFORMATION32PMEMORY_BASIC_INFORMATION64MEMORY_BASIC_INFORMATION64CFG_CALL_TARGET_VALIDCFG_CALL_TARGET_PROCESSEDCFG_CALL_TARGET_CONVERT_EXPORT_SUPPRESSED_TO_VALIDPCFG_CALL_TARGET_INFOCFG_CALL_TARGET_INFOSESSION_QUERY_ACCESSSESSION_MODIFY_ACCESSSESSION_ALL_ACCESSMEMORY_PARTITION_QUERY_ACCESSMEMORY_PARTITION_MODIFY_ACCESSMEMORY_PARTITION_ALL_ACCESSPAGE_NOACCESSPAGE_EXECUTEPAGE_GUARDPAGE_NOCACHEPAGE_WRITECOMBINEPAGE_ENCLAVE_THREAD_CONTROLPAGE_REVERT_TO_FILE_MAPPAGE_TARGETS_NO_UPDATEPAGE_TARGETS_INVALIDPAGE_ENCLAVE_UNVALIDATEDPAGE_ENCLAVE_DECOMMITMEM_COMMITMEM_RESERVEMEM_DECOMMITMEM_RELEASEMEM_FREEMEM_PRIVATEMEM_MAPPEDMEM_RESETMEM_TOP_DOWNMEM_WRITE_WATCHMEM_PHYSICALMEM_ROTATEMEM_DIFFERENT_IMAGE_BASE_OKMEM_RESET_UNDOMEM_LARGE_PAGESMEM_4MB_PAGESMEM_64K_PAGESSEC_64K_PAGESSEC_FILESEC_IMAGESEC_PROTECTED_IMAGESEC_RESERVESEC_COMMITSEC_NOCACHESEC_WRITECOMBINESEC_LARGE_PAGESSEC_IMAGE_NO_EXECUTEMEM_IMAGEWRITE_WATCH_FLAG_RESETMEM_UNMAP_WITH_TRANSIENT_BOOSTENCLAVE_TYPE_SGXENCLAVE_TYPE_SGX2PENCLAVE_CREATE_INFO_SGXENCLAVE_CREATE_INFO_SGXPENCLAVE_INIT_INFO_SGXENCLAVE_INIT_INFO_SGXFILE_LIST_DIRECTORYFILE_ADD_FILEFILE_APPEND_DATAFILE_ADD_SUBDIRECTORYFILE_CREATE_PIPE_INSTANCEFILE_READ_EAFILE_WRITE_EAFILE_EXECUTEFILE_TRAVERSEFILE_DELETE_CHILDFILE_READ_ATTRIBUTESFILE_WRITE_ATTRIBUTESFILE_ALL_ACCESSFILE_GENERIC_EXECUTEFILE_ATTRIBUTE_READONLYFILE_ATTRIBUTE_HIDDENFILE_ATTRIBUTE_SYSTEMFILE_ATTRIBUTE_DIRECTORYFILE_ATTRIBUTE_ARCHIVEFILE_ATTRIBUTE_DEVICEFILE_ATTRIBUTE_SPARSE_FILEFILE_ATTRIBUTE_REPARSE_POINTFILE_ATTRIBUTE_COMPRESSEDFILE_ATTRIBUTE_OFFLINEFILE_ATTRIBUTE_NOT_CONTENT_INDEXEDFILE_ATTRIBUTE_ENCRYPTEDFILE_ATTRIBUTE_INTEGRITY_STREAMFILE_ATTRIBUTE_VIRTUALFILE_ATTRIBUTE_NO_SCRUB_DATAFILE_ATTRIBUTE_EAFILE_ATTRIBUTE_PINNEDFILE_ATTRIBUTE_UNPINNEDFILE_ATTRIBUTE_RECALL_ON_OPENFILE_ATTRIBUTE_RECALL_ON_DATA_ACCESSFILE_NOTIFY_CHANGE_FILE_NAMEFILE_NOTIFY_CHANGE_DIR_NAMEFILE_NOTIFY_CHANGE_ATTRIBUTESFILE_NOTIFY_CHANGE_SIZEFILE_NOTIFY_CHANGE_LAST_WRITEFILE_NOTIFY_CHANGE_LAST_ACCESSFILE_NOTIFY_CHANGE_CREATIONFILE_NOTIFY_CHANGE_SECURITYFILE_ACTION_ADDEDFILE_ACTION_REMOVEDFILE_ACTION_MODIFIEDFILE_ACTION_RENAMED_OLD_NAMEFILE_ACTION_RENAMED_NEW_NAMEMAILSLOT_NO_MESSAGEMAILSLOT_WAIT_FOREVERFILE_CASE_SENSITIVE_SEARCHFILE_CASE_PRESERVED_NAMESFILE_UNICODE_ON_DISKFILE_PERSISTENT_ACLSFILE_FILE_COMPRESSIONFILE_VOLUME_QUOTASFILE_SUPPORTS_SPARSE_FILESFILE_SUPPORTS_REPARSE_POINTSFILE_SUPPORTS_REMOTE_STORAGEFILE_RETURNS_CLEANUP_RESULT_INFOFILE_VOLUME_IS_COMPRESSEDFILE_SUPPORTS_OBJECT_IDSFILE_SUPPORTS_ENCRYPTIONFILE_NAMED_STREAMSFILE_READ_ONLY_VOLUMEFILE_SEQUENTIAL_WRITE_ONCEFILE_SUPPORTS_TRANSACTIONSFILE_SUPPORTS_HARD_LINKSFILE_SUPPORTS_EXTENDED_ATTRIBUTESFILE_SUPPORTS_OPEN_BY_FILE_IDFILE_SUPPORTS_USN_JOURNALFILE_SUPPORTS_INTEGRITY_STREAMSFILE_SUPPORTS_BLOCK_REFCOUNTINGFILE_SUPPORTS_SPARSE_VDLFILE_DAX_VOLUMEFILE_SUPPORTS_GHOSTINGFILE_INVALID_FILE_IDPFILE_ID_128PFILE_SEGMENT_ELEMENTFLUSH_FLAGS_FILE_DATA_ONLYFLUSH_FLAGS_NO_SYNCFLUSH_FLAGS_FILE_DATA_SYNC_ONLYPREPARSE_GUID_DATA_BUFFERREPARSE_GUID_DATA_BUFFERMAXIMUM_REPARSE_DATA_BUFFER_SIZEIO_REPARSE_TAG_RESERVED_ZEROIO_REPARSE_TAG_RESERVED_ONEIO_REPARSE_TAG_RESERVED_TWOIO_REPARSE_TAG_RESERVED_RANGEIsReparseTagMicrosoftIsReparseTagNameSurrogateIsReparseTagDirectoryIO_REPARSE_TAG_MOUNT_POINTIO_REPARSE_TAG_HSMIO_REPARSE_TAG_HSM2IO_REPARSE_TAG_SISIO_REPARSE_TAG_WIMIO_REPARSE_TAG_CSVIO_REPARSE_TAG_DFSIO_REPARSE_TAG_SYMLINKIO_REPARSE_TAG_DFSRIO_REPARSE_TAG_DEDUPIO_REPARSE_TAG_NFSIO_REPARSE_TAG_FILE_PLACEHOLDERIO_REPARSE_TAG_WOFIO_REPARSE_TAG_WCIIO_REPARSE_TAG_GLOBAL_REPARSEIO_REPARSE_TAG_CLOUDIO_REPARSE_TAG_CLOUD_ROOTIO_REPARSE_TAG_CLOUD_ON_DEMANDIO_REPARSE_TAG_CLOUD_ROOT_ON_DEMANDIO_REPARSE_TAG_APPEXECLINKIO_REPARSE_TAG_GVFSIO_REPARSE_TAG_WCI_TOMBSTONEIO_REPARSE_TAG_UNHANDLEDIO_REPARSE_TAG_ONEDRIVEIO_REPARSE_TAG_GVFS_TOMBSTONESCRUB_DATA_INPUT_FLAG_RESUMESCRUB_DATA_INPUT_FLAG_SKIP_IN_SYNCSCRUB_DATA_INPUT_FLAG_SKIP_NON_INTEGRITY_DATASCRUB_DATA_OUTPUT_FLAG_INCOMPLETESCRUB_DATA_OUTPUT_FLAG_NON_USER_DATA_RANGESCRUB_DATA_OUTPUT_FLAG_PARITY_EXTENT_DATA_RETURNEDSCRUB_DATA_OUTPUT_FLAG_RESUME_CONTEXT_LENGTH_SPECIFIEDPSCRUB_DATA_INPUTSCRUB_DATA_INPUTPSCRUB_PARITY_EXTENTSCRUB_PARITY_EXTENTPSCRUB_PARITY_EXTENT_DATASCRUB_PARITY_EXTENT_DATAPSCRUB_DATA_OUTPUTSCRUB_DATA_OUTPUTPSHARED_VIRTUAL_DISK_SUPPORTSHARED_VIRTUAL_DISK_SUPPORTIsVirtualDiskFileSharedSharedVirtualDiskHandleStateIO_COMPLETION_MODIFY_STATEIO_COMPLETION_ALL_ACCESSIO_QOS_MAX_RESERVATIONSMB_CCF_APP_INSTANCE_EA_NAMENETWORK_APP_INSTANCE_CSV_FLAGS_VALID_ONLY_IF_CSV_COORDINATORPNETWORK_APP_INSTANCE_EANETWORK_APP_INSTANCE_EADUPLICATE_CLOSE_SOURCEPOWERBUTTON_ACTION_INDEX_NOTHINGPOWERBUTTON_ACTION_INDEX_SLEEPPOWERBUTTON_ACTION_INDEX_HIBERNATEPOWERBUTTON_ACTION_INDEX_SHUTDOWNPOWERBUTTON_ACTION_INDEX_TURN_OFF_THE_DISPLAYPOWERBUTTON_ACTION_VALUE_NOTHINGPOWERBUTTON_ACTION_VALUE_SLEEPPOWERBUTTON_ACTION_VALUE_HIBERNATEPOWERBUTTON_ACTION_VALUE_SHUTDOWNPOWERBUTTON_ACTION_VALUE_TURN_OFF_THE_DISPLAYPERFSTATE_POLICY_CHANGE_IDEALPERFSTATE_POLICY_CHANGE_SINGLEPERFSTATE_POLICY_CHANGE_ROCKETPERFSTATE_POLICY_CHANGE_IDEAL_AGGRESSIVEPERFSTATE_POLICY_CHANGE_DECREASE_MAXPERFSTATE_POLICY_CHANGE_INCREASE_MAXPROCESSOR_THROTTLE_DISABLEDPROCESSOR_THROTTLE_ENABLEDPROCESSOR_THROTTLE_AUTOMATICPROCESSOR_PERF_BOOST_POLICY_DISABLEDPROCESSOR_PERF_BOOST_POLICY_MAXPROCESSOR_PERF_BOOST_MODE_DISABLEDPROCESSOR_PERF_BOOST_MODE_ENABLEDPROCESSOR_PERF_BOOST_MODE_AGGRESSIVEPROCESSOR_PERF_BOOST_MODE_EFFICIENT_ENABLEDPROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVEPROCESSOR_PERF_BOOST_MODE_AGGRESSIVE_AT_GUARANTEEDPROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE_AT_GUARANTEEDPROCESSOR_PERF_BOOST_MODE_MAXPROCESSOR_PERF_AUTONOMOUS_MODE_DISABLEDPROCESSOR_PERF_AUTONOMOUS_MODE_ENABLEDPROCESSOR_PERF_PERFORMANCE_PREFERENCEPROCESSOR_PERF_ENERGY_PREFERENCEPROCESSOR_PERF_MINIMUM_ACTIVITY_WINDOWPROCESSOR_PERF_MAXIMUM_ACTIVITY_WINDOWPROCESSOR_DUTY_CYCLING_DISABLEDPROCESSOR_DUTY_CYCLING_ENABLEDCORE_PARKING_POLICY_CHANGE_IDEALCORE_PARKING_POLICY_CHANGE_SINGLECORE_PARKING_POLICY_CHANGE_ROCKETCORE_PARKING_POLICY_CHANGE_MULTISTEPCORE_PARKING_POLICY_CHANGE_MAXPOWER_DEVICE_IDLE_POLICY_PERFORMANCEPOWER_DEVICE_IDLE_POLICY_CONSERVATIVEPOWER_CONNECTIVITY_IN_STANDBY_DISABLEDPOWER_CONNECTIVITY_IN_STANDBY_ENABLEDPOWER_CONNECTIVITY_IN_STANDBY_DISABLED_LID_CLOSEPOWER_DISCONNECTED_STANDBY_MODE_NORMALPOWER_DISCONNECTED_STANDBY_MODE_AGGRESSIVEPSYSTEM_POWER_STATEPOWER_SYSTEM_MAXIMUMPPOWER_ACTIONPOWER_ACTIONPDEVICE_POWER_STATEDEVICE_POWER_STATEPMONITOR_DISPLAY_STATEMONITOR_DISPLAY_STATEPUSER_ACTIVITY_PRESENCEUSER_ACTIVITY_PRESENCEES_USER_PRESENTPEXECUTION_STATEDIAGNOSTIC_REASON_VERSIONDIAGNOSTIC_REASON_SIMPLE_STRINGDIAGNOSTIC_REASON_DETAILED_STRINGDIAGNOSTIC_REASON_NOT_SPECIFIEDDIAGNOSTIC_REASON_INVALID_FLAGSPOWER_REQUEST_CONTEXT_VERSIONPOWER_REQUEST_CONTEXT_SIMPLE_STRINGPOWER_REQUEST_CONTEXT_DETAILED_STRINGPPOWER_REQUEST_TYPEPDCAP_D0_SUPPORTEDPDCAP_D1_SUPPORTEDPDCAP_D2_SUPPORTEDPDCAP_D3_SUPPORTEDPDCAP_WAKE_FROM_D0_SUPPORTEDPDCAP_WAKE_FROM_D1_SUPPORTEDPDCAP_WAKE_FROM_D2_SUPPORTEDPDCAP_WAKE_FROM_D3_SUPPORTEDPDCAP_WARM_EJECT_SUPPORTEDPCM_POWER_DATACM_POWER_DATAPPOWER_USER_PRESENCE_TYPEPOWER_USER_PRESENCE_TYPEPPOWER_USER_PRESENCEPOWER_USER_PRESENCEPPOWER_SESSION_CONNECTPOWER_SESSION_CONNECTPPOWER_SESSION_TIMEOUTSPOWER_SESSION_TIMEOUTSPPOWER_SESSION_RIT_STATEPOWER_SESSION_RIT_STATEPPOWER_SESSION_WINLOGONPOWER_SESSION_WINLOGONPPOWER_IDLE_RESILIENCYPOWER_IDLE_RESILIENCYPPOWER_MONITOR_INVOCATIONPOWER_MONITOR_INVOCATIONPRESUME_PERFORMANCERESUME_PERFORMANCEPSET_POWER_SETTING_VALUESET_POWER_SETTING_VALUEPNOTIFY_USER_POWER_SETTINGNOTIFY_USER_POWER_SETTINGPAPPLICATIONLAUNCH_SETTING_VALUEAPPLICATIONLAUNCH_SETTING_VALUEPPOWER_PLATFORM_ROLEPOWER_PLATFORM_ROLE_V1POWER_PLATFORM_ROLE_V1_MAXPOWER_PLATFORM_ROLE_V2POWER_PLATFORM_ROLE_V2_MAXPOWER_PLATFORM_ROLE_VERSIONPOWER_PLATFORM_ROLE_VERSION_MAXPPOWER_PLATFORM_INFORMATIONPOWER_PLATFORM_INFORMATIONPBATTERY_REPORTING_SCALEBATTERY_REPORTING_SCALEPPPM_WMI_LEGACY_PERFSTATEPPM_WMI_LEGACY_PERFSTATEPPPM_WMI_IDLE_STATEPPM_WMI_IDLE_STATEPPPM_WMI_IDLE_STATESPPM_WMI_IDLE_STATESPPPM_WMI_IDLE_STATES_EXPPM_WMI_IDLE_STATES_EXPPPM_WMI_PERF_STATEPPM_WMI_PERF_STATEPPPM_WMI_PERF_STATESPPM_WMI_PERF_STATESPPPM_WMI_PERF_STATES_EXPPM_WMI_PERF_STATES_EXPROC_IDLE_BUCKET_COUNTPPPM_IDLE_STATE_ACCOUNTINGPPM_IDLE_STATE_ACCOUNTINGPPPM_IDLE_ACCOUNTINGPPM_IDLE_ACCOUNTINGPROC_IDLE_BUCKET_COUNT_EXPPPM_IDLE_STATE_BUCKET_EXPPM_IDLE_STATE_BUCKET_EXPPPM_IDLE_STATE_ACCOUNTING_EXPPM_IDLE_STATE_ACCOUNTING_EXPPPM_IDLE_ACCOUNTING_EXPPM_IDLE_ACCOUNTING_EXACPI_PPM_SOFTWARE_ALLACPI_PPM_SOFTWARE_ANYACPI_PPM_HARDWARE_ALLMS_PPM_SOFTWARE_ALLPPM_FIRMWARE_ACPI1C2PPM_FIRMWARE_ACPI1C3PPM_FIRMWARE_ACPI1TSTATESPPM_FIRMWARE_CSTPPM_FIRMWARE_CSDPPM_FIRMWARE_PCTPPM_FIRMWARE_PSSPPM_FIRMWARE_XPSSPPM_FIRMWARE_PPCPPM_FIRMWARE_PSDPPM_FIRMWARE_PTCPPM_FIRMWARE_TSSPPM_FIRMWARE_TPCPPM_FIRMWARE_TSDPPM_FIRMWARE_PCCHPPM_FIRMWARE_PCCPPPM_FIRMWARE_OSCPPM_FIRMWARE_PDCPPM_FIRMWARE_CPCPPM_FIRMWARE_LPIPPM_PERFORMANCE_IMPLEMENTATION_NONEPPM_PERFORMANCE_IMPLEMENTATION_PSTATESPPM_PERFORMANCE_IMPLEMENTATION_PCCV1PPM_PERFORMANCE_IMPLEMENTATION_CPPCPPM_PERFORMANCE_IMPLEMENTATION_PEPPPM_IDLE_IMPLEMENTATION_NONEPPM_IDLE_IMPLEMENTATION_CSTATESPPM_IDLE_IMPLEMENTATION_PEPPPM_IDLE_IMPLEMENTATION_MICROPEPPPM_IDLE_IMPLEMENTATION_LPISTATESPPPM_PERFSTATE_EVENTPPM_PERFSTATE_EVENTPPPM_PERFSTATE_DOMAIN_EVENTPPM_PERFSTATE_DOMAIN_EVENTPPPM_IDLESTATE_EVENTPPM_IDLESTATE_EVENTPPPM_THERMALCHANGE_EVENTPPM_THERMALCHANGE_EVENTPPPM_THERMAL_POLICY_EVENTPPM_THERMAL_POLICY_EVENTPPOWER_ACTION_POLICYPOWER_ACTION_QUERY_ALLOWEDPOWER_ACTION_UI_ALLOWEDPOWER_ACTION_OVERRIDE_APPSPOWER_ACTION_HIBERBOOTPOWER_ACTION_USER_NOTIFYPOWER_ACTION_DOZE_TO_HIBERNATEPOWER_ACTION_PSEUDO_TRANSITIONPOWER_ACTION_LIGHTEST_FIRSTPOWER_ACTION_LOCK_CONSOLEPOWER_ACTION_DISABLE_WAKESPOWER_ACTION_CRITICALPOWER_LEVEL_USER_NOTIFY_TEXTPOWER_LEVEL_USER_NOTIFY_SOUNDPOWER_LEVEL_USER_NOTIFY_EXECPOWER_USER_NOTIFY_BUTTONPOWER_USER_NOTIFY_SHUTDOWNPOWER_USER_NOTIFY_FORCED_SHUTDOWNPOWER_FORCE_TRIGGER_RESETBATTERY_DISCHARGE_FLAGS_EVENTCODE_MASKBATTERY_DISCHARGE_FLAGS_ENABLEPSYSTEM_POWER_LEVELDISCHARGE_POLICY_CRITICALDISCHARGE_POLICY_LOWPSYSTEM_POWER_POLICYSYSTEM_POWER_POLICYPROCESSOR_IDLESTATE_POLICY_COUNTPPROCESSOR_IDLESTATE_INFOPROCESSOR_IDLESTATE_INFOPPROCESSOR_IDLESTATE_POLICYPROCESSOR_IDLESTATE_POLICYPO_THROTTLE_NONEPO_THROTTLE_CONSTANTPO_THROTTLE_DEGRADEPO_THROTTLE_ADAPTIVEPO_THROTTLE_MAXIMUMPPROCESSOR_POWER_POLICY_INFOPROCESSOR_POWER_POLICY_INFOPPROCESSOR_POWER_POLICYPPROCESSOR_PERFSTATE_POLICYPROCESSOR_PERFSTATE_POLICYADMINISTRATOR_POWER_POLICYHIBERFILE_TYPE_NONEHIBERFILE_TYPE_REDUCEDHIBERFILE_TYPE_FULLHIBERFILE_TYPE_MAXPHIBERFILE_BUCKETHIBERFILE_BUCKETSYSTEM_POWER_CAPABILITIESPSYSTEM_BATTERY_STATESYSTEM_BATTERY_STATEPIMAGE_DOS_HEADERIMAGE_DOS_HEADERPIMAGE_OS2_HEADERIMAGE_OS2_HEADERPIMAGE_VXD_HEADERIMAGE_VXD_HEADERPIMAGE_FILE_HEADERIMAGE_FILE_HEADERPIMAGE_DATA_DIRECTORYIMAGE_DATA_DIRECTORYPIMAGE_OPTIONAL_HEADER32IMAGE_OPTIONAL_HEADER32PIMAGE_ROM_OPTIONAL_HEADERIMAGE_ROM_OPTIONAL_HEADERPIMAGE_OPTIONAL_HEADER64IMAGE_OPTIONAL_HEADER64IMAGE_NT_HEADERS64IMAGE_NT_HEADERS32PIMAGE_ROM_HEADERSIMAGE_ROM_HEADERSIMAGE_SECTION_HEADERPIMAGE_SYMBOLIMAGE_SYMBOLPIMAGE_SYMBOL_EXIMAGE_SYMBOL_EXBTYPEISPTRISFCNISARYISTAGINCREFDECREFPIMAGE_AUX_SYMBOL_TOKEN_DEFIMAGE_AUX_SYMBOL_TOKEN_DEFPIMAGE_AUX_SYMBOLIMAGE_AUX_SYMBOLPIMAGE_AUX_SYMBOL_EXIMAGE_AUX_SYMBOL_EXPIMAGE_RELOCATIONIMAGE_RELOCATIONPIMAGE_LINENUMBERIMAGE_LINENUMBERPIMAGE_BASE_RELOCATIONIMAGE_BASE_RELOCATIONPIMAGE_ARCHIVE_MEMBER_HEADERIMAGE_ARCHIVE_MEMBER_HEADERPIMAGE_EXPORT_DIRECTORYIMAGE_EXPORT_DIRECTORYPIMAGE_IMPORT_BY_NAMEIMAGE_IMPORT_BY_NAMEPIMAGE_THUNK_DATA64IMAGE_THUNK_DATA64PIMAGE_THUNK_DATA32IMAGE_THUNK_DATA32IMAGE_ORDINAL64IMAGE_ORDINAL32IMAGE_SNAP_BY_ORDINAL64IMAGE_SNAP_BY_ORDINAL32PIMAGE_TLS_DIRECTORY64IMAGE_TLS_DIRECTORY64PIMAGE_TLS_DIRECTORY32IMAGE_TLS_DIRECTORY32PIMAGE_IMPORT_DESCRIPTORIMAGE_IMPORT_DESCRIPTORPIMAGE_BOUND_IMPORT_DESCRIPTORIMAGE_BOUND_IMPORT_DESCRIPTORPIMAGE_BOUND_FORWARDER_REFIMAGE_BOUND_FORWARDER_REFPIMAGE_DELAYLOAD_DESCRIPTORIMAGE_DELAYLOAD_DESCRIPTORPCIMAGE_DELAYLOAD_DESCRIPTORPIMAGE_RESOURCE_DIRECTORYIMAGE_RESOURCE_DIRECTORYPIMAGE_RESOURCE_DIRECTORY_ENTRYIMAGE_RESOURCE_DIRECTORY_ENTRYPIMAGE_RESOURCE_DIRECTORY_STRINGIMAGE_RESOURCE_DIRECTORY_STRINGPIMAGE_RESOURCE_DIR_STRING_UIMAGE_RESOURCE_DIR_STRING_UPIMAGE_RESOURCE_DATA_ENTRYIMAGE_RESOURCE_DATA_ENTRYPIMAGE_LOAD_CONFIG_CODE_INTEGRITYIMAGE_LOAD_CONFIG_CODE_INTEGRITYPIMAGE_DYNAMIC_RELOCATION_TABLEIMAGE_DYNAMIC_RELOCATION_TABLEPIMAGE_DYNAMIC_RELOCATION32IMAGE_DYNAMIC_RELOCATION32PIMAGE_DYNAMIC_RELOCATION64IMAGE_DYNAMIC_RELOCATION64PIMAGE_DYNAMIC_RELOCATION32_V2IMAGE_DYNAMIC_RELOCATION32_V2PIMAGE_DYNAMIC_RELOCATION64_V2IMAGE_DYNAMIC_RELOCATION64_V2PIMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADERIMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADERPIMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADERIMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADERPIMAGE_LOAD_CONFIG_DIRECTORY32IMAGE_LOAD_CONFIG_DIRECTORY32PIMAGE_LOAD_CONFIG_DIRECTORY64IMAGE_LOAD_CONFIG_DIRECTORY64PIMAGE_HOT_PATCH_INFOIMAGE_HOT_PATCH_INFOPIMAGE_HOT_PATCH_BASEIMAGE_HOT_PATCH_BASEPIMAGE_HOT_PATCH_HASHESIMAGE_HOT_PATCH_HASHESPIMAGE_CE_RUNTIME_FUNCTION_ENTRYIMAGE_CE_RUNTIME_FUNCTION_ENTRYPIMAGE_ARM_RUNTIME_FUNCTION_ENTRYIMAGE_ARM_RUNTIME_FUNCTION_ENTRYPIMAGE_ARM64_RUNTIME_FUNCTION_ENTRYIMAGE_ARM64_RUNTIME_FUNCTION_ENTRYPIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRYIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRYPIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRYIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY_PIMAGE_RUNTIME_FUNCTION_ENTRY_IMAGE_RUNTIME_FUNCTION_ENTRYIMAGE_IA64_RUNTIME_FUNCTION_ENTRYPIMAGE_IA64_RUNTIME_FUNCTION_ENTRYIMAGE_DEBUG_DIRECTORYIMAGE_COFF_SYMBOLS_HEADERFPO_DATASIZEOF_RFPO_DATAPIMAGE_DEBUG_MISCIMAGE_DEBUG_MISCIMAGE_FUNCTION_ENTRYPIMAGE_FUNCTION_ENTRY64IMAGE_FUNCTION_ENTRY64PIMAGE_SEPARATE_DEBUG_HEADERIMAGE_SEPARATE_DEBUG_HEADERPNON_PAGED_DEBUG_INFONON_PAGED_DEBUG_INFOPIMAGE_ARCHITECTURE_HEADERIMAGE_ARCHITECTURE_HEADERPIMAGE_ARCHITECTURE_ENTRYIMAGE_ARCHITECTURE_ENTRYPIMAGE_COR20_HEADERIMAGE_COR20_HEADERRtlCaptureStackBackTraceRtlCaptureContextRtlUnwindRtlAddFunctionTablePRUNTIME_FUNCTIONRtlDeleteFunctionTableRtlInstallFunctionTableCallbackPGET_RUNTIME_FUNCTION_CALLBACKRtlAddGrowableFunctionTableRtlGrowFunctionTableRtlDeleteGrowableFunctionTableRtlLookupFunctionEntryPUNWIND_HISTORY_TABLERtlPcToFileHeaderRtlCompareMemorySLIST_ENTRYRtlInitializeSListHeadRtlFirstEntrySListSLIST_HEADERRtlInterlockedPopEntrySListRtlInterlockedPushEntrySListRtlInterlockedPushListSListExRtlInterlockedFlushSListRtlQueryDepthSListRTL_RUN_ONCE_INITRTL_RUN_ONCE_CHECK_ONLYRTL_RUN_ONCE_ASYNCRTL_RUN_ONCE_INIT_FAILEDFAST_FAIL_LEGACY_GS_VIOLATIONFAST_FAIL_VTGUARD_CHECK_FAILUREFAST_FAIL_STACK_COOKIE_CHECK_FAILUREFAST_FAIL_CORRUPT_LIST_ENTRYFAST_FAIL_INCORRECT_STACKFAST_FAIL_INVALID_ARGFAST_FAIL_GS_COOKIE_INITFAST_FAIL_FATAL_APP_EXITFAST_FAIL_RANGE_CHECK_FAILUREFAST_FAIL_UNSAFE_REGISTRY_ACCESSFAST_FAIL_GUARD_ICALL_CHECK_FAILUREFAST_FAIL_GUARD_WRITE_CHECK_FAILUREFAST_FAIL_INVALID_FIBER_SWITCHFAST_FAIL_INVALID_SET_OF_CONTEXTFAST_FAIL_INVALID_REFERENCE_COUNTFAST_FAIL_INVALID_JUMP_BUFFERFAST_FAIL_MRDATA_MODIFIEDFAST_FAIL_CERTIFICATION_FAILUREFAST_FAIL_INVALID_EXCEPTION_CHAINFAST_FAIL_CRYPTO_LIBRARYFAST_FAIL_INVALID_CALL_IN_DLL_CALLOUTFAST_FAIL_INVALID_IMAGE_BASEFAST_FAIL_DLOAD_PROTECTION_FAILUREFAST_FAIL_UNSAFE_EXTENSION_CALLFAST_FAIL_DEPRECATED_SERVICE_INVOKEDFAST_FAIL_INVALID_BUFFER_ACCESSFAST_FAIL_INVALID_BALANCED_TREEFAST_FAIL_INVALID_NEXT_THREADFAST_FAIL_GUARD_ICALL_CHECK_SUPPRESSEDFAST_FAIL_APCS_DISABLEDFAST_FAIL_INVALID_IDLE_STATEFAST_FAIL_MRDATA_PROTECTION_FAILUREFAST_FAIL_UNEXPECTED_HEAP_EXCEPTIONFAST_FAIL_INVALID_LOCK_STATEFAST_FAIL_GUARD_JUMPTABLEFAST_FAIL_INVALID_LONGJUMP_TARGETFAST_FAIL_INVALID_DISPATCH_CONTEXTFAST_FAIL_INVALID_THREADFAST_FAIL_INVALID_SYSCALL_NUMBERFAST_FAIL_INVALID_FILE_OPERATIONFAST_FAIL_LPAC_ACCESS_DENIEDFAST_FAIL_GUARD_SS_FAILUREFAST_FAIL_LOADER_CONTINUITY_FAILUREFAST_FAIL_GUARD_EXPORT_SUPPRESSION_FAILUREFAST_FAIL_INVALID_CONTROL_STACKFAST_FAIL_SET_CONTEXT_DENIEDFAST_FAIL_INVALID_FAST_FAIL_CODEHEAP_NO_SERIALIZEHEAP_GROWABLEHEAP_GENERATE_EXCEPTIONSHEAP_REALLOC_IN_PLACE_ONLYHEAP_TAIL_CHECKING_ENABLEDHEAP_FREE_CHECKING_ENABLEDHEAP_DISABLE_COALESCE_ON_FREEHEAP_CREATE_ALIGN_16HEAP_CREATE_ENABLE_TRACINGHEAP_CREATE_ENABLE_EXECUTEHEAP_MAXIMUM_TAGHEAP_PSEUDO_TAG_FLAGHEAP_TAG_SHIFTHEAP_CREATE_SEGMENT_HEAPHEAP_CREATE_HARDENEDHEAP_MAKE_TAG_FLAGSIS_TEXT_UNICODE_ASCII16IS_TEXT_UNICODE_REVERSE_ASCII16IS_TEXT_UNICODE_STATISTICSIS_TEXT_UNICODE_REVERSE_STATISTICSIS_TEXT_UNICODE_CONTROLSIS_TEXT_UNICODE_REVERSE_CONTROLSIS_TEXT_UNICODE_SIGNATUREIS_TEXT_UNICODE_REVERSE_SIGNATUREIS_TEXT_UNICODE_ILLEGAL_CHARSIS_TEXT_UNICODE_ODD_LENGTHIS_TEXT_UNICODE_DBCS_LEADBYTEIS_TEXT_UNICODE_NULL_BYTESIS_TEXT_UNICODE_UNICODE_MASKIS_TEXT_UNICODE_REVERSE_MASKIS_TEXT_UNICODE_NOT_UNICODE_MASKIS_TEXT_UNICODE_NOT_ASCII_MASKCOMPRESSION_FORMAT_NONECOMPRESSION_FORMAT_DEFAULTCOMPRESSION_FORMAT_LZNT1COMPRESSION_FORMAT_XPRESSCOMPRESSION_FORMAT_XPRESS_HUFFCOMPRESSION_ENGINE_STANDARDCOMPRESSION_ENGINE_MAXIMUMCOMPRESSION_ENGINE_HIBERRtlMoveMemory// RtlEqualMemoryRtlCopyMemoryRtlFillMemoryRtlZeroMemorySEF_DACL_AUTO_INHERITSEF_SACL_AUTO_INHERITSEF_DEFAULT_DESCRIPTOR_FOR_OBJECTSEF_AVOID_PRIVILEGE_CHECKSEF_AVOID_OWNER_CHECKSEF_DEFAULT_OWNER_FROM_PARENTSEF_DEFAULT_GROUP_FROM_PARENTSEF_MACL_NO_WRITE_UPSEF_MACL_NO_READ_UPSEF_MACL_NO_EXECUTE_UPSEF_AI_USE_EXTRA_PARAMSSEF_AVOID_OWNER_RESTRICTIONSEF_MACL_VALID_FLAGSPMESSAGE_RESOURCE_ENTRYMESSAGE_RESOURCE_ENTRYMESSAGE_RESOURCE_UNICODEPMESSAGE_RESOURCE_BLOCKMESSAGE_RESOURCE_BLOCKPMESSAGE_RESOURCE_DATAMESSAGE_RESOURCE_DATAPOSVERSIONINFOAOSVERSIONINFOAPOSVERSIONINFOWOSVERSIONINFOWRTL_OSVERSIONINFOWPRTL_OSVERSIONINFOWPOSVERSIONINFOEXAPOSVERSIONINFOEXWRTL_OSVERSIONINFOEXWPRTL_OSVERSIONINFOEXWVER_EQUALVER_GREATERVER_GREATER_EQUALVER_LESSVER_LESS_EQUALVER_ANDVER_ORVER_CONDITION_MASKVER_NUM_BITS_PER_CONDITION_MASKVER_MINORVERSIONVER_MAJORVERSIONVER_BUILDNUMBERVER_PLATFORMIDVER_SERVICEPACKMINORVER_SERVICEPACKMAJORVER_SUITENAMEVER_PRODUCT_TYPEVER_NT_DOMAIN_CONTROLLERVER_NT_SERVERVER_PLATFORM_WIN32sVER_PLATFORM_WIN32_WINDOWSVER_PLATFORM_WIN32_NTRtlGetProductInfoRTL_UMS_VERSIONIS_VALIDATION_ENABLEDVRL_PREDEFINED_CLASS_BEGINVRL_CUSTOM_CLASS_BEGINVRL_CLASS_CONSISTENCYVRL_ENABLE_KERNEL_BREAKSCTMF_INCLUDE_APPCONTAINERCTMF_INCLUDE_LPACCTMF_VALID_FLAGSRtlCrc32RtlCrc64RtlOsDeploymentStateOS_DEPLOYEMENT_STATE_VALUESRTL_RESOURCE_DEBUGPRTL_RESOURCE_DEBUGRTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFORTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPINRTL_CRITICAL_SECTION_FLAG_STATIC_INITRTL_CRITICAL_SECTION_FLAG_RESOURCE_TYPERTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFORTL_CRITICAL_SECTION_ALL_FLAG_BITSRTL_CRITICAL_SECTION_FLAG_RESERVEDRTL_CRITICAL_SECTION_DEBUG_FLAG_STATIC_INITPRTL_SRWLOCKPRTL_CONDITION_VARIABLERTL_CONDITION_VARIABLE_LOCKMODE_SHAREDHEAP_OPTIMIZE_RESOURCES_CURRENT_VERSIONPHEAP_OPTIMIZE_RESOURCES_INFORMATIONHEAP_OPTIMIZE_RESOURCES_INFORMATIONWT_EXECUTEINIOTHREADWT_EXECUTEINUITHREADWT_EXECUTEINTIMERTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTEINPERSISTENTTHREADWT_TRANSFER_IMPERSONATIONWT_SET_MAX_THREADPOOL_THREADSWAITORTIMERCALLBACKFUNCWT_EXECUTEINLONGTHREADWT_EXECUTEDELETEWAITACTIVATIONCONTEXTINFOCLASSACTIVATION_CONTEXT_INFO_CLASSPACTIVATION_CONTEXT_QUERY_INDEXACTIVATION_CONTEXT_QUERY_INDEXPCACTIVATION_CONTEXT_QUERY_INDEXACTIVATION_CONTEXT_PATH_TYPE_NONEACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILEACTIVATION_CONTEXT_PATH_TYPE_URLACTIVATION_CONTEXT_PATH_TYPE_ASSEMBLYREFPASSEMBLY_FILE_DETAILED_INFORMATIONASSEMBLY_FILE_DETAILED_INFORMATIONPCASSEMBLY_FILE_DETAILED_INFORMATIONASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATIONPASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATIONPCASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATIONPACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATIONACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATIONPCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATIONPACTIVATION_CONTEXT_RUN_LEVEL_INFORMATIONACTIVATION_CONTEXT_RUN_LEVEL_INFORMATIONPCACTIVATION_CONTEXT_RUN_LEVEL_INFORMATIONPCOMPATIBILITY_CONTEXT_ELEMENTCOMPATIBILITY_CONTEXT_ELEMENTPCCOMPATIBILITY_CONTEXT_ELEMENTPACTIVATION_CONTEXT_COMPATIBILITY_INFORMATIONACTIVATION_CONTEXT_COMPATIBILITY_INFORMATIONPCACTIVATION_CONTEXT_COMPATIBILITY_INFORMATIONPSUPPORTED_OS_INFOSUPPORTED_OS_INFOPACTIVATION_CONTEXT_DETAILED_INFORMATIONACTIVATION_CONTEXT_DETAILED_INFORMATIONPCACTIVATION_CONTEXT_DETAILED_INFORMATIONCREATE_BOUNDARY_DESCRIPTOR_ADD_APPCONTAINER_SIDPHARDWARE_COUNTER_DATAHARDWARE_COUNTER_DATAPERFORMANCE_DATA_VERSIONPERFORMANCE_DATAREAD_THREAD_PROFILING_FLAG_DISPATCHINGREAD_THREAD_PROFILING_FLAG_HARDWARE_COUNTERSUNIFIEDBUILDREVISION_KEYUNIFIEDBUILDREVISION_VALUEUNIFIEDBUILDREVISION_MINDEVICEFAMILYDEVICEFORM_KEYDEVICEFAMILYDEVICEFORM_VALUEDEVICEFAMILYINFOENUM_UAPDEVICEFAMILYINFOENUM_WINDOWS_8XDEVICEFAMILYINFOENUM_WINDOWS_PHONE_8XDEVICEFAMILYINFOENUM_DESKTOPDEVICEFAMILYINFOENUM_MOBILEDEVICEFAMILYINFOENUM_XBOXDEVICEFAMILYINFOENUM_TEAMDEVICEFAMILYINFOENUM_IOTDEVICEFAMILYINFOENUM_IOT_HEADLESSDEVICEFAMILYINFOENUM_SERVERDEVICEFAMILYINFOENUM_HOLOGRAPHICDEVICEFAMILYINFOENUM_XBOXSRADEVICEFAMILYINFOENUM_XBOXERADEVICEFAMILYINFOENUM_SERVER_NANODEVICEFAMILYINFOENUM_MAXDEVICEFAMILYDEVICEFORM_UNKNOWNDEVICEFAMILYDEVICEFORM_PHONEDEVICEFAMILYDEVICEFORM_TABLETDEVICEFAMILYDEVICEFORM_DESKTOPDEVICEFAMILYDEVICEFORM_NOTEBOOKDEVICEFAMILYDEVICEFORM_CONVERTIBLEDEVICEFAMILYDEVICEFORM_DETACHABLEDEVICEFAMILYDEVICEFORM_ALLINONEDEVICEFAMILYDEVICEFORM_STICKPCDEVICEFAMILYDEVICEFORM_PUCKDEVICEFAMILYDEVICEFORM_LARGESCREENDEVICEFAMILYDEVICEFORM_HMDDEVICEFAMILYDEVICEFORM_INDUSTRY_HANDHELDDEVICEFAMILYDEVICEFORM_INDUSTRY_TABLETDEVICEFAMILYDEVICEFORM_BANKINGDEVICEFAMILYDEVICEFORM_BUILDING_AUTOMATIONDEVICEFAMILYDEVICEFORM_DIGITAL_SIGNAGEDEVICEFAMILYDEVICEFORM_GAMINGDEVICEFAMILYDEVICEFORM_HOME_AUTOMATIONDEVICEFAMILYDEVICEFORM_INDUSTRIAL_AUTOMATIONDEVICEFAMILYDEVICEFORM_KIOSKDEVICEFAMILYDEVICEFORM_MAKER_BOARDDEVICEFAMILYDEVICEFORM_MEDICALDEVICEFAMILYDEVICEFORM_NETWORKINGDEVICEFAMILYDEVICEFORM_POINT_OF_SERVICEDEVICEFAMILYDEVICEFORM_PRINTINGDEVICEFAMILYDEVICEFORM_THIN_CLIENTDEVICEFAMILYDEVICEFORM_TOYDEVICEFAMILYDEVICEFORM_VENDINGDEVICEFAMILYDEVICEFORM_INDUSTRY_OTHERDEVICEFAMILYDEVICEFORM_MAXRtlGetDeviceFamilyInfoEnumRtlConvertDeviceFamilyInfoToStringRtlSwitchedVVIDLL_PROCESS_ATTACHDLL_THREAD_ATTACHDLL_THREAD_DETACHDLL_PROCESS_DETACHEVENTLOG_SEQUENTIAL_READEVENTLOG_SEEK_READEVENTLOG_FORWARDS_READEVENTLOG_BACKWARDS_READEVENTLOG_SUCCESSEVENTLOG_ERROR_TYPEEVENTLOG_WARNING_TYPEEVENTLOG_INFORMATION_TYPEEVENTLOG_AUDIT_SUCCESSEVENTLOG_AUDIT_FAILUREEVENTLOG_START_PAIRED_EVENTEVENTLOG_END_PAIRED_EVENTEVENTLOG_END_ALL_PAIRED_EVENTSEVENTLOG_PAIRED_EVENT_ACTIVEEVENTLOG_PAIRED_EVENT_INACTIVEPEVENTLOGRECORDEVENTLOGRECORDMAXLOGICALLOGNAMESIZEPEVENTSFORLOGFILEEVENTSFORLOGFILEPPACKEDEVENTINFOPACKEDEVENTINFOKEY_QUERY_VALUEKEY_SET_VALUEKEY_CREATE_SUB_KEYKEY_ENUMERATE_SUB_KEYSKEY_NOTIFYKEY_CREATE_LINKKEY_WOW64_64KEYKEY_WOW64_RESKEY_WRITEKEY_EXECUTEKEY_ALL_ACCESSREG_OPTION_RESERVEDREG_OPTION_NON_VOLATILEREG_OPTION_VOLATILEREG_OPTION_CREATE_LINKREG_OPTION_BACKUP_RESTOREREG_OPTION_OPEN_LINKREG_OPTION_DONT_VIRTUALIZEREG_LEGAL_OPTIONREG_OPEN_LEGAL_OPTIONREG_CREATED_NEW_KEYREG_OPENED_EXISTING_KEYREG_STANDARD_FORMATREG_LATEST_FORMATREG_NO_COMPRESSIONREG_WHOLE_HIVE_VOLATILEREG_REFRESH_HIVEREG_NO_LAZY_FLUSHREG_FORCE_RESTOREREG_APP_HIVEREG_PROCESS_PRIVATEREG_START_JOURNALREG_HIVE_EXACT_FILE_GROWTHREG_HIVE_NO_RMREG_HIVE_SINGLE_LOGREG_BOOT_HIVEREG_LOAD_HIVE_OPEN_HANDLEREG_FLUSH_HIVE_FILE_GROWTHREG_OPEN_READ_ONLYREG_IMMUTABLEREG_APP_HIVE_OPEN_READ_ONLYREG_FORCE_UNLOADREG_UNLOAD_LEGAL_FLAGSREG_NOTIFY_CHANGE_NAMEREG_NOTIFY_CHANGE_ATTRIBUTESREG_NOTIFY_CHANGE_LAST_SETREG_NOTIFY_CHANGE_SECURITYREG_NOTIFY_THREAD_AGNOSTICREG_LEGAL_CHANGE_FILTERREG_EXPAND_SZREG_BINARYREG_DWORDREG_DWORD_LITTLE_ENDIANREG_DWORD_BIG_ENDIANREG_LINKREG_MULTI_SZREG_RESOURCE_LISTREG_FULL_RESOURCE_DESCRIPTORREG_RESOURCE_REQUIREMENTS_LISTREG_QWORDREG_QWORD_LITTLE_ENDIANSERVICE_KERNEL_DRIVERSERVICE_FILE_SYSTEM_DRIVERSERVICE_ADAPTERSERVICE_RECOGNIZER_DRIVERSERVICE_DRIVERSERVICE_WIN32_OWN_PROCESSSERVICE_WIN32_SHARE_PROCESSSERVICE_WIN32SERVICE_USER_SERVICESERVICE_USERSERVICE_INSTANCESERVICE_USER_SHARE_PROCESSSERVICE_USER_OWN_PROCESSSERVICE_INTERACTIVE_PROCESSSERVICE_PKG_SERVICESERVICE_TYPE_ALLSERVICE_BOOT_STARTSERVICE_SYSTEM_STARTSERVICE_AUTO_STARTSERVICE_DEMAND_STARTSERVICE_DISABLEDSERVICE_ERROR_IGNORESERVICE_ERROR_NORMALSERVICE_ERROR_SEVERESERVICE_ERROR_CRITICALCM_SERVICE_NETWORK_BOOT_LOADCM_SERVICE_VIRTUAL_DISK_BOOT_LOADCM_SERVICE_USB_DISK_BOOT_LOADCM_SERVICE_SD_DISK_BOOT_LOADCM_SERVICE_USB3_DISK_BOOT_LOADCM_SERVICE_MEASURED_BOOT_LOADCM_SERVICE_VERIFIER_BOOT_LOADCM_SERVICE_WINPE_BOOT_LOADCM_SERVICE_VALID_PROMOTION_MASKTAPE_ERASE_SHORTTAPE_ERASE_LONGPTAPE_ERASETAPE_ERASETAPE_LOADTAPE_UNLOADTAPE_TENSIONTAPE_LOCKTAPE_UNLOCKTAPE_FORMATPTAPE_PREPARETAPE_PREPARETAPE_SETMARKSTAPE_FILEMARKSTAPE_SHORT_FILEMARKSTAPE_LONG_FILEMARKSPTAPE_WRITE_MARKSTAPE_WRITE_MARKSTAPE_ABSOLUTE_POSITIONTAPE_LOGICAL_POSITIONTAPE_PSEUDO_LOGICAL_POSITIONPTAPE_GET_POSITIONTAPE_GET_POSITIONTAPE_REWINDTAPE_ABSOLUTE_BLOCKTAPE_LOGICAL_BLOCKTAPE_PSEUDO_LOGICAL_BLOCKTAPE_SPACE_END_OF_DATATAPE_SPACE_RELATIVE_BLOCKSTAPE_SPACE_FILEMARKSTAPE_SPACE_SEQUENTIAL_FMKSTAPE_SPACE_SETMARKSTAPE_SPACE_SEQUENTIAL_SMKSPTAPE_SET_POSITIONTAPE_SET_POSITIONTAPE_DRIVE_FIXEDTAPE_DRIVE_SELECTTAPE_DRIVE_INITIATORTAPE_DRIVE_ERASE_SHORTTAPE_DRIVE_ERASE_LONGTAPE_DRIVE_ERASE_BOP_ONLYTAPE_DRIVE_ERASE_IMMEDIATETAPE_DRIVE_TAPE_CAPACITYTAPE_DRIVE_TAPE_REMAININGTAPE_DRIVE_FIXED_BLOCKTAPE_DRIVE_VARIABLE_BLOCKTAPE_DRIVE_WRITE_PROTECTTAPE_DRIVE_EOT_WZ_SIZETAPE_DRIVE_ECCTAPE_DRIVE_COMPRESSIONTAPE_DRIVE_PADDINGTAPE_DRIVE_REPORT_SMKSTAPE_DRIVE_GET_ABSOLUTE_BLKTAPE_DRIVE_GET_LOGICAL_BLKTAPE_DRIVE_SET_EOT_WZ_SIZETAPE_DRIVE_EJECT_MEDIATAPE_DRIVE_CLEAN_REQUESTSTAPE_DRIVE_SET_CMP_BOP_ONLYTAPE_DRIVE_RESERVED_BITTAPE_DRIVE_LOAD_UNLOADTAPE_DRIVE_TENSIONTAPE_DRIVE_LOCK_UNLOCKTAPE_DRIVE_REWIND_IMMEDIATETAPE_DRIVE_SET_BLOCK_SIZETAPE_DRIVE_LOAD_UNLD_IMMEDTAPE_DRIVE_TENSION_IMMEDTAPE_DRIVE_LOCK_UNLK_IMMEDTAPE_DRIVE_SET_ECCTAPE_DRIVE_SET_COMPRESSIONTAPE_DRIVE_SET_PADDINGTAPE_DRIVE_SET_REPORT_SMKSTAPE_DRIVE_ABSOLUTE_BLKTAPE_DRIVE_ABS_BLK_IMMEDTAPE_DRIVE_LOGICAL_BLKTAPE_DRIVE_LOG_BLK_IMMEDTAPE_DRIVE_END_OF_DATATAPE_DRIVE_RELATIVE_BLKSTAPE_DRIVE_FILEMARKSTAPE_DRIVE_SEQUENTIAL_FMKSTAPE_DRIVE_SETMARKSTAPE_DRIVE_SEQUENTIAL_SMKSTAPE_DRIVE_REVERSE_POSITIONTAPE_DRIVE_SPACE_IMMEDIATETAPE_DRIVE_WRITE_SETMARKSTAPE_DRIVE_WRITE_FILEMARKSTAPE_DRIVE_WRITE_SHORT_FMKSTAPE_DRIVE_WRITE_LONG_FMKSTAPE_DRIVE_WRITE_MARK_IMMEDTAPE_DRIVE_FORMATTAPE_DRIVE_FORMAT_IMMEDIATETAPE_DRIVE_HIGH_FEATURESPTAPE_GET_DRIVE_PARAMETERSTAPE_GET_DRIVE_PARAMETERSPTAPE_SET_DRIVE_PARAMETERSTAPE_SET_DRIVE_PARAMETERSPTAPE_GET_MEDIA_PARAMETERSTAPE_GET_MEDIA_PARAMETERSPTAPE_SET_MEDIA_PARAMETERSTAPE_SET_MEDIA_PARAMETERSTAPE_FIXED_PARTITIONSTAPE_SELECT_PARTITIONSTAPE_INITIATOR_PARTITIONSPTAPE_CREATE_PARTITIONTAPE_CREATE_PARTITIONTAPE_QUERY_DRIVE_PARAMETERSTAPE_QUERY_MEDIA_CAPACITYTAPE_CHECK_FOR_DRIVE_PROBLEMTAPE_QUERY_IO_ERROR_DATATAPE_QUERY_DEVICE_ERROR_DATAPTAPE_WMI_OPERATIONSTAPE_WMI_OPERATIONSTRANSACTIONMANAGER_QUERY_INFORMATIONTRANSACTIONMANAGER_SET_INFORMATIONTRANSACTIONMANAGER_RECOVERTRANSACTIONMANAGER_RENAMETRANSACTIONMANAGER_CREATE_RMTRANSACTIONMANAGER_BIND_TRANSACTIONTRANSACTIONMANAGER_GENERIC_READTRANSACTIONMANAGER_GENERIC_WRITETRANSACTIONMANAGER_GENERIC_EXECUTETRANSACTIONMANAGER_ALL_ACCESSTRANSACTION_QUERY_INFORMATIONTRANSACTION_SET_INFORMATIONTRANSACTION_ENLISTTRANSACTION_COMMITTRANSACTION_ROLLBACKTRANSACTION_PROPAGATETRANSACTION_RIGHT_RESERVED1TRANSACTION_GENERIC_READTRANSACTION_GENERIC_WRITETRANSACTION_GENERIC_EXECUTETRANSACTION_ALL_ACCESSTRANSACTION_RESOURCE_MANAGER_RIGHTSRESOURCEMANAGER_QUERY_INFORMATIONRESOURCEMANAGER_SET_INFORMATIONRESOURCEMANAGER_RECOVERRESOURCEMANAGER_ENLISTRESOURCEMANAGER_GET_NOTIFICATIONRESOURCEMANAGER_REGISTER_PROTOCOLRESOURCEMANAGER_COMPLETE_PROPAGATIONRESOURCEMANAGER_GENERIC_READRESOURCEMANAGER_GENERIC_WRITERESOURCEMANAGER_GENERIC_EXECUTERESOURCEMANAGER_ALL_ACCESSENLISTMENT_QUERY_INFORMATIONENLISTMENT_SET_INFORMATIONENLISTMENT_RECOVERENLISTMENT_SUBORDINATE_RIGHTSENLISTMENT_SUPERIOR_RIGHTSENLISTMENT_GENERIC_READENLISTMENT_GENERIC_WRITEENLISTMENT_GENERIC_EXECUTEENLISTMENT_ALL_ACCESSPTRANSACTION_BASIC_INFORMATIONTRANSACTION_BASIC_INFORMATIONPTRANSACTIONMANAGER_BASIC_INFORMATIONTRANSACTIONMANAGER_BASIC_INFORMATIONPTRANSACTIONMANAGER_LOG_INFORMATIONTRANSACTIONMANAGER_LOG_INFORMATIONPTRANSACTIONMANAGER_LOGPATH_INFORMATIONTRANSACTIONMANAGER_LOGPATH_INFORMATIONPTRANSACTIONMANAGER_RECOVERY_INFORMATIONTRANSACTIONMANAGER_RECOVERY_INFORMATIONPTRANSACTIONMANAGER_OLDEST_INFORMATIONTRANSACTIONMANAGER_OLDEST_INFORMATIONPTRANSACTION_PROPERTIES_INFORMATIONTRANSACTION_PROPERTIES_INFORMATIONPTRANSACTION_BIND_INFORMATIONTRANSACTION_BIND_INFORMATIONPTRANSACTION_ENLISTMENT_PAIRTRANSACTION_ENLISTMENT_PAIRPTRANSACTION_ENLISTMENTS_INFORMATIONTRANSACTION_ENLISTMENTS_INFORMATIONPTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATIONTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATIONPRESOURCEMANAGER_BASIC_INFORMATIONRESOURCEMANAGER_BASIC_INFORMATIONPRESOURCEMANAGER_COMPLETION_INFORMATIONRESOURCEMANAGER_COMPLETION_INFORMATIONPENLISTMENT_BASIC_INFORMATIONENLISTMENT_BASIC_INFORMATIONPENLISTMENT_CRM_INFORMATIONENLISTMENT_CRM_INFORMATIONPTRANSACTION_LIST_ENTRYTRANSACTION_LIST_ENTRYPTRANSACTION_LIST_INFORMATIONTRANSACTION_LIST_INFORMATIONPKTMOBJECT_TYPEKTMOBJECT_TYPEPKTMOBJECT_CURSORKTMOBJECT_CURSORTP_VERSIONPTP_VERSIONTP_CALLBACK_INSTANCETP_POOLTP_POOL_STACK_INFORMATIONTP_CLEANUP_GROUPTP_CALLBACK_ENVIRONTP_CALLBACK_ENVIRON_V3TP_WORKTP_TIMERTP_WAIT_RESULTTP_WAITTP_IOACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATIONACTIVATION_CONTEXT_SECTION_DLL_REDIRECTIONACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTIONACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTIONACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTIONACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTIONACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTIONACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLEACTIVATION_CONTEXT_SECTION_CLR_SURROGATESACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGSACTIVATION_CONTEXT_SECTION_COMPATIBILITY_INFO//! This module defines the 32-Bit Windows types and constants that are defined by NT, but exposed//! through the Win32 API.LSTATUSRRF_RT_REG_NONERRF_RT_REG_SZRRF_RT_REG_EXPAND_SZRRF_RT_REG_BINARYRRF_RT_REG_DWORDRRF_RT_REG_MULTI_SZRRF_RT_REG_QWORDRRF_RT_DWORDRRF_RT_QWORDRRF_RT_ANYRRF_SUBKEY_WOW6464KEYRRF_SUBKEY_WOW6432KEYRRF_WOW64_MASKRRF_NOEXPANDRRF_ZEROONFAILUREREG_PROCESS_APPKEYHKEY_CLASSES_ROOTHKEY_CURRENT_USERHKEY_USERSHKEY_PERFORMANCE_DATAHKEY_PERFORMANCE_TEXTHKEY_PERFORMANCE_NLSTEXTHKEY_CURRENT_CONFIGHKEY_DYN_DATAHKEY_CURRENT_USER_LOCAL_SETTINGS// PROVIDER_KEEPS_VALUE_LENGTH// val_context// PVALUEA// PVALUEW// QUERYHANDLER// REG_PROVIDERPVALENTAVALENTAPVALENTWVALENTWREG_MUI_STRING_TRUNCATE// WIN31_CLASSREG_SECURE_CONNECTIONRegOverridePredefKeyRegOpenUserClassesRootRegOpenCurrentUserRegDisablePredefinedCacheRegDisablePredefinedCacheExRegConnectRegistryARegConnectRegistryWRegConnectRegistryExARegConnectRegistryExWRegCreateKeyARegCreateKeyWRegCreateKeyExARegCreateKeyExWRegCreateKeyTransactedARegCreateKeyTransactedWRegDeleteKeyARegDeleteKeyWRegDeleteKeyExARegDeleteKeyExWRegDeleteKeyTransactedARegDeleteKeyTransactedWRegDisableReflectionKeyRegEnableReflectionKeyRegQueryReflectionKeyRegDeleteValueARegDeleteValueWRegEnumKeyARegEnumKeyWRegEnumKeyExARegEnumValueARegEnumValueWRegFlushKeyRegGetKeySecurityRegLoadKeyARegLoadKeyWRegNotifyChangeKeyValueRegOpenKeyARegOpenKeyWRegOpenKeyExARegOpenKeyTransactedARegOpenKeyTransactedWRegQueryInfoKeyARegQueryInfoKeyWRegQueryValueARegQueryValueWRegQueryMultipleValuesARegQueryMultipleValuesWRegQueryValueExARegReplaceKeyARegReplaceKeyWRegRestoreKeyARegRestoreKeyWRegRenameKeyRegSaveKeyARegSaveKeyWRegSetKeySecurityRegSetValueARegSetValueWRegSetValueExARegSetValueExWRegUnLoadKeyARegUnLoadKeyWRegDeleteKeyValueARegDeleteKeyValueWRegSetKeyValueARegSetKeyValueWRegDeleteTreeARegDeleteTreeWRegCopyTreeARegGetValueARegGetValueWRegCopyTreeWRegLoadMUIStringARegLoadMUIStringWRegLoadAppKeyARegLoadAppKeyWInitiateSystemShutdownAAbortSystemShutdownAAbortSystemShutdownWREASON_SWINSTALLREASON_HWINSTALLREASON_SERVICEHANGREASON_UNSTABLEREASON_SWHWRECONFREASON_OTHERREASON_UNKNOWNREASON_LEGACY_APIREASON_PLANNED_FLAGMAX_SHUTDOWN_TIMEOUTInitiateSystemShutdownExAInitiateSystemShutdownExWSHUTDOWN_FORCE_OTHERSSHUTDOWN_FORCE_SELFSHUTDOWN_RESTARTSHUTDOWN_POWEROFFSHUTDOWN_NOREBOOTSHUTDOWN_GRACE_OVERRIDESHUTDOWN_INSTALL_UPDATESSHUTDOWN_RESTARTAPPSSHUTDOWN_SKIP_SVC_PRESHUTDOWNSHUTDOWN_HYBRIDSHUTDOWN_RESTART_BOOTOPTIONSSHUTDOWN_SOFT_REBOOTSHUTDOWN_MOBILE_UISHUTDOWN_ARSOInitiateShutdownAInitiateShutdownWCheckForHiberbootRegSaveKeyExARegSaveKeyExWSAFER_SCOPEID_MACHINESAFER_SCOPEID_USERSAFER_LEVELID_DISALLOWEDSAFER_LEVELID_UNTRUSTEDSAFER_LEVELID_CONSTRAINEDSAFER_LEVELID_NORMALUSERSAFER_LEVELID_FULLYTRUSTEDSAFER_LEVEL_OPENSAFER_MAX_FRIENDLYNAME_SIZESAFER_MAX_DESCRIPTION_SIZESAFER_MAX_HASH_SIZESAFER_TOKEN_NULL_IF_EQUALSAFER_TOKEN_COMPARE_ONLYSAFER_TOKEN_MAKE_INERTSAFER_TOKEN_WANT_FLAGSSAFER_CRITERIA_IMAGEPATHSAFER_CRITERIA_NOSIGNEDHASHSAFER_CRITERIA_IMAGEHASHSAFER_CRITERIA_AUTHENTICODESAFER_CRITERIA_URLZONESAFER_CRITERIA_APPX_PACKAGESAFER_CRITERIA_IMAGEPATH_NTPSAFER_CODE_PROPERTIES_V1SAFER_CODE_PROPERTIES_V1PSAFER_CODE_PROPERTIES_V2SAFER_CODE_PROPERTIES_V2SAFER_CODE_PROPERTIESPSAFER_CODE_PROPERTIESSAFER_POLICY_JOBID_MASKSAFER_POLICY_JOBID_CONSTRAINEDSAFER_POLICY_JOBID_UNTRUSTEDSAFER_POLICY_ONLY_EXESSAFER_POLICY_SANDBOX_INERTSAFER_POLICY_HASH_DUPLICATESAFER_POLICY_ONLY_AUDITSAFER_POLICY_BLOCK_CLIENT_UISAFER_POLICY_UIFLAGS_MASKSAFER_POLICY_UIFLAGS_INFORMATION_PROMPTSAFER_POLICY_UIFLAGS_OPTION_PROMPTSAFER_POLICY_UIFLAGS_HIDDENPSAFER_IDENTIFICATION_HEADERSAFER_IDENTIFICATION_HEADERPSAFER_PATHNAME_IDENTIFICATIONSAFER_PATHNAME_IDENTIFICATIONPSAFER_HASH_IDENTIFICATIONSAFER_HASH_IDENTIFICATIONPSAFER_HASH_IDENTIFICATION2SAFER_HASH_IDENTIFICATION2PSAFER_URLZONE_IDENTIFICATIONSAFER_URLZONE_IDENTIFICATIONSaferGetPolicyInformationSAFER_POLICY_INFO_CLASSSaferSetPolicyInformationSaferCreateLevelSAFER_LEVEL_HANDLESaferCloseLevelSaferIdentifyLevelSaferComputeTokenFromLevelSaferGetLevelInformationSAFER_OBJECT_INFO_CLASSSaferSetLevelInformationSaferRecordEventLogEntrySaferiIsExecutableFileTypeSRP_POLICY_EXESRP_POLICY_DLLSRP_POLICY_MSISRP_POLICY_SCRIPTSRP_POLICY_SHELLSRP_POLICY_NOV2SRP_POLICY_APPXSRP_POLICY_WLDPMSISRP_POLICY_WLDPSCRIPTSRP_POLICY_WLDPCONFIGCISRP_POLICY_MANAGEDINSTALLER// This header file provides the definitions and symbols necessary for an// Application or Smart Card Service Provider to access the Smartcard Subsystem.LPCSCARD_IO_REQUESTLPSCARD_IO_REQUESTSCARDCONTEXTPSCARDCONTEXTLPSCARDCONTEXTSCARDHANDLEPSCARDHANDLELPSCARDHANDLESCARD_AUTOALLOCATESCARD_SCOPE_USERSCARD_SCOPE_TERMINALSCARD_SCOPE_SYSTEMSCardEstablishContextSCardReleaseContextSCardIsValidContextSCARD_PROVIDER_PRIMARYSCARD_PROVIDER_CSPSCARD_PROVIDER_KSPSCardListReaderGroupsASCardListReaderGroupsWSCardListReadersASCardListReadersWSCardListCardsASCardListCardsWSCardListInterfacesASCardListInterfacesWSCardGetProviderIdASCardGetProviderIdWSCardGetCardTypeProviderNameASCardGetCardTypeProviderNameWSCardIntroduceReaderGroupASCardIntroduceReaderGroupWSCardForgetReaderGroupASCardForgetReaderGroupWSCardIntroduceReaderASCardIntroduceReaderWSCardForgetReaderASCardForgetReaderWSCardAddReaderToGroupASCardAddReaderToGroupWSCardRemoveReaderFromGroupASCardRemoveReaderFromGroupWSCardIntroduceCardTypeASCardIntroduceCardTypeWSCardSetCardTypeProviderNameASCardSetCardTypeProviderNameWSCardForgetCardTypeASCardForgetCardTypeWSCardFreeMemorySCardAccessStartedEventSCardReleaseStartedEventPSCARD_READERSTATEASCARD_READERSTATEALPSCARD_READERSTATEAPSCARD_READERSTATEWSCARD_READERSTATEWLPSCARD_READERSTATEWSCARD_READERSTATE_ASCARD_READERSTATE_WPSCARD_READERSTATE_APSCARD_READERSTATE_WLPSCARD_READERSTATE_ALPSCARD_READERSTATE_WSCARD_STATE_UNAWARESCARD_STATE_IGNORESCARD_STATE_CHANGEDSCARD_STATE_UNKNOWNSCARD_STATE_UNAVAILABLESCARD_STATE_EMPTYSCARD_STATE_PRESENTSCARD_STATE_ATRMATCHSCARD_STATE_EXCLUSIVESCARD_STATE_INUSESCARD_STATE_MUTESCARD_STATE_UNPOWEREDSCardLocateCardsASCardLocateCardsWPSCARD_ATRMASKSCARD_ATRMASKLPSCARD_ATRMASKSCardLocateCardsByATRASCardLocateCardsByATRWSCardGetStatusChangeASCardGetStatusChangeWSCardCancelSCARD_SHARE_EXCLUSIVESCARD_SHARE_SHAREDSCARD_SHARE_DIRECTSCARD_LEAVE_CARDSCARD_RESET_CARDSCARD_UNPOWER_CARDSCARD_EJECT_CARDSCardConnectASCardConnectWSCardReconnectSCardDisconnectSCardBeginTransactionSCardEndTransactionSCardStateSCardStatusASCardStatusWSCardTransmitSCardGetTransmitCountSCardControlSCardGetAttribSCardSetAttribSC_DLG_MINIMAL_UISC_DLG_NO_UISC_DLG_FORCE_UISCERR_NOCARDNAMESCERR_NOGUIDSPOPENCARD_SEARCH_CRITERIAAOPENCARD_SEARCH_CRITERIAALPOPENCARD_SEARCH_CRITERIAAPOPENCARD_SEARCH_CRITERIAWOPENCARD_SEARCH_CRITERIAWLPOPENCARD_SEARCH_CRITERIAWPOPENCARDNAME_EXAOPENCARDNAME_EXALPOPENCARDNAME_EXAPOPENCARDNAME_EXWOPENCARDNAME_EXWLPOPENCARDNAME_EXWOPENCARDNAMEA_EXOPENCARDNAMEW_EXPOPENCARDNAMEA_EXPOPENCARDNAMEW_EXLPOPENCARDNAMEA_EXLPOPENCARDNAMEW_EXSCARD_READER_SEL_AUTH_PACKAGEPREADER_SEL_REQUESTREADER_SEL_REQUESTPREADER_SEL_RESPONSEREADER_SEL_RESPONSEPOPENCARDNAMEAOPENCARDNAMEALPOPENCARDNAMEAPOPENCARDNAMEWOPENCARDNAMEWLPOPENCARDNAMEWOPENCARDNAME_AOPENCARDNAME_WPOPENCARDNAME_APOPENCARDNAME_WLPOPENCARDNAME_ALPOPENCARDNAME_WSCardReadCacheASCardReadCacheWSCardWriteCacheASCardWriteCacheWSCardGetReaderIconASCardGetReaderIconWSCardGetDeviceTypeIdASCardGetDeviceTypeIdWSCardGetReaderDeviceInstanceIdASCardGetReaderDeviceInstanceIdWSCardListReadersWithDeviceInstanceIdASCardListReadersWithDeviceInstanceIdWSCARD_AUDIT_CHV_FAILURESCARD_AUDIT_CHV_SUCCESSSCardAuditUWORDSCARD_ATR_LENGTHLSCARD_PROTOCOL_UNDEFINEDSCARD_PROTOCOL_T0SCARD_PROTOCOL_T1SCARD_PROTOCOL_RAWSCARD_PROTOCOL_TxSCARD_PROTOCOL_DEFAULTSCARD_PROTOCOL_OPTIMALSCARD_POWER_DOWNSCARD_COLD_RESETSCARD_WARM_RESETIOCTL_SMARTCARD_POWERIOCTL_SMARTCARD_GET_ATTRIBUTEIOCTL_SMARTCARD_SET_ATTRIBUTEIOCTL_SMARTCARD_CONFISCATEIOCTL_SMARTCARD_TRANSMITIOCTL_SMARTCARD_EJECTIOCTL_SMARTCARD_SWALLOWIOCTL_SMARTCARD_IS_PRESENTIOCTL_SMARTCARD_IS_ABSENTIOCTL_SMARTCARD_SET_PROTOCOLIOCTL_SMARTCARD_GET_STATEIOCTL_SMARTCARD_GET_LAST_ERRORIOCTL_SMARTCARD_GET_PERF_CNTRMAXIMUM_ATTR_STRING_LENGTHMAXIMUM_SMARTCARD_READERSSCARD_CLASS_VENDOR_INFOSCARD_CLASS_COMMUNICATIONSSCARD_CLASS_PROTOCOLSCARD_CLASS_POWER_MGMTSCARD_CLASS_SECURITYSCARD_CLASS_MECHANICALSCARD_CLASS_VENDOR_DEFINEDSCARD_CLASS_IFD_PROTOCOLSCARD_CLASS_ICC_STATESCARD_CLASS_PERFSCARD_CLASS_SYSTEMSCARD_ATTR_VENDOR_NAMESCARD_ATTR_VENDOR_IFD_TYPESCARD_ATTR_VENDOR_IFD_VERSIONSCARD_ATTR_VENDOR_IFD_SERIAL_NOSCARD_ATTR_CHANNEL_IDSCARD_ATTR_PROTOCOL_TYPESSCARD_ATTR_DEFAULT_CLKSCARD_ATTR_MAX_CLKSCARD_ATTR_DEFAULT_DATA_RATESCARD_ATTR_MAX_DATA_RATESCARD_ATTR_MAX_IFSDSCARD_ATTR_POWER_MGMT_SUPPORTSCARD_ATTR_USER_TO_CARD_AUTH_DEVICESCARD_ATTR_USER_AUTH_INPUT_DEVICESCARD_ATTR_CHARACTERISTICSSCARD_ATTR_CURRENT_PROTOCOL_TYPESCARD_ATTR_CURRENT_CLKSCARD_ATTR_CURRENT_FSCARD_ATTR_CURRENT_DSCARD_ATTR_CURRENT_NSCARD_ATTR_CURRENT_WSCARD_ATTR_CURRENT_IFSCSCARD_ATTR_CURRENT_IFSDSCARD_ATTR_CURRENT_BWTSCARD_ATTR_CURRENT_CWTSCARD_ATTR_CURRENT_EBC_ENCODINGSCARD_ATTR_EXTENDED_BWTSCARD_ATTR_ICC_PRESENCESCARD_ATTR_ICC_INTERFACE_STATUSSCARD_ATTR_CURRENT_IO_STATESCARD_ATTR_ATR_STRINGSCARD_ATTR_ICC_TYPE_PER_ATRSCARD_ATTR_ESC_RESETSCARD_ATTR_ESC_CANCELSCARD_ATTR_ESC_AUTHREQUESTSCARD_ATTR_MAXINPUTSCARD_ATTR_DEVICE_UNITSCARD_ATTR_DEVICE_IN_USESCARD_ATTR_DEVICE_FRIENDLY_NAME_ASCARD_ATTR_DEVICE_SYSTEM_NAME_ASCARD_ATTR_DEVICE_FRIENDLY_NAME_WSCARD_ATTR_DEVICE_SYSTEM_NAME_WSCARD_ATTR_SUPRESS_T1_IFS_REQUESTSCARD_PERF_NUM_TRANSMISSIONSSCARD_PERF_BYTES_TRANSMITTEDSCARD_PERF_TRANSMISSION_TIMESCARD_T0_HEADER_LENGTHSCARD_T0_CMD_LENGTHSCARD_T1_PROLOGUE_LENGTHSCARD_T1_EPILOGUE_LENGTHSCARD_T1_MAX_IFSSCARD_UNKNOWNSCARD_ABSENTSCARD_PRESENTSCARD_SWALLOWEDSCARD_POWEREDSCARD_NEGOTIABLESCARD_SPECIFICPSCARD_IO_REQUESTSCARD_IO_REQUESTLPSCARD_T0_COMMANDSCARD_T0_COMMANDPSCARD_T0_REQUESTSCARD_T0_REQUESTLPSCARD_T0_REQUESTPSCARD_T1_REQUESTSCARD_T1_REQUESTLPSCARD_T1_REQUESTSCARD_READER_SWALLOWSSCARD_READER_EJECTSSCARD_READER_CONFISCATESSCARD_READER_TYPE_SERIALSCARD_READER_TYPE_PARALELLSCARD_READER_TYPE_KEYBOARDSCARD_READER_TYPE_SCSISCARD_READER_TYPE_IDESCARD_READER_TYPE_USBSCARD_READER_TYPE_PCMCIASCARD_READER_TYPE_TPMSCARD_READER_TYPE_NFCSCARD_READER_TYPE_UICCSCARD_READER_TYPE_VENDOR//! Smart Card class/port IOCTL codes.__uint32WINSOCK_VERSIONu_int64__WSAFDIsSetSIOCSHIWATSIOCGHIWATSIOCSLOWATSIOCGLOWATIMPLINK_IPIMPLINK_LOWEXPERIMPLINK_HIGHEXPERADDR_ANYWSADESCRIPTION_LENWSASYS_STATUS_LENLPWSADATAFROM_PROTOCOL_INFOSO_PROTOCOL_INFOAPVD_CONFIGPF_VOICEVIEWPF_FIREFOXPF_UNKNOWN1PF_BANPF_BTHSOMAXCONN_HINTMSG_PUSH_IMMEDIATEMSG_PARTIALMSG_INTERRUPTMAXGETHOSTSTRUCTFD_READ_BITFD_READFD_WRITE_BITFD_WRITEFD_OOB_BITFD_OOBFD_ACCEPT_BITFD_ACCEPTFD_CONNECT_BITFD_CONNECTFD_CLOSE_BITFD_CLOSEFD_QOS_BITFD_QOSFD_GROUP_QOS_BITFD_GROUP_QOSFD_ROUTING_INTERFACE_CHANGE_BITFD_ROUTING_INTERFACE_CHANGEFD_ADDRESS_LIST_CHANGE_BITFD_ADDRESS_LIST_CHANGEFD_MAX_EVENTSFD_ALL_EVENTSh_errnoWSANO_ADDRESSWSAEVENTLPWSAEVENTWSAOVERLAPPEDWSA_IO_PENDINGWSA_IO_INCOMPLETEWSA_INVALID_HANDLEWSA_INVALID_PARAMETERWSA_NOT_ENOUGH_MEMORYWSA_OPERATION_ABORTEDWSA_INVALID_EVENTWSA_MAXIMUM_WAIT_EVENTSWSA_WAIT_FAILEDWSA_WAIT_EVENT_0WSA_WAIT_IO_COMPLETIONWSA_WAIT_TIMEOUTWSA_INFINITELPQOSQOSCF_ACCEPTCF_REJECTCF_DEFERSG_UNCONSTRAINED_GROUPSG_CONSTRAINED_GROUPLPWSANETWORKEVENTSWSANETWORKEVENTSMAX_PROTOCOL_CHAINBASE_PROTOCOLLAYERED_PROTOCOLLPWSAPROTOCOLCHAINWSAPROTOCOLCHAINWSAPROTOCOL_LENLPWSAPROTOCOL_INFOAWSAPROTOCOL_INFOALPWSAPROTOCOL_INFOWPFL_MULTIPLE_PROTO_ENTRIESPFL_RECOMMENDED_PROTO_ENTRYPFL_HIDDENPFL_MATCHES_PROTOCOL_ZEROPFL_NETWORKDIRECT_PROVIDERXP1_CONNECTIONLESSXP1_GUARANTEED_DELIVERYXP1_GUARANTEED_ORDERXP1_MESSAGE_ORIENTEDXP1_PSEUDO_STREAMXP1_GRACEFUL_CLOSEXP1_EXPEDITED_DATAXP1_CONNECT_DATAXP1_DISCONNECT_DATAXP1_SUPPORT_BROADCASTXP1_SUPPORT_MULTIPOINTXP1_MULTIPOINT_CONTROL_PLANEXP1_MULTIPOINT_DATA_PLANEXP1_QOS_SUPPORTEDXP1_INTERRUPTXP1_UNI_SENDXP1_UNI_RECVXP1_IFS_HANDLESXP1_PARTIAL_MESSAGEXP1_SAN_SUPPORT_SDPBIGENDIANLITTLEENDIANSECURITY_PROTOCOL_NONEJL_SENDER_ONLYJL_RECEIVER_ONLYJL_BOTHWSA_FLAG_MULTIPOINT_C_ROOTWSA_FLAG_MULTIPOINT_C_LEAFWSA_FLAG_MULTIPOINT_D_ROOTWSA_FLAG_MULTIPOINT_D_LEAFWSA_FLAG_ACCESS_SYSTEM_SECURITYWSA_FLAG_REGISTERED_IOPWSACOMPLETIONTYPEWSACOMPLETIONTYPELPWSACOMPLETIONTYPEPWSACOMPLETIONWSACOMPLETIONLPWSACOMPLETIONTH_NETDEVTH_TAPISERVICE_MULTIPLENS_LOCALNAMERES_UNUSED_1RES_FLUSH_CACHERES_SERVICESERVICE_TYPE_VALUE_IPXPORTSERVICE_TYPE_VALUE_SAPIDSERVICE_TYPE_VALUE_TCPPORTSERVICE_TYPE_VALUE_UDPPORTSERVICE_TYPE_VALUE_OBJECTIDPAFPROTOCOLSAFPROTOCOLSLPAFPROTOCOLSPWSAECOMPARATORWSAECOMPARATORLPWSAECOMPARATORPWSAVERSIONWSAVERSIONLPWSAVERSIONPWSAQUERYSETAWSAQUERYSETALPWSAQUERYSETAPWSAQUERYSETWWSAQUERYSETWLPWSAQUERYSETWPWSAQUERYSET2AWSAQUERYSET2ALPWSAQUERYSET2APWSAQUERYSET2WWSAQUERYSET2WLPWSAQUERYSET2WLUP_DEEPLUP_CONTAINERSLUP_NOCONTAINERSLUP_NEARESTLUP_RETURN_NAMELUP_RETURN_TYPELUP_RETURN_VERSIONLUP_RETURN_COMMENTLUP_RETURN_ADDRLUP_RETURN_BLOBLUP_RETURN_ALIASESLUP_RETURN_QUERY_STRINGLUP_RETURN_ALLLUP_RES_SERVICELUP_FLUSHCACHELUP_FLUSHPREVIOUSLUP_NON_AUTHORITATIVELUP_SECURELUP_RETURN_PREFERRED_NAMESLUP_DNS_ONLYLUP_ADDRCONFIGLUP_DUAL_ADDRLUP_FILESERVERLUP_DISABLE_IDN_ENCODINGLUP_API_ANSILUP_RESOLUTION_HANDLERESULT_IS_ALIASRESULT_IS_ADDEDRESULT_IS_CHANGEDRESULT_IS_DELETEDPWSAESETSERVICEOPLPWSAESETSERVICEOPPWSANSCLASSINFOAWSANSCLASSINFOALPWSANSCLASSINFOAPWSANSCLASSINFOWWSANSCLASSINFOWLPWSANSCLASSINFOWPWSASERVICECLASSINFOAWSASERVICECLASSINFOALPWSASERVICECLASSINFOAPWSASERVICECLASSINFOWWSASERVICECLASSINFOWLPWSASERVICECLASSINFOWPWSANAMESPACE_INFOAWSANAMESPACE_INFOALPWSANAMESPACE_INFOAPWSANAMESPACE_INFOWWSANAMESPACE_INFOWLPWSANAMESPACE_INFOWPWSANAMESPACE_INFOEXAWSANAMESPACE_INFOEXALPWSANAMESPACE_INFOEXAPWSANAMESPACE_INFOEXWWSANAMESPACE_INFOEXWLPWSANAMESPACE_INFOEXWPWSAPOLLFDinet_addrinet_ntoa_WS2_32_WINSOCK_SWAP_LONG_WS2_32_WINSOCK_SWAP_LONGLONGhtonllntohllhtonfntohfhtondntohdgethostbyaddrgethostbynameGetHostNameWWSASetLastErrorWSAIsBlockingWSAUnhookBlockingHookWSASetBlockingHookWSACancelBlockingCallWSAAsyncGetServByNameWSAAsyncGetServByPortWSAAsyncGetProtoByNameWSAAsyncGetProtoByNumberWSAAsyncGetHostByNameWSAAsyncGetHostByAddrWSACancelAsyncRequestWSAAsyncSelectWSAAcceptLPCONDITIONPROCWSACloseEventWSAConnectWSAConnectByNameWWSAConnectByNameAWSAConnectByListWSACreateEventWSADuplicateSocketAWSAEnumNetworkEventsWSAEnumProtocolsAWSAEnumProtocolsWWSAEventSelectWSAGetOverlappedResultWSAGetQOSByNameWSAHtonlWSAHtonsWSAJoinLeafWSANtohlWSANtohsWSARecvWSARecvDisconnectWSARecvFromWSAResetEventWSASendWSASendMsgWSASendDisconnectWSASendToWSASetEventWSASocketAWSAWaitForMultipleEventsWSAAddressToStringAWSAAddressToStringWWSAStringToAddressAWSAStringToAddressWWSALookupServiceBeginAWSALookupServiceBeginWWSALookupServiceNextAWSALookupServiceNextWWSANSPIoctlWSALookupServiceEndWSAInstallServiceClassAWSAInstallServiceClassWWSARemoveServiceClassWSAGetServiceClassInfoAWSAGetServiceClassInfoWWSAEnumNameSpaceProvidersAWSAEnumNameSpaceProvidersWWSAEnumNameSpaceProvidersExAWSAEnumNameSpaceProvidersExWWSAGetServiceClassNameByClassIdAWSAGetServiceClassNameByClassIdWWSASetServiceAWSASetServiceWWSAProviderConfigChangeLPSOCKADDR_INPLINGERLPLINGERPFD_SETLPFD_SETHOSTENTPHOSTENTLPHOSTENTSERVENTPSERVENTLPSERVENTPROTOENTPPROTOENTLPPROTOENTTIMEVALPTIMEVALLPTIMEVALWSAMAKEASYNCREPLYWSAMAKESELECTREPLYWSAGETASYNCBUFLENWSAGETASYNCERRORWSAGETSELECTEVENTWSAGETSELECTERROR//! Definitions to be used with the WinSock 2 DLL and WinSock 2 applications.PPRINTER_INFO_1APRINTER_INFO_1ALPPRINTER_INFO_1APPRINTER_INFO_1WPRINTER_INFO_1WLPPRINTER_INFO_1WPPRINTER_INFO_2APRINTER_INFO_2ALPPRINTER_INFO_2APPRINTER_INFO_2WPRINTER_INFO_2WLPPRINTER_INFO_2WPPRINTER_INFO_3PRINTER_INFO_3LPPRINTER_INFO_3PPRINTER_INFO_4APRINTER_INFO_4ALPPRINTER_INFO_4APPRINTER_INFO_4WPRINTER_INFO_4WLPPRINTER_INFO_4WPPRINTER_INFO_5APRINTER_INFO_5ALPPRINTER_INFO_5APPRINTER_INFO_5WPRINTER_INFO_5WLPPRINTER_INFO_5WPPRINTER_INFO_6PRINTER_INFO_6LPPRINTER_INFO_6PPRINTER_INFO_7APRINTER_INFO_7ALPPRINTER_INFO_7APPRINTER_INFO_7WPRINTER_INFO_7WLPPRINTER_INFO_7WDSPRINT_PUBLISHDSPRINT_UPDATEDSPRINT_UNPUBLISHDSPRINT_REPUBLISHDSPRINT_PENDINGPPRINTER_INFO_8APRINTER_INFO_8ALPPRINTER_INFO_8APPRINTER_INFO_8WPRINTER_INFO_8WLPPRINTER_INFO_8WPPRINTER_INFO_9APRINTER_INFO_9ALPPRINTER_INFO_9APPRINTER_INFO_9WPRINTER_INFO_9WLPPRINTER_INFO_9WPRINTER_CONTROL_PAUSEPRINTER_CONTROL_RESUMEPRINTER_CONTROL_PURGEPRINTER_CONTROL_SET_STATUSPRINTER_STATUS_PAUSEDPRINTER_STATUS_ERRORPRINTER_STATUS_PENDING_DELETIONPRINTER_STATUS_PAPER_JAMPRINTER_STATUS_PAPER_OUTPRINTER_STATUS_MANUAL_FEEDPRINTER_STATUS_PAPER_PROBLEMPRINTER_STATUS_OFFLINEPRINTER_STATUS_IO_ACTIVEPRINTER_STATUS_BUSYPRINTER_STATUS_PRINTINGPRINTER_STATUS_OUTPUT_BIN_FULLPRINTER_STATUS_NOT_AVAILABLEPRINTER_STATUS_WAITINGPRINTER_STATUS_PROCESSINGPRINTER_STATUS_INITIALIZINGPRINTER_STATUS_WARMING_UPPRINTER_STATUS_TONER_LOWPRINTER_STATUS_NO_TONERPRINTER_STATUS_PAGE_PUNTPRINTER_STATUS_USER_INTERVENTIONPRINTER_STATUS_OUT_OF_MEMORYPRINTER_STATUS_DOOR_OPENPRINTER_STATUS_SERVER_UNKNOWNPRINTER_STATUS_POWER_SAVEPRINTER_STATUS_SERVER_OFFLINEPRINTER_STATUS_DRIVER_UPDATE_NEEDEDPRINTER_ATTRIBUTE_QUEUEDPRINTER_ATTRIBUTE_DIRECTPRINTER_ATTRIBUTE_DEFAULTPRINTER_ATTRIBUTE_SHAREDPRINTER_ATTRIBUTE_NETWORKPRINTER_ATTRIBUTE_HIDDENPRINTER_ATTRIBUTE_LOCALPRINTER_ATTRIBUTE_ENABLE_DEVQPRINTER_ATTRIBUTE_KEEPPRINTEDJOBSPRINTER_ATTRIBUTE_DO_COMPLETE_FIRSTPRINTER_ATTRIBUTE_WORK_OFFLINEPRINTER_ATTRIBUTE_ENABLE_BIDIPRINTER_ATTRIBUTE_RAW_ONLYPRINTER_ATTRIBUTE_PUBLISHEDPRINTER_ATTRIBUTE_FAXPRINTER_ATTRIBUTE_TSPRINTER_ATTRIBUTE_PUSHED_USERPRINTER_ATTRIBUTE_PUSHED_MACHINEPRINTER_ATTRIBUTE_MACHINEPRINTER_ATTRIBUTE_FRIENDLY_NAMEPRINTER_ATTRIBUTE_TS_GENERIC_DRIVERPRINTER_ATTRIBUTE_PER_USERPRINTER_ATTRIBUTE_ENTERPRISE_CLOUDNO_PRIORITYMAX_PRIORITYMIN_PRIORITYDEF_PRIORITYPJOB_INFO_1AJOB_INFO_1ALPJOB_INFO_1APJOB_INFO_1WJOB_INFO_1WLPJOB_INFO_1WPJOB_INFO_2AJOB_INFO_2ALPJOB_INFO_2APJOB_INFO_2WJOB_INFO_2WLPJOB_INFO_2WPJOB_INFO_3JOB_INFO_3LPJOB_INFO_3PJOB_INFO_4AJOB_INFO_4ALPJOB_INFO_4APJOB_INFO_4WJOB_INFO_4WLPJOB_INFO_4WJOB_CONTROL_PAUSEJOB_CONTROL_RESUMEJOB_CONTROL_CANCELJOB_CONTROL_RESTARTJOB_CONTROL_DELETEJOB_CONTROL_SENT_TO_PRINTERJOB_CONTROL_LAST_PAGE_EJECTEDJOB_STATUS_PAUSEDJOB_STATUS_ERRORJOB_STATUS_DELETINGJOB_STATUS_SPOOLINGJOB_STATUS_PRINTINGJOB_STATUS_OFFLINEJOB_STATUS_PAPEROUTJOB_STATUS_PRINTEDJOB_STATUS_DELETEDJOB_STATUS_BLOCKED_DEVQJOB_STATUS_USER_INTERVENTIONJOB_STATUS_RESTARTJOB_POSITION_UNSPECIFIEDPADDJOB_INFO_1AADDJOB_INFO_1ALPADDJOB_INFO_1APADDJOB_INFO_1WADDJOB_INFO_1WLPADDJOB_INFO_1WPDRIVER_INFO_1ADRIVER_INFO_1ALPDRIVER_INFO_1APDRIVER_INFO_1WDRIVER_INFO_1WLPDRIVER_INFO_1WPDRIVER_INFO_2ADRIVER_INFO_2ALPDRIVER_INFO_2APDRIVER_INFO_2WDRIVER_INFO_2WLPDRIVER_INFO_2WPDRIVER_INFO_3ADRIVER_INFO_3ALPDRIVER_INFO_3APDRIVER_INFO_3WDRIVER_INFO_3WLPDRIVER_INFO_3WPDRIVER_INFO_4ADRIVER_INFO_4ALPDRIVER_INFO_4APDRIVER_INFO_4WDRIVER_INFO_4WLPDRIVER_INFO_4WPDRIVER_INFO_5ADRIVER_INFO_5ALPDRIVER_INFO_5APDRIVER_INFO_5WDRIVER_INFO_5WLPDRIVER_INFO_5WPDRIVER_INFO_6ADRIVER_INFO_6ALPDRIVER_INFO_6APDRIVER_INFO_6WDRIVER_INFO_6WLPDRIVER_INFO_6WPRINTER_DRIVER_PACKAGE_AWAREPRINTER_DRIVER_XPSPRINTER_DRIVER_SANDBOX_ENABLEDPRINTER_DRIVER_CLASSPRINTER_DRIVER_DERIVEDPRINTER_DRIVER_NOT_SHAREABLEPRINTER_DRIVER_CATEGORY_FAXPRINTER_DRIVER_CATEGORY_FILEPRINTER_DRIVER_CATEGORY_VIRTUALPRINTER_DRIVER_CATEGORY_SERVICEPRINTER_DRIVER_SOFT_RESET_REQUIREDPRINTER_DRIVER_SANDBOX_DISABLEDPRINTER_DRIVER_CATEGORY_3DPRINTER_DRIVER_CATEGORY_CLOUDPDRIVER_INFO_8ADRIVER_INFO_8ALPDRIVER_INFO_8APDRIVER_INFO_8WDRIVER_INFO_8WLPDRIVER_INFO_8WDRIVER_KERNELMODEDRIVER_USERMODEDPD_DELETE_UNUSED_FILESDPD_DELETE_SPECIFIC_VERSIONDPD_DELETE_ALL_FILESAPD_STRICT_UPGRADEAPD_STRICT_DOWNGRADEAPD_COPY_ALL_FILESAPD_COPY_NEW_FILESAPD_COPY_FROM_DIRECTORYPDOC_INFO_1ADOC_INFO_1ALPDOC_INFO_1APDOC_INFO_1WDOC_INFO_1WLPDOC_INFO_1WPFORM_INFO_1AFORM_INFO_1ALPFORM_INFO_1APFORM_INFO_1WFORM_INFO_1WLPFORM_INFO_1WSTRING_NONESTRING_MUIDLLSTRING_LANGPAIRMAX_FORM_KEYWORD_LENGTHPFORM_INFO_2AFORM_INFO_2ALPFORM_INFO_2APFORM_INFO_2WFORM_INFO_2WLPFORM_INFO_2WPDOC_INFO_2ADOC_INFO_2ALPDOC_INFO_2APDOC_INFO_2WDOC_INFO_2WLPDOC_INFO_2WDI_CHANNELDI_READ_SPOOL_JOBPDOC_INFO_3ADOC_INFO_3ALPDOC_INFO_3APDOC_INFO_3WDOC_INFO_3WLPDOC_INFO_3WDI_MEMORYMAP_WRITEFORM_USERFORM_BUILTINFORM_PRINTERPPRINTPROCESSOR_INFO_1APRINTPROCESSOR_INFO_1ALPPRINTPROCESSOR_INFO_1APPRINTPROCESSOR_INFO_1WPRINTPROCESSOR_INFO_1WLPPRINTPROCESSOR_INFO_1WPPRINTPROCESSOR_CAPS_1PRINTPROCESSOR_CAPS_1PPRINTPROCESSOR_CAPS_2PRINTPROCESSOR_CAPS_2PPCAPS_RIGHT_THEN_DOWNPPCAPS_DOWN_THEN_RIGHTPPCAPS_LEFT_THEN_DOWNPPCAPS_DOWN_THEN_LEFTPPCAPS_BORDER_PRINTPPCAPS_BOOKLET_EDGEPPCAPS_REVERSE_PAGES_FOR_REVERSE_DUPLEXPPCAPS_DONT_SEND_EXTRA_PAGES_FOR_DUPLEXPPCAPS_SQUARE_SCALINGPPORT_INFO_1APORT_INFO_1ALPPORT_INFO_1APPORT_INFO_1WPORT_INFO_1WLPPORT_INFO_1WPPORT_INFO_2APORT_INFO_2ALPPORT_INFO_2APPORT_INFO_2WPORT_INFO_2WLPPORT_INFO_2WPORT_TYPE_WRITEPORT_TYPE_READPORT_TYPE_REDIRECTEDPORT_TYPE_NET_ATTACHEDPPORT_INFO_3APORT_INFO_3ALPPORT_INFO_3APPORT_INFO_3WPORT_INFO_3WLPPORT_INFO_3WPORT_STATUS_TYPE_ERRORPORT_STATUS_TYPE_WARNINGPORT_STATUS_TYPE_INFOPORT_STATUS_OFFLINEPORT_STATUS_PAPER_JAMPORT_STATUS_PAPER_OUTPORT_STATUS_OUTPUT_BIN_FULLPORT_STATUS_PAPER_PROBLEMPORT_STATUS_NO_TONERPORT_STATUS_DOOR_OPENPORT_STATUS_USER_INTERVENTIONPORT_STATUS_OUT_OF_MEMORYPORT_STATUS_TONER_LOWPORT_STATUS_WARMING_UPPORT_STATUS_POWER_SAVEPMONITOR_INFO_1AMONITOR_INFO_1ALPMONITOR_INFO_1APMONITOR_INFO_1WMONITOR_INFO_1WLPMONITOR_INFO_1WPMONITOR_INFO_2AMONITOR_INFO_2ALPMONITOR_INFO_2APMONITOR_INFO_2WMONITOR_INFO_2WLPMONITOR_INFO_2WPDATATYPES_INFO_1ADATATYPES_INFO_1ALPDATATYPES_INFO_1APDATATYPES_INFO_1WDATATYPES_INFO_1WLPDATATYPES_INFO_1WPPRINTER_DEFAULTSAPRINTER_DEFAULTSALPPRINTER_DEFAULTSAPPRINTER_DEFAULTSWPRINTER_DEFAULTSWLPPRINTER_DEFAULTSWPPRINTER_ENUM_VALUESAPRINTER_ENUM_VALUESALPPRINTER_ENUM_VALUESAPPRINTER_ENUM_VALUESWPRINTER_ENUM_VALUESWLPPRINTER_ENUM_VALUESWEnumPrintersAEnumPrintersWPRINTER_ENUM_DEFAULTPRINTER_ENUM_LOCALPRINTER_ENUM_CONNECTIONSPRINTER_ENUM_FAVORITEPRINTER_ENUM_NAMEPRINTER_ENUM_REMOTEPRINTER_ENUM_SHAREDPRINTER_ENUM_NETWORKPRINTER_ENUM_EXPANDPRINTER_ENUM_CONTAINERPRINTER_ENUM_ICONMASKPRINTER_ENUM_ICON1PRINTER_ENUM_ICON2PRINTER_ENUM_ICON3PRINTER_ENUM_ICON4PRINTER_ENUM_ICON5PRINTER_ENUM_ICON6PRINTER_ENUM_ICON7PRINTER_ENUM_ICON8PRINTER_ENUM_HIDEPRINTER_ENUM_CATEGORY_ALLPRINTER_ENUM_CATEGORY_3DSPOOL_FILE_PERSISTENTSPOOL_FILE_TEMPORARYGetSpoolFileHandleCommitSpoolDataCloseSpoolFileHandleOpenPrinterAOpenPrinterWResetPrinterAResetPrinterWSetJobASetJobWGetJobAGetJobWEnumJobsAEnumJobsWAddPrinterAAddPrinterWDeletePrinterSetPrinterASetPrinterWGetPrinterAGetPrinterWAddPrinterDriverAAddPrinterDriverWAddPrinterDriverExAAddPrinterDriverExWEnumPrinterDriversAEnumPrinterDriversWGetPrinterDriverAGetPrinterDriverWGetPrinterDriverDirectoryAGetPrinterDriverDirectoryWDeletePrinterDriverADeletePrinterDriverWDeletePrinterDriverExADeletePrinterDriverExWAddPrintProcessorAAddPrintProcessorWEnumPrintProcessorsAEnumPrintProcessorsWGetPrintProcessorDirectoryAGetPrintProcessorDirectoryWEnumPrintProcessorDatatypesAEnumPrintProcessorDatatypesWDeletePrintProcessorADeletePrintProcessorWStartDocPrinterAStartDocPrinterWStartPagePrinterWritePrinterFlushPrinterEndPagePrinterAbortPrinterReadPrinterEndDocPrinterAddJobAAddJobWScheduleJobPrinterPropertiesDocumentPropertiesADocumentPropertiesWAdvancedDocumentPropertiesAAdvancedDocumentPropertiesWExtDeviceModeGetPrinterDataAGetPrinterDataWGetPrinterDataExAGetPrinterDataExWEnumPrinterDataAEnumPrinterDataWEnumPrinterDataExAEnumPrinterDataExWEnumPrinterKeyAEnumPrinterKeyWSetPrinterDataASetPrinterDataWSetPrinterDataExASetPrinterDataExWDeletePrinterDataADeletePrinterDataWDeletePrinterDataExADeletePrinterDataExWDeletePrinterKeyADeletePrinterKeyWPRINTER_NOTIFY_TYPEJOB_NOTIFY_TYPESERVER_NOTIFY_TYPEPRINTER_NOTIFY_FIELD_SERVER_NAMEPRINTER_NOTIFY_FIELD_PRINTER_NAMEPRINTER_NOTIFY_FIELD_SHARE_NAMEPRINTER_NOTIFY_FIELD_PORT_NAMEPRINTER_NOTIFY_FIELD_DRIVER_NAMEPRINTER_NOTIFY_FIELD_COMMENTPRINTER_NOTIFY_FIELD_LOCATIONPRINTER_NOTIFY_FIELD_DEVMODEPRINTER_NOTIFY_FIELD_SEPFILEPRINTER_NOTIFY_FIELD_PRINT_PROCESSORPRINTER_NOTIFY_FIELD_PARAMETERSPRINTER_NOTIFY_FIELD_DATATYPEPRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTORPRINTER_NOTIFY_FIELD_ATTRIBUTESPRINTER_NOTIFY_FIELD_PRIORITYPRINTER_NOTIFY_FIELD_DEFAULT_PRIORITYPRINTER_NOTIFY_FIELD_START_TIMEPRINTER_NOTIFY_FIELD_UNTIL_TIMEPRINTER_NOTIFY_FIELD_STATUSPRINTER_NOTIFY_FIELD_STATUS_STRINGPRINTER_NOTIFY_FIELD_CJOBSPRINTER_NOTIFY_FIELD_AVERAGE_PPMPRINTER_NOTIFY_FIELD_TOTAL_PAGESPRINTER_NOTIFY_FIELD_PAGES_PRINTEDPRINTER_NOTIFY_FIELD_TOTAL_BYTESPRINTER_NOTIFY_FIELD_BYTES_PRINTEDPRINTER_NOTIFY_FIELD_OBJECT_GUIDPRINTER_NOTIFY_FIELD_FRIENDLY_NAMEPRINTER_NOTIFY_FIELD_BRANCH_OFFICE_PRINTINGJOB_NOTIFY_FIELD_PRINTER_NAMEJOB_NOTIFY_FIELD_MACHINE_NAMEJOB_NOTIFY_FIELD_PORT_NAMEJOB_NOTIFY_FIELD_USER_NAMEJOB_NOTIFY_FIELD_NOTIFY_NAMEJOB_NOTIFY_FIELD_DATATYPEJOB_NOTIFY_FIELD_PRINT_PROCESSORJOB_NOTIFY_FIELD_PARAMETERSJOB_NOTIFY_FIELD_DRIVER_NAMEJOB_NOTIFY_FIELD_DEVMODEJOB_NOTIFY_FIELD_STATUSJOB_NOTIFY_FIELD_STATUS_STRINGJOB_NOTIFY_FIELD_SECURITY_DESCRIPTORJOB_NOTIFY_FIELD_DOCUMENTJOB_NOTIFY_FIELD_PRIORITYJOB_NOTIFY_FIELD_POSITIONJOB_NOTIFY_FIELD_SUBMITTEDJOB_NOTIFY_FIELD_START_TIMEJOB_NOTIFY_FIELD_UNTIL_TIMEJOB_NOTIFY_FIELD_TIMEJOB_NOTIFY_FIELD_TOTAL_PAGESJOB_NOTIFY_FIELD_PAGES_PRINTEDJOB_NOTIFY_FIELD_TOTAL_BYTESJOB_NOTIFY_FIELD_BYTES_PRINTEDJOB_NOTIFY_FIELD_REMOTE_JOB_IDSERVER_NOTIFY_FIELD_PRINT_DRIVER_ISOLATION_GROUPPRINTER_NOTIFY_CATEGORY_ALLPRINTER_NOTIFY_CATEGORY_3DPPRINTER_NOTIFY_OPTIONS_TYPEPRINTER_NOTIFY_OPTIONS_TYPELPPRINTER_NOTIFY_OPTIONS_TYPEPRINTER_NOTIFY_OPTIONS_REFRESHPPRINTER_NOTIFY_OPTIONSPRINTER_NOTIFY_OPTIONSLPPRINTER_NOTIFY_OPTIONSPRINTER_NOTIFY_INFO_DISCARDEDPPRINTER_NOTIFY_INFO_DATAPRINTER_NOTIFY_INFO_DATALPPRINTER_NOTIFY_INFO_DATAPPRINTER_NOTIFY_INFOPRINTER_NOTIFY_INFOLPPRINTER_NOTIFY_INFOPBINARY_CONTAINERBINARY_CONTAINERPBIDI_DATABIDI_DATALPBIDI_DATAPBIDI_REQUEST_DATABIDI_REQUEST_DATALPBIDI_REQUEST_DATAPBIDI_REQUEST_CONTAINERBIDI_REQUEST_CONTAINERLPBIDI_REQUEST_CONTAINERPBIDI_RESPONSE_DATABIDI_RESPONSE_DATALPBIDI_RESPONSE_DATAPBIDI_RESPONSE_CONTAINERBIDI_RESPONSE_CONTAINERLPBIDI_RESPONSE_CONTAINERBIDI_ACTION_ENUM_SCHEMABIDI_ACTION_GETBIDI_ACTION_SETBIDI_ACTION_GET_ALLBIDI_ACTION_GET_WITH_ARGUMENTBIDI_ACCESS_ADMINISTRATORBIDI_ACCESS_USERERROR_BIDI_STATUS_OKERROR_BIDI_NOT_SUPPORTEDERROR_BIDI_ERROR_BASEERROR_BIDI_STATUS_WARNINGERROR_BIDI_SCHEMA_READ_ONLYERROR_BIDI_SERVER_OFFLINEERROR_BIDI_DEVICE_OFFLINEERROR_BIDI_SCHEMA_NOT_SUPPORTEDERROR_BIDI_SET_DIFFERENT_TYPEERROR_BIDI_SET_MULTIPLE_SCHEMAPATHERROR_BIDI_SET_INVALID_SCHEMAPATHERROR_BIDI_SET_UNKNOWN_FAILUREERROR_BIDI_SCHEMA_WRITE_ONLYERROR_BIDI_GET_REQUIRES_ARGUMENTERROR_BIDI_GET_ARGUMENT_NOT_SUPPORTEDERROR_BIDI_GET_MISSING_ARGUMENTERROR_BIDI_DEVICE_CONFIG_UNCHANGEDERROR_BIDI_NO_LOCALIZED_RESOURCESERROR_BIDI_NO_BIDI_SCHEMA_EXTENSIONSERROR_BIDI_UNSUPPORTED_CLIENT_LANGUAGEERROR_BIDI_UNSUPPORTED_RESOURCE_FORMATWaitForPrinterChangeFindFirstPrinterChangeNotificationFindNextPrinterChangeNotificationFreePrinterNotifyInfoFindClosePrinterChangeNotificationPRINTER_CHANGE_ADD_PRINTERPRINTER_CHANGE_SET_PRINTERPRINTER_CHANGE_DELETE_PRINTERPRINTER_CHANGE_FAILED_CONNECTION_PRINTERPRINTER_CHANGE_PRINTERPRINTER_CHANGE_ADD_JOBPRINTER_CHANGE_SET_JOBPRINTER_CHANGE_DELETE_JOBPRINTER_CHANGE_WRITE_JOBPRINTER_CHANGE_JOBPRINTER_CHANGE_ADD_FORMPRINTER_CHANGE_SET_FORMPRINTER_CHANGE_DELETE_FORMPRINTER_CHANGE_FORMPRINTER_CHANGE_ADD_PORTPRINTER_CHANGE_CONFIGURE_PORTPRINTER_CHANGE_DELETE_PORTPRINTER_CHANGE_PORTPRINTER_CHANGE_ADD_PRINT_PROCESSORPRINTER_CHANGE_DELETE_PRINT_PROCESSORPRINTER_CHANGE_PRINT_PROCESSORPRINTER_CHANGE_SERVERPRINTER_CHANGE_ADD_PRINTER_DRIVERPRINTER_CHANGE_SET_PRINTER_DRIVERPRINTER_CHANGE_DELETE_PRINTER_DRIVERPRINTER_CHANGE_PRINTER_DRIVERPRINTER_CHANGE_TIMEOUTPRINTER_CHANGE_ALLPrinterMessageBoxAPrinterMessageBoxWPRINTER_ERROR_INFORMATIONPRINTER_ERROR_WARNINGPRINTER_ERROR_SEVEREPRINTER_ERROR_OUTOFPAPERPRINTER_ERROR_JAMPRINTER_ERROR_OUTOFTONERClosePrinterAddFormAAddFormWDeleteFormADeleteFormWGetFormAGetFormWSetFormASetFormWEnumFormsAEnumFormsWEnumMonitorsAEnumMonitorsWAddMonitorAAddMonitorWDeleteMonitorADeleteMonitorWEnumPortsAEnumPortsWAddPortAAddPortWConfigurePortAConfigurePortWDeletePortADeletePortWXcvDataWGetDefaultPrinterAGetDefaultPrinterWSetDefaultPrinterASetDefaultPrinterWSetPortASetPortWAddPrinterConnectionAAddPrinterConnectionWDeletePrinterConnectionADeletePrinterConnectionWConnectToPrinterDlgPPROVIDOR_INFO_1APROVIDOR_INFO_1ALPPROVIDOR_INFO_1APPROVIDOR_INFO_1WPROVIDOR_INFO_1WLPPROVIDOR_INFO_1WPPROVIDOR_INFO_2APROVIDOR_INFO_2ALPPROVIDOR_INFO_2APPROVIDOR_INFO_2WPROVIDOR_INFO_2WLPPROVIDOR_INFO_2WAddPrintProvidorAAddPrintProvidorWDeletePrintProvidorADeletePrintProvidorWIsValidDevmodeAIsValidDevmodeWSPLREG_DEFAULT_SPOOL_DIRECTORYSPLREG_PORT_THREAD_PRIORITY_DEFAULTSPLREG_PORT_THREAD_PRIORITYSPLREG_SCHEDULER_THREAD_PRIORITY_DEFAULTSPLREG_SCHEDULER_THREAD_PRIORITYSPLREG_BEEP_ENABLEDSPLREG_NET_POPUPSPLREG_RETRY_POPUPSPLREG_NET_POPUP_TO_COMPUTERSPLREG_EVENT_LOGSPLREG_MAJOR_VERSIONSPLREG_MINOR_VERSIONSPLREG_ARCHITECTURESPLREG_OS_VERSIONSPLREG_OS_VERSIONEXSPLREG_DS_PRESENTSPLREG_DS_PRESENT_FOR_USERSPLREG_REMOTE_FAXSPLREG_RESTART_JOB_ON_POOL_ERRORSPLREG_RESTART_JOB_ON_POOL_ENABLEDSPLREG_DNS_MACHINE_NAMESPLREG_ALLOW_USER_MANAGEFORMSSPLREG_WEBSHAREMGMTSPLREG_PRINT_DRIVER_ISOLATION_GROUPS_SEPARATORSPLREG_PRINT_DRIVER_ISOLATION_GROUPSSPLREG_PRINT_DRIVER_ISOLATION_TIME_BEFORE_RECYCLESPLREG_PRINT_DRIVER_ISOLATION_MAX_OBJECTS_BEFORE_RECYCLESPLREG_PRINT_DRIVER_ISOLATION_IDLE_TIMEOUTSPLREG_PRINT_DRIVER_ISOLATION_EXECUTION_POLICYSPLREG_PRINT_DRIVER_ISOLATION_OVERRIDE_POLICYSPLREG_PRINT_QUEUE_V4_DRIVER_DIRECTORYSERVER_ACCESS_ADMINISTERSERVER_ACCESS_ENUMERATEPRINTER_ACCESS_ADMINISTERPRINTER_ACCESS_USEJOB_ACCESS_ADMINISTERJOB_ACCESS_READPRINTER_ACCESS_MANAGE_LIMITEDSERVER_ALL_ACCESSSERVER_READSERVER_WRITESERVER_EXECUTEPRINTER_ALL_ACCESSPRINTER_READPRINTER_WRITEPRINTER_EXECUTEJOB_ALL_ACCESSJOB_READJOB_WRITEJOB_EXECUTESPLDS_SPOOLER_KEYSPLDS_DRIVER_KEYSPLDS_USER_KEYSPLDS_ASSET_NUMBERSPLDS_BYTES_PER_MINUTESPLDS_DESCRIPTIONSPLDS_DRIVER_NAMESPLDS_DRIVER_VERSIONSPLDS_LOCATIONSPLDS_PORT_NAMESPLDS_PRINT_ATTRIBUTESSPLDS_PRINT_BIN_NAMESSPLDS_PRINT_COLLATESPLDS_PRINT_COLORSPLDS_PRINT_DUPLEX_SUPPORTEDSPLDS_PRINT_END_TIMESPLDS_PRINTER_CLASSSPLDS_PRINTER_NAMESPLDS_PRINT_KEEP_PRINTED_JOBSSPLDS_PRINT_LANGUAGESPLDS_PRINT_MAC_ADDRESSSPLDS_PRINT_MAX_X_EXTENTSPLDS_PRINT_MAX_Y_EXTENTSPLDS_PRINT_MAX_RESOLUTION_SUPPORTEDSPLDS_PRINT_MEDIA_READYSPLDS_PRINT_MEDIA_SUPPORTEDSPLDS_PRINT_MEMORYSPLDS_PRINT_MIN_X_EXTENTSPLDS_PRINT_MIN_Y_EXTENTSPLDS_PRINT_NETWORK_ADDRESSSPLDS_PRINT_NOTIFYSPLDS_PRINT_NUMBER_UPSPLDS_PRINT_ORIENTATIONS_SUPPORTEDSPLDS_PRINT_OWNERSPLDS_PRINT_PAGES_PER_MINUTESPLDS_PRINT_RATESPLDS_PRINT_RATE_UNITSPLDS_PRINT_SEPARATOR_FILESPLDS_PRINT_SHARE_NAMESPLDS_PRINT_SPOOLINGSPLDS_PRINT_STAPLING_SUPPORTEDSPLDS_PRINT_START_TIMESPLDS_PRINT_STATUSSPLDS_PRIORITYSPLDS_SERVER_NAMESPLDS_SHORT_SERVER_NAMESPLDS_UNC_NAMESPLDS_URLSPLDS_FLAGSSPLDS_VERSION_NUMBERSPLDS_PRINTER_NAME_ALIASESSPLDS_PRINTER_LOCATIONSSPLDS_PRINTER_MODELPPRINTER_OPTIONSAPRINTER_OPTIONSALPPRINTER_OPTIONSAPPRINTER_OPTIONSWPRINTER_OPTIONSWLPPRINTER_OPTIONSWOpenPrinter2AOpenPrinter2WPRINTER_CONNECTION_MISMATCHPRINTER_CONNECTION_NO_UIPPRINTER_CONNECTION_INFO_1APRINTER_CONNECTION_INFO_1ALPPRINTER_CONNECTION_INFO_1APPRINTER_CONNECTION_INFO_1WPRINTER_CONNECTION_INFO_1WLPPRINTER_CONNECTION_INFO_1WAddPrinterConnection2AAddPrinterConnection2WIPDFP_COPY_ALL_FILESInstallPrinterDriverFromPackageAInstallPrinterDriverFromPackageWUPDP_SILENT_UPLOADUPDP_UPLOAD_ALWAYSUPDP_CHECK_DRIVERSTOREUploadPrinterDriverPackageAUploadPrinterDriverPackageWPCORE_PRINTER_DRIVERACORE_PRINTER_DRIVERAPCORE_PRINTER_DRIVERWCORE_PRINTER_DRIVERWGetCorePrinterDriversAGetCorePrinterDriversWCorePrinterDriverInstalledACorePrinterDriverInstalledWGetPrinterDriverPackagePathAGetPrinterDriverPackagePathWDeletePrinterDriverPackageADeletePrinterDriverPackageWReportJobProcessingProgressEPrintXPSJobOperationEPrintXPSJobProgressGetPrinterDriver2AGetPrinterDriver2WGetPrintExecutionDataPRINT_EXECUTION_DATAGetJobNamedPropertyValuePrintPropertyValueFreePrintPropertyValueFreePrintNamedPropertyArrayPrintNamedPropertySetJobNamedPropertyDeleteJobNamedPropertyEnumJobNamedPropertiesGetPrintOutputInfoMS_PRINT_JOB_OUTPUT_FILE//! Winspool header fileSERVICE_NO_CHANGESERVICE_ACTIVESERVICE_INACTIVESERVICE_STATE_ALLSERVICE_CONTROL_STOPSERVICE_CONTROL_PAUSESERVICE_CONTROL_CONTINUESERVICE_CONTROL_INTERROGATESERVICE_CONTROL_SHUTDOWNSERVICE_CONTROL_PARAMCHANGESERVICE_CONTROL_NETBINDADDSERVICE_CONTROL_NETBINDREMOVESERVICE_CONTROL_NETBINDENABLESERVICE_CONTROL_NETBINDDISABLESERVICE_CONTROL_DEVICEEVENTSERVICE_CONTROL_HARDWAREPROFILECHANGESERVICE_CONTROL_POWEREVENTSERVICE_CONTROL_SESSIONCHANGESERVICE_CONTROL_PRESHUTDOWNSERVICE_CONTROL_TIMECHANGESERVICE_CONTROL_TRIGGEREVENTSERVICE_STOPPEDSERVICE_START_PENDINGSERVICE_STOP_PENDINGSERVICE_RUNNINGSERVICE_CONTINUE_PENDINGSERVICE_PAUSE_PENDINGSERVICE_PAUSEDSERVICE_ACCEPT_STOPSERVICE_ACCEPT_PAUSE_CONTINUESERVICE_ACCEPT_SHUTDOWNSERVICE_ACCEPT_PARAMCHANGESERVICE_ACCEPT_NETBINDCHANGESERVICE_ACCEPT_HARDWAREPROFILECHANGESERVICE_ACCEPT_POWEREVENTSERVICE_ACCEPT_SESSIONCHANGESERVICE_ACCEPT_PRESHUTDOWNSERVICE_ACCEPT_TIMECHANGESERVICE_ACCEPT_TRIGGEREVENTSC_MANAGER_CONNECT// SERVICE_ACCEPT_USER_LOGOFFSC_MANAGER_CREATE_SERVICESC_MANAGER_ENUMERATE_SERVICESC_MANAGER_LOCKSC_MANAGER_QUERY_LOCK_STATUSSC_MANAGER_MODIFY_BOOT_CONFIGSC_MANAGER_ALL_ACCESSSERVICE_QUERY_CONFIGSERVICE_CHANGE_CONFIGSERVICE_QUERY_STATUSSERVICE_ENUMERATE_DEPENDENTSSERVICE_STARTSERVICE_STOPSERVICE_PAUSE_CONTINUESERVICE_INTERROGATESERVICE_USER_DEFINED_CONTROLSERVICE_ALL_ACCESSSERVICE_RUNS_IN_SYSTEM_PROCESSSERVICE_CONFIG_DESCRIPTIONSERVICE_CONFIG_FAILURE_ACTIONSSERVICE_CONFIG_DELAYED_AUTO_START_INFOSERVICE_CONFIG_FAILURE_ACTIONS_FLAGSERVICE_CONFIG_SERVICE_SID_INFOSERVICE_CONFIG_REQUIRED_PRIVILEGES_INFOSERVICE_CONFIG_PRESHUTDOWN_INFOSERVICE_CONFIG_TRIGGER_INFOSERVICE_CONFIG_PREFERRED_NODESERVICE_CONFIG_LAUNCH_PROTECTEDSERVICE_NOTIFY_STATUS_CHANGE_1SERVICE_NOTIFY_STATUS_CHANGE_2SERVICE_NOTIFY_STATUS_CHANGESERVICE_NOTIFY_STOPPEDSERVICE_NOTIFY_START_PENDINGSERVICE_NOTIFY_STOP_PENDINGSERVICE_NOTIFY_RUNNINGSERVICE_NOTIFY_CONTINUE_PENDINGSERVICE_NOTIFY_PAUSE_PENDINGSERVICE_NOTIFY_PAUSEDSERVICE_NOTIFY_CREATEDSERVICE_NOTIFY_DELETEDSERVICE_NOTIFY_DELETE_PENDINGSERVICE_STOP_REASON_FLAG_MINSERVICE_STOP_REASON_FLAG_UNPLANNEDSERVICE_STOP_REASON_FLAG_CUSTOMSERVICE_STOP_REASON_FLAG_PLANNEDSERVICE_STOP_REASON_FLAG_MAXSERVICE_STOP_REASON_MAJOR_MINSERVICE_STOP_REASON_MAJOR_OTHERSERVICE_STOP_REASON_MAJOR_HARDWARESERVICE_STOP_REASON_MAJOR_OPERATINGSYSTEMSERVICE_STOP_REASON_MAJOR_SOFTWARESERVICE_STOP_REASON_MAJOR_APPLICATIONSERVICE_STOP_REASON_MAJOR_NONESERVICE_STOP_REASON_MAJOR_MAXSERVICE_STOP_REASON_MAJOR_MIN_CUSTOMSERVICE_STOP_REASON_MAJOR_MAX_CUSTOMSERVICE_STOP_REASON_MINOR_MINSERVICE_STOP_REASON_MINOR_OTHERSERVICE_STOP_REASON_MINOR_MAINTENANCESERVICE_STOP_REASON_MINOR_INSTALLATIONSERVICE_STOP_REASON_MINOR_UPGRADESERVICE_STOP_REASON_MINOR_RECONFIGSERVICE_STOP_REASON_MINOR_HUNGSERVICE_STOP_REASON_MINOR_UNSTABLESERVICE_STOP_REASON_MINOR_DISKSERVICE_STOP_REASON_MINOR_NETWORKCARDSERVICE_STOP_REASON_MINOR_ENVIRONMENTSERVICE_STOP_REASON_MINOR_HARDWARE_DRIVERSERVICE_STOP_REASON_MINOR_OTHERDRIVERSERVICE_STOP_REASON_MINOR_SERVICEPACKSERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATESERVICE_STOP_REASON_MINOR_SECURITYFIXSERVICE_STOP_REASON_MINOR_SECURITYSERVICE_STOP_REASON_MINOR_NETWORK_CONNECTIVITYSERVICE_STOP_REASON_MINOR_WMISERVICE_STOP_REASON_MINOR_SERVICEPACK_UNINSTALLSERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE_UNINSTALLSERVICE_STOP_REASON_MINOR_SECURITYFIX_UNINSTALLSERVICE_STOP_REASON_MINOR_MMCSERVICE_STOP_REASON_MINOR_NONESERVICE_STOP_REASON_MINOR_MAXSERVICE_STOP_REASON_MINOR_MIN_CUSTOMSERVICE_STOP_REASON_MINOR_MAX_CUSTOMSERVICE_CONTROL_STATUS_REASON_INFOSERVICE_SID_TYPE_NONESERVICE_SID_TYPE_UNRESTRICTEDSERVICE_SID_TYPE_RESTRICTEDSERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVALSERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITYSERVICE_TRIGGER_TYPE_DOMAIN_JOINSERVICE_TRIGGER_TYPE_FIREWALL_PORT_EVENTSERVICE_TRIGGER_TYPE_GROUP_POLICYSERVICE_TRIGGER_TYPE_NETWORK_ENDPOINTSERVICE_TRIGGER_TYPE_CUSTOM_SYSTEM_STATE_CHANGESERVICE_TRIGGER_TYPE_CUSTOMSERVICE_TRIGGER_DATA_TYPE_BINARYSERVICE_TRIGGER_DATA_TYPE_STRINGSERVICE_TRIGGER_DATA_TYPE_LEVELSERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANYSERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALLSERVICE_START_REASON_DEMANDSERVICE_START_REASON_AUTOSERVICE_START_REASON_TRIGGERSERVICE_START_REASON_RESTART_ON_FAILURESERVICE_START_REASON_DELAYEDAUTOSERVICE_DYNAMIC_INFORMATION_LEVEL_START_REASONSERVICE_LAUNCH_PROTECTED_NONESERVICE_LAUNCH_PROTECTED_WINDOWSSERVICE_LAUNCH_PROTECTED_WINDOWS_LIGHTSERVICE_LAUNCH_PROTECTED_ANTIMALWARE_LIGHTLPSC_ACTIONSC_ACTIONLPSERVICE_FAILURE_ACTIONSWSERVICE_FAILURE_ACTIONSWLPSC_HANDLESC_HANDLELPSERVICE_STATUSSERVICE_STATUSLPSERVICE_STATUS_PROCESSSERVICE_STATUS_PROCESSLPENUM_SERVICE_STATUSAENUM_SERVICE_STATUSALPENUM_SERVICE_STATUSWENUM_SERVICE_STATUSWLPENUM_SERVICE_STATUS_PROCESSAENUM_SERVICE_STATUS_PROCESSALPENUM_SERVICE_STATUS_PROCESSWENUM_SERVICE_STATUS_PROCESSWSC_LOCKLPQUERY_SERVICE_LOCK_STATUSAQUERY_SERVICE_LOCK_STATUSALPQUERY_SERVICE_LOCK_STATUSWQUERY_SERVICE_LOCK_STATUSWLPQUERY_SERVICE_CONFIGAQUERY_SERVICE_CONFIGALPQUERY_SERVICE_CONFIGWQUERY_SERVICE_CONFIGWLPSERVICE_DESCRIPTIONASERVICE_DESCRIPTIONALPSERVICE_DESCRIPTIONWSERVICE_DESCRIPTIONWLPSERVICE_TABLE_ENTRYASERVICE_TABLE_ENTRYALPSERVICE_TABLE_ENTRYWSERVICE_TABLE_ENTRYWPSERVICE_NOTIFY_1SERVICE_NOTIFY_1PSERVICE_NOTIFY_2ASERVICE_NOTIFY_2APSERVICE_NOTIFY_2WSERVICE_NOTIFY_2WSERVICE_NOTIFYAPSERVICE_NOTIFYASERVICE_NOTIFYWPSERVICE_NOTIFYWChangeServiceConfigAChangeServiceConfigWChangeServiceConfig2AChangeServiceConfig2WCloseServiceHandleControlServiceCreateServiceACreateServiceWDeleteServiceEnumDependentServicesAEnumDependentServicesWEnumServicesStatusAEnumServicesStatusWEnumServicesStatusExASC_ENUM_TYPEEnumServicesStatusExWGetServiceKeyNameAGetServiceKeyNameWGetServiceDisplayNameAGetServiceDisplayNameWLockServiceDatabaseNotifyBootConfigStatusOpenSCManagerAOpenSCManagerWOpenServiceAOpenServiceWQueryServiceConfigAQueryServiceConfigWQueryServiceConfig2AQueryServiceConfig2WQueryServiceLockStatusAQueryServiceLockStatusWQueryServiceObjectSecurityQueryServiceStatusQueryServiceStatusExSC_STATUS_TYPERegisterServiceCtrlHandlerALPHANDLER_FUNCTIONRegisterServiceCtrlHandlerWRegisterServiceCtrlHandlerExALPHANDLER_FUNCTION_EXRegisterServiceCtrlHandlerExWSetServiceObjectSecuritySetServiceStatusStartServiceCtrlDispatcherAStartServiceCtrlDispatcherWStartServiceAStartServiceWUnlockServiceDatabaseNotifyServiceStatusChangeANotifyServiceStatusChangeWControlServiceExAControlServiceExWQueryServiceDynamicInformationWaitServiceState//! Header file for the Service Control ManagerWTD_UI_ALL//90WTD_UI_NONEWTD_UI_NOBADWTD_UI_NOGOODWTD_REVOKE_NONEWTD_REVOKE_WHOLECHAINWTD_CHOICE_FILEWTD_CHOICE_CATALOGWTD_CHOICE_BLOBWTD_CHOICE_SIGNERWTD_CHOICE_CERTWTD_STATEACTION_IGNOREWTD_STATEACTION_VERIFYWTD_STATEACTION_CLOSEWTD_STATEACTION_AUTO_CACHEWTD_STATEACTION_AUTO_CACHE_FLUSHWTD_PROV_FLAGS_MASKWTD_USE_IE4_TRUST_FLAGWTD_NO_IE4_CHAIN_FLAGWTD_NO_POLICY_USAGE_FLAGWTD_REVOCATION_CHECK_NONEWTD_REVOCATION_CHECK_END_CERTWTD_REVOCATION_CHECK_CHAINWTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOTWTD_SAFER_FLAGWTD_HASH_ONLY_FLAGWTD_USE_DEFAULT_OSVER_CHECKWTD_LIFETIME_SIGNING_FLAGWTD_CACHE_ONLY_URL_RETRIEVALWTD_DISABLE_MD2_MD4WTD_MOTWWTD_CODE_INTEGRITY_DRIVER_MODEWTD_UICONTEXT_EXECUTEWTD_UICONTEXT_INSTALLPWINTRUST_DATAWINTRUST_DATAPWINTRUST_SIGNATURE_SETTINGSWINTRUST_SIGNATURE_SETTINGS//217WinVerifyTrustSPC_UUID_LENGTH//1246SPC_UUID//SpcSerializedObjectAttributesClassIdPSPC_SERIALIZED_OBJECTSPC_SERIALIZED_OBJECTPSPC_SIGINFOSPC_SIGINFOSPC_URL_LINK_CHOICESPC_MONIKER_LINK_CHOICESPC_FILE_LINK_CHOICEPSPC_LINKSPC_LINK//1337//414WINUSB_INTERFACE_HANDLEPWINUSB_INTERFACE_HANDLEWINUSB_ISOCH_BUFFER_HANDLEPWINUSB_ISOCH_BUFFER_HANDLEPWINUSB_SETUP_PACKETWINUSB_SETUP_PACKETWinUsb_InitializeWinUsb_FreeWinUsb_GetAssociatedInterfaceWinUsb_GetDescriptorWinUsb_QueryInterfaceSettingsWinUsb_QueryDeviceInformationWinUsb_SetCurrentAlternateSettingWinUsb_GetCurrentAlternateSettingWinUsb_QueryPipeWinUsb_QueryPipeExWinUsb_SetPipePolicyWinUsb_GetPipePolicyWinUsb_ReadPipeWinUsb_WritePipeWinUsb_ControlTransferWinUsb_ResetPipeWinUsb_AbortPipeWinUsb_FlushPipeWinUsb_SetPowerPolicyWinUsb_GetPowerPolicyWinUsb_GetOverlappedResultWinUsb_ParseConfigurationDescriptorWinUsb_ParseDescriptorsWinUsb_GetCurrentFrameNumberWinUsb_GetAdjustedFrameNumberWinUsb_RegisterIsochBufferWinUsb_UnregisterIsochBufferWinUsb_WriteIsochPipeWinUsb_ReadIsochPipeWinUsb_WriteIsochPipeAsapWinUsb_ReadIsochPipeAsap//! FFI bindings to winusb.HWINSTADPI_AWARENESSDPI_HOSTING_BEHAVIORHDESKHWINEVENTHOOKUINT_MAXHDWPMENUTEMPLATEAMENUTEMPLATEWLPMENUTEMPLATEALPMENUTEMPLATEWWINSTAENUMPROCANAMEENUMPROCADESKTOPENUMPROCAWINSTAENUMPROCWNAMEENUMPROCWDESKTOPENUMPROCWIS_INTRESOURCEMAKEINTRESOURCEAMAKEINTRESOURCEWDIFFERENCECREATEPROCESS_MANIFEST_RESOURCE_IDISOLATIONAWARE_MANIFEST_RESOURCE_IDISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_IDMINIMUM_RESERVED_MANIFEST_RESOURCE_IDMAXIMUM_RESERVED_MANIFEST_RESOURCE_IDwvsprintfAwvsprintfWwsprintfAwsprintfWSETWALLPAPER_DEFAULTSB_HORZSB_VERTSB_CTLSB_BOTHSB_LINEUPSB_LINELEFTSB_LINEDOWNSB_LINERIGHTSB_PAGEUPSB_PAGELEFTSB_PAGEDOWNSB_PAGERIGHTSB_THUMBPOSITIONSB_THUMBTRACKSB_TOPSB_LEFTSB_BOTTOMSB_RIGHTSB_ENDSCROLLSW_SHOWNORMALSW_NORMALSW_SHOWMINIMIZEDSW_SHOWMAXIMIZEDSW_SHOWNOACTIVATESW_SHOWSW_SHOWMINNOACTIVESW_SHOWNASW_RESTORESW_SHOWDEFAULTSW_FORCEMINIMIZEHIDE_WINDOWSHOW_OPENWINDOWSHOW_ICONWINDOWSHOW_FULLSCREENSHOW_OPENNOACTIVATESW_PARENTCLOSINGSW_OTHERZOOMSW_PARENTOPENINGSW_OTHERUNZOOMAW_HOR_POSITIVEAW_HOR_NEGATIVEAW_VER_POSITIVEAW_VER_NEGATIVEAW_CENTERAW_HIDEAW_ACTIVATEAW_SLIDEAW_BLENDKF_EXTENDEDKF_DLGMODEKF_MENUMODEKF_ALTDOWNKF_REPEATKF_UPVK_HANGEULVK_NAVIGATION_VIEWVK_NAVIGATION_MENUVK_NAVIGATION_UPVK_NAVIGATION_DOWNVK_NAVIGATION_LEFTVK_NAVIGATION_RIGHTVK_NAVIGATION_ACCEPTVK_NAVIGATION_CANCELVK_OEM_NEC_EQUALVK_OEM_FJ_JISHOVK_OEM_FJ_MASSHOUVK_OEM_FJ_TOUROKUVK_OEM_FJ_LOYAVK_OEM_FJ_ROYAVK_GAMEPAD_AVK_GAMEPAD_BVK_GAMEPAD_XVK_GAMEPAD_YVK_GAMEPAD_RIGHT_SHOULDERVK_GAMEPAD_LEFT_SHOULDERVK_GAMEPAD_LEFT_TRIGGERVK_GAMEPAD_RIGHT_TRIGGERVK_GAMEPAD_DPAD_UPVK_GAMEPAD_DPAD_DOWNVK_GAMEPAD_DPAD_LEFTVK_GAMEPAD_DPAD_RIGHTVK_GAMEPAD_MENUVK_GAMEPAD_VIEWVK_GAMEPAD_LEFT_THUMBSTICK_BUTTONVK_GAMEPAD_RIGHT_THUMBSTICK_BUTTONVK_GAMEPAD_LEFT_THUMBSTICK_UPVK_GAMEPAD_LEFT_THUMBSTICK_DOWNVK_GAMEPAD_LEFT_THUMBSTICK_RIGHTVK_GAMEPAD_LEFT_THUMBSTICK_LEFTVK_GAMEPAD_RIGHT_THUMBSTICK_UPVK_GAMEPAD_RIGHT_THUMBSTICK_DOWNVK_GAMEPAD_RIGHT_THUMBSTICK_RIGHTVK_GAMEPAD_RIGHT_THUMBSTICK_LEFTVK_OEM_AXVK_ICO_HELPVK_ICO_00VK_ICO_CLEARVK_OEM_RESETVK_OEM_JUMPVK_OEM_PA1VK_OEM_PA2VK_OEM_PA3VK_OEM_WSCTRLVK_OEM_CUSELVK_OEM_ATTNVK_OEM_FINISHVK_OEM_COPYVK_OEM_AUTOVK_OEM_ENLWVK_OEM_BACKTABWH_MINWH_MSGFILTERWH_JOURNALRECORDWH_JOURNALPLAYBACKWH_KEYBOARDWH_GETMESSAGEWH_CALLWNDPROCWH_CBTWH_SYSMSGFILTERWH_MOUSEWH_HARDWAREWH_DEBUGWH_SHELLWH_FOREGROUNDIDLEWH_CALLWNDPROCRETWH_MAXWH_MINHOOKWH_MAXHOOKHC_GETNEXTHC_SKIPHC_NOREMOVEHC_NOREMHC_SYSMODALONHC_SYSMODALOFFHCBT_MOVESIZEHCBT_MINMAXHCBT_QSHCBT_CREATEWNDHCBT_DESTROYWNDHCBT_ACTIVATEHCBT_CLICKSKIPPEDHCBT_KEYSKIPPEDHCBT_SYSCOMMANDHCBT_SETFOCUSLPCBT_CREATEWNDACBT_CREATEWNDALPCBT_CREATEWNDWCBT_CREATEWNDWLPCBTACTIVATESTRUCTCBTACTIVATESTRUCTPWTSSESSION_NOTIFICATIONWTSSESSION_NOTIFICATIONWTS_CONSOLE_CONNECTWTS_CONSOLE_DISCONNECTWTS_REMOTE_CONNECTWTS_REMOTE_DISCONNECTWTS_SESSION_LOGONWTS_SESSION_LOGOFFWTS_SESSION_LOCKWTS_SESSION_UNLOCKWTS_SESSION_REMOTE_CONTROLWTS_SESSION_CREATEWTS_SESSION_TERMINATEMSGF_DIALOGBOXMSGF_MESSAGEBOXMSGF_MENUMSGF_SCROLLBARMSGF_NEXTWINDOWMSGF_MAXMSGF_USERHSHELL_WINDOWCREATEDHSHELL_WINDOWDESTROYEDHSHELL_ACTIVATESHELLWINDOWHSHELL_WINDOWACTIVATEDHSHELL_GETMINRECTHSHELL_REDRAWHSHELL_TASKMANHSHELL_LANGUAGEHSHELL_SYSMENUHSHELL_ENDTASKHSHELL_ACCESSIBILITYSTATEHSHELL_APPCOMMANDHSHELL_WINDOWREPLACEDHSHELL_WINDOWREPLACINGHSHELL_MONITORCHANGEDHSHELL_HIGHBITHSHELL_FLASHHSHELL_RUDEAPPACTIVATEDAPPCOMMAND_BROWSER_BACKWARDAPPCOMMAND_BROWSER_FORWARDAPPCOMMAND_BROWSER_REFRESHAPPCOMMAND_BROWSER_STOPAPPCOMMAND_BROWSER_SEARCHAPPCOMMAND_BROWSER_FAVORITESAPPCOMMAND_BROWSER_HOMEAPPCOMMAND_VOLUME_MUTEAPPCOMMAND_VOLUME_DOWNAPPCOMMAND_VOLUME_UPAPPCOMMAND_MEDIA_NEXTTRACKAPPCOMMAND_MEDIA_PREVIOUSTRACKAPPCOMMAND_MEDIA_STOPAPPCOMMAND_MEDIA_PLAY_PAUSEAPPCOMMAND_LAUNCH_MAILAPPCOMMAND_LAUNCH_MEDIA_SELECTAPPCOMMAND_LAUNCH_APP1APPCOMMAND_LAUNCH_APP2APPCOMMAND_BASS_DOWNAPPCOMMAND_BASS_BOOSTAPPCOMMAND_BASS_UPAPPCOMMAND_TREBLE_DOWNAPPCOMMAND_TREBLE_UPAPPCOMMAND_MICROPHONE_VOLUME_MUTEAPPCOMMAND_MICROPHONE_VOLUME_DOWNAPPCOMMAND_MICROPHONE_VOLUME_UPAPPCOMMAND_HELPAPPCOMMAND_FINDAPPCOMMAND_NEWAPPCOMMAND_OPENAPPCOMMAND_CLOSEAPPCOMMAND_SAVEAPPCOMMAND_PRINTAPPCOMMAND_UNDOAPPCOMMAND_REDOAPPCOMMAND_COPYAPPCOMMAND_CUTAPPCOMMAND_PASTEAPPCOMMAND_REPLY_TO_MAILAPPCOMMAND_FORWARD_MAILAPPCOMMAND_SEND_MAILAPPCOMMAND_SPELL_CHECKAPPCOMMAND_DICTATE_OR_COMMAND_CONTROL_TOGGLEAPPCOMMAND_MIC_ON_OFF_TOGGLEAPPCOMMAND_CORRECTION_LISTAPPCOMMAND_MEDIA_PLAYAPPCOMMAND_MEDIA_PAUSEAPPCOMMAND_MEDIA_RECORDAPPCOMMAND_MEDIA_FAST_FORWARDAPPCOMMAND_MEDIA_REWINDAPPCOMMAND_MEDIA_CHANNEL_UPAPPCOMMAND_MEDIA_CHANNEL_DOWNAPPCOMMAND_DELETEAPPCOMMAND_DWM_FLIP3DFAPPCOMMAND_MOUSEFAPPCOMMAND_KEYFAPPCOMMAND_OEMFAPPCOMMAND_MASKGET_APPCOMMAND_LPARAMGET_DEVICE_LPARAMGET_MOUSEORKEY_LPARAMGET_FLAGS_LPARAMGET_KEYSTATE_LPARAMLPSHELLHOOKINFOSHELLHOOKINFOPEVENTMSGMSGEVENTMSGNPEVENTMSGMSGLPEVENTMSGMSGPEVENTMSGNPEVENTMSGLPEVENTMSGPCWPSTRUCTCWPSTRUCTNPCWPSTRUCTLPCWPSTRUCTPCWPRETSTRUCTCWPRETSTRUCTNPCWPRETSTRUCTLPCWPRETSTRUCTLLKHF_EXTENDEDLLKHF_INJECTEDLLKHF_ALTDOWNLLKHF_UPLLKHF_LOWER_IL_INJECTEDLLMHF_INJECTEDLLMHF_LOWER_IL_INJECTEDLPKBDLLHOOKSTRUCTLPMSLLHOOKSTRUCTPMSLLHOOKSTRUCTPDEBUGHOOKINFODEBUGHOOKINFONPDEBUGHOOKINFOLPDEBUGHOOKINFOLPMOUSEHOOKSTRUCTMOUSEHOOKSTRUCTLPMOUSEHOOKSTRUCTEXMOUSEHOOKSTRUCTEXPMOUSEHOOKSTRUCTEXLPHARDWAREHOOKSTRUCTHARDWAREHOOKSTRUCTPHARDWAREHOOKSTRUCTHKL_PREVHKL_NEXTKLF_ACTIVATEKLF_SUBSTITUTE_OKKLF_REORDERKLF_REPLACELANGKLF_NOTELLSHELLKLF_SETFORPROCESSKLF_SHIFTLOCKKLF_RESETINPUTLANGCHANGE_SYSCHARSETINPUTLANGCHANGE_FORWARDINPUTLANGCHANGE_BACKWARDKL_NAMELENGTHLoadKeyboardLayoutALoadKeyboardLayoutWActivateKeyboardLayoutUnloadKeyboardLayoutGetKeyboardLayoutNameAGetKeyboardLayoutNameWPMOUSEMOVEPOINTMOUSEMOVEPOINTLPMOUSEMOVEPOINTGMMP_USE_DISPLAY_POINTSGMMP_USE_HIGH_RESOLUTION_POINTSGetMouseMovePointsExDESKTOP_READOBJECTSDESKTOP_CREATEWINDOWDESKTOP_CREATEMENUDESKTOP_HOOKCONTROLDESKTOP_JOURNALRECORDDESKTOP_JOURNALPLAYBACKDESKTOP_ENUMERATEDESKTOP_WRITEOBJECTSDESKTOP_SWITCHDESKTOPDF_ALLOWOTHERACCOUNTHOOKCreateDesktopACreateDesktopWCreateDesktopExACreateDesktopExWOpenDesktopAOpenDesktopWOpenInputDesktopEnumDesktopsAEnumDesktopsWEnumDesktopWindowsWNDENUMPROCSwitchDesktopSetThreadDesktopCloseDesktopGetThreadDesktopWINSTA_ENUMDESKTOPSWINSTA_READATTRIBUTESWINSTA_ACCESSCLIPBOARDWINSTA_CREATEDESKTOPWINSTA_WRITEATTRIBUTESWINSTA_ACCESSGLOBALATOMSWINSTA_EXITWINDOWSWINSTA_ENUMERATEWINSTA_READSCREENWINSTA_ALL_ACCESSCWF_CREATE_ONLYWSF_VISIBLECreateWindowStationACreateWindowStationWOpenWindowStationAOpenWindowStationWEnumWindowStationsAEnumWindowStationsWCloseWindowStationSetProcessWindowStationGetProcessWindowStationSetUserObjectSecurityGetUserObjectSecurityUOI_FLAGSUOI_NAMEUOI_TYPEUOI_USER_SIDUOI_HEAPSIZEUOI_IOUOI_TIMERPROC_EXCEPTION_SUPPRESSIONPUSEROBJECTFLAGSUSEROBJECTFLAGSGetUserObjectInformationAGetUserObjectInformationWSetUserObjectInformationASetUserObjectInformationWPWNDCLASSEXAWNDCLASSEXANPWNDCLASSEXALPWNDCLASSEXAPWNDCLASSEXWWNDCLASSEXWNPWNDCLASSEXWLPWNDCLASSEXWPWNDCLASSAWNDCLASSANPWNDCLASSALPWNDCLASSAPWNDCLASSWNPWNDCLASSWLPWNDCLASSWIsHungAppWindowDisableProcessWindowsGhostingPMSGNPMSGGWL_WNDPROC//POINTSTOPOINT//POINTTOPOINTS//MAKEWPARAM//MAKELPARAM//MAKELRESULTGWL_HINSTANCEGWL_HWNDPARENTGWL_STYLEGWL_EXSTYLEGWL_IDGWLP_WNDPROCGWLP_HINSTANCEGWLP_HWNDPARENTGWLP_USERDATAGWLP_IDGCL_MENUNAMEGCL_HBRBACKGROUNDGCL_HCURSORGCL_HICONGCL_HMODULEGCL_CBWNDEXTRAGCL_CBCLSEXTRAGCL_WNDPROCGCL_STYLEGCW_ATOMGCL_HICONSMGCLP_MENUNAMEGCLP_HBRBACKGROUNDGCLP_HCURSORGCLP_HICONGCLP_HMODULEGCLP_WNDPROCGCLP_HICONSMWM_NULLWM_MOVEWM_SIZEWM_ACTIVATEWA_INACTIVEWA_ACTIVEWA_CLICKACTIVEWM_SETFOCUSWM_KILLFOCUSWM_ENABLEWM_SETREDRAWWM_SETTEXTWM_GETTEXTWM_GETTEXTLENGTHWM_PAINTWM_QUERYENDSESSIONWM_QUERYOPENWM_ENDSESSIONWM_QUITWM_ERASEBKGNDWM_SYSCOLORCHANGEWM_SHOWWINDOWWM_WININICHANGEWM_SETTINGCHANGEWM_DEVMODECHANGEWM_ACTIVATEAPPWM_FONTCHANGEWM_TIMECHANGEWM_CANCELMODEWM_SETCURSORWM_MOUSEACTIVATEWM_CHILDACTIVATEWM_QUEUESYNCWM_GETMINMAXINFOPMINMAXINFOMINMAXINFOLPMINMAXINFOWM_PAINTICONWM_ICONERASEBKGNDWM_NEXTDLGCTLWM_SPOOLERSTATUSWM_DRAWITEMWM_MEASUREITEMWM_DELETEITEMWM_VKEYTOITEMWM_CHARTOITEMWM_SETFONTWM_GETFONTWM_SETHOTKEYWM_GETHOTKEYWM_QUERYDRAGICONWM_COMPAREITEMWM_GETOBJECTWM_COMPACTINGWM_COMMNOTIFYWM_WINDOWPOSCHANGINGWM_WINDOWPOSCHANGEDWM_POWERPWR_OKPWR_FAILPWR_SUSPENDREQUESTPWR_SUSPENDRESUMEPWR_CRITICALRESUMEWM_COPYDATAWM_CANCELJOURNALPCOPYDATASTRUCTCOPYDATASTRUCTPMDINEXTMENUMDINEXTMENULPMDINEXTMENUWM_NOTIFYWM_INPUTLANGCHANGEREQUESTWM_INPUTLANGCHANGEWM_TCARDWM_HELPWM_USERCHANGEDWM_NOTIFYFORMATNFR_ANSINFR_UNICODENF_QUERYNF_REQUERYWM_CONTEXTMENUWM_STYLECHANGINGWM_STYLECHANGEDWM_DISPLAYCHANGEWM_GETICONWM_SETICONWM_NCDESTROYWM_NCCALCSIZEWM_NCHITTESTWM_GETDLGCODEWM_SYNCPAINTWM_NCMOUSEMOVEWM_NCLBUTTONDOWNWM_NCLBUTTONUPWM_NCLBUTTONDBLCLKWM_NCRBUTTONDOWNWM_NCRBUTTONUPWM_NCRBUTTONDBLCLKWM_NCMBUTTONDOWNWM_NCMBUTTONUPWM_NCMBUTTONDBLCLKWM_NCXBUTTONDOWNWM_NCXBUTTONUPWM_NCXBUTTONDBLCLKWM_INPUT_DEVICE_CHANGEWM_INPUTWM_KEYFIRSTWM_CHARWM_DEADCHARWM_SYSCHARWM_SYSDEADCHARWM_UNICHARWM_KEYLASTUNICODE_NOCHARWM_IME_STARTCOMPOSITIONWM_IME_ENDCOMPOSITIONWM_IME_COMPOSITIONWM_IME_KEYLASTWM_INITDIALOGWM_SYSCOMMANDWM_HSCROLLWM_VSCROLLWM_INITMENUWM_INITMENUPOPUPWM_GESTUREWM_GESTURENOTIFYWM_MENUSELECTWM_MENUCHARWM_ENTERIDLEWM_MENURBUTTONUPWM_MENUDRAGWM_MENUGETOBJECTWM_UNINITMENUPOPUPWM_MENUCOMMANDWM_CHANGEUISTATEWM_UPDATEUISTATEWM_QUERYUISTATEUIS_SETUIS_CLEARUIS_INITIALIZEUISF_HIDEFOCUSUISF_HIDEACCELUISF_ACTIVEWM_CTLCOLORMSGBOXWM_CTLCOLOREDITWM_CTLCOLORLISTBOXWM_CTLCOLORBTNWM_CTLCOLORDLGWM_CTLCOLORSCROLLBARWM_CTLCOLORSTATICMN_GETHMENUWM_MOUSEFIRSTWM_LBUTTONDBLCLKWM_RBUTTONDBLCLKWM_MBUTTONDBLCLKWM_XBUTTONDBLCLKWM_MOUSELASTWHEEL_PAGESCROLLGET_KEYSTATE_WPARAMGET_NCHITTEST_WPARAMWM_PARENTNOTIFYWM_ENTERMENULOOPWM_EXITMENULOOPWM_NEXTMENUWM_SIZINGWM_CAPTURECHANGEDWM_MOVINGWM_POWERBROADCASTPBT_APMQUERYSUSPENDPBT_APMQUERYSTANDBYPBT_APMQUERYSUSPENDFAILEDPBT_APMQUERYSTANDBYFAILEDPBT_APMSUSPENDPBT_APMSTANDBYPBT_APMRESUMECRITICALPBT_APMRESUMESUSPENDPBT_APMRESUMESTANDBYPBTF_APMRESUMEFROMFAILUREPBT_APMBATTERYLOWPBT_APMPOWERSTATUSCHANGEPBT_APMOEMEVENTPBT_APMRESUMEAUTOMATICPBT_POWERSETTINGCHANGEPPOWERBROADCAST_SETTINGPOWERBROADCAST_SETTINGWM_MDICREATEWM_MDIDESTROYWM_MDIACTIVATEWM_MDIRESTOREWM_MDINEXTWM_MDIMAXIMIZEWM_MDITILEWM_MDICASCADEWM_MDIICONARRANGEWM_MDIGETACTIVEWM_MDISETMENUWM_ENTERSIZEMOVEWM_EXITSIZEMOVEWM_DROPFILESWM_MDIREFRESHMENUWM_POINTERDEVICECHANGEWM_POINTERDEVICEINRANGEWM_POINTERDEVICEOUTOFRANGEWM_TOUCHWM_NCPOINTERUPDATEWM_NCPOINTERDOWNWM_NCPOINTERUPWM_POINTERUPDATEWM_POINTERDOWNWM_POINTERUPWM_POINTERENTERWM_POINTERLEAVEWM_POINTERACTIVATEWM_POINTERCAPTURECHANGEDWM_TOUCHHITTESTINGWM_POINTERWHEELWM_POINTERHWHEELDM_POINTERHITTESTWM_POINTERROUTEDTOWM_POINTERROUTEDAWAYWM_POINTERROUTEDRELEASEDWM_IME_SETCONTEXTWM_IME_NOTIFYWM_IME_CONTROLWM_IME_COMPOSITIONFULLWM_IME_SELECTWM_IME_CHARWM_IME_REQUESTWM_IME_KEYDOWNWM_IME_KEYUPWM_MOUSEHOVERWM_MOUSELEAVEWM_NCMOUSEHOVERWM_NCMOUSELEAVEWM_WTSSESSION_CHANGEWM_TABLET_FIRSTWM_TABLET_LASTWM_DPICHANGEDWM_DPICHANGED_BEFOREPARENTWM_DPICHANGED_AFTERPARENTWM_GETDPISCALEDSIZEWM_CUTWM_COPYWM_PASTEWM_CLEARWM_UNDOWM_RENDERFORMATWM_RENDERALLFORMATSWM_DESTROYCLIPBOARDWM_DRAWCLIPBOARDWM_PAINTCLIPBOARDWM_VSCROLLCLIPBOARDWM_SIZECLIPBOARDWM_ASKCBFORMATNAMEWM_CHANGECBCHAINWM_HSCROLLCLIPBOARDWM_QUERYNEWPALETTEWM_PALETTEISCHANGINGWM_PALETTECHANGEDWM_HOTKEYWM_PRINTWM_PRINTCLIENTWM_APPCOMMANDWM_THEMECHANGEDWM_DWMCOMPOSITIONCHANGEDWM_DWMNCRENDERINGCHANGEDWM_DWMCOLORIZATIONCOLORCHANGEDWM_DWMWINDOWMAXIMIZEDCHANGEWM_DWMSENDICONICTHUMBNAILWM_DWMSENDICONICLIVEPREVIEWBITMAPWM_GETTITLEBARINFOEXWM_HANDHELDFIRSTWM_HANDHELDLASTWM_AFXFIRSTWM_AFXLASTWM_PENWINFIRSTWM_PENWINLASTWM_APPWMSZ_LEFTWMSZ_RIGHTWMSZ_TOPWMSZ_TOPLEFTWMSZ_TOPRIGHTWMSZ_BOTTOMWMSZ_BOTTOMLEFTWMSZ_BOTTOMRIGHTHTERRORHTTRANSPARENTHTNOWHEREHTCLIENTHTCAPTIONHTSYSMENUHTGROWBOXHTSIZEHTMENUHTHSCROLLHTVSCROLLHTMINBUTTONHTMAXBUTTONHTLEFTHTRIGHTHTTOPHTTOPLEFTHTTOPRIGHTHTBOTTOMHTBOTTOMLEFTHTBOTTOMRIGHTHTBORDERHTREDUCEHTZOOMHTSIZEFIRSTHTSIZELASTHTOBJECTHTCLOSEHTHELPSMTO_NORMALSMTO_BLOCKSMTO_ABORTIFHUNGSMTO_NOTIMEOUTIFNOTHUNGSMTO_ERRORONEXITMA_ACTIVATEMA_ACTIVATEANDEATMA_NOACTIVATEMA_NOACTIVATEANDEATICON_SMALL2RegisterWindowMessageWSIZE_RESTOREDSIZE_MINIMIZEDSIZE_MAXIMIZEDSIZE_MAXSHOWSIZE_MAXHIDESIZENORMALSIZEICONICSIZEFULLSCREENSIZEZOOMSHOWSIZEZOOMHIDELPWINDOWPOSPWINDOWPOSLPNCCALCSIZE_PARAMSNCCALCSIZE_PARAMSWVR_ALIGNTOPWVR_ALIGNLEFTWVR_ALIGNBOTTOMWVR_ALIGNRIGHTWVR_HREDRAWWVR_VREDRAWWVR_REDRAWWVR_VALIDRECTSMK_LBUTTONMK_RBUTTONMK_SHIFTMK_CONTROLMK_MBUTTONMK_XBUTTON1MK_XBUTTON2TME_HOVERTME_LEAVETME_NONCLIENTTME_QUERYTME_CANCELTRACKMOUSEEVENTTrackMouseEventWS_POPUPWS_CHILDWS_MINIMIZEWS_VISIBLEWS_DISABLEDWS_CLIPSIBLINGSWS_CLIPCHILDRENWS_MAXIMIZEWS_CAPTIONWS_BORDERWS_DLGFRAMEWS_VSCROLLWS_HSCROLLWS_SYSMENUWS_THICKFRAMEWS_GROUPWS_TABSTOPWS_MINIMIZEBOXWS_MAXIMIZEBOXWS_TILEDWS_ICONICWS_SIZEBOXWS_TILEDWINDOWWS_OVERLAPPEDWINDOWWS_POPUPWINDOWWS_CHILDWINDOWWS_EX_DLGMODALFRAMEWS_EX_NOPARENTNOTIFYWS_EX_TOPMOSTWS_EX_ACCEPTFILESWS_EX_MDICHILDWS_EX_WINDOWEDGEWS_EX_CLIENTEDGEWS_EX_CONTEXTHELPWS_EX_RIGHTWS_EX_LEFTWS_EX_RTLREADINGWS_EX_LTRREADINGWS_EX_LEFTSCROLLBARWS_EX_RIGHTSCROLLBARWS_EX_CONTROLPARENTWS_EX_STATICEDGEWS_EX_APPWINDOWWS_EX_OVERLAPPEDWINDOWWS_EX_PALETTEWINDOWWS_EX_NOINHERITLAYOUTWS_EX_NOREDIRECTIONBITMAPWS_EX_LAYOUTRTLWS_EX_COMPOSITEDCS_VREDRAWCS_HREDRAWCS_DBLCLKSCS_OWNDCCS_CLASSDCCS_PARENTDCCS_NOCLOSECS_SAVEBITSCS_BYTEALIGNCLIENTCS_BYTEALIGNWINDOWCS_GLOBALCLASSCS_IMECS_DROPSHADOWPRF_CHECKVISIBLEPRF_NONCLIENTPRF_CLIENTPRF_ERASEBKGNDPRF_CHILDRENPRF_OWNEDBDR_RAISEDOUTERBDR_SUNKENOUTERBDR_RAISEDINNERBDR_SUNKENINNERBDR_OUTERBDR_INNERBDR_RAISEDBDR_SUNKENEDGE_RAISEDEDGE_SUNKENEDGE_ETCHEDEDGE_BUMPBF_LEFTBF_TOPBF_RIGHTBF_BOTTOMBF_TOPLEFTBF_TOPRIGHTBF_BOTTOMLEFTBF_BOTTOMRIGHTBF_RECTBF_DIAGONALBF_DIAGONAL_ENDTOPRIGHTBF_DIAGONAL_ENDTOPLEFTBF_DIAGONAL_ENDBOTTOMLEFTBF_DIAGONAL_ENDBOTTOMRIGHTBF_MIDDLEBF_SOFTBF_ADJUSTBF_FLATBF_MONODrawEdgeDFC_CAPTIONDFC_MENUDFC_SCROLLDFC_BUTTONDFC_POPUPMENUDFCS_CAPTIONCLOSEDFCS_CAPTIONMINDFCS_CAPTIONMAXDFCS_CAPTIONRESTOREDFCS_CAPTIONHELPDFCS_MENUARROWDFCS_MENUCHECKDFCS_MENUBULLETDFCS_MENUARROWRIGHTDFCS_SCROLLUPDFCS_SCROLLDOWNDFCS_SCROLLLEFTDFCS_SCROLLRIGHTDFCS_SCROLLCOMBOBOXDFCS_SCROLLSIZEGRIPDFCS_SCROLLSIZEGRIPRIGHTDFCS_BUTTONCHECKDFCS_BUTTONRADIOIMAGEDFCS_BUTTONRADIOMASKDFCS_BUTTONRADIODFCS_BUTTON3STATEDFCS_BUTTONPUSHDFCS_INACTIVEDFCS_PUSHEDDFCS_CHECKEDDFCS_TRANSPARENTDFCS_HOTDFCS_ADJUSTRECTDFCS_FLATDFCS_MONODrawFrameControlDC_ACTIVEDC_SMALLCAPDC_ICONDC_TEXTDC_INBUTTONDC_GRADIENTDC_BUTTONSDrawCaptionIDANI_OPENIDANI_CAPTIONDrawAnimatedRectsCF_TEXTCF_BITMAPCF_METAFILEPICTCF_SYLKCF_DIFCF_TIFFCF_OEMTEXTCF_DIBCF_PALETTECF_PENDATACF_RIFFCF_WAVECF_UNICODETEXTCF_ENHMETAFILECF_LOCALECF_MAXCF_OWNERDISPLAYCF_DSPTEXTCF_DSPBITMAPCF_DSPMETAFILEPICTCF_DSPENHMETAFILECF_PRIVATEFIRSTCF_PRIVATELASTCF_GDIOBJFIRSTCF_GDIOBJLASTFNOINVERTLPACCELPPAINTSTRUCTPAINTSTRUCTNPPAINTSTRUCTLPPAINTSTRUCTLPCREATESTRUCTACREATESTRUCTALPCREATESTRUCTWPWINDOWPLACEMENTLPWINDOWPLACEMENTWPF_SETMINPOSITIONWPF_RESTORETOMAXIMIZEDWPF_ASYNCWINDOWPLACEMENTLPNMHDRLPSTYLESTRUCTSTYLESTRUCTODT_MENUODT_LISTBOXODT_COMBOBOXODT_BUTTONODT_STATICODA_DRAWENTIREODA_SELECTODA_FOCUSODS_SELECTEDODS_GRAYEDODS_DISABLEDODS_CHECKEDODS_FOCUSODS_DEFAULTODS_COMBOBOXEDITODS_HOTLIGHTODS_INACTIVEODS_NOACCELODS_NOFOCUSRECTPMEASUREITEMSTRUCTMEASUREITEMSTRUCTLPMEASUREITEMSTRUCTPDRAWITEMSTRUCTLPDRAWITEMSTRUCTPDELETEITEMSTRUCTDELETEITEMSTRUCTLPDELETEITEMSTRUCTPCOMPAREITEMSTRUCTCOMPAREITEMSTRUCTLPCOMPAREITEMSTRUCTGetMessageWDispatchMessageWSetMessageQueuePeekMessageAPeekMessageWPM_NOREMOVEPM_REMOVEPM_NOYIELDPM_QS_INPUTPM_QS_POSTMESSAGEPM_QS_PAINTPM_QS_SENDMESSAGERegisterHotKeyUnregisterHotKeyMOD_ALTMOD_CONTROLMOD_SHIFTMOD_WINMOD_NOREPEATIDHOT_SNAPWINDOWIDHOT_SNAPDESKTOPENDSESSION_CLOSEAPPENDSESSION_CRITICALENDSESSION_LOGOFFEWX_POWEROFFEWX_QUICKRESOLVEEWX_RESTARTAPPSEWX_HYBRID_SHUTDOWNEWX_BOOTOPTIONSSwapMouseButtonGetMessagePosGetMessageTimeGetMessageExtraInfoGetUnpredictedMessagePosIsWow64MessageSetMessageExtraInfoSendMessageASendMessageTimeoutASendMessageTimeoutWSendNotifyMessageASendNotifyMessageWSendMessageCallbackASENDASYNCPROCSendMessageCallbackWPBSMINFOBSMINFOBroadcastSystemMessageExABroadcastSystemMessageExWBroadcastSystemMessageABroadcastSystemMessageWBSM_ALLDESKTOPSBSF_ALLOWSFWBSF_SENDNOTIFYMESSAGEBSF_RETURNHDESKBSF_LUIDBROADCAST_QUERY_DENYPHDEVNOTIFYDEVICE_NOTIFY_WINDOW_HANDLEDEVICE_NOTIFY_SERVICE_HANDLEDEVICE_NOTIFY_ALL_INTERFACE_CLASSESRegisterDeviceNotificationARegisterDeviceNotificationWUnregisterDeviceNotificationRegisterPowerSettingNotificationUnregisterPowerSettingNotificationRegisterSuspendResumeNotificationUnregisterSuspendResumeNotificationPostMessageAPostThreadMessageWHWND_BROADCAST// PostAppMessageA// PostAppMessageWHWND_MESSAGEAttachThreadInputReplyMessageWaitMessageWaitForInputIdleDefWindowProcACallWindowProcAWNDPROCCallWindowProcWInSendMessageInSendMessageExISMEX_NOSENDISMEX_SENDISMEX_NOTIFYISMEX_CALLBACKISMEX_REPLIEDGetDoubleClickTimeSetDoubleClickTimeRegisterClassAUnregisterClassAUnregisterClassWGetClassInfoAGetClassInfoWRegisterClassExARegisterClassExWGetClassInfoExAGetClassInfoExWHWND_DESKTOPCreateWindowExAIsWindowIsMenuIsChildAnimateWindowUpdateLayeredWindowPUPDATELAYEREDWINDOWINFOUPDATELAYEREDWINDOWINFOUpdateLayeredWindowIndirectGetLayeredWindowAttributesPW_CLIENTONLYPW_RENDERFULLCONTENTPrintWindowSetLayeredWindowAttributesLWA_COLORKEYLWA_ALPHAULW_COLORKEYULW_ALPHAULW_OPAQUEULW_EX_NORESIZEShowWindowAsyncFlashWindowPFLASHWINFOFLASHWINFOFlashWindowExFLASHW_STOPFLASHW_CAPTIONFLASHW_TRAYFLASHW_ALLFLASHW_TIMERFLASHW_TIMERNOFGShowOwnedPopupsOpenIconMoveWindowSetWindowPosGetWindowPlacementSetWindowPlacementWDA_NONEWDA_MONITORGetWindowDisplayAffinitySetWindowDisplayAffinityBeginDeferWindowPosDeferWindowPosEndDeferWindowPosIsWindowVisibleIsIconicAnyPopupBringWindowToTopIsZoomedSWP_NOSIZESWP_NOMOVESWP_NOZORDERSWP_NOREDRAWSWP_NOACTIVATESWP_FRAMECHANGEDSWP_SHOWWINDOWSWP_HIDEWINDOWSWP_NOCOPYBITSSWP_NOOWNERZORDERSWP_NOSENDCHANGINGSWP_DRAWFRAMESWP_NOREPOSITIONSWP_DEFERERASESWP_ASYNCWINDOWPOSHWND_TOPHWND_BOTTOMHWND_TOPMOSTHWND_NOTOPMOST// FIXME packed(2)LPDLGTEMPLATEADLGTEMPLATELPDLGTEMPLATEWLPCDLGTEMPLATEWPDLGITEMTEMPLATEADLGITEMTEMPLATEPDLGITEMTEMPLATEWLPDLGITEMTEMPLATEALPDLGITEMTEMPLATEWCreateDialogParamACreateDialogParamWCreateDialogIndirectParamACreateDialogIndirectParamWDialogBoxParamADialogBoxParamWDialogBoxIndirectParamADialogBoxIndirectParamWEndDialogGetDlgItemSetDlgItemIntGetDlgItemIntSetDlgItemTextASetDlgItemTextWGetDlgItemTextAGetDlgItemTextWCheckDlgButtonCheckRadioButtonIsDlgButtonCheckedSendDlgItemMessageASendDlgItemMessageWGetNextDlgGroupItemGetNextDlgTabItemGetDlgCtrlIDGetDialogBaseUnitsDefDlgProcADefDlgProcWSetDialogControlDpiChangeBehaviorDIALOG_CONTROL_DPI_CHANGE_BEHAVIORSGetDialogControlDpiChangeBehaviorSetDialogDpiChangeBehaviorDIALOG_DPI_CHANGE_BEHAVIORSGetDialogDpiChangeBehaviorCallMsgFilterACallMsgFilterWCloseClipboardGetClipboardSequenceNumberGetClipboardOwnerSetClipboardViewerGetClipboardViewerChangeClipboardChainGetClipboardDataRegisterClipboardFormatARegisterClipboardFormatWCountClipboardFormatsEnumClipboardFormatsGetClipboardFormatNameAGetClipboardFormatNameWEmptyClipboardIsClipboardFormatAvailableGetPriorityClipboardFormatGetOpenClipboardWindowGetUpdatedClipboardFormatsCharToOemACharToOemWOemToCharAOemToCharWCharToOemBuffACharToOemBuffWOemToCharBuffAOemToCharBuffWCharUpperACharUpperWCharUpperBuffACharUpperBuffWCharLowerACharLowerWCharLowerBuffACharLowerBuffWCharNextACharNextWCharPrevACharPrevWCharNextExACharPrevExAIsCharAlphaAIsCharAlphaWIsCharAlphaNumericAIsCharAlphaNumericWIsCharUpperAIsCharUpperWIsCharLowerAIsCharLowerWSetFocusGetActiveWindowGetFocusGetKBCodePageGetAsyncKeyStateSetKeyboardStateGetKeyNameTextAGetKeyNameTextWGetKeyboardTypeToAsciiToAsciiExToUnicodeOemKeyScanVkKeyScanExAkeybd_eventmouse_eventPMOUSEINPUTLPMOUSEINPUTPKEYBDINPUTLPKEYBDINPUTPHARDWAREINPUTHARDWAREINPUTLPHARDWAREINPUTPINPUTPTOUCHINPUTTOUCHINPUTPCTOUCHINPUTTOUCHEVENTF_MOVE// TOUCH_COORD_TO_PIXELTOUCHEVENTF_DOWNTOUCHEVENTF_UPTOUCHEVENTF_INRANGETOUCHEVENTF_PRIMARYTOUCHEVENTF_NOCOALESCETOUCHEVENTF_PENTOUCHEVENTF_PALMTOUCHINPUTMASKF_TIMEFROMSYSTEMTOUCHINPUTMASKF_EXTRAINFOTOUCHINPUTMASKF_CONTACTAREAGetTouchInputInfoHTOUCHINPUTCloseTouchInputHandleTWF_FINETOUCHTWF_WANTPALMRegisterTouchWindowUnregisterTouchWindowIsTouchWindowPOINTER_MOD_SHIFTPOINTER_MOD_CTRLPOINTER_MESSAGE_FLAG_NEWPOINTER_MESSAGE_FLAG_INRANGEPOINTER_MESSAGE_FLAG_INCONTACTPOINTER_MESSAGE_FLAG_FIRSTBUTTONPOINTER_MESSAGE_FLAG_SECONDBUTTONPOINTER_MESSAGE_FLAG_THIRDBUTTONPOINTER_MESSAGE_FLAG_FOURTHBUTTONPOINTER_MESSAGE_FLAG_FIFTHBUTTONPOINTER_MESSAGE_FLAG_PRIMARYPOINTER_MESSAGE_FLAG_CONFIDENCEPOINTER_MESSAGE_FLAG_CANCELEDPA_ACTIVATEPA_NOACTIVATEMAX_TOUCH_COUNTTOUCH_FEEDBACK_DEFAULTTOUCH_FEEDBACK_INDIRECTTOUCH_FEEDBACK_NONEInitializeTouchInjectionInjectTouchInputPUSAGE_PROPERTIESUSAGE_PROPERTIESPPOINTER_TYPE_INFOPOINTER_TYPE_INFOPINPUT_INJECTION_VALUEINPUT_INJECTION_VALUEGetPointerTypePOINTER_INPUT_TYPEGetPointerCursorIdGetPointerInfoGetPointerInfoHistoryGetPointerFrameInfoGetPointerTouchInfoHistoryGetPointerFrameTouchInfoGetPointerFrameTouchInfoHistoryGetPointerPenInfoHistoryGetPointerFramePenInfoGetPointerFramePenInfoHistoryRegisterPointerInputTargetUnregisterPointerInputTargetRegisterPointerInputTargetExUnregisterPointerInputTargetExCreateSyntheticPointerDevicePOINTER_FEEDBACK_MODEHSYNTHETICPOINTERDEVICEInjectSyntheticPointerInputDestroySyntheticPointerDeviceEnableMouseInPointerIsMouseInPointerEnabledTOUCH_HIT_TESTING_DEFAULTTOUCH_HIT_TESTING_CLIENTTOUCH_HIT_TESTING_NONERegisterTouchHitTestingWindowPTOUCH_HIT_TESTING_PROXIMITY_EVALUATIONTOUCH_HIT_TESTING_PROXIMITY_EVALUATIONPTOUCH_HIT_TESTING_INPUTTOUCH_HIT_TESTING_INPUTTOUCH_HIT_TESTING_PROXIMITY_CLOSESTTOUCH_HIT_TESTING_PROXIMITY_FARTHESTEvaluateProximityToRectEvaluateProximityToPolygonPackTouchHitTestingProximityEvaluationGWFS_INCLUDE_ANCESTORSGetWindowFeedbackSettingFEEDBACK_TYPESetWindowFeedbackSettingGetPointerInputTransformINPUT_TRANSFORMPLASTINPUTINFOLASTINPUTINFOGetLastInputInfoMapVirtualKeyAMapVirtualKeyWMapVirtualKeyExAMAPVK_VSC_TO_VKMAPVK_VK_TO_CHARGetInputStateGetQueueStatusGetCaptureSetCaptureReleaseCaptureMsgWaitForMultipleObjectsMsgWaitForMultipleObjectsExMWMO_WAITALLMWMO_ALERTABLEMWMO_INPUTAVAILABLEQS_KEYQS_MOUSEMOVEQS_MOUSEBUTTONQS_POSTMESSAGEQS_TIMERQS_PAINTQS_SENDMESSAGEQS_HOTKEYQS_ALLPOSTMESSAGEQS_RAWINPUTQS_TOUCHQS_POINTERQS_MOUSEQS_INPUTQS_ALLEVENTSQS_ALLINPUTUSER_TIMER_MAXIMUMUSER_TIMER_MINIMUMTIMERPROCTIMERV_DEFAULT_COALESCINGTIMERV_NO_COALESCINGTIMERV_COALESCING_MINTIMERV_COALESCING_MAXSetCoalescableTimerIsWindowUnicodeEnableWindowIsWindowEnabledLoadAcceleratorsALoadAcceleratorsWCreateAcceleratorTableACopyAcceleratorTableACopyAcceleratorTableWTranslateAcceleratorATranslateAcceleratorWSM_CXVSCROLLSM_CYHSCROLLSM_CYCAPTIONSM_CXBORDERSM_CYBORDERSM_CXDLGFRAMESM_CYDLGFRAMESM_CYVTHUMBSM_CXHTHUMBSM_CXICONSM_CYICONSM_CXCURSORSM_CYCURSORSM_CYMENUSM_CXFULLSCREENSM_CYFULLSCREENSM_CYKANJIWINDOWSM_MOUSEPRESENTSM_CYVSCROLLSM_CXHSCROLLSM_DEBUGSM_SWAPBUTTONSM_RESERVED1SM_RESERVED2SM_RESERVED3SM_RESERVED4SM_CXMINSM_CYMINSM_CXSIZESM_CYSIZESM_CXFRAMESM_CYFRAMESM_CXMINTRACKSM_CYMINTRACKSM_CXDOUBLECLKSM_CYDOUBLECLKSM_CXICONSPACINGSM_CYICONSPACINGSM_MENUDROPALIGNMENTSM_PENWINDOWSSM_DBCSENABLEDSM_CMOUSEBUTTONSSM_CXFIXEDFRAMESM_CYFIXEDFRAMESM_CXSIZEFRAMESM_CYSIZEFRAMESM_SECURESM_CXEDGESM_CYEDGESM_CXMINSPACINGSM_CYMINSPACINGSM_CXSMICONSM_CYSMICONSM_CYSMCAPTIONSM_CXSMSIZESM_CYSMSIZESM_CXMENUSIZESM_CYMENUSIZESM_ARRANGESM_CXMINIMIZEDSM_CYMINIMIZEDSM_CXMAXTRACKSM_CYMAXTRACKSM_CXMAXIMIZEDSM_CYMAXIMIZEDSM_NETWORKSM_CLEANBOOTSM_CXDRAGSM_CYDRAGSM_SHOWSOUNDSSM_CXMENUCHECKSM_CYMENUCHECKSM_SLOWMACHINESM_MIDEASTENABLEDSM_MOUSEWHEELPRESENTSM_XVIRTUALSCREENSM_YVIRTUALSCREENSM_CMONITORSSM_SAMEDISPLAYFORMATSM_IMMENABLEDSM_CXFOCUSBORDERSM_CYFOCUSBORDERSM_TABLETPCSM_MEDIACENTERSM_STARTERSM_MOUSEHORIZONTALWHEELPRESENTSM_CXPADDEDBORDERSM_DIGITIZERSM_MAXIMUMTOUCHESSM_CMETRICSSM_REMOTESESSIONSM_SHUTTINGDOWNSM_REMOTECONTROLSM_CARETBLINKINGENABLEDSM_CONVERTIBLESLATEMODESM_SYSTEMDOCKEDGetSystemMetricsForDpiLoadMenuALoadMenuWLoadMenuIndirectALoadMenuIndirectWChangeMenuAChangeMenuWHiliteMenuItemGetMenuStringAGetMenuStringWGetMenuStatePMB_ACTIVEGetSystemMenuGetSubMenuGetMenuItemIDGetMenuItemCountInsertMenuAAppendMenuAModifyMenuAModifyMenuWDeleteMenuSetMenuItemBitmapsGetMenuCheckMarkDimensionsMNC_IGNOREMNC_CLOSEMNC_EXECUTEMNC_SELECTLPTPMPARAMSTPMPARAMSTrackPopupMenuExCalculatePopupWindowPositionMNS_NOCHECKMNS_MODELESSMNS_DRAGDROPMNS_AUTODISMISSMNS_NOTIFYBYPOSMNS_CHECKORBMPMIM_MAXHEIGHTMIM_BACKGROUNDMIM_HELPIDMIM_MENUDATAMIM_STYLEMIM_APPLYTOSUBMENUSLPMENUINFOMENUINFOLPCMENUINFOGetMenuInfoSetMenuInfoEndMenuMND_CONTINUEMND_ENDMENUPMENUGETOBJECTINFOMENUGETOBJECTINFOMNGOF_TOPGAPMNGOF_BOTTOMGAPMNGO_NOINTERFACEMNGO_NOERRORMIIM_IDMIIM_SUBMENUMIIM_CHECKMARKSMIIM_TYPEMIIM_DATAMIIM_FTYPEHBMMENU_CALLBACKHBMMENU_SYSTEMHBMMENU_MBAR_RESTOREHBMMENU_MBAR_MINIMIZEHBMMENU_MBAR_CLOSEHBMMENU_MBAR_CLOSE_DHBMMENU_MBAR_MINIMIZE_DHBMMENU_POPUP_CLOSEHBMMENU_POPUP_RESTOREHBMMENU_POPUP_MAXIMIZEHBMMENU_POPUP_MINIMIZELPMENUITEMINFOAMENUITEMINFOALPCMENUITEMINFOALPMENUITEMINFOWLPCMENUITEMINFOWInsertMenuItemAInsertMenuItemWGetMenuItemInfoASetMenuItemInfoAGMDI_USEDISABLEDGMDI_GOINTOPOPUPSGetMenuDefaultItemSetMenuDefaultItemGetMenuItemRectMenuItemFromPointTPM_LEFTBUTTONTPM_RIGHTBUTTONTPM_CENTERALIGNTPM_RIGHTALIGNTPM_TOPALIGNTPM_VCENTERALIGNTPM_HORIZONTALTPM_VERTICALTPM_NONOTIFYTPM_RETURNCMDTPM_RECURSETPM_HORPOSANIMATIONTPM_HORNEGANIMATIONTPM_VERPOSANIMATIONTPM_VERNEGANIMATIONTPM_NOANIMATIONTPM_LAYOUTRTLTPM_WORKAREAPDROPSTRUCTDROPSTRUCTLPDROPSTRUCTDOF_EXECUTABLEDOF_DOCUMENTDOF_DIRECTORYDOF_MULTIPLEDOF_PROGMANDOF_SHELLDATADO_DROPFILEDO_PRINTFILEDragObjectDragDetectDrawIconDT_TOPDT_LEFTDT_CENTERDT_RIGHTDT_VCENTERDT_BOTTOMDT_WORDBREAKDT_SINGLELINEDT_EXPANDTABSDT_TABSTOPDT_NOCLIPDT_EXTERNALLEADINGDT_CALCRECTDT_NOPREFIXDT_INTERNALDT_EDITCONTROLDT_PATH_ELLIPSISDT_END_ELLIPSISDT_MODIFYSTRINGDT_RTLREADINGDT_WORD_ELLIPSISDT_NOFULLWIDTHCHARBREAKDT_HIDEPREFIXDT_PREFIXONLYLPDRAWTEXTPARAMSDRAWTEXTPARAMSDrawTextADrawTextWDrawTextExADrawTextExWGrayStringAGRAYSTRINGPROCGrayStringWDST_COMPLEXDST_TEXTDST_PREFIXTEXTDST_ICONDST_BITMAPDSS_NORMALDSS_UNIONDSS_DISABLEDDSS_MONODSS_HIDEPREFIXDSS_PREFIXONLYDSS_RIGHTDrawStateADRAWSTATEPROCDrawStateWTabbedTextOutATabbedTextOutWGetTabbedTextExtentAGetTabbedTextExtentWUpdateWindowSetActiveWindowPaintDesktopSwitchToThisWindowAllowSetForegroundWindowASFW_ANYLockSetForegroundWindowLSFW_LOCKLSFW_UNLOCKWindowFromDCGetDCExDCX_WINDOWDCX_CACHEDCX_NORESETATTRSDCX_CLIPCHILDRENDCX_CLIPSIBLINGSDCX_PARENTCLIPDCX_EXCLUDERGNDCX_INTERSECTRGNDCX_EXCLUDEUPDATEDCX_INTERSECTUPDATEDCX_LOCKWINDOWUPDATEDCX_VALIDATEGetWindowDCBeginPaintEndPaintGetUpdateRectGetUpdateRgnSetWindowRgnGetWindowRgnGetWindowRgnBoxExcludeUpdateRgnInvalidateRectValidateRectValidateRgnRDW_INVALIDATERDW_ERASERDW_VALIDATERDW_NOINTERNALPAINTRDW_NOERASERDW_NOCHILDRENRDW_ALLCHILDRENRDW_UPDATENOWRDW_ERASENOWRDW_FRAMERDW_NOFRAMELockWindowUpdateScrollWindowScrollDCScrollWindowExSW_SCROLLCHILDRENSW_INVALIDATESW_ERASESW_SMOOTHSCROLLSetScrollPosGetScrollPosSetScrollRangeGetScrollRangeShowScrollBarEnableScrollBarESB_ENABLE_BOTHESB_DISABLE_BOTHESB_DISABLE_LEFTESB_DISABLE_RIGHTESB_DISABLE_UPESB_DISABLE_DOWNESB_DISABLE_LTUPESB_DISABLE_RTDNSetPropASetPropWGetPropAGetPropWRemovePropARemovePropWEnumPropsExAPROPENUMPROCAEnumPropsExWPROPENUMPROCWEnumPropsAEnumPropsWSetWindowTextASetWindowTextWGetWindowTextAGetWindowTextWGetWindowTextLengthAGetWindowTextLengthWAdjustWindowRectAdjustWindowRectExHELPINFO_WINDOWHELPINFO_MENUITEMLPHELPINFOHELPINFOSetWindowContextHelpIdGetWindowContextHelpIdSetMenuContextHelpIdGetMenuContextHelpIdMB_OKMB_OKCANCELMB_ABORTRETRYIGNOREMB_YESNOCANCELMB_YESNOMB_RETRYCANCELMB_CANCELTRYCONTINUEMB_ICONHANDMB_ICONQUESTIONMB_ICONEXCLAMATIONMB_ICONASTERISKMB_USERICONMB_ICONWARNINGMB_ICONERRORMB_ICONINFORMATIONMB_ICONSTOPMB_DEFBUTTON1MB_DEFBUTTON2MB_DEFBUTTON3MB_DEFBUTTON4MB_APPLMODALMB_SYSTEMMODALMB_TASKMODALMB_HELPMB_NOFOCUSMB_SETFOREGROUNDMB_DEFAULT_DESKTOP_ONLYMB_TOPMOSTMB_RIGHTMB_RTLREADINGMB_SERVICE_NOTIFICATIONMB_SERVICE_NOTIFICATION_NT3XMB_TYPEMASKMB_ICONMASKMB_DEFMASKMB_MODEMASKMB_MISCMASKMessageBoxAMessageBoxWMessageBoxExAMessageBoxExWPMSGBOXPARAMSAMSGBOXPARAMSALPMSGBOXPARAMSAPMSGBOXPARAMSWMSGBOXPARAMSWLPMSGBOXPARAMSWMessageBoxIndirectAMessageBoxIndirectWMessageBeepShowCursorSetCursorPosSetPhysicalCursorPosGetPhysicalCursorPosGetClipCursorGetCursorCreateCaretGetCaretBlinkTimeSetCaretBlinkTimeDestroyCaretHideCaretShowCaretSetCaretPosGetCaretPosScreenToClientLogicalToPhysicalPointPhysicalToLogicalPointLogicalToPhysicalPointForPerMonitorDPIPhysicalToLogicalPointForPerMonitorDPIMapWindowPointsWindowFromPointWindowFromPhysicalPointChildWindowFromPointClipCursorCWP_ALLCWP_SKIPINVISIBLECWP_SKIPDISABLEDCWP_SKIPTRANSPARENTChildWindowFromPointExCTLCOLOR_MSGBOXCTLCOLOR_EDITCTLCOLOR_LISTBOXCTLCOLOR_BTNCTLCOLOR_DLGCTLCOLOR_SCROLLBARCTLCOLOR_STATICCTLCOLOR_MAXCOLOR_SCROLLBARCOLOR_BACKGROUNDCOLOR_ACTIVECAPTIONCOLOR_INACTIVECAPTIONCOLOR_MENUCOLOR_WINDOWCOLOR_WINDOWFRAMECOLOR_MENUTEXTCOLOR_WINDOWTEXTCOLOR_CAPTIONTEXTCOLOR_ACTIVEBORDERCOLOR_INACTIVEBORDERCOLOR_APPWORKSPACECOLOR_HIGHLIGHTCOLOR_HIGHLIGHTTEXTCOLOR_BTNFACECOLOR_BTNSHADOWCOLOR_GRAYTEXTCOLOR_BTNTEXTCOLOR_INACTIVECAPTIONTEXTCOLOR_BTNHIGHLIGHTCOLOR_3DDKSHADOWCOLOR_3DLIGHTCOLOR_INFOTEXTCOLOR_INFOBKCOLOR_HOTLIGHTCOLOR_GRADIENTACTIVECAPTIONCOLOR_GRADIENTINACTIVECAPTIONCOLOR_MENUHILIGHTCOLOR_MENUBARCOLOR_DESKTOPCOLOR_3DFACECOLOR_3DSHADOWCOLOR_3DHIGHLIGHTCOLOR_3DHILIGHTCOLOR_BTNHILIGHTGetSysColorGetSysColorBrushSetSysColorsDrawFocusRectFillRectFrameRectInvertRectSetRectSetRectEmptyCopyRectInflateRectIntersectRectUnionRectSubtractRectOffsetRectIsRectEmptyEqualRectPtInRectGetWindowWordSetWindowWordGetWindowLongAGetWindowLongWSetWindowLongASetWindowLongWGetWindowLongPtrASetWindowLongPtrAGetClassWordSetClassWordGetClassLongAGetClassLongWSetClassLongASetClassLongWGetClassLongPtrAGetClassLongPtrWSetClassLongPtrASetClassLongPtrWGetProcessDefaultLayoutSetProcessDefaultLayoutGetDesktopWindowGetParentEnumChildWindowsFindWindowAFindWindowWFindWindowExAFindWindowExWGetShellWindowRegisterShellHookWindowDeregisterShellHookWindowEnumWindowsEnumThreadWindowsGetClassNameAGetClassNameWGetTopWindowIsGUIThreadGetLastActivePopupGW_HWNDFIRSTGW_HWNDLASTGW_HWNDNEXTGW_HWNDPREVGW_OWNERGW_CHILDGW_ENABLEDPOPUPGW_MAXSetWindowsHookAHOOKPROCSetWindowsHookWUnhookWindowsHookSetWindowsHookExWMF_INSERT// DefHookProcMF_CHANGEMF_APPENDMF_DELETEMF_REMOVEMF_USECHECKBITMAPSMF_BITMAPMF_OWNERDRAWMF_MENUBARBREAKMF_MENUBREAKMF_UNHILITEMF_HILITEMF_DEFAULTMF_SYSMENUMF_HELPMF_RIGHTJUSTIFYMF_MOUSESELECTMF_ENDMFT_STRINGMFT_BITMAPMFT_MENUBARBREAKMFT_MENUBREAKMFT_OWNERDRAWMFT_RADIOCHECKMFT_SEPARATORMFT_RIGHTORDERMFT_RIGHTJUSTIFYMFS_GRAYEDMFS_HILITEMFS_ENABLEDMFS_UNCHECKEDMFS_UNHILITEMFS_DEFAULTCheckMenuRadioItemSC_SIZE//10225SC_MOVESC_MINIMIZESC_MAXIMIZESC_NEXTWINDOWSC_PREVWINDOWSC_CLOSESC_VSCROLLSC_HSCROLLSC_MOUSEMENUSC_KEYMENUSC_ARRANGESC_RESTORESC_TASKLISTSC_SCREENSAVESC_HOTKEYSC_DEFAULTSC_MONITORPOWERSC_CONTEXTHELPSC_SEPARATORLoadBitmapALoadBitmapWLoadCursorALoadCursorWLoadCursorFromFileALoadCursorFromFileWCreateCursorDestroyCursorIDC_ARROW//10355IDC_IBEAMIDC_WAITIDC_CROSSIDC_UPARROWIDC_SIZEIDC_ICONIDC_SIZENWSEIDC_SIZENESWIDC_SIZEWEIDC_SIZENSIDC_SIZEALLIDC_NOIDC_HANDIDC_APPSTARTINGIDC_HELPSetSystemCursorPICONINFOICONINFOLoadIconALoadIconWLookupIconIdFromDirectoryLookupIconIdFromDirectoryExCreateIconFromResourceCreateIconFromResourceEx//10524IMAGE_CURSORIMAGE_ENHMETAFILELR_DEFAULTCOLORLR_MONOCHROMELR_COLORLR_COPYRETURNORGLR_COPYDELETEORGLR_LOADTRANSPARENTLR_VGACOLORLR_LOADMAP3DCOLORSLR_CREATEDIBSECTIONLR_COPYFROMRESOURCELR_SHAREDLoadImageACopyImageCreateIconIndirectCopyIconGetIconInfoIDI_APPLICATION//10781IDI_HANDIDI_QUESTIONIDI_EXCLAMATIONIDI_ASTERISKIDI_WINLOGOIDI_SHIELDIDI_WARNINGIDI_ERRORIDI_INFORMATIONIDOK//10853IDCANCELIDABORTIDRETRYIDIGNOREIDYESIDNOIDCLOSEIDHELPIDTRYAGAINIDCONTINUEIDTIMEOUTES_LEFTES_CENTERES_RIGHTES_MULTILINEES_UPPERCASEES_LOWERCASEES_PASSWORDES_AUTOVSCROLLES_AUTOHSCROLLES_NOHIDESELES_OEMCONVERTES_READONLYES_WANTRETURNES_NUMBEREN_SETFOCUSEN_KILLFOCUSEN_CHANGEEN_UPDATEEN_ERRSPACEEN_MAXTEXTEN_HSCROLLEN_VSCROLLEN_ALIGN_LTR_ECEN_ALIGN_RTL_ECEC_LEFTMARGINEC_RIGHTMARGINEC_USEFONTINFOEMSIS_COMPOSITIONSTRINGEIMES_GETCOMPSTRATONCEEIMES_CANCELCOMPSTRINFOCUSEIMES_COMPLETECOMPSTRKILLFOCUSEM_GETSELEM_SETSELEM_GETRECTEM_SETRECTEM_SETRECTNPEM_SCROLLEM_LINESCROLLEM_SCROLLCARETEM_GETMODIFYEM_SETMODIFYEM_GETLINECOUNTEM_LINEINDEXEM_SETHANDLEEM_GETHANDLEEM_GETTHUMBEM_LINELENGTHEM_REPLACESELEM_GETLINEEM_LIMITTEXTEM_CANUNDOEM_UNDOEM_FMTLINESEM_LINEFROMCHAREM_SETTABSTOPSEM_SETPASSWORDCHAREM_EMPTYUNDOBUFFEREM_GETFIRSTVISIBLELINEEM_SETREADONLYEM_SETWORDBREAKPROCEM_GETWORDBREAKPROCEM_GETPASSWORDCHAREM_SETMARGINSEM_GETMARGINSEM_SETLIMITTEXTEM_GETLIMITTEXTEM_POSFROMCHAREM_CHARFROMPOSEM_SETIMESTATUSEM_GETIMESTATUSWB_LEFTWB_RIGHTWB_ISDELIMITERBN_CLICKEDBN_PAINTBN_HILITEBN_UNHILITEBN_DISABLEBN_DOUBLECLICKEDBN_PUSHEDBN_UNPUSHEDBN_DBLCLKBN_SETFOCUSBN_KILLFOCUSBS_PUSHBUTTONBS_DEFPUSHBUTTONBS_CHECKBOXBS_AUTOCHECKBOXBS_RADIOBUTTONBS_3STATEBS_AUTO3STATEBS_GROUPBOXBS_USERBUTTONBS_AUTORADIOBUTTONBS_PUSHBOXBS_OWNERDRAWBS_TYPEMASKBS_LEFTTEXTBS_TEXTBS_ICONBS_BITMAPBS_LEFTBS_RIGHTBS_CENTERBS_TOPBS_BOTTOMBS_VCENTERBS_PUSHLIKEBS_MULTILINEBS_NOTIFYBS_FLATBS_RIGHTBUTTONBM_GETCHECKBM_SETCHECKBM_GETSTATEBM_SETSTATEBM_SETSTYLEBM_CLICKBM_GETIMAGEBM_SETIMAGEBM_SETDONTCLICKBST_UNCHECKEDBST_CHECKEDBST_INDETERMINATEBST_PUSHEDBST_FOCUSSS_LEFTSS_CENTERSS_RIGHTSS_ICONSS_BLACKRECTSS_GRAYRECTSS_WHITERECTSS_BLACKFRAMESS_GRAYFRAMESS_WHITEFRAMESS_USERITEMSS_SIMPLESS_LEFTNOWORDWRAPSS_OWNERDRAWSS_BITMAPSS_ENHMETAFILESS_ETCHEDHORZSS_ETCHEDVERTSS_ETCHEDFRAMESS_TYPEMASKSS_REALSIZECONTROLSS_NOPREFIXSS_NOTIFYSS_CENTERIMAGESS_RIGHTJUSTSS_REALSIZEIMAGESS_SUNKENSS_EDITCONTROLSS_ENDELLIPSISSS_PATHELLIPSISSS_WORDELLIPSISSS_ELLIPSISMASKSTM_SETICONSTM_GETICONSTM_SETIMAGESTM_GETIMAGESTN_CLICKEDSTN_DBLCLKSTN_ENABLESTN_DISABLESTM_MSGMAXIsDialogMessageAIsDialogMessageWMapDialogRectDlgDirListADlgDirListWDlgDirSelectExADlgDirSelectExWDlgDirListComboBoxADlgDirListComboBoxWDlgDirSelectComboBoxExADlgDirSelectComboBoxExWDS_ABSALIGNDS_SYSMODALDS_LOCALEDITDS_SETFONTDS_MODALFRAMEDS_NOIDLEMSGDS_SETFOREGROUNDDS_3DLOOKDS_FIXEDSYSDS_NOFAILCREATEDS_CONTROLDS_CENTERDS_CENTERMOUSEDS_CONTEXTHELPDS_SHELLFONTDS_USEPIXELSDM_GETDEFIDDM_SETDEFIDDM_REPOSITIONDC_HASDEFIDDLGC_WANTARROWSDLGC_WANTTABDLGC_WANTALLKEYSDLGC_WANTMESSAGEDLGC_HASSETSELDLGC_DEFPUSHBUTTONDLGC_UNDEFPUSHBUTTONDLGC_RADIOBUTTONDLGC_WANTCHARSDLGC_STATICDLGC_BUTTONLB_OKAYLB_ERRLB_ERRSPACELBN_ERRSPACELBN_SELCHANGELBN_DBLCLKLBN_SELCANCELLBN_SETFOCUSLBN_KILLFOCUSLB_ADDSTRINGLB_INSERTSTRINGLB_DELETESTRINGLB_SELITEMRANGEEXLB_RESETCONTENTLB_SETSELLB_SETCURSELLB_GETSELLB_GETCURSELLB_GETTEXTLB_GETTEXTLENLB_GETCOUNTLB_SELECTSTRINGLB_DIRLB_GETTOPINDEXLB_FINDSTRINGLB_GETSELCOUNTLB_GETSELITEMSLB_SETTABSTOPSLB_GETHORIZONTALEXTENTLB_SETHORIZONTALEXTENTLB_SETCOLUMNWIDTHLB_ADDFILELB_SETTOPINDEXLB_GETITEMRECTLB_GETITEMDATALB_SETITEMDATALB_SELITEMRANGELB_SETANCHORINDEXLB_GETANCHORINDEXLB_SETCARETINDEXLB_GETCARETINDEXLB_SETITEMHEIGHTLB_GETITEMHEIGHTLB_FINDSTRINGEXACTLB_SETLOCALELB_GETLOCALELB_SETCOUNTLB_INITSTORAGELB_ITEMFROMPOINTLB_MULTIPLEADDSTRINGLB_GETLISTBOXINFOLB_MSGMAXLBS_NOTIFYLBS_SORTLBS_NOREDRAWLBS_MULTIPLESELLBS_OWNERDRAWFIXEDLBS_OWNERDRAWVARIABLELBS_HASSTRINGSLBS_USETABSTOPSLBS_NOINTEGRALHEIGHTLBS_MULTICOLUMNLBS_WANTKEYBOARDINPUTLBS_EXTENDEDSELLBS_DISABLENOSCROLLLBS_NODATALBS_NOSELLBS_COMBOBOXLBS_STANDARDCB_OKAYCB_ERRCB_ERRSPACECBN_ERRSPACECBN_SELCHANGECBN_DBLCLKCBN_SETFOCUSCBN_KILLFOCUSCBN_EDITCHANGECBN_EDITUPDATECBN_DROPDOWNCBN_CLOSEUPCBN_SELENDOKCBN_SELENDCANCELCBS_SIMPLECBS_DROPDOWNCBS_DROPDOWNLISTCBS_OWNERDRAWFIXEDCBS_OWNERDRAWVARIABLECBS_AUTOHSCROLLCBS_OEMCONVERTCBS_SORTCBS_HASSTRINGSCBS_NOINTEGRALHEIGHTCBS_DISABLENOSCROLLCBS_UPPERCASECBS_LOWERCASECB_GETEDITSEL//11571CB_LIMITTEXTCB_SETEDITSELCB_ADDSTRINGCB_DIRCB_GETCOUNTCB_GETCURSELCB_GETLBTEXTCB_GETLBTEXTLENCB_INSERTSTRINGCB_RESETCONTENTCB_FINDSTRINGCB_SELECTSTRINGCB_SETCURSELCB_SHOWDROPDOWNCB_GETITEMDATACB_SETITEMDATACB_GETDROPPEDCONTROLRECTCB_SETITEMHEIGHTCB_GETITEMHEIGHTCB_SETEXTENDEDUICB_GETEXTENDEDUICB_GETDROPPEDSTATECB_FINDSTRINGEXACTCB_SETLOCALECB_GETLOCALECB_GETTOPINDEXCB_SETTOPINDEXCB_GETHORIZONTALEXTENTCB_SETHORIZONTALEXTENTCB_GETDROPPEDWIDTHCB_SETDROPPEDWIDTHCB_INITSTORAGECB_MULTIPLEADDSTRINGCB_GETCOMBOBOXINFOCB_MSGMAXSBS_HORZSBS_VERTSBS_TOPALIGNSBS_LEFTALIGNSBS_BOTTOMALIGNSBS_RIGHTALIGNSBS_SIZEBOXTOPLEFTALIGNSBS_SIZEBOXBOTTOMRIGHTALIGNSBS_SIZEBOXSBS_SIZEGRIPSBM_SETPOSSBM_GETPOSSBM_SETRANGESBM_SETRANGEREDRAWSBM_GETRANGESBM_ENABLE_ARROWSSBM_SETSCROLLINFOSBM_GETSCROLLINFOSBM_GETSCROLLBARINFOSIF_RANGESIF_PAGESIF_POSSIF_DISABLENOSCROLLSIF_TRACKPOSSIF_ALLSCROLLINFOLPCSCROLLINFOSetScrollInfoGetScrollInfoMDITILE_VERTICALMDITILE_HORIZONTALMDITILE_SKIPDISABLEDMDITILE_ZORDERDefFrameProcADefFrameProcWDefMDIChildProcADefMDIChildProcWArrangeIconicWindowsCreateMDIWindowACreateMDIWindowWCascadeWindowsWinHelpAWinHelpWSPI_GETBEEP//12083SPI_SETBEEPSPI_GETMOUSESPI_SETMOUSESPI_GETBORDERSPI_SETBORDERSPI_GETKEYBOARDSPEEDSPI_SETKEYBOARDSPEEDSPI_LANGDRIVERSPI_ICONHORIZONTALSPACINGSPI_GETSCREENSAVETIMEOUTSPI_SETSCREENSAVETIMEOUTSPI_GETSCREENSAVEACTIVESPI_SETSCREENSAVEACTIVESPI_GETGRIDGRANULARITYSPI_SETGRIDGRANULARITYSPI_SETDESKPATTERNSPI_GETKEYBOARDDELAYSPI_SETKEYBOARDDELAYSPI_ICONVERTICALSPACINGSPI_GETICONTITLEWRAPSPI_SETICONTITLEWRAPSPI_GETMENUDROPALIGNMENTSPI_SETMENUDROPALIGNMENTSPI_SETDOUBLECLKWIDTHSPI_SETDOUBLECLKHEIGHTSPI_GETICONTITLELOGFONTSPI_SETDOUBLECLICKTIMESPI_SETMOUSEBUTTONSWAPSPI_SETICONTITLELOGFONTSPI_GETFASTTASKSWITCHSPI_SETFASTTASKSWITCHSPI_SETDRAGFULLWINDOWSSPI_GETDRAGFULLWINDOWSSPI_GETNONCLIENTMETRICSSPI_SETNONCLIENTMETRICSSPI_GETMINIMIZEDMETRICSSPI_SETMINIMIZEDMETRICSSPI_GETICONMETRICSSPI_SETICONMETRICSSPI_SETWORKAREASPI_GETWORKAREASPI_SETPENWINDOWSSPI_SETHIGHCONTRASTSPI_GETKEYBOARDPREFSPI_SETKEYBOARDPREFSPI_GETSCREENREADERSPI_SETSCREENREADERSPI_GETANIMATIONSPI_SETANIMATIONSPI_GETFONTSMOOTHINGSPI_SETFONTSMOOTHINGSPI_SETDRAGWIDTHSPI_SETDRAGHEIGHTSPI_SETHANDHELDSPI_GETLOWPOWERTIMEOUTSPI_GETPOWEROFFTIMEOUTSPI_SETLOWPOWERTIMEOUTSPI_SETPOWEROFFTIMEOUTSPI_GETLOWPOWERACTIVESPI_GETPOWEROFFACTIVESPI_SETLOWPOWERACTIVESPI_SETPOWEROFFACTIVESPI_SETCURSORSSPI_SETICONSSPI_GETDEFAULTINPUTLANGSPI_SETDEFAULTINPUTLANGSPI_SETLANGTOGGLESPI_GETWINDOWSEXTENSIONSPI_SETMOUSETRAILSSPI_GETMOUSETRAILSSPI_SETSCREENSAVERRUNNINGSPI_SCREENSAVERRUNNINGSPI_GETFILTERKEYSSPI_SETFILTERKEYSSPI_GETTOGGLEKEYSSPI_SETTOGGLEKEYSSPI_GETMOUSEKEYSSPI_SETMOUSEKEYSSPI_GETSHOWSOUNDSSPI_SETSHOWSOUNDSSPI_GETSTICKYKEYSSPI_SETSTICKYKEYSSPI_GETACCESSTIMEOUTSPI_SETACCESSTIMEOUTSPI_GETSERIALKEYSSPI_SETSERIALKEYSSPI_GETSOUNDSENTRYSPI_SETSOUNDSENTRYSPI_GETSNAPTODEFBUTTONSPI_SETSNAPTODEFBUTTONSPI_GETMOUSEHOVERWIDTHSPI_SETMOUSEHOVERWIDTHSPI_GETMOUSEHOVERHEIGHTSPI_SETMOUSEHOVERHEIGHTSPI_GETMOUSEHOVERTIMESPI_SETMOUSEHOVERTIMESPI_GETWHEELSCROLLLINESSPI_SETWHEELSCROLLLINESSPI_GETMENUSHOWDELAYSPI_SETMENUSHOWDELAYSPI_GETWHEELSCROLLCHARSSPI_SETWHEELSCROLLCHARSSPI_GETSHOWIMEUISPI_SETSHOWIMEUISPI_GETMOUSESPEEDSPI_SETMOUSESPEEDSPI_GETSCREENSAVERRUNNINGSPI_GETAUDIODESCRIPTIONSPI_SETAUDIODESCRIPTIONSPI_GETSCREENSAVESECURESPI_SETSCREENSAVESECURESPI_GETHUNGAPPTIMEOUTSPI_SETHUNGAPPTIMEOUTSPI_GETWAITTOKILLTIMEOUTSPI_SETWAITTOKILLTIMEOUTSPI_GETWAITTOKILLSERVICETIMEOUTSPI_SETWAITTOKILLSERVICETIMEOUTSPI_GETMOUSEDOCKTHRESHOLDSPI_SETMOUSEDOCKTHRESHOLDSPI_GETPENDOCKTHRESHOLDSPI_SETPENDOCKTHRESHOLDSPI_GETWINARRANGINGSPI_SETWINARRANGINGSPI_GETMOUSEDRAGOUTTHRESHOLDSPI_SETMOUSEDRAGOUTTHRESHOLDSPI_GETPENDRAGOUTTHRESHOLDSPI_SETPENDRAGOUTTHRESHOLDSPI_GETMOUSESIDEMOVETHRESHOLDSPI_SETMOUSESIDEMOVETHRESHOLDSPI_GETPENSIDEMOVETHRESHOLDSPI_SETPENSIDEMOVETHRESHOLDSPI_GETDRAGFROMMAXIMIZESPI_SETDRAGFROMMAXIMIZESPI_GETSNAPSIZINGSPI_SETSNAPSIZINGSPI_GETDOCKMOVINGSPI_SETDOCKMOVINGSPI_GETACTIVEWINDOWTRACKINGSPI_SETACTIVEWINDOWTRACKINGSPI_GETMENUANIMATIONSPI_SETMENUANIMATIONSPI_GETCOMBOBOXANIMATIONSPI_SETCOMBOBOXANIMATIONSPI_GETLISTBOXSMOOTHSCROLLINGSPI_SETLISTBOXSMOOTHSCROLLINGSPI_GETGRADIENTCAPTIONSSPI_SETGRADIENTCAPTIONSSPI_GETKEYBOARDCUESSPI_SETKEYBOARDCUESSPI_GETMENUUNDERLINESSPI_SETMENUUNDERLINESSPI_GETACTIVEWNDTRKZORDERSPI_SETACTIVEWNDTRKZORDERSPI_GETHOTTRACKINGSPI_SETHOTTRACKINGSPI_GETMENUFADESPI_SETMENUFADESPI_GETSELECTIONFADESPI_SETSELECTIONFADESPI_GETTOOLTIPANIMATIONSPI_SETTOOLTIPANIMATIONSPI_GETTOOLTIPFADESPI_SETTOOLTIPFADESPI_GETCURSORSHADOWSPI_SETCURSORSHADOWSPI_GETMOUSESONARSPI_SETMOUSESONARSPI_GETMOUSECLICKLOCKSPI_SETMOUSECLICKLOCKSPI_GETMOUSEVANISHSPI_SETMOUSEVANISHSPI_GETFLATMENUSPI_SETFLATMENUSPI_GETDROPSHADOWSPI_SETDROPSHADOWSPI_GETBLOCKSENDINPUTRESETSSPI_SETBLOCKSENDINPUTRESETSSPI_GETUIEFFECTSSPI_SETUIEFFECTSSPI_GETDISABLEOVERLAPPEDCONTENTSPI_SETDISABLEOVERLAPPEDCONTENTSPI_GETCLIENTAREAANIMATIONSPI_SETCLIENTAREAANIMATIONSPI_GETCLEARTYPESPI_SETCLEARTYPESPI_GETSPEECHRECOGNITIONSPI_SETSPEECHRECOGNITIONSPI_GETFOREGROUNDLOCKTIMEOUTSPI_SETFOREGROUNDLOCKTIMEOUTSPI_GETACTIVEWNDTRKTIMEOUTSPI_SETACTIVEWNDTRKTIMEOUTSPI_GETFOREGROUNDFLASHCOUNTSPI_SETFOREGROUNDFLASHCOUNTSPI_GETCARETWIDTHSPI_SETCARETWIDTHSPI_GETMOUSECLICKLOCKTIMESPI_SETMOUSECLICKLOCKTIMESPI_GETFONTSMOOTHINGTYPESPI_SETFONTSMOOTHINGTYPEFE_FONTSMOOTHINGSTANDARDFE_FONTSMOOTHINGCLEARTYPESPI_GETFONTSMOOTHINGCONTRASTSPI_SETFONTSMOOTHINGCONTRASTSPI_GETFOCUSBORDERWIDTHSPI_SETFOCUSBORDERWIDTHSPI_GETFOCUSBORDERHEIGHTSPI_SETFOCUSBORDERHEIGHTSPI_GETFONTSMOOTHINGORIENTATIONSPI_SETFONTSMOOTHINGORIENTATIONFE_FONTSMOOTHINGORIENTATIONBGRFE_FONTSMOOTHINGORIENTATIONRGBSPI_GETMINIMUMHITRADIUSSPI_SETMINIMUMHITRADIUSSPI_GETMESSAGEDURATIONSPI_SETMESSAGEDURATIONSPIF_UPDATEINIFILE//12472SPIF_SENDWININICHANGESPIF_SENDCHANGE//12484LPNONCLIENTMETRICSANONCLIENTMETRICSALPNONCLIENTMETRICSWNONCLIENTMETRICSW//12598LPANIMATIONINFOANIMATIONINFO//12638LPHIGHCONTRASTALPHIGHCONTRASTWHIGHCONTRASTWHCF_HIGHCONTRASTONHCF_AVAILABLEHCF_HOTKEYACTIVEHCF_CONFIRMHOTKEYHCF_HOTKEYSOUNDHCF_INDICATORHCF_HOTKEYAVAILABLEHCF_LOGONDESKTOPHCF_DEFAULTDESKTOPCDS_UPDATEREGISTRYCDS_TESTCDS_FULLSCREENCDS_GLOBALCDS_SET_PRIMARYCDS_VIDEOPARAMETERSCDS_ENABLE_UNSAFE_MODESCDS_DISABLE_UNSAFE_MODESCDS_RESETCDS_RESET_EXCDS_NORESETDISP_CHANGE_SUCCESSFULDISP_CHANGE_RESTARTDISP_CHANGE_FAILEDDISP_CHANGE_BADMODEDISP_CHANGE_NOTUPDATEDDISP_CHANGE_BADFLAGSDISP_CHANGE_BADPARAMDISP_CHANGE_BADDUALVIEWChangeDisplaySettingsAChangeDisplaySettingsWChangeDisplaySettingsExAChangeDisplaySettingsExWENUM_CURRENT_SETTINGSENUM_REGISTRY_SETTINGSEnumDisplaySettingsAEnumDisplaySettingsWEnumDisplaySettingsExAEnumDisplaySettingsExWEDS_RAWMODEEDS_ROTATEDMODEEnumDisplayDevicesAEnumDisplayDevicesWEDD_GET_DEVICE_INTERFACE_NAMESystemParametersInfoForDpiSetLastErrorExInternalGetWindowTextEndTaskCancelShutdownMONITOR_DEFAULTTONULLMONITOR_DEFAULTTOPRIMARYMonitorFromPointMonitorFromRectMONITORINFOF_PRIMARYLPMONITORINFOMONITORINFOLPMONITORINFOEXAMONITORINFOEXALPMONITORINFOEXWGetMonitorInfoAGetMonitorInfoWEnumDisplayMonitorsMONITORENUMPROCNotifyWinEventSetWinEventHookWINEVENTPROCIsWinEventHookInstalledWINEVENT_OUTOFCONTEXTWINEVENT_SKIPOWNTHREADWINEVENT_SKIPOWNPROCESSWINEVENT_INCONTEXTUnhookWinEventCHILDID_SELFINDEXID_OBJECTINDEXID_CONTAINEROBJID_WINDOWOBJID_SYSMENUOBJID_TITLEBAROBJID_CLIENTOBJID_VSCROLLOBJID_HSCROLLOBJID_SIZEGRIPOBJID_CARETOBJID_CURSOROBJID_ALERTOBJID_SOUNDOBJID_QUERYCLASSNAMEIDXOBJID_NATIVEOMEVENT_MINEVENT_MAXEVENT_SYSTEM_SOUNDEVENT_SYSTEM_ALERTEVENT_SYSTEM_FOREGROUNDEVENT_SYSTEM_MENUSTARTEVENT_SYSTEM_MENUENDEVENT_SYSTEM_MENUPOPUPSTARTEVENT_SYSTEM_MENUPOPUPENDEVENT_SYSTEM_CAPTURESTARTEVENT_SYSTEM_CAPTUREENDEVENT_SYSTEM_MOVESIZESTARTEVENT_SYSTEM_MOVESIZEENDEVENT_SYSTEM_CONTEXTHELPSTARTEVENT_SYSTEM_CONTEXTHELPENDEVENT_SYSTEM_DRAGDROPSTARTEVENT_SYSTEM_DRAGDROPENDEVENT_SYSTEM_DIALOGSTARTEVENT_SYSTEM_DIALOGENDEVENT_SYSTEM_SCROLLINGSTARTEVENT_SYSTEM_SCROLLINGENDEVENT_SYSTEM_SWITCHSTARTEVENT_SYSTEM_SWITCHENDEVENT_SYSTEM_MINIMIZESTARTEVENT_SYSTEM_MINIMIZEENDEVENT_SYSTEM_DESKTOPSWITCHEVENT_SYSTEM_SWITCHER_APPGRABBEDEVENT_SYSTEM_SWITCHER_APPOVERTARGETEVENT_SYSTEM_SWITCHER_APPDROPPEDEVENT_SYSTEM_SWITCHER_CANCELLEDEVENT_SYSTEM_IME_KEY_NOTIFICATIONEVENT_SYSTEM_ENDEVENT_OEM_DEFINED_STARTEVENT_OEM_DEFINED_ENDEVENT_UIA_EVENTID_STARTEVENT_UIA_EVENTID_ENDEVENT_UIA_PROPID_STARTEVENT_UIA_PROPID_ENDEVENT_CONSOLE_CARETEVENT_CONSOLE_UPDATE_REGIONEVENT_CONSOLE_UPDATE_SIMPLEEVENT_CONSOLE_UPDATE_SCROLLEVENT_CONSOLE_LAYOUTEVENT_CONSOLE_START_APPLICATIONEVENT_CONSOLE_END_APPLICATIONCONSOLE_APPLICATION_16BITCONSOLE_CARET_SELECTIONCONSOLE_CARET_VISIBLEEVENT_CONSOLE_ENDEVENT_OBJECT_CREATEEVENT_OBJECT_DESTROYEVENT_OBJECT_SHOWEVENT_OBJECT_HIDEEVENT_OBJECT_REORDEREVENT_OBJECT_FOCUSEVENT_OBJECT_SELECTIONEVENT_OBJECT_SELECTIONADDEVENT_OBJECT_SELECTIONREMOVEEVENT_OBJECT_SELECTIONWITHINEVENT_OBJECT_STATECHANGEEVENT_OBJECT_LOCATIONCHANGEEVENT_OBJECT_NAMECHANGEEVENT_OBJECT_DESCRIPTIONCHANGEEVENT_OBJECT_VALUECHANGEEVENT_OBJECT_PARENTCHANGEEVENT_OBJECT_HELPCHANGEEVENT_OBJECT_DEFACTIONCHANGEEVENT_OBJECT_ACCELERATORCHANGEEVENT_OBJECT_INVOKEDEVENT_OBJECT_TEXTSELECTIONCHANGEDEVENT_OBJECT_CONTENTSCROLLEDEVENT_SYSTEM_ARRANGMENTPREVIEWEVENT_OBJECT_CLOAKEDEVENT_OBJECT_UNCLOAKEDEVENT_OBJECT_LIVEREGIONCHANGEDEVENT_OBJECT_HOSTEDOBJECTSINVALIDATEDEVENT_OBJECT_DRAGSTARTEVENT_OBJECT_DRAGCANCELEVENT_OBJECT_DRAGCOMPLETEEVENT_OBJECT_DRAGENTEREVENT_OBJECT_DRAGLEAVEEVENT_OBJECT_DRAGDROPPEDEVENT_OBJECT_IME_SHOWEVENT_OBJECT_IME_HIDEEVENT_OBJECT_IME_CHANGEEVENT_OBJECT_TEXTEDIT_CONVERSIONTARGETCHANGEDEVENT_OBJECT_ENDEVENT_AIA_STARTEVENT_AIA_ENDALERT_SYSTEM_INFORMATIONALALERT_SYSTEM_WARNINGALERT_SYSTEM_ERRORALERT_SYSTEM_QUERYALERT_SYSTEM_CRITICALCALERT_SYSTEMPGUITHREADINFOGUITHREADINFOLPGUITHREADINFOGUI_CARETBLINKINGGUI_INMOVESIZEGUI_INMENUMODEGUI_SYSTEMMENUMODEGUI_POPUPMENUMODEGUI_16BITTASKGetGUIThreadInfoBlockInputUSER_DEFAULT_SCREEN_DPISetThreadDpiAwarenessContextGetThreadDpiAwarenessContextGetWindowDpiAwarenessContextGetAwarenessFromDpiAwarenessContextGetDpiFromDpiAwarenessContextAreDpiAwarenessContextsEqualIsValidDpiAwarenessContextGetDpiForSystemGetSystemDpiForProcessSetThreadDpiHostingBehaviorGetThreadDpiHostingBehaviorGetWindowDpiHostingBehaviorGetWindowModuleFileNameAGetWindowModuleFileNameWSTATE_SYSTEM_UNAVAILABLESTATE_SYSTEM_SELECTEDSTATE_SYSTEM_FOCUSEDSTATE_SYSTEM_PRESSEDSTATE_SYSTEM_CHECKEDSTATE_SYSTEM_MIXEDSTATE_SYSTEM_INDETERMINATESTATE_SYSTEM_READONLYSTATE_SYSTEM_HOTTRACKEDSTATE_SYSTEM_DEFAULTSTATE_SYSTEM_EXPANDEDSTATE_SYSTEM_COLLAPSEDSTATE_SYSTEM_BUSYSTATE_SYSTEM_FLOATINGSTATE_SYSTEM_MARQUEEDSTATE_SYSTEM_ANIMATEDSTATE_SYSTEM_INVISIBLESTATE_SYSTEM_OFFSCREENSTATE_SYSTEM_SIZEABLESTATE_SYSTEM_MOVEABLESTATE_SYSTEM_SELFVOICINGSTATE_SYSTEM_FOCUSABLESTATE_SYSTEM_SELECTABLESTATE_SYSTEM_LINKEDSTATE_SYSTEM_TRAVERSEDSTATE_SYSTEM_MULTISELECTABLESTATE_SYSTEM_EXTSELECTABLESTATE_SYSTEM_ALERT_LOWSTATE_SYSTEM_ALERT_MEDIUMSTATE_SYSTEM_ALERT_HIGHSTATE_SYSTEM_PROTECTEDSTATE_SYSTEM_VALIDCCHILDREN_TITLEBARCCHILDREN_SCROLLBARPCURSORINFOCURSORINFOLPCURSORINFOCURSOR_SHOWINGCURSOR_SUPPRESSEDGetCursorInfoPWINDOWINFOWINDOWINFOLPWINDOWINFOWS_ACTIVECAPTIONGetWindowInfoPTITLEBARINFOTITLEBARINFOLPTITLEBARINFOGetTitleBarInfoPTITLEBARINFOEXTITLEBARINFOEXLPTITLEBARINFOEXPMENUBARINFOLPMENUBARINFOPSCROLLBARINFOSCROLLBARINFOLPSCROLLBARINFOGetScrollBarInfoPCOMBOBOXINFOCOMBOBOXINFOLPCOMBOBOXINFOGetComboBoxInfoGA_PARENTGA_ROOTGA_ROOTOWNERGetAncestorRealChildWindowFromPointRealGetWindowClassARealGetWindowClassWPALTTABINFOALTTABINFOLPALTTABINFOGetAltTabInfoAGetAltTabInfoWGetListBoxInfoLockWorkStationUserHandleGrantAccessGET_RAWINPUT_CODE_WPARAMRIM_INPUTRIM_INPUTSINKPRAWINPUTHEADERRAWINPUTHEADERLPRAWINPUTHEADERRIM_TYPEMOUSERIM_TYPEKEYBOARDRIM_TYPEHIDPRAWMOUSERAWMOUSELPRAWMOUSERI_MOUSE_LEFT_BUTTON_DOWNRI_MOUSE_LEFT_BUTTON_UPRI_MOUSE_RIGHT_BUTTON_DOWNRI_MOUSE_RIGHT_BUTTON_UPRI_MOUSE_MIDDLE_BUTTON_DOWNRI_MOUSE_MIDDLE_BUTTON_UPRI_MOUSE_BUTTON_1_DOWNRI_MOUSE_BUTTON_1_UPRI_MOUSE_BUTTON_2_DOWNRI_MOUSE_BUTTON_2_UPRI_MOUSE_BUTTON_3_DOWNRI_MOUSE_BUTTON_3_UPRI_MOUSE_BUTTON_4_DOWNRI_MOUSE_BUTTON_4_UPRI_MOUSE_BUTTON_5_DOWNRI_MOUSE_BUTTON_5_UPRI_MOUSE_WHEELMOUSE_MOVE_RELATIVEMOUSE_MOVE_ABSOLUTEMOUSE_VIRTUAL_DESKTOPMOUSE_ATTRIBUTES_CHANGEDMOUSE_MOVE_NOCOALESCEPRAWKEYBOARDRAWKEYBOARDLPRAWKEYBOARDKEYBOARD_OVERRUN_MAKE_CODERI_KEY_MAKERI_KEY_BREAKRI_KEY_E0RI_KEY_E1RI_KEY_TERMSRV_SET_LEDRI_KEY_TERMSRV_SHADOWPRAWHIDRAWHIDLPRAWHIDPRAWINPUTLPRAWINPUTRID_INPUTRID_HEADERGetRawInputDataRIDI_PREPARSEDDATARIDI_DEVICENAMERIDI_DEVICEINFOPRID_DEVICE_INFO_MOUSEPRID_DEVICE_INFO_KEYBOARDPRID_DEVICE_INFO_HIDPRID_DEVICE_INFOLPRID_DEVICE_INFOGetRawInputDeviceInfoAGetRawInputDeviceInfoWGetRawInputBufferPRAWINPUTDEVICELPRAWINPUTDEVICEPCRAWINPUTDEVICERIDEV_REMOVERIDEV_EXCLUDERIDEV_PAGEONLYRIDEV_NOLEGACYRIDEV_INPUTSINKRIDEV_CAPTUREMOUSERIDEV_NOHOTKEYSRIDEV_APPKEYSRIDEV_EXINPUTSINKRIDEV_DEVNOTIFYRIDEV_EXMODEMASKGIDC_ARRIVALGIDC_REMOVALRegisterRawInputDevicesGetRegisteredRawInputDevicesPRAWINPUTDEVICELISTGetRawInputDeviceListDefRawInputProcChangeWindowMessageFilter//15165ChangeWindowMessageFilterExPCHANGEFILTERSTRUCTCHANGEFILTERSTRUCTNID_INTEGRATED_TOUCH//15427NID_EXTERNAL_TOUCHNID_INTEGRATED_PENNID_EXTERNAL_PENNID_MULTI_INPUTNID_READYMAX_STR_BLOCKREASONShutdownBlockReasonCreateShutdownBlockReasonQueryShutdownBlockReasonDestroyIsImmersiveProcess//! USER procedure declarations, constant definitions and macros// ExitWindows// CreateWindowA// CreateWindowW// CreateDialogA// CreateDialogW// CreateDialogIndirectA// CreateDialogIndirectW// DialogBoxA// DialogBoxW// DialogBoxIndirectA// DialogBoxIndirectW// AnsiToOem// OemToAnsi// AnsiToOemBuff// OemToAnsiBuff// AnsiUpper// AnsiUpperBuff// AnsiLower// AnsiLowerBuff// AnsiNext// AnsiPrev// EnumTaskWindows// GetNextWindow// GetSysModalWindow// SetSysModalWindow//10269//10449//10592//11194//11265//11776//12016//13191//15615GetFileVersionInfoSizeAGetFileVersionInfoSizeWGetFileVersionInfoAGetFileVersionInfoWVerQueryValueAVerQueryValueWVerLanguageNameAVerLanguageNameW//! Version management functions, types, and definitionsWLAN_API_VERSION_1_0WLAN_API_VERSION_2_0WLAN_API_VERSION_MAJORWLAN_API_VERSION_MINORWLAN_API_MAKE_VERSIONWLAN_API_VERSIONWLAN_MAX_NAME_LENGTHWLAN_PROFILE_GROUP_POLICYWLAN_PROFILE_USERWLAN_PROFILE_GET_PLAINTEXT_KEYWLAN_PROFILE_CONNECTION_MODE_SET_BY_CLIENTWLAN_PROFILE_CONNECTION_MODE_AUTOWLAN_SET_EAPHOST_DATA_ALL_USERSPWLAN_PROFILE_INFOWLAN_PROFILE_INFOPDOT11_NETWORKDOT11_NETWORKDOT11_PSD_IE_MAX_DATA_SIZEDOT11_PSD_IE_MAX_ENTRY_NUMBERPWLAN_RAW_DATAWLAN_RAW_DATAPWLAN_RAW_DATA_LISTWLAN_RAW_DATA_LISTPWLAN_CONNECTION_MODEWLAN_CONNECTION_MODEWLAN_REASON_CODEPWLAN_REASON_CODEWLAN_REASON_CODE_SUCCESSWLAN_REASON_CODE_UNKNOWNWLAN_REASON_CODE_RANGE_SIZEWLAN_REASON_CODE_BASEWLAN_REASON_CODE_AC_BASEWLAN_REASON_CODE_AC_CONNECT_BASEWLAN_REASON_CODE_AC_ENDWLAN_REASON_CODE_PROFILE_BASEWLAN_REASON_CODE_PROFILE_CONNECT_BASEWLAN_REASON_CODE_PROFILE_ENDWLAN_REASON_CODE_MSM_BASEWLAN_REASON_CODE_MSM_CONNECT_BASEWLAN_REASON_CODE_MSM_ENDWLAN_REASON_CODE_MSMSEC_BASEWLAN_REASON_CODE_MSMSEC_CONNECT_BASEWLAN_REASON_CODE_MSMSEC_ENDWLAN_REASON_CODE_NETWORK_NOT_COMPATIBLEWLAN_REASON_CODE_PROFILE_NOT_COMPATIBLEWLAN_REASON_CODE_NO_AUTO_CONNECTIONWLAN_REASON_CODE_NOT_VISIBLEWLAN_REASON_CODE_GP_DENIEDWLAN_REASON_CODE_USER_DENIEDWLAN_REASON_CODE_BSS_TYPE_NOT_ALLOWEDWLAN_REASON_CODE_IN_FAILED_LISTWLAN_REASON_CODE_IN_BLOCKED_LISTWLAN_REASON_CODE_SSID_LIST_TOO_LONGWLAN_REASON_CODE_CONNECT_CALL_FAILWLAN_REASON_CODE_SCAN_CALL_FAILWLAN_REASON_CODE_NETWORK_NOT_AVAILABLEWLAN_REASON_CODE_PROFILE_CHANGED_OR_DELETEDWLAN_REASON_CODE_KEY_MISMATCHWLAN_REASON_CODE_USER_NOT_RESPONDWLAN_REASON_CODE_AP_PROFILE_NOT_ALLOWED_FOR_CLIENTWLAN_REASON_CODE_AP_PROFILE_NOT_ALLOWEDWLAN_REASON_CODE_HOTSPOT2_PROFILE_DENIEDWLAN_REASON_CODE_INVALID_PROFILE_SCHEMAWLAN_REASON_CODE_PROFILE_MISSINGWLAN_REASON_CODE_INVALID_PROFILE_NAMEWLAN_REASON_CODE_INVALID_PROFILE_TYPEWLAN_REASON_CODE_INVALID_PHY_TYPEWLAN_REASON_CODE_MSM_SECURITY_MISSINGWLAN_REASON_CODE_IHV_SECURITY_NOT_SUPPORTEDWLAN_REASON_CODE_IHV_OUI_MISMATCHWLAN_REASON_CODE_IHV_OUI_MISSINGWLAN_REASON_CODE_IHV_SETTINGS_MISSINGWLAN_REASON_CODE_CONFLICT_SECURITYWLAN_REASON_CODE_SECURITY_MISSINGWLAN_REASON_CODE_INVALID_BSS_TYPEWLAN_REASON_CODE_INVALID_ADHOC_CONNECTION_MODEWLAN_REASON_CODE_NON_BROADCAST_SET_FOR_ADHOCWLAN_REASON_CODE_AUTO_SWITCH_SET_FOR_ADHOCWLAN_REASON_CODE_AUTO_SWITCH_SET_FOR_MANUAL_CONNECTIONWLAN_REASON_CODE_IHV_SECURITY_ONEX_MISSINGWLAN_REASON_CODE_PROFILE_SSID_INVALIDWLAN_REASON_CODE_TOO_MANY_SSIDWLAN_REASON_CODE_IHV_CONNECTIVITY_NOT_SUPPORTEDWLAN_REASON_CODE_BAD_MAX_NUMBER_OF_CLIENTS_FOR_APWLAN_REASON_CODE_INVALID_CHANNELWLAN_REASON_CODE_OPERATION_MODE_NOT_SUPPORTEDWLAN_REASON_CODE_AUTO_AP_PROFILE_NOT_ALLOWEDWLAN_REASON_CODE_AUTO_CONNECTION_NOT_ALLOWEDWLAN_REASON_CODE_HOTSPOT2_PROFILE_NOT_ALLOWEDWLAN_REASON_CODE_UNSUPPORTED_SECURITY_SET_BY_OSWLAN_REASON_CODE_UNSUPPORTED_SECURITY_SETWLAN_REASON_CODE_BSS_TYPE_UNMATCHWLAN_REASON_CODE_PHY_TYPE_UNMATCHWLAN_REASON_CODE_DATARATE_UNMATCHWLAN_REASON_CODE_USER_CANCELLEDWLAN_REASON_CODE_ASSOCIATION_FAILUREWLAN_REASON_CODE_ASSOCIATION_TIMEOUTWLAN_REASON_CODE_PRE_SECURITY_FAILUREWLAN_REASON_CODE_START_SECURITY_FAILUREWLAN_REASON_CODE_SECURITY_FAILUREWLAN_REASON_CODE_SECURITY_TIMEOUTWLAN_REASON_CODE_ROAMING_FAILUREWLAN_REASON_CODE_ROAMING_SECURITY_FAILUREWLAN_REASON_CODE_ADHOC_SECURITY_FAILUREWLAN_REASON_CODE_DRIVER_DISCONNECTEDWLAN_REASON_CODE_DRIVER_OPERATION_FAILUREWLAN_REASON_CODE_IHV_NOT_AVAILABLEWLAN_REASON_CODE_IHV_NOT_RESPONDINGWLAN_REASON_CODE_DISCONNECT_TIMEOUTWLAN_REASON_CODE_INTERNAL_FAILUREWLAN_REASON_CODE_UI_REQUEST_TIMEOUTWLAN_REASON_CODE_TOO_MANY_SECURITY_ATTEMPTSWLAN_REASON_CODE_AP_STARTING_FAILUREWLAN_REASON_CODE_MSMSEC_MINWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_KEY_INDEXWLAN_REASON_CODE_MSMSEC_PROFILE_PSK_PRESENTWLAN_REASON_CODE_MSMSEC_PROFILE_KEY_LENGTHWLAN_REASON_CODE_MSMSEC_PROFILE_PSK_LENGTHWLAN_REASON_CODE_MSMSEC_PROFILE_NO_AUTH_CIPHER_SPECIFIEDWLAN_REASON_CODE_MSMSEC_PROFILE_TOO_MANY_AUTH_CIPHER_SPECIFIEDWLAN_REASON_CODE_MSMSEC_PROFILE_DUPLICATE_AUTH_CIPHERWLAN_REASON_CODE_MSMSEC_PROFILE_RAWDATA_INVALIDWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_AUTH_CIPHERWLAN_REASON_CODE_MSMSEC_PROFILE_ONEX_DISABLEDWLAN_REASON_CODE_MSMSEC_PROFILE_ONEX_ENABLEDWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_PMKCACHE_MODEWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_PMKCACHE_SIZEWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_PMKCACHE_TTLWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_PREAUTH_MODEWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_PREAUTH_THROTTLEWLAN_REASON_CODE_MSMSEC_PROFILE_PREAUTH_ONLY_ENABLEDWLAN_REASON_CODE_MSMSEC_CAPABILITY_NETWORKWLAN_REASON_CODE_MSMSEC_CAPABILITY_NICWLAN_REASON_CODE_MSMSEC_CAPABILITY_PROFILEWLAN_REASON_CODE_MSMSEC_CAPABILITY_DISCOVERYWLAN_REASON_CODE_MSMSEC_PROFILE_PASSPHRASE_CHARWLAN_REASON_CODE_MSMSEC_PROFILE_KEYMATERIAL_CHARWLAN_REASON_CODE_MSMSEC_PROFILE_WRONG_KEYTYPEWLAN_REASON_CODE_MSMSEC_MIXED_CELLWLAN_REASON_CODE_MSMSEC_PROFILE_AUTH_TIMERS_INVALIDWLAN_REASON_CODE_MSMSEC_PROFILE_INVALID_GKEY_INTVWLAN_REASON_CODE_MSMSEC_TRANSITION_NETWORKWLAN_REASON_CODE_MSMSEC_PROFILE_KEY_UNMAPPED_CHARWLAN_REASON_CODE_MSMSEC_CAPABILITY_PROFILE_AUTHWLAN_REASON_CODE_MSMSEC_CAPABILITY_PROFILE_CIPHERWLAN_REASON_CODE_MSMSEC_PROFILE_SAFE_MODEWLAN_REASON_CODE_MSMSEC_CAPABILITY_PROFILE_SAFE_MODE_NICWLAN_REASON_CODE_MSMSEC_CAPABILITY_PROFILE_SAFE_MODE_NWWLAN_REASON_CODE_MSMSEC_PROFILE_UNSUPPORTED_AUTHWLAN_REASON_CODE_MSMSEC_PROFILE_UNSUPPORTED_CIPHERWLAN_REASON_CODE_MSMSEC_CAPABILITY_MFP_NW_NICWLAN_REASON_CODE_MSMSEC_UI_REQUEST_FAILUREWLAN_REASON_CODE_MSMSEC_AUTH_START_TIMEOUTWLAN_REASON_CODE_MSMSEC_AUTH_SUCCESS_TIMEOUTWLAN_REASON_CODE_MSMSEC_KEY_START_TIMEOUTWLAN_REASON_CODE_MSMSEC_KEY_SUCCESS_TIMEOUTWLAN_REASON_CODE_MSMSEC_M3_MISSING_KEY_DATAWLAN_REASON_CODE_MSMSEC_M3_MISSING_IEWLAN_REASON_CODE_MSMSEC_M3_MISSING_GRP_KEYWLAN_REASON_CODE_MSMSEC_PR_IE_MATCHINGWLAN_REASON_CODE_MSMSEC_SEC_IE_MATCHINGWLAN_REASON_CODE_MSMSEC_NO_PAIRWISE_KEYWLAN_REASON_CODE_MSMSEC_G1_MISSING_KEY_DATAWLAN_REASON_CODE_MSMSEC_G1_MISSING_GRP_KEYWLAN_REASON_CODE_MSMSEC_PEER_INDICATED_INSECUREWLAN_REASON_CODE_MSMSEC_NO_AUTHENTICATORWLAN_REASON_CODE_MSMSEC_NIC_FAILUREWLAN_REASON_CODE_MSMSEC_CANCELLEDWLAN_REASON_CODE_MSMSEC_KEY_FORMATWLAN_REASON_CODE_MSMSEC_DOWNGRADE_DETECTEDWLAN_REASON_CODE_MSMSEC_PSK_MISMATCH_SUSPECTEDWLAN_REASON_CODE_MSMSEC_FORCED_FAILUREWLAN_REASON_CODE_MSMSEC_M3_TOO_MANY_RSNIEWLAN_REASON_CODE_MSMSEC_M2_MISSING_KEY_DATAWLAN_REASON_CODE_MSMSEC_M2_MISSING_IEWLAN_REASON_CODE_MSMSEC_AUTH_WCN_COMPLETEDWLAN_REASON_CODE_MSMSEC_M3_MISSING_MGMT_GRP_KEYWLAN_REASON_CODE_MSMSEC_G1_MISSING_MGMT_GRP_KEYWLAN_REASON_CODE_MSMSEC_MAXWLAN_SIGNAL_QUALITYPWLAN_SIGNAL_QUALITYWLAN_AVAILABLE_NETWORK_CONNECTEDWLAN_AVAILABLE_NETWORK_HAS_PROFILEWLAN_AVAILABLE_NETWORK_CONSOLE_USER_PROFILEWLAN_AVAILABLE_NETWORK_INTERWORKING_SUPPORTEDWLAN_AVAILABLE_NETWORK_HOTSPOT2_ENABLEDWLAN_AVAILABLE_NETWORK_ANQP_SUPPORTEDWLAN_AVAILABLE_NETWORK_HOTSPOT2_DOMAINWLAN_AVAILABLE_NETWORK_HOTSPOT2_ROAMINGWLAN_AVAILABLE_NETWORK_AUTO_CONNECT_FAILEDWLAN_AVAILABLE_NETWORK_INCLUDE_ALL_ADHOC_PROFILESWLAN_AVAILABLE_NETWORK_INCLUDE_ALL_MANUAL_HIDDEN_PROFILESPWLAN_RATE_SETWLAN_RATE_SETWLAN_MAX_PHY_TYPE_NUMBERPWLAN_AVAILABLE_NETWORKWLAN_AVAILABLE_NETWORKPWLAN_AVAILABLE_NETWORK_V2WLAN_AVAILABLE_NETWORK_V2PWLAN_BSS_ENTRYWLAN_BSS_ENTRYPWLAN_BSS_LISTWLAN_BSS_LISTPWLAN_INTERFACE_STATEWLAN_INTERFACE_STATEPWLAN_ADHOC_NETWORK_STATEWLAN_ADHOC_NETWORK_STATEPWLAN_INTERFACE_INFOWLAN_INTERFACE_INFOPWLAN_ASSOCIATION_ATTRIBUTESWLAN_ASSOCIATION_ATTRIBUTESPWLAN_SECURITY_ATTRIBUTESWLAN_SECURITY_ATTRIBUTESPWLAN_CONNECTION_ATTRIBUTESWLAN_CONNECTION_ATTRIBUTESPDOT11_RADIO_STATEDOT11_RADIO_STATEWLAN_MAX_PHY_INDEXPWLAN_PHY_RADIO_STATEWLAN_PHY_RADIO_STATEPWLAN_RADIO_STATEWLAN_RADIO_STATEPWLAN_OPERATIONAL_STATEWLAN_OPERATIONAL_STATEPWLAN_INTERFACE_TYPEWLAN_INTERFACE_TYPEPWLAN_INTERFACE_CAPABILITYWLAN_INTERFACE_CAPABILITYPWLAN_AUTH_CIPHER_PAIR_LISTWLAN_AUTH_CIPHER_PAIR_LISTPWLAN_COUNTRY_OR_REGION_STRING_LISTWLAN_COUNTRY_OR_REGION_STRING_LISTPWLAN_PROFILE_INFO_LISTWLAN_PROFILE_INFO_LISTPWLAN_AVAILABLE_NETWORK_LISTWLAN_AVAILABLE_NETWORK_LISTPWLAN_AVAILABLE_NETWORK_LIST_V2WLAN_AVAILABLE_NETWORK_LIST_V2PWLAN_INTERFACE_INFO_LISTWLAN_INTERFACE_INFO_LISTPDOT11_NETWORK_LISTDOT11_NETWORK_LISTPWLAN_POWER_SETTINGWLAN_POWER_SETTINGWLAN_CONNECTION_HIDDEN_NETWORKWLAN_CONNECTION_ADHOC_JOIN_ONLYWLAN_CONNECTION_IGNORE_PRIVACY_BITWLAN_CONNECTION_EAPOL_PASSTHROUGHWLAN_CONNECTION_PERSIST_DISCOVERY_PROFILEWLAN_CONNECTION_PERSIST_DISCOVERY_PROFILE_CONNECTION_MODE_AUTOWLAN_CONNECTION_PERSIST_DISCOVERY_PROFILE_OVERWRITE_EXISTINGPWLAN_CONNECTION_PARAMETERSWLAN_CONNECTION_PARAMETERSPWLAN_CONNECTION_PARAMETERS_V2WLAN_CONNECTION_PARAMETERS_V2PWLAN_MSM_NOTIFICATION_DATAWLAN_MSM_NOTIFICATION_DATAWLAN_CONNECTION_NOTIFICATION_ADHOC_NETWORK_FORMEDWLAN_CONNECTION_NOTIFICATION_CONSOLE_USER_PROFILEPWLAN_CONNECTION_NOTIFICATION_DATAWLAN_CONNECTION_NOTIFICATION_DATAWLAN_NOTIFICATION_SOURCE_NONEWLAN_NOTIFICATION_SOURCE_ALLWLAN_NOTIFICATION_SOURCE_ACMWLAN_NOTIFICATION_SOURCE_MSMWLAN_NOTIFICATION_SOURCE_SECURITYWLAN_NOTIFICATION_SOURCE_IHVWLAN_NOTIFICATION_SOURCE_HNWKWLAN_NOTIFICATION_SOURCE_ONEXPWLAN_NOTIFICATION_ACMWLAN_NOTIFICATION_ACMPWLAN_NOTIFICATION_MSMWLAN_NOTIFICATION_MSMPWLAN_NOTIFICATION_SECURITYWLAN_NOTIFICATION_SECURITYWLAN_NOTIFICATION_DATAPWLAN_NOTIFICATION_DATAPWLAN_OPCODE_VALUE_TYPEWLAN_OPCODE_VALUE_TYPEPWLAN_INTF_OPCODEWLAN_INTF_OPCODEPWLAN_AUTOCONF_OPCODEWLAN_AUTOCONF_OPCODEPWLAN_IHV_CONTROL_TYPEWLAN_IHV_CONTROL_TYPEPWLAN_FILTER_LIST_TYPEWLAN_FILTER_LIST_TYPEPWLAN_PHY_FRAME_STATISTICSWLAN_PHY_FRAME_STATISTICSPWLAN_MAC_FRAME_STATISTICSWLAN_MAC_FRAME_STATISTICSPWLAN_STATISTICSWLAN_STATISTICSWLAN_READ_ACCESSWLAN_EXECUTE_ACCESSWLAN_WRITE_ACCESSPWLAN_SECURABLE_OBJECTWLAN_SECURABLE_OBJECTPWLAN_DEVICE_SERVICE_GUID_LISTWLAN_DEVICE_SERVICE_GUID_LISTWFD_API_VERSION_1_0WFD_API_VERSIONPWFD_ROLE_TYPEWFD_ROLE_TYPEPWFD_GROUP_IDWFD_GROUP_IDWlanOpenHandleWlanCloseHandleWlanEnumInterfacesWlanSetAutoConfigParameterWlanQueryAutoConfigParameterWlanGetInterfaceCapabilityWlanSetInterfaceWlanQueryInterfaceWlanIhvControlWlanScanWlanGetAvailableNetworkListWlanGetAvailableNetworkList2WlanGetNetworkBssListWlanConnectWlanConnect2WlanDisconnectWlanRegisterNotificationWLAN_NOTIFICATION_CALLBACKWlanGetProfileWlanSetProfileEapUserDataWlanSetProfileEapXmlUserDataWlanSetProfileWlanDeleteProfileWlanRenameProfileWlanGetProfileListWlanSetProfileListWlanSetProfilePositionWlanSetProfileCustomUserDataWlanGetProfileCustomUserDataWlanSetFilterListWlanGetFilterListWlanSetPsdIEDataListWlanSaveTemporaryProfileWlanDeviceServiceCommandWlanGetSupportedDeviceServicesWlanExtractPsdIEDataListWlanReasonCodeToStringWlanAllocateMemoryWlanFreeMemoryWlanSetSecuritySettingsWlanGetSecuritySettingsWLAN_UI_API_VERSIONWLAN_UI_API_INITIAL_VERSIONPWL_DISPLAY_PAGESWL_DISPLAY_PAGESWlanUIEditProfilePWLAN_HOSTED_NETWORK_STATEWLAN_HOSTED_NETWORK_STATEPWLAN_HOSTED_NETWORK_REASONWLAN_HOSTED_NETWORK_REASONPWLAN_HOSTED_NETWORK_PEER_AUTH_STATEWLAN_HOSTED_NETWORK_PEER_AUTH_STATEWlanHostedNetworkStartUsingWlanHostedNetworkStopUsingWlanHostedNetworkForceStartWlanHostedNetworkForceStopPWLAN_HOSTED_NETWORK_PEER_STATEWLAN_HOSTED_NETWORK_PEER_STATEPWLAN_HOSTED_NETWORK_RADIO_STATEWLAN_HOSTED_NETWORK_RADIO_STATEPWLAN_HOSTED_NETWORK_NOTIFICATION_CODEWLAN_HOSTED_NETWORK_NOTIFICATION_CODEPWLAN_HOSTED_NETWORK_STATE_CHANGEWLAN_HOSTED_NETWORK_STATE_CHANGEPWLAN_HOSTED_NETWORK_DATA_PEER_STATE_CHANGEWLAN_HOSTED_NETWORK_DATA_PEER_STATE_CHANGEPWLAN_HOSTED_NETWORK_OPCODEWLAN_HOSTED_NETWORK_OPCODEPWLAN_HOSTED_NETWORK_CONNECTION_SETTINGSWLAN_HOSTED_NETWORK_CONNECTION_SETTINGSPWLAN_HOSTED_NETWORK_SECURITY_SETTINGSWLAN_HOSTED_NETWORK_SECURITY_SETTINGSWlanHostedNetworkQueryPropertyWlanHostedNetworkSetPropertyWlanHostedNetworkInitSettingsWlanHostedNetworkRefreshSecuritySettingsPWLAN_HOSTED_NETWORK_STATUSWLAN_HOSTED_NETWORK_STATUSWlanHostedNetworkQueryStatusWlanHostedNetworkSetSecondaryKeyWlanHostedNetworkQuerySecondaryKeyWlanRegisterVirtualStationNotificationWFDOpenHandleWFDCloseHandleWFDStartOpenSessionWFD_OPEN_SESSION_COMPLETE_CALLBACKWFDCancelOpenSessionWFDOpenLegacySessionWFDCloseSessionWFDUpdateDeviceVisibility//! Definitions and data structures for wlan auto config client side API.MS_MAX_PROFILE_NAME_LENGTHPDOT11EXT_IHV_PROFILE_PARAMSPDOT11_ADAPTERPDOT11_BSS_LISTPDOT11_PORT_STATEPDOT11EXT_APISDOT11EXT_APISPDOT11EXT_IHV_HANDLERSDOT11EXT_IHV_HANDLERSPDOT11EXT_VIRTUAL_STATION_APISDOT11EXT_VIRTUAL_STATION_APISPDOT11_IHV_VERSION_INFODOT11_IHV_VERSION_INFOPDOT11EXT_IHV_CONNECTION_PHASEDOT11EXT_IHV_CONNECTION_PHASEPDOT11EXT_IHV_UI_REQUESTDOT11EXT_IHV_UI_REQUESTPDOT11_MSONEX_RESULTDOT11_MSONEX_RESULTPDOT11_EAP_RESULTDOT11_EAP_RESULTPDOT11_MSONEX_RESULT_PARAMSDOT11_MSONEX_RESULT_PARAMSPDOT11EXT_IHV_CONNECTIVITY_PROFILEDOT11EXT_IHV_CONNECTIVITY_PROFILEPDOT11EXT_IHV_SECURITY_PROFILEDOT11EXT_IHV_SECURITY_PROFILEPDOT11EXT_IHV_DISCOVERY_PROFILEDOT11EXT_IHV_DISCOVERY_PROFILEPDOT11EXT_IHV_DISCOVERY_PROFILE_LISTDOT11EXT_IHV_DISCOVERY_PROFILE_LISTPDOT11EXT_IHV_INDICATION_TYPEDOT11EXT_IHV_INDICATION_TYPEDOT11EXT_PSK_MAX_LENGTHPDOT11EXT_VIRTUAL_STATION_AP_PROPERTYDOT11EXT_VIRTUAL_STATION_AP_PROPERTYWDIAG_IHV_WLAN_ID_FLAG_SECURITY_ENABLEDPWDIAG_IHV_WLAN_IDWDIAG_IHV_WLAN_IDIHV_VERSION_FUNCTION_NAMEIHV_INIT_FUNCTION_NAMEIHV_INIT_VS_FUNCTION_NAME//! Definition of public APIs for WLAN Extensibility Framework.PDOT11_MSSECURITY_SETTINGSDOT11_MSSECURITY_SETTINGSPDOT11EXT_IHV_SSID_LISTDOT11EXT_IHV_SSID_LISTDOT11EXT_IHV_PROFILE_PARAMSMS_PROFILE_GROUP_POLICYMS_PROFILE_USERPDOT11EXT_IHV_PARAMSDOT11EXT_IHV_PARAMS//! Structures used to hold information for IHV.DOT11_ADAPTERDOT11_BSS_LISTDOT11_PORT_STATEPDOT11_SECURITY_PACKET_HEADERDOT11_SECURITY_PACKET_HEADERWow64DisableWow64FsRedirectionWow64RevertWow64FsRedirectionIsWow64ProcessGetSystemWow64DirectoryAGetSystemWow64DirectoryWIsWow64Process2BT_PORT_ANYBT_PORT_MINBT_PORT_MAXBT_PORT_DYN_FIRSTPH_BTHPSOCKADDR_BTHSOCKADDR_BTHBTH_ADDR_STRING_SIZEBTHPROTO_RFCOMMBTHPROTO_L2CAPSOL_RFCOMMSOL_L2CAPSOL_SDPSO_BTH_AUTHENTICATESO_BTH_ENCRYPTSO_BTH_MTUSO_BTH_MTU_MAXSO_BTH_MTU_MINRFCOMM_MAX_MTURFCOMM_MIN_MTUBTH_SDP_VERSIONPBTH_SET_SERVICEBTH_SET_SERVICESDP_DEFAULT_INQUIRY_SECONDSSDP_MAX_INQUIRY_SECONDSSDP_DEFAULT_INQUIRY_MAX_RESPONSESSDP_SERVICE_SEARCH_REQUESTSDP_SERVICE_ATTRIBUTE_REQUESTSDP_SERVICE_SEARCH_ATTRIBUTE_REQUESTPBTH_QUERY_DEVICEBTH_QUERY_DEVICEPBTH_QUERY_SERVICEBTH_QUERY_SERVICEBTHNS_RESULT_DEVICE_CONNECTEDBTHNS_RESULT_DEVICE_REMEMBEREDBTHNS_RESULT_DEVICE_AUTHENTICATEDSIO_RFCOMM_SEND_COMMANDSIO_RFCOMM_WAIT_COMMANDSIO_BTH_PINGSIO_BTH_INFOSIO_RFCOMM_SESSION_FLOW_OFFSIO_RFCOMM_TESTSIO_RFCOMM_USECFCBITPRFCOMM_MSC_DATARFCOMM_MSC_DATAMSC_EA_BITMSC_FC_BITMSC_RTC_BITMSC_RTR_BITMSC_RESERVEDMSC_IC_BITMSC_DV_BITMSC_BREAK_BITMSC_SET_BREAK_LENGTHPRFCOMM_RLS_DATARFCOMM_RLS_DATARLS_ERRORRLS_OVERRUNRLS_PARITYRLS_FRAMINGPRFCOMM_RPN_DATARFCOMM_RPN_DATARPN_BAUD_2400RPN_BAUD_4800RPN_BAUD_7200RPN_BAUD_9600RPN_BAUD_19200RPN_BAUD_38400RPN_BAUD_57600RPN_BAUD_115200RPN_BAUD_230400RPN_DATA_5RPN_DATA_6RPN_DATA_7RPN_DATA_8RPN_STOP_1RPN_STOP_1_5RPN_PARITY_NONERPN_PARITY_ODDRPN_PARITY_EVENRPN_PARITY_MARKRPN_PARITY_SPACERPN_FLOW_X_INRPN_FLOW_X_OUTRPN_FLOW_RTR_INRPN_FLOW_RTR_OUTRPN_FLOW_RTC_INRPN_FLOW_RTC_OUTRPN_PARAM_BAUDRPN_PARAM_DATARPN_PARAM_STOPRPN_PARAM_PARITYRPN_PARAM_P_TYPERPN_PARAM_XONRPN_PARAM_XOFFRPN_PARAM_X_INRPN_PARAM_X_OUTRPN_PARAM_RTR_INRPN_PARAM_RTR_OUTRPN_PARAM_RTC_INRPN_PARAM_RTC_OUTRFCOMM_CMD_NONERFCOMM_CMD_MSCRFCOMM_CMD_RLSRFCOMM_CMD_RPNRFCOMM_CMD_RPN_REQUESTRFCOMM_CMD_RPN_RESPONSEPRFCOMM_COMMANDRFCOMM_COMMANDPBTH_PING_REQBTH_PING_REQPBTH_PING_RSPBTH_PING_RSPPBTH_INFO_REQBTH_INFO_REQPBTH_INFO_RSPBTH_INFO_RSPBTHNS_SETBLOBPBTHNS_SETBLOBBTHNS_INQUIRYBLOBPBTHNS_INQUIRYBLOBBTHNS_RESTRICTIONBLOBPBTHNS_RESTRICTIONBLOBWSPDESCRIPTION_LENWSS_OPERATION_IN_PROGRESSLPWSPDATAWSPDATALPWSATHREADIDWSATHREADIDLPWSPPROC_TABLEWSPPROC_TABLELPWSPUPCALLTABLEWSPUPCALLTABLEWSPStartupWSCEnumProtocolsWSCEnumProtocols32WSCDeinstallProviderWSCDeinstallProvider32WSCInstallProviderWSCInstallProvider64_32WSCGetProviderPathWSCGetProviderPath32WSCUpdateProviderWSCUpdateProvider32LSP_SYSTEMLSP_INSPECTORLSP_REDIRECTORLSP_PROXYLSP_FIREWALLLSP_INBOUND_MODIFYLSP_OUTBOUND_MODIFYLSP_CRYPTO_COMPRESSLSP_LOCAL_CACHEWSCSetProviderInfoWSC_PROVIDER_INFO_TYPEWSCGetProviderInfoWSCSetProviderInfo32WSCGetProviderInfo32WSCSetApplicationCategoryWSCGetApplicationCategoryWPUCloseEventWPUCloseSocketHandleWPUCreateEventWPUCreateSocketHandleWPUFDIsSetWPUGetProviderPathWPUModifyIFSHandleWPUPostMessageWPUQueryBlockingCallbackLPBLOCKINGCALLBACKWPUQuerySocketHandleContextWPUQueueApcLPWSAUSERAPCWPUResetEventWPUSetEventWPUCompleteOverlappedRequestWPUOpenCurrentThreadWPUCloseThreadWSCEnumNameSpaceProviders32WSCEnumNameSpaceProvidersEx32WSCInstallNameSpaceWSCInstallNameSpace32WSCUnInstallNameSpaceWSCInstallNameSpaceExWSCInstallNameSpaceEx32WSCUnInstallNameSpace32WSCEnableNSProviderWSCEnableNSProvider32WSCInstallProviderAndChains64_32WSCInstallProviderAndChainsLPNSP_ROUTINENSP_ROUTINENSPStartupPNSPV2_ROUTINENSPV2_ROUTINELPNSPV2_ROUTINEPCNSPV2_ROUTINELPCNSPV2_ROUTINEWSAAdvertiseProviderWSAUnadvertiseProviderWSAProviderCompleteAsyncCall//! Definitions to be used with the WinSock service provider.SOCKET_PEER_TARGET_NAMESOCKET_SECURITY_QUERY_INFOSOCKET_SECURITY_QUERY_TEMPLATESOCKET_SECURITY_SETTINGSUDP_NOCHECKSUMUDP_CHECKSUM_COVERAGEEAI_NOSECURENAMEEAI_IPSECPOLICYADDRINFOLPADDRINFOGetAddrInfoWGetAddrInfoExALPLOOKUPSERVICE_COMPLETION_ROUTINEGetAddrInfoExWGetAddrInfoExCancelGetAddrInfoExOverlappedResultSetAddrInfoExASetAddrInfoExWFreeAddrInfoWFreeAddrInfoExFreeAddrInfoExWGetNameInfoWinet_ptonInetPtonWinet_ntopInetNtopWGAI_STRERROR_BUFFER_SIZEWSASetSocketSecurityWSAQuerySocketSecurityWSASetSocketPeerTargetNameWSADeleteSocketPeerTargetNameWSAImpersonateSocketPeerWSARevertImpersonation//! WinSock2 Extension for TCP/IP protocolsWTSQueryUserToken//1286XINPUT_DEVTYPE_GAMEPADXINPUT_DEVSUBTYPE_GAMEPADXINPUT_DEVSUBTYPE_UNKNOWNXINPUT_DEVSUBTYPE_WHEELXINPUT_DEVSUBTYPE_ARCADE_STICKXINPUT_DEVSUBTYPE_FLIGHT_SICKXINPUT_DEVSUBTYPE_DANCE_PADXINPUT_DEVSUBTYPE_GUITARXINPUT_DEVSUBTYPE_GUITAR_ALTERNATEXINPUT_DEVSUBTYPE_DRUM_KITXINPUT_DEVSUBTYPE_GUITAR_BASSXINPUT_DEVSUBTYPE_ARCADE_PADXINPUT_CAPS_VOICE_SUPPORTEDXINPUT_CAPS_FFB_SUPPORTEDXINPUT_CAPS_WIRELESSXINPUT_CAPS_PMD_SUPPORTEDXINPUT_CAPS_NO_NAVIGATIONXINPUT_GAMEPAD_DPAD_UPXINPUT_GAMEPAD_DPAD_DOWNXINPUT_GAMEPAD_DPAD_LEFTXINPUT_GAMEPAD_DPAD_RIGHTXINPUT_GAMEPAD_STARTXINPUT_GAMEPAD_BACKXINPUT_GAMEPAD_LEFT_THUMBXINPUT_GAMEPAD_RIGHT_THUMBXINPUT_GAMEPAD_LEFT_SHOULDERXINPUT_GAMEPAD_RIGHT_SHOULDERXINPUT_GAMEPAD_AXINPUT_GAMEPAD_BXINPUT_GAMEPAD_XXINPUT_GAMEPAD_YXINPUT_GAMEPAD_LEFT_THUMB_DEADZONEXINPUT_GAMEPAD_RIGHT_THUMB_DEADZONEXINPUT_GAMEPAD_TRIGGER_THRESHOLDXINPUT_FLAG_GAMEPADBATTERY_DEVTYPE_GAMEPADBATTERY_DEVTYPE_HEADSETBATTERY_TYPE_DISCONNECTEDBATTERY_TYPE_WIREDBATTERY_TYPE_ALKALINEBATTERY_TYPE_NIMHBATTERY_TYPE_UNKNOWNBATTERY_LEVEL_EMPTYBATTERY_LEVEL_LOWBATTERY_LEVEL_MEDIUMBATTERY_LEVEL_FULLXUSER_MAX_COUNTXUSER_INDEX_ANYVK_PAD_AVK_PAD_BVK_PAD_XVK_PAD_YVK_PAD_RSHOULDERVK_PAD_LSHOULDERVK_PAD_LTRIGGERVK_PAD_RTRIGGERVK_PAD_DPAD_UPVK_PAD_DPAD_DOWNVK_PAD_DPAD_LEFTVK_PAD_DPAD_RIGHTVK_PAD_STARTVK_PAD_BACKVK_PAD_LTHUMB_PRESSVK_PAD_RTHUMB_PRESSVK_PAD_LTHUMB_UPVK_PAD_LTHUMB_DOWNVK_PAD_LTHUMB_RIGHTVK_PAD_LTHUMB_LEFTVK_PAD_LTHUMB_UPLEFTVK_PAD_LTHUMB_UPRIGHTVK_PAD_LTHUMB_DOWNRIGHTVK_PAD_LTHUMB_DOWNLEFTVK_PAD_RTHUMB_UPVK_PAD_RTHUMB_DOWNVK_PAD_RTHUMB_RIGHTVK_PAD_RTHUMB_LEFTVK_PAD_RTHUMB_UPLEFTVK_PAD_RTHUMB_UPRIGHTVK_PAD_RTHUMB_DOWNRIGHTVK_PAD_RTHUMB_DOWNLEFTXINPUT_KEYSTROKE_KEYDOWNXINPUT_KEYSTROKE_KEYUPXINPUT_KEYSTROKE_REPEATPXINPUT_GAMEPADXINPUT_GAMEPADPXINPUT_STATEXINPUT_STATEPXINPUT_VIBRATIONXINPUT_VIBRATIONPXINPUT_CAPABILITIESXINPUT_CAPABILITIESPXINPUT_BATTERY_INFORMATIONXINPUT_BATTERY_INFORMATIONPXINPUT_KEYSTROKEXINPUT_KEYSTROKEXInputGetStateXInputSetStateXInputGetCapabilitiesXInputEnableXInputGetAudioDeviceIdsXInputGetBatteryInformationXInputGetKeystrokeXInputGetDSoundAudioDeviceGuids//! XInput procedure declarations, constant definitions and macrosEXCEPTION_EXECUTE_HANDLER// While there are functions defined here in `excpt.h`, they are actually intrinsics which have// special black magic in the msvc compiler. Thus bindings cannot be provided for them.EXCEPTION_CONTINUE_SEARCHEXCEPTION_CONTINUE_EXECUTION//! The declarations of the compiler-dependent intrinsics, support functions, and keywords which//! implement the structured exception handling extensions.//! Headers that come with VC. Notably, these are not part of the Windows SDK.//! Declarations used throughout the VCRuntime library.winrtinspectableIInspectableVtbl//! This interface definition contains typedefs for Windows Runtime data types.hstringLPINSPECTABLEroapirobufferroerrorapiwinstringIApartmentShutdownRO_REGISTRATION_COOKIE__RO_REGISTRATION_COOKIERoInitializeRO_INIT_TYPERoUninitializeRoActivateInstanceRoRegisterActivationFactoriesPFNGETACTIVATIONFACTORYRoRevokeActivationFactoriesRoGetActivationFactoryRoRegisterForApartmentShutdownAPARTMENT_SHUTDOWN_REGISTRATION_COOKIERoUnregisterForApartmentShutdownRoGetApartmentIdentifierRoGetBufferMarshalerIRestrictedErrorInfoRoGetErrorReportingFlagsRoSetErrorReportingFlagsRoResolveRestrictedErrorInfoReferenceSetRestrictedErrorInfoGetRestrictedErrorInfoRoOriginateErrorWRoOriginateErrorRoTransformErrorWRoTransformErrorRoCaptureErrorContextRoFailFastWithErrorContextRoOriginateLanguageExceptionRoClearErrorRoReportUnhandledErrorRoInspectThreadErrorInfoPINSPECT_MEMORY_CALLBACKRoInspectCapturedStackBackTraceRoGetMatchingRestrictedErrorInfoRoReportFailedDelegateIsErrorPropagationEnabledHSTRING_BUFFERHSTRING_HEADERWindowsCreateStringWindowsCreateStringReferenceWindowsDeleteStringWindowsDuplicateStringWindowsGetStringLenWindowsGetStringRawBufferWindowsIsStringEmptyWindowsStringHasEmbeddedNullWindowsCompareStringOrdinalWindowsSubstringWindowsSubstringWithSpecifiedLengthWindowsConcatStringWindowsReplaceStringWindowsTrimStringStartWindowsTrimStringEndWindowsPreallocateStringBufferWindowsPromoteStringBufferWindowsDeleteStringBufferWindowsInspectStringPINSPECT_HSTRING_CALLBACKHSTRING_UserSizeHSTRING_UserMarshalHSTRING_UserUnmarshalHSTRING_UserFreeHSTRING_UserSize64HSTRING_UserMarshal64HSTRING_UserUnmarshal64HSTRING_UserFree64ActiveEventLoopnew_events/// This is a useful place to put code that should be done before you start processing/// events, such as updating frame timing information for benchmarking or checking the/// [`StartCause`] to see if a timer set by/// [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil] has elapsed.resumed/// For consistency, all platforms emit a `Resumed` event even if they don't themselves have a/// formal suspend/resume lifecycle. For systems without a formal suspend/resume lifecycle/// the `Resumed` event is always emitted after the/// [`NewEvents(StartCause::Init)`][StartCause::Init] event./// It's recommended that applications should only initialize their graphics context and create/// a window after they have received their first `Resumed` event. Some systems/// (specifically Android) won't allow applications to create a render surface until they are/// resumed./// Considering that the implementation of [`Suspended`] and `Resumed` events may be internally/// driven by multiple platform-specific events, and that there may be subtle differences across/// platforms with how these internal events are delivered, it's recommended that applications/// be able to gracefully handle redundant (i.e. back-to-back) [`Suspended`] or `Resumed`/// Also see [`Suspended`] notes./// ## Android/// On Android, the `Resumed` event is sent when a new [`SurfaceView`] has been created. This is/// expected to closely correlate with the [`onResume`] lifecycle event but there may/// technically be a discrepancy./// [`onResume`]: https://developer.android.com/reference/android/app/Activity#onResume()/// Applications that need to run on Android must wait until they have been `Resumed`/// before they will be able to create a render surface (such as an `EGLSurface`,/// [`VkSurfaceKHR`] or [`wgpu::Surface`]) which depend on having a/// [`SurfaceView`]. Applications must also assume that if they are [`Suspended`], then their/// render surfaces are invalid and should be dropped./// [`SurfaceView`]: https://developer.android.com/reference/android/view/SurfaceView/// [Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle/// [`VkSurfaceKHR`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html/// [`wgpu::Surface`]: https://docs.rs/wgpu/latest/wgpu/struct.Surface.html/// On iOS, the `Resumed` event is emitted in response to an [`applicationDidBecomeActive`]/// callback which means the application is "active" (according to the/// [iOS application lifecycle])./// [`applicationDidBecomeActive`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622956-applicationdidbecomeactive/// [iOS application lifecycle]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle/// ## Web/// On Web, the `Resumed` event is emitted in response to a [`pageshow`] event/// with the property [`persisted`] being true, which means that the page is being/// restored from the [`bfcache`] (back/forward cache) - an in-memory cache that/// stores a complete snapshot of a page (including the JavaScript heap) as the/// user is navigating away./// [`pageshow`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pageshow_event/// [`persisted`]: https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent/persisted/// [`bfcache`]: https://web.dev/bfcache//// [`Suspended`]: Self::suspendeduser_event/// Emitted when an event is sent from [`EventLoopProxy::send_event`]./// [`EventLoopProxy::send_event`]: crate::event_loop::EventLoopProxy::send_eventwindow_event/// Emitted when the OS sends an event to a winit window.device_eventabout_to_wait/// Emitted when the event loop is about to block and wait for new events./// Most applications shouldn't need to hook into this event since there is no real relationship/// between how often the event loop needs to wake up and the dispatching of any specific/// High frequency event sources, such as input devices could potentially lead to lots of wake/// ups and also lots of corresponding `AboutToWait` events./// This is not an ideal event to drive application rendering from and instead applications/// should render in response to [`WindowEvent::RedrawRequested`] events./// Not all platforms support the notion of suspending applications, and there may be no/// technical way to guarantee being able to emit a `Suspended` event if the OS has/// no formal application lifecycle (currently only Android, iOS, and Web do). For this reason,/// Winit does not currently try to emit pseudo `Suspended` events before the application/// quits on platforms without an application lifecycle./// Considering that the implementation of `Suspended` and [`Resumed`] events may be internally/// be able to gracefully handle redundant (i.e. back-to-back) `Suspended` or [`Resumed`]/// Also see [`Resumed`] notes./// On Android, the `Suspended` event is only sent when the application's associated/// [`SurfaceView`] is destroyed. This is expected to closely correlate with the [`onPause`]/// lifecycle event but there may technically be a discrepancy./// [`onPause`]: https://developer.android.com/reference/android/app/Activity#onPause()/// Applications that need to run on Android should assume their [`SurfaceView`] has been/// destroyed, which indirectly invalidates any existing render surfaces that may have been/// created outside of Winit (such as an `EGLSurface`, [`VkSurfaceKHR`] or [`wgpu::Surface`])./// After being `Suspended` on Android applications must drop all render surfaces before/// the event callback completes, which may be re-created when the application is next/// [`Resumed`]./// On iOS, the `Suspended` event is currently emitted in response to an/// [`applicationWillResignActive`] callback which means that the application is/// about to transition from the active to inactive state (according to the/// [`applicationWillResignActive`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622950-applicationwillresignactive/// On Web, the `Suspended` event is emitted in response to a [`pagehide`] event/// put in the [`bfcache`] (back/forward cache) - an in-memory cache that stores a/// complete snapshot of a page (including the JavaScript heap) as the user is/// navigating away./// [`pagehide`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event/// [`Resumed`]: Self::resumedexiting/// This is irreversible - if this method is called, it is guaranteed that the event loop/// will exit right after.memory_warning/// Emitted when the application has received a memory warning./// ### Android/// On Android, the `MemoryWarning` event is sent when [`onLowMemory`] was called. The/// application must [release memory] or risk being killed./// [`onLowMemory`]: https://developer.android.com/reference/android/app/Application.html#onLowMemory()/// [release memory]: https://developer.android.com/topic/performance/memory#release/// ### iOS/// On iOS, the `MemoryWarning` event is emitted in response to an/// [`applicationDidReceiveMemoryWarning`] callback. The application must free as much/// memory as possible or risk being terminated, see [how to respond to memory warnings]./// [`applicationDidReceiveMemoryWarning`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1623063-applicationdidreceivememorywarni/// [how to respond to memory warnings]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle/responding_to_memory_warnings/// ### Others/// - **macOS / Orbital / Wayland / Web / Windows:** Unsupported.ApplicationHandler/// The handler of the application events.//! End user application handling.v0_30v0_29v0_28v0_27v0_26v0_25v0_24v0_23v0_22v0_21v0_20v0_19v0_18v0_17v0_16v0_15v0_14v0_13v0_12v0_11v0_10v0_9v0_8//! # Changelog and migrations//! All notable changes to this project will be documented in this module,//! along with migration instructions for larger changes.// Put the current entry at the top of this page, for discoverability.// See `.cargo/config.toml` for details about `unreleased_changelogs`.PlatformCustomCursorPlatformCustomCursorSourceMAX_CURSOR_SIZE/// The maximum width and height for a cursor when using [`CustomCursor::from_rgba`].CustomCursor/// See [`Window::set_cursor()`][crate::window::Window::set_cursor] for more details./// Platforms should make sure this is cheap to clone./// Use a custom image as a cursor (mouse pointer)./// Is guaranteed to be cheap to clone./// **Web**: Some browsers have limits on cursor sizes usually at 128x128./// # use winit::event_loop::ActiveEventLoop;/// # use winit::window::Window;/// # fn scope(event_loop: &ActiveEventLoop, window: &Window) {/// use winit::window::CustomCursor;/// let w = 10;/// let h = 10;/// let rgba = vec![255; (w * h * 4) as usize];/// #[cfg(not(target_family = "wasm"))]/// let source = CustomCursor::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();/// #[cfg(target_family = "wasm")]/// let source = {///     use winit::platform::web::CustomCursorExtWebSys;///     CustomCursor::from_url(String::from("http://localhost:3000/cursor.png"), 0, 0)/// let custom_cursor = event_loop.create_custom_cursor(source);/// window.set_cursor(custom_cursor.clone());CustomCursorSourceBadImage/// Creates a new cursor from an rgba buffer./// The alpha channel is assumed to be **not** premultiplied./// Source for [`CustomCursor`]./// See [`CustomCursor`] for more details./// Produced when the image dimensions are larger than [`MAX_CURSOR_SIZE`]. This doesn't/// guarantee that the cursor will work, but should avoid many platform and device specific/// limits.HotspotOutOfBounds/// Produced when the hotspot is outside the image bounds/// An error produced when using [`CustomCursor::from_rgba`] with invalid arguments.CursorImageOnlyCursorImageSource/// Platforms export this directly as `PlatformCustomCursorSource` if they need to only work with/// images.OnlyCursorImage/// Platforms export this directly as `PlatformCustomCursor` if they don't implement caching.NoCustomCursor// Platforms that don't support cursors will export this as `PlatformCustomCursor`./// The operation was ignored.// TODO: Rename/// An error that may be generated when requesting Winit stateEventLoopErrorRecreationAttempt/// The event loop can't be re-created.ExitFailure/// Application has exit with an error status./// A general error that may occur while running the Winit event loopensure_fmt_does_not_panic// Eat attributes for testingAsyncRequestSerialModifiersKeyStateModifiersKeysActivationToken/// See [`ApplicationHandler::new_events`] for details./// [`ApplicationHandler::new_events`]: crate::application::ApplicationHandler::new_events/// See [`ApplicationHandler::window_event`] for details./// [`ApplicationHandler::window_event`]: crate::application::ApplicationHandler::window_event/// See [`ApplicationHandler::device_event`] for details./// [`ApplicationHandler::device_event`]: crate::application::ApplicationHandler::device_event/// See [`ApplicationHandler::user_event`] for details./// [`ApplicationHandler::user_event`]: crate::application::ApplicationHandler::user_event/// See [`ApplicationHandler::suspended`] for details./// [`ApplicationHandler::suspended`]: crate::application::ApplicationHandler::suspended/// See [`ApplicationHandler::resumed`] for details./// [`ApplicationHandler::resumed`]: crate::application::ApplicationHandler::resumedAboutToWait/// See [`ApplicationHandler::about_to_wait`] for details./// [`ApplicationHandler::about_to_wait`]: crate::application::ApplicationHandler::about_to_waitLoopExiting/// See [`ApplicationHandler::exiting`] for details./// [`ApplicationHandler::exiting`]: crate::application::ApplicationHandler::exitingMemoryWarning/// See [`ApplicationHandler::memory_warning`] for details./// [`ApplicationHandler::memory_warning`]: crate::application::ApplicationHandler::memory_warning/// Sent if the time specified by [`ControlFlow::WaitUntil`] has been reached. Contains the/// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil/// [`ControlFlow::Poll`]./// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::PollActivationTokenDone/// The activation token was delivered back and now could be used./// Delivered in response to [`request_activation_token`]./// [`request_activation_token`]: crate::platform::startup_notify::WindowExtStartupNotify::request_activation_token/// - **iOS / Android / Web / Wayland:** Unsupported./// If `true`, the event was generated synthetically by winit/// * Synthetic key press events are generated for all keys pressed when a window gains///   focus. Likewise, synthetic key release events are generated for all keys pressed when///   a window goes out of focus. ***Currently, this is only functional on X11 and///   Windows***/// An event from an input method./// **Note:** You have to explicitly enable this event using [`Window::set_ime_allowed`]./// - **iOS / Android / Web / Orbital:** Unsupported./// (x,y) coords in pixels relative to the top-left corner of the window. Because the range/// of this data is limited by the display area and it may have been transformed by/// the OS to implement effects such as cursor acceleration, it should not be used/// to implement non-cursor-like interactions such as 3D camera control./// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`]./// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border/// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding/// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform/// Positive values indicate magnification (zooming in) and  negative/// values indicate shrinking (zooming out)./// This value may be NaN.PinchGesture/// Two-finger pinch gesture, often used for magnification./// - Only available on **macOS** and **iOS**./// - On iOS, not recognized by default. It must be enabled when needed./// Change in pixels of pan gesture from last update.PanGesture/// N-finger pan gesture/// - Only available on **iOS**.DoubleTapGesture/// Double tap gesture./// On a Mac, smart magnification is triggered by a double tap with two fingers/// on the trackpad and is commonly used to zoom on a certain object/// (e.g. a paragraph of a PDF) or (sort of like a toggle) to reset any zoom./// The gesture is also supported in Safari, Pages, etc./// The event is general enough that its generating gesture is allowed to vary/// across platforms. It could also be generated by another device./// Unfortunately, neither [Windows](https://support.microsoft.com/en-us/windows/touch-gestures-for-windows-a9d28305-4818-a5df-4e2b-e5590f850741)/// nor [Wayland](https://wayland.freedesktop.org/libinput/doc/latest/gestures.html)/// support this gesture or any other gesture with the same effect./// - Only available on **macOS 10.8** and later, and **iOS**./// change in rotation in degreesRotationGesture/// Two-finger rotation gesture./// Positive delta values indicate rotation counterclockwise and/// negative delta values indicate rotation clockwise./// The parameters are: pressure level (value between 0 and 1 representing how hard the/// touchpad is being pressed) and stage (integer representing the click level).inner_size_writerInnerSizeWriter/// Handle to update inner size during scale changes./// See [`InnerSizeWriter`] docs for more details./// To update the window size, use the provided [`InnerSizeWriter`] handle. By default, the/// window is resized to the value suggested by the OS, but it can be changed to any value./// For more information about DPI in general, see the [`dpi`] crate./// This only reports a change if the window theme was not overridden by [`Window::set_theme`]./// - **iOS / Android / X11 / Wayland / Orbital:** Unsupported.Occluded/// The window has been occluded (completely hidden from view)./// This is different to window visibility as it depends on whether the window is closed,/// minimised, set invisible, or fully occluded by another window./// On iOS, the `Occluded(false)` event is emitted in response to an/// [`applicationWillEnterForeground`] callback which means the application should start/// preparing its data. The `Occluded(true)` event is emitted in response to an/// [`applicationDidEnterBackground`] callback which means the application should free/// resources (according to the [iOS application lifecycle])./// [`applicationWillEnterForeground`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1623076-applicationwillenterforeground/// [`applicationDidEnterBackground`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622997-applicationdidenterbackground/// - **Android / Wayland / Windows / Orbital:** Unsupported./// Emitted when a window should be redrawn./// - The application has explicitly requested a redraw via [`Window::request_redraw`]./// Winit will aggregate duplicate redraw requests into a single event, to/// help avoid duplicating rendering work./// Describes an event from a [`Window`]./// Whenever you receive an event arising from a particular input device, this event contains a/// `DeviceId` which identifies its origin. Note that devices may be virtual (representing an/// on-screen cursor and keyboard focus) or physical. Virtual devices typically aggregate inputs/// from multiple physical devices./// Returns a dummy id, useful for unit testing./// The only guarantee made about the return value of this function is that/// it will always be equal to itself and to future values returned by this function./// No other guarantees are made. This may be equal to a real `DeviceId`./// This represents raw, unfiltered physical motion. Not to be confused with/// [`WindowEvent::CursorMoved`]./// Motion on some analog axis. This event will be reported for all arbitrary input devices/// that winit supports on this platform, including mouse devices.  If the device is a mouse/// Useful for interactions that diverge significantly from a conventional 2D GUI, such as 3D camera/// or first-person game controls. Many physical actions, such as mouse movement, can produce both/// device and window events. Because window events typically arise from virtual devices/// (corresponding to GUI cursors and keyboard focus) the device IDs may not match.PhysicalKey/// - Certain niche hardware will shuffle around physical key positions, e.g. a keyboard that///   implements DVORAK in hardware (or firmware)/// - Your application will likely have to handle keyboards which are missing keys that your///   own keyboard has./// - Certain `KeyCode`s will move between a couple of different positions depending on what///   layout the keyboard was manufactured to support.///  **Because of these caveats, it is important that you provide users with a way to configure///  most (if not all) keybinds in your application.**/// ## `Fn` and `FnLock`/// `Fn` and `FnLock` key events are *exceedingly unlikely* to be emitted by Winit. These keys/// are usually handled at the hardware or OS level, and aren't surfaced to applications. If/// you somehow see this in the wild, we'd like to know :)// Allowing `broken_intra_doc_links` for `logical_key`, because// `key_without_modifiers` is not available on all platforms/// - Allows handling key-bindings on platforms which don't support [`key_without_modifiers`]./// If you use this field (or [`key_without_modifiers`] for that matter) for keyboard/// shortcuts, **it is important that you provide users with a way to configure your/// application's shortcuts so you don't render your application unusable for users with an/// incompatible keyboard layout.**/// - **Web:** Dead keys might be reported as the real key instead of `Dead` depending on the///   browser/OS./// [`key_without_modifiers`]: crate::platform::modifier_supplement::KeyEventExtModifierSupplement::key_without_modifiers/// `logical_key` is `Key::Named(NamedKey::Enter)`, this field is `Some("\r")`./// Contains the location of this key on the keyboard./// Certain keys on the keyboard may appear in more than once place. For example, the "Shift"/// key appears on the left side of the QWERTY keyboard as well as the right side. However,/// both keys have the same symbolic value. Another example of this phenomenon is the "1"/// key, which appears both above the "Q" key and as the "Keypad 1" key./// This field allows the user to differentiate between keys like this that have the same/// symbolic value but different locations on the keyboard./// See the [`KeyLocation`] type for more details./// [`KeyLocation`]: crate::keyboard::KeyLocation/// Whether the key is being pressed or released./// See the [`ElementState`] type for more details./// Whether or not this key is a key repeat event./// On some systems, holding down a key for some period of time causes that key to be repeated/// as though it were being pressed and released repeatedly. This field is `true` if and only/// if this event is the result of one of those repeats./// In games, you often want to ignore repated key events - this can be/// done by ignoring events where this property is set./// use winit::event::{ElementState, KeyEvent, WindowEvent};/// use winit::keyboard::{KeyCode, PhysicalKey};/// # let window_event = WindowEvent::RedrawRequested; // To make the example compile/// match window_event {///     WindowEvent::KeyboardInput {///         event:///             KeyEvent {///                 physical_key: PhysicalKey::Code(KeyCode::KeyW),///                 state: ElementState::Pressed,///                 repeat: false,///                 ..///         ..///     } => {///         // The physical key `W` was pressed, and it was not a repeat///     _ => {}, // Handle other events/// Platform-specific key event information./// On Windows, Linux and macOS, this type contains the key without modifiers and the text with/// all modifiers applied./// On Android, iOS, Redox and Web, this type is a no-op.pressed_mods// NOTE: Currently pressed modifiers keys.// The field providing a metadata, it shouldn't be used as a source of truth./// Describes keyboard modifiers event./// The state of the modifiers.lshift_state/// The state of the left shift key.rshift_state/// The state of the right shift key.lalt_state/// The state of the left alt key.ralt_state/// The state of the right alt key.lcontrol_state/// The state of the left control key.rcontrol_state/// The state of the right control key.lsuper_state/// The state of the left super key.rsuper_state/// The state of the right super key.mod_state/// Notifies when the IME was enabled./// After getting this event you could receive [`Preedit`][Self::Preedit] and/// [`Commit`][Self::Commit] events. You should also start performing IME related requests/// like [`Window::set_ime_cursor_area`].Preedit/// Notifies when a new composing text should be set at the cursor position./// The value represents a pair of the preedit string and the cursor begin position and end/// position. When it's `None`, the cursor should be hidden. When `String` is an empty string/// this indicates that preedit was cleared./// The cursor position is byte-wise indexed./// Notifies when text should be inserted into the editor widget./// Right before this event winit will send empty [`Self::Preedit`] event./// Notifies when the IME was disabled./// After receiving this event you won't get any more [`Preedit`][Self::Preedit] or/// [`Commit`][Self::Commit] events until the next [`Enabled`][Self::Enabled] event. You should/// also stop issuing IME related requests like [`Window::set_ime_cursor_area`] and clear/// pending preedit text./// Describes [input method](https://en.wikipedia.org/wiki/Input_method) events./// This is also called a "composition event"./// Most keypresses using a latin-like keyboard layout simply generate a/// [`WindowEvent::KeyboardInput`]. However, one couldn't possibly have a key for every single/// unicode character that the user might want to type/// - so the solution operating systems employ is to allow the user to type these using _a sequence///   of keypresses_ instead./// A prominent example of this is accents - many keyboard layouts allow you to first click the/// "accent key", and then the character you want to apply the accent to. In this case, some/// platforms will generate the following event sequence:/// // Press "`" key/// Ime::Preedit("`", Some((0, 0)))/// // Press "E" key/// Ime::Preedit("", None) // Synthetic event generated by winit to clear preedit./// Ime::Commit("é")/// Additionally, certain input devices are configured to display a candidate box that allow the/// user to select the desired character interactively. (To properly position this box, you must use/// [`Window::set_ime_cursor_area`].)/// An example of a keyboard layout which uses candidate boxes is pinyin. On a latin keyboard the/// following event sequence could be obtained:/// // Press "A" key/// Ime::Preedit("a", Some((1, 1)))/// // Press "B" key/// Ime::Preedit("a b", Some((3, 3)))/// // Press left arrow key/// Ime::Preedit("a b", Some((1, 1)))/// // Press space key/// Ime::Preedit("啊b", Some((3, 3)))/// Ime::Commit("啊不")/// - Only available on **iOS** 9.0+, **Windows** 8+, **Web**, and **Android**./// - **Android**: This will never be [None]. If the device doesn't support pressure///   sensitivity, force will either be 0.0 or 1.0. Also see the///   [android documentation](https://developer.android.com/reference/android/view/MotionEvent#AXIS_PRESSURE)./// Every time the user touches the screen, a new [`TouchPhase::Started`] event with an unique/// identifier for the finger is generated. When the finger is lifted, an [`TouchPhase::Ended`]/// After a `Started` event has been emitted, there may be zero or more `Move`/// The finger id may be reused by the system after an `Ended` event. The user/// should assume that a new `Started` event received with the same id has nothing/// A [`TouchPhase::Cancelled`] event is emitted when the system has canceled tracking this/// [`Force::Calibrated`] so that the amount of force the user has to apply isis_pressed/// True if `self == Pressed`./// **macOS:** `Back` and `Forward` might not work with all hardware./// **Orbital:** `Back` and `Forward` are unsupported due to orbital not supporting them./// Positive values indicate that the content that is being scrolled should move/// right and down (revealing more content left and up)./// Scroll events are expressed as a `PixelDelta` if/// Positive values indicate that the content being scrolled should/// move right/down./// For a 'natural scrolling' touch pad (that acts like a touch screen)/// this means moving your fingers right and down should give positive values,/// and move the content right and down (to reveal more things left and up)./// Handle to synchronously change the size of the window from the/// [`WindowEvent`].request_inner_size/// Try to request inner size which will be set synchronously on the window.foreach_eventtest_event_clonetest_map_nonuser_eventtest_force_normalize//! The [`Event`] enum and assorted supporting types.//! These are sent to the closure given to [`EventLoop::run_app(...)`], where they get//! processed and used to modify the program state. For more details, see the root-level//! documentation.//! approximate the basic ordering loop of [`EventLoop::run_app(...)`] like this://! while !elwt.exiting() {//!     app.new_events(event_loop, start_cause);//!     for event in (window events, user events, device events) {//!         // This will pick the right method on the application based on the event.//!         app.handle_event(event_loop, event);//!     for window_id in (redraw windows) {//!         app.window_event(event_loop, window_id, RedrawRequested);//!     app.about_to_wait(event_loop);//!     start_cause = wait_if_necessary();//! app.exiting(event_loop);//! This leaves out timing details like [`ControlFlow::WaitUntil`] but hopefully//! [`EventLoop::run_app(...)`]: crate::event_loop::EventLoop::run_app//! [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil/// An `EventLoop` can be seen more or less as a "context". Calling [`EventLoop::new`]/// initializes everything that will be required to create windows. For example on Linux creating/// an event loop opens a connection to the X or Wayland server./// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs./// Note that this cannot be shared across threads (due to platform-dependant logic/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access,/// the [`Window`] created from this _can_ be sent to an other thread, and the/// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread./// Target that associates windows with an [`EventLoop`]./// This type exists to allow you to create new windows while Winit executes/// your callback./// This can be created using [`EventLoop::new`] or [`EventLoop::with_user_event`].EVENT_LOOP_CREATED"use `EventLoop::builder` instead"/// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,/// and only once per application.***/// Calling this function will result in display backend initialisation./// Attempting to create the event loop off the main thread will panic. This/// restriction isn't strictly necessary on all platforms, but is imposed to/// eliminate any nasty surprises when porting to platforms that require it./// `EventLoopBuilderExt::any_thread` functions are exposed in the relevant/// [`platform`] module if the target platform supports creating an event/// loop on any thread./// - **Wayland/X11:** to prevent running under `Wayland` or `X11` unset `WAYLAND_DISPLAY` or///   `DISPLAY` respectively when building the event loop./// - **Android:** must be configured with an `AndroidApp` from `android_main()` by calling///   [`.with_android_app(app)`] before calling `.build()`, otherwise it'll panic./// [`platform`]: crate::platform/// Useful for implementing efficient timers. Applications which want to render at the/// display's native refresh rate should instead use [`Poll`] and the VSync functionality/// of a graphics API to reduce odds of missed frames./// [`Poll`]: Self::Poll/// Set through [`ActiveEventLoop::set_control_flow()`]./// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted./// Defaults to [`Wait`]./// [`Wait`]: Self::Waitwait_duration/// Creates a [`ControlFlow`] that waits until a timeout has expired./// In most cases, this is set to [`WaitUntil`]. However, if the timeout overflows, it is/// instead set to [`Wait`]./// [`WaitUntil`]: Self::WaitUntil/// Create the event loop./// This is an alias of `EventLoop::builder().build()`./// This returns an [`EventLoopBuilder`], to allow configuring the event loop before creation./// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that."use `EventLoop::run_app` instead"/// See [`run_app`]./// [`run_app`]: Self::run_app/// Run the application with the event loop on the calling thread./// See the [`set_control_flow()`] docs on how to change the event loop's behavior./// - **iOS:** Will never return to the caller and so values not passed to this function will///   *not* be dropped before the process exits./// - **Web:** Will _act_ as if it never returns to the caller by throwing a Javascript///   exception (that Rust doesn't see) that will also mean that the rest of the function is///   never executed and any values not passed to this function will *not* be dropped.///   Web applications are recommended to use///   [^1] instead of [`run_app()`] to avoid the need///   for the Javascript exception trick, and to make it clearer that the event loop runs///   asynchronously (via the browser's own, internal, event loop) and doesn't block the///   current thread of execution like it does on other platforms.///   This function won't be available with `target_feature = "exception-handling"`./// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()/// [`run_app()`]: Self::run_app()/// [^1]: `EventLoopExtWebSys::spawn_app()` is only available on Web./// Creates an [`EventLoopProxy`] that can be used to dispatch user events/// to the main event loop, possibly from another thread.owned_display_handleOwnedDisplayHandle/// Gets a persistent reference to the underlying platform display./// See the [`OwnedDisplayHandle`] type for more information.listen_device_eventsDeviceEvents/// Change if or when [`DeviceEvent`]s are captured./// See [`ActiveEventLoop::listen_device_events`] for details.set_control_flow/// Sets the [`ControlFlow`]."use `ActiveEventLoop::create_window` instead"/// Create a window./// Creating window without event loop running often leads to improper window creation;/// use [`ActiveEventLoop::create_window`] instead.create_custom_cursor/// Create custom cursor./// Get the underlying [EventLoop]'s `fd` which you can register/// into other event loop, like [`calloop`] or [`mio`]. When doing so, the/// loop must be polled with the [`pump_app_events`] API./// [`calloop`]: https://crates.io/crates/calloop/// [`mio`]: https://crates.io/crates/mio/// [`pump_app_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_app_events/// Get the underlying [EventLoop]'s raw `fd` which you can register/// Create the window./// - **Web:** The window is created but not inserted into the web page automatically. Please///   see the web platform module for more information./// **Wayland / Web:** Always returns `None`./// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit/// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing/// this at runtime to explicitly capture them again./// - **Wayland / macOS / iOS / Android / Orbital:** Unsupported.system_theme/// Returns the current system theme./// Returns `None` if it cannot be determined on the current platform./// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported./// Gets the current [`ControlFlow`]./// This exits the event loop./// See [`LoopExiting`][Event::LoopExiting]./// Returns if the [`EventLoop`] is about to stop./// See [`exit()`][Self::exit]./// A proxy for the underlying display handle./// The purpose of this type is to provide a cheaply cloneable handle to the underlying/// display handle. This is often used by graphics APIs to connect to the underlying APIs./// It is difficult to keep a handle to the [`EventLoop`] type or the [`ActiveEventLoop`]/// type. In contrast, this type involves no lifetimes and can be persisted for as long as/// For all platforms, this is one of the following:/// - A zero-sized type that is likely optimized out./// - A reference-counted pointer to the underlying type./// Used to send custom events to [`EventLoop`]./// Send an event to the [`EventLoop`] from which this proxy was created. This emits a/// Returns an `Err` if the associated [`EventLoop`] no longer exists./// [`UserEvent(event)`]: Event::UserEvent/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that/// no longer exists./// Contains the original event given to [`EventLoopProxy::send_event`]./// Report device events regardless of window focus.WhenFocused/// Only capture device events while the window is focused./// Never capture device events./// Control when device events are captured./// A unique identifier of the winit's async request./// This could be used to identify the async request once it's done/// and a specific action must be taken./// One of the handling scenarios could be to maintain a working list/// containing [`AsyncRequestSerial`] and some closure associated with it./// Then once event is arriving the working list is being traversed and a job/// executed and removed from the list.// TODO(kchibisov): Remove `cfg` when the clipboard will be added.dispatch_event_for_app/// Shim for various run APIs.//! The [`EventLoop`] struct and assorted supporting types, including//! [`ControlFlow`].//! If you want to send custom events to the event loop, use//! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its//! [`send_event`][EventLoopProxy::send_event] method./// An Android "scancode"./// A macOS "scancode"./// A Windows "scancode".Xkb/// An XKB "keycode"./// Contains the platform-native physical key identifier/// The exact values vary from platform to platform (which is part of why this is a per-platform/// enum), but the values are primarily tied to the key's physical location on the keyboard./// This enum is primarily used to store raw keycodes when Winit doesn't map a given native/// physical key identifier to a meaningful [`KeyCode`] variant. In the presence of identifiers we/// haven't mapped for you yet, this lets you use use [`KeyCode`] to:/// - Correctly match key press and release events./// - On non-web platforms, support assigning keybinds to virtually any key through a UI.NativeKey/// An Android "keycode", which is similar to a "virtual-key code" on Windows./// A macOS "scancode". There does not appear to be any direct analogue to either keysyms or/// "virtual-key" codes in macOS, so we report the scancode instead./// A Windows "virtual-key code"./// An XKB "keysym"./// A "key value string"./// Contains the platform-native logical key identifier/// Exactly what that means differs from platform to platform, but the values are to some degree/// tied to the currently active keyboard layout. The same key on the same keyboard may also report/// different values on different platforms, which is one of the reasons this is a per-platform/// This enum is primarily used to store raw keysym when Winit doesn't map a given native logical/// key identifier to a meaningful [`Key`] variant. This lets you use [`Key`], and let the user/// define keybinds which work in the presence of identifiers we haven't mapped for you yet.// uses less code than direct match; target is stack allocated/// A known key code/// This variant is used when the key cannot be translated to a [`KeyCode`]/// The native keycode is provided (if available) so you're able to more reliably match/// key-press and key-release events by hashing the [`PhysicalKey`]. It is also possible to use/// this for keybinds for non-standard keys, but such keybinds are tied to a given platform./// This type is a superset of [`KeyCode`], including an [`Unidentified`][Self::Unidentified]/// <kbd> </kbd> (space)/// Japanese: <kbd>カタカナ</kbd>/<kbd>ひらがな</kbd>/<kbd>ローマ字</kbd>/// (katakana/hiragana/romaji)/// <kbd>1 End</kbd> on a keyboard. <kbd>1</kbd> or <kbd>1 QZ</kbd> on a phone or remote/// control// Legacy modifier key. Also called "Super" in certain places.// Legacy modifier key./// Code representing the location of a physical keyNamedKey/// input. This key value is used for the "Windows Logo" key and the Apple `Command` or `⌘`/// The `Enter` or `↵` key. Used to activate current selection or accept current input. This/// key value is also used for the `Return` (Macintosh numpad) key. This key value is also/// used for the Android `KEYCODE_DPAD_CENTER`./// Used to delete the character to the right of the cursor. This key value is also used for/// the key labeled `Delete` on MacOS keyboards when `Fn` is active./// Initiate the multi-candidate mode./// manner similar to a dead key, triggering a mode where subsequent key presses are combined/// to produce a different character./// The Kanji (Japanese name for ideographic characters of Chinese origin) Mode key. This key/// is typically used to switch to a hiragana keyboard for the purpose of converting input/// into kanji. (`KEYCODE_KANA`)/// A [`Key::Named`] value///   specification./// A simple (unparameterised) action/// The native key is provided (if available) in order to allow the user to specify keybindings/// for keys which are not defined by this API, mainly through some sort of UI./// This is a superset of the UI Events Specification's [`KeyboardEvent.key`] with/// additions:/// - All simple variants are wrapped under the `Named` variant/// - The `Unidentified` variant here, can still identify a key through it's `NativeKeyCode`./// Convert `Key::Character(SmolStr)` to `Key::Character(&str)` so you can more easily match on/// `Key`. All other variants remain unchanged./// Convert an action to its approximate textual equivalent./// use winit::keyboard::NamedKey;/// assert_eq!(NamedKey::Enter.to_text(), Some("\r"));/// assert_eq!(NamedKey::F20.to_text(), None);/// Convert a key to its approximate textual equivalent./// use winit::keyboard::{Key, NamedKey};/// assert_eq!(Key::Character("a".into()).to_text(), Some("a"));/// assert_eq!(Key::Named(NamedKey::Enter).to_text(), Some("\r"));/// assert_eq!(Key::Named(NamedKey::F20).to_text(), None);/// The key is in its "normal" location on the keyboard./// For instance, the "1" key above the "Q" key on a QWERTY keyboard will use this location./// This invariant is also returned when the location of the key cannot be identified./// ![Standard 1 key](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/keyboard_standard_1_key.svg)/// <sub>///   For image attribution, see the///   <a href="https://github.com/rust-windowing/winit/blob/master/docs/res/ATTRIBUTION.md">///     ATTRIBUTION.md///   </a>///   file./// </sub>/// The key is on the left side of the keyboard./// For instance, the left Shift key below the Caps Lock key on a QWERTY keyboard will use this/// ![Left Shift key](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/keyboard_left_shift_key.svg)/// The key is on the right side of the keyboard./// For instance, the right Shift key below the Enter key on a QWERTY keyboard will use this/// ![Right Shift key](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/keyboard_right_shift_key.svg)/// The key is on the numpad./// For instance, the "1" key on the numpad will use this location./// ![Numpad 1 key](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/keyboard_numpad_1_key.svg)/// The location of the key on the keyboard./// Certain physical keys on the keyboard can have the same value, but are in different locations./// For instance, the Shift key can be on the left or right side of the keyboard, or the number/// keys can be above the letters or on the numpad. This enum allows the user to differentiate/// See the documentation for the [`location`] field on the [`KeyEvent`] struct for more/// [`location`]: ../event/struct.KeyEvent.html#structfield.location/// [`KeyEvent`]: crate::event::KeyEvent/// The particular key is pressed./// The state of the key is unknown./// The state of the particular modifiers key.LSHIFTRSHIFTLCONTROLRCONTROLLALTRALTLSUPERRSUPER// NOTE: the exact modifier key is not used to represent modifiers state in the// first place due to a fact that modifiers state could be changed without any// key being pressed and on some platforms like Wayland/X11 which key resulted// in modifiers change is hidden, also, not that it really matters.// The reason this API is even exposed is mostly to provide a way for users// to treat modifiers differently based on their position, which is required// on macOS due to their AltGr/Option situation.//! Types related to the keyboard.// --------- BEGINNING OF W3C LICENSE --------------------------------------------------------------// --------- BEGINNING OF W3C SHORT NOTICE ---------------------------------------------------------// winit: https://github.com/rust-windowing/winit// Re-export DPI types so that users don't have to put it in Cargo.toml.//! Winit is a cross-platform window creation and event loop management library.//! Before you can create a [`Window`], you first need to build an [`EventLoop`]. This is done with//! the [`EventLoop::new()`] function.//! use winit::event_loop::EventLoop;//! # // Intentionally use `fn main` for clarity//!     let event_loop = EventLoop::new().unwrap();//! Then you create a [`Window`] with [`create_window`].//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if//! desired.//! You can retrieve events by calling [`EventLoop::run_app()`]. This function will//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].//! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop//! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works//! poorly on most other platforms. However, this model can be re-implemented to an extent with//! [^1]. See that method's documentation for more reasons about why//! it's discouraged beyond compatibility reasons.//! use winit::application::ApplicationHandler;//! use winit::event::WindowEvent;//! use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};//! use winit::window::{Window, WindowId};//! struct App {//!     window: Option<Window>,//! impl ApplicationHandler for App {//!     fn resumed(&mut self, event_loop: &ActiveEventLoop) {//!         self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());//!     fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {//!         match event {//!             WindowEvent::CloseRequested => {//!                 println!("The close button was pressed; stopping");//!                 event_loop.exit();//!             WindowEvent::RedrawRequested => {//!                 // Redraw the application.//!                 // It's preferable for applications that do not render continuously to render in//!                 // this event rather than in AboutToWait, since rendering in here allows//!                 // the program to gracefully handle redraws requested by the OS.//!                 // Draw.//!                 // Queue a RedrawRequested event.//!                 // You only need to call this if you've determined that you need to redraw in//!                 // applications which do not always need to. Applications that redraw continuously//!                 // can render here instead.//!                 self.window.as_ref().unwrap().request_redraw();//!             _ => (),//!     event_loop.set_control_flow(ControlFlow::Poll);//!     event_loop.set_control_flow(ControlFlow::Wait);//!     let mut app = App::default();//!     event_loop.run_app(&mut app);//! [`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be//! compared to the value returned by [`Window::id()`] to determine which [`Window`]//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However, it allows you//! to retrieve the raw handle of the window and display (see the [`platform`] module and/or the//! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows//! you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.//! [`visible` set to `false`][crate::window::WindowAttributes::with_visible] and explicitly make//! the window visible only once you're ready to render into it.//! # UI scaling//! UI scaling is important, go read the docs for the [`dpi`] crate for an//! introduction.//! All of Winit's functions return physical types, but can take either logical or physical//! Winit will dispatch a [`ScaleFactorChanged`] event whenever a window's scale factor has changed.//! This can happen if the user drags their window from a standard-resolution monitor to a high-DPI//! monitor or if the user changes their DPI settings. This allows you to rescale your application's//! UI elements and adjust how the platform changes the window's size to reflect the new scale//! factor. If a window hasn't received a [`ScaleFactorChanged`] event, its scale factor//! can be found by calling [`window.scale_factor()`].//! [`ScaleFactorChanged`]: event::WindowEvent::ScaleFactorChanged//! [`window.scale_factor()`]: window::Window::scale_factor//! Winit provides the following Cargo features://! * `x11` (enabled by default): On Unix platforms, enables the X11 backend.//! * `wayland` (enabled by default): On Unix platforms, enables the Wayland backend.//! * `rwh_04`: Implement `raw-window-handle v0.4` traits.//! * `rwh_05`: Implement `raw-window-handle v0.5` traits.//! * `rwh_06`: Implement `raw-window-handle v0.6` traits.//! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).//! See the [`platform`] module for documentation on platform-specific cargo//! [`EventLoop::run_app()`]: event_loop::EventLoop::run_app//! [`exit()`]: event_loop::ActiveEventLoop::exit//! [`WindowAttributes`]: window::WindowAttributes//! [`create_window`]: event_loop::ActiveEventLoop::create_window//! [`Window::id()`]: window::Window::id//! [`Event::UserEvent`]: event::Event::UserEvent//! [`Event::LoopExiting`]: event::Event::LoopExiting//! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.// Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly// doc"Renamed to `VideoModeHandle`"VideoModeHandle/// Deprecated! Use `VideoModeHandle` instead./// Can be acquired with [`MonitorHandle::video_modes`]./// - **Wayland / Orbital:** Always returns 32.refresh_rate_millihertz/// Returns the refresh rate of this video mode in mHz./// The monitor refresh rate used by the system./// Return `Some` if succeed, or `None` if failed, which usually happens when the monitor/// the window is on is removed./// When using exclusive fullscreen, the refresh rate of the [`VideoModeHandle`] that was/// used to enter fullscreen should be used instead./// Returns the scale factor of the underlying monitor. To map logical pixels to physical/// pixels and vice versa, use [`Window::scale_factor`]./// See the [`dpi`] module for more information./// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable./// - **Wayland:** May differ from [`Window::scale_factor`]./// [`Window::scale_factor`]: crate::window::Window::scale_factor/// - **Web:** Always returns an empty iterator//! If you want to get basic information about a monitor, you can use the//! [`MonitorHandle`] type. This is retrieved from one of the following//! methods, which return an iterator of [`MonitorHandle`]://! - [`ActiveEventLoop::available_monitors`][crate::event_loop::ActiveEventLoop::available_monitors].//! - [`Window::available_monitors`][crate::window::Window::available_monitors].activityAndroidAppConfigurationRefandroid_app/// Get the [`AndroidApp`] which was used to create this event loop./// Additional methods on [`EventLoop`] that are specific to Android.ActiveEventLoopExtAndroid/// Additional methods on [`ActiveEventLoop`] that are specific to Android./// Additional methods on [`Window`] that are specific to Android.WindowAttributesExtAndroid/// Additional methods on [`WindowAttributes`] that are specific to Android.with_android_app/// Associates the [`AndroidApp`] that was passed to `android_main()` with the event loop/// This must be called on Android since the [`AndroidApp`] is not global state.handle_volume_keys/// Calling this will mark the volume keys to be manually handled by the application/// Default is to let the operating system handle the volume keysEventLoopBuilderExtAndroidandroid_activity// We enable the `"native-activity"` feature just so that we can build the// docs, but it'll be very confusing for users to see the docs with that// feature enabled, so we avoid inlining it so that they're forced to view// it on the crate's own docs.rs page./// Re-export of the `android_activity` API/// Winit re-exports the `android_activity` API for convenience so that most/// applications can rely on the Winit crate to resolve the required version of/// `android_activity` and avoid any chance of a conflict between Winit and the/// application crate./// Unlike most libraries there can only be a single implementation/// of the `android_activity` glue crate linked with an application because/// it is responsible for the application's `android_main()` entry point./// Since Winit depends on a specific version of `android_activity` the simplest/// way to avoid creating a conflict is for applications to avoid explicitly/// depending on the `android_activity` crate, and instead consume the API that/// is re-exported by Winit./// For compatibility applications should then import the [`AndroidApp`] type for/// their `android_main(app: AndroidApp)` function like:/// #[cfg(target_os = "android")]/// use winit::platform::android::activity::AndroidApp;//! # Android//! The Android backend builds on (and exposes types from) the [`ndk`](https://docs.rs/ndk/) crate.//! Native Android applications need some form of "glue" crate that is responsible//! for defining the main entry point for your Rust application as well as tracking//! various life-cycle events and synchronizing with the main JVM thread.//! Winit uses the [android-activity](https://docs.rs/android-activity/) as a//! glue crate (prior to `0.28` it used//! [ndk-glue](https://github.com/rust-windowing/android-ndk-rs/tree/master/ndk-glue)).//! The version of the glue crate that your application depends on _must_ match the//! version that Winit depends on because the glue crate is responsible for your//! application's main entry point. If Cargo resolves multiple versions, they will//! clash.//! `winit` glue compatibility table://! | winit |       ndk-glue               |//! | :---: | :--------------------------: |//! | 0.30  | `android-activity = "0.6"`   |//! | 0.29  | `android-activity = "0.5"`   |//! | 0.28  | `android-activity = "0.4"`   |//! | 0.27  | `ndk-glue = "0.7"`           |//! | 0.26  | `ndk-glue = "0.5"`           |//! | 0.25  | `ndk-glue = "0.3"`           |//! | 0.24  | `ndk-glue = "0.2"`           |//! The recommended way to avoid a conflict with the glue version is to avoid explicitly//! depending on the `android-activity` crate, and instead consume the API that//! is re-exported by Winit under `winit::platform::android::activity::*`//! Running on an Android device needs a dynamic system library. Add this to Cargo.toml://! name = "main"//! crate-type = ["cdylib"]//! All Android applications are based on an `Activity` subclass, and the//! `android-activity` crate is designed to support different choices for this base//! class. Your application _must_ specify the base class it needs via a feature flag://! | Base Class       | Feature Flag      |  Notes  |//! | :--------------: | :---------------: | :-----: |//! | `NativeActivity` | `android-native-activity` | Built-in to Android - it is possible to use without compiling any Java or Kotlin code. Java or Kotlin code may be needed to subclass `NativeActivity` to access some platform features. It does not derive from the [`AndroidAppCompat`] base class.|//! | [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`], a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][agdk_jetpack] (or link with an embedded [release][agdk_releases] of [`GameActivity`]) |//! [`GameActivity`]: https://developer.android.com/games/agdk/game-activity//! [`GameTextInput`]: https://developer.android.com/games/agdk/add-support-for-text-input//! [`AndroidAppCompat`]: https://developer.android.com/reference/androidx/appcompat/app/AppCompatActivity//! [agdk_jetpack]: https://developer.android.com/jetpack/androidx/releases/games//! [agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries//! [Gradle]: https://developer.android.com/studio/build//! For more details, refer to these `android-activity` [example applications](https://github.com/rust-mobile/android-activity/tree/main/examples).//! ## Converting from `ndk-glue` to `android-activity`//! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building//! with `cargo apk`, then the minimal changes would be://! 1. Remove `ndk-glue` from your `Cargo.toml`//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.9",//!    features = [ "android-native-activity" ] }`//! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc//!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize//!    logging as above).//! 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your//!    event loop (as shown above)./// This sets the value of the/// [`prefersStatusBarHidden`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc)/// [`setNeedsStatusBarAppearanceUpdate()`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc)/// is also called for you.set_preferred_status_bar_styleStatusBarStyle/// Sets the preferred status bar style for the [`Window`]./// The default is system-defined./// [`preferredStatusBarStyle`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc)recognize_pinch_gesture/// Sets whether the [`Window`] should recognize pinch gestures./// The default is to not recognize gestures.recognize_pan_gesture/// Sets whether the [`Window`] should recognize pan gestures./// Installs [`UIPanGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer) onto view/// Set the minimum number of touches required: [`minimumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-minimumnumberoftouches)/// Set the maximum number of touches recognized: [`maximumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-maximumnumberoftouches)recognize_doubletap_gesture/// Sets whether the [`Window`] should recognize double tap gestures.recognize_rotation_gesture/// Sets whether the [`Window`] should recognize rotation gestures.with_preferred_status_bar_style/// Sets the style of the [`Window`]'s status bar./// [`-[UIViewController preferredStatusBarStyle]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc),WindowAttributesExtIOS/// Additional methods on [`WindowAttributes`] that are specific to iOS./// Returns the preferred [`VideoModeHandle`] for this monitor.LightContentDarkContent//! # iOS / UIKit//! Winit has an OS requirement of iOS 8 or higher, and is regularly tested on//! iOS 9.3.//! iOS's main `UIApplicationMain` does some init work that's required by all//! UI-related code (see issue [#1705]). It is best to create your windows//! inside `Event::Resumed`.//! [#1705]: https://github.com/rust-windowing/winit/issues/1705//! ## Building app//! pub extern fn start_winit_app() {//! Compile project and then drag resulting .a into Xcode project. Add winit.h to xcode.//! void start_winit_app();//! Use start_winit_app inside your xcode's main function.//! ## App lifecycle and events//! This is how those event are represented in winit://!  - applicationWillTerminate is LoopExiting//! Keep in mind that after LoopExiting event is received every attempt to draw with//! Also note that app may not receive the LoopExiting event if suspended; it might be SIGKILL'ed.select_next_tab/// Select next tab.select_previous_tab/// Select previous tab.select_tab_at_index/// Select the tab with the given index./// Will no-op when the index is out of bounds.num_tabs/// Get the number of tabs in the window tab group./// Get the window's edit state./// WindowEvent::CloseRequested => {///     if window.is_document_edited() {///         // Show the user a save pop-up or similar///         // Close the window///         drop(window);set_document_editedset_option_as_altOptionAsAlt/// Set option as alt behavior as described in [`OptionAsAlt`]./// This will ignore diacritical marks and accent characters from/// being processed as received characters. Instead, the input/// device's raw character will be placed in event queues with the/// Alt modifier set.option_as_alt/// Getter for the [`WindowExtMacOS::set_option_as_alt`].set_borderless_game/// Disable the Menu Bar and Dock in Borderless Fullscreen mode. Useful for games.is_borderless_game/// Getter for the [`WindowExtMacOS::set_borderless_game`]./// Additional methods on [`Window`] that are specific to MacOS.with_accepts_first_mouse/// Window accepts click-through mouse events./// Defines the window tabbing identifier.with_option_as_alt/// Set how the <kbd>Option</kbd> keys are interpreted./// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.with_borderless_game/// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.WindowAttributesExtMacOS/// Additional methods on [`WindowAttributes`] that are specific to MacOS./// **Note:** Properties dealing with the titlebar will be overwritten by the/// [`WindowAttributes::with_decorations`] method:/// - `with_titlebar_transparent`/// - `with_title_hidden`/// - `with_titlebar_hidden`/// - `with_titlebar_buttons_hidden`/// - `with_fullsize_content_view`with_activation_policy/// Sets the activation policy for the application. If used, this will override/// any relevant settings provided in the package manifest./// For instance, `with_activation_policy(ActivationPolicy::Regular)` will prevent/// the application from running as an "agent", even if LSUIElement is set to true./// If unused, the Winit will honor the package manifest./// Set the activation policy to "accessory"./// use winit::event_loop::EventLoopBuilder;/// #[cfg(target_os = "macos")]/// use winit::platform::macos::{ActivationPolicy, EventLoopBuilderExtMacOS};/// builder.with_activation_policy(ActivationPolicy::Accessory);with_default_menu/// Used to control whether a default menubar menu is created./// Menu creation is enabled by default./// Disable creating a default menubar./// use winit::platform::macos::EventLoopBuilderExtMacOS;/// builder.with_default_menu(false);with_activate_ignoring_other_apps/// another application is already active.EventLoopBuilderExtMacOS/// Additional methods on [`MonitorHandle`] that are specific to MacOS./// Hide the entire application. In most applications this is typically triggered with/// Command-H./// Hide the other applications. In most applications this is typically triggered with/// Command+Option-H./// Set whether the system can automatically organize windows into tabs.ActiveEventLoopExtMacOS/// Additional methods on [`ActiveEventLoop`] that are specific to macOS.OnlyLeft/// The left `Option` key is treated as `Alt`.OnlyRight/// The right `Option` key is treated as `Alt`./// Both `Option` keys are treated as `Alt`./// No special handling is applied for `Option` key./// Option as alt behavior.//! # macOS / AppKit//! Winit has an OS requirement of macOS 10.11 or higher (same as Rust//! itself), and is regularly tested on macOS 10.14.//! A lot of functionality expects the application to be ready before you//! start doing anything; this includes creating windows, fetching monitors,//! drawing, and so on, see issues [#2238], [#2051] and [#2087].//! If you encounter problems, you should try doing your initialization inside//! `Event::Resumed`.//! [#2238]: https://github.com/rust-windowing/winit/issues/2238//! [#2051]: https://github.com/rust-windowing/winit/issues/2051//! [#2087]: https://github.com/rust-windowing/winit/issues/2087startup_notifyrun_on_demandpump_eventsmodifier_supplement//! Only the modules corresponding to the platform you're compiling to will be available.KeyEventExtModifierSupplement/// Additional methods for the `KeyEvent` which cannot be implemented on all//! # Orbital / Redox OS//! Redox OS has some functionality not yet present that will be implemented//! when its orbital display server provides it.// There are no Orbital specific traits yet./// A type provided by the user that can be passed through [`Event::UserEvent`].pump_app_eventsPumpStatus/// Pump the `EventLoop` to check for and dispatch pending events./// This API is designed to enable applications to integrate Winit into an/// external event loop, for platforms that can support this./// The given `timeout` limits how long it may block waiting for new events./// Passing a `timeout` of `Some(Duration::ZERO)` would ensure your external/// event loop is never blocked but you would likely need to consider how/// to throttle your own external loop./// Passing a `timeout` of `None` means that it may wait indefinitely for new/// events before returning control back to the external loop./// **Note:** This is not a portable API, and its usage involves a number of/// caveats and trade offs that should be considered before using this API!/// You almost certainly shouldn't use this API, unless you absolutely know it's/// the only practical option you have./// ## Synchronous events/// Some events _must_ only be handled synchronously via the closure that/// is passed to Winit so that the handler will also be synchronized with/// the window system and operating system./// This is because some events are driven by a window system callback/// where the window systems expects the application to have handled the/// event before returning./// **These events can not be buffered and handled outside of the closure/// passed to Winit.**/// As a general rule it is not recommended to ever buffer events to handle/// them outside of the closure passed to Winit since it's difficult to/// provide guarantees about which events are safe to buffer across all/// operating systems./// Notable events that will certainly create portability problems if/// buffered and handled outside of Winit include:/// - `RedrawRequested` events, used to schedule rendering.///     macOS for example uses a `drawRect` callback to drive rendering///     within applications and expects rendering to be finished before///     the `drawRect` callback returns.///     For portability it's strongly recommended that applications should///     keep their rendering inside the closure provided to Winit./// - Any lifecycle events, such as `Suspended` / `Resumed`.///     The handling of these events needs to be synchronized with the///     operating system and it would never be appropriate to buffer a///     notification that your application has been suspended or resumed and///     then handled that later since there would always be a chance that///     other lifecycle events occur while the event is buffered./// - Windows/// - Linux/// - MacOS/// ## Unsupported Platforms/// - **Web:**  This API is fundamentally incompatible with the event-based way in which Web///   browsers work because it's not possible to have a long-running external loop that would///   block the browser and there is nothing that can be polled to ask for new new events.///   Events are delivered via callbacks based on an event loop that is internal to the browser///   itself./// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS so///   there's no way to support the same approach to polling as on MacOS./// - **Windows**: The implementation will use `PeekMessage` when checking for window messages///   to avoid blocking your external event loop./// - **MacOS**: The implementation works in terms of stopping the global application whenever///   the application `RunLoop` indicates that it is preparing to block and wait for new events.///   This is very different to the polling APIs that are available on other///   platforms (the lower level polling primitives on MacOS are private///   implementation details for `NSApplication` which aren't accessible to///   application developers)///   It's likely this will be less efficient than polling on other OSs and///   it also means the `NSApplication` is stopped while outside of the Winit///   event loop - and that's observable (for example to crates like `rfd`)///   because the `NSApplication` is global state.///   If you render outside of Winit you are likely to see window resizing artifacts///   since MacOS expects applications to render synchronously during any `drawRect`///   callback."use EventLoopExtPumpEvents::pump_app_events"/// See [`pump_app_events`]./// [`pump_app_events`]: Self::pump_app_eventsEventLoopExtPumpEvents/// Additional methods on [`EventLoop`] for pumping events within an external event loop/// Continue running external loop./// Exit external loop./// The return status for `pump_events`"use EventLoopExtRunOnDemand::run_app_on_demand"/// See [`run_app_on_demand`]./// [`run_app_on_demand`]: Self::run_app_on_demandrun_app_on_demand/// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)/// closures and it is possible to return control back to the caller without/// consuming the `EventLoop` (by using [`exit()`]) and/// so the event loop can be re-run after it has exit./// It's expected that each run of the loop will be for orthogonal instantiations of your/// Winit application, but internally each instantiation may re-use some common window/// system resources, such as a display server connection./// This API is not designed to run an event loop in bursts that you can exit from and return/// to while maintaining the full state of your application. (If you need something like this/// you can look at the [`EventLoopExtPumpEvents::pump_app_events()`] API)/// Each time `run_app_on_demand` is called the startup sequence of `init`, followed by/// `resume` is being preserved./// - This extension isn't available on all platforms, since it's not always possible to return///   to the caller (specifically this is impossible on iOS and Web - though with the Web///   backend it is possible to use `EventLoopExtWebSys::spawn()`///   more than once instead)./// - No [`Window`] state can be carried between separate runs of the event loop./// You are strongly encouraged to use [`EventLoop::run_app()`] for portability, unless you/// specifically need the ability to re-run a single event loop more than once/// # Supported Platforms/// # Unsupported Platforms///   block the browser and there is nothing that can be polled to ask for new events. Events///   are delivered via callbacks based on an event loop that is internal to the browser itself./// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS./// [`exit()`]: ActiveEventLoop::exit()EventLoopExtRunOnDemand/// Additional methods on [`EventLoop`] to return control flow to the caller.clear_exit/// Clear exit status.test_run_on_demand_cannot_access_event_loop/// use winit::event_loop::EventLoop;/// use winit::platform::run_on_demand::EventLoopExtRunOnDemand;/// let mut event_loop = EventLoop::new().unwrap();/// event_loop.run_on_demand(|_, _| {///     // Attempt to run the event loop re-entrantly; this must fail.///     event_loop.run_on_demand(|_, _| {});/// The raw value of the platform-specific physical key identifier./// Returns `Some(key_id)` if the conversion was successful; returns `None` otherwise./// - **Windows:** A 16bit extended scancode/// - **Wayland/X11**: A 32-bit linux scancode, which is X11/Wayland keycode subtracted by 8./// Constructs a `PhysicalKey` from a platform-specific physical key identifier./// Note that this conversion may be lossy, i.e. converting the returned `PhysicalKey` back/// using `to_scancode` might not yield the original value./// - **Wayland/X11**: A 32-bit linux scancode. When building from X11/Wayland keycode subtract///   `8` to get the value you wanted.PhysicalKeyExtScancode/// Additional methods for the [`PhysicalKey`] type that allow the user to access the/// platform-specific scancode./// [`PhysicalKey`]: crate::keyboard::PhysicalKey// TODO: Describe what this value contains for each platformX11_VAR/// The variable which is used mostly on X11.WAYLAND_VAR/// The variable which is used mostly on Wayland.read_token_from_env/// Read the token from the environment./// It's recommended **to unset** this environment variable for child processes.EventLoopExtStartupNotifyrequest_activation_token/// Request a new activation token./// The token will be delivered insideWindowExtStartupNotifywith_activation_token/// Use this [`ActivationToken`] during window creation./// Not using such a token upon a window could make your window not gaining/// focus until the user clicks on the window.WindowAttributesExtStartupNotifyreset_activation_token_env/// Remove the activation environment variables from the current process./// This is wise to do before running child processes,/// which may not to support the activation token.set_activation_token_env/// Set environment variables responsible for activation token./// This could be used before running daemon processes.//! Window startup notification to handle window raising.//! The [`ActivationToken`] is essential to ensure that your newly//! created window will obtain the focus, otherwise the user could//! be requered to click on the window.//! Such token is usually delivered via the environment variable and//! could be read from it with the [`EventLoopExtStartupNotify::read_token_from_env`].//! Such token must also be reset after reading it from your environment with//! [`reset_activation_token_env`] otherwise child processes could inherit it.//! When starting a new child process with a newly obtained [`ActivationToken`] from//! [`WindowExtStartupNotify::request_activation_token`] the [`set_activation_token_env`]//! must be used to propagate it to the child//! To ensure the delivery of such token by other processes to you, the user should//! set `StartupNotify=true` inside the `.desktop` file of their application.//! The specification could be found [`here`].//! [`here`]: https://specifications.freedesktop.org/startup-notification-spec/startup-notification-latest.txt/// True if the [`ActiveEventLoop`] uses Wayland.ActiveEventLoopExtWayland/// Additional methods on [`ActiveEventLoop`] that are specific to Wayland./// True if the [`EventLoop`] uses Wayland.EventLoopExtWayland/// Additional methods on [`EventLoop`] that are specific to Wayland.with_wayland/// Force using Wayland.EventLoopBuilderExtWayland/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.WindowExtWayland/// Additional methods on [`Window`] that are specific to Wayland./// Build window with the given name./// The `general` name sets an application ID, which should match the `.desktop`/// file distributed with your program. The `instance` is a `no-op`./// For details about application ID conventions, see the/// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)WindowAttributesExtWayland/// Additional methods on [`WindowAttributes`] that are specific to Wayland./// Returns the inner identifier of the monitor.MonitorHandleExtWayland/// Additional methods on `MonitorHandle` that are specific to Wayland.//! # Wayland//! **Note:** Windows don't appear on Wayland until you draw/present to them.//! By default, Winit loads system libraries using `dlopen`. This can be//! disabled by disabling the `"wayland-dlopen"` cargo feature.//! ## Client-side decorations//! Winit provides client-side decorations by default, but the behaviour can//! be controlled with the following feature flags://! * `wayland-csd-adwaita` (default).//! * `wayland-csd-adwaita-crossfont`.//! * `wayland-csd-adwaita-notitle`.CustomCursorFuturePlatformCustomCursorFuture/// Only returns the canvas if called from inside the window context (the/// main thread).prevent_default/// Returns [`true`] if calling `event.preventDefault()` is enabled./// See [`Window::set_prevent_default()`] for more details.set_prevent_default/// Sets whether `event.preventDefault()` should be called on events on the/// canvas that have side effects./// For example, by default using the mouse wheel would cause the page to scroll, enabling this/// would prevent that./// Some events are impossible to prevent. E.g. Firefox allows to access the native browser/// context menu with Shift+Rightclick.WindowExtWebSyswith_canvas/// Pass an [`HtmlCanvasElement`] to be used for this [`Window`]. If [`None`],/// [`WindowAttributes::default()`] will create one./// In any case, the canvas won't be automatically inserted into the web page./// [`None`] by default.with_prevent_defaultwith_focusable/// Whether the canvas should be focusable using the tab key. This is necessary to capture/// canvas keyboard events.with_append/// On window creation, append the canvas element to the web page if it isn't already.WindowAttributesExtWebSysspawn_app/// Initializes the winit event loop./// Unlike/// [^1], this returns immediately, and doesn't throw an exception in order to/// satisfy its [`!`] return type./// Once the event loop has been destroyed, it's possible to reinitialize another event loop/// by calling this function again. This can be useful if you want to recreate the event loop/// while the WebAssembly module is still loaded. For example, this can be used to recreate the/// event loop when switching between tabs on a single page application./// [^1]: `run_app()` is _not_ available on WASM when the target supports `exception-handling`."use EventLoopExtWebSys::spawn_app"/// See [`spawn_app`]./// [`spawn_app`]: Self::spawn_appset_poll_strategyPollStrategy/// Sets the strategy for [`ControlFlow::Poll`]./// See [`PollStrategy`].poll_strategy/// Gets the strategy for [`ControlFlow::Poll`].set_wait_until_strategyWaitUntilStrategy/// Sets the strategy for [`ControlFlow::WaitUntil`]./// See [`WaitUntilStrategy`].wait_until_strategy/// Gets the strategy for [`ControlFlow::WaitUntil`].EventLoopExtWebSys/// Additional methods on `EventLoop` that are specific to the web.create_custom_cursor_async/// Async version of [`ActiveEventLoop::create_custom_cursor()`] which waits until the/// cursor has completely finished loading.ActiveEventLoopExtWebSys/// Uses [`Window.requestIdleCallback()`] to queue the next event loop. If not available/// this will fallback to [`setTimeout()`]./// This strategy will wait for the browser to enter an idle period before running and might/// be affected by browser throttling./// [`Window.requestIdleCallback()`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback/// [`setTimeout()`]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout/// Uses the [Prioritized Task Scheduling API] to queue the next event loop. If not available/// This strategy will run as fast as possible without disturbing users from interacting with/// the page and is not affected by browser throttling./// This is the default strategy./// [Prioritized Task Scheduling API]: https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API/// Strategy used for [`ControlFlow::Poll`][crate::event_loop::ControlFlow::Poll]./// This strategy is commonly not affected by browser throttling unless the window is not/// focused./// Equal to [`Scheduler`][Self::Scheduler] but wakes up the event loop from a [worker]./// This strategy is commonly not affected by browser throttling regardless of window focus./// [worker]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/// Strategy used for [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil].is_animation/// Returns if this cursor is an animation./// Creates a new cursor from a URL pointing to an image./// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),/// but browser support for image formats is inconsistent. Using [PNG] is recommended./// [PNG]: https://en.wikipedia.org/wiki/PNGBadAnimation/// Crates a new animated cursor from multiple [`CustomCursor`]s./// Supplied `cursors` can't be empty or other animations.CustomCursorExtWebSys/// Produced when no cursors were supplied./// Produced when a supplied cursor is an animation./// An error produced when using [`CustomCursor::from_animation`] with invalid arguments.CustomCursorError//! # Web//! The officially supported browsers are Chrome, Firefox and Safari 13.1+,//! though forks of these should work fine.//! Winit supports compiling to the `wasm32-unknown-unknown` target with//! `web-sys`.//! On the web platform, a Winit window is backed by a `<canvas>` element. You//! can either [provide Winit with a `<canvas>` element][with_canvas], or//! [let Winit create a `<canvas>` element which you can then retrieve][get]//! and insert it into the DOM yourself.//! Currently, there is no example code using Winit on Web, see [#3473]. For//! information on using Rust on WebAssembly, check out the [Rust and//! WebAssembly book].//! [with_canvas]: WindowAttributesExtWebSys::with_canvas//! [get]: WindowExtWebSys::canvas//! [#3473]: https://github.com/rust-windowing/winit/issues/3473//! [Rust and WebAssembly book]: https://rustwasm.github.io/book///! ## CSS properties//! It is recommended **not** to apply certain CSS properties to the canvas://! - [`transform`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform)//! - [`border`](https://developer.mozilla.org/en-US/docs/Web/CSS/border)//! - [`padding`](https://developer.mozilla.org/en-US/docs/Web/CSS/padding)//! The following APIs can't take them into account and will therefore provide inaccurate results://! - [`WindowEvent::Resized`] and [`Window::(set_)inner_size()`]//! - [`WindowEvent::Occluded`]//! - [`WindowEvent::CursorMoved`], [`WindowEvent::CursorEntered`], [`WindowEvent::CursorLeft`], and//!   [`WindowEvent::Touch`].//! - [`Window::set_outer_position()`]//! [`WindowEvent::Resized`]: crate::event::WindowEvent::Resized//! [`Window::(set_)inner_size()`]: crate::window::Window::inner_size//! [`WindowEvent::Occluded`]: crate::event::WindowEvent::Occluded//! [`WindowEvent::CursorMoved`]: crate::event::WindowEvent::CursorMoved//! [`WindowEvent::CursorEntered`]: crate::event::WindowEvent::CursorEntered//! [`WindowEvent::CursorLeft`]: crate::event::WindowEvent::CursorLeft//! [`WindowEvent::Touch`]: crate::event::WindowEvent::Touch//! [`Window::set_outer_position()`]: crate::window::Window::set_outer_position/// Window Handle type used by Win32 API/// Menu Handle type used by Win32 API/// Monitor Handle type used by Win32 APIBackdropType/// Corresponds to `DWMSBT_AUTO`./// Usually draws a default backdrop effect on the title bar./// Corresponds to `DWMSBT_NONE`./// Corresponds to `DWMSBT_MAINWINDOW`./// Draws the Mica backdrop material.TransientWindow/// Corresponds to `DWMSBT_TRANSIENTWINDOW`./// Draws the Background Acrylic backdrop material.TabbedWindow/// Corresponds to `DWMSBT_TABBEDWINDOW`./// Draws the Alt Mica backdrop material./// Describes a system-drawn backdrop material of a window./// For a detailed explanation, see [`DWM_SYSTEMBACKDROP_TYPE docs`]./// [`DWM_SYSTEMBACKDROP_TYPE docs`]: https://learn.microsoft.com/en-us/windows/win32/api/dwmapi/ne-dwmapi-dwm_systembackdrop_type/// Describes a color used by Windows// Special constant only valid for the window border and therefore modeled using Option<Color>// for user facing codeSYSTEM_DEFAULT/// Use the system's default color/// Create a new color from the given RGB valuesCornerPreference/// Corresponds to `DWMWCP_DEFAULT`./// Let the system decide when to round window corners.DoNotRound/// Corresponds to `DWMWCP_DONOTROUND`./// Never round window corners./// Corresponds to `DWMWCP_ROUND`./// Round the corners, if appropriate.RoundSmall/// Corresponds to `DWMWCP_ROUNDSMALL`./// Round the corners if appropriate, with a small radius./// Describes how the corners of a window should look like./// For a detailed explanation, see [`DWM_WINDOW_CORNER_PREFERENCE docs`]./// [`DWM_WINDOW_CORNER_PREFERENCE docs`]: https://learn.microsoft.com/en-us/windows/win32/api/dwmapi/ne-dwmapi-dwm_window_corner_preferenceAnyThread/// A wrapper around a [`Window`] that ignores thread-specific window handle limitations./// See [`WindowBorrowExtWindows::any_thread`] for more information./// Get a reference to the inner window./// Get a reference to the inner object./// Unwrap and get the inner window./// By default, `winit` will attempt to enable process-wide DPI awareness. If/// use winit::platform::windows::EventLoopBuilderExtWindows;/// Return true to disable winit's internal message dispatching./// # use windows_sys::Win32::UI::WindowsAndMessaging::{ACCEL, CreateAcceleratorTableW, TranslateAcceleratorW, DispatchMessageW, TranslateMessage, MSG};/// #   let accels: Vec<ACCEL> = Vec::new();///             CreateAcceleratorTableW(accels.as_ptr() as _, 1),/// (as described in [`WindowAttributesExtWindows::with_owner_window`]), the application must/// enable the owner window before destroying the dialog box./// Whether to show or hide the window icon in the taskbar.set_system_backdrop/// Sets system-drawn backdrop type./// Requires Windows 11 build 22523+.set_border_color/// Sets the color of the window border./// Supported starting with Windows 11 Build 22000.set_title_background_color/// Sets the background color of the title bar.set_title_text_color/// Sets the color of the window title.set_corner_preference/// Sets the preferred style of the window corners.window_handle_any_thread/// Get the raw window handle for this [`Window`] without checking for thread affinity./// Window handles in Win32 have a property called "thread affinity" that ties them to their/// origin thread. Some operations can only happen on the window's origin thread, while others/// can be called from any thread. For example, [`SetWindowSubclass`] is not thread safe while/// [`GetDC`] is thread safe./// In Rust terms, the window handle is `Send` sometimes but `!Send` other times./// Therefore, in order to avoid confusing threading errors, [`Window`] only returns the/// window handle when the [`window_handle`] function is called from the thread that created/// the window. In other cases, it returns an [`Unavailable`] error./// However in some cases you may already know that you are using the window handle for/// operations that are guaranteed to be thread-safe. In which case this function aims/// to provide an escape hatch so these functions are still accessible from other threads./// It is the responsibility of the user to only pass the window handle into thread-safe/// Win32 APIs./// [`SetWindowSubclass`]: https://learn.microsoft.com/en-us/windows/win32/api/commctrl/nf-commctrl-setwindowsubclass/// [`GetDC`]: https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc/// [`window_handle`]: https://docs.rs/raw-window-handle/latest/raw_window_handle/trait.HasWindowHandle.html#tymethod.window_handle/// [`Unavailable`]: https://docs.rs/raw-window-handle/latest/raw_window_handle/enum.HandleError.html#variant.Unavailable/// # fn scope(window: Window) {/// use winit::platform::windows::WindowExtWindows;/// use winit::raw_window_handle::HasWindowHandle;/// // We can get the window handle on the current thread./// let handle = window.window_handle().unwrap();/// // However, on another thread, we can't!///     assert!(window.window_handle().is_err());///     // We can use this function as an escape hatch.///     let handle = unsafe { window.window_handle_any_thread().unwrap() };/// Create an object that allows accessing the inner window handle in a thread-unsafe way./// It is possible to call [`window_handle_any_thread`] to get around Windows's thread/// affinity limitations. However, it may be desired to pass the [`Window`] into something/// that requires the [`HasWindowHandle`] trait, while ignoring thread affinity limitations./// This function wraps anything that implements `Borrow<Window>` into a structure that/// uses the inner window handle as a mean of implementing [`HasWindowHandle`]. It wraps/// `Window`, `&Window`, `Arc<Window>`, and other reference types./// [`window_handle_any_thread`]: WindowExtWindows::window_handle_any_thread/// [`HasWindowHandle`]: rwh_06::HasWindowHandleWindowBorrowExtWindows/// Additional methods for anything that dereference to [`Window`]./// This only works when [`WindowAttributes::with_parent_window`] isn't called or set to `None`./// Can be used in combination with/// [`WindowExtWindows::set_enable(false)`][WindowExtWindows::set_enable] on the owner/// window to create a modal dialog box./// The menu must have been manually created beforehand with [`CreateMenu`] or similar./// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how/// the menus look. If you use this, it is recommended that you combine it with/// `with_theme(Some(Theme::Light))` to avoid a jarring effect./// Enables or disables drag and drop support (enabled by default). Will interfere with other/// crates that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED`/// instead of `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still/// attempt to initialize COM API regardless of this option. Currently only fullscreen mode/// does that, but there may be more in the future. If you need COM API with/// `COINIT_MULTITHREADED` you must initialize it before calling any winit functions. See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information./// Whether show or hide the window icon in the taskbar.with_class_namewith_system_backdropwith_clip_children/// This sets or removes `WS_CLIPCHILDREN` style.with_border_colorwith_title_background_colorwith_title_text_colorwith_corner_preferenceWindowAttributesExtWindows/// Additional methods on `WindowAttributes` that are specific to Windows.//! # Windows//! The supported OS version is Windows 7 or higher, though Windows 10 is//! tested regularly./// A desktop feature. This can include a single window containing desktop icons with the same/// dimensions as the screen, allowing the desktop environment to have full control of the/// desktop, without the need for proxying root window clicks./// A dock or panel feature. Typically a Window Manager would keep such windows on top of all/// other windows./// Toolbar windows. "Torn off" from the main application./// Pinnable menu windows. "Torn off" from the main application./// A small persistent utility window, such as a palette or toolbox.Splash/// The window is a splash screen displayed as an application is starting up./// This is a dialog window./// A dropdown menu that usually appears when the user clicks on an item in a menu bar./// This property is typically used on override-redirect windows./// A popup menu that usually appears when the user right clicks on an object./// A tooltip window. Usually used to show additional information when hovering over an object/// with the cursor. This property is typically used on override-redirect windows./// The window is a notification./// This should be used on the windows that are popped up by combo boxes./// This indicates the window is being dragged./// This is a normal, top-level window./// X window type. Maps directly to/// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).XlibErrorHook/// The first argument in the provided hook will be the pointer to `XDisplay`/// and the second one the pointer to [`XErrorEvent`]. The returned `bool` is an/// indicator whether the error was handled by the callback./// [`XErrorEvent`]: https://linux.die.net/man/3/xerroreventXVisualID/// A unique identifier for an X11 visual.XWindow/// A unique identifier for an X11 window.register_xlib_error_hook/// Hook to winit's xlib error handling callback./// This method is provided as a safe way to handle the errors coming from X11/// when using xlib in external crates, like glutin for GLX access. Trying to/// handle errors by speculating with `XSetErrorHandler` is [`unsafe`]./// **Be aware that your hook is always invoked and returning `true` from it will/// prevent `winit` from getting the error itself. It's wise to always return/// `false` if you're not initiated the `Sync`.**/// [`unsafe`]: https://www.remlab.net/op/xlib.shtml/// True if the [`ActiveEventLoop`] uses X11.ActiveEventLoopExtX11/// Additional methods on [`ActiveEventLoop`] that are specific to X11./// True if the [`EventLoop`] uses X11.EventLoopExtX11/// Additional methods on [`EventLoop`] that are specific to X11.with_x11/// Force using X11.EventLoopBuilderExtX11/// Additional methods on [`EventLoopBuilder`] that are specific to X11.WindowExtX11/// Additional methods on [`Window`] that are specific to X11.with_x11_visual/// Create this window with a specific X11 visual.with_x11_screen/// Build window with the given `general` and `instance` names./// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the/// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "instance",/// "general"`.with_override_redirect/// Build window with override-redirect flag; defaults to false.with_x11_window_type/// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`.with_base_size/// Build window with base size hint./// # use winit::dpi::{LogicalSize, PhysicalSize};/// # use winit::platform::x11::WindowAttributesExtX11;/// // Specify the size in logical dimensions like this:/// Window::default_attributes().with_base_size(LogicalSize::new(400.0, 200.0));/// // Or specify the size in physical dimensions like this:/// Window::default_attributes().with_base_size(PhysicalSize::new(400, 200));with_embed_parent_window/// Embed this window into another parent window./// use winit::window::Window;/// use winit::event_loop::ActiveEventLoop;/// use winit::platform::x11::{XWindow, WindowAttributesExtX11};/// # fn create_window(event_loop: &ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {/// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;/// let window_attributes = Window::default_attributes().with_embed_parent_window(parent_window_id);/// let window = event_loop.create_window(window_attributes)?;WindowAttributesExtX11/// Additional methods on [`WindowAttributes`] that are specific to X11.MonitorHandleExtX11/// Additional methods on `MonitorHandle` that are specific to X11.//! # X11KeyMapCharto_physical_keycharacter_map_and_combine_key/// Tries to map the `key_event` to a `KeyMapChar` containing a unicode character or dead key accent/// This takes a `KeyEvent` and looks up its corresponding `KeyCharacterMap` and/// uses that to try and map the `key_code` + `meta_state` to a unicode/// character or a dead key that can be combined with the next key press.to_locationAndroidAppWakerInputStatusMainEventRootAELCursorGrabModeImePurposeWindowButtonsWindowLevelHAS_FOCUSmin_timeout/// Returns the minimum `Option<Duration>`, taking into account that `None`/// equates to an infinite timeout, not a zero timeout (so can't just use/// `Option::min`)PeekableReceiverfrom_recvhas_incomingSharedFlagSetterSharedFlagget_and_reset// Used for queuing redraws from arbitrary threads. We don't care how many// times a redraw is requested (so don't actually need to queue any data,// we just need to know at the start of a main loop iteration if a redraw// was queued and be able to read and clear the state atomically)RedrawRequesterredraw_flaguser_events_senderuser_events_receiverloop_running// must wake looper whenever something gets sent// Dispatched `NewEvents<Init>`ignore_volume_keyscombining_accentsingle_iterationhandle_input_eventpoll_events_with_timeoutredraw_requesterPlatformSpecificWindowAttributesmaybe_queue_on_mainmaybe_wait_on_mainpre_present_notifyset_resize_incrementsset_transparentset_blurset_enabled_buttonsenabled_buttonsset_window_levelset_ime_cursor_areaset_ime_allowedset_ime_purposefocus_windowset_cursor_hittest// Allow the usage of HasRawWindowHandle inside this functionset_themeset_content_protectedNSResponderNSObjectWindowDelegateCoreMonitorHandleCoreWindowWinitWindow/// The window only keeps a weak reference to this, so we must keep it around here.surface_sizerequest_surface_sizeset_min_surface_sizeset_max_surface_sizesurface_resize_incrementsset_surface_resize_incrementsrwh_06_display_handlerwh_06_window_handleobjc2_ui_kitUIApplicationsend_occluded_event_for_all_windowsrunloopNSObjectProtocolNSProcessInfoUICoordinateSpaceUIViewUIWindowWinitUIWindowRootActiveEventLoopHandlePendingUserEventsqueued_handlerwaiting_handlerhas_terminatedUIDeviceUIScreenAppDelegatemap_user_event/// There is no way to detect which device that performed a certain event in/// UIKit (i.e. you can't differentiate between different external keyboards,/// or whether it was the main touchscreen, assistive technologies, or some/// other pointer device that caused a touch event).IsRetainableUIScreenModeRootVideoModeHandleMainThreadBoundDelegateImpls// Workaround for `MainThreadBound` implementing almost no traitsNSSetscreen_comparisons// Test that UIScreen pointer comparisons are correct.UIEventUIGestureRecognizerUIGestureRecognizerDelegateUIGestureRecognizerStateUIKeyInputUIPanGestureRecognizerUIPinchGestureRecognizerUIResponderUIRotationGestureRecognizerUITapGestureRecognizerUITextInputTraitsUITouchUITraitEnvironmentpinch_gesture_recognizerdoubletap_gesture_recognizerrotation_gesture_recognizerpan_gesture_recognizerrotation_last_delta// for iOS delta references the start of the Gesturepinch_last_deltapan_last_deltaWinitViewStatehandle_toucheshandle_insert_texthandle_delete_backwardWinitViewUIStatusBarStyleUIViewControllerpreferred_status_bar_styleprefers_home_indicator_auto_hiddensupported_orientationsViewControllerStateset_prefers_home_indicator_auto_hiddenset_supported_interface_orientationsWinitViewController/// Show / hide the keyboard. To show the keyboard, we call `becomeFirstResponder`,/// requesting focus for the [WinitView]. Since [WinitView] implements/// [objc2_ui_kit::UIKeyInput], the keyboard will be shown./// <https://developer.apple.com/documentation/uikit/uiresponder/1621113-becomefirstresponder>rect_to_screen_spacerect_from_screen_spaceXkbContextXKBCHxkb_compose_compile_flagsxkb_compose_feed_resultxkb_compose_statexkb_compose_state_flagsxkb_compose_statusxkb_compose_tableXkbComposeTableXkbComposeState/// Create new state with the given compose table.ComposeStatus//! XKB compose handling.XKB_MOD_INVALIDxkb_keycode_txkb_keymapxkb_keymap_compile_flagsxkb_layout_index_txkb_mod_index_tXKBXHXKBHraw_keycode_to_physicalkey/// Map the raw X11-style keycode to the `KeyCode` enum./// X11-style keycodes are offset by 8 from the keycodes the Linux kernel uses.scancode_to_physicalkey/// Map the linux scancode to Keycode./// Both X11 and Wayland use keys with `+ 8` offset to linux scancode.physicalkey_to_scancodekeysym_to_keykeysym_location_mods_indicesModsIndices_core_keyboard_idXkbKeymapfrom_x11_keymapmods_indicesfirst_keysym_by_levelkey_repeats/// Check whether the given key repeats.mod3mod5/// Modifier index in the keymap.mod_index_for_name//! XKB keymap.xkb_context_flagsxkbcommon_compose_handlexkbcommon_handleXkbCommonXkbCommonComposexkbcommon_x11_handleXkbStateRESET_DEAD_KEYS// TODO: Wire this up without using a static `AtomicBool`.XkbCommonX11XKBNotFound/// libxkbcommon is not availablecore_keyboard_id// NOTE: field order matters.compose_state1compose_state2_compose_tablefrom_x11_xkbkeymap_mutset_keymap_from_fdset_keymap_from_x11key_contextKeyContext/// Key builder context with the user provided xkb state.key_context_with_state/// Should be used when the original context must not be altered.process_key_eventkeysym_to_utf8_rawKeyEventResults// The current behaviour makes it so composing a character overrides attempts to input a// control character with the `Ctrl` key. We can potentially add a configuration option// if someone specifically wants the oppsite behaviour.composed_textmake_string_with/// Shared logic for constructing a string with `xkb_compose_state_get_utf8` and/// `xkb_state_key_get_utf8`.byte_slice_to_smol_str// NOTE: This is track_caller so we can have more informative line numbers when loggingxkb_state_componentnew_waylandnew_x11get_one_sym_rawdepressed_modifiersxkb_mod_mask_tlatched_modifierslocked_modifiersget_utf8_rawreload_modifiers/// Reload the modifiers.mod_name_is_active/// Check if the modifier is active within xkb./// Also known as the "windows" key on most keyboards/// Represents the current state of the keyboard modifiers/// Each field of this struct represents a modifier and is `true` if this modifier is active./// For some modifiers, this means that the key is currently pressed, others are toggled/// (like caps lock).//! XKB state.X11ErrorXWindowTypeforced_backendactivation_tokenX11WindowAttributesscreen_idx11_window_typesembed_window/// The parent window to embed this window into.X11_BACKENDx11_or_wayland/// `x11_or_wayland!(match expr; Enum(foo) => foo.something())`/// expands to the equivalent of/// match self {///    Enum::X(foo) => foo.something(),///    Enum::Wayland(foo) => foo.something(),/// The result can be converted to another enum by adding `; as AnotherEnum`XLIB_ERROR_HOOKS/// Hooks for X11 errors.new_wayland_any_threadnew_x11_any_threadset_exit_codeIOResultCalloopErrorPlatformActiveEventLoopRootCustomCursorEventSinkWindowCompositorUpdateWinitStateFrameCallbackStatelogical_to_physical_roundedWaylandDispatcher/// Has `run` or `run_on_demand` been called or a call to `pump_events` that starts the loopbuffer_sinkcompositor_updateswindow_ids/// Sender of user events.pending_user_events// XXX can't remove RefCell out of here, unless we can plumb generics into the `Window`, which// we don't really want, since it'll break public API by a lot./// Pending events from the user.wayland_dispatcher/// The Wayland dispatcher to has raw access to the queue when needed, such as/// when creating a new window./// Connection to the wayland server./// Event loop window target.// XXX drop after everything else, just to be safe./// Calloop's event loop./// The Wayland event loop.loop_dispatchevent_loop_awakener/// The event loop wakeup source./// The main queue used by the event loop./// The application's latest control_flow state/// The application's exit state.// TODO remove that RefCell once we can pass `&mut` in `Window::new`./// Winit state./// Dispatcher of Wayland events.//! The event-loop routines./// A handle that can be sent across the threads and used to wake up the `EventLoop`.//! An event loop proxy.PlatformDeviceIdwindow_events/// An event loop's sink to deliver events from the Wayland event callbacks/// to the winit's user./// Return `true` if there're pending events.push_device_event/// Add new device event to a queue.push_window_event/// Add new window event to a queue.//! An event loop's sink to deliver events from the Wayland event callbacks./// Error connecting to the socket./// Error binding the global.// Bind error./// Error during the dispatching the event queue.Calloop/// Calloop error./// Wayland/// Dummy device id, since Wayland doesn't have device events.make_wid/// Get the WindowId out of the surface./// The default routine does floor, but we need round on Wayland.//! Winit's Wayland backend.PlatformVideoModeHandleWlKeyboardEventWlKeyStateWlKeymapFormat/// The underlying WlKeyboard./// Loop handle to handle key repeat./// The state of the keyboard./// The information about the repeat rate obtained from the compositor./// The token of the current handle inside the calloop's event loop./// The current repeat raw key./// The state of the keyboard on the current seat.gap/// The time between the key repeats./// The default repeat rate is 25 keys per second with the delay of 200ms./// The values are picked based on the default in various compositors and Xorg./// The currently focused window surface. Could be `None` on bugged compositors, like mutter./// The seat used to create this keyboard./// Keyboard user data.key_input//! The keyboard input handling.SeatCapabilityWinitPointerDataWinitPointerDataExtTextInputStateZwpTextInputV3ExtTextInputDataTouchPoint/// The pointer bound on the seat./// The touch bound on the seat.touch_map/// The mapping from touched points to the surfaces they're present./// The text input bound on the seat./// The relative pointer bound on the seat.keyboard_state/// The keyboard bound on the seat./// The current modifiers state on the seat.modifiers_pending/// Whether we have pending modifiers.WinitSeatStateon_keyboard_destroy//! Seat handling.WinitPointerDataInner/// The inner winit data associated with the pointer.sctk_data/// The data required by the sctk.unlock_pointerunconfine_pointer/// Seat associated with this pointer.focused_window/// Active window./// Last button serial./// Last enter serial.set_locked_cursor_positionlocked_pointer/// The associated locked pointer.confined_pointer/// The associated confined pointer./// Serial of the last button event./// Currently focused window./// Current axis phase.wayland_button_to_winit/// Convert the Wayland button into winit.winit_data//! The pointer events./// Wrapper around the relative pointer./// Create new relative pointer manager.//! Relative pointer.TextInputEventtext_input_managerset_content_type_by_purposeTextInputDataInner/// The Data associated with the text input./// The `WlSurface` we're performing input to.pending_commit/// The commit to submit on `done`.pending_preedit/// The preedit to submit on `done`./// The state of the preedit./// The surface on which the point is present./// The location of the point on the surface./// The state of the touch point.//! Touch handling.kwin_blurKWinBlurManagerwp_fractional_scalingFractionalScalingManagerViewporterStateXdgActivationStateWindowRequestsregistry_state/// The WlRegistry./// The state of the WlOutput handling.compositor_state/// The compositor state which is used to create new windows and regions.subcompositor_state/// The state of the subcompositor./// The seat state responsible for all sorts of input./// The shm for software buffers, such as cursors.custom_cursor_pool/// The pool where custom cursors are allocated.xdg_shell/// The XDG shell that is used for windows./// The currently present windows.window_requests/// The requests from the `Window` to EventLoop, such as close operations and redraw requests.window_events_sink/// The events that were generated directly from the window.window_compositor_updates/// The update for the `windows` coming from the compositor./// Currently handled seats.pointer_surfaces/// Currently present cursor surfaces.text_input_state/// The state of the text input on the client.monitors/// Observed monitors.events_sink/// Sink to accumulate window events from the compositor, which is latter dispatched in/// event loop run./// Xdg activation./// Relative pointer./// Pointer constraints to handle pointer locking and confining.viewporter_state/// Viewporter state on the given window.fractional_scaling_manager/// Fractional scaling manager.kwin_blur_manager/// KWin blur manager./// Loop handle to re-register event sources, such as keyboard repeat.dispatched_events/// Whether we have dispatched events to the user thus we want to/// send `AboutToWait` and normally wakeup the user./// Winit's Wayland state.queue_close/// The id of the window this updates belongs to.resized/// New window size.scale_changed/// New scale factor.// The window update coming from the compositor.SelectedCursor//! Handling of KDE-compatible blur.//! Wayland protocol implementation boilerplate.FractionalScalingEventSCALE_DENOMINATOR/// The scaling factor denominator./// The surface used for scaling.FractionalScaling/// Create new viewporter.fractional_scaling//! Handling of the fractional scaling./// Viewporter./// Get the viewport for the given object.//! Handling of the wp-viewporter.ActivationTokenEventXdgActivationTokenData/// Request user attention for the given surface.Obtain/// Get a token to be passed outside of the winit./// The data associated with the activation request.//! Handling of xdg activation, which is used for user attention requests.SctkWindowPlatformMonitorHandle/// Reference to the underlying SCTK window./// The state of the window./// Compositor to handle WlRegion stuff./// The wayland display used solely for raw window handle./// Xdg activation to request user attention.attention_requested/// The state of the requested attention from the `xdg_activation`./// Handle to the main queue to perform requests./// Window requests to the event loop./// Source to wake-up the event-loop for window requests./// The event sink to deliver synthetic events./// The Wayland window./// Set the minimum inner size for the window./// Set the maximum inner size for the window./// The window was closed.redraw_requested/// Redraw Requested./// The request from the window to the event loop.take_closedtake_redraw_requested/// use winit::window::Theme;/// assert_eq!("dark".try_into(), Ok(Theme::Dark));/// assert_eq!("lIghT".try_into(), Ok(Theme::Light));//! The Wayland window.XdgWindowStateXdgResizeEdgeWinitFrameMIN_WINDOW_SIZE// Minimum window inner size./// The connection to Wayland server./// The `Shm` to set cursor.// A shared pool where to allocate custom cursors.last_configure/// The last received configure./// The pointers observed on the window.selected_cursor/// Whether the cursor is visible./// Pointer constraints to lock/confine pointer./// Queue handle./// Theme variant./// The current window title.seat_focus// NOTE: we can't use simple counter, since it's racy when seat getting destroyed and new// is created, since add/removed stuff could be delivered a bit out of order./// Seats that has keyboard focus on that window./// The scale factor of the window./// Whether the window is transparent./// The state of the compositor to create WlRegions.cursor_grab_modeGrabState/// The current cursor grabbing mode.ime_allowed/// Whether the IME input is allowed for that window.ime_purpose/// The current IME purpose.text_inputs/// The text inputs observed on the window./// The inner size of the window, as in without client side decorations.csd_fails/// Whether the CSD fail to create, so we don't try to create them on each iteration./// Whether we should decorate the frame.min_inner_size/// Min size.max_inner_sizestateless_size/// The size of the window when no states were applied to it. The primary use for it/// is to fallback to original window size, before it was maximized, if the compositor/// sends `None` for the new size in the configure.initial_size/// Initial window size provided by the user. Removed on the first/// configure.frame_callback_state/// The state of the frame callback.blur_managerhas_pending_move/// Whether the client side decorations have pending move operations./// The value is the serial of the event triggered moved./// The underlying SCTK window.// NOTE: The spec says that destroying parent(`window` in our case), will unmap the// subsurfaces. Thus to achieve atomic unmap of the client, drop the decorations// frame after the `window` is dropped. To achieve that we rely on rust's struct// field drop order guarantees./// The window frame, which is created from the configure request./// The state of the window which is being updated from the [`WinitState`]./// Create new window state.apply_on_pointer/// Apply closure on the given pointer./// Get the current state of the frame callback.frame_callback_received/// The frame callback was received, but not yet sent to the user.frame_callback_reset/// Reset the frame callbacks state.request_frame_callback/// Request a frame callback if we don't have one for this window in flight.inner_size_bounds/// Compute the bounds for the inner size of the surface.is_stateless/// Start interacting drag resize./// Start the window drag.frame_click/// Tells whether the window should be closed.frame_point_leftframe_point_moved// Move the point over decorations./// Get the stored resizable state./// Set the resizable state on the window./// Returns `true` when the state was applied./// Whether the window is focused by any seat./// Whether the IME is allowed./// Get the size of the window.is_configured/// Whether the window received initial configure event from the compositor./// Get the outer size of the window.pointer_entered/// Register pointer on the top-level.pointer_left/// Pointer has left the top-level.refresh_frame/// Refresh the decorations frame if it's present returning whether the client should redraw.reload_cursor_style/// Reload the cursor style on the given window.reload_transparency_hint/// Reissue the transparency hint to the compositor./// Try to resize the window when the user can do so./// Resize the window to the new inner size./// Get the scale factor of the window./// Set the cursor icon.set_custom_cursor/// Set the custom cursor icon.apply_custom_cursor/// Set maximum inner window size./// Set the CSD theme./// The current theme for CSD decorations./// Set the cursor grabbing state on the top-level.reload_min_max_hints/// Reload the hints for minimum and maximum sizes.set_cursor_grab_inner/// Set the grabbing state on the surface./// Set the position of the cursor./// Set the visibility state of the cursor.set_decorate/// Whether show or hide client side decorations.add_seat_focus/// Add seat focus for the window.remove_seat_focus/// Remove seat focus from the window./// Returns `true` if the requested state was applied./// Set the IME position./// Set the IME purpose./// Get the IME purpose./// Set the scale factor for the given window./// Make window background blurred/// Set the window title to a new value./// This will automatically truncate the title to something meaningful./// Mark the window as transparent.text_input_entered/// Register text input on the top-level.text_input_left/// The text input left the top-level./// Get the cached title.user_grab_mode/// The grab mode requested by the user.current_grab_mode/// The current grab mode./// The state of the cursor grabs./// No frame callback was requested./// The frame callback was requested, but not yet arrived, the redraw events are throttled./// The callback was marked as done, and user could receive redraw requestedinto_sctk_adwaita_config// NOTE: Rust doesn't allow `From<Option<Theme>>`.//! The state of the window, which is shared with the event-loop.VoidCookie/// "Request" a new activation token from the server.remove_activation_token/// Finish launching a window with the given startup ID./// Send a startup notification message to the window manager.quote_string/// Quote a literal string as per the startup notification specification.push_display/// Push a `Display` implementation to the buffer.properly_escapes_x11_messages//! X11 activation handling.//! X11 has a "startup notification" specification similar to Wayland's, see this URL://! <https://specifications.freedesktop.org/startup-notification-spec/startup-notification-latest.txt>AtomsCookier" The atoms used by `winit`"WM_CHANGE_STATEWM_CLIENT_MACHINEWM_DELETE_WINDOWWM_PROTOCOLSWM_STATEXIM_SERVERS_NET_WM_ICON_NET_WM_MOVERESIZE_NET_WM_NAME_NET_WM_PID_NET_WM_PING_NET_WM_STATE_NET_WM_STATE_ABOVE_NET_WM_STATE_BELOW_NET_WM_STATE_FULLSCREEN_NET_WM_STATE_HIDDEN_NET_WM_STATE_MAXIMIZED_HORZ_NET_WM_STATE_MAXIMIZED_VERT_NET_WM_WINDOW_TYPE_NET_STARTUP_INFO_BEGIN_NET_STARTUP_INFO_NET_STARTUP_ID_NET_WM_WINDOW_TYPE_DESKTOP_NET_WM_WINDOW_TYPE_DOCK_NET_WM_WINDOW_TYPE_TOOLBAR_NET_WM_WINDOW_TYPE_MENU_NET_WM_WINDOW_TYPE_UTILITY_NET_WM_WINDOW_TYPE_SPLASH_NET_WM_WINDOW_TYPE_DIALOG_NET_WM_WINDOW_TYPE_DROPDOWN_MENU_NET_WM_WINDOW_TYPE_POPUP_MENU_NET_WM_WINDOW_TYPE_TOOLTIP_NET_WM_WINDOW_TYPE_NOTIFICATION_NET_WM_WINDOW_TYPE_COMBO_NET_WM_WINDOW_TYPE_DND_NET_WM_WINDOW_TYPE_NORMALXdndAwareXdndEnterXdndLeaveXdndDropXdndPositionXdndStatusXdndActionPrivateXdndSelectionXdndFinishedXdndTypeListTextUriList_GTK_THEME_VARIANT_MOTIF_WM_HINTS_NET_ACTIVE_WINDOW_NET_CLIENT_LIST_NET_FRAME_EXTENTS_NET_SUPPORTED_NET_SUPPORTING_WM_CHECK_XEMBED_XSETTINGS_SETTINGSr" Indices into the `Atoms` struct."AtomNameatom_from// Make sure `None` is still defined.//! Collects every atom used by the platform implementation.DndNoneCookieResultExtDndStateDndDataParseErrorEmptyDataHostnameSpecifiedUnexpectedProtocolUnresolvablePathxconn// Populated by XdndEnter event handlertype_list// Populated by XdndPosition event handler// Populated by SelectionNotify event handler (triggered by XdndPosition event handler)send_statussend_finishedget_type_listconvert_selectionXkbIdModMaskx11_utilsExtensionInformationimeImeEventImeEventReceiverImeRequestGenericEventCookiemkdidmkwidImeReceiverScrollOrientationMAX_MOD_REPLAY_LEN/// The maximum amount of X modifiers to replay.KEYCODE_OFFSET/// The X11 documentation states: "Keycodes lie in the inclusive range `[8, 255]`".ime_receiverime_event_receiverrandr_event_offsetxi2extxkbextnum_touch// Number of touch events currently in progressheld_key_press// This is the last pressed key that is repeatable (if it hasn't been// released).// Used to detect key repeats.first_touch// Currently focused window belonging to this process/// Latest modifiers we've sent for the user to trigger change in event.xfiltered_modifiers// Track modifiers based on keycodes. NOTE: that serials generally don't work for tracking// since they are not unique and could be duplicated in case of sequence of key events is// delivered at near the same time.xmodmapModifierKeymapEventProcessorfilter_event/// XFilterEvent tells us when an event has been discarded by the input method./// Specifically, this involves all of the KeyPress events in compose/pre-edit sequences,/// along with an extra copy of the KeyRelease events. This also prevents backspace and/// arrow keys from being detected twice.process_xeventpoll_one_eventinit_device// NOTE: we avoid `self` to not borrow the entire `self` as not mut./// Get the platform window target.window_target_mutselection_notifyconfigure_notifyreparent_notify/// This is generally a reliable way to detect when the window manager's been/// replaced, though this event is only fired by reparenting window managers/// (which is almost all of them). Failing to correctly update WM info doesn't/// really have much impact, since on the WMs affected (xmonad, dwm, etc.) the only/// effect is that we waste some time trying to query unsupported properties.map_notifyproperty_notifyvisibility_notifyxinput_key_inputsend_synthic_modifier_from_corexinput2_button_inputxinput2_mouse_motionxinput2_mouse_enterxinput2_mouse_leftxinput2_focusedxinput2_unfocusedxinput2_touchxinput2_raw_button_inputxinput2_raw_mouse_motionxinput2_raw_key_inputxinput2_hierarchy_changedxkb_eventupdate_mods_from_xinput2_eventupdate_mods_from_queryupdate_mods_from_core_eventcore_keyboard_group// Bits 13 and 14 report the state keyboard group.xkb_mod_mask_from_coresend_modifiers/// Send modifiers for the active window./// The event won't be sent when the `modifiers` match the previously `sent` modifiers value,/// unless `force` is passed. The `force` should be passed when the active window changes.handle_pressed_keysprocess_dpi_changewindow_existsis_first_touchImeContextImeContextCreationErrorclose_imImeInnerPotentialInputMethodsxim_set_callbackset_instantiate_callback// Set a callback for when an input method matching the current locale modifiers becomes// available. Note that this has nothing to do with what input methods are open or able to be// opened, and simply uses the modifiers that are set when the callback is set.// * This is called per locale modifier, not per input method opened with that locale modifier.// * Trying to set this for multiple locale modifiers causes problems, i.e. one of the rebuilt input//   contexts would always silently fail to use the input method.unset_instantiate_callbackset_destroy_callbackReplaceImErrorMethodOpenFailed// Boxed to prevent large error typeContextCreationFailedSetDestroyCallbackFailedreplace_im// Attempt to replace current IM (which may or may not be presently valid) with a new one. This// includes replacing all existing input contexts and free'ing resources as necessary. This only// modifies existing state if all operations succeed.xim_instantiate_callback// This field is unsupplied.xim_destroy_callback// This callback is triggered when the input method is closed on the server end. When this// happens, XCloseIM/XDestroyIC doesn't need to be called, as the resources have already been// free'd (attempting to do so causes our connection to freeze).XIMStyleImeEventSender/// Got the error from Xlib./// Got null pointer from Xlib but without exact reason./// IME creation error.XIMProcNonnull/// The callback used by XIM preedit functions.create_xim_callback/// Wrapper for creating XIM callbacks.preedit_start_callback/// The server started preedit.preedit_done_callback/// Done callback is used when the preedit should be hidden.calc_byte_positionpreedit_draw_callback/// Preedit text information to be drawn inline by the client.preedit_caret_callback/// Handling of cursor movements in preedit text.start_callbackdone_callbackdraw_callbackcaret_callbackPreeditCallbacks/// Struct to simplify callback creation and latter passing into Xlib XIM.event_senderImeContextClientDataicic_spot_client_data// Since the data is passed shared between X11 XIM callbacks, but couldn't be directly free// from there we keep the pointer to automatically deallocate it.// XXX: this struct doesn't destroy its XIC resource when dropped.// This is intentional, as it doesn't have enough information to know whether or not the context// still exists on the server. Since `ImeInner` has that awareness, destruction must be handled// through `ImeInner`.create_none_iccreate_preedit_iccreate_nothing_icunfocusset_spot// Set the spot for preedit text. Setting spot isn't working with libX11 when preedit callbacks// are being used. Certain IMEs do show selection window, but it's placed in bottom left of the// window and couldn't be changed.// For me see: https://bugs.freedesktop.org/show_bug.cgi?id=1580.destroy_icpotential_input_methodsdestroy_callback// WARNING: this is initially zeroed!// Indicates whether or not the input method was destroyed on the server end// (i.e. if ibus/fcitx/etc. was terminated/restarted)close_im_if_necessarydestroy_ic_if_necessarydestroy_all_contexts_if_necessaryIntoStringErrorGLOBAL_LOCKopen_impreedit_stylenone_styleXIM_PREEDIT_STYLEXIM_NOTHING_STYLEXIM_NONE_STYLE/// Preedit callbacks./// Nothing./// No IME./// Style of the IME context.count_stylessupported_stylesXIMStylesInputMethodResultXModifiers/// Input method used locale modifier from `XMODIFIERS` environment variable./// Input method used internal fallback locale modifier./// Input method could not be opened using any locale modifier tried.GetXimServersErrorget_xim_servers// The root window has a property named XIM_SERVERS, which contains a list of atoms representing// the available XIM servers. For instance, if you're using ibus, it would contain an atom named// "@server=ibus". It's possible for this property to contain multiple atoms, though presumably// rare. Note that we replace "@server=" with "@im=" in order to match the format of locale// modifiers, since we don't want a user who's looking at logs to ask "am I supposed to set// XMODIFIERS to `@server=ibus`?!?"InputMethodNamesuccessfulPotentialInputMethodxmodifiers// On correctly configured systems, the XMODIFIERS environment variable tells us everything we// need to know.fallbacks// We have some standard options at our disposal that should ostensibly always work. For users// who only need compose sequences, this ensures that the program launches without a hitch// For users who need more sophisticated IME features, this is more or less a silent failure.// Logging features should be added in the future to allow both audiences to be effectively// served._xim_servers// For diagnostic purposes, we include the list of XIM servers that the server reports as// being available.// By logging this struct, you get a sequential listing of every locale modifier tried, where it// came from, and if it succeeded.// This resets the `successful` field of every potential input method, ensuring we have// accurate information when this struct is re-used by the destruction/instantiation callbacks.ImeSender/// Set IME spot position for given `window_id`./// Allow IME input for the given `window_id`./// Request to control XIM handler from the window.ImeCreationErrorOpenFailure// The actual meat of this struct is boxed away, since it needs to have a fixed location in// memory so we can pass a pointer to it around.// This pattern is used for various methods here:// Ok(_) indicates that nothing went wrong internally// Ok(true) indicates that the action was actually performed// Ok(false) indicates that the action is not presently applicableremove_contextsend_xim_spotis_ime_allowed// Important: all XIM calls need to happen from the same thread!IdsExhaustedLogicalErrorevent_processorxsettingsALL_DEVICES// Xinput constants not defined in x11rbALL_MASTER_DEVICESICONIC_STATEX11rbConnection/// The underlying x11rb connection that we are using.X11SourceWakeSenderwm_delete_windownet_wm_pingime_senderredraw_senderactivation_senderEventLoopStateredraw_receiveruser_receiveractivation_receiveruser_sender/// The current state of the event loop.x11_readiness/// The latest readiness state for the x11 file descriptordrain_eventsx_connection/// Returns the `XConnection` of this events loop.update_listen_device_events/// Update the device event based on window focus./// An error from the Xlib library./// An error that occurred while trying to connect to the X server./// An error that occurred over the connection medium./// An error that occurred logically on the X11 end.XidsExhausted/// The XID range has been exhausted./// Got `null` from an Xlib function without a reason.InvalidActivationToken/// Got an invalid activation token./// An extension that we rely on is not available.NoSuchVisual/// Could not find a matching X11 visual for this visualidXsettingsParse/// Unable to parse xsettings./// Failed to get property./// Generic sum error type for X11 errors./// Type alias for a void cookie.expect_then_ignore_error/// Unwrap the send error and ignore the result./// Extension trait for `Result<VoidCookie, E>`.scroll_axesScrollAxis// For master devices, this is the paired device (pointer <-> keyboard).// For slave devices, this is the master.reset_scroll_positionphysical_devicexinput_fp1616_to_floatFp1616/// Convert the raw X11 representation for a 32-bit floating point to a double.randrDISABLE_MONITOR_LIST_CACHING// Used for testing. This should always be committed as false.invalidate_cached_monitor_listCrtc/// The actual id/// The name of the monitor/// The size of the monitor/// The position of the monitor in the X screen/// If the monitor is the primary one/// The refresh rate used by monitor./// The DPI scale factorAaRect/// Used to determine which windows are on this monitor/// Supported video modes on this monitormode_refresh_rate_millihertzModeInfoScreenResourcesGetCrtcInfoReplyis_dummyget_monitor_for_windowquery_monitor_listselect_xrandr_input/// List of attached modes./// List of attached CRTCs.from_connectionfrom_get_screen_resources_replyGetScreenResourcesReplyfrom_get_screen_resources_current_replyGetScreenResourcesCurrentReplysend_client_msg// The window this is "about"; not necessarily this window// The window we're sending to/// XEvents of type GenericEvent store their actual data in an XGenericEventCookie data structure./// This is a wrapper to extract the cookie from a GenericEvent XEvent and release the cookie data/// once it has been processedas_event/// Borrow inner event data as `&T`./// ## SAFETY/// The caller must ensure that the event has the `T` inside of it.create_empty_cursorupdate_cursorCustomCursorInner// Friendly neighborhood axis-aligned rectangleget_overlapping_areaFrameExtentsfrom_borderFrameExtentsHeuristicPathUnsupportedNestedUnsupportedBorderedheuristic_pathFrameExtentsHeuristicinner_pos_to_outerinner_size_to_outertranslate_coordsTranslateCoordinatesReply// This is adequate for inner_positionget_geometryGetGeometryReply// This is adequate for inner_sizeget_frame_extentsis_top_levelget_parent_windowclimb_hierarchyget_frame_extents_heuristicStateOperation// _NET_WM_STATE_REMOVEToggle// _NET_WM_STATE_ADD// _NET_WM_STATE_TOGGLEas_atomhintsMwmHintsMotifHintsMWM_HINTS_FUNCTIONS// Motif WM hints are obsolete, but still widely supported.// https://stackoverflow.com/a/1909708MWM_HINTS_DECORATIONSMWM_FUNC_ALLMWM_FUNC_RESIZEMWM_FUNC_MOVEMWM_FUNC_MINIMIZEMWM_FUNC_MAXIMIZEMWM_FUNC_CLOSEmwmadd_funcremove_funcget_motif_hintsset_motif_hintsto_packed_argbCardinalto_cardinalsVIRTUAL_CORE_POINTERVIRTUAL_CORE_KEYBOARDTEXT_BUFFER_SIZE// A base buffer size of 1kB uses a negligible amount of RAM while preventing us from having to// re-allocate (and make another round-trip) in the *vast* majority of cases.// To test if `lookup_utf8` works correctly, set this to 1.select_xinput_eventsselect_xkb_eventsDeviceSpecquery_pointerXIQueryPointerReplylookup_utf8_innerlookup_utf8KeymapIterquery_keymapfirst_bitXSmartPointer// You're responsible for only passing things to this that should be XFree'd.// Returns None if ptr is null.client_msgwindow_propertywmmaybe_changeflush_requests// This is impoartant, so pay attention!// Xlib has an output buffer, and tries to hide the async nature of X from you.// This buffer contains the requests you make, and is flushed under various circumstances:// 1. `XPending`, `XNextEvent`, and `XWindowEvent` flush "as needed"// 2. `XFlush` explicitly flushes// 3. `XSync` flushes and blocks until all requests are responded to// 4. Calls that have a return dependent on a response (i.e. `XGetWindowProperty`) sync//    internally. When in doubt, check the X11 source; if a function calls `_XReply`, it flushes//    and waits.// All util functions that abstract an async function will return a `Flusher`.sync_with_server// Welcome to the util module, where we try to keep you from shooting yourself in the foot.// *results may varySHIFT_OFFSET// Offsets within XModifierKeymap to each set of keycodes.// We are only interested in Shift, Control, Alt, and Logo.// There are 8 sets total. The order of keycode sets is://     Shift, Lock, Control, Mod1 (Alt), Mod2, Mod3, Mod4 (Logo), Mod5// https://tronche.com/gui/x/xlib/input/XSetModifierMapping.htmlCONTROL_OFFSETALT_OFFSETLOGO_OFFSETNUM_MODSCtrlLogo// Maps keycodes to modifiers// Contains currently pressed modifier keys and their corresponding modifiersModifierKeyStatereset_from_x_connectionreset_from_x_keymapread_x_keyskey_presskey_release/// Recorded mouse delta designed to filter out noise.//! Utilities for handling mouse events.EnvVarDPIRandrNotSet/// Represents values of `WINIT_HIDPI_FACTOR`.calc_dpi_factorget_xft_dpi// Retrieve DPI from Xft.dpi propertyget_output_infoset_crtc_configget_crtc_modeCARDINAL_SIZEX11rbErrorFormatMismatchis_actual_property_typePROPERTY_BUFFER_SIZE// Number of 32-bit chunks to retrieve per iteration of get_property's inner loop.// To test if `get_property` works correctly, set this to 1.change_property/// Handle to the connection./// The window that we're fetching the property from./// The property that we're fetching./// The type of the property that we're fetching./// The offset of the next window, in 32-bit chunks./// The format of the type./// Keep a reference to `T`.PropIterator/// An iterator over the "windows" of the property that we are fetching./// Create a new property iterator.next_window/// Get the next window and append it to `data`./// Returns whether there are more windows to fetch.// 4k of RAM ought to be enough for anyone!MOVERESIZE_TOPLEFT// https://specifications.freedesktop.org/wm-spec/latest/ar01s04.html#idm46075117309248MOVERESIZE_TOPMOVERESIZE_TOPRIGHTMOVERESIZE_RIGHTMOVERESIZE_BOTTOMRIGHTMOVERESIZE_BOTTOMMOVERESIZE_BOTTOMLEFTMOVERESIZE_LEFTMOVERESIZE_MOVESUPPORTED_HINTS// This info is global to the window manager.WM_NAMEhint_is_supportedwm_name_is_one_ofupdate_cached_wm_infoget_supported_hintsget_wm_nameXKeyCode/// Track which keys are modifiers, so we can properly replay them when they were filtered.reload_from_x_connectionWmHintsWmSizeHintsWmSizeHintsSpecificationSKRegionWrapperX11MonitorHandleinner_position_rel_parentlast_monitordpi_adjusteddesired_fullscreen// Set when application calls `set_fullscreen` when window is not visiblerestore_position// Used to restore position after exiting fullscreendesktop_video_mode// Used to restore video mode after exiting fullscreencursor_hittest// Use `Option` to not apply hittest logic when it was never requested.YesWait// Waiting for VisibilityNotifyxwindowcursor_grabbed_mode/// Embed this window into a parent window.shared_state_lockset_window_typesset_theme_innerset_netwmset_fullscreen_hintset_fullscreen_inner// Called by EventProcessor when a VisibilityNotify event is receivedrefresh_dpi_for_monitor/// Refresh the API for the given monitor.set_minimized_innerset_maximized_innerset_decorations_innerset_maximizable_innertoggle_atomset_window_level_innerset_icon_innerunset_icon_innerupdate_cached_frame_extentsinvalidate_cached_frame_extentsouter_position_physicalinner_position_physicalset_position_innerset_position_physicalinner_size_physicalrequest_inner_size_physicalupdate_normal_hintsset_min_inner_size_physicalset_max_inner_size_physicaladjust_for_dpixlib_displayxlib_windowset_cursor_position_physical/// Moves the window while it is being dragged./// Resizes the window while it is being dragged.drag_initiate/// Initiates a drag operation while the left mouse button is pressed.generate_activation_tokencast_dimension_to_hint/// Cast a dimension value into a hinted dimension for `WmSizeHints`, clamping if too large.cast_physical_size_to_hint/// Use the above strategy to cast a physical size into a hinted size.cast_size_to_hint/// Use the above strategy to cast a size into a hinted size.resource_manager// TODO(notgull): I'd like to remove this, but apparently Xlib and Xinput2 are tied together// for some reason.xcb/// The manager for the XCB connection./// The `Option` ensures that we can drop it before we close the `Display`./// The atoms used by `winit`./// This is a large structure, so I've elected to Box it to make accessing the fields of/// this struct easier. Feel free to unbox it if you like kicking puppies./// The index of the default screen./// The last timestamp received by this connection.monitor_handles/// List of monitor handles./// The resource database.randr_version/// RandR version.xsettings_screen/// Atom for the XSettings screen.new_xsettings_screenxcb_connection/// Get the underlying XCB connection./// Get the list of atoms.default_screen_index/// Get the index of the default screen.default_root/// Get the default screen./// Get the resource database.reload_database/// Reload the resource database./// Get the latest timestamp./// Set the last witnessed timestamp./// Get the atom for Xsettings.XcbConversionError/// We encountered an error while converting the connection to XCB.// TODO: add better message.WrapConnectError/// A newtype wrapper around a `ConnectError` that can't be accessed by downstream libraries./// Without this, `x11rb` would become a public dependency.// We can't implement `source()` here or otherwise risk exposing `x11rb`.DPI_NAMEDPI_MULTIPLIERxsettings_dpi/// Get the DPI from XSettings./// Read over the settings in the block of data./// The name of the setting.SettingData/// The data contained in the setting./// A setting in the settings list./// The data contained in a setting./// Parse a new `SettingData`.SettingType/// Parser for the incoming byte stream./// Create a new parser./// Get a slice of bytes./// Skip some padding./// Get a single byte./// Get two bytes./// Get four bytes./// Endianness of the incoming data.NoMoreBytes/// Ran out of bytes./// Invalid type.BadType/// Bad setting type./// Parser errors.ran_outXSETTINGSparse_xsettingsassert_stringassert_int/// Tests for the XSETTINGS parser.//! Parser for the xsettings data format.//! Some of this code is referenced from [here].//! [here]: https://github.com/derat/xsettingsdApplicationDelegateNSApplicationDelegateNSRunningApplicationNSNotificationstop_app_immediatelydefault_menustop_on_launchstop_before_waitstop_after_waitstop_on_redrawis_launched/// Whether `applicationDidFinishLaunching:` has been run or not./// Whether an `EventLoop` is currently running./// Whether the user has requested the event loop to exit.// NOTE: This is strongly referenced by our `NSWindowDelegate` and our `NSView` subclass, and// as such should be careful to not add fields that, in turn, strongly reference those.// NOTE: This will, globally, only be run once, no matter how many// `EventLoop`s the user creates.will_terminate/// Place the event handler in the application delegate for the duration/// of the given closure.set_stop_on_launch/// If `pump_events` is called to progress the event loop then we/// bootstrap the event loop via `-[NSApplication run]` but will use/// `CFRunLoopRunInMode` for subsequent calls to `pump_events`.set_stop_before_waitset_stop_after_waitset_stop_on_redrawset_wait_timeoutinternal_exit/// Clears the `running` state and resets the `control_flow` state when an `EventLoop` exits./// NOTE: that if the `NSApplication` has been launched then that state is preserved,/// and we won't need to re-launch the app if subsequent EventLoops are run.set_is_runningmaybe_queue_window_eventhandle_window_eventmaybe_queue_device_eventmaybe_queue_eventdispatch_init_events/// dispatch `NewEvents(Init)` + `Resumed`// Called by RunLoopObserver after finishing waiting for new events// Called by RunLoopObserver before waiting for new events/// Returns the minimum `Option<Instant>`, taking into account that `None`NSBitmapImageRepNSCursorNSDeviceRGBColorSpacens_stringNSNumber// SAFETY: NSCursor is immutable and thread-safe// TODO(madsmtm): Put this logic in objc2-app-kit itselfcursor_from_imagedefault_cursortry_cursor_from_selectordef_undocumented_cursor// Note that loading `busybutclickable` with this code won't animate// the frames; instead you'll just get them all in a column.webkit_movewebkit_cellcursor_from_icon/// Ignores ALL modifiers.// Ignores all modifiers except for SHIFT (yes, even ALT is ignored)./// Create `KeyEvent` for the given `NSEvent`./// This function shouldn't be called when the IME input is in process.// The values are from the https://github.com/apple-oss-distributions/IOHIDFamily/blob/19666c840a6d896468416ff0007040a10b7b46b8/IOHIDSystem/IOKit/hidsystem/IOLLEvent.h#L258-L259lalt_pressedralt_presseddummy_eventEventHandlerData/// This can be in the following states:/// - Not registered by the event loop (None)./// - Present (Some(handler))./// - Currently executing the handler / in use (RefCell borrowed).'handler/// Set the event loop handler for the duration of the given closure./// This is similar to using the `scoped-tls` or `scoped-tls-hkt` crates/// to store the handler in a thread local, such that it can be accessed/// from within the closure.WinitApplication/// Overwrites the current state if the current state is not panicking/// Store a reference to the application for convenience./// We intentionally don't store `WinitApplication` since we want to have/// the possibility of swapping that out at some point./// The application delegate that we've registered./// The delegate is only weakly referenced by NSApplication, so we must/// keep it around here as well.// Event sender and receiver, used for EventLoopProxy.// NB: we don't base this on `pump_events` because for `MacOs` we can't support// `pump_events` elegantly (we just ask to run the loop for a "short" amount of// time and so a layered implementation would end up using a lot of CPU due to// redundant wake ups.CGSMainConnectionID// Wildly used private APIs; Apple uses them for their Terminal.app.CGSSetWindowBackgroundBlurRadiuskCGNumReservedWindowLevelskCGNumReservedBaseWindowLevelskCGBaseWindowLevelkCGMinimumWindowLevelkCGMaximumWindowLevelkCGDesktopWindowLevelkCGDesktopIconWindowLevelkCGBackstopMenuLevelkCGNormalWindowLevelkCGFloatingWindowLevelkCGTornOffMenuWindowLevelkCGModalPanelWindowLevelkCGUtilityWindowLevelkCGDockWindowLevelkCGMainMenuWindowLevelkCGStatusWindowLevelkCGPopUpMenuWindowLevelkCGOverlayWindowLevelkCGHelpWindowLevelkCGDraggingWindowLevelkCGScreenSaverWindowLevelkCGAssistiveTechHighWindowLevelkCGCursorWindowLevelwindow_level// CGWindowLevel.h// Note: There are two different things at play in this header:// `CGWindowLevel` and `CGWindowLevelKey`.// It seems like there was a push towards using "key" values instead of the// raw window level values, and then you were supposed to use// `CGWindowLevelForKey` to get the actual level.// But the values that `NSWindowLevel` has are compiled in, and as such has// to remain ABI compatible, so they're safe for us to hardcode as well.KeyEquivalentCFUUIDGetUUIDBytesCFUUIDCGDisplayCopyDisplayModeMonitorUuid/// Internal comparisons of [`MonitorHandle`]s are done first requesting a UUID for the handle.// TODO: Be smarter about this:// <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>get_display_idblock2// without that, LoopExiting would  get sent after AboutToWaitqueue_closure/// Submit a closure to run on the main thread as the next step in the run loop, before other/// event sources are processed./// This is used for running event handlers, as those are not allowed to run re-entrantly./// This queuing could be implemented in the following several ways with subtle differences in/// timing. This list is sorted in rough order in which they are run:/// 1. Using `CFRunLoopPerformBlock` or `-[NSRunLoop performBlock:]`./// 2. Using `-[NSObject performSelectorOnMainThread:withObject:waitUntilDone:]` or wrapping the///    event in `NSEvent` and posting that to `-[NSApplication postEvent:atStart:]` (both///    creates a custom `CFRunLoopSource`, and signals that to wake up the main event loop).///    a. `atStart = true`.///    b. `atStart = false`./// 3. `dispatch_async` or `dispatch_async_f`. Note that this may appear before 2b, it does not///    respect the ordering that runloop events have./// We choose the first one, both for ease-of-implementation, but mostly for consistency, as we/// want the event to be queued in a way that preserves the order the events originally arrived/// in./// As an example, let's assume that we receive two events from the user, a mouse click which we/// handled by queuing it, and a window resize which we handled immediately. If we allowed/// AppKit to choose the ordering when queuing the mouse event, it might get put in the back of/// the queue, and the events would appear out of order to the user of Winit. So we must instead/// put the event at the very front of the queue, to be handled as soon as possible after/// handling whatever event it's currently handling.start_instant/// An arbitrary instant in the past, that will trigger an immediate wake/// We save this as the `next_fire_date` for consistency so we can/// easily check if the next_fire_date needs updating.next_fire_date/// This is what the `NextFireDate` has been set to./// `None` corresponds to `waker.stop()` and `start_instant` is used/// for `waker.start()`//! Utilities for working with `CFRunLoop`.//! See Apple's documentation on Run Loops for details://! <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html>trace_scopecalled_from_fnTraceGuardWeakIdNSTextInputClientNSTrackingRectTagNSViewFrameDidChangeNotificationNSAttributedStringNSAttributedStringKeyNSCopyingNSNotificationCenterImeState/// The IME events are disabled, so only `ReceivedCharacter` is being sent to the user./// The ground state of enabled IME input. It means that both Preedit and regular keyboard/// input could be start from it./// The IME is in preedit.Committed/// The text was just committed, so the next input from the keyboard must be ignored.from_locationModLocationMaskkey_to_modifierget_right_modifier_codeget_left_modifier_code/// Strong reference to the global application state.ime_positionime_sizeime_state/// True iff the application wants IME events./// Can be set using `set_ime_allowed`forward_key_to_app/// True if the current key event should be forwarded/// to the application, even during IMEmarked_text_ns_window// Weak reference because the window keeps a strong reference to the view/// The state of the `Option` as `Alt`.is_ime_enabledcurrent_input_source/// Set whether the cursor should be visible or not./// Returns whether the state changed.reset_modifiers/// Reset modifiers and emit a synthetic ModifiersChanged event if deemed necessary./// Update modifiers if `event` has something different/// Get the mouse button from the NSEvent.replace_event// NOTE: to get option as alt working we need to rewrite events// we're getting from the operating system, which makes it// impossible to provide such events as extra in `KeyEvent`.NSAppKitVersionNumberNSAppKitVersionNumber10_12NSAppearanceNSAppearanceCustomizationNSAppearanceNameAquaNSBackingStoreTypeNSDraggingDestinationNSFilenamesPboardTypeNSWindowDelegateNSWindowFullScreenButtonNSWindowOcclusionStateNSWindowSharingTypeNSWindowTabbingModeNSWindowTitleVisibilityNSKeyValueChangeKeyNSKeyValueChangeNewKeyNSKeyValueChangeOldKeyNSKeyValueObservingOptionsNSObjectNSDelayedPerformingNSObjectNSKeyValueObserverRegistrationborderless_game// This is expressed in desktop coordinates, and flipped to match Winit's coordinate system./// The current resize increments for the window content./// Whether the window is showing decorations.// This is set when WindowAttributes::with_fullscreen was set,/// This field tracks the current fullscreen state of the window/// (as seen by `WindowDelegate`).new_windowhandle_scale_factor_changedset_resize_increments_innerrestore_and_release_displayDEFAULT_STANDARD_FRAMEdark_appearance_nameappearance_to_themetheme_to_appearanceRootFullscreen/// Helper for converting between platform-specific and generic/// [`VideoModeHandle`]/[`MonitorHandle`]orbclientButtonEventEventOptionFocusEventHoverEventMouseRelativeEventMoveEventQuitEventResizeEventScrollEventRedoxSocketTimeSocketWindowPropertiesconvert_scancodeelement_stateKeyboardModifierStateresize_optEventStatecharacter_all_modifierswake_socketcreatesredrawsdestroysevent_socketopen_raw// Paths should be checked to ensure they are actually sockets and not normal files. If a// non-socket path is used, it could cause read and write to not function as expected. For// example, the seek would change in a potentially unpredictable way if either read or write// were called at the same time by multiple threads.fpath// Read current time.// Write a timeout.// Wake immediately.ORBITAL_FLAG_ASYNC// These values match the values uses in the `window_new` function in orbital:// https://gitlab.redox-os.org/redox-os/orbital/-/blob/master/src/scheme.rsORBITAL_FLAG_BACKORBITAL_FLAG_FRONTORBITAL_FLAG_HIDDENORBITAL_FLAG_BORDERLESSORBITAL_FLAG_MAXIMIZEDORBITAL_FLAG_RESIZABLEORBITAL_FLAG_TRANSPARENTwindow_socketDropAbortHandle// SAFETY: Wasm without the `atomics` target feature is single-threaded.SenderInner// We need to wrap it into a `Mutex` to make it `Sync`. So the sender can't// be accessed on the main thread, as it could block. Additionally we need// to wrap `Sender` in an `Arc` to make it cloneable on the main thread without// having to block.main_threadDispatchRunnerWakerSpawnersender_datasender_handler// Unsafe wrapper type that allows us to use `T` when it's not `Send` from other threads.// `value` **must** only be accessed on the main thread.// This value must not be accessed if not on the main thread.// - We wrap this in an `Arc` to allow it to be safely cloned without accessing the value.// - The `RefCell` lets us mutably access in the main thread but is safe to drop in any thread//   because it has no `Drop` behavior.// - The `Option` lets us safely drop `T` only in the main thread.// Prevent's `Send` or `Sync` to be automatically implemented.// SAFETY: See `Self::value`.with_sender_dataDomExceptionHtmlImageElementImageBitmapImageBitmapOptionsImageBitmapRenderingContextPremultiplyAlphaImageStatebuild_spawnCursorHandler_handleLoadingAnimationDropper_object_urlObjectUrlkeyframesKeyframeAnimationOptions_imagesUrlTypeWebAnimation// false-positiveCanvasAnimateExtanimate_with_keyframe_animation_optionsKeyframeset_iterationselwuser_event_senderExecutionPageTransitionEventWheelEventweb_timeEventListenerHandleOnEventHandleproxy_spawnerRunnerEnumevent_loop_recreationall_canvasesredraw_pendingdestroy_pendingpage_transition_event_handlePageTransitionEventHandleon_mouse_moveon_wheelon_mouse_presson_mouse_releaseon_key_presson_key_releaseon_visibility_change/// The `EventLoop` is created but not being run./// The `EventLoop` is being run./// The `EventLoop` is exited after being started with `EventLoop::run_app`. Since/// `EventLoop::run_app` takes ownership of the `EventLoop`, we can be certain/// that this event loop will never be run again.maybe_runnermaybe_start_cause/// Returns the corresponding `StartCause` for the current `state`, or `None`/// when in `Exit` state.handle_single_eventadd_canvasnotify_destroy_windowset_listener// Set the event callback to use for the event loop runner// This the event callback is a fairly thin layer over the user-provided callback that closes// over a RootActiveEventLoop referencegenerate_id// Generate a strictly increasing ID// This is used to differentiate windows when handling events// Run the polling logic for the Poll ControlFlow, which involves clearing the queueresume_time_reached// Run the logic for waking from a WaitUntil, which involves clearing the queue// Generally there shouldn't be events built up when this is called// Add an event to the event loop runner, from the user or an event handler// It will determine if the event should be immediately sent to the user or buffered for latersend_user_events// Add a series of user events to the event loop runner// This will schedule the event loop to wake up instead of waking it up immediately if its not// running.// Add a series of events to the event loop runnerprocess_destroy_pending_windows// Process the destroy-pending windows. This should only be called from// `run_until_cleared`, somewhere between emitting `NewEvents` and `AboutToWait`.run_until_cleared// Given the set of new events, run the event loop until the main events and redraw events are// cleared// This will also process any events that have been queued or that are queued during processinghandle_unload// handle_event takes in events and either queues them or applies a callback// It should only ever be called from `run_until_cleared`.apply_control_flow// Apply the new ControlFlow that has been selected by the user// Start any necessary timeouts etchandle_loop_destroyed// Check if the event loop is currently closedScaleChange_timeout_requestVecDequeIterModifiersSharedfrom_key_attribute_valuefrom_key_code_attribute_valueDROP_HANDLERDropBox// Brief introduction to the internals of the web backend:// The web backend used to support both wasm-bindgen and stdweb as methods of binding to the// environment. Because they are both supporting the same underlying APIs, the actual web bindings// are cordoned off into backend abstractions, which present the thinnest unifying layer possible.// When adding support for new events or interactions with the browser, first consult trusted// documentation (such as MDN) to ensure it is well-standardised and supported across many browsers.// Once you have decided on the relevant web APIs, add support to both backends.// The backend is used by the rest of the module to implement Winit's business logic, which forms// the rest of the code. 'device', 'error', 'monitor', and 'window' define web-specific structures// for winit's cross-platform structures. They are all relatively simple translations.// The event_loop module handles listening for and processing events. 'Proxy' implements// EventLoopProxy and 'WindowTarget' implements ActiveEventLoop. WindowTarget also handles// registering the event handlers. The 'Execution' struct in the 'runner' module handles taking// incoming events (from the registered handlers) and ensuring they are passed to the user in a// compliant way.// TODO: FP, remove when <https://github.com/rust-lang/rust-clippy/issues/12377> is fixed.AnimationFrameHandleron_animation_frameCssStyleDeclarationRootOEanimation_frameevent_handleintersection_handleIntersectionObserverHandlemedia_query_handleMediaQueryListHandleButtonsStateResizeScaleHandleis_intersectingon_touch_starton_focuson_bluron_keyboard_releaseon_keyboard_presson_mouse_wheelon_dark_modepointer_handleron_resize_scaleon_intersectanimation_frame_handleron_touch_endon_context_menu/// Note: resizing the HTMLCanvasElement should go through `backend::set_canvas_size` to ensure/// the DPI factor is maintained. Note: this is read-only because we use a pointer to this/// for [`WindowHandle`][rwh_06::WindowHandle].old_sizeset_cursor_lockset_old_sizeset_current_sizeon_cursor_leaveon_cursor_enteron_cursor_moveon_touch_cancelon_intersectionrequest_fullscreenexit_fullscreenrequest_animation_framehandle_scale_changeremove_listenersadd_eventFromWasmAbimouse_buttonsto_idmouse_positionMouseDeltaChromiumold_positionold_deltaGecko// TODO: Remove this when Firefox supports correct movement values in coalesced events and browsers// have agreed on what coordinate space `movementX/Y` is using.// See <https://bugzilla.mozilla.org/show_bug.cgi?id=1753724>.// See <https://github.com/w3c/pointerlock/issues/42>.mouse_scroll_deltakey_textkeyboard_modifiersmouse_modifierspointer_move_eventhas_coalesced_events_support// TODO: Remove when Safari supports `getCoalescedEvents`.// See <https://bugs.webkit.org/show_bug.cgi?id=210454>.EventTargethas_fullscreen_api_supportIntersectionObserverIntersectionObserverEntry_closureMediaQueryListmqlremove_listenerresize_scalingthrow_show_listener_hide_listeneron_page_transitionfix_canvas_sizeset_canvas_sizeset_canvas_min_sizeset_canvas_max_sizeset_canvas_positionstyle_size_property/// This function will panic if the element is not inserted in the DOM/// or is not a CSS property that represents a size in pixel.is_dark_modeRawCanvasTypeon_pointer_presson_pointer_releaseResizeObserverResizeObserverBoxOptionsResizeObserverEntryResizeObserverOptionsResizeObserverSizeResizeScaleInternalnotify_resize_observer_closurescale_handlerresize_handlernotify_scale/// This is a helper type to help manage the `MediaQueryList` used for detecting/// changes of the `devicePixelRatio`.create_mqlcreate_observerhandle_scaleprocess_entryhas_device_pixel_support// TODO: Remove when Safari supports `devicePixelContentBoxSize`.// See <https://bugs.webkit.org/show_bug.cgi?id=219005>.MessageChannelcontroller_timeout_closurenew_with_durationnew_schedulernew_idle_callbackduration_millis_ceil// TODO: Replace with `u32::div_ceil()` when we hit Rust v1.73.has_scheduler_supporthas_idle_callback_supportScriptUrlWindowSupportExtpost_task_with_optionsSchedulerPostTaskOptionsRootWIdestroy_fnfocusableset_canvasDARK_THEME_NAMELIGHT_THEME_NAMEtry_themeset_dark_mode_for_windowIAdviseSinkIEnumFORMATETCIEnumSTATDATASTGMEDIUMGetDataGetDataHereQueryGetDataGetCanonicalFormatEtcSetDataEnumFormatEtcDAdviseDUnadviseEnumDAdviseIDataObjectVtblIDropTargetVtblHrInitAddTabDeleteTabActivateTabSetActiveAltITaskbarListVtblMarkFullscreenWindowITaskbarList2ITaskbarList2VtblCLSID_TaskbarListIID_ITaskbarListIID_ITaskbarList2PROCESS_PER_MONITOR_DPI_AWARE/* If the currently hovered item is not valid there must not be any
                             * `HoveredFileCancelled` emitted */FileDropHandlerData// Implement IUnknownInterfaceTfrom_interfaceDROP_TARGET_VTBLinterrupt_msg_dispatch// Setting this will ensure pump_events will return to the external// loop asap. E.g. set after each RedrawRequested to ensure pump_events// can't stall an external loop beyond a frame/// `NewEvents` has been sent, and `AboutToWait` hasn't./// Associate the application's event handler with the runner/// This is ignoring the lifetime of the application handler (which may not/// outlive the EventLoopRunner) and can lead to undefined behaviour if/// the handler is not cleared before the end of real lifetime./// All public APIs that take an event handler (`run`, `run_on_demand`,/// `pump_events`) _must_ pair a call to `set_event_handler` with/// a call to `clear_event_handler` before returning to avoidclear_event_handlerprepare_wait/// Dispatch control flow events (`NewEvents`, `AboutToWait`, and/// `LoopExiting`) as necessary to bring the internal `RunnerState` to the/// new runner state.///        Idle///       ^    |///       |    V/// HandlingMainEvents///         |///         V///     Destroyed/// transition *from* `Destroyed` will also result in a panic. Transitioning to the currentCREATE_WAITABLE_TIMER_HIGH_RESOLUTIONGCS_COMPSTRGCS_RESULTSTRISC_SHOWUICOMPOSITIONWINDOWPOINTER_FLAG_DOWNPOINTER_FLAG_UPPOINTER_FLAG_UPDATEPT_PENPT_TOUCHRI_MOUSE_HWHEELWinCursorInitDataUserEventPlaceholder/// some backends like macos uses an uninhabited `Never` type,/// on windows, `UserEvent`s are also dispatched through the/// WNDPROC callback, and due to the re-entrant nature of the/// callback, recursively delivered events must be queued in a/// buffer, the current implementation put this queue in/// `EventLoopRunner`, which is shared between the event pumping/// loop and the callback. because it's hard to decide from the/// outside whether a event needs to be buffered, I decided not/// use `Event<Never>` for the shared runner state, but use unit/// as a placeholder so user events can be buffered as usual,/// the real `UserEvent` is pulled from the mpsc channel directly/// when the placeholder event is delivered to the event handlerkey_event_builderuserdata_removedwindow_state_lockThreadMsgTargetDatahigh_resolution_timer// It is a timer used on timed waits.// It is created lazily in case if we have `ControlFlow::WaitUntil`.// Keep it as a field to avoid recreating it on every `ControlFlow::WaitUntil`.wait_for_messages/// Waits until new event messages arrive to be peeked./// Doesn't peek messages itself./// Parameter timeout is optional. This method would wait for the smaller timeout/// between the argument and a timeout from control flow.dispatch_peeked_messages/// Dispatch all queued messages via `PeekMessageW`/// Returns the id of the main thread./// Windows has no real API to check if the current executing thread is the "main thread", unlike/// macOS./// Windows will let us look up the current thread's id, but there's no API that lets us check what/// the id of the main thread is. We would somehow need to get the main thread's id before a/// developer could spin off any other threads inside of the main entrypoint in order to emulate the/// capabilities of other platforms./// We can get the id of the main thread by using CRT initialization. CRT initialization can be used/// to setup global state within a program. The OS will call a list of function pointers which/// assign values to a static variable. To have get a hold of the main thread id, we need to place/// our function pointer inside of the `.CRT$XCU` section so it is called before the main/// entrypoint./// Full details of CRT initialization can be found here:/// <https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-initialization?view=msvc-160>FIFTY_DAYS/// Set upper limit for waiting time to avoid overflows./// I chose 50 days as a limit because it is used in dur2timeout.MIN_WAIT/// Waitable timers use 100 ns intervals to indicate due time./// <https://learn.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-setwaitabletimer#parameters>/// And there is no point waiting using other ways for such small timings/// because they are even less precise (can overshoot by few ms).create_high_resolution_timerset_high_resolution_timer/// This function should not return error if parameters are valid/// but there is no guarantee about that at MSDN docs/// so we return result of GetLastError if fail./// timer must be a valid timer handle created by [create_high_resolution_timer]./// timeout divided by 100 nanoseconds must be more than 0 and less than i64::MAX.wait_for_messages_impl/// Implementation detail of [EventLoop::wait_for_messages]./// Does actual system-level waiting and doesn't process any messages itself,/// including winits internal notifications about waiting and new messages arrival./// The ID./// The name of the message.LazyMessageId/// A lazily-initialized window message ID.INVALID_ID/// An invalid custom window ID./// Create a new `LazyId`./// Get the message ID.USER_EVENT_MSG_ID// Message sent by the `EventLoopProxy` when we want to wake up the thread.// WPARAM and LPARAM are unused.EXEC_MSG_ID// Message sent when we want to execute a closure in the thread.// WPARAM contains a Box<Box<dyn FnMut()>> that must be retrieved with `Box::from_raw`,// and LPARAM is unused.// Message sent by a `Window` when it wants to be destroyed by the main thread.SET_RETAIN_STATE_ON_SIZE_MSG_ID// WPARAM is a bool specifying the `WindowFlags::MARKER_RETAIN_STATE_ON_SIZE` flag. See the// documentation in the `window_state` module for more information.THREAD_EVENT_TARGET_WINDOW_CLASSTASKBAR_CREATED/// When the taskbar is created, it registers a message with the "TaskbarCreated" string and then/// broadcasts this message to all top-level windows <https://docs.microsoft.com/en-us/windows/win32/shell/taskbar#taskbar-creation-notification>insert_event_target_window_dataPointerMoveKind/// Pointer enterd to the window./// Pointer leaved the window client area./// Pointer is inside the window or `GetClientRect` failed.get_pointer_move_kind// here below, the generic `EventLoopRunnerShared<T>` is replaced with// `EventLoopRunnerShared<UserEventPlaceholder>` so we can get rid// of the generic parameter T in types which don't depend on T.// this is the approach which requires minimum changes to current// backend implementation. it should be considered transitional// and should be refactored and cleaned up eventually, I hope.RaiiCursorImmAssociateContextExImmGetCompositionStringWImmSetCandidateWindowATTR_TARGET_CONVERTEDATTR_TARGET_NOTCONVERTEDCANDIDATEFORMGCS_COMPATTRGCS_CURSORPOSIACE_CHILDRENIACE_DEFAULThimcget_composing_text_and_cursorget_composed_textget_composition_cursorget_composition_stringget_composition_datasystem_has_imeVK_ABNT_C2lowordprimarylangidPendingEventQueue/// A single Winit `KeyEvent` contains information which the Windows API passes to the application/// in multiple window messages. In other words: a Winit `KeyEvent` cannot be built from a single/// `PeekMessage` is sometimes used to determine whether the next window message still belongs to/// the current keypress. If it doesn't and the current state represents a key event waiting to be///   put together in the sequence they arrived in, forms the text which is the result of pressing///   the key.// Allowing nominimal_bool lint because the `is_key_pressed` macro triggers this warning// and I don't know of another way to resolve it and also keeping the macro/// This is `previous_state XOR transition_state`. See the lParam for WM_KEYDOWN and WM_KEYUP/// for further details./// Due to this equivalence, the system generates a fake Ctrl key-press (and key-release) precedingPendingMessagePendingMessageTokenIdentifiedPendingMessage/// While processing keyboard events, we sometimes need/// to call `PeekMessageW` (`next_msg`). But `PeekMessageW`/// can also call the event handler, which means that the new event/// gets processed before finishing to process the one that came before./// This would mean that the application receives events in the wrong order./// To avoid this, we keep track whether we are in the middle of processing/// an event. Such an event is an "incomplete pending event". A/// "complete pending event" is one that has already finished processing, but/// hasn't been dispatched to the application because there still are incomplete/// pending events that came before it./// When we finish processing an event, we call `complete_pending`,/// which returns an empty array if there are incomplete pending events, but/// if all pending events are complete, then it returns all pending events in/// the order they were encountered. These can then be dispatched to the applicationadd_pending/// Add a new pending event to the "pending queue"complete_pending/// Returns all finished pending events/// If the return value is non empty, it's guaranteed to contain `msg`/// See also: `add_pending`complete_multiremove_pending/// It's safe to call this even if the element isn't in the list anymoredrain_pendingnext_kbd_msg/// WARNING: Due to using PeekMessage, the event handler/// function may get called during this function./// (Re-entrance to the event handler)/// This can cause a deadlock if calling this function/// while having a mutex locked./// It can also cause code to get executed in a surprising order.NUMPAD_KEYCODES/// This is useful because some numpad keys generate different characters based on the locale./// the conversion, but as such it cannot convert certain keys, like language-specific character/// The result includes all non-character keys defined within `Key` plus characters from numpad/// keys. For example, backspace and tab are included.class_namebackdrop_typeclip_childrentitle_background_colortitle_text_colorcorner_preferenceget_xbutton_wparamget_x_lparamget_y_lparamhiword// DEVMODEW is huge so we box it to avoid blowing up the size of winit::window::Fullscreen// Send is not implemented for HMONITOR, we have to wrap it and implement it manually.get_keyboard_physical_keyWindowArea// Helper function to dynamically load function pointer as some functions// may not be available on all Windows platforms supported by winit.ADJUST_WINDOW_RECT_EX_FOR_DPIGET_POINTER_FRAME_INFO_HISTORYSKIP_POINTER_FRAME_MESSAGESGET_POINTER_DEVICE_RECTSGET_POINTER_TOUCH_INFOGET_POINTER_PEN_INFODWMWA_BORDER_COLORDWMWA_CAPTION_COLORDWMWA_SYSTEMBACKDROP_TYPEDWMWA_TEXT_COLORDWMWA_WINDOW_CORNER_PREFERENCEDWM_SYSTEMBACKDROP_TYPEDWM_WINDOW_CORNER_PREFERENCECOINIT_APARTMENTTHREADEDINPUT_0MENU_ITEM_STATEWDA_EXCLUDEFROMCAPTURErwh_06_no_thread_checkhandle_showing_window_menu// inputs// outputscreate_window_dataon_nccreate// Returns a pointer to window user data on success.// The user data will be registered for the window and can be accessed within the window event// callback.on_create// Flag whether redraw was requested.adjust_rect// A poly-fill for `lazy_cell`// Replace with std::sync::LazyLock when https://github.com/rust-lang/rust/issues/109736 is stabilized.// This isn't used on every platform, which can come up as dead code warnings./// The window is closed when dropped./// ## Threading/// This is `Send + Sync`, meaning that it can be freely used from other/// However, some platforms (macOS, Web and iOS) only allow user interface/// interactions on the main thread, so on those platforms, if you use the/// window from a thread other than the main, the code is scheduled to run on/// the main thread, and your thread may be blocked until that completes./// **Web:** The [`Window`], which is represented by a `HTMLElementCanvas`, can/// not be closed by dropping the [`Window`]./// This will close the [`Window`]./// See [`Window`] for more details./// Can be obtained with [`window.id()`][`Window::id`]./// No other guarantees are made. This may be equal to a real [`WindowId`].content_protectedSendSyncRawWindowHandle/// Attributes used when creating a window./// Wrapper for [`rwh_06::RawWindowHandle`] for [`WindowAttributes::parent_window`]./// The user has to account for that when using [`WindowAttributes::with_parent_window()`],/// which is `unsafe`."use `Window::default_attributes` instead"/// Initializes new attributes with default values./// Get the parent window stored on the attributes./// If this is not set, some platform-specific dimensions will be used./// See [`Window::request_inner_size`] for details./// Sets the minimum dimensions a window can have./// If this is not set, the window will have no minimum dimensions (aside/// from reserved)./// Sets the maximum dimensions a window can have./// If this is not set, the window will have no maximum or will be set to/// the primary monitor's dimensions by the platform./// If this is not set, some platform-specific position will be chosen./// See [`Window::set_outer_position`] for details./// - **macOS:** The top left corner position of the window content, the window's "inner"///   position. The window title bar will be placed above it. The window will be positioned such///   that it fits on screen, maintaining set `inner_size` if any. If you need to precisely///   position the top left corner of the whole window you have to use///   [`Window::set_outer_position`] after creating the window./// - **Windows:** The top left corner position of the window title bar, the window's "outer"///   position. There may be a small gap between this position and the window due to the///   specifics of the Window Manager./// - **X11:** The top left corner of the window, the window's "outer" position./// - **Others:** Ignored.with_enabled_buttons/// Sets the enabled window buttons./// The default is [`WindowButtons::all`]/// See [`Window::set_enabled_buttons`] for details./// Sets the initial title of the window in the title bar./// The default is `"winit window"`./// Sets whether the window should be put into fullscreen upon creation./// Request that the window is maximized upon creation./// Sets whether the window will be initially visible or hidden./// The default is to show the window./// If this is `true`, writing colors with alpha values different than/// `1.0` will produce a transparent window. On some platforms this/// is more of a hint for the system and you'd still have the alpha/// buffer. To control it see [`Window::set_transparent`].with_blur/// Sets whether the background of the window should be blurred by the system./// See [`Window::set_blur`] for details./// Get whether the window will support transparency.with_window_level/// Sets the window level./// This is just a hint to the OS, and the system could ignore it./// The default is [`WindowLevel::Normal`]./// See [`WindowLevel`] for details./// Sets a specific theme for the window./// If `None` is provided, the window will use the system theme./// - **Wayland:** This controls only CSD. When using `None` it'll try to use dbus to get the///   system preference. When explicit theme is used, this will avoid dbus all together./// - **x11:** Build window with `_GTK_THEME_VARIANT` hint set to `dark` or `light`./// - **iOS / Android / Web / x11 / Orbital:** Ignored./// Build window with resize increments hint./// See [`Window::set_resize_increments`] for details.with_content_protected/// - **macOS**: if `false`, [`NSWindowSharingNone`] is used but doesn't completely prevent all///   apps from reading the window content, for instance, QuickTime./// [`NSWindowSharingNone`]: https://developer.apple.com/documentation/appkit/nswindowsharingtype/nswindowsharingnone/// The window should be assumed as not focused by default/// following by the [`WindowEvent::Focused`]./// **Android / iOS / X11 / Wayland / Orbital:** Unsupported./// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused.with_cursor/// The default is [`CursorIcon::Default`]./// See [`Window::set_cursor()`] for more details./// Build window with parent window./// `parent_window` must be a valid window handle./// - **Windows** : A child window has the WS_CHILD style and is confined///   to the client area of its parent window. For more information, see///   <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>/// - **X11**: A child window is confined to the client area of its parent window./// - **Android / iOS / Wayland / Web:** Unsupported./// Create a new [`WindowAttributes`] which allows modifying the window's attributes before/// Returns the scale factor that can be used to map logical pixels to physical pixels, and/// vice versa./// moved to another screen); as such, tracking [`WindowEvent::ScaleFactorChanged`] events is/// This value may differ from [`MonitorHandle::scale_factor`]./// See the [`dpi`] crate for more information./// The scale factor is calculated differently on different platforms:/// - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from///   the display settings. While users are free to select any option they want, they're only///   given a selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7. The scale///   factor is global and changing it requires logging out. See [this article][windows_1] for///   technical details./// - **macOS:** Recent macOS versions allow the user to change the scaling factor for specific///   displays. When available, the user may pick a per-monitor scaling factor from a set of///   pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default,///   but the specific value varies across devices./// - **X11:** Many man-hours have been spent trying to figure out how to handle DPI in X11.///   Winit currently uses a three-pronged approach:///   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable if present.///   + If not present, use the value set in `Xft.dpi` in Xresources.///   + Otherwise, calculate the scale factor based on the millimeter monitor dimensions///     provided by XRandR.///   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use///   the   XRandR scaling method. Generally speaking, you should try to configure the///   standard system   variables to do what you want before resorting to///   `WINIT_X11_SCALE_FACTOR`./// - **Wayland:** The scale factor is suggested by the compositor for each window individually///   by using the wp-fractional-scale protocol if available. Falls back to integer-scale///   factors otherwise.///   The monitor scale factor may differ from the window scale factor./// - **iOS:** Scale factors are set by Apple to the value that best suits the device, and range///   from `1.0` to `3.0`. See [this article][apple_1] and [this article][apple_2] for more///   This uses the underlying `UIView`'s [`contentScaleFactor`]./// - **Android:** Scale factors are set by the manufacturer to the value that best suits the///   device, and range from `1.0` to `4.0`. See [this article][android_1] for more information.///   This is currently unimplemented, and this function always returns 1.0./// - **Web:** The scale factor is the ratio between CSS pixels and the physical device pixels.///   In other words, it is the value of [`window.devicePixelRatio`][web_1]. It is affected by///   both the screen scaling and the browser zoom level and can go below `1.0`./// - **Orbital:** This is currently unimplemented, and this function always returns 1.0./// [`WindowEvent::ScaleFactorChanged`]: crate::event::WindowEvent::ScaleFactorChanged/// [windows_1]: https://docs.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows/// [apple_1]: https://developer.apple.com/library/archive/documentation/DeviceInformation/Reference/iOSDeviceCompatibility/Displays/Displays.html/// [apple_2]: https://developer.apple.com/design/human-interface-guidelines/macos/icons-and-images/image-size-and-resolution//// [android_1]: https://developer.android.com/training/multiscreen/screendensities/// [web_1]: https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio/// Queues a [`WindowEvent::RedrawRequested`] event to be emitted that aligns with the windowing/// system drawing loop./// OS-requested redraws (e.g. when a window gets resized). To improve the event delivery/// consider using [`Window::pre_present_notify`] as described in docs./// Applications should always aim to redraw whenever they receive a `RedrawRequested` event./// There are no strong guarantees about when exactly a `RedrawRequest` event will be emitted/// with respect to other events, since the requirements can vary significantly between/// windowing systems./// However as the event aligns with the windowing system drawing loop, it may not arrive in/// same or even next event loop iteration./// - **Windows** This API uses `RedrawWindow` to request a `WM_PAINT` message and///   `RedrawRequested` is emitted in sync with any `WM_PAINT` messages./// - **Wayland:** The events are aligned with the frame callbacks when///   [`Window::pre_present_notify`] is used./// - **Web:** [`WindowEvent::RedrawRequested`] will be aligned with the///   `requestAnimationFrame`./// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested/// Notify the windowing system before presenting to the window./// You should call this event after your drawing operations, but before you submit/// the buffer to the display or commit your drawings. Doing so will help winit to properly/// schedule and make assumptions about its internal state. For example, it could properly/// throttle [`WindowEvent::RedrawRequested`]./// This example illustrates how it looks with OpenGL, but it applies to other graphics/// APIs and software rendering./// # fn swap_buffers() {}/// # fn scope(window: &Window) {/// // Do the actual drawing with OpenGL./// // Notify winit that we're about to submit buffer to the windowing system./// window.pre_present_notify();/// // Submit buffer to the windowing system./// swap_buffers();/// - **Android / iOS / X11 / Web / Windows / macOS / Orbital:** Unsupported./// - **Wayland:** Schedules a frame callback to throttle [`WindowEvent::RedrawRequested`]./// - **Web, macOS:** Does nothing// ---------------------------// Developers' Note: If this cannot be implemented on every desktop platform// at least, then this function should be provided through a platform specific// extension trait/// The same conditions that apply to [`Window::outer_position`] apply to this method./// - **Web:** Returns the top-left coordinates relative to the viewport. _Note: this returns///   the same value as [`Window::outer_position`]._/// - **Android / Wayland:** Always returns [`NotSupportedError`]./// the screen. If the user uses a desktop with multiple monitors, the top-left hand corner/// of the desktop is the top-left hand corner of the monitor at the top-left of the desktop./// of the visible screen region./// - **Web:** Returns the top-left coordinates relative to the viewport./// See [`Window::outer_position`] for more information about the coordinates./// This automatically un-maximizes the window if it's maximized./// # use winit::dpi::{LogicalPosition, PhysicalPosition};/// // Specify the position in logical dimensions like this:/// window.set_outer_position(LogicalPosition::new(400.0, 200.0));/// // Or specify the position in physical dimensions like this:/// window.set_outer_position(PhysicalPosition::new(400, 200));/// - **Web:** Sets the top-left coordinates relative to the viewport. Doesn't account for CSS///   [`transform`]./// - **Android / Wayland:** Unsupported./// - **Web:** Returns the size of the canvas element. Doesn't account for CSS [`transform`]./// Request the new size for the window./// On platforms where the size is entirely controlled by the user the/// applied size will be returned immediately, resize event in such case/// may not be generated./// On platforms where resizing is disallowed by the windowing system, the current/// inner size is returned immediately, and the user one is ignored./// When `None` is returned, it means that the request went to the display system,/// and the actual size will be delivered later with the [`WindowEvent::Resized`]./// See [`Window::inner_size`] for more information about the values./// The request could automatically un-maximize the window if it's maximized./// let _ = window.request_inner_size(LogicalSize::new(400.0, 200.0));/// let _ = window.request_inner_size(PhysicalSize::new(400, 200));/// - **Web:** Sets the size of the canvas element. Doesn't account for CSS [`transform`]./// [`WindowEvent::Resized`]: crate::event::WindowEvent::Resized/// These dimensions include the title bar and borders. If you don't want that (and you usually/// don't), use [`Window::inner_size`] instead./// - **iOS:** Can only be called on the main thread. Returns the [`PhysicalSize`] of the window///   in screen space coordinates./// - **Web:** Returns the size of the canvas element. _Note: this returns the same value as///   [`Window::inner_size`]._/// window.set_min_inner_size(Some(LogicalSize::new(400.0, 200.0)));/// window.set_min_inner_size(Some(PhysicalSize::new(400, 200)));/// - **iOS / Android / Orbital:** Unsupported./// window.set_max_inner_size(Some(LogicalSize::new(400.0, 200.0)));/// window.set_max_inner_size(Some(PhysicalSize::new(400, 200)));/// Returns window resize increments if any were set./// - **iOS / Android / Web / Wayland / Orbital:** Always returns [`None`]./// Sets window resize increments./// This is a niche constraint hint usually employed by terminal emulators/// and other apps that need "blocky" resizes./// - **macOS:** Increments are converted to logical size and then macOS rounds them to whole///   numbers./// - **Wayland:** Not implemented./// Change the window transparency state./// This is just a hint that may not change anything about/// the window transparency, however doing a mismatch between/// the content of your window and this hint may result in/// visual artifacts./// The default value follows the [`WindowAttributes::with_transparent`]./// - **macOS:** This will reset the window's background color./// - **Web / iOS / Android:** Unsupported./// - **X11:** Can only be set while building the window, with///   [`WindowAttributes::with_transparent`]./// Change the window blur state./// If `true`, this will make the transparent window background blurry./// - **Android / iOS / X11 / Web / Windows:** Unsupported./// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol./// - **Android / Wayland / Web:** Unsupported./// `None` means it couldn't be determined, so it is not recommended to use this to drive your/// rendering backend./// - **X11:** Not implemented./// - **Wayland / iOS / Android / Web:** Unsupported./// Note that making the window unresizable doesn't exempt you from handling/// [`WindowEvent::Resized`], as that event can still be triggered by DPI scaling, entering/// fullscreen mode, etc. Also, the window could still be resized by calling/// [`Window::request_inner_size`]./// - **X11:** Due to a bug in XFCE, this has no effect on Xfwm./// - **iOS / Android / Web:** Unsupported./// - **Wayland / X11 / Orbital:** Not implemented./// Gets the enabled window buttons./// - **Wayland / X11 / Orbital:** Not implemented. Always returns [`WindowButtons::all`]./// - **Web / iOS / Android:** Unsupported. Always returns [`WindowButtons::all`]./// - **Wayland:** Un-minimize is unsupported./// `None` will be returned, if the minimized state couldn't be determined./// - You shouldn't stop rendering for minimized windows, however you could lower the fps./// - **Wayland**: always `None`./// - **macOS:** [`Fullscreen::Exclusive`] provides true exclusive mode with a video mode///   change. *Caveat!* macOS doesn't provide task switching (or spaces!) while in exclusive///   fullscreen mode. This mode should be used when a video mode change is desired, but for a///   better user experience, borderless fullscreen might be preferred.///   [`Fullscreen::Borderless`] provides a borderless fullscreen window on a///   The dock and the menu bar are disabled in exclusive fullscreen mode./// - **Wayland:** Does not support exclusive fullscreen mode and will no-op a request./// - **Android / Orbital:** Unsupported./// - **Web:** Does nothing without a [transient activation]./// [transient activation]: https://developer.mozilla.org/en-US/docs/Glossary/Transient_activation/// - **Android / Orbital:** Will always return `None`./// - **Wayland:** Can return `Borderless(None)` when there are no monitors./// - **Web:** Can only return `None` or `Borderless(None)`./// Enable/disable window decorations provided by the server or Winit./// By default this is enabled. Note that fullscreen windows and windows on/// mobile and web platforms naturally do not have decorations./// - **iOS / Android / Web:** No effect./// Gets the window's current decorations state./// Returns `true` when windows are decorated (server-side or by Winit)./// Also returns `true` when no decorations are required (mobile, web)./// - **iOS / Android / Web:** Always returns `true`./// Change the window level./// On Windows and X11, this is typically the small icon in the top-left/// corner of the titlebar./// - **iOS / Android / Web / Wayland / macOS / Orbital:** Unsupported./// - **Windows:** Sets `ICON_SMALL`. The base size for a window icon is 16x16, but it's///   recommended to account for screen scaling and pick a multiple of that, i.e. 32x32./// - **X11:** Has no universal guidelines for icon sizes, so you're at the whims of the WM.///   That said, it's usually in the same ballpark as on Windows./// Set the IME cursor editing area, where the `position` is the top left corner of that area/// and `size` is the size of this area starting from the position. An example of such area/// could be a input field in the UI or line in the editor./// The windowing system could place a candidate box close to that area, but try to not obscure/// the specified area, so the user input to it stays visible./// The candidate box is the window / popup / overlay that allows you to select the desired/// characters. The look of this box may differ between input devices, even on the same/// (Apple's official term is "candidate window", see their [chinese] and [japanese] guides)./// # use winit::dpi::{LogicalPosition, PhysicalPosition, LogicalSize, PhysicalSize};/// window.set_ime_cursor_area(LogicalPosition::new(400.0, 200.0), LogicalSize::new(100, 100));/// window.set_ime_cursor_area(PhysicalPosition::new(400, 200), PhysicalSize::new(100, 100));/// - **X11:** - area is not supported, only position./// [chinese]: https://support.apple.com/guide/chinese-input-method/use-the-candidate-window-cim12992/104/mac/12.0/// [japanese]: https://support.apple.com/guide/japanese-input-method/use-the-candidate-window-jpim10262/6.3/mac/12.0/// Sets whether the window should get IME events/// When IME is allowed, the window will receive [`Ime`] events, and during the/// preedit phase the window will NOT get [`KeyboardInput`] events. The window/// should allow IME while it is expecting text input./// When IME is not allowed, the window won't receive [`Ime`] events, and will/// receive [`KeyboardInput`] events for every keypress instead. Not allowing/// IME is useful for games for example./// IME is **not** allowed by default./// - **macOS:** IME must be enabled to receive text-input where dead-key sequences are///   combined./// - **iOS / Android:** This will show / hide the soft keyboard./// - **Web / Orbital:** Unsupported./// - **X11**: Enabling IME will disable dead keys reporting during compose./// [`Ime`]: crate::event::WindowEvent::Ime/// [`KeyboardInput`]: crate::event::WindowEvent::KeyboardInput/// Sets the IME purpose for the window using [`ImePurpose`]./// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported./// Brings the window to the front and sets input focus. Has no effect if the window is/// already in focus, minimized, or not visible./// This method steals input focus from other applications. Do not use this method unless/// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive/// user experience./// - **iOS / Android / Wayland / Orbital:** Unsupported./// Gets whether the window has keyboard focus./// This queries the same state information as [`WindowEvent::Focused`]./// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused/// see [`UserAttentionType`] for details./// - **X11:** Requests for user attention must be manually cleared./// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect./// Set or override the window theme./// Specify `None` to reset the theme to the system default./// - **Wayland:** Sets the theme for the client side decorations. Using `None` will use dbus to///   get the system preference./// - **X11:** Sets `_GTK_THEME_VARIANT` hint to `dark` or `light` and if `None` is used, it///   will default to  [`Theme::Dark`]./// - **iOS / Android / x11 / Orbital:** Unsupported./// - **Wayland:** Only returns theme overrides./// - **iOS / Android / x11 / Wayland / Web / Orbital:** Unsupported./// - **iOS / Android / x11 / Wayland / Web:** Unsupported. Always returns an empty string./// - **Web:** Custom cursors have to be loaded and decoded first, until then the previous///   cursor is shown."Renamed to `set_cursor`"/// Deprecated! Use [`Window::set_cursor()`] instead./// window.set_cursor_position(LogicalPosition::new(400.0, 200.0));/// window.set_cursor_position(PhysicalPosition::new(400, 200));/// - **Wayland**: Cursor must be in [`CursorGrabMode::Locked`]./// - **iOS / Android / Web / Orbital:** Always returns an [`ExternalError::NotSupported`]./// Set grabbing [mode][CursorGrabMode] on the cursor preventing it from leaving the window./// First try confining the cursor, and if that fails, try locking it instead./// # use winit::window::{CursorGrabMode, Window};/// window///     .set_cursor_grab(CursorGrabMode::Confined)///     .or_else(|_e| window.set_cursor_grab(CursorGrabMode::Locked))/// - **X11:** The cursor is only hidden within the confines of the window./// - **Wayland:** The cursor is only hidden within the confines of the window./// - **macOS:** The cursor is hidden as long as the window has input focus, even if the cursor///   is outside of the window./// - **X11:** Un-grabs the cursor./// - **Wayland:** Requires the cursor to be inside the window to be dragged./// - **iOS / Android / Web:** Always returns an [`ExternalError::NotSupported`]./// - **macOS:** Always returns an [`ExternalError::NotSupported`]/// Show [window menu] at a specified position ./// This is the context menu that is normally shown when interacting with/// the title bar. This is useful when implementing custom decorations./// **Android / iOS / macOS / Orbital / Wayland / Web / X11:** Unsupported./// [window menu]: https://en.wikipedia.org/wiki/Common_menus_in_Microsoft_Windows#System_menu/// If `true`, the window will catch the cursor events. If `false`, events are passed through/// the window such that any other window behind it receives them. By default hittest is/// This is the same as [`ActiveEventLoop::available_monitors`], and is provided for/// convenience./// [`ActiveEventLoop::available_monitors`]: crate::event_loop::ActiveEventLoop::available_monitors/// This is the same as [`ActiveEventLoop::primary_monitor`], and is provided for convenience./// [`ActiveEventLoop::primary_monitor`]: crate::event_loop::ActiveEventLoop::primary_monitor/// No grabbing of the cursor is performed./// The cursor is confined to the window area./// There's no guarantee that the cursor will be hidden. You should hide it by yourself if you/// want to do so./// - **macOS:** Not implemented. Always returns [`ExternalError::NotSupported`] for now./// The cursor is locked inside the window area to the certain position./// - **X11 / Windows:** Not implemented. Always returns [`ExternalError::NotSupported`] for///   now./// The behavior of cursor grabbing./// Use this enum with [`Window::set_cursor_grab`] to grab the cursor./// Use the light variant./// Use the dark variant./// The theme variant to use./// - **Windows:** Flashes both the window and the taskbar button until the application is in///   focus./// - **X11:** Sets the WM's `XUrgencyHint`. No distinction between [`Critical`] and///   [`Informational`]./// [`Critical`]: Self::Critical/// [`Informational`]: Self::Informational/// The window will always be below normal windows./// This is useful for a widget-based app./// The window will always be on top of normal windows./// A window level groups windows with respect to their z-position./// The relative ordering between windows in different window levels is fixed./// The z-order of a window within the same window level may change dynamically on user interaction./// No special hints for the IME (default)./// The IME is used for password input./// The IME is used to input into a terminal./// For example, that could alter OSK on Wayland to show extra buttons./// Generic IME purposes for use in [`Window::set_ime_purpose`]./// The purpose may improve UX by optimizing the IME for the specific use case,/// if winit can express the purpose to the platform and the platform reacts accordingly./// An opaque token used to activate the [`Window`]./// Make an [`ActivationToken`] from a string./// This method should be used to wrap tokens passed by side channels to your application, like/// dbus./// The validity of the token is ensured by the windowing system. Using the invalid token will/// only result in the side effect of the operation involving it being ignored (e.g. window/// won't get focused automatically), but won't yield any errors./// To obtain a valid token, use/// Convert the token to its string representation to later pass via IPC.//! The [`Window`] struct and associated types.//! # Arithmetic//! ## Direct evaluation//! ## Parse to AST//! ## Parse to Tokens then ASTchapter_6AddContext//! # Custom Errors//! Between [`ContextError`], [`Parser::context`], and [`cut_err`],//! most error needs will likely be met//! (see [tutorial][chapter_6]).//! When that isn't the case, you can implement your own error type.//! The most basic error trait is [`ParserError`].//! Optional traits include://! - [`AddContext`]//! - [`FromExternalError`]//!```rust//! # Implementing `FromStr`//! The [`FromStr` trait][std::str::FromStr] provides//! a common interface to parse from a string.//! # HTTP//! # INI//! # jsondec_uinthex_uint//! # Elements of Programming Languages//! These are short recipes for accomplishing common tasks.//! * [Whitespace](#whitespace)//!   + [Wrapper combinators that eat whitespace before and after a parser](#wrapper-combinators-that-eat-whitespace-before-and-after-a-parser)//! * [Comments](#comments)//!   + [`// C++/EOL-style comments`](#-ceol-style-comments)//!   + [`/* C-style comments */`](#-c-style-comments-)//! * [Identifiers](#identifiers)//!   + [`Rust-Style Identifiers`](#rust-style-identifiers)//! * [Literal Values](#literal-values)//!   + [Escaped Strings](#escaped-strings)//!   + [Integers](#integers)//!     - [Hexadecimal](#hexadecimal)//!     - [Octal](#octal)//!     - [Binary](#binary)//!     - [Decimal](#decimal)//!   + [Floating Point Numbers](#floating-point-numbers)//! ## Whitespace//! ### Wrapper combinators that eat whitespace before and after a parser//! use winnow::prelude::*;//! use winnow::{//!   error::ParserError,//!   combinator::delimited,//!   ascii::multispace0,//! /// A combinator that takes a parser `inner` and produces a parser that also consumes both leading and//! /// trailing whitespace, returning the output of `inner`.//! fn ws<'a, F, O, E: ParserError<&'a str>>(inner: F) -> impl Parser<&'a str, O, E>//!   where//!   F: Parser<&'a str, O, E>,//!   delimited(//!     multispace0,//!     inner,//!     multispace0//!   )//! To eat only trailing whitespace, replace `delimited(...)` with `terminated(&inner, multispace0)`.//! Likewise, the eat only leading whitespace, replace `delimited(...)` with `preceded(multispace0,//! &inner)`. You can use your own parser instead of `multispace0` if you want to skip a different set//! of lexemes.//! ## Comments//! ### `// C++/EOL-style comments`//! This version uses `%` to start a comment, does not consume the newline character, and returns an//! output of `()`.//!   token::take_till1,//! pub fn peol_comment<'a, E: ParserError<&'a str>>(i: &mut &'a str) -> PResult<(), E>//!   ('%', take_till1(['\n', '\r']))//!     .void() // Output is thrown away.//!     .parse_next(i)//! ### `/* C-style comments */`//! Inline comments surrounded with sentinel tags `(*` and `*)`. This version returns an output of `()`//! and does not handle nested comments.//!   token::{tag, take_until},//! pub fn pinline_comment<'a, E: ParserError<&'a str>>(i: &mut &'a str) -> PResult<(), E> {//!   (//!     "(*",//!     take_until(0.., "*)"),//!     "*)"//! ## Identifiers//! ### `Rust-Style Identifiers`//! Parsing identifiers that may start with a letter (or underscore) and may contain underscores,//! letters and numbers may be parsed like this://!   stream::AsChar,//!   token::take_while,//!   token::one_of,//! pub fn identifier<'s>(input: &mut &'s str) -> PResult<&'s str> {//!       one_of(|c: char| c.is_alpha() || c == '_'),//!       take_while(0.., |c: char| c.is_alphanum() || c == '_')//!   .recognize()//!   .parse_next(input)//! Let's say we apply this to the identifier `hello_world123abc`. The first element of the tuple//! would uses [`one_of`][crate::token::one_of] which would recognize `h`. The tuple ensures that//! `ello_world123abc` will be piped to the next [`take_while`][crate::token::take_while] parser,//! which recognizes every remaining character. However, the tuple returns a tuple of the results//! of its sub-parsers. The [`recognize`][crate::Parser::recognize] parser produces a `&str` of the//! input text that was parsed, which in this case is the entire `&str` `hello_world123abc`.//! ## Literal Values//! ### Escaped Strings//! See also [`escaped`] and [`escaped_transform`].//! ### Integers//! The following recipes all return string slices rather than integer values. How to obtain an//! integer value instead is demonstrated for hexadecimal integers. The others are similar.//! The parsers allow the grouping character `_`, which allows one to group the digits by byte, for//! example: `0xA4_3F_11_28`. If you prefer to exclude the `_` character, the lambda to convert from a//! string slice to an integer value is slightly simpler. You can also strip the `_` from the string//! slice that is returned, which is demonstrated in the second hexadecimal number parser.//! #### Hexadecimal//! The parser outputs the string slice of the digits without the leading `0x`/`0X`.//!   combinator::alt,//!   combinator::{repeat},//!   combinator::{preceded, terminated},//!   token::tag,//! fn hexadecimal<'s>(input: &mut &'s str) -> PResult<&'s str> { // <'a, E: ParserError<&'a str>>//!   preceded(//!     alt(("0x", "0X")),//!     repeat(1..,//!       terminated(one_of(('0'..='9', 'a'..='f', 'A'..='F')), repeat(0.., '_').map(|()| ()))//!     ).map(|()| ()).recognize()//!   ).parse_next(input)//! If you want it to return the integer value instead, use map://! fn hexadecimal_value(input: &mut &str) -> PResult<i64> {//!   ).try_map(//!     |out: &str| i64::from_str_radix(&str::replace(&out, "_", ""), 16)//! See also [`hex_uint`]//! #### Octal//! fn octal<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     alt(("0o", "0O")),//!       terminated(one_of('0'..='7'), repeat(0.., '_').map(|()| ()))//! #### Binary//! fn binary<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     alt(("0b", "0B")),//!       terminated(one_of('0'..='1'), repeat(0.., '_').map(|()| ()))//! #### Decimal//!   combinator::terminated,//! fn decimal<'s>(input: &mut &'s str) -> PResult<&'s str> {//!   repeat(1..,//!     terminated(one_of('0'..='9'), repeat(0.., '_').map(|()| ()))//!   ).map(|()| ())//!     .recognize()//!     .parse_next(input)//! See also [`dec_uint`] and [`dec_int`]//! ### Floating Point Numbers//! The following is adapted from [the Python parser by Valentin Lorentz](https://github.com/ProgVal/rust-python-parser/blob/master/src/numbers.rs).//!   combinator::opt,//! fn float<'s>(input: &mut &'s str) -> PResult<&'s str> {//!   alt((//!     // Case one: .42//!     (//!       '.',//!       decimal,//!       opt((//!         one_of(['e', 'E']),//!         opt(one_of(['+', '-'])),//!         decimal//!       ))//!     ).recognize()//!     , // Case two: 42e42 and 42.42e42//!       opt(preceded(//!         '.',//!         decimal,//!       )),//!       one_of(['e', 'E']),//!       opt(one_of(['+', '-'])),//!       decimal//!     , // Case three: 42. and 42.42//!       opt(decimal)//!   )).parse_next(input)//!   ).//!   map(|()| ())//! See also [`float`]fromstrs_expressionwhy//! # Special Topics//! - [Why `winnow`?][why]//! - [Migrating from `nom`][nom]//! - Formats://!   - [Elements of Programming Languages][language]//!   - [Arithmetic][arithmetic]//!   - [s-expression][s_expression]//!   - [json]//!   - [INI][ini]//!   - [HTTP][http]//! - Special Topics://!   - [Implementing `FromStr`][fromstr]//!   - [Performance][performance]//!   - [Parsing Partial Input][partial]//!   - [Custom stream or token][stream]//!   - [Custom errors][error]//!   - [Debugging][crate::_tutorial::chapter_8]//! See also parsers written with `winnow`://! - [`toml_edit`](https://crates.io/crates/toml_edit)//! - [`hcl-edit`](https://crates.io/crates/hcl-edit)//! # Migrating from `nom`//! For comparisons with `nom`, see//! - [Why `winnow`][super::why]//! - [parse-rosetta-rs](https://github.com/rosetta-rs/parse-rosetta-rs/)//! What approach you take depends on the size and complexity of your parser.//! For small, simple parsers, its likely easiest to directly port from `nom`.//! When trying to look for the equivalent of a `nom` combinator, search in the docs for the name//! of the `nom` combinator.  It is expected that, where names diverge, a doc alias exists.//! See also the [List of combinators][crate::combinator].//! For larger parsers, it is likely best to take smaller steps//! - Easier to debug when something goes wrong//! - Deprecation messages will help assist through the process//! The workflow goes something like://! 1. Run `cargo rm nom && cargo add winnow@0.3`//! 1. Ensure everything compiles and tests pass, ignoring deprecation messages (see [migration//!    notes](https://github.com/winnow-rs/winnow/blob/v0.3-main/CHANGELOG.md#nom-migration-guide))//! 1. Commit//! 1. Switch any `impl FnMut(I) -> IResult<I, O, E>` to `impl Parser<I, O, E>`//! 1. Resolve deprecation messages//! 1. Run `cargo add winnow@0.4`//! 1. Ensure everything compiles and tests pass, ignoring deprecation messages (see [changelog](https://github.com/winnow-rs/winnow/blob/v0.4-main/CHANGELOG.md#compatibility-2) for more details)//! 1. Run `cargo add winnow@0.5`//!     notes](https://github.com/winnow-rs/winnow/blob/v0.5.0/CHANGELOG.md))//! 1. Resolve deprecation messagess//! For example migrations, see//! - [git-config-env](https://github.com/gitext-rs/git-config-env/pull/11) (nom to winnow 0.3)//! - [git-conventional](https://github.com/crate-ci/git-conventional/pull/37) (nom to winnow 0.3,//!   adds explicit tracing for easier debugging)//! - [typos](https://github.com/crate-ci/typos/pull/664) (nom to winnow 0.3)//! - [cargo-smart-release](https://github.com/Byron/gitoxide/pull/948) (gradual migration from nom//!   to winnow 0.5)//! - [gix-config](https://github.com/Byron/gitoxide/pull/951) (gradual migration from nom//! - [gix-protocol](https://github.com/Byron/gitoxide/pull/1009) (gradual migration from nom//! - [gitoxide](https://github.com/Byron/gitoxide/pull/956) (gradual migration from nomlength_and_thenStreamIsPartial//! # Parsing Partial Input//! Typically, the input being parsed is all in-memory, or is complete. Some data sources are too//! large to fit into memory, only allowing parsing an incomplete or [`Partial`] subset of the//! data, requiring incrementally parsing.//! By wrapping a stream, like `&[u8]`, with [`Partial`], parsers will report when the data is//! [`Incomplete`] and more input is [`Needed`], allowing the caller to stream-in additional data//! to be parsed. The data is then parsed a chunk at a time.//! Chunks are typically defined by either://! - A header reporting the number of bytes, like with [`length_and_then`]//!   - [`Partial`] can explicitly be changed to being complete once the specified bytes are//!     acquired via [`StreamIsPartial::complete`].//! - A delimiter, like with [ndjson](http://ndjson.org/)//!   - You can parse up-to the delimiter or do a `take_until(0.., delim).and_then(parser)`//! If the chunks are not homogeneous, a state machine will be needed to track what the expected//! parser is for the next chunk.//! Caveats://! - `winnow` takes the approach of re-parsing from scratch. Chunks should be relatively small to//!   prevent the re-parsing overhead from dominating.//! - Parsers like [`repeat`] do not know when an `eof` is from insufficient data or the end of the//!   stream, causing them to always report [`Incomplete`].//! `main.rs`://! `parser.rs`:// Used for intra-doc links//! ## Runtime Performance//! See also the general Rust [Performance Book](https://nnethercote.github.io/perf-book/)//! Tips//! - Try `cargo add winnow -F simd`. For some it offers significant performance improvements//! - When enough cases of an [`alt`] have unique prefixes, prefer [`dispatch`]//! - When parsing text, try to parse as bytes (`u8`) rather than `char`s ([`BStr`] can make//!   debugging easier)//! - Find simplified subsets of the grammar to parse, falling back to the full grammar when it//!   doesn't work. For example, when parsing json strings, parse them without support for escapes,//!   falling back to escape support if it fails.//! - Watch for large return types. A surprising place these can show up is when chaining parsers//!   with a tuple.//! ## Build-time Performance//! Returning complex types as `impl Trait` can negatively impact build times. This can hit in//! surprising cases like://! # use winnow::prelude::*;//! fn foo<I, O, E>() -> impl Parser<I, O, E>//! #    I: winnow::stream::Stream<Token=O>,//! #    I: winnow::stream::StreamIsPartial,//! #    E: winnow::error::ParserError<I>,//!     // ...some chained combinators...//! # winnow::token::any//! Instead, wrap the combinators in a closure to simplify the type://!     move |input: &mut I| {//!         // ...some chained combinators...//!             .parse_next(input)//! # s-expression// Here for intra-dock links//! # Custom [`Stream`]//! `winnow` is batteries included with support for//! - Basic inputs like `&str`, newtypes with//! - Improved debug output like [`Bytes`]//! - [`Stateful`] for passing state through your parser, like tracking recursion//!   depth//! - [`Located`] for looking up the absolute position of a token//! But that won't always cut it for your parser. For example, you might lex `&str` into//! a series of tokens and then want to parse a `TokenStream`.//! ## Implementing a custom stream//! Let's assume we have an input type we'll call `MyStream`.//! `MyStream` is a sequence of `MyItem` type.//! The goal is to define parsers with this signature: `&mut MyStream -> PResult<Output>`.//! # use winnow::token::tag;//! # type MyStream<'i> = &'i str;//! # type Output<'i> = &'i str;//! fn parser<'s>(i: &mut MyStream<'s>) -> PResult<Output<'s>> {//!     "test".parse_next(i)//! Here are the traits you may have to implement for `MyStream`://! | trait | usage |//! |---|---|//! | [`Stream`] |Core trait for driving parsing|//! | [`StreamIsPartial`] | Marks the input as being the complete buffer or a partial buffer for streaming input |//! | [`AsBytes`] |Casts the input type to a byte slice|//! | [`AsBStr`] |Casts the input type to a slice of ASCII / UTF-8-like bytes|//! | [`Compare`] |Character comparison operations|//! | [`FindSlice`] |Look for a substring in self|//! | [`Location`] |Calculate location within initial input|//! | [`Offset`] |Calculate the offset between slices|//! And for `MyItem`://! | [`AsChar`] |Transforms common types to a char for basic token parsing|//! | [`ContainsToken`] |Look for the token in the given set|//! And traits for `&[MyItem]`://! | [`SliceLen`] |Calculate the input length|//! | [`ParseSlice`] |Used to integrate `&str`'s `parse()` method|//! ## Implementing a custom token//! If you are parsing `&[Myitem]`, leaving just the `MyItem` traits.length_takeAccumulate//! # Why `winnow`?//! To answer this question, it will be useful to contrast this with other approaches to parsing.//! **Note:** This will focus on principles and priorities. For a deeper and wider wider//! comparison with other Rust parser libraries, see//! [parse-rosetta-rs](https://github.com/rosetta-rs/parse-rosetta-rs).//! ## Hand-written parsers//! Typically, a hand-written parser gives you the flexibility to get//! - Fast parse performance//! - Fast compile-time//! - Small binary sizes//! - High quality error message//! - Fewer dependencies to audit//! However, this comes at the cost of doing it all yourself, including//! - Optimizing for each of the above characteristics you care about//! - Ensuring the safety of any `unsafe` code (buffer overflows being a common bug with parsers)//! - Being aware of, familiar with, and correctly implement the relevant algorithms.//!   matklad, who has written two rust compile frontends, commented//!   ["I’ve implemented a production-grade Pratt parser once, but I no longer immediately understand that code :-)"](https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html)//! This approach works well if://! - Your format is small and is unlikely to change//! - Your format is large but you have people who can focus solely on parsing, like with large//!   programming languages//! ## `winnow`//! Unlike traditional programming language parsers that use//! [lex](https://en.wikipedia.org/wiki/Lex_(software)) or//! [yacc](https://en.wikipedia.org/wiki/Yacc), you can think of `winnow` as a general version of//! the helpers you would create along the way to writing a hand-written parser.//! `winnow` includes support for://! - Zero-copy parsing//! - [Parse traces][crate::trace] for easier debugging//! - [Streaming parsing][crate::Partial] for network communication or large file//! - [Stateful][crate::Stateful] parsers//! For binary formats, `winnow` includes://! - [A hexadecimal view][crate::Bytes] in [traces][crate::trace]//! - [TLV](https://en.wikipedia.org/wiki/Type-length-value) (e.g. [`length_take`])//! - Some common parsers to help get started, like numbers//! For text formats, `winnow` includes://! - [Tracking of spans][crate::Located]//! - [A textual view when parsing as bytes][crate::BStr] in [traces][crate::trace]//! - Ability to evaluate directly, parse to an AST, or lex and parse the format//! This works well for://! - Prototyping for what will be a hand-written parser//! - When you want to minimize the work to evolve your format//! - When you don't have contributors focused solely on parsing and your grammar is large enough//!   to be unwieldy to hand write.//! ## `nom`//! `winnow` is a fork of the venerable [`nom`](https://crates.io/crates/nom). The difference//! between them is largely in priorities.  `nom` prioritizes://! - Lower churn for existing users while `winnow` is trying to find ways to make things better//!   for the parsers yet to be written.//! - Having a small core, relying on external crates like//!   [`nom-locate`](https://crates.io/crates/nom_locate) and//!   [`nom-supreme`](https://crates.io/crates/nom-supreme), encouraging flexibility among users//!   and to not block users on new features being merged while `winnow` aims to include all the//!   fundamentals for parsing to ensure the experience is cohesive and high quality.//! See also our [nom migration guide][super::nom]//! ## `chumsky`//! [`chumsky`](https://crates.io/crates/chumsky) is an up and coming parser-combinator library//! that includes advanced features like error recovery.//! Probably the biggest diverging philosophy is `chumsky`s stance://! > "If you need to implement either `Parser` or `Strategy` by hand, that's a problem that needs fixing".//! This is under "batteries included" but it also ties into the feeling that `chumsky` acts more like//! a framework. Instead of composing together helpers, you are expected to do everything through//! their system to the point that it is non-trivial to implement their `Parser` trait and are//! encouraged to use the//! [`custom`](https://docs.rs/chumsky/0.9.0/chumsky/primitive/fn.custom.html) helper. This//! requires re-framing everything to fit within their model and makes the code harder to understand//! and debug as you are working with abstract operations that will eventually be applied//! rather than directly with the parsers.//! In contrast, `winnow` is an introspectable toolbox that can easily be customized at any level.//! Probably the biggest thing that `winnow` loses out on is optimizations from ["parse modes" via//! GATs](https://github.com/zesterer/chumsky/pull/82) which allows downstream parsers to tell//! upstream parsers when information will be discarded, allowing bypassing expensive operations,//! like allocations. This requires a lot more complex interaction with parsers that isn't as//! trivial to do with bare functions which would lose out on any of that side-band information.//! Instead, we work around this with things like the [`Accumulate`] trait._topicchapter_1table_of_contents//! # Chapter 0: Introduction//! This tutorial assumes that you are://! - Already familiar with Rust//! - Using `winnow` for the first time//! The focus will be on parsing in-memory strings (`&str`). Once done, you might want to check the//! [Special Topics][_topic] for more specialized topics or examples.//! `winnow` is a parser-combinator library. In other words, it gives you tools to define://! - "parsers", or functions that take an input and give back an output//! - "combinators", or functions that take parsers and _combine_ them together!//! While "combinator" might be an unfamiliar word, you are likely using them in your rust code//! today, like with the [`Iterator`] trait://! let data = vec![1, 2, 3, 4, 5];//! let even_count = data.iter()//!     .copied()  // combinator//!     .filter(|d| d % 2 == 0)  // combinator//!     .count();  // combinator//! Parser combinators are great because://! - The parsers components are easy to reuse (if they're general enough, please add them to winnow!)chapter_0chapter_2//! # Chapter 1: The Winnow Way//! First of all, we need to understand the way that winnow thinks about parsing.//! As discussed in the introduction, winnow lets us build simple parsers, and//! then combine them (using "combinators").//! Let's discuss what a "parser" actually does. A parser takes an input and returns//! a result, where://!  - `Ok` indicates the parser successfully found what it was looking for; or//!  - `Err` indicates the parser could not find what it was looking for.//! Parsers do more than just return a binary "success"/"failure" code.//! On success, the parser will return the processed data. The input will be left pointing to//! data that still needs processing//! If the parser failed, then there are multiple errors that could be returned.//! For simplicity, however, in the next chapters we will leave these unexplored.//!                                   ┌─► Ok(what matched the parser)//!             ┌─────────┐           │//! my input───►│my parser├──►either──┤//!             └─────────┘           └─► Err(...)//! To represent this model of the world, winnow uses the [`PResult<O>`] type.//! The `Ok` variant has `output: O`;//! whereas the `Err` variant stores an error.//! You can import that from://! use winnow::PResult;//! To combine parsers, we need a common way to refer to them which is where the [`Parser<I, O, E>`]//! trait comes in with [`Parser::parse_next`] being the primary way to drive//! parsing forward.//! You'll note that `I` and `O` are parameterized -- while most of the examples in this book//! will be with `&str` (i.e. parsing a string); they do not have to be strings; nor do they//! have to be the same type (consider the simple example where `I = &str`, and `O = u64` -- this//! parses a string into an unsigned integer.)//! # Let's write our first parser!//! The simplest parser we can write is one which successfully does nothing.//! To make it easier to implement a [`Parser`], the trait is implemented for//! functions of the form `Fn(&mut I) -> PResult<O>`.//! This parser function should take in a `&str`://!  - Since it is supposed to succeed, we know it will return the `Ok` variant.//!  - Since it does nothing to our input, the remaining input is the same as the input.//!  - Since it doesn't parse anything, it also should just return an empty string.//! use winnow::Parser;//! pub fn do_nothing_parser<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     Ok("")//!     let mut input = "0x1a2b Hello";//!     let output = do_nothing_parser.parse_next(&mut input).unwrap();//!     // Same as://!     // let output = do_nothing_parser(&mut input).unwrap();//!     assert_eq!(input, "0x1a2b Hello");//!     assert_eq!(output, "");ContainsTokenchapter_3//! # Chapter 2: Tokens and Tags//! The simplest *useful* parser you can write is one which matches tokens.//! ## Tokens//! [`Stream`] provides some core operations to help with parsing. For example, to process a//! single token, you can do://! # use winnow::Parser;//! # use winnow::PResult;//! use winnow::stream::Stream;//! use winnow::error::ParserError;//! use winnow::error::ErrorKind;//! use winnow::error::ErrMode;//! fn parse_prefix(input: &mut &str) -> PResult<char> {//!     let c = input.next_token().ok_or_else(|| {//!         ErrMode::from_error_kind(input, ErrorKind::Token)//!     })?;//!     if c != '0' {//!         return Err(ErrMode::from_error_kind(input, ErrorKind::Verify));//!     Ok(c)//! fn main()  {//!     let output = parse_prefix.parse_next(&mut input).unwrap();//!     assert_eq!(input, "x1a2b Hello");//!     assert_eq!(output, '0');//!     assert!(parse_prefix.parse_next(&mut "d").is_err());//! [`any`] and [`Parser::verify`] are [`Parser`] building blocks on top of [`Stream`]://! use winnow::token::any;//!     any.verify(|c| *c == '0').parse_next(input)//! # fn main()  {//! #     let mut input = "0x1a2b Hello";//! #     let output = parse_prefix.parse_next(&mut input).unwrap();//! #     assert_eq!(input, "x1a2b Hello");//! #     assert_eq!(output, '0');//! #     assert!(parse_prefix.parse_next(&mut "d").is_err());//! Matching a single token literal is common enough that [`Parser`] is implemented for//!     '0'.parse_next(input)//! ## Tags//! [`Stream`] also supports processing slices of tokens://! fn parse_prefix<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     let expected = "0x";//!     if input.len() < expected.len() {//!         return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));//!     let actual = input.next_slice(expected.len());//!     if actual != expected {//!     Ok(actual)//!     assert_eq!(input, "1a2b Hello");//!     assert_eq!(output, "0x");//!     assert!(parse_prefix.parse_next(&mut "0o123").is_err());//! Again, matching a literal is common enough that [`Parser`] is implemented for `&str`://!     "0x".parse_next(input)//! #     assert_eq!(input, "1a2b Hello");//! #     assert_eq!(output, "0x");//! #     assert!(parse_prefix.parse_next(&mut "0o123").is_err());//! In `winnow`, we call this type of parser a [`tag`]. See [`token`] for additional individual//! and token-slice parsers.//! ## Character Classes//! Selecting a single `char` or a [`tag`] is fairly limited. Sometimes, you will want to select one of several//! `chars` of a specific class, like digits. For this, we use the [`one_of`] parser://! use winnow::token::one_of;//! fn parse_digits(input: &mut &str) -> PResult<char> {//!     one_of(('0'..='9', 'a'..='f', 'A'..='F')).parse_next(input)//!     let mut input = "1a2b Hello";//!     let output = parse_digits.parse_next(&mut input).unwrap();//!     assert_eq!(input, "a2b Hello");//!     assert_eq!(output, '1');//!     assert!(parse_digits.parse_next(&mut "Z").is_err());//! > **Aside:** [`one_of`] might look straightforward, a function returning a value that implements `Parser`.//! > Let's look at it more closely as its used above (resolving all generic parameters)://! > ```rust//! > # use winnow::prelude::*;//! > # use winnow::error::InputError;//! > pub fn one_of<'i>(//! >     list: &'static [char]//! > ) -> impl Parser<&'i str, char, InputError<&'i str>> {//! >     // ...//! > #    winnow::token::one_of(list)//! > }//! > If you have not programmed in a language where functions are values, the type signature of the//! > [`one_of`] function might be a surprise.//! > The function [`one_of`] *returns a function*. The function it returns is a//! > `Parser`, taking a `&str` and returning an `PResult`. This is a common pattern in winnow for//! > configurable or stateful parsers.//! Some of character classes are common enough that a named parser is provided, like with://! - [`line_ending`][crate::ascii::line_ending]: Recognizes an end of line (both `\n` and `\r\n`)//! - [`newline`][crate::ascii::newline]: Matches a newline character `\n`//! - [`tab`][crate::ascii::tab]: Matches a tab character `\t`//! You can then capture sequences of these characters with parsers like [`take_while`].//! use winnow::token::take_while;//! fn parse_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     take_while(1.., ('0'..='9', 'a'..='f', 'A'..='F')).parse_next(input)//!     assert_eq!(input, " Hello");//!     assert_eq!(output, "1a2b");//! We could simplify this further by using one of the built-in character classes, [`hex_digit1`]://! use winnow::ascii::hex_digit1;//!     hex_digit1.parse_next(input)//! See [`ascii`] for more text-based parsers.chapter_4//! # Chapter 3: Sequencing and Alternatives//! In the last chapter, we saw how to create simple parsers using prebuilt parsers.//! In this chapter, we explore two other widely used features://! alternatives and composition.//! ## Sequencing//! Now that we can create more interesting parsers, we can sequence them together, like://! # use winnow::token::take_while;//!     take_while(1.., (//!         ('0'..='9'),//!         ('A'..='F'),//!         ('a'..='f'),//!     )).parse_next(input)//!     let prefix = parse_prefix.parse_next(&mut input).unwrap();//!     let digits = parse_digits.parse_next(&mut input).unwrap();//!     assert_eq!(prefix, "0x");//!     assert_eq!(digits, "1a2b");//! To sequence these together, you can just put them in a tuple://! # fn parse_prefix<'s>(input: &mut &'s str) -> PResult<&'s str> {//! #     "0x".parse_next(input)//! # fn parse_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {//! #     take_while(1.., (//! #         ('0'..='9'),//! #         ('A'..='F'),//! #         ('a'..='f'),//! #     )).parse_next(input)//!     let (prefix, digits) = (//!         parse_prefix,//!         parse_digits//!     ).parse_next(&mut input).unwrap();//! Frequently, you won't care about the tag and you can instead use one of the provided combinators,//! like [`preceded`]://! use winnow::combinator::preceded;//!     let digits = preceded(//! See [`combinator`] for more sequencing parsers.//! ## Alternatives//! Sometimes, we might want to choose between two parsers; and we're happy with//! either being used.//! [`Stream::checkpoint`] helps us to retry parsing://! fn parse_digits<'s>(input: &mut &'s str) -> PResult<(&'s str, &'s str)> {//!     let start = input.checkpoint();//!     if let Ok(output) = ("0b", parse_bin_digits).parse_next(input) {//!         return Ok(output);//!     input.reset(start);//!     if let Ok(output) = ("0o", parse_oct_digits).parse_next(input) {//!     if let Ok(output) = ("0d", parse_dec_digits).parse_next(input) {//!     ("0x", parse_hex_digits).parse_next(input)//! # fn parse_bin_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {//! #         ('0'..='7'),//! # fn parse_oct_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {//! # fn parse_dec_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {//! # fn parse_hex_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     let (prefix, digits) = parse_digits.parse_next(&mut input).unwrap();//!     assert!(parse_digits(&mut "ghiWorld").is_err());//! > **Warning:** the above example is for illustrative purposes and relying on `Result::Ok` or//! > `Result::Err` can lead to incorrect behavior. This will be clarified in later when covering//! > [error handling][`chapter_6`#errmode]//! [`opt`] is a basic building block for correctly handling retrying parsing://! use winnow::combinator::opt;//!     if let Some(output) = opt(("0b", parse_bin_digits)).parse_next(input)? {//!         Ok(output)//!     } else if let Some(output) = opt(("0o", parse_oct_digits)).parse_next(input)? {//!     } else if let Some(output) = opt(("0d", parse_dec_digits)).parse_next(input)? {//!         ("0x", parse_hex_digits).parse_next(input)//! #     let (prefix, digits) = parse_digits.parse_next(&mut input).unwrap();//! #     assert_eq!(input, " Hello");//! #     assert_eq!(prefix, "0x");//! #     assert_eq!(digits, "1a2b");//! #     assert!(parse_digits(&mut "ghiWorld").is_err());//! [`alt`] encapsulates this if/else-if ladder pattern, with the last case being the `else`://! use winnow::combinator::alt;//!     alt((//!         ("0b", parse_bin_digits),//!         ("0o", parse_oct_digits),//!         ("0d", parse_dec_digits),//!         ("0x", parse_hex_digits),//! > **Note:** [`empty`] and [`fail`] are parsers that might be useful in the `else` case.//! Sometimes a giant if/else-if ladder can be slow and you'd rather have a `match` statement for//! branches of your parser that have unique prefixes. In this case, you can use the//! [`dispatch`] macro://! use winnow::combinator::dispatch;//! use winnow::token::take;//! use winnow::combinator::fail;//!     dispatch!(take(2usize);//!         "0b" => parse_bin_digits,//!         "0o" => parse_oct_digits,//!         "0d" => parse_dec_digits,//!         "0x" => parse_hex_digits,//!         _ => fail,//!     ).parse_next(input)//! > **Note:** [`peek`] may be useful when [`dispatch`]ing from hints from each case's parser.//! See [`combinator`] for more alternative parsers.chapter_5//! # Chapter 4: Parsers With Custom Return Types//! So far, we have seen mostly functions that take an `&str`, and return a//! `PResult<&str>`. Splitting strings into smaller strings and characters is certainly//! useful, but it's not the only thing winnow is capable of!//! A useful operation when parsing is to convert between types; for example//! parsing from `&str` to another primitive, like [`usize`].//! All we need to do for our parser to return a different type is to change//! the type parameter of [`PResult`] to the desired return type.//! For example, to return a `usize`, return a `PResult<usize>`.//! One winnow-native way of doing a type conversion is to use the//! [`Parser::parse_to`] combinator//! to convert from a successful parse to a particular type using [`FromStr`].//! The following code converts from a string containing a number to `usize`://! # use winnow::ascii::digit1;//! fn parse_digits(input: &mut &str) -> PResult<usize> {//!     digit1//!         .parse_to()//!         .parse_next(input)//!     let mut input = "1024 Hello";//!     assert_eq!(output, 1024);//!     assert!(parse_digits(&mut "Z").is_err());//! `Parser::parse_to` is just a convenient form of [`Parser::try_map`] which we can use to handle//! all radices of numbers://!         "0b" => parse_bin_digits.try_map(|s| usize::from_str_radix(s, 2)),//!         "0o" => parse_oct_digits.try_map(|s| usize::from_str_radix(s, 8)),//!         "0d" => parse_dec_digits.try_map(|s| usize::from_str_radix(s, 10)),//!         "0x" => parse_hex_digits.try_map(|s| usize::from_str_radix(s, 16)),//!     assert_eq!(digits, 0x1a2b);//! See also [`Parser`] for more output-modifying parsers.separated//! # Chapter 5: Repetition//! In [`chapter_3`], we covered how to sequence different parsers into a tuple but sometimes you need to run a//! single parser multiple times, collecting the result into a container, like [`Vec`].//! Let's collect the result of `parse_digits`://! # use winnow::combinator::dispatch;//! # use winnow::token::take;//! # use winnow::combinator::fail;//! use winnow::combinator::repeat;//! use winnow::combinator::terminated;//! fn parse_list(input: &mut &str) -> PResult<Vec<usize>> {//!     let mut list = Vec::new();//!     while let Some(output) = opt(terminated(parse_digits, opt(','))).parse_next(input)? {//!         list.push(output);//!     Ok(list)//! # fn parse_digits(input: &mut &str) -> PResult<usize> {//! #     dispatch!(take(2usize);//! #         "0b" => parse_bin_digits.try_map(|s| usize::from_str_radix(s, 2)),//! #         "0o" => parse_oct_digits.try_map(|s| usize::from_str_radix(s, 8)),//! #         "0d" => parse_dec_digits.try_map(|s| usize::from_str_radix(s, 10)),//! #         "0x" => parse_hex_digits.try_map(|s| usize::from_str_radix(s, 16)),//! #         _ => fail,//! #     ).parse_next(input)//!     let mut input = "0x1a2b,0x3c4d,0x5e6f Hello";//!     let digits = parse_list.parse_next(&mut input).unwrap();//!     assert_eq!(digits, vec![0x1a2b, 0x3c4d, 0x5e6f]);//! We can implement this declaratively with [`repeat`]://!     repeat(0..,//!         terminated(parse_digits, opt(','))//! #     let mut input = "0x1a2b,0x3c4d,0x5e6f Hello";//! #     let digits = parse_list.parse_next(&mut input).unwrap();//! #     assert_eq!(digits, vec![0x1a2b, 0x3c4d, 0x5e6f]);//! You'll notice that the above allows trailing `,` when we intended to not support that. We can//! easily fix this by using [`separated`]://! use winnow::combinator::separated;//!     separated(0.., parse_digits, ",").parse_next(input)//! If you look closely at [`repeat`], it isn't collecting directly into a [`Vec`] but//! [`Accumulate`] to gather the results. This lets us make more complex parsers than we did in//! [`chapter_2`] by accumulating the results into a `()` and [`recognize`][Parser::recognize]-ing the captured input://! # use winnow::combinator::separated;//! fn recognize_list<'s>(input: &mut &'s str) -> PResult<&'s str> {//!     parse_list.recognize().parse_next(input)//! fn parse_list(input: &mut &str) -> PResult<()> {//!     let digits = recognize_list.parse_next(&mut input).unwrap();//!     assert_eq!(digits, "0x1a2b,0x3c4d,0x5e6f");//! See [`combinator`] for more repetition parsers.chapter_7//! # Chapter 6: Error Reporting//! ## `Error`//! Back in [`chapter_1`], we glossed over the `Err` side of [`PResult`].  `PResult<O>` is//! actually short for `PResult<O, E=ContextError>` where [`ContextError`] is a relatively cheap//! way of building up reasonable errors for humans.//! You can use [`Parser::context`] to annotate the error with custom types//! while unwinding to further improve the error quality.//! # use winnow::combinator::alt;//! use winnow::error::StrContext;//!         ("0b", parse_bin_digits).context(StrContext::Label("binary")),//!         ("0o", parse_oct_digits).context(StrContext::Label("octal")),//!         ("0d", parse_dec_digits).context(StrContext::Label("decimal")),//!         ("0x", parse_hex_digits).context(StrContext::Label("hexadecimal")),//! At first glance, this looks correct but what `context` will be reported when parsing `"0b5"`?//! If you remember back to [`chapter_3`], [`alt`] will only report the last error by default which//! means when parsing `"0b5"`, the `context` will be `"hexadecimal"`.//! ## `ErrMode`//! Let's break down `PResult<O, E>` one step further://! # use winnow::error::ErrorKind;//! # use winnow::error::ErrMode;//! pub type PResult<O, E = ErrorKind> = Result<O, ErrMode<E>>;//! [`PResult`] is just a fancy wrapper around `Result` that wraps our error in an [`ErrMode`]//! [`ErrMode`] is an enum with [`Backtrack`] and [`Cut`] variants (ignore [`Incomplete`] as its only//! relevant for [streaming][_topic::stream]). By default, errors are [`Backtrack`], meaning that//! other parsing branches will be attempted on failure, like the next case of an [`alt`].  [`Cut`]//! shortcircuits all other branches, immediately reporting the error.//! So we can get the correct `context` by modifying the above example with [`cut_err`]://! # use winnow::error::StrContext;//! use winnow::combinator::cut_err;//!         ("0b", cut_err(parse_bin_digits)).context(StrContext::Label("binary")),//!         ("0o", cut_err(parse_oct_digits)).context(StrContext::Label("octal")),//!         ("0d", cut_err(parse_dec_digits)).context(StrContext::Label("decimal")),//!         ("0x", cut_err(parse_hex_digits)).context(StrContext::Label("hexadecimal")),//! Now, when parsing `"0b5"`, the `context` will be `"binary"`.InputErrorchapter_8//! # Chapter 7: Integrating the Parser//! So far, we've highlighted how to incrementally parse, but how do we bring this all together//! into our application?//! Parsers we've been working with look like://! # use winnow::error::ContextError;//! pub fn parser<'s>(input: &mut &'s str) -> PResult<&'s str> {//! #     Ok("")//! type PResult<O> = Result<//!     O,//!     ErrMode<ContextError>//! >;//! 1. We have to decide what to do about the "remainder" of the `input`.//! 2. The [`ErrMode<ContextError>`] is not compatible with the rest of the Rust ecosystem.//!     Normally, Rust applications want errors that are `std::error::Error + Send + Sync + 'static`//!     meaning://!     - They implement the [`std::error::Error`] trait//!     - They can be sent across threads//!     - They are safe to be referenced across threads//!     - They do not borrow//! winnow provides [`Parser::parse`] to help with this://! - Ensures we hit [`eof`]//! - Removes the [`ErrMode`] wrapper//! - Wraps the error in [`ParseError`]//!   - Provides access to the original [`input`][ParseError::input] with the//!     [`offset`][ParseError::offset] of where it failed//!   - Provides a default renderer (via [`std::fmt::Display`])//! pub struct Hex(usize);//! impl std::str::FromStr for Hex {//!     type Err = String;//!     fn from_str(input: &str) -> Result<Self, Self::Err> {//!             .map(Hex)//!             .parse(input)//!             .map_err(|e| e.to_string())//! # fn parse_digits<'s>(input: &mut &'s str) -> PResult<usize> {//!     let input = "0x1a2b";//!     assert_eq!(input.parse::<Hex>().unwrap(), Hex(0x1a2b));//!     let input = "0x1a2b Hello";//!     assert!(input.parse::<Hex>().is_err());//!     let input = "ghiHello";//! # Chapter 8: Debugging//! When things inevitably go wrong, you can introspect the parsing state by running your test case//! with `--features debug`://! ![Trace output from string example](https://raw.githubusercontent.com/winnow-rs/winnow/main/assets/trace.svg "Example output")//! You can extend your own parsers to show up by wrapping their body with//! [`trace`][crate::combinator::trace].  Going back to [`do_nothing_parser`][super::chapter_1].//! use winnow::combinator::trace;//!     trace(//!         "do_nothing_parser",//!         |i: &mut _| Ok("")//! #     let output = do_nothing_parser.parse_next(&mut input).unwrap();//! #     // Same as://! #     // let output = do_nothing_parser(&mut input).unwrap();//! #     assert_eq!(input, "0x1a2b Hello");//! #     assert_eq!(output, "");//! # Tutorial//! Table of ContentsAsBStrParseSliceCaseless/// Mark a value as case-insensitive for ASCII characters/// # use winnow::prelude::*;/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}};/// # use winnow::ascii::Caseless;/// fn parser<'s>(s: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {///   Caseless("hello").parse_next(s)/// assert_eq!(parser.parse_peek("Hello, World!"), Ok((", World!", "Hello")));/// assert_eq!(parser.parse_peek("hello, World!"), Ok((", World!", "hello")));/// assert_eq!(parser.parse_peek("HeLlo, World!"), Ok((", World!", "HeLlo")));/// assert_eq!(parser.parse_peek("Some"), Err(ErrMode::Backtrack(InputError::new("Some", ErrorKind::Tag))));/// assert_eq!(parser.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag))));/// Get the byte-representation of this case-insensitive value/// Recognizes the string `"\r\n"`./// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data./// # use winnow::ascii::crlf;/// fn parser<'s>(input: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {///     crlf.parse_next(input)/// assert_eq!(parser.parse_peek("\r\nc"), Ok(("c", "\r\n")));/// assert_eq!(parser.parse_peek("ab\r\nc"), Err(ErrMode::Backtrack(InputError::new("ab\r\nc", ErrorKind::Tag))));/// # use winnow::{error::ErrMode, error::ErrorKind, error::InputError, error::Needed};/// # use winnow::Partial;/// assert_eq!(crlf::<_, InputError<_>>.parse_peek(Partial::new("\r\nc")), Ok((Partial::new("c"), "\r\n")));/// assert_eq!(crlf::<_, InputError<_>>.parse_peek(Partial::new("ab\r\nc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("ab\r\nc"), ErrorKind::Tag))));/// assert_eq!(crlf::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(2))));till_line_ending/// Recognizes a string of any char except `"\r\n"` or `"\n"`./// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed};/// # use winnow::ascii::till_line_ending;///     till_line_ending.parse_next(input)/// assert_eq!(parser.parse_peek("ab\r\nc"), Ok(("\r\nc", "ab")));/// assert_eq!(parser.parse_peek("ab\nc"), Ok(("\nc", "ab")));/// assert_eq!(parser.parse_peek("abc"), Ok(("", "abc")));/// assert_eq!(parser.parse_peek(""), Ok(("", "")));/// assert_eq!(parser.parse_peek("a\rb\nc"), Err(ErrMode::Backtrack(InputError::new("\rb\nc", ErrorKind::Tag ))));/// assert_eq!(parser.parse_peek("a\rbc"), Err(ErrMode::Backtrack(InputError::new("\rbc", ErrorKind::Tag ))));/// assert_eq!(till_line_ending::<_, InputError<_>>.parse_peek(Partial::new("ab\r\nc")), Ok((Partial::new("\r\nc"), "ab")));/// assert_eq!(till_line_ending::<_, InputError<_>>.parse_peek(Partial::new("abc")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(till_line_ending::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(till_line_ending::<_, InputError<_>>.parse_peek(Partial::new("a\rb\nc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("\rb\nc"), ErrorKind::Tag ))));/// assert_eq!(till_line_ending::<_, InputError<_>>.parse_peek(Partial::new("a\rbc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("\rbc"), ErrorKind::Tag ))));/// Deprecated, replaced with [`till_line_ending`]till_line_ending_/// Recognizes an end of line (both `"\n"` and `"\r\n"`)./// # use winnow::ascii::line_ending;///     line_ending.parse_next(input)/// assert_eq!(line_ending::<_, InputError<_>>.parse_peek(Partial::new("\r\nc")), Ok((Partial::new("c"), "\r\n")));/// assert_eq!(line_ending::<_, InputError<_>>.parse_peek(Partial::new("ab\r\nc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("ab\r\nc"), ErrorKind::Tag))));/// assert_eq!(line_ending::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Matches a newline character `'\n'`./// # use winnow::ascii::newline;/// fn parser<'s>(input: &mut &'s str) -> PResult<char, InputError<&'s str>> {///     newline.parse_next(input)/// assert_eq!(parser.parse_peek("\nc"), Ok(("c", '\n')));/// assert_eq!(parser.parse_peek("\r\nc"), Err(ErrMode::Backtrack(InputError::new("\r\nc", ErrorKind::Verify))));/// assert_eq!(parser.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Token))));/// assert_eq!(newline::<_, InputError<_>>.parse_peek(Partial::new("\nc")), Ok((Partial::new("c"), '\n')));/// assert_eq!(newline::<_, InputError<_>>.parse_peek(Partial::new("\r\nc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("\r\nc"), ErrorKind::Verify))));/// assert_eq!(newline::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Matches a tab character `'\t'`./// # use winnow::ascii::tab;///     tab.parse_next(input)/// assert_eq!(parser.parse_peek("\tc"), Ok(("c", '\t')));/// assert_eq!(tab::<_, InputError<_>>.parse_peek(Partial::new("\tc")), Ok((Partial::new("c"), '\t')));/// assert_eq!(tab::<_, InputError<_>>.parse_peek(Partial::new("\r\nc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("\r\nc"), ErrorKind::Verify))));/// assert_eq!(tab::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes zero or more lowercase and uppercase ASCII alphabetic characters: `'a'..='z'`, `'A'..='Z'`/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,/// # use winnow::ascii::alpha0;///     alpha0.parse_next(input)/// assert_eq!(parser.parse_peek("ab1c"), Ok(("1c", "ab")));/// assert_eq!(parser.parse_peek("1c"), Ok(("1c", "")));/// assert_eq!(alpha0::<_, InputError<_>>.parse_peek(Partial::new("ab1c")), Ok((Partial::new("1c"), "ab")));/// assert_eq!(alpha0::<_, InputError<_>>.parse_peek(Partial::new("1c")), Ok((Partial::new("1c"), "")));/// assert_eq!(alpha0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes one or more lowercase and uppercase ASCII alphabetic characters: `'a'..='z'`, `'A'..='Z'`/// # use winnow::ascii::alpha1;///     alpha1.parse_next(input)/// assert_eq!(parser.parse_peek("aB1c"), Ok(("1c", "aB")));/// assert_eq!(parser.parse_peek("1c"), Err(ErrMode::Backtrack(InputError::new("1c", ErrorKind::Slice))));/// assert_eq!(parser.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));/// assert_eq!(alpha1::<_, InputError<_>>.parse_peek(Partial::new("aB1c")), Ok((Partial::new("1c"), "aB")));/// assert_eq!(alpha1::<_, InputError<_>>.parse_peek(Partial::new("1c")), Err(ErrMode::Backtrack(InputError::new(Partial::new("1c"), ErrorKind::Slice))));/// assert_eq!(alpha1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes zero or more ASCII numerical characters: `'0'..='9'`/// # use winnow::ascii::digit0;///     digit0.parse_next(input)/// assert_eq!(parser.parse_peek("21c"), Ok(("c", "21")));/// assert_eq!(parser.parse_peek("21"), Ok(("", "21")));/// assert_eq!(parser.parse_peek("a21c"), Ok(("a21c", "")));/// assert_eq!(digit0::<_, InputError<_>>.parse_peek(Partial::new("21c")), Ok((Partial::new("c"), "21")));/// assert_eq!(digit0::<_, InputError<_>>.parse_peek(Partial::new("a21c")), Ok((Partial::new("a21c"), "")));/// assert_eq!(digit0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes one or more ASCII numerical characters: `'0'..='9'`/// # use winnow::ascii::digit1;///     digit1.parse_next(input)/// assert_eq!(parser.parse_peek("c1"), Err(ErrMode::Backtrack(InputError::new("c1", ErrorKind::Slice))));/// assert_eq!(digit1::<_, InputError<_>>.parse_peek(Partial::new("21c")), Ok((Partial::new("c"), "21")));/// assert_eq!(digit1::<_, InputError<_>>.parse_peek(Partial::new("c1")), Err(ErrMode::Backtrack(InputError::new(Partial::new("c1"), ErrorKind::Slice))));/// assert_eq!(digit1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// You can use `digit1` in combination with [`Parser::try_map`] to parse an integer:/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed, Parser};/// fn parser<'s>(input: &mut &'s str) -> PResult<u32, InputError<&'s str>> {///   digit1.try_map(str::parse).parse_next(input)/// assert_eq!(parser.parse_peek("416"), Ok(("", 416)));/// assert_eq!(parser.parse_peek("12b"), Ok(("b", 12)));/// assert!(parser.parse_peek("b").is_err());/// Recognizes zero or more ASCII hexadecimal numerical characters: `'0'..='9'`, `'A'..='F'`,/// `'a'..='f'`/// # use winnow::ascii::hex_digit0;///     hex_digit0.parse_next(input)/// assert_eq!(parser.parse_peek("21cZ"), Ok(("Z", "21c")));/// assert_eq!(parser.parse_peek("Z21c"), Ok(("Z21c", "")));/// assert_eq!(hex_digit0::<_, InputError<_>>.parse_peek(Partial::new("21cZ")), Ok((Partial::new("Z"), "21c")));/// assert_eq!(hex_digit0::<_, InputError<_>>.parse_peek(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));/// assert_eq!(hex_digit0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes one or more ASCII hexadecimal numerical characters: `'0'..='9'`, `'A'..='F'`,/// # use winnow::ascii::hex_digit1;///     hex_digit1.parse_next(input)/// assert_eq!(parser.parse_peek("H2"), Err(ErrMode::Backtrack(InputError::new("H2", ErrorKind::Slice))));/// assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(Partial::new("21cZ")), Ok((Partial::new("Z"), "21c")));/// assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(Partial::new("H2")), Err(ErrMode::Backtrack(InputError::new(Partial::new("H2"), ErrorKind::Slice))));/// assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes zero or more octal characters: `'0'..='7'`/// # use winnow::ascii::oct_digit0;///     oct_digit0.parse_next(input)/// assert_eq!(parser.parse_peek("21cZ"), Ok(("cZ", "21")));/// assert_eq!(oct_digit0::<_, InputError<_>>.parse_peek(Partial::new("21cZ")), Ok((Partial::new("cZ"), "21")));/// assert_eq!(oct_digit0::<_, InputError<_>>.parse_peek(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));/// assert_eq!(oct_digit0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes one or more octal characters: `'0'..='7'`/// # use winnow::ascii::oct_digit1;///     oct_digit1.parse_next(input)/// assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(Partial::new("21cZ")), Ok((Partial::new("cZ"), "21")));/// assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(Partial::new("H2")), Err(ErrMode::Backtrack(InputError::new(Partial::new("H2"), ErrorKind::Slice))));/// assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes zero or more ASCII numerical and alphabetic characters: `'a'..='z'`, `'A'..='Z'`, `'0'..='9'`/// # use winnow::ascii::alphanumeric0;///     alphanumeric0.parse_next(input)/// assert_eq!(parser.parse_peek("21cZ%1"), Ok(("%1", "21cZ")));/// assert_eq!(parser.parse_peek("&Z21c"), Ok(("&Z21c", "")));/// assert_eq!(alphanumeric0::<_, InputError<_>>.parse_peek(Partial::new("21cZ%1")), Ok((Partial::new("%1"), "21cZ")));/// assert_eq!(alphanumeric0::<_, InputError<_>>.parse_peek(Partial::new("&Z21c")), Ok((Partial::new("&Z21c"), "")));/// assert_eq!(alphanumeric0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognizes one or more ASCII numerical and alphabetic characters: `'a'..='z'`, `'A'..='Z'`, `'0'..='9'`/// # use winnow::ascii::alphanumeric1;///     alphanumeric1.parse_next(input)/// assert_eq!(parser.parse_peek("&H2"), Err(ErrMode::Backtrack(InputError::new("&H2", ErrorKind::Slice))));/// assert_eq!(alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new("21cZ%1")), Ok((Partial::new("%1"), "21cZ")));/// assert_eq!(alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new("&H2")), Err(ErrMode::Backtrack(InputError::new(Partial::new("&H2"), ErrorKind::Slice))));/// assert_eq!(alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// # use winnow::ascii::space0;/// assert_eq!(space0::<_, InputError<_>>.parse_peek(Partial::new(" \t21c")), Ok((Partial::new("21c"), " \t")));/// assert_eq!(space0::<_, InputError<_>>.parse_peek(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));/// assert_eq!(space0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// # use winnow::ascii::space1;///     space1.parse_next(input)/// assert_eq!(parser.parse_peek(" \t21c"), Ok(("21c", " \t")));/// assert_eq!(space1::<_, InputError<_>>.parse_peek(Partial::new(" \t21c")), Ok((Partial::new("21c"), " \t")));/// assert_eq!(space1::<_, InputError<_>>.parse_peek(Partial::new("H2")), Err(ErrMode::Backtrack(InputError::new(Partial::new("H2"), ErrorKind::Slice))));/// assert_eq!(space1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// # use winnow::ascii::multispace0;///     multispace0.parse_next(input)/// assert_eq!(parser.parse_peek(" \t\n\r21c"), Ok(("21c", " \t\n\r")));/// assert_eq!(multispace0::<_, InputError<_>>.parse_peek(Partial::new(" \t\n\r21c")), Ok((Partial::new("21c"), " \t\n\r")));/// assert_eq!(multispace0::<_, InputError<_>>.parse_peek(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));/// assert_eq!(multispace0::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// # use winnow::ascii::multispace1;///     multispace1.parse_next(input)/// assert_eq!(multispace1::<_, InputError<_>>.parse_peek(Partial::new(" \t\n\r21c")), Ok((Partial::new("21c"), " \t\n\r")));/// assert_eq!(multispace1::<_, InputError<_>>.parse_peek(Partial::new("H2")), Err(ErrMode::Backtrack(InputError::new(Partial::new("H2"), ErrorKind::Slice))));/// assert_eq!(multispace1::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Decode a decimal unsigned integer (e.g. [`u32`])/// *Complete version*: can parse until the end of input.SealedMarker/// Metadata for parsing unsigned integers, see [`dec_uint`]/// Deprecated since v0.5.17/// Decode a decimal signed integer (e.g. [`i32`])/// Metadata for parsing signed integers, see [`dec_int`]HexUint/// Decode a variable-width hexadecimal integer (e.g. [`u32`])/// *Complete version*: Will parse until the end of input if it has fewer characters than the type/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if end-of-input/// is hit before a hard boundary (non-hex character, more characters than supported)./// # use winnow::{error::ErrMode, error::ErrorKind, error::InputError};/// use winnow::ascii::hex_uint;/// fn parser<'s>(s: &mut &'s [u8]) -> PResult<u32, InputError<&'s [u8]>> {///   hex_uint(s)/// assert_eq!(parser.parse_peek(&b"01AE"[..]), Ok((&b""[..], 0x01AE)));/// assert_eq!(parser.parse_peek(&b"abc"[..]), Ok((&b""[..], 0x0ABC)));/// assert_eq!(parser.parse_peek(&b"ggg"[..]), Err(ErrMode::Backtrack(InputError::new(&b"ggg"[..], ErrorKind::Slice))));/// fn parser<'s>(s: &mut Partial<&'s [u8]>) -> PResult<u32, InputError<Partial<&'s [u8]>>> {/// assert_eq!(parser.parse_peek(Partial::new(&b"01AE;"[..])), Ok((Partial::new(&b";"[..]), 0x01AE)));/// assert_eq!(parser.parse_peek(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(parser.parse_peek(Partial::new(&b"ggg"[..])), Err(ErrMode::Backtrack(InputError::new(Partial::new(&b"ggg"[..]), ErrorKind::Slice))));max_nibbles/// Metadata for parsing hex numbers, see [`hex_uint`]IterOffsets/// Recognizes floating point number in text format and returns a [`f32`] or [`f64`]./// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data./// # use winnow::error::Needed::Size;/// use winnow::ascii::float;/// fn parser<'s>(s: &mut &'s str) -> PResult<f64, InputError<&'s str>> {/// assert_eq!(parser.parse_peek("11e-1"), Ok(("", 1.1)));/// assert_eq!(parser.parse_peek("123E-02"), Ok(("", 1.23)));/// assert_eq!(parser.parse_peek("123K-01"), Ok(("K-01", 123.0)));/// assert_eq!(parser.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Tag))));/// fn parser<'s>(s: &mut Partial<&'s str>) -> PResult<f64, InputError<Partial<&'s str>>> {/// assert_eq!(parser.parse_peek(Partial::new("11e-1 ")), Ok((Partial::new(" "), 1.1)));/// assert_eq!(parser.parse_peek(Partial::new("11e-1")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(parser.parse_peek(Partial::new("123E-02")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(parser.parse_peek(Partial::new("123K-01")), Ok((Partial::new("K-01"), 123.0)));/// assert_eq!(parser.parse_peek(Partial::new("abc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("abc"), ErrorKind::Tag))));// HACK: clippy 1.64.0 bug/// # use winnow::{error::ErrMode, error::ErrorKind, error::InputError, error::Needed, IResult};/// use winnow::ascii::escaped;/// use winnow::token::one_of;///   escaped(digit1, '\\', one_of(['"', 'n', '\\'])).parse_peek(s)/// fn esc(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(esc(Partial::new("123;")), Ok((Partial::new(";"), "123")));/// assert_eq!(esc(Partial::new("12\\\"34;")), Ok((Partial::new(";"), "12\\\"34")));streaming_escaped_internalcomplete_escaped_internal/// use winnow::token::tag;/// use winnow::ascii::escaped_transform;/// use winnow::ascii::alpha1;/// use winnow::combinator::alt;/// fn parser<'s>(input: &mut &'s str) -> PResult<String, InputError<&'s str>> {///       "\\".value("\\"),///       "\"".value("\""),///       "n".value("\n"),///   ).parse_next(input)/// assert_eq!(parser.parse_peek("ab\\\"cd"), Ok(("", String::from("ab\"cd"))));/// assert_eq!(parser.parse_peek("ab\\ncd"), Ok(("", String::from("ab\ncd"))));/// fn parser<'s>(input: &mut Partial<&'s str>) -> PResult<String, InputError<Partial<&'s str>>> {/// assert_eq!(parser.parse_peek(Partial::new("ab\\\"cd\"")), Ok((Partial::new("\""), String::from("ab\"cd"))));streaming_escaped_transform_internalcomplete_escaped_transform_internalis_till_line_ending_bytesis_till_line_ending_strhex_uint_testscomplete_escaped_hangcomplete_escaped_hang_1118complete_escapingcomplete_escaping_strtest_escaped_errorcomplete_escape_transformcomplete_escape_transform_strtest_escaped_transform_errorunpeek/// Number of bits in a byte/// Converts a byte-level input to a bit-level input/// See [`bytes`] to convert it back./// use winnow::prelude::*;/// use winnow::Bytes;/// use winnow::binary::bits::{bits, take};/// use winnow::error::InputError;/// type Stream<'i> = &'i Bytes;/// fn stream(b: &[u8]) -> Stream<'_> {///     Bytes::new(b)/// fn parse(input: Stream<'_>) -> IResult<Stream<'_>, (u8, u8)> {///     bits::<_, _, InputError<(_, usize)>, _, _>((take(4usize), take(8usize))).parse_peek(input)/// let input = stream(&[0x12, 0x34, 0xff, 0xff]);/// assert_eq!(remaining, stream(&[0xff, 0xff]));/// Convert a [`bits`] stream back into a byte stream/// **Warning:** A partial byte remaining in the input will be ignored and the given parser will/// start parsing at the next full byte./// use winnow::binary::bits::{bits, bytes, take};/// use winnow::combinator::rest;/// fn parse(input: Stream<'_>) -> IResult<Stream<'_>, (u8, u8, &[u8])> {///   bits::<_, _, InputError<(_, usize)>, _, _>((///     bytes::<_, _, InputError<_>, _, _>(rest)///   )).parse_peek(input)/// assert_eq!(parse(input), Ok(( stream(&[]), (0x01, 0x23, &[0xff, 0xff][..]) )));/// Parse taking `count` bits/// # use winnow::Bytes;/// # use winnow::error::{InputError, ErrorKind};/// use winnow::binary::bits::take;/// fn parser(input: (Stream<'_>, usize), count: usize)-> IResult<(Stream<'_>, usize), u8> {///   take(count).parse_peek(input)/// assert_eq!(parser((stream(&[0b00010010]), 0), 0), Ok(((stream(&[0b00010010]), 0), 0)));/// assert_eq!(parser((stream(&[0b00010010]), 0), 4), Ok(((stream(&[0b00010010]), 4), 0b00000001)));/// assert_eq!(parser((stream(&[0b00010010]), 4), 4), Ok(((stream(&[]), 0), 0b00000010)));/// assert_eq!(parser((stream(&[0b00010010]), 0), 12), Err(winnow::error::ErrMode::Backtrack(InputError::new((stream(&[0b00010010]), 0), ErrorKind::Eof))));take_/// Parse taking `count` bits and comparing them to `pattern`/// use winnow::binary::bits::tag;/// /// Compare the lowest `count` bits of `input` against the lowest `count` bits of `pattern`./// /// Return Ok and the matching section of `input` if there's a match./// /// Return Err if there's no match./// fn parser(pattern: u8, count: u8, input: (Stream<'_>, usize)) -> IResult<(Stream<'_>, usize), u8> {///     tag(pattern, count).parse_peek(input)/// // The lowest 4 bits of 0b00001111 match the lowest 4 bits of 0b11111111.///     parser(0b0000_1111, 4, (stream(&[0b1111_1111]), 0)),///     Ok(((stream(&[0b1111_1111]), 4), 0b0000_1111))/// // The lowest bit of 0b00001111 matches the lowest bit of 0b11111111 (both are 1).///     parser(0b00000001, 1, (stream(&[0b11111111]), 0)),///     Ok(((stream(&[0b11111111]), 1), 0b00000001))/// // The lowest 2 bits of 0b11111111 and 0b00000001 are different.///     parser(0b000000_01, 2, (stream(&[0b111111_11]), 0)),///     Err(winnow::error::ErrMode::Backtrack(InputError::new(///         (stream(&[0b11111111]), 0),///         ErrorKind::Tag///     )))/// // The lowest 8 bits of 0b11111111 and 0b11111110 are different.///     parser(0b11111110, 8, (stream(&[0b11111111]), 0)),/// Deprecated, replaced with [`pattern`]/// use winnow::binary::bits::bool;/// fn parse(input: (Stream<'_>, usize)) -> IResult<(Stream<'_>, usize), bool> {///     bool.parse_peek(input)/// assert_eq!(parse((stream(&[0b10000000]), 0)), Ok(((stream(&[0b10000000]), 1), true)));/// assert_eq!(parse((stream(&[0b10000000]), 1)), Ok(((stream(&[0b10000000]), 2), false)));test_take_complete_0test_take_complete_eoftest_take_complete_span_over_multiple_bytestest_take_partial_0test_tag_partial_oktest_tag_partial_errtest_bool_0_completetest_bool_eof_completetest_bool_0_partialtest_bool_eof_partialUpdateSlice/// use winnow::binary::be_u8;/// fn parser(s: &[u8]) -> IResult<&[u8], u8> {///     be_u8.parse_peek(s)/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&[][..], ErrorKind::Token))));/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"\x01abcd"[..]), 0x00)));/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// use winnow::binary::be_u16;/// fn parser(s: &[u8]) -> IResult<&[u8], u16> {///     be_u16.parse_peek(s)/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u16> {/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0001)));/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// use winnow::binary::be_u24;/// fn parser(s: &[u8]) -> IResult<&[u8], u32> {///     be_u24.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x000102)));/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));/// use winnow::binary::be_u32;///     be_u32.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x00010203)));/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));/// use winnow::binary::be_u64;/// fn parser(s: &[u8]) -> IResult<&[u8], u64> {///     be_u64.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u64> {/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0001020304050607)));/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));/// use winnow::binary::be_u128;/// fn parser(s: &[u8]) -> IResult<&[u8], u128> {///     be_u128.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u128> {/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x00010203040506070809101112131415)));/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));be_uintto_be_uint/// use winnow::binary::be_i8;/// fn parser(s: &[u8]) -> IResult<&[u8], i8> {///     be_i8.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i8> {///       be_i8.parse_peek(s)/// use winnow::binary::be_i16;/// fn parser(s: &[u8]) -> IResult<&[u8], i16> {///     be_i16.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i16> {///       be_i16.parse_peek(s)/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(2))));/// use winnow::binary::be_i24;/// fn parser(s: &[u8]) -> IResult<&[u8], i32> {///     be_i24.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {///       be_i24.parse_peek(s)/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(3))));/// use winnow::binary::be_i32;///       be_i32.parse_peek(s)/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(4))));/// use winnow::binary::be_i64;/// fn parser(s: &[u8]) -> IResult<&[u8], i64> {///       be_i64.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i64> {/// use winnow::binary::be_i128;/// fn parser(s: &[u8]) -> IResult<&[u8], i128> {///       be_i128.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i128> {/// use winnow::binary::le_u8;///       le_u8.parse_peek(s)/// use winnow::binary::le_u16;///       le_u16.parse_peek(s)///       le_u16::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0100)));/// use winnow::binary::le_u24;///       le_u24.parse_peek(s)///       le_u24::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x020100)));/// use winnow::binary::le_u32;///       le_u32.parse_peek(s)///       le_u32::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x03020100)));/// use winnow::binary::le_u64;///       le_u64.parse_peek(s)///       le_u64::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0706050403020100)));/// use winnow::binary::le_u128;///       le_u128.parse_peek(s)///       le_u128::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x15141312111009080706050403020100)));le_uintto_le_uint/// use winnow::binary::le_i8;///       le_i8.parse_peek(s)/// use winnow::binary::le_i16;///       le_i16.parse_peek(s)///       le_i16::<_, InputError<_>>.parse_peek(s)/// use winnow::binary::le_i24;///       le_i24.parse_peek(s)///       le_i24::<_, InputError<_>>.parse_peek(s)/// use winnow::binary::le_i32;///       le_i32.parse_peek(s)///       le_i32::<_, InputError<_>>.parse_peek(s)/// use winnow::binary::le_i64;///       le_i64.parse_peek(s)///       le_i64::<_, InputError<_>>.parse_peek(s)/// use winnow::binary::le_i128;///       le_i128.parse_peek(s)///       le_i128::<_, InputError<_>>.parse_peek(s)/// **Note:** that endianness does not apply to 1 byte numbers./// *Complete version*: returns an error if there is not enough input data/// use winnow::binary::u8;///       u8.parse_peek(s)///       u8::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"\x03abcefg"[..]), 0x00)));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian u16 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian u16 integer./// use winnow::binary::u16;///     u16(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u16(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u16(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u16(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u16::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0003)));/// assert_eq!(be_u16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));///     u16::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0300)));/// assert_eq!(le_u16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian u24 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian u24 integer./// use winnow::binary::u24;///     u24(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u24(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u24(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u24(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u24::<_,InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x000305)));/// assert_eq!(be_u24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));///     u24::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x050300)));/// assert_eq!(le_u24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian u32 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian u32 integer./// use winnow::binary::u32;///     u32(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u32(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u32(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u32(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u32::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00030507)));/// assert_eq!(be_u32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));///     u32::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07050300)));/// assert_eq!(le_u32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian u64 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian u64 integer./// use winnow::binary::u64;///     u64(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u64(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u64(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u64(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u64::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0001020304050607)));/// assert_eq!(be_u64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));///     u64::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0706050403020100)));/// assert_eq!(le_u64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian u128 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian u128 integer./// use winnow::binary::u128;///     u128(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u128(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u128(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u128(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     u128::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_u128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00010203040506070001020304050607)));/// assert_eq!(be_u128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));///     u128::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_u128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07060504030201000706050403020100)));/// assert_eq!(le_u128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));/// use winnow::binary::i8;///       i8.parse_peek(s)/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian i16 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian i16 integer./// use winnow::binary::i16;///     i16(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i16(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i16(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i16(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i16::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0003)));/// assert_eq!(be_i16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));///     i16::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0300)));/// assert_eq!(le_i16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian i24 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian i24 integer./// use winnow::binary::i24;///     i24(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i24(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i24(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i24(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i24::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x000305)));/// assert_eq!(be_i24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));///     i24::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x050300)));/// assert_eq!(le_i24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian i32 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian i32 integer./// use winnow::binary::i32;///     i32(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i32(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i32(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i32(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i32::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00030507)));/// assert_eq!(be_i32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));///     i32::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07050300)));/// assert_eq!(le_i32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian i64 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian i64 integer./// use winnow::binary::i64;///     i64(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i64(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i64(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i64(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i64::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0001020304050607)));/// assert_eq!(be_i64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));///     i64::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0706050403020100)));/// assert_eq!(le_i64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian i128 integer,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian i128 integer./// use winnow::binary::i128;///     i128(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i128(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i128(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i128(&b"\x01"[..]), Err(ErrMode::Backtrack(InputError::new(&[0x01][..], ErrorKind::Slice))));///     i128::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_i128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00010203040506070001020304050607)));/// assert_eq!(be_i128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));///     i128::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_i128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07060504030201000706050403020100)));/// assert_eq!(le_i128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));/// use winnow::binary::be_f32;/// fn parser(s: &[u8]) -> IResult<&[u8], f32> {///       be_f32.parse_peek(s)/// assert_eq!(parser(&b"abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"abc"[..], ErrorKind::Slice))));/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, f32> {/// assert_eq!(parser(Partial::new(&[0x40, 0x29, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 2.640625)));/// assert_eq!(parser(Partial::new(&[0x01][..])), Err(ErrMode::Incomplete(Needed::new(3))));/// use winnow::binary::be_f64;/// fn parser(s: &[u8]) -> IResult<&[u8], f64> {///       be_f64.parse_peek(s)/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, f64> {///       be_f64::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 12.5)));/// assert_eq!(parser(Partial::new(&[0x01][..])), Err(ErrMode::Incomplete(Needed::new(7))));/// use winnow::binary::le_f32;///       le_f32.parse_peek(s)///       le_f32::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&[0x00, 0x00, 0x48, 0x41][..])), Ok((Partial::new(&b""[..]), 12.5)));/// use winnow::binary::le_f64;///       le_f64.parse_peek(s)///       le_f64::<_, InputError<_>>.parse_peek(s)/// assert_eq!(parser(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41][..])), Ok((Partial::new(&b""[..]), 3145728.0)));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian f32 float,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian f32 float./// use winnow::binary::f32;///     f32(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_f32(&b"abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"abc"[..], ErrorKind::Slice))));///     f32(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_f32(&b"abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"abc"[..], ErrorKind::Slice))));///     f32::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_f32(Partial::new(&[0x41, 0x48, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 12.5)));/// assert_eq!(be_f32(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));///     f32::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_f32(Partial::new(&[0x00, 0x00, 0x48, 0x41][..])), Ok((Partial::new(&b""[..]), 12.5)));/// assert_eq!(le_f32(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// If the parameter is `winnow::binary::Endianness::Big`, parse a big endian f64 float,/// otherwise if `winnow::binary::Endianness::Little` parse a little endian f64 float./// use winnow::binary::f64;///     f64(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_f64(&b"abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"abc"[..], ErrorKind::Slice))));///     f64(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_f64(&b"abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"abc"[..], ErrorKind::Slice))));///     f64::<_, InputError<_>>(winnow::binary::Endianness::Big).parse_peek(s)/// assert_eq!(be_f64(Partial::new(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 12.5)));/// assert_eq!(be_f64(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(5))));///     f64::<_, InputError<_>>(winnow::binary::Endianness::Little).parse_peek(s)/// assert_eq!(le_f64(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..])), Ok((Partial::new(&b""[..]), 12.5)));/// assert_eq!(le_f64(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(5))));/// Get a length-prefixed slice ([TLV](https://en.wikipedia.org/wiki/Type-length-value))/// To apply a parser to the returned slice, see [`length_and_then`]./// If the count is for something besides tokens, see [`length_repeat`]./// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed, stream::Partial};/// use winnow::binary::length_take;/// type Stream<'i> = Partial<&'i Bytes>;///     Partial::new(Bytes::new(b))/// fn parser(s: Stream<'_>) -> IResult<Stream<'_>, &[u8]> {///   length_take(be_u16).parse_peek(s)/// assert_eq!(parser(stream(b"\x00\x03abcefg")), Ok((stream(&b"efg"[..]), &b"abc"[..])));/// assert_eq!(parser(stream(b"\x00\x03a")), Err(ErrMode::Incomplete(Needed::new(2))));/// Deprecated since 0.5.27, replaced with [`length_take`]/// Parse a length-prefixed slice ([TLV](https://en.wikipedia.org/wiki/Type-length-value))/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed, stream::{Partial, StreamIsPartial}};/// use winnow::binary::length_and_then;/// fn complete_stream(b: &[u8]) -> Stream<'_> {///     let mut p = Partial::new(Bytes::new(b));///     let _ = p.complete();///     p///   length_and_then(be_u16, "abc").parse_peek(s)/// assert_eq!(parser(stream(b"\x00\x03123123")), Err(ErrMode::Backtrack(InputError::new(complete_stream(&b"123"[..]), ErrorKind::Tag))));/// Deprecated since 0.5.27, replaced with [`length_and_then`]length_repeat/// [`Accumulate`] a length-prefixed sequence of values ([TLV](https://en.wikipedia.org/wiki/Type-length-value))/// If the length represents token counts, see instead [`length_take`]/// use winnow::binary::length_count;/// fn parser(s: Stream<'_>) -> IResult<Stream<'_>, Vec<&[u8]>> {///   length_count(u8.map(|i| {///   }), "abc").parse_peek(s)/// assert_eq!(parser(stream(b"\x02abcabcabc")), Ok((stream(b"abc"), vec![&b"abc"[..], &b"abc"[..]])));/// assert_eq!(parser(stream(b"\x03123123123")), Err(ErrMode::Backtrack(InputError::new(stream(b"123123123"), ErrorKind::Tag))));/// Deprecated since 0.5.27, replaced with [`length_repeat`]length_repeat_testpartial_length_byteslength_take_testlength_and_then_test/// Pick the first successful parser/// To stop on an error, rather than trying further cases, see/// [`cut_err`][crate::combinator::cut_err] ([example][crate::_tutorial::chapter_6])./// For tight control over the error when no match is found, add a final case using [`fail`][crate::combinator::fail]./// Alternatively, with a [custom error type][crate::_topic::error], it is possible to track all/// errors or return the error of the parser that went the farthest in the input data./// When the alternative cases have unique prefixes, [`dispatch`] can offer better performance./// # use winnow::{error::ErrMode, error::InputError,error::ErrorKind, error::Needed};/// use winnow::ascii::{alpha1, digit1};///   alt((alpha1, digit1)).parse_peek(input)/// assert_eq!(parser(" "), Err(ErrMode::Backtrack(InputError::new(" ", ErrorKind::Slice))));/// To stop on an error, rather than trying further permutations, see/// # use winnow::{error::ErrMode,error::{InputError, ErrorKind}, error::Needed};/// use winnow::combinator::permutation;///   permutation((alpha1, digit1)).parse_peek(input)/// assert_eq!(parser("abc;"), Err(ErrMode::Backtrack(InputError::new(";", ErrorKind::Slice))));/// use winnow::token::any;///   permutation((any, 'a')).parse_peek(input)/// // any parses 'b', then char('a') parses 'a'/// // any parses 'a', then char('a') fails on 'b',/// // even though char('a') followed by any would succeed/// assert_eq!(parser("ab"), Err(ErrMode::Backtrack(InputError::new("b", ErrorKind::Verify))));Alt2Alt3Alt4Alt5Alt6Alt7Alt8Alt9Alt10Alt11Alt12Alt13Alt14Alt15Alt16Alt17Alt18Alt19Alt20Alt21Alt22O4O5O6O7O8O9O10O11O12O13O14O15O16O17O18O19O20O21/// # use winnow::error::ErrorKind;/// # use winnow::error::InputError;/// assert_eq!(rest::<_,InputError<_>>.parse_peek("abc"), Ok(("", "abc")));/// assert_eq!(rest::<_,InputError<_>>.parse_peek(""), Ok(("", "")));/// Note: this does not advance the [`Stream`]/// use winnow::combinator::rest_len;/// assert_eq!(rest_len::<_,InputError<_>>.parse_peek("abc"), Ok(("abc", 3)));/// assert_eq!(rest_len::<_,InputError<_>>.parse_peek(""), Ok(("", 0)));/// Apply a [`Parser`], producing `None` on [`ErrMode::Backtrack`]./// To chain an error up, see [`cut_err`]./// use winnow::combinator::opt;///   opt(alpha1).parse_peek(i)/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, IResult};/// use winnow::combinator::cond;///   cond(b, alpha1).parse_peek(i)/// assert_eq!(parser(true, "123;"), Err(ErrMode::Backtrack(InputError::new("123;", ErrorKind::Slice))));/// # use winnow::{error::ErrMode, error::ErrorKind, error::InputError, IResult};/// use winnow::combinator::peek;/// assert_eq!(parser.parse_peek("abcd;"), Ok(("abcd;", "abcd")));/// assert_eq!(parser.parse_peek("123;"), Err(ErrMode::Backtrack(InputError::new("123;", ErrorKind::Slice))));/// Match the end of the [`Stream`]/// Otherwise, it will error./// # use winnow::combinator::eof;/// let mut parser = eof;/// assert_eq!(parser.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Eof))));/// **Note:** This does not advance the [`Stream`]/// use winnow::combinator::not;/// assert_eq!(parser.parse_peek("123"), Ok(("123", ())));/// assert_eq!(parser.parse_peek("abcd"), Err(ErrMode::Backtrack(InputError::new("abcd", ErrorKind::Not))));/// Transforms an [`ErrMode::Backtrack`] (recoverable) to [`ErrMode::Cut`] (unrecoverable)/// [`winnow::combinator::alt`][crate::combinator::alt]./// See the [tutorial][crate::_tutorial::chapter_6] for more details./// Without `cut_err`:/// # use winnow::token::one_of;/// # use winnow::combinator::rest;/// # use winnow::combinator::alt;/// # use winnow::combinator::preceded;///     preceded(one_of(['+', '-']), digit1),/// With `cut_err`:/// use winnow::combinator::cut_err;///     preceded(one_of(['+', '-']), cut_err(digit1)),/// assert_eq!(parser("+"), Err(ErrMode::Cut(InputError::new("", ErrorKind::Slice ))));backtrack_err/// Transforms an [`ErrMode::Cut`] (unrecoverable) to [`ErrMode::Backtrack`] (recoverable)/// This attempts the parse, allowing other parsers to be tried on failure, like with/// A placeholder for a not-yet-implemented [`Parser`]/// This is analogous to the [`todo!`] macro and helps with prototyping./// This will panic when parsing/// # use winnow::combinator::todo;/// fn parser(input: &mut &str) -> PResult<u64> {///     todo(input)/// Repeats the embedded parser, lazily returning the results/// Call the iterator's [`ParserIterator::finish`] method to get the remaining input if successful,/// On [`ErrMode::Backtrack`], iteration will stop. To instead chain an error up, see [`cut_err`]./// use winnow::{combinator::iterator, IResult, token::tag, ascii::alpha1, combinator::terminated};/// let mut it = iterator(data, terminated(alpha1, "|"));/// Main structure associated to [`iterator`]./// Succeed, consuming no input/// For example, it can be used as the last alternative in `alt` to/// Useful with:/// - [`Parser::value`]/// - [`Parser::default_value`]/// - [`Parser::map`]/// **Note:** This never advances the [`Stream`]/// use winnow::combinator::empty;/// fn sign(input: &str) -> IResult<&str, isize> {///         '-'.value(-1),///         '+'.value(1),///         empty.value(1)///     )).parse_peek(input)/// Deprecated, replaced with [`empty`] + [`Parser::value`]/// control the error message given./// use winnow::combinator::fail;/// assert_eq!(fail::<_, &str, _>.parse_peek(s), Err(ErrMode::Backtrack(InputError::new(s, ErrorKind::Fail))));call_countexistingDEPTHSeverityBacktrackcolumn_widthsquery_widthcolumns_env/// Trace the execution of the parser/// Note that [`Parser::context`] also provides high level trace information./// See [tutorial][crate::_tutorial::chapter_8] for more details./// # use winnow::token::take_while;/// # use winnow::stream::AsChar;/// use winnow::combinator::trace;/// fn short_alpha<'s>(s: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {///   trace("short_alpha",///     take_while(3..=6, AsChar::is_alpha)///   ).parse_next(s)/// assert_eq!(short_alpha.parse_peek(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));/// assert_eq!(short_alpha.parse_peek(b"lengthy"), Ok((&b"y"[..], &b"length"[..])));/// assert_eq!(short_alpha.parse_peek(b"latin"), Ok((&b""[..], &b"latin"[..])));/// assert_eq!(short_alpha.parse_peek(b"ed"), Err(ErrMode::Backtrack(InputError::new(&b"ed"[..], ErrorKind::Slice))));/// assert_eq!(short_alpha.parse_peek(b"12345"), Err(ErrMode::Backtrack(InputError::new(&b"12345"[..], ErrorKind::Slice))));//! # List of parsers and combinators//! **Note**: this list is meant to provide a nicer way to find a parser than reading through the documentation on docs.rs. Function combinators are organized in module so they are a bit easier to find.//! ## Basic elements//! Those are used to recognize the lowest level elements of your grammar, like, "here is a dot", or "here is an big endian integer".//! | combinator | usage | input | new input | output | comment |//! | [`one_of`][crate::token::one_of] | `one_of(['a', 'b', 'c'])` |  `"abc"` |  `"bc"` | `Ok('a')` |Matches one of the provided characters (works with non ASCII characters too)|//! | [`none_of`][crate::token::none_of] | `none_of(['a', 'b', 'c'])` |  `"xyab"` |  `"yab"` | `Ok('x')` |Matches anything but the provided characters|//! | [`tag`][crate::token::tag] | `"hello"` |  `"hello world"` |  `" world"` | `Ok("hello")` |Recognizes a specific suite of characters or bytes (see also [`Caseless`][crate::ascii::Caseless])|//! | [`take`][crate::token::take] | `take(4)` |  `"hello"` |  `"o"` | `Ok("hell")` |Takes a specific number of bytes or characters|//! | [`take_while`][crate::token::take_while] | `take_while(0.., is_alphabetic)` |  `"abc123"` |  `"123"` | `Ok("abc")` |Returns the longest list of bytes for which the provided pattern matches.|//! | [`take_till0`][crate::token::take_till0] | `take_till0(is_alphabetic)` |  `"123abc"` |  `"abc"` | `Ok("123")` |Returns the longest list of bytes or characters until the provided pattern matches. `take_till1` does the same, but must return at least one character. This is the reverse behaviour from `take_while`: `take_till(f)` is equivalent to `take_while(0.., \|c\| !f(c))`|//! | [`take_until`][crate::token::take_until] | `take_until(0.., "world")` |  `"Hello world"` |  `"world"` | `Ok("Hello ")` |Returns the longest list of bytes or characters until the provided tag is found.|//! ## Choice combinators//! | [`alt`] | `alt(("ab", "cd"))` |  `"cdef"` |  `"ef"` | `Ok("cd")` |Try a list of parsers and return the result of the first successful one|//! | [`dispatch`] | \- | \- | \- | \- | `match` for parsers |//! | [`permutation`] | `permutation(("ab", "cd", "12"))` | `"cd12abc"` | `"c"` | `Ok(("ab", "cd", "12"))` |Succeeds when all its child parser have succeeded, whatever the order|//! ## Sequence combinators//! | [`(...)` (tuples)][crate::Parser] | `("ab", "XY", take(1))` | `"abXYZ!"` | `"!"` | `Ok(("ab", "XY", "Z"))` |Chains parsers and assemble the sub results in a tuple. You can use as many child parsers as you can put elements in a tuple|//! | [`seq!`] | `seq!(_: char('('), take(2), _: char(')'))` | `"(ab)cd"` | `"cd"` | `Ok("ab")` ||//! | [`delimited`] | `delimited(char('('), take(2), char(')'))` | `"(ab)cd"` | `"cd"` | `Ok("ab")` ||//! | [`preceded`] | `preceded("ab", "XY")` | `"abXYZ"` | `"Z"` | `Ok("XY")` ||//! | [`terminated`] | `terminated("ab", "XY")` | `"abXYZ"` | `"Z"` | `Ok("ab")` ||//! | [`separated_pair`] | `separated_pair("hello", char(','), "world")` | `"hello,world!"` | `"!"` | `Ok(("hello", "world"))` ||//! ## Applying a parser multiple times//! | [`repeat`] | `repeat(1..=3, "ab")` | `"ababc"` | `"c"` | `Ok(vec!["ab", "ab"])` |Applies the parser between m and n times (n included) and returns the list of results in a Vec|//! | [`repeat_till`] | `repeat_till(0.., tag( "ab" ), tag( "ef" ))` | `"ababefg"` | `"g"` | `Ok((vec!["ab", "ab"], "ef"))` |Applies the first parser until the second applies. Returns a tuple containing the list of results from the first in a Vec and the result of the second|//! | [`separated`] | `separated(1..=3, "ab", ",")` | `"ab,ab,ab."` | `"."` | `Ok(vec!["ab", "ab", "ab"])` |Applies the parser and separator between m and n times (n included) and returns the list of results in a Vec|//! | [`fold_repeat`] | `fold_repeat(1..=2, be_u8, \|\| 0, \|acc, item\| acc + item)` | `[1, 2, 3]` | `[3]` | `Ok(3)` |Applies the parser between m and n times (n included) and folds the list of return value|//! ## Partial related//! - [`eof`]: Returns its input if it is at the end of input data//! - [`Parser::complete_err`]: Replaces an `Incomplete` returned by the child parser with an `Backtrack`//! ## Modifiers//! - [`cond`]: Conditional combinator. Wraps another parser and calls it if the condition is met//! - [`Parser::flat_map`]: method to map a new parser from the output of the first parser, then apply that parser over the rest of the input//! - [`Parser::value`]: method to replace the result of a parser//! - [`Parser::default_value`]: method to replace the result of a parser//! - [`Parser::void`]: method to discard the result of a parser//! - [`Parser::map`]: method to map a function on the result of a parser//! - [`Parser::and_then`]: Applies a second parser over the output of the first one//! - [`Parser::verify_map`]: Maps a function returning an `Option` on the output of a parser//! - [`Parser::try_map`]: Maps a function returning a `Result` on the output of a parser//! - [`Parser::parse_to`]: Apply [`std::str::FromStr`] to the output of the parser//! - [`not`]: Returns a result only if the embedded parser returns `Backtrack` or `Incomplete`. Does not consume the input//! - [`opt`]: Make the underlying parser optional//! - [`peek`]: Returns a result without consuming the input//! - [`Parser::recognize`]: If the child parser was successful, return the consumed input as the produced value//! - [`Parser::with_recognized`]: If the child parser was successful, return a tuple of the consumed input and the produced output.//! - [`Parser::span`]: If the child parser was successful, return the location of the consumed input as the produced value//! - [`Parser::with_span`]: If the child parser was successful, return a tuple of the location of the consumed input and the produced output.//! - [`Parser::verify`]: Returns the result of the child parser if it satisfies a verification function//! ## Error management and debugging//! - [`cut_err`]: Commit the parse result, disallowing alternative parsers from being attempted//! - [`backtrack_err`]: Attempts a parse, allowing alternative parsers to be attempted despite//!   use of `cut_err`//! - [`Parser::context`]: Add context to the error if the parser fails//! - [`trace`]: Print the parse state with the `debug` feature flag//! - [`todo()`]: Placeholder parser//! ## Remaining combinators//! - [`success`]: Returns a value without consuming any input, always succeeds//! - [`fail`]: Inversion of `success`. Always fails.//! - [`Parser::by_ref`]: Allow moving `&mut impl Parser` into other parsers//! ## Text parsing//! - [`any`][crate::token::any]: Matches one token//! - [`crlf`][crate::ascii::crlf]: Recognizes the string `\r\n`//! - [`till_line_ending`][crate::ascii::till_line_ending]: Recognizes a string of any char except `\r` or `\n`//! - [`rest`]: Return the remaining input//! - [`alpha0`][crate::ascii::alpha0]: Recognizes zero or more lowercase and uppercase alphabetic characters: `[a-zA-Z]`. [`alpha1`][crate::ascii::alpha1] does the same but returns at least one character//! - [`alphanumeric0`][crate::ascii::alphanumeric0]: Recognizes zero or more numerical and alphabetic characters: `[0-9a-zA-Z]`. [`alphanumeric1`][crate::ascii::alphanumeric1] does the same but returns at least one character//! - [`space0`][crate::ascii::space0]: Recognizes zero or more spaces and tabs. [`space1`][crate::ascii::space1] does the same but returns at least one character//! - [`multispace0`][crate::ascii::multispace0]: Recognizes zero or more spaces, tabs, carriage returns and line feeds. [`multispace1`][crate::ascii::multispace1] does the same but returns at least one character//! - [`digit0`][crate::ascii::digit0]: Recognizes zero or more numerical characters: `[0-9]`. [`digit1`][crate::ascii::digit1] does the same but returns at least one character//! - [`hex_digit0`][crate::ascii::hex_digit0]: Recognizes zero or more hexadecimal numerical characters: `[0-9A-Fa-f]`. [`hex_digit1`][crate::ascii::hex_digit1] does the same but returns at least one character//! - [`oct_digit0`][crate::ascii::oct_digit0]: Recognizes zero or more octal characters: `[0-7]`. [`oct_digit1`][crate::ascii::oct_digit1] does the same but returns at least one character//! - [`float`][crate::ascii::float]: Parse a floating point number in a byte string//! - [`dec_int`][crate::ascii::dec_int]: Decode a variable-width, decimal signed integer//! - [`dec_uint`][crate::ascii::dec_uint]: Decode a variable-width, decimal unsigned integer//! - [`hex_uint`][crate::ascii::hex_uint]: Decode a variable-width, hexadecimal integer//! - [`escaped`][crate::ascii::escaped]: Matches a byte string with escaped characters//! - [`escaped_transform`][crate::ascii::escaped_transform]: Matches a byte string with escaped characters, and returns a new string with the escaped characters replaced//! ### Character test functions//! Use these functions with a combinator like `take_while`://! - [`AsChar::is_alpha`][crate::stream::AsChar::is_alpha]: Tests if byte is ASCII alphabetic: `[A-Za-z]`//! - [`AsChar::is_alphanum`][crate::stream::AsChar::is_alphanum]: Tests if byte is ASCII alphanumeric: `[A-Za-z0-9]`//! - [`AsChar::is_dec_digit`][crate::stream::AsChar::is_dec_digit]: Tests if byte is ASCII digit: `[0-9]`//! - [`AsChar::is_hex_digit`][crate::stream::AsChar::is_hex_digit]: Tests if byte is ASCII hex digit: `[0-9A-Fa-f]`//! - [`AsChar::is_oct_digit`][crate::stream::AsChar::is_oct_digit]: Tests if byte is ASCII octal digit: `[0-7]`//! - [`AsChar::is_space`][crate::stream::AsChar::is_space]: Tests if byte is ASCII space or tab: `[ \t]`//! - [`AsChar::is_newline`][crate::stream::AsChar::is_newline]: Tests if byte is ASCII newline: `[\n]`//! ## Binary format parsing//! - [`length_count`][crate::binary::length_count] Gets a number from the first parser, then applies the second parser that many times//! - [`length_data`][crate::binary::length_data]: Gets a number from the first parser, then takes a subslice of the input of that size, and returns that subslice//! - [`length_value`][crate::binary::length_value]: Gets a number from the first parser, takes a subslice of the input of that size, then applies the second parser on that subslice. If the second parser returns `Incomplete`, `length_value` will return an error//! Parsing integers from binary formats can be done in two ways: With parser functions, or combinators with configurable endianness.//! - **configurable endianness:** [`i16`][crate::binary::i16], [`i32`][crate::binary::i32],//!   [`i64`][crate::binary::i64], [`u16`][crate::binary::u16], [`u32`][crate::binary::u32],//!   [`u64`][crate::binary::u64] are combinators that take as argument a//!   [`winnow::binary::Endianness`][crate::binary::Endianness], like this: `i16(endianness)`. If the//!   parameter is `winnow::binary::Endianness::Big`, parse a big endian `i16` integer, otherwise a//!   little endian `i16` integer.//! - **fixed endianness**: The functions are prefixed by `be_` for big endian numbers, and by `le_` for little endian numbers, and the suffix is the type they parse to. As an example, `be_u32` parses a big endian unsigned integer stored in 32 bits.//!   - [`be_f32`][crate::binary::be_f32], [`be_f64`][crate::binary::be_f64]: Big endian floating point numbers//!   - [`le_f32`][crate::binary::le_f32], [`le_f64`][crate::binary::le_f64]: Little endian floating point numbers//!   - [`be_i8`][crate::binary::be_i8], [`be_i16`][crate::binary::be_i16], [`be_i24`][crate::binary::be_i24], [`be_i32`][crate::binary::be_i32], [`be_i64`][crate::binary::be_i64], [`be_i128`][crate::binary::be_i128]: Big endian signed integers//!   - [`be_u8`][crate::binary::be_u8], [`be_u16`][crate::binary::be_u16], [`be_u24`][crate::binary::be_u24], [`be_u32`][crate::binary::be_u32], [`be_u64`][crate::binary::be_u64], [`be_u128`][crate::binary::be_u128]: Big endian unsigned integers//!   - [`le_i8`][crate::binary::le_i8], [`le_i16`][crate::binary::le_i16], [`le_i24`][crate::binary::le_i24], [`le_i32`][crate::binary::le_i32], [`le_i64`][crate::binary::le_i64], [`le_i128`][crate::binary::le_i128]: Little endian signed integers//!   - [`le_u8`][crate::binary::le_u8], [`le_u16`][crate::binary::le_u16], [`le_u24`][crate::binary::le_u24], [`le_u32`][crate::binary::le_u32], [`le_u64`][crate::binary::le_u64], [`le_u128`][crate::binary::le_u128]: Little endian unsigned integers//! ### Bit stream parsing//! - [`bits`][crate::binary::bits::bits]: Transforms the current input type (byte slice `&[u8]`) to a bit stream on which bit specific parsers and more general combinators can be applied//! - [`bytes`][crate::binary::bits::bytes]: Transforms its bits stream input back into a byte slice for the underlying parser//! - [`take`][crate::binary::bits::take]: Take a set number of bits//! - [`tag`][crate::binary::bits::tag]: Check if a set number of bits matches a pattern//! - [`bool`][crate::binary::bits::bool]: Match any one bit/// [`Accumulate`] the output of a parser into a container, like `Vec`/// This stops before `n` when the parser returns [`ErrMode::Backtrack`]. To instead chain an error up, see/// [`cut_err`][crate::combinator::cut_err]./// To recognize a series of tokens, [`Accumulate`] into a `()` and then [`Parser::recognize`]./// **Warning:** If the parser passed to `repeat` accepts empty inputs/// (like `alpha0` or `digit0`), `repeat` will return an error,/// Zero or more repetitions:/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed};/// use winnow::combinator::repeat;///   repeat(0.., "abc").parse_peek(s)/// One or more repetitions:///   repeat(1.., "abc").parse_peek(s)/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(InputError::new("123123", ErrorKind::Tag))));/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag))));/// Fixed number of repetitions:///   repeat(2, "abc").parse_peek(s)/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(InputError::new("123", ErrorKind::Tag))));/// Arbitrary repetitions:///   repeat(0..=2, "abc").parse_peek(s)/// Implementation of [`repeat`]/// Repeats the embedded parser, calling `g` to gather the results/// **Warning:** If the parser passed to `fold` accepts empty inputs/// (like `alpha0` or `digit0`), `fold_repeat` will return an error,///   repeat(///     0..,///     "abc"///   ).fold(///   ).parse_peek(s)///     1..,///     "abc",/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(InputError::new("123123", ErrorKind::Many))));/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Many))));/// Arbitrary number of repetitions:///     0..=2,repeat0_repeat1_repeat_n_repeat_m_n_repeat_till/// [`Accumulate`] the output of parser `f` into a container, like `Vec`, until the parser `g`/// produces a result./// `f` keeps going so long as `g` produces [`ErrMode::Backtrack`]. To instead chain an error up, see [`cut_err`][crate::combinator::cut_err]./// use winnow::combinator::repeat_till;///   repeat_till(0.., "abc", "end").parse_peek(s)/// assert_eq!(parser("abc123end"), Err(ErrMode::Backtrack(InputError::new("123end", ErrorKind::Tag))));/// assert_eq!(parser("123123end"), Err(ErrMode::Backtrack(InputError::new("123123end", ErrorKind::Tag))));repeat_till0/// Deprecated, replaced with [`repeat_till`]repeat_till0_repeat_till_m_n_/// [`Accumulate`] the output of a parser, interleaved with `sep`/// This stops when either parser returns [`ErrMode::Backtrack`]. To instead chain an error up, see/// * `range` The minimum and maximum number of iterations./// * `parser` The parser that parses the elements of the list./// * `sep` The parser that parses the separator between list elements./// **Warning:** If the separator parser accepts empty inputs/// (like `alpha0` or `digit0`), `separated` will return an error,/// use winnow::combinator::separated;///   separated(0.., "abc", "|").parse_peek(s)///   separated(1.., "abc", "|").parse_peek(s)/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(InputError::new("def|abc", ErrorKind::Tag))));///   separated(2, "abc", "|").parse_peek(s)/// assert_eq!(parser("abc|abc|abc"), Ok(("|abc", vec!["abc", "abc"])));/// assert_eq!(parser("abc123abc"), Err(ErrMode::Backtrack(InputError::new("123abc", ErrorKind::Tag))));/// assert_eq!(parser("abc|def"), Err(ErrMode::Backtrack(InputError::new("def", ErrorKind::Tag))));///   separated(0..=2, "abc", "|").parse_peek(s)/// * `parser` Parses the elements of the list./// use winnow::combinator::separated0;///   separated0("abc", "|").parse_peek(s)separated0_/// use winnow::combinator::separated1;///   separated1("abc", "|").parse_peek(s)separated1_separated_n_separated_m_n_separated_foldl1/// Alternates between two parsers, merging the results (left associative)/// use winnow::combinator::separated_foldl1;/// use winnow::ascii::dec_int;/// fn parser(s: &str) -> IResult<&str, i32> {///   separated_foldl1(dec_int, "-", |l, _, r| l - r).parse_peek(s)/// assert_eq!(parser("9-3-5"), Ok(("", 1)));/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(InputError::new("def|abc", ErrorKind::Slice))));separated_foldr1/// Alternates between two parsers, merging the results (right associative)/// use winnow::combinator::separated_foldr1;/// use winnow::ascii::dec_uint;/// fn parser(s: &str) -> IResult<&str, u32> {///   separated_foldr1(dec_uint, "^", |l: u32, _, r: u32| l.pow(r)).parse_peek(s)/// assert_eq!(parser("2^3^2"), Ok(("", 512)));/// assert_eq!(parser("2"), Ok(("", 2)));/// Repeats the embedded parser, filling the given slice with results./// use winnow::combinator::fill;///   let (rest, ()) = fill("abc", &mut buf).parse_peek(s)?;fold_repeat/// Deprecated, replaced with [`Repeat::fold`]fold_repeat0_fold_repeat1_fold_repeat_m_n_ByRef/// Implementation of [`Parser::by_ref`]o2/// Implementation of [`Parser::map`]e2/// Implementation of [`Parser::try_map`]VerifyMap/// Implementation of [`Parser::verify_map`]/// Implementation of [`Parser::and_then`]/// Implementation of [`Parser::parse_to`]/// Implementation of [`Parser::flat_map`]CompleteErr/// Implementation of [`Parser::complete_err`]/// Implementation of [`Parser::verify`]/// Implementation of [`Parser::value`]/// Implementation of [`Parser::default_value`]/// Implementation of [`Parser::void`]Recognize/// Implementation of [`Parser::recognize`]WithRecognized/// Implementation of [`Parser::with_recognized`]/// Implementation of [`Parser::span`]/// Implementation of [`Parser::with_span`]OutputInto/// Implementation of [`Parser::output_into`]/// Implementation of [`Parser::err_into`]/// Implementation of [`Parser::context`]/// Sequence two parsers, only returning the output from the second./// See also [`seq`] to generalize this across any number of fields./// use winnow::combinator::preceded;/// let mut parser = preceded("abc", "efg");/// assert_eq!(parser.parse_peek("abcefg"), Ok(("", "efg")));/// assert_eq!(parser.parse_peek("abcefghij"), Ok(("hij", "efg")));/// assert_eq!(parser.parse_peek("123"), Err(ErrMode::Backtrack(InputError::new("123", ErrorKind::Tag))));/// Sequence two parsers, only returning the output of the first./// use winnow::combinator::terminated;/// let mut parser = terminated("abc", "efg");/// assert_eq!(parser.parse_peek("abcefg"), Ok(("", "abc")));/// assert_eq!(parser.parse_peek("abcefghij"), Ok(("hij", "abc")));/// Sequence three parsers, only returning the values of the first and third./// use winnow::combinator::separated_pair;/// let mut parser = separated_pair("abc", "|", "efg");/// assert_eq!(parser.parse_peek("abc|efg"), Ok(("", ("abc", "efg"))));/// assert_eq!(parser.parse_peek("abc|efghij"), Ok(("hij", ("abc", "efg"))));/// Sequence three parsers, only returning the output of the second./// use winnow::combinator::delimited;/// let mut parser = delimited("(", "abc", ")");/// assert_eq!(parser.parse_peek("(abc)"), Ok(("", "abc")));/// assert_eq!(parser.parse_peek("(abc)def"), Ok(("def", "abc")));test_parser_flat_maptest_closure_compiles_195test_parser_verify_maptest_parser_map_parsertest_parser_intotest_parser_verifytest_parser_verify_reftest_parser_verify_allocalt_arrayseparated0_testseparated0_empty_sep_testseparated1_testseparated_testrepeat0_testrepeat0_empty_testrepeat1_testrepeat_till_testrepeat_till_range_testrepeat_testfold_repeat0_testfold_repeat0_empty_testfold_repeat1_testfold_repeat_testrepeat0_count_testrepeat1_count_test// Here for intra-doc links/// For use with [`Parser::parse_peek`] which allows the input stream to be threaded through a/// - `Ok((I, O))` is the remaining [input][crate::stream] and the parsed value/// - [`Err(ErrMode<E>)`][ErrMode] is the error along with how to respond to it/// By default, the error type (`E`) is [`InputError`]/// When integrating into the result of the application, see/// - [`Parser::parse`]/// - [`ErrMode::into_inner`]/// For use with [`Parser::parse_next`]/// - `Ok(O)` is the parsed value/// By default, the error type (`E`) is [`ContextError`]./// **Note:** This is only possible for `Stream` that are [partial][`crate::stream::StreamIsPartial`],/// like [`Partial`][crate::Partial]./// There was not enough data to determine the appropriate action/// More data needs to be buffered before retrying the parse./// This must only be set when the [`Stream`] is [partial][`crate::stream::StreamIsPartial`], like with/// [`Partial`][crate::Partial]/// Convert this into an `Backtrack` with [`Parser::complete_err`]/// The parser failed with a recoverable error (the default)./// For example, a parser for json values might include a/// [`dec_uint`][crate::ascii::dec_uint] as one case in an [`alt`][crate::combinator::alt]/// combinator. If it fails, the next case should be tried./// The parser had an unrecoverable error./// The parser was on the right branch, so directly report it to the user rather than trying/// other branches. You can use [`cut_err()`][crate::combinator::cut_err] combinator to switch/// from `ErrMode::Backtrack` to `ErrMode::Cut`./// For example, one case in an [`alt`][crate::combinator::alt] combinator found a unique prefix/// and you want any further errors parsing the case to be reported to the user./// Add parse error state to [`ParserError`]s/// Prevent backtracking, bubbling the error up to the top/// Enable backtracking support/// Unwrap the mode, returning the underlying error/// Returns `None` for [`ErrMode::Incomplete`]EXT/// Maps `ErrMode<InputError<T>>` to `ErrMode<InputError<U>>` with the given `F: T -> U`/// Creates an error from the input position and an [`ErrorKind`]/// Process a parser assertion/// Like [`ParserError::from_error_kind`] but merges it with the existing error./// This is useful when backtracking through a parse tree, accumulating error context on the/// Combines errors from two different parse branches./// For example, this would be used by [`alt`][crate::combinator::alt] to report the error from/// each case./// The basic [`Parser`] trait for errors/// Append to an existing error custom data/// This is used mainly by [`Parser::context`], to add user friendly information/// Used by [`Parser::context`] to add custom data to error while backtracking/// May be implemented multiple times for different kinds of context.from_recoverable_errorCheckpoint/// Capture context from when an error was recoveredFromRecoverableError/// Like [`ParserError::from_error_kind`] but also include an external error./// Create a new error with an external error, from [`std::str::FromStr`]/// This trait is required by the [`Parser::try_map`] combinator./// Equivalent of `From` implementation to avoid orphan rules in bits parsers/// The input stream, pointing to the location where the error occurred/// A rudimentary error kind/// Capture input on error/// This is useful for testing of generic parsers to ensure the error happens at the right/// **Note:** [context][Parser::context] and inner errors (like from [`Parser::try_map`]) will be/// Creates a new basic error/// Translate the input type/// The Display implementation allows the `std::error::Error` implementation/// Accumulate context while backtracking errors/// Create an empty error/// Access context from [`Parser::context`]/// Originating [`std::error::Error`]// For tests/// Description of what is currently being parsed/// Grammar item that was expected/// Additional parse context for [`ContextError`] added via [`Parser::context`]CharLiteral/// A [`char`] tokenStringLiteral/// A [`&str`] token/// A description of what was being parsed/// See [`StrContext`]TreeErrorTreeErrorBase/// Initial error that kicked things offTreeErrorFrame/// Traces added to the error while walking back up the stack/// All failed branches of an `alt`/// Trace all error paths, particularly for tests/// See [`ParserError::append`]TreeErrorContext/// See [`AddContext::add_context`]/// See [`TreeError::Stack`]/// Parsed input, at the location where the error occurred/// Debug context/// See [`FromExternalError::from_external_error`]/// See [`TreeErrorFrame::Kind`], [`ParserError::append`]/// See [`TreeErrorFrame::Context`], [`AddContext::add_context`]append_frameabbreviate/// Accumulated error information/// Deprecated, replaced with [`ContextError`]Winnow/// Error kind given by various parsersMany/// Provide some minor debug context for errors/// Converts an `ErrorKind` to a text description/// See [`Parser::parse`]/// The [`Stream`] at the initial location when parsing started/// The location in [`ParseError::input`] where parsing failed/// **Note:** This is an offset, not an index, and may point to the end of input/// (`input.len()`) on eof errors./// The original [`ParserError`]single_linetest_parse_error/// Creates a parse error from a [`ErrorKind`]//! # Error management//! Errors are designed with multiple needs in mind://! - Accumulate more [context][Parser::context] as the error goes up the parser chain//! - Distinguish between [recoverable errors,//!   unrecoverable errors, and more data is needed][ErrMode]//! - Have a very low overhead, as errors are often discarded by the calling parser (examples: `repeat`, `alt`)//! - Can be modified according to the user's needs, because some languages need a lot more information//! - Help thread-through the [stream][crate::stream]//! To abstract these needs away from the user, generally `winnow` parsers use the [`PResult`]//! alias, rather than [`Result`].  [`Parser::parse`] is a top-level operation//! that can help convert to a `Result` for integrating with your application's error reporting.//! Error types include://! - `()`//! - [`ErrorKind`]//! - [`InputError`] (mostly for testing)//! - [`ContextError`]//! - [`TreeError`] (mostly for testing)//! - [Custom errors][crate::_topic::error]/// internal std exports for `no_std` compatibility/// Core concepts available for glob import/// Including/// - [`StreamIsPartial`][crate::stream::StreamIsPartial]/// - [`Parser`]/// fn parse_data(input: &mut &str) -> PResult<u64> {/// #   winnow::ascii::dec_uint(input)///   let result = parse_data.parse("100");///   assert_eq!(result, Ok(100));//! > winnow, making parsing a breeze//! `winnow` is a parser combinator library//! Quick links://! - [List of combinators][crate::combinator]//! - [Tutorial][_tutorial::chapter_0]//! - [Special Topics][_topic]//! - [Discussions](https://github.com/winnow-rs/winnow/discussions)//! - [CHANGELOG](https://github.com/winnow-rs/winnow/blob/v0.5.40/CHANGELOG.md) (includes major version migration//! `winnow` aims to be your "do everything" parser, much like people treat regular expressions.//! In roughly priority order://! 1. Support writing parser declaratively while not getting in the way of imperative-style//!    parsing when needed, working as an open-ended toolbox rather than a close-ended framework.//! 2. Flexible enough to be used for any application, including parsing binary data, strings, or//!    separate lexing and parsing phases//! 3. Zero-cost abstractions, making it easy to write high performance parsers//! 4. Easy to use, making it trivial for one-off uses//! In addition://!   - Leverage feature flags to keep one active branch//! - We will support the last 6 months of rust releases (MSRV, currently 1.64.0)//! See also [Special Topic: Why winnow?][crate::_topic::why]//! $ cargo add winnow//! Then use it to parse://! See also the [Tutorial][_tutorial::chapter_0] and [Special Topics][_topic]// BEGIN - Embark standard lints v6 for Rust 1.55+// do not change or add/remove here, but one can add exceptions after this section// for more info see: <https://github.com/EmbarkStudios/rust-ecosystem/issues/59>// "-Dunsafe_code",// END - Embark standard lints v6 for Rust 1.55+/// `match` for parsers/// When parsers have unique prefixes to test for, this offers better performance over/// [`alt`][crate::combinator::alt] though it might be at the cost of duplicating parts of your grammar/// if you needed to [`peek`][crate::combinator::peek]./// For tight control over the error in a catch-all case, use [`fail`][crate::combinator::fail]./// use winnow::combinator::dispatch;/// # use winnow::token::any;/// # use winnow::combinator::peek;/// # use winnow::combinator::empty;/// # use winnow::combinator::fail;/// fn escaped(input: &mut &str) -> PResult<char> {///     preceded('\\', escape_seq_char).parse_next(input)/// fn escape_seq_char(input: &mut &str) -> PResult<char> {///     dispatch! {any;///         'b' => empty.value('\u{8}'),///         'f' => empty.value('\u{c}'),///         'n' => empty.value('\n'),///         'r' => empty.value('\r'),///         't' => empty.value('\t'),///         '\\' => empty.value('\\'),///         '"' => empty.value('"'),///         _ => fail::<_, char, _>,///     .parse_next(input)/// assert_eq!(escaped.parse_peek("\\nHello"), Ok(("Hello", '\n')));// forced to be visible in intended location/// Initialize a struct or tuple out of a sequences of parsers///# Example/// # use winnow::ascii::{alphanumeric1, dec_uint, space0};/// # use winnow::combinator::delimited;/// # use winnow::error::ContextError;/// use winnow::combinator::seq;/// #[derive(Default, Debug, PartialEq)]///     namespace: u32,///     name: Vec<u8>,///     value: Vec<u8>,///     point: (u32, u32),///     metadata: Vec<u8>,/// // Parse into structs / tuple-structs/// fn field(input: &mut &[u8]) -> PResult<Field> {///     seq!{Field {///         namespace: empty.value(5),///         name: alphanumeric1.map(|s: &[u8]| s.to_owned()),///         // `_` fields are ignored when building the struct///         _: (space0, b':', space0),///         value: alphanumeric1.map(|s: &[u8]| s.to_owned()),///         point: point,///         // default initialization also works///         ..Default::default()///     }}.parse_next(input)/// // Or parse into tuples/// fn point(input: &mut &[u8]) -> PResult<(u32, u32)> {///     let num = dec_uint::<_, u32, ContextError>;///     seq!(num, _: (space0, b',', space0), num).parse_next(input)///     field.parse_peek(&b"test: data: 123 , 4"[..]),///     Ok((///         &b""[..],///         Field {///             namespace: 5,///             name: b"test"[..].to_owned(),///             value: b"data"[..].to_owned(),///             point: (123, 4),///             metadata: Default::default(),seq_parse_struct_fieldsseq_parse_tuple_fieldsseq_init_struct_fieldsseq_init_tuple_fieldsdispatch_basicsseq_struct_basicsseq_struct_default_initseq_struct_trailing_comma_elidedseq_struct_no_trailing_commaseq_struct_no_trailing_comma_elidedseq_tuple_struct_basicsseq_tuple_struct_trailing_comma_elidedseq_tuple_struct_no_trailing_commaseq_tuple_struct_no_trailing_comma_elidedseq_tuple_basicsseq_tuple_trailing_comma_elidedseq_tuple_no_trailing_commaseq_tuple_no_trailing_comma_elidedseq_tuple_no_parensAsciiCaseless// Force users to deal with `Incomplete` when `StreamIsPartial<true>`/// Parse all of `input`, generating `O` from it/// Take tokens from the [`Stream`], turning it into the output/// This includes advancing the [`Stream`] to the next location./// On error, `input` will be left pointing at the error location.parse_peek/// Treat `&mut Self` as a parser/// This helps when needing to move a `Parser` when all you have is a `&mut Parser`./// Because parsers are `FnMut`, they can be called multiple times. This prevents moving `f`/// into [`length_data`][crate::binary::length_data] and `g` into/// [`Parser::complete_err`]:/// # use winnow::Parser;/// # use winnow::error::ParserError;/// # use winnow::binary::length_data;/// pub fn length_value<'i, O, E: ParserError<&'i [u8]>>(///     mut f: impl Parser<&'i [u8], usize, E>,///     mut g: impl Parser<&'i [u8], O, E>/// ) -> impl Parser<&'i [u8], O, E> {///   move |i: &mut &'i [u8]| {///     let mut data = length_data(f).parse_next(i)?;///     let o = g.complete_err().parse_next(&mut data)?;///     Ok(o)/// By adding `by_ref`, we can make this work:///     let mut data = length_data(f.by_ref()).parse_next(i)?;///     let o = g.by_ref().complete_err().parse_next(&mut data)?;/// Produce the provided value/// # use winnow::{error::ErrMode,error::ErrorKind, error::InputError, Parser};/// let mut parser = alpha1.value(1234);/// assert_eq!(parser.parse_peek("abcd"), Ok(("", 1234)));/// assert_eq!(parser.parse_peek("123abcd;"), Err(ErrMode::Backtrack(InputError::new("123abcd;", ErrorKind::Slice))));/// Produce a type's default value/// let mut parser = alpha1.default_value::<u32>();/// assert_eq!(parser.parse_peek("abcd"), Ok(("", 0)));/// Discards the output of the `Parser`/// let mut parser = alpha1.void();/// assert_eq!(parser.parse_peek("abcd"), Ok(("", ())));output_into/// Convert the parser's output to another type using [`std::convert::From`]/// fn parser1<'s>(i: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {///   alpha1(i)/// let mut parser2 = parser1.output_into();/// let bytes: IResult<&str, Vec<u8>> = parser2.parse_peek("abcd");/// Produce the consumed input as produced value./// use winnow::ascii::{alpha1};/// let mut parser = separated_pair(alpha1, ',', alpha1).recognize();/// assert_eq!(parser.parse_peek("abcd,efgh"), Ok(("", "abcd,efgh")));/// assert_eq!(parser.parse_peek("abcd;"),Err(ErrMode::Backtrack(InputError::new(";", ErrorKind::Verify))));with_recognized/// Produce the consumed input with the output/// Functions similarly to [recognize][Parser::recognize] except it/// Returned tuple is of the format `(produced output, consumed input)`./// # use winnow::{error::ErrMode,error::ErrorKind, error::InputError};/// fn inner_parser<'s>(input: &mut &'s str) -> PResult<bool, InputError<&'s str>> {///     "1234".value(true).parse_next(input)/// let mut consumed_parser = separated_pair(alpha1, ',', alpha1).value(true).with_recognized();/// assert_eq!(consumed_parser.parse_peek("abcd,efgh1"), Ok(("1", (true, "abcd,efgh"))));/// assert_eq!(consumed_parser.parse_peek("abcd;"),Err(ErrMode::Backtrack(InputError::new(";", ErrorKind::Verify))));/// // the second output (representing the consumed input)/// let mut recognize_parser = inner_parser.recognize();/// let mut consumed_parser = inner_parser.with_recognized().map(|(output, consumed)| consumed);/// assert_eq!(recognize_parser.parse_peek("1234"), consumed_parser.parse_peek("1234"));/// assert_eq!(recognize_parser.parse_peek("abcd"), consumed_parser.parse_peek("abcd"));/// Produce the location of the consumed input as produced value./// # use winnow::{error::ErrMode,error::ErrorKind, error::InputError, stream::Stream};/// use winnow::stream::Located;/// let mut parser = separated_pair(alpha1.span(), ',', alpha1.span());/// assert_eq!(parser.parse(Located::new("abcd,efgh")), Ok((0..4, 5..9)));/// assert_eq!(parser.parse_peek(Located::new("abcd;")),Err(ErrMode::Backtrack(InputError::new(Located::new("abcd;").peek_slice(4).0, ErrorKind::Verify))));/// Produce the location of consumed input with the output/// Functions similarly to [`Parser::span`] except it/// fn inner_parser<'s>(input: &mut Located<&'s str>) -> PResult<bool, InputError<Located<&'s str>>> {/// let mut consumed_parser = separated_pair(alpha1.value(1).with_span(), ',', alpha1.value(2).with_span());/// assert_eq!(consumed_parser.parse(Located::new("abcd,efgh")), Ok(((1, 0..4), (2, 5..9))));/// assert_eq!(consumed_parser.parse_peek(Located::new("abcd;")),Err(ErrMode::Backtrack(InputError::new(Located::new("abcd;").peek_slice(4).0, ErrorKind::Verify))));/// // should be the same as that of the `span` parser./// let mut recognize_parser = inner_parser.span();/// let mut consumed_parser = inner_parser.with_span().map(|(output, consumed)| consumed);/// assert_eq!(recognize_parser.parse_peek(Located::new("1234")), consumed_parser.parse_peek(Located::new("1234")));/// assert_eq!(recognize_parser.parse_peek(Located::new("abcd")), consumed_parser.parse_peek(Located::new("abcd")));/// Maps a function over the output of a parser/// use winnow::{error::ErrMode,error::ErrorKind, error::InputError, Parser};/// use winnow::ascii::digit1;/// let mut parser = digit1.map(|s: &str| s.len());/// assert_eq!(parser.parse_peek("123456"), Ok(("", 6)));/// assert_eq!(parser.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Slice))));/// Applies a function returning a `Result` over the output of a parser./// let mut parse = digit1.try_map(|s: &str| s.parse::<u8>());/// assert_eq!(parse.parse_peek("123"), Ok(("", 123)));/// assert_eq!(parse.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Slice))));/// assert_eq!(parse.parse_peek("123456"), Err(ErrMode::Backtrack(InputError::new("123456", ErrorKind::Verify))));verify_map/// Apply both [`Parser::verify`] and [`Parser::map`]./// let mut parse = digit1.verify_map(|s: &str| s.parse::<u8>().ok());/// Creates a parser from the output of this one/// # use winnow::{error::ErrMode,error::ErrorKind, error::InputError, PResult, Parser};/// use winnow::token::take;/// fn length_data<'s>(input: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {///     u8.flat_map(take).parse_next(input)/// assert_eq!(length_data.parse_peek(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..])));/// assert_eq!(length_data.parse_peek(&[4, 0, 1, 2][..]), Err(ErrMode::Backtrack(InputError::new(&[0, 1, 2][..], ErrorKind::Slice))));/// which is the same as///     let length = u8.parse_next(input)?;///     let data = take(length).parse_next(input)?;///     Ok(data)/// let mut digits = take(5u8).and_then(digit1);/// assert_eq!(digits.parse_peek("12345"), Ok(("", "12345")));/// assert_eq!(digits.parse_peek("123ab"), Ok(("", "123")));/// assert_eq!(digits.parse_peek("123"), Err(ErrMode::Backtrack(InputError::new("123", ErrorKind::Slice))));/// Apply [`std::str::FromStr`] to the output of the parser/// fn parser<'s>(input: &mut &'s str) -> PResult<u64, InputError<&'s str>> {///     digit1.parse_to().parse_next(input)/// assert_eq!(parser.parse_peek("123456"), Ok(("", 123456)));/// Returns the output of the child parser if it satisfies a verification function./// let mut parser = alpha1.verify(|s: &str| s.len() == 4);/// assert_eq!(parser.parse_peek("abcd"), Ok(("", "abcd")));/// assert_eq!(parser.parse_peek("abcde"), Err(ErrMode::Backtrack(InputError::new("abcde", ErrorKind::Verify))));/// assert_eq!(parser.parse_peek("123abcd;"),Err(ErrMode::Backtrack(InputError::new("123abcd;", ErrorKind::Slice))));/// If parsing fails, add context to the error/// This is used mainly to add user friendly information/// to errors when backtracking through a parse tree.complete_err/// Transforms [`Incomplete`][crate::error::ErrMode::Incomplete] into [`Backtrack`][crate::error::ErrMode::Backtrack]/// # use winnow::{error::ErrMode, error::ErrorKind, error::InputError, stream::Partial, Parser};/// # use winnow::token::take;/// let mut parser = take(5u8).complete_err();/// assert_eq!(parser.parse_peek(Partial::new("abcdefg")), Ok((Partial::new("fg"), "abcde")));/// assert_eq!(parser.parse_peek(Partial::new("abcd")), Err(ErrMode::Backtrack(InputError::new(Partial::new("abcd"), ErrorKind::Complete))));/// Convert the parser's error to another type using [`std::convert::From`]/// Core trait for parsing/// The simplest way to implement a `Parser` is with a function/// fn empty(input: &mut &str) -> PResult<()> {///     let output = ();///     Ok(output)/// let (input, output) = empty.parse_peek("Hello").unwrap();/// assert_eq!(input, "Hello");  // We didn't consume any input/// which can be made stateful by returning a function/// fn empty<O: Clone>(output: O) -> impl FnMut(&mut &str) -> PResult<O> {///     move |input: &mut &str| {///         let output = output.clone();///         Ok(output)/// let (input, output) = empty("World").parse_peek("Hello").unwrap();/// assert_eq!(output, "World");/// Additionally, some basic types implement `Parser` as well, including/// - `u8` and `char`, see [`winnow::token::one_of`][crate::token::one_of]/// - `&[u8]` and `&str`, see [`winnow::token::tag`][crate::token::tag]/// This is a shortcut for [`one_of`][crate::token::one_of]./// # use winnow::{error::ErrMode, error::{ErrorKind, InputError}};/// fn parser<'s>(i: &mut &'s [u8]) -> PResult<u8, InputError<&'s [u8]>>  {///     b'a'.parse_next(i)/// assert_eq!(parser.parse_peek(&b"abc"[..]), Ok((&b"bc"[..], b'a')));/// assert_eq!(parser.parse_peek(&b" abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b" abc"[..], ErrorKind::Verify))));/// assert_eq!(parser.parse_peek(&b"bc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"bc"[..], ErrorKind::Verify))));/// assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Token))));/// fn parser<'s>(i: &mut &'s str) -> PResult<char, InputError<&'s str>> {///     'a'.parse_next(i)/// assert_eq!(parser.parse_peek("abc"), Ok(("bc", 'a')));/// assert_eq!(parser.parse_peek(" abc"), Err(ErrMode::Backtrack(InputError::new(" abc", ErrorKind::Verify))));/// assert_eq!(parser.parse_peek("bc"), Err(ErrMode::Backtrack(InputError::new("bc", ErrorKind::Verify))));/// This is a shortcut for [`tag`][crate::token::tag]./// fn parser<'s>(s: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {///   alt((&"Hello"[..], take(5usize))).parse_next(s)/// assert_eq!(parser.parse_peek(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));/// assert_eq!(parser.parse_peek(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));/// assert_eq!(parser.parse_peek(&b"Some"[..]), Err(ErrMode::Backtrack(InputError::new(&b"Some"[..], ErrorKind::Slice))));/// assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Slice))));/// use winnow::ascii::Caseless;///   alt((Caseless(&"hello"[..]), take(5usize))).parse_next(s)/// assert_eq!(parser.parse_peek(&b"hello, World!"[..]), Ok((&b", World!"[..], &b"hello"[..])));/// assert_eq!(parser.parse_peek(&b"HeLlo, World!"[..]), Ok((&b", World!"[..], &b"HeLlo"[..])));///   alt((b"Hello", take(5usize))).parse_next(s)///   alt((Caseless(b"hello"), take(5usize))).parse_next(s)///   alt(("Hello", take(5usize))).parse_next(s)/// assert_eq!(parser.parse_peek("Something"), Ok(("hing", "Somet")));/// assert_eq!(parser.parse_peek("Some"), Err(ErrMode::Backtrack(InputError::new("Some", ErrorKind::Slice))));///   alt((Caseless("hello"), take(5usize))).parse_next(s)impl_parser_for_tupleimpl_parser_for_tuples/// Convert a [`Parser::parse_peek`] style parse function to be a [`Parser`]impl_partial_eqimpl_partial_ordcleantest_pretty_debugtest_sliced/// UTF-8 Stream/// Improved `Debug` experience for `&[u8]` byte streams/// Make a stream out of a byte slice-like./// Improved `Debug` experience for `&[u8]` UTF-8-ish streams/// Allow collecting the span of a parsed token/// Spans are tracked as a [`Range<usize>`] of byte offsets./// Converting byte offsets to line or column numbers is left up to the user, as computing column/// numbers requires domain knowledge (are columns byte-based, codepoint-based, or grapheme-based?)/// and O(n) iteration over the input to determine codepoint and line boundaries./// [The `line-span` crate](https://docs.rs/line-span/latest/line_span/) can help with converting/// byte offsets to line numbers./// See [`Parser::span`][crate::Parser::span] and [`Parser::with_span`][crate::Parser::with_span] for more details/// Wrap another Stream with span tracking/// Inner input being wrapped in state/// User-provided state/// Thread global state through your parsers/// Use cases/// - Recursion checks/// - Error recovery/// - Debugging/// # use std::cell::Cell;/// # use winnow::stream::Stateful;/// # type Error = ();/// struct State<'s>(&'s Cell<u32>);/// impl<'s> State<'s> {///     fn count(&self) {///         self.0.set(self.0.get() + 1);/// type Stream<'is> = Stateful<&'is str, State<'is>>;/// fn word<'s>(i: &mut Stream<'s>) -> PResult<&'s str> {///   i.state.count();///   alpha1.parse_next(i)/// let data = "Hello";/// let state = Cell::new(0);/// let input = Stream { input: data, state: State(&state) };/// let output = word.parse(input).unwrap();/// assert_eq!(state.get(), 1);/// Mark the input as a partial buffer for streaming input./// Complete input means that we already have all of the data. This will be the common case with/// small files that can be read entirely to memory./// In contrast, streaming input assumes that we might not have all of the data./// This can happen with some network protocol or large file parsers, where the/// input buffer can be full and need to be resized or refilled./// - [`ErrMode::Incomplete`] will report how much more data is needed./// - [`Parser::complete_err`][crate::Parser::complete_err] transform [`ErrMode::Incomplete`] to///   [`ErrMode::Backtrack`]/// See also [`StreamIsPartial`] to tell whether the input supports complete or partial parsing./// See also [Special Topics: Parsing Partial Input][crate::_topic::partial]./// Here is how it works in practice:/// # use winnow::{PResult, error::ErrMode, error::Needed, error::{InputError, ErrorKind}, token, ascii, stream::Partial};/// fn take_partial<'s>(i: &mut Partial<&'s [u8]>) -> PResult<&'s [u8], InputError<Partial<&'s [u8]>>> {///   token::take(4u8).parse_next(i)/// fn take_complete<'s>(i: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {/// // both parsers will take 4 bytes as expected/// assert_eq!(take_partial.parse_peek(Partial::new(&b"abcde"[..])), Ok((Partial::new(&b"e"[..]), &b"abcd"[..])));/// assert_eq!(take_complete.parse_peek(&b"abcde"[..]), Ok((&b"e"[..], &b"abcd"[..])));/// // if the input is smaller than 4 bytes, the partial parser/// // will return `Incomplete` to indicate that we need more data/// assert_eq!(take_partial.parse_peek(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));/// // but the complete parser will return an error/// assert_eq!(take_complete.parse_peek(&b"abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"abc"[..], ErrorKind::Slice))));/// // the alpha0 function recognizes 0 or more alphabetic characters/// fn alpha0_partial<'s>(i: &mut Partial<&'s str>) -> PResult<&'s str, InputError<Partial<&'s str>>> {///   ascii::alpha0.parse_next(i)/// fn alpha0_complete<'s>(i: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {/// // if there's a clear limit to the recognized characters, both parsers work the same way/// assert_eq!(alpha0_partial.parse_peek(Partial::new("abcd;")), Ok((Partial::new(";"), "abcd")));/// assert_eq!(alpha0_complete.parse_peek("abcd;"), Ok((";", "abcd")));/// // but when there's no limit, the partial version returns `Incomplete`, because it cannot/// // know if more input data should be recognized. The whole input could be "abcd;", or/// // "abcde;"/// assert_eq!(alpha0_partial.parse_peek(Partial::new("abcd")), Err(ErrMode::Incomplete(Needed::new(1))));/// // while the complete version knows that all of the data is there/// assert_eq!(alpha0_complete.parse_peek("abcd"), Ok(("", "abcd")));/// Create a partial input/// Extract the original [`Stream`]slice_lenSliceLen/// The smallest unit being parsed/// Sequence of `Token`s/// Example: `&[u8]` for `Located<&[u8]>` or `&str` for `Located<&str>`/// Iterate with the offset from the current location/// A parse location within the streamiter_offsetseof_offset/// Returns the offset to the end of the input/// Split off the next token from the inputpeek_tokenoffset_for/// Finds the offset of the next matching tokenoffset_at/// Get the offset for the number of `tokens` into the stream/// This means "0 tokens" will return `0` offsetnext_slice/// Split off a slice of tokens from the input/// **NOTE:** For inputs with variable width tokens, like `&str`'s `char`, `offset` might not correspond/// with the number of tokens. To get a valid offset, use:/// - [`Stream::eof_offset`]/// - [`Stream::iter_offsets`]/// - [`Stream::offset_for`]/// - [`Stream::offset_at`]/// This will panic if/// * Indexes must be within bounds of the original input;/// * Indexes must uphold invariants of the stream, like for `str` they must lie on UTF-8///   sequence boundaries.peek_slice/// Advance to the end of the streampeek_finish/// Save the current parse location within the stream/// Revert the stream to a prior [`Self::Checkpoint`]/// May panic if an invalid [`Self::Checkpoint`] is provided/// Return the inner-most stream/// Core definition for parser input stateBitOffsets/// Iterator for [bit][crate::binary::bits] stream (`(I, usize)`)/// Number of indices input has advanced since start of parsing/// See [`Located`] for adding location tracking to your [`Stream`]PartialState/// Whether the stream is currently partial or complete/// Mark the stream is completerestore_partial/// Restore the stream back to its previous stateis_partial_supported/// Report whether the [`Stream`] is can ever be incomplete/// Report whether the [`Stream`] is currently incomplete/// Marks the input as being the complete buffer or a partial buffer for streaming input/// See [`Partial`] for marking a presumed complete buffer type as a streaming buffer./// Offset between the first byte of `start` and the first byte of `self`a/// (`start.len()`) when `self` is exhausted.as_bstr/// Result of [`Compare::compare`]find_slice/// Returns the offset of the slice if it is foundFindSlice/// Look for a slice in selfparse_slice/// Succeeds if `parse()` succeededThe/// The byte slice implementation will first convert it to a `&str`, then apply the `parse()`/// functionupdate_slice/// Convert an `Output` type to be used as `Stream`/// Convert a `Stream` into an appropriate `Output` type/// Ensure checkpoint details are kept private/// A range bounded inclusively for counting parses performedclamp_capacity/// Makes a char from self/// use winnow::stream::AsChar as _;/// assert_eq!('a'.as_char(), 'a');/// assert_eq!(u8::MAX.as_char(), std::char::from_u32(u8::MAX as u32).unwrap());/// **Warning:** for `&str` it recognizes alphabetic/// Tests that self is ASCII space or tab/// Transforms a token into a char for basic string parsingcontains_token/// Check if a token in in a set of possible tokens/// This is generally implemented on patterns that a token may match and supports `u8` and `char`/// tokens along with the following patterns/// - `b'c'` and `'c'`/// - `b""` and `""`/// - `|c| true`/// - `b'a'..=b'z'`, `'a'..='z'` (etc for each [range type][std::ops])/// - `(pattern1, pattern2, ...)`/// For example, you could implement `hex_digit0` as:/// fn hex_digit1<'s>(input: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {///     take_while(1.., ('a'..='f', 'A'..='F', '0'..='9')).parse_next(input)/// assert_eq!(hex_digit1.parse_peek("21cZ"), Ok(("Z", "21c")));/// assert_eq!(hex_digit1.parse_peek("H2"), Err(ErrMode::Backtrack(InputError::new("H2", ErrorKind::Slice))));/// assert_eq!(hex_digit1.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));impl_contains_token_for_tupleimpl_contains_token_for_tuplesmemmem2memmem3memmem_memmem2_memmem3_//! Stream capability for combinators to parse//! Stream types include://! - `&[u8]` and [`Bytes`] for binary data//! - `&str` (aliased as [`Str`]) and [`BStr`] for UTF-8 data//! - [`Located`] can track the location within the original buffer to report//!   [spans][crate::Parser::with_span]//! - [`Stateful`] to thread global state through your parsers//! - [`Partial`] can mark an input as partial buffer that is being streamed into//! - [Custom stream types][crate::_topic::stream]test_fxhashmap_compilestest_bit_stream_emptytest_bit_offset_emptybit_stream_innertest_partial_completetest_custom_slicetest_tag_support_char/// Matches one token/// # use winnow::{token::any, error::ErrMode, error::{InputError, ErrorKind}};///     any.parse_peek(input)/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Token))));/// # use winnow::{token::any, error::ErrMode, error::ErrorKind, error::InputError, error::Needed};/// assert_eq!(any::<_, InputError<_>>.parse_peek(Partial::new("abc")), Ok((Partial::new("bc"),'a')));/// assert_eq!(any::<_, InputError<_>>.parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));any_/// Recognizes a literal/// It will return `Err(ErrMode::Backtrack(InputError::new(_, ErrorKind::Tag)))` if the input doesn't match the pattern/// **Note:** [`Parser`] is implemented for strings and byte strings as a convenience (complete/// only)///   "Hello".parse_peek(s)/// assert_eq!(parser("Something"), Err(ErrMode::Backtrack(InputError::new("Something", ErrorKind::Tag))));/// fn parser(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(parser(Partial::new("Hello, World!")), Ok((Partial::new(", World!"), "Hello")));/// assert_eq!(parser(Partial::new("Something")), Err(ErrMode::Backtrack(InputError::new(Partial::new("Something"), ErrorKind::Tag))));/// assert_eq!(parser(Partial::new("S")), Err(ErrMode::Backtrack(InputError::new(Partial::new("S"), ErrorKind::Tag))));/// assert_eq!(parser(Partial::new("H")), Err(ErrMode::Incomplete(Needed::new(4))));///   tag(Caseless("hello")).parse_peek(s)/// Deprecated, replaced with [`literal`]literal_/// Recognizes a case insensitive literal./// It will return `Err(ErrMode::Backtrack(InputError::new(_, ErrorKind::Tag)))` if the input doesn't match the pattern./// use winnow::token::tag_no_case;///   tag_no_case("hello").parse_peek(s)/// assert_eq!(parser(Partial::new("hello, World!")), Ok((Partial::new(", World!"), "hello")));/// assert_eq!(parser(Partial::new("HeLlO, World!")), Ok((Partial::new(", World!"), "HeLlO")));/// assert_eq!(parser(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(5))));tag_no_case_/// Recognize a token that matches the [pattern][ContainsToken]/// **Note:** [`Parser`] is implemented as a convenience (complete/// only) for/// - `u8`/// assert_eq!(one_of::<_, _, InputError<_>>(['a', 'b', 'c']).parse_peek("b"), Ok(("", 'b')));/// assert_eq!(one_of::<_, _, InputError<_>>('a').parse_peek("bc"), Err(ErrMode::Backtrack(InputError::new("bc", ErrorKind::Verify))));/// assert_eq!(one_of::<_, _, InputError<_>>('a').parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Token))));/// fn parser_fn(i: &str) -> IResult<&str, char> {///     one_of(|c| c == 'a' || c == 'b').parse_peek(i)/// assert_eq!(parser_fn("abc"), Ok(("bc", 'a')));/// assert_eq!(parser_fn("cd"), Err(ErrMode::Backtrack(InputError::new("cd", ErrorKind::Verify))));/// assert_eq!(parser_fn(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Token))));/// assert_eq!(one_of::<_, _, InputError<_>>(['a', 'b', 'c']).parse_peek(Partial::new("b")), Ok((Partial::new(""), 'b')));/// assert_eq!(one_of::<_, _, InputError<_>>('a').parse_peek(Partial::new("bc")), Err(ErrMode::Backtrack(InputError::new(Partial::new("bc"), ErrorKind::Verify))));/// assert_eq!(one_of::<_, _, InputError<_>>('a').parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// fn parser_fn(i: Partial<&str>) -> IResult<Partial<&str>, char> {/// assert_eq!(parser_fn(Partial::new("abc")), Ok((Partial::new("bc"), 'a')));/// assert_eq!(parser_fn(Partial::new("cd")), Err(ErrMode::Backtrack(InputError::new(Partial::new("cd"), ErrorKind::Verify))));/// assert_eq!(parser_fn(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognize a token that does not match the [pattern][ContainsToken]/// # use winnow::token::none_of;/// assert_eq!(none_of::<_, _, InputError<_>>(['a', 'b', 'c']).parse_peek("z"), Ok(("", 'z')));/// assert_eq!(none_of::<_, _, InputError<_>>(['a', 'b']).parse_peek("a"), Err(ErrMode::Backtrack(InputError::new("a", ErrorKind::Verify))));/// assert_eq!(none_of::<_, _, InputError<_>>('a').parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Token))));/// assert_eq!(none_of::<_, _, InputError<_>>(['a', 'b', 'c']).parse_peek(Partial::new("z")), Ok((Partial::new(""), 'z')));/// assert_eq!(none_of::<_, _, InputError<_>>(['a', 'b']).parse_peek(Partial::new("a")), Err(ErrMode::Backtrack(InputError::new(Partial::new("a"), ErrorKind::Verify))));/// assert_eq!(none_of::<_, _, InputError<_>>('a').parse_peek(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognize the longest (m <= len <= n) input slice that matches the [pattern][ContainsToken]/// It will return an `ErrMode::Backtrack(InputError::new(_, ErrorKind::Slice))` if the pattern wasn't met or is out/// *Partial version* will return a `ErrMode::Incomplete(Needed::new(1))` if the pattern reaches the end of the input or is too short./// To recognize a series of tokens, use [`repeat`][crate::combinator::repeat] to [`Accumulate`][crate::stream::Accumulate] into a `()` and then [`Parser::recognize`]./// Zero or more tokens:/// use winnow::token::take_while;/// use winnow::stream::AsChar;///   take_while(0.., AsChar::is_alpha).parse_peek(s)/// fn alpha(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {/// assert_eq!(alpha(Partial::new(b"latin123")), Ok((Partial::new(&b"123"[..]), &b"latin"[..])));/// assert_eq!(alpha(Partial::new(b"12345")), Ok((Partial::new(&b"12345"[..]), &b""[..])));/// assert_eq!(alpha(Partial::new(b"latin")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(alpha(Partial::new(b"")), Err(ErrMode::Incomplete(Needed::new(1))));/// One or more tokens:///   take_while(1.., AsChar::is_alpha).parse_peek(s)/// assert_eq!(alpha(b"12345"), Err(ErrMode::Backtrack(InputError::new(&b"12345"[..], ErrorKind::Slice))));///   take_while(1.., ('0'..='9', 'A'..='F')).parse_peek(s)/// assert_eq!(hex(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));/// assert_eq!(alpha(Partial::new(b"12345")), Err(ErrMode::Backtrack(InputError::new(Partial::new(&b"12345"[..]), ErrorKind::Slice))));/// fn hex(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(hex(Partial::new("123 and voila")), Ok((Partial::new(" and voila"), "123")));/// assert_eq!(hex(Partial::new("DEADBEEF and others")), Ok((Partial::new(" and others"), "DEADBEEF")));/// assert_eq!(hex(Partial::new("BADBABEsomething")), Ok((Partial::new("something"), "BADBABE")));/// assert_eq!(hex(Partial::new("D15EA5E")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(hex(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Arbitrary amount of tokens:///   take_while(3..=6, AsChar::is_alpha).parse_peek(s)/// assert_eq!(short_alpha(b"ed"), Err(ErrMode::Backtrack(InputError::new(&b"ed"[..], ErrorKind::Slice))));/// assert_eq!(short_alpha(b"12345"), Err(ErrMode::Backtrack(InputError::new(&b"12345"[..], ErrorKind::Slice))));/// fn short_alpha(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {/// assert_eq!(short_alpha(Partial::new(b"latin123")), Ok((Partial::new(&b"123"[..]), &b"latin"[..])));/// assert_eq!(short_alpha(Partial::new(b"lengthy")), Ok((Partial::new(&b"y"[..]), &b"length"[..])));/// assert_eq!(short_alpha(Partial::new(b"latin")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(short_alpha(Partial::new(b"ed")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(short_alpha(Partial::new(b"12345")), Err(ErrMode::Backtrack(InputError::new(Partial::new(&b"12345"[..]), ErrorKind::Slice))));take_while0_take_while1_take_while_m_n_take_till0_partial/// *Partial version*: If no element is found matching the condition, this will return `Incomplete`take_till1_partialtake_till0_complete/// *Complete version*: If no element is found matching the condition, this will return the whole inputtake_till1_completetake_till_m_n/// Recognize the longest input slice (if any) till a [pattern][ContainsToken] is met./// *Partial version* will return a `ErrMode::Incomplete(Needed::new(1))` if the match reaches the/// use winnow::token::take_till;///   take_till(0.., |c| c == ':').parse_peek(s)/// fn till_colon(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(till_colon(Partial::new("latin:123")), Ok((Partial::new(":123"), "latin")));/// assert_eq!(till_colon(Partial::new(":empty matched")), Ok((Partial::new(":empty matched"), ""))); //allowed/// assert_eq!(till_colon(Partial::new("12345")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(till_colon(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));take_till0/// use winnow::token::take_till0;///   take_till0(|c| c == ':').parse_peek(s)/// Recognize the longest (at least 1) input slice till a [pattern][ContainsToken] is met./// It will return `Err(ErrMode::Backtrack(InputError::new(_, ErrorKind::Slice)))` if the input is empty or the/// use winnow::token::take_till1;///   take_till1(|c| c == ':').parse_peek(s)/// assert_eq!(till_colon(":empty matched"), Err(ErrMode::Backtrack(InputError::new(":empty matched", ErrorKind::Slice))));/// assert_eq!(till_colon(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));///   take_till1([' ', '\t', '\r', '\n']).parse_peek(s)/// assert_eq!(not_space(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));/// assert_eq!(till_colon(Partial::new(":empty matched")), Err(ErrMode::Backtrack(InputError::new(Partial::new(":empty matched"), ErrorKind::Slice))));/// fn not_space(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(not_space(Partial::new("Hello, World!")), Ok((Partial::new(" World!"), "Hello,")));/// assert_eq!(not_space(Partial::new("Sometimes\t")), Ok((Partial::new("\t"), "Sometimes")));/// assert_eq!(not_space(Partial::new("Nospace")), Err(ErrMode::Incomplete(Needed::new(1))));/// assert_eq!(not_space(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));/// Recognize an input slice containing the first N input elements (I[..N])./// *Complete version*: It will return `Err(ErrMode::Backtrack(InputError::new(_, ErrorKind::Slice)))` if the input is shorter than the argument./// *Partial version*: if the input has less than N elements, `take` will/// return a `ErrMode::Incomplete(Needed::new(M))` where M is the number of/// the next few chars, so the result will be `ErrMode::Incomplete(Needed::Unknown)`///   take(6usize).parse_peek(s)/// assert_eq!(take6("short"), Err(ErrMode::Backtrack(InputError::new("short", ErrorKind::Slice))));/// assert_eq!(take6(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));/// assert_eq!(take::<_, _, InputError<_>>(1usize).parse_peek("💙"), Ok(("", "💙")));/// assert_eq!(take::<_, _, InputError<_>>(1usize).parse_peek("💙".as_bytes()), Ok((b"\x9F\x92\x99".as_ref(), b"\xF0".as_ref())));/// fn take6(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(take6(Partial::new("1234567")), Ok((Partial::new("7"), "123456")));/// assert_eq!(take6(Partial::new("things")), Ok((Partial::new(""), "things")));/// // `Unknown` as we don't know the number of bytes that `count` corresponds to/// assert_eq!(take6(Partial::new("short")), Err(ErrMode::Incomplete(Needed::Unknown)));/// Recognize the input slice up to the first occurrence of the literal./// *Complete version*: It will return `Err(ErrMode::Backtrack(InputError::new(_, ErrorKind::Slice)))`/// *Partial version*: will return a `ErrMode::Incomplete(Needed::new(N))` if the input doesn't/// use winnow::token::take_until;///   take_until(0.., "eof").parse_peek(s)/// assert_eq!(until_eof("hello, world"), Err(ErrMode::Backtrack(InputError::new("hello, world", ErrorKind::Slice))));/// assert_eq!(until_eof(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));/// fn until_eof(s: Partial<&str>) -> IResult<Partial<&str>, &str> {/// assert_eq!(until_eof(Partial::new("hello, worldeof")), Ok((Partial::new("eof"), "hello, world")));/// assert_eq!(until_eof(Partial::new("hello, world")), Err(ErrMode::Incomplete(Needed::Unknown)));/// assert_eq!(until_eof(Partial::new("hello, worldeo")), Err(ErrMode::Incomplete(Needed::Unknown)));/// assert_eq!(until_eof(Partial::new("1eof2eof")), Ok((Partial::new("eof2eof"), "1")));///   take_until(1.., "eof").parse_peek(s)/// assert_eq!(until_eof("eof"), Err(ErrMode::Backtrack(InputError::new("eof", ErrorKind::Slice))));/// assert_eq!(until_eof(Partial::new("eof")), Err(ErrMode::Backtrack(InputError::new(Partial::new("eof"), ErrorKind::Slice))));take_until0/// Deprecated, see [`take_until`]take_until0_take_until1_take_until_m_n_//! Parsers extracting tokens from the streammodel_complete_take_while_m_ncomplete_take_untilcomplete_tag_case_insensitivecomplete_tag_fixed_size_arraycomplete_tag_charcomplete_tag_bytepartial_any_strpartial_one_of_testpartial_none_of_testpartial_is_apartial_is_notpartial_take_until_incompletepartial_take_until_incomplete_spartial_recognizepartial_take_while0partial_take_while1partial_take_while_m_npartial_take_till0partial_take_till1partial_take_while_utf8partial_take_till0_utf8partial_take_utf8partial_take_while_m_n_utf8_fixedpartial_take_while_m_n_utf8_rangepartial_take_while_m_n_utf8_full_match_fixedpartial_take_while_m_n_utf8_full_match_rangepartial_recognize_take_while0partial_tag_case_insensitivepartial_tag_fixed_size_array/// Deprecated, replaced with [`winnow::combinator::trace`][crate::combinator::trace]//! Deprecated, replaced with [`winnow::combinator`][crate::combinator]VersionInfoFILEVERSION/// The version value consists of four 16 bit words, e.g.,/// `MAJOR << 48 | MINOR << 32 | PATCH << 16 | RELEASE`PRODUCTVERSIONFILEOS/// Should be Windows NT Win32, with value `0x40004`FILETYPE/// The value (for a rust compiler output) should be/// 1 for a EXE and 2 for a DLLFILESUBTYPE/// Only for Windows driversFILEFLAGSMASK/// Bit mask for FILEFLAGSFILEFLAGS/// Only the bits set in FILEFLAGSMASK are read/// Version info field namestoolkit_pathrc_filemanifest_fileoutput_directorywindres_pathar_pathadd_toolkit_includeappend_rc_contentWindowsResource/// Create a new resource with version info struct/// We initialize the resource file with values provided by cargo/// | Field                | Cargo / Values               |/// |----------------------|------------------------------|/// | `"FileVersion"`      | `package.version`            |/// | `"ProductVersion"`   | `package.version`            |/// | `"ProductName"`      | `package.name`               |/// | `"FileDescription"`  | `package.description`        |/// Furthermore if a section `package.metadata.winres` exists/// in `Cargo.toml` it will be parsed. Values in this section take precedence/// over the values provided natively by cargo. Only the string table/// of the version struct can be set this way./// Additionally, the language field is set to neutral (i.e. `0`)/// and no icon is set. These settings have to be done programmatically./// `Cargo.toml` files have to be written in UTF-8, so we support all valid UTF-8 strings/// ```,toml/// #Cargo.toml/// [package.metadata.winres]/// OriginalFilename = "testing.exe"/// FileDescription = "⛄❤☕"/// LegalCopyright = "Copyright © 2016"/// The version info struct is set to some values/// sensible for creating an executable file./// | Property             | Cargo / Values               |/// | `FILEVERSION`        | `package.version`            |/// | `PRODUCTVERSION`     | `package.version`            |/// | `FILEOS`             | `VOS_NT_WINDOWS32 (0x40004)` |/// | `FILETYPE`           | `VFT_APP (0x1)`              |/// | `FILESUBTYPE`        | `VFT2_UNKNOWN (0x0)`         |/// | `FILEFLAGSMASK`      | `VS_FFI_FILEFLAGSMASK (0x3F)`|/// | `FILEFLAGS`          | `0x0`                        |/// Set string properties of the version info struct./// Possible field names are:///  - `"FileVersion"`///  - `"FileDescription"`///  - `"ProductVersion"`///  - `"ProductName"`///  - `"OriginalFilename"`///  - `"LegalCopyright"`///  - `"LegalTrademark"`///  - `"CompanyName"`///  - `"Comments"`///  - `"InternalName"`/// Additionally there exists/// `"PrivateBuild"`, `"SpecialBuild"`/// which should only be set, when the `FILEFLAGS` property is set to/// `VS_FF_PRIVATEBUILD(0x08)` or `VS_FF_SPECIALBUILD(0x20)`/// It is possible to use arbirtrary field names but Windows Explorer and other/// tools might not show them.set_toolkit_path/// Set the correct path for the toolkit./// For the GNU toolkit this has to be the path where MinGW/// put `windres.exe` and `ar.exe`. This could be something like:/// `"C:\Program Files\mingw-w64\x86_64-5.3.0-win32-seh-rt_v4-rev0\mingw64\bin"`/// For MSVC the Windows SDK has to be installed. It comes with the resource compiler/// `rc.exe`. This should be set to the root directory of the Windows SDK, e.g.,/// `"C:\Program Files (x86)\Windows Kits\10"`/// or, if multiple 10 versions are installed,/// set it directly to the corret bin directory/// `"C:\Program Files (x86)\Windows Kits\10\bin\10.0.14393.0\x64"`/// If it is left unset, it will look up a path in the registry,/// i.e. `HKLM\SOFTWARE\Microsoft\Windows Kits\Installed Roots`/// Set the user interface language of the file/// extern crate winapi;/// extern crate winres;///   if cfg!(target_os = "windows") {///     let mut res = winres::WindowsResource::new();/// #   res.set_output_directory(".");///     res.set_language(winapi::um::winnt::MAKELANGID(///         winapi::um::winnt::LANG_ENGLISH,///         winapi::um::winnt::SUBLANG_ENGLISH_US///     ));///     res.compile().unwrap();/// For possible values look at the `winapi::um::winnt` constants, specifically those/// starting with `LANG_` and `SUBLANG_`./// [`MAKELANGID`]: https://docs.rs/winapi/0.3/x86_64-pc-windows-msvc/winapi/um/winnt/fn.MAKELANGID.html/// [`winapi::um::winnt`]: https://docs.rs/winapi/0.3/x86_64-pc-windows-msvc/winapi/um/winnt/index.html#constants/// # Table/// Sometimes it is just simpler to specify the numeric constant directly/// (That is what most `.rc` files do)./// For possible values take a look at the MSDN page for resource files;/// we only listed some values here./// | Language            | Value    |/// |---------------------|----------|/// | Neutral             | `0x0000` |/// | English             | `0x0009` |/// | English (US)        | `0x0409` |/// | English (GB)        | `0x0809` |/// | German              | `0x0407` |/// | German (AT)         | `0x0c07` |/// | French              | `0x000c` |/// | French (FR)         | `0x040c` |/// | Catalan             | `0x0003` |/// | Basque              | `0x042d` |/// | Breton              | `0x007e` |/// | Scottish Gaelic     | `0x0091` |/// | Romansch            | `0x0017` |/// Add an icon with nameID `1`./// This icon need to be in `ico` format. The filename can be absolute/// or relative to the projects root./// Equivalent to `set_icon_with_id(path, "1")`.set_icon_with_id/// Add an icon with the specified name ID./// This icon need to be in `ico` format. The path can be absolute or/// relative to the projects root./// ## Name ID and Icon Loading/// The name ID can be (the string representation of) a 16-bit unsigned/// integer, or some other string./// You should not add multiple icons with the same name ID. It will result/// in a build failure./// When the name ID is an integer, the icon can be loaded at runtime with/// LoadIconW(h_instance, MAKEINTRESOURCEW(name_id_as_integer))/// Otherwise, it can be loaded with/// LoadIconW(h_instance, name_id_as_wide_c_str_as_ptr)/// Where `h_instance` is the module handle of the current executable/// ([`GetModuleHandleW`](https://docs.rs/winapi/0.3.8/winapi/um/libloaderapi/fn.GetModuleHandleW.html)`(null())`),/// [`LoadIconW`](https://docs.rs/winapi/0.3.8/winapi/um/winuser/fn.LoadIconW.html)/// [`MAKEINTRESOURCEW`](https://docs.rs/winapi/0.3.8/winapi/um/winuser/fn.MAKEINTRESOURCEW.html)/// are defined in winapi./// ## Multiple Icons, Which One is Application Icon?/// When you have multiple icons, it's a bit complicated which one will be/// chosen as the application icon:/// <https://docs.microsoft.com/en-us/previous-versions/ms997538(v=msdn.10)?redirectedfrom=MSDN#choosing-an-icon>./// To keep things simple, we recommand you use only 16-bit unsigned integer/// name IDs, and add the application icon first with the lowest id:/// ```nocheck/// res.set_icon("icon.ico") // This is application icon.///    .set_icon_with_id("icon2.icon", "2")///    .set_icon_with_id("icon3.icon", "3")set_version_info/// Set a version info struct property/// Currently we only support numeric values; you have to look them up./// Set the embedded manifest file/// The following manifest will brand the exe as requesting administrator privileges./// Thus, everytime it is executed, a Windows UAC dialog will appear./// let mut res = winres::WindowsResource::new();/// res.set_manifest(r#"/// <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">/// <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">///     <security>///         <requestedPrivileges>///             <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />///         </requestedPrivileges>///     </security>/// </trustInfo>/// </assembly>set_manifest_file/// Some as [`set_manifest()`] but a filename can be provided and/// file is included by the resource compieler itself./// This method works the same way as [`set_icon()`]/// [`set_manifest()`]: #method.set_manifest/// [`set_icon()`]: #method.set_iconset_windres_path/// Set the path to the windres executable.set_ar_path/// Set the path to the ar executable.write_resource_file/// Write a resource file with the set valuesset_resource_file/// Set a path to an already existing resource file./// We will neither modify this file nor parse its contents. This function/// simply replaces the internaly generated resource file that is passed to/// the compiler. You can use this function to write a resource file yourself./// Append an additional snippet to the generated rc file./// Define a menu resource:/// # extern crate winres;/// # if cfg!(target_os = "windows") {///     res.append_rc_content(r##"sample MENU///     MENUITEM "&Soup", 100///     MENUITEM "S&alad", 101///     POPUP "&Entree"///          MENUITEM "&Fish", 200///          MENUITEM "&Chicken", 201, CHECKED///          POPUP "&Beef"///          {///               MENUITEM "&Steak", 301///               MENUITEM "&Prime Rib", 302///     MENUITEM "&Dessert", 103/// }"##);/// #    res.compile()?;/// # Ok::<_, std::io::Error>(())set_output_directory/// Override the output directoy./// As a default, we use `%OUT_DIR%` set by cargo, but it may be necessary to override the/// the setting.compile_with_toolkit_gnu/// Run the resource compiler/// This function generates a resource file from the settings or/// uses an existing resource file and passes it to the resource compiler/// of your toolkit./// Further more we will print the correct statements for/// `cargo:rustc-link-lib=` and `cargo:rustc-link-search` on the console,/// so that the cargo build script can link the compiled resource file.compile_with_toolkit_msvcget_sdk/// Find a Windows SDKparse_cargo_tomlwin_sdk_inlcude_rootstring_escapingtoolkit_include_win10toolkit_include_win8//! Rust Windows resource helper//! This crate implements a simple generator for Windows resource (.rc) files//! for use with either Microsoft `rc.exe` resource compiler or with GNU `windres.exe`//! The [`WindowsResorce::compile()`] method is intended to be used from a build script and//! needs environment variables from cargo to be set. It not only compiles the resource//! but directs cargo to link the resource compiler's output.//! # extern crate winres;//! # fn test_main() -> io::Result<()> {//! if cfg!(target_os = "windows") {//!     let mut res = winres::WindowsResource::new();//!     res.set_icon("test.ico")//! #      .set_output_directory(".")//!        .set("InternalName", "TEST.EXE")//!        // manually set version 1.0.0.0//!        .set_version_info(winres::VersionInfo::PRODUCTVERSION, 0x0001000000000000);//!     res.compile()?;//! We try to guess some sensible default values from Cargo's build time environement variables//! This is described in [`WindowsResource::new()`]. Furthermore we have to know where to find the//! resource compiler for the MSVC Toolkit. This can be done by looking up a registry key but//! for MinGW this has to be done manually.//! The following paths are the hardcoded defaults://! MSVC the last registry key at//! `HKLM\SOFTWARE\Microsoft\Windows Kits\Installed Roots`, for MinGW we try our luck by simply//! using the `%PATH%` environment variable.//! Note that the toolkit bitness as to match the one from the current Rust compiler. If you are//! using Rust GNU 64-bit you have to use MinGW64. For MSVC this is simpler as (recent) Windows//! SDK always installs both versions on a 64-bit system.//! [`WindowsResorce::compile()`]: struct.WindowsResource.html#method.compile//! [`WindowsResource::new()`]: struct.WindowsResource.html#method.newseat_dataclipboard_managerSocketOpenErrorWaylandConnectionWaylandCommunicationMissingProtocol/// The regular clipboard./// The "primary" clipboard./// Working with the "primary" clipboard requires the compositor to support the data-control/// protocol of version 2 or above./// Operate on both clipboards at once./// Useful for atomically setting both clipboards at once. This option requires the "primary"/// clipboard to be supported./// The clipboard to operate on.Autodetect/// Detect the MIME type automatically from the data./// Offer a number of common plain text MIME types.Specific/// Offer a specific MIME type./// MIME type to offer the copied data under.StdIn/// Copy contents of the standard input./// Copy the given bytes./// Source for copying./// Source for copying, with a MIME type./// Used for [`copy_multi`]./// [`copy_multi`]: fn.copy_multi.html/// Operate on all existing seats at once./// Operate on a seat with the given name./// Seat to operate on.ServeRequests/// Serve requests indefinitely./// Serve only the given number of requests./// Number of paste requests to serve./// The clipboard to work with./// The seat to work with.trim_newline/// Trim the trailing newline character before copying./// This flag is only applied for text MIME types./// Do not spawn a separate thread for serving copy requests./// Setting this flag will result in the call to `copy()` **blocking** until all data sources/// it creates are destroyed, e.g. until someone else copies something into the clipboard./// Limiting the number of paste requests to one effectively clears the clipboard after the/// first paste. It can be used when copying e.g. sensitive data, like passwords. Note however/// that certain apps may have issues pasting when this option is used, in particular XWayland/// clients are known to suffer from this.omit_additional_text_mime_types/// Omit additional text mime types which are offered by default if at least one text mime type is provided./// Omits additionally offered `text/plain;charset=utf-8`, `text/plain`, `STRING`, `UTF8_STRING` and/// `TEXT` mime types which are offered by default if at least one text mime type is provided./// Options and flags that are used to customize the copying.PreparedCopy/// A copy operation ready to start serving requests.SourceCreationErrorTempDirCreateTempFileCreateDataCopyTempFileWriteTempFileOpenTempFileMetadataTempFileSeekTempFileReadTempFileTruncate/// Errors that can occur for copying the source data to a temporary file.NoSeatsPrimarySelectionUnsupportedSeatNotFoundTempCopyTempFileRemoveTempDirRemoveDataSourceError/// Errors that can occur for copying and clearing the clipboard.FileOpengot_primary_selectionshould_quit// This bool can be set to true when serving a request: either if an error occurs, or if the// number of requests to serve was limited and the last request was served.data_paths// An error that occurred while serving a request, if any./// Sets the clipboard to work with./// Sets the seat to use for copying./// Sets the flag for trimming the trailing newline./// Sets the flag for not spawning a separate thread for serving copy requests./// Sets the number of requests to serve./// Limiting the number of requests to one effectively clears the clipboard after the first/// paste. It can be used when copying e.g. sensitive data, like passwords. Note however that/// certain apps may have issues pasting when this option is used, in particular XWayland/// Sets the flag for omitting additional text mime types which are offered by default if at least one text mime type is provided./// Invokes the copy operation. See `copy()`./// # extern crate wl_clipboard_rs;/// # use wl_clipboard_rs::copy::Error;/// use wl_clipboard_rs::copy::{MimeType, Options, Source};/// let opts = Options::new();/// opts.copy(Source::Bytes([1, 2, 3][..].into()), MimeType::Autodetect)?;copy_multi/// Invokes the copy_multi operation. See `copy_multi()`./// use wl_clipboard_rs::copy::{MimeSource, MimeType, Options, Source};/// opts.copy_multi(vec![MimeSource { source: Source::Bytes([1, 2, 3][..].into()),///                                   mime_type: MimeType::Autodetect },///                      MimeSource { source: Source::Bytes([7, 8, 9][..].into()),///                                   mime_type: MimeType::Text }])?;prepare_copy/// Invokes the prepare_copy operation. See `prepare_copy()`./// Panics if `foreground` is `false`./// opts.foreground(true);/// let prepared_copy = opts.prepare_copy(Source::Bytes([1, 2, 3][..].into()),///                                       MimeType::Autodetect)?;/// prepared_copy.serve()?;prepare_copy_multi/// Invokes the prepare_copy_multi operation. See `prepare_copy_multi()`./// let prepared_copy =///     opts.prepare_copy_multi(vec![MimeSource { source: Source::Bytes([1, 2, 3][..].into()),///                                               mime_type: MimeType::Autodetect },///                                  MimeSource { source: Source::Bytes([7, 8, 9][..].into()),///                                               mime_type: MimeType::Text }])?;/// Starts serving copy requests./// This function **blocks** until all requests are served or the clipboard is taken over by/// some other application.make_source/// Clears the clipboard for the given seat./// If `seat` is `None`, clears clipboards of all existing seats./// use wl_clipboard_rs::{copy::{clear, ClipboardType, Seat}};/// clear(ClipboardType::Regular, Seat::All)?;clear_internal/// Prepares a data copy to the clipboard./// The data is copied from `source` and offered in the `mime_type` MIME type. See `Options` for/// customizing the behavior of this operation./// This function can be used instead of `copy()` when it's desirable to separately prepare the/// copy operation, handle any errors that this may produce, and then start the serving loop,/// potentially past a fork (which is how `wl-copy` uses it). It is meant to be used in the/// foreground mode and does not spawn any threads./// Prepares a data copy to the clipboard, offering multiple data sources./// The data from each source in `sources` is copied and offered in the corresponding MIME type./// See `Options` for customizing the behavior of this operation./// If multiple sources specify the same MIME type, the first one is offered. If one of the MIME/// types is text, all automatically added plain text offers will fall back to the first source/// with a text MIME type.prepare_copy_internal/// Copies data to the clipboard./// use wl_clipboard_rs::copy::{copy, MimeType, Options, Source};/// copy(opts, Source::Bytes([1, 2, 3][..].into()), MimeType::Autodetect)?;/// Copies data to the clipboard, offering multiple data sources.copy_internal//! Copying and clearing clipboard contents.// It's more convenient for testing some stuff.//! A safe Rust crate for working with the Wayland clipboard.//! This crate is intended to be used by terminal applications, clipboard managers and other//! utilities which don't spawn Wayland surfaces (windows). If your application has a window,//! please use the appropriate Wayland protocols for interacting with the Wayland clipboard//! (`wl_data_device` from the core Wayland protocol, the `primary_selection` protocol for the//! primary selection), for example via the//! [smithay-clipboard](https://crates.io/crates/smithay-clipboard) crate.//! The protocol used for clipboard interaction is `data-control` from//! [wlroots](https://github.com/swaywm/wlr-protocols). When using the regular clipboard, the//! compositor must support the first version of the protocol. When using the "primary" clipboard,//! the compositor must support the second version of the protocol (or higher).//! For example applications using these features, see `wl-clipboard-rs-tools/src/bin/wl_copy.rs`//! and `wl-clipboard-rs-tools/src/bin/wl_paste.rs` which implement terminal apps similar to//! [wl-clipboard](https://github.com/bugaevc/wl-clipboard) or//! `wl-clipboard-rs-tools/src/bin/wl_clip.rs` which implements a Wayland version of `xclip`.//! The Rust implementation of the Wayland client is used by default; use the `native_lib` feature//! to link to `libwayland-client.so` for communication instead. A `dlopen` feature is also//! available for loading `libwayland-client.so` dynamically at runtime rather than linking to it.//! The code of the crate itself (and the code of the example utilities) is 100% safe Rust. This//! doesn't include the dependencies.//! Copying to the regular clipboard://! # extern crate wl_clipboard_rs;//! # fn foo() -> Result<(), Box<dyn std::error::Error>> {//! use wl_clipboard_rs::copy::{MimeType, Options, Source};//! let opts = Options::new();//! opts.copy(Source::Bytes("Hello world!".to_string().into_bytes().into()), MimeType::Autodetect)?;//! Pasting plain text from the regular clipboard://! use wl_clipboard_rs::{paste::{get_contents, ClipboardType, Error, MimeType, Seat}};//! let result = get_contents(ClipboardType::Regular, Seat::Unspecified, MimeType::Text);//! match result {//!     Ok((mut pipe, _)) => {//!         let mut contents = vec![];//!         pipe.read_to_end(&mut contents)?;//!         println!("Pasted: {}", String::from_utf8_lossy(&contents));//!     Err(Error::NoSeats) | Err(Error::ClipboardEmpty) | Err(Error::NoMimeType) => {//!         // The clipboard is empty or doesn't contain text, nothing to worry about.//!     Err(err) => Err(err)?//! Checking if the "primary" clipboard is supported (note that this might be unnecessary depending//! on your crate usage, the regular copying and pasting functions do report if the primary//! selection is unsupported when it is requested)://! use wl_clipboard_rs::utils::{is_primary_selection_supported, PrimarySelectionCheckError};//! match is_primary_selection_supported() {//!     Ok(supported) => {//!         // We have our definitive result. False means that either data-control version 1//!         // is present (which does not support the primary selection), or that data-control//!         // version 2 is present and it did not signal the primary selection support.//!     Err(PrimarySelectionCheckError::NoSeats) => {//!         // Impossible to give a definitive result. Primary selection may or may not be//!         // supported.//!         // The required protocol (data-control version 2) is there, but there are no seats.//!         // Unfortunately, at least one seat is needed to check for the primary clipboard//!         // support.//!     Err(PrimarySelectionCheckError::MissingProtocol { .. }) => {//!         // The data-control protocol (required for wl-clipboard-rs operation) is not//!         // supported by the compositor.//!     Err(_) => {//!         // Some communication error occurred.//! # Included terminal utilities//! - `wl-paste`: implements `wl-paste` from//!   [wl-clipboard](https://github.com/bugaevc/wl-clipboard).//! - `wl-copy`: implements `wl-copy` from [wl-clipboard](https://github.com/bugaevc/wl-clipboard).//! - `wl-clip`: a Wayland version of `xclip`./// Request any available MIME type./// If multiple MIME types are offered, the requested MIME type is unspecified and depends on/// the order they are received from the Wayland compositor. However, plain text formats are/// prioritized, so if a plain text format is available among others then it will be requested./// Request a plain text MIME type./// This will request one of the multiple common plain text MIME types. It will prioritize MIME/// types known to return UTF-8 text.TextWithPriority/// Request the given MIME type, and if it's not available fall back to `MimeType::Text`./// Example use-case: pasting `text/html` should try `text/html` first, but if it's not/// available, any other plain text format will do fine too./// Request a specific MIME type./// MIME types that can be requested from the clipboard./// Operate on one of the existing seats depending on the order returned by the compositor./// This is perfectly fine when only a single seat is present, so for most configurations.offers// The value is the set of MIME types in the offer.// TODO: We never remove offers from here, even if we don't use them or after destroying them.ClipboardEmptyNoMimeTypePipeCreation/// Errors that can occur for pasting and listing MIME types./// You may want to ignore some of these errors (rather than show an error message), like/// `NoSeats`, `ClipboardEmpty` or `NoMimeType` as they are essentially equivalent to an emptyget_offerget_mime_types/// Retrieves the offered MIME types./// If `seat` is `None`, uses an unspecified seat (it depends on the order returned by the/// compositor). This is perfectly fine when only a single seat is present, so for most/// # use wl_clipboard_rs::paste::Error;/// use wl_clipboard_rs::{paste::{get_mime_types, ClipboardType, Seat}};/// let mime_types = get_mime_types(ClipboardType::Regular, Seat::Unspecified)?;/// for mime_type in mime_types {///     println!("{}", mime_type);get_mime_types_internal// The internal function accepts the socket name, used for tests./// Retrieves the clipboard contents./// This function returns a tuple of the reading end of a pipe containing the clipboard contents/// and the actual MIME type of the contents./// # fn foo() -> Result<(), Box<dyn std::error::Error>> {/// use wl_clipboard_rs::{paste::{get_contents, ClipboardType, Error, MimeType, Seat}};/// let result = get_contents(ClipboardType::Regular, Seat::Unspecified, MimeType::Any);/// match result {///     Ok((mut pipe, mime_type)) => {///         println!("Got data of the {} MIME type", &mime_type);///         let mut contents = vec![];///         pipe.read_to_end(&mut contents)?;///         println!("Read {} bytes of data", contents.len());///     Err(Error::NoSeats) | Err(Error::ClipboardEmpty) | Err(Error::NoMimeType) => {///         // The clipboard is empty, nothing to worry about.///     Err(err) => Err(err)?get_contents_internal//! Getting the offered MIME types and the clipboard contents./// The name of this seat, if any./// The data device of this seat, if any./// The data offer of this seat, if any.primary_offer/// The primary-selection data offer of this seat, if any./// Sets this seat's name./// Sets this seat's device./// Destroys the old one, if any.set_offer/// Sets this seat's data offer.set_primary_offer/// Sets this seat's primary-selection data offer.TestServerclear_testcopy_testcopy_multi_testcopy_multi_no_additional_text_mime_types_testcopy_large// The idea here is to exceed the pipe capacity. This fails unless O_NONBLOCK is cleared when// sending data over the pipe using cat.wayland_serverListeningSocketClientCountersocket_namerun_mutexrun_internalserver_ignore_impl// https://github.com/Smithay/wayland-rs/blob/90a9ad1f8f1fdef72e96d3c48bdb76b53a7722ff/wayland-tests/tests/helpers/mod.rsserver_ignore_global_implget_mime_types_testget_mime_types_no_data_controlget_mime_types_no_data_control_2get_mime_types_no_seatsget_mime_types_empty_clipboardget_mime_types_specific_seatget_mime_types_primaryget_contents_testget_contents_wrong_mime_typeproptest_deriveGlobalDispatchOfferInfoselection_updated_senderset_nonblock_on_write_fdDataInitcreate_seats//! Test compositor implementation.//! This module contains the test compositor ([`State`]), which boils down to a minimal wlr-data-control protocol//! implementation. The compositor can be initialized with an arbitrary set of seats, each offering arbitrary clipboard//! contents in their regular and primary selections. Then the compositor handles all wlr-data-control interactions, such//! as copying and pasting.advertise_primary_selectionis_primary_selection_supported_testis_primary_selection_supported_primary_selection_unsupportedis_primary_selection_supported_data_control_v1is_primary_selection_supported_no_seatssupports_v2_seatsis_primary_selection_supported_no_data_control/// Checks if the given MIME type represents plain text./// use wl_clipboard_rs::utils::is_text;/// assert!(is_text("text/plain"));/// assert!(!is_text("application/octet-stream"));// Any seat that we get from the compositor.clipboard_manager_was_v1PrimarySelectionStatePrimarySelectionCheckError/// Errors that can occur when checking whether the primary selection is supported./// Checks if the compositor supports the primary selection./// use wl_clipboard_rs::utils::{is_primary_selection_supported, PrimarySelectionCheckError};/// match is_primary_selection_supported() {///     Ok(supported) => {///         // We have our definitive result. False means that either data-control version 1///         // is present (which does not support the primary selection), or that data-control///         // version 2 is present and it did not signal the primary selection support.///     Err(PrimarySelectionCheckError::NoSeats) => {///         // Impossible to give a definitive result. Primary selection may or may not be///         // supported.///         // The required protocol (data-control version 2) is there, but there are no seats.///         // Unfortunately, at least one seat is needed to check for the primary clipboard///         // support.///     Err(PrimarySelectionCheckError::MissingProtocol { .. }) => {///         // The data-control protocol (required for wl-clipboard-rs operation) is not///         // supported by the compositor.///         // Some communication error occurred.is_primary_selection_supported_internalMAC_ADDR_SIZE/// Mac address size of bytesBIND_PORT/// Bind port, 0 means assigned by osWOL_PORT/// WoL port could be 0/7/9， use 9 here/// Mac address./// A 6 bytes mac address, e.g. "00:0a:0b:0c:0d:0e".MacAddrError/// Mac address error.send_wol/// Send a WoL magic packet over UDP./// * `mac_addr` - Destination mac address/// * `bcast_addr` - Broadcast ip address/// * `bind_addr` - Bind ip address/// Raise an [`std::io::Error`] if the WoL magic packet could not be send./// Destination MAC addressbcast_addr/// Broadcast IP address/// Bind IP address/// The iterator being governed./// A pointer to either `I::next` or `I::next_back`./// A pointer to either `I::next_back` or `I::next`./// A pointer to either `I::nth` or `I::nth_back`./// A pointer to either `I::nth_back` or `I::nth`.Bidi/** An iterator that conditionally reverses itself upon creation.

This acts as a conditional `.rev()` adapter: it reverses the direction of
iteration, swapping `.next()` and `.next_back()`, but only if the provided
condition is true. If the condition is false, then iteration proceeds normally.

The condition is only evaluated when the adapter is constructed, and all calls
to drive the iterator are branchless.

## Usage

This can be constructed directly with `Bidi::new(some_iterator)`, but it is more
conveniently accessed as an extension method on double-ended iterators. Import
`wyz::BidiIterator` or `wyz::bidi::*;` and then call `.bidi()` in your iterator
adapter sequence.

## Examples

This can be used to hand-roll a `memmove` implementation that correctly handles
the case where the destination begins in the source region:

```rust
use wyz::bidi::*;

unsafe fn memmove<T>(from: *const T, to: *mut T, count: usize) {
 let src = from .. from.add(count);
 let rev = src.contains(&(to as *const T));
 for idx in (0 .. count).bidi(rev) {
  to.add(idx).write(from.add(idx).read());
 }
}
```

This example detects if `to` is between `from` and `from.add(count)` and uses
that to determine whether to iterate forward from `0` to `count - 1` or backward
from `count - 1` to `0`.
**//// Applies the `Bidi` adapter to a double-ended iterator and selects the/// direction of traversal./// - `iter`: anything that can be made into a double-ended iterator/// - `cond`: determines whether iteration proceeds ordinarily or reversed/// Conditionally reverses the direction of iteration./// When `cond` is true, this adapter swaps the `next` and `nth` methods/// with `next_back` and `nth_back`. The resulting iterator is equivalent to/// `if cond { self.rev() } else { self }`./// use wyz::BidiIterator;/// let data = [1, 2, 3];/// let mut iter = data.iter().copied().bidi(false);/// assert_eq!(iter.next_back(), Some(3));/// let mut iter = data.iter().copied().bidi(true);/// assert_eq!(iter.next_back(), Some(1));/// Extension trait that provides `.bidi()` for all double-ended iterators.//! A bidirectional iterator that only checks its direction once./// A basic `const` marker./// A basic `mut` marker./// A frozen wrapper over some other `Mutability` marker.CONTAINS_MUTABILITY/// Marks whether this type contains mutability permissions within it./// This is `false` for `Const` and `true` for `Mut`. `Frozen` wrappers/// atop either of these types inherit their interior marker.PEANO_NUMBER/// Counts the layers of `Frozen<>` wrapping around a base `Const` or `Mut`.SELF/// Allow instances to be constructed generically.RENDER/// One of `*const` or `*mut`./// Freeze this type, wrapping it in a `const` marker that may later be/// removed to thaw it./// Thaw a previously-frozen type, removing its `Frozen` marker and/// restoring it to `Self`./** Generalized mutability permissions.

This trait enables referent structures to be generic over the write permissions
of their referent data. As an example, the standard library defines `*const T`
and `*mut T` as two duplicate type families, that cannot share any logic at all.

An equivalent library implementation might be `Ptr<T, M: Mutability>`, where
shared logic can be placed in an `impl<T, M> Ptr<T, M>` block, but unique logic
(such as freezing a `Mut` pointer, or unfreezing a `Frozen<Mut>`) can be placed
in specialized `impl<T> Ptr<T, Mut>` blocks.
**//// The address value./// The mutability permissions./** A generic non-null pointer with type-system mutability tracking.

# Type Parameters

- `M`: The mutability permissions of the source pointer.
- `T`: The referent type of the source pointer.
**//// The dangling pointer./// Constructs a new `Address` over some pointer value./// You are responsible for selecting the correct `Mutability` marker.immut/// Permanently converts an `Address<_>` into an `Address<Const>`./// You should generally prefer [`Address::freeze`].assert_mut/// Force an `Address<Const>` to be `Address<Mut>`./// You should only call this on addresses you know to have been created/// with `Mut`able permissions and previously removed by [`Address::immut`]./// You should prefer using [`Address::freeze`] for temporary, trackable,/// immutability constraints instead./// Freezes the `Address` so that it is read-only./// Removes the `Address` type marker, returning the original pointer./// Gets the address as a read-only pointer./// Gets the address as a write-capable pointer./// Thaws the `Address` to its original mutability permission./// Implement `*T -> *T` functions as `Address<T> -> Address<T>`./// Implement all other pointer functions.r" See [original documentation][orig]."/// Port of the pointer inherent methods on `Address`es of `Sized` types.with_ptr/// Applies a pointer -> pointer function within an Address -> Address./// Port of the pointer inherent methods on `Address`es of any type./// Port of pointer inherent methods on mutable `Address`es of sized types./// Port of pointer inherent methods on mutable `Address`es of any type./// The created reference type. Must be one of `&T` or `&mut T`.to_ref/// Converts the `Address` to a reference./// The caller is responsible for ensuring that the memory location that the/// `Address` describes contains an initialized value, and that the produced/// reference abides by the Rust `&`/`&mut` exclusion rules./// Converts a reference back into an `Address`./// Allows an `Address` to produce an ordinary reference./// A generically-mutable reference./// The type of the element pointer./// Constructs an ordinary slice reference from a base-address and a length./// - `ptr`: The address of the base element in the slice./// - `len`: The number of elements, beginning at `ptr`, in the slice./// The base address and the element count must describe a valid region of/// Allows an `Address<M, [T]>` to produce an ordinary slice reference./// [`Address`] cannot be constructed over null pointers./*! Trait-level `co`nst/`mu`table tracking.

This module provides a system of marker types that can be used to encode write
permissions into type parameters rather than duplicate structures.
!*///  This module has no compute logic of its own; it only exists in the//  type-system and to forward to the standard library./// `exit!` macro/*! `exit!` macro

The `exit!` macro simplifies exiting with an error code, and optionally printing
an error message prior to exit.

# Examples

This example exits with status `1`.

```rust,should_panic
wyz::exit!();
```

This example exits with status `2`.

```rust,should_panic
wyz::exit!(2);
```

This example exits with status `3`, and uses `eprintln!` to print an error
message before exiting. Note that if `stderr` has been closed, this will crash
the program with a panic due to `SIGPIPE`, and *not* call `process::exit()`.

```rust,should_panic
wyz::exit!(3, "Error status: {}", "testing");
```
!*/fmt_binaryFmtBinary/// Causes `self` to use its `Binary` implementation when `Debug`-formatted.fmt_displayFmtDisplay/// Causes `self` to use its `Display` implementation when/// `Debug`-formatted.fmt_lower_expFmtLowerExp/// Causes `self` to use its `LowerExp` implementation whenfmt_lower_hexFmtLowerHex/// Causes `self` to use its `LowerHex` implementation whenfmt_octalFmtOctal/// Causes `self` to use its `Octal` implementation when `Debug`-formatted.fmt_pointerFmtPointer/// Causes `self` to use its `Pointer` implementation whenfmt_upper_expFmtUpperExp/// Causes `self` to use its `UpperExp` implementation whenfmt_upper_hexFmtUpperHex/// Causes `self` to use its `UpperHex` implementation whenfmt_listFmtList/// Formats each item in a sequence./// This wrapper structure conditionally implements all of the formatting/// traits when `self` can be viewed as an iterator whose *items* implement/// them. It iterates over `&self` and prints each item according to the/// formatting specifier provided./// Wraps any value with a format-forward to `Debug`./// Forwards a type’s `Binary` formatting implementation to `Debug`./// Forwards a type’s `Display` formatting implementation to `Debug`./// Renders each element of a stream into a list./// Forwards a type’s `LowerExp` formatting implementation to `Debug`./// Forwards a type’s `LowerHex` formatting implementation to `Debug`./// Forwards a type’s `Octal` formatting implementation to `Debug`./// Forwards a type’s `Pointer` formatting implementation to `Debug`./// Forwards a type’s `UpperExp` formatting implementation to `Debug`./// Forwards a type’s `UpperHex` formatting implementation to `Debug`./*! Format forwarding

This module provides wrapper types for each formatting trait other than `Debug`
which, when `Debug`-formatted, forward to the original trait instead of `Debug`.

Each wrapper type is a tuple struct so that it can be used as a named
constructor, such as in `.map(FmtDisplay)`. In addition, a blanket trait adds
extension methods `.fmt_<trait_name>>()` to provide the corresponding wrap.

Any modifiers in the format template string or struct modifier are passed
through to the desired trait implementation unchanged. The only effect of the
forwarding types in this module is to change the `?` template character to one
of the other trait signifiers.
!*//*! `wyz` – myrrlyn’s wyzyrdly library

This crate consolidates all the small tools and conveniences I’ve built up in my
experience building Rust crates.

Each module has more documentation about what it contains. The modules are
largely independent, and can be used individually.
!*//// Normalizes a range-like type to a canonical half-open `Range`./// - `self`: The range to normalize./// - `start`: An optional fallback *inclusive* lower bound./// - `end`: An optional fallback *exclusive* upper bound./// A `Range` whose start and end values are the following, in order of/// decreasing priority:/// - `self.start()`, or if absent, the `start` parameter, or if it is///   `None`, `0`./// - `self.end()`, or if absent, the `end` parameter, or if it is `None`,///   !0`./// Finds the intersection between two range-likes. The produced `Range`/// spans only the elements common to both./// This returns `None` if the ranges do not have an intersection (at least/// one element present in both ranges)./// Finds the union between two range-likes. The produced `Range` spans all/// elements present in at least one of them./// Extension methods for working with various range types.//  TODO(myrrlyn): Use funty to extend this for all integers.//! Range utilities.typemapTypeMapBgDrop/** Run an object’s destructor in the background.

When `BgDrop`-wrapped objects go out of scope, the `BgDrop` destructor attempts
to use a global background-thread to receive the wrapped value, so that its
destructor is run on the worker thread. If the thread running a `BgDrop`
destructor is able to send the value to the worker, then it resumes immediately,
and does not wait for the worker to get around to actually running the wrapped
destructor. This is similar to the disposal semantics of many GC systems, though
the actual system used to determine when an object becomes garbage is still the
compiler’s static lifetime analyzer.

All `BgDrop` types use the same persistent worker thread, minimizing the program
cost of deferral.

If the function [`wm::shutdown()`] is called, all future `BgDrop`s become a noöp
and run their contained destructors on their local threads.

[`wm::shutdown()`]: ../fn.shutdown.html
**//// Instructs an object to run its destructor in the background./// This function modifies the wrapped object’s `Drop` implementation to try/// to, on `drop`, send the inner object to a background thread for actual/// destruction. If the object cannot be sent to the background when its/// wrapper goes out of scope, then its destructor runs immediately, in the/// thread that had been holding the object when the modified destructor was/// If the wrapped object is successfully sent to the background, the/// modified destructor exits, and the current thread resumes work. Once/// enqueued, the inner object is guaranteed to be *eventually* destroyed,/// unless the program exits in a manner that prevents the background/// collector from emptying its work queue./// Removes the background-destruction marker, returning the interior value.bg_drop/// Attempt to prevent double-deferral, which would cause the outer to send/// the inner to the worker thread, making the worker thread send the/// *actual* inner to itself for destruction. This is safe, but stupid./// Modifies the object’s destructor to run in the background./// When this value goes out of scope, it will attempt to send itself to a/// background thread where its *actual* destructor will be run. The actual/// destructor will run on the local thread only if the transfer to the/// background worker was unable to occur./// The background worker is started only when the first value marked for/// deferred destruction actually drops, so the first call will block until/// the disposal system is initialized./// The first value of each *type* to be deferred will modify the disposal/// system to handle its type./// All subsequent drops of a type that has been deferred before will happen/// nearly instantaneously, as they must only observe that the system is set/// up for them, and move the value into the transfer queue./// use wyz::wm::BgDropExt;/// vec![1, 2, 3, 4, 5].bg_drop();/// vec![6, 7, 8, 9, 10].bg_drop();/// If you need to guarantee that your program remains open until all/// deferred objects are destroyed, you can block on [`wm::shutdown()`]./// [`wm::shutdown()`]: ../fn.shutdown.htmlBgDropExt/// Attaches a `BgDrop` constructor to all suitable types./** Stop the background disposal system.

This function shuts down the disposal system, and ensures that all deferred
destructors in the program are correctly handled. It disables all *future*
deferred-drops from sending values to the worker thread, which forces them to
run their destructors locally. In the meantime, the worker thread will pull all
remaining values out of its work queue and destroy them, then terminate once it
sees that its queue has been closed.

When this function returns, the worker thread will have emptied its queue, torn
down its transfer system, and exited.

You may call this function more than once; it is idempotent. The worker system
is program-global, and will only be started once and stopped once. Once this
function is called, the program will never run deferred disposal again.

Rust does not provide a portable `atexit` behavior, so you are responsible for
calling this before your program terminates if you want to ensure that all
deferred destructions actually take place. Future versions of this library may
register `wm::shutdown()` with the sytem `atexit` handler. If this occurs, the
function will be marked as deprecated on platforms where it is set.
**/DtorAssertThreadsafe//  The sender is never used concurrently.DUMP//  The map is only ever used behind a mutex lock.JOIN/// Initialize the collection system.dq/// Lock the transfer map./// Pull the front object out of a typed queue, and destroy it./// Get a local copy of the sender, free of threading concerns./// Look up a type’s location in the transfer map./// The transfer map holds some form of collection of the transferred types./// The specific collection type is irrelevant, as long as it supports both/// insertion and removal, and has reasonable behavior characteristics./// Since the map has to be completely locked for any transfer event, as the/// first transfer of each type must insert its queue into the map, there is/// no advantage in trying to make this mpsc-friendly./// If Rust were to allow a construction like/// fn type_chan<T: 'static>() -> (///   &'static mpsc::Sender<T>,///   &'static mpsc::Receiver<T>,///   static MAKE: Once = Once::new();///   static mut CHAN: Option<(mpsc::Sender<T>, mpsc::Receiver<T>) = None;///   MAKE.call_once(|| unsafe {///     CHAN = Some(mpsc::channel());///   (&CHAN.0, &CHAN.1)/// then a dynamic type-map would not be necessary at all, since each type/// would be granted its own dedicated channel at compile-time. But Rust/// does not, so, it is./** Get off my back, `rustc`.

This is required because `static` vars must be `Sync`, and the thread-safety
wrappers in use apparently inherit the `Sync`hronicity of their wrapped types.
This module uses them correctly, and does not permit escape, so this struct is
needed to get the compiler to accept our use.
**/trash_pickup/*! Waste Management

Do you drive your own garbage to the landfill or compost heap? Maybe you should,
but that’s a lot of work and takes time out of your day, so you probably don’t.
Instead, you give it to a worker that specializes in managing objects at the end
of their time in your service.

This module moves objects from the threads where they were working to a single,
global, worker thread when they go out of scope. Since an object that is going
out of scope can no longer be used, you could say that it is *garbage*; since
there is only one worker thread to receive all such objects, you could say that
the worker *collects* them. Wink wink, nudge nudge.

Users need only wrap their values in `BgDrop` to have their garbage collected.
`BgDrop` only accepts `'static` values, since the values are being sent to
another thread that makes no guarantees about timeliness of destruction, and
thus the garbage cannot have any lingering ties to live objects in the rest of
the program.

When a `BgDrop` goes out of scope, it attempts to send its interior value to the
collector thread. The first `BgDrop` to drop must start the collector thread,
which may result in an indefinite block until the thread begins. Once the
collector is running, all `BgDrop` drops will *attempt* to send their internal
value to the collector for destruction. If the send fails, then the value will
be dropped on the sending thread, rather than on the collector.

You can prevent future collections with `cancel_collection()`, which destroys
the channel used to move values to the collector thread. You can also get the
thread key for the collector with `collector()`. If you need to ensure that all
pending destructions occur before program exit, you should end your program with
a `cancel_collection()` and then `collector().unwrap().join()`. The collector
guarantees that objects queued for destruction are either enqueued for future
destruction *or* destroyed immediately, so the collector thread *will* receive a
signal for each object not destroyed on its prior thread.
!*///  Disposal system implementationxpresentxshmXSyncQueryExtensionXSyncInitializeXSyncListSystemCountersXSyncSystemCounterXSyncFreeSystemCounterListXSyncCreateCounterXSyncValueXSyncCounterXSyncSetCounterXSyncChangeCounterXSyncDestroyCounterXSyncQueryCounterXSyncAwaitXSyncWaitConditionXSyncCreateAlarmXSyncAlarmAttributesXSyncAlarmXSyncDestroyAlarmXSyncQueryAlarmXSyncChangeAlarmXSyncSetPriorityXSyncGetPriorityXSyncCreateFenceXSyncFenceXSyncTriggerFenceXSyncResetFenceXSyncDestroyFenceXSyncQueryFenceXSyncAwaitFenceXSyncIntToValueXSyncIntsToValueXSyncValueGreaterThanXSyncValueLessThanXSyncValueGreaterOrEqualXSyncValueLessOrEqualXSyncValueEqualXSyncValueIsNegativeXSyncValueIsZeroXSyncValueIsPositiveXSyncValueLow32XSyncValueHigh32XSyncValueAddXSyncValueSubtractXSyncMaxValueXSyncMinValueXSyncValueTypeXSyncTestTypeXSyncAlarmStateXSyncAlarmErrorXSyncCounterErrorwait_valuetest_typeXSyncTriggerevent_thresholdcounter_valueXSyncCounterNotifyEventalarm_valueXSyncAlarmNotifyEventSYNC_NAMESYNC_MAJOR_VERSIONSYNC_MINOR_VERSIONXSyncCounterNotifyXSyncAlarmNotifyXSyncAlarmNotifyMaskXSyncNumberEventsXSyncBadCounterXSyncBadAlarmXSyncBadFenceXSyncNumberErrorsXSyncCACounterXSyncCAValueTypeXSyncCAValueXSyncCATestTypeXSyncCADeltaXSyncCAEventsXSyncValueType_XSyncAbsoluteXSyncValueType_XSyncRelativeXSyncTestType_XSyncPositiveTransitionXSyncTestType_XSyncNegativeTransitionXSyncTestType_XSyncPositiveComparisonXSyncTestType_XSyncNegativeComparisonXSyncAlarmState_XSyncAlarmActiveXSyncAlarmState_XSyncAlarmInactiveXSyncAlarmState_XSyncAlarmDestroyedtypelengthvaluelengthXServerInterpretedAddressXPresentQueryExtensionXPresentQueryVersionXPresentVersionXPresentPixmapXPresentNotifyXPresentNotifyMSCXPresentSelectInputXPresentFreeInputXPresentQueryCapabilitiesXPresentEventeididle_fenceXPresentIdleNotifyEventustmscXPresentCompleteNotifyEventoff_xoff_ypixmap_widthpixmap_heightpixmap_flagsXPresentConfigureNotifyEventPRESENT_NAMEPRESENT_MAJORPRESENT_MINORPRESENT_REVISIONPRESENT_VERSIONPresentNumberErrorsPresentNumberEventsX_PresentQueryVersionX_PresentPixmapX_PresentNotifyMSCX_PresentSelectInputX_PresentQueryCapabilitiesPresentNumberRequestsPresentOptionNonePresentOptionAsyncPresentOptionCopyPresentOptionUSTPresentOptionSuboptimalPresentAllOptionsPresentCapabilityNonePresentCapabilityAsyncPresentCapabilityFencePresentCapabilityUSTPresentAllCapabilitiesPresentConfigureNotifyPresentCompleteNotifyPresentIdleNotifyPresentConfigureNotifyMaskPresentCompleteNotifyMaskPresentIdleNotifyMaskPresentAllEventsPresentCompleteKindPixmapPresentCompleteKindNotifyMSCPresentCompleteModeCopyPresentCompleteModeFlipPresentCompleteModeSkipPresentCompleteModeSuboptimalCopy// TypesPictStandardARGB32PictStandardRGB24PictStandardA8PictStandardA4PictStandardA1XShmQueryExtensionXShmGetEventBaseXShmQueryVersionXShmPixmapFormatXShmAttachXShmSegmentInfoXShmDetachXShmPutImageXShmGetImageXShmCreateImageXShmCreatePixmapShmSeg/// of event/// # of last request processed by server/// true if this came from a SendEvent requestdiplay/// Display the event was read from/// drawable of request/// ShmReqCode/// X_ShmPutImageshmseg/// the ShmSeg used in the request/// the offset into ShmSeg used in the requestXShmCompletionEvent/// resource idshmid/// kernel idshmaddr/// address in clientreadOnly/// how the server should attach itEventFdCreate// Could change name on next major, since this uses pipes now.create_pipe_drop_fdPipeDropFds_drop_fd// Relying on the Drop in OwnedFd to close the fdXextOpenErrorKind// OpenError// OpenErrorKindGlxxextxxf86vmxixtstxscrnsaverlibdirDynamicLibraryopen_multi// x11_link!// DynamicLibraryXf86vmodeXftXInputXmuXpresentXssXt// The build constants emitted by this script are NOT public API.ReplyFDsRequestReplyRequestVoidRequestCookieWithFdsSetupRawFdContainerTryParseFdDiscardModeRawEventAndSeqNumberBufWithFds// Used to avoid too-complex types./// A combination of a buffer and a list of file descriptors.EventAndSeqNumber/// An event and its sequence number.PiecewiseBuf/// A buffer that is logically continuous, but presented in a number of pieces.ReplyOrError/// The reply to an X11 request./// An error caused by an X11 request./// Either a raw reply or a raw error response to an X11 request./// Type used as buffer to store raw replies or events before/// they are parsed.send_request_with_reply/// Send a request with a reply to the server./// The `bufs` parameter describes the raw bytes that should be sent. The returned cookie/// allows to get the response./// The `fds` parameter contains a list of file descriptors that should be sent with the/// request. Ownership of these FDs is transferred to the connection. This means that the/// connection will close the FDs after they were sent./// Users of this library will most likely not want to use this function directly. Instead, the/// generated code will take the supplied arguments, construct byte buffers, and call this/// The provided buffers must contain at least a single element and the first buffer must have/// at least four bytes. The length field must be set correctly, unless the request is larger/// than 2^18 bytes, because in this case, the length field would overflow. The connection/// automatically uses the BIG-REQUESTS extension for such large requests./// In any case, the request may not be larger than the server's maximum request length.send_trait_request_with_reply/// This function is a wrapper around [`RequestConnection::send_request_with_reply`]. This/// function gets a [`ReplyRequest`] as its argument to specify the request to send.send_request_with_reply_with_fds/// Send a request with a reply containing file descriptors to the server.send_trait_request_with_reply_with_fds/// This function is a wrapper around [`RequestConnection::send_request_with_reply_with_fds`]./// This function gets a [`ReplyFDsRequest`] as its argument to specify the request to send.send_request_without_reply/// Send a request without a reply to the server./// The `bufs` parameter describes the raw bytes that should be sent. The sequence number of/// the request is returned, but most likely not useful to users.send_trait_request_without_reply/// This function is a wrapper around [`RequestConnection::send_request_without_reply`]. This/// function gets a [`VoidRequest`] as its argument to specify the request to send.discard_replyRequestKind/// A reply to an error should be discarded./// This method is automatically called by the `Drop` implementation on `Cookie` so that any/// replies that are received later can be ignored./// Users of this library will most likely not want to use this function directly.prefetch_extension_information/// Prefetches information about an extension./// If the information of a extension is not cached yet, this function sends a/// `QueryExtension` request, but it does not wait for the reply./// You can use `extension_information()` to get the reply of such request./// Using this function can help to reduce round-trip latency, but you can use/// `extension_information()` directly without calling this function first.extension_information/// Get information about an extension./// To send a request for some extension, information about the extension (major opcode,/// first event code and first error code) is necessary. This function provides this/// The returned object is guaranteed to have a non-zero `present` field. Extensions that are/// not present are instead returned as `None`.wait_for_reply_or_error/// Wait for the reply to a request./// The given sequence number identifies the request for which replies are expected. If the X11/// server answered the request with an error, that error is returned as an `Err`.wait_for_reply_or_raw_errorwait_for_reply/// server answered the request with an error, this function returns `None` and the error is/// instead returned by `wait_for_event()` or `poll_for_event()`.wait_for_reply_with_fds/// Wait for the reply to a request that has FDs./// The given sequence number identifies the request for which replies are expected.wait_for_reply_with_fds_rawcheck_for_error/// Check whether a request that does not have a reply caused an X11 error./// The given sequence number identifies the request for which the check should be performed.check_for_raw_errorprefetch_maximum_request_bytes/// Prefetches the maximum request length./// If the maximum request length is not cached yet, this function sends a `BigRequests::Enable`/// request, but it does not wait for the reply./// You can use `maximum_request_bytes()` to get the result of this request./// `maximum_request_bytes()` directly without calling this function first./// Since this uses the `BigRequests` extension, the information about that extension needs to/// available. Otherwise, this has to wait for the reply when calling/// `extension_information()`./// To prefetch the necessary information, you can do the following:/// use x11rb::connection::RequestConnection;/// use x11rb::errors::ConnectionError;/// use x11rb::protocol::bigreq;/// # fn do_it(conn: impl RequestConnection) -> Result<(), ConnectionError> {/// // conn is a RequestConnection/// conn.prefetch_extension_information(bigreq::X11_EXTENSION_NAME)?;maximum_request_bytes/// The maximum number of bytes that the X11 server accepts in a request./// Parse a generic error./// Parse a generic event./// A connection to an X11 server for sending requests./// This trait only contains functions that are used by other parts of this library. This means/// that users of this library will most likely not need these functions, unless they want to/// implement their own X11 connection.wait_for_event/// Wait for a new event from the X11 server.wait_for_raw_event/// Wait for a new raw/unparsed event from the X11 server.wait_for_event_with_sequencewait_for_raw_event_with_sequencepoll_for_event/// Poll for a new event from the X11 server.poll_for_raw_event/// Poll for a new raw/unparsed event from the X11 server.poll_for_event_with_sequencepoll_for_raw_event_with_sequence/// Poll for a new unparsed/raw event from the X11 server./// Send all pending requests to the server./// Implementations of this trait may buffer requests for batched sending. When this method is/// called, all pending requests are sent./// You do not have to call this method before `wait_for_reply()`. If the request you want to/// wait for was not yet sent, it will be sent by `wait_for_reply()`./// Get the setup information sent by the X11 server./// The setup information contains X11 server, for example the window id of the root window./// Generate a new X11 identifier./// This method can, for example, be used for creating a new window. First, this method is/// called to generate an identifier. Next, `xproto::create_window` can be called to/// actually create the window./// A connection to an X11 server.IsVoid/// The request has no response, i.e. its type is "void".HasResponse/// The request has a response./// Does a request have a response?compute_length_field/// Check the request length and use BIG-REQUESTS if necessary./// This function is used by implementations of `RequestConnection` for sending requests. It/// examines the given request buffers and checks that the length field is set correctly./// If the request has more than 2^18 bytes, this function handles using the BIG-REQUESTS/// extension. The request is rewritten to include the correct length field. For this case, the/// `storage` parameter is needed. This function uses it to store the necessary buffers./// When using this function, it is recommended to allocate the `storage` parameter with/// use std::io::IoSlice;/// use x11rb::connection::{BufWithFds, RequestConnection, compute_length_field};/// use x11rb::cookie::{Cookie, CookieWithFds, VoidCookie};/// use x11rb::errors::{ParseError, ConnectionError};/// use x11rb::utils::RawFdContainer;/// use x11rb::x11_utils::{ExtensionInformation, TryParse, TryParseFd};/// use x11rb_protocol::SequenceNumber;/// # use x11rb::connection::ReplyOrError;/// struct MyConnection();/// impl RequestConnection for MyConnection {///     type Buf = Vec<u8>;///     // [snip, other functions here]///     # fn discard_reply(&self, sequence: SequenceNumber,///     #                  kind: x11rb::connection::RequestKind,///     #                  mode: x11rb_protocol::DiscardMode) {///     #    unimplemented!()///     # fn prefetch_extension_information(///     #     &self,///     #     extension_name: &'static str,///     # ) -> Result<(), ConnectionError> {///     # fn extension_information(&self, ext: &'static str)///     # -> Result<Option<ExtensionInformation>, ConnectionError> {///     # fn wait_for_reply_or_raw_error(&self, sequence: SequenceNumber)///     # -> Result<ReplyOrError<Vec<u8>>, ConnectionError> {///     # fn wait_for_reply(&self, sequence: SequenceNumber)///     # -> Result<Option<Vec<u8>>, x11rb::errors::ConnectionError> {///     # fn wait_for_reply_with_fds_raw(&self, sequence: SequenceNumber)///     # -> Result<ReplyOrError<BufWithFds<Vec<u8>>, Vec<u8>>, ConnectionError> {///     # fn check_for_raw_error(&self, sequence: SequenceNumber)///     # ->Result<Option<Vec<u8>>, ConnectionError> {///     # fn maximum_request_bytes(&self) -> usize {///     # fn prefetch_maximum_request_bytes(&self) {///     # fn parse_error(&self, _error: &[u8]) -> Result<x11rb::x11_utils::X11Error, ParseError> {///     # fn parse_event(&self, _event: &[u8]) -> Result<x11rb::protocol::Event, ParseError> {///     fn send_request_with_reply<R>(&self, bufs: &[IoSlice], fds: Vec<RawFdContainer>)///     -> Result<Cookie<Self, R>, ConnectionError>///     where R: TryParse {///         Ok(Cookie::new(self, self.send_request(bufs, fds, true, false)?))///     fn send_request_with_reply_with_fds<R>(&self, bufs: &[IoSlice], fds: Vec<RawFdContainer>)///     -> Result<CookieWithFds<Self, R>, ConnectionError>///     where R: TryParseFd {///         Ok(CookieWithFds::new(self, self.send_request(bufs, fds, true, true)?))///     fn send_request_without_reply(&self, bufs: &[IoSlice], fds: Vec<RawFdContainer>)///     -> Result<VoidCookie<Self>, ConnectionError> {///         Ok(VoidCookie::new(self, self.send_request(bufs, fds, false, false)?))/// impl MyConnection {///     fn send_request(&self, bufs: &[IoSlice], fds: Vec<RawFdContainer>,///                     has_reply: bool, reply_has_fds: bool)///     -> Result<SequenceNumber, ConnectionError>///         let mut storage = Default::default();///         let bufs = compute_length_field(self, bufs, &mut storage)?;///         unimplemented!("Now send bufs and fds to the X11 server");//! Generic connection-related types and definitions.//! This module contains the `Connection` trait and related definitions. The code in this module is//! used by each concrete implementation of the X11 protocol.EnableContextReplyListFontsWithInfoReply/// A handle to a possible error from the X11 server./// When sending a request for which no reply is expected, this library returns a `VoidCookie`./// This `VoidCookie` can then later be used to check if the X11 server sent an error./// See [crate::cookie#requests-without-a-reply] for infos on the different ways to handle X11/// errors in response to a request./// Construct a new cookie./// This function should only be used by implementations of/// `Connection::send_request_without_reply`./// Get the sequence number of the request that generated this cookie./// Check if the original request caused an X11 error./// Ignore all errors to this request./// Without calling this method, an error becomes available on the connection as an event after/// this cookie was dropped. This function causes errors to be ignored instead.RawCookie/// Internal helper for a cookie with an response/// Construct a new raw cookie./// `RequestConnection::send_request_with_reply`.into_sequence_number/// Consume this instance and get the contained sequence number out.raw_cookie/// A handle to a response from the X11 server./// When sending a request to the X11 server, this library returns a `Cookie`. This `Cookie` can/// then later be used to get the response that the server sent./// See [crate::cookie#requests-with-a-reply] for infos on the different ways to handle X11raw_reply/// Get the raw reply that the server sent.raw_reply_unchecked/// Get the raw reply that the server sent, but have errors handled as events./// Get the reply that the server sent.reply_unchecked/// Get the reply that the server sent, but have errors handled as events.discard_reply_and_errors/// Discard all responses to the request this cookie represents, even errors./// Without this function, errors are treated as events after the cookie is dropped./// A handle to a response containing `RawFd` from the X11 server./// This variant of `Cookie` represents a response that can contain `RawFd`s.multiple_reply_cookier" A handle to the replies to a `ListFontsWithInfo` request."r" `ListFontsWithInfo` generated more than one reply, but `Cookie` only allows getting one reply."r" This structure implements `Iterator` and allows to get all the replies."ListFontsWithInfoCookier" Get the sequence number of the request that generated this cookie."r" A handle to the replies to a `record::EnableContext` request."r" `EnableContext` generated more than one reply, but `Cookie` only allows getting one reply."RecordEnableContextCookie//! Cookies are handles to future replies or errors from the X11 server.//! When sending a request, you get back a cookie. There are different cookies for different//! kinds of requests.//! For requests without a reply, you get a [`VoidCookie`]. Requests with a reply are represented//! by a [`Cookie`] or a [`CookieWithFds`] if the reply also contains file descriptors.//! Additionally, there are two special cases for requests which generate more than one reply://! [`ListFontsWithInfoCookie`] and [`RecordEnableContextCookie`].//! # Handling X11 errors//! The X11 server can answer requests with an error packet for various reasons, e.g. because an//! invalid window ID was given. There are three options what can be done with errors://! - Errors can appear as X11 events in `wait_for_event()` (in XCB, this is called "unchecked")//! - Errors can be checked for locally after a request was sent (in XCB, this is called "checked")//! - Errors can be completely ignored (the closest analog in XCB would be `xcb_discard_reply()`)//! There is an additional difference between requests with and without replies.//! ## Requests without a reply//! For requests that do not have a reply, you get an instance of `VoidCookie` after sending the//! request. The different behaviors can be achieved via interacting with this cookie as foolows://! | What?           | How?                       |//! | --------------- | -------------------------- |//! | Treat as events | Just drop the cookie       |//! | Check locally   | `VoidCookie::check`        |//! | Ignore          | `VoidCookie::ignore_error` |//! ## Requests with a reply//! For requests with a reply, an additional option is what should happen to the reply. You can get//! the reply, but any errors are still treated as events. This allows to centralise X11 error//! handling a bit in case you only want to log errors.//! The following things can be done with the `Cookie` that you get after sending a request with an//! | Reply  | Errors locally/ignored             | Errors as events          |//! | ------ | ---------------------------------- | ------------------------- |//! | Get    | `Cookie::reply`                    | `Cookie::reply_unchecked` |//! | Ignore | `Cookie::discard_reply_and_errors` | Just drop the cookie      |CORE_CURSORScursor_shape_to_id/// Find a core cursor based on its name/// This function checks a built-in list of known names.NoHomeDir/// `$HOME` is not setNothingFound/// No cursor file could be found/// An error that occurred while searchingCoreChar/// The cursor is a core cursor that can be created with xproto's `CreateGlyphCursor`/// A cursor file was opened/// The result of finding a cursorparse_inherits// Get the 'Inherits' entry from an index.theme fileparse_inherits_implparse_inherits_successfultest_parse_inheritsfind_cursor/// Find a cursor file based on the name of a cursor theme and the name of the cursor.find_cursor_implcore_cursornothing_foundinherittest_find_cursor// FIXME: Make these tests pass on Windows; problem is "/" vs "\\" in paths//! Find the right cursor file from a cursor name// Based on libxcb-cursor's load_cursor.c which has://   Copyright © 2013 Michael Stapelberg//   Copyright © 2002 Keith Packard// and is licensed under MIT/X Consortium LicenseX11CookiePictformatparse_cursorRenderSupport/// Render extension not availableStaticCursor/// Static cursor support (CreateCursor added in RENDER 0.5)AnimatedCursor/// Animated cursor support (CreateAnimCursor added in RENDER 0.8)/// The level of cursor support of the X11 serverresource_databaserender_infoQueryVersionReplyQueryPictFormatsReply/// A cookie for creating a `Handle`/// Get the handle from the replies from the X11 serverfrom_repliescursor_fontpicture_formatrender_supportcursor_size/// A handle necessary for loading cursors/// Create a new cursor handle for creating cursors on the given screen./// The `resource_database` is used to look up settings like the current cursor theme and the/// cursor size to use./// This function returns a cookie that can be used to later get the actual handle./// If you want this function not to block, you should prefetch the RENDER extension's data on/// Loads the specified cursor, either from the cursor theme or by falling back to the X11/// "cursor" font.open_cursorcreate_core_cursorcreate_render_cursorAnimcursoreltfind_formatget_cursor_size//! Utility functions for working with X11 cursors//! The code in this module is only available when the `cursor` feature of the library is enabled.FILE_MAGICIMAGE_TYPEIMAGE_MAX_SIZE/// An I/O error occurred/// The file did not begin with the expected magicTooManyEntries/// The file contained unrealistically many imagesNoImages/// The file contains no images/// Some image's entry is corrupt and not self-consistent/// An entry is larger than the maximum size/// An error that occurred while parsing/// Read a single `u32` from a cursor file/// The file stores these entries in little endian.x_hoty_hot/// A single cursor image/// Read an `Image` from a reader/// A TOC entry in a cursor file/// Read a `TocEntry` from a readerfind_best_size/// Find the size of the image in the toc with a size as close as possible to the desired size./// Parse a complete cursor fileread_3x5_imageread_corrupt_image_wrong_kindread_corrupt_image_wrong_sizeread_image_too_large_widthread_image_too_large_heightread_image_too_shortfind_best_size_empty_inputfind_best_size_one_inputfind_best_size_selects_betterparse_cursor_too_shortparse_cursor_incorrect_magicparse_cursor_too_many_entriesparse_cursor_empty_tocparse_cursor_one_imageparse_cursor_two_images_plus_one_ignoredassert_same_images//! Parse the contents of a cursor file// This code is loosely based on parse_cursor_file.c from libxcb-cursor, which is:// and is covered by MIT/X Consortium License/// An unknown error occurred./// One situation were this error is used when libxcb indicates an error that does not match/// any of the defined error conditions. Thus, libxcb is violating its own API (or new error/// cases were defined, but are not yet handled by x11rb)./// An X11 extension was not supported by the server./// This corresponds to `XCB_CONN_CLOSED_EXT_NOTSUPPORTED`.MaximumRequestLengthExceeded/// A request larger than the maximum request length was sent./// This corresponds to `XCB_CONN_CLOSED_REQ_LEN_EXCEED`.FdPassingFailed/// File descriptor passing failed./// This corresponds to `XCB_CONN_CLOSED_FDPASSING_FAILED`./// Error while parsing some data, see `ParseError`./// Out of memory./// This is `XCB_CONN_CLOSED_MEM_INSUFFICIENT`./// An I/O error occurred on the connection./// An error that occurred on an already established X11 connection/// Some error occurred on the X11 connection./// The X11 server sent an error in response to a request./// An error that occurred with some request./// All available IDs have been exhausted./// An error caused by some request or by the exhaustion of IDs.//! This module contains the current mess that is error handling.//! # Integrating x11rb with an Event Loop//! To integrate x11rb with an event loop,//! [`std::os::unix::io::AsRawFd`](https://doc.rust-lang.org/std/os/unix/io/trait.AsRawFd.html) is//! implemented by [`RustConnection`](../rust_connection/struct.RustConnection.html)'s//! [`DefaultStream`](../rust_connection/struct.DefaultStream.html#impl-AsRawFd) and//! [`XCBConnection`](../xcb_ffi/struct.XCBConnection.html#impl-AsRawFd). This allows to integrate//! with an event loop that also handles timeouts or network I/O. See//! [`xclock_utc`](https://github.com/psychon/x11rb/blob/master/x11rb/examples/xclock_utc.rs) for an//! example.//! The general form of such an integration could be as follows://! use std::os::unix::io::{AsRawFd, RawFd};//! use std::os::windows::io::{AsRawSocket, RawSocket};//! use x11rb::rust_connection::RustConnection;//! use x11rb::errors::ConnectionError;//! fn main_loop(conn: &RustConnection) -> Result<(), ConnectionError> {//!     #[cfg(unix)]//!     let raw_handle = conn.stream().as_raw_fd();//!     let raw_handle = conn.stream().as_raw_socket();//!         while let Some(event) = conn.poll_for_event()? {//!             handle_event(event);//!         poll_for_readable(raw_handle);//!         // Do other work here.//! # fn handle_event<T>(event: T) {}//! # fn poll_for_readable<T>(event: T) {}//! The function `poll_for_readable` could wait for any number of I/O streams (besides the one from//! x11rb) to become readable. It can also implement timeouts, as seen in the//! [`xclock_utc` example](https://github.com/psychon/x11rb/blob/master/x11rb/examples/xclock_utc.rs).//! ## Threads and Races//! Both [`RustConnection`](../rust_connection/struct.RustConnection.html) and//! [`XCBConnection`](../xcb_ffi/struct.XCBConnection.html) are `Sync+Send`. However, it is still//! possible to see races in the presence of threads and an event loop.//! The underlying problem is that the following two points are not equivalent://! 1. A new event is available and can be returned from `conn.poll_for_event()`.//! 2. The underlying I/O stream is readable.//! The reason for this is an internal buffer that is required: When an event is received from the//! X11 server, but we are currently not in `conn.poll_for_event()`, then this event is added to an//! internal buffer. Thus, it can happen that there is an event available, but the stream is not//! readable.//! An example for such an other function is `conn.get_input_focus()?.reply()?`: The//! `GetInputFocus` request is sent to the server and then `reply()` waits for the reply. It does//! so by reading X11 packets from the X11 server until the right reply arrives. Any events that//! are read during this are buffered internally in the `Connection`.//! If this race occurs, the main loop would sit in `poll_for_readable` and wait, while the already//! buffered event is available. When something else wakes up the main loop and//! `conn.poll_for_event()` is called the next time, the event is finally processed.//! There are two ways around this://! 1. Only interact with x11rb from one thread.//! 2. Use a dedicated thread for waiting for event.//! In case (1), one can call `conn.poll_for_event()` before waiting for the underlying I/O stream//! to be readable. Since there are no other threads, nothing can read a new event from the stream//! after `conn.poll_for_event()` returned `None`.//! Option (2) is to start a thread that calls `conn.wait_for_event()` in a loop. This is basically//! a dedicated event loop for fetching events from the X11 server. All other threads can now//! freely use the X11 connection without events possibly getting stuck and only being processed//! later.HashMapEntryQueryExtensionReplyExtInfoProviderCheckStateExtensionManager/// Helper for implementing `RequestConnection::extension_information()`./// This helps with implementing `RequestConnection`. Most likely, you do not need this in your own/// code, unless you really want to implement your own X11 connection.Prefetchedprefetch_extension_information_aux/// If the extension has not prefetched yet, sends a `QueryExtension`/// requests, adds a field to the hash map and returns a reference to it./// Prefetchs an extension sending a `QueryExtension` without waiting for/// the reply.insert_extension_information/// Insert an extension if you already have the information./// An implementation of `RequestConnection::extension_information()`./// The given connection is used for sending a `QueryExtension` request if needed.get_from_major_opcodeget_from_event_codeget_from_error_codeFakeConnectiontest_double_awaittest_info_provider//! Helper for implementing `RequestConnection::extension_information()`.put_imageGetImageReplyXprotoImageOrderVisualtype/// Number of bits for the component/// Offset in an u32 of the componentColorComponent/// The description of a single color component./// For example, in an RGB image, pixels are often saved as `0xRRGGBB`, where each letter/// represents the respective color component. In the example, green has a `width` of 8 (it takes/// up 8 bits) and a `shift` of `16` (there are 16 less significant bits beyond it). This info is/// represented as a `ColorComponent`./// Create a new color component with the given information./// The following conditions must be satisfied:/// - `width <= 16`: color components have at most 16 bits./// - `shift < 32`: pixel values have at most 32 bits./// - `shift + width <= 32`: pixel values have at most 32 bits./// Get the bit width of the color component./// Get the bit shift of the color component./// Get the pixel mask representing this color component./// The mask can be used to mask off other colors in a pixel value. Only the bits that/// correspond to this color component are set./// # use x11rb::image::ColorComponent;/// let red = ColorComponent::new(8, 16)?;/// assert_eq!(red.mask(), 0xff0000);/// # Ok::<(), x11rb::errors::ParseError>(())/// Create a new color component from a color mask./// This turns a color mask into its individual components./// let red1 = ColorComponent::new(8, 16);/// let red2 = ColorComponent::from_mask(0xff0000);/// This function fails if the given value is not a well-formed mask. This means that at least/// one bit must be set and the set bits must be consecutive./// Get this color component out of a pixel value./// This function gets a single pixel value and returns this color component's value in that/// pixel value, expanded to width 16./// assert_eq!(0xABAB, red.decode(0x78AB_4321));/// Encode a color value according to this pixel format./// assert_eq!(0xAB0000, red.encode(0xABCD));/// A collection of color components describing the red, green, and blue components of a pixel./// A [`ColorComponent`] describes a single color component in an image. This structure describes/// the `red`, `green`, and `blue` color components by containing a [`ColorComponent`] for each of/// Create a new pixel layout from the description of each componentfrom_visual_type/// Create a new pixel layout/// This function errors if the visual has a different class than `TrueColor` or `DirectColor`,/// because color pallets and grayscales are not supported. This function also errors if the/// mask components of the visual are malformed./// Get the depth of this pixel layout./// The depth is the number of significant bits of each pixel value./// Decode a pixel value into its red, green, and blue components./// This function returns each component expanded to width 16./// # use x11rb::image::{ColorComponent, PixelLayout};/// let layout = PixelLayout::new(///     ColorComponent::new(8, 16)?,///     ColorComponent::new(8, 8)?,///     ColorComponent::new(8, 0)?,/// assert_eq!((0xABAB, 0x4343, 0x2121), layout.decode(0x78AB_4321));/// Encode a color value according to this layout./// assert_eq!(0x00AB_4321, layout.encode((0xABAB, 0x4343, 0x2121)));compute_strideBitsPerPixelScanlinePad// Compute the stride based on some information of the imagetest_stride// Find the format with the given depth in `setup.pixmap_formats`.number_enumround_to_multiplenumber_conversionstest_round_to_multipletest_scanline_pad/// Least significant byte first/// Most significant byte first/// Order in which bytes are stored in memory./// If the numberof bits per pixel is less than 8, then this is the/// order in which bits are packed into bytes./// Width in pixels./// Height in pixels./// Right padding on each scanline./// Color depth in bits./// Storage per pixel in bits. Must be >= depth./// Byte order of components./// This is the nibble order when bits_per_pixel is 4./// The image data./// The description of an image./// The width in pixels./// The height in pixels./// The padding on the right side of each scanline./// Each scanline is rounded up to some multiple of the `scanline_pad`./// Number of bits required to store one pixel./// This is always `>= depth`./// If `bits_per_pixel()` is smaller than 8, then this is the order in which bits are packed/// into bytes./// Raw pixel data./// Mutable access to the raw pixel data./// If the `Image` was constructed with `Cow::Borrowed`-access to its pixel data, then a copy/// is made when this method is called./// Construct a new image from existing data./// This constructs a new `Image` from given `data` without copying this data around. The other/// parameters describe the format that the image data is in./// See [`Image::allocate`] for a variant that allocates memory for you and/// [`Image::allocate_native`] for allocating an image that is in an X11 server's native/// The only possible error is that `data.len()` is too short for an image as described by the/// other parameters./// Construct a new, empty image./// This function allocates memory for a new image in the format that is described by the/// See [`Image::new`] for a variant that wraps an existing in-memory image in an `Image` andallocate_native/// This function allocates memory for a new image in the format that the X11 server expects./// The image will have size `width`x`height` and a depth of `depth`./// [`Image::allocate`] for allocating an image that is in a more general format, not/// necessarily what the X11 server wants./// The stride is the number of bytes that each row of pixel data occupies in memory./// Get an image from the X11 server./// This function sends a [`GetImage`](crate::protocol::xproto::GetImageRequest) request, waits/// for its response and wraps it in a new `Image`. The image and the corresponding visual id/// are returned./// The returned image contains the rectangle with top left corner `(x, y)` and size `(width,/// height)` of the given `drawable`.get_from_reply/// Construct an `Image` from a `GetImageReply`./// This function takes a `GetImageReply` and wraps it in an `Image`. The given `width` and/// `height` describe the corresponding values of the `GetImage` request that was used to get/// the `GetImageReply`./// Put an image to the X11 server./// This function sends a [`PutImage`](crate::protocol::xproto::PutImageRequest) request. This/// will upload this image to the given `drawable` to position `(dst_x, dst_y)`./// The server's maximum request size is honored. This means that a too large `PutImage`/// request is automatically split up into smaller pieces. Thus, if this function returns an/// error, the image could already be partially sent./// Convert this image into the format specified by the other parameters./// This function may need to copy the image, hence returns a `Cow`./// Convert this image into the native format of the X11 server.reencode/// Reencode this image to a different pixel layout / depth./// Each pixel of this image is interpreted according to `own` and written to the resulting/// image in the format described by `output`./// The resulting image is always in the native format as described by `setup`./// Set a single pixel in this image./// The pixel at position `(x, y)` will be set to the value `pixel`. `pixel` is truncated to/// this image's [`Self::bits_per_pixel`]./// If the image was constructed from a `Cow::Borrowed` access to its pixel data, this causes/// the whole pixel data to be copied. See [`Image::new`] and [`Image::data_mut`]./// Get the value of a single pixel./// This function gets the value of the pixel at `(x, y)`.compute_depth_1_addresstest_new_too_shortput_pixel_depth1put_pixel_depth4put_pixel_depth8put_pixel_depth16put_pixel_depth32get_pixel_depth1get_pixel_depth4get_pixel_depth8get_pixel_depth16get_pixel_depth32test_image//! Utility code for working with images.//! This module contains the [`Image`] struct which represents an arbitrary image in//! `ImageFormat::ZPixmap`. If you do not know what `ZPixmap` means, then rest assured that you do//! not want to know the details. It suffices to know that the values of the individual pixels are//! saved one after another in memory.//! An [`Image`] can be converted to a different internal representation. [`Image::native`]//! converts it to the native format of the X11 server. These conversions do not change the actual//! content of the image, but only the way that it is laid out in memory (e.g. byte order and//! padding). Specifically, there is no support for converting an image to another `depth`.//! The code in this module is only available when the `image` feature of the library is// For future readers:// - Z-Pixmap means that the pixels are right next to each other. I.e. first you have the value of//   the pixel at (0, 0), then (1, 0), .... At the end of the row, there might be some padding//   before the next row begins.// - XY-Bitmap consists of individual bits. The bits are assigned colors via a GC's foreground and//   background color when uploading to the X11 server.// - XY-Pixmap consists of bit planes. This means you first get the first bit of each pixel,//   stuffed together into bytes. After all of the first pixels are represented, the second plane//   begins with the second bit of each pixel etc.//single_use_lifetimes,// #[derive] generates an #[allow] for this// Not everything in x11rb::protocol has doc commentsevent_loop_integration// Only contains documentation, but no "actual rust"/// Reexports of dependenciesextension_manager/// Establish a new connection to an X11 server./// This function is identical to/// [RustConnection::connect](crate::rust_connection::RustConnection::connect)./// The universal null resource or null atom parameter value for many core X requests/// This constant can be used for many parameters in `create_window`/// This constant can be used for the depth parameter in `create_window`. It indicates to use the/// parent window's depth.COPY_CLASS_FROM_PARENT/// This constant can be used for the class parameter in `create_window`. It indicates to use the/// parent window's class./// This constant can be used in most request that take a timestamp argumentNO_SYMBOL/// This constant can be used to fill unused entries in `Keysym` tables//! X11 rust bindings.//! This library allows to interact with an X11 server from rust code. A connection to an X11//! server is represented by an implementation of the `Connection` trait.//! The client can interact with the server by sending requests. The server can answer requests and//! can also generate events.//! The examples that come with this library might be a good starting point for new users.//! # Getting started with X11//! X11 is a big protocol. I would claim that most of it is not actually that complicated, but it//! is still difficult to get into it. A good starting point might be some [libxcb//! tutorial](https://www.x.org/releases/X11R7.7/doc/libxcb/tutorial/index.html). This tutorial//! was adapted in this crate [as an//! example](https://github.com/psychon/x11rb/blob/master/x11rb/examples/tutorial.rs). A more in-depth//! look at the X11 protocol can be gained from the [protocol reference//! manual](https://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.html), but this requires some//! existing basic understanding of X11. If you want to figure out what some specific request does,//! be sure to look it up in the specification!//! Most extensions can be understood by reading their specification. Most of them can be found//! [here](https://www.x.org/releases/current/doc/index.html#protocol). For example, [the//! specification of Composite//! 0.4](https://www.x.org/releases/X11R7.5/doc/compositeproto/compositeproto.txt) consists of//! about six pages of text.//! The notable exception is the X keyboard extension, which is documented in a [PDF file with 168//! pages](https://www.x.org/releases/current/doc/kbproto/xkbproto.pdf) which I am never going to//! read completely.//! # Getting started with x11rb//! Most code in this code is automatically generated from an XML description of the protocol. This//! is the same approach as taken by [libxcb](https://xcb.freedesktop.org/) (and in fact this uses//! the same XML description). This means that if you know your way around X11, most things should//! be obvious to you.//! For example, here is how to create a new window with x11rb://! use x11rb::errors::ReplyOrIdError;//! use x11rb::protocol::xproto::*;//! use x11rb::COPY_DEPTH_FROM_PARENT;//!     let (conn, screen_num) = x11rb::connect(None).unwrap();//!     let screen = &conn.setup().roots[screen_num];//!     let win_id = conn.generate_id()?;//!     conn.create_window(//!         COPY_DEPTH_FROM_PARENT,//!         win_id,//!         screen.root,//!         100,//!         WindowClass::INPUT_OUTPUT,//!         &CreateWindowAux::new().background_pixel(screen.white_pixel),//!     )?;//!     conn.map_window(win_id)?;//!     conn.flush();//!         println!("Event: {:?}", conn.wait_for_event()?);//! More examples can be found in the//! [examples](https://github.com/psychon/x11rb/tree/master/x11rb/examples) directory.//! This crate uses [feature//! flags](https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section) to reduce//! the amount of compiled code. There are two kinds of feature flags available://! * Feature flags for specific X11 extensions//! * Feature flags for additional functionality//! ### Feature flags for specific X11 extensions//! By default, only the core X11 protocol and X11 extensions that are//! needed internally are enabled. Further extensions need to be explicitly enabled via their//! feature flag://! `composite`, `damage`, `dpms`, `dri2`, `dri3`, `glx`, `present`, `randr`, `record`, `render`,//! `res`, `screensaver`, `shape`, `shm`, `sync`, `xevie`, `xf86dri`, `xf86vidmode`, `xfixes`,//! `xinerama`, `xinput`, `xkb`, `xprint`, `xselinux`, `xtest`, `xv`, `xvmc`.//! If you want to take the "I do not want to think about this"-approach, you can enable the//! `all-extensions` feature to just enable, well, all extensions.//! ### Feature flags for additional functionality//! Additionally, the following flags exist://! * `allow-unsafe-code`: Enable features that require `unsafe`. Without this flag,//!   `x11rb::xcb_ffi::XCBConnection` and some support code for it are unavailable.//! * `cursor`: Enable the code in [crate::cursor] for loading cursor files.//! * `resource_manager`: Enable the code in [crate::resource_manager] for loading and querying the//!   X11 resource database.//! * `image`: Enable the code in [crate::image] for working with pixel image data.//! * `dl-libxcb`: Enabling this feature will prevent from libxcb being linked to the//!   resulting executable. Instead libxcb will be dynamically loaded at runtime.//!   This feature adds the [`crate::xcb_ffi::load_libxcb`] function, that allows to load//!   libxcb and check for success or failure.//! The [event_loop_integration](event_loop_integration/index.html) module contains some hints for//! integrating x11rb with an event loop as doc comments.// A list of lints that are only #![deny] and not the stronger #![forbid]. Each one has a comment// explaining why it gets the weaker treatment.GetPropertyReplyproperty_cookier" A cookie for getting a window's `WM_CLASS` property."r" See `WmClass`."WmClassCookier" Get the reply that the server sent."WmClassr" Get the reply that the server sent, but have errors handled as events."/// Send a `GetProperty` request for the `WM_CLASS` property of the given window/// The value of a window's `WM_CLASS` property./// Usage example:/// use x11rb::connection::Connection;/// use x11rb::properties::WmClass;/// use x11rb::protocol::xproto::Window;/// fn print_class_instance(///     conn: &impl Connection,///     window: Window,/// ) -> Result<bool, ConnectionError> {///     let wm_class = match WmClass::get(conn, window)?.reply_unchecked()? {///         Some(wm_class) => wm_class,///         None => return Ok(false), // Getting the property failed///     // Note that the WM_CLASS property is not actually encoded in utf8.///     // ASCII values are most common and for these from_utf8() should be fine.///     let class = std::str::from_utf8(wm_class.class());///     let instance = std::str::from_utf8(wm_class.instance());///         "For window {:x}, class is '{:?}' and instance is '{:?}'",///         window, class, instance,///     Ok(true)from_reply/// Construct a new `WmClass` instance from a `GetPropertyReply`./// The original `GetProperty` request must have been for a `WM_CLASS` property for this/// function to return sensible results./// Get the instance contained in this `WM_CLASS` property/// Get the class contained in this `WM_CLASS` propertyUserSpecified/// The user specified the values.ProgramSpecified/// The program specified the values./// Representation of whether some part of `WM_SIZE_HINTS` was user/program specified.r" A cookie for getting a window's `WM_SIZE_HINTS` property."WmSizeHintsCookieNUM_WM_SIZE_HINTS_ELEMENTS/// Send a `GetProperty` request for the given property of the given windowU_S_POSITION// Possible flags for `WM_SIZE_HINTS`.U_S_SIZEP_S_POSITIONP_S_SIZEP_MIN_SIZEP_MAX_SIZEP_RESIZE_INCREMENTP_ASPECTP_BASE_SIZEP_WIN_GRAVITY/// The numerator of the aspect ratio./// The denominator of the aspect ratio./// An aspect ratio `numerator` / `denominator`./// Create a new aspect ratio with the given values./// The position that the window should be assigned./// Note that current versions of ICCCM only make use of the `WmSizeHintsSpecification` field./// The later two fields exist only for backwards compatibility./// The size that the window should be assigned./// The minimum size that the window may be assigned./// The maximum size that the window may be assigned.size_increment/// The increment to be used for sizing the window together with `base_size`.aspect/// The minimum and maximum aspect ratio./// The base size of the window./// This is used together with `size_increment`./// The gravity that is used to make room for window decorations./// A structure representing a `WM_SIZE_HINTS` property./// Get a new, empty `WmSizeHints` structure.get_normal_hints/// Send a `GetProperty` request for the `WM_NORMAL_HINTS` property of the given window/// Construct a new `WmSizeHints` instance from a `GetPropertyReply`./// The original `WmSizeHints` request must have been for a `WM_SIZE_HINTS` property for thisset_normal_hints/// Set these `WM_SIZE_HINTS` on some window as the `WM_NORMAL_HINTS` property./// Set these `WM_SIZE_HINTS` on some window as the given property.r" A cookie for getting a window's `WM_HINTS` property."r" See `WmHints`."WmHintsCookie// WM_HINTSNUM_WM_HINTS_ELEMENTSWmHintsState/// The window should be in Normal state.Iconic/// The window should be in Iconic state./// The possible values for a `WM_STATE`'s state field.HINT_INPUT// Possible flags for `WM_HINTS`.HINT_STATEHINT_ICON_PIXMAPHINT_ICON_WINDOWHINT_ICON_POSITIONHINT_ICON_MASKHINT_WINDOW_GROUPHINT_URGENCY// This bit is obsolete, according to ICCCM//const HINT_MESSAGE: u32 = 1 << 7;/// Whether the window manager may set the input focus to this window./// See ICCCM §4.1.7 for details./// The state that the window should be when it leaves the Withdrawn state./// A pixmap that represents the icon of this window./// A window that should be used as icon.icon_position/// The position where the icon should be shown./// A mask for `icon_pixmap`./// This allows nonrectangular icons./// A window that represents a group of windows./// The specified window is called the "group leader". All windows with the same group leader/// are part of the same group./// Indication that the window contents are urgent./// Urgency means that a timely response of the user is required. The window manager must make/// some effort to draw the user's attention to this window while this flag is set./// A structure representing a `WM_HINTS` property./// Send a `GetProperty` request for the `WM_HINTS` property of the given window/// Construct a new `WmHints` instance from a `GetPropertyReply`./// The original `WmHints` request must have been for a `WM_HINTS` property for this/// Set these `WM_HINTS` on some window.parse_with_flag/// Parse an element of type `T` and turn it into an `Option` by checking if the given `bit` is set/// in `flags`.get_property_replytest_wm_classtest_wm_normal_hintstest_wm_hints//! Utility functions for working with X11 properties// WM_CLASS// WM_SIZE_HINTSRequestHeaderX11Connectionbigreq/// Get the major opcode of this extensionEnableReplybigreq_enable/// Extension trait defining the requests of this extension.// This file contains generated code. Do not edit directly.// To regenerate this, run 'make'.//! Bindings to the `BigRequests` X11 extension.query_versionredirect_windowredirect_subwindowsunredirect_windowunredirect_subwindowscreate_region_from_border_clipname_window_pixmapget_overlay_windowGetOverlayWindowReplyrelease_overlay_windowcomposite_query_versioncomposite_redirect_windowcomposite_redirect_subwindowscomposite_unredirect_windowcomposite_unredirect_subwindowscomposite_create_region_from_border_clipcomposite_name_window_pixmapcomposite_get_overlay_windowcomposite_release_overlay_window//! Bindings to the `Composite` X11 extension.ReportLeveldamage_query_versiondamage_createdamage_destroydamage_subtractdamage_addDamageWrapper/// A RAII-like wrapper around a [Damage]./// Instances of this struct represent a Damage that is freed in `Drop`./// Any errors during `Drop` are silently ignored. Most likely an error here means that your/// X11 connection is broken and later requests will also fail.for_damage/// Assume ownership of the given resource and destroy it in `Drop`./// Get the XID of the wrapped resourceinto_damage/// Assume ownership of the XID of the wrapped resource/// This function destroys this wrapper without freeing the underlying resource.create_and_get_cookie/// Create a new Damage and return a Damage wrapper and a cookie./// This is a thin wrapper around [create] that allocates an id for the Damage./// This function returns the resulting `DamageWrapper` that owns the created Damage and frees/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to/// [create]./// Errors can come from the call to [X11Connection::generate_id] or [create]./// Create a new Damage and return a Damage wrapper/// it in `Drop`.//! Bindings to the `Damage` X11 extension.dbe/// Queries the version of this extension./// Queries the version of this extension. You must do this before using any functionality it provides./// # Fields/// * `major_version` - The major version of the extension. Check that it is compatible with the XCB_DBE_MAJOR_VERSION that your code is compiled with./// * `minor_version` - The minor version of the extension. Check that it is compatible with the XCB_DBE_MINOR_VERSION that your code is compiled with.allocate_back_bufferBackBuffer/// Allocates a back buffer./// Associates `buffer` with the back buffer of `window`. Multiple ids may be associated with the back buffer, which is created by the first allocate call and destroyed by the last deallocate./// * `window` - The window to which to add the back buffer./// * `buffer` - The buffer id to associate with the back buffer./// * `swap_action` - The swap action most likely to be used to present this back buffer. This is only a hint, and does not preclude the use of other swap actions.deallocate_back_buffer/// Deallocates a back buffer./// Deallocates the given `buffer`. If `buffer` is an invalid id, a `BadBuffer` error is returned. Because a window may have allocated multiple back buffer ids, the back buffer itself is not deleted until all these ids are deallocated by this call./// * `buffer` - The back buffer to deallocate.swap_buffersSwapInfo/// Swaps front and back buffers./// Swaps the front and back buffers on the specified windows. The front and back buffers retain their ids, so that the window id continues to refer to the front buffer, while the back buffer id created by this extension continues to refer to the back buffer. Back buffer contents is moved to the front buffer. Back buffer contents after the operation depends on the given swap action. The optimal swap action depends on how each frame is rendered. For example, if the buffer is cleared and fully overwritten on every frame, the "untouched" action, which throws away the buffer contents, would provide the best performance. To eliminate visual artifacts, the swap will occure during the monitor VSync, if the X server supports detecting it./// * `n_actions` - Number of swap actions in `actions`./// * `actions` - List of windows on which to swap buffers.begin_idiom/// Begins a logical swap block./// Creates a block of operations intended to occur together. This may be needed if window presentation requires changing buffers unknown to this extension, such as depth or stencil buffers.end_idiom/// Ends a logical swap block.get_visual_infoGetVisualInfoReply/// Requests visuals that support double buffering.get_back_buffer_attributesGetBackBufferAttributesReply/// Gets back buffer attributes./// Returns the attributes of the specified `buffer`./// * `buffer` - The back buffer to query./// * `attributes` - The attributes of `buffer`.dbe_query_versiondbe_allocate_back_bufferdbe_deallocate_back_bufferdbe_swap_buffersdbe_begin_idiomdbe_end_idiomdbe_get_visual_infodbe_get_back_buffer_attributes//! Bindings to the `Dbe` X11 extension.GetVersionReplycapableCapableReplyget_timeoutsGetTimeoutsReplyset_timeoutsforce_levelDPMSModeInfoReplydpms_get_versiondpms_capabledpms_get_timeoutsdpms_set_timeoutsdpms_enabledpms_disabledpms_force_leveldpms_info//! Bindings to the `DPMS` X11 extension.dri2DriverTypeConnectReplyAuthenticateReplycreate_drawabledestroy_drawableget_buffersGetBuffersReplyCopyRegionReplyget_buffers_with_formatAttachFormatGetBuffersWithFormatReplySwapBuffersReplyget_mscGetMSCReplywait_mscWaitMSCReplywait_sbcWaitSBCReplyswap_intervalget_paramGetParamReplydri2_query_versiondri2_connectdri2_authenticatedri2_create_drawabledri2_destroy_drawabledri2_get_buffersdri2_copy_regiondri2_get_buffers_with_formatdri2_swap_buffersdri2_get_mscdri2_wait_mscdri2_wait_sbcdri2_swap_intervaldri2_get_param//! Bindings to the `DRI2` X11 extension.dri3OpenReplypixmap_from_bufferbuffer_from_pixmapBufferFromPixmapReplyfence_from_fdfd_from_fenceFDFromFenceReplyget_supported_modifiersGetSupportedModifiersReplypixmap_from_buffersbuffers_from_pixmapBuffersFromPixmapReplyset_drm_device_in_usedri3_query_versiondri3_opendri3_pixmap_from_bufferdri3_buffer_from_pixmapdri3_fence_from_fddri3_fd_from_fencedri3_get_supported_modifiersdri3_pixmap_from_buffersdri3_buffers_from_pixmapdri3_set_drm_device_in_use//! Bindings to the `DRI3` X11 extension.ge_query_version//! Bindings to the `GenericEvent` X11 extension.ContextTagrender_largedestroy_contextMakeCurrentReplyis_directIsDirectReplywait_glwait_xuse_x_fontcreate_glx_pixmapget_visual_configsGetVisualConfigsReplydestroy_glx_pixmapvendor_privatevendor_private_with_replyVendorPrivateWithReplyReplyquery_extensions_stringQueryExtensionsStringReplyquery_server_stringQueryServerStringReplyget_fb_configsGetFBConfigsReplycreate_pixmapFbconfigdestroy_pixmapcreate_new_contextquery_contextQueryContextReplymake_context_currentMakeContextCurrentReplycreate_pbufferPbufferdestroy_pbufferget_drawable_attributesGetDrawableAttributesReplychange_drawable_attributesdelete_windowset_client_info_arbcreate_context_attribs_arbset_client_info2_arbnew_listend_listdelete_listsgen_listsGenListsReplyfeedback_bufferselect_bufferrender_modeRenderModeReplyFinishReplypixel_storefpixel_storeiReadPixelsReplyget_booleanvGetBooleanvReplyget_clip_planeGetClipPlaneReplyget_doublevGetDoublevReplyGetErrorReplyget_floatvGetFloatvReplyget_integervGetIntegervReplyget_lightfvGetLightfvReplyget_lightivGetLightivReplyget_mapdvGetMapdvReplyget_mapfvGetMapfvReplyget_mapivGetMapivReplyget_materialfvGetMaterialfvReplyget_materialivGetMaterialivReplyget_pixel_mapfvGetPixelMapfvReplyget_pixel_mapuivGetPixelMapuivReplyget_pixel_mapusvGetPixelMapusvReplyget_polygon_stippleGetPolygonStippleReplyGetStringReplyget_tex_envfvGetTexEnvfvReplyget_tex_envivGetTexEnvivReplyget_tex_gendvGetTexGendvReplyget_tex_genfvGetTexGenfvReplyget_tex_genivGetTexGenivReplyget_tex_imageGetTexImageReplyget_tex_parameterfvGetTexParameterfvReplyget_tex_parameterivGetTexParameterivReplyget_tex_level_parameterfvGetTexLevelParameterfvReplyget_tex_level_parameterivGetTexLevelParameterivReplyIsEnabledReplyis_listIsListReplyare_textures_residentAreTexturesResidentReplydelete_texturesgen_texturesGenTexturesReplyis_textureIsTextureReplyget_color_tableGetColorTableReplyget_color_table_parameterfvGetColorTableParameterfvReplyget_color_table_parameterivGetColorTableParameterivReplyget_convolution_filterGetConvolutionFilterReplyget_convolution_parameterfvGetConvolutionParameterfvReplyget_convolution_parameterivGetConvolutionParameterivReplyget_separable_filterGetSeparableFilterReplyget_histogramGetHistogramReplyget_histogram_parameterfvGetHistogramParameterfvReplyget_histogram_parameterivGetHistogramParameterivReplyget_minmaxGetMinmaxReplyget_minmax_parameterfvGetMinmaxParameterfvReplyget_minmax_parameterivGetMinmaxParameterivReplyget_compressed_tex_image_arbGetCompressedTexImageARBReplydelete_queries_arbgen_queries_arbGenQueriesARBReplyis_query_arbIsQueryARBReplyget_queryiv_arbGetQueryivARBReplyget_query_objectiv_arbGetQueryObjectivARBReplyget_query_objectuiv_arbGetQueryObjectuivARBReplyglx_renderglx_render_largeglx_create_contextglx_destroy_contextglx_make_currentglx_is_directglx_query_versionglx_wait_glglx_wait_xglx_copy_contextglx_swap_buffersglx_use_x_fontglx_create_glx_pixmapglx_get_visual_configsglx_destroy_glx_pixmapglx_vendor_privateglx_vendor_private_with_replyglx_query_extensions_stringglx_query_server_stringglx_client_infoglx_get_fb_configsglx_create_pixmapglx_destroy_pixmapglx_create_new_contextglx_query_contextglx_make_context_currentglx_create_pbufferglx_destroy_pbufferglx_get_drawable_attributesglx_change_drawable_attributesglx_create_windowglx_delete_windowglx_set_client_info_arbglx_create_context_attribs_arbglx_set_client_info2_arbglx_new_listglx_end_listglx_delete_listsglx_gen_listsglx_feedback_bufferglx_select_bufferglx_render_modeglx_finishglx_pixel_storefglx_pixel_storeiglx_read_pixelsglx_get_booleanvglx_get_clip_planeglx_get_doublevglx_get_errorglx_get_floatvglx_get_integervglx_get_lightfvglx_get_lightivglx_get_mapdvglx_get_mapfvglx_get_mapivglx_get_materialfvglx_get_materialivglx_get_pixel_mapfvglx_get_pixel_mapuivglx_get_pixel_mapusvglx_get_polygon_stippleglx_get_stringglx_get_tex_envfvglx_get_tex_envivglx_get_tex_gendvglx_get_tex_genfvglx_get_tex_genivglx_get_tex_imageglx_get_tex_parameterfvglx_get_tex_parameterivglx_get_tex_level_parameterfvglx_get_tex_level_parameterivglx_is_enabledglx_is_listglx_flushglx_are_textures_residentglx_delete_texturesglx_gen_texturesglx_is_textureglx_get_color_tableglx_get_color_table_parameterfvglx_get_color_table_parameterivglx_get_convolution_filterglx_get_convolution_parameterfvglx_get_convolution_parameterivglx_get_separable_filterglx_get_histogramglx_get_histogram_parameterfvglx_get_histogram_parameterivglx_get_minmaxglx_get_minmax_parameterfvglx_get_minmax_parameterivglx_get_compressed_tex_image_arbglx_delete_queries_arbglx_gen_queries_arbglx_is_query_arbglx_get_queryiv_arbglx_get_query_objectiv_arbglx_get_query_objectuiv_arb//! Bindings to the `Glx` X11 extension.screensaverxc_miscxeviexf86drixf86vidmodexprintxselinuxxvxvmc//! Bindings to the X11 protocol.//! Each sub-module of this module corresponds to one X11 extension. It contains all the//! definitions from that extension. The core X11 protocol is in [`xproto`](xproto/index.html).// Clippy does not like some names from the XML.// This is not easy to fix, so ignore it.Fencenotify_mscselect_inputquery_capabilitiesQueryCapabilitiesReplypresent_query_versionpresent_pixmappresent_notify_mscpresent_select_inputpresent_query_capabilities//! Bindings to the `Present` X11 extension.set_screen_configSetScreenConfigReplyNotifyMaskget_screen_infoGetScreenInfoReplyget_screen_size_rangeGetScreenSizeRangeReplyset_screen_sizeget_screen_resourcesGetOutputInfoReplylist_output_propertiesListOutputPropertiesReplyquery_output_propertyQueryOutputPropertyReplyconfigure_output_propertychange_output_propertydelete_output_propertyget_output_propertyGetOutputPropertyReplycreate_modeCreateModeReplydestroy_modeadd_output_modedelete_output_modeget_crtc_infoSetCrtcConfigReplyget_crtc_gamma_sizeGetCrtcGammaSizeReplyget_crtc_gammaGetCrtcGammaReplyset_crtc_gammaget_screen_resources_currentset_crtc_transformget_crtc_transformGetCrtcTransformReplyget_panningGetPanningReplyset_panningSetPanningReplyset_output_primaryget_output_primaryGetOutputPrimaryReplyGetProvidersReplyget_provider_infoGetProviderInfoReplyset_provider_offload_sinkset_provider_output_sourcelist_provider_propertiesListProviderPropertiesReplyquery_provider_propertyQueryProviderPropertyReplyconfigure_provider_propertychange_provider_propertydelete_provider_propertyget_provider_propertyGetProviderPropertyReplyget_monitorsGetMonitorsReplyMonitorInfodelete_monitorCreateLeaseReplyfree_leaserandr_query_versionrandr_set_screen_configrandr_select_inputrandr_get_screen_inforandr_get_screen_size_rangerandr_set_screen_sizerandr_get_screen_resourcesrandr_get_output_inforandr_list_output_propertiesrandr_query_output_propertyrandr_configure_output_propertyrandr_change_output_propertyrandr_delete_output_propertyrandr_get_output_propertyrandr_create_moderandr_destroy_moderandr_add_output_moderandr_delete_output_moderandr_get_crtc_inforandr_set_crtc_configrandr_get_crtc_gamma_sizerandr_get_crtc_gammarandr_set_crtc_gammarandr_get_screen_resources_currentrandr_set_crtc_transformrandr_get_crtc_transformrandr_get_panningrandr_set_panningrandr_set_output_primaryrandr_get_output_primaryrandr_get_providersrandr_get_provider_inforandr_set_provider_offload_sinkrandr_set_provider_output_sourcerandr_list_provider_propertiesrandr_query_provider_propertyrandr_configure_provider_propertyrandr_change_provider_propertyrandr_delete_provider_propertyrandr_get_provider_propertyrandr_get_monitorsrandr_set_monitorrandr_delete_monitorrandr_create_leaserandr_free_lease//! Bindings to the `RandR` X11 extension.ElementHeaderClientSpecregister_clientsunregister_clientsGetContextReplyenable_contextdisable_contextfree_contextrecord_query_versionrecord_create_contextrecord_register_clientsrecord_unregister_clientsrecord_get_contextrecord_enable_contextrecord_disable_contextrecord_free_contextContextWrapper/// A RAII-like wrapper around a [Context]./// Instances of this struct represent a Context that is freed in `Drop`.for_contextcreate_context_and_get_cookie/// Create a new Context and return a Context wrapper and a cookie./// This is a thin wrapper around [create_context] that allocates an id for the Context./// This function returns the resulting `ContextWrapper` that owns the created Context and frees/// [create_context]./// Errors can come from the call to [X11Connection::generate_id] or [create_context]./// Create a new Context and return a Context wrapper//! Bindings to the `Record` X11 extension.query_pict_formatsquery_pict_index_valuesQueryPictIndexValuesReplycreate_pictureCreatePictureAuxchange_pictureChangePictureAuxset_picture_clip_rectanglesfree_picturePictOptrapezoidsTrapezoidtrianglestri_stripPointfixtri_fancreate_glyph_setGlyphsetreference_glyph_setfree_glyph_setadd_glyphsGlyphinfofree_glyphscomposite_glyphs8composite_glyphs16composite_glyphs32fill_rectanglescreate_cursorset_picture_transformquery_filtersQueryFiltersReplyset_picture_filtercreate_anim_cursoradd_trapscreate_solid_fillcreate_linear_gradientcreate_radial_gradientcreate_conical_gradientrender_query_versionrender_query_pict_formatsrender_query_pict_index_valuesrender_create_picturerender_change_picturerender_set_picture_clip_rectanglesrender_free_picturerender_compositerender_trapezoidsrender_trianglesrender_tri_striprender_tri_fanrender_create_glyph_setrender_reference_glyph_setrender_free_glyph_setrender_add_glyphsrender_free_glyphsrender_composite_glyphs8render_composite_glyphs16render_composite_glyphs32render_fill_rectanglesrender_create_cursorrender_set_picture_transformrender_query_filtersrender_set_picture_filterrender_create_anim_cursorrender_add_trapsrender_create_solid_fillrender_create_linear_gradientrender_create_radial_gradientrender_create_conical_gradientPictureWrapper/// A RAII-like wrapper around a [Picture]./// Instances of this struct represent a Picture that is freed in `Drop`.for_pictureinto_picturecreate_picture_and_get_cookie/// Create a new Picture and return a Picture wrapper and a cookie./// This is a thin wrapper around [create_picture] that allocates an id for the Picture./// This function returns the resulting `PictureWrapper` that owns the created Picture and frees/// [create_picture]./// Errors can come from the call to [X11Connection::generate_id] or [create_picture]./// Create a new Picture and return a Picture wrappercreate_solid_fill_and_get_cookie/// This is a thin wrapper around [create_solid_fill] that allocates an id for the Picture./// [create_solid_fill]./// Errors can come from the call to [X11Connection::generate_id] or [create_solid_fill].create_linear_gradient_and_get_cookie/// This is a thin wrapper around [create_linear_gradient] that allocates an id for the Picture./// [create_linear_gradient]./// Errors can come from the call to [X11Connection::generate_id] or [create_linear_gradient].create_radial_gradient_and_get_cookie/// This is a thin wrapper around [create_radial_gradient] that allocates an id for the Picture./// [create_radial_gradient]./// Errors can come from the call to [X11Connection::generate_id] or [create_radial_gradient].create_conical_gradient_and_get_cookie/// This is a thin wrapper around [create_conical_gradient] that allocates an id for the Picture./// [create_conical_gradient]./// Errors can come from the call to [X11Connection::generate_id] or [create_conical_gradient].GlyphsetWrapper/// A RAII-like wrapper around a [Glyphset]./// Instances of this struct represent a Glyphset that is freed in `Drop`.for_glyphsetinto_glyphsetcreate_glyph_set_and_get_cookie/// Create a new Glyphset and return a Glyphset wrapper and a cookie./// This is a thin wrapper around [create_glyph_set] that allocates an id for the Glyphset./// This function returns the resulting `GlyphsetWrapper` that owns the created Glyphset and frees/// [create_glyph_set]./// Errors can come from the call to [X11Connection::generate_id] or [create_glyph_set]./// Create a new Glyphset and return a Glyphset wrapper//! Bindings to the `Render` X11 extension.query_clientsQueryClientsReplyquery_client_resourcesQueryClientResourcesReplyquery_client_pixmap_bytesQueryClientPixmapBytesReplyquery_client_idsClientIdSpecQueryClientIdsReplyquery_resource_bytesResourceIdSpecQueryResourceBytesReplyres_query_versionres_query_clientsres_query_client_resourcesres_query_client_pixmap_bytesres_query_client_idsres_query_resource_bytes//! Bindings to the `Res` X11 extension.QueryInfoReplySetAttributesAuxunset_attributesscreensaver_query_versionscreensaver_query_infoscreensaver_select_inputscreensaver_set_attributesscreensaver_unset_attributesscreensaver_suspend//! Bindings to the `ScreenSaver` X11 extension.SOClipOrderingquery_extentsQueryExtentsReplyinput_selectedInputSelectedReplyget_rectanglesGetRectanglesReplyshape_query_versionshape_rectanglesshape_maskshape_combineshape_offsetshape_query_extentsshape_select_inputshape_input_selectedshape_get_rectangles//! Bindings to the `Shape` X11 extension.attach_fdcreate_segmentCreateSegmentReplyshm_query_versionshm_attachshm_detachshm_put_imageshm_get_imageshm_create_pixmapshm_attach_fdshm_create_segmentSegWrapper/// A RAII-like wrapper around a [Seg]./// Instances of this struct represent a Seg that is freed in `Drop`.for_seginto_segattach_and_get_cookie/// Create a new Seg and return a Seg wrapper and a cookie./// This is a thin wrapper around [attach] that allocates an id for the Seg./// This function returns the resulting `SegWrapper` that owns the created Seg and frees/// [attach]./// Errors can come from the call to [X11Connection::generate_id] or [attach]./// Create a new Seg and return a Seg wrapperattach_fd_and_get_cookie/// This is a thin wrapper around [attach_fd] that allocates an id for the Seg./// [attach_fd]./// Errors can come from the call to [X11Connection::generate_id] or [attach_fd].//! Bindings to the `Shm` X11 extension.InitializeReplylist_system_countersListSystemCountersReplycreate_counterdestroy_counterquery_counterQueryCounterReplyawait_Waitconditionchange_counterset_countercreate_alarmCreateAlarmAuxchange_alarmChangeAlarmAuxdestroy_alarmquery_alarmQueryAlarmReplyGetPriorityReplycreate_fencetrigger_fencereset_fencedestroy_fencequery_fenceQueryFenceReplyawait_fencesync_initializesync_list_system_counterssync_create_countersync_destroy_countersync_query_countersync_await_sync_change_countersync_set_countersync_create_alarmsync_change_alarmsync_destroy_alarmsync_query_alarmsync_set_prioritysync_get_prioritysync_create_fencesync_trigger_fencesync_reset_fencesync_destroy_fencesync_query_fencesync_await_fenceCounterWrapper/// A RAII-like wrapper around a [Counter]./// Instances of this struct represent a Counter that is freed in `Drop`.for_counterinto_countercreate_counter_and_get_cookie/// Create a new Counter and return a Counter wrapper and a cookie./// This is a thin wrapper around [create_counter] that allocates an id for the Counter./// This function returns the resulting `CounterWrapper` that owns the created Counter and frees/// [create_counter]./// Errors can come from the call to [X11Connection::generate_id] or [create_counter]./// Create a new Counter and return a Counter wrapperAlarmWrapper/// A RAII-like wrapper around a [Alarm]./// Instances of this struct represent a Alarm that is freed in `Drop`.for_alarminto_alarmcreate_alarm_and_get_cookie/// Create a new Alarm and return a Alarm wrapper and a cookie./// This is a thin wrapper around [create_alarm] that allocates an id for the Alarm./// This function returns the resulting `AlarmWrapper` that owns the created Alarm and frees/// [create_alarm]./// Errors can come from the call to [X11Connection::generate_id] or [create_alarm]./// Create a new Alarm and return a Alarm wrapperFenceWrapper/// A RAII-like wrapper around a [Fence]./// Instances of this struct represent a Fence that is freed in `Drop`.for_fenceinto_fencecreate_fence_and_get_cookie/// Create a new Fence and return a Fence wrapper and a cookie./// This is a thin wrapper around [create_fence] that allocates an id for the Fence./// This function returns the resulting `FenceWrapper` that owns the created Fence and frees/// [create_fence]./// Errors can come from the call to [X11Connection::generate_id] or [create_fence]./// Create a new Fence and return a Fence wrapperdri3_fence_from_fd_and_get_cookie/// This is a thin wrapper around [super::dri3::fence_from_fd] that allocates an id for the Fence./// [super::dri3::fence_from_fd]./// Errors can come from the call to [X11Connection::generate_id] or [super::dri3::fence_from_fd].//! Bindings to the `Sync` X11 extension.get_xid_rangeGetXIDRangeReplyget_xid_listGetXIDListReplyxc_misc_get_versionxc_misc_get_xid_rangexc_misc_get_xid_list//! Bindings to the `XCMisc` X11 extension.StartReplyEndReplySendReplySelectInputReplyxevie_query_versionxevie_startxevie_endxevie_sendxevie_select_input//! Bindings to the `Xevie` X11 extension.query_direct_rendering_capableQueryDirectRenderingCapableReplyopen_connectionOpenConnectionReplyclose_connectionget_client_driver_nameGetClientDriverNameReplyCreateContextReplyCreateDrawableReplyget_drawable_infoGetDrawableInfoReplyget_device_infoGetDeviceInfoReplyauth_connectionAuthConnectionReplyxf86dri_query_versionxf86dri_query_direct_rendering_capablexf86dri_open_connectionxf86dri_close_connectionxf86dri_get_client_driver_namexf86dri_create_contextxf86dri_destroy_contextxf86dri_create_drawablexf86dri_destroy_drawablexf86dri_get_drawable_infoxf86dri_get_device_infoxf86dri_auth_connection//! Bindings to the `XF86Dri` X11 extension.get_mode_lineGetModeLineReplymod_mode_lineModeFlagswitch_modeget_monitorGetMonitorReplylock_mode_switchget_all_mode_linesGetAllModeLinesReplyadd_mode_lineDotclockdelete_mode_linevalidate_mode_lineValidateModeLineReplyswitch_to_modeget_view_portGetViewPortReplyset_view_portget_dot_clocksGetDotClocksReplyset_client_versionGetGammaReplyget_gamma_rampGetGammaRampReplyset_gamma_rampget_gamma_ramp_sizeGetGammaRampSizeReplyget_permissionsGetPermissionsReplyxf86vidmode_query_versionxf86vidmode_get_mode_linexf86vidmode_mod_mode_linexf86vidmode_switch_modexf86vidmode_get_monitorxf86vidmode_lock_mode_switchxf86vidmode_get_all_mode_linesxf86vidmode_add_mode_linexf86vidmode_delete_mode_linexf86vidmode_validate_mode_linexf86vidmode_switch_to_modexf86vidmode_get_view_portxf86vidmode_set_view_portxf86vidmode_get_dot_clocksxf86vidmode_set_client_versionxf86vidmode_set_gammaxf86vidmode_get_gammaxf86vidmode_get_gamma_rampxf86vidmode_set_gamma_rampxf86vidmode_get_gamma_ramp_sizexf86vidmode_get_permissions//! Bindings to the `XF86VidMode` X11 extension.change_save_setSaveSetModeSaveSetTargetSaveSetMappingselect_selection_inputSelectionEventMaskselect_cursor_inputCursorNotifyMaskget_cursor_imageGetCursorImageReplycreate_region_from_bitmapcreate_region_from_windowcreate_region_from_gccreate_region_from_picturedestroy_regionunion_regionintersect_regionsubtract_regioninvert_regiontranslate_regionregion_extentsfetch_regionFetchRegionReplyset_gc_clip_regionset_window_shape_regionset_picture_clip_regionset_cursor_nameget_cursor_nameGetCursorNameReplyget_cursor_image_and_nameGetCursorImageAndNameReplychange_cursorchange_cursor_by_nameexpand_regionshow_cursorcreate_pointer_barrierBarrierDirectionsdelete_pointer_barrierset_client_disconnect_modeClientDisconnectFlagsget_client_disconnect_modeGetClientDisconnectModeReplyxfixes_query_versionxfixes_change_save_setxfixes_select_selection_inputxfixes_select_cursor_inputxfixes_get_cursor_imagexfixes_create_regionxfixes_create_region_from_bitmapxfixes_create_region_from_windowxfixes_create_region_from_gcxfixes_create_region_from_picturexfixes_destroy_regionxfixes_set_regionxfixes_copy_regionxfixes_union_regionxfixes_intersect_regionxfixes_subtract_regionxfixes_invert_regionxfixes_translate_regionxfixes_region_extentsxfixes_fetch_regionxfixes_set_gc_clip_regionxfixes_set_window_shape_regionxfixes_set_picture_clip_regionxfixes_set_cursor_namexfixes_get_cursor_namexfixes_get_cursor_image_and_namexfixes_change_cursorxfixes_change_cursor_by_namexfixes_expand_regionxfixes_hide_cursorxfixes_show_cursorxfixes_create_pointer_barrierxfixes_delete_pointer_barrierxfixes_set_client_disconnect_modexfixes_get_client_disconnect_mode/// A RAII-like wrapper around a [Region]./// Instances of this struct represent a Region that is freed in `Drop`.for_regioninto_regioncreate_region_and_get_cookie/// Create a new Region and return a Region wrapper and a cookie./// This is a thin wrapper around [create_region] that allocates an id for the Region./// This function returns the resulting `RegionWrapper` that owns the created Region and frees/// [create_region]./// Errors can come from the call to [X11Connection::generate_id] or [create_region]./// Create a new Region and return a Region wrappercreate_region_from_bitmap_and_get_cookie/// This is a thin wrapper around [create_region_from_bitmap] that allocates an id for the Region./// [create_region_from_bitmap]./// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_bitmap].create_region_from_window_and_get_cookie/// This is a thin wrapper around [create_region_from_window] that allocates an id for the Region./// [create_region_from_window]./// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_window].create_region_from_gc_and_get_cookie/// This is a thin wrapper around [create_region_from_gc] that allocates an id for the Region./// [create_region_from_gc]./// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_gc].create_region_from_picture_and_get_cookie/// This is a thin wrapper around [create_region_from_picture] that allocates an id for the Region./// [create_region_from_picture]./// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_picture].composite_create_region_from_border_clip_and_get_cookie/// This is a thin wrapper around [super::composite::create_region_from_border_clip] that allocates an id for the Region./// [super::composite::create_region_from_border_clip]./// Errors can come from the call to [X11Connection::generate_id] or [super::composite::create_region_from_border_clip].//! Bindings to the `XFixes` X11 extension.GetStateReplyget_screen_countGetScreenCountReplyget_screen_sizeGetScreenSizeReplyIsActiveReplyquery_screensQueryScreensReplyxinerama_query_versionxinerama_get_statexinerama_get_screen_countxinerama_get_screen_sizexinerama_is_activexinerama_query_screens//! Bindings to the `Xinerama` X11 extension.get_extension_versionGetExtensionVersionReplylist_input_devicesListInputDevicesReplyopen_deviceOpenDeviceReplyclose_deviceset_device_modeValuatorModeSetDeviceModeReplyselect_extension_eventEventClassget_selected_extension_eventsGetSelectedExtensionEventsReplychange_device_dont_propagate_listPropagateModeget_device_dont_propagate_listGetDeviceDontPropagateListReplyget_device_motion_eventsGetDeviceMotionEventsReplychange_keyboard_deviceChangeKeyboardDeviceReplychange_pointer_deviceChangePointerDeviceReplygrab_deviceGrabModeGrabDeviceReplyungrab_devicegrab_device_keyungrab_device_keygrab_device_buttonungrab_device_buttonallow_device_eventsDeviceInputModeget_device_focusGetDeviceFocusReplyset_device_focusget_feedback_controlGetFeedbackControlReplychange_feedback_controlChangeFeedbackControlMaskFeedbackCtlget_device_key_mappingGetDeviceKeyMappingReplychange_device_key_mappingget_device_modifier_mappingGetDeviceModifierMappingReplyset_device_modifier_mappingSetDeviceModifierMappingReplyget_device_button_mappingGetDeviceButtonMappingReplyset_device_button_mappingSetDeviceButtonMappingReplyquery_device_stateQueryDeviceStateReplydevice_bellset_device_valuatorsSetDeviceValuatorsReplyget_device_controlGetDeviceControlReplychange_device_controlDeviceCtlChangeDeviceControlReplylist_device_propertiesListDevicePropertiesReplychange_device_propertyChangeDevicePropertyAuxdelete_device_propertyget_device_propertyGetDevicePropertyReplyxi_query_pointerxi_warp_pointerxi_change_cursorxi_change_hierarchyHierarchyChangexi_set_client_pointerxi_get_client_pointerXIGetClientPointerReplyxi_select_eventsxi_query_versionXIQueryVersionReplyxi_query_deviceXIQueryDeviceReplyxi_set_focusxi_get_focusXIGetFocusReplyxi_grab_deviceGrabOwnerXIGrabDeviceReplyxi_ungrab_devicexi_allow_eventsEventModexi_passive_grab_deviceGrabTypeGrabMode22XIPassiveGrabDeviceReplyxi_passive_ungrab_devicexi_list_propertiesXIListPropertiesReplyxi_change_propertyXIChangePropertyAuxxi_delete_propertyxi_get_propertyXIGetPropertyReplyxi_get_selected_eventsXIGetSelectedEventsReplyxi_barrier_release_pointerBarrierReleasePointerInfosend_extension_eventEventForSendxinput_get_extension_versionxinput_list_input_devicesxinput_open_devicexinput_close_devicexinput_set_device_modexinput_select_extension_eventxinput_get_selected_extension_eventsxinput_change_device_dont_propagate_listxinput_get_device_dont_propagate_listxinput_get_device_motion_eventsxinput_change_keyboard_devicexinput_change_pointer_devicexinput_grab_devicexinput_ungrab_devicexinput_grab_device_keyxinput_ungrab_device_keyxinput_grab_device_buttonxinput_ungrab_device_buttonxinput_allow_device_eventsxinput_get_device_focusxinput_set_device_focusxinput_get_feedback_controlxinput_change_feedback_controlxinput_get_device_key_mappingxinput_change_device_key_mappingxinput_get_device_modifier_mappingxinput_set_device_modifier_mappingxinput_get_device_button_mappingxinput_set_device_button_mappingxinput_query_device_statexinput_device_bellxinput_set_device_valuatorsxinput_get_device_controlxinput_change_device_controlxinput_list_device_propertiesxinput_change_device_propertyxinput_delete_device_propertyxinput_get_device_propertyxinput_xi_query_pointerxinput_xi_warp_pointerxinput_xi_change_cursorxinput_xi_change_hierarchyxinput_xi_set_client_pointerxinput_xi_get_client_pointerxinput_xi_select_eventsxinput_xi_query_versionxinput_xi_query_devicexinput_xi_set_focusxinput_xi_get_focusxinput_xi_grab_devicexinput_xi_ungrab_devicexinput_xi_allow_eventsxinput_xi_passive_grab_devicexinput_xi_passive_ungrab_devicexinput_xi_list_propertiesxinput_xi_change_propertyxinput_xi_delete_propertyxinput_xi_get_propertyxinput_xi_get_selected_eventsxinput_xi_barrier_release_pointerxinput_send_extension_event//! Bindings to the `Input` X11 extension.use_extensionUseExtensionReplyselect_eventsMapPartSelectEventsAuxbellBellClassSpecIDSpeclatch_lock_stateget_controlsGetControlsReplyVModAXOptionBoolCtrlGetMapReplyset_mapSetMapFlagsSetMapAuxget_compat_mapSetOfGroupGetCompatMapReplyset_compat_mapSymInterpretModDefget_indicator_stateGetIndicatorStateReplyget_indicator_mapGetIndicatorMapReplyset_indicator_mapIndicatorMapget_named_indicatorLedClassGetNamedIndicatorReplyset_named_indicatorIMFlagIMGroupsWhichSetOfGroupsIMModsWhichget_namesNameDetailGetNamesReplyset_namesSetNamesAuxper_client_flagsPerClientFlagPerClientFlagsReplylist_componentsListComponentsReplyget_kbd_by_nameGBNDetailGetKbdByNameReplyXIFeatureset_device_infoDeviceLedInfoset_debugging_flagsString8SetDebuggingFlagsReplyxkb_use_extensionxkb_select_eventsxkb_bellxkb_get_statexkb_latch_lock_statexkb_get_controlsxkb_set_controlsxkb_get_mapxkb_set_mapxkb_get_compat_mapxkb_set_compat_mapxkb_get_indicator_statexkb_get_indicator_mapxkb_set_indicator_mapxkb_get_named_indicatorxkb_set_named_indicatorxkb_get_namesxkb_set_namesxkb_per_client_flagsxkb_list_componentsxkb_get_kbd_by_namexkb_get_device_infoxkb_set_device_infoxkb_set_debugging_flags//! Bindings to the `xkb` X11 extension.print_query_versionPrintQueryVersionReplyprint_get_printer_listPrintGetPrinterListReplyprint_rehash_printer_listprint_set_contextprint_get_contextPrintGetContextReplyprint_destroy_contextprint_get_screen_of_contextPrintGetScreenOfContextReplyprint_start_jobprint_end_jobprint_start_docprint_end_docprint_put_document_dataprint_get_document_dataPcontextPrintGetDocumentDataReplyprint_start_pageprint_end_pageprint_select_inputprint_input_selectedPrintInputSelectedReplyprint_get_attributesPrintGetAttributesReplyprint_get_one_attributesPrintGetOneAttributesReplyprint_set_attributesprint_get_page_dimensionsPrintGetPageDimensionsReplyprint_query_screensPrintQueryScreensReplyprint_set_image_resolutionPrintSetImageResolutionReplyprint_get_image_resolutionPrintGetImageResolutionReplyxprint_print_query_versionxprint_print_get_printer_listxprint_print_rehash_printer_listxprint_create_contextxprint_print_set_contextxprint_print_get_contextxprint_print_destroy_contextxprint_print_get_screen_of_contextxprint_print_start_jobxprint_print_end_jobxprint_print_start_docxprint_print_end_docxprint_print_put_document_dataxprint_print_get_document_dataxprint_print_start_pagexprint_print_end_pagexprint_print_select_inputxprint_print_input_selectedxprint_print_get_attributesxprint_print_get_one_attributesxprint_print_set_attributesxprint_print_get_page_dimensionsxprint_print_query_screensxprint_print_set_image_resolutionxprint_print_get_image_resolution//! Bindings to the `XPrint` X11 extension./// Creates a window./// Creates an unmapped window as child of the specified `parent` window. A/// CreateNotify event will be generated. The new window is placed on top in the/// stacking order with respect to siblings./// The coordinate system has the X axis horizontal and the Y axis vertical with/// the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms/// of pixels, and coincide with pixel centers. Each window and pixmap has its own/// coordinate system. For a window, the origin is inside the border at the inside,/// upper-left corner./// The created window is not yet displayed (mapped), call `xcb_map_window` to/// display it./// The created window will initially use the same cursor as its parent./// * `wid` - The ID with which you will refer to the new window, created by/// `xcb_generate_id`./// * `depth` - Specifies the new window's depth (TODO: what unit?)./// The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the/// `parent` window./// * `visual` - Specifies the id for the new window's visual./// The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the/// * `class` -/// * `parent` - The parent window of the new window./// * `border_width` - TODO:/// Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs./// * `x` - The X coordinate of the new window./// * `y` - The Y coordinate of the new window./// * `width` - The width of the new window./// * `height` - The height of the new window./// * `Colormap` - TODO: reasons?/// * `Match` - TODO: reasons?/// * `Cursor` - TODO: reasons?/// * `Pixmap` - TODO: reasons?/// * `Value` - TODO: reasons?/// * `Window` - TODO: reasons?/// * `Alloc` - The X server could not allocate the requested resources (no memory?)./// # See/// * `xcb_generate_id`: function/// * `MapWindow`: request/// * `CreateNotify`: eventchange_window_attributes/// change window attributes./// Changes the attributes specified by `value_mask` for the specified `window`./// * `window` - The window to change./// * `value_mask` -/// * `value_list` - Values for each of the attributes specified in the bitmask `value_mask`. The/// order has to correspond to the order of possible `value_mask` bits. See the/// * `Access` - TODO: reasons?/// * `Window` - The specified `window` does not exist.get_window_attributesGetWindowAttributesReply/// Gets window attributes./// Gets the current attributes for the specified `window`./// * `window` - The window to get the attributes from./// * `Drawable` - TODO: reasons?/// Destroys a window./// Destroys the specified window and all of its subwindows. A DestroyNotify event/// is generated for each destroyed window (a DestroyNotify event is first generated/// for any given window's inferiors). If the window was mapped, it will be/// automatically unmapped before destroying./// Calling DestroyWindow on the root window will do nothing./// * `window` - The window to destroy./// * `Window` - The specified window does not exist./// * `DestroyNotify`: event/// * `UnmapWindow`: requestdestroy_subwindows/// Changes a client's save set./// TODO: explain what the save set is for./// This function either adds or removes the specified window to the client's (your/// application's) save set./// * `mode` - Insert to add the specified window to the save set or Delete to delete it from the save set./// * `window` - The window to add or delete to/from your save set./// * `Match` - You created the specified window. This does not make sense, you can only add/// windows created by other clients to your save set./// * `Value` - You specified an invalid mode./// * `ReparentWindow`: requestreparent_window/// Reparents a window./// Makes the specified window a child of the specified parent window. If the/// window is mapped, it will automatically be unmapped before reparenting and/// re-mapped after reparenting. The window is placed in the stacking order on top/// with respect to sibling windows./// After reparenting, a ReparentNotify event is generated./// * `window` - The window to reparent./// * `parent` - The new parent of the window./// * `x` - The X position of the window within its new parent./// * `y` - The Y position of the window within its new parent./// * `Match` - The new parent window is not on the same screen as the old parent window./// The new parent window is the specified window or an inferior of the specified window./// The new parent is InputOnly and the window is not./// The specified window has a ParentRelative background and the new parent window is not the same depth as the specified window./// * `ReparentNotify`: eventmap_window/// Makes a window visible./// Maps the specified window. This means making the window visible (as long as its/// parent is visible)./// This MapWindow request will be translated to a MapRequest request if a window/// manager is running. The window manager then decides to either map the window or/// not. Set the override-redirect window attribute to true if you want to bypass/// this mechanism./// If the window manager decides to map the window (or if no window manager is/// running), a MapNotify event is generated./// If the window becomes viewable and no earlier contents for it are remembered,/// the X server tiles the window with its background. If the window's background/// is undefined, the existing screen contents are not altered, and the X server/// generates zero or more Expose events./// If the window type is InputOutput, an Expose event will be generated when the/// window becomes visible. The normal response to an Expose event should be to/// repaint the window./// * `window` - The window to make visible./// * `Match` - The specified window does not exist./// * `MapNotify`: event/// * `Expose`: eventmap_subwindowsunmap_window/// Makes a window invisible./// Unmaps the specified window. This means making the window invisible (and all/// its child windows)./// Unmapping a window leads to the `UnmapNotify` event being generated. Also,/// `Expose` events are generated for formerly obscured windows./// * `window` - The window to make invisible./// * `UnmapNotify`: eventunmap_subwindowsconfigure_windowConfigureWindowAux/// Configures window attributes./// Configures a window's size, position, border width and stacking order./// * `window` - The window to configure./// * `value_mask` - Bitmask of attributes to change./// * `value_list` - New values, corresponding to the attributes in value_mask. The order has to/// correspond to the order of possible `value_mask` bits. See the example./// * `Match` - You specified a Sibling without also specifying StackMode or the window is not/// actually a Sibling./// * `Window` - The specified window does not exist. TODO: any other reason?///  * Configures the given window to the left upper corner///  * with a size of 1024x768 pixels.///  */// void my_example(xcb_connection_t *c, xcb_window_t window) {///     uint16_t mask = 0;///     mask |= XCB_CONFIG_WINDOW_X;///     mask |= XCB_CONFIG_WINDOW_Y;///     mask |= XCB_CONFIG_WINDOW_WIDTH;///     mask |= XCB_CONFIG_WINDOW_HEIGHT;///     const uint32_t values[] = {///         0,    /* x *////         0,    /* y *////         1024, /* width *////         768   /* height *////     xcb_configure_window(c, window, mask, values);///     xcb_flush(c);circulate_windowCirculate/// Change window stacking order./// If `direction` is `XCB_CIRCULATE_RAISE_LOWEST`, the lowest mapped child (if/// any) will be raised to the top of the stack./// If `direction` is `XCB_CIRCULATE_LOWER_HIGHEST`, the highest mapped child will/// be lowered to the bottom of the stack./// * `direction` -/// * `window` - The window to raise/lower (depending on `direction`)./// * `Value` - The specified `direction` is invalid./// Get current window geometry./// Gets the current geometry of the specified drawable (either `Window` or `Pixmap`)./// * `drawable` - The drawable (`Window` or `Pixmap`) of which the geometry will be received./// * `xwininfo`: program///  * Displays the x and y position of the given window.///     xcb_get_geometry_cookie_t cookie;///     xcb_get_geometry_reply_t *reply;///     cookie = xcb_get_geometry(c, window);///     /* ... do other work here if possible ... *////     if ((reply = xcb_get_geometry_reply(c, cookie, NULL))) {///         printf("This window is at %d, %d\\n", reply->x, reply->y);///     free(reply);query_treeQueryTreeReply/// query the window tree./// Gets the root window ID, parent window ID and list of children windows for the/// specified `window`. The children are listed in bottom-to-top stacking order./// * `window` - The `window` to query.///  * Displays the root, parent and children of the specified window./// void my_example(xcb_connection_t *conn, xcb_window_t window) {///     xcb_query_tree_cookie_t cookie;///     xcb_query_tree_reply_t *reply;///     cookie = xcb_query_tree(conn, window);///     if ((reply = xcb_query_tree_reply(conn, cookie, NULL))) {///         printf("root = 0x%08x\\n", reply->root);///         printf("parent = 0x%08x\\n", reply->parent);///         xcb_window_t *children = xcb_query_tree_children(reply);///         for (int i = 0; i < xcb_query_tree_children_length(reply); i++)///             printf("child window = 0x%08x\\n", children[i]);///         free(reply);intern_atom/// Get atom identifier by name./// Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified/// name. Atoms are used in protocols like EWMH, for example to store window titles/// (`_NET_WM_NAME` atom) as property of a window./// If `only_if_exists` is 0, the atom will be created if it does not already exist./// If `only_if_exists` is 1, `XCB_ATOM_NONE` will be returned if the atom does/// not yet exist./// * `name_len` - The length of the following `name`./// * `name` - The name of the atom./// * `only_if_exists` - Return a valid atom id only if the atom already exists./// * `Alloc` - TODO: reasons?/// * `Value` - A value other than 0 or 1 was specified for `only_if_exists`./// * `xlsatoms`: program/// * `GetAtomName`: request///  * Resolves the _NET_WM_NAME atom./// void my_example(xcb_connection_t *c) {///     xcb_intern_atom_cookie_t cookie;///     xcb_intern_atom_reply_t *reply;///     cookie = xcb_intern_atom(c, 0, strlen("_NET_WM_NAME"), "_NET_WM_NAME");///     if ((reply = xcb_intern_atom_reply(c, cookie, NULL))) {///         printf("The _NET_WM_NAME atom has ID %u\n", reply->atom);get_atom_nameGetAtomNameReply/// Changes a window property./// Sets or updates a property on the specified `window`. Properties are for/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`)./// Protocols such as EWMH also use properties - for example EWMH defines the/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property./// * `window` - The window whose property you want to change./// * `mode` -/// * `property` - The property you want to change (an atom)./// * `type` - The type of the property you want to change (an atom)./// * `format` - Specifies whether the data should be viewed as a list of 8-bit, 16-bit or/// 32-bit quantities. Possible values are 8, 16 and 32. This information allows/// the X server to correctly perform byte-swap operations as necessary./// * `data_len` - Specifies the number of elements (see `format`)./// * `data` - The property data./// * `Atom` - `property` or `type` do not refer to a valid atom./// * `Alloc` - The X server could not store the property (no memory?)./// * `InternAtom`: request/// * `xprop`: program///  * Sets the WM_NAME property of the window to "XCB Example".///     xcb_change_property(conn,///         XCB_PROP_MODE_REPLACE,///         window,///         XCB_ATOM_WM_NAME,///         XCB_ATOM_STRING,///         8,///         strlen("XCB Example"),///         "XCB Example");///     xcb_flush(conn);delete_property/// Gets a window property./// Gets the specified `property` from the specified `window`. Properties are for/// TODO: talk about `type`/// TODO: talk about `delete`/// TODO: talk about the offset/length thing. what's a valid use case?/// * `window` - The window whose property you want to get./// * `delete` - Whether the property should actually be deleted. For deleting a property, the/// specified `type` has to match the actual property type./// * `property` - The property you want to get (an atom)./// * `type` - The type of the property you want to get (an atom)./// * `long_offset` - Specifies the offset (in 32-bit multiples) in the specified property where the/// data is to be retrieved./// * `long_length` - Specifies how many 32-bit multiples of data should be retrieved (e.g. if you/// set `long_length` to 4, you will receive 16 bytes of data)./// * `Value` - The specified `long_offset` is beyond the actual property length (e.g. the/// property has a length of 3 bytes and you are setting `long_offset` to 1,/// resulting in a byte offset of 4).///  * Prints the WM_NAME property of the window.///     xcb_get_property_cookie_t cookie;///     xcb_get_property_reply_t *reply;///     /* These atoms are predefined in the X11 protocol. *////     xcb_atom_t property = XCB_ATOM_WM_NAME;///     xcb_atom_t type = XCB_ATOM_STRING;///     // TODO: a reasonable long_length for WM_NAME?///     cookie = xcb_get_property(c, 0, window, property, type, 0, 0);///     if ((reply = xcb_get_property_reply(c, cookie, NULL))) {///         int len = xcb_get_property_value_length(reply);///         if (len == 0) {///             printf("TODO\\n");///             free(reply);///             return;///         printf("WM_NAME is %.*s\\n", len,///                (char*)xcb_get_property_value(reply));ListPropertiesReplyset_selection_owner/// Sets the owner of a selection./// Makes `window` the owner of the selection `selection` and updates the/// last-change time of the specified selection./// TODO: briefly explain what a selection is./// * `selection` - The selection./// * `owner` - The new owner of the selection./// The special value `XCB_NONE` means that the selection will have no owner./// * `time` - Timestamp to avoid race conditions when running X over the network./// The selection will not be changed if `time` is earlier than the current/// last-change time of the `selection` or is later than the current X server time./// Otherwise, the last-change time is set to the specified time./// The special value `XCB_CURRENT_TIME` will be replaced with the current server/// * `Atom` - `selection` does not refer to a valid atom./// * `SetSelectionOwner`: requestget_selection_ownerGetSelectionOwnerReply/// Gets the owner of a selection./// Gets the owner of the specified selection./// send an event./// Identifies the `destination` window, determines which clients should receive/// the specified event and ignores any active grabs./// The `event` must be one of the core events or an event defined by an extension,/// so that the X server can correctly byte-swap the contents as necessary. The/// contents of `event` are otherwise unaltered and unchecked except for the/// `send_event` field which is forced to 'true'./// * `destination` - The window to send this event to. Every client which selects any event within/// `event_mask` on `destination` will get the event./// The special value `XCB_SEND_EVENT_DEST_POINTER_WINDOW` refers to the window/// that contains the mouse pointer./// The special value `XCB_SEND_EVENT_DEST_ITEM_FOCUS` refers to the window which/// has the keyboard focus./// * `event_mask` - Event_mask for determining which clients should receive the specified event./// See `destination` and `propagate`./// * `propagate` - If `propagate` is true and no clients have selected any event on `destination`,/// the destination is replaced with the closest ancestor of `destination` for/// which some client has selected a type in `event_mask` and for which no/// intervening window has that type in its do-not-propagate-mask. If no such/// window exists or if the window is an ancestor of the focus window and/// `InputFocus` was originally specified as the destination, the event is not sent/// to any clients. Otherwise, the event is reported to every client selecting on/// the final destination any of the types specified in `event_mask`./// * `event` - The event to send to the specified `destination`./// * `Window` - The specified `destination` window does not exist./// * `Value` - The given `event` is neither a core event nor an event defined by an extension./// * `ConfigureNotify`: event///  * Tell the given window that it was configured to a size of 800x600 pixels.///     /* Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes.///      * In order to properly initialize these bytes, we allocate 32 bytes even///      * though we only need less for an xcb_configure_notify_event_t *////     xcb_configure_notify_event_t *event = calloc(32, 1);///     event->event = window;///     event->window = window;///     event->response_type = XCB_CONFIGURE_NOTIFY;///     event->x = 0;///     event->y = 0;///     event->width = 800;///     event->height = 600;///     event->border_width = 0;///     event->above_sibling = XCB_NONE;///     event->override_redirect = false;///     xcb_send_event(conn, false, window, XCB_EVENT_MASK_STRUCTURE_NOTIFY,///                    (char*)event);///     free(event);grab_pointerGrabPointerReply/// Grab the pointer./// Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client./// * `event_mask` - Specifies which pointer events are reported to the client./// TODO: which values?/// * `confine_to` - Specifies the window to confine the pointer in (the user will not be able to/// move the pointer out of that window)./// The special value `XCB_NONE` means don't confine the pointer./// * `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the/// cursor./// * `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not/// reported to the `grab_window`./// * `grab_window` - Specifies the window on which the pointer should be grabbed./// * `time` - The time argument allows you to avoid certain circumstances that come up if/// applications take a long time to respond or if there are long network delays./// Consider a situation where you have two applications, both of which normally/// grab the pointer when clicked on. If both applications specify the timestamp/// from the event, the second application may wake up faster and successfully grab/// the pointer before the first application. The first application then will get/// an indication that the other application grabbed the pointer before its request/// was processed./// * `pointer_mode` -/// * `keyboard_mode` -/// * `GrabKeyboard`: request///  * Grabs the pointer actively/// void my_example(xcb_connection_t *conn, xcb_screen_t *screen, xcb_cursor_t cursor) {///     xcb_grab_pointer_cookie_t cookie;///     xcb_grab_pointer_reply_t *reply;///     cookie = xcb_grab_pointer(///         conn,///         false,               /* get all pointer events specified by the following mask *////         screen->root,        /* grab the root window *////         XCB_NONE,            /* which events to let through *////         XCB_GRAB_MODE_ASYNC, /* pointer events should continue as normal *////         XCB_GRAB_MODE_ASYNC, /* keyboard mode *////         XCB_NONE,            /* confine_to = in which window should the cursor stay *////         cursor,              /* we change the cursor to whatever the user wanted *////         XCB_CURRENT_TIME///     if ((reply = xcb_grab_pointer_reply(conn, cookie, NULL))) {///         if (reply->status == XCB_GRAB_STATUS_SUCCESS)///             printf("successfully grabbed the pointer\\n");ungrab_pointer/// release the pointer./// Releases the pointer and any queued events if you actively grabbed the pointer/// before using `xcb_grab_pointer`, `xcb_grab_button` or within a normal button/// press./// EnterNotify and LeaveNotify events are generated./// The pointer will not be released if `time` is earlier than the/// last-pointer-grab time or later than the current X server time./// * `name_len` - Length (in bytes) of `name`./// * `name` - A pattern describing an X core font./// * `GrabPointer`: request/// * `GrabButton`: request/// * `EnterNotify`: event/// * `LeaveNotify`: eventgrab_buttonButtonIndex/// Grab pointer button(s)./// This request establishes a passive grab. The pointer is actively grabbed as/// described in GrabPointer, the last-pointer-grab time is set to the time at/// which the button was pressed (as transmitted in the ButtonPress event), and the/// ButtonPress event is reported if all of the following conditions are true:/// The pointer is not grabbed and the specified button is logically pressed when/// the specified modifier keys are logically down, and no other buttons or/// modifier keys are logically down./// The grab-window contains the pointer./// The confine-to window (if any) is viewable./// A passive grab on the same button/key combination does not exist on any/// ancestor of grab-window./// The interpretation of the remaining arguments is the same as for GrabPointer./// The active grab is terminated automatically when the logical state of the/// pointer has all buttons released, independent of the logical state of modifier/// keys. Note that the logical state of a device (as seen by means of the/// protocol) may lag the physical state if device event processing is frozen. This/// request overrides all previous passive grabs by the same client on the same/// button/key combinations on the same window. A modifier of AnyModifier is/// equivalent to issuing the request for all possible modifier combinations/// (including the combination of no modifiers). It is not required that all/// specified modifiers have currently assigned keycodes. A button of AnyButton is/// equivalent to issuing the request for all possible buttons. Otherwise, it is/// not required that the button specified currently be assigned to a physical/// button./// An Access error is generated if some other client has already issued a/// GrabButton request with the same button/key combination on the same window./// When using AnyModifier or AnyButton, the request fails completely (no grabs are/// established), and an Access error is generated if there is a conflicting grab/// for any combination. The request has no effect on an active grab./// * `modifiers` - The modifiers to grab./// Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all/// possible modifier combinations./// * `button` -/// * `Access` - Another client has already issued a GrabButton with the same button/key/// combination on the same window./// * `Cursor` - The specified `cursor` does not exist.ungrab_buttonchange_active_pointer_grabGrabKeyboardReply/// Grab the keyboard./// Actively grabs control of the keyboard and generates FocusIn and FocusOut/// events. Further key events are reported only to the grabbing client./// Any active keyboard grab by this client is overridden. If the keyboard is/// actively grabbed by some other client, `AlreadyGrabbed` is returned. If/// `grab_window` is not viewable, `GrabNotViewable` is returned. If the keyboard/// is frozen by an active grab of another client, `GrabFrozen` is returned. If the/// specified `time` is earlier than the last-keyboard-grab time or later than the/// current X server time, `GrabInvalidTime` is returned. Otherwise, the/// last-keyboard-grab time is set to the specified time.///  * Grabs the keyboard actively/// void my_example(xcb_connection_t *conn, xcb_screen_t *screen) {///     xcb_grab_keyboard_cookie_t cookie;///     xcb_grab_keyboard_reply_t *reply;///     cookie = xcb_grab_keyboard(///         true,                /* report events *////         XCB_CURRENT_TIME,///         XCB_GRAB_MODE_ASYNC, /* process events as normal, do not require sync *////         XCB_GRAB_MODE_ASYNC///     if ((reply = xcb_grab_keyboard_reply(conn, cookie, NULL))) {///             printf("successfully grabbed the keyboard\\n");ungrab_keyboardgrab_key/// Grab keyboard key(s)./// Establishes a passive grab on the keyboard. In the future, the keyboard is/// actively grabbed (as for `GrabKeyboard`), the last-keyboard-grab time is set to/// the time at which the key was pressed (as transmitted in the KeyPress event),/// and the KeyPress event is reported if all of the following conditions are true:/// The keyboard is not grabbed and the specified key (which can itself be a/// modifier key) is logically pressed when the specified modifier keys are/// logically down, and no other modifier keys are logically down./// Either the grab_window is an ancestor of (or is) the focus window, or the/// grab_window is a descendant of the focus window and contains the pointer./// A passive grab on the same key combination does not exist on any ancestor of/// grab_window./// The interpretation of the remaining arguments is as for XGrabKeyboard.  The active grab is terminated/// automatically when the logical state of the keyboard has the specified key released (independent of the/// logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window./// Note that the logical state of a device (as seen by client applications) may lag the physical state if/// device event processing is frozen./// A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers).  It is not required that all modifiers specified/// have currently assigned KeyCodes.  A keycode argument of AnyKey is equivalent to issuing the request for/// all possible KeyCodes.  Otherwise, the specified keycode must be in the range specified by min_keycode/// and max_keycode in the connection setup, or a BadValue error results./// If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess/// error results.  When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error/// results (no grabs are established) if there is a conflicting grab for any combination./// * `owner_events` - If 1, the `grab_window` will still get the key events. If 0, events are not/// * `grab_window` - Specifies the window on which the key should be grabbed./// * `key` - The keycode of the key to grab./// The special value `XCB_GRAB_ANY` means grab any key./// Using the special value `XCB_MOD_MASK_ANY` means grab the key with all/// * `Access` - Another client has already issued a GrabKey with the same button/key/// * `Value` - The key is not `XCB_GRAB_ANY` and not in the range specified by `min_keycode`/// and `max_keycode` in the connection setup.ungrab_key/// release a key combination./// Releases the key combination on `grab_window` if you grabbed it using/// `xcb_grab_key` before./// * `key` - The keycode of the specified key combination./// Using the special value `XCB_GRAB_ANY` means releasing all possible key codes./// * `grab_window` - The window on which the grabbed key combination will be released./// * `modifiers` - The modifiers of the specified key combination./// Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination/// with every possible modifier combination./// * `Window` - The specified `grab_window` does not exist./// * `GrabKey`: request/// * `xev`: programallow_events/// release queued events./// Releases queued events if the client has caused a device (pointer/keyboard) to/// freeze due to grabbing it actively. This request has no effect if `time` is/// earlier than the last-grab time of the most recent active grab for this client/// or if `time` is later than the current X server time./// * `Value` - You specified an invalid `mode`.grab_serverungrab_serverQueryPointerReply/// get pointer coordinates./// Gets the root window the pointer is logically on and the pointer coordinates/// relative to the root window's origin./// * `window` - A window to check if the pointer is on the same screen as `window` (see the/// `same_screen` field in the reply).get_motion_eventsGetMotionEventsReply/// move mouse pointer./// Moves the mouse pointer to the specified position./// If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the/// pointer is inside `src_window` and within the rectangle specified by (`src_x`,/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to/// `src_window`./// If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`)/// relative to the current position of the pointer./// * `src_window` - If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the/// * `dst_window` - If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the/// * `SetInputFocus`: requestset_input_focus/// Sets input focus./// Changes the input focus and the last-focus-change time. If the specified `time`/// is earlier than the current last-focus-change time, the request is ignored (to/// avoid race conditions when running X over the network)./// A FocusIn and FocusOut event is generated when focus is changed./// * `focus` - The window to focus. All keyboard events will be reported to this window. The/// window must be viewable (TODO), or a `xcb_match_error_t` occurs (TODO)./// If `focus` is `XCB_NONE` (TODO), all keyboard events are/// discarded until a new focus window is set./// If `focus` is `XCB_POINTER_ROOT` (TODO), focus is on the root window of the/// screen on which the pointer is on currently./// * `revert_to` - Specifies what happens when the `focus` window becomes unviewable (if `focus`/// is neither `XCB_NONE` nor `XCB_POINTER_ROOT`)./// * `Window` - The specified `focus` window does not exist./// * `Match` - The specified `focus` window is not viewable./// * `Value` - TODO: Reasons?/// * `FocusIn`: event/// * `FocusOut`: eventget_input_focusGetInputFocusReplyQueryKeymapReplyopen_font/// opens a font./// Opens any X core font matching the given `name` (for example "-misc-fixed-*")./// Note that X core fonts are deprecated (but still supported) in favor of/// client-side rendering using Xft./// * `fid` - The ID with which you will refer to the font, created by `xcb_generate_id`./// * `Name` - No font matches the given `name`.close_fontquery_fontFontableQueryFontReply/// query font metrics./// Queries information associated with the font./// * `font` - The fontable (Font or Graphics Context) to query.query_text_extentsChar2bQueryTextExtentsReply/// get text extents./// Query text extents from the X11 server. This request returns the bounding box/// of the specified 16-bit character string in the specified `font` or the font/// contained in the specified graphics context./// `font_ascent` is set to the maximum of the ascent metrics of all characters in/// the string. `font_descent` is set to the maximum of the descent metrics./// `overall_width` is set to the sum of the character-width metrics of all/// characters in the string. For each character in the string, let W be the sum of/// the character-width metrics of all characters preceding it in the string. Let L/// be the left-side-bearing metric of the character plus W. Let R be the/// right-side-bearing metric of the character plus W. The lbearing member is set/// to the minimum L of all characters in the string. The rbearing member is set to/// the maximum R./// For fonts defined with linear indexing rather than 2-byte matrix indexing, each/// `xcb_char2b_t` structure is interpreted as a 16-bit number with byte1 as the/// most significant byte. If the font has no defined default character, undefined/// characters in the string are taken to have all zero metrics./// Characters with all zero metrics are ignored. If the font has no defined/// default_char, the undefined characters in the string are also ignored./// * `font` - The `font` to calculate text extents in. You can also pass a graphics context./// * `string_len` - The number of characters in `string`./// * `string` - The text to get text extents for./// * `GContext` - The specified graphics context does not exist./// * `Font` - The specified `font` does not exist.list_fontsListFontsReply/// get matching font names./// Gets a list of available font names which match the given `pattern`./// * `pattern_len` - The length (in bytes) of `pattern`./// * `pattern` - A font pattern, for example "-misc-fixed-*"./// The asterisk (*) is a wildcard for any number of characters. The question mark/// (?) is a wildcard for a single character. Use of uppercase or lowercase does/// not matter./// * `max_names` - The maximum number of fonts to be returned.list_fonts_with_info/// get matching font names and information.set_font_pathget_font_pathGetFontPathReply/// Creates a pixmap./// Creates a pixmap. The pixmap can only be used on the same screen as `drawable`/// is on and only with drawables of the same `depth`./// * `depth` - TODO/// * `pid` - The ID with which you will refer to the new pixmap, created by/// * `drawable` - Drawable to get the screen from./// * `width` - The width of the new pixmap./// * `height` - The height of the new pixmap./// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.free_pixmap/// Destroys a pixmap./// Deletes the association between the pixmap ID and the pixmap. The pixmap/// storage will be freed when there are no more references to it./// * `pixmap` - The pixmap to destroy./// * `Pixmap` - The specified pixmap does not exist.create_gcCreateGCAux/// Creates a graphics context./// Creates a graphics context. The graphics context can be used with any drawable/// that has the same root and depth as the specified drawable./// * `cid` - The ID with which you will refer to the graphics context, created by/// * `drawable` - Drawable to get the root/depth from./// * `Font` - TODO: reasons?change_gcChangeGCAux/// change graphics context components./// Changes the components specified by `value_mask` for the specified graphics context./// * `gc` - The graphics context to change./// * `value_list` - Values for each of the components specified in the bitmask `value_mask`. The/// * `GContext` - TODO: reasons?///  * Changes the foreground color component of the specified graphics context./// void my_example(xcb_connection_t *conn, xcb_gcontext_t gc, uint32_t fg, uint32_t bg) {///     /* C99 allows us to use a compact way of changing a single component: *////     xcb_change_gc(conn, gc, XCB_GC_FOREGROUND, (uint32_t[]){ fg });///     /* The more explicit way. Beware that the order of values is important! *////     uint32_t mask = 0;///     mask |= XCB_GC_FOREGROUND;///     mask |= XCB_GC_BACKGROUND;///     uint32_t values[] = {///         fg,///         bg///     xcb_change_gc(conn, gc, mask, values);copy_gcset_dashesset_clip_rectanglesfree_gc/// Destroys a graphics context./// Destroys the specified `gc` and all associated storage./// * `gc` - The graphics context to destroy.clear_area/// copy areas./// Copies the specified rectangle from `src_drawable` to `dst_drawable`./// * `dst_drawable` - The destination drawable (Window or Pixmap)./// * `src_drawable` - The source drawable (Window or Pixmap)./// * `gc` - The graphics context to use./// * `src_x` - The source X coordinate./// * `src_y` - The source Y coordinate./// * `dst_x` - The destination X coordinate./// * `dst_y` - The destination Y coordinate./// * `width` - The width of the area to copy (in pixels)./// * `height` - The height of the area to copy (in pixels)./// * `Match` - `src_drawable` has a different root or depth than `dst_drawable`.poly_pointCoordModepoly_line/// draw lines./// Draws `points_len`-1 lines between each pair of points (point[i], point[i+1])/// in the `points` array. The lines are drawn in the order listed in the array./// They join correctly at all intermediate points, and if the first and last/// points coincide, the first and last lines also join correctly. For any given/// line, a pixel is not drawn more than once. If thin (zero line-width) lines/// intersect, the intersecting pixels are drawn multiple times. If wide lines/// intersect, the intersecting pixels are drawn only once, as though the entire/// request were a single, filled shape./// * `drawable` - The drawable to draw the line(s) on./// * `points_len` - The number of `xcb_point_t` structures in `points`./// * `points` - An array of points./// * `coordinate_mode` -///  * Draw a straight line./// void my_example(xcb_connection_t *conn, xcb_drawable_t drawable, xcb_gcontext_t gc) {///     xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, drawable, gc, 2,///                   (xcb_point_t[]) { {10, 10}, {100, 10} });poly_segment/// Draws multiple, unconnected lines. For each segment, a line is drawn between/// (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of/// `xcb_segment_t` structures and does not perform joining at coincident/// endpoints. For any given line, a pixel is not drawn more than once. If lines/// intersect, the intersecting pixels are drawn multiple times./// TODO: include the xcb_segment_t data structure/// TODO: an example/// * `drawable` - A drawable (Window or Pixmap) to draw on./// TODO: document which attributes of a gc are used/// * `segments_len` - The number of `xcb_segment_t` structures in `segments`./// * `segments` - An array of `xcb_segment_t` structures./// * `Drawable` - The specified `drawable` does not exist./// * `GContext` - The specified `gc` does not exist.poly_rectanglepoly_arcfill_polyPolyShapepoly_fill_rectangle/// Fills rectangles./// Fills the specified rectangle(s) in the order listed in the array. For any/// given rectangle, each pixel is not drawn more than once. If rectangles/// * `drawable` - The drawable (Window or Pixmap) to draw on./// The following graphics context components are used: function, plane-mask,/// fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask./// The following graphics context mode-dependent components are used:/// foreground, background, tile, stipple, tile-stipple-x-origin, and/// tile-stipple-y-origin./// * `rectangles_len` - The number of `xcb_rectangle_t` structures in `rectangles`./// * `rectangles` - The rectangles to fill.poly_fill_arcpoly_text8poly_text16image_text8/// Draws text./// Fills the destination rectangle with the background pixel from `gc`, then/// paints the text with the foreground pixel from `gc`. The upper-left corner of/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width,/// the height is font-ascent + font-descent. The overall-width, font-ascent and/// font-descent are as returned by `xcb_query_text_extents` (TODO)./// Note that using X core fonts is deprecated (but still supported) in favor of/// * `drawable` - The drawable (Window or Pixmap) to draw text on./// * `string_len` - The length of the `string`. Note that this parameter limited by 255 due to/// using 8 bits!/// * `string` - The string to draw. Only the first 255 characters are relevant due to the data/// type of `string_len`./// * `x` - The x coordinate of the first character, relative to the origin of `drawable`./// * `y` - The y coordinate of the first character, relative to the origin of `drawable`./// The following graphics context components are used: plane-mask, foreground,/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask./// * `ImageText16`: requestimage_text16/// * `string_len` - The length of the `string` in characters. Note that this parameter limited by/// 255 due to using 8 bits!/// type of `string_len`. Every character uses 2 bytes (hence the 16 in this/// request's name)./// * `ImageText8`: requestcreate_colormapColormapAllocfree_colormapcopy_colormap_and_freeinstall_colormapuninstall_colormaplist_installed_colormapsListInstalledColormapsReplyalloc_colorAllocColorReply/// Allocate a color./// Allocates a read-only colormap entry corresponding to the closest RGB value/// supported by the hardware. If you are using TrueColor, you can take a shortcut/// and directly calculate the color pixel value to avoid the round trip. But, for/// example, on 16-bit color setups (VNC), you can easily get the closest supported/// RGB value to the RGB value you are specifying./// * `cmap` - TODO/// * `red` - The red value of your color./// * `green` - The green value of your color./// * `blue` - The blue value of your color./// * `Colormap` - The specified colormap `cmap` does not exist.alloc_named_colorAllocNamedColorReplyalloc_color_cellsAllocColorCellsReplyalloc_color_planesAllocColorPlanesReplyfree_colorsstore_colorsColoritemstore_named_colorColorFlagquery_colorsQueryColorsReplyLookupColorReplycreate_glyph_cursor/// create cursor./// Creates a cursor from a font glyph. X provides a set of standard cursor shapes/// in a special font named cursor. Applications are encouraged to use this/// interface for their cursors because the font can be customized for the/// individual display type./// All pixels which are set to 1 in the source will use the foreground color (as/// specified by `fore_red`, `fore_green` and `fore_blue`). All pixels set to 0/// will use the background color (as specified by `back_red`, `back_green` and/// `back_blue`)./// * `cid` - The ID with which you will refer to the cursor, created by `xcb_generate_id`./// * `source_font` - In which font to look for the cursor glyph./// * `mask_font` - In which font to look for the mask glyph./// * `source_char` - The glyph of `source_font` to use./// * `mask_char` - The glyph of `mask_font` to use as a mask: Pixels which are set to 1 define/// which source pixels are displayed. All pixels which are set to 0 are not/// * `fore_red` - The red value of the foreground color./// * `fore_green` - The green value of the foreground color./// * `fore_blue` - The blue value of the foreground color./// * `back_red` - The red value of the background color./// * `back_green` - The green value of the background color./// * `back_blue` - The blue value of the background color./// * `Font` - The specified `source_font` or `mask_font` does not exist./// * `Value` - Either `source_char` or `mask_char` are not defined in `source_font` or `mask_font`, respectively.free_cursor/// Deletes a cursor./// Deletes the association between the cursor resource ID and the specified/// cursor. The cursor is freed when no other resource references it./// * `cursor` - The cursor to destroy./// * `Cursor` - The specified cursor does not exist.recolor_cursorquery_best_sizeQueryShapeOfQueryBestSizeReplyquery_extension/// check if extension is present./// Determines if the specified extension is present on this X11 server./// Every extension has a unique `major_opcode` to identify requests, the minor/// opcodes and request formats are extension-specific. If the extension provides/// events and errors, the `first_event` and `first_error` fields in the reply are/// set accordingly./// There should rarely be a need to use this request directly, XCB provides the/// `xcb_get_extension_data` function instead./// * `name_len` - The length of `name` in bytes./// * `name` - The name of the extension to query, for example "RANDR". This is case/// sensitive!/// * `xdpyinfo`: program/// * `xcb_get_extension_data`: functionlist_extensionsListExtensionsReplyget_keyboard_mappingGetKeyboardMappingReplychange_keyboard_controlChangeKeyboardControlAuxget_keyboard_controlGetKeyboardControlReplychange_pointer_controlget_pointer_controlGetPointerControlReplyset_screen_saverBlankingExposuresget_screen_saverGetScreenSaverReplychange_hostsHostModelist_hostsListHostsReplyset_access_controlAccessControlset_close_down_modeCloseDown/// kills a client./// Forces a close down of the client that created the specified `resource`./// * `resource` - Any resource belonging to the client (for example a Window), used to identify/// the client connection./// The special value of `XCB_KILL_ALL_TEMPORARY`, the resources of all clients/// that have terminated in `RetainTemporary` (TODO) are destroyed./// * `Value` - The specified `resource` does not exist./// * `xkill`: programrotate_propertiesforce_screen_saverset_pointer_mappingSetPointerMappingReplyget_pointer_mappingGetPointerMappingReplyset_modifier_mappingSetModifierMappingReplyget_modifier_mappingGetModifierMappingReplyno_operationPixmapWrapper/// A RAII-like wrapper around a [Pixmap]./// Instances of this struct represent a Pixmap that is freed in `Drop`.for_pixmapinto_pixmapcreate_pixmap_and_get_cookie/// Create a new Pixmap and return a Pixmap wrapper and a cookie./// This is a thin wrapper around [create_pixmap] that allocates an id for the Pixmap./// This function returns the resulting `PixmapWrapper` that owns the created Pixmap and frees/// [create_pixmap]./// Errors can come from the call to [X11Connection::generate_id] or [create_pixmap]./// Create a new Pixmap and return a Pixmap wrapper/// A RAII-like wrapper around a [Window]./// Instances of this struct represent a Window that is freed in `Drop`.for_windowinto_windowcreate_window_and_get_cookie/// Create a new Window and return a Window wrapper and a cookie./// This is a thin wrapper around [create_window] that allocates an id for the Window./// This function returns the resulting `WindowWrapper` that owns the created Window and frees/// [create_window]./// Errors can come from the call to [X11Connection::generate_id] or [create_window]./// Create a new Window and return a Window wrapperFontWrapper/// A RAII-like wrapper around a [Font]./// Instances of this struct represent a Font that is freed in `Drop`.for_fontinto_fontopen_font_and_get_cookie/// Create a new Font and return a Font wrapper and a cookie./// This is a thin wrapper around [open_font] that allocates an id for the Font./// This function returns the resulting `FontWrapper` that owns the created Font and frees/// [open_font]./// Errors can come from the call to [X11Connection::generate_id] or [open_font]./// Create a new Font and return a Font wrapperGcontextWrapper/// A RAII-like wrapper around a [Gcontext]./// Instances of this struct represent a Gcontext that is freed in `Drop`.for_gcontextgcontextinto_gcontextcreate_gc_and_get_cookie/// Create a new Gcontext and return a Gcontext wrapper and a cookie./// This is a thin wrapper around [create_gc] that allocates an id for the Gcontext./// This function returns the resulting `GcontextWrapper` that owns the created Gcontext and frees/// [create_gc]./// Errors can come from the call to [X11Connection::generate_id] or [create_gc]./// Create a new Gcontext and return a Gcontext wrapperColormapWrapper/// A RAII-like wrapper around a [Colormap]./// Instances of this struct represent a Colormap that is freed in `Drop`.for_colormapinto_colormapcreate_colormap_and_get_cookie/// Create a new Colormap and return a Colormap wrapper and a cookie./// This is a thin wrapper around [create_colormap] that allocates an id for the Colormap./// This function returns the resulting `ColormapWrapper` that owns the created Colormap and frees/// [create_colormap]./// Errors can come from the call to [X11Connection::generate_id] or [create_colormap]./// Create a new Colormap and return a Colormap wrapperCursorWrapper/// A RAII-like wrapper around a [Cursor]./// Instances of this struct represent a Cursor that is freed in `Drop`.for_cursorinto_cursorcreate_cursor_and_get_cookie/// Create a new Cursor and return a Cursor wrapper and a cookie./// This is a thin wrapper around [create_cursor] that allocates an id for the Cursor./// This function returns the resulting `CursorWrapper` that owns the created Cursor and frees/// [create_cursor]./// Errors can come from the call to [X11Connection::generate_id] or [create_cursor]./// Create a new Cursor and return a Cursor wrappercreate_glyph_cursor_and_get_cookie/// This is a thin wrapper around [create_glyph_cursor] that allocates an id for the Cursor./// [create_glyph_cursor]./// Errors can come from the call to [X11Connection::generate_id] or [create_glyph_cursor].//! Bindings to the core X11 protocol.//! For more documentation on the X11 protocol, see the//! [protocol reference manual](https://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.html).//! This is especially recommended for looking up the exact semantics of//! specific errors, events, or requests.set_device_create_contextget_device_create_contextGetDeviceCreateContextReplyset_device_contextget_device_contextGetDeviceContextReplyset_window_create_contextget_window_create_contextGetWindowCreateContextReplyget_window_contextGetWindowContextReplyset_property_create_contextget_property_create_contextGetPropertyCreateContextReplyset_property_use_contextget_property_use_contextGetPropertyUseContextReplyget_property_contextGetPropertyContextReplyget_property_data_contextGetPropertyDataContextReplyset_selection_create_contextget_selection_create_contextGetSelectionCreateContextReplyset_selection_use_contextget_selection_use_contextGetSelectionUseContextReplyget_selection_contextGetSelectionContextReplyget_selection_data_contextGetSelectionDataContextReplylist_selectionsListSelectionsReplyget_client_contextGetClientContextReplyxselinux_query_versionxselinux_set_device_create_contextxselinux_get_device_create_contextxselinux_set_device_contextxselinux_get_device_contextxselinux_set_window_create_contextxselinux_get_window_create_contextxselinux_get_window_contextxselinux_set_property_create_contextxselinux_get_property_create_contextxselinux_set_property_use_contextxselinux_get_property_use_contextxselinux_get_property_contextxselinux_get_property_data_contextxselinux_list_propertiesxselinux_set_selection_create_contextxselinux_get_selection_create_contextxselinux_set_selection_use_contextxselinux_get_selection_use_contextxselinux_get_selection_contextxselinux_get_selection_data_contextxselinux_list_selectionsxselinux_get_client_context//! Bindings to the `SELinux` X11 extension.compare_cursorCompareCursorReplygrab_controlxtest_get_versionxtest_compare_cursorxtest_fake_inputxtest_grab_control//! Bindings to the `Test` X11 extension.query_adaptorsQueryAdaptorsReplyquery_encodingsQueryEncodingsReplygrab_portGrabPortReplyungrab_portput_videoput_stillget_videoget_stillstop_videoselect_video_notifyselect_port_notifyset_port_attributeget_port_attributeGetPortAttributeReplyquery_port_attributesQueryPortAttributesReplylist_image_formatsListImageFormatsReplyquery_image_attributesQueryImageAttributesReplyxv_query_extensionxv_query_adaptorsxv_query_encodingsxv_grab_portxv_ungrab_portxv_put_videoxv_put_stillxv_get_videoxv_get_stillxv_stop_videoxv_select_video_notifyxv_select_port_notifyxv_query_best_sizexv_set_port_attributexv_get_port_attributexv_query_port_attributesxv_list_image_formatsxv_query_image_attributesxv_put_imagexv_shm_put_image//! Bindings to the `Xv` X11 extension.list_surface_typesListSurfaceTypesReplyCreateSurfaceReplydestroy_surfacecreate_subpictureSubpictureCreateSubpictureReplydestroy_subpicturelist_subpicture_typesListSubpictureTypesReplyxvmc_query_versionxvmc_list_surface_typesxvmc_create_contextxvmc_destroy_contextxvmc_create_surfacexvmc_destroy_surfacexvmc_create_subpicturexvmc_destroy_subpicturexvmc_list_subpicture_types//! Bindings to the `XvMC` X11 extension.new_from_resource_manager/// Create a new X11 resource database from the `RESOURCE_MANAGER` property of the first/// screen's root window./// This function returns an error if the `GetProperty` request to get the `RESOURCE_MANAGER`/// property fails. It returns `Ok(None)` if the property does not exist, has the wrong format,/// or is empty.new_from_default/// Create a new X11 resource database from the default locations./// The default location is a combination of two places. First, the following places are/// searched for data:/// - The `RESOURCE_MANAGER` property of the first screen's root window (See///   [`new_from_resource_manager`])./// - If not found, the file `$HOME/.Xresources` is loaded./// - If not found, the file `$HOME/.Xdefaults` is loaded./// The result of the above search of the above search is combined with:/// - The contents of the file `$XENVIRONMENT`, if this environment variable is set./// - Otherwise, the contents of `$HOME/.Xdefaults-[hostname]`./// This function only returns an error if communication with the X11 server fails. All other/// errors are ignored. It might be that an empty database is returned./// The behaviour of this function is mostly equivalent to Xlib's `XGetDefault()`. The/// exception is that `XGetDefault()` does not load `$HOME/.Xresources`./// The behaviour of this function is equivalent to xcb-util-xrm's/// `xcb_xrm_database_from_default()`.//! X11 resource manager library.//! Usage example (please cache the database returned by [`new_from_default`] in real applications//! instead of re-opening it whenever a value is needed)://! use x11rb::{connection::Connection, errors::ReplyError, resource_manager::new_from_default};//! fn get_xft_dpi(conn: &impl Connection) -> Result<Option<u32>, ReplyError> {//!     let db = new_from_default(conn)?;//!     let value = db.get_value("Xft.dpi", "");//!     Ok(value.ok().flatten())//! This functionality is similar to what is available to C code through xcb-util-xrm and Xlib's//! `Xrm*` function family. Not all their functionality is available in this library. Please open a//! feature request if you need something that is not available.//! The code in this module is only available when the `resource_manager` feature of the library isGET_INPUT_FOCUS_REQUESTQUERY_EXTENSION_REQUESTProtoConnectionPollReplyReplyFdKindid_allocatorIdAllocatorxauthget_authpacket_readerPacketReaderDefaultStream/// A combination of a buffer and a list of file descriptors for use by [`RustConnection`].MaxRequestBytesBlockingMode// This mutex is only locked with `try_lock` (never blocks), so a simpler// lock based only on a atomic variable would be more efficient.reader_condition/// A connection to an X11 server implemented in pure rust/// This type is generic over `S`, which allows to use a generic stream to communicate with the/// server. This stream can written to and read from, but it can also be polled, meaning that one/// checks if new data can be read or written./// `RustConnection` always used an internal buffer for reading, so `R` does not need/// to be buffered./// Establish a new connection./// If no `dpy_name` is provided, the value from `$DISPLAY` is used.connect_to_stream/// Establish a new connection to the given streams./// `read` is used for reading data from the X11 server and `write` is used for writing./// `screen` is the number of the screen that should be used. This function checks that a/// screen with that number exists.connect_to_stream_with_auth_info/// The parameters `auth_name` and `auth_data` are used for the members/// `authorization_protocol_name` and `authorization_protocol_data` of the `SetupRequest` that/// is sent to the X11 server.for_connected_stream/// Establish a new connection for an already connected stream./// The given `stream` is used for communicating with the X11 server./// It is assumed that `setup` was just received from the server. Thus, the first reply to a/// request that is sent will have sequence number one./// Internal function for actually sending a request./// This function "does the actual work" for `send_request_with_reply()` and/// `send_request_without_reply()`./// Send a synchronisation packet to the X11 server./// This function sends a `GetInputFocus` request to the X11 server and arranges for its reply/// to be ignored. This ensures that a reply is expected (`ConnectionInner.next_reply_expected`/// increases).write_all_vectored/// Write a set of buffers on a `writer`. May also read packets/// from the server.flush_implread_packet_and_enqueue/// Read a packet from the connection./// This function waits for an X11 packet to be received. It drops the mutex protecting the/// inner data while waiting for a packet so that other threads can make progress. For this/// reason, you need to pass in a `MutexGuard` to be dropped. This function locks the mutex/// again and returns a new `MutexGuard`./// Note: If `mode` is `BlockingMode::Blocking`, the lock on `inner` will be temporarily/// released. While sending a request, `inner` must be kept locked to avoid sending the data/// of different requests interleaved. So, when `read_packet_and_enqueue` is called as part/// of a write, it must always be done with `mode` set to `BlockingMode::NonBlocking`.prefetch_maximum_request_bytes_impl/// Returns a reference to the contained stream.NotifyOnDrop/// Call `notify_all` on a condition variable when dropped.minor_opcodeRequestInfo/// Format information about a request in a Display impl//! A pure-rust implementation of a connection to an X11 server.// Locking rules// =============// To avoid deadlocks, it is important to have a defined ordering about mutexes:// Mutexes that may be locked when no other mutex is held:// - maximum_request_bytes// - extension_manager// - id_allocator// Then comes `inner`. This mutex protects the information about in-flight requests and packets// that were already read from the connection but not given out to callers. This mutex also// contains the write buffer and has to be locked in order to write something to the X11 server.// In this case, the mutex has to be kept locked until writing the request has finished. This is// necessary to ensure correct sync insertion without threads interfering with each other. When// this mutex is locked for operations other than writing, the lock should be kept only for a// short time.// The inner level is `packet_reader`. This mutex is only locked when `inner` is already held and// only with `try_lock()`. This ensures that there is only one reader. While actually reading, the// lock on `inner` is released so that other threads can make progress. If more threads want to// read while `read` is already locked, they sleep on `reader_condition`. The actual reader will// then notify this condition variable once it is done reading.// n.b. notgull: write_buffer follows the same rules// The condition variable is necessary since one thread may read packets that another thread waits// for. Thus, after reading something from the connection, all threads that wait for something have// to check if they are the intended recipient.ProtoPacketReader/// The read buffer to store incoming bytes in./// The inner reader that breaks these bytes into packets./// A wrapper around a reader that reads X11 packet./// Create a new `PacketReader` that reads from the given stream.try_read_packets/// Reads as many packets as possible from stream reader without blocking.TestStream// make a Stream that just reads from a Vec<u8>test_packetfixed_size_packetvariable_size_packetvery_large_packet//! Read X11 packets from a readerparse_displayConnectAddress/// Check if the stream is readable, i.e. there is pending data to be read./// Check if the stream is writable, i.e. some data could be successfully written to it.ReadAndWritable/// Check for both readability and writability./// The kind of operation that one want to poll for./// Does this poll mode include readability?/// Does this poll mode include writability?/// Waits for level-triggered read and/or write events on the stream./// This function does not return what caused it to complete the poll./// Instead, callers should try to read or write and check for/// [`std::io::ErrorKind::WouldBlock`]./// This function is allowed to spuriously return even if the stream/// is neither readable nor writable. However, it shall not do it/// continuously, which would cause a 100% CPU usage./// # Multithreading/// If `Self` is `Send + Sync` and `poll` is used concurrently from more than/// one thread, all threads should wake when the stream becomes readable (when/// `read` is `true`) or writable (when `write` is `true`)./// Read some bytes and FDs from this reader without blocking, returning how many bytes/// were read./// This function works like [`std::io::Read::read`], but also supports the reception of file/// descriptors. Any received file descriptors are appended to the given `fd_storage`./// Whereas implementation of [`std::io::Read::read`] are allowed to block or not to block,/// this method shall never block and return `ErrorKind::WouldBlock` if needed./// This function does not guarantee that all file descriptors were sent together with the data/// with which they are received. However, file descriptors may not be received later than the/// data that was sent at the same time. Instead, file descriptors may only be received/// If `Self` is `Send + Sync` and `read` is used concurrently from more than one thread:/// * Both the data and the file descriptors shall be read in order, but possibly/// interleaved across threads./// * Neither the data nor the file descriptors shall be duplicated./// * The returned value shall always be the actual number of bytes read into `buf`./// Read the exact number of bytes required to fill `buf` and also some amount of FDs./// Unlike `read`, this method always blocks until `buf` has been filled or there is an/// Same as `read`. In any case, if this function returns without error, `buf.len()` bytes/// should have been read into `buf`./// Write a buffer and some FDs into this writer without blocking, returning how many/// bytes were written./// This function works like [`std::io::Write::write`], but also supports sending file/// descriptors. The `fds` argument contains the file descriptors to send. The order of file/// descriptors is maintained. Whereas implementation of [`std::io::Write::write`] are/// allowed to block or not to block, this function must never block and return/// `ErrorKind::WouldBlock` if needed./// This function does not guarantee that all file descriptors are sent together with the data./// Any file descriptors that were sent are removed from the beginning of the given `Vec`./// There is no guarantee that the given file descriptors are received together with the given/// data. File descriptors might be received earlier than their corresponding data. It is not/// allowed for file descriptors to be received later than the bytes that were sent at the same/// If `Self` is `Send + Sync` and `write` is used concurrently from more than one thread:/// * Both the data and the file descriptors shall be written in order, but possibly/// * The returned value shall always be the actual number of bytes written from `buf`./// Like `write`, except that it writes from a slice of buffers. Like `write`, this/// method must never block./// This method must behave as a call to `write` with the buffers concatenated would./// The default implementation calls `write` with the first nonempty buffer provided./// Same as `write`./// A trait used to implement the raw communication with the X11 server./// None of the functions of this trait shall return [`std::io::ErrorKind::Interrupted`]./// If a system call fails with this error, the implementation should try again.DefaultStreamInner/// A wrapper around a `TcpStream` or `UnixStream`./// Use by default in `RustConnection` as stream.AbstractUnix/// Try to connect to the X11 server described by the given arguments.from_tcp_stream/// Creates a new `Stream` from an already connected `TcpStream`./// The stream will be set in non-blocking mode.from_unix_stream/// Creates a new `Stream` from an already connected `UnixStream`./// Get the peer's address in a format suitable for xauth./// The returned values can be directly given to `super::xauth::get_auth` as `family` and/// `address`.do_writeconnect_abstract_unix_streamafter_recvmsg/// Helper code to make sure that received FDs are marked as CLOEXECdata_buffd_bufflush_bufferwrite_helperneeds_flush/// Returns `true` if there is buffered data or FDs.WouldBlockWriterempty_write// Once upon a time, this paniced because it did bufs[0]incorrect_eof// Once upon a time, BufWriteFD fell back to only writing the first buffer. This could be// mistaken as EOF.SendEventDesttest_enum_debugtest_bitmask_debugwarning_span//! Wrapper around tracing so that tracing can be an optional dependency.//! Utility functions that are not specific to X11.//! # CSlice//! [`CSlice`] is a wrapper around some bytes in memory. It is unsafe to construct, but takes//! ownership of the bytes and allows accessing them as a `[u8]`. When dropped, the underlying//! memory is freed via [`libc::free`].//! `CSlice` is only available when the `allow-unsafe-code` feature is enabled.XProtoConnectionExtchange_property8/// Change a property on a window with format 8.change_property16/// Change a property on a window with format 16.change_property32/// Change a property on a window with format 32./// Synchronise with the X11 server./// This function synchronises with the X11 server. This means that all requests that are still/// in the output buffer are sent to the server. Then, we wait until the X11 server processed/// all requests./// Extension trait that simplifies API useGrabServer/// A RAII-like wrapper around [super::protocol::xproto::grab_server] and/// [super::protocol::xproto::ungrab_server]./// Instances of this struct represent that we sent a [super::protocol::xproto::grab_server]/// request. When this struct is dropped, an [super::protocol::xproto::ungrab_server] request is/// Grab the server by sending a [super::protocol::xproto::grab_server] request./// The returned type will call [super::protocol::xproto::ungrab_server] when it is dropped.//! Some wrappers around the generated code to simplify use.parse_request_headerBigRequestsReplyParsingFunction/// A helper macro for managing atoms/// In X11, one often has to work with many different atoms that are already known at compile time./// This macro can simplify managing such a list of atoms./// The following macro invocation:/// # use x11rb::atom_manager;/// atom_manager! {///     /// A collection of Atoms.///     pub AtomCollection:///     /// A handle to a response from the X11 server.///     AtomCollectionCookie {///         _NET_WM_NAME,///         _NET_WM_ICON,///         ATOM_WITH_SPACES: b"ATOM WITH SPACES",///         WHATEVER,/// ...expands to this:/// # use x11rb::protocol::xproto::{Atom, ConnectionExt, InternAtomReply};/// # use x11rb::errors::{ConnectionError, ReplyError};/// # use x11rb::cookie::Cookie;/// #[allow(non_snake_case)]/// #[derive(Debug, Clone, Copy)]/// /// A collection of Atoms./// pub struct AtomCollection {///     pub _NET_WM_NAME: Atom,///     pub _NET_WM_ICON: Atom,///     pub ATOM_WITH_SPACES: Atom,///     pub WHATEVER: Atom,/// /// A handle to a response from the X11 server./// struct AtomCollectionCookie<'c, C: ConnectionExt> {///     phantom: std::marker::PhantomData<&'c C>,///     _NET_WM_NAME: Cookie<'c, C, InternAtomReply>,///     _NET_WM_ICON: Cookie<'c, C, InternAtomReply>,///     ATOM_WITH_SPACES: Cookie<'c, C, InternAtomReply>,///     WHATEVER: Cookie<'c, C, InternAtomReply>,/// impl AtomCollection {///     pub fn new<C: ConnectionExt>(///         conn: &C,///     ) -> Result<AtomCollectionCookie<'_, C>, ConnectionError> {///         Ok(AtomCollectionCookie {///             phantom: std::marker::PhantomData,///             _NET_WM_NAME: conn.intern_atom(false, b"_NET_WM_NAME")?,///             _NET_WM_ICON: conn.intern_atom(false, b"_NET_WM_ICON")?,///             ATOM_WITH_SPACES: conn.intern_atom(false, b"ATOM WITH SPACES")?,///             WHATEVER: conn.intern_atom(false, b"WHATEVER")?,/// impl<'c, C> AtomCollectionCookie<'c, C>///     C: ConnectionExt,///     pub fn reply(self) -> Result<AtomCollection, ReplyError> {///         Ok(AtomCollection {///             _NET_WM_NAME: self._NET_WM_NAME.reply()?.atom,///             _NET_WM_ICON: self._NET_WM_ICON.reply()?.atom,///             ATOM_WITH_SPACES: self.ATOM_WITH_SPACES.reply()?.atom,///             WHATEVER: self.WHATEVER.reply()?.atom,__atom_manager_atom_value//! Some utilities for working with X11.// Use the `AtomicU64` from the standard library if we're on a platform that supports atomic// 64-bit operations. If we can't tell, just fall back to the `Mutex` implementation anyways.//! Either `AtomicU64` or emulating `AtomicU64` through a `Mutex`.CSlicepending_errorsraw_ffilibxcb_libraryload_libxcb/// The raw bytes of an event received by [`XCBConnection`] and its sequence number./// A combination of a buffer and a list of file descriptors for use by [`XCBConnection`].XcbConnectionWrapperext_mgrPendingErrorsmaximum_sequence_received/// This type wraps `*mut xcb_connection_t` that is provided by libxcb. It provides a rust/// interface to this C library.connection_error_from_connectionconnection_error_from_c_errorconnect_error_from_c_error/// If a `dpy_name` is provided, it describes the display that should be connected to, for/// example `127.0.0.1:1`. If no value is provided, the `$DISPLAY` environment variable isfrom_raw_xcb_connection/// Create a connection wrapper for a raw libxcb `xcb_connection_t`./// `xcb_disconnect` is called on drop only if `should_drop` is `true`./// If this function returns an `Err()` and `should_drop` was true, then/// `xcb_disconnect` was already called./// If `should_drop` is `false`, the connection must live longer than the returned/// `XCBConnection`. If `should_drop` is `true`, the returned `XCBConnection` will/// take the ownership of the connection.parse_setupxcb_setup_t// Slince the warning about ioslice.len().try_into().unwrap(). The target type is sometimes// usize (where this warning is correct) and sometimes c_int (where we need the conversion). We// need this here due to https://github.com/rust-lang/rust/issues/60681./// Check if the underlying XCB connection is in an error state.get_raw_xcb_connection/// Get access to the raw libxcb `xcb_connection_t`./// The returned pointer is valid for as long as the original object was not dropped. No/// ownerhsip is transferred.poll_for_reply/// Check if a reply to the given request already received./// Return Err(()) when the reply was not yet received. Returns Ok(None) when there can be no/// reply. Returns Ok(buffer) with the reply if there is one (this buffer can be an error or a/// reply).wrap_replywrap_errorwrap_eventreconstruct_full_sequence/// Reconstruct a full sequence number based on a partial value./// The assumption for the algorithm here is that the given sequence number was received/// recently. Thus, the maximum sequence number that was received so far is used to fill in the/// missing bytes for the result.// SAFETY: We provide a valid xcb_connection_t that is valid for as long as required by the trait.reconstruct_full_sequence_impl/// Reconstruct a partial sequence number based on a recently received 'full' sequence number./// The new sequence number may be before or after the `recent` sequence number.xcb_connect_smoke_test//! A FFI-based connection to an X11 server, using libxcb.//! This module is only available when the `allow-unsafe-code` feature is enabled.PendingErrorsInner/// A management struct for pending X11 errors//! Management of pending errors for the XCB connection.//! We add our own error tracking ontop of what XCB already provides. For this reason, this module//! contains a struct for tracking requests that were send and also tracking errors that were//! received, but not yet given to the user of this library.xcb_generic_error_txcb_generic_event_txcb_protocol_request_txcb_void_cookie_tLibxcbFuncsLibxcbLoadError_library// Needed to keep the library loadedLibxcbLibrary/// The functions pointers in `funcs` do not have lifetime,/// but they must not outlive the returned result.LIBXCB_LIBRARYget_libxcb/// Tries to dynamically load libxcb, returning an error on failure./// It is not required to call this function, as libxcb will be lazily loaded./// However, if a lazy load fails, a panic will be raised, missing the chance/// to (nicely) handle the error./// It is safe to call this function more than once from the same or different/// threads. Only the first call will try to load libxcb, subsequent calls will/// always return the same result.make_ffi_fn_defs//! The code in this module allows to call libxcb's C functions.//! At its heart, this module only contains an `extern "C"` block that defines the C functions so//! that they can be called from Rust.//! However, this module also contains the implementation of the `dl-libxcb` features. When this//! future is enabled, we do not link against libxcb, but instead use `libloading` to load//! `libxcb.so` at runtime. Most of the code is actually responsible for this later feature.// As defined in xcb_windefs.hshould_drop// libxcb is fully thread-safe (well, except for xcb_disconnect()), so the following is// actually fine and safe:pad0full_sequenceglobal_idxcb_extension_tisvoidEXT_NOTSUPPORTEDMEM_INSUFFICIENTREQ_LEN_EXCEEDPARSE_ERRINVALID_SCREENFDPASSING_FAILEDconnection_errorsREPLY_FDS//pub(crate) const DISCARD_REPLY: c_int = 4;send_request_flags//! The low-level foreign function interface to interact with libxcb.//! This module contains some `#[repr(C)]` type definitions that match libxcb's definitions. The//! actual functions are defined in the `ffi` submodule. There is also a `test` submodule that//! contains a mock of the interface that is used for unit tests.ConnectionMockxcb_flush// From xcb.hxcb_get_maximum_request_lengthxcb_prefetch_maximum_request_lengthxcb_wait_for_eventxcb_poll_for_eventxcb_request_checkxcb_discard_reply64xcb_get_setupxcb_get_file_descriptorxcb_connection_has_errorxcb_disconnectxcb_connectxcb_generate_idxcb_send_request64// From xcbext.hxcb_send_request_with_fds64xcb_wait_for_reply64xcb_poll_for_reply64//! A mock of libxcb that is used by the unit tests in [`x11rb::xcb_ffi`].impl_deref_request_connection_innerimpl_deref_connection_innerimpl_deref_connection//! Implement RequestConnection for wrappers around other connection types, e.g.//! `Box<Connection>`.replace_connection/// Move this cookie to refer to another connection instance./// This function may only be used if both connections are "basically the same". For example, a/// Cookie for a connection `C` can be moved to `Rc<C>` since that still refers to the same/// underlying connection.DisplayParsingErrorOpenLibError/// Could not open the library. The `OsString` is the library/// file name and the string is the reason.GetSymbolError/// Could not get a symbol from the library. The byte vector is the/// symbol name and the string is the reason./// An error occurred  while dynamically loading libxcb./// Before uploading, the image is translated into the server's native format via/// [`Image::native`]. This may convert the image to another format, which can be slow. If you/// intend to upload the same image multiple times, it is likely more efficient to call/// [`Image::native`] once initially so that the conversion is not repeated on each upload.put_impl/// Get a version of this image with `'static` lifetime./// If the image was constructed from a `Cow::Borrowed`, this clones the contained data./// Otherwise, this simply returns `self`.test_into_owned_keeps_owned_data// Contains unreachable_code and "?" generates an #[allow] for this// #[derive] generates an #[allow] for this; not part of "unused"//! By default, only the core X11 protocol and X11 extensions that are needed internally are//! enabled. These are the `bigreq`, `ge` and `xc_misc` extensions. Further extensions need to be//! explicitly enabled via their feature flag://!   [`xcb_ffi::XCBConnection`] and some support code for it are unavailable.//! * `cursor`: Enable the code in [cursor] for loading cursor files.//! * `resource_manager`: Enable the code in [resource_manager] for loading and querying the//! * `image`: Enable the code in [image] for working with pixel image data.//!   This feature adds the [`xcb_ffi::load_libxcb`] function, that allows to load//! * `extra-traits`: Enable some additional traits for generated code, like `Eq`, `Ord` and//!   `Hash`. This is not needed by default and adds a large amount of code that bloats codegen//!   time//! * `request-parsing`: Add the ability to parse X11 requests. Not normally needed.//! * `extra-traits`: Implement extra traits for X11 types. This improves the output of the `Debug`//!   impl and adds `PartialEq`, `Eq`, `PartialOrd`, `Ord`, and `Hash` where possible.test_wm_class_missingtest_wm_normal_hints_missingtest_wm_hints_missing/// Enable the BIG-REQUESTS extension./// This enables the BIG-REQUESTS extension, which allows for requests larger than/// 262140 bytes in length.  When enabled, if the 16-bit length field is zero, it/// is immediately followed by a 32-bit length field specifying the length of the/// request in 4-byte units./// Negotiate the version of Composite./// This negotiates the version of the Composite extension.  It must be precede all/// other requests using Composite.  Failure to do so will cause a BadRequest error./// * `client_major_version` - The major version supported by the client./// * `client_minor_version` - The minor version supported by the client./// Redirect the hierarchy starting at "window" to off-screen storage../// The hierarchy starting at 'window' is directed to off-screen/// storage.  When all clients enabling redirection terminate,/// the redirection will automatically be disabled./// The root window may not be redirected. Doing so results in a Match/// * `window` - The root of the hierarchy to redirect to off-screen storage./// * `update` - Whether contents are automatically mirrored to the parent window.  If one client/// already specifies an update type of Manual, any attempt by another to specify a/// mode of Manual so will result in an Access error./// Redirect all current and future children of ‘window’./// Hierarchies starting at all current and future children of window/// will be redirected as in RedirectWindow. If update is Manual,/// then painting of the window background during window manipulation/// and ClearArea requests is inhibited./// Terminate redirection of the specified window../// Redirection of the specified window will be terminated.  This cannot be/// used if the window was redirected with RedirectSubwindows./// * `window` - The window to terminate redirection of.  Must be redirected by the/// current client, or a Value error results./// * `update` - The update type passed to RedirectWindows.  If this does not match the/// previously requested update type, a Value error results./// Terminate redirection of the specified window’s children./// Redirection of all children of window will be terminated./// * `window` - The window to terminate redirection of.  Must have previously been/// selected for sub-redirection by the current client, or a Value error/// * `update` - The update type passed to RedirectSubWindows.  If this does not match/// the previously requested update type, a Value error results./// Negotiate the version of the DAMAGE extension./// This negotiates the version of the DAMAGE extension.  It must precede any other/// request using the DAMAGE extension.  Failure to do so will cause a BadRequest/// error for those requests./// Creates a Damage object to monitor changes to a drawable../// This creates a Damage object to monitor changes to a drawable, and specifies/// the level of detail to be reported for changes./// We call changes made to pixel contents of windows and pixmaps 'damage'/// throughout this extension./// Damage accumulates as drawing occurs in the drawable.  Each drawing operation/// 'damages' one or more rectangular areas within the drawable.  The rectangles/// are guaranteed to include the set of pixels modified by each operation, but/// may include significantly more than just those pixels.  The desire is for/// the damage to strike a balance between the number of rectangles reported and/// the extraneous area included.  A reasonable goal is for each primitive/// object drawn (line, string, rectangle) to be represented as a single/// rectangle and for the damage area of the operation to be the union of these/// rectangles./// The DAMAGE extension allows applications to either receive the raw/// rectangles as a stream of events, or to have them partially processed within/// the X server to reduce the amount of data transmitted as well as reduce the/// processing latency once the repaint operation has started./// The Damage object holds any accumulated damage region and reflects the/// relationship between the drawable selected for damage notification and the/// drawable for which damage is tracked./// * `damage` - The ID with which you will refer to the new Damage object, created by/// * `drawable` - The ID of the drawable to be monitored./// * `level` - The level of detail to be provided in Damage events./// Destroys a previously created Damage object../// This destroys a Damage object and requests the X server stop reporting/// the changes it was tracking./// * `damage` - The ID you provided to `xcb_create_damage`./// Remove regions from a previously created Damage object../// This updates the regions of damage recorded in a a Damage object./// See <https://www.x.org/releases/current/doc/damageproto/damageproto.txt>/// Add a region to a previously created Damage object..dpms_select_inputimport_syncobjSyncobjfree_syncobjdri3_import_syncobjdri3_free_syncobjpixmap_syncedpresent_pixmap_synced/// Query the version of the MIT-SHM extension../// This is used to determine the version of the MIT-SHM extension supported by the/// X server.  Clients MUST NOT make other requests in this extension until a reply/// to this requests indicates the X server supports them./// Attach a System V shared memory segment../// Attach a System V shared memory segment to the server.  This will fail unless/// the server has permission to map the segment.  The client may destroy the segment/// as soon as it receives a XCB_SHM_COMPLETION event with the shmseg value in this/// request and with the appropriate serial number./// * `shmseg` - A shared memory segment ID created with xcb_generate_id()./// * `shmid` - The System V shared memory segment the server should map./// * `read_only` - True if the segment shall be mapped read only by the X11 server, otherwise false./// Destroys the specified shared memory segment../// Destroys the specified shared memory segment.  This will never fail unless the/// segment number is incorrect./// * `shmseg` - The segment to be destroyed./// Copy data from the shared memory to the specified drawable../// Copy data from the shared memory to the specified drawable.  The amount of bytes/// written to the destination image is always equal to the number of bytes read/// from the shared memory segment./// * `drawable` - The drawable to draw to./// * `total_width` - The total width of the source image./// * `total_height` - The total height of the source image./// * `src_x` - The source X coordinate of the sub-image to copy./// * `src_y` - The source Y coordinate of the sub-image to copy./// * `src_width` - The width, in source image coordinates, of the data to copy from the source./// The X server will use this to determine the amount of data to copy.  The amount/// of the destination image that is overwritten is determined automatically./// * `src_height` - The height, in source image coordinates, of the data to copy from the source./// * `dst_x` - The X coordinate on the destination drawable to copy to./// * `dst_y` - The Y coordinate on the destination drawable to copy to./// * `depth` - The depth to use./// * `format` - The format of the image being drawn.  If it is XYBitmap, depth must be 1, or a/// "BadMatch" error results.  The foreground pixel in the GC determines the source/// for the one bits in the image, and the background pixel determines the source/// for the zero bits.  For XYPixmap and ZPixmap, the depth must match the depth of/// the drawable, or a "BadMatch" error results./// * `send_event` - True if the server should send an XCB_SHM_COMPLETION event when the blit/// * `offset` - The offset that the source image starts at./// Copies data from the specified drawable to the shared memory segment../// Copy data from the specified drawable to the shared memory segment.  The amount/// of bytes written to the destination image is always equal to the number of bytes/// read from the shared memory segment./// * `drawable` - The drawable to copy the image out of./// * `x` - The X coordinate in the drawable to begin copying at./// * `y` - The Y coordinate in the drawable to begin copying at./// * `width` - The width of the image to copy./// * `height` - The height of the image to copy./// * `plane_mask` - A mask that determines which planes are used./// * `format` - The format to use for the copy (???)./// * `shmseg` - The destination shared memory segment./// * `offset` - The offset in the shared memory segment to copy data to./// Create a pixmap backed by shared memory../// Create a pixmap backed by shared memory.  Writes to the shared memory will be/// reflected in the contents of the pixmap, and writes to the pixmap will be/// reflected in the contents of the shared memory./// * `pid` - A pixmap ID created with xcb_generate_id()./// * `drawable` - The drawable to create the pixmap in./// * `width` - The width of the pixmap to create.  Must be nonzero, or a Value error results./// * `height` - The height of the pixmap to create.  Must be nonzero, or a Value error results./// * `depth` - The depth of the pixmap to create.  Must be nonzero, or a Value error results./// * `shmseg` - The shared memory segment to use to create the pixmap./// * `offset` - The offset in the segment to create the pixmap at./// Create a shared memory segment./// Create a shared memory segment.  The file descriptor will be mapped at offset/// zero, and the size will be obtained using fstat().  A zero size will result in a/// Value error./// * `shm_fd` - The file descriptor the server should mmap()./// Asks the server to allocate a shared memory segment../// Asks the server to allocate a shared memory segment.  The server’s reply will/// include a file descriptor for the client to pass to mmap()./// * `size` - The size of the segment to create./// * `read_only` - True if the server should map the segment read-only; otherwise false./// Sets the disconnect mode for the client../// * `disconnect_mode` - The new disconnect mode.PeerAddr/// The address of a peer in a format suitable for xauth./// These values can be directly given to [`x11rb_protocol::xauth::get_auth`]./// This returns the peer address in a format suitable for [`x11rb_protocol::xauth::get_auth`].// Get xauth information representing a local connection// Get xauth information representing a TCP connection to the given address_compile_test_arc_in_wrapper_compile_test_rc_in_wrapper/// Wrapper around a slice that was allocated in C code./// `CSlice` is only available when the `allow-unsafe-code` feature is enabled.// `CSlice` is `Send` and `Sync` because, once created, it is// completely immutable (it does not have interior mutability),// so it can be safely accessed from different threads simultaneously./// Constructs a new `CSlice` from the given parts. `libc::free` will be called on the given/// pointer when the slice is dropped./// The same rules as for `std::slice::from_raw_parts` apply. Additionally, the given pointer/// must be safe to free with `libc::free`./// Convert `self` into a raw part./// Ownership of the returned pointer is given to the caller. Specifically, `libc::free` will/// not be called on it by `CSlice`.unsafe_code///     // please treat the actual members as private///     # phantom: std::marker::PhantomData<&'c C>,///     # _NET_WM_NAME: Cookie<'c, C, InternAtomReply>,///     # _NET_WM_ICON: Cookie<'c, C, InternAtomReply>,///     # ATOM_WITH_SPACES: Cookie<'c, C, InternAtomReply>,///     # WHATEVER: Cookie<'c, C, InternAtomReply>,///         // This is just an example for readability; the actual code is more efficient.///         // This is just an example for readability; the actual code is different.// 64-bit operations.SetupAuthenticateSetupFailedSetupRequest// input bufferadvanced// position in the buffer that has been filled/// The connection handshake used to connect to the X11 server./// In order to connect to the X11 server, the client must send the/// server a request containing important pieces of client data. In/// response, the server sends the client a response containing one/// of the following:/// - An error indicating that the setup request is malformed, or the///   setup otherwise failed./// - A request for further authorization data./// - The [`Setup`](protocol/xproto/struct.Setup.html) for the connection,///   which contains server-specific information and is necessary for///   the client's ability to communicate with the server./// This handshake contains four relevant methods:/// - `new`, which creates the handshake and also returns the setup request///   to send to the server./// - `buffer`, which returns an `&mut [u8]` containing the buffer///   which is intended to hold the bytes received from the server./// - `advance`, which takes a `usize` indicating how many bytes///   were received from the server and advances the buffer./// - `into_setup`, which consumes this `Connect` and returns the///   full `Setup`./// Let's say you have an object `stream` which implements `Read`/// and `Write`. In addition, you already have the connection family,/// the address of the connection, and the display. You can use the `Connect`/// to establish an X11 connection like so:/// # use x11rb_protocol::connect::Connect;/// # use x11rb_protocol::xauth::Family;/// # use std::{error::Error, io::prelude::*};/// # impl Read for Stream {/// #    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {/// #       Ok(buf.len())/// # impl Write for Stream {/// #    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {/// #    fn flush(&mut self) -> std::io::Result<()> {/// #       Ok(())/// # let mut stream = Stream;/// let family = Family::INTERNET;/// let address = b"foobar";/// let display = 0;/// let (mut connect, setup_request) = Connect::new(family, address, display)?;/// // send the setup request to the server/// stream.write_all(&setup_request)?;/// // receive the setup response from the server///     let adv = stream.read(connect.buffer())?;///     // if we've completed the setup, break out of the loop///     if connect.advance(adv) {/// // get the setup used for our connection/// let setup = connect.into_setup()?;/// If, instead, `stream` implements `AsyncRead` and `AsyncWrite`, the code/// would be identical, but with `.await` after `read` and `write_all`.// X11 interprets capital B as big endian, and lowercase l as little endian.PROTOCOL_MAJOR_VERSION// protocol versionPROTOCOL_MINOR_VERSION/// The initial state of a `Connect`.with_authorization/// Create a new `Connect` from the given authorization data./// This uses the provided protocol name and data to establish the connection,/// rather than the default protocol name and data found in `Xauthority`./// let (connect, setup_request) = Connect::with_authorization(///     b"MIT-MAGIC-COOKIE-1".to_vec(),///     b"my_secret_password".to_vec(),/// Create a new `Connect` from the information necessary to connect to the X11 server./// This returns the connection handshake object as well as the setup request to send to the server./// Returns the buffer that needs to be filled with incoming data from the server./// After filling this buffer (using a method like `Read::read`), call [`Self::advance`] with/// the number of bytes read to indicate that the buffer has been filled./// Advance the internal buffer, given the number of bytes that have been read.into_setup/// Returns the setup provided by the server./// - If this method is called before the server returns all of the required data,///   it returns `ConnectError::NotEnoughData`./// - If the server fails to establish the X11 connection, the `ConnectError::SetupFailed`///   variant is returned./// - If the server failed to authenticate the user, the `ConnectError::SetupAuthenticate`///   error is returned./// - If the server failed to parse any of the above responses, the///   `ConnectError::ParseError` error is returned.test_setuptry_receive_bytestest_connect_receive_setuptest_connect_receive_setup_authenticatetest_connect_receive_setup_failed//! Contains utilities for connection to the X11 server./// The raw bytes of an X11 event and its sequence number.NoReply/// The request does not have a reply.ReplyWithoutFDs/// The request has a reply and that reply does *not* contain any file descriptors.ReplyWithFDs/// The request has a reply and that reply *does* contain file descriptor(s)./// Information about the reply to an X11 request.TryAgain/// It is not clear yet what the result will be; try again later./// There will be no reply; polling is done./// Here is the result of the polling; polling is done./// Information about the result of polling for a reply packet.seqnodiscard_modehas_fdsSentRequestlast_sequence_written// The sequence number of the last request that was writtensent_requests// Sorted(!) list with information on requests that were written, but no answer received yet.next_reply_expected// The sequence number of the next reply that is expected to come inlast_sequence_read// The sequence number of the last reply/error/event that was read// Events that were read, but not yet returned to the API userpending_replies// Replies that were read, but not yet returned to the API userpending_fds// FDs that were read, but not yet assigned to any reply/// A pure-rust, sans-I/O implementation of the X11 protocol./// This object is designed to be used in combination with an I/O backend, in/// order to keep state for the X11 protocol./// Create a new `Connection`./// It is assumed that the connection was just established. This means that the next request/// that is sent will have sequence number one./// Send a request to the X11 server./// When this returns `None`, a sync with the server is necessary. Afterwards, the caller/// should try again./// Ignore the reply for a request that was previously sent.extract_sequence_number// Extract the sequence number from a packet read from the X11 server. The packet must be a// reply, an event, or an error. All of these have a u16 sequence number in bytes 2 and 3...// except for KeymapNotify events.enqueue_fds/// Add FDs that were received to the internal state./// This must be called before the corresponding packets are enqueued.enqueue_packet/// An X11 packet was received from the connection and is now enqueued into our state./// Any FDs that were received must already be enqueued before this can be called.poll_for_reply_or_error/// Check if the server already sent an answer to the request with the given sequence number./// This function is meant to be used for requests that have a reply. Such requests always/// cause a reply or an error to be sent.prepare_check_for_reply_or_error/// Prepare for calling `poll_check_for_reply_or_error()`./// To check if a request with a reply caused an error, one simply has to wait for the error or/// reply to be received. However, this approach does not work for requests without errors:/// Success is indicated by the absence of an error./// Thus, this function returns true if a sync is necessary to ensure that a reply with a/// higher sequence number will be received. Since the X11 server handles requests in-order,/// if the reply to a later request is received, this means that the earlier request did notpoll_check_for_reply_or_error/// Check if the request with the given sequence number was already handled by the server./// Before calling this function, you must call `prepare_check_for_reply_or_error()` with the/// sequence number./// This function can be used for requests with and without a reply./// Find the reply for the request with the given sequence number./// If the request caused an error, that error will be handled as an event. This means that a/// latter call to `poll_for_event()` will return it./// Get a pending event.insert_sync_no_replyinsert_no_sync_with_replyinsert_no_sync_when_already_syncingget_sync_replies//! Helper types for implementing an X11 client./// Not enough data was provided.ConversionFailed/// A value did not fit./// This error can e.g. happen when a value that was received from the X11 server does not fit/// into an `usize`./// The value of an expression could not be computed./// As an example, the length of the data in `xproto`'s `GetPropertyReply` is described by/// `value_len * (format / 8)`. The multiplication could cause an overflow, which would be/// represented by this error./// A value was outside of its valid range./// There are two kinds of situations where this error can happen:/// 1. The protocol was violated and a nonsensical value was found./// 2. The user of the API called the wrong parsing function./// Examples for the first kind of error:/// - One of a set of values should be present (a `<switch>` in xcb-proto-speak), but none of///   the `<cases>` matched. This can e.g. happen when parsing///   [`crate::protocol::xinput::InputInfo`]./// - Parsing a request with a length field that is too small for the request header to fit./// Examples for the second kind of error:/// - Parsing an X11 error with `response_type != 0`./// - Parsing an X11 reply with `response_type != 1`./// - Parsing an X11 request with the wrong value for its `minor_opcode`.MissingFileDescriptors/// Some file descriptors were expected, but not enough were received./// An error occurred while parsing some data/// Error during parsing of display string./// This is `XCB_CONN_CLOSED_PARSE_ERR`.InvalidScreen/// Server does not have a screen matching the display./// This is `XCB_CONN_CLOSED_INVALID_SCREEN`.ZeroIdMask/// Invalid ID mask provided by the server./// The value of `resource_id_mask` in the `Setup` provided by the server was zero./// The server rejected the connection with a `SetupAuthenticate` message./// The server rejected the connection with a `SetupFailed` message./// The number of bytes that were expected./// The number of bytes that were received./// The client did not receive enough data from the server to complete/// the handshake./// An error that occurred while connecting to an X11 server/// An allocator for X11 IDs./// This struct handles the client-side generation of X11 IDs. The ID allocation is based on a/// range of IDs that the server assigned us. This range is described by a base and a mask. From/// the X11 protocol reference manual:/// > The resource-id-mask contains a single contiguous set of bits (at least 18). The client/// > allocates resource IDs [..] by choosing a value with only some subset of these bits set and/// > ORing it with resource-id-base./// Create a new instance of an ID allocator./// The arguments should be the `resource_id_base` and `resource_id_mask` values that the X11/// server sent in a `Setup` response.update_xid_range/// Update the available range of IDs based on a GetXIDRangeReply/// Generate the next ID.exhaustivenew_rangeinvalid_new_arginvalid_update_arggenerate_get_xid_range_reply//! A mechanism for allocating XIDs.// serde's Deserialize/Serialize impls add allows for this// Not everything in x11rb_protocol::protocol has doc comments// std crate imports/// Number type used for referring to things that were sent to the server in responses from the/// Each request sent to the X11 server is implicitly assigned a monotonically increasing sequence/// number. Replies, events, and errors contain the sequence number of the last request that the/// server received. This allows to map replies to their requests and to figure out which request/// caused an error./// The raw bytes of an event and its sequence number.DiscardReply/// Only discard the actual reply. Errors go to the main loop.DiscardReplyAndError/// Ignore any kind of response that this request generates./// Variants describing which responses to a request should be discarded.//! This crate provides a representation of the X11 protocol in Rust. With this protocol, raw X11//! bytes can be parsed into a structured representation or raw bytes can be produces.//! This protocol does not do any I/O. If you need an X11 client library, look at//! <https://docs.rs/x11rb/latest/x11rb/>.MINIMAL_PACKET_LENGTH/// Minimal length of an X11 packet.pending_packet/// A partially-read packet.already_read/// The point at which the packet is already read./// A wrapper around a buffer used to read X11 packets./// Create a new, empty `PacketReader`./// # use x11rb_protocol::packet_reader::PacketReader;/// let reader = PacketReader::new();/// Get the buffer that the reader should fill with data./// # use x11rb_protocol::protocol::xproto::{GetInputFocusReply, InputFocus, Window};/// let mut reader = PacketReader::new();/// let buffer: [u8; 32] = read_in_buffer();/// reader.buffer().copy_from_slice(&buffer);/// # fn read_in_buffer() -> [u8; 32] { [0; 32] }/// The remaining capacity that needs to be filled./// Advance this buffer by the given amount./// This will return the packet that was read, if enough bytes were read in order/// to form a complete packet.extra_length/// Compute the length of the data we need to read, beyond the `MINIMAL_PACKET_LENGTH`.test_packetsmake_reply_with_lengthtest_many_fixed_size_packetstest_many_variable_size_packetstest_many_size_packets_mixedtest_debug_fixed_size_packettest_debug_variable_size_packet//! Collects X11 data into "packets" to be parsed by a display.ParsedDisplay/// Connect to this hostname and port over TCP./// Connect to this Unix socket./// First, the given path should be attempted in the abstract namespace. Only if that fails,/// then the named socket with the given name should be tried./// A possible address for an X11 server.connect_addresses/// Get an iterator over all of the addresses we should target with a/// `ParsedDisplay`.// make sure iterator properties are cleanbasic_testtry_over_hostnametry_over_unix_hostname//! Provides the `ConnectInstruction` structure, which allows for a `ParsedDisplay`//! to be transformed into a server connection.connect_instruction/// The hostname of the computer we nned to connect to./// This is an empty string if we are connecting to the/// local host./// The protocol we are communicating over./// This is `None` if the protocol may be determined/// The index of the display we are connecting to./// The index of the screen that we are using as the/// default screen./// A parsed X11 display string./// Get an iterator over `ConnectAddress`es from this parsed display for connecting/// Parse an X11 display string./// If `dpy_name` is `None`, the display is parsed from the environment variable `DISPLAY`.parse_display_impldo_parse_displaytest_parsing// The tests modify environment variables. This is process-global. Thus, the tests in this// module cannot be run concurrently. We achieve this by having only a single test functions// that calls all other functions.test_missing_inputown_good_casesxcb_good_cases// Based on libxcb's test suite; (C) 2001-2006 Bart Massey, Jamey Sharp, and Josh Triplettxcb_bad_cases//! Utilities for parsing X11 display strings.TryIntoUSizepretty_print_bitmaskpretty_print_enumX11_EXTENSION_NAME/// The X11 name of the extension for QueryExtensionX11_XML_VERSION/// The version number of this extension that this client library supports./// This constant contains the version number of this extension that is supported/// by this build of x11rb. For most things, it does not make sense to use this/// information. If you need to send a `QueryVersion`, it is recommended to instead/// send the maximum version of the extension that you need.ENABLE_REQUEST/// Opcode for the Enable requestEnableRequest/// Serialize this request into bytes for the provided connectiontry_parse_request/// Parse this request given its header, its body, and any fds that go along with itEXTENSION_NAMEmaximum_request_length// The code generator is simpler if it can always use conversionsAUTOMATICMANUALQUERY_VERSION_REQUEST/// Opcode for the QueryVersion requestclient_major_versionclient_minor_versionQueryVersionRequestREDIRECT_WINDOW_REQUEST/// Opcode for the RedirectWindow requestRedirectWindowRequestREDIRECT_SUBWINDOWS_REQUEST/// Opcode for the RedirectSubwindows requestRedirectSubwindowsRequestUNREDIRECT_WINDOW_REQUEST/// Opcode for the UnredirectWindow requestUnredirectWindowRequestUNREDIRECT_SUBWINDOWS_REQUEST/// Opcode for the UnredirectSubwindows requestUnredirectSubwindowsRequestCREATE_REGION_FROM_BORDER_CLIP_REQUEST/// Opcode for the CreateRegionFromBorderClip requestCreateRegionFromBorderClipRequestNAME_WINDOW_PIXMAP_REQUEST/// Opcode for the NameWindowPixmap requestNameWindowPixmapRequestGET_OVERLAY_WINDOW_REQUEST/// Opcode for the GetOverlayWindow requestGetOverlayWindowRequestoverlay_winRELEASE_OVERLAY_WINDOW_REQUEST/// Opcode for the ReleaseOverlayWindow requestReleaseOverlayWindowRequestRAW_RECTANGLESDELTA_RECTANGLESBOUNDING_BOXNON_EMPTYBAD_DAMAGE_ERROR/// Opcode for the BadDamage errorCREATE_REQUEST/// Opcode for the Create requestCreateRequestDESTROY_REQUEST/// Opcode for the Destroy requestDestroyRequestSUBTRACT_REQUEST/// Opcode for the Subtract requestrepairSubtractRequestADD_REQUEST/// Opcode for the Add requestAddRequestNOTIFY_EVENT/// Opcode for the Notify eventNotifyEventSwapAction/// Specifies what to do with the front buffer after it is swapped with the back buffer./// * `Undefined` - Discard the buffer. The buffer may be reallocated and end up with random VRAM content./// * `Background` - Erase with window background./// * `Untouched` - Leave untouched./// * `Copied` - Copy the newly displayed front buffer.BACKGROUNDUNTOUCHEDCOPIEDswap_actionBufferAttributesVisualInfoVisualInfos/// Get the value of the `n_infos` field./// The `n_infos` field is used as the length field of the `infos` field./// This function computes the field's value again based on the length of the list./// Panics if the value cannot be represented in the target type. This/// cannot happen with values of the struct received from the X11 server.BAD_BUFFER_ERROR/// Opcode for the BadBuffer errorALLOCATE_BACK_BUFFER_REQUEST/// Opcode for the AllocateBackBuffer requestAllocateBackBufferRequestDEALLOCATE_BACK_BUFFER_REQUEST/// Opcode for the DeallocateBackBuffer requestDeallocateBackBufferRequestSWAP_BUFFERS_REQUEST/// Opcode for the SwapBuffers requestSwapBuffersRequest/// Clone all borrowed data in this SwapBuffersRequest.BEGIN_IDIOM_REQUEST/// Opcode for the BeginIdiom requestBeginIdiomRequestEND_IDIOM_REQUEST/// Opcode for the EndIdiom requestEndIdiomRequestGET_VISUAL_INFO_REQUEST/// Opcode for the GetVisualInfo requestdrawablesGetVisualInfoRequest/// Clone all borrowed data in this GetVisualInfoRequest.n_supported_visuals/// Get the value of the `n_supported_visuals` field./// The `n_supported_visuals` field is used as the length field of the `supported_visuals` field.GET_BACK_BUFFER_ATTRIBUTES_REQUEST/// Opcode for the GetBackBufferAttributes requestGetBackBufferAttributesRequestGET_VERSION_REQUEST/// Opcode for the GetVersion requestGetVersionRequestserver_major_versionserver_minor_versionCAPABLE_REQUEST/// Opcode for the Capable requestCapableRequestGET_TIMEOUTS_REQUEST/// Opcode for the GetTimeouts requestGetTimeoutsRequeststandby_timeoutsuspend_timeoutoff_timeoutSET_TIMEOUTS_REQUEST/// Opcode for the SetTimeouts requestSetTimeoutsRequestDISABLE_REQUEST/// Opcode for the Disable requestDisableRequestSTANDBYFORCE_LEVEL_REQUEST/// Opcode for the ForceLevel requestpower_levelForceLevelRequestINFO_REQUEST/// Opcode for the Info requestInfoRequestBUFFER_FRONT_LEFTBUFFER_BACK_LEFTBUFFER_FRONT_RIGHTBUFFER_BACK_RIGHTBUFFER_DEPTHBUFFER_STENCILBUFFER_ACCUMBUFFER_FAKE_FRONT_LEFTBUFFER_FAKE_FRONT_RIGHTBUFFER_DEPTH_STENCILBUFFER_HIZVDPAUEXCHANGE_COMPLETEBLIT_COMPLETEFLIP_COMPLETEDRI2BufferCONNECT_REQUEST/// Opcode for the Connect requestdriver_typeConnectRequestdriver_namealignment_paddriver_name_length/// Get the value of the `driver_name_length` field./// The `driver_name_length` field is used as the length field of the `driver_name` field.device_name_length/// Get the value of the `device_name_length` field./// The `device_name_length` field is used as the length field of the `device_name` field.AUTHENTICATE_REQUEST/// Opcode for the Authenticate requestAuthenticateRequestCREATE_DRAWABLE_REQUEST/// Opcode for the CreateDrawable requestCreateDrawableRequestDESTROY_DRAWABLE_REQUEST/// Opcode for the DestroyDrawable requestDestroyDrawableRequestGET_BUFFERS_REQUEST/// Opcode for the GetBuffers requestattachmentsGetBuffersRequest/// Clone all borrowed data in this GetBuffersRequest./// Get the value of the `count` field./// The `count` field is used as the length field of the `buffers` field.COPY_REGION_REQUEST/// Opcode for the CopyRegion requestCopyRegionRequestGET_BUFFERS_WITH_FORMAT_REQUEST/// Opcode for the GetBuffersWithFormat requestGetBuffersWithFormatRequest/// Clone all borrowed data in this GetBuffersWithFormatRequest.target_msc_hitarget_msc_lodivisor_hidivisor_loremainder_hiremainder_loswap_hiswap_loGET_MSC_REQUEST/// Opcode for the GetMSC requestGetMSCRequestust_hiust_lomsc_himsc_losbc_hisbc_loWAIT_MSC_REQUEST/// Opcode for the WaitMSC requestWaitMSCRequestWAIT_SBC_REQUEST/// Opcode for the WaitSBC requesttarget_sbc_hitarget_sbc_loWaitSBCRequestSWAP_INTERVAL_REQUEST/// Opcode for the SwapInterval requestSwapIntervalRequestGET_PARAM_REQUEST/// Opcode for the GetParam requestGetParamRequestis_param_recognizedvalue_hivalue_loBUFFER_SWAP_COMPLETE_EVENT/// Opcode for the BufferSwapComplete eventsbcBufferSwapCompleteEventINVALIDATE_BUFFERS_EVENT/// Opcode for the InvalidateBuffers eventInvalidateBuffersEventOPEN_REQUEST/// Opcode for the Open requestOpenRequestdevice_fdtry_parse_fdPIXMAP_FROM_BUFFER_REQUEST/// Opcode for the PixmapFromBuffer requestpixmap_fdPixmapFromBufferRequesttry_parse_request_fdBUFFER_FROM_PIXMAP_REQUEST/// Opcode for the BufferFromPixmap requestBufferFromPixmapRequestFENCE_FROM_FD_REQUEST/// Opcode for the FenceFromFD requestinitially_triggeredfence_fdFenceFromFDRequestFD_FROM_FENCE_REQUEST/// Opcode for the FDFromFence requestFDFromFenceRequestGET_SUPPORTED_MODIFIERS_REQUEST/// Opcode for the GetSupportedModifiers requestGetSupportedModifiersRequestwindow_modifiersscreen_modifiersnum_window_modifiers/// Get the value of the `num_window_modifiers` field./// The `num_window_modifiers` field is used as the length field of the `window_modifiers` field.num_screen_modifiers/// Get the value of the `num_screen_modifiers` field./// The `num_screen_modifiers` field is used as the length field of the `screen_modifiers` field.PIXMAP_FROM_BUFFERS_REQUEST/// Opcode for the PixmapFromBuffers requeststride0offset0stride1offset1offset2stride3offset3PixmapFromBuffersRequestBUFFERS_FROM_PIXMAP_REQUEST/// Opcode for the BuffersFromPixmap requestBuffersFromPixmapRequest/// Get the value of the `nfd` field./// The `nfd` field is used as the length field of the `strides` field.SET_DRM_DEVICE_IN_USE_REQUEST/// Opcode for the SetDRMDeviceInUse requestdrm_majordrm_minorSetDRMDeviceInUseRequestBool32BAD_CONTEXT_ERROR/// Opcode for the BadContext errorBAD_CONTEXT_STATE_ERROR/// Opcode for the BadContextState errorBAD_DRAWABLE_ERROR/// Opcode for the BadDrawable errorBAD_PIXMAP_ERROR/// Opcode for the BadPixmap errorBAD_CONTEXT_TAG_ERROR/// Opcode for the BadContextTag errorBAD_CURRENT_WINDOW_ERROR/// Opcode for the BadCurrentWindow errorBAD_RENDER_REQUEST_ERROR/// Opcode for the BadRenderRequest errorBAD_LARGE_REQUEST_ERROR/// Opcode for the BadLargeRequest errorUNSUPPORTED_PRIVATE_REQUEST_ERROR/// Opcode for the UnsupportedPrivateRequest errorBAD_FB_CONFIG_ERROR/// Opcode for the BadFBConfig errorBAD_PBUFFER_ERROR/// Opcode for the BadPbuffer errorBAD_CURRENT_DRAWABLE_ERROR/// Opcode for the BadCurrentDrawable errorBAD_WINDOW_ERROR/// Opcode for the BadWindow errorGLX_BAD_PROFILE_ARB_ERROR/// Opcode for the GLXBadProfileARB errorPBUFFER_CLOBBER_EVENT/// Opcode for the PbufferClobber eventdraw_typeb_maskaux_bufferPbufferClobberEventPBCETDAMAGEDSAVEDPBCDTPBUFFERRENDER_REQUEST/// Opcode for the Render requestcontext_tagRenderRequest/// Clone all borrowed data in this RenderRequest.RENDER_LARGE_REQUEST/// Opcode for the RenderLarge requestrequest_numrequest_totalRenderLargeRequest/// Clone all borrowed data in this RenderLargeRequest.CREATE_CONTEXT_REQUEST/// Opcode for the CreateContext requestshare_listCreateContextRequestDESTROY_CONTEXT_REQUEST/// Opcode for the DestroyContext requestDestroyContextRequestMAKE_CURRENT_REQUEST/// Opcode for the MakeCurrent requestold_context_tagMakeCurrentRequestIS_DIRECT_REQUEST/// Opcode for the IsDirect requestIsDirectRequestWAIT_GL_REQUEST/// Opcode for the WaitGL requestWaitGLRequestWAIT_X_REQUEST/// Opcode for the WaitX requestWaitXRequestCOPY_CONTEXT_REQUEST/// Opcode for the CopyContext requestsrc_context_tagCopyContextRequestGL_CURRENT_BITGL_POINT_BITGL_LINE_BITGL_POLYGON_BITGL_POLYGON_STIPPLE_BITGL_PIXEL_MODE_BITGL_LIGHTING_BITGL_FOG_BITGL_DEPTH_BUFFER_BITGL_ACCUM_BUFFER_BITGL_STENCIL_BUFFER_BITGL_VIEWPORT_BITGL_TRANSFORM_BITGL_ENABLE_BITGL_COLOR_BUFFER_BITGL_HINT_BITGL_EVAL_BITGL_LIST_BITGL_TEXTURE_BITGL_SCISSOR_BITGL_ALL_ATTRIB_BITSUSE_X_FONT_REQUEST/// Opcode for the UseXFont requestlist_baseUseXFontRequestCREATE_GLX_PIXMAP_REQUEST/// Opcode for the CreateGLXPixmap requestglx_pixmapCreateGLXPixmapRequestGET_VISUAL_CONFIGS_REQUEST/// Opcode for the GetVisualConfigs requestGetVisualConfigsRequestnum_visualsnum_propertiesproperty_list/// Get the value of the `length` field./// The `length` field is used as the length field of the `property_list` field.DESTROY_GLX_PIXMAP_REQUEST/// Opcode for the DestroyGLXPixmap requestDestroyGLXPixmapRequestVENDOR_PRIVATE_REQUEST/// Opcode for the VendorPrivate requestvendor_codeVendorPrivateRequest/// Clone all borrowed data in this VendorPrivateRequest.VENDOR_PRIVATE_WITH_REPLY_REQUEST/// Opcode for the VendorPrivateWithReply requestVendorPrivateWithReplyRequest/// Clone all borrowed data in this VendorPrivateWithReplyRequest./// The `length` field is used as the length field of the `data2` field.QUERY_EXTENSIONS_STRING_REQUEST/// Opcode for the QueryExtensionsString requestQueryExtensionsStringRequestQUERY_SERVER_STRING_REQUEST/// Opcode for the QueryServerString requestQueryServerStringRequest/// Get the value of the `str_len` field./// The `str_len` field is used as the length field of the `string` field.CLIENT_INFO_REQUEST/// Opcode for the ClientInfo requestClientInfoRequest/// Clone all borrowed data in this ClientInfoRequest.GET_FB_CONFIGS_REQUEST/// Opcode for the GetFBConfigs requestGetFBConfigsRequestnum_fb_configsCREATE_PIXMAP_REQUEST/// Opcode for the CreatePixmap requestfbconfigCreatePixmapRequest/// Clone all borrowed data in this CreatePixmapRequest.DESTROY_PIXMAP_REQUEST/// Opcode for the DestroyPixmap requestDestroyPixmapRequestCREATE_NEW_CONTEXT_REQUEST/// Opcode for the CreateNewContext requestrender_typeCreateNewContextRequestQUERY_CONTEXT_REQUEST/// Opcode for the QueryContext requestQueryContextRequestnum_attribs/// Get the value of the `num_attribs` field./// The `num_attribs` field is used as the length field of the `attribs` field.MAKE_CONTEXT_CURRENT_REQUEST/// Opcode for the MakeContextCurrent requestread_drawableMakeContextCurrentRequestCREATE_PBUFFER_REQUEST/// Opcode for the CreatePbuffer requestpbufferCreatePbufferRequest/// Clone all borrowed data in this CreatePbufferRequest.DESTROY_PBUFFER_REQUEST/// Opcode for the DestroyPbuffer requestDestroyPbufferRequestGET_DRAWABLE_ATTRIBUTES_REQUEST/// Opcode for the GetDrawableAttributes requestGetDrawableAttributesRequestCHANGE_DRAWABLE_ATTRIBUTES_REQUEST/// Opcode for the ChangeDrawableAttributes requestChangeDrawableAttributesRequest/// Clone all borrowed data in this ChangeDrawableAttributesRequest.CREATE_WINDOW_REQUEST/// Opcode for the CreateWindow requestglx_windowCreateWindowRequest/// Clone all borrowed data in this CreateWindowRequest.DELETE_WINDOW_REQUEST/// Opcode for the DeleteWindow requestglxwindowDeleteWindowRequestSET_CLIENT_INFO_ARB_REQUEST/// Opcode for the SetClientInfoARB requestgl_versionsgl_extension_stringglx_extension_stringSetClientInfoARBRequest/// Clone all borrowed data in this SetClientInfoARBRequest.CREATE_CONTEXT_ATTRIBS_ARB_REQUEST/// Opcode for the CreateContextAttribsARB requestCreateContextAttribsARBRequest/// Clone all borrowed data in this CreateContextAttribsARBRequest.SET_CLIENT_INFO2_ARB_REQUEST/// Opcode for the SetClientInfo2ARB requestSetClientInfo2ARBRequest/// Clone all borrowed data in this SetClientInfo2ARBRequest.NEW_LIST_REQUEST/// Opcode for the NewList requestNewListRequestEND_LIST_REQUEST/// Opcode for the EndList requestEndListRequestDELETE_LISTS_REQUEST/// Opcode for the DeleteLists requestDeleteListsRequestGEN_LISTS_REQUEST/// Opcode for the GenLists requestGenListsRequestret_valFEEDBACK_BUFFER_REQUEST/// Opcode for the FeedbackBuffer requestFeedbackBufferRequestSELECT_BUFFER_REQUEST/// Opcode for the SelectBuffer requestSelectBufferRequestRENDER_MODE_REQUEST/// Opcode for the RenderMode requestRenderModeRequestnew_mode/// Get the value of the `n` field./// The `n` field is used as the length field of the `data` field.RMGL_RENDERGL_FEEDBACKGL_SELECTFINISH_REQUEST/// Opcode for the Finish requestFinishRequestPIXEL_STOREF_REQUEST/// Opcode for the PixelStoref requestpnamedatumPixelStorefRequestPIXEL_STOREI_REQUEST/// Opcode for the PixelStorei requestPixelStoreiRequestREAD_PIXELS_REQUEST/// Opcode for the ReadPixels requestlsb_firstReadPixelsRequest/// The `length` field is used as the length field of the `data` field.GET_BOOLEANV_REQUEST/// Opcode for the GetBooleanv requestGetBooleanvRequestGET_CLIP_PLANE_REQUEST/// Opcode for the GetClipPlane requestGetClipPlaneRequestGET_DOUBLEV_REQUEST/// Opcode for the GetDoublev requestGetDoublevRequestGET_ERROR_REQUEST/// Opcode for the GetError requestGetErrorRequestGET_FLOATV_REQUEST/// Opcode for the GetFloatv requestGetFloatvRequestGET_INTEGERV_REQUEST/// Opcode for the GetIntegerv requestGetIntegervRequestGET_LIGHTFV_REQUEST/// Opcode for the GetLightfv requestGetLightfvRequestGET_LIGHTIV_REQUEST/// Opcode for the GetLightiv requestGetLightivRequestGET_MAPDV_REQUEST/// Opcode for the GetMapdv requestGetMapdvRequestGET_MAPFV_REQUEST/// Opcode for the GetMapfv requestGetMapfvRequestGET_MAPIV_REQUEST/// Opcode for the GetMapiv requestGetMapivRequestGET_MATERIALFV_REQUEST/// Opcode for the GetMaterialfv requestGetMaterialfvRequestGET_MATERIALIV_REQUEST/// Opcode for the GetMaterialiv requestGetMaterialivRequestGET_PIXEL_MAPFV_REQUEST/// Opcode for the GetPixelMapfv requestGetPixelMapfvRequestGET_PIXEL_MAPUIV_REQUEST/// Opcode for the GetPixelMapuiv requestGetPixelMapuivRequestGET_PIXEL_MAPUSV_REQUEST/// Opcode for the GetPixelMapusv requestGetPixelMapusvRequestGET_POLYGON_STIPPLE_REQUEST/// Opcode for the GetPolygonStipple requestGetPolygonStippleRequestGET_STRING_REQUEST/// Opcode for the GetString requestGetStringRequest/// The `n` field is used as the length field of the `string` field.GET_TEX_ENVFV_REQUEST/// Opcode for the GetTexEnvfv requestGetTexEnvfvRequestGET_TEX_ENVIV_REQUEST/// Opcode for the GetTexEnviv requestGetTexEnvivRequestGET_TEX_GENDV_REQUEST/// Opcode for the GetTexGendv requestcoordGetTexGendvRequestGET_TEX_GENFV_REQUEST/// Opcode for the GetTexGenfv requestGetTexGenfvRequestGET_TEX_GENIV_REQUEST/// Opcode for the GetTexGeniv requestGetTexGenivRequestGET_TEX_IMAGE_REQUEST/// Opcode for the GetTexImage requestGetTexImageRequestGET_TEX_PARAMETERFV_REQUEST/// Opcode for the GetTexParameterfv requestGetTexParameterfvRequestGET_TEX_PARAMETERIV_REQUEST/// Opcode for the GetTexParameteriv requestGetTexParameterivRequestGET_TEX_LEVEL_PARAMETERFV_REQUEST/// Opcode for the GetTexLevelParameterfv requestGetTexLevelParameterfvRequestGET_TEX_LEVEL_PARAMETERIV_REQUEST/// Opcode for the GetTexLevelParameteriv requestGetTexLevelParameterivRequestIS_ENABLED_REQUEST/// Opcode for the IsEnabled requestIsEnabledRequestIS_LIST_REQUEST/// Opcode for the IsList requestIsListRequestFLUSH_REQUEST/// Opcode for the Flush requestFlushRequestARE_TEXTURES_RESIDENT_REQUEST/// Opcode for the AreTexturesResident requesttexturesAreTexturesResidentRequest/// Clone all borrowed data in this AreTexturesResidentRequest.DELETE_TEXTURES_REQUEST/// Opcode for the DeleteTextures requestDeleteTexturesRequest/// Clone all borrowed data in this DeleteTexturesRequest.GEN_TEXTURES_REQUEST/// Opcode for the GenTextures requestGenTexturesRequestIS_TEXTURE_REQUEST/// Opcode for the IsTexture requestIsTextureRequestGET_COLOR_TABLE_REQUEST/// Opcode for the GetColorTable requestGetColorTableRequestGET_COLOR_TABLE_PARAMETERFV_REQUEST/// Opcode for the GetColorTableParameterfv requestGetColorTableParameterfvRequestGET_COLOR_TABLE_PARAMETERIV_REQUEST/// Opcode for the GetColorTableParameteriv requestGetColorTableParameterivRequestGET_CONVOLUTION_FILTER_REQUEST/// Opcode for the GetConvolutionFilter requestGetConvolutionFilterRequestGET_CONVOLUTION_PARAMETERFV_REQUEST/// Opcode for the GetConvolutionParameterfv requestGetConvolutionParameterfvRequestGET_CONVOLUTION_PARAMETERIV_REQUEST/// Opcode for the GetConvolutionParameteriv requestGetConvolutionParameterivRequestGET_SEPARABLE_FILTER_REQUEST/// Opcode for the GetSeparableFilter requestGetSeparableFilterRequestrow_wcol_hrows_and_cols/// The `length` field is used as the length field of the `rows_and_cols` field.GET_HISTOGRAM_REQUEST/// Opcode for the GetHistogram requestGetHistogramRequestGET_HISTOGRAM_PARAMETERFV_REQUEST/// Opcode for the GetHistogramParameterfv requestGetHistogramParameterfvRequestGET_HISTOGRAM_PARAMETERIV_REQUEST/// Opcode for the GetHistogramParameteriv requestGetHistogramParameterivRequestGET_MINMAX_REQUEST/// Opcode for the GetMinmax requestGetMinmaxRequestGET_MINMAX_PARAMETERFV_REQUEST/// Opcode for the GetMinmaxParameterfv requestGetMinmaxParameterfvRequestGET_MINMAX_PARAMETERIV_REQUEST/// Opcode for the GetMinmaxParameteriv requestGetMinmaxParameterivRequestGET_COMPRESSED_TEX_IMAGE_ARB_REQUEST/// Opcode for the GetCompressedTexImageARB requestGetCompressedTexImageARBRequestDELETE_QUERIES_ARB_REQUEST/// Opcode for the DeleteQueriesARB requestDeleteQueriesARBRequest/// Clone all borrowed data in this DeleteQueriesARBRequest.GEN_QUERIES_ARB_REQUEST/// Opcode for the GenQueriesARB requestGenQueriesARBRequestIS_QUERY_ARB_REQUEST/// Opcode for the IsQueryARB requestIsQueryARBRequestGET_QUERYIV_ARB_REQUEST/// Opcode for the GetQueryivARB requestGetQueryivARBRequestGET_QUERY_OBJECTIV_ARB_REQUEST/// Opcode for the GetQueryObjectivARB requestGetQueryObjectivARBRequestGET_QUERY_OBJECTUIV_ARB_REQUEST/// Opcode for the GetQueryObjectuivARB requestGetQueryObjectuivARBRequestparse_replyparse_reply_fdsXproto/// A core protocol requestKnownExt/// A known request from a known extension. String is of the form "ExtName::RequestName".UnknownRequest/// A request which could not be identified. The first entry is the extension name (or none for xproto). Second is opcode./// A request from an extension that could not be identified/// Helper container for translating numeric request information to a stringget_request_name_internal/// Get information about a request based on its major and minor code./// The major and minor opcode are the first and second byte of a request./// Core requests do not have a minor opcode. For these, the minor opcode is ignored by this function./// This function returns the name of the extension to which the request belongs, if available, and information about the specific request.get_request_name/// Get the name of a request based on its major and minor code.ChangeWindowAttributesRequestChangeWindowAttributesGetWindowAttributesRequestGetWindowAttributesDestroyWindowRequestDestroySubwindowsRequestDestroySubwindowsChangeSaveSetRequestChangeSaveSetReparentWindowRequestReparentWindowMapWindowRequestMapWindowMapSubwindowsRequestMapSubwindowsUnmapWindowRequestUnmapWindowUnmapSubwindowsRequestUnmapSubwindowsConfigureWindowRequestConfigureWindowCirculateWindowRequestCirculateWindowGetGeometryRequestGetGeometryQueryTreeRequestQueryTreeInternAtomRequestInternAtomGetAtomNameRequestGetAtomNameChangePropertyRequestChangePropertyDeletePropertyRequestDeletePropertyGetPropertyRequestListPropertiesRequestListPropertiesSetSelectionOwnerRequestSetSelectionOwnerGetSelectionOwnerRequestGetSelectionOwnerConvertSelectionRequestConvertSelectionSendEventRequestSendEventGrabPointerRequestGrabPointerUngrabPointerRequestUngrabPointerGrabButtonRequestGrabButtonUngrabButtonRequestUngrabButtonChangeActivePointerGrabRequestChangeActivePointerGrabGrabKeyboardRequestUngrabKeyboardRequestUngrabKeyboardGrabKeyRequestGrabKeyUngrabKeyRequestUngrabKeyAllowEventsRequestAllowEventsGrabServerRequestUngrabServerRequestUngrabServerQueryPointerRequestQueryPointerGetMotionEventsRequestGetMotionEventsTranslateCoordinatesRequestTranslateCoordinatesWarpPointerRequestSetInputFocusRequestSetInputFocusGetInputFocusRequestGetInputFocusQueryKeymapRequestQueryKeymapOpenFontRequestOpenFontCloseFontRequestCloseFontQueryFontRequestQueryFontQueryTextExtentsRequestQueryTextExtentsListFontsRequestListFontsListFontsWithInfoRequestListFontsWithInfoSetFontPathRequestSetFontPathGetFontPathRequestGetFontPathCreatePixmapFreePixmapRequestFreePixmapCreateGCRequestCreateGCChangeGCRequestChangeGCCopyGCRequestCopyGCSetDashesRequestSetDashesSetClipRectanglesRequestSetClipRectanglesFreeGCRequestFreeGCClearAreaRequestClearAreaCopyAreaRequestCopyAreaCopyPlaneRequestCopyPlanePolyPointRequestPolyPointPolyLineRequestPolyLinePolySegmentRequestPolySegmentPolyRectangleRequestPolyRectanglePolyArcRequestPolyArcFillPolyRequestFillPolyPolyFillRectangleRequestPolyFillRectanglePolyFillArcRequestPolyFillArcPutImageRequestPutImageGetImageRequestGetImagePolyText8RequestPolyText8PolyText16RequestPolyText16ImageText8RequestImageText8ImageText16RequestImageText16CreateColormapRequestCreateColormapFreeColormapRequestFreeColormapCopyColormapAndFreeRequestCopyColormapAndFreeInstallColormapRequestInstallColormapUninstallColormapRequestUninstallColormapListInstalledColormapsRequestListInstalledColormapsAllocColorRequestAllocColorAllocNamedColorRequestAllocNamedColorAllocColorCellsRequestAllocColorCellsAllocColorPlanesRequestAllocColorPlanesFreeColorsRequestFreeColorsStoreColorsRequestStoreColorsStoreNamedColorRequestStoreNamedColorQueryColorsRequestQueryColorsLookupColorRequestLookupColorCreateCursorRequestCreateGlyphCursorRequestCreateGlyphCursorFreeCursorRequestFreeCursorRecolorCursorRequestRecolorCursorQueryBestSizeRequestQueryBestSizeQueryExtensionRequestQueryExtensionListExtensionsRequestListExtensionsChangeKeyboardMappingRequestChangeKeyboardMappingGetKeyboardMappingRequestGetKeyboardMappingChangeKeyboardControlRequestChangeKeyboardControlGetKeyboardControlRequestGetKeyboardControlBellRequestChangePointerControlRequestChangePointerControlGetPointerControlRequestGetPointerControlSetScreenSaverRequestSetScreenSaverGetScreenSaverRequestGetScreenSaverChangeHostsRequestChangeHostsListHostsRequestListHostsSetAccessControlRequestSetAccessControlSetCloseDownModeRequestSetCloseDownModeKillClientRequestKillClientRotatePropertiesRequestRotatePropertiesForceScreenSaverRequestForceScreenSaverSetPointerMappingRequestSetPointerMappingGetPointerMappingRequestGetPointerMappingSetModifierMappingRequestSetModifierMappingGetModifierMappingRequestGetModifierMappingNoOperationRequestNoOperationBigreqEnableCompositeQueryVersionCompositeRedirectWindowCompositeRedirectSubwindowsCompositeUnredirectWindowCompositeUnredirectSubwindowsCompositeCreateRegionFromBorderClipCompositeNameWindowPixmapCompositeGetOverlayWindowCompositeReleaseOverlayWindowDamageQueryVersionDamageCreateDamageDestroyDamageSubtractDamageAddDbeQueryVersionDbeAllocateBackBufferDbeDeallocateBackBufferDbeSwapBuffersDbeBeginIdiomDbeEndIdiomDbeGetVisualInfoDbeGetBackBufferAttributesDpmsGetVersionDpmsCapableDpmsGetTimeoutsDpmsSetTimeoutsDpmsEnableDpmsDisableDpmsForceLevelDpmsInfoDri2QueryVersionDri2ConnectDri2AuthenticateDri2CreateDrawableDri2DestroyDrawableDri2GetBuffersDri2CopyRegionDri2GetBuffersWithFormatDri2SwapBuffersDri2GetMSCDri2WaitMSCDri2WaitSBCDri2SwapIntervalDri2GetParamDri3QueryVersionDri3OpenDri3PixmapFromBufferDri3BufferFromPixmapDri3FenceFromFDDri3FDFromFenceDri3GetSupportedModifiersDri3PixmapFromBuffersDri3BuffersFromPixmapDri3SetDRMDeviceInUseGeQueryVersionGlxRenderGlxRenderLargeGlxCreateContextGlxDestroyContextGlxMakeCurrentGlxIsDirectGlxQueryVersionGlxWaitGLGlxWaitXGlxCopyContextGlxSwapBuffersGlxUseXFontGlxCreateGLXPixmapGlxGetVisualConfigsGlxDestroyGLXPixmapGlxVendorPrivateGlxVendorPrivateWithReplyGlxQueryExtensionsStringGlxQueryServerStringGlxClientInfoGlxGetFBConfigsGlxCreatePixmapGlxDestroyPixmapGlxCreateNewContextGlxQueryContextGlxMakeContextCurrentGlxCreatePbufferGlxDestroyPbufferGlxGetDrawableAttributesGlxChangeDrawableAttributesGlxCreateWindowGlxDeleteWindowGlxSetClientInfoARBGlxCreateContextAttribsARBGlxSetClientInfo2ARBGlxNewListGlxEndListGlxDeleteListsGlxGenListsGlxFeedbackBufferGlxSelectBufferGlxRenderModeGlxFinishGlxPixelStorefGlxPixelStoreiGlxReadPixelsGlxGetBooleanvGlxGetClipPlaneGlxGetDoublevGlxGetErrorGlxGetFloatvGlxGetIntegervGlxGetLightfvGlxGetLightivGlxGetMapdvGlxGetMapfvGlxGetMapivGlxGetMaterialfvGlxGetMaterialivGlxGetPixelMapfvGlxGetPixelMapuivGlxGetPixelMapusvGlxGetPolygonStippleGlxGetStringGlxGetTexEnvfvGlxGetTexEnvivGlxGetTexGendvGlxGetTexGenfvGlxGetTexGenivGlxGetTexImageGlxGetTexParameterfvGlxGetTexParameterivGlxGetTexLevelParameterfvGlxGetTexLevelParameterivGlxIsEnabledGlxIsListGlxFlushGlxAreTexturesResidentGlxDeleteTexturesGlxGenTexturesGlxIsTextureGlxGetColorTableGlxGetColorTableParameterfvGlxGetColorTableParameterivGlxGetConvolutionFilterGlxGetConvolutionParameterfvGlxGetConvolutionParameterivGlxGetSeparableFilterGlxGetHistogramGlxGetHistogramParameterfvGlxGetHistogramParameterivGlxGetMinmaxGlxGetMinmaxParameterfvGlxGetMinmaxParameterivGlxGetCompressedTexImageARBGlxDeleteQueriesARBGlxGenQueriesARBGlxIsQueryARBGlxGetQueryivARBGlxGetQueryObjectivARBGlxGetQueryObjectuivARBPresentQueryVersionPixmapRequestPresentPixmapNotifyMSCRequestPresentNotifyMSCSelectInputRequestPresentSelectInputQueryCapabilitiesRequestPresentQueryCapabilitiesRandrQueryVersionSetScreenConfigRequestRandrSetScreenConfigRandrSelectInputGetScreenInfoRequestRandrGetScreenInfoGetScreenSizeRangeRequestRandrGetScreenSizeRangeSetScreenSizeRequestRandrSetScreenSizeGetScreenResourcesRequestRandrGetScreenResourcesGetOutputInfoRequestRandrGetOutputInfoListOutputPropertiesRequestRandrListOutputPropertiesQueryOutputPropertyRequestRandrQueryOutputPropertyConfigureOutputPropertyRequestRandrConfigureOutputPropertyChangeOutputPropertyRequestRandrChangeOutputPropertyDeleteOutputPropertyRequestRandrDeleteOutputPropertyGetOutputPropertyRequestRandrGetOutputPropertyCreateModeRequestRandrCreateModeDestroyModeRequestRandrDestroyModeAddOutputModeRequestRandrAddOutputModeDeleteOutputModeRequestRandrDeleteOutputModeGetCrtcInfoRequestRandrGetCrtcInfoSetCrtcConfigRequestRandrSetCrtcConfigGetCrtcGammaSizeRequestRandrGetCrtcGammaSizeGetCrtcGammaRequestRandrGetCrtcGammaSetCrtcGammaRequestRandrSetCrtcGammaGetScreenResourcesCurrentRequestRandrGetScreenResourcesCurrentSetCrtcTransformRequestRandrSetCrtcTransformGetCrtcTransformRequestRandrGetCrtcTransformGetPanningRequestRandrGetPanningSetPanningRequestRandrSetPanningSetOutputPrimaryRequestRandrSetOutputPrimaryGetOutputPrimaryRequestRandrGetOutputPrimaryGetProvidersRequestRandrGetProvidersGetProviderInfoRequestRandrGetProviderInfoSetProviderOffloadSinkRequestRandrSetProviderOffloadSinkSetProviderOutputSourceRequestRandrSetProviderOutputSourceListProviderPropertiesRequestRandrListProviderPropertiesQueryProviderPropertyRequestRandrQueryProviderPropertyConfigureProviderPropertyRequestRandrConfigureProviderPropertyChangeProviderPropertyRequestRandrChangeProviderPropertyDeleteProviderPropertyRequestRandrDeleteProviderPropertyGetProviderPropertyRequestRandrGetProviderPropertyGetMonitorsRequestRandrGetMonitorsSetMonitorRequestRandrSetMonitorDeleteMonitorRequestRandrDeleteMonitorRandrCreateLeaseFreeLeaseRequestRandrFreeLeaseRecordQueryVersionRecordCreateContextRegisterClientsRequestRecordRegisterClientsUnregisterClientsRequestRecordUnregisterClientsGetContextRequestRecordGetContextEnableContextRequestRecordEnableContextDisableContextRequestRecordDisableContextFreeContextRequestRecordFreeContextRenderQueryVersionQueryPictFormatsRequestRenderQueryPictFormatsQueryPictIndexValuesRequestRenderQueryPictIndexValuesCreatePictureRequestRenderCreatePictureChangePictureRequestRenderChangePictureSetPictureClipRectanglesRequestRenderSetPictureClipRectanglesFreePictureRequestRenderFreePictureCompositeRequestRenderCompositeTrapezoidsRequestRenderTrapezoidsTrianglesRequestRenderTrianglesTriStripRequestRenderTriStripTriFanRequestRenderTriFanCreateGlyphSetRequestRenderCreateGlyphSetReferenceGlyphSetRequestRenderReferenceGlyphSetFreeGlyphSetRequestRenderFreeGlyphSetAddGlyphsRequestRenderAddGlyphsFreeGlyphsRequestRenderFreeGlyphsCompositeGlyphs8RequestRenderCompositeGlyphs8CompositeGlyphs16RequestRenderCompositeGlyphs16CompositeGlyphs32RequestRenderCompositeGlyphs32FillRectanglesRequestRenderFillRectanglesRenderCreateCursorSetPictureTransformRequestRenderSetPictureTransformQueryFiltersRequestRenderQueryFiltersSetPictureFilterRequestRenderSetPictureFilterCreateAnimCursorRequestRenderCreateAnimCursorAddTrapsRequestRenderAddTrapsCreateSolidFillRequestRenderCreateSolidFillCreateLinearGradientRequestRenderCreateLinearGradientCreateRadialGradientRequestRenderCreateRadialGradientCreateConicalGradientRequestRenderCreateConicalGradientResQueryVersionQueryClientsRequestResQueryClientsQueryClientResourcesRequestResQueryClientResourcesQueryClientPixmapBytesRequestResQueryClientPixmapBytesQueryClientIdsRequestResQueryClientIdsQueryResourceBytesRequestResQueryResourceBytesScreensaverQueryVersionQueryInfoRequestScreensaverQueryInfoScreensaverSelectInputSetAttributesRequestScreensaverSetAttributesUnsetAttributesRequestScreensaverUnsetAttributesSuspendRequestScreensaverSuspendShapeQueryVersionRectanglesRequestShapeRectanglesMaskRequestShapeMaskCombineRequestShapeCombineOffsetRequestShapeOffsetQueryExtentsRequestShapeQueryExtentsShapeSelectInputInputSelectedRequestShapeInputSelectedGetRectanglesRequestShapeGetRectanglesShmQueryVersionAttachRequestShmAttachDetachRequestShmDetachShmPutImageShmGetImageShmCreatePixmapAttachFdRequestShmAttachFdCreateSegmentRequestShmCreateSegmentInitializeRequestSyncInitializeListSystemCountersRequestSyncListSystemCountersCreateCounterRequestSyncCreateCounterDestroyCounterRequestSyncDestroyCounterQueryCounterRequestSyncQueryCounterAwaitRequestSyncAwaitChangeCounterRequestSyncChangeCounterSetCounterRequestSyncSetCounterCreateAlarmRequestSyncCreateAlarmChangeAlarmRequestSyncChangeAlarmDestroyAlarmRequestSyncDestroyAlarmQueryAlarmRequestSyncQueryAlarmSetPriorityRequestSyncSetPriorityGetPriorityRequestSyncGetPriorityCreateFenceRequestSyncCreateFenceTriggerFenceRequestSyncTriggerFenceResetFenceRequestSyncResetFenceDestroyFenceRequestSyncDestroyFenceQueryFenceRequestSyncQueryFenceAwaitFenceRequestSyncAwaitFenceXcMiscGetVersionGetXIDRangeRequestXcMiscGetXIDRangeGetXIDListRequestXcMiscGetXIDListXevieQueryVersionStartRequestXevieStartEndRequestXevieEndXevieSendXevieSelectInputXf86driQueryVersionQueryDirectRenderingCapableRequestXf86driQueryDirectRenderingCapableOpenConnectionRequestXf86driOpenConnectionCloseConnectionRequestXf86driCloseConnectionGetClientDriverNameRequestXf86driGetClientDriverNameXf86driCreateContextXf86driDestroyContextXf86driCreateDrawableXf86driDestroyDrawableGetDrawableInfoRequestXf86driGetDrawableInfoGetDeviceInfoRequestXf86driGetDeviceInfoAuthConnectionRequestXf86driAuthConnectionXf86vidmodeQueryVersionGetModeLineRequestXf86vidmodeGetModeLineModModeLineRequestXf86vidmodeModModeLineSwitchModeRequestXf86vidmodeSwitchModeGetMonitorRequestXf86vidmodeGetMonitorLockModeSwitchRequestXf86vidmodeLockModeSwitchGetAllModeLinesRequestXf86vidmodeGetAllModeLinesAddModeLineRequestXf86vidmodeAddModeLineDeleteModeLineRequestXf86vidmodeDeleteModeLineValidateModeLineRequestXf86vidmodeValidateModeLineSwitchToModeRequestXf86vidmodeSwitchToModeGetViewPortRequestXf86vidmodeGetViewPortSetViewPortRequestXf86vidmodeSetViewPortGetDotClocksRequestXf86vidmodeGetDotClocksSetClientVersionRequestXf86vidmodeSetClientVersionSetGammaRequestXf86vidmodeSetGammaGetGammaRequestXf86vidmodeGetGammaGetGammaRampRequestXf86vidmodeGetGammaRampSetGammaRampRequestXf86vidmodeSetGammaRampGetGammaRampSizeRequestXf86vidmodeGetGammaRampSizeGetPermissionsRequestXf86vidmodeGetPermissionsXfixesQueryVersionXfixesChangeSaveSetSelectSelectionInputRequestXfixesSelectSelectionInputSelectCursorInputRequestXfixesSelectCursorInputGetCursorImageRequestXfixesGetCursorImageCreateRegionRequestXfixesCreateRegionCreateRegionFromBitmapRequestXfixesCreateRegionFromBitmapCreateRegionFromWindowRequestXfixesCreateRegionFromWindowCreateRegionFromGCRequestXfixesCreateRegionFromGCCreateRegionFromPictureRequestXfixesCreateRegionFromPictureDestroyRegionRequestXfixesDestroyRegionSetRegionRequestXfixesSetRegionXfixesCopyRegionUnionRegionRequestXfixesUnionRegionIntersectRegionRequestXfixesIntersectRegionSubtractRegionRequestXfixesSubtractRegionInvertRegionRequestXfixesInvertRegionTranslateRegionRequestXfixesTranslateRegionRegionExtentsRequestXfixesRegionExtentsFetchRegionRequestXfixesFetchRegionSetGCClipRegionRequestXfixesSetGCClipRegionSetWindowShapeRegionRequestXfixesSetWindowShapeRegionSetPictureClipRegionRequestXfixesSetPictureClipRegionSetCursorNameRequestXfixesSetCursorNameGetCursorNameRequestXfixesGetCursorNameGetCursorImageAndNameRequestXfixesGetCursorImageAndNameChangeCursorRequestXfixesChangeCursorChangeCursorByNameRequestXfixesChangeCursorByNameExpandRegionRequestXfixesExpandRegionHideCursorRequestXfixesHideCursorShowCursorRequestXfixesShowCursorCreatePointerBarrierRequestXfixesCreatePointerBarrierDeletePointerBarrierRequestXfixesDeletePointerBarrierSetClientDisconnectModeRequestXfixesSetClientDisconnectModeGetClientDisconnectModeRequestXfixesGetClientDisconnectModeGetStateRequestXineramaGetStateGetScreenCountRequestXineramaGetScreenCountGetScreenSizeRequestXineramaGetScreenSizeIsActiveRequestQueryScreensRequestGetExtensionVersionRequestXinputGetExtensionVersionListInputDevicesRequestXinputListInputDevicesOpenDeviceRequestXinputOpenDeviceCloseDeviceRequestXinputCloseDeviceSetDeviceModeRequestXinputSetDeviceModeSelectExtensionEventRequestXinputSelectExtensionEventGetSelectedExtensionEventsRequestXinputGetSelectedExtensionEventsChangeDeviceDontPropagateListRequestXinputChangeDeviceDontPropagateListGetDeviceDontPropagateListRequestXinputGetDeviceDontPropagateListGetDeviceMotionEventsRequestXinputGetDeviceMotionEventsChangeKeyboardDeviceRequestXinputChangeKeyboardDeviceChangePointerDeviceRequestXinputChangePointerDeviceGrabDeviceRequestXinputGrabDeviceUngrabDeviceRequestXinputUngrabDeviceGrabDeviceKeyRequestXinputGrabDeviceKeyUngrabDeviceKeyRequestXinputUngrabDeviceKeyGrabDeviceButtonRequestXinputGrabDeviceButtonUngrabDeviceButtonRequestXinputUngrabDeviceButtonAllowDeviceEventsRequestXinputAllowDeviceEventsGetDeviceFocusRequestXinputGetDeviceFocusSetDeviceFocusRequestXinputSetDeviceFocusGetFeedbackControlRequestXinputGetFeedbackControlChangeFeedbackControlRequestXinputChangeFeedbackControlGetDeviceKeyMappingRequestXinputGetDeviceKeyMappingChangeDeviceKeyMappingRequestXinputChangeDeviceKeyMappingGetDeviceModifierMappingRequestXinputGetDeviceModifierMappingSetDeviceModifierMappingRequestXinputSetDeviceModifierMappingGetDeviceButtonMappingRequestXinputGetDeviceButtonMappingSetDeviceButtonMappingRequestXinputSetDeviceButtonMappingQueryDeviceStateRequestXinputQueryDeviceStateDeviceBellRequestXinputDeviceBellSetDeviceValuatorsRequestXinputSetDeviceValuatorsGetDeviceControlRequestXinputGetDeviceControlChangeDeviceControlRequestXinputChangeDeviceControlListDevicePropertiesRequestXinputListDevicePropertiesChangeDevicePropertyRequestXinputChangeDevicePropertyDeleteDevicePropertyRequestXinputDeleteDevicePropertyGetDevicePropertyRequestXinputGetDevicePropertyXIQueryPointerRequestXinputXIQueryPointerXIWarpPointerRequestXinputXIWarpPointerXIChangeCursorRequestXinputXIChangeCursorXIChangeHierarchyRequestXinputXIChangeHierarchyXISetClientPointerRequestXinputXISetClientPointerXIGetClientPointerRequestXinputXIGetClientPointerXISelectEventsRequestXinputXISelectEventsXIQueryVersionRequestXinputXIQueryVersionXIQueryDeviceRequestXinputXIQueryDeviceXISetFocusRequestXinputXISetFocusXIGetFocusRequestXinputXIGetFocusXIGrabDeviceRequestXinputXIGrabDeviceXIUngrabDeviceRequestXinputXIUngrabDeviceXIAllowEventsRequestXinputXIAllowEventsXIPassiveGrabDeviceRequestXinputXIPassiveGrabDeviceXIPassiveUngrabDeviceRequestXinputXIPassiveUngrabDeviceXIListPropertiesRequestXinputXIListPropertiesXIChangePropertyRequestXinputXIChangePropertyXIDeletePropertyRequestXinputXIDeletePropertyXIGetPropertyRequestXinputXIGetPropertyXIGetSelectedEventsRequestXinputXIGetSelectedEventsXIBarrierReleasePointerRequestXinputXIBarrierReleasePointerSendExtensionEventRequestXinputSendExtensionEventUseExtensionRequestSelectEventsRequestLatchLockStateRequestXkbLatchLockStateGetControlsRequestSetControlsRequestGetMapRequestSetMapRequestGetCompatMapRequestSetCompatMapRequestGetIndicatorStateRequestGetIndicatorMapRequestSetIndicatorMapRequestGetNamedIndicatorRequestSetNamedIndicatorRequestGetNamesRequestSetNamesRequestPerClientFlagsRequestXkbPerClientFlagsListComponentsRequestGetKbdByNameRequestXkbGetKbdByNameSetDeviceInfoRequestSetDebuggingFlagsRequestPrintQueryVersionRequestXprintPrintQueryVersionPrintGetPrinterListRequestXprintPrintGetPrinterListPrintRehashPrinterListRequestXprintPrintRehashPrinterListXprintCreateContextPrintSetContextRequestXprintPrintSetContextPrintGetContextRequestXprintPrintGetContextPrintDestroyContextRequestXprintPrintDestroyContextPrintGetScreenOfContextRequestXprintPrintGetScreenOfContextPrintStartJobRequestXprintPrintStartJobPrintEndJobRequestXprintPrintEndJobPrintStartDocRequestXprintPrintStartDocPrintEndDocRequestXprintPrintEndDocPrintPutDocumentDataRequestXprintPrintPutDocumentDataPrintGetDocumentDataRequestXprintPrintGetDocumentDataPrintStartPageRequestXprintPrintStartPagePrintEndPageRequestXprintPrintEndPagePrintSelectInputRequestXprintPrintSelectInputPrintInputSelectedRequestXprintPrintInputSelectedPrintGetAttributesRequestXprintPrintGetAttributesPrintGetOneAttributesRequestXprintPrintGetOneAttributesPrintSetAttributesRequestXprintPrintSetAttributesPrintGetPageDimensionsRequestXprintPrintGetPageDimensionsPrintQueryScreensRequestXprintPrintQueryScreensPrintSetImageResolutionRequestXprintPrintSetImageResolutionPrintGetImageResolutionRequestXprintPrintGetImageResolutionXselinuxQueryVersionSetDeviceCreateContextRequestXselinuxSetDeviceCreateContextGetDeviceCreateContextRequestXselinuxGetDeviceCreateContextSetDeviceContextRequestXselinuxSetDeviceContextGetDeviceContextRequestXselinuxGetDeviceContextSetWindowCreateContextRequestXselinuxSetWindowCreateContextGetWindowCreateContextRequestXselinuxGetWindowCreateContextGetWindowContextRequestXselinuxGetWindowContextSetPropertyCreateContextRequestXselinuxSetPropertyCreateContextGetPropertyCreateContextRequestXselinuxGetPropertyCreateContextSetPropertyUseContextRequestXselinuxSetPropertyUseContextGetPropertyUseContextRequestXselinuxGetPropertyUseContextGetPropertyContextRequestXselinuxGetPropertyContextGetPropertyDataContextRequestXselinuxGetPropertyDataContextXselinuxListPropertiesSetSelectionCreateContextRequestXselinuxSetSelectionCreateContextGetSelectionCreateContextRequestXselinuxGetSelectionCreateContextSetSelectionUseContextRequestXselinuxSetSelectionUseContextGetSelectionUseContextRequestXselinuxGetSelectionUseContextGetSelectionContextRequestXselinuxGetSelectionContextGetSelectionDataContextRequestXselinuxGetSelectionDataContextListSelectionsRequestXselinuxListSelectionsGetClientContextRequestXselinuxGetClientContextXtestGetVersionCompareCursorRequestXtestCompareCursorFakeInputRequestXtestFakeInputGrabControlRequestXtestGrabControlXvQueryExtensionQueryAdaptorsRequestXvQueryAdaptorsQueryEncodingsRequestXvQueryEncodingsGrabPortRequestXvGrabPortUngrabPortRequestXvUngrabPortPutVideoRequestXvPutVideoPutStillRequestXvPutStillGetVideoRequestXvGetVideoGetStillRequestXvGetStillStopVideoRequestXvStopVideoSelectVideoNotifyRequestXvSelectVideoNotifySelectPortNotifyRequestXvSelectPortNotifyXvQueryBestSizeSetPortAttributeRequestXvSetPortAttributeGetPortAttributeRequestXvGetPortAttributeQueryPortAttributesRequestXvQueryPortAttributesListImageFormatsRequestXvListImageFormatsQueryImageAttributesRequestXvQueryImageAttributesXvPutImageShmPutImageRequestXvShmPutImageXvmcQueryVersionListSurfaceTypesRequestXvmcListSurfaceTypesXvmcCreateContextXvmcDestroyContextCreateSurfaceRequestXvmcCreateSurfaceDestroySurfaceRequestXvmcDestroySurfaceCreateSubpictureRequestXvmcCreateSubpictureDestroySubpictureRequestXvmcDestroySubpictureListSubpictureTypesRequestXvmcListSubpictureTypes/// Enumeration of all possible X11 requests.// Might not be used if none of the extensions that use FD passing is enabled// Parse a X11 request into a concrete typereply_parser/// Get the matching reply parser (if any) for this request./// For `Request::Unknown`, `None` is also returned./// Convert this Request into an owned version with no borrows./// Enumeration of all possible X11 replies./// Get the name of a request from its extension name and opcodes./// First result is the name of the extension, second the name of the request.IDChoiceDamageBadDamageDbeBadBufferGlxBadContextGlxBadContextStateGlxBadContextTagGlxBadCurrentDrawableGlxBadCurrentWindowGlxBadDrawableGlxBadFBConfigGlxBadLargeRequestGlxBadPbufferGlxBadPixmapGlxBadRenderRequestGlxBadWindowGlxGLXBadProfileARBGlxUnsupportedPrivateRequestRandrBadCrtcRandrBadModeRandrBadOutputRandrBadProviderRecordBadContextRenderGlyphRenderGlyphSetRenderPictFormatRenderPictOpRenderPictureShmBadSegSyncAlarmSyncCounterXf86vidmodeBadClockXf86vidmodeBadHTimingsXf86vidmodeBadVTimingsXf86vidmodeClientNotLocalXf86vidmodeExtensionDisabledXf86vidmodeModeUnsuitableXf86vidmodeZoomLockedXfixesBadRegionXinputClassXinputDeviceXinputDeviceBusyXinputEventXinputModeXkbKeyboardXprintBadContextXprintBadSequenceXvBadControlXvBadEncodingXvBadPort/// Enumeration of all possible X11 error kinds.from_wire_error_codeButtonPressEventButtonReleaseEventCirculateNotifyEventCirculateRequestEventClientMessageEventColormapNotifyEventConfigureNotifyEventConfigureRequestEventCreateNotifyEventDestroyNotifyEventEnterNotifyEventExposeEventFocusInEventFocusOutEventGeGenericEventGeGenericGraphicsExposureEventGraphicsExposureGravityNotifyEventKeyPressEventKeyReleaseEventKeymapNotifyEventLeaveNotifyEventMapNotifyEventMapRequestEventMappingNotifyEventMotionNotifyEventNoExposureEventNoExposureReparentNotifyEventResizeRequestEventSelectionClearEventUnmapNotifyEventVisibilityNotifyEventDamageNotifyDri2BufferSwapCompleteDri2InvalidateBuffersGlxBufferSwapCompleteGlxPbufferClobberCompleteNotifyEventPresentGenericIdleNotifyEventRedirectNotifyEventPresentRedirectNotifyRandrNotifyScreenChangeNotifyEventRandrScreenChangeNotifyScreensaverNotifyShapeNotifyCompletionEventShmCompletionAlarmNotifyEventSyncAlarmNotifyCounterNotifyEventSyncCounterNotifyCursorNotifyEventXfixesCursorNotifyXfixesSelectionNotifyBarrierHitEventXinputBarrierHitBarrierLeaveEventXinputBarrierLeaveXinputButtonPressXinputButtonReleaseChangeDeviceNotifyEventXinputChangeDeviceNotifyDeviceButtonPressEventXinputDeviceButtonPressDeviceButtonReleaseEventXinputDeviceButtonReleaseDeviceButtonStateNotifyEventXinputDeviceButtonStateNotifyDeviceChangedEventXinputDeviceChangedDeviceFocusInEventXinputDeviceFocusInDeviceFocusOutEventXinputDeviceFocusOutDeviceKeyPressEventXinputDeviceKeyPressDeviceKeyReleaseEventXinputDeviceKeyReleaseDeviceKeyStateNotifyEventXinputDeviceKeyStateNotifyDeviceMappingNotifyEventXinputDeviceMappingNotifyDeviceMotionNotifyEventXinputDeviceMotionNotifyDevicePresenceNotifyEventXinputDevicePresenceNotifyDevicePropertyNotifyEventXinputDevicePropertyNotifyDeviceStateNotifyEventXinputDeviceStateNotifyDeviceValuatorEventXinputDeviceValuatorEnterEventXinputEnterXinputFocusInXinputFocusOutGesturePinchBeginEventXinputGesturePinchBeginGesturePinchEndEventXinputGesturePinchEndGesturePinchUpdateEventXinputGesturePinchUpdateGestureSwipeBeginEventXinputGestureSwipeBeginGestureSwipeEndEventXinputGestureSwipeEndGestureSwipeUpdateEventXinputGestureSwipeUpdateHierarchyEventXinputHierarchyXinputKeyPressXinputKeyReleaseLeaveEventXinputLeaveMotionEventXinputMotionPropertyEventXinputPropertyProximityInEventXinputProximityInProximityOutEventXinputProximityOutRawButtonPressEventXinputRawButtonPressRawButtonReleaseEventXinputRawButtonReleaseRawKeyPressEventXinputRawKeyPressRawKeyReleaseEventXinputRawKeyReleaseRawMotionEventXinputRawMotionRawTouchBeginEventXinputRawTouchBeginRawTouchEndEventXinputRawTouchEndRawTouchUpdateEventXinputRawTouchUpdateTouchBeginEventXinputTouchBeginTouchEndEventXinputTouchEndTouchOwnershipEventXinputTouchOwnershipTouchUpdateEventXinputTouchUpdateAccessXNotifyEventActionMessageEventBellNotifyEventCompatMapNotifyEventControlsNotifyEventExtensionDeviceNotifyEventIndicatorMapNotifyEventIndicatorStateNotifyEventNamesNotifyEventNewKeyboardNotifyEventStateNotifyEventAttributNotifyEventXprintAttributNotifyXprintNotifyPortNotifyEventXvPortNotifyVideoNotifyEventXvVideoNotify/// Enumeration of all possible X11 events./// Parse a generic X11 event into a concrete event type.from_generic_eventwire_sequence_number/// Get the sequence number contained in this X11 eventraw_response_type/// Get the raw response type of this X11 event/// Response types have seven bits in X11. The eight bit indicates whether/// the packet was generated through the `SendEvent` request. This function/// returns all eight bits./// See also the `response_type()`, `server_generated()` and `sent_event()` methods./// Get the response type of this X11 eventserver_generated/// Was this event generated by the X11 server?/// If this function returns true, then this event comes from the X11 server./// Otherwise, it was sent from another client via the `SendEvent` request.sent_event/// Was this event generated by another X11 client?/// If this function returns true, then this event comes from another client via/// the `SendEvent` request. Otherwise, it was generated by the X11 server./// Get the response type out of the raw bytes of an X11 error or event./// Get the sequence number out of an X11 packet.EventEnumCONFIGURE_NOTIFYCOMPLETE_NOTIFYIDLE_NOTIFYREDIRECT_NOTIFYNO_EVENTbitmask_binopr" Check if this object has all bits set that are also set in `flag`."r" `flag` can be a single enum variant or a whole other mask."r" Check if this object has some bits set that are also set in `flag`."USTSUBOPTIMALFENCECompleteKindPIXMAPNOTIFY_MSCCompleteModeSUBOPTIMAL_COPYPIXMAP_REQUEST/// Opcode for the Pixmap requestx_offy_offtarget_crtcwait_fencetarget_mscnotifies/// Clone all borrowed data in this PixmapRequest.NOTIFY_MSC_REQUEST/// Opcode for the NotifyMSC requestSELECT_INPUT_REQUEST/// Opcode for the SelectInput requestQUERY_CAPABILITIES_REQUEST/// Opcode for the QueryCapabilities requestGENERIC_EVENT/// Opcode for the Generic eventCONFIGURE_NOTIFY_EVENT/// Opcode for the ConfigureNotify eventCOMPLETE_NOTIFY_EVENT/// Opcode for the CompleteNotify eventIDLE_NOTIFY_EVENT/// Opcode for the IdleNotify eventREDIRECT_NOTIFY_EVENT/// Opcode for the RedirectNotify eventupdate_windowvalid_regionupdate_regionvalid_rectupdate_rectBAD_OUTPUT_ERROR/// Opcode for the BadOutput errorBAD_CRTC_ERROR/// Opcode for the BadCrtc errorBAD_MODE_ERROR/// Opcode for the BadMode errorBAD_PROVIDER_ERROR/// Opcode for the BadProvider errorROTATE0ROTATE90ROTATE180ROTATE270REFLECT_XREFLECT_YScreenSizeratesRefreshRatesn_rates/// Get the value of the `nRates` field./// The `nRates` field is used as the length field of the `rates` field.SetConfigINVALID_CONFIG_TIMEINVALID_TIMESET_SCREEN_CONFIG_REQUEST/// Opcode for the SetScreenConfig requestsize_idnew_timestampSCREEN_CHANGECRTC_CHANGEOUTPUT_CHANGEOUTPUT_PROPERTYPROVIDER_CHANGEPROVIDER_PROPERTYRESOURCE_CHANGEGET_SCREEN_INFO_REQUEST/// Opcode for the GetScreenInfo requestn_infon_sizes/// Get the value of the `nSizes` field./// The `nSizes` field is used as the length field of the `sizes` field.GET_SCREEN_SIZE_RANGE_REQUEST/// Opcode for the GetScreenSizeRange requestSET_SCREEN_SIZE_REQUEST/// Opcode for the SetScreenSize requestHSYNC_POSITIVEHSYNC_NEGATIVEVSYNC_POSITIVEVSYNC_NEGATIVEDOUBLE_SCANCSYNC_POSITIVECSYNC_NEGATIVEHSKEW_PRESENTPIXEL_MULTIPLEXDOUBLE_CLOCKHALVE_CLOCKdot_clockmode_flagsGET_SCREEN_RESOURCES_REQUEST/// Opcode for the GetScreenResources requestnum_crtcs/// Get the value of the `num_crtcs` field./// The `num_crtcs` field is used as the length field of the `crtcs` field.num_outputs/// Get the value of the `num_outputs` field./// The `num_outputs` field is used as the length field of the `outputs` field.num_modes/// Get the value of the `num_modes` field./// The `num_modes` field is used as the length field of the `modes` field.names_len/// Get the value of the `names_len` field./// The `names_len` field is used as the length field of the `names` field.DISCONNECTEDGET_OUTPUT_INFO_REQUEST/// Opcode for the GetOutputInfo requestnum_preferrednum_clones/// Get the value of the `num_clones` field./// The `num_clones` field is used as the length field of the `clones` field./// Get the value of the `name_len` field./// The `name_len` field is used as the length field of the `name` field.LIST_OUTPUT_PROPERTIES_REQUEST/// Opcode for the ListOutputProperties requestnum_atoms/// Get the value of the `num_atoms` field./// The `num_atoms` field is used as the length field of the `atoms` field.QUERY_OUTPUT_PROPERTY_REQUEST/// Opcode for the QueryOutputProperty requestvalid_values/// The `length` field is used as the length field of the `validValues` field.CONFIGURE_OUTPUT_PROPERTY_REQUEST/// Opcode for the ConfigureOutputProperty request/// Clone all borrowed data in this ConfigureOutputPropertyRequest.CHANGE_OUTPUT_PROPERTY_REQUEST/// Opcode for the ChangeOutputProperty requestnum_units/// Clone all borrowed data in this ChangeOutputPropertyRequest.DELETE_OUTPUT_PROPERTY_REQUEST/// Opcode for the DeleteOutputProperty requestGET_OUTPUT_PROPERTY_REQUEST/// Opcode for the GetOutputProperty requestlong_offsetlong_lengthbytes_afterCREATE_MODE_REQUEST/// Opcode for the CreateMode requestmode_info/// Clone all borrowed data in this CreateModeRequest.DESTROY_MODE_REQUEST/// Opcode for the DestroyMode requestADD_OUTPUT_MODE_REQUEST/// Opcode for the AddOutputMode requestDELETE_OUTPUT_MODE_REQUEST/// Opcode for the DeleteOutputMode requestGET_CRTC_INFO_REQUEST/// Opcode for the GetCrtcInfo requestnum_possible_outputs/// Get the value of the `num_possible_outputs` field./// The `num_possible_outputs` field is used as the length field of the `possible` field.SET_CRTC_CONFIG_REQUEST/// Opcode for the SetCrtcConfig request/// Clone all borrowed data in this SetCrtcConfigRequest.GET_CRTC_GAMMA_SIZE_REQUEST/// Opcode for the GetCrtcGammaSize requestGET_CRTC_GAMMA_REQUEST/// Opcode for the GetCrtcGamma request/// Get the value of the `size` field./// The `size` field is used as the length field of the `red` field.SET_CRTC_GAMMA_REQUEST/// Opcode for the SetCrtcGamma request/// Clone all borrowed data in this SetCrtcGammaRequest.GET_SCREEN_RESOURCES_CURRENT_REQUEST/// Opcode for the GetScreenResourcesCurrent requestSCALE_UPSCALE_DOWNPROJECTIVESET_CRTC_TRANSFORM_REQUEST/// Opcode for the SetCrtcTransform requestfilter_namefilter_params/// Clone all borrowed data in this SetCrtcTransformRequest.GET_CRTC_TRANSFORM_REQUEST/// Opcode for the GetCrtcTransform requestpending_transformhas_transformscurrent_transformpending_filter_namepending_paramscurrent_filter_namecurrent_params/// Get the value of the `pending_len` field./// The `pending_len` field is used as the length field of the `pending_filter_name` field.pending_nparams/// Get the value of the `pending_nparams` field./// The `pending_nparams` field is used as the length field of the `pending_params` field.current_len/// Get the value of the `current_len` field./// The `current_len` field is used as the length field of the `current_filter_name` field.current_nparams/// Get the value of the `current_nparams` field./// The `current_nparams` field is used as the length field of the `current_params` field.GET_PANNING_REQUEST/// Opcode for the GetPanning requestSET_PANNING_REQUEST/// Opcode for the SetPanning requestSET_OUTPUT_PRIMARY_REQUEST/// Opcode for the SetOutputPrimary requestGET_OUTPUT_PRIMARY_REQUEST/// Opcode for the GetOutputPrimary requestGET_PROVIDERS_REQUEST/// Opcode for the GetProviders requestnum_providers/// Get the value of the `num_providers` field./// The `num_providers` field is used as the length field of the `providers` field.ProviderCapabilitySINK_OUTPUTSOURCE_OFFLOADSINK_OFFLOADGET_PROVIDER_INFO_REQUEST/// Opcode for the GetProviderInfo requestnum_associated_providers/// Get the value of the `num_associated_providers` field./// The `num_associated_providers` field is used as the length field of the `associated_providers` field.SET_PROVIDER_OFFLOAD_SINK_REQUEST/// Opcode for the SetProviderOffloadSink requestsink_providerSET_PROVIDER_OUTPUT_SOURCE_REQUEST/// Opcode for the SetProviderOutputSource requestsource_providerLIST_PROVIDER_PROPERTIES_REQUEST/// Opcode for the ListProviderProperties requestQUERY_PROVIDER_PROPERTY_REQUEST/// Opcode for the QueryProviderProperty request/// The `length` field is used as the length field of the `valid_values` field.CONFIGURE_PROVIDER_PROPERTY_REQUEST/// Opcode for the ConfigureProviderProperty request/// Clone all borrowed data in this ConfigureProviderPropertyRequest.CHANGE_PROVIDER_PROPERTY_REQUEST/// Opcode for the ChangeProviderProperty request/// Clone all borrowed data in this ChangeProviderPropertyRequest.DELETE_PROVIDER_PROPERTY_REQUEST/// Opcode for the DeleteProviderProperty requestGET_PROVIDER_PROPERTY_REQUEST/// Opcode for the GetProviderProperty requestSCREEN_CHANGE_NOTIFY_EVENT/// Opcode for the ScreenChangeNotify eventrequest_windowCrtcChangeOutputChangeOutputPropertyProviderChangeProviderPropertyResourceChangewidth_in_millimetersheight_in_millimetersn_output/// Get the value of the `nOutput` field./// The `nOutput` field is used as the length field of the `outputs` field.GET_MONITORS_REQUEST/// Opcode for the GetMonitors requestget_activen_outputs/// Get the value of the `nMonitors` field./// The `nMonitors` field is used as the length field of the `monitors` field.SET_MONITOR_REQUEST/// Opcode for the SetMonitor requestmonitorinfoDELETE_MONITOR_REQUEST/// Opcode for the DeleteMonitor requestCREATE_LEASE_REQUEST/// Opcode for the CreateLease requestlid/// Clone all borrowed data in this CreateLeaseRequest.master_fdFREE_LEASE_REQUEST/// Opcode for the FreeLease requestleaseLeaseNotifyNotifyDataas_ccas_ocas_opas_pcas_ppas_rcas_lcsub_codeRange8Range16ExtRangeHTypeFROM_SERVER_TIMEFROM_CLIENT_TIMEFROM_CLIENT_SEQUENCECURRENT_CLIENTSFUTURE_CLIENTSALL_CLIENTSclient_resourcenum_ranges/// Get the value of the `num_ranges` field./// The `num_ranges` field is used as the length field of the `ranges` field.element_headerclient_specs/// Clone all borrowed data in this CreateContextRequest.REGISTER_CLIENTS_REQUEST/// Opcode for the RegisterClients request/// Clone all borrowed data in this RegisterClientsRequest.UNREGISTER_CLIENTS_REQUEST/// Opcode for the UnregisterClients request/// Clone all borrowed data in this UnregisterClientsRequest.GET_CONTEXT_REQUEST/// Opcode for the GetContext requestintercepted_clientsnum_intercepted_clients/// Get the value of the `num_intercepted_clients` field./// The `num_intercepted_clients` field is used as the length field of the `intercepted_clients` field.ENABLE_CONTEXT_REQUEST/// Opcode for the EnableContext requestxid_baserec_sequence_numDISABLE_CONTEXT_REQUEST/// Opcode for the DisableContext requestFREE_CONTEXT_REQUEST/// Opcode for the FreeContext requestPictTypeINDEXEDPictureEnumCLEARSRCDSTOVEROVER_REVERSEIN_REVERSEOUT_REVERSEATOPATOP_REVERSESATURATEDISJOINT_CLEARDISJOINT_SRCDISJOINT_DSTDISJOINT_OVERDISJOINT_OVER_REVERSEDISJOINT_INDISJOINT_IN_REVERSEDISJOINT_OUTDISJOINT_OUT_REVERSEDISJOINT_ATOPDISJOINT_ATOP_REVERSEDISJOINT_XORCONJOINT_CLEARCONJOINT_SRCCONJOINT_DSTCONJOINT_OVERCONJOINT_OVER_REVERSECONJOINT_INCONJOINT_IN_REVERSECONJOINT_OUTCONJOINT_OUT_REVERSECONJOINT_ATOPCONJOINT_ATOP_REVERSECONJOINT_XORMULTIPLYSCREENOVERLAYDARKENLIGHTENCOLOR_DODGECOLOR_BURNHARD_LIGHTSOFT_LIGHTEXCLUSIONHSL_HUEHSL_SATURATIONHSL_COLORHSL_LUMINOSITYPolyEdgeSHARPSMOOTHPolyModeIMPRECISEALPHA_MAPALPHA_X_ORIGINALPHA_Y_ORIGINCLIP_X_ORIGINCLIP_Y_ORIGINGRAPHICS_EXPOSURESUBWINDOW_MODEPOLY_EDGEPOLY_MODEDITHERCOMPONENT_ALPHAHORIZONTAL_RGBHORIZONTAL_BGRVERTICAL_RGBVERTICAL_BGRREFLECTPICT_FORMAT_ERROR/// Opcode for the PictFormat errorPICTURE_ERROR/// Opcode for the Picture errorPICT_OP_ERROR/// Opcode for the PictOp errorGLYPH_SET_ERROR/// Opcode for the GlyphSet errorGLYPH_ERROR/// Opcode for the Glyph errorred_shiftgreen_shiftblue_shiftalpha_shiftalpha_maskDirectformatPictforminfoPictvisualPictdepth/// Get the value of the `num_visuals` field./// The `num_visuals` field is used as the length field of the `visuals` field.Pictscreennum_depths/// Get the value of the `num_depths` field./// The `num_depths` field is used as the length field of the `depths` field.IndexvalueLinefixQUERY_PICT_FORMATS_REQUEST/// Opcode for the QueryPictFormats requestscreenssubpixelsnum_formats/// Get the value of the `num_formats` field./// The `num_formats` field is used as the length field of the `formats` field.num_screens/// Get the value of the `num_screens` field./// The `num_screens` field is used as the length field of the `screens` field.num_subpixel/// Get the value of the `num_subpixel` field./// The `num_subpixel` field is used as the length field of the `subpixels` field.QUERY_PICT_INDEX_VALUES_REQUEST/// Opcode for the QueryPictIndexValues request/// Get the value of the `num_values` field./// The `num_values` field is used as the length field of the `values` field.alphamapalphaxoriginalphayoriginclipxoriginclipyoriginclipmaskgraphicsexposuresubwindowmodeSubwindowModepolyedgepolymodecomponentalpha/// Auxiliary and optional information for the `create_picture` functionswitch_expr/// Create a new instance with all fields unset / not present./// Set the `repeat` field of this structure./// Set the `alphamap` field of this structure./// Set the `alphaxorigin` field of this structure./// Set the `alphayorigin` field of this structure./// Set the `clipxorigin` field of this structure./// Set the `clipyorigin` field of this structure./// Set the `clipmask` field of this structure./// Set the `graphicsexposure` field of this structure./// Set the `subwindowmode` field of this structure./// Set the `polyedge` field of this structure./// Set the `polymode` field of this structure./// Set the `dither` field of this structure./// Set the `componentalpha` field of this structure.CREATE_PICTURE_REQUEST/// Opcode for the CreatePicture requestvalue_list/// Clone all borrowed data in this CreatePictureRequest./// Auxiliary and optional information for the `change_picture` functionCHANGE_PICTURE_REQUEST/// Opcode for the ChangePicture request/// Clone all borrowed data in this ChangePictureRequest.SET_PICTURE_CLIP_RECTANGLES_REQUEST/// Opcode for the SetPictureClipRectangles request/// Clone all borrowed data in this SetPictureClipRectanglesRequest.FREE_PICTURE_REQUEST/// Opcode for the FreePicture requestCOMPOSITE_REQUEST/// Opcode for the Composite requestmask_xmask_ydst_xdst_yTRAPEZOIDS_REQUEST/// Opcode for the Trapezoids requestmask_formattraps/// Clone all borrowed data in this TrapezoidsRequest.TRIANGLES_REQUEST/// Opcode for the Triangles request/// Clone all borrowed data in this TrianglesRequest.TRI_STRIP_REQUEST/// Opcode for the TriStrip request/// Clone all borrowed data in this TriStripRequest.TRI_FAN_REQUEST/// Opcode for the TriFan request/// Clone all borrowed data in this TriFanRequest.CREATE_GLYPH_SET_REQUEST/// Opcode for the CreateGlyphSet requestgsidREFERENCE_GLYPH_SET_REQUEST/// Opcode for the ReferenceGlyphSet requestFREE_GLYPH_SET_REQUEST/// Opcode for the FreeGlyphSet requestADD_GLYPHS_REQUEST/// Opcode for the AddGlyphs requestglyphids/// Clone all borrowed data in this AddGlyphsRequest.FREE_GLYPHS_REQUEST/// Opcode for the FreeGlyphs request/// Clone all borrowed data in this FreeGlyphsRequest.COMPOSITE_GLYPHS8_REQUEST/// Opcode for the CompositeGlyphs8 requestglyphcmds/// Clone all borrowed data in this CompositeGlyphs8Request.COMPOSITE_GLYPHS16_REQUEST/// Opcode for the CompositeGlyphs16 request/// Clone all borrowed data in this CompositeGlyphs16Request.COMPOSITE_GLYPHS32_REQUEST/// Opcode for the CompositeGlyphs32 request/// Clone all borrowed data in this CompositeGlyphs32Request.FILL_RECTANGLES_REQUEST/// Opcode for the FillRectangles request/// Clone all borrowed data in this FillRectanglesRequest.CREATE_CURSOR_REQUEST/// Opcode for the CreateCursor requestmatrix11matrix12matrix13matrix21matrix22matrix23matrix31matrix32matrix33SET_PICTURE_TRANSFORM_REQUEST/// Opcode for the SetPictureTransform requestQUERY_FILTERS_REQUEST/// Opcode for the QueryFilters request/// Get the value of the `num_aliases` field./// The `num_aliases` field is used as the length field of the `aliases` field.num_filters/// Get the value of the `num_filters` field./// The `num_filters` field is used as the length field of the `filters` field.SET_PICTURE_FILTER_REQUEST/// Opcode for the SetPictureFilter request/// Clone all borrowed data in this SetPictureFilterRequest.CREATE_ANIM_CURSOR_REQUEST/// Opcode for the CreateAnimCursor request/// Clone all borrowed data in this CreateAnimCursorRequest.SpanfixbotADD_TRAPS_REQUEST/// Opcode for the AddTraps request/// Clone all borrowed data in this AddTrapsRequest.CREATE_SOLID_FILL_REQUEST/// Opcode for the CreateSolidFill requestCREATE_LINEAR_GRADIENT_REQUEST/// Opcode for the CreateLinearGradient request/// Clone all borrowed data in this CreateLinearGradientRequest.CREATE_RADIAL_GRADIENT_REQUEST/// Opcode for the CreateRadialGradient requestinner_radiusouter_radius/// Clone all borrowed data in this CreateRadialGradientRequest.CREATE_CONICAL_GRADIENT_REQUEST/// Opcode for the CreateConicalGradient request/// Clone all borrowed data in this CreateConicalGradientRequest.resource_baseresource_maskresource_typeClientIdMaskCLIENT_XIDLOCAL_CLIENT_PIDClientIdValue/// The `length` field is used as the length field of the `value` field.ResourceSizeSpeccross_referencesResourceSizeValuenum_cross_references/// Get the value of the `num_cross_references` field./// The `num_cross_references` field is used as the length field of the `cross_references` field.client_majorclient_minorserver_majorserver_minorQUERY_CLIENTS_REQUEST/// Opcode for the QueryClients requestnum_clients/// Get the value of the `num_clients` field./// The `num_clients` field is used as the length field of the `clients` field.QUERY_CLIENT_RESOURCES_REQUEST/// Opcode for the QueryClientResources request/// Get the value of the `num_types` field./// The `num_types` field is used as the length field of the `types` field.QUERY_CLIENT_PIXMAP_BYTES_REQUEST/// Opcode for the QueryClientPixmapBytes requestbytes_overflowQUERY_CLIENT_IDS_REQUEST/// Opcode for the QueryClientIds requestspecs/// Clone all borrowed data in this QueryClientIdsRequest.num_ids/// Get the value of the `num_ids` field./// The `num_ids` field is used as the length field of the `ids` field.QUERY_RESOURCE_BYTES_REQUEST/// Opcode for the QueryResourceBytes request/// Clone all borrowed data in this QueryResourceBytesRequest.num_sizes/// Get the value of the `num_sizes` field./// The `num_sizes` field is used as the length field of the `sizes` field.BLANKEDNOTIFY_MASKCYCLE_MASKQUERY_INFO_REQUEST/// Opcode for the QueryInfo requestsaver_windowms_until_serverms_since_user_inputBackingStoredo_not_propogate_mask/// Auxiliary and optional information for the `set_attributes` function/// Set the `background_pixmap` field of this structure./// Set the `background_pixel` field of this structure./// Set the `border_pixmap` field of this structure./// Set the `border_pixel` field of this structure./// Set the `bit_gravity` field of this structure./// Set the `win_gravity` field of this structure./// Set the `backing_store` field of this structure./// Set the `backing_planes` field of this structure./// Set the `backing_pixel` field of this structure./// Set the `override_redirect` field of this structure./// Set the `save_under` field of this structure./// Set the `event_mask` field of this structure./// Set the `do_not_propogate_mask` field of this structure./// Set the `colormap` field of this structure./// Set the `cursor` field of this structure.SET_ATTRIBUTES_REQUEST/// Opcode for the SetAttributes request/// Clone all borrowed data in this SetAttributesRequest.UNSET_ATTRIBUTES_REQUEST/// Opcode for the UnsetAttributes requestSUSPEND_REQUEST/// Opcode for the Suspend requestINTERSECTSUBTRACTBOUNDINGshape_kindaffected_windowextents_xextents_yextents_widthextents_heightshapedRECTANGLES_REQUEST/// Opcode for the Rectangles requestdestination_kinddestination_window/// Clone all borrowed data in this RectanglesRequest.MASK_REQUEST/// Opcode for the Mask requestsource_bitmapCOMBINE_REQUEST/// Opcode for the Combine requestsource_kindOFFSET_REQUEST/// Opcode for the Offset requestQUERY_EXTENTS_REQUEST/// Opcode for the QueryExtents requestbounding_shapedclip_shapedbounding_shape_extents_xbounding_shape_extents_ybounding_shape_extents_widthbounding_shape_extents_heightclip_shape_extents_xclip_shape_extents_yclip_shape_extents_widthclip_shape_extents_heightINPUT_SELECTED_REQUEST/// Opcode for the InputSelected requestGET_RECTANGLES_REQUEST/// Opcode for the GetRectangles requestrectangles_len/// Get the value of the `rectangles_len` field./// The `rectangles_len` field is used as the length field of the `rectangles` field.COMPLETION_EVENT/// Opcode for the Completion eventminor_eventmajor_eventBAD_SEG_ERROR/// Opcode for the BadSeg errorshared_pixmapspixmap_formatATTACH_REQUEST/// Opcode for the Attach requestDETACH_REQUEST/// Opcode for the Detach requestPUT_IMAGE_REQUEST/// Opcode for the PutImage requesttotal_widthtotal_heightsrc_widthsrc_heightGET_IMAGE_REQUEST/// Opcode for the GetImage requestATTACH_FD_REQUEST/// Opcode for the AttachFd requestshm_fdCREATE_SEGMENT_REQUEST/// Opcode for the CreateSegment requestALARMSTATEDESTROYEDTESTTYPEPOSITIVE_TRANSITIONNEGATIVE_TRANSITIONPOSITIVE_COMPARISONNEGATIVE_COMPARISONVALUETYPETEST_TYPEEVENTSSystemcounterwait_typeTriggerCOUNTER_ERROR/// Opcode for the Counter errorALARM_ERROR/// Opcode for the Alarm errorINITIALIZE_REQUEST/// Opcode for the Initialize requestdesired_major_versiondesired_minor_versionLIST_SYSTEM_COUNTERS_REQUEST/// Opcode for the ListSystemCounters requestcounters_len/// Get the value of the `counters_len` field./// The `counters_len` field is used as the length field of the `counters` field.CREATE_COUNTER_REQUEST/// Opcode for the CreateCounter requestinitial_valueDESTROY_COUNTER_REQUEST/// Opcode for the DestroyCounter requestQUERY_COUNTER_REQUEST/// Opcode for the QueryCounter requestAWAIT_REQUEST/// Opcode for the Await requestwait_list/// Clone all borrowed data in this AwaitRequest.CHANGE_COUNTER_REQUEST/// Opcode for the ChangeCounter requestSET_COUNTER_REQUEST/// Opcode for the SetCounter request/// Auxiliary and optional information for the `create_alarm` function/// Set the `counter` field of this structure./// Set the `value_type` field of this structure./// Set the `value` field of this structure./// Set the `test_type` field of this structure./// Set the `delta` field of this structure./// Set the `events` field of this structure.CREATE_ALARM_REQUEST/// Opcode for the CreateAlarm request/// Clone all borrowed data in this CreateAlarmRequest./// Auxiliary and optional information for the `change_alarm` functionCHANGE_ALARM_REQUEST/// Opcode for the ChangeAlarm request/// Clone all borrowed data in this ChangeAlarmRequest.DESTROY_ALARM_REQUEST/// Opcode for the DestroyAlarm requestQUERY_ALARM_REQUEST/// Opcode for the QueryAlarm requestSET_PRIORITY_REQUEST/// Opcode for the SetPriority requestGET_PRIORITY_REQUEST/// Opcode for the GetPriority requestCREATE_FENCE_REQUEST/// Opcode for the CreateFence requestTRIGGER_FENCE_REQUEST/// Opcode for the TriggerFence requestRESET_FENCE_REQUEST/// Opcode for the ResetFence requestDESTROY_FENCE_REQUEST/// Opcode for the DestroyFence requestQUERY_FENCE_REQUEST/// Opcode for the QueryFence requesttriggeredAWAIT_FENCE_REQUEST/// Opcode for the AwaitFence requestfence_list/// Clone all borrowed data in this AwaitFenceRequest.COUNTER_NOTIFY_EVENT/// Opcode for the CounterNotify eventALARM_NOTIFY_EVENT/// Opcode for the AlarmNotify eventGET_XID_RANGE_REQUEST/// Opcode for the GetXIDRange requeststart_idGET_XID_LIST_REQUEST/// Opcode for the GetXIDList requestids_len/// Get the value of the `ids_len` field./// The `ids_len` field is used as the length field of the `ids` field.START_REQUEST/// Opcode for the Start requestEND_REQUEST/// Opcode for the End requestDatatypeUNMODIFIEDMODIFIEDSEND_REQUEST/// Opcode for the Send requestx3DrmClipRectdri_major_versiondri_minor_versiondri_minor_patchQUERY_DIRECT_RENDERING_CAPABLE_REQUEST/// Opcode for the QueryDirectRenderingCapable requestis_capableOPEN_CONNECTION_REQUEST/// Opcode for the OpenConnection requestsarea_handle_lowsarea_handle_highbus_idbus_id_len/// Get the value of the `bus_id_len` field./// The `bus_id_len` field is used as the length field of the `bus_id` field.CLOSE_CONNECTION_REQUEST/// Opcode for the CloseConnection requestGET_CLIENT_DRIVER_NAME_REQUEST/// Opcode for the GetClientDriverName requestclient_driver_major_versionclient_driver_minor_versionclient_driver_patch_versionclient_driver_nameclient_driver_name_len/// Get the value of the `client_driver_name_len` field./// The `client_driver_name_len` field is used as the length field of the `client_driver_name` field.hw_contexthw_drawable_handleGET_DRAWABLE_INFO_REQUEST/// Opcode for the GetDrawableInfo requestdrawable_table_indexdrawable_table_stampdrawable_origin_xdrawable_origin_ydrawable_size_wdrawable_size_hback_xback_yclip_rectsback_clip_rectsnum_clip_rects/// Get the value of the `num_clip_rects` field./// The `num_clip_rects` field is used as the length field of the `clip_rects` field.num_back_clip_rects/// Get the value of the `num_back_clip_rects` field./// The `num_back_clip_rects` field is used as the length field of the `back_clip_rects` field.GET_DEVICE_INFO_REQUEST/// Opcode for the GetDeviceInfo requestframebuffer_handle_lowframebuffer_handle_highframebuffer_origin_offsetframebuffer_sizeframebuffer_stridedevice_privatedevice_private_size/// Get the value of the `device_private_size` field./// The `device_private_size` field is used as the length field of the `device_private` field.AUTH_CONNECTION_REQUEST/// Opcode for the AuthConnection requestSyncrangePOSITIVE_H_SYNCNEGATIVE_H_SYNCPOSITIVE_V_SYNCNEGATIVE_V_SYNCCOMPOSITE_SYNCPOSITIVE_C_SYNCNEGATIVE_C_SYNCH_SKEWHALF_CLOCKClockFlagPROGRAMABLEGET_MODE_LINE_REQUEST/// Opcode for the GetModeLine request/// Get the value of the `privsize` field./// The `privsize` field is used as the length field of the `private` field.MOD_MODE_LINE_REQUEST/// Opcode for the ModModeLine request/// Clone all borrowed data in this ModModeLineRequest.SWITCH_MODE_REQUEST/// Opcode for the SwitchMode requestzoomGET_MONITOR_REQUEST/// Opcode for the GetMonitor requestvendor_length/// Get the value of the `vendor_length` field./// The `vendor_length` field is used as the length field of the `vendor` field.model_length/// Get the value of the `model_length` field./// The `model_length` field is used as the length field of the `model` field.num_hsync/// Get the value of the `num_hsync` field./// The `num_hsync` field is used as the length field of the `hsync` field.num_vsync/// Get the value of the `num_vsync` field./// The `num_vsync` field is used as the length field of the `vsync` field.LOCK_MODE_SWITCH_REQUEST/// Opcode for the LockModeSwitch requestGET_ALL_MODE_LINES_REQUEST/// Opcode for the GetAllModeLines requestmodeinfomodecount/// Get the value of the `modecount` field./// The `modecount` field is used as the length field of the `modeinfo` field.ADD_MODE_LINE_REQUEST/// Opcode for the AddModeLine requestafter_dotclockafter_hdisplayafter_hsyncstartafter_hsyncendafter_htotalafter_hskewafter_vdisplayafter_vsyncstartafter_vsyncendafter_vtotalafter_flags/// Clone all borrowed data in this AddModeLineRequest.DELETE_MODE_LINE_REQUEST/// Opcode for the DeleteModeLine request/// Clone all borrowed data in this DeleteModeLineRequest.VALIDATE_MODE_LINE_REQUEST/// Opcode for the ValidateModeLine request/// Clone all borrowed data in this ValidateModeLineRequest.SWITCH_TO_MODE_REQUEST/// Opcode for the SwitchToMode request/// Clone all borrowed data in this SwitchToModeRequest.GET_VIEW_PORT_REQUEST/// Opcode for the GetViewPort requestSET_VIEW_PORT_REQUEST/// Opcode for the SetViewPort requestGET_DOT_CLOCKS_REQUEST/// Opcode for the GetDotClocks requestclocksmaxclocksSET_CLIENT_VERSION_REQUEST/// Opcode for the SetClientVersion requestSET_GAMMA_REQUEST/// Opcode for the SetGamma requestGET_GAMMA_REQUEST/// Opcode for the GetGamma requestGET_GAMMA_RAMP_REQUEST/// Opcode for the GetGammaRamp requestSET_GAMMA_RAMP_REQUEST/// Opcode for the SetGammaRamp request/// Clone all borrowed data in this SetGammaRampRequest.GET_GAMMA_RAMP_SIZE_REQUEST/// Opcode for the GetGammaRampSize requestGET_PERMISSIONS_REQUEST/// Opcode for the GetPermissions requestBAD_CLOCK_ERROR/// Opcode for the BadClock errorBAD_H_TIMINGS_ERROR/// Opcode for the BadHTimings errorBAD_V_TIMINGS_ERROR/// Opcode for the BadVTimings errorMODE_UNSUITABLE_ERROR/// Opcode for the ModeUnsuitable errorEXTENSION_DISABLED_ERROR/// Opcode for the ExtensionDisabled errorCLIENT_NOT_LOCAL_ERROR/// Opcode for the ClientNotLocal errorZOOM_LOCKED_ERROR/// Opcode for the ZoomLocked errorINSERTNEARESTUNMAPCHANGE_SAVE_SET_REQUEST/// Opcode for the ChangeSaveSet requestSelectionEventSET_SELECTION_OWNERSELECTION_WINDOW_DESTROYSELECTION_CLIENT_CLOSE/// Opcode for the SelectionNotify eventSELECT_SELECTION_INPUT_REQUEST/// Opcode for the SelectSelectionInput requestCursorNotifyDISPLAY_CURSORCURSOR_NOTIFY_EVENT/// Opcode for the CursorNotify eventSELECT_CURSOR_INPUT_REQUEST/// Opcode for the SelectCursorInput requestGET_CURSOR_IMAGE_REQUEST/// Opcode for the GetCursorImage requestcursor_imageBAD_REGION_ERROR/// Opcode for the BadRegion errorRegionEnumCREATE_REGION_REQUEST/// Opcode for the CreateRegion request/// Clone all borrowed data in this CreateRegionRequest.CREATE_REGION_FROM_BITMAP_REQUEST/// Opcode for the CreateRegionFromBitmap requestCREATE_REGION_FROM_WINDOW_REQUEST/// Opcode for the CreateRegionFromWindow requestCREATE_REGION_FROM_GC_REQUEST/// Opcode for the CreateRegionFromGC requestCREATE_REGION_FROM_PICTURE_REQUEST/// Opcode for the CreateRegionFromPicture requestDESTROY_REGION_REQUEST/// Opcode for the DestroyRegion requestSET_REGION_REQUEST/// Opcode for the SetRegion request/// Clone all borrowed data in this SetRegionRequest.UNION_REGION_REQUEST/// Opcode for the UnionRegion requestsource1source2INTERSECT_REGION_REQUEST/// Opcode for the IntersectRegion requestSUBTRACT_REGION_REQUEST/// Opcode for the SubtractRegion requestINVERT_REGION_REQUEST/// Opcode for the InvertRegion requestTRANSLATE_REGION_REQUEST/// Opcode for the TranslateRegion requestREGION_EXTENTS_REQUEST/// Opcode for the RegionExtents requestFETCH_REGION_REQUEST/// Opcode for the FetchRegion request/// The `length` field is used as the length field of the `rectangles` field.SET_GC_CLIP_REGION_REQUEST/// Opcode for the SetGCClipRegion requestSET_WINDOW_SHAPE_REGION_REQUEST/// Opcode for the SetWindowShapeRegion requestdest_kindSET_PICTURE_CLIP_REGION_REQUEST/// Opcode for the SetPictureClipRegion requestSET_CURSOR_NAME_REQUEST/// Opcode for the SetCursorName request/// Clone all borrowed data in this SetCursorNameRequest.GET_CURSOR_NAME_REQUEST/// Opcode for the GetCursorName request/// Get the value of the `nbytes` field./// The `nbytes` field is used as the length field of the `name` field.GET_CURSOR_IMAGE_AND_NAME_REQUEST/// Opcode for the GetCursorImageAndName requestcursor_atomCHANGE_CURSOR_REQUEST/// Opcode for the ChangeCursor requestCHANGE_CURSOR_BY_NAME_REQUEST/// Opcode for the ChangeCursorByName request/// Clone all borrowed data in this ChangeCursorByNameRequest.EXPAND_REGION_REQUEST/// Opcode for the ExpandRegion requestHIDE_CURSOR_REQUEST/// Opcode for the HideCursor requestSHOW_CURSOR_REQUEST/// Opcode for the ShowCursor requestPOSITIVE_XPOSITIVE_YNEGATIVE_XNEGATIVE_YCREATE_POINTER_BARRIER_REQUEST/// Opcode for the CreatePointerBarrier requestdirections/// Clone all borrowed data in this CreatePointerBarrierRequest.DELETE_POINTER_BARRIER_REQUEST/// Opcode for the DeletePointerBarrier requestTERMINATESET_CLIENT_DISCONNECT_MODE_REQUEST/// Opcode for the SetClientDisconnectMode requestdisconnect_modeGET_CLIENT_DISCONNECT_MODE_REQUEST/// Opcode for the GetClientDisconnectMode requestScreenInfoGET_STATE_REQUEST/// Opcode for the GetState requestGET_SCREEN_COUNT_REQUEST/// Opcode for the GetScreenCount requestscreen_countGET_SCREEN_SIZE_REQUEST/// Opcode for the GetScreenSize requestIS_ACTIVE_REQUEST/// Opcode for the IsActive requestQUERY_SCREENS_REQUEST/// Opcode for the QueryScreens request/// Get the value of the `number` field./// The `number` field is used as the length field of the `screen_info` field.Fp3232GET_EXTENSION_VERSION_REQUEST/// Opcode for the GetExtensionVersion request/// Clone all borrowed data in this GetExtensionVersionRequest.xi_reply_typeDeviceUseIS_X_POINTERIS_X_KEYBOARDIS_X_EXTENSION_DEVICEIS_X_EXTENSION_KEYBOARDIS_X_EXTENSION_POINTERInputClassBUTTONVALUATORFEEDBACKPROXIMITYnum_class_infodevice_usemin_keycodemax_keycodeButtonInfoAxisInfomotion_sizeValuatorInfoaxes_len/// Get the value of the `axes_len` field./// The `axes_len` field is used as the length field of the `axes` field.InputInfoInfoKeyInputInfoInfoButtonInputInfoInfoValuatorInputInfoInfoValuator/// This variant is returned when the server sends a discriminant/// value that does not match any of the defined by the protocol./// Usually, this should be considered a parsing error, but there/// are some cases where the server violates the protocol./// Trying to use `serialize` or `serialize_into` with this variant/// will raise a panic.as_keyas_buttonas_valuatorInputInfoDeviceName/// Get the value of the `len` field./// The `len` field is used as the length field of the `string` field.// This is not a container and is_empty() makes no senseLIST_INPUT_DEVICES_REQUEST/// Opcode for the ListInputDevices requestdevices_len/// Get the value of the `devices_len` field./// The `devices_len` field is used as the length field of the `devices` field.EventTypeBaseInputClassInfoOPEN_DEVICE_REQUEST/// Opcode for the OpenDevice requestclass_info/// Get the value of the `num_classes` field./// The `num_classes` field is used as the length field of the `class_info` field.CLOSE_DEVICE_REQUEST/// Opcode for the CloseDevice requestSET_DEVICE_MODE_REQUEST/// Opcode for the SetDeviceMode requestSELECT_EXTENSION_EVENT_REQUEST/// Opcode for the SelectExtensionEvent request/// Clone all borrowed data in this SelectExtensionEventRequest.GET_SELECTED_EXTENSION_EVENTS_REQUEST/// Opcode for the GetSelectedExtensionEvents requestthis_classesall_classesnum_this_classes/// Get the value of the `num_this_classes` field./// The `num_this_classes` field is used as the length field of the `this_classes` field.num_all_classes/// Get the value of the `num_all_classes` field./// The `num_all_classes` field is used as the length field of the `all_classes` field.ADD_TO_LISTDELETE_FROM_LISTCHANGE_DEVICE_DONT_PROPAGATE_LIST_REQUEST/// Opcode for the ChangeDeviceDontPropagateList request/// Clone all borrowed data in this ChangeDeviceDontPropagateListRequest.GET_DEVICE_DONT_PROPAGATE_LIST_REQUEST/// Opcode for the GetDeviceDontPropagateList request/// The `num_classes` field is used as the length field of the `classes` field.axisvaluesDeviceTimeCoordGET_DEVICE_MOTION_EVENTS_REQUEST/// Opcode for the GetDeviceMotionEvents requestnum_axesdevice_modenum_events/// Get the value of the `num_events` field./// The `num_events` field is used as the length field of the `events` field.CHANGE_KEYBOARD_DEVICE_REQUEST/// Opcode for the ChangeKeyboardDevice requestCHANGE_POINTER_DEVICE_REQUEST/// Opcode for the ChangePointerDevice requestx_axisy_axisGRAB_DEVICE_REQUEST/// Opcode for the GrabDevice requestthis_device_modeother_device_modeowner_events/// Clone all borrowed data in this GrabDeviceRequest.UNGRAB_DEVICE_REQUEST/// Opcode for the UngrabDevice requestModifierDeviceUSE_X_KEYBOARDGRAB_DEVICE_KEY_REQUEST/// Opcode for the GrabDeviceKey requestmodifier_devicegrabbed_device/// Clone all borrowed data in this GrabDeviceKeyRequest.UNGRAB_DEVICE_KEY_REQUEST/// Opcode for the UngrabDeviceKey requestGRAB_DEVICE_BUTTON_REQUEST/// Opcode for the GrabDeviceButton request/// Clone all borrowed data in this GrabDeviceButtonRequest.UNGRAB_DEVICE_BUTTON_REQUEST/// Opcode for the UngrabDeviceButton requestASYNC_THIS_DEVICESYNC_THIS_DEVICEREPLAY_THIS_DEVICEASYNC_OTHER_DEVICESASYNC_ALLSYNC_ALLALLOW_DEVICE_EVENTS_REQUEST/// Opcode for the AllowDeviceEvents requestGET_DEVICE_FOCUS_REQUEST/// Opcode for the GetDeviceFocus requestrevert_toSET_DEVICE_FOCUS_REQUEST/// Opcode for the SetDeviceFocus requestFeedbackClassBELLfeedback_idled_valuesKbdFeedbackStateaccel_numaccel_denomPtrFeedbackStateIntegerFeedbackStatemax_symbolskeysymsStringFeedbackStatenum_keysyms/// Get the value of the `num_keysyms` field./// The `num_keysyms` field is used as the length field of the `keysyms` field.BellFeedbackStateLedFeedbackStateFeedbackStateDataKeyboardFeedbackStateDataPointerFeedbackStateDataStringFeedbackStateDataIntegerFeedbackStateDataLedFeedbackStateDataBellFeedbackStateDataas_keyboardas_pointeras_ledas_bellFeedbackStateGET_FEEDBACK_CONTROL_REQUEST/// Opcode for the GetFeedbackControl requestfeedbacksnum_feedbacks/// Get the value of the `num_feedbacks` field./// The `num_feedbacks` field is used as the length field of the `feedbacks` field.KbdFeedbackCtlPtrFeedbackCtlint_to_displayIntegerFeedbackCtlStringFeedbackCtlBellFeedbackCtlLedFeedbackCtlFeedbackCtlDataKeyboardFeedbackCtlDataPointerFeedbackCtlDataStringFeedbackCtlDataIntegerFeedbackCtlDataLedFeedbackCtlDataBellFeedbackCtlDataKEY_CLICK_PERCENTPERCENTPITCHDURATIONLED_MODEAUTO_REPEAT_MODEACCEL_NUMACCEL_DENOMCHANGE_FEEDBACK_CONTROL_REQUEST/// Opcode for the ChangeFeedbackControl requestGET_DEVICE_KEY_MAPPING_REQUEST/// Opcode for the GetDeviceKeyMapping requestkeysyms_per_keycode/// The `length` field is used as the length field of the `keysyms` field.CHANGE_DEVICE_KEY_MAPPING_REQUEST/// Opcode for the ChangeDeviceKeyMapping requestkeycode_count/// Clone all borrowed data in this ChangeDeviceKeyMappingRequest.GET_DEVICE_MODIFIER_MAPPING_REQUEST/// Opcode for the GetDeviceModifierMapping requestkeymapskeycodes_per_modifier/// Get the value of the `keycodes_per_modifier` field./// The `keycodes_per_modifier` field is used as the length field of the `keymaps` field.SET_DEVICE_MODIFIER_MAPPING_REQUEST/// Opcode for the SetDeviceModifierMapping request/// Clone all borrowed data in this SetDeviceModifierMappingRequest.MappingStatusGET_DEVICE_BUTTON_MAPPING_REQUEST/// Opcode for the GetDeviceButtonMapping requestmap_size/// Get the value of the `map_size` field./// The `map_size` field is used as the length field of the `map` field.SET_DEVICE_BUTTON_MAPPING_REQUEST/// Opcode for the SetDeviceButtonMapping request/// Clone all borrowed data in this SetDeviceButtonMappingRequest.ValuatorStateModeMaskDEVICE_MODE_ABSOLUTEOUT_OF_PROXIMITYValuatorStatenum_valuators/// Get the value of the `num_valuators` field./// The `num_valuators` field is used as the length field of the `valuators` field.InputStateDataKeyInputStateDataButtonInputStateDataValuatorInputStateDataInputStateQUERY_DEVICE_STATE_REQUEST/// Opcode for the QueryDeviceState requestDEVICE_BELL_REQUEST/// Opcode for the DeviceBell requestfeedback_classSET_DEVICE_VALUATORS_REQUEST/// Opcode for the SetDeviceValuators requestfirst_valuator/// Clone all borrowed data in this SetDeviceValuatorsRequest.RESOLUTIONABSCALIBCOREABSAREAcontrol_idresolution_valuesresolution_minresolution_maxDeviceResolutionState/// The `num_valuators` field is used as the length field of the `resolution_values` field.min_xmax_xmin_ymax_yflip_xflip_ybutton_thresholdDeviceAbsCalibStatefollowingDeviceAbsAreaStateiscoreDeviceCoreStateDeviceEnableStateDeviceStateDataResolutionDeviceStateDataAbsCalibDeviceStateDataCoreDeviceStateDataAbsAreaDeviceStateDataAbsCalibAbsAreaas_resolutionas_abs_calibas_coreas_enableas_abs_areaGET_DEVICE_CONTROL_REQUEST/// Opcode for the GetDeviceControl requestDeviceResolutionCtlDeviceAbsCalibCtlDeviceAbsAreaCtrlDeviceCoreCtrlDeviceEnableCtrlDeviceCtlDataResolutionDeviceCtlDataAbsCalibDeviceCtlDataCoreDeviceCtlDataAbsAreaDeviceCtlDataCHANGE_DEVICE_CONTROL_REQUEST/// Opcode for the ChangeDeviceControl requestLIST_DEVICE_PROPERTIES_REQUEST/// Opcode for the ListDeviceProperties requestPropertyFormatM8_BITSM16_BITSM32_BITSData16Data32as_data8as_data16as_data32CHANGE_DEVICE_PROPERTY_REQUEST/// Opcode for the ChangeDeviceProperty request/// Clone all borrowed data in this ChangeDevicePropertyRequest.DELETE_DEVICE_PROPERTY_REQUEST/// Opcode for the DeleteDeviceProperty requestGET_DEVICE_PROPERTY_REQUEST/// Opcode for the GetDeviceProperty requestGetDevicePropertyItemsALL_MASTERModifierInfoXI_QUERY_POINTER_REQUEST/// Opcode for the XIQueryPointer requestwin_xwin_ybuttons_len/// Get the value of the `buttons_len` field./// The `buttons_len` field is used as the length field of the `buttons` field.XI_WARP_POINTER_REQUEST/// Opcode for the XIWarpPointer requestsrc_windst_winXI_CHANGE_CURSOR_REQUEST/// Opcode for the XIChangeCursor requestHierarchyChangeTypeADD_MASTERREMOVE_MASTERATTACH_SLAVEDETACH_SLAVEChangeModeATTACHAddMasterRemoveMasterAttachSlaveDetachSlaveHierarchyChangeDataAddMasterHierarchyChangeDataRemoveMasterHierarchyChangeDataAttachSlaveHierarchyChangeDataDetachSlaveHierarchyChangeDataas_add_masteras_remove_masteras_attach_slaveas_detach_slaveXI_CHANGE_HIERARCHY_REQUEST/// Opcode for the XIChangeHierarchy request/// Clone all borrowed data in this XIChangeHierarchyRequest.XI_SET_CLIENT_POINTER_REQUEST/// Opcode for the XISetClientPointer requestXI_GET_CLIENT_POINTER_REQUEST/// Opcode for the XIGetClientPointer requestDEVICE_CHANGEDKEY_PRESSKEY_RELEASEBUTTON_RELEASELEAVEFOCUS_INFOCUS_OUTPROPERTYRAW_KEY_PRESSRAW_KEY_RELEASERAW_BUTTON_PRESSRAW_BUTTON_RELEASERAW_MOTIONTOUCH_BEGINTOUCH_UPDATETOUCH_ENDTOUCH_OWNERSHIPRAW_TOUCH_BEGINRAW_TOUCH_UPDATERAW_TOUCH_ENDBARRIER_HITBARRIER_LEAVE/// Get the value of the `mask_len` field./// The `mask_len` field is used as the length field of the `mask` field.XI_SELECT_EVENTS_REQUEST/// Opcode for the XISelectEvents request/// Clone all borrowed data in this XISelectEventsRequest.XI_QUERY_VERSION_REQUEST/// Opcode for the XIQueryVersion requestDeviceClassTypeSCROLLGESTUREMASTER_POINTERMASTER_KEYBOARDSLAVE_POINTERSLAVE_KEYBOARDFLOATING_SLAVEScrollFlagsNO_EMULATIONVERTICALHORIZONTALTouchModeDEPENDENTButtonClass/// Get the value of the `num_buttons` field./// The `num_buttons` field is used as the length field of the `labels` field./// Get the value of the `num_keys` field./// The `num_keys` field is used as the length field of the `keys` field.ScrollClassTouchClassGestureClassValuatorClassDeviceClassDataKeyDeviceClassDataButtonDeviceClassDataValuatorDeviceClassDataScrollDeviceClassDataTouchDeviceClassDataGestureDeviceClassDataas_scrollas_touchas_gestureXI_QUERY_DEVICE_REQUEST/// Opcode for the XIQueryDevice requestnum_infos/// Get the value of the `num_infos` field./// The `num_infos` field is used as the length field of the `infos` field.XI_SET_FOCUS_REQUEST/// Opcode for the XISetFocus requestXI_GET_FOCUS_REQUEST/// Opcode for the XIGetFocus requestNO_OWNERXI_GRAB_DEVICE_REQUEST/// Opcode for the XIGrabDevice requestpaired_device_mode/// Clone all borrowed data in this XIGrabDeviceRequest.XI_UNGRAB_DEVICE_REQUEST/// Opcode for the XIUngrabDevice requestASYNC_DEVICESYNC_DEVICEREPLAY_DEVICEASYNC_PAIRED_DEVICEASYNC_PAIRSYNC_PAIRACCEPT_TOUCHREJECT_TOUCHXI_ALLOW_EVENTS_REQUEST/// Opcode for the XIAllowEvents requestevent_modeKEYCODEGESTURE_PINCH_BEGINGESTURE_SWIPE_BEGINModifierMaskGrabModifierInfoXI_PASSIVE_GRAB_DEVICE_REQUEST/// Opcode for the XIPassiveGrabDevice requestgrab_typegrab_mode/// Clone all borrowed data in this XIPassiveGrabDeviceRequest.num_modifiers/// Get the value of the `num_modifiers` field./// The `num_modifiers` field is used as the length field of the `modifiers` field.XI_PASSIVE_UNGRAB_DEVICE_REQUEST/// Opcode for the XIPassiveUngrabDevice request/// Clone all borrowed data in this XIPassiveUngrabDeviceRequest.XI_LIST_PROPERTIES_REQUEST/// Opcode for the XIListProperties request/// Get the value of the `num_properties` field./// The `num_properties` field is used as the length field of the `properties` field.XI_CHANGE_PROPERTY_REQUEST/// Opcode for the XIChangeProperty request/// Clone all borrowed data in this XIChangePropertyRequest.XI_DELETE_PROPERTY_REQUEST/// Opcode for the XIDeleteProperty requestXI_GET_PROPERTY_REQUEST/// Opcode for the XIGetProperty requestXIGetPropertyItemsXI_GET_SELECTED_EVENTS_REQUEST/// Opcode for the XIGetSelectedEvents requestnum_masks/// Get the value of the `num_masks` field./// The `num_masks` field is used as the length field of the `masks` field.XI_BARRIER_RELEASE_POINTER_REQUEST/// Opcode for the XIBarrierReleasePointer requestbarriers/// Clone all borrowed data in this XIBarrierReleasePointerRequest.DEVICE_VALUATOR_EVENT/// Opcode for the DeviceValuator eventMoreEventsMaskMORE_EVENTSDEVICE_KEY_PRESS_EVENT/// Opcode for the DeviceKeyPress eventKeyButMaskDEVICE_KEY_RELEASE_EVENT/// Opcode for the DeviceKeyRelease eventDEVICE_BUTTON_PRESS_EVENT/// Opcode for the DeviceButtonPress eventDEVICE_BUTTON_RELEASE_EVENT/// Opcode for the DeviceButtonRelease eventDEVICE_MOTION_NOTIFY_EVENT/// Opcode for the DeviceMotionNotify eventDEVICE_FOCUS_IN_EVENT/// Opcode for the DeviceFocusIn eventNotifyDetailNotifyModeDEVICE_FOCUS_OUT_EVENT/// Opcode for the DeviceFocusOut eventPROXIMITY_IN_EVENT/// Opcode for the ProximityIn eventPROXIMITY_OUT_EVENT/// Opcode for the ProximityOut eventClassesReportedMaskREPORTING_VALUATORSREPORTING_BUTTONSREPORTING_KEYSDEVICE_STATE_NOTIFY_EVENT/// Opcode for the DeviceStateNotify eventclasses_reportedDEVICE_MAPPING_NOTIFY_EVENT/// Opcode for the DeviceMappingNotify eventChangeDeviceNEW_POINTERNEW_KEYBOARDCHANGE_DEVICE_NOTIFY_EVENT/// Opcode for the ChangeDeviceNotify eventDEVICE_KEY_STATE_NOTIFY_EVENT/// Opcode for the DeviceKeyStateNotify eventDEVICE_BUTTON_STATE_NOTIFY_EVENT/// Opcode for the DeviceButtonStateNotify eventDeviceChangeADDEDREMOVEDUNRECOVERABLECONTROL_CHANGEDDEVICE_PRESENCE_NOTIFY_EVENT/// Opcode for the DevicePresenceNotify eventdevchangeDEVICE_PROPERTY_NOTIFY_EVENT/// Opcode for the DevicePropertyNotify eventChangeReasonSLAVE_SWITCHDEVICE_CHANGEDEVICE_CHANGED_EVENT/// Opcode for the DeviceChanged eventKeyEventFlagsKEY_REPEATKEY_PRESS_EVENT/// Opcode for the KeyPress eventbutton_maskvaluator_mask/// The `buttons_len` field is used as the length field of the `button_mask` field.valuators_len/// Get the value of the `valuators_len` field./// The `valuators_len` field is used as the length field of the `valuator_mask` field.KEY_RELEASE_EVENT/// Opcode for the KeyRelease eventPointerEventFlagsPOINTER_EMULATEDBUTTON_PRESS_EVENT/// Opcode for the ButtonPress eventBUTTON_RELEASE_EVENT/// Opcode for the ButtonRelease eventMOTION_EVENT/// Opcode for the Motion eventGRABUNGRABWHILE_GRABBEDPASSIVE_GRABPASSIVE_UNGRABANCESTORVIRTUALINFERIORNONLINEARNONLINEAR_VIRTUALPOINTER_ROOTENTER_EVENT/// Opcode for the Enter eventLEAVE_EVENT/// Opcode for the Leave eventFOCUS_IN_EVENT/// Opcode for the FocusIn eventFOCUS_OUT_EVENT/// Opcode for the FocusOut eventHierarchyMaskMASTER_ADDEDMASTER_REMOVEDSLAVE_ADDEDSLAVE_REMOVEDSLAVE_ATTACHEDSLAVE_DETACHEDDEVICE_ENABLEDDEVICE_DISABLEDHierarchyInfoHIERARCHY_EVENT/// Opcode for the Hierarchy eventPropertyFlagPROPERTY_EVENT/// Opcode for the Property eventRAW_KEY_PRESS_EVENT/// Opcode for the RawKeyPress eventaxisvalues_rawRAW_KEY_RELEASE_EVENT/// Opcode for the RawKeyRelease eventRAW_BUTTON_PRESS_EVENT/// Opcode for the RawButtonPress eventRAW_BUTTON_RELEASE_EVENT/// Opcode for the RawButtonRelease eventRAW_MOTION_EVENT/// Opcode for the RawMotion eventTouchEventFlagsTOUCH_PENDING_ENDTOUCH_EMULATING_POINTERTOUCH_BEGIN_EVENT/// Opcode for the TouchBegin eventTOUCH_UPDATE_EVENT/// Opcode for the TouchUpdate eventTOUCH_END_EVENT/// Opcode for the TouchEnd eventTouchOwnershipFlagsTOUCH_OWNERSHIP_EVENT/// Opcode for the TouchOwnership eventRAW_TOUCH_BEGIN_EVENT/// Opcode for the RawTouchBegin eventRAW_TOUCH_UPDATE_EVENT/// Opcode for the RawTouchUpdate eventRAW_TOUCH_END_EVENT/// Opcode for the RawTouchEnd eventBarrierFlagsPOINTER_RELEASEDDEVICE_IS_GRABBEDBARRIER_HIT_EVENT/// Opcode for the BarrierHit eventBARRIER_LEAVE_EVENT/// Opcode for the BarrierLeave eventGesturePinchEventFlagsGESTURE_PINCH_CANCELLEDGESTURE_PINCH_BEGIN_EVENT/// Opcode for the GesturePinchBegin eventdelta_unaccel_xdelta_unaccel_ydelta_angleGESTURE_PINCH_UPDATE_EVENT/// Opcode for the GesturePinchUpdate eventGESTURE_PINCH_END_EVENT/// Opcode for the GesturePinchEnd eventGestureSwipeEventFlagsGESTURE_SWIPE_CANCELLEDGESTURE_SWIPE_BEGIN_EVENT/// Opcode for the GestureSwipeBegin eventGESTURE_SWIPE_UPDATE_EVENT/// Opcode for the GestureSwipeUpdate eventGESTURE_SWIPE_END_EVENT/// Opcode for the GestureSwipeEnd eventas_device_valuator_eventas_device_key_press_eventas_device_key_release_eventas_device_button_press_eventas_device_button_release_eventas_device_motion_notify_eventas_device_focus_in_eventas_device_focus_out_eventas_proximity_in_eventas_proximity_out_eventas_device_state_notify_eventas_device_mapping_notify_eventas_change_device_notify_eventas_device_key_state_notify_eventas_device_button_state_notify_eventas_device_presence_notify_eventas_device_property_notify_eventSEND_EXTENSION_EVENT_REQUEST/// Opcode for the SendExtensionEvent request/// Clone all borrowed data in this SendExtensionEventRequest.DEVICE_ERROR/// Opcode for the Device errorEVENT_ERROR/// Opcode for the Event errorMODE_ERROR/// Opcode for the Mode errorDEVICE_BUSY_ERROR/// Opcode for the DeviceBusy errorCLASS_ERROR/// Opcode for the Class errorMAX_LEGAL_KEY_CODEPER_KEY_BIT_ARRAY_SIZEKEY_NAME_LENGTHNEW_KEYBOARD_NOTIFYMAP_NOTIFYSTATE_NOTIFYCONTROLS_NOTIFYINDICATOR_STATE_NOTIFYINDICATOR_MAP_NOTIFYNAMES_NOTIFYCOMPAT_MAP_NOTIFYBELL_NOTIFYACTION_MESSAGEACCESS_X_NOTIFYEXTENSION_DEVICE_NOTIFYNKNDetailKEYCODESGEOMETRYAXNDetailSK_PRESSSK_ACCEPTSK_REJECTSK_RELEASEBK_ACCEPTBK_REJECTAXK_WARNINGKEY_TYPESKEY_SYMSEXPLICIT_COMPONENTSKEY_ACTIONSKEY_BEHAVIORSVIRTUAL_MODSVIRTUAL_MOD_MAPRESIZE_TYPESRECOMPUTE_ACTIONSMODIFIER_STATEMODIFIER_BASEMODIFIER_LATCHMODIFIER_LOCKGROUP_STATEGROUP_BASEGROUP_LATCHGROUP_LOCKCOMPAT_STATEGRAB_MODSCOMPAT_GRAB_MODSLOOKUP_MODSCOMPAT_LOOKUP_MODSPOINTER_BUTTONSREPEAT_KEYSSLOW_KEYSBOUNCE_KEYSSTICKY_KEYSMOUSE_KEYSMOUSE_KEYS_ACCELACCESS_X_KEYSACCESS_X_TIMEOUT_MASKACCESS_X_FEEDBACK_MASKAUDIBLE_BELL_MASKOVERLAY1_MASKOVERLAY2_MASKIGNORE_GROUP_LOCK_MASKGROUPS_WRAPINTERNAL_MODSIGNORE_LOCK_MODSPER_KEY_REPEATCONTROLS_ENABLEDSK_PRESS_FBSK_ACCEPT_FBFEATURE_FBSLOW_WARN_FBINDICATOR_FBSTICKY_KEYS_FBTWO_KEYSLATCH_TO_LOCKSK_RELEASE_FBSK_REJECT_FBBK_REJECT_FBDUMB_BELLLedClassResultKBD_FEEDBACK_CLASSLED_FEEDBACK_CLASSDFLT_XI_CLASSALL_XI_CLASSESLedClassSpecBellClassResultBELL_FEEDBACK_CLASSBellClassUSE_CORE_KBDUSE_CORE_PTRDFLT_XI_IDALL_XI_CLASSALL_XI_IDXI_NONEM3M4GROUP1GROUP2GROUP3GROUP4GroupsWrapWRAP_INTO_RANGECLAMP_INTO_RANGEREDIRECT_INTO_RANGEVModsHighM15M14M13M12M11M10M9M8VModsLowM7M6M5M0V_MOD_MAPBEHAVIORAUTO_REPEATINTERPRETKEY_TYPE4KEY_TYPE3KEY_TYPE2KEY_TYPE1SymInterpretMatchNONE_OFANY_OF_OR_NONEANY_OFALL_OFEXACTLYSymInterpMatchLEVEL_ONE_ONLYOP_MASKNO_AUTOMATICLED_DRIVES_KBUSE_COMPATUSE_EFFECTIVEUSE_LOCKEDUSE_LATCHEDUSE_BASEwhich_groupswhich_modsCMDetailSYM_INTERPGROUP_COMPATSYMBOLSPHYS_SYMBOLSCOMPATKEY_TYPE_NAMESKT_LEVEL_NAMESINDICATOR_NAMESKEY_NAMESKEY_ALIASESVIRTUAL_MOD_NAMESGROUP_NAMESRG_NAMESCOMPAT_MAPCLIENT_SYMBOLSSERVER_SYMBOLSINDICATOR_MAPSOTHER_NAMESKEYBOARDSBUTTON_ACTIONSINDICATOR_STATEDETECTABLE_AUTO_REPEATGRABS_USE_XKB_STATEAUTO_RESET_CONTROLSLOOKUP_STATE_WHEN_GRABBEDSEND_EVENT_USES_XKB_STATEKeyNameKeyAliasCountedString16/// The `length` field is used as the length field of the `string` field.mods_maskmods_modsmods_vmodsKTMapEntryhas_preserven_map_entries/// Get the value of the `nMapEntries` field./// The `nMapEntries` field is used as the length field of the `map` field.KeySymMapn_syms/// Get the value of the `nSyms` field./// The `nSyms` field is used as the length field of the `syms` field.CommonBehaviorDefaultBehaviorLockBehaviorRadioGroupBehaviorOverlayBehaviorPermamentLockBehaviorPermamentRadioGroupBehaviorPermamentOverlayBehaviorBehavioras_commonas_defaultas_lockas_radio_groupas_overlay1as_overlay2as_permament_lockas_permament_radio_groupas_permament_overlay1as_permament_overlay2BehaviorTypeRADIO_GROUPOVERLAY1OVERLAY2PERMAMENT_LOCKPERMAMENT_RADIO_GROUPPERMAMENT_OVERLAY1PERMAMENT_OVERLAY2behaviorSetBehaviorSetExplicitKeyModMapKeyVModMapvirtual_modsKTSetMapEntrypreserve_entriesSetKeyType/// The `nMapEntries` field is used as the length field of the `entries` field.corner_radius/// Get the value of the `nPoints` field./// The `nPoints` field is used as the length field of the `points` field.primary_ndxapprox_ndxoutlinesn_outlines/// Get the value of the `nOutlines` field./// The `nOutlines` field is used as the length field of the `outlines` field.shape_ndxcolor_ndxoverunderOverlayKeyrow_underOverlayRow/// Get the value of the `nKeys` field./// The `nKeys` field is used as the length field of the `keys` field./// Get the value of the `nRows` field./// The `nRows` field is used as the length field of the `rows` field.DoodadTypeOUTLINESOLIDINDICATORLOGOListingnames_presentmaps_presentBAD_DEVICEBAD_CLASSBAD_IDKEYBOARD_ERROR/// Opcode for the Keyboard errorCLEAR_LOCKSUSE_MOD_MAP_MODSGROUP_ABSOLUTESATypeNO_ACTIONSET_MODSLATCH_MODSLOCK_MODSSET_GROUPLATCH_GROUPLOCK_GROUPMOVE_PTRPTR_BTNLOCK_PTR_BTNSET_PTR_DFLTISO_LOCKSWITCH_SCREENSET_CONTROLSLOCK_CONTROLSREDIRECT_KEYDEVICE_BTNLOCK_DEVICE_BTNDEVICE_VALUATORSANoActionvmods_highvmods_lowSASetModsSALatchModsSALockModsSASetGroupSALatchGroupSALockGroupSAMovePtrFlagNO_ACCELERATIONMOVE_ABSOLUTE_XMOVE_ABSOLUTE_Yx_highx_lowy_highy_lowSAMovePtrSAPtrBtnSALockPtrBtnSASetPtrDfltFlagDFLT_BTN_ABSOLUTEAFFECT_DFLT_BUTTONaffectSASetPtrDfltSAIsoLockFlagNO_LOCKNO_UNLOCKISO_DFLT_IS_GROUPSAIsoLockNoAffectCTRLSMODSSAIsoLockSATerminateSwitchScreenFlagnew_screenSASwitchScreenBoolCtrlsHighACCESS_X_FEEDBACKAUDIBLE_BELLIGNORE_GROUP_LOCKBoolCtrlsLowACCESS_X_TIMEOUTbool_ctrls_highbool_ctrls_lowSASetControlsSALockControlsActionMessageFlagON_PRESSON_RELEASEGEN_KEY_EVENTSAActionMessagenewkeyreal_modifiersvmods_mask_highvmods_mask_lowSARedirectKeySADeviceBtnLockDeviceFlagsSALockDeviceBtnSAValWhatIGNORE_VALSET_VAL_MINSET_VAL_CENTERSET_VAL_MAXSET_VAL_RELATIVESET_VAL_ABSOLUTEval1whatval1indexval1valueval2whatval2indexval2valueSADeviceValuatorSIActionvirtual_modas_noactionas_setmodsas_latchmodsas_lockmodsas_setgroupas_latchgroupas_lockgroupas_moveptras_ptrbtnas_lockptrbtnas_setptrdfltas_isolockas_terminateas_switchscreenas_setcontrolsas_lockcontrolsas_redirectas_devbtnas_lockdevbtnas_devvalUSE_EXTENSION_REQUEST/// Opcode for the UseExtension requestwanted_majorwanted_minoraffect_new_keyboardnew_keyboard_detailsSelectEventsAuxNewKeyboardNotifyaffect_statestate_detailsSelectEventsAuxStateNotifyaffect_ctrlsctrl_detailsSelectEventsAuxControlsNotifyaffect_indicator_stateindicator_state_detailsSelectEventsAuxIndicatorStateNotifyaffect_indicator_mapindicator_map_detailsSelectEventsAuxIndicatorMapNotifyaffect_namesnames_detailsSelectEventsAuxNamesNotifyaffect_compatcompat_detailsSelectEventsAuxCompatMapNotifyaffect_bellbell_detailsSelectEventsAuxBellNotifyaffect_msg_detailsmsg_detailsSelectEventsAuxActionMessageaffect_access_xaccess_x_detailsSelectEventsAuxAccessXNotifyaffect_ext_devextdev_detailsSelectEventsAuxExtensionDeviceNotifynew_keyboard_notifystate_notifycontrols_notifyindicator_state_notifyindicator_map_notifynames_notifycompat_map_notifybell_notifyaction_messageaccess_x_notifyextension_device_notify/// Auxiliary and optional information for the `select_events` function/// Set the `new_keyboard_notify` field of this structure./// Set the `state_notify` field of this structure./// Set the `controls_notify` field of this structure./// Set the `indicator_state_notify` field of this structure./// Set the `indicator_map_notify` field of this structure./// Set the `names_notify` field of this structure./// Set the `compat_map_notify` field of this structure./// Set the `bell_notify` field of this structure./// Set the `action_message` field of this structure./// Set the `access_x_notify` field of this structure./// Set the `extension_device_notify` field of this structure.SELECT_EVENTS_REQUEST/// Opcode for the SelectEvents requestaffect_map/// Clone all borrowed data in this SelectEventsRequest.BELL_REQUEST/// Opcode for the Bell requestforce_soundptr_btn_stateLATCH_LOCK_STATE_REQUEST/// Opcode for the LatchLockState requestaffect_mod_locksmod_lockslock_groupgroup_lockaffect_mod_latcheslatch_groupgroup_latchGET_CONTROLS_REQUEST/// Opcode for the GetControls requestmouse_keys_dflt_btninternal_mods_maskignore_lock_mods_maskinternal_mods_real_modsignore_lock_mods_real_modsinternal_mods_vmodsignore_lock_mods_vmodsmouse_keys_delaymouse_keys_intervalmouse_keys_time_to_maxmouse_keys_max_speedmouse_keys_curveaccess_x_optionaccess_x_timeoutaccess_x_timeout_options_maskaccess_x_timeout_options_valuesaccess_x_timeout_maskaccess_x_timeout_valuesenabled_controlsSET_CONTROLS_REQUEST/// Opcode for the SetControls requestaffect_internal_real_modsinternal_real_modsaffect_ignore_lock_real_modsignore_lock_real_modsaffect_internal_virtual_modsinternal_virtual_modsaffect_ignore_lock_virtual_modsignore_lock_virtual_modsaccess_x_optionsaffect_enabled_controlschange_controls/// Clone all borrowed data in this SetControlsRequest.GET_MAP_REQUEST/// Opcode for the GetMap requestn_typesn_key_symsfirst_key_actionn_key_actionsfirst_key_behaviorn_key_behaviorsn_key_explicitfirst_mod_map_keyn_mod_map_keysfirst_v_mod_map_keyn_v_mod_map_keysacts_rtrn_countacts_rtrn_actsGetMapMapKeyActionstypes_rtrnsyms_rtrnkey_actionsbehaviors_rtrnvmods_rtrnexplicit_rtrnmodmap_rtrnvmodmap_rtrnGetMapMaptotal_typestotal_symstotal_actionstotal_key_behaviorstotal_key_explicittotal_mod_map_keystotal_v_mod_map_keysactions_countSetMapAuxKeyActionsvmodmap/// Auxiliary and optional information for the `set_map` function/// Set the `types` field of this structure./// Set the `syms` field of this structure./// Set the `key_actions` field of this structure./// Set the `behaviors` field of this structure./// Set the `vmods` field of this structure./// Set the `explicit` field of this structure./// Set the `modmap` field of this structure./// Set the `vmodmap` field of this structure.SET_MAP_REQUEST/// Opcode for the SetMap request/// Clone all borrowed data in this SetMapRequest.GET_COMPAT_MAP_REQUEST/// Opcode for the GetCompatMap requestget_all_sin_sigroups_rtrnfirst_si_rtrnn_total_sisi_rtrngroup_rtrnn_si_rtrn/// Get the value of the `nSIRtrn` field./// The `nSIRtrn` field is used as the length field of the `si_rtrn` field.SET_COMPAT_MAP_REQUEST/// Opcode for the SetCompatMap requestrecompute_actionstruncate_sigroup_maps/// Clone all borrowed data in this SetCompatMapRequest.GET_INDICATOR_STATE_REQUEST/// Opcode for the GetIndicatorState requestGET_INDICATOR_MAP_REQUEST/// Opcode for the GetIndicatorMap requestreal_indicatorsn_indicatorsSET_INDICATOR_MAP_REQUEST/// Opcode for the SetIndicatorMap request/// Clone all borrowed data in this SetIndicatorMapRequest.GET_NAMED_INDICATOR_REQUEST/// Opcode for the GetNamedIndicator requestreal_indicatorndxmap_flagsmap_which_groupsmap_groupsmap_which_modsmap_modsmap_real_modsmap_vmodmap_ctrlsSET_NAMED_INDICATOR_REQUEST/// Opcode for the SetNamedIndicator requestcreate_mapmap_vmodsGET_NAMES_REQUEST/// Opcode for the GetNames requestn_levels_per_typekt_level_namesGetNamesValueListKTLevelNameskeycodes_namegeometry_namesymbols_namephys_symbols_nametypes_namecompat_nameindicator_namesvirtual_mod_nameskey_namesradio_group_namesGetNamesValueListgroup_namesn_radio_groupsn_key_aliasesn_kt_levelsSetNamesAuxKTLevelNames/// Auxiliary and optional information for the `set_names` function/// Set the `keycodes_name` field of this structure./// Set the `geometry_name` field of this structure./// Set the `symbols_name` field of this structure./// Set the `phys_symbols_name` field of this structure./// Set the `types_name` field of this structure./// Set the `compat_name` field of this structure./// Set the `type_names` field of this structure./// Set the `kt_level_names` field of this structure./// Set the `indicator_names` field of this structure./// Set the `virtual_mod_names` field of this structure./// Set the `groups` field of this structure./// Set the `key_names` field of this structure./// Set the `key_aliases` field of this structure./// Set the `radio_group_names` field of this structure.SET_NAMES_REQUEST/// Opcode for the SetNames requestfirst_kt_levelttotal_kt_level_names/// Clone all borrowed data in this SetNamesRequest.PER_CLIENT_FLAGS_REQUEST/// Opcode for the PerClientFlags requestctrls_to_changeauto_ctrlsauto_ctrls_valuesLIST_COMPONENTS_REQUEST/// Opcode for the ListComponents requestmax_namescompat_mapsgeometriesn_keymaps/// Get the value of the `nKeymaps` field./// The `nKeymaps` field is used as the length field of the `keymaps` field.n_keycodes/// Get the value of the `nKeycodes` field./// The `nKeycodes` field is used as the length field of the `keycodes` field./// Get the value of the `nTypes` field./// The `nTypes` field is used as the length field of the `types` field.n_compat_maps/// Get the value of the `nCompatMaps` field./// The `nCompatMaps` field is used as the length field of the `compatMaps` field.n_symbols/// Get the value of the `nSymbols` field./// The `nSymbols` field is used as the length field of the `symbols` field.n_geometries/// Get the value of the `nGeometries` field./// The `nGeometries` field is used as the length field of the `geometries` field.GET_KBD_BY_NAME_REQUEST/// Opcode for the GetKbdByName requestneedGetKbdByNameRepliesTypesMapKeyActionsGetKbdByNameRepliesTypesMapgetmap_typetype_device_idgetmap_sequencegetmap_lengthtype_min_key_codetype_max_key_codeGetKbdByNameRepliesTypescompatmap_typecompat_device_idcompatmap_sequencecompatmap_lengthGetKbdByNameRepliesCompatMapindicatormap_typeindicator_device_idindicatormap_sequenceindicatormap_lengthGetKbdByNameRepliesIndicatorMaps/// Get the value of the `nIndicators` field./// The `nIndicators` field is used as the length field of the `maps` field.GetKbdByNameRepliesKeyNamesValueListKTLevelNamesGetKbdByNameRepliesKeyNamesValueListkeyname_typekey_device_idkeyname_sequencekeyname_lengthkey_min_key_codekey_max_key_codeGetKbdByNameRepliesKeyNamesgeometry_typegeometry_device_idgeometry_sequencegeometry_lengthgeometry_foundn_colorsn_shapesn_sectionsn_doodadsbase_color_ndxlabel_color_ndxlabel_fontGetKbdByNameRepliesGeometrycompat_mapindicator_mapsGetKbdByNameRepliesloadednew_keyboardreportedwantedall_buttonsfirst_buttonn_buttonsfirst_btn_wantedn_btns_wantedfirst_btn_rtrntotal_btnshas_own_statedflt_kbd_fbdflt_led_fbdev_typebtn_actionsledsn_device_led_f_bs/// Get the value of the `nDeviceLedFBs` field./// The `nDeviceLedFBs` field is used as the length field of the `leds` field.n_btns_rtrn/// Get the value of the `nBtnsRtrn` field./// The `nBtnsRtrn` field is used as the length field of the `btnActions` field./// Get the value of the `nameLen` field./// The `nameLen` field is used as the length field of the `name` field.SET_DEVICE_INFO_REQUEST/// Opcode for the SetDeviceInfo request/// Clone all borrowed data in this SetDeviceInfoRequest.SET_DEBUGGING_FLAGS_REQUEST/// Opcode for the SetDebuggingFlags requestaffect_flags/// Clone all borrowed data in this SetDebuggingFlagsRequest.current_ctrlssupported_flagssupported_ctrlsNEW_KEYBOARD_NOTIFY_EVENT/// Opcode for the NewKeyboardNotify eventold_device_idrequest_majorrequest_minorMAP_NOTIFY_EVENT/// Opcode for the MapNotify eventptr_btn_actionsn_key_actsn_key_behaviorSTATE_NOTIFY_EVENT/// Opcode for the StateNotify eventcompat_loockup_modsCONTROLS_NOTIFY_EVENT/// Opcode for the ControlsNotify eventchanged_controlsenabled_control_changesINDICATOR_STATE_NOTIFY_EVENT/// Opcode for the IndicatorStateNotify eventINDICATOR_MAP_NOTIFY_EVENT/// Opcode for the IndicatorMapNotify eventmap_changedNAMES_NOTIFY_EVENT/// Opcode for the NamesNotify eventfirst_level_namen_level_nameschanged_group_nameschanged_virtual_modsCOMPAT_MAP_NOTIFY_EVENT/// Opcode for the CompatMapNotify eventBELL_NOTIFY_EVENT/// Opcode for the BellNotify eventACTION_MESSAGE_EVENT/// Opcode for the ActionMessage eventACCESS_X_NOTIFY_EVENT/// Opcode for the AccessXNotify eventdetailtEXTENSION_DEVICE_NOTIFY_EVENT/// Opcode for the ExtensionDeviceNotify event/// Get the value of the `descLen` field./// The `descLen` field is used as the length field of the `description` field.GetDocFINISHEDSECOND_CONSUMEREvMaskNO_EVENT_MASKPRINT_MASKATTRIBUTE_MASKDetailSTART_JOB_NOTIFYEND_JOB_NOTIFYSTART_DOC_NOTIFYEND_DOC_NOTIFYSTART_PAGE_NOTIFYEND_PAGE_NOTIFYJOB_ATTRDOC_ATTRPAGE_ATTRPRINTER_ATTRSERVER_ATTRMEDIUM_ATTRSPOOLER_ATTRPRINT_QUERY_VERSION_REQUEST/// Opcode for the PrintQueryVersion requestPRINT_GET_PRINTER_LIST_REQUEST/// Opcode for the PrintGetPrinterList requestprinter_name/// Clone all borrowed data in this PrintGetPrinterListRequest.printerslist_count/// Get the value of the `listCount` field./// The `listCount` field is used as the length field of the `printers` field.PRINT_REHASH_PRINTER_LIST_REQUEST/// Opcode for the PrintRehashPrinterList requestPRINT_SET_CONTEXT_REQUEST/// Opcode for the PrintSetContext requestPRINT_GET_CONTEXT_REQUEST/// Opcode for the PrintGetContext requestPRINT_DESTROY_CONTEXT_REQUEST/// Opcode for the PrintDestroyContext requestPRINT_GET_SCREEN_OF_CONTEXT_REQUEST/// Opcode for the PrintGetScreenOfContext requestPRINT_START_JOB_REQUEST/// Opcode for the PrintStartJob requestoutput_modePRINT_END_JOB_REQUEST/// Opcode for the PrintEndJob requestPRINT_START_DOC_REQUEST/// Opcode for the PrintStartDoc requestdriver_modePRINT_END_DOC_REQUEST/// Opcode for the PrintEndDoc requestPRINT_PUT_DOCUMENT_DATA_REQUEST/// Opcode for the PrintPutDocumentData requestdoc_format/// Clone all borrowed data in this PrintPutDocumentDataRequest.PRINT_GET_DOCUMENT_DATA_REQUEST/// Opcode for the PrintGetDocumentData requestfinished_flag/// Get the value of the `dataLen` field./// The `dataLen` field is used as the length field of the `data` field.PRINT_START_PAGE_REQUEST/// Opcode for the PrintStartPage requestPRINT_END_PAGE_REQUEST/// Opcode for the PrintEndPage requestPRINT_SELECT_INPUT_REQUEST/// Opcode for the PrintSelectInput requestPRINT_INPUT_SELECTED_REQUEST/// Opcode for the PrintInputSelected requestall_events_maskPRINT_GET_ATTRIBUTES_REQUEST/// Opcode for the PrintGetAttributes request/// Get the value of the `stringLen` field./// The `stringLen` field is used as the length field of the `attributes` field.PRINT_GET_ONE_ATTRIBUTES_REQUEST/// Opcode for the PrintGetOneAttributes request/// Clone all borrowed data in this PrintGetOneAttributesRequest./// Get the value of the `valueLen` field./// The `valueLen` field is used as the length field of the `value` field.PRINT_SET_ATTRIBUTES_REQUEST/// Opcode for the PrintSetAttributes request/// Clone all borrowed data in this PrintSetAttributesRequest.PRINT_GET_PAGE_DIMENSIONS_REQUEST/// Opcode for the PrintGetPageDimensions requestreproducible_widthreproducible_heightPRINT_QUERY_SCREENS_REQUEST/// Opcode for the PrintQueryScreens request/// The `listCount` field is used as the length field of the `roots` field.PRINT_SET_IMAGE_RESOLUTION_REQUEST/// Opcode for the PrintSetImageResolution requestimage_resolutionprevious_resolutionsPRINT_GET_IMAGE_RESOLUTION_REQUEST/// Opcode for the PrintGetImageResolution requestATTRIBUT_NOTIFY_EVENT/// Opcode for the AttributNotify eventBAD_SEQUENCE_ERROR/// Opcode for the BadSequence errorKeycode32STATIC_GRAYGRAY_SCALESTATIC_COLORPSEUDO_COLORTRUE_COLORDIRECT_COLORbits_per_rgb_valuecolormap_entriesvisuals_len/// Get the value of the `visuals_len` field./// The `visuals_len` field is used as the length field of the `visuals` field.ENTER_WINDOWLEAVE_WINDOWPOINTER_MOTIONPOINTER_MOTION_HINTBUTTON1_MOTIONBUTTON2_MOTIONBUTTON3_MOTIONBUTTON4_MOTIONBUTTON5_MOTIONBUTTON_MOTIONKEYMAP_STATEEXPOSUREVISIBILITY_CHANGESTRUCTURE_NOTIFYRESIZE_REDIRECTSUBSTRUCTURE_NOTIFYSUBSTRUCTURE_REDIRECTFOCUS_CHANGEPROPERTY_CHANGECOLOR_MAP_CHANGEOWNER_GRAB_BUTTONNOT_USEFULWHEN_MAPPEDALWAYSdefault_colormapcurrent_input_maskswidth_in_pixelsheight_in_pixelsmin_installed_mapsmax_installed_mapsbacking_storesallowed_depthsallowed_depths_len/// Get the value of the `allowed_depths_len` field./// The `allowed_depths_len` field is used as the length field of the `allowed_depths` field.protocol_major_versionprotocol_minor_versionauthorization_protocol_nameauthorization_protocol_dataauthorization_protocol_name_len/// Get the value of the `authorization_protocol_name_len` field./// The `authorization_protocol_name_len` field is used as the length field of the `authorization_protocol_name` field.authorization_protocol_data_len/// Get the value of the `authorization_protocol_data_len` field./// The `authorization_protocol_data_len` field is used as the length field of the `authorization_protocol_data` field./// Get the value of the `reason_len` field./// The `reason_len` field is used as the length field of the `reason` field./// The `length` field is used as the length field of the `reason` field.LSB_FIRSTMSB_FIRSTrelease_numberresource_id_baseresource_id_maskmotion_buffer_sizeimage_byte_orderbitmap_format_bit_orderbitmap_format_scanline_unitbitmap_format_scanline_padpixmap_formatsvendor_len/// Get the value of the `vendor_len` field./// The `vendor_len` field is used as the length field of the `vendor` field.roots_len/// Get the value of the `roots_len` field./// The `roots_len` field is used as the length field of the `roots` field.pixmap_formats_len/// Get the value of the `pixmap_formats_len` field./// The `pixmap_formats_len` field is used as the length field of the `pixmap_formats` field.MOD1MOD2MOD3MOD4MOD5BUTTON1BUTTON2BUTTON3BUTTON4BUTTON5WindowEnum/// a key was pressed/released./// * `detail` - The keycode (a number representing a physical key on the keyboard) of the key/// which was pressed./// * `time` - Time when the event was generated (in milliseconds)./// * `root` - The root window of `child`./// * `same_screen` - Whether the `event` window is on the same screen as the `root` window./// * `event_x` - If `same_screen` is true, this is the X coordinate relative to the `event`/// window's origin. Otherwise, `event_x` will be set to zero./// * `event_y` - If `same_screen` is true, this is the Y coordinate relative to the `event`/// window's origin. Otherwise, `event_y` will be set to zero./// * `root_x` - The X coordinate of the pointer relative to the `root` window at the time of/// the event./// * `root_y` - The Y coordinate of the pointer relative to the `root` window at the time of/// * `state` - The logical state of the pointer buttons and modifier keys just prior to theButtonMask/// a mouse button was pressed/released.MOTION_NOTIFY_EVENT/// Opcode for the MotionNotify event/// a key was pressed.ENTER_NOTIFY_EVENT/// Opcode for the EnterNotify eventsame_screen_focus/// the pointer is in a different window./// * `event` - The window on which the event was generated./// * `child` - If the `event` window has subwindows and the final pointer position is in one/// of them, then `child` is set to that subwindow, `XCB_WINDOW_NONE` otherwise./// * `root` - The root window for the final cursor position./// * `root_x` - The pointer X coordinate relative to `root`'s origin at the time of the event./// * `root_y` - The pointer Y coordinate relative to `root`'s origin at the time of the event./// * `event_x` - If `event` is on the same screen as `root`, this is the pointer X coordinate/// relative to the event window's origin./// * `event_y` - If `event` is on the same screen as `root`, this is the pointer Y coordinateLEAVE_NOTIFY_EVENT/// Opcode for the LeaveNotify event/// NOT YET DOCUMENTED./// * `event` - The window on which the focus event was generated. This is the window used by/// the X server to report the event./// * `detail` -KEYMAP_NOTIFY_EVENT/// Opcode for the KeymapNotify eventEXPOSE_EVENT/// Opcode for the Expose event/// * `window` - The exposed (damaged) window./// * `x` - The X coordinate of the left-upper corner of the exposed rectangle, relative to/// the `window`'s origin./// * `y` - The Y coordinate of the left-upper corner of the exposed rectangle, relative to/// * `width` - The width of the exposed rectangle./// * `height` - The height of the exposed rectangle./// * `count` - The amount of `Expose` events following this one. Simple applications that do/// not want to optimize redisplay by distinguishing between subareas of its window/// can just ignore all Expose events with nonzero counts and perform full/// redisplays on events with zero counts.GRAPHICS_EXPOSURE_EVENT/// Opcode for the GraphicsExposure eventNO_EXPOSURE_EVENT/// Opcode for the NoExposure eventUNOBSCUREDPARTIALLY_OBSCUREDFULLY_OBSCUREDVISIBILITY_NOTIFY_EVENT/// Opcode for the VisibilityNotify eventCREATE_NOTIFY_EVENT/// Opcode for the CreateNotify eventDESTROY_NOTIFY_EVENT/// Opcode for the DestroyNotify event/// a window is destroyed./// * `event` - The reconfigured window or its parent, depending on whether `StructureNotify`/// or `SubstructureNotify` was selected./// * `window` - The window that is destroyed./// * `DestroyWindow`: requestUNMAP_NOTIFY_EVENT/// Opcode for the UnmapNotify event/// a window is unmapped./// * `window` - The window that was unmapped./// * `from_configure` - Set to 1 if the event was generated as a result of a resizing of the window's/// parent when `window` had a win_gravity of `UnmapGravity`./// a window was mapped./// * `event` - The window which was mapped or its parent, depending on whether/// `StructureNotify` or `SubstructureNotify` was selected./// * `window` - The window that was mapped./// * `override_redirect` - Window managers should ignore this window if `override_redirect` is 1.MAP_REQUEST_EVENT/// Opcode for the MapRequest event/// window wants to be mapped./// * `parent` - The parent of `window`./// * `window` - The window to be mapped.REPARENT_NOTIFY_EVENT/// Opcode for the ReparentNotify eventabove_sibling/// * `window` - The window whose size, position, border, and/or stacking order was changed./// * `above_sibling` - If `XCB_NONE`, the `window` is on the bottom of the stack with respect to/// sibling windows. However, if set to a sibling window, the `window` is placed on/// top of this sibling window./// * `x` - The X coordinate of the upper-left outside corner of `window`, relative to the/// parent window's origin./// * `y` - The Y coordinate of the upper-left outside corner of `window`, relative to the/// * `width` - The inside width of `window`, not including the border./// * `height` - The inside height of `window`, not including the border./// * `border_width` - The border width of `window`./// * `FreeColormap`: requestCONFIGURE_REQUEST_EVENT/// Opcode for the ConfigureRequest eventStackModeConfigWindowGRAVITY_NOTIFY_EVENT/// Opcode for the GravityNotify eventRESIZE_REQUEST_EVENT/// Opcode for the ResizeRequest eventPlace/// * `OnTop` - The window is now on top of all siblings./// * `OnBottom` - The window is now below all siblings.ON_TOPON_BOTTOMCIRCULATE_NOTIFY_EVENT/// Opcode for the CirculateNotify event/// * `event` - Either the restacked window or its parent, depending on whether/// * `window` - The restacked window./// * `place` -/// * `CirculateWindow`: requestCIRCULATE_REQUEST_EVENT/// Opcode for the CirculateRequest eventNEW_VALUEPROPERTY_NOTIFY_EVENT/// Opcode for the PropertyNotify event/// a window property changed./// * `window` - The window whose associated property was changed./// * `atom` - The property's atom, to indicate which property was changed./// * `time` - A timestamp of the server time when the property was changed./// * `state` -/// * `ChangeProperty`: requestSELECTION_CLEAR_EVENT/// Opcode for the SelectionClear eventARCCARDINALCUT_BUFFE_R0CUT_BUFFE_R1CUT_BUFFE_R2CUT_BUFFE_R3CUT_BUFFE_R4CUT_BUFFE_R5CUT_BUFFE_R6CUT_BUFFE_R7DRAWABLERECTANGLERESOURCE_MANAGERRGB_COLOR_MAPRGB_BEST_MAPRGB_BLUE_MAPRGB_DEFAULT_MAPRGB_GRAY_MAPRGB_GREEN_MAPRGB_RED_MAPVISUALIDWM_HINTSWM_ICON_NAMEWM_ICON_SIZEWM_NORMAL_HINTSWM_SIZE_HINTSWM_ZOOM_HINTSNORM_SPACEMAX_SPACEEND_SPACESUPERSCRIPT_XSUPERSCRIPT_YSUBSCRIPT_XSUBSCRIPT_YUNDERLINE_POSITIONUNDERLINE_THICKNESSSTRIKEOUT_ASCENTSTRIKEOUT_DESCENTITALIC_ANGLEX_HEIGHTQUAD_WIDTHPOINT_SIZECOPYRIGHTNOTICEFONT_NAMEFAMILY_NAMECAP_HEIGHTWM_CLASSWM_TRANSIENT_FORSELECTION_REQUEST_EVENT/// Opcode for the SelectionRequest eventColormapState/// * `Uninstalled` - The colormap was uninstalled./// * `Installed` - The colormap was installed.UNINSTALLEDINSTALLEDColormapEnumCOLORMAP_NOTIFY_EVENT/// Opcode for the ColormapNotify event/// the colormap for some window changed./// * `window` - The window whose associated colormap is changed, installed or uninstalled./// * `colormap` - The colormap which is changed, installed or uninstalled. This is `XCB_NONE`/// when the colormap is changed by a call to `FreeColormap`./// * `_new` - Indicates whether the colormap was changed (1) or installed/uninstalled (0).CLIENT_MESSAGE_EVENT/// Opcode for the ClientMessage event/// This event represents a ClientMessage, sent by another X11 client. An example/// is a client sending the `_NET_WM_STATE` ClientMessage to the root window/// to indicate the fullscreen window state, effectively requesting that the window/// manager puts it into fullscreen mode./// * `format` - Specifies how to interpret `data`. Can be either 8, 16 or 32./// * `type` - An atom which indicates how the data should be interpreted by the receiving/// * `data` - The data itself (20 bytes max)./// * `SendEvent`: request/// Create a new `ClientMessageEvent`./// This function simplifies the creation of a `ClientMessageEvent` by applying/// some useful defaults:/// - `response_type = CLIENT_MESSAGE_EVENT`/// - `sequence = 0`/// The other fields are set from the parameters given to this function.MODIFIERMAPPING_NOTIFY_EVENT/// Opcode for the MappingNotify event/// keyboard mapping changed./// * `request` -/// * `first_keycode` - The first number in the range of the altered mapping./// * `count` - The number of keycodes altered.GE_GENERIC_EVENT/// Opcode for the GeGeneric event/// generic event (with length)./// * `extension` - The major opcode of the extension creating this event/// * `length` - The amount (in 4-byte units) of data beyond 32 bytes/// * `evtype` - The extension-specific event typeREQUEST_ERROR/// Opcode for the Request errorVALUE_ERROR/// Opcode for the Value errorWINDOW_ERROR/// Opcode for the Window errorPIXMAP_ERROR/// Opcode for the Pixmap errorATOM_ERROR/// Opcode for the Atom errorCURSOR_ERROR/// Opcode for the Cursor errorFONT_ERROR/// Opcode for the Font errorMATCH_ERROR/// Opcode for the Match errorDRAWABLE_ERROR/// Opcode for the Drawable errorACCESS_ERROR/// Opcode for the Access errorALLOC_ERROR/// Opcode for the Alloc errorCOLORMAP_ERROR/// Opcode for the Colormap errorG_CONTEXT_ERROR/// Opcode for the GContext errorID_CHOICE_ERROR/// Opcode for the IDChoice errorNAME_ERROR/// Opcode for the Name errorLENGTH_ERROR/// Opcode for the Length errorIMPLEMENTATION_ERROR/// Opcode for the Implementation errorINPUT_OUTPUTINPUT_ONLY/// * `BackPixmap` - Overrides the default background-pixmap. The background pixmap and window must/// have the same root and same depth. Any size pixmap can be used, although some/// sizes may be faster than others./// If `XCB_BACK_PIXMAP_NONE` is specified, the window has no defined background./// The server may fill the contents with the previous screen contents or with/// contents of its own choosing./// If `XCB_BACK_PIXMAP_PARENT_RELATIVE` is specified, the parent's background is/// used, but the window must have the same depth as the parent (or a Match error/// results).   The parent's background is tracked, and the current version is/// used each time the window background is required./// * `BackPixel` - Overrides `BackPixmap`. A pixmap of undefined size filled with the specified/// background pixel is used for the background. Range-checking is not performed,/// the background pixel is truncated to the appropriate number of bits./// * `BorderPixmap` - Overrides the default border-pixmap. The border pixmap and window must have the/// same root and the same depth. Any size pixmap can be used, although some sizes/// may be faster than others./// The special value `XCB_COPY_FROM_PARENT` means the parent's border pixmap is/// copied (subsequent changes to the parent's border attribute do not affect the/// child), but the window must have the same depth as the parent./// * `BorderPixel` - Overrides `BorderPixmap`. A pixmap of undefined size filled with the specified/// border pixel is used for the border. Range checking is not performed on the/// border-pixel value, it is truncated to the appropriate number of bits./// * `BitGravity` - Defines which region of the window should be retained if the window is resized./// * `WinGravity` - Defines how the window should be repositioned if the parent is resized (see/// `ConfigureWindow`)./// * `BackingStore` - A backing-store of `WhenMapped` advises the server that maintaining contents of/// obscured regions when the window is mapped would be beneficial. A backing-store/// of `Always` advises the server that maintaining contents even when the window/// is unmapped would be beneficial. In this case, the server may generate an/// exposure event when the window is created. A value of `NotUseful` advises the/// server that maintaining contents is unnecessary, although a server may still/// choose to maintain contents while the window is mapped. Note that if the server/// maintains contents, then the server should maintain complete contents not just/// the region within the parent boundaries, even if the window is larger than its/// parent. While the server maintains contents, exposure events will not normally/// be generated, but the server may stop maintaining contents at any time./// * `BackingPlanes` - The backing-planes indicates (with bits set to 1) which bit planes of the/// window hold dynamic data that must be preserved in backing-stores and during/// save-unders./// * `BackingPixel` - The backing-pixel specifies what value to use in planes not covered by/// backing-planes. The server is free to save only the specified bit planes in the/// backing-store or save-under and regenerate the remaining planes with the/// specified pixel value. Any bits beyond the specified depth of the window in/// these values are simply ignored./// * `OverrideRedirect` - The override-redirect specifies whether map and configure requests on this/// window should override a SubstructureRedirect on the parent, typically to/// inform a window manager not to tamper with the window./// * `SaveUnder` - If 1, the server is advised that when this window is mapped, saving the/// contents of windows it obscures would be beneficial./// * `EventMask` - The event-mask defines which events the client is interested in for this window/// (or for some event types, inferiors of the window)./// * `DontPropagate` - The do-not-propagate-mask defines which events should not be propagated to/// ancestor windows when no client has the event type selected in this window./// * `Colormap` - The colormap specifies the colormap that best reflects the true colors of the window. Servers/// capable of supporting multiple hardware colormaps may use this information, and window man-/// agers may use it for InstallColormap requests. The colormap must have the same visual type/// and root as the window (or a Match error results). If CopyFromParent is specified, the parent's/// colormap is copied (subsequent changes to the parent's colormap attribute do not affect the child)./// However, the window must have the same visual type as the parent (or a Match error results),/// and the parent must not have a colormap of None (or a Match error results). For an explanation/// of None, see FreeColormap request. The colormap is copied by sharing the colormap object/// between the child and the parent, not by making a complete copy of the colormap contents./// * `Cursor` - If a cursor is specified, it will be used whenever the pointer is in the window. If None is speci-/// fied, the parent's cursor will be used when the pointer is in the window, and any change in the/// parent's cursor will cause an immediate change in the displayed cursor.BACK_PIXMAPBACK_PIXELBORDER_PIXMAPBORDER_PIXELBIT_GRAVITYBACKING_STOREBACKING_PLANESBACKING_PIXELOVERRIDE_REDIRECTSAVE_UNDEREVENT_MASKDONT_PROPAGATEBackPixmapPARENT_RELATIVEBIT_FORGETWIN_UNMAPNORTH_WESTNORTH_EASTSOUTH_WESTSOUTH_EASTSTATIC/// Auxiliary and optional information for the `create_window` functionwid/// Auxiliary and optional information for the `change_window_attributes` functionCHANGE_WINDOW_ATTRIBUTES_REQUEST/// Opcode for the ChangeWindowAttributes request/// Clone all borrowed data in this ChangeWindowAttributesRequest.MapStateUNMAPPEDUNVIEWABLEVIEWABLEGET_WINDOW_ATTRIBUTES_REQUEST/// Opcode for the GetWindowAttributes requestmap_is_installed/// * `visual` - The associated visual structure of `window`./// * `backing_planes` - Planes to be preserved if possible./// * `backing_pixel` - Value to be used when restoring planes./// * `save_under` - Boolean, should bits under be saved?/// * `colormap` - Color map to be associated with window./// * `all_event_masks` - Set of events all people have interest in./// * `your_event_mask` - My event mask./// * `do_not_propagate_mask` - Set of events that should not propagate./// * `backing_store` -/// * `bit_gravity` -/// * `win_gravity` -/// * `map_state` -DESTROY_WINDOW_REQUEST/// Opcode for the DestroyWindow requestDESTROY_SUBWINDOWS_REQUEST/// Opcode for the DestroySubwindows requestREPARENT_WINDOW_REQUEST/// Opcode for the ReparentWindow requestMAP_WINDOW_REQUEST/// Opcode for the MapWindow requestMAP_SUBWINDOWS_REQUEST/// Opcode for the MapSubwindows requestUNMAP_WINDOW_REQUEST/// Opcode for the UnmapWindow requestUNMAP_SUBWINDOWS_REQUEST/// Opcode for the UnmapSubwindows requestHEIGHTBORDER_WIDTHSIBLINGSTACK_MODETOP_IFBOTTOM_IFOPPOSITE/// Auxiliary and optional information for the `configure_window` function/// Set the `x` field of this structure./// Set the `y` field of this structure./// Set the `width` field of this structure./// Set the `height` field of this structure./// Set the `border_width` field of this structure./// Set the `sibling` field of this structure./// Set the `stack_mode` field of this structure.from_configure_request/// Construct from a [`ConfigureRequestEvent`]./// This function construct a new `ConfigureWindowAux` instance by accepting all requested/// changes from a `ConfigureRequestEvent`. This function is useful for window managers that want/// to handle `ConfigureRequestEvent`s.CONFIGURE_WINDOW_REQUEST/// Opcode for the ConfigureWindow request/// Clone all borrowed data in this ConfigureWindowRequest.RAISE_LOWESTLOWER_HIGHESTCIRCULATE_WINDOW_REQUEST/// Opcode for the CirculateWindow requestGET_GEOMETRY_REQUEST/// Opcode for the GetGeometry request/// * `root` - Root window of the screen containing `drawable`./// * `x` - The X coordinate of `drawable`. If `drawable` is a window, the coordinate/// specifies the upper-left outer corner relative to its parent's origin. If/// `drawable` is a pixmap, the X coordinate is always 0./// * `y` - The Y coordinate of `drawable`. If `drawable` is a window, the coordinate/// `drawable` is a pixmap, the Y coordinate is always 0./// * `width` - The width of `drawable`./// * `height` - The height of `drawable`./// * `border_width` - The border width (in pixels)./// * `depth` - The depth of the drawable (bits per pixel for the object).QUERY_TREE_REQUEST/// Opcode for the QueryTree request/// * `root` - The root window of `window`./// * `parent` - The parent window of `window`.children_len/// Get the value of the `children_len` field./// The `children_len` field is used as the length field of the `children` field.INTERN_ATOM_REQUEST/// Opcode for the InternAtom requestonly_if_exists/// Clone all borrowed data in this InternAtomRequest.GET_ATOM_NAME_REQUEST/// Opcode for the GetAtomName request/// * `Replace` - Discard the previous property value and store the new data./// * `Prepend` - Insert the new data before the beginning of existing data. The `format` must/// match existing property value. If the property is undefined, it is treated as/// defined with the correct type and format with zero-length data./// * `Append` - Insert the new data after the beginning of existing data. The `format` mustCHANGE_PROPERTY_REQUEST/// Opcode for the ChangeProperty request/// Clone all borrowed data in this ChangePropertyRequest.DELETE_PROPERTY_REQUEST/// Opcode for the DeleteProperty requestGetPropertyTypeGET_PROPERTY_REQUEST/// Opcode for the GetProperty requestvalue8/// Iterate over the contained value if its format is 8./// This function checks if the `format` member of the reply/// is 8. If it it is not, `None` is returned. Otherwise/// and iterator is returned that interprets the value in/// this reply as type `u8`./// Successfully iterate over the value:/// // First, we have to 'invent' a GetPropertyReply./// let reply = x11rb_protocol::protocol::xproto::GetPropertyReply {///     format: 8,///     sequence: 0,///     length: 0, // This value is incorrect///     type_: 0, // This value is incorrect///     bytes_after: 0,///     value_len: 4,///     value: vec![1, 2, 3, 4],/// // This is the actual example: Iterate over the value./// let mut iter = reply.value8().unwrap();/// An iterator is only returned when the `format` is correct./// The following example shows this.///     format: 42, // Not allowed in X11, but used for the example/// assert!(reply.value8().is_none());value16/// Iterate over the contained value if its format is 16./// is 16. If it it is not, `None` is returned. Otherwise/// this reply as type `u16`.///     format: 16,///     value: vec![1, 1, 2, 2],/// let mut iter = reply.value16().unwrap();/// assert_eq!(iter.next(), Some(257));/// assert_eq!(iter.next(), Some(514));/// assert!(reply.value16().is_none());value32/// Iterate over the contained value if its format is 32./// is 32. If it it is not, `None` is returned. Otherwise/// this reply as type `u32`.///     format: 32,///     value: vec![1, 2, 2, 1],/// let mut iter = reply.value32().unwrap();/// assert_eq!(iter.next(), Some(16908801));/// assert!(reply.value32().is_none());/// * `format` - Specifies whether the data should be viewed as a list of 8-bit, 16-bit, or/// 32-bit quantities. Possible values are 8, 16, and 32. This information allows/// * `type` - The actual type of the property (an atom)./// * `bytes_after` - The number of bytes remaining to be read in the property if a partial read was/// * `value_len` - The length of value. You should use the corresponding accessor instead of thisLIST_PROPERTIES_REQUEST/// Opcode for the ListProperties requestatoms_len/// Get the value of the `atoms_len` field./// The `atoms_len` field is used as the length field of the `atoms` field.SET_SELECTION_OWNER_REQUEST/// Opcode for the SetSelectionOwner requestGET_SELECTION_OWNER_REQUEST/// Opcode for the GetSelectionOwner request/// * `owner` - The current selection owner window.CONVERT_SELECTION_REQUEST/// Opcode for the ConvertSelection requestPOINTER_WINDOWITEM_FOCUSSEND_EVENT_REQUEST/// Opcode for the SendEvent request/// Clone all borrowed data in this SendEventRequest./// * `Sync` - The state of the keyboard appears to freeze: No further keyboard events are/// generated by the server until the grabbing client issues a releasing/// `AllowEvents` request or until the keyboard grab is released./// * `Async` - Keyboard event processing continues normally.ALREADY_GRABBEDNOT_VIEWABLEFROZENCursorEnumGRAB_POINTER_REQUEST/// Opcode for the GrabPointer requestpointer_modeconfine_toUNGRAB_POINTER_REQUEST/// Opcode for the UngrabPointer request/// * `Any` - Any of the following (or none):/// * `1` - The left mouse button./// * `2` - The right mouse button./// * `3` - The middle mouse button./// * `4` - Scroll wheel. TODO: direction?/// * `5` - Scroll wheel. TODO: direction?GRAB_BUTTON_REQUEST/// Opcode for the GrabButton requestUNGRAB_BUTTON_REQUEST/// Opcode for the UngrabButton requestCHANGE_ACTIVE_POINTER_GRAB_REQUEST/// Opcode for the ChangeActivePointerGrab requestGRAB_KEYBOARD_REQUEST/// Opcode for the GrabKeyboard requestUNGRAB_KEYBOARD_REQUEST/// Opcode for the UngrabKeyboard requestGRAB_KEY_REQUEST/// Opcode for the GrabKey requestUNGRAB_KEY_REQUEST/// Opcode for the UngrabKey request/// * `AsyncPointer` - For AsyncPointer, if the pointer is frozen by the client, pointer event/// processing continues normally. If the pointer is frozen twice by the client on/// behalf of two separate grabs, AsyncPointer thaws for both. AsyncPointer has no/// effect if the pointer is not frozen by the client, but the pointer need not be/// grabbed by the client./// TODO: rewrite this in more understandable terms./// * `SyncPointer` - For SyncPointer, if the pointer is frozen and actively grabbed by the client,/// pointer event processing continues normally until the next ButtonPress or/// ButtonRelease event is reported to the client, at which time the pointer again/// appears to freeze. However, if the reported event causes the pointer grab to be/// released, then the pointer does not freeze. SyncPointer has no effect if the/// pointer is not frozen by the client or if the pointer is not grabbed by the/// * `ReplayPointer` - For ReplayPointer, if the pointer is actively grabbed by the client and is/// frozen as the result of an event having been sent to the client (either from/// the activation of a GrabButton or from a previous AllowEvents with mode/// SyncPointer but not from a GrabPointer), then the pointer grab is released and/// that event is completely reprocessed, this time ignoring any passive grabs at/// or above (towards the root) the grab-window of the grab just released. The/// request has no effect if the pointer is not grabbed by the client or if the/// pointer is not frozen as the result of an event./// * `AsyncKeyboard` - For AsyncKeyboard, if the keyboard is frozen by the client, keyboard event/// processing continues normally. If the keyboard is frozen twice by the client on/// behalf of two separate grabs, AsyncKeyboard thaws for both. AsyncKeyboard has/// no effect if the keyboard is not frozen by the client, but the keyboard need/// not be grabbed by the client./// * `SyncKeyboard` - For SyncKeyboard, if the keyboard is frozen and actively grabbed by the client,/// keyboard event processing continues normally until the next KeyPress or/// KeyRelease event is reported to the client, at which time the keyboard again/// appears to freeze. However, if the reported event causes the keyboard grab to/// be released, then the keyboard does not freeze. SyncKeyboard has no effect if/// the keyboard is not frozen by the client or if the keyboard is not grabbed by/// the client./// * `ReplayKeyboard` - For ReplayKeyboard, if the keyboard is actively grabbed by the client and is/// the activation of a GrabKey or from a previous AllowEvents with mode/// SyncKeyboard but not from a GrabKeyboard), then the keyboard grab is released/// and that event is completely reprocessed, this time ignoring any passive grabs/// at or above (towards the root) the grab-window of the grab just released. The/// request has no effect if the keyboard is not grabbed by the client or if the/// keyboard is not frozen as the result of an event./// * `SyncBoth` - For SyncBoth, if both pointer and keyboard are frozen by the client, event/// processing (for both devices) continues normally until the next ButtonPress,/// ButtonRelease, KeyPress, or KeyRelease event is reported to the client for a/// grabbed device (button event for the pointer, key event for the keyboard), at/// which time the devices again appear to freeze. However, if the reported event/// causes the grab to be released, then the devices do not freeze (but if the/// other device is still grabbed, then a subsequent event for it will still cause/// both devices to freeze). SyncBoth has no effect unless both pointer and/// keyboard are frozen by the client. If the pointer or keyboard is frozen twice/// by the client on behalf of two separate grabs, SyncBoth thaws for both (but a/// subsequent freeze for SyncBoth will only freeze each device once)./// * `AsyncBoth` - For AsyncBoth, if the pointer and the keyboard are frozen by the client, event/// processing for both devices continues normally. If a device is frozen twice by/// the client on behalf of two separate grabs, AsyncBoth thaws for both. AsyncBoth/// has no effect unless both pointer and keyboard are frozen by the client.ASYNC_POINTERSYNC_POINTERREPLAY_POINTERASYNC_KEYBOARDSYNC_KEYBOARDREPLAY_KEYBOARDASYNC_BOTHSYNC_BOTHALLOW_EVENTS_REQUEST/// Opcode for the AllowEvents requestGRAB_SERVER_REQUEST/// Opcode for the GrabServer requestUNGRAB_SERVER_REQUEST/// Opcode for the UngrabServer requestQUERY_POINTER_REQUEST/// Opcode for the QueryPointer request/// * `same_screen` - If `same_screen` is False, then the pointer is not on the same screen as the/// argument window, `child` is None, and `win_x` and `win_y` are zero. If/// `same_screen` is True, then `win_x` and `win_y` are the pointer coordinates/// relative to the argument window's origin, and child is the child containing the/// pointer, if any./// * `root` - The root window the pointer is logically on./// * `child` - The child window containing the pointer, if any, if `same_screen` is true. If/// `same_screen` is false, `XCB_NONE` is returned./// * `root_x` - The pointer X position, relative to `root`./// * `root_y` - The pointer Y position, relative to `root`./// * `win_x` - The pointer X coordinate, relative to `child`, if `same_screen` is true. Zero/// * `win_y` - The pointer Y coordinate, relative to `child`, if `same_screen` is true. Zero/// * `mask` - The current logical state of the modifier keys and the buttons. Note that the/// logical state of a device (as seen by means of the protocol) may lag the/// physical state if device event processing is frozen.TimecoordGET_MOTION_EVENTS_REQUEST/// Opcode for the GetMotionEvents requestevents_len/// Get the value of the `events_len` field./// The `events_len` field is used as the length field of the `events` field.TRANSLATE_COORDINATES_REQUEST/// Opcode for the TranslateCoordinates requestsrc_windowdst_windowWARP_POINTER_REQUEST/// Opcode for the WarpPointer request/// * `None` - The focus reverts to `XCB_NONE`, so no window will have the input focus./// * `PointerRoot` - The focus reverts to `XCB_POINTER_ROOT` respectively. When the focus reverts,/// FocusIn and FocusOut events are generated, but the last-focus-change time is/// not changed./// * `Parent` - The focus reverts to the parent (or closest viewable ancestor) and the new/// revert_to value is `XCB_INPUT_FOCUS_NONE`./// * `FollowKeyboard` - NOT YET DOCUMENTED. Only relevant for the xinput extension.PARENTFOLLOW_KEYBOARDSET_INPUT_FOCUS_REQUEST/// Opcode for the SetInputFocus request/// Opcode for the GetInputFocus requestQUERY_KEYMAP_REQUEST/// Opcode for the QueryKeymap requestOPEN_FONT_REQUEST/// Opcode for the OpenFont request/// Clone all borrowed data in this OpenFontRequest.CLOSE_FONT_REQUEST/// Opcode for the CloseFont requestFontDrawLEFT_TO_RIGHTRIGHT_TO_LEFTFontpropleft_side_bearingright_side_bearingcharacter_widthCharinfoQUERY_FONT_REQUEST/// Opcode for the QueryFont requestdraw_directionfont_ascentfont_descentchar_infos/// * `min_bounds` - minimum bounds over all existing char/// * `max_bounds` - maximum bounds over all existing char/// * `min_char_or_byte2` - first character/// * `max_char_or_byte2` - last character/// * `default_char` - char to print for undefined character/// * `all_chars_exist` - flag if all characters have nonzero size/// * `font_ascent` - baseline to top edge of raster/// * `font_descent` - baseline to bottom edge of raster/// * `draw_direction` -properties_len/// Get the value of the `properties_len` field./// The `properties_len` field is used as the length field of the `properties` field.char_infos_len/// Get the value of the `char_infos_len` field./// The `char_infos_len` field is used as the length field of the `char_infos` field.QUERY_TEXT_EXTENTS_REQUEST/// Opcode for the QueryTextExtents request/// Clone all borrowed data in this QueryTextExtentsRequest.overall_ascentoverall_descentoverall_widthoverall_leftoverall_rightLIST_FONTS_REQUEST/// Opcode for the ListFonts request/// Clone all borrowed data in this ListFontsRequest.LIST_FONTS_WITH_INFO_REQUEST/// Opcode for the ListFontsWithInfo request/// Clone all borrowed data in this ListFontsWithInfoRequest.replies_hint/// * `replies_hint` - An indication of how many more fonts will be returned. This is only a hint and/// may be larger or smaller than the number of fonts actually returned. A zero/// value does not guarantee that no more fonts will be returned.SET_FONT_PATH_REQUEST/// Opcode for the SetFontPath request/// Clone all borrowed data in this SetFontPathRequest.GET_FONT_PATH_REQUEST/// Opcode for the GetFontPath request/// Get the value of the `path_len` field./// The `path_len` field is used as the length field of the `path` field.FREE_PIXMAP_REQUEST/// Opcode for the FreePixmap request/// * `Function` - TODO: Refer to GX/// * `PlaneMask` - In graphics operations, given a source and destination pixel, the result is/// computed bitwise on corresponding bits of the pixels; that is, a Boolean/// operation is performed in each bit plane. The plane-mask restricts the/// operation to a subset of planes, so the result is:/// ((src FUNC dst) AND plane-mask) OR (dst AND (NOT plane-mask))/// * `Foreground` - Foreground colorpixel./// * `Background` - Background colorpixel./// * `LineWidth` - The line-width is measured in pixels and can be greater than or equal to one, a wide line, or the/// special value zero, a thin line./// * `LineStyle` - The line-style defines which sections of a line are drawn:/// Solid                The full path of the line is drawn./// DoubleDash           The full path of the line is drawn, but the even dashes are filled differently/// than the odd dashes (see fill-style), with Butt cap-style used where even and/// odd dashes meet./// OnOffDash            Only the even dashes are drawn, and cap-style applies to all internal ends of/// the individual dashes (except NotLast is treated as Butt)./// * `CapStyle` - The cap-style defines how the endpoints of a path are drawn:/// NotLast    The result is equivalent to Butt, except that for a line-width of zero the final/// endpoint is not drawn./// Butt       The result is square at the endpoint (perpendicular to the slope of the line)/// with no projection beyond./// Round      The result is a circular arc with its diameter equal to the line-width, centered/// on the endpoint; it is equivalent to Butt for line-width zero./// Projecting The result is square at the end, but the path continues beyond the endpoint for/// a distance equal to half the line-width; it is equivalent to Butt for line-width/// * `JoinStyle` - The join-style defines how corners are drawn for wide lines:/// Miter               The outer edges of the two lines extend to meet at an angle. However, if the/// angle is less than 11 degrees, a Bevel join-style is used instead./// Round               The result is a circular arc with a diameter equal to the line-width, centered/// on the joinpoint./// Bevel               The result is Butt endpoint styles, and then the triangular notch is filled./// * `FillStyle` - The fill-style defines the contents of the source for line, text, and fill requests. For all text and fill/// requests (for example, PolyText8, PolyText16, PolyFillRectangle, FillPoly, and PolyFillArc)/// as well as for line requests with line-style Solid, (for example, PolyLine, PolySegment,/// PolyRectangle, PolyArc) and for the even dashes for line requests with line-style OnOffDash/// or DoubleDash:/// Solid                     Foreground/// Tiled                     Tile/// OpaqueStippled            A tile with the same width and height as stipple but with background/// everywhere stipple has a zero and with foreground everywhere stipple/// has a one/// Stippled                  Foreground masked by stipple/// For the odd dashes for line requests with line-style DoubleDash:/// Solid                     Background/// Tiled                     Same as for even dashes/// OpaqueStippled            Same as for even dashes/// Stippled                  Background masked by stipple/// * `FillRule` -/// * `Tile` - The tile/stipple represents an infinite two-dimensional plane with the tile/stipple replicated in all/// dimensions. When that plane is superimposed on the drawable for use in a graphics operation,/// the upper-left corner of some instance of the tile/stipple is at the coordinates within the drawable/// specified by the tile/stipple origin. The tile/stipple and clip origins are interpreted relative to the/// origin of whatever destination drawable is specified in a graphics request./// The tile pixmap must have the same root and depth as the gcontext (or a Match error results)./// The stipple pixmap must have depth one and must have the same root as the gcontext (or a/// Match error results). For fill-style Stippled (but not fill-style/// OpaqueStippled), the stipple pattern is tiled in a single plane and acts as an/// additional clip mask to be ANDed with the clip-mask./// Any size pixmap can be used for tiling or stippling, although some sizes may be faster to use than/// * `Stipple` - The tile/stipple represents an infinite two-dimensional plane with the tile/stipple replicated in all/// * `TileStippleOriginX` - TODO/// * `TileStippleOriginY` - TODO/// * `Font` - Which font to use for the `ImageText8` and `ImageText16` requests./// * `SubwindowMode` - For ClipByChildren, both source and destination windows are additionally/// clipped by all viewable InputOutput children. For IncludeInferiors, neither/// source nor destination window is/// clipped by inferiors. This will result in including subwindow contents in the source and drawing/// through subwindow boundaries of the destination. The use of IncludeInferiors with a source or/// destination window of one depth with mapped inferiors of differing depth is not illegal, but the/// semantics is undefined by the core protocol./// * `GraphicsExposures` - Whether ExposureEvents should be generated (1) or not (0)./// The default is 1./// * `ClipOriginX` - TODO/// * `ClipOriginY` - TODO/// * `ClipMask` - The clip-mask restricts writes to the destination drawable. Only pixels where the clip-mask has/// bits set to 1 are drawn. Pixels are not drawn outside the area covered by the clip-mask or where/// the clip-mask has bits set to 0. The clip-mask affects all graphics requests, but it does not clip/// sources. The clip-mask origin is interpreted relative to the origin of whatever destination drawable is specified in a graphics request. If a pixmap is specified as the clip-mask, it must have/// depth 1 and have the same root as the gcontext (or a Match error results). If clip-mask is None,/// then pixels are always drawn, regardless of the clip origin. The clip-mask can also be set with the/// SetClipRectangles request./// * `DashOffset` - TODO/// * `DashList` - TODO/// * `ArcMode` - TODOPLANE_MASKFOREGROUNDLINE_WIDTHLINE_STYLECAP_STYLEJOIN_STYLEFILL_STYLEFILL_RULESTIPPLETILE_STIPPLE_ORIGIN_XTILE_STIPPLE_ORIGIN_YGRAPHICS_EXPOSURESCLIP_ORIGIN_XCLIP_ORIGIN_YDASH_OFFSETDASH_LISTARC_MODEGXAND_REVERSEAND_INVERTEDNOOPNOREQUIVOR_REVERSECOPY_INVERTEDOR_INVERTEDNANDLineStyleON_OFF_DASHDOUBLE_DASHCapStyleNOT_LASTPROJECTINGJoinStyleFillStyleSTIPPLEDOPAQUE_STIPPLEDEVEN_ODDCLIP_BY_CHILDRENINCLUDE_INFERIORSArcModeCHORDPIE_SLICEtile_stipple_x_origintile_stipple_y_origin/// Auxiliary and optional information for the `create_gc` function/// Set the `function` field of this structure./// Set the `plane_mask` field of this structure./// Set the `foreground` field of this structure./// Set the `background` field of this structure./// Set the `line_width` field of this structure./// Set the `line_style` field of this structure./// Set the `cap_style` field of this structure./// Set the `join_style` field of this structure./// Set the `fill_style` field of this structure./// Set the `fill_rule` field of this structure./// Set the `tile` field of this structure./// Set the `stipple` field of this structure./// Set the `tile_stipple_x_origin` field of this structure./// Set the `tile_stipple_y_origin` field of this structure./// Set the `font` field of this structure./// Set the `subwindow_mode` field of this structure./// Set the `graphics_exposures` field of this structure./// Set the `clip_x_origin` field of this structure./// Set the `clip_y_origin` field of this structure./// Set the `clip_mask` field of this structure./// Set the `dash_offset` field of this structure./// Set the `dashes` field of this structure./// Set the `arc_mode` field of this structure.CREATE_GC_REQUEST/// Opcode for the CreateGC request/// Clone all borrowed data in this CreateGCRequest./// Auxiliary and optional information for the `change_gc` functionCHANGE_GC_REQUEST/// Opcode for the ChangeGC request/// Clone all borrowed data in this ChangeGCRequest.COPY_GC_REQUEST/// Opcode for the CopyGC requestsrc_gcdst_gcSET_DASHES_REQUEST/// Opcode for the SetDashes request/// Clone all borrowed data in this SetDashesRequest.UNSORTEDY_SORTEDYX_SORTEDYX_BANDEDSET_CLIP_RECTANGLES_REQUEST/// Opcode for the SetClipRectangles request/// Clone all borrowed data in this SetClipRectanglesRequest.FREE_GC_REQUEST/// Opcode for the FreeGC requestCLEAR_AREA_REQUEST/// Opcode for the ClearArea requestexposuresCOPY_AREA_REQUEST/// Opcode for the CopyArea requestsrc_drawabledst_drawableCOPY_PLANE_REQUEST/// Opcode for the CopyPlane requestbit_plane/// * `Origin` - Treats all coordinates as relative to the origin./// * `Previous` - Treats all coordinates after the first as relative to the previous coordinate.PREVIOUSPOLY_POINT_REQUEST/// Opcode for the PolyPoint requestcoordinate_mode/// Clone all borrowed data in this PolyPointRequest.POLY_LINE_REQUEST/// Opcode for the PolyLine request/// Clone all borrowed data in this PolyLineRequest.POLY_SEGMENT_REQUEST/// Opcode for the PolySegment request/// Clone all borrowed data in this PolySegmentRequest.POLY_RECTANGLE_REQUEST/// Opcode for the PolyRectangle request/// Clone all borrowed data in this PolyRectangleRequest.POLY_ARC_REQUEST/// Opcode for the PolyArc request/// Clone all borrowed data in this PolyArcRequest.NONCONVEXCONVEXFILL_POLY_REQUEST/// Opcode for the FillPoly request/// Clone all borrowed data in this FillPolyRequest.POLY_FILL_RECTANGLE_REQUEST/// Opcode for the PolyFillRectangle request/// Clone all borrowed data in this PolyFillRectangleRequest.POLY_FILL_ARC_REQUEST/// Opcode for the PolyFillArc request/// Clone all borrowed data in this PolyFillArcRequest.XY_BITMAPXY_PIXMAPZ_PIXMAPleft_pad/// Clone all borrowed data in this PutImageRequest.POLY_TEXT8_REQUEST/// Opcode for the PolyText8 request/// Clone all borrowed data in this PolyText8Request.POLY_TEXT16_REQUEST/// Opcode for the PolyText16 request/// Clone all borrowed data in this PolyText16Request.IMAGE_TEXT8_REQUEST/// Opcode for the ImageText8 request/// Clone all borrowed data in this ImageText8Request.IMAGE_TEXT16_REQUEST/// Opcode for the ImageText16 request/// Clone all borrowed data in this ImageText16Request.CREATE_COLORMAP_REQUEST/// Opcode for the CreateColormap requestFREE_COLORMAP_REQUEST/// Opcode for the FreeColormap requestCOPY_COLORMAP_AND_FREE_REQUEST/// Opcode for the CopyColormapAndFree requestsrc_cmapINSTALL_COLORMAP_REQUEST/// Opcode for the InstallColormap requestUNINSTALL_COLORMAP_REQUEST/// Opcode for the UninstallColormap requestLIST_INSTALLED_COLORMAPS_REQUEST/// Opcode for the ListInstalledColormaps requestcmapscmaps_len/// Get the value of the `cmaps_len` field./// The `cmaps_len` field is used as the length field of the `cmaps` field.ALLOC_COLOR_REQUEST/// Opcode for the AllocColor requestALLOC_NAMED_COLOR_REQUEST/// Opcode for the AllocNamedColor request/// Clone all borrowed data in this AllocNamedColorRequest.exact_redexact_greenexact_bluevisual_redvisual_greenvisual_blueALLOC_COLOR_CELLS_REQUEST/// Opcode for the AllocColorCells requestpixels_len/// Get the value of the `pixels_len` field./// The `pixels_len` field is used as the length field of the `pixels` field.masks_len/// Get the value of the `masks_len` field./// The `masks_len` field is used as the length field of the `masks` field.ALLOC_COLOR_PLANES_REQUEST/// Opcode for the AllocColorPlanes requestredsgreensbluesFREE_COLORS_REQUEST/// Opcode for the FreeColors request/// Clone all borrowed data in this FreeColorsRequest.STORE_COLORS_REQUEST/// Opcode for the StoreColors request/// Clone all borrowed data in this StoreColorsRequest.STORE_NAMED_COLOR_REQUEST/// Opcode for the StoreNamedColor request/// Clone all borrowed data in this StoreNamedColorRequest.QUERY_COLORS_REQUEST/// Opcode for the QueryColors request/// Clone all borrowed data in this QueryColorsRequest.colors_len/// Get the value of the `colors_len` field./// The `colors_len` field is used as the length field of the `colors` field.LOOKUP_COLOR_REQUEST/// Opcode for the LookupColor request/// Clone all borrowed data in this LookupColorRequest.PixmapEnumfore_redfore_greenfore_blueback_redback_greenback_blueFontEnumCREATE_GLYPH_CURSOR_REQUEST/// Opcode for the CreateGlyphCursor requestsource_fontmask_fontsource_charmask_charFREE_CURSOR_REQUEST/// Opcode for the FreeCursor requestRECOLOR_CURSOR_REQUEST/// Opcode for the RecolorCursor requestLARGEST_CURSORFASTEST_TILEFASTEST_STIPPLEQUERY_BEST_SIZE_REQUEST/// Opcode for the QueryBestSize request/// Opcode for the QueryExtension request/// Clone all borrowed data in this QueryExtensionRequest./// * `present` - Whether the extension is present on this X11 server./// * `major_opcode` - The major opcode for requests./// * `first_event` - The first event code, if any./// * `first_error` - The first error code, if any.LIST_EXTENSIONS_REQUEST/// Opcode for the ListExtensions requestCHANGE_KEYBOARD_MAPPING_REQUEST/// Opcode for the ChangeKeyboardMapping request/// Clone all borrowed data in this ChangeKeyboardMappingRequest.GET_KEYBOARD_MAPPING_REQUEST/// Opcode for the GetKeyboardMapping requestKBBELL_PERCENTBELL_PITCHBELL_DURATIONLedModeAutoRepeatMode/// Auxiliary and optional information for the `change_keyboard_control` function/// Set the `key_click_percent` field of this structure./// Set the `bell_percent` field of this structure./// Set the `bell_pitch` field of this structure./// Set the `bell_duration` field of this structure./// Set the `led` field of this structure./// Set the `led_mode` field of this structure./// Set the `key` field of this structure./// Set the `auto_repeat_mode` field of this structure.CHANGE_KEYBOARD_CONTROL_REQUEST/// Opcode for the ChangeKeyboardControl request/// Clone all borrowed data in this ChangeKeyboardControlRequest.GET_KEYBOARD_CONTROL_REQUEST/// Opcode for the GetKeyboardControl requestCHANGE_POINTER_CONTROL_REQUEST/// Opcode for the ChangePointerControl requestacceleration_numeratoracceleration_denominatordo_accelerationdo_thresholdGET_POINTER_CONTROL_REQUEST/// Opcode for the GetPointerControl requestNOT_PREFERREDNOT_ALLOWEDALLOWEDSET_SCREEN_SAVER_REQUEST/// Opcode for the SetScreenSaver requestprefer_blankingallow_exposuresGET_SCREEN_SAVER_REQUEST/// Opcode for the GetScreenSaver requestINTERNETDEC_NETCHAOSSERVER_INTERPRETEDINTERNET6CHANGE_HOSTS_REQUEST/// Opcode for the ChangeHosts request/// Clone all borrowed data in this ChangeHostsRequest.address_len/// Get the value of the `address_len` field./// The `address_len` field is used as the length field of the `address` field.LIST_HOSTS_REQUEST/// Opcode for the ListHosts requesthosts_len/// Get the value of the `hosts_len` field./// The `hosts_len` field is used as the length field of the `hosts` field.SET_ACCESS_CONTROL_REQUEST/// Opcode for the SetAccessControl requestDESTROY_ALLRETAIN_PERMANENTRETAIN_TEMPORARYSET_CLOSE_DOWN_MODE_REQUEST/// Opcode for the SetCloseDownMode requestALL_TEMPORARYKILL_CLIENT_REQUEST/// Opcode for the KillClient requestROTATE_PROPERTIES_REQUEST/// Opcode for the RotateProperties request/// Clone all borrowed data in this RotatePropertiesRequest.FORCE_SCREEN_SAVER_REQUEST/// Opcode for the ForceScreenSaver requestSET_POINTER_MAPPING_REQUEST/// Opcode for the SetPointerMapping request/// Clone all borrowed data in this SetPointerMappingRequest.GET_POINTER_MAPPING_REQUEST/// Opcode for the GetPointerMapping request/// Get the value of the `map_len` field./// The `map_len` field is used as the length field of the `map` field.MapIndexSET_MODIFIER_MAPPING_REQUEST/// Opcode for the SetModifierMapping request/// Clone all borrowed data in this SetModifierMappingRequest.GET_MODIFIER_MAPPING_REQUEST/// Opcode for the GetModifierMapping request/// The `keycodes_per_modifier` field is used as the length field of the `keycodes` field.NO_OPERATION_REQUEST/// Opcode for the NoOperation requestSET_DEVICE_CREATE_CONTEXT_REQUEST/// Opcode for the SetDeviceCreateContext request/// Clone all borrowed data in this SetDeviceCreateContextRequest.GET_DEVICE_CREATE_CONTEXT_REQUEST/// Opcode for the GetDeviceCreateContext requestcontext_len/// Get the value of the `context_len` field./// The `context_len` field is used as the length field of the `context` field.SET_DEVICE_CONTEXT_REQUEST/// Opcode for the SetDeviceContext request/// Clone all borrowed data in this SetDeviceContextRequest.GET_DEVICE_CONTEXT_REQUEST/// Opcode for the GetDeviceContext requestSET_WINDOW_CREATE_CONTEXT_REQUEST/// Opcode for the SetWindowCreateContext request/// Clone all borrowed data in this SetWindowCreateContextRequest.GET_WINDOW_CREATE_CONTEXT_REQUEST/// Opcode for the GetWindowCreateContext requestGET_WINDOW_CONTEXT_REQUEST/// Opcode for the GetWindowContext requestobject_contextdata_contextobject_context_len/// Get the value of the `object_context_len` field./// The `object_context_len` field is used as the length field of the `object_context` field.data_context_len/// Get the value of the `data_context_len` field./// The `data_context_len` field is used as the length field of the `data_context` field.SET_PROPERTY_CREATE_CONTEXT_REQUEST/// Opcode for the SetPropertyCreateContext request/// Clone all borrowed data in this SetPropertyCreateContextRequest.GET_PROPERTY_CREATE_CONTEXT_REQUEST/// Opcode for the GetPropertyCreateContext requestSET_PROPERTY_USE_CONTEXT_REQUEST/// Opcode for the SetPropertyUseContext request/// Clone all borrowed data in this SetPropertyUseContextRequest.GET_PROPERTY_USE_CONTEXT_REQUEST/// Opcode for the GetPropertyUseContext requestGET_PROPERTY_CONTEXT_REQUEST/// Opcode for the GetPropertyContext requestGET_PROPERTY_DATA_CONTEXT_REQUEST/// Opcode for the GetPropertyDataContext requestSET_SELECTION_CREATE_CONTEXT_REQUEST/// Opcode for the SetSelectionCreateContext request/// Clone all borrowed data in this SetSelectionCreateContextRequest.GET_SELECTION_CREATE_CONTEXT_REQUEST/// Opcode for the GetSelectionCreateContext requestSET_SELECTION_USE_CONTEXT_REQUEST/// Opcode for the SetSelectionUseContext request/// Clone all borrowed data in this SetSelectionUseContextRequest.GET_SELECTION_USE_CONTEXT_REQUEST/// Opcode for the GetSelectionUseContext requestGET_SELECTION_CONTEXT_REQUEST/// Opcode for the GetSelectionContext requestGET_SELECTION_DATA_CONTEXT_REQUEST/// Opcode for the GetSelectionDataContext requestLIST_SELECTIONS_REQUEST/// Opcode for the ListSelections requestselections_len/// Get the value of the `selections_len` field./// The `selections_len` field is used as the length field of the `selections` field.GET_CLIENT_CONTEXT_REQUEST/// Opcode for the GetClientContext requestCOMPARE_CURSOR_REQUEST/// Opcode for the CompareCursor requestsameFAKE_INPUT_REQUEST/// Opcode for the FakeInput requestGRAB_CONTROL_REQUEST/// Opcode for the GrabControl requestimperviousINPUT_MASKOUTPUT_MASKVIDEO_MASKSTILL_MASKIMAGE_MASKImageFormatInfoTypeImageFormatInfoFormatPACKEDPLANARAttributeFlagGETTABLESETTABLEVideoNotifyReasonSTARTEDPREEMPTEDHARD_ERRORScanlineOrderTOP_TO_BOTTOMBOTTOM_TO_TOPGrabPortStatusBAD_EXTENSIONBAD_REPLYBAD_ALLOCnum_portsAdaptorInfoname_size/// Get the value of the `name_size` field./// The `name_size` field is used as the length field of the `name` field.EncodingInfo/// Get the value of the `data_size` field./// The `data_size` field is used as the length field of the `data` field./// Get the value of the `num_planes` field./// The `num_planes` field is used as the length field of the `pitches` field./// The `size` field is used as the length field of the `name` field.y_sample_bitsu_sample_bitsv_sample_bitsvhorz_y_periodvhorz_u_periodvhorz_v_periodvvert_y_periodvvert_u_periodvvert_v_periodvcomp_ordervscanline_orderImageFormatInfoBAD_PORT_ERROR/// Opcode for the BadPort errorBAD_ENCODING_ERROR/// Opcode for the BadEncoding errorBAD_CONTROL_ERROR/// Opcode for the BadControl errorVIDEO_NOTIFY_EVENT/// Opcode for the VideoNotify eventPORT_NOTIFY_EVENT/// Opcode for the PortNotify eventQUERY_ADAPTORS_REQUEST/// Opcode for the QueryAdaptors requestnum_adaptors/// Get the value of the `num_adaptors` field./// The `num_adaptors` field is used as the length field of the `info` field.QUERY_ENCODINGS_REQUEST/// Opcode for the QueryEncodings requestnum_encodings/// Get the value of the `num_encodings` field./// The `num_encodings` field is used as the length field of the `info` field.GRAB_PORT_REQUEST/// Opcode for the GrabPort requestUNGRAB_PORT_REQUEST/// Opcode for the UngrabPort requestPUT_VIDEO_REQUEST/// Opcode for the PutVideo requestvid_xvid_yvid_wvid_hdrw_xdrw_ydrw_wdrw_hPUT_STILL_REQUEST/// Opcode for the PutStill requestGET_VIDEO_REQUEST/// Opcode for the GetVideo requestGET_STILL_REQUEST/// Opcode for the GetStill requestSTOP_VIDEO_REQUEST/// Opcode for the StopVideo requestSELECT_VIDEO_NOTIFY_REQUEST/// Opcode for the SelectVideoNotify requestSELECT_PORT_NOTIFY_REQUEST/// Opcode for the SelectPortNotify requestactual_widthactual_heightSET_PORT_ATTRIBUTE_REQUEST/// Opcode for the SetPortAttribute requestGET_PORT_ATTRIBUTE_REQUEST/// Opcode for the GetPortAttribute requestQUERY_PORT_ATTRIBUTES_REQUEST/// Opcode for the QueryPortAttributes requesttext_sizenum_attributes/// Get the value of the `num_attributes` field./// The `num_attributes` field is used as the length field of the `attributes` field.LIST_IMAGE_FORMATS_REQUEST/// Opcode for the ListImageFormats request/// The `num_formats` field is used as the length field of the `format` field.QUERY_IMAGE_ATTRIBUTES_REQUEST/// Opcode for the QueryImageAttributes requestSHM_PUT_IMAGE_REQUEST/// Opcode for the ShmPutImage requestsubpicture_max_widthsubpicture_max_heightmc_typeSurfaceInfoLIST_SURFACE_TYPES_REQUEST/// Opcode for the ListSurfaceTypes requestsurfaces/// Get the value of the `num` field./// The `num` field is used as the length field of the `surfaces` field.surface_idwidth_actualheight_actualflags_returnpriv_data/// The `length` field is used as the length field of the `priv_data` field.CREATE_SURFACE_REQUEST/// Opcode for the CreateSurface requestDESTROY_SURFACE_REQUEST/// Opcode for the DestroySurface requestCREATE_SUBPICTURE_REQUEST/// Opcode for the CreateSubpicture requestsubpicture_idxvimage_idnum_palette_entriesentry_bytescomponent_orderDESTROY_SUBPICTURE_REQUEST/// Opcode for the DestroySubpicture requestLIST_SUBPICTURE_TYPES_REQUEST/// Opcode for the ListSubpictureTypes request/// The `num` field is used as the length field of the `types` field./// Given two slices, produce an iterator that zips the two slices./// Compared to std::iter::Iterator::zip(), this iterator does not stop at the end of the/// shorter of the two slices, but instead continues to the end of the longer slice. To make/// this possible, the individual items are wrapped in `Option`./// See tests below to make this clearer.same_lengthfirst_shortersecond_shortertest_zip_longestHowMatched/// The component matched the instance of the query/// The component matched the class of the query/// The component is a wildcard and thus matched by default/// Info how a specific component was matched./// This information is used to decide which of two matches is "better" in `compare_matches()`.preceding_bindinghow_matchedMatchComponent/// Info on how an (unskipped) component of the query was matchedSkippedViaLooseBinding/// The component was skipped via a loose binding ("*")Matched/// The component was matched against the entry./// Info how a (possibly skipped) component of the query was matchednew_match/// Create a new `MatchKind::Match` with the given entries.check_matchcompare_matches/// Compare two matches and decide which one of the two is better (`Ordering::Greater`)match_entry/// Find the best match for the given query in the database, returning `None` when nothing matches.parse_databasetest_matches// Most tests in here are based on [1], which is: Copyright © 2016 Ingo Bürk// [1]: https://github.com/Airblader/xcb-util-xrm/blob/master/tests/tests_match.c//! Match Xrm entries against a query.MAX_INCLUSION_DEPTH/// Maximum nesting of #include directives, same value as Xlib uses./// After following this many `#include` directives, further includes are ignored.Tight/// We have a tight match, meaning that the next component of the entry must match the query.Loose/// We have a loose match, meaning that any number of components can be skipped before the next/// How tightly does the component of an entry match a query?/// A string component// Actually just a-z, A-Z, 0-9 and _ or - is allowed/// A wildcard component ("?") that matches anything/// A component of a database entry./// The components of the entry describe which queries it matches/// The value of the entry is what the caller gets after a match./// A single entry in the resource manager database.ATOM_RESOURCE_MANAGERATOM_STRINGconstants_are_correct// For GET_RESOURCE_DATABASE, we need Into::into() to use AtomEnum, but that is not const.// This module exists to work around that.work_around_constant_limitations/// A X11 resource database./// The recommended way to load a database is through [`Database::new_from_default`].GET_RESOURCE_DATABASE/// The GetPropertyRequest to load the X11 resource database from the root window./// Copy this struct, set its `window` field to the root window of the first screen send the/// resulting request to the X11 server. The reply can be passed to/// [`Self::new_from_default`]./// The `reply` argument should come from [`Self::GET_RESOURCE_DATABASE`] with its `window`/// field set to the window ID of the first root window. The `hostname` argument should be the/// hostname of the running system.///   [`Self::GET_RESOURCE_DATABASE`] and [`Self::new_from_get_property_reply`]).new_from_get_property_reply/// Construct a new X11 resource database from a [`GetPropertyReply`]./// The reply should come from [`Self::GET_RESOURCE_DATABASE`] with its `window` field set to/// the window ID of the first root window.new_from_data/// Construct a new X11 resource database from raw data./// This function parses data like `Some.Entry: Value\n#include "some_file"\n` and returns the/// resulting resource database. Parsing cannot fail since unparsable lines are simply ignored./// See [`Self::new_from_data_with_base_directory`] for a version that allows to provide a path that/// is used for resolving relative `#include` statements.new_from_data_with_base_directory/// When a relative `#include` statement is encountered, the file to include is searched/// relative to the given `base_path`./// Get a value from the resource database as a byte slice./// The given values describe a query to the resource database. `resource_class` can be an/// empty string, but otherwise must contain the same number of components as `resource_name`./// Both strings may only contain alphanumeric characters or '-', '_', and '.'./// For example, this is how Xterm could query one of its settings if it where written in Rust/// (see `man xterm`):/// use x11rb_protocol::resource_manager::Database;/// fn get_pointer_shape(db: &Database) -> &[u8] {///     db.get_bytes("XTerm.vt100.pointerShape", "XTerm.VT100.Cursor").unwrap_or(b"xterm")/// If an entry is found that is not a valid utf8 `str`, `None` is returned./// fn get_pointer_shape(db: &Database) -> &str {///     db.get_string("XTerm.vt100.pointerShape", "XTerm.VT100.Cursor").unwrap_or("xterm")/// This function interprets "true", "on", "yes" as true-ish and "false", "off", "no" als/// false-ish. Numbers are parsed and are true if they are not zero. Unknown values are mapped/// to `None`./// fn get_bell_is_urgent(db: &Database) -> bool {///     db.get_bool("XTerm.vt100.bellIsUrgent", "XTerm.VT100.BellIsUrgent").unwrap_or(false)/// Get a value from the resource database and parse it./// If no value is found, `Ok(None)` is returned. Otherwise, the result from/// [`FromStr::from_str]` is returned with `Ok(value)` replaced with `Ok(Some(value))`./// fn get_print_attributes(db: &Database) -> u8 {///     db.get_value("XTerm.vt100.printAttributes", "XTerm.VT100.PrintAttributes")///             .ok().flatten().unwrap_or(1)parse_data_with_base_directory/// Parse the given data as a resource database./// The parsed entries are appended to `result`. `#include`s are resolved relative to the given/// `base_path`. `depth` is the number of includes that we are already handling. This value is used/// to prevent endless loops when a file (directly or indirectly) includes itself./// Parse a value to a boolean, returning `None` if this is not possible.test_bool_truetest_bool_falsetest_bool_nonetest_parse_i32_failtest_parse_i32_success//! To open a database, it is recommended to use [`Database::new_from_default`], but that function//! needs to do I/O. A wrapper to simplify usage is e.g. provided in the x11rb crate.is_octal_digit/// Check if a character (well, u8) is an octal digitparse_with_matcher/// Find the longest prefix of the given data where the given callback returns trueallowed_in_quark_name/// Check if a character is allowed in a quark namenext_component/// Find the longest prefix satisfying allowed_in_quark_name()./// This returns (Some(prefix), remaining) if a prefix is found, else (None, data).skip_to_eol/// Skip to the next end of line in the given data/// Skip all spaces in the given dataskip_text/// Skip the given text. Returns `None` if the text was not foundnext_component_name/// Parse a single `Component` from the data. This can either be a wildcard ("?") or a/// component made up of characters accepted by `allowed_in_quark_name`.parse_components/// Parse a resource like "foo.?*baz" (wildcards allowed)/// Parse a full entry from the data. This begins with components (see `parse_components()`),/// then after a colon (":") comes the value. The value may contain escape sequences./// Parse the contents of a database/// Parse a resource query like "foo.bar.baz" (no wildcards allowed, no bindings allowed)test_parse_query_successtest_parse_query_errortest_parse_entry_successtest_parse_entry_errortest_parse_large_valuetest_parse_large_resourcetest_parse_databasetest_include_parsingtest_include_additionsrun_entry_test// [1]: https://github.com/Airblader/xcb-util-xrm/blob/master/tests/tests_parser.c//! Code for parsing resource management things// =======================// Common helper functions// =========================// Parser for resource filesExtInfoget_request_names/// Test whether request_name() and get_request_name() provide the correct information for the/// given request.test_core_request_namestest_bigreq_request_namestest_xc_misc_request_namestest_unknown_extension_request_names/// A simple wrapper around RawFd that closes the fd on drop./// On non-unix systems, this type is empty and does not provide/// any method./// Create a new `RawFdContainer` for the given `RawFd`./// The `RawFdContainer` takes ownership of the `RawFd` and closes it on drop./// Tries to clone the `RawFdContainer` creating a new FD/// with `dup`. The new `RawFdContainer` will take ownership/// of the `dup`ed version, whereas the original `RawFdContainer`/// will keep the ownership of its FD./// Get the `RawFd` out of this `RawFdContainer`./// This function would be an implementation of `IntoRawFd` if that were possible. However, it/// causes a conflict with an `impl` from libcore.../// Consumes the `RawFdContainer` and closes the wrapped FD with/// the `close` system call./// This is similar to dropping the `RawFdContainer`, but it allows/// the caller to handle errors.raw_fd_container/// A helper to pretty-print an enumeration value./// This function prints the given number. If it matches one of the provided variants, that/// match is used. Otherwise, the number is printed as a decimal./// In alternate mode, the second string in the given array is used, else the first./// A helper to pretty-print a bitmask./// This function prints the given number. All bit-matches with the given variants are printed./// Any left-over number is printed as a decimal.CallbackTypeCallbackFormatingnew_enumnew_bitmasktest_bitmaskpretty_printer//! # RawFdContainer//! [`RawFdContainer`] is a variant of [`std::os::unix::io::RawFd`] with ownership semantics. This//! means that the `RawFd` will be closed when the `RawFdContainer` is dropped.//! On non-`cfg(unix)`-systems, this is an empty type without methods. It still exists as a type so//! that it can appear in interfaces, but it is not actually possible to construct an instance of//! `RawFdContainer`.PropertyIterator/// Iterator implementation used by [GetPropertyReply]./// This is the actual type returned by [GetPropertyReply::value8], [GetPropertyReply::value16],/// and [GetPropertyReply::value32]. This type needs to be public due to Rust's visibility rules./// [GetPropertyReply]: crate::protocol::xproto::GetPropertyReply/// [GetPropertyReply::value8]: crate::protocol::xproto::GetPropertyReply::value8/// [GetPropertyReply::value16]: crate::protocol::xproto::GetPropertyReply::value16/// [GetPropertyReply::value32]: crate::protocol::xproto::GetPropertyReply::value32test_parse_u8test_parse_u32//! Helpers for the generated codeerror_kind/// The kind of error that occurred as it appears "on the wire"./// The sequence number of the request that caused this error.bad_value/// The value in the request that caused the error./// The minor opcode of the request that caused this error./// The major opcode of the request that caused this error.extension_name/// Name of the extension that caused this error, if known./// Name of the request that caused this error, if known./// Representation of an X11 error packet that was sent by the server./// Parse an X11 error.try_parse_errorreject_invalid_response_typetryparse_x11error_testtest_serialiseserialise_x11error_test/// Major opcode used in request/// Lowest event number used by the extension./// Lowest error number used by the extension./// Information about a X11 extension./// Returns the information of the extension that whose/// opcode is `major_opcode`./// event number range includes `event_number`./// error number range includes `error_number`./// Trait to provide information about extensions./// Try to parse the given values into an instance of this type./// If parsing is successful, an instance of the type and a slice for the remaining data should/// be returned. Otherwise, an error is returned./// A type implementing this trait can be parsed from some raw bytes./// File descriptors are consumed by removing them from the beginning of the given `fds` `Vec`./// If a file descriptor is expected, but missing, a `ParseError` should be returned. If more file/// descriptors are provided than expected, this is not an error and the remaining descriptors/// should be left in the `Vec`./// A type implementing this trait can be parsed from some raw bytes and a list of fds./// The major opcode of the request./// The minor opcode of the request (which, for some requests, may not be an/// opcode at all).remaining_length/// The remaining length of the request, measured in 4 bytes units. Unlike the wire format,/// this does *not* include the header itself, which is 1 unit (or 2 if BigRequests is/// enabled and the length in the first unit is zero). If the BigRequests extension is/// enabled this can be greater than u16::max_value - 1./// A representation of the header of a request./// The protocol name of the extension that this request belongs to, or None for core requests/// Serialize this request into its X11 protocol wire representation./// The argument is the major opcode of the extension that this request belongs to. For core/// requests, the argument may not have any influence/// A type implementing this trait is an X11 request./// A type alias for reply parsers (matches the signature of TryParseFd)./// A X11 request that does not have a reply/// The kind of reply that this request generates./// A X11 request that has a reply without FDs/// A X11 request that has a reply with FDs/// The value returned by `serialize`./// This should be `Vec<u8>` in most cases. However, arrays like `[u8; 4]` should also be/// allowed and thus this is an associated type./// If generic associated types were available, implementing `AsRef<[u8]>` would be required./// Serialize this value into X11 raw bytes./// Serialize this value into X11 raw bytes, appending the result into `bytes`./// When calling this method, the given vector must satisfy `assert_eq!(bytes.len() % 4, 0);`./// In words: Its length must be a multiple of four./// A type implementing this trait can be serialized into X11 raw bytes.implement_try_parseimplement_serializeforward_floattest_f32_round_tripstest_f64_round_tripstest_parse_known_valuetest_serialize_known_valuefloat_teststuple_try_parsetuple_serialize// We can optimise serialisation of empty tuples or one-element-tuples with different Bytes type/// Parse a list of objects from the given data./// This function parses a list of objects where the length of the list was specified externally./// The wire format for `list_length` instances of `T` will be read from the given data.parse_u8_list/// Parse a list of `u8` from the given data.parse_u8_array_ref/// Parse an array of `u8` from the given data.parse_u8_array// This macro is used by the generated code to implement e.g. `std::ops::BitOr` and// `std::ops::BitOrAssign`.try_to_usize/// Attempt the conversion/// Wrapper around TryInto that produces a ParseError./// This trait shortens `x.try_into().or(Err(ParseError::ConversionFailed))` to `x.try_to_usize()`./// The BigRequests extension has been enabled.NotEnabled/// The BigRequests extension has not been enabled./// Has the BigRequests extension been enabled?/// Parse the given input for a RequestHeader and the remaining input.//! Utility functions for X11 things.//! The most important definitions in this module are the [`TryParse`], [`TryParseFd`] and//! [`Serialize`] traits. These traits are used internally for parsing incoming data and producing//! outgoing data when talking with the X11 server.// Now implement TryParse and Serialize for some primitive data types that we need.// Tuple handlingX11FamilyMIT_MAGIC_COOKIE_1/// A family describes how to interpret some bytes as an address in an `AuthEntry`./// Compared to [`super::protocol::xproto::Family`], this is a `u16` and not an `u8` since/// that's what is used in `~/.Xauthority` files./// IPv4 connection to the server/// DECnet/// Chaosnet connection/// Family without predefined meaning, but interpreted by the server, for example a user name/// IPv6 connection to the serverWILD/// Wildcard matching any protocol familyLOCAL/// For local non-net authenticationNETNAME/// TODO: No idea what this means exactlyKRB5_PRINCIPAL/// Kerberos 5 principal nameLOCAL_HOST/// The protocol family to which the entry applies/// The address of the peer in a family-specific format/// The display number/// The name of the authentication method to use for the X11 server described by the previous/// Extra data for the authentication method.AuthEntry/// A single entry of an `.Xauthority` file./// Read a single `u16` from an `~/.Xauthority` file./// The file stores these entries in big endian./// Read a single "byte array" from an `~/.Xauthority` file./// The file stores these as a length field followed by a number of bytes that contain the/// actual data./// Read a single entry from an `~/.Xauthority` file./// This function tries to return `Ok(None)` when the end of the file is reached. However, the/// code also treats a single byte as 'end of file', because things were simpler to implement/// like this.get_xauthority_file_name/// Get the file name for `~/.Xauthority` based on environment variables./// The code in libXau contains a special case for Windows (looks like cygwin) that is not/// handled here (yet?).XAuthorityEntries/// An iterator over the entries of an `.Xauthority` file/// Open `~/.Xauthority` for reading./// This function returns `Ok(None)` when the location of the `.Xauthority` file could not/// be determined. If opening the file failed (for example, because it does not exist),/// that error is returned.test_read_iterate//! Code for actually reading `~/.Xauthority`.AuthInfo/// Get the authentication information necessary for connecting to the given display./// - `family` is the protocol family that is used for connecting; this describes how to interpret///   the `address`./// - `address` is the raw bytes describing the address that is being connected to./// - `display` is the display number./// If successful, this function returns that can be written to the X11 server as authorization/// protocol name and data, respectively.get_auth_implexpect_match// Call the given function on a matching auth entry. The function can change the entry.// Afterwards, it should still be a match.expect_mismatch// Afterwards, it should no longer match.direct_matchdisplay_wildcardaddress_wildcard_match1address_wildcard_match2family_mismatchaddress_mismatchnumber_mismatchprotocol_mismatch//! Helpers for working with `~/.Xauthority`.DisplayNotSet/// No explicit display was provided and the `$DISPLAY` environment variable is not set.MalformedValue/// The given value could not be parsed. The input to parsing is provided.NotUnicode/// The value of `$DISPLAY` is not valid unicode/// An unknown error occurred during display parsing./// An error that occurred while parsing the `$DISPLAY` environment variable//! ## Feature flags for specific X11 extensions//! By default, only the core X11 protocol and some small, commonly needed X11 extensions are//! ## Feature flags for additional functionality//! * `std` (enabled by default): Enable functionality needing the std library, e.g. environment//!   variables or [`std::os::unix::io::OwnedFd`].//! * `serde`: Implement [`serde::Serialize`] and [`serde::Deserialize`] for all objects.//! * `extra-traits`: Implement extra traits for types. This improves the output of the `Debug`/// This function is only available when the `std` feature is enabled.parse_display_with_file_exists_callback/// The parameter `file_exists` is called to check whether a given string refers to an existing/// file. This function does not need to check the file type.parse_display_direct_path// Check for "launchd mode" where we get the full path to a unix socketown_bad_casesmake_unix_pathtest_file_exists_callback_direct_pathtest_file_exists_callback_direct_path_with_screentest_file_exists_callback_not_called_without_pathimpl_debug_if_no_extra_traits/// * `maximum_request_length` - The maximum length of requests supported by the server, in 4-byte units./// The negotiated version of Composite./// This indicates the version of Composite chosen by the server.  It will always be/// less than or equal to the version offered by the client./// * `major_version` - The major version chosen by the server./// * `minor_version` - The minor version chosen by the server./// The negotiated version of the DAMAGE extension./// This indicates the version of the DAMAGE extension chosen by the server./// It will always be less than or equal to the version offered by the client./// the contents of the monitored drawable have changed./// * `level` - The level of the damage being reported./// If the 0x80 bit is set, indicates there are subsequent Damage events/// being delivered immediately as part of a larger Damage region./// * `drawable` - The drawable for which damage is being reported./// * `damage` - The Damage object being used to track the damage./// * `timestamp` - Time when the event was generated (in milliseconds)./// * `area` - Damaged area of the drawable./// * `geometry` - Total area of the drawable./// * `Create`: requestINFO_NOTIFYINFO_NOTIFY_EVENT/// Opcode for the InfoNotify eventInfoNotifyEventIMPORT_SYNCOBJ_REQUEST/// Opcode for the ImportSyncobj requestsyncobj_fdImportSyncobjRequestFREE_SYNCOBJ_REQUEST/// Opcode for the FreeSyncobj requestFreeSyncobjRequest// clippy::unnecessary_fallible_conversions is new in 1.75. TODO: Remove once our MSRV is high enough.// We use TryFrom in places where From could be used, but fixing this would make the code generator more complicatedASYNC_MAY_TEARSYNCOBJPIXMAP_SYNCED_REQUEST/// Opcode for the PixmapSynced requestacquire_syncobjrelease_syncobjacquire_pointrelease_pointPixmapSyncedRequest/// Clone all borrowed data in this PixmapSyncedRequest.r" Remove some flags."r" All bits that are set in the given flags are removed from the `self` instance, if"r" they are present."r" Returns the internal value of the object."/// Report that an XCB_SHM_PUT_IMAGE request has completed./// This is generated by the X server to report that an XCB_SHM_PUT_IMAGE request/// has been successfully processed./// * `drawable` - The drawable used in the XCB_SHM_PUT_IMAGE request./// * `minor_event` - The minor opcode used in the request.  Always XCB_SHM_PUT_IMAGE./// * `major_event` - The major opcode used in the request.  Always the opcode of the MIT-SHM/// * `shmseg` - The shared memory segment used in the request./// * `offset` - The offset in the shared memory segment used in the request./// The version of the MIT-SHM extension supported by the server./// This contains the version of the MIT-SHM extension supported by the server, as/// well as the server’s UID and GID.  Clients MUST obtain the version supproted by/// the server before making other requests from this extension.  To prevent local/// privilege escalation and local information leak security vulnerabilities,/// clients MUST ensure that System V shared memory objects they use with this/// extension can only be accessed by the client and the X server.  If this is not/// possible, the requests in this extension that use System V shared memory MUST/// NOT be used.  The file descriptor-passing versions provide an alternative./// * `shared_pixmaps` - True if the server supports shared pixmaps, otherwise false./// * `major_version` - The major version of the extension supported./// * `minor_version` - The minor version of the extension supported./// * `uid` - The UID of the server./// * `gid` - The GID of the server./// Indicates the result of the copy../// The result of the copy./// * `depth` - The depth of the source drawable./// * `visual` - The visual ID of the source drawable./// * `size` - The number of bytes copied./// The returned file descriptor../// The file descriptor returned by the server.  The client may call mmap() on it to/// map the memory allocated by the server./// * `nfd` - The number of file descriptors sent by the server.  Will always be 1./// * `Default` - The default behavior for regular clients: the X11 server won't terminate as long/// as such clients are still connected, and should this client disconnect, the/// server will continue running so long as other clients (that have not set/// XFixesClientDisconnectFlagTerminate) are connected./// * `Terminate` - Indicates to the X11 server that it can ignore the client and terminate itself/// even though the client is still connected to the X11 server./// Gets the disconnect mode for the client../// * `disconnect_mode` - The current disconnect mode./// A type representative of the file descriptors as they are sent to and from the X server./// On `cfg(unix)` platforms, this is a type alias for [`std::os::unix::io::OwnedFd`]. See the/// documentation for that type for more information on how it should be used. In most cases it/// can be cast into a [`File`] or [`UnixStream`], or otherwise downgraded into the actual/// underlying file descriptor./// On non-Unix platforms, this is an uninhabited type in the same vogue as [`Void`]. As handle/// passing is an undefined operation on non-Unix implementations of the X11 protocol, instances/// of this type cannot exist. No operations can be called on this type. If handle passing is ever/// added to any reference implementation of the X11 protocol, this type will be changed to/// something that can be used to represent the file descriptors./// Consumers of this type should be careful to check for `cfg(unix)` before using it in any/// meaningful way. Otherwise, the program will not compile on non-Unix platforms./// [`UnixStream`]: std::os::unix::net::UnixStream/// [`Void`]: https://docs.rs/void/latest/void/enum.Void.html// This file is part of x25519-dalek.// Copyright (c) 2017-2021 isis lovecruft// Copyright (c) 2019-2021 DebugSteven// - DebugSteven <debugsteven@gmail.com>// Refuse to compile if documentation is missing, but only on nightly.// This means that missing docs will still fail CI, but means we can use// README.md as the crate documentation.// x25519-dalek public API/// A Diffie-Hellman public key/// We implement `Zeroize` so that downstream consumers may derive it for `Drop`/// should they wish to erase public keys from memory.  Note that this erasure/// (in this crate) does *not* automatically happen, but either must be derived/// for Drop or explicitly called./// Given a byte array, construct a x25519 `PublicKey`./// Convert this public key to a byte array./// View this public key as a byte array./// A short-lived Diffie-Hellman secret key that can only be used to compute a single/// [`SharedSecret`]./// This type is identical to the `StaticSecret` type, except that the/// [`EphemeralSecret::diffie_hellman`] method consumes and then wipes the secret key, and there/// are no serialization methods defined.  This means that [`EphemeralSecret`]s can only be/// generated from fresh randomness where the compiler statically checks that the resulting/// secret is used at most once./// Perform a Diffie-Hellman key agreement between `self` and/// `their_public` key to produce a [`SharedSecret`]./// Generate a new [`EphemeralSecret`] with the supplied RNG.random_from_rng/// Given an x25519 [`EphemeralSecret`] key, compute its corresponding [`PublicKey`]./// A Diffie-Hellman secret key that can be used to compute multiple [`SharedSecret`]s./// This type is identical to the [`EphemeralSecret`] type, except that the/// [`StaticSecret::diffie_hellman`] method does not consume the secret key, and the type provides/// serialization methods to save and load key material.  This means that the secret may be used/// multiple times (but does not *have to be*)./// If you're uncertain about whether you should use this, then you likely/// should not be using this.  Our strongly recommended advice is to use/// [`EphemeralSecret`] at all times, as that type enforces at compile-time that/// secret keys are never reused, which can have very serious security/// implications for many protocols./// `their_public` key to produce a `SharedSecret`./// Generate a new [`StaticSecret`] with the supplied RNG./// Extract this key's bytes for serialization./// View this key as a byte array./// Load a secret key from a byte array./// Given an x25519 [`StaticSecret`] key, compute its corresponding [`PublicKey`]./// The result of a Diffie-Hellman key exchange./// Each party computes this using their [`EphemeralSecret`] or [`StaticSecret`] and their/// counterparty's [`PublicKey`]./// Convert this shared secret to a byte array./// View this shared secret key as a byte array.was_contributory/// Ensure in constant-time that this shared secret did not result from a/// key exchange with non-contributory behaviour./// In some more exotic protocols which need to guarantee "contributory"/// behaviour for both parties, that is, that each party contributed a public/// value which increased the security of the resulting shared secret./// To take an example protocol attack where this could lead to undesirable/// results [from Thái "thaidn" Dương](https://vnhacker.blogspot.com/2015/09/why-not-validating-curve25519-public.html):/// > If Mallory replaces Alice's and Bob's public keys with zero, which is/// > a valid Curve25519 public key, he would be able to force the ECDH/// > shared value to be zero, which is the encoding of the point at infinity,/// > and thus get to dictate some publicly known values as the shared/// > keys. It still requires an active man-in-the-middle attack to pull the/// > trick, after which, however, not only Mallory can decode Alice's data,/// > but everyone too! It is also impossible for Alice and Bob to detect the/// > intrusion, as they still share the same keys, and can communicate with/// > each other as normal./// The original Curve25519 specification argues that checks for/// non-contributory behaviour are "unnecessary for Diffie-Hellman"./// Whether this check is necessary for any particular given protocol is/// often a matter of debate, which we will not re-hash here, but simply/// cite some of the [relevant] [public] [discussions]./// Returns `true` if the key exchange was contributory (good), and `false`/// otherwise (can be bad for some protocols)./// [relevant]: https://tools.ietf.org/html/rfc7748#page-15/// [public]: https://vnhacker.blogspot.com/2015/09/why-not-validating-curve25519-public.html/// [discussions]: https://vnhacker.blogspot.com/2016/08/the-internet-of-broken-protocols.html/// The bare, byte-oriented x25519 function, exactly as specified in RFC7748./// This can be used with [`X25519_BASEPOINT_BYTES`] for people who/// cannot use the better, safer, and faster ephemeral DH API./// use rand_core::RngCore;/// use x25519_dalek::x25519;/// use x25519_dalek::StaticSecret;/// use x25519_dalek::PublicKey;/// // Generate Alice's key pair./// let alice_secret = StaticSecret::random_from_rng(&mut OsRng);/// let alice_public = PublicKey::from(&alice_secret);/// // Generate Bob's key pair./// let bob_secret = StaticSecret::random_from_rng(&mut OsRng);/// let bob_public = PublicKey::from(&bob_secret);/// // Alice and Bob should now exchange their public keys./// // Once they've done so, they may generate a shared secret./// let alice_shared = x25519(alice_secret.to_bytes(), bob_public.to_bytes());/// let bob_shared = x25519(bob_secret.to_bytes(), alice_public.to_bytes());/// assert_eq!(alice_shared, bob_shared);X25519_BASEPOINT_BYTES/// The X25519 basepoint, for use with the bare, byte-oriented x25519/// function.  This is provided for people who cannot use the typed/// DH API for some reason.//! x25519 Diffie-Hellman key exchange//! This implements x25519 key exchange as specified by Mike Hamburg//! and Adam Langley in [RFC7748](https://tools.ietf.org/html/rfc7748).X509ErrorX509ResultASN1Timeformat_serialparse_serialparse_signature_valueX509Versiontbs_certificateTbsCertificatesignature_value/// An X.509 v3 Certificate./// X.509 v3 certificates are defined in [RFC5280](https://tools.ietf.org/html/rfc5280), section/// 4.1. This object uses the same structure for content, so for ex the subject can be accessed/// using the path `x509.tbs_certificate.subject`./// `X509Certificate` also contains convenience methods to access the most common fields (subject,/// issuer, etc.). These are provided using `Deref<Target = TbsCertificate>`, so documentation for/// these methods can be found in the [`TbsCertificate`] object./// A `X509Certificate` is a zero-copy view over a buffer, so the lifetime is the same as the/// buffer containing the binary representation./// # use x509_parser::prelude::FromDer;/// # use x509_parser::certificate::X509Certificate;/// # static DER: &'static [u8] = include_bytes!("../assets/IGC_A.der");/// fn display_x509_info(x509: &X509Certificate<'_>) {///      let subject = x509.subject();///      let issuer = x509.issuer();///      println!("X.509 Subject: {}", subject);///      println!("X.509 Issuer: {}", issuer);///      println!("X.509 serial: {}", x509.tbs_certificate.raw_serial_as_string());/// # let res = X509Certificate::from_der(DER);/// #     Ok((_rem, x509)) => {/// #         display_x509_info(&x509);/// #     _ => panic!("x509 parsing failed: {:?}", res),/// Verify the cryptographic signature of this certificate/// `public_key` is the public key of the **signer**. For a self-signed certificate,/// (for ex. a public root certificate authority), this is the key from the certificate,/// so you can use `None`./// For a leaf certificate, this is the public key of the certificate that signed it./// It is usually an intermediate authority./// Not all algorithms are supported, this function is limited to what `ring` supports./// Parse a DER-encoded X.509 Certificate, and return the remaining of the input and the built/// The returned object uses zero-copy, and so has the same lifetime as the input./// Note that only parsing is done, not validation./// Certificate  ::=  SEQUENCE  {///         tbsCertificate       TBSCertificate,///         signatureAlgorithm   AlgorithmIdentifier,///         signatureValue       BIT STRING  }/// To parse a certificate and print the subject and issuer:/// # use x509_parser::parse_x509_certificate;/// let res = parse_x509_certificate(DER);/// match res {///     Ok((_rem, x509)) => {///         let subject = x509.subject();///         let issuer = x509.issuer();///         println!("X.509 Subject: {}", subject);///         println!("X.509 Issuer: {}", issuer);///     _ => panic!("x509 parsing failed: {:?}", res),deep_parse_extensions// strict: bool,X509CertificateParser/// X.509 Certificate parser/// This object is a parser builder, and allows specifying parsing options./// Currently, the only option is to control deep parsing of X.509v3 extensions:/// a parser can decide to skip deep-parsing to be faster (the structure of extensions is still/// parsed, and the contents can be parsed later using the [`from_der`](FromDer::from_der)/// method from individual extension objects)./// This object uses the `nom::Parser` trait, which must be imported./// To parse a certificate without parsing extensions:/// use x509_parser::certificate::X509CertificateParser;/// use x509_parser::nom::Parser;/// // create a parser that will not parse extensions/// let mut parser = X509CertificateParser::new()///     .with_deep_parse_extensions(false);/// let res = parser.parse(DER);with_deep_parse_extensionsValiditysubject_pkiissuer_uidUniqueIdentifiersubject_uidraw_serial/// The sequence `TBSCertificate` contains information associated with the/// subject of the certificate and the CA that issued it./// RFC5280 definition:///   TBSCertificate  ::=  SEQUENCE  {///        version         [0]  EXPLICIT Version DEFAULT v1,///        serialNumber         CertificateSerialNumber,///        signature            AlgorithmIdentifier,///        issuer               Name,///        validity             Validity,///        subject              Name,///        subjectPublicKeyInfo SubjectPublicKeyInfo,///        issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL,///                             -- If present, version MUST be v2 or v3///        subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL,///        extensions      [3]  EXPLICIT Extensions OPTIONAL///                             -- If present, version MUST be v3/// Get the version of the encoded certificate/// Get the certificate subject./// Get the certificate issuer./// Get the certificate validity./// Get the certificate public key information./// Returns the certificate extensionsiter_extensions/// Returns an iterator over the certificate extensionsget_extension_unique/// Searches for an extension with the given `Oid`./// Return `Ok(Some(extension))` if exactly one was found, `Ok(None)` if none was found,/// or an error `DuplicateExtensions` if the extension is present twice or more./// ## Duplicate extensions/// Note: if there are several extensions with the same `Oid`, the first one is returned, masking other values./// RFC5280 forbids having duplicate extensions, but does not specify how errors should be handled./// **Because of this, the `find_extension` method is not safe and should not be used!**/// The [`get_extension_unique`](Self::get_extension_unique) method checks for duplicate extensions and should beextensions_map/// Builds and returns a map of extensions./// If an extension is present twice, this will fail and return `DuplicateExtensions`.BasicExtension/// Attempt to get the certificate Basic Constraints extension/// or an error if the extension is present twice or more./// Attempt to get the certificate Key Usage extension/// or an error if the extension is invalid, or is present twice or more.extended_key_usage/// Attempt to get the certificate Extended Key Usage extensionpolicy_constraintsPolicyConstraints/// Attempt to get the certificate Policy Constraints extensioninhibit_anypolicyInhibitAnyPolicypolicy_mappingsPolicyMappings/// Attempt to get the certificate Policy Mappings extensionsubject_alternative_name/// Attempt to get the certificate Subject Alternative Name extension/// Attempt to get the certificate Name Constraints extension/// Returns true if certificate has `basicConstraints CA:true`/// Get the raw bytes of the certificate serial numberraw_serial_as_string/// Get a formatted string of the certificate serial number, separated by ':'/// Note: if there are several extensions with the same `Oid`, an error `DuplicateExtensions` is returned./// Parse a DER-encoded TbsCertificate object/// TBSCertificate  ::=  SEQUENCE  {///      version         [0]  Version DEFAULT v1,///      serialNumber         CertificateSerialNumber,///      signature            AlgorithmIdentifier,///      issuer               Name,///      validity             Validity,///      subject              Name,///      subjectPublicKeyInfo SubjectPublicKeyInfo,///      issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL,///                           -- If present, version MUST be v2 or v3///      subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL,///      extensions      [3]  Extensions OPTIONAL///                           -- If present, version MUST be v3 --  }TbsCertificateParser/// `TbsCertificate` parser builder/// Basic extension structure, used in search resultstime_to_expiration/// The time left before the certificate expires./// If the certificate is not currently valid, then `None` is/// returned.  Otherwise, the `Duration` until the certificate/// expires is returned.is_valid_at/// Check the certificate time validity for the provided date/time/// Check the certificate time validityfrom_der_issuer// issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONALfrom_der_subject// subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL// Parse a [tag] UniqueIdentifier OPTIONAL// UniqueIdentifier  ::=  BIT STRINGcheck_validity_expirationextension_duplication//! X.509 Certificate object definitions and operationscri_attributescertification_request_infoX509CertificationRequestInfoX509CertificationRequest/// Certification Signing Request (CSR)requested_extensionsParsedExtension/// Verify the cryptographic signature of this certification request/// Uses the public key contained in the CSR, which must be the one of the entity/// requesting the certification for this verification to succeed./// CertificationRequest ::= SEQUENCE {///     certificationRequestInfo CertificationRequestInfo,///     signatureAlgorithm AlgorithmIdentifier{{ SignatureAlgorithms }},///     signature          BIT STRINGX509CriAttribute/// Certification Request Info structure/// Certification request information is defined by the following ASN.1 structure:/// CertificationRequestInfo ::= SEQUENCE {///      version       INTEGER { v1(0) } (v1,...),///      subject       Name,///      subjectPKInfo SubjectPublicKeyInfo{{ PKInfoAlgorithms }},///      attributes    [0] Attributes{{ CRIAttributes }}/// version is the version number; subject is the distinguished name of the certificate/// subject; subject_pki contains information about the public key being certified, and/// attributes is a collection of attributes providing additional information about the/// subject of the certificate./// Get the CRL entry extensions.iter_attributes/// Returns an iterator over the CRL entry extensions/// Searches for a CRL entry extension with the given `Oid`./// Note: if there are several extensions with the same `Oid`, the first one is returned.attributes_map/// Builds and returns a map of CRL entry extensions.parsed_attributeParsedCriAttribute/// Attributes for Certification Request/// Return the attribute type or `UnsupportedAttribute` if the attribute is unknown.ExtensionRequest/// Section 3.1 of rfc 5272ChallengePasswordUnsupportedAttributeAttrParserATTRIBUTE_PARSERS// look into the parser map if the extension is known, and parse it// otherwise, leave it as UnsupportedExtensionparse_extension_requestparse_extension_request_attrparse_challenge_password// RFC 2985, 5.4.1 Challenge password//    challengePassword ATTRIBUTE ::= {//            WITH SYNTAX DirectoryString {pkcs-9-ub-challengePassword}//            EQUALITY MATCHING RULE caseExactMatch//            SINGLE VALUE TRUE//            ID pkcs-9-at-challengePassword// RFC 5280, 4.1.2.4.  Issuer//    DirectoryString ::= CHOICE {//          teletexString           TeletexString (SIZE (1..MAX)),//          printableString         PrintableString (SIZE (1..MAX)),//          universalString         UniversalString (SIZE (1..MAX)),//          utf8String              UTF8String (SIZE (1..MAX)),//          bmpString               BMPString (SIZE (1..MAX))parse_challenge_password_attrparse_cri_attributesNidError/// An error that can occur while converting an OID to a Nid./// Holds the result of parsing functions (X.509)InvalidAlgorithmIdentifierInvalidX509NameInvalidDateInvalidSPKIInvalidSubjectUIDInvalidIssuerUIDInvalidExtensionsInvalidAttributesDuplicateExtensionsDuplicateAttributesInvalidSignatureValueInvalidTbsCertificateInvalidUserCertificate// error types from CRL/// Top-level certificate structure is invalidSignatureVerificationErrorSignatureUnsupportedAlgorithm/// An error that can occur while parsing or validating a certificate.PEMErrorBase64DecodeErrorIncompletePEMMissingHeader//! X.509 errorsRFC822Name/// More or less an e-mail, the format is not checked.DNSName/// A hostname, format is not checked.X400Address/// X400Address,/// RFC5280 defines several string types, we always try to parse as utf-8/// which is more or less a superset of the string types.EDIPartyName/// EDIPartyName/// An uniform resource identifier. The format is not checked.IPAddress/// An ip address, provided as encoded.RegisteredID/// Represents a GeneralName as defined in RFC5280. There/// is no support X.400 addresses and EDIPartyName./// String formats are not validated.parse_generalnameKEY_USAGE_FLAGS// This list must have the same order as KeyUsage flags declaration (4.2.1.3)ocsp_signingparse_keyusageparse_extendedkeyusageRelativeDistinguishedNamegeneralnamekeyusagenameconstraintspolicymappingssct/// OID describing the extension content/// Boolean value describing the 'critical' attribute of the extension/// An extension includes the boolean critical, with a default value of FALSE./// Raw content of the extensionparsed_extension/// X.509 version 3 extension/// X.509 extensions allow adding attributes to objects like certificates or revocation lists./// Each extension in a certificate is designated as either critical or non-critical.  A/// certificate using system MUST reject the certificate if it encounters a critical extension it/// does not recognize; however, a non-critical extension MAY be ignored if it is not recognized./// Each extension includes an OID and an ASN.1 structure.  When an extension appears in a/// certificate, the OID appears as the field extnID and the corresponding ASN.1 encoded structure/// is the value of the octet string extnValue.  A certificate MUST NOT include more than one/// instance of a particular extension./// When parsing an extension, the global extension structure (described above) is parsed,/// and the object is returned if it succeeds./// During this step, it also attempts to parse the content of the extension, if known./// The returned object has a/// [`X509Extension::parsed_extension()`] method. The returned/// enum is either a known extension, or the special value `ParsedExtension::UnsupportedExtension`./// use x509_parser::extensions::{X509Extension, ParsedExtension};/// static DER: &[u8] = &[///    0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0xA3, 0x05, 0x2F, 0x18,///    0x60, 0x50, 0xC2, 0x89, 0x0A, 0xDD, 0x2B, 0x21, 0x4F, 0xFF, 0x8E, 0x4E, 0xA8, 0x30, 0x31,///    0x36 ];/// let res = X509Extension::from_der(DER);///     Ok((_rem, ext)) => {///         println!("Extension OID: {}", ext.oid);///         println!("  Critical: {}", ext.critical);///         let parsed_ext = ext.parsed_extension();///         assert!(!parsed_ext.unsupported());///         assert!(parsed_ext.error().is_none());///         if let ParsedExtension::SubjectKeyIdentifier(key_id) = parsed_ext {///             assert!(key_id.0.len() > 0);///             panic!("Extension has wrong type");///     _ => panic!("x509 extension parsing failed: {:?}", res),/// Creates a new extension with the provided values./// Return the extension type or `UnsupportedExtension` if the extension is not implemented./// Extension  ::=  SEQUENCE  {///     extnID      OBJECT IDENTIFIER,///     critical    BOOLEAN DEFAULT FALSE,///     extnValue   OCTET STRING  }X509ExtensionParser/// `X509Extension` parser builder/// Crate parser does not support this extension (yet)/// Section 4.2.1.1 of rfc 5280KeyIdentifier/// Section 4.2.1.2 of rfc 5280/// Section 4.2.1.3 of rfc 5280CertificatePolicies/// Section 4.2.1.4 of rfc 5280/// Section 4.2.1.5 of rfc 5280/// Section 4.2.1.6 of rfc 5280IssuerAlternativeName/// Section 4.2.1.7 of rfc 5280/// Section 4.2.1.9 of rfc 5280/// Section 4.2.1.10 of rfc 5280/// Section 4.2.1.11 of rfc 5280/// Section 4.2.1.12 of rfc 5280CRLDistributionPoints/// Section 4.2.1.13 of rfc 5280/// Section 4.2.1.14 of rfc 5280AuthorityInfoAccess/// Section 4.2.2.1 of rfc 5280NSCertType/// Netscape certificate type (subject is SSL client, an SSL server, or a CA)NsCertComment/// Netscape certificate comment/// Section 5.2.5 of rfc 5280CRLNumber/// Section 5.3.1 of rfc 5280InvalidityDate/// Section 5.3.3 of rfc 5280SignedCertificateTimestamp/// rfc 6962Unparsed/// Unparsed extension (was not requested in parsing options)/// Return `true` if the extension is unsupported/// Return a reference on the parsing error if the extension parsing failedauthority_cert_issuerauthority_cert_serialPolicyInformationpolicy_idpolicy_qualifiersPolicyQualifierInfopolicy_qualifier_idqualifierpath_len_constraint/// Identifies whether the subject of the certificate is a CA, and the max validation depth.ssl_clientssl_serversmimeobject_signingssl_casmime_caobject_signing_ca// The value is a bit-string, where the individual bit positions are defined as://     bit-0 SSL client - this cert is certified for SSL client authentication use//     bit-1 SSL server - this cert is certified for SSL server authentication use//     bit-2 S/MIME - this cert is certified for use by clients (New in PR3)//     bit-3 Object Signing - this cert is certified for signing objects such as Java applets and plugins(New in PR3)//     bit-4 Reserved - this bit is reserved for future use//     bit-5 SSL CA - this cert is certified for issuing certs for SSL use//     bit-6 S/MIME CA - this cert is certified for issuing certs for S/MIME use (New in PR3)//     bit-7 Object Signing CA - this cert is certified for issuing certs for Object Signing (New in PR3)NS_CERT_TYPE_FLAGSaccessdescs/// Returns an iterator over the Access Descriptors/// Returns a `HashMap` mapping `Oid` to the list of references to `GeneralNames`/// If several names match the same `Oid`, they are merged in the same entry.into_hashmap/// Returns a `HashMap` mapping `Oid` to the list of `GeneralNames` (consuming the input)access_methodaccess_locationskip_certsrequire_explicit_policyinhibit_policy_mappinggeneral_namesCRLDistributionPointReasonFlagsNameRelativeToCRLIssuerkey_compromiseca_compromiseaffilation_changedsupersededcessation_of_operationcertificate_holdprivelege_withdrawnaa_compromiseREASON_FLAGSExtParserEXTENSION_PARSERSparse_extension0parse_extensionparse_basicconstraints/// Parse a "Basic Constraints" extension///   id-ce-basicConstraints OBJECT IDENTIFIER ::=  { id-ce 19 }///   BasicConstraints ::= SEQUENCE {///        cA                      BOOLEAN DEFAULT FALSE,///        pathLenConstraint       INTEGER (0..MAX) OPTIONAL }/// Note the maximum length of the `pathLenConstraint` field is limited to the size of a 32-bits/// unsigned integer, and parsing will fail if value if larger.parse_basicconstraints_extparse_nameconstraints_extparse_subjectalternativename_extparse_issueralternativename_extparse_policyconstraintsparse_policyconstraints_extparse_policymappings_extparse_inhibitanypolicy_extparse_extendedkeyusage_extparse_distributionpointname// DistributionPointName ::= CHOICE {//     fullName                [0]     GeneralNames,//     nameRelativeToCRLIssuer [1]     RelativeDistinguishedName }parse_implicit_tagged_reasonsparse_reasons// ReasonFlags ::= BIT STRING {// unused                  (0),// keyCompromise           (1),// cACompromise            (2),// affiliationChanged      (3),// superseded              (4),// cessationOfOperation    (5),// certificateHold         (6),// privilegeWithdrawn      (7),// aACompromise            (8) }parse_crlissuer_contentparse_crldistributionpoint// DistributionPoint ::= SEQUENCE {//     distributionPoint       [0]     DistributionPointName OPTIONAL,//     reasons                 [1]     ReasonFlags OPTIONAL,//     cRLIssuer               [2]     GeneralNames OPTIONAL }parse_crldistributionpointsparse_crldistributionpoints_extparse_issuingdistributionpoint//  IssuingDistributionPoint ::= SEQUENCE {//         distributionPoint          [0] DistributionPointName OPTIONAL,//         onlyContainsUserCerts      [1] BOOLEAN DEFAULT FALSE,//         onlyContainsCACerts        [2] BOOLEAN DEFAULT FALSE,//         onlySomeReasons            [3] ReasonFlags OPTIONAL,//         indirectCRL                [4] BOOLEAN DEFAULT FALSE,//         onlyContainsAttributeCerts [5] BOOLEAN DEFAULT FALSE }parse_issuingdistributionpoint_extparse_authorityinfoaccess// AuthorityInfoAccessSyntax  ::=//         SEQUENCE SIZE (1..MAX) OF AccessDescription// AccessDescription  ::=  SEQUENCE {//         accessMethod          OBJECT IDENTIFIER,//         accessLocation        GeneralName  }parse_authorityinfoaccess_extparse_aki_contentparse_authoritykeyidentifier// RFC 5280 section 4.2.1.1: Authority Key Identifierparse_authoritykeyidentifier_extparse_keyidentifierparse_keyidentifier_extparse_keyusage_extparse_nscerttypeparse_nscerttype_extparse_nscomment_extparse_certificatepolicies// CertificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation// PolicyInformation ::= SEQUENCE {//      policyIdentifier   CertPolicyId,//      policyQualifiers   SEQUENCE SIZE (1..MAX) OF//              PolicyQualifierInfo OPTIONAL }// CertPolicyId ::= OBJECT IDENTIFIER// PolicyQualifierInfo ::= SEQUENCE {//      policyQualifierId  PolicyQualifierId,//      qualifier          ANY DEFINED BY policyQualifierId }// -- Implementations that recognize additional policy qualifiers MUST// -- augment the following definition for PolicyQualifierId// PolicyQualifierId ::= OBJECT IDENTIFIER ( id-qt-cps | id-qt-unotice )parse_certificatepolicies_extparse_reason_code// CRLReason ::= ENUMERATED { ...parse_invalidity_date// invalidityDate ::=  GeneralizedTimeparse_crl_number// CRLNumber ::= INTEGER (0..MAX)// Note from RFC 3280: "CRL verifiers MUST be able to handle CRLNumber values up to 20 octets."parse_sct_extparse_extension_sequence/// Extensions  ::=  SEQUENCE SIZE (1..MAX) OF Extensionparse_extensionsparse_extension_envelope_sequenceparse_extensions_envelopeder_read_criticaltest_keyusage_flagstest_extensions1test_extensions2test_extensions_crl_distribution_points// Test cases for:// - parsing SubjectAlternativeName// - parsing NameConstraints//! X.509 Extensions objects and types// impl<'a> FromDer<'a> for CertificatePolicies<'a> {//     fn from_der(i: &'a [u8]) -> X509Result<'a, Self> {//         parser::parse_certificatepolicies(i).map_err(Err::convert)// minimum: u32,// maximum: Option<u32>,/// Represents the structure used in the name constraints extensions./// The fields minimum and maximum are not supported (openssl also has no support).parse_nameconstraintsPolicyMapping/// Returns a `HashMap` mapping `Oid` to the list of references to `Oid`/// Returns a `HashMap` mapping `Oid` to the list of `Oid` (consuming the input)issuer_domain_policysubject_domain_policyparse_policymappings// PolicyMappings ::= SEQUENCE SIZE (1..MAX) OF SEQUENCE {//  issuerDomainPolicy      CertPolicyId,//  subjectDomainPolicy     CertPolicyId }CtVersionCtLogIDCtExtensionsDigitallySigned/// Certificate Transparency Version as defined in/// [RFC6962 Section 3.2](https://datatracker.ietf.org/doc/html/rfc6962#section-3.2)/// LogID as defined in/// CtExtensions as defined inhash_alg_idsign_alg_idparse_ct_signed_certificate_timestamp_list/// Parses a list of Signed Certificate Timestamp entriesparse_ct_signed_certificate_timestamp/// Parses as single Signed Certificate Timestamp entryparse_ct_signed_certificate_timestamp_contentparse_log_id// Safety: cannot fail, take() returns exactly 32 bytesparse_ct_extensionsparse_digitally_signed//! Certificate transparency [RFC6962](https://datatracker.ietf.org/doc/html/rfc6962)//! Code borrowed from tls-parser crate (file <https://github.com/rusticata/tls-parser/blob/tls-parser-0.11.0/src/certificate_transparency.rs>)certification_requestrevocation_list// reexportsparse_x509_certificate/// Parse a **DER-encoded** X.509 Certificate, and return the remaining of the input and the built/// This function is an alias to [X509Certificate::from_der](certificate::X509Certificate::from_der). See this function/// For PEM-encoded certificates, use the [`pem`](pem/index.html) module.parse_x509_crl/// Parse a DER-encoded X.509 v2 CRL, and return the remaining of the input and the built/// This function is an alias to [CertificateRevocationList::from_der](revocation_list::CertificateRevocationList::from_der). See this functionparse_x509_derparse_crl_der//! [![docs.rs](https://docs.rs/x509-parser/badge.svg)](https://docs.rs/x509-parser)//! [![crates.io](https://img.shields.io/crates/v/x509-parser.svg)](https://crates.io/crates/x509-parser)//! [![Download numbers](https://img.shields.io/crates/d/x509-parser.svg)](https://crates.io/crates/x509-parser)//! [![Github CI](https://github.com/rusticata/x509-parser/workflows/Continuous%20integration/badge.svg)](https://github.com/rusticata/x509-parser/actions)//! # X.509 Parser//! A X.509 v3 ([RFC5280]) parser, implemented with the [nom](https://github.com/Geal/nom)//! parser combinator framework.//! The code is available on [Github](https://github.com/rusticata/x509-parser)//! Certificates are usually encoded in two main formats: PEM (usually the most common format) or//! DER.  A PEM-encoded certificate is a container, storing a DER object. See the//! [`pem`](pem/index.html) module for more documentation.//! To decode a DER-encoded certificate, the main parsing method is//! `X509Certificate::from_der` (//! part of the [`FromDer`](prelude/trait.FromDer.html) trait//! ), which builds a//! [`X509Certificate`](certificate/struct.X509Certificate.html) object.//! An alternative method is to use [`X509CertificateParser`](certificate/struct.X509CertificateParser.html),//! which allows specifying parsing options (for example, not automatically parsing option contents).//! The returned objects for parsers follow the definitions of the RFC. This means that accessing//! fields is done by accessing struct members recursively. Some helper functions are provided, for//! example [`X509Certificate::issuer()`](certificate/struct.X509Certificate.html#method.issuer) returns the//! same as accessing `<object>.tbs_certificate.issuer`.//! For PEM-encoded certificates, use the [`pem`](pem/index.html) module.//! Parsing a certificate in DER format://! use x509_parser::prelude::*;//! static IGCA_DER: &[u8] = include_bytes!("../assets/IGC_A.der");//! let res = X509Certificate::from_der(IGCA_DER);//! match res {//!     Ok((rem, cert)) => {//!         assert!(rem.is_empty());//!         assert_eq!(cert.version(), X509Version::V3);//!     _ => panic!("x509 parsing failed: {:?}", res),//! To parse a CRL and print information about revoked certificates://! # use x509_parser::prelude::*;//! # static DER: &[u8] = include_bytes!("../assets/example.crl");//! let res = CertificateRevocationList::from_der(DER);//!     Ok((_rem, crl)) => {//!         for revoked in crl.iter_revoked_certificates() {//!             println!("Revoked certificate serial: {}", revoked.raw_serial_as_string());//!             println!("  Reason: {}", revoked.reason_code().unwrap_or_default().1);//!     _ => panic!("CRL parsing failed: {:?}", res),//! See also `examples/print-cert.rs`.//! - The `verify` feature adds support for (cryptographic) signature verification, based on `ring`.//!   It adds the//!   [`X509Certificate::verify_signature()`](certificate/struct.X509Certificate.html#method.verify_signature)//!   to `X509Certificate`.//! # #[cfg(feature = "verify")]//! # use x509_parser::certificate::X509Certificate;//! /// Cryptographic signature verification: returns true if certificate was signed by issuer//! #[cfg(feature = "verify")]//! pub fn check_signature(cert: &X509Certificate<'_>, issuer: &X509Certificate<'_>) -> bool {//!     let issuer_public_key = issuer.public_key();//!     cert//!         .verify_signature(Some(issuer_public_key))//!         .is_ok()//! - The `validate` features add methods to run more validation functions on the certificate structure//!   and values using the [`Validate`](validate/trait.Validate.html) trait.//!   It does not validate any cryptographic parameter (see `verify` above).//! `x509-parser` requires **Rustc version 1.63 or greater**, based on der-parser//! dependencies and for proc-macro attributes support.//! Note that due to breaking changes in the `time` crate, a specific version of this//! crate must be specified for compiler versions <= 1.63://! `cargo update -p time --precise 0.3.20`//! [RFC5280]: https://tools.ietf.org/html/rfc5280OID_REGISTRYABBREV_MAPoid2abbrev/// Return the abbreviation (for ex. CN for Common Name), or if not found, the OID short nameoid2sn/// Returns the short name corresponding to the OIDoid2description/// Returns the description corresponding to the OID/// Return a reference to the default registry of known OIDstest_oid_match// This test is meant to check syntax of pattern matching with OID objects//! X.509 helper objects definitions and registry//! All OID objects and definitions are now stored in the [oid-registry](https://crates.io/crates/oid-registry) crate.//! This crate is re-exporting `oid-registry`, so to access the OID constants the//! `x509_parser::oid_oid_registry` namespace can be used (see example below).//! To get the short name for a given OID://! use x509_parser::objects::*;//! use x509_parser::oid_registry::*;//! let oid = &OID_X509_COMMON_NAME;//! let sn = oid2sn(oid, oid_registry());//! assert_eq!(sn, Ok("commonName"));/// The PEM label/// The PEM decoded data/// Representation of PEM datapem_to_derparse_x509_pem/// Read a PEM-encoded structure, and decode the base64 data/// Return a structure describing the PEM object: the enclosing tag, and the data./// Allocates a new buffer for the decoded data./// Note that only the *first* PEM block is decoded. To iterate all blocks from PEM data,/// use [`Pem::iter_from_buffer`]./// For X.509 (`CERTIFICATE` tag), the data is a certificate, encoded in DER. To parse the/// certificate content, use `Pem::parse_x509` or `parse_x509_certificate`./// Read the next PEM-encoded structure, and decode the base64 data/// Returns the certificate (encoded in DER) and the number of bytes read./// Note that a PEM file can contain multiple PEM blocks. This function returns the/// *first* decoded object, starting from the current reader position./// To get all objects, call this function repeatedly until `PEMError::MissingHeader`/// let file = std::fs::File::open("assets/certificate.pem").unwrap();/// let subject = x509_parser::pem::Pem::read(std::io::BufReader::new(file))///      .unwrap().0///     .parse_x509().unwrap()///     .tbs_certificate.subject.to_string();/// assert_eq!(subject, "CN=lists.for-our.info");parse_x509/// Decode the PEM contents into a X.509 objectiter_from_bufferPemIterator/// Returns an iterator over the PEM-encapsulated parts of a buffer/// Only the sections enclosed in blocks starting with `-----BEGIN xxx-----`/// and ending with `-----END xxx-----` will be considered./// Lines before, between or after such blocks will be ignored./// The iterator is fallible: `next()` returns a `Result<Pem, PEMError>` object./// An error indicates a block is present but invalid./// If the buffer does not contain any block, iterator will be empty.iter_from_reader/// Returns an iterator over the PEM-encapsulated parts of a reader/// If the reader does not contain any block, iterator will be empty./// Iterator over PEM-encapsulated blocksread_pem_from_filepem_multi_word_label//! Decoding functions for PEM-encoded data//! A PEM object is a container, which can store (amongst other formats) a public X.509//! Certificate, or a CRL, etc. It contains only printable characters.//! PEM-encoded binary data is essentially a beginning and matching end tag that encloses//! base64-encoded binary data (see://! <https://en.wikipedia.org/wiki/Privacy-enhanced_Electronic_Mail>).//! To parse a certificate in PEM format, first create the `Pem` object, then decode//! contents://! use x509_parser::pem::Pem;//! use x509_parser::x509::X509Version;//! static IGCA_PEM: &str = "../assets/IGC_A.pem";//! let data = std::fs::read(IGCA_PEM).expect("Could not read file");//! for pem in Pem::iter_from_buffer(&data) {//!     let pem = pem.expect("Reading next PEM block failed");//!     let x509 = pem.parse_x509().expect("X.509: decoding DER failed");//!     assert_eq!(x509.tbs_certificate.version, X509Version::V3);//! This is the most direct method to parse PEM data.//! Another method to parse the certificate is to use `parse_x509_pem`://! use x509_parser::pem::parse_x509_pem;//! use x509_parser::parse_x509_certificate;//! static IGCA_PEM: &[u8] = include_bytes!("../assets/IGC_A.pem");//! let res = parse_x509_pem(IGCA_PEM);//!     Ok((rem, pem)) => {//!         assert_eq!(pem.label, String::from("CERTIFICATE"));//!         let res_x509 = parse_x509_certificate(&pem.contents);//!         assert!(res_x509.is_ok());//!     _ => panic!("PEM parsing failed: {:?}", res),//! Note that all methods require to store the `Pem` object in a variable, mainly because decoding//! the PEM object requires allocation of buffers, and that the lifetime of X.509 certificates will//! be bound to these buffers.//! A "prelude" for users of the x509-parser crate.RSAPublicKeyECPoint/// DSAPublicKey ::= INTEGER -- public key, Y (RFC 3279)GostR3410/// GostR3410-94-PublicKey ::= OCTET STRING -- public key, Y (RFC 4491)GostR3410_2012/// GostR3410-2012-256-PublicKey ::= OCTET STRING (64),/// GostR3410-2012-512-PublicKey ::= OCTET STRING (128). (RFC 4491-bis)/// Public Key value/// Return the key size (in bits) or 0/// Raw bytes of the modulus/// This possibly includes a leading 0 if the MSB is 1/// Raw bytes of the exponent/// RSA public Key, defined in rfc3279try_exponent/// Attempt to convert exponent to u64/// Returns an error if integer is too large, empty, or negativeparse_rsa_key// helper function to parse with error type BerError/// Elliptic Curve point, as defined in [RFC5480](https://datatracker.ietf.org/doc/html/rfc5480)/// EC Point content (See Standards for Efficient Cryptography Group (SECG), "SEC1: Elliptic Curve Cryptography")tbs_cert_listTbsCertList/// An X.509 v2 Certificate Revocation List (CRL)./// X.509 v2 CRLs are defined in [RFC5280](https://tools.ietf.org/html/rfc5280)./// To parse a CRL and print information about revoked certificates:/// use x509_parser::revocation_list::CertificateRevocationList;/// # static DER: &'static [u8] = include_bytes!("../assets/example.crl");/// let res = CertificateRevocationList::from_der(DER);///     Ok((_rem, crl)) => {///         for revoked in crl.iter_revoked_certificates() {///             println!("Revoked certificate serial: {}", revoked.raw_serial_as_string());///             println!("  Reason: {}", revoked.reason_code().unwrap_or_default().1);///     _ => panic!("CRL parsing failed: {:?}", res),/// Get the date and time of the last (this) update./// Get the date and time of the next update, if present.iter_revoked_certificates/// Return an iterator over the `RevokedCertificate` objects/// Get the CRL extensions./// Get the CRL number, if present/// Note that the returned value is a `BigUint`, because of the following RFC specification:/// Given the requirements above, CRL numbers can be expected to contain long integers.  CRL/// verifiers MUST be able to handle CRLNumber values up to 20 octets.  Conformant CRL issuers/// MUST NOT use CRLNumber values longer than 20 octets./// Verify the cryptographic signature of this certificate revocation list/// `public_key` is the public key of the **signer**./// CertificateList  ::=  SEQUENCE  {///      tbsCertList          TBSCertList,///      signatureAlgorithm   AlgorithmIdentifier,///      signatureValue       BIT STRING  }revoked_certificates/// The sequence TBSCertList contains information about the certificates that have/// been revoked by the CA that issued the CRL./// TBSCertList  ::=  SEQUENCE  {///         version                 Version OPTIONAL,///                                      -- if present, MUST be v2///         signature               AlgorithmIdentifier,///         issuer                  Name,///         thisUpdate              Time,///         nextUpdate              Time OPTIONAL,///         revokedCertificates     SEQUENCE OF SEQUENCE  {///             userCertificate         CertificateSerialNumber,///             revocationDate          Time,///             crlEntryExtensions      Extensions OPTIONAL///                                      -- if present, version MUST be v2///                                   } OPTIONAL,///         crlExtensions           [0]  EXPLICIT Extensions OPTIONALuser_certificate/// The Serial number of the revoked certificate/// The date on which the revocation occurred is specified./// Additional information about revocation/// Return the serial number of the revoked certificate/// Get the code identifying the reason for the revocation, if present/// Get the invalidity date, if present/// The invalidity date is the date on which it is known or suspected that the private///  key was compromised or that the certificate otherwise became invalid.// revokedCertificates     SEQUENCE OF SEQUENCE  {//     userCertificate         CertificateSerialNumber,//     revocationDate          Time,//     crlEntryExtensions      Extensions OPTIONAL//                                   -- if present, MUST be v2//                          }  OPTIONAL,parse_revoked_certificatesRsaSsaPssParamsRsaAesOaepParamsRSAAES_OAEPtest_ecdsa_oidhash_algmask_gen_algorithmtrailer_field// RSASSA-PSS-params  ::=  SEQUENCE  {//     hashAlgorithm      [0] HashAlgorithm DEFAULT//                               sha1Identifier,//     maskGenAlgorithm   [1] MaskGenAlgorithm DEFAULT//                               mgf1SHA1Identifier,//     saltLength         [2] INTEGER DEFAULT 20,//     trailerField       [3] INTEGER DEFAULT 1  }/// Get a reference to the rsa ssa pss params's hash algorithm.hash_algorithm_oid/// Return the hash algorithm OID, or SHA1 if absent (RFC4055)mask_gen_algorithm_raw/// Get a reference to the rsa ssa pss params's mask generation algorithm.MaskGenAlgorithm/// Get the rsa ssa pss params's mask generation algorithm./// If the algorithm encoding is invalid, raise an error `InvalidAlgorithmIdentifier`/// Return the salt length/// Return the trailer field (value must be `1` according to RFC4055)mgfmask_gen_algp_source_alg// RSAES-OAEP-params  ::=  SEQUENCE  {//     hashFunc          [0] AlgorithmIdentifier DEFAULT//                              sha1Identifier,//     maskGenFunc       [1] AlgorithmIdentifier DEFAULT//                              mgf1SHA1Identifier,//     pSourceFunc       [2] AlgorithmIdentifier DEFAULT//                              pSpecifiedEmptyIdentifier  }//  pSpecifiedEmptyIdentifier  AlgorithmIdentifier  ::=//                       { id-pSpecified, nullOctetString }//  nullOctetString  OCTET STRING (SIZE (0))  ::=  { ''H }/// Get a reference to the rsa aes oaep params's hash algorithm./// Return the pSourceFunc algorithm// RSASSA-PSS public keys [RFC4055](https://www.rfc-editor.org/rfc/rfc4055.html)// RSAAES-OAEP public keys [RFC8017](https://www.rfc-editor.org/rfc/rfc8017.html)// ECC subject public key information [RFC5480](https://datatracker.ietf.org/doc/rfc5480/)// ECParameters ::= CHOICE {//     namedCurve         OBJECT IDENTIFIER//     -- implicitCurve   NULL//     -- specifiedCurve  SpecifiedECDomain//     -- implicitCurve and specifiedCurve MUST NOT be used in PKIX.//     -- Details for SpecifiedECDomain can be found in [X9.62].//     -- Any future additions to this CHOICE should be coordinated//     -- with ANSI X9.EcdsaSigValue/// ECDSA Signature Value (RFC3279)// Ecdsa-Sig-Value  ::=  SEQUENCE  {//     r     INTEGER,//     s     INTEGER  }/// An ASN.1 timestamp.from_der_opt/// Makes a new `ASN1Time` from the number of non-leap seconds since Epoch/// Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp")./// Returns a `ASN1Time` which corresponds to the current date./// Conversion to RFC2822 date can fail if date cannot be represented in this format,/// for example if year < 1900./// For an infallible conversion to string, use `.to_string()`.parse_choice_of_timeparse_malformed_date// allow relaxed parsing of UTCTime (ex: 370116130016+0000)test_time_to_stringtest_nonrfc2822_date/// Formats a slice to a colon-separated hex string (for ex `01:02:ff:ff`)test_format_serialX509ExtensionsValidatorX509CertificateValidatorWARN_SHOULD_BE_CRITICALtest_critical// extra-pedantic checksVecLogger/// Simple Logger for [`Validator`](crate::validate::Validator) trait, storing messages in `Vec`/// Get stored warnings/// Get stored errorsStderrLogger/// Simple Logger for [`Validator`](crate::validate::Validator) trait, printing messages to `stderr`CallbackLogger/// Simple Logger for [`Validator`](crate::validate::Validator) trait, using closures for `warn`/`err`.loggers/// Attempts to validate current item./// Returns `true` if item was validated./// Call `warn()` if a non-fatal error was encountered, and `err()`/// if the error is fatal. These fucntions receive a description of the error.validate_to_vec/// Attempts to validate current item, storing warning and errors in `Vec`./// Returns the validation result (`true` if validated), the list of warnings,/// and the list of errors.Validate/// Trait for validating item (for ex. validate X.509 structure)/// Using callbacks:/// use x509_parser::certificate::X509Certificate;/// # #[allow(deprecated)]/// use x509_parser::validate::Validate;/// #[cfg(feature = "validate")]/// fn validate_certificate(x509: &X509Certificate<'_>) -> Result<(), &'static str> {///     println!("  Subject: {}", x509.subject());///     // validate and print warnings and errors to stderr///     let ok = x509.validate(///         |msg| {///             eprintln!("  [W] {}", msg);///             eprintln!("  [E] {}", msg);///     print!("Structure validation status: ");///     if ok {///         println!("Ok");///         println!("FAIL");///         Err("validation failed")/// Collecting warnings and errors to `Vec`:///     let (ok, warnings, errors) = x509.validate_to_vec();///     for warning in &warnings {///         eprintln!("  [W] {}", warning);///     for error in &errors {///         eprintln!("  [E] {}", error);///     println!();///     if !errors.is_empty() {///         return Err("validation failed");/// The item to validate/// Call `l.warn()` if a non-fatal error was encountered, and `l.err()`/// if the error is fatal. These functions receive a description of the error.ChainValidator/// Trait for build item validators (for ex. validate X.509 structure)/// See [`X509StructureValidator`] for a default implementation, validating the/// DER structure of a X.509 Certificate./// See implementors of the [`Logger`] trait for methods to collect or handle warnings and errors./// use x509_parser::validate::*;///     let mut logger = VecLogger::default();///     let ok = X509StructureValidator.validate(&x509, &mut logger);///     for warning in logger.warnings() {///     for error in logger.errors() {///     if !logger.errors().is_empty() {V1Validatorvalidate_warnvalidator_warnX509NameStructureValidatorX509StructureValidator/// Default X.509 structure validator for `X509Certificate`/// This [`Validator`] iterates the X.509 Certificate fields, and verifies the/// DER encoding and structure:/// - numbers with wrong encoding/sign (for ex. serial number)/// - strings with characters not allowed in DER type (for ex. '*' in `PrintableString`)/// Validate structure, collect warnings and errors to a `Vec`:TbsCertificateStructureValidator/// Default X.509 structure validator for `TbsCertificate`X509PublicKeyValidator/// Verify the cryptographic signature of the raw data (can be a certificate, a CRL or a CSR).get_ec_curve_sha/// Find the verification algorithm for the given EC curve and SHA digest size/// Not all algorithms are supported, we are limited to what `ring` supports./// The version of the encoded certificate./// When extensions are used, as expected in this profile, version MUST be 3/// (value is `2`).  If no extensions are present, but a UniqueIdentifier/// is present, the version SHOULD be 2 (value is `1`); however, the/// version MAY be 3.  If only basic fields are present, the version/// SHOULD be 1 (the value is omitted from the certificate as the default/// value); however, the version MAY be 2 or 3.from_der_tagged_0/// Parse [0] EXPLICIT Version DEFAULT v1// Version  ::=  INTEGER  {  v1(0), v2(1), v3(2)  }// ANY -- DEFINED BY AttributeTypeAttributeTypeAndValue/// A generic attribute type and value/// These objects are used as [`RelativeDistinguishedName`] components./// Builds a new `AttributeTypeAndValue`/// Returns the attribute type/// Returns the attribute value, as `ANY`/// Attempt to get the content as `str`./// Note: the [`TryFrom`] trait is implemented for `&str`, so this is/// equivalent to `attr.try_into()`./// Only NumericString, PrintableString, UTF8String and IA5String/// are considered here. Other string types can be read using `as_slice`./// Get the content as a slice.// AttributeTypeAndValue   ::= SEQUENCE {//     type    AttributeType,//     value   AttributeValue }parse_attribute_value// AttributeValue          ::= ANY -- DEFINED BY AttributeTypeparse_malformed_string/// A Relative Distinguished Name element./// These objects are used as [`X509Name`] components./// Builds a new `RelativeDistinguishedName`/// Return an iterator over the components of this object/// A raw unparsed PKIX, ASN.1 DER form (see RFC 5280, Section 4.1)./// Note: use the [`Self::parsed()`] function to parse this object./// Attempt to parse the public key, and return the parsed version or an error/// Parse the SubjectPublicKeyInfo struct portion of a DER-encoded X.509 Certificate/// Algorithm identifier/// An algorithm identifier is defined by the following ASN.1 structure:/// The algorithm identifier is used to identify a cryptographic/// algorithm.  The OBJECT IDENTIFIER component identifies the algorithm/// (such as DSA with SHA-1).  The contents of the optional parameters/// field will vary according to the algorithm identified./// Create a new `AlgorithmIdentifier`/// Get the algorithm OID/// Get a reference to the algorithm parameters, if presentrdn_seq/// X.509 Name (as used in `Issuer` and `Subject` fields)/// The Name describes a hierarchical name composed of attributes, such/// as country name, and corresponding values, such as US.  The type of/// the component AttributeValue is determined by the AttributeType; in/// general it will be a DirectoryString./// Builds a new `X509Name` from the provided elements.to_string_with_registry/// Attempt to format the current name, using the given registry to convert OIDs to strings./// Note: a default registry is provided with this crate, and is returned by the/// [`oid_registry()`] method.// Not using the AsRef trait, as that would not give back the full 'a lifetime/// Return an iterator over the `RelativeDistinguishedName` components of the nameiter_rdn/// Return an iterator over the attribute types and values of the nameiter_by_oid/// Return an iterator over the components identified by the given OID/// The type of the component AttributeValue is determined by the AttributeType; in/// Attributes with same OID may be present multiple times, so the returned object is/// an iterator./// Expected number of objects in this iterator are///   - 0: not found///   - 1: present once (common case)///   - 2 or more: attribute is present multiple timesiter_common_name/// Return an iterator over the `CommonName` attributes of the X.509 Name./// Returned iterator can be empty if there are no `CommonName` attributes./// If you expect only one `CommonName` to be present, then using `next()` will/// get an `Option<&AttributeTypeAndValue>`./// A common operation is to extract the `CommonName` as a string./// use x509_parser::x509::X509Name;/// fn get_first_cn_as_str<'a>(name: &'a X509Name<'_>) -> Option<&'a str> {///     name.iter_common_name()///         .next()///         .and_then(|cn| cn.as_str().ok())/// Note that there are multiple reasons for failure or incorrect behavior, for ex. if/// the attribute is present multiple times, or is not a UTF-8 encoded string (it can be/// UTF-16, or even an OCTETSTRING according to the standard).iter_country/// Return an iterator over the `Country` attributes of the X.509 Name.iter_organization/// Return an iterator over the `Organization` attributes of the X.509 Name.iter_organizational_unit/// Return an iterator over the `OrganizationalUnit` attributes of the X.509 Name.iter_state_or_province/// Return an iterator over the `StateOrProvinceName` attributes of the X.509 Name.iter_locality/// Return an iterator over the `Locality` attributes of the X.509 Name.iter_email/// Return an iterator over the `EmailAddress` attributes of the X.509 Name./// Parse the X.501 type Name, used for ex in issuer and subject of a X.509 certificateCACompromiseRemoveFromCRLAACompromiseattribute_value_to_string// Attempt to convert attribute to string. If type is not a string, return value is the hex// encoding of the attribute valuex509name_to_string/// Convert a DER representation of a X.509 name to a human-readable string/// RDNs are separated with ","/// Multiple RDNs are separated with "+"/// Attributes that cannot be represented by a string are hex-encodedtest_x509_versiontest_x509_name//! X.509 objects and types//! Based on RFC5280/// A module implementing XCursor file parsing.CursorThemeIml/// Global search path for themes./// A cursor theme./// Search for a theme with the given name in the given search paths,/// and returns an XCursorTheme which represents it. If no inheritance/// can be determined, then the themes inherits from the "default" theme./// Try to load an icon from the theme./// If the icon is not found within this theme's/// directories, then the function looks at the/// theme from which this theme is inherited.load_icon_with_depth/// Try to load an icon from the theme, returning it with its inheritance/// depth./// If the icon is not found within this theme's directories, then the/// function looks at the theme from which this theme is inherited. The/// second element of the returned tuple indicates how many levels of/// inheritance were traversed before the icon was found./// Theme name./// Directories where the theme is presented and corresponding names of inherited themes./// `None` if theme inherits nothing./// The implementation of cursor theme loading./// The implementation of cursor icon loading.xcursor_pathxdg_data_homexdg_data_dirsSearchPathsEnvironmenttheme_search_paths/// Get the list of paths where the themes have to be searched, according to the XDG Icon Theme/// specification. If `XCURSOR_PATH` is set, it will override the default search paths.expand_home_dir/// If the first component of the path is `~`, replaces it with the home dir. If no home dir is/// present, returns `None`.theme_inherits/// Load the specified index.theme file, and returns a `Some` with/// the value of the `Inherits` key in it./// Returns `None` if the file cannot be read for any reason,/// if the file cannot be parsed, or if the `Inherits` key is omitted.parse_theme/// Parse the content of the `index.theme` and return the `Inherits` value.test_parse_themetest_expand_home_dirtest_theme_search_paths//! A crate to load cursor themes, and parse XCursor files.toctype/// The nominal size of the image./// The actual width of the image. Doesn't need to match `size`./// The actual height of the image. Doesn't need to match `size`./// The X coordinate of the hotspot pixel (the pixel where the tip of the arrow is situated)/// The Y coordinate of the hotspot pixel (the pixel where the tip of the arrow is situated)/// The amount of time (in milliseconds) that this image should be shown for, before switching to the next.pixels_rgba/// A slice containing the pixels' bytes, in RGBA format (or, in the order of the file).pixels_argb/// A slice containing the pixels' bytes, in ARGB format./// A struct representing an image./// Pixels are in ARGB format, with each byte representing a single channel.parse_tocparse_imgrgba_to_argb/// Converts a RGBA slice into an ARGB vec/// Note that, if the input length is not/// a multiple of 4, the extra elements are ignored.parse_xcursor/// Parse an XCursor file into its images.parse_xcursor_stream/// Parse a series of bytes, returning `None` if it doesn't exist.take_bytes/// Take a slice of bytes.u32_le/// Parse a 32-bit little endian number.FILE_CONTENTS// A sample (and simple) XCursor file generated with xcursorgen.// Contains a single 4x4 image.test_parse_toctest_parse_imagetest_one_image_three_timestest_rgba_to_argbtest_rgba_to_argb_extra_itemstest_rgba_to_argb_no_items/// Get the path of the current user's home directory./// See the library documentation for more information.XKB_MOD_NAME_SHIFTXKB_MOD_NAME_CAPSXKB_MOD_NAME_CTRLXKB_MOD_NAME_ALTXKB_MOD_NAME_NUMXKB_MOD_NAME_LOGOXKB_LED_NAME_CAPSXKB_LED_NAME_NUMXKB_LED_NAME_SCROLLxkb_layout_mask_txkb_level_index_txkb_led_index_txkb_led_mask_txkb_keymap_key_iter_tXKB_KEYCODE_INVALIDXKB_LAYOUT_INVALIDXKB_LEVEL_INVALIDXKB_LED_INVALIDXKB_KEYCODE_MAXxkb_rule_namesxkb_keysym_flagsXKB_KEYSYM_NO_FLAGS/// Do not apply any flags.XKB_KEYSYM_CASE_INSENSITIVE/// Find keysym by case-insensitive search.XKB_CONTEXT_NO_FLAGS/// Do not apply any context flags.XKB_CONTEXT_NO_DEFAULT_INCLUDES/// Create this context with an empty include path.XKB_CONTEXT_NO_ENVIRONMENT_NAMES/// Don't take RMLVO names from the environment.xkb_log_levelXKB_LOG_LEVEL_CRITICAL/// Log critical internal errors only.XKB_LOG_LEVEL_ERROR/// Log all errors. */XKB_LOG_LEVEL_WARNING/// Log warnings and errors.XKB_LOG_LEVEL_INFO/// Log information, warnings, and errors.XKB_LOG_LEVEL_DEBUG/// Log everything.XKB_KEYMAP_COMPILE_NO_FLAGSxkb_keymap_formatXKB_KEYMAP_USE_ORIGINAL_FORMAT/// Cannot be used for creation.XKB_KEYMAP_FORMAT_TEXT_V1/// The current/classic XKB text format, as generated by xkbcomp -xkb.xkb_key_directionXKB_KEY_UP/// The key was released.XKB_KEY_DOWN/// The key was pressed.XKB_COMPOSE_COMPILE_NO_FLAGSxkb_compose_formatXKB_COMPOSE_FORMAT_TEXT_V1XKB_COMPOSE_STATE_NO_FLAGSXKB_COMPOSE_NOTHINGXKB_COMPOSE_COMPOSINGXKB_COMPOSE_COMPOSEDXKB_COMPOSE_CANCELLEDXKB_COMPOSE_FEED_IGNOREDXKB_COMPOSE_FEED_ACCEPTEDr" Depressed modifiers, i.e. a key is physically holding them."XKB_STATE_MODS_DEPRESSEDr" Latched modifiers, i.e. will be unset after the next non-modifier key press."XKB_STATE_MODS_LATCHEDr" Locked modifiers, i.e. will be unset after the key provoking the lock has been"r" pressed again."XKB_STATE_MODS_LOCKEDr" Effective modifiers, i.e. currently active and affect key processing"r" (derived from the other state components)."r" Use this unless you explictly care how the state came about."XKB_STATE_MODS_EFFECTIVEr" Depressed layout, i.e. a key is physically holding it."XKB_STATE_LAYOUT_DEPRESSEDr" Latched layout, i.e. will be unset after the next non-modifier key press."XKB_STATE_LAYOUT_LATCHEDr" Locked layout, i.e. will be unset after the key provoking the lock has been pressed"r" again."XKB_STATE_LAYOUT_LOCKEDr" Effective layout, i.e. currently active and affects key processing"XKB_STATE_LAYOUT_EFFECTIVEr" LEDs (derived from the other state components)."XKB_STATE_LEDSxkb_keysym_get_namexkb_keysym_from_namexkb_keysym_to_utf8xkb_context_newxkb_context_refxkb_context_unrefxkb_context_set_user_dataxkb_context_get_user_dataxkb_context_include_path_appendxkb_context_include_path_append_defaultxkb_context_include_path_reset_defaultsxkb_context_include_path_clearxkb_context_num_include_pathsxkb_context_include_path_getxkb_context_set_log_levelxkb_context_get_log_levelxkb_context_set_log_verbosityxkb_context_get_log_verbosityxkb_keymap_new_from_namesxkb_keymap_new_from_stringxkb_keymap_new_from_bufferxkb_keymap_refxkb_keymap_unrefxkb_keymap_get_as_stringxkb_keymap_key_get_syms_by_levelxkb_keymap_key_repeatsxkb_keymap_min_keycodexkb_keymap_max_keycodexkb_keymap_key_for_eachxkb_keymap_num_layoutsxkb_keymap_num_layouts_for_keyxkb_keymap_num_levels_for_keyxkb_keymap_mod_get_namexkb_keymap_mod_get_indexxkb_state_newxkb_state_refxkb_state_unrefxkb_state_update_maskxkb_state_update_keyxkb_state_key_get_symsxkb_state_key_get_utf8xkb_state_key_get_utf32xkb_state_key_get_one_symxkb_state_key_get_layoutxkb_state_key_get_levelxkb_state_mod_name_is_activexkb_state_mod_index_is_activexkb_state_serialize_modsxkb_state_serialize_layoutxkb_compose_table_new_from_localexkb_compose_table_unrefxkb_compose_state_newxkb_compose_state_unrefxkb_compose_state_feedxkb_compose_state_resetxkb_compose_state_get_statusxkb_compose_state_get_utf8xkb_compose_state_get_one_sym// Compose and dead-keys support modulexkbcommon_optionxkbcommon_compose_optionopen_with_sonamesXKB_X11_MIN_MAJOR_XKB_VERSIONXKB_X11_MIN_MINOR_XKB_VERSIONxkb_x11_setup_xkb_extension_flagsXKB_X11_SETUP_XKB_EXTENSION_NO_FLAGSxkb_x11_setup_xkb_extensionxkb_x11_get_core_keyboard_device_idxkb_x11_keymap_new_from_devicexkb_x11_state_new_from_devicexkbcommon_x11_optionRawKeysymdead_lowlinedead_aboveverticallinedead_belowverticallinedead_longsolidusoverlaydead_schwadead_SCHWAdead_hamzaguillemetleftordmasculineguillemetrightcombining_tildecombining_gravecombining_acutecombining_hookcombining_belowdotXF86_ModeLockXF86_MonBrightnessUpXF86_MonBrightnessDownXF86_KbdLightOnOffXF86_KbdBrightnessUpXF86_KbdBrightnessDownXF86_MonBrightnessCycleXF86_StandbyXF86_AudioLowerVolumeXF86_AudioMuteXF86_AudioRaiseVolumeXF86_AudioPlayXF86_AudioStopXF86_AudioPrevXF86_AudioNextXF86_HomePageXF86_MailXF86_StartXF86_SearchXF86_AudioRecordXF86_CalculatorXF86_MemoXF86_ToDoListXF86_CalendarXF86_PowerDownXF86_ContrastAdjustXF86_RockerUpXF86_RockerDownXF86_RockerEnterXF86_BackXF86_ForwardXF86_StopXF86_RefreshXF86_PowerOffXF86_WakeUpXF86_EjectXF86_ScreenSaverXF86_WWWXF86_SleepXF86_FavoritesXF86_AudioPauseXF86_AudioMediaXF86_MyComputerXF86_VendorHomeXF86_LightBulbXF86_ShopXF86_HistoryXF86_OpenURLXF86_AddFavoriteXF86_HotLinksXF86_BrightnessAdjustXF86_FinanceXF86_CommunityXF86_AudioRewindXF86_BackForwardXF86_Launch0XF86_Launch1XF86_Launch2XF86_Launch3XF86_Launch4XF86_Launch5XF86_Launch6XF86_Launch7XF86_Launch8XF86_Launch9XF86_LaunchAXF86_LaunchBXF86_LaunchCXF86_LaunchDXF86_LaunchEXF86_LaunchFXF86_ApplicationLeftXF86_ApplicationRightXF86_BookXF86_CDXF86_CalculaterXF86_ClearXF86_CloseXF86_CopyXF86_CutXF86_DisplayXF86_DOSXF86_DocumentsXF86_ExcelXF86_ExplorerXF86_GameXF86_GoXF86_iTouchXF86_LogOffXF86_MarketXF86_MeetingXF86_MenuKBXF86_MenuPBXF86_MySitesXF86_NewXF86_NewsXF86_OfficeHomeXF86_OpenXF86_OptionXF86_PasteXF86_PhoneXF86_QXF86_ReplyXF86_ReloadXF86_RotateWindowsXF86_RotationPBXF86_RotationKBXF86_SaveXF86_ScrollUpXF86_ScrollDownXF86_ScrollClickXF86_SendXF86_SpellXF86_SplitScreenXF86_SupportXF86_TaskPaneXF86_TerminalXF86_ToolsXF86_TravelXF86_UserPBXF86_User1KBXF86_User2KBXF86_VideoXF86_WheelButtonXF86_WordXF86_XferXF86_ZoomInXF86_ZoomOutXF86_AwayXF86_MessengerXF86_WebCamXF86_MailForwardXF86_PicturesXF86_MusicXF86_BatteryXF86_BluetoothXF86_WLANXF86_UWBXF86_AudioForwardXF86_AudioRepeatXF86_AudioRandomPlayXF86_SubtitleXF86_AudioCycleTrackXF86_CycleAngleXF86_FrameBackXF86_FrameForwardXF86_TimeXF86_SelectXF86_ViewXF86_TopMenuXF86_RedXF86_GreenXF86_YellowXF86_BlueXF86_SuspendXF86_HibernateXF86_TouchpadToggleXF86_TouchpadOnXF86_TouchpadOffXF86_AudioMicMuteXF86_KeyboardXF86_WWANXF86_RFKillXF86_AudioPresetXF86_RotationLockToggleXF86_FullScreenXF86_Switch_VT_1XF86_Switch_VT_2XF86_Switch_VT_3XF86_Switch_VT_4XF86_Switch_VT_5XF86_Switch_VT_6XF86_Switch_VT_7XF86_Switch_VT_8XF86_Switch_VT_9XF86_Switch_VT_10XF86_Switch_VT_11XF86_Switch_VT_12XF86_UngrabXF86_ClearGrabXF86_Next_VModeXF86_Prev_VModeXF86_LogWindowTreeXF86_LogGrabInfoXF86_BrightnessAutoXF86_DisplayOffXF86_InfoXF86_AspectRatioXF86_DVDXF86_AudioXF86_ChannelUpXF86_ChannelDownXF86_BreakXF86_VideoPhoneXF86_ZoomResetXF86_EditorXF86_GraphicsEditorXF86_PresentationXF86_DatabaseXF86_VoicemailXF86_AddressbookXF86_DisplayToggleXF86_SpellCheckXF86_ContextMenuXF86_MediaRepeatXF86_10ChannelsUpXF86_10ChannelsDownXF86_ImagesXF86_NotificationCenterXF86_PickupPhoneXF86_HangupPhoneXF86_FnXF86_Fn_EscXF86_FnRightShiftXF86_Numeric0XF86_Numeric1XF86_Numeric2XF86_Numeric3XF86_Numeric4XF86_Numeric5XF86_Numeric6XF86_Numeric7XF86_Numeric8XF86_Numeric9XF86_NumericStarXF86_NumericPoundXF86_NumericAXF86_NumericBXF86_NumericCXF86_NumericDXF86_CameraFocusXF86_WPSButtonXF86_CameraZoomInXF86_CameraZoomOutXF86_CameraUpXF86_CameraDownXF86_CameraLeftXF86_CameraRightXF86_AttendantOnXF86_AttendantOffXF86_AttendantToggleXF86_LightsToggleXF86_ALSToggleXF86_ButtonconfigXF86_TaskmanagerXF86_JournalXF86_ControlPanelXF86_AppSelectXF86_ScreensaverXF86_VoiceCommandXF86_AssistantXF86_EmojiPickerXF86_DictateXF86_CameraAccessEnableXF86_CameraAccessDisableXF86_CameraAccessToggleXF86_BrightnessMinXF86_BrightnessMaxXF86_KbdInputAssistPrevXF86_KbdInputAssistNextXF86_KbdInputAssistPrevgroupXF86_KbdInputAssistNextgroupXF86_KbdInputAssistAcceptXF86_KbdInputAssistCancelXF86_RightUpXF86_RightDownXF86_LeftUpXF86_LeftDownXF86_RootMenuXF86_MediaTopMenuXF86_Numeric11XF86_Numeric12XF86_AudioDescXF86_3DModeXF86_NextFavoriteXF86_StopRecordXF86_PauseRecordXF86_VODXF86_UnmuteXF86_FastReverseXF86_SlowReverseXF86_DataXF86_OnScreenKeyboardXF86_PrivacyScreenToggleXF86_SelectiveScreenshotXF86_NextElementXF86_PreviousElementXF86_AutopilotEngageToggleXF86_MarkWaypointXF86_SosXF86_NavChartXF86_FishingChartXF86_SingleRangeRadarXF86_DualRangeRadarXF86_RadarOverlayXF86_TraditionalSonarXF86_ClearvuSonarXF86_SidevuSonarXF86_NavInfoXF86_Macro1XF86_Macro2XF86_Macro3XF86_Macro4XF86_Macro5XF86_Macro6XF86_Macro7XF86_Macro8XF86_Macro9XF86_Macro10XF86_Macro11XF86_Macro12XF86_Macro13XF86_Macro14XF86_Macro15XF86_Macro16XF86_Macro17XF86_Macro18XF86_Macro19XF86_Macro20XF86_Macro21XF86_Macro22XF86_Macro23XF86_Macro24XF86_Macro25XF86_Macro26XF86_Macro27XF86_Macro28XF86_Macro29XF86_Macro30XF86_MacroRecordStartXF86_MacroRecordStopXF86_MacroPresetCycleXF86_MacroPreset1XF86_MacroPreset2XF86_MacroPreset3XF86_KbdLcdMenu1XF86_KbdLcdMenu2XF86_KbdLcdMenu3XF86_KbdLcdMenu4XF86_KbdLcdMenu5SUN_FA_GraveSUN_FA_CircumSUN_FA_TildeSUN_FA_AcuteSUN_FA_DiaeresisSUN_FA_CedillaSUN_F36SUN_F37SUN_Sys_ReqSUN_Print_ScreenSUN_ComposeSUN_AltGraphSUN_PageUpSUN_PageDownSUN_UndoSUN_AgainSUN_FindSUN_StopSUN_PropsSUN_FrontSUN_CopySUN_OpenSUN_PasteSUN_CutSUN_PowerSwitchSUN_AudioLowerVolumeSUN_AudioMuteSUN_AudioRaiseVolumeSUN_VideoDegaussSUN_VideoLowerBrightnessSUN_VideoRaiseBrightnessSUN_PowerSwitchShiftD_ring_accentD_circumflex_accentD_cedilla_accentD_acute_accentD_grave_accentD_tildeD_diaeresisD_RemoveHP_ClearLineHP_InsertLineHP_DeleteLineHP_InsertCharHP_DeleteCharHP_BackTabHP_KP_BackTabHP_Modelock1HP_Modelock2HP_ResetHP_SystemHP_UserHP_mute_acuteHP_mute_graveHP_mute_asciicircumHP_mute_diaeresisHP_mute_asciitildeHP_liraHP_guilderHP_IOHP_longminusHP_blockOSF_CopyOSF_CutOSF_PasteOSF_BackTabOSF_BackSpaceOSF_ClearOSF_EscapeOSF_AddModeOSF_PrimaryPasteOSF_QuickPasteOSF_PageLeftOSF_PageUpOSF_PageDownOSF_PageRightOSF_ActivateOSF_MenuBarOSF_LeftOSF_UpOSF_RightOSF_DownOSF_EndLineOSF_BeginLineOSF_EndDataOSF_BeginDataOSF_PrevMenuOSF_NextMenuOSF_PrevFieldOSF_NextFieldOSF_SelectOSF_InsertOSF_UndoOSF_MenuOSF_CancelOSF_HelpOSF_SelectAllOSF_DeselectAllOSF_ReselectOSF_ExtendOSF_RestoreOSF_DeleteClearLineInsertCharDeleteCharKP_BackTabExt16bit_LExt16bit_Rmute_acutemute_gravemute_asciicircummute_diaeresismute_asciitildeliraguilderlongminus/// A list of raw keyboard symbols./// The "empty" keyboard symbol.// This file was automatically generated using keysym-generator.// Copyright 2022-2023 John Nunley// // the Zlib license ("the Licenses"), you may not use this file except in // compliance with one of the the Licenses, at your option. You may obtain//  a copy of the Licenses at//     http://opensource.org/licenses/MIT//     http://opensource.org/licenses/Zlib// distributed under the Licenses is distributed on an "AS IS" BASIS,// See the Licenses for the specific language governing permissions and// limitations under the Licenses.automatically_generatedRawKeyCode/// The type of a raw keyboard code./// The keyboard code, often corresponding to a physical key./// Keyboard events usually return this type directly, and leave it to be the responsibility of the/// user to convert it to a keyboard symbol./// Create a new `KeyCode` from a raw keyboard code./// Get the raw keyboard code./// The type of a raw keyboard symbol./// The keyboard symbol, often corresponding to a character./// Create a new `Keysym` from a raw keyboard symbol./// Get the raw keyboard symbol./// Get a string corresponding to the name of this keyboard symbol./// The output of this function is not stable and is intended for debugging purposes.is_keypad_key/// Tell whether a keysym is a keypad key.is_private_keypad_key/// Tell whether a keysym is a private keypad key.is_cursor_key/// Tell whether a keysym is a cursor key.is_pf_key/// Tell whether a keysym is a PF key.is_function_key/// Tell whether a keysym is a function key.is_misc_function_key/// Tell whether a key is a miscellaneous function key.is_modifier_key/// Tell whether a key is a modifier key.key_char/// Translate a keyboard symbol to its approximate character./// The translation follows the `xkb_keysym_to_utf32` function./// Create a [`Keysym`] from the given `char`./// This function replecates the `xkb_utf32_to_keysym` behavior./// Get the keyboard symbol from a keyboard code and its column./// `min_keycode` can be retrieved from the X11 setup, and `keysyms_per_keycode` and `keysyms` can be/// retrieved from the X11 server through the `GetKeyboardMapping` request./// Convert a keysym to its uppercase/lowercase equivalents.ucsCodePair// We don't use the uint32_t types here, to save some space.KEYSYMTAB763keysym_from_char/*
     * Copyright © 2009 Dan Nicholson
     *
     * Permission is hereby granted, free of charge, to any person obtaining a
     * copy of this software and associated documentation files (the "Software"),
     * to deal in the Software without restriction, including without limitation
     * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     * and/or sell copies of the Software, and to permit persons to whom the
     * Software is furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice (including the next
     * paragraph) shall be included in all copies or substantial portions of the
     * Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
     * DEALINGS IN THE SOFTWARE.
     */// NOTE: Tests were taken from https://github.com/xkbcommon/libxkbcommon/blob/f3210cbf/test/keysym.c#L229// and are under MIT license.// the Zlib license ("the Licenses"), you may not use this file except in// The KEYSYMTAB, CodePair, Keysym::key_char, and Keysym::from_char, including// their comments, were taken from https://github.com/xkbcommon/libxkbcommon/blob/f3210cbf/src/keysym-utf.c// which are under Public domain.//! Keyboard symbols for X11.ASN1ResultBERModeBERReaderparse_ber_generalTaggedDerValuedecode_ber/// Reads an ASN.1 value from `BERReader` and converts it to `Self`./// use yasna::{BERDecodable,BERReader,ASN1Result};/// struct Entry {///     age: i64,/// impl BERDecodable for Entry {///     fn decode_ber(reader: BERReader) -> ASN1Result<Self> {///         reader.read_sequence(|reader| {///             let name = reader.next().read_visible_string()?;///             let age = reader.next().read_i64()?;///             return Ok(Entry {///                 name: name,///                 age: age,///     let entry : Entry = yasna::decode_der(///         &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]).unwrap();///     assert_eq!(entry.name, "John");///     assert_eq!(entry.age, 32);BERDecodable/// Types decodable in BER./// use yasna;/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();/// assert_eq!(asn, 65535);/// Rust types don't correspond to ASN.1 types one-to-one. Not all kinds/// of ASN.1 types can be decoded via default `BERDecodable` implementation./// If you want to decode ASN.1, you may implement `BERDecodable` for your/// own types or use [`parse_der`](crate::parse_der)//// [`parse_ber`](crate::parse_ber)./// # Default implementations/// - The decoder for `Vec<T>` is implemented as SEQUENCE OF decoder./// - `()` as NULL decoder./// - Tuples (except `()`) as SEQUENCE decoder./// - `Vec<u8>` as OCTETSTRING decoder./// - `BitVec` as BITSTRING decoder./// - `String` as UTF8String decoder./// - `i64`, `u64`, `i32`, `u32`, `i16`, `u16`, `BigInt`, `BigUint`///   as INTEGER decoder. (`u8` is avoided because of confliction.)/// - `bool` as BOOLEAN decoder./// - `ObjectIdentifier` as OBJECTT IDENTIFIER decoder./// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime decoder.decode_ber_general/// Decodes DER/BER-encoded data./// [`decode_ber`] and [`decode_der`] are shorthands/// Reads an ASN.1 value from `&[u8]`./// If you want to accept only DER-encoded data,/// use [`decode_der`]./// let asn : i64 = yasna::decode_ber(&[2, 3, 0, 255, 255]).unwrap();/// If you want to decode BER-encoded data in general,/// use [`decode_ber`].// Copyright 2016 Masaki Haradeserializerserializerconstruct_dertry_construct_derconstruct_der_seqtry_construct_der_seqDERWriterSetBERReaderSeqBERReaderSetASN1ErrorKindDEREncodableencode_derPCBit/// The bit's value is "Primitive"/// The bit's value is "Constructed"/// A value of the ASN.1 primitive/constructed ("P/C") bit.TagClass/// The UNIVERSAL tag class/// The APPLICATION tag class/// The CONTEXT-SPECIFIC tag class/// The PRIVATE tag class/// An ASN.1 tag class, used in [`Tag`]./// A tag class is one of:/// - UNIVERSAL/// - APPLICATION/// - context specific/// - PRIVATETAG_CLASSES/// The tag class/// The tag number/// An ASN.1 tag./// An ASN.1 tag is a pair of a tag class and a tag number./// - A tag class is one of:///   - UNIVERSAL///   - APPLICATION///   - context specific///   - PRIVATE/// - A tag number is a nonnegative integer.///   In this library, tag numbers are assumed to fit into `u64`./// Constructs an APPLICATION tag, namely \[APPLICATION n\]./// Constructs a context specific tag, namely \[n\]./// Constructs a PRIVATE tag, namely \[PRIVATE n\].//! A library for reading and writing ASN.1 data.//! ## Encoding/decoding simple data//! A type implementing [`DEREncodable`] can be easily encoded://!     let der = yasna::encode_der(&(10, true));//!     println!("(10, true) = {:?}", der);//! Similarly, a type implementing [`BERDecodable`] can be//! easily decoded://!     let asn: (i64, bool) = yasna::decode_der(//!         &[48, 6, 2, 1, 10, 1, 1, 255]).unwrap();//!     println!("{:?} = [48, 6, 2, 1, 10, 1, 1, 255]", asn);//! ## Encoding/decoding by hand//! The default [`DEREncodable`]/[`BERDecodable`] implementations can't handle//! all ASN.1 types. In many cases you have to write your reader/writer//! by hand.//! To serialize ASN.1 data, you can use [`construct_der`].//!     let der = yasna::construct_der(|writer| {//!         writer.write_sequence(|writer| {//!             writer.next().write_i64(10);//!             writer.next().write_bool(true);//! To deserialize ASN.1 data, you can use [`parse_ber`] or [`parse_der`].//!     let asn = yasna::parse_der(&[48, 6, 2, 1, 10, 1, 1, 255], |reader| {//!         reader.read_sequence(|reader| {//!             let i = reader.next().read_i64()?;//!             let b = reader.next().read_bool()?;//!             return Ok((i, b));//!     }).unwrap();pcbit/// Container for a tag and arbitrary DER value./// When obtained by `BERReader::read_tagged_der` in DER mode,/// the reader verifies that the payload is actually valid DER./// When constructed from bytes, the caller is responsible for/// providing valid DER.from_octetstring/// Constructs a new `TaggedDerValue` as an octet stringfrom_tag_and_bytes/// Constructs a new `TaggedDerValue` from its tag and contentfrom_tag_pc_and_bytes/// Constructs a new `TaggedDerValue` from its tag,/// primitive/constructed bit, and content/// Returns the tag/// Returns the primitive/constructed bit/// Returns the value/// If the value is something that contains raw bytes,/// returns its content./// use yasna::models::TaggedDerValue;/// let value = TaggedDerValue::from_octetstring(vec![1, 2, 3, 4, 5, 6]);/// assert!(value.as_bytes() == Some(&[1, 2, 3, 4, 5, 6]));/// If the value is something string-like, returns it as string.// Copyright 2017 Fortanix, Inc.ParseOidError//! Provides datatypes which correspond to ASN.1 types./// A type that represents object identifiers./// This is actually a thin wrapper of `Vec<u64>`./// use yasna::models::ObjectIdentifier;/// let sha384WithRSAEncryption = ObjectIdentifier::from_slice(&///     [1, 2, 840, 113549, 1, 1, 12]);/// println!("{}", sha384WithRSAEncryption);/// Constructs a new `ObjectIdentifier` from `Vec<u64>`./// let pkcs1 = ObjectIdentifier::new(///     [1, 2, 840, 113549, 1, 1].to_vec());/// println!("{}", pkcs1);/// Constructs a new `ObjectIdentifier` from `&[u64]`./// let pkcs1 = ObjectIdentifier::from_slice(&///     [1, 2, 840, 113549, 1, 1]);/// Borrows its internal vector of components./// let components : &Vec<u64> = pkcs1.components();/// Mutably borrows its internal vector of components./// let mut pkcs1 = ObjectIdentifier::from_slice(&/// let components : &mut Vec<u64> = pkcs1.components_mut();into_components/// Extracts its internal vector of components./// let mut components : Vec<u64> = pkcs1.into_components();/// An error indicating failure to parse an Object identifiertest_display_oidparse_oid/// Date and time between 1950-01-01T00:00:00Z and 2049-12-31T23:59:59Z./// It cannot express fractional seconds and leap seconds./// It doesn't carry timezone information./// Corresponds to ASN.1 UTCTime type. Often used in conjunction with/// [`GeneralizedTime`]./// # Features/// This struct is enabled by `time` feature./// yasna = { version = "*", features = ["time"] }/// use yasna::models::UTCTime;/// let datetime = *UTCTime::parse(b"8201021200Z").unwrap().datetime();/// assert_eq!(datetime.year(), 1982);/// assert_eq!(datetime.month() as u8, 1);/// assert_eq!(datetime.day(), 2);/// assert_eq!(datetime.hour(), 12);/// assert_eq!(datetime.minute(), 0);/// assert_eq!(datetime.second(), 0);/// assert_eq!(datetime.nanosecond(), 0);/// Parses ASN.1 string representation of UTCTime./// let datetime = UTCTime::parse(b"000229123456Z").unwrap();/// assert_eq!(&datetime.to_string(), "000229123456Z");/// It returns `None` if the given string does not specify a correct/// datetime./// # Interpretation/// While neither X.680 nor X.690 specify interpretation of 2-digits year,/// X.501 specifies that UTCTime in Time shall be interpreted as between/// 1950 and 2049. This method parses the string according to the X.501/// rule.from_datetime/// Constructs `UTCTime` from an `OffsetDateTime`./// Panics when UTCTime can't represent the datetime. That is:/// - The year is not between 1950 and 2049./// - It is in a leap second./// - It has a non-zero nanosecond value.from_datetime_opt/// It returns `None` when UTCTime can't represent the datetime. That is:/// Returns the `OffsetDateTime` it represents./// Returns ASN.1 canonical representation of the datetime as `Vec<u8>`./// Returns ASN.1 canonical representation of the datetime as `String`.sub_nanois_leap_second// TODO: time does not support leap seconds. This is a simple hack to support round-tripping./// Date and time between 0000-01-01T00:00:00Z and 9999-12-31T23:59:60.999...Z./// It can contain arbitrary length of decimal fractional seconds./// However, it doesn't carry accuracy information./// It can also contain leap seconds./// The datetime is canonicalized to UTC./// Corresponds to ASN.1 GeneralizedTime type. Often used in conjunction with/// [`UTCTime`]./// use yasna::models::GeneralizedTime;///     *GeneralizedTime::parse(b"19851106210627.3Z").unwrap().datetime();/// assert_eq!(datetime.year(), 1985);/// assert_eq!(datetime.month() as u8, 11);/// assert_eq!(datetime.day(), 6);/// assert_eq!(datetime.hour(), 21);/// assert_eq!(datetime.minute(), 6);/// assert_eq!(datetime.second(), 27);/// assert_eq!(datetime.nanosecond(), 300_000_000);parse_general/// Almost same as `parse`. It takes `default_offset` however./// GeneralizedTime value can omit offset in local time./// In that case, `default_offset` is used instead./// Parses ASN.1 string representation of GeneralizedTime./// let datetime = GeneralizedTime::parse(b"1985110621.14159Z").unwrap();/// assert_eq!(&datetime.to_string(), "19851106210829.724Z");parse_with_offset/// Parses ASN.1 string representation of GeneralizedTime, with the/// default timezone for local time given./// Constructs `GeneralizedTime` from an `OffsetDateTime`./// Panics when GeneralizedTime can't represent the datetime. That is:/// - The year is not between 0 and 9999./// It returns `None` when GeneralizedTime can't represent the datetime./// That is:from_datetime_and_sub_nano/// Constructs `GeneralizedTime` from an `OffsetDateTime` and sub-nanoseconds/// digits./// It also panics if `sub_nano` contains a non-digit character.from_datetime_and_sub_nano_opt/// It also returns `None` if `sub_nano` contains a non-digit character./// Leap seconds and sub-nanoseconds digits will be discarded./// Returns sub-nanoseconds digits of the datetime.test_utctime_parsetest_generalized_time_parseStackOverflowTAG_EOCTAG_BOOLEANTAG_INTEGERTAG_OCTETSTRINGTAG_NULLTAG_OIDTAG_UTF8STRINGTAG_SEQUENCETAG_SETTAG_ENUMTAG_NUMERICSTRINGTAG_PRINTABLESTRINGTAG_VISIBLESTRINGTAG_IA5STRING/// Parses DER/BER-encoded data./// [`parse_ber`] and [`parse_der`] are shorthands/// Parses BER-encoded data./// This function uses the loan pattern: `callback` is called back with/// a [`BERReader`], from which the ASN.1 value is read./// If you want to accept only DER-encoded data, use [`parse_der`]./// let data = &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0];/// let asn = yasna::parse_ber(data, |reader| {///     reader.read_sequence(|reader| {///         let i = reader.next().read_i64()?;///         let b = reader.next().read_bool()?;///         return Ok((i, b));/// println!("{:?} = [48, 128, 2, 1, 10, 1, 1, 255, 0, 0]", asn);/// Parses DER-encoded data./// If you want to parse BER-encoded data in general,/// use [`parse_ber`]./// let data = &[48, 6, 2, 1, 10, 1, 1, 255];/// let asn = yasna::parse_der(data, |reader| {/// println!("{:?} = [48, 6, 2, 1, 10, 1, 1, 255]", asn);/// Use BER (Basic Encoding Rules)./// Use DER (Distinguished Encoding Rules)./// Used by [`BERReader`] to determine whether or not to enforce/// DER restrictions when parsing.BERReaderImplPC_BITSBER_READER_STACK_DEPTHend_of_bufend_of_contentsread_identifierlookahead_tagread_generalskip_generalread_with_bufferread_optionalimplicit_tag/// A reader object for BER/DER-encoded ASN.1 data./// The two main sources of `BERReaderSeq` are:/// - The [`parse_ber`]/[`parse_der`] function,///   the starting point of DER serialization./// - The [`next`](BERReaderSeq::next) method of [`BERReaderSeq`]./// let data = &[2, 1, 10];///     reader.read_i64()/// assert_eq!(asn, 10);/// Tells which format we are parsing, BER or DER./// Reads an ASN.1 BOOLEAN value as `bool`./// let data = &[1, 1, 255];///     reader.read_bool()/// assert_eq!(asn, true);/// Reads an ASN.1 ENUMERATED value as `i64`./// let data = &[10, 1, 13];///     reader.read_enum()/// assert_eq!(asn, 13);/// Except parse errors, it can raise integer overflow errors./// Reads an ASN.1 INTEGER value as `i64`./// let data = &[2, 4, 73, 150, 2, 210];/// assert_eq!(asn, 1234567890);/// Reads an ASN.1 INTEGER value as `u64`./// Reads an ASN.1 INTEGER value as `i32`./// Reads an ASN.1 INTEGER value as `u32`./// Reads an ASN.1 INTEGER value as `i16`./// Reads an ASN.1 INTEGER value as `u16`./// Reads an ASN.1 INTEGER value as `i8`./// Reads an ASN.1 INTEGER value as `u8`.read_bigint_bytes/// Reads an ASN.1 INTEGER value as `Vec<u8>` and a sign bit./// The number given is in big endian byte ordering, and in two's/// complement./// The sign bit is `true` if the number is positive,/// and false if it is negative./// let (bytes, nonnegative) = yasna::parse_der(data, |reader| {///     reader.read_bigint_bytes()/// assert_eq!(&bytes, &[73, 150, 2, 210]);/// assert_eq!(nonnegative, true);read_bitvec_implread_bitvec_bytes/// Reads an ASN.1 BITSTRING value as `(Vec<u8>, usize)`./// let data = &[3, 4, 6, 117, 13, 64];///     reader.read_bitvec_bytes()/// assert_eq!(asn, (vec![117, 13, 64], 18));/// This method is enabled by `bit-vec` feature./// yasna = { version = "*", features = ["bit-vec"] }read_bytes_impl/// Reads an ASN.1 OCTETSTRING value as `Vec<u8>`./// let data = &[36, 128, 4, 2, 72, 101, 4, 4, 108, 108, 111, 33, 0, 0];///     reader.read_bytes()/// assert_eq!(&asn, b"Hello!");read_null/// Reads the ASN.1 NULL value./// let data = &[5, 0];///     reader.read_null()/// assert_eq!(asn, ());read_oid/// Reads an ASN.1 object identifier./// let data = &[6, 8, 42, 134, 72, 134, 247, 13, 1, 1];///     reader.read_oid()/// assert_eq!(&*asn.components(), &[1, 2, 840, 113549, 1, 1]);read_utf8string/// Reads an ASN.1 UTF8String./// let data = &[///     12, 29, 103, 110, 97, 119, 32, 207, 129, 206, 191, 206,///     186, 206, 177, 206, 189, 206, 175, 206, 182, 207,///     137, 32, 240, 170, 152, 130, 227, 130, 139];///     reader.read_utf8string()/// assert_eq!(&asn, "gnaw ροκανίζω 𪘂る");read_sequence/// Reads an ASN.1 SEQUENCE value./// a [`BERReaderSeq`], from which the contents of the/// SEQUENCE is read./// assert_eq!(asn, (10, true));read_sequence_of/// Reads an ASN.1 SEQUENCE OF value./// a [`BERReader`], from which the contents of the/// SEQUENCE OF is read./// This function doesn't return values. Instead, use mutable values to/// maintain read values. `collect_set_of` can be an alternative./// let data = &[48, 7, 2, 1, 10, 2, 2, 255, 127];///     let mut numbers = Vec::new();///     reader.read_sequence_of(|reader| {///         numbers.push(reader.read_i64()?);///     return Ok(numbers);/// assert_eq!(&asn, &[10, -129]);collect_sequence_of/// Collects an ASN.1 SEQUENCE OF value./// If you don't like `Vec`, you can use `read_sequence_of` instead.///     reader.collect_sequence_of(|reader| {///         reader.read_i64()read_set/// Reads an ASN.1 SET value./// a [`BERReaderSet`], from which the contents of the/// SET are read./// For SET OF values, use `read_set_of` instead./// use yasna::tags::{TAG_INTEGER,TAG_BOOLEAN};/// let data = &[49, 6, 1, 1, 255, 2, 1, 10];///     reader.read_set(|reader| {///         let i = reader.next(&[TAG_INTEGER])?.read_i64()?;///         let b = reader.next(&[TAG_BOOLEAN])?.read_bool()?;read_set_of/// Reads an ASN.1 SET OF value./// SET OF are read./// This function doesn't sort the elements. In DER, it is assumed that/// the elements occur in an order determined by DER encodings of them./// For SET values, use `read_set` instead./// let data = &[49, 7, 2, 1, 10, 2, 2, 255, 127];///     reader.read_set_of(|reader| {/// assert_eq!(asn, vec![10, -129]);collect_set_of/// Collects an ASN.1 SET OF value./// SET OF is read./// If you don't like `Vec`, you can use `read_set_of` instead.///     reader.collect_set_of(|reader| {read_numeric_string/// Reads an ASN.1 NumericString./// let data = &[18, 7, 49, 50, 56, 32, 50, 53, 54];///     reader.read_numeric_string()/// assert_eq!(&asn, "128 256");read_printable_string/// Reads an ASN.1 PrintableString./// let data = &[19, 9, 67, 111, 46, 44, 32, 76, 116, 100, 46];///     reader.read_printable_string()/// assert_eq!(&asn, "Co., Ltd.");read_ia5_string/// Reads an ASN.1 IA5String./// let data = &[22, 9, 0x41, 0x53, 0x43, 0x49, 0x49, 0x20, 0x70, 0x6C, 0x7A];///     reader.read_ia5_string()/// assert_eq!(&asn, "ASCII plz");read_bmp_string/// Reads an ASN.1 BMPString./// let data = &[30, 14, 0x00, 0xA3, 0x03, 0xC0, 0x00, 0x20, 0x00, 0x71, 0x00, 0x75, 0x00, 0x75, 0x00, 0x78];///     reader.read_bmp_string()/// assert_eq!(&asn, "£π quux");read_utctime/// Reads an ASN.1 UTCTime.///     23, 15, 56, 50, 48, 49, 48, 50, 48,///     55, 48, 48, 45, 48, 53, 48, 48];///     reader.read_utctime()/// assert_eq!(asn.datetime().unix_timestamp(), 378820800);/// This method is enabled by `time` feature.read_generalized_time/// Reads an ASN.1 GeneralizedTime.///     24, 17, 49, 57, 56, 53, 49, 49, 48, 54,///     50, 49, 46, 49, 52, 49, 53, 57, 90];///     reader.read_generalized_time()/// assert_eq!(asn.datetime().unix_timestamp(), 500159309);read_visible_string/// Reads an ASN.1 VisibleString./// let data = &[26, 3, 72, 105, 33];///     reader.read_visible_string()/// assert_eq!(&asn, "Hi!");read_tagged/// Reads a (explicitly) tagged value./// use yasna::{self,Tag};/// let data = &[163, 3, 2, 1, 10];///     reader.read_tagged(Tag::context(3), |reader| {read_tagged_implicit/// Reads an implicitly tagged value./// let data = &[131, 1, 10];///     reader.read_tagged_implicit(Tag::context(3), |reader| {/// Lookaheads the tag in the next value. Used to parse CHOICE values./// use yasna::tags::*;/// let data = &[48, 5, 2, 1, 10, 5, 0];///         let tag = reader.lookahead_tag()?;///         let choice;///         if tag == TAG_INTEGER {///             choice = Some(reader.read_i64()?);///             reader.read_null()?;///             choice = None;///         return Ok(choice);/// assert_eq!(&asn, &[Some(10), None]);read_tagged_der/// Read an arbitrary (tag, value) pair as a TaggedDerValue./// The length is not included in the returned payload. If the/// payload has indefinite-length encoding, the EOC bytes are/// included in the returned payload./// use yasna::tags::TAG_OCTETSTRING;/// let data = b"\x04\x06Hello!";/// let res = yasna::parse_der(data, |reader| reader.read_tagged_der()).unwrap();/// assert_eq!(res, TaggedDerValue::from_tag_and_bytes(TAG_OCTETSTRING, b"Hello!".to_vec()));read_der/// Reads a DER object as raw bytes. Tag and length are included/// in the returned buffer. For indefinite length encoding, EOC bytes/// are included in the returned buffer as well./// let res = yasna::parse_der(data, |reader| reader.read_der()).unwrap();/// assert_eq!(res, data);/// A reader object for a sequence of BER/DER-encoded ASN.1 data./// The main source of this object is the [`read_sequence`] method from/// [`BERReader`]./// [`read_sequence`]: BERReader::read_sequence/// Generates a new [`BERReader`]./// Tries to read an ASN.1 value. If it fails at the first tag,/// it doesn't consume buffer and returns `None`./// Used to parse OPTIONAL elements./// let data = &[48, 3, 1, 1, 255];///         let i = reader.read_optional(|reader| {///             reader.read_i64()/// assert_eq!(asn, (None, true));read_default/// Similar to [`read_optional`](Self::read_optional),/// but uses `default` if it fails./// `T: Eq` is required because it fails in DER mode if the read value/// is equal to `default`./// Used to parse DEFAULT elements.///         let i = reader.read_default(10, |reader| {impl_ref/// A reader object for a set of BER/DER-encoded ASN.1 data./// The main source of this object is the [`read_set`](BERReader::read_set)/// method from [`BERReader`]./// This method needs `tag_hint` to determine the position of the data./// If there is a set element with a tag in `tag_hint`, reads an ASN.1/// value from that element and returns `Some(_)`./// Otherwise, returns `None`./// let data = &[49, 3, 1, 1, 255];///         let i = reader.read_optional(&[TAG_INTEGER], |reader| {///         let i = reader.read_default(&[TAG_INTEGER], 10, |reader| {// Copyright 2017,2019 Fortanix, Inc.test_der_read_bool_oktest_der_read_bool_errtest_ber_read_bool_oktest_ber_read_bool_errtest_der_read_i64_oktest_der_read_i64_errtest_ber_read_i64_oktest_ber_read_i64_errtest_general_read_i64_oktest_general_read_i64_errtest_der_read_u64_oktest_der_read_u64_errtest_ber_read_u64_oktest_ber_read_u64_errtest_general_read_u64_oktest_general_read_u64_errtest_der_read_i32_oktest_der_read_i32_errtest_ber_read_i32_oktest_ber_read_i32_errtest_general_read_i32_oktest_general_read_i32_errtest_der_read_u32_errtest_ber_read_u32_oktest_ber_read_u32_errtest_general_read_u32_oktest_general_read_u32_errtest_der_read_i16_oktest_der_read_i16_errtest_ber_read_i16_oktest_ber_read_i16_errtest_general_read_i16_oktest_general_read_i16_errtest_der_read_u16_oktest_der_read_u16_errtest_ber_read_u16_oktest_ber_read_u16_errtest_general_read_u16_oktest_general_read_u16_errtest_der_read_i8_oktest_der_read_i8_errtest_ber_read_i8_oktest_ber_read_i8_errtest_general_read_i8_oktest_general_read_i8_errtest_der_read_u8_oktest_der_read_u8_errtest_ber_read_u8_oktest_ber_read_u8_errtest_general_read_u8_oktest_general_read_u8_errtest_der_read_bytes_oktest_der_read_bytes_errtest_ber_read_bytes_oktest_ber_read_bytes_errtest_der_read_null_oktest_der_read_null_errtest_ber_read_null_oktest_ber_read_null_errtest_der_read_sequence_oktest_der_read_sequence_errtest_der_read_tagged_der_errtest_ber_read_sequence_oktest_ber_read_sequence_errtest_der_read_set_oktest_der_read_set_errtest_ber_read_set_oktest_ber_read_set_errtest_der_read_set_of_oktest_der_read_set_of_errtest_ber_read_set_of_oktest_ber_read_set_of_errtest_der_read_tagged_oktest_der_read_tagged_errtest_ber_read_tagged_oktest_ber_read_tagged_errtest_der_read_tagged_implicit_oktest_der_read_tagged_implicit_errtest_ber_read_tagged_implicit_oktest_ber_read_tagged_implicit_errtest_ber_read_overflow/// Writes the value as an DER-encoded ASN.1 value./// use yasna::{DEREncodable,DERWriter};/// impl DEREncodable for Entry {///     fn encode_der(&self, writer: DERWriter) {///         writer.write_sequence(|writer| {///             writer.next().write_visible_string(&self.name);///             writer.next().write_i64(self.age);///     let entry = Entry {///         name: String::from("John"),///         age: 32,///     let der = yasna::encode_der(&entry);///     assert_eq!(&der, &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]);/// Types encodable in DER./// let der = yasna::encode_der::<i64>(&65535);/// assert_eq!(&der, &[2, 3, 0, 255, 255]);/// of ASN.1 types can be encoded via default `DEREncodable` implementation./// If you want to encode ASN.1, you may implement `DEREncodable` for your/// own types or use [`construct_der`]./// - The encoder for `Vec<T>`/`[T]` is implemented as SEQUENCE OF encoder./// - `()` as NULL encoder./// - Tuples (except `()`) as SEQUENCE encoder./// - `Vec<u8>`/`[u8]` as OCTETSTRING encoder./// - `BitVec` as BITSTRING encoder./// - `String`/`str` as UTF8String encoder.///   as INTEGER encoder. (`u8` is avoided because of confliction.)/// - `bool` as BOOLEAN encoder./// - `ObjectIdentifier` as OBJECTT IDENTIFIER encoder./// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime encoder./// Encodes a value to DER-encoded ASN.1 data./// A special tag representing "end of contents"./// A universal tag for BOOLEAN./// A universal tag for INTEGER.TAG_BITSTRING/// A universal tag for BITSTRING./// A universal tag for OCTETSTRING./// A universal tag for NULL./// A universal tag for object identifiers.TAG_OBJECT_DESCRIPTOR/// A universal tag for object descriptors.TAG_EXT/// A universal tag for external/instance-of types.TAG_REAL/// A universal tag for REAL./// A universal tag for enumerated types.TAG_EMBEDDED_PDV/// A universal tag for embedded-pdv types./// A universal tag for UTF8String.TAG_RELATIVE_OID/// A universal tag for relative object identifiers.TAG_TIME/// A universal tag for TIME./// A universal tag for SEQUENCE/SEQUENCE OF./// A universal tag for SET/SET OF./// A universal tag for NumericString./// A universal tag for PrintableString./// A universal tag for TeletexString.TAG_VIDEOTEXSTRING/// A universal tag for VideotexString./// A universal tag for IA5String.TAG_UTCTIME/// A universal tag for UTCTime.TAG_GENERALIZEDTIME/// A universal tag for GeneralizedTime.TAG_GRAPHICSTRING/// A universal tag for GraphicString./// A universal tag for VisibleString.TAG_GENERALSTRING/// A universal tag for GeneralString./// A universal tag for UniversalString./// A universal tag for BMPString./// A universal tag for DATE.TAG_TIME_OF_DAY/// A universal tag for TIME-OF-DAY./// A universal tag for DATE-TIME./// A universal tag for DURATION.TAG_OID_INTL_RESID/// A universal tag for OID internationalized resource identifiers.TAG_RELATIVE_OID_INTL_RESID/// A universal tag for relative OID internationalized resource identifiers.//! Provides universal tag constants./// Constructs DER-encoded data as `Vec<u8>`./// a [`DERWriter`], to which the ASN.1 value is written./// let der = yasna::construct_der(|writer| {///     writer.write_sequence(|writer| {///         writer.next().write_i64(10);///         writer.next().write_bool(true);/// assert_eq!(der, vec![48, 6, 2, 1, 10, 1, 1, 255]);/// Tries to construct DER-encoded data as `Vec<u8>`./// Same as [`construct_der`], only that it allows/// returning an error from the passed closure./// a [`DERWriterSeq`], to which the ASN.1 values are written./// let res_ok = yasna::try_construct_der::<_, ()>(|writer| {/// let res_err = yasna::try_construct_der::<_, &str>(|writer| {///         return Err("some error here");/// assert_eq!(res_ok, Ok(vec![48, 6, 2, 1, 10, 1, 1, 255]));/// assert_eq!(res_err, Err("some error here"));/// Constructs DER-encoded sequence of data as `Vec<u8>`./// This is similar to [`construct_der`], but this function/// accepts more than one ASN.1 values./// let der = yasna::construct_der_seq(|writer| {///     writer.next().write_i64(10);///     writer.next().write_bool(true);/// assert_eq!(der, vec![2, 1, 10, 1, 1, 255]);/// Tries to construct a DER-encoded sequence of data as `Vec<u8>`./// Same as [`construct_der_seq`], only that it allows/// let res_ok = yasna::try_construct_der_seq::<_, ()>(|writer| {/// let res_err = yasna::try_construct_der_seq::<_, &str>(|writer| {///     return Err("some error here");/// assert_eq!(res_ok, Ok(vec![2, 1, 10, 1, 1, 255]));/// A writer object that accepts an ASN.1 value./// The two main sources of `DERWriterSeq` are:/// - The [`construct_der`] function, the starting point of///   DER serialization./// - The [`next`](DERWriterSeq::next) method of [`DERWriterSeq`].///     writer.write_i64(10)/// assert_eq!(der, vec![2, 1, 10]);write_identifier/// Writes BER identifier (tag + primitive/constructed) octets./// Writes BER length octets./// Deals with unknown length procedures./// This function first marks the current position and/// allocates 3 bytes. Then it calls back `callback`./// It then calculates the length and moves the written data/// to the actual position. Finally, it writes the length./// Writes `bool` as an ASN.1 BOOLEAN value.///     writer.write_bool(true)/// assert_eq!(der, vec![1, 1, 255]);write_integer/// Writes `i64` as an ASN.1 ENUMERATED value.///     writer.write_enum(2)/// assert_eq!(der, vec![10, 1, 2]);/// Writes `i64` as an ASN.1 INTEGER value.///     writer.write_i64(1234567890)/// assert_eq!(der, vec![2, 4, 73, 150, 2, 210]);/// Writes `u64` as an ASN.1 INTEGER value./// Writes `i32` as an ASN.1 INTEGER value./// Writes `u32` as an ASN.1 INTEGER value./// Writes `i16` as an ASN.1 INTEGER value./// Writes `u16` as an ASN.1 INTEGER value./// Writes `i8` as an ASN.1 INTEGER value./// Writes `u8` as an ASN.1 INTEGER value.write_bigint_bytes/// Writes `&[u8]` and `bool` as an ASN.1 INTEGER value./// The first parameter encodes the bytes of the integer, in big-endian/// byte ordering and two's complement format. The second parameter encodes/// the sign, and is true if the number is non-negative, and false if it is/// negative. Zero is encoded by passing an empty slice./// The number is expected to be in two's complement format, so for example/// `1` is encoded as `[1]` and `-1` as `[255]`./// You don't have to worry about leading bits, meaning that if the leading/// bit of a positive number is not zero, a leading zero byte will be/// encoded by the function. Similarly, if the leading bit of a negative/// number is not one, a leading byte will be added by the function as well.///     // Encodes 1234567890///     writer.write_bigint_bytes(&[73, 150, 2, 210], true)write_bitvec_bytes/// Writes `&[u8]` and `usize` as an ASN.1 BITSTRING value./// The `len` parameter represents the number of bits to be encoded./// This function is similar to `write_bitvec`, with `to_bytes` applied to/// the bitvec, but is available even if the `bit-vec` feature is disabled./// let der_1 = yasna::construct_der(|writer| {///     writer.write_bitvec_bytes(&[117, 13, 64], 18)/// let der_2 = yasna::construct_der(|writer| {///     writer.write_bitvec_bytes(&[117, 13, 65], 18)/// assert_eq!(&der_1, &[3, 4, 6, 117, 13, 64]);/// assert_eq!(&der_2, &[3, 4, 6, 117, 13, 64]);/// Writes `&[u8]` as an ASN.1 OCTETSTRING value.///     writer.write_bytes(b"Hello!")/// assert_eq!(der, vec![4, 6, 72, 101, 108, 108, 111, 33]);write_utf8_string/// Writes `&str` as an ASN.1 UTF8String value.///     writer.write_utf8_string("Hello!")/// assert_eq!(der, vec![12, 6, 72, 101, 108, 108, 111, 33]);write_ia5_string/// Writes `&str` as an ASN.1 IA5String value.///     writer.write_ia5_string("Hello!")/// assert_eq!(der, vec![22, 6, 72, 101, 108, 108, 111, 33]);write_bmp_string/// Writes `&str` as an ASN.1 BMPString value.///     writer.write_bmp_string("❤πü2?")/// assert_eq!(der, vec![30, 10, 39, 100, 3, 192, 0, 252, 0, 50, 0, 63]);/// Writes the ASN.1 NULL value.///     writer.write_null()/// assert_eq!(der, vec![5, 0]);write_oid/// Writes an ASN.1 object identifier.///     writer.write_oid(&ObjectIdentifier::from_slice(///         &[1, 2, 840, 113549, 1, 1]))/// assert_eq!(&der, &[6, 8, 42, 134, 72, 134, 247, 13, 1, 1]);/// It panics when the OID cannot be canonically encoded in BER.write_utf8string/// Writes an ASN.1 UTF8String.///     writer.write_utf8string("gnaw ροκανίζω 𪘂る")/// assert_eq!(&der, &[///     137, 32, 240, 170, 152, 130, 227, 130, 139]);write_sequence/// Writes ASN.1 SEQUENCE./// a [`DERWriterSeq`], to which the contents of the/// SEQUENCE is written./// This is equivalent to [`write_sequence_of`](Self::write_sequence_of)/// in behavior.write_sequence_of/// Writes ASN.1 SEQUENCE OF./// SEQUENCE OF are written./// This is equivalent to [`write_sequence`](Self::write_sequence) in///     writer.write_sequence_of(|writer| {///         for &i in &[10, -129] {///             writer.next().write_i64(i);/// assert_eq!(der, vec![48, 7, 2, 1, 10, 2, 2, 255, 127]);write_set/// Writes ASN.1 SET./// a [`DERWriterSet`], to which the contents of the/// SET are written./// For SET OF values, use [`write_set_of`](Self::write_set_of) instead.///     writer.write_set(|writer| {/// assert_eq!(der, vec![49, 6, 1, 1, 255, 2, 1, 10]);write_set_of/// Writes ASN.1 SET OF./// SET OF are written./// For SET values, use [`write_set`](Self::write_set) instead.///     writer.write_set_of(|writer| {/// assert_eq!(der, vec![49, 7, 2, 1, 10, 2, 2, 255, 127]);write_numeric_string/// Writes an ASN.1 NumericString.///     writer.write_numeric_string("128 256")/// assert_eq!(&der, &[18, 7, 49, 50, 56, 32, 50, 53, 54]);write_printable_string/// Writes an ASN.1 PrintableString.///     writer.write_printable_string("Co., Ltd.")/// assert_eq!(&der, &[19, 9, 67, 111, 46, 44, 32, 76, 116, 100, 46]);write_utctime/// Writes an ASN.1 UTCTime./// use time::OffsetDateTime;///     writer.write_utctime(///         &UTCTime::from_datetime(///             OffsetDateTime::from_unix_timestamp(378820800).unwrap()))///     23, 13, 56, 50, 48, 49, 48, 50, 49, 50, 48, 48, 48, 48, 90]);write_generalized_time/// Writes an ASN.1 GeneralizedTime.///     writer.write_generalized_time(///         &GeneralizedTime::from_datetime(///             OffsetDateTime::from_unix_timestamp_nanos(///                 500_159_309_724_000_000).unwrap()))///     24, 19, 49, 57, 56, 53, 49, 49, 48, 54, 50,///     49, 48, 56, 50, 57, 46, 55, 50, 52, 90]);write_visible_string/// Writes an ASN.1 VisibleString.///     writer.write_visible_string("Hi!")/// assert_eq!(&der, &[26, 3, 72, 105, 33]);write_tagged/// Writes an (explicitly) tagged value.///     writer.write_tagged(Tag::context(3), |writer| {///         writer.write_i64(10)/// assert_eq!(der, vec![163, 3, 2, 1, 10]);/// Note: you can achieve the same using/// [`write_tagged_implicit`](Self::write_tagged_implicit):///     writer.write_tagged_implicit(Tag::context(3), |writer| {///             let writer = writer.next();///             writer.write_i64(10)write_tagged_implicit/// Writes an implicitly tagged value./// assert_eq!(der, vec![131, 1, 10]);write_tagged_der/// Writes the arbitrary tagged DER value in `der`./// let tagged_der_value = TaggedDerValue::from_tag_and_bytes(TAG_OCTETSTRING, b"Hello!".to_vec());/// let der1 = yasna::construct_der(|writer| {///     writer.write_tagged_der(&tagged_der_value)/// let der2 = yasna::construct_der(|writer| {/// assert_eq!(der1, der2);/// Writes `&[u8]` into the DER output buffer directly. Properly encoded tag/// and length must be included at the start of the passed buffer./// let raw_der = yasna::construct_der(|writer| {///     writer.write_der(b"\x04\x06Hello!")/// assert_eq!(raw_der, der);/// A writer object that accepts ASN.1 values./// The main source of this object is the [`write_sequence`][write_sequence]/// method from [`DERWriter`]./// [write_sequence]: DERWriter::write_sequence///     writer.write_sequence(|writer : &mut yasna::DERWriterSeq| {/// Generates a new [`DERWriter`]./// The main source of this object is the [`write_set`](DERWriter::write_set)///     writer.write_set(|writer : &mut yasna::DERWriterSet| {// Copyright 2019 Fortanix, Inc.test_der_write_booltest_der_write_i64test_der_write_u64test_der_write_i32test_der_write_u32test_der_write_i16test_der_write_u16test_der_write_i8test_der_write_u8test_der_write_bigint_bytestest_der_write_bytestest_der_write_nulltest_der_write_sequence_smalltest_der_write_sequence_mediumtest_der_write_sequence_largetest_der_write_settest_der_write_set_oftest_der_write_taggedtest_der_write_tagged_implicit" Perform the async cleanup."async_drop" Async equivalent of [`Drop`]."" This trait is similar to [`Drop`], but it is async so types that need to perform async"" operations when they\'re dropped should implement this. Unfortunately, the `async_drop` method"" won\'t be implicitly called by the compiler for the user so types implementing this trait will"" also have to implement [`Drop`] to clean up (for example, by passing the async cleanup to"" another async task). This is also why the `async_drop` method consumes `self` instead of taking"" a `&mut self` like [`Drop`]."" Hopefully this will be unnecessary [in the future][itf] when Rust gain an `AsyncDrop` itself."" [itf]: https://rust-lang.github.io/async-fundamentals-initiative/roadmap/async_drop.html"AsyncDropAsyncExecutorAsyncTask/// A wrapper around the underlying runtime/executor./// This is used to run asynchronous tasks internally and allows integration with various runtimes./// See [`crate::Connection::executor`] for an example of integration with external runtimes./// **Note:** You can (and should) completely ignore this type when building with `tokio` feature/// With `tokio` feature enabled, this always returns `true`./// With `tokio` feature enabled, its a noop and never returns./// Create a new `Executor`./// With `tokio` feature enabled, it just awaits on the `future`./// A wrapper around the task API of the underlying runtime/executor./// This follows the semantics of `async_task::Task` on drop:/// * it will be cancelled, rather than detached. For detaching, use the `detach` method./// * errors from the task cancellation will will be ignored. If you need to know about task errors,///   convert the task to a `FallibleTask` using the `fallible` method./// Launch the given blocking function in a task.FileLines// Not unix-specific itself but only used on unix.//! Runtime-agnostic File I/O abstractions.//! Proving only specific API that we need internally./// This mod contains a bunch of abstractions./// These abstractions allow us to make use of the appropriate API depending on which features are/// An asynchronous wrapper around running and getting command outputTcpAddressFamily/// A `tcp:` address family.TcpAddress/// A `tcp:` D-Bus address./// Returns the `tcp:` address `host` value./// Returns the `tcp:` address `bind` value./// Returns the `tcp:` address `port` value./// Returns the `tcp:` address `family` value.from_tcp// Helper for FromStrwrite_options/// A path on the filesystem/// TCP address detailsnonce_fileNonceTcp/// TCP address details with nonce file pathAutolaunch/// Autolaunch address with optional scopeLaunchd/// Launchd address with a required env key/// A bus address/// Get the address for session socket respecting the DBUS_SESSION_BUS_ADDRESS environment/// variable. If we don't recognize the value (or it's not set) we fall back to/// $XDG_RUNTIME_DIR/bus/// Get the address for system bus respecting the DBUS_SYSTEM_BUS_ADDRESS environment/// /var/run/dbus/system_bus_socketdecode_percentsencode_percents/// Parse a D-BUS address and return its path if we recognize itparse_dbus_addressesstringify_dbus_addressesconnect_nonce_tcpInterfaceNameOwnedUniqueNameWellKnownNameObjectServerConnectionCredentialsRequestNameFlags"Dropping a `Connection` will close the underlying socket."/// A blocking wrapper of [`zbus::Connection`]./// Most of the API is very similar to [`zbus::Connection`], except it's blocking. One/// notable difference is that there is no equivalent of [`Sink`] implementation provided./// [`Sink`]: https://docs.rs/futures/0.3.17/futures/sink/trait.Sink.html/// Create a `Connection` to the session/user message bus./// Create a `Connection` to the system-wide message bus.max_queued/// The capacity of the main (unfiltered) queue.set_max_queued/// Set the capacity of the main (unfiltered) queue.server_guid/// The server's GUID./// The unique name as assigned by the message bus or `None` if not a message bus connection./// Send `msg` to the peer./// The connection sets a unique serial number on the message before sending it off./// On successfully sending off `msg`, the assigned serial number is returned./// Send a method call./// Create a method-call message, send it over the connection, then wait for the reply. Incoming/// messages are received through [`receive_message`] until the matching method reply (error or/// return) is received./// On successful reply, an `Ok(Message)` is returned. On error, an `Err` is returned. D-Bus/// error replies are returned as [`MethodError`]./// [`receive_message`]: struct.Connection.html#method.receive_message/// [`MethodError`]: enum.Error.html#variant.MethodError/// Emit a signal./// Create a signal message, and send it over the connection./// Reply to a message./// Given an existing message (likely a method call), send a reply back to the caller with the/// given `body`./// Returns the message serial number./// Reply an error to a message./// Given an existing message (likely a method call), send an error reply back to the caller/// with the given `error_name` and `body`.reply_dbus_errorMessageHeader/// Reply to a method call with an error./// Given an existing method call message header, send an error reply back to the caller/// using one of the standard interface reply types./// Register a well-known name for this service on the bus./// Blocking version of [`crate::Connection::request_name`]. See docs there for more details/// and caveats.request_name_with_flags/// Blocking version of [`crate::Connection::request_name_with_flags`]. See docs there for more/// details and caveats./// Deregister a previously registered well-known name for this service on the bus./// Use this method to deregister a well-known name, registered through/// [`Connection::request_name`]./// Unless an error is encountered, returns `Ok(true)` if name was previously registered with/// the bus through `self` and it has now been successfully deregistered, `Ok(false)` if name/// was not previously registered or already deregistered.is_bus/// Checks if `self` is a connection to a message bus./// This will return `false` for p2p connections.object_server/// Get a reference to the associated [`ObjectServer`]./// The `ObjectServer` is created on-demand./// Get a reference to the underlying async Connection./// Get the underlying async Connection, consuming `self`.monitor_activity/// Returns a listener, notified on various connection activity./// This function is meant for the caller to implement idle or timeout on inactivity./// Returns the peer credentials./// The fields are populated on the best effort basis. Some or all fields may not even make/// sense for certain sockets or on certain platforms and hence will be set to `None`./// Currently `unix_group_ids` and `linux_security_label` fields are not populated.ntestConnectionBuilderMessageIteratorunix_p2pUniqueNameAuthMechanism/// A builder for [`zbus::blocking::Connection`]./// Create a builder for the session/user message bus connection./// Create a builder for the system-wide message bus connection./// Create a builder for connection that will use the given [D-Bus bus address]./// [D-Bus bus address]: https://dbus.freedesktop.org/doc/dbus-specification.html#addressesunix_stream/// Create a builder for connection that will use the given unix stream./// If the default `async-io` feature is disabled, this method will expect/// [`tokio::net::UnixStream`](https://docs.rs/tokio/latest/tokio/net/struct.UnixStream.html)tcp_stream/// Create a builder for connection that will use the given TCP stream./// [`tokio::net::TcpStream`](https://docs.rs/tokio/latest/tokio/net/struct.TcpStream.html)auth_mechanisms/// Specify the mechanisms to use during authentication.cookie_context/// The cookie context to use during authentication./// This is only used when the `cookie` authentication mechanism is enabled and only valid for/// server connection./// If not specified, the default cookie context of `org_freedesktop_general` will be used./// If the given string is not a valid cookie context.cookie_id/// The ID of the cookie to use during authentication./// If not specified, the first cookie found in the cookie context file will be used.p2p/// The to-be-created connection will be a peer-to-peer connection./// The to-be-created connection will be a server using the given GUID./// The to-be-created connection will wait for incoming client authentication handshake and/// negotiation messages, for peer-to-peer communications after successful creation./// Since typically you'd want to set this at instantiation time, you can set it through the/// # use zbus::blocking::ConnectionBuilder;/// let conn = ConnectionBuilder::session()?///     .max_queued(30)/// assert_eq!(conn.max_queued(), 30);/// // Do something useful with `conn`../// # Ok::<_, Box<dyn Error + Send + Sync>>(())serve_at/// Register a D-Bus [`Interface`] to be served at a given path./// This is similar to [`zbus::blocking::ObjectServer::at`], except that it allows you to have/// your interfaces available immediately after the connection is established. Typically, this/// is exactly what you'd want. Also in contrast to [`zbus::blocking::ObjectServer::at`], this/// method will replace any previously added interface with the same name at the same path./// Register a well-known name for this connection on the bus./// This is similar to [`zbus::blocking::Connection::request_name`], except the name is/// requested as part of the connection setup ([`ConnectionBuilder::build`]), immediately after/// interfaces registered (through [`ConnectionBuilder::serve_at`]) are advertised. Typically/// this is exactly what you want./// Sets the unique name of the connection./// This method panics if the to-be-created connection is not a peer-to-peer connection./// It will always panic if the connection is to a message bus as it's the bus that assigns/// peers their unique names. This is mainly provided for bus implementations. All other users/// should not need to use this method./// Build the connection, consuming the builder./// Until server-side bus connection is supported, attempting to build such a connection will/// result in [`Error::Unsupported`] error.OwnedBusNameOwnedInterfaceNameOwnedValueManagedObjectsgen_introspectable_proxyIntrospectableProxyr" Proxy for the `org.freedesktop.DBus.Introspectable` interface."r" Returns an XML description of the object, including its interfaces (with signals and"r" methods), objects below it in the object path tree, and its properties."gen_properties_proxyPropertiesProxyr" Proxy for the `org.freedesktop.DBus.Properties` interface."r" Get a property value."r" Set a property value."r" Get all properties.""Create a stream that receives `PropertiesChanged` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal)."receive_properties_changedPropertiesChangedIterator"Create a stream that receives `PropertiesChanged` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal_with_args)."receive_properties_changed_with_args"A [`Iterator`] implementation that yields [`PropertiesChanged`] signals.\n\nUse [`PropertiesProxy::receive_properties_changed`] to create an instance of this type.\n\n[`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html"r" Consumes `self`, returning the underlying `zbus::#signal_type`."r" The reference to the underlying `zbus::#signal_type`."PropertiesChanged"A `PropertiesChanged` signal.""Try to construct a ""PropertiesChanged"" from a [::zbus::Message]."r" Retrieve the signal arguments."PropertiesChangedArgs"`PropertiesChanged` signal arguments."gen_object_manager_proxyObjectManagerProxyr" Proxy for the `org.freedesktop.DBus.ObjectManager` interface."r" **NB:** Changes to properties on existing interfaces are not reported using this interface."r" Please use [`PropertiesProxy::receive_properties_changed`] to monitor changes to properties on"r" objects."r" The return value of this method is a dict whose keys are object paths. All returned object"r" paths are children of the object path implementing this interface, i.e. their object paths"r" start with the ObjectManager's object path plus '/'."r" Each value is a dict whose keys are interfaces names. Each value in this inner dict is the"r" same dict that would be returned by the org.freedesktop.DBus.Properties.GetAll() method for"r" that combination of object path and interface. If an interface has no properties, the empty"r" dict is returned.""Create a stream that receives `InterfacesAdded` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal)."r" This signal is emitted when either a new object is added or when an existing object gains"r" one or more interfaces. The `interfaces_and_properties` argument contains a map with the"r" interfaces and properties (if any) that have been added to the given object path."receive_interfaces_addedInterfacesAddedIterator"Create a stream that receives `InterfacesAdded` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal_with_args)."receive_interfaces_added_with_args"Create a stream that receives `InterfacesRemoved` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal)."r" This signal is emitted whenever an object is removed or it loses one or more interfaces."r" The `interfaces` parameters contains a list of the interfaces that were removed."receive_interfaces_removedInterfacesRemovedIterator"Create a stream that receives `InterfacesRemoved` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal_with_args)."receive_interfaces_removed_with_args"A [`Iterator`] implementation that yields [`InterfacesAdded`] signals.\n\nUse [`ObjectManagerProxy::receive_interfaces_added`] to create an instance of this type.\n\n[`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html"InterfacesAdded"A `InterfacesAdded` signal.""InterfacesAdded"InterfacesAddedArgs"`InterfacesAdded` signal arguments."interfaces_and_properties"A [`Iterator`] implementation that yields [`InterfacesRemoved`] signals.\n\nUse [`ObjectManagerProxy::receive_interfaces_removed`] to create an instance of this type.\n\n[`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html"InterfacesRemoved"A `InterfacesRemoved` signal.""InterfacesRemoved"InterfacesRemovedArgs"`InterfacesRemoved` signal arguments."gen_peer_proxyPeerProxyr" Proxy for the `org.freedesktop.DBus.Peer` interface."r" On receipt, an application should do nothing other than reply as usual. It does not matter"r" which object path a ping is sent to."r" An application should reply the containing a hex-encoded UUID representing the identity of"r" the machine the process is running on. This UUID must be the same for all processes on a"r" single system at least until that system next reboots. It should be the same across reboots"r" if possible, but this is not always possible to implement and is not guaranteed. It does not"r" matter which object path a GetMachineId is sent to."gen_monitoring_proxyMonitoringProxyr" Proxy for the `org.freedesktop.DBus.Monitoring` interface."r" Converts the connection into a monitor connection which can be used as a"r" debugging/monitoring tool."become_monitorgen_stats_proxyStatsProxyr" Proxy for the `org.freedesktop.DBus.Debug.Stats` interface."r" GetStats (undocumented)"r" GetConnectionStats (undocumented)"get_connection_statsr" GetAllMatchRules (undocumented)"get_all_match_rulesgen_dbus_proxyr" Proxy for the `org.freedesktop.DBus` interface."r" Adds a match rule to match messages going through the message bus"add_match_ruler" Returns auditing data used by Solaris ADT, in an unspecified binary format."r" Returns as many credentials as possible for the process connected to the server."r" Returns the security context used by SELinux, in an unspecified format."r" Returns the Unix process ID of the process connected to the server."r" Returns the Unix user ID of the process connected to the server."r" Gets the unique ID of the bus."r" Returns the unique connection name of the primary owner of the name given."r" Returns the unique name assigned to the connection."r" Returns a list of all names that can be activated on the bus."r" Returns a list of all currently-owned names on the bus."r" List the connections currently queued for a bus name."r" Checks if the specified name exists (currently has an owner)."r" Ask the message bus to release the method caller's claim to the given name."r" Reload server configuration."r" Removes the first rule that matches."remove_match_ruler" Ask the message bus to assign the given name to the method caller."r" Tries to launch the executable associated with a name (service"r" activation), as an explicit request."r" This method adds to or modifies that environment when activating services.""Create a stream that receives `NameOwnerChanged` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal)."r" This signal indicates that the owner of a name has"r" changed. It's also the signal to use to detect the appearance"r" of new names on the bus."receive_name_owner_changedNameOwnerChangedIterator"Create a stream that receives `NameOwnerChanged` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal_with_args)."receive_name_owner_changed_with_args"Create a stream that receives `NameLost` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal)."r" This signal is sent to a specific application when it loses ownership of a name."receive_name_lostNameLostIterator"Create a stream that receives `NameLost` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal_with_args)."receive_name_lost_with_args"Create a stream that receives `NameAcquired` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal)."r" This signal is sent to a specific application when it gains ownership of a name."receive_name_acquiredNameAcquiredIterator"Create a stream that receives `NameAcquired` signals.\n\nThis a convenient wrapper around [`zbus::blocking::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/blocking/struct.Proxy.html#method.receive_signal_with_args)."receive_name_acquired_with_argsr" This property lists abstract “features” provided by the message bus, and can be used by"r" clients to detect the capabilities of the message bus with which they are communicating."" Get the cached value of the `Features` property, or `None` if the property is not cached."cached_featuresResultAdapter"Create a stream for the `Features` property changes. This is a convenient wrapper around [`zbus::blocking::Proxy::receive_property_changed`]."receive_features_changedr" This property lists interfaces provided by the `/org/freedesktop/DBus` object, and can be"r" used by clients to detect the capabilities of the message bus with which they are"r" communicating. Unlike the standard Introspectable interface, querying this property does not"r" require parsing XML. This property was added in version 1.11.x of the reference"r" implementation of the message bus."r" The standard `org.freedesktop.DBus` and `org.freedesktop.DBus.Properties` interfaces are not"r" included in the value of this property, because their presence can be inferred from the fact"r" that a method call on `org.freedesktop.DBus.Properties` asking for properties of"r" `org.freedesktop.DBus` was successful. The standard `org.freedesktop.DBus.Peer` and"r" `org.freedesktop.DBus.Introspectable` interfaces are not included in the value of this"r" property either, because they do not indicate features of the message bus implementation."" Get the cached value of the `Interfaces` property, or `None` if the property is not cached."cached_interfaces"Create a stream for the `Interfaces` property changes. This is a convenient wrapper around [`zbus::blocking::Proxy::receive_property_changed`]."receive_interfaces_changed"A [`Iterator`] implementation that yields [`NameOwnerChanged`] signals.\n\nUse [`DBusProxy::receive_name_owner_changed`] to create an instance of this type.\n\n[`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html"NameOwnerChanged"A `NameOwnerChanged` signal.""NameOwnerChanged"NameOwnerChangedArgs"`NameOwnerChanged` signal arguments."old_ownernew_owner"A [`Iterator`] implementation that yields [`NameLost`] signals.\n\nUse [`DBusProxy::receive_name_lost`] to create an instance of this type.\n\n[`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html""A `NameLost` signal.""NameLost"NameLostArgs"`NameLost` signal arguments.""A [`Iterator`] implementation that yields [`NameAcquired`] signals.\n\nUse [`DBusProxy::receive_name_acquired`] to create an instance of this type.\n\n[`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html""A `NameAcquired` signal.""NameAcquired"NameAcquiredArgs"`NameAcquired` signal arguments."//! D-Bus standard interfaces.//! Provides blocking versions of the proxy types in [`zbus::fdo`] module.OwnedMatchRuleazyncMessageStream// Wrap it in an `Option` to ensure the stream is dropped in a `block_on` call. This is needed// for tokio because the proxy spawns a task in its `Drop` impl and that needs a runtime// context in case of tokio. Moreover, we want to use `AsyncDrop::async_drop` to drop the// stream to ensure any associated match rule is deregistered before the iterator is/// A blocking wrapper of [`crate::MessageStream`]./// Just like [`crate::MessageStream`] must be continuously polled, you must continuously iterate/// over this type until it's consumed or dropped./// Get a reference to the underlying async message stream./// Get the underlying async message stream, consuming `self`.for_match_rule/// Create a message iterator for the given match rule./// This is a wrapper around [`crate::MessageStream::for_match_rule`]. Unlike the underlying/// `MessageStream`, the match rule is immediately deregistered when the iterator is dropped./// use zbus::{blocking::{Connection, MessageIterator}, MatchRule, fdo::NameOwnerChanged};/// let conn = Connection::session()?;/// let rule = MatchRule::builder()///     .msg_type(zbus::MessageType::Signal)///     .sender("org.freedesktop.DBus")?///     .interface("org.freedesktop.DBus")?///     .member("NameOwnerChanged")?///     .add_arg("org.freedesktop.zbus.MatchRuleIteratorTest42")?/// let mut iter = MessageIterator::for_match_rule(///     rule,///     &conn,///     // For such a specific match rule, we don't need a big queue.///     Some(1),/// let rule_str = "type='signal',sender='org.freedesktop.DBus',\///                 interface='org.freedesktop.DBus',member='NameOwnerChanged',\///                 arg0='org.freedesktop.zbus.MatchRuleIteratorTest42'";///     iter.match_rule().map(|r| r.to_string()).as_deref(),///     Some(rule_str),/// // We register 2 names, starting with the uninteresting one. If `iter` wasn't filtering/// // messages based on the match rule, we'd receive method return call for each of these 2/// // calls first./// // Note that the `NameOwnerChanged` signal will not be sent by the bus  for the first name/// // we register since we setup an arg filter./// conn.request_name("org.freedesktop.zbus.MatchRuleIteratorTest44")?;/// conn.request_name("org.freedesktop.zbus.MatchRuleIteratorTest42")?;/// let msg = iter.next().unwrap()?;/// let signal = NameOwnerChanged::from_message(msg).unwrap();/// assert_eq!(signal.args()?.name(), "org.freedesktop.zbus.MatchRuleIteratorTest42");/// Since this method relies on [`MatchRule::matches`], it inherits its caveats./// The associated match rule, if any.connection_buildermessage_iteratorproxy_builder//! The blocking API.//! This module hosts all our blocking API. All the types under this module are thin wrappers//! around the corresponding asynchronous types. Most of the method calls are simply calling their//! asynchronous counterparts on the underlying types and use [`async_io::block_on`] to turn them//! into blocking calls.//! Since methods provided by these types run their own little runtime (`block_on`), you must not//! use them in async contexts because of the infamous [async sandwich footgun][asf]. This is//! an especially important fact to keep in mind for [`crate::dbus_interface`]. While//! `dbus_interface` allows non-async methods for convenience, these methods are called from an//! async context. The [`blocking` crate] provides an easy way around this problem though.//! [asf]: https://rust-lang.github.io/wg-async/vision/shiny_future/users_manual.html#caveat-beware-the-async-sandwich//! [`blocking` crate]: https://docs.rs/blocking/InterfaceDerefInterfaceDerefMutSignalContext/// Wrapper over an interface, along with its corresponding `SignalContext`/// instance. A reference to the underlying interface may be obtained via/// [`InterfaceRef::get`] and [`InterfaceRef::get_mut`]./// Get a reference to the underlying interface./// **WARNINGS:** Since the `ObjectServer` will not be able to access the interface in question/// until the return value of this method is dropped, it is highly recommended that the scope/// of the interface returned is restricted./// If the interface at this instance's path is not valid, `Error::InterfaceNotFound` error is/// # use async_io::block_on;/// # use zbus::{blocking::Connection, dbus_interface};/// struct MyIface(u32);/// #[dbus_interface(name = "org.myiface.MyIface")]/// impl MyIface {///    #[dbus_interface(property)]///    fn count(&self) -> u32 {///        self.0/// // Setup connection and object_server etc here and then in another part of the code:/// # let connection = Connection::session()?;/// # let path = "/org/zbus/path";/// # connection.object_server().at(path, MyIface(22))?;/// let object_server = connection.object_server();/// let iface_ref = object_server.interface::<_, MyIface>(path)?;/// let mut iface = iface_ref.get_mut();/// iface.0 = 42;/// block_on(iface.count_changed(iface_ref.signal_context()))?;signal_context/// A blocking wrapper of [`crate::ObjectServer`]./// This example exposes the `org.myiface.Example.Quit` method on the `/org/zbus/path`/// use zbus::{blocking::Connection, dbus_interface};///     // Interfaces are owned by the ObjectServer. They can have///     // `&mut self` methods.///     quit_event: Event,/// impl Example {///     fn new(quit_event: Event) -> Self {///         Self { quit_event }/// #[dbus_interface(name = "org.myiface.Example")]///     // This will be the "Quit" D-Bus method.///     fn quit(&mut self) {///         self.quit_event.notify(1);///     // See `dbus_interface` documentation to learn///     // how to expose properties & signals as well./// let connection = Connection::session()?;/// let quit_event = Event::new();/// let quit_listener = quit_event.listen();/// let interface = Example::new(quit_event);/// connection///     .object_server()///     .at("/org/zbus/path", interface)?;/// quit_listener.wait();/// Creates a new D-Bus `ObjectServer`./// Register a D-Bus [`Interface`] at a given path. (see the example above)/// Typically you'd want your interfaces to be registered immediately after the associated/// connection is established and therefore use [`zbus::blocking::ConnectionBuilder::serve_at`]/// instead. However, there are situations where you'd need to register interfaces dynamically/// and that's where this method becomes useful./// If the interface already exists at this path, returns false./// [`Interface`]: trait.Interface.html/// Unregister a D-Bus [`Interface`] at a given path./// If there are no more interfaces left at that path, destroys the object as well./// Returns whether the object was destroyed./// Get the interface at the given path./// If the interface is not registered at the given path, `Error::InterfaceNotFound` error is/// The typical use of this is to emit signals outside of a dispatched handler:/// # use zbus::block_on;/// # use zbus::{/// #    SignalContext,/// #    blocking::Connection,/// #    dbus_interface,/// struct MyIface;///     #[dbus_interface(signal)]///     async fn emit_signal(ctxt: &SignalContext<'_>) -> zbus::Result<()>;/// # connection.object_server().at(path, MyIface)?;/// let iface_ref = connection///     .interface::<_, MyIface>(path)?;/// block_on(MyIface::emit_signal(iface_ref.signal_context()))?;/// Get a reference to the underlying async ObjectServer./// Get the underlying async ObjectServer, consuming `self`.MethodFlags// Wrap it in an `Option` to ensure the proxy is dropped in a `block_on` call. This is needed// context in case of tokio./// A blocking wrapper of [`crate::Proxy`]./// This API is mostly the same as [`crate::Proxy`], except that all its methods block to/// use zbus::blocking::{Connection, Proxy};///     let connection = Connection::session()?;///     let p = Proxy::new(///         &connection,///         "org.freedesktop.DBus",///         "/org/freedesktop/DBus",///     // owned return value///     let _id: String = p.call("GetId", &())?;///     // borrowed return value///     let _id: &str = p.call_method("GetId", &())?.body()?;/// It is recommended to use the [`dbus_proxy`] macro, which provides a more convenient and/// type-safe *façade* `Proxy` derived from a Rust trait./// ## Current limitations:/// At the moment, `Proxy` doesn't prevent [auto-launching][al]./// [`dbus_proxy`]: attr.dbus_proxy.html/// [al]: https://github.com/dbus2/zbus/issues/54/// Create a new `Proxy` for the given destination/path/interface./// Create a new `Proxy` for the given destination/path/interface, taking ownership of all/// passed arguments./// Get a reference to the associated connection./// Get a reference to the destination service name./// Get a reference to the object path./// Get a reference to the interface./// Introspect the associated object, and return the XML description./// See the [xml](xml/index.html) module for parsing the result./// Get the cached value of the property `property_name`./// This returns `None` if the property is not in the cache.  This could be because the cache/// was invalidated by an update, because caching was disabled for this property or proxy, or/// because the cache has not yet been populated.  Use `get_property` to fetch the value from/// the peer.cached_property_raw/// Same as `cached_property`, but gives you access to the raw value stored in the cache. This/// is useful if you want to avoid allocations and cloning./// Get the property `property_name`./// Get the property value from the cache or call the `Get` method of the/// `org.freedesktop.DBus.Properties` interface./// Set the property `property_name`./// Effectively, call the `Set` method of the `org.freedesktop.DBus.Properties` interface./// Call a method and return the reply./// Typically, you would want to use [`call`] method instead. Use this method if you need to/// deserialize the reply message manually (this way, you can avoid the memory/// allocation/copying, by deserializing the reply to an unowned type)./// [`call`]: struct.Proxy.html#method.call/// Call a method and return the reply body./// Use [`call_method`] instead if you need to deserialize the reply manually/separately./// [`call_method`]: struct.Proxy.html#method.call_methodcall_with_flags/// Call a method and return the reply body, optionally supplying a set of/// method flags to control the way the method call message is sent and handled./// Use [`call`] instead if you do not need any special handling via additional flags./// If the `NoReplyExpected` flag is passed , this will return None immediately/// after sending the message, similar to [`call_noreply`]/// [`call_noreply`]: struct.Proxy.html#method.call_noreplycall_noreply/// Call a method without expecting a reply/// This sets the `NoReplyExpected` flag on the calling message and does not wait for a reply.receive_signal/// Create a stream for signal named `signal_name`./// Apart from general I/O errors that can result from socket communications, calling this/// method will also result in an error if the destination service has not yet registered its/// well-known name with the bus (assuming you're using the well-known name as destination).receive_signal_with_args/// Same as [`Proxy::receive_signal`] but with a filter./// The D-Bus specification allows you to filter signals by their arguments, which helps avoid/// a lot of unnecessary traffic and processing since the filter is run on the server side. Use/// this method where possible. Note that this filtering is limited to arguments of string/// The arguments are passed as a tuples of argument index and expected value.receive_all_signals/// Create a stream for all signals emitted by this service.receive_property_changed/// Get an iterator to receive owner changed events./// If the proxy destination is a unique name, the stream will be notified of the peer/// disconnection from the bus (with a `None` value)./// If the proxy destination is a well-known name, the stream will be notified whenever the name/// owner is changed, either by a new peer being granted ownership (`Some` value) or when the/// name is released (with a `None` value)./// Note that zbus doesn't queue the updates. If the listener is slower than the receiver, it/// will only receive the last update.receive_owner_changedOwnerChangedIterator/// Get an iterator to receive property changed events./// Get a reference to the underlying async Proxy./// Get the underlying async Proxy, consuming `self`.SignalStream/// An [`std::iter::Iterator`] implementation that yields signal [messages](`Message`)./// Use [`Proxy::receive_signal`] to create an instance of this type./// The signal name.PropertyStream/// An [`std::iter::Iterator`] implementation that yields property change notifications./// Use [`Proxy::receive_property_changed`] to create an instance of this type.PropertyChanged/// A property changed event./// The property changed event generated by [`PropertyIterator`]./// Get the name of the property that changed.// Get the raw value of the property that changed.// If the notification signal contained the new value, it has been cached already and this call// will return that value. Otherwise (i-e invalidated property), a D-Bus call is made to fetch// and cache the new value.// split this out to avoid the trait bound on `name` method// Get the value of the property that changed.OwnerChangedStream/// An [`std::iter::Iterator`] implementation that yields owner change notifications./// Use [`Proxy::receive_owner_changed`] to create an instance of this type./// The bus name being tracked.CacheProperties/// Builder for proxies.new_bare/// Create a new [`ProxyBuilder`] for the given connection./// Set the proxy destination address./// Set the proxy path./// Set the proxy interface.cache_properties/// Set whether to cache properties.uncached_properties/// Specify a set of properties (by name) which should be excluded from caching./// Build a proxy from the builder./// Panics if the builder is lacking the necessary details to build a proxy.BroadcasterRawConnectionsocket_readerSocketReaderAuthenticatedMessageFlagsDEFAULT_MAX_QUEUEDDEFAULT_MAX_METHOD_RETURN_QUEUEDcap_unix_fdbus_connregistered_namesraw_conn// Serial number for next outgoing message// Our executorsocket_reader_task// Socket reader taskmsg_receivermethod_return_receivermsg_sendersMsgBroadcasterSubscriptionsobject_server_dispatch_task/// Inner state shared by Connection and WeakConnection/// A D-Bus connection./// A connection to a D-Bus bus, or a direct peer./// Once created, the connection is authenticated and negotiated and messages can be sent or/// received, such as [method calls] or [signals]./// For higher-level message handling (typed functions, introspection, documentation reasons etc),/// it is recommended to wrap the low-level D-Bus messages into Rust functions with the/// [`dbus_proxy`] and [`dbus_interface`] macros instead of doing it directly on a `Connection`./// Typically, a connection is made to the session bus with [`Connection::session`], or to the/// system bus with [`Connection::system`]. Then the connection is used with [`crate::Proxy`]/// instances or the on-demand [`ObjectServer`] instance that can be accessed through/// [`Connection::object_server`]./// `Connection` implements [`Clone`] and cloning it is a very cheap operation, as the underlying/// data is not cloned. This makes it very convenient to share the connection between different/// parts of your code. `Connection` also implements [`std::marker::Sync`] and [`std::marker::Send`]/// so you can send and share a connection instance across threads as well./// `Connection` keeps internal queues of incoming message. The default capacity of each of these is/// 64. The capacity of the main (unfiltered) queue is configurable through the [`set_max_queued`]/// method. When the queue is full, no more messages can be received until room is created for more./// This is why it's important to ensure that all [`crate::MessageStream`] and/// [`crate::blocking::MessageIterator`] instances are continuously polled and iterated on,/// For sending messages you can either use [`Connection::send_message`] method or make use of the/// [`Sink`] implementation. For latter, you might find [`SinkExt`] API very useful. Keep in mind/// that [`Connection`] will not manage the serial numbers (cookies) on the messages for you when/// they are sent through the [`Sink`] implementation. You can manually assign unique serial numbers/// to them using the [`Connection::assign_serial_num`] method before sending them off, if needed./// Having said that, the [`Sink`] is mainly useful for sending out signals, as they do not expect/// a reply, and serial numbers are not very useful for signals either for the same reason./// Since you do not need exclusive access to a `zbus::Connection` to send messages on the bus,/// [`Sink`] is also implemented on `&Connection`./// At the moment, a simultaneous [flush request] from multiple tasks/threads could/// potentially create a busy loop, thus wasting CPU time. This limitation may be removed in the/// [flush request]: https://docs.rs/futures/0.3.15/futures/sink/trait.SinkExt.html#method.flush/// [method calls]: struct.Connection.html#method.call_method/// [signals]: struct.Connection.html#method.emit_signal/// [`dbus_interface`]: attr.dbus_interface.html/// [`set_max_queued`]: struct.Connection.html#method.set_max_queued/// #### Get the session bus ID/// # zbus::block_on(async {/// use zbus::Connection;/// let connection = Connection::session().await?;/// let reply = connection///     .call_method(///         Some("org.freedesktop.DBus"),///         "GetId",///         &(),/// let id: &str = reply.body()?;/// println!("Unique ID of the bus: {}", id);/// # Ok::<(), zbus::Error>(())/// # }).unwrap();/// #### Monitoring all messages/// Let's eavesdrop on the session bus 😈 using the [Monitor] interface:/// use futures_util::stream::TryStreamExt;/// use zbus::{Connection, MessageStream};///         Some("org.freedesktop.DBus.Monitoring"),///         "BecomeMonitor",///         &(&[] as &[&str], 0u32),/// let mut stream = MessageStream::from(connection);/// while let Some(msg) = stream.try_next().await? {///     println!("Got message: {}", msg);/// This should print something like:/// Got message: Signal NameAcquired from org.freedesktop.DBus/// Got message: Signal NameLost from org.freedesktop.DBus/// Got message: Method call GetConnectionUnixProcessID from :1.1324/// Got message: Error org.freedesktop.DBus.Error.NameHasNoOwner:///              Could not get PID of name ':1.1332': no such name from org.freedesktop.DBus/// Got message: Method call AddMatch from :1.918/// Got message: Method return from org.freedesktop.DBus/// [Monitor]: https://dbus.freedesktop.org/doc/dbus-specification.html#bus-messages-become-monitorPendingMethodCall/// A method call whose completion can be awaited or joined with other streams./// This is useful for cache population method calls, where joining the [`JoinableStream`] with/// an update signal stream can be used to ensure that cache updates are not overwritten by a cache/// population whose task is scheduled later.MessageSequence/// Unlike our [`Sink`] implementation, this method sets a unique (to this connection) serial/// number on the message before sending it off, for you./// Create a method-call message, send it over the connection, then wait for the reply./// error replies are returned as [`Error::MethodError`].call_method_raw/// Send the given message, which must be a method call, over the connection and return an/// object that allows the reply to be retrieved.  Typically you'd want to use/// [`Connection::call_method`] instead./// If the `flags` do not contain `MethodFlags::NoReplyExpected`, the return value is/// guaranteed to be `Ok(Some(_))`, if there was no error encountered./// INTERNAL NOTE: If this method is ever made pub, flags should become `BitFlags<MethodFlags>`./// Register a well-known name for this connection./// When connecting to a bus, the name is requested from the bus. In case of p2p connection, the/// name (if requested) is used of self-identification./// You can request multiple names for the same connection. Use [`Connection::release_name`] for/// deregistering names registered through this method./// Note that exclusive ownership without queueing is requested (using/// [`RequestNameFlags::ReplaceExisting`] and [`RequestNameFlags::DoNotQueue`] flags) since that/// is the most typical case. If that is not what you want, you should use/// [`Connection::request_name_with_flags`] instead (but make sure then that name is requested/// **after** you've setup your service implementation with the `ObjectServer`)./// The associated `ObjectServer` will only handle method calls destined for the unique name of/// this connection or any of the registered well-known names. If no well-known name is/// registered, the method calls destined to all well-known names will be handled./// Since names registered through any other means than `Connection` or [`ConnectionBuilder`]/// API are not known to the connection, method calls destined to those names will only be/// handled by the associated `ObjectServer` if none of the names are registered through/// `Connection*` API. Simply put, either register all the names through `Connection*` API or/// none of them./// Fails with `zbus::Error::NameTaken` if the name is already owned by another peer./// This is the same as [`Connection::request_name`] but allows to specify the flags to use when/// requesting the name./// If the [`RequestNameFlags::DoNotQueue`] flag is not specified and request ends up in the/// queue, you can use [`fdo::NameAcquiredStream`] to be notified when the name is acquired. A/// queued name request can be cancelled using [`Connection::release_name`]./// If the [`RequestNameFlags::AllowReplacement`] flag is specified, the requested name can be/// lost if another peer requests the same name. You can use [`fdo::NameLostStream`] to be/// notified when the name is lost/// use zbus::{Connection, fdo::{DBusProxy, RequestNameFlags, RequestNameReply}};/// use enumflags2::BitFlags;/// let name = "org.freedesktop.zbus.QueuedNameTest";/// let conn1 = Connection::session().await?;/// // This should just work right away./// conn1.request_name(name).await?;/// let conn2 = Connection::session().await?;/// // A second request from the another connection will fail with `DoNotQueue` flag, which is/// // implicit with `request_name` method./// assert!(conn2.request_name(name).await.is_err());/// // Now let's try w/o `DoNotQueue` and we should be queued./// let reply = conn2///     .request_name_with_flags(name, RequestNameFlags::AllowReplacement.into())/// assert_eq!(reply, RequestNameReply::InQueue);/// // Another request should just give us the same response.///     // The flags on subsequent requests will however be ignored.///     .request_name_with_flags(name, BitFlags::empty())/// let mut acquired_stream = DBusProxy::new(&conn2)///     .receive_name_acquired()/// assert!(conn1.release_name(name).await?);/// // This would have waited forever if `conn1` hadn't just release the name./// let acquired = acquired_stream.next().await.unwrap();/// assert_eq!(acquired.args().unwrap().name, name);/// // conn2 made the mistake of being too nice and allowed name replacemnt, so conn1 should be/// // able to take it back./// let mut lost_stream = DBusProxy::new(&conn2)///     .receive_name_lost()/// let lost = lost_stream.next().await.unwrap();/// assert_eq!(lost.args().unwrap().name, name);/// * Same as that of [`Connection::request_name`]./// * If you wish to track changes to name ownership after this call, make sure that the/// [`fdo::NameAcquired`] and/or [`fdo::NameLostStream`] instance(s) are created **before**/// calling this method. Otherwise, you may loose the signal if it's emitted after this call but/// just before the stream instance get created.assign_serial_num/// Assigns a serial number to `msg` that is unique to this connection./// This method can fail if `msg` is corrupted./// The unique name of the connection, if set/applicable./// The unique name is assigned by the message bus or set manually using/// [`Connection::set_unique_name`].set_unique_name/// Sets the unique name of the connection (if not already set)./// This method panics if the unique name is already set. It will always panic if the connection/// is to a message bus as it's the bus that assigns peers their unique names. This is mainly/// provided for bus implementations. All other users should not need to use this method./// The underlying executor./// When a connection is built with internal_executor set to false, zbus will not spawn a/// thread to run the executor. You're responsible to continuously [tick the executor][tte]./// Failure to do so will result in hangs./// Here is how one would typically run the zbus executor through async-std's single-threaded/// scheduler:/// # // Disable on windows because somehow it triggers a stack overflow there:/// # // https://gitlab.freedesktop.org/zeenix/zbus/-/jobs/34023494/// # #[cfg(all(not(feature = "tokio"), not(target_os = "windows")))]/// use zbus::ConnectionBuilder;/// use async_std::task::{block_on, spawn};/// # struct SomeIface;/// # #[zbus::dbus_interface]/// # impl SomeIface {/// block_on(async {///     let conn = ConnectionBuilder::session()///         .internal_executor(false)/// #         // This is only for testing a deadlock that used to happen with this combo./// #         .serve_at("/some/iface", SomeIface)/// #         .unwrap()///        let conn = conn.clone();///        spawn(async move {///            loop {///                conn.executor().tick().await;///     // All your other async code goes here./// **Note**: zbus 2.1 added support for tight integration with tokio. This means, if you use/// zbus with tokio, you do not need to worry about this at all. All you need to do is enable/// `tokio` feature. You should also disable the (default) `async-io` feature in your/// `Cargo.toml` to avoid unused dependencies. Also note that **prior** to zbus 3.0, disabling/// `async-io` was required to enable tight `tokio` integration./// [tte]: https://docs.rs/async-executor/1.4.1/async_executor/struct.Executor.html#method.tick/// **Note**: Once the `ObjectServer` is created, it will be replying to all method calls/// received on `self`. If you want to manually reply to method calls, do not use this/// method (or any of the `ObjectServer` related API).sync_object_serversetup_object_serverstart_object_serverqueue_remove_matchhello_buspeer_pid/// Returns the peer process ID, or Ok(None) if it cannot be returned for the associated socket.init_socket_readerWeakConnection// Internal API that allows keeping a weak connection ref around./// Upgrade to a Connection.// The task waits for name lost signal if owner allows replacement.// The task waits for name acquisition signal.test_p2p// Same numbered client and server are already paired up. We make use of the// `futures_util::stream::Forward` to connect the two pipes and hence test one of the benefits// of our Stream and Sink impls.tcp_p2ptest_tcp_p2ptcp_p2p_pipetest_unix_p2punix_p2p_pipeserial_monotonically_increasestest_serial_monotonically_increasesdisconnect_on_droptest_disconnect_on_dropunix_p2p_cookie_authtest_unix_p2p_cookie_authinternal_executorCookieContext/// A builder for [`zbus::Connection`]./// Here is an example of connecting to an IBus service:/// # use zbus::ConnectionBuilder;/// # block_on(async {/// let addr = "unix:\///     path=/home/zeenix/.cache/ibus/dbus-ET0Xzrk9,\///     guid=fdd08e811a6c7ebe1fef0d9e647230da";/// let conn = ConnectionBuilder::address(addr)?/// #     drop(conn);/// #     Ok::<(), zbus::Error>(())/// **Note:** The IBus address is different for each session. You can find the address for your/// current session using `ibus address` command./// Create a builder for connection that will use the given socket./// Enable or disable the internal executor thread./// The thread is enabled by default./// See [Connection::executor] for more details./// This is similar to [`zbus::ObjectServer::at`], except that it allows you to have your/// interfaces available immediately after the connection is established. Typically, this is/// exactly what you'd want. Also in contrast to [`zbus::ObjectServer::at`], this method will/// replace any previously added interface with the same name at the same path./// This is similar to [`zbus::Connection::request_name`], except the name is requested as part/// of the connection setup ([`ConnectionBuilder::build`]), immediately after interfaces/// registered (through [`ConnectionBuilder::serve_at`]) are advertised. Typically this is/// exactly what you want.build_start_internal_executor/// Start the internal executor thread./// Returns a dummy task that keep the executor ticking thread from exiting due to absence of any/// tasks until socket reader task kicks in.create_reply/// Generate an error reply message for the given method call.// The name of the error.// Every D-Bus error must have a name. See [`ErrorName`] for more information.// The optional description for the error./// A trait that needs to be implemented by error types to be returned from D-Bus methods./// Typically, you'd use the [`crate::fdo::Error`] since that covers quite a lot of failures but/// occasionally you might find yourself needing to use a custom error type. You'll need to/// implement this trait for your error type. The easiest way to achieve that is to make use of the/// [`DBusError` macro][dm]./// [dm]: derive.DBusError.htmlNamesErrorOwnedErrorNameVariantErrorInterfaceNotFound/// Interface not found/// Invalid D-Bus address./// An I/O error.InvalidField/// Invalid message field.ExcessData/// A [zvariant](../zvariant/index.html) error./// A [zbus_names](../zbus_names/index.html) error.IncorrectEndian/// Endian signature invalid or doesn't match expectation./// Initial handshake error.InvalidReply/// Unexpected or incorrect reply.MethodError/// A D-Bus method error reply.// According to the spec, there can be all kinds of details in D-Bus errors but nobody adds// anything more than a string description.MissingField/// A required field is missing in the message headers.InvalidGUID/// Invalid D-Bus GUID./// Unsupported function, or support currently lacking.FDO/// A [`fdo::Error`] transformed into [`Error`].NoBodySignatureNameTaken/// The requested name was already claimed by another peer.InvalidMatchRule/// Invalid [match rule][MR] string./// [MR]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-routing-match-rules/// Generic error.MissingParameter/// A required parameter was missing./// The error type for `zbus`./// The various errors that can be reported by this crate.// For messages that are D-Bus error returns/// Alias for a `Result` with the error type `zbus::Error`.Deserialize_reprSerialize_reprOwnedObjectPath/// Server-side implementation for the `org.freedesktop.DBus.Introspectable` interface./// This interface is implemented automatically for any object registered to the/// [ObjectServer](crate::ObjectServer).'callDispatchResult'life5set_mutintrospect_to_writer"Create a stream that receives `PropertiesChanged` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal)."PropertiesChangedStream"Create a stream that receives `PropertiesChanged` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal_with_args).""A [`Stream`] implementation that yields [`PropertiesChanged`] signals.\n\nUse [`PropertiesProxy::receive_properties_changed`] to create an instance of this type.\n\n[`Stream`]: https://docs.rs/futures/0.3.15/futures/stream/trait.Stream.html"/// Server-side implementation for the `org.freedesktop.DBus.Properties` interface." Emits the `org.freedesktop.DBus.Properties.PropertiesChanged` signal."properties_changed/// The type returned by the [`ObjectManagerProxy::get_managed_objects`] method."Create a stream that receives `InterfacesAdded` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal)."InterfacesAddedStream"Create a stream that receives `InterfacesAdded` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal_with_args).""Create a stream that receives `InterfacesRemoved` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal)."InterfacesRemovedStream"Create a stream that receives `InterfacesRemoved` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal_with_args).""A [`Stream`] implementation that yields [`InterfacesAdded`] signals.\n\nUse [`ObjectManagerProxy::receive_interfaces_added`] to create an instance of this type.\n\n[`Stream`]: https://docs.rs/futures/0.3.15/futures/stream/trait.Stream.html""A [`Stream`] implementation that yields [`InterfacesRemoved`] signals.\n\nUse [`ObjectManagerProxy::receive_interfaces_removed`] to create an instance of this type.\n\n[`Stream`]: https://docs.rs/futures/0.3.15/futures/stream/trait.Stream.html"/// Service-side [Object Manager][om] interface implementation./// The recommended path to add this interface at is the path form of the well-known name of a D-Bus/// service, or below. For example, if a D-Bus service is available at the well-known name/// `net.example.ExampleService1`, this interface should typically be registered at/// `/net/example/ExampleService1`, or below (to allow for multiple object managers in a service)./// It is supported, but not recommended, to add this interface at the root path, `/`./// When added to an `ObjectServer`, `InterfacesAdded` signal is emitted for all the objects under/// the `path` its added at. You can use this fact to minimize the signal emissions by populating/// the entire (sub)tree under `path` before registering an object manager./// [om]: https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager" This signal is emitted when either a new object is added or when an existing object gains"" one or more interfaces. The `interfaces_and_properties` argument contains a map with the"" interfaces and properties (if any) that have been added to the given object path."" This signal is emitted whenever an object is removed or it loses one or more interfaces."" The `interfaces` parameters contains a list of the interfaces that were removed."" Server-side implementation for the `org.freedesktop.DBus.Peer` interface."" This interface is implemented automatically for any object registered to the"" [ObjectServer](crate::ObjectServer)."" The flags used by the bus [`request_name`] method."" [`request_name`]: struct.DBusProxy.html#method.request_name"" If an application A specifies this flag and succeeds in becoming the owner of the name, and"" another application B later calls [`request_name`] with the [`ReplaceExisting`] flag, then"" application A will lose ownership and receive a `org.freedesktop.DBus.NameLost` signal, and"" application B will become the new owner. If [`AllowReplacement`] is not specified by"" application A, or [`ReplaceExisting`] is not specified by application B, then application B"" will not replace application A as the owner."" [`ReplaceExisting`]: enum.RequestNameFlags.html#variant.ReplaceExisting"" [`AllowReplacement`]: enum.RequestNameFlags.html#variant.AllowReplacement"" Try to replace the current owner if there is one. If this flag is not set the application"" will only become the owner of the name if there is no current owner. If this flag is set,"" the application will replace the current owner if the current owner specified"" [`AllowReplacement`].""  Without this flag, if an application requests a name that is already owned, the"" application  will be placed in a queue to own the name when the current owner gives it"" up. If this flag  is given, the application will not be placed in the queue, the"" request for the name will  simply fail. This flag also affects behavior when an"" application is replaced as name owner;  by default the application moves back into the"" waiting queue, unless this flag was provided  when the application became the name"" owner."/// The caller is now the primary owner of the name, replacing any previous owner. Either the/// name had no owner before, or the caller specified [`ReplaceExisting`] and the current owner/// specified [`AllowReplacement`]./// [`ReplaceExisting`]: enum.RequestNameFlags.html#variant.ReplaceExisting/// [`AllowReplacement`]: enum.RequestNameFlags.html#variant.AllowReplacement/// The name already had an owner, [`DoNotQueue`] was not specified, and either the current/// owner did not specify [`AllowReplacement`] or the requesting application did not specify/// [`ReplaceExisting`]./// [`DoNotQueue`]: enum.RequestNameFlags.html#variant.DoNotQueue/// The name already has an owner, [`DoNotQueue`] was specified, and either/// [`AllowReplacement`] was not specified by the current owner, or [`ReplaceExisting`] was/// not specified by the requesting application./// The application trying to request ownership of a name is already the owner of it./// The return code of the [`request_name`] method./// [`request_name`]: struct.DBusProxy.html#method.request_name/// The caller has released their claim on the given name. Either the caller was the primary/// owner of the name, and the name is now unused or taken by somebody waiting in the queue for/// the name, or the caller was waiting in the queue for the name and has now been removed from/// The given name does not exist on this bus./// The caller was not the primary owner of this name, and was also not waiting in the queue to/// own this name./// The return code of the [`release_name`] method./// [`release_name`]: struct.DBusProxy.html#method.release_nameunix_user_idunix_group_idswindows_sidlinux_security_label/// Credentials of a process connected to a bus server./// If unable to determine certain credentials (for instance, because the process is not on the same/// machine as the bus daemon, or because this version of the bus daemon does not support a/// particular security framework), or if the values of those credentials cannot be represented as/// documented here, then those credentials are omitted./// **Note**: unknown keys, in particular those with "." that are not from the specification, will/// be ignored. Use your own implementation or contribute your keys here, or in the specification./// The numeric Unix user ID, as defined by POSIX./// The numeric Unix group IDs (including both the primary group and the supplementary groups),/// as defined by POSIX, in numerically sorted order. This array is either complete or absent:/// if the message bus is able to determine some but not all of the caller's groups, or if one/// of the groups is not representable in a UINT32, it must not add this credential to theinto_unix_group_ids/// Same as [`ConnectionCredentials::unix_group_ids`], but consumes `self` and returns the group/// IDs Vec./// The numeric process ID, on platforms that have this concept. On Unix, this is the process ID/// defined by POSIX./// The Windows security identifier in its string form, e.g./// `S-1-5-21-3623811015-3361044348-30300820-1013` for a domain or local computer user or/// "S-1-5-18` for the LOCAL_SYSTEM user.into_windows_sid/// Same as [`ConnectionCredentials::windows_sid`], but consumes `self` and returns the SID/// On Linux systems, the security label that would result from the SO_PEERSEC getsockopt call./// The array contains the non-zero bytes of the security label in an unspecified/// ASCII-compatible encoding, followed by a single zero byte./// For example, the SELinux context `system_u:system_r:init_t:s0` (a string of length 27) would/// be encoded as 28 bytes ending with `':', 's', '0', '\x00'`/// On SELinux systems this is the SELinux context, as output by `ps -Z` or `ls -Z`. Typical/// values might include `system_u:system_r:init_t:s0`,/// `unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023`, or/// `unconfined_u:unconfined_r:chrome_sandbox_t:s0-s0:c0.c1023`./// On Smack systems, this is the Smack label. Typical values might include `_`, `*`, `User`,/// `System` or `System::Shared`./// On AppArmor systems, this is the AppArmor context, a composite string encoding the AppArmor/// label (one or more profiles) and the enforcement mode. Typical values might include/// `unconfined`, `/usr/bin/firefox (enforce)` or `user1 (complain)`.into_linux_security_label/// Same as [`ConnectionCredentials::linux_security_label`], but consumes `self` and returns/// the security label bytes.set_unix_user_id/// Set the numeric Unix user ID, as defined by POSIX.add_unix_group_id/// Add a numeric Unix group ID./// See [`ConnectionCredentials::unix_group_ids`] for more information.set_process_id/// Set the numeric process ID, on platforms that have this concept./// See [`ConnectionCredentials::process_id`] for more information.set_windows_sid/// Set the Windows security identifier in its string form.set_linux_security_label/// Set the Linux security label./// See [`ConnectionCredentials::linux_security_label`] for more information."Create a stream that receives `NameOwnerChanged` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal)."NameOwnerChangedStream"Create a stream that receives `NameOwnerChanged` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal_with_args).""Create a stream that receives `NameLost` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal)."NameLostStream"Create a stream that receives `NameLost` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal_with_args).""Create a stream that receives `NameAcquired` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal)."NameAcquiredStream"Create a stream that receives `NameAcquired` signals.\n\nThis a convenient wrapper around [`zbus::Proxy::receive_signal_with_args`](https://docs.rs/zbus/latest/zbus/struct.Proxy.html#method.receive_signal_with_args).""Create a stream for the `Features` property changes. This is a convenient wrapper around [`zbus::Proxy::receive_property_changed`].""Create a stream for the `Interfaces` property changes. This is a convenient wrapper around [`zbus::Proxy::receive_property_changed`].""A [`Stream`] implementation that yields [`NameOwnerChanged`] signals.\n\nUse [`DBusProxy::receive_name_owner_changed`] to create an instance of this type.\n\n[`Stream`]: https://docs.rs/futures/0.3.15/futures/stream/trait.Stream.html""A [`Stream`] implementation that yields [`NameLost`] signals.\n\nUse [`DBusProxy::receive_name_lost`] to create an instance of this type.\n\n[`Stream`]: https://docs.rs/futures/0.3.15/futures/stream/trait.Stream.html""A [`Stream`] implementation that yields [`NameAcquired`] signals.\n\nUse [`DBusProxy::receive_name_acquired`] to create an instance of this type.\n\n[`Stream`]: https://docs.rs/futures/0.3.15/futures/stream/trait.Stream.html"dbus_errorZBus/// Unknown or fall-through ZBus error./// A generic error; "something went wrong" - see the error message for more./// There was not enough memory to complete an operation.ServiceUnknown/// The bus doesn't know how to launch a service to supply the bus name you wanted.NameHasNoOwner/// The bus name you referenced doesn't exist (i.e. no application owns it)./// No reply to a message expecting one, usually means a timeout occurred./// Something went wrong reading or writing to a socket, for example.BadAddress/// A D-Bus bus address was malformed./// Requested operation isn't supported (like ENOSYS on UNIX)./// Some limited resource is exhausted./// Security restrictions don't allow doing what you're trying to do.AuthFailed/// Authentication didn't work.NoServer/// Unable to connect to server (probably caused by ECONNREFUSED on a socket)./// Certain timeout errors, possibly ETIMEDOUT on a socket./// Note that `TimedOut` is used for message reply timeouts.NoNetwork/// No network access (probably ENETUNREACH on a socket)./// Can't bind a socket since its address is in use (i.e. EADDRINUSE)./// The connection is disconnected and you're trying to use it.InvalidArgs/// Invalid arguments passed to a method call./// Missing file.FileExists/// Existing file and the operation you're using does not silently overwrite.UnknownMethod/// Method name you invoked isn't known by the object you invoked it on.UnknownObject/// Object you invoked a method on isn't known.UnknownInterface/// Interface you invoked a method on isn't known by the object.UnknownProperty/// Property you tried to access isn't known by the object.PropertyReadOnly/// Property you tried to set is read-only./// Certain timeout errors, e.g. while starting a service.MatchRuleNotFound/// Tried to remove or modify a match rule that didn't exist.MatchRuleInvalid/// The match rule isn't syntactically valid.SpawnExecFailed/// While starting a new process, the exec() call failed.SpawnForkFailed/// While starting a new process, the fork() call failed.SpawnChildExited/// While starting a new process, the child exited with a status code.SpawnChildSignaled/// While starting a new process, the child exited on a signal.SpawnFailed/// While starting a new process, something went wrong.SpawnFailedToSetup/// We failed to setup the environment correctly.SpawnConfigInvalid/// We failed to setup the config parser correctly.SpawnServiceNotValid/// Bus name was not valid.SpawnServiceNotFound/// Service file not found in system-services directory.SpawnPermissionsInvalid/// Permissions are incorrect on the setuid helper.SpawnFileInvalid/// Service file invalid (Name, User or Exec missing).SpawnNoMemory/// There was not enough memory to complete the operation.UnixProcessIdUnknown/// Tried to get a UNIX process ID and it wasn't available./// A type signature is not valid.InvalidFileContent/// A file contains invalid syntax or is otherwise broken.SELinuxSecurityContextUnknown/// Asked for SELinux security context and it wasn't available.AdtAuditDataUnknown/// Asked for ADT audit data and it wasn't available.ObjectPathInUse/// There's already an object with the requested object path.InconsistentMessage/// The message meta data does not match the payload. e.g. expected number of file descriptors/// were not sent over the socket this message was received on.InteractiveAuthorizationRequired/// The message is not allowed without performing interactive authorization, but could have/// succeeded if an interactive authorization step was allowed.NotContainer/// The connection is not from a container, or the specified container instance does not exist./// Errors from <https://gitlab.freedesktop.org/dbus/dbus/-/blob/master/dbus/dbus-protocol.h>/// Alias for a `Result` with the error type [`zbus::fdo::Error`]./// [`zbus::fdo::Error`]: enum.Error.htmlerror_from_zerror//! The D-Bus specification defines the message bus messages and some standard interfaces that may//! be useful across various D-Bus applications. This module provides their proxy./// A D-Bus server GUID./// See the D-Bus specification [UUIDs chapter] for details./// You can create a `Guid` from an existing string with [`Guid::try_from::<&str>`][TryFrom]./// [UUIDs chapter]: https://dbus.freedesktop.org/doc/dbus-specification.html#uuids/// [TryFrom]: #impl-TryFrom%3C%26%27_%20str%3E/// Generate a D-Bus GUID that can be used with e.g. [`Connection::new_unix_server`]./// [`Connection::new_unix_server`]: struct.Connection.html#method.new_unix_server/// Returns a string slice for the GUID./// Creates a GUID from a string with 32 hex digits./// Returns `Err(`[`Error::InvalidGUID`]`)` if the provided string is not a well-formed GUID./// [`Error::InvalidGUID`]: enum.Error.html#variant.InvalidGUIDvalid_guid/// This is the recommended authentication mechanism on platforms where credentials can be/// transferred out-of-band, in particular Unix platforms that can perform credentials-passing/// over the `unix:` transport./// This mechanism is designed to establish that a client has the ability to read a private/// file owned by the user being authenticated./// Does not perform any authentication at all, and should not be accepted by message buses./// However, it might sometimes be useful for non-message-bus uses of D-Bus./// Authentication mechanisms/// See <https://dbus.freedesktop.org/doc/dbus-specification.html#auth-mechanisms>/// The server Guid/// Whether file descriptor passing has been accepted by both sides/// The result of a finalized handshake/// The result of a finalized [`ClientHandshake`] or [`ServerHandshake`]. It can be passed to/// [`Connection::new_authenticated`] to initialize a connection./// [`ClientHandshake`]: struct.ClientHandshake.html/// [`ServerHandshake`]: struct.ServerHandshake.html/// [`Connection::new_authenticated`]: ../struct.Connection.html#method.new_authenticated/// Create a client-side `Authenticated` for the given `socket`./// Create a server-side `Authenticated` for the given `socket`./// The function takes `client_uid` on Unix only. On Windows, it takes `client_sid` instead.ClientHandshakeStepMechanismInitWaitingForDataWaitingForOKWaitingForAgreeUnixFDNegotiateUnixFDAgreeUnixFD// The plain-text SASL profile authentication protocol described here:// <https://dbus.freedesktop.org/doc/dbus-specification.html#auth-protocol>// These are all the known commands, which can be parsed from or serialized to text.HandshakeCommon/// A representation of an in-progress handshake, client-side/// This struct is an async-compatible representation of the initial handshake that must be/// performed before a D-Bus connection can be used. To use it, you should call the/// [`advance_handshake`] method whenever the underlying socket becomes ready (tracking the/// readiness itself is not managed by this abstraction) until it returns `Ok(())`, at which point/// you can invoke the [`try_finish`] method to get an [`Authenticated`], which can be given to/// [`Connection::new_authenticated`]./// [`advance_handshake`]: struct.ClientHandshake.html#method.advance_handshake/// [`try_finish`]: struct.ClientHandshake.html#method.try_finish/// [`Authenticated`]: struct.AUthenticated.html" Perform the handshake."" On a successful handshake, you get an `Authenticated`. If you need to send a Bus Hello,"" this remains to be done."/// Start a handshake on this client socketmechanism_initmechanism_datarandom_asciisasl_auth_idkeyring_pathread_keyringServerHandshakeStepWaitingForNullWaitingForAuthWaitingForBeginclient_uid/// A representation of an in-progress handshake, server-side/// This would typically be used to implement a D-Bus broker, or in the context of a P2P connection./// [`advance_handshake`]: struct.ServerHandshake.html#method.advance_handshake/// [`try_finish`]: struct.ServerHandshake.html#method.try_finish/// [`Authenticated`]: struct.Authenticated.htmlauth_okcheck_external_authcheck_cookie_authunsupported_command_errorrejected_errorrecv_buffermechanisms// the current AUTH mechanism is front, ordered by priority// Common code for the client and server side of the handshake.read_commandmechanismcreate_async_socket_pairpipelined_handshakeseparate_external_datamissing_external_dataanonymous_handshakeseparate_anonymous_data/*
 * Client-side handshake logic
 *//*
 * Server-side handshake logic
 *//// This interface does not support the given methodRequiresMut/// Retry with [Interface::call_mut]./// This is equivalent to NotFound if returned by call_mut./// The method was found and will be completed by running this Future/// A helper type returned by [`Interface`] callbacks./// Helper for creating the Async variant" Return the name of the interface. Ex: \"org.foo.MyInterface\""" Get a property value. Returns `None` if the property doesn\'t exist."" Return all the properties."" Set a property value."" Return [`DispatchResult::NotFound`] if the property doesn\'t exist, or"" [`DispatchResult::RequiresMut`] if `set_mut` should be used instead.  The default"" implementation just returns `RequiresMut`."" Returns `None` if the property doesn\'t exist."" This will only be invoked if `set` returned `RequiresMut`."" Call a method."" Return [`DispatchResult::NotFound`] if the method doesn\'t exist, or"" [`DispatchResult::RequiresMut`] if `call_mut` should be used instead."" It is valid, though inefficient, for this to always return `RequiresMut`."" Call a `&mut self` method."" This will only be invoked if `call` returned `RequiresMut`."" Write introspection XML to the writer, with the given indentation level."" The trait used to dispatch messages to an interface instance."" Note: It is not recommended to manually implement this trait. The [`dbus_interface`] macro"" implements it for you."" [`dbus_interface`]: attr.dbus_interface.html"/// Return Any of self// Note: while it is possible to implement this without `unsafe`, it currently requires a helper// trait with a blanket impl that creates `dyn Any` refs.  It's simpler (and more performant) to// just check the type ID and do the downcast ourself.// See https://github.com/rust-lang/rust/issues/65991 for a rustc feature that will make it// possible to get a `dyn Any` ref directly from a `dyn Interface` ref; once that is stable, we can// remove this unsafe code.message_buildermessage_headermessage_streamabstractionsmatch_rule_builder// Required for the macros to function within this crate.// Macro support module, not part of the public API.is_gdbus_testbasic_connectionbasic_connection_asynctest_basic_connectionfdpass_systemdfreedesktop_apifreedesktop_api_asynctest_freedesktop_apiissue_68issue104issue_121// This one we just want to see if it builds, no need to run it. For details see:// https://github.com/dbus2/zbus/issues/121issue_122issue_81issue173uncached_propertytest_uncached_propertyissue_260issue_260_serviceissue_260_clientMatchRuleBuilderpath_specMatchRulePathSpecarg_pathsarg0namespacearg0ns/// A bus match rule for subscribing to specific messages./// This is mainly used by peer to subscribe to specific signals as by default the bus will not/// send out most broadcasted signals. This API is intended to make it easy to create and parse/// match rules. See the [match rules section of the D-Bus specification][mrs] for a description of/// each possible element of a match rule./// # use zbus::MatchRule;/// // Let's take the most typical example of match rule to subscribe to properties' changes:///     .interface("org.freedesktop.DBus.Properties")?///     .member("PropertiesChanged")?///     .add_arg("org.zbus")?///     // Sometimes it's useful to match empty strings (null check).///     .add_arg("")?/// let rule_str = rule.to_string();///     rule_str,///     "type='signal',\///      sender='org.freedesktop.DBus',\///      interface='org.freedesktop.DBus.Properties',\///      member='PropertiesChanged',\///      arg0='org.zbus',\///      arg1=''",/// // Let's parse it back./// let parsed_rule = MatchRule::try_from(rule_str.as_str())?;/// assert_eq!(rule, parsed_rule);/// // Now for `ObjectManager::InterfacesAdded` signal.///     .sender("org.zbus")?///     .interface("org.freedesktop.DBus.ObjectManager")?///     .member("InterfacesAdded")?///     .arg_path(0, "/org/zbus/NewPath")?///      sender='org.zbus',\///      interface='org.freedesktop.DBus.ObjectManager',\///      member='InterfacesAdded',\///      arg0path='/org/zbus/NewPath'",/// The `PartialEq` implementation assumes arguments in both rules are in the same order./// [mrs]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-routing-match-rules/// Create a builder for `MatchRuleBuilder`./// The sender, if set./// The message type, if set./// The interfac, if set./// The member name if set./// The path or path namespace, if set./// The destination, if set./// The arguments./// The argument paths."use arg0ns instead"/// Match messages whose first argument is within the specified namespace./// This function is deprecated because the choice of `InterfaceName` was too restrictive./// Creates an owned clone of `self`./// Match the given message against this rule./// Since this method doesn't have any knowledge of names on the bus (or even connection to a/// bus) matching always succeeds for:/// * `sender` in the rule (if set) that is a well-known name. The `sender` on a message is///   always a unique name./// * `destination` in the rule when `destination` on the `msg` is a well-known name. The///   `destination` on match rule is always a unique name.write_match_rule_string_componentwrite_commaPathNamespace/// The path or path namespace./// Owned sibling of [`MatchRule`]./// Convert to the inner `MatchRule`, consuming `self`./// Get a reference to the inner `MatchRule`.'owned'unownedMAX_ARGS/// Builder for [`MatchRule`]./// This is created by [`MatchRule::builder`]./// Build the `MatchRule`./// Set the sender./// Set the message type./// Set the interface./// Set the member./// Set the path./// Note: Since both a path and a path namespace are not allowed to appear in a match rule at/// the same time, this overrides any path namespace previously set.path_namespace/// Set the path namespace./// the same time, this overrides any path previously set./// Set the destination./// Append an arguments./// Use this in instead of [`MatchRuleBuilder::arg`] if you want to sequentially add args./// [`Error::InvalidMatchRule`] on attempt to add the 65th argument./// Add an argument of a specified index./// [`Error::InvalidMatchRule`] if `idx` is greater than 64.add_arg_path/// Append a path argument./// Use this in instead of [`MatchRuleBuilder::arg_path`] if you want to sequentially add args./// [`Error::InvalidMatchRule`] on attempt to add the 65th path argument.arg_path/// Add a path argument of a specified index./// Set 0th argument's namespace./// The namespace be a valid bus name or a valid element of a bus name. For more information,/// see [the spec](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus)./// // Valid namespaces/// MatchRule::builder().arg0ns("org.mpris.MediaPlayer2").unwrap();/// MatchRule::builder().arg0ns("org").unwrap();/// MatchRule::builder().arg0ns(":org").unwrap();/// MatchRule::builder().arg0ns(":1org").unwrap();/// // Invalid namespaces/// MatchRule::builder().arg0ns("org.").unwrap_err();/// MatchRule::builder().arg0ns(".org").unwrap_err();/// MatchRule::builder().arg0ns("1org").unwrap_err();/// MatchRule::builder().arg0ns(".").unwrap_err();/// MatchRule::builder().arg0ns("org..freedesktop").unwrap_err();padding_for_8_bytesEncodingContextEndianSigMessageFieldCodeMessageFieldsMessagePrimaryHeaderQuickMessageFieldsMIN_MESSAGE_SIZENATIVE_ENDIAN_SIGLOCK_PANIC_MSGdbus_contextrecv_seq/// A position in the stream of [`Message`] objects received by a single [`zbus::Connection`]./// Note: the relative ordering of values obtained from distinct [`zbus::Connection`] objects is/// not specified; only sequence numbers originating from the same connection should be compared./// A sequence number that is higher than any other; used by errors that terminate a stream.primary_headerquick_fieldsbody_offset/// A D-Bus Message./// The content of the message are stored in serialized format. To deserialize the body of the/// message, use the [`body`] method. You may also access the header and other details with the/// various other getters./// Also provided are constructors for messages of different types. These will mainly be useful for/// very advanced use cases as typically you will want to create a message for immediate dispatch/// and hence use the API provided by [`Connection`], even when using the low-level API./// **Note**: The message owns the received FDs and will close them when dropped. You can call/// [`take_fds`] after deserializing to `RawFD` using [`body`] if you want to take the ownership./// [`body`]: #method.body/// [`take_fds`]: #method.take_fds/// [`Connection`]: struct.Connection#method.call_method/// Create a message of type [`MessageType::MethodCall`]./// [`MessageType::MethodCall`]: enum.MessageType.html#variant.MethodCall/// Create a message of type [`MessageType::Signal`]./// [`MessageType::Signal`]: enum.MessageType.html#variant.Signalmethod_reply/// Create a message of type [`MessageType::MethodReturn`]./// [`MessageType::MethodReturn`]: enum.MessageType.html#variant.MethodReturnmethod_error/// Create a message of type [`MessageType::MethodError`]./// [`MessageType::MethodError`]: enum.MessageType.html#variant.MethodError/// Create a message from bytes./// The `fds` parameter is only available on unix. It specifies the file descriptors that/// accompany the message. On the wire, values of the UNIX_FD types store the index of the/// corresponding file descriptor in this vector. Passing an empty vector on a message that/// has UNIX_FD will result in an error./// **Note:** Since the constructed message is not construct by zbus, the receive sequence,/// which can be acquired from [`Message::recv_position`], is not applicable and hence set/// to `0`./// This method is unsafe as bytes may have an invalid encoding./// Create a message from its full contentstake_fds/// Take ownership of the associated file descriptors in the message./// When a message is received over a AF_UNIX socket, it may contain associated FDs. To prevent/// the message from closing those FDs on drop, call this method that returns all the received/// FDs with their ownership./// This function is Unix-specific./// Note: the message will continue to reference the files, so you must keep them open for as/// long as the message itself.body_signature/// The signature of the body./// **Note:** While zbus treats multiple arguments as a struct (to allow you to use the tuple/// syntax), D-Bus does not. Since this method gives you the signature expected on the wire by/// D-Bus, the trailing and leading STRUCT signature parenthesis will not be present in case of/// multiple arguments.modify_primary_header/// Deserialize the header./// Note: prefer using the direct access methods if possible; they are more efficient./// Deserialize the fields./// The message type./// The object to send a call to, or the object a signal is emitted from./// The interface to invoke a method call on, or that a signal is emitted from./// The member, either the method name or signal name./// The serial number of the message this message is a reply to.body_unchecked/// Deserialize the body (without checking signature matching).DynamicDeserialize/// Deserialize the body using the contained signature./// # use zbus::Message;/// # (|| -> zbus::Result<()> {/// let send_body = (7i32, (2i32, "foo"), vec!["bar"]);/// let message = Message::method(None::<&str>, Some("zbus.test"), "/", Some("zbus.test"), "ping", &send_body)?;/// let body : zbus::zvariant::Structure = message.body()?;/// let fields = body.fields();/// assert!(matches!(fields[0], zvariant::Value::I32(7)));/// assert!(matches!(fields[1], zvariant::Value::Structure(_)));/// assert!(matches!(fields[2], zvariant::Value::Array(_)));/// let reply_msg = Message::method_reply(None::<&str>, &message, &body)?;/// let reply_value : (i32, (i32, &str), Vec<String>) = reply_msg.body()?;/// assert_eq!(reply_value.0, 7);/// assert_eq!(reply_value.2.len(), 1);/// # Ok(()) })().unwrap()/// Get a reference to the byte encoding of the message.body_as_bytes/// Get a reference to the byte encoding of the body of the message.recv_position/// Get the receive ordering of a message./// This may be used to identify how two events were ordered on the bus.  It only produces a/// useful ordering for messages that were produced by the same [`zbus::Connection`]./// This is completely unrelated to the serial number on the message, which is set by the peer/// and might not be ordered at all.// TODO: Handle non-native byte order: https://github.com/dbus2/zbus/issues/19BuildGenericResult/// A builder for [`Message`]/// Create a message of type [`MessageType::Error`]./// Add flags to the message./// See [`MessageFlags`] documentation for the meaning of the flags./// The function will return an error if invalid flags are given for the message type./// Set the unique name of the sending connection./// Set the object to send a call to, or the object a signal is emitted from./// Set the interface to invoke a method call on, or that a signal is emitted from./// Set the member, either the method name or signal name./// Set the name of the connection this message is intended for.reply_to/// Build the [`Message`] with the given body./// You may pass `()` as the body if the message has no body./// The caller is currently required to ensure that the resulting message contains the headers/// as compliant with the [specification]. Additional checks may be added to this builder over/// time as needed./// [specification]:/// https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-header-fieldsbuild_raw_body/// Create a new message from a raw slice of bytes to populate the body with, rather than by/// serializing a value. The message body will be the exact bytes./// This method is unsafe because it can be used to build an invalid message.WriteFuncbuild_generictest_raw/// Code for [`MessageField::Invalid`](enum.MessageField.html#variant.Invalid)/// Code for [`MessageField::Path`](enum.MessageField.html#variant.Path)/// Code for [`MessageField::Interface`](enum.MessageField.html#variant.Interface)/// Code for [`MessageField::Member`](enum.MessageField.html#variant.Member)/// Code for [`MessageField::ErrorName`](enum.MessageField.html#variant.ErrorName)/// Code for [`MessageField::ReplySerial`](enum.MessageField.html#variant.ReplySerial)/// Code for [`MessageField::Destinatione`](enum.MessageField.html#variant.Destination)/// Code for [`MessageField::Sender`](enum.MessageField.html#variant.Sender)/// Code for [`MessageField::Signature`](enum.MessageField.html#variant.Signature)UnixFDs/// Code for [`MessageField::UnixFDs`](enum.MessageField.html#variant.UnixFDs)/// The message field code./// Every [`MessageField`] has an associated code. This is mostly an internal D-Bus protocol detail/// that you would not need to ever care about when using the high-level API. When using the/// low-level API, this is how you can [retrieve a specific field] from [`MessageFields`]./// [`MessageField`]: enum.MessageField.html/// [retrieve a specific field]: struct.MessageFields.html#method.get_field/// [`MessageFields`]: struct.MessageFields.html/// Get the associated code for this field./// Not a valid field./// The name of the error that occurred, for errors/// The name of the connection this message is intended for./// Unique name of the sending connection./// The signature of the message body./// The number of Unix file descriptors that accompany the message./// The dynamic message header./// All D-Bus messages contain a set of metadata [headers]. Some of these headers [are fixed] for/// all types of messages, while others depend on the type of the message in question. The latter/// are called message fields./// Please consult the [Message Format] section of the D-Bus spec for more details./// [headers]: struct.MessageHeader.html/// [are fixed]: struct.MessagePrimaryHeader.html/// [Message Format]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-messagesMAX_FIELDS_IN_MESSAGE// It's actually 10 (and even not that) but let's round it to next 8-byte alignment/// A collection of [`MessageField`] instances./// Creates an empty collection of fields./// Appends a [`MessageField`] to the collection of fields in the message./// Replaces a [`MessageField`] from the collection of fields with one with the same code,/// returning the old value if present./// Returns a slice with all the [`MessageField`] in the message./// Gets a reference to a specific [`MessageField`] by its code./// Returns `None` if the message has no such field.into_field/// Consumes the `MessageFields` and returns a specific [`MessageField`] by its code./// Remove the field matching the `code`./// Returns `true` if a field was found and removed, `false` otherwise.FieldPos/// A byte range of a field in a Message, used in [`QuickMessageFields`]./// Some invalid encodings (end = 0) are used to indicate "not cached" and "not present".new_not_present/// Reassemble a previously cached field./// **NOTE**: The caller must ensure that the `msg_buff` is the same one `build` was called for./// Otherwise, you'll get a panic./// A cache of some commonly-used fields of the header of a Message.PRIMARY_HEADER_SIZEb'B'/// The D-Bus message is in big-endian (network) byte order.b'l'/// The D-Bus message is in little-endian byte order./// D-Bus code for endianness.// Such a shame I've to do this manually/// Signature of the target's native endian./// Invalid message type. All unknown types on received messages are treated as invalid./// Method call. This message type may prompt a reply (and typically does)./// A reply to a method call./// An error in response to a method call./// Signal emission./// Message header representing the D-Bus type of the message." Pre-defined flags that can be passed in Message header."" This message does not expect method return replies or error replies, even if it is of a"" type that can have a reply; the reply should be omitted."" Note that `MessageType::MethodCall` is the only message type currently defined in the"" specification that can expect a reply, so the presence or absence of this flag in the other"" three message types that are currently documented is meaningless: replies to those message"" types should not be sent, whether this flag is present or not."NoReplyExpected" The bus must not launch an owner for the destination name in response to this message."NoAutoStart" This flag may be set on a method call message to inform the receiving side that the caller"" is prepared to wait for interactive authorization, which might take a considerable time to"" complete. For instance, if this flag is set, it would be appropriate to query the user for"" passwords or confirmation via Polkit or a similar framework."AllowInteractiveAuthSerialNum// FIXME: Can use `zvariant::Type` macro after `zvariant` provides a blanket implementation for// `OnceCell<T>`.// Unfortunately Serde doesn't provide a blanket impl. for `Cell<T>` so we have to implement// manually.// https://github.com/serde-rs/serde/issues/1952endian_sigbody_lenserial_num/// The primary message header, which is present in all D-Bus messages./// This header contains all the essential information about a message, regardless of its type./// Create a new `MessagePrimaryHeader` instance./// D-Bus code for bytorder encoding of the message.set_endian_sig/// Set the D-Bus code for bytorder encoding of the message.set_msg_type/// The message flags./// Set the message flags./// The major version of the protocol the message is compliant to./// Currently only `1` is valid.set_protocol_version/// Set the major version of the protocol the message is compliant to./// The byte length of the message body.set_body_len/// Set the byte length of the message body./// The serial number of the message (if set)./// This is used to match a reply to a method call./// **Note:** There is no setter provided for this in the public API since this is set by the/// [`Connection`](struct.Connection.html) the message is sent over.serial_num_or_init/// The message header, containing all the metadata about the message./// This includes both the [`MessagePrimaryHeader`] and [`MessageFields`]./// [`MessagePrimaryHeader`]: struct.MessagePrimaryHeader.htmlget_field_u32/// Create a new `MessageHeader` instance./// Get a reference to the primary header.primary_mut/// Get a mutable reference to the primary header.into_primary/// Get the primary header, consuming `self`./// Get a reference to the message fields.fields_mut/// Get a mutable reference to the message fields.into_fields/// Get the message fields, consuming `self`./// The message type/// The name of the error that occurred, for errors.unix_fds// 128 MiBActiveReceiver/// A [`stream::Stream`] implementation that yields [`Message`] items./// You can convert a [`Connection`] to this type and back to [`Connection`]./// **NOTE**: You must ensure a `MessageStream` is continuously polled or you will experience hangs./// If you don't need to continuously poll the `MessageStream` but need to keep it around for later/// use, keep the connection around and convert it into a `MessageStream` when needed. The/// conversion is not an expensive operation so you don't need to  worry about performance, unless/// you do it very frequently. If you need to convert back and forth frequently, you may want to/// consider keeping both a connection and stream around./// Create a message stream for the given match rule./// If `conn` is a bus connection and match rule is for a signal, the match rule will be/// registered with the bus and queued for deregistration when the stream is dropped. If you'd/// like immediate deregistration, use [`AsyncDrop::async_drop`]. The reason match rules are/// only registered with the bus for signals is that D-Bus specification only allows signals to/// be broadcasted and unicast messages are always sent to their destination (regardless of any/// match rules registered by the destination) by the bus. Hence there is no need to register/// match rules for non-signal messages with the bus./// Having said that, stream created by this method can still very useful as it allows you to/// avoid needless task wakeups and simplify your stream consuming code./// You can optionally also request the capacity of the underlying message queue through/// `max_queued`. If specified, the capacity is guaranteed to be at least `max_queued`. If not/// specified, the default of 64 is assumed. The capacity can also be changed later through/// [`MessageStream::set_max_queued`]./// use zbus::{AsyncDrop, Connection, MatchRule, MessageStream, fdo::NameOwnerChanged};/// use futures_util::{TryStreamExt, future::select, future::Either::{Left, Right}, pin_mut};/// let conn = Connection::session().await?;///     .add_arg("org.freedesktop.zbus.MatchRuleStreamTest42")?/// let mut stream = MessageStream::for_match_rule(/// ).await?;///                 arg0='org.freedesktop.zbus.MatchRuleStreamTest42'";///     stream.match_rule().map(|r| r.to_string()).as_deref(),/// // We register 2 names, starting with the uninteresting one. If `stream` wasn't filtering/// conn.request_name("org.freedesktop.zbus.MatchRuleStreamTest44")/// conn.request_name("org.freedesktop.zbus.MatchRuleStreamTest42")/// let msg = stream.try_next().await?.unwrap();/// assert_eq!(signal.args()?.name(), "org.freedesktop.zbus.MatchRuleStreamTest42");/// stream.async_drop().await;/// // Ensure the match rule is deregistered and this connection doesn't receive/// // `NameOwnerChanged` signals./// let stream = MessageStream::from(&conn).try_filter_map(|msg| async move {///     Ok(NameOwnerChanged::from_message(msg))/// conn.release_name("org.freedesktop.zbus.MatchRuleStreamTest42").await?;/// let next = stream.try_next();/// pin_mut!(next);/// let timeout = Timer::after(std::time::Duration::from_millis(50));/// pin_mut!(timeout);/// match select(next, timeout).await {///    Left((msg, _)) => unreachable!("unexpected message: {:?}", msg),///    Right((_, _)) => (),/// The maximum number of messages to queue for this stream./// Set maximum number of messages to queue for this stream./// After this call, the capacity is guaranteed to be at least `max_queued`.for_subscription_channelconn_inner//! The asynchronous API.//! This module hosts all our asynchronous API./// Opaque structure that derefs to an `Interface` type./// Opaque structure that mutably derefs to an `Interface` type./// **WARNING:** If methods (e.g property setters) in `ObjectServer` require `&mut self`/// `ObjectServer` will not be able to access the interface in question until all references/// of this method are dropped, it is highly recommended that the scope of the interface/// returned is restricted./// # use zbus::{Connection, dbus_interface};///    async fn count(&self) -> u32 {/// # let connection = Connection::session().await?;/// # connection.object_server().at(path, MyIface(22)).await?;/// let iface_ref = object_server.interface::<_, MyIface>(path).await?;/// let mut iface = iface_ref.get_mut().await;/// iface.count_changed(iface_ref.signal_context()).await?;get_child// Get the child Node at path.get_child_mut// Get the child Node at path. Optionally create one if it doesn't exist.// It also returns the path of parent node that implements ObjectManager (if any). If multiple// parents implement it (they shouldn't), then the closest one is returned.interface_lock// Takes a closure so caller can avoid having to create an Arc & RwLock in case interface was// already added.'life_self'async_recursion/// An object server, holding server-side D-Bus objects & interfaces./// Object servers hold interfaces on various object paths, and expose them over D-Bus./// All object paths will have the standard interfaces implemented on your behalf, such as/// `org.freedesktop.DBus.Introspectable` or `org.freedesktop.DBus.Properties`./// use zbus::{Connection, dbus_interface};///     async fn quit(&mut self) {///     .at("/org/zbus/path", interface)/// quit_listener.await;/// connection is established and therefore use [`zbus::ConnectionBuilder::serve_at`] instead./// However, there are situations where you'd need to register interfaces dynamically and that's/// where this method becomes useful.'nodeat_ready// Needs to be hardcoded as 'static instead of 'p like most other// functions, due to https://github.com/rust-lang/rust/issues/63033// (It doesn't matter a whole lot since this is an internal-only API// anyway.)/// Same as `at` but expects an interface already in `Arc<RwLock<dyn Interface>>` form.// FIXME: Better name?/// The typical use of this is property changes outside of a dispatched handler:///      #[dbus_interface(property)]///      async fn count(&self) -> u32 {///          self.0/// # connection.object_server().at(path, MyIface(0)).await?;///     .interface::<_, MyIface>(path).await?;dispatch_method_call_trydispatch_method_call" Dispatch an incoming message to a registered interface."" The object server will handle the message by:"" - looking up the called object path & interface,"" - calling the associated method if one exists,"" - returning a message (responding to the caller with either a return or error message) to""   the caller through the associated server connection."" Returns an error if the message is malformed, true if it\'s handled, false otherwise."dispatch_messageResponseDispatchNotifier/// A response wrapper that notifies after response has been sent./// Sometimes in [`dbus_interface`] method implemenations we need to do some other work after the/// response has been sent off. This wrapper type allows us to do that. Instead of returning your/// intended response type directly, wrap it in this type and return it from your method. The/// returned `EventListener` from `new` method will be notified when the response has been sent./// A typical use case is sending off signals after the response has been sent. The easiest way to/// do that is to spawn a task from the method that sends the signal but only after being notified/// of the response dispatch./// The notification indicates that the response has been sent off, not that destination peer has/// received it. That can only be guaranteed for a peer-to-peer connection./// [`dbus_interface`]: crate::dbus_interface/// Create a new `NotifyResponse`.join_streamsProxyInner/// A client-side interface proxy./// A `Proxy` is a helper to interact with an interface on a remote object./// use zbus::{Connection, Proxy};///     let connection = Connection::session().await?;///     ).await?;///     let _id: String = p.call("GetId", &()).await?;///     let _id: &str = p.call_method("GetId", &()).await?.body()?;/// [`futures` crate]: https://crates.io/crates/futuresdest_owner_change_match_ruleProxyInnerStatic/// This is required to avoid having the Drop impl extend the lifetime 'a, which breaks zbus_xmlgen/// (and possibly other crates).inner_without_borrowsproperty_cachePropertiesCache/// Cache of property values./// Set of properties which do not get cached, by name./// This overrides proxy-level caching behavior./// The property changed event generated by [`PropertyStream`].// The name of the property that changed.changed_listener/// A [`stream::Stream`] implementation that yields property change notifications.PropertyValuecaching_resultCachingResultCachingCached// new() runs this in a task it spawns for initialization of properties cache.keep_updated/// Wait for the cache to be populated and return any error encountered during populationsubscribe_dest_owner_change/// Subscribe to the "NameOwnerChanged" signal on the bus for our destination./// If the destination is a unique name, we will not subscribe to the signal.MAX_NAME_OWNER_CHANGED_SIGNALS_QUEUED/// See the [xml](xml/index.html) or [quick_xml](quick_xml/index.html) module for parsing theproperties_proxyowned_properties_proxyget_property_cache/// Get the cache, starting it in the background if needed./// Use PropertiesCache::ready() to wait for the cache to be populated and to get any errors/// encountered in the population.get_proxy_property/// Get the property value from the cache (if caching is enabled) or call the/// `Get` method of the `org.freedesktop.DBus.Properties` interface.receive_signals/// Get a stream to receive property changed events./// If caching is not enabled on this proxy, the resulting stream will not return any events./// Get a stream to receive destination owner changed events." Flags to use with [`Proxy::call_with_flags`]."" No response is expected from this method call, regardless of whether the"" signature for the interface method indicates a reply type. When passed,"" `call_with_flags` will return `Ok(None)` immediately after successfully"" sending the method call."" Errors encountered while *making* the call will still be returned as"" an `Err` variant, but any errors that are triggered by the receiver\'s"" handling of the call will not be delivered."" When set on a call whose destination is a message bus, this flag will instruct"" the bus not to [launch][al] a service to handle the call if no application"" on the bus owns the requested name."" This flag is ignored when using a peer-to-peer connection."" [al]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-starting-services"" Indicates to the receiver that this client is prepared to wait for interactive"" authorization, which might take a considerable time to complete. For example, the receiver"" may query the user for confirmation via [polkit] or a similar framework."" [polkit]: https://gitlab.freedesktop.org/polkit/polkit/"OwnerChangedStreamMap/// A [`stream::Stream`] implementation that yields `UniqueName` when the bus owner changes.src_unique_name/// A [`stream::Stream`] implementation that yields signal [messages](`Message`)./// This type uses a [`MessageStream::for_match_rule`] internally and therefore the note about match/// rule registration and [`AsyncDrop`] in its documentation applies here as well.signal_stream_deadlocktest_signal_stream_deadlock/// Tests deadlocking in signal reception when the message queue is full./// Creates a connection with a small message queue, and a service that/// emits signals at a high rate. First a listener is created that listens/// for that signal which should fill the small queue. Then another signal/// signal listener is created against another signal. Previously, this second/// call to add the match rule never resolved and resulted in a deadlock./// Cache properties. The properties will be cached upfront as part of the proxy/// Don't cache properties.Lazily/// Cache properties but only populate the cache on the first read of a property (default)./// The properties caching mode.proxy_type/// Set the properties caching mode.build_internal/// If the builder is lacking the necessary parameters to build a proxy,/// [`Error::MissingParameter`] is returned./// Trait for the default associated values of a proxy./// The trait is automatically implemented by the [`dbus_proxy`] macro on your behalf, and may be/// later used to retrieve the associated constants.builder_async/// Annotations are generic key/value pairs of metadata./// Return the annotation name/key./// Return the annotation value.ArgDirection/// A direction of an argument/// An argument/// Return the argument name, if any./// Return the argument type./// Return the argument direction, if any./// Return the associated annotations./// A method/// Return the method name./// Return the method arguments./// Return the method annotations./// A signal/// Return the signal name./// Return the signal arguments./// Return the signal annotations.PropertyAccess/// The possible property access types/// A property/// Returns the property name./// Returns the property type./// Returns the property access flags (should be "read", "write" or "readwrite")./// An interface/// Returns the interface name./// Returns the interface methods./// Returns the interface signals./// Returns the interface properties./// An introspection tree node (typically the root of the XML document)./// Parse the introspection XML document from reader./// Write the XML document to writer./// Returns the node name, if any./// Returns the children nodes./// Returns the interfaces on this node./// Parse the introspection XML document from `s`.EXAMPLE//! Introspection XML support (`quick-xml` feature)//! Thanks to the [`org.freedesktop.DBus.Introspectable`] interface, objects may be introspected at//! runtime, returning an XML string that describes the object.//! This optional `quick_xml` module provides facilities to parse the XML data into more convenient//! Rust structures. The XML string may be parsed to a tree with [`Node.from_reader()`].//! This module has a more type-safe API and uses a maintained XML parser.//! It will eventually replace the [xml](xml/index.html) module.//! See also://! * [Introspection format] in the DBus specification//! [`Node.from_reader()`]: struct.Node.html#method.from_reader//! [Introspection format]: https://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format//! [`org.freedesktop.DBus.Introspectable`]: https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-introspectableraw_in_bufferraw_in_fdsraw_in_posout_msgsprev_seq/// A low-level representation of a D-Bus connection/// This wrapper is agnostic on the actual transport, using the `Socket` trait/// to abstract it. It is compatible with sockets both in blocking or non-blocking/// This wrapper abstracts away the serialization & buffering considerations of the/// protocol, and allows interaction based on messages, rather than bytes.try_flush/// Attempt to flush the outgoing buffer/// This will try to write as many messages as possible from the/// outgoing buffer into the socket, until an error is encountered./// This method will thus only block if the socket is in blocking mode.enqueue_message/// Enqueue a message to be sent out to the socket/// This method will *not* write anything to the socket, you need to call/// `try_flush()` afterwards so that your message is actually sent out.try_receive_message/// Attempt to read a message from the socket/// This methods will read from the socket until either a full D-Bus message is/// read or an error is encountered./// If the socket is in non-blocking mode, it may read a partial message. In such case it/// will buffer it internally and try to complete it the next time you call/// `try_receive_message`./// After this call, all reading and writing operations will fail./// Access the underlying socket/// This method is intended to provide access to the socket in order to access certain/// properties (e.g peer credentials)./// You should not try to read or write from it directly, as it may corrupt the internal state/// of this wrapper./// Same as `try_flush` above, except it wraps the method for use in [`std::future::Future`]/// impls.raw_send_receiveraw_send_receive_asyncFDS_MAXfd_recvmsgfd_sendmsgget_unix_pidget_unix_uidPollRecvmsgcan_pass_unix_fd/// Supports passing file descriptors.poll_recvmsg/// Attempt to receive a message from the socket./// On success, returns the number of bytes read as well as a `Vec` containing/// any associated file descriptors.poll_sendmsg/// Attempt to send a message on the socket/// On success, return the number of bytes written. There may be a partial write, in/// which case the caller is responsible of sending the remaining data by calling this/// method again until everything is written or it returns an error of kind `WouldBlock`./// If at least one byte has been written, then all the provided file descriptors will/// have been sent as well, and should not be provided again in subsequent calls./// If the underlying transport does not support transmitting file descriptors, this/// will return `Err(ErrorKind::InvalidInput)`./// Close the socket./// After this call, it is valid for all reading and writing operations to fail./// Return the peer PID./// Return the User ID, if any./// Trait representing some transport layer over which the DBus protocol can be used/// The crate provides implementations for `async_io` and `tokio`'s `UnixStream` wrappers if you/// enable the corresponding crate features (`async_io` is enabled by default)./// You can implement it manually to integrate with other runtimes or other dbus transports.  Feel/// free to submit pull requests to add support for more runtimes to zbus itself so rust's orphan/// rules don't force the use of a wrapper struct (and to avoid duplicating the work across many/// projects)./// A signal emission context./// For signal emission using the high-level API, you'll need instances of this type./// See [`crate::InterfaceRef::signal_context`] and [`crate::dbus_interface`]/// documentation for details and examples of this type in use./// Create a new signal context for the given connection and object path./// Set the destination for the signal emission./// Signals are typically broadcasted and thus don't have a destination. However, there are/// cases where you need to unicast signals to specific peers. This method allows you to set the/// destination for the signals emitted with this context./// Get a reference to the associated object path./// Get a reference to the associated destination (if any).receive_msgpadding_for_n_bytes/// Helper trait for macro-generated code./// This trait allows macros to refer to the `Ok` and `Err` types of a [Result] that is behind a/// type alias.  This is currently required because the macros for properties expect a Result/// return value, but the macro-generated `receive_` functions need to refer to the actual/// type without the associated error.// this is hardcoded in sdbus - nothing in the specMIB_TCP_STATE_ESTABuds_windows// An owned Windows handle// SAFETY: since `handle` is just a pointer, it can be given to multiple `OwnedHandle`ProcessHandle// A process handle// Open the process associated with the process_id (if None, the current process)ProcessToken// A process token// See MSDN documentation:// https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocesstoken// Get the process security identifier with the `sid()` function.// Open the access token associated with the process_id (if None, the current process)// Return the process SID (security identifier) as a stringsocket_addr_get_pid// Get the process ID of the local socket address// TODO: add ipv6 supporttcp_stream_get_peer_pid// Get the process ID of the connected peerunix_stream_get_peer_pidread_shmwindows_autolaunch_bus_addresssocket_pid_and_sidserde_xml_rs/// Return the argument direction (should be "in" or "out"), if any.MethodElementSignalElementInterfaceElementNodeElement//! Introspection XML support (`xml` feature)//! This optional `xml` module provides facilities to parse the XML data into more convenient Rust//! structures. The XML string may be parsed to a tree with [`Node.from_reader()`].// note: serde-xml-rs doesn't handle nicely interleaved elements, so we have to use enums:// https://github.com/RReverser/serde-xml-rs/issues/55def_attrsALLOWED_ATTRSStructAttributesparse_nested_metaszbus_errorVariantAttributes// FIXME: The list name should once be "zbus" instead of "dbus_error" (like in serde).expand_derivegen_reply_for_variantTraitAttributesMethodAttributes// FIXME: The list name should once be "zbus" instead of "dbus_interface" (like in serde).ArgAttributesarg_attrsdoc_commentsget_args_from_inputsclean_input_argsintrospect_signalintrospect_methodintrospect_input_argsintrospect_output_argget_result_typeintrospect_add_output_argsintrospect_propertiesto_xml_docs/// Attribute macro for defining D-Bus proxies (using [`zbus::Proxy`] and/// [`zbus::blocking::Proxy`])./// The macro must be applied on a `trait T`. Two matching `impl T` will provide an asynchronous/// Proxy implementation, named `TraitNameProxy` and a blocking one, named `TraitNameProxyBlocking`./// The proxy instances can be created with the associated `new()` or `builder()` methods. The/// former doesn't take any argument and uses the default service name and path. The later allows/// you to specify non-default proxy arguments./// The following attributes are supported:/// * `interface` - the name of the D-Bus interface this proxy is for./// * `default_service` - the default service this proxy should connect to./// * `default_path` - The default object path the method calls will be sent on and signals will be///   sent for by the target service./// * `gen_async` - Whether or not to generate the asynchronous Proxy type./// * `gen_blocking` - Whether or not to generate the blocking Proxy type. If set to `false`, the///   asynchronous proxy type will take the name `TraitNameProxy` (i-e no `Async` prefix)./// * `async_name` - Specify the exact name of the asynchronous proxy type./// * `blocking_name` - Specify the exact name of the blocking proxy type./// * `assume_defaults` - whether to auto-generate values for `default_path` and `default_service`///   if none are specified (default: `true`). `dbus_proxy` currently generates a warning if neither///   this attribute nor one of the default values are specified. A future release will change the///   default to `false`. Please make sure to explicitly set either this attribute or the default///   values, according to your needs./// Each trait method will be expanded to call to the associated D-Bus remote interface./// Trait methods accept `dbus_proxy` attributes:/// * `name` - override the D-Bus name (pascal case form by default)/// * `property` - expose the method as a property. If the method takes an argument, it must be a///   setter, with a `set_` prefix. Otherwise, it's a getter. Additional sub-attributes exists to///   control specific property behaviors:///   * `emits_changed_signal` - specifies how property changes are signaled. Valid values are those///     documented in [DBus specifications][dbus_emits_changed_signal]:///     * `"true"` - (default) change signal is always emitted with the value included. This uses///       the default caching behavior of the proxy, and generates a listener method for the change///       signal.///     * `"invalidates"` - change signal is emitted, but the value is not included in the signal.///       This has the same behavior as `"true"`.///     * `"const"` - property never changes, thus no signal is ever emitted for it. This uses the///       default caching behavior of the proxy, but does not generate a listener method for the///       change signal.///     * `"false"` - change signal is not (guaranteed to be) emitted if the property changes. This///       disables property value caching, and does not generate a listener method for the change/// * `signal` - declare a signal just like a D-Bus method. Read the [Signals](#signals) section///   below for details./// * `no_reply` - declare a method call that does not wait for a reply./// * `no_autostart` - declare a method call that will not trigger the bus to automatically launch///   the destination service if it is not already running./// * `allow_interactive_auth` - declare a method call that is allowed to trigger an interactive///   prompt for authorization or confirmation from the receiver./// * `object` - methods that returns an [`ObjectPath`] can be annotated with the `object` attribute///   to specify the proxy object to be constructed from the returned [`ObjectPath`]./// * `async_object` - if the assumptions made by `object` attribute about naming of the///   asynchronous proxy type, don't fit your bill, you can use this to specify its exact name./// * `blocking_object` - if the assumptions made by `object` attribute about naming of the blocking///   proxy type, don't fit your bill, you can use this to specify its exact name.///   NB: Any doc comments provided shall be appended to the ones added by the macro./// # Signals/// For each signal method declared, this macro will provide a method, named `receive_<method_name>`/// to create a [`zbus::SignalStream`] ([`zbus::blocking::SignalIterator`] for the blocking proxy)/// wrapper, named `<SignalName>Stream` (`<SignalName>Iterator` for the blocking proxy) that yield/// a [`zbus::Message`] wrapper, named `<SignalName>`. This wrapper provides type safe access to the/// signal arguments. It also implements `Deref<Target = Message>` to allow easy access to the/// underlying [`zbus::Message`]./// use zbus_macros::dbus_proxy;/// use zbus::{blocking::Connection, Result, fdo, zvariant::Value};/// use async_io::block_on;/// #[dbus_proxy(///     interface = "org.test.SomeIface",///     default_service = "org.test.SomeService",///     default_path = "/org/test/SomeObject"/// )]/// trait SomeIface {///     fn do_this(&self, with: &str, some: u32, arg: &Value<'_>) -> Result<bool>;///     #[dbus_proxy(property)]///     fn a_property(&self) -> fdo::Result<String>;///     fn set_a_property(&self, a_property: &str) -> fdo::Result<()>;///     #[dbus_proxy(signal)]///     fn some_signal(&self, arg1: &str, arg2: u32) -> fdo::Result<()>;///     #[dbus_proxy(object = "SomeOtherIface", blocking_object = "SomeOtherInterfaceBlock")]///     // The method will return a `SomeOtherIfaceProxy` or `SomeOtherIfaceProxyBlock`, depending///     // on whether it is called on `SomeIfaceProxy` or `SomeIfaceProxyBlocking`, respectively.///     // NB: We explicitly specified the exact name of the blocking proxy type. If we hadn't,///     // `SomeOtherIfaceProxyBlock` would have been assumed and expected. We could also specify///     // the specific name of the asynchronous proxy types, using the `async_object` attribute.///     fn some_method(&self, arg1: &str);///     interface = "org.test.SomeOtherIface",///     default_service = "org.test.SomeOtherService",///     blocking_name = "SomeOtherInterfaceBlock",/// trait SomeOtherIface {}/// // Use `builder` to override the default arguments, `new` otherwise./// let proxy = SomeIfaceProxyBlocking::builder(&connection)///                .destination("org.another.Service")?///                .cache_properties(zbus::CacheProperties::No)///                .build()?;/// let _ = proxy.do_this("foo", 32, &Value::new(true));/// let _ = proxy.set_a_property("val");/// let signal = proxy.receive_some_signal()?.next().unwrap();/// let args = signal.args()?;/// println!("arg1: {}, arg2: {}", args.arg1(), args.arg2());/// // Now the same again, but asynchronous./// block_on(async move {///     let proxy = SomeIfaceProxy::builder(&connection.into())///                    .cache_properties(zbus::CacheProperties::No)///                    .build()///                    .await///                    .unwrap();///     let _ = proxy.do_this("foo", 32, &Value::new(true)).await;///     let _ = proxy.set_a_property("val").await;///     let signal = proxy.receive_some_signal().await?.next().await.unwrap();///     let args = signal.args()?;///     println!("arg1: {}, arg2: {}", args.arg1(), args.arg2());///     Ok::<(), zbus::Error>(())/// [`zbus_polkit`] is a good example of how to bind a real D-Bus API./// [`zbus_polkit`]: https://docs.rs/zbus_polkit/1.0.0/zbus_polkit/policykit1/index.html/// [`zbus::Proxy`]: https://docs.rs/zbus/3.0.0/zbus/struct.Proxy.html/// [`zbus::Message`]: https://docs.rs/zbus/3.0.0/zbus/struct.Message.html/// [`zbus::blocking::Proxy`]: https://docs.rs/zbus/3.0.0/zbus/blocking/struct.Proxy.html/// [`zbus::SignalStream`]: https://docs.rs/zbus/3.0.0/zbus/struct.SignalStream.html/// [`zbus::blocking::SignalIterator`]: https://docs.rs/zbus/3.0.0/zbus/blocking/struct.SignalIterator.html/// [`zbus::SignalReceiver::receive_for`]:/// https://docs.rs/zbus/3.0.0/zbus/struct.SignalReceiver.html#method.receive_for/// [`ObjectPath`]: https://docs.rs/zvariant/2.10.0/zvariant/struct.ObjectPath.html/// [dbus_emits_changed_signal]: https://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format/// Attribute macro for implementing a D-Bus interface./// The macro must be applied on an `impl T`. All methods will be exported, either as methods,/// properties or signal depending on the item attributes. It will implement the [`Interface`] trait/// `for T` on your behalf, to handle the message dispatching and introspection support./// The methods accepts the `dbus_interface` attributes:/// * `name` - override the D-Bus name (pascal case form of the method by default)///   setter, with a `set_` prefix. Otherwise, it's a getter. If it may fail, a property method must///   return `zbus::fdo::Result`./// * `signal` - the method is a "signal". It must be a method declaration (without body). Its code///   block will be expanded to emit the signal from the object path associated with the interface///   instance.///   You can call a signal method from a an interface method, or from an [`ObjectServer::with`]///   function./// * `out_args` - When returning multiple values from a method, naming the out arguments become///   important. You can use `out_args` to specify their names.///   In such case, your method must return a tuple containing///   your out arguments, in the same order as passed to `out_args`./// The `struct_return` attribute (from zbus 1.x) is no longer supported. If you want to return a/// single structure from a method, declare it to return a tuple containing either a named structure/// or a nested tuple./// Note: a `<property_name_in_snake_case>_changed` method is generated for each property: this/// method emits the "PropertiesChanged" signal for the associated property. The setter (if it/// exists) will automatically call this method. For instance, a property setter named `set_foo`/// will be called to set the property "Foo", and will emit the "PropertiesChanged" signal with the/// new value for "Foo". Other changes to the "Foo" property can be signaled manually with the/// generated `foo_changed` method. In addition, a `<property_name_in_snake_case>_invalidated`/// method is also generated that much like `_changed` method, emits a "PropertyChanged" signal/// but does not send over the new value of the property along with it. It is usually best to avoid/// using this since it will force all interested peers to fetch the new value and hence result in/// excess traffic on the bus./// The method arguments support the following `zbus` attributes:/// * `object_server` - This marks the method argument to receive a reference to the///   [`ObjectServer`] this method was called by./// * `connection` - This marks the method argument to receive a reference to the [`Connection`] on///   which the method call was received./// * `header` - This marks the method argument to receive the message header associated with the///   D-Bus method call being handled./// * `signal_context` - This marks the method argument to receive a [`SignalContext`] instance,///   which is needed for emitting signals the easy way./// use zbus_macros::dbus_interface;/// use zbus::{ObjectServer, SignalContext, MessageHeader};///     _some_data: String,/// #[dbus_interface(name = "org.myservice.Example")]///     // "Quit" method. A method may throw errors.///     async fn quit(///         #[zbus(header)]///         hdr: MessageHeader<'_>,///         #[zbus(signal_context)]///         ctxt: SignalContext<'_>,///         #[zbus(object_server)]///         _server: &ObjectServer,///     ) -> zbus::fdo::Result<()> {///         let path = hdr.path()?.unwrap();///         let msg = format!("You are leaving me on the {} path?", path);///         Example::bye(&ctxt, &msg).await?;///         // Do some asynchronous tasks before quitting..///     // "TheAnswer" property (note: the "name" attribute), with its associated getter.///     // A `the_answer_changed` method has also been generated to emit the///     // "PropertiesChanged" signal for this property.///     #[dbus_interface(property, name = "TheAnswer")]///     fn answer(&self) -> u32 {///         2 * 3 * 7///     // "IFail" property with its associated getter.///     // An `i_fail_changed` method has also been generated to emit the///     #[dbus_interface(property)]///     fn i_fail(&self) -> zbus::fdo::Result<i32> {///         Err(zbus::fdo::Error::UnknownProperty("IFail".into()))///     // "Bye" signal (note: no implementation body).///     async fn bye(signal_ctxt: &SignalContext<'_>, message: &str) -> zbus::Result<()>;///     #[dbus_interface(out_args("answer", "question"))]///     fn meaning_of_life(&self) -> zbus::fdo::Result<(i32, String)> {///         Ok((42, String::from("Meaning of life")))/// See also [`ObjectServer`] documentation to learn how to export an interface over a `Connection`./// [`ObjectServer`]: https://docs.rs/zbus/3.0.0/zbus/struct.ObjectServer.html/// [`ObjectServer::with`]: https://docs.rs/zbus/3.0.0/zbus/struct.ObjectServer.html#method.with/// [`Connection`]: https://docs.rs/zbus/3.0.0/zbus/struct.Connection.html/// [`Connection::emit_signal()`]: https://docs.rs/zbus/3.0.0/zbus/struct.Connection.html#method.emit_signal/// [`SignalContext`]: https://docs.rs/zbus/3.0.0/zbus/struct.SignalContext.html/// [`Interface`]: https://docs.rs/zbus/3.0.0/zbus/trait.Interface.htmlderive_dbus_error/// Derive macro for implementing [`zbus::DBusError`] trait./// This macro makes it easy to implement the [`zbus::DBusError`] trait for your custom error type/// (currently only enums are supported)./// If a special variant marked with the `dbus_error` attribute is present, `From<zbus::Error>` is/// also implemented for your type. This variant can only have a single unnamed field of type/// [`zbus::Error`]. This implementation makes it possible for you to declare proxy methods to/// directly return this type, rather than [`zbus::Error`]./// Each variant (except for the special `dbus_error` one) can optionally have a (named or unnamed)/// `String` field (which is used as the human-readable error description)./// use zbus_macros::DBusError;/// #[derive(DBusError, Debug)]/// #[dbus_error(prefix = "org.myservice.App")]///     #[dbus_error(zbus_error)]///     ZBus(zbus::Error),///     FileNotFound(String),///     OutOfMemory,/// [`zbus::DBusError`]: https://docs.rs/zbus/3.0.0/zbus/trait.DBusError.html/// [`zbus::Error`]: https://docs.rs/zbus/3.0.0/zbus/enum.Error.html/// [`zvariant::Type`]: https://docs.rs/zvariant/3.0.0/zvariant/trait.Type.html/// [`serde::Serialize`]: https://docs.rs/serde/1.0.132/serde/trait.Serialize.htmltyped_argzbus_pathassume_defaultsdefault_pathdefault_serviceasync_nameblocking_namegen_blockingImplAttributesemits_changed_signalPropertyAttributesasync_objectblocking_objectno_replyno_autostartallow_interactive_auth// FIXME: The list name should once be "zbus" instead of "dbus_proxy" (like in serde).AsyncOptsgen_proxy_method_callPropertyEmitsChangedSignal/// Standard annotation `org.freedesktop.DBus.Property.EmitsChangedSignal`./// See <https://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format>.gen_proxy_propertySetLifetimeSgen_proxy_signalget_doc_attrspascal_case// Convert to pascal case, assuming snake case.// If `s` is already in pascal case, should yield the same result.is_blankOwnedWellKnownNameNoneValueWellKnown/// String that identifies a [bus name]./// use core::convert::TryFrom;/// use zbus_names::BusName;/// // Valid well-known names./// let name = BusName::try_from("org.gnome.Service-for_you").unwrap();/// assert!(matches!(name, BusName::WellKnown(_)));/// assert_eq!(name, "org.gnome.Service-for_you");/// let name = BusName::try_from("a.very.loooooooooooooooooo-ooooooo_0000o0ng.Name").unwrap();/// assert_eq!(name, "a.very.loooooooooooooooooo-ooooooo_0000o0ng.Name");/// // Valid unique names./// let name = BusName::try_from(":org.gnome.Service-for_you").unwrap();/// assert!(matches!(name, BusName::Unique(_)));/// assert_eq!(name, ":org.gnome.Service-for_you");/// let name = BusName::try_from(":a.very.loooooooooooooooooo-ooooooo_0000o0ng.Name").unwrap();/// assert_eq!(name, ":a.very.loooooooooooooooooo-ooooooo_0000o0ng.Name");/// // Invalid bus names/// BusName::try_from("").unwrap_err();/// BusName::try_from("double..dots").unwrap_err();/// BusName::try_from(".").unwrap_err();/// BusName::try_from(".start.with.dot").unwrap_err();/// BusName::try_from("1start.with.digit").unwrap_err();/// BusName::try_from("no-dots").unwrap_err();/// [bus name]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus/// A borrowed clone (never allocates, unlike clone)./// The well-known-name as string.from_static_str/// Same as `try_from`, except it takes a `&'static str`.NoneType// Manual deserialize implementation to get the desired error on invalid bus names./// This never succeeds but is provided so it's easier to pass `Option::None` values for API/// requiring `Option<TryInto<impl BusName>>`, since type inference won't work here./// Owned sibling of [`BusName`]./// Convert to the inner `BusName`, consuming `self`./// Get a reference to the inner `BusName`.InvalidBusName/// Invalid bus name. The strings describe why the bus name is neither a valid unique nor/// well-known name, respectively.InvalidWellKnownName/// Invalid well-known bus name.InvalidUniqueName/// Invalid unique bus name.InvalidInterfaceName/// Invalid interface name.InvalidMemberName/// Invalid member (method or signal) name.InvalidErrorName/// Invalid error name./// The error type for `zbus_names`./// Alias for a `Result` with the error type `zbus_names::Error`.impl_try_from/// String that identifies an [error name][en] on the bus./// Error names have same constraints as error names./// use zbus_names::ErrorName;/// // Valid error names./// let name = ErrorName::try_from("org.gnome.Error_for_you").unwrap();/// assert_eq!(name, "org.gnome.Error_for_you");/// let name = ErrorName::try_from("a.very.loooooooooooooooooo_ooooooo_0000o0ng.ErrorName").unwrap();/// assert_eq!(name, "a.very.loooooooooooooooooo_ooooooo_0000o0ng.ErrorName");/// // Invalid error names/// ErrorName::try_from("").unwrap_err();/// ErrorName::try_from(":start.with.a.colon").unwrap_err();/// ErrorName::try_from("double..dots").unwrap_err();/// ErrorName::try_from(".").unwrap_err();/// ErrorName::try_from(".start.with.dot").unwrap_err();/// ErrorName::try_from("no-dots").unwrap_err();/// ErrorName::try_from("1st.element.starts.with.digit").unwrap_err();/// ErrorName::try_from("the.2nd.element.starts.with.digit").unwrap_err();/// ErrorName::try_from("contains.dashes-in.the.name").unwrap_err();/// [en]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-error/// The error name as string./// Create a new `ErrorName` from the given string./// Since the passed string is not checked for correctness, prefer using the/// `TryFrom<&str>` implementation.from_static_str_unchecked/// Same as `from_str_unchecked`, except it takes a `&'static str`./// Same as `from_str_unchecked`, except it takes an owned `String`./// `TryFrom<String>` implementation.ensure_correct_error_name/// Owned sibling of [`ErrorName`]./// Convert to the inner `ErrorName`, consuming `self`./// Get a reference to the inner `ErrorName`./// String that identifies an [interface name][in] on the bus./// use zbus_names::InterfaceName;/// // Valid interface names./// let name = InterfaceName::try_from("org.gnome.Interface_for_you").unwrap();/// assert_eq!(name, "org.gnome.Interface_for_you");/// let name = InterfaceName::try_from("a.very.loooooooooooooooooo_ooooooo_0000o0ng.Name").unwrap();/// assert_eq!(name, "a.very.loooooooooooooooooo_ooooooo_0000o0ng.Name");/// // Invalid interface names/// InterfaceName::try_from("").unwrap_err();/// InterfaceName::try_from(":start.with.a.colon").unwrap_err();/// InterfaceName::try_from("double..dots").unwrap_err();/// InterfaceName::try_from(".").unwrap_err();/// InterfaceName::try_from(".start.with.dot").unwrap_err();/// InterfaceName::try_from("no-dots").unwrap_err();/// InterfaceName::try_from("1st.element.starts.with.digit").unwrap_err();/// InterfaceName::try_from("the.2nd.element.starts.with.digit").unwrap_err();/// InterfaceName::try_from("contains.dashes-in.the.name").unwrap_err();/// [in]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface/// The interface name as string./// Create a new `InterfaceName` from the given string.ensure_correct_interface_name/// Owned sibling of [`InterfaceName`]./// Convert to the inner `InterfaceName`, consuming `self`./// Get a reference to the inner `InterfaceName`.bus_namewell_known_namemember_name/// String that identifies an [member (method or signal) name][in] on the bus./// use zbus_names::MemberName;/// // Valid member names./// let name = MemberName::try_from("Member_for_you").unwrap();/// assert_eq!(name, "Member_for_you");/// let name = MemberName::try_from("CamelCase101").unwrap();/// assert_eq!(name, "CamelCase101");/// let name = MemberName::try_from("a_very_loooooooooooooooooo_ooooooo_0000o0ngName").unwrap();/// assert_eq!(name, "a_very_loooooooooooooooooo_ooooooo_0000o0ngName");/// // Invalid member names/// MemberName::try_from("").unwrap_err();/// MemberName::try_from(".").unwrap_err();/// MemberName::try_from("1startWith_a_Digit").unwrap_err();/// MemberName::try_from("contains.dots_in_the_name").unwrap_err();/// MemberName::try_from("contains-dashes-in_the_name").unwrap_err();/// [in]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-member/// The member name as string./// Create a new `MemberName` from the given string.OwnedMemberNameensure_correct_member_name/// Owned sibling of [`MemberName`]./// Convert to the inner `MemberName`, consuming `self`./// Get a reference to the inner `MemberName`./// String that identifies a [unique bus name][ubn]./// use zbus_names::UniqueName;/// let name = UniqueName::try_from(":org.gnome.Service-for_you").unwrap();/// let name = UniqueName::try_from(":a.very.loooooooooooooooooo-ooooooo_0000o0ng.Name").unwrap();/// // Invalid unique names/// UniqueName::try_from("").unwrap_err();/// UniqueName::try_from("dont.start.with.a.colon").unwrap_err();/// UniqueName::try_from(":double..dots").unwrap_err();/// UniqueName::try_from(".").unwrap_err();/// UniqueName::try_from(".start.with.dot").unwrap_err();/// UniqueName::try_from(":no-dots").unwrap_err();/// [ubn]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus/// The unique name as string./// Create a new `UniqueName` from the given string.ensure_correct_unique_name/// Owned sibling of [`UniqueName`]./// Convert to the inner `UniqueName`, consuming `self`./// Get a reference to the inner `UniqueName`./// String that identifies a [well-known bus name][wbn]./// use zbus_names::WellKnownName;/// let name = WellKnownName::try_from("org.gnome.Service-for_you").unwrap();/// let name = WellKnownName::try_from("a.very.loooooooooooooooooo-ooooooo_0000o0ng.Name").unwrap();/// // Invalid well-known names/// WellKnownName::try_from("").unwrap_err();/// WellKnownName::try_from("double..dots").unwrap_err();/// WellKnownName::try_from(".").unwrap_err();/// WellKnownName::try_from(".start.with.dot").unwrap_err();/// WellKnownName::try_from("1st.element.starts.with.digit").unwrap_err();/// WellKnownName::try_from("the.2nd.element.starts.with.digit").unwrap_err();/// WellKnownName::try_from("no-dots").unwrap_err();/// [wbn]: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus/// Create a new `WellKnownName` from the given string.ensure_correct_well_known_name/// Owned sibling of [`WellKnownName`]./// Convert to the inner `WellKnownName`, consuming `self`./// Get a reference to the inner `WellKnownName`.// We don't reexport `WriteBytesExt` or `ReadBytesExt` because those are only// available with the `std` feature enabled, and zerocopy is `no_std` byimpl_fmt_traitimpl_ops_traits// Implement traits in terms of the same trait on the native type, but// without performing a byte order swap. This only works for bitwise// operations like `&`, `|`, etc.define_max_value_constant// We don't provide maximum and minimum value constants for signed values// and floats because there's no way to do it generically - it would require// a different value depending on the value of the `ByteOrder` type// parameter. Currently, one workaround would be to provide implementations// for concrete implementations of that trait. In the long term, if we are// ever able to make the `new` constructor a const fn, we could use that// instead.define_typeDstLayoutraw_from_ptr_lenUnalignedsafety_commentr" The value zero."r" This constant should be preferred to constructing a new value"r" using `new`, as `new` may perform an endianness swap depending"r" on the endianness and platform."r" This constant should be preferred to constructing a new value using"r" `new`, as `new` may perform an endianness swap depending on the"r" endianness `O` and the endianness of the platform."r" Constructs a new value from bytes which are already in the"r" endianness `O`."r" Constructs a new value, possibly performing an endianness swap"r" to guarantee that the returned value has endianness `O`."r" Returns the value as a primitive type, possibly performing an"r" endianness swap to guarantee that the return value has the"r" endianness of the native platform."r" Updates the value in place as a primitive type, possibly"r" performing an endianness swap to guarantee that the stored value"r" has the endianness `O`."r" Numeric primitives stored in""big-endian"r" byte order."r" A""16-bit unsigned integer"r" stored in""32-bit unsigned integer""64-bit unsigned integer""128-bit unsigned integer""16-bit signed integer""32-bit signed integer""64-bit signed integer""128-bit signed integer""32-bit floating point number""64-bit floating point number""little-endian""network-endian"network_endian"native-endian"compatibilityassert_eq_or_nan/// For `f32` and `f64`, NaN values are not considered equal to/// themselves. This method is like `assert_eq!`, but it treats NaN/// values as equal.// A native integer type (u16, i32, etc)./// Invert the order of the bytes in the array.ByteOrderTypeByteOrderTypeUnsignedimpl_byte_arrayimpl_byte_order_type_unsignedcall_for_unsigned_typescall_for_signed_typescall_for_float_typescall_for_all_typesNonNativeEndian// We use a `u64` seed so that we can use `SeedableRng::seed_from_u64`.// `SmallRng`'s `SeedableRng::Seed` differs by platform, so if we wanted to// call `SeedableRng::from_seed`, which takes a `Seed`, we would need// conditional compilation by `target_pointer_width`.RAND_ITERStest_max_valuetest_endiantest_ops_implstest_debug_impl// Copyright 2019 The Fuchsia Authors// Licensed under a BSD-style license <LICENSE-BSD>, Apache License, Version 2.0// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0>, or the MIT// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.// This file may not be copied, modified, or distributed except according to// those terms.//! Byte order-aware numeric primitives.//! This module contains equivalents of the native multi-byte integer types with//! no alignment requirement and supporting byte order conversions.//! For each native multi-byte integer type - `u16`, `i16`, `u32`, etc - and//! floating point type - `f32` and `f64` - an equivalent type is defined by//! this module - [`U16`], [`I16`], [`U32`], [`F64`], etc. Unlike their native//! counterparts, these types have alignment 1, and take a type parameter//! specifying the byte order in which the bytes are stored in memory. Each type//! implements the [`FromBytes`], [`AsBytes`], and [`Unaligned`] traits.//! These two properties, taken together, make these types useful for defining//! data structures whose memory layout matches a wire format such as that of a//! network protocol or a file format. Such formats often have multi-byte values//! at offsets that do not respect the alignment requirements of the equivalent//! native types, and stored in a byte order not necessarily the same as that of//! the target platform.//! Type aliases are provided for common byte orders in the [`big_endian`],//! [`little_endian`], [`network_endian`], and [`native_endian`] submodules.//! One use of these types is for representing network packet formats, such as//! UDP://! ```rust,edition2021//! # #[cfg(feature = "derive")] { // This example uses derives, and won't compile without them//! use zerocopy::{AsBytes, ByteSlice, FromBytes, FromZeroes, Ref, Unaligned};//! use zerocopy::byteorder::network_endian::U16;//! #[derive(FromZeroes, FromBytes, AsBytes, Unaligned)]//! struct UdpHeader {//!     src_port: U16,//!     dst_port: U16,//!     length: U16,//!     checksum: U16,//! struct UdpPacket<B: ByteSlice> {//!     header: Ref<B, UdpHeader>,//!     body: B,//! impl<B: ByteSlice> UdpPacket<B> {//!     fn parse(bytes: B) -> Option<UdpPacket<B>> {//!         let (header, body) = Ref::new_from_prefix(bytes)?;//!         Some(UdpPacket { header, body })//!     fn src_port(&self) -> u16 {//!         self.header.src_port.get()//!     // more getters...// This is a hack to allow zerocopy-derive derives to work in this crate. They// assume that zerocopy is linked as an extern crate, so they access items from// it as `zerocopy::Xxx`. This makes that still work.post_monomorphization_compile_fail_tests// TODO(#252): If we make this pub, come up with a better name.// `pub use` separately here so that we can mark it `#[doc(hidden)]`.// TODO(#29): Remove this or add a doc comment.// Used by `TryFromBytes::is_bit_valid`.polyfillsNonNullExt// For each polyfill, as soon as the corresponding feature is stable, the// polyfill import will be unused because method/function resolution will prefer// the inherent method/function over a trait method/function. Thus, we suppress// the `unused_imports` warning.// See the documentation on `util::polyfills` for more information.POINTER_WIDTH_BITS/// The target pointer width, counted in bits.size_infoSizeInfo/// The layout of a type which might be dynamically-sized./// `DstLayout` describes the layout of sized types, slice types, and "slice/// DSTs" - ie, those that are known by the type system to have a trailing slice/// (as distinguished from `dyn Trait` types - such types *might* have a/// trailing slice type, but the type system isn't aware of it)./// Unlike [`core::alloc::Layout`], `DstLayout` is only used to describe full/// Rust types - ie, those that satisfy the layout requirements outlined by/// [the reference]. Callers may assume that an instance of `DstLayout`/// satisfies any conditions imposed on Rust types by the reference./// If `layout: DstLayout` describes a type, `T`, then it is guaranteed that:/// - `layout.align` is equal to `T`'s alignment/// - If `layout.size_info` is `SizeInfo::Sized { size }`, then `T: Sized` and///   `size_of::<T>() == size`/// - If `layout.size_info` is `SizeInfo::SliceDst(slice_layout)`, then///   - `T` is a slice DST/// - The `size` of an instance of `T` with `elems` trailing slice elements is///   equal to `slice_layout.offset + slice_layout.elem_size * elems` rounded up///   to the nearest multiple of `layout.align`. Any bytes in the range///   `[slice_layout.offset + slice_layout.elem_size * elems, size)` are padding///   and must not be assumed to be initialized./// [the reference]: https://doc.rust-lang.org/reference/type-layout.html_sizeTrailingSliceLayoutSliceDst_offset// The offset of the first byte of the trailing slice field. Note that this// is NOT the same as the minimum size of the type. For example, consider// the following type://   struct Foo {//       a: u16,//       b: u8,//       c: [u8],// In `Foo`, `c` is at byte offset 3. When `c.len() == 0`, `c` is followed// by a padding byte._elem_size// The size of the element type of the trailing slice field.try_to_nonzero_elem_size/// Attempts to create a `SizeInfo` from `Self` in which `elem_size` is a/// `NonZeroUsize`. If `elem_size` is 0, returns `None`._CastType_Prefix_SuffixMIN_ALIGN/// The minimum possible alignment of a type.THEORETICAL_MAX_ALIGN/// The maximum theoretic possible alignment of a type./// For compatibility with future Rust versions, this is defined as the/// maximum power-of-two that fits into a `usize`. See also/// [`DstLayout::CURRENT_MAX_ALIGN`].CURRENT_MAX_ALIGN/// The current, documented max alignment of a type \[1\]./// \[1\] Per <https://doc.rust-lang.org/reference/type-layout.html#the-alignment-modifiers>:///   The alignment value must be a power of two from 1 up to///   2<sup>29</sup>.new_zst/// Constructs a `DstLayout` for a zero-sized type with `repr_align`/// alignment (or 1). If `repr_align` is provided, then it must be a power/// of two./// This function panics if the supplied `repr_align` is not a power of two./// Unsafe code may assume that the contract of this function is satisfied./// Constructs a `DstLayout` which describes `T`./// Unsafe code may assume that `DstLayout` is the correct layout for `T`.for_slice/// Constructs a `DstLayout` which describes `[T]`./// Unsafe code may assume that `DstLayout` is the correct layout for `[T]`./// Like `Layout::extend`, this creates a layout that describes a record/// whose layout consists of `self` followed by `next` that includes the/// necessary inter-field padding, but not any trailing padding./// In order to match the layout of a `#[repr(C)]` struct, this method/// should be invoked for each field in declaration order. To add trailing/// padding, call `DstLayout::pad_to_align` after extending the layout for/// all fields. If `self` corresponds to a type marked with/// `repr(packed(N))`, then `repr_packed` should be set to `Some(N)`,/// otherwise `None`./// This method cannot be used to match the layout of a record with the/// default representation, as that representation is mostly unspecified./// If a (potentially hypothetical) valid `repr(C)` Rust type begins with/// fields whose layout are `self`, and those fields are immediately/// followed by a field whose layout is `field`, then unsafe code may rely/// on `self.extend(field, repr_packed)` producing a layout that correctly/// encompasses those two components./// We make no guarantees to the behavior of this method if these fragments/// cannot appear in a valid Rust type (e.g., the concatenation of the/// layouts would lead to a size larger than `isize::MAX`).pad_to_align/// Like `Layout::pad_to_align`, this routine rounds the size of this layout/// up to the nearest multiple of this type's alignment or `repr_packed`/// (whichever is less). This method leaves DST layouts unchanged, since the/// trailing padding of DSTs is computed at runtime./// should be invoked after the invocations of [`DstLayout::extend`]. If/// `self` corresponds to a type marked with `repr(packed(N))`, then/// `repr_packed` should be set to `Some(N)`, otherwise `None`./// If a (potentially hypothetical) valid `repr(C)` type begins with fields/// whose layout are `self` followed only by zero or more bytes of trailing/// padding (not included in `self`), then unsafe code may rely on/// `self.pad_to_align(repr_packed)` producing a layout that correctly/// encapsulates the layout of that type./// We make no guarantees to the behavior of this method if `self` cannot/// appear in a valid Rust type (e.g., because the addition of trailing/// padding would lead to a size larger than `isize::MAX`).validate_cast_and_convert_metadata/// Validates that a cast is sound from a layout perspective./// Validates that the size and alignment requirements of a type with the/// layout described in `self` would not be violated by performing a/// `cast_type` cast from a pointer with address `addr` which refers to a/// memory region of size `bytes_len`./// If the cast is valid, `validate_cast_and_convert_metadata` returns/// `(elems, split_at)`. If `self` describes a dynamically-sized type, then/// `elems` is the maximum number of trailing slice elements for which a/// cast would be valid (for sized types, `elem` is meaningless and should/// be ignored). `split_at` is the index at which to split the memory region/// in order for the prefix (suffix) to contain the result of the cast, and/// in order for the remaining suffix (prefix) to contain the leftover/// There are three conditions under which a cast can fail:/// - The smallest possible value for the type is larger than the provided///   memory region/// - A prefix cast is requested, and `addr` does not satisfy `self`'s///   alignment requirement/// - A suffix cast is requested, and `addr + bytes_len` does not satisfy///   `self`'s alignment requirement (as a consequence, since all instances///   of the type are a multiple of its alignment, no size for the type will///   result in a starting address which is properly aligned)/// The caller may assume that this implementation is correct, and may rely/// on that assumption for the soundness of their code. In particular, the/// caller may assume that, if `validate_cast_and_convert_metadata` returns/// `Some((elems, split_at))`, then:/// - A pointer to the type (for dynamically sized types, this includes///   `elems` as its pointer metadata) describes an object of size `size <=///   bytes_len`/// - If this is a prefix cast:///   - `addr` satisfies `self`'s alignment///   - `size == split_at`/// - If this is a suffix cast:///   - `split_at == bytes_len - size`///   - `addr + split_at` satisfies `self`'s alignment/// Note that this method does *not* ensure that a pointer constructed from/// its return values will be a valid pointer. In particular, this method/// does not reason about `isize` overflow, which is a requirement of many/// Rust pointer APIs, and may at some point be determined to be a validity/// invariant of pointer types themselves. This should never be a problem so/// long as the arguments to this method are derived from a known-valid/// pointer (e.g., one derived from a safe Rust reference), but it is/// nonetheless the caller's responsibility to justify that pointer/// arithmetic will not overflow based on a safety argument *other than* the/// mere fact that this method returned successfully./// `validate_cast_and_convert_metadata` will panic if `self` describes a/// DST whose trailing slice element is zero-sized./// If `addr + bytes_len` overflows `usize`,/// `validate_cast_and_convert_metadata` may panic, or it may return/// incorrect results. No guarantees are made about when/// `validate_cast_and_convert_metadata` will panic. The caller should not/// rely on `validate_cast_and_convert_metadata` panicking in any particular/// condition, even if `debug_assertions` are enabled.// The `Self: Sized` bound makes it so that `KnownLayout` can still be// object safe. It's not currently object safe thanks to `const LAYOUT`, and// it likely won't be in the future, but there's no reason not to be// forwards-compatible with object safety./// SAFETY: The returned pointer has the same address and provenance as/// `bytes`. If `Self` is a DST, the returned pointer's referent has `elems`/// elements in its trailing slice. If `Self` is sized, `elems` is ignored./// A trait which carries information about a type's layout that is used by the/// internals of this crate./// This trait is not meant for consumption by code outside of this crate. While/// the normal semver stability guarantees apply with respect to which types/// implement this trait and which trait implementations are implied by this/// trait, no semver stability guarantees are made regarding its internals; they/// may change at any time, and code which makes use of them may break./// This trait does not convey any safety guarantees to code outside this crate.// TODO: Remove this once KnownLayout is used by other APIs// SAFETY: `.cast` preserves address and provenance. The returned pointer// refers to an object with `elems` elements by construction.// SAFETY: Delegates safety to `DstLayout::for_slice`.impl_known_layout/// Analyzes whether a type is [`FromZeroes`]./// This derive analyzes, at compile time, whether the annotated type satisfies/// the [safety conditions] of `FromZeroes` and implements `FromZeroes` if it is/// sound to do so. This derive can be applied to structs, enums, and unions;/// e.g.:/// # use zerocopy_derive::FromZeroes;/// #[derive(FromZeroes)]/// struct MyStruct {/// # /*/// # *//// #   Variant0,/// union MyUnion {/// #   variant: u8,/// [safety conditions]: trait@FromZeroes#safety/// # Analysis/// *This section describes, roughly, the analysis performed by this derive to/// determine whether it is sound to implement `FromZeroes` for a given type./// Unless you are modifying the implementation of this derive, or attempting to/// manually implement `FromZeroes` for a type yourself, you don't need to read/// this section.*/// If a type has the following properties, then this derive can implement/// `FromZeroes` for that type:/// - If the type is a struct, all of its fields must be `FromZeroes`./// - If the type is an enum, it must be C-like (meaning that all variants have///   no fields) and it must have a variant with a discriminant of `0`. See [the///   reference] for a description of how discriminant values are chosen./// - The type must not contain any [`UnsafeCell`]s (this is required in order///   for it to be sound to construct a `&[u8]` and a `&T` to the same region of///   memory). The type may contain references or pointers to `UnsafeCell`s so///   long as those values can themselves be initialized from zeroes///   (`FromZeroes` is not currently implemented for, e.g.,///   `Option<&UnsafeCell<_>>`, but it could be one day)./// This analysis is subject to change. Unsafe code may *only* rely on the/// documented [safety conditions] of `FromZeroes`, and must *not* rely on the/// implementation details of this derive./// [the reference]: https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-fieldless-enumerations/// [`UnsafeCell`]: core::cell::UnsafeCell/// ## Why isn't an explicit representation required for structs?/// Neither this derive, nor the [safety conditions] of `FromZeroes`, requires/// that structs are marked with `#[repr(C)]`./// Per the [Rust reference](reference),/// > The representation of a type can change the padding between fields, but/// does not change the layout of the fields themselves./// [reference]: https://doc.rust-lang.org/reference/type-layout.html#representations/// Since the layout of structs only consists of padding bytes and field bytes,/// a struct is soundly `FromZeroes` if:/// 1. its padding is soundly `FromZeroes`, and/// 2. its fields are soundly `FromZeroes`./// The answer to the first question is always yes: padding bytes do not have/// any validity constraints. A [discussion] of this question in the Unsafe Code/// Guidelines Working Group concluded that it would be virtually unimaginable/// for future versions of rustc to add validity constraints to padding bytes./// [discussion]: https://github.com/rust-lang/unsafe-code-guidelines/issues/174/// Whether a struct is soundly `FromZeroes` therefore solely depends on whether/// its fields are `FromZeroes`.// TODO(#146): Document why we don't require an enum to have an explicit `repr`/// Does a given memory range contain a valid instance of `Self`?/// ## Preconditions/// The memory referenced by `candidate` may only be accessed via reads for/// the duration of this method call. This prohibits writes through mutable/// references and through [`UnsafeCell`]s. There may exist immutable/// references to the same memory which contain `UnsafeCell`s so long as:/// - Those `UnsafeCell`s exist at the same byte ranges as `UnsafeCell`s in///   `Self`. This is a bidirectional property: `Self` may not contain///   `UnsafeCell`s where other references to the same memory do not, and///   vice-versa./// - Those `UnsafeCell`s are never used to perform mutation for the///   duration of this method call./// The memory referenced by `candidate` may not be referenced by any/// mutable references even if these references are not used to perform/// mutation./// `candidate` is not required to refer to a valid `Self`. However, it must/// satisfy the requirement that uninitialized bytes may only be present/// where it is possible for them to be present in `Self`. This is a dynamic/// property: if, at a particular byte offset, a valid enum discriminant is/// set, the subsequent bytes may only have uninitialized bytes as/// specificed by the corresponding enum./// Formally, given `len = size_of_val_raw(candidate)`, at every byte/// offset, `b`, in the range `[0, len)`:/// - If, in all instances `s: Self` of length `len`, the byte at offset `b`///   in `s` is initialized, then the byte at offset `b` within `*candidate`///   must be initialized./// - Let `c` be the contents of the byte range `[0, b)` in `*candidate`.///   Let `S` be the subset of valid instances of `Self` of length `len`///   which contain `c` in the offset range `[0, b)`. If, for all instances///   of `s: Self` in `S`, the byte at offset `b` in `s` is initialized,///   then the byte at offset `b` in `*candidate` must be initialized.///   Pragmatically, this means that if `*candidate` is guaranteed to///   contain an enum type at a particular offset, and the enum discriminant///   stored in `*candidate` corresponds to a valid variant of that enum///   type, then it is guaranteed that the appropriate bytes of `*candidate`///   are initialized as defined by that variant's bit validity (although///   note that the variant may contain another enum type, in which case the///   same rules apply depending on the state of its discriminant, and so on///   recursively)./// ## Postconditions/// Unsafe code may assume that, if `is_bit_valid(candidate)` returns true,/// `*candidate` contains a valid `Self`./// `is_bit_valid` may panic. Callers are responsible for ensuring that any/// `unsafe` code remains sound even in the face of `is_bit_valid`/// panicking. (We support user-defined validation routines; so long as/// these routines are not required to be `unsafe`, there is no way to/// ensure that these do not generate panics.)try_from_ref/// Attempts to interpret a byte slice as a `Self`./// `try_from_ref` validates that `bytes` contains a valid `Self`, and that/// it satisfies `Self`'s alignment requirement. If it does, then `bytes` is/// reinterpreted as a `Self`./// Note that Rust's bit validity rules are still being decided. As such,/// there exist types whose bit validity is ambiguous. See the/// `TryFromBytes` docs for a discussion of how these cases are handled.// TODO(#251): In a future in which we distinguish between `FromBytes` and// `RefFromBytes`, this requires `where Self: RefFromBytes` to disallow// interior mutability.// TODO(#5): Finalize name before remove this attribute./// Types whose validity can be checked at runtime, allowing them to be/// conditionally converted from byte slices./// WARNING: Do not implement this trait yourself! Instead, use/// `#[derive(TryFromBytes)]`./// `TryFromBytes` types can safely be deserialized from an untrusted sequence/// of bytes by performing a runtime check that the byte sequence contains a/// valid instance of `Self`./// `TryFromBytes` is ignorant of byte order. For byte order-aware types, see/// the [`byteorder`] module./// # What is a "valid instance"?/// In Rust, each type has *bit validity*, which refers to the set of bit/// patterns which may appear in an instance of that type. It is impossible for/// safe Rust code to produce values which violate bit validity (ie, values/// outside of the "valid" set of bit patterns). If `unsafe` code produces an/// invalid value, this is considered [undefined behavior]./// Rust's bit validity rules are currently being decided, which means that some/// types have three classes of bit patterns: those which are definitely valid,/// and whose validity is documented in the language; those which may or may not/// be considered valid at some point in the future; and those which are/// definitely invalid./// Zerocopy takes a conservative approach, and only considers a bit pattern to/// be valid if its validity is a documenteed guarantee provided by the/// language./// For most use cases, Rust's current guarantees align with programmers'/// intuitions about what ought to be valid. As a result, zerocopy's/// conservatism should not affect most users. One notable exception is unions,/// whose bit validity is very up in the air; zerocopy does not permit/// implementing `TryFromBytes` for any union type./// If you are negatively affected by lack of support for a particular type,/// we encourage you to let us know by [filing an issue][github-repo]./// On its own, `T: TryFromBytes` does not make any guarantees about the layout/// or representation of `T`. It merely provides the ability to perform a/// validity check at runtime via methods like [`try_from_ref`]./// Currently, it is not possible to stably implement `TryFromBytes` other than/// by using `#[derive(TryFromBytes)]`. While there are `#[doc(hidden)]` items/// on this trait that provide well-defined safety invariants, no stability/// guarantees are made with respect to these items. In particular, future/// releases of zerocopy may make backwards-breaking changes to these items,/// including changes that only affect soundness, which may cause code which/// uses those items to silently become unsound./// [undefined behavior]: https://raphlinus.github.io/programming/rust/2018/08/17/undefined-behavior.html/// [github-repo]: https://github.com/google/zerocopy/// [`try_from_ref`]: TryFromBytes::try_from_ref// TODO(#5): Update `try_from_ref` doc link once it exists// The `Self: Sized` bound makes it so that `FromZeroes` is still object// safe./// Overwrites `self` with zeroes./// Sets every byte in `self` to 0. While this is similar to doing `*self =/// Self::new_zeroed()`, it differs in that `zero` does not semantically/// drop the current value and replace it with a new one - it simply/// modifies the bytes of the existing value./// # use zerocopy::FromZeroes;/// # use zerocopy_derive::*;/// struct PacketHeader {///     src_port: [u8; 2],///     dst_port: [u8; 2],///     length: [u8; 2],///     checksum: [u8; 2],/// let mut header = PacketHeader {///     src_port: 100u16.to_be_bytes(),///     dst_port: 200u16.to_be_bytes(),///     length: 300u16.to_be_bytes(),///     checksum: 400u16.to_be_bytes(),/// header.zero();/// assert_eq!(header.src_port, [0, 0]);/// assert_eq!(header.dst_port, [0, 0]);/// assert_eq!(header.length, [0, 0]);/// assert_eq!(header.checksum, [0, 0]);new_zeroed/// Creates an instance of `Self` from zeroed bytes./// let header: PacketHeader = FromZeroes::new_zeroed();/// Types for which a sequence of bytes all set to zero represents a valid/// instance of the type./// Any memory region of the appropriate length which is guaranteed to contain/// only zero bytes can be viewed as any `FromZeroes` type with no runtime/// overhead. This is useful whenever memory is known to be in a zeroed state,/// such memory returned from some allocation routines./// **Do not implement this trait yourself!** Instead, use/// [`#[derive(FromZeroes)]`][derive] (requires the `derive` Cargo feature);/// This derive performs a sophisticated, compile-time safety analysis to/// determine whether a type is `FromZeroes`./// *This section describes what is required in order for `T: FromZeroes`, and/// what unsafe code may assume of such types. If you don't plan on implementing/// `FromZeroes` manually, and you don't plan on writing unsafe code that/// operates on `FromZeroes` types, then you don't need to read this section.*/// If `T: FromZeroes`, then unsafe code may assume that:/// - It is sound to treat any initialized sequence of zero bytes of length///   `size_of::<T>()` as a `T`./// - Given `b: &[u8]` where `b.len() == size_of::<T>()`, `b` is aligned to///   `align_of::<T>()`, and `b` contains only zero bytes, it is sound to///   construct a `t: &T` at the same address as `b`, and it is sound for both///   `b` and `t` to be live at the same time./// If a type is marked as `FromZeroes` which violates this contract, it may/// cause undefined behavior./// `#[derive(FromZeroes)]` only permits [types which satisfy these/// requirements][derive-analysis]./// Analyzes whether a type is [`FromBytes`]./// the [safety conditions] of `FromBytes` and implements `FromBytes` if it is/// # use zerocopy_derive::{FromBytes, FromZeroes};/// #[derive(FromZeroes, FromBytes)]/// #   V00, V01, V02, V03, V04, V05, V06, V07, V08, V09, V0A, V0B, V0C, V0D, V0E,/// #   V0F, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V1A, V1B, V1C, V1D,/// #   V1E, V1F, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V2A, V2B, V2C,/// #   V2D, V2E, V2F, V30, V31, V32, V33, V34, V35, V36, V37, V38, V39, V3A, V3B,/// #   V3C, V3D, V3E, V3F, V40, V41, V42, V43, V44, V45, V46, V47, V48, V49, V4A,/// #   V4B, V4C, V4D, V4E, V4F, V50, V51, V52, V53, V54, V55, V56, V57, V58, V59,/// #   V5A, V5B, V5C, V5D, V5E, V5F, V60, V61, V62, V63, V64, V65, V66, V67, V68,/// #   V69, V6A, V6B, V6C, V6D, V6E, V6F, V70, V71, V72, V73, V74, V75, V76, V77,/// #   V78, V79, V7A, V7B, V7C, V7D, V7E, V7F, V80, V81, V82, V83, V84, V85, V86,/// #   V87, V88, V89, V8A, V8B, V8C, V8D, V8E, V8F, V90, V91, V92, V93, V94, V95,/// #   V96, V97, V98, V99, V9A, V9B, V9C, V9D, V9E, V9F, VA0, VA1, VA2, VA3, VA4,/// #   VA5, VA6, VA7, VA8, VA9, VAA, VAB, VAC, VAD, VAE, VAF, VB0, VB1, VB2, VB3,/// #   VB4, VB5, VB6, VB7, VB8, VB9, VBA, VBB, VBC, VBD, VBE, VBF, VC0, VC1, VC2,/// #   VC3, VC4, VC5, VC6, VC7, VC8, VC9, VCA, VCB, VCC, VCD, VCE, VCF, VD0, VD1,/// #   VD2, VD3, VD4, VD5, VD6, VD7, VD8, VD9, VDA, VDB, VDC, VDD, VDE, VDF, VE0,/// #   VE1, VE2, VE3, VE4, VE5, VE6, VE7, VE8, VE9, VEA, VEB, VEC, VED, VEE, VEF,/// #   VF0, VF1, VF2, VF3, VF4, VF5, VF6, VF7, VF8, VF9, VFA, VFB, VFC, VFD, VFE,/// #   VFF,/// [safety conditions]: trait@FromBytes#safety/// determine whether it is sound to implement `FromBytes` for a given type./// manually implement `FromBytes` for a type yourself, you don't need to read/// `FromBytes` for that type:/// - If the type is a struct, all of its fields must be `FromBytes`./// - If the type is an enum:///   - It must be a C-like enum (meaning that all variants have no fields).///   - It must have a defined representation (`repr`s `C`, `u8`, `u16`, `u32`,///     `u64`, `usize`, `i8`, `i16`, `i32`, `i64`, or `isize`).///   - The maximum number of discriminants must be used (so that every possible///     bit pattern is a valid one). Be very careful when using the `C`,///     `usize`, or `isize` representations, as their size is///     platform-dependent.///   (`FromBytes` is not currently implemented for, e.g., `Option<*const///   UnsafeCell<_>>`, but it could be one day)./// documented [safety conditions] of `FromBytes`, and must *not* rely on the/// Neither this derive, nor the [safety conditions] of `FromBytes`, requires/// a struct is soundly `FromBytes` if:/// 1. its padding is soundly `FromBytes`, and/// 2. its fields are soundly `FromBytes`./// Whether a struct is soundly `FromBytes` therefore solely depends on whether/// its fields are `FromBytes`.// The `Self: Sized` bound makes it so that `FromBytes` is still objectref_from/// Interprets the given `bytes` as a `&Self` without copying./// If `bytes.len() != size_of::<Self>()` or `bytes` is not aligned to/// `align_of::<Self>()`, this returns `None`./// use zerocopy::FromBytes;/// // These bytes encode a `PacketHeader`./// let bytes = [0, 1, 2, 3, 4, 5, 6, 7].as_slice();/// let header = PacketHeader::ref_from(bytes).unwrap();/// assert_eq!(header.src_port, [0, 1]);/// assert_eq!(header.dst_port, [2, 3]);/// assert_eq!(header.length, [4, 5]);/// assert_eq!(header.checksum, [6, 7]);ref_from_prefix/// Interprets the prefix of the given `bytes` as a `&Self` without copying./// `ref_from_prefix` returns a reference to the first `size_of::<Self>()`/// bytes of `bytes`. If `bytes.len() < size_of::<Self>()` or `bytes` is not/// aligned to `align_of::<Self>()`, this returns `None`./// To also access the prefix bytes, use [`Ref::new_from_prefix`]. Then, use/// [`Ref::into_ref`] to get a `&Self` with the same lifetime./// // These are more bytes than are needed to encode a `PacketHeader`./// let bytes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].as_slice();/// let header = PacketHeader::ref_from_prefix(bytes).unwrap();ref_from_suffix/// Interprets the suffix of the given `bytes` as a `&Self` without copying./// `ref_from_suffix` returns a reference to the last `size_of::<Self>()`/// bytes of `bytes`. If `bytes.len() < size_of::<Self>()` or the suffix of/// `bytes` is not aligned to `align_of::<Self>()`, this returns `None`./// To also access the suffix bytes, use [`Ref::new_from_suffix`]. Then, use/// struct PacketTrailer {///     frame_check_sequence: [u8; 4],/// // These are more bytes than are needed to encode a `PacketTrailer`./// let trailer = PacketTrailer::ref_from_suffix(bytes).unwrap();/// assert_eq!(trailer.frame_check_sequence, [6, 7, 8, 9]);mut_from/// Interprets the given `bytes` as a `&mut Self` without copying./// #[derive(AsBytes, FromZeroes, FromBytes)]/// let bytes = &mut [0, 1, 2, 3, 4, 5, 6, 7][..];/// let header = PacketHeader::mut_from(bytes).unwrap();/// header.checksum = [0, 0];/// assert_eq!(bytes, [0, 1, 2, 3, 4, 5, 0, 0]);mut_from_prefix/// Interprets the prefix of the given `bytes` as a `&mut Self` without/// copying./// `mut_from_prefix` returns a reference to the first `size_of::<Self>()`/// [`Ref::into_mut`] to get a `&mut Self` with the same lifetime./// let bytes = &mut [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][..];/// let header = PacketHeader::mut_from_prefix(bytes).unwrap();/// assert_eq!(bytes, [0, 1, 2, 3, 4, 5, 0, 0, 8, 9]);mut_from_suffix/// Interprets the suffix of the given `bytes` as a `&mut Self` without copying./// `mut_from_suffix` returns a reference to the last `size_of::<Self>()`/// To also access the suffix bytes, use [`Ref::new_from_suffix`]. Then,/// use [`Ref::into_mut`] to get a `&mut Self` with the same lifetime./// let trailer = PacketTrailer::mut_from_suffix(bytes).unwrap();/// trailer.frame_check_sequence = [0, 0, 0, 0];/// assert_eq!(bytes, [0, 1, 2, 3, 4, 5, 0, 0, 0, 0]);slice_from/// Interprets the given `bytes` as a `&[Self]` without copying./// If `bytes.len() % size_of::<Self>() != 0` or `bytes` is not aligned to/// If you need to convert a specific number of slice elements, see/// [`slice_from_prefix`](FromBytes::slice_from_prefix) or/// [`slice_from_suffix`](FromBytes::slice_from_suffix)./// If `Self` is a zero-sized type./// # #[derive(Debug, PartialEq, Eq)]/// struct Pixel {///     a: u8,/// // These bytes encode two `Pixel`s./// let pixels = Pixel::slice_from(bytes).unwrap();/// assert_eq!(pixels, &[///     Pixel { r: 0, g: 1, b: 2, a: 3 },///     Pixel { r: 4, g: 5, b: 6, a: 7 },slice_from_prefix/// Interprets the prefix of the given `bytes` as a `&[Self]` with length/// equal to `count` without copying./// This method verifies that `bytes.len() >= size_of::<T>() * count`/// and that `bytes` is aligned to `align_of::<T>()`. It consumes the/// first `size_of::<T>() * count` bytes from `bytes` to construct a/// `&[Self]`, and returns the remaining bytes to the caller. It also/// ensures that `sizeof::<T>() * count` does not overflow a `usize`./// If any of the length, alignment, or overflow checks fail, it returns/// If `T` is a zero-sized type./// // These are more bytes than are needed to encode two `Pixel`s./// let (pixels, rest) = Pixel::slice_from_prefix(bytes, 2).unwrap();/// assert_eq!(rest, &[8, 9]);slice_from_suffix/// Interprets the suffix of the given `bytes` as a `&[Self]` with length/// last `size_of::<T>() * count` bytes from `bytes` to construct a/// `&[Self]`, and returns the preceding bytes to the caller. It also/// let (rest, pixels) = Pixel::slice_from_suffix(bytes, 2).unwrap();/// assert_eq!(rest, &[0, 1]);///     Pixel { r: 2, g: 3, b: 4, a: 5 },///     Pixel { r: 6, g: 7, b: 8, a: 9 },mut_slice_from/// Interprets the given `bytes` as a `&mut [Self]` without copying./// If `bytes.len() % size_of::<T>() != 0` or `bytes` is not aligned to/// `align_of::<T>()`, this returns `None`./// [`mut_slice_from_prefix`](FromBytes::mut_slice_from_prefix) or/// [`mut_slice_from_suffix`](FromBytes::mut_slice_from_suffix)./// let pixels = Pixel::mut_slice_from(bytes).unwrap();/// pixels[1] = Pixel { r: 0, g: 0, b: 0, a: 0 };/// assert_eq!(bytes, [0, 1, 2, 3, 0, 0, 0, 0]);mut_slice_from_prefix/// Interprets the prefix of the given `bytes` as a `&mut [Self]` with length/// let (pixels, rest) = Pixel::mut_slice_from_prefix(bytes, 2).unwrap();/// assert_eq!(bytes, [0, 1, 2, 3, 0, 0, 0, 0, 8, 9]);mut_slice_from_suffix/// Interprets the suffix of the given `bytes` as a `&mut [Self]` with length/// let (rest, pixels) = Pixel::mut_slice_from_suffix(bytes, 2).unwrap();/// Reads a copy of `Self` from `bytes`./// If `bytes.len() != size_of::<Self>()`, `read_from` returns `None`./// let header = PacketHeader::read_from(bytes).unwrap();read_from_prefix/// Reads a copy of `Self` from the prefix of `bytes`./// `read_from_prefix` reads a `Self` from the first `size_of::<Self>()`/// bytes of `bytes`. If `bytes.len() < size_of::<Self>()`, it returns/// let header = PacketHeader::read_from_prefix(bytes).unwrap();read_from_suffix/// Reads a copy of `Self` from the suffix of `bytes`./// `read_from_suffix` reads a `Self` from the last `size_of::<Self>()`/// let trailer = PacketTrailer::read_from_suffix(bytes).unwrap();/// Types for which any bit pattern is valid./// Any memory region of the appropriate length which contains initialized bytes/// can be viewed as any `FromBytes` type with no runtime overhead. This is/// useful for efficiently parsing bytes as structured data./// [`#[derive(FromBytes)]`][derive] (requires the `derive` Cargo feature);/// determine whether a type is `FromBytes`./// *This section describes what is required in order for `T: FromBytes`, and/// `FromBytes` manually, and you don't plan on writing unsafe code that/// operates on `FromBytes` types, then you don't need to read this section.*/// If `T: FromBytes`, then unsafe code may assume that:/// - It is sound to treat any initialized sequence of bytes of length///   `align_of::<T>()` it is sound to construct a `t: &T` at the same address///   as `b`, and it is sound for both `b` and `t` to be live at the same time./// If a type is marked as `FromBytes` which violates this contract, it may/// `#[derive(FromBytes)]` only permits [types which satisfy these/// Analyzes whether a type is [`AsBytes`]./// the [safety conditions] of `AsBytes` and implements `AsBytes` if it is/// # use zerocopy_derive::{AsBytes};/// #[derive(AsBytes)]/// #   Variant,/// [safety conditions]: trait@AsBytes#safety/// # Error Messages/// Due to the way that the custom derive for `AsBytes` is implemented, you may/// get an error like this:/// error[E0277]: the trait bound `HasPadding<Foo, true>: ShouldBe<false>` is not satisfied///   --> lib.rs:23:10///  1 | #[derive(AsBytes)]///    |          ^^^^^^^ the trait `ShouldBe<false>` is not implemented for `HasPadding<Foo, true>`///    = help: the trait `ShouldBe<VALUE>` is implemented for `HasPadding<T, VALUE>`/// This error indicates that the type being annotated has padding bytes, which/// is illegal for `AsBytes` types. Consider reducing the alignment of some/// fields by using types in the [`byteorder`] module, adding explicit struct/// fields where those padding bytes would be, or using `#[repr(packed)]`. See/// the Rust Reference's page on [type layout] for more information/// about type layout and padding./// [type layout]: https://doc.rust-lang.org/reference/type-layout.html/// determine whether it is sound to implement `AsBytes` for a given type./// manually implement `AsBytes` for a type yourself, you don't need to read/// `AsBytes` for that type:/// - If the type is a struct:///   - It must have a defined representation (`repr(C)`, `repr(transparent)`,///     or `repr(packed)`).///   - All of its fields must be `AsBytes`.///   - Its layout must have no padding. This is always true for///     `repr(transparent)` and `repr(packed)`. For `repr(C)`, see the layout///     algorithm described in the [Rust Reference].///   long as those values can themselves be initialized from zeroes (`AsBytes`///   is not currently implemented for, e.g., `Option<&UnsafeCell<_>>`, but it///   could be one day)./// [Rust Reference]: https://doc.rust-lang.org/reference/type-layout.html// The `Self: Sized` bound makes it so that this function doesn't prevent// `AsBytes` from being object safe. Note that other `AsBytes` methods// prevent object safety, but those provide a benefit in exchange for object// safety. If at some point we remove those methods, change their type// signatures, or move them out of this trait so that `AsBytes` is object// safe again, it's important that this function not prevent object safety./// Gets the bytes of this value./// `as_bytes` provides access to the bytes of this value as an immutable/// use zerocopy::AsBytes;/// let header = PacketHeader {///     src_port: [0, 1],///     dst_port: [2, 3],///     length: [4, 5],///     checksum: [6, 7],/// let bytes = header.as_bytes();/// assert_eq!(bytes, [0, 1, 2, 3, 4, 5, 6, 7]);/// Gets the bytes of this value mutably./// `as_bytes_mut` provides access to the bytes of this value as a mutable/// # #[derive(Eq, PartialEq, Debug)]/// let bytes = header.as_bytes_mut();/// bytes.reverse();/// assert_eq!(header, PacketHeader {///     src_port: [7, 6],///     dst_port: [5, 4],///     length: [3, 2],///     checksum: [1, 0],/// Writes a copy of `self` to `bytes`./// If `bytes.len() != size_of_val(self)`, `write_to` returns `None`./// let mut bytes = [0, 0, 0, 0, 0, 0, 0, 0];/// header.write_to(&mut bytes[..]);/// If too many or too few target bytes are provided, `write_to` returns/// `None` and leaves the target bytes unmodified:/// # use zerocopy::AsBytes;/// # let header = u128::MAX;/// let mut excessive_bytes = &mut [0u8; 128][..];/// let write_result = header.write_to(excessive_bytes);/// assert!(write_result.is_none());/// assert_eq!(excessive_bytes, [0u8; 128]);write_to_prefix/// Writes a copy of `self` to the prefix of `bytes`./// `write_to_prefix` writes `self` to the first `size_of_val(self)` bytes/// of `bytes`. If `bytes.len() < size_of_val(self)`, it returns `None`./// let mut bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];/// header.write_to_prefix(&mut bytes[..]);/// assert_eq!(bytes, [0, 1, 2, 3, 4, 5, 6, 7, 0, 0]);/// If insufficient target bytes are provided, `write_to_prefix` returns/// let mut insufficent_bytes = &mut [0, 0][..];/// let write_result = header.write_to_suffix(insufficent_bytes);/// assert_eq!(insufficent_bytes, [0, 0]);write_to_suffix/// Writes a copy of `self` to the suffix of `bytes`./// `write_to_suffix` writes `self` to the last `size_of_val(self)` bytes of/// `bytes`. If `bytes.len() < size_of_val(self)`, it returns `None`./// header.write_to_suffix(&mut bytes[..]);/// assert_eq!(bytes, [0, 0, 0, 1, 2, 3, 4, 5, 6, 7]);/// If insufficient target bytes are provided, `write_to_suffix` returns/// Types that can be viewed as an immutable slice of initialized bytes./// Any `AsBytes` type can be viewed as a slice of initialized bytes of the same/// size. This is useful for efficiently serializing structured data as raw/// [`#[derive(AsBytes)]`][derive] (requires the `derive` Cargo feature); e.g.:/// # use zerocopy_derive::AsBytes;/// determine whether a type is `AsBytes`. See the [derive/// documentation][derive] for guidance on how to interpret error messages/// produced by the derive's analysis./// *This section describes what is required in order for `T: AsBytes`, and/// `AsBytes` manually, and you don't plan on writing unsafe code that/// operates on `AsBytes` types, then you don't need to read this section.*/// If `T: AsBytes`, then unsafe code may assume that:/// - It is sound to treat any `t: T` as an immutable `[u8]` of length///   `size_of_val(t)`./// - Given `t: &T`, it is sound to construct a `b: &[u8]` where `b.len() ==///   size_of_val(t)` at the same address as `t`, and it is sound for both `b`///   and `t` to be live at the same time./// If a type is marked as `AsBytes` which violates this contract, it may cause/// `#[derive(AsBytes)]` only permits [types which satisfy these// The `Self: Sized` bound makes it so that `Unaligned` is still object/// Types with no alignment requirement./// `#[derive(Unaligned)]` (requires the `derive` Cargo feature)./// If `T: Unaligned`, then `align_of::<T>() == 1`./// *This section describes what is required in order for `T: Unaligned`, and/// what unsafe code may assume of such types. `#[derive(Unaligned)]` only/// permits types which satisfy these requirements. If you don't plan on/// implementing `Unaligned` manually, and you don't plan on writing unsafe code/// that operates on `Unaligned` types, then you don't need to read this/// section.*/// If `T: Unaligned`, then unsafe code may assume that it is sound to produce a/// reference to `T` at any memory location regardless of alignment. If a type/// is marked as `Unaligned` which violates this contract, it may causesimd_arch_mod/// Defines a module which implements `TryFromBytes`, `FromZeroes`,/// `FromBytes`, and `AsBytes` for a set of types from a module in/// `core::arch`./// `$arch` is both the name of the defined module and the name of the/// module in `core::arch`, and `$typ` is the list of items from that module/// to implement `FromZeroes`, `FromBytes`, and `AsBytes` for.// `allow(unused_macros)` is needed because some// target/feature combinations don't emit any impls// and thus don't use this macro.// SIMD support// Per the Unsafe Code Guidelines Reference [1]://   Packed SIMD vector types are `repr(simd)` homogeneous tuple-structs//   containing `N` elements of type `T` where `N` is a power-of-two and the//   size and alignment requirements of `T` are equal://   ```rust//   #[repr(simd)]//   struct Vector<T, N>(T_0, ..., T_(N - 1));//   ```//   ...//   The size of `Vector` is `N * size_of::<T>()` and its alignment is an//   implementation-defined function of `T` and `N` greater than or equal to//   `align_of::<T>()`.//   Vector elements are laid out in source field order, enabling random access//   to vector elements by reinterpreting the vector as an array://   union U {//      vec: Vector<T, N>,//      arr: [T; N]//   assert_eq!(size_of::<Vector<T, N>>(), size_of::<[T; N]>());//   assert!(align_of::<Vector<T, N>>() >= align_of::<[T; N]>());//     let u = U { vec: Vector<T, N>(t_0, ..., t_(N - 1)) };//     assert_eq!(u.vec.0, u.arr[0]);//     assert_eq!(u.vec.(N - 1), u.arr[N - 1]);// Given this background, we can observe that:// - The size and bit pattern requirements of a SIMD type are equivalent to the//   equivalent array type. Thus, for any SIMD type whose primitive `T` is//   `TryFromBytes`, `FromZeroes`, `FromBytes`, or `AsBytes`, that SIMD type is//   also `TryFromBytes`, `FromZeroes`, `FromBytes`, or `AsBytes` respectively.// - Since no upper bound is placed on the alignment, no SIMD type can be//   guaranteed to be `Unaligned`.// Also per [1]://   This chapter represents the consensus from issue #38. The statements in//   here are not (yet) "guaranteed" not to change until an RFC ratifies them.// See issue #38 [2]. While this behavior is not technically guaranteed, the// likelihood that the behavior will change such that SIMD types are no longer// `TryFromBytes`, `FromZeroes`, `FromBytes`, or `AsBytes` is next to zero, as// that would defeat the entire purpose of SIMD types. Nonetheless, we put this// behavior behind the `simd` Cargo feature, which requires consumers to opt// into this stability hazard.// [1] https://rust-lang.github.io/unsafe-code-guidelines/layout/packed-simd-vectors.html// [2] https://github.com/rust-lang/unsafe-code-guidelines/issues/38/// Safely transmutes a value of one type to a value of another type of the same/// The expression `$e` must have a concrete type, `T`, which implements/// `AsBytes`. The `transmute!` expression must also have a concrete type, `U`/// (`U` is inferred from the calling context), and `U` must implement/// `FromBytes`./// Note that the `T` produced by the expression `$e` will *not* be dropped./// Semantically, its bits will be copied into a new value of type `U`, the/// original `T` will be forgotten, and the value of type `U` will be returned./// # use zerocopy::transmute;/// let one_dimensional: [u8; 8] = [0, 1, 2, 3, 4, 5, 6, 7];/// let two_dimensional: [[u8; 4]; 2] = transmute!(one_dimensional);/// assert_eq!(two_dimensional, [[0, 1, 2, 3], [4, 5, 6, 7]]);transmute_ref/// Safely transmutes a mutable or immutable reference of one type to an/// immutable reference of another type of the same size./// The expression `$e` must have a concrete type, `&T` or `&mut T`, where `T:/// Sized + AsBytes`. The `transmute_ref!` expression must also have a concrete/// type, `&U` (`U` is inferred from the calling context), where `U: Sized +/// FromBytes`. It must be the case that `align_of::<T>() >= align_of::<U>()`./// The lifetime of the input type, `&T` or `&mut T`, must be the same as or/// outlive the lifetime of the output type, `&U`./// # use zerocopy::transmute_ref;/// let two_dimensional: &[[u8; 4]; 2] = transmute_ref!(&one_dimensional);/// assert_eq!(two_dimensional, &[[0, 1, 2, 3], [4, 5, 6, 7]]);/// # Alignment increase error message/// Because of limitations on macros, the error message generated when/// `transmute_ref!` is used to transmute from a type of lower alignment to a/// type of higher alignment is somewhat confusing. For example, the following/// code:/// const INCREASE_ALIGNMENT: &u16 = zerocopy::transmute_ref!(&[0u8; 2]);/// ...generates the following error:/// error[E0512]: cannot transmute between types of different sizes, or dependently-sized types///  --> src/lib.rs:1524:34/// 5 | const INCREASE_ALIGNMENT: &u16 = zerocopy::transmute_ref!(&[0u8; 2]);///   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^///   = note: source type: `AlignOf<[u8; 2]>` (8 bits)///   = note: target type: `MaxAlignsOf<[u8; 2], u16>` (16 bits)///   = note: this error originates in the macro `$crate::assert_align_gt_eq` which comes from the expansion of the macro `transmute_ref` (in Nightly builds, run with -Z macro-backtrace for more info)/// This is saying that `max(align_of::<T>(), align_of::<U>()) !=/// align_of::<T>()`, which is equivalent to `align_of::<T>() </// align_of::<U>()`.transmute_mut/// Safely transmutes a mutable reference of one type to an mutable reference of/// another type of the same size./// The expression `$e` must have a concrete type, `&mut T`, where `T: Sized +/// AsBytes`. The `transmute_mut!` expression must also have a concrete type,/// `&mut U` (`U` is inferred from the calling context), where `U: Sized +/// The lifetime of the input type, `&mut T`, must be the same as or outlive the/// lifetime of the output type, `&mut U`./// # use zerocopy::transmute_mut;/// let mut one_dimensional: [u8; 8] = [0, 1, 2, 3, 4, 5, 6, 7];/// let two_dimensional: &mut [[u8; 4]; 2] = transmute_mut!(&mut one_dimensional);/// two_dimensional.reverse();/// assert_eq!(one_dimensional, [4, 5, 6, 7, 0, 1, 2, 3]);/// `transmute_mut!` is used to transmute from a type of lower alignment to a/// const INCREASE_ALIGNMENT: &mut u16 = zerocopy::transmute_mut!(&mut [0u8; 2]);/// 5 | const INCREASE_ALIGNMENT: &mut u16 = zerocopy::transmute_mut!(&mut [0u8; 2]);///   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^///   = note: this error originates in the macro `$crate::assert_align_gt_eq` which comes from the expansion of the macro `transmute_mut` (in Nightly builds, run with -Z macro-backtrace for more info)include_value/// Includes a file and safely transmutes it to a value of an arbitrary type./// The file will be included as a byte array, `[u8; N]`, which will be/// transmuted to another type, `T`. `T` is inferred from the calling context,/// and must implement [`FromBytes`]./// The file is located relative to the current file (similarly to how modules/// are found). The provided path is interpreted in a platform-specific way at/// compile time. So, for instance, an invocation with a Windows path containing/// backslashes `\` would not compile correctly on Unix./// `include_value!` is ignorant of byte order. For byte order-aware types, see/// Assume there are two files in the same directory with the following/// contents:/// File `data` (no trailing newline):/// abcd/// File `main.rs`:/// use zerocopy::include_value;/// # macro_rules! include_value {/// # ($file:expr) => { zerocopy::include_value!(concat!("../testdata/include_value/", $file)) };///     let as_u32: u32 = include_value!("data");///     assert_eq!(as_u32, u32::from_ne_bytes([b'a', b'b', b'c', b'd']));///     let as_i32: i32 = include_value!("data");///     assert_eq!(as_i32, i32::from_ne_bytes([b'a', b'b', b'c', b'd']));/// A typed reference derived from a byte slice./// A `Ref<B, T>` is a reference to a `T` which is stored in a byte slice, `B`./// Unlike a native reference (`&T` or `&mut T`), `Ref<B, T>` has the same/// mutability as the byte slice it was constructed from (`B`)./// `Ref` can be used to treat a sequence of bytes as a structured type, and to/// read and write the fields of that type as if the byte slice reference were/// simply a reference to that type./// # #[cfg(feature = "derive")] { // This example uses derives, and won't compile without them/// use zerocopy::{AsBytes, ByteSlice, ByteSliceMut, FromBytes, FromZeroes, Ref, Unaligned};/// #[derive(FromZeroes, FromBytes, AsBytes, Unaligned)]/// struct UdpHeader {/// struct UdpPacket<B> {///     header: Ref<B, UdpHeader>,///     body: B,/// impl<B: ByteSlice> UdpPacket<B> {///     pub fn parse(bytes: B) -> Option<UdpPacket<B>> {///         let (header, body) = Ref::new_unaligned_from_prefix(bytes)?;///         Some(UdpPacket { header, body })///     pub fn get_src_port(&self) -> [u8; 2] {///         self.header.src_port/// impl<B: ByteSliceMut> UdpPacket<B> {///     pub fn set_src_port(&mut self, src_port: [u8; 2]) {///         self.header.src_port = src_port;LayoutVerified/// Deprecated: prefer [`Ref`] instead./// Constructs a new `Ref`./// `new` verifies that `bytes.len() == size_of::<T>()` and that `bytes` is/// aligned to `align_of::<T>()`, and constructs a new `Ref`. If either of/// these checks fail, it returns `None`.new_from_prefix/// Constructs a new `Ref` from the prefix of a byte slice./// `new_from_prefix` verifies that `bytes.len() >= size_of::<T>()` and that/// `bytes` is aligned to `align_of::<T>()`. It consumes the first/// `size_of::<T>()` bytes from `bytes` to construct a `Ref`, and returns/// the remaining bytes to the caller. If either the length or alignment/// checks fail, it returns `None`.new_from_suffix/// Constructs a new `Ref` from the suffix of a byte slice./// `new_from_suffix` verifies that `bytes.len() >= size_of::<T>()` and that/// the last `size_of::<T>()` bytes of `bytes` are aligned to/// `align_of::<T>()`. It consumes the last `size_of::<T>()` bytes from/// `bytes` to construct a `Ref`, and returns the preceding bytes to the/// caller. If either the length or alignment checks fail, it returns/// Constructs a new `Ref` of a slice type./// `new_slice` verifies that `bytes.len()` is a multiple of/// `size_of::<T>()` and that `bytes` is aligned to `align_of::<T>()`, and/// constructs a new `Ref`. If either of these checks fail, it returns/// `new_slice` panics if `T` is a zero-sized type.new_slice_from_prefix/// Constructs a new `Ref` of a slice type from the prefix of a byte slice./// `new_slice_from_prefix` verifies that `bytes.len() >= size_of::<T>() */// count` and that `bytes` is aligned to `align_of::<T>()`. It consumes the/// first `size_of::<T>() * count` bytes from `bytes` to construct a `Ref`,/// and returns the remaining bytes to the caller. It also ensures that/// `sizeof::<T>() * count` does not overflow a `usize`. If any of the/// length, alignment, or overflow checks fail, it returns `None`./// `new_slice_from_prefix` panics if `T` is a zero-sized type.new_slice_from_suffix/// Constructs a new `Ref` of a slice type from the suffix of a byte slice./// `new_slice_from_suffix` verifies that `bytes.len() >= size_of::<T>() */// last `size_of::<T>() * count` bytes from `bytes` to construct a `Ref`,/// and returns the preceding bytes to the caller. It also ensures that/// `new_slice_from_suffix` panics if `T` is a zero-sized type.ByteSliceMutmap_zeroedmap_prefix_tuple_zeroedmap_suffix_tuple_zeroed/// Constructs a new `Ref` after zeroing the bytes./// `new_zeroed` verifies that `bytes.len() == size_of::<T>()` and that/// `bytes` is aligned to `align_of::<T>()`, and constructs a new `Ref`. If/// either of these checks fail, it returns `None`./// If the checks succeed, then `bytes` will be initialized to zero. This/// can be useful when re-using buffers to ensure that sensitive data/// previously stored in the buffer is not leaked.new_from_prefix_zeroed/// Constructs a new `Ref` from the prefix of a byte slice, zeroing the/// `new_from_prefix_zeroed` verifies that `bytes.len() >= size_of::<T>()`/// and that `bytes` is aligned to `align_of::<T>()`. It consumes the first/// If the checks succeed, then the prefix which is consumed will be/// initialized to zero. This can be useful when re-using buffers to ensure/// that sensitive data previously stored in the buffer is not leaked.new_from_suffix_zeroed/// Constructs a new `Ref` from the suffix of a byte slice, zeroing the/// `new_from_suffix_zeroed` verifies that `bytes.len() >= size_of::<T>()`/// and that the last `size_of::<T>()` bytes of `bytes` are aligned to/// If the checks succeed, then the suffix which is consumed will benew_slice_zeroed/// Constructs a new `Ref` of a slice type after zeroing the bytes./// `new_slice_zeroed` verifies that `bytes.len()` is a multiple ofnew_slice_from_prefix_zeroed/// Constructs a new `Ref` of a slice type from the prefix of a byte slice,/// after zeroing the bytes./// `new_slice_from_prefix_zeroed` panics if `T` is a zero-sized type.new_slice_from_suffix_zeroed/// If the checks succeed, then the consumed suffix will be initialized to/// zero. This can be useful when re-using buffers to ensure that sensitive/// data previously stored in the buffer is not leaked./// `new_slice_from_suffix_zeroed` panics if `T` is a zero-sized type.new_unaligned/// Constructs a new `Ref` for a type with no alignment requirement./// `new_unaligned` verifies that `bytes.len() == size_of::<T>()` and/// constructs a new `Ref`. If the check fails, it returns `None`.new_unaligned_from_prefix/// Constructs a new `Ref` from the prefix of a byte slice for a type with/// no alignment requirement./// `new_unaligned_from_prefix` verifies that `bytes.len() >=/// size_of::<T>()`. It consumes the first `size_of::<T>()` bytes from/// `bytes` to construct a `Ref`, and returns the remaining bytes to the/// caller. If the length check fails, it returns `None`.new_unaligned_from_suffix/// Constructs a new `Ref` from the suffix of a byte slice for a type with/// `new_unaligned_from_suffix` verifies that `bytes.len() >=/// size_of::<T>()`. It consumes the last `size_of::<T>()` bytes fromnew_slice_unaligned/// Constructs a new `Ref` of a slice type with no alignment requirement./// `new_slice_unaligned` verifies that `bytes.len()` is a multiple of/// `size_of::<T>()` and constructs a new `Ref`. If the check fails, itnew_slice_unaligned_from_prefix/// Constructs a new `Ref` of a slice type with no alignment requirement/// from the prefix of a byte slice./// count`. It consumes the first `size_of::<T>() * count` bytes from/// caller. It also ensures that `sizeof::<T>() * count` does not overflow a/// `usize`. If either the length, or overflow checks fail, it returns/// `new_slice_unaligned_from_prefix` panics if `T` is a zero-sized type.new_slice_unaligned_from_suffix/// from the suffix of a byte slice./// count`. It consumes the last `size_of::<T>() * count` bytes from `bytes`/// to construct a `Ref`, and returns the remaining bytes to the caller. It/// also ensures that `sizeof::<T>() * count` does not overflow a `usize`./// If either the length, or overflow checks fail, it returns `None`./// `new_slice_unaligned_from_suffix` panics if `T` is a zero-sized type.new_unaligned_zeroed/// Constructs a new `Ref` for a type with no alignment requirement, zeroing/// `new_unaligned_zeroed` verifies that `bytes.len() == size_of::<T>()` and/// If the check succeeds, then `bytes` will be initialized to zero. Thisnew_unaligned_from_prefix_zeroed/// no alignment requirement, zeroing the prefix./// `new_unaligned_from_prefix_zeroed` verifies that `bytes.len() >=/// If the check succeeds, then the prefix which is consumed will benew_unaligned_from_suffix_zeroed/// no alignment requirement, zeroing the suffix./// `new_unaligned_from_suffix_zeroed` verifies that `bytes.len() >=/// If the check succeeds, then the suffix which is consumed will benew_slice_unaligned_zeroed/// Constructs a new `Ref` for a slice type with no alignment requirement,/// zeroing the bytes./// `new_slice_unaligned_zeroed` verifies that `bytes.len()` is a multiple/// of `size_of::<T>()` and constructs a new `Ref`. If the check fails, itnew_slice_unaligned_from_prefix_zeroed/// from the prefix of a byte slice, after zeroing the bytes./// If the checks succeed, then the prefix will be initialized to zero. This/// `new_slice_unaligned_from_prefix_zeroed` panics if `T` is a zero-sizednew_slice_unaligned_from_suffix_zeroed/// from the suffix of a byte slice, after zeroing the bytes./// If the checks succeed, then the suffix will be initialized to zero. This/// `new_slice_unaligned_from_suffix_zeroed` panics if `T` is a zero-sized/// Converts this `Ref` into a reference./// `into_ref` consumes the `Ref`, and returns a reference to `T`./// Converts this `Ref` into a mutable reference./// `into_mut` consumes the `Ref`, and returns a mutable reference to `T`./// Converts this `Ref` into a slice reference./// `into_slice` consumes the `Ref`, and returns a reference to `[T]`.into_mut_slice/// Converts this `Ref` into a mutable slice reference./// `into_mut_slice` consumes the `Ref`, and returns a mutable reference to/// `[T]`.deref_helper/// Creates an immutable reference to `T` with a specific lifetime./// The type bounds on this method guarantee that it is safe to create an/// immutable reference to `T` from `self`. However, since the lifetime `'a`/// is not required to be shorter than the lifetime of the reference to/// `self`, the caller must guarantee that the lifetime `'a` is valid for/// this reference. In particular, the referent must exist for all of `'a`,/// and no mutable references to the same memory may be constructed during/// `'a`.deref_mut_helper/// Creates a mutable reference to `T` with a specific lifetime./// The type bounds on this method guarantee that it is safe to create a/// mutable reference to `T` from `self`. However, since the lifetime `'a`/// and no other references - mutable or immutable - to the same memory may/// be constructed during `'a`.deref_slice_helper/// Creates an immutable reference to `[T]` with a specific lifetime./// `deref_slice_helper` has the same safety requirements as `deref_helper`.deref_mut_slice_helper/// Creates a mutable reference to `[T]` with a specific lifetime./// `deref_mut_slice_helper` has the same safety requirements as/// `deref_mut_helper`./// Gets the underlying bytes./// Gets the underlying bytes mutably./// Reads a copy of `T`./// Writes the bytes of `t` and then forgets `t`.ByteSliceSealedINTO_REF_INTO_MUT_ARE_SOUND/// Are the [`Ref::into_ref`] and [`Ref::into_mut`] methods sound when used/// with `Self`? If not, evaluating this constant must panic at compile/// This exists to work around #716 on versions of zerocopy prior to 0.8./// This may only be set to true if the following holds: Given the/// - `Self: 'a`/// - `bytes: Self`/// - `let ptr = bytes.as_ptr()`/// ...then:/// - Using `ptr` to read the memory previously addressed by `bytes` is///   sound for `'a` even after `bytes` has been dropped./// - If `Self: ByteSliceMut`, using `ptr` to write the memory previously///   addressed by `bytes` is sound for `'a` even after `bytes` has been///   dropped./// Gets a raw pointer to the first byte in the slice./// Splits the slice at the midpoint./// `x.split_at(mid)` returns `x[..mid]` and `x[mid..]`./// `x.split_at(mid)` panics if `mid > x.len()`.// TODO(fxbug.dev/99068)/// A mutable or immutable reference to a byte slice./// `ByteSlice` abstracts over the mutability of a byte slice reference, and is/// implemented for various special reference types such as `Ref<[u8]>` and/// `RefMut<[u8]>`./// Note that, while it would be technically possible, `ByteSlice` is not/// implemented for [`Vec<u8>`], as the only way to implement the [`split_at`]/// method would involve reallocation, and `split_at` must be a very cheap/// operation in order for the utilities in this crate to perform as designed./// [`split_at`]: crate::ByteSlice::split_at// It may seem overkill to go to this length to ensure that this doc link never// breaks. We do this because it simplifies CI - it means that generating docs// always succeeds, so we don't need special logic to only generate docs under// certain features./// Gets a mutable raw pointer to the first byte in the slice./// A mutable reference to a byte slice./// `ByteSliceMut` abstracts over various ways of storing a mutable reference to/// a byte slice, and is implemented for various special reference types such as// SAFETY: If `&'b [u8]: 'a`, then the underlying memory is treated as// borrowed immutably for `'a` even if the slice itself is dropped.// TODO(#429): Add a "SAFETY" comment and remove this `allow`.// SAFETY: If `&'b mut [u8]: 'a`, then the underlying memory is treated as// borrowed mutably for `'a` even if the slice itself is dropped.// An unsized type.// This is used to test the custom derives of our traits. The `[u8]` type// gets a hand-rolled impl, so it doesn't exercise our custom derives.test_dst_layout_extend_sized_with_sized/// Tests of when a sized `DstLayout` is extended with a sized field.test_dst_layout_extend_sized_with_dst/// Tests of when a sized `DstLayout` is extended with a DST field.test_dst_layout_pad_to_align_with_sized/// Tests that calling `pad_to_align` on a sized `DstLayout` adds the/// expected amount of trailing padding.test_dst_layout_pad_to_align_with_dst/// Tests that calling `pad_to_align` on a DST `DstLayout` is a no-op.testvalidate_cast_and_convert_metadata// This test takes a long time when running under Miri, so we skip it in// that case. This is acceptable because this is a logic test that doesn't// attempt to expose UB.test_known_layouttest_known_layout_derivetest_object_safetytest_from_zeroes_onlytest_read_writetest_transmutetest_transmute_reftest_transmute_muttest_macros_evaluate_args_oncetest_include_valuetest_addresstest_new_helperAU64// Verify that values written to a `Ref` are properly shared between the// typed and untyped representations, that reads via `deref` and `read`// behave the same, and that writes via `deref_mut` and `write` behave the// same.test_new_helper_slice// typed and untyped representations; pass a value with `typed_len` `AU64`s// backed by an array of `typed_len * 8` bytes.test_new_helper_unalignedtest_new_helper_slice_unaligned// typed and untyped representations; pass a value with `len` `u8`s backed// by an array of `len` bytes.test_new_aligned_sizedtest_new_unaligned_sizedtest_new_oversizedtest_new_unaligned_oversizedtest_ref_from_mut_fromtest_ref_from_mut_from_errortest_new_errorzst_testtest_zst_panics// Tests for ensuring that, if a ZST is passed into a slice-like function,// we always panic. Since these tests need to be separate per-function, and// they tend to take up a lot of space, we generate them using a macro in a// submodule instead. The submodule ensures that we can just re-use the name// of the function under test for the name of the test itself.test_as_bytes_methodstest_display_debugtest_netest_new_zeroedtest_transparent_packed_generic_structtest_impls// Copyright 2018 The Fuchsia Authors// Licensed under the 2-Clause BSD License <LICENSE-BSD or// https://opensource.org/license/bsd-2-clause>, Apache License, Version 2.0// After updating the following doc comment, make sure to run the following// command to update `README.md` based on its contents://   ./generate-readme.sh > README.md//! *<span style="font-size: 100%; color:grey;">Want to help improve zerocopy?//! Fill out our [user survey][user-survey]!</span>*//! ***<span style="font-size: 140%">Fast, safe, <span//! style="color:red;">compile error</span>. Pick two.</span>***//! Zerocopy makes zero-cost memory manipulation effortless. We write `unsafe`//! so you don't have to.//! Zerocopy provides four core marker traits, each of which can be derived//! (e.g., `#[derive(FromZeroes)]`)://! - [`FromZeroes`] indicates that a sequence of zero bytes represents a valid//!   instance of a type//! - [`FromBytes`] indicates that a type may safely be converted from an//!   arbitrary byte sequence//! - [`AsBytes`] indicates that a type may safely be converted *to* a byte//!   sequence//! - [`Unaligned`] indicates that a type's alignment requirement is 1//! Types which implement a subset of these traits can then be converted to/from//! byte sequences with little to no runtime overhead.//! Zerocopy also provides byte-order aware integer types that support these//! conversions; see the [`byteorder`] module. These types are especially useful//! for network parsing.//! [user-survey]: https://docs.google.com/forms/d/e/1FAIpQLSdzBNTN9tzwsmtyZxRFNL02K36IWCdHWW2ZBckyQS2xiO3i8Q/viewform?usp=published_options//! - **`alloc`**   //!   By default, `zerocopy` is `no_std`. When the `alloc` feature is enabled,//!   the `alloc` crate is added as a dependency, and some allocation-related//!   functionality is added.//! - **`byteorder`** (enabled by default)   //!   Adds the [`byteorder`] module and a dependency on the `byteorder` crate.//!   The `byteorder` module provides byte order-aware equivalents of the//!   multi-byte primitive numerical types. Unlike their primitive equivalents,//!   the types in this module have no alignment requirement and support byte//!   order conversions. This can be useful in handling file formats, network//!   packet layouts, etc which don't provide alignment guarantees and which may//!   use a byte order different from that of the execution platform.//! - **`derive`**   //!   Provides derives for the core marker traits via the `zerocopy-derive`//!   crate. These derives are re-exported from `zerocopy`, so it is not//!   necessary to depend on `zerocopy-derive` directly.   //!   However, you may experience better compile times if you instead directly//!   depend on both `zerocopy` and `zerocopy-derive` in your `Cargo.toml`,//!   since doing so will allow Rust to compile these crates in parallel. To do//!   so, do *not* enable the `derive` feature, and list both dependencies in//!   your `Cargo.toml` with the same leading non-zero version number; e.g://!   zerocopy = "0.X"//!   zerocopy-derive = "0.X"//! - **`simd`**   //!   When the `simd` feature is enabled, `FromZeroes`, `FromBytes`, and//!   `AsBytes` impls are emitted for all stable SIMD types which exist on the//!   target platform. Note that the layout of SIMD types is not yet stabilized,//!   so these impls may be removed in the future if layout changes make them//!   invalid. For more information, see the Unsafe Code Guidelines Reference//!   page on the [layout of packed SIMD vectors][simd-layout].//! - **`simd-nightly`**   //!   Enables the `simd` feature and adds support for SIMD types which are only//!   available on nightly. Since these types are unstable, support for any type//!   may be removed at any point in the future.//! [simd-layout]: https://rust-lang.github.io/unsafe-code-guidelines/layout/packed-simd-vectors.html//! # Security Ethos//! Zerocopy is expressly designed for use in security-critical contexts. We//! strive to ensure that that zerocopy code is sound under Rust's current//! memory model, and *any future memory model*. We ensure this by://! - **...not 'guessing' about Rust's semantics.**   //!   We annotate `unsafe` code with a precise rationale for its soundness that//!   cites a relevant section of Rust's official documentation. When Rust's//!   documented semantics are unclear, we work with the Rust Operational//!   Semantics Team to clarify Rust's documentation.//! - **...rigorously testing our implementation.**   //!   We run tests using [Miri], ensuring that zerocopy is sound across a wide//!   array of supported target platforms of varying endianness and pointer//!   width, and across both current and experimental memory models of Rust.//! - **...formally proving the correctness of our implementation.**   //!   We apply formal verification tools like [Kani][kani] to prove zerocopy's//!   correctness.//! For more information, see our full [soundness policy].//! [Miri]: https://github.com/rust-lang/miri//! [Kani]: https://github.com/model-checking/kani//! [soundness policy]: https://github.com/google/zerocopy/blob/main/POLICIES.md#soundness//! # Relationship to Project Safe Transmute//! [Project Safe Transmute] is an official initiative of the Rust Project to//! develop language-level support for safer transmutation. The Project consults//! with crates like zerocopy to identify aspects of safer transmutation that//! would benefit from compiler support, and has developed an [experimental,//! compiler-supported analysis][mcp-transmutability] which determines whether,//! for a given type, any value of that type may be soundly transmuted into//! another type. Once this functionality is sufficiently mature, zerocopy//! intends to replace its internal transmutability analysis (implemented by our//! custom derives) with the compiler-supported one. This change will likely be//! an implementation detail that is invisible to zerocopy's users.//! Project Safe Transmute will not replace the need for most of zerocopy's//! higher-level abstractions. The experimental compiler analysis is a tool for//! checking the soundness of `unsafe` code, not a tool to avoid writing//! `unsafe` code altogether. For the foreseeable future, crates like zerocopy//! will still be required in order to provide higher-level abstractions on top//! of the building block provided by Project Safe Transmute.//! [Project Safe Transmute]: https://rust-lang.github.io/rfcs/2835-project-safe-transmute.html//! [mcp-transmutability]: https://github.com/rust-lang/compiler-team/issues/411//! # MSRV//! See our [MSRV policy].//! [MSRV policy]: https://github.com/google/zerocopy/blob/main/POLICIES.md#msrv//! # Changelog//! Zerocopy uses [GitHub Releases].//! [GitHub Releases]: https://github.com/google/zerocopy/releases// Sometimes we want to use lints which were added after our MSRV.// `unknown_lints` is `warn` by default and we deny warnings in CI, so without// this attribute, any unknown lint would cause a CI failure when testing with// our MSRV.// TODO(#1201): Remove `unexpected_cfgs`// In test code, it makes sense to weight more heavily towards concise, readable// code over correct or debuggable code.// ByteSlice and ByteSliceMut abstract over [u8] references (&[u8], &mut [u8],// Ref<[u8]>, RefMut<[u8]>, etc). We rely on various behaviors of these// references such as that a given reference will never changes its length// between calls to deref() or deref_mut(), and that split_at() works as// expected. If ByteSlice or ByteSliceMut were not sealed, consumers could// implement them in a way that violated these behaviors, and would break our// unsafe code. Thus, we seal them and implement it only for known-good// reference types. For the same reason, they're unsafe traits.ShouldBe/// A compile-time check that should be one particular value.HasPadding/// A struct for checking whether `T` contains padding.// This field ensures that:// - The size is always at least 1 (the minimum possible alignment).// - If the alignment is greater than 1, Rust has to round up to the next//   multiple of it in order to make sure that `Align`'s size is a multiple//   of that alignment. Without this field, its size could be 0, which is a//   valid multiple of any alignment._aAlignOf/// A type whose size is equal to `align_of::<T>()`.into_t// Make `missing_inline_in_public_items` happy.MaxAlignsOf/// A type whose size is equal to `max(align_of::<T>(), align_of::<U>())`._64K/// Does the struct type `$t` have padding?/// `$ts` is the list of the type of every field in `$t`. `$t` must be a/// struct type, or else `struct_has_padding!`'s result may be meaningless./// Note that `struct_has_padding!`'s results are independent of `repr` since/// they only consider the size of the type and the sizes of the fields./// Whatever the repr, the size of the type already takes into account any/// padding that the compiler has decided to add. Structs with well-defined/// representations (such as `repr(C)`) can use this macro to check for padding./// Note that while this may yield some consistent value for some `repr(Rust)`/// structs, it is not guaranteed across platforms or compilations.// `#[macro_export]` bypasses this module's `#[doc(hidden)]`.union_has_padding/// Does the union type `$t` have padding?/// union type, or else `union_has_padding!`'s result may be meaningless./// Note that `union_has_padding!`'s results are independent of `repr` since/// padding that the compiler has decided to add. Unions with well-defined/// unions, it is not guaranteed across platforms or compilations.assert_align_gt_eq/// Does `t` have alignment greater than or equal to `u`?  If not, this macro/// produces a compile error. It must be invoked in a dead codepath. This is/// used in `transmute_ref!` and `transmute_mut!`.assert_size_eq/// Do `t` and `u` have the same size?  If not, this macro produces a compile/// error. It must be invoked in a dead codepath. This is used in/// `transmute_ref!` and `transmute_mut!`.'dst'srcDst/// Transmutes a reference of one type to a reference of another type./// The caller must guarantee that:/// - `Src: AsBytes`/// - `Dst: FromBytes`/// - `size_of::<Src>() == size_of::<Dst>()`/// - `align_of::<Src>() >= align_of::<Dst>()`/// Transmutes a mutable reference of one type to a mutable reference of another/// - `Src: FromBytes + AsBytes`/// - `Dst: FromBytes + AsBytes`// NOTE: We can't change this to a `pub use core as core_reexport` until [1] is// fixed or we update to a semver-breaking version (as of this writing, 0.8.0)// on the `main` branch.// [1] https://github.com/obi1kenobi/cargo-semver-checks/issues/573test_align_oftest_max_aligns_oftest_typed_align_checktest_struct_has_paddingtest_union_has_padding// Copyright 2022 The Fuchsia Authors//! Utilities used by macros and by `zerocopy-derive`.//! These are defined here `zerocopy` rather than in code generated by macros or//! by `zerocopy-derive` so that they can be compiled once rather than//! recompiled for every invocation (e.g., if they were defined in generated//! code, then deriving `AsBytes` and `FromBytes` on three different types would//! result in the code in question being emitted and compiled six different//! times)./// Documents multiple unsafe blocks with a single safety comment./// Invoked as:/// safety_comment! {///     // Non-doc comments come first.///     /// SAFETY:///     /// Safety comment starts on its own line.///     macro_1!(args);///     macro_2! { args };///     /// Subsequent safety comments are allowed but not required.///     macro_3! { args };/// The macro invocations are emitted, each decorated with the following/// attribute: `#[allow(clippy::undocumented_unsafe_blocks)]`.unsafe_impl// Implement `$trait` for `$ty` with no bounds.// Implement all `$traits` for `$ty` with no bounds.// This arm is identical to the following one, except it contains a// preceding `const`. If we attempt to handle these with a single arm, there// is an inherent ambiguity between `const` (the keyword) and `const` (the// ident match for `$tyvar:ident`).// To explain how this works, consider the following invocation://   unsafe_impl!(const N: usize, T: ?Sized + Copy => Clone for Foo<T>);// In this invocation, here are the assignments to meta-variables://   |---------------|------------|//   | Meta-variable | Assignment |//   | $constname    |  N         |//   | $constty      |  usize     |//   | $tyvar        |  T         |//   | $optbound     |  Sized     |//   | $bound        |  Copy      |//   | $trait        |  Clone     |//   | $ty           |  Foo<T>    |// The following arm has the same behavior with the exception of the lack of// support for a leading `const` parameter./// Unsafely implements trait(s) for a type./// The trait impl must be sound./// When implementing `TryFromBytes`:/// - If no `is_bit_valid` impl is provided, then it must be valid for///   `is_bit_valid` to unconditionally return `true`. In other words, it must///   be the case that any initialized sequence of bytes constitutes a valid///   instance of `$ty`./// - If an `is_bit_valid` impl is provided, then:///   - Regardless of whether the provided closure takes a `Ptr<$repr>` or///     `&$repr` argument, it must be the case that, given `t: *mut $ty` and///     `let r = t as *mut $repr`, `r` refers to an object of equal or lesser///     size than the object referred to by `t`.///   - If the provided closure takes a `&$repr` argument, then given a `Ptr<'a,///     $ty>` which satisfies the preconditions of///     `TryFromBytes::<$ty>::is_bit_valid`, it must be guaranteed that the///     memory referenced by that `Ptr` always contains a valid `$repr`.///   - The alignment of `$repr` is less than or equal to the alignment of///     `$ty`.///   - The impl of `is_bit_valid` must only return `true` for its argument///     `Ptr<$repr>` if the original `Ptr<$ty>` refers to a valid `$ty`.unsafe_impl_for_power_set/// Implements a trait for a type, bounding on each memeber of the power set of/// a set of type variables. This is useful for implementing traits for tuples/// or `fn` types./// The last argument is the name of a macro which will be called in every/// `impl` block, and is expected to expand to the name of the type for which to/// implement the trait./// For example, the invocation:/// unsafe_impl_for_power_set!(A, B => Foo for type!(...))/// ...expands to:/// unsafe impl       Foo for type!()     { ... }/// unsafe impl<B>    Foo for type!(B)    { ... }/// unsafe impl<A, B> Foo for type!(A, B) { ... }opt_extern_c_fn/// Expands to an `Option<extern "C" fn>` type with the given argument types and/// return type. Designed for use with `unsafe_impl_for_power_set`.opt_fn/// Expands to a `Option<fn>` type with the given argument types and return/// type. Designed for use with `unsafe_impl_for_power_set`.impl_or_verify// The following two match arms follow the same pattern as their// counterparts in `unsafe_impl!`; see the documentation on those arms for// more details./// Implements trait(s) for a type or verifies the given implementation by/// referencing an existing (derived) implementation./// This macro exists so that we can provide zerocopy-derive as an optional/// dependency and still get the benefit of using its derives to validate that/// our trait impls are sound./// When compiling without `--cfg 'feature = "derive"` and without `--cfg test`,/// `impl_or_verify!` emits the provided trait impl. When compiling with either/// of those cfgs, it is expected that the type in question is deriving the/// traits instead. In this case, `impl_or_verify!` emits code which validates/// that the given trait impl is at least as restrictive as the the impl emitted/// by the custom derive. This has the effect of confirming that the impl which/// is emitted when the `derive` feature is disabled is actually sound (on the/// assumption that the impl emitted by the custom derive is sound)./// The caller is still required to provide a safety comment (e.g. using the/// `safety_comment!` macro) . The reason for this restriction is that, while/// `impl_or_verify!` can guarantee that the provided impl is sound when it is/// compiled with the appropriate cfgs, there is no way to guarantee that it is/// ever compiled with those cfgs. In particular, it would be possible to/// accidentally place an `impl_or_verify!` call in a context that is only ever/// compiled when the `derive` feature is disabled. If that were to happen,/// there would be nothing to prevent an unsound trait impl from being emitted./// Requiring a safety comment reduces the likelihood of emitting an unsound/// impl in this case, and also provides useful documentation for readers of the/// // Note that these derives are gated by `feature = "derive"`/// #[cfg_attr(any(feature = "derive", test), derive(FromZeroes, FromBytes, AsBytes, Unaligned))]/// struct Wrapper<T>(T);///     /// `Wrapper<T>` is `repr(transparent)`, so it is sound to implement any///     /// zerocopy trait if `T` implements that trait.///     impl_or_verify!(T: FromZeroes => FromZeroes for Wrapper<T>);///     impl_or_verify!(T: FromBytes => FromBytes for Wrapper<T>);///     impl_or_verify!(T: AsBytes => AsBytes for Wrapper<T>);///     impl_or_verify!(T: Unaligned => Unaligned for Wrapper<T>);/// Implements `KnownLayout` for a sized type.unsafe_impl_known_layout/// Implements `KnownLayout` for a type in terms of the implementation of/// another type with the same representation./// - `$ty` and `$repr` must have the same:///   - Fixed prefix size///   - Alignment///   - (For DSTs) trailing slice element size/// - It must be valid to perform an `as` cast from `*mut $repr` to `*mut $ty`,///   and this operation must preserve referent size (ie, `size_of_val_raw`).assert_unaligned/// Uses `align_of` to confirm that a type or set of types have alignment 1./// Note that `align_of<T>` requires `T: Sized`, so this macro doesn't work for/// unsized types.// Copyright 2023 The Fuchsia AuthorsREFCELL_REF_INTO_REF/// use core::cell::{Ref, RefCell};/// let refcell = RefCell::new([0u8, 1, 2, 3]);/// let core_ref = refcell.borrow();/// let core_ref = Ref::map(core_ref, |bytes| &bytes[..]);/// // `zc_ref` now stores `core_ref` internally./// let zc_ref = zerocopy::Ref::<_, u32>::new(core_ref).unwrap();/// // This causes `core_ref` to get dropped and synthesizes a Rust/// // reference to the memory `core_ref` was pointing at./// let rust_ref = zc_ref.into_ref();/// // UB!!! This mutates `rust_ref`'s referent while it's alive./// *refcell.borrow_mut() = [0, 0, 0, 0];/// println!("{}", rust_ref);REFCELL_REFMUT_INTO_MUT/// use core::cell::{RefCell, RefMut};/// let core_ref_mut = refcell.borrow_mut();/// let core_ref_mut = RefMut::map(core_ref_mut, |bytes| &mut bytes[..]);/// // `zc_ref` now stores `core_ref_mut` internally./// let zc_ref = zerocopy::Ref::<_, u32>::new(core_ref_mut).unwrap();/// // This causes `core_ref_mut` to get dropped and synthesizes a Rust/// let rust_ref_mut = zc_ref.into_mut();/// // UB!!! This mutates `rust_ref_mut`'s referent while it's alive./// println!("{}", rust_ref_mut);REFCELL_REFMUT_INTO_SLICE/// let zc_ref = zerocopy::Ref::<_, [u16]>::new_slice(core_ref).unwrap();/// let rust_ref = zc_ref.into_slice();/// println!("{:?}", rust_ref);REFCELL_REFMUT_INTO_MUT_SLICE/// let zc_ref = zerocopy::Ref::<_, [u16]>::new_slice(core_ref_mut).unwrap();/// let rust_ref_mut = zc_ref.into_mut_slice();/// println!("{:?}", rust_ref_mut);//! Code that should fail to compile during the post-monomorphization compiler//! pass.//! Due to [a limitation with the `trybuild` crate][trybuild-issue], we cannot//! use our UI testing framework to test compilation failures that are//! encountered after monomorphization has complated. This module has one item//! for each such test we would prefer to have as a UI test, with the code in//! question appearing as a rustdoc example which is marked with `compile_fail`.//! This has the effect of causing doctests to fail if any of these examples//! compile successfully.//! This is very much a hack and not a complete replacement for UI tests - most//! notably because this only provides a single "compile vs fail" bit of//! information, but does not allow us to depend upon the specific error that//! causes compilation to fail.//! [trybuild-issue]: https://github.com/dtolnay/trybuild/issues/241// Miri doesn't detect post-monimorphization failures as compile-time failures,// but instead as runtime failures./// Returns the amount of padding we must insert after `len` bytes to ensure/// that the following address will satisfy `align` (measured in bytes)./// e.g., if `len` is 9, then `padding_needed_for(len, 4)` returns 3, because/// that is the minimum number of bytes of padding required to get a 4-aligned/// address (assuming that the corresponding memory block starts at a 4-aligned/// address)./// The return value of this function has no meaning if `align` is not a/// power-of-two./// May panic if `align` is not a power of two.// TODO(#419): Replace `len` with a witness type for region size."third_party/rust/layout.rs"core_layoutAsAddress// INVARIANTS:// 1. `ptr` is derived from some valid Rust allocation, `A`// 2. `ptr` has the same provenance as `A`// 3. `ptr` addresses a byte range which is entirely contained in `A`// 4. `ptr` addresses a byte range whose length fits in an `isize`// 5. `ptr` addresses a byte range which does not wrap around the address//     space// 6. `ptr` is validly-aligned for `T`// 7. `A` is guaranteed to live for at least `'a`// 8. `T: 'a`/// A raw pointer with more restrictions./// `Ptr<T>` is similar to `NonNull<T>`, but it is more restrictive in the/// following ways:/// - It must derive from a valid allocation/// - It must reference a byte range which is contained inside the///   allocation from which it derives///   - As a consequence, the byte range it references must have a size///     which does not overflow `isize`/// - It must satisfy `T`'s alignment requirement/// Thanks to these restrictions, it is easier to prove the soundness of/// some operations using `Ptr`s./// `Ptr<'a, T>` is [covariant] in `'a` and `T`./// [covariant]: https://doc.rust-lang.org/reference/subtyping.html/// Returns a shared reference to the value./// For the duration of `'a`:/// - The referenced memory must contain a validly-initialized `T` for///   the duration of `'a`./// - The referenced memory must not also be referenced by any mutable///   references./// - The referenced memory must not be mutated, even via an///   [`UnsafeCell`]./// - There must not exist any references to the same memory region///   which contain `UnsafeCell`s at byte ranges which are not identical///   to the byte ranges at which `T` contains `UnsafeCell`s.// TODO(#429): The safety requirements are likely overly-restrictive.// Notably, mutation via `UnsafeCell`s is probably fine. Once the rules// are more clearly defined, we should relax the safety requirements.// For an example of why this is subtle, see:// https://github.com/rust-lang/unsafe-code-guidelines/issues/463#issuecomment-1736771593cast_unsized/// Casts to a different (unsized) target type./// The caller promises that/// - `cast(p)` is implemented exactly as follows: `|p: *mut T| p as///   *mut U`./// - The size of the object referenced by the resulting pointer is less///   than or equal to the size of the object referenced by `self`./// - The alignment of `U` is less than or equal to the alignment of///   `T`.try_cast_into/// Attempts to cast `self` to a `U` using the given cast type./// Returns `None` if the resulting `U` would be invalidly-aligned or if/// no `U` can fit in `self`. On success, returns a pointer to the/// largest-possible `U` which fits in `self`./// The caller may assume that this implementation is correct, and may/// rely on that assumption for the soundness of their code. In/// particular, the caller may assume that, if `try_cast_into` returns/// `Some((ptr, split_at))`, then:/// - If this is a prefix cast, `ptr` refers to the byte range `[0,///   split_at)` in `self`./// - If this is a suffix cast, `ptr` refers to the byte range///   `[split_at, self.len())` in `self`./// Panics if `U` is a DST whose trailing slice element is zero-sized.try_cast_into_no_leftover/// Attempts to cast `self` into a `U`, failing if all of the bytes of/// `self` cannot be treated as a `U`./// In particular, this method fails if `self` is not validly-aligned/// for `U` or if `self`'s size is not a valid size for `U`./// On success, the caller may assume that the returned pointer/// references the same byte range as `self`./// The number of slice elements referenced by `self`./// Unsafe code my rely on `len` satisfying the above contract.test_ptrtry_cast_into_soundnessaligned_to/// Is `t` aligned to `mem::align_of::<U>()`?round_down_to_next_multiple_of_alignment/// Round `n` down to the largest value `m` such that `m <= n` and `m % align ==/// 0`./// May panic if `align` is not a power of two. Even if it doesn't panic in this/// case, it will produce nonsense results.// A polyfill for `NonNull::slice_from_raw_parts` that we can use before our// MSRV is 1.70, when that function was stabilized.// TODO(#67): Once our MSRV is 1.70, remove this./// Since we support multiple versions of Rust, there are often features which/// have been stabilized in the most recent stable release which do not yet/// exist (stably) on our MSRV. This module provides polyfills for those/// features so that we can write more "modern" code, and just remove the/// polyfill once our MSRV supports the corresponding feature. Without this,/// we'd have to write worse/more verbose code and leave TODO comments sprinkled/// throughout the codebase to update to the new pattern once it's stabilized./// Each trait is imported as `_` at the crate root; each polyfill should "just/// work" at usage sites./// A `T` which is aligned to at least `align_of::<A>()`.// A `u64` with alignment 8.// Though `u64` has alignment 8 on some platforms, it's not guaranteed.// By contrast, `AU64` is guaranteed to have alignment 8.// Converts this `AU64` to bytes using this platform's endianness.test_round_down_to_next_multiple_of_alignmentUnalign/// A type with no alignment requirement./// An `Unalign` wraps a `T`, removing any alignment requirement. `Unalign<T>`/// has the same size and bit validity as `T`, but not necessarily the same/// alignment [or ABI]. This is useful if a type with an alignment requirement/// needs to be read from a chunk of memory which provides no alignment/// guarantees./// Since `Unalign` has no alignment requirement, the inner `T` may not be/// properly aligned in memory. There are five ways to access the inner `T`:/// - by value, using [`get`] or [`into_inner`]/// - by reference inside of a callback, using [`update`]/// - fallibly by reference, using [`try_deref`] or [`try_deref_mut`]; these can///   fail if the `Unalign` does not satisfy `T`'s alignment requirement at///   runtime/// - unsafely by reference, using [`deref_unchecked`] or///   [`deref_mut_unchecked`]; it is the caller's responsibility to ensure that///   the `Unalign` satisfies `T`'s alignment requirement/// - (where `T: Unaligned`) infallibly by reference, using [`Deref::deref`] or///   [`DerefMut::deref_mut`]/// [or ABI]: https://github.com/google/zerocopy/issues/164/// [`get`]: Unalign::get/// [`into_inner`]: Unalign::into_inner/// [`update`]: Unalign::update/// [`try_deref`]: Unalign::try_deref/// [`try_deref_mut`]: Unalign::try_deref_mut/// [`deref_unchecked`]: Unalign::deref_unchecked/// [`deref_mut_unchecked`]: Unalign::deref_mut_unchecked// NOTE: This type is sound to use with types that need to be dropped. The// reason is that the compiler-generated drop code automatically moves all// values to aligned memory slots before dropping them in-place. This is not// well-documented, but it's hinted at in places like [1] and [2]. However, this// also means that `T` must be `Sized`; unless something changes, we can never// support unsized `T`. [3]// [1] https://github.com/rust-lang/rust/issues/54148#issuecomment-420529646// [2] https://github.com/google/zerocopy/pull/126#discussion_r1018512323// [3] https://github.com/google/zerocopy/issues/209// Note that `Unalign: Clone` only if `T: Copy`. Since the inner `T` may not be// aligned, there's no way to safely call `T::clone`, and so a `T: Clone` bound// is not sufficient to implement `Clone` for `Unalign`./// Constructs a new `Unalign`./// Consumes `self`, returning the inner `T`.try_deref/// Attempts to return a reference to the wrapped `T`, failing if `self` is/// not properly aligned./// If `self` does not satisfy `mem::align_of::<T>()`, then it is unsound to/// return a reference to the wrapped `T`, and `try_deref` returns `None`./// If `T: Unaligned`, then `Unalign<T>` implements [`Deref`], and callers/// may prefer [`Deref::deref`], which is infallible.try_deref_mut/// Attempts to return a mutable reference to the wrapped `T`, failing if/// `self` is not properly aligned./// return a reference to the wrapped `T`, and `try_deref_mut` returns/// If `T: Unaligned`, then `Unalign<T>` implements [`DerefMut`], and/// callers may prefer [`DerefMut::deref_mut`], which is infallible.deref_unchecked/// Returns a reference to the wrapped `T` without checking alignment./// If `T: Unaligned`, then `Unalign<T>` implements[ `Deref`], and callers/// may prefer [`Deref::deref`], which is safe./// If `self` does not satisfy `mem::align_of::<T>()`, then/// `self.deref_unchecked()` may cause undefined behavior.deref_mut_unchecked/// Returns a mutable reference to the wrapped `T` without checking/// alignment./// If `T: Unaligned`, then `Unalign<T>` implements[ `DerefMut`], and/// callers may prefer [`DerefMut::deref_mut`], which is safe./// `self.deref_mut_unchecked()` may cause undefined behavior./// Gets an unaligned raw pointer to the inner `T`./// The returned raw pointer is not necessarily aligned to/// `align_of::<T>()`. Most functions which operate on raw pointers require/// those pointers to be aligned, so calling those functions with the result/// of `get_ptr` will be undefined behavior if alignment is not guaranteed/// using some out-of-band mechanism. In general, the only functions which/// are safe to call with this pointer are those which are explicitly/// documented as being sound to use with an unaligned pointer, such as/// [`read_unaligned`]./// [`read_unaligned`]: core::ptr::read_unalignedget_mut_ptr/// Gets an unaligned mutable raw pointer to the inner `T`.// TODO(https://github.com/rust-lang/rust/issues/57349): Make this `const`./// Sets the inner `T`, dropping the previous value./// Updates the inner `T` by calling a function on it./// If [`T: Unaligned`], then `Unalign<T>` implements [`DerefMut`], and that/// impl should be preferred over this method when performing updates, as it/// will usually be faster and more ergonomic./// For large types, this method may be expensive, as it requires copying/// `2 * size_of::<T>()` bytes. \[1\]/// \[1\] Since the inner `T` may not be aligned, it would not be sound to/// invoke `f` on it directly. Instead, `update` moves it into a/// properly-aligned location in the local stack frame, calls `f` on it, and/// then moves it back to its original location in `self`./// [`T: Unaligned`]: Unaligned/// Gets a copy of the inner `T`.// The outer struct is aligned to `A`, and, thanks to `repr(C)`, `t` is// placed at the minimum offset that guarantees its alignment. If// `align_of::<T>() < align_of::<A>()`, then that offset will be// guaranteed *not* to satisfy `align_of::<A>()`.ForceUnalign/// A `T` which is guaranteed not to satisfy `align_of::<A>()`./// It must be the case that `align_of::<T>() < align_of::<A>()` in order/// fot this type to work properly.test_unaligntest_unalign_updatecfg_nameVersionCfgITER_FIRST_NEXT_EXPECT_MSGparse_version_cfgs_from_cargo_toml// Copyright 2024 The Fuchsia AuthorsNumExt// For each trait polyfill, as soon as the corresponding feature is stable, the/// implemented for various special reference types such as/// [`Ref<[u8]>`](core::cell::Ref) and [`RefMut<[u8]>`](core::cell::RefMut)./// Implementations of `ByteSlice` must promise that their implementations of/// [`Deref`] and [`DerefMut`] are "stable". In particular, given `B: ByteSlice`/// and `b: B`, two calls, each to either `b.deref()` or `b.deref_mut()`, must/// return a byte slice with the same address and length. This must hold even if/// the two calls are separated by an arbitrary sequence of calls to methods on/// `ByteSlice`, [`ByteSliceMut`], [`IntoByteSlice`], or [`IntoByteSliceMut`],/// or on their super-traits. This does *not* need to hold if the two calls are/// separated by any method calls, field accesses, or field modifications *other/// than* those from these traits./// Note that this also implies that, given `b: B`, the address and length/// cannot be modified via objects other than `b`, either on the same thread or/// on another thread./// `ByteSliceMut` is a shorthand for [`ByteSlice`] and [`DerefMut`].CopyableByteSliceCloneableByteSlice/// A [`ByteSlice`] which can be copied without violating dereference stability./// If `B: CopyableByteSlice`, then the dereference stability properties/// required by [`ByteSlice`] (see that trait's safety documentation) do not/// only hold regarding two calls to `b.deref()` or `b.deref_mut()`, but also/// hold regarding `c.deref()` or `c.deref_mut()`, where `c` is produced by/// copying `b`./// A [`ByteSlice`] which can be cloned without violating dereference stability./// If `B: CloneableByteSlice`, then the dereference stability properties/// `b.clone()`, `b.clone().clone()`, etc./// Attempts to split `self` at the midpoint./// `s.split_at(mid)` returns `Ok((s[..mid], s[mid..]))` if `mid <=/// s.deref().len()` and otherwise returns `Err(s)`./// Unsafe code may rely on this function correctly implementing the above/// Splits the slice at the midpoint, possibly omitting bounds checks./// `s.split_at_unchecked(mid)` returns `s[..mid]` and `s[mid..]`./// `mid` must not be greater than `self.deref().len()`./// Implementations of this method may choose to perform a bounds check and/// panic if `mid > self.deref().len()`. They may also panic for any other/// reason. Since it is optional, callers must not rely on this behavior for/// soundness.SplitByteSlice/// A [`ByteSlice`] that can be split in two./// Unsafe code may depend for its soundness on the assumption that `split_at`/// and `split_at_unchecked` are implemented correctly. In particular, given `B:/// SplitByteSlice` and `b: B`, if `b.deref()` returns a byte slice with address/// `addr` and length `len`, then if `split <= len`, both of these/// invocations:/// - `b.split_at(split)`/// - `b.split_at_unchecked(split)`/// ...will return `(first, second)` such that:/// - `first`'s address is `addr` and its length is `split`/// - `second`'s address is `addr + split` and its length is `len - split`SplitByteSliceMut/// A shorthand for [`SplitByteSlice`] and [`ByteSliceMut`].into_byte_slice/// Coverts `self` into a `&[u8]`./// The returned reference has the same address and length as `self.deref()`/// and `self.deref_mut()`./// Note that, combined with the safety invariant on [`ByteSlice`], this/// safety invariant implies that the returned reference is "stable" in the/// sense described in the `ByteSlice` docs.IntoByteSlice// There's a `Safety` section on `into_byte_slice`./// A [`ByteSlice`] that conveys no ownership, and so can be converted into a/// Some `ByteSlice` types (notably, the standard library's [`Ref`] type) convey/// ownership, and so they cannot soundly be moved by-value into a byte slice/// type (`&[u8]`). Some methods in this crate's API (such as [`Ref::into_ref`])/// are only compatible with `ByteSlice` types without these ownership/// [`Ref`]: core::cell::Refinto_byte_slice_mut/// Coverts `self` into a `&mut [u8]`.IntoByteSliceMut// There's a `Safety` section on `into_byte_slice_mut`./// A [`ByteSliceMut`] that conveys no ownership, and so can be converted into a/// mutable byte slice./// Some `ByteSliceMut` types (notably, the standard library's [`RefMut`] type)/// convey ownership, and so they cannot soundly be moved by-value into a byte/// slice type (`&mut [u8]`). Some methods in this crate's API (such as/// [`Ref::into_mut`]) are only compatible with `ByteSliceMut` types without/// these ownership semantics./// [`RefMut`]: core::cell::RefMut// FIXME(#429): Add a "SAFETY" comment and remove this `allow`.// SAFETY: This delegates to `polyfills:split_at_unchecked`, which is documented// to correctly split `self` into two slices at the given `mid` point.// SAFETY: See inline.// SAFETY: This delegates to `polyfills:split_at_mut_unchecked`, which is// documented to correctly split `self` into two slices at the given `mid`// point.// SAFETY: This delegates to stdlib implementation of `Ref::map_split`, which is// assumed to be correct, and `SplitByteSlice::split_at_unchecked`, which is// SAFETY: This delegates to stdlib implementation of `RefMut::map_split`, which// is assumed to be correct, and `SplitByteSlice::split_at_unchecked`, which is//! Traits for types that encapsulate a `[u8]`.//! These traits are used to bound the `B` parameter of [`Ref`]./// A type-level representation of byte order./// This type is implemented by [`BigEndian`] and [`LittleEndian`], which/// represent big-endian and little-endian byte order respectively. This module/// also provides a number of useful aliases for those types: [`NativeEndian`],/// [`NetworkEndian`], [`BE`], and [`LE`]./// `ByteOrder` types can be used to specify the byte order of the types in this/// module - for example, [`U32<BigEndian>`] is a 32-bit integer stored in/// [`U32<BigEndian>`]: U32/// Big-endian byte order./// See [`ByteOrder`] for more details./// Little-endian byte order./// The endianness used by this platform./// This is a type alias for [`BigEndian`] or [`LittleEndian`] depending on the/// endianness of the target platform./// The endianness used in many network protocols./// This is a type alias for [`BigEndian`].// without performing a byte order swap when both operands are byteorder// types. This only works for bitwise operations like `&`, `|`, etc.// When only one operand is a byteorder type, we still need to perform a// byteorder swap.PointerMetadatapointer_to_metadatar" Constructs a new value from bytes which are already in `O` byte"r" order.""has no side effects"r" Extracts the bytes of `self` without swapping the byte order."r" The returned bytes will be in `O` byte order."maybe_const_trait_bounded_fnr" Constructs a new value, possibly performing an endianness"r" swap to guarantee that the returned value has endianness"r" `O`."r" Returns the value as a primitive type, possibly performing"r" an endianness swap to guarantee that the return value has"r" the endianness of the native platform."define_float_conversion// FIXME(https://github.com/rust-lang/rust/issues/72447): Use the endianness// conversion methods directly once those are const-stable.f32_extf64_exttest_const_methods//! this module - [`U16`], [`I16`], [`U32`], [`F32`], [`F64`], etc. Unlike their//! native counterparts, these types have alignment 1, and take a type parameter//! implements this crate's relevant conversion and marker traits.//! use zerocopy::{*, byteorder::network_endian::U16};//! # use zerocopy_derive::*;//! #[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]//! struct UdpPacket {//!     header: UdpHeader,//!     body: [u8],//! impl UdpPacket {//!     fn parse(bytes: &[u8]) -> Option<&UdpPacket> {//!         UdpPacket::ref_from_bytes(bytes).ok()//! Deprecated items. These are kept separate so that they don't clutter up//! other modules.TransmuteRefMutAlignmentIncrease/// We require that the alignment of the destination type is not larger than the/// alignment of the source type./// let increase_alignment: &u16 = zerocopy::transmute_ref!(&[0u8; 2]);/// let mut src = [0u8; 2];/// let increase_alignment: &mut u16 = zerocopy::transmute_mut!(&mut src);TransmuteRefMutSizeIncrease/// We require that the size of the destination type is not larger than the size/// of the source type./// let increase_size: &[u8; 2] = zerocopy::transmute_ref!(&0u8);/// let mut src = 0u8;/// let increase_size: &mut [u8; 2] = zerocopy::transmute_mut!(&mut src);TransmuteRefMutSizeDecrease/// We require that the size of the destination type is not smaller than the/// size of the source type./// let decrease_size: &u8 = zerocopy::transmute_ref!(&[0u8; 2]);/// let decrease_size: &mut u8 = zerocopy::transmute_mut!(&mut src);TransmuteRefMutDstOffsetIncrease/// It's not possible in the general case to increase the trailing slice offset/// during a reference transmutation - some pointer metadata values would not be/// supportable, and so such a transmutation would be fallible./// use zerocopy::doctests::SliceDst;/// let src: &SliceDst<u8, u8> = SliceDst::new();/// let increase_offset: &SliceDst<[u8; 2], u8> = zerocopy::transmute_ref!(src);/// let src: &mut SliceDst<u8, u8> = SliceDst::new_mut();/// let increase_offset: &mut SliceDst<[u8; 2], u8> = zerocopy::transmute_mut!(src);TransmuteRefMutDstOffsetNotMultiple/// Reference transmutes are not possible when the difference between the source/// and destination types' trailing slice offsets is not a multiple of the/// destination type's trailing slice element size./// let src: &SliceDst<[u8; 3], [u8; 2]> = SliceDst::new();/// let _: &SliceDst<[u8; 2], [u8; 2]> = zerocopy::transmute_ref!(src);/// let src: &mut SliceDst<[u8; 3], [u8; 2]> = SliceDst::new_mut();/// let _: &mut SliceDst<[u8; 2], [u8; 2]> = zerocopy::transmute_mut!(src);TransmuteRefMutDstElemSizeNotMultiple/// Reference transmutes are not possible when the source's trailing slice/// element size is not a multiple of the destination's./// let src: &SliceDst<(), [u8; 3]> = SliceDst::new();/// let _: &SliceDst<(), [u8; 2]> = zerocopy::transmute_ref!(src);/// let src: &mut SliceDst<(), [u8; 3]> = SliceDst::new_mut();/// let _: &mut SliceDst<(), [u8; 2]> = zerocopy::transmute_mut!(src);// Copyright 2025 The Fuchsia Authors// Required for derives on `SliceDst`//! Our UI test framework, built on the `trybuild` crate, does not support//! testing for post-monomorphization errors. Instead, we use doctests, which//! are able to test for post-monomorphization errors.SendSyncPhantomData/// The conversion source was improperly aligned./// The conversion source was of incorrect size./// The conversion source contained invalid data./// Zerocopy's generic error type./// Generally speaking, zerocopy's conversions may fail for one of up to three/// - [`AlignmentError`]: the conversion source was improperly aligned/// - [`SizeError`]: the conversion source was of incorrect size/// - [`ValidityError`]: the conversion source contained invalid data/// However, not all conversions produce all errors. For instance,/// [`FromBytes::ref_from_bytes`] may fail due to alignment or size issues, but/// not validity issues. This generic error type captures these/// (im)possibilities via parameterization: `A` is parameterized with/// [`AlignmentError`], `S` is parameterized with [`SizeError`], and `V` is/// parameterized with [`Infallible`]./// Zerocopy never uses this type directly in its API. Rather, we provide three/// pre-parameterized aliases:/// - [`CastError`]: the error type of reference conversions/// - [`TryCastError`]: the error type of fallible reference conversions/// - [`TryReadError`]: the error type of fallible read conversionsAlignmentError/// Infallibly discards the alignment error from this `ConvertError` since/// `Dst` is unaligned./// Since [`Dst: Unaligned`], it is impossible to encounter an alignment/// error. This method permits discarding that alignment error infallibly/// and replacing it with [`Infallible`]./// [`Dst: Unaligned`]: crate::Unaligned/// use core::convert::Infallible;/// use zerocopy::*;/// #[derive(TryFromBytes, KnownLayout, Unaligned, Immutable)]/// struct Bools {///     one: bool,///     two: bool,///     many: [bool],/// impl Bools {///     fn parse(bytes: &[u8]) -> Result<&Bools, AlignedTryCastError<&[u8], Bools>> {///         // Since `Bools: Unaligned`, we can infallibly discard///         // the alignment error.///         Bools::try_ref_from_bytes(bytes).map_err(Into::into)/// Produces a human-readable error message./// The message differs between debug and release builds. When/// `debug_assertions` are enabled, this message is verbose and includes/// potentially sensitive information./// The source value involved in the conversion./// The inner destination type inolved in the conversion./// INVARIANT: An `AlignmentError` may only be constructed if `Dst`'s/// alignment requirement is greater than one./// The error emitted if the conversion source is improperly aligned./// The caller must ensure that `Dst`'s alignment requirement is greater/// than one.into_src/// Produces the source underlying the failed conversion.NewSrcwith_srcmap_src/// Maps the source value associated with the conversion error./// This can help mitigate [issues with `Send`, `Sync` and `'static`/// bounds][self#send-sync-and-static]./// let unaligned = Unalign::new(0u16);/// // Attempt to deref `unaligned`. This might fail with an alignment error./// let maybe_n: Result<&u16, AlignmentError<&Unalign<u16>, u16>> = unaligned.try_deref();/// // Map the error's source to its address as a usize./// let maybe_n: Result<&u16, AlignmentError<usize, u16>> = maybe_n.map_err(|err| {///     err.map_src(|src| src as *const _ as usize)display_verbose_extras/// Format extra details for a verbose, human-readable error message./// This formatting may include potentially sensitive information.// A convenience constructor so that test code doesn't need to write// `unsafe`.SizeError/// The error emitted if the conversion source is of incorrect size./// Sets the source value associated with the conversion error./// let source: [u8; 3] = [0, 1, 2];/// // Try to read a `u32` from `source`. This will fail because there are insufficient/// // bytes in `source`./// let maybe_u32: Result<u32, SizeError<&[u8], u32>> = u32::read_from_bytes(&source[..]);/// // Map the error's source to its size./// let maybe_u32: Result<u32, SizeError<usize, u32>> = maybe_u32.map_err(|err| {///     err.map_src(|src| src.len())NewDstwith_dst/// Sets the destination type associated with the conversion error./// Converts the error into a general [`ConvertError`].ValidityError/// The error emitted if the conversion source contains invalid data./// let source: u8 = 42;/// // Try to transmute the `source` to a `bool`. This will fail./// let maybe_bool: Result<bool, ValidityError<u8, bool>> = try_transmute!(source);/// // Drop the error's source./// let maybe_bool: Result<bool, ValidityError<(), bool>> = maybe_bool.map_err(|err| {///     err.map_src(drop)CastError/// The error type of reference conversions./// Reference conversions, like [`FromBytes::ref_from_bytes`] may emit/// [alignment](AlignmentError) and [size](SizeError) errors.// Bounds on generic parameters are not enforced in type aliases, but they do// appear in rustdoc./// let maybe_u32: Result<&u32, CastError<&[u8], u32>> = u32::ref_from_bytes(&source[..]);/// // Map the error's source to its size and address./// let maybe_u32: Result<&u32, CastError<(usize, usize), u32>> = maybe_u32.map_err(|err| {///     err.map_src(|src| (src.len(), src.as_ptr() as usize))TryCastError/// Infallibly extracts the [`SizeError`] from this `CastError` since `Dst`/// is unaligned./// error, and so the only error that can be encountered at runtime is a/// [`SizeError`]. This method permits extracting that `SizeError`/// infallibly./// #[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]/// struct UdpPacket {///     header: UdpHeader,///     body: [u8],/// impl UdpPacket {///     pub fn parse(bytes: &[u8]) -> Result<&UdpPacket, SizeError<&[u8], UdpPacket>> {///         // Since `UdpPacket: Unaligned`, we can map the `CastError` to a `SizeError`.///         UdpPacket::ref_from_bytes(bytes).map_err(Into::into)/// The error type of fallible reference conversions./// Fallible reference conversions, like [`TryFromBytes::try_ref_from_bytes`]/// may emit [alignment](AlignmentError), [size](SizeError), and/// [validity](ValidityError) errors./// let source: [u8; 3] = [0, 0, 0];/// // Try to read a `NonZeroU32` from `source`./// let maybe_u32: Result<&NonZeroU32, TryCastError<&[u8], NonZeroU32>>///     = NonZeroU32::try_ref_from_bytes(&source[..]);/// let maybe_u32: Result<&NonZeroU32, TryCastError<(usize, usize), NonZeroU32>> =///     maybe_u32.map_err(|err| {///         err.map_src(|src| (src.len(), src.as_ptr() as usize))// FIXME(#1139): Remove the `TryFromBytes` here and in other downstream// locations (all the way to `ValidityError`) if we determine it's not necessary// for rich validity errors.TryReadError/// The error type of fallible read-conversions./// Fallible read-conversions, like [`TryFromBytes::try_read_from_bytes`] may emit/// [size](SizeError) and [validity](ValidityError) errors, but not alignment errors./// let maybe_u32: Result<NonZeroU32, TryReadError<&[u8], NonZeroU32>>///     = NonZeroU32::try_read_from_bytes(&source[..]);/// let maybe_u32: Result<NonZeroU32, TryReadError<usize, NonZeroU32>> =///         err.map_src(|src| src.len())AlignedTryCastError/// The error type of well-aligned, fallible casts./// This is like [`TryCastError`], but for casts that are always well-aligned./// It is identical to `TryCastError`, except that its alignment error is/// [`Infallible`]./// As of this writing, none of zerocopy's API produces this error directly./// However, it is useful since it permits users to infallibly discard alignment/// errors when they can prove statically that alignment errors are impossible./// The error type of a failed allocation./// This type is intended to be deprecated in favor of the standard library's/// [`AllocError`] type once it is stabilized. When that happens, this type will/// be replaced by a type alias to the standard library type. We do not intend/// to treat this as a breaking change; users who wish to avoid breakage should/// avoid writing code which assumes that this is *not* such an alias. For/// example, implementing the same trait for both types will result in an impl/// conflict once this type is an alias./// [`AllocError`]: https://doc.rust-lang.org/alloc/alloc/struct.AllocError.htmlalignment_displaysize_displayvalidity_display//! Types related to error reporting.//! ## Single failure mode errors//! Generally speaking, zerocopy's conversions may fail for one of up to three//! reasons://! - [`AlignmentError`]: the conversion source was improperly aligned//! - [`SizeError`]: the conversion source was of incorrect size//! - [`ValidityError`]: the conversion source contained invalid data//! Methods that only have one failure mode, like//! [`FromBytes::read_from_bytes`], return that mode's corresponding error type//! ## Compound errors//! Conversion methods that have either two or three possible failure modes//! return one of these error types://! - [`CastError`]: the error type of reference conversions//! - [`TryCastError`]: the error type of fallible reference conversions//! - [`TryReadError`]: the error type of fallible read conversions//! ## [`Unaligned`] destination types//! For [`Unaligned`] destination types, alignment errors are impossible. All//! compound error types support infallibly discarding the alignment error via//! [`From`] so long as `Dst: Unaligned`. For example, see [`<SizeError as//! From<ConvertError>>::from`][size-error-from].//! [size-error-from]: struct.SizeError.html#method.from-1//! ## Accessing the conversion source//! All error types provide an `into_src` method that converts the error into//! the source value underlying the failed conversion.//! ## Display formatting//! All error types provide a `Display` implementation that produces a//! human-readable error message. When `debug_assertions` are enabled, these//! error messages are verbose and may include potentially sensitive//! information, including://! - the names of the involved types//! - the sizes of the involved types//! - the addresses of the involved types//! - the contents of the involved types//! When `debug_assertions` are disabled (as is default for `release` builds),//! such potentially sensitive information is excluded.//! In the future, we may support manually configuring this behavior. If you are//! interested in this feature, [let us know on GitHub][issue-1457] so we know//! to prioritize it.//! [issue-1457]: https://github.com/google/zerocopy/issues/1457//! ## Validation order//! Our conversion methods typically check alignment, then size, then bit//! validity. However, we do not guarantee that this is always the case, and//! this behavior may change between releases.//! ## `Send`, `Sync`, and `'static`//! Our error types are `Send`, `Sync`, and `'static` when their `Src` parameter//! is `Send`, `Sync`, or `'static`, respectively. This can cause issues when an//! error is sent or synchronized across threads; e.g.://! ```compile_fail,E0515//! use zerocopy::*;//! let result: SizeError<&[u8], u32> = std::thread::spawn(|| {//!     let source = &mut [0u8, 1, 2][..];//!     // Try (and fail) to read a `u32` from `source`.//!     u32::read_from_bytes(source).unwrap_err()//! }).join().unwrap();//! To work around this, use [`map_src`][CastError::map_src] to convert the//! source parameter to an unproblematic type; e.g.://! let result: SizeError<(), u32> = std::thread::spawn(|| {//!         // Erase the error source.//!         .map_src(drop)//! Alternatively, use `.to_string()` to eagerly convert the error into a//! human-readable message; e.g.://! let result: Result<u32, String> = std::thread::spawn(|| {//!     u32::read_from_bytes(source)//!         // Eagerly render the error message.//!         .map_err(|err| err.to_string())CoreMaybeUninit// SAFETY: Per the reference [1], "the unit tuple (`()`) ... is guaranteed as a// zero-sized type to have a size of 0 and an alignment of 1."// - `Immutable`: `()` self-evidently does not contain any `UnsafeCell`s.// - `TryFromBytes` (with no validator), `FromZeros`, `FromBytes`: There is only//   one possible sequence of 0 bytes, and `()` is inhabited.// - `IntoBytes`: Since `()` has size 0, it contains no padding bytes.// - `Unaligned`: `()` has alignment 1.// [1] https://doc.rust-lang.org/1.81.0/reference/type-layout.html#tuple-layout// - `Immutable`: These types self-evidently do not contain any `UnsafeCell`s.// - `TryFromBytes` (with no validator), `FromZeros`, `FromBytes`: all bit//   patterns are valid for numeric types [1]// - `IntoBytes`: numeric types have no padding bytes [1]// - `Unaligned` (`u8` and `i8` only): The reference [2] specifies the size of//   `u8` and `i8` as 1 byte. We also know that://   - Alignment is >= 1 [3]//   - Size is an integer multiple of alignment [4]//   - The only value >= 1 for which 1 is an integer multiple is 1 Therefore,//   the only possible alignment for `u8` and `i8` is 1.// [1] Per https://doc.rust-lang.org/1.81.0/reference/types/numeric.html#bit-validity://     For every numeric type, `T`, the bit validity of `T` is equivalent to//     the bit validity of `[u8; size_of::<T>()]`. An uninitialized byte is//     not a valid `u8`.// [2] https://doc.rust-lang.org/1.81.0/reference/type-layout.html#primitive-data-layout// [3] Per https://doc.rust-lang.org/1.81.0/reference/type-layout.html#size-and-alignment://     Alignment is measured in bytes, and must be at least 1.// [4] Per https://doc.rust-lang.org/1.81.0/reference/type-layout.html#size-and-alignment://     The size of a value is always a multiple of its alignment.// FIXME(#278): Once we've updated the trait docs to refer to `u8`s rather than// bits or bytes, update this comment, especially the reference to [1].// - `Immutable`: `bool` self-evidently does not contain any `UnsafeCell`s.// - `FromZeros`: Valid since "[t]he value false has the bit pattern 0x00" [1].// - `IntoBytes`: Since "the boolean type has a size and alignment of 1 each"//   and "The value false has the bit pattern 0x00 and the value true has the//   bit pattern 0x01" [1]. Thus, the only byte of the bool is always//   initialized.// - `Unaligned`: Per the reference [1], "[a]n object with the boolean type has//   a size and alignment of 1 each."// [1] https://doc.rust-lang.org/1.81.0/reference/types/boolean.html// SAFETY: The impl must only return `true` for its argument if the original// `Maybe<bool>` refers to a valid `bool`. We only return true if the `u8` value// is 0 or 1, and both of these are valid values for `bool` [1].// [1] Per https://doc.rust-lang.org/1.81.0/reference/types/boolean.html://   The value false has the bit pattern 0x00 and the value true has the bit//   pattern 0x01.impl_size_eq// - `Immutable`: `char` self-evidently does not contain any `UnsafeCell`s.// - `FromZeros`: Per reference [1], "[a] value of type char is a Unicode scalar//   value (i.e. a code point that is not a surrogate), represented as a 32-bit//   unsigned word in the 0x0000 to 0xD7FF or 0xE000 to 0x10FFFF range" which//   contains 0x0000.// - `IntoBytes`: `char` is per reference [1] "represented as a 32-bit unsigned//   word" (`u32`) which is `IntoBytes`. Note that unlike `u32`, not all bit//   patterns are valid for `char`.// [1] https://doc.rust-lang.org/1.81.0/reference/types/textual.html// `Maybe<char>` refers to a valid `char`. `char::from_u32` guarantees that it// returns `None` if its input is not a valid `char` [1].// [1] Per https://doc.rust-lang.org/core/primitive.char.html#method.from_u32://   `from_u32()` will return `None` if the input is not a valid value for a//   `char`.// SAFETY: Per the Reference [1], `str` has the same layout as `[u8]`.// - `Immutable`: `[u8]` does not contain any `UnsafeCell`s.// - `FromZeros`, `IntoBytes`, `Unaligned`: `[u8]` is `FromZeros`, `IntoBytes`,//   and `Unaligned`.// Note that we don't `assert_unaligned!(str)` because `assert_unaligned!` uses// `align_of`, which only works for `Sized` types.// FIXME(#429):// - Add quotes from documentation.// - Improve safety proof for `FromZeros` and `IntoBytes`; having the same//   layout as `[u8]` isn't sufficient.// [1] https://doc.rust-lang.org/1.81.0/reference/type-layout.html#str-layout// `Maybe<str>` refers to a valid `str`. `str::from_utf8` guarantees that it// returns `Err` if its input is not a valid `str` [1].// [2] Per https://doc.rust-lang.org/core/str/fn.from_utf8.html#errors://   Returns `Err` if the slice is not UTF-8.unsafe_impl_try_from_bytes_for_nonzero// `NonZeroXxx` is `IntoBytes`, but not `FromZeros` or `FromBytes`.// - `IntoBytes`: `NonZeroXxx` has the same layout as its associated primitive.//    Since it is the same size, this guarantees it has no padding - integers//    have no padding, and there's no room for padding if it can represent all//    of the same values except 0.// - `Unaligned`: `NonZeroU8` and `NonZeroI8` document that `Option<NonZeroU8>`//   and `Option<NonZeroI8>` both have size 1. [1] [2] This is worded in a way//   that makes it unclear whether it's meant as a guarantee, but given the//   purpose of those types, it's virtually unthinkable that that would ever//   change. `Option` cannot be smaller than its contained type, which implies//   that, and `NonZeroX8` are of size 1 or 0. `NonZeroX8` can represent//   multiple states, so they cannot be 0 bytes, which means that they must be 1//   byte. The only valid alignment for a 1-byte type is 1.// - Add safety comment for `Immutable`. How can we prove that `NonZeroXxx`//   doesn't contain any `UnsafeCell`s? It's obviously true, but it's not clear//   how we'd prove it short of adding text to the stdlib docs that says so//   explicitly, which likely wouldn't be accepted.// [1] https://doc.rust-lang.org/1.81.0/std/num/type.NonZeroU8.html//     `NonZeroU8` is guaranteed to have the same layout and bit validity as `u8` with//     the exception that 0 is not a valid instance// [2] https://doc.rust-lang.org/1.81.0/std/num/type.NonZeroI8.html// FIXME(https://github.com/rust-lang/rust/pull/104082): Cite documentation that// layout is the same as primitive layout.// - `TryFromBytes` (with no validator), `FromZeros`, `FromBytes`, `IntoBytes`://   The Rust compiler reuses `0` value to represent `None`, so//   `size_of::<Option<NonZeroXxx>>() == size_of::<xxx>()`; see `NonZeroXxx`//   documentation.//   change. The only valid alignment for a 1-byte type is 1.// FIXME(#429): Add quotes from documentation.// [1] https://doc.rust-lang.org/stable/std/num/struct.NonZeroU8.html// [2] https://doc.rust-lang.org/stable/std/num/struct.NonZeroI8.html// FIXME(https://github.com/rust-lang/rust/pull/104082): Cite documentation for// layout guarantees.// SAFETY: The following types can be transmuted from `[0u8; size_of::<T>()]`. [1]// [1] Per https://doc.rust-lang.org/nightly/core/option/index.html#representation://   Rust guarantees to optimize the following types `T` such that [`Option<T>`]//   has the same size and alignment as `T`. In some of these cases, Rust//   further guarantees that `transmute::<_, Option<T>>([0u8; size_of::<T>()])`//   is sound and produces `Option::<T>::None`. These cases are identified by//   the second column://   | `T`                   | `transmute::<_, Option<T>>([0u8; size_of::<T>()])` sound? |//   |-----------------------|-----------------------------------------------------------|//   | [`Box<U>`]            | when `U: Sized`                                           |//   | `&U`                  | when `U: Sized`                                           |//   | `&mut U`              | when `U: Sized`                                           |//   | [`ptr::NonNull<U>`]   | when `U: Sized`                                           |//   | `fn`, `extern "C" fn` | always                                                    |// FIXME(#429), FIXME(https://github.com/rust-lang/rust/pull/115333): Cite the// Stable docs once they're available.// SAFETY: `fn()` and `extern "C" fn()` self-evidently do not contain// `UnsafeCell`s. This is not a proof, but we are accepting this as a known risk// per #1358.impl_traits_for_atomicsunsafe_impl_transmute_from_for_atomic/// Implements `TransmuteFrom` for `$atomic`, `$prim`, and/// `UnsafeCell<$prim>`./// `$atomic` must have the same size and bit validity as `$prim`.impl_for_transmute_from// SAFETY: Per [1], `AtomicBool`, `AtomicU8`, and `AtomicI8` have the// same size as `bool`, `u8`, and `i8` respectively. Since a type's// alignment cannot be smaller than 1 [2], and since its alignment// cannot be greater than its size [3], the only possible value for the// alignment is 1. Thus, it is sound to implement `Unaligned`.// [1] Per (for example) https://doc.rust-lang.org/1.81.0/std/sync/atomic/struct.AtomicU8.html://   This type has the same size, alignment, and bit validity as the//   underlying integer type// [2] Per https://doc.rust-lang.org/1.81.0/reference/type-layout.html#size-and-alignment:// SAFETY: `AtomicU8`, `AtomicI8`, and `AtomicBool` have the same size// and bit validity as `u8`, `i8`, and `bool` respectively [1][2][3].// [1] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicU8.html://   underlying integer type, `u8`.// [2] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicI8.html://   underlying integer type, `i8`.// [3] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicBool.html://   This type has the same size, alignment, and bit validity a `bool`.atomic_8// SAFETY: `AtomicU16` and `AtomicI16` have the same size and bit// validity as `u16` and `i16` respectively [1][2].// [1] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicU16.html://   This type has the same size and bit validity as the underlying//   integer type, `u16`.// [2] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicI16.html://   integer type, `i16`.atomic_16// SAFETY: `AtomicU32` and `AtomicI32` have the same size and bit// validity as `u32` and `i32` respectively [1][2].// [1] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicU32.html://   integer type, `u32`.// [2] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicI32.html://   integer type, `i32`.atomic_32// SAFETY: `AtomicU64` and `AtomicI64` have the same size and bit// validity as `u64` and `i64` respectively [1][2].// [1] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicU64.html://   integer type, `u64`.// [2] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicI64.html://   integer type, `i64`.atomic_64// FIXME(#170): Implement `FromBytes` and `IntoBytes` once we implement// those traits for `*mut T`.// SAFETY: `AtomicUsize` and `AtomicIsize` have the same size and bit// validity as `usize` and `isize` respectively [1][2].// [1] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicUsize.html://   integer type, `usize`.// [2] Per https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicIsize.html://   integer type, `isize`.// SAFETY: Per// https://doc.rust-lang.org/1.85.0/std/sync/atomic/struct.AtomicPtr.html://   This type has the same size and bit validity as a `*mut T`.atomics// SAFETY: Per reference [1]: "For all T, the following are guaranteed:// size_of::<PhantomData<T>>() == 0 align_of::<PhantomData<T>>() == 1". This// gives:// - `Immutable`: `PhantomData` has no fields.//   one possible sequence of 0 bytes, and `PhantomData` is inhabited.// - `IntoBytes`: Since `PhantomData` has size 0, it contains no padding bytes.// - `Unaligned`: Per the preceding reference, `PhantomData` has alignment 1.// [1] https://doc.rust-lang.org/1.81.0/std/marker/struct.PhantomData.html#layout-1// SAFETY: Per [1], `Wrapping<T>` has the same layout as `T`. Since its single// field (of type `T`) is public, it would be a breaking change to add or remove// fields. Thus, we know that `Wrapping<T>` contains a `T` (as opposed to just// having the same size and alignment as `T`) with no pre- or post-padding.// Thus, `Wrapping<T>` must have `UnsafeCell`s covering the same byte ranges as// `Inner = T`.// [1] Per https://doc.rust-lang.org/1.81.0/std/num/struct.Wrapping.html#layout-1://   `Wrapping<T>` is guaranteed to have the same layout and ABI as `T`// SAFETY: Per [1] in the preceding safety comment, `Wrapping<T>` has the same// alignment as `T`.// SAFETY: `TryFromBytes` (with no validator), `FromZeros`, `FromBytes`:// `MaybeUninit<T>` has no restrictions on its contents.// SAFETY: `MaybeUninit<T>` has `UnsafeCell`s covering the same byte ranges as// `Inner = T`. This is not explicitly documented, but it can be inferred. Per// [1], `MaybeUninit<T>` has the same size as `T`. Further, note the signature// of `MaybeUninit::assume_init_ref` [2]://   pub unsafe fn assume_init_ref(&self) -> &T// If the argument `&MaybeUninit<T>` and the returned `&T` had `UnsafeCell`s at// different offsets, this would be unsound. Its existence is proof that this is// not the case.// [1] Per https://doc.rust-lang.org/1.81.0/std/mem/union.MaybeUninit.html#layout-1:// `MaybeUninit<T>` is guaranteed to have the same size, alignment, and ABI as// `T`.// [2] https://doc.rust-lang.org/1.81.0/std/mem/union.MaybeUninit.html#method.assume_init_ref// SAFETY: Per [1] in the preceding safety comment, `MaybeUninit<T>` has the// same alignment as `T`.// SAFETY: `ManuallyDrop<T>` has the same layout as `T` [1]. This strongly// implies, but does not guarantee, that it contains `UnsafeCell`s covering the// same byte ranges as in `T`. However, it also implements `Defer<Target = T>`// [2], which provides the ability to convert `&ManuallyDrop<T> -> &T`. This,// combined with having the same size as `T`, implies that `ManuallyDrop<T>`// exactly contains a `T` with the same fields and `UnsafeCell`s covering the// same byte ranges, or else the `Deref` impl would permit safe code to obtain// different shared references to the same region of memory with different// `UnsafeCell` coverage, which would in turn permit interior mutation that// would violate the invariants of a shared reference.// [1] Per https://doc.rust-lang.org/1.85.0/std/mem/struct.ManuallyDrop.html://   `ManuallyDrop<T>` is guaranteed to have the same layout and bit validity as//   `T`// [2] https://doc.rust-lang.org/1.85.0/std/mem/struct.ManuallyDrop.html#impl-Deref-for-ManuallyDrop%3CT%3E// SAFETY: `ManuallyDrop<T>` has the same layout as `T` [1], and thus has the// [1] Per https://doc.rust-lang.org/nightly/core/mem/struct.ManuallyDrop.html:// SAFETY: `Cell<T>` has the same in-memory representation as `T` [1], and thus// has the same alignment as `T`.// [1] Per https://doc.rust-lang.org/1.81.0/core/cell/struct.Cell.html#memory-layout://   `Cell<T>` has the same in-memory representation as its inner type `T`.// SAFETY: `UnsafeCell<T>` has the same in-memory representation as `T` [1], and// thus has the same alignment as `T`.// [1] Per https://doc.rust-lang.org/1.81.0/core/cell/struct.UnsafeCell.html#memory-layout://   `UnsafeCell<T>` has the same in-memory representation as its inner type//   `T`.// SAFETY: See safety comment in `is_bit_valid` impl.// SAFETY: Per the reference [1]://   An array of `[T; N]` has a size of `size_of::<T>() * N` and the same//   alignment of `T`. Arrays are laid out so that the zero-based `nth` element//   of the array is offset from the start of the array by `n * size_of::<T>()`//   bytes.//   Slices have the same layout as the section of the array they slice.// In other words, the layout of a `[T]` or `[T; N]` is a sequence of `T`s laid// out back-to-back with no bytes in between. Therefore, `[T]` or `[T; N]` are// `Immutable`, `TryFromBytes`, `FromZeros`, `FromBytes`, and `IntoBytes` if `T`// is (respectively). Furthermore, since an array/slice has "the same alignment// of `T`", `[T]` and `[T; N]` are `Unaligned` if `T` is.// Note that we don't `assert_unaligned!` for slice types because// `assert_unaligned!` uses `align_of`, which only works for `Sized` types.// [1] https://doc.rust-lang.org/1.81.0/reference/type-layout.html#array-layout// - `Immutable`: Raw pointers do not contain any `UnsafeCell`s.// - `FromZeros`: For thin pointers (note that `T: Sized`), the zero pointer is//   considered "null". [1] No operations which require provenance are legal on//   null pointers, so this is not a footgun.// - `TryFromBytes`: By the same reasoning as for `FromZeroes`, we can implement//   `TryFromBytes` for thin pointers provided that//   [`TryFromByte::is_bit_valid`] only produces `true` for zeroed bytes.// NOTE(#170): Implementing `FromBytes` and `IntoBytes` for raw pointers would// be sound, but carries provenance footguns. We want to support `FromBytes` and// `IntoBytes` for raw pointers eventually, but we are holding off until we can// figure out how to address those footguns.// [1] FIXME(https://github.com/rust-lang/rust/pull/116988): Cite the// documentation once this PR lands.// SAFETY: `NonNull<T>` self-evidently does not contain `UnsafeCell`s. This is// not a proof, but we are accepting this as a known risk per #1358.// SAFETY: Reference types do not contain any `UnsafeCell`s.// SAFETY: `Option` is not `#[non_exhaustive]` [1], which means that the types// in its variants cannot change, and no new variants can be added. `Option<T>`// does not contain any `UnsafeCell`s outside of `T`. [1]// [1] https://doc.rust-lang.org/core/option/enum.Option.html/// Defines a module which implements `TryFromBytes`, `FromZeros`,/// `FromBytes`, and `IntoBytes` for a set of types from a module in/// to implement `FromZeros`, `FromBytes`, and `IntoBytes` for.//   `Immutable`, `TryFromBytes`, `FromZeros`, `FromBytes`, or `IntoBytes`, that//   SIMD type is also `Immutable`, `TryFromBytes`, `FromZeros`, `FromBytes`, or//   `IntoBytes` respectively.// `TryFromBytes`, `FromZeros`, `FromBytes`, or `IntoBytes` is next to zero, as/// Note that `DstLayout` does not have any internal invariants, so no guarantee/// is made that a `DstLayout` conforms to any of Rust's requirements regarding/// the layout of real Rust types or instances of types.CastTypeMetadataCastErrorcast_from_rawPtrInner/// Implements [`<Dst as SizeEq<Src>>::cast_from_raw`][cast_from_raw]./// # PME/// Generates a post-monomorphization error if it is not possible to satisfy/// the soundness conditions of [`SizeEq::cast_from_raw`][cast_from_raw]/// for `Src` and `Dst`./// [cast_from_raw]: crate::pointer::SizeEq::cast_from_raw// FIXME(#1817): Support Sized->Unsized and Unsized->Sized caststest_validate_cast_and_convert_metadata// FIXME(#67): For some reason, on our MSRV toolchain, this `allow` isn't// enforced despite having `#![allow(unknown_lints)]` at the crate root, but// putting it here works. Once our MSRV is high enough that this bug has been// fixed, remove this `allow`.// We intentionally choose not to deny `unused_qualifications`. When items// are added to the prelude (e.g., `core::mem::size_of`), this has the// consequence of making some uses trigger this lint on the latest toolchain// (e.g., `mem::size_of`), but fixing it (e.g. by replacing with `size_of`)// does not work on older toolchains.// We tested a more complicated fix in #1413, but ultimately decided that,// since this lint is just a minor style lint, the complexity isn't worth it// - it's fine to occasionally have unused qualifications slip through,// especially since these do not affect our user-facing API in any way.// This module is `pub` so that zerocopy's error types and error handling// documentation is grouped together in a cohesive module. In practice, we// expect most users to use the re-export of `error`'s items to avoid identifier// stuttering.r#ref// FIXME(#252): If we make this pub, come up with a better name.BecauseExclusiveSplitAtMetadataOf// Used by `KnownLayout`.BecauseImmutable// These exist so that code which was written against the old names will get// less confusing error messages when they upgrade to a more recent version of// zerocopy. On our MSRV toolchain, the error messages read, for example://   error[E0603]: trait `FromZeroes` is private//       --> examples/deprecated.rs:1:15//        |//   1    | use zerocopy::FromZeroes;//        |               ^^^^^^^^^^ private trait//   note: the trait `FromZeroes` is defined here//       --> /Users/josh/workspace/zerocopy/src/lib.rs:1845:5//   1845 | use FromZeros as FromZeroes;//        |     ^^^^^^^^^^^^^^^^^^^^^^^// The "note" provides enough context to make it easy to figure out how to fix// the error./// Implements [`KnownLayout`]./// This derive analyzes various aspects of a type's layout that are needed for/// some of zerocopy's APIs. It can be applied to structs, enums, and unions;/// # use zerocopy_derive::KnownLayout;/// #[derive(KnownLayout)]/// #   V00,/// This derive cannot currently be applied to unsized structs without an/// explicit `repr` attribute./// Some invocations of this derive run afoul of a [known bug] in Rust's type/// privacy checker. For example, this code:/// ```compile_fail,E0446/// pub struct PublicType {///     leading: Foo,///     trailing: Bar,/// ...results in a compilation error:/// error[E0446]: private type `Bar` in public interface///  --> examples/bug.rs:3:10/// 3  | #[derive(KnownLayout)]///    |          ^^^^^^^^^^^ can't leak private type/// .../// 14 | struct Bar;///    | ---------- `Bar` declared as private///    = note: this error originates in the derive macro `KnownLayout` (in Nightly builds, run with -Z macro-backtrace for more info)/// This issue arises when `#[derive(KnownLayout)]` is applied to `repr(C)`/// structs whose trailing field type is less public than the enclosing struct./// To work around this, mark the trailing field type `pub` and annotate it with/// `#[doc(hidden)]`; e.g.:/// #[doc(hidden)]/// pub struct Bar; // <- `Bar` is now also `pub`/// [known bug]: https://github.com/rust-lang/rust/issues/45713/// The type of metadata stored in a pointer to `Self`./// This is `()` for sized types and `usize` for slice DSTs./// A maybe-uninitialized analog of `Self`/// `Self::LAYOUT` and `Self::MaybeUninit::LAYOUT` are identical./// `Self::MaybeUninit` admits uninitialized bytes in all positions./// The layout of `Self`./// Callers may assume that `LAYOUT` accurately reflects the layout of/// `Self`. In particular:/// - `LAYOUT.align` is equal to `Self`'s alignment/// - If `Self: Sized`, then `LAYOUT.size_info == SizeInfo::Sized { size }`///   where `size == size_of::<Self>()`/// - If `Self` is a slice DST, then `LAYOUT.size_info ==///   SizeInfo::SliceDst(slice_layout)` where:///   - The size, `size`, of an instance of `Self` with `elems` trailing///     slice elements is equal to `slice_layout.offset +///     slice_layout.elem_size * elems` rounded up to the nearest multiple///     of `LAYOUT.align`///   - For such an instance, any bytes in the range `[slice_layout.offset +///     slice_layout.elem_size * elems, size)` are padding and must not be///     assumed to be initialized/// elements in its trailing slice./// Extracts the metadata from a pointer to `Self`./// `pointer_to_metadata` always returns the correct metadata stored in/// `ptr`.size_of_val_raw/// Computes the length of the byte range addressed by `ptr`./// Returns `None` if the resulting length would not fit in an `usize`./// Callers may assume that `size_of_val_raw` always returns the correct/// Callers may assume that, if `ptr` addresses a byte range whose length/// fits in an `usize`, this will return `Some`.raw_dangling/// Indicates that zerocopy can reason about certain aspects of a type's layout./// This trait is required by many of zerocopy's APIs. It supports sized types,/// slices, and [slice DSTs](#dynamically-sized-types)./// [`#[derive(KnownLayout)]`][derive]; e.g.:/// This derive performs a sophisticated analysis to deduce the layout/// characteristics of types. You **must** implement this trait via the derive./// # Dynamically-sized types/// `KnownLayout` supports slice-based dynamically sized types ("slice DSTs")./// A slice DST is a type whose trailing field is either a slice or another/// slice DST, rather than a type with fixed size. For example:///     header: PacketHeader,/// It can be useful to think of slice DSTs as a generalization of slices - in/// other words, a normal slice is just the special case of a slice DST with/// zero leading fields. In particular:/// - Like slices, slice DSTs can have different lengths at runtime/// - Like slices, slice DSTs cannot be passed by-value, but only by reference///   or via other indirection such as `Box`/// - Like slices, a reference (or `Box`, or other pointer type) to a slice DST///   encodes the number of elements in the trailing slice field/// ## Slice DST layout/// Just like other composite Rust types, the layout of a slice DST is not/// well-defined unless it is specified using an explicit `#[repr(...)]`/// attribute such as `#[repr(C)]`. [Other representations are/// supported][reprs], but in this section, we'll use `#[repr(C)]` as our/// A `#[repr(C)]` slice DST is laid out [just like sized `#[repr(C)]`/// types][repr-c-structs], but the presenence of a variable-length field/// introduces the possibility of *dynamic padding*. In particular, it may be/// necessary to add trailing padding *after* the trailing slice field in order/// to satisfy the outer type's alignment, and the amount of padding required/// may be a function of the length of the trailing slice field. This is just a/// natural consequence of the normal `#[repr(C)]` rules applied to slice DSTs,/// but it can result in surprising behavior. For example, consider the/// following type:///     z: [u16],/// Assuming that `u32` has alignment 4 (this is not true on all platforms),/// then `Foo` has alignment 4 as well. Here is the smallest possible value for/// `Foo`:/// byte offset | 01234567///       field | aaaab---///                    ></// In this value, `z` has length 0. Abiding by `#[repr(C)]`, the lowest offset/// that we can place `z` at is 5, but since `z` has alignment 2, we need to/// round up to offset 6. This means that there is one byte of padding between/// `b` and `z`, then 0 bytes of `z` itself (denoted `><` in this diagram), and/// then two bytes of padding after `z` in order to satisfy the overall/// alignment of `Foo`. The size of this instance is 8 bytes./// What about if `z` has length 1?///       field | aaaab-zz/// In this instance, `z` has length 1, and thus takes up 2 bytes. That means/// that we no longer need padding after `z` in order to satisfy `Foo`'s/// alignment. We've now seen two different values of `Foo` with two different/// lengths of `z`, but they both have the same size - 8 bytes./// What about if `z` has length 2?/// byte offset | 012345678901///       field | aaaab-zzzz--/// Now `z` has length 2, and thus takes up 4 bytes. This brings our un-padded/// size to 10, and so we now need another 2 bytes of padding after `z` to/// satisfy `Foo`'s alignment./// Again, all of this is just a logical consequence of the `#[repr(C)]` rules/// applied to slice DSTs, but it can be surprising that the amount of trailing/// padding becomes a function of the trailing slice field's length, and thus/// can only be computed at runtime./// [reprs]: https://doc.rust-lang.org/reference/type-layout.html#representations/// [repr-c-structs]: https://doc.rust-lang.org/reference/type-layout.html#reprc-structs/// ## What is a valid size?/// There are two places in zerocopy's API that we refer to "a valid size" of a/// type. In normal casts or conversions, where the source is a byte slice, we/// need to know whether the source byte slice is a valid size of the/// destination type. In prefix or suffix casts, we need to know whether *there/// exists* a valid size of the destination type which fits in the source byte/// slice and, if so, what the largest such size is./// As outlined above, a slice DST's size is defined by the number of elements/// in its trailing slice field. However, there is not necessarily a 1-to-1/// mapping between trailing slice field length and overall size. As we saw in/// the previous section with the type `Foo`, instances with both 0 and 1/// elements in the trailing `z` field result in a `Foo` whose size is 8 bytes./// When we say "x is a valid size of `T`", we mean one of two things:/// - If `T: Sized`, then we mean that `x == size_of::<T>()`/// - If `T` is a slice DST, then we mean that there exists a `len` such that the instance of///   `T` with `len` trailing slice elements has size `x`/// When we say "largest possible size of `T` that fits in a byte slice", we/// mean one of two things:/// - If `T: Sized`, then we mean `size_of::<T>()` if the byte slice is at least///   `size_of::<T>()` bytes long/// - If `T` is a slice DST, then we mean to consider all values, `len`, such///   that the instance of `T` with `len` trailing slice elements fits in the///   byte slice, and to choose the largest such `len`, if any/// You must not rely on the `#[doc(hidden)]` internals of `KnownLayout`. Futuretrailing_slice_layout/// Efficiently produces the [`TrailingSliceLayout`] of `T`.from_elem_count/// Constructs a `Self` from an element count./// If `Self = ()`, this returns `()`. If `Self = usize`, this returns/// `elems`. No other types are currently supported.size_for_metadata/// Computes the size of the object with the given layout and pointer/// If `Self = ()`, `layout` must describe a sized type. If `Self = usize`,/// `layout` must describe a slice DST. Otherwise, `size_for_metadata` may/// `size_for_metadata` promises to only return `None` if the resulting size/// would not fit in a `usize`./// The metadata associated with a [`KnownLayout`] type.// SAFETY: `CoreMaybeUninit<T>::LAYOUT` and `T::LAYOUT` are identical// because `CoreMaybeUninit<T>` has the same size and alignment as `T` [1].// Consequently, `[CoreMaybeUninit<T>]::LAYOUT` and `[T]::LAYOUT` are// identical, because they both lack a fixed-sized prefix and because they// inherit the alignments of their inner element type (which are identical)// [2][3].// `[CoreMaybeUninit<T>]` admits uninitialized bytes at all positions// because `CoreMaybeUninit<T>` admits uninitialized bytes at all positions// and because the inner elements of `[CoreMaybeUninit<T>]` are laid out// back-to-back [2][3].//   `MaybeUninit<T>` is guaranteed to have the same size, alignment, and ABI as// [2] Per https://doc.rust-lang.org/1.82.0/reference/type-layout.html#slice-layout:// [3] Per https://doc.rust-lang.org/1.82.0/reference/type-layout.html#array-layout://   alignment of `T`. Arrays are laid out so that the zero-based `nth`//   element of the array is offset from the start of the array by `n *//   size_of::<T>()` bytes.// SAFETY: `str` has the same representation as `[u8]`. `ManuallyDrop<T>` [1],// `UnsafeCell<T>` [2], and `Cell<T>` [3] have the same representation as `T`.// [2] Per https://doc.rust-lang.org/1.85.0/core/cell/struct.UnsafeCell.html#memory-layout:// [3] Per https://doc.rust-lang.org/1.85.0/core/cell/struct.Cell.html#memory-layout://   `Cell<T>` has the same in-memory representation as `T`.// - By consequence of the invariant on `T::MaybeUninit` that `T::LAYOUT` and//   `T::MaybeUninit::LAYOUT` are equal, `T` and `T::MaybeUninit` have the same://   - Fixed prefix size//   - Alignment//   - (For DSTs) trailing slice element size// - By consequence of the above, referents `T::MaybeUninit` and `T` have the//   require the same kind of pointer metadata, and thus it is valid to perform//   an `as` cast from `*mut T` and `*mut T::MaybeUninit`, and this operation//   preserves referent size (ie, `size_of_val_raw`)./// Analyzes whether a type is [`FromZeros`]./// the [safety conditions] of `FromZeros` and implements `FromZeros` and its/// supertraits if it is sound to do so. This derive can be applied to structs,/// enums, and unions; e.g.:/// # use zerocopy_derive::{FromZeros, Immutable};/// #[derive(FromZeros)]/// #[derive(FromZeros, Immutable)]/// [safety conditions]: trait@FromZeros#safety/// determine whether it is sound to implement `FromZeros` for a given type./// manually implement `FromZeros` for a type yourself, you don't need to read/// `FromZeros` for that type:/// - If the type is a struct, all of its fields must be `FromZeros`.///   - It must have a variant with a discriminant/tag of `0`, and its fields///     must be `FromZeros`. See [the reference] for a description of///     discriminant values are specified.///   - The fields of that variant must be `FromZeros`./// documented [safety conditions] of `FromZeros`, and must *not* rely on the/// Neither this derive, nor the [safety conditions] of `FromZeros`, requires/// > does not change the layout of the fields themselves./// a struct is soundly `FromZeros` if:/// 1. its padding is soundly `FromZeros`, and/// 2. its fields are soundly `FromZeros`./// Whether a struct is soundly `FromZeros` therefore solely depends on whether/// its fields are `FromZeros`.// FIXME(#146): Document why we don't require an enum to have an explicit `repr`/// Analyzes whether a type is [`Immutable`]./// the [safety conditions] of `Immutable` and implements `Immutable` if it is/// # use zerocopy_derive::Immutable;/// #[derive(Immutable)]/// determine whether it is sound to implement `Immutable` for a given type./// Unless you are modifying the implementation of this derive, you don't need/// to read this section.*/// `Immutable` for that type:/// - All fields must be `Immutable`./// documented [safety conditions] of `Immutable`, and must *not* rely on the/// [safety conditions]: trait@Immutable#safety// The `Self: Sized` bound makes it so that `Immutable` is still object/// Types which are free from interior mutability./// `T: Immutable` indicates that `T` does not permit interior mutation, except/// by ownership or an exclusive (`&mut`) borrow./// [`#[derive(Immutable)]`][derive] (requires the `derive` Cargo feature);/// determine whether a type is `Immutable`./// Unsafe code outside of this crate must not make any assumptions about `T`/// based on `T: Immutable`. We reserve the right to relax the requirements for/// `Immutable` in the future, and if unsafe code outside of this crate makes/// assumptions based on `T: Immutable`, future relaxations may cause that code/// to become unsound.// # Safety (Internal)// If `T: Immutable`, unsafe code *inside of this crate* may assume that, given// `t: &T`, `t` does not contain any [`UnsafeCell`]s at any byte location// within the byte range addressed by `t`. This includes ranges of length 0// (e.g., `UnsafeCell<()>` and `[UnsafeCell<u8>; 0]`). If a type implements// `Immutable` which violates this assumptions, it may cause this crate to// exhibit [undefined behavior].// [`UnsafeCell`]: core::cell::UnsafeCell// [undefined behavior]: https://raphlinus.github.io/programming/rust/2018/08/17/undefined-behavior.html/// Implements [`TryFromBytes`]./// This derive synthesizes the runtime checks required to check whether a/// sequence of initialized bytes corresponds to a valid instance of a type./// This derive can be applied to structs, enums, and unions; e.g.:/// # use zerocopy_derive::{TryFromBytes, Immutable};/// #[derive(TryFromBytes)]/// #[derive(TryFromBytes, Immutable)]/// To ensure consistent endianness for enums with multi-byte representations,/// explicitly specify and convert each discriminant using `.to_le()` or/// `.to_be()`; e.g.:/// # use zerocopy_derive::TryFromBytes;/// // `DataStoreVersion` is encoded in little-endian./// pub enum DataStoreVersion {///     /// Version 1 of the data store.///     V1 = 9u32.to_le(),///     /// Version 2 of the data store.///     V2 = 10u32.to_le(),/// [safety conditions]: trait@TryFromBytes#safety// The `Self: Sized` bound makes it so that `TryFromBytes` is still object/// Besides user-defined validation routines panicking, `is_bit_valid` will/// either panic or fail to compile if called on a pointer with [`Shared`]/// aliasing when `Self: !Immutable`./// [`Shared`]: invariant::Sharedtry_ref_from_bytes/// Attempts to interpret the given `source` as a `&Self`./// If the bytes of `source` are a valid instance of `Self`, this method/// returns a reference to those bytes interpreted as a `Self`. If the/// length of `source` is not a [valid size of `Self`][valid-size], or if/// `source` is not appropriately aligned, or if `source` is not a valid/// instance of `Self`, this returns `Err`. If [`Self:/// Unaligned`][self-unaligned], you can [infallibly discard the alignment/// error][ConvertError::from]./// `Self` may be a sized type, a slice, or a [slice DST][slice-dst]./// [valid-size]: crate::KnownLayout#what-is-a-valid-size/// [self-unaligned]: Unaligned/// [slice-dst]: KnownLayout#dynamically-sized-types/// # Compile-Time Assertions/// This method cannot yet be used on unsized types whose dynamically-sized/// component is zero-sized. Attempting to use this method on such types/// results in a compile-time assertion error; e.g.:/// #[derive(TryFromBytes, Immutable, KnownLayout)]/// struct ZSTy {///     leading_sized: u16,///     trailing_dst: [()],/// let _ = ZSTy::try_ref_from_bytes(0u16.as_bytes()); // ⚠ Compile Error!/// use zerocopy::TryFromBytes;/// // The only valid value of this type is the byte `0xC0`/// #[derive(TryFromBytes, KnownLayout, Immutable)]/// enum C0 { xC0 = 0xC0 }/// // The only valid value of this type is the byte sequence `0xC0C0`./// struct C0C0(C0, C0);///     magic_number: C0C0,///     mug_size: u8,///     temperature: u8,///     marshmallows: [[u8; 2]],/// let bytes = &[0xC0, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5][..];/// let packet = Packet::try_ref_from_bytes(bytes).unwrap();/// assert_eq!(packet.mug_size, 240);/// assert_eq!(packet.temperature, 77);/// assert_eq!(packet.marshmallows, [[0, 1], [2, 3], [4, 5]]);/// // These bytes are not valid instance of `Packet`./// let bytes = &[0x10, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5][..];/// assert!(Packet::try_ref_from_bytes(bytes).is_err());try_ref_from_prefix/// Attempts to interpret the prefix of the given `source` as a `&Self`./// This method computes the [largest possible size of `Self`][valid-size]/// that can fit in the leading bytes of `source`. If that prefix is a valid/// instance of `Self`, this method returns a reference to those bytes/// interpreted as `Self`, and a reference to the remaining bytes. If there/// are insufficient bytes, or if `source` is not appropriately aligned, or/// if those bytes are not a valid instance of `Self`, this returns `Err`./// If [`Self: Unaligned`][self-unaligned], you can [infallibly discard the/// alignment error][ConvertError::from]./// let _ = ZSTy::try_ref_from_prefix(0u16.as_bytes()); // ⚠ Compile Error!/// // The only valid value of this type is the bytes `0xC0C0`./// // These are more bytes than are needed to encode a `Packet`./// let bytes = &[0xC0, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5, 6][..];/// let (packet, suffix) = Packet::try_ref_from_prefix(bytes).unwrap();/// assert_eq!(suffix, &[6u8][..]);/// let bytes = &[0x10, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5, 6][..];/// assert!(Packet::try_ref_from_prefix(bytes).is_err());try_ref_from_suffix/// Attempts to interpret the suffix of the given `source` as a `&Self`./// that can fit in the trailing bytes of `source`. If that suffix is a/// valid instance of `Self`, this method returns a reference to those bytes/// interpreted as `Self`, and a reference to the preceding bytes. If there/// are insufficient bytes, or if the suffix of `source` would not be/// appropriately aligned, or if the suffix is not a valid instance of/// `Self`, this returns `Err`. If [`Self: Unaligned`][self-unaligned], you/// can [infallibly discard the alignment error][ConvertError::from]./// let _ = ZSTy::try_ref_from_suffix(0u16.as_bytes()); // ⚠ Compile Error!/// let bytes = &[0, 0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7][..];/// let (prefix, packet) = Packet::try_ref_from_suffix(bytes).unwrap();/// assert_eq!(packet.marshmallows, [[2, 3], [4, 5], [6, 7]]);/// assert_eq!(prefix, &[0u8][..]);/// let bytes = &[0, 1, 2, 3, 4, 5, 6, 77, 240, 0xC0, 0x10][..];/// assert!(Packet::try_ref_from_suffix(bytes).is_err());try_mut_from_bytes/// Attempts to interpret the given `source` as a `&mut Self` without/// #[derive(TryFromBytes, IntoBytes, KnownLayout)]///     leading_sized: [u8; 2],/// let mut source = [85, 85];/// let _ = ZSTy::try_mut_from_bytes(&mut source[..]); // ⚠ Compile Error!/// let bytes = &mut [0xC0, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5][..];/// let packet = Packet::try_mut_from_bytes(bytes).unwrap();/// packet.temperature = 111;/// assert_eq!(bytes, [0xC0, 0xC0, 240, 111, 0, 1, 2, 3, 4, 5]);/// let bytes = &mut [0x10, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5, 6][..];/// assert!(Packet::try_mut_from_bytes(bytes).is_err());try_mut_from_prefix/// Attempts to interpret the prefix of the given `source` as a `&mut/// Self`./// if the bytes are not a valid instance of `Self`, this returns `Err`. If/// [`Self: Unaligned`][self-unaligned], you can [infallibly discard the/// let _ = ZSTy::try_mut_from_prefix(&mut source[..]); // ⚠ Compile Error!/// let bytes = &mut [0xC0, 0xC0, 240, 77, 0, 1, 2, 3, 4, 5, 6][..];/// let (packet, suffix) = Packet::try_mut_from_prefix(bytes).unwrap();/// suffix[0] = 222;/// assert_eq!(bytes, [0xC0, 0xC0, 240, 111, 0, 1, 2, 3, 4, 5, 222]);/// assert!(Packet::try_mut_from_prefix(bytes).is_err());try_mut_from_suffix/// Attempts to interpret the suffix of the given `source` as a `&mut/// let _ = ZSTy::try_mut_from_suffix(&mut source[..]); // ⚠ Compile Error!/// let bytes = &mut [0, 0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7][..];/// let (prefix, packet) = Packet::try_mut_from_suffix(bytes).unwrap();/// prefix[0] = 111;/// packet.temperature = 222;/// assert_eq!(bytes, [111, 0xC0, 0xC0, 240, 222, 2, 3, 4, 5, 6, 7]);/// let bytes = &mut [0, 1, 2, 3, 4, 5, 6, 77, 240, 0xC0, 0x10][..];/// assert!(Packet::try_mut_from_suffix(bytes).is_err());try_ref_from_bytes_with_elems/// Attempts to interpret the given `source` as a `&Self` with a DST length/// equal to `count`./// This method attempts to return a reference to `source` interpreted as a/// `Self` with `count` trailing elements. If the length of `source` is not/// equal to the size of `Self` with `count` elements, if `source` is not/// appropriately aligned, or if `source` does not contain a valid instance/// of `Self`, this returns `Err`. If [`Self: Unaligned`][self-unaligned],/// you can [infallibly discard the alignment error][ConvertError::from]./// # #![allow(non_camel_case_types)] // For C0::xC0/// let bytes = &[0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7][..];/// let packet = Packet::try_ref_from_bytes_with_elems(bytes, 3).unwrap();/// let bytes = &[0, 1, 2, 3, 4, 5, 6, 77, 240, 0xC0, 0xC0][..];/// assert!(Packet::try_ref_from_bytes_with_elems(bytes, 3).is_err());/// Since an explicit `count` is provided, this method supports types with/// zero-sized trailing slice elements. Methods such as [`try_ref_from_bytes`]/// which do not take an explicit count do not support such types./// use core::num::NonZeroU16;///     leading_sized: NonZeroU16,/// let src = 0xCAFEu16.as_bytes();/// let zsty = ZSTy::try_ref_from_bytes_with_elems(src, 42).unwrap();/// assert_eq!(zsty.trailing_dst.len(), 42);/// [`try_ref_from_bytes`]: TryFromBytes::try_ref_from_bytestry_ref_from_prefix_with_elems/// Attempts to interpret the prefix of the given `source` as a `&Self` with/// a DST length equal to `count`./// This method attempts to return a reference to the prefix of `source`/// interpreted as a `Self` with `count` trailing elements, and a reference/// to the remaining bytes. If the length of `source` is less than the size/// of `Self` with `count` elements, if `source` is not appropriately/// aligned, or if the prefix of `source` does not contain a valid instance/// let bytes = &[0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7, 8][..];/// let (packet, suffix) = Packet::try_ref_from_prefix_with_elems(bytes, 3).unwrap();/// assert_eq!(suffix, &[8u8][..]);/// let bytes = &mut [0, 1, 2, 3, 4, 5, 6, 7, 8, 77, 240, 0xC0, 0xC0][..];/// assert!(Packet::try_ref_from_prefix_with_elems(bytes, 3).is_err());/// zero-sized trailing slice elements. Methods such as [`try_ref_from_prefix`]/// let (zsty, _) = ZSTy::try_ref_from_prefix_with_elems(src, 42).unwrap();/// [`try_ref_from_prefix`]: TryFromBytes::try_ref_from_prefixtry_ref_from_suffix_with_elems/// Attempts to interpret the suffix of the given `source` as a `&Self` with/// This method attempts to return a reference to the suffix of `source`/// to the preceding bytes. If the length of `source` is less than the size/// of `Self` with `count` elements, if the suffix of `source` is not/// appropriately aligned, or if the suffix of `source` does not contain a/// valid instance of `Self`, this returns `Err`. If [`Self:/// let bytes = &[123, 0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7][..];/// let (prefix, packet) = Packet::try_ref_from_suffix_with_elems(bytes, 3).unwrap();/// assert_eq!(prefix, &[123u8][..]);/// let bytes = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 77, 240, 0xC0, 0xC0][..];/// assert!(Packet::try_ref_from_suffix_with_elems(bytes, 3).is_err());/// let (_, zsty) = ZSTy::try_ref_from_suffix_with_elems(src, 42).unwrap();try_mut_from_bytes_with_elems/// Attempts to interpret the given `source` as a `&mut Self` with a DST/// length equal to `count`./// let bytes = &mut [0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7][..];/// let packet = Packet::try_mut_from_bytes_with_elems(bytes, 3).unwrap();/// assert_eq!(bytes, [0xC0, 0xC0, 240, 111, 2, 3, 4, 5, 6, 7]);/// let bytes = &mut [0, 1, 2, 3, 4, 5, 6, 77, 240, 0xC0, 0xC0][..];/// assert!(Packet::try_mut_from_bytes_with_elems(bytes, 3).is_err());/// zero-sized trailing slice elements. Methods such as [`try_mut_from_bytes`]/// let mut src = 0xCAFEu16;/// let src = src.as_mut_bytes();/// let zsty = ZSTy::try_mut_from_bytes_with_elems(src, 42).unwrap();/// [`try_mut_from_bytes`]: TryFromBytes::try_mut_from_bytestry_mut_from_prefix_with_elems/// Attempts to interpret the prefix of the given `source` as a `&mut Self`/// with a DST length equal to `count`./// let bytes = &mut [0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7, 8][..];/// let (packet, suffix) = Packet::try_mut_from_prefix_with_elems(bytes, 3).unwrap();/// assert_eq!(bytes, [0xC0, 0xC0, 240, 111, 2, 3, 4, 5, 6, 7, 222]);/// assert!(Packet::try_mut_from_prefix_with_elems(bytes, 3).is_err());/// zero-sized trailing slice elements. Methods such as [`try_mut_from_prefix`]/// let (zsty, _) = ZSTy::try_mut_from_prefix_with_elems(src, 42).unwrap();/// [`try_mut_from_prefix`]: TryFromBytes::try_mut_from_prefixtry_mut_from_suffix_with_elems/// Attempts to interpret the suffix of the given `source` as a `&mut Self`/// let bytes = &mut [123, 0xC0, 0xC0, 240, 77, 2, 3, 4, 5, 6, 7][..];/// let (prefix, packet) = Packet::try_mut_from_suffix_with_elems(bytes, 3).unwrap();/// assert!(Packet::try_mut_from_suffix_with_elems(bytes, 3).is_err());/// let (_, zsty) = ZSTy::try_mut_from_suffix_with_elems(src, 42).unwrap();try_read_from_bytes/// Attempts to read the given `source` as a `Self`./// If `source.len() != size_of::<Self>()` or the bytes are not a valid/// instance of `Self`, this returns `Err`./// let bytes = &[0xC0, 0xC0, 240, 77][..];/// let packet = Packet::try_read_from_bytes(bytes).unwrap();/// let bytes = &mut [0x10, 0xC0, 240, 77][..];/// assert!(Packet::try_read_from_bytes(bytes).is_err());try_read_from_prefix/// Attempts to read a `Self` from the prefix of the given `source`./// This attempts to read a `Self` from the first `size_of::<Self>()` bytes/// of `source`, returning that `Self` and any remaining bytes. If/// `source.len() < size_of::<Self>()` or the bytes are not a valid instance/// of `Self`, it returns `Err`./// let (packet, suffix) = Packet::try_read_from_prefix(bytes).unwrap();/// assert_eq!(suffix, &[0u8, 1, 2, 3, 4, 5, 6][..]);/// assert!(Packet::try_read_from_prefix(bytes).is_err());try_read_from_suffix/// Attempts to read a `Self` from the suffix of the given `source`./// This attempts to read a `Self` from the last `size_of::<Self>()` bytes/// of `source`, returning that `Self` and any preceding bytes. If/// let bytes = &[0, 1, 2, 3, 4, 5, 0xC0, 0xC0, 240, 77][..];/// let (prefix, packet) = Packet::try_read_from_suffix(bytes).unwrap();/// assert_eq!(prefix, &[0u8, 1, 2, 3, 4, 5][..]);/// let bytes = &[0, 1, 2, 3, 4, 5, 0x10, 0xC0, 240, 77][..];/// assert!(Packet::try_read_from_suffix(bytes).is_err());/// Types for which some bit patterns are valid./// A memory region of the appropriate length which contains initialized bytes/// can be viewed as a `TryFromBytes` type so long as the runtime value of those/// bytes corresponds to a [*valid instance*] of that type. For example,/// [`bool`] is `TryFromBytes`, so zerocopy can transmute a [`u8`] into a/// [`bool`] so long as it first checks that the value of the [`u8`] is `0` or/// `1`./// [`#[derive(TryFromBytes)]`][derive]; e.g.:/// This derive ensures that the runtime check of whether bytes correspond to a/// valid instance is sound. You **must** implement this trait via the derive./// conservatism should not affect most users./// # `TryFromBytes` is not symmetrical with [`IntoBytes`]/// There are some types which implement both `TryFromBytes` and [`IntoBytes`],/// but for which `TryFromBytes` is not guaranteed to accept all byte sequences/// produced by `IntoBytes`. In other words, for some `T: TryFromBytes +/// IntoBytes`, there exist values of `t: T` such that/// `TryFromBytes::try_ref_from_bytes(t.as_bytes()) == None`. Code should not/// generally assume that values produced by `IntoBytes` will necessarily be/// accepted as valid by `TryFromBytes`./// validity check at runtime via methods like [`try_ref_from_bytes`]./// You must not rely on the `#[doc(hidden)]` internals of `TryFromBytes`./// Future releases of zerocopy may make backwards-breaking changes to these/// items, including changes that only affect soundness, which may cause code/// which uses those items to silently become unsound./// [*valid instance*]: #what-is-a-valid-instancetry_ref_from_prefix_suffixtry_mut_from_prefix_suffixtry_read_from/// All bytes of `candidate` must be initialized.// The `Self: Sized` bound makes it so that `FromZeros` is still object/// Overwrites `self` with zeros./// drop the current value and replace it with a new one — it simply/// # use zerocopy::FromZeros;/// let header: PacketHeader = FromZeros::new_zeroed();"has no side effects (other than allocation)"new_box_zeroed/// Creates a `Box<Self>` from zeroed bytes./// This function is useful for allocating large values on the heap and/// zero-initializing them, without ever creating a temporary instance of/// `Self` on the stack. For example, `<[u8; 1048576]>::new_box_zeroed()`/// will allocate `[u8; 1048576]` directly on the heap; it does not require/// storing `[u8; 1048576]` in a temporary variable on the stack./// On systems that use a heap implementation that supports allocating from/// pre-zeroed memory, using `new_box_zeroed` (or related functions) may/// have performance benefits./// Returns an error on allocation failure. Allocation failure is guaranteed/// never to cause a panic or an abort./// Types for which a sequence of `0` bytes is a valid instance./// only zero bytes can be viewed as any `FromZeros` type with no runtime/// # Warning: Padding bytes/// Note that, when a value is moved or copied, only the non-padding bytes of/// that value are guaranteed to be preserved. It is unsound to assume that/// values written to padding bytes are preserved after a move or copy. For more/// details, see the [`FromBytes` docs][frombytes-warning-padding-bytes]./// [frombytes-warning-padding-bytes]: FromBytes#warning-padding-bytes/// [`#[derive(FromZeros)]`][derive]; e.g.:/// determine whether a type is `FromZeros`./// *This section describes what is required in order for `T: FromZeros`, and/// `FromZeros` manually, and you don't plan on writing unsafe code that/// operates on `FromZeros` types, then you don't need to read this section.*/// If `T: FromZeros`, then unsafe code may assume that it is sound to produce a/// `T` whose bytes are all initialized to zero. If a type is marked as/// `FromZeros` which violates this contract, it may cause undefined behavior./// `#[derive(FromZeros)]` only permits [types which satisfy these/// the [safety conditions] of `FromBytes` and implements `FromBytes` and its/// enums, and unions;/// # use zerocopy_derive::{FromBytes, FromZeros, Immutable};/// #[derive(FromBytes)]/// #[derive(FromBytes, Immutable)]///   - It must have a defined representation (`repr`s `u8`, `u16`, `u32`,///     bit pattern is a valid one). Be very careful when using the `usize` or///     `isize` representations, as their size is platform-dependent.///   - Its fields must be `FromBytes`.ref_from_bytes/// Interprets the given `source` as a `&Self`./// `Self`. If the length of `source` is not a [valid size of/// `Self`][valid-size], or if `source` is not appropriately aligned, this/// returns `Err`. If [`Self: Unaligned`][self-unaligned], you can/// [infallibly discard the alignment error][size-error-from]./// [size-error-from]: error/struct.SizeError.html#method.from-1/// #[derive(FromBytes, Immutable, KnownLayout)]/// let _ = ZSTy::ref_from_bytes(0u16.as_bytes()); // ⚠ Compile Error!/// #[derive(FromBytes, KnownLayout, Immutable)]/// // These bytes encode a `Packet`./// let bytes = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11][..];/// let packet = Packet::ref_from_bytes(bytes).unwrap();/// assert_eq!(packet.header.src_port, [0, 1]);/// assert_eq!(packet.header.dst_port, [2, 3]);/// assert_eq!(packet.header.length, [4, 5]);/// assert_eq!(packet.header.checksum, [6, 7]);/// assert_eq!(packet.body, [8, 9, 10, 11]);/// Interprets the prefix of the given `source` as a `&Self` without/// that can fit in the leading bytes of `source`, then attempts to return/// both a reference to those bytes interpreted as a `Self`, and a reference/// to the remaining bytes. If there are insufficient bytes, or if `source`/// is not appropriately aligned, this returns `Err`. If [`Self:/// error][size-error-from]./// component is zero-sized. See [`ref_from_prefix_with_elems`], which does/// support such types. Attempting to use this method on such types results/// in a compile-time assertion error; e.g.:/// let _ = ZSTy::ref_from_prefix(0u16.as_bytes()); // ⚠ Compile Error!/// [`ref_from_prefix_with_elems`]: FromBytes::ref_from_prefix_with_elems///     body: [[u8; 2]],/// let bytes = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14][..];/// let (packet, suffix) = Packet::ref_from_prefix(bytes).unwrap();/// assert_eq!(packet.body, [[8, 9], [10, 11], [12, 13]]);/// assert_eq!(suffix, &[14u8][..]);/// Interprets the suffix of the given bytes as a `&Self`./// that can fit in the trailing bytes of `source`, then attempts to return/// to the preceding bytes. If there are insufficient bytes, or if that/// suffix of `source` is not appropriately aligned, this returns `Err`. If/// alignment error][size-error-from]./// component is zero-sized. See [`ref_from_suffix_with_elems`], which does/// let _ = ZSTy::ref_from_suffix(0u16.as_bytes()); // ⚠ Compile Error!/// [`ref_from_suffix_with_elems`]: FromBytes::ref_from_suffix_with_elems/// let bytes = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9][..];/// let (prefix, trailer) = PacketTrailer::ref_from_suffix(bytes).unwrap();/// assert_eq!(prefix, &[0, 1, 2, 3, 4, 5][..]);mut_from_bytes/// Interprets the given `source` as a `&mut Self`./// component is zero-sized. See [`mut_from_prefix_with_elems`], which does/// #[derive(FromBytes, Immutable, IntoBytes, KnownLayout)]/// let _ = ZSTy::mut_from_bytes(&mut source[..]); // ⚠ Compile Error!/// [`mut_from_prefix_with_elems`]: FromBytes::mut_from_prefix_with_elems/// #[derive(FromBytes, IntoBytes, KnownLayout, Immutable)]/// let header = PacketHeader::mut_from_bytes(bytes).unwrap();/// Interprets the prefix of the given `source` as a `&mut Self` without/// component is zero-sized. See [`mut_from_suffix_with_elems`], which does/// let _ = ZSTy::mut_from_prefix(&mut source[..]); // ⚠ Compile Error!/// [`mut_from_suffix_with_elems`]: FromBytes::mut_from_suffix_with_elems/// let (header, body) = PacketHeader::mut_from_prefix(bytes).unwrap();/// assert_eq!(body, &[8, 9][..]);/// body.fill(1);/// assert_eq!(bytes, [0, 1, 2, 3, 4, 5, 0, 0, 1, 1]);/// Interprets the suffix of the given `source` as a `&mut Self` without/// let _ = ZSTy::mut_from_suffix(&mut source[..]); // ⚠ Compile Error!/// let (prefix, trailer) = PacketTrailer::mut_from_suffix(bytes).unwrap();/// prefix.fill(0);/// trailer.frame_check_sequence.fill(1);/// assert_eq!(bytes, [0, 0, 0, 0, 0, 0, 1, 1, 1, 1]);ref_from_bytes_with_elems/// Interprets the given `source` as a `&Self` with a DST length equal to/// `count`./// equal to the size of `Self` with `count` elements, or if `source` is not/// appropriately aligned, this returns `Err`. If [`Self:/// let bytes = &[0, 1, 2, 3, 4, 5, 6, 7][..];/// let pixels = <[Pixel]>::ref_from_bytes_with_elems(bytes, 2).unwrap();/// zero-sized trailing slice elements. Methods such as [`ref_from_bytes`]/// let src = &[85, 85][..];/// let zsty = ZSTy::ref_from_bytes_with_elems(src, 42).unwrap();/// [`ref_from_bytes`]: FromBytes::ref_from_bytesref_from_prefix_with_elems/// Interprets the prefix of the given `source` as a DST `&Self` with length/// let (pixels, suffix) = <[Pixel]>::ref_from_prefix_with_elems(bytes, 2).unwrap();/// assert_eq!(suffix, &[8, 9]);/// zero-sized trailing slice elements. Methods such as [`ref_from_prefix`]/// let (zsty, _) = ZSTy::ref_from_prefix_with_elems(src, 42).unwrap();/// [`ref_from_prefix`]: FromBytes::ref_from_prefixref_from_suffix_with_elems/// Interprets the suffix of the given `source` as a DST `&Self` with length/// let (prefix, pixels) = <[Pixel]>::ref_from_suffix_with_elems(bytes, 2).unwrap();/// assert_eq!(prefix, &[0, 1]);/// zero-sized trailing slice elements. Methods such as [`ref_from_suffix`]/// let (_, zsty) = ZSTy::ref_from_suffix_with_elems(src, 42).unwrap();/// [`ref_from_suffix`]: FromBytes::ref_from_suffixmut_from_bytes_with_elems/// Interprets the given `source` as a `&mut Self` with a DST length equal/// to `count`./// #[derive(KnownLayout, FromBytes, IntoBytes, Immutable)]/// let pixels = <[Pixel]>::mut_from_bytes_with_elems(bytes, 2).unwrap();/// zero-sized trailing slice elements. Methods such as [`mut_from`] which/// do not take an explicit count do not support such types./// #[derive(FromBytes, IntoBytes, Immutable, KnownLayout)]/// let src = &mut [85, 85][..];/// let zsty = ZSTy::mut_from_bytes_with_elems(src, 42).unwrap();/// [`mut_from`]: FromBytes::mut_frommut_from_prefix_with_elems/// Interprets the prefix of the given `source` as a `&mut Self` with DST/// to the preceding bytes. If there are insufficient bytes, or if `source`/// let (pixels, suffix) = <[Pixel]>::mut_from_prefix_with_elems(bytes, 2).unwrap();/// suffix.fill(1);/// assert_eq!(bytes, [0, 1, 2, 3, 0, 0, 0, 0, 1, 1]);/// zero-sized trailing slice elements. Methods such as [`mut_from_prefix`]/// let (zsty, _) = ZSTy::mut_from_prefix_with_elems(src, 42).unwrap();/// [`mut_from_prefix`]: FromBytes::mut_from_prefixmut_from_suffix_with_elems/// Interprets the suffix of the given `source` as a `&mut Self` with DST/// to the remaining bytes. If there are insufficient bytes, or if that/// #[derive(FromBytes, IntoBytes, Immutable)]/// let (prefix, pixels) = <[Pixel]>::mut_from_suffix_with_elems(bytes, 2).unwrap();/// prefix.fill(9);/// assert_eq!(bytes, [9, 9, 2, 3, 4, 5, 0, 0, 0, 0]);/// zero-sized trailing slice elements. Methods such as [`mut_from_suffix`]/// let (_, zsty) = ZSTy::mut_from_suffix_with_elems(src, 42).unwrap();/// [`mut_from_suffix`]: FromBytes::mut_from_suffixread_from_bytes/// Reads a copy of `Self` from the given `source`./// If `source.len() != size_of::<Self>()`, `read_from_bytes` returns `Err`./// let header = PacketHeader::read_from_bytes(bytes).unwrap();/// Reads a copy of `Self` from the prefix of the given `source`./// `source.len() < size_of::<Self>()`, it returns `Err`./// let (header, body) = PacketHeader::read_from_prefix(bytes).unwrap();/// assert_eq!(body, [8, 9]);/// Reads a copy of `Self` from the suffix of the given `source`./// let (prefix, trailer) = PacketTrailer::read_from_suffix(bytes).unwrap();/// assert_eq!(prefix, [0, 1, 2, 3, 4, 5]);/// values written to padding bytes are preserved after a move or copy. For/// example, the following is unsound:/// use core::mem::{size_of, transmute};/// use zerocopy::FromZeros;/// // Assume `Foo` is a type with padding bytes./// #[derive(FromZeros, Default)]/// let mut foo: Foo = Foo::default();/// FromZeros::zero(&mut foo);/// // UNSOUND: Although `FromZeros::zero` writes zeros to all bytes of `foo`,/// // those writes are not guaranteed to be preserved in padding bytes when/// // `foo` is moved, so this may expose padding bytes as `u8`s./// let foo_bytes: [u8; size_of::<Foo>()] = unsafe { transmute(foo) };/// [`#[derive(FromBytes)]`][derive]; e.g.:/// # use zerocopy_derive::{FromBytes, Immutable};/// If `T: FromBytes`, then unsafe code may assume that it is sound to produce a/// `T` whose bytes are initialized to any sequence of valid `u8`s (in other/// words, any byte value which is not uninitialized). If a type is marked as/// `FromBytes` which violates this contract, it may cause undefined behavior.ref_from_prefix_suffix/// Interprets the given affix of the given bytes as a `&Self`./// This method computes the largest possible size of `Self` that can fit in the/// prefix or suffix bytes of `source`, then attempts to return both a reference/// to those bytes interpreted as a `Self`, and a reference to the excess bytes./// If there are insufficient bytes, or if that affix of `source` is not/// appropriately aligned, this returns `Err`.mut_from_prefix_suffix/// Interprets the given affix of the given bytes as a `&mut Self` without/// Analyzes whether a type is [`IntoBytes`]./// the [safety conditions] of `IntoBytes` and implements `IntoBytes` if it is/// sound to do so. This derive can be applied to structs and enums (see below/// for union support); e.g.:/// # use zerocopy_derive::{IntoBytes};/// #[derive(IntoBytes)]/// [safety conditions]: trait@IntoBytes#safety/// On Rust toolchains prior to 1.78.0, due to the way that the custom derive/// for `IntoBytes` is implemented, you may get an error like this:/// error[E0277]: the trait bound `(): PaddingFree<Foo, true>` is not satisfied///  1 | #[derive(IntoBytes)]///    |          ^^^^^^^^^ the trait `PaddingFree<Foo, true>` is not implemented for `()`///    = help: the following implementations were found:///                   <() as PaddingFree<T, false>>/// is illegal for `IntoBytes` types. Consider reducing the alignment of some/// fields by using types in the [`byteorder`] module, wrapping field types in/// [`Unalign`], adding explicit struct fields where those padding bytes would/// be, or using `#[repr(packed)]`. See the Rust Reference's page on [type/// layout] for more information about type layout and padding./// # Unions/// Currently, union bit validity is [up in the air][union-validity], and so/// zerocopy does not support `#[derive(IntoBytes)]` on unions by default./// However, implementing `IntoBytes` on a union type is likely sound on all/// existing Rust toolchains - it's just that it may become unsound in the/// future. You can opt-in to `#[derive(IntoBytes)]` support on unions by/// passing the unstable `zerocopy_derive_union_into_bytes` cfg:/// $ RUSTFLAGS='--cfg zerocopy_derive_union_into_bytes' cargo build/// However, it is your responsibility to ensure that this derive is sound on/// the specific versions of the Rust toolchain you are using! We make no/// stability or soundness guarantees regarding this cfg, and may remove it at/// any point./// We are actively working with Rust to stabilize the necessary language/// guarantees to support this in a forwards-compatible way, which will enable/// us to remove the cfg gate. As part of this effort, we need to know how much/// demand there is for this feature. If you would like to use `IntoBytes` on/// unions, [please let us know][discussion]./// [union-validity]: https://github.com/rust-lang/unsafe-code-guidelines/issues/438/// [discussion]: https://github.com/google/zerocopy/discussions/1802/// determine whether it is sound to implement `IntoBytes` for a given type./// manually implement `IntoBytes` for a type yourself, you don't need to read/// `IntoBytes` for that type:/// - If the type is a struct, its fields must be [`IntoBytes`]. Additionally:///     - if the type is `repr(transparent)` or `repr(packed)`, it is///       [`IntoBytes`] if its fields are [`IntoBytes`]; else,///     - if the type is `repr(C)` with at most one field, it is [`IntoBytes`]///       if its field is [`IntoBytes`]; else,///     - if the type has no generic parameters, it is [`IntoBytes`] if the type///       is sized and has no padding bytes; else,///     - if the type is `repr(C)`, its fields must be [`Unaligned`].///   - It must have no padding bytes.///   - Its fields must be [`IntoBytes`].// `IntoBytes` from being object safe. Note that other `IntoBytes` methods// signatures, or move them out of this trait so that `IntoBytes` is object/// use zerocopy::IntoBytes;/// #[derive(IntoBytes, Immutable)]/// let bytes = header.as_mut_bytes();"callers should check the return value to see if the operation succeeded"/// Writes a copy of `self` to `dst`./// If `dst.len() != size_of_val(self)`, `write_to` returns `Err`./// `Err` and leaves the target bytes unmodified:/// # use zerocopy::IntoBytes;/// assert!(write_result.is_err());// False positive: `&self -> &mut [u8]`/// Writes a copy of `self` to the prefix of `dst`./// of `dst`. If `dst.len() < size_of_val(self)`, it returns `Err`./// let mut insufficient_bytes = &mut [0, 0][..];/// let write_result = header.write_to_suffix(insufficient_bytes);/// assert_eq!(insufficient_bytes, [0, 0]);/// Writes a copy of `self` to the suffix of `dst`./// `dst`. If `dst.len() < size_of_val(self)`, it returns `Err`./// Types that can be converted to an immutable slice of initialized bytes./// Any `IntoBytes` type can be converted to a slice of initialized bytes of the/// same size. This is useful for efficiently serializing structured data as raw/// [`#[derive(IntoBytes)]`][derive]; e.g.:/// # use zerocopy_derive::IntoBytes;/// determine whether a type is `IntoBytes`. See the [derive/// *This section describes what is required in order for `T: IntoBytes`, and/// `IntoBytes` manually, and you don't plan on writing unsafe code that/// operates on `IntoBytes` types, then you don't need to read this section.*/// If `T: IntoBytes`, then unsafe code may assume that it is sound to treat any/// `t: T` as an immutable `[u8]` of length `size_of_val(t)`. If a type is/// marked as `IntoBytes` which violates this contract, it may cause undefined/// `#[derive(IntoBytes)]` only permits [types which satisfy these/// Analyzes whether a type is [`Unaligned`]./// the [safety conditions] of `Unaligned` and implements `Unaligned` if it is/// # use zerocopy_derive::Unaligned;/// #[derive(Unaligned)]/// #[repr(packed)]/// determine whether it is sound to implement `Unaligned` for a given type./// manually implement `Unaligned` for a type yourself, you don't need to read/// `Unaligned` for that type:/// - If the type is a struct or union:///   - If `repr(align(N))` is provided, `N` must equal 1.///   - If the type is `repr(C)` or `repr(transparent)`, all fields must be///     [`Unaligned`].///   - If the type is not `repr(C)` or `repr(transparent)`, it must be///     `repr(packed)` or `repr(packed(1))`.///   - It must be a field-less enum (meaning that all variants have no fields).///   - It must be `repr(i8)` or `repr(u8)`./// [safety conditions]: trait@Unaligned#safety/// [`#[derive(Unaligned)]`][derive]; e.g.:/// determine whether a type is `Unaligned`./// `Unaligned` manually, and you don't plan on writing unsafe code that/// operates on `Unaligned` types, then you don't need to read this section.*/// `#[derive(Unaligned)]` only permits [types which satisfy these/// Derives optimized [`PartialEq`] and [`Eq`] implementations./// This derive can be applied to structs and enums implementing both/// [`Immutable`] and [`IntoBytes`]; e.g.:/// # use zerocopy_derive::{ByteEq, Immutable, IntoBytes};/// #[derive(ByteEq, Immutable, IntoBytes)]/// The standard library's [`derive(Eq, PartialEq)`][derive@PartialEq] computes/// equality by individually comparing each field. Instead, the implementation/// of [`PartialEq::eq`] emitted by `derive(ByteHash)` converts the entirety of/// `self` and `other` to byte slices and compares those slices for equality./// This may have performance advantages./// Derives an optimized [`Hash`] implementation./// # use zerocopy_derive::{ByteHash, Immutable, IntoBytes};/// #[derive(ByteHash, Immutable, IntoBytes)]/// The standard library's [`derive(Hash)`][derive@Hash] produces hashes by/// individually hashing each field and combining the results. Instead, the/// implementations of [`Hash::hash()`] and [`Hash::hash_slice()`] generated by/// `derive(ByteHash)` convert the entirety of `self` to a byte slice and hashes/// it in a single call to [`Hasher::write()`]. This may have performance/// advantages./// [`Hash`]: core::hash::Hash/// [`Hash::hash()`]: core::hash::Hash::hash()/// [`Hash::hash_slice()`]: core::hash::Hash::hash_slice()/// Implements [`SplitAt`]./// This derive can be applied to structs; e.g.:test_from_zeros_onlytest_zst_count_preservedtest_try_from_bytes_try_read_fromtest_to_methods//   cargo -q run --manifest-path tools/Cargo.toml -p generate-readme > README.md//! *For an overview of what's changed from zerocopy 0.7, check out our [release//! notes][release-notes], which include a step-by-step upgrading guide.*//! *Have questions? Need more out of zerocopy? Submit a [customer request//! issue][customer-request-issue] or ask the maintainers on//! [GitHub][github-q-a] or [Discord][discord]!*//! [customer-request-issue]: https://github.com/google/zerocopy/issues/new/choose//! [release-notes]: https://github.com/google/zerocopy/discussions/1680//! [github-q-a]: https://github.com/google/zerocopy/discussions/categories/q-a//! [discord]: https://discord.gg/MAvWH2R6zk//! ##### Conversion Traits//! Zerocopy provides four derivable traits for zero-cost conversions://! - [`TryFromBytes`] indicates that a type may safely be converted from//!   certain byte sequences (conditional on runtime checks)//! - [`FromZeros`] indicates that a sequence of zero bytes represents a valid//! - [`IntoBytes`] indicates that a type may safely be converted *to* a byte//! These traits support sized types, slices, and [slice DSTs][slice-dsts].//! [slice-dsts]: KnownLayout#dynamically-sized-types//! ##### Marker Traits//! Zerocopy provides three derivable marker traits that do not provide any//! functionality themselves, but are required to call certain methods provided//! by the conversion traits://! - [`KnownLayout`] indicates that zerocopy can reason about certain layout//!   qualities of a type//! - [`Immutable`] indicates that a type is free from interior mutability,//!   except by ownership or an exclusive (`&mut`) borrow//! You should generally derive these marker traits whenever possible.//! ##### Conversion Macros//! Zerocopy provides six macros for safe casting between types://! - ([`try_`][try_transmute])[`transmute`] (conditionally) converts a value of//!   one type to a value of another type of the same size//! - ([`try_`][try_transmute_mut])[`transmute_mut`] (conditionally) converts a//!   mutable reference of one type to a mutable reference of another type of//!   the same size//! - ([`try_`][try_transmute_ref])[`transmute_ref`] (conditionally) converts a//!   mutable or immutable reference of one type to an immutable reference of//!   another type of the same size//! These macros perform *compile-time* size and alignment checks, meaning that//! unconditional casts have zero cost at runtime. Conditional casts do not need//! to validate size or alignment runtime, but do need to validate contents.//! These macros cannot be used in generic contexts. For generic conversions,//! use the methods defined by the [conversion traits](#conversion-traits).//! ##### Byteorder-Aware Numerics//! Zerocopy provides byte-order aware integer types that support these//! - **`alloc`**//! - **`std`**//!   By default, `zerocopy` is `no_std`. When the `std` feature is enabled, the//!   `std` crate is added as a dependency (ie, `no_std` is disabled), and//!   support for some `std` types is added. `std` implies `alloc`.//! - **`derive`**//!   necessary to depend on `zerocopy-derive` directly.//!   To avoid the risk of [duplicate import errors][duplicate-import-errors] if//!   one of your dependencies enables zerocopy's `derive` feature, import//!   derives as `use zerocopy_derive::*` rather than by name (e.g., `use//!   zerocopy_derive::FromBytes`).//! - **`simd`**//!   When the `simd` feature is enabled, `FromZeros`, `FromBytes`, and//!   `IntoBytes` impls are emitted for all stable SIMD types which exist on the//! - **`simd-nightly`**//! - **`float-nightly`**//!   Adds support for the unstable `f16` and `f128` types. These types are//!   not yet fully implemented and may not be supported on all platforms.//! [duplicate-import-errors]: https://github.com/google/zerocopy/issues/1587//! - **...not 'guessing' about Rust's semantics.**//! - **...rigorously testing our implementation.**//! - **...formally proving the correctness of our implementation.**//! # Thanks//! Zerocopy is maintained by engineers at Google and Amazon with help from//! [many wonderful contributors][contributors]. Thank you to everyone who has//! lent a hand in making Rust a little more secure!//! [contributors]: https://github.com/google/zerocopy/graphs/contributors// `clippy::incompatible_msrv` (implied by `clippy::suspicious`): This sometimes// has false positives, and we test on our MSRV in CI, so it doesn't help us// anyway.// NOTE: This attribute should have the effect of causing CI to fail if// `stdarch_x86_avx512` - which is currently stable in 1.89.0-nightly as of this// writing on 2025-06-10 - has its stabilization rolled back.// FIXME(#2583): Remove once `stdarch_x86_avx512` is stabilized in 1.89.0, and// 1.89.0 has been released as stable.// 1.89.0 has been released as stable. Replace with version detection for 1.89.0// (see #2574 for a draft implementation).// NOTE: This must be a macro (rather than a function with trait bounds)// because there's no way, in a generic context, to enforce that two types// have the same size. `core::mem::transmute` uses compiler magic to enforce// this so long as the types are concrete./// This macro behaves like an invocation of this function:/// const fn transmute<Src, Dst>(src: Src) -> Dst///     Src: IntoBytes,///     Dst: FromBytes,///     size_of::<Src>() == size_of::<Dst>(),/// However, unlike a function, this macro can only be invoked when the types of/// `Src` and `Dst` are completely concrete. The types `Src` and `Dst` are/// inferred from the calling context; they cannot be explicitly specified in/// Note that the `Src` produced by the expression `$e` will *not* be dropped./// Semantically, its bits will be copied into a new value of type `Dst`, the/// original `Src` will be forgotten, and the value of type `Dst` will be/// # `#![allow(shrink)]`/// If `#![allow(shrink)]` is provided, `transmute!` additionally supports/// transmutations that shrink the size of the value; e.g.:/// let u: u32 = transmute!(#![allow(shrink)] 0u64);/// assert_eq!(u, 0u32);/// # Use in `const` contexts/// This macro can be invoked in `const` contexts./// immutable reference of another type of the same size and compatible/// fn transmute_ref<'src, 'dst, Src, Dst>(src: &'src Src) -> &'dst Dst///     'src: 'dst,///     Src: IntoBytes + Immutable + ?Sized,///     Dst: FromBytes + Immutable + ?Sized,///     align_of::<Src>() >= align_of::<Dst>(),///     size_compatible::<Src, Dst>(),/// The types `Src` and `Dst` are inferred from the calling context; they cannot/// be explicitly specified in the macro invocation./// # Size compatibility/// `transmute_ref!` supports transmuting between `Sized` types or between/// unsized (i.e., `?Sized`) types. It supports any transmutation that preserves/// the number of bytes of the referent, even if doing so requires updating the/// metadata stored in an unsized "fat" reference:/// # use core::mem::size_of_val; // Not in the prelude on our MSRV/// let src: &[[u8; 2]] = &[[0, 1], [2, 3]][..];/// let dst: &[u8] = transmute_ref!(src);/// assert_eq!(src.len(), 2);/// assert_eq!(dst.len(), 4);/// assert_eq!(dst, [0, 1, 2, 3]);/// assert_eq!(size_of_val(src), size_of_val(dst));/// Violations of the alignment and size compatibility checks are detected/// *after* the compiler performs monomorphization. This has two important/// consequences./// First, it means that generic code will *never* fail these conditions:/// # use zerocopy::{transmute_ref, FromBytes, IntoBytes, Immutable};/// fn transmute_ref<Src, Dst>(src: &Src) -> &Dst///     Src: IntoBytes + Immutable,///     Dst: FromBytes + Immutable,///     transmute_ref!(src)/// Instead, failures will only be detected once generic code is instantiated/// with concrete types:/// # fn transmute_ref<Src, Dst>(src: &Src) -> &Dst/// #     Src: IntoBytes + Immutable,/// #     Dst: FromBytes + Immutable,/// #     transmute_ref!(src)/// let src: &u16 = &0;/// let dst: &u8 = transmute_ref(src);/// Second, the fact that violations are detected after monomorphization means/// that `cargo check` will usually not detect errors, even when types are/// concrete. Instead, `cargo build` must be used to detect such errors./// Transmuting between `Sized` types:/// Transmuting between unsized types:/// # use {zerocopy::*, zerocopy_derive::*};/// # type u16 = zerocopy::byteorder::native_endian::U16;/// # type u32 = zerocopy::byteorder::native_endian::U32;/// struct SliceDst<T, U> {///     t: T,///     u: [U],/// type Src = SliceDst<u32, u16>;/// type Dst = SliceDst<u16, u8>;/// let src = Src::ref_from_bytes(&[0, 1, 2, 3, 4, 5, 6, 7]).unwrap();/// let dst: &Dst = transmute_ref!(src);/// assert_eq!(src.t.as_bytes(), [0, 1, 2, 3]);/// assert_eq!(src.u.len(), 2);/// assert_eq!(src.u.as_bytes(), [4, 5, 6, 7]);/// assert_eq!(dst.t.as_bytes(), [0, 1]);/// assert_eq!(dst.u, [2, 3, 4, 5, 6, 7]);/// This macro can be invoked in `const` contexts only when `Src: Sized` and/// `Dst: Sized`./// Safely transmutes a mutable reference of one type to a mutable reference of/// another type of the same size and compatible alignment./// const fn transmute_mut<'src, 'dst, Src, Dst>(src: &'src mut Src) -> &'dst mut Dst///     Src: FromBytes + IntoBytes,///     Dst: FromBytes + IntoBytes,/// `transmute_mut!` supports transmuting between `Sized` types or between/// let src: &mut [[u8; 2]] = &mut [[0, 1], [2, 3]][..];/// let dst: &mut [u8] = transmute_mut!(src);/// let dst_size = size_of_val(dst);/// assert_eq!(size_of_val(src), dst_size);/// # use zerocopy::{transmute_mut, FromBytes, IntoBytes, Immutable};/// fn transmute_mut<Src, Dst>(src: &mut Src) -> &mut Dst///     transmute_mut!(src)/// # fn transmute_mut<Src, Dst>(src: &mut Src) -> &mut Dst/// #     Src: FromBytes + IntoBytes,/// #     Dst: FromBytes + IntoBytes,/// #     transmute_mut!(src)/// let src: &mut u16 = &mut 0;/// let dst: &mut u8 = transmute_mut(src);/// let mut bytes = [0, 1, 2, 3, 4, 5, 6, 7];/// let src = Src::mut_from_bytes(&mut bytes[..]).unwrap();/// let dst: &mut Dst = transmute_mut!(src);try_transmute/// Conditionally transmutes a value of one type to a value of another type of/// fn try_transmute<Src, Dst>(src: Src) -> Result<Dst, ValidityError<Src, Dst>>///     Dst: TryFromBytes,/// # use zerocopy::*;/// // 0u8 → bool = false/// assert_eq!(try_transmute!(0u8), Ok(false));/// // 1u8 → bool = true///  assert_eq!(try_transmute!(1u8), Ok(true));/// // 2u8 → bool = error///     try_transmute!(2u8),///     Result::<bool, _>::Err(ValidityError { .. })try_transmute_ref/// Conditionally transmutes a mutable or immutable reference of one type to an/// fn try_transmute_ref<Src, Dst>(src: &Src) -> Result<&Dst, ValidityError<&Src, Dst>>///     Dst: TryFromBytes + Immutable,/// assert_eq!(try_transmute_ref!(&0u8), Ok(&false));///  assert_eq!(try_transmute_ref!(&1u8), Ok(&true));///     try_transmute_ref!(&2u8),///     Result::<&bool, _>::Err(ValidityError { .. })/// `try_transmute_ref!` is used to transmute from a type of lower alignment to/// a type of higher alignment is somewhat confusing. For example, the following/// let increase_alignment: Result<&u16, _> = zerocopy::try_transmute_ref!(&[0u8; 2]);///  --> example.rs:1:47/// 1 |     let increase_alignment: Result<&u16, _> = zerocopy::try_transmute_ref!(&[0u8; 2]);///   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^///   = note: this error originates in the macro `$crate::assert_align_gt_eq` which comes from the expansion of the macro `zerocopy::try_transmute_ref` (in Nightly builds, run with -Z macro-backtrace for more info)/// ```try_transmute_mut/// Conditionally transmutes a mutable reference of one type to a mutable/// reference of another type of the same size and compatible alignment./// fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&mut Src, Dst>>///     Dst: TryFromBytes + IntoBytes,/// let src = &mut 0u8;/// assert_eq!(try_transmute_mut!(src), Ok(&mut false));/// let src = &mut 1u8;///  assert_eq!(try_transmute_mut!(src), Ok(&mut true));/// let src = &mut 2u8;///     try_transmute_mut!(src),///     Result::<&mut bool, _>::Err(ValidityError { .. })/// let src = &mut [0u8; 2];/// let increase_alignment: Result<&mut u16, _> = zerocopy::try_transmute_mut!(src);///  --> example.rs:2:51/// 2 |     let increase_alignment: Result<&mut u16, _> = zerocopy::try_transmute_mut!(src);///   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^///   = note: this error originates in the macro `$crate::assert_align_gt_eq` which comes from the expansion of the macro `zerocopy::try_transmute_mut` (in Nightly builds, run with -Z macro-backtrace for more info)/// [`FromBytes`]: crate::FromBytes/// [`byteorder`]: crate::byteordercryptocorrosion_derive_traitsNkl// A `Sized` type which doesn't implement `KnownLayout` (it is "not// `KnownLayout`", or `Nkl`).// This permits us to test that `transmute_ref!` and `transmute_mut!` work// for types which are `Sized + !KnownLayout`. When we added support for// slice DSTs in #1924, this new support relied on `KnownLayout`, but we// need to make sure to remain backwards-compatible with code which uses// these macros with types which are `!KnownLayout`.test_try_transmutetest_try_transmute_reftest_try_transmute_muttest_cryptocorrosion_derive_traits_def/// 0. If `ptr`'s referent is not zero sized, then `ptr` has valid///    provenance for its referent, which is entirely contained in some///    Rust allocation, `A`./// 1. If `ptr`'s referent is not zero sized, `A` is guaranteed to live///    for at least `'a`./// # Postconditions/// By virtue of these invariants, code may assume the following, which/// are logical implications of the invariants:/// - `ptr`'s referent is not larger than `isize::MAX` bytes \[1\]/// - `ptr`'s referent does not wrap around the address space \[1\]/// \[1\] Per <https://doc.rust-lang.org/1.85.0/std/ptr/index.html#allocated-object>:///   For any allocated object with `base` address, `size`, and a set of///   `addresses`, the following are guaranteed:///   ...///   - `size <= isize::MAX`///   As a consequence of these guarantees, given any address `a` within///   the set of addresses of an allocated object:///   - It is guaranteed that, given `o = a - base` (i.e., the offset of///     `a` within the allocated object), `base + o` will not wrap around///     the address space (in other words, will not overflow `usize`)// SAFETY: `&'a UnsafeCell<T>` is covariant in `'a` and invariant in `T`// [1]. We use this construction rather than the equivalent `&mut T`,// because our MSRV of 1.65 prohibits `&mut` types in const contexts.// [1] https://doc.rust-lang.org/1.81.0/reference/subtyping.html#variance/// The inner pointer stored inside a [`Ptr`][crate::Ptr]./// `PtrInner<'a, T>` is [covariant] in `'a` and invariant in `T`./// Constructs a `Ptr` from a [`NonNull`]./// The caller promises that:/// Converts this `PtrInner<T>` to a [`NonNull<T>`]./// Note that this method does not consume `self`. The caller should/// watch out for `unsafe` code which uses the returned `NonNull` in a/// way that violates the safety invariants of `self`./// Constructs a `PtrInner` from a reference./// Constructs a `PtrInner` from a mutable reference.cast_sized/// `U` must not be larger than the size of `self`'s referent./// Extracts the metadata of this `ptr`.with_meta/// Produces a `PtrInner` with the same address and provenance as `self` but/// the given `meta`./// The caller promises that if `self`'s referent is not zero sized, then/// a pointer constructed from its address with the given `meta` metadata/// will address a subset of the allocation pointed to by `self`./// Splits `T` in two.///  - `l_len.get() <= self.meta()`./// ## (Non-)Overlap/// Given `let (left, right) = ptr.split_at(l_len)`, it is guaranteed that/// `left` and `right` are contiguous and non-overlapping if/// `l_len.padding_needed_for() == 0`. This is true for all `[T]`./// If `l_len.padding_needed_for() != 0`, then the left pointer will overlap/// the right pointer to satisfy `T`'s padding requirements.trailing_slice/// Produces the trailing slice of `self`.slice_unchecked/// Creates a pointer which addresses the given `range` of self./// `range` is a valid range (`start <= end`) and `end <= self.meta()`./// Iteratively projects the elements `PtrInner<T>` from `PtrInner<[T]>`./// Casts this pointer-to-array into a slice./// Callers may assume that the returned `PtrInner` references the same/// address and length as `self`./// If `U` is a slice DST and pointer metadata (`meta`) is provided, then/// the cast will only succeed if it would produce an object with the given/// Returns `None` if the resulting `U` would be invalidly-aligned, if no/// `U` can fit in `self`, or if the provided pointer metadata describes an/// invalid instance of `U`. On success, returns a pointer to the/// caller may assume that, if `try_cast_into` returns `Some((ptr,/// remainder))`, then `ptr` and `remainder` refer to non-overlapping byte/// ranges within `self`, and that `ptr` and `remainder` entirely cover/// `self`. Finally:/// - If this is a prefix cast, `ptr` has the same address as `self`./// - If this is a suffix cast, `remainder` has the same address as `self`.test_metatest_split_attest_trailing_sliceAliasingInvariants/// The invariants of a [`Ptr`][super::Ptr].AAIS_EXCLUSIVE/// Is `Self` [`Exclusive`]?/// The aliasing invariant of a [`Ptr`][super::Ptr]./// All aliasing invariants must permit reading from the bytes of a pointer's/// referent which are not covered by [`UnsafeCell`]s./// The alignment invariant of a [`Ptr`][super::Ptr]./// The validity invariant of a [`Ptr`][super::Ptr]./// In this section, we will use `Ptr<T, V>` as a shorthand for `Ptr<T, I:/// Invariants<Validity = V>>` for brevity./// Each `V: Validity` defines a set of bit values which may appear in the/// referent of a `Ptr<T, V>`, denoted `S(T, V)`. Each `V: Validity`, in its/// documentation, provides a definition of `S(T, V)` which must be valid for/// all `T: ?Sized`. Any `V: Validity` must guarantee that this set is only a/// function of the *bit validity* of the referent type, `T`, and not of any/// other property of `T`. As a consequence, given `V: Validity`, `T`, and `U`/// where `T` and `U` have the same bit validity, `S(V, T) = S(V, U)`./// It is guaranteed that the referent of any `ptr: Ptr<T, V>` is a member of/// `S(T, V)`. Unsafe code must ensure that this guarantee will be upheld for/// any existing `Ptr`s or any `Ptr`s that that code creates./// An important implication of this guarantee is that it restricts what/// transmutes are sound, where "transmute" is used in this context to refer to/// changing the referent type or validity invariant of a `Ptr`, as either/// change may change the set of bit values permitted to appear in the referent./// In particular, the following are necessary (but not sufficient) conditions/// in order for a transmute from `src: Ptr<T, V>` to `dst: Ptr<U, W>` to be/// sound:/// - If `S(T, V) = S(U, W)`, then no restrictions apply; otherwise,/// - If `dst` permits mutation of its referent (e.g. via `Exclusive` aliasing///   or interior mutation under `Shared` aliasing), then it must hold that///   `S(T, V) ⊇ S(U, W)` - in other words, the transmute must not expand the///   set of allowed referent bit patterns. A violation of this requirement///   would permit using `dst` to write `x` where `x ∈ S(U, W)` but `x ∉ S(T,///   V)`, which would violate the guarantee that `src`'s referent may only///   contain values in `S(T, V)`./// - If the referent may be mutated without going through `dst` while `dst` is///   live (e.g. via interior mutation on a `Shared`-aliased `Ptr` or `&`///   reference), then it must hold that `S(T, V) ⊆ S(U, W)` - in other words,///   the transmute must not shrink the set of allowed referent bit patterns. A///   violation of this requirement would permit using `src` or another///   mechanism (e.g. a `&` reference used to derive `src`) to write `x` where///   `x ∈ S(T, V)` but `x ∉ S(U, W)`, which would violate the guarantee that///   `dst`'s referent may only contain values in `S(U, W)`./// An [`Aliasing`] invariant which is either [`Shared`] or [`Exclusive`]./// Given `A: Reference`, callers may assume that either `A = Shared` or `A =/// Exclusive`./// The `Ptr<'a, T>` adheres to the aliasing rules of a `&'a T`./// The referent of a shared-aliased `Ptr` may be concurrently referenced by any/// number of shared-aliased `Ptr` or `&T` references, or by any number of/// `Ptr<U>` or `&U` references as permitted by `T`'s library safety invariants,/// and may not be concurrently referenced by any exclusively-aliased `Ptr`s or/// `&mut` references. The referent must not be mutated, except via/// [`UnsafeCell`]s, and only when permitted by `T`'s library safety invariants./// The `Ptr<'a, T>` adheres to the aliasing rules of a `&'a mut T`./// The referent of an exclusively-aliased `Ptr` may not be concurrently/// referenced by any other `Ptr`s or references, and may not be accessed (read/// or written) other than via this `Ptr`./// It is unknown whether the pointer is aligned./// The referent is aligned: for `Ptr<T>`, the referent's address is a multiple/// of the `T`'s alignment./// Any bit pattern is allowed in the `Ptr`'s referent, including uninitialized// SAFETY: `Uninit`'s validity is well-defined for all `T: ?Sized`, and is not a// function of any property of `T` other than its bit validity (in fact, it's// not even a property of `T`'s bit validity, but this is more than we are// required to uphold).AsInitialized/// The byte ranges initialized in `T` are also initialized in the referent of a/// `Ptr<T>`./// Formally: uninitialized bytes may only be present in `Ptr<T>`'s referent/// where they are guaranteed to be present in `T`. This is a dynamic property:/// if, at a particular byte offset, a valid enum discriminant is set, the/// subsequent bytes may only have uninitialized bytes as specified by the/// corresponding enum./// Formally, given `len = size_of_val_raw(ptr)`, at every byte offset, `b`, in/// the range `[0, len)`:/// - If, in any instance `t: T` of length `len`, the byte at offset `b` in `t`///   is initialized, then the byte at offset `b` within `*ptr` must be///   initialized./// - Let `c` be the contents of the byte range `[0, b)` in `*ptr`. Let `S` be///   the subset of valid instances of `T` of length `len` which contain `c` in///   the offset range `[0, b)`. If, in any instance of `t: T` in `S`, the byte///   at offset `b` in `t` is initialized, then the byte at offset `b` in `*ptr`///   Pragmatically, this means that if `*ptr` is guaranteed to contain an enum///   type at a particular offset, and the enum discriminant stored in `*ptr`///   corresponds to a valid variant of that enum type, then it is guaranteed///   that the appropriate bytes of `*ptr` are initialized as defined by that///   variant's bit validity (although note that the variant may contain another///   enum type, in which case the same rules apply depending on the state of///   its discriminant, and so on recursively).// SAFETY: `AsInitialized`'s validity is well-defined for all `T: ?Sized`, and// is not a function of any property of `T` other than its bit validity./// The byte ranges in the referent are fully initialized. In other words, if/// the referent is `N` bytes long, then it contains a bit-valid `[u8; N]`.// SAFETY: `Initialized`'s validity is well-defined for all `T: ?Sized`, and is// not a function of any property of `T` other than its bit validity (in fact,// it's not even a property of `T`'s bit validity, but this is more than we are/// The referent of a `Ptr<T>` is valid for `T`, upholding bit validity and any/// library safety invariants.// SAFETY: `Valid`'s validity is well-defined for all `T: ?Sized`, and is not a// function of any property of `T` other than its bit validity.SVCastableFrom/// `DT: CastableFrom<ST, SV, DV>` is sound if `SV = DV = Uninit` or `SV = DV =/// Initialized`.DT// SAFETY: `SV = DV = Uninit`.// SAFETY: `SV = DV = Initialized`./// [`Ptr`](crate::Ptr) referents that permit unsynchronized read operations./// `T: Read<A, R>` implies that a pointer to `T` with aliasing `A` permits/// unsynchronized read operations. This can be because `A` is [`Exclusive`] or/// because `T` does not permit interior mutation./// `T: Read<A, R>` if either of the following conditions holds:/// - `A` is [`Exclusive`]/// - `T` implements [`Immutable`](crate::Immutable)/// As a consequence, if `T: Read<A, R>`, then any `Ptr<T, (A, ...)>` is/// permitted to perform unsynchronized reads from its referent./// Unsynchronized reads are permitted because only one live [`Ptr`](crate::Ptr)/// or reference may exist to the referent bytes at a time./// Unsynchronized reads are permitted because no live [`Ptr`](crate::Ptr)s or/// references permit interior mutation.//! The parameterized invariants of a [`Ptr`][super::Ptr].//! Invariants are encoded as ([`Aliasing`], [`Alignment`], [`Validity`])//! triples implementing the [`Invariants`] trait./// A shorthand for a maybe-valid, maybe-aligned reference. Used as the argument/// to [`TryFromBytes::is_bit_valid`]./// [`TryFromBytes::is_bit_valid`]: crate::TryFromBytes::is_bit_validis_zeroed/// Checks if the referent is zeroed.//! Abstractions over raw pointers.MutationCompatibleSizeEqTransmuteFromPtr/// 0. `ptr` conforms to the aliasing invariant of///    [`I::Aliasing`](invariant::Aliasing)./// 1. `ptr` conforms to the alignment invariant of///    [`I::Alignment`](invariant::Alignment)./// 2. `ptr` conforms to the validity invariant of///    [`I::Validity`](invariant::Validity).// SAFETY: `PtrInner<'a, T>` is covariant in `'a` and invariant in `T`._invariants/// `Ptr<T>` is similar to [`NonNull<T>`], but it is more restrictive in the/// following ways (note that these requirements only hold of non-zero-sized/// referents):/// - It must derive from a valid allocation.///   allocation from which it derives.///     which does not overflow `isize`./// Depending on how `Ptr` is parameterized, it may have additional/// invariants:/// - `ptr` conforms to the aliasing invariant of///   [`I::Aliasing`](invariant::Aliasing)./// - `ptr` conforms to the alignment invariant of///   [`I::Alignment`](invariant::Alignment)./// - `ptr` conforms to the validity invariant of///   [`I::Validity`](invariant::Validity)./// `Ptr<'a, T>` is [covariant] in `'a` and invariant in `T`./// [`NonNull<T>`]: core::ptr::NonNull/// Constructs a new `Ptr` from a [`PtrInner`]./// Converts this `Ptr<T>` to a [`PtrInner<T>`]./// watch out for `unsafe` code which uses the returned value in a way/// that violates the safety invariants of `self`./// Module used to gate access to [`Ptr`]'s fields.// This is a false positive on our MSRV toolchain./// SAFETY: Shared pointers are safely `Copy`. `Ptr`'s other invariants/// (besides aliasing) are unaffected by the number of references that exist/// to `Ptr`'s referent. The notable cases are:/// - Alignment is a property of the referent type (`T`) and the address,///   both of which are unchanged/// - Let `S(T, V)` be the set of bit values permitted to appear in the///   referent of a `Ptr<T, I: Invariants<Validity = V>>`. Since this copy///   does not change `I::Validity` or `T`, `S(T, I::Validity)` is also///   unchanged.///   ///   We are required to guarantee that the referents of the original `Ptr`///   and of the copy (which, of course, are actually the same since they///   live in the same byte address range) both remain in the set `S(T,///   I::Validity)`. Since this invariant holds on the original `Ptr`, it///   cannot be violated by the original `Ptr`, and thus the original `Ptr`///   cannot be used to violate this invariant on the copy. The inverse///   holds as well./// SAFETY: See the safety comment on `Copy`._external/// External trait implementations on [`Ptr`]./// Constructs a `Ptr` from a shared reference./// `&'a T` → `Ptr<'a, T>`/// Constructs a `Ptr` from an exclusive reference./// `&'a mut T` → `Ptr<'a, T>`/// Converts `self` to a shared reference.// This consumes `self`, not `&self`, because `self` is, logically, a// pointer. For `I::Aliasing = invariant::Shared`, `Self: Copy`, and so// this doesn't prevent the caller from still using the pointer after// calling `as_ref`./// `Ptr<'a, T>` → `&'a T`/// Reborrows `self`, producing another `Ptr`./// Since `self` is borrowed immutably, this prevents any mutable/// methods from being called on `self` as long as the returned `Ptr`// Allows us to name the lifetime in the safety comment below./// Converts `self` to a mutable reference./// `Ptr<'a, T>` → `&'a mut T`recall_validitytransmute_unchecked/// Casts to a different (unsized) target type without checking interior/// mutability./// Callers should prefer [`cast_unsized`] where possible./// [`cast_unsized`]: Ptr::cast_unsized/// The caller promises that `u = cast(p)` is a pointer cast with the/// following properties:/// - `u` addresses a subset of the bytes addressed by `p`/// - `u` has the same provenance as `p`/// - If `I::Aliasing` is [`Shared`], it must not be possible for safe///   code, operating on a `&T` and `&U` with the same referent///   simultaneously, to cause undefined behavior/// - It is sound to transmute a pointer of type `T` with aliasing///   `I::Aliasing` and validity `I::Validity` to a pointer of type `U`///   with aliasing `I::Aliasing` and validity `V`. This is a subtle///   soundness requirement that is a function of `T`, `U`,///   `I::Aliasing`, `I::Validity`, and `V`, and may depend upon the///   presence, absence, or specific location of `UnsafeCell`s in `T`///   and/or `U`. See [`Validity`] for more details./// `Ptr<'a, T>` → `Ptr<'a, U>`into_unalign/// Converts a `Ptr` an unaligned `T` into a `Ptr` to an aligned/// `Unalign<T>`./// `Ptr<'a, T, (_, _, _)>` → `Ptr<'a, Unalign<T>, (_, Aligned, _)>`/// Reads the referent.unaligned_as_ref/// Views the value as an aligned reference./// This is only available if `T` is [`Unaligned`]._conversions/// Methods for converting to and from `Ptr` and Rust's safe reference types.TryTransmuteFromPtrinto_exclusive_or_pme/// Returns a `Ptr` with [`Exclusive`] aliasing if `self` already has/// `Exclusive` aliasing, or generates a compile-time assertion failure./// This allows code which is generic over aliasing to down-cast to a/// concrete aliasing./// [`Exclusive`]: crate::pointer::invariant::Exclusiveassume_invariants/// Assumes that `self` satisfies the invariants `H`./// The caller promises that `self` satisfies the invariants `H`.unify_invariants/// Helps the type system unify two distinct invariant types which are/// actually the same.assume_aliasing/// Assumes that `self` satisfies the aliasing requirement of `A`./// The caller promises that `self` satisfies the aliasing requirement/// of `A`.assume_exclusive/// Assumes `self` satisfies the aliasing requirement of [`Exclusive`]./// of `Exclusive`.assume_alignment/// Assumes that `self`'s referent is validly-aligned for `T` if/// required by `A`./// The caller promises that `self`'s referent conforms to the alignment/// invariant of `T` if required by `A`.try_into_aligned/// Checks the `self`'s alignment at runtime, returning an aligned `Ptr`bikeshed_recall_aligned/// Recalls that `self`'s referent is validly-aligned for `T`.// FIXME(#859): Reconsider the name of this method before making it// public.assume_validity/// Assumes that `self`'s referent conforms to the validity requirement/// of `V`./// The caller promises that `self`'s referent conforms to the validity/// requirement of `V`.assume_initialized/// A shorthand for `self.assume_validity<invariant::Initialized>()`./// The caller promises to uphold the safety preconditions of/// `self.assume_validity<invariant::Initialized>()`.assume_valid/// A shorthand for `self.assume_validity<Valid>()`./// `self.assume_validity<Valid>()`.bikeshed_recall_initialized_from_bytes/// Recalls that `self`'s referent is initialized.bikeshed_recall_initialized_immutabletry_into_valid/// Checks that `self`'s referent is validly initialized for `T`,/// returning a `Ptr` with `Valid` on success./// This method will panic if/// [`T::is_bit_valid`][TryFromBytes::is_bit_valid] panics./// On error, unsafe code may rely on this method's returned/// `ValidityError` containing `self`.forget_aligned/// Forgets that `self`'s referent is validly-aligned for `T`._transitions/// State transitions between invariants.cast_unsized_unchecked/// `cast_unsized_unchecked` guarantees that the pointer passed to/// `cast` will reference a byte sequence which is either contained/// inside a single allocated object or is zero sized. In either case,/// this means that its size will fit in an `isize` and it will not wrap/// around the address space./// Casts this pointer-to-initialized into a pointer-to-bytes./// If `U` is a slice DST and pointer metadata (`meta`) is provided,/// then the cast will only succeed if it would produce an object with/// the given metadata./// Returns `None` if the resulting `U` would be invalidly-aligned, if/// no `U` can fit in `self`, or if the provided pointer metadata/// describes an invalid instance of `U`. On success, returns a pointer/// to the largest-possible `U` which fits in `self`./// `Some((ptr, remainder))`, then `ptr` and `remainder` refer to/// non-overlapping byte ranges within `self`, and that `ptr` and/// `remainder` entirely cover `self`. Finally:/// - If this is a suffix cast, `remainder` has the same address as///   `self`./// For caller convenience, these methods are generic over alignment/// invariant. In practice, the referent is always well-aligned, because the/// alignment of `[u8]` is 1./// Converts this `Ptr` into a pointer to the underlying data./// This call borrows the `UnsafeCell` mutably (at compile-time) which/// guarantees that we possess the only reference./// This is like [`UnsafeCell::get_mut`], but for `Ptr`./// [`UnsafeCell::get_mut`]: core::cell::UnsafeCell::get_mut_casts/// Casts of the referent type./// Iteratively projects the elements `Ptr<T>` from `Ptr<[T]>`./// The number of slice elements in the object referenced by `self`._project/// Projections through the referent.// Needed on our MSRV, but considered unused on later toolchains.// - If `size_of::<T>() == 0`, `N == 4`// - Else, `N == 4 * size_of::<T>()`// Each test will be run for each metadata in `metas`.// Each test case becomes its own `#[test]` function. We do this because// this test in particular takes far, far longer to execute under Miri// than all of our other tests combined. Previously, we had these// execute sequentially in a single test function. We run Miri tests in// parallel in CI, but this test being sequential meant that most of// that parallelism was wasted, as all other tests would finish in a// fraction of the total execution time, leaving this test to execute on// a single thread for the remainder of the test. By putting each test// case in its own function, we permit better use of available// parallelism.empty_tuple// This test is designed so that if `Ptr::try_cast_into_xxx` are// buggy, it will manifest as unsoundness that Miri can detect.test_ptr_try_cast_into_soundnesstest_try_cast_into_explicit_count/// Transmutations which are sound to attempt, conditional on validating the bit/// validity of the destination type./// If a `Ptr` transmutation is `TryTransmuteFromPtr`, then it is sound to/// perform that transmutation so long as some additional mechanism is used to/// validate that the referent is bit-valid for the destination type. That/// validation mechanism could be a type bound (such as `TransmuteFrom`) or a/// runtime validity check./// ## Post-conditions/// Given `Dst: TryTransmuteFromPtr<Src, A, SV, DV, _>`, callers may assume the/// Given `src: Ptr<'a, Src, (A, _, SV)>`, if the referent of `src` is/// `DV`-valid for `Dst`, then it is sound to transmute `src` into `dst: Ptr<'a,/// Dst, (A, Unaligned, DV)>` by preserving pointer address and metadata./// ## Pre-conditions/// Given `src: Ptr<Src, (A, _, SV)>` and `dst: Ptr<Dst, (A, Unaligned, DV)>`,/// `Dst: TryTransmuteFromPtr<Src, A, SV, DV, _>` is sound if all of the/// following hold:/// - Forwards transmutation: Either of the following hold:///   - So long as `dst` is active, no mutation of `dst`'s referent is allowed///     except via `dst` itself///   - The set of `DV`-valid `Dst`s is a superset of the set of `SV`-valid///     `Src`s/// - Reverse transmutation: Either of the following hold:///   - `dst` does not permit mutation of its referent///   - The set of `DV`-valid `Dst`s is a subset of the set of `SV`-valid `Src`s/// - No safe code, given access to `src` and `dst`, can cause undefined///   behavior: Any of the following hold:///   - `A` is `Exclusive`///   - `Src: Immutable` and `Dst: Immutable`///   - It is sound for shared code to operate on a `&Src` and `&Dst` which///     reference the same byte range at the same time/// ## Proof/// Given:/// - `src: Ptr<'a, Src, (A, _, SV)>`/// - `src`'s referent is `DV`-valid for `Dst`/// - `Dst: SizeEq<Src>`/// We are trying to prove that it is sound to perform a pointer address- and/// metadata-preserving transmute from `src` to a `dst: Ptr<'a, Dst, (A,/// Unaligned, DV)>`. We need to prove that such a transmute does not violate/// any of `src`'s invariants, and that it satisfies all invariants of the/// destination `Ptr` type./// First, all of `src`'s `PtrInner` invariants are upheld. `src`'s address and/// metadata are unchanged, so:/// - If its referent is not zero sized, then it still has valid provenance for///   its referent, which is still entirely contained in some Rust allocation,///   `A`/// - If its referent is not zero sized, `A` is guaranteed to live for at least///   `'a`/// Since `Dst: SizeEq<Src>`, and since `dst` has the same address and metadata/// as `src`, `dst` addresses the same byte range as `src`. `dst` also has the/// same lifetime as `src`. Therefore, all of the `PtrInner` invariants/// mentioned above also hold for `dst`./// Second, since `src`'s address is unchanged, it still satisfies its/// alignment. Since `dst`'s alignment is `Unaligned`, it trivially satisfies/// its alignment./// Third, aliasing is either `Exclusive` or `Shared`:/// - If it is `Exclusive`, then both `src` and `dst` satisfy `Exclusive`///   aliasing trivially: since `src` and `dst` have the same lifetime, `src` is///   inaccessible so long as `dst` is alive, and no other live `Ptr`s or///   references may reference the same referent./// - If it is `Shared`, then either:///   - `Src: Immutable` and `Dst: Immutable`, and so `UnsafeCell`s trivially///     cover the same byte ranges in both types.///   - It is explicitly sound for safe code to operate on a `&Src` and a `&Dst`///     pointing to the same byte range at the same time./// Fourth, `src`'s validity is satisfied. By invariant, `src`'s referent began/// as an `SV`-valid `Src`. It is guaranteed to remain so, as either of the/// - `dst` does not permit mutation of its referent./// - The set of `DV`-valid `Dst`s is a superset of the set of `SV`-valid///   `Src`s. Thus, any value written via `dst` is guaranteed to be `SV`-valid///   for `Src`./// Fifth, `dst`'s validity is satisfied. It is a given of this proof that the/// referent is `DV`-valid for `Dst`. It is guaranteed to remain so, as either/// of the following hold:/// - So long as `dst` is active, no mutation of the referent is allowed except///   via `dst` itself.///   `Src`s. Thus, any value written via `src` is guaranteed to be a `DV`-valid///   `Dst`.BecauseMutationCompatibleTransmuteFrom// - Forwards transmutation: By `Dst: MutationCompatible<Src, A, SV, DV, _>`, we//   know that at least one of the following holds://   - So long as `dst: Ptr<Dst>` is active, no mutation of its referent is//     allowed except via `dst` itself if either of the following hold://     - Aliasing is `Exclusive`, in which case, so long as the `Dst` `Ptr`//       exists, no mutation is permitted except via that `Ptr`//     - Aliasing is `Shared`, `Src: Immutable`, and `Dst: Immutable`, in which//       case no mutation is possible via either `Ptr`//   - `Dst: TransmuteFrom<Src, SV, DV>`. Since `Dst: SizeEq<Src>`, this bound//     guarantees that the set of `DV`-valid `Dst`s is a supserset of the set of//     `SV`-valid `Src`s.// - Reverse transmutation: `Src: TransmuteFrom<Dst, DV, SV>`. Since `Dst://   SizeEq<Src>`, this guarantees that the set of `DV`-valid `Dst`s is a subset//   of the set of `SV`-valid `Src`s.// - No safe code, given access to `src` and `dst`, can cause undefined//   behavior: By `Dst: MutationCompatible<Src, A, SV, DV, _>`, at least one of//   the following holds://   - `A` is `Exclusive`//   - `Src: Immutable` and `Dst: Immutable`//   - `Dst: InvariantsEq<Src>`, which guarantees that `Src` and `Dst` have the//     same invariants, and have `UnsafeCell`s covering the same byte ranges// - Forwards transmutation: Since aliasing is `Shared` and `Src: Immutable`,//   `src` does not permit mutation of its referent.// - Reverse transmutation: Since aliasing is `Shared` and `Dst: Immutable`,//   `dst` does not permit mutation of its referent.//   behavior: `Src: Immutable` and `Dst: Immutable`/// Denotes that `src: Ptr<Src, (A, _, SV)>` and `dst: Ptr<Self, (A, _, DV)>`,/// referencing the same referent at the same time, cannot be used by safe code/// to break library safety invariants of `Src` or `Self`./// At least one of the following must hold:/// - `Src: Read<A, _>` and `Self: Read<A, _>`/// - `Self: InvariantsEq<Src>`, and, for some `V`:///   - `Dst: TransmuteFrom<Src, V, V>`///   - `Src: TransmuteFrom<Dst, V, V>`BecauseRead// SAFETY: `Src: Read<A, _>` and `Dst: Read<A, _>`.InvariantsEq/// Denotes that two types have the same invariants./// It is sound for safe code to operate on a `&T` and a `&Self` pointing to the/// same referent at the same time - no such safe code can cause undefined// SAFETY: Trivially sound to have multiple `&T` pointing to the same referent.BecauseInvariantsEq// SAFETY: `Dst: InvariantsEq<Src> + TransmuteFrom<Src, SV, DV>`, and `Src:// TransmuteFrom<Dst, DV, SV>`.unsafe_impl_invariants_eqimpl_transitive_transmute_from// SAFETY: `ManuallyDrop<T>` has the same size and bit validity as `T` [1], and// implements `Deref<Target = T>` [2]. Thus, it is already possible for safe// code to obtain a `&T` and a `&ManuallyDrop<T>` to the same referent at the// same time.// [1] Per https://doc.rust-lang.org/1.81.0/std/mem/struct.ManuallyDrop.html://   `ManuallyDrop<T>` is guaranteed to have the same layout and bit//   validity as `T`// [2] https://doc.rust-lang.org/1.81.0/std/mem/struct.ManuallyDrop.html#impl-Deref-for-ManuallyDrop%3CT%3E// SAFETY: See previous safety comment./// Transmutations which are always sound./// `TransmuteFromPtr` is a shorthand for [`TryTransmuteFromPtr`] and/// [`TransmuteFrom`]./// `Dst: TransmuteFromPtr<Src, A, SV, DV, _>` is equivalent to `Dst:/// TryTransmuteFromPtr<Src, A, SV, DV, _> + TransmuteFrom<Src, SV, DV>`.// SAFETY: The `where` bounds are equivalent to the safety invariant on// `TransmuteFromPtr`./// Denotes that any `SV`-valid `Src` may soundly be transmuted into a/// `DV`-valid `Self`./// Given `src: Ptr<Src, (_, _, SV)>` and `dst: Ptr<Dst, (_, _, DV)>`, if the/// referents of `src` and `dst` are the same size, then the set of bit patterns/// allowed to appear in `src`'s referent must be a subset of the set allowed to/// appear in `dst`'s referent./// If the referents are not the same size, then `Dst: TransmuteFrom<Src, SV,/// DV>` conveys no safety guarantee./// `T` and `Self` must have the same vtable kind (`Sized`, slice DST, `dyn`,/// etc) and have the same size. In particular:/// - If `T: Sized` and `Self: Sized`, then their sizes must be equal/// - If `T: ?Sized` and `Self: ?Sized`, then it must be the case that, given///   any `t: PtrInner<'_, T>`, `<Self as SizeEq<T>>::cast_from_raw(t)` produces///   a pointer which addresses the same number of bytes as `t`. *Note that it///   is **not** guaranteed that an `as` cast preserves referent size: it may be///   the case that `cast_from_raw` modifies the pointer's metadata in order to///   preserve referent size, which an `as` cast does not do.*// SAFETY: `T` trivially has the same size and vtable kind as `T`, and since// pointer `*mut T -> *mut T` pointer casts are no-ops, this cast trivially// preserves referent size (when `T: ?Sized`).// SAFETY: Since `Src: IntoBytes`, the set of valid `Src`'s is the set of// initialized bit patterns, which is exactly the set allowed in the referent of// any `Initialized` `Ptr`.// SAFETY: Since `Dst: FromBytes`, any initialized bit pattern may appear in the// referent of a `Ptr<Dst, (_, _, Valid)>`. This is exactly equal to the set of// bit patterns which may appear in the referent of any `Initialized` `Ptr`.// SAFETY: The set of allowed bit patterns in the referent of any `Initialized`// `Ptr` is the same regardless of referent type.// SAFETY: A `Dst` with validity `Uninit` permits any byte sequence, and// therefore can be transmuted from any value.// - `ManuallyDrop<T>` has the same size as `T` [1]// - `ManuallyDrop<T>` has the same validity as `T` [1]// - `Unalign<T>` promises to have the same size as `T`.// - `Unalign<T>` promises to have the same validity as `T`.// SAFETY: `Unalign<T>` promises to have the same size and validity as `T`.// Given `u: &Unalign<T>`, it is already possible to obtain `let t =// u.try_deref().unwrap()`. Because `Unalign<T>` has the same size as `T`, the// returned `&T` must point to the same referent as `u`, and thus it must be// sound for these two references to exist at the same time since it's already// possible for safe code to get into this state.// - `Wrapping<T>` has the same size as `T` [1].// - `Wrapping<T>` has only one field, which is `pub` [2]. We are also//   guaranteed per that `Wrapping<T>` has the same layout as `T` [1]. The only//   way for both of these to be true simultaneously is for `Wrapping<T>` to//   have the same bit validity as `T`. In particular, in order to change the//   bit validity, one of the following would need to happen://   - `Wrapping` could change its `repr`, but this would violate the layout//     guarantee.//   - `Wrapping` could add or change its fields, but this would be a//     stability-breaking change.// [1] Per https://doc.rust-lang.org/1.85.0/core/num/struct.Wrapping.html#layout-1://   `Wrapping<T>` is guaranteed to have the same layout and ABI as `T`.// [2] Definition from https://doc.rust-lang.org/1.85.0/core/num/struct.Wrapping.html://   #[repr(transparent)]//   pub struct Wrapping<T>(pub T);// SAFETY: By the preceding safety proof, `Wrapping<T>` and `T` have the same// layout and bit validity. Since a `Wrapping<T>`'s `T` field is `pub`, given// `w: &Wrapping<T>`, it's possible to do `let t = &w.t`, which means that it's// already possible for safe code to obtain a `&Wrapping<T>` and a `&T` pointing// to the same referent at the same time. Thus, this must be sound.// - `UnsafeCell<T>` has the same size as `T` [1].// - Per [1], `UnsafeCell<T>` has the same bit validity as `T`. Technically the//   term "representation" doesn't guarantee this, but the subsequent sentence//   in the documentation makes it clear that this is the intention.//   `T`. A consequence of this guarantee is that it is possible to convert//   between `T` and `UnsafeCell<T>`.// - `Cell<T>` has the same size as `T` [1].// - Per [1], `Cell<T>` has the same bit validity as `T`. Technically the term//   "representation" doesn't guarantee this, but it does promise to have the//   "same memory layout and caveats as `UnsafeCell<T>`." The `UnsafeCell` docs//   [2] make it clear that bit validity is the intention even if that phrase//   isn't used.// [1] Per https://doc.rust-lang.org/1.85.0/std/cell/struct.Cell.html#memory-layout://   `Cell<T>` has the same memory layout and caveats as `UnsafeCell<T>`. In//   particular, this means that `Cell<T>` has the same in-memory representation//   as its inner type `T`.// [2] Per https://doc.rust-lang.org/1.81.0/core/cell/struct.UnsafeCell.html#memory-layout:// SAFETY: `MaybeUninit<T>` has no validity requirements. Currently this is not// explicitly guaranteed, but it's obvious from `MaybeUninit`'s documentation// that this is the intention:// https://doc.rust-lang.org/1.85.0/core/mem/union.MaybeUninit.html// SAFETY: `MaybeUninit<T>` has the same size as `T` [1].// FIXME(#2354): This seems like a smell - the soundness of this bound has// nothing to do with `Src` or `Dst` - we're basically just saying `[u8; N]` is// transmutable into `[u8; N]`.// nothing to do with `Dst` - we're basically just saying that any type is// transmutable into `MaybeUninit<[u8; N]>`.// INVARIANTS: The referent (via `.deref`, `.deref_mut`, `.into`) byte// slice is aligned to `T`'s alignment and its size corresponds to a// valid size for `T`./// `Ref` can be used to treat a sequence of bytes as a structured type, and/// to read and write the fields of that type as if the byte slice reference/// were simply a reference to that type.///     pub fn parse<B: ByteSlice>(bytes: B) -> Option<Ref<B, UdpPacket>> {///         Ref::from_bytes(bytes).ok()/// `bytes` dereferences (via [`deref`], [`deref_mut`], and [`into`]) to/// a byte slice which is aligned to `T`'s alignment and whose size is a/// valid size for `T`./// [`deref`]: core::ops::Deref::deref/// [`deref_mut`]: core::ops::DerefMut::deref_mut/// [`into`]: core::convert::Into::into/// Access the byte slice as a [`ByteSlice`]./// The caller promises not to call methods on the returned/// [`ByteSlice`] other than `ByteSlice` methods (for example, via/// `Any::downcast_ref`)./// `as_byte_slice` promises to return a `ByteSlice` whose referent is/// validly-aligned for `T` and has a valid size for `T`./// Access the byte slice as a [`ByteSliceMut`]./// [`ByteSliceMut`] other than `ByteSliceMut` methods (for example, via/// `Any::downcast_mut`)./// Access the byte slice as an [`IntoByteSlice`]./// [`IntoByteSlice`] other than `IntoByteSlice` methods (for example,/// via `Any::downcast_ref`)./// Access the byte slice as an [`IntoByteSliceMut`]./// [`IntoByteSliceMut`] other than `IntoByteSliceMut` methods (for/// example, via `Any::downcast_mut`).// INVARIANTS: Since `B: CopyableByteSlice`, the copied `Ref`'s `.0` has the// same address and length as the original `Ref`'s `.0`. Since the original// upholds the field invariants, so does the copy.sized_fromsized_from_prefixsized_from_suffix/// Constructs a `Ref` from a byte slice./// If the length of `source` is not a [valid size of `T`][valid-size], or/// if `source` is not appropriately aligned for `T`, this returns `Err`. If/// [`T: Unaligned`][t-unaligned], you can [infallibly discard the alignment/// `T` may be a sized type, a slice, or a [slice DST][slice-dst]./// [t-unaligned]: Unaligned/// #[derive(Immutable, KnownLayout)]/// let _ = Ref::<_, ZSTy>::from_bytes(&b"UU"[..]); // ⚠ Compile Error!from_prefix/// Constructs a `Ref` from the prefix of a byte slice./// This method computes the [largest possible size of `T`][valid-size] that/// can fit in the leading bytes of `source`, then attempts to return both a/// `Ref` to those bytes, and a reference to the remaining bytes. If there/// are insufficient bytes, or if `source` is not appropriately aligned,/// this returns `Err`. If [`T: Unaligned`][t-unaligned], you can/// let _ = Ref::<_, ZSTy>::from_prefix(&b"UU"[..]); // ⚠ Compile Error!from_suffix/// Constructs a `Ref` from the suffix of a byte slice./// can fit in the trailing bytes of `source`, then attempts to return both/// a `Ref` to those bytes, and a reference to the preceding bytes. If there/// are insufficient bytes, or if that suffix of `source` is not/// appropriately aligned, this returns `Err`. If [`T:/// Unaligned`][t-unaligned], you can [infallibly discard the alignment/// let _ = Ref::<_, ZSTy>::from_suffix(&b"UU"[..]); // ⚠ Compile Error!from_bytes_with_elems/// Constructs a `Ref` from the given bytes with DST length equal to `count`/// without copying./// This method attempts to return a `Ref` to the prefix of `source`/// interpreted as a `T` with `count` trailing elements, and a reference to/// the remaining bytes. If the length of `source` is not equal to the size/// of `Self` with `count` elements, or if `source` is not appropriately/// aligned, this returns `Err`. If [`T: Unaligned`][t-unaligned], you can/// let _ = Ref::<_, ZSTy>::from_bytes_with_elems(&b"UU"[..], 42); // ⚠ Compile Error!from_prefix_with_elems/// Constructs a `Ref` from the prefix of the given bytes with DST/// length equal to `count` without copying./// the remaining bytes. If there are insufficient bytes, or if `source` is/// not appropriately aligned, this returns `Err`. If [`T:/// let _ = Ref::<_, ZSTy>::from_prefix_with_elems(&b"UU"[..], 42); // ⚠ Compile Error!from_suffix_with_elems/// Constructs a `Ref` from the suffix of the given bytes with DST length/// This method attempts to return a `Ref` to the suffix of `source`/// the preceding bytes. If there are insufficient bytes, or if that suffix/// of `source` is not appropriately aligned, this returns `Err`. If [`T:/// let _ = Ref::<_, ZSTy>::from_suffix_with_elems(&b"UU"[..], 42); // ⚠ Compile Error!/// Note: this is an associated function, which means that you have to call/// it as `Ref::into_ref(r)` instead of `r.into_ref()`. This is so that/// there is no conflict with a method on the inner type./// it as `Ref::into_mut(r)` instead of `r.into_mut()`. This is so that/// it as `Ref::bytes(r)` instead of `r.bytes()`. This is so that there is/// no conflict with a method on the inner type./// it as `Ref::bytes_mut(r)` instead of `r.bytes_mut()`. This is so that/// it as `Ref::read(r)` instead of `r.read()`. This is so that there is no/// conflict with a method on the inner type./// it as `Ref::write(r, t)` instead of `r.write(t)`. This is so that there/// is no conflict with a method on the inner type.// FIXME(#251): We can't remove `Immutable` here because it's required by// the impl of `Deref`, which is a super-trait of `DerefMut`. Maybe we can// add a separate inherent method for this?test_mut_slice_into_reftest_into_ref_mut/// The element type of the trailing slice./// Unsafely splits `self` in two./// The caller promises that `l_len` is not greater than the length of/// `self`'s trailing slice./// Attempts to split `self` in two./// Returns `None` if `l_len` is greater than the length of `self`'s/// trailing slice./// use zerocopy::{SplitAt, FromBytes};/// #[derive(SplitAt, FromBytes, KnownLayout, Immutable)]///     length: u8,/// let bytes = &[4, 1, 2, 3, 4, 5, 6, 7, 8, 9][..];/// assert_eq!(packet.length, 4);/// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);/// // Attempt to split `packet` at `length`./// let split = packet.split_at(packet.length as usize).unwrap();/// // Use the `Immutable` bound on `Packet` to prove that it's okay to/// // return concurrent references to `packet` and `rest`./// let (packet, rest) = split.via_immutable();/// assert_eq!(packet.body, [1, 2, 3, 4]);/// assert_eq!(rest, [5, 6, 7, 8, 9]);split_at_mut_unchecked/// trailing slice, or if the given `l_len` would result in [the trailing/// padding](KnownLayout#slice-dst-layout) of the left portion overlapping/// the right portion./// #[derive(SplitAt, FromBytes, KnownLayout, IntoBytes)]/// struct Packet<B: ?Sized> {/// let mut bytes = &mut [4, 1, 2, 3, 4, 5, 6, 7, 8, 9][..];/// let packet = Packet::<[u8]>::mut_from_bytes(bytes).unwrap();///     // Attempt to split `packet` at `length`.///     let split = packet.split_at_mut(packet.length as usize).unwrap();///     // Use the `IntoBytes` bound on `Packet` to prove that it's okay to///     // return concurrent references to `packet` and `rest`.///     let (packet, rest) = split.via_into_bytes();///     assert_eq!(packet.length, 4);///     assert_eq!(packet.body, [1, 2, 3, 4]);///     assert_eq!(rest, [5, 6, 7, 8, 9]);///     rest.fill(0);/// assert_eq!(packet.body, [1, 2, 3, 4, 0, 0, 0, 0, 0]);/// Types that can be split in two./// This trait generalizes Rust's existing support for splitting slices to/// support slices and slice-based dynamically-sized types ("slice DSTs")./// [`#[derive(SplitAt)]`][derive]; e.g.:/// # use zerocopy_derive::{SplitAt, KnownLayout};/// #[derive(SplitAt, KnownLayout)]/// struct MyStruct<T: ?Sized> {///     // `SplitAt` types must have at least one field./// determine whether a type is `SplitAt`./// You must not rely on the `#[doc(hidden)]` internals of `SplitAt`. Future// The trailing slice is well-aligned for its element type. `Self` is `[T]`, or// a `repr(C)` or `repr(transparent)` slice DST.// SAFETY: `[T]`'s trailing slice is `[T]`, which is trivially aligned./// A pointer to the source slice DST./// The length of the future left half of `source`./// If `source` is a pointer to a slice DST, `l_len` is no greater than/// `source`'s length./// A `T` that has been split into two possibly-overlapping parts./// For some dynamically sized types, the padding that appears after the/// trailing slice field [is a dynamic function of the trailing slice/// length](KnownLayout#slice-dst-layout). If `T` is split at a length that/// requires trailing padding, the trailing padding of the left part of the/// split `T` will overlap the right part. If `T` is a mutable reference or/// permits interior mutation, you must ensure that the left and right parts do/// not overlap. You can do this at zero-cost using using/// [`Self::via_immutable`], [`Self::via_into_bytes`], or/// [`Self::via_unaligned`], or with a dynamic check by using/// [`Self::via_runtime_check`]./// Produces a `Split` of `source` with `l_len`./// `l_len` is no greater than `source`'s length.via_immutable/// Produces the split parts of `self`, using [`Immutable`] to ensure that/// it is sound to have concurrent references to both parts.via_into_bytes/// Produces the split parts of `self`, using [`IntoBytes`] to ensure that/// #[derive(SplitAt, FromBytes, KnownLayout, Immutable, IntoBytes)]/// let packet = Packet::<[u8]>::ref_from_bytes(bytes).unwrap();/// // Use the `IntoBytes` bound on `Packet` to prove that it's okay to/// let (packet, rest) = split.via_into_bytes();via_unaligned/// Produces the split parts of `self`, using [`Unaligned`] to ensure that/// #[derive(SplitAt, FromBytes, KnownLayout, Immutable, Unaligned)]/// // Use the `Unaligned` bound on `Packet` to prove that it's okay to/// let (packet, rest) = split.via_unaligned();via_runtime_check/// Produces the split parts of `self`, using a dynamic check to ensure that/// it is sound to have concurrent references to both parts. You should/// prefer using [`Self::via_immutable`], [`Self::via_into_bytes`], or/// [`Self::via_unaligned`], which have no runtime cost./// Note that this check is overly conservative if `T` is [`Immutable`]; for/// some types, this check will reject some splits which/// [`Self::via_immutable`] will accept./// use zerocopy::{SplitAt, FromBytes, IntoBytes, network_endian::U16};/// #[derive(SplitAt, FromBytes, KnownLayout, Immutable, Debug)]/// #[repr(C, align(2))]///     length: U16,///     4u16.to_be(),///     1u16.to_be(),///     2u16.to_be(),///     3u16.to_be(),///     4u16.to_be()/// let packet = Packet::ref_from_bytes(bytes.as_bytes()).unwrap();/// assert_eq!(packet.body, [0, 1, 0, 2, 0, 3, 0, 4]);/// let split = packet.split_at(packet.length.into()).unwrap();/// // Use a dynamic check to prove that it's okay to return concurrent/// // references to `packet` and `rest`./// let (packet, rest) = split.via_runtime_check().unwrap();/// assert_eq!(packet.body, [0, 1, 0, 2]);/// assert_eq!(rest, [0, 3, 0, 4]);/// // Attempt to split `packet` at `length - 1`./// let idx = packet.length.get() - 1;/// let split = packet.split_at(idx as usize).unwrap();/// // Attempt (and fail) to use a dynamic check to prove that it's okay/// // to return concurrent references to `packet` and `rest`. Note that/// // this is a case of `via_runtime_check` being overly conservative./// // Although the left and right parts indeed overlap, the `Immutable`/// // bound ensures that concurrently referencing these overlapping/// // parts is sound./// assert!(split.via_runtime_check().is_err());via_unchecked/// Unsafely produces the split parts of `self`./// If `T` permits interior mutation, the trailing padding bytes of the left/// portion must not overlap the right portion. For some dynamically sized/// types, the padding that appears after the trailing slice field [is a/// dynamic function of the trailing slice/// length](KnownLayout#slice-dst-layout). Thus, for some types, this/// condition is dependent on the length of the left portion./// #[derive(SplitAt, FromBytes, KnownLayout, IntoBytes, Unaligned)]///     // Use the `Unaligned` bound on `Packet` to prove that it's okay to///     let (packet, rest) = split.via_unaligned();/// prefer using [`Self::via_into_bytes`] or [`Self::via_unaligned`], which/// have no runtime cost./// #[derive(SplitAt, FromBytes, KnownLayout, IntoBytes, Debug)]///     // Use a dynamic check to prove that it's okay to return concurrent///     // references to `packet` and `rest`.///     let (packet, rest) = split.via_runtime_check().unwrap();/// The trailing padding bytes of the left portion must not overlap the/// right portion. For some dynamically sized types, the padding that/// appears after the trailing slice field [is a dynamic function of the/// trailing slice length](KnownLayout#slice-dst-layout). Thus, for some/// types, this condition is dependent on the length of the left portion./// Produces the length of `self`'s left part./// The caller promises that if `I::Aliasing` is [`Exclusive`] or `T`/// permits interior mutation, then `l_len.padding_needed_for() == 0`.test_split_at_overlapping/// The type of the field at `Index`./// Projects the type of the field at `Index` in `Self`./// The `Index` parameter is any sort of handle that identifies the field; its/// definition is the obligation of the implementer./// Unsafe code may assume that this accurately reflects the definition of/// `Self`.HAS_PADDINGSizeToTagsize_to_tag/// An alias for the unsigned integer of the given size in bytes.on_unimplemented__size_of// We put `Sized` in its own module so it can have the same name as the standard// library `Sized` without shadowing it in the parent module./// Note that `struct_has_padding!`'s results are independent of `repcr` sinceenum_has_padding/// Does the enum type `$t` have padding?/// `$disc` is the type of the enum tag, and `$ts` is a list of fields in each/// square-bracket-delimited variant. `$t` must be an enum, or else/// `enum_has_padding!`'s result may be meaningless. An enum has padding if any/// of its variant structs [1][2] contain padding, and so all of the variants of/// an enum must be "full" in order for the enum to not have padding./// The results of `enum_has_padding!` require that the enum is not/// `repr(Rust)`, as `repr(Rust)` enums may niche the enum's tag and reduce the/// total number of bytes required to represent the enum as a result. As long as/// the enum is `repr(C)`, `repr(int)`, or `repr(C, int)`, this will/// consistently return whether the enum contains any padding bytes./// [1]: https://doc.rust-lang.org/1.81.0/reference/type-layout.html#reprc-enums-with-fields/// [2]: https://doc.rust-lang.org/1.81.0/reference/type-layout.html#primitive-representation-of-enums-with-fieldstry_cast_or_pme// FIXME(#2226): There should be a `Src: FromBytes` bound here, but doing so// requires deeper surgery./// Is a given source a valid instance of `Dst`?/// If so, returns `src` casted to a `Ptr<Dst, _>`. Otherwise returns `None`./// Unsafe code may assume that, if `try_cast_or_pme(src)` returns `Ok`,/// `*src` is a bit-valid instance of `Dst`, and that the size of `Src` is/// greater than or equal to the size of `Dst`./// Unsafe code may assume that, if `try_cast_or_pme(src)` returns `Err`, the/// encapsulated `Ptr` value is the original `src`. `try_cast_or_pme` cannot/// guarantee that the referent has not been modified, as it calls user-defined/// code (`TryFromBytes::is_bit_valid`)./// `try_cast_or_pme` may either produce a post-monomorphization error or a/// panic if `Dst` not the same size as `Src`. Otherwise, `try_cast_or_pme`/// panics under the same circumstances as [`is_bit_valid`]./// [`is_bit_valid`]: TryFromBytes::is_bit_valid/// Attempts to transmute `Src` into `Dst`./// A helper for `try_transmute!`./// `try_transmute` may either produce a post-monomorphization error or a panic/// if `Dst` is bigger than `Src`. Otherwise, `try_transmute` panics under the/// same circumstances as [`is_bit_valid`]./// Attempts to transmute `&Src` into `&Dst`./// A helper for `try_transmute_ref!`./// `try_transmute_ref` may either produce a post-monomorphization error or a/// panic if `Dst` is bigger or has a stricter alignment requirement than `Src`./// Otherwise, `try_transmute_ref` panics under the same circumstances as/// [`is_bit_valid`]./// Attempts to transmute `&mut Src` into `&mut Dst`./// A helper for `try_transmute_mut!`./// `try_transmute_mut` may either produce a post-monomorphization error or a/// Otherwise, `try_transmute_mut` panics under the same circumstances as// Used in `transmute_ref!` and friends.// This permits us to use the autoref specialization trick to dispatch to// associated functions for `transmute_ref` and `transmute_mut` when both `Src`// and `Dst` are `Sized`, and to trait methods otherwise. The associated// functions, unlike the trait methods, do not require a `KnownLayout` bound.// This permits us to add support for transmuting references to unsized types// without breaking backwards-compatibility (on v0.8.x) with the old// implementation, which did not require a `KnownLayout` bound to transmute// sized types./// - `Src: IntoBytes + Immutable`/// - `Dst: FromBytes + Immutable`/// Instantiating this method PMEs unless both:/// - `mem::size_of::<Dst>() == mem::size_of::<Src>()`/// - `mem::align_of::<Dst>() <= mem::align_of::<Src>()`TransmuteRefDstTransmuteMutDst/// A function which emits a warning if its return value is not used.test_enum_caststest_enum_has_padding//! code, then deriving `IntoBytes` and `FromBytes` on three different types//! would result in the code in question being emitted and compiled six//! different times).// The 2 arms under this one are there so we can apply// N attributes for each one of M trait implementations.// The simple solution of:// ($(#[$attrs:meta])* $ty:ty: $($traits:ident),*) => {//     $( unsafe_impl!( $(#[$attrs])* $ty: $traits ) );*// Won't work. The macro processor sees that the outer repetition// contains both $attrs and $traits and expects them to match the same// amount of fragments.// To solve this we must:// 1. Pack the attributes into a single token tree fragment we can match over.// 2. Expand the traits.// 3. Unpack and expand the attributes./// - If an `is_bit_valid` impl is provided, then the impl of `is_bit_valid`///   must only return `true` if its argument refers to a valid `$ty`./// Implements `$trait` for `$ty` where `$ty: TransmuteFrom<$repr>` (and/// vice-versa)./// Calling this macro is safe; the internals of the macro emit appropriate/// trait bounds which ensure that the given impl is sound./// Implements a trait for a type, bounding on each member of the power set of/// `const _: () = unsafe` macro) . The reason for this restriction is that, while/// Finally, if a `TryFromBytes::is_bit_valid` impl is provided, it must adhere/// to the safety preconditions of [`unsafe_impl!`]./// #[cfg_attr(any(feature = "derive", test), derive(FromZeros, FromBytes, IntoBytes, Unaligned))]/// const _: () = unsafe {///     impl_or_verify!(T: FromZeros => FromZeros for Wrapper<T>);///     impl_or_verify!(T: IntoBytes => IntoBytes for Wrapper<T>);// This case handles both `self` methods (where `self` is by value) and// non-method functions. Each `$args` may optionally be followed by `:// $arg_tys:ty`, which can be omitted for `self`./// Emits a function definition as either `const fn` or `fn` depending on/// whether the current toolchain version supports `const fn` with generic trait/// Either panic (if the current Rust toolchain supports panicking in `const/// fn`) or evaluate a constant that will cause an array indexing error whose/// error message will include the format string./// The type that this expression evaluates to must be `Copy`, or else the/// non-panicking desugaring will fail to compile./// Either assert (if the current Rust toolchain supports panicking in `const/// fn`) or evaluate the expression and, if it evaluates to `false`, call/// `const_panic!`. This is used in place of `assert!` in const contexts to/// accommodate old toolchains.const_debug_assert/// Like `const_assert!`, but relative to `debug_assert!`.const_unreachable/// Either invoke `unreachable!()` or `loop {}` depending on whether the Rust/// toolchain supports panicking in `const fn`./// Asserts at compile time that `$condition` is true for `Self` or the given/// `$tyvar`s. Unlike `const_assert`, this is *strictly* a compile-time check;/// it cannot be evaluated in a runtime context. The condition is checked after/// monomorphization and, upon failure, emits a compile error.static_assert_dst_is_not_zst/// Assert at compile time that `tyvar` does not have a zero-sized DST/// The caller must ensure that the cast does not grow the size of the referent./// Preserving or shrinking the size of the referent are both acceptable.unsafe_impl_for_transparent_wrapper/// Implements `TransmuteFrom` and `SizeEq` for `T` and `$wrapper<T>`./// `T` and `$wrapper<T>` must have the same bit validity, and must have the/// same size in the sense of `SizeEq`.unsafe_with_size_eq/// Invokes `$blk` in a context in which `$src<$t>` and `$dst<$u>` implement/// `SizeEq`./// This macro emits code which implements `SizeEq`, and ensures that the impl/// is sound via PME./// Inside of `$blk`, the caller must only use `$src` and `$dst` as `$src<$t>`/// and `$dst<$u>`. The caller must not use `$src` or `$dst` to wrap any other/// A no-op `unsafe fn` for use in macro expansions./// Calling this function in a macro expansion ensures that the macro's caller/// must wrap the call in `unsafe { ... }`./// Like [`PhantomData`], but [`Send`] and [`Sync`] regardless of whether the/// wrapped `T` is.// SAFETY: `SendSyncPhantomData` does not enable any behavior which isn't sound// to be called from multiple threads.validate_aligned_to/// Validates that `t` is aligned to `align_of::<U>()`.// Ensures that we add the minimum required padding./// Returns the bytes needed to pad `len` to the next multiple of `align`./// This function assumes that align is a power of two; there are no guarantees/// on the answer it gives if this is not the case.// Guarantees that `m` is the *largest* value such that `m % align == 0`./// Rounds `n` down to the largest value `m` such that `m <= n` and `m % align/// == 0`.copy_unchecked/// Copies `src` into the prefix of `dst`./// The caller guarantees that `src.len() <= dst.len()`./// Unsafely transmutes the given `src` into a type `Dst`./// The value `src` must be a valid instance of `Dst`./// The size of an instance of `&T` with the given metadata is not/// larger than `isize::MAX`./// A witness type for metadata of a valid instance of `&T`.new_in_bounds/// Returns `None` if `meta` is greater than `t`'s metadata.len_of// The `#[allow(unused)]` is necessary because, on sufficiently recent// toolchain versions, `ptr.slice_from_raw_parts()` resolves to the inherent// method rather than to this trait, and so this trait is considered unused.// FIXME(#67): Once our MSRV is 1.70, remove this.// NOTE on coverage: this will never be tested in nightly since it's a// polyfill for a feature which has been stabilized on our nightly// toolchain./// Add without checking for overflow./// The caller promises that the addition will not overflow./// Subtract without checking for underflow./// The caller promises that the subtraction will not underflow./// Multiply without checking for overflow./// The caller promises that the multiplication will not overflow.// A polyfill for `Self::unchecked_sub` that we can use until methods like// `usize::unchecked_sub` is stabilized.// FIXME(#67): Once our MSRV is high enough, remove this.// NOTE on coverage: these will never be tested in nightly since they're// polyfills for a feature which has been stabilized on our nightly/// we'd have to write worse/more verbose code and leave FIXME comments sprinkled// Note that we need `T: Unaligned` in order to guarantee that there is// no padding between `_u` and `t`./// for this type to work properly.// Though `u64` has alignment 8 on some platforms, it's not guaranteed. By// contrast, `AU64` is guaranteed to have alignment 8 on all platforms.test_round_down_to_next_multiple_of_alignment_zerocopy_panic_in_const_and_vec_try_reserve/// In this example, we need `EthernetFrame` to have no alignment requirement -/// and thus implement [`Unaligned`]. `EtherType` is `#[repr(u16)]` and so/// cannot implement `Unaligned`. We use `Unalign` to relax `EtherType`'s/// alignment requirement so that `EthernetFrame` has no alignment requirement/// and can implement `Unaligned`./// # #[derive(FromBytes, KnownLayout, Immutable, Unaligned)] #[repr(C)] struct Mac([u8; 6]);/// # #[derive(PartialEq, Copy, Clone, Debug)]/// #[repr(u16)]/// enum EtherType {///     Ipv4 = 0x0800u16.to_be(),///     Arp = 0x0806u16.to_be(),///     Ipv6 = 0x86DDu16.to_be(),///     # /*///     # *//// #[derive(TryFromBytes, KnownLayout, Immutable, Unaligned)]/// struct EthernetFrame {///     src: Mac,///     dst: Mac,///     ethertype: Unalign<EtherType>,///     payload: [u8],///     # 0, 1, 2, 3, 4, 5,///     # 6, 7, 8, 9, 10, 11,///     0x86, 0xDD,            // EtherType///     0xDE, 0xAD, 0xBE, 0xEF // Payload/// ][..];/// // PANICS: Guaranteed not to panic because `bytes` is of the right/// // length, has the right contents, and `EthernetFrame` has no/// // alignment requirement./// let packet = EthernetFrame::try_ref_from_bytes(&bytes).unwrap();/// assert_eq!(packet.ethertype.get(), EtherType::Ipv6);/// assert_eq!(packet.payload, [0xDE, 0xAD, 0xBE, 0xEF]);/// `Unalign<T>` is guaranteed to have the same size and bit validity as `T`,/// and to have [`UnsafeCell`]s covering the same byte ranges as `T`./// `Unalign<T>` is guaranteed to have alignment 1.// We do not use `derive(KnownLayout)` on `Unalign`, because the derive is not// smart enough to realize that `Unalign<T>` is always sized and thus emits a// `KnownLayout` impl bounded on `T: KnownLayout.` This is overly restrictive.// - `Unalign<T>` promises to have alignment 1, and so we don't require that `T://   Unaligned`.// - `Unalign<T>` has the same bit validity as `T`, and so it is `FromZeros`,//   `FromBytes`, or `IntoBytes` exactly when `T` is as well.// - `Immutable`: `Unalign<T>` has the same fields as `T`, so it contains//   `UnsafeCell`s exactly when `T` does.// - `TryFromBytes`: `Unalign<T>` has the same the same bit validity as `T`, so//   `T::is_bit_valid` is a sound implementation of `is_bit_valid`.// Unused when `feature = "derive"`./// If `self` does not satisfy `align_of::<T>()`, then `try_deref` returns/// `Err`./// The caller must guarantee that `self` satisfies `align_of::<T>()`./// of `get_ptr` will result in undefined behavior if alignment is not/// guaranteed using some out-of-band mechanism. In general, the only/// functions which are safe to call with this pointer are those which are/// explicitly documented as being sound to use with an unaligned pointer,/// such as [`read_unaligned`]./// Even if the caller is permitted to mutate `self` (e.g. they have/// ownership or a mutable borrow), it is not guaranteed to be sound to/// write through the returned pointer. If writing is required, prefer/// [`get_mut_ptr`] instead./// [`get_mut_ptr`]: Unalign::get_mut_ptr// FIXME(https://github.com/rust-lang/rust/issues/57349): Make this `const`.// SAFETY: `MaybeUninit<T>` has the same size as `T`, because (by invariant// on `T::MaybeUninit`) `T::MaybeUninit` has `T::LAYOUT` identical to `T`,// and because (invariant on `T::LAYOUT`) we can trust that `LAYOUT`// accurately reflects the layout of `T`. By invariant on `T::MaybeUninit`,// it admits uninitialized bytes in all positions. Because `MaybeUninit` is// marked `repr(transparent)`, these properties additionally hold true for// `Self`./// A wrapper type to construct uninitialized instances of `T`./// `MaybeUninit` is identical to the [standard library/// `MaybeUninit`][core-maybe-uninit] type except that it supports unsized/// # Layout/// The same layout guarantees and caveats apply to `MaybeUninit<T>` as apply to/// the [standard library `MaybeUninit`][core-maybe-uninit] with one exception:/// for `T: !Sized`, there is no single value for `T`'s size. Instead, for such/// types, the following are guaranteed:/// - Every [valid size][valid-size] for `T` is a valid size for///   `MaybeUninit<T>` and vice versa/// - Given `t: *const T` and `m: *const MaybeUninit<T>` with identical fat///   pointer metadata, `t` and `m` address the same number of bytes (and///   likewise for `*mut`)/// [core-maybe-uninit]: core::mem::MaybeUninit/// Constructs a `MaybeUninit<T>` initialized with the given value./// Constructs an uninitialized `MaybeUninit<T>`./// Extracts the value from the `MaybeUninit<T>` container./// The caller must ensure that `self` is in an bit-valid state. Depending/// on subsequent use, it may also need to be in a library-valid state.test_unalign_copy_clonetest_unalign_trait_implstest_maybe_uninitfield_types/// Extract the types of all fields. For enums, extract the types of fields/// from each variant.DataExtis_c_likeEnumExttry_or_print// Unwraps a `Result<_, Vec<Error>>`, converting any `Err` value into a// `TokenStream` and returning it.derive_known_layoutderive_from_zeroesderive_from_bytesderive_as_bytesderive_unalignedSTRUCT_UNION_ALLOWED_REPR_COMBINATIONSStructReprderive_from_zeroes_structderive_from_zeroes_enumderive_from_zeroes_unionderive_from_bytes_structderive_from_bytes_enumENUM_FROM_BYTES_CFGEnumReprderive_from_bytes_unionderive_as_bytes_structSTRUCT_UNION_AS_BYTES_CFGderive_as_bytes_enumENUM_AS_BYTES_CFGderive_as_bytes_unionderive_unaligned_structSTRUCT_UNION_UNALIGNED_CFGderive_unaligned_enumENUM_UNALIGNED_CFGderive_unaligned_unionPaddingCheck// Check that the sum of the fields' sizes exactly equals the struct's size.// Check that the size of each field exactly equals the union's size.// This enum describes what kind of padding check needs to be generated for the// associated impl.validator_macro_ident/// Returns the ident of the macro to call in order to validate that a type/// passes the padding check encoded by `PaddingCheck`.RequireBoundedFieldsimpl_blockprint_all_errorsthen_someBoolExt// A polyfill for `Option::then_some`, which was added after our MSRV.// TODO(#67): Remove this once our MSRV is >= 1.62.test_config_repr_orderingstest_config_repr_no_overlap//! Derive macros for [zerocopy]'s traits.//! [zerocopy]: https://docs.rs/zerocopy// TODO(https://github.com/rust-lang/rust/issues/54140): Some errors could be// made better if we could add multiple lines of error output like this:// error: unsupported representation//   --> enum.rs:28:8//    |// 28 | #[repr(transparent)]// help: required by the derive of FromBytes// Instead, we have more verbose error messages like "unsupported representation// for deriving FromZeroes, FromBytes, AsBytes, or Unaligned on an enum"// This will probably require Span::error// (https://doc.rust-lang.org/nightly/proc_macro/struct.Span.html#method.error),// which is currently unstable. Revisit this once it's stable.// A struct is `FromZeroes` if:// - all fields are `FromZeroes`// An enum is `FromZeroes` if:// - all of its variants are fieldless// - one of the variants has a discriminant of `0`// Like structs, unions are `FromZeroes` if// A struct is `FromBytes` if:// - all fields are `FromBytes`// An enum is `FromBytes` if:// - Every possible bit pattern must be valid, which means that every bit//   pattern must correspond to a different enum variant. Thus, for an enum//   whose layout takes up N bytes, there must be 2^N variants.// - Since we must know N, only representations which guarantee the layout's//   size are allowed. These are `repr(uN)` and `repr(iN)` (`repr(C)` implies an//   implementation-defined size). `usize` and `isize` technically guarantee the//   layout's size, but would require us to know how large those are on the//   target platform. This isn't terribly difficult - we could emit a const//   expression that could call `core::mem::size_of` in order to determine the//   size and check against the number of enum variants, but a) this would be//   platform-specific and, b) even on Rust's smallest bit width platform (32),//   this would require ~4 billion enum variants, which obviously isn't a thing.// Like structs, unions are `FromBytes` if// A struct is `AsBytes` if:// - all fields are `AsBytes`// - `repr(C)` or `repr(transparent)` and//   - no padding (size of struct equals sum of size of field types)// - `repr(packed)`// An enum is `AsBytes` if it is C-like and has a defined repr.// A union is `AsBytes` if:// - `repr(C)`, `repr(transparent)`, or `repr(packed)`// - no padding (size of union equals size of each field type)// A struct is `Unaligned` if:// - `repr(align)` is no more than 1 and either//   - `repr(C)` or `repr(transparent)` and//     - all fields `Unaligned`//   - `repr(packed)`// An enum is `Unaligned` if:// - No `repr(align(N > 1))`// - `repr(u8)` or `repr(i8)`// Like structs, a union is `Unaligned` if:allowed_combinations_message// A human-readable message describing what combinations of representations// are allowed. This will be printed to the user if they use an invalid// combination.// Whether we're checking as part of `derive(Unaligned)`. If not, we can// ignore `repr(align)`, which makes the code (and the list of valid repr// combinations we have to enumerate) somewhat simpler. If we're checking// for `Unaligned`, then in addition to checking against illegal// combinations, we also check to see if there exists a `repr(align(N > 1))`allowed_combinations// Combinations which are valid for the trait.disallowed_but_legal_combinations// Combinations which are not valid for the trait, but are legal according// to Rust. Any combination not in this or `allowed_combinations` is either// illegal according to Rust or the behavior is unspecified. If the behavior// is unspecified, it might become specified in the future, and that// specification might not play nicely with our requirements. Thus, we// reject combinations with unspecified behavior in addition to illegal// combinations.KindReprvalidate_reprs/// Validate that `input`'s representation attributes conform to the/// requirements specified by this `Config`./// `validate_reprs` extracts the `repr` attributes, validates that they/// conform to the requirements of `self`, and returns them. Regardless of/// whether `align` attributes are considered during validation, they are/// stripped out of the returned value since no callers care about them.is_alignis_align_gt_one// The type of valid reprs for a particular kind (enum, struct, union).define_kind_specific_repr// Defines an enum for reprs which are valid for a given kind (structs, enums,// etc), and provide implementations of `KindRepr`, `Ord`, and `Display`, and// those traits' super-traits.PackedN// All representations known to Rust.from_metareprsderive_try_from_bytes_innergenerate_tag_enum/// Generates a tag enum for the given enum. This generates an enum with the/// same non-align `repr`s, variants, and corresponding discriminants, but none/// of the fields.tag_identgenerate_tag_consts/// Generates a constant for the tag associated with each variant of the enum./// When we match on the enum's tag, each arm matches one of these constants. We/// have to use constants here because:/// - The type that we're matching on is not the type of the tag, it's an///   integer of the same size as the tag type and with the same bit patterns./// - We can't read the enum tag as an enum because the bytes may not represent///   a valid variant./// - Patterns do not currently support const expressions, so we have to assign///   these constants to names rather than use them inline in the `match`///   statement.variant_struct_identgenerate_variant_structs/// Generates variant structs for the given enum variant./// These are structs associated with each variant of an enum. They are/// `repr(C)` tuple structs with the same fields as the variant after a/// `MaybeUninit<___ZerocopyInnerTag>`./// In order to unify the generated types for `repr(C)` and `repr(int)` enums,/// we use a "fused" representation with fields for both an inner tag and an/// outer tag. Depending on the repr, we will set one of these tags to the tag/// type and the other to `()`. This lets us generate the same code but put the/// tags in different locations.generate_variants_unionderive_is_bit_valid/// Generates an implementation of `is_bit_valid` for an arbitrary enum./// The general process is:/// 1. Generate a tag enum. This is an enum with the same repr, variants, and///    corresponding discriminants as the original enum, but without any fields///    on the variants. This gives us access to an enum where the variants have///    the same discriminants as the one we're writing `is_bit_valid` for./// 2. Make constants from the variants of the tag enum. We need these because///    we can't put const exprs in match arms./// 3. Generate variant structs. These are structs which have the same fields as///    each variant of the enum, and are `#[repr(C)]` with an optional "inner///    tag"./// 4. Generate a variants union, with one field for each variant struct type./// 5. And finally, our raw enum is a `#[repr(C)]` struct of an "outer tag" and///    the variants union./// See these reference links for fully-worked example decompositions./// - `repr(C)`: <https://doc.rust-lang.org/reference/type-layout.html#reprc-enums-with-fields>/// - `repr(int)`: <https://doc.rust-lang.org/reference/type-layout.html#primitive-representation-of-enums-with-fields>/// - `repr(C, int)`: <https://doc.rust-lang.org/reference/type-layout.html#combining-primitive-representations-of-enums-with-fields-and-reprc>/// Extracts the names and types of all fields. For enums, extracts the/// names and types of fields from each variant. For tuple structs, the/// names are the indices used to index into the struct (ie, `0`, `1`, etc)./// FIXME: Extracting field names for enums doesn't really make sense. Types/// makes sense because we don't care about where they live - we just care/// about transitive ownership. But for field names, we'd only use them when/// generating is_bit_valid, which cares about where they live.map_fieldsoutput_tests/// Defines a derive function named `$outer` which parses its input/// `TokenStream` as a `DeriveInput` and then invokes the `$inner` function./// Note that the separate `$outer` parameter is required - proc macro functions/// are currently required to live at the crate root, and so the caller must/// specify the name in order to avoid name collisions.into_tsIntoTokenStreamextract_zerocopy_crate/// Attempt to extract a crate path from the provided attributes. Defaults to `::zerocopy` if notderive_no_cellderive_try_from_bytesderive_from_zerosderive_into_bytesderive_split_at/// Deprecated: prefer [`FromZeros`] instead./// Deprecated: prefer [`IntoBytes`] instead.derive_known_layout_innerderive_no_cell_innerderive_from_zeros_innerderive_from_bytes_innerderive_into_bytes_innerderive_unaligned_innerderive_hash_innerderive_eq_innerderive_split_at_innerderive_try_from_bytes_struct/// A struct is `TryFromBytes` if:/// - all fields are `TryFromBytes`derive_try_from_bytes_union/// A union is `TryFromBytes` if:/// - all of its fields are `TryFromBytes` and `Immutable`derive_try_from_bytes_enumtry_gen_trivial_is_bit_valid/// Attempts to generate a `TryFromBytes::is_bit_valid` instance that/// unconditionally returns true./// This is possible when the `top_level` trait is `FromBytes` and there are no/// generic type parameters. In this case, we know that compilation will succeed/// only if the type is unconditionally `FromBytes`. Type parameters are not/// supported because a type with type parameters could be `TryFromBytes` but/// not `FromBytes` depending on its type parameters, and so deriving a trivial/// `is_bit_valid` would be either unsound or, assuming we add a defensive/// `Self: FromBytes` bound (as we currently do), overly restrictive. Consider,/// for example, that `Foo<bool>` ought to be `TryFromBytes` but not `FromBytes`/// in this example:/// This should be used where possible. Using this impl is faster to codegen,/// faster to compile, and is friendlier on the optimizer.gen_trivial_is_bit_valid_unchecked/// Generates a `TryFromBytes::is_bit_valid` instance that unconditionally/// This should be used where possible, (although `try_gen_trivial_is_bit_valid`/// should be preferred over this for safety reasons). Using this impl is faster/// to codegen, faster to compile, and is friendlier on the optimizer./// The caller must ensure that all initialized bit patterns are valid forderive_from_zeros_struct/// A struct is `FromZeros` if:/// - all fields are `FromZeros`find_zero_variant/// Returns `Ok(index)` if variant `index` of the enum has a discriminant of/// zero. If `Err(bool)` is returned, the boolean is true if the enum has/// unknown discriminants (e.g. discriminants set to const expressions which we/// can't evaluate in a proc macro). If the enum has unknown discriminants, then/// it might have a zero variant that we just can't detect.derive_from_zeros_enum/// An enum is `FromZeros` if:/// - one of the variants has a discriminant of `0`/// - that variant's fields are all `FromZeros`derive_from_zeros_union/// Unions are `FromZeros` if/// - all fields are `FromZeros` and `Immutable`/// A struct is `FromBytes` if:/// - all fields are `FromBytes`/// An enum is `FromBytes` if:/// - Every possible bit pattern must be valid, which means that every bit///   pattern must correspond to a different enum variant. Thus, for an enum///   whose layout takes up N bytes, there must be 2^N variants./// - Since we must know N, only representations which guarantee the layout's///   size are allowed. These are `repr(uN)` and `repr(iN)` (`repr(C)` implies an///   implementation-defined size). `usize` and `isize` technically guarantee the///   layout's size, but would require us to know how large those are on the///   target platform. This isn't terribly difficult - we could emit a const///   expression that could call `core::mem::size_of` in order to determine the///   size and check against the number of enum variants, but a) this would be///   platform-specific and, b) even on Rust's smallest bit width platform (32),///   this would require ~4 billion enum variants, which obviously isn't a thing./// - All fields of all variants are `FromBytes`.enum_size_from_repr// Returns `None` if the enum's size is not guaranteed by the repr./// Unions are `FromBytes` if/// - all fields are `FromBytes` and `Immutable`derive_into_bytes_structderive_into_bytes_enum/// If the type is an enum:/// - It must have a defined representation (`repr`s `C`, `u8`, `u16`, `u32`,///   `u64`, `usize`, `i8`, `i16`, `i32`, `i64`, or `isize`)./// - It must have no padding bytes./// - Its fields must be `IntoBytes`.derive_into_bytes_union/// A union is `IntoBytes` if:/// - all fields are `IntoBytes`/// - `repr(C)`, `repr(transparent)`, or `repr(packed)`/// - no padding (size of union equals size of each field type)/// A struct is `Unaligned` if:/// - `repr(align)` is no more than 1 and either///   - `repr(C)` or `repr(transparent)` and///     - all fields `Unaligned`///   - `repr(packed)`/// An enum is `Unaligned` if:/// - No `repr(align(N > 1))`/// - `repr(u8)` or `repr(i8)`/// Like structs, a union is `Unaligned` if:/// Check that the sum of the fields' sizes exactly equals the struct's/// Check that the size of each field exactly equals the union's size.tag_type_definition/// Check that every variant of the enum contains no padding./// Because doing so requires a tag enum, this padding check requires an/// additional `TokenStream` which defines the tag enum as `___ZerocopyTag`./// This enum describes what kind of padding check needs to be generated for the/// associated impl.validator_macro_context/// Sometimes performing the padding check requires some additional/// "context" code. For enums, this is the definition of the tag enum.SlfFieldBoundsALL_SELFTRAILING_SELFSelfBoundsSIZED// FIXME(https://github.com/rust-lang/rust-clippy/issues/12908): This is a false// positive. Explicit lifetimes are actually necessary here.normalize_bounds/// Normalizes a slice of bounds by replacing [`TraitBound::Slf`] with `slf`.trtfield_type_trait_boundszerocopy_crateself_type_trait_boundspadding_checkinner_extrasouter_extrasImplBlockBuilder// The `#[allow(unused)]` is necessary because, on sufficiently recent toolchain// versions, `b.then_some(...)` resolves to the inherent method rather than to// this trait, and so this trait is considered unused.// FIXME(#67): Remove this once our MSRV is >= 1.62.// Inlining format args isn't supported on our MSRV.// FIXME(https://github.com/rust-lang/rust/issues/54140): Some errors could be// for deriving FromZeros, FromBytes, IntoBytes, or Unaligned on an enum"dissimilaruse_as_trait_name// This permits invocations of `test!` to be more ergonomic, passing the name of// the trait under test rather than the name of the inner derive function./// Test that the given derive input expands to the expected output./// Equality is tested by formatting both token streams using `prettyplease` and/// performing string equality on the results. This has the effect of making the/// tests less brittle and robust against meaningless formatting changes.// Adapted from https://github.com/joshlf/synstructure/blob/400499aaf54840056ff56718beb7810540e6be59/src/macros.rs#L212-L317assert_eq_streamstest_immutabletest_try_from_bytestest_from_zerostest_from_bytes_structtest_from_bytes_uniontest_unalignedtest_try_from_bytes_enumtest_from_bytes_enum// This goes at the bottom because it's so verbose and it makes scrolling past// other code a pain.test_try_from_bytes_trivial_is_bit_valid_enumPrim/// `#[repr(transparent)]`CompoundReprAlignRepr/// A compound representation: `repr(C)`, `repr(Rust)`, or `repr(Int)`/// optionally combined with `repr(packed(...))` or `repr(align(...))`/// The computed representation of a type./// This is the result of processing all `#[repr(...)]` attributes on a type, if/// any. A `Repr` is only capable of representing legal combinations of/// `#[repr(...)]` attributes./// A compound representation: `repr(C)`, `repr(Rust)`, or `repr(Int)`.PrimitiveRepr/// `repr(Int)`/// `repr(packed(...))` or `repr(align(...))`StructUnionRepr/// The representations which can legally appear on a struct or union type./// The representations which can legally appear on an enum type.repr_type_name/// Gets the name of this "repr type" - the non-align `repr(X)` that is used/// in prose to refer to this type./// For example, we would refer to `#[repr(C, align(4))] struct Foo { ... }`/// as a "`repr(C)` struct".is_transparentis_cget_packedis_align_gt_1unaligned_validate_no_align_gt_1/// When deriving `Unaligned`, validate that the decorated type has no/// `#[repr(align(N))]` attribute where `N > 1`. If no such attribute exists/// (including if `N == 1`), this returns `Ok(())`, and otherwise it returns/// a descriptive error.is_packed_1/// Does `self` describe a `#[repr(packed)]` or `#[repr(packed(1))]` type?/// Does `self` describe a `#[repr(u8)]` type?is_i8/// Does `self` describe a `#[repr(i8)]` type?RawRepr/// The result of parsing a single `#[repr(...)]` attribute or a single/// directive inside a compound `#[repr(..., ...)]` attribute.FromRawReprError/// The `RawRepr` doesn't affect the high-level repr we're parsing (e.g./// it's `align(...)` and we're parsing a `CompoundRepr`)./// The `RawRepr` is invalid for the high-level repr we're parsing (e.g./// it's `packed` repr and we're parsing an `AlignRepr` for an enum type)./// The error from converting from a `RawRepr`.UnsupportedReprError/// The representation hint is not supported for the decorated type.PckedFromRawReprsError/// One of the `RawRepr`s is invalid for the high-level repr we're parsing/// (e.g. there's a `packed` repr and we're parsing an `AlignRepr` for an/// enum type)./// Two `RawRepr`s appear which both affect the high-level repr we're/// parsing (e.g., the list is `#[repr(align(2), packed)]`). Note that we/// conservatively treat redundant reprs as conflicting (e.g./// `#[repr(packed, packed)]`)./// The error from extracting a high-level repr type from a list of `RawRepr`s.try_from_raw_reprs/// Tries to extract a high-level repr from a list of `RawRepr`s.FromAttrsErrorFromRawReprs/// The error returned from [`Repr::from_attrs`].UnrecognizedReprErrorfrom_attrs_inner/// The representation hint could not be parsed or was unrecognized./// A value with an associated span./// Delegates to `T: TryFrom`, preserving span information in both the/// success and error cases.Inhabited// Used to permit implementing `With<T> for T: Inhabited` and for// `Infallible` without a blanket impl conflict.try_with_or// We ignore spans for equality in testing since real spans are hard to// synthesize and don't implement `PartialEq`.atomic_fencevolatile_writeimpl_zeroize_for_simd_register// TODO(tarcieri): other NEON register types?//! [`Zeroize`] impls for ARM64 SIMD registers./// Zero out this object from memory using Rust intrinsics which ensure the/// zeroization operation is not "optimized away" by the compiler./// Trait for securely erasing values from memory./// Marker trait signifying that this type will [`Zeroize::zeroize`] itself on [`Drop`]./// Marker trait for types whose [`Default`] is the desired zeroization resulttry_zeroize/// Try to zero out this object from memory using Rust intrinsics which/// ensure the zeroization operation is not "optimized away" by theTryZeroize/// Fallible trait for representing cases where zeroization may or may not be/// This is primarily useful for scenarios like reference counted data, where/// zeroization is only possible when the last reference is dropped.impl_zeroize_with_default/// `PhantomPinned` is zero sized so provide a ZeroizeOnDrop implementation./// `()` is zero sized so provide a ZeroizeOnDrop implementation.impl_zeroize_for_non_zero/// Impl [`Zeroize`] on arrays of types that impl [`Zeroize`]./// Impl [`ZeroizeOnDrop`] on arrays of types that impl [`ZeroizeOnDrop`]./// Impl [`Zeroize`] on [`MaybeUninit`] types./// This fills the memory with zeroes./// Note that this ignore invariants that `Z` might have, because/// [`MaybeUninit`] removes all invariants./// Impl [`Zeroize`] on slices of [`MaybeUninit`] types./// This impl can eventually be optimized using an memset intrinsic,/// such as [`core::intrinsics::volatile_set_memory`]./// This fills the slice with zeroes./// Impl [`Zeroize`] on slices of types that can be zeroized with [`Default`]./// such as [`core::intrinsics::volatile_set_memory`]. For that reason the/// blanket impl on slices is bounded by [`DefaultIsZeroes`]./// To zeroize a mut slice of `Z: Zeroize` which does not impl/// [`DefaultIsZeroes`], call `iter_mut().zeroize()`./// [`PhantomData`] is always zero sized so provide a [`Zeroize`] implementation./// [`PhantomData` is always zero sized so provide a ZeroizeOnDrop implementation.impl_zeroize_tuple// Generic implementations for tuples up to 10 parameters./// "Best effort" zeroization for `Vec`./// Ensures the entire capacity of the `Vec` is zeroed. Cannot ensure that/// previous reallocations did not leave values on the heap./// Unlike `Vec`, `Box<[Z]>` cannot reallocate, so we can be sure that we are not leaving/// values on the heap./// `Zeroizing` is a a wrapper for any `Z: Zeroize` type which implements a/// `Drop` handler which zeroizes dropped values./// Move value inside a `Zeroizing` wrapper which ensures it will be/// zeroized when it's dropped./// Use fences to prevent accesses from being reordered before this/// point, which should hopefully help ensure that all accessors/// see zeroes after this point./// Perform a volatile write to the destinationvolatile_set/// Perform a volatile `memset` operation which fills a slice with a value/// The memory pointed to by `dst` must be a single allocated object that is valid for `count`/// contiguous elements of `T`./// `count` must not be larger than an `isize`./// `dst` being offset by `mem::size_of::<T> * count` bytes must not wrap around the address space./// Also `dst` must be properly aligned.zeroize_flat_type/// Zeroizes a flat type/struct. Only zeroizes the values that it owns, and it does not work on/// dynamically sized values or trait objects. It would be inefficient to use this function on a/// type that already implements `ZeroizeOnDrop`./// - The type must not contain references to outside data or dynamically sized data, such as///   `Vec<T>` or `String`./// - Values stored in the type must not have `Drop` impls./// - This function can invalidate the type if it is used after this function is called on it.///   It is advisable to call this function only in `impl Drop`./// - The bit pattern of all zeroes must be valid for the data being zeroized. This may not be///   true for enums and pointers./// # Incompatible data types/// Some data types that cannot be safely zeroized using `zeroize_flat_type` include,/// but are not limited to:/// - References: `&T` and `&mut T`/// - Non-nullable types: `NonNull<T>`, `NonZeroU32`, etc./// - Enums with explicit non-zero tags./// - Smart pointers and collections: `Arc<T>`, `Box<T>`, `Vec<T>`, `HashMap<K, V>`, `String`, etc./// Safe usage for a struct containing strictly flat data:/// use zeroize::{ZeroizeOnDrop, zeroize_flat_type};/// struct DataToZeroize {///     flat_data_1: [u8; 32],///     flat_data_2: SomeMoreFlatData,/// struct SomeMoreFlatData(u64);/// impl Drop for DataToZeroize {///         unsafe { zeroize_flat_type(self as *mut Self) }/// impl ZeroizeOnDrop for DataToZeroize {}/// let mut data = DataToZeroize {///     flat_data_1: [3u8; 32],///     flat_data_2: SomeMoreFlatData(123u64)/// // data gets zeroized when droppedzeroize_or_on_dropAssertZeroizeOnDrop/// Auto-deref workaround for deriving `ZeroizeOnDrop`.AssertZeroize/// Internal module used as support for `AssertZeroizeOnDrop`.//! Securely zero memory with a simple trait ([`Zeroize`]) built on stable Rust//! primitives which guarantee the operation will not be "optimized away".//! [Zeroing memory securely is hard] - compilers optimize for performance, and//! in doing so they love to "optimize away" unnecessary zeroing calls. There are//! many documented "tricks" to attempt to avoid these optimizations and ensure//! that a zeroing routine is performed reliably.//! This crate isn't about tricks: it uses [`core::ptr::write_volatile`]//! and [`core::sync::atomic`] memory fences to provide easy-to-use, portable//! zeroing behavior which works on all of Rust's core number types and slices//! thereof, implemented in pure Rust with no usage of FFI or assembly.//! - No insecure fallbacks!//! - No dependencies!//! - No FFI or inline assembly! **WASM friendly** (and tested)!//! - `#![no_std]` i.e. **embedded-friendly**!//! - No functionality besides securely zeroing memory!//! - (Optional) Custom derive support for zeroing complex structures//! Requires Rust **1.72** or newer.//! In the future, we reserve the right to change MSRV (i.e. MSRV is out-of-scope//! for this crate's SemVer guarantees), however when we do it will be accompanied//! by a minor version bump.//! use zeroize::Zeroize;//! // Protip: don't embed secrets in your source code.//! // This is just an example.//! let mut secret = b"Air shield password: 1,2,3,4,5".to_vec();//! // [ ... ] open the air shield here//! // Now that we're done using the secret, zero it out.//! secret.zeroize();//! The [`Zeroize`] trait is impl'd on all of Rust's core scalar types including//! integers, floats, `bool`, and `char`.//! Additionally, it's implemented on slices and `IterMut`s of the above types.//! When the `alloc` feature is enabled (which it is by default), it's also//! impl'd for `Vec<T>` for the above types as well as `String`, where it provides//! [`Vec::clear`] / [`String::clear`]-like behavior (truncating to zero-length)//! but ensures the backing memory is securely zeroed with some caveats.//! With the `std` feature enabled (which it is **not** by default), [`Zeroize`]//! is also implemented for [`CString`]. After calling `zeroize()` on a `CString`,//! its internal buffer will contain exactly one nul byte. The backing//! memory is zeroed by converting it to a `Vec<u8>` and back into a `CString`.//! (NOTE: see "Stack/Heap Zeroing Notes" for important `Vec`/`String`/`CString` details)//! [`CString`]: https://doc.rust-lang.org/std/ffi/struct.CString.html//! The [`DefaultIsZeroes`] marker trait can be impl'd on types which also//! impl [`Default`], which implements [`Zeroize`] by overwriting a value with//! the default value.//! ## Custom Derive Support//! This crate has custom derive support for the `Zeroize` trait,//! gated under the `zeroize` crate's `zeroize_derive` Cargo feature,//! which automatically calls `zeroize()` on all members of a struct//! or tuple struct.//! Attributes supported for `Zeroize`://! On the item level://! - `#[zeroize(drop)]`: *deprecated* use `ZeroizeOnDrop` instead//! - `#[zeroize(bound = "T: MyTrait")]`: this replaces any trait bounds//!   inferred by zeroize//! On the field level://! - `#[zeroize(skip)]`: skips this field or variant when calling `zeroize()`//! Attributes supported for `ZeroizeOnDrop`://! Example which derives `Drop`://! # #[cfg(feature = "zeroize_derive")]//! use zeroize::{Zeroize, ZeroizeOnDrop};//! // This struct will be zeroized on drop//! #[derive(Zeroize, ZeroizeOnDrop)]//! struct MyStruct([u8; 32]);//! Example which does not derive `Drop` (useful for e.g. `Copy` types)//! #[cfg(feature = "zeroize_derive")]//! // This struct will *NOT* be zeroized on drop//! #[derive(Copy, Clone, Zeroize)]//! Example which only derives `Drop`://! use zeroize::ZeroizeOnDrop;//! #[derive(ZeroizeOnDrop)]//! ## `Zeroizing<Z>`: wrapper for zeroizing arbitrary values on drop//! `Zeroizing<Z: Zeroize>` is a generic wrapper type that impls `Deref`//! and `DerefMut`, allowing access to an inner value of type `Z`, and also//! impls a `Drop` handler which calls `zeroize()` on its contents://! use zeroize::Zeroizing;//! fn use_secret() {//!     let mut secret = Zeroizing::new([0u8; 5]);//!     // Set the air shield password//!     // Protip (again): don't embed secrets in your source code.//!     secret.copy_from_slice(&[1, 2, 3, 4, 5]);//!     assert_eq!(secret.as_ref(), &[1, 2, 3, 4, 5]);//!     // The contents of `secret` will be automatically zeroized on drop//! # use_secret()//! ## What guarantees does this crate provide?//! This crate guarantees the following://! 1. The zeroing operation can't be "optimized away" by the compiler.//! 2. All subsequent reads to memory will see "zeroized" values.//! LLVM's volatile semantics ensure #1 is true.//! Additionally, thanks to work by the [Unsafe Code Guidelines Working Group],//! we can now fairly confidently say #2 is true as well. Previously there were//! worries that the approach used by this crate (mixing volatile and//! non-volatile accesses) was undefined behavior due to language contained//! in the documentation for `write_volatile`, however after some discussion//! [these remarks have been removed] and the specific usage pattern in this//! crate is considered to be well-defined.//! Additionally this crate leverages [`core::sync::atomic::compiler_fence`]//! with the strictest ordering//! ([`Ordering::SeqCst`]) as a//! precaution to help ensure reads are not reordered before memory has been//! zeroed.//! All of that said, there is still potential for microarchitectural attacks//! (ala Spectre/Meltdown) to leak "zeroized" secrets through covert channels.//! This crate makes no guarantees that zeroized values cannot be leaked//! through such channels, as they represent flaws in the underlying hardware.//! ## Stack/Heap Zeroing Notes//! This crate can be used to zero values from either the stack or the heap.//! However, be aware several operations in Rust can unintentionally leave//! copies of data in memory. This includes but is not limited to://! - Moves and [`Copy`]//! - Heap reallocation when using [`Vec`] and [`String`]//! - Borrowers of a reference making copies of the data//! [`Pin`][`core::pin::Pin`] can be leveraged in conjunction with this crate//! to ensure data kept on the stack isn't moved.//! The `Zeroize` impls for `Vec`, `String` and `CString` zeroize the entire//! capacity of their backing buffer, but cannot guarantee copies of the data//! were not previously made by buffer reallocation. It's therefore important//! when attempting to zeroize such buffers to initialize them to the correct//! capacity, and take care to prevent subsequent reallocation.//! The `secrecy` crate provides higher-level abstractions for eliminating//! usage patterns which can cause reallocations://! <https://crates.io/crates/secrecy>//! ## What about: clearing registers, mlock, mprotect, etc?//! This crate is focused on providing simple, unobtrusive support for reliably//! zeroing memory using the best approach possible on stable Rust.//! Clearing registers is a difficult problem that can't easily be solved by//! something like a crate, and requires either inline ASM or rustc support.//! See <https://github.com/rust-lang/rust/issues/17046> for background on//! this particular problem.//! Other memory protection mechanisms are interesting and useful, but often//! overkill (e.g. defending against RAM scraping or attackers with swap access).//! In as much as there may be merit to these approaches, there are also many//! other crates that already implement more sophisticated memory protections.//! Such protections are explicitly out-of-scope for this crate.//! Zeroing memory is [good cryptographic hygiene] and this crate seeks to promote//! it in the most unobtrusive manner possible. This includes omitting complex//! `unsafe` memory protection systems and just trying to make the best memory//! zeroing crate available.//! [Zeroing memory securely is hard]: http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html//! [Unsafe Code Guidelines Working Group]: https://github.com/rust-lang/unsafe-code-guidelines//! [these remarks have been removed]: https://github.com/rust-lang/rust/pull/60972//! [good cryptographic hygiene]: https://github.com/veorq/cryptocoding#clean-memory-of-secret-data//! [`Ordering::SeqCst`]: core::sync::atomic::Ordering::SeqCst//! [`Zeroize`] impls for x86 SIMD registersZEROIZE_ATTR/// Name of zeroize-related attributesderive_zeroize/// Derive the `Zeroize` trait./// Supports the following attributes:/// On the item level:/// - `#[zeroize(drop)]`: *deprecated* use `ZeroizeOnDrop` instead/// - `#[zeroize(bound = "T: MyTrait")]`: this replaces any trait bounds///   inferred by zeroize-derive/// On the field level:/// - `#[zeroize(skip)]`: skips this field or variant when calling `zeroize()`derive_zeroize_implderive_zeroize_on_drop/// Derive the `ZeroizeOnDrop` trait.derive_zeroize_on_drop_impl/// Derive a `Drop` impl which calls zeroize on this type/// Custom bounds as defined by the userauto_params/// Type parameters in use by fieldsZeroizeAttrs/// Custom derive attributes for `Zeroize`/// Parsing helper for custom boundsBoundAccumulator/// Parse attributes from the incoming ASTparse_attr/// Parse attribute and handle `#[zeroize(...)]` attributes/// Parse `#[zeroize(...)]` attribute metadata (e.g. `drop`)generate_fieldsattr_skipimpl_zeroize_on_dropparse_zeroize_testzeroize_without_dropzeroize_with_dropzeroize_with_skipzeroize_with_boundzeroize_only_dropzeroize_on_structzeroize_on_enumzeroize_on_struct_fieldzeroize_on_tuple_struct_fieldzeroize_on_second_fieldzeroize_on_tuple_enum_variant_fieldzeroize_on_enum_variant_fieldzeroize_on_enum_second_variant_fieldzeroize_on_enum_variantzeroize_on_enum_second_variantzeroize_skip_on_structzeroize_skip_on_enumzeroize_duplicate_skipzeroize_duplicate_skip_listzeroize_duplicate_skip_enumzeroize_duplicate_boundzeroize_duplicate_bound_listzeroize_bound_structzeroize_bound_enumzeroize_bound_enum_variant_fieldzeroize_bound_no_valuezeroize_bound_no_where_predicate//! Custom derive support for `zeroize`aes_ctrAesModePWD_VERIFY_LENGTH/// The length of the password verifcation value in bytesAUTH_CODE_LENGTH/// The length of the authentication code in bytesITERATION_COUNT/// The number of iterations used with PBKDF2cipher_from_modeAesCipher/// Create a AesCipher depending on the used `AesMode` and the given `key`./// This panics if `key` doesn't have the correct size for the chosen aes mode.aes_modeAesReader// An aes encrypted file starts with a salt, whose length depends on the used aes mode// followed by a 2 byte password verification value// then the variable length encrypted data// and lastly a 10 byte authentication codeAesReaderValid/// Read the AES header bytes and validate the password./// Even if the validation succeeds, there is still a 1 in 65536 chance that an incorrect/// password was provided./// It isn't possible to check the authentication code in this step. This will be done after/// reading and decrypting the file./// If the password verification failed `Ok(None)` will be returned to match the validate/// method of ZipCryptoReader.data_remaining/// A reader for aes encrypted files, which has already passed the first password check./// There is a 1 in 65536 chance that an invalid password passes that check./// After the data has been read and decrypted an HMAC will be checked and provide a final means/// to check if either the password is invalid or if the data has been changed./// This implementation does not fulfill all requirements set in the trait documentation./// "If an error is returned then it must be guaranteed that no bytes were read."/// Whether this applies to errors that occur while reading the encrypted data depends on the/// underlying reader. If the error occurs while verifying the HMAC, the reader might become/// practically unusable, since its position after the error is not known.//! Implementation of the AES decryption for zip files.//! This was implemented according to the [WinZip specification](https://www.winzip.com/win/en/aes_info.html).//! Note that using CRC with AES depends on the used encryption specification, AE-1 or AE-2.//! If the file is marked as encrypted with AE-2 the CRC field is ignored, even if it isn't set to 0.// use aes::{BlockEncrypt, NewBlockCipher};/// Internal block size of an AES cipher./// AES-192/// Key type./// Cipher used to decrypt.AesKind/// An AES cipher kind./// Current AES counter./// AES cipher instance./// Stores the currently available keystream bytes./// Number of bytes already used up from `buffer`.AesCtrZipKeyStream/// An AES-CTR key stream generator./// Implements the slightly non-standard AES-CTR variant used by WinZip AES encryption./// Typical AES-CTR implementations combine a nonce with a 64 bit counter. WinZIP AES instead uses/// no nonce and also uses a different byte order (little endian) than NIST (big endian)./// The stream implements the `Read` trait; encryption or decryption is performed by XOR-ing the/// bytes from the key stream with the ciphertext/plaintext./// Creates a new zip variant AES-CTR key stream./// This panics if `key` doesn't have the correct size for cipher `C`.crypt_in_place/// Decrypt or encrypt `target`./// This trait allows using generic AES ciphers with different key sizes./// XORs a slice in place with another slice./// Checks whether `crypt_in_place` produces the correct plaintext after one use and yields the/// cipertext again after applying it again.new_with_wrong_key_sizecrypt_aes_256_0_byte// The data used in these tests was generated with p7zip without any compression.// It's not possible to recreate the exact same data, since a random salt is used for encryption.// `7z a -phelloworld -mem=AES256 -mx=0 aes256_40byte.zip 40byte_data.txt`crypt_aes_128_5_bytecrypt_aes_192_5_bytecrypt_aes_256_5_bytecrypt_aes_128_40_bytecrypt_aes_192_40_bytecrypt_aes_256_40_byte//! A counter mode (CTR) for AES to work with the encryption used in zip files.//! This was implemented since the zip specification requires the mode to not use a nonce and uses a//! different byte order (little endian) than NIST (big endian).//! See [AesCtrZipKeyStream] for more information.Stored/// Store the file as isDeflated/// Compress the file using DeflateBzip2/// Compress the file using BZIP2/// Encrypted using AES./// The actual compression method has to be taken from the AES extra data field/// or from `ZipFileData`./// Compress the file using ZStandard/// Unsupported compression method/// Identifies the storage format used to compress a file within a ZIP archive./// Each file's compression method is stored alongside it, allowing the/// contents to be read without context./// When creating ZIP files, you may choose the method to use with/// [`crate::write::FileOptions::compression_method`]STOREREDUCE_1REDUCE_2REDUCE_3REDUCE_4IMPLODEDEFLATEDEFLATE64PKWARE_IMPLODEBZIP2LZMAIBM_ZOS_CMPSCIBM_TERSEZSTD_DEPRECATEDZSTDMP3XZWAVPACKPPMD/// All compression methods defined for the ZIP format/// Converts an u16 to its corresponding CompressionMethod/// Converts a CompressionMethod to a u16SUPPORTED_COMPRESSION_METHODS/// The compression methods which have been implemented.from_eq_toto_eq_fromto_display_fmt//! Possible ZIP compression methods./// Target typefrom_cp437/// Function that does the conversion from cp437./// Generally allocations will be avoided if all data falls into the ASCII range.FromCp437/// Trait to convert IBM codepage 437 to the target typeto_char_validexample_sliceexample_vec//! Convert a string in IBM codepage 437 to UTF-8ae2_encrypted/// Signals if `inner` stores aes encrypted data./// AE-2 encrypted data doesn't use crc and sets the value to 0.Crc32Reader/// Reader that validates the CRC32 when it reaches the EOF./// Get a new Crc32Reader which checks the inner reader against checksum./// The check is disabled if `ae2_encrypted == true`.check_matchestest_empty_readertest_byte_by_bytetest_zero_read//! Helper module to compute a CRC32 checksumZipArchiveZipWritercp437zipcrypto/// Unstable APIs/// All APIs accessible by importing this module are unstable; They may be changed in patch releases./// You MUST you an exact version specifier in `Cargo.toml`, to indicate the version of this API you're using:/// zip = "=0.6.6"//! A library for reading and writing ZIP archives.//! ZIP is a format designed for cross-platform file "archiving".//! That is, storing a collection of files in a single datastream//! to make them easier to share between computers.//! Additionally, ZIP is able to compress and encrypt files in its//! archives.//! The current implementation is based on [PKWARE's APPNOTE.TXT v6.3.9](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT)//! [`zip`](`crate`) has support for the most common ZIP archives found in common use.//! However, in special cases,//! there are some zip archives that are difficult to read or write.//! This is a list of supported features://! |         | Reading | Writing |//! | ------- | ------  | ------- |//! | Deflate | ✅ [->](`crate::ZipArchive::by_name`)      | ✅ [->](`crate::write::FileOptions::compression_method`) |central_header_to_zip_file_innerread_zipfile_from_streamZipErrorZipFileZipFileDataZipResultZipStreamReader/// Stream decoder for zip./// Create a new ZipStreamReaderparse_central_directoryZipStreamFileMetadataZipStreamVisitor/// Iteraate over the stream and extract all file and their/// Extract a Zip archive into a directory, overwriting files if they/// already exist. Paths are sanitized with [`ZipFile::enclosed_name`]./// Extraction is not atomic; If an error is encountered, some of the files/// may be left on disk.///  * `file` - contains the content of the file and most of the metadata,///    except:///     - `comment`: set to an empty string///     - `data_start`: set to 0///     - `external_attributes`: `unix_mode()`: will return Nonevisit_additional_metadata/// This function is guranteed to be called after all `visit_file`s.///  * `metadata` - Provides missing metadata in `visit_file`./// Visitor for ZipStreamReader/// Additional metadata for the file./// Get the name of the file/// It is dangerous to use this name directly when extracting an archive./// It may contain an absolute path (`/etc/shadow`), or break out of the/// current directory (`../runtime`). Carelessly writing to these paths/// allows an attacker to craft a ZIP archive that will overwrite critical/// files./// You can use the [`ZipFile::enclosed_name`] method to validate the name/// as a safe path./// Get the name of the file, in the raw (internal) byte representation./// The encoding of this data is currently undefined./// Rewrite the path, ignoring any path components with special meaning./// - Absolute paths are made relative/// - [`ParentDir`]s are ignored/// - Truncates the filename at a NULL byte/// This is appropriate if you need to be able to extract *something* from/// any archive, but will easily misrepresent trivial paths like/// `foo/../bar` as `foo/bar` (instead of `bar`). Because of this,/// [`ZipFile::enclosed_name`] is the better option in most scenarios./// [`ParentDir`]: `Component::ParentDir`enclosed_name/// Ensure the file path is safe to use as a [`Path`]./// - It can't contain NULL bytes/// - It can't resolve to a path outside the current directory///   > `foo/../bar` is fine, `foo/../../bar` is not./// - It can't be an absolute path/// This will read well-formed ZIP files correctly, and is resistant/// to path-based exploits. It is recommended over/// [`ZipFile::mangled_name`]./// Returns whether the file is actually a directory/// Returns whether the file is a regular file/// Get the comment of the file/// Get the starting offset of the data of the compressed fileunix_mode/// Get unix mode for the fileDummyVisitorCounterVisitorinvalid_offsetinvalid_offset2zip_read_streamingfile_and_dir_predicatesinvalid_cde_number_of_files_allocation_smaller_offset/// test case to ensure we don't preemptively over allocate based on the/// declared number of files in the CDE of an invalid zip when the number of/// files declared is more than the alleged offset in the CDEinvalid_cde_number_of_files_allocation_greater_offset/// files declared is less than the alleged offset in the CDEInvalidPasswordAesVendorVersionZipCryptoReaderZipCryptoReaderValidZipCryptoValidator/// Provides high level API for reading from a stream.names_map/// Extract immutable data from `ZipArchive` to make it cheap to clone/// ZIP archive reader/// At the moment, this type is cheap to clone if this is the case for the/// reader it uses. However, this is not guaranteed by this crate and it may/// change in the future./// fn list_zip_contents(reader: impl Read + Seek) -> zip::result::ZipResult<()> {///     let mut zip = zip::ZipArchive::new(reader)?;///     for i in 0..zip.len() {///         let mut file = zip.by_index(i)?;///         println!("Filename: {}", file.name());///         std::io::copy(&mut file, &mut std::io::stdout());zip_archive// Put the struct declaration in a private module to convince rustdoc to display ZipArchive nicelyCryptoReaderPlaintextZipCryptovendor_versionis_ae2_encrypted/// Returns `true` if the data is encrypted using AE2.ZipFileReaderNoReadercrypto_reader/// A struct for reading a zip filefind_contentmake_crypto_readermake_readerget_directory_countsCentralDirectoryEnd/// Get the directory start offset and number of files. This is done in a/// separate function to ease the control flow design./// Read a ZIP archive, collecting the files it contains/// This uses the central directory record of the ZIP file, and ignores local file headers/// Number of files contained in this zip./// Whether this zip archive contains no files/// Get the offset from the beginning of the underlying reader that this zip begins at, in bytes./// Normally this value is zero, but if the zip has arbitrary data prepended to it, then this value will be the size/// of that prepended data./// Get the comment of the zip archive./// Returns an iterator over all the file and directory names in this archive.by_name_decrypt/// Search for a file entry by name, decrypt with given password/// The implementation of the cryptographic algorithms has not/// gone through a correctness review, and you should assume it is insecure:/// passwords used with this API may be compromised./// This function sometimes accepts wrong password. This is because the ZIP spec only allows us/// to check for a 1/256 chance that the password is correct./// There are many passwords out there that will also pass the validity checks/// we are able to perform. This is a weakness of the ZipCrypto algorithm,/// due to its fairly primitive approach to cryptography./// Search for a file entry by nameby_name_with_optional_passwordby_index_decrypt/// Get a contained file by index, decrypt with given passwordby_index/// Get a contained file by indexby_index_raw/// Get a contained file by index without decompressing itby_index_with_optional_password/// Unwrap and return the inner reader object/// The position of the reader is undefined.unsupported_zip_errorcentral_header_to_zip_file/// Parse a central directory entry to collect the information for the file.parse_extra_fieldget_readerget_raw_readerversion_made_by/// Get the version of the file/// Get the name of the file in a sanitized form. It truncates the name to the first NULL byte,/// removes a leading '/' and removes '..' parts./// Get the compression method used to store the file/// Get the size of the file, in bytes, in the archive/// Get the size of the file, in bytes, when uncompressed/// Get the time the file was last modified/// Get the CRC32 hash of the original fileextra_data/// Get the extra data of the zip header for this fileheader_start/// Get the starting offset of the zip header for this filecentral_header_start/// Get the starting offset of the zip header in the central directory for this file/// Methods for retrieving information on zip files/// Read ZipFile structures from a non-seekable reader./// This is an alternative method to read a zip file. If possible, use the ZipArchive functions/// as some information will be missing when reading this manner./// Reads a file header from the start of the stream. Will return `Ok(Some(..))` if a file is/// present at the start of the stream. Returns `Ok(None)` if the start of the central directory/// is encountered. No more files should be read after this./// The Drop implementation of ZipFile ensures that the reader will be correctly positioned after/// the structure is done./// Missing fields are:/// * `comment`: set to an empty string/// * `data_start`: set to 0/// * `external_attributes`: `unix_mode()`: will return Nonezip64_with_leading_junkzip_contentszip_clone//! Types for reading ZIP archives/// Generic result type with ZipError as its error variant/// The given password is wrong/// An Error caused by I/OInvalidArchive/// This file is probably not a zip archiveUnsupportedArchive/// This archive is not supported/// The requested file could not be found in the archive/// Error type for ZipPASSWORD_REQUIRED/// The text used as an error when a password is required and not supplied/// # use zip::result::ZipError;/// # let mut archive = zip::ZipArchive::new(std::io::Cursor::new(&[])).unwrap();/// match archive.by_index(1) {///     Err(ZipError::UnsupportedArchive(ZipError::PASSWORD_REQUIRED)) => eprintln!("a password is needed to unzip this file"),///     _ => (),/// # ()DateTimeRangeError/// Error type for time parsing//! Error types that can be emitted from this libraryLOCAL_FILE_HEADER_SIGNATURECENTRAL_DIRECTORY_HEADER_SIGNATURECENTRAL_DIRECTORY_END_SIGNATUREZIP64_CENTRAL_DIRECTORY_END_SIGNATUREZIP64_CENTRAL_DIRECTORY_END_LOCATOR_SIGNATUREZIP64_BYTES_THRZIP64_ENTRY_THRdisk_numberdisk_with_central_directorynumber_of_files_on_this_disknumber_of_filescentral_directory_sizecentral_directory_offsetzip_file_commentrecord_too_small// Per spec 4.4.1.4 - a CentralDirectoryEnd field might be insufficient to hold the// required data. In this case the file SHOULD contain a ZIP64 format record// and the field of this record will be set to -1find_and_parseend_of_central_directory_offsetnumber_of_disksZip64CentralDirectoryEndLocatorversion_needed_to_extract//pub extensible_data_sector: Vec<u8>, <-- We don't do anything with this at the moment.Zip64CentralDirectoryEndDos/// Representation of a moment in time./// Zip files use an old format from DOS to store timestamps,/// with its own set of peculiarities./// For example, it has a resolution of 2 seconds!/// A [`DateTime`] can be stored directly in a zipfile with [`FileOptions::last_modified_time`],/// or read from one with [`ZipFile::last_modified`]/// Because there is no timezone associated with the [`DateTime`], they should ideally only/// be used for user-facing descriptions. This also means [`DateTime::to_time`] returns an/// [`OffsetDateTime`] (which is the equivalent of chrono's `NaiveDateTime`)./// Modern zip files store more precise timestamps, which are ignored by [`crate::read::ZipArchive`],/// so keep in mind that these timestamps are unreliable. [We're working on this](https://github.com/zip-rs/zip/issues/156#issuecomment-652981904)./// Constructs an 'default' datetime of 1980-01-01 00:00:00from_msdos/// Converts an msdos (u16, u16) pair to a DateTime objectfrom_date_and_time/// Constructs a DateTime from a specific date and time/// The bounds are:/// * year: [1980, 2107]/// * month: [1, 12]/// * day: [1, 31]/// * hour: [0, 23]/// * minute: [0, 59]/// * second: [0, 60]from_time/// Converts a OffsetDateTime object to a DateTime/// Returns `Err` when this object is out of boundstimepart/// Gets the time portion of this datetime in the msdos representationdatepart/// Gets the date portion of this datetime in the msdos representationto_time/// Converts the DateTime to a OffsetDateTime structure/// Get the year. There is no epoch, i.e. 2018 will be returned as 2018./// Get the month, where 1 = january and 12 = december/// When read from a zip file, this may not be a reasonable value/// Get the day/// Get the hour/// Get the minute/// Get the secondDEFAULT_VERSION/// A type like `AtomicU64` except it implements `Clone` and has predefined/// It uses `Relaxed` ordering because it is not used for synchronisation./// Compatibility of the file attribute information/// Specification version/// True if the file is encrypted.using_data_descriptor/// True if the file uses a data-descriptor section/// Compression method used to store the filecompression_level/// Compression level to store the filelast_modified_time/// Last modified time. This will only have a 2 second precision./// CRC32 checksum/// Size of the file in the ZIP/// Size of the file when extracted/// Name of the filefile_name_raw/// Raw file name. To be used when file_name was incorrectly decoded.extra_field/// Extra field usually used for storage expansionfile_comment/// File comment/// Specifies where the local header of the file starts/// Specifies where the central header of the file starts/// Note that when this is not known, it is set to 0/// Specifies where the compressed data of the file startsexternal_attributes/// External file attributeslarge_file/// Reserve local ZIP64 extra field/// AES mode if applicable/// Structure representing a ZIP file.file_name_sanitizedzip64_extensionversion_neededAe1Ae2/// The encryption specification used to encrypt a file with AES./// According to the [specification](https://www.winzip.com/win/en/aes_info.html#winzip11) AE-2/// does not make use of the CRC check./// AES variant used.sanitizedatetime_defaultdatetime_maxdatetime_boundsdatetime_try_from_boundstime_conversiontime_out_of_boundstime_at_january//! Types that specify what is contained in a ZIP.with_deprecated_encryption/// Write the file with the given password using the deprecated ZipCrypto algorithm./// This is not recommended for new archives, as ZipCrypto is not secure.FileOptionsExt/// Unstable methods for [`FileOptions`]./// Types for creating ZIP archives.MaybeEncryptedUnencryptedZipCryptoWriterEncryptedGenericZipWriterStorerDeflaterZipWriterStatswriting_to_filewriting_to_extra_fieldwriting_to_central_extra_field_onlywriting_raw/// ZIP archive generator/// Handles the bookkeeping involved in building an archive, and provides an/// API to edit its contents./// # fn doit() -> zip::result::ZipResult<()>/// # use zip::ZipWriter;/// use zip::write::FileOptions;/// // We use a buffer here, though you'd normally use a `File`/// let mut buf = [0; 65536];/// let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut buf[..]));/// let options = zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);/// zip.start_file("hello_world.txt", options)?;/// zip.write(b"Hello, World!")?;/// // Apply the changes you've made./// // Dropping the `ZipWriter` will have the same effect, but may silently fail/// zip.finish()?;/// # doit().unwrap();zip_writer// Put the struct declaration in a private module to convince rustdoc to display ZipWriter nicelyZipRawValuesZipCryptoKeys/// Metadata for a file to be written/// Set the compression method for the new file/// The default is `CompressionMethod::Deflated`. If the deflate compression feature is/// disabled, `CompressionMethod::Stored` becomes the default./// Set the compression level for the new file/// `None` value specifies default compression level./// Range of values depends on compression method:/// * `Deflated`: 0 - 9. Default is 6/// * `Bzip2`: 0 - 9. Default is 6/// * `Zstd`: -7 - 22, with zero being mapped to default level. Default is 3/// * others: only `None` is allowed/// Set the last modified time/// The default is the current timestamp if the 'time' feature is enabled, and 1980-01-01/// otherwiseunix_permissions/// Set the permissions for the new file./// The format is represented with unix-style permissions./// The default is `0o644`, which represents `rw-r--r--` for files,/// and `0o755`, which represents `rwxr-xr-x` for directories./// This method only preserves the file permissions bits (via a `& 0o777`) and discards/// higher file mode bits. So it cannot be used to denote an entry as a directory,/// symlink, or other special file type./// Set whether the new file's compressed and uncompressed size is less than 4 GiB./// If set to `false` and the file exceeds the limit, an I/O error is thrown. If set to `true`,/// readers will require ZIP64 support and if the file does not exceed the limit, 20 B are/// wasted. The default is `false`./// Construct a new FileOptions object/// Initializes the archive from an existing ZIP archive, making it ready for append./// Initializes the archive./// Before writing to this object, the [`ZipWriter::start_file`] function should be called./// Set ZIP archive comment.set_raw_comment/// This sets the raw bytes of the comment. The comment/// is typically expected to be encoded in UTF-8start_entry/// Start a new file for with the requested options.finish_filestart_file/// Create a file in the archive and start writing its' contents./// The data should be written using the [`io::Write`] implementation on this [`ZipWriter`]start_file_from_path/// Starts a file, taking a Path as argument./// This function ensures that the '/' path separator is used. It also ignores all non 'Normal'/// Components, such as a starting '/' or '..' and '.'.start_file_aligned/// Create an aligned file in the archive and start writing its' contents./// Returns the number of padding bytes required to align the file.start_file_with_extra_data/// Create a file in the archive and start writing its extra data first./// Finish writing extra data and start writing file data with [`ZipWriter::end_extra_data`]./// Optionally, distinguish local from central extra data with/// [`ZipWriter::end_local_start_central_extra_data`]./// Returns the preliminary starting offset of the file data without any extra data allowing to/// align the file data by calculating a pad length to be prepended as part of the extra data./// use byteorder::{LittleEndian, WriteBytesExt};/// use zip::{ZipArchive, ZipWriter, result::ZipResult};/// use zip::{write::FileOptions, CompressionMethod};/// use std::io::{Write, Cursor};/// # fn main() -> ZipResult<()> {/// let mut archive = Cursor::new(Vec::new());///     let mut zip = ZipWriter::new(&mut archive);///     let options = FileOptions::default()///         .compression_method(CompressionMethod::Stored);///     zip.start_file_with_extra_data("identical_extra_data.txt", options)?;///     let extra_data = b"local and central extra data";///     zip.write_u16::<LittleEndian>(0xbeef)?;///     zip.write_u16::<LittleEndian>(extra_data.len() as u16)?;///     zip.write_all(extra_data)?;///     zip.end_extra_data()?;///     zip.write_all(b"file data")?;///     let data_start = zip.start_file_with_extra_data("different_extra_data.txt", options)?;///     let extra_data = b"local extra data";///     let data_start = data_start as usize + 4 + extra_data.len() + 4;///     let align = 64;///     let pad_length = (align - data_start % align) % align;///     assert_eq!(pad_length, 19);///     zip.write_u16::<LittleEndian>(0xdead)?;///     zip.write_u16::<LittleEndian>(pad_length as u16)?;///     zip.write_all(&vec![0; pad_length])?;///     let data_start = zip.end_local_start_central_extra_data()?;///     assert_eq!(data_start as usize % align, 0);///     let extra_data = b"central extra data";///     zip.finish()?;/// let mut zip = ZipArchive::new(archive)?;/// assert_eq!(&zip.by_index(0)?.extra_data()[4..], b"local and central extra data");/// assert_eq!(&zip.by_index(1)?.extra_data()[4..], b"central extra data");end_local_start_central_extra_data/// End local and start central extra data. Requires [`ZipWriter::start_file_with_extra_data`]./// Returns the final starting offset of the file data.end_extra_data/// End extra data and start file data. Requires [`ZipWriter::start_file_with_extra_data`].raw_copy_file_rename/// Add a new file using the already compressed data from a ZIP file being read and renames it, this/// allows faster copies of the `ZipFile` since there is no need to decompress and compress it again./// Any `ZipFile` metadata is copied and not checked, for example the file CRC./// use std::io::{Read, Seek, Write};/// use zip::{ZipArchive, ZipWriter};/// fn copy_rename<R, W>(///     src: &mut ZipArchive<R>,///     dst: &mut ZipWriter<W>,/// ) -> zip::result::ZipResult<()>///     R: Read + Seek,///     W: Write + Seek,///     // Retrieve file entry by name///     let file = src.by_name("src_file.txt")?;///     // Copy and rename the previously obtained file entry to the destination zip archive///     dst.raw_copy_file_rename(file, "new_name.txt")?;raw_copy_file/// Add a new file using the already compressed data from a ZIP file being read, this allows faster/// copies of the `ZipFile` since there is no need to decompress and compress it again. Any `ZipFile`/// metadata is copied and not checked, for example the file CRC./// fn copy<R, W>(src: &mut ZipArchive<R>, dst: &mut ZipWriter<W>) -> zip::result::ZipResult<()>///     // Copy the previously obtained file entry to the destination zip archive///     dst.raw_copy_file(file)?;/// Add a directory entry./// As directories have no content, you must not call [`ZipWriter::write`] before adding a new file.add_directory_from_path/// Add a directory entry, taking a Path as argument./// Finish the last file and write all other zip-structures/// This will return the writer, but one should normally not append any data to the end of the file./// Note that the zipfile will also be finished on drop.add_symlink/// Add a symlink entry./// The zip archive will contain an entry for path `name` which is a symlink to `target`./// No validation or normalization of the paths is performed. For best results,/// callers should normalize `\` to `/` and ensure symlinks are relative to other/// paths within the zip archive./// WARNING: not all zip implementations preserve symlinks on extract. Some zip/// implementations may materialize a symlink as a regular file, possibly with the/// content incorrectly set to the symlink target. For maximum portability, consider/// storing a regular file instead.switch_tocurrent_compressiondeflate_compression_level_rangebzip2_compression_level_rangeclamp_optwrite_local_file_headerupdate_local_file_headerwrite_central_directory_headervalidate_extra_datawrite_local_zip64_extra_fieldupdate_local_zip64_extra_fieldwrite_central_zip64_extra_fieldwrite_empty_zipunix_permissions_bitmaskwrite_zip_dirwrite_symlink_simplewrite_symlink_wonky_pathswrite_mimetype_zipEXTRA_FIELD_MAPPING//! Types for creating ZIP archiveskey_0key_1key_2/// A container to hold the current key statestream_bytedecrypt_byteencrypt_byte/// A ZipCrypto reader with unverified passwordPkzipCrc32InfoZipMsdosTime/// Note: The password is `&[u8]` and not `&str` because the/// [zip specification](https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE-6.3.3.TXT)/// does not specify password encoding (see function `update_keys` in the specification)./// Therefore, if `&str` was used, the password would be UTF-8 and it/// would be impossible to decrypt files that were encrypted with a/// password byte sequence that is unrepresentable in UTF-8./// Read the ZipCrypto header bytes and validate the password./// A ZipCrypto reader with verified passwordCRCTABLE//! Implementation of the ZipCrypto algorithm//! The following paper was used to implement the ZipCrypto algorithm://! [https://courses.cs.ut.ee/MTAT.07.022/2015_fall/uploads/Main/dmitri-report-f15-16.pdf](https://courses.cs.ut.ee/MTAT.07.022/2015_fall/uploads/Main/dmitri-report-f15-16.pdf)CCtx/// Allows to compress independently multiple chunks of data./// Each job will be processed entirely in-memory without streaming, so this/// is most fitting for many small jobs. To compress larger volume that don't/// easily fit in memory, a streaming compression may be more appropriate./// It is more efficient than a streaming compressor for 2 reasons:/// * It re-uses the zstd context between jobs to avoid re-allocations/// * It avoids copying data from a `Read` into a temporary buffer before compression./// Creates a new zstd compressorwith_dictionary/// Creates a new zstd compressor, using the given dictionary./// Note that using a dictionary means that decompression will need to use/// the same dictionary.with_prepared_dictionaryEncoderDictionary/// Creates a new compressor using an existing `EncoderDictionary`./// The compression level will be the one specified when creating the dictionary./// Changes the compression level used by this compressor./// *This will clear any dictionary previously registered.*/// If you want to keep the existing dictionary, you will need to pass it again to/// `Self::set_dictionary` instead of using this method.set_dictionary/// Changes the dictionary and compression level used by this compressor./// Will affect future compression jobs.set_prepared_dictionary/// Changes the dictionary used by this compressor./// The compression level used when preparing the dictionary will be used.compress_to_buffer/// Compress a single block of data to the given destination buffer./// Returns the number of bytes written, or an error if something happened/// (for instance if the destination buffer was too small)./// A level of `0` uses zstd's default (currently `3`)./// Compresses a block of data and returns the compressed result.context_mut/// Gives mutable access to the internal context./// Sets a compression parameter for this compressor.encoder_parametersr" Controls whether zstd should include a content checksum at the end"r" of each frame."include_checksumr" Enables or disables storing of the dict id."r" Defaults to true. If false, the behaviour of decoding with a wrong"r" dictionary is undefined."include_dictidr" Enables or disabled storing of the contentsize."r" Note that this only has an effect if the size is given with `set_pledged_src_size`."include_contentsizer" Enables or disables long-distance matching"long_distance_matchingr" Sets the maximum back-reference distance."r" The actual maximum distance is going to be `2^log_distance`."r" Note that decompression will need to use at least the same setting."_assert_traitsDCtx/// Allows to decompress independently multiple blocks of data./// This reduces memory usage compared to calling `decompress` multiple times./// Creates a new zstd decompressor./// Creates a new zstd decompressor, using the given dictionary.DecoderDictionary/// Creates a new decompressor using an existing `DecoderDictionary`./// Note that using a dictionary means that compression will need to use/// Changes the dictionary used by this decompressor.decompress_to_buffer/// Deompress a single block of data to the given destination buffer./// Decompress a block of data, and return the result in a `Vec<u8>`./// The decompressed data should be less than `capacity` bytes,/// or an error will be returned./// Sets a decompression parameter for this decompressor.decoder_parametersr" This will need to at least match the value set when compressing."/// Get an upper bound on the decompressed size of data, if available/// This can be used to pre-allocate enough capacity for `decompress_to_buffer`/// and is used by `decompress` to ensure that it does not over-allocate if/// you supply a large `capacity`./// Will return `None` if the upper bound cannot be determined or is larger than `usize::MAX`/// Note that unless the `experimental` feature is enabled, this will always return `None`./// Compresses a single block of data to the given destination buffer./// Decompresses a block of data and returns the decompressed result.//! Compress and decompress data in bulk.//! These methods process all the input data at once.//! It is therefore best used with relatively small blocks//! (like small network packets).test_directtest_stream_compathas_content_sizeCDictDDictcdict/// Prepared dictionary for compression/// A dictionary can include its own copy of the data (if it is `'static`), or it can merely point/// to a separate buffer (if it has another lifetime)./// Creates a prepared dictionary for compression./// This will copy the dictionary internally.as_cdict/// Returns reference to `CDict` inner objectddict/// Prepared dictionary for decompression/// Create a prepared dictionary for decompression.as_ddict/// Returns reference to `DDict` inner objectfrom_continuous/// Train a dictionary from a big continuous chunk of data./// This is the most efficient way to train a dictionary,/// since this is directly fed into `zstd`./// Train a dictionary from multiple samples./// The samples will internaly be copied to a single continuous buffer,/// so make sure you have enough memory available./// If you need to stretch your system's limits,/// [`from_continuous`] directly uses the given slice./// [`from_continuous`]: ./fn.from_continuous.html/// Train a dict from a list of files.test_dict_training//! Train a dictionary from various sources.//! A dictionary can help improve the compression of small files.//! The dictionary must be present during decompression,//! but can be shared accross multiple "similar" files.//! Creating a dictionary using the `zstd` C library,//! using the `zstd` command-line interface, using this library,//! or using the `train` binary provided, should give the same result,//! and are therefore completely compatible.//! To use, see [`Encoder::with_dictionary`] or [`Decoder::with_dictionary`].//! [`Encoder::with_dictionary`]: ../struct.Encoder.html#method.with_dictionary//! [`Decoder::with_dictionary`]: ../struct.Decoder.html#method.with_dictionary// Re-export the zstd-safe crate.bulkCLEVEL_DEFAULTDEFAULT_COMPRESSION_LEVEL/// Default compression level.compression_level_range/// The accepted range of compression levels./// Returns the error message as io::Error based on error_code.test_cycletest_cycle_unwrapdefault_compression_level_in_range//! Rust binding to the [zstd library][zstd].//! * An [encoder](stream/write/struct.Encoder.html) to compress data using zstd//!   and send the output to another write.//! * A [decoder](stream/read/struct.Decoder.html) to read input data from a `Read`//!   and decompress it.//! * Convenient functions for common tasks.//! // Uncompress input and print the result.//! zstd::stream::copy_decode(io::stdin(), io::stdout()).unwrap();//! [zstd]: https://github.com/facebook/zstd// Some helper functions to write full-cycle tests./// Decompress from the given source as if using a `Decoder`./// The input data must be in the zstd frame format.copy_decode/// Decompressed data will be appended to `destination`./// Compress all data from the given source as if using an `Encoder`./// Result will be in the zstd frame format.copy_encode/// Compressed data will be appended to `destination`.AutoFinishEncoder/// Common functions for the decoder, both in read and write mode.decoder_common/// Parameter-setters for the encoder. Relies on a `set_parameter` method.encoder_common/// Common functions for the encoder, both in read and write mode.//! Compress and decompress Zstd streams.//! Zstd streams are the main way to compress and decompress data.//! They are compatible with the `zstd` command-line tool.//! This module provides both `Read` and `Write` interfaces to compressing and//! decompressing.InBufferOutBuffer/// Performs a single step of this operation./// Should return a hint for the next input size./// If the result is `Ok(0)`, it may indicate that a frame was justrun_on_buffers/// This is a comvenience wrapper around `Operation::run` if you don't/// want to deal with `InBuffer`/`OutBuffer`./// Flushes any internal buffer, if any./// Returns the number of bytes still in the buffer./// To flush entirely, keep calling until it returns `Ok(0)`./// Prepares the operation for a new frame./// This is hopefully cheaper than creating a new operation./// Finishes the operation, writing any footer if necessary./// Returns the number of bytes still to write./// Keep calling this method until it returns `Ok(0)`,/// and then don't ever call this method./// Represents an abstract compression/decompression operation./// This trait covers both `Encoder` and `Decoder`./// Dummy operation that just copies its input to the output./// Number of bytes expected for next input./// This is just a hint./// Number of bytes read from the input./// Number of bytes written to the output./// Describes the result of an operation./// An in-memory decoder for streams of data./// Creates a new decoder./// Creates a new decoder initialized with the given dictionary./// Creates a new decoder, using an existing `DecoderDictionary`./// Sets a decompression parameter for this decoder./// An in-memory encoder for streams of data./// Creates a new encoder initialized with the given dictionary./// Creates a new encoder using an existing `EncoderDictionary`./// Sets a compression parameter for this encoder.set_pledged_src_size/// Sets the size of the input expected by zstd./// May affect compression ratio./// It is an error to give an incorrect size (an error _will_ be returned when closing the/// stream).// This requires impl for [u8; N] which is currently behind a feature.//! Raw in-memory stream compression/decompression.//! This module defines a `Decoder` and an `Encoder` to decode/encode streams//! of data using buffers.//! They are mostly thin wrappers around `zstd_safe::{DCtx, CCtx}`./// A decoder that decompress input data from another `Read`./// This allows to read a stream of compressed data/// (good for files or heavy network stream)./// An encoder that compress input data from another `Read`./// Creates a new decoder around a `BufRead`./// Creates a new decoder, using an existing dictionary./// The dictionary must be the same as the one used during compression.single_frame/// Sets this `Decoder` to stop after the first frame./// By default, it keeps concatenating frames until EOF is reached.recommended_output_size/// Recommendation for the size of the output buffer./// Acquire a reference to the underlying reader./// Acquire a mutable reference to the underlying reader./// Return the inner `Read`./// Calling `finish()` is not *required* after reading a stream -/// just use it if you need to get the `Read` back.r" Sets a decompression parameter on the decompression stream."/// Creates a new encoder around a `BufRead`./// Creates a new encoder, using an existing dictionary./// Creates a new encoder, using an existing `EncoderDictionary`.r" Sets the given zstd compression parameter."r" Sets the expected size of the input."r" This affects the compression effectiveness."r" It is an error to give an incorrect size (an error will be returned when closing the"r" stream if the size does not match what was pledged)."r" Giving a `None` size means the size is unknown (this is the default)."//! Implement pull-based [`Read`] trait for both compressing and decompressing.test_error_handlingPartialOptest_end_of_frametest_concatenated_framestest_flushtest_try_finishtest_write_after_try_finishsetup_try_finishtest_failing_writetest_invalid_frametest_incomplete_frametest_cli_compatibilitytest_legacytest_full_cycle// Check that compressing+decompressing some data gives back the originaltest_ll_sourcereader_to_writer// output writer (compressed data)/// An encoder that compress and forward data to another writer./// This allows to compress a stream of data/// Don't forget to call [`finish()`] before dropping it!/// Alternatively, you can call [`auto_finish()`] to use an/// [`AutoFinishEncoder`] that will finish on drop./// Note: The zstd library has its own internal input buffer (~128kb)./// [`finish()`]: #method.finish/// [`auto_finish()`]: #method.auto_finish/// [`AutoFinishEncoder`]: AutoFinishEncoder// output writer (decompressed data)/// A decoder that decompress and forward data to another writer./// Note that you probably want to `flush()` after writing your stream content./// You can use [`auto_flush()`] to automatically flush the writer on drop./// [`auto_flush()`]: Decoder::auto_flush// We wrap this in an option to take it during drop.on_finish/// A wrapper around an `Encoder<W>` that finishes the stream on drop./// This can be created by the [`auto_finish()`] method on the [`Encoder`]./// [`auto_finish()`]: Encoder::auto_finish/// [`Encoder`]: Encoderon_flushAutoFlushDecoder/// A wrapper around a `Decoder<W>` that flushes the stream on drop./// This can be created by the [`auto_flush()`] method on the [`Decoder`]./// [`Decoder`]: Decoder/// Mostly used for testing purposes./// `level`: compression level (1-21)./// (Provides better compression ratio for small files,/// but requires the dictionary to be present during decompression.)/// Creates a new encoder, using an existing prepared `EncoderDictionary`.auto_finish/// Returns a wrapper around `self` that will finish the stream on drop./// Panics on drop if an error happens when finishing the stream./// Returns an encoder that will finish the stream on drop./// Calls the given callback with the result from `finish()`./// **Required**: Finishes the stream./// You *need* to finish the stream when you're done writing, either with/// this method or with [`try_finish(self)`](#method.try_finish)./// This returns the inner writer in case you need it./// To get back `self` in case an error happened, use `try_finish`./// **Note**: If you don't want (or can't) call `finish()` manually after///           writing your data, consider using `auto_finish()` to get an///           `AutoFinishEncoder`./// **Required**: Attempts to finish the stream./// this method or with [`finish(self)`](#method.finish)./// This returns the inner writer if the finish was successful, or the/// object plus an error if it wasn't./// `write` on this object will panic after `try_finish` has been called,/// even if it fails.do_finish/// Attemps to finish the stream.recommended_input_size/// Return a recommendation for the size of data to write at once./// Creates a new decoder, using an existing prepared `DecoderDictionary`./// Returns the inner `Write`.auto_flush/// Returns a wrapper around `self` that will flush the stream on drop./// Panics on drop if an error happens when flushing the stream./// Returns a decoder that will flush the stream on drop./// Calls the given callback with the result from `flush()`.//! Implement push-based [`Write`] trait for both compressing and decompressing.test_partial_write_flush/// Test that flush after a partial write works successfully without/// corrupting the frame. This test is in this module because it checks/// internal implementation details.test_partial_write_finish/// Test that finish after a partial write works successfully withoutsetup_partial_write//! Wrappers around raw operations implementing `std::io::{Read, Write}`.finished_frame// [ reader -> zstd ] -> output/// Implements the [`Read`] API around an [`Operation`]./// This can be used to wrap a raw in-memory operation in a read-focused API./// It can wrap either a compression or decompression operation, and pulls/// input data from a wrapped `Read`.// Still actively reading from the inner `Read`PastEof// We reached EOF from the inner `Read`, now flushing.// We are fully done, nothing can be read./// Creates a new `Reader`./// `reader` will be used to pull input data for the given operation.set_single_frame/// Sets `self` to stop after the first decoded frame.operation_mut/// Returns a mutable reference to the underlying operation./// Returns a mutable reference to the underlying reader./// Returns a reference to the underlying reader./// Returns the inner reader.// Read and retry on Interrupted errors.test_nooptest_compress// When `true`, indicates that nothing should be added to the buffer.// All that's left if to empty the buffer./// Implements the [`Write`] API around an [`Operation`]./// This can be used to wrap a raw in-memory operation in a write-focused API./// It can be used with either compression or decompression, and forwards the/// output to a wrapped `Write`./// Creates a new `Writer`./// All output from the given operation will be forwarded to `writer`./// Ends the stream./// This *must* be called after all data has been written to finish the/// If you forget to call this and just drop the `Writer`, you *will* have/// an incomplete output./// Keep calling it until it returns `Ok(())`, then don't call it again./// Run the given closure on `self.buffer`./// The buffer will be cleared, and made available wrapped in an `OutBuffer`.write_from_offset/// Attempt to write `self.buffer` to the wrapped writer./// Returns `Ok(())` once all the buffer has been written./// Return the wrapped `Writer` and `Operation`./// Careful: if you call this before calling [`Writer::finish()`], the/// output may be incomplete./// Gives a reference to the inner writer./// Gives a mutable reference to the inner writer./// Gives a reference to the inner operation./// Gives a mutable reference to the inner operation./// Returns the offset in the current buffer. Only useful for debugging./// Returns the current buffer. Only useful for debugging.test_decompress// input -> [ zstd -> buffer -> writer ]r" Sets the target size for compressed blocks."r" A lower block size may result in slightly lower speed (~2%) and compression ratio"r" (~0.1%), but may decrease end-to-end latency in low-bandwidth environments (time to"r" first decompressed byte)."r" No value, or a value of zero, results in no contraint for the block sizes."set_target_cblock_size/// The decompressed data should be at most `capacity` bytes,/// Train a dictionary from a big continuous chunk of data, with all samples/// contiguous in memory./// * `sample_data` is the concatenation of all sample data./// * `sample_sizes` is the size of each sample in `sample_data`.///     The sum of all `sample_sizes` should equal the length of `sample_data`./// * `max_size` is the maximum size of the dictionary to generate./// The result is the dictionary data. You can, for example, feed it to [`CDict::create`]./// * `samples` is a list of individual samples to train on.from_sample_iterator/// Unlike [`from_samples`], this does not require having a list of all samples./// It also allows running into an error when iterating through the samples./// They will still be copied to a continuous array and fed to [`from_continuous`]./// * `samples` is an iterator of individual samples to train on./// // Train from a couple of json files./// let dict_buffer = zstd::dict::from_sample_iterator(///     ["file_a.json", "file_b.json"]///         .map(|filename| std::fs::File::open(filename)),///     10_000,  // 10kB dictionary/// use std::io::BufRead as _;/// // Treat each line from stdin as a separate sample.///     std::io::stdin().lock().lines().map(|line: std::io::Result<String>| {///         // Transform each line into a `Cursor<Vec<u8>>` so they implement Read.///         line.map(String::into_bytes)///             .map(std::io::Cursor::new)/// * `filenames` is an iterator of files to load. Each file will be treated as an individual///     sample./// * If `remaining = 0`, then we are at the end of a frame./// * If `remaining > 0`, then it's just a hint for how much there is still///   to read./// If `None` is given, it assume the size is not known (default behaviour)./// Flush any internal buffer./// This ensures all input consumed so far is compressed./// Since it prevents bundling currently buffered data with future input,/// it may affect compression ratio./// * Returns the number of bytes written to `out`./// * Returns `Ok(0)` when everything has been flushed./// `level`: compression level (1-22)./// Calls the given callback with the result from `finish()`. This runs during drop so it's/// important that the provided callback doesn't panic./// Calls the given callback with the result from `flush()`. This runs during drop so it's/// For encoders, this ensures all input consumed so far is compressed.BLOCKSIZELOG_MAX// This file has been generated by ./update_consts.shBLOCKSIZE_MAXCONTENTSIZE_ERRORCONTENTSIZE_UNKNOWNMAGIC_DICTIONARYMAGICNUMBERMAGIC_SKIPPABLE_MASKMAGIC_SKIPPABLE_STARTVERSION_MAJORVERSION_MINORVERSION_NUMBERVERSION_RELEASECHAINLOG_MAX_32CHAINLOG_MAX_64CHAINLOG_MINFRAMEHEADERSIZE_MAXHASHLOG_MINLDM_BUCKETSIZELOG_MAXLDM_BUCKETSIZELOG_MINLDM_HASHLOG_MINLDM_HASHRATELOG_MINLDM_MINMATCH_MAXLDM_MINMATCH_MINMINMATCH_MAXMINMATCH_MINOVERLAPLOG_MAXOVERLAPLOG_MINSEARCHLOG_MINSKIPPABLEHEADERSIZESRCSIZEHINT_MINTARGETCBLOCKSIZE_MAXTARGETCBLOCKSIZE_MINTARGETLENGTH_MAXTARGETLENGTH_MINWINDOWLOG_LIMIT_DEFAULTWINDOWLOG_MAX_32WINDOWLOG_MAX_64WINDOWLOG_MIN// Re-export zstd-sysZSTD_strategy/// How to compress data.ZSTD_ResetDirectiveResetDirective/// Reset directive./// Represents the compression level used by zstd./// Represents a possible error from the zstd library.SafeResult/// Wrapper result around most zstd functions./// Either a success code (usually number of bytes written), or an error code./// Returns true if code represents error./// Parse the result code/// Returns the number of bytes written if the code represents success,/// or the error message code otherwise.ptr_voidptr_mut_voidversion_numbermin_c_level/// Returns the minimum (fastest) compression level supported.max_c_level/// Returns the maximum (slowest) compression level supported./// Wraps the `ZSTD_compress` function./// Wraps the `ZSTD_decompress` function.get_decompressed_size/// Wraps the `ZSTD_getDecompressedSize` function.compress_bound/// maximum compressed size in worst case single-pass scenarioZSTD_CCtxtry_create/// Tries to create a new context./// Returns `None` if zstd returns a NULL pointer - may happen if allocation fails./// Wrap `ZSTD_createCCtx`/// If zstd returns a NULL pointer./// Wraps the `ZSTD_compressCCtx()` function/// Wraps the `ZSTD_compress2()` function.compress_using_dict/// Wraps the `ZSTD_compress_usingDict()` function.compress_using_cdict/// Wraps the `ZSTD_compress_usingCDict()` function.load_dictionaryref_cdict/// Wraps the `ZSTD_CCtx_refCDict()` function./// Dictionary must outlive the context.ref_prefixcompress_streamcompress_stream2ZSTD_EndDirective/// Wraps the `ZSTD_compressStream2()` function.flush_stream/// Wraps the `ZSTD_flushStream()` function.end_stream/// Wraps the `ZSTD_endStream()` function.sizeofcreate_cctxc_char_to_strget_error_namecompress_cctxZSTD_DCtx/// A Decompression Context./// The lifetime references the potential dictionary used for this context./// If no dictionary was used, it will most likely be `'static`./// Same as `DStream`./// Wraps the `ZSTD_decompressDCtx()` function.decompress_using_dict/// Wraps `ZSTD_decompress_usingDict`decompress_using_ddict/// Wraps the `ZSTD_decompress_usingDDict()` function./// Wraps the `ZSTD_initCStream()` function./// Initializes an existing `DStream` for decompression./// Wraps the `ZSTD_resetDStream()` function.ref_ddictdecompress_stream/// Wraps the `ZSTD_decompressStream()` function./// Wraps the `ZSTD_DStreamInSize()` function./// Returns a hint for the recommended size of the input buffer for decompression./// Wraps the `ZSTD_DStreamOutSize()` function./// Returns a hint for the recommended size of the output buffer for decompression./// Wraps the `ZSTD_sizeof_DCtx()` function.create_dctx/// Prepares a new decompression context without dictionary.decompress_dctx/// Wraps the `ZSTD_decompress_usingDict()` function.ZSTD_CDict/// Compression dictionary.get_dict_idcreate_cdict/// Wraps the `ZSTD_createCDict()` function.ZSTD_DDict/// A digested decompression dictionary.create_ddict/// Wraps the `ZSTD_createDDict()` function./// It copies the dictionary internally, so the resulting `DDict` is `'static`.CStream/// Compression stream./// Same as `CCtx`.create_cstream/// Allocates a new `CStream`.init_cstream/// Prepares an existing `CStream` for compression at the given level./// Wrapper around an input buffer./// Bytes will be read starting at `src[pos]`./// `pos` will be updated after reading./// Returns the valid data part of this container. Should only cover initialized data./// Returns the full capacity of this container. May include uninitialized data./// Returns a pointer to the start of the data.filled_until/// Indicates that the first `n` bytes of the container have been written.write_from/// Call the given closure using the pointer and capacity from `self`./// Assumes the given function returns a parseable code, which if valid, represents how many/// bytes were written to `self`./// The given closure must treat its first argument as pointing to potentially uninitialized/// memory, and should not read from it./// In addition, it must have written at least `n` bytes contiguously from this pointer, where/// `n` is the returned value./// Describe a resizeable bytes container like `Vec<u8>`./// Can start from uninitialized memory, and will be partially filled./// Should be implemented by a contiguous chunk of memory./// The main implementors are:/// * `Vec<u8>` and similar structures. These can start empty with a non-zero capacity, and they///   will be resized to cover the data written./// * `[u8]` and `[u8; N]`. These must start already-initialized, and will not be resized. It will///   be up to the caller to only use the part that was written./// Wrapper around an output buffer./// `C` is usually either `[u8]` or `Vec<u8>`./// Bytes will be written starting at `dst[pos]`./// `pos` will be updated after writing./// `pos <= dst.capacity()`ptr_mut/// Convenience method to get a mut pointer from a mut ref.ZSTD_outBufferOutBufferWrapper/// Interface between a C-level ZSTD_outBuffer and a rust-level `OutBuffer`./// Will update the parent buffer from the C buffer on drop.around/// Returns a new `OutBuffer` around the given slice./// Starts with `pos = 0`.around_pos/// Returns a new `OutBuffer` around the given slice, starting at the given position./// If `pos >= dst.capacity()`./// Returns the current cursor position.set_pos/// Sets the new cursor position./// If `pos > self.dst.capacity()`./// Data up to `pos` must have actually been written to./// Returns the part of this buffer that was written to.ZSTD_inBufferInBufferWrapper/// Returns a new `InBuffer` around the given slice./// If `pos > self.src.len()`./// Wraps the `ZSTD_compressStream()` function.cstream_in_size/// Wraps `ZSTD_CStreamInSize()`cstream_out_size/// Wraps `ZSTD_CStreamOutSize()`DStream/// A Decompression stream./// Same as `DCtx`.create_dstreaminit_dstreamdstream_in_sizedstream_out_sizefind_frame_compressed_size/// Wraps the `ZSTD_findFrameCompressedSize()` function./// `src` should contain at least an entire frame.get_frame_content_size/// Wraps the `ZSTD_getFrameContentSize()` function./// `src` should contain at least a frame header.sizeof_cctx/// Wraps the `ZSTD_sizeofCCtx()` function.sizeof_dctxsizeof_cstream/// Wraps the `ZSTD_sizeof_CStream()` function.sizeof_dstream/// Wraps the `ZSTD_sizeof_DStream()` function.sizeof_cdict/// Wraps the `ZSTD_sizeof_CDict()` function.sizeof_ddict/// Wraps the `ZSTD_sizeof_DDict()` function.get_dict_id_from_dict/// Wraps the `ZSTD_getDictID_fromDict()` function.get_dict_id_from_ddict/// Wraps the `ZSTD_getDictID_fromDDict()` function.get_dict_id_from_frame/// Wraps the `ZSTD_getDictID_fromFrame()` function.cctx_load_dictionary/// Wraps the `ZSTD_CCtx_loadDictionary()` function.cctx_ref_cdictcctx_ref_prefix/// Wraps the `ZSTD_CCtx_refPrefix()` function./// Dictionary must outlive the prefix.dctx_load_dictionary/// Wraps the `ZSTD_DCtx_loadDictionary()` function.dctx_ref_ddict/// Wraps the `ZSTD_DCtx_refDDict()` function.dctx_ref_prefix/// Wraps the `ZSTD_DCtx_refPrefix()` function.cctx_reset/// Wraps the `ZSTD_CCtx_reset()` function.dctx_reset/// Wraps the `ZSTD_DCtx_reset()` function.WindowLogHashLogChainLogSearchLogMinMatchTargetLengthEnableLongDistanceMatchingLdmHashLogLdmMinMatchLdmBucketSizeLogLdmHashRateLogContentSizeFlagChecksumFlagDictIdFlagNbWorkers/// Note: this will only work if the `zstdmt` feature is activated.JobSizeOverlapSizeLog/// A compression parameter.WindowLogMax/// A decompression parameter.dctx_set_parameter/// Wraps the `ZSTD_DCtx_setParameter()` function.cctx_set_parameter/// Wraps the `ZSTD_CCtx_setParameter()` function.cctx_set_pledged_src_size/// Wraps the `ZSTD_CCtx_setPledgedSrcSize()` function.train_from_buffer/// Wraps the `ZDICT_trainFromBuffer()` function.//! Minimal safe wrapper around zstd-sys.//! This crates provides a minimal translation of the [zstd-sys] methods.//! For a more comfortable high-level library, see the [zstd] crate.//! [zstd-sys]: https://crates.io/crates/zstd-sys//! [zstd]: https://crates.io/crates/zstd//! Most of the functions here map 1-for-1 to a function from//! [the C zstd library][zstd-c] mentioned in their descriptions.//! Check the [source documentation][doc] for more information on their//! behaviour.//! [doc]: https://facebook.github.io/zstd/zstd_manual.html//! [zstd-c]: https://facebook.github.io/zstd///! Features denoted as experimental in the C library are hidden behind an//! `experimental` feature.// CCtx can't be shared across threads, so it does not implement Sync.// DCtx can't be shared across threads, so it does not implement Sync.// CStream can't be shared across threads, so it does not implement Sync./*
// This is possible, but... why?
unsafe impl<'a> WriteBuf for OutBuffer<'a, [u8]> {
    fn as_slice(&self) -> &[u8] {
        self.dst
    }
    fn capacity(&self) -> usize {
        self.dst.len()
    }
    fn as_mut_ptr(&mut self) -> *mut u8 {
        self.dst.as_mut_ptr()
    }
    unsafe fn filled_until(&mut self, n: usize) {
        self.pos = n;
    }
}
*/LONG_CONTENTtest_simple_cycletest_cctx_cycletest_dictionarytest_checksumBLOCKSIZE_MAX_MIN// TODO: Use alloc feature instead to implement stuff for Vec// TODO: What about Cursor?// pub use zstd_sys::ZSTD_ResetDirective as ResetDirective;ContentSizeError/// Indicates an error happened when parsing the frame content size./// The stream may be corrupted, or the given frame prefix was too small.parse_content_size/// Parse a content size value./// zstd uses 2 special content size values to indicate either unknown size or parsing error./// Returns the ZSTD version./// Returns `major * 10_000 + minor * 100 + patch`./// So 1.5.3 would be returned as `10_503`./// Returns a string representation of the ZSTD version./// For example "1.5.3"./// This is likely going to be a _very_ large negative number./// This will try to compress `src` entirely and write the result to `dst`, returning the number of/// bytes written. If `dst` is too small to hold the compressed content, an error will be returned./// For streaming operations that don't require to store the entire input/ouput in memory, see/// `compress_stream`./// This is a one-step decompression (not streaming)./// You will need to make sure `dst` is large enough to store all the decompressed content, or an/// error will be returned./// If decompression was a success, the number of bytes written will be returned./// Returns `None` if the size could not be found, or if the content is actually empty./// Maximum compressed size in worst case single-pass scenario/// Compression context/// It is recommended to allocate a single context per thread and re-use it/// for many compression operations./// Initializes the context with the given compression level./// This is equivalent to running:/// * `reset()`/// * `set_parameter(CompressionLevel, compression_level)`/// Tries to load a dictionary./// The dictionary content will be copied internally and does not need to be kept alive after/// If you need to use the same dictionary for multiple contexts, it may be more efficient to/// create a `CDict` first, then loads that./// The dictionary will apply to all compressed frames, until a new dictionary is set.disable_dictionary/// Return to "no-dictionary" mode./// This will disable any dictionary/prefix previously registered for future frames./// Use some prefix as single-use dictionary for the next compressed frame./// Just like a dictionary, decompression will need to be given the same prefix./// This is best used if the "prefix" looks like the data to be compressed./// Performs a step of a streaming compression operation./// This will read some data from `input` and/or write some data to `output`./// A hint for the "ideal" amount of input data to provide in the next call./// This hint is only for performance purposes./// The `end_op` directive can be used to specify what to do after: nothing special, flush/// internal buffers, or end the frame./// An lower bound for the amount of data that still needs to be flushed out./// This is useful when flushing or ending the frame: you need to keep calling this function/// until it returns 0./// Flush any intermediate buffer./// To fully flush, you should keep calling this function until it returns `Ok(0)`./// You should keep calling this function until it returns `Ok(0)`./// Returns the size currently used by this context./// This may change over time./// Resets the state of the context./// Depending on the reset mode, it can reset the session, the parameters, or both./// Sets a compression parameter./// Some of these parameters need to be set during de-compression as well./// Guarantee that the input size will be this value./// If given `None`, assumes the size is unknown./// Unless explicitly disabled, this will cause the size to be written in the compressed frame/// If the actual data given to compress has a different size, an error will be returned./// Returns the recommended input buffer size./// Using this size may result in minor performance boost./// Returns the recommended output buffer size./// Using this may result in minor performance boost.// Non thread-safe methods already take `&mut self`, so it's fine to implement Sync here./// Returns the error string associated with an error code./// Try to create a new decompression context./// Returns `None` if the operation failed (for example, not enough memory)./// Creates a new decoding context./// If the context creation fails./// Fully decompress the given frame./// This decompress an entire frame in-memory. If you can have enough memory to store both the/// input and output buffer, then it may be faster that streaming decompression./// Fully decompress the given frame using a dictionary./// Dictionary must be identical to the one used during compression./// If you plan on using the same dictionary multiple times, it is faster to create a `DDict`/// first and use `decompress_using_ddict`./// This is equivalent to calling:/// * `reset(SessionOnly)`/// * `disable_dictionary()`/// Loads a dictionary./// This will let this context decompress frames that were compressed using this dictionary./// create a `DDict` first, then loads that./// The dictionary will apply to all future frames, until a new dictionary is set./// References a dictionary./// This will let this context decompress frames compressed with the same dictionary./// It will apply to all frames decompressed by this context (until a new dictionary is set)./// Use some prefix as single-use dictionary for the next frame./// Just like a dictionary, this only works if compression was done with the same prefix./// But unlike a dictionary, this only applies to the next frame./// Sets a decompression parameter./// Performs a step of a streaming decompression operation./// * `Ok(0)` if the current frame just finished decompressing successfully./// * `Ok(hint)` with a hint for the "ideal" amount of input data to provide in the next call.///     Can be safely ignored./// Prepare a dictionary to compress data./// This will make it easier for compression contexts to load this dictionary./// The dictionary content will be copied internally, and does not need to be kept around./// If loading this dictionary failed./// Returns the _current_ memory usage of this dictionary./// Note that this may change over time./// Returns the dictionary ID for this dict./// Returns `None` if this dictionary is empty or invalid./// Safety: this should only be called if the `n` first bytes of this buffer have actually been/// Describe a bytes container, like `Vec<u8>`./// Represents a contiguous segment of allocated memory, a prefix of which is initialized./// It allows starting from an uninitializes chunk of memory and writing to it, progressively/// initializing it. No re-allocation typically occur after the initial creation./// * `Vec<u8>` and similar structures. These hold both a length (initialized data) and a capacity///   (allocated memory).///   Use `Vec::with_capacity` to create an empty `Vec` with non-zero capacity, and the length///   field will be updated to cover the data written to it (as long as it fits in the given///   capacity).///   be up to the caller to only use the part that was written (as returned by the various writing///   operations)./// * `std::io::Cursor<T: WriteBuf>`. This will ignore data before the cursor's position, and///   append data after that./// If `pos > dst.capacity()`./// Guaranteed to be <= self.capacity()/// Returns the capacity of the underlying buffer./// Returns a pointer to the start of this buffer./// Args:/// * `src`: A prefix of the compressed frame. It should at least include the frame header./// * `Err(ContentSizeError)` if `src` is too small of a prefix, or if it appears corrupted./// * `Ok(None)` if the frame does not include a content size./// * `Ok(Some(content_size_in_bytes))` otherwise./// Returns `None` if the dictionary is not a valid zstd dictionary./// Returns `None` if the dictionary ID could not be decoded. This may happen if:/// * The frame was not encoded with a dictionary./// * The frame intentionally did not include dicionary ID./// * The dictionary was non-conformant./// * `src` is too small and does not include the frame header./// * `src` is not a valid zstd frame prefix.SessionOnly/// Only the session will be reset./// All parameters will be preserved (including the dictionary)./// But any frame being processed will be dropped./// It can be useful to start re-using a context after an error or when an/// ongoing compression is no longer needed./// Only reset parameters (including dictionary or referenced prefix)./// All parameters will be reset to default values./// This can only be done between sessions - no compression or decompression must be ongoing.SessionAndParameters/// Reset both the session and parameters./// The result is similar to a newly created context./// What kind of context reset should be applied.as_sysTargetCBlockSize/// Target CBlock size./// Tries to make compressed blocks fit in this size (not a guarantee, just a target)./// Useful to reduce end-to-end latency in low-bandwidth environments./// No target when the value is 0./// Compression level to use./// Compression levels are global presets for the other compression parameters./// Maximum allowed back-reference distance./// The actual distance is 2 power "this value"./// How many threads will be spawned./// With a default value of `0`, `compress_stream*` functions block until they complete./// With any other value (including 1, a single compressing thread), these methods directly/// return, and the actual compression is done in the background (until a flush is requested)./// Size in bytes of a compression job./// Does not have any effect when `NbWorkers` is set to 0./// The default value of 0 finds the best job size based on the compression parameters./// Specifies how much overlap must be given to each worker./// Possible values:/// * `0` (default value): automatic overlap based on compression strategy./// * `1`: No overlap/// * `1 < n < 9`: Overlap a fraction of the window size, defined as `1/(2 ^ 9-n)`./// * `9`: Full overlap (as long as the window)/// * `9 < m`: Will return an error./// Wraps the `ZDICT_getDictID()` function.// Some functions work on a "frame prefix".// TODO: Define `struct FramePrefix(&[u8]);` and move these functions to it?// Some other functions work on a dictionary (not CDict or DDict).// Same thing?test_writebufset_legacyset_pthreadenable_threadingflag_if_supported_with_fallbacks/// This function would find the first flag in `flags` that is supported/// and add that to `config`.compile_zstdcargo_print/// Print a line for cargo./// If non-cargo is set, do not print anything." ZDICT_trainFromBuffer():\n  Train a dictionary from an array of samples.\n  Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4,\n  f=20, and accel=1.\n  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,\n  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.\n  The resulting dictionary will be saved into `dictBuffer`.\n @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)\n          or an error code, which can be tested with ZDICT_isError().\n  Note:  Dictionary training will fail if there are not enough samples to construct a\n         dictionary, or if most of the samples are too small (< 8 bytes being the lower limit).\n         If dictionary training fails, you should use zstd without a dictionary, as the dictionary\n         would've been ineffective anyways. If you believe your samples would benefit from a dictionary\n         please open an issue with details, and we can look into it.\n  Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB.\n  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.\n        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.\n        In general, it's recommended to provide a few thousands samples, though this can vary a lot.\n        It's recommended that total size of all samples be about ~x100 times the target size of dictionary."ZDICT_trainFromBuffer"< optimize for a specific zstd compression level; 0 means default"compressionLevel"< Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug;"notificationLevel"< force dictID value; 0 means auto mode (32-bits random value)\n   NOTE: The zstd format reserves some dictionary IDs for future use.\n         You may use them in private settings, but be warned that they\n         may be used by zstd in a public dictionary registry in the future.\n         These dictionary IDs are:\n           - low range  : <= 32767\n           - high range : >= (2^31)"dictIDZDICT_params_t" ZDICT_finalizeDictionary():\n Given a custom content as a basis for dictionary, and a set of samples,\n finalize dictionary by adding headers and statistics according to the zstd\n dictionary format.\n\n Samples must be stored concatenated in a flat buffer `samplesBuffer`,\n supplied with an array of sizes `samplesSizes`, providing the size of each\n sample in order. The samples are used to construct the statistics, so they\n should be representative of what you will compress with this dictionary.\n\n The compression level can be set in `parameters`. You should pass the\n compression level you expect to use in production. The statistics for each\n compression level differ, so tuning the dictionary for the compression level\n can help quite a bit.\n\n You can set an explicit dictionary ID in `parameters`, or allow us to pick\n a random dictionary ID for you, but we can't guarantee no collisions.\n\n The dstDictBuffer and the dictContent may overlap, and the content will be\n appended to the end of the header. If the header + the content doesn't fit in\n maxDictSize the beginning of the content is truncated to make room, since it\n is presumed that the most profitable content is at the end of the dictionary,\n since that is the cheapest to reference.\n\n `maxDictSize` must be >= max(dictContentSize, ZSTD_DICTSIZE_MIN).\n\n @return: size of dictionary stored into `dstDictBuffer` (<= `maxDictSize`),\n          or an error code, which can be tested by ZDICT_isError().\n Note: ZDICT_finalizeDictionary() will push notifications into stderr if\n       instructed to, using notificationLevel>0.\n NOTE: This function currently may fail in several edge cases including:\n         * Not enough samples\n         * Samples are uncompressible\n         * Samples are all exactly the same"ZDICT_finalizeDictionaryZDICT_getDictIDZDICT_getDictHeaderSizeZDICT_isErrorZDICT_getErrorName/*
This file is auto-generated from the public API of the zstd library.
It is released under the same BSD license.

BSD License

For Zstandard software

Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

 * Neither the name Facebook, nor Meta, nor the names of its contributors may
   be used to endorse or promote products derived from this software without
   specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ZDICT_DICTSIZE_MINZDICT_CONTENTSIZE_MIN" ZDICT_cover_params_t:\n  k and d are the only required parameters.\n  For others, value 0 means default."stepsnbThreadssplitPointshrinkDictshrinkDictMaxRegressionzParamsZDICT_cover_params_tZDICT_fastCover_params_t" ZDICT_trainFromBuffer_cover():\n  Train a dictionary from an array of samples using the COVER algorithm.\n  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,\n  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.\n  The resulting dictionary will be saved into `dictBuffer`.\n @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)\n          or an error code, which can be tested with ZDICT_isError().\n          See ZDICT_trainFromBuffer() for details on failure modes.\n  Note: ZDICT_trainFromBuffer_cover() requires about 9 bytes of memory for each input byte.\n  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.\n        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.\n        In general, it's recommended to provide a few thousands samples, though this can vary a lot.\n        It's recommended that total size of all samples be about ~x100 times the target size of dictionary."ZDICT_trainFromBuffer_cover" ZDICT_optimizeTrainFromBuffer_cover():\n The same requirements as above hold for all the parameters except `parameters`.\n This function tries many parameter combinations and picks the best parameters.\n `*parameters` is filled with the best parameters found,\n dictionary constructed with those parameters is stored in `dictBuffer`.\n\n All of the parameters d, k, steps are optional.\n If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}.\n if steps is zero it defaults to its default value.\n If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000].\n\n @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)\n          or an error code, which can be tested with ZDICT_isError().\n          On success `*parameters` contains the parameters selected.\n          See ZDICT_trainFromBuffer() for details on failure modes.\n Note: ZDICT_optimizeTrainFromBuffer_cover() requires about 8 bytes of memory for each input byte and additionally another 5 bytes of memory for each byte of memory for each thread."ZDICT_optimizeTrainFromBuffer_cover" ZDICT_trainFromBuffer_fastCover():\n  Train a dictionary from an array of samples using a modified version of COVER algorithm.\n  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,\n  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.\n  d and k are required.\n  All other parameters are optional, will use default values if not provided\n  The resulting dictionary will be saved into `dictBuffer`.\n @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)\n          or an error code, which can be tested with ZDICT_isError().\n          See ZDICT_trainFromBuffer() for details on failure modes.\n  Note: ZDICT_trainFromBuffer_fastCover() requires 6 * 2^f bytes of memory.\n  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.\n        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.\n        In general, it's recommended to provide a few thousands samples, though this can vary a lot.\n        It's recommended that total size of all samples be about ~x100 times the target size of dictionary."ZDICT_trainFromBuffer_fastCover" ZDICT_optimizeTrainFromBuffer_fastCover():\n The same requirements as above hold for all the parameters except `parameters`.\n This function tries many parameter combinations (specifically, k and d combinations)\n and picks the best parameters. `*parameters` is filled with the best parameters found,\n dictionary constructed with those parameters is stored in `dictBuffer`.\n All of the parameters d, k, steps, f, and accel are optional.\n If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}.\n if steps is zero it defaults to its default value.\n If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000].\n If f is zero, default value of 20 is used.\n If accel is zero, default value of 1 is used.\n\n @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)\n          or an error code, which can be tested with ZDICT_isError().\n          On success `*parameters` contains the parameters selected.\n          See ZDICT_trainFromBuffer() for details on failure modes.\n Note: ZDICT_optimizeTrainFromBuffer_fastCover() requires about 6 * 2^f bytes of memory for each thread."ZDICT_optimizeTrainFromBuffer_fastCoverselectivityLevelZDICT_legacy_params_t" ZDICT_trainFromBuffer_legacy():\n  Train a dictionary from an array of samples.\n  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,\n  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.\n  The resulting dictionary will be saved into `dictBuffer`.\n `parameters` is optional and can be provided with values set to 0 to mean \"default\".\n @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)\n          or an error code, which can be tested with ZDICT_isError().\n          See ZDICT_trainFromBuffer() for details on failure modes.\n  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.\n        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.\n        In general, it's recommended to provide a few thousands samples, though this can vary a lot.\n        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.\n  Note: ZDICT_trainFromBuffer_legacy() will send notifications into stderr if instructed to, using notificationLevel>0."ZDICT_trainFromBuffer_legacyZDICT_addEntropyTablesFromBufferZSTD_VERSION_MAJORZSTD_VERSION_MINORZSTD_VERSION_RELEASEZSTD_VERSION_NUMBERZSTD_CLEVEL_DEFAULTZSTD_MAGICNUMBERZSTD_MAGIC_DICTIONARYZSTD_MAGIC_SKIPPABLE_STARTZSTD_MAGIC_SKIPPABLE_MASKZSTD_BLOCKSIZELOG_MAXZSTD_BLOCKSIZE_MAXZSTD_CONTENTSIZE_UNKNOWNZSTD_CONTENTSIZE_ERROR" ZSTD_versionNumber() :\n  Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE)."ZSTD_versionNumber" ZSTD_versionString() :\n  Return runtime library version, like \"1.4.5\". Requires v1.3.0+."ZSTD_versionString"  Simple API\n/\n/*! ZSTD_compress() :\n  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.\n  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have\n        enough space to successfully compress the data.\n  @return : compressed size written into `dst` (<= `dstCapacity),\n            or an error code if it fails (which can be tested using ZSTD_isError())."ZSTD_compress" ZSTD_decompress() :\n  `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.\n  `dstCapacity` is an upper bound of originalSize to regenerate.\n  If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.\n  @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),\n            or an errorCode if it fails (which can be tested using ZSTD_isError())."ZSTD_decompressZSTD_getFrameContentSize" ZSTD_getDecompressedSize() :\n  NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize().\n  Both functions work the same way, but ZSTD_getDecompressedSize() blends\n  \"empty\", \"unknown\" and \"error\" results to the same return value (0),\n  while ZSTD_getFrameContentSize() gives them separate return values.\n @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise."ZSTD_getDecompressedSize" ZSTD_findFrameCompressedSize() : Requires v1.4.0+\n `src` should point to the start of a ZSTD frame or skippable frame.\n `srcSize` must be >= first frame size\n @return : the compressed size of the first frame starting at `src`,\n           suitable to pass as `srcSize` to `ZSTD_decompress` or similar,\n        or an error code if input is invalid"ZSTD_findFrameCompressedSizeZSTD_compressBoundZSTD_isErrorZSTD_getErrorNameZSTD_minCLevelZSTD_maxCLevelZSTD_defaultCLevelZSTD_CCtx_s"  Explicit context"ZSTD_createCCtxZSTD_freeCCtx" ZSTD_compressCCtx() :\n  Same as ZSTD_compress(), using an explicit ZSTD_CCtx.\n  Important : in order to mirror `ZSTD_compress()` behavior,\n  this function compresses at the requested compression level,\n  __ignoring any other advanced parameter__ .\n  If any advanced parameter was set using the advanced API,\n  they will all be reset. Only `compressionLevel` remains."ZSTD_compressCCtxZSTD_DCtx_sZSTD_createDCtxZSTD_freeDCtx" ZSTD_decompressDCtx() :\n  Same as ZSTD_decompress(),\n  requires an allocated ZSTD_DCtx.\n  Compatible with sticky parameters (see below)."ZSTD_decompressDCtx"  Advanced compression API (Requires v1.4.0+)"ZSTD_fastZSTD_dfastZSTD_greedyZSTD_lazyZSTD_lazy2ZSTD_btlazy2ZSTD_btoptZSTD_btultraZSTD_btultra2ZSTD_cParameterZSTD_c_compressionLevelZSTD_c_windowLogZSTD_c_hashLogZSTD_c_chainLogZSTD_c_searchLogZSTD_c_minMatchZSTD_c_targetLengthZSTD_c_strategyZSTD_c_targetCBlockSizeZSTD_c_enableLongDistanceMatchingZSTD_c_ldmHashLogZSTD_c_ldmMinMatchZSTD_c_ldmBucketSizeLogZSTD_c_ldmHashRateLogZSTD_c_contentSizeFlagZSTD_c_checksumFlagZSTD_c_dictIDFlagZSTD_c_nbWorkersZSTD_c_jobSizeZSTD_c_overlapLogZSTD_c_experimentalParam1ZSTD_c_experimentalParam2ZSTD_c_experimentalParam31001ZSTD_c_experimentalParam41002ZSTD_c_experimentalParam51004ZSTD_c_experimentalParam71005ZSTD_c_experimentalParam81006ZSTD_c_experimentalParam91007ZSTD_c_experimentalParam101008ZSTD_c_experimentalParam111009ZSTD_c_experimentalParam121010ZSTD_c_experimentalParam131011ZSTD_c_experimentalParam141012ZSTD_c_experimentalParam151013ZSTD_c_experimentalParam161014ZSTD_c_experimentalParam171015ZSTD_c_experimentalParam181016ZSTD_c_experimentalParam19lowerBoundupperBoundZSTD_bounds" ZSTD_cParam_getBounds() :\n  All parameters must belong to an interval with lower and upper bounds,\n  otherwise they will either trigger an error or be automatically clamped.\n @return : a structure, ZSTD_bounds, which contains\n         - an error status field, which must be tested using ZSTD_isError()\n         - lower and upper bounds, both inclusive"ZSTD_cParam_getBounds" ZSTD_CCtx_setParameter() :\n  Set one compression parameter, selected by enum ZSTD_cParameter.\n  All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().\n  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).\n  Setting a parameter is generally only possible during frame initialization (before starting compression).\n  Exception : when using multi-threading mode (nbWorkers >= 1),\n              the following parameters can be updated _during_ compression (within same frame):\n              => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy.\n              new parameters will be active for next job only (after a flush()).\n @return : an error code (which can be tested using ZSTD_isError())."ZSTD_CCtx_setParameter" ZSTD_CCtx_setPledgedSrcSize() :\n  Total input data size to be compressed as a single frame.\n  Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag.\n  This value will also be controlled at end of frame, and trigger an error if not respected.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame.\n           In order to mean \"unknown content size\", pass constant ZSTD_CONTENTSIZE_UNKNOWN.\n           ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame.\n  Note 2 : pledgedSrcSize is only valid once, for the next frame.\n           It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.\n  Note 3 : Whenever all input data is provided and consumed in a single round,\n           for example with ZSTD_compress2(),\n           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),\n           this value is automatically overridden by srcSize instead."ZSTD_CCtx_setPledgedSrcSizeZSTD_reset_session_onlyZSTD_reset_parametersZSTD_reset_session_and_parameters" ZSTD_CCtx_reset() :\n  There are 2 different things that can be reset, independently or jointly :\n  - The session : will stop compressing current frame, and make CCtx ready to start a new one.\n                  Useful after an error, or to interrupt any ongoing compression.\n                  Any internal data not yet flushed is cancelled.\n                  Compression parameters and dictionary remain unchanged.\n                  They will be used to compress next frame.\n                  Resetting session never fails.\n  - The parameters : changes all parameters back to \"default\".\n                  This also removes any reference to any dictionary or external sequence producer.\n                  Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)\n                  otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())\n  - Both : similar to resetting the session, followed by resetting parameters."ZSTD_CCtx_reset" ZSTD_compress2() :\n  Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.\n  (note that this entry point doesn't even expose a compression level parameter).\n  ZSTD_compress2() always starts a new frame.\n  Should cctx hold data from a previously unfinished frame, everything about it is forgotten.\n  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()\n  - The function is always blocking, returns when compression is completed.\n  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have\n        enough space to successfully compress the data, though it is possible it fails for other reasons.\n @return : compressed size written into `dst` (<= `dstCapacity),\n           or an error code if it fails (which can be tested using ZSTD_isError())."ZSTD_compress2"  Advanced decompression API (Requires v1.4.0+)"ZSTD_dParameterZSTD_d_windowLogMaxZSTD_d_experimentalParam1ZSTD_d_experimentalParam2ZSTD_d_experimentalParam31003ZSTD_d_experimentalParam4ZSTD_d_experimentalParam5ZSTD_d_experimentalParam6" ZSTD_dParam_getBounds() :\n  All parameters must belong to an interval with lower and upper bounds,\n  otherwise they will either trigger an error or be automatically clamped.\n @return : a structure, ZSTD_bounds, which contains\n         - an error status field, which must be tested using ZSTD_isError()\n         - both lower and upper bounds, inclusive"ZSTD_dParam_getBounds" ZSTD_DCtx_setParameter() :\n  Set one compression parameter, selected by enum ZSTD_dParameter.\n  All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds().\n  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).\n  Setting a parameter is only possible during frame initialization (before starting decompression).\n @return : 0, or an error code (which can be tested using ZSTD_isError())."ZSTD_DCtx_setParameter" ZSTD_DCtx_reset() :\n  Return a DCtx to clean state.\n  Session and parameters can be reset jointly or separately.\n  Parameters can only be reset when no active frame is being decompressed.\n @return : 0, or an error code, which can be tested with ZSTD_isError()"ZSTD_DCtx_reset"  Streaming""< start of input buffer""< size of input buffer""< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size"ZSTD_inBuffer_s"< start of output buffer""< size of output buffer""< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size"ZSTD_outBuffer_sZSTD_CStreamZSTD_createCStreamZSTD_freeCStreamZSTD_e_continueZSTD_e_flushZSTD_e_end" ZSTD_compressStream2() : Requires v1.4.0+\n  Behaves about the same as ZSTD_compressStream, with additional control on end directive.\n  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()\n  - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)\n  - output->pos must be <= dstCapacity, input->pos must be <= srcSize\n  - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.\n  - endOp must be a valid directive\n  - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.\n  - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available,\n                                                  and then immediately returns, just indicating that there is some data remaining to be flushed.\n                                                  The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.\n  - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.\n  - @return provides a minimum amount of data remaining to be flushed from internal buffers\n            or an error code, which can be tested using ZSTD_isError().\n            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.\n            This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.\n            For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.\n  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),\n            only ZSTD_e_end or ZSTD_e_flush operations are allowed.\n            Before starting a new compression job, or changing compression parameters,\n            it is required to fully flush internal buffers.\n  - note: if an operation ends with an error, it may leave @cctx in an undefined state.\n          Therefore, it's UB to invoke ZSTD_compressStream2() of ZSTD_compressStream() on such a state.\n          In order to be re-employed after an error, a state must be reset,\n          which can be done explicitly (ZSTD_CCtx_reset()),\n          or is sometimes implied by methods starting a new compression job (ZSTD_initCStream(), ZSTD_compressCCtx())"ZSTD_compressStream2ZSTD_CStreamInSizeZSTD_CStreamOutSize" Equivalent to:\n\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)\n     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);\n\n Note that ZSTD_initCStream() clears any previously set dictionary. Use the new API\n to compress with a dictionary."ZSTD_initCStream" Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).\n NOTE: The return value is different. ZSTD_compressStream() returns a hint for\n the next read size (if non-zero and not an error). ZSTD_compressStream2()\n returns the minimum nb of bytes left to flush (if non-zero and not an error)."ZSTD_compressStream" Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush)."ZSTD_flushStream" Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end)."ZSTD_endStreamZSTD_DStreamZSTD_createDStreamZSTD_freeDStream" ZSTD_initDStream() :\n Initialize/reset DStream state for new decompression operation.\n Call before new decompression operation using same DStream.\n\n Note : This function is redundant with the advanced API and equivalent to:\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n     ZSTD_DCtx_refDDict(zds, NULL);"ZSTD_initDStream" ZSTD_decompressStream() :\n Streaming decompression function.\n Call repetitively to consume full input updating it as necessary.\n Function will update both input and output `pos` fields exposing current state via these fields:\n - `input.pos < input.size`, some input remaining and caller should provide remaining input\n   on the next call.\n - `output.pos < output.size`, decoder finished and flushed all remaining buffers.\n - `output.pos == output.size`, potentially uncflushed data present in the internal buffers,\n   call ZSTD_decompressStream() again to flush remaining data to output.\n Note : with no additional input, amount of data flushed <= ZSTD_BLOCKSIZE_MAX.\n\n @return : 0 when a frame is completely decoded and fully flushed,\n           or an error code, which can be tested using ZSTD_isError(),\n           or any other value > 0, which means there is some decoding or flushing to do to complete current frame.\n\n Note: when an operation returns with an error code, the @zds state may be left in undefined state.\n       It's UB to invoke `ZSTD_decompressStream()` on such a state.\n       In order to re-use such a state, it must be first reset,\n       which can be done explicitly (`ZSTD_DCtx_reset()`),\n       or is implied for operations starting some new decompression job (`ZSTD_initDStream`, `ZSTD_decompressDCtx()`, `ZSTD_decompress_usingDict()`)"ZSTD_decompressStreamZSTD_DStreamInSizeZSTD_DStreamOutSize"  Simple dictionary API\n/\n/*! ZSTD_compress_usingDict() :\n  Compression at an explicit compression level using a Dictionary.\n  A dictionary can be any arbitrary data segment (also called a prefix),\n  or a buffer with specified information (see zdict.h).\n  Note : This function loads the dictionary, resulting in significant startup delay.\n         It's intended for a dictionary used only once.\n  Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used."ZSTD_compress_usingDict" ZSTD_decompress_usingDict() :\n  Decompression using a known Dictionary.\n  Dictionary must be identical to the one used during compression.\n  Note : This function loads the dictionary, resulting in significant startup delay.\n         It's intended for a dictionary used only once.\n  Note : When `dict == NULL || dictSize < 8` no dictionary is used."ZSTD_decompress_usingDictZSTD_CDict_s"  Bulk processing dictionary API"" ZSTD_createCDict() :\n  When compressing multiple messages or blocks using the same dictionary,\n  it's recommended to digest the dictionary only once, since it's a costly operation.\n  ZSTD_createCDict() will create a state from digesting a dictionary.\n  The resulting state can be used for future compression operations with very limited startup cost.\n  ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.\n @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict.\n  Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content.\n  Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer,\n      in which case the only thing that it transports is the @compressionLevel.\n      This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively,\n      expecting a ZSTD_CDict parameter with any data, including those without a known dictionary."ZSTD_createCDict" ZSTD_freeCDict() :\n  Function frees memory allocated by ZSTD_createCDict().\n  If a NULL pointer is passed, no operation is performed."ZSTD_freeCDict" ZSTD_compress_usingCDict() :\n  Compression using a digested Dictionary.\n  Recommended when same dictionary is used multiple times.\n  Note : compression level is _decided at dictionary creation time_,\n     and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no)"ZSTD_compress_usingCDictZSTD_DDict_s" ZSTD_createDDict() :\n  Create a digested dictionary, ready to start decompression operation without startup delay.\n  dictBuffer can be released after DDict creation, as its content is copied inside DDict."ZSTD_createDDict" ZSTD_freeDDict() :\n  Function frees memory allocated with ZSTD_createDDict()\n  If a NULL pointer is passed, no operation is performed."ZSTD_freeDDict" ZSTD_decompress_usingDDict() :\n  Decompression using a digested Dictionary.\n  Recommended when same dictionary is used multiple times."ZSTD_decompress_usingDDict" ZSTD_getDictID_fromDict() : Requires v1.4.0+\n  Provides the dictID stored within dictionary.\n  if @return == 0, the dictionary is not conformant with Zstandard specification.\n  It can still be loaded, but as a content-only dictionary."ZSTD_getDictID_fromDict" ZSTD_getDictID_fromCDict() : Requires v1.5.0+\n  Provides the dictID of the dictionary loaded into `cdict`.\n  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.\n  Non-conformant dictionaries can still be loaded, but as content-only dictionaries."ZSTD_getDictID_fromCDict" ZSTD_getDictID_fromDDict() : Requires v1.4.0+\n  Provides the dictID of the dictionary loaded into `ddict`.\n  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.\n  Non-conformant dictionaries can still be loaded, but as content-only dictionaries."ZSTD_getDictID_fromDDict" ZSTD_getDictID_fromFrame() : Requires v1.4.0+\n  Provides the dictID required to decompressed the frame stored within `src`.\n  If @return == 0, the dictID could not be decoded.\n  This could for one of the following reasons :\n  - The frame does not require a dictionary to be decoded (most common case).\n  - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden piece of information.\n    Note : this use case also happens when using a non-conformant dictionary.\n  - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).\n  - This is not a Zstandard frame.\n  When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code."ZSTD_getDictID_fromFrame" ZSTD_CCtx_loadDictionary() : Requires v1.4.0+\n  Create an internal CDict from `dict` buffer.\n  Decompression will have to use same dictionary.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,\n           meaning \"return to no-dictionary mode\".\n  Note 1 : Dictionary is sticky, it will be used for all future compressed frames,\n           until parameters are reset, a new dictionary is loaded, or the dictionary\n           is explicitly invalidated by loading a NULL dictionary.\n  Note 2 : Loading a dictionary involves building tables.\n           It's also a CPU consuming operation, with non-negligible impact on latency.\n           Tables are dependent on compression parameters, and for this reason,\n           compression parameters can no longer be changed after loading a dictionary.\n  Note 3 :`dict` content will be copied internally.\n           Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.\n           In such a case, dictionary buffer must outlive its users.\n  Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()\n           to precisely select how dictionary content must be interpreted.\n  Note 5 : This method does not benefit from LDM (long distance mode).\n           If you want to employ LDM on some large dictionary content,\n           prefer employing ZSTD_CCtx_refPrefix() described below."ZSTD_CCtx_loadDictionary" ZSTD_CCtx_refCDict() : Requires v1.4.0+\n  Reference a prepared dictionary, to be used for all future compressed frames.\n  Note that compression parameters are enforced from within CDict,\n  and supersede any compression parameter previously set within CCtx.\n  The parameters ignored are labelled as \"superseded-by-cdict\" in the ZSTD_cParameter enum docs.\n  The ignored parameters will be used again if the CCtx is returned to no-dictionary mode.\n  The dictionary will remain valid for future compressed frames using same CCtx.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special : Referencing a NULL CDict means \"return to no-dictionary mode\".\n  Note 1 : Currently, only one dictionary can be managed.\n           Referencing a new dictionary effectively \"discards\" any previous one.\n  Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx."ZSTD_CCtx_refCDict" ZSTD_CCtx_refPrefix() : Requires v1.4.0+\n  Reference a prefix (single-usage dictionary) for next compressed frame.\n  A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end).\n  Decompression will need same prefix to properly regenerate data.\n  Compressing with a prefix is similar in outcome as performing a diff and compressing it,\n  but performs much faster, especially during decompression (compression speed is tunable with compression level).\n  This method is compatible with LDM (long distance mode).\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary\n  Note 1 : Prefix buffer is referenced. It **must** outlive compression.\n           Its content must remain unmodified during compression.\n  Note 2 : If the intention is to diff some large src data blob with some prior version of itself,\n           ensure that the window size is large enough to contain the entire source.\n           See ZSTD_c_windowLog.\n  Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.\n           It's a CPU consuming operation, with non-negligible impact on latency.\n           If there is a need to use the same prefix multiple times, consider loadDictionary instead.\n  Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent).\n           Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation."ZSTD_CCtx_refPrefix" ZSTD_DCtx_loadDictionary() : Requires v1.4.0+\n  Create an internal DDict from dict buffer, to be used to decompress all future frames.\n  The dictionary remains valid for all future frames, until explicitly invalidated, or\n  a new dictionary is loaded.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,\n            meaning \"return to no-dictionary mode\".\n  Note 1 : Loading a dictionary involves building tables,\n           which has a non-negligible impact on CPU usage and latency.\n           It's recommended to \"load once, use many times\", to amortize the cost\n  Note 2 :`dict` content will be copied internally, so `dict` can be released after loading.\n           Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead.\n  Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of\n           how dictionary content is loaded and interpreted."ZSTD_DCtx_loadDictionary" ZSTD_DCtx_refDDict() : Requires v1.4.0+\n  Reference a prepared dictionary, to be used to decompress next frames.\n  The dictionary remains active for decompression of future frames using same DCtx.\n\n  If called with ZSTD_d_refMultipleDDicts enabled, repeated calls of this function\n  will store the DDict references in a table, and the DDict used for decompression\n  will be determined at decompression time, as per the dict ID in the frame.\n  The memory for the table is allocated on the first call to refDDict, and can be\n  freed with ZSTD_freeDCtx().\n\n  If called with ZSTD_d_refMultipleDDicts disabled (the default), only one dictionary\n  will be managed, and referencing a dictionary effectively \"discards\" any previous one.\n\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special: referencing a NULL DDict means \"return to no-dictionary mode\".\n  Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx."ZSTD_DCtx_refDDict" ZSTD_DCtx_refPrefix() : Requires v1.4.0+\n  Reference a prefix (single-usage dictionary) to decompress next frame.\n  This is the reverse operation of ZSTD_CCtx_refPrefix(),\n  and must use the same prefix as the one used during compression.\n  Prefix is **only used once**. Reference is discarded at end of frame.\n  End of frame is reached when ZSTD_decompressStream() returns 0.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary\n  Note 2 : Prefix buffer is referenced. It **must** outlive decompression.\n           Prefix buffer must remain unmodified up to the end of frame,\n           reached when ZSTD_decompressStream() returns 0.\n  Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent).\n           Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)\n  Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.\n           A full dictionary is more costly, as it requires building tables."ZSTD_DCtx_refPrefix" ZSTD_sizeof_*() : Requires v1.4.0+\n  These functions give the _current_ memory usage of selected object.\n  Note that object memory usage can evolve (increase or decrease) over time."ZSTD_sizeof_CCtxZSTD_sizeof_DCtxZSTD_sizeof_CStreamZSTD_sizeof_DStreamZSTD_sizeof_CDictZSTD_sizeof_DDictZSTD_FRAMEHEADERSIZE_MAXZSTD_SKIPPABLEHEADERSIZEZSTD_WINDOWLOG_MAX_32ZSTD_WINDOWLOG_MAX_64ZSTD_WINDOWLOG_MINZSTD_HASHLOG_MINZSTD_CHAINLOG_MAX_32ZSTD_CHAINLOG_MAX_64ZSTD_CHAINLOG_MINZSTD_SEARCHLOG_MINZSTD_MINMATCH_MAXZSTD_MINMATCH_MINZSTD_TARGETLENGTH_MAXZSTD_TARGETLENGTH_MINZSTD_BLOCKSIZE_MAX_MINZSTD_OVERLAPLOG_MINZSTD_OVERLAPLOG_MAXZSTD_WINDOWLOG_LIMIT_DEFAULTZSTD_LDM_HASHLOG_MINZSTD_LDM_MINMATCH_MINZSTD_LDM_MINMATCH_MAXZSTD_LDM_BUCKETSIZELOG_MINZSTD_LDM_BUCKETSIZELOG_MAXZSTD_LDM_HASHRATELOG_MINZSTD_TARGETCBLOCKSIZE_MINZSTD_TARGETCBLOCKSIZE_MAXZSTD_SRCSIZEHINT_MINZSTD_CCtx_params_sZSTD_CCtx_paramslitLengthmatchLengthrepZSTD_Sequence"< largest match distance : larger == more compression, more memory needed during decompression"windowLog"< fully searched segment : larger == more compression, slower, more memory (useless for fast)"chainLog"< dispatch table : larger == faster, more memory"hashLog"< nb of searches : larger == more compression, slower"searchLog"< match length searched : larger == faster decompression, sometimes less compression"minMatch"< acceptable match size for optimal parser (only) : larger == more compression, slower"targetLength"< see ZSTD_strategy definition above"ZSTD_compressionParameters"< 1: content size will be in frame header (when known)"contentSizeFlag"< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection"checksumFlag"< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression)"noDictIDFlagZSTD_frameParameterscParamsfParamsZSTD_parametersZSTD_dictContentType_eZSTD_dct_autoZSTD_dct_rawContentZSTD_dct_fullDictZSTD_dictLoadMethod_e"< Copy dictionary content internally"ZSTD_dlm_byCopy"< Reference dictionary content -- the dictionary buffer must outlive its users."ZSTD_dlm_byRefZSTD_format_eZSTD_f_zstd1ZSTD_f_zstd1_magiclessZSTD_forceIgnoreChecksum_eZSTD_d_validateChecksumZSTD_d_ignoreChecksumZSTD_refMultipleDDicts_eZSTD_rmd_refSingleDDictZSTD_rmd_refMultipleDDictsZSTD_dictAttachPref_eZSTD_dictDefaultAttachZSTD_dictForceAttachZSTD_dictForceCopyZSTD_dictForceLoadZSTD_literalCompressionMode_e"< Automatically determine the compression mode based on the compression level.\n   Negative compression levels will be uncompressed, and positive compression\n   levels will be compressed."ZSTD_lcm_auto"< Always attempt Huffman compression. Uncompressed literals will still be\n   emitted if Huffman compression is not profitable."ZSTD_lcm_huffman"< Always emit uncompressed literals."ZSTD_lcm_uncompressedZSTD_paramSwitch_eZSTD_ps_autoZSTD_ps_enableZSTD_ps_disable" ZSTD_findDecompressedSize() :\n  `src` should point to the start of a series of ZSTD encoded and/or skippable frames\n  `srcSize` must be the _exact_ size of this series\n       (i.e. there should be a frame boundary at `src + srcSize`)\n  @return : - decompressed size of all data in all successive frames\n            - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN\n            - if an error occurred: ZSTD_CONTENTSIZE_ERROR\n\n   note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.\n            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.\n            In which case, it's necessary to use streaming mode to decompress data.\n   note 2 : decompressed size is always present when compression is done with ZSTD_compress()\n   note 3 : decompressed size can be very large (64-bits value),\n            potentially larger than what local system can handle as a single memory segment.\n            In which case, it's necessary to use streaming mode to decompress data.\n   note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.\n            Always ensure result fits within application's authorized limits.\n            Each application can set its own limits.\n   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to\n            read each contained frame header.  This is fast as most of the data is skipped,\n            however it does mean that all frame data must be present and valid."ZSTD_findDecompressedSize" ZSTD_decompressBound() :\n  `src` should point to the start of a series of ZSTD encoded and/or skippable frames\n  `srcSize` must be the _exact_ size of this series\n       (i.e. there should be a frame boundary at `src + srcSize`)\n  @return : - upper-bound for the decompressed size of all data in all successive frames\n            - if an error occurred: ZSTD_CONTENTSIZE_ERROR\n\n  note 1  : an error can occur if `src` contains an invalid or incorrectly formatted frame.\n  note 2  : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`.\n            in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value.\n  note 3  : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:\n              upper-bound = # blocks * min(128 KB, Window_Size)"ZSTD_decompressBound" ZSTD_frameHeaderSize() :\n  srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX.\n @return : size of the Frame Header,\n           or an error code (if srcSize is too small)"ZSTD_frameHeaderSizeZSTD_frameType_eZSTD_frameZSTD_skippableFrameframeContentSizewindowSizeblockSizeMaxframeTypeheaderSizeZSTD_frameHeader" ZSTD_getFrameHeader() :\n  decode Frame Header, or requires larger `srcSize`.\n @return : 0, `zfhPtr` is correctly filled,\n          >0, `srcSize` is too small, value is wanted `srcSize` amount,\n           or an error code, which can be tested using ZSTD_isError()"ZSTD_getFrameHeader" ZSTD_getFrameHeader_advanced() :\n  same as ZSTD_getFrameHeader(),\n  with added capability to select a format (like ZSTD_f_zstd1_magicless)"ZSTD_getFrameHeader_advanced" ZSTD_decompressionMargin() :\n Zstd supports in-place decompression, where the input and output buffers overlap.\n In this case, the output buffer must be at least (Margin + Output_Size) bytes large,\n and the input buffer must be at the end of the output buffer.\n\n  _______________________ Output Buffer ________________________\n |                                                              |\n |                                        ____ Input Buffer ____|\n |                                       |                      |\n v                                       v                      v\n |---------------------------------------|-----------|----------|\n ^                                                   ^          ^\n |___________________ Output_Size ___________________|_ Margin _|\n\n NOTE: See also ZSTD_DECOMPRESSION_MARGIN().\n NOTE: This applies only to single-pass decompression through ZSTD_decompress() or\n ZSTD_decompressDCtx().\n NOTE: This function supports multi-frame input.\n\n @param src The compressed frame(s)\n @param srcSize The size of the compressed frame(s)\n @returns The decompression margin or an error that can be checked with ZSTD_isError()."ZSTD_decompressionMarginZSTD_sequenceFormat_eZSTD_sf_noBlockDelimitersZSTD_sf_explicitBlockDelimiters" ZSTD_sequenceBound() :\n `srcSize` : size of the input buffer\n  @return : upper-bound for the number of sequences that can be generated\n            from a buffer of srcSize bytes\n\n  note : returns number of sequences - to get bytes, multiply by sizeof(ZSTD_Sequence)."ZSTD_sequenceBound" ZSTD_generateSequences() :\n WARNING: This function is meant for debugging and informational purposes ONLY!\n Its implementation is flawed, and it will be deleted in a future version.\n It is not guaranteed to succeed, as there are several cases where it will give\n up and fail. You should NOT use this function in production code.\n\n This function is deprecated, and will be removed in a future version.\n\n Generate sequences using ZSTD_compress2(), given a source buffer.\n\n @param zc The compression context to be used for ZSTD_compress2(). Set any\n           compression parameters you need on this context.\n @param outSeqs The output sequences buffer of size @p outSeqsSize\n @param outSeqsSize The size of the output sequences buffer.\n                    ZSTD_sequenceBound(srcSize) is an upper bound on the number\n                    of sequences that can be generated.\n @param src The source buffer to generate sequences from of size @p srcSize.\n @param srcSize The size of the source buffer.\n\n Each block will end with a dummy sequence\n with offset == 0, matchLength == 0, and litLength == length of last literals.\n litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0)\n simply acts as a block delimiter.\n\n @returns The number of sequences generated, necessarily less than\n          ZSTD_sequenceBound(srcSize), or an error code that can be checked\n          with ZSTD_isError()."ZSTD_generateSequences" ZSTD_mergeBlockDelimiters() :\n Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals\n by merging them into the literals of the next sequence.\n\n As such, the final generated result has no explicit representation of block boundaries,\n and the final last literals segment is not represented in the sequences.\n\n The output of this function can be fed into ZSTD_compressSequences() with CCtx\n setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters\n @return : number of sequences left after merging"ZSTD_mergeBlockDelimiters" ZSTD_compressSequences() :\n Compress an array of ZSTD_Sequence, associated with @src buffer, into dst.\n @src contains the entire input (not just the literals).\n If @srcSize > sum(sequence.length), the remaining bytes are considered all literals\n If a dictionary is included, then the cctx should reference the dict. (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.)\n The entire source is compressed into a single frame.\n\n The compression behavior changes based on cctx params. In particular:\n    If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain\n    no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on\n    the block size derived from the cctx, and sequences may be split. This is the default setting.\n\n    If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain\n    block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided.\n\n    If ZSTD_c_validateSequences == 0, this function will blindly accept the sequences provided. Invalid sequences cause undefined\n    behavior. If ZSTD_c_validateSequences == 1, then if sequence is invalid (see doc/zstd_compression_format.md for\n    specifics regarding offset/matchlength requirements) then the function will bail out and return an error.\n\n    In addition to the two adjustable experimental params, there are other important cctx params.\n    - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN.\n    - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression.\n    - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset\n      is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md\n\n Note: Repcodes are, as of now, always re-calculated within this function, so ZSTD_Sequence::rep is unused.\n Note 2: Once we integrate ability to ingest repcodes, the explicit block delims mode must respect those repcodes exactly,\n         and cannot emit an RLE block that disagrees with the repcode history\n @return : final compressed size, or a ZSTD error code."ZSTD_compressSequences" ZSTD_writeSkippableFrame() :\n Generates a zstd skippable frame containing data given by src, and writes it to dst buffer.\n\n Skippable frames begin with a 4-byte magic number. There are 16 possible choices of magic number,\n ranging from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15.\n As such, the parameter magicVariant controls the exact skippable frame magic number variant used, so\n the magic number used will be ZSTD_MAGIC_SKIPPABLE_START + magicVariant.\n\n Returns an error if destination buffer is not large enough, if the source size is not representable\n with a 4-byte unsigned int, or if the parameter magicVariant is greater than 15 (and therefore invalid).\n\n @return : number of bytes written or a ZSTD error."ZSTD_writeSkippableFrame" ZSTD_readSkippableFrame() :\n Retrieves a zstd skippable frame containing data given by src, and writes it to dst buffer.\n\n The parameter magicVariant will receive the magicVariant that was supplied when the frame was written,\n i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START.  This can be NULL if the caller is not interested\n in the magicVariant.\n\n Returns an error if destination buffer is not large enough, or if the frame is not skippable.\n\n @return : number of bytes written or a ZSTD error."ZSTD_readSkippableFrame" ZSTD_isSkippableFrame() :\n  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame."ZSTD_isSkippableFrame" ZSTD_estimate*() :\n  These functions make it possible to estimate memory usage\n  of a future {D,C}Ctx, before its creation.\n  This is useful in combination with ZSTD_initStatic(),\n  which makes it possible to employ a static buffer for ZSTD_CCtx* state.\n\n  ZSTD_estimateCCtxSize() will provide a memory budget large enough\n  to compress data of any size using one-shot compression ZSTD_compressCCtx() or ZSTD_compress2()\n  associated with any compression level up to max specified one.\n  The estimate will assume the input may be arbitrarily large,\n  which is the worst case.\n\n  Note that the size estimation is specific for one-shot compression,\n  it is not valid for streaming (see ZSTD_estimateCStreamSize*())\n  nor other potential ways of using a ZSTD_CCtx* state.\n\n  When srcSize can be bound by a known and rather \"small\" value,\n  this knowledge can be used to provide a tighter budget estimation\n  because the ZSTD_CCtx* state will need less memory for small inputs.\n  This tighter estimation can be provided by employing more advanced functions\n  ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),\n  and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter().\n  Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits.\n\n  Note : only single-threaded compression is supported.\n  ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1."ZSTD_estimateCCtxSizeZSTD_estimateCCtxSize_usingCParamsZSTD_estimateCCtxSize_usingCCtxParamsZSTD_estimateDCtxSize" ZSTD_estimateCStreamSize() :\n  ZSTD_estimateCStreamSize() will provide a memory budget large enough for streaming compression\n  using any compression level up to the max specified one.\n  It will also consider src size to be arbitrarily \"large\", which is a worst case scenario.\n  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.\n  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.\n  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.\n  Note : CStream size estimation is only correct for single-threaded compression.\n  ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.\n  Note 2 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time.\n  Size estimates assume that no external sequence producer is registered.\n\n  ZSTD_DStream memory budget depends on frame's window Size.\n  This information can be passed manually, using ZSTD_estimateDStreamSize,\n  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();\n  Any frame requesting a window size larger than max specified one will be rejected.\n  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),\n         an internal ?Dict will be created, which additional size is not estimated here.\n         In this case, get total size by adding ZSTD_estimate?DictSize"ZSTD_estimateCStreamSizeZSTD_estimateCStreamSize_usingCParamsZSTD_estimateCStreamSize_usingCCtxParamsZSTD_estimateDStreamSizeZSTD_estimateDStreamSize_fromFrame" ZSTD_estimate?DictSize() :\n  ZSTD_estimateCDictSize() will bet that src size is relatively \"small\", and content is copied, like ZSTD_createCDict().\n  ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().\n  Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller."ZSTD_estimateCDictSizeZSTD_estimateCDictSize_advancedZSTD_estimateDDictSize" ZSTD_initStatic*() :\n  Initialize an object using a pre-allocated fixed-size buffer.\n  workspace: The memory area to emplace the object into.\n             Provided pointer *must be 8-bytes aligned*.\n             Buffer must outlive object.\n  workspaceSize: Use ZSTD_estimate*Size() to determine\n                 how large workspace must be to support target scenario.\n @return : pointer to object (same address as workspace, just different type),\n           or NULL if error (size too small, incorrect alignment, etc.)\n  Note : zstd will never resize nor malloc() when using a static buffer.\n         If the object requires more memory than available,\n         zstd will just error out (typically ZSTD_error_memory_allocation).\n  Note 2 : there is no corresponding \"free\" function.\n           Since workspace is allocated externally, it must be freed externally too.\n  Note 3 : cParams : use ZSTD_getCParams() to convert a compression level\n           into its associated cParams.\n  Limitation 1 : currently not compatible with internal dictionary creation, triggered by\n                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().\n  Limitation 2 : static cctx currently not compatible with multi-threading.\n  Limitation 3 : static dctx is incompatible with legacy support."ZSTD_initStaticCCtxZSTD_initStaticCStreamZSTD_initStaticDCtxZSTD_initStaticDStreamZSTD_initStaticCDictZSTD_initStaticDDict" Custom memory allocation :\n  These prototypes make it possible to pass your own allocation/free functions.\n  ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.\n  All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones."ZSTD_allocFunctionZSTD_freeFunctioncustomAlloccustomFreeZSTD_customMem"< this constant defers to stdlib's functions"ZSTD_defaultCMemZSTD_createCCtx_advancedZSTD_createCStream_advancedZSTD_createDCtx_advancedZSTD_createDStream_advancedZSTD_createCDict_advancedPOOL_ctx_s" Thread pool :\n  These prototypes make it possible to share a thread pool among multiple compression contexts.\n  This can limit resources for applications with multiple threads where each one uses\n  a threaded compression mode (via ZSTD_c_nbWorkers parameter).\n  ZSTD_createThreadPool creates a new thread pool with a given number of threads.\n  Note that the lifetime of such pool must exist while being used.\n  ZSTD_CCtx_refThreadPool assigns a thread pool to a context (use NULL argument value\n  to use an internal thread pool).\n  ZSTD_freeThreadPool frees a thread pool, accepts NULL pointer."ZSTD_threadPoolZSTD_createThreadPoolZSTD_freeThreadPoolZSTD_CCtx_refThreadPoolZSTD_createCDict_advanced2ZSTD_createDDict_advanced" ZSTD_createCDict_byReference() :\n  Create a digested dictionary for compression\n  Dictionary content is just referenced, not duplicated.\n  As a consequence, `dictBuffer` **must** outlive CDict,\n  and its content must remain unmodified throughout the lifetime of CDict.\n  note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef"ZSTD_createCDict_byReference" ZSTD_getCParams() :\n @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.\n `estimatedSrcSize` value is optional, select 0 if not known"ZSTD_getCParams" ZSTD_getParams() :\n  same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.\n  All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0"ZSTD_getParams" ZSTD_checkCParams() :\n  Ensure param values remain within authorized range.\n @return 0 on success, or an error code (can be checked with ZSTD_isError())"ZSTD_checkCParams" ZSTD_adjustCParams() :\n  optimize params for a given `srcSize` and `dictSize`.\n `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.\n `dictSize` must be `0` when there is no dictionary.\n  cPar can be invalid : all parameters will be clamped within valid range in the @return struct.\n  This function never fails (wide contract)"ZSTD_adjustCParams" ZSTD_CCtx_setCParams() :\n  Set all parameters provided within @p cparams into the working @p cctx.\n  Note : if modifying parameters during compression (MT mode only),\n         note that changes to the .windowLog parameter will be ignored.\n @return 0 on success, or an error code (can be checked with ZSTD_isError()).\n         On failure, no parameters are updated."ZSTD_CCtx_setCParams" ZSTD_CCtx_setFParams() :\n  Set all parameters provided within @p fparams into the working @p cctx.\n @return 0 on success, or an error code (can be checked with ZSTD_isError())."ZSTD_CCtx_setFParams" ZSTD_CCtx_setParams() :\n  Set all parameters provided within @p params into the working @p cctx.\n @return 0 on success, or an error code (can be checked with ZSTD_isError())."ZSTD_CCtx_setParams" ZSTD_compress_advanced() :\n  Note : this function is now DEPRECATED.\n         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters.\n  This prototype will generate compilation warnings."ZSTD_compress_advanced" ZSTD_compress_usingCDict_advanced() :\n  Note : this function is now DEPRECATED.\n         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters.\n  This prototype will generate compilation warnings."ZSTD_compress_usingCDict_advanced" ZSTD_CCtx_loadDictionary_byReference() :\n  Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.\n  It saves some memory, but also requires that `dict` outlives its usage within `cctx`"ZSTD_CCtx_loadDictionary_byReference" ZSTD_CCtx_loadDictionary_advanced() :\n  Same as ZSTD_CCtx_loadDictionary(), but gives finer control over\n  how to load the dictionary (by copy ? by reference ?)\n  and how to interpret it (automatic ? force raw mode ? full mode only ?)"ZSTD_CCtx_loadDictionary_advanced" ZSTD_CCtx_refPrefix_advanced() :\n  Same as ZSTD_CCtx_refPrefix(), but gives finer control over\n  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?)"ZSTD_CCtx_refPrefix_advanced" ZSTD_CCtx_getParameter() :\n  Get the requested compression parameter value, selected by enum ZSTD_cParameter,\n  and store it into int* value.\n @return : 0, or an error code (which can be tested with ZSTD_isError())."ZSTD_CCtx_getParameter" ZSTD_CCtx_params :\n  Quick howto :\n  - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure\n  - ZSTD_CCtxParams_setParameter() : Push parameters one by one into\n                                     an existing ZSTD_CCtx_params structure.\n                                     This is similar to\n                                     ZSTD_CCtx_setParameter().\n  - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to\n                                    an existing CCtx.\n                                    These parameters will be applied to\n                                    all subsequent frames.\n  - ZSTD_compressStream2() : Do compression using the CCtx.\n  - ZSTD_freeCCtxParams() : Free the memory, accept NULL pointer.\n\n  This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()\n  for static allocation of CCtx for single-threaded compression."ZSTD_createCCtxParamsZSTD_freeCCtxParams" ZSTD_CCtxParams_reset() :\n  Reset params to default values."ZSTD_CCtxParams_reset" ZSTD_CCtxParams_init() :\n  Initializes the compression parameters of cctxParams according to\n  compression level. All other parameters are reset to their default values."ZSTD_CCtxParams_init" ZSTD_CCtxParams_init_advanced() :\n  Initializes the compression and frame parameters of cctxParams according to\n  params. All other parameters are reset to their default values."ZSTD_CCtxParams_init_advanced" ZSTD_CCtxParams_setParameter() : Requires v1.4.0+\n  Similar to ZSTD_CCtx_setParameter.\n  Set one compression parameter, selected by enum ZSTD_cParameter.\n  Parameters must be applied to a ZSTD_CCtx using\n  ZSTD_CCtx_setParametersUsingCCtxParams().\n @result : a code representing success or failure (which can be tested with\n           ZSTD_isError())."ZSTD_CCtxParams_setParameter" ZSTD_CCtxParams_getParameter() :\n Similar to ZSTD_CCtx_getParameter.\n Get the requested value of one compression parameter, selected by enum ZSTD_cParameter.\n @result : 0, or an error code (which can be tested with ZSTD_isError())."ZSTD_CCtxParams_getParameter" ZSTD_CCtx_setParametersUsingCCtxParams() :\n  Apply a set of ZSTD_CCtx_params to the compression context.\n  This can be done even after compression is started,\n    if nbWorkers==0, this will have no impact until a new compression is started.\n    if nbWorkers>=1, new parameters will be picked up at next job,\n       with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated)."ZSTD_CCtx_setParametersUsingCCtxParams" ZSTD_compressStream2_simpleArgs() :\n  Same as ZSTD_compressStream2(),\n  but using only integral types as arguments.\n  This variant might be helpful for binders from dynamic languages\n  which have troubles handling structures containing memory pointers."ZSTD_compressStream2_simpleArgs" ZSTD_isFrame() :\n  Tells if the content of `buffer` starts with a valid Frame Identifier.\n  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.\n  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.\n  Note 3 : Skippable Frame Identifiers are considered valid."ZSTD_isFrame" ZSTD_createDDict_byReference() :\n  Create a digested dictionary, ready to start decompression operation without startup delay.\n  Dictionary content is referenced, and therefore stays in dictBuffer.\n  It is important that dictBuffer outlives DDict,\n  it must remain read accessible throughout the lifetime of DDict"ZSTD_createDDict_byReference" ZSTD_DCtx_loadDictionary_byReference() :\n  Same as ZSTD_DCtx_loadDictionary(),\n  but references `dict` content instead of copying it into `dctx`.\n  This saves memory if `dict` remains around.,\n  However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression."ZSTD_DCtx_loadDictionary_byReference" ZSTD_DCtx_loadDictionary_advanced() :\n  Same as ZSTD_DCtx_loadDictionary(),\n  but gives direct control over\n  how to load the dictionary (by copy ? by reference ?)\n  and how to interpret it (automatic ? force raw mode ? full mode only ?)."ZSTD_DCtx_loadDictionary_advanced" ZSTD_DCtx_refPrefix_advanced() :\n  Same as ZSTD_DCtx_refPrefix(), but gives finer control over\n  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?)"ZSTD_DCtx_refPrefix_advanced" ZSTD_DCtx_setMaxWindowSize() :\n  Refuses allocating internal buffers for frames requiring a window size larger than provided limit.\n  This protects a decoder context from reserving too much memory for itself (potential attack scenario).\n  This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.\n  By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)\n @return : 0, or an error code (which can be tested using ZSTD_isError())."ZSTD_DCtx_setMaxWindowSize" ZSTD_DCtx_getParameter() :\n  Get the requested decompression parameter value, selected by enum ZSTD_dParameter,\n  and store it into int* value.\n @return : 0, or an error code (which can be tested with ZSTD_isError())."ZSTD_DCtx_getParameter" ZSTD_DCtx_setFormat() :\n  This function is REDUNDANT. Prefer ZSTD_DCtx_setParameter().\n  Instruct the decoder context about what kind of data to decode next.\n  This instruction is mandatory to decode data without a fully-formed header,\n  such ZSTD_f_zstd1_magicless for example.\n @return : 0, or an error code (which can be tested using ZSTD_isError())."ZSTD_DCtx_setFormat" ZSTD_decompressStream_simpleArgs() :\n  Same as ZSTD_decompressStream(),\n  but using only integral types as arguments.\n  This can be helpful for binders from dynamic languages\n  which have troubles handling structures containing memory pointers."ZSTD_decompressStream_simpleArgs" ZSTD_initCStream_srcSize() :\n This function is DEPRECATED, and equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)\n     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n\n pledgedSrcSize must be correct. If it is not known at init time, use\n ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,\n \"0\" also disables frame content size field. It may be enabled in the future.\n This prototype will generate compilation warnings."ZSTD_initCStream_srcSize" ZSTD_initCStream_usingDict() :\n This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);\n     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);\n\n Creates of an internal CDict (incompatible with static CCtx), except if\n dict == NULL or dictSize < 8, in which case no dict is used.\n Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if\n it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.\n This prototype will generate compilation warnings."ZSTD_initCStream_usingDict" ZSTD_initCStream_advanced() :\n This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setParams(zcs, params);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);\n\n dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy.\n pledgedSrcSize must be correct.\n If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.\n This prototype will generate compilation warnings."ZSTD_initCStream_advanced" ZSTD_initCStream_usingCDict() :\n This function is DEPRECATED, and equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_refCDict(zcs, cdict);\n\n note : cdict will just be referenced, and must outlive compression session\n This prototype will generate compilation warnings."ZSTD_initCStream_usingCDict" ZSTD_initCStream_usingCDict_advanced() :\n   This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setFParams(zcs, fParams);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n     ZSTD_CCtx_refCDict(zcs, cdict);\n\n same as ZSTD_initCStream_usingCDict(), with control over frame parameters.\n pledgedSrcSize must be correct. If srcSize is not known at init time, use\n value ZSTD_CONTENTSIZE_UNKNOWN.\n This prototype will generate compilation warnings."ZSTD_initCStream_usingCDict_advanced" ZSTD_resetCStream() :\n This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n Note: ZSTD_resetCStream() interprets pledgedSrcSize == 0 as ZSTD_CONTENTSIZE_UNKNOWN, but\n       ZSTD_CCtx_setPledgedSrcSize() does not do the same, so ZSTD_CONTENTSIZE_UNKNOWN must be\n       explicitly specified.\n\n  start a new frame, using same parameters from previous frame.\n  This is typically useful to skip dictionary loading stage, since it will reuse it in-place.\n  Note that zcs must be init at least once before using ZSTD_resetCStream().\n  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.\n  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.\n  For the time being, pledgedSrcSize==0 is interpreted as \"srcSize unknown\" for compatibility with older programs,\n  but it will change to mean \"empty\" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.\n @return : 0, or an error code (which can be tested using ZSTD_isError())\n  This prototype will generate compilation warnings."ZSTD_resetCStreamingestedproducedcurrentJobIDnbActiveWorkersZSTD_frameProgressionZSTD_getFrameProgression" ZSTD_toFlushNow() :\n  Tell how many bytes are ready to be flushed immediately.\n  Useful for multithreading scenarios (nbWorkers >= 1).\n  Probe the oldest active job, defined as oldest job not yet entirely flushed,\n  and check its output buffer.\n @return : amount of data stored in oldest job and ready to be flushed immediately.\n  if @return == 0, it means either :\n  + there is no active job (could be checked with ZSTD_frameProgression()), or\n  + oldest job is still actively compressing data,\n    but everything it has produced has also been flushed so far,\n    therefore flush speed is limited by production speed of oldest job\n    irrespective of the speed of concurrent (and newer) jobs."ZSTD_toFlushNow" This function is deprecated, and is equivalent to:\n\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n     ZSTD_DCtx_loadDictionary(zds, dict, dictSize);\n\n note: no dictionary will be used if dict == NULL or dictSize < 8"ZSTD_initDStream_usingDict" This function is deprecated, and is equivalent to:\n\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n     ZSTD_DCtx_refDDict(zds, ddict);\n\n note : ddict is referenced, it must outlive decompression session"ZSTD_initDStream_usingDDict" This function is deprecated, and is equivalent to:\n\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n\n reuse decompression parameters from previous init; saves dictionary loading"ZSTD_resetDStreamZSTD_sequenceProducer_F" ZSTD_registerSequenceProducer() :\n Instruct zstd to use a block-level external sequence producer function.\n\n The sequenceProducerState must be initialized by the caller, and the caller is\n responsible for managing its lifetime. This parameter is sticky across\n compressions. It will remain set until the user explicitly resets compression\n parameters.\n\n Sequence producer registration is considered to be an \"advanced parameter\",\n part of the \"advanced API\". This means it will only have an effect on compression\n APIs which respect advanced parameters, such as compress2() and compressStream2().\n Older compression APIs such as compressCCtx(), which predate the introduction of\n \"advanced parameters\", will ignore any external sequence producer setting.\n\n The sequence producer can be \"cleared\" by registering a NULL function pointer. This\n removes all limitations described above in the \"LIMITATIONS\" section of the API docs.\n\n The user is strongly encouraged to read the full API documentation (above) before\n calling this function."ZSTD_registerSequenceProducer" ZSTD_CCtxParams_registerSequenceProducer() :\n Same as ZSTD_registerSequenceProducer(), but operates on ZSTD_CCtx_params.\n This is used for accurate size estimation with ZSTD_estimateCCtxSize_usingCCtxParams(),\n which is needed when creating a ZSTD_CCtx with ZSTD_initStaticCCtx().\n\n If you are using the external sequence producer API in a scenario where ZSTD_initStaticCCtx()\n is required, then this function is for you. Otherwise, you probably don't need it.\n\n See tests/zstreamtest.c for example usage."ZSTD_CCtxParams_registerSequenceProducer"Buffer-less streaming compression (synchronous mode)\n\nA ZSTD_CCtx object is required to track streaming operations.\nUse ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.\nZSTD_CCtx object can be reused multiple times within successive compression operations.\n\nStart by initializing a context.\nUse ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression.\n\nThen, consume your input using ZSTD_compressContinue().\nThere are some important considerations to keep in mind when using this advanced function :\n- ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.\n- Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.\n- Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.\nWorst case evaluation is provided by ZSTD_compressBound().\nZSTD_compressContinue() doesn't guarantee recover after a failed compression.\n- ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).\nIt remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)\n- ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.\nIn which case, it will \"discard\" the relevant memory section from its history.\n\nFinish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.\nIt's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.\nWithout last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.\n\n`ZSTD_CCtx` object can be reused (ZSTD_compressBegin()) to compress again."ZSTD_compressBeginZSTD_compressBegin_usingDictZSTD_compressBegin_usingCDictZSTD_copyCCtxZSTD_compressContinueZSTD_compressEndZSTD_compressBegin_advancedZSTD_compressBegin_usingCDict_advanced"Buffer-less streaming decompression (synchronous mode)\n\nA ZSTD_DCtx object is required to track streaming operations.\nUse ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.\nA ZSTD_DCtx object can be reused multiple times.\n\nFirst typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().\nFrame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.\nData fragment must be large enough to ensure successful decoding.\n`ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.\nresult  : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.\n>0 : `srcSize` is too small, please provide at least result bytes on next attempt.\nerrorCode, which can be tested using ZSTD_isError().\n\nIt fills a ZSTD_frameHeader structure with important information to correctly decode the frame,\nsuch as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).\nNote that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.\nAs a consequence, check that values remain within valid application range.\nFor example, do not allocate memory blindly, check that `windowSize` is within expectation.\nEach application can set its own limits, depending on local restrictions.\nFor extended interoperability, it is recommended to support `windowSize` of at least 8 MB.\n\nZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.\nZSTD_decompressContinue() is very sensitive to contiguity,\nif 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,\nor that previous contiguous segment is large enough to properly handle maximum back-reference distance.\nThere are multiple ways to guarantee this condition.\n\nThe most memory efficient way is to use a round buffer of sufficient size.\nSufficient size is determined by invoking ZSTD_decodingBufferSize_min(),\nwhich can return an error code if required value is too large for current system (in 32-bits mode).\nIn a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,\nup to the moment there is not enough room left in the buffer to guarantee decoding another full block,\nwhich maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.\nAt which point, decoding can resume from the beginning of the buffer.\nNote that already decoded data stored in the buffer should be flushed before being overwritten.\n\nThere are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.\n\nFinally, if you control the compression process, you can also ignore all buffer size rules,\nas long as the encoder and decoder progress in \"lock-step\",\naka use exactly the same buffer sizes, break contiguity at the same place, etc.\n\nOnce buffers are setup, start decompression, with ZSTD_decompressBegin().\nIf decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().\n\nThen use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.\nZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().\nZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.\n\nresult of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).\nIt can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.\nIt can also be an error code, which can be tested with ZSTD_isError().\n\nA frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.\nContext can then be reset to start a new decompression.\n\nNote : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().\nThis information is not required to properly decode a frame.\n\n== Special case : skippable frames ==\n\nSkippable frames allow integration of user-defined data into a flow of concatenated frames.\nSkippable frames will be ignored (skipped) by decompressor.\nThe format of skippable frames is as follows :\na) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F\nb) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits\nc) Frame Content - any content (User Data) of length equal to Frame Size\nFor skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.\nFor skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content."ZSTD_decodingBufferSize_minZSTD_decompressBeginZSTD_decompressBegin_usingDictZSTD_decompressBegin_usingDDictZSTD_nextSrcSizeToDecompressZSTD_decompressContinueZSTD_copyDCtxZSTD_nextInputType_eZSTDnit_frameHeaderZSTDnit_blockHeaderZSTDnit_blockZSTDnit_lastBlockZSTDnit_checksumZSTDnit_skippableFrameZSTD_nextInputType"This API is deprecated in favor of the regular compression API.\nYou can get the frame header down to 2 bytes by setting:\n- ZSTD_c_format = ZSTD_f_zstd1_magicless\n- ZSTD_c_contentSizeFlag = 0\n- ZSTD_c_checksumFlag = 0\n- ZSTD_c_dictIDFlag = 0\n\nThis API is not as well tested as our normal API, so we recommend not using it.\nWe will be removing it in a future version. If the normal API doesn't provide\nthe functionality you need, please open a GitHub issue.\n\nBlock functions produce and decode raw zstd blocks, without frame metadata.\nFrame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).\nBut users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.\n\nA few rules to respect :\n- Compressing and decompressing require a context structure\n+ Use ZSTD_createCCtx() and ZSTD_createDCtx()\n- It is necessary to init context before starting\n+ compression : any ZSTD_compressBegin*() variant, including with dictionary\n+ decompression : any ZSTD_decompressBegin*() variant, including with dictionary\n- Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB\n+ If input is larger than a block size, it's necessary to split input data into multiple blocks\n+ For inputs larger than a single block, consider using regular ZSTD_compress() instead.\nFrame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block.\n- When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !\n===> In which case, nothing is produced into `dst` !\n+ User __must__ test for such outcome and deal directly with uncompressed data\n+ A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0.\nDoing so would mess up with statistics history, leading to potential data corruption.\n+ ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!\n+ In case of multiple successive blocks, should some of them be uncompressed,\ndecoder must be informed of their existence in order to follow proper history.\nUse ZSTD_insertBlock() for such a case."ZSTD_getBlockSizeZSTD_compressBlockZSTD_decompressBlockZSTD_insertBlockZSTD_ErrorCodeZSTD_error_no_errorZSTD_error_GENERICZSTD_error_prefix_unknownZSTD_error_version_unsupportedZSTD_error_frameParameter_unsupportedZSTD_error_frameParameter_windowTooLargeZSTD_error_corruption_detectedZSTD_error_checksum_wrongZSTD_error_literals_headerWrongZSTD_error_dictionary_corruptedZSTD_error_dictionary_wrongZSTD_error_dictionaryCreation_failedZSTD_error_parameter_unsupportedZSTD_error_parameter_combination_unsupportedZSTD_error_parameter_outOfBoundZSTD_error_tableLog_tooLargeZSTD_error_maxSymbolValue_tooLargeZSTD_error_maxSymbolValue_tooSmallZSTD_error_stabilityCondition_notRespectedZSTD_error_stage_wrongZSTD_error_init_missingZSTD_error_memory_allocationZSTD_error_workSpace_tooSmallZSTD_error_dstSize_tooSmallZSTD_error_srcSize_wrongZSTD_error_dstBuffer_nullZSTD_error_noForwardProgress_destFullZSTD_error_noForwardProgress_inputEmptyZSTD_error_frameIndex_tooLargeZSTD_error_seekableIOZSTD_error_dstBuffer_wrongZSTD_error_srcBuffer_wrongZSTD_error_sequenceProducer_failedZSTD_error_externalSequences_invalidZSTD_error_maxCode" ZSTD_getErrorCode() :\nconvert a `size_t` function result into a `ZSTD_ErrorCode` enum type,\nwhich can be used to compare with enum list published above"ZSTD_getErrorCodeZSTD_getErrorString" ZSTD_compressCCtx() :\n  Same as ZSTD_compress(), using an explicit ZSTD_CCtx.\n  Important : in order to behave similarly to `ZSTD_compress()`,\n  this function compresses at requested compression level,\n  __ignoring any other parameter__ .\n  If any advanced parameter was set using the advanced API,\n  they will all be reset. Only `compressionLevel` remains."" ZSTD_decompressDCtx() :\n  Same as ZSTD_decompress(),\n  requires an allocated ZSTD_DCtx.\n  Compatible with sticky parameters."ZSTD_c_experimentalParam6" ZSTD_compress2() :\n  Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.\n  ZSTD_compress2() always starts a new frame.\n  Should cctx hold data from a previously unfinished frame, everything about it is forgotten.\n  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()\n  - The function is always blocking, returns when compression is completed.\n  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have\n        enough space to successfully compress the data, though it is possible it fails for other reasons.\n @return : compressed size written into `dst` (<= `dstCapacity),\n           or an error code if it fails (which can be tested using ZSTD_isError())."" ZSTD_compressStream2() : Requires v1.4.0+\n  Behaves about the same as ZSTD_compressStream, with additional control on end directive.\n  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()\n  - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)\n  - output->pos must be <= dstCapacity, input->pos must be <= srcSize\n  - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.\n  - endOp must be a valid directive\n  - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.\n  - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available,\n                                                  and then immediately returns, just indicating that there is some data remaining to be flushed.\n                                                  The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.\n  - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.\n  - @return provides a minimum amount of data remaining to be flushed from internal buffers\n            or an error code, which can be tested using ZSTD_isError().\n            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.\n            This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.\n            For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.\n  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),\n            only ZSTD_e_end or ZSTD_e_flush operations are allowed.\n            Before starting a new compression job, or changing compression parameters,\n            it is required to fully flush internal buffers."" ZSTD_decompressStream() :\n Streaming decompression function.\n Call repetitively to consume full input updating it as necessary.\n Function will update both input and output `pos` fields exposing current state via these fields:\n - `input.pos < input.size`, some input remaining and caller should provide remaining input\n   on the next call.\n - `output.pos < output.size`, decoder finished and flushed all remaining buffers.\n - `output.pos == output.size`, potentially uncflushed data present in the internal buffers,\n   call ZSTD_decompressStream() again to flush remaining data to output.\n Note : with no additional input, amount of data flushed <= ZSTD_BLOCKSIZE_MAX.\n\n @return : 0 when a frame is completely decoded and fully flushed,\n           or an error code, which can be tested using ZSTD_isError(),\n           or any other value > 0, which means there is some decoding or flushing to do to complete current frame."" ZSTD_generateSequences() :\n Generate sequences using ZSTD_compress2(), given a source buffer.\n\n Each block will end with a dummy sequence\n with offset == 0, matchLength == 0, and litLength == length of last literals.\n litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0)\n simply acts as a block delimiter.\n\n @zc can be used to insert custom compression params.\n This function invokes ZSTD_compress2().\n\n The output of this function can be fed into ZSTD_compressSequences() with CCtx\n setting of ZSTD_c_blockDelimiters as ZSTD_sf_explicitBlockDelimiters\n @return : number of sequences generated"" ZSTD_estimate*() :\n  These functions make it possible to estimate memory usage\n  of a future {D,C}Ctx, before its creation.\n\n  ZSTD_estimateCCtxSize() will provide a memory budget large enough\n  for any compression level up to selected one.\n  Note : Unlike ZSTD_estimateCStreamSize*(), this estimate\n         does not include space for a window buffer.\n         Therefore, the estimation is only guaranteed for single-shot compressions, not streaming.\n  The estimate will assume the input may be arbitrarily large,\n  which is the worst case.\n\n  When srcSize can be bound by a known and rather \"small\" value,\n  this fact can be used to provide a tighter estimation\n  because the CCtx compression context will need less memory.\n  This tighter estimation can be provided by more advanced functions\n  ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),\n  and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter().\n  Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits.\n\n  Note : only single-threaded compression is supported.\n  ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.\n\n  Note 2 : ZSTD_estimateCCtxSize* functions are not compatible with the Block-Level Sequence Producer API at this time.\n  Size estimates assume that no external sequence producer is registered."" ZSTD_estimateCStreamSize() :\n  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.\n  It will also consider src size to be arbitrarily \"large\", which is worst case.\n  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.\n  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.\n  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.\n  Note : CStream size estimation is only correct for single-threaded compression.\n  ZSTD_DStream memory budget depends on window Size.\n  This information can be passed manually, using ZSTD_estimateDStreamSize,\n  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();\n  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),\n         an internal ?Dict will be created, which additional size is not estimated here.\n         In this case, get total size by adding ZSTD_estimate?DictSize\n  Note 2 : only single-threaded compression is supported.\n  ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.\n  Note 3 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time.\n  Size estimates assume that no external sequence producer is registered."" ZSTD_resetCStream() :\n This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n Note: ZSTD_resetCStream() interprets pledgedSrcSize == 0 as ZSTD_CONTENTSIZE_UNKNOWN, but\n       ZSTD_CCtx_setPledgedSrcSize() does not do the same, so ZSTD_CONTENTSIZE_UNKNOWN must be\n       explicitly specified.\n\n  start a new frame, using same parameters from previous frame.\n  This is typically useful to skip dictionary loading stage, since it will re-use it in-place.\n  Note that zcs must be init at least once before using ZSTD_resetCStream().\n  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.\n  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.\n  For the time being, pledgedSrcSize==0 is interpreted as \"srcSize unknown\" for compatibility with older programs,\n  but it will change to mean \"empty\" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.\n @return : 0, or an error code (which can be tested using ZSTD_isError())\n  This prototype will generate compilation warnings."" This function is deprecated, and is equivalent to:\n\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n\n re-use decompression parameters from previous init; saves dictionary loading""Buffer-less streaming compression (synchronous mode)\n\nA ZSTD_CCtx object is required to track streaming operations.\nUse ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.\nZSTD_CCtx object can be re-used multiple times within successive compression operations.\n\nStart by initializing a context.\nUse ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression.\n\nThen, consume your input using ZSTD_compressContinue().\nThere are some important considerations to keep in mind when using this advanced function :\n- ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.\n- Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.\n- Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.\nWorst case evaluation is provided by ZSTD_compressBound().\nZSTD_compressContinue() doesn't guarantee recover after a failed compression.\n- ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).\nIt remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)\n- ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.\nIn which case, it will \"discard\" the relevant memory section from its history.\n\nFinish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.\nIt's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.\nWithout last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.\n\n`ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.""Buffer-less streaming decompression (synchronous mode)\n\nA ZSTD_DCtx object is required to track streaming operations.\nUse ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.\nA ZSTD_DCtx object can be re-used multiple times.\n\nFirst typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().\nFrame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.\nData fragment must be large enough to ensure successful decoding.\n`ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.\nresult  : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.\n>0 : `srcSize` is too small, please provide at least result bytes on next attempt.\nerrorCode, which can be tested using ZSTD_isError().\n\nIt fills a ZSTD_frameHeader structure with important information to correctly decode the frame,\nsuch as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).\nNote that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.\nAs a consequence, check that values remain within valid application range.\nFor example, do not allocate memory blindly, check that `windowSize` is within expectation.\nEach application can set its own limits, depending on local restrictions.\nFor extended interoperability, it is recommended to support `windowSize` of at least 8 MB.\n\nZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.\nZSTD_decompressContinue() is very sensitive to contiguity,\nif 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,\nor that previous contiguous segment is large enough to properly handle maximum back-reference distance.\nThere are multiple ways to guarantee this condition.\n\nThe most memory efficient way is to use a round buffer of sufficient size.\nSufficient size is determined by invoking ZSTD_decodingBufferSize_min(),\nwhich can return an error code if required value is too large for current system (in 32-bits mode).\nIn a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,\nup to the moment there is not enough room left in the buffer to guarantee decoding another full block,\nwhich maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.\nAt which point, decoding can resume from the beginning of the buffer.\nNote that already decoded data stored in the buffer should be flushed before being overwritten.\n\nThere are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.\n\nFinally, if you control the compression process, you can also ignore all buffer size rules,\nas long as the encoder and decoder progress in \"lock-step\",\naka use exactly the same buffer sizes, break contiguity at the same place, etc.\n\nOnce buffers are setup, start decompression, with ZSTD_decompressBegin().\nIf decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().\n\nThen use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.\nZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().\nZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.\n\nresult of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).\nIt can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.\nIt can also be an error code, which can be tested with ZSTD_isError().\n\nA frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.\nContext can then be reset to start a new decompression.\n\nNote : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().\nThis information is not required to properly decode a frame.\n\n== Special case : skippable frames ==\n\nSkippable frames allow integration of user-defined data into a flow of concatenated frames.\nSkippable frames will be ignored (skipped) by decompressor.\nThe format of skippable frames is as follows :\na) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F\nb) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits\nc) Frame Content - any content (User Data) of length equal to Frame Size\nFor skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.\nFor skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content."// The bindings used depend on a few feature flags.//! Low-level bindings to the [zstd] library.//! [zstd]: https://facebook.github.io/zstd/USIZE_SIZErust_zstd_wasm_shim_qsortrust_zstd_wasm_shim_mallocrust_zstd_wasm_shim_memcmprust_zstd_wasm_shim_callocZEROEDwasm_shim_allocrust_zstd_wasm_shim_freerust_zstd_wasm_shim_memcpyrust_zstd_wasm_shim_memmoverust_zstd_wasm_shim_memset// buffer from which we are pulling in bits from// used in decompression.// position in our buffer,bits_leftover_readBitStreamReader/// Create a new `BitStreamReader` instance/// # Expectations/// The buffer must be padded with fill bytes in the end,/// if not, this becomes UB in the refill phase.refill/// Refill the bitstream ensuring the buffer has bits between/// 56 and 63.refill_inner_looprefill_slowLOOKAHEADpeek_var_bitsget_bits_left/// Get number of bits left in the bit buffer./// Get position the stream is in this buffer/// Or alternatively, number of bits read./// Reset buffer and bits left to zero.has/// Return true if the bit buffer can satisfy/// `bits` read without refilling,drop_bits/// Return the remaining bytes in this stream./// This does not consider bits in the bit-buffer hence/// may not be accurate//! `BitStreamReader` API//! This module provides an interface to read and write bits (and bytes) for//! huffmanconst_min_usizeDEFLATE_NUM_PRECODE_SYMS/// Number of symbols in each Huffman code.  Note: for the literal/length/// and offset codes, these are actually the maximum values; a given block/// might use fewer symbols.DEFLATE_NUM_LITLEN_SYMSDEFLATE_NUM_OFFSET_SYMSDELFATE_MAX_LENS_OVERRUN/// Maximum possible overrun when decoding codeword lengthsDEFLATE_PRECODE_LENS_PERMUTATION/// Order which precode lengths are storedPRECODE_ENOUGHDEFLATE_MAX_CODEWORD_LENGTH/// Maximum codeword length across all codes.DEFLATE_MAX_OFFSET_CODEWORD_LENGTHDEFLATE_MAX_LITLEN_CODEWORD_LENGTHPRECODE_TABLE_BITSLITLEN_TABLE_BITSLITLEN_ENOUGHOFFSET_TABLEBITS/// Maximum bits found in the lookup table for offsets/// offsets larger than this require a lookup into a sub-tableOFFSET_ENOUGH/// Note, default libdeflate value is 402, but with 512,/// we can remove a branch check by simply doing & 511, and I'll take that.DEFLATE_MAX_NUM_SYMS/// Maximum number of symbols across all codesDEFLATE_MAX_PRE_CODEWORD_LEN///Maximum codeword length in bits for each precodePRECODE_DECODE_RESULTS/// Format for precode decode table entries, Bits not explicitly contain zeroes/// 20-16: presym/// 10-8 Codeword length(not used)/// Bit 2-0 Codeword length/// It never has sub-tables since we use PRECODE_TABLEBITS == MAX_PRECODEWORD_LENGTH/// PRECODE_DECODE_RESULTS contains static parts of the entry for each symbol,/// make_decode_table_entry produces the final resultsmake_precode_static_tableHUFFDEC_LITERAL/// Presence of a literal entryHUFFDEC_EXCEPTIONAL/// Presence of HUFFDEC_SUITABLE_POINTER or HUFFDEC_END_OF_BLOCKHUFFDEC_SUITABLE_POINTER/// Pointer entry in the litlen or offset decode tableHUFFDEC_END_OF_BLOCK/// End of block entry in litlen decode tableconstruct_litlen_decode_tableOFFSET_DECODE_RESULTS// the things we do for alignmentLITLEN_DECODE_RESULTSDEFLATE_BLOCKTYPE_DYNAMIC_HUFFMANDEFLATE_BLOCKTYPE_UNCOMPRESSEDDEFLATE_BLOCKTYPE_RESERVEDDEFLATE_BLOCKTYPE_STATICLITLEN_DECODE_BITSDEFLATE_MAX_MATCH_LEN/// Maximum length of a deflate matchFASTCOPY_BYTES/// Number of bytes copied per every loopFASTLOOP_MAX_BYTES_WRITTEN/// Worst case maximum number of output bytes writtern during each iteration of the/// fastloop.CRC32_SLICE1_TABLECRC32_SLICE8_TABLE//! crc tables- Data tables for CRC32 computation//! Gotten from Eric Biggers libdeflate.crc_tables/// Calculate crc for a data and an initial crc valuebitstreamDecodeErrorStatusInflateDecodeErrorscopy_rep_matchesfixed_copy_withinmake_decode_table_entrylitlen_decode_tableoffset_decode_tableDeflateHeaderTablesconfirm_checksumDeflateOptions/// Options that can influence decompression/// in Deflate/Zlib/Gzip/// To use them, pass a customized options to/// the deflate decoder.get_limit/// Get deflate/zlib limit option/// The decoder won't extend the inbuilt limit and will/// return an error if the limit is exceeded///  The currently set limit of the instance/// This is provided as a best effort, correctly quiting/// is detrimental to speed and hence this should not be relied too much./// Set a limit to the internal vector/// used to store decoded zlib/deflate output./// limit: The new decompressor limit/// A modified version of DeflateDecoder/// is detrimental to speed and hence this should not be relied too muchget_confirm_checksum/// Get whether the decoder will confirm a checksum/// after decodingset_confirm_checksum/// Set whether the decoder should confirm a checksum/// Note, you should definitely confirm your checksum, use/// this with caution, otherwise data returned may be corrupt/// - yes: When true, the decoder will confirm checksum/// when false, the decoder will skip checksum verification/// This does not have an influence for deflate decoding as/// it does not have a checksumget_size_hint/// Get the default set size hint for the decompressor/// The decompressor initializes the internal storage for decompressed bytes/// with this size and will reallocate the vec if the decompressed size becomes bigger/// than this, but when the user currently knows how big the output will be, can be used/// to prevent unnecessary re-allocationsset_size_hint/// Set the size hint for the decompressor/// This can be used to prevent multiple re-allocationsis_last_blockstatic_codes_loadeddeflate_header_tables/// A deflate decoder instance./// The decoder manages output buffer as opposed to requiring the caller to provide a pre-allocated buffer/// it tracks number of bytes written and on successfully reaching the/// end of the block, will return a vector with exactly/// the number of decompressed bytes./// This means that it may use up huge amounts of memory if not checked, but/// there are [options] that can prevent that/// [options]: DeflateOptions/// Create a new decompressor that will read compressed/// data from `data` and return a new vector containing new data/// - `data`: The compressed data. Data can be of any type/// gzip,zlib or raw deflate./// A decoder instance which will pull compressed data from `data` to inflate the output output///  # Note/// The default output size limit is **1 GiB.**/// this is to protect the end user against ddos attacks as deflate does not specify it's/// output size upfront/// The checksum will be verified depending on the called function./// this only works for zlib and gzip since deflate does not have a checksum/// These defaults can be overridden via [new_with_options()](Self::new_with_options)./// Create new decoder with specified options/// This can be used to fine tune the decoder to the user's/// - `data`: The compressed data. Data can be of any format i.e/// gzip, zlib or raw deflate./// - `options` : A set of user defined options which tune how the decompressor///  # Returns/// A decoder instance which will pull compressed data from `data` to inflate output/// use zune_inflate::{DeflateDecoder, DeflateOptions};/// let data  = [37];/// let options = DeflateOptions::default()///     .set_confirm_checksum(true) // confirm the checksum for zlib and gzip///     .set_limit(1000); // how big I think the input will be    /// let mut decoder = DeflateDecoder::new_with_options(&data,options);/// // do some stuff and then call decode/// let data = decoder.decode_zlib();decode_zlib/// Decode zlib-encoded data returning the uncompressed in a `Vec<u8>`/// or an error if something went wrong./// Bytes consumed will be from the data passed when the/// `new` method was called./// - None/// Result type containing the decoded data./// - `Ok(Vec<u8>)`: Decoded vector containing the uncompressed bytes/// - `Err(InflateDecodeErrors)`: Error that occurred during decoding/// It's possible to recover bytes even after an error occurred, bytes up/// to when error was encountered are stored in [InflateDecodeErrors]/// This needs the `zlib` feature enabled to be available otherwise it's a/// compile time error/// [InflateDecodeErrors]:crate::errors::InflateDecodeErrorsdecode_deflate/// Decode a deflate stream returning the data as `Vec<u8>` or an error/// indicating what went wrong./// let data = [42]; // answer to life, the universe and everything/// let mut decoder = zune_inflate::DeflateDecoder::new(&data);/// let bytes = decoder.decode_deflate().unwrap();///  [InflateDecodeErrors]:crate::errors::InflateDecodeErrorsstart_deflate_block/// Main inner loop for decompressing deflate databuild_decode_table/// Build decode tables for static and dynamic/// huffman blocks.build_decode_table_inner/// Build the decode table for the precodeRESIZE_BYresize_and_push/// Resize vector if its current space wont/// be able to store a new byte and then push an element to that new space// 4 kb/*
 * Copyright (c) 2023.
 *
 * This software is free software;
 *
 * You can redistribute it or modify it under terms of the MIT, Apache License or Zlib license
 *///! Fast match finder//! This implements a fast match finder that can match up to one previous matchfast_match_finder_SEQ_LENGTH_SHIFT_SEQ_LITRUNLEN_MASKlitrunlen_and_length/*
     * Bits 0..22: the number of literals in this run.  This may be 0 and
     * can be at most MAX_BLOCK_LENGTH.  The literals are not stored
     * explicitly in this structure; instead, they are read directly from
     * the uncompressed data.
     *
     * Bits 23..31: the length of the match which follows the literals, or 0
     * if this literal run was the last in the block, so there is no match
     * which follows it.
     */_SequenceDeflateEncodingStrategyDeflateEncodingOptionsoutput_positioninput_position/// A simple Deflate Encoder./// Not yet complete/// Create a new deflate encoder./// Thewrite_zlib_headerencode_no_compression/// Encode a deflate data block with no compression/// # Argument/// - `bytes`: number of bytes to compress from input as non-compressed/// bytesencode_deflate/// Encode a deflate streamencode_zlib/*
 * Copyright (c) 2023.
 *
 * This software is free software; You can redistribute it or modify it under terms of the MIT, Apache License or Zlib license
 *//// reason why decompression fails/// Decoded data up until that decompression error/// A struct returned when decompression fails/// This struct contains two fields,/// - `error`:Tells you the error that actually occured./// - `data`: Gives you decoded data up until that point when/// the error was encountered./// One can recover data up to the error if they so wish but/// guarantees about data state is not given/// Create a new decode wrapper with data being/// how many bytes we actually decoded before hitting an error/// - `error`: Error encountered during decoding/// - `data`:  Data up to that point of decoding/// Itself/// Create a new decode wrapper with an empty vector/// - `error`: Error encountered during decoding./// Input data is not enough to construct/// a full output/// Anything that isn't significantGenericStr/// Anything that isn't significant but we need to/// pass back information to the user as to what went wrongCorruptData///Input data was malformed.OutputLimitExceeded/// Limit set by the user was exceeded by/// decompressed outputMismatchedCRC/// Output CRC does not match stored CRC./// Only present for zlibMismatchedAdler/// Output Adler does not match stored adler/// Only present for gzip//! Errors possible when decoding deflate/zlib/gzip//! streamsGZIP_ID1GZIP_ID2GZIP_CM_DEFLATEGZIP_FRESERVEDGZIP_FEXTRAGZIP_FOOTER_SIZEGZIP_FHCRCGZIP_FNAMEGZIP_FCOMMENTgzip_constants//! An incredibly spiffy deflate decoder.//! This crate features a deflate/zlib decoder inspired by//! Eric Bigger's [libdeflate].//! This libary has a smaller set of features hence you should use it//! if it aligns with your end goals.//! Use it if//! - You want a smaller library footprint when compared to flate/miniz-oxide//! - You want faster speeds than zlib-ng/zlib/miniz-oxide.//! - You do full buffer decompression and not streaming decompression.//! - You don't need compression support for now, it will come soon enough.//! - You want a 100% safe, pure rust implementation with above.//!Do not use it if//!  - You want compression support, not yet there//!  - You stream your data, not compatible with this library//!- For the fastest speeds, check out [libdeflate] (C), if using Rust there is [libdeflater] which//! provides bindings to [libdeflate]//!- For streaming support use [flate2-rs] with an appropriate backend(zlib-ng is recommended for speed)//! You can disable features depending on what you need. the following are//! features present//! - gzip: Enable gzip decoding//! - zlib: Enable zlib decoding//! These features are enabled by default//! To disable a feature , modify Cargo.toml to disable default features//! and add the needed feature , e.g below will include zlib decoding and disable gzip decoding//! zune-inflate={ version="0.2",default-features=false,feature=["zlib"]}//! In case of an error, the library returns the error and the decoded//! data up to when the error was encountered hence that data can be recovered//! but no data further than that can be recovered//! Decoding delfate data//! use zune_inflate::DeflateDecoder;//! let totally_valid_data = [0;23];//! let mut decoder = DeflateDecoder::new(&totally_valid_data);//! let decompressed =decoder.decode_deflate().unwrap();//! Decoding zlib data//! // yea this isn't valid//! let decompressed =decoder.decode_zlib().unwrap();//! Decoding zlib data without confirming the adler32 checksum//! use zune_inflate::DeflateOptions;//! let totally_valid_data=[0;23];//! let mut options = DeflateOptions::default()//!                     .set_confirm_checksum(false);//! let decoder =  DeflateDecoder::new_with_options(&totally_valid_data,options);//! [libdeflate]: https://github.com/ebiggers/libdeflate//! [libdeflater]: https://github.com/adamkewley/libdeflater//! [flate2-rs]: https://github.com/rust-lang/flate2-rs/// make_decode_table_entry() creates a decode table entry for the given symbol/// by combining the static part 'decode_results[sym]' with the dynamic part/// 'len', which is the remaining codeword length (the codeword length for main/// table entries, or the codeword length minus TABLEBITS for subtable entries)./// In all cases, we add 'len' to each of the two low-order bytes to create the/// appropriately-formatted decode table entry.  See the definitions of the/// *_decode_results[] arrays below, where the entry format is described./// A safe version of src.copy_within that helps me because I tend to always/// confuse the arguments/// Return the minimum of two usizes in a const contextcalc_adler_hash/// Calculate the adler hash of a piece of data.value_display_fmtSignatureSeed/// A helper type to wrap arrays in a [`Value`]./// API is provided to convert from, and to a [`Vec`]./// [`Value`]: enum.Value.html#variant.Array/// Create a new empty `Array`, given the signature of the elements.new_full_signature/// Append `element`./// if `element`'s signature doesn't match the element signature `self` was created for./// Get all the elements./// Get the number of elements./// Get the signature of this `Array`./// NB: This method potentially allocates and copies. Use [`full_signature`] if you'd like to/// avoid that./// [`full_signature`]: #method.full_signaturefull_signature/// Get the signature of the elements in the `Array`.array_display_fmtArraySeed/// Use this to deserialize an [Array].dynamic_signaturedeserializer_for_signaturecreate_signature// TODO: this could be useful// impl<'a, 'b, T> TryFrom<&'a Array<'b>> for Vec<T>EncodingFormatSIGNATURE_CHAR/// The type signature, as a character.SIGNATURE_STR/// The type signature, as a string./// The required padding alignment for the given format./// Trait for basic types./// All basic types are also [`Type`] implementers./// [`Type`]: trait.Type.html/// [`Value`]: enum.Value.htmlimpl_typealignment_method// No i8 type in D-Bus/GVariant, let's pretend it's i16// No f32 type in D-Bus/GVariant, let's pretend it's f64MaxDepthExceededMAX_STRUCT_DEPTH// We take the limits from the D-Bus specification for gvariant as well.// The GVariant specification removed all the limits, from the D-Bus specification but that turned// out to be a [mistake]. Although glib went for a higher limit (128) but we'll stick to the D-Bus// limits and expand if/when needed.// [mistake]: https://gitlab.gnome.org/GNOME/glib/-/commit/7c4e6e9fbe473de0401c778c6b0c4aad27d5145aMAX_ARRAY_DEPTHMAX_TOTAL_DEPTHContainerDepths// Represents the current depth of all container being (de)serialized.inc_structuredec_structureinc_arraydec_arrayinc_variantValueParseStagesignature_parserSignatureParser'sigDeserializerCommon/// Our D-Bus deserialization implementation./// Create a Deserializer struct instance./// On Windows, there is no `fds` argument.deserialize_basicdeserialize_aselement_alignment// alignment of elementelement_signature_len// where value signature startsdeserialize_ayArraySeqDeserializerArrayMapDeserializerStructureDeserializersig_startcontainer_depths'serSerializerCommon/// Our D-Bus serialization implementation./// Create a D-Bus Serializer struct instance.serialize_basicStructSeqSerializer// size of element signaturefirst_padding// First element's paddingend_parens// The number of `)` in the signature to skip at the end.// The original container depths. We restore to that at the end.enum_variantserialize_struct_elementend_struct/// Allows us to serialize a struct as an ARRAY.serialize_struct_anon_fieldsserialize_struct_named_fieldsDBusDeserializerfrom_slice_fds/// Deserialize `T` from a given slice of bytes, containing file descriptor indices./// Please note that actual file descriptors are not part of the encoding and need to be transferred/// via an out-of-band platform specific mechanism. The encoding only contain the indices of the/// file descriptors and hence the reason, caller must pass a slice of file descriptors./// This function is not available on Windows./// use zvariant::{to_bytes_fds, from_slice_fds};/// use zvariant::{EncodingContext, Fd};/// let ctxt = EncodingContext::<byteorder::LE>::new_dbus(0);/// let (encoded, fds) = to_bytes_fds(ctxt, &Fd::from(42)).unwrap();/// let decoded: Fd = from_slice_fds(&encoded, Some(&fds), ctxt).unwrap();/// assert_eq!(decoded, Fd::from(42));/// [`from_slice`]: fn.from_slice.html/// Deserialize `T` from a given slice of bytes./// If `T` is an, or (potentially) contains an [`Fd`], use [`from_slice_fds`] instead./// use zvariant::{to_bytes, from_slice};/// use zvariant::EncodingContext;/// let encoded = to_bytes(ctxt, "hello world").unwrap();/// let decoded: &str = from_slice(&encoded, ctxt).unwrap();/// assert_eq!(decoded, "hello world");/// [`Fd`]: struct.Fd.html/// [`from_slice_fds`]: fn.from_slice_fds.htmlfrom_slice_for_signature/// Deserialize `T` from a given slice of bytes with the given signature./// Use this function instead of [`from_slice`] if the value being deserialized does not implement/// [`Type`]. Also, if `T` is an, or (potentially) contains an [`Fd`], use/// [`from_slice_fds_for_signature`] instead./// While `Type` derive supports enums, for this example, let's supposed it doesn't and we don't/// want to manually implement `Type` trait either:/// use zvariant::{to_bytes_for_signature, from_slice_for_signature};/// #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]/// enum Unit {///     Variant1,///     Variant2,///     Variant3,/// let signature = "u".try_into().unwrap();/// let encoded = to_bytes_for_signature(ctxt, &signature, &Unit::Variant2).unwrap();/// assert_eq!(encoded.len(), 4);/// let decoded: Unit = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();/// assert_eq!(decoded, Unit::Variant2);/// enum NewType<'s> {///     Variant1(&'s str),///     Variant2(&'s str),///     Variant3(&'s str),/// let signature = "(us)".try_into().unwrap();/// let encoded =///     to_bytes_for_signature(ctxt, &signature, &NewType::Variant2("hello")).unwrap();/// assert_eq!(encoded.len(), 14);/// let decoded: NewType<'_> = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();/// assert_eq!(decoded, NewType::Variant2("hello"));/// enum Structs {///     Tuple(u8, u64),///     Struct { y: u8, t: u64 },/// // TODO: Provide convenience API to create complex signatures/// let signature = "(u(yt))".try_into().unwrap();/// let encoded = to_bytes_for_signature(ctxt, &signature, &Structs::Tuple(42, 42)).unwrap();/// assert_eq!(encoded.len(), 24);/// let decoded: Structs = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();/// assert_eq!(decoded, Structs::Tuple(42, 42));/// let s = Structs::Struct { y: 42, t: 42 };/// let encoded = to_bytes_for_signature(ctxt, &signature, &s).unwrap();/// assert_eq!(decoded, Structs::Struct { y: 42, t: 42 });/// [`from_slice_fds_for_signature`]: fn.from_slice_fds_for_signature.html// TODO: Return number of bytes parsed?from_slice_fds_for_signature/// Deserialize `T` from a given slice of bytes containing file descriptor indices, with the given/// [`from_slice_for_signature`]: fn.from_slice_for_signature.html_from_slice_fds_for_signaturefrom_slice_for_dynamic_signaturefrom_slice_fds_for_dynamic_signaturefrom_slice_with_seed/// Deserialize `T` from a given slice of bytes containing file descriptor indices, using the givenfrom_slice_fds_with_seed_from_slice_fds_with_seedsig_parser/// Our deserialization implementation./// Using this deserializer involves an redirection to the actual deserializer. It's best/// to use the serialization functions, e.g [`crate::to_bytes`] or specific serializers,/// [`crate::dbus::Deserializer`] or [`crate::zvariant::Deserializer`].parse_paddingprep_deserialize_basicnext_const_size_sliceabs_posdeserialize_method// Enum handling is very generic so it can be here and specific deserializers can use this.DeserializeValue/// A wrapper to deserialize a value to `T: Type + Deserialize`./// When the type of a value is well-known, you may avoid the cost and complexity of wrapping to a/// generic [`Value`] and instead use this wrapper./// # use zvariant::{to_bytes, EncodingContext, DeserializeValue, SerializeValue, from_slice};/// # let ctxt = EncodingContext::<byteorder::LE>::new_dbus(0);/// # let array = [0, 1, 2];/// # let v = SerializeValue(&array);/// # let encoded = to_bytes(ctxt, &v).unwrap();/// let decoded: DeserializeValue<[u8; 3]> = from_slice(&encoded, ctxt).unwrap();/// # assert_eq!(decoded.0, array);DeserializeValueVisitorkey_signaturevalue_signature// should use a separate lifetime or everything should use the same but API break./// A helper type to wrap dictionaries in a [`Value`]./// API is provided to convert from, and to a [`HashMap`]./// [`Value`]: enum.Value.html#variant.Dict/// [`HashMap`]: https://doc.rust-lang.org/std/collections/struct.HashMap.html/// Create a new empty `Dict`, given the signature of the keys and values.'kv'vv/// Append `key` and `value` as a new entry./// * if [`key.value_signature()`] doesn't match the key signature `self` was created for./// * if [`value.value_signature()`] doesn't match the value signature `self` was created for./// [`key.value_signature()`]: enum.Value.html#method.value_signature/// [`value.value_signature()`]: enum.Value.html#method.value_signature/// Add a new entry./// Get the value for the given key./// Get the signature of this `Dict`./// Create a new empty `Dict`, given the complete signature.// TODO: Provide more API like https://docs.rs/toml/0.5.5/toml/map/struct.Map.htmldict_display_fmt// Conversion of Dict to HashMap// Conversion of Hashmap to Dict// impl<'d, 'k, 'v, K, V, H> TryFrom<&'d Dict<'k, 'v>> for HashMap<&'k K, &'v V, H>// TODO: Conversion of Dict from/to BTreeMap/// [D-Bus](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-marshaling)/// The encoding format./// The encoding context to use with the [serialization and deserialization] API./// This type is generic over the [ByteOrder] trait. Moreover, the encoding is dependent on the/// position of the encoding in the entire message and hence the need to [specify] the byte/// position of the data being serialized or deserialized. Simply pass `0` if serializing or/// deserializing to or from the beginning of message, or the preceding bytes end on an 8-byte/// use byteorder::LE;/// use zvariant::EncodingContext as Context;/// use zvariant::{from_slice, to_bytes};/// let str_vec = vec!["Hello", "World"];/// let ctxt = Context::<LE>::new_dbus(0);/// let encoded = to_bytes(ctxt, &str_vec).unwrap();/// // Let's decode the 2nd element of the array only/// let ctxt = Context::<LE>::new_dbus(14);/// let decoded: &str = from_slice(&encoded[14..], ctxt).unwrap();/// assert_eq!(decoded, "World");/// [serialization and deserialization]: index.html#functions/// [ByteOrder]: https://docs.rs/byteorder/1.3.4/byteorder/trait.ByteOrder.html/// [specify]: #method.new/// Create a new encoding context.new_dbus/// Convenient wrapper for [`new`] to create a context for D-Bus format./// The [`EncodingFormat`] of this context./// [`EncodingFormat`]: enum.EncodingFormat.html/// The byte position of the value to be encoded or decoded, in the entire message./// The maximum allowed depth for structures in encoding was exceeded./// The maximum allowed depth for arrays in encoding was exceeded./// The maximum allowed depth for containers in encoding was exceeded./// Enum representing the max depth exceeded error./// Generic error. All serde errors gets transformed into this variant./// Wrapper for [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html)IncorrectType/// Type conversions errors./// Wrapper for [`std::str::Utf8Error`](https://doc.rust-lang.org/std/str/struct.Utf8Error.html)PaddingNot0/// Non-0 padding byte(s) encountered.UnknownFd/// The deserialized file descriptor is not in the given FD index.MissingFramingOffset/// Missing framing offset at the end of a GVariant-encoded container,IncompatibleFormat/// The type (signature as first argument) being (de)serialized is not supported by the format.SignatureMismatch/// The provided signature (first argument) was not valid for reading as the requested type./// Details on the expected signatures are in the second argument./// Out of bounds range specified./// Error type used by zvariant API.// TODO: Add more specific error variants to Error enum above so we can implement other methods/// Alias for a `Result` with the error type `zvariant::Error`./// A [`RawFd`](https://doc.rust-lang.org/std/os/unix/io/type.RawFd.html) wrapper./// See also `OwnedFd` if you need a wrapper that takes ownership of the file./// We wrap the `RawFd` type so that we can implement [`Serialize`] and [`Deserialize`] for it./// File descriptors are serialized in a special way and you need to use specific [serializer] and/// [deserializer] API when file descriptors are or could be involved./// [`Serialize`]: https://docs.serde.rs/serde/trait.Serialize.html/// [`Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html/// [deserializer]: fn.from_slice_fds.html/// [serializer]: fn.to_bytes_fds.htmlfd_impl/// An owned [`RawFd`](https://doc.rust-lang.org/std/os/unix/io/type.RawFd.html) wrapper./// See also [`Fd`]. This type owns the file and will close it on drop. On deserialize, it will/// duplicate the file descriptor.FramingOffsetSize// Used internally for GVariant encoding and decoding.// GVariant containers keeps framing offsets at the end and size of these offsets is dependent on// the size of the container (which includes offsets themselves).for_bare_containerfor_encoded_containerread_last_offset_from_bufferbump_upframing_offset_sizeframing_offset_size_bumpFramingOffsetsfrom_encoded_array// the size of the container (which includes offsets themselves.OwnedSignaturevalue_try_fromvalue_try_from_refvalue_try_from_ref_clonevalue_try_from_all// tuple conversions in `structure` module for avoiding code-duplication.// This would be great but somehow it conflicts with some blanket generic implementations from// core:// impl<'a, T> TryFrom<Value<'a>> for Option<T>// impl<'a, 'b, T> TryFrom<&'a Value<'b>> for Vec<T>// impl<'a, 'b, K, V, H> TryFrom<&'a Value<'v>> for HashMap<K, V, H>// and more..framing_offsets/// Our GVariant deserialization implementation./// On Windows, the function doesn't have `fds` argument.// All offsets (GVariant-specific)offsets_len// Length of all the offsets after the arraykey_offset_size// size of the framing offset of last dict-entry key read (GVariant-specific)element_end// size of the framing offsetsig_endvalue_startvalue_end/// Our serialization implementation./// Create a GVariant Serializer struct instance./// On Windows, the method doesn't have `fds` argument.serialize_maybe// All offsetskey_start// start of last dict-entry key written// Conversions from encodable types to `Value`encoding_contextdeserialize_valueowned_valueTypeDictto_bytes_for_signatureto_bytes_fdsSerializeValuebasic_type_test// Test through both generic and specific API (wrt byte order)value_testf64_type_testf64_type_test_as_valuef64_value_testi8_valuefd_valuei16_valueu32_valuei32_valuei64_valuef64_valuestr_valueobject_path_valueunit_fdsstruct_byte_arraystruct_refdict_valuevalue_valuestruct_with_hashmapissue_59recursion_limits// All fixed size types have the same encoding in DBus and GVariant formats.// NB: Value (i-e VARIANT type) isn't a fixed size type.// u64 is covered by `value_value` test below/// A helper type to wrap `Option<T>` (GVariant's Maybe type) in [`Value`]./// API is provided to convert from, and to `Option<T>`./// Get a reference to underlying value.just/// Create a new Just (Some) `Maybe`.just_full_signature/// Create a new Nothing (None) `Maybe`, given the signature of the type.nothing_full_signature/// Get the inner value as a concrete type/// Get the signature of `Maybe`./// Get the signature of the potential value in the `Maybe`.maybe_display_fmt// impl<'a, T> TryFrom<Maybe<'a>> for Option<T>/// String that identifies objects at a given destination on the D-Bus bus./// Mostly likely this is only useful in the D-Bus context./// use zvariant::ObjectPath;/// // Valid object paths/// let o = ObjectPath::try_from("/").unwrap();/// assert_eq!(o, "/");/// let o = ObjectPath::try_from("/Path/t0/0bject").unwrap();/// assert_eq!(o, "/Path/t0/0bject");/// let o = ObjectPath::try_from("/a/very/looooooooooooooooooooooooo0000o0ng/path").unwrap();/// assert_eq!(o, "/a/very/looooooooooooooooooooooooo0000o0ng/path");/// // Invalid object paths/// ObjectPath::try_from("").unwrap_err();/// ObjectPath::try_from("/double//slashes/").unwrap_err();/// ObjectPath::try_from(".").unwrap_err();/// ObjectPath::try_from("/end/with/slash/").unwrap_err();/// ObjectPath::try_from("/ha.d").unwrap_err();/// A borrowed clone (this never allocates, unlike clone)./// The object path as a string./// The object path as bytes./// Create a new `ObjectPath` from given bytes./// Since the passed bytes are not checked for correctness, prefer using the/// `TryFrom<&[u8]>` implementation./// See [`std::str::from_utf8_unchecked`]./// Create a new `ObjectPath` from the given string./// the object path's length./// if the object path is empty./// Try to create an ObjectPath from a string.ObjectPathVisitorensure_correct_object_path_str/// Owned [`ObjectPath`](struct.ObjectPath.html)owned_from_reader/// The none-equivalent value./// Type that uses a special value to be used as none./// See [`Optional`] documentation for the rationale for this trait's existence./// Since use of default values as none is typical, this trait is implemented for all types that/// implement [`Default`] for convenience. Unfortunately, this means you can not implement this/// trait manually for types that implement [`Default`]./// An optional value./// Since D-Bus doesn't have the concept of nullability, it uses a special value (typically the/// default value) as the null value. For example [this signal][ts] uses empty strings for null/// values. Serde has built-in support for `Option` but unfortunately that doesn't work for us./// Hence the need for this type./// The serialization and deserialization of `Optional` relies on [`NoneValue`] implementation of/// the underlying type./// use zvariant::{EncodingContext, Optional, from_slice, to_bytes};/// // `Null` case./// let ctxt = EncodingContext::<LE>::new_dbus(0);/// let s = Optional::<&str>::default();/// let encoded = to_bytes(ctxt, &s).unwrap();/// assert_eq!(encoded, &[0, 0, 0, 0, 0]);/// let s: Optional<&str> = from_slice(&encoded, ctxt).unwrap();/// assert_eq!(*s, None);/// // `Some` case./// let s = Optional::from(Some("hello"));/// assert_eq!(encoded.len(), 10);/// // The first byte is the length of the string in Little-Endian format./// assert_eq!(encoded[0], 5);/// assert_eq!(*s, Some("hello"));/// [ts]: https://dbus.freedesktop.org/doc/dbus-specification.html#bus-messages-name-owner-changed/// Owned [`Value`](enum.Value.html)ov_try_fromov_try_from_refmap_conversion// FIXME: Replace with a generic impl<T: TryFrom<Value>> TryFrom<OwnedValue> for T?// https://github.com/dbus2/zbus/issues/138DBusSerializerNullWriteSeek/// Calculate the serialized size of `T`./// This function will panic if the value to serialize contains file descriptors. Use/// [`serialized_size_fds`] if `T` (potentially) contains FDs./// use zvariant::{EncodingContext, serialized_size};/// let len = serialized_size(ctxt, "hello world").unwrap();/// assert_eq!(len, 16);/// let len = serialized_size(ctxt, &("hello world!", 42_u64)).unwrap();/// assert_eq!(len, 32);/// [`serialized_size_fds`]: fn.serialized_size_fds.htmlserialized_size_fds/// Calculate the serialized size of `T` that (potentially) contains FDs./// Returns the serialized size of `T` and the number of FDs./// Serialize `T` to the given `writer`./// This function returns the number of bytes written to the given `writer`./// [`to_writer_fds`] if you'd want to potentially pass FDs./// use zvariant::{EncodingContext, from_slice, to_writer};/// let mut cursor = std::io::Cursor::new(vec![]);/// to_writer(&mut cursor, ctxt, &42u32).unwrap();/// let value: u32 = from_slice(cursor.get_ref(), ctxt).unwrap();/// assert_eq!(value, 42);/// [`to_writer_fds`]: fn.to_writer_fds.htmlto_writer_fds/// Serialize `T` that (potentially) contains FDs, to the given `writer`./// This function returns the number of bytes written to the given `writer` and the file descriptor/// vector, which needs to be transferred via an out-of-band platform specific mechanism./// Serialize `T` as a byte vector./// See [`from_slice`] documentation for an example of how to use this function./// [`to_bytes_fds`] if you'd want to potentially pass FDs./// [`to_bytes_fds`]: fn.to_bytes_fds.html/// [`from_slice`]: fn.from_slice.html#examples/// Serialize `T` that (potentially) contains FDs, as a byte vector./// The returned file descriptor needs to be transferred via an out-of-band platform specific/// mechanism.to_writer_for_signature/// Serialize `T` that has the given signature, to the given `writer`./// Use this function instead of [`to_writer`] if the value being serialized does not implement/// [`Type`]./// [`to_writer`]: fn.to_writer.htmlto_writer_fds_for_signature/// Serialize `T` that (potentially) contains FDs and has the given signature, to the given/// `writer`./// Use this function instead of [`to_writer_fds`] if the value being serialized does not implement/// Serialize `T` that has the given signature, to a new byte vector./// Use this function instead of [`to_bytes`] if the value being serialized does not implement/// [`Type`]. See [`from_slice_for_signature`] documentation for an example of how to use this/// [`to_bytes_fds_for_signature`] if you'd want to potentially pass FDs./// [`to_bytes`]: fn.to_bytes.html/// [`from_slice_for_signature`]: fn.from_slice_for_signature.html#examplesto_bytes_fds_for_signature/// Serialize `T` that (potentially) contains FDs and has the given signature, to a new byte vector./// Use this function instead of [`to_bytes_fds`] if the value being serialized does not implement/// Please note that the serialized bytes only contain the indices of the file descriptors from the/// returned file descriptor vector, which needs to be transferred via an out-of-band platform/// specific mechanism.value_sign/// Context for all our serializers and provides shared functionality./// Using this serializer involves an redirection to the actual serializer. It's best to use the/// serialization functions, e.g [`to_bytes`] or specific serializers, [`dbus::Serializer`] or/// [`zvariant::Serializer`]./// Create a Serializer struct instance./// Unwrap the `Writer` reference from the `Serializer`.add_fdprep_serialize_basicprep_serialize_enum_variant/// This starts the enum serialization./// It's up to the caller to do the rest: serialize the variant payload and skip the `)./// Write `buf` and increment internal bytes written counter.serialize_method/// A wrapper to serialize `T: Type + Serialize` as a value./// # use zvariant::{to_bytes, EncodingContext, SerializeValue};/// let _ = to_bytes(ctxt, &SerializeValue(&[0, 1, 2])).unwrap();// A data type similar to Cow and [`bytes::Bytes`] but unlike the former won't allow us to only keep// the owned bytes in Arc and latter doesn't have a notion of borrowed data and would require API// breakage.// [`bytes::Bytes`]: https://docs.rs/bytes/0.5.6/bytes/struct.Bytes.html/// String that [identifies] the type of an encoded value./// use zvariant::Signature;/// // Valid signatures/// let s = Signature::try_from("").unwrap();/// let s = Signature::try_from("y").unwrap();/// assert_eq!(s, "y");/// let s = Signature::try_from("xs").unwrap();/// assert_eq!(s, "xs");/// let s = Signature::try_from("(ysa{sd})").unwrap();/// assert_eq!(s, "(ysa{sd})");/// let s = Signature::try_from("a{sd}").unwrap();/// assert_eq!(s, "a{sd}");/// // Invalid signatures/// Signature::try_from("z").unwrap_err();/// Signature::try_from("(xs").unwrap_err();/// Signature::try_from("xs)").unwrap_err();/// Signature::try_from("s/").unwrap_err();/// Signature::try_from("a").unwrap_err();/// Signature::try_from("a{yz}").unwrap_err();/// This is implemented so that multiple instances can share the same underlying signature string./// Use [`slice`] method to create new signature that represents a portion of a signature/// [identifies]: https://dbus.freedesktop.org/doc/dbus-specification.html#type-system/// [`slice`]: #method.slice/// The signature as a string./// The signature bytes./// Create a new Signature from given bytes./// Since the passed bytes are not checked for correctness, it's provided for ease of/// `Type` implementations./// This method is unsafe as it allows creating a `str` that is not valid UTF-8.from_static_bytes_unchecked/// Same as `from_bytes_unchecked`, except it takes a static reference./// Same as `from_bytes_unchecked`, except it takes a string reference./// Same as `from_str_unchecked`, except it takes a static string reference./// Same as `from_static_str_unchecked`, except it checks validity of the signature./// It's recommended to use this method instead of `TryFrom<&str>` implementation for/// `&'static str`. The former will ensure that [`Signature::to_owned`] and/// [`Signature::into_owned`] do not clone the underlying bytes.from_static_bytes/// Same as `from_static_bytes_unchecked`, except it checks validity of the signature./// It's recommended to use this method instead of the `TryFrom<&[u8]>` implementation for/// `&'static [u8]`. The former will ensure that [`Signature::to_owned`] and/// the signature's length./// if the signature is empty./// Returns a slice of `self` for the provided range./// Requires that begin <= end and end <= self.len(), otherwise slicing will panic./// Try to create a Signature from a string.SignatureVisitorensure_correct_signature_str/// Owned [`Signature`](struct.Signature.html)signature_slicingSTRUCT_SIG_END_CHARARRAY_SIGNATURE_CHARDICT_ENTRY_SIG_END_CHARDICT_ENTRY_SIG_START_CHARSTRUCT_SIG_START_CHARVARIANT_SIGNATURE_CHARskip_charparse_next_signature/// Get the next signature and increment the position.next_signature/// Get the next signature but don't increment the position.next_single_child_type_container_signaturenext_array_signaturenext_structure_signaturenext_dict_entry_signaturesignature_slice/// A string wrapper./// This is used for keeping strings in a [`Value`]. API is provided to convert from, and to a/// [`&str`] and [`String`]./// [`Value`]: enum.Value.html#variant.Str/// [`&str`]: https://doc.rust-lang.org/std/str/index.html/// The underlying string./// An owned string without allocationstest_orderingStructureBuilder/// Use this to efficiently build a [`Structure`]./// [`Structure`]: struct.Structure.html/// Create a new `StructureBuilder`./// Same as `StructureBuilder::default()`.add_field/// Append `field` to `self`./// This method returns `Self` so that you can use the builder pattern to create a complexappend_field/// Identical to `add_field`, except the field must be in the form of a `Value`.push_field/// Identical to `add_field`, except it makes changes in-place./// Identical to `append_field`, except it makes changes in-place./// Build the `Structure`.build_with_signature/// Same as `build` except Signature is provided.StructureSeed/// Use this to deserialize a [`Structure`]./// Create a new `StructureSeed`/// The given signature must be a valid structure signature./// A helper type to wrap structs in [`Value`]./// API is provided to convert from, and to tuples./// Get a reference to all the fields of `self`./// Converts `self` to a `Vec` containing all its fields./// Get the signature of this `Structure`.structure_display_fmtcreate_signature_from_fields/// Get the signature for the implementing type./// use zvariant::Type;/// assert_eq!(u32::signature(), "u");/// assert_eq!(String::signature(), "s");/// assert_eq!(<(u32, &str, u64)>::signature(), "(ust)");/// assert_eq!(<(u32, &str, &[u64])>::signature(), "(usat)");/// assert_eq!(<HashMap<u8, &str>>::signature(), "a{ys}");/// Trait implemented by all serializable types./// This very simple trait provides the signature for the implementing type. Since the [D-Bus type/// system] relies on these signatures, our [serialization and deserialization] API requires this/// trait in addition to [`Serialize`] and [`Deserialize`], respectively./// Implementation is provided for all the [basic types] and blanket implementations for common/// container types, such as, arrays, slices, tuples, [`Vec`] and [`HashMap`]. For easy/// implementation for custom types, use `Type` derive macro from [zvariant_derive] crate./// If your type's signature cannot be determined statically, you should implement the/// [DynamicType] trait instead, which is otherwise automatically implemented if you implement this/// [D-Bus type system]: https://dbus.freedesktop.org/doc/dbus-specification.html#type-system/// [basic types]: trait.Basic.html/// [zvariant_derive]: https://docs.rs/zvariant_derive/2.10.0/zvariant_derive//// See [Type::signature] for details./// Types with dynamic signatures./// Prefer implementing [Type] if possible, but if the actual signature of your type cannot be/// determined until runtime, you can implement this type to support serialization.  You should/// also implement [DynamicDeserialize] for deserialization./// A [DeserializeSeed] implementation for this type./// Get a deserializer compatible with this signature./// Types that deserialize based on dynamic signatures./// Prefer implementing [Type] and [Deserialize] if possible, but if the actual signature of your/// type cannot be determined until runtime, you should implement this type to support/// deserialization given a signature.// Empty type deserves empty signature// Arrays are serialized as tuples/structs by Serde so we treat them as such too even though// it's very strange. Slices and arrayvec::ArrayVec can be used anyway so I guess it's no big// deal.// BitFlagsstatic_str_type// TODO: Blanket implementation for more types: https://github.com/serde-rs/serde/blob/master/serde/src/ser/impls.rs/// The prefix of ARRAY type signature, as a character. Provided for manual signature creation.ARRAY_SIGNATURE_STR/// The prefix of ARRAY type signature, as a string. Provided for manual signature creation.ARRAY_ALIGNMENT_DBUS/// The opening character of STRUCT type signature. Provided for manual signature creation./// The closing character of STRUCT type signature. Provided for manual signature creation.STRUCT_SIG_START_STR/// The opening character of STRUCT type signature, as a string. Provided for manual signatureSTRUCT_SIG_END_STR/// The closing character of STRUCT type signature, as a string. Provided for manual signatureSTRUCT_ALIGNMENT_DBUS/// The opening character of DICT_ENTRY type signature. Provided for manual signature creation./// The closing character of DICT_ENTRY type signature. Provided for manual signature creation.DICT_ENTRY_SIG_START_STR/// The opening character of DICT_ENTRY type signature, as a string. Provided for manual signatureDICT_ENTRY_SIG_END_STR/// The closing character of DICT_ENTRY type signature, as a string. Provided for manual signatureDICT_ENTRY_ALIGNMENT_DBUS/// The VARIANT type signature. Provided for manual signature creation.VARIANT_SIGNATURE_STR/// The VARIANT type signature, as a string. Provided for manual signature creation.VARIANT_ALIGNMENT_DBUSusize_to_u32usize_to_u8f64_to_f32alignment_for_signature// `signature` must be **one** complete and correct signature. Expect panics otherwise!signature_string// Given an &str, create an owned (String-based) Signature w/ appropriate capacitycheck_child_value_signaturealignment_for_single_child_type_signaturealignment_for_array_signaturealignment_for_struct_signaturealignment_for_dict_entry_signature/// Slice the given slice of bytes safely and return an error if the slice is too small.// Simple types// Container types/// A generic container, in the form of an enum that holds exactly one value of any of the other/// Note that this type corresponds to the `VARIANT` data type defined by the [D-Bus specification]/// and as such, its encoding is not the same as that of the enclosed value./// use zvariant::{from_slice, to_bytes, EncodingContext, Value};/// // Create a Value from an i16/// let v = Value::new(i16::max_value());/// // Encode it/// let encoding = to_bytes(ctxt, &v).unwrap();/// // Decode it back/// let v: Value = from_slice(&encoding, ctxt).unwrap();/// // Check everything is as expected/// assert_eq!(i16::try_from(&v).unwrap(), i16::max_value());/// Now let's try a more complicated example:/// use zvariant::{from_slice, to_bytes, EncodingContext};/// use zvariant::{Structure, Value, Str};/// // Create a Value from a tuple this time/// let v = Value::new((i16::max_value(), "hello", true));/// // Same drill as previous example/// let s = Structure::try_from(v).unwrap();///     <(i16, Str, bool)>::try_from(s).unwrap(),///     (i16::max_value(), Str::from("hello"), true),/// [D-Bus specification]: https://dbus.freedesktop.org/doc/dbus-specification.html#container-types/// Make a [`Value`] for a given value./// In general, you can use [`Into`] trait on basic types, except/// when you explicitly need to wrap [`Value`] itself, in which/// case this constructor comes handy./// use zvariant::Value;/// let s = Value::new("hello");/// let u: Value = 51.into();/// assert_ne!(s, u);/// [`Into`]: https://doc.rust-lang.org/std/convert/trait.Into.html/// Create an owned version of `self`./// Ideally, we should implement [`std::borrow::ToOwned`] trait for `Value`, but that's/// implemented generically for us through `impl<T: Clone> ToOwned for T` and it's not what we/// need/want./// Get the signature of the enclosed value.serialize_value_as_struct_fieldserialize_value_as_tuple_struct_fieldserialize_value_as_seq_element// Really crappy that we need to do this separately for struct and seq cases. :(/// Try to get the underlying type `T`./// Note that [`TryFrom<Value>`] is implemented for various types, and it's usually best to use/// that instead. However, in generic code where you also want to unwrap [`Value::Value`],/// you should use this function (because [`TryFrom<Value>`] can not be implemented for `Value`/// itself as [`From<Value>`] is implicitly implemented for `Value`)./// use zvariant::{Result, Value};/// fn value_vec_to_type_vec<'a, T>(values: Vec<Value<'a>>) -> Result<Vec<T>>///     T: TryFrom<Value<'a>>,///     let mut res = vec![];///     for value in values.into_iter() {///         res.push(value.downcast().unwrap());///     Ok(res)/// // Let's try u32 values first/// let v = vec![Value::U32(42), Value::U32(43)];/// let v = value_vec_to_type_vec::<u32>(v).unwrap();/// assert_eq!(v[0], 42);/// assert_eq!(v[1], 43);/// // Now try Value values/// let v = vec![Value::new(Value::U32(42)), Value::new(Value::U32(43))];/// let v = value_vec_to_type_vec::<Value>(v).unwrap();/// assert_eq!(v[0], Value::U32(42));/// assert_eq!(v[1], Value::U32(43));/// [`Value::Value`]: enum.Value.html#variant.Value/// [`TryFrom<Value>`]: https://doc.rust-lang.org/std/convert/trait.TryFrom.html/// [`From<Value>`]: https://doc.rust-lang.org/std/convert/trait.From.html/// Try to get a reference to the underlying type `T`./// Same as [`downcast`] except it doesn't consume `self` and get a reference to the underlying/// fn value_vec_to_type_vec<'a, T>(values: &'a Vec<Value<'a>>) -> Result<Vec<&'a T>>///     &'a T: TryFrom<&'a Value<'a>>,///         res.push(value.downcast_ref().unwrap());/// let v = value_vec_to_type_vec::<u32>(&v).unwrap();/// assert_eq!(*v[0], 42);/// assert_eq!(*v[1], 43);/// let v = value_vec_to_type_vec::<Value>(&v).unwrap();/// assert_eq!(*v[0], Value::U32(42));/// assert_eq!(*v[1], Value::U32(43));/// [`downcast`]: enum.Value.html#method.downcast/// Implemented based on https://gitlab.gnome.org/GNOME/glib/-/blob/e1d47f0b0d0893ac9171e24cc7bf635495376546/glib/gvariant.c#L2213ValueSeedvalue_seed_basic_methodvalue_seed_str_methodvalue_display// Note that the Visitor implementations don't check for validity of the// signature. That's left to the Deserialize implementation of Signature// itself.expand_type_derivedict_name_for_fieldexpand_serialize_deriveexpand_deserialize_derivetype_macro_derive/// Derive macro to add [`Type`] implementation to structs and enums./// For structs it works just like serde's [`Serialize`] and [`Deserialize`] macros:/// use zvariant::{EncodingContext, from_slice, to_bytes, Type};/// #[derive(Deserialize, Serialize, Type, PartialEq, Debug)]/// struct Struct<'s> {///     field1: u16,///     field2: i64,///     field3: &'s str,/// assert_eq!(Struct::signature(), "(qxs)");/// let s = Struct {///     field1: 42,///     field2: i64::max_value(),///     field3: "hello",/// let decoded: Struct = from_slice(&encoded, ctxt).unwrap();/// assert_eq!(decoded, s);/// Same with enum, except that all variants of the enum must have the same number and types of/// fields (if any). If you want the encoding size of the (unit-type) enum to be dictated by/// `repr` attribute (like in the example below), you'll also need [serde_repr] crate./// use serde_repr::{Deserialize_repr, Serialize_repr};/// #[derive(Deserialize_repr, Serialize_repr, Type, Debug, PartialEq)]/// enum Enum {/// assert_eq!(Enum::signature(), u8::signature());/// let encoded = to_bytes(ctxt, &Enum::Variant2).unwrap();/// let decoded: Enum = from_slice(&encoded, ctxt).unwrap();/// assert_eq!(decoded, Enum::Variant2);/// #[repr(i64)]/// #[derive(Deserialize_repr, Serialize_repr, Type)]/// enum Enum2 {/// assert_eq!(Enum2::signature(), i64::signature());/// // w/o repr attribute, u32 representation is chosen/// #[derive(Deserialize, Serialize, Type)]/// enum NoReprEnum {/// assert_eq!(NoReprEnum::signature(), u32::signature());/// // Not-unit enums are represented as a structure, with the first field being a u32 denoting the/// // variant and the second as the actual value./// enum NewType {///     Variant1(f64),///     Variant2(f64),/// assert_eq!(NewType::signature(), "(ud)");/// enum StructFields {///     Variant1(u16, i64, &'static str),///     Variant2 { field1: u16, field2: i64, field3: &'static str },/// assert_eq!(StructFields::signature(), "(u(qxs))");/// # Custom signatures/// There are times when you'd find yourself wanting to specify a hardcoded signature yourself for/// the type. The `signature` attribute exists for this purpose. A typical use case is when you'd/// need to encode your type as a dictionary (signature `a{sv}`) type. For convenience, `dict` is/// an alias for `a{sv}`. Here is an example:/// use zvariant::{SerializeDict, DeserializeDict, EncodingContext, from_slice, to_bytes, Type};/// #[derive(DeserializeDict, SerializeDict, Type, PartialEq, Debug)]/// // `#[zvariant(signature = "a{sv}")]` would be the same./// #[zvariant(signature = "dict")]///     field3: String,/// assert_eq!(Struct::signature(), "a{sv}");///     field3: "hello".to_string(),/// Another common use for custom signatures is (de)serialization of unit enums as strings:/// #[zvariant(signature = "s")]/// enum StrEnum {/// assert_eq!(StrEnum::signature(), "s");/// let encoded = to_bytes(ctxt, &StrEnum::Variant2).unwrap();/// assert_eq!(encoded.len(), 13);/// let decoded: StrEnum = from_slice(&encoded, ctxt).unwrap();/// assert_eq!(decoded, StrEnum::Variant2);/// [`Type`]: https://docs.rs/zvariant/2.10.0/zvariant/trait.Type.html/// [serde_repr]: https://crates.io/crates/serde_reprtype_dict_macro_derive/// Derive macro to add [`Type`] implementation to structs serialized as `a{sv}` type./// [`Type`]: ../zvariant/trait.Type.htmlserialize_dict_macro_derive/// Adds [`Serialize`] implementation to structs to be serialized as `a{sv}` type./// This macro serializes the deriving struct as a D-Bus dictionary type, where keys are strings and/// values are generic values. Such dictionary types are very commonly used with/// [D-Bus](https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)/// and GVariant./// For structs it works just like serde's [`Serialize`] macros:/// use zvariant::{SerializeDict, Type};/// #[derive(SerializeDict, Type)]/// #[zvariant(signature = "a{sv}")]///     #[zvariant(rename = "another-name")]///     optional_field: Option<String>,/// The serialized D-Bus version of `Struct {42, 77, None}`/// will be `{"field1": Value::U16(42), "another-name": Value::I64(77)}`./// # Auto renaming fields/// The macro supports specifying a Serde-like `#[zvariant(rename_all = "case")]` attribute on/// structures. The attribute allows to rename all the fields from snake case to another case/// automatically:/// #[zvariant(signature = "a{sv}", rename_all = "PascalCase")]/// It's still possible to specify custom names for individual fields using the/// `#[zvariant(rename = "another-name")]` attribute even when the `rename_all` attribute is/// Currently the macro supports the following values for `case`:/// * `"lowercase"`/// * `"UPPERCASE"`/// * `"PascalCase"`/// * `"camelCase"`/// * `"snake_case"`deserialize_dict_macro_derive/// Adds [`Deserialize`] implementation to structs to be deserialized from `a{sv}` type./// This macro deserializes a D-Bus dictionary type as a struct, where keys are strings and values/// are generic values. Such dictionary types are very commonly used with/// For structs it works just like serde's [`Deserialize`] macros:/// use zvariant::{DeserializeDict, Type};/// #[derive(DeserializeDict, Type)]/// ##[allow(unused)]/// The deserialized D-Bus dictionary `{"field1": Value::U16(42), "another-name": Value::I64(77)}`/// will be `Struct {42, 77, None}`.value_macro_derive/// Implements conversions for your type to/from [`Value`]./// Implements `TryFrom<Value>` and `Into<Value>` for your type./// Simple owned strutures:/// use zvariant::{OwnedObjectPath, OwnedValue, Value};/// #[derive(Clone, Value, OwnedValue)]/// struct OwnedStruct {///     owned_str: String,///     owned_path: OwnedObjectPath,/// let s = OwnedStruct {///     owned_str: String::from("hi"),///     owned_path: OwnedObjectPath::try_from("/blah").unwrap(),/// let value = Value::from(s.clone());/// let _ = OwnedStruct::try_from(value).unwrap();/// let value = OwnedValue::from(s);/// let s = OwnedStruct::try_from(value).unwrap();/// assert_eq!(s.owned_str, "hi");/// assert_eq!(s.owned_path.as_str(), "/blah");/// Now for the more exciting case of unowned structures:/// use zvariant::{ObjectPath, Str};/// # use zvariant::{OwnedValue, Value};/// struct UnownedStruct<'a> {///     s: Str<'a>,///     path: ObjectPath<'a>,/// let hi = String::from("hi");/// let s = UnownedStruct {///     s: Str::from(&hi),///     path: ObjectPath::try_from("/blah").unwrap(),/// let s = UnownedStruct::try_from(value).unwrap();/// assert_eq!(s.s, "hi");/// assert_eq!(s.path, "/blah");/// Generic structures also supported:/// # use zvariant::{OwnedObjectPath, OwnedValue, Value};/// struct GenericStruct<S, O> {///     field1: S,///     field2: O,/// let s = GenericStruct {///     field1: String::from("hi"),///     field2: OwnedObjectPath::try_from("/blah").unwrap(),/// let _ = GenericStruct::<String, OwnedObjectPath>::try_from(value).unwrap();/// let s = GenericStruct::<String, OwnedObjectPath>::try_from(value).unwrap();/// assert_eq!(s.field1, "hi");/// assert_eq!(s.field2.as_str(), "/blah");/// Enums also supported but currently only simple ones w/ an integer representation:/// #[derive(Debug, PartialEq, Value, OwnedValue)]/// let value = Value::from(Enum::Variant1);/// let e = Enum::try_from(value).unwrap();/// assert_eq!(e, Enum::Variant1);/// let value = OwnedValue::from(Enum::Variant2);/// assert_eq!(e, Enum::Variant2);/// # Dictionary encoding/// For treating your type as a dictionary, you can use the `signature = "dict"` attribute. See/// [`Type`] for more details and an example use. Please note that this macro can only handle/// `dict` or `a{sv}` values. All other values will be ignored./// [`Value`]: https://docs.rs/zvariant/2.10.0/zvariant/enum.Value.html/// [`Type`]: derive.Type.html#custom-typesowned_value_macro_derive/// Implements conversions for your type to/from [`OwnedValue`]./// Implements `TryFrom<OwnedValue>` and `Into<OwnedValue>` for your type./// See [`Value`] documentation for examples./// [`OwnedValue`]: https://docs.rs/zvariant/2.10.0/zvariant/struct.OwnedValue.htmlsignature_for_structimpl_unit_structimpl_empty_structsignature_for_variantzvariant_pathr" Attributes defined on structures."rename_allr" Attributes defined on fields."FieldAttributespascal_or_camel_case/// Convert to pascal or camel case, assuming snake case./// If `s` is already in pascal or camel case, should yield the same result./// Convert to snake case, assuming pascal case./// If `s` is already in snake case, should yield the same result.//! Contains utilities used to convert strings between different cases.//! Various utilities used by the `zvariant` crate and others.get_meta_valuematch_attribute_with_str_value/// Compares `ident` and `attr` and in case they match ensures `value` is `Some` and contains a/// [`struct@LitStr`]. Returns `true` in case `ident` and `attr` match, otherwise false./// Returns an error in case `ident` and `attr` match but the value is not `Some` or is not a/// [`struct@LitStr`].match_attribute_with_bool_value/// [`struct@LitBool`]. Returns `true` in case `ident` and `attr` match, otherwise false./// [`struct@LitBool`].match_attribute_with_str_list_valuematch_attribute_without_value/// Compares `ident` and `attr` and in case they match ensures `value` is `None`. Returns `true` in/// case `ident` and `attr` match, otherwise false./// Returns an error in case `ident` and `attr` match but the value is not `None`.iter_meta_lists/// Returns an iterator over the contents of all [`MetaList`]s with the specified identifier in an/// array of [`Attribute`]s./// Generates one or more structures used for parsing attributes in proc macros./// Generated structures have one static method called parse that accepts a slice of [`Attribute`]s./// The method finds attributes that contain meta lists (look like `#[your_custom_ident(...)]`) and/// fills a newly allocated structure with values of the attributes if any./// The expected input looks as follows:/// # use zvariant_utils::def_attrs;/// def_attrs! {///     crate zvariant;///     /// A comment.///     pub StructAttributes("struct") { foo str, bar str, baz none };///     #[derive(Hash)]///     FieldAttributes("field") { field_attr bool };/// Here we see multiple entries: an entry for an attributes group called `StructAttributes` and/// another one for `FieldAttributes`. The former has three defined attributes: `foo`, `bar` and/// `baz`. The generated structures will look like this in that case:/// /// A comment./// #[derive(Default, Clone, Debug)]/// pub struct StructAttributes {///     foo: Option<String>,///     baz: bool,/// struct FieldAttributes {///     field_attr: Option<bool>,/// `foo` and `bar` attributes got translated to fields with `Option<String>` type which contain the/// value of the attribute when one is specified. They are marked with `str` keyword which stands/// for string literals. The `baz` attribute, on the other hand, has `bool` type because it's an/// attribute without value marked by the `none` keyword./// Currently the following literals are supported:/// * `str` - string literals;/// * `bool` - boolean literals;/// * `[str]` - lists of string literals (`#[macro_name(foo("bar", "baz"))]`);/// * `none` - no literal at all, the attribute is specified alone./// The strings between braces are embedded into error messages produced when an attribute defined/// for one attribute group is used on another group where it is not defined. For example, if the/// `field_attr` attribute was encountered by the generated `StructAttributes::parse` method, the/// error message would say that it "is not allowed on structs"./// # Nested attribute lists/// It is possible to create nested lists for specific attributes. This is done as follows:///     pub OuterAttributes("outer") {///         simple_attr bool,///         nested_attr {///             /// An example of nested attributes.///             pub InnerAttributes("inner") {///                 inner_attr str/// The syntax for inner attributes is the same as for the outer attributes, but you can specify/// only one inner attribute per outer attribute./// # Calling the macro multiple times/// The macro generates an array called `ALLOWED_ATTRS` that contains a list of allowed attributes./// Calling the macro twice in the same scope will cause a name alias and thus will fail to compile./// You need to place each macro invocation into a module in that case./// The generated parse method checks for some error conditions:/// 1. Unknown attributes. When multiple attribute groups are defined in the same macro invocation,/// one gets a different error message when providing an attribute from a different attribute group./// 2. Duplicate attributes./// 3. Missing attribute value or present attribute value when none is expected./// 4. Invalid literal type for attributes with values.ty_is_option/// Checks if a [`Type`]'s identifier is "Option".rustc_allocatorrustc_nounwindrustc_std_internal_symbol"__rust_alloc_zeroed"rustc_allocator_zeroed_variant__rust_alloc// These are the magic symbols to call the global allocator. rustc generates// them to call the global allocator if there is a `#[global_allocator]` attribute// (the code expanding that attribute macro generates those functions), or to call// the default implementations in std (`__rdl_alloc` etc. in `library/std/src/alloc.rs`)rustc_deallocator__rust_deallocrustc_reallocator__rust_reallocrustc_allocator_zeroed__rust_alloc_zeroed__rust_no_alloc_shim_is_unstable_v2"global_alloc_ty"/// The global memory allocator./// This type implements the [`Allocator`] trait by forwarding calls/// to the allocator registered with the `#[global_allocator]` attribute/// if there is one, or the `std` crate’s default./// Note: while this type is unstable, the functionality it provides can be/// accessed through the [free functions in `alloc`](self#functions).// the compiler needs to know when a Box uses the global allocator vs a custom one"losing the pointer will leak memory"/// Allocates memory with the global allocator./// This function forwards calls to the [`GlobalAlloc::alloc`] method/// of the allocator registered with the `#[global_allocator]` attribute/// This function is expected to be deprecated in favor of the `allocate` method/// of the [`Global`] type when it and the [`Allocator`] trait become stable./// See [`GlobalAlloc::alloc`]./// use std::alloc::{alloc, dealloc, handle_alloc_error, Layout};///     let layout = Layout::new::<u16>();///     let ptr = alloc(layout);///     if ptr.is_null() {///         handle_alloc_error(layout);///     *(ptr as *mut u16) = 42;///     assert_eq!(*(ptr as *mut u16), 42);///     dealloc(ptr, layout);/// Deallocates memory with the global allocator./// This function forwards calls to the [`GlobalAlloc::dealloc`] method/// This function is expected to be deprecated in favor of the `deallocate` method/// See [`GlobalAlloc::dealloc`]./// Reallocates memory with the global allocator./// This function forwards calls to the [`GlobalAlloc::realloc`] method/// This function is expected to be deprecated in favor of the `grow` and `shrink` methods/// See [`GlobalAlloc::realloc`]./// Allocates zero-initialized memory with the global allocator./// This function forwards calls to the [`GlobalAlloc::alloc_zeroed`] method/// This function is expected to be deprecated in favor of the `allocate_zeroed` method/// See [`GlobalAlloc::alloc_zeroed`]./// use std::alloc::{alloc_zeroed, dealloc, handle_alloc_error, Layout};///     let ptr = alloc_zeroed(layout);///     assert_eq!(*(ptr as *mut u16), 0);grow_impl// SAFETY: Same as `Allocator::grow`allocate_zeroedgrow_zeroed"exchange_malloc"exchange_malloc/// The allocator for `Box`.__rust_alloc_error_handler// This is the magic symbol to call the global alloc error handler. rustc generates// it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the// default implementations below (`__rdl_alloc_error_handler`) otherwise.rustc_const_unstable/// Signals a memory allocation error./// Callers of memory allocation APIs wishing to cease execution/// in response to an allocation error are encouraged to call this function,/// rather than directly invoking [`panic!`] or similar./// This function is guaranteed to diverge (not return normally with a value), but depending on/// global configuration, it may either panic (resulting in unwinding or aborting as per/// configuration for all panics), or abort the process (with no unwinding)./// The default behavior is:///  * If the binary links against `std` (typically the case), then///   print a message to standard error and abort the process.///   This behavior can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`].///   Future versions of Rust may panic by default instead./// * If the binary does not link against `std` (all of its crates are marked///   [`#![no_std]`][no_std]), then call [`panic!`] with a message.///   [The panic handler] applies as to any panic./// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html/// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html/// [The panic handler]: https://doc.rust-lang.org/reference/runtime.html#the-panic_handler-attribute/// [no_std]: https://doc.rust-lang.org/reference/names/preludes.html#the-no_std-attribute__rdl_alloc_error_handler// called via generated `__rust_alloc_error_handler` if there is no// `#[alloc_error_handler]`.__alloc_error_handler//! Memory allocation APIs// # Allocation error handlerDerefPure// FIXME(inference): const bounds removed due to inference regressions found by crater;//   see https://github.com/rust-lang/rust/issues/147964// #[rustc_const_unstable(feature = "const_convert", issue = "143773")]//     B::Owned: [const] Borrow<B>,"to_owned_method"rustc_diagnostic_item/// Creates owned data from borrowed data, usually by cloning./// let s: &str = "a";/// let ss: String = s.to_owned();/// let v: &[i32] = &[1, 2];/// let vv: Vec<i32> = v.to_owned();/// Uses borrowed data to replace owned data, usually by cloning./// This is borrow-generalized version of [`Clone::clone_from`]./// let mut s: String = String::new();/// "hello".clone_into(&mut s);/// let mut v: Vec<i32> = Vec::new();/// [1, 2][..].clone_into(&mut v);"ToOwned"/// A generalization of `Clone` to borrowed data./// Some types make it possible to go from borrowed to owned, usually by/// implementing the `Clone` trait. But `Clone` works only for going from `&T`/// to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data/// from any borrow of a given type."Cow"/// Borrowed data./// Owned data./// A clone-on-write smart pointer./// The type `Cow` is a smart pointer providing clone-on-write functionality: it/// can enclose and provide immutable access to borrowed data, and clone the/// data lazily when mutation or ownership is required. The type is designed to/// work with general borrowed data via the `Borrow` trait./// `Cow` implements `Deref`, which means that you can call/// non-mutating methods directly on the data it encloses. If mutation/// is desired, `to_mut` will obtain a mutable reference to an owned/// value, cloning if necessary./// If you need reference-counting pointers, note that/// [`Rc::make_mut`][crate::rc::Rc::make_mut] and/// [`Arc::make_mut`][crate::sync::Arc::make_mut] can provide clone-on-write/// functionality as well./// fn abs_all(input: &mut Cow<'_, [i32]>) {///     for i in 0..input.len() {///         let v = input[i];///         if v < 0 {///             // Clones into a vector if not already owned.///             input.to_mut()[i] = -v;/// // No clone occurs because `input` doesn't need to be mutated./// let slice = [0, 1, 2];/// let mut input = Cow::from(&slice[..]);/// abs_all(&mut input);/// // Clone occurs because `input` needs to be mutated./// let slice = [-1, 0, 1];/// // No clone occurs because `input` is already owned./// let mut input = Cow::from(vec![-1, 0, 1]);/// Another example showing how to keep `Cow` in a struct:/// struct Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {///     values: Cow<'a, [X]>,/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {///     fn new(v: Cow<'a, [X]>) -> Self {///         Items { values: v }/// // Creates a container from borrowed values of a slice/// let readonly = [1, 2];/// let borrowed = Items::new((&readonly[..]).into());/// match borrowed {///     Items { values: Cow::Borrowed(b) } => println!("borrowed {b:?}"),///     _ => panic!("expect borrowed value"),/// let mut clone_on_write = borrowed;/// // Mutates the data from slice into owned vec and pushes a new value on top/// clone_on_write.values.to_mut().push(3);/// println!("clone_on_write = {:?}", clone_on_write.values);/// // The data was mutated. Let's check it out./// match clone_on_write {///     Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"),///     _ => panic!("expect owned data"),/// Returns true if the data is borrowed, i.e. if `to_mut` would require additional work./// it as `Cow::is_borrowed(&c)` instead of `c.is_borrowed()`. This is so/// that there is no conflict with a method on the inner type./// #![feature(cow_is_borrowed)]/// let cow = Cow::Borrowed("moo");/// assert!(Cow::is_borrowed(&cow));/// let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string());/// assert!(!Cow::is_borrowed(&bull));/// Returns true if the data is owned, i.e. if `to_mut` would be a no-op./// it as `Cow::is_owned(&c)` instead of `c.is_owned()`. This is so that/// let cow: Cow<'_, str> = Cow::Owned("moo".to_string());/// assert!(Cow::is_owned(&cow));/// let bull = Cow::Borrowed("...moo?");/// assert!(!Cow::is_owned(&bull));/// Acquires a mutable reference to the owned form of the data./// Clones the data if it is not already owned./// let mut cow = Cow::Borrowed("foo");/// cow.to_mut().make_ascii_uppercase();///   cow,///   Cow::Owned(String::from("FOO")) as Cow<'_, str>/// Extracts the owned data./// Calling `into_owned` on a `Cow::Borrowed` returns a clone of the borrowed data:/// let s = "Hello world!";/// let cow = Cow::Borrowed(s);///   cow.into_owned(),///   String::from(s)/// Calling `into_owned` on a `Cow::Owned` returns the owned data. The data is moved out of the/// `Cow` without being cloned./// let cow: Cow<'_, str> = Cow::Owned(String::from(s));// `Cow<'_, T>` can only implement `DerefPure` if `<T::Owned as Borrow<T>>` (and `BorrowMut<T>`) is trusted.// For now, we restrict `DerefPure for Cow<T>` to `T: Sized` (`T as Borrow<T>` is trusted),// `str` (`String as Borrow<str>` is trusted) and `[T]` (`Vec<T> as Borrow<[T]>` is trusted).// In the future, a `BorrowPure<T>` trait analogous to `DerefPure` might generalize this./// Creates an owned Cow<'a, B> with the default value for the contained owned value.//     T::Owned: [const] Borrow<T>,//! A module for working with borrowed data./// Converts a `T` into a `Box<T>`/// The conversion allocates on the heap and moves `t`/// from the stack into it./// let x = 5;/// let boxed = Box::new(5);/// assert_eq!(Box::from(x), boxed);/// Converts a `Box<T>` into a `Pin<Box<T>>`. If `T` does not implement [`Unpin`], then/// `*boxed` will be pinned in memory and unable to be moved./// This conversion does not allocate on the heap and happens in place./// This is also available via [`Box::into_pin`]./// Constructing and pinning a `Box` with <code><Pin<Box\<T>>>::from([Box::new]\(x))</code>/// can also be written more concisely using <code>[Box::pin]\(x)</code>./// This `From` implementation is useful if you already have a `Box<T>`, or you are/// constructing a (pinned) `Box` in a different way than with [`Box::new`]./// Converts a `&[T]` into a `Box<[T]>`/// This conversion allocates on the heap/// and performs a copy of `slice` and its contents./// // create a &[u8] which will be used to create a Box<[u8]>/// let slice: &[u8] = &[104, 101, 108, 108, 111];/// let boxed_slice: Box<[u8]> = Box::from(slice);/// println!("{boxed_slice:?}");/// Converts a `&mut [T]` into a `Box<[T]>`/// // create a &mut [u8] which will be used to create a Box<[u8]>/// let mut array = [104, 101, 108, 108, 111];/// let slice: &mut [u8] = &mut array;/// Converts a `Cow<'_, [T]>` into a `Box<[T]>`/// When `cow` is the `Cow::Borrowed` variant, this/// conversion allocates on the heap and copies the/// underlying slice. Otherwise, it will try to reuse the owned/// `Vec`'s allocation./// Converts a `&str` into a `Box<str>`/// and performs a copy of `s`./// let boxed: Box<str> = Box::from("hello");/// println!("{boxed}");/// Converts a `&mut str` into a `Box<str>`/// let mut original = String::from("hello");/// let original: &mut str = &mut original;/// let boxed: Box<str> = Box::from(original);/// Converts a `Cow<'_, str>` into a `Box<str>`/// underlying `str`. Otherwise, it will try to reuse the owned/// `String`'s allocation./// let unboxed = Cow::Borrowed("hello");/// let boxed: Box<str> = Box::from(unboxed);/// # use std::borrow::Cow;/// let unboxed = Cow::Owned("hello".to_string());/// Converts a `Box<str>` into a `Box<[u8]>`/// // create a Box<str> which will be used to create a Box<[u8]>/// let boxed_str: Box<[u8]> = Box::from(boxed);/// let boxed_slice = Box::from(slice);/// assert_eq!(boxed_slice, boxed_str);/// Converts a `[T; N]` into a `Box<[T]>`/// This conversion moves the array to newly heap-allocated memory./// let boxed: Box<[u8]> = Box::from([4, 2]);/// println!("{boxed:?}");boxed_slice_as_array_unchecked/// Casts a boxed slice to a boxed array./// `boxed_slice.len()` must be exactly `N`./// Attempts to convert a `Box<[T]>` into a `Box<[T; N]>`./// The conversion occurs in-place and does not require a/// new memory allocation./// Returns the old `Box<[T]>` in the `Err` variant if/// `boxed_slice.len()` does not equal `N`./// Attempts to convert a `Vec<T>` into a `Box<[T; N]>`./// Like [`Vec::into_boxed_slice`], this is in-place if `vec.capacity() == N`,/// but will require a reallocation otherwise./// Returns the original `Vec<T>` in the `Err` variant if/// This can be used with [`vec!`] to create an array on the heap:/// let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();/// assert_eq!(state.len(), 100);/// Attempts to downcast the box to a concrete type./// use std::any::Any;/// fn print_if_string(value: Box<dyn Any>) {///     if let Ok(string) = value.downcast::<String>() {///         println!("String ({}): {}", string.len(), string);/// let my_string = "Hello World".to_string();/// print_if_string(Box::new(my_string));/// print_if_string(Box::new(0i8));downcast_unchecked/// Downcasts the box to a concrete type./// For a safe alternative see [`downcast`]./// #![feature(downcast_unchecked)]/// let x: Box<dyn Any> = Box::new(1_usize);///     assert_eq!(*x.downcast_unchecked::<usize>(), 1);/// The contained value must be of type `T`. Calling this method/// with the incorrect type is *undefined behavior*./// [`downcast`]: Self::downcast/// fn print_if_string(value: Box<dyn Any + Send>) {/// let x: Box<dyn Any + Send> = Box::new(1_usize);/// fn print_if_string(value: Box<dyn Any + Send + Sync>) {/// let x: Box<dyn Any + Send + Sync> = Box::new(1_usize);/// Converts a type of [`Error`] into a box of dyn [`Error`]./// struct AnError;/// impl fmt::Display for AnError {///         write!(f, "An error")/// impl Error for AnError {}/// let an_error = AnError;/// assert!(0 == size_of_val(&an_error));/// let a_boxed_error = Box::<dyn Error>::from(an_error);/// assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))/// Converts a type of [`Error`] + [`Send`] + [`Sync`] into a box of/// dyn [`Error`] + [`Send`] + [`Sync`]./// unsafe impl Send for AnError {}/// unsafe impl Sync for AnError {}/// let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);///     size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))/// Converts a [`String`] into a box of dyn [`Error`] + [`Send`] + [`Sync`]./// let a_string_error = "a string error".to_string();/// let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);/// Converts a [`String`] into a box of dyn [`Error`]./// let a_boxed_error = Box::<dyn Error>::from(a_string_error);/// Converts a [`str`] into a box of dyn [`Error`] + [`Send`] + [`Sync`]./// [`str`]: prim@str/// let a_str_error = "a str error";/// let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);/// Converts a [`str`] into a box of dyn [`Error`]./// let a_boxed_error = Box::<dyn Error>::from(a_str_error);/// Converts a [`Cow`] into a box of dyn [`Error`] + [`Send`] + [`Sync`]./// let a_cow_str_error = Cow::from("a str error");/// let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);/// Converts a [`Cow`] into a box of dyn [`Error`]./// let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);rustc_allow_incoherent_implasync_iterAsyncIteratorBoxIter/// Specialization for sized `I`s that uses `I`s implementation of `last()`/// instead of the default./// This implementation is required to make sure that the `Box<[I]>: IntoIterator`/// implementation doesn't overlap with `IntoIterator for T where T: Iterator` blanket./// This implementation is required to make sure that the `&Box<[I]>: IntoIterator`/// This implementation is required to make sure that the `&mut Box<[I]>: IntoIterator`// Note: the `#[rustc_skip_during_method_dispatch(boxed_slice)]` on `trait IntoIterator`// hides this implementation from explicit `.into_iter()` calls on editions < 2024,// so those calls will still resolve to the slice implementation, by reference.const_allocateconst_make_globalUnsizeWithOpaqueHeader// This is essentially `WithHeader<<T as Pointee>::Metadata>`,// but that would be invariant in `T`, and we want covariance.ThinBox/// ThinBox./// A thin pointer for heap allocation, regardless of T./// #![feature(thin_box)]/// use std::boxed::ThinBox;/// let five = ThinBox::new(5);/// let thin_slice = ThinBox::<[i32]>::new_unsize([1, 2, 3, 4]);/// let size_of_ptr = size_of::<*const ()>();/// assert_eq!(size_of_ptr, size_of_val(&five));/// assert_eq!(size_of_ptr, size_of_val(&thin_slice));/// `ThinBox<T>` is `Send` if `T` is `Send` because the data is owned./// `ThinBox<T>` is `Sync` if `T` is `Sync` because the data is owned./// Moves a type to the heap with its [`Metadata`] stored in the heap allocation instead of on/// [`Metadata`]: core::ptr::Pointee::Metadata/// the stack. Returns an error if allocation fails, instead of aborting./// #![feature(allocator_api)]/// let five = ThinBox::try_new(5)?;/// # Ok::<(), std::alloc::AllocError>(())new_unsizeWithHeader/// A pointer to type-erased data, guaranteed to either be:/// 1. `NonNull::dangling()`, in the case where both the pointee (`T`) and///    metadata (`H`) are ZSTs./// 2. A pointer to a valid `T` that has a header `H` directly before the///    pointed-to location./// An opaque representation of `WithHeader<H>` to avoid the/// projection invariance of `<T as Pointee>::Metadata`.new_unsize_zst/// Non-panicking version of `new`./// Any error is returned as `Err(core::alloc::AllocError)`.// `Dyn` is `?Sized` type like `[u32]`, and `T` is ZST type like `[u32; 0]`.// Safety:// - Assumes that either `value` can be dereferenced, or is the//   `NonNull::dangling()` we use when both `T` and `H` are ZSTs.alloc_layout//! Based on//! <https://github.com/matthieu-m/rfc2580/blob/b58d1d3cba0d4b5e859d3617ea2d0943aaa31329/examples/thin.rs>//! by matthieu-mCloneToUninitAsyncFnAsyncFnMutAsyncFnOnceCoerceUnsizedCoroutineCoroutineStateDispatchFromDynLegacyReceiverPinCoerceUnsizedraw_vecRawVecfrom_boxed_utf8_unchecked/// Conversion related impls for `Box<_>` (`From`, `downcast`, etc)/// Iterator related impls for `Box<_>`./// [`ThinBox`] implementation."owned_box"fundamentalrustc_insignificant_dtor/// A pointer type that uniquely owns a heap allocation of type `T`./// See the [module-level documentation](../../std/boxed/index.html) for more.// The declaration of the `Box` struct must be kept in sync with the// compiler or ICEs will happen.rustc_intrinsicbox_new/// Constructs a `Box<T>` by calling the `exchange_malloc` lang item and moving the argument into/// the newly allocated memory. This is an intrinsic to avoid unnecessary copies./// This is the surface syntax for `box <expr>` expressions."box_new"/// Allocates memory on the heap and then places `x` into it./// This doesn't actually allocate if `T` is zero-sized./// let five = Box::new(5);/// Constructs a new box with uninitialized contents./// let mut five = Box::<u32>::new_uninit();/// // Deferred initialization:/// five.write(5);/// let five = unsafe { five.assume_init() };/// assert_eq!(*five, 5)/// Constructs a new `Box` with uninitialized contents, with the memory/// being filled with `0` bytes./// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage/// let zero = Box::<u32>::new_zeroed();/// let zero = unsafe { zero.assume_init() };/// assert_eq!(*zero, 0)/// [zeroed]: mem::MaybeUninit::zeroed/// Constructs a new `Pin<Box<T>>`. If `T` does not implement [`Unpin`], then/// `x` will be pinned in memory and unable to be moved./// Constructing and pinning of the `Box` can also be done in two steps: `Box::pin(x)`/// does the same as <code>[Box::into_pin]\([Box::new]\(x))</code>. Consider using/// [`into_pin`](Box::into_pin) if you already have a `Box<T>`, or if you want to/// construct a (pinned) `Box` in a different way than with [`Box::new`]./// Allocates memory on the heap then places `x` into it,/// returning an error if the allocation fails/// let five = Box::try_new(5)?;try_new_uninit/// Constructs a new box with uninitialized contents on the heap,/// let mut five = Box::<u32>::try_new_uninit()?;/// assert_eq!(*five, 5);try_new_zeroed/// being filled with `0` bytes on the heap/// let zero = Box::<u32>::try_new_zeroed()?;/// assert_eq!(*zero, 0);/// Maps the value in a box, reusing the allocation if possible./// `f` is called on the value in the box, and the result is returned, also boxed./// Note: this is an associated function, which means that you have/// to call it as `Box::map(b, f)` instead of `b.map(f)`. This/// is so that there is no conflict with a method on the inner type./// #![feature(smart_pointer_try_map)]/// let b = Box::new(7);/// let new = Box::map(b, |i| i + 7);/// assert_eq!(*new, 14);TryType/// Attempts to map the value in a box, reusing the allocation if possible./// `f` is called on the value in the box, and if the operation succeeds, the result is/// returned, also boxed./// to call it as `Box::try_map(b, f)` instead of `b.try_map(f)`. This/// let new = Box::try_map(b, u32::try_from).unwrap();/// assert_eq!(*new, 7);/// Allocates memory in the given allocator then places `x` into it./// use std::alloc::System;/// let five = Box::new_in(5, System);try_new_in/// Allocates memory in the given allocator then places `x` into it,/// let five = Box::try_new_in(5, System)?;new_uninit_in/// Constructs a new box with uninitialized contents in the provided allocator./// let mut five = Box::<u32, _>::new_uninit_in(System);try_new_uninit_in/// Constructs a new box with uninitialized contents in the provided allocator,/// let mut five = Box::<u32, _>::try_new_uninit_in(System)?;new_zeroed_in/// being filled with `0` bytes in the provided allocator./// let zero = Box::<u32, _>::new_zeroed_in(System);try_new_zeroed_in/// being filled with `0` bytes in the provided allocator,/// returning an error if the allocation fails,/// let zero = Box::<u32, _>::try_new_zeroed_in(System)?;pin_in/// Constructs a new `Pin<Box<T, A>>`. If `T` does not implement [`Unpin`], then/// Constructing and pinning of the `Box` can also be done in two steps: `Box::pin_in(x, alloc)`/// does the same as <code>[Box::into_pin]\([Box::new_in]\(x, alloc))</code>. Consider using/// [`into_pin`](Box::into_pin) if you already have a `Box<T, A>`, or if you want to/// construct a (pinned) `Box` in a different way than with [`Box::new_in`]./// Converts a `Box<T>` into a `Box<[T]>`/// Consumes the `Box`, returning the wrapped value./// #![feature(box_into_inner)]/// let c = Box::new(5);/// assert_eq!(Box::into_inner(c), 5);/// Consumes the `Box` without consuming its allocation, returning the wrapped value and a `Box`/// to the uninitialized memory where the wrapped value used to live./// This can be used together with [`write`](Box::write) to reuse the allocation for multiple/// boxed values./// #![feature(box_take)]/// // take the value out of the box/// let (value, uninit) = Box::take(c);/// assert_eq!(value, 5);/// // reuse the box for a second value/// let c = Box::write(uninit, 6);/// assert_eq!(*c, 6);clone_from_ref/// Allocates memory on the heap then clones `src` into it./// This doesn't actually allocate if `src` is zero-sized./// #![feature(clone_from_ref)]/// let hello: Box<str> = Box::clone_from_ref("hello");try_clone_from_ref/// Allocates memory on the heap then clones `src` into it, returning an error if allocation fails./// let hello: Box<str> = Box::try_clone_from_ref("hello")?;//#[unstable(feature = "allocator_api", issue = "32838")]clone_from_ref_in/// Allocates memory in the given allocator then clones `src` into it./// let hello: Box<str, System> = Box::clone_from_ref_in("hello", System);try_clone_from_ref_in/// Allocates memory in the given allocator then clones `src` into it, returning an error if allocation fails./// let hello: Box<str, System> = Box::try_clone_from_ref_in("hello", System)?;new_uninit_slice/// Constructs a new boxed slice with uninitialized contents./// let mut values = Box::<[u32]>::new_uninit_slice(3);/// values[0].write(1);/// values[1].write(2);/// values[2].write(3);/// let values = unsafe { values.assume_init() };/// assert_eq!(*values, [1, 2, 3])new_zeroed_slice/// Constructs a new boxed slice with uninitialized contents, with the memory/// let values = Box::<[u32]>::new_zeroed_slice(3);/// assert_eq!(*values, [0, 0, 0])try_new_uninit_slice/// Constructs a new boxed slice with uninitialized contents. Returns an error if/// the allocation fails./// let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;/// assert_eq!(*values, [1, 2, 3]);try_new_zeroed_slice/// being filled with `0` bytes. Returns an error if the allocation fails./// let values = Box::<[u32]>::try_new_zeroed_slice(3)?;/// assert_eq!(*values, [0, 0, 0]);/// Converts the boxed slice into a boxed array./// This operation does not reallocate; the underlying array of the slice is simply reinterpreted as an array type./// If `N` is not exactly equal to the length of `self`, then this method returns `None`.new_uninit_slice_in/// Constructs a new boxed slice with uninitialized contents in the provided allocator./// let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System);new_zeroed_slice_in/// Constructs a new boxed slice with uninitialized contents in the provided allocator,/// with the memory being filled with `0` bytes./// let values = Box::<[u32], _>::new_zeroed_slice_in(3, System);try_new_uninit_slice_in/// Constructs a new boxed slice with uninitialized contents in the provided allocator. Returns an error if/// let mut values = Box::<[u32], _>::try_new_uninit_slice_in(3, System)?;try_new_zeroed_slice_in/// Constructs a new boxed slice with uninitialized contents in the provided allocator, with the memory/// let values = Box::<[u32], _>::try_new_zeroed_slice_in(3, System)?;/// Converts to `Box<T, A>`./// As with [`MaybeUninit::assume_init`],/// it is up to the caller to guarantee that the value/// really is in an initialized state./// Calling this when the content is not yet fully initialized/// causes immediate undefined behavior./// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init/// let five: Box<u32> = unsafe { five.assume_init() };/// Writes the value and converts to `Box<T, A>`./// This method converts the box similarly to [`Box::assume_init`] but/// writes `value` into it before conversion thus guaranteeing safety./// In some scenarios use of this method may improve performance because/// the compiler may be able to optimize copying from stack./// let big_box = Box::<[usize; 1024]>::new_uninit();/// let mut array = [0; 1024];/// for (i, place) in array.iter_mut().enumerate() {///     *place = i;/// // The optimizer may be able to elide this copy, so previous code writes/// // to heap directly./// let big_box = Box::write(big_box, array);/// for (i, x) in big_box.iter().enumerate() {///     assert_eq!(*x, i);/// Converts to `Box<[T], A>`./// it is up to the caller to guarantee that the values/// really are in an initialized state."call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`"/// Constructs a box from a raw pointer./// After calling this function, the raw pointer is owned by the/// resulting `Box`. Specifically, the `Box` destructor will call/// the destructor of `T` and free the allocated memory. For this/// to be safe, the memory must have been allocated in accordance/// with the [memory layout] used by `Box` ./// This function is unsafe because improper use may lead to/// memory problems. For example, a double-free may occur if the/// function is called twice on the same raw pointer./// The raw pointer must point to a block of memory allocated by the global allocator./// The safety conditions are described in the [memory layout] section./// Recreate a `Box` which was previously converted to a raw pointer/// using [`Box::into_raw`]:/// let x = Box::new(5);/// let ptr = Box::into_raw(x);/// let x = unsafe { Box::from_raw(ptr) };/// Manually create a `Box` from scratch by using the global allocator:/// use std::alloc::{alloc, Layout};///     let ptr = alloc(Layout::new::<i32>()) as *mut i32;///     // In general .write is required to avoid attempting to destruct///     // the (uninitialized) previous contents of `ptr`, though for this///     // simple example `*ptr = 5` would have worked as well.///     ptr.write(5);///     let x = Box::from_raw(ptr);/// [memory layout]: self#memory-layout"call `drop(Box::from_non_null(ptr))` if you intend to drop the `Box`"from_non_null/// Constructs a box from a `NonNull` pointer./// After calling this function, the `NonNull` pointer is owned by/// the resulting `Box`. Specifically, the `Box` destructor will call/// function is called twice on the same `NonNull` pointer./// The non-null pointer must point to a block of memory allocated by the global allocator./// Recreate a `Box` which was previously converted to a `NonNull`/// pointer using [`Box::into_non_null`]:/// #![feature(box_vec_non_null)]/// let non_null = Box::into_non_null(x);/// let x = unsafe { Box::from_non_null(non_null) };///     let non_null = NonNull::new(alloc(Layout::new::<i32>()).cast::<i32>())///         .expect("allocation failed");///     // the (uninitialized) previous contents of `non_null`.///     non_null.write(5);///     let x = Box::from_non_null(non_null);/// Consumes the `Box`, returning a wrapped raw pointer./// The pointer will be properly aligned and non-null./// After calling this function, the caller is responsible for the/// memory previously managed by the `Box`. In particular, the/// caller should properly destroy `T` and release the memory, taking/// into account the [memory layout] used by `Box`. The easiest way to/// do this is to convert the raw pointer back into a `Box` with the/// [`Box::from_raw`] function, allowing the `Box` destructor to perform/// the cleanup./// to call it as `Box::into_raw(b)` instead of `b.into_raw()`. This/// Converting the raw pointer back into a `Box` with [`Box::from_raw`]/// for automatic cleanup:/// let x = Box::new(String::from("Hello"));/// Manual cleanup by explicitly running the destructor and deallocating/// the memory:/// use std::alloc::{dealloc, Layout};///     ptr::drop_in_place(ptr);///     dealloc(ptr as *mut u8, Layout::new::<String>());/// Note: This is equivalent to the following:///     drop(Box::from_raw(ptr));into_non_null/// Consumes the `Box`, returning a wrapped `NonNull` pointer./// The pointer will be properly aligned./// do this is to convert the `NonNull` pointer back into a `Box` with the/// [`Box::from_non_null`] function, allowing the `Box` destructor to/// perform the cleanup./// to call it as `Box::into_non_null(b)` instead of `b.into_non_null()`./// This is so that there is no conflict with a method on the inner type./// Converting the `NonNull` pointer back into a `Box` with [`Box::from_non_null`]///     non_null.drop_in_place();///     dealloc(non_null.as_ptr().cast::<u8>(), Layout::new::<String>());///     drop(Box::from_non_null(non_null));from_raw_in/// Constructs a box from a raw pointer in the given allocator./// The raw pointer must point to a block of memory allocated by `alloc`./// using [`Box::into_raw_with_allocator`]:/// let x = Box::new_in(5, System);/// let (ptr, alloc) = Box::into_raw_with_allocator(x);/// let x = unsafe { Box::from_raw_in(ptr, alloc) };/// Manually create a `Box` from scratch by using the system allocator:/// #![feature(allocator_api, slice_ptr_get)]/// use std::alloc::{Allocator, Layout, System};///     let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;///     let x = Box::from_raw_in(ptr, System);from_non_null_in/// Constructs a box from a `NonNull` pointer in the given allocator./// The non-null pointer must point to a block of memory allocated by `alloc`./// Recreate a `Box` which was previously converted to a `NonNull` pointer/// using [`Box::into_non_null_with_allocator`]:/// #![feature(allocator_api, box_vec_non_null)]/// let (non_null, alloc) = Box::into_non_null_with_allocator(x);/// let x = unsafe { Box::from_non_null_in(non_null, alloc) };/// #![feature(allocator_api, box_vec_non_null, slice_ptr_get)]///     let non_null = System.allocate(Layout::new::<i32>())?.cast::<i32>();///     let x = Box::from_non_null_in(non_null, System);// #[unstable(feature = "box_vec_non_null", reason = "new API", issue = "130364")]into_raw_with_allocator/// Consumes the `Box`, returning a wrapped raw pointer and the allocator./// [`Box::from_raw_in`] function, allowing the `Box` destructor to perform/// to call it as `Box::into_raw_with_allocator(b)` instead of `b.into_raw_with_allocator()`. This/// Converting the raw pointer back into a `Box` with [`Box::from_raw_in`]/// let x = Box::new_in(String::from("Hello"), System);/// use std::ptr::{self, NonNull};///     let non_null = NonNull::new_unchecked(ptr);///     alloc.deallocate(non_null.cast(), Layout::new::<String>());into_non_null_with_allocator/// Consumes the `Box`, returning a wrapped `NonNull` pointer and the allocator./// [`Box::from_non_null_in`] function, allowing the `Box` destructor to/// to call it as `Box::into_non_null_with_allocator(b)` instead of/// `b.into_non_null_with_allocator()`. This is so that there is no/// Converting the `NonNull` pointer back into a `Box` with/// [`Box::from_non_null_in`] for automatic cleanup:///     alloc.deallocate(non_null.cast::<u8>(), Layout::new::<String>());into_uniquerustc_never_returns_null_ptrrustc_as_ptr/// Returns a raw mutable pointer to the `Box`'s contents./// The caller must ensure that the `Box` outlives the pointer this/// function returns, or else it will end up dangling./// This method guarantees that for the purpose of the aliasing model, this method/// does not materialize a reference to the underlying memory, and thus the returned pointer/// will remain valid when mixed with other calls to [`as_ptr`] and [`as_mut_ptr`]./// Note that calling other methods that materialize references to the memory/// may still invalidate this pointer./// See the example below for how this guarantee can be used./// Due to the aliasing guarantee, the following code is legal:/// #![feature(box_as_ptr)]///     let mut b = Box::new(0);///     let ptr1 = Box::as_mut_ptr(&mut b);///     ptr1.write(1);///     let ptr2 = Box::as_mut_ptr(&mut b);///     ptr2.write(2);///     // Notably, the write to `ptr2` did *not* invalidate `ptr1`:///     ptr1.write(3);/// [`as_mut_ptr`]: Self::as_mut_ptr/// [`as_ptr`]: Self::as_ptr/// Returns a raw pointer to the `Box`'s contents./// The caller must also ensure that the memory the pointer (non-transitively) points to/// is never written to (except inside an `UnsafeCell`) using this pointer or any pointer/// derived from it. If you need to mutate the contents of the `Box`, use [`as_mut_ptr`]./// Note that calling other methods that materialize mutable references to the memory,/// as well as writing to this memory, may still invalidate this pointer.///     let mut v = Box::new(0);///     let ptr1 = Box::as_ptr(&v);///     let ptr2 = Box::as_mut_ptr(&mut v);///     let _val = ptr2.read();///     // No write to this memory has happened yet, so `ptr1` is still valid.///     let _val = ptr1.read();///     // However, once we do a write...///     ptr2.write(1);///     // ... `ptr1` is no longer valid.///     // This would be UB: let _val = ptr1.read();/// to call it as `Box::allocator(&b)` instead of `b.allocator()`. This/// Consumes and leaks the `Box`, returning a mutable reference,/// `&'a mut T`./// Note that the type `T` must outlive the chosen lifetime `'a`. If the type/// has only static references, or none at all, then this may be chosen to be/// `'static`./// This function is mainly useful for data that lives for the remainder of/// the program's life. Dropping the returned reference will cause a memory/// leak. If this is not acceptable, the reference should first be wrapped/// with the [`Box::from_raw`] function producing a `Box`. This `Box` can/// then be dropped which will properly destroy `T` and release the/// to call it as `Box::leak(b)` instead of `b.leak()`. This/// Simple usage:/// let x = Box::new(41);/// let static_ref: &'static mut usize = Box::leak(x);/// *static_ref += 1;/// assert_eq!(*static_ref, 42);/// # // FIXME(https://github.com/rust-lang/miri/issues/3670):/// # // use -Zmiri-disable-leak-check instead of unleaking in tests meant to leak./// # drop(unsafe { Box::from_raw(static_ref) });/// Unsized data:/// let x = vec![1, 2, 3].into_boxed_slice();/// let static_ref = Box::leak(x);/// static_ref[0] = 4;/// assert_eq!(*static_ref, [4, 2, 3]);into_pin/// This is also available via [`From`]./// Constructing and pinning a `Box` with <code>Box::into_pin([Box::new]\(x))</code>/// This `into_pin` method is useful if you already have a `Box<T>`, or you are/// It's not recommended that crates add an impl like `From<Box<T>> for Pin<T>`,/// as it'll introduce an ambiguity when calling `Pin::from`./// A demonstration of such a poor impl is shown below./// struct Foo; // A type defined in this crate./// impl From<Box<()>> for Pin<Foo> {///     fn from(_: Box<()>) -> Pin<Foo> {///         Pin::new(Foo)/// let foo = Box::new(());/// let bar = Pin::from(foo);/// Creates a `Box<T>`, with the `Default` value for `T`./// Creates an empty `[T]` inside a `Box`./// Returns a new box with a `clone()` of this box's contents./// let y = x.clone();/// // The value is the same/// // But they are unique objects/// assert_ne!(&*x as *const i32, &*y as *const i32);/// Copies `source`'s contents into `self` without creating a new allocation./// let mut y = Box::new(10);/// let yp: *const i32 = &*y;/// y.clone_from(&x);/// // And no allocation occurred/// assert_eq!(yp, &*y);/// Copies `source`'s contents into `self` without creating a new allocation,/// so long as the two are of the same length./// let x = Box::new([5, 6, 7]);/// let mut y = Box::new([8, 9, 10]);/// let yp: *const [i32] = &*y;write_isizewrite_length_prefix"rust-call"CallOnceFutureasync_call_onceCallRefFutureasync_call_mutasync_call// It is quite crucial that we only allow the `Global` allocator here.// Handling arbitrary custom allocators (which can affect the `Box` layout heavily!)// would need a lot of codegen and interpreter adjustments./* Nota bene
 *
 *  We could have chosen not to add this impl, and instead have written a
 *  function of Pin<Box<T>> to Pin<T>. Such a function would not be sound,
 *  because Box<T> implements Unpin even when T does not, as a result of
 *  this impl.
 *
 *  We chose this API instead of the alternative for a few reasons:
 *      - Logically, it is helpful to understand pinning in regard to the
 *        memory region being pointed to. For this reason none of the
 *        standard library pointer types support projecting through a pin
 *        (Box<T> is the only pointer type in std for which this would be
 *        safe.)
 *      - It is in practice very useful to have Box<T> be unconditionally
 *        Unpin because of trait objects, for which the structural auto
 *        trait functionality does not apply (e.g., Box<dyn Foo> would
 *        otherwise not be Unpin).
 *
 *  Another type with the same semantics as Box but only a conditional
 *  implementation of `Unpin` (where `T: Unpin`) would be valid/safe, and
 *  could have a method to project a Pin<T> from it.
 *///! The `Box<T>` type for heap allocation.//! [`Box<T>`], casually referred to as a 'box', provides the simplest form of//! heap allocation in Rust. Boxes provide ownership for this allocation, and//! drop their contents when they go out of scope. Boxes also ensure that they//! never allocate more than `isize::MAX` bytes.//! Move a value from the stack to the heap by creating a [`Box`]://! let val: u8 = 5;//! let boxed: Box<u8> = Box::new(val);//! Move a value from a [`Box`] back to the stack by [dereferencing]://! let boxed: Box<u8> = Box::new(5);//! let val: u8 = *boxed;//! Creating a recursive data structure://! enum List<T> {//!     Cons(T, Box<List<T>>),//!     Nil,//! let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));//! println!("{list:?}");//! This will print `Cons(1, Cons(2, Nil))`.//! Recursive structures must be boxed, because if the definition of `Cons`//! looked like this://! ```compile_fail,E0072//! # enum List<T> {//! Cons(T, List<T>),//! It wouldn't work. This is because the size of a `List` depends on how many//! elements are in the list, and so we don't know how much memory to allocate//! for a `Cons`. By introducing a [`Box<T>`], which has a defined size, we know how//! big `Cons` needs to be.//! # Memory layout//! For non-zero-sized values, a [`Box`] will use the [`Global`] allocator for its allocation. It is//! valid to convert both ways between a [`Box`] and a raw pointer allocated with the [`Global`]//! allocator, given that the [`Layout`] used with the allocator is correct for the type and the raw//! pointer points to a valid value of the right type. More precisely, a `value: *mut T` that has//! been allocated with the [`Global`] allocator with `Layout::for_value(&*value)` may be converted//! into a box using [`Box::<T>::from_raw(value)`]. Conversely, the memory backing a `value: *mut T`//! obtained from [`Box::<T>::into_raw`] may be deallocated using the [`Global`] allocator with//! [`Layout::for_value(&*value)`].//! For zero-sized values, the `Box` pointer has to be non-null and sufficiently aligned. The//! recommended way to build a Box to a ZST if `Box::new` cannot be used is to use//! [`ptr::NonNull::dangling`].//! On top of these basic layout requirements, a `Box<T>` must point to a valid value of `T`.//! So long as `T: Sized`, a `Box<T>` is guaranteed to be represented//! as a single pointer and is also ABI-compatible with C pointers//! (i.e. the C type `T*`). This means that if you have extern "C"//! Rust functions that will be called from C, you can define those//! Rust functions using `Box<T>` types, and use `T*` as corresponding//! type on the C side. As an example, consider this C header which//! declares functions that create and destroy some kind of `Foo`//! value://! /* C header *///! /* Returns ownership to the caller *///! struct Foo* foo_new(void);//! /* Takes ownership from the caller; no-op when invoked with null *///! void foo_delete(struct Foo*);//! These two functions might be implemented in Rust as follows. Here, the//! `struct Foo*` type from C is translated to `Box<Foo>`, which captures//! the ownership constraints. Note also that the nullable argument to//! `foo_delete` is represented in Rust as `Option<Box<Foo>>`, since `Box<Foo>`//! cannot be null.//! pub struct Foo;//! #[unsafe(no_mangle)]//! pub extern "C" fn foo_new() -> Box<Foo> {//!     Box::new(Foo)//! pub extern "C" fn foo_delete(_: Option<Box<Foo>>) {}//! Even though `Box<T>` has the same representation and C ABI as a C pointer,//! this does not mean that you can convert an arbitrary `T*` into a `Box<T>`//! and expect things to work. `Box<T>` values will always be fully aligned,//! non-null pointers. Moreover, the destructor for `Box<T>` will attempt to//! free the value with the global allocator. In general, the best practice//! is to only use `Box<T>` for pointers that originated from the global//! allocator.//! **Important.** At least at present, you should avoid using//! `Box<T>` types for functions that are defined in C but invoked//! from Rust. In those cases, you should directly mirror the C types//! as closely as possible. Using types like `Box<T>` where the C//! definition is just using `T*` can lead to undefined behavior, as//! described in [rust-lang/unsafe-code-guidelines#198][ucg#198].//! # Considerations for unsafe code//! **Warning: This section is not normative and is subject to change, possibly//! being relaxed in the future! It is a simplified summary of the rules//! currently implemented in the compiler.**//! The aliasing rules for `Box<T>` are the same as for `&mut T`. `Box<T>`//! asserts uniqueness over its content. Using raw pointers derived from a box//! after that box has been mutated through, moved or borrowed as `&mut T`//! is not allowed. For more guidance on working with box from unsafe code, see//! [rust-lang/unsafe-code-guidelines#326][ucg#326].//! # Editions//! A special case exists for the implementation of `IntoIterator` for arrays on the Rust 2021//! edition, as documented [here][array]. Unfortunately, it was later found that a similar//! workaround should be added for boxed slices, and this was applied in the 2024 edition.//! Specifically, `IntoIterator` is implemented for `Box<[T]>` on all editions, but specific calls//! to `into_iter()` for boxed slices will defer to the slice implementation on editions before//! 2024://! // Rust 2015, 2018, and 2021://! # #![allow(boxed_slice_into_iter)] // override our `deny(warnings)`//! let boxed_slice: Box<[i32]> = vec![0; 3].into_boxed_slice();//! // This creates a slice iterator, producing references to each value.//! for item in boxed_slice.into_iter().enumerate() {//!     let (i, x): (usize, &i32) = item;//!     println!("boxed_slice[{i}] = {x}");//! // The `boxed_slice_into_iter` lint suggests this change for future compatibility://! for item in boxed_slice.iter().enumerate() {//! // You can explicitly iterate a boxed slice by value using `IntoIterator::into_iter`//! for item in IntoIterator::into_iter(boxed_slice).enumerate() {//!     let (i, x): (usize, i32) = item;//! Similar to the array implementation, this may be modified in the future to remove this override,//! and it's best to avoid relying on this edition-dependent behavior if you wish to preserve//! compatibility with future versions of the compiler.//! [ucg#198]: https://github.com/rust-lang/unsafe-code-guidelines/issues/198//! [ucg#326]: https://github.com/rust-lang/unsafe-code-guidelines/issues/326//! [dereferencing]: core::ops::Deref//! [`Box::<T>::from_raw(value)`]: Box::from_raw//! [`Global`]: crate::alloc::Global//! [`Layout`]: crate::alloc::Layout//! [`Layout::for_value(&*value)`]: crate::alloc::Layout::for_value//! [valid]: ptr#safetyimpl_partial_eq_nimpl_partial_eq_ord/// A wrapper for `Vec<u8>` representing a human-readable string that's conventionally, but not/// always, UTF-8./// Unlike `String`, this type permits non-UTF-8 contents, making it suitable for user input,/// non-native filenames (as `Path` only supports native filenames), and other applications that/// need to round-trip whatever data the user provides./// A `ByteString` owns its contents and can grow and shrink, like a `Vec` or `String`. For a/// borrowed byte string, see [`ByteStr`](../../std/bstr/struct.ByteStr.html)./// `ByteString` implements `Deref` to `&Vec<u8>`, so all methods available on `&Vec<u8>` are/// available on `ByteString`. Similarly, `ByteString` implements `DerefMut` to `&mut Vec<u8>`,/// so you can modify a `ByteString` using any method available on `&mut Vec<u8>`./// The `Debug` and `Display` implementations for `ByteString` are the same as those for `ByteStr`,/// showing invalid UTF-8 as hex escapes or the Unicode replacement character, respectively.as_bytestras_mut_bytestrimpl_partial_eq_ord_cow// PartialOrd with `Vec<u8>` omitted to avoid inference failures// PartialOrd with `[u8]` omitted to avoid inference failures// PartialOrd with `&[u8]` omitted to avoid inference failures// PartialOrd with `String` omitted to avoid inference failures// PartialOrd with `str` omitted to avoid inference failures// PartialOrd with `&str` omitted to avoid inference failures// PartialOrd with `[u8; N]` omitted to avoid inference failures// PartialOrd with `&[u8; N]` omitted to avoid inference failures//! The `ByteStr` and `ByteString` types and trait implementations.// This could be more fine-grained.// `impl Borrow<ByteStr> for Vec<u8>` omitted to avoid inference failures// `impl Borrow<ByteStr> for String` omitted to avoid inference failures// `impl BorrowMut<ByteStr> for Vec<u8>` omitted to avoid inference failures// Omitted due to inference failures// #[unstable(feature = "bstr", issue = "134915")]// impl<'a, const N: usize> From<&'a [u8; N]> for ByteString {//     fn from(s: &'a [u8; N]) -> Self {//         ByteString(s.as_slice().to_vec())// impl<const N: usize> From<[u8; N]> for ByteString {//     fn from(s: [u8; N]) -> Self {// impl<'a> From<&'a [u8]> for ByteString {//     fn from(s: &'a [u8]) -> Self {//         ByteString(s.to_vec())// impl From<Vec<u8>> for ByteString {//     fn from(s: Vec<u8>) -> Self {//         ByteString(s)// impl<'a> From<&'a str> for ByteString {//     fn from(s: &'a str) -> Self {//         ByteString(s.as_bytes().to_vec())// impl From<String> for ByteString {//     fn from(s: String) -> Self {//         ByteString(s.into_bytes())// Additional impls for `ByteStr` that require types from `alloc`:InPlaceIterableSourceIterTrustedFusedTrustedLenAsVecIntoIter/// A priority queue implemented with a binary heap./// This will be a max-heap./// item's ordering relative to any other item, as determined by the [`Ord`]/// trait, changes while it is in the heap. This is normally only possible/// through interior mutability, global state, I/O, or unsafe code. The/// behavior resulting from such a logic error is not specified, but will/// be encapsulated to the `BinaryHeap` that observed the logic error and not/// result in undefined behavior. This could include panics, incorrect results,/// aborts, memory leaks, and non-termination./// As long as no elements change their relative order while being in the heap/// as described above, the API of `BinaryHeap` guarantees that the heap/// invariant remains intact i.e. its methods all behave as documented. For/// example if a method is documented as iterating in sorted order, that's/// guaranteed to work as long as elements in the heap have not changed order,/// even in the presence of closures getting unwinded out of, iterators getting/// leaked, and similar foolishness./// // would be `BinaryHeap<i32>` in this example)./// let mut heap = BinaryHeap::new();/// // We can use peek to look at the next item in the heap. In this case,/// // there's no items in there yet so we get None./// assert_eq!(heap.peek(), None);/// // Let's add some scores.../// heap.push(1);/// heap.push(5);/// heap.push(2);/// // Now peek shows the most important item in the heap./// assert_eq!(heap.peek(), Some(&5));/// // We can check the length of a heap./// assert_eq!(heap.len(), 3);/// // We can iterate over the items in the heap, although they are returned in/// // a random order./// for x in &heap {///     println!("{x}");/// // If we instead pop these scores, they should come back in order./// assert_eq!(heap.pop(), Some(5));/// assert_eq!(heap.pop(), Some(2));/// assert_eq!(heap.pop(), Some(1));/// assert_eq!(heap.pop(), None);/// // We can clear the heap of any remaining items./// heap.clear();/// // The heap should now be empty./// assert!(heap.is_empty())/// A `BinaryHeap` with a known list of items can be initialized from an array:/// let heap = BinaryHeap::from([1, 5, 2]);/// ## Min-heap/// Either [`core::cmp::Reverse`] or a custom [`Ord`] implementation can be used to/// make `BinaryHeap` a min-heap. This makes `heap.pop()` return the smallest/// value instead of the greatest one./// use std::cmp::Reverse;/// // Wrap values in `Reverse`/// heap.push(Reverse(1));/// heap.push(Reverse(5));/// heap.push(Reverse(2));/// // If we pop these scores now, they should come back in the reverse order./// assert_eq!(heap.pop(), Some(Reverse(1)));/// assert_eq!(heap.pop(), Some(Reverse(2)));/// assert_eq!(heap.pop(), Some(Reverse(5)));/// | [push]  | [pop]         | [peek]/[peek\_mut] |/// |---------|---------------|--------------------|/// | *O*(1)~ | *O*(log(*n*)) | *O*(1)             |/// The value for `push` is an expected cost; the method documentation gives a/// more detailed analysis./// [`core::cmp::Reverse`]: core::cmp::Reverse/// [`Cell`]: core::cell::Cell/// [`RefCell`]: core::cell::RefCell/// [push]: BinaryHeap::push/// [pop]: BinaryHeap::pop/// [peek]: BinaryHeap::peek/// [peek\_mut]: BinaryHeap::peek_mutoriginal_len// If a set_len + sift_down are required, this is Some. If a &mut T has not// yet been exposed to peek_mut()'s caller, it's None./// Structure wrapping a mutable reference to the greatest item on a/// `BinaryHeap`./// This `struct` is created by the [`peek_mut`] method on [`BinaryHeap`]. See/// [`peek_mut`]: BinaryHeap::peek_mut"is equivalent to dropping and getting a new PeekMut except for return information"/// Sifts the current element to its new position./// Afterwards refers to the new element. Returns if the element changed./// The condition can be used to upper bound all elements in the heap. When only few elements/// are affected, the heap's sort ensures this is faster than a reconstruction from the raw/// element list and requires no additional allocation./// #![feature(binary_heap_peek_mut_refresh)]/// let mut heap: BinaryHeap<u32> = (0..128).collect();/// let mut peek = heap.peek_mut().unwrap();///     *peek = 99;///     if !peek.refresh() {/// // Post condition, this is now an upper bound./// assert!(*peek < 100);/// When the element remains the maximum after modification, the peek remains unchanged:/// let mut heap: BinaryHeap<u32> = [1, 2, 3].into();/// assert_eq!(*peek, 3);/// *peek = 42;/// // When we refresh, the peek is updated to the new maximum./// assert!(!peek.refresh(), "42 is even larger than 3");/// assert_eq!(*peek, 42);/// Removes the peeked value from the heap and returns it./// Overwrites the contents of `self` with a clone of the contents of `source`./// This method is preferred over simply assigning `source.clone()` to `self`,/// as it avoids reallocation if possible./// See [`Vec::clone_from()`] for more details./// Creates an empty `BinaryHeap<T>`.rebuild_fromRebuildOnDroprustc_const_stable/// Creates an empty `BinaryHeap` as a max-heap./// heap.push(4);/// Creates an empty `BinaryHeap` with at least the specified capacity./// The binary heap will be able to hold at least `capacity` elements without/// reallocating. This method is allowed to allocate for more elements than/// `capacity`. If `capacity` is zero, the binary heap will not allocate./// let mut heap = BinaryHeap::with_capacity(10);/// Creates an empty `BinaryHeap` as a max-heap, using `A` as allocator./// let mut heap = BinaryHeap::new_in(System);/// Creates an empty `BinaryHeap` with at least the specified capacity, using `A` as allocator./// let mut heap = BinaryHeap::with_capacity_in(10, System);/// Returns a mutable reference to the greatest item in the binary heap, or/// `None` if it is empty./// Note: If the `PeekMut` value is leaked, some heap elements might get/// leaked along with it, but the remaining elements will remain a valid/// assert!(heap.peek_mut().is_none());/// if let Some(mut val) = heap.peek_mut() {///     *val = 0;/// assert_eq!(heap.peek(), Some(&2));/// If the item is modified then the worst case time complexity is *O*(log(*n*)),/// otherwise it's *O*(1)./// Removes the greatest item from the binary heap and returns it, or `None` if it/// let mut heap = BinaryHeap::from([1, 3]);/// assert_eq!(heap.pop(), Some(3));/// The worst case cost of `pop` on a heap containing *n* elements is *O*(log(*n*)).rustc_confusables/// Pushes an item onto the binary heap./// heap.push(3);/// The expected cost of `push`, averaged over every possible ordering of/// the elements being pushed, and over a sufficiently large number of/// pushes, is *O*(1). This is the most meaningful cost metric when pushing/// elements that are *not* already in any sorted pattern./// The time complexity degrades if elements are pushed in predominantly/// ascending order. In the worst case, elements are pushed in ascending/// sorted order and the amortized cost per push is *O*(log(*n*)) against a heap/// containing *n* elements./// The worst case cost of a *single* call to `push` is *O*(*n*). The worst case/// occurs when capacity is exhausted and needs a resize. The resize cost/// has been amortized in the previous figures."`self` will be dropped if the result is not used"/// Consumes the `BinaryHeap` and returns a vector in sorted/// (ascending) order./// let mut heap = BinaryHeap::from([1, 2, 4, 5, 7]);/// heap.push(6);/// let vec = heap.into_sorted_vec();/// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]);sift_up/// The caller must guarantee that `pos < self.len()`./// Returns the new position of the element.sift_down_range/// Take an element at `pos` and move it down the heap,/// while its children are larger./// The caller must guarantee that `pos < end <= self.len()`.sift_down_to_bottom/// Take an element at `pos` and move it all the way down the heap,/// then sift it up to its position./// Note: This is faster when the element is known to be large / should/// be closer to the bottom.rebuild_tail/// Rebuild assuming data[0..start] is still a proper heap./// let mut a = BinaryHeap::from([-10, 1, 2, 3, 3]);/// let mut b = BinaryHeap::from([-20, 5, 43]);/// assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]);drain_sortedDrainSorted/// Clears the binary heap, returning an iterator over the removed elements/// in heap order. If the iterator is dropped before being fully consumed,/// it drops the remaining elements in heap order./// The returned iterator keeps a mutable borrow on the heap to optimize/// its implementation./// * `.drain_sorted()` is *O*(*n* \* log(*n*)); much slower than `.drain()`.///   You should use the latter for most cases./// #![feature(binary_heap_drain_sorted)]/// let mut heap = BinaryHeap::from([1, 2, 3, 4, 5]);/// assert_eq!(heap.len(), 5);/// drop(heap.drain_sorted()); // removes all elements in heap order/// assert_eq!(heap.len(), 0);/// In other words, remove all elements `e` for which `f(&e)` returns/// `false`. The elements are visited in unsorted (and unspecified) order./// let mut heap = BinaryHeap::from([-10, -5, 1, 2, 4, 13]);/// heap.retain(|x| x % 2 == 0); // only keep even numbers/// assert_eq!(heap.into_sorted_vec(), [-10, 2, 4])// The implementations of sift_up and sift_down use unsafe blocks in// order to move an element out of the vector (leaving behind a// hole), shift along the others and move the removed element back into the// vector at the final location of the hole.// The `Hole` type is used to represent this, and make sure// the hole is filled back at the end of its scope, even on panic.// Using a hole reduces the constant factor compared to using swaps,// which involves twice as many moves./// Returns an iterator visiting all values in the underlying vector, in/// arbitrary order./// let heap = BinaryHeap::from([1, 2, 3, 4]);/// // Print 1, 2, 3, 4 in arbitrary order/// for x in heap.iter() {into_iter_sortedIntoIterSorted/// Returns an iterator which retrieves elements in heap order./// This method consumes the original heap./// #![feature(binary_heap_into_iter_sorted)]/// let heap = BinaryHeap::from([1, 2, 3, 4, 5]);/// assert_eq!(heap.into_iter_sorted().take(2).collect::<Vec<_>>(), [5, 4]);/// Returns the greatest item in the binary heap, or `None` if it is empty./// Cost is *O*(1) in the worst case./// Returns the number of elements the binary heap can hold without reallocating./// let mut heap = BinaryHeap::with_capacity(100);/// assert!(heap.capacity() >= 100);/// Reserves the minimum capacity for at least `additional` elements more than/// the current length. Unlike [`reserve`], this will not/// deliberately over-allocate to speculatively avoid frequent allocations./// After calling `reserve_exact`, capacity will be greater than or equal to/// `self.len() + additional`. Does nothing if the capacity is already/// [`reserve`]: BinaryHeap::reserve/// Panics if the new capacity overflows [`usize`]./// heap.reserve_exact(100);/// Reserves capacity for at least `additional` elements more than the/// current length. The allocator may reserve more space to speculatively/// avoid frequent allocations. After calling `reserve`,/// capacity will be greater than or equal to `self.len() + additional`./// Does nothing if capacity is already sufficient./// heap.reserve(100);/// Tries to reserve the minimum capacity for at least `additional` elements/// more than the current length. Unlike [`try_reserve`], this will not/// After calling `try_reserve_exact`, capacity will be greater than or/// equal to `self.len() + additional` if it returns `Ok(())`./// 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 [`try_reserve`] if future insertions are expected./// [`try_reserve`]: BinaryHeap::try_reserve/// use std::collections::TryReserveError;/// fn find_max_slow(data: &[u32]) -> Result<Option<u32>, TryReserveError> {///     let mut heap = BinaryHeap::new();///     // Pre-reserve the memory, exiting if we can't///     heap.try_reserve_exact(data.len())?;///     // Now we know this can't OOM in the middle of our complex work///     heap.extend(data.iter());///     Ok(heap.pop())/// # find_max_slow(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");/// Tries to reserve capacity for at least `additional` elements more than the/// avoid frequent allocations. After calling `try_reserve`, capacity will be/// greater than or equal to `self.len() + additional` if it returns/// `Ok(())`. Does nothing if capacity is already sufficient. This method/// preserves the contents even if an error occurs.///     heap.try_reserve(data.len())?;/// Discards as much additional capacity as possible./// let mut heap: BinaryHeap<i32> = BinaryHeap::with_capacity(100);/// heap.shrink_to_fit();/// assert!(heap.capacity() == 0);/// Discards capacity with a lower bound./// The capacity will remain at least as large as both the length/// and the supplied value./// heap.shrink_to(10);/// assert!(heap.capacity() >= 10);/// Returns a slice of all values in the underlying vector, in arbitrary/// let heap = BinaryHeap::from([1, 2, 3, 4, 5, 6, 7]);/// io::sink().write(heap.as_slice()).unwrap();/// Consumes the `BinaryHeap` and returns the underlying vector/// in arbitrary order./// let vec = heap.into_vec();/// // Will print in some order/// for x in vec {/// Returns the length of the binary heap./// let heap = BinaryHeap::from([1, 3]);/// assert_eq!(heap.len(), 2);/// Checks if the binary heap is empty./// assert!(!heap.is_empty());/// in arbitrary order. If the iterator is dropped before being fully/// consumed, it drops the remaining elements in arbitrary order./// for x in heap.drain() {/// Drops all items from the binary heap./// Hole represents a hole in a slice i.e., an index without valid value/// (because it was moved from or duplicated)./// In drop, `Hole` will restore the slice by filling the hole/// position with the value that was originally removed./// Creates a new `Hole` at index `pos`./// Unsafe because pos must be within the data slice./// Returns a reference to the element removed./// Returns a reference to the element at `index`./// Unsafe because index must be within the data slice and not equal to pos./// Move hole to new location/// An iterator over the elements of a `BinaryHeap`./// This `struct` is created by [`BinaryHeap::iter()`]. See its/// [`iter`]: BinaryHeap::iter/// Creates an empty `binary_heap::Iter`./// # use std::collections::binary_heap;/// let iter: binary_heap::Iter<'_, u8> = Default::default();/// assert_eq!(iter.len(), 0);/// An owning iterator over the elements of a `BinaryHeap`./// This `struct` is created by [`BinaryHeap::into_iter()`]/// [`into_iter`]: BinaryHeap::into_iter/// Creates an empty `binary_heap::IntoIter`./// let iter: binary_heap::IntoIter<u8> = Default::default();// In addition to the SAFETY invariants of the following three unsafe traits// also refer to the vec::in_place_collect module documentation to get an overviewEXPAND_BYMERGE_BYas_into_iter/// A draining iterator over the elements of a `BinaryHeap`./// This `struct` is created by [`BinaryHeap::drain()`]. See its/// [`drain`]: BinaryHeap::drain/// This `struct` is created by [`BinaryHeap::drain_sorted()`]. See its/// [`drain_sorted`]: BinaryHeap::drain_sorted/// Removes heap elements in heap order./// Converts a `Vec<T>` into a `BinaryHeap<T>`./// This conversion happens in-place, and has *O*(*n*) time complexity./// let mut h1 = BinaryHeap::from([1, 4, 2, 3]);/// let mut h2: BinaryHeap<_> = [1, 4, 2, 3].into();/// while let Some((a, b)) = h1.pop().zip(h2.pop()) {///     assert_eq!(a, b);/// Converts a `BinaryHeap<T>` into a `Vec<T>`./// This conversion requires no data movement or allocation, and has/// constant time complexity./// Creates a consuming iterator, that is, one that moves each value out of/// the binary heap in arbitrary order. The binary heap cannot be used/// after calling this./// for x in heap.into_iter() {///     // x has type i32, not &i32//! A priority queue implemented with a binary heap.//! Insertion and popping the largest element have *O*(log(*n*)) time complexity.//! Checking the largest element is *O*(1). Converting a vector to a binary heap//! can be done in-place, and has *O*(*n*) complexity. A binary heap can also be//! converted to a sorted vector in-place, allowing it to be used for an *O*(*n* * log(*n*))//! in-place heapsort.//! This is a larger example that implements [Dijkstra's algorithm][dijkstra]//! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph].//! It shows how to use [`BinaryHeap`] with custom types.//! [dijkstra]: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm//! [sssp]: https://en.wikipedia.org/wiki/Shortest_path_problem//! [dir_graph]: https://en.wikipedia.org/wiki/Directed_graph//! use std::collections::BinaryHeap;//! #[derive(Copy, Clone, Eq, PartialEq)]//!     cost: usize,//!     position: usize,//! // The priority queue depends on `Ord`.//! // Explicitly implement the trait so the queue becomes a min-heap//! // instead of a max-heap.//! impl Ord for State {//!     fn cmp(&self, other: &Self) -> Ordering {//!         // Notice that we flip the ordering on costs.//!         // In case of a tie we compare positions - this step is necessary//!         // to make implementations of `PartialEq` and `Ord` consistent.//!         other.cost.cmp(&self.cost)//!             .then_with(|| self.position.cmp(&other.position))//! // `PartialOrd` needs to be implemented as well.//! impl PartialOrd for State {//!     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {//!         Some(self.cmp(other))//! // Each node is represented as a `usize`, for a shorter implementation.//! struct Edge {//!     node: usize,//! // Dijkstra's shortest path algorithm.//! // Start at `start` and use `dist` to track the current shortest distance//! // to each node. This implementation isn't memory-efficient as it may leave duplicate//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value,//! // for a simpler implementation.//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: usize, goal: usize) -> Option<usize> {//!     // dist[node] = current shortest distance from `start` to `node`//!     let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();//!     let mut heap = BinaryHeap::new();//!     // We're at `start`, with a zero cost//!     dist[start] = 0;//!     heap.push(State { cost: 0, position: start });//!     // Examine the frontier with lower cost nodes first (min-heap)//!     while let Some(State { cost, position }) = heap.pop() {//!         // Alternatively we could have continued to find all shortest paths//!         if position == goal { return Some(cost); }//!         // Important as we may have already found a better way//!         if cost > dist[position] { continue; }//!         // For each node we can reach, see if we can find a way with//!         // a lower cost going through this node//!         for edge in &adj_list[position] {//!             let next = State { cost: cost + edge.cost, position: edge.node };//!             // If so, add it to the frontier and continue//!             if next.cost < dist[next.position] {//!                 heap.push(next);//!                 // Relaxation, we have now found a better way//!                 dist[next.position] = next.cost;//!     // Goal not reachable//!     // This is the directed graph we're going to use.//!     // The node numbers correspond to the different states,//!     // and the edge weights symbolize the cost of moving//!     // from one node to another.//!     // Note that the edges are one-way.//!     //                  7//!     //          +-----------------+//!     //          |                 |//!     //          v   1        2    |  2//!     //          0 -----> 1 -----> 3 ---> 4//!     //          |        ^        ^      ^//!     //          |        | 1      |      |//!     //          |        |        | 3    | 1//!     //          +------> 2 -------+      |//!     //           10      |               |//!     //                   +---------------+//!     // The graph is represented as an adjacency list where each index,//!     // corresponding to a node value, has a list of outgoing edges.//!     // Chosen for its efficiency.//!     let graph = vec![//!         // Node 0//!         vec![Edge { node: 2, cost: 10 },//!              Edge { node: 1, cost: 1 }],//!         // Node 1//!         vec![Edge { node: 3, cost: 2 }],//!         // Node 2//!         vec![Edge { node: 1, cost: 1 },//!              Edge { node: 3, cost: 3 },//!              Edge { node: 4, cost: 1 }],//!         // Node 3//!         vec![Edge { node: 0, cost: 7 },//!              Edge { node: 4, cost: 2 }],//!         // Node 4//!         vec![]];//!     assert_eq!(shortest_path(&graph, 0, 1), Some(1));//!     assert_eq!(shortest_path(&graph, 0, 3), Some(3));//!     assert_eq!(shortest_path(&graph, 3, 0), Some(7));//!     assert_eq!(shortest_path(&graph, 0, 4), Some(5));//!     assert_eq!(shortest_path(&graph, 4, 0), None);merge_iterMergeIterInnerappend_from_sorted_iters/// Appends all key-value pairs from the union of two ascending iterators,/// incrementing a `length` variable along the way. The latter makes it/// easier for the caller to avoid a leak when a drop handler panicks./// If both iterators produce the same key, this method drops the pair from/// the left iterator and appends the pair from the right iterator./// If you want the tree to end up in a strictly ascending order, like for/// a `BTreeMap`, both iterators should produce keys in strictly ascending/// order, each greater than all keys in the tree, including any keys/// already in the tree upon entry.bulk_push/// Pushes all key-value pairs to the end of the tree, incrementing a/// `length` variable along the way. The latter makes it easier for the/// caller to avoid a leak when the iterator panicks.MergeIter// An iterator for merging two sorted sequences into one/// If two keys are equal, returns the key from the left and the value from the right.DormantMutRef/// Models a reborrow of some unique reference, when you know that the reborrow/// and all its descendants (i.e., all pointers and references derived from it)/// will not be used any more at some point, after which you want to use the/// original unique reference again./// The borrow checker usually handles this stacking of borrows for you, but/// some control flows that accomplish this stacking are too complicated for/// the compiler to follow. A `DormantMutRef` allows you to check borrowing/// yourself, while still expressing its stacked nature, and encapsulating/// the raw pointer code needed to do this without undefined behavior./// Capture a unique borrow, and immediately reborrow it. For the compiler,/// the lifetime of the new reference is the same as the lifetime of the/// original reference, but you promise to use it for a shorter period.awaken/// Revert to the unique borrow initially captured./// The reborrow must have ended, i.e., the reference returned by `new` and/// all pointers and references derived from it, must not be used anymore./// Borrows a new mutable reference from the unique borrow initially captured.reborrow_shared/// Borrows a new shared reference from the unique borrow initially captured.DedupSortedIter/// An iterator for deduping the key of a sorted iterator./// When encountering the duplicated key, only the last key-value pair is yielded./// Used by [`BTreeMap::bulk_build_from_sorted_iter`][1]./// [1]: crate::collections::BTreeMap::bulk_build_from_sorted_iterForceResultLeftOrRightfix_node_through_parent/// Stocks up a possibly underfull node by merging with or stealing from a/// sibling. If successful but at the cost of shrinking the parent node,/// returns that shrunk parent node. Returns an `Err` if the node is/// an empty root.LeafOrInternalfix_node_and_affected_ancestors/// Stocks up a possibly underfull node, and if that causes its parent node/// to shrink, stocks up the parent, recursively./// Returns `true` if it fixed the tree, `false` if it couldn't because the/// root node became empty./// This method does not expect ancestors to already be underfull upon entry/// and panics if it encounters an empty ancestor.fix_top/// Removes empty levels on the top, but keeps an empty leaf if the entire tree is empty.fix_right_border/// Stocks up or merge away any underfull nodes on the right border of the/// tree. The other nodes, those that are not the root nor a rightmost edge,/// must already have at least MIN_LEN elements.fix_left_border/// The symmetric clone of `fix_right_border`.fix_right_border_of_plentiful/// Stocks up any underfull nodes on the right border of the tree./// The other nodes, those that are neither the root nor a rightmost edge,/// must be prepared to have up to MIN_LEN elements stolen.fix_left_border_of_left_edgefix_right_border_of_right_edgefix_left_child/// Stocks up the left child, assuming the right child isn't underfull, and/// provisions an extra element to allow merging its children in turn/// without becoming underfull./// Returns the left child.fix_right_child/// Stocks up the right child, assuming the left child isn't underfull, and/// Returns wherever the right child ended up./// This `enum` is constructed from the [`entry`] method on [`BTreeMap`]./// [`entry`]: BTreeMap::entry/// `None` for a (empty) map without rootdormant_map/// The BTreeMap will outlive this IntoIter so we don't care about drop order for `alloc`.// Be invariant in `K` and `V`/// A view into a vacant entry in a `BTreeMap`./// A view into an occupied entry in a `BTreeMap`./// The error returned by [`try_insert`](BTreeMap::try_insert) when the key already exists./// let mut map: BTreeMap<&str, usize> = BTreeMap::new();/// let mut map: BTreeMap<&str, String> = BTreeMap::new();/// map.entry("poneyland").or_insert_with(|| s);/// let entry = map.entry("poneyland").insert_entry("hoho".to_string());/// let mut map: BTreeMap<&str, Option<usize>> = BTreeMap::new();/// use std::collections::btree_map::Entry;/// let mut map: BTreeMap<&str, u32> = BTreeMap::new();/// and returns an `OccupiedEntry`.///     let entry = o.insert_entry(37);///     assert_eq!(entry.get(), &37);/// Converts the entry into a reference to its key./// Take ownership of the key and value from the map./// // If now try to get the value, it will panic:/// // println!("{}", map["poneyland"]);/// If you need a reference to the `OccupiedEntry` that may outlive the/// [`into_mut`]: OccupiedEntry::into_mut/// [`get_mut`]: OccupiedEntry::get_mut/// Sets the value of the entry with the `OccupiedEntry`'s key,/// // If we try to get "poneyland"'s value, it'll panic:remove_kv// Body of `remove_entry`, probably separate because the name reflects the returned pair.testingcrash_testCrashTestDummyord_chaosCyclic3GovernedGovernorIdBasedDeterministicRngMIN_INSERTS_HEIGHT_1// Minimum number of elements to insert, to guarantee a tree with 2 levels,// i.e., a tree who's root is an internal node at height 1, with edges to leaf nodes.// It's not the minimum size: removing an element from such a tree does not always reduce height.MIN_INSERTS_HEIGHT_2// Minimum number of elements to insert in ascending order, to guarantee a tree with 3 levels,// i.e., a tree who's root is an internal node at height 2, with edges to more internal nodes.test_all_refs// Gathers all references from a mutable iterator and makes sure Miri notices if// using them is dangerous.// Panics if the map (or the code navigating it) is corrupted.// Panics if the map is corrupted or if the keys are not in strictly// ascending order, in the current opinion of the `Ord` implementation.// If the `Ord` implementation violates transitivity, this method does not// guarantee that all keys are unique, just that adjacent keys are unique.// Returns the height of the root, if any.dump_keysassert_strictly_ascending// Panics if the keys are not in strictly ascending order.// Transform the tree to minimize wasted space, obtaining fewer nodes that// are mostly filled up to their capacity. The same compact tree could have// been obtained by inserting keys in a shrewd order.assert_min_lentest_levels// Tests our value of MIN_INSERTS_HEIGHT_2. Failure may mean you just need to// adapt that value to match a change in node::CAPACITY or the choices made// during insertion, otherwise other test cases may fail or be less useful.test_check_ord_chaos// Ensures the testing infrastructure usually notices order violations.test_check_invariants_ord_chaos// Ensures the testing infrastructure doesn't always mind order violations.test_basic_largetest_basic_smalltest_itertest_iter_revdo_test_iter_mut_mutation// Specifically tests iter_mut's ability to mutate the value of pairs in-line.Align32test_iter_mut_mutationtest_values_mut_mutationtest_iter_entering_root_twicetest_iter_descending_to_same_node_twicetest_iter_mixedtest_iter_min_maxrange_keystest_range_smalltest_range_height_1test_range_largetest_range_inclusive_max_valuetest_range_equal_empty_casestest_range_equal_excludedtest_range_backwards_1test_range_backwards_2test_range_backwards_3test_range_backwards_4test_range_finding_ill_order_in_maptest_range_finding_ill_order_in_range_ordtest_range_1000test_range_borrowed_keytest_range_muttest_range_panic_1test_range_panic_2test_range_panic_3consumed_keeping_all// Explicitly consumes the iterator, where most test cases drop it instantly.consumed_removing_allconsumed_removing_somemutating_and_keeping// Explicitly consumes the iterator and modifies values through it.mutating_and_removingunderfull_keeping_allunderfull_removing_oneunderfull_keeping_oneunderfull_removing_allheight_0_keeping_allheight_0_removing_oneheight_0_keeping_oneheight_0_removing_allheight_0_keeping_halfheight_1_removing_allheight_1_removing_oneheight_1_keeping_oneheight_2_removing_oneheight_2_keeping_oneheight_2_removing_alldrop_panic_leakpred_panic_leakpred_panic_reuse// Same as above, but attempt to use the iterator again after the panic in the predicatetest_zsttest_bad_zst// This test's only purpose is to ensure that zero-sized keys with nonsensical orderings// do not cause segfaults when used with zero-sized values. All other map behavior is// undefined.test_clear_drop_panic_leaktest_clone_panic_leaktest_clone_panic_leak_height_0test_clone_panic_leak_height_1test_ord_absencetest_vacant_entry_no_inserttest_first_last_entrytest_pop_first_lasttest_get_key_valuetest_insert_into_full_height_0test_insert_into_full_height_1test_try_insertcreate_append_test// These are mostly for testing the algorithm that "fixes" the right edge after insertion.// Single node.// Two leafs that don't need fixing.// Two leafs where the second one ends up underfull and needs stealing at the end.// Two leafs where the second one ends up empty because the insertion finished at the root.// Three levels; insertion finished at the root.// Three levels; insertion finished at leaf while there is an empty node on the second level.// Tests for several randomly chosen sizes.test_append_drop_leaktest_append_ord_chaosrand_datatest_split_off_empty_righttest_split_off_empty_lefttest_split_off_tiny_left_height_2// In a tree with 3 levels, if all but a part of the first leaf node is split off,// make sure fix_top eliminates both top levels.test_split_off_tiny_right_height_2// In a tree with 3 levels, if only part of the last leaf node is split off,test_split_off_halfwaytest_split_off_large_random_sortedtest_into_iter_drop_leak_height_0test_into_iter_drop_leak_kv_panic_in_keytest_into_iter_drop_leak_kv_panic_in_valtest_into_iter_drop_leak_height_1test_insert_remove_intertwinedtest_insert_remove_intertwined_ord_chaostest_cursortest_cursor_muttest_cursor_mut_keytest_cursor_emptytest_cursor_mut_insert_before_1test_cursor_mut_insert_before_2test_cursor_mut_insert_before_3test_cursor_mut_insert_before_4test_cursor_mut_insert_after_1test_cursor_mut_insert_after_2test_cursor_mut_insert_after_3test_cursor_mut_insert_after_4cursor_peek_prev_agrees_with_cursor_muttest_id_based_inserttest_id_based_appenddedup_sorted_iternavigateLazyLeafRangeLeafRangeSearchBoundSearchResultset_valSetValZST/// Minimum number of elements in a node that is not a root./// We might temporarily have fewer elements during methods./// `ManuallyDrop` to control drop order (needs to be dropped after all the nodes).// Although some of the accessory types store a copy of the allocator, the nodes do not.// Because allocations will remain live as long as any copy (like this one) of the allocator// is live, it's unnecessary to store the allocator in each node.// For dropck; the `Box` avoids making the `Unpin` impl more strict than before/// An ordered map based on a [B-Tree]./// Given a key type with a [total order], an ordered map stores its entries in key order./// That means that keys must be of a type that implements the [`Ord`] trait,/// such that two keys can always be compared to determine their [`Ordering`]./// Examples of keys with a total order are strings with lexicographical order,/// and numbers with their natural order./// Iterators obtained from functions such as [`BTreeMap::iter`], [`BTreeMap::into_iter`], [`BTreeMap::values`], or/// [`BTreeMap::keys`] produce their items in key order, and take worst-case logarithmic and/// amortized constant time per item returned./// It is a logic error for a key to be modified in such a way that the key's ordering relative to/// any other key, as determined by the [`Ord`] trait, changes while it is in the map. This is/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code./// The behavior resulting from such a logic error is not specified, but will be encapsulated to the/// `BTreeMap` that observed the logic error and not result in undefined behavior. This could/// include panics, incorrect results, aborts, memory leaks, and non-termination./// // would be `BTreeMap<&str, &str>` in this example)./// let mut movie_reviews = BTreeMap::new();/// // review some movies./// movie_reviews.insert("Office Space",       "Deals with real issues in the workplace.");/// movie_reviews.insert("Pulp Fiction",       "Masterpiece.");/// movie_reviews.insert("The Godfather",      "Very enjoyable.");/// movie_reviews.insert("The Blues Brothers", "Eye lyked it a lot.");/// // check for a specific one./// if !movie_reviews.contains_key("Les Misérables") {///              movie_reviews.len());/// movie_reviews.remove("The Blues Brothers");/// // look up the values associated with some keys./// let to_find = ["Up!", "Office Space"];/// for movie in &to_find {///     match movie_reviews.get(movie) {///        Some(review) => println!("{movie}: {review}"),///        None => println!("{movie} is unreviewed.")/// println!("Movie review: {}", movie_reviews["Office Space"]);/// // iterate over everything./// for (movie, review) in &movie_reviews {///     println!("{movie}: \"{review}\"");/// A `BTreeMap` with a known list of items can be initialized from an array:/// let solar_distance = BTreeMap::from([///     ("Mercury", 0.4),///     ("Venus", 0.7),///     ("Earth", 1.0),///     ("Mars", 1.5),/// ## `Entry` API/// `BTreeMap` implements an [`Entry API`], which allows for complex/// methods of getting, setting, updating and removing keys and their values:/// [`Entry API`]: BTreeMap::entry/// // would be `BTreeMap<&str, u8>` in this example)./// let mut player_stats = BTreeMap::new();/// // modify an entry before an insert with in-place mutation/// player_stats.entry("mana").and_modify(|mana| *mana += 200).or_insert(100);/// A B-tree is (like) a [binary search tree], but adapted to the natural granularity that modern/// machines like to consume data at. This means that each node contains an entire array of elements,/// instead of just a single element./// B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing/// the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal/// choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum number of/// comparisons necessary to find an element (log<sub>2</sub>n). However, in practice the way this/// is done is *very* inefficient for modern computer architectures. In particular, every element/// is stored in its own individually heap-allocated node. This means that every single insertion/// triggers a heap-allocation, and every comparison is a potential cache-miss due to the indirection./// Since both heap-allocations and cache-misses are notably expensive in practice, we are forced to,/// at the very least, reconsider the BST strategy./// A B-Tree instead makes each node contain B-1 to 2B-1 elements in a contiguous array. By doing/// this, we reduce the number of allocations by a factor of B, and improve cache efficiency in/// searches. However, this does mean that searches will have to do *more* comparisons on average./// The precise number of comparisons depends on the node search strategy used. For optimal cache/// efficiency, one could search the nodes linearly. For optimal comparisons, one could search/// the node using binary search. As a compromise, one could also perform a linear search/// that initially only checks every i<sup>th</sup> element for some choice of i./// Currently, our implementation simply performs naive linear search. This provides excellent/// performance on *small* nodes of elements which are cheap to compare. However in the future we/// would like to further explore choosing the optimal search strategy based on the choice of B,/// and possibly other factors. Using linear search, searching for a random element is expected/// to take B * log(n) comparisons, which is generally worse than a BST. In practice,/// however, performance is excellent./// [B-Tree]: https://en.wikipedia.org/wiki/B-tree/// [binary search tree]: https://en.wikipedia.org/wiki/Binary_search_tree/// [total order]: https://en.wikipedia.org/wiki/Total_order// FIXME: This implementation is "wrong", but changing it would be a breaking change.// (The bounds of the automatic `UnwindSafe` implementation have been like this since Rust 1.50.)// Maybe we can fix it nonetheless with a crater run, or if the `UnwindSafe`// traits are deprecated, or disarmed (no longer causing hard errors) in the future.// Internal functionality for `BTreeSet`./// An iterator over the entries of a `BTreeMap`./// This `struct` is created by the [`iter`] method on [`BTreeMap`]. See its/// [`iter`]: BTreeMap::iter/// Creates an empty `btree_map::Iter`./// # use std::collections::btree_map;/// let iter: btree_map::Iter<'_, u8, u8> = Default::default();ValMut/// A mutable iterator over the entries of a `BTreeMap`./// This `struct` is created by the [`iter_mut`] method on [`BTreeMap`]. See its/// [`iter_mut`]: BTreeMap::iter_mut/// Creates an empty `btree_map::IterMut`./// let iter: btree_map::IterMut<'_, u8, u8> = Default::default();Dying/// An owning iterator over the entries of a `BTreeMap`, sorted by key./// This `struct` is created by the [`into_iter`] method on [`BTreeMap`]/// [`into_iter`]: IntoIterator::into_iter/// Returns an iterator of references over the remaining items./// Creates an empty `btree_map::IntoIter`./// let iter: btree_map::IntoIter<u8, u8> = Default::default();/// An iterator over the keys of a `BTreeMap`./// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its/// [`keys`]: BTreeMap::keys/// An iterator over the values of a `BTreeMap`./// This `struct` is created by the [`values`] method on [`BTreeMap`]. See its/// [`values`]: BTreeMap::values/// A mutable iterator over the values of a `BTreeMap`./// This `struct` is created by the [`values_mut`] method on [`BTreeMap`]. See its/// [`values_mut`]: BTreeMap::values_mut/// An owning iterator over the keys of a `BTreeMap`./// This `struct` is created by the [`into_keys`] method on [`BTreeMap`]./// [`into_keys`]: BTreeMap::into_keys/// An owning iterator over the values of a `BTreeMap`./// This `struct` is created by the [`into_values`] method on [`BTreeMap`]./// [`into_values`]: BTreeMap::into_values/// An iterator over a sub-range of entries in a `BTreeMap`./// This `struct` is created by the [`range`] method on [`BTreeMap`]. See its/// [`range`]: BTreeMap::rangeRangeMut/// A mutable iterator over a sub-range of entries in a `BTreeMap`./// This `struct` is created by the [`range_mut`] method on [`BTreeMap`]. See its/// [`range_mut`]: BTreeMap::range_mut/// Makes a new, empty `BTreeMap`./// Does not allocate anything on its own./// // entries can now be inserted into the empty map/// Clears the map, removing all elements./// let mut a = BTreeMap::new();/// Makes a new empty BTreeMap with a reasonable choice for B./// # #![feature(allocator_api)]/// # #![feature(btreemap_alloc)]/// use std::alloc::Global;/// let mut map = BTreeMap::new_in(Global);/// Returns the key-value pair corresponding to the supplied key. This is/// potentially useful:/// - for key types where non-identical keys can be considered equal;/// - for getting the `&K` stored key value from a borrowed `&Q` lookup key; or/// - for getting a reference to a key with the same lifetime as the collection./// The supplied key may be any borrowed form of the map's key type, but the ordering///     id: u32,/// #   #[allow(unused)] // prevents a "field `name` is never read" error///     name: &'static str, // ignored by equality and ordering operations/// impl PartialEq for S {///     fn eq(&self, other: &S) -> bool {///         self.id == other.id/// impl Eq for S {}/// impl PartialOrd for S {///     fn partial_cmp(&self, other: &S) -> Option<Ordering> {///         self.id.partial_cmp(&other.id)/// impl Ord for S {///     fn cmp(&self, other: &S) -> Ordering {///         self.id.cmp(&other.id)/// let j_a = S { id: 1, name: "Jessica" };/// let j_b = S { id: 1, name: "Jess" };/// let p = S { id: 2, name: "Paul" };/// assert_eq!(j_a, j_b);/// map.insert(j_a, "Paris");/// assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));/// assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case/// assert_eq!(map.get_key_value(&p), None);first_key_value/// Returns the first key-value pair in the map./// The key in this pair is the minimum key in the map./// assert_eq!(map.first_key_value(), None);/// map.insert(1, "b");/// map.insert(2, "a");/// assert_eq!(map.first_key_value(), Some((&1, &"b")));first_entry/// Returns the first entry in the map for in-place manipulation./// The key of this entry is the minimum key in the map./// if let Some(mut entry) = map.first_entry() {///     if *entry.key() > 0 {///         entry.insert("first");/// assert_eq!(*map.get(&1).unwrap(), "first");/// assert_eq!(*map.get(&2).unwrap(), "b");/// Removes and returns the first element in the map./// The key of this element is the minimum key that was in the map./// Draining elements in ascending order, while keeping a usable map each iteration./// while let Some((key, _val)) = map.pop_first() {///     assert!(map.iter().all(|(k, _v)| *k > key));last_key_value/// Returns the last key-value pair in the map./// The key in this pair is the maximum key in the map./// assert_eq!(map.last_key_value(), Some((&2, &"a")));last_entry/// Returns the last entry in the map for in-place manipulation./// The key of this entry is the maximum key in the map./// if let Some(mut entry) = map.last_entry() {///         entry.insert("last");/// assert_eq!(*map.get(&1).unwrap(), "a");/// assert_eq!(*map.get(&2).unwrap(), "last");/// Removes and returns the last element in the map./// The key of this element is the maximum key that was in the map./// Draining elements in descending order, while keeping a usable map each iteration./// while let Some((key, _val)) = map.pop_last() {///     assert!(map.iter().all(|(k, _v)| *k < key));// See `get` for implementation notes, this is basically a copy-paste with mut's added/// [module-level documentation]: index.html#insert-and-complex-keys/// #![feature(map_try_insert)]/// let err = map.try_insert(37, "b").unwrap_err();/// assert_eq!(err.entry.key(), &37);/// assert_eq!(err.entry.get(), &"a");/// assert_eq!(err.value, "b");/// Removes a key from the map, returning the stored key and value if the key/// assert_eq!(map.remove_entry(&1), None);/// In other words, remove all pairs `(k, v)` for which `f(&k, &mut v)` returns `false`./// The elements are visited in ascending key order./// let mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x*10)).collect();/// // Keep only the elements with even-numbered keys./// assert!(map.into_iter().eq(vec![(0, 0), (2, 20), (4, 40), (6, 60)]));/// Moves all elements from `other` into `self`, leaving `other` empty./// If a key from `other` is already present in `self`, the respective/// value from `self` will be overwritten with the respective value from `other`./// Similar to [`insert`], though, the key is not overwritten,/// which matters for types that can be `==` without being identical./// [`insert`]: BTreeMap::insert/// a.insert(3, "c"); // Note: Key (3) also present in b./// let mut b = BTreeMap::new();/// b.insert(3, "d"); // Note: Key (3) also present in a./// b.insert(4, "e");/// b.insert(5, "f");/// assert_eq!(a.len(), 5);/// assert_eq!(a[&1], "a");/// assert_eq!(a[&2], "b");/// assert_eq!(a[&3], "d"); // Note: "c" has been overwritten./// assert_eq!(a[&4], "e");/// assert_eq!(a[&5], "f");/// Constructs a double-ended iterator over a sub-range of elements in the map./// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will/// yield elements from min (inclusive) to max (exclusive)./// The range may also be entered as `(Bound<T>, Bound<T>)`, so for example/// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive/// range from 4 to 10./// Panics if range `start > end`./// Panics if range `start == end` and both bounds are `Excluded`./// use std::ops::Bound::Included;/// map.insert(3, "a");/// map.insert(5, "b");/// map.insert(8, "c");/// for (&key, &value) in map.range((Included(&4), Included(&8))) {///     println!("{key}: {value}");/// assert_eq!(Some((&5, &"b")), map.range(4..).next());range_mut/// Constructs a mutable double-ended iterator over a sub-range of elements in the map./// let mut map: BTreeMap<&str, i32> =///     [("Alice", 0), ("Bob", 0), ("Carol", 0), ("Cheryl", 0)].into();/// for (_, balance) in map.range_mut("B".."Cheryl") {///     *balance += 100;/// for (name, balance) in &map {///     println!("{name} => {balance}");/// let mut count: BTreeMap<&str, usize> = BTreeMap::new();/// // count the number of occurrences of letters in the vec/// for x in ["a", "b", "a", "c", "a", "b"] {///     count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);/// assert_eq!(count["a"], 3);/// assert_eq!(count["b"], 2);/// assert_eq!(count["c"], 1);/// Splits the collection into two at the given key. Returns everything after the given key,/// including the key. If the key is not present, the split will occur at the nearest/// greater key, or return an empty map if no such key exists./// a.insert(17, "d");/// a.insert(41, "e");/// let b = a.split_off(&3);/// assert_eq!(a.len(), 2);/// assert_eq!(b.len(), 3);/// assert_eq!(b[&3], "c");/// assert_eq!(b[&17], "d");/// assert_eq!(b[&41], "e");/// Creates an iterator that visits elements (key-value pairs) in the specified range in/// ascending key order and uses a closure to determine if an element/// should be removed./// If the closure returns `true`, the element is removed from the map and/// yielded. If the closure returns `false`, or panics, the element remains/// in the map and will not be yielded./// The iterator also lets you mutate the value of each element in the/// closure, regardless of whether you choose to keep or remove it./// Use `extract_if().for_each(drop)` if you do not need the returned iterator,/// or [`retain`] with a negated predicate if you also do not need to restrict the range./// [`retain`]: BTreeMap::retain/// // Splitting a map into even and odd keys, reusing the original map:/// let mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x)).collect();/// let evens: BTreeMap<_, _> = map.extract_if(.., |k, _v| k % 2 == 0).collect();/// let odds = map;/// assert_eq!(evens.keys().copied().collect::<Vec<_>>(), [0, 2, 4, 6]);/// assert_eq!(odds.keys().copied().collect::<Vec<_>>(), [1, 3, 5, 7]);/// // Splitting a map into low and high halves, reusing the original map:/// let low: BTreeMap<_, _> = map.extract_if(0..4, |_k, _v| true).collect();/// let high = map;/// assert_eq!(low.keys().copied().collect::<Vec<_>>(), [0, 1, 2, 3]);/// assert_eq!(high.keys().copied().collect::<Vec<_>>(), [4, 5, 6, 7]);extract_if_innerExtractIfInner/// Creates a consuming iterator visiting all the keys, in sorted order./// let keys: Vec<i32> = a.into_keys().collect();/// assert_eq!(keys, [1, 2]);/// Creates a consuming iterator visiting all the values, in order by key./// a.insert(1, "hello");/// a.insert(2, "goodbye");/// let values: Vec<&str> = a.into_values().collect();/// assert_eq!(values, ["hello", "goodbye"]);bulk_build_from_sorted_iter/// Makes a `BTreeMap` from a sorted iterator./// Gets an owning iterator over the entries of the map, sorted by key.dying_next/// Core of a `next` method returning a dying KV handle,/// invalidated by further calls to this function and some others.dying_next_back/// Core of a `next_back` method returning a dying KV handle,/// Creates an empty `btree_map::Keys`./// let iter: btree_map::Keys<'_, u8, u8> = Default::default();/// Creates an empty `btree_map::Values`./// let iter: btree_map::Values<'_, u8, u8> = Default::default();"iterators are lazy and do nothing unless consumed; \
    use `retain` or `extract_if().for_each(drop)` to remove and discard elements"/// An iterator produced by calling `extract_if` on BTreeMap./// Reference to the length field in the borrowed map, updated live.dormant_root/// Buried reference to the root field in the borrowed map./// Wrapped in `Option` to allow drop handler to `take` it.cur_leaf_edge/// Contains a leaf edge preceding the next element to be returned, or the last leaf edge./// Empty if the map has no root, if iteration went beyond the last leaf edge,/// or if a panic occurred in the predicate./// Range over which iteration was requested.  We don't need the left side, but we/// can't extract the right side without requiring K: Clone./// Most of the implementation of ExtractIf are generic over the type/// of the predicate, thus also serving for BTreeSet::ExtractIf./// Allow Debug implementations to predict the next element./// Implementation of a typical `ExtractIf::next` method, given the predicate./// Implementation of a typical `ExtractIf::size_hint` method./// Creates an empty `btree_map::Range`./// let iter: btree_map::Range<'_, u8, u8> = Default::default();/// assert_eq!(iter.count(), 0);/// Creates an empty `btree_map::RangeMut`./// let iter: btree_map::RangeMut<'_, u8, u8> = Default::default();/// Creates an empty `btree_map::ValuesMut`./// let iter: btree_map::ValuesMut<'_, u8, u8> = Default::default();/// Creates an empty `btree_map::IntoKeys`./// let iter: btree_map::IntoKeys<u8, u8> = Default::default();/// Creates an empty `btree_map::IntoValues`./// let iter: btree_map::IntoValues<u8, u8> = Default::default();/// Constructs a `BTreeMap<K, V>` from an iterator of key-value pairs./// If the iterator produces any pairs with equal keys,/// all but one of the corresponding values will be dropped./// Creates an empty `BTreeMap`./// Panics if the key is not present in the `BTreeMap`./// Converts a `[(K, V); N]` into a `BTreeMap<K, V>`./// If any entries in the array have equal keys,/// let map1 = BTreeMap::from([(1, 2), (3, 4)]);/// let map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();/// Gets an iterator over the entries of the map, sorted by key./// let (first_key, first_value) = map.iter().next().unwrap();/// assert_eq!((*first_key, *first_value), (1, "a"));/// Gets a mutable iterator over the entries of the map, sorted by key./// let mut map = BTreeMap::from([///    ("a", 1),///    ("b", 2),///    ("c", 3),/// // add 10 to the value if the key isn't "a"///     if key != &"a" {///         *value += 10;/// Gets an iterator over the keys of the map, in sorted order./// let keys: Vec<_> = a.keys().cloned().collect();/// Gets an iterator over the values of the map, in order by key./// let values: Vec<&str> = a.values().cloned().collect();/// Gets a mutable iterator over the values of the map, in order by key./// a.insert(1, String::from("hello"));/// a.insert(2, String::from("goodbye"));/// for value in a.values_mut() {///     value.push_str("!");/// let values: Vec<String> = a.values().cloned().collect();/// assert_eq!(values, [String::from("hello!"),///                     String::from("goodbye!")]);/// Returns a [`Cursor`] pointing at the gap before the smallest key/// greater than the given bound./// Passing `Bound::Included(x)` will return a cursor pointing to the/// gap before the smallest key greater than or equal to `x`./// Passing `Bound::Excluded(x)` will return a cursor pointing to the/// gap before the smallest key greater than `x`./// Passing `Bound::Unbounded` will return a cursor pointing to the/// gap before the smallest key in the map./// #![feature(btree_cursors)]/// use std::ops::Bound;/// let map = BTreeMap::from([///     (1, "a"),///     (2, "b"),///     (3, "c"),///     (4, "d"),/// let cursor = map.lower_bound(Bound::Included(&2));/// assert_eq!(cursor.peek_prev(), Some((&1, &"a")));/// assert_eq!(cursor.peek_next(), Some((&2, &"b")));/// let cursor = map.lower_bound(Bound::Excluded(&2));/// assert_eq!(cursor.peek_prev(), Some((&2, &"b")));/// assert_eq!(cursor.peek_next(), Some((&3, &"c")));/// let cursor = map.lower_bound(Bound::Unbounded);/// assert_eq!(cursor.peek_prev(), None);/// assert_eq!(cursor.peek_next(), Some((&1, &"a")));lower_bound_mutCursorMut/// Returns a [`CursorMut`] pointing at the gap before the smallest key/// let mut cursor = map.lower_bound_mut(Bound::Included(&2));/// assert_eq!(cursor.peek_prev(), Some((&1, &mut "a")));/// assert_eq!(cursor.peek_next(), Some((&2, &mut "b")));/// let mut cursor = map.lower_bound_mut(Bound::Excluded(&2));/// assert_eq!(cursor.peek_prev(), Some((&2, &mut "b")));/// assert_eq!(cursor.peek_next(), Some((&3, &mut "c")));/// let mut cursor = map.lower_bound_mut(Bound::Unbounded);/// assert_eq!(cursor.peek_next(), Some((&1, &mut "a")));/// Returns a [`Cursor`] pointing at the gap after the greatest key/// smaller than the given bound./// gap after the greatest key smaller than or equal to `x`./// gap after the greatest key smaller than `x`./// gap after the greatest key in the map./// let cursor = map.upper_bound(Bound::Included(&3));/// assert_eq!(cursor.peek_prev(), Some((&3, &"c")));/// assert_eq!(cursor.peek_next(), Some((&4, &"d")));/// let cursor = map.upper_bound(Bound::Excluded(&3));/// let cursor = map.upper_bound(Bound::Unbounded);/// assert_eq!(cursor.peek_prev(), Some((&4, &"d")));/// assert_eq!(cursor.peek_next(), None);upper_bound_mut/// Returns a [`CursorMut`] pointing at the gap after the greatest key/// let mut cursor = map.upper_bound_mut(Bound::Included(&3));/// assert_eq!(cursor.peek_prev(), Some((&3, &mut "c")));/// assert_eq!(cursor.peek_next(), Some((&4, &mut "d")));/// let mut cursor = map.upper_bound_mut(Bound::Excluded(&3));/// let mut cursor = map.upper_bound_mut(Bound::Unbounded);/// assert_eq!(cursor.peek_prev(), Some((&4, &mut "d")));// If current is None then it means the tree has not been allocated yet./// A cursor over a `BTreeMap`./// A `Cursor` is like an iterator, except that it can freely seek back-and-forth./// Cursors always point to a gap between two elements in the map, and can/// operate on the two immediately adjacent elements./// A `Cursor` is created with the [`BTreeMap::lower_bound`] and [`BTreeMap::upper_bound`] methods.CursorMutKey/// A cursor over a `BTreeMap` with editing operations./// A `Cursor` is like an iterator, except that it can freely seek back-and-forth, and can/// safely mutate the map during iteration. This is because the lifetime of its yielded/// references is tied to its own lifetime, instead of just the underlying map. This means/// cursors cannot yield multiple elements at once./// A `CursorMut` is created with the [`BTreeMap::lower_bound_mut`] and [`BTreeMap::upper_bound_mut`]/// A cursor over a `BTreeMap` with editing operations, and which allows/// mutating the key of elements./// A `CursorMutKey` is created from a [`CursorMut`] with the/// [`CursorMut::with_mutable_key`] method./// Since this cursor allows mutating keys, you must ensure that the `BTreeMap`/// invariants are maintained. Specifically:/// * The key of the newly inserted element must be unique in the tree./// * All keys in the tree must remain in sorted order./// Advances the cursor to the next gap, returning the key and value of the/// element that it moved over./// If the cursor is already at the end of the map then `None` is returned/// and the cursor is not moved./// Advances the cursor to the previous gap, returning the key and value of/// the element that it moved over./// If the cursor is already at the start of the map then `None` is returned/// Returns a reference to the key and value of the next element without/// moving the cursor./// If the cursor is at the end of the map then `None` is returned.peek_prev/// Returns a reference to the key and value of the previous element/// without moving the cursor./// If the cursor is at the start of the map then `None` is returned./// Returns a read-only cursor pointing to the same location as the/// `CursorMut`./// The lifetime of the returned `Cursor` is bound to that of the/// `CursorMut`, which means it cannot outlive the `CursorMut` and that the/// `CursorMut` is frozen for the lifetime of the `Cursor`.with_mutable_key/// Converts the cursor into a [`CursorMutKey`], which allows mutating/// the key of elements in the tree./// `CursorMutKey`./// `CursorMutKey`, which means it cannot outlive the `CursorMutKey` and that the/// `CursorMutKey` is frozen for the lifetime of the `Cursor`.insert_after_unchecked/// Inserts a new key-value pair into the map in the gap that the/// cursor is currently pointing to./// After the insertion the cursor will be pointing at the gap before the/// newly inserted element./// You must ensure that the `BTreeMap` invariants are maintained./// Specifically:insert_before_unchecked/// After the insertion the cursor will be pointing at the gap after theUnorderedKeyError/// If the inserted key is not greater than the key before the cursor/// (if any), or if it not less than the key after the cursor (if any),/// then an [`UnorderedKeyError`] is returned since this would/// invalidate the [`Ord`] invariant between the keys of the map.remove_next/// Removes the next element from the `BTreeMap`./// The element that was removed is returned. The cursor position is/// unchanged (before the removed element).remove_prev/// Removes the preceding element from the `BTreeMap`./// unchanged (after the removed element).// Now the tree editing operations/// Error type returned by [`CursorMut::insert_before`] and/// [`CursorMut::insert_after`] if the key being inserted is not properly/// ordered with regards to adjacent keys.// A tree in a `BTreeMap` is a tree in the `node` module with additional invariants:// - Keys must appear in ascending order (according to the key's type).// - Every non-leaf node contains at least 1 element (has at least 2 children).// - Every non-root node contains at least MIN_LEN elements.// An empty map is represented either by the absence of a root node or by a// root node that is an empty leaf.take_mut/// This replaces the value behind the `v` unique reference by calling the/// relevant function./// If a panic occurs in the `change` closure, the entire process will be aborted.// keep as illustration and for future use/// relevant function, and returns a result obtained along the way.Peeked/// Core of an iterator that merges the output of two strictly ascending iterators,/// for instance a union or a symmetric difference./// Benchmarks faster than wrapping both iterators in a Peekable,/// probably because we can afford to impose a FusedIterator bound./// Creates a new core for an iterator merging a pair of sources./// Returns the next pair of items stemming from the pair of sources/// being merged. If both returned options contain a value, that value/// is equal and occurs in both sources. If one of the returned options/// contains a value, that value doesn't occur in the other source (or/// the sources are not strictly ascending). If neither returned option/// contains a value, iteration has finished and subsequent calls will/// return the same empty pair.lens/// Returns a pair of upper bounds for the `size_hint` of the final iterator.BorrowType// `front` and `back` are always both `None` or both `Some`./// Temporarily takes out another, immutable equivalent of the same range.next_checkednext_back_checkedperform_next_checked/// If possible, extract some result from the following KV and move to the edge beyond it.perform_next_back_checked/// If possible, extract some result from the preceding KV and move to the edge beyond it.LazyLeafHandle// not yet descendeddeallocating_next_uncheckeddeallocating_next_back_uncheckeddeallocating_endinit_frontinit_backfind_leaf_edges_spanning_range/// Finds the distinct leaf edges delimiting a specified range in a tree./// If such distinct edges exist, returns them in ascending order, meaning/// that a non-zero number of calls to `next_unchecked` on the `front` of/// the result and/or calls to `next_back_unchecked` on the `back` of the/// result will eventually reach the same edge./// If there are no such edges, i.e., if the tree contains no key within/// the range, returns an empty `front` and `back`./// Unless `BorrowType` is `Immut`, do not use the handles to visit the same/// KV twice.full_rangerange_search/// Finds the pair of leaf edges delimiting a specific range in a tree./// The result is meaningful only if the tree is ordered by key, like the tree/// in a `BTreeMap` is./// Finds the pair of leaf edges delimiting an entire tree./// Splits a unique reference into a pair of leaf edges delimiting a specified range./// The result are non-unique references allowing (some) mutation, which must be used/// carefully./// Do not use the duplicate handles to visit the same KV twice./// Splits a unique reference into a pair of leaf edges delimiting the full range of the tree./// The results are non-unique references allowing mutation (of values only), so must be used/// The results are non-unique references allowing massively destructive mutation, so must be/// used with the utmost care.next_kv/// Given a leaf edge handle, returns [`Result::Ok`] with a handle to the neighboring KV/// on the right side, which is either in the same leaf node or in an ancestor node./// If the leaf edge is the last one in the tree, returns [`Result::Err`] with the root node.next_back_kv/// on the left side, which is either in the same leaf node or in an ancestor node./// If the leaf edge is the first one in the tree, returns [`Result::Err`] with the root node./// Given an internal edge handle, returns [`Result::Ok`] with a handle to the neighboring KV/// on the right side, which is either in the same internal node or in an ancestor node./// If the internal edge is the last one in the tree, returns [`Result::Err`] with the root node.deallocating_next/// Given a leaf edge handle into a dying tree, returns the next leaf edge/// on the right side, and the key-value pair in between, if they exist./// If the given edge is the last one in a leaf, this method deallocates/// the leaf, as well as any ancestor nodes whose last edge was reached./// This implies that if no more key-value pair follows, the entire tree/// will have been deallocated and there is nothing left to return./// - The given edge must not have been previously returned by counterpart///   `deallocating_next_back`./// - The returned KV handle is only valid to access the key and value,///   and only valid until the next call to a `deallocating_` method.deallocating_next_back/// on the left side, and the key-value pair in between, if they exist./// If the given edge is the first one in a leaf, this method deallocates/// the leaf, as well as any ancestor nodes whose first edge was reached.///   `deallocating_next`./// Deallocates a pile of nodes from the leaf up to the root./// This is the only way to deallocate the remainder of a tree after/// `deallocating_next` and `deallocating_next_back` have been nibbling at/// both sides of the tree, and have hit the same edge. As it is intended/// only to be called when all keys and values have been returned,/// no cleanup is done on any of the keys or values./// Moves the leaf edge handle to the next leaf edge and returns references to the/// key and value in between./// There must be another KV in the direction travelled./// Moves the leaf edge handle to the previous leaf edge and returns references to the/// Moves the leaf edge handle to the previous leaf and returns references to the/// Moves the leaf edge handle to the next leaf edge and returns the key and value/// in between, deallocating any node left behind while leaving the corresponding/// edge in its parent node dangling./// - There must be another KV in the direction travelled./// - That KV was not previously returned by counterpart///   `deallocating_next_back_unchecked` on any copy of the handles///   being used to traverse the tree./// The only safe way to proceed with the updated handle is to compare it, drop it,/// or call this method or counterpart `deallocating_next_back_unchecked` again./// Moves the leaf edge handle to the previous leaf edge and returns the key and value/// - That leaf edge was not previously returned by counterpart///   `deallocating_next_unchecked` on any copy of the handles/// or call this method or counterpart `deallocating_next_unchecked` again.first_leaf_edge/// Returns the leftmost leaf edge in or underneath a node - in other words, the edge/// you need first when navigating forward (or last when navigating backward).last_leaf_edge/// Returns the rightmost leaf edge in or underneath a node - in other words, the edge/// you need last when navigating forward (or first when navigating backward).InternalKVvisit_nodes_in_order/// Visits leaf nodes and internal KVs in order of ascending keys, and also/// visits internal nodes as a whole in a depth first order, meaning that/// internal nodes precede their individual KVs and their child nodes.calc_length/// Calculates the number of elements in a (sub)tree.next_leaf_edge/// Returns the leaf edge closest to a KV for forward navigation.next_back_leaf_edge/// Returns the leaf edge closest to a KV for backward navigation./// Returns the leaf edge corresponding to the first point at which the/// given bound is true./// Returns the leaf edge corresponding to the last point at which theassert_back_pointers// Asserts that the back pointer in each reachable node points to its parent.// Renders a multi-line display of the keys in order and in tree hierarchy,// picturing the tree growing sideways from its root on the left to its// leaves on the right.test_splitpointtest_partial_eq// We'd like to run Miri with layout randomizationMIN_LEN_AFTER_SPLITKV_IDX_CENTEREDGE_IDX_LEFT_OF_CENTEREDGE_IDX_RIGHT_OF_CENTERInternalNode/// We want to be covariant in `K` and `V`./// This node's index into the parent node's `edges` array./// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`./// This is only guaranteed to be initialized when `parent` is non-null./// The number of keys and values this node stores./// The arrays storing the actual data of the node. Only the first `len` elements of each/// array are initialized and valid.LeafNode/// The underlying representation of leaf nodes and part of the representation of internal nodes./// Initializes a new `LeafNode` in-place./// The caller must ensure that `this` points to a (possibly uninitialized) `LeafNode`/// Creates a new boxed `LeafNode`.BoxedNode/// The pointers to the children of this node. `len + 1` of these are considered/// initialized and valid, except that near the end, while the tree is held/// through borrow type `Dying`, some of these pointers are dangling./// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden/// behind `BoxedNode`s to prevent dropping uninitialized keys and values. Any pointer to an/// `InternalNode` can be directly cast to a pointer to the underlying `LeafNode` portion of the/// node, allowing code to act on leaf and internal nodes generically without having to even check/// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`.// gdb_providers.py uses this type name for introspection./// Creates a new boxed `InternalNode`./// An invariant of internal nodes is that they have at least one/// initialized and valid edge. This function does not set up/// such an edge./// A managed, non-null pointer to a node. This is either an owned pointer to/// `LeafNode<K, V>` or an owned pointer to `InternalNode<K, V>`./// However, `BoxedNode` contains no information as to which of the two types/// of nodes it actually contains, and, partially due to this lack of information,/// is not a separate type and has no destructor./// The number of levels that the node and the level of leaves are apart, a/// constant of the node that cannot be entirely described by `Type`, and that/// the node itself does not store. We only need to store the height of the root/// node, and derive every other node's height from it./// Must be zero if `Type` is `Leaf` and non-zero if `Type` is `Internal`./// The pointer to the leaf or internal node. The definition of `InternalNode`/// ensures that the pointer is valid either way.// N.B. `NodeRef` is always covariant in `K` and `V`, even when the `BorrowType`// is `Mut`. This is technically wrong, but cannot result in any unsafety due to// internal use of `NodeRef` because we stay completely generic over `K` and `V`.// However, whenever a public type wraps `NodeRef`, make sure that it has the// correct variance./// A reference to a node./// This type has a number of parameters that control how it acts:/// - `BorrowType`: A dummy type that describes the kind of borrow and carries a lifetime.///    - When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`.///    - When this is `ValMut<'a>`, the `NodeRef` acts roughly like `&'a Node`///      with respect to keys and tree structure, but also allows many///      mutable references to values throughout the tree to coexist.///    - When this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`,///      although insert methods allow a mutable pointer to a value to coexist.///    - When this is `Owned`, the `NodeRef` acts roughly like `Box<Node>`,///      but does not have a destructor, and must be cleaned up manually.///    - When this is `Dying`, the `NodeRef` still acts roughly like `Box<Node>`,///      but has methods to destroy the tree bit by bit, and ordinary methods,///      while not marked as unsafe to call, can invoke UB if called incorrectly.///   Since any `NodeRef` allows navigating through the tree, `BorrowType`///   effectively applies to the entire tree, not just to the node itself./// - `K` and `V`: These are the types of keys and values stored in the nodes./// - `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is///   `Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the///   `NodeRef` points to an internal node, and when this is `LeafOrInternal` the///   `NodeRef` could be pointing to either type of node.///   `Type` is named `NodeType` when used outside `NodeRef`./// Both `BorrowType` and `NodeType` restrict what methods we implement, to/// exploit static type safety. There are limitations in the way we can apply/// such restrictions:/// - For each type parameter, we can only define a method either generically///   or for one particular type. For example, we cannot define a method like///   `into_kv` generically for all `BorrowType`, or once for all types that///   carry a lifetime, because we want it to return `&'a` references.///   Therefore, we define it only for the least powerful type `Immut<'a>`./// - We cannot get implicit coercion from say `Mut<'a>` to `Immut<'a>`.///   Therefore, we have to explicitly call `reborrow` on a more powerful///   `NodeRef` in order to reach a method like `into_kv`./// All methods on `NodeRef` that return some kind of reference, either:/// - Take `self` by value, and return the lifetime carried by `BorrowType`.///   Sometimes, to invoke such a method, we need to call `reborrow_mut`./// - Take `self` by reference, and (implicitly) return that reference's///   lifetime, instead of the lifetime carried by `BorrowType`. That way,///   the borrow checker guarantees that the `NodeRef` remains borrowed as long///   as the returned reference is used.///   The methods supporting insert bend this rule by returning a raw pointer,///   i.e., a reference without any lifetime./// The root node of an owned tree./// Note that this does not have a destructor, and must be cleaned up manually.new_leaffrom_new_leaf/// Creates a new internal (height > 0) `NodeRef`from_new_internal/// Creates a new internal (height > 0) `NodeRef` from an existing internal nodefrom_internal/// Unpack a node reference that was packed as `NodeRef::parent`.as_internal_ptr/// Exposes the data of an internal node./// Returns a raw ptr to avoid invalidating other references to this node.as_internal_mut/// Borrows exclusive access to the data of an internal node./// Finds the length of the node. This is the number of keys or values./// The number of edges is `len() + 1`./// Note that, despite being safe, calling this function can have the side effect/// of invalidating mutable references that unsafe code has created./// Returns the number of levels that the node and leaves are apart. Zero/// height means the node is a leaf itself. If you picture trees with the/// root on top, the number says at which elevation the node appears./// If you picture trees with leaves on top, the number says how high/// the tree extends above the node./// Temporarily takes out another, immutable reference to the same node.as_leaf_ptr/// Exposes the leaf portion of any leaf or internal node.ascend/// Finds the parent of the current node. Returns `Ok(handle)` if the current/// node actually has a parent, where `handle` points to the edge of the parent/// that points to the current node. Returns `Err(self)` if the current node has/// no parent, giving back the original `NodeRef`./// The method name assumes you picture trees with the root node on top./// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should/// both, upon success, do nothing.last_edgefirst_kv/// Note that `self` must be nonempty.last_kv/// Could be a public implementation of PartialEq, but only used in this module.into_leaf/// Exposes the leaf portion of any leaf or internal node in an immutable tree./// Borrows a view into the keys stored in the node.deallocate_and_ascend/// Similar to `ascend`, gets a reference to a node's parent node, but also/// deallocates the current node in the process. This is unsafe because the/// current node will still be accessible despite being deallocated.reborrow_mut/// Temporarily takes out another mutable reference to the same node. Beware, as/// this method is very dangerous, doubly so since it might not immediately appear/// dangerous./// Because mutable pointers can roam anywhere around the tree, the returned/// pointer can easily be used to make the original pointer dangling, out of/// bounds, or invalid under stacked borrow rules.// FIXME(@gereeter) consider adding yet another type parameter to `NodeRef`// that restricts the use of navigation methods on reborrowed pointers,// preventing this unsafety.as_leaf_mut/// Borrows exclusive access to the leaf portion of a leaf or internal node.into_leaf_mut/// Offers exclusive access to the leaf portion of a leaf or internal node.dormantDormantMut/// Returns a dormant copy of this node with its lifetime erased which can/// be reawakened later.as_leaf_dying/// Borrows exclusive access to the leaf portion of a dying leaf or internal node.key_area_mut/// Borrows exclusive access to an element of the key storage area./// `index` is in bounds of 0..CAPACITYval_area_mut/// Borrows exclusive access to an element or slice of the node's value storage area.edge_area_mut/// Borrows exclusive access to an element or slice of the node's storage area for edge contents./// `index` is in bounds of 0..CAPACITY + 1into_key_val_mut_at/// - The node has more than `idx` initialized elements.len_mut/// Borrows exclusive access to the length of the node.correct_childrens_parent_links/// Every item returned by `range` is a valid edge index for the node.correct_all_childrens_parent_linksset_parent_link/// Sets the node's link to its parent edge,/// without invalidating other references to the node.clear_parent_link/// Clears the root's link to its parent edge./// Returns a new owned tree, with its own root node that is initially empty.push_internal_level/// Adds a new internal node with a single edge pointing to the previous root node,/// make that new node the root node, and return it. This increases the height by 1/// and is the opposite of `pop_internal_level`.pop_internal_level/// Removes the internal root node, using its first child as the new root node./// As it is intended only to be called when the root node has only one child,/// no cleanup is done on any of the keys, values and other children./// This decreases the height by 1 and is the opposite of `push_internal_level`./// Does not invalidate any handles or references pointing into the subtree/// rooted at the first child of `self`./// Panics if there is no internal level, i.e., if the root node is a leaf./// Mutably borrows the owned root node. Unlike `reborrow_mut`, this is safe/// because the return value cannot be used to destroy the root, and there/// cannot be other references to the tree.borrow_valmut/// Slightly mutably borrows the owned root node.into_dying/// Irreversibly transitions to a reference that permits traversal and offers/// destructive methods and little else.push_with_handle/// Adds a key-value pair to the end of the node, and returns/// a handle to the inserted value./// The returned handle has an unbound lifetime./// the mutable reference of the inserted value./// Adds a key-value pair, and an edge to go to the right of that pair,/// to the end of the node.forget_type/// Removes any static information asserting that this node is a `Leaf` node./// Removes any static information asserting that this node is an `Internal` node./// Checks whether a node is an `Internal` node or a `Leaf` node.cast_to_leaf_unchecked/// Unsafely asserts to the compiler the static information that this node is a `Leaf`.cast_to_internal_unchecked/// Unsafely asserts to the compiler the static information that this node is an `Internal`./// A reference to a specific key-value pair or edge within a node. The `Node` parameter/// must be a `NodeRef`, while the `Type` can either be `KV` (signifying a handle on a key-value/// pair) or `Edge` (signifying a handle on an edge)./// Note that even `Leaf` nodes can have `Edge` handles. Instead of representing a pointer to/// a child node, these represent the spaces where child pointers would go between the key-value/// pairs. For example, in a node with length 2, there would be 3 possible edge locations - one/// to the left of the node, one between the two pairs, and one at the right of the node.// We don't need the full generality of `#[derive(Clone)]`, as the only time `Node` will be// `Clone`able is when it is an immutable reference and therefore `Copy`.into_node/// Retrieves the node that contains the edge or key-value pair this handle points to./// Returns the position of this handle in the node.new_kv/// Creates a new handle to a key-value pair in `node`./// Unsafe because the caller must ensure that `idx < node.len()`.left_edgeright_edge/// Temporarily takes out another immutable handle on the same location./// Temporarily takes out another mutable handle on the same location. Beware, as/// For details, see `NodeRef::reborrow_mut`./// Returns a dormant copy of this handle which can be reawakened later./// See `DormantMutRef` for more details.new_edge/// Creates a new handle to an edge in `node`./// Unsafe because the caller must ensure that `idx <= node.len()`.left_kvright_kvsplitpoint/// Given an edge index where we want to insert into a node filled to capacity,/// computes a sensible KV index of a split point and where to perform the insertion./// The goal of the split point is for its key and value to end up in a parent node;/// the keys, values and edges to the left of the split point become the left child;/// the keys, values and edges to the right of the split point become the right child.insert_fit/// Inserts a new key-value pair between the key-value pairs to the right and left of/// this edge. This method assumes that there is enough space in the node for the new/// pair to fit.SplitResult/// this edge. This method splits the node if there isn't enough room./// Returns a dormant handle to the inserted node which can be reawakened/// once splitting is complete.correct_parent_link/// Fixes the parent pointer and index in the child node that this edge/// links to. This is useful when the ordering of edges has been changed,/// Inserts a new key-value pair and an edge that will go to the right of that new pair/// between this edge and the key-value pair to the right of this edge. This method assumes/// that there is enough space in the node for the new pair to fit./// between this edge and the key-value pair to the right of this edge. This method splits/// the node if there isn't enough room.insert_recursing/// this edge. This method splits the node if there isn't enough room, and tries to/// insert the split off portion into the parent node recursively, until the root is reached./// If the returned result is some `SplitResult`, the `left` field will be the root node./// The returned pointer points to the inserted value, which in the case of `SplitResult`/// is in the `left` or `right` tree.descend/// Finds the node pointed to by this edge.into_kvinto_val_mutinto_kv_mutinto_kv_valmutkv_mutreplace_kv/// Replaces the key and value that the KV handle refers to.into_key_val/// Extracts the key and value that the KV handle refers to./// The node that the handle refers to must not yet have been deallocated.drop_key_val/// Drops the key and value that the KV handle refers to.split_leaf_data/// Helps implementations of `split` for a particular `NodeType`,/// by taking care of leaf data./// Splits the underlying node into three parts:/// - The node is truncated to only contain the key-value pairs to the left of///   this handle./// - The key and value pointed to by this handle are extracted./// - All the key-value pairs to the right of this handle are put into a newly///   allocated node./// Removes the key-value pair pointed to by this handle and returns it, along with the edge/// that the key-value pair collapsed into./// - The node is truncated to only contain the edges and key-value pairs to the///   left of this handle./// - All the edges and key-value pairs to the right of this handle are put into///   a newly allocated node.left_childright_childBalancingContext/// Represents a session for evaluating and performing a balancing operation/// around an internal key-value pair.consider_for_balancingchoose_parent_kv/// Chooses a balancing context involving the node as a child, thus between/// the KV immediately to the left or to the right in the parent node./// Returns an `Err` if there is no parent./// Panics if the parent is empty./// Prefers the left side, to be optimal if the given node is somehow/// underfull, meaning here only that it has fewer elements than its left/// sibling and than its right sibling, if they exist. In that case,/// merging with the left sibling is faster, since we only need to move/// the node's N elements, instead of shifting them to the right and moving/// more than N elements in front. Stealing from the left sibling is also/// typically faster, since we only need to shift the node's N elements to/// the right, instead of shifting at least N of the sibling's elements to/// the left.left_child_lenright_child_leninto_left_childinto_right_childcan_merge/// Returns whether merging is possible, i.e., whether there is enough room/// in a node to combine the central KV with both adjacent child nodes.do_merge/// Performs a merge and lets a closure decide what to return.merge_tracking_parent/// Merges the parent's key-value pair and both adjacent child nodes into/// the left child node and returns the shrunk parent node./// Panics unless we `.can_merge()`.merge_tracking_child/// the left child node and returns that child node.merge_tracking_child_edge/// the left child node and returns the edge handle in that child node/// where the tracked child edge ended up,steal_left/// Removes a key-value pair from the left child and places it in the key-value storage/// of the parent, while pushing the old parent key-value pair into the right child./// Returns a handle to the edge in the right child corresponding to where the original/// edge specified by `track_right_edge_idx` ended up.steal_right/// Removes a key-value pair from the right child and places it in the key-value storage/// of the parent, while pushing the old parent key-value pair onto the left child./// Returns a handle to the edge in the left child specified by `track_left_edge_idx`,/// which didn't move.bulk_steal_left/// This does stealing similar to `steal_left` but steals multiple elements at once.bulk_steal_right/// The symmetric clone of `bulk_steal_left`.forget_node_type/// Checks whether the underlying node is an `Internal` node or a `Leaf` node./// Unsafely asserts to the compiler the static information that the handle's node is a `Leaf`.move_suffix/// Move the suffix after `self` from one node to another one. `right` must be empty./// The first edge of `right` remains unchanged.// Altered node in existing tree with elements and edges that belong to the left of `kv`.// Some key and value that existed before and were split off, to be inserted elsewhere.// Owned, unattached, new node with elements and edges that belong to the right of `kv`./// Result of insertion, when a node needed to expand beyond its capacity.TRAVERSAL_PERMIT/// If node references of this borrow type allow traversing to other/// nodes in the tree, this constant is set to `true`. It can be used/// for a compile-time assertion./// Reject traversal, because it isn't needed. Instead traversal/// happens using the result of `borrow_mut`./// By disabling traversal, and only creating new references to roots,/// we know that every reference of the `Owned` type is to a root node.slice_insert/// Inserts a value into a slice of initialized elements followed by one uninitialized element./// The slice has more than `idx` elements.slice_remove/// Removes and returns a value from a slice of all initialized elements, leaving behind one/// trailing uninitialized element.slice_shl/// Shifts the elements in a slice `distance` positions to the left./// The slice has at least `distance` elements.slice_shr/// Shifts the elements in a slice `distance` positions to the right.move_to_slice/// Moves all values from a slice of initialized elements to a slice/// of uninitialized elements, leaving behind `src` as all uninitialized./// Works like `dst.copy_from_slice(src)` but does not require `T` to be `Copy`.// This is an attempt at an implementation following the ideal// struct BTreeMap<K, V> {//     height: usize,//     root: Option<Box<Node<K, V, height>>>// struct Node<K, V, height: usize> {//     keys: [K; 2 * B - 1],//     vals: [V; 2 * B - 1],//     edges: [if height > 0 { Box<Node<K, V, height - 1>> } else { () }; 2 * B],//     parent: Option<(NonNull<Node<K, V, height + 1>>, u16)>,//     len: u16,// Since Rust doesn't actually have dependent types and polymorphic recursion,// we make do with lots of unsafety.// A major goal of this module is to avoid complexity by treating the tree as a generic (if// weirdly shaped) container and avoiding dealing with most of the B-Tree invariants. As such,// this module doesn't care whether the entries are sorted, which nodes can be underfull, or// even what underfull means. However, we do rely on a few invariants:// - Trees must have uniform depth/height. This means that every path down to a leaf from a//   given node has exactly the same length.// - A node of length `n` has `n` keys, `n` values, and `n + 1` edges.//   This implies that even an empty node has at least one edge.//   For a leaf node, "having an edge" only means we can identify a position in the node,//   since leaf edges are empty and need no data representation. In an internal node,//   an edge both identifies a position and contains a pointer to a child node.remove_kv_tracking/// Removes a key-value pair from the tree, and returns that pair, as well as/// the leaf edge corresponding to that former pair. It's possible this empties/// a root node that is internal, which the caller should pop from the map/// holding the tree. The caller should also decrement the map's length.remove_leaf_kvremove_internal_kv/// An inclusive bound to look for, just like `Bound::Included(T)`./// An exclusive bound to look for, just like `Bound::Excluded(T)`.AllIncluded/// An unconditional inclusive bound, just like `Bound::Unbounded`.AllExcluded/// An unconditional exclusive bound.FoundTypeGoDownTypeGoDownIndexResultsearch_tree/// Looks up a given key in a (sub)tree headed by the node, recursively./// Returns a `Found` with the handle of the matching KV, if any. Otherwise,/// returns a `GoDown` with the handle of the leaf edge where the key belongs.search_tree_for_bifurcation/// Descends to the nearest node where the edge matching the lower bound/// of the range is different from the edge matching the upper bound, i.e.,/// the nearest node that has at least one key contained in the range./// If found, returns an `Ok` with that node, the strictly ascending pair of/// edge indices in the node delimiting the range, and the corresponding/// pair of bounds for continuing the search in the child nodes, in case/// the node is internal./// If not found, returns an `Err` with the leaf edge matching the entire/// As a diagnostic service, panics if the range specifies impossible bounds./// The result is meaningful only if the tree is ordered by key.find_lower_bound_edge/// Finds an edge in the node delimiting the lower bound of a range./// Also returns the lower bound to be used for continuing the search in/// the matching child node, if `self` is an internal node.find_upper_bound_edge/// Clone of `find_lower_bound_edge` for the upper bound.search_node/// Looks up a given key in the node, without recursion./// returns a `GoDown` with the handle of the edge where the key might be found/// (if the node is internal) or where the key can be inserted.find_key_index/// Returns either the KV index in the node at which the key (or an equivalent)/// exists, or the edge index where the key belongs, starting from a particular index./// `start_index` must be a valid edge index for the node.find_lower_bound_index/// Finds an edge index in the node delimiting the lower bound of a range.find_upper_bound_index/// Mirror image of `find_lower_bound_index` for the upper bound,/// with an additional parameter to skip part of the key array./// #![feature(btree_set_entry)]/// use std::collections::btree_set::{Entry, BTreeSet};/// let mut set = BTreeSet::from(["a", "b"]);/// let mut set = BTreeSet::new();/// This `enum` is constructed from the [`entry`] method on [`BTreeSet`]./// [`BTreeSet`]: super::BTreeSet/// [`entry`]: super::BTreeSet::entry/// use std::collections::btree_set::BTreeSet;/// let entry = set.entry("a");/// let _raw_o = entry.insert();/// println!("Our BTreeSet: {:?}", set);/// assert!(set.iter().eq(&["a", "b", "c", "d", "e"]));/// A view into an occupied entry in a `BTreeSet`./// let _entry_o = set.entry("a").insert();/// A view into a vacant entry in a `BTreeSet`./// let mut set = BTreeSet::<&str>::new();/// let entry_v = match set.entry("a") {/// use std::collections::btree_set::Entry;test_clone_eqtest_intersection_size_hinttest_difference_size_hinttest_symmetric_difference_size_hinttest_union_size_hinttest_is_disjoint// Only tests the simple function definition with respect to intersectiontest_is_subset// Also implicitly tests the trivial function definition of is_supersettest_is_supersettest_extract_if_drop_panic_leaktest_extract_if_pred_panic_leaktest_ziptest_recoveryassert_derives// Check that the member-like functions conditionally provided by #[derive()]// are not overridden by genuine member functions with a different signature.test_first_last// Unlike the function with the same name in map/tests, returns no values.// Which also means it returns different predetermined pseudo-random keys,// and the test cases using this function explore slightly different trees./// An ordered set based on a B-Tree./// See [`BTreeMap`]'s documentation for a detailed discussion of this collection's performance/// benefits and drawbacks./// It is a logic error for an item to be modified in such a way that the item's ordering relative/// to any other item, as determined by the [`Ord`] trait, changes while it is in the set. This is/// `BTreeSet` that observed the logic error and not result in undefined behavior. This could/// Iterators returned by [`BTreeSet::iter`] and [`BTreeSet::into_iter`] produce their items in order, and take worst-case/// logarithmic and amortized constant time per item returned./// // would be `BTreeSet<&str>` in this example)./// let mut books = BTreeSet::new();/// books.insert("A Dance With Dragons");/// books.insert("To Kill a Mockingbird");/// books.insert("The Odyssey");/// books.insert("The Great Gatsby");///     println!("{book}");/// A `BTreeSet` with a known list of items can be initialized from an array:/// let set = BTreeSet::from([1, 2, 3]);/// An iterator over the items of a `BTreeSet`./// This `struct` is created by the [`iter`] method on [`BTreeSet`]./// [`iter`]: BTreeSet::iter/// An owning iterator over the items of a `BTreeSet` in ascending order./// This `struct` is created by the [`into_iter`] method on [`BTreeSet`]/// [`into_iter`]: BTreeSet#method.into_iter/// An iterator over a sub-range of items in a `BTreeSet`./// This `struct` is created by the [`range`] method on [`BTreeSet`]./// [`range`]: BTreeSet::range"this returns the difference as an iterator, \
              without modifying either input set"DifferenceInner/// A lazy iterator producing elements in the difference of `BTreeSet`s./// This `struct` is created by the [`difference`] method on [`BTreeSet`]./// [`difference`]: BTreeSet::differenceself_iter// iterate all of `self` and some of `other`, spotting matches along the wayother_iterStitch// iterate `self`, look up in `other`other_set// simply produce all elements in `self`// Explicit Debug impl necessary because of issue #26925/// A lazy iterator producing elements in the symmetric difference of `BTreeSet`s./// [`BTreeSet`]. See its documentation for more./// [`symmetric_difference`]: BTreeSet::symmetric_difference"this returns the intersection as an iterator, \
              without modifying either input set"IntersectionInner/// A lazy iterator producing elements in the intersection of `BTreeSet`s./// This `struct` is created by the [`intersection`] method on [`BTreeSet`]./// [`intersection`]: BTreeSet::intersection// iterate similarly sized sets jointly, spotting matches along the waysmall_iter// iterate a small set, look up in the large setlarge_set// return a specific element or emptiness"this returns the union as an iterator, \
              without modifying either input set"/// A lazy iterator producing elements in the union of `BTreeSet`s./// This `struct` is created by the [`union`] method on [`BTreeSet`]./// [`union`]: BTreeSet::unionITER_PERFORMANCE_TIPPING_SIZE_DIFF// This constant is used by functions that compare two sets.// It estimates the relative size at which searching performs better// than iterating, based on the benchmarks in// https://github.com/ssomers/rust_bench_btreeset_intersection.// It's used to divide rather than multiply sizes, to rule out overflow,// and it's a power of two to make that division cheap./// Makes a new, empty `BTreeSet`./// # #![allow(unused_mut)]/// let mut set: BTreeSet<i32> = BTreeSet::new();/// Makes a new `BTreeSet` with a reasonable choice of B./// let mut set: BTreeSet<i32> = BTreeSet::new_in(Global);/// Constructs a double-ended iterator over a sub-range of elements in the set./// set.insert(3);/// set.insert(5);/// set.insert(8);/// for &elem in set.range((Included(&4), Included(&8))) {///     println!("{elem}");/// assert_eq!(Some(&5), set.range(4..).next());/// Visits the elements representing the difference,/// i.e., the elements that are in `self` but not in `other`,/// let mut a = BTreeSet::new();/// a.insert(1);/// a.insert(2);/// let mut b = BTreeSet::new();/// b.insert(2);/// b.insert(3);/// let diff: Vec<_> = a.difference(&b).cloned().collect();/// assert_eq!(diff, [1]);/// Visits the elements representing the symmetric difference,/// i.e., the elements that are in `self` or in `other` but not in both,/// let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect();/// assert_eq!(sym_diff, [1, 3]);/// Visits the elements representing the intersection,/// i.e., the elements that are both in `self` and `other`,/// let intersection: Vec<_> = a.intersection(&b).cloned().collect();/// assert_eq!(intersection, [2]);/// Visits the elements representing the union,/// i.e., all the elements in `self` or `other`, without duplicates,/// let union: Vec<_> = a.union(&b).cloned().collect();/// assert_eq!(union, [1, 2]);/// Clears the set, removing all elements./// let mut v = BTreeSet::new();/// Returns `true` if the set contains an element equal to the value./// The value may be any borrowed form of the set's element type,/// but the ordering on the borrowed form *must* match the/// ordering on the element type./// Returns a reference to the element in the set, if any, that is equal to/// let a = BTreeSet::from([1, 2, 3]);/// i.e., `other` contains at least all the elements in `self`./// let sup = BTreeSet::from([1, 2, 3]);/// i.e., `self` contains at least all the elements in `other`./// let sub = BTreeSet::from([1, 2]);/// Returns a reference to the first element in the set, if any./// This element is always the minimum of all elements in the set./// assert_eq!(set.first(), None);/// assert_eq!(set.first(), Some(&1));/// Returns a reference to the last element in the set, if any./// This element is always the maximum of all elements in the set./// assert_eq!(set.last(), None);/// assert_eq!(set.last(), Some(&1));/// assert_eq!(set.last(), Some(&2));/// Removes the first element from the set and returns it, if any./// The first element is always the minimum element in the set./// while let Some(n) = set.pop_first() {/// Removes the last element from the set and returns it, if any./// The last element is always the maximum element in the set./// while let Some(n) = set.pop_last() {/// Returns whether the value was newly inserted. That is:/// - If the set did not previously contain an equal value, `true` is/// - If the set already contained an equal value, `false` is returned, and///   the entry is not updated./// Adds a value to the set, replacing the existing element, if any, that is/// equal to the value. Returns the replaced element./// let mut set = BTreeSet::from([1, 2, 3]);/// let mut set: BTreeSet<String> = ["cat", "dog", "horse"]/// use std::collections::btree_set::Entry::*;/// let mut singles = BTreeSet::new();/// let mut dupes = BTreeSet::new();/// If the set contains an element equal to the value, removes it from the/// set and drops it. Returns whether such an element was present./// Removes and returns the element in the set, if any, that is equal to/// In other words, remove all elements `e` for which `f(&e)` returns `false`./// The elements are visited in ascending order./// let mut set = BTreeSet::from([1, 2, 3, 4, 5, 6]);/// // Keep only the even numbers./// assert!(set.iter().eq([2, 4, 6].iter()));/// a.insert(3);/// b.insert(5);/// assert!(a.contains(&1));/// assert!(a.contains(&2));/// assert!(a.contains(&3));/// assert!(a.contains(&4));/// assert!(a.contains(&5));/// Splits the collection into two at the value. Returns a new collection/// with all elements greater than or equal to the value./// a.insert(17);/// a.insert(41);/// assert!(b.contains(&3));/// assert!(b.contains(&17));/// assert!(b.contains(&41));/// Creates an iterator that visits elements in the specified range in ascending order and/// uses a closure to determine if an element should be removed./// If the closure returns `true`, the element is removed from the set and/// in the set and will not be yielded./// [`retain`]: BTreeSet::retain/// // Splitting a set into even and odd values, reusing the original set:/// let mut set: BTreeSet<i32> = (0..8).collect();/// let evens: BTreeSet<_> = set.extract_if(.., |v| v % 2 == 0).collect();/// let odds = set;/// assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![0, 2, 4, 6]);/// assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 7]);/// // Splitting a set into low and high halves, reusing the original set:/// let low: BTreeSet<_> = set.extract_if(0..4, |_v| true).collect();/// let high = set;/// assert_eq!(low.into_iter().collect::<Vec<_>>(), [0, 1, 2, 3]);/// assert_eq!(high.into_iter().collect::<Vec<_>>(), [4, 5, 6, 7]);/// Gets an iterator that visits the elements in the `BTreeSet` in ascending/// let set = BTreeSet::from([3, 1, 2]);/// let mut set_iter = set.iter();/// assert_eq!(set_iter.next(), Some(&1));/// assert_eq!(set_iter.next(), Some(&2));/// assert_eq!(set_iter.next(), Some(&3));/// assert_eq!(set_iter.next(), None);/// Returns a [`Cursor`] pointing at the gap before the smallest element/// gap before the smallest element greater than or equal to `x`./// gap before the smallest element greater than `x`./// gap before the smallest element in the set./// let set = BTreeSet::from([1, 2, 3, 4]);/// let cursor = set.lower_bound(Bound::Included(&2));/// assert_eq!(cursor.peek_prev(), Some(&1));/// assert_eq!(cursor.peek_next(), Some(&2));/// let cursor = set.lower_bound(Bound::Excluded(&2));/// assert_eq!(cursor.peek_prev(), Some(&2));/// assert_eq!(cursor.peek_next(), Some(&3));/// let cursor = set.lower_bound(Bound::Unbounded);/// assert_eq!(cursor.peek_next(), Some(&1));/// Returns a [`CursorMut`] pointing at the gap before the smallest element/// let mut set = BTreeSet::from([1, 2, 3, 4]);/// let mut cursor = set.lower_bound_mut(Bound::Included(&2));/// let mut cursor = set.lower_bound_mut(Bound::Excluded(&2));/// let mut cursor = set.lower_bound_mut(Bound::Unbounded);/// Returns a [`Cursor`] pointing at the gap after the greatest element/// gap after the greatest element smaller than or equal to `x`./// gap after the greatest element smaller than `x`./// gap after the greatest element in the set./// let cursor = set.upper_bound(Bound::Included(&3));/// assert_eq!(cursor.peek_prev(), Some(&3));/// assert_eq!(cursor.peek_next(), Some(&4));/// let cursor = set.upper_bound(Bound::Excluded(&3));/// let cursor = set.upper_bound(Bound::Unbounded);/// assert_eq!(cursor.peek_prev(), Some(&4));/// Returns a [`CursorMut`] pointing at the gap after the greatest element/// let mut cursor = set.upper_bound_mut(Bound::Included(&3));/// let mut cursor = set.upper_bound_mut(Bound::Excluded(&3));/// let mut cursor = set.upper_bound_mut(Bound::Unbounded);from_sorted_iter/// Converts a `[T; N]` into a `BTreeSet<T>`./// If the array contains any equal values,/// all but one will be dropped./// let set1 = BTreeSet::from([1, 2, 3, 4]);/// let set2: BTreeSet<_> = [1, 2, 3, 4].into();/// Gets an iterator for moving out the `BTreeSet`'s contents in ascending order./// let v: Vec<_> = set.into_iter().collect();/// assert_eq!(v, [1, 2, 3, 4]);/// An iterator produced by calling `extract_if` on BTreeSet./// Creates an empty `BTreeSet`./// Returns the difference of `self` and `rhs` as a new `BTreeSet<T>`./// let b = BTreeSet::from([3, 4, 5]);/// let result = &a - &b;/// assert_eq!(result, BTreeSet::from([1, 2]));/// Returns the symmetric difference of `self` and `rhs` as a new `BTreeSet<T>`./// let b = BTreeSet::from([2, 3, 4]);/// let result = &a ^ &b;/// assert_eq!(result, BTreeSet::from([1, 4]));/// Returns the intersection of `self` and `rhs` as a new `BTreeSet<T>`./// let result = &a & &b;/// assert_eq!(result, BTreeSet::from([2, 3]));/// Returns the union of `self` and `rhs` as a new `BTreeSet<T>`./// let result = &a | &b;/// assert_eq!(result, BTreeSet::from([1, 2, 3, 4, 5]));/// Creates an empty `btree_set::Iter`./// # use std::collections::btree_set;/// let iter: btree_set::Iter<'_, u8> = Default::default();/// Creates an empty `btree_set::IntoIter`./// let iter: btree_set::IntoIter<u8> = Default::default();/// Creates an empty `btree_set::Range`./// let iter: btree_set::Range<'_, u8> = Default::default();/// A cursor over a `BTreeSet`./// Cursors always point to a gap between two elements in the set, and can/// A `Cursor` is created with the [`BTreeSet::lower_bound`] and [`BTreeSet::upper_bound`] methods./// A cursor over a `BTreeSet` with editing operations./// safely mutate the set during iteration. This is because the lifetime of its yielded/// A `CursorMut` is created with the [`BTreeSet::lower_bound_mut`] and [`BTreeSet::upper_bound_mut`]/// A cursor over a `BTreeSet` with editing operations, and which allows/// mutating elements./// references is tied to its own lifetime, instead of just the underlying set. This means/// Since this cursor allows mutating elements, you must ensure that the/// `BTreeSet` invariants are maintained. Specifically:/// * The newly inserted element must be unique in the tree./// * All elements in the tree must remain in sorted order./// Advances the cursor to the next gap, returning the element that it/// moved over./// If the cursor is already at the end of the set then `None` is returned/// Advances the cursor to the previous gap, returning the element that it/// If the cursor is already at the start of the set then `None` is returned/// Returns a reference to next element without moving the cursor./// If the cursor is at the end of the set then `None` is returned/// Returns a reference to the previous element without moving the cursor./// If the cursor is at the start of the set then `None` is returned./// Returns a reference to the next element without moving the cursor./// If the cursor is at the end of the set then `None` is returned./// elements in the tree./// Advances the cursor to the next gap, returning the  element that it/// Inserts a new element into the set in the gap that the/// You must ensure that the `BTreeSet` invariants are maintained./// If the inserted element is not greater than the element before the/// cursor (if any), or if it not less than the element after the cursor (if/// any), then an [`UnorderedKeyError`] is returned since this would/// invalidate the [`Ord`] invariant between the elements of the set./// Removes the next element from the `BTreeSet`./// Removes the preceding element from the `BTreeSet`./// Zero-Sized Type (ZST) for internal `BTreeSet` values./// Used instead of `()` to differentiate between:/// * `BTreeMap<T, ()>` (possible user-defined map)/// * `BTreeMap<T, SetValZST>` (internal set representation)is_set_valIsSetVal/// A trait to differentiate between `BTreeMap` and `BTreeSet` values./// Returns `true` only for type `SetValZST`, `false` for all other types (blanket implementation)./// `TypeId` requires a `'static` lifetime, use of this trait avoids that restriction./// [`TypeId`]: core::any::TypeId// Blanket implementation// Specializationcalc_split_length/// Calculates the length of both trees that result from splitting up/// a given number of distinct key-value pairs./// Split off a tree with key-value pairs at and after the given key./// The result is meaningful only if the tree is ordered by key,/// and if the ordering of `Q` corresponds to that of `K`./// If `self` respects all `BTreeMap` tree invariants, then both/// `self` and the returned tree will respect those invariants.new_pillar/// Creates a tree consisting of empty nodes.struct_with_counted_droplist_fromcheck_links/// Starting from the head of the LinkedList,/// follow the next links, while checking the prev links,/// and check that length equals the count of visited nodes.test_iterator_clonetest_iterator_double_endtest_rev_itertest_mut_itertest_iterator_mut_double_endtest_mut_rev_itertest_ord_nantest_26021test_split_off_2fuzz_testtest_fuzzextract_if_testdrain_to_empty_testtest_cursor_move_peektest_cursor_mut_inserttest_cursor_push_front_backtest_cursor_pop_front_backextract_if_emptyextract_if_zstextract_if_falseextract_if_trueextract_if_complexextract_if_drop_panic_leakextract_if_pred_panic_leaktest_drop_with_poptest_drop_cleartest_drop_panictest_allocatorSpecExtend/// A doubly-linked list with owned nodes./// The `LinkedList` allows pushing and popping elements at either end/// in constant time./// A `LinkedList` with a known list of items can be initialized from an array:/// use std::collections::LinkedList;/// let list = LinkedList::from([1, 2, 3]);/// NOTE: It is almost always better to use [`Vec`] or [`VecDeque`] because/// array-based containers are generally faster,/// more memory efficient, and make better use of CPU cache./// [`Vec`]: crate::vec::Vec/// [`VecDeque`]: super::vec_deque::VecDeque/// An iterator over the elements of a `LinkedList`./// This `struct` is created by [`LinkedList::iter()`]. See its/// A mutable iterator over the elements of a `LinkedList`./// This `struct` is created by [`LinkedList::iter_mut()`]. See its/// An owning iterator over the elements of a `LinkedList`./// This `struct` is created by the [`into_iter`] method on [`LinkedList`]/// [`into_iter`]: LinkedList::into_iterinto_elementpush_front_node/// Adds the given node to the front of the list./// `node` must point to a valid node that was boxed and leaked using the list's allocator./// This method takes ownership of the node, so the pointer should not be used again.pop_front_node/// Removes and returns the node at the front of the list.push_back_node/// Adds the given node to the back of the list.pop_back_node/// Removes and returns the node at the back of the list.unlink_node/// Unlinks the specified node from the current list./// Warning: this will not check that the provided node belongs to the current list./// This method takes care not to create mutable references to `element`, to/// maintain validity of aliasing pointers.splice_nodes/// Splices a series of nodes between two existing nodes./// Warning: this will not check that the provided node belongs to the two existing lists.detach_all_nodes/// Detaches all nodes from a linked list as a series of nodes.split_off_before_nodesplit_off_after_node// private methods/// Creates an empty `LinkedList<T>`./// Creates an empty `LinkedList`./// let list: LinkedList<u32> = LinkedList::new();/// Moves all elements from `other` to the end of the list./// This reuses all the nodes from `other` and moves them into `self`. After/// this operation, `other` becomes empty./// This operation should compute in *O*(1) time and *O*(1) memory./// let mut list1 = LinkedList::new();/// list1.push_back('a');/// let mut list2 = LinkedList::new();/// list2.push_back('b');/// list2.push_back('c');/// list1.append(&mut list2);/// let mut iter = list1.iter();/// assert_eq!(iter.next(), Some(&'a'));/// assert_eq!(iter.next(), Some(&'b'));/// assert_eq!(iter.next(), Some(&'c'));/// assert!(list2.is_empty());/// Constructs an empty `LinkedList<T, A>`./// let list: LinkedList<u32, _> = LinkedList::new_in(System);/// Provides a forward iterator./// let mut list: LinkedList<u32> = LinkedList::new();/// list.push_back(0);/// list.push_back(1);/// list.push_back(2);/// let mut iter = list.iter();/// assert_eq!(iter.next(), Some(&0));/// assert_eq!(iter.next(), Some(&1));/// assert_eq!(iter.next(), Some(&2));/// Provides a forward iterator with mutable references./// for element in list.iter_mut() {///     *element += 10;/// assert_eq!(iter.next(), Some(&10));/// assert_eq!(iter.next(), Some(&11));/// assert_eq!(iter.next(), Some(&12));cursor_front/// Provides a cursor at the front element./// The cursor is pointing to the "ghost" non-element if the list is empty.cursor_front_mut/// Provides a cursor with editing operations at the front element./// Provides a cursor at the back element.cursor_back_mut/// Provides a cursor with editing operations at the back element./// Returns `true` if the `LinkedList` is empty./// This operation should compute in *O*(1) time./// let mut dl = LinkedList::new();/// assert!(dl.is_empty());/// dl.push_front("foo");/// assert!(!dl.is_empty());/// Returns the length of the `LinkedList`./// dl.push_front(2);/// assert_eq!(dl.len(), 1);/// dl.push_front(1);/// assert_eq!(dl.len(), 2);/// dl.push_back(3);/// assert_eq!(dl.len(), 3);/// Removes all elements from the `LinkedList`./// This operation should compute in *O*(*n*) time./// assert_eq!(dl.front(), Some(&1));/// dl.clear();/// assert_eq!(dl.len(), 0);/// assert_eq!(dl.front(), None);/// Returns `true` if the `LinkedList` contains an element equal to the/// This operation should compute linearly in *O*(*n*) time./// assert_eq!(list.contains(&0), true);/// assert_eq!(list.contains(&10), false);/// Provides a reference to the front element, or `None` if the list is/// Provides a mutable reference to the front element, or `None` if the list/// match dl.front_mut() {///     None => {},///     Some(x) => *x = 5,/// assert_eq!(dl.front(), Some(&5));/// Provides a reference to the back element, or `None` if the list is/// assert_eq!(dl.back(), None);/// dl.push_back(1);/// assert_eq!(dl.back(), Some(&1));/// Provides a mutable reference to the back element, or `None` if the list/// match dl.back_mut() {/// assert_eq!(dl.back(), Some(&5));/// Adds an element to the front of the list./// assert_eq!(dl.front().unwrap(), &2);/// assert_eq!(dl.front().unwrap(), &1);"if you don't need a reference to the value, use `LinkedList::push_front` instead"push_front_mut/// Adds an element to the front of the list, returning a reference to it./// #![feature(push_mut)]/// let mut dl = LinkedList::from([1, 2, 3]);/// let ptr = dl.push_front_mut(2);/// *ptr += 4;/// assert_eq!(dl.front().unwrap(), &6);/// Removes the first element and returns it, or `None` if the list is/// let mut d = LinkedList::new();/// assert_eq!(d.pop_front(), None);/// d.push_front(1);/// d.push_front(3);/// assert_eq!(d.pop_front(), Some(3));/// assert_eq!(d.pop_front(), Some(1));/// Adds an element to the back of the list./// d.push_back(1);/// d.push_back(3);/// assert_eq!(3, *d.back().unwrap());"if you don't need a reference to the value, use `LinkedList::push_back` instead"push_back_mut/// Adds an element to the back of the list, returning a reference to it./// let ptr = dl.push_back_mut(2);/// assert_eq!(dl.back().unwrap(), &6);/// Removes the last element from a list and returns it, or `None` if/// assert_eq!(d.pop_back(), None);/// assert_eq!(d.pop_back(), Some(3));/// Splits the list into two at the given index. Returns everything after the given index,/// including the index./// d.push_front(2);/// let mut split = d.split_off(2);/// assert_eq!(split.pop_front(), Some(1));/// assert_eq!(split.pop_front(), None);/// Removes the element at the given index and returns it./// Panics if at >= len/// #![feature(linked_list_remove)]/// assert_eq!(d.remove(1), 2);/// assert_eq!(d.remove(0), 3);/// assert_eq!(d.remove(0), 1);/// In other words, remove all elements `e` for which `f(&mut e)` returns false./// #![feature(linked_list_retain)]/// d.retain(|&mut x| x % 2 == 0);/// assert_eq!(d.pop_front(), Some(2));/// let keep = [false, true, false];/// d.retain(|_| *iter.next().unwrap());/// Creates an iterator which uses a closure to determine if an element should be removed./// If the closure returns `true`, the element is removed from the list and/// in the list and will not be yielded./// Use `extract_if().for_each(drop)` if you do not need the returned iterator./// Splitting a list into even and odd values, reusing the original list:/// let mut numbers: LinkedList<u32> = LinkedList::new();/// numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]);/// let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<LinkedList<_>>();/// let odds = numbers;/// assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]);/// assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);/// Creates an empty `linked_list::Iter`./// # use std::collections::linked_list;/// let iter: linked_list::Iter<'_, u8> = Default::default();/// A cursor over a `LinkedList`./// Cursors always rest between two elements in the list, and index in a logically circular way./// To accommodate this, there is a "ghost" non-element that yields `None` between the head and/// tail of the list./// When created, cursors start at the front of the list, or the "ghost" non-element if the list is empty./// A cursor over a `LinkedList` with editing operations./// safely mutate the list during iteration. This is because the lifetime of its yielded/// references is tied to its own lifetime, instead of just the underlying list. This means/// Returns the cursor position index within the `LinkedList`./// This returns `None` if the cursor is currently pointing to the/// "ghost" non-element./// Moves the cursor to the next element of the `LinkedList`./// If the cursor is pointing to the "ghost" non-element then this will move it to/// the first element of the `LinkedList`. If it is pointing to the last/// element of the `LinkedList` then this will move it to the "ghost" non-element.move_prev/// Moves the cursor to the previous element of the `LinkedList`./// the last element of the `LinkedList`. If it is pointing to the first/// Returns a reference to the element that the cursor is currently/// pointing to./// Returns a reference to the next element./// If the cursor is pointing to the "ghost" non-element then this returns/// element of the `LinkedList` then this returns `None`./// Returns a reference to the previous element./// Provides a reference to the front element of the cursor's parent list,/// or None if the list is empty./// Provides a reference to the back element of the cursor's parent list,as_list/// Provides a reference to the cursor's parent list./// Returns a read-only cursor pointing to the current element./// Provides a read-only reference to the cursor's parent list./// The lifetime of the returned reference is bound to that of the/// `CursorMut` is frozen for the lifetime of the reference.splice_after/// Inserts the elements from the given `LinkedList` after the current one./// If the cursor is pointing at the "ghost" non-element then the new elements are/// inserted at the start of the `LinkedList`.splice_before/// Inserts the elements from the given `LinkedList` before the current one./// inserted at the end of the `LinkedList`./// Inserts a new element into the `LinkedList` after the current one./// If the cursor is pointing at the "ghost" non-element then the new element is/// inserted at the front of the `LinkedList`./// Inserts a new element into the `LinkedList` before the current one.remove_current/// Removes the current element from the `LinkedList`./// The element that was removed is returned, and the cursor is/// moved to point to the next element in the `LinkedList`./// If the cursor is currently pointing to the "ghost" non-element then no element/// is removed and `None` is returned.remove_current_as_list/// Removes the current element from the `LinkedList` without deallocating the list node./// The node that was removed is returned as a new `LinkedList` containing only this node./// The cursor is moved to point to the next element in the current `LinkedList`.split_after/// Splits the list into two after the current element. This will return a/// new list consisting of everything after the cursor, with the original/// list retaining everything before./// If the cursor is pointing at the "ghost" non-element then the entire contents/// of the `LinkedList` are moved.split_before/// Splits the list into two before the current element. This will return a/// new list consisting of everything before the cursor, with the original/// list retaining everything after./// Appends an element to the front of the cursor's parent list. The node/// that the cursor points to is unchanged, even if it is the "ghost" node.// `push_front` continues to point to "ghost" when it adds a node to mimic// the behavior of `insert_before` on an empty list./// Appends an element to the back of the cursor's parent list. The node/// Removes the first element from the cursor's parent list and returns it,/// or None if the list is empty. The element the cursor points to remains/// unchanged, unless it was pointing to the front element. In that case, it/// points to the new front element./// Removes the last element from the cursor's parent list and returns it,/// unchanged, unless it was pointing to the back element. In that case, it/// points to the "ghost" element./// Provides a mutable reference to the front element of the cursor's/// parent list, or None if the list is empty./// Provides a mutable reference to back element of the cursor's parent/// list, or `None` if the list is empty./// Building and mutating a list with a cursor, then getting the back element:/// #![feature(linked_list_cursors)]/// dl.push_front(3);/// let mut cursor = dl.cursor_front_mut();/// *cursor.current().unwrap() = 99;/// *cursor.back_mut().unwrap() = 0;/// let mut contents = dl.into_iter();/// assert_eq!(contents.next(), Some(99));/// assert_eq!(contents.next(), Some(2));/// assert_eq!(contents.next(), Some(0));/// assert_eq!(contents.next(), None);"iterators are lazy and do nothing unless consumed; \
    use `extract_if().for_each(drop)` to remove and discard elements"old_len/// An iterator produced by calling `extract_if` on LinkedList./// Creates an empty `linked_list::IntoIter`./// let iter: linked_list::IntoIter<u8> = Default::default();/// Consumes the list into an iterator yielding elements by value.spec_extend/// as it avoids reallocation of the nodes of the linked list. Additionally,/// if the element type `T` overrides `clone_from()`, this will reuse the/// resources of `self`'s elements as well./// Converts a `[T; N]` into a `LinkedList<T>`./// let list1 = LinkedList::from([1, 2, 3, 4]);/// let list2: LinkedList<_> = [1, 2, 3, 4].into();/// assert_eq!(list1, list2);// Ensure that `LinkedList` and its read-only iterators are covariant in their type parameters.//! A doubly-linked list with owned nodes.//! The `LinkedList` allows pushing and popping elements at either end//! in constant time.//! NOTE: It is almost always better to use [`Vec`] or [`VecDeque`] because//! array-based containers are generally faster,//! more memory efficient, and make better use of CPU cache.//! [`Vec`]: crate::vec::Vec//! [`VecDeque`]: super::vec_deque::VecDeque// Now the list editing operationsbtree//! An ordered map based on a B-Tree.//! An ordered set based on a B-Tree./// Details about the allocation that caused the error/// The layout of allocation request that failed/// Details of the allocation that caused a `TryReserveError`/// Always evaluates to [`TryReserveErrorKind::CapacityOverflow`]./// Extends `self` with the contents of the given iterator./// An intermediate trait for specialization of `Extend`.//! Collection types.// Note: This module is also included in the alloctests crate using #[path] to// run the tests. See the comment there for an explanation why this is the case.// We can't just use a &mut VecDeque<T, A>, as that would make Drain invariant over T// and we want it to be covariant insteaddrain_len// drain_start is stored in deque.len// index into the logical array, not the physical one (always lies in [0..deque.len))new_len// number of elements remaining after dropping the drain// Needed to make Drain covariant over T/// A draining iterator over the elements of a `VecDeque`./// This `struct` is created by the [`drain`] method on [`VecDeque`]. See its/// [`drain`]: VecDeque::drainas_slices// Only returns pointers to the slices, as that's all we need// to drop them. May only be called if `self.remaining != 0`."iterators are lazy and do nothing unless consumed; \
    use `retain_mut` or `extract_if().for_each(drop)` to remove and discard elements"/// The index of the item that will be inspected by the next call to `next`./// Elements at and beyond this point will be retained. Must be equal or smaller than `old_len`./// The number of items that have been drained (removed) thus far./// The original length of `vec` prior to draining./// The filter test predicate./// An iterator which uses a closure to determine if an element should be removed./// This struct is created by [`VecDeque::extract_if`]./// #![feature(vec_deque_extract_if)]/// use std::collections::vec_deque::ExtractIf;/// use std::collections::vec_deque::VecDeque;/// let mut v = VecDeque::from([0, 1, 2]);/// let iter: ExtractIf<'_, _, _> = v.extract_if(.., |x| *x % 2 == 0);/// An owning iterator over the elements of a `VecDeque`./// This `struct` is created by the [`into_iter`] method on [`VecDeque`]/// [`into_iter`]: VecDeque::into_iterinto_vecdequeadvance_back_bytry_rfoldTrustedRandomAccessTrustedRandomAccessNoCoercei1i2/// An iterator over the elements of a `VecDeque`./// This `struct` is created by the [`iter`] method on [`super::VecDeque`]. See its/// [`iter`]: super::VecDeque::iter/// Views the underlying data as a pair of subslices of the original data./// The slices contain, in order, the contents of the deque not yet yielded/// This has the same lifetime as the original `VecDeque`, and so the/// iterator can continue to be used while this exists./// #![feature(vec_deque_iter_as_slices)]/// let mut deque = VecDeque::new();/// deque.push_back(0);/// deque.push_back(1);/// deque.push_back(2);/// deque.push_front(10);/// deque.push_front(9);/// deque.push_front(8);/// let mut iter = deque.iter();/// iter.next_back();/// assert_eq!(iter.as_slices(), (&[9, 10][..], &[0, 1][..]));/// Creates an empty `vec_deque::Iter`./// # use std::collections::vec_deque;/// let iter: vec_deque::Iter<'_, u8> = Default::default();__iterator_get_uncheckedMAY_HAVE_SIDE_EFFECT/// A mutable iterator over the elements of a `VecDeque`./// This `struct` is created by the [`iter_mut`] method on [`super::VecDeque`]. See its/// [`iter_mut`]: super::VecDeque::iter_mutinto_slices/// To avoid creating `&mut` references that alias, this is forced to/// consume the iterator./// let mut iter = deque.iter_mut();/// let slices = iter.into_slices();/// slices.0[0] = 42;/// slices.1[0] = 24;/// assert_eq!(deque.as_slices(), (&[8, 42, 10][..], &[24, 1, 2][..]));/// To avoid creating `&mut [T]` references that alias, the returned slices/// borrow their lifetimes from the iterator the method is applied on.as_mut_slices/// iter.as_mut_slices().0[0] = 42;/// iter.as_mut_slices().1[0] = 24;/// Creates an empty `vec_deque::IterMut`./// let iter: vec_deque::IterMut<'_, u8> = Default::default();__impl_slice_eq1ByRefSized// This is used in a bunch of intra-doc links.// FIXME: For some reason, `#[cfg(doc)]` wasn't sufficient, resulting in// failures in linkchecker even though rustdoc built the docs just fine.SpecExtendFrontspec_from_iterSpecFromIter// `self[0]`, if it exists, is `buf[head]`.// `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`.// the number of initialized elements, starting from the one at `head` and potentially wrapping around.// if `len == 0`, the exact value of `head` is unimportant.// if `T` is zero-Sized, then `self.len <= usize::MAX`, otherwise `self.len <= isize::MAX as usize`./// A double-ended queue implemented with a growable ring buffer./// The "default" usage of this type as a queue is to use [`push_back`] to add to/// the queue, and [`pop_front`] to remove from the queue. [`extend`] and [`append`]/// push onto the back in this manner, and iterating over `VecDeque` goes front/// to back./// A `VecDeque` with a known list of items can be initialized from an array:/// let deq = VecDeque::from([-1, 0, 1]);/// Since `VecDeque` is a ring buffer, its elements are not necessarily contiguous/// in memory. If you want to access the elements as a single slice, such as for/// efficient sorting, you can use [`make_contiguous`]. It rotates the `VecDeque`/// so that its elements do not wrap, and returns a mutable slice to the/// now-contiguous element sequence./// [`push_back`]: VecDeque::push_back/// [`pop_front`]: VecDeque::pop_front/// [`extend`]: VecDeque::extend/// [`append`]: VecDeque::append/// [`make_contiguous`]: VecDeque::make_contiguous/// Creates an empty deque./// Marginally more convenient/// Appends an element to the buffer./// May only be called if `deque.len() < deque.capacity()`push_front_unchecked/// Prepends an element to the buffer.buffer_read/// Moves an element out of the bufferbuffer_write/// Writes an element into the buffer, moving it and returning a pointer to it./// May only be called if `off < self.capacity()`.buffer_range/// Returns a slice pointer into the buffer./// `range` must lie inside `0..self.capacity()`./// Returns `true` if the buffer is at full capacity.wrap_add/// Returns the index in the underlying buffer for a given logical element/// index + addend.to_physical_idxwrap_sub/// index - subtrahend.nonoverlapping_ranges/// Get source, destination and count (like the arguments to [`ptr::copy_nonoverlapping`])/// for copying `count` values from index `src` to index `dst`./// One of the ranges can wrap around the physical buffer, for this reason 2 triples are returned./// Use of the word "ranges" specifically refers to `src..src + count` and `dst..dst + count`./// - Ranges must not overlap: `src.abs_diff(dst) >= count`./// - Ranges must be in bounds of the logical buffer: `src + count <= self.capacity()` and `dst + count <= self.capacity()`./// - `head` must be in bounds: `head < self.capacity()`./// Copies a contiguous block of memory len long from src to dstwrap_copy/// Copies a potentially wrapping block of memory len long from src to dest./// (abs(dst - src) + len) must be no larger than capacity() (There must be at/// most one continuous overlapping region between src and dest).copy_slice/// Copies all values from `src` to `dst`, wrapping around if needed./// Assumes capacity is sufficient.copy_slice_reversed/// Copies all values from `src` to `dst` in reversed order, wrapping around if needed./// Equivalent to calling [`VecDeque::copy_slice`] with a [reversed](https://doc.rust-lang.org/std/primitive.slice.html#method.reverse) slice.write_iter/// Writes all values from `iter` to `dst`./// Assumes no wrapping around happens.write_iter_wrapping/// Writes all values from `iter` to `dst`, wrapping/// at the end of the buffer and returns the number/// of written values./// Assumes that `iter` yields at most `len` items.handle_capacity_increase/// Frobs the head and tail sections around to handle the fact that we/// just reallocated. Unsafe because it trusts old_capacity./// Creates an iterator which uses a closure to determine if an element in the range should be removed./// If the closure returns `true`, the element is removed from the deque and yielded. If the closure/// returns `false`, or panics, the element remains in the deque and will not be yielded./// Only elements that fall in the provided range are considered for extraction, but any elements/// after the range will still have to be moved if any element has been extracted./// or [`retain_mut`] with a negated predicate if you also do not need to restrict the range./// [`retain_mut`]: VecDeque::retain_mut/// Using this method is equivalent to the following code:/// # use std::collections::VecDeque;/// # let some_predicate = |x: &mut i32| { *x % 2 == 1 };/// # let mut deq: VecDeque<_> = (0..10).collect();/// # let mut deq2 = deq.clone();/// # let range = 1..5;/// let mut i = range.start;/// let end_items = deq.len() - range.end;/// # let mut extracted = vec![];/// while i < deq.len() - end_items {///     if some_predicate(&mut deq[i]) {///         let val = deq.remove(i).unwrap();///         // your code here/// #         extracted.push(val);///         i += 1;/// # let extracted2: Vec<_> = deq2.extract_if(range, some_predicate).collect();/// # assert_eq!(deq, deq2);/// # assert_eq!(extracted, extracted2);/// But `extract_if` is easier to use. `extract_if` is also more efficient,/// because it can backshift the elements of the array in bulk./// If `range` is out of bounds./// Splitting a deque into even and odd values, reusing the original deque:/// let mut numbers = VecDeque::from([1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]);/// let evens = numbers.extract_if(.., |x| *x % 2 == 0).collect::<VecDeque<_>>();/// assert_eq!(evens, VecDeque::from([2, 4, 6, 8, 14]));/// assert_eq!(odds, VecDeque::from([1, 3, 5, 9, 11, 13, 15]));/// Using the range argument to only process a part of the deque:/// let mut items = VecDeque::from([0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 2, 1, 2]);/// let ones = items.extract_if(7.., |x| *x == 1).collect::<VecDeque<_>>();/// assert_eq!(items, VecDeque::from([0, 0, 0, 0, 0, 0, 0, 2, 2, 2]));/// assert_eq!(ones.len(), 3);/// let deque: VecDeque<u32> = VecDeque::new();/// Creates an empty deque with space for at least `capacity` elements./// let deque: VecDeque<u32> = VecDeque::with_capacity(10);/// Returns an error if the capacity exceeds `isize::MAX` _bytes_,/// or if the allocator reports allocation failure./// # #![feature(try_with_capacity)]/// # fn example() -> Result<(), std::collections::TryReserveError> {/// let deque: VecDeque<u32> = VecDeque::try_with_capacity(10)?;from_contiguous_raw_parts_in/// Creates a `VecDeque` from a raw allocation, when the initialized/// part of that allocation forms a *contiguous* subslice thereof./// For use by `vec::IntoIter::into_vecdeque`/// All the usual requirements on the allocated memory like in/// `Vec::from_raw_parts_in`, but takes a *range* of elements that are/// initialized rather than only supporting `0..len`.  Requires that/// `initialized.start` ≤ `initialized.end` ≤ `capacity`./// Provides a reference to the element at the given index./// Element at index 0 is the front of the queue./// let mut buf = VecDeque::new();/// buf.push_back(3);/// buf.push_back(4);/// buf.push_back(5);/// buf.push_back(6);/// assert_eq!(buf.get(1), Some(&4));/// Provides a mutable reference to the element at the given index./// assert_eq!(buf[1], 4);/// if let Some(elem) = buf.get_mut(1) {///     *elem = 7;/// assert_eq!(buf[1], 7);/// Swaps elements at indices `i` and `j`./// `i` and `j` may be equal./// Panics if either index is out of bounds./// assert_eq!(buf, [3, 4, 5]);/// buf.swap(0, 2);/// assert_eq!(buf, [5, 4, 3]);/// Returns the number of elements the deque can hold without/// let buf: VecDeque<i32> = VecDeque::with_capacity(10);/// assert!(buf.capacity() >= 10);/// Reserves the minimum capacity for at least `additional` more elements to be inserted in the/// given deque. 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./// let mut buf: VecDeque<i32> = [1].into();/// buf.reserve_exact(10);/// assert!(buf.capacity() >= 11);/// [`reserve`]: VecDeque::reserve/// Reserves capacity for at least `additional` more elements to be inserted in the given/// deque. The collection may reserve more space to speculatively avoid frequent reallocations./// buf.reserve(10);/// Tries to reserve the minimum capacity for at least `additional` more elements to/// be inserted in the given deque. After calling `try_reserve_exact`,/// capacity will be greater than or equal to `self.len() + additional` if/// it returns `Ok(())`. Does nothing if the capacity is already sufficient./// [`try_reserve`]: VecDeque::try_reserve/// If the capacity overflows `usize`, or the allocator reports a failure, then an error/// fn process_data(data: &[u32]) -> Result<VecDeque<u32>, TryReserveError> {///     let mut output = VecDeque::new();///     output.try_reserve_exact(data.len())?;///     // Now we know this can't OOM(Out-Of-Memory) in the middle of our complex work///     output.extend(data.iter().map(|&val| {///         val * 2 + 5 // very complicated/// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");/// in the given deque. The collection may reserve more space to speculatively avoid/// frequent reallocations. After calling `try_reserve`, capacity will be///     output.try_reserve(data.len())?;/// Shrinks the capacity of the deque as much as possible./// It will drop down as close as possible to the length but the allocator may still inform the/// deque that there is space for a few more elements./// let mut buf = VecDeque::with_capacity(15);/// buf.extend(0..4);/// assert_eq!(buf.capacity(), 15);/// buf.shrink_to_fit();/// assert!(buf.capacity() >= 4);/// Shrinks the capacity of the deque with a lower bound./// buf.shrink_to(6);/// assert!(buf.capacity() >= 6);/// buf.shrink_to(0);abort_shrink/// Reverts the deque back into a consistent state in case `shrink_to` failed./// This is necessary to prevent UB if the backing allocator returns an error/// from `shrink` and `handle_alloc_error` subsequently unwinds (see #123369)./// `old_head` refers to the head index before `shrink_to` was called. `target_cap`/// is the capacity that it was trying to shrink to./// Shortens the deque, keeping the first `len` elements and dropping/// If `len` is greater or equal to the deque's current length, this has/// no effect./// buf.push_back(10);/// buf.push_back(15);/// assert_eq!(buf, [5, 10, 15]);/// buf.truncate(1);/// assert_eq!(buf, [5]);truncate_front/// Shortens the deque, keeping the last `len` elements and dropping/// # #![feature(vec_deque_truncate_front)]/// buf.push_front(5);/// buf.push_front(10);/// buf.push_front(15);/// assert_eq!(buf, [15, 10, 5]);/// assert_eq!(buf.as_slices(), (&[15, 10, 5][..], &[][..]));/// buf.truncate_front(1);/// assert_eq!(buf.as_slices(), (&[5][..], &[][..]));/// Returns a front-to-back iterator./// let b: &[_] = &[&5, &3, &4];/// let c: Vec<&i32> = buf.iter().collect();/// assert_eq!(&c[..], b);/// Returns a front-to-back iterator that returns mutable references./// for num in buf.iter_mut() {///     *num = *num - 2;/// let b: &[_] = &[&mut 3, &mut 1, &mut 2];/// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[..], b);/// Returns a pair of slices which contain, in order, the contents of the/// deque./// If [`make_contiguous`] was previously called, all elements of the/// deque will be in the first slice and the second slice will be empty./// Otherwise, the exact split point depends on implementation details/// and is not guaranteed./// let expected = [0, 1, 2];/// let (front, back) = deque.as_slices();/// assert_eq!(&expected[..front.len()], front);/// assert_eq!(&expected[front.len()..], back);/// let expected = [9, 10, 0, 1, 2];/// // Since the split point is not guaranteed, we may need to update/// // either slice./// let mut update_nth = |index: usize, val: u32| {///     let (front, back) = deque.as_mut_slices();///     if index > front.len() - 1 {///         back[index - front.len()] = val;///         front[index] = val;/// update_nth(0, 42);/// update_nth(2, 24);/// let v: Vec<_> = deque.into();/// assert_eq!(v, [42, 10, 24, 1]);/// Returns the number of elements in the deque./// assert_eq!(deque.len(), 0);/// assert_eq!(deque.len(), 1);/// Returns `true` if the deque is empty./// assert!(deque.is_empty());/// deque.push_front(1);/// assert!(!deque.is_empty());slice_ranges/// Given a range into the logical buffer of the deque, this function/// return two ranges into the physical buffer that correspond to/// the given range. The `len` parameter should usually just be `self.len`;/// the reason it's passed explicitly is that if the deque is wrapped in/// a `Drain`, then `self.len` is not actually the length of the deque./// This function is always safe to call. For the resulting ranges to be valid/// ranges into the physical buffer, the caller must ensure that the result of/// calling `slice::range(range, ..len)` represents a valid range into the/// logical buffer, and that all elements in that range are initialized./// Creates an iterator that covers the specified range in the deque./// Panics if the range has `start_bound > end_bound`, or, if the range is/// bounded on either end and past the length of the deque./// let deque: VecDeque<_> = [1, 2, 3].into();/// let range = deque.range(2..).copied().collect::<VecDeque<_>>();/// assert_eq!(range, [3]);/// // A full range covers all contents/// let all = deque.range(..);/// assert_eq!(all.len(), 3);/// Creates an iterator that covers the specified mutable range in the deque./// let mut deque: VecDeque<_> = [1, 2, 3].into();/// for v in deque.range_mut(2..) {///   *v *= 2;/// assert_eq!(deque, [1, 2, 6]);/// for v in deque.range_mut(..) {/// assert_eq!(deque, [2, 4, 12]);/// Removes the specified range from the deque in bulk, returning all/// removed elements as an iterator. If the iterator is dropped before/// being fully consumed, it drops the remaining removed elements./// The returned iterator keeps a mutable borrow on the queue to optimize/// # Leaking/// If the returned iterator goes out of scope without being dropped (due to/// [`mem::forget`], for example), the deque may have lost and leaked/// elements arbitrarily, including elements outside the range./// let drained = deque.drain(2..).collect::<VecDeque<_>>();/// assert_eq!(drained, [3]);/// assert_eq!(deque, [1, 2]);/// // A full range clears all contents, like `clear()` does/// deque.drain(..);/// Clears the deque, removing all values./// deque.clear();/// Returns `true` if the deque contains an element equal to the/// This operation is *O*(*n*)./// Note that if you have a sorted `VecDeque`, [`binary_search`] may be faster./// [`binary_search`]: VecDeque::binary_search/// let mut deque: VecDeque<u32> = VecDeque::new();/// assert_eq!(deque.contains(&1), true);/// assert_eq!(deque.contains(&10), false);/// Provides a reference to the front element, or `None` if the deque is/// let mut d = VecDeque::new();/// assert_eq!(d.front(), None);/// d.push_back(2);/// assert_eq!(d.front(), Some(&1));/// Provides a mutable reference to the front element, or `None` if the/// deque is empty./// assert_eq!(d.front_mut(), None);/// match d.front_mut() {///     Some(x) => *x = 9,///     None => (),/// assert_eq!(d.front(), Some(&9));/// Provides a reference to the back element, or `None` if the deque is/// assert_eq!(d.back(), None);/// assert_eq!(d.back(), Some(&2));/// Provides a mutable reference to the back element, or `None` if the/// match d.back_mut() {/// assert_eq!(d.back(), Some(&9));/// Removes the first element and returns it, or `None` if the deque is/// Removes the last element from the deque and returns it, or `None` if/// assert_eq!(buf.pop_back(), None);/// buf.push_back(1);/// assert_eq!(buf.pop_back(), Some(3));pop_front_if/// Removes and returns the first element from the deque if the predicate/// returns `true`, or [`None`] if the predicate returns false or the deque/// is empty (the predicate will not be called in that case)./// let mut deque: VecDeque<i32> = vec![0, 1, 2, 3, 4].into();/// let pred = |x: &mut i32| *x % 2 == 0;/// assert_eq!(deque.pop_front_if(pred), Some(0));/// assert_eq!(deque, [1, 2, 3, 4]);/// assert_eq!(deque.pop_front_if(pred), None);pop_back_if/// Removes and returns the last element from the deque if the predicate/// assert_eq!(deque.pop_back_if(pred), Some(4));/// assert_eq!(deque, [0, 1, 2, 3]);/// assert_eq!(deque.pop_back_if(pred), None);/// Prepends an element to the deque./// assert_eq!(d.front(), Some(&2));"if you don't need a reference to the value, use `VecDeque::push_front` instead"/// Prepends an element to the deque, returning a reference to it./// let mut d = VecDeque::from([1, 2, 3]);/// let x = d.push_front_mut(8);/// *x -= 1;/// assert_eq!(d.front(), Some(&7));/// Appends an element to the back of the deque./// assert_eq!(3, *buf.back().unwrap());"if you don't need a reference to the value, use `VecDeque::push_back` instead"/// Appends an element to the back of the deque, returning a reference to it./// let x = d.push_back_mut(9);/// *x += 1;/// assert_eq!(d.back(), Some(&10));/// Prepends all contents of the iterator to the front of the deque./// The order of the contents is preserved./// To get behavior like [`append`][VecDeque::append] where elements are moved/// from the other collection to this one, use `self.prepend(other.drain(..))`./// #![feature(deque_extend_front)]/// let mut deque = VecDeque::from([4, 5, 6]);/// deque.prepend([1, 2, 3]);/// assert_eq!(deque, [1, 2, 3, 4, 5, 6]);/// Move values between collections like [`append`][VecDeque::append] does but prepend to the front:/// let mut deque1 = VecDeque::from([4, 5, 6]);/// let mut deque2 = VecDeque::from([1, 2, 3]);/// deque1.prepend(deque2.drain(..));/// assert_eq!(deque1, [1, 2, 3, 4, 5, 6]);/// assert!(deque2.is_empty());extend_front/// Prepends all contents of the iterator to the front of the deque,/// as if [`push_front`][VecDeque::push_front] was called repeatedly with/// the values yielded by the iterator./// deque.extend_front([3, 2, 1]);/// This behaves like [`push_front`][VecDeque::push_front] was called repeatedly:/// for v in [3, 2, 1] {///     deque.push_front(v);swap_remove_front/// Removes an element from anywhere in the deque and returns it,/// replacing it with the first element./// This does not preserve ordering, but is *O*(1)./// Returns `None` if `index` is out of bounds./// assert_eq!(buf.swap_remove_front(0), None);/// buf.push_back(2);/// assert_eq!(buf, [1, 2, 3]);/// assert_eq!(buf.swap_remove_front(2), Some(3));/// assert_eq!(buf, [2, 1]);swap_remove_back/// replacing it with the last element./// assert_eq!(buf.swap_remove_back(0), None);/// assert_eq!(buf.swap_remove_back(0), Some(1));/// assert_eq!(buf, [3, 2]);/// Inserts an element at `index` within the deque, shifting all elements/// with indices greater than or equal to `index` towards the back./// Panics if `index` is strictly greater than the deque's length./// let mut vec_deque = VecDeque::new();/// vec_deque.push_back('a');/// vec_deque.push_back('b');/// vec_deque.push_back('c');/// assert_eq!(vec_deque, &['a', 'b', 'c']);/// vec_deque.insert(1, 'd');/// assert_eq!(vec_deque, &['a', 'd', 'b', 'c']);/// vec_deque.insert(4, 'e');/// assert_eq!(vec_deque, &['a', 'd', 'b', 'c', 'e']);"if you don't need a reference to the value, use `VecDeque::insert` instead"insert_mut/// with indices greater than or equal to `index` towards the back, and/// returning a reference to it./// let mut vec_deque = VecDeque::from([1, 2, 3]);/// let x = vec_deque.insert_mut(1, 5);/// *x += 7;/// assert_eq!(vec_deque, &[1, 12, 2, 3]);/// Removes and returns the element at `index` from the deque./// Whichever end is closer to the removal point will be moved to make/// room, and all the affected elements will be moved to new positions./// buf.push_back('a');/// buf.push_back('b');/// buf.push_back('c');/// assert_eq!(buf, ['a', 'b', 'c']);/// assert_eq!(buf.remove(1), Some('b'));/// assert_eq!(buf, ['a', 'c']);/// Splits the deque into two at the given index./// Returns a newly allocated `VecDeque`. `self` contains elements `[0, at)`,/// and the returned deque contains elements `[at, len)`./// let mut buf: VecDeque<_> = ['a', 'b', 'c'].into();/// let buf2 = buf.split_off(1);/// assert_eq!(buf, ['a']);/// assert_eq!(buf2, ['b', 'c']);/// Panics if the new number of elements in self overflows a `usize`./// let mut buf: VecDeque<_> = [1, 2].into();/// let mut buf2: VecDeque<_> = [3, 4].into();/// buf.append(&mut buf2);/// assert_eq!(buf, [1, 2, 3, 4]);/// assert_eq!(buf2, []);/// In other words, remove all elements `e` for which `f(&e)` returns false./// buf.extend(1..5);/// buf.retain(|&x| x % 2 == 0);/// assert_eq!(buf, [2, 4]);/// buf.extend(1..6);/// buf.retain(|_| *iter.next().unwrap());/// assert_eq!(buf, [2, 3, 5]);/// buf.retain_mut(|x| if *x % 2 == 0 {///     *x += 1;/// assert_eq!(buf, [3, 5]);// Double the buffer size. This method is inline(never), so we expect it to only// be called in cold paths.// This may panic or abort/// Modifies the deque in-place so that `len()` is equal to `new_len`,/// either by removing excess elements from the back or by appending/// elements generated by calling `generator` to the back./// buf.resize_with(5, Default::default);/// assert_eq!(buf, [5, 10, 15, 0, 0]);/// buf.resize_with(2, || unreachable!());/// assert_eq!(buf, [5, 10]);/// let mut state = 100;/// buf.resize_with(5, || { state += 1; state });/// assert_eq!(buf, [5, 10, 101, 102, 103]);make_contiguous/// Rearranges the internal storage of this deque so it is one contiguous/// slice, which is then returned./// This method does not allocate and does not change the order of the/// inserted elements. As it returns a mutable slice, this can be used to/// sort a deque./// Once the internal storage is contiguous, the [`as_slices`] and/// [`as_mut_slices`] methods will return the entire contents of the/// deque in a single slice./// [`as_slices`]: VecDeque::as_slices/// [`as_mut_slices`]: VecDeque::as_mut_slices/// Sorting the content of a deque./// buf.push_front(3);/// // sorting the deque/// buf.make_contiguous().sort();/// assert_eq!(buf.as_slices(), (&[1, 2, 3] as &[_], &[] as &[_]));/// // sorting it in reverse order/// buf.make_contiguous().sort_by(|a, b| b.cmp(a));/// assert_eq!(buf.as_slices(), (&[3, 2, 1] as &[_], &[] as &[_]));/// Getting immutable access to the contiguous slice./// buf.make_contiguous();/// if let (slice, &[]) = buf.as_slices() {///     // we can now be sure that `slice` contains all elements of the deque,///     // while still having immutable access to `buf`.///     assert_eq!(buf.len(), slice.len());///     assert_eq!(slice, &[3, 2, 1] as &[_]);/// Rotates the double-ended queue `n` places to the left./// Equivalently,/// - Rotates item `n` into the first position./// - Pops the first `n` items and pushes them to the end./// - Rotates `len() - n` places to the right./// If `n` is greater than `len()`. Note that `n == len()`/// does _not_ panic and is a no-op rotation./// Takes `*O*(min(n, len() - n))` time and no extra space./// let mut buf: VecDeque<_> = (0..10).collect();/// buf.rotate_left(3);/// assert_eq!(buf, [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]);/// for i in 1..10 {///     assert_eq!(i * 3 % 10, buf[0]);///     buf.rotate_left(3);/// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);/// Rotates the double-ended queue `n` places to the right./// - Rotates the first item into position `n`./// - Pops the last `n` items and pushes them to the front./// - Rotates `len() - n` places to the left./// buf.rotate_right(3);/// assert_eq!(buf, [7, 8, 9, 0, 1, 2, 3, 4, 5, 6]);///     assert_eq!(0, buf[i * 3 % 10]);///     buf.rotate_right(3);rotate_left_innerrotate_right_inner/// Binary searches this `VecDeque` for a given element./// If the `VecDeque` is not sorted, the returned result is unspecified and/// meaningless./// If the value is found then [`Result::Ok`] is returned, containing the/// index of the matching element. If there are multiple matches, then any/// one of the matches could be returned. If the value is not found then/// [`Result::Err`] is returned, containing the index where a matching/// element could be inserted while maintaining sorted order./// See also [`binary_search_by`], [`binary_search_by_key`], and [`partition_point`]./// [`binary_search_by`]: VecDeque::binary_search_by/// [`binary_search_by_key`]: VecDeque::binary_search_by_key/// [`partition_point`]: VecDeque::partition_point/// Looks up a series of four elements. The first is found, with a/// uniquely determined position; the second and third are not/// found; the fourth could match any position in `[1, 4]`./// let deque: VecDeque<_> = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();/// assert_eq!(deque.binary_search(&13),  Ok(9));/// assert_eq!(deque.binary_search(&4),   Err(7));/// assert_eq!(deque.binary_search(&100), Err(13));/// let r = deque.binary_search(&1);/// assert!(matches!(r, Ok(1..=4)));/// If you want to insert an item to a sorted deque, while maintaining/// sort order, consider using [`partition_point`]:/// let mut deque: VecDeque<_> = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();/// let num = 42;/// let idx = deque.partition_point(|&x| x <= num);/// // If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to/// // `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` may allow `insert`/// // to shift less elements./// deque.insert(idx, num);/// assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);/// Binary searches this `VecDeque` with a comparator function./// The comparator function should return an order code that indicates/// whether its argument is `Less`, `Equal` or `Greater` the desired/// If the `VecDeque` is not sorted or if the comparator function does not/// implement an order consistent with the sort order of the underlying/// `VecDeque`, the returned result is unspecified and meaningless./// See also [`binary_search`], [`binary_search_by_key`], and [`partition_point`]./// assert_eq!(deque.binary_search_by(|x| x.cmp(&13)),  Ok(9));/// assert_eq!(deque.binary_search_by(|x| x.cmp(&4)),   Err(7));/// assert_eq!(deque.binary_search_by(|x| x.cmp(&100)), Err(13));/// let r = deque.binary_search_by(|x| x.cmp(&1));/// Binary searches this `VecDeque` with a key extraction function./// Assumes that the deque is sorted by the key, for instance with/// [`make_contiguous().sort_by_key()`] using the same key extraction function./// If the deque is not sorted by the key, the returned result is/// unspecified and meaningless./// See also [`binary_search`], [`binary_search_by`], and [`partition_point`]./// [`make_contiguous().sort_by_key()`]: VecDeque::make_contiguous/// Looks up a series of four elements in a slice of pairs sorted by/// their second elements. The first is found, with a uniquely/// determined position; the second and third are not found; the/// fourth could match any position in `[1, 4]`./// let deque: VecDeque<_> = [(0, 0), (2, 1), (4, 1), (5, 1),///          (3, 1), (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),///          (1, 21), (2, 34), (4, 55)].into();/// assert_eq!(deque.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));/// assert_eq!(deque.binary_search_by_key(&4, |&(a, b)| b),   Err(7));/// assert_eq!(deque.binary_search_by_key(&100, |&(a, b)| b), Err(13));/// let r = deque.binary_search_by_key(&1, |&(a, b)| b);/// Returns the index of the partition point according to the given predicate/// The deque is assumed to be partitioned according to the given predicate./// This means that all elements for which the predicate returns true are at the start of the deque/// and all elements for which the predicate returns false are at the end./// For example, `[7, 15, 3, 5, 4, 12, 6]` is partitioned under the predicate `x % 2 != 0`/// (all odd numbers are at the start, all even at the end)./// If the deque is not partitioned, the returned result is unspecified and meaningless,/// as this method performs a kind of binary search./// See also [`binary_search`], [`binary_search_by`], and [`binary_search_by_key`]./// let deque: VecDeque<_> = [1, 2, 3, 3, 5, 6, 7].into();/// let i = deque.partition_point(|&x| x < 5);/// assert_eq!(i, 4);/// assert!(deque.iter().take(i).all(|&x| x < 5));/// assert!(deque.iter().skip(i).all(|&x| !(x < 5)));/// sort order:/// let idx = deque.partition_point(|&x| x < num);// SAFETY: the following two methods require that the rotation amount// be less than half the length of the deque.// `wrap_copy` requires that `min(x, capacity() - x) + copy_len <= capacity()`,// but then `min` is never more than half the capacity, regardless of x,// so it's sound to call here because we're calling with something// less than half the length, which is never above half the capacity./// Modifies the deque in-place so that `len()` is equal to new_len,/// either by removing excess elements from the back or by appending clones of `value`/// to the back./// buf.resize(2, 0);/// buf.resize(5, 20);/// assert_eq!(buf, [5, 10, 20, 20, 20]);/// Clones the elements at the range `src` and appends them to the end./// Panics if the starting index is greater than the end index/// or if either index is greater than the length of the vector./// let mut characters = VecDeque::from(['a', 'b', 'c', 'd', 'e']);/// characters.extend_from_within(2..);/// assert_eq!(characters, ['a', 'b', 'c', 'd', 'e', 'c', 'd', 'e']);/// let mut numbers = VecDeque::from([0, 1, 2, 3, 4]);/// numbers.extend_from_within(..2);/// assert_eq!(numbers, [0, 1, 2, 3, 4, 0, 1]);/// let mut strings = VecDeque::from([String::from("hello"), String::from("world"), String::from("!")]);/// strings.extend_from_within(1..=2);/// assert_eq!(strings, ["hello", "world", "!", "world", "!"]);prepend_from_within/// Clones the elements at the range `src` and prepends them to the front./// characters.prepend_from_within(2..);/// assert_eq!(characters, ['c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']);/// numbers.prepend_from_within(..2);/// assert_eq!(numbers, [0, 1, 0, 1, 2, 3, 4]);/// strings.prepend_from_within(1..=2);/// assert_eq!(strings, ["world", "!", "hello", "world", "!"]);spec_extend_from_withinspec_prepend_from_withinSpecExtendFromWithin/// Associated functions have the following preconditions:/// - `src` needs to be a valid range: `src.start <= src.end <= self.len()`./// - The buffer must have enough spare capacity: `self.capacity() - self.len() >= src.len()`.wrap_index/// Returns the index in the underlying buffer for a given logical element index./// Consumes the deque into a front-to-back iterator yielding elements byextend_one_unchecked/// Turn a [`Vec<T>`] into a [`VecDeque<T>`]./// [`Vec<T>`]: crate::vec::Vec/// [`VecDeque<T>`]: crate::collections::VecDeque/// This conversion is guaranteed to run in *O*(1) time/// and to not re-allocate the `Vec`'s buffer or allocate/// any additional memory./// Turn a [`VecDeque<T>`] into a [`Vec<T>`]./// This never needs to re-allocate, but does need to do *O*(*n*) data movement if/// the circular buffer doesn't happen to be at the beginning of the allocation./// // This one is *O*(1)./// let deque: VecDeque<_> = (1..5).collect();/// let ptr = deque.as_slices().0.as_ptr();/// let vec = Vec::from(deque);/// assert_eq!(vec, [1, 2, 3, 4]);/// assert_eq!(vec.as_ptr(), ptr);/// // This one needs data rearranging./// let mut deque: VecDeque<_> = (1..5).collect();/// let ptr = deque.as_slices().1.as_ptr();/// assert_eq!(vec, [8, 9, 1, 2, 3, 4]);/// Converts a `[T; N]` into a `VecDeque<T>`./// let deq1 = VecDeque::from([1, 2, 3, 4]);/// let deq2: VecDeque<_> = [1, 2, 3, 4].into();/// assert_eq!(deq1, deq2);//! A double-ended queue (deque) implemented with a growable ring buffer.//! This queue has *O*(1) amortized inserts and removals from both ends of the//! container. It also has *O*(1) indexing like a vector. The contained elements//! are not required to be copyable, and the queue will be sendable if the//! contained type is sendable.// Specialization trait used for VecDeque::extendspec_extend_front// Specialization trait used for VecDeque::extend_front/// Elements of `slice` will be copied into the deque, make sure to forget the items if `T` is not `Copy`.prepend_reversed/// Specialization trait used for `VecDeque::from_iter`bench_push_back_100bench_push_front_100bench_pop_back_100bench_retain_whole_10000bench_retain_odd_10000bench_retain_half_10000bench_pop_front_100test_swap_front_back_removetest_swap"assertion failed: j < self.len()"test_swap_panictest_reserve_exact"capacity overflow"test_reserve_exact_panictest_try_reserve_exacttest_rotate_left_right"assertion failed: n <= self.len()"test_rotate_left_panictest_rotate_right_panictest_binary_searchtest_binary_search_keymake_contiguous_big_headmake_contiguous_big_tailmake_contiguous_small_freemake_contiguous_head_to_endmake_contiguous_head_to_end_2issue_108453test_shrink_totest_extend_basictest_extend_trusted_lentest_extend_impltest_from_arraytest_vec_from_vecdequetest_vec_deque_truncate_dropissue_53529issue_80303extract_if_non_contiguous"cstring_type"// Invariant 1: the slice ends with a zero byte and has a length of at least one.// Invariant 2: the slice contains only one zero byte.// Improper usage of unsafe function can break Invariant 2, but not Invariant 1./// A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the/// This type serves the purpose of being able to safely generate a/// C-compatible string from a Rust byte slice or vector. An instance of this/// type is a static guarantee that the underlying bytes contain no interior 0/// bytes ("nul characters") and that the final byte is 0 ("nul terminator")./// `CString` is to <code>&[CStr]</code> as [`String`] is to <code>&[str]</code>: the former/// in each pair are owned strings; the latter are borrowed/// # Creating a `CString`/// A `CString` is created from either a byte slice or a byte vector,/// or anything that implements <code>[Into]<[Vec]<[u8]>></code> (for/// example, you can build a `CString` straight out of a [`String`] or/// a <code>&[str]</code>, since both implement that trait)./// You can create a `CString` from a literal with `CString::from(c"Text")`./// The [`CString::new`] method will actually check that the provided <code>&[[u8]]</code>/// does not have 0 bytes in the middle, and return an error if it/// finds one./// # Extracting a raw pointer to the whole C string/// `CString` implements an [`as_ptr`][`CStr::as_ptr`] method through the [`Deref`]/// trait. This method will give you a `*const c_char` which you can/// feed directly to extern functions that expect a nul-terminated/// string, like C's `strdup()`. Notice that [`as_ptr`][`CStr::as_ptr`] returns a/// read-only pointer; if the C code writes to it, that causes/// # Extracting a slice of the whole C string/// Alternatively, you can obtain a <code>&[[u8]]</code> slice from a/// `CString` with the [`CString::as_bytes`] method. Slices produced in this/// way do *not* contain the trailing nul terminator. This is useful/// when you will be calling an extern function that takes a `*const/// u8` argument which is not necessarily nul-terminated, plus another/// argument with the length of the string — like C's `strndup()`./// You can of course get the slice's length with its/// [`len`][slice::len] method./// If you need a <code>&[[u8]]</code> slice *with* the nul terminator, you/// can use [`CString::as_bytes_with_nul`] instead./// Once you have the kind of slice you need (with or without a nul/// terminator), you can call the slice's own/// [`as_ptr`][slice::as_ptr] method to get a read-only raw pointer to pass to/// extern functions. See the documentation for that function for a/// discussion on ensuring the lifetime of the raw pointer./// [str]: prim@str "str"/// [`Deref`]: ops::Deref/// ```ignore (extern-declaration)/// use std::os::raw::c_char;///     fn my_printer(s: *const c_char);/// // We are certain that our string doesn't have 0 bytes in the middle,/// // so we can .expect()/// let c_to_print = CString::new("Hello, world!").expect("CString::new failed");///     my_printer(c_to_print.as_ptr());/// `CString` is intended for working with traditional C-style strings/// (a sequence of non-nul bytes terminated by a single nul byte); the/// primary use case for these kinds of strings is interoperating with C-like/// code. Often you will need to transfer ownership to/from that external/// code. It is strongly recommended that you thoroughly read through the/// documentation of `CString` before use, as improper ownership management/// of `CString` instances can lead to invalid memory accesses, memory leaks,/// and other memory errors./// An error indicating that an interior nul byte was found./// While Rust strings may contain nul bytes in the middle, C strings/// can't, as that byte would effectively truncate the string./// This error is created by the [`new`][`CString::new`] method on/// [`CString`]. See its documentation for more./// use std::ffi::{CString, NulError};/// let _: NulError = CString::new(b"f\0oo".to_vec()).unwrap_err();FromBytesWithNulErrorKindNotNulTerminatedFromVecWithNulError/// An error indicating that a nul byte was not in the expected position./// The vector used to create a [`CString`] must have one and only one nul byte,/// positioned at the end./// This error is created by the [`CString::from_vec_with_nul`] method./// use std::ffi::{CString, FromVecWithNulError};/// let _: FromVecWithNulError = CString::from_vec_with_nul(b"f\0oo".to_vec()).unwrap_err();/// Returns a slice of [`u8`]s bytes that were attempted to convert to a [`CString`]./// // Some invalid bytes in a vector/// let bytes = b"f\0oo".to_vec();/// let value = CString::from_vec_with_nul(bytes.clone());/// assert_eq!(&bytes[..], value.unwrap_err().as_bytes());/// Returns the bytes that were attempted to convert to a [`CString`]./// This method is carefully constructed to avoid allocation. It will/// consume the error, moving out the bytes, so that a copy of the bytes/// does not need to be made./// assert_eq!(bytes, value.unwrap_err().into_bytes());/// An error indicating invalid UTF-8 when converting a [`CString`] into a [`String`]./// `CString` is just a wrapper over a buffer of bytes with a nul terminator;/// [`CString::into_string`] performs UTF-8 validation on those bytes and may/// return this error./// This `struct` is created by [`CString::into_string()`]. See/// Creates a new C-compatible string from a container of bytes./// This function will consume the provided data and use the/// underlying bytes to construct a new string, ensuring that/// there is a trailing 0 byte. This trailing 0 byte will be/// appended by this function; the provided data should *not*/// contain any 0 bytes in it./// extern "C" { fn puts(s: *const c_char); }/// let to_print = CString::new("Hello!").expect("CString::new failed");///     puts(to_print.as_ptr());/// This function will return an error if the supplied bytes contain an/// internal 0 byte. The [`NulError`] returned will contain the bytes as well as/// the position of the nul byte./// Creates a C-compatible string by consuming a byte vector,/// without checking for interior 0 bytes./// Trailing 0 byte will be appended by this function./// This method is equivalent to [`CString::new`] except that no runtime/// assertion is made that `v` contains no 0 bytes, and it requires an/// actual byte vector, not anything that can be converted to one with Into./// let raw = b"foo".to_vec();///     let c_string = CString::from_vec_unchecked(raw);_from_vec_unchecked"call `drop(from_raw(ptr))` if you intend to drop the `CString`"/// Retakes ownership of a `CString` that was transferred to C via/// [`CString::into_raw`]./// Additionally, the length of the string will be recalculated from the pointer./// This should only ever be called with a pointer that was earlier/// obtained by calling [`CString::into_raw`], and the memory it points to must not be accessed/// through any other pointer during the lifetime of reconstructed `CString`./// Other usage (e.g., trying to take ownership of a string that was allocated by foreign code)/// is likely to lead to undefined behavior or allocator corruption./// This function does not validate ownership of the raw pointer's memory./// A double-free may occur if the function is called twice on the same raw pointer./// Additionally, the caller must ensure the pointer is not dangling./// It should be noted that the length isn't just "recomputed," but that/// the recomputed length must match the original length from the/// [`CString::into_raw`] call. This means the [`CString::into_raw`]/`from_raw`/// methods should not be used when passing the string to C functions that can/// modify the string's length./// > **Note:** If you need to borrow a string that was allocated by/// > foreign code, use [`CStr`]. If you need to take ownership of/// > a string that was allocated by foreign code, you will need to/// > make your own provisions for freeing it appropriately, likely/// > with the foreign code's API to do that./// Creates a `CString`, pass ownership to an `extern` function (via raw pointer), then retake/// ownership with `from_raw`:///     fn some_extern_function(s: *mut c_char);/// let c_string = CString::from(c"Hello!");/// let raw = c_string.into_raw();///     some_extern_function(raw);///     let c_string = CString::from_raw(raw);/// Consumes the `CString` and transfers ownership of the string to a C caller./// The pointer which this function returns must be returned to Rust and reconstituted using/// [`CString::from_raw`] to be properly deallocated. Specifically, one/// should *not* use the standard C `free()` function to deallocate/// this string./// Failure to call [`CString::from_raw`] will lead to a memory leak./// The C side must **not** modify the length of the string (by writing a/// nul byte somewhere inside the string or removing the final one) before/// it makes it back into Rust using [`CString::from_raw`]. See the safety section/// in [`CString::from_raw`]./// let c_string = CString::from(c"foo");/// let ptr = c_string.into_raw();///     assert_eq!(b'f', *ptr as u8);///     assert_eq!(b'o', *ptr.add(1) as u8);///     assert_eq!(b'o', *ptr.add(2) as u8);///     assert_eq!(b'\0', *ptr.add(3) as u8);///     // retake pointer to free memory///     let _ = CString::from_raw(ptr);/// Converts the `CString` into a [`String`] if it contains valid UTF-8 data./// On failure, ownership of the original `CString` is returned./// let valid_utf8 = vec![b'f', b'o', b'o'];/// let cstring = CString::new(valid_utf8).expect("CString::new failed");/// assert_eq!(cstring.into_string().expect("into_string() call failed"), "foo");/// let invalid_utf8 = vec![b'f', 0xff, b'o', b'o'];/// let cstring = CString::new(invalid_utf8).expect("CString::new failed");/// let err = cstring.into_string().err().expect("into_string().err() failed");/// assert_eq!(err.utf8_error().valid_up_to(), 1);/// Consumes the `CString` and returns the underlying byte buffer./// The returned buffer does **not** contain the trailing nul/// terminator, and it is guaranteed to not have any interior nul/// let bytes = c_string.into_bytes();/// assert_eq!(bytes, vec![b'f', b'o', b'o']);/// Equivalent to [`CString::into_bytes()`] except that the/// returned vector includes the trailing nul terminator./// let bytes = c_string.into_bytes_with_nul();/// assert_eq!(bytes, vec![b'f', b'o', b'o', b'\0']);/// Returns the contents of this `CString` as a slice of bytes./// The returned slice does **not** contain the trailing nul/// bytes. If you need the nul terminator, use/// [`CString::as_bytes_with_nul`] instead./// let bytes = c_string.as_bytes();/// assert_eq!(bytes, &[b'f', b'o', b'o']);/// Equivalent to [`CString::as_bytes()`] except that the/// returned slice includes the trailing nul terminator./// let bytes = c_string.as_bytes_with_nul();/// assert_eq!(bytes, &[b'f', b'o', b'o', b'\0']);"cstring_as_c_str"/// Extracts a [`CStr`] slice containing the entire string./// use std::ffi::{CString, CStr};/// let cstr = c_string.as_c_str();/// assert_eq!(cstr,///            CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));into_boxed_c_str/// Converts this `CString` into a boxed [`CStr`]./// let c_string = c"foo".to_owned();/// let boxed = c_string.into_boxed_c_str();/// assert_eq!(boxed.to_bytes_with_nul(), b"foo\0");/// Bypass "move out of struct which implements [`Drop`] trait" restriction.from_vec_with_nul_unchecked/// Converts a <code>[Vec]<[u8]></code> to a [`CString`] without checking the/// invariants on the given [`Vec`]./// The given [`Vec`] **must** have one nul byte as its last element./// This means it cannot be empty nor have any other nul byte anywhere else.///     unsafe { CString::from_vec_with_nul_unchecked(b"abc\0".to_vec()) },///     unsafe { CString::from_vec_unchecked(b"abc".to_vec()) }_from_vec_with_nul_uncheckedfrom_vec_with_nul/// Attempts to converts a <code>[Vec]<[u8]></code> to a [`CString`]./// Runtime checks are present to ensure there is only one nul byte in the/// [`Vec`], its last element./// If a nul byte is present and not the last element or no nul bytes/// is present, an error will be returned./// A successful conversion will produce the same result as [`CString::new`]/// when called without the ending nul byte.///     CString::from_vec_with_nul(b"abc\0".to_vec())///         .expect("CString::from_vec_with_nul failed"),///     c"abc".to_owned()/// An incorrectly formatted [`Vec`] will produce an error./// // Interior nul byte/// let _: FromVecWithNulError = CString::from_vec_with_nul(b"a\0bc".to_vec()).unwrap_err();/// // No nul byte/// let _: FromVecWithNulError = CString::from_vec_with_nul(b"abc".to_vec()).unwrap_err();// Turns this `CString` into an empty string to prevent// memory-unsafe code from working by accident. Inline// to prevent LLVM from optimizing it away in debug builds./// Delegates to the [`CStr`] implementation of [`fmt::Debug`],/// showing invalid UTF-8 as hex escapes./// Converts a [`CString`] into a <code>[Vec]<[u8]></code>./// The conversion consumes the [`CString`], and removes the terminating NUL byte./// Creates an empty `CString`./// Converts a `Cow<'a, CStr>` into a `CString`, by copying the contents if they are/// borrowed./// Converts a `&CStr` into a `Box<CStr>`,/// by copying the contents into a newly allocated [`Box`]./// Converts a `&mut CStr` into a `Box<CStr>`,/// Converts a `Cow<'a, CStr>` into a `Box<CStr>`,/// by copying the contents if they are borrowed./// Converts a <code>[Box]<[CStr]></code> into a [`CString`] without copying or allocating./// Converts a <code>[Vec]<[NonZero]<[u8]>></code> into a [`CString`] without/// copying nor checking for inner nul bytes./// Converts a string `s` into a [`CString`]./// This method is equivalent to [`CString::new`]./// Converts a [`CString`] into a [`String`] if it contains valid UTF-8 data./// This method is equivalent to [`CString::into_string`]./// Converts a [`CString`] into a <code>[Box]<[CStr]></code> without copying or allocating./// Converts a [`CString`] into an owned [`Cow`] without copying or allocating./// Converts a [`CStr`] into a borrowed [`Cow`] without copying or allocating./// Converts a `&`[`CString`] into a borrowed [`Cow`] without copying or allocating./// Converts a [`CString`] into an <code>[Arc]<[CStr]></code> by moving the [`CString`]/// data into a new [`Arc`] buffer./// Converts a `&CStr` into a `Arc<CStr>`,/// by copying the contents into a newly allocated [`Arc`]./// Converts a `&mut CStr` into a `Arc<CStr>`,/// Converts a [`CString`] into an <code>[Rc]<[CStr]></code> by moving the [`CString`]/// data into a new [`Rc`] buffer./// Converts a `&CStr` into a `Rc<CStr>`,/// by copying the contents into a newly allocated [`Rc`]./// Converts a `&mut CStr` into a `Rc<CStr>`,/// Creates an empty CStr inside an Rc/// This may or may not share an allocation with other Rcs on the same thread./// Returns the position of the nul byte in the slice that caused/// [`CString::new`] to fail./// let nul_error = CString::new("foo\0bar").unwrap_err();/// assert_eq!(nul_error.nul_position(), 3);/// let nul_error = CString::new("foo bar\0").unwrap_err();/// assert_eq!(nul_error.nul_position(), 7);/// Consumes this error, returning the underlying vector of bytes which/// generated the error in the first place./// assert_eq!(nul_error.into_vec(), b"foo\0bar");/// Consumes this error, returning original [`CString`] which generated the/// Access the underlying UTF-8 error that was the cause of this error./// Converts a <code>&[CStr]</code> into a [`CString`]/// by copying the contents into a new allocation./// Converts a `CStr` into a <code>[Cow]<[str]></code>./// If the contents of the `CStr` are valid UTF-8 data, this/// function will return a <code>[Cow]::[Borrowed]\(&[str])</code>/// with the corresponding <code>&[str]</code> slice. Otherwise, it will/// replace any invalid UTF-8 sequences with/// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD] and return a/// <code>[Cow]::[Owned]\([String])</code> with the result./// [Borrowed]: Cow::Borrowed/// [Owned]: Cow::Owned/// [U+FFFD]: core::char::REPLACEMENT_CHARACTER "std::char::REPLACEMENT_CHARACTER"/// Calling `to_string_lossy` on a `CStr` containing valid UTF-8. The leading/// `c` on the string literal denotes a `CStr`./// assert_eq!(c"Hello World".to_string_lossy(), Cow::Borrowed("Hello World"));/// Calling `to_string_lossy` on a `CStr` containing invalid UTF-8:///     c"Hello \xF0\x90\x80World".to_string_lossy(),///     Cow::Owned(String::from("Hello �World")) as Cow<'_, str>/// use std::ffi::{CStr, CString};/// let boxed: Box<CStr> = Box::from(c"foo");/// let c_string: CString = c"foo".to_owned();/// assert_eq!(boxed.into_c_string(), c_string);//! [`CString`] and its related types.//! This module provides utilities to handle data across non-Rust//! interfaces, like other programming languages and the underlying//! operating system. It is mainly of use for FFI (Foreign Function//! Interface) bindings and code that needs to exchange C-like strings//! with other languages.//! Rust represents owned strings with the [`String`] type, and//! borrowed slices of strings with the [`str`] primitive. Both are//! always in UTF-8 encoding, and may contain nul bytes in the middle,//! i.e., if you look at the bytes that make up the string, there may//! be a `\0` among them. Both `String` and `str` store their length//! explicitly; there are no nul terminators at the end of strings//! like in C.//! C strings are different from Rust strings://! * **Encodings** - Rust strings are UTF-8, but C strings may use//! other encodings. If you are using a string from C, you should//! check its encoding explicitly, rather than just assuming that it//! is UTF-8 like you can do in Rust.//! * **Character size** - C strings may use `char` or `wchar_t`-sized//! characters; please **note** that C's `char` is different from Rust's.//! The C standard leaves the actual sizes of those types open to//! interpretation, but defines different APIs for strings made up of//! each character type. Rust strings are always UTF-8, so different//! Unicode characters will be encoded in a variable number of bytes//! each. The Rust type [`char`] represents a '[Unicode scalar//! value]', which is similar to, but not the same as, a '[Unicode//! code point]'.//! * **Nul terminators and implicit string lengths** - Often, C//! strings are nul-terminated, i.e., they have a `\0` character at the//! end. The length of a string buffer is not stored, but has to be//! calculated; to compute the length of a string, C code must//! manually call a function like `strlen()` for `char`-based strings,//! or `wcslen()` for `wchar_t`-based ones. Those functions return//! the number of characters in the string excluding the nul//! terminator, so the buffer length is really `len+1` characters.//! Rust strings don't have a nul terminator; their length is always//! stored and does not need to be calculated. While in Rust//! accessing a string's length is an *O*(1) operation (because the//! length is stored); in C it is an *O*(*n*) operation because the//! length needs to be computed by scanning the string for the nul//! terminator.//! * **Internal nul characters** - When C strings have a nul//! terminator character, this usually means that they cannot have nul//! characters in the middle — a nul character would essentially//! truncate the string. Rust strings *can* have nul characters in//! the middle, because nul does not have to mark the end of the//! string in Rust.//! # Representations of non-Rust strings//! [`CString`] and [`CStr`] are useful when you need to transfer//! UTF-8 strings to and from languages with a C ABI, like Python.//! * **From Rust to C:** [`CString`] represents an owned, C-friendly//! string: it is nul-terminated, and has no internal nul characters.//! Rust code can create a [`CString`] out of a normal string (provided//! that the string doesn't have nul characters in the middle), and//! then use a variety of methods to obtain a raw <code>\*mut [u8]</code> that can//! then be passed as an argument to functions which use the C//! conventions for strings.//! * **From C to Rust:** [`CStr`] represents a borrowed C string; it//! is what you would use to wrap a raw <code>\*const [u8]</code> that you got from//! a C function. A [`CStr`] is guaranteed to be a nul-terminated array//! of bytes. Once you have a [`CStr`], you can convert it to a Rust//! <code>&[str]</code> if it's valid UTF-8, or lossily convert it by adding//! replacement characters.//! [`String`]: crate::string::String//! [`CStr`]: core::ffi::CStrDebugAsHexFormattingOptionsFromFn/// Takes an [`Arguments`] struct and returns the resulting formatted string./// The [`Arguments`] instance can be created with the [`format_args!`] macro./// let s = fmt::format(format_args!("Hello, {}!", "world"));/// assert_eq!(s, "Hello, world!");/// Please note that using [`format!`] might be preferable./// let s = format!("Hello, {}!", "world");/// [`format_args!`]: core::format_args/// [`format!`]: crate::format//! Utilities for formatting and printing `String`s.//! This module contains the runtime support for the [`format!`] syntax extension.//! This macro is implemented in the compiler to emit calls to this module in//! order to format arguments at runtime into strings.//! The [`format!`] macro is intended to be familiar to those coming from C's//! `printf`/`fprintf` functions or Python's `str.format` function.//! Some examples of the [`format!`] extension are://! # #![allow(unused_must_use)]//! format!("Hello");                 // => "Hello"//! format!("Hello, {}!", "world");   // => "Hello, world!"//! format!("The number is {}", 1);   // => "The number is 1"//! format!("{:?}", (3, 4));          // => "(3, 4)"//! format!("{value}", value=4);      // => "4"//! let people = "Rustaceans";//! format!("Hello {people}!");       // => "Hello Rustaceans!"//! format!("{} {}", 1, 2);           // => "1 2"//! format!("{:04}", 42);             // => "0042" with leading zeros//! format!("{:#?}", (100, 200));     // => "(//!                                   //       100,//!                                   //       200,//!                                   //     )"//! From these, you can see that the first argument is a format string. It is//! required by the compiler for this to be a string literal; it cannot be a//! variable passed in (in order to perform validity checking). The compiler//! will then parse the format string and determine if the list of arguments//! provided is suitable to pass to this format string.//! To convert a single value to a string, use the [`to_string`] method. This//! will use the [`Display`] formatting trait.//! ## Positional parameters//! Each formatting argument is allowed to specify which value argument it's//! referencing, and if omitted it is assumed to be "the next argument". For//! example, the format string `{} {} {}` would take three parameters, and they//! would be formatted in the same order as they're given. The format string//! `{2} {1} {0}`, however, would format arguments in reverse order.//! Things can get a little tricky once you start intermingling the two types of//! positional specifiers. The "next argument" specifier can be thought of as an//! iterator over the argument. Each time a "next argument" specifier is seen,//! the iterator advances. This leads to behavior like this://! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"//! The internal iterator over the argument has not been advanced by the time//! the first `{}` is seen, so it prints the first argument. Then upon reaching//! the second `{}`, the iterator has advanced forward to the second argument.//! Essentially, parameters that explicitly name their argument do not affect//! parameters that do not name an argument in terms of positional specifiers.//! A format string is required to use all of its arguments, otherwise it is a//! compile-time error. You may refer to the same argument more than once in the//! format string.//! ## Named parameters//! Rust itself does not have a Python-like equivalent of named parameters to a//! function, but the [`format!`] macro is a syntax extension that allows it to//! leverage named parameters. Named parameters are listed at the end of the//! argument list and have the syntax://! identifier '=' expression//! For example, the following [`format!`] expressions all use named arguments://! format!("{argument}", argument = "test");   // => "test"//! format!("{name} {}", 1, name = 2);          // => "2 1"//! format!("{a} {c} {b}", a="a", b='b', c=3);  // => "a 3 b"//! If a named parameter does not appear in the argument list, `format!` will//! reference a variable with that name in the current scope.//! let argument = 2 + 2;//! format!("{argument}");   // => "4"//! fn make_string(a: u32, b: &str) -> String {//!     format!("{b} {a}")//! make_string(927, "label"); // => "label 927"//! It is not valid to put positional parameters (those without names) after//! arguments that have names. Like with positional parameters, it is not//! valid to provide named parameters that are unused by the format string.//! # Formatting Parameters//! Each argument being formatted can be transformed by a number of formatting//! parameters (corresponding to `format_spec` in [the syntax](#syntax)). These//! parameters affect the string representation of what's being formatted.//! The colon `:` in format syntax divides identifier of the input data and//! the formatting options, the colon itself does not change anything, only//! introduces the options.//! let a = 5;//! let b = &a;//! println!("{a:e} {b:p}"); // => 5e0 0x7ffe37b7273c//! ## Width//! // All of these print "Hello x    !"//! println!("Hello {:5}!", "x");//! println!("Hello {:1$}!", "x", 5);//! println!("Hello {1:0$}!", 5, "x");//! println!("Hello {:width$}!", "x", width = 5);//! let width = 5;//! println!("Hello {:width$}!", "x");//! This is a parameter for the "minimum width" that the format should take up.//! If the value's string does not fill up this many characters, then the//! padding specified by fill/alignment will be used to take up the required//! space (see below).//! The value for the width can also be provided as a [`usize`] in the list of//! parameters by adding a postfix `$`, indicating that the second argument is//! a [`usize`] specifying the width.//! Referring to an argument with the dollar syntax does not affect the "next//! argument" counter, so it's usually a good idea to refer to arguments by//! position, or use named arguments.//! ## Fill/Alignment//! assert_eq!(format!("Hello {:<5}!", "x"),  "Hello x    !");//! assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!");//! assert_eq!(format!("Hello {:^5}!", "x"),  "Hello   x  !");//! assert_eq!(format!("Hello {:>5}!", "x"),  "Hello     x!");//! The optional fill character and alignment is provided normally in conjunction with the//! [`width`](#width) parameter. It must be defined before `width`, right after the `:`.//! This indicates that if the value being formatted is smaller than//! `width` some extra characters will be printed around it.//! Filling comes in the following variants for different alignments://! * `[fill]<` - the argument is left-aligned in `width` columns//! * `[fill]^` - the argument is center-aligned in `width` columns//! * `[fill]>` - the argument is right-aligned in `width` columns//! The default [fill/alignment](#fillalignment) for non-numerics is a space and//! left-aligned. The//! default for numeric formatters is also a space character but with right-alignment. If//! the `0` flag (see below) is specified for numerics, then the implicit fill character is//! `0`.//! Note that alignment might not be implemented by some types. In particular, it//! is not generally implemented for the `Debug` trait.  A good way to ensure//! padding is applied is to format your input, then pad this resulting string//! to obtain your output://! println!("Hello {:^15}!", format!("{:?}", Some("hi"))); // => "Hello   Some("hi")   !"//! ## Sign/`#`/`0`//! assert_eq!(format!("Hello {:+}!", 5), "Hello +5!");//! assert_eq!(format!("{:#x}!", 27), "0x1b!");//! assert_eq!(format!("Hello {:05}!", 5),  "Hello 00005!");//! assert_eq!(format!("Hello {:05}!", -5), "Hello -0005!");//! assert_eq!(format!("{:#010x}!", 27), "0x0000001b!");//! These are all flags altering the behavior of the formatter.//! * `+` - This is intended for numeric types and indicates that the sign//!         should always be printed. By default only the negative sign of signed values//!         is printed, and the sign of positive or unsigned values is omitted.//!         This flag indicates that the correct sign (`+` or `-`) should always be printed.//! * `-` - Currently not used//! * `#` - This flag indicates that the "alternate" form of printing should//!         be used. The alternate forms are://!     * `#?` - pretty-print the [`Debug`] formatting (adds linebreaks and indentation)//!     * `#x` - precedes the argument with a `0x`//!     * `#X` - precedes the argument with a `0x`//!     * `#b` - precedes the argument with a `0b`//!     * `#o` - precedes the argument with a `0o`//!   See [Formatting traits](#formatting-traits) for a description of what the `?`, `x`, `X`,//!   `b`, and `o` flags do.//! * `0` - This is used to indicate for integer formats that the padding to `width` should//!         both be done with a `0` character as well as be sign-aware. A format//!         like `{:08}` would yield `00000001` for the integer `1`, while the//!         same format would yield `-0000001` for the integer `-1`. Notice that//!         the negative version has one fewer zero than the positive version.//!         Note that padding zeros are always placed after the sign (if any)//!         and before the digits. When used together with the `#` flag, a similar//!         rule applies: padding zeros are inserted after the prefix but before//!         the digits. The prefix is included in the total width.//!         This flag overrides the [fill character and alignment flag](#fillalignment).//! ## Precision//! For non-numeric types, this can be considered a "maximum width". If the resulting string is//! longer than this width, then it is truncated down to this many characters and that truncated//! value is emitted with proper `fill`, `alignment` and `width` if those parameters are set.//! For integral types, this is ignored.//! For floating-point types, this indicates how many digits after the decimal point should be//! printed.//! There are three possible ways to specify the desired `precision`://! 1. An integer `.N`://!    the integer `N` itself is the precision.//! 2. An integer or name followed by dollar sign `.N$`://!    use format *argument* `N` (which must be a `usize`) as the precision.//! 3. An asterisk `.*`://!    `.*` means that this `{...}` is associated with *two* format inputs rather than one://!    - If a format string in the fashion of `{:<spec>.*}` is used, then the first input holds//!      the `usize` precision, and the second holds the value to print.//!    - If a format string in the fashion of `{<arg>:<spec>.*}` is used, then the `<arg>` part//!      refers to the value to print, and the `precision` is taken like it was specified with an//!      omitted positional parameter (`{}` instead of `{<arg>:}`).//! For example, the following calls all print the same thing `Hello x is 0.01000`://! // Hello {arg 0 ("x")} is {arg 1 (0.01) with precision specified inline (5)}//! println!("Hello {0} is {1:.5}", "x", 0.01);//! // Hello {arg 1 ("x")} is {arg 2 (0.01) with precision specified in arg 0 (5)}//! println!("Hello {1} is {2:.0$}", 5, "x", 0.01);//! // Hello {arg 0 ("x")} is {arg 2 (0.01) with precision specified in arg 1 (5)}//! println!("Hello {0} is {2:.1$}", "x", 5, 0.01);//! // Hello {next arg -> arg 0 ("x")} is {second of next two args -> arg 2 (0.01) with precision//! //                          specified in first of next two args -> arg 1 (5)}//! println!("Hello {} is {:.*}",    "x", 5, 0.01);//! // Hello {arg 1 ("x")} is {arg 2 (0.01) with precision//! //                          specified in next arg -> arg 0 (5)}//! println!("Hello {1} is {2:.*}",  5, "x", 0.01);//! // Hello {next arg -> arg 0 ("x")} is {arg 2 (0.01) with precision//! //                          specified in next arg -> arg 1 (5)}//! println!("Hello {} is {2:.*}",   "x", 5, 0.01);//! // Hello {next arg -> arg 0 ("x")} is {arg "number" (0.01) with precision specified//! //                          in arg "prec" (5)}//! println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01);//! While these://! println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56);//! println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56");//! println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56");//! print three significantly different things://! Hello, `1234.560` has 3 fractional digits//! Hello, `123` has 3 characters//! Hello, `     123` has 3 right-aligned characters//! When truncating these values, Rust uses [round half-to-even](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even),//! which is the default rounding mode in IEEE 754.//! print!("{0:.1$e}", 12345, 3);//! print!("{0:.1$e}", 12355, 3);//! Would return://! 1.234e4//! 1.236e4//! ## Localization//! In some programming languages, the behavior of string formatting functions//! depends on the operating system's locale setting. The format functions//! provided by Rust's standard library do not have any concept of locale and//! will produce the same results on all systems regardless of user//! For example, the following code will always print `1.5` even if the system//! locale uses a decimal separator other than a dot.//! println!("The value is {}", 1.5);//! # Escaping//! The literal characters `{` and `}` may be included in a string by preceding//! them with the same character. For example, the `{` character is escaped with//! `{{` and the `}` character is escaped with `}}`.//! assert_eq!(format!("Hello {{}}"), "Hello {}");//! assert_eq!(format!("{{ Hello"), "{ Hello");//! # Syntax//! To summarize, here you can find the full grammar of format strings.//! The syntax for the formatting language used is drawn from other languages,//! so it should not be too alien. Arguments are formatted with Python-like//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like//! `%`. The actual grammar for the formatting syntax is://! format_string := text [ maybe_format text ] *//! maybe_format := '{' '{' | '}' '}' | format//! format := '{' [ argument ] [ ':' format_spec ] [ ws ] * '}'//! argument := integer | identifier//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type]//! fill := character//! align := '<' | '^' | '>'//! sign := '+' | '-'//! width := count//! precision := count | '*'//! type := '?' | 'x?' | 'X?' | 'o' | 'x' | 'X' | 'p' | 'b' | 'e' | 'E'//! count := parameter | integer//! parameter := argument '$'//! In the above grammar,//! - `text` must not contain any `'{'` or `'}'` characters,//! - `ws` is any character for which [`char::is_whitespace`] returns `true`, has no semantic//!   meaning and is completely optional,//! - `integer` is a decimal integer that may contain leading zeroes and must fit into an `usize` and//! - `identifier` is an `IDENTIFIER_OR_KEYWORD` (not an `IDENTIFIER`) as defined by the [Rust language reference](https://doc.rust-lang.org/reference/identifiers.html).//! # Formatting traits//! When requesting that an argument be formatted with a particular type, you//! are actually requesting that an argument ascribes to a particular trait.//! This allows multiple actual types to be formatted via `{:x}` (like [`i8`] as//! well as [`isize`]). The current mapping of types to traits is://! * *nothing* ⇒ [`Display`]//! * `?` ⇒ [`Debug`]//! * `x?` ⇒ [`Debug`] with lower-case hexadecimal integers//! * `X?` ⇒ [`Debug`] with upper-case hexadecimal integers//! * `o` ⇒ [`Octal`]//! * `x` ⇒ [`LowerHex`]//! * `X` ⇒ [`UpperHex`]//! * `p` ⇒ [`Pointer`]//! * `b` ⇒ [`Binary`]//! * `e` ⇒ [`LowerExp`]//! * `E` ⇒ [`UpperExp`]//! What this means is that any type of argument which implements the//! [`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations//! are provided for these traits for a number of primitive types by the//! standard library as well. If no format is specified (as in `{}` or `{:6}`),//! then the format trait used is the [`Display`] trait.//! When implementing a format trait for your own type, you will have to//! implement a method of the signature://! # use std::fmt;//! # struct Foo; // our custom type//! # impl fmt::Display for Foo {//! fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {//! # write!(f, "testing, testing")//! # } }//! Your type will be passed as `self` by-reference, and then the function//! should emit output into the Formatter `f` which implements `fmt::Write`. It is up to each//! format trait implementation to correctly adhere to the requested formatting parameters.//! The values of these parameters can be accessed with methods of the//! [`Formatter`] struct. In order to help with this, the [`Formatter`] struct also//! provides some helper methods.//! Additionally, the return value of this function is [`fmt::Result`] which is a//! type alias of <code>[Result]<(), [std::fmt::Error]></code>. Formatting implementations//! should ensure that they propagate errors from the [`Formatter`] (e.g., when//! calling [`write!`]). However, they should never return errors spuriously. That//! is, a formatting implementation must and may only return an error if the//! passed-in [`Formatter`] returns an error. This is because, contrary to what//! the function signature might suggest, string formatting is an infallible//! operation. This function only returns a [`Result`] because writing to the//! underlying stream might fail and it must provide a way to propagate the fact//! that an error has occurred back up the stack.//! An example of implementing the formatting traits would look//! struct Vector2D {//!     x: isize,//!     y: isize,//! impl fmt::Display for Vector2D {//!     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {//!         // The `f` value implements the `Write` trait, which is what the//!         // write! macro is expecting. Note that this formatting ignores the//!         // various flags provided to format strings.//!         write!(f, "({}, {})", self.x, self.y)//! // Different traits allow different forms of output of a type. The meaning//! // of this format is to print the magnitude of a vector.//! impl fmt::Binary for Vector2D {//!         let magnitude = (self.x * self.x + self.y * self.y) as f64;//!         let magnitude = magnitude.sqrt();//!         // Respect the formatting flags by using the helper method//!         // `pad_integral` on the Formatter object. See the method//!         // documentation for details, and the function `pad` can be used//!         // to pad strings.//!         let decimals = f.precision().unwrap_or(3);//!         let string = format!("{magnitude:.decimals$}");//!         f.pad_integral(true, "", &string)//!     let myvector = Vector2D { x: 3, y: 4 };//!     println!("{myvector}");       // => "(3, 4)"//!     println!("{myvector:?}");     // => "Vector2D {x: 3, y:4}"//!     println!("{myvector:10.3b}"); // => "     5.000"//! ### `fmt::Display` vs `fmt::Debug`//! These two formatting traits have distinct purposes://! - [`fmt::Display`][`Display`] implementations assert that the type can be faithfully//!   represented as a UTF-8 string at all times. It is **not** expected that//!   all types implement the [`Display`] trait.//! - [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types.//!   Output will typically represent the internal state as faithfully as possible.//!   The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In//!   most cases, using `#[derive(Debug)]` is sufficient and recommended.//! Some examples of the output from both traits://! assert_eq!(format!("{} {:?}", 3, 4), "3 4");//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");//! # Related macros//! There are a number of related macros in the [`format!`] family. The ones that//! are currently implemented are://! ```ignore (only-for-syntax-highlight)//! format!      // described above//! write!       // first argument is either a &mut io::Write or a &mut fmt::Write, the destination//! writeln!     // same as write but appends a newline//! print!       // the format string is printed to the standard output//! println!     // same as print but appends a newline//! eprint!      // the format string is printed to the standard error//! eprintln!    // same as eprint but appends a newline//! format_args! // described below.//! ### `write!`//! [`write!`] and [`writeln!`] are two macros which are used to emit the format string//! to a specified stream. This is used to prevent intermediate allocations of//! format strings and instead directly write the output. Under the hood, this//! function is actually invoking the [`write_fmt`] function defined on the//! [`std::io::Write`] and the [`std::fmt::Write`] trait. Example usage is://! let mut w = Vec::new();//! write!(&mut w, "Hello {}!", "world");//! ### `print!`//! This and [`println!`] emit their output to stdout. Similarly to the [`write!`]//! macro, the goal of these macros is to avoid intermediate allocations when//! printing output. Example usage is://! print!("Hello {}!", "world");//! println!("I have a newline {}", "character at the end");//! ### `eprint!`//! The [`eprint!`] and [`eprintln!`] macros are identical to//! [`print!`] and [`println!`], respectively, except they emit their//! output to stderr.//! ### `format_args!`//! [`format_args!`] is a curious macro used to safely pass around//! an opaque object describing the format string. This object//! does not require any heap allocations to create, and it only//! references information on the stack. Under the hood, all of//! the related macros are implemented in terms of this. First//! off, some example usage is://! let mut some_writer = io::stdout();//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));//! fn my_fmt_fn(args: fmt::Arguments<'_>) {//!     write!(&mut io::stdout(), "{args}");//! my_fmt_fn(format_args!(", or a {} too", "function"));//! The result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].//! This structure can then be passed to the [`write`] and [`format`] functions//! inside this module in order to process the format string.//! The goal of this macro is to even further prevent intermediate allocations//! when dealing with formatting strings.//! For example, a logging library could use the standard formatting syntax, but//! it would internally pass around this structure until it has been determined//! where output should go to.//! [`fmt::Result`]: Result "fmt::Result"//! [Result]: core::result::Result "std::result::Result"//! [std::fmt::Error]: Error "fmt::Error"//! [`write`]: write() "fmt::write"//! [`to_string`]: crate::string::ToString::to_string "ToString::to_string"//! [`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt//! [`std::io::Write`]: ../../std/io/trait.Write.html//! [`std::fmt::Write`]: ../../std/fmt/trait.Write.html//! [`print!`]: ../../std/macro.print.html "print!"//! [`println!`]: ../../std/macro.println.html "println!"//! [`eprint!`]: ../../std/macro.eprint.html "eprint!"//! [`eprintln!`]: ../../std/macro.eprintln.html "eprintln!"//! [`format_args!`]: ../../std/macro.format_args.html "format_args!"//! [`fmt::Arguments`]: Arguments "fmt::Arguments"//! [`format`]: format() "fmt::format"realalloc//! Grep bootstrap for `MIRI_REPLACE_LIBRS_IF_NOT_TEST` to learn what this is about.needs_allocatorrustc_preserve_ub_checks// Module with internal macros used by other modules (needs to be included before other modules).// Heaps provided for low-level allocation strategies// Need to conditionally define the mod from `boxed.rs` to avoid// duplicating the lang-items when building in test cfg; but also need// to allow code to have `use boxed::Box;` declarations.wtf8//! # The Rust core allocation and collections library//! This library provides smart pointers and collections for managing//! heap-allocated values.//! This library, like core, normally doesn’t need to be used directly//! since its contents are re-exported in the [`std` crate](../std/index.html).//! Crates that use the `#![no_std]` attribute however will typically//! not depend on `std`, so they’d use this crate instead.//! ## Boxed values//! The [`Box`] type is a smart pointer type. There can only be one owner of a//! [`Box`], and the owner can decide to mutate the contents, which live on the//! heap.//! This type can be sent among threads efficiently as the size of a `Box` value//! is the same as that of a pointer. Tree-like data structures are often built//! with boxes because each node often has only one owner, the parent.//! ## Reference counted pointers//! The [`Rc`] type is a non-threadsafe reference-counted pointer type intended//! for sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and//! only allows access to `&T`, a shared reference.//! This type is useful when inherited mutability (such as using [`Box`]) is too//! constraining for an application, and is often paired with the [`Cell`] or//! [`RefCell`] types in order to allow mutation.//! ## Atomically reference counted pointers//! The [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It//! provides all the same functionality of [`Rc`], except it requires that the//! contained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself//! sendable while [`Rc<T>`][`Rc`] is not.//! This type allows for shared access to the contained data, and is often//! paired with synchronization primitives such as mutexes to allow mutation of//! shared resources.//! ## Collections//! Implementations of the most common general purpose data structures are//! defined in this library. They are re-exported through the//! [standard collections library](../std/collections/index.html).//! ## Heap interfaces//! The [`alloc`](alloc/index.html) module defines the low-level interface to the//! default global allocator. It is not compatible with the libc allocator API.//! [`Arc`]: sync//! [`Box`]: boxed//! [`Cell`]: core::cell//! [`Rc`]: rc//! [`RefCell`]: core::cell// Lints:// Library features:// tidy-alphabetical-start// tidy-alphabetical-end// Language features:// Rustdoc features:// Technically, this is a bug in rustdoc: rustdoc sees the documentation on `#[lang = slice_alloc]`// blocks is for `&[T]`, which also has documentation using this feature in `core`, and gets mad// that the feature-gate isn't enabled. Ideally, it wouldn't check for the feature gate for docs// from other crates, but since this can only appear for lang items, it doesn't seem worth fixing.// Primitive types using the heaps above"vec_macro"allow_internal_unstable/// Creates a [`Vec`] containing the arguments./// `vec!` allows `Vec`s to be defined with the same syntax as array expressions./// - Create a [`Vec`] containing a given list of elements:/// let v = vec![1, 2, 3];/// - Create a [`Vec`] from a given element and size:/// let v = vec![1; 3];/// assert_eq!(v, [1, 1, 1]);/// example, `vec![Rc::new(1); 5]` will create a vector of five references/// Also, note that `vec![expr; 0]` is allowed, and produces an empty vector./// This will still evaluate `expr`, however, and immediately drop the resulting value, so/// be mindful of side effects."format_macro"/// Creates a `String` using interpolation of runtime expressions./// The first argument `format!` receives is a format string. This must be a string/// literal. The power of the formatting string is in the `{}`s contained./// Additional parameters passed to `format!` replace the `{}`s within the/// formatting string in the order given unless named or positional parameters/// are used./// See [the formatting syntax documentation in `std::fmt`](../std/fmt/index.html)/// A common use for `format!` is concatenation and interpolation of strings./// The same convention is used with [`print!`] and [`write!`] macros,/// depending on the intended destination of the string; all these macros internally use [`format_args!`]./// To convert a single value to a string, use the [`to_string`] method. This/// will use the [`Display`] formatting trait./// To concatenate literals into a `&'static str`, use the [`concat!`] macro./// [`print!`]: ../std/macro.print.html/// [`write!`]: core::write/// [`to_string`]: crate::string::ToString/// [`Display`]: core::fmt::Display/// [`concat!`]: core::concat/// `format!` panics if a formatting trait implementation returns an error./// This indicates an incorrect implementation/// since `fmt::Write for String` never returns an error itself./// # #![allow(unused_must_use)]/// format!("test");                             // => "test"/// format!("hello {}", "world!");               // => "hello world!"/// format!("x = {}, y = {val}", 10, val = 30);  // => "x = 10, y = 30"/// let (x, y) = (1, 2);/// format!("{x} + {y} = 3");                    // => "1 + 2 = 3"// One central function responsible for reporting capacity overflows. This'll// ensure that the code generation related to these panics is minimal as there's// only one location which panics rather than a bunch throughout the module.AllocInit/// The contents of the new memory are uninitialized.Zeroed/// The new memory is guaranteed to be zeroed.niche_typesUsizeNoHighBitZERO_CAPnew_cap/// `Cap(cap)`, except if `T` is a ZST then `Cap::ZERO`./// # Safety: cap must be <= `isize::MAX`.RawVecInner/// A low-level utility for more ergonomically allocating, reallocating, and deallocating/// a buffer of memory on the heap without having to worry about all the corner cases/// involved. This type is excellent for building your own data structures like Vec and VecDeque./// In particular:/// * Produces `Unique::dangling()` on zero-sized types./// * Produces `Unique::dangling()` on zero-length allocations./// * Avoids freeing `Unique::dangling()`./// * Catches all overflows in capacity computations (promotes them to "capacity overflow" panics)./// * Guards against 32-bit systems allocating more than `isize::MAX` bytes./// * Guards against overflowing your length./// * Calls `handle_alloc_error` for fallible allocations./// * Contains a `ptr::Unique` and thus endows the user with all related benefits./// * Uses the excess returned from the allocator to use the largest available capacity./// This type does not in anyway inspect the memory that it manages. When dropped it *will*/// free its memory, but it *won't* try to drop its contents. It is up to the user of `RawVec`/// to handle the actual things *stored* inside of a `RawVec`./// Note that the excess of a zero-sized types is always infinite, so `capacity()` always returns/// `usize::MAX`. This means that you need to be careful when round-tripping this type with a/// `Box<[T]>`, since `capacity()` won't yield the length./// Never used for ZSTs; it's `capacity()`'s responsibility to return usize::MAX in that case./// `cap` must be in the `0..=isize::MAX` range./// Like a `RawVec`, but only generic over the allocator, not the type./// As such, all the methods need the layout passed-in as a parameter./// Having this separation reduces the amount of code we need to monomorphize,/// as most operations don't need the actual type, just its layout./// Creates the biggest possible `RawVec` (on the system heap)/// without allocating. If `T` has positive size, then this makes a/// `RawVec` with capacity `0`. If `T` is zero-sized, then it makes a/// `RawVec` with capacity `usize::MAX`. Useful for implementing/// delayed allocation./// Creates a `RawVec` (on the system heap) with exactly the/// capacity and alignment requirements for a `[T; capacity]`. This is/// equivalent to calling `RawVec::new` when `capacity` is `0` or `T` is/// zero-sized. Note that if `T` is zero-sized this means you will/// *not* get a `RawVec` with the requested capacity./// Non-fallible version of `try_with_capacity`/// Panics if the requested capacity exceeds `isize::MAX` bytes./// # Aborts/// Aborts on OOM.with_capacity_zeroed/// Like `with_capacity`, but guarantees the buffer is zeroed.min_non_zero_cap// Tiny Vecs are dumb. Skip to:// - 8 if the element size is 1, because any heap allocator is likely//   to round up a request of less than 8 bytes to at least 8 bytes.// - 4 if elements are moderate-sized (<= 1 KiB).// - 1 otherwise, to avoid wasting too much space for very short Vecs.MIN_NON_ZERO_CAP/// Like `new`, but parameterized over the choice of allocator for/// the returned `RawVec`./// Like `with_capacity`, but parameterized over the choice of/// allocator for the returned `RawVec`./// Like `try_with_capacity`, but parameterized over the choice ofwith_capacity_zeroed_in/// Like `with_capacity_zeroed`, but parameterized over the choice/// of allocator for the returned `RawVec`./// Converts the entire buffer into `Box<[MaybeUninit<T>]>` with the specified `len`./// Note that this will correctly reconstitute any `cap` changes/// that may have been performed. (See description of type for details.)/// * `len` must be greater than or equal to the most recently requested capacity, and/// * `len` must be less than or equal to `self.capacity()`./// Note, that the requested capacity and `self.capacity()` could differ, as/// an allocator could overallocate and return a greater memory block than requested.from_raw_parts_in/// Reconstitutes a `RawVec` from a pointer, capacity, and allocator./// The `ptr` must be allocated (via the given allocator `alloc`), and with the given/// `capacity`./// The `capacity` cannot exceed `isize::MAX` for sized types. (only a concern on 32-bit/// systems). For ZSTs capacity is ignored./// If the `ptr` and `capacity` come from a `RawVec` created via `alloc`, then this isfrom_nonnull_in/// A convenience method for hoisting the non-null precondition out of [`RawVec::from_raw_parts_in`]./// See [`RawVec::from_raw_parts_in`]./// Gets a raw pointer to the start of the allocation. Note that this is/// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must/// be careful./// Gets the capacity of the allocation./// This will always be `usize::MAX` if `T` is zero-sized./// Returns a shared reference to the allocator backing this `RawVec`./// Ensures that the buffer contains at least enough space to hold `len +/// additional` elements. If it doesn't already have enough capacity, will/// reallocate enough space plus comfortable slack space to get amortized/// *O*(1) behavior. Will limit this behavior if it would needlessly cause/// itself to panic./// If `len` exceeds `self.capacity()`, this may fail to actually allocate/// the requested space. This is not really unsafe, but the unsafe/// code *you* write that relies on the behavior of this function may break./// This is ideal for implementing a bulk-push operation like `extend`./// Panics if the new capacity exceeds `isize::MAX` _bytes_.grow_one/// A specialized version of `self.reserve(len, 1)` which requires the/// caller to ensure `len == self.capacity()`./// The same as `reserve`, but returns on errors instead of panicking or aborting./// additional` elements. If it doesn't already, will reallocate the/// minimum possible amount of memory necessary. Generally this will be/// exactly the amount of memory necessary, but in principle the allocator/// is free to give back more than we asked for./// the requested space. This is not really unsafe, but the unsafe code/// *you* write that relies on the behavior of this function may break./// The same as `reserve_exact`, but returns on errors instead of panicking or aborting./// Shrinks the buffer down to the specified capacity. If the given amount/// is 0, actually completely deallocates./// Panics if the given amount is *larger* than the current capacity./// Frees the memory owned by the `RawVec` *without* trying to drop its contents.try_allocate_incurrent_memory/// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to///   initially construct `self`/// - `elem_layout`'s size must be a multiple of its alignment/// - `cap` must be less than or equal to `self.capacity(elem_layout.size())`needs_to_growset_ptr_and_capgrow_amortized/// - The sum of `len` and `additional` must be greater than the current capacitygrow_exactfinish_grow/// - `cap` must be greater than the current capacity// not marked inline(never) since we want optimizers to be able to observe the specifics of this// function, see tests/codegen-llvm/vec-reserve-extend.rs.shrink_unchecked/// `shrink`, but without the capacity check./// This is split out so that `shrink` can inline the check, since it/// optimizes out in things like `shrink_to_fit`, without needing to/// also inline all this code, as doing that ends up failing the/// `vec-shrink-panic` codegen test when `shrink_to_fit` ends up being too/// big for LLVM to be willing to inline./// `cap <= self.capacity()`/// This function deallocates the owned allocation, but does not update `ptr` or `cap` to/// prevent double-free or use-after-free. Essentially, do not do anything with the caller/// Ideally this function would take `self` by move, but it cannot because it exists to be/// called from a `Drop` impl.// Central function for reserve error handling.allocator_paramreserve_does_not_overallocateZSTzst_sanity// A `RawVec` holding zero-sized elements should always look like this.zstzst_reserve_paniczst_reserve_exact_panicnichesCloneFromCellUseClonedalign_of_val_rawstrongRcInner// This is repr(C) to future-proof against possible field-reordering, which// would interfere with otherwise safe [into|from]_raw() of transmutable// inner types.// repr(align(2)) (forcing alignment to at least 2) is required because usize// has 1-byte alignment on AVR.rc_inner_layout_for_value_layout/// Calculate layout for `RcInner<T>` using the inner value's layout"Rc"/// A single-threaded reference-counting pointer. 'Rc' stands for 'Reference/// Counted'./// See the [module-level documentation](./index.html) for more details./// The inherent methods of `Rc` are all associated functions, which means/// that you have to call them as e.g., [`Rc::get_mut(&mut value)`][get_mut] instead of/// `value.get_mut()`. This avoids conflicts with methods of the inner type `T`./// [get_mut]: Rc::get_mut// Note that this negative impl isn't strictly necessary for correctness,// as `Rc` transitively contains a `Cell`, which is itself `!Sync`.// However, given how important `Rc`'s `!Sync`-ness is,// having an explicit negative impl is nice for documentation purposes// and results in nicer error messages.// SAFETY: `Rc::clone` doesn't access any `Cell`s which could contain the `Rc` being cloned.into_inner_with_allocatorfrom_inner_infrom_ptr_indrop_slow// Non-inlined part of `drop`./// Constructs a new `Rc<T>`./// let five = Rc::new(5);new_cyclic/// Constructs a new `Rc<T>` while giving you a `Weak<T>` to the allocation,/// to allow you to construct a `T` which holds a weak pointer to itself./// Generally, a structure circularly referencing itself, either directly or/// indirectly, should not hold a strong reference to itself to prevent a memory leak./// Using this function, you get access to the weak pointer during the/// initialization of `T`, before the `Rc<T>` is created, such that you can/// clone and store it inside the `T`./// `new_cyclic` first allocates the managed allocation for the `Rc<T>`,/// then calls your closure, giving it a `Weak<T>` to this allocation,/// and only afterwards completes the construction of the `Rc<T>` by placing/// the `T` returned from your closure into the allocation./// Since the new `Rc<T>` is not fully-constructed until `Rc<T>::new_cyclic`/// returns, calling [`upgrade`] on the weak reference inside your closure will/// fail and result in a `None` value./// If `data_fn` panics, the panic is propagated to the caller, and the/// temporary [`Weak<T>`] is dropped normally./// use std::rc::{Rc, Weak};/// struct Gadget {///     me: Weak<Gadget>,/// impl Gadget {///     /// Constructs a reference counted Gadget.///     fn new() -> Rc<Self> {///         // `me` is a `Weak<Gadget>` pointing at the new allocation of the///         // `Rc` we're constructing.///         Rc::new_cyclic(|me| {///             // Create the actual struct here.///             Gadget { me: me.clone() }///     /// Returns a reference counted pointer to Self.///     fn me(&self) -> Rc<Self> {///         self.me.upgrade().unwrap()/// [`upgrade`]: Weak::upgrade/// Constructs a new `Rc` with uninitialized contents./// let mut five = Rc::<u32>::new_uninit();/// Rc::get_mut(&mut five).unwrap().write(5);/// Constructs a new `Rc` with uninitialized contents, with the memory/// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and/// incorrect usage of this method./// let zero = Rc::<u32>::new_zeroed();/// Constructs a new `Rc<T>`, returning an error if the allocation fails/// let five = Rc::try_new(5);/// Constructs a new `Rc` with uninitialized contents, returning an error if the allocation fails/// let mut five = Rc::<u32>::try_new_uninit()?;/// being filled with `0` bytes, returning an error if the allocation fails/// let zero = Rc::<u32>::try_new_zeroed()?;/// Constructs a new `Pin<Rc<T>>`. If `T` does not implement `Unpin`, then/// `value` will be pinned in memory and unable to be moved./// Maps the value in an `Rc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `Rc`, and the result is returned, also in/// an `Rc`./// to call it as `Rc::map(r, f)` instead of `r.map(f)`. This/// let r = Rc::new(7);/// let new = Rc::map(r, |i| i + 7);/// Attempts to map the value in an `Rc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `Rc`, and if the operation succeeds, the/// result is returned, also in an `Rc`./// to call it as `Rc::try_map(r, f)` instead of `r.try_map(f)`. This/// let b = Rc::new(7);/// let new = Rc::try_map(b, |&i| u32::try_from(i)).unwrap();/// Constructs a new `Rc` in the provided allocator./// let five = Rc::new_in(5, System);/// Constructs a new `Rc` with uninitialized contents in the provided allocator./// #![feature(get_mut_unchecked)]/// let mut five = Rc::<u32, _>::new_uninit_in(System);/// let five = unsafe {///     // Deferred initialization:///     Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);///     five.assume_init()/// being filled with `0` bytes, in the provided allocator./// let zero = Rc::<u32, _>::new_zeroed_in(System);new_cyclic_in/// Constructs a new `Rc<T, A>` in the given allocator while giving you a `Weak<T, A>` to the allocation,/// initialization of `T`, before the `Rc<T, A>` is created, such that you can/// `new_cyclic_in` first allocates the managed allocation for the `Rc<T, A>`,/// then calls your closure, giving it a `Weak<T, A>` to this allocation,/// and only afterwards completes the construction of the `Rc<T, A>` by placing/// Since the new `Rc<T, A>` is not fully-constructed until `Rc<T, A>::new_cyclic_in`/// temporary [`Weak<T, A>`] is dropped normally./// See [`new_cyclic`]./// [`new_cyclic`]: Rc::new_cyclic/// Constructs a new `Rc<T>` in the provided allocator, returning an error if the allocation/// fails/// let five = Rc::try_new_in(5, System);/// Constructs a new `Rc` with uninitialized contents, in the provided allocator, returning an/// error if the allocation fails/// let mut five = Rc::<u32, _>::try_new_uninit_in(System)?;/// being filled with `0` bytes, in the provided allocator, returning an error if the allocation/// let zero = Rc::<u32, _>::try_new_zeroed_in(System)?;/// Constructs a new `Pin<Rc<T>>` in the provided allocator. If `T` does not implement `Unpin`, then/// Returns the inner value, if the `Rc` has exactly one strong reference./// Otherwise, an [`Err`] is returned with the same `Rc` that was/// passed in./// This will succeed even if there are outstanding weak references./// let x = Rc::new(3);/// assert_eq!(Rc::try_unwrap(x), Ok(3));/// let x = Rc::new(4);/// let _y = Rc::clone(&x);/// assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4);/// Otherwise, [`None`] is returned and the `Rc` is dropped./// If `Rc::into_inner` is called on every clone of this `Rc`,/// it is guaranteed that exactly one of the calls returns the inner value./// This means in particular that the inner value is not dropped./// [`Rc::try_unwrap`] is conceptually similar to `Rc::into_inner`./// And while they are meant for different use-cases, `Rc::into_inner(this)`/// is in fact equivalent to <code>[Rc::try_unwrap]\(this).[ok][Result::ok]()</code>./// (Note that the same kind of equivalence does **not** hold true for/// [`Arc`](crate::sync::Arc), due to race conditions that do not apply to `Rc`!)/// assert_eq!(Rc::into_inner(x), Some(3));/// let y = Rc::clone(&x);/// assert_eq!(Rc::into_inner(y), None);/// assert_eq!(Rc::into_inner(x), Some(4));/// Constructs a new reference-counted slice with uninitialized contents./// let mut values = Rc::<[u32]>::new_uninit_slice(3);/// let data = Rc::get_mut(&mut values).unwrap();/// data[0].write(1);/// data[1].write(2);/// data[2].write(3);/// Constructs a new reference-counted slice with uninitialized contents, with the memory being/// filled with `0` bytes./// let values = Rc::<[u32]>::new_zeroed_slice(3);/// Converts the reference-counted slice into a reference-counted array./// let mut values = Rc::<[u32], _>::new_uninit_slice_in(3, System);/// let values = unsafe {///     Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);///     Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);///     Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);///     values.assume_init()/// let values = Rc::<[u32], _>::new_zeroed_slice_in(3, System);/// Converts to `Rc<T>`./// it is up to the caller to guarantee that the inner value/// Constructs a new `Rc<T>` with a clone of `value`./// let hello: Rc<str> = Rc::clone_from_ref("hello");/// Constructs a new `Rc<T>` with a clone of `value`, returning an error if allocation fails/// let hello: Rc<str> = Rc::try_clone_from_ref("hello")?;/// Constructs a new `Rc<T>` with a clone of `value` in the provided allocator./// let hello: Rc<str, System> = Rc::clone_from_ref_in("hello", System);/// Constructs a new `Rc<T>` with a clone of `value` in the provided allocator, returning an error if allocation fails/// let hello: Rc<str, System> = Rc::try_clone_from_ref_in("hello", System)?;/// Converts to `Rc<[T]>`./// Constructs an `Rc<T>` from a raw pointer./// The raw pointer must have been previously returned by a call to/// [`Rc<U>::into_raw`][into_raw] with the following requirements:/// * If `U` is sized, it must have the same size and alignment as `T`. This///   is trivially true if `U` is `T`./// * If `U` is unsized, its data pointer must have the same size and///   alignment as `T`. This is trivially true if `Rc<U>` was constructed///   through `Rc<T>` and then converted to `Rc<U>` through an [unsized///   coercion]./// Note that if `U` or `U`'s data pointer is not `T` but has the same size/// and alignment, this is basically like transmuting references of/// different types. See [`mem::transmute`][transmute] for more information/// on what restrictions apply in this case./// The raw pointer must point to a block of memory allocated by the global allocator/// The user of `from_raw` has to make sure a specific value of `T` is only/// dropped once./// This function is unsafe because improper use may lead to memory unsafety,/// even if the returned `Rc<T>` is never accessed./// [into_raw]: Rc::into_raw/// [transmute]: core::mem::transmute/// [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions/// let x = Rc::new("hello".to_owned());/// let x_ptr = Rc::into_raw(x);///     // Convert back to an `Rc` to prevent leak.///     let x = Rc::from_raw(x_ptr);///     assert_eq!(&*x, "hello");///     // Further calls to `Rc::from_raw(x_ptr)` would be memory-unsafe./// // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!/// Convert a slice back into its original array:/// let x: Rc<[u32]> = Rc::new([1, 2, 3]);/// let x_ptr: *const [u32] = Rc::into_raw(x);///     let x: Rc<[u32; 3]> = Rc::from_raw(x_ptr.cast::<[u32; 3]>());///     assert_eq!(&*x, &[1, 2, 3]);/// Consumes the `Rc`, returning the wrapped pointer./// To avoid a memory leak the pointer must be converted back to an `Rc` using/// [`Rc::from_raw`]./// assert_eq!(unsafe { &*x_ptr }, "hello");/// # // Prevent leaks for Miri./// # drop(unsafe { Rc::from_raw(x_ptr) });increment_strong_count/// Increments the strong reference count on the `Rc<T>` associated with the/// provided pointer by one./// The pointer must have been obtained through `Rc::into_raw` and must satisfy the/// same layout requirements specified in [`Rc::from_raw_in`][from_raw_in]./// The associated `Rc` instance must be valid (i.e. the strong count must be at/// least 1) for the duration of this method, and `ptr` must point to a block of memory/// allocated by the global allocator./// [from_raw_in]: Rc::from_raw_in///     let ptr = Rc::into_raw(five);///     Rc::increment_strong_count(ptr);///     let five = Rc::from_raw(ptr);///     assert_eq!(2, Rc::strong_count(&five));/// #   // Prevent leaks for Miri./// #   Rc::decrement_strong_count(ptr);decrement_strong_count/// Decrements the strong reference count on the `Rc<T>` associated with the/// The pointer must have been obtained through `Rc::into_raw`and must satisfy the/// least 1) when invoking this method, and `ptr` must point to a block of memory/// allocated by the global allocator. This method can be used to release the final `Rc` and/// backing storage, but **should not** be called after the final `Rc` has been released.///     Rc::decrement_strong_count(ptr);///     assert_eq!(1, Rc::strong_count(&five));/// to call it as `Rc::allocator(&r)` instead of `r.allocator()`. This/// Consumes the `Rc`, returning the wrapped pointer and allocator./// [`Rc::from_raw_in`]./// let x = Rc::new_in("hello".to_owned(), System);/// let (ptr, alloc) = Rc::into_raw_with_allocator(x);/// assert_eq!(unsafe { &*ptr }, "hello");/// let x = unsafe { Rc::from_raw_in(ptr, alloc) };/// assert_eq!(&*x, "hello");/// Provides a raw pointer to the data./// The counts are not affected in any way and the `Rc` is not consumed. The pointer is valid/// for as long as there are strong counts in the `Rc`./// let x = Rc::new(0);/// let x_ptr = Rc::as_ptr(&x);/// assert_eq!(x_ptr, Rc::as_ptr(&y));/// assert_eq!(unsafe { *x_ptr }, 0);/// Constructs an `Rc<T, A>` from a raw pointer in the provided allocator./// The raw pointer must have been previously returned by a call to [`Rc<U,/// A>::into_raw`][into_raw] with the following requirements:/// The raw pointer must point to a block of memory allocated by `alloc`/// let (x_ptr, _alloc) = Rc::into_raw_with_allocator(x);///     let x = Rc::from_raw_in(x_ptr, System);/// let x: Rc<[u32], _> = Rc::new_in([1, 2, 3], System);/// let x_ptr: *const [u32] = Rc::into_raw_with_allocator(x).0;///     let x: Rc<[u32; 3], _> = Rc::from_raw_in(x_ptr.cast::<[u32; 3]>(), System);"this returns a new `Weak` pointer, \
                  without modifying the original `Rc`"/// Creates a new [`Weak`] pointer to this allocation./// let weak_five = Rc::downgrade(&five);/// Gets the number of [`Weak`] pointers to this allocation./// let _weak_five = Rc::downgrade(&five);/// assert_eq!(1, Rc::weak_count(&five));/// Gets the number of strong (`Rc`) pointers to this allocation./// let _also_five = Rc::clone(&five);/// assert_eq!(2, Rc::strong_count(&five));increment_strong_count_in/// allocated by `alloc`.///     let (ptr, _alloc) = Rc::into_raw_with_allocator(five);///     Rc::increment_strong_count_in(ptr, System);///     let five = Rc::from_raw_in(ptr, System);/// #   Rc::decrement_strong_count_in(ptr, System);decrement_strong_count_in/// allocated by `alloc`. This method can be used to release the final `Rc` and///     Rc::decrement_strong_count_in(ptr, System);/// Returns `true` if there are no other `Rc` or [`Weak`] pointers to/// this allocation./// Returns a mutable reference into the given `Rc`, if there are/// no other `Rc` or [`Weak`] pointers to the same allocation./// Returns [`None`] otherwise, because it is not safe to/// mutate a shared value./// See also [`make_mut`][make_mut], which will [`clone`][clone]/// the inner value when there are other `Rc` pointers./// [make_mut]: Rc::make_mut/// [clone]: Clone::clone/// let mut x = Rc::new(3);/// *Rc::get_mut(&mut x).unwrap() = 4;/// assert_eq!(*x, 4);/// assert!(Rc::get_mut(&mut x).is_none());/// Returns a mutable reference into the given `Rc`,/// without any check./// See also [`get_mut`], which is safe and does appropriate checks./// [`get_mut`]: Rc::get_mut/// If any other `Rc` or [`Weak`] pointers to the same allocation exist, then/// they must not be dereferenced or have active borrows for the duration/// of the returned borrow, and their inner type must be exactly the same as the/// inner type of this Rc (including lifetimes). This is trivially the case if no/// such pointers exist, for example immediately after `Rc::new`./// let mut x = Rc::new(String::new());///     Rc::get_mut_unchecked(&mut x).push_str("foo")/// assert_eq!(*x, "foo");/// Other `Rc` pointers to the same allocation must be to the same type./// let x: Rc<str> = Rc::from("Hello, world!");/// let mut y: Rc<[u8]> = x.clone().into();///     // this is Undefined Behavior, because x's inner type is str, not [u8]///     Rc::get_mut_unchecked(&mut y).fill(0xff); // 0xff is invalid in UTF-8/// println!("{}", &*x); // Invalid UTF-8 in a str/// Other `Rc` pointers to the same allocation must be to the exact same type, including lifetimes./// let x: Rc<&str> = Rc::new("Hello, world!");///     let s = String::from("Oh, no!");///     let mut y: Rc<&str> = x.clone();///         // this is Undefined Behavior, because x's inner type///         // is &'long str, not &'short str///         *Rc::get_mut_unchecked(&mut y) = &s;/// println!("{}", &*x); // Use-after-free/// Returns `true` if the two `Rc`s point to the same allocation in a vein similar to/// [`ptr::eq`]. This function ignores the metadata of  `dyn Trait` pointers./// let same_five = Rc::clone(&five);/// let other_five = Rc::new(5);/// assert!(Rc::ptr_eq(&five, &same_five));/// assert!(!Rc::ptr_eq(&five, &other_five));/// Makes a mutable reference into the given `Rc`./// If there are other `Rc` pointers to the same allocation, then `make_mut` will/// [`clone`] the inner value to a new allocation to ensure unique ownership.  This is also/// referred to as clone-on-write./// However, if there are no other `Rc` pointers to this allocation, but some [`Weak`]/// pointers, then the [`Weak`] pointers will be disassociated and the inner value will not/// be cloned./// See also [`get_mut`], which will fail rather than cloning the inner value/// or disassociating [`Weak`] pointers./// [`clone`]: Clone::clone/// let mut data = Rc::new(5);/// *Rc::make_mut(&mut data) += 1;         // Won't clone anything/// let mut other_data = Rc::clone(&data); // Won't clone inner data/// *Rc::make_mut(&mut data) += 1;         // Clones inner data/// *Rc::make_mut(&mut other_data) *= 2;   // Won't clone anything/// // Now `data` and `other_data` point to different allocations./// assert_eq!(*data, 8);/// assert_eq!(*other_data, 12);/// [`Weak`] pointers will be disassociated:/// let mut data = Rc::new(75);/// let weak = Rc::downgrade(&data);/// assert!(75 == *data);/// assert!(75 == *weak.upgrade().unwrap());/// *Rc::make_mut(&mut data) += 1;/// assert!(76 == *data);unwrap_or_clone/// If we have the only reference to `T` then unwrap it. Otherwise, clone `T` and return the/// Assuming `rc_t` is of type `Rc<T>`, this function is functionally equivalent to/// `(*rc_t).clone()`, but will avoid cloning the inner value where possible./// # use std::{ptr, rc::Rc};/// let inner = String::from("test");/// let ptr = inner.as_ptr();/// let rc = Rc::new(inner);/// let inner = Rc::unwrap_or_clone(rc);/// // The inner value was not cloned/// assert!(ptr::eq(ptr, inner.as_ptr()));/// let rc2 = rc.clone();/// // Because there were 2 references, we had to clone the inner value./// assert!(!ptr::eq(ptr, inner.as_ptr()));/// // `rc2` is the last reference, so when we unwrap it we get back/// // the original `String`./// let inner = Rc::unwrap_or_clone(rc2);/// Attempts to downcast the `Rc<dyn Any>` to a concrete type./// fn print_if_string(value: Rc<dyn Any>) {/// print_if_string(Rc::new(my_string));/// print_if_string(Rc::new(0i8));/// Downcasts the `Rc<dyn Any>` to a concrete type./// let x: Rc<dyn Any> = Rc::new(1_usize);allocate_for_layout/// Allocates an `RcInner<T>` with sufficient space for/// a possibly-unsized inner value where the value has the layout provided./// The function `mem_to_rc_inner` is called with the data pointer/// and must return back a (potentially fat)-pointer for the `RcInner<T>`.try_allocate_for_layout/// a possibly-unsized inner value where the value has the layout provided,/// returning an error if allocation fails.allocate_for_ptr_in/// Allocates an `RcInner<T>` with sufficient space for an unsized inner valuefrom_box_inallocate_for_slice/// Allocates an `RcInner<[T]>` with the given length./// Copy elements from slice into newly allocated `Rc<[T]>`/// Unsafe because the caller must either take ownership, bind `T: Copy` or/// bind `T: TrivialClone`.from_iter_exact/// Constructs an `Rc<[T]>` from an iterator known to be of a certain size./// Behavior is undefined should the size be wrong.allocate_for_slice_inRcFromSlice/// Specialization trait used for `From<&[T]>`.UniqueRc//#[unstable(feature = "unique_rc_arc", issue = "112566")]/// Drops the `Rc`./// This will decrement the strong reference count. If the strong reference/// count reaches zero then the only other references (if any) are/// [`Weak`], so we `drop` the inner value./// impl Drop for Foo {///         println!("dropped!");/// let foo  = Rc::new(Foo);/// let foo2 = Rc::clone(&foo);/// drop(foo);    // Doesn't print anything/// drop(foo2);   // Prints "dropped!"/// Makes a clone of the `Rc` pointer./// This creates another pointer to the same allocation, increasing the/// strong reference count./// let _ = Rc::clone(&five);/// Creates a new `Rc<T>`, with the `Default` value for `T`./// let x: Rc<i32> = Default::default();/// assert_eq!(*x, 0);/// Creates an empty `str` inside an `Rc`./// Creates an empty `[T]` inside an `Rc`.RcEqIdentrustc_unsafe_specialization_markerMarkerEq// Hack to allow specializing on `Eq` even though `Eq` has a method./// We're doing this specialization here, and not as a more general optimization on `&T`, because it/// would otherwise add a cost to all equality checks on refs. We assume that `Rc`s are used to/// store large values, that are slow to clone, but also heavy to check for equality, causing this/// cost to pay off more easily. It's also more likely to have two `Rc` clones, that point to/// the same value, than two `&T`s./// We can only do this when `T: Eq` as a `PartialEq` might be deliberately irreflexive./// Equality for two `Rc`s./// Two `Rc`s are equal if their inner values are equal, even if they are/// stored in different allocation./// If `T` also implements `Eq` (implying reflexivity of equality),/// two `Rc`s that point to the same allocation are/// always equal./// assert!(five == Rc::new(5));/// Inequality for two `Rc`s./// Two `Rc`s are not equal if their inner values are not equal./// assert!(five != Rc::new(6));/// Partial comparison for two `Rc`s./// The two are compared by calling `partial_cmp()` on their inner values./// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6)));/// Less-than comparison for two `Rc`s./// The two are compared by calling `<` on their inner values./// assert!(five < Rc::new(6));/// 'Less than or equal to' comparison for two `Rc`s./// The two are compared by calling `<=` on their inner values./// assert!(five <= Rc::new(5));/// Greater-than comparison for two `Rc`s./// The two are compared by calling `>` on their inner values./// assert!(five > Rc::new(4));/// 'Greater than or equal to' comparison for two `Rc`s./// The two are compared by calling `>=` on their inner values./// assert!(five >= Rc::new(5));/// Comparison for two `Rc`s./// The two are compared by calling `cmp()` on their inner values./// assert_eq!(Ordering::Less, five.cmp(&Rc::new(6)));/// Converts a generic type `T` into an `Rc<T>`/// let rc = Rc::new(5);/// assert_eq!(Rc::from(x), rc);/// Converts a [`[T; N]`](prim@array) into an `Rc<[T]>`./// The conversion moves the array into a newly allocated `Rc`./// let original: [i32; 3] = [1, 2, 3];/// let shared: Rc<[i32]> = Rc::from(original);/// assert_eq!(&[1, 2, 3], &shared[..]);/// Allocates a reference-counted slice and fills it by cloning `v`'s items./// let original: &[i32] = &[1, 2, 3];/// let mut original = [1, 2, 3];/// let original: &mut [i32] = &mut original;/// Allocates a reference-counted string slice and copies `v` into it./// let shared: Rc<str> = Rc::from("statue");/// assert_eq!("statue", &shared[..]);/// let mut original = String::from("statue");/// let shared: Rc<str> = Rc::from(original);/// let original: String = "statue".to_owned();/// Move a boxed object to a new, reference counted, allocation./// let original: Box<i32> = Box::new(1);/// let shared: Rc<i32> = Rc::from(original);/// assert_eq!(1, *shared);/// Allocates a reference-counted slice and moves `v`'s items into it./// let unique: Vec<i32> = vec![1, 2, 3];/// let shared: Rc<[i32]> = Rc::from(unique);/// Creates a reference-counted pointer from a clone-on-write pointer by/// copying its content./// let cow: Cow<'_, str> = Cow::Borrowed("eggplant");/// let shared: Rc<str> = Rc::from(cow);/// assert_eq!("eggplant", &shared[..]);/// Converts a reference-counted string slice into a byte slice./// let string: Rc<str> = Rc::from("eggplant");/// let bytes: Rc<[u8]> = Rc::from(string);/// assert_eq!("eggplant".as_bytes(), bytes.as_ref());/// Takes each element in the `Iterator` and collects it into an `Rc<[T]>`./// ## The general case/// In the general case, collecting into `Rc<[T]>` is done by first/// collecting into a `Vec<T>`. That is, when writing the following:/// let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect();/// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]);/// this behaves as if we wrote:/// let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0)///     .collect::<Vec<_>>() // The first set of allocations happens here.///     .into(); // A second allocation for `Rc<[T]>` happens here./// This will allocate as many times as needed for constructing the `Vec<T>`/// and then it will allocate once for turning the `Vec<T>` into the `Rc<[T]>`./// ## Iterators of known length/// When your `Iterator` implements `TrustedLen` and is of an exact size,/// a single allocation will be made for the `Rc<[T]>`. For example:/// let evens: Rc<[u8]> = (0..10).collect(); // Just a single allocation happens here./// # assert_eq!(&*evens, &*(0..10).collect::<Vec<_>>());to_rc_sliceToRcSlice/// Specialization trait used for collecting into `Rc<[T]>`."RcWeak"// This is a `NonNull` to allow optimizing the size of this type in enums,// but it is not necessarily a valid pointer.// `Weak::new` sets this to `usize::MAX` so that it doesn’t need// to allocate space on the heap. That's not a value a real pointer// will ever have because RcInner has alignment at least 2./// `Weak` is a version of [`Rc`] that holds a non-owning reference to the/// managed allocation./// The allocation is accessed by calling [`upgrade`] on the `Weak`/// pointer, which returns an <code>[Option]<[Rc]\<T>></code>./// Since a `Weak` reference does not count towards ownership, it will not/// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no/// guarantees about the value still being present. Thus it may return [`None`]/// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation/// itself (the backing store) from being deallocated./// A `Weak` pointer is useful for keeping a temporary reference to the allocation/// managed by [`Rc`] without preventing its inner value from being dropped. It is also used to/// prevent circular references between [`Rc`] pointers, since mutual owning references/// would never allow either [`Rc`] to be dropped. For example, a tree could/// have strong [`Rc`] pointers from parent nodes to children, and `Weak`/// pointers from children back to their parents./// The typical way to obtain a `Weak` pointer is to call [`Rc::downgrade`].// SAFETY: `Weak::clone` doesn't access any `Cell`s which could contain the `Weak` being cloned./// Constructs a new `Weak<T>`, without allocating any memory./// Calling [`upgrade`] on the return value always gives [`None`]./// use std::rc::Weak;/// let empty: Weak<i64> = Weak::new();/// assert!(empty.upgrade().is_none());/// Constructs a new `Weak<T>`, without allocating any memory, technically in the provided/// allocator.is_danglingWeakInner/// Helper type to allow accessing the reference counts without/// making any assertions about the data field./// Converts a raw pointer previously created by [`into_raw`] back into `Weak<T>`./// This can be used to safely get a strong reference (by calling [`upgrade`]/// later) or to deallocate the weak count by dropping the `Weak<T>`./// It takes ownership of one weak reference (with the exception of pointers created by [`new`],/// as these don't own anything; the method still works on them)./// The pointer must have originated from the [`into_raw`] and must still own its potential/// weak reference, and `ptr` must point to a block of memory allocated by the global allocator./// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this/// takes ownership of one weak reference currently represented as a raw pointer (the weak/// count is not modified by this operation) and therefore it must be paired with a previous/// call to [`into_raw`]./// let strong = Rc::new("hello".to_owned());/// let raw_1 = Rc::downgrade(&strong).into_raw();/// let raw_2 = Rc::downgrade(&strong).into_raw();/// assert_eq!(2, Rc::weak_count(&strong));/// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());/// assert_eq!(1, Rc::weak_count(&strong));/// drop(strong);/// // Decrement the last weak count./// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());/// [`into_raw`]: Weak::into_raw/// [`new`]: Weak::new/// Consumes the `Weak<T>` and turns it into a raw pointer./// This converts the weak pointer into a raw pointer, while still preserving the ownership of/// one weak reference (the weak count is not modified by this operation). It can be turned/// back into the `Weak<T>` with [`from_raw`]./// The same restrictions of accessing the target of the pointer as with/// [`as_ptr`] apply./// let weak = Rc::downgrade(&strong);/// let raw = weak.into_raw();/// assert_eq!("hello", unsafe { &*raw });/// drop(unsafe { Weak::from_raw(raw) });/// assert_eq!(0, Rc::weak_count(&strong));/// [`from_raw`]: Weak::from_raw/// [`as_ptr`]: Weak::as_ptr/// Returns a raw pointer to the object `T` pointed to by this `Weak<T>`./// The pointer is valid only if there are some strong references. The pointer may be dangling,/// unaligned or even [`null`] otherwise./// // Both point to the same object/// assert!(ptr::eq(&*strong, weak.as_ptr()));/// assert_eq!("hello", unsafe { &*weak.as_ptr() });/// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to/// // undefined behavior./// // assert_eq!("hello", unsafe { &*weak.as_ptr() });/// [`null`]: ptr::null/// Consumes the `Weak<T>`, returning the wrapped pointer and allocator./// back into the `Weak<T>` with [`from_raw_in`]./// let strong = Rc::new_in("hello".to_owned(), System);/// let (raw, alloc) = weak.into_raw_with_allocator();/// drop(unsafe { Weak::from_raw_in(raw, alloc) });/// [`from_raw_in`]: Weak::from_raw_in/// weak reference, and `ptr` must point to a block of memory allocated by `alloc`."this returns a new `Rc`, \
                  without modifying the original weak pointer"/// Attempts to upgrade the `Weak` pointer to an [`Rc`], delaying/// dropping of the inner value if successful./// Returns [`None`] if the inner value has since been dropped./// let strong_five: Option<Rc<_>> = weak_five.upgrade();/// assert!(strong_five.is_some());/// // Destroy all strong pointers./// drop(strong_five);/// drop(five);/// assert!(weak_five.upgrade().is_none());/// Gets the number of strong (`Rc`) pointers pointing to this allocation./// If `self` was created using [`Weak::new`], this will return 0./// Gets the number of `Weak` pointers pointing to this allocation./// If no strong pointers remain, this will return zero./// Returns `None` when the pointer is dangling and there is no allocated `RcInner`,/// (i.e., when this `Weak` was created by `Weak::new`)./// Returns `true` if the two `Weak`s point to the same allocation similar to [`ptr::eq`], or if/// both don't point to any allocation (because they were created with `Weak::new()`). However,/// this function ignores the metadata of  `dyn Trait` pointers./// Since this compares pointers it means that `Weak::new()` will equal each/// other, even though they don't point to any allocation./// let first_rc = Rc::new(5);/// let first = Rc::downgrade(&first_rc);/// let second = Rc::downgrade(&first_rc);/// assert!(first.ptr_eq(&second));/// let third_rc = Rc::new(5);/// let third = Rc::downgrade(&third_rc);/// assert!(!first.ptr_eq(&third));/// Comparing `Weak::new`./// let first = Weak::new();/// let second = Weak::new();/// let third_rc = Rc::new(());/// Drops the `Weak` pointer./// let foo = Rc::new(Foo);/// let weak_foo = Rc::downgrade(&foo);/// let other_weak_foo = Weak::clone(&weak_foo);/// drop(weak_foo);   // Doesn't print anything/// drop(foo);        // Prints "dropped!"/// assert!(other_weak_foo.upgrade().is_none());/// Makes a clone of the `Weak` pointer that points to the same allocation./// let weak_five = Rc::downgrade(&Rc::new(5));/// let _ = Weak::clone(&weak_five);/// let empty: Weak<i64> = Default::default();strong_refinc_strongdec_stronginc_weakdec_weakRcInnerPtr/// Gets the offset within an `RcInner` for the payload behind a pointer./// The pointer must point to (and have valid metadata for) a previously/// valid instance of T, but the T is allowed to be dropped.data_offset_align// Define the ownership of `RcInner<T>` for drop-check_marker2// Invariance is necessary for soundness: once other `Weak`// references exist, we already have a form of shared mutability!/// A uniquely owned [`Rc`]./// This represents an `Rc` that is known to be uniquely owned -- that is, have exactly one strong/// reference. Multiple weak pointers can be created, but attempts to upgrade those to strong/// references will fail unless the `UniqueRc` they point to has been converted into a regular `Rc`./// Because they are uniquely owned, the contents of a `UniqueRc` can be freely mutated. A common/// use case is to have an object be mutable during its initialization phase but then have it become/// immutable and converted to a normal `Rc`./// This can be used as a flexible way to create cyclic data structures, as in the example below./// #![feature(unique_rc_arc)]/// use std::rc::{Rc, Weak, UniqueRc};///     #[allow(dead_code)]/// fn create_gadget() -> Option<Rc<Gadget>> {///     let mut rc = UniqueRc::new(Gadget {///         me: Weak::new(),///     rc.me = UniqueRc::downgrade(&rc);///     Some(UniqueRc::into_rc(rc))/// create_gadget().unwrap();/// An advantage of using `UniqueRc` over [`Rc::new_cyclic`] to build cyclic data structures is that/// [`Rc::new_cyclic`]'s `data_fn` parameter cannot be async or return a [`Result`]. As shown in the/// previous example, `UniqueRc` allows for more flexibility in the construction of cyclic data,/// including fallible or async constructors.// Not necessary for correctness since `UniqueRc` contains `NonNull`,// but having an explicit negative impl is nice for documentation purposes/// Equality for two `UniqueRc`s./// Two `UniqueRc`s are equal if their inner values are equal./// use std::rc::UniqueRc;/// let five = UniqueRc::new(5);/// assert!(five == UniqueRc::new(5));/// Inequality for two `UniqueRc`s./// Two `UniqueRc`s are not equal if their inner values are not equal./// assert!(five != UniqueRc::new(6));/// Partial comparison for two `UniqueRc`s./// assert_eq!(Some(Ordering::Less), five.partial_cmp(&UniqueRc::new(6)));/// Less-than comparison for two `UniqueRc`s./// assert!(five < UniqueRc::new(6));/// 'Less than or equal to' comparison for two `UniqueRc`s./// assert!(five <= UniqueRc::new(5));/// Greater-than comparison for two `UniqueRc`s./// assert!(five > UniqueRc::new(4));/// 'Greater than or equal to' comparison for two `UniqueRc`s./// assert!(five >= UniqueRc::new(5));/// Comparison for two `UniqueRc`s./// assert_eq!(Ordering::Less, five.cmp(&UniqueRc::new(6)));/// Creates a new `UniqueRc`./// Weak references to this `UniqueRc` can be created with [`UniqueRc::downgrade`]. Upgrading/// these weak references will fail before the `UniqueRc` has been converted into an [`Rc`]./// After converting the `UniqueRc` into an [`Rc`], any weak references created beforehand will/// point to the new [`Rc`]./// Maps the value in a `UniqueRc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `UniqueRc`, and the result is returned,/// also in a `UniqueRc`./// to call it as `UniqueRc::map(u, f)` instead of `u.map(f)`. This/// let r = UniqueRc::new(7);/// let new = UniqueRc::map(r, |i| i + 7);/// Attempts to map the value in a `UniqueRc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `UniqueRc`, and if the operation succeeds,/// the result is returned, also in a `UniqueRc`./// to call it as `UniqueRc::try_map(u, f)` instead of `u.try_map(f)`. This/// let b = UniqueRc::new(7);/// let new = UniqueRc::try_map(b, u32::try_from).unwrap();// Depends on A = Global/// Creates a new `UniqueRc` in the provided allocator.into_rc/// Converts the `UniqueRc` into a regular [`Rc`]./// This consumes the `UniqueRc` and returns a regular [`Rc`] that contains the `value` that/// is passed to `into_rc`./// Any weak references created before this method is called can now be upgraded to strong/// Creates a new weak reference to the `UniqueRc`./// Attempting to upgrade this weak reference will fail before the `UniqueRc` has been converted/// to a [`Rc`] using [`UniqueRc::into_rc`].layout_for_valueUniqueRcUninit/// A unique owning pointer to a [`RcInner`] **that does not imply the contents are initialized,**/// but will deallocate it (without dropping the value) when dropped./// This is a helper for [`Rc::make_mut()`] to ensure correct cleanup on panic./// It is nearly a duplicate of `UniqueRc<MaybeUninit<T>, A>` except that it allows `T: !Sized`,/// which `MaybeUninit` does not./// Allocates a RcInner with layout suitable to contain `for_value` or a clone of it./// Allocates a RcInner with layout suitable to contain `for_value` or a clone of it,/// Returns the pointer to be written into to initialize the [`Rc`]./// Upgrade this into a normal [`Rc`]./// The data must have been initialized (by writing to [`Self::data_ptr()`]).//! Single-threaded reference-counting pointers. 'Rc' stands for 'Reference//! Counted'.//! The type [`Rc<T>`][`Rc`] provides shared ownership of a value of type `T`,//! allocated in the heap. Invoking [`clone`][clone] on [`Rc`] produces a new//! pointer to the same allocation in the heap. When the last [`Rc`] pointer to a//! given allocation is destroyed, the value stored in that allocation (often//! referred to as "inner value") is also dropped.//! Shared references in Rust disallow mutation by default, and [`Rc`]//! is no exception: you cannot generally obtain a mutable reference to//! something inside an [`Rc`]. If you need mutability, put a [`Cell`]//! or [`RefCell`] inside the [`Rc`]; see [an example of mutability//! inside an `Rc`][mutability].//! [`Rc`] uses non-atomic reference counting. This means that overhead is very//! low, but an [`Rc`] cannot be sent between threads, and consequently [`Rc`]//! does not implement [`Send`]. As a result, the Rust compiler//! will check *at compile time* that you are not sending [`Rc`]s between//! threads. If you need multi-threaded, atomic reference counting, use//! [`sync::Arc`][arc].//! The [`downgrade`][downgrade] method can be used to create a non-owning//! [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d//! to an [`Rc`], but this will return [`None`] if the value stored in the allocation has//! already been dropped. In other words, `Weak` pointers do not keep the value//! inside the allocation alive; however, they *do* keep the allocation//! (the backing store for the inner value) alive.//! A cycle between [`Rc`] pointers will never be deallocated. For this reason,//! [`Weak`] is used to break cycles. For example, a tree could have strong//! [`Rc`] pointers from parent nodes to children, and [`Weak`] pointers from//! children back to their parents.//! `Rc<T>` automatically dereferences to `T` (via the [`Deref`] trait),//! so you can call `T`'s methods on a value of type [`Rc<T>`][`Rc`]. To avoid name//! clashes with `T`'s methods, the methods of [`Rc<T>`][`Rc`] itself are associated//! functions, called using [fully qualified syntax]://! let my_rc = Rc::new(());//! let my_weak = Rc::downgrade(&my_rc);//! `Rc<T>`'s implementations of traits like `Clone` may also be called using//! fully qualified syntax. Some people prefer to use fully qualified syntax,//! while others prefer using method-call syntax.//! let rc = Rc::new(());//! // Method-call syntax//! let rc2 = rc.clone();//! // Fully qualified syntax//! let rc3 = Rc::clone(&rc);//! [`Weak<T>`][`Weak`] does not auto-dereference to `T`, because the inner value may have//! already been dropped.//! # Cloning references//! Creating a new reference to the same allocation as an existing reference counted pointer//! is done using the `Clone` trait implemented for [`Rc<T>`][`Rc`] and [`Weak<T>`][`Weak`].//! let foo = Rc::new(vec![1.0, 2.0, 3.0]);//! // The two syntaxes below are equivalent.//! let a = foo.clone();//! let b = Rc::clone(&foo);//! // a and b both point to the same memory location as foo.//! The `Rc::clone(&from)` syntax is the most idiomatic because it conveys more explicitly//! the meaning of the code. In the example above, this syntax makes it easier to see that//! this code is creating a new reference rather than copying the whole content of foo.//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`.//! We want to have our `Gadget`s point to their `Owner`. We can't do this with//! unique ownership, because more than one gadget may belong to the same//! `Owner`. [`Rc`] allows us to share an `Owner` between multiple `Gadget`s,//! and have the `Owner` remain allocated as long as any `Gadget` points at it.//! struct Owner {//!     // ...other fields//! struct Gadget {//!     id: i32,//!     owner: Rc<Owner>,//!     // Create a reference-counted `Owner`.//!     let gadget_owner: Rc<Owner> = Rc::new(//!         Owner {//!             name: "Gadget Man".to_string(),//!     // Create `Gadget`s belonging to `gadget_owner`. Cloning the `Rc<Owner>`//!     // gives us a new pointer to the same `Owner` allocation, incrementing//!     // the reference count in the process.//!     let gadget1 = Gadget {//!         id: 1,//!         owner: Rc::clone(&gadget_owner),//!     let gadget2 = Gadget {//!         id: 2,//!     // Dispose of our local variable `gadget_owner`.//!     drop(gadget_owner);//!     // Despite dropping `gadget_owner`, we're still able to print out the name//!     // of the `Owner` of the `Gadget`s. This is because we've only dropped a//!     // single `Rc<Owner>`, not the `Owner` it points to. As long as there are//!     // other `Rc<Owner>` pointing at the same `Owner` allocation, it will remain//!     // live. The field projection `gadget1.owner.name` works because//!     // `Rc<Owner>` automatically dereferences to `Owner`.//!     println!("Gadget {} owned by {}", gadget1.id, gadget1.owner.name);//!     println!("Gadget {} owned by {}", gadget2.id, gadget2.owner.name);//!     // At the end of the function, `gadget1` and `gadget2` are destroyed, and//!     // with them the last counted references to our `Owner`. Gadget Man now//!     // gets destroyed as well.//! If our requirements change, and we also need to be able to traverse from//! `Owner` to `Gadget`, we will run into problems. An [`Rc`] pointer from `Owner`//! to `Gadget` introduces a cycle. This means that their//! reference counts can never reach 0, and the allocation will never be destroyed://! a memory leak. In order to get around this, we can use [`Weak`]//! pointers.//! Rust actually makes it somewhat difficult to produce this loop in the first//! place. In order to end up with two values that point at each other, one of//! them needs to be mutable. This is difficult because [`Rc`] enforces//! memory safety by only giving out shared references to the value it wraps,//! and these don't allow direct mutation. We need to wrap the part of the//! value we wish to mutate in a [`RefCell`], which provides *interior//! mutability*: a method to achieve mutability through a shared reference.//! [`RefCell`] enforces Rust's borrowing rules at runtime.//! use std::rc::Weak;//!     gadgets: RefCell<Vec<Weak<Gadget>>>,//!     // Create a reference-counted `Owner`. Note that we've put the `Owner`'s//!     // vector of `Gadget`s inside a `RefCell` so that we can mutate it through//!     // a shared reference.//!             gadgets: RefCell::new(vec![]),//!     // Create `Gadget`s belonging to `gadget_owner`, as before.//!     let gadget1 = Rc::new(//!         Gadget {//!             id: 1,//!             owner: Rc::clone(&gadget_owner),//!     let gadget2 = Rc::new(//!             id: 2,//!     // Add the `Gadget`s to their `Owner`.//!         let mut gadgets = gadget_owner.gadgets.borrow_mut();//!         gadgets.push(Rc::downgrade(&gadget1));//!         gadgets.push(Rc::downgrade(&gadget2));//!         // `RefCell` dynamic borrow ends here.//!     // Iterate over our `Gadget`s, printing their details out.//!     for gadget_weak in gadget_owner.gadgets.borrow().iter() {//!         // `gadget_weak` is a `Weak<Gadget>`. Since `Weak` pointers can't//!         // guarantee the allocation still exists, we need to call//!         // `upgrade`, which returns an `Option<Rc<Gadget>>`.//!         // In this case we know the allocation still exists, so we simply//!         // `unwrap` the `Option`. In a more complicated program, you might//!         // need graceful error handling for a `None` result.//!         let gadget = gadget_weak.upgrade().unwrap();//!         println!("Gadget {} owned by {}", gadget.id, gadget.owner.name);//!     // At the end of the function, `gadget_owner`, `gadget1`, and `gadget2`//!     // are destroyed. There are now no strong (`Rc`) pointers to the//!     // gadgets, so they are destroyed. This zeroes the reference count on//!     // Gadget Man, so he gets destroyed as well.//! [clone]: Clone::clone//! [`Cell`]: core::cell::Cell//! [`RefCell`]: core::cell::RefCell//! [arc]: crate::sync::Arc//! [`Deref`]: core::ops::Deref//! [downgrade]: Rc::downgrade//! [upgrade]: Weak::upgrade//! [mutability]: core::cell#introducing-mutability-inside-of-something-immutable//! [fully qualified syntax]: https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name// NOTE: If you mem::forget Rcs (or Weaks), drop is skipped and the ref-count// is not decremented, meaning the ref-count can overflow, and then you can// free the allocation while outstanding Rcs (or Weaks) exist, which would be// unsound. We abort because this is such a degenerate scenario that we don't// care about what happens -- no real program should ever experience this.// This should have negligible overhead since you don't actually need to// clone these much in Rust thanks to ownership and move-semantics.ArrayWindowsEscapeAsciiGetDisjointMutErrorfrom_mut_ptr_rangefrom_ptr_rangetry_range// Basic slice extension methods/// Sorts the slice in ascending order, preserving initial order of equal elements./// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*))/// worst-case./// If the implementation of [`Ord`] for `T` does not implement a [total order], the function/// may panic; even if the function exits normally, the resulting order of elements in the slice/// is unspecified. See also the note on panicking below./// sorting and it doesn't allocate auxiliary memory. See/// [`sort_unstable`](slice::sort_unstable). The exception are partially sorted slices, which/// may be better served with `slice::sort`./// Sorting types that only implement [`PartialOrd`] such as [`f32`] and [`f64`] require/// additional precautions. For example, `f32::NAN != f32::NAN`, which doesn't fulfill the/// reflexivity requirement of [`Ord`]. By using an alternative comparison function with/// `slice::sort_by` such as [`f32::total_cmp`] or [`f64::total_cmp`] that defines a [total/// order] users can sort slices containing floating-point values. Alternatively, if all values/// in the slice are guaranteed to be in a subset for which [`PartialOrd::partial_cmp`] forms a/// [total order], it's possible to sort the slice with `sort_by(|a, b|/// a.partial_cmp(b).unwrap())`./// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which/// combines the fast average case of quicksort with the fast worst case and partial run/// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs/// with k distinct elements, the expected time to sort the data is *O*(*n* \* log(*k*))./// The auxiliary memory allocation behavior depends on the input length. Short slices are/// handled without allocation, medium sized slices allocate `self.len()` and beyond that it/// clamps at `self.len() / 2`./// May panic if the implementation of [`Ord`] for `T` does not implement a [total order], or if/// the [`Ord`] implementation itself panics./// All safe functions on slices preserve the invariant that even if the function panics, all/// original elements will remain in the slice and any possible modifications via interior/// mutability are observed in the input. This ensures that recovery code (for instance inside/// of a `Drop` or following a `catch_unwind`) will still have access to all the original/// elements. For instance, if the slice belongs to a `Vec`, the `Vec::drop` method will be able/// to dispose of all contained elements./// let mut v = [4, -5, 1, -3, 2];/// v.sort();/// [driftsort]: https://github.com/Voultapher/driftsort/// Sorts the slice in ascending order with a comparison function, preserving initial order of/// If the comparison function `compare` does not implement a [total order], the function may/// panic; even if the function exits normally, the resulting order of elements in the slice is/// unspecified. See also the note on panicking below./// For example `|a, b| (a - b).cmp(a)` is a comparison function that is neither transitive nor/// reflexive nor total, `a < b < c < a` with `a = 1, b = 2, c = 3`. For more information and/// examples see the [`Ord`] documentation./// May panic if `compare` does not implement a [total order], or if `compare` itself panics./// v.sort_by(|a, b| a.cmp(b));/// v.sort_by(|a, b| b.cmp(a));/// assert_eq!(v, [4, 2, 1, -3, -5]);/// Sorts the slice in ascending order with a key extraction function, preserving initial order/// If the implementation of [`Ord`] for `K` does not implement a [total order], the function/// May panic if the implementation of [`Ord`] for `K` does not implement a [total order], or if/// the [`Ord`] implementation or the key-function `f` panics./// let mut v = [4i32, -5, 1, -3, 2];/// v.sort_by_key(|k| k.abs());/// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* + *n* \*/// log(*n*)) worst-case, where the key function is *O*(*m*)./// During sorting, the key function is called at most once per element, by using temporary/// storage to remember the results of key evaluation. The order of calls to the key function is/// unspecified and may change in future versions of the standard library./// For simple key functions (e.g., functions that are property accesses or basic operations),/// [`sort_by_key`](slice::sort_by_key) is likely to be faster./// The current implementation is based on [instruction-parallel-network sort][ipnsort] by Lukas/// Bergdoll, which combines the fast average case of randomized quicksort with the fast worst/// case of heapsort, while achieving linear time on fully sorted and reversed inputs. And/// *O*(*k* \* log(*n*)) where *k* is the number of distinct elements in the input. It leverages/// superscalar out-of-order execution capabilities commonly found in CPUs, to efficiently/// perform the operation./// the [`Ord`] implementation panics./// let mut v = [4i32, -5, 1, -3, 2, 10];/// // Strings are sorted by lexicographical order./// v.sort_by_cached_key(|k| k.to_string());/// assert_eq!(v, [-3, -5, 1, 10, 2, 4]);/// [ipnsort]: https://github.com/Voultapher/sort-research-rs/tree/main/ipnsortrustc_conversion_suggestion/// Copies `self` into a new `Vec`./// let s = [10, 40, 30];/// let x = s.to_vec();/// // Here, `s` and `x` can be modified independently.to_vec_in/// Copies `self` into a new `Vec` with an allocator./// let x = s.to_vec_in(System);"slice_into_vec"/// The resulting vector can be converted back into a box via/// `Vec<T>`'s `into_boxed_slice` method./// let s: Box<[i32]> = Box::new([10, 40, 30]);/// let x = s.into_vec();/// // `s` cannot be used anymore because it has been converted into `x`./// assert_eq!(x, vec![10, 40, 30]);/// Creates a vector by copying a slice `n` times./// This function will panic if the capacity would overflow./// assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);/// A panic upon overflow:/// // this will panic at runtime/// b"0123456789abcdef".repeat(usize::MAX);/// Flattens a slice of `T` into a single value `Self::Output`./// assert_eq!(["hello", "world"].concat(), "helloworld");/// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);/// Flattens a slice of `T` into a single value `Self::Output`, placing a/// given separator between each./// assert_eq!(["hello", "world"].join(" "), "hello world");/// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);/// assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);/// assert_eq!(["hello", "world"].connect(" "), "hello world");/// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);"this returns the uppercase bytes as a new Vec, \
                  without modifying the original"to_ascii_uppercase/// Returns a vector containing a copy of this slice where each byte/// is mapped to its ASCII upper case equivalent./// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',/// but non-ASCII letters are unchanged./// To uppercase the value in-place, use [`make_ascii_uppercase`]./// [`make_ascii_uppercase`]: slice::make_ascii_uppercase"this returns the lowercase bytes as a new Vec, \
                  without modifying the original"/// is mapped to its ASCII lower case equivalent./// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',/// To lowercase the value in-place, use [`make_ascii_lowercase`]./// [`make_ascii_lowercase`]: slice::make_ascii_lowercase/// The resulting type after concatenation/// Implementation of [`[T]::concat`](slice::concat)/// Helper trait for [`[T]::concat`](slice::concat)./// Note: the `Item` type parameter is not used in this trait,/// but it allows impls to be more generic./// Without it, we get this error:/// ```error/// error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predica///    --> library/alloc/src/slice.rs:608:6///     |/// 608 | impl<T: Clone, V: Borrow<[T]>> Concat for [V] {///     |      ^ unconstrained type parameter/// This is because there could exist `V` types with multiple `Borrow<[_]>` impls,/// such that multiple `T` types would apply:/// pub struct Foo(Vec<u32>, Vec<String>);/// impl std::borrow::Borrow<[u32]> for Foo {///     fn borrow(&self) -> &[u32] { &self.0 }/// impl std::borrow::Borrow<[String]> for Foo {///     fn borrow(&self) -> &[String] { &self.1 }/// Implementation of [`[T]::join`](slice::join)/// Helper trait for [`[T]::join`](slice::join)SpecCloneIntoVec// Specializable trait for implementing ToOwned::clone_into. This is// public in the crate and has the Allocator parameter so that// vec::clone_from use it too.stable_sortBufGuard//! Utilities for the slice primitive type.//! *[See also the slice primitive type](slice).*//! Most of the structs in this module are iterator types which can only be created//! using a certain function. For example, `slice.iter()` yields an [`Iter`].//! A few functions are provided to create a slice from a value reference//! or from a raw pointer.// Extension traits for slices over specific kinds of data// Standard trait implementations for slices// SortingDoubleEndedSearcherReverseSearcherfrom_utf8_mutLinesAnyRMatchIndicesRMatchesfrom_utf8_unchecked_mutRSplitTerminatorUtf8ChunkUtf8Chunks/// Note: `str` in `Concat<str>` is not meaningful here./// This type parameter of the trait only exists to enable another impl.specialize_for_lengthscopy_slice_and_advancejoin_generic_copy// Optimized join implementation that works for both Vec<T> (T: Copy) and String's inner vec// Currently (2018-05-13) there is a bug with type inference and specialization (see issue #36262)// For this reason SliceConcat<T> is not specialized for T: Copy and SliceConcat<str> is the// only user of this function. It is left in place for the time when that is fixed.// the bounds for String-join are S: Borrow<str> and for Vec-join Borrow<[T]>// [T] and str both impl AsRef<[T]> for some T// => s.borrow().as_ref() and we always have slicesinto_boxed_bytes/// Converts a `Box<str>` into a `Box<[u8]>` without copying or allocating./// let s = "this is a string";/// let boxed_str = s.to_owned().into_boxed_str();/// let boxed_bytes = boxed_str.into_boxed_bytes();/// assert_eq!(*boxed_bytes, *s.as_bytes());"this returns the replaced string as a new allocation, \
                  without modifying the original"/// Replaces all matches of a pattern with another string./// `replace` creates a new [`String`], and copies the data from this string slice into it./// While doing so, it attempts to find matches of a pattern. If it finds any, it/// replaces them with the replacement string slice./// let s = "this is old";/// assert_eq!("this is new", s.replace("old", "new"));/// assert_eq!("than an old", s.replace("is", "an"));/// When the pattern doesn't match, it returns this string slice as [`String`]:/// assert_eq!(s, s.replace("cookie monster", "little lamb"));/// Replaces first N matches of a pattern with another string./// `replacen` creates a new [`String`], and copies the data from this string slice into it./// replaces them with the replacement string slice at most `count` times./// let s = "foo foo 123 foo";/// assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));/// assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));/// assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));/// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));"this returns the lowercase string as a new String, \
                  without modifying the original"/// Returns the lowercase equivalent of this string slice, as a new [`String`]./// Since some characters can expand into multiple characters when changing/// the case, this function returns a [`String`] instead of modifying the/// parameter in-place./// let s = "HELLO";/// assert_eq!("hello", s.to_lowercase());/// A tricky example, with sigma:/// let sigma = "Σ";/// assert_eq!("σ", sigma.to_lowercase());/// // but at the end of a word, it's ς, not σ:/// let odysseus = "ὈΔΥΣΣΕΎΣ";/// assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());/// Languages without case are not changed:/// let new_year = "农历新年";/// assert_eq!(new_year, new_year.to_lowercase());"this returns the uppercase string as a new String, \
                  without modifying the original"/// Returns the uppercase equivalent of this string slice, as a new [`String`]./// let s = "hello";/// assert_eq!("HELLO", s.to_uppercase());/// Scripts without case are not changed:/// assert_eq!(new_year, new_year.to_uppercase());/// One character can become multiple:/// let s = "tschüß";/// assert_eq!("TSCHÜSS", s.to_uppercase());/// Converts a [`Box<str>`] into a [`String`] without copying or allocating./// let string = String::from("birthday gift");/// let boxed_str = string.clone().into_boxed_str();/// assert_eq!(boxed_str.into_string(), string);/// Creates a new [`String`] by repeating a string `n` times./// assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));/// let huge = "0123456789abcdef".repeat(usize::MAX);"to uppercase the value in-place, use `make_ascii_uppercase()`"/// ASCII upper case equivalent./// To uppercase ASCII characters in addition to non-ASCII characters, use/// [`to_uppercase`]./// let s = "Grüße, Jürgen ❤";/// assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());/// [`make_ascii_uppercase`]: str::make_ascii_uppercase/// [`to_uppercase`]: #method.to_uppercase"to lowercase the value in-place, use `make_ascii_lowercase()`"/// ASCII lower case equivalent./// To lowercase ASCII characters in addition to non-ASCII characters, use/// [`to_lowercase`]./// assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());/// [`make_ascii_lowercase`]: str::make_ascii_lowercase/// [`to_lowercase`]: #method.to_lowercase/// Methods for string slices./// Converts a boxed slice of bytes to a boxed string slice without checking/// that the string contains valid UTF-8./// * The provided bytes must contain a valid UTF-8 sequence./// let smile_utf8 = Box::new([226, 152, 186]);/// let smile = unsafe { std::str::from_boxed_utf8_unchecked(smile_utf8) };/// assert_eq!("☺", &*smile);convert_while_ascii/// Converts leading ascii bytes in `s` by calling the `convert` function./// For better average performance, this happens in chunks of `2*size_of::<usize>()`./// Returns a tuple of the converted prefix and the remainder starting from/// the first non-ascii character./// This function is only public so that it can be verified in a codegen test,/// see `issue-123712-str-to-lower-autovectorization.rs`.replace_ascii/// Faster implementation of string replacement for ASCII to ASCII cases./// Should produce fast vectorized code.//! Utilities for the `str` primitive type.//! *[See also the `str` primitive type](str).*// Many of the usings in this module are only used in the test configuration.// It's cleaner to just turn off the unused_imports warning than to fix them."String"/// A UTF-8–encoded, growable string./// `String` is the most common string type. It has ownership over the contents/// of the string, stored in a heap-allocated buffer (see [Representation](#representation))./// It is closely related to its borrowed counterpart, the primitive [`str`]./// You can create a `String` from [a literal string][`&str`] with [`String::from`]:/// [`String::from`]: From::from/// let hello = String::from("Hello, world!");/// You can append a [`char`] to a `String` with the [`push`] method, and/// append a [`&str`] with the [`push_str`] method:/// let mut hello = String::from("Hello, ");/// hello.push('w');/// hello.push_str("orld!");/// [`push`]: String::push/// [`push_str`]: String::push_str/// If you have a vector of UTF-8 bytes, you can create a `String` from it with/// the [`from_utf8`] method:/// // some bytes, in a vector/// let sparkle_heart = vec![240, 159, 146, 150];/// // We know these bytes are valid, so we'll use `unwrap()`./// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();/// [`from_utf8`]: String::from_utf8/// `String`s are always valid UTF-8. If you need a non-UTF-8 string, consider/// [`OsString`]. It is similar, but without the UTF-8 constraint. Because UTF-8/// is a variable width encoding, `String`s are typically smaller than an array of/// the same `char`s:/// // `s` is ASCII which represents each `char` as one byte/// assert_eq!(s.len(), 5);/// // A `char` array with the same contents would be longer because/// // every `char` is four bytes/// let s = ['h', 'e', 'l', 'l', 'o'];/// let size: usize = s.into_iter().map(|c| size_of_val(&c)).sum();/// assert_eq!(size, 20);/// // However, for non-ASCII strings, the difference will be smaller/// // and sometimes they are the same/// let s = "💖💖💖💖💖";/// assert_eq!(s.len(), 20);/// let s = ['💖', '💖', '💖', '💖', '💖'];/// This raises interesting questions as to how `s[i]` should work./// What should `i` be here? Several options include byte indices and/// `char` indices but, because of UTF-8 encoding, only byte indices/// would provide constant time indexing. Getting the `i`th `char`, for/// example, is available using [`chars`]:/// let third_character = s.chars().nth(2);/// assert_eq!(third_character, Some('l'));/// assert_eq!(third_character, Some('💖'));/// Next, what should `s[i]` return? Because indexing returns a reference/// to underlying data it could be `&u8`, `&[u8]`, or something similar./// Since we're only providing one index, `&u8` makes the most sense but that/// might not be what the user expects and can be explicitly achieved with/// [`as_bytes()`]:/// // The first byte is 104 - the byte value of `'h'`/// assert_eq!(s.as_bytes()[0], 104);/// assert_eq!(s.as_bytes()[0], b'h');/// // The first byte is 240 which isn't obviously useful/// assert_eq!(s.as_bytes()[0], 240);/// Due to these ambiguities/restrictions, indexing with a `usize` is simply/// forbidden:/// ```compile_fail,E0277/// // The following will not compile!/// println!("The first letter of s is {}", s[0]);/// It is more clear, however, how `&s[i..j]` should work (that is,/// indexing with a range). It should accept byte indices (to be constant-time)/// and return a `&str` which is UTF-8 encoded. This is also called "string slicing"./// Note this will panic if the byte indices provided are not character/// boundaries - see [`is_char_boundary`] for more details. See the implementations/// for [`SliceIndex<str>`] for more details on string slicing. For a non-panicking/// version of string slicing, see [`get`]./// [`OsString`]: ../../std/ffi/struct.OsString.html "ffi::OsString"/// [`SliceIndex<str>`]: core::slice::SliceIndex/// [`as_bytes()`]: str::as_bytes/// [`get`]: str::get/// [`is_char_boundary`]: str::is_char_boundary/// The [`bytes`] and [`chars`] methods return iterators over the bytes and/// codepoints of the string, respectively. To iterate over codepoints along/// with byte indices, use [`char_indices`]./// [`bytes`]: str::bytes/// [`chars`]: str::chars/// [`char_indices`]: str::char_indices/// # Deref/// `String` implements <code>[Deref]<Target = [str]></code>, and so inherits all of [`str`]'s/// methods. In addition, this means that you can pass a `String` to a/// function which takes a [`&str`] by using an ampersand (`&`):/// fn takes_str(s: &str) { }/// let s = String::from("Hello");/// takes_str(&s);/// This will create a [`&str`] from the `String` and pass it in. This/// conversion is very inexpensive, and so generally, functions will accept/// [`&str`]s as arguments unless they need a `String` for some specific/// In certain cases Rust doesn't have enough information to make this/// conversion, known as [`Deref`] coercion. In the following example a string/// slice [`&'a str`][`&str`] implements the trait `TraitExample`, and the function/// `example_func` takes anything that implements the trait. In this case Rust/// would need to make two implicit conversions, which Rust doesn't have the/// means to do. For that reason, the following example will not compile./// trait TraitExample {}/// impl<'a> TraitExample for &'a str {}/// fn example_func<A: TraitExample>(example_arg: A) {}/// let example_string = String::from("example_string");/// example_func(&example_string);/// There are two options that would work instead. The first would be to/// change the line `example_func(&example_string);` to/// `example_func(example_string.as_str());`, using the method [`as_str()`]/// to explicitly extract the string slice containing the string. The second/// way changes `example_func(&example_string);` to/// `example_func(&*example_string);`. In this case we are dereferencing a/// `String` to a [`str`], then referencing the [`str`] back to/// [`&str`]. The second way is more idiomatic, however both work to do the/// conversion explicitly rather than relying on the implicit conversion./// A `String` is made up of three components: a pointer to some bytes, a/// length, and a capacity. The pointer points to the internal buffer which `String`/// uses to store its data. The length is the number of bytes currently stored/// in the buffer, and the capacity is the size of the buffer in bytes. As such,/// the length will always be less than or equal to the capacity./// This buffer is always stored on the heap./// You can look at these with the [`as_ptr`], [`len`], and [`capacity`]/// methods:/// let story = String::from("Once upon a time...");/// // Deconstruct the String into parts./// let (ptr, len, capacity) = story.into_raw_parts();/// // story has nineteen bytes/// assert_eq!(19, len);/// // We can re-build a String out of ptr, len, and capacity. This is all/// // unsafe because we are responsible for making sure the components are/// // valid:/// let s = unsafe { String::from_raw_parts(ptr, len, capacity) } ;/// assert_eq!(String::from("Once upon a time..."), s);/// [`as_ptr`]: str::as_ptr/// [`len`]: String::len/// [`capacity`]: String::capacity/// If a `String` has enough capacity, adding elements to it will not/// re-allocate. For example, consider this program:/// println!("{}", s.capacity());///     s.push_str("hello");///     println!("{}", s.capacity());/// This will output the following:/// 0/// 8/// 32/// At first, we have no memory allocated at all, but as we append to the/// string, it increases its capacity appropriately. If we instead use the/// [`with_capacity`] method to allocate the correct capacity initially:/// let mut s = String::with_capacity(25);/// [`with_capacity`]: String::with_capacity/// We end up with a different output:/// 25/// Here, there's no need to allocate more memory inside the loop./// [`str`]: prim@str "str"/// [`&str`]: prim@str "&str"/// [Deref]: core::ops::Deref "ops::Deref"/// [`Deref`]: core::ops::Deref "ops::Deref"/// [`as_str()`]: String::as_str/// A possible error value when converting a `String` from a UTF-8 byte vector./// This type is the error type for the [`from_utf8`] method on [`String`]. It/// is designed in such a way to carefully avoid reallocations: the/// [`into_bytes`] method will give back the byte vector that was used in the/// conversion attempt./// [`into_bytes`]: FromUtf8Error::into_bytes/// The [`Utf8Error`] type provided by [`std::str`] represents an error that may/// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's/// an analogue to `FromUtf8Error`, and you can get one from a `FromUtf8Error`/// through the [`utf8_error`] method./// [`Utf8Error`]: str::Utf8Error "std::str::Utf8Error"/// [`std::str`]: core::str "std::str"/// [`utf8_error`]: FromUtf8Error::utf8_error/// // some invalid bytes, in a vector/// let bytes = vec![0, 159];/// let value = String::from_utf8(bytes);/// assert!(value.is_err());/// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());/// A possible error value when converting a `String` from a UTF-16 byte slice./// This type is the error type for the [`from_utf16`] method on [`String`]./// [`from_utf16`]: String::from_utf16/// // 𝄞mu<invalid>ic/// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,///           0xD800, 0x0069, 0x0063];/// assert!(String::from_utf16(v).is_err());"string_new"/// Creates a new empty `String`./// Given that the `String` is empty, this will not allocate any initial/// buffer. While that means that this initial operation is very/// inexpensive, it may cause excessive allocation later when you add/// data. If you have an idea of how much data the `String` will hold,/// consider the [`with_capacity`] method to prevent excessive/// re-allocation./// let s = String::new();/// Creates a new empty `String` with at least the specified capacity./// `String`s have an internal buffer to hold their data. The capacity is/// the length of that buffer, and can be queried with the [`capacity`]/// method. This method creates an empty `String`, but one with an initial/// buffer that can hold at least `capacity` bytes. This is useful when you/// may be appending a bunch of data to the `String`, reducing the number of/// reallocations it needs to do./// If the given capacity is `0`, no allocation will occur, and this method/// is identical to the [`new`] method./// [`new`]: String::new/// Panics if the capacity exceeds `isize::MAX` _bytes_./// let mut s = String::with_capacity(10);/// // The String contains no chars, even though it has capacity for more/// let cap = s.capacity();///     s.push('a');/// assert_eq!(s.capacity(), cap);/// // ...but this may make the string reallocate/// s.push('a');/// Returns [`Err`] if the capacity exceeds `isize::MAX` bytes,/// or if the memory allocator reports failure."string_from_utf8"/// Converts a vector of bytes to a `String`./// A string ([`String`]) is made of bytes ([`u8`]), and a vector of bytes/// ([`Vec<u8>`]) is made of bytes, so this function converts between the/// two. Not all byte slices are valid `String`s, however: `String`/// requires that it is valid UTF-8. `from_utf8()` checks to ensure that/// the bytes are valid UTF-8, and then does the conversion./// If you are sure that the byte slice is valid UTF-8, and you don't want/// to incur the overhead of the validity check, there is an unsafe version/// of this function, [`from_utf8_unchecked`], which has the same behavior/// This method will take care to not copy the vector, for efficiency's/// sake./// If you need a [`&str`] instead of a `String`, consider/// [`str::from_utf8`]./// The inverse of this method is [`into_bytes`]./// Returns [`Err`] if the slice is not UTF-8 with a description as to why the/// provided bytes are not UTF-8. The vector you moved in is also included./// Incorrect bytes:/// let sparkle_heart = vec![0, 159, 146, 150];/// assert!(String::from_utf8(sparkle_heart).is_err());/// See the docs for [`FromUtf8Error`] for more details on what you can do/// with this error./// [`from_utf8_unchecked`]: String::from_utf8_unchecked/// [`Vec<u8>`]: crate::vec::Vec "Vec"/// [`into_bytes`]: String::into_bytes/// Converts a slice of bytes to a string, including invalid characters./// Strings are made of bytes ([`u8`]), and a slice of bytes/// ([`&[u8]`][byteslice]) is made of bytes, so this function converts/// between the two. Not all byte slices are valid strings, however: strings/// are required to be valid UTF-8. During this conversion,/// `from_utf8_lossy()` will replace any invalid UTF-8 sequences with/// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: �/// [byteslice]: prim@slice/// [U+FFFD]: core::char::REPLACEMENT_CHARACTER/// to incur the overhead of the conversion, there is an unsafe version/// but skips the checks./// This function returns a [`Cow<'a, str>`]. If our byte slice is invalid/// UTF-8, then we need to insert the replacement characters, which will/// change the size of the string, and hence, require a `String`. But if/// it's already valid UTF-8, we don't need a new allocation. This return/// type allows us to handle both cases./// [`Cow<'a, str>`]: crate::borrow::Cow "borrow::Cow"/// let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);/// // some invalid bytes/// let input = b"Hello \xF0\x90\x80World";/// let output = String::from_utf8_lossy(input);/// assert_eq!("Hello �World", output);from_utf8_lossy_owned/// Converts a [`Vec<u8>`] to a `String`, substituting invalid UTF-8/// sequences with replacement characters./// See [`from_utf8_lossy`] for more details./// [`from_utf8_lossy`]: String::from_utf8_lossy/// Note that this function does not guarantee reuse of the original `Vec`/// #![feature(string_from_utf8_lossy_owned)]/// let sparkle_heart = String::from_utf8_lossy_owned(sparkle_heart);/// assert_eq!(String::from("💖"), sparkle_heart);/// let input: Vec<u8> = b"Hello \xF0\x90\x80World".into();/// let output = String::from_utf8_lossy_owned(input);/// assert_eq!(String::from("Hello �World"), output);/// Decode a native endian UTF-16–encoded vector `v` into a `String`,/// returning [`Err`] if `v` contains any invalid data./// // 𝄞music///           0x0073, 0x0069, 0x0063];/// assert_eq!(String::from("𝄞music"),///            String::from_utf16(v).unwrap());/// Decode a native endian UTF-16–encoded slice `v` into a `String`,/// replacing invalid data with [the replacement character (`U+FFFD`)][U+FFFD]./// Unlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`],/// `from_utf16_lossy` returns a `String` since the UTF-16 to UTF-8/// conversion requires a memory allocation.///           0x0073, 0xDD1E, 0x0069, 0x0063,///           0xD834];/// assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),///            String::from_utf16_lossy(v));/// Decode a UTF-16LE–encoded vector `v` into a `String`,/// #![feature(str_from_utf16_endian)]/// let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,///           0x73, 0x00, 0x69, 0x00, 0x63, 0x00];///            String::from_utf16le(v).unwrap());///           0x00, 0xD8, 0x69, 0x00, 0x63, 0x00];/// assert!(String::from_utf16le(v).is_err());from_utf16le_lossy/// Decode a UTF-16LE–encoded slice `v` into a `String`, replacing/// invalid data with [the replacement character (`U+FFFD`)][U+FFFD]./// `from_utf16le_lossy` returns a `String` since the UTF-16 to UTF-8///           0x73, 0x00, 0x1E, 0xDD, 0x69, 0x00, 0x63, 0x00,///           0x34, 0xD8];///            String::from_utf16le_lossy(v));/// Decode a UTF-16BE–encoded vector `v` into a `String`,/// let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,///           0x00, 0x73, 0x00, 0x69, 0x00, 0x63];///            String::from_utf16be(v).unwrap());///           0xD8, 0x00, 0x00, 0x69, 0x00, 0x63];/// assert!(String::from_utf16be(v).is_err());from_utf16be_lossy/// Decode a UTF-16BE–encoded slice `v` into a `String`, replacing///           0x00, 0x73, 0xDD, 0x1E, 0x00, 0x69, 0x00, 0x63,///           0xD8, 0x34];///            String::from_utf16be_lossy(v));/// Decomposes a `String` into its raw components: `(pointer, length, capacity)`./// Returns the raw pointer to the underlying data, the length of/// the string (in bytes), and the allocated capacity of the data/// (in bytes). These are the same arguments in the same order as/// the arguments to [`from_raw_parts`]./// memory previously managed by the `String`. The only way to do/// this is to convert the raw pointer, length, and capacity back/// into a `String` with the [`from_raw_parts`] function, allowing/// the destructor to perform the cleanup./// [`from_raw_parts`]: String::from_raw_parts/// let s = String::from("hello");/// let (ptr, len, cap) = s.into_raw_parts();/// let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };/// assert_eq!(rebuilt, "hello");/// Creates a new `String` from a pointer, a length and a capacity./// * all safety requirements for [`Vec::<u8>::from_raw_parts`]./// * all safety requirements for [`String::from_utf8_unchecked`]./// internal data structures. For example, it is normally **not** safe to/// build a `String` from a pointer to a C `char` array containing UTF-8/// _unless_ you are certain that array was originally allocated by the/// Rust standard library's allocator./// The ownership of `buf` is effectively transferred to the/// `String` which may then deallocate, reallocate or change the///     let s = String::from("hello");///     // Deconstruct the String into parts.///     let (ptr, len, capacity) = s.into_raw_parts();///     let s = String::from_raw_parts(ptr, len, capacity);///     assert_eq!(String::from("hello"), s);/// Converts a vector of bytes to a `String` without checking that the/// string contains valid UTF-8./// See the safe version, [`from_utf8`], for more details./// This function is unsafe because it does not check that the bytes passed/// to it are valid UTF-8. If this constraint is violated, it may cause/// memory unsafety issues with future users of the `String`, as the rest of/// the standard library assumes that `String`s are valid UTF-8./// let sparkle_heart = unsafe {///     String::from_utf8_unchecked(sparkle_heart)rustc_allow_const_fn_unstable/// Converts a `String` into a byte vector./// This consumes the `String`, so we do not need to copy its contents./// let bytes = s.into_bytes();/// assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);"string_as_str"/// Extracts a string slice containing the entire `String`./// let s = String::from("foo");/// assert_eq!("foo", s.as_str());"string_as_mut_str"/// Converts a `String` into a mutable string slice./// let mut s = String::from("foobar");/// let s_mut_str = s.as_mut_str();/// s_mut_str.make_ascii_uppercase();/// assert_eq!("FOOBAR", s_mut_str);"string_push_str"/// Appends a given string slice onto the end of this `String`./// let mut s = String::from("foo");/// s.push_str("bar");/// Copies elements from `src` range to the end of the string./// Panics if the range has `start_bound > end_bound`, if the range is/// bounded on either end and does not lie on a [`char`] boundary, or if the/// new capacity exceeds `isize::MAX` bytes./// let mut string = String::from("abcde");/// string.extend_from_within(2..);/// assert_eq!(string, "abcdecde");/// string.extend_from_within(..2);/// assert_eq!(string, "abcdecdeab");/// string.extend_from_within(4..8);/// assert_eq!(string, "abcdecdeabecde");/// Returns this `String`'s capacity, in bytes./// let s = String::with_capacity(10);/// assert!(s.capacity() >= 10);/// Reserves capacity for at least `additional` bytes more than the/// s.reserve(10);/// This might not actually increase the capacity:/// s.push('b');/// // s now has a length of 2 and a capacity of at least 10/// let capacity = s.capacity();/// assert_eq!(2, s.len());/// assert!(capacity >= 10);/// // Since we already have at least an extra 8 capacity, calling this.../// s.reserve(8);/// // ... doesn't actually increase./// assert_eq!(capacity, s.capacity());/// Reserves the minimum capacity for at least `additional` bytes more than/// [`reserve`]: String::reserve/// s.reserve_exact(10);/// s.reserve_exact(8);/// Tries to reserve capacity for at least `additional` bytes more than the/// fn process_data(data: &str) -> Result<String, TryReserveError> {///     let mut output = String::new();///     output.push_str(data);/// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?");/// Tries to reserve the minimum capacity for at least `additional` bytes/// [`try_reserve`]: String::try_reserve/// Shrinks the capacity of this `String` to match its length./// s.reserve(100);/// assert!(s.capacity() >= 100);/// s.shrink_to_fit();/// assert_eq!(3, s.capacity());/// Shrinks the capacity of this `String` with a lower bound./// s.shrink_to(10);/// s.shrink_to(0);/// assert!(s.capacity() >= 3);/// Appends the given [`char`] to the end of this `String`./// let mut s = String::from("abc");/// Returns a byte slice of this `String`'s contents./// The inverse of this method is [`from_utf8`]./// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());/// Shortens this `String` to the specified length./// If `new_len` is greater than or equal to the string's current length, this has no/// Note that this method has no effect on the allocated capacity/// of the string/// let mut s = String::from("hello");/// Returns [`None`] if this `String` is empty./// let mut s = String::from("abč");/// assert_eq!(s.pop(), Some('č'));/// assert_eq!(s.pop(), Some('b'));/// assert_eq!(s.pop(), Some('a'));/// Removes a [`char`] from this `String` at byte position `idx` and returns it./// Copies all bytes after the removed char to new positions./// Note that calling this in a loop can result in quadratic behavior./// Panics if `idx` is larger than or equal to the `String`'s length,/// or if it does not lie on a [`char`] boundary./// let mut s = String::from("abç");/// assert_eq!(s.remove(0), 'a');/// assert_eq!(s.remove(1), 'ç');/// assert_eq!(s.remove(0), 'b');remove_matches/// Remove all matches of pattern `pat` in the `String`./// #![feature(string_remove_matches)]/// let mut s = String::from("Trees are not green, the sky is not blue.");/// s.remove_matches("not ");/// assert_eq!("Trees are green, the sky is blue.", s);/// Matches will be detected and removed iteratively, so in cases where/// patterns overlap, only the first pattern will be removed:/// let mut s = String::from("banana");/// s.remove_matches("ana");/// assert_eq!("bna", s);/// In other words, remove all characters `c` such that `f(c)` returns `false`./// This method operates in place, visiting each character exactly once in the/// original order, and preserves the order of the retained characters./// let mut s = String::from("f_o_ob_ar");/// let mut s = String::from("abcde");/// Inserts a character into this `String` at byte position `idx`./// Reallocates if `self.capacity()` is insufficient, which may involve copying all/// `self.capacity()` bytes. Makes space for the insertion by copying all bytes of/// `&self[idx..]` to new positions./// Panics if `idx` is larger than the `String`'s length, or if it does not/// let mut s = String::with_capacity(3);/// s.insert(2, 'o');"string_insert_str"insert_str/// Inserts a string slice into this `String` at byte position `idx`./// let mut s = String::from("bar");/// s.insert_str(0, "foo");/// Returns a mutable reference to the contents of this `String`./// This function is unsafe because the returned `&mut Vec` allows writing/// bytes which are not valid UTF-8. If this constraint is violated, using/// the original `String` after dropping the `&mut Vec` may violate memory/// safety, as the rest of the standard library assumes that `String`s are///     let vec = s.as_mut_vec();///     assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);///     vec.reverse();/// assert_eq!(s, "olleh");rustc_no_implicit_autorefs/// Returns the length of this `String`, in bytes, not [`char`]s or/// graphemes. In other words, it might not be what a human considers the/// length of the string./// let a = String::from("foo");/// assert_eq!(a.len(), 3);/// let fancy_f = String::from("ƒoo");/// assert_eq!(fancy_f.len(), 4);/// assert_eq!(fancy_f.chars().count(), 3);/// Returns `true` if this `String` has a length of zero, and `false` otherwise./// let mut v = String::new();/// v.push('a');/// Splits the string into two at the given byte index./// Returns a newly allocated `String`. `self` contains bytes `[0, at)`, and/// the returned `String` contains bytes `[at, len)`. `at` must be on the/// boundary of a UTF-8 code point./// Panics if `at` is not on a `UTF-8` code point boundary, or if it is beyond the last/// code point of the string./// let mut hello = String::from("Hello, World!");/// Truncates this `String`, removing all contents./// While this means the `String` will have a length of zero, it does not/// touch its capacity./// s.clear();/// assert_eq!(0, s.len());/// Removes the specified range from the string in bulk, returning all/// removed characters as an iterator./// The returned iterator keeps a mutable borrow on the string to optimize/// bounded on either end and does not lie on a [`char`] boundary./// [`core::mem::forget`], for example), the string may still contain a copy/// of any drained characters, or may have lost characters arbitrarily,/// including characters outside the range./// let mut s = String::from("α is alpha, β is beta");/// let beta_offset = s.find('β').unwrap_or(s.len());/// let t: String = s.drain(..beta_offset).collect();/// // A full range clears the string, like `clear()` doesinto_charsIntoChars/// Converts a `String` into an iterator over the [`char`]s of the string./// As a string consists of valid UTF-8, we can iterate through a string/// by [`char`]. This method returns such an iterator./// It's important to remember that [`char`] represents a Unicode Scalar/// Value, and might not match your idea of what a 'character' is. Iteration/// over grapheme clusters may be what you actually want. That functionality/// is not provided by Rust's standard library, check crates.io instead./// #![feature(string_into_chars)]/// let word = String::from("goodbye");/// let mut chars = word.into_chars();/// assert_eq!(Some('g'), chars.next());/// assert_eq!(Some('o'), chars.next());/// assert_eq!(Some('d'), chars.next());/// assert_eq!(Some('b'), chars.next());/// assert_eq!(Some('y'), chars.next());/// assert_eq!(Some('e'), chars.next());/// assert_eq!(None, chars.next());/// Remember, [`char`]s might not match your intuition about characters:/// let y = String::from("y̆");/// let mut chars = y.into_chars();/// assert_eq!(Some('y'), chars.next()); // not 'y̆'/// assert_eq!(Some('\u{0306}'), chars.next());/// [`char`]: prim@char/// Removes the specified range in the string,/// and replaces it with the given string./// s.replace_range(..beta_offset, "Α is capital alpha; ");replace_first/// Replaces the leftmost occurrence of a pattern with another string, in-place./// This method can be preferred over [`string = string.replacen(..., 1);`][replacen],/// as it can use the `String`'s existing capacity to prevent a reallocation if/// sufficient space is available./// #![feature(string_replace_in_place)]/// let mut s = String::from("Test Results: ❌❌❌");/// // Replace the leftmost ❌ with a ✅/// s.replace_first('❌', "✅");/// assert_eq!(s, "Test Results: ✅❌❌");/// [replacen]: ../../std/primitive.str.html#method.replacenreplace_last/// Replaces the rightmost occurrence of a pattern with another string, in-place./// // Replace the rightmost ❌ with a ✅/// s.replace_last('❌', "✅");/// assert_eq!(s, "Test Results: ❌❌✅");into_boxed_str/// Converts this `String` into a <code>[Box]<[str]></code>./// Before doing the conversion, this method discards excess capacity like [`shrink_to_fit`]./// Note that this call may reallocate and copy the bytes of the string./// [`shrink_to_fit`]: String::shrink_to_fit/// let b = s.into_boxed_str();/// Consumes and leaks the `String`, returning a mutable reference to the contents,/// `&'a mut str`./// The caller has free choice over the returned lifetime, including `'static`. Indeed,/// this function is ideally used for data that lives for the remainder of the program's life,/// as dropping the returned reference will cause a memory leak./// It does not reallocate or shrink the `String`, so the leaked allocation may include unused/// capacity that is not part of the returned slice. If you want to discard excess capacity,/// call [`into_boxed_str`], and then [`Box::leak`] instead. However, keep in mind that/// trimming the capacity may result in a reallocation and copy./// [`into_boxed_str`]: Self::into_boxed_str/// let x = String::from("bucket");/// let static_ref: &'static mut str = x.leak();/// assert_eq!(static_ref, "bucket");/// Returns a slice of [`u8`]s bytes that were attempted to convert to a `String`./// assert_eq!(&[0, 159], value.unwrap_err().as_bytes());into_utf8_lossy/// Converts the bytes into a `String` lossily, substituting invalid UTF-8/// See [`String::from_utf8_lossy`] for more details on replacement of/// invalid sequences, and [`String::from_utf8_lossy_owned`] for the/// `String` function which corresponds to this function./// let output = String::from_utf8(input).unwrap_or_else(|e| e.into_utf8_lossy());/// Returns the bytes that were attempted to convert to a `String`./// Fetch a `Utf8Error` to get more details about the conversion failure./// an analogue to `FromUtf8Error`. See its documentation for more details/// on using it./// let error = String::from_utf8(bytes).unwrap_err().utf8_error();/// // the first byte is invalid here/// assert_eq!(1, error.valid_up_to());/// Clones the contents of `source` into `self`.is_contained_inis_prefix_ofstrip_prefix_ofstrip_suffix_of/// A convenience impl that delegates to the impl for `&str`./// assert_eq!(String::from("Hello world").find("world"), Some(6));/// Creates an empty `String`./// Implements the `+` operator for concatenating two strings./// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if/// necessary). This is done to avoid allocating a new `String` and copying the entire contents on/// every operation, which would lead to *O*(*n*^2) running time when building an *n*-byte string by/// repeated concatenation./// The string on the right-hand side is only borrowed; its contents are copied into the returned/// Concatenating two `String`s takes the first by value and borrows the second:/// let a = String::from("hello");/// let b = String::from(" world");/// let c = a + &b;/// // `a` is moved and can no longer be used here./// If you want to keep using the first `String`, you can clone it and append to the clone instead:/// let c = a.clone() + &b;/// // `a` is still valid here./// Concatenating `&str` slices can be done by converting the first to a `String`:/// let a = "hello";/// let b = " world";/// let c = a.to_string() + b;/// Implements the `+=` operator for appending to a `String`./// This has the same behavior as the [`push_str`][String::push_str] method./// A type alias for [`Infallible`]./// This alias exists for backwards compatibility, and may be eventually deprecated./// [`Infallible`]: core::convert::Infallible "convert::Infallible""to_string_method"/// Converts the given value to a `String`./// let i = 5;/// let five = String::from("5");/// assert_eq!(five, i.to_string());"ToString"/// A trait for converting a value to a `String`./// This trait is automatically implemented for any type which implements the/// [`Display`] trait. As such, `ToString` shouldn't be implemented directly:/// [`Display`] should be implemented instead, and you get the `ToString`/// implementation for free./// [`Display`]: fmt::Display/// In this implementation, the `to_string` method panics/// if the `Display` implementation returns an error./// This indicates an incorrect `Display` implementationspec_to_stringSpecToString// A common guideline is to not inline generic functions. However,// removing `#[inline]` from this method causes non-negligible regressions.// See <https://github.com/rust-lang/rust/pull/74852>, the last attempt// to try to remove it.impl_to_stringto_string_str/// Converts a `&str` into a [`String`]./// Converts a `&mut str` into a [`String`]./// Converts a `&String` into a [`String`]./// This clones `s` and returns the clone./// Converts the given boxed `str` slice to a [`String`]./// It is notable that the `str` slice is owned./// let s1: String = String::from("hello world");/// let s2: Box<str> = s1.into_boxed_str();/// let s3: String = String::from(s2);/// assert_eq!("hello world", s3)// note: test pulls in std, which causes errors here/// Converts the given [`String`] to a boxed `str` slice that is owned./// let s2: Box<str> = Box::from(s1);/// Converts a clone-on-write string to an owned/// instance of [`String`]./// This extracts the owned string,/// clones the string if it is not already owned./// // If the string is not owned.../// // It will allocate on the heap and copy the string./// let owned: String = String::from(cow);/// assert_eq!(&owned[..], "eggplant");/// Converts a string slice into a [`Borrowed`] variant./// No heap allocation is performed, and the string/// is not copied./// assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));/// [`Borrowed`]: crate::borrow::Cow::Borrowed "borrow::Cow::Borrowed"/// Converts a [`String`] into an [`Owned`] variant./// let s = "eggplant".to_string();/// let s2 = "eggplant".to_string();/// assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));/// [`Owned`]: crate::borrow::Cow::Owned "borrow::Cow::Owned"/// Converts a [`String`] reference into a [`Borrowed`] variant./// assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));/// Converts the given [`String`] to a vector [`Vec`] that holds values of type [`u8`]./// let s1 = String::from("hello world");/// let v1 = Vec::from(s1);/// for b in v1 {///     println!("{b}");/// Converts the given [`Vec<u8>`] into a  [`String`] if it contains valid UTF-8 data./// let s1 = b"hello world".to_vec();/// let v1 = String::try_from(s1).unwrap();/// assert_eq!(v1, "hello world");/// An iterator over the [`char`]s of a string./// This struct is created by the [`into_chars`] method on [`String`]./// [`into_chars`]: String::into_chars/// Views the underlying data as a subslice of the original data./// let mut chars = String::from("abc").into_chars();/// assert_eq!(chars.as_str(), "abc");/// chars.next();/// assert_eq!(chars.as_str(), "bc");/// assert_eq!(chars.as_str(), "");/// Consumes the `IntoChars`, returning the remaining string./// let chars = String::from("abc").into_chars();/// assert_eq!(chars.into_string(), "abc");/// let mut chars = String::from("def").into_chars();/// assert_eq!(chars.into_string(), "ef");/// Will be used as &'a mut String in the destructor/// Start of part to remove/// End of part to remove/// A draining iterator for `String`./// This struct is created by the [`drain`] method on [`String`]. See its/// [`drain`]: String::drain/// Returns the remaining (sub)string of this iterator as a slice./// let mut drain = s.drain(..);/// assert_eq!(drain.as_str(), "abc");/// let _ = drain.next().unwrap();/// assert_eq!(drain.as_str(), "bc");/// Allocates an owned [`String`] from a single character./// let c: char = 'a';/// let s: String = String::from(c);/// assert_eq!("a", &s[..]);//! A UTF-8–encoded, growable string.//! This module contains the [`String`] type, the [`ToString`] trait for//! converting to strings, and several error types that may result from//! working with [`String`]s.//! There are multiple ways to create a new [`String`] from a string literal://! let s = "Hello".to_string();//! let s = String::from("world");//! let s: String = "also this".into();//! You can create a new [`String`] from an existing one by concatenating with//! `+`://! let message = s + " world!";//! If you have a vector of valid UTF-8 bytes, you can make a [`String`] out of//! it. You can do the reverse too.//! let sparkle_heart = vec![240, 159, 146, 150];//! // We know these bytes are valid, so we'll use `unwrap()`.//! let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();//! assert_eq!("💖", sparkle_heart);//! let bytes = sparkle_heart.into_bytes();//! assert_eq!(bytes, [240, 159, 146, 150]);MAX_REFCOUNT/// A soft limit on the amount of references that may be made to an `Arc`./// Going above this limit will abort your program (although not/// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references./// Trying to go above it might call a `panic` (if not actually going above it)./// This is a global invariant, and also applies when using a compare-exchange loop./// See comment in `Arc::clone`.INTERNAL_OVERFLOW_ERROR/// The error in case either counter reaches above `MAX_REFCOUNT`, and we can `panic` safely."Arc"ArcInner/// A thread-safe reference-counting pointer. 'Arc' stands for 'Atomically/// Reference Counted'./// The type `Arc<T>` provides shared ownership of a value of type `T`,/// allocated in the heap. Invoking [`clone`][clone] on `Arc` produces/// a new `Arc` instance, which points to the same allocation on the heap as the/// source `Arc`, while increasing a reference count. When the last `Arc`/// pointer to a given allocation is destroyed, the value stored in that allocation (often/// referred to as "inner value") is also dropped./// Shared references in Rust disallow mutation by default, and `Arc` is no/// exception: you cannot generally obtain a mutable reference to something/// inside an `Arc`. If you do need to mutate through an `Arc`, you have several options:/// 1. Use interior mutability with synchronization primitives like [`Mutex`][mutex],///    [`RwLock`][rwlock], or one of the [`Atomic`][atomic] types./// 2. Use clone-on-write semantics with [`Arc::make_mut`] which provides efficient mutation///    without requiring interior mutability. This approach clones the data only when///    needed (when there are multiple references) and can be more efficient when mutations///    are infrequent./// 3. Use [`Arc::get_mut`] when you know your `Arc` is not shared (has a reference count of 1),///    which provides direct mutable access to the inner value without any cloning./// let mut data = Arc::new(vec![1, 2, 3]);/// // This will clone the vector only if there are other references to it/// Arc::make_mut(&mut data).push(4);/// assert_eq!(*data, vec![1, 2, 3, 4]);/// **Note**: This type is only available on platforms that support atomic/// loads and stores of pointers, which includes all platforms that support/// the `std` crate but not all those which only support [`alloc`](crate)./// This may be detected at compile time using `#[cfg(target_has_atomic = "ptr")]`./// ## Thread Safety/// Unlike [`Rc<T>`], `Arc<T>` uses atomic operations for its reference/// counting. This means that it is thread-safe. The disadvantage is that/// atomic operations are more expensive than ordinary memory accesses. If you/// are not sharing reference-counted allocations between threads, consider using/// [`Rc<T>`] for lower overhead. [`Rc<T>`] is a safe default, because the/// compiler will catch any attempt to send an [`Rc<T>`] between threads./// However, a library might choose `Arc<T>` in order to give library consumers/// more flexibility./// `Arc<T>` will implement [`Send`] and [`Sync`] as long as the `T` implements/// [`Send`] and [`Sync`]. Why can't you put a non-thread-safe type `T` in an/// `Arc<T>` to make it thread-safe? This may be a bit counter-intuitive at/// first: after all, isn't the point of `Arc<T>` thread safety? The key is/// this: `Arc<T>` makes it thread safe to have multiple ownership of the same/// data, but it  doesn't add thread safety to its data. Consider/// <code>Arc<[RefCell\<T>]></code>. [`RefCell<T>`] isn't [`Sync`], and if `Arc<T>` was always/// [`Send`], <code>Arc<[RefCell\<T>]></code> would be as well. But then we'd have a problem:/// [`RefCell<T>`] is not thread safe; it keeps track of the borrowing count using/// non-atomic operations./// In the end, this means that you may need to pair `Arc<T>` with some sort of/// [`std::sync`] type, usually [`Mutex<T>`][mutex]./// ## Breaking cycles with `Weak`/// The [`downgrade`][downgrade] method can be used to create a non-owning/// [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d/// to an `Arc`, but this will return [`None`] if the value stored in the allocation has/// already been dropped. In other words, `Weak` pointers do not keep the value/// inside the allocation alive; however, they *do* keep the allocation/// (the backing store for the value) alive./// A cycle between `Arc` pointers will never be deallocated. For this reason,/// [`Weak`] is used to break cycles. For example, a tree could have/// strong `Arc` pointers from parent nodes to children, and [`Weak`]/// # Cloning references/// Creating a new reference from an existing reference-counted pointer is done using the/// `Clone` trait implemented for [`Arc<T>`][Arc] and [`Weak<T>`][Weak]./// let foo = Arc::new(vec![1.0, 2.0, 3.0]);/// // The two syntaxes below are equivalent./// let a = foo.clone();/// let b = Arc::clone(&foo);/// // a, b, and foo are all Arcs that point to the same memory location/// ## `Deref` behavior/// `Arc<T>` automatically dereferences to `T` (via the [`Deref`] trait),/// so you can call `T`'s methods on a value of type `Arc<T>`. To avoid name/// clashes with `T`'s methods, the methods of `Arc<T>` itself are associated/// functions, called using [fully qualified syntax]:/// let my_arc = Arc::new(());/// let my_weak = Arc::downgrade(&my_arc);/// `Arc<T>`'s implementations of traits like `Clone` may also be called using/// fully qualified syntax. Some people prefer to use fully qualified syntax,/// while others prefer using method-call syntax./// let arc = Arc::new(());/// // Method-call syntax/// let arc2 = arc.clone();/// // Fully qualified syntax/// let arc3 = Arc::clone(&arc);/// [`Weak<T>`][Weak] does not auto-dereference to `T`, because the inner value may have/// already been dropped./// [`Rc<T>`]: crate::rc::Rc/// [mutex]: ../../std/sync/struct.Mutex.html/// [rwlock]: ../../std/sync/struct.RwLock.html/// [atomic]: core::sync::atomic/// [downgrade]: Arc::downgrade/// [upgrade]: Weak::upgrade/// [RefCell\<T>]: core::cell::RefCell/// [`RefCell<T>`]: core::cell::RefCell/// [`std::sync`]: ../../std/sync/index.html/// [`Arc::clone(&from)`]: Arc::clone/// [fully qualified syntax]: https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name/// Sharing some immutable data between threads:/// let five = Arc::new(5);///     let five = Arc::clone(&five);///         println!("{five:?}");/// Sharing a mutable [`AtomicUsize`]:/// [`AtomicUsize`]: core::sync::atomic::AtomicUsize "sync::atomic::AtomicUsize"/// let val = Arc::new(AtomicUsize::new(5));///     let val = Arc::clone(&val);///         let v = val.fetch_add(1, Ordering::Relaxed);///         println!("{v:?}");/// See the [`rc` documentation][rc_examples] for more examples of reference/// counting in general./// [rc_examples]: crate::rc#examples// SAFETY: `Arc::clone` doesn't access any `Cell`s which could contain the `Arc` being cloned."ArcWeak"// will ever have because ArcInner has alignment at least 2./// `Weak` is a version of [`Arc`] that holds a non-owning reference to the/// pointer, which returns an <code>[Option]<[Arc]\<T>></code>./// managed by [`Arc`] without preventing its inner value from being dropped. It is also used to/// prevent circular references between [`Arc`] pointers, since mutual owning references/// would never allow either [`Arc`] to be dropped. For example, a tree could/// have strong [`Arc`] pointers from parent nodes to children, and `Weak`/// The typical way to obtain a `Weak` pointer is to call [`Arc::downgrade`].// the value usize::MAX acts as a sentinel for temporarily "locking" the// ability to upgrade weak pointers or downgrade strong ones; this is used// to avoid races in `make_mut` and `get_mut`.// Unlike RcInner, repr(align(2)) is not strictly required because atomic types// have the alignment same as its size, but we use it for consistency and clarity.arcinner_layout_for_value_layout/// Calculate layout for `ArcInner<T>` using the inner value's layout/// Constructs a new `Arc<T>`./// Constructs a new `Arc<T>` while giving you a `Weak<T>` to the allocation,/// initialization of `T`, before the `Arc<T>` is created, such that you can/// `new_cyclic` first allocates the managed allocation for the `Arc<T>`,/// and only afterwards completes the construction of the `Arc<T>` by placing/// Since the new `Arc<T>` is not fully-constructed until `Arc<T>::new_cyclic`/// use std::sync::{Arc, Weak};///     fn new() -> Arc<Self> {///         // `Arc` we're constructing.///         Arc::new_cyclic(|me| {///     fn me(&self) -> Arc<Self> {/// Constructs a new `Arc` with uninitialized contents./// let mut five = Arc::<u32>::new_uninit();/// Arc::get_mut(&mut five).unwrap().write(5);/// Constructs a new `Arc` with uninitialized contents, with the memory/// let zero = Arc::<u32>::new_zeroed();/// Constructs a new `Pin<Arc<T>>`. If `T` does not implement `Unpin`, then/// `data` will be pinned in memory and unable to be moved.try_pin/// Constructs a new `Pin<Arc<T>>`, return an error if allocation fails./// Constructs a new `Arc<T>`, returning an error if allocation fails./// let five = Arc::try_new(5)?;/// Constructs a new `Arc` with uninitialized contents, returning an error/// if allocation fails./// let mut five = Arc::<u32>::try_new_uninit()?;/// being filled with `0` bytes, returning an error if allocation fails./// #![feature( allocator_api)]/// let zero = Arc::<u32>::try_new_zeroed()?;/// Maps the value in an `Arc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `Arc`, and the result is returned, also in/// an `Arc`./// to call it as `Arc::map(a, f)` instead of `r.map(a)`. This/// let r = Arc::new(7);/// let new = Arc::map(r, |i| i + 7);/// Attempts to map the value in an `Arc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `Arc`, and if the operation succeeds, the/// result is returned, also in an `Arc`./// to call it as `Arc::try_map(a, f)` instead of `a.try_map(f)`. This/// let b = Arc::new(7);/// let new = Arc::try_map(b, |&i| u32::try_from(i)).unwrap();/// Constructs a new `Arc<T>` in the provided allocator./// let five = Arc::new_in(5, System);/// Constructs a new `Arc` with uninitialized contents in the provided allocator./// let mut five = Arc::<u32, _>::new_uninit_in(System);///     Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);/// let zero = Arc::<u32, _>::new_zeroed_in(System);/// Constructs a new `Arc<T, A>` in the given allocator while giving you a `Weak<T, A>` to the allocation,/// initialization of `T`, before the `Arc<T, A>` is created, such that you can/// `new_cyclic_in` first allocates the managed allocation for the `Arc<T, A>`,/// and only afterwards completes the construction of the `Arc<T, A>` by placing/// Since the new `Arc<T, A>` is not fully-constructed until `Arc<T, A>::new_cyclic_in`/// See [`new_cyclic`]/// [`new_cyclic`]: Arc::new_cyclic/// Constructs a new `Pin<Arc<T, A>>` in the provided allocator. If `T` does not implement `Unpin`,/// then `data` will be pinned in memory and unable to be moved.try_pin_in/// Constructs a new `Pin<Arc<T, A>>` in the provided allocator, return an error if allocation/// Constructs a new `Arc<T, A>` in the provided allocator, returning an error if allocation fails./// let five = Arc::try_new_in(5, System)?;/// Constructs a new `Arc` with uninitialized contents, in the provided allocator, returning an/// error if allocation fails./// let mut five = Arc::<u32, _>::try_new_uninit_in(System)?;/// being filled with `0` bytes, in the provided allocator, returning an error if allocation/// let zero = Arc::<u32, _>::try_new_zeroed_in(System)?;/// Returns the inner value, if the `Arc` has exactly one strong reference./// Otherwise, an [`Err`] is returned with the same `Arc` that was/// It is strongly recommended to use [`Arc::into_inner`] instead if you don't/// keep the `Arc` in the [`Err`] case./// Immediately dropping the [`Err`]-value, as the expression/// `Arc::try_unwrap(this).ok()` does, can cause the strong count to/// drop to zero and the inner value of the `Arc` to be dropped./// For instance, if two threads execute such an expression in parallel,/// there is a race condition without the possibility of unsafety:/// The threads could first both check whether they own the last instance/// in `Arc::try_unwrap`, determine that they both do not, and then both/// discard and drop their instance in the call to [`ok`][`Result::ok`]./// In this scenario, the value inside the `Arc` is safely destroyed/// by exactly one of the threads, but neither thread will ever be able/// to use the value./// let x = Arc::new(3);/// assert_eq!(Arc::try_unwrap(x), Ok(3));/// let x = Arc::new(4);/// let _y = Arc::clone(&x);/// assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);/// Otherwise, [`None`] is returned and the `Arc` is dropped./// If `Arc::into_inner` is called on every clone of this `Arc`,/// [`Arc::try_unwrap`] is conceptually similar to `Arc::into_inner`, but it/// is meant for different use-cases. If used as a direct replacement/// for `Arc::into_inner` anyway, such as with the expression/// <code>[Arc::try_unwrap]\(this).[ok][Result::ok]()</code>, then it does/// **not** give the same guarantee as described in the previous paragraph./// For more information, see the examples below and read the documentation/// of [`Arc::try_unwrap`]./// Minimal example demonstrating the guarantee that `Arc::into_inner` gives./// let y = Arc::clone(&x);/// // Two threads calling `Arc::into_inner` on both clones of an `Arc`:/// let x_thread = std::thread::spawn(|| Arc::into_inner(x));/// let y_thread = std::thread::spawn(|| Arc::into_inner(y));/// let x_inner_value = x_thread.join().unwrap();/// let y_inner_value = y_thread.join().unwrap();/// // One of the threads is guaranteed to receive the inner value:///     (x_inner_value, y_inner_value),///     (None, Some(3)) | (Some(3), None)/// // The result could also be `(None, None)` if the threads called/// // `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead./// A more practical example demonstrating the need for `Arc::into_inner`:/// // Definition of a simple singly linked list using `Arc`:/// struct LinkedList<T>(Option<Arc<Node<T>>>);/// struct Node<T>(T, Option<Arc<Node<T>>>);/// // Dropping a long `LinkedList<T>` relying on the destructor of `Arc`/// // can cause a stack overflow. To prevent this, we can provide a/// // manual `Drop` implementation that does the destruction in a loop:/// impl<T> Drop for LinkedList<T> {///         let mut link = self.0.take();///         while let Some(arc_node) = link.take() {///             if let Some(Node(_value, next)) = Arc::into_inner(arc_node) {///                 link = next;/// // Implementation of `new` and `push` omitted/// impl<T> LinkedList<T> {/// #   fn new() -> Self {/// #       LinkedList(None)/// #   fn push(&mut self, x: T) {/// #       self.0 = Some(Arc::new(Node(x, self.0.take())));/// // The following code could have still caused a stack overflow/// // despite the manual `Drop` impl if that `Drop` impl had used/// // `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`./// // Create a long list and clone it/// let mut x = LinkedList::new();/// let size = 100000;/// # let size = if cfg!(miri) { 100 } else { size };/// for i in 0..size {///     x.push(i); // Adds i to the front of x/// // Drop the clones in parallel/// let x_thread = std::thread::spawn(|| drop(x));/// let y_thread = std::thread::spawn(|| drop(y));/// x_thread.join().unwrap();/// y_thread.join().unwrap();/// Constructs a new atomically reference-counted slice with uninitialized contents./// let mut values = Arc::<[u32]>::new_uninit_slice(3);/// let data = Arc::get_mut(&mut values).unwrap();/// Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being/// let values = Arc::<[u32]>::new_zeroed_slice(3);/// Constructs a new atomically reference-counted slice with uninitialized contents in the/// provided allocator./// let mut values = Arc::<[u32], _>::new_uninit_slice_in(3, System);///     Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);///     Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);///     Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);/// filled with `0` bytes, in the provided allocator./// let values = Arc::<[u32], _>::new_zeroed_slice_in(3, System);/// Converts to `Arc<T>`./// Constructs a new `Arc<T>` with a clone of `value`./// let hello: Arc<str> = Arc::clone_from_ref("hello");/// Constructs a new `Arc<T>` with a clone of `value`, returning an error if allocation fails/// let hello: Arc<str> = Arc::try_clone_from_ref("hello")?;/// Constructs a new `Arc<T>` with a clone of `value` in the provided allocator./// let hello: Arc<str, System> = Arc::clone_from_ref_in("hello", System);/// Constructs a new `Arc<T>` with a clone of `value` in the provided allocator, returning an error if allocation fails/// let hello: Arc<str, System> = Arc::try_clone_from_ref_in("hello", System)?;/// Converts to `Arc<[T]>`./// Constructs an `Arc<T>` from a raw pointer./// [`Arc<U>::into_raw`][into_raw] with the following requirements:///   alignment as `T`. This is trivially true if `Arc<U>` was constructed///   through `Arc<T>` and then converted to `Arc<U>` through an [unsized/// even if the returned `Arc<T>` is never accessed./// [into_raw]: Arc::into_raw/// let x = Arc::new("hello".to_owned());/// let x_ptr = Arc::into_raw(x);///     // Convert back to an `Arc` to prevent leak.///     let x = Arc::from_raw(x_ptr);///     // Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe./// let x: Arc<[u32]> = Arc::new([1, 2, 3]);/// let x_ptr: *const [u32] = Arc::into_raw(x);///     let x: Arc<[u32; 3]> = Arc::from_raw(x_ptr.cast::<[u32; 3]>());/// Consumes the `Arc`, returning the wrapped pointer./// To avoid a memory leak the pointer must be converted back to an `Arc` using/// [`Arc::from_raw`]./// # drop(unsafe { Arc::from_raw(x_ptr) });/// Increments the strong reference count on the `Arc<T>` associated with the/// The pointer must have been obtained through `Arc::into_raw` and must satisfy the/// same layout requirements specified in [`Arc::from_raw_in`][from_raw_in]./// The associated `Arc` instance must be valid (i.e. the strong count must be at/// [from_raw_in]: Arc::from_raw_in///     let ptr = Arc::into_raw(five);///     Arc::increment_strong_count(ptr);///     // This assertion is deterministic because we haven't shared///     // the `Arc` between threads.///     let five = Arc::from_raw(ptr);///     assert_eq!(2, Arc::strong_count(&five));/// #   Arc::decrement_strong_count(ptr);/// Decrements the strong reference count on the `Arc<T>` associated with the/// allocated by the global allocator. This method can be used to release the final/// `Arc` and backing storage, but **should not** be called after the final `Arc` has been///     // Those assertions are deterministic because we haven't shared///     Arc::decrement_strong_count(ptr);///     assert_eq!(1, Arc::strong_count(&five));/// to call it as `Arc::allocator(&a)` instead of `a.allocator()`. This/// Consumes the `Arc`, returning the wrapped pointer and allocator./// [`Arc::from_raw_in`]./// let x = Arc::new_in("hello".to_owned(), System);/// let (ptr, alloc) = Arc::into_raw_with_allocator(x);/// let x = unsafe { Arc::from_raw_in(ptr, alloc) };/// The counts are not affected in any way and the `Arc` is not consumed. The pointer is valid for/// as long as there are strong counts in the `Arc`./// let x_ptr = Arc::as_ptr(&x);/// assert_eq!(x_ptr, Arc::as_ptr(&y));/// Constructs an `Arc<T, A>` from a raw pointer./// The raw pointer must have been previously returned by a call to [`Arc<U,/// let (x_ptr, alloc) = Arc::into_raw_with_allocator(x);///     let x = Arc::from_raw_in(x_ptr, System);/// let x: Arc<[u32], _> = Arc::new_in([1, 2, 3], System);/// let x_ptr: *const [u32] = Arc::into_raw_with_allocator(x).0;///     let x: Arc<[u32; 3], _> = Arc::from_raw_in(x_ptr.cast::<[u32; 3]>(), System);"this returns a new `Weak` pointer, \
                  without modifying the original `Arc`"/// let weak_five = Arc::downgrade(&five);/// This method by itself is safe, but using it correctly requires extra care./// Another thread can change the weak count at any time,/// including potentially between calling this method and acting on the result./// let _weak_five = Arc::downgrade(&five);/// // This assertion is deterministic because we haven't shared/// // the `Arc` or `Weak` between threads./// assert_eq!(1, Arc::weak_count(&five));/// Gets the number of strong (`Arc`) pointers to this allocation./// Another thread can change the strong count at any time,/// let _also_five = Arc::clone(&five);/// // the `Arc` between threads./// assert_eq!(2, Arc::strong_count(&five));///     let (ptr, _alloc) = Arc::into_raw_with_allocator(five);///     Arc::increment_strong_count_in(ptr, System);///     let five = Arc::from_raw_in(ptr, System);/// #   Arc::decrement_strong_count_in(ptr, System);/// allocated by `alloc`. This method can be used to release the final///     Arc::decrement_strong_count_in(ptr, System);/// Returns `true` if the two `Arc`s point to the same allocation in a vein similar to/// let same_five = Arc::clone(&five);/// let other_five = Arc::new(5);/// assert!(Arc::ptr_eq(&five, &same_five));/// assert!(!Arc::ptr_eq(&five, &other_five));/// [`ptr::eq`]: core::ptr::eq "ptr::eq"/// Allocates an `ArcInner<T>` with sufficient space for/// The function `mem_to_arcinner` is called with the data pointer/// and must return back a (potentially fat)-pointer for the `ArcInner<T>`.initialize_arcinner/// Allocates an `ArcInner<T>` with sufficient space for an unsized inner value./// Allocates an `ArcInner<[T]>` with the given length./// Copy elements from slice into newly allocated `Arc<[T]>`/// Constructs an `Arc<[T]>` from an iterator known to be of a certain size.ArcFromSlice/// Makes a clone of the `Arc` pointer./// let _ = Arc::clone(&five);/// Makes a mutable reference into the given `Arc`./// If there are other `Arc` pointers to the same allocation, then `make_mut` will/// However, if there are no other `Arc` pointers to this allocation, but some [`Weak`]/// pointers, then the [`Weak`] pointers will be dissociated and the inner value will not/// or dissociating [`Weak`] pointers./// [`get_mut`]: Arc::get_mut/// let mut data = Arc::new(5);/// *Arc::make_mut(&mut data) += 1;         // Won't clone anything/// let mut other_data = Arc::clone(&data); // Won't clone inner data/// *Arc::make_mut(&mut data) += 1;         // Clones inner data/// *Arc::make_mut(&mut other_data) *= 2;   // Won't clone anything/// [`Weak`] pointers will be dissociated:/// let mut data = Arc::new(75);/// let weak = Arc::downgrade(&data);/// *Arc::make_mut(&mut data) += 1;/// Assuming `arc_t` is of type `Arc<T>`, this function is functionally equivalent to/// `(*arc_t).clone()`, but will avoid cloning the inner value where possible./// # use std::{ptr, sync::Arc};/// let arc = Arc::new(inner);/// let inner = Arc::unwrap_or_clone(arc);/// // `arc2` is the last reference, so when we unwrap it we get back/// let inner = Arc::unwrap_or_clone(arc2);/// Returns a mutable reference into the given `Arc`, if there are/// no other `Arc` or [`Weak`] pointers to the same allocation./// the inner value when there are other `Arc` pointers./// [make_mut]: Arc::make_mut/// let mut x = Arc::new(3);/// *Arc::get_mut(&mut x).unwrap() = 4;/// assert!(Arc::get_mut(&mut x).is_none());/// Returns a mutable reference into the given `Arc`,/// If any other `Arc` or [`Weak`] pointers to the same allocation exist, then/// inner type of this Arc (including lifetimes). This is trivially the case if no/// such pointers exist, for example immediately after `Arc::new`./// let mut x = Arc::new(String::new());///     Arc::get_mut_unchecked(&mut x).push_str("foo")/// Other `Arc` pointers to the same allocation must be to the same type./// let x: Arc<str> = Arc::from("Hello, world!");/// let mut y: Arc<[u8]> = x.clone().into();///     Arc::get_mut_unchecked(&mut y).fill(0xff); // 0xff is invalid in UTF-8/// Other `Arc` pointers to the same allocation must be to the exact same type, including lifetimes./// let x: Arc<&str> = Arc::new("Hello, world!");///     let mut y: Arc<&str> = x.clone();///         *Arc::get_mut_unchecked(&mut y) = &s;/// Determine whether this is the unique reference to the underlying data./// Returns `true` if there are no other `Arc` or [`Weak`] pointers to the same allocation;/// returns `false` otherwise./// If this function returns `true`, then is guaranteed to be safe to call [`get_mut_unchecked`]/// on this `Arc`, so long as no clones occur in between./// #![feature(arc_is_unique)]/// assert!(Arc::is_unique(&x));/// assert!(!Arc::is_unique(&x));/// drop(y);/// // Weak references also count, because they could be upgraded at any time./// let z = Arc::downgrade(&x);/// # Pointer invalidation/// This function will always return the same value as `Arc::get_mut(arc).is_some()`. However,/// unlike that operation it does not produce any mutable references to the underlying data,/// meaning no pointers to the data inside the `Arc` are invalidated by the call. Thus, the/// following code is valid, even though it would be UB if it used `Arc::get_mut`:/// let arc = Arc::new(5);/// let pointer: *const i32 = &*arc;/// assert!(Arc::is_unique(&arc));/// assert_eq!(unsafe { *pointer }, 5);/// # Atomic orderings/// Concurrent drops to other `Arc` pointers to the same allocation will synchronize with this/// call - that is, this call performs an `Acquire` operation on the underlying strong and weak/// ref counts. This ensures that calling `get_mut_unchecked` is safe./// Note that this operation requires locking the weak ref count, so concurrent calls to/// `downgrade` may spin-loop for a short period of time./// [`get_mut_unchecked`]: Self::get_mut_unchecked/// Drops the `Arc`./// let foo  = Arc::new(Foo);/// let foo2 = Arc::clone(&foo);/// Attempts to downcast the `Arc<dyn Any + Send + Sync>` to a concrete type./// fn print_if_string(value: Arc<dyn Any + Send + Sync>) {/// print_if_string(Arc::new(my_string));/// print_if_string(Arc::new(0i8));/// Downcasts the `Arc<dyn Any + Send + Sync>` to a concrete type./// let x: Arc<dyn Any + Send + Sync> = Arc::new(1_usize);/// use std::sync::Weak;/// Constructs a new `Weak<T, A>`, without allocating any memory, technically in the provided/// let empty: Weak<i64, _> = Weak::new_in(System);/// weak reference, and must point to a block of memory allocated by global allocator./// let strong = Arc::new("hello".to_owned());/// let raw_1 = Arc::downgrade(&strong).into_raw();/// let raw_2 = Arc::downgrade(&strong).into_raw();/// assert_eq!(2, Arc::weak_count(&strong));/// assert_eq!(1, Arc::weak_count(&strong));/// let weak = Arc::downgrade(&strong);/// assert_eq!(0, Arc::weak_count(&strong));/// [`null`]: core::ptr::null "ptr::null"/// let strong = Arc::new_in("hello".to_owned(), System);/// Converts a raw pointer previously created by [`into_raw`] back into `Weak<T>` in the provided/// weak reference, and must point to a block of memory allocated by `alloc`."this returns a new `Arc`, \
                  without modifying the original weak pointer"/// Attempts to upgrade the `Weak` pointer to an [`Arc`], delaying/// let strong_five: Option<Arc<_>> = weak_five.upgrade();/// Gets the number of strong (`Arc`) pointers pointing to this allocation./// Gets an approximation of the number of `Weak` pointers pointing to this/// If `self` was created using [`Weak::new`], or if there are no remaining/// strong pointers, this will return 0./// # Accuracy/// Due to implementation details, the returned value can be off by 1 in/// either direction when other threads are manipulating any `Arc`s or/// `Weak`s pointing to the same allocation./// Returns `None` when the pointer is dangling and there is no allocated `ArcInner`,/// let first_rc = Arc::new(5);/// let first = Arc::downgrade(&first_rc);/// let second = Arc::downgrade(&first_rc);/// let third_rc = Arc::new(5);/// let third = Arc::downgrade(&third_rc);/// let third_rc = Arc::new(());/// let weak_five = Arc::downgrade(&Arc::new(5));/// Constructs a new `Weak<T>`, without allocating memory./// Calling [`upgrade`] on the return value always/// gives [`None`]./// let foo = Arc::new(Foo);/// let weak_foo = Arc::downgrade(&foo);ArcEqIdent/// would otherwise add a cost to all equality checks on refs. We assume that `Arc`s are used to/// cost to pay off more easily. It's also more likely to have two `Arc` clones, that point to/// Equality for two `Arc`s./// Two `Arc`s are equal if their inner values are equal, even if they are/// two `Arc`s that point to the same allocation are always equal./// assert!(five == Arc::new(5));/// Inequality for two `Arc`s./// Two `Arc`s are not equal if their inner values are not equal./// two `Arc`s that point to the same value are always equal./// assert!(five != Arc::new(6));/// Partial comparison for two `Arc`s./// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));/// Less-than comparison for two `Arc`s./// assert!(five < Arc::new(6));/// 'Less than or equal to' comparison for two `Arc`s./// assert!(five <= Arc::new(5));/// Greater-than comparison for two `Arc`s./// assert!(five > Arc::new(4));/// 'Greater than or equal to' comparison for two `Arc`s./// assert!(five >= Arc::new(5));/// Comparison for two `Arc`s./// assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));/// Creates a new `Arc<T>`, with the `Default` value for `T`./// let x: Arc<i32> = Default::default();SliceArcInnerForStatic/// Struct to hold the static `ArcInner` used for empty `Arc<str/CStr/[T]>` as/// returned by `Default::default`./// Layout notes:/// * `repr(align(16))` so we can use it for `[T]` with `align_of::<T>() <= 16`./// * `repr(C)` so `inner` is at offset 0 (and thus guaranteed to actually be aligned to 16)./// * `[u8; 1]` (to be initialized with 0) so it can be used for `Arc<CStr>`.MAX_STATIC_INNER_SLICE_ALIGNMENTSTATIC_INNER_SLICE/// Creates an empty str inside an Arc/// This may or may not share an allocation with other Arcs./// Creates an empty CStr inside an Arc/// Creates an empty `[T]` inside an Arc/// Converts a `T` into an `Arc<T>`/// The conversion moves the value into a/// newly allocated `Arc`. It is equivalent to/// calling `Arc::new(t)`./// assert_eq!(Arc::from(x), arc);/// Converts a [`[T; N]`](prim@array) into an `Arc<[T]>`./// The conversion moves the array into a newly allocated `Arc`./// let shared: Arc<[i32]> = Arc::from(original);/// Allocates a reference-counted `str` and copies `v` into it./// let shared: Arc<str> = Arc::from("eggplant");/// let mut original = String::from("eggplant");/// let shared: Arc<str> = Arc::from(original);/// let unique: String = "eggplant".to_owned();/// let shared: Arc<str> = Arc::from(unique);/// Move a boxed object to a new, reference-counted allocation./// let unique: Box<str> = Box::from("eggplant");/// let shared: Arc<[i32]> = Arc::from(unique);/// Creates an atomically reference-counted pointer from a clone-on-write/// pointer by copying its content./// let shared: Arc<str> = Arc::from(cow);/// Converts an atomically reference-counted string slice into a byte slice./// let string: Arc<str> = Arc::from("eggplant");/// let bytes: Arc<[u8]> = Arc::from(string);/// Takes each element in the `Iterator` and collects it into an `Arc<[T]>`./// In the general case, collecting into `Arc<[T]>` is done by first/// let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect();/// let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0)///     .into(); // A second allocation for `Arc<[T]>` happens here./// and then it will allocate once for turning the `Vec<T>` into the `Arc<[T]>`./// a single allocation will be made for the `Arc<[T]>`. For example:/// let evens: Arc<[u8]> = (0..10).collect(); // Just a single allocation happens here.to_arc_sliceToArcSlice/// Specialization trait used for collecting into `Arc<[T]>`./// Gets the offset within an `ArcInner` for the payload behind a pointer.UniqueArcUninit/// A unique owning pointer to an [`ArcInner`] **that does not imply the contents are initialized,**/// This is a helper for [`Arc::make_mut()`] to ensure correct cleanup on panic./// Allocates an ArcInner with layout suitable to contain `for_value` or a clone of it./// Allocates an ArcInner with layout suitable to contain `for_value` or a clone of it,/// Returns the pointer to be written into to initialize the [`Arc`]./// Upgrade this into a normal [`Arc`].// Define the ownership of `ArcInner<T>` for drop-checkUniqueArc/// A uniquely owned [`Arc`]./// This represents an `Arc` that is known to be uniquely owned -- that is, have exactly one strong/// references will fail unless the `UniqueArc` they point to has been converted into a regular `Arc`./// Because it is uniquely owned, the contents of a `UniqueArc` can be freely mutated. A common/// immutable and converted to a normal `Arc`./// use std::sync::{Arc, Weak, UniqueArc};/// fn create_gadget() -> Option<Arc<Gadget>> {///     let mut rc = UniqueArc::new(Gadget {///     rc.me = UniqueArc::downgrade(&rc);///     Some(UniqueArc::into_arc(rc))/// An advantage of using `UniqueArc` over [`Arc::new_cyclic`] to build cyclic data structures is that/// [`Arc::new_cyclic`]'s `data_fn` parameter cannot be async or return a [`Result`]. As shown in the/// previous example, `UniqueArc` allows for more flexibility in the construction of cyclic data,// #[unstable(feature = "coerce_unsized", issue = "18598")]/// Equality for two `UniqueArc`s./// Two `UniqueArc`s are equal if their inner values are equal./// use std::sync::UniqueArc;/// let five = UniqueArc::new(5);/// assert!(five == UniqueArc::new(5));/// Partial comparison for two `UniqueArc`s./// assert_eq!(Some(Ordering::Less), five.partial_cmp(&UniqueArc::new(6)));/// Less-than comparison for two `UniqueArc`s./// assert!(five < UniqueArc::new(6));/// 'Less than or equal to' comparison for two `UniqueArc`s./// assert!(five <= UniqueArc::new(5));/// Greater-than comparison for two `UniqueArc`s./// assert!(five > UniqueArc::new(4));/// 'Greater than or equal to' comparison for two `UniqueArc`s./// assert!(five >= UniqueArc::new(5));/// Comparison for two `UniqueArc`s./// assert_eq!(Ordering::Less, five.cmp(&UniqueArc::new(6)));/// Creates a new `UniqueArc`./// Weak references to this `UniqueArc` can be created with [`UniqueArc::downgrade`]. Upgrading/// these weak references will fail before the `UniqueArc` has been converted into an [`Arc`]./// After converting the `UniqueArc` into an [`Arc`], any weak references created beforehand will/// point to the new [`Arc`]./// Maps the value in a `UniqueArc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `UniqueArc`, and the result is returned,/// also in a `UniqueArc`./// to call it as `UniqueArc::map(u, f)` instead of `u.map(f)`. This/// let r = UniqueArc::new(7);/// let new = UniqueArc::map(r, |i| i + 7);/// Attempts to map the value in a `UniqueArc`, reusing the allocation if possible./// `f` is called on a reference to the value in the `UniqueArc`, and if the operation succeeds,/// the result is returned, also in a `UniqueArc`./// to call it as `UniqueArc::try_map(u, f)` instead of `u.try_map(f)`. This/// let b = UniqueArc::new(7);/// let new = UniqueArc::try_map(b, u32::try_from).unwrap();/// Creates a new `UniqueArc` in the provided allocator.// #[unstable(feature = "allocator_api", issue = "32838")]/// Converts the `UniqueArc` into a regular [`Arc`]./// This consumes the `UniqueArc` and returns a regular [`Arc`] that contains the `value` that/// is passed to `into_arc`./// Creates a new weak reference to the `UniqueArc`./// Attempting to upgrade this weak reference will fail before the `UniqueArc` has been converted/// to a [`Arc`] using [`UniqueArc::into_arc`].// #[unstable(feature = "unique_rc_arc", issue = "112566")]// #[unstable(feature = "deref_pure_trait", issue = "87121")]//! Thread-safe reference-counting pointers.//! See the [`Arc<T>`][Arc] documentation for more details.//! **Note**: This module is only available on platforms that support atomic//! loads and stores of pointers. This may be detected at compile time using//! `#[cfg(target_has_atomic = "ptr")]`.LocalWaker/// Wake this task./// Wake this task without consuming the waker./// If an executor supports a cheaper way to wake without consuming the/// waker, it should override this method. By default, it clones the/// [`Arc`] and calls [`wake`] on the clone./// [`wake`]: Wake::wake/// The implementation of waking a task on an executor./// This trait can be used to create a [`Waker`]. An executor can define an/// implementation of this trait, and use that to construct a [`Waker`] to pass/// to the tasks that are executed on that executor./// This trait is a memory-safe and ergonomic alternative to constructing a/// [`RawWaker`]. It supports the common executor design in which the data used/// to wake up a task is stored in an [`Arc`]. Some executors (especially/// those for embedded systems) cannot use this API, which is why [`RawWaker`]/// exists as an alternative for those systems./// To construct a [`Waker`] from some type `W` implementing this trait,/// wrap it in an [`Arc<W>`](Arc) and call `Waker::from()` on that./// It is also possible to convert to [`RawWaker`] in the same way./// <!-- Ideally we'd link to the `From` impl, but rustdoc doesn't generate any page for it within///      `alloc` because `alloc` neither defines nor re-exports `From` or `Waker`, and we can't///      link ../../std/task/struct.Waker.html#impl-From%3CArc%3CW,+Global%3E%3E-for-Waker///      without getting a link-checking error in CI. -->/// A basic `block_on` function that takes a future and runs it to completion on/// the current thread./// **Note:** This example trades correctness for simplicity. In order to prevent/// deadlocks, production-grade implementations will also need to handle/// intermediate calls to `thread::unpark` as well as nested invocations./// use std::task::{Context, Poll, Wake};/// use std::thread::{self, Thread};/// use core::pin::pin;/// /// A waker that wakes up the current thread when called./// struct ThreadWaker(Thread);/// impl Wake for ThreadWaker {///     fn wake(self: Arc<Self>) {///         self.0.unpark();/// /// Run a future to completion on the current thread./// fn block_on<T>(fut: impl Future<Output = T>) -> T {///     // Pin the future so it can be polled.///     let mut fut = pin!(fut);///     // Create a new context to be passed to the future.///     let t = thread::current();///     let waker = Arc::new(ThreadWaker(t)).into();///     let mut cx = Context::from_waker(&waker);///     // Run the future to completion.///         match fut.as_mut().poll(&mut cx) {///             Poll::Ready(res) => return res,///             Poll::Pending => thread::park(),///     println!("Hi from inside a future!");/// Use a [`Wake`]-able type as a `Waker`./// No heap allocations or atomic operations are used for this conversion./// Use a `Wake`-able type as a `RawWaker`.// NB: This private function for constructing a RawWaker is used, rather than// inlining this into the `From<Arc<W>> for RawWaker` impl, to ensure that// the safety of `From<Arc<W>> for Waker` does not depend on the correct// trait dispatch - instead both impls call this function directly and// explicitly./// Wake this task without consuming the local waker./// [`Rc`] and calls [`wake`] on the clone./// [`wake`]: LocalWaker::wakeLocalWake/// An analogous trait to `Wake` but used to construct a `LocalWaker`./// This API works in exactly the same way as `Wake`,/// except that it uses an `Rc` instead of an `Arc`,/// and the result is a `LocalWaker` instead of a `Waker`./// The benefits of using `LocalWaker` over `Waker` are that it allows the local waker/// to hold data that does not implement `Send` and `Sync`. Additionally, it saves calls/// to `Arc::clone`, which requires atomic synchronization./// This is a simplified example of a `spawn` and a `block_on` function. The `spawn` function/// is used to push new tasks onto the run queue, while the block on function will remove them/// and poll them. When a task is woken, it will put itself back on the run queue to be polled/// by the executor./// **Note:** This example trades correctness for simplicity. A real world example would interleave/// poll calls with calls to an io reactor to wait for events instead of spinning on a loop./// #![feature(local_waker)]/// use std::task::{LocalWake, ContextBuilder, LocalWaker, Waker};///     // A queue containing all tasks ready to do progress///     static RUN_QUEUE: RefCell<VecDeque<Rc<Task>>> = RefCell::default();/// type BoxedFuture = Pin<Box<dyn Future<Output = ()>>>;/// struct Task(RefCell<BoxedFuture>);/// impl LocalWake for Task {///     fn wake(self: Rc<Self>) {///         RUN_QUEUE.with_borrow_mut(|queue| {///             queue.push_back(self)/// fn spawn<F>(future: F)///     F: Future<Output=()> + 'static + Send + Sync///     let task = RefCell::new(Box::pin(future));///     RUN_QUEUE.with_borrow_mut(|queue| {///         queue.push_back(Rc::new(Task(task)));/// fn block_on<F>(future: F)///     F: Future<Output=()> + 'static + Sync + Send///     spawn(future);///         let Some(task) = RUN_QUEUE.with_borrow_mut(|queue| queue.pop_front()) else {///             // we exit, since there are no more tasks remaining on the queue///         // cast the Rc<Task> into a `LocalWaker`///         let local_waker: LocalWaker = task.clone().into();///         // Build the context using `ContextBuilder`///         let mut cx = ContextBuilder::from_waker(Waker::noop())///             .local_waker(&local_waker)///             .build();///         // Poll the task///         let _ = task.0///             .borrow_mut()///             .as_mut()///             .poll(&mut cx);///     println!("hello world");/// Use a `Wake`-able type as a `LocalWaker`.local_raw_waker// inlining this into the `From<Rc<W>> for RawWaker` impl, to ensure that// the safety of `From<Rc<W>> for Waker` does not depend on the correct//! Types and Traits for working with asynchronous tasks.//! **Note**: Some of the types in this module are only available//! on platforms that support atomic loads and stores of pointers.//! This may be detected at compile time using/// Creates a [`Borrowed`] variant of [`Cow`]/// from a slice./// This conversion does not allocate or clone the data./// [`Borrowed`]: crate::borrow::Cow::Borrowed/// from a reference to an array./// Creates an [`Owned`] variant of [`Cow`]/// from an owned instance of [`Vec`]./// [`Owned`]: crate::borrow::Cow::Owned/// from a reference to [`Vec`]./// A draining iterator for `Vec<T>`./// This `struct` is created by [`Vec::drain`]./// let mut v = vec![0, 1, 2];/// let iter: std::vec::Drain<'_, _> = v.drain(..);/// let mut vec = vec!['a', 'b', 'c'];/// let mut drain = vec.drain(..);/// assert_eq!(drain.as_slice(), &['a', 'b', 'c']);/// assert_eq!(drain.as_slice(), &['b', 'c']);keep_rest/// Keep unyielded elements in the source `Vec`./// #![feature(drain_keep_rest)]/// assert_eq!(drain.next().unwrap(), 'a');/// // This call keeps 'b' and 'c' in the vec./// drain.keep_rest();/// // If we wouldn't call `keep_rest()`,/// // `vec` would be empty./// assert_eq!(vec, ['b', 'c']);/// This struct is created by [`Vec::extract_if`]./// let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(.., |x| *x % 2 == 0);InPlaceDropInPlaceDstDataSrcBufDropSpecFromIterNestedDESTin_place_collectibleneeds_reallocrustc_specialization_traitInPlaceCollect/// This provides a shorthand for the source type since local type aliases aren't a thing.from_iter_in_placewrite_in_place_with_dropcollect_in_place/// Collects an iterator (`self`) into the destination buffer (`dst`) and returns the number of items/// collected. `end` is the last writable element of the allocation and used for bounds checks./// This method is specialized and one of its implementations makes use of/// `Iterator::__iterator_get_unchecked` calls with a `TrustedRandomAccessNoCoerce` bound/// on `I` which means the caller of this method must take the safety conditions/// of that trait into consideration.SpecInPlaceCollect/// Helper trait to hold specialized implementations of the in-place iterate-collect loop/// Internal helper trait for in-place iteration specialization./// Currently this is only implemented by [`vec::IntoIter`] - returning a reference to itself - and/// [`binary_heap::IntoIter`] which returns a reference to its inner representation./// Since this is an internal trait it hides the implementation detail `binary_heap::IntoIter`/// uses `vec::IntoIter` internally./// [`vec::IntoIter`]: super::IntoIter/// [`binary_heap::IntoIter`]: crate::collections::binary_heap::IntoIter/// In-place iteration relies on implementation details of `vec::IntoIter`, most importantly that/// it does not create references to the whole allocation during iteration, only raw pointers//! Inplace iterate-and-collect specialization for `Vec`//! Note: This documents Vec internals, some of the following sections explain implementation//! details and are best read together with the source of this module.//! The specialization in this module applies to iterators in the shape of//! `source.adapter().adapter().adapter().collect::<Vec<U>>()`//! where `source` is an owning iterator obtained from [`Vec<T>`], [`Box<[T]>`][box] (by conversion to `Vec`)//! or [`BinaryHeap<T>`], the adapters guarantee to consume enough items per step to make room//! for the results (represented by [`InPlaceIterable`]), provide transitive access to `source`//! (via [`SourceIter`]) and thus the underlying allocation.//! And finally there are alignment and size constraints to consider, this is currently ensured via//! const eval instead of trait bounds in the specialized [`SpecFromIter`] implementation.//! [`BinaryHeap<T>`]: crate::collections::BinaryHeap//! [box]: crate::boxed::Box//! By extension some other collections which use `collect::<Vec<_>>()` internally in their//! `FromIterator` implementation benefit from this too.//! Access to the underlying source goes through a further layer of indirection via the private//! trait [`AsVecIntoIter`] to hide the implementation detail that other collections may use//! `vec::IntoIter` internally.//! In-place iteration depends on the interaction of several unsafe traits, implementation//! details of multiple parts in the iterator pipeline and often requires holistic reasoning//! across multiple structs since iterators are executed cooperatively rather than having//! a central evaluator/visitor struct executing all iterator components.//! # Reading from and writing to the same allocation//! By its nature collecting in place means that the reader and writer side of the iterator//! use the same allocation. Since `try_fold()` (used in [`SpecInPlaceCollect`]) takes a//! reference to the iterator for the duration of the iteration that means we can't interleave//! the step of reading a value and getting a reference to write to. Instead raw pointers must be//! used on the reader and writer side.//! That writes never clobber a yet-to-be-read items is ensured by the [`InPlaceIterable`] requirements.//! # Layout constraints//! When recycling an allocation between different types we must uphold the [`Allocator`] contract//! which means that the input and output Layouts have to "fit".//! To complicate things further `InPlaceIterable` supports splitting or merging items into smaller///! larger ones to enable (de)aggregation of arrays.//! Ultimately each step of the iterator must free up enough *bytes* in the source to make room//! for the next output item.//! If `T` and `U` have the same size no fixup is needed.//! If `T`'s size is a multiple of `U`'s we can compensate by multiplying the capacity accordingly.//! Otherwise the input capacity (and thus layout) in bytes may not be representable by the output//! `Vec<U>`. In that case `alloc.shrink()` is used to update the allocation's layout.//! Alignments of `T` must be the same or larger than `U`. Since alignments are always a power//! of two _larger_ implies _is a multiple of_.//! See `in_place_collectible()` for the current conditions.//! Additionally this specialization doesn't make sense for ZSTs as there is no reallocation to//! avoid and it would make pointer arithmetic more difficult.//! [`Allocator`]: core::alloc::Allocator//! # Drop- and panic-safety//! Iteration can panic, requiring dropping the already written parts but also the remainder of//! the source. Iteration can also leave some source items unconsumed which must be dropped.//! All those drops in turn can panic which then must either leak the allocation or abort to avoid//! double-drops.//! This is handled by the [`InPlaceDrop`] guard for sink items (`U`) and by//! [`vec::IntoIter::forget_allocation_drop_remaining()`] for remaining source items (`T`).//! If dropping any remaining source item (`T`) panics then [`InPlaceDstDataSrcBufDrop`] will handle dropping//! the already collected sink items (`U`) and freeing the allocation.//! [`vec::IntoIter::forget_allocation_drop_remaining()`]: super::IntoIter::forget_allocation_drop_remaining()//! # O(1) collect//! The main iteration itself is further specialized when the iterator implements//! [`TrustedRandomAccessNoCoerce`] to let the optimizer see that it is a counted loop with a single//! [induction variable]. This can turn some iterators into a noop, i.e. it reduces them from O(n) to//! O(1). This particular optimization is quite fickle and doesn't always work, see [#79308]//! [#79308]: https://github.com/rust-lang/rust/issues/79308//! [induction variable]: https://en.wikipedia.org/wiki/Induction_variable//! Since unchecked accesses through that trait do not advance the read pointer of `IntoIter`//! this would interact unsoundly with the requirements about dropping the tail described above.//! But since the normal `Drop` implementation of `IntoIter` would suffer from the same problem it//! is only correct for `TrustedRandomAccessNoCoerce` to be implemented when the items don't//! have a destructor. Thus that implicit requirement also makes the specialization safe to use for//! in-place collection.//! Note that this safety concern is about the correctness of `impl Drop for IntoIter`,//! not the guarantees of `InPlaceIterable`.//! # Adapter implementations//! The invariants for adapters are documented in [`SourceIter`] and [`InPlaceIterable`], but//! getting them right can be rather subtle for multiple, sometimes non-local reasons.//! For example `InPlaceIterable` would be valid to implement for [`Peekable`], except//! that it is stateful, cloneable and `IntoIter`'s clone implementation shortens the underlying//! allocation which means if the iterator has been peeked and then gets cloned there no longer is//! enough room, thus breaking an invariant ([#85322]).//! [#85322]: https://github.com/rust-lang/rust/issues/85322//! [`Peekable`]: core::iter::Peekable//! Some cases that are optimized by this specialization, more can be found in the `Vec`//! benchmarks://! /// Converts a usize vec into an isize one.//! pub fn cast(vec: Vec<usize>) -> Vec<isize> {//!   // Does not allocate, free or panic. On optlevel>=2 it does not loop.//!   // Of course this particular case could and should be written with `into_raw_parts` and//!   // `from_raw_parts` instead.//!   vec.into_iter().map(|u| u as isize).collect()//! /// Drops remaining items in `src` and if the layouts of `T` and `U` match it//! /// returns an empty Vec backed by the original allocation. Otherwise it returns a new//! /// empty vec.//! pub fn recycle_allocation<T, U>(src: Vec<T>) -> Vec<U> {//!   src.into_iter().filter_map(|_| None).collect()//! let vec = vec![13usize; 1024];//! let _ = vec.into_iter()//!   .enumerate()//!   .filter_map(|(idx, val)| if idx % 2 == 0 { Some(val+idx) } else {None})//!   .collect::<Vec<_>>();//! // is equivalent to the following, but doesn't require bounds checks//! let mut vec = vec![13usize; 1024];//! let mut write_idx = 0;//! for idx in 0..vec.len() {//!    if idx % 2 == 0 {//!       vec[write_idx] = vec[idx] + idx;//!       write_idx += 1;//! vec.truncate(write_idx);// A helper struct for in-place iteration that drops the destination slice of iteration,// i.e. the head. The source slice (the tail) is dropped by IntoIter.src_cap// A helper struct for in-place collection that drops the destination items together with// the source allocation - i.e. before the reallocation happened - to avoid leaking them// if some other destructor panics.// the drop impl reconstructs a RawVec from buf, cap and alloc// to avoid dropping the allocator twice we need to wrap it into ManuallyDrop/// If T is a ZST, this is actually ptr+len. This encoding is picked so that/// ptr == end is a quick test for the Iterator being empty, that works/// for both ZST and non-ZST./// For non-ZSTs the pointer is treated as `NonNull<T>`/// An iterator that moves out of a vector./// This `struct` is created by the `into_iter` method on [`Vec`](super::Vec)/// (provided by the [`IntoIterator`] trait)./// let v = vec![0, 1, 2];/// let iter: std::vec::IntoIter<_> = v.into_iter();// Manually mirroring what `Vec` has,// because otherwise we get `T: RefUnwindSafe` from `NonNull`./// let vec = vec!['a', 'b', 'c'];/// let mut into_iter = vec.into_iter();/// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);/// let _ = into_iter.next().unwrap();/// assert_eq!(into_iter.as_slice(), &['b', 'c']);/// into_iter.as_mut_slice()[2] = 'z';/// assert_eq!(into_iter.next().unwrap(), 'a');/// assert_eq!(into_iter.next().unwrap(), 'b');/// assert_eq!(into_iter.next().unwrap(), 'z');forget_allocation_drop_remaining/// Drops remaining elements and relinquishes the backing allocation./// This method guarantees it won't panic before relinquishing the backing/// This is roughly equivalent to the following, but more efficient/// # let mut vec = Vec::<u8>::with_capacity(10);/// # let ptr = vec.as_mut_ptr();/// # let mut into_iter = vec.into_iter();/// let mut into_iter = std::mem::replace(&mut into_iter, Vec::new().into_iter());/// (&mut into_iter).for_each(drop);/// std::mem::forget(into_iter);/// # drop(unsafe { Vec::<u8>::from_raw_parts(ptr, 0, 10) });/// This method is used by in-place iteration, refer to the vec::in_place_collect/// documentation for an overview.forget_remaining_elements/// Forgets to Drop the remaining elements while still allowing the backing allocation to be freed./// Creates an empty `vec::IntoIter`./// # use std::vec;/// let iter: vec::IntoIter<u8> = Default::default();/// assert_eq!(iter.as_slice(), &[]);NonDrop// T: Copy as approximation for !Drop since get_unchecked does not advance self.ptr// and thus we can't implement drop-handling// TrustedRandomAccess (without NoCoerce) must not be implemented because// subtypes/supertypes of `T` might not be `NonDrop`/// Whether this value's representation is all zeros,/// or can be represented with all zeroes.IsZeroimpl_is_zero// It is needed to impl for arrays and tuples of i8.// It is needed to impl for arrays and tuples of u8.impl_is_zero_tuples// Stopper// This is recursive macro.impl_is_zero_option_of_nonzero_int// `Option<NonZero<u32>>` and similar have a representation guarantee that// they're the same size as the corresponding `u32` type, as well as a guarantee// that transmuting between `NonZero<u32>` and `Option<NonZero<u32>>` works.// While the documentation officially makes it UB to transmute from `None`,// we're the standard library so we can make extra inferences, and we know that// the only niche available to represent `None` is the one that's all zeros.impl_is_zero_option_of_intimpl_is_zero_option_of_bool// It is needed to impl for arrays and tuples of ().// `IsZero` cannot be soundly implemented for pointers because of provenance// (see #135338).// `Option<&T>` and `Option<Box<T>>` are guaranteed to represent `None` as null.// For fat pointers, the bytes that would be the pointer metadata in the `Some`// variant are padding in the `None` variant, so ignoring them and// zero-initializing instead is ok.// `Option<&mut T>` never implements `Clone`, so there's no need for an impl of// `SpecFromElem`.Assumeub_checksin_place_collectspec_from_elemSpecFromElemset_len_on_dropin_place_dropspec_from_iter_nested"Vec"/// A contiguous growable array type, written as `Vec<T>`, short for 'vector'./// vec.push(2);/// assert_eq!(vec.len(), 2);/// assert_eq!(vec[0], 1);/// assert_eq!(vec.pop(), Some(2));/// assert_eq!(vec.len(), 1);/// vec[0] = 7;/// assert_eq!(vec[0], 7);/// vec.extend([1, 2, 3]);/// for x in &vec {/// assert_eq!(vec, [7, 1, 2, 3]);/// The [`vec!`] macro is provided for convenient initialization:/// let mut vec1 = vec![1, 2, 3];/// vec1.push(4);/// let vec2 = Vec::from([1, 2, 3, 4]);/// assert_eq!(vec1, vec2);/// It can also initialize each element of a `Vec<T>` with a given value./// This may be more efficient than performing allocation and initialization/// in separate steps, especially when initializing a vector of zeros:/// let vec = vec![0; 5];/// assert_eq!(vec, [0, 0, 0, 0, 0]);/// // The following is equivalent, but potentially slower:/// let mut vec = Vec::with_capacity(5);/// vec.resize(5, 0);/// [Capacity and Reallocation](#capacity-and-reallocation)./// Use a `Vec<T>` as an efficient stack:/// let mut stack = Vec::new();/// stack.push(1);/// stack.push(2);/// stack.push(3);/// while let Some(top) = stack.pop() {///     // Prints 3, 2, 1///     println!("{top}");/// The `Vec` type allows access to values by index, because it implements the/// [`Index`] trait. An example will be more explicit:/// let v = vec![0, 2, 4, 6];/// println!("{}", v[1]); // it will display '2'/// However be careful: if you try to access an index which isn't in the `Vec`,/// your software will panic! You cannot do this:/// println!("{}", v[6]); // it will panic!/// Use [`get`] and [`get_mut`] if you want to check whether the index is in/// the `Vec`./// # Slicing/// A `Vec` can be mutable. On the other hand, slices are read-only objects./// To get a [slice][prim@slice], use [`&`]. Example:/// fn read_slice(slice: &[usize]) {/// let v = vec![0, 1];/// read_slice(&v);/// // ... and that's all!/// // you can also do it like this:/// let u: &[usize] = &v;/// // or like this:/// let u: &[_] = &v;/// In Rust, it's more common to pass slices as arguments rather than vectors/// when you just want to provide read access. The same goes for [`String`] and/// [`&str`]./// # Capacity and reallocation/// The capacity of a vector is the amount of space allocated for any future/// elements that will be added onto the vector. This is not to be confused with/// the *length* of a vector, which specifies the number of actual elements/// within the vector. If a vector's length exceeds its capacity, its capacity/// will automatically be increased, but its elements will have to be/// reallocated./// For example, a vector with capacity 10 and length 0 would be an empty vector/// with space for 10 more elements. Pushing 10 or fewer elements onto the/// vector will not change its capacity or cause reallocation to occur. However,/// if the vector's length is increased to 11, it will have to reallocate, which/// can be slow. For this reason, it is recommended to use [`Vec::with_capacity`]/// whenever possible to specify how big the vector is expected to get./// Due to its incredibly fundamental nature, `Vec` makes a lot of guarantees/// about its design. This ensures that it's as low-overhead as possible in/// the general case, and can be correctly manipulated in primitive ways/// by unsafe code. Note that these guarantees refer to an unqualified `Vec<T>`./// If additional type parameters are added (e.g., to support custom allocators),/// overriding their defaults may change the behavior./// Most fundamentally, `Vec` is and always will be a (pointer, capacity, length)/// triplet. No more, no less. The order of these fields is completely/// unspecified, and you should use the appropriate methods to modify these./// The pointer will never be null, so this type is null-pointer-optimized./// However, the pointer might not actually point to allocated memory. In particular,/// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],/// [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`]/// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized/// types inside a `Vec`, it will not allocate space for them. *Note that in this case/// the `Vec` might not report a [`capacity`] of 0*. `Vec` will allocate if and only/// if <code>[size_of::\<T>]\() * [capacity]\() > 0</code>. In general, `Vec`'s allocation/// details are very subtle --- if you intend to allocate memory using a `Vec`/// and use it for something else (either to pass to unsafe code, or to build your/// own memory-backed collection), be sure to deallocate this memory by using/// `from_raw_parts` to recover the `Vec` and then dropping it./// If a `Vec` *has* allocated memory, then the memory it points to is on the heap/// (as defined by the allocator Rust is configured to use by default), and its/// pointer points to [`len`] initialized, contiguous elements in order (what/// you would see if you coerced it to a slice), followed by <code>[capacity] - [len]</code>/// logically uninitialized, contiguous elements./// A vector containing the elements `'a'` and `'b'` with capacity 4 can be/// visualized as below. The top part is the `Vec` struct, it contains a/// pointer to the head of the allocation in the heap, length and capacity./// The bottom part is the allocation on the heap, a contiguous memory block.///             ptr      len  capacity///        +--------+--------+--------+///        | 0x0123 |      2 |      4 |///             |///             v/// Heap   +--------+--------+--------+--------+///        |    'a' |    'b' | uninit | uninit |///        +--------+--------+--------+--------+/// - **uninit** represents memory that is not initialized, see [`MaybeUninit`]./// - Note: the ABI is not stable and `Vec` makes no guarantees about its memory///   layout (including the order of fields)./// `Vec` will never perform a "small optimization" where elements are actually/// stored on the stack for two reasons:/// * It would make it more difficult for unsafe code to correctly manipulate///   a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were///   only moved, and it would be more difficult to determine if a `Vec` had///   actually allocated memory./// * It would penalize the general case, incurring an additional branch///   on every access./// `Vec` will never automatically shrink itself, even if completely empty. This/// ensures no unnecessary allocations or deallocations occur. Emptying a `Vec`/// and then filling it back up to the same [`len`] should incur no calls to/// the allocator. If you wish to free up unused memory, use/// [`shrink_to_fit`] or [`shrink_to`]./// [`push`] and [`insert`] will never (re)allocate if the reported capacity is/// sufficient. [`push`] and [`insert`] *will* (re)allocate if/// <code>[len] == [capacity]</code>. That is, the reported capacity is completely/// accurate, and can be relied on. It can even be used to manually free the memory/// allocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even/// when not necessary./// `Vec` does not guarantee any particular growth strategy when reallocating/// when full, nor when [`reserve`] is called. The current strategy is basic/// and it may prove desirable to use a non-constant growth factor. Whatever/// strategy is used will of course guarantee *O*(1) amortized [`push`]./// It is guaranteed, in order to respect the intentions of the programmer, that/// all of `vec![e_1, e_2, ..., e_n]`, `vec![x; n]`, and [`Vec::with_capacity(n)`] produce a `Vec`/// that requests an allocation of the exact size needed for precisely `n` elements from the allocator,/// and no other size (such as, for example: a size rounded up to the nearest power of 2)./// The allocator will return an allocation that is at least as large as requested, but it may be larger./// It is guaranteed that the [`Vec::capacity`] method returns a value that is at least the requested capacity/// and not more than the allocated capacity./// The method [`Vec::shrink_to_fit`] will attempt to discard excess capacity an allocator has given to a `Vec`./// If <code>[len] == [capacity]</code>, then a `Vec<T>` can be converted/// to and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements./// `Vec` exploits this fact as much as reasonable when implementing common conversions/// such as [`into_boxed_slice`]./// `Vec` will not specifically overwrite any data that is removed from it,/// but also won't specifically preserve it. Its uninitialized memory is/// scratch space that it may use however it wants. It will generally just do/// whatever is most efficient or otherwise easy to implement. Do not rely on/// removed data to be erased for security purposes. Even if you drop a `Vec`, its/// buffer may simply be reused by another allocation. Even if you zero a `Vec`'s memory/// first, that might not actually happen because the optimizer does not consider/// this a side-effect that must be preserved. There is one case which we will/// not break, however: using `unsafe` code to write to the excess capacity,/// and then increasing the length to match, is always valid./// Currently, `Vec` does not guarantee the order in which elements are dropped./// The order has changed in the past and may change again./// [`get`]: slice::get/// [`get_mut`]: slice::get_mut/// [`String`]: crate::string::String/// [`&str`]: type@str/// [`shrink_to_fit`]: Vec::shrink_to_fit/// [`shrink_to`]: Vec::shrink_to/// [capacity]: Vec::capacity/// [`capacity`]: Vec::capacity/// [`Vec::capacity`]: Vec::capacity/// [size_of::\<T>]: size_of/// [len]: Vec::len/// [`len`]: Vec::len/// [`push`]: Vec::push/// [`insert`]: Vec::insert/// [`reserve`]: Vec::reserve/// [`Vec::with_capacity(n)`]: Vec::with_capacity/// [`MaybeUninit`]: core::mem::MaybeUninit/// [owned slice]: Box/// [`into_boxed_slice`]: Vec::into_boxed_slice"vec_new"/// Constructs a new, empty `Vec<T>`./// The vector will not allocate until elements are pushed onto it."vec_with_capacity"/// Constructs a new, empty `Vec<T>` with at least the specified capacity./// The vector will be able to hold at least `capacity` elements without/// `capacity`. If `capacity` is zero, the vector will not allocate./// It is important to note that although the returned vector has the/// minimum *capacity* specified, the vector will have a zero *length*. For/// an explanation of the difference between length and capacity, see/// *[Capacity and reallocation]*./// If it is important to know the exact allocated capacity of a `Vec`,/// always use the [`capacity`] method after construction./// For `Vec<T>` where `T` is a zero-sized type, there will be no allocation/// and the capacity will always be `usize::MAX`./// [Capacity and reallocation]: #capacity-and-reallocation/// let mut vec = Vec::with_capacity(10);/// // The vector contains no items, even though it has capacity for more/// assert_eq!(vec.len(), 0);/// assert!(vec.capacity() >= 10);///     vec.push(i);/// // ...but this may make the vector reallocate/// vec.push(11);/// assert_eq!(vec.len(), 11);/// assert!(vec.capacity() >= 11);/// // A vector of a zero-sized type will always over-allocate, since no/// // allocation is necessary/// let vec_units = Vec::<()>::with_capacity(10);/// assert_eq!(vec_units.capacity(), usize::MAX);/// Creates a `Vec<T>` directly from a pointer, a length, and a capacity./// * If `T` is not a zero-sized type and the capacity is nonzero, `ptr` must have///   been allocated using the global allocator, such as via the [`alloc::alloc`]///   function. If `T` is a zero-sized type or the capacity is zero, `ptr` need///   only be non-null and aligned./// * `T` needs to have the same alignment as what `ptr` was allocated with,///   if the pointer is required to be allocated.///   (`T` having a less strict alignment is not sufficient, the alignment really///   needs to be equal to satisfy the [`dealloc`] requirement that memory must be///   allocated and deallocated with the same layout.)/// * The size of `T` times the `capacity` (ie. the allocated size in bytes), if///   nonzero, needs to be the same size as the pointer was allocated with.///   (Because similar to alignment, [`dealloc`] must be called with the same///   layout `size`.)/// * The first `length` values must be properly initialized values of type `T`./// * `capacity` needs to be the capacity that the pointer was allocated with,/// * The allocated size in bytes must be no larger than `isize::MAX`.///   See the safety documentation of [`pointer::offset`]./// These requirements are always upheld by any `ptr` that has been allocated/// via `Vec<T>`. Other allocation sources are allowed if the invariants are/// upheld./// internal data structures. For example it is normally **not** safe/// to build a `Vec<u8>` from a pointer to a C `char` array with length/// `size_t`, doing so is only safe if the array was initially allocated by/// a `Vec` or `String`./// It's also not safe to build one from a `Vec<u16>` and its length, because/// the allocator cares about the alignment, and these two types have different/// alignments. The buffer was allocated with alignment 2 (for `u16`), but after/// turning it into a `Vec<u8>` it'll be deallocated with alignment 1. To avoid/// these issues, it is often preferable to do casting/transmuting using/// [`slice::from_raw_parts`] instead./// `Vec<T>` which may then deallocate, reallocate or change the/// [`alloc::alloc`]: crate::alloc::alloc/// [`dealloc`]: crate::alloc::GlobalAlloc::dealloc/// // Deconstruct the vector into parts./// let (p, len, cap) = v.into_raw_parts();///     // Overwrite memory with 4, 5, 6///     for i in 0..len {///         ptr::write(p.add(i), 4 + i);///     // Put everything back together into a Vec///     let rebuilt = Vec::from_raw_parts(p, len, cap);///     assert_eq!(rebuilt, [4, 5, 6]);/// Using memory that was allocated elsewhere:///     let layout = Layout::array::<u32>(16).expect("overflow cannot happen");///     let vec = unsafe {///         let mem = alloc(layout).cast::<u32>();///         if mem.is_null() {///         mem.write(1_000_000);///         Vec::from_raw_parts(mem, 1, 16)///     assert_eq!(vec, &[1_000_000]);///     assert_eq!(vec.capacity(), 16);/// Creates a `Vec<T>` directly from a `NonNull` pointer, a length, and a capacity./// * `ptr` must have been allocated using the global allocator, such as via///   the [`alloc::alloc`] function./// * `T` needs to have the same alignment as what `ptr` was allocated with./// * The size of `T` times the `capacity` (ie. the allocated size in bytes) needs///   to be the same size as the pointer was allocated with. (Because similar to///   alignment, [`dealloc`] must be called with the same layout `size`.)/// * `capacity` needs to be the capacity that the pointer was allocated with./// [`NonNull::slice_from_raw_parts`] instead./// let (p, len, cap) = v.into_parts();///         p.add(i).write(4 + i);///     let rebuilt = Vec::from_parts(p, len, cap);///         let Some(mem) = NonNull::new(alloc(layout).cast::<u32>()) else {///         Vec::from_parts(mem, 1, 16)/// Decomposes a `Vec<T>` into its raw components: `(pointer, length, capacity)`./// the vector (in elements), and the allocated capacity of the/// data (in elements). These are the same arguments in the same/// order as the arguments to [`from_raw_parts`]./// memory previously managed by the `Vec`. Most often, one does/// this by converting the raw pointer, length, and capacity back/// into a `Vec` with the [`from_raw_parts`] function; more generally,/// if `T` is non-zero-sized and the capacity is nonzero, one may use/// any method that calls [`dealloc`] with a layout of/// `Layout::array::<T>(capacity)`; if `T` is zero-sized or the/// capacity is zero, nothing needs to be done./// [`from_raw_parts`]: Vec::from_raw_parts/// let v: Vec<i32> = vec![-1, 0, 1];/// let (ptr, len, cap) = v.into_raw_parts();/// let rebuilt = unsafe {///     // We can now make changes to the components, such as///     // transmuting the raw pointer to a compatible type.///     let ptr = ptr as *mut u32;///     Vec::from_raw_parts(ptr, len, cap)/// assert_eq!(rebuilt, [4294967295, 0, 1]);/// Decomposes a `Vec<T>` into its raw components: `(NonNull pointer, length, capacity)`./// Returns the `NonNull` pointer to the underlying data, the length of/// order as the arguments to [`from_parts`]./// memory previously managed by the `Vec`. The only way to do/// this is to convert the `NonNull` pointer, length, and capacity back/// into a `Vec` with the [`from_parts`] function, allowing/// [`from_parts`]: Vec::from_parts/// let (ptr, len, cap) = v.into_parts();///     let ptr = ptr.cast::<u32>();///     Vec::from_parts(ptr, len, cap)/// Constructs a new, empty `Vec<T, A>`./// # #[allow(unused_mut)]/// let mut vec: Vec<i32, _> = Vec::new_in(System);/// Constructs a new, empty `Vec<T, A>` with at least the specified capacity/// with the provided allocator./// For `Vec<T, A>` where `T` is a zero-sized type, there will be no allocation/// let mut vec = Vec::with_capacity_in(10, System);/// let vec_units = Vec::<(), System>::with_capacity_in(10, System);// #[unstable(feature = "try_with_capacity", issue = "91913")]/// Creates a `Vec<T, A>` directly from a pointer, a length, a capacity,/// and an allocator./// * `ptr` must be [*currently allocated*] via the given allocator `alloc`./// * `capacity` needs to [*fit*] the layout size that the pointer was allocated with./// via `Vec<T, A>`. Other allocation sources are allowed if the invariants are/// internal data structures. For example it is **not** safe/// to build a `Vec<u8>` from a pointer to a C `char` array with length `size_t`./// turning it into a `Vec<u8>` it'll be deallocated with alignment 1./// [*currently allocated*]: crate::alloc::Allocator#currently-allocated-memory/// [*fit*]: crate::alloc::Allocator#memory-fitting/// let mut v = Vec::with_capacity_in(3, System);/// v.push(1);/// v.push(2);/// v.push(3);/// let (p, len, cap, alloc) = v.into_raw_parts_with_alloc();///     let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());/// use std::alloc::{AllocError, Allocator, Global, Layout};///         let mem = match Global.allocate(layout) {///             Ok(mem) => mem.cast::<u32>().as_ptr(),///             Err(AllocError) => return,///         Vec::from_raw_parts_in(mem, 1, 16, Global)from_parts_in/// Creates a `Vec<T, A>` directly from a `NonNull` pointer, a length, a capacity,/// let (p, len, cap, alloc) = v.into_parts_with_alloc();///     let rebuilt = Vec::from_parts_in(p, len, cap, alloc.clone());///             Ok(mem) => mem.cast::<u32>(),///         Vec::from_parts_in(mem, 1, 16, Global)// #[unstable(feature = "box_vec_non_null", issue = "130364")]into_raw_parts_with_alloc/// Decomposes a `Vec<T>` into its raw components: `(pointer, length, capacity, allocator)`./// Returns the raw pointer to the underlying data, the length of the vector (in elements),/// the allocated capacity of the data (in elements), and the allocator. These are the same/// arguments in the same order as the arguments to [`from_raw_parts_in`]./// into a `Vec` with the [`from_raw_parts_in`] function, allowing/// [`from_raw_parts_in`]: Vec::from_raw_parts_in/// let mut v: Vec<i32, System> = Vec::new_in(System);/// v.push(-1);/// v.push(0);/// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();///     Vec::from_raw_parts_in(ptr, len, cap, alloc)into_parts_with_alloc/// Decomposes a `Vec<T>` into its raw components: `(NonNull pointer, length, capacity, allocator)`./// Returns the `NonNull` pointer to the underlying data, the length of the vector (in elements),/// arguments in the same order as the arguments to [`from_parts_in`]./// into a `Vec` with the [`from_parts_in`] function, allowing/// [`from_parts_in`]: Vec::from_parts_in/// let (ptr, len, cap, alloc) = v.into_parts_with_alloc();///     Vec::from_parts_in(ptr, len, cap, alloc)/// Returns the total number of elements the vector can hold without/// let mut vec: Vec<i32> = Vec::with_capacity(10);/// vec.push(42);/// A vector with zero-sized elements will always have a capacity of usize::MAX:/// struct ZeroSized;///     assert_eq!(std::mem::size_of::<ZeroSized>(), 0);///     let v = vec![ZeroSized; 0];///     assert_eq!(v.capacity(), usize::MAX);"vec_reserve"/// in the given `Vec<T>`. The collection may reserve more space to/// speculatively avoid frequent reallocations. After calling `reserve`,/// let mut vec = vec![1];/// vec.reserve(10);/// Reserves the minimum capacity for at least `additional` more elements to/// be inserted in the given `Vec<T>`. Unlike [`reserve`], this will not/// minimal. Prefer [`reserve`] if future insertions are expected./// vec.reserve_exact(10);/// in the given `Vec<T>`. The collection may reserve more space to speculatively avoid/// fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {/// Tries to reserve the minimum capacity for at least `additional`/// elements to be inserted in the given `Vec<T>`. Unlike [`try_reserve`],/// this will not deliberately over-allocate to speculatively avoid frequent/// allocations. After calling `try_reserve_exact`, capacity will be greater/// than or equal to `self.len() + additional` if it returns `Ok(())`./// [`try_reserve`]: Vec::try_reserve/// Shrinks the capacity of the vector as much as possible./// The behavior of this method depends on the allocator, which may either shrink the vector/// in-place or reallocate. The resulting vector might still have some excess capacity, just as/// is the case for [`with_capacity`]. See [`Allocator::shrink`] for more details./// [`with_capacity`]: Vec::with_capacity/// vec.shrink_to_fit();/// assert!(vec.capacity() >= 3);/// Shrinks the capacity of the vector with a lower bound./// vec.shrink_to(4);/// assert!(vec.capacity() >= 4);/// vec.shrink_to(0);/// Converts the vector into [`Box<[T]>`][owned slice]./// let slice = v.into_boxed_slice();/// Any excess capacity is removed:/// let slice = vec.into_boxed_slice();/// assert_eq!(slice.into_vec().capacity(), 3);/// If `len` is greater or equal to the vector's current length, this has/// The [`drain`] method can emulate `truncate`, but causes the excess/// elements to be returned instead of dropped./// of the vector./// Truncating a five element vector to two elements:/// let mut vec = vec![1, 2, 3, 4, 5];/// vec.truncate(2);/// assert_eq!(vec, [1, 2]);/// No truncation occurs when `len` is greater than the vector's current/// let mut vec = vec![1, 2, 3];/// vec.truncate(8);/// Truncating when `len == 0` is equivalent to calling the [`clear`]/// vec.truncate(0);/// assert_eq!(vec, []);/// [`clear`]: Vec::clear/// [`drain`]: Vec::drain"vec_as_slice"/// io::sink().write(buffer.as_slice()).unwrap();"vec_as_mut_slice"/// let mut buffer = vec![0; 3];/// io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();/// Returns a raw pointer to the vector's buffer, or a dangling raw pointer/// valid for zero sized reads if the vector didn't allocate./// The caller must ensure that the vector outlives the pointer this/// Modifying the vector may cause its buffer to be reallocated,/// which would also make any pointers to it invalid./// derived from it. If you need to mutate the contents of the slice, use [`as_mut_ptr`]./// does not materialize a reference to the underlying slice, and thus the returned pointer/// will remain valid when mixed with other calls to [`as_ptr`], [`as_mut_ptr`],/// and [`as_non_null`]./// Note that calling other methods that materialize mutable references to the slice,/// or mutable references to specific elements you are planning on accessing through this pointer,/// as well as writing to those elements, may still invalidate this pointer./// See the second example below for how this guarantee can be used./// let x = vec![1, 2, 4];/// let x_ptr = x.as_ptr();///     for i in 0..x.len() {///         assert_eq!(*x_ptr.add(i), 1 << i);///     let mut v = vec![0, 1, 2];///     let ptr1 = v.as_ptr();///     let _ = ptr1.read();///     let ptr2 = v.as_mut_ptr().offset(2);///     // Notably, the write to `ptr2` did *not* invalidate `ptr1`///     // because it mutated a different element:/// [`as_mut_ptr`]: Vec::as_mut_ptr/// [`as_ptr`]: Vec::as_ptr/// [`as_non_null`]: Vec::as_non_null/// Returns a raw mutable pointer to the vector's buffer, or a dangling/// raw pointer valid for zero sized reads if the vector didn't allocate./// Note that calling other methods that materialize references to the slice,/// or references to specific elements you are planning on accessing through this pointer,/// The method also guarantees that, as long as `T` is not zero-sized and the capacity is/// nonzero, the pointer may be passed into [`dealloc`] with a layout of/// `Layout::array::<T>(capacity)` in order to deallocate the backing memory. If this is done,/// be careful not to run the destructor of the `Vec`, as dropping it will result in/// double-frees. Wrapping the `Vec` in a [`ManuallyDrop`] is the typical way to achieve this./// // Allocate vector big enough for 4 elements./// let size = 4;/// let mut x: Vec<i32> = Vec::with_capacity(size);/// let x_ptr = x.as_mut_ptr();/// // Initialize elements via raw pointer writes, then set length.///     for i in 0..size {///         *x_ptr.add(i) = i as i32;///     x.set_len(size);/// assert_eq!(&*x, &[0, 1, 2, 3]);///     let mut v = vec![0];///     let ptr1 = v.as_mut_ptr();///     let ptr2 = v.as_mut_ptr();/// Deallocating a vector using [`Box`] (which uses [`dealloc`] internally):/// use std::mem::{ManuallyDrop, MaybeUninit};/// let mut v = ManuallyDrop::new(vec![0, 1, 2]);/// let ptr = v.as_mut_ptr();/// let capacity = v.capacity();/// let slice_ptr: *mut [MaybeUninit<i32>] =///     std::ptr::slice_from_raw_parts_mut(ptr.cast(), capacity);/// drop(unsafe { Box::from_raw(slice_ptr) });/// [`ManuallyDrop`]: core::mem::ManuallyDrop/// Returns a `NonNull` pointer to the vector's buffer, or a dangling/// `NonNull` pointer valid for zero sized reads if the vector didn't allocate./// let x_ptr = x.as_non_null();///         x_ptr.add(i).write(i as i32);///     let ptr1 = v.as_non_null();///     let ptr2 = v.as_non_null();/// Forces the length of the vector to `new_len`./// This is a low-level operation that maintains none of the normal/// invariants of the type. Normally changing the length of a vector/// is done using one of the safe operations instead, such as/// [`truncate`], [`resize`], [`extend`], or [`clear`]./// [`truncate`]: Vec::truncate/// [`resize`]: Vec::resize/// [`extend`]: Extend::extend/// - `new_len` must be less than or equal to [`capacity()`]./// - The elements at `old_len..new_len` must be initialized./// [`capacity()`]: Vec::capacity/// See [`spare_capacity_mut()`] for an example with safe/// initialization of capacity elements and use of this method./// `set_len()` can be useful for situations in which the vector/// is serving as a buffer for other code, particularly over FFI:/// # // This is just a minimal skeleton for the doc example;/// # // don't use this as a starting point for a real library./// # pub struct StreamWrapper { strm: *mut std::ffi::c_void }/// # const Z_OK: i32 = 0;/// # unsafe extern "C" {/// #     fn deflateGetDictionary(/// #         strm: *mut std::ffi::c_void,/// #         dictionary: *mut u8,/// #         dictLength: *mut usize,/// #     ) -> i32;/// # impl StreamWrapper {/// pub fn get_dictionary(&self) -> Option<Vec<u8>> {///     // Per the FFI method's docs, "32768 bytes is always enough".///     let mut dict = Vec::with_capacity(32_768);///     let mut dict_length = 0;///     // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:///     // 1. `dict_length` elements were initialized.///     // 2. `dict_length` <= the capacity (32_768)///     // which makes `set_len` safe to call.///         // Make the FFI call...///         let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);///         if r == Z_OK {///             // ...and update the length to what was initialized.///             dict.set_len(dict_length);///             Some(dict)/// While the following example is sound, there is a memory leak since/// the inner vectors were not freed prior to the `set_len` call:/// let mut vec = vec![vec![1, 0, 0],///                    vec![0, 1, 0],///                    vec![0, 0, 1]];/// // SAFETY:/// // 1. `old_len..0` is empty so no elements need to be initialized./// // 2. `0 <= capacity` always holds whatever `capacity` is.///     vec.set_len(0);/// #   // FIXME(https://github.com/rust-lang/miri/issues/3670):/// #   // use -Zmiri-disable-leak-check instead of unleaking in tests meant to leak./// #   vec.set_len(3);/// Normally, here, one would use [`clear`] instead to correctly drop/// the contents and thus not leak memory./// [`spare_capacity_mut()`]: Vec::spare_capacity_mut/// Removes an element from the vector and returns it./// The removed element is replaced by the last element of the vector./// This does not preserve ordering of the remaining elements, but is *O*(1)./// If you need to preserve the element order, use [`remove`] instead./// [`remove`]: Vec::remove/// let mut v = vec!["foo", "bar", "baz", "qux"];/// assert_eq!(v.swap_remove(1), "bar");/// assert_eq!(v, ["foo", "qux", "baz"]);/// assert_eq!(v.swap_remove(0), "foo");/// assert_eq!(v, ["baz", "qux"]);/// Inserts an element at position `index` within the vector, shifting all/// elements after it to the right./// vec.insert(1, 'd');/// assert_eq!(vec, ['a', 'd', 'b', 'c']);/// vec.insert(4, 'e');/// assert_eq!(vec, ['a', 'd', 'b', 'c', 'e']);/// Takes *O*([`Vec::len`]) time. All items after the insertion index must be/// shifted to the right. In the worst case, all elements are shifted when/// the insertion index is 0."if you don't need a reference to the value, use `Vec::insert` instead"/// elements after it to the right, and returning a reference to the new/// let mut vec = vec![1, 3, 5, 9];/// let x = vec.insert_mut(3, 6);/// assert_eq!(vec, [1, 3, 5, 7, 9]);/// Removes and returns the element at position `index` within the vector,/// shifting all elements after it to the left./// Note: Because this shifts over the remaining elements, it has a/// worst-case performance of *O*(*n*). If you don't need the order of elements/// to be preserved, use [`swap_remove`] instead. If you'd like to remove/// elements from the beginning of the `Vec`, consider using/// [`VecDeque::pop_front`] instead./// [`swap_remove`]: Vec::swap_remove/// [`VecDeque::pop_front`]: crate::collections::VecDeque::pop_front/// let mut v = vec!['a', 'b', 'c'];/// assert_eq!(v.remove(1), 'b');/// assert_eq!(v, ['a', 'c']);/// Remove and return the element at position `index` within the vector,/// shifting all elements after it to the left, or [`None`] if it does not/// worst-case performance of *O*(*n*). If you'd like to remove/// #![feature(vec_try_remove)]/// assert_eq!(v.try_remove(0), Some(1));/// assert_eq!(v.try_remove(2), None);/// let mut vec = vec![1, 2, 3, 4];/// vec.retain(|&x| x % 2 == 0);/// assert_eq!(vec, [2, 4]);/// vec.retain(|_| *iter.next().unwrap());/// assert_eq!(vec, [2, 3, 5]);/// Retains only the elements specified by the predicate, passing a mutable reference to it./// In other words, remove all elements `e` such that `f(&mut e)` returns `false`./// vec.retain_mut(|x| if *x <= 3 {/// assert_eq!(vec, [2, 3, 4]);/// Removes all but the first of consecutive elements in the vector that resolve to the same/// If the vector is sorted, this removes all duplicates./// let mut vec = vec![10, 20, 21, 30, 20];/// vec.dedup_by_key(|i| *i / 10);/// assert_eq!(vec, [10, 20, 30, 20]);/// Removes all but the first of consecutive elements in the vector satisfying a given equality/// relation./// The `same_bucket` function is passed references to two elements from the vector and/// must determine if the elements compare equal. The elements are passed in opposite order/// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is removed./// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];/// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));/// assert_eq!(vec, ["foo", "bar", "baz", "bar"]);/// Appends an element to the back of a collection./// let mut vec = vec![1, 2];/// vec.push(3);/// Takes amortized *O*(1) time. If the vector's length would exceed its/// capacity after the push, *O*(*capacity*) time is taken to copy the/// vector's elements to a larger allocation. This expensive operation is/// offset by the *capacity* *O*(1) insertions it allows.push_within_capacity/// Appends an element and returns a reference to it if there is sufficient spare capacity,/// otherwise an error is returned with the element./// Unlike [`push`] this method will not reallocate when there's insufficient capacity./// The caller should use [`reserve`] or [`try_reserve`] to ensure that there is enough capacity./// A manual, panic-free alternative to [`FromIterator`]:/// #![feature(vec_push_within_capacity)]/// fn from_iter_fallible<T>(iter: impl Iterator<Item=T>) -> Result<Vec<T>, TryReserveError> {///     let mut vec = Vec::new();///     for value in iter {///         if let Err(value) = vec.push_within_capacity(value) {///             vec.try_reserve(1)?;///             // this cannot fail, the previous line either returned or added at least 1 free slot///             let _ = vec.push_within_capacity(value);///     Ok(vec)/// assert_eq!(from_iter_fallible(0..100), Ok(Vec::from_iter(0..100)));/// Takes *O*(1) time.// #[unstable(feature = "push_mut", issue = "135974")]"if you don't need a reference to the value, use `Vec::push` instead"push_mut/// Appends an element to the back of a collection, returning a reference to it./// let last = vec.push_mut(3);/// assert_eq!(*last, 3);/// *last += 1;"vec_pop"/// Removes the last element from a vector and returns it, or [`None`] if it/// If you'd like to pop the first element, consider using/// assert_eq!(vec.pop(), Some(3));pop_if/// Removes and returns the last element from a vector if the predicate/// returns `true`, or [`None`] if the predicate returns false or the vector/// assert_eq!(vec.pop_if(pred), Some(4));/// assert_eq!(vec.pop_if(pred), None);/// Returns a mutable reference to the last item in the vector, or/// #![feature(vec_peek_mut)]/// assert!(vec.peek_mut().is_none());/// vec.push(5);/// assert_eq!(vec.last(), Some(&2));/// if let Some(mut val) = vec.peek_mut() {/// assert_eq!(vec.last(), Some(&0));/// let mut vec2 = vec![4, 5, 6];/// vec.append(&mut vec2);/// assert_eq!(vec, [1, 2, 3, 4, 5, 6]);/// assert_eq!(vec2, []);append_elements/// Appends elements to `self` from other buffer./// Removes the subslice indicated by the given range from the vector,/// returning a double-ended iterator over the removed subslice./// If the iterator is dropped before being fully consumed,/// it drops the remaining removed elements./// The returned iterator keeps a mutable borrow on the vector to optimize/// bounded on either end and past the length of the vector./// [`mem::forget`], for example), the vector may have lost and leaked/// let u: Vec<_> = v.drain(1..).collect();/// assert_eq!(v, &[1]);/// assert_eq!(u, &[2, 3]);/// // A full range clears the vector, like `clear()` does/// v.drain(..);/// assert_eq!(v, &[]);/// Clears the vector, removing all values./// Returns the number of elements in the vector, also referred to/// as its 'length'./// let a = vec![1, 2, 3];"vec_is_empty"/// Returns `true` if the vector contains no elements./// Returns a newly allocated vector containing the elements in the range/// `[at, len)`. After the call, the original vector will be left containing/// - If you want to take ownership of the entire contents and capacity of///   the vector, see [`mem::take`] or [`mem::replace`]./// - If you don't need the returned vector at all, see [`Vec::truncate`]./// - If you want to take ownership of an arbitrary subslice, or you don't///   necessarily want to store the removed items in a vector, see [`Vec::drain`]./// let vec2 = vec.split_off(1);/// assert_eq!(vec, ['a']);/// assert_eq!(vec2, ['b', 'c']);/// Resizes the `Vec` in-place so that `len` is equal to `new_len`./// If `new_len` is greater than `len`, the `Vec` is extended by the/// difference, with each additional slot filled with the result of/// calling the closure `f`. The return values from `f` will end up/// in the `Vec` in the order they have been generated./// If `new_len` is less than `len`, the `Vec` is simply truncated./// This method uses a closure to create new values on every push. If/// you'd rather [`Clone`] a given value, use [`Vec::resize`]. If you/// want to use the [`Default`] trait to generate values, you can/// pass [`Default::default`] as the second argument./// assert_eq!(vec, [1, 2, 3, 0, 0]);/// assert_eq!(vec, [2, 4, 8, 16]);/// Consumes and leaks the `Vec`, returning a mutable reference to the contents,/// `&'a mut [T]`./// As of Rust 1.57, this method does not reallocate or shrink the `Vec`,/// so the leaked allocation may include unused capacity that is not part/// of the returned slice./// leak./// let static_ref: &'static mut [usize] = x.leak();/// static_ref[0] += 1;/// assert_eq!(static_ref, &[2, 2, 3]);/// Returns the remaining spare capacity of the vector as a slice of/// `MaybeUninit<T>`./// The returned slice can be used to fill the vector with data (e.g. by/// [`set_len`]: Vec::set_len/// // Allocate vector big enough for 10 elements./// let mut v = Vec::with_capacity(10);/// let uninit = v.spare_capacity_mut();/// // Mark the first 3 elements of the vector as being initialized.///     v.set_len(3);/// assert_eq!(&v, &[0, 1, 2]);split_at_spare_mut/// Returns vector content as a slice of `T`, along with the remaining spare/// capacity of the vector as a slice of `MaybeUninit<T>`./// The returned spare capacity slice can be used to fill the vector with data/// (e.g. by reading from a file) before marking the data as initialized using/// the [`set_len`] method./// Note that this is a low-level API, which should be used with care for/// optimization purposes. If you need to append data to a `Vec`/// you can use [`push`], [`extend`], [`extend_from_slice`],/// [`extend_from_within`], [`insert`], [`append`], [`resize`] or/// [`resize_with`], depending on your exact needs./// [`extend`]: Vec::extend/// [`extend_from_slice`]: Vec::extend_from_slice/// [`extend_from_within`]: Vec::extend_from_within/// [`append`]: Vec::append/// [`resize_with`]: Vec::resize_with/// #![feature(vec_split_at_spare)]/// let mut v = vec![1, 1, 2];/// // Reserve additional space big enough for 10 elements./// v.reserve(10);/// let (init, uninit) = v.split_at_spare_mut();/// let sum = init.iter().copied().sum::<u32>();/// // Fill in the next 4 elements./// uninit[0].write(sum);/// uninit[1].write(sum * 2);/// uninit[2].write(sum * 3);/// uninit[3].write(sum * 4);/// // Mark the 4 elements of the vector as being initialized.///     v.set_len(len + 4);/// assert_eq!(&v, &[1, 1, 2, 4, 8, 12, 16]);split_at_spare_mut_with_len/// Safety: changing returned .2 (&mut usize) is considered the same as calling `.set_len(_)`./// This method provides unique access to all vec parts at once in `extend_from_within`./// Groups every `N` elements in the `Vec<T>` into chunks to produce a `Vec<[T; N]>`, dropping/// elements in the remainder. `N` must be greater than zero./// If the capacity is not a multiple of the chunk size, the buffer will shrink down to the/// nearest multiple with a reallocation or deallocation./// This function can be used to reverse [`Vec::into_flattened`]./// #![feature(vec_into_chunks)]/// let vec = vec![0, 1, 2, 3, 4, 5, 6, 7];/// assert_eq!(vec.into_chunks::<3>(), [[0, 1, 2], [3, 4, 5]]);/// let vec = vec![0, 1, 2, 3];/// let chunks: Vec<[u8; 10]> = vec.into_chunks();/// assert!(chunks.is_empty());/// let flat = vec![0; 8 * 8 * 8];/// let reshaped: Vec<[[[u8; 8]; 8]; 8]> = flat.into_chunks().into_chunks().into_chunks();/// assert_eq!(reshaped.len(), 1);recycleRecyclable/// This clears out this `Vec` and recycles the allocation into a new `Vec`./// The item type of the resulting `Vec` needs to have the same size and/// alignment as the item type of the original `Vec`.///  ```/// #![feature(vec_recycle, transmutability)]/// let a: Vec<u8> = vec![0; 100];/// let capacity = a.capacity();/// let addr = a.as_ptr().addr();/// let b: Vec<i8> = a.recycle();/// assert_eq!(b.capacity(), capacity);/// assert_eq!(b.as_ptr().addr(), addr);/// The `Recyclable` bound prevents this method from being called when `T` and `U` have different sizes; e.g.:///  ```compile_fail,E0277/// let vec: Vec<[u8; 2]> = Vec::new();/// let _: Vec<[u8; 1]> = vec.recycle();/// ...or different alignments:/// let vec: Vec<[u16; 0]> = Vec::new();/// let _: Vec<[u8; 0]> = vec.recycle();/// However, due to temporary implementation limitations of `Recyclable`,/// this method is not yet callable when `T` or `U` are slices, trait objects,/// or other exotic types; e.g.:/// # let inputs = ["a b c", "d e f"];/// # fn process(_: &[&str]) {}/// let mut storage: Vec<&[&str]> = Vec::new();/// for input in inputs {///     let mut buffer: Vec<&str> = storage.recycle();///     buffer.extend(input.split(" "));///     process(&buffer);///     storage = buffer.recycle();/// Denotes that an allocation of `From` can be recycled into an allocation of `Self`./// `Self` is `Recyclable<From>` if `Layout::new::<Self>() == Layout::new::<From>()`.unstable_feature_boundSAFETY// SAFETY: enforced by `TransmuteFrom`/// difference, with each additional slot filled with `value`./// This method requires `T` to implement [`Clone`],/// in order to be able to clone the passed value./// If you need more flexibility (or want to rely on [`Default`] instead of/// [`Clone`]), use [`Vec::resize_with`]./// If you only need to resize to a smaller size, use [`Vec::truncate`]./// let mut vec = vec!["hello"];/// vec.resize(3, "world");/// assert_eq!(vec, ["hello", "world", "world"]);/// let mut vec = vec!['a', 'b', 'c', 'd'];/// vec.resize(2, '_');/// assert_eq!(vec, ['a', 'b']);/// Clones and appends all elements in a slice to the `Vec`./// Iterates over the slice `other`, clones each element, and then appends/// it to this `Vec`. The `other` slice is traversed in-order./// Note that this function is the same as [`extend`],/// except that it also works with slice elements that are Clone but not Copy./// If Rust gets specialization this function may be deprecated./// vec.extend_from_slice(&[2, 3, 4]);/// Given a range `src`, clones a slice of elements in that range and appends it to the end./// `src` must be a range that can form a valid subslice of the `Vec`./// Panics if starting index is greater than the end index, if the index is/// greater than the length of the vector, or if the new capacity exceeds/// `isize::MAX` _bytes_./// let mut characters = vec!['a', 'b', 'c', 'd', 'e'];/// let mut numbers = vec![0, 1, 2, 3, 4];/// let mut strings = vec![String::from("hello"), String::from("world"), String::from("!")];into_flattened/// Takes a `Vec<[T; N]>` and flattens it into a `Vec<T>`./// Panics if the length of the resulting vector would overflow a `usize`./// This is only possible when flattening a vector of arrays of zero-sized/// types, and thus tends to be irrelevant in practice. If/// `size_of::<T>() > 0`, this will never panic./// let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];/// assert_eq!(vec.pop(), Some([7, 8, 9]));/// let mut flattened = vec.into_flattened();/// assert_eq!(flattened.pop(), Some(6));extend_with/// Extend the vector by `n` clones of value./// Removes consecutive repeated elements in the vector according to the/// [`PartialEq`] trait implementation./// let mut vec = vec![1, 2, 2, 3, 2];/// vec.dedup();/// assert_eq!(vec, [1, 2, 3, 2]);"vec_from_elem"from_elem_in/// - `src` needs to be valid index/// - `self.capacity() - self.len()` must be `>= src.len()`ExtendFromWithinSpec/// as it avoids reallocation if possible. Additionally, if the element type/// `T` overrides `clone_from()`, this will reuse the resources of `self`'s/// elements as well./// let x = vec![5, 6, 7];/// let mut y = vec![8, 9, 10];/// let yp: *const i32 = y.as_ptr();/// // And no reallocation occurred/// assert_eq!(yp, y.as_ptr());/// The hash of a vector is the same as that of the corresponding slice,/// as required by the `core::borrow::Borrow` implementation./// let b = std::hash::RandomState::new();/// let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];/// let s: &[u8] = &[0xa8, 0x3c, 0x09];/// assert_eq!(b.hash_one(v), b.hash_one(s));/// Collects an iterator into a Vec, commonly called via [`Iterator::collect()`]/// # Allocation behavior/// In general `Vec` does not guarantee any particular growth or allocation strategy./// That also applies to this trait impl./// **Note:** This section covers implementation details and is therefore exempt from/// Vec may use any or none of the following strategies,/// depending on the supplied iterator:/// * preallocate based on [`Iterator::size_hint()`]///   * and panic if the number of items is outside the provided lower/upper bounds/// * use an amortized growth strategy similar to `pushing` one item at a time/// * perform the iteration in-place on the original allocation backing the iterator/// The last case warrants some attention. It is an optimization that in many cases reduces peak memory/// consumption and improves cache locality. But when big, short-lived allocations are created,/// only a small fraction of their items get collected, no further use is made of the spare capacity/// and the resulting `Vec` is moved into a longer-lived structure, then this can lead to the large/// allocations having their lifetimes unnecessarily extended which can result in increased memory/// footprint./// In cases where this is an issue, the excess capacity can be discarded with [`Vec::shrink_to()`],/// [`Vec::shrink_to_fit()`] or by collecting into [`Box<[T]>`][owned slice] instead, which additionally reduces/// the size of the long-lived struct./// # use std::sync::Mutex;/// static LONG_LIVED: Mutex<Vec<Vec<u16>>> = Mutex::new(Vec::new());///     let big_temporary: Vec<u16> = (0..1024).collect();///     // discard most items///     let mut result: Vec<_> = big_temporary.into_iter().filter(|i| i % 100 == 0).collect();///     // without this a lot of unused capacity might be moved into the global///     result.shrink_to_fit();///     LONG_LIVED.lock().unwrap().push(result);/// the vector (from start to end). The vector cannot be used after calling/// let v = vec!["a".to_string(), "b".to_string()];/// let mut v_iter = v.into_iter();/// let first_element: Option<String> = v_iter.next();/// assert_eq!(first_element, Some("a".to_string()));/// assert_eq!(v_iter.next(), Some("b".to_string()));/// assert_eq!(v_iter.next(), None);extend_desugared// leaf method to which various SpecFrom/SpecExtend implementations delegate when// they have no further optimizations to applyextend_trusted// specific extend for `TrustedLen` iterators, called both by the specializations// and internal places where resolving specialization makes compilation slower/// Creates a splicing iterator that replaces the specified range in the vector/// `range` is removed even if the `Splice` iterator is not consumed before it is dropped./// It is unspecified how many elements are removed from the vector/// if the `Splice` value is leaked./// The input iterator `replace_with` is only consumed when the `Splice` value is dropped./// This is optimal if:/// * The tail (elements in the vector after `range`) is empty,/// * or `replace_with` yields fewer or equal elements than `range`'s length/// * or the lower bound of its `size_hint()` is exact./// Otherwise, a temporary vector is allocated and the tail is moved twice./// let mut v = vec![1, 2, 3, 4];/// let new = [7, 8, 9];/// let u: Vec<_> = v.splice(1..3, new).collect();/// assert_eq!(v, [1, 7, 8, 9, 4]);/// assert_eq!(u, [2, 3]);/// Using `splice` to insert new items into a vector efficiently at a specific position/// indicated by an empty range:/// let mut v = vec![1, 5];/// let new = [2, 3, 4];/// v.splice(1..1, new);/// If the closure returns `true`, the element is removed from the vector/// and yielded. If the closure returns `false`, or panics, the element/// remains in the vector and will not be yielded./// [`retain_mut`]: Vec::retain_mut/// # let mut vec = vec![0, 1, 2, 3, 4, 5, 6];/// # let mut vec2 = vec.clone();/// let end_items = vec.len() - range.end;/// while i < vec.len() - end_items {///     if some_predicate(&mut vec[i]) {///         let val = vec.remove(i);/// # let extracted2: Vec<_> = vec2.extract_if(range, some_predicate).collect();/// # assert_eq!(vec, vec2);/// Splitting a vector into even and odd values, reusing the original vector:/// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];/// let evens = numbers.extract_if(.., |x| *x % 2 == 0).collect::<Vec<_>>();/// assert_eq!(evens, vec![2, 4, 6, 8, 14]);/// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);/// Using the range argument to only process a part of the vector:/// let mut items = vec![0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 2, 1, 2];/// let ones = items.extract_if(7.., |x| *x == 1).collect::<Vec<_>>();/// assert_eq!(items, vec![0, 0, 0, 0, 0, 0, 0, 2, 2, 2]);/// Extend implementation that copies elements out of references before pushing them onto the Vec./// This implementation is specialized for slice iterators, where it uses [`copy_from_slice`] to/// append the entire slice at once./// [`copy_from_slice`]: slice::copy_from_slice/// Implements comparison of vectors, [lexicographically](Ord#lexicographical-comparison)./// Implements ordering of vectors, [lexicographically](Ord#lexicographical-comparison)./// Creates an empty `Vec<T>`./// Allocates a `Vec<T>` and fills it by cloning `s`'s items./// assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);/// assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);/// assert_eq!(Vec::from(&[1, 2, 3]), vec![1, 2, 3]);/// assert_eq!(Vec::from(&mut [1, 2, 3]), vec![1, 2, 3]);/// Allocates a `Vec<T>` and moves `s`'s items into it./// assert_eq!(Vec::from([1, 2, 3]), vec![1, 2, 3]);/// Converts a clone-on-write slice into a vector./// If `s` already owns a `Vec<T>`, it will be returned directly./// If `s` is borrowing a slice, a new `Vec<T>` will be allocated and/// filled by cloning `s`'s items into it./// let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);/// let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);/// assert_eq!(Vec::from(o), Vec::from(b));/// Converts a boxed slice into a vector by transferring ownership of/// the existing heap allocation./// let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();/// assert_eq!(Vec::from(b), vec![1, 2, 3]);/// Converts a vector into a boxed slice./// Before doing the conversion, this method discards excess capacity like [`Vec::shrink_to_fit`]./// [`Vec::shrink_to_fit`]: Vec::shrink_to_fit/// assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());/// assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());/// Allocates a `Vec<u8>` and fills it with a UTF-8 string./// assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);/// Gets the entire contents of the `Vec<T>` as an array,/// if its size exactly matches that of the requested array./// assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));/// assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));/// If the length doesn't match, the input comes back in `Err`:/// let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();/// assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));/// If you're fine with just getting a prefix of the `Vec<T>`,/// you can call [`.truncate(N)`](Vec::truncate) first./// let mut v = String::from("hello world").into_bytes();/// v.truncate(2);/// let [a, b]: [_; 2] = v.try_into().unwrap();/// assert_eq!(a, b' ');/// assert_eq!(b, b'd');//! A contiguous growable array type with heap-allocated contents, written//! `Vec<T>`.//! Vectors have *O*(1) indexing, amortized *O*(1) push (to the end) and//! *O*(1) pop (from the end).//! Vectors ensure they never allocate more than `isize::MAX` bytes.//! You can explicitly create a [`Vec`] with [`Vec::new`]://! let v: Vec<i32> = Vec::new();//! ...or by using the [`vec!`] macro://! let v: Vec<i32> = vec![];//! let v = vec![0; 10]; // ten zeroes//! You can [`push`] values onto the end of a vector (which will grow the vector//! as needed)://! let mut v = vec![1, 2];//! v.push(3);//! Popping values works in much the same way://! let two = v.pop();//! Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits)://! let mut v = vec![1, 2, 3];//! let three = v[2];//! v[1] = v[1] + 5;//! When the type is non-zero-sized and the capacity is nonzero, [`Vec`] uses the [`Global`]//! allocator for its allocation. It is valid to convert both ways between such a [`Vec`] and a raw//! pointer allocated with the [`Global`] allocator, provided that the [`Layout`] used with the//! allocator is correct for a sequence of `capacity` elements of the type, and the first `len`//! values pointed to by the raw pointer are valid. More precisely, a `ptr: *mut T` that has been//! allocated with the [`Global`] allocator with [`Layout::array::<T>(capacity)`][Layout::array] may//! be converted into a vec using//! [`Vec::<T>::from_raw_parts(ptr, len, capacity)`](Vec::from_raw_parts). Conversely, the memory//! backing a `value: *mut T` obtained from [`Vec::<T>::as_mut_ptr`] may be deallocated using the//! [`Global`] allocator with the same layout.//! For zero-sized types (ZSTs), or when the capacity is zero, the `Vec` pointer must be non-null//! and sufficiently aligned. The recommended way to build a `Vec` of ZSTs if [`vec!`] cannot be//! used is to use [`ptr::NonNull::dangling`].//! [`push`]: Vec::push//! [`ptr::NonNull::dangling`]: NonNull::dangling//! [Layout::array]: crate::alloc::Layout::array// Inherent methods// Internal methods and functions// Common trait implementations for Vec// NOTE: some less important impls are omitted to reduce code bloat// FIXME(Centril): Reconsider this?//__impl_slice_eq1! { [const N: usize] Vec<A>, &mut [B; N], }//__impl_slice_eq1! { [const N: usize] [A; N], Vec<B>, }//__impl_slice_eq1! { [const N: usize] &[A; N], Vec<B>, }//__impl_slice_eq1! { [const N: usize] &mut [A; N], Vec<B>, }//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, [B; N], }//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &[B; N], }//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &mut [B; N], }/// Structure wrapping a mutable reference to the last item in a/// This `struct` is created by the [`peek_mut`] method on [`Vec`]. See/// [`peek_mut`]: Vec::peek_mut/// Removes the peeked value from the vector and returns it.// Set the length of the vec when the `SetLenOnDrop` value goes out of scope.// The idea is: The length field in SetLenOnDrop is a local variable// that the optimizer will see does not alias with any stores through the Vec's data// pointer. This is a workaround for alias analysis issue #32155// Specialization trait used for Vec::extend// Specialization trait used for Vec::from_elem// A better way would be to implement this for all ZSTs which are `Copy` and have trivial `Clone`// but the latter cannot be detected currently/// Specialization trait used for Vec::from_iter/// ## The delegation graph:/// +-------------+/// |FromIterator |/// +-+-----------+///   v/// +-+---------------------------------+  +---------------------+/// |SpecFromIter                    +---->+SpecFromIterNested   |/// |where I:                        |  |  |where I:             |/// |  Iterator (default)------------+  |  |  Iterator (default) |/// |  vec::IntoIter                 |  |  |  TrustedLen         |/// |  InPlaceCollect--(fallback to)-+  |  +---------------------+/// +-----------------------------------+/// Another specialization trait for Vec::from_iter/// necessary to manually prioritize overlapping specializations/// see [`SpecFromIter`](super::SpecFromIter) for details./// A splicing iterator for `Vec`./// This struct is created by [`Vec::splice()`]./// let new = [7, 8];/// let iter: std::vec::Splice<'_, _> = v.splice(1.., new);/// The range from `self.vec.len` to `self.tail_start` contains elements/// that have been moved out./// Fill that range as much as possible with new elements from the `replace_with` iterator./// Returns `true` if we filled the entire range. (`replace_with.next()` didn’t return `None`.)/// Makes room for inserting more elements before the tail./// Private helper methods for `Splice::drop`encode_utf8_rawWtf8EncodeWideWtf8CodePointsis_known_utf8/// Do we know that `bytes` holds a valid UTF-8 encoding? We can easily/// know this if we're constructed from a `String` or `&str`./// It is possible for `bytes` to have valid UTF-8 without this being/// set, such as when we're concatenating `&Wtf8`'s and surrogates become/// paired, as we don't bother to rescan the entire string.Wtf8Buf/// An owned, growable string of well-formed WTF-8 data./// Similar to `String`, but can additionally contain surrogate code points/// if they’re not in a surrogate pair./// Formats the string in double quotes, with characters escaped according to/// [`char::escape_debug`] and unpaired surrogates represented as `\u{xxxx}`,/// where each `x` is a hexadecimal digit./// For example, the code units [U+0061, U+D800, U+000A] are formatted as/// `"a\u{D800}\n"`./// Formats the string with unpaired surrogates substituted with the replacement/// character, U+FFFD./// Creates a new, empty WTF-8 string./// Creates a new, empty WTF-8 string with pre-allocated capacity for `capacity` bytes./// Creates a WTF-8 string from a WTF-8 byte vec./// Since the byte vec is not checked for valid WTF-8, this function is/// marked unsafe./// Creates a WTF-8 string from a UTF-8 `String`./// This takes ownership of the `String` and does not copy./// Since WTF-8 is a superset of UTF-8, this always succeeds./// Creates a WTF-8 string from a UTF-8 `&str` slice./// This copies the content of the slice.from_wide/// Creates a WTF-8 string from a potentially ill-formed UTF-16 slice of 16-bit code units./// This is lossless: calling `.encode_wide()` on the resulting string/// will always return the original code units.push_code_point_unchecked/// Appends the given `char` to the end of this string./// This does **not** include the WTF-8 concatenation check or `is_known_utf8` check./// Copied from String::push.as_known_utf8/// Converts the string to UTF-8 without validation, if it was created from/// in the given `Wtf8Buf`./// Tries to reserve capacity for at least `additional` more bytes to be/// inserted in the given `Wtf8Buf`. The `Wtf8Buf` may reserve more space to/// avoid frequent reallocations. After calling `try_reserve`, capacity will/// be greater than or equal to `self.len() + additional`. Does nothing if/// capacity is already sufficient. This method preserves the contents even/// if an error occurs./// Tries to reserve the minimum capacity for exactly `additional` more/// bytes to be inserted in the given `Wtf8Buf`. After calling/// `try_reserve_exact`, capacity will be greater than or equal to/// `self.len() + additional` if it returns `Ok(())`./// Note that the allocator may give the `Wtf8Buf` more space than it/// [`try_reserve`]: Wtf8Buf::try_reserve/// Returns the number of bytes that this string buffer can hold without reallocating./// Append a UTF-8 slice at the end of the string.push_wtf8/// Append a WTF-8 slice at the end of the string./// This replaces newly paired surrogates at the boundary/// with a supplementary code point,/// like concatenating ill-formed UTF-16 strings effectively would./// Append a Unicode scalar value at the end of the string./// Append a code point at the end of the string./// Shortens a string to the specified length./// Panics if `new_len` > current length,/// or if `new_len` is not a code point boundary./// Consumes the WTF-8 string and tries to convert it to a vec of bytes./// Consumes the WTF-8 string and tries to convert it to UTF-8./// This does not copy the data./// If the contents are not well-formed UTF-8/// (that is, if the string contains surrogates),/// the original WTF-8 string is returned instead.into_string_lossy/// Consumes the WTF-8 string and converts it lossily to UTF-8./// This does not copy the data (but may overwrite parts of it in place)./// Surrogates are replaced with `"\u{FFFD}"` (the replacement character “�”)/// Converts this `Wtf8Buf` into a boxed `Wtf8`.from_box/// Converts a `Box<Wtf8>` into a `Wtf8Buf`.extend_from_slice_unchecked/// Provides plumbing to core `Vec::extend_from_slice`./// More well behaving alternative to allowing outer types/// full mutable access to the core `Vec`./// Creates a new WTF-8 string from an iterator of code points./// This replaces surrogate code point pairs with supplementary code points,/// Append code points from an iterator to the string./// Creates an owned `Wtf8Buf` from a borrowed `Wtf8`./// Lossily converts the string to UTF-8./// Returns a UTF-8 `&str` slice if the contents are well-formed in UTF-8./// Surrogates are replaced with `"\u{FFFD}"` (the replacement character “�”)./// This only copies the data if necessary (if it contains any surrogate).empty_boxdecode_surrogate_pair//! Heap-allocated counterpart to core `wtf8` module.// rustdoc bug: doc(hidden) on the module won't stop types in the module from showing up in trait// implementations, so, we'll have to add more doc(hidden)s anywaycode_point_from_u32code_point_to_u32code_point_to_lead_surrogatecode_point_to_trail_surrogatecode_point_from_charcode_point_to_stringcode_point_to_charcode_point_to_char_lossywtf8buf_newwtf8buf_from_strwtf8buf_from_stringwtf8buf_from_widewtf8buf_push_strwtf8buf_push_charwtf8buf_pushwtf8buf_push_wtf8wtf8buf_truncatewtf8buf_truncate_around_non_bmpwtf8buf_truncate_fail_code_point_boundarywtf8buf_truncate_fail_longerwtf8buf_truncate_splitting_non_bmp3wtf8buf_truncate_splitting_non_bmp2wtf8buf_truncate_splitting_non_bmp1wtf8buf_into_stringwtf8buf_into_string_lossywtf8buf_from_iteratorwtf8buf_extendwtf8buf_showwtf8buf_as_slicewtf8buf_show_strwtf8_from_strwtf8_lenwtf8_slicewtf8_slice_not_code_point_boundarywtf8_slice_fromwtf8_slice_from_not_code_point_boundarywtf8_slice_towtf8_slice_to_not_code_point_boundarywtf8_ascii_byte_atwtf8_code_pointswtf8_as_strwtf8_to_string_lossywtf8_displaywtf8_encode_widewtf8_encode_wide_size_hintwtf8_encode_wide_debugwtf8_clone_intowtf8_make_ascii_lowercasewtf8_make_ascii_uppercasewtf8_to_ownedwtf8_valid_utf8_boundarieswtf8_utf8_boundary_out_of_boundswtf8_utf8_boundary_inside_codepointwtf8_utf8_boundary_inside_surrogatewtf8_utf8_boundary_between_surrogateswobbled_wtf8_plus_bytes_isnt_utf8wobbled_wtf8_plus_str_isnt_utf8unwobbly_wtf8_plus_utf8_is_utf8bench_find_smallest_1000bench_peek_mut_deref_mutbench_from_vecbench_into_sorted_vecbench_pushbench_popmap_insert_rand_benchmap_insert_seq_benchmap_from_iter_rand_benchmap_from_iter_seq_benchmap_find_rand_benchmap_find_seq_benchbench_iterationiteration_20iteration_1000iteration_100000bench_iteration_mutiteration_mut_20iteration_mut_1000iteration_mut_100000bench_first_and_last_nightlybench_first_and_last_stablefirst_and_last_0_nightlyfirst_and_last_0_stablefirst_and_last_100_nightlyfirst_and_last_100_stablefirst_and_last_10k_nightlyfirst_and_last_10k_stableBENCH_RANGE_SIZEBENCH_RANGE_COUNTbench_rangerange_included_excludedrange_included_includedrange_included_unboundedrange_unbounded_unboundedbench_iterrange_unbounded_vs_iter/// Contrast range_unbounded_unbounded with `iter()`.iter_0iter_1iter_100iter_10kiter_1m// hits an OOMFATslim_map// The returned map has small keys and values.// Benchmarks on it have a counterpart in set.rs with the same keys and no values at all.fat_val_map// The returned map has small keys and large values.clone_slim_100clone_slim_100_and_clearclone_slim_100_and_drain_allclone_slim_100_and_drain_halfclone_slim_100_and_into_iterclone_slim_100_and_pop_allclone_slim_100_and_remove_allclone_slim_100_and_remove_halfclone_slim_10kclone_slim_10k_and_clearclone_slim_10k_and_drain_allclone_slim_10k_and_drain_halfclone_slim_10k_and_into_iterclone_slim_10k_and_pop_allclone_slim_10k_and_remove_allclone_slim_10k_and_remove_halfclone_fat_val_100clone_fat_val_100_and_clearclone_fat_val_100_and_drain_allclone_fat_val_100_and_drain_halfclone_fat_val_100_and_into_iterclone_fat_val_100_and_pop_allclone_fat_val_100_and_remove_allclone_fat_val_100_and_remove_halfstaggerset_benchslim_setclone_100clone_100_and_clearclone_100_and_drain_allclone_100_and_drain_halfclone_100_and_into_iterclone_100_and_pop_allclone_100_and_remove_allclone_100_and_remove_halfclone_10kclone_10k_and_clearclone_10k_and_drain_allclone_10k_and_drain_halfclone_10k_and_into_iterclone_10k_and_pop_allclone_10k_and_remove_allclone_10k_and_remove_halfbench_rng/// Returns a `rand::Rng` seeded with a consistent seed./// This is done to avoid introducing nondeterminism in benchmark results.// Disabling in Miri as these would take too long.bench_collect_intobench_push_frontbench_push_backbench_push_back_pop_backbench_push_front_pop_frontbench_iter_mutbench_iter_revbench_iter_mut_revmut_iteratorstarts_with_same_vectorstarts_with_single_elementstarts_with_diff_one_element_at_endends_with_same_vectorends_with_single_elementends_with_diff_one_element_at_beginningcontains_last_elementzero_1kb_from_elemzero_1kb_set_memoryzero_1kb_loop_setzero_1kb_mut_iterrandom_insertsrandom_removesgen_ascendinggen_descendinggen_randomgen_random_bytesgen_mostly_ascendinggen_mostly_descendinggen_stringsgen_big_randomsort_stringssort_expensivesort_lexicographicF64x4// Intended to use more RAM than the machine has cachechar_iteratorchar_iterator_forchar_iterator_asciichar_iterator_revchar_iterator_rev_forchar_indicesatorchar_indicesator_revsplit_unicode_asciisplit_asciisplit_extern_fnsplit_closuresplit_slicebench_joinbench_contains_short_shortLONG_HAYSTACKbench_contains_2b_repeated_longbench_contains_short_longbench_contains_16b_in_longbench_contains_32b_in_longbench_contains_bad_naivebench_contains_bad_simdbench_contains_equalmake_test_innermake_testbench_with_capacitybench_push_strREPETITIONSbench_push_str_one_bytebench_push_char_one_bytebench_push_char_two_bytesfrom_utf8_lossy_100_asciifrom_utf8_lossy_100_multibytefrom_utf8_lossy_invalidfrom_utf8_lossy_100_invalidbench_exact_size_shrink_to_fitbench_from_strbench_frombench_to_stringbench_insert_char_shortbench_insert_char_longbench_insert_str_shortbench_insert_str_longbench_newdo_bench_with_capacitybench_with_capacity_0000bench_with_capacity_0010bench_with_capacity_0100bench_with_capacity_1000do_bench_from_fnbench_from_fn_0000bench_from_fn_0010bench_from_fn_0100bench_from_fn_1000do_bench_from_elembench_from_elem_0000bench_from_elem_0010bench_from_elem_0100bench_from_elem_1000do_bench_from_slicebench_from_slice_0000bench_from_slice_0010bench_from_slice_0100bench_from_slice_1000do_bench_from_iterbench_from_iter_0000bench_from_iter_0010bench_from_iter_0100bench_from_iter_1000do_bench_extendbench_extend_0000_0000bench_extend_0000_0010bench_extend_0000_0100bench_extend_0000_1000bench_extend_0010_0010bench_extend_0100_0100bench_extend_1000_1000do_bench_extend_from_slicebench_extend_recyclebench_extend_from_slice_0000_0000bench_extend_from_slice_0000_0010bench_extend_from_slice_0000_0100bench_extend_from_slice_0000_1000bench_extend_from_slice_0010_0010bench_extend_from_slice_0100_0100bench_extend_from_slice_1000_1000do_bench_clonebench_clone_0000bench_clone_0010bench_clone_0100bench_clone_1000do_bench_clone_frombench_clone_from_01_0000_0000bench_clone_from_01_0000_0010bench_clone_from_01_0000_0100bench_clone_from_01_0000_1000bench_clone_from_01_0010_0010bench_clone_from_01_0100_0100bench_clone_from_01_1000_1000bench_clone_from_01_0010_0100bench_clone_from_01_0100_1000bench_clone_from_01_0010_0000bench_clone_from_01_0100_0010bench_clone_from_01_1000_0100bench_clone_from_10_0000_0000bench_clone_from_10_0000_0010bench_clone_from_10_0000_0100bench_clone_from_10_0000_1000bench_clone_from_10_0010_0010bench_clone_from_10_0100_0100bench_clone_from_10_1000_1000bench_clone_from_10_0010_0100bench_clone_from_10_0100_1000bench_clone_from_10_0010_0000bench_clone_from_10_0100_0010bench_clone_from_10_1000_0100bench_in_placebench_in_place_recyclebench_in_place_zip_recyclebench_in_place_zip_iter_mutvec_castbench_transmutebench_in_place_collect_droppable// node.js gives out of memory error to use with length 1_100_000bench_chain_collectbench_chain_chain_collectbench_nest_chain_chain_collectbench_range_map_collectbench_chain_extend_refbench_chain_extend_valuebench_rev_1bench_rev_2bench_map_regularbench_map_fastrandom_sorted_fillbench_dedup_slice_truncate// Measures performance of slice dedup impl.// This was used to justify separate implementation of dedup for Vec.// This algorithm was used for Vecs prior to Rust 1.52.bench_vec_dedup_random// Measures performance of Vec::dedup on random data.bench_vec_dedup_none// Measures performance of Vec::dedup when there is no items removedbench_vec_dedup_all// Measures performance of Vec::dedup when there is all items removedbench_dedup_slice_truncate_100bench_dedup_random_100bench_dedup_none_100bench_dedup_all_100bench_dedup_slice_truncate_1000bench_dedup_random_1000bench_dedup_none_1000bench_dedup_all_1000bench_dedup_slice_truncate_10000bench_dedup_random_10000bench_dedup_none_10000bench_dedup_all_10000bench_dedup_slice_truncate_100000bench_dedup_random_100000bench_dedup_none_100000bench_dedup_all_100000bench_flat_map_collectbench_retain_iter_100000/// Reference benchmark that `retain` has to compete with.bench_retain_100000bench_retain_whole_100000bench_next_chunkbench_grow_1025bench_iter_1000bench_mut_iter_1000bench_try_foldinto_iter_helper/// does the memory bookkeeping to reuse the buffer of the Vec between iterations./// `setup` must not modify its argument's length or capacity. `g` must not move out of its argument.bench_into_iterbench_into_iter_foldbench_into_iter_try_foldbench_into_iter_next_chunkbench_from_array_1000bench_extend_bytesbench_extend_vecbench_extend_trustedlenbench_extend_chained_trustedlenbench_extend_chained_bytesVECDEQUE_LENWARMUP_NBENCH_N// Allow testing this library"../alloc/src/collections/mod.rs"// We are directly including collections, raw_vec, and wtf8 here as they use non-public// methods and fields in tests and as such need to have the types to test in the same// crate as the tests themself."../alloc/src/raw_vec/mod.rs""../alloc/src/wtf8/mod.rs"/// Copied from `std::test_helpers::test_rng`, since these tests rely on the/// seed not being the same for every RNG invocation too.// Not used in all configurationsqueried/// A blueprint for crash test dummy instances that monitor particular events./// Some instances may be configured to panic at some point./// Events are `clone`, `drop` or some anonymous `query`./// Crash test dummies are identified and ordered by an id, so they can be used/// as keys in a BTreeMap./// Creates a crash test dummy design. The `id` determines order and equality of instances./// Creates an instance of a crash test dummy that records what events it experiences/// and optionally panics./// Returns how many times instances of the dummy have been cloned./// Returns how many times instances of the dummy have been dropped./// Returns how many times instances of the dummy have had their `query` member invoked.InCloneInDropInQuery/// Some anonymous query, the result of which is already given.// Minimal type with an `Ord` implementation violating transitivity.flipped// Controls the ordering of values wrapped by `Governed`.// Type with an `Ord` implementation that forms a total order at any moment// (assuming that `T` respects total order), but can suddenly be made to invert// that total order.// Comparison based only on the ID, the name is ignored./// XorShiftRng/// Guarantees that each returned number is unique.alloc_owned_smalltrait_objectfloat_nan_ne// The test code below is identical to that in `rc.rs`.// For better maintainability we therefore define this type alias.SHARED_ITER_MAXassert_trusted_lenshared_from_iter_normalshared_from_iter_trustedlen_normal"I've almost got 99 problems."shared_from_iter_trustedlen_panicshared_from_iter_trustedlen_no_fuseweak_may_danglepanic_no_leak/// Test that a panic from a destructor does not leak the allocation.make_mut_unsized/// This is similar to the doc-test for `Arc::make_mut()`, but on an unsized type (slice).test_unique_arc_weakMyTraitpin_arc// Pin coercion should work for Arcpin_unique_arcpin_coerce_unsizedrequire_syncrequire_send_synctest_btree_maptest_btree_settest_binary_heaptest_linked_listtest_vec_dequetest_from_cowtest_from_cow_slicetest_from_cow_strtest_from_cow_c_strtest_from_cow_os_strtest_from_cow_pathcow_constuninitialized_zero_size_boxbox_clone_and_clone_from_equivalencebox_clone_from_ptr_stability/// This test might give a false positive in case the box reallocates,/// but the allocator keeps the original pointer./// On the other hand, it won't give a false negative: If it fails, then the/// memory was definitely not reused.box_deref_lvalConstAllocatorpin_box// Pin coercion should work for Boxpin_coerce_unsized_boxtest_prefix_freeFromBytesUntilNulErrorc_to_rustbuild_with_zero1build_with_zero2equal_hashfrom_bytes_with_nulfrom_bytes_with_nul_unterminatedfrom_bytes_with_nul_interiorcstr_from_bytes_until_nulboxed_defaulttest_c_str_clone_intocstr_const_constructorcstr_index_fromcstr_index_from_emptyc_string_from_empty_stringc_str_from_empty_stringtest_iter_rev_cloned_collecttest_into_iter_collecttest_into_iter_rev_collecttest_into_iter_sorted_collecttest_drain_sorted_collectcheck_exact_size_iteratorcheck_trusted_lentest_trusted_lentest_peek_and_poptest_peek_muttest_peek_mut_leektest_peek_mut_poptest_push_uniquecheck_to_vectest_to_vectest_in_place_iterator_specializationtest_empty_poptest_empty_peektest_empty_peek_muttest_drain_sortedtest_drain_sorted_leaktest_drain_forgettest_drain_sorted_forgettest_append_to_emptytest_extend_specializationtest_retain_catch_unwindpanic_safe// old binaryheap failed this test// Integrity means that all elements are present after a comparison panics,// even if the order might not be correct.// Destructors must be called exactly once per element.Evil/// This intentionally has a panicking `PartialEq` impl, to test that various/// collections' `PartialEq` impls don't actually compare elements if their sizes/// are unequal./// This is not advisable in normal code."Evil::eq is evil"evil_eq_works// check Evil worksvec_evil_eqhashset_evil_eqhashmap_evil_eqbtreeset_evil_eqbtreemap_evil_eqlinkedlist_evil_eq//! Regression tests which fail if some collections' `PartialEq::eq` impls compare//! elements when the collections have different sizes.//! This behavior is not guaranteed either way, so regressing these tests is fine//! if it is done on purpose.// check various containers don't compare if their sizes are differenteq_diff_lenMY_VECMY_STRINGMY_BTREEMAPMAP_LENMAP_IS_EMPTYMY_BTREESETSET_LENSET_IS_EMPTY// Test const functions in the library// FIXME(#110395)// pub const MY_VEC2: Vec<usize> = Default::default();// pub const MY_STRING2: String = Default::default();// pub const MY_BOXED_SLICE: Box<[usize]> = Default::default();// pub const MY_BOXED_STR: Box<str> = Default::default();check_cow_add_cow// check that Cow<'a, str> implements additioncheck_cow_add_strcheck_cow_add_assign_cowcheck_cow_add_assign_strcheck_cow_clone_fromtest_formattest_format_macro_interface// Basic test to make sure that we can invoke the `write!` macro with an// fmt::Write instance.test_print// Just make sure that the macros are defined, there's not really a lot that we// can do with them just yet (to test the output)test_format_argscounter_fntest_oncetest_refcellalloc_system_overaligned_request/// Issue #45955 and #62251.std_heap_overaligned_requestcheck_overalign_requestsalloc_testautotraitsbtree_set_hashc_str2cow_strmisc_teststhin_boxtest_boxed_hashertest_owned_cloneany_moveraw_sizedraw_traitf64_slicei64_slicestr_sliceboxed_slice_from_itertest_array_from_slice//! Test for `boxed` mod.NumBufferassert_nbuint_to_sint_to_spin_rc// Pin coercion should work for Rcpin_unique_rctest_simple_clonetest_destructortest_livetest_deadweak_self_cyclictest_strong_counttest_weak_countweak_countsinto_from_rawtest_into_from_raw_unsizedinto_from_weak_rawtest_into_from_weak_raw_unsizedtest_cowrc_clone_make_uniquetest_cowrc_clone_unique2test_cowrc_clone_weaktest_cowrc_unsized/// This is similar to the doc-test for `Rc::make_mut()`, but on an unsized type (slice).test_unsizedtest_maybe_thin_unsizedtest_from_ownedtest_new_weaktest_ptr_eqtest_copy_from_slicetest_clone_from_slicetest_clone_from_slice_panictest_from_boxtest_from_box_strtest_from_box_slicetest_from_box_traittest_from_box_trait_zero_sizedtest_downcasttest_rc_cyclic_with_zero_refstest_rc_cyclic_with_one_reftest_rc_cyclic_with_two_reftest_unique_rc_weaktest_unique_rc_drop_weaktest_unique_rc_drops_contentstest_unique_rc_with_alloc_drops_contents/// Exercise the non-default allocator usage.test_unique_rc_weak_clone_holding_reftest_unique_rc_unsizing_coerciontest_from_fntest_from_elemtest_len_divzerotest_firsttest_first_muttest_split_firsttest_split_first_muttest_split_lasttest_split_last_muttest_lasttest_last_muttest_slice_fromtest_slice_totest_swap_removetest_swap_remove_failtest_swap_remove_noncopyabletest_rotate_lefttest_rotate_righttest_join_nocopytest_insert_oobtest_remove_failtest_slice_2assert_ordertest_total_ord_u8test_total_ord_i32test_iter_size_hintstest_iter_as_slicetest_iter_as_reftest_iter_clonetest_iter_is_emptytest_move_iteratortest_move_rev_iteratortest_split_iteratortest_split_iterator_inclusivetest_split_iterator_inclusive_reversetest_split_iterator_mut_inclusivetest_split_iterator_mut_inclusive_reversetest_splitn_iteratortest_splitn_iterator_muttest_rsplit_iteratortest_rsplitn_iteratortest_split_iterators_size_hinttest_windows_iteratortest_windows_iterator_0test_chunks_iteratortest_chunks_iterator_0test_chunks_exact_iteratortest_chunks_exact_iterator_0test_rchunks_iteratortest_rchunks_iterator_0test_rchunks_exact_iteratortest_rchunks_exact_iterator_0test_reverse_parttest_vec_defaulttest_overflow_does_not_cause_segfaulttest_overflow_does_not_cause_segfault_managedtest_mut_split_attest_iter_zero_sizedtest_starts_withtest_ends_withtest_mut_split_iteratortest_mut_split_iterator_revtest_mut_chunkstest_mut_chunks_revtest_mut_chunks_0test_mut_chunks_exacttest_mut_chunks_exact_revtest_mut_chunks_exact_0test_mut_rchunkstest_mut_rchunks_revtest_mut_rchunks_0test_mut_rchunks_exacttest_mut_rchunks_exact_revtest_mut_rchunks_exact_0test_mut_lasttest_box_slice_clonetest_box_slice_clone_panics// here, we care about the side effects of `.clone()`test_copy_from_slice_dst_longertest_copy_from_slice_dst_shorterrepeat_generic_slicesubslice_patternstest_chunk_bytest_chunk_by_mutFFIOneKibiByte// Very large stack value.F128// 16 byte stack value, with more expensive comparison.// This is kind of hacky, but we know we only have normal comparable floats in there.// Goal is similar code-gen between Rust and C++// - Rust https://godbolt.org/z/3YM3xenPP// - C++ https://godbolt.org/z/178M6j1zz/// Sort `v` preserving initial order of equal elements./// - Guaranteed O(N * log(N)) worst case perf/// - No adaptiveness/// - Branch miss-prediction not affected by outcome of comparison function/// - Uses `v.len()` auxiliary memory./// If `T: Ord` does not implement a total order the resulting order is/// unspecified. All original elements will remain in `v` and any possible modifications via/// interior mutability will be observable. Same is true if `T: Ord` panics./// Panics if allocating the auxiliary memory fails.mergesort_main/// The core logic should not be inlined./// SAFETY: The caller has to ensure that len is > 0 and that T is not a ZST.mergesort_core/// Tiny recursive top-down merge sort optimized for binary size. It has no adaptiveness whatsoever,/// no run detection, etc./// Buffer as pointed to by `scratch` must have space for `v.len()` writes. And must not alias `v`./// Branchless merge function./// SAFETY: The caller must ensure that `scratch_ptr` is valid for `v.len()` writes. And that mid is/// in-bounds.unwrap_unchecked// SAFETY: The caller has to ensure that Option is Some, UB otherwise.buf_ptr// Extremely basic versions of Vec.// Their use is super limited and by having the code here, it allows reuse between the sort// SAFETY: The caller has to ensure that len is not 0 and that T is not a ZST.// This module implements a known good stable sort implementation that helps provide better error// messages when the correctness tests fail, we can't use the stdlib sort functions because we are// testing them for correctness.// Based on https://github.com/voultapher/tiny-sort-rs.ffi_typesknown_good_stable_sortzipfZipfDistributionrandom_uniformrandom_zipfrandom_sortedascendingdescendingsaw_mixedsaw_mixed_rangepipe_organget_or_init_rand_seedSEED_VALUErand_root_seed/// Provides a set of patterns useful for testing and benchmarking sorting algorithms./// Currently limited to i32 values.// --- Public ---// --- Private ---TEST_LENGTHScheck_is_sortedtest_is_sortedget_valDynTraitDynValADynValBshift_i32_to_u32reverse_shift_i32_to_u32extend_i32_to_u64extend_i32_to_u128dyn_trait_from_i32i32_from_i32i32_from_i32_refstring_from_i32i32_from_stringcell_i32_from_i32i32_from_cell_i32calc_comps_requiredcomp_countCompCountgen_sort_test_fns/// Generates $base_name_pattern_name_impl functions calling the test_fns for all test_len.gen_sort_test_fns_with_default_patterns/// Generates $base_name_pattern_name_impl functions calling the test_fns for all test_len,/// with a default set of patterns that can be extended by the caller.gen_sort_test_fns_with_default_patterns_3_ty/// Generates $base_name_type_pattern_name_impl functions calling the test_fns for all test_len for/// three types that cover the core specialization differences in the sort implementations, with a/// default set of patterns that can be extended by the caller.fixed_seed_implfixed_seed_rand_vec_prefix_implint_edge_implsort_vs_sort_by_impl// Dyn values are fat pointers, something the implementation might have overlooked.stability_legacy_implstability_with_patternsobservable_is_lesspanic_retain_orig_setpanic_observable_is_lessself_cmpviolate_ord_retain_orig_setinstantiate_sort_test_innerdefine_instantiate_sort_tests// Using this construct allows us to get warnings for unused test functions.// Some tests are not tested with miri to avoid prohibitively long test times. This leaves coverage// holes, but the way they are selected should make for relatively small holes. Many properties that// can lead to UB are tested directly, for example that the original set of elements is retained// even when a panic occurs or Ord is implemented incorrectly.instantiate_sort_testsSortImpl// --- TESTS ---/// Number of elements/// Exponent parameter of the distributionh_integral_x1/// `hIntegral(1.5) - 1}`h_integral_num_elements/// `hIntegral(num_elements + 0.5)}`/// `2 - hIntegralInverse(hIntegral(2.5) - h(2)}`/// Random number generator that generates Zipf-distributed random numbers using rejection/// inversion./// Creates a new [Zipf-distributed](https://en.wikipedia.org/wiki/Zipf's_law)/// random number generator./// Note that both the number of elements and the exponent must be greater than 0.h_integral/// Computes `H(x)`, defined as///  - `(x^(1 - exponent) - 1) / (1 - exponent)`, if `exponent != 1`///  - `log(x)`, if `exponent == 1`/// `H(x)` is an integral function of `h(x)`, the derivative of `H(x)` is `h(x)`./// Computes `h(x) = 1 / x^exponent`h_integral_inv/// The inverse function of `H(x)`./// Returns the `y` for which `H(y) = x`.helper1/// Helper function that calculates `log(1 + x) / x`./// A Taylor series expansion is used, if x is close to 0.helper2/// Helper function to calculate `(exp(x) - 1) / x`.// This module implements a Zipfian distribution generator.// Based on https://github.com/jonhoo/rust-zipf.test_letest_rfindtest_collecttest_find_strtest_concat_for_different_typestest_concat_for_different_lengthstest_join_for_different_typestest_join_for_different_lengthstest_join_for_different_lengths_with_long_separator// join has fast paths for small separators up to 4 bytes// this tests the slow paths.test_join_issue_80335test_unsafe_slicetest_replacentest_replace_2atest_replace_2btest_replace_2ctest_replace_2dtest_replace_patternassert_range_eq// Test a slicing operation **that should succeed,**// testing it on all of the indexing methods.// This is not suitable for testing failure on invalid inputs.assert_range_eq_can_fail_by_panic// Make sure the macro can actually detect bugs,// because if it can't, then what are we even doing here?// (Be aware this only demonstrates the ability to detect bugs//  in the FIRST method that panics, as the macro is not designed//  to be used in `should_panic`)assert_range_eq_can_fail_by_inequality//  in the FIRST method it calls, as the macro is not designedpanic_cases// Generates test cases for bad index operations.// This generates `should_panic` test cases for Index/IndexMut// and `None` test cases for get/get_mut.simple_asciisimple_unicodesimple_bigtest_slice_failBAD_STARTGOOD_STARTBAD_ENDGOOD_ENDBAD_END_INCLGOOD_END_INCL// it is especially important to test all of the different range types here// because some of the logic may be duplicated as part of micro-optimizations// to dodge unicode boundary checks on half-ranges.LOREM_PARAGRAPHtest_slice_fail_truncated_1// check the panic includes the prefix of the sliced stringtest_slice_fail_truncated_2// check the truncation in the panic message// The current implementation of SliceIndex fails to handle methods// orthogonally from range types; therefore, it is worth testing// all of the indexing operations on each input.test_str_slice_rangetoinclusive_oktest_str_slice_rangetoinclusive_notoktest_str_slicemut_rangetoinclusive_oktest_str_slicemut_rangetoinclusive_notoktest_is_char_boundarytest_trim_start_matchestest_trim_end_matchestest_trim_matchestest_trim_starttest_trim_endtest_trimtest_is_whitespacetest_is_utf8test_const_is_utf8from_utf8_mostly_asciiconst_from_utf8_mostly_asciifrom_utf8_errortest_as_bytes_failtest_as_ptrvec_str_conversionstest_contains_chartest_split_at_muttest_split_at_boundschecktest_escape_unicodetest_escape_debugtest_escape_defaulttest_total_ordtest_iterator_advancetest_to_lowercase_rev_iteratortest_to_uppercase_rev_iteratortest_chars_decodingtest_chars_rev_decodingtest_iterator_lasttest_chars_debugtest_bytesatortest_bytes_revatortest_bytesator_nthtest_bytesator_counttest_bytesator_lasttest_char_indicesatortest_char_indices_revatortest_char_indices_lasttest_splitn_char_iteratortest_split_char_iterator_no_trailingtest_split_char_iterator_inclusivetest_split_char_iterator_inclusive_revtest_rsplittest_rsplitntest_rsplit_oncetest_split_whitespacetest_linestest_splitatortest_str_defaulttest_str_containertest_str_from_utf8test_pattern_deref_forwardtest_empty_match_indicestest_bool_from_strcheck_contains_all_substringsstrslice_issue_16589strslice_issue_16878strslice_issue_104726test_strslice_containstest_rsplitn_char_iteratortest_split_char_iteratortest_rev_split_char_iterator_no_trailingtest_utf16_code_unitstest_utf16_size_hintstarts_with_in_unicodestarts_short_longcontains_weird_casestrim_wstest_into_stringtest_cow_fromtest_repeatcmp_search_to_vecstr_searcher_empty_needle_after_done// See #85462generate_iterator_testdifferent_str_pattern_forwarding_lifetimestest_str_multilinetest_str_escapesconst_str_ptrutf8_charsutf8_char_countsfloor_char_boundaryceil_char_boundaryIntoCowtest_unsized_to_stringtest_from_utf8test_from_utf8_lossytest_fromutf8error_into_lossytest_utf16_invalidtest_from_utf16_lossytest_push_bytestest_push_strtest_split_off_emptytest_split_off_past_endtest_split_off_mid_chartest_split_off_asciitest_split_off_unicodetest_str_truncatetest_str_truncate_invalid_lentest_str_truncate_split_codepointtest_str_cleartest_str_addremove_badtest_remove_matchesinsert_bad1insert_bad2test_slicingtest_simple_typestest_drain_start_overflowtest_drain_end_overflowtest_replace_rangetest_replace_range_char_boundarytest_replace_range_inclusive_rangetest_replace_range_out_of_boundstest_replace_range_inclusive_out_of_boundstest_replace_range_start_overflowtest_replace_range_end_overflowtest_replace_range_emptytest_replace_range_unboundedtest_replace_range_evil_start_boundtest_replace_range_evil_end_boundtest_replace_firsttest_replace_lasttest_into_boxed_strtest_try_with_capacity// Miri does not support signalling OOMtest_from_chartest_str_concatCanaryAllocCanarymanually_share_arctest_arc_get_mut// no threadstest_cowarc_clone_make_muttest_cowarc_clone_unique2test_cowarc_clone_weakdrop_arcdrop_arc_weakshow_arc_Foo// Make sure deriving works with Arc<T>test_weak_count_lockedtest_arc_cyclic_with_zero_refstest_arc_new_cyclic_one_reftest_arc_cyclic_two_refsarc_drop_dereferenceable_race/// Test for Arc::drop bug (https://github.com/rust-lang/rust/issues/55005)// relies on Stacked Borrows in Miriarc_doesnt_leak_allocatortest_waker_will_wake_clone// `will_wake` doesn't guarantee that this test will work, and indeed on Miri it can failtest_local_waker_will_wake_clone"../../testing/crash_test.rs""../../testing/macros.rs"want_niche_optimizationwant_thinverify_alignedcheck_thin_sizedcheck_thin_dyndefine_test// Note: `#[repr(align(2))]` is worth testing because// - can have pointers which are misaligned, unlike align(1)// - is still expected to have an alignment less than the alignment of a vtable.assert_netest_small_vec_structtest_double_droptest_zst_capacitytest_indexingtest_debug_fmttest_slice_from_reftest_slice_from_muttest_slice_to_muttest_retain_predicate_ordertest_retain_pred_panic_with_holetest_retain_pred_panic_no_holetest_retain_drop_panictest_retain_maybeuninitstest_dedup_by_keytest_dedup_bytest_dedup_uniquezero_sized_valuestest_partitiontest_zip_unziptest_vec_truncate_droptest_vec_truncate_failtest_index_out_of_boundstest_slice_out_of_bounds_1test_slice_out_of_bounds_2test_slice_out_of_bounds_3test_slice_out_of_bounds_4test_slice_out_of_bounds_5test_swap_remove_emptytest_try_removetest_move_itemstest_move_items_reversetest_move_items_zero_sizedtest_drain_empty_vectest_drain_itemstest_drain_items_reversetest_drain_items_zero_sizedtest_drain_out_of_boundstest_drain_rangetest_drain_inclusive_rangetest_drain_max_vec_sizetest_drain_index_overflowtest_drain_inclusive_out_of_boundstest_drain_leaktest_drain_keep_resttest_drain_keep_rest_alltest_drain_keep_rest_nonetest_splice_inclusive_rangetest_splice_out_of_boundstest_splice_inclusive_out_of_boundstest_splice_items_zero_sizedtest_splice_unboundedtest_splice_forgettest_into_boxed_slicetest_split_off_take_alltest_into_iter_as_mut_slicetest_into_iter_counttest_into_iter_next_chunktest_into_iter_leaktest_into_iter_advance_bytest_into_iter_drop_allocatortest_into_iter_zsttest_from_iter_specializationtest_from_iter_partially_drained_in_place_specializationtest_from_iter_specialization_with_iterator_adapterstest_in_place_specialization_step_up_downtest_from_iter_specialization_head_tail_droptest_from_iter_specialization_panic_during_iteration_dropstest_from_iter_specialization_panic_during_drop_doesnt_leaktest_collect_after_iterator_clone// regression test for issue #85322. Peekable previously implemented InPlaceIterable,// but due to an interaction with IntoIter's current Clone implementation it failed to uphold// the contract.test_flatten_clone// regression test for #135103, similar to the one above Flatten/FlatMap had an unsound InPlaceIterablefrom_into_inneroveraligned_allocationsextract_if_rangesextract_if_out_of_boundsextract_if_consumed_panicextract_if_unconsumed_panicextract_if_unconsumedextract_if_debugtest_stable_pointersvec_macro_repeating_null_raw_fat_pointer// https://github.com/rust-lang/rust/pull/49496 introduced specialization based on:// unsafe impl<T: ?Sized> IsZero for *mut T {//     fn is_zero(&self) -> bool {//         (*self).is_null()// … to call `RawVec::with_capacity_zeroed` for creating `Vec<*mut T>`,// which is incorrect for fat pointers since `<*mut T>::is_null` only looks at the data component.// That is, a fat pointer can be “null” without being made entirely of zero bits.test_push_growth_strategy// This test will likely fail if you change the capacities used in// `RawVec::grow_amortized`.generate_assert_eq_vec_and_primpartialeq_vec_and_primassert_partial_eq_validpartialeq_vec_fulltest_vec_cycletest_vec_cycle_wrappedtest_zero_sized_capacitytest_zero_sized_vec_pushtest_vec_macro_repeattest_vec_swaptest_extend_from_within_clonetest_extend_from_within_complete_randetest_extend_from_within_empty_randetest_extend_from_within_out_of_randetest_extend_from_within_zsttest_extend_from_within_empty_vectest_extend_from_withintest_vec_dedup_bytest_vec_dedup_emptytest_vec_dedup_onetest_vec_dedup_multiple_identtest_vec_dedup_partialeqtest_vec_deduptest_vec_dedup_panickingtest_extend_from_within_panicking_clone// Regression test for issue #82533"vec len overflow"test_into_flattened_size_overflowtest_box_zero_allocatortest_vec_from_array_reftest_vec_from_array_mut_reftest_pop_iftest_pop_if_emptytest_pop_if_mutates/// in the stdlib. Draining and extending the allocation are fairly well-tested earlier, but/// `vec.insert(usize::MAX, val)` once slipped by!/// All code that manipulates the collection types should be tested with "trivially wrong" args.max_insertmax_splicevec_null_ptr_roundtrip// Regression test for #135338TaggyTaggypartest_parameterizedtest_push_front_growtest_range_start_overflowtest_range_end_overflowOneparTwoparThreeparRecCytest_param_inttest_param_taggytest_param_taggypartest_param_reccytest_with_capacity_non_power_twotest_mut_rev_iter_wraptest_partial_eq_arraytest_hash_after_rotationtest_eq_after_rotationtest_reserve_growtest_fronttest_as_slicestest_as_mut_slicestest_append_permutationstest_append_double_droptest_append_zst_capacity_overflowtest_reserve_exact_2test_rotate_noptest_rotate_left_partstest_rotate_right_partstest_rotate_left_randomtest_rotate_right_randomtest_try_fold_emptytest_try_fold_nonetest_try_fold_oktest_try_fold_unittest_try_fold_unit_nonetest_try_fold_rotatedtest_try_fold_moves_itertest_try_fold_exhaust_wraptest_try_fold_wraparoundtest_try_rfold_rotatedtest_try_rfold_moves_itertruncate_leaktruncate_front_leaktest_zero_sized_pushtest_from_zero_sized_vectest_resize_keeps_reserved_space_from_itemtest_collect_from_into_iter_keeps_allocationtest_truncate_front// Counters can be set to None if not needed.CloneTracker/// Struct that allows tracking clone and drop calls and can be set to panic on calling clone.test_extend_from_within_clone_panictest_prepend_from_withintest_prepend_from_within_clonetest_prepend_from_within_clone_panictest_extend_and_prepend_from_withintest_extend_fronttest_extend_front_specialization_vec_into_itertest_extend_front_specialization_copy_sliceset_alloc_error_hooktest_shrink_to_unwindtrace_and_resolve_callbacktrace_and_resolve_separatenew_unresolved_and_resolve_separatebaz// SAFETY: This function is safe to call. It is only marked as `unsafe` to// avoid having to allow `unused_unsafe` since other implementations are// unsafe.// required by `CONTEXT`, is a FIXME in windows metadata right nowTracePtr/// SAFETY: These pointers are always valid within a process and are not used for mutation.into_voidfrom_addrDeserialized// we don't want to implement `impl From<Backtrace> for Vec<BacktraceFrame>` on purpose,SerializedFrameserde_implsDbghelp//! actually use the raw definitions in `windows_sys`, but rather we need to define//! be in the business of duplicating auto-generated bindings, so we assert that all bindings match//! those in `windows_sys.rs`.//! backtrace::trace(|frame| {//!     let ip = frame.ip();//!     let symbol_address = frame.symbol_address();//!     // Resolve this instruction pointer to a symbol name//!     backtrace::resolve_frame(frame, |symbol| {//!         if let Some(name) = symbol.name() {//!             // ...//!         if let Some(filename) = symbol.filename() {//!     true // keep going to the next framenew_android/// On Android, shared objects can be loaded directly from a ZIP archive/// (see: [`super::Library::zip_offset`])./// If `zip_offset` is not None, we interpret the `path` as an/// "embedded" library path, and the value of `zip_offset` tells us where/// in the ZIP archive the library data starts./// We expect `zip_offset` to be page-aligned because the dynamic linker/// requires this. Otherwise, loading the embedded library will fail./// If we fail to load an embedded library for any reason, we fallback to/// interpreting the path as a literal file on disk (same as calling [`Self::new`]).decompress_zstd"_Errno"CallbackData/// `info` must be a valid pointer./// `data` must be a valid pointer to `CallbackData`.get_posix_path// Safety: long_path should be null-terminated// SAFETY: len <= initialized values/// least-recently-used cache with static size// #[feature(optimize_attr)] is enabled when we're built inside libstdzip_offset/// On Android, the dynamic linker [can map libraries directly from a/// ZIP archive][ndk-linker-changes] (typically an `.apk`)./// The linker requires that these libraries are stored uncompressed/// and page-aligned./// These "embedded" libraries have filepaths of the form/// `/path/to/my.apk!/lib/mylib.so` (where `/path/to/my.apk` is the archive/// and `lib/mylib.so` is the name of the library within the archive)./// This mechanism is present on Android since API level 23./// [ndk-linker-changes]: https://android.googlesource.com/platform/bionic/+/main/android-changes-for-ndk-developers.md#opening-shared-libraries-directly-from-an-apk/// On AIX, the library mmapped can be a member of a big-archive file./// For example, with a big-archive named libfoo.a containing libbar.so,/// one can use `dlopen("libfoo.a(libbar.so)", RTLD_MEMBER | RTLD_LAZY)`/// to use the `libbar.so` library. In this case, only `libbar.so` is/// mmapped, not the whole `libfoo.a`.extract_zip_path_android/// Try to extract the archive path from an "embedded" library path/// (e.g. `/path/to/my.apk` from `/path/to/my.apk!/mylib.so`)./// Returns `None` if the path does not contain a `!/` separator.ADDRESS_MODEARM64_NT_NEON128ARM64_NT_NEON128_0AddrModeFlatContextFlagsCONTEXT_FLAGSCpsrCONTEXT_0FpcrFpsrBcrBvrWcrWvrCONTEXT_0_0FpLrP1HomeP2HomeP3HomeP4HomeP5HomeP6HomeMxCsrSegCsSegDsSegEsSegFsSegGsSegSsEFlagsDr0Dr1Dr2Dr3Dr6Dr7RaxRcxRdxRbxRbpRsiRdiVectorRegisterVectorControlDebugControlLastBranchToRipLastBranchFromRipLastExceptionToRipLastExceptionFromRipFltSaveXmm0Xmm1Xmm2Xmm3Xmm4Xmm5Xmm6Xmm7Xmm8Xmm9Xmm10Xmm11Xmm12Xmm13Xmm14Xmm15FloatSaveEdiEsiEbxEdxEcxEaxEbpEipEspExtendedRegistersCREATE_TOOLHELP_SNAPSHOT_FLAGSExceptionCodeExceptionFlagsExceptionRecordExceptionAddressNumberParametersExceptionInformationEXCEPTION_ROUTINEFILE_MAPControlWordStatusWordTagWordErrorOffsetErrorSelectorDataOffsetDataSelectorRegisterAreaCr0NpxStateSpare0SizeOfStructLineNumberFileNameBeginAddressIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0UnwindDataIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0_bitfieldEndAddressIMAGE_RUNTIME_FUNCTION_ENTRY_0IMAGE_RUNTIME_FUNCTION_ENTRYUnwindInfoAddressThCallbackStackThCallbackBStoreNextCallbackFramePointerKiCallUserModeKeUserCallbackDispatcherSystemRangeStartKiUserExceptionDispatcherStackBaseStackLimitRetpolineStubFunctionTableSizeRetpolineStubFunctionTableRetpolineStubOffsetRetpolineStubSizeReserved0KNONVOLATILE_CONTEXT_POINTERSAnonymous1KNONVOLATILE_CONTEXT_POINTERS_0Anonymous2KNONVOLATILE_CONTEXT_POINTERS_1FloatingContextKNONVOLATILE_CONTEXT_POINTERS_0_0IntegerContextKNONVOLATILE_CONTEXT_POINTERS_1_0MEMORY_MAPPED_VIEW_ADDRESSdwSizeth32ModuleIDth32ProcessIDGlblcntUsageProccntUsagemodBaseAddrmodBaseSizehModuleszModuleszExePathPAGE_PROTECTION_FLAGSRTL_VIRTUAL_UNWIND_HANDLER_TYPEAddrPCAddrReturnAddrFrameAddrStackAddrBStoreFuncTableEntryFarKdHelpStackFrameSizeInlineFrameContextTypeIndexModBaseSYMBOL_INFO_FLAGSNameLenMaxNameLenLocalHintGlobalHintLowAddressHighAddressUNWIND_HISTORY_TABLE_ENTRYUNWIND_HISTORY_TABLEImageBaseFunctionEntryReserved1ErrorOpcodeReserved2Reserved3MxCsr_MaskFloatRegistersXmmRegistersReserved4ARM_MAX_BREAKPOINTSARM_MAX_WATCHPOINTSNEON128CONTEXT_FloatRegs// Control registersFpsrc// Floating-point registers// Debug registersPadding2callback_inlinedauxiliarycollapse_debuginfoinner_inlinedcannot_reexec_the_test/// Some tests only make sense in contexts where they can re-exec the test/// itself. Not all contexts support this, so you can call this method to find/// out which case you are in.PANICSVAREarlyExitIgnoreTestfind_interpreter// we use the `readelf` command to extract the path to the interpreter requested// by our binary.// if we cannot `readelf` for some reason, or if we fail to parse its output,// then we will just give up on this test (and not treat it as a test failure).// rust-lang/rust#101913: when you run your program explicitly via `ld.so`,// `std::env::current_exe` will return the path of *that* program, and not// the Rust program itself.// This behavior is only known to be supported on Linux and FreeBSD, see// https://mail-index.netbsd.org/tech-toolchain/2024/07/27/msg004469.html_234567890_234567890_234567890_234567890_234567890// 50-character struct name// 50-character module nametest_long_fn_name// Long function names must be truncated to (MAX_SYM_NAME - 1) characters.// Only run this test for msvc, since gnu prints "<no info>" for all frames.sgx_image_base_with_stdsgx_image_base_no_std// This test only works on platforms which have a working `symbol_address`// function for frames which reports the starting address of a symbol. As a// result it's only enabled on a few platforms.backtrace_new_unresolved_should_start_with_call_site_tracebacktrace_new_should_start_with_call_site_traceget_actual_fn_pointersmoke_test_frames// FIXME: shouldn't ignore this test on i686-msvc, unsure why it's failing// we care about line numbers heremany_threadsis_serdesp_smoke_testbuiltins_testfloat_benchcriterion_mainfloat_addgt_res_eq/// `gt` symbols are allowed to return differing results, they just get compared/// to 0.float_cmpfloat_conv/* unsigned int -> float *//* signed int -> float *//* float -> unsigned int *//* float -> signed int */float_divfloat_extend// "unused" f16 registersfloat_mul// FIXME(f16_f128): can be changed to only `f128_enabled` once `__multf3` and `__divtf3` are// distributed by nightly.float_powfloat_subfloat_truncAlignedVecmemcpy_builtinmemcpy_rustmemset_builtinmemset_rustmemcmp_builtinmemcmp_builtin_unalignedmemcmp_rustmemcmp_rust_unalignedmemmove_builtinmemmove_rustmemcpy_builtin_4096memcpy_rust_4096memcpy_builtin_1048576memcpy_rust_1048576memcpy_builtin_4096_offsetmemcpy_rust_4096_offsetmemcpy_builtin_1048576_offsetmemcpy_rust_1048576_offsetmemcpy_builtin_4096_misalignmemcpy_rust_4096_misalignmemcpy_builtin_1048576_misalignmemcpy_rust_1048576_misalignmemset_builtin_4096memset_rust_4096memset_builtin_1048576memset_rust_1048576memset_builtin_4096_offsetmemset_rust_4096_offsetmemset_builtin_1048576_offsetmemset_rust_1048576_offsetmemcmp_builtin_8memcmp_rust_8memcmp_builtin_16memcmp_rust_16memcmp_builtin_32memcmp_rust_32memcmp_builtin_64memcmp_rust_64memcmp_builtin_4096memcmp_rust_4096memcmp_builtin_1048576memcmp_rust_1048576memcmp_builtin_unaligned_7memcmp_rust_unaligned_7memcmp_builtin_unaligned_15memcmp_rust_unaligned_15memcmp_builtin_unaligned_31memcmp_rust_unaligned_31memcmp_builtin_unaligned_63memcmp_rust_unaligned_63memcmp_builtin_unaligned_4095memcmp_rust_unaligned_4095memcmp_builtin_unaligned_1048575memcmp_rust_unaligned_1048575memmove_builtin_4096memmove_rust_4096memmove_builtin_1048576memmove_rust_1048576memmove_builtin_4096_misalignmemmove_rust_4096_misalignmemmove_builtin_1048576_misalignmemmove_rust_1048576_misaligniai_callgrindlibrary_benchmarklibrary_benchmark_groupMAX_ALIGN// 4 kiBMEG1// assume we may use avx512 operations one dayAlignedSlice/// A buffer that is page-aligned by default, with an optional offset to create a/// misalignment./// Allocate a slice aligned to ALIGN with at least `len` items, with `offset` from/// page alignment.s_offbenchesaligned// Both aligned// Both at the same offsetmisaligned// `src` and `dst` both misaligned by different amountsmcpymsetmcmpspread/// `src` and `dst` are close and have the same alignment (or offset)./// `src` and `dst` are close./// `src` and `dst` are halfway offset in the buffer./// `src` and `dst` only overlap by a single byte.calculate_spread// Note that small and large aresetup_forwardsetup_backwardsmall_spreadmedium_spreadlarge_spreadaligned_offsmall_spread_offmedium_spread_offlarge_spread_offmmove//! Benchmarks that use Callgrind (via `iai_callgrind`) to report instruction count metrics. This//! is stable enough to be tested in CI.// 1 MiBbuiltins_configureNoSysF128NoSysF128IntConvertNoSysF16NoSysF16F64ConvertNoSysF16F128Convert/// Features to enableCHECK_ITER_ITEMS/// Fuzz with these many items to ensure equal functionsBENCH_ITER_ITEMS/// Benchmark with this many items to get a varietyskip_sys_checks/// Still run benchmarks/tests but don't check correctness between compiler-builtins and/// builtin system functions functionsskip_asm_checks/// assembly functions// Allow overriding a default// Allow overriding a function name/// Create a comparison of the system symbol, compiler_builtins, and optionally handwritten/// assembly./// The signature must be correct and any assembly must be sound.make_testveccheck_eqTestIO/// A type used as either an input or output to/from a benchmark function.impl_testioMinIntrand_xoshiroXoshiro128StarStar/// Sets the number of fuzz iterations run for most tests. In practice, the vast majority of bugs/// are caught by the edge case testers. Most of the remaining bugs triggered by more complex/// sequences are caught well within 10_000 fuzz iterations. For classes of algorithms like division/// that are vulnerable to rare edge cases, we want 1_000_000 iterations to be more confident. In/// practical CI, however, we only want to run the more strenuous test once to catch algorithmic/// level bugs, and run the 10_000 iteration test on most targets. Target-dependent bugs are likely/// to involve miscompilation and misconfiguration that is likely to break algorithms in quickly/// caught ways. We choose to configure `N = 1_000_000` iterations for `x86_64` targets (and if/// debug assertions are disabled. Tests without `--release` would take too long) which are likely/// to have fast hardware, and run `N = 10_000` for all other targets.FUZZ_LENGTHS/// LUT used for maximizing the space covered and minimizing the computational cost of fuzzing/// in `builtins-test`. For example, Self = u128 produces [0,1,2,7,8,15,16,31,32,63,64,95,96,/// 111,112,119,120,125,126,127].FUZZ_NUM/// The number of entries of `FUZZ_LENGTHS` actually used. The maximum is 20 for u128.FuzzInt/// Additional constants that determine how the integer gets fuzzed.make_fuzz_lengthsfuzz_step/// Random fuzzing step. When run several times, it results in excellent fuzzing entropy such as:/// 11110101010101011110111110011111/// 10110101010100001011101011001010/// 1000000000000000/// 10000000000000110111110000001010/// 1111011111111101010101111110101/// 101111111110100000000101000000/// 10000000110100000000100010101/// 1010101010101000edge_cases// We need macros like this, because `#![no_std]` prevents us from using iterators/// Feeds a series of fuzzing inputs to `f`. The fuzzer first uses an algorithm designed to find/// edge cases, followed by a more random fuzzer that runs `n` times.fuzz_2/// The same as `fuzz`, except `f` has two inputs.fuzz_shift/// Tester for shift functionsfuzz_float_stepfloat_edge_casesfuzz_floatfuzz_float_2apfloat_fallback// Operations that do not need converting back to a float// Some apfloat operations return a `StatusAnd` that we need to extract the value from. This// is the default.// This is the case where we can't use the same expression for the default builtin and// nonstandard apfloat fallback (e.g. `as` casts in std are normal functions in apfloat, so// two separate expressions must be specified./// Perform an operation using builtin types if available, falling back to apfloat if not.//! This crate is for integration testing and fuzz testing of functions in `compiler-builtins`. This//! includes publicly documented intrinsics and some internal alternative implementation functions//! such as `usize_leading_zeros_riscv` (which are tested because they are configured for//! architectures not tested by the CI).//! The general idea is to use a combination of edge case testing and randomized fuzz testing. The//! edge case testing is crucial for checking cases like where both inputs are equal or equal to//! special values such as `i128::MIN`, which is unlikely for the random fuzzer by itself to//! encounter. The randomized fuzz testing is specially designed to cover wide swaths of search//! space in as few iterations as possible. See `fuzz_values` in `builtins-test/tests/misc.rs` for//! an example.//! Some floating point tests are disabled for specific architectures, because they do not have//! correct rounding.overflowing_sum// Integer addition and subtraction is very simple, so 100 fuzzing passes should be plenty.int_addsubfloat_sumfloat_addsubutest_cortex_m_qemu// test runnerutest_macros// overrides `panic!`"aapcs"__aeabi_memclr4__aeabi_memset4_alignmentmemclr4// SAFETY: defined in  compiler-builtins__aeabi_memcpy__aeabi_memcpy4memcpy4threefoursixseveneightHInti256u256LOHI_SPLIThexu/// Print a `u256` as hex since we can't add format implementationswiden_u128widen_i128widen_mul_u128not_u128shr_u128cmp_f16cmp_f32cmp_f128float_comparisonscmp2float_comparisons_armrustc_apfloatFloatConverti_to_ff_to_if32_to_intf64_to_intf128_to_intf_to_f// makes configuration easiersdiv__divmoddi4__divmodsi4__divmodti4udiv__udivmoddi4__udivmodsi4__udivmodti4u128_divide_sparc/// Creates intensive test functions for division functions of a certain sizedivide_sparc// Division algorithms have by far the nastiest and largest number of edge cases, and experience shows// that sometimes 100_000 iterations of the random fuzzer is needed.// This is approximate because of issues related to// https://github.com/rust-lang/rust/issues/73920.// TODO how do we resolve this indeterminacy?// FIXME(i586): failure for powidf2int_ty/// Translate a byte size to a Rust type.castest_cas16foreach_bytesforeach_orderingforeach_casforeach_cas16foreach_swpforeach_ldaddforeach_ldclrforeach_ldeorforeach_ldset// so we can use pub(super)memcpy_3memcpy_10memcpy_bigmemmove_forwardmemmove_backwardmemset_zeromemset_nonzeromemcmp_eqmemcmp_negen_arrmemmove_forward_misaligned_nonaligned_startmemmove_forward_misaligned_aligned_startmemmove_forward_alignedmemmove_backward_misaligned_nonaligned_startmemmove_backward_misaligned_aligned_startmemmove_backward_alignedmemmove_misaligned_boundsmemset_backward_misaligned_nonaligned_startmemset_backward_misaligned_aligned_startmemset_backward_alignedfuzz_values/// Make sure that the the edge case tester and randomized tester don't break, and list examples of/// fuzz values for documentation purposes.int_muloverflowing_mul_u128int_overflowing_mul// FIXME(#616): Stop ignoring arches that don't have native support once fix for builtins is in// nightly.float_mul_f128float_mul_f128_ppcno_main// Ensure this `compiler_builtins` gets used, rather than the version injected from the sysroot.extendhfsfextendhfdfextendhftftruncsfhfaeabi_f2d// extendsfdf2extendsftfaeabi_f2iz// fixsfsiaeabi_f2lz// fixsfdifixsftiaeabi_f2uiz// fixunssfsiaeabi_f2ulz// fixunssfdifixunssftiaeabi_fadd// addsf3aeabi_fcmpeq// eqsf2aeabi_fcmpgt// gtsf2aeabi_fcmplt// ltsf2aeabi_fdiv// divsf3aeabi_fmul// mulsf3aeabi_fsub// subsf3aeabi_d2f// truncdfsf2aeabi_d2i// fixdfsiaeabi_d2l// fixdfdifixdftiaeabi_d2uiz// fixunsdfsiaeabi_d2ulz// fixunsdfdifixunsdftiaeabi_dadd// adddf3aeabi_dcmpeq// eqdf2aeabi_dcmpgt// gtdf2aeabi_dcmplt// ltdf2aeabi_ddiv// divdf3aeabi_dmul// muldf3aeabi_dsub// subdf3trunctfhftrunctfsftrunctfdffixtfsifixtfdifixtftifixunstfsifixunstfdifixunstftiaddtfeqtfgttflttfmultfdivtfsubtfaeabi_i2f// floatsisfaeabi_i2d// floatsidffloatsitfaeabi_idivaeabi_idivmodaeabi_l2f// floatdisfaeabi_l2d// floatdidffloatditfmulodi4aeabi_ldivmod// divdi3moddi3aeabi_lmul// muldi3floattisffloattidffloattitflshrti3divti3modti3aeabi_ui2f// floatunsisfaeabi_ui2d// floatunsidffloatunsitfaeabi_uidivaeabi_uidivmodaeabi_ul2f// floatundisfaeabi_ul2d// floatundidffloatunditfaeabi_uldivmod// udivdi3umoddi3floatuntisffloatuntidffloatuntitfmuloti4multi3ashlti3ashrti3udivti3umodti3/* f16 operations *//* f32 operations *//* f64 operations *//* f128 operations *//* i32 operations *//* i64 operations *//* i128 operations *//* u32 operations *//* u64 operations *//* u128 operations */// Every function in this module maps will be lowered to an intrinsic by LLVM, if the platform// doesn't have native support for the operation used in the function. ARM has a naming convention// convention for its intrinsics that's different from other architectures; that's why some function// have an additional comment: the function name is the ARM name for the intrinsic and the comment// in the non-ARM name for the intrinsic.something_with_a_dtor_start__aeabi_unwind_cpp_pr0// ARM targets need these symbols__aeabi_unwind_cpp_pr1_Unwind_Resume"eh_personality"eh_personalityrust_eh_personalityrust_eh_unwind_resumerust_eh_register_framesrust_eh_unregister_framesmingw_unwinding// By compiling this file we check that all the intrinsics we care about continue to be provided by// the `compiler_builtins` crate regardless of the changes we make to it. If we, by mistake, stop// compiling a C implementation and forget to implement that intrinsic in Rust, this file will fail// to link due to the missing intrinsic (symbol).// SAFETY: no definitions, only used for linkingconfigure_aliasesconfigure_libm/// Run configuration for `libm` since it is included directly./// Much of this is copied from `libm/configure.rs`.configure_check_cfg/// Emit directives for features we expect to support that aren't in `Cargo.toml`./// These are mostly cfg elements emitted by this `build.rs`.// SYMBOL -> PATH TO SOURCESources/// Compile intrinsics from the compiler-rt C source codebuild_aarch64_out_of_line_atomics_librariestriple_splitcargo_featuresreliable_f128reliable_f16// Configuration that is shared between `compiler_builtins` and `builtins_test`.HAVE_LSE_ATOMICS/// non-zero if the host supports LSE atomics./// Given a byte size and a register number, return a register of the appropriate size./// See <https://developer.arm.com/documentation/102374/0101/Registers-in-AArch64---general-purpose-registers>./// Given an atomic ordering, translate it to the acquire suffix for the lxdr aarch64 ASM instruction./// Given an atomic ordering, translate it to the release suffix for the stxr aarch64 ASM instruction./// Given a size in bytes, translate it to the byte suffix for an aarch64 ASM instruction.uxt/// Given a byte size, translate it to an Unsigned eXTend instruction/// with the correct semantics./// See <https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/UXTB--Unsigned-Extend-Byte--an-alias-of-UBFM->ldxr/// Given an atomic ordering and byte size, translate it to a LoaD eXclusive Register instruction/// See <https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/LDXR--Load-Exclusive-Register->.stxr/// Given an atomic ordering and byte size, translate it to a STore eXclusive Register instruction/// See <https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/STXR--Store-Exclusive-Register->.ldxp/// Given an atomic ordering and byte size, translate it to a LoaD eXclusive Pair of registers instruction/// See <https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/LDXP--Load-Exclusive-Pair-of-Registers->stxp/// Given an atomic ordering and byte size, translate it to a STore eXclusive Pair of registers instruction/// See <https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/STXP--Store-Exclusive-Pair-of-registers->.try_lse_op// If supported, perform the requested LSE op and return, or fallthrough.lse_mem_sfx// Translate memory ordering to the LSE suffixlse// Generate the aarch64 LSE operation for memory ordering and width/// See <https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicI8.html#method.compare_and_swap>.compare_and_swap_i128// i128 uses a completely different impl, so it has its own macro./// See <https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicI8.html#method.swap>.fetch_op/// See (e.g.) <https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicI8.html#method.fetch_add>.// We need a single macro to pass to `foreach_ldadd`./// Generate different macros for cas/swp/add/clr/eor/set so that we can test them separately./// Only CAS supports 16 bytes, and it has a different implementation that uses a different macro.//! Aarch64 targets have two possible implementations for atomics://! 1. Load-Locked, Store-Conditional (LL/SC), older and slower.//! 2. Large System Extensions (LSE), newer and faster.//! To avoid breaking backwards compat, C toolchains introduced a concept of "outlined atomics",//! where atomic operations call into the compiler runtime to dispatch between two depending on//! which is supported on the current CPU.//! See <https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/making-the-most-of-the-arm-architecture-in-gcc-10#:~:text=out%20of%20line%20atomics> for more discussion.//! Ported from `aarch64/lse.S` in LLVM's compiler-rt.//! Generate functions for each of the following symbols://!  __aarch64_casM_ORDER//!  __aarch64_swpN_ORDER//!  __aarch64_ldaddN_ORDER//!  __aarch64_ldclrN_ORDER//!  __aarch64_ldeorN_ORDER//!  __aarch64_ldsetN_ORDER//! for N = {1, 2, 4, 8}, M = {1, 2, 4, 8, 16}, ORDER = { relax, acq, rel, acq_rel }//! The original `lse.S` has some truly horrifying code that expects to be compiled multiple times with different constants.//! We do something similar, but with macro arguments.// avoid putting the macros into a submodule"custom"__aeabi_idiv// AAPCS is not always the correct ABI for these intrinsics, but we only use this to// forward another `__aeabi_` call so it doesn't matter.// Interfaces used by naked trampolines.// SAFETY: these are defined in compiler-builtins__kuser_cmpxchg// Kernel-provided user-mode helper functions:// https://www.kernel.org/doc/Documentation/arm/kernel_user_helpers.txt__kuser_memory_barrieralign_ptr// Word-align a pointerget_shift_mask// Calculate the shift and mask of a value inside an aligned wordextract_aligned// Extract a value from an aligned wordinsert_aligned// Insert a value into an aligned wordatomic_load_aligned/// Performs a relaxed atomic load of 4 bytes at `ptr`. Some of the bytes are allowed to be out of/// bounds as long as `size_of::<T>()` bytes are in bounds./// - `ptr` must be 4-aligned./// - `size_of::<T>()` must be at most 4./// - if `size_of::<T>() == 1`, `ptr` or `ptr` offset by 1, 2 or 3 bytes must be valid for a relaxed///   atomic read of 1 byte./// - if `size_of::<T>() == 2`, `ptr` or `ptr` offset by 2 bytes must be valid for a relaxed atomic///   read of 2 bytes./// - if `size_of::<T>() == 4`, `ptr` must be valid for a relaxed atomic read of 4 bytes.// FIXME: assert some of the preconditions in debug mode// Generic atomic read-modify-write operationatomic_cmpxchg// Generic atomic compare-exchange operationCastFromCastInto/// Returns `a + b`__addhf3__addsf3__adddf3__addtf3// Taken from LLVM config:// https://github.com/llvm/llvm-project/blob/0cf3c437c18ed27d9663d87804a9a15ff6874af2/compiler-rt/lib/builtins/fp_compare_impl.inc#L11-L27to_le_abito_ge_abiunord__lesf2__gesf2__unordsf2__eqsf2__ltsf2__nesf2__gtsf2__ledf2__gedf2__unorddf2__eqdf2__ltdf2__nedf2__gtdf2/// Calculate the exponent from the number of leading zeros./// Usually 1 is subtracted from this function's result, so that a mantissa with the implicit/// bit set can be added back later.m_adj/// Adjust a mantissa with dropped bits to perform correct rounding./// The dropped bits should be exactly the bits that get truncated (left-aligned), but they/// can be combined or compressed in some way that simplifies operations./// Shift the exponent to its position and add the mantissa./// If the mantissa has the implicit bit set, the exponent should be one less than its actual/// value to cancel it out.shift_f_lt_i/// Shift distance from a left-aligned integer to a smaller float.shift_f_gt_i/// Shift distance from an integer with `n` leading zeros to a smaller float./// Perform a signed operation as unsigned, then add the sign back.u32_to_f32_bitsu32_to_f64_bitsu64_to_f32_bitsu64_to_f64_bitsu128_to_f32_bitsu128_to_f64_bitsint_to_float/// Conversions from integers to floats./// The algorithm is explained here: <https://blog.m-ou.se/floats/>. It roughly does the following:/// - Calculate a base mantissa by shifting the integer into mantissa position. This gives us a///   mantissa _with the implicit bit set_!/// - Figure out if rounding needs to occur by classifying the bits that are to be truncated. Some///   patterns are used to simplify this. Adjust the mantissa with the result if needed./// - Calculate the exponent based on the base-2 logarithm of `i` (leading zeros). Subtract one./// - Shift the exponent and add the mantissa to create the final representation. Subtracting one///   from the exponent (above) accounts for the explicit bit being set in the mantissa./// # Terminology/// - `i`: the original integer/// - `i_m`: the integer, shifted fully left (no leading zeros)/// - `n`: number of leading zeroes/// - `e`: the resulting exponent. Usually 1 is subtracted to offset the mantissa implicit bit./// - `m_base`: the mantissa before adjusting for truncated bits. Implicit bit is usually set./// - `adj`: the bits that will be truncated, possibly compressed in some way./// - `m`: the resulting mantissa. Implicit bit is usually set.__floatunsisf__floatunsidf__floatundisf__floatundidf__floatuntisf__floatuntidf__floatunsitf__floatunditf__floatuntitf// Conversions from unsigned integers to floats.__floatsisf__floatsidf__floatdisf__floatdidf__floattisf__floattidf__floatsitf__floatditf__floattitf// Conversions from signed integers to floats.float_to_unsigned_int/// Generic float to unsigned int conversions.float_to_signed_int/// Generic float to signed int conversions.FnFooFnOobfloat_to_int_inner/// Float to int conversions, generic for both signed and unsigned./// - `fbits`: `abg(f)` bitcasted to an integer./// - `map_inbounds`: apply this transformation to integers that are within range (add the sign back)./// - `out_of_bounds`: return value when out of range for `I`.__fixunssfsi__fixunssfdi__fixunssfti__fixunsdfsi__fixunsdfdi__fixunsdfti__fixunstfsi__fixunstfdi__fixunstfti// Conversions from floats to unsigned integers.__fixsfsi__fixsfdi__fixsfti__fixdfsi__fixdfdi__fixdfti__fixtfsi__fixtfdi__fixtfti// Conversions from floats to signed integers.HalfRepDIntget_iterations/// Calculate the number of iterations required for a float type's precision./// This returns `(h, f)` where `h` is the number of iterations to be done using integers at half/// the float's bit width, and `f` is the number of iterations done using integers of the float's/// full width. This is further explained in the module documentation./// The initial estimate should have at least 8 bits of precision. If this is not true, results/// will be inaccurate.reciprocal_precision/// `u_n` for different precisions (with N-1 half-width iterations)./// W0 is the precision of C///   u_0 = (3/4 - 1/sqrt(2) + 2^-W0) * 2^HW/// Estimated with bc:///   define half1(un) { return 2.0 * (un + un^2) / 2.0^hw + 1.0; }///   define half2(un) { return 2.0 * un / 2.0^hw + 2.0; }///   define full1(un) { return 4.0 * (un + 3.01) / 2.0^hw + 2.0 * (un + 3.01)^2 + 4.0; }///   define full2(un) { return 4.0 * (un + 3.01) / 2.0^hw + 8.0; }///             | f32 (0 + 3) | f32 (2 + 1)  | f64 (3 + 1)  | f128 (4 + 1)/// u_0         | < 184224974 | < 2812.1     | < 184224974  | < 791240234244348797/// u_1         | < 15804007  | < 242.7      | < 15804007   | < 67877681371350440/// u_2         | < 116308    | < 2.81       | < 116308     | < 499533100252317/// u_3         | < 7.31      |              | < 7.31       | < 27054456580/// u_4         |             |              |              | < 80.4/// Final (U_N) | same as u_3 | < 72         | < 218        | < 13920/// Add 2 to `U_N` due to final decrement.c_hw/// The value of `C` adjusted to half width./// C is (3/4 + 1/sqrt(2)) - 1 truncated to W0 fractional bits as UQ0.HW with W0 being either/// 16 or 32 and W0 <= HW. That is, C is the aforementioned 3/4 + 1/sqrt(2) constant (from/// which b/2 is subtracted to obtain x0) wrapped to [0, 1) range.next_guess/// Perform one iteration at any width to approach `1/b`, given previous guess `x`. Returns/// the next `x` as a UQ0 number./// This is the `x_{n+1} = 2*x_n - b*x_n^2` algorithm, implemented as `x_n * (2 - b*x_n)`. It/// uses widening multiplication to calculate the result with necessary precision.__divsf3__divdf3__divtf3__divsf3vfp__divdf3vfp//! Floating point division routines.//! This module documentation gives an overview of the method used. More documentation is inline.//! # Relevant notation//! - `m_a`: the mantissa of `a`, in base 2//! - `p_a`: the exponent of `a`, in base 2. I.e. `a = m_a * 2^p_a`//! - `uqN` (e.g. `uq1`): this refers to Q notation for fixed-point numbers. UQ1.31 is an unsigned//!   fixed-point number with 1 integral bit, and 31 decimal bits. A `uqN` variable of type `uM`//!   will have N bits of integer and M-N bits of fraction.//! - `hw`: half width, i.e. for `f64` this will be a `u32`.//! - `x` is the best estimate of `1/m_b`//! # Method Overview//! Division routines must solve for `a / b`, which is `res = m_a*2^p_a / m_b*2^p_b`. The basic//! process is as follows://! - Rearange the exponent and significand to simplify the operations://!   `res = (m_a / m_b) * 2^{p_a - p_b}`.//! - Check for early exits (infinity, zero, etc).//! - If `a` or `b` are subnormal, normalize by shifting the mantissa and adjusting the exponent.//! - Set the implicit bit so math is correct.//! - Shift mantissa significant digits (with implicit bit) fully left such that fixed-point UQ1//!   or UQ0 numbers can be used for mantissa math. These will have greater precision than the//!   actual mantissa, which is important for correct rounding.//! - Calculate the reciprocal of `m_b`, `x`.//! - Use the reciprocal to multiply rather than divide: `res = m_a * x_b * 2^{p_a - p_b}`.//! - Reapply rounding.//! # Reciprocal calculation//! Calculating the reciprocal is the most complicated part of this process. It uses the//! [Newton-Raphson method], which picks an initial estimation (of the reciprocal) and performs//! a number of iterations to increase its precision.//! In general, Newton's method takes the following form://! `x_n` is a guess or the result of a previous iteration. Increasing `n` converges to the//! desired result.//! The result approaches a zero of `f(x)` by applying a correction to the previous gues.//! x_{n+1} = x_n - f(x_n) / f'(x_n)//! Applying this to find the reciprocal://! 1 / x = b//! Rearrange so we can solve by finding a zero//! 0 = (1 / x) - b = f(x)//! f'(x) = -x^{-2}//! x_{n+1} = 2*x_n - b*x_n^2//! This is a process that can be repeated to calculate the reciprocal with enough precision to//! achieve a correctly rounded result for the overall division operation. The maximum required//! number of iterations is known since precision doubles with each iteration.//! # Half-width operations//! Calculating the reciprocal requires widening multiplication and performing arithmetic on the//! results, meaning that emulated integer arithmetic on `u128` (for `f64`) and `u256` (for `f128`)//! gets used instead of native math.//! To make this more efficient, all but the final operation can be computed using half-width//! integers. For example, rather than computing four iterations using 128-bit integers for `f64`,//! we can instead perform three iterations using native 64-bit integers and only one final//! iteration using the full 128 bits.//! This works because of precision doubling. Some leeway is allowed here because the fixed-point//! number has more bits than the final mantissa will.//! [Newton-Raphson method]: https://en.wikipedia.org/wiki/Newton%27s_method/// Generic conversion from a narrower to a wider IEEE-754 floating-point type__extendsfdf2__extendhfsf2__gnu_h2f_ieee__extendhfdf2__extendhftf2__extendsftf2__extenddftf2__mulhf3__mulsf3__muldf3__multf3/// Returns `a` raised to the power `b`__powisf2__powidf2__powitf2__subhf3__subsf3__subdf3__subtf3/// Wrapper to extract the integer type half of the float's sizeOtherSignSignedInt/// A uint of the same width as the float/// A int of the same width as the floatExpInt/// An int capable of containing the exponent bits plus a sign bit. This is signed./// The bitwidth of the float type.SIG_BITS/// The bitwidth of the significand.EXP_BITS/// The bitwidth of the exponent.EXP_SAT/// The saturated (maximum bitpattern) value of the exponent, i.e. the infinite/// This is in the rightmost position, use `EXP_MASK` for the shifted value.EXP_BIAS/// The exponent bias value./// A mask for the sign bit.SIG_MASK/// A mask for the significand.IMPLICIT_BIT/// The implicit bit of the float format.EXP_MASK/// A mask for the exponent./// Returns `self` transmuted to `Self::Int`to_bits_signed/// Returns `self` transmuted to `Self::SignedInt`eq_repr/// Checks if two floats have the same bit representation. *Except* for NaNs! NaN can be/// represented in multiple different ways. This method returns `true` if two NaNs are/// compared./// Returns true if the sign is negative/// Returns the exponent, not adjusting for bias./// Returns the significand with no implicit bit (or the "fractional" part)imp_frac/// Returns the significand with implicit bit/// Returns a `Self::Int` transmuted back to `Self`/// Constructs a `Self` from its parts. Inputs are treated as bits and shifted into position./// Returns (normalized exponent, normalized significand)/// Returns if `self` is subnormal/// Trait for some basic operations on floatsfloat_impl__truncdfsf2__truncsfhf2__gnu_f2h_ieee__truncdfhf2__trunctfhf2__trunctfsf2__trunctfdf2uadduadd_oneusubUAddSubAddSubaddoAddosuboSubo__rust_i128_add__rust_i128_addo__rust_u128_add__rust_u128_addo__rust_i128_sub__rust_i128_subo__rust_u128_sub__rust_u128_suboWORD_LO_MASKWORD_HI_MASKWORD_FULL_MASKU128_LO_MASKU128_HI_MASK/// A 256-bit unsigned integer represented as 4 64-bit limbs./// Each limb is a native-endian number, but the array is little-limb-endian./// Reinterpret as a signed integer/// A 256-bit signed integer represented as 4 64-bit limbs./// Reinterpret as an unsigned integerSIGNEDimpl_commonwidenzero_widenzero_widen_mulwiden_mulwiden_hi//! Integers used for wide operations, larger than `u128`.r" Swaps bytes in 32-bit number"__bswapsi2r" Swaps bytes in 64-bit number"__bswapdi2r" Swaps bytes in 128-bit number"__bswapti2leading_zeros_defaultleading_zeros_riscv/// Returns the number of leading binary zeros in `x`.// The above method does not compile well on RISC-V (because of the lack of predicated// instructions), producing code with many branches or using an excessively long// branchless solution. This method takes advantage of the set-if-less-than instruction on// RISC-V that allows `(x >= power-of-two) as usize` to be branchless.r" Returns the number of leading binary zeros in `x`"__clzsi2__clzdi2__clzti2// Note: these functions happen to produce the correct `usize::leading_zeros(0)` value// without a explicit zero check. Zero is probably common enough that it could warrant// adding a zero check at the beginning, but `__clzsi2` has a precondition that `x != 0`.// Compilers will insert the check for zero in cases where it is needed.specialized_div_remaddsubmuloUMuloimpl_signed_muloi32_overflowing_muli64_overflowing_muli128_overflowing_mul__muldi3__multi3__mulosi4__mulodi4__muloti4__rust_i128_mulo__rust_u128_mulosdivmodsmodr" Returns `n / d` and sets `*rem = n % d`"r" Returns `n / d`"__divsi3// The `#[arm_aeabi_alias = __aeabi_idiv]` attribute cannot be made to work with `intrinsics!` in macrosr" Returns `n % d`"__modsi3__divdi3__moddi3// LLVM does not currently have a `__divmodti4` function, but GCC does__divti3__modti3ashl/// Returns `a << b`, requires `b < Self::BITS`Ashlashr/// Returns arithmetic `a >> b`, requires `b < Self::BITS`Ashrlshr/// Returns logical `a >> b`, requires `b < Self::BITS`Lshr__ashlsi3__ashldi3__ashlti3__ashrsi3__ashrdi3__ashrti3__lshrsi3__lshrdi3__lshrti3impl_asymmetric/// Creates an unsigned division function optimized for dividing integers with the same/// bitwidth as the largest operand in an asymmetrically sized division. For example, x86-64 has an/// assembly instruction that can divide a 128 bit integer by a 64 bit integer if the quotient fits/// in 64 bits. The 128 bit version of this algorithm would use that fast hardware division to/// construct a full 128 bit by 128 bit division.impl_binary_long/// Creates an unsigned division function that uses binary long division, designed for/// computer architectures without division instructions. These functions have good performance for/// microarchitectures with large branch miss penalties and architectures without the ability to/// predicate instructions. For architectures with predicated instructions, one of the algorithms/// described in the documentation of these functions probably has higher performance, and a custom/// assembly routine should be used instead.impl_delegate/// Creates an unsigned division function that uses a combination of hardware division and/// binary long division to divide integers larger than what hardware division by itself can do. This/// function is intended for microarchitectures that have division hardware, but not fast enough/// multiplication hardware for `impl_trifecta` to be faster./// Returns `n / d` and sets `*rem = n % d`./// This specialization exists because:///  - The LLVM backend for 32-bit SPARC cannot compile functions that return `(u128, u128)`,///    so we have to use an old fashioned `&mut u128` argument to return the remainder.///  - 64-bit SPARC does not have u64 * u64 => u128 widening multiplication, which makes the///    delegate algorithm strategy the only reasonably fast way to perform `u128` division.// used on SPARCnorm_shiftbinary_longtrifectaasymmetriczero_div_fn/// The behavior of all divisions by zero is controlled by this function. This function should be/// impossible to reach by Rust users, unless `compiler-builtins` public division functions or/// `core/std::unchecked_div/rem` are directly used without a zero check in front.USE_LZimpl_normalization_shiftr" Finds the shift left that the divisor `div` would need to be normalized for a binary"r" long division step with the dividend `duo`. NOTE: This function assumes that these edge"r" cases have been handled before reaching it:"r" `"r" if div == 0 {"r#"     panic!("attempt to divide by zero")"#r" if duo < div {"r"     return (0, duo)"r" Normalization is defined as (where `shl` is the output of this function):"r" if duo.leading_zeros() != (div << shl).leading_zeros() {"r"     // If the most significant bits of `duo` and `div << shl` are not in the same place,"r"     // then `div << shl` has one more leading zero than `duo`."r"     assert_eq!(duo.leading_zeros() + 1, (div << shl).leading_zeros());"r"     // Also, `2*(div << shl)` is not more than `duo` (otherwise the first division step"r"     // would not be able to clear the msb of `duo`)"r"     assert!(duo < (div << (shl + 1)));"r" if full_normalization {"r#"     // Some algorithms do not need "full" normalization, which means that `duo` is"#r"     // larger than `div << shl` when the most significant bits are aligned."r"     assert!((div << shl) <= duo);"r" Note: If the software bisection algorithm is being used in this function, it happens"r" that full normalization always occurs, so be careful that new algorithms are not"r" invisibly depending on this invariant when `full_normalization` is set to `false`."u32_normalization_shiftu64_normalization_shiftu64_by_u64_div_rem/// Divides `duo` by `div` and returns a tuple of the quotient and the remainder./// `checked_div` and `checked_rem` are used to avoid bringing in panic functionu128_by_u64_div_rem/// If the quotient does not fit in a `u64`, a floating point exception occurs./// If `div == 0`, then a division by zero exception occurs.r" Computes the quotient and remainder of `duo` divided by `div` and returns them as a"r" tuple."u128_div_rem// use `asymmetric` instead of `trifecta` on x86_64u32_by_u32_div_remu64_div_rem// When not on x86 and the pointer width is 64, use `binary_long`.u32_div_rem// 32 bits is the smallest division used by `compiler-builtins`, so we end with binary long division// TODO: when `unsafe_block_in_unsafe_fn` is stabilized, remove this// The functions are complex with many branches, and explicit// `return`s makes it clear where function exit points are// Clippy is confused by the complex configuration//! This `specialized_div_rem` module is originally from version 1.0.0 of the//! `specialized-div-rem` crate. Note that `for` loops with ranges are not used in this//! module, since unoptimized compilation may generate references to `memcpy`.//! The purpose of these macros is to easily change the both the division algorithm used//! for a given integer size and the half division used by that algorithm. The way//! functions call each other is also constructed such that linkers will find the chain of//! software and hardware divisions needed for every size of signed and unsigned division.//! For example, most target compilations do the following://!  - Many 128 bit division functions like `u128::wrapping_div` use//!    `std::intrinsics::unchecked_div`, which gets replaced by `__udivti3` because there//!    is not a 128 bit by 128 bit hardware division function in most architectures.//!    `__udivti3` uses `u128_div_rem` (this extra level of function calls exists because//!    `__umodti3` and `__udivmodti4` also exist, and `specialized_div_rem` supplies just//!    one function to calculate both the quotient and remainder. If configuration flags//!    enable it, `impl_trifecta!` defines `u128_div_rem` to use the trifecta algorithm,//!    which requires the half sized division `u64_by_u64_div_rem`. If the architecture//!    supplies a 64 bit hardware division instruction, `u64_by_u64_div_rem` will be//!    reduced to those instructions. Note that we do not specify the half size division//!    directly to be `__udivdi3`, because hardware division would never be introduced.//!  - If the architecture does not supply a 64 bit hardware division instruction, u64//!    divisions will use functions such as `__udivdi3`. This will call `u64_div_rem`//!    which is defined by `impl_delegate!`. The half division for this algorithm is//!    `u32_by_u32_div_rem` which in turn becomes hardware division instructions or more//!    software division algorithms.//!  - If the architecture does not supply a 32 bit hardware instruction, linkers will//!    look for `__udivsi3`. `impl_binary_long!` is used, but this  algorithm uses no half//!    division, so the chain of calls ends here.//! On some architectures like x86_64, an asymmetrically sized division is supplied, in//! which 128 bit numbers can be divided by 64 bit numbers. `impl_asymmetric!` is used to//! extend the 128 by 64 bit division to a full 128 by 128 bit division.// `allow(dead_code)` is used in various places, because the configuration code would otherwise be// ridiculously complex/// Creates a function used by some division algorithms to compute the "normalization shift".impl_trifecta/// Creates an unsigned division function optimized for division of integers with bitwidths/// larger than the largest hardware integer division supported. These functions use large radix/// division algorithms that require both fast division and very fast widening multiplication on the/// target microarchitecture. Otherwise, `impl_delegate` should be used instead./// Returns number of trailing binary zeros in `x`.r" Returns the number of trailing binary zeros in `x` (32 bit version)."__ctzsi2r" Returns the number of trailing binary zeros in `x` (64 bit version)."__ctzdi2r" Returns the number of trailing binary zeros in `x` (128 bit version)."__ctzti2/// Integer that is half the bit width of the integer this trait is implemented for/// Returns the low half of `self`/// Returns the high half of `self`lo_hi/// Returns the low and high halves of `self` as a tuplefrom_lo_hi/// Constructs an integer using lower and higher half parts/// Trait for integers twice the bit width of another integer. This is implemented for all/// primitives except for `u8`, because there is not a smaller primitive./// Integer that is double the bit width of the integer this trait is implemented for/// Widens (using default extension) the integer to have double bit width/// Widens (zero extension only) the integer to have double bit width. This is needed to get/// around problems with associated type bounds (such as `Int<Othersign: DInt>`) being unstable/// Widens the integer to have double bit width and shifts the integer into the higher bits/// Widening multiplication with zero widening. This cannot overflow./// Widening multiplication. This cannot overflow.// NB: some of the below methods could have default implementations (e.g. `widen_hi`), but for// unknown reasons this can cause infinite recursion when optimizations are disabled. See// <https://github.com/rust-lang/compiler-builtins/pull/707> for context./// Trait for integers half the bit width of another integer. This is implemented for all/// primitives except for `u128`, because it there is not a larger primitive.impl_d_intimpl_h_int__udivsi3__umodsi3__udivdi3__umoddi3__udivti3__umodti3no_builtinslibm_math// `libm` expects its `support` module to be available in the crate root.probestack// `mem::swap` cannot be used because it may generate references to memcpy in unoptimized code.// Support compiling on both stage0 and stage1 which may differ in supported stable features.// By default, disallow this as it is forbidden in edition 2024. There is a lot of unsafe code to// be migrated, however, so exceptions exist.// We disable #[no_mangle] for tests so that we can verify the test results// against the native compiler-rt implementations of the builtins.// NOTE cfg(all(feature = "c", ..)) indicate that compiler-rt provides an arch optimized// implementation of that intrinsic and we'll prefer to use that// NOTE(aapcs, aeabi, arm) ARM targets use intrinsics named __aeabi_* instead of the intrinsics// that follow "x86 naming convention" (e.g. addsf3). Those aeabi intrinsics must adhere to the// AAPCS calling convention (`extern "aapcs"`) because that's how LLVM will call them.// Support cfg_attr:// Same as above but for unsafe.// Right now there's a bunch of architecture-optimized intrinsics in the// stock compiler-rt implementation. Not all of these have been ported over// to Rust yet so when the `c` feature of this crate is enabled we fall back// to the architecture-specific versions which should be more optimized. The// purpose of this macro is to easily allow specifying this.// The `#[maybe_use_optimized_c_shim]` attribute indicates that this// intrinsic may have an optimized C version. In these situations the build// script, if the C code is enabled and compiled, will emit a cfg directive// to get passed to rustc for our compilation. If that cfg is set we skip// the Rust implementation, but if the attribute is not enabled then we// compile in the Rust implementation.// We recognize the `#[aapcs_on_arm]` attribute here and generate the// same intrinsic but force it to have the `"aapcs"` calling convention on// ARM and `"C"` elsewhere.// Like aapcs above we recognize an attribute for the "unadjusted" abi on// win64 for some methods.// `arm_aeabi_alias` would conflict with `f16_apple_{arg,ret}_abi` not handled here. Avoid macro ambiguity by combining in a// single `#[]`.// On x86 (32-bit and 64-bit) Apple platforms, `f16` is passed and returned like a `u16` unless// the builtin involves `f128`.// A bunch of intrinsics on ARM are aliased in the standard compiler-rt// build under `__aeabi_*` aliases, and LLVM will call these instead of the// original function. The aliasing here is used to generate these symbols in// the object file.// PowerPC usually uses `kf` rather than `tf` for `f128`. This is just an easy// way to add an alias on those targets.// C mem* functions are only generated when the "mem" feature is enabled.// Naked functions are special: we can't generate wrappers for them since// they use a custom calling convention.// This is the final catch-all rule. At this point we generate an// intrinsic with a conditional `#[no_mangle]` directive to avoid// interfering with duplicate symbols and whatnot during testing.// The implementation is placed in a separate module, to take advantage// of the fact that rustc partitions functions into code generation// units based on module they are defined in. As a result we will have// a separate object file for each intrinsic. For further details see// corresponding PR in rustc https://github.com/rust-lang/rust/pull/70846// After the intrinsic is defined we just continue with the rest of the// input we were given./// The "main macro" used for defining intrinsics./// The compiler-builtins library is super platform-specific with tons of crazy/// little tweaks for various platforms. As a result it *could* involve a lot of/// #[cfg] and macro soup, but the intention is that this macro alleviates a lot/// of that complexity. Ideally this macro has all the weird ABI things/// platforms need and elsewhere in this library it just looks like normal Rust/// All intrinsics functions are marked with #[linkage = "weak"] when/// `not(windows) and not(target_vendor = "apple")`./// `weak` linkage attribute is used so that these functions can be replaced/// by another implementation at link time. This is particularly useful for mixed/// Rust/C++ binaries that want to use the C++ intrinsics, otherwise linking against/// the Rust stdlib will replace those from the compiler-rt library./// This macro is structured to be invoked with a bunch of functions that looks///     intrinsics! {///         pub extern "C" fn foo(a: i32) -> u32 {///         #[nonstandard_attribute]///         pub extern "C" fn bar(a: i32) -> u32 {/// Each function is defined in a manner that looks like a normal Rust function./// The macro then accepts a few nonstandard attributes that can decorate/// various functions. Each of the attributes is documented below with what it/// can do, and each of them slightly tweaks how further expansion happens./// A quick overview of attributes supported right now are:/// * `maybe_use_optimized_c_shim` - indicates that the Rust implementation is///   ignored if an optimized C version was compiled./// * `aapcs_on_arm` - forces the ABI of the function to be `"aapcs"` on ARM and///   the specified ABI everywhere else./// * `unadjusted_on_win64` - like `aapcs_on_arm` this switches to the///   `"unadjusted"` abi on Win64 and the specified abi elsewhere./// * `arm_aeabi_alias` - handles the "aliasing" of various intrinsics on ARM///   their otherwise typical names to other prefixed ones./// * `ppc_alias` - changes the name of the symbol on PowerPC platforms without///   changing any other behavior. This is mostly for `f128`, which is `tf` on///   most platforms but `kf` on PowerPC.//! Macros shared throughout the compiler-builtins implementation"../../../libm/src/math/mod.rs"libm_intrinsicsfmaximumfmaximumffminimumfminimumfroundevenroundevenf// Windows and MacOS do not yet expose roundeven and IEEE 754-2019 `maximum` / `minimum`,// however, so we still provide a fallback./* Weak linkage is unreliable on Windows and Apple, so we don't expose symbols that we know
     * the system libc provides in order to avoid conflicts. */full_availability/// This set of functions is well tested in `libm` and known to provide similar performance to/// system `libm`, as well as the same or better accuracy.// In C and Rust it is UB to read or write to usize::MAX because if an allocation extends to the// last byte of address space (there must be an allocation to do the read or write), in C computing// its one-past-the-end pointer would be equal to NULL and in Rust computing the address of a// trailing ZST member with a safe place projection would wrap (place projection address computation// is non-wrapping).// However, some embedded systems have special memory at usize::MAX, and need to access that// memory. If they do that with the intrinsics provided by compiler-builtins (such as memcpy!), the// ptr::add in these loops will wrap. And if compiler-builtins is compiled with cfg(ub_checks),// this will fail a UB check at runtime.// Since this scenario is UB, we are within our rights hit this check and halt execution...// But we are also within our rights to try to make it work.// We use wrapping_add/wrapping_sub for pointer arithmetic in this module in an attempt to support// this use. Of course this is not a guarantee that such use will work, it just means that this// crate doing wrapping pointer arithmetic with a method that must not wrap won't be the problem if// something does go wrong at runtime.WORD_MASKWORD_COPY_THRESHOLD// If the number of bytes involved exceed this threshold we will opt in word-wise copy.// The value here selected is max(2 * WORD_SIZE, 16):// * We need at least 2 * WORD_SIZE bytes to guarantee that at least 1 word will be copied through//   word-wise copy.// * The word-wise copy logic needs to perform some checks so it has some small overhead.//   ensures that even on 32-bit platforms we have copied at least 8 bytes through//   word-wise copy so the saving of word-wise copy outweighs the fixed overhead.read_usize_unalignedload_chunk_aligned/// Loads a `T`-sized chunk from `src` into `dst` at offset `offset`, if that does not exceed/// `load_sz`. The offset pointers must both be `T`-aligned. Returns the new offset, advanced by the/// chunk size if a load happened.load_aligned_partial/// Load `load_sz` many bytes from `src`, which must be usize-aligned. Acts as if we did a `usize`/// read with the out-of-bounds part filled with 0s./// `load_sz` be strictly less than `WORD_SIZE`.load_aligned_end_partial/// Load `load_sz` many bytes from `src.wrapping_byte_add(WORD_SIZE - load_sz)`. `src` must be/// `usize`-aligned. The bytes are returned as the *last* bytes of the return value, i.e., this acts/// as if we had done a `usize` read from `src`, with the out-of-bounds part filled with 0s.copy_forwardcopy_backwardcompare_bytesc_string_length// memcpy/memmove/memset have optimized implementations on some architectures// Trying to satisfy clippy here is hopeless// FIXME(e2024): this eventually needs to be removed.rep_param/// Determine optimal parameters for a `rep` instruction.// On most modern Intel and AMD processors, "rep movsq" and "rep stosq" have// been enhanced to perform better than an simple qword loop, making them ideal// for implementing memcpy/memset. Note that "rep cmps" has received no such// enhancement, so it is not used to implement memcmp.// On certain recent Intel processors, "rep movsb" and "rep stosb" have been// further enhanced to automatically select the best microarchitectural// implementation based on length and alignment. See the following features from// the "Intel® 64 and IA-32 Architectures Optimization Reference Manual"://  - ERMSB - Enhanced REP MOVSB and STOSB (Ivy Bridge and later)//  - FSRM - Fast Short REP MOV (Ice Lake and later)//  - Fast Zero-Length MOVSB (On no current hardware)//  - Fast Short STOSB (On no current hardware)// To simplify things, we switch to using the byte-based variants if the "ermsb"// feature is present at compile-time. We don't bother detecting other features.// Note that ERMSB does not enhance the backwards (DF=1) "rep movsb".// In order to process more than on byte simultaneously when executing strlen,// two things must be considered:// * An n byte read with an n-byte aligned address will never cross//   a page boundary and will always succeed. Any smaller alignment//   may result in a read that will cross a page boundary, which may//   trigger an access violation.// * Surface Rust considers any kind of out-of-bounds read as undefined//   behaviour. To dodge this, memory access operations are written//   using inline assembly.__rust_probestack// Our goal here is to touch each page between %rsp+8 and %rsp+8-%rax,// ensuring that if any pages are unmapped we'll make a page fault.// The ABI here is that the stack frame size is located in `%rax`. Upon// return we're not supposed to modify `%rsp` or `%rax`.// Copyright 2017 The Rust Project Developers. See the COPYRIGHT//! This module defines the `__rust_probestack` intrinsic which is used in the//! implementation of "stack probes" on certain platforms.//! The purpose of a stack probe is to provide a static guarantee that if a//! thread has a guard page then a stack overflow is guaranteed to hit that//! guard page. If a function did not have a stack probe then there's a risk of//! having a stack frame *larger* than the guard page, so a function call could//! skip over the guard page entirely and then later hit maybe the heap or//! another thread, possibly leading to security vulnerabilities such as [The//! Stack Clash], for example.//! [The Stack Clash]: https://blog.qualys.com/securitylabs/2017/06/19/the-stack-clash//! The `__rust_probestack` is called in the prologue of functions whose stack//! size is larger than the guard page, for example larger than 4096 bytes on//! x86. This function is then responsible for "touching" all pages relevant to//! the stack to ensure that that if any of them are the guard page we'll hit//! them guaranteed.//! The precise ABI for how this function operates is defined by LLVM. There's//! no real documentation as to what this is, so you'd basically need to read//! the LLVM source code for reference. Often though the test cases can be//! illuminating as to the ABI that's generated, or just looking at the output//! of `llc`.//! Note that `#[naked]` is typically used here for the stack probe because the//! ABI corresponds to no actual ABI.//! Finally it's worth noting that at the time of this writing LLVM only has//! support for stack probes on x86 and x86_64. There's no support for stack//! probes on any other architecture like ARM or PowerPC64. LLVM I'm sure would//! be more than welcome to accept such a change!// Windows and Cygwin already has builtins to do this.// We only define stack probing for these architectures today.// NOTE These functions are implemented using assembly because they use a custom// calling convention which can't be implemented using a normal Rust function// NOTE These functions are never mangled as they are not tested against compiler-rt___chkstk_ms_fltused// HACK(https://github.com/rust-lang/rust/issues/62785): x86_64-unknown-uefi needs special LLVM// support unless we emit the _fltusedpm2ALL_OPERATIONSfunction_enum/// Implement `#[function_enum]`, see documentation in `lib.rs`.base_name_enum/// Implement `#[base_name_enum]`, see documentation in `lib.rs`.expect_empty_enum/// Verify that an enum is empty, otherwise return an errorInvocationStructuredInputFloatTyMathOpInfoKNOWN_TYPES/// Populate an enum with a variant representing function. Names are in upper camel case./// Applied to an empty enum. Expects one attribute `#[function_enum(BaseName)]` that provides/// the name of the `BaseName` enum./// Create an enum representing all possible base names, with names in upper camel case./// Applied to an empty enum.for_each_function/// Do something for each function present in this crate./// Takes a callback macro and invokes it multiple times, once for each function that/// this crate exports. This makes it easy to create generic tests, benchmarks, or other checks/// and apply it to each symbol./// Additionally, the `extra` and `fn_extra` patterns can make use of magic identifiers:/// - `MACRO_FN_NAME`: gets replaced with the name of the function on that invocation./// - `MACRO_FN_NAME_NORMALIZED`: similar to the above, but removes sufixes so e.g. `sinf` becomes///   `sin`, `cosf128` becomes `cos`, etc./// Invoke as:/// // Macro that is invoked once per function/// macro_rules! callback_macro {///         // Name of that function///         fn_name: $fn_name:ident,///         // The basic float type for this function (e.g. `f32`, `f64`)///         FTy: $FTy:ty,///         // Function signature of the C version (e.g. `fn(f32, &mut f32) -> f32`)///         CFn: $CFn:ty,///         // A tuple representing the C version's arguments (e.g. `(f32, &mut f32)`)///         CArgs: $CArgs:ty,///         // The C version's return type (e.g. `f32`)///         CRet: $CRet:ty,///         // Function signature of the Rust version (e.g. `fn(f32) -> (f32, f32)`)///         RustFn: $RustFn:ty,///         // A tuple representing the Rust version's arguments (e.g. `(f32,)`)///         RustArgs: $RustArgs:ty,///         // The Rust version's return type (e.g. `(f32, f32)`)///         RustRet: $RustRet:ty,///         // True if this is part of `libm`'s public API///         public: $public:expr,///         // Attributes for the current function, if any///         attrs: [$($attr:meta),*],///         // Extra tokens passed directly (if any)///         extra: [$extra:ident],///         // Extra function-tokens passed directly (if any)///         fn_extra: $fn_extra:expr,///     ) => { };/// // All fields except for `callback` are optional./// libm_macros::for_each_function! {///     // The macro to invoke as a callback///     callback: callback_macro,///     // Which types to include either as a list (`[CFn, RustFn, RustArgs]`) or "all"///     emit_types: all,///     // Functions to skip, i.e. `callback` shouldn't be called at all for these.///     skip: [sin, cos],///     // Attributes passed as `attrs` for specific functions. For example, here the invocation///     // with `sinf` and that with `cosf` will both get `meta1` and `meta2`, but no others will.///     // Note that `f16_enabled` and `f128_enabled` will always get emitted regardless of whether///     // or not this is specified.///     attributes: [///         #[meta1]///         #[meta2]///         [sinf, cosf],///     // Any tokens that should be passed directly to all invocations of the callback. This can///     // be used to pass local variables or other things the macro needs access to.///     extra: [foo],///     // Similar to `extra`, but allow providing a pattern for only specific functions. Uses///     // a simplified match-like syntax.///     fn_extra: match MACRO_FN_NAME {///         hypot | hypotf => |x| x.hypot(),///         // `ALL_*` magic matchers also work to extract specific types///         ALL_F64 => |x| x,///         // The default pattern gets applied to everything that did not match///         _ => |x| x,/// Check for any input that is structurally correct but has other problems./// Returns the list of function names that we should expand for./// Expand our structured macro input into invocations of the callback macro.fn_namenorm_name/// Remove the trailing `f` or `f128` to makeMacroReplace/// Visitor to replace "magic" identifiers that we allow: `MACRO_FN_NAME` and/// `MACRO_FN_NAME_NORMALIZED`.visit_ident_inner/// Return the unsuffixed version of a function name; e.g. `abs` and `absf` both return `abs`,/// `lgamma_r` and `lgammaf_r` both return `lgamma_r`./// The input to our macro; just a list of `field: value` items._sep/// A `key: expression` mapping with nothing else. Basically a simplified `syn::Field`./// Macro to invoke once per functionemit_types/// Whether or not to provide `CFn` `CArgs` `RustFn` etc. This is really only needed/// once for crate to set up the main trait./// Skip these functionsskip_f16_f128/// If true, omit f16 and f128 functions that aren't present in other libraries.only/// Invoke only for these functionsAttributeMap/// Attributes that get applied to specific functions/// Extra expressions to pass to all invocations of the macrofn_extra/// Per-function extra expressions to pass to the macroemit_types_span// For diagnosticsonly_spanfn_extra_span/// The input provided to our proc macro, after parsing into the form we expect.extract_fn_extra_fieldexpect_empty_attrsexpect_field/// Extract a named field from a map, raising an error if it doesn't exist.expect_ident/// Coerce an expression into a simple identifier.expect_litbool/// Coerce an expression into a simple keyword.parse_ident_or_array/// Parse either a single identifier (`foo`) or an array of identifiers (`[foo, bar, baz]`).parse_expr_array/// Parse an array of expressions.parse_ident_array/// Parse an array of idents, e.g. `[foo, bar, baz]`.parse_ident_pat/// Parse an pattern of idents, specifically `(foo | bar | baz)`./// A mapping of attributes to identifiers (just a simplified `Expr`)./// Expressed as:/// #[meta1]/// #[meta2]/// [foo, bar, baz]LazyLockfloat_tyrust_sigc_sigfn_listNestedOpALL_OPERATIONS_NESTED/// We need a flat list to work with most of the time, but define things as a more convenient/// nested list.CIntMutF16MutF32MutF64MutF128MutI32MutCInt/// A type used in a function signature./// A subset of [`Ty`] representing only floats.returns/// Representation of e.g. `(f32, f32) -> f32`/// Function signature for C implementations/// Function signature for Rust implementations/// True if part of libm's public API/// Combined information about a function implementation./// A flat representation of `ALL_FUNCTIONS`./* List of all functions that is shared between `libm-macros` and `libm-test`. */libm_macrosbasic_no_extra// Test with no extra, no skip, and no attributestest_basic_no_extra// Test that only workstest_onlyspecified_types// Test that we can specify a couple types to emittest_emit_typestest_skip_f16_f128test_fn_extra_expansion// `STATUS_DLL_NOT_FOUND` on i686 MinGW, not worth looking into.BaseNamemath_op// Replicate the structure that we have in `libm-test`LIB_NAME/// Static library that will be builtMULTIPLE_SYMBOLS/// Files that have more than one symbol. Map of file names to the symbols defined in that file.manifest_dirmusl_dirmusl_archtarget_familiestarget_stringbuild_musl_math/// Build musl math symbols to a static libraryfind_math_source/// Build a map of `name -> path`. `name` is typically the symbol name, but this doesn't account/// for files that provide multiple symbols.validate_archive_symbols/// Make sure we don't have something like a loose unprefixed `_cos` called somewhere, which could/// wind up linking to system libraries rather than the built musl library./// Macro for creating bindings and exposing a safe function (since the implementations have no/// preconditions). Included functions must have correct signatures, otherwise this will be/// unsound.CallTest/// Just verify that we are able to call the function.impl_calltesttest_support//! Bindings to Musl math functions (these are built in `build.rs`).//! This is needed for tests on targets that require a `#[panic_handler]` functionObjFileObjResultCHECK_LIBRARIESCHECK_EXTENSIONSrun_build_and_checkcheck_pathshost_targetexec_cargo_with_args/// Run `cargo build` with the provided additional arguments, collecting the list of created/// libraries.SymInfo/// Information collected from `object`, for convenience.// only for printingverify_no_duplicatesBinFile/// Ensure that the same global symbol isn't defined in multiple object files within an archive./// Note that this will also locate cases where a symbol is weakly defined in more than one place./// Technically there are no linker errors that will come from this, but it keeps our binary more/// straightforward and saves some distribution size.verify_core_symbols/// Ensure that there are no references to symbols from `core` that aren't also (somehow) defined./// Thin wrapper for owning data used by `object`.as_archive_fileas_obj_filefor_each_object/// For a given archive, do something with each object file. For an object file, do/// something once.for_each_symbol/// D something with each symbol in an archive or object file.//! Tool used by CI to inspect compiler-builtins archives and help ensure we won't run into any//! linking errors."../../libm/configure.rs"Hexfhf32hf64libm_testmpfloatMpOpMathOpTupleCallrugazAzhandle_calldo_eval/// Evaluate the specified operation with a given basis.ParseTuple/// Parse a tuple from a space-delimited string.impl_parse_tupleimpl_parse_tuple_via_rug// Fallback for when Rug is not built.FromStrRadix/// Try to parse the number, printing a nice message on failure.parse_rug/// Try to parse the float type going via `rug`, for `f16` and `f128` which don't yet implement/// `FromStr`.strip_radix_prefix//! Helper CLI utility for common tasks.emit_libm_config/// Libm gets most config options made available.emit_test_config/// Tests don't need most feature-related config.emit_intrinsics_cfg/// Simplify the feature logic for enabling intrinsics so code only needs to use/// `cfg(intrinsics_enabled)`.emit_arch_cfg/// Simplify the feature logic for enabling arch-specific features so code only needs to use/// `cfg(arch_enabled)`.emit_optimization_cfg/// Some tests are extremely slow. Emit a config option based on optimization level.emit_cfg_shorthands/// Provide an alias for common longer config combinations.emit_cfg_env/// Reemit config that we make use of for test logging.emit_f16_f128_cfg/// Configure whether or not `f16` and `f128` support should be enabled.// Configuration shared with both libm and libm-test// verify-apilist-start// verify-apilist-endrintf16sqrtf16//! Architecture-specific support for aarch64 with neon.// NB: `frintx` is technically the correct instruction for C's `rint`. However, in Rust (and LLVM// by default), `rint` is identical to `roundeven` (no fpenv interaction) so we use the// side-effect-free `frintn`.// In general, C code that calls Rust's libm should assume that fpenv is ignored.//! Architecture-specific support for x86-32 without SSE2//! We use an alternative implementation on x86, because the//! main implementation fails with the x87 FPU used by//! debian i386, probably due to excess precision issues.//! See https://github.com/rust-lang/compiler-builtins/pull/976 for discussion on why these//! functions are implemented in this way.// There are certain architecture-specific implementations that are needed for correctness// even with `force-soft-float`. These are configured here.//! Architecture-specific routines and operations.//! LLVM will already optimize calls to some of these in cases that there are hardware//! instructions. Providing an implementation here just ensures that the faster implementation//! is used when calling the function directly. This helps anyone who uses `libm` directly, as//! well as improving things when these routines are called as part of other implementations.//! Wasm has builtins for simple float operations. Use the unstable `core::arch` intrinsics which//! are significantly faster than soft float operations.__cpuid_count_xgetbvfeature_detectget_or_init_flags_cacheunique_maskscpu_flags/// CPU features that get cached (doesn't correlate to anything on the CPU).get_cpu_features/// Get CPU features, loading from a cache if available.load_x86_features/// Read from cpuid and translate to a `Flags` instance, using `cpu_flags`./// Implementation is taken from [std-detect][std-detect]./// [std-detect]: https://github.com/rust-lang/stdarch/blob/690b3a6334d482874163bd6fcef408e0518febe9/crates/std_detect/src/detect/os/x86.rs#L142check_matches_std// Using runtime feature detection requires atomics. Currently there are no x86 targets// that support sse but not `AtomicPtr`.select_oncefma_with_fma/// Must have +fma available.fmaf_with_fmafma_with_fma4/// Must have +fma4 available.fmaf_with_fma4fma_fallbackfmaf_fallback//! Use assembly fma if the `fma` or `fma4` feature is detected at runtime.// FIXME: the `select_implementation` macro should handle arch implementations that want// to use the fallback, so we don't need to recreate the body.//! Architecture-specific support for x86-32 and x86-64 with SSE2FpResult/// Compute the cube root of the argument.cbrt_round/* SPDX-License-Identifier: MIT *//* origin: core-math/src/binary64/cbrt/cbrt.c
 * Copyright (c) 2021-2022 Alexei Sibidanov.
 * Ported to Rust in 2025 by Trevor Gross.
 *//// The cosine of `x` (f64)./// `x` is specified in radians./// The cosine of `x` (f32)./// Calculates 10 raised to the power of `x` (f64)./// Calculates 10 raised to the power of `x` (f32)./// * x - y if x > y, or/// * +0    if x <= y, or/// * NAN   if either argument is NAN./// Computes `(x*y)+z`, rounded as one ternary operation (i.e. calculated with infinite precision)./// Fused multiply add (f64)/* origin: musl src/math/fma.c, fmaf.c Ported to generic Rust algorithm in 2025, TG. *//// Return the lesser of two arguments or, if either argument is NaN, the other argument./// This coincides with IEEE 754-2011 `minNum`. The result disregards signed zero (meaning if/// the inputs are -0.0 and +0.0, either may be returned)./// Return the greater of two arguments or, if either argument is NaN, the other argument./// This coincides with IEEE 754-2011 `maxNum`. The result disregards signed zero (meaning if/// This coincides with IEEE 754-2019 `minimum`. The result orders -0.0 < 0.0./// This coincides with IEEE 754-2019 `maximum`. The result orders -0.0 < 0.0.fminimum_numf/// Return the lesser of two arguments or, if either argument is NaN, NaN./// This coincides with IEEE 754-2019 `minimumNumber`. The result orders -0.0 < 0.0.fminimum_numfmaximum_numf/// Return the greater of two arguments or, if either argument is NaN, NaN./// This coincides with IEEE 754-2019 `maximumNumber`. The result orders -0.0 < 0.0.fmaximum_num/// Calculate the remainder of `x / y`, the precise result of `x - trunc(x / y) * y`.IntTyceil_status/* origin: musl src/math/ceilf.c *///! Generic `ceil` algorithm.//! Note that this uses the algorithm from musl's `ceilf` rather than `ceil` or `ceill` because//! performance seems to be better (based on icount) and it does not seem to experience rounding//! errors on i386./// Copy the sign of `y` to `x`./// Absolute value.floor_status/* SPDX-License-Identifier: MIT
 * origin: musl src/math/floor.c *///! Generic `floor` algorithm.//! Note that this uses the algorithm from musl's `floorf` rather than `floor` or `floorl` becausefma_round/// Fused multiply-add that works when there is not a larger float size available. Computes/// `(x * y) + z`./// Normalized significand with one guard bit, unsigned./// Exponent of the mantissa such that `m * 2^e = x`. Accounts for the shift in the mantissa/// and the guard bit; that is, 1.0 will normalize as `m = 1 << 53` and `e = -53`.Norm/// Representation of `F` that has handled subnormals.EXP_UNBIAS/// Unbias the exponent and account for the mantissa's precision, including the guard bit.ZERO_INF_NAN/// Values greater than this had a saturated exponent (infinity or NaN), OR were zero and we/// adjusted the exponent such that it exceeds this threashold.is_zero_nan_inf/// True if the value was zero, infinity, or NaN./// The only value we have/* origin: musl src/math/fma.c. Ported to generic Rust algorithm in 2025, TG. */DFloatHFloatfma_wide_round/// Fma implementation when a hardware-backed larger float type is available. For `f32` and `f64`,/// `f64` has enough precision to represent the `f32` in its entirety, except for double rounding./* SPDX-License-Identifier: MIT OR Apache-2.0 *///! IEEE 754-2011 `maxNum`. This has been superseded by IEEE 754-2019 `maximumNumber`.//! Per the spec, returns the canonicalized result of://! - `x` if `x > y`//! - `y` if `y > x`//! - The other number if one is NaN//! - Otherwise, either `x` or `y`, canonicalized//! - -0.0 and +0.0 may be disregarded (unlike newer operations)//! Excluded from our implementation is sNaN handling.//! More on the differences: [link].//! [link]: https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/minNum_maxNum_Removal_Demotion_v3.pdf//! IEEE 754-2019 `maximum`.//! - +0.0 if x and y are zero with opposite signs//! - qNaN if either operation is NaN//! IEEE 754-2019 `maximumNumber`.//! Per the spec, returns://! - Either `x` or `y` if `x == y` and the signs are the same//! - Non-NaN if one operand is NaN//! - qNaN if both operands are NaNx//! IEEE 754-2008 `minNum`. This has been superseded by IEEE 754-2019 `minimumNumber`.//! - `x` if `x < y`//! - `y` if `y < x`//! IEEE 754-2019 `minimum`.//! - -0.0 if x and y are zero with opposite signsinto_sig_exp/// Given the bits of a finite float, return a tuple of///  - the mantissa with the implicit bit (0 if subnormal, 1 otherwise)///  - the additional exponent past 1, (0 for subnormal, 0 or more otherwise)/// Compute the remainder `(x * 2.pow(e)) % y` without overflow.fma_widerint_round// Note: generic functions are marked `#[inline]` because, even though generic functions are// typically inlined, this does not seem to always be the case./// IEEE 754-2019 `roundToIntegralExact`, which respects rounding mode and raises inexact if/// applicable./* origin: musl src/math/rint.c *//// Scale the exponent./// From N3220:/// > The scalbn and scalbln functions compute `x * b^n`, where `b = FLT_RADIX` if the return type/// > of the function is a standard floating type, or `b = 10` if the return type of the function/// > is a decimal floating type. A range error occurs for some finite x, depending on n./// > [...]/// > * `scalbn(±0, n)` returns `±0`./// > * `scalbn(x, 0)` returns `x`./// > * `scalbn(±∞, n)` returns `±∞`./// > If the calculation does not overflow or underflow, the returned value is exact and/// > independent of the current rounding direction mode.SqrtHelperISet2ISet1sqrt_roundwmulh/// Multiply at the wider integer size, returning the high half.goldschmidt/// Perform `count` goldschmidt iterations, returning `(r_u0, s_u?)`./// - `r_u0` is the reciprocal `r ~ 1 / sqrt(m)`, as U0./// - `s_u2` is the square root, `s ~ sqrt(m)`, as U2./// - `count` is the number of iterations to perform./// - `final_set` should be true if this is the last round (same-sized integer). If so, the///   returned `s` will be U3, for later shifting. Otherwise, the returned `s` is U2./// Note that performance relies on the optimizer being able to unroll these loops (reasonably/// trivial, `count` is a constant when called).Shifted/// The exponent has been shifted to a `u32` and is LSB-aligned.NoShift/// The exponent is in its natural position in integer repr./// Representation of whether we shift the exponent into a `u32`, or modify it in place to save/// the shift operations./// Integer for the first set of rounds. If unused, set to the same type as the next set./// Integer for the second set of rounds. If unused, set to the same type as the next set.SET1_ROUNDS/// Number of rounds at `ISet1`.SET2_ROUNDS/// Number of rounds at `ISet2`.FINAL_ROUNDS/// Number of rounds at `Self::Int`./// Size-specific constants related to the square root routine.// unusedRSQRT_TAB/// A U0.16 representation of `1/sqrt(x)`./// The index is a 7-bit number consisting of a single exponent bit and 6 bits of significand./* origin: musl src/math/sqrt.c. Ported to generic Rust algorithm in 2025, TG. *///! Generic square root algorithm.//! This routine operates around `m_u2`, a U.2 (fixed point with two integral bits) mantissa//! within the range [1, 4). A table lookup provides an initial estimate, then goldschmidt//! iterations at various widths are used to approach the real values.//! For the iterations, `r` is a U0 number that approaches `1/sqrt(m_u2)`, and `s` is a U2 number//! that approaches `sqrt(m_u2)`. Recall that m_u2 ∈ [1, 4).//! With Newton-Raphson iterations, this would be://! - `w = r * r           w ~ 1 / m`//! - `u = 3 - m * w       u ~ 3 - m * w = 3 - m / m = 2`//! - `r = r * u / 2       r ~ r`//! (Note that the righthand column does not show anything analytically meaningful (i.e. r ~ r),//! since the value of performing one iteration is in reducing the error representable by `~`).//! Instead of Newton-Raphson iterations, Goldschmidt iterations are used to calculate//! `s = m * r`://! - `s = m * r           s ~ m / sqrt(m)`//! - `u = 3 - s * r       u ~ 3 - (m / sqrt(m)) * (1 / sqrt(m)) = 3 - m / m = 2`//! - `s = s * u / 2       s ~ s`//! The above is precise because it uses the original value `m`. There is also a faster version//! that performs fewer steps but does not use `m`://! - `u = 3 - s * r       u ~ 3 - 1`//! Rounding errors accumulate faster with the second version, so it is only used for subsequent//! iterations within the same width integer. The first version is always used for the first//! iteration at a new width in order to avoid this accumulation.//! Goldschmidt has the advantage over Newton-Raphson that `sqrt(x)` and `1/sqrt(x)` are//! computed at the same time, i.e. there is no need to calculate `1/sqrt(x)` and invert it.trunc_status/* SPDX-License-Identifier: MIT
 * origin: musl src/math/trunc.c *//// Zeroth order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the first kind (f64)./// Zeroth order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the second kind (f64)./// Zeroth order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the first kind (f32)./// Zeroth order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the second kind (f32)./// First order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the first kind (f64)./// First order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the second kind (f64)./// First order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the first kind (f32)./// First order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the second kind (f32)./// Integer order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the first kind (f64)./// Integer order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the second kind (f64)./// Integer order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the first kind (f32)./// Integer order of the [Bessel function](https://en.wikipedia.org/wiki/Bessel_function) of the second kind (f32)./// The natural logarithm of the/// [Gamma function](https://en.wikipedia.org/wiki/Gamma_function) (f64)./// [Gamma function](https://en.wikipedia.org/wiki/Gamma_function) (f32)./// The natural logarithm of `x` (f64)./// The base 10 logarithm of `x` (f64)./// The base 10 logarithm of `x` (f32)./// The natural logarithm of 1+`x` (f64)./// The natural logarithm of 1+`x` (f32)./// The base 2 logarithm of `x` (f64)./// The base 2 logarithm of `x` (f32)./// The natural logarithm of `x` (f32).fmin_fmaxfminimum_fmaximumfminimum_fmaximum_num// many false positives//      2. Perform y*log2(x) = n+y' by simulating multi-precision/// Returns `x` to the power of `y` (f64)./// Returns `x` to the power of `y` (f32).//      y[]     output result in an array of double precision numbers./// Round `x` to the nearest integer, breaking ties toward even./// Round `x` to the nearest integer, breaking ties away from zero./// Round `x` to the nearest integer, breaking ties toward even. This is IEEE 754/// `roundToIntegralTiesToEven`.roundeven_impl/// The sine of `x` (f64)./// Both the sine and cosine of `x` (f64)./// `x` is specified in radians and the return value is (sin(x), cos(x))./// Both the sine and cosine of `x` (f32)./// The sine of `x` (f32)./// The hyperbolic sine of `x` (f64)./// The hyperbolic sine of `x` (f32)./// The square root of `x` (f32)./// The square root of `x` (f64).NarrowingDivnot_u256shr_u256shr_u256_overflow// FIXME(ppc): ppc64le seems to have issues with `should_panic` tests.u256_ordi256_ordu256_shiftsi256_shiftsdiv_u256_by_u128/// A 256-bit unsigned integer represented as two 128-bit native-endian limbs./// A 256-bit signed integer represented as two 128-bit native-endian limbs./// A value combined with a floating point status./// Return `val` with `Status::OK`./// IEEE 754 nearest, `roundTiesToEven`./// IEEE 754 `roundTowardNegative`./// IEEE 754 `roundTowardPositive`./// IEEE 754 `roundTowardZero`./// IEEE 754 rounding mode, excluding the optional `roundTiesToAway` version of nearest./// Integer representation comes from what CORE-MATH uses for indexing./// IEEE 754 exception status flags./// Default status indicating no errors./// No definable result./// Includes:/// - Any ops on sNaN, with a few exceptions./// - `0 * inf`, `inf * 0`./// - `fma(0, inf, c)` or `fma(inf, 0, c)`, possibly excluding `c = qNaN`./// - `+inf + -inf` and similar (includes subtraction and fma)./// - `0.0 / 0.0`, `inf / inf`/// - `remainder(x, y)` if `y == 0.0` or `x == inf`, and neither is NaN./// - `sqrt(x)` with `x < 0.0`.DIVIDE_BY_ZERO/// Division by zero./// The default result for division is +/-inf based on operand sign. For `logB`, the default/// result is -inf./// `x / y` when `x != 0.0` and `y == 0.0`,/// The result exceeds the maximum finite value./// The default result depends on rounding mode. `Nearest*` rounds to +/- infinity, sign based/// on the intermediate result. `Zero` rounds to the signed maximum finite. `Positive` and/// `Negative` round to signed maximum finite in one direction, signed infinity in the other.UNDERFLOW/// The result is subnormal and lost precision.INEXACT/// The finite-precision result does not match that of infinite precision, and the reason/// is not represented by one of the other flags./// True if `UNDERFLOW` is set./// True if `OVERFLOW` is set.set_underflow/// True if `INEXACT` is set.set_inexact//! Support for rounding directions and status flags as specified by IEEE 754.//! Rust does not support the floating point environment so rounding mode is passed as an argument//! and status flags are returned as part of the result. There is currently not much support for//! this; most existing ports from musl use a form of `force_eval!` to raise exceptions, but this//! has no side effects in Rust. Further, correct behavior relies on elementary operations making//! use of the correct rounding and raising relevant exceptions, which is not the case for Rust.//! This module exists so no functionality is lost when porting algorithms that respect floating//! point environment, and so that some functionality may be tested (that which does not rely on//! side effects from elementary operations). Full support would require wrappers around basic//! operations, but there is no plan to add this at the current time.// Matcher for a single value/// Given a list of identifiers, assign each one a unique sequential single-bit mask./// Call `init` once to choose an implementation, then use it for the rest of the program./// - `sig` is the function type./// - `init` is an expression called at startup that chooses an implementation and returns a///   function pointer./// - `call` is an expression to call a function returned by `init`, encapsulating any safety///   preconditions./// The type `Func` is available in `init` and `call`./// This is effectively our version of an ifunc without linker support. Note that `init` may be/// called more than once until one completes.// only used on some architectures/// Helper for working with bit flags, based on `bitflags`./// No bits set./// Create with bits already set./// Get the integer representation./// Set any bits in `mask`./// Check whether the mask is set.test_nth/// Check whether the nth bit is set./// Load flags from an atomic value. If the flags have not yet been initialized, call `init`/// Note that `init` may run more than once.//! Helpers for runtime target feature detection that are shared across architectures.int_traitsNEG_NANNEG_PIMIN_POSITIVE_NORMAL/// The bitwidth of the float type/// The bitwidth of the significand/// The bitwidth of the exponent/// This shifted fully right, use `EXP_MASK` for the shifted value./// The exponent bias valueEXP_MAX/// Maximum unbiased exponent value.EXP_MIN/// Minimum *NORMAL* unbiased exponent value.EXP_MIN_SUBNORM/// Minimum subnormal exponent value./// A mask for the sign bit/// A mask for the significand/// A mask for the exponent/// The implicit bit of the float formatbiteq/// Check bitwise equality./// represented in multiple different ways./// This method returns `true` if two NaNs are compared. Use [`biteq`](Self::biteq) instead/// if `NaN` should not be treated separately./// Returns true if the value is NaN./// Returns true if the value is +inf or -inf./// Returns true if the sign is negative. Extracts the sign bit regardless of zero or NaN./// Returns true if the sign is positive. Extracts the sign bit regardless of zero or NaN./// Returns if `self` is subnormal.ex/// Returns the exponent, not adjusting for bias, not accounting for subnormals or zero.exp_unbiased/// Extract the exponent and adjust it for bias, not accounting for subnormals or zero./// Returns a number composed of the magnitude of self and the sign of sign./// Fused multiply add, rounding once./// Returns a number that represents the sign of self./// Make a best-effort attempt to canonicalize the number. Note that this is allowed/// to be a nop and does not always quiet sNaNs.// Some constants are only used with tests/// Access the associated `Int` type from a float (helper to avoid ambiguous associated types).f32_from_bits/// `f32::from_bits`// lint appears in newer versions of Rustf32_to_bits/// `f32::to_bits`// workaround for false positive RUST-144060f64_from_bits/// `f64::from_bits`f64_to_bits/// `f64::to_bits`/// Float that is half the bit width of the floatthis trait is implemented for./// Narrow the float type./// Trait for floats twice the bit width of another integer./// Float that is double the bit width of the float this trait is implemented for./// Widen the float type./// Trait for floats half the bit width of another float.impl_d_floatimpl_h_float// FIXME(msrv) we shouldn't need this/* FIXME(msrv): vendor some things that are not const stable at our MSRV *//// Construct a 32-bit float from hex float representation (C-style)/// Construct a 64-bit float from hex float representation (C-style)HexFloatParseErrorparse_hex_exact/// Parses any float to its bitwise representation, returning an error if it cannot be represented exactly/// Parse any float from hex to its bitwise representation.parse_finiteshr_odd_rounding/// Shift right, rounding all inexact divisions to the nearest odd number/// E.g. (0 >> 4) -> 0, (1..=31 >> 4) -> 1, (32 >> 4) -> 2, .../// Useful for reducing a number before rounding the last two bits, since/// the result of the final rounding is preserved for all rounding modes.shr2_round/// Divide by 4, rounding with the given mode/// Absolute value sig * 2^exp/// A parsed finite and unsigned floating point number./// Parse a hexadecimal float xdec_digitu128_ilog2/// `u128::ilog2`//! Utilities for working with hex float formats.unchecked_narrowing_div_rem/// Computes `(self / n, self % n))`/// The caller must ensure that `self.hi() < n`, or equivalently,/// that the quotient does not overflow.checked_narrowing_div_rem/// Returns `Some((self / n, self % n))` when `self.hi() < n`./// Trait for unsigned division of a double-wide integer/// when the quotient doesn't overflow./// This is the inverse of widening multiplication:///  - for any `x` and nonzero `y`: `x.widen_mul(y).checked_narrowing_div_rem(y) == Some((x, 0))`,///  - and for any `r in 0..y`: `x.carrying_mul(y, r).checked_narrowing_div_rem(y) == Some((x, r))`,impl_narrowing_div_primitive// For primitive types we can just use the standard// division operators in the double-wide type.impl_narrowing_div_recurse// Extend division from `u2N / uN` to `u4N / u2N`// This is not the most efficient algorithm, but it is// relatively simple.div_three_digits_by_two/// Implement `u3N / u2N`-division on top of `u2N / uN`-division./// Returns the quotient and remainder of `(a * R + a0) / n`,/// where `R = (1 << U::BITS)` is the digit size./// Requires that `n.leading_zeros() == 0` and `a < n`.narrowing_div/// Type with the same width but other signedness/// Unsigned version of Self/// If `Self` is a signed integer/// The bitwidth of the int type/// Minimal integer implementations needed on all integer types, including wide integers./// Access the associated `OtherSign` type from an int (helper to avoid ambiguous associated/// types).logical_shr/// Prevents the need for excessive conversions between signed and unsignedabs_diff/// Absolute difference between two integers.// copied from primitive integers, but put in a traitcarrying_addborrowing_sub/// Trait for some basic operations on integersint_impl_commonint_impl/// By default, casts should be exact.cast_lossy/// Call for casts that are expected to truncate./// In practice, this is exactly the same as `cast`; the main difference is to document intent/// in code. `cast` may panic in debug mode./// Trait to express (possibly lossy) casting of integerscast_fromcast_from_lossycast_into_float/// `libm` cannot have dependencies, so this is vendored directly from the `cfg-if` crate/// (with some comments stripped for compactness).select_implementation// Coalesce helper to construct an expression only if a config is provided/// Choose between using an arch-specific implementation and the function body. Returns directly/// if the arch implementation is used, otherwise continue with the rest of the function./// Specify a `use_arch` meta field if an architecture-specific implementation is provided./// These live in the `math::arch::some_target_arch` module./// Specify a `use_arch_required` meta field if something architecture-specific must be used/// regardless of feature configuration (`force-soft-floats`)./// The passed meta options do not need to account for the `arch` target feature./// Construct a 32-bit float from hex float representation (C-style), guaranteed to/// evaluate at compile time./// Construct a 64-bit float from hex float representation (C-style), guaranteed to// Runtime feature detection requires atomics.float_traitshex_float// Clippy seems to have a false positive/// Hint to the compiler that the current path is cold./// The tangent of `x` (f64)./// The tangent of `x` (f32)./// The hyperbolic tangent of `x` (f64)./// The hyperbolic tangent of `x` (f32)./// The [Gamma function](https://en.wikipedia.org/wiki/Gamma_function) (f64)./// The [Gamma function](https://en.wikipedia.org/wiki/Gamma_function) (f32)./// Rounds the number toward 0 to the closest integral value (f32)./// This effectively removes the decimal part of the number, leaving the integral part./// Rounds the number toward 0 to the closest integral value (f64).hf16hf128spacedCheckBasisCheckCtxGeneratorKindOpRustArgsicount_benchessetup_u128_mulsetup_u256_addsetup_u256_shiftlinspaceicount_bench_u128_widen_mulicount_bench_u256_narrowing_divicount_bench_u256_addicount_bench_u256_subicount_bench_u256_shlicount_bench_u256_shricount_bench_hf16icount_bench_hf32icount_bench_hf64icount_bench_hf128icount_bench_print_hf16icount_bench_print_hf32icount_bench_print_hf64icount_bench_print_hf128//! Benchmarks that use `iai-cachegrind` to be reasonably CI-stable.RandomInputmusl_fnskip_on_i586MuslExtra/// Extra parameters we only care about if we are benchmarking against musl.musl_rand_benchesbench_oneCFnRustArgsrun_callbackmusl_random"../libm/configure.rs"SpacedInputJL_PLOTplot_one_operatorFTy/// Run multiple generators for a single operator.plot_one_generator/// Plot the output of a single generator.//! Program to write all inputs from a generator to a file, then invoke a Julia script to plot//! them. Output is in `target/plots`.//! Requires Julia with the `CairoMakie` dependency.//! Note that running in release mode by default generates a _lot_ more datapoints, which//! causes plotting to be extremely slow (some simplification to be done in the script)./// Start of the region for which a function is defined (ignoring poles)./// Endof the region for which a function is defined (ignoring poles).check_points/// Additional points to check closer around. These can be e.g. undefined asymptotes or/// inflection points./// Representation of a single dimension of a function's domain.range_start/// The start of this domain, saturating at negative infinity.range_end/// The end of this domain, saturating at infinity.EitherPrim/// A value that may be any float type or any integer type.unwrap_floatunwrap_intUNBOUNDED/// x ∈ ℝPOSITIVE/// x ∈ ℝ >= 0STRICTLY_POSITIVE/// x ∈ ℝ > 0into_prim_float/// Wrap in the float variant of [`EitherPrim`]./// Convenience 1-dimensional float domains.UNBOUNDED_INTinto_prim_int/// Wrap in the int variant of [`EitherPrim`]./// Convenience 1-dimensional integer domains.UNBOUNDED1UNBOUNDED2/// {x1, x2} ∈ ℝUNBOUNDED3/// {x1, x2, x3} ∈ ℝUNBOUNDED_F_I/// {x1, x2} ∈ ℝ, one float and one intINVERSE_TRIG_PERIODIC/// Used for versions of `asin` and `acos`.ACOSH/// Domain for `acosh`ATANH/// Domain for `atanh`TRIG/// Domain for `sin`, `cos`, and `tan`LOG/// Domain for `log` in various basesLOG1P/// Domain for `log1p` i.e. `log(1 + x)`SQRT/// Domain for `sqrt`/// Domain for `gamma`LGAMMA/// Domain for `loggamma`BESSEL_N/// Domain for `jn` and `yn`.// FIXME: the domain should provide some sort of "reasonable range" so we don't actually test// the entire system unbounded./// Multidimensional domains, represented as an array of 1-D domains.get_domain/// Get the domain for a given function.//! Traits and operations related to bounds of a function.f8/// Sometimes verifying float logic is easiest when all values can quickly be checked exhaustively/// or by hand./// IEEE-754 compliant type that includes a 1 bit sign, 4 bit exponent, and 3 bit significand./// Bias is -7./// Based on <https://en.wikipedia.org/wiki/Minifloat#Example_8-bit_float_(1.4.3)>.// FIXME: incorrect valuesALL_LEN/// All non-infinite non-NaN values of `f8`hf8//! An IEEE-compliant 8-bit float type for testing purposes.RustRetappend_inputsappend_pairsacos_casesRoutineacosf_casesacosh_casesacoshf_casesasin_casesasinf_casesasinh_casesasinhf_casesatan_casesatan2_casesatan2f_casesatanf_casesatanh_casesatanhf_casescbrt_casescbrtf_casesceil_casesceilf_casesceilf128_casesceilf128ceilf16_casesceilf16copysign_casescopysignf_casescopysignf128_casescopysignf128copysignf16_casescopysignf16cos_casescosf_casescosh_casescoshf_caseserf_caseserfc_caseserfcf_caseserff_casesexp_casesexp10_casesexp10f_casesexp2_casesexp2f_casesexpf_casesexpm1_casesexpm1f_casesfabs_casesfabsf_casesfabsf128_casesfabsf128fabsf16_casesfabsf16fdim_casesfdimf_casesfdimf128_casesfdimf128fdimf16_casesfdimf16floor_casesfloorf_casesfloorf128_casesfloorf128floorf16_casesfloorf16fma_casesfmaf_casesfmaf128_casesfmaf128fmaxf16_casesfmaxf16fmaxf_casesfmax_casesfmaxf128_casesfmaxf128fmaximumf16_casesfmaximumf16fmaximumf_casesfmaximum_casesfmaximumf128_casesfmaximumf128fmaximum_numf16_casesfmaximum_numf16fmaximum_numf_casesfmaximum_num_casesfmaximum_numf128_casesfmaximum_numf128fminf16_casesfminf16fminf_casesfmin_casesfminf128_casesfminf128fminimumf16_casesfminimumf16fminimumf_casesfminimum_casesfminimumf128_casesfminimumf128fminimum_numf16_casesfminimum_numf16fminimum_numf_casesfminimum_num_casesfminimum_numf128_casesfminimum_numf128fmod_casesfmodf_casesfmodf128_casesfmodf128fmodf16_casesfmodf16frexp_casesfrexpf_caseshypot_caseshypotf_casesilogb_casesilogbf_casesj0_casesj0f_casesj1_casesj1f_casesjn_casesjnf_casesldexp_casesldexpf_casesldexpf128_casesldexpf128ldexpf16_casesldexpf16lgamma_caseslgamma_r_caseslgammaf_caseslgammaf_r_caseslog_caseslog10_caseslog10f_caseslog1p_caseslog1pf_caseslog2_caseslog2f_caseslogf_casesmodf_casesmodff_casesnextafter_casesnextafterf_casespow_casespowf_casesremainder_casesremainderf_casesremquo_casesremquof_casesrint_casesrintf_casesrintf128_casesrintf128rintf16_casesroundf16_casesroundf16round_casesroundf_casesroundf128_casesroundf128roundevenf16_casesroundevenf16roundeven_casesroundevenf_casesroundevenf128_casesroundevenf128scalbn_casesscalbnf_casesscalbnf128_casesscalbnf128scalbnf16_casesscalbnf16sin_casessincos_casessincosf_casessinf_casessinh_casessinhf_casessqrt_casessqrtf_casessqrtf128_casessqrtf128sqrtf16_casestan_casestanf_casestanh_casestanhf_casestgamma_casestgammaf_casestrunc_casestruncf_casestruncf128_casestruncf128truncf16_casestruncf16y0_casesy0f_casesy1_casesy1f_casesyn_casesynf_casesget_casesCaseListInputimpl_case_listget_test_cases_standalone/// This is the test generator for standalone tests, i.e. those with no basis. For this, it/// only extracts tests with a known output.get_test_cases_basis/// Opposite of the above; extract only test cases that don't have a known output, to be run/// against a basis.//! Test cases to verify specific values.//! Each routine can have a set of inputs and, optinoally, outputs. If an output is provided, it//! will be used to check against. If only inputs are provided, the case will be checked against//! a basis.//! This is useful for adding regression tests or expected failures.KnownSizeOpITyrun_cfgcheck_near_countcheck_point_countEdgeCaseInput/// Generate a sequence of edge cases, e.g. numbers near zeroes and infiniteis./// Create a list of values around interesting points (infinities, zeroes, NaNs).count_up/// Add `points` values starting at and including `x` and counting up. Uses the smallest possible/// increments (1 ULP).count_down/// Add `points` values starting at and including `x` and counting down. Uses the smallest possibleint_edge_cases/// Create a list of values around interesting integer points (min, zero, max).int_count_around/// Add `points` values both up and down, starting at and including `x`.impl_edge_case_inputget_test_cases//! A generator that checks a handful of cases near infinities, zeros, asymptotes, and NaNs.int_rangeiteration_countSEED_ENV/// Generate a sequence of random values of this type.random_floats/// Generate a sequence of deterministically random floats.random_ints/// Generate a sequence of deterministically random `i32`s within a specified range.impl_random_input/// Create a test case iterator.linear_intslogspace/// Generate a sequence of inputs that eiher cover the domain in completeness (for smaller float/// types and single argument functions) or provide evenly spaced inputs across the domain with/// approximately `u32::MAX` total iterations.logspace_steps/// Construct an iterator from `logspace` and also calculate the total number of steps expected/// for that iterator.EitherIter/// Represents the iterator in either `Left` or `Right`.value_count/// Gets the total number of possible values, returning `None` if that number doesn't fit in aall_values/// Returns an iterator of every possible value of type `F`.impl_spaced_input/// Create a test case iterator for extensive inputs. Also returns the total test case count.case_list/// A wrapper to turn any iterator into an `ExactSizeIterator`. Asserts the final result to ensure/// the provided size was correct.//! Different generators that can create random or systematic bit patterns.f8_impltest_traitsOpCFnOpCRetOpFTyOpRustFnOpRustRetMaybeOverrideSpecialCasedefault_ulpextensive_max_iterationsEXTENSIVE_ENVbigint_fuzz_iteration_countskip_extensive_testCheckOutput/// Result type for tests is usually from `anyhow`. Most times there is no success value to/// propagate.emulated/// True if `EMULATED` is set and nonempty. Used to determine how many iterations to run./// True if `CI` is set and nonempty./// Print to stderr and additionally log it to `target/test-log.txt`. This is useful for saving/// output that would otherwise be consumed by the test harness.// sometimes we group by sign_exp_sigMpFloatPowAssignRoundRemAssignRoundnew_mpfloat/// Create a multiple-precision float with the correct number of bits for a concrete float type.prep_retval/// Set subnormal emulation and convert to a concrete float type.MpTy/// The struct itself should hold any context that can be reused among calls to `run` (allocated/// `MpFloat`s).new_mp/// Create a new instance./// Perform the operation./// Usually this means assigning inputs to cached floats, performing the operation, applying/// subnormal approximation, and converting the result back to concrete values./// Structures that represent a float operation.impl_mp_op// Matcher for unary functions// Matcher for binary functions// Matcher for ternary functions/// Implement `MpOp` for functions with a single return value.impl_no_round// Unary matcher/// Implement unary functions that don't have a `_round` versionimpl_op_for_ty/// Some functions are difficult to do in a generic way. Implement them here.impl_op_for_ty_all/// Version of `impl_op_for_ty` with only functions that have `f16` and `f128` implementations.// `lgamma_r` is not a simple suffix so we can't use the above macro.//! Interfaces needed to support testing with multi-precision floating point numbers.//! Within this module, the macros create a submodule for each `libm` function. These contain//! a struct named `Operation` that implements [`MpOp`]./* stub implementations so we don't need to special case them */TINY_BITS/// The minimum subnormal number./// Retrieve additional constants for this float type.next_up/// Increment by one ULP, saturating at infinity.n_up/// A faster way to effectively call `next_up` `n` times.next_down/// Decrement by one ULP, saturating at negative infinity.n_down/// A faster way to effectively call `next_down` `n` times./// Extension to `libm`'s `Float` trait with methods that are useful for tests but not/// needed in `libm` itself.pos_nan/// The default quiet NaN, which is also the minimum quiet NaN.neg_nan/// The default quiet NaN with negative sign.max_qnan/// NaN with maximum (unsigned) significand to be a quiet NaN. The significand is saturated.min_snan/// NaN with minimum (unsigned) significand to be a signaling NaN.max_snan/// NaN with maximum (unsigned) significand to be a signaling NaN.neg_max_qnanneg_min_snanneg_max_snan/// Extra constants that are useful for tests.ulp_between/// Return the number of steps between two floats, returning `None` if either input is NaN./// This is the number of steps needed for `n_up` or `n_down` to go between values. Infinities/// are treated the same as those functions (will return the nearest finite value), and only one/// of `-0` or `+0` is counted. It does not matter which value is greater.as_ulp_steps/// Return the (signed) number of steps from zero to `x`./// An iterator that returns floats with linearly spaced integer representations, which translates/// to logarithmic spacing of their values./// Note that this tends to skip negative zero, so that needs to be checked explicitly./// Returns `(iterator, iterator_length)`./// Returns an iterator of up to `steps` integers evenly distributed.test_next_up_downtest_next_up_down_inf_nantest_n_up_down_quicktest_n_up_down_onetest_n_up_down_inf_nan_zerocrossed_zero/// True if the specified range of `f8::ALL` includes both +0 and -0test_n_up_downtest_ulp_betweentest_ulp_between_inf_nan_zerotest_logspacetest_linear_ints//! Helpful numeric operations./// An enum representing each possible symbol name (`sin`, `sinf`, `sinl`, etc)./// The name without any type specifier, e.g. `sin` and `sinf` both become `sin`./// The float type used for this operation./// The function type representing the signature in a C library.CArgs/// Arguments passed to the C library function as a tuple. These may include `&mut` returnCRet/// The type returned by C implementations.RustFn/// The signature of the Rust function as a `fn(...) -> ...` type./// Arguments passed to the Rust library function as a tuple./// The required `TupleCall` bounds ensure this type can be passed either to the C function or/// to the Rust function./// Type returned from the Rust function.IDENTIFIER/// The name of this function, including suffix (e.g. `sin`, `sinf`)./// The name as a string.BASE_NAME/// The name of the function excluding the type suffix, e.g. `sin` and `sinf` are both `sin`.ROUTINE/// The function in `libm` which can be called.PUBLIC/// Whether or not the function is part of libm public API./// Attributes ascribed to a `libm` routine including signature, type information,/// and naming./// Access the associated `FTy` type from an op (helper to avoid ambiguous associated types)./// Access the associated `FTy::Int` type from an op (helper to avoid ambiguous associated types)./// Access the associated `CFn` type from an op (helper to avoid ambiguous associated types)./// Access the associated `CRet` type from an op (helper to avoid ambiguous associated types)./// Access the associated `RustFn` type from an op (helper to avoid ambiguous associated types)./// Access the associated `RustArgs` type from an op (helper to avoid ambiguous associated types)./// Access the associated `RustRet` type from an op (helper to avoid ambiguous associated types).create_op_modules//! Types representing individual functions.//! Each routine gets a module with its name, e.g. `mod sinf { /* ... */ }`. The module//! contains a unit struct `Routine` which implements `MathOp`.//! Basically everything could be called a "function" here, so we loosely use the following//! terminology://! - "Function": the math operation that does not have an associated precision. E.g. `f(x) = e^x`,//!   `f(x) = log(x)`.//! - "Routine": A code implementation of a math operation with a specific precision. E.g. `exp`,//!   `expf`, `expl`, `log`, `logf`.//! - "Operation" / "Op": Something that relates a routine to a function or is otherwise higher//!   level. `Op` is also used as the name for generic parameters since it is terse.Mpfr/// Type implementing [`IgnoreCase`]./// ULP allowed to differ from the results returned by a test basis.CheckActionAssertSuccess/// The check should pass. Default case.AssertWithUlp/// Override the ULP for this check.AssertFailure/// Failure is expected, ensure this is the case (xfail). Takes a contxt string to help trace/// back exactly why we expect this to fail./// The override somehow validated the result, here it is./// Disregard the output./// Result of checking for possible overrides./// Don't run further validation on this test case.XFAIL/// Return this to skip checks on a test that currently fails but shouldn't. Takes a description/// of context.XFAIL_NOCHECK/// Indicates that we expect a test to fail but we aren't asserting that it does (e.g. some results/// within a range do actually pass)./// Same as `SKIP`, just indicates we have something to eventually fix./// By default, all tests should pass.check_floatcheck_int/// Allow overriding the outputs of specific test cases./// There are some cases where we want to xfail specific cases or handle certain inputs/// differently than the rest of calls to `validate`. This provides a hook to do that./// If `None` is returned, checks will proceed as usual. If `Some(result)` is returned, checks/// are skipped and the provided result is returned instead./// This gets implemented once per input type, then the functions provide further filtering/// based on function name and values./// `ulp` can also be set to adjust the ULP for that specific test, even if `None` is stillunop_common// F1 and F2 are always the same type, this is just to please genericsbinop_commonint_float_common//! Configuration for skipping or changing the result for individual test cases (inputs) rather//! than ignoring entire tests./// The environment variable indicating which extensive tests should be run.EXTENSIVE_ITER_ENV/// Specify the number of iterations via this environment variable, rather than using the default.EXTENSIVE_ITER_OVERRIDE/// The override value, if set by the above environment.EXTREMELY_SLOW_TESTSSlowTest/// Specific tests that need to have a reduced amount of iterations to complete in a reasonable/// amount of time.gen_kindextensivereduce_factor/// A pattern to match a `CheckCtx`, plus a factor to reduce by.matches_ctx/// True if the test in `CheckCtx` should be reduced by `reduce_factor`./// Maximum number of iterations to run for a single routine./// The default value of one greater than `u32::MAX` allows testing single-argument `f32` routines/// and single- or double-argument `f16` routines exhaustively. `f64` and `f128` can't feasibly/// be tested exhaustively; however, [`EXTENSIVE_ITER_ENV`] can be set to run tests for multiple/// hours.ulp/// Allowed ULP deviationfn_ident/// Function name.base_name_str/// Return the unsuffixed version of the function name.basis/// Source of truth for tests.override_iterations/// If specified, this value will override the value returned by [`iteration_count`]./// Context passed to [`CheckOutput`]./// Create a new check context, using the default ULP for the function./// Configure that this is an extensive test.input_count/// The number of input arguments for this function./// Check against Musl's math sources./// Check against infinite precision (MPFR)./// Benchmarks or other times when this is not relevant./// Possible items to test againstEdgeCases/// Extremes, zeros, nonstandard numbers, etc.Spaced/// Spaced by logarithm (floats) or linear (integers)./// Test inputs from an RNG./// A provided test case list./// The different kinds of generators that provide test input, which account for input pattern/// and quantity.EXTENSIVE/// A list of all functions that should get extensive tests, as configured by environment variable./// This also supports the special test name `all` to run all tests, as well as `all_f16`,/// `all_f32`, `all_f64`, and `all_f128` to run all tests for a specific float type.slow_platform/// Tests should be reduced because the platform is slow. E.g. 32-bit or emulated.large_float_ty/// The float cannot be tested exhaustively, `f64` or `f128`.should_run_extensive/// Env indicates that an extensive test should be run.mp_tests_enabled/// Multiprecision tests will be run./// The number of inputs to the function.TestEnv/// Information about the function to be tested./// Tests are pretty slow on non-64-bit targets, x86 MacOS, and targets that run in QEMU. Start/// with a reduced number on these platforms./// The number of iterations to run for a given test./// Some tests require that an integer be kept within reasonable limits; generate that here./// For domain tests, limit how many asymptotes or specified check points we test./// When validating points of interest (e.g. asymptotes, inflection points, extremes), also check/// this many surrounding values./// Check whether extensive actions should be run or skipped./// The number of iterations to run for `u256` fuzz tests.//! Configuration for how tests get run.call_intercept_panics/// Intercept panics and print the input to stderr before continuing./// Trait for calling a function with a tuple as arguments./// Implemented on the tuple with the function signature as the generic (so we can use the same/// tuple for multiple signatures)./// Validate `self` (actual) and `expected` are the same./// `input` is only used here for error messages./// A trait to implement on any output type so we can verify it in a generic way./// Hex integer syntax.hexf/// Hex float syntax./// A helper trait to print something as hex with the correct number of nibbles, e.g. a `u32`/// will always print with `0x` followed by 8 digits./// This is only used for printing errors so allocating is okay.validate_intimpl_floatvalidate_floatimpl_tuples/// Implement `CheckOutput` for combinations of types.//! Traits related to testing.//! There are two main traits in this module://! - `TupleCall`: implemented on tuples to allow calling them as function arguments.//! - `CheckOutput`: implemented on anything that is an output type for validation against an//!   expected value./* implement `TupleCall` *//* implement `Hex` *//* trait implementations for ints *//* trait implementations for floats *//* trait implementations for compound types */test_for_each_function_all_includedensure_list_updated//! Ensure that `for_each_function!` isn't missing any symbols.BASISmusl_runnermusl_tests/// Test against musl with generators from a domain.//! Compare our implementations with the result of musl functions, as provided by `musl-math-sys`.//! Currently this only tests randomized inputs. In the future this may be improved to test edge//! cases or run exhaustive tests.//! Note that musl functions do not always provide 0.5ULP rounding, so our functions can do better//! than these results.// There are some targets we can't build musl formp_runnermp_tests//! Test with "infinite precision"standalone_runner//! Test cases that have both an input and an output, so do not require a basis.NotAssignBIGINT_U256_MAX/// Copied from the test module.random_u256assign_bigintfrom_bigintcheck_onemp_u256_bitormp_u256_notmp_u256_addmp_u256_submp_u256_shlmp_u256_shrmp_u256_widen_mul//! Test the u256 implementation. the ops already get exercised reasonably well through the `f128`//! routines, so this only does a few million fuzz iterations against GMP.//! `main` is just a wrapper to handle configuration.indicatifProgressStylelibtest_mimicTrial/// Run the extensive test suite.mp_extensive_testsregister_all_tests/// Create a list of tests for consumption by `libtest_mimic`.register_single_test/// Add a single test to the list.run_single_test/// Test runner for a signle routine.pbname_paddedfinal_styleis_tty/// Wrapper around a `ProgressBar` that handles styles and non-TTY messages.PB_TEMPLATEPB_TEMPLATE_FINAL//! Exhaustive tests for `f16` and `f32`, high-iteration for `f64` and `f128`./// Allocates memory as described by the given `layout`./// Returns a pointer to newly-allocated memory,/// or null to indicate allocation failure./// `layout` must have non-zero size. Attempting to allocate for a zero-sized `layout` will/// result in undefined behavior./// (Extension subtraits might provide more specific bounds on/// behavior, e.g., guarantee a sentinel address or a null pointer/// in response to a zero-size allocation request.)/// The allocated block of memory may or may not be initialized./// Returning a null pointer indicates that either memory is exhausted/// or `layout` does not meet this allocator's size or alignment constraints./// Implementations are encouraged to return null on memory/// exhaustion rather than aborting, but this is not/// a strict requirement. (Specifically: it is *legal* to/// implement this trait atop an underlying native allocation/// library that aborts on memory exhaustion.)/// Clients wishing to abort computation in response to an/// allocation error are encouraged to call the [`handle_alloc_error`] function,/// rather than directly invoking `panic!` or similar./// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html/// Deallocates the block of memory at the given `ptr` pointer with the given `layout`./// * `ptr` is a block of memory currently allocated via this allocator and,/// * `layout` is the same layout that was used to allocate that block of///   memory./// Otherwise the behavior is undefined./// Behaves like `alloc`, but also ensures that the contents/// are set to zero before being returned./// The caller has to ensure that `layout` has non-zero size. Like `alloc`/// zero sized `layout` will result in undefined behavior./// However the allocated block of memory is guaranteed to be initialized./// or `layout` does not meet allocator's size or alignment constraints,/// just as in `alloc`./// Shrinks or grows a block of memory to the given `new_size` in bytes./// The block is described by the given `ptr` pointer and `layout`./// If this returns a non-null pointer, then ownership of the memory block/// referenced by `ptr` has been transferred to this allocator./// Any access to the old `ptr` is Undefined Behavior, even if the/// allocation remained in-place. The newly returned pointer is the only valid pointer/// for accessing this memory now./// The new memory block is allocated with `layout`,/// but with the `size` updated to `new_size` in bytes./// This new layout must be used when deallocating the new memory block with `dealloc`./// The range `0..min(layout.size(), new_size)` of the new memory block is/// guaranteed to have the same values as the original block./// If this method returns null, then ownership of the memory/// block has not been transferred to this allocator, and the/// contents of the memory block are unaltered./// The caller must ensure that:/// * `ptr` is allocated via this allocator,/// * `layout` is the same layout that was used///   to allocate that block of memory,/// * `new_size` is greater than zero./// * `new_size`, when rounded up to the nearest multiple of `layout.align()`,///   does not overflow `isize` (i.e., the rounded value must be less than or///   equal to `isize::MAX`)./// If these are not followed, the behavior is undefined./// Returns null if the new layout does not meet the size/// and alignment constraints of the allocator, or if reallocation/// otherwise fails./// exhaustion rather than panicking or aborting, but this is not/// Clients wishing to abort computation in response to a/// reallocation error are encouraged to call the [`handle_alloc_error`] function,/// A memory allocator that can be registered as the standard library’s default/// through the `#[global_allocator]` attribute./// Some of the methods require that a memory block be *currently/// allocated* via an allocator. This means that:/// * the starting address for that memory block was previously///   returned by a previous call to an allocation method///   such as `alloc`, and/// * the memory block has not been subsequently deallocated, where///   blocks are deallocated either by being passed to a deallocation///   method such as `dealloc` or by being///   passed to a reallocation method that returns a non-null pointer./// use std::alloc::{GlobalAlloc, Layout};/// use std::cell::UnsafeCell;/// use std::ptr::null_mut;/// const ARENA_SIZE: usize = 128 * 1024;/// const MAX_SUPPORTED_ALIGN: usize = 4096;/// #[repr(C, align(4096))] // 4096 == MAX_SUPPORTED_ALIGN/// struct SimpleAllocator {///     arena: UnsafeCell<[u8; ARENA_SIZE]>,///     remaining: AtomicUsize, // we allocate from the top, counting down/// #[global_allocator]/// static ALLOCATOR: SimpleAllocator = SimpleAllocator {///     arena: UnsafeCell::new([0x55; ARENA_SIZE]),///     remaining: AtomicUsize::new(ARENA_SIZE),/// unsafe impl Sync for SimpleAllocator {}/// unsafe impl GlobalAlloc for SimpleAllocator {///     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {///         let size = layout.size();///         let align = layout.align();///         // `Layout` contract forbids making a `Layout` with align=0, or align not power of 2.///         // So we can safely use a mask to ensure alignment without worrying about UB.///         let align_mask_to_round_down = !(align - 1);///         if align > MAX_SUPPORTED_ALIGN {///             return null_mut();///         let mut allocated = 0;///         if self///             .remaining///             .fetch_update(Relaxed, Relaxed, |mut remaining| {///                 if size > remaining {///                     return None;///                 remaining -= size;///                 remaining &= align_mask_to_round_down;///                 allocated = remaining;///                 Some(remaining)///             .is_err()///         unsafe { self.arena.get().cast::<u8>().add(allocated) }///     unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}///     let _s = format!("allocating a string!");///     let currently = ALLOCATOR.remaining.load(Relaxed);///     println!("allocated so far: {}", ARENA_SIZE - currently);/// The `GlobalAlloc` trait is an `unsafe` trait for a number of reasons, and/// implementors must ensure that they adhere to these contracts:/// * It's undefined behavior if global allocators unwind. This restriction may///   be lifted in the future, but currently a panic from any of these///   functions may lead to memory unsafety./// * `Layout` queries and calculations in general must be correct. Callers of///   this trait are allowed to rely on the contracts defined on each method,///   and implementors must ensure such contracts remain true./// * You must not rely on allocations actually happening, even if there are explicit///   heap allocations in the source. The optimizer may detect unused allocations that it can either///   eliminate entirely or move to the stack and thus never invoke the allocator. The///   optimizer may further assume that allocation is infallible, so code that used to fail due///   to allocator failures may now suddenly work because the optimizer worked around the///   need for an allocation. More concretely, the following code example is unsound, irrespective///   of whether your custom allocator allows counting how many allocations have happened.///   ```rust,ignore (unsound and has placeholders)///   drop(Box::new(42));///   let number_of_heap_allocs = /* call private allocator API */;///   unsafe { std::hint::assert_unchecked(number_of_heap_allocs > 0); }///   Note that the optimizations mentioned above are not the only///   optimization that can be applied. You may generally not rely on heap allocations///   happening if they can be removed without changing program behavior.///   Whether allocations happen or not is not part of the program behavior, even if it///   could be detected via an allocator that tracks allocations by printing or otherwise///   having side effects./// # Re-entrance/// When implementing a global allocator one has to be careful not to create an infinitely recursive/// implementation by accident, as many constructs in the Rust standard library may allocate in/// their implementation. For example, on some platforms [`std::sync::Mutex`] may allocate, so using/// it is highly problematic in a global allocator./// Generally speaking for this reason one should stick to library features available through/// [`core`], and avoid using [`std`] in a global allocator. A few features from [`std`] are/// guaranteed to not use `#[global_allocator]` to allocate:///  - [`std::thread_local`],///  - [`std::thread::current`],///  - [`std::thread::park`] and [`std::thread::Thread`]'s [`unpark`] method and/// [`Clone`] implementation./// [`std`]: ../../std/index.html/// [`std::sync::Mutex`]: ../../std/sync/struct.Mutex.html/// [`std::thread_local`]: ../../std/macro.thread_local.html/// [`std::thread::current`]: ../../std/thread/fn.current.html/// [`std::thread::park`]: ../../std/thread/fn.park.html/// [`std::thread::Thread`]: ../../std/thread/struct.Thread.html/// [`unpark`]: ../../std/thread/struct.Thread.html#method.unparkassert_unsafe_precondition"alloc_layout"// size of the requested block of memory, measured in bytes.// alignment of the requested block of memory, measured in bytes.// we ensure that this is always a power-of-two, because API's// like `posix_memalign` require it and it is a reasonable// constraint to impose on Layout constructors.// (However, we do not analogously require `align >= sizeof(void*)`,//  even though that is *also* a requirement of `posix_memalign`.)/// Layout of a block of memory./// An instance of `Layout` describes a particular layout of memory./// You build a `Layout` up as an input to give to an allocator./// All layouts have an associated size and a power-of-two alignment. The size, when rounded up to/// the nearest multiple of `align`, does not overflow `isize` (i.e., the rounded value will always be/// less than or equal to `isize::MAX`)./// (Note that layouts are *not* required to have non-zero size,/// even though `GlobalAlloc` requires that all memory requests/// be non-zero in size. A caller must either ensure that conditions/// like this are met, use specific allocators with looser/// requirements, or use the more lenient `Allocator` interface.)/// Constructs a `Layout` from a given `size` and `align`,/// or returns `LayoutError` if any of the following conditions/// are not met:/// * `align` must not be zero,/// * `align` must be a power of two,/// * `size`, when rounded up to the nearest multiple of `align`,///   must not overflow `isize` (i.e., the rounded value must be///   less than or equal to `isize::MAX`).is_size_align_validmax_size_for_alignfrom_size_alignment/// Internal helper constructor to skip revalidating alignment validity.from_size_align_unchecked/// Creates a layout, bypassing all checks./// This function is unsafe as it does not verify the preconditions from/// [`Layout::from_size_align`]./// The minimum size in bytes for a memory block of this layout."this returns the minimum alignment, \
                  without modifying the layout"/// The minimum byte alignment for a memory block of this layout./// The returned alignment is guaranteed to be a power of two./// Constructs a `Layout` suitable for holding a value of type `T`.for_value/// Produces layout describing a record that could be used to/// allocate backing structure for `T` (which could be a trait/// or other unsized type like a slice).for_value_raw/// This function is only safe to call if the following conditions hold:/// - If `T` is `Sized`, this function is always safe to call./// - If the unsized tail of `T` is:///     - a [slice], then the length of the slice tail must be an initialized///       integer, and the size of the *entire value*///       (dynamic tail length + statically sized prefix) must fit in `isize`.///       For the special case where the dynamic tail length is 0, this function///       is safe to call.///     - a [trait object], then the vtable part of the pointer must point///       to a valid vtable for the type `T` acquired by an unsizing coercion,///       and the size of the *entire value*///     - an (unstable) [extern type], then this function is always safe to///       call, but may panic or otherwise return the wrong value, as the///       extern type's layout is not known. This is the same behavior as///       [`Layout::for_value`] on a reference to an extern type tail.///     - otherwise, it is conservatively not allowed to call this function./// [trait object]: ../../book/ch17-02-trait-objects.html/// [extern type]: ../../unstable-book/language-features/extern-types.htmldangling/// Creates a `NonNull` that is dangling, but well-aligned for this Layout./// Note that the address of the returned pointer may potentially/// be that of a valid pointer, which means this must not be used/// as a "not yet initialized" sentinel value./// Types that lazily allocate must track initialization by some other means./// Creates a layout describing the record that can hold a value/// of the same layout as `self`, but that also is aligned to/// alignment `align` (measured in bytes)./// If `self` already meets the prescribed alignment, then returns/// Note that this method does not add any padding to the overall/// size, regardless of whether the returned layout has a different/// alignment. In other words, if `K` has size 16, `K.align_to(32)`/// will *still* have size 16./// Returns an error if the combination of `self.size()` and the given/// `align` violates the conditions listed in [`Layout::from_size_align`]."this returns the padding needed, \
                  without modifying the `Layout`"/// Returns the amount of padding we must insert after `self`/// to ensure that the following address will satisfy `align`/// (measured in bytes)./// e.g., if `self.size()` is 9, then `self.padding_needed_for(4)`/// returns 3, because that is the minimum number of bytes of/// padding required to get a 4-aligned address (assuming that the/// corresponding memory block starts at a 4-aligned address)./// The return value of this function has no meaning if `align` is/// not a power-of-two./// Note that the utility of the returned value requires `align`/// to be less than or equal to the alignment of the starting/// address for the whole allocated block of memory. One way to/// satisfy this constraint is to ensure `align <= self.align()`.size_rounded_up_to_custom_align/// Returns the smallest multiple of `align` greater than or equal to `self.size()`./// This can return at most `Alignment::MAX` (aka `isize::MAX + 1`)/// because the original size is at most `isize::MAX`."this returns a new `Layout`, \
                  without modifying the original"/// Creates a layout by rounding the size of this layout up to a multiple/// of the layout's alignment./// This is equivalent to adding the result of `padding_needed_for`/// to the layout's current size./// Creates a layout describing the record for `n` instances of/// `self`, with a suitable amount of padding between each to/// ensure that each instance is given its requested size and/// alignment. On success, returns `(k, offs)` where `k` is the/// layout of the array and `offs` is the distance between the start/// of each element in the array./// (That distance between elements is sometimes known as "stride".)/// On arithmetic overflow, returns `LayoutError`./// #![feature(alloc_layout_extra)]/// use std::alloc::Layout;/// // All rust types have a size that's a multiple of their alignment./// let normal = Layout::from_size_align(12, 4).unwrap();/// let repeated = normal.repeat(3).unwrap();/// assert_eq!(repeated, (Layout::from_size_align(36, 4).unwrap(), 12));/// // But you can manually make layouts which don't meet that rule./// let padding_needed = Layout::from_size_align(6, 4).unwrap();/// let repeated = padding_needed.repeat(3).unwrap();/// assert_eq!(repeated, (Layout::from_size_align(24, 4).unwrap(), 8));/// Creates a layout describing the record for `self` followed by/// `next`, including any necessary padding to ensure that `next`/// will be properly aligned, but *no trailing padding*./// In order to match C representation layout `repr(C)`, you should/// call `pad_to_align` after extending the layout with all fields./// (There is no way to match the default Rust representation/// layout `repr(Rust)`, as it is unspecified.)/// Note that the alignment of the resulting layout will be the maximum of/// those of `self` and `next`, in order to ensure alignment of both parts./// Returns `Ok((k, offset))`, where `k` is layout of the concatenated/// record and `offset` is the relative location, in bytes, of the/// start of the `next` embedded within the concatenated record/// (assuming that the record itself starts at offset 0)./// To calculate the layout of a `#[repr(C)]` structure and the offsets of/// the fields from its fields' layouts:/// # use std::alloc::{Layout, LayoutError};/// pub fn repr_c(fields: &[Layout]) -> Result<(Layout, Vec<usize>), LayoutError> {///     let mut offsets = Vec::new();///     let mut layout = Layout::from_size_align(0, 1)?;///     for &field in fields {///         let (new_layout, offset) = layout.extend(field)?;///         layout = new_layout;///         offsets.push(offset);///     // Remember to finalize with `pad_to_align`!///     Ok((layout.pad_to_align(), offsets))/// # // test that it works/// # #[repr(C)] struct S { a: u64, b: u32, c: u16, d: u32 }/// # let s = Layout::new::<S>();/// # let u16 = Layout::new::<u16>();/// # let u32 = Layout::new::<u32>();/// # let u64 = Layout::new::<u64>();/// # assert_eq!(repr_c(&[u64, u32, u16, u32]), Ok((s, vec![0, 8, 12, 16])));repeat_packed/// `self`, with no padding between each instance./// Note that, unlike `repeat`, `repeat_packed` does not guarantee/// that the repeated instances of `self` will be properly/// aligned, even if a given instance of `self` is properly/// aligned. In other words, if the layout returned by/// `repeat_packed` is used to allocate an array, it is not/// guaranteed that all elements in the array will be properly/// aligned.extend_packed/// `next` with no additional padding between the two. Since no/// padding is inserted, the alignment of `next` is irrelevant,/// and is not incorporated *at all* into the resulting layout./// Creates a layout describing the record for a `[T; n]`./// On arithmetic overflow or when the total size would exceed/// `isize::MAX`, returns `LayoutError`./// Perma-unstable access to `align` as `Alignment` type./// The `LayoutError` is returned when the parameters given/// to `Layout::from_size_align`/// or some other `Layout` constructor/// do not satisfy its documented constraints.// (we need this for downstream impl of trait Error)// Seemingly inconsequential code changes to this file can lead to measurable// performance impact on compilation times, due at least in part to the fact// that the layout code gets called from many instantiations of the various// collections, resulting in having to optimize down excess IR multiple times.// Your performance intuition is useless. Run perf./// The `AllocError` error indicates an allocation failure/// that may be due to resource exhaustion or to/// something wrong when combining the given input arguments with this/// Attempts to allocate a block of memory./// On success, returns a [`NonNull<[u8]>`][NonNull] meeting the size and alignment guarantees of `layout`./// The returned block may have a larger size than specified by `layout.size()`, and may or may/// not have its contents initialized./// The returned block of memory remains valid as long as it is [*currently allocated*] and the shorter of:///   - the borrow-checker lifetime of the allocator type itself.///   - as long as the allocator and all its clones have not been dropped./// [*currently allocated*]: #currently-allocated-memory/// Returning `Err` indicates that either memory is exhausted or `layout` does not meet/// allocator's size or alignment constraints./// Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or/// aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement/// this trait atop an underlying native allocation library that aborts on memory exhaustion.)/// Clients wishing to abort computation in response to an allocation error are encouraged to/// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar./// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized./// Deallocates the memory referenced by `ptr`./// * `ptr` must denote a block of memory [*currently allocated*] via this allocator, and/// * `layout` must [*fit*] that block of memory./// [*fit*]: #memory-fitting/// Attempts to extend the memory block./// Returns a new [`NonNull<[u8]>`][NonNull] containing a pointer and the actual size of the allocated/// memory. The pointer is suitable for holding data described by `new_layout`. To accomplish/// this, the allocator may extend the allocation referenced by `ptr` to fit the new layout./// If this returns `Ok`, then ownership of the memory block referenced by `ptr` has been/// transferred to this allocator. Any access to the old `ptr` is Undefined Behavior, even if the/// allocation was grown in-place. The newly returned pointer is the only valid pointer/// If this method returns `Err`, then ownership of the memory block has not been transferred to/// this allocator, and the contents of the memory block are unaltered./// * `ptr` must denote a block of memory [*currently allocated*] via this allocator./// * `old_layout` must [*fit*] that block of memory (The `new_layout` argument need not fit it.)./// * `new_layout.size()` must be greater than or equal to `old_layout.size()`./// Note that `new_layout.align()` need not be the same as `old_layout.align()`./// Returns `Err` if the new layout does not meet the allocator's size and alignment/// constraints of the allocator, or if growing otherwise fails./// Behaves like `grow`, but also ensures that the new contents are set to zero before being/// The memory block will contain the following contents after a successful call to/// `grow_zeroed`:///   * Bytes `0..old_layout.size()` are preserved from the original allocation.///   * Bytes `old_layout.size()..old_size` will either be preserved or zeroed, depending on///     the allocator implementation. `old_size` refers to the size of the memory block prior///     to the `grow_zeroed` call, which may be larger than the size that was originally///     requested when it was allocated.///   * Bytes `old_size..new_size` are zeroed. `new_size` refers to the size of the memory///     block returned by the `grow_zeroed` call./// Attempts to shrink the memory block./// this, the allocator may shrink the allocation referenced by `ptr` to fit the new layout./// allocation was shrunk in-place. The newly returned pointer is the only valid pointer/// * `new_layout.size()` must be smaller than or equal to `old_layout.size()`./// constraints of the allocator, or if shrinking otherwise fails./// Creates a "by reference" adapter for this instance of `Allocator`./// The returned adapter also implements `Allocator` and will simply borrow this./// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of/// data described via [`Layout`][]./// `Allocator` is designed to be implemented on ZSTs, references, or smart pointers./// An allocator for `MyAlloc([u8; N])` cannot be moved, without updating the pointers to the/// In contrast to [`GlobalAlloc`][], `Allocator` allows zero-sized allocations. If an underlying/// allocator does not support this (like jemalloc) or responds by returning a null pointer/// (such as `libc::malloc`), this must be caught by the implementation./// ### Currently allocated memory/// Some of the methods require that a memory block is *currently allocated* by an allocator./// This means that:///  * the starting address for that memory block was previously///    returned by [`allocate`], [`grow`], or [`shrink`], and///  * the memory block has not subsequently been deallocated./// A memory block is deallocated by a call to [`deallocate`],/// or by a call to [`grow`] or [`shrink`] that returns `Ok`./// A call to `grow` or `shrink` that returns `Err`,/// does not deallocate the memory block passed to it./// [`allocate`]: Allocator::allocate/// [`grow`]: Allocator::grow/// [`shrink`]: Allocator::shrink/// [`deallocate`]: Allocator::deallocate/// ### Memory fitting/// Some of the methods require that a `layout` *fit* a memory block or vice versa. This means that the/// following conditions must hold:///  * the memory block must be *currently allocated* with alignment of [`layout.align()`], and///  * [`layout.size()`] must fall in the range `min ..= max`, where:///    - `min` is the size of the layout used to allocate the block, and///    - `max` is the actual size returned from [`allocate`], [`grow`], or [`shrink`]./// [`layout.align()`]: Layout::align/// [`layout.size()`]: Layout::size/// Memory blocks that are [*currently allocated*] by an allocator,/// must point to valid memory, and retain their validity until either:///  - the memory block is deallocated, or///  - the allocator is dropped./// Copying, cloning, or moving the allocator must not invalidate memory blocks returned from it./// A copied or cloned allocator must behave like the original allocator./// A memory block which is [*currently allocated*] may be passed to/// any method of the allocator that accepts such an argument./// Gets the `TypeId` of `self`./// If called on a `dyn Any` trait object/// (or a trait object of a subtrait of `Any`),/// this returns the `TypeId` of the underlying/// concrete type, not that of `dyn Any` itself./// use std::any::{Any, TypeId};/// fn is_string(s: &dyn Any) -> bool {///     TypeId::of::<String>() == s.type_id()/// assert_eq!(is_string(&0), false);/// assert_eq!(is_string(&"cookie monster".to_string()), true);"Any"/// A trait to emulate dynamic typing./// Most types implement `Any`. However, any type which contains a non-`'static` reference does not./// See the [module-level documentation][mod] for more details./// [mod]: crate::any// This trait is not unsafe, though we rely on the specifics of it's sole impl's// `type_id` function in unsafe code (e.g., `downcast`). Normally, that would be// a problem, but because the only impl of `Any` is a blanket implementation, no// other code can implement `Any`.// We could plausibly make this trait unsafe -- it would not cause breakage,// since we control all the implementations -- but we choose not to as that's// both not really necessary and may confuse users about the distinction of// unsafe traits and unsafe methods (i.e., `type_id` would still be safe to call,// but we would likely want to indicate as such in documentation).// Ensure that the result of e.g., joining a thread can be printed and// hence used with `unwrap`. May eventually no longer be needed if// dispatch works with upcasting./// Returns `true` if the inner type is the same as `T`./// fn is_string(s: &dyn Any) {///     if s.is::<String>() {///         println!("It's a string!");///         println!("Not a string...");/// is_string(&0);/// is_string(&"cookie monster".to_string());/// Returns some reference to the inner value if it is of type `T`, or/// `None` if it isn't./// fn print_if_string(s: &dyn Any) {///     if let Some(string) = s.downcast_ref::<String>() {///         println!("It's a string({}): '{}'", string.len(), string);/// print_if_string(&0);/// print_if_string(&"cookie monster".to_string());/// Returns some mutable reference to the inner value if it is of type `T`, or/// fn modify_if_u32(s: &mut dyn Any) {///     if let Some(num) = s.downcast_mut::<u32>() {///         *num = 42;/// let mut x = 10u32;/// let mut s = "starlord".to_string();/// modify_if_u32(&mut x);/// modify_if_u32(&mut s);/// assert_eq!(&s, "starlord");downcast_unchecked_ref/// Returns a reference to the inner value as type `dyn T`.///     assert_eq!(*x.downcast_unchecked_ref::<usize>(), 1);downcast_unchecked_mut/// Returns a mutable reference to the inner value as type `dyn T`./// let mut x: Box<dyn Any> = Box::new(1_usize);///     *x.downcast_unchecked_mut::<usize>() += 1;/// assert_eq!(*x.downcast_ref::<usize>().unwrap(), 2);/// Forwards to the method defined on the type `dyn Any`./// fn is_string(s: &(dyn Any + Send)) {/// fn print_if_string(s: &(dyn Any + Send)) {/// fn modify_if_u32(s: &mut (dyn Any + Send)) {/// Forwards to the method defined on the type `Any`./// fn is_string(s: &(dyn Any + Send + Sync)) {/// fn print_if_string(s: &(dyn Any + Send + Sync)) {/// fn modify_if_u32(s: &mut (dyn Any + Send + Sync)) {derive_const"type_id"/// This needs to be an array of pointers, since there is provenance/// in the first array field. This provenance knows exactly which type/// the TypeId actually is, allowing CTFE and miri to operate based off it./// At runtime all the pointers in the array contain bits of the hash, making/// the entire `TypeId` actually just be a `u128` hash of the type./// A `TypeId` represents a globally unique identifier for a type./// Each `TypeId` is an opaque object which does not allow inspection of what's/// inside but does allow basic operations such as cloning, comparison,/// printing, and showing./// A `TypeId` is currently only available for types which ascribe to `'static`,/// but this limitation may be removed in the future./// While `TypeId` implements `Hash`, `PartialOrd`, and `Ord`, it is worth/// noting that the hashes and ordering will vary between Rust releases. Beware/// of relying on them inside of your code!/// Like other [`Rust`-representation][repr-rust] types, `TypeId`'s size and layout are unstable./// In particular, this means that you cannot rely on the size and layout of `TypeId` remaining the/// same between Rust releases; they are subject to change without prior notice between Rust/// releases./// [repr-rust]: https://doc.rust-lang.org/reference/type-layout.html#r-layout.repr.rust.unspecified/// # Danger of Improper Variance/// You might think that subtyping is impossible between two static types,/// but this is false; there exists a static type with a static subtype./// To wit, `fn(&str)`, which is short for `for<'any> fn(&'any str)`, and/// `fn(&'static str)`, are two distinct, static types, and yet,/// `fn(&str)` is a subtype of `fn(&'static str)`, since any value of type/// `fn(&str)` can be used where a value of type `fn(&'static str)` is needed./// This means that abstractions around `TypeId`, despite its/// `'static` bound on arguments, still need to worry about unnecessary/// and improper variance: it is advisable to strive for invariance/// first. The usability impact will be negligible, while the reduction/// in the risk of unsoundness will be most welcome./// Suppose `SubType` is a subtype of `SuperType`, that is,/// a value of type `SubType` can be used wherever/// a value of type `SuperType` is expected./// Suppose also that `CoVar<T>` is a generic type, which is covariant over `T`/// (like many other types, including `PhantomData<T>` and `Vec<T>`)./// Then, by covariance, `CoVar<SubType>` is a subtype of `CoVar<SuperType>`,/// that is, a value of type `CoVar<SubType>` can be used wherever/// a value of type `CoVar<SuperType>` is expected./// Then if `CoVar<SuperType>` relies on `TypeId::of::<SuperType>()` to uphold any invariants,/// those invariants may be broken because a value of type `CoVar<SuperType>` can be created/// without going through any of its methods, like so:/// type SubType = fn(&());/// type SuperType = fn(&'static ());/// type CoVar<T> = Vec<T>; // imagine something more complicated/// let sub: CoVar<SubType> = CoVar::new();/// // we have a `CoVar<SuperType>` instance without/// // *ever* having called `CoVar::<SuperType>::new()`!/// let fake_super: CoVar<SuperType> = sub;/// The following is an example program that tries to use `TypeId::of` to/// implement a generic type `Unique<T>` that guarantees unique instances for each `Unique<T>`,/// that is, and for each type `T` there can be at most one value of type `Unique<T>` at any time./// mod unique {///     use std::any::TypeId;///     use std::collections::BTreeSet;///     use std::marker::PhantomData;///     use std::sync::Mutex;///     static ID_SET: Mutex<BTreeSet<TypeId>> = Mutex::new(BTreeSet::new());///     // TypeId has only covariant uses, which makes Unique covariant over TypeAsId 🚨///     #[derive(Debug, PartialEq)]///     pub struct Unique<TypeAsId: 'static>(///         // private field prevents creation without `new` outside this module///         PhantomData<TypeAsId>,///     impl<TypeAsId: 'static> Unique<TypeAsId> {///         pub fn new() -> Option<Self> {///             let mut set = ID_SET.lock().unwrap();///             (set.insert(TypeId::of::<TypeAsId>())).then(|| Self(PhantomData))///     impl<TypeAsId: 'static> Drop for Unique<TypeAsId> {///         fn drop(&mut self) {///             (!set.remove(&TypeId::of::<TypeAsId>())).then(|| panic!("duplicity detected"));/// use unique::Unique;/// // `OtherRing` is a subtype of `TheOneRing`. Both are 'static, and thus have a TypeId./// type TheOneRing = fn(&'static ());/// type OtherRing = fn(&());///     let the_one_ring: Unique<TheOneRing> = Unique::new().unwrap();///     assert_eq!(Unique::<TheOneRing>::new(), None);///     let other_ring: Unique<OtherRing> = Unique::new().unwrap();///     // Use that `Unique<OtherRing>` is a subtype of `Unique<TheOneRing>` 🚨///     let fake_one_ring: Unique<TheOneRing> = other_ring;///     assert_eq!(fake_one_ring, the_one_ring);///     std::mem::forget(fake_one_ring);// SAFETY: the raw pointer is always an integer/// Returns the `TypeId` of the generic type parameter./// fn is_string<T: ?Sized + Any>(_s: &T) -> bool {///     TypeId::of::<String>() == TypeId::of::<T>()/// Returns the name of a type as a string slice./// This is intended for diagnostic use. The exact contents and format of the/// string returned are not specified, other than being a best-effort/// description of the type. For example, amongst the strings/// that `type_name::<Option<String>>()` might return are `"Option<String>"` and/// `"std::option::Option<std::string::String>"`./// The returned string must not be considered to be a unique identifier of a/// type as multiple types may map to the same type name. Similarly, there is no/// guarantee that all parts of a type will appear in the returned string. In/// addition, the output may change between versions of the compiler. For/// example, lifetime specifiers were omitted in some earlier versions./// The current implementation uses the same infrastructure as compiler/// diagnostics and debuginfo, but this is not guaranteed.///     std::any::type_name::<Option<String>>(),///     "core::option::Option<alloc::string::String>",type_name_of_val/// Returns the type name of the pointed-to value as a string slice./// This is the same as `type_name::<T>()`, but can be used where the type of a/// variable is not easily available./// Like [`type_name`], this is intended for diagnostic use and the exact output is not/// guaranteed. It provides a best-effort description, but the output may change between/// versions of the compiler./// In short: use this for debugging, avoid using the output to affect program behavior. More/// information is available at [`type_name`]./// Additionally, this function does not resolve trait objects. This means that/// `type_name_of_val(&7u32 as &dyn Debug)` may return `"dyn Debug"`, but will not return `"u32"`/// at this time./// Prints the default integer and float types./// use std::any::type_name_of_val;/// let s = "foo";/// let x: i32 = 1;/// let y: f32 = 1.0;/// assert!(type_name_of_val(&s).contains("str"));/// assert!(type_name_of_val(&x).contains("i32"));/// assert!(type_name_of_val(&y).contains("f32"));//! Utilities for dynamic typing or type reflection.//! # `Any` and `TypeId`//! `Any` itself can be used to get a `TypeId`, and has more features when used//! as a trait object. As `&dyn Any` (a borrowed trait object), it has the `is`//! and `downcast_ref` methods, to test if the contained value is of a given type,//! and to get a reference to the inner value as a type. As `&mut dyn Any`, there//! is also the `downcast_mut` method, for getting a mutable reference to the//! inner value. `Box<dyn Any>` adds the `downcast` method, which attempts to//! convert to a `Box<T>`. See the [`Box`] documentation for the full details.//! Note that `&dyn Any` is limited to testing whether a value is of a specified//! concrete type, and cannot be used to test whether a type implements a trait.//! [`Box`]: ../../std/boxed/struct.Box.html//! # Smart pointers and `dyn Any`//! One piece of behavior to keep in mind when using `Any` as a trait object,//! especially with types like `Box<dyn Any>` or `Arc<dyn Any>`, is that simply//! calling `.type_id()` on the value will produce the `TypeId` of the//! *container*, not the underlying trait object. This can be avoided by//! converting the smart pointer into a `&dyn Any` instead, which will return//! the object's `TypeId`. For example://! use std::any::{Any, TypeId};//! let boxed: Box<dyn Any> = Box::new(3_i32);//! // You're more likely to want this://! let actual_id = (&*boxed).type_id();//! // ... than this://! let boxed_id = boxed.type_id();//! assert_eq!(actual_id, TypeId::of::<i32>());//! assert_eq!(boxed_id, TypeId::of::<Box<dyn Any>>());//! Consider a situation where we want to log a value passed to a function.//! We know the value we're working on implements `Debug`, but we don't know its//! concrete type. We want to give special treatment to certain types: in this//! case printing out the length of `String` values prior to their value.//! We don't know the concrete type of our value at compile time, so we need to//! use runtime reflection instead.//! use std::fmt::Debug;//! use std::any::Any;//! // Logger function for any type that implements `Debug`.//! fn log<T: Any + Debug>(value: &T) {//!     let value_any = value as &dyn Any;//!     // Try to convert our value to a `String`. If successful, we want to//!     // output the `String`'s length as well as its value. If not, it's a//!     // different type: just print it out unadorned.//!     match value_any.downcast_ref::<String>() {//!         Some(as_string) => {//!             println!("String ({}): {}", as_string.len(), as_string);//!         None => {//!             println!("{value:?}");//! // This function wants to log its parameter out prior to doing work with it.//! fn do_work<T: Any + Debug>(value: &T) {//!     log(value);//!     // ...do some other work//!     let my_string = "Hello World".to_string();//!     do_work(&my_string);//!     let my_i8: i8 = 100;//!     do_work(&my_i8);// Any trait// Extension methods for Any trait objects.// TypeID and its methods// some targets don't have anything to reexport, which// makes the `pub use` unused and unreachable, allow// both lints as to not have `#[cfg]`s// cf. https://github.com/rust-lang/rust/pull/116033#issuecomment-1760085575core_archrustc_builtin_macro/// Inline assembly./// Refer to [Rust By Example] for a usage guide and the [reference] for/// detailed information about the syntax and available options./// [Rust By Example]: https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html/// [reference]: https://doc.rust-lang.org/nightly/reference/inline-assembly.htmlnaked_asm/// Inline assembly used in combination with `#[naked]` functions./// Module-level inline assembly.breakpoint/// Compiles to a target-specific software breakpoint instruction or equivalent./// This will typically abort the program. It may result in a core dump, and/or the system logging/// debug information. Additional target-specific capabilities may be possible depending on/// debuggers or other tooling; in particular, a debugger may be able to resume execution./// If possible, this will produce an instruction sequence that allows a debugger to resume *after*/// the breakpoint, rather than resuming *at* the breakpoint; however, the exact behavior is/// target-specific and debugger-specific, and not guaranteed./// If the target platform does not have any kind of debug breakpoint instruction, this may compile/// to a trapping instruction (e.g. an undefined instruction) instead, or to some other form of/// target-specific abort that may or may not support convenient resumption./// The precise behavior and the precise instruction generated are not guaranteed, except that in/// normal execution with no debug tooling involved this will not continue executing./// - On x86 targets, this produces an `int3` instruction./// - On aarch64 targets, this produces a `brk #0xf000` instruction.// When stabilizing this, update the comment on `core::intrinsics::breakpoint`./// Converts this array of bytes into an array of ASCII characters,/// or returns `None` if any of the characters is non-ASCII./// #![feature(ascii_char)]/// const HEX_DIGITS: [std::ascii::Char; 16] =///     *b"0123456789abcdef".as_ascii().unwrap();/// assert_eq!(HEX_DIGITS[1].as_str(), "1");/// assert_eq!(HEX_DIGITS[10].as_str(), "a");as_ascii_unchecked/// without checking whether they're valid./// Every byte in the array must be in `0..=127`, or else this is UB.Destructconjure_zst/// This function returns a function that lets you index the given array in const./// As implemented it can optimize better than iterators, and can be constified./// It acts like a sort of guard (owns the array) and iterator combined, which can be implemented/// as it is a struct that implements const fn;/// in that regard it is somewhat similar to an array::Iter implementing `UncheckedIterator`./// The only method you're really allowed to call is `next()`,/// anything else is more or less UB, hence this function being unsafe./// Moved elements will not be dropped./// This will also not actually store the array./// SAFETY: must only be called `N` times. Thou shalt not drop the array either.// FIXME(const-hack): this is a hack for `let guard = Guard(array); |i| f(guard[i])`.// FIXME(const-hack): This is essentially a slice::IterMut<'static>, replace when possible./// The pointer to the next element to return, or the past-the-end location/// if the drainer is empty./// This address will be used for all ZST elements, never changed./// As we "own" this array, we dont need to store any lifetime./// For non-ZSTs, the non-null pointer to the past-the-end element./// For ZSTs, this is null./// See [`Drain::new`]; this is our fake iterator./// This implementation is useless.// FIXME(const-hack): ideally this would be an unsafe fn `next()`, and to use it you would instead `|_| unsafe { drain.next() }`.BytewiseEqspec_eqspec_neSpecArrayEq// __impl_slice_eq2! { [A; $N], &'b [B; $N] }// __impl_slice_eq2! { [A; $N], &'b mut [B; $N] }NeverShortCircuitpartial_drop/// `self[alive]` are all initialized before the call,/// then are never used (without reinitializing them) after it.PartialDrop/// The elements in `data` that have not been yielded yet./// Invariants:/// - `alive.end <= N`/// (And the `IndexRange` type requires `alive.start <= alive.end`.)/// This is the array we are iterating over./// Elements with index `i` where `alive.start <= i < alive.end` have not/// been yielded yet and are valid array entries. Elements with indices `i/// < alive.start` or `i >= alive.end` have been yielded already and must/// not be accessed anymore! Those dead elements might even be in a/// completely uninitialized state!/// So the invariants are:/// - `data[alive]` is alive (i.e. contains valid elements)/// - `data[..alive.start]` and `data[alive.end..]` are dead (i.e. the///   elements were already read and must not be touched anymore!)PolymorphicIter/// The internals of a by-value array iterator./// The real `array::IntoIter<T, N>` stores a `PolymorphicIter<[MaybeUninit<T>, N]>`/// which it unsizes to `PolymorphicIter<[MaybeUninit<T>]>` to iterate./// `data[alive]` are all initialized./// Iterator-equivalent methods./// We don't implement the actual iterator traits because we want to implement/// things like `try_fold` that require `Self: Sized` (which we're not).//! Defines the `IntoIter` owned iterator for arrays.iter_innerInnerSizedInnerUnsized"ArrayIntoIter"/// A by-value [array] iterator.unsize_mut/// the array (from start to end)./// The array cannot be used after calling this unless `T` implements/// `Copy`, so the whole array is copied./// Arrays have special behavior when calling `.into_iter()` prior to the/// 2021 edition -- see the [array] Editions section for more information./// [array]: prim@array// Note: the `#[rustc_skip_during_method_dispatch(array)]` on `trait IntoIterator`// hides this implementation from explicit `.into_iter()` calls on editions < 2021,/// Creates a new iterator over the given `array`./// Creates an iterator over the elements in a partially-initialized buffer./// If you have a fully-initialized array, then use [`IntoIterator`]./// But this is useful for returning partial results from unsafe code./// - The `buffer[initialized]` elements must all be initialized./// - The range must be canonical, with `initialized.start <= initialized.end`./// - The range must be in-bounds for the buffer, with `initialized.end <= N`.///   (Like how indexing `[0][100..100]` fails despite the range being empty.)/// It's sound to have more elements initialized than mentioned, though that/// will most likely result in them being leaked./// #![feature(array_into_iter_constructors)]/// #![feature(maybe_uninit_uninit_array_transpose)]/// use std::array::IntoIter;/// # // Hi!  Thanks for reading the code. This is restricted to `Copy` because/// # // otherwise it could leak. A fully-general version this would need a drop/// # // guard to handle panics from the iterator, but this works for an example./// fn next_chunk<T: Copy, const N: usize>(///     it: &mut impl Iterator<Item = T>,/// ) -> Result<[T; N], IntoIter<T, N>> {///     let mut buffer = [const { MaybeUninit::uninit() }; N];///     while i < N {///         match it.next() {///             Some(x) => {///                 buffer[i].write(x);///                 i += 1;///                 // SAFETY: We've initialized the first `i` items///                 unsafe {///                     return Err(IntoIter::new_unchecked(buffer, 0..i));///     // SAFETY: We've initialized all N items///     unsafe { Ok(buffer.transpose().assume_init()) }/// let r: [_; 4] = next_chunk(&mut (10..16)).unwrap();/// assert_eq!(r, [10, 11, 12, 13]);/// let r: IntoIter<_, 40> = next_chunk(&mut (10..16)).unwrap_err();/// assert_eq!(r.collect::<Vec<_>>(), vec![10, 11, 12, 13, 14, 15]);/// Creates an iterator over `T` which returns no elements./// If you just need an empty iterator, then use/// [`iter::empty()`](crate::iter::empty) instead./// And if you need an empty array, use `[]`./// But this is useful when you need an `array::IntoIter<T, N>` *specifically*./// let empty = IntoIter::<i32, 3>::empty();/// assert_eq!(empty.len(), 0);/// assert_eq!(empty.as_slice(), &[]);/// let empty = IntoIter::<std::convert::Infallible, 200>::empty();/// `[1, 2].into_iter()` and `[].into_iter()` have different types/// ```should_fail,edition2021/// pub fn get_bytes(b: bool) -> IntoIter<i8, 4> {///     if b {///         [1, 2, 3, 4].into_iter()///         [].into_iter() // error[E0308]: mismatched types/// But using this method you can get an empty iterator of appropriate size:///         IntoIter::empty()/// assert_eq!(get_bytes(true).collect::<Vec<_>>(), vec![1, 2, 3, 4]);/// assert_eq!(get_bytes(false).collect::<Vec<_>>(), vec![]);/// Returns an immutable slice of all elements that have not been yielded/// Returns a mutable slice of all elements that have not been yielded yet.// Even though all the Drop logic could be completely handled by// PolymorphicIter, this impl still serves two purposes:// - Drop has been part of the public API, so we can't remove it// - the partial_drop function doesn't always get fully optimized away//   for !Drop types and ends up as dead code in the final binary.//   Branching on needs_drop higher in the call-tree allows it to be//   removed by earlier optimization passes.// The iterator indeed reports the correct length. The number of "alive"// elements (that will still be yielded) is the length of the range `alive`.// This range is decremented in length in either `next` or `next_back`. It is// always decremented by 1 in those methods, but only if `Some(_)` is returned.// T: Copy as approximation for !Drop since get_unchecked does not advance self.aliveUncheckedIteratorChangeOutputTypeFromResidual/// Creates an array of type `[T; N]` by repeatedly cloning a value./// This is the same as `[val; N]`, but it also works for types that do not/// implement [`Copy`]./// The provided value will be used as an element of the resulting array and/// will be cloned N - 1 times to fill up the rest. If N is zero, the value/// will be dropped./// Creating multiple copies of a `String`:/// use std::array;/// let string = "Hello there!".to_string();/// let strings = array::repeat(string);/// assert_eq!(strings, ["Hello there!", "Hello there!"]);/// Creates an array where each element is produced by calling `f` with/// that element's index while walking forward through the array./// This is essentially the same as writing/// [f(0), f(1), f(2), …, f(N - 2), f(N - 1)]/// and is similar to `(0..i).map(f)`, just for arrays not iterators./// If `N == 0`, this produces an empty array without ever calling `f`./// // type inference is helping us here, the way `from_fn` knows how many/// // elements to produce is the length of array down there: only arrays of/// // equal lengths can be compared, so the const generic parameter `N` is/// // inferred to be 5, thus creating array of 5 elements./// let array = core::array::from_fn(|i| i);/// // indexes are:    0  1  2  3  4/// assert_eq!(array, [0, 1, 2, 3, 4]);/// let array2: [usize; 8] = core::array::from_fn(|i| i * 2);/// // indexes are:     0  1  2  3  4  5   6   7/// assert_eq!(array2, [0, 2, 4, 6, 8, 10, 12, 14]);/// let bool_arr = core::array::from_fn::<_, 5, _>(|i| i % 2 == 0);/// // indexes are:       0     1      2     3      4/// assert_eq!(bool_arr, [true, false, true, false, true]);/// You can also capture things, for example to create an array full of clones/// where you can't just use `[item; N]` because it's not `Copy`:/// # // TBH `array::repeat` would be better for this, but it's not stable yet./// let my_string = String::from("Hello");/// let clones: [String; 42] = std::array::from_fn(|_| my_string.clone());/// assert!(clones.iter().all(|x| *x == my_string));/// The array is generated in ascending index order, starting from the front/// and going towards the back, so you can use closures with mutable state:/// let mut state = 1;/// let a = std::array::from_fn(|_| { let x = state; state *= 2; x });/// assert_eq!(a, [1, 2, 4, 8, 16, 32]);try_from_fn/// Creates an array `[T; N]` where each fallible array element `T` is returned by the `cb` call./// Unlike [`from_fn`], where the element creation can't fail, this version will return an error/// if any element creation was unsuccessful./// The return type of this function depends on the return type of the closure./// If you return `Result<T, E>` from the closure, you'll get a `Result<[T; N], E>`./// If you return `Option<T>` from the closure, you'll get an `Option<[T; N]>`./// * `cb`: Callback where the passed argument is the current array index./// #![feature(array_try_from_fn)]/// let array: Result<[u8; 5], _> = std::array::try_from_fn(|i| i.try_into());/// assert_eq!(array, Ok([0, 1, 2, 3, 4]));/// let array: Result<[i8; 200], _> = std::array::try_from_fn(|i| i.try_into());/// assert!(array.is_err());/// let array: Option<[_; 4]> = std::array::try_from_fn(|i| i.checked_add(100));/// assert_eq!(array, Some([100, 101, 102, 103]));/// let array: Option<[_; 4]> = std::array::try_from_fn(|i| i.checked_sub(100));/// assert_eq!(array, None);/// Converts a reference to `T` into a reference to an array of length 1 (without copying)./// Converts a mutable reference to `T` into a mutable reference to an array of length 1 (without copying)./// The error type returned when a conversion from a slice to an array fails./// Tries to create an array `[T; N]` by copying from a slice `&[T]`./// Succeeds if `slice.len() == N`./// let bytes: [u8; 3] = [1, 0, 2];/// let bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();/// assert_eq!(1, u16::from_le_bytes(bytes_head));/// let bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();/// assert_eq!(512, u16::from_le_bytes(bytes_tail));/// Tries to create an array `[T; N]` by copying from a mutable slice `&mut [T]`./// let mut bytes: [u8; 3] = [1, 0, 2];/// let bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();/// let bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();/// Tries to create an array ref `&[T; N]` from a slice ref `&[T]`. Succeeds if/// `slice.len() == N`./// let bytes_head: &[u8; 2] = <&[u8; 2]>::try_from(&bytes[0..2]).unwrap();/// assert_eq!(1, u16::from_le_bytes(*bytes_head));/// let bytes_tail: &[u8; 2] = bytes[1..3].try_into().unwrap();/// assert_eq!(512, u16::from_le_bytes(*bytes_tail));/// Tries to create a mutable array ref `&mut [T; N]` from a mutable slice ref/// `&mut [T]`. Succeeds if `slice.len() == N`./// let bytes_head: &mut [u8; 2] = <&mut [u8; 2]>::try_from(&mut bytes[0..2]).unwrap();/// let bytes_tail: &mut [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();/// The hash of an array is the same as that of the corresponding slice,/// as required by the `Borrow` implementation./// let a: [u8; 3] = [0xa8, 0x3c, 0x09];/// assert_eq!(b.hash_one(a), b.hash_one(s));/// Implements comparison of arrays [lexicographically](Ord#lexicographical-comparison).SpecArrayClonearray_impl_default/// Returns an array of the same size as `self`, with function `f` applied to each element/// in order./// If you don't necessarily need a new fixed-size array, consider using/// [`Iterator::map`] instead./// # Note on performance and stack usage/// Unfortunately, usages of this method are currently not always optimized/// as well as they could be. This mainly concerns large arrays, as mapping/// over small arrays seem to be optimized just fine. Also note that in/// debug mode (i.e. without any optimizations), this method can use a lot/// of stack space (a few times the size of the array or more)./// Therefore, in performance-critical code, try to avoid using this method/// on large arrays or check the emitted code. Also try to avoid chained/// maps (e.g. `arr.map(...).map(...)`)./// In many cases, you can instead use [`Iterator::map`] by calling `.iter()`/// or `.into_iter()` on your array. `[T; N]::map` is only necessary if you/// really need a new array of the same size as the result. Rust's lazy/// iterators tend to get optimized very well./// let x = [1, 2, 3];/// let y = x.map(|v| v + 1);/// assert_eq!(y, [2, 3, 4]);/// let mut temp = 0;/// let y = x.map(|v| { temp += 1; v * temp });/// assert_eq!(y, [1, 4, 9]);/// let x = ["Ferris", "Bueller's", "Day", "Off"];/// let y = x.map(|v| v.len());/// assert_eq!(y, [6, 9, 3, 3]);/// A fallible function `f` applied to each element on array `self` in order to/// return an array the same size as `self` or the first error encountered./// #![feature(array_try_map)]/// let a = ["1", "2", "3"];/// let b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);/// assert_eq!(b, [2, 3, 4]);/// let a = ["1", "2a", "3"];/// let b = a.try_map(|v| v.parse::<u32>());/// assert!(b.is_err());/// use std::num::NonZero;/// let z = [1, 2, 0, 3, 4];/// assert_eq!(z.try_map(NonZero::new), None);/// let b = a.try_map(NonZero::new);/// let c = b.map(|x| x.map(NonZero::get));/// assert_eq!(c, Some(a));/// Returns a slice containing the entire array. Equivalent to `&s[..]`./// Returns a mutable slice containing the entire array. Equivalent to/// `&mut s[..]`.each_ref/// Borrows each element and returns an array of references with the same/// size as `self`./// let floats = [3.1, 2.7, -1.0];/// let float_refs: [&f64; 3] = floats.each_ref();/// assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);/// This method is particularly useful if combined with other methods, like/// [`map`](#method.map). This way, you can avoid moving the original/// array if its elements are not [`Copy`]./// let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];/// let is_ascii = strings.each_ref().map(|s| s.is_ascii());/// assert_eq!(is_ascii, [true, false, true]);/// // We can still access the original array: it has not been moved./// assert_eq!(strings.len(), 3);each_mut/// Borrows each element mutably and returns an array of mutable references/// with the same size as `self`./// let mut floats = [3.1, 2.7, -1.0];/// let float_refs: [&mut f64; 3] = floats.each_mut();/// *float_refs[0] = 0.0;/// assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);/// assert_eq!(floats, [0.0, 2.7, -1.0]);split_array_ref/// Divides one array reference into two at an index./// The first will contain all indices from `[0, M)` (excluding/// the index `M` itself) and the second will contain all/// indices from `[M, N)` (excluding the index `N` itself)./// Panics if `M > N`./// #![feature(split_array)]/// let v = [1, 2, 3, 4, 5, 6];///    let (left, right) = v.split_array_ref::<0>();///    assert_eq!(left, &[]);///    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);///     let (left, right) = v.split_array_ref::<2>();///     assert_eq!(left, &[1, 2]);///     assert_eq!(right, &[3, 4, 5, 6]);///     let (left, right) = v.split_array_ref::<6>();///     assert_eq!(left, &[1, 2, 3, 4, 5, 6]);///     assert_eq!(right, &[]);split_array_mut/// Divides one mutable array reference into two at an index./// let mut v = [1, 0, 3, 0, 5, 6];/// let (left, right) = v.split_array_mut::<2>();/// assert_eq!(left, &mut [1, 0][..]);/// assert_eq!(right, &mut [3, 0, 5, 6]);/// left[1] = 2;/// right[1] = 4;/// assert_eq!(v, [1, 2, 3, 4, 5, 6]);rsplit_array_ref/// Divides one array reference into two at an index from the end./// The first will contain all indices from `[0, N - M)` (excluding/// the index `N - M` itself) and the second will contain all/// indices from `[N - M, N)` (excluding the index `N` itself).///    let (left, right) = v.rsplit_array_ref::<0>();///    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);///    assert_eq!(right, &[]);///     let (left, right) = v.rsplit_array_ref::<2>();///     assert_eq!(left, &[1, 2, 3, 4]);///     assert_eq!(right, &[5, 6]);///     let (left, right) = v.rsplit_array_ref::<6>();///     assert_eq!(left, &[]);///     assert_eq!(right, &[1, 2, 3, 4, 5, 6]);rsplit_array_mut/// Divides one mutable array reference into two at an index from the end./// let (left, right) = v.rsplit_array_mut::<4>();/// assert_eq!(left, &mut [1, 0]);/// assert_eq!(right, &mut [3, 0, 5, 6][..]);from_trusted_iterator/// Populate an array from the first `N` elements of `iter`/// If the iterator doesn't actually have enough items./// By depending on `TrustedLen`, however, we can do that check up-front (where/// it easily optimizes away) so it doesn't impact the loop that fills the array.try_from_trusted_iteratortry_from_fn_erased/// Version of [`try_from_fn`] using a passed-in slice in order to avoid/// needing to monomorphize for every array length./// This takes a generator rather than an iterator so that *at the type level*/// it never needs to worry about running out of items.  When combined with/// an infallible `Try` type, that means the loop canonicalizes easily, allowing/// it to optimize well./// It would be *possible* to unify this and [`iter_next_chunk_erased`] into one/// function that does the union of both things, but last time it was that way/// it resulted in poor codegen from the "are there enough source items?" checks/// not optimizing away.  So if you give it a shot, make sure to watch what/// happens in the codegen tests./// The array to be initialized./// The number of items that have been initialized so far./// Panic guard for incremental initialization of arrays./// Disarm the guard with `mem::forget` once the array has been initialized./// All write accesses to this structure are unsafe and must maintain a correct/// count of `initialized` elements./// To minimize indirection, fields are still pub but callers should at least use/// `push_unchecked` to signal that something unsafe is going on./// Adds an item to the array and updates the initialized item counter./// No more than N elements must be initialized.iter_next_chunk/// Pulls `N` items from `iter` and returns them as an array. If the iterator/// yields fewer than `N` items, `Err` is returned containing an iterator over/// the already yielded items./// Since the iterator is passed as a mutable reference and this function calls/// `next` at most `N` times, the iterator can still be used afterwards to/// retrieve the remaining items./// If `iter.next()` panics, all items already yielded by the iterator are/// Used for [`Iterator::next_chunk`].iter_next_chunk_erased/// Version of [`iter_next_chunk`] using a passed-in slice in order to avoid/// Unfortunately this loop has two exit conditions, the buffer filling up/// or the iterator running out of items, making it tend to optimize poorly.//! Utilities for the array primitive type.//! *[See also the array primitive type](array).*// The Default impls cannot be done with const generics because `[T; 0]` doesn't// require Default to be implemented, and having different impl blocks for// different numbers isn't supported yet.// Trying to improve the `[T; 0]` situation has proven to be difficult.// Please see these issues for more context on past attempts and crater runs:// - https://github.com/rust-lang/rust/issues/61415// - https://github.com/rust-lang/rust/pull/145457/// U+0000 (The default variant)StartOfHeading/// U+0001StartOfText/// U+0002EndOfText/// U+0003EndOfTransmission/// U+0004Enquiry/// U+0005Acknowledge/// U+0006/// U+0007/// U+0008CharacterTabulation/// U+0009/// U+000ALineTabulation/// U+000B/// U+000C/// U+000DShiftOut/// U+000EShiftIn/// U+000FDataLinkEscape/// U+0010DeviceControlOne/// U+0011DeviceControlTwo/// U+0012DeviceControlThree/// U+0013DeviceControlFour/// U+0014NegativeAcknowledge/// U+0015SynchronousIdle/// U+0016EndOfTransmissionBlock/// U+0017/// U+0018EndOfMedium/// U+0019Substitute/// U+001A/// U+001BInformationSeparatorFour/// U+001CInformationSeparatorThree/// U+001DInformationSeparatorTwo/// U+001EInformationSeparatorOne/// U+001F/// U+0020ExclamationMark/// U+0021QuotationMark/// U+0022NumberSign/// U+0023DollarSign/// U+0024PercentSign/// U+0025Ampersand/// U+0026/// U+0027LeftParenthesis/// U+0028RightParenthesis/// U+0029Asterisk/// U+002APlusSign/// U+002B/// U+002CHyphenMinus/// U+002DFullStop/// U+002E/// U+002F/// U+0030/// U+0031/// U+0032/// U+0033/// U+0034/// U+0035/// U+0036/// U+0037/// U+0038/// U+0039/// U+003A/// U+003BLessThanSign/// U+003CEqualsSign/// U+003DGreaterThanSign/// U+003EQuestionMark/// U+003FCommercialAt/// U+0040CapitalA/// U+0041CapitalB/// U+0042CapitalC/// U+0043CapitalD/// U+0044CapitalE/// U+0045CapitalF/// U+0046CapitalG/// U+0047CapitalH/// U+0048CapitalI/// U+0049CapitalJ/// U+004ACapitalK/// U+004BCapitalL/// U+004CCapitalM/// U+004DCapitalN/// U+004ECapitalO/// U+004FCapitalP/// U+0050CapitalQ/// U+0051CapitalR/// U+0052CapitalS/// U+0053CapitalT/// U+0054CapitalU/// U+0055CapitalV/// U+0056CapitalW/// U+0057CapitalX/// U+0058CapitalY/// U+0059CapitalZ/// U+005ALeftSquareBracket/// U+005B/// U+005CRightSquareBracket/// U+005DCircumflexAccent/// U+005ELowLine/// U+005FGraveAccent/// U+0060SmallA/// U+0061SmallB/// U+0062SmallC/// U+0063SmallD/// U+0064SmallE/// U+0065SmallF/// U+0066SmallG/// U+0067SmallH/// U+0068SmallI/// U+0069SmallJ/// U+006ASmallK/// U+006BSmallL/// U+006CSmallM/// U+006DSmallN/// U+006ESmallO/// U+006FSmallP/// U+0070SmallQ/// U+0071SmallR/// U+0072SmallS/// U+0073SmallT/// U+0074SmallU/// U+0075SmallV/// U+0076SmallW/// U+0077SmallX/// U+0078SmallY/// U+0079SmallZ/// U+007ALeftCurlyBracket/// U+007BVerticalLine/// U+007CRightCurlyBracket/// U+007D/// U+007E/// U+007F/// One of the 128 Unicode characters from U+0000 through U+007F,/// often known as the [ASCII] subset./// Officially, this is the first [block] in Unicode, _Basic Latin_./// For details, see the [*C0 Controls and Basic Latin*][chart] code chart./// This block was based on older 7-bit character code standards such as/// ANSI X3.4-1977, ISO 646-1973, and [NIST FIPS 1-2]./// # When to use this/// The main advantage of this subset is that it's always valid UTF-8.  As such,/// the `&[ascii::Char]` -> `&str` conversion function (as well as other related/// ones) are O(1): *no* runtime checks are needed./// If you're consuming strings, you should usually handle Unicode and thus/// accept `str`s, not limit yourself to `ascii::Char`s./// However, certain formats are intentionally designed to produce ASCII-only/// output in order to be 8-bit-clean.  In those cases, it can be simpler and/// faster to generate `ascii::Char`s instead of dealing with the variable width/// properties of general UTF-8 encoded strings, while still allowing the result/// to be used freely with other Rust things that deal in general `str`s./// For example, a UUID library might offer a way to produce the string/// representation of a UUID as an `[ascii::Char; 36]` to avoid memory/// allocation yet still allow it to be used as UTF-8 via `as_str` without/// paying for validation (or needing `unsafe` code) the way it would if it/// were provided as a `[u8; 36]`./// This type is guaranteed to have a size and alignment of 1 byte./// # Names/// The variants on this type are [Unicode names][NamesList] of the characters/// in upper camel case, with a few tweaks:/// - For `<control>` characters, the primary alias name is used./// - `LATIN` is dropped, as this block has no non-latin letters./// - `LETTER` is dropped, as `CAPITAL`/`SMALL` suffices in this block./// - `DIGIT`s use a single digit rather than writing out `ZERO`, `ONE`, etc./// [ASCII]: https://www.unicode.org/glossary/index.html#ASCII/// [block]: https://www.unicode.org/glossary/index.html#block/// [chart]: https://www.unicode.org/charts/PDF/U0000.pdf/// [NIST FIPS 1-2]: https://nvlpubs.nist.gov/nistpubs/Legacy/FIPS/fipspub1-2-1977.pdf/// [NamesList]: https://www.unicode.org/Public/15.0.0/ucd/NamesList.txt/// The character with the lowest ASCII code./// The character with the highest ASCII code./// Creates an ASCII character from the byte `b`,/// or returns `None` if it's too large.from_u8_unchecked/// without checking whether it's valid./// `b` must be in `0..=127`, or else this is UB./// When passed the *number* `0`, `1`, …, `9`, returns the *character*/// `'0'`, `'1'`, …, `'9'` respectively./// If `d >= 10`, returns `None`.digit_unchecked/// `'0'`, `'1'`, …, `'9'` respectively, without checking that it's in-range./// This is immediate UB if called with `d > 64`./// If `d >= 10` and `d <= 64`, this is allowed to return any value or panic./// Notably, it should not be expected to return hex digits, or any other/// reasonable extension of the decimal digits./// (This loose safety condition is intended to simplify soundness proofs/// when writing code using this method, since the implementation doesn't/// need something really specific, not to make those other arguments do/// something useful. It might be tightened before stabilization.)/// Gets this ASCII character as a byte./// Gets this ASCII character as a `char` Unicode Scalar Value./// Views this ASCII character as a one-code-unit UTF-8 `str`."to uppercase the value in-place, use `make_uppercase()`"/// Makes a copy of the value in its upper case equivalent./// Letters 'a' to 'z' are mapped to 'A' to 'Z'./// To uppercase the value in-place, use [`make_uppercase`]./// #![feature(ascii_char, ascii_char_variants)]/// use std::ascii;/// let lowercase_a = ascii::Char::SmallA;///     ascii::Char::CapitalA,///     lowercase_a.to_uppercase(),/// [`make_uppercase`]: Self::make_uppercase"to lowercase the value in-place, use `make_lowercase()`"/// Makes a copy of the value in its lower case equivalent./// Letters 'A' to 'Z' are mapped to 'a' to 'z'./// To lowercase the value in-place, use [`make_lowercase`]./// let uppercase_a = ascii::Char::CapitalA;///     ascii::Char::SmallA,///     uppercase_a.to_lowercase(),/// [`make_lowercase`]: Self::make_lowercase/// Checks that two values are a case-insensitive match./// This is equivalent to `to_lowercase(a) == to_lowercase(b)`./// assert!(lowercase_a.eq_ignore_case(uppercase_a));make_uppercase/// Converts this value to its upper case equivalent in-place./// To return a new uppercased value without modifying the existing one, use/// let mut letter_a = ascii::Char::SmallA;/// letter_a.make_uppercase();/// assert_eq!(ascii::Char::CapitalA, letter_a);/// [`to_uppercase`]: Self::to_uppercasemake_lowercase/// Converts this value to its lower case equivalent in-place./// To return a new lowercased value without modifying the existing one, use/// let mut letter_a = ascii::Char::CapitalA;/// letter_a.make_lowercase();/// assert_eq!(ascii::Char::SmallA, letter_a);/// [`to_lowercase`]: Self::to_lowercase/// Checks if the value is an alphabetic character:/// - 0x41 'A' ..= 0x5A 'Z', or/// - 0x61 'a' ..= 0x7A 'z'./// let uppercase_g = ascii::Char::CapitalG;/// let a = ascii::Char::SmallA;/// let g = ascii::Char::SmallG;/// let zero = ascii::Char::Digit0;/// let percent = ascii::Char::PercentSign;/// let space = ascii::Char::Space;/// let lf = ascii::Char::LineFeed;/// let esc = ascii::Char::Escape;/// assert!(uppercase_a.is_alphabetic());/// assert!(uppercase_g.is_alphabetic());/// assert!(a.is_alphabetic());/// assert!(g.is_alphabetic());/// assert!(!zero.is_alphabetic());/// assert!(!percent.is_alphabetic());/// assert!(!space.is_alphabetic());/// assert!(!lf.is_alphabetic());/// assert!(!esc.is_alphabetic());/// Checks if the value is an uppercase character:/// 0x41 'A' ..= 0x5A 'Z'./// assert!(uppercase_a.is_uppercase());/// assert!(uppercase_g.is_uppercase());/// assert!(!a.is_uppercase());/// assert!(!g.is_uppercase());/// assert!(!zero.is_uppercase());/// assert!(!percent.is_uppercase());/// assert!(!space.is_uppercase());/// assert!(!lf.is_uppercase());/// assert!(!esc.is_uppercase());is_lowercase/// Checks if the value is a lowercase character:/// 0x61 'a' ..= 0x7A 'z'./// assert!(!uppercase_a.is_lowercase());/// assert!(!uppercase_g.is_lowercase());/// assert!(a.is_lowercase());/// assert!(g.is_lowercase());/// assert!(!zero.is_lowercase());/// assert!(!percent.is_lowercase());/// assert!(!space.is_lowercase());/// assert!(!lf.is_lowercase());/// assert!(!esc.is_lowercase());/// Checks if the value is an alphanumeric character:/// - 0x61 'a' ..= 0x7A 'z', or/// - 0x30 '0' ..= 0x39 '9'./// assert!(uppercase_a.is_alphanumeric());/// assert!(uppercase_g.is_alphanumeric());/// assert!(a.is_alphanumeric());/// assert!(g.is_alphanumeric());/// assert!(zero.is_alphanumeric());/// assert!(!percent.is_alphanumeric());/// assert!(!space.is_alphanumeric());/// assert!(!lf.is_alphanumeric());/// assert!(!esc.is_alphanumeric());/// Checks if the value is a decimal digit:/// 0x30 '0' ..= 0x39 '9'./// assert!(!uppercase_a.is_digit());/// assert!(!uppercase_g.is_digit());/// assert!(!a.is_digit());/// assert!(!g.is_digit());/// assert!(zero.is_digit());/// assert!(!percent.is_digit());/// assert!(!space.is_digit());/// assert!(!lf.is_digit());/// assert!(!esc.is_digit());is_octdigit/// Checks if the value is an octal digit:/// 0x30 '0' ..= 0x37 '7'./// #![feature(ascii_char, ascii_char_variants, is_ascii_octdigit)]/// let seven = ascii::Char::Digit7;/// let eight = ascii::Char::Digit8;/// assert!(!uppercase_a.is_octdigit());/// assert!(!a.is_octdigit());/// assert!(zero.is_octdigit());/// assert!(seven.is_octdigit());/// assert!(!eight.is_octdigit());/// assert!(!percent.is_octdigit());/// assert!(!lf.is_octdigit());/// assert!(!esc.is_octdigit());// This is blocked on two unstable features. Please ensure both are// stabilized before marking this method as stable.// #[unstable(feature = "is_ascii_octdigit", issue = "101288")]is_hexdigit/// Checks if the value is a hexadecimal digit:/// - 0x30 '0' ..= 0x39 '9', or/// - 0x41 'A' ..= 0x46 'F', or/// - 0x61 'a' ..= 0x66 'f'./// assert!(uppercase_a.is_hexdigit());/// assert!(!uppercase_g.is_hexdigit());/// assert!(a.is_hexdigit());/// assert!(!g.is_hexdigit());/// assert!(zero.is_hexdigit());/// assert!(!percent.is_hexdigit());/// assert!(!space.is_hexdigit());/// assert!(!lf.is_hexdigit());/// assert!(!esc.is_hexdigit());/// Checks if the value is a punctuation character:/// - 0x21 ..= 0x2F `! " # $ % & ' ( ) * + , - . /`, or/// - 0x3A ..= 0x40 `: ; < = > ? @`, or/// - 0x5B ..= 0x60 `` [ \ ] ^ _ ` ``, or/// - 0x7B ..= 0x7E `{ | } ~`/// assert!(!uppercase_a.is_punctuation());/// assert!(!uppercase_g.is_punctuation());/// assert!(!a.is_punctuation());/// assert!(!g.is_punctuation());/// assert!(!zero.is_punctuation());/// assert!(percent.is_punctuation());/// assert!(!space.is_punctuation());/// assert!(!lf.is_punctuation());/// assert!(!esc.is_punctuation());is_graphic/// Checks if the value is a graphic character:/// 0x21 '!' ..= 0x7E '~'./// assert!(uppercase_a.is_graphic());/// assert!(uppercase_g.is_graphic());/// assert!(a.is_graphic());/// assert!(g.is_graphic());/// assert!(zero.is_graphic());/// assert!(percent.is_graphic());/// assert!(!space.is_graphic());/// assert!(!lf.is_graphic());/// assert!(!esc.is_graphic());/// Checks if the value is a whitespace character:/// 0x20 SPACE, 0x09 HORIZONTAL TAB, 0x0A LINE FEED,/// 0x0C FORM FEED, or 0x0D CARRIAGE RETURN./// Rust uses the WhatWG Infra Standard's [definition of ASCII/// whitespace][infra-aw]. There are several other definitions in/// wide use. For instance, [the POSIX locale][pct] includes/// 0x0B VERTICAL TAB as well as all the above characters,/// but—from the very same specification—[the default rule for/// "field splitting" in the Bourne shell][bfs] considers *only*/// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace./// If you are writing a program that will process an existing/// file format, check what that format's definition of whitespace is/// before using this function./// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace/// [pct]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01/// [bfs]: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05/// assert!(!uppercase_a.is_whitespace());/// assert!(!uppercase_g.is_whitespace());/// assert!(!a.is_whitespace());/// assert!(!g.is_whitespace());/// assert!(!zero.is_whitespace());/// assert!(!percent.is_whitespace());/// assert!(space.is_whitespace());/// assert!(lf.is_whitespace());/// assert!(!esc.is_whitespace());/// Checks if the value is a control character:/// 0x00 NUL ..= 0x1F UNIT SEPARATOR, or 0x7F DELETE./// Note that most whitespace characters are control/// characters, but SPACE is not./// assert!(!uppercase_a.is_control());/// assert!(!uppercase_g.is_control());/// assert!(!a.is_control());/// assert!(!g.is_control());/// assert!(!zero.is_control());/// assert!(!percent.is_control());/// assert!(!space.is_control());/// assert!(lf.is_control());/// assert!(esc.is_control());"this returns the escaped character as an iterator, \
                  without modifying the original"escape_ascii/// Returns an iterator that produces an escaped version of a/// The behavior is identical to/// [`ascii::escape_default`](crate::ascii::escape_default)./// let tab = ascii::Char::CharacterTabulation;/// let cr = ascii::Char::CarriageReturn;/// let apostrophe = ascii::Char::Apostrophe;/// let double_quote = ascii::Char::QuotationMark;/// let backslash = ascii::Char::ReverseSolidus;/// assert_eq!("0", zero.escape_ascii().to_string());/// assert_eq!("\\t", tab.escape_ascii().to_string());/// assert_eq!("\\r", cr.escape_ascii().to_string());/// assert_eq!("\\n", lf.escape_ascii().to_string());/// assert_eq!("\\'", apostrophe.escape_ascii().to_string());/// assert_eq!("\\\"", double_quote.escape_ascii().to_string());/// assert_eq!("\\\\", backslash.escape_ascii().to_string());into_int_impl/// Views this slice of ASCII characters as a UTF-8 `str`./// Views this slice of ASCII characters as a slice of `u8` bytes.//! This uses the name `AsciiChar`, even though it's not exposed that way right now,//! because it avoids a whole bunch of "are you sure you didn't mean `char`?"//! suggestions from rustc if you get anything slightly wrong in here, and overall//! helps with clarity as we're also referring to `char` intentionally in here.AlwaysEscapedEscapeIterInner/// An iterator over the escaped version of a byte./// This `struct` is created by the [`escape_default`] function. See its/// Returns an iterator that produces an escaped version of a `u8`./// The default is chosen with a bias toward producing literals that are/// legal in a variety of languages, including C++11 and similar C-family/// languages. The exact rules are:/// * Tab is escaped as `\t`./// * Carriage return is escaped as `\r`./// * Line feed is escaped as `\n`./// * Single quote is escaped as `\'`./// * Double quote is escaped as `\"`./// * Backslash is escaped as `\\`./// * Any character in the 'printable ASCII' range `0x20` .. `0x7e`///   inclusive is not escaped./// * Any other chars are given hex escapes of the form '\xNN'./// * Unicode escapes are never generated by this function./// let escaped = ascii::escape_default(b'0').next().unwrap();/// assert_eq!(b'0', escaped);/// let mut escaped = ascii::escape_default(b'\t');/// assert_eq!(b'\\', escaped.next().unwrap());/// assert_eq!(b't', escaped.next().unwrap());/// let mut escaped = ascii::escape_default(b'\r');/// assert_eq!(b'r', escaped.next().unwrap());/// let mut escaped = ascii::escape_default(b'\n');/// assert_eq!(b'n', escaped.next().unwrap());/// let mut escaped = ascii::escape_default(b'\'');/// assert_eq!(b'\'', escaped.next().unwrap());/// let mut escaped = ascii::escape_default(b'"');/// assert_eq!(b'"', escaped.next().unwrap());/// let mut escaped = ascii::escape_default(b'\\');/// let mut escaped = ascii::escape_default(b'\x9d');/// assert_eq!(b'x', escaped.next().unwrap());/// assert_eq!(b'9', escaped.next().unwrap());/// assert_eq!(b'd', escaped.next().unwrap());//! Operations on ASCII strings and characters.//! Most string operations in Rust act on UTF-8 strings. However, at times it//! makes more sense to only consider the ASCII character set for a specific//! The [`escape_default`] function provides an iterator over the bytes of an//! escaped version of the character given.TryCaptureWithoutDebug/// Marker used by [Capture]try_capture/// Similar to [TryCapturePrintable] but generic to any `E`.TryCaptureGeneric/// Catches an arbitrary `E` and modifies `to` accordinglyTryCaptureWithDebug/// Similar as [TryCaptureGeneric] but specialized to any `E: Printable`.TryCapturePrintable/// Catches an arbitrary `E: Printable` and modifies `to` accordinglyPrintable// If None, then `E` does not implements [Printable] or `E` wasn't evaluated (`assert!( ... )`// short-circuited).// If Some, then `E` implements [Printable] and was evaluated.//spellchecker:off/// All possible captured `assert!` elements/// * `E`: **E**lement that is going to be displayed./// * `M`: **M**arker used to differentiate [Capture]s in regards to [Debug].//spellchecker:on/// Necessary for the implementations of `TryCapture*`/// Tells which elements can be copied and displayed// Contains the machinery necessary to print useful `assert!` messages. Not intended for public// usage, not even nightly use-cases.// Based on https://github.com/dtolnay/case-studies/tree/master/autoref-specialization. When// 'specialization' is robust enough (5 years? 10 years? Never?), `Capture` can be specialized// to [Printable].// ***** TryCapture - Generic *****// ***** TryCapture - Printable *****// ***** Others *****/// The type of items yielded by the async iterator."async_iterator_poll_next"/// Attempts to pull out the next value of this async iterator, registering the/// `None` if the async iterator is exhausted./// async iterator state:/// - `Poll::Pending` means that this async iterator's next value is not ready/// - `Poll::Ready(Some(val))` means that the async iterator has successfully/// - `Poll::Ready(None)` means that the async iterator has terminated, and/// Once an async iterator has finished (returned `Ready(None)` from `poll_next`), calling its/// problems; the `AsyncIterator` trait places no requirements on the effects of/// regardless of the async iterator's state./// Returns the bounds on the remaining length of the async iterator./// The second half of the tuple that is returned is an <code>[Option]<[usize]></code>./// It is not enforced that an async iterator implementation yields the declared/// number of elements. A buggy async iterator may yield less than the lower bound/// reserving space for the elements of the async iterator, but must not be/// The default implementation returns <code>(0, [None])</code> which is correct for any/// async iterator."async iterators do nothing unless polled""async_iterator"/// A trait for dealing with asynchronous iterators./// This is the main async iterator trait. For more about the concept of async iterators/// generally, please see the [module-level documentation]. In particular, you/// may want to know how to [implement `AsyncIterator`][impl]./// [module-level documentation]: index.html/// [impl]: index.html#implementing-async-iterator"AsyncGenReady"async_gen_ready/// A helper function for internal desugaring -- produces `Ready(Some(t))`,/// which corresponds to the async iterator yielding a value."AsyncGenPending"/// A helper constant for internal desugaring -- produces `Pending`,/// which corresponds to the async iterator pending on an `.await`.// FIXME(gen_blocks): This probably could be deduplicated."AsyncGenFinished"/// A helper constant for internal desugaring -- produces `Ready(None)`,/// which corresponds to the async iterator finishing its iteration./// The type of the item yielded by the iteratorIntoAsyncIter/// The type of the resulting iterator"into_async_iter_into_iter"into_async_iter/// Converts `self` into an async iteratorIntoAsyncIterator/// Converts something into an async iteratorFromIter/// An async iterator that was created from iterator./// This async iterator is created by the [`from_iter`] function./// See it documentation for more./// [`from_iter`]: fn.from_iter.html/// Converts an iterator into an async iterator.//! Composable asynchronous iteration.//! If you've found yourself with an asynchronous collection of some kind,//! and needed to perform an operation on the elements of said collection,//! you'll quickly run into 'async iterators'. Async Iterators are heavily used in//! idiomatic asynchronous Rust code, so it's worth becoming familiar with them.//! Before explaining more, let's talk about how this module is structured://! This module is largely organized by type://! * [Traits] are the core portion: these traits define what kind of async iterators//!   exist and what you can do with them. The methods of these traits are worth//!   putting some extra study time into.//! * Functions provide some helpful ways to create some basic async iterators.//! * Structs are often the return types of the various methods on this//!   module's traits. You'll usually want to look at the method that creates//!   the `struct`, rather than the `struct` itself. For more detail about why,//!   see '[Implementing Async Iterator](#implementing-async-iterator)'.//! [Traits]: #traits//! That's it! Let's dig into async iterators.//! # Async Iterators//! The heart and soul of this module is the [`AsyncIterator`] trait. The core of//! [`AsyncIterator`] looks like this://! # use core::task::{Context, Poll};//! # use core::pin::Pin;//! trait AsyncIterator {//!     type Item;//!     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;//! Unlike `Iterator`, `AsyncIterator` makes a distinction between the [`poll_next`]//! method which is used when implementing an `AsyncIterator`, and a (to-be-implemented)//! `next` method which is used when consuming an async iterator. Consumers of `AsyncIterator`//! only need to consider `next`, which when called, returns a future which//! yields `Option<AsyncIterator::Item>`.//! The future returned by `next` will yield `Some(Item)` as long as there are//! elements, and once they've all been exhausted, will yield `None` to indicate//! that iteration is finished. If we're waiting on something asynchronous to//! resolve, the future will wait until the async iterator is ready to yield again.//! Individual async iterators may choose to resume iteration, and so calling `next`//! again may or may not eventually yield `Some(Item)` again at some point.//! [`AsyncIterator`]'s full definition includes a number of other methods as well,//! but they are default methods, built on top of [`poll_next`], and so you get//! them for free.//! [`Poll`]: super::task::Poll//! [`poll_next`]: AsyncIterator::poll_next//! # Implementing Async Iterator//! Creating an async iterator of your own involves two steps: creating a `struct` to//! hold the async iterator's state, and then implementing [`AsyncIterator`] for that//! `struct`.//! Let's make an async iterator named `Counter` which counts from `1` to `5`://! #![feature(async_iterator)]//! # use core::async_iter::AsyncIterator;//! // First, the struct://! /// An async iterator which counts from one to five//! struct Counter {//!     count: usize,//! // we want our count to start at one, so let's add a new() method to help.//! // This isn't strictly necessary, but is convenient. Note that we start//! // `count` at zero, we'll see why in `poll_next()`'s implementation below.//! impl Counter {//!     fn new() -> Counter {//!         Counter { count: 0 }//! // Then, we implement `AsyncIterator` for our `Counter`://! impl AsyncIterator for Counter {//!     // we will be counting with usize//!     type Item = usize;//!     // poll_next() is the only required method//!     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {//!         // Increment our count. This is why we started at zero.//!         self.count += 1;//!         // Check to see if we've finished counting or not.//!         if self.count < 6 {//!             Poll::Ready(Some(self.count))//!             Poll::Ready(None)//! # Laziness//! Async iterators are *lazy*. This means that just creating an async iterator doesn't//! _do_ a whole lot. Nothing really happens until you call `poll_next`. This is//! sometimes a source of confusion when creating an async iterator solely for its side//! effects. The compiler will warn us about this kind of behavior://! warning: unused result that must be used: async iterators do nothing unless polled/// Returns `Some(t)` if the `bool` is [`true`](../std/keyword.true.html),/// or `None` otherwise./// Arguments passed to `then_some` are eagerly evaluated; if you are/// passing the result of a function call, it is recommended to use/// [`then`], which is lazily evaluated./// [`then`]: bool::then/// assert_eq!(false.then_some(0), None);/// assert_eq!(true.then_some(0), Some(0));/// let mut a = 0;/// let mut function_with_side_effects = || { a += 1; };/// true.then_some(function_with_side_effects());/// false.then_some(function_with_side_effects());/// // `a` is incremented twice because the value passed to `then_some` is/// // evaluated eagerly./// assert_eq!(a, 2);"bool_then"/// Returns `Some(f())` if the `bool` is [`true`](../std/keyword.true.html),/// assert_eq!(false.then(|| 0), None);/// assert_eq!(true.then(|| 0), Some(0));/// true.then(|| { a += 1; });/// false.then(|| { a += 1; });/// // `a` is incremented once because the closure is evaluated lazily by/// // `then`./// assert_eq!(a, 1);/// Returns `Ok(())` if the `bool` is [`true`](../std/keyword.true.html),/// or `Err(err)` otherwise./// Arguments passed to `ok_or` are eagerly evaluated; if you are/// [`ok_or_else`], which is lazily evaluated./// [`ok_or_else`]: bool::ok_or_else/// #![feature(bool_to_result)]/// assert_eq!(false.ok_or(0), Err(0));/// assert_eq!(true.ok_or(0), Ok(()));/// assert!(true.ok_or(function_with_side_effects()).is_ok());/// assert!(false.ok_or(function_with_side_effects()).is_err());/// // `a` is incremented twice because the value passed to `ok_or` isok_or_else/// or `Err(f())` otherwise./// assert_eq!(false.ok_or_else(|| 0), Err(0));/// assert_eq!(true.ok_or_else(|| 0), Ok(()));/// assert!(true.ok_or_else(|| { a += 1; }).is_ok());/// assert!(false.ok_or_else(|| { a += 1; }).is_err());/// // `ok_or_else`.//! impl bool {}/// Immutably borrows from an owned value./// use std::borrow::Borrow;/// fn check<T: Borrow<str>>(s: T) {///     assert_eq!("Hello", s.borrow());/// let s = "Hello".to_string();/// check(s);/// let s = "Hello";"Borrow"/// A trait for borrowing data./// In Rust, it is common to provide different representations of a type for/// different use cases. For instance, storage location and management for a/// value can be specifically chosen as appropriate for a particular use via/// pointer types such as [`Box<T>`] or [`Rc<T>`]. Beyond these generic/// wrappers that can be used with any type, some types provide optional/// facets providing potentially costly functionality. An example for such a/// type is [`String`] which adds the ability to extend a string to the basic/// [`str`]. This requires keeping additional information unnecessary for a/// simple, immutable string./// These types provide access to the underlying data through references/// to the type of that data. They are said to be ‘borrowed as’ that type./// For instance, a [`Box<T>`] can be borrowed as `T` while a [`String`]/// can be borrowed as `str`./// Types express that they can be borrowed as some type `T` by implementing/// `Borrow<T>`, providing a reference to a `T` in the trait’s/// [`borrow`] method. A type is free to borrow as several different types./// If it wishes to mutably borrow as the type, allowing the underlying data/// to be modified, it can additionally implement [`BorrowMut<T>`]./// Further, when providing implementations for additional traits, it needs/// to be considered whether they should behave identically to those of the/// underlying type as a consequence of acting as a representation of that/// underlying type. Generic code typically uses `Borrow<T>` when it relies/// on the identical behavior of these additional trait implementations./// These traits will likely appear as additional trait bounds./// In particular `Eq`, `Ord` and `Hash` must be equivalent for/// borrowed and owned values: `x.borrow() == y.borrow()` should give the/// same result as `x == y`./// If generic code merely needs to work for all types that can/// provide a reference to related type `T`, it is often better to use/// [`AsRef<T>`] as more types can safely implement it./// [`Box<T>`]: ../../std/boxed/struct.Box.html/// [`Mutex<T>`]: ../../std/sync/struct.Mutex.html/// [`Rc<T>`]: ../../std/rc/struct.Rc.html/// [`String`]: ../../std/string/struct.String.html/// [`borrow`]: Borrow::borrow/// As a data collection, [`HashMap<K, V>`] owns both keys and values. If/// the key’s actual data is wrapped in a managing type of some kind, it/// should, however, still be possible to search for a value using a/// reference to the key’s data. For instance, if the key is a string, then/// it is likely stored with the hash map as a [`String`], while it should/// be possible to search using a [`&str`][`str`]. Thus, `insert` needs to/// operate on a `String` while `get` needs to be able to use a `&str`./// Slightly simplified, the relevant parts of `HashMap<K, V>` look like/// pub struct HashMap<K, V> {///     # marker: ::std::marker::PhantomData<(K, V)>,///     // fields omitted/// impl<K, V> HashMap<K, V> {///     pub fn insert(&self, key: K, value: V) -> Option<V>///     where K: Hash + Eq///     pub fn get<Q>(&self, k: &Q) -> Option<&V>///         K: Borrow<Q>,///         Q: Hash + Eq + ?Sized/// The entire hash map is generic over a key type `K`. Because these keys/// are stored with the hash map, this type has to own the key’s data./// When inserting a key-value pair, the map is given such a `K` and needs/// to find the correct hash bucket and check if the key is already present/// based on that `K`. It therefore requires `K: Hash + Eq`./// When searching for a value in the map, however, having to provide a/// reference to a `K` as the key to search for would require to always/// create such an owned value. For string keys, this would mean a `String`/// value needs to be created just for the search for cases where only a/// `str` is available./// Instead, the `get` method is generic over the type of the underlying key/// data, called `Q` in the method signature above. It states that `K`/// borrows as a `Q` by requiring that `K: Borrow<Q>`. By additionally/// requiring `Q: Hash + Eq`, it signals the requirement that `K` and `Q`/// have implementations of the `Hash` and `Eq` traits that produce identical/// The implementation of `get` relies in particular on identical/// implementations of `Hash` by determining the key’s hash bucket by calling/// `Hash::hash` on the `Q` value even though it inserted the key based on/// the hash value calculated from the `K` value./// As a consequence, the hash map breaks if a `K` wrapping a `Q` value/// produces a different hash than `Q`. For instance, imagine you have a/// type that wraps a string but compares ASCII letters ignoring their case:/// pub struct CaseInsensitiveString(String);/// impl PartialEq for CaseInsensitiveString {///         self.0.eq_ignore_ascii_case(&other.0)/// impl Eq for CaseInsensitiveString { }/// Because two equal values need to produce the same hash value, the/// implementation of `Hash` needs to ignore ASCII case, too:/// # pub struct CaseInsensitiveString(String);/// impl Hash for CaseInsensitiveString {///     fn hash<H: Hasher>(&self, state: &mut H) {///         for c in self.0.as_bytes() {///             c.to_ascii_lowercase().hash(state)/// Can `CaseInsensitiveString` implement `Borrow<str>`? It certainly can/// provide a reference to a string slice via its contained owned string./// But because its `Hash` implementation differs, it behaves differently/// from `str` and therefore must not, in fact, implement `Borrow<str>`./// If it wants to allow others access to the underlying `str`, it can do/// that via `AsRef<str>` which doesn’t carry any extra requirements./// [`Hash`]: crate::hash::Hash/// [`HashMap<K, V>`]: ../../std/collections/struct.HashMap.html/// Mutably borrows from an owned value./// use std::borrow::BorrowMut;/// fn check<T: BorrowMut<[i32]>>(mut v: T) {///     assert_eq!(&mut [1, 2, 3], v.borrow_mut());/// check(v);"BorrowMut"/// A trait for mutably borrowing data./// As a companion to [`Borrow<T>`] this trait allows a type to borrow as/// an underlying type by providing a mutable reference. See [`Borrow<T>`]/// for more information on borrowing as another type."noop_method_borrow"//! Utilities for working with borrowed data./// A wrapper for `&[u8]` representing a human-readable string that's conventionally, but not/// Unlike `&str`, this type permits non-UTF-8 contents, making it suitable for user input,/// For an owned, growable byte string buffer, use/// [`ByteString`](../../std/bstr/struct.ByteString.html)./// `ByteStr` implements `Deref` to `[u8]`, so all methods available on `[u8]` are available on/// `ByteStr`./// A `&ByteStr` has the same representation as a `&str`. That is, a `&ByteStr` is a wide pointer/// which includes a pointer to some bytes and a length./// The `ByteStr` type has a number of trait implementations, and in particular, defines equality/// and comparisons between `&ByteStr`, `&str`, and `&[u8]`, for convenience./// The `Debug` implementation for `ByteStr` shows its bytes as a normal string, with invalid UTF-8/// presented as hex escape sequences./// The `Display` implementation behaves as if the `ByteStr` were first lossily converted to a/// `str`, with invalid UTF-8 presented as the Unicode replacement character (�)./// Creates a `ByteStr` slice from anything that can be converted to a byte slice./// This is a zero-cost conversion./// You can create a `ByteStr` from a byte array, a byte slice or a string slice:/// # #![feature(bstr)]/// # use std::bstr::ByteStr;/// let a = ByteStr::new(b"abc");/// let b = ByteStr::new(&b"abc"[..]);/// let c = ByteStr::new("abc");/// assert_eq!(a, c);//! The `ByteStr` type and trait implementations.// `impl AsRef<ByteStr> for [u8]` omitted to avoid widespread inference failures// `impl AsMut<ByteStr> for [u8]` omitted to avoid widespread inference failures// `impl Borrow<ByteStr> for [u8]` omitted to avoid widespread inference failures// `impl Borrow<ByteStr> for str` omitted to avoid widespread inference failures// `impl BorrowMut<ByteStr> for [u8]` omitted to avoid widespread inference failures// impl<'a, const N: usize> From<&'a [u8; N]> for &'a ByteStr {//         ByteStr::from_bytes(s)// impl<'a> From<&'a [u8]> for &'a ByteStr {// Omitted due to slice-from-array-issue-113238:// impl<'a> From<&'a ByteStr> for &'a [u8] {//     fn from(s: &'a ByteStr) -> Self {//         &s.0// impl<'a> From<&'a mut ByteStr> for &'a mut [u8] {//     fn from(s: &'a mut ByteStr) -> Self {//         &mut s.0// impl<'a> From<&'a str> for &'a ByteStr {//         ByteStr::from_bytes(s.as_bytes())impl_slice_index//! Trait implementations for `ByteStr`./// For a thread-safe version of this struct, see [`std::sync::LazyLock`]./// [`std::sync::LazyLock`]: ../../std/sync/struct.LazyLock.html/// If the initialization closure passed to [`LazyCell::new`] panics, the cell will be poisoned./// Once the cell is poisoned, any threads that attempt to access this cell (via a dereference/// or via an explicit call to [`force()`]) will panic./// This concept is similar to that of poisoning in the [`std::sync::poison`] module. A key/// difference, however, is that poisoning in `LazyCell` is _unrecoverable_. All future accesses of/// the cell from other threads will panic, whereas a type in [`std::sync::poison`] like/// [`std::sync::poison::Mutex`] allows recovery via [`PoisonError::into_inner()`]./// [`force()`]: LazyCell::force/// [`std::sync::poison`]: ../../std/sync/poison/index.html/// [`std::sync::poison::Mutex`]: ../../std/sync/poison/struct.Mutex.html/// [`PoisonError::into_inner()`]: ../../std/sync/poison/struct.PoisonError.html#method.into_inner/// use std::cell::LazyCell;/// let lazy: LazyCell<i32> = LazyCell::new(|| {/// let lazy = LazyCell::new(|| hello.to_uppercase());/// Consumes this `LazyCell` returning the stored value./// Panics if the cell is poisoned./// #![feature(lazy_cell_into_inner)]/// assert_eq!(LazyCell::into_inner(lazy).ok(), Some("HELLO, WORLD!".to_string()));rustc_should_not_be_called_on_const_items/// If the initialization closure panics (the one that is passed to the [`new()`] method), the/// panic is propagated to the caller, and the cell becomes poisoned. This will cause all future/// accesses of the cell (via [`force()`] or a dereference) to panic./// [`new()`]: LazyCell::new/// let lazy = LazyCell::new(|| 92);/// assert_eq!(LazyCell::force(&lazy), &92);/// #![feature(lazy_get)]/// let mut lazy = LazyCell::new(|| 92);/// let p = LazyCell::force_mut(&mut lazy);/// assert_eq!(*p, 92);/// *p = 44;/// assert_eq!(*lazy, 44);really_init/// May only be called when the state is `Uninit`./// Returns a mutable reference to the value if initialized. Otherwise (if uninitialized or/// poisoned), returns `None`./// assert_eq!(LazyCell::get_mut(&mut lazy), None);/// let _ = LazyCell::force(&lazy);/// *LazyCell::get_mut(&mut lazy).unwrap() = 44;/// Returns a reference to the value if initialized. Otherwise (if uninitialized or poisoned),/// assert_eq!(LazyCell::get(&lazy), None);/// assert_eq!(LazyCell::get(&lazy), Some(&92));panic_poisoned/// A cell which can nominally be written to only once./// This allows obtaining a shared `&T` reference to its inner value without copying or replacing/// it (unlike [`Cell`]), and without runtime borrow checks (unlike [`RefCell`]). However,/// only immutable references can be obtained unless one has a mutable reference to the cell/// itself. In the same vein, the cell can only be re-initialized with such a mutable reference./// A `OnceCell` can be thought of as a safe abstraction over uninitialized data that becomes/// initialized once written./// For a thread-safe version of this struct, see [`std::sync::OnceLock`]./// [`RefCell`]: crate::cell::RefCell/// [`Cell`]: crate::cell::Cell/// [`std::sync::OnceLock`]: ../../std/sync/struct.OnceLock.html/// use std::cell::OnceCell;/// Creates a new uninitialized cell./// Returns `None` if the cell is uninitialized./// Initializes the contents of the cell to `value`./// This method returns `Ok(())` if the cell was uninitialized/// and `Err(value)` if it was already initialized./// Initializes the contents of the cell to `value` if the cell was/// uninitialized, then returns a reference to it./// This method returns `Ok(&value)` if the cell was uninitialized/// and `Err((&current_value, value))` if it was already initialized./// #![feature(once_cell_try_insert)]/// Gets the contents of the cell, initializing it to `f()`/// if the cell was uninitialized./// If `f()` panics, the panic is propagated to the caller, and the cellget_mut_or_init/// Gets the mutable reference of the contents of the cell,/// initializing it to `f()` if the cell was uninitialized./// #![feature(once_cell_get_mut)]/// let value = cell.get_mut_or_init(|| 92);/// *value += 2;/// assert_eq!(*value, 94);/// let value = cell.get_mut_or_init(|| unreachable!());/// Gets the contents of the cell, initializing it to `f()` if/// the cell was uninitialized. If the cell was uninitialized/// and `f()` failed, an error is returned./// #![feature(once_cell_try)]get_mut_or_try_init/// Gets the mutable reference of the contents of the cell, initializing/// it to `f()` if the cell was uninitialized. If the cell was uninitialized/// // Failed attempts to initialize the cell do not change its contents/// assert!(cell.get_mut_or_try_init(|| "not a number!".parse()).is_err());/// let value = cell.get_mut_or_try_init(|| "1234".parse());/// assert_eq!(value, Ok(&mut 1234));/// let Ok(value) = value else { return; };/// assert_eq!(cell.get(), Some(&1236))// Avoid inlining the initialization closure into the common path that fetches// the already initialized value/// Consumes the cell, returning the wrapped value./// Returns `None` if the cell was uninitialized./// let _ = cell.set("hello".to_owned());/// assert_eq!(cell.into_inner(), Some("hello".to_owned()));/// Has no effect and returns `None` if the `OnceCell` is uninitialized./// Safety is guaranteed by requiring a mutable reference./// assert_eq!(cell.take(), Some("hello".to_owned()));/// Creates a new `OnceCell<T>` which already contains the given `value`.// Just like for `Cell<T>` this isn't needed, but results in nicer error messages."Cell"rustc_pub_transparent/// A mutable memory location./// `Cell<T>` has the same [memory layout and caveats as/// `UnsafeCell<T>`](UnsafeCell#memory-layout). In particular, this means that/// `Cell<T>` has the same in-memory representation as its inner type `T`./// In this example, you can see that `Cell<T>` enables mutation inside an/// immutable struct. In other words, it enables "interior mutability".///     regular_field: u8,///     special_field: Cell<u8>,/// let my_struct = SomeStruct {///     regular_field: 0,///     special_field: Cell::new(1),/// let new_value = 100;/// // ERROR: `my_struct` is immutable/// // my_struct.regular_field = new_value;/// // WORKS: although `my_struct` is immutable, `special_field` is a `Cell`,/// // which can always be mutated/// my_struct.special_field.set(new_value);/// assert_eq!(my_struct.special_field.get(), new_value);/// See the [module-level documentation](self) for more.// as `Cell` wraps `UnsafeCell`, which is itself `!Sync`.// However, given how important `Cell`'s `!Sync`-ness is,/// Creates a `Cell<T>`, with the `Default` value for T./// Creates a new `Cell<T>` containing the given value./// Creates a new `Cell` containing the given value./// let c = Cell::new(5);/// Sets the contained value./// c.set(10);/// Swaps the values of two `Cell`s./// The difference with `std::mem::swap` is that this function doesn't/// require a `&mut` reference./// This function will panic if `self` and `other` are different `Cell`s that partially overlap./// (Using just standard library methods, it is impossible to create such partially overlapping `Cell`s./// However, unsafe code is allowed to e.g. create two `&Cell<[i32; 2]>` that partially overlap.)/// let c1 = Cell::new(5i32);/// let c2 = Cell::new(10i32);/// c1.swap(&c2);/// assert_eq!(10, c1.get());/// assert_eq!(5, c2.get());/// Replaces the contained value with `val`, and returns the old contained value./// let cell = Cell::new(5);/// assert_eq!(cell.get(), 5);/// assert_eq!(cell.replace(10), 5);/// assert_eq!(cell.get(), 10);/// Unwraps the value, consuming the cell./// let five = c.into_inner();/// Returns a copy of the contained value./// let five = c.get();// FIXME(const-hack): `Copy` should imply `const Destruct`/// Updates the contained value using a function./// c.update(|x| x + 1);/// assert_eq!(c.get(), 6);/// Returns a raw pointer to the underlying data in this cell./// let ptr = c.as_ptr();/// This call borrows `Cell` mutably (at compile-time) which guarantees/// that we possess the only reference./// However be cautious: this method expects `self` to be mutable, which is/// generally not the case when using a `Cell`. If you require interior/// mutability by reference, consider using `RefCell` which provides/// run-time checked mutable borrows through its [`borrow_mut`] method./// [`borrow_mut`]: RefCell::borrow_mut()/// let mut c = Cell::new(5);/// *c.get_mut() += 1;/// Returns a `&Cell<T>` from a `&mut T`/// let slice: &mut [i32] = &mut [1, 2, 3];/// let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);/// let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();/// assert_eq!(slice_cell.len(), 3);/// Takes the value of the cell, leaving `Default::default()` in its place./// let five = c.take();/// assert_eq!(c.into_inner(), 0);// Allow types that wrap `Cell` to also implement `DispatchFromDyn`// and become dyn-compatible method receivers.// Note that currently `Cell` itself cannot be a method receiver// because it does not implement Deref.// In other words:// `self: Cell<&Self>` won't work// `self: CellWrapper<Self>` becomes possibleas_slice_of_cells/// Returns a `&[Cell<T>]` from a `&Cell<[T]>`as_array_of_cells/// Returns a `&[Cell<T>; N]` from a `&Cell<[T; N]>`/// let mut array: [i32; 3] = [1, 2, 3];/// let cell_array: &Cell<[i32; 3]> = Cell::from_mut(&mut array);/// let array_cell: &[Cell<i32>; 3] = cell_array.as_array_of_cells();/// Types for which cloning `Cell<Self>` is sound./// Implementing this trait for a type is sound if and only if the following code is sound for T =/// that type./// #![feature(cell_get_cloned)]/// # use std::cell::{CloneFromCell, Cell};/// fn clone_from_cell<T: CloneFromCell>(cell: &Cell<T>) -> T {///     unsafe { T::clone(&*cell.as_ptr()) }/// Importantly, you can't just implement `CloneFromCell` for any arbitrary `Copy` type, e.g. the/// following is unsound:/// #[derive(Copy, Debug)]/// pub struct Bad<'a>(Option<&'a Cell<Bad<'a>>>, u8);/// impl Clone for Bad<'_> {///     fn clone(&self) -> Self {///         let a: &u8 = &self.1;///         // when self.0 points to self, we write to self.1 while we have a live `&u8` pointing to///         // it -- this is UB///         self.0.unwrap().set(Self(None, 1));///         dbg!((a, self));///         Self(None, 0)/// // this is not sound/// // unsafe impl CloneFromCell for Bad<'_> {}// Allow potential overlapping implementations in user code// `CloneFromCell` can be implemented for types that don't have indirection and which don't access// `Cell`s in their `Clone` implementation. A commonly-used subset is covered here.get_cloned/// Get a clone of the `Cell` that contains a copy of the original value./// This allows a cheaply `Clone`-able type like an `Rc` to be stored in a `Cell`, exposing the/// cheaper `clone()` method./// let rc = Rc::new(1usize);/// let c1 = Cell::new(rc);/// let c2 = c1.get_cloned();/// assert_eq!(*c2.into_inner(), 1);"RefCell"BorrowCounter/// A mutable memory location with dynamically checked borrow rules/// An error returned by [`RefCell::try_borrow`]./// An error returned by [`RefCell::try_borrow_mut`].panic_already_borrowed// This ensures the panicking code is outlined from `borrow_mut` for `RefCell`.panic_already_mutably_borrowed// This ensures the panicking code is outlined from `borrow` for `RefCell`.// Positive values represent the number of `Ref` active. Negative values// represent the number of `RefMut` active. Multiple `RefMut`s can only be// active at a time if they refer to distinct, nonoverlapping components of a// `RefCell` (e.g., different ranges of a slice).// `Ref` and `RefMut` are both two words in size, and so there will likely never// be enough `Ref`s or `RefMut`s in existence to overflow half of the `usize`// range. Thus, a `BorrowCounter` will probably never overflow or underflow.// However, this is not a guarantee, as a pathological program could repeatedly// create and then mem::forget `Ref`s or `RefMut`s. Thus, all code must// explicitly check for overflow and underflow in order to avoid unsafety, or at// least behave correctly in the event that overflow or underflow happens (e.g.,// see BorrowRef::new).is_writingis_reading/// Creates a new `RefCell` containing `value`./// let c = RefCell::new(5);/// Consumes the `RefCell`, returning the wrapped value./// Replaces the wrapped value with a new one, returning the old value,/// without deinitializing either one./// This function corresponds to [`std::mem::replace`](../mem/fn.replace.html)./// Panics if the value is currently borrowed./// let cell = RefCell::new(5);/// let old_value = cell.replace(6);/// assert_eq!(old_value, 5);/// assert_eq!(cell, RefCell::new(6));/// Replaces the wrapped value with a new one computed from `f`, returning/// the old value, without deinitializing either one./// let old_value = cell.replace_with(|&mut old| old + 1);/// Swaps the wrapped value of `self` with the wrapped value of `other`,/// This function corresponds to [`std::mem::swap`](../mem/fn.swap.html)./// Panics if the value in either `RefCell` is currently borrowed, or/// if `self` and `other` point to the same `RefCell`./// let d = RefCell::new(6);/// c.swap(&d);/// assert_eq!(c, RefCell::new(6));/// assert_eq!(d, RefCell::new(5));/// Panics if the value is currently mutably borrowed. For a non-panicking variant, use/// let borrowed_five = c.borrow();/// let borrowed_five2 = c.borrow();/// An example of panic:/// let m = c.borrow_mut();/// let b = c.borrow(); // this causes a panic///     let m = c.borrow_mut();///     assert!(c.try_borrow().is_err());///     let m = c.borrow();///     assert!(c.try_borrow().is_ok());/// Panics if the value is currently borrowed. For a non-panicking variant, use/// let c = RefCell::new("hello".to_owned());/// *c.borrow_mut() = "bonjour".to_owned();/// assert_eq!(&*c.borrow(), "bonjour");/// let m = c.borrow();/// let b = c.borrow_mut(); // this causes a panic///     assert!(c.try_borrow_mut().is_err());/// assert!(c.try_borrow_mut().is_ok());/// Since this method borrows `RefCell` mutably, it is statically guaranteed/// that no borrows to the underlying data exist. The dynamic checks inherent/// in [`borrow_mut`] and most other methods of `RefCell` are therefore/// unnecessary. Note that this method does not reset the borrowing state if borrows were previously leaked/// (e.g., via [`forget()`] on a [`Ref`] or [`RefMut`]). For that purpose,/// consider using the unstable [`undo_leak`] method./// This method can only be called if `RefCell` can be mutably borrowed,/// which in general is only the case directly after the `RefCell` has/// been created. In these situations, skipping the aforementioned dynamic/// borrowing checks may yield better ergonomics and runtime-performance./// In most situations where `RefCell` is used, it can't be borrowed mutably./// Use [`borrow_mut`] to get mutable access to the underlying data then./// [`forget()`]: mem::forget/// [`undo_leak`]: RefCell::undo_leak()/// let mut c = RefCell::new(5);undo_leak/// Undo the effect of leaked guards on the borrow state of the `RefCell`./// This call is similar to [`get_mut`] but more specialized. It borrows `RefCell` mutably to/// ensure no borrows exist and then resets the state tracking shared borrows. This is relevant/// if some `Ref` or `RefMut` borrows have been leaked./// [`get_mut`]: RefCell::get_mut()/// #![feature(cell_leak)]/// let mut c = RefCell::new(0);/// std::mem::forget(c.borrow_mut());/// assert!(c.try_borrow().is_err());/// c.undo_leak();/// assert!(c.try_borrow().is_ok());try_borrow_unguarded/// Immutably borrows the wrapped value, returning an error if the value is/// currently mutably borrowed./// Unlike `RefCell::borrow`, this method is unsafe because it does not/// return a `Ref`, thus leaving the borrow flag untouched. Mutably/// borrowing the `RefCell` while the reference returned by this method/// is alive is undefined behavior.///     assert!(unsafe { c.try_borrow_unguarded() }.is_err());///     assert!(unsafe { c.try_borrow_unguarded() }.is_ok());/// Takes the wrapped value, leaving `Default::default()` in its place./// Panics if the value is currently mutably borrowed./// Panics if `source` is currently mutably borrowed./// Creates a `RefCell<T>`, with the `Default` value for T./// Panics if the value in either `RefCell` is currently mutably borrowed./// Creates a new `RefCell<T>` containing the given value.BorrowRef"holding a Ref across suspend points can cause BorrowErrors"must_not_suspend"RefCellRef"// NB: we use a pointer instead of `&'b T` to avoid `noalias` violations, because a// `Ref` argument doesn't hold immutability for its whole scope, only until it drops.// `NonNull` is also covariant over `T`, just like we would have with `&T`./// Wraps a borrowed reference to a value in a `RefCell` box./// A wrapper type for an immutably borrowed value from a `RefCell<T>`./// Copies a `Ref`./// The `RefCell` is already immutably borrowed, so this cannot fail./// `Ref::clone(...)`. A `Clone` implementation or a method would interfere/// with the widespread use of `r.borrow().clone()` to clone the contents of/// a `RefCell`./// Makes a new `Ref` for a component of the borrowed data./// This is an associated function that needs to be used as `Ref::map(...)`./// A method would interfere with methods of the same name on the contents/// of a `RefCell` used through `Deref`./// use std::cell::{RefCell, Ref};/// let c = RefCell::new((5, 'b'));/// let b1: Ref<'_, (u32, char)> = c.borrow();/// let b2: Ref<'_, u32> = Ref::map(b1, |t| &t.0);/// assert_eq!(*b2, 5)/// Makes a new `Ref` for an optional component of the borrowed data. The/// original guard is returned as an `Err(..)` if the closure returns/// `Ref::filter_map(...)`. A method would interfere with methods of the same/// name on the contents of a `RefCell` used through `Deref`./// let c = RefCell::new(vec![1, 2, 3]);/// let b1: Ref<'_, Vec<u32>> = c.borrow();/// let b2: Result<Ref<'_, u32>, _> = Ref::filter_map(b1, |v| v.get(1));/// assert_eq!(*b2.unwrap(), 2);/// Tries to makes a new `Ref` for a component of the borrowed data./// On failure, the original guard is returned alongside with the error/// returned by the closure./// `Ref::try_map(...)`. A method would interfere with methods of the same/// #![feature(refcell_try_map)]/// use std::str::{from_utf8, Utf8Error};/// let c = RefCell::new(vec![0xF0, 0x9F, 0xA6 ,0x80]);/// let b1: Ref<'_, Vec<u8>> = c.borrow();/// let b2: Result<Ref<'_, str>, _> = Ref::try_map(b1, |v| from_utf8(v));/// assert_eq!(&*b2.unwrap(), "🦀");/// let c = RefCell::new(vec![0xF0, 0x9F, 0xA6]);/// let b2: Result<_, (Ref<'_, Vec<u8>>, Utf8Error)> = Ref::try_map(b1, |v| from_utf8(v));/// let (b3, e) = b2.unwrap_err();/// assert_eq!(*b3, vec![0xF0, 0x9F, 0xA6]);/// assert_eq!(e.valid_up_to(), 0);map_split/// Splits a `Ref` into multiple `Ref`s for different components of the/// borrowed data./// `Ref::map_split(...)`. A method would interfere with methods of the same/// use std::cell::{Ref, RefCell};/// let cell = RefCell::new([1, 2, 3, 4]);/// let borrow = cell.borrow();/// let (begin, end) = Ref::map_split(borrow, |slice| slice.split_at(2));/// assert_eq!(*begin, [1, 2]);/// assert_eq!(*end, [3, 4]);/// Converts into a reference to the underlying data./// The underlying `RefCell` can never be mutably borrowed from again and will always appear/// already immutably borrowed. It is not a good idea to leak more than a constant number of/// references. The `RefCell` can be immutably borrowed again if only a smaller number of leaks/// have occurred in total./// `Ref::leak(...)`. A method would interfere with methods of the/// same name on the contents of a `RefCell` used through `Deref`./// let cell = RefCell::new(0);/// let value = Ref::leak(cell.borrow());/// assert_eq!(*value, 0);/// assert!(cell.try_borrow().is_ok());/// assert!(cell.try_borrow_mut().is_err());/// Makes a new `RefMut` for a component of the borrowed data, e.g., an enum/// The `RefCell` is already mutably borrowed, so this cannot fail./// `RefMut::map(...)`. A method would interfere with methods of the same/// use std::cell::{RefCell, RefMut};///     let b1: RefMut<'_, (u32, char)> = c.borrow_mut();///     let mut b2: RefMut<'_, u32> = RefMut::map(b1, |t| &mut t.0);///     assert_eq!(*b2, 5);///     *b2 = 42;/// assert_eq!(*c.borrow(), (42, 'b'));/// Makes a new `RefMut` for an optional component of the borrowed data. The/// `RefMut::filter_map(...)`. A method would interfere with methods of the///     let b1: RefMut<'_, Vec<u32>> = c.borrow_mut();///     let mut b2: Result<RefMut<'_, u32>, _> = RefMut::filter_map(b1, |v| v.get_mut(1));///     if let Ok(mut b2) = b2 {///         *b2 += 2;/// assert_eq!(*c.borrow(), vec![1, 4, 3]);/// Tries to makes a new `RefMut` for a component of the borrowed data./// `RefMut::try_map(...)`. A method would interfere with methods of the same/// use std::str::{from_utf8_mut, Utf8Error};/// let c = RefCell::new(vec![0x68, 0x65, 0x6C, 0x6C, 0x6F]);///     let b1: RefMut<'_, Vec<u8>> = c.borrow_mut();///     let b2: Result<RefMut<'_, str>, _> = RefMut::try_map(b1, |v| from_utf8_mut(v));///     let mut b2 = b2.unwrap();///     assert_eq!(&*b2, "hello");///     b2.make_ascii_uppercase();/// assert_eq!(*c.borrow(), "HELLO".as_bytes());/// let c = RefCell::new(vec![0xFF]);/// let b1: RefMut<'_, Vec<u8>> = c.borrow_mut();/// let b2: Result<_, (RefMut<'_, Vec<u8>>, Utf8Error)> = RefMut::try_map(b1, |v| from_utf8_mut(v));/// assert_eq!(*b3, vec![0xFF]);/// Splits a `RefMut` into multiple `RefMut`s for different components of the/// The underlying `RefCell` will remain mutably borrowed until both/// returned `RefMut`s go out of scope./// `RefMut::map_split(...)`. A method would interfere with methods of the/// let borrow = cell.borrow_mut();/// let (mut begin, mut end) = RefMut::map_split(borrow, |slice| slice.split_at_mut(2));/// begin.copy_from_slice(&[4, 3]);/// end.copy_from_slice(&[2, 1]);/// Converts into a mutable reference to the underlying data./// The underlying `RefCell` can not be borrowed from again and will always appear already/// mutably borrowed, making the returned reference the only to the interior./// `RefMut::leak(...)`. A method would interfere with methods of the/// let value = RefMut::leak(cell.borrow_mut());/// *value = 1;BorrowRefMut// Clones a `BorrowRefMut`.// This is only valid if each `BorrowRefMut` is used to track a mutable// reference to a distinct, nonoverlapping range of the original object.// This isn't in a Clone impl so that code doesn't call this implicitly."holding a RefMut across suspend points can cause BorrowErrors""RefCellRefMut"// NB: we use a pointer instead of `&'b mut T` to avoid `noalias` violations, because a// `RefMut` argument doesn't hold exclusivity for its whole scope, only until it drops.// `NonNull` is covariant over `T`, so we need to reintroduce invariance./// A wrapper type for a mutably borrowed value from a `RefCell<T>`."unsafe_cell"/// The core primitive for interior mutability in Rust./// If you have a reference `&T`, then normally in Rust the compiler performs optimizations based on/// the knowledge that `&T` points to immutable data. Mutating that data, for example through an/// alias or by transmuting a `&T` into a `&mut T`, is considered undefined behavior./// `UnsafeCell<T>` opts-out of the immutability guarantee for `&T`: a shared reference/// `&UnsafeCell<T>` may point to data that is being mutated. This is called "interior mutability"./// All other types that allow internal mutability, such as [`Cell<T>`] and [`RefCell<T>`], internally/// use `UnsafeCell` to wrap their data./// Note that only the immutability guarantee for shared references is affected by `UnsafeCell`. The/// uniqueness guarantee for mutable references is unaffected. There is *no* legal way to obtain/// aliasing `&mut`, not even with `UnsafeCell<T>`./// `UnsafeCell` does nothing to avoid data races; they are still undefined behavior. If multiple/// threads have access to the same `UnsafeCell`, they must follow the usual rules of the/// [concurrent memory model]: conflicting non-synchronized accesses must be done via the APIs in/// [`core::sync::atomic`]./// The `UnsafeCell` API itself is technically very simple: [`.get()`] gives you a raw pointer/// `*mut T` to its contents. It is up to _you_ as the abstraction designer to use that raw pointer/// [`.get()`]: `UnsafeCell::get`/// [concurrent memory model]: ../sync/atomic/index.html#memory-model-for-atomic-accesses/// # Aliasing rules/// The precise Rust aliasing rules are somewhat in flux, but the main points are not contentious:/// - If you create a safe reference with lifetime `'a` (either a `&T` or `&mut T` reference), then///   you must not access the data in any way that contradicts that reference for the remainder of///   `'a`. For example, this means that if you take the `*mut T` from an `UnsafeCell<T>` and cast it///   to an `&T`, then the data in `T` must remain immutable (modulo any `UnsafeCell` data found///   within `T`, of course) until that reference's lifetime expires. Similarly, if you create a///   `&mut T` reference that is released to safe code, then you must not access the data within the///   `UnsafeCell` until that reference expires./// - For both `&T` without `UnsafeCell<_>` and `&mut T`, you must also not deallocate the data///   until the reference expires. As a special exception, given an `&T`, any part of it that is///   inside an `UnsafeCell<_>` may be deallocated during the lifetime of the reference, after the///   last time the reference is used (dereferenced or reborrowed). Since you cannot deallocate a part///   of what a reference points to, this means the memory an `&T` points to can be deallocated only if///   *every part of it* (including padding) is inside an `UnsafeCell`./// However, whenever a `&UnsafeCell<T>` is constructed or dereferenced, it must still point to/// live memory and the compiler is allowed to insert spurious reads if it can prove that this/// memory has not yet been deallocated./// To assist with proper design, the following scenarios are explicitly declared legal/// for single-threaded code:/// 1. A `&T` reference can be released to safe code and there it can co-exist with other `&T`///    references, but not with a `&mut T`/// 2. A `&mut T` reference may be released to safe code provided neither other `&mut T` nor `&T`///    co-exist with it. A `&mut T` must always be unique./// Note that whilst mutating the contents of an `&UnsafeCell<T>` (even while other/// `&UnsafeCell<T>` references alias the cell) is/// ok (provided you enforce the above invariants some other way), it is still undefined behavior/// to have multiple `&mut UnsafeCell<T>` aliases. That is, `UnsafeCell` is a wrapper/// designed to have a special interaction with _shared_ accesses (_i.e._, through an/// `&UnsafeCell<_>` reference); there is no magic whatsoever when dealing with _exclusive_/// accesses (_e.g._, through a `&mut UnsafeCell<_>`): neither the cell nor the wrapped value/// may be aliased for the duration of that `&mut` borrow./// This is showcased by the [`.get_mut()`] accessor, which is a _safe_ getter that yields/// a `&mut T`./// [`.get_mut()`]: `UnsafeCell::get_mut`/// `UnsafeCell<T>` has the same in-memory representation as its inner type `T`. A consequence/// of this guarantee is that it is possible to convert between `T` and `UnsafeCell<T>`./// Special care has to be taken when converting a nested `T` inside of an `Outer<T>` type/// to an `Outer<UnsafeCell<T>>` type: this is not sound when the `Outer<T>` type enables [niche]/// optimizations. For example, the type `Option<NonNull<u8>>` is typically 8 bytes large on/// 64-bit platforms, but the type `Option<UnsafeCell<NonNull<u8>>>` takes up 16 bytes of space./// Therefore this is not a valid conversion, despite `NonNull<u8>` and `UnsafeCell<NonNull<u8>>>`/// having the same memory layout. This is because `UnsafeCell` disables niche optimizations in/// order to avoid its interior mutability property from spreading from `T` into the `Outer` type,/// thus this can cause distortions in the type size in these cases./// Note that the only valid way to obtain a `*mut T` pointer to the contents of a/// _shared_ `UnsafeCell<T>` is through [`.get()`]  or [`.raw_get()`]. A `&mut T` reference/// can be obtained by either dereferencing this pointer or by calling [`.get_mut()`]/// on an _exclusive_ `UnsafeCell<T>`. Even though `T` and `UnsafeCell<T>` have the/// same memory layout, the following is not allowed and undefined behavior:/// # use std::cell::UnsafeCell;/// unsafe fn not_allowed<T>(ptr: &UnsafeCell<T>) -> &mut T {///   let t = ptr as *const UnsafeCell<T> as *mut T;///   // This is undefined behavior, because the `*mut T` pointer///   // was not obtained through `.get()` nor `.raw_get()`:///   unsafe { &mut *t }/// Instead, do this:/// // Safety: the caller must ensure that there are no references that/// // point to the *contents* of the `UnsafeCell`./// unsafe fn get_mut<T>(ptr: &UnsafeCell<T>) -> &mut T {///   unsafe { &mut *ptr.get() }/// Converting in the other direction from a `&mut T`/// to an `&UnsafeCell<T>` is allowed:/// fn get_shared<T>(ptr: &mut T) -> &UnsafeCell<T> {///   let t = ptr as *mut T as *const UnsafeCell<T>;///   // SAFETY: `T` and `UnsafeCell<T>` have the same memory layout///   unsafe { &*t }/// [niche]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#niche/// [`.raw_get()`]: `UnsafeCell::raw_get`/// Here is an example showcasing how to soundly mutate the contents of an `UnsafeCell<_>` despite/// there being multiple references aliasing the cell:/// let x: UnsafeCell<i32> = 42.into();/// // Get multiple / concurrent / shared references to the same `x`./// let (p1, p2): (&UnsafeCell<i32>, &UnsafeCell<i32>) = (&x, &x);///     // SAFETY: within this scope there are no other references to `x`'s contents,///     // so ours is effectively unique.///     let p1_exclusive: &mut i32 = &mut *p1.get(); // -- borrow --+///     *p1_exclusive += 27; //                                     |/// } // <---------- cannot go beyond this point -------------------+///     // SAFETY: within this scope nobody expects to have exclusive access to `x`'s contents,///     // so we can have multiple shared accesses concurrently.///     let p2_shared: &i32 = &*p2.get();///     assert_eq!(*p2_shared, 42 + 27);///     let p1_shared: &i32 = &*p1.get();///     assert_eq!(*p1_shared, *p2_shared);/// The following example showcases the fact that exclusive access to an `UnsafeCell<T>`/// implies exclusive access to its `T`:/// #![forbid(unsafe_code)]/// // with exclusive accesses, `UnsafeCell` is a transparent no-op wrapper, so no need for/// // `unsafe` here./// let mut x: UnsafeCell<i32> = 42.into();/// // Get a compile-time-checked unique reference to `x`./// let p_unique: &mut UnsafeCell<i32> = &mut x;/// // With an exclusive reference, we can mutate the contents for free./// *p_unique.get_mut() = 0;/// // Or, equivalently:/// x = UnsafeCell::new(0);/// // When we own the value, we can extract the contents for free./// let contents: i32 = x.into_inner();/// assert_eq!(contents, 0);/// Constructs a new instance of `UnsafeCell` which will wrap the specified/// All access to the inner value through `&UnsafeCell<T>` requires `unsafe` code./// let uc = UnsafeCell::new(5);/// let five = uc.into_inner();/// Replace the value in this `UnsafeCell` and return the old value./// The caller must take care to avoid aliasing and data races./// - It is Undefined Behavior to allow calls to race with///   any other access to the wrapped value./// - It is Undefined Behavior to call this while any other///   reference(s) to the wrapped value are alive./// #![feature(unsafe_cell_access)]/// let old = unsafe { uc.replace(10) };/// assert_eq!(old, 5);/// Converts from `&mut T` to `&mut UnsafeCell<T>`./// let mut val = 42;/// let uc = UnsafeCell::from_mut(&mut val);/// *uc.get_mut() -= 1;/// assert_eq!(*uc.get_mut(), 41);/// Gets a mutable pointer to the wrapped value./// This can be cast to a pointer of any kind. When creating references, you must uphold the/// aliasing rules; see [the type-level docs][UnsafeCell#aliasing-rules] for more discussion and/// caveats./// let five = uc.get();/// let mut c = UnsafeCell::new(5);/// assert_eq!(*c.get_mut(), 6);"unsafe_cell_raw_get"/// The difference from [`get`] is that this function accepts a raw pointer,/// which is useful to avoid the creation of temporary references./// [`get`]: UnsafeCell::get()/// Gradual initialization of an `UnsafeCell` requires `raw_get`, as/// calling `get` would require creating a reference to uninitialized data:/// let m = MaybeUninit::<UnsafeCell<i32>>::uninit();/// unsafe { UnsafeCell::raw_get(m.as_ptr()).write(5); }/// // avoid below which references to uninitialized data/// // unsafe { UnsafeCell::get(&*m.as_ptr()).write(5); }/// let uc = unsafe { m.assume_init() };/// assert_eq!(uc.into_inner(), 5);as_ref_unchecked/// Get a shared reference to the value within the `UnsafeCell`./// - It is Undefined Behavior to call this while any mutable///   reference to the wrapped value is alive./// - Mutating the wrapped value while the returned///   reference is alive is Undefined Behavior./// let val = unsafe { uc.as_ref_unchecked() };/// assert_eq!(val, &5);as_mut_unchecked/// Get an exclusive reference to the value within the `UnsafeCell`./// - Mutating the wrapped value through other means while the///   returned reference is alive is Undefined Behavior./// unsafe { *uc.as_mut_unchecked() += 1; }/// assert_eq!(uc.into_inner(), 6);/// Creates an `UnsafeCell`, with the `Default` value for T./// Creates a new `UnsafeCell<T>` containing the given value.// Allow types that wrap `UnsafeCell` to also implement `DispatchFromDyn`// Note that currently `UnsafeCell` itself cannot be a method receiver// `self: UnsafeCell<&Self>` won't work// `self: UnsafeCellWrapper<Self>` becomes possible"SyncUnsafeCell"SyncUnsafeCell/// [`UnsafeCell`], but [`Sync`]./// This is just an `UnsafeCell`, except it implements `Sync`/// if `T` implements `Sync`./// `UnsafeCell` doesn't implement `Sync`, to prevent accidental mis-use./// You can use `SyncUnsafeCell` instead of `UnsafeCell` to allow it to be/// shared between threads, if that's intentional./// Providing proper synchronization is still the task of the user,/// making this type just as unsafe to use./// See [`UnsafeCell`] for details./// Constructs a new instance of `SyncUnsafeCell` which will wrap the specified value./// This can be cast to a pointer of any kind./// Ensure that the access is unique (no active references, mutable or not)/// when casting to `&mut T`, and ensure that there are no mutations/// or mutable aliases going on when casting to `&T`/// This call borrows the `SyncUnsafeCell` mutably (at compile-time) which/// See [`UnsafeCell::get`] for details./// Creates an `SyncUnsafeCell`, with the `Default` value for T./// Creates a new `SyncUnsafeCell<T>` containing the given value.//#[unstable(feature = "sync_unsafe_cell", issue = "95439")]// Allow types that wrap `SyncUnsafeCell` to also implement `DispatchFromDyn`// Note that currently `SyncUnsafeCell` itself cannot be a method receiver// `self: SyncUnsafeCell<&Self>` won't work// `self: SyncUnsafeCellWrapper<Self>` becomes possibleassert_coerce_unsized//! Shareable mutable containers.//! Rust memory safety is based on this rule: Given an object `T`, it is only possible to//! have one of the following://! - Several immutable references (`&T`) to the object (also known as **aliasing**).//! - One mutable reference (`&mut T`) to the object (also known as **mutability**).//! This is enforced by the Rust compiler. However, there are situations where this rule is not//! flexible enough. Sometimes it is required to have multiple references to an object and yet//! mutate it.//! Shareable mutable containers exist to permit mutability in a controlled manner, even in the//! presence of aliasing. [`Cell<T>`], [`RefCell<T>`], and [`OnceCell<T>`] allow doing this in//! a single-threaded way—they do not implement [`Sync`]. (If you need to do aliasing and//! mutation among multiple threads, [`Mutex<T>`], [`RwLock<T>`], [`OnceLock<T>`] or [`atomic`]//! types are the correct data structures to do so).//! Values of the `Cell<T>`, `RefCell<T>`, and `OnceCell<T>` types may be mutated through shared//! references (i.e. the common `&T` type), whereas most Rust types can only be mutated through//! unique (`&mut T`) references. We say these cell types provide 'interior mutability'//! (mutable via `&T`), in contrast with typical Rust types that exhibit 'inherited mutability'//! (mutable only via `&mut T`).//! Cell types come in four flavors: `Cell<T>`, `RefCell<T>`, `OnceCell<T>`, and `LazyCell<T>`.//! Each provides a different way of providing safe interior mutability.//! ## `Cell<T>`//! [`Cell<T>`] implements interior mutability by moving values in and out of the cell. That is, an//! `&mut T` to the inner value can never be obtained, and the value itself cannot be directly//! obtained without replacing it with something else. Both of these rules ensure that there is//! never more than one reference pointing to the inner value. This type provides the following//! methods://!  - For types that implement [`Copy`], the [`get`](Cell::get) method retrieves the current//!    interior value by duplicating it.//!  - For types that implement [`Default`], the [`take`](Cell::take) method replaces the current//!    interior value with [`Default::default()`] and returns the replaced value.//!  - All types have://!    - [`replace`](Cell::replace): replaces the current interior value and returns the replaced//!      value.//!    - [`into_inner`](Cell::into_inner): this method consumes the `Cell<T>` and returns the//!      interior value.//!    - [`set`](Cell::set): this method replaces the interior value, dropping the replaced value.//! `Cell<T>` is typically used for more simple types where copying or moving values isn't too//! resource intensive (e.g. numbers), and should usually be preferred over other cell types when//! possible. For larger and non-copy types, `RefCell` provides some advantages.//! ## `RefCell<T>`//! [`RefCell<T>`] uses Rust's lifetimes to implement "dynamic borrowing", a process whereby one can//! claim temporary, exclusive, mutable access to the inner value. Borrows for `RefCell<T>`s are//! tracked at _runtime_, unlike Rust's native reference types which are entirely tracked//! statically, at compile time.//! An immutable reference to a `RefCell`'s inner value (`&T`) can be obtained with//! [`borrow`](`RefCell::borrow`), and a mutable borrow (`&mut T`) can be obtained with//! [`borrow_mut`](`RefCell::borrow_mut`). When these functions are called, they first verify that//! Rust's borrow rules will be satisfied: any number of immutable borrows are allowed or a//! single mutable borrow is allowed, but never both. If a borrow is attempted that would violate//! these rules, the thread will panic.//! The corresponding [`Sync`] version of `RefCell<T>` is [`RwLock<T>`].//! ## `OnceCell<T>`//! [`OnceCell<T>`] is somewhat of a hybrid of `Cell` and `RefCell` that works for values that//! typically only need to be set once. This means that a reference `&T` can be obtained without//! moving or copying the inner value (unlike `Cell`) but also without runtime checks (unlike//! `RefCell`). However, its value can also not be updated once set unless you have a mutable//! reference to the `OnceCell`.//! `OnceCell` provides the following methods://! - [`get`](OnceCell::get): obtain a reference to the inner value//! - [`set`](OnceCell::set): set the inner value if it is unset (returns a `Result`)//! - [`get_or_init`](OnceCell::get_or_init): return the inner value, initializing it if needed//! - [`get_mut`](OnceCell::get_mut): provide a mutable reference to the inner value, only available//!   if you have a mutable reference to the cell itself.//! The corresponding [`Sync`] version of `OnceCell<T>` is [`OnceLock<T>`].//! ## `LazyCell<T, F>`//! A common pattern with OnceCell is, for a given OnceCell, to use the same function on every//! call to [`OnceCell::get_or_init`] with that cell. This is what is offered by [`LazyCell`],//! which pairs cells of `T` with functions of `F`, and always calls `F` before it yields `&T`.//! This happens implicitly by simply attempting to dereference the LazyCell to get its contents,//! so its use is much more transparent with a place which has been initialized by a constant.//! More complicated patterns that don't fit this description can be built on `OnceCell<T>` instead.//! `LazyCell` works by providing an implementation of `impl Deref` that calls the function,//! so you can just use it by dereference (e.g. `*lazy_cell` or `lazy_cell.deref()`).//! The corresponding [`Sync`] version of `LazyCell<T, F>` is [`LazyLock<T, F>`].//! # When to choose interior mutability//! The more common inherited mutability, where one must have unique access to mutate a value, is//! one of the key language elements that enables Rust to reason strongly about pointer aliasing,//! statically preventing crash bugs. Because of that, inherited mutability is preferred, and//! interior mutability is something of a last resort. Since cell types enable mutation where it//! would otherwise be disallowed though, there are occasions when interior mutability might be//! appropriate, or even *must* be used, e.g.//! * Introducing mutability 'inside' of something immutable//! * Implementation details of logically-immutable methods.//! * Mutating implementations of [`Clone`].//! ## Introducing mutability 'inside' of something immutable//! Many shared smart pointer types, including [`Rc<T>`] and [`Arc<T>`], provide containers that can//! be cloned and shared between multiple parties. Because the contained values may be//! multiply-aliased, they can only be borrowed with `&`, not `&mut`. Without cells it would be//! impossible to mutate data inside of these smart pointers at all.//! It's very common then to put a `RefCell<T>` inside shared pointer types to reintroduce//! mutability://! use std::cell::{RefCell, RefMut};//!     let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));//!     // Create a new block to limit the scope of the dynamic borrow//!         let mut map: RefMut<'_, _> = shared_map.borrow_mut();//!         map.insert("africa", 92388);//!         map.insert("kyoto", 11837);//!         map.insert("piccadilly", 11826);//!         map.insert("marbles", 38);//!     // Note that if we had not let the previous borrow of the cache fall out//!     // of scope then the subsequent borrow would cause a dynamic thread panic.//!     // This is the major hazard of using `RefCell`.//!     let total: i32 = shared_map.borrow().values().sum();//!     println!("{total}");//! Note that this example uses `Rc<T>` and not `Arc<T>`. `RefCell<T>`s are for single-threaded//! scenarios. Consider using [`RwLock<T>`] or [`Mutex<T>`] if you need shared mutability in a//! multi-threaded situation.//! ## Implementation details of logically-immutable methods//! Occasionally it may be desirable not to expose in an API that there is mutation happening//! "under the hood". This may be because logically the operation is immutable, but e.g., caching//! forces the implementation to perform mutation; or because you must employ mutation to implement//! a trait method that was originally defined to take `&self`.//! use std::cell::OnceCell;//! struct Graph {//!     edges: Vec<(i32, i32)>,//!     span_tree_cache: OnceCell<Vec<(i32, i32)>>//! impl Graph {//!     fn minimum_spanning_tree(&self) -> Vec<(i32, i32)> {//!         self.span_tree_cache//!             .get_or_init(|| self.calc_span_tree())//!             .clone()//!     fn calc_span_tree(&self) -> Vec<(i32, i32)> {//!         // Expensive computation goes here//!         vec![]//! ## Mutating implementations of `Clone`//! This is simply a special - but common - case of the previous: hiding mutability for operations//! that appear to be immutable. The [`clone`](Clone::clone) method is expected to not change the//! source value, and is declared to take `&self`, not `&mut self`. Therefore, any mutation that//! happens in the `clone` method must use cell types. For example, [`Rc<T>`] maintains its//! reference counts within a `Cell<T>`.//! use std::ptr::NonNull;//! use std::process::abort;//! use std::marker::PhantomData;//! struct Rc<T: ?Sized> {//!     ptr: NonNull<RcInner<T>>,//!     phantom: PhantomData<RcInner<T>>,//! struct RcInner<T: ?Sized> {//!     strong: Cell<usize>,//!     refcount: Cell<usize>,//!     value: T,//! impl<T: ?Sized> Clone for Rc<T> {//!     fn clone(&self) -> Rc<T> {//!         self.inc_strong();//!         Rc {//!             ptr: self.ptr,//!             phantom: PhantomData,//! trait RcInnerPtr<T: ?Sized> {//!     fn inner(&self) -> &RcInner<T>;//!     fn strong(&self) -> usize {//!         self.inner().strong.get()//!     fn inc_strong(&self) {//!         self.inner()//!             .strong//!             .set(self.strong()//!                      .checked_add(1)//!                      .unwrap_or_else(|| abort() ));//! impl<T: ?Sized> RcInnerPtr<T> for Rc<T> {//!    fn inner(&self) -> &RcInner<T> {//!        unsafe {//!            self.ptr.as_ref()//!        }//! [`Arc<T>`]: ../../std/sync/struct.Arc.html//! [`Rc<T>`]: ../../std/rc/struct.Rc.html//! [`RwLock<T>`]: ../../std/sync/struct.RwLock.html//! [`Mutex<T>`]: ../../std/sync/struct.Mutex.html//! [`OnceLock<T>`]: ../../std/sync/struct.OnceLock.html//! [`LazyLock<T, F>`]: ../../std/sync/struct.LazyLock.html//! [`Sync`]: ../../std/marker/trait.Sync.html//! [`atomic`]: crate::sync::atomicTryFromCharError/// Converts a `u32` to a `char`. See [`char::from_u32`]./// Converts a `u32` to a `char`, ignoring validity. See [`char::from_u32_unchecked`]./// Converts a [`char`] into a [`u32`]./// let c = 'c';/// let u = u32::from(c);/// assert!(4 == size_of_val(&u))/// Converts a [`char`] into a [`u64`]./// let c = '👤';/// let u = u64::from(c);/// assert!(8 == size_of_val(&u))/// Converts a [`char`] into a [`u128`]./// let c = '⚙';/// let u = u128::from(c);/// assert!(16 == size_of_val(&u))/// Tries to convert a [`char`] into a [`u8`]./// let a = 'ÿ'; // U+00FF/// let b = 'Ā'; // U+0100/// assert_eq!(u8::try_from(a), Ok(0xFF_u8));/// assert!(u8::try_from(b).is_err());/// Maps a `char` with code point in U+0000..=U+00FF to a byte in 0x00..=0xFF with same value,/// failing if the code point is greater than U+00FF./// See [`impl From<u8> for char`](char#impl-From<u8>-for-char) for details on the encoding./// Tries to convert a [`char`] into a [`u16`]./// let trans_rights = '⚧'; // U+26A7/// let ninjas = '🥷'; // U+1F977/// assert_eq!(u16::try_from(trans_rights), Ok(0x26A7_u16));/// assert!(u16::try_from(ninjas).is_err());/// Maps a `char` with code point in U+0000..=U+FFFF to a `u16` in 0x0000..=0xFFFF with same value,/// failing if the code point is greater than U+FFFF./// This corresponds to the UCS-2 encoding, as specified in ISO/IEC 10646:2003./// Converts a [`u8`] into a [`char`]./// let u = 32 as u8;/// let c = char::from(u);/// assert!(4 == size_of_val(&c))/// Maps a byte in 0x00..=0xFF to a `char` whose code point has the same value, in U+0000..=U+00FF./// Unicode is designed such that this effectively decodes bytes/// with the character encoding that IANA calls ISO-8859-1./// This encoding is compatible with ASCII./// Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen),/// which leaves some "blanks", byte values that are not assigned to any character./// ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes./// Note that this is *also* different from Windows-1252 a.k.a. code page 1252,/// which is a superset ISO/IEC 8859-1 that assigns some (not all!) blanks/// to punctuation and various Latin characters./// To confuse things further, [on the Web](https://encoding.spec.whatwg.org/)/// `ascii`, `iso-8859-1`, and `windows-1252` are all aliases/// for a superset of Windows-1252 that fills the remaining blanks with corresponding/// C0 and C1 control codes.CharErrorKindParseCharError/// An error which can be returned when parsing a char./// This `struct` is created when using the [`char::from_str`] method.TooManyCharschar_try_from_u32/// The error type returned when a conversion from [`prim@u32`] to [`prim@char`] fails./// This `struct` is created by the [`char::try_from<u32>`](char#impl-TryFrom<u32>-for-char) method.from_digit/// Converts a digit in the given radix to a `char`. See [`char::from_digit`].//! Character conversions./// An iterator that decodes UTF-16 encoded code points from an iterator of `u16`s./// This `struct` is created by the [`decode_utf16`] method on [`char`]. See its/// [`decode_utf16`]: char::decode_utf16/// This `struct` is created when using the [`DecodeUtf16`] type./// Creates an iterator over the UTF-16 encoded code points in `iter`,/// returning unpaired surrogates as `Err`s. See [`char::decode_utf16`].//! UTF-8 and UTF-16 decoding iteratorsis_printable/// The lowest valid code point a `char` can have, `'\0'`./// Unlike integer types, `char` actually has a gap in the middle,/// meaning that the range of possible `char`s is smaller than you/// might expect. Ranges of `char` will automatically hop this gap/// for you:/// let dist = u32::from(char::MAX) - u32::from(char::MIN);/// let size = (char::MIN..=char::MAX).count() as u32;/// assert!(size < dist);/// Despite this gap, the `MIN` and [`MAX`] values can be used as bounds for/// all `char` values./// [`MAX`]: char::MAX/// # fn something_which_returns_char() -> char { 'a' }/// let c: char = something_which_returns_char();/// assert!(char::MIN <= c);/// let value_at_min = u32::from(char::MIN);/// assert_eq!(char::from_u32(value_at_min), Some('\0'));/// The highest valid code point a `char` can have, `'\u{10FFFF}'`./// Despite this gap, the [`MIN`] and `MAX` values can be used as bounds for/// [`MIN`]: char::MIN/// assert!(c <= char::MAX);/// let value_at_max = u32::from(char::MAX);/// assert_eq!(char::from_u32(value_at_max), Some('\u{10FFFF}'));/// assert_eq!(char::from_u32(value_at_max + 1), None);MAX_LEN_UTF8/// The maximum number of bytes required to [encode](char::encode_utf8) a `char` to/// UTF-8 encoding.MAX_LEN_UTF16/// The maximum number of two-byte units required to [encode](char::encode_utf16) a `char`/// to UTF-16 encoding./// `U+FFFD REPLACEMENT CHARACTER` (�) is used in Unicode to represent a/// decoding error./// It can occur, for example, when giving ill-formed UTF-8 bytes to/// [`String::from_utf8_lossy`](../std/string/struct.String.html#method.from_utf8_lossy)./// The version of [Unicode](https://www.unicode.org/) that the Unicode parts of/// `char` and `str` methods are based on./// New versions of Unicode are released regularly and subsequently all methods/// in the standard library depending on Unicode are updated. Therefore the/// behavior of some `char` and `str` methods and the value of this constant/// changes over time. This is *not* considered to be a breaking change./// The version numbering scheme is explained in/// [Unicode 11.0 or later, Section 3.1 Versions of the Unicode Standard](https://www.unicode.org/versions/Unicode11.0.0/ch03.pdf#page=4)./// Creates an iterator over the native endian UTF-16 encoded code points in `iter`,/// returning unpaired surrogates as `Err`s.///     char::decode_utf16(v)/// A lossy decoder can be obtained by replacing `Err` results with the replacement character:///        .map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER))/// Converts a `u32` to a `char`./// Note that all `char`s are valid [`u32`]s, and can be cast to one with/// [`as`](../std/keyword.as.html):/// let c = '💯';/// let i = c as u32;/// assert_eq!(128175, i);/// However, the reverse is not true: not all valid [`u32`]s are valid/// `char`s. `from_u32()` will return `None` if the input is not a valid value/// for a `char`./// For an unsafe version of this function which ignores these checks, see/// [`from_u32_unchecked`]./// [`from_u32_unchecked`]: #method.from_u32_unchecked/// let c = char::from_u32(0x2764);/// assert_eq!(Some('❤'), c);/// Returning `None` when the input is not a valid `char`:/// let c = char::from_u32(0x110000);/// assert_eq!(None, c);/// Converts a `u32` to a `char`, ignoring validity./// `as`:/// `char`s. `from_u32_unchecked()` will ignore this, and blindly cast to/// `char`, possibly creating an invalid one./// This function is unsafe, as it may construct invalid `char` values./// For a safe version of this function, see the [`from_u32`] function./// [`from_u32`]: #method.from_u32/// let c = unsafe { char::from_u32_unchecked(0x2764) };/// assert_eq!('❤', c);/// Converts a digit in the given radix to a `char`./// A 'radix' here is sometimes also called a 'base'. A radix of two/// indicates a binary number, a radix of ten, decimal, and a radix of/// sixteen, hexadecimal, to give some common values. Arbitrary/// radices are supported./// `from_digit()` will return `None` if the input is not a digit in/// the given radix./// Panics if given a radix larger than 36./// let c = char::from_digit(4, 10);/// assert_eq!(Some('4'), c);/// // Decimal 11 is a single digit in base 16/// let c = char::from_digit(11, 16);/// assert_eq!(Some('b'), c);/// Returning `None` when the input is not a digit:/// let c = char::from_digit(20, 10);/// Passing a large radix, causing a panic:/// // this panics/// let _c = char::from_digit(1, 37);/// Checks if a `char` is a digit in the given radix./// Compared to [`is_numeric()`], this function only recognizes the characters/// `0-9`, `a-z` and `A-Z`./// 'Digit' is defined to be only the following characters:/// * `0-9`/// * `a-z`/// * `A-Z`/// For a more comprehensive understanding of 'digit', see [`is_numeric()`]./// [`is_numeric()`]: #method.is_numeric/// Panics if given a radix smaller than 2 or larger than 36./// assert!('1'.is_digit(10));/// assert!('f'.is_digit(16));/// assert!(!'f'.is_digit(10));/// '1'.is_digit(37);/// Passing a small radix, causing a panic:/// '1'.is_digit(1);"char_to_digit"/// Converts a `char` to a digit in the given radix./// Returns `None` if the `char` does not refer to a digit in the given radix./// assert_eq!('1'.to_digit(10), Some(1));/// assert_eq!('f'.to_digit(16), Some(15));/// Passing a non-digit results in failure:/// assert_eq!('f'.to_digit(10), None);/// assert_eq!('z'.to_digit(16), None);/// let _ = '1'.to_digit(37);/// let _ = '1'.to_digit(1);"this returns the escaped char as an iterator, \
                  without modifying the original"/// Returns an iterator that yields the hexadecimal Unicode escape of a/// character as `char`s./// This will escape characters with the Rust syntax of the form/// `\u{NNNNNN}` where `NNNNNN` is a hexadecimal representation./// As an iterator:/// for c in '❤'.escape_unicode() {///     print!("{c}");/// println!();/// Using `println!` directly:/// println!("{}", '❤'.escape_unicode());/// Both are equivalent to:/// println!("\\u{{2764}}");/// Using [`to_string`](../std/string/trait.ToString.html#tymethod.to_string):/// assert_eq!('❤'.escape_unicode().to_string(), "\\u{2764}");escape_debug_extEscapeDebugExtArgs/// An extended version of `escape_debug` that optionally permits escaping/// Extended Grapheme codepoints, single quotes, and double quotes. This/// allows us to format characters like nonspacing marks better when they're/// at the start of a string, and allows escaping single quotes in/// characters, and double quotes in strings./// Returns an iterator that yields the literal escape code of a character/// as `char`s./// This will escape the characters similar to the [`Debug`](core::fmt::Debug) implementations/// of `str` or `char`./// for c in '\n'.escape_debug() {/// println!("{}", '\n'.escape_debug());/// println!("\\n");/// assert_eq!('\n'.escape_debug().to_string(), "\\n");/// * All other characters are given hexadecimal Unicode escapes; see///   [`escape_unicode`]./// [`escape_unicode`]: #method.escape_unicode/// for c in '"'.escape_default() {/// println!("{}", '"'.escape_default());/// println!("\\\"");/// assert_eq!('"'.escape_default().to_string(), "\\\"");len_utf8/// Returns the number of bytes this `char` would need if encoded in UTF-8./// That number of bytes is always between 1 and 4, inclusive./// let len = 'A'.len_utf8();/// assert_eq!(len, 1);/// let len = 'ß'.len_utf8();/// let len = 'ℝ'.len_utf8();/// let len = '💣'.len_utf8();/// assert_eq!(len, 4);/// The `&str` type guarantees that its contents are UTF-8, and so we can compare the length it/// would take if each code point was represented as a `char` vs in the `&str` itself:/// // as chars/// let eastern = '東';/// let capital = '京';/// // both can be represented as three bytes/// assert_eq!(3, eastern.len_utf8());/// assert_eq!(3, capital.len_utf8());/// // as a &str, these two are encoded in UTF-8/// let tokyo = "東京";/// let len = eastern.len_utf8() + capital.len_utf8();/// // we can see that they take six bytes total.../// assert_eq!(6, tokyo.len());/// // ... just like the &str/// assert_eq!(len, tokyo.len());len_utf16/// Returns the number of 16-bit code units this `char` would need if/// encoded in UTF-16./// That number of code units is always either 1 or 2, for unicode scalar values in/// the [basic multilingual plane] or [supplementary planes] respectively./// See the documentation for [`len_utf8()`] for more explanation of this/// concept. This function is a mirror, but for UTF-16 instead of UTF-8./// [basic multilingual plane]: http://www.unicode.org/glossary/#basic_multilingual_plane/// [supplementary planes]: http://www.unicode.org/glossary/#supplementary_planes/// [`len_utf8()`]: #method.len_utf8/// let n = 'ß'.len_utf16();/// assert_eq!(n, 1);/// let len = '💣'.len_utf16();/// Encodes this character as UTF-8 into the provided byte buffer,/// and then returns the subslice of the buffer that contains the encoded character./// Panics if the buffer is not large enough./// A buffer of length four is large enough to encode any `char`./// In both of these examples, 'ß' takes two bytes to encode./// let mut b = [0; 2];/// let result = 'ß'.encode_utf8(&mut b);/// assert_eq!(result, "ß");/// assert_eq!(result.len(), 2);/// A buffer that's too small:/// let mut b = [0; 1];/// 'ß'.encode_utf8(&mut b);/// Encodes this character as native endian UTF-16 into the provided `u16` buffer,/// A buffer of length 2 is large enough to encode any `char`./// In both of these examples, '𝕊' takes two `u16`s to encode./// let result = '𝕊'.encode_utf16(&mut b);/// '𝕊'.encode_utf16(&mut b);/// Returns `true` if this `char` has the `Alphabetic` property./// `Alphabetic` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`]./// [Unicode Standard]: https://www.unicode.org/versions/latest//// [ucd]: https://www.unicode.org/reports/tr44//// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt/// assert!('a'.is_alphabetic());/// assert!('京'.is_alphabetic());/// let c = '💝';/// // love is many things, but it is not alphabetic/// assert!(!c.is_alphabetic());/// Returns `true` if this `char` has the `Lowercase` property./// `Lowercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and/// assert!('a'.is_lowercase());/// assert!('δ'.is_lowercase());/// assert!(!'A'.is_lowercase());/// assert!(!'Δ'.is_lowercase());/// // The various Chinese scripts and punctuation do not have case, and so:/// assert!(!'中'.is_lowercase());/// assert!(!' '.is_lowercase());/// In a const context:/// const CAPITAL_DELTA_IS_LOWERCASE: bool = 'Δ'.is_lowercase();/// assert!(!CAPITAL_DELTA_IS_LOWERCASE);/// Returns `true` if this `char` has the `Uppercase` property./// `Uppercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and/// assert!(!'a'.is_uppercase());/// assert!(!'δ'.is_uppercase());/// assert!('A'.is_uppercase());/// assert!('Δ'.is_uppercase());/// assert!(!'中'.is_uppercase());/// assert!(!' '.is_uppercase());/// const CAPITAL_DELTA_IS_UPPERCASE: bool = 'Δ'.is_uppercase();/// assert!(CAPITAL_DELTA_IS_UPPERCASE);/// Returns `true` if this `char` has the `White_Space` property./// `White_Space` is specified in the [Unicode Character Database][ucd] [`PropList.txt`]./// [`PropList.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt/// assert!(' '.is_whitespace());/// // line break/// assert!('\n'.is_whitespace());/// // a non-breaking space/// assert!('\u{A0}'.is_whitespace());/// assert!(!'越'.is_whitespace());/// Returns `true` if this `char` satisfies either [`is_alphabetic()`] or [`is_numeric()`]./// [`is_alphabetic()`]: #method.is_alphabetic/// assert!('٣'.is_alphanumeric());/// assert!('7'.is_alphanumeric());/// assert!('৬'.is_alphanumeric());/// assert!('¾'.is_alphanumeric());/// assert!('①'.is_alphanumeric());/// assert!('K'.is_alphanumeric());/// assert!('و'.is_alphanumeric());/// assert!('藏'.is_alphanumeric());/// Returns `true` if this `char` has the general category for control codes./// Control codes (code points with the general category of `Cc`) are described in Chapter 4/// (Character Properties) of the [Unicode Standard] and specified in the [Unicode Character/// Database][ucd] [`UnicodeData.txt`]./// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt/// // U+009C, STRING TERMINATOR/// assert!('œ'.is_control());/// assert!(!'q'.is_control());is_grapheme_extended/// Returns `true` if this `char` has the `Grapheme_Extend` property./// `Grapheme_Extend` is described in [Unicode Standard Annex #29 (Unicode Text/// Segmentation)][uax29] and specified in the [Unicode Character Database][ucd]/// [`DerivedCoreProperties.txt`]./// [uax29]: https://www.unicode.org/reports/tr29/is_cased/// Returns `true` if this `char` has the `Cased` property./// `Cased` is described in Chapter 4 (Character Properties) of the [Unicode Standard] andis_case_ignorable/// Returns `true` if this `char` has the `Case_Ignorable` property./// `Case_Ignorable` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and/// Returns `true` if this `char` has one of the general categories for numbers./// The general categories for numbers (`Nd` for decimal digits, `Nl` for letter-like numeric/// characters, and `No` for other numeric characters) are specified in the [Unicode Character/// This method doesn't cover everything that could be considered a number, e.g. ideographic numbers like '三'./// If you want everything including characters with overlapping purposes then you might want to use/// a unicode or language-processing library that exposes the appropriate character properties instead/// of looking at the unicode categories./// If you want to parse ASCII decimal digits (0-9) or ASCII base-N, use/// `is_ascii_digit` or `is_digit` instead./// assert!('٣'.is_numeric());/// assert!('7'.is_numeric());/// assert!('৬'.is_numeric());/// assert!('¾'.is_numeric());/// assert!('①'.is_numeric());/// assert!(!'K'.is_numeric());/// assert!(!'و'.is_numeric());/// assert!(!'藏'.is_numeric());/// assert!(!'三'.is_numeric());"this returns the lowercase character as a new iterator, \
                  without modifying the original"ToLowercase/// Returns an iterator that yields the lowercase mapping of this `char` as one or more/// `char`s./// If this `char` does not have a lowercase mapping, the iterator yields the same `char`./// If this `char` has a one-to-one lowercase mapping given by the [Unicode Character/// Database][ucd] [`UnicodeData.txt`], the iterator yields that `char`./// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields/// the `char`(s) given by [`SpecialCasing.txt`]./// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt/// This operation performs an unconditional mapping without tailoring. That is, the conversion/// is independent of context and language./// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in/// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion./// for c in 'İ'.to_lowercase() {/// println!("{}", 'İ'.to_lowercase());/// println!("i\u{307}");/// assert_eq!('C'.to_lowercase().to_string(), "c");/// // Sometimes the result is more than one character:/// assert_eq!('İ'.to_lowercase().to_string(), "i\u{307}");/// // Characters that do not have both uppercase and lowercase/// // convert into themselves./// assert_eq!('山'.to_lowercase().to_string(), "山");"this returns the uppercase character as a new iterator, \
                  without modifying the original"ToUppercase/// Returns an iterator that yields the uppercase mapping of this `char` as one or more/// If this `char` does not have an uppercase mapping, the iterator yields the same `char`./// If this `char` has a one-to-one uppercase mapping given by the [Unicode Character/// for c in 'ß'.to_uppercase() {/// println!("{}", 'ß'.to_uppercase());/// println!("SS");/// assert_eq!('c'.to_uppercase().to_string(), "C");/// assert_eq!('ß'.to_uppercase().to_string(), "SS");/// assert_eq!('山'.to_uppercase().to_string(), "山");/// # Note on locale/// In Turkish, the equivalent of 'i' in Latin has five forms instead of two:/// * 'Dotless': I / ı, sometimes written ï/// * 'Dotted': İ / i/// Note that the lowercase dotted 'i' is the same as the Latin. Therefore:/// let upper_i = 'i'.to_uppercase().to_string();/// The value of `upper_i` here relies on the language of the text: if we're/// in `en-US`, it should be `"I"`, but if we're in `tr_TR`, it should/// be `"İ"`. `to_uppercase()` does not take this into account, and so:/// assert_eq!(upper_i, "I");/// holds across languages."char_is_ascii"/// Checks if the value is within the ASCII range./// let ascii = 'a';/// let non_ascii = '❤';/// assert!(ascii.is_ascii());/// assert!(!non_ascii.is_ascii());/// Returns `Some` if the value is within the ASCII range,/// or `None` if it's not./// This is preferred to [`Self::is_ascii`] when you're passing the value/// along to something else that can take [`ascii::Char`] rather than/// needing to check again for itself whether the value is in ASCII./// Converts this char into an [ASCII character](`ascii::Char`), without/// checking whether it is valid./// This char must be within the ASCII range, or else this is UB./// Makes a copy of the value in its ASCII upper case equivalent./// To uppercase the value in-place, use [`make_ascii_uppercase()`]./// [`to_uppercase()`]./// assert_eq!('A', ascii.to_ascii_uppercase());/// assert_eq!('❤', non_ascii.to_ascii_uppercase());/// [`make_ascii_uppercase()`]: #method.make_ascii_uppercase/// [`to_uppercase()`]: #method.to_uppercase/// Makes a copy of the value in its ASCII lower case equivalent./// To lowercase the value in-place, use [`make_ascii_lowercase()`]./// [`to_lowercase()`]./// let ascii = 'A';/// assert_eq!('a', ascii.to_ascii_lowercase());/// assert_eq!('❤', non_ascii.to_ascii_lowercase());/// [`make_ascii_lowercase()`]: #method.make_ascii_lowercase/// [`to_lowercase()`]: #method.to_lowercase/// Checks that two values are an ASCII case-insensitive match./// Equivalent to <code>[to_ascii_lowercase]\(a) == [to_ascii_lowercase]\(b)</code>./// let upper_a = 'A';/// let lower_a = 'a';/// let lower_z = 'z';/// assert!(upper_a.eq_ignore_ascii_case(&lower_a));/// assert!(upper_a.eq_ignore_ascii_case(&upper_a));/// assert!(!upper_a.eq_ignore_ascii_case(&lower_z));/// [to_ascii_lowercase]: #method.to_ascii_lowercasemake_ascii_uppercase/// Converts this type to its ASCII upper case equivalent in-place./// [`to_ascii_uppercase()`]./// let mut ascii = 'a';/// ascii.make_ascii_uppercase();/// assert_eq!('A', ascii);/// [`to_ascii_uppercase()`]: #method.to_ascii_uppercasemake_ascii_lowercase/// Converts this type to its ASCII lower case equivalent in-place./// [`to_ascii_lowercase()`]./// let mut ascii = 'A';/// ascii.make_ascii_lowercase();/// assert_eq!('a', ascii);/// [`to_ascii_lowercase()`]: #method.to_ascii_lowercaseis_ascii_alphabetic/// Checks if the value is an ASCII alphabetic character:/// - U+0041 'A' ..= U+005A 'Z', or/// - U+0061 'a' ..= U+007A 'z'./// let uppercase_a = 'A';/// let uppercase_g = 'G';/// let a = 'a';/// let g = 'g';/// let zero = '0';/// let percent = '%';/// let space = ' ';/// let lf = '\n';/// let esc = '\x1b';/// assert!(uppercase_a.is_ascii_alphabetic());/// assert!(uppercase_g.is_ascii_alphabetic());/// assert!(a.is_ascii_alphabetic());/// assert!(g.is_ascii_alphabetic());/// assert!(!zero.is_ascii_alphabetic());/// assert!(!percent.is_ascii_alphabetic());/// assert!(!space.is_ascii_alphabetic());/// assert!(!lf.is_ascii_alphabetic());/// assert!(!esc.is_ascii_alphabetic());is_ascii_uppercase/// Checks if the value is an ASCII uppercase character:/// U+0041 'A' ..= U+005A 'Z'./// assert!(uppercase_a.is_ascii_uppercase());/// assert!(uppercase_g.is_ascii_uppercase());/// assert!(!a.is_ascii_uppercase());/// assert!(!g.is_ascii_uppercase());/// assert!(!zero.is_ascii_uppercase());/// assert!(!percent.is_ascii_uppercase());/// assert!(!space.is_ascii_uppercase());/// assert!(!lf.is_ascii_uppercase());/// assert!(!esc.is_ascii_uppercase());is_ascii_lowercase/// Checks if the value is an ASCII lowercase character:/// U+0061 'a' ..= U+007A 'z'./// assert!(!uppercase_a.is_ascii_lowercase());/// assert!(!uppercase_g.is_ascii_lowercase());/// assert!(a.is_ascii_lowercase());/// assert!(g.is_ascii_lowercase());/// assert!(!zero.is_ascii_lowercase());/// assert!(!percent.is_ascii_lowercase());/// assert!(!space.is_ascii_lowercase());/// assert!(!lf.is_ascii_lowercase());/// assert!(!esc.is_ascii_lowercase());/// Checks if the value is an ASCII alphanumeric character:/// - U+0061 'a' ..= U+007A 'z', or/// - U+0030 '0' ..= U+0039 '9'./// assert!(uppercase_a.is_ascii_alphanumeric());/// assert!(uppercase_g.is_ascii_alphanumeric());/// assert!(a.is_ascii_alphanumeric());/// assert!(g.is_ascii_alphanumeric());/// assert!(zero.is_ascii_alphanumeric());/// assert!(!percent.is_ascii_alphanumeric());/// assert!(!space.is_ascii_alphanumeric());/// assert!(!lf.is_ascii_alphanumeric());/// assert!(!esc.is_ascii_alphanumeric());is_ascii_digit/// Checks if the value is an ASCII decimal digit:/// U+0030 '0' ..= U+0039 '9'./// assert!(!uppercase_a.is_ascii_digit());/// assert!(!uppercase_g.is_ascii_digit());/// assert!(!a.is_ascii_digit());/// assert!(!g.is_ascii_digit());/// assert!(zero.is_ascii_digit());/// assert!(!percent.is_ascii_digit());/// assert!(!space.is_ascii_digit());/// assert!(!lf.is_ascii_digit());/// assert!(!esc.is_ascii_digit());is_ascii_octdigit/// Checks if the value is an ASCII octal digit:/// U+0030 '0' ..= U+0037 '7'./// #![feature(is_ascii_octdigit)]/// let seven = '7';/// let nine = '9';/// assert!(!uppercase_a.is_ascii_octdigit());/// assert!(!a.is_ascii_octdigit());/// assert!(zero.is_ascii_octdigit());/// assert!(seven.is_ascii_octdigit());/// assert!(!nine.is_ascii_octdigit());/// assert!(!percent.is_ascii_octdigit());/// assert!(!lf.is_ascii_octdigit());is_ascii_hexdigit/// Checks if the value is an ASCII hexadecimal digit:/// - U+0030 '0' ..= U+0039 '9', or/// - U+0041 'A' ..= U+0046 'F', or/// - U+0061 'a' ..= U+0066 'f'./// assert!(uppercase_a.is_ascii_hexdigit());/// assert!(!uppercase_g.is_ascii_hexdigit());/// assert!(a.is_ascii_hexdigit());/// assert!(!g.is_ascii_hexdigit());/// assert!(zero.is_ascii_hexdigit());/// assert!(!percent.is_ascii_hexdigit());/// assert!(!space.is_ascii_hexdigit());/// assert!(!lf.is_ascii_hexdigit());/// assert!(!esc.is_ascii_hexdigit());/// Checks if the value is an ASCII punctuation character:/// - U+0021 ..= U+002F `! " # $ % & ' ( ) * + , - . /`, or/// - U+003A ..= U+0040 `: ; < = > ? @`, or/// - U+005B ..= U+0060 ``[ \ ] ^ _ ` ``, or/// - U+007B ..= U+007E `{ | } ~`/// assert!(!uppercase_a.is_ascii_punctuation());/// assert!(!uppercase_g.is_ascii_punctuation());/// assert!(!a.is_ascii_punctuation());/// assert!(!g.is_ascii_punctuation());/// assert!(!zero.is_ascii_punctuation());/// assert!(percent.is_ascii_punctuation());/// assert!(!space.is_ascii_punctuation());/// assert!(!lf.is_ascii_punctuation());/// assert!(!esc.is_ascii_punctuation());is_ascii_graphic/// Checks if the value is an ASCII graphic character:/// U+0021 '!' ..= U+007E '~'./// assert!(uppercase_a.is_ascii_graphic());/// assert!(uppercase_g.is_ascii_graphic());/// assert!(a.is_ascii_graphic());/// assert!(g.is_ascii_graphic());/// assert!(zero.is_ascii_graphic());/// assert!(percent.is_ascii_graphic());/// assert!(!space.is_ascii_graphic());/// assert!(!lf.is_ascii_graphic());/// assert!(!esc.is_ascii_graphic());/// Checks if the value is an ASCII whitespace character:/// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,/// U+000C FORM FEED, or U+000D CARRIAGE RETURN./// U+000B VERTICAL TAB as well as all the above characters,/// assert!(!uppercase_a.is_ascii_whitespace());/// assert!(!uppercase_g.is_ascii_whitespace());/// assert!(!a.is_ascii_whitespace());/// assert!(!g.is_ascii_whitespace());/// assert!(!zero.is_ascii_whitespace());/// assert!(!percent.is_ascii_whitespace());/// assert!(space.is_ascii_whitespace());/// assert!(lf.is_ascii_whitespace());/// assert!(!esc.is_ascii_whitespace());is_ascii_control/// Checks if the value is an ASCII control character:/// U+0000 NUL ..= U+001F UNIT SEPARATOR, or U+007F DELETE./// Note that most ASCII whitespace characters are control/// assert!(!uppercase_a.is_ascii_control());/// assert!(!uppercase_g.is_ascii_control());/// assert!(!a.is_ascii_control());/// assert!(!g.is_ascii_control());/// assert!(!zero.is_ascii_control());/// assert!(!percent.is_ascii_control());/// assert!(!space.is_ascii_control());/// assert!(lf.is_ascii_control());/// assert!(esc.is_ascii_control());escape_grapheme_extended/// Escape Extended Grapheme codepoints?/// Escape single quotes?/// Escape double quotes?ESCAPE_ALL/// Encodes a raw `u32` value as UTF-8 into the provided byte buffer,/// Unlike `char::encode_utf8`, this method also handles codepoints in the surrogate range./// (Creating a `char` in the surrogate range is UB.)/// The result is valid [generalized UTF-8] but not valid UTF-8./// [generalized UTF-8]: https://simonsapin.github.io/wtf-8/#generalized-utf8encode_utf8_raw_unchecked/// Encodes a raw `u32` value as UTF-8 into the byte buffer pointed to by `dst`./// The behavior is undefined if the buffer pointed to by `dst` is not/// large enough to hold the encoded codepoint. A buffer of length four/// is large enough to encode any `char`./// For a safe version of this function, see the [`encode_utf8_raw`] function.encode_utf16_raw/// Encodes a raw `u32` value as native endian UTF-16 into the provided `u16` buffer,/// Unlike `char::encode_utf16`, this method also handles codepoints in the surrogate range.//! impl char {}// stable re-exports// perma-unstable re-exports// perma-unstableMaybeEscaped/// The highest valid code point a `char` can have, `'\u{10FFFF}'`. Use [`char::MAX`] instead./// decoding error. Use [`char::REPLACEMENT_CHARACTER`] instead./// `char` and `str` methods are based on. Use [`char::UNICODE_VERSION`] instead./// Creates an iterator over the UTF-16 encoded code points in `iter`, returning/// unpaired surrogates as `Err`s. Use [`char::decode_utf16`] instead./// Converts a `u32` to a `char`. Use [`char::from_u32`] instead./// Converts a `u32` to a `char`, ignoring validity. Use [`char::from_u32_unchecked`]/// Converts a digit in the given radix to a `char`. Use [`char::from_digit`] instead./// character, as `char`s./// This `struct` is created by the [`escape_unicode`] method on [`char`]. See/// [`escape_unicode`]: char::escape_unicode/// An iterator that yields the literal escape code of a `char`./// This `struct` is created by the [`escape_default`] method on [`char`]. See/// [`escape_default`]: char::escape_default/// This `struct` is created by the [`escape_debug`] method on [`char`]. See its/// [`escape_debug`]: char::escape_debugcasemappingiter_implsr" Returns an iterator that yields the lowercase equivalent of a `char`."r" This `struct` is created by the [`to_lowercase`] method on [`char`]. See"r" its documentation for more."r" [`to_lowercase`]: char::to_lowercase"CaseMappingIterr" Returns an iterator that yields the uppercase equivalent of a `char`."r" This `struct` is created by the [`to_uppercase`] method on [`char`]. See"r" [`to_uppercase`]: char::to_uppercase"// SAFETY: forwards to inner `array::IntoIter`// SAFETY: `CaseMappingIter` has no subtypes/supertypes/// The error type returned when a checked char conversion fails.//! Utilities for the `char` primitive type.//! *[See also the `char` primitive type](primitive@char).*//! The `char` type represents a single character. More specifically, since//! 'character' isn't a well-defined concept in Unicode, `char` is a '[Unicode//! scalar value]', which is similar to, but not the same as, a '[Unicode code//! point]'.//! [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value//! [Unicode code point]: https://www.unicode.org/glossary/#code_point//! This module exists for technical reasons, the primary documentation for//! `char` is directly on [the `char` primitive type][char] itself.//! This module is the home of the iterator implementations for the iterators//! implemented on `char`, as well as some useful constants and conversion//! functions that convert various types to `char`./*
    Lu  Uppercase_Letter        an uppercase letter
    Ll  Lowercase_Letter        a lowercase letter
    Lt  Titlecase_Letter        a digraphic character, with first part uppercase
    Lm  Modifier_Letter         a modifier letter
    Lo  Other_Letter            other letters, including syllables and ideographs
    Mn  Nonspacing_Mark         a nonspacing combining mark (zero advance width)
    Mc  Spacing_Mark            a spacing combining mark (positive advance width)
    Me  Enclosing_Mark          an enclosing combining mark
    Nd  Decimal_Number          a decimal digit
    Nl  Letter_Number           a letterlike numeric character
    No  Other_Number            a numeric character of other type
    Pc  Connector_Punctuation   a connecting punctuation mark, like a tie
    Pd  Dash_Punctuation        a dash or hyphen punctuation mark
    Ps  Open_Punctuation        an opening punctuation mark (of a pair)
    Pe  Close_Punctuation       a closing punctuation mark (of a pair)
    Pi  Initial_Punctuation     an initial quotation mark
    Pf  Final_Punctuation       a final quotation mark
    Po  Other_Punctuation       a punctuation mark of other type
    Sm  Math_Symbol             a symbol of primarily mathematical use
    Sc  Currency_Symbol         a currency sign
    Sk  Modifier_Symbol         a non-letterlike modifier symbol
    So  Other_Symbol            a symbol of other type
    Zs  Space_Separator         a space character (of various non-zero widths)
    Zl  Line_Separator          U+2028 LINE SEPARATOR only
    Zp  Paragraph_Separator     U+2029 PARAGRAPH SEPARATOR only
    Cc  Control                 a C0 or C1 control code
    Cf  Format                  a format control character
    Cs  Surrogate               a surrogate code point
    Co  Private_Use             a private-use character
    Cn  Unassigned              a reserved unassigned code point or a noncharacter
*/clone_oneclone_sliceCopySpec/// Private specialization trait used by CloneToUninit, as per/// [the dev guide](https://std-dev-guide.rust-lang.org/policy/specialization.html).// Specialized implementation for types that are [`TrivialClone`], not just [`Clone`],// and can therefore be copied bitwise./// Number of elements of `*self.data` that are initialized.InitializingSlice/// Ownership of a collection of values stored in a non-owned `[MaybeUninit<T>]`, some of which/// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation./// Its responsibility is to provide cleanup on unwind by dropping the values that *are*/// initialized, unless disarmed by forgetting./// This is a helper for `impl<T: Clone> CloneToUninit for [T]`.from_fully_uninit/// Push a value onto the end of the initialized part of the slice./// Panics if the slice is already fully initialized.// will only be invoked on unwindPointeeSized"clone_fn"/// Returns a duplicate of the value./// Note that what "duplicate" means varies by type:/// - For most types, this creates a deep, independent copy/// - For reference types like `&T`, this creates another reference to the same value/// - For smart pointers like [`Arc`] or [`Rc`], this increments the reference count///   but still points to the same underlying data/// [`Arc`]: ../../std/sync/struct.Arc.html/// [`Rc`]: ../../std/rc/struct.Rc.html/// # #![allow(noop_method_call)]/// let hello = "Hello"; // &str implements Clone/// assert_eq!("Hello", hello.clone());/// Example with a reference-counted type:/// let data = Arc::new(Mutex::new(vec![1, 2, 3]));/// let data_clone = data.clone(); // Creates another Arc pointing to the same Mutex///     let mut lock = data.lock().unwrap();///     lock.push(4);/// // Changes are visible through the clone because they share the same underlying data/// assert_eq!(*data_clone.lock().unwrap(), vec![1, 2, 3, 4]);// Clone::clone is special because the compiler generates MIR to implement it for some types.// See InstanceKind::CloneShim./// Performs copy-assignment from `source`./// `a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality,/// but can be overridden to reuse the resources of `a` to avoid unnecessary/// allocations."clone""Clone"rustc_trivial_field_reads/// A common trait that allows explicit creation of a duplicate value./// Calling [`clone`] always produces a new value./// However, for types that are references to other data (such as smart pointers or references),/// the new value may still point to the same underlying data, rather than duplicating it./// See [`Clone::clone`] for more details./// This distinction is especially important when using `#[derive(Clone)]` on structs containing/// smart pointers like `Arc<Mutex<T>>` - the cloned struct will share mutable state with the/// original./// Differs from [`Copy`] in that [`Copy`] is implicit and an inexpensive bit-wise copy, while/// `Clone` is always explicit and may or may not be expensive. In order to enforce/// these characteristics, Rust does not allow you to reimplement [`Copy`], but you/// may reimplement `Clone` and run arbitrary code./// Since `Clone` is more general than [`Copy`], you can automatically make anything/// [`Copy`] be `Clone` as well./// ## Derivable/// This trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d/// implementation of [`Clone`] calls [`clone`] on each field./// For a generic struct, `#[derive]` implements `Clone` conditionally by adding bound `Clone` on/// generic parameters./// // `derive` implements Clone for Reading<T> when T is Clone./// struct Reading<T> {///     frequency: T,/// ## How can I implement `Clone`?/// Types that are [`Copy`] should have a trivial implementation of `Clone`. More formally:/// if `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`./// Manual implementations should be careful to uphold this invariant; however, unsafe code/// must not rely on it to ensure memory safety./// An example is a generic struct holding a function pointer. In this case, the/// implementation of `Clone` cannot be `derive`d, but can be implemented as:/// struct Generate<T>(fn() -> T);/// impl<T> Copy for Generate<T> {}/// impl<T> Clone for Generate<T> {///         *self/// If we `derive`:/// the auto-derived implementations will have unnecessary `T: Copy` and `T: Clone` bounds:/// # struct Generate<T>(fn() -> T);/// // Automatically derived/// impl<T: Copy> Copy for Generate<T> { }/// impl<T: Clone> Clone for Generate<T> {///     fn clone(&self) -> Generate<T> {///         Generate(Clone::clone(&self.0))/// The bounds are unnecessary because clearly the function itself should be/// copy- and cloneable even if its return type is not:/// struct NotCloneable;/// fn generate_not_cloneable() -> NotCloneable {///     NotCloneable/// Generate(generate_not_cloneable).clone(); // error: trait bounds were not satisfied/// // Note: With the manual implementations the above line will compile./// ## `Clone` and `PartialEq`/`Eq`/// `Clone` is intended for the duplication of objects. Consequently, when implementing/// both `Clone` and [`PartialEq`], the following property is expected to hold:/// x == x -> x.clone() == x/// In other words, if an object compares equal to itself,/// its clone must also compare equal to the original./// For types that also implement [`Eq`] – for which `x == x` always holds –/// this implies that `x.clone() == x` must always be true./// Standard library collections such as/// [`HashMap`], [`HashSet`], [`BTreeMap`], [`BTreeSet`] and [`BinaryHeap`]/// rely on their keys respecting this property for correct behavior./// Furthermore, these collections require that cloning a key preserves the outcome of the/// [`Hash`] and [`Ord`] methods. Thankfully, this follows automatically from `x.clone() == x`/// if `Hash` and `Ord` are correctly implemented according to their own requirements./// When deriving both `Clone` and [`PartialEq`] using `#[derive(Clone, PartialEq)]`/// or when additionally deriving [`Eq`] using `#[derive(Clone, PartialEq, Eq)]`,/// then this property is automatically upheld – provided that it is satisfied by/// the underlying types./// Violating this property is a logic error. The behavior resulting from a logic error is not/// specified, but users of the trait must ensure that such logic errors do *not* result in/// undefined behavior. This means that `unsafe` code **must not** rely on this property/// being satisfied./// ## Additional implementors/// In addition to the [implementors listed below][impls],/// the following types also implement `Clone`:/// * Function item types (i.e., the distinct types defined for each function)/// * Function pointer types (e.g., `fn() -> i32`)/// * Closure types, if they capture no value from the environment///   or if all such captured values implement `Clone` themselves.///   Note that variables captured by shared reference always implement `Clone`///   (even if the referent doesn't),///   while variables captured by mutable reference never implement `Clone`./// [`HashMap`]: ../../std/collections/struct.HashMap.html/// [`HashSet`]: ../../std/collections/struct.HashSet.html/// [`BTreeMap`]: ../../std/collections/struct.BTreeMap.html/// [`BTreeSet`]: ../../std/collections/struct.BTreeSet.html/// [`BinaryHeap`]: ../../std/collections/struct.BinaryHeap.html/// [impls]: #implementors"trivial_clone"/// Indicates that the `Clone` implementation is identical to copying the value./// This is used for some optimizations in the standard library, which specializes/// on this trait to select faster implementations of functions such as/// [`clone_from_slice`](slice::clone_from_slice). It is automatically implemented/// when using `#[derive(Clone, Copy)]`./// Note that this trait does not imply that the type is `Copy`, because e.g./// `core::ops::Range<i32>` could soundly implement this trait./// `Clone::clone` must be equivalent to copying the value, otherwise calling functions/// such as `slice::clone_from_slice` can have undefined behaviour.// It is sound to specialize on this because the `clone` implementation cannot be// lifetime-dependent. Therefore, if `TrivialClone` is implemented for any lifetime,// its invariant holds whenever `Clone` is implemented, even if the actual// `TrivialClone` bound would not be satisfied because of lifetime bounds.// If `#[derive(Clone, Clone, Copy)]` is written, there will be multiple// implementations of `TrivialClone`. To keep it from appearing in error// messages, make it a `#[marker]` trait./// Derive macro generating an impl of the trait `Clone`.// Empty."use_cloned"/// Trait for objects whose [`Clone`] impl is lightweight (e.g. reference-counted)/// Cloning an object implementing this trait should in general:/// - be O(1) (constant) time regardless of the amount of data managed by the object,/// - not require a memory allocation,/// - not require copying more than roughly 64 bytes (a typical cache line size),/// - not block the current thread,/// - not have any semantic side effects (e.g. allocating a file descriptor), and/// - not have overhead larger than a couple of atomic operations./// The `UseCloned` trait does not provide a method; instead, it indicates that/// `Clone::clone` is lightweight, and allows the use of the `.use` syntax./// ## .use postfix syntax/// Values can be `.use`d by adding `.use` postfix to the value you want to use./// ```ignore (this won't work until we land use)/// fn foo(f: Foo) {///     // if `Foo` implements `Copy` f would be copied into x.///     // if `Foo` implements `UseCloned` f would be cloned into x.///     // otherwise f would be moved into x.///     let x = f.use;/// ## use closures/// Use closures allow captured values to be automatically used./// This is similar to have a closure that you would call `.use` over each captured value.impl_use_cloned_fieldAssertParamIsClone// FIXME(aburka): these structs are used solely by #[derive] to// assert that every component of a type implements Clone or Copy.// These structs should never appear in user code.AssertParamIsCopyclone_to_uninit/// Performs copy-assignment from `self` to `dest`./// This is analogous to `std::ptr::write(dest.cast(), self.clone())`,/// except that `Self` may be a dynamically-sized type ([`!Sized`](Sized))./// Before this function is called, `dest` may point to uninitialized memory./// After this function is called, `dest` will point to initialized memory; it will be/// sound to create a `&Self` reference from the pointer with the [pointer metadata]/// from `self`./// * `dest` must be [valid] for writes for `size_of_val(self)` bytes./// * `dest` must be properly aligned to `align_of_val(self)`./// [valid]: crate::ptr#safety/// [pointer metadata]: crate::ptr::metadata()/// This function may panic. (For example, it might panic if memory allocation for a clone/// of a value owned by `self` fails.)/// If the call panics, then `*dest` should be treated as uninitialized memory; it must not be/// read or dropped, because even if it was previously valid, it may have been partially/// The caller may wish to take care to deallocate the allocation pointed to by `dest`,/// if applicable, to avoid a memory leak (but this is not a requirement)./// Implementors should avoid leaking values by, upon unwinding, dropping all component values/// that might have already been created. (For example, if a `[Foo]` of length 3 is being/// cloned, and the second of the three calls to `Foo::clone()` unwinds, then the first `Foo`/// cloned should be dropped.)/// A generalization of [`Clone`] to [dynamically-sized types][DST] stored in arbitrary containers./// This trait is implemented for all types implementing [`Clone`], [slices](slice) of all/// such types, and other dynamically-sized types in the standard library./// You may also implement this trait to enable cloning custom DSTs/// (structures containing dynamically-sized fields), or use it as a supertrait to enable/// cloning a [trait object]./// This trait is normally used via operations on container types which support DSTs,/// so you should not typically need to call `.clone_to_uninit()` explicitly except when/// implementing such a container or otherwise performing explicit management of an allocation,/// or when implementing `CloneToUninit` itself./// Implementations must ensure that when `.clone_to_uninit(dest)` returns normally rather than/// panicking, it always leaves `*dest` initialized as a valid value of type `Self`.// FIXME(#126799): when `Box::clone` allows use of `CloneToUninit`, rewrite these examples with it// since `Rc` is a distraction./// If you are defining a trait, you can add `CloneToUninit` as a supertrait to enable cloning of/// `dyn` values of your trait:/// #![feature(clone_to_uninit)]/// trait Foo: std::fmt::Debug + std::clone::CloneToUninit {///     fn modify(&mut self);///     fn value(&self) -> i32;/// impl Foo for i32 {///     fn modify(&mut self) {///         *self *= 10;///     fn value(&self) -> i32 {/// let first: Rc<dyn Foo> = Rc::new(1234);/// let mut second = first.clone();/// Rc::make_mut(&mut second).modify(); // make_mut() will call clone_to_uninit()/// assert_eq!(first.value(), 1234);/// assert_eq!(second.value(), 12340);/// The following is an example of implementing `CloneToUninit` for a custom DST./// (It is essentially a limited form of what `derive(CloneToUninit)` would do,/// if such a derive macro existed.)/// use std::clone::CloneToUninit;/// use std::mem::offset_of;/// #[derive(PartialEq)]/// struct MyDst<T: ?Sized> {///     label: String,///     contents: T,/// unsafe impl<T: ?Sized + CloneToUninit> CloneToUninit for MyDst<T> {///     unsafe fn clone_to_uninit(&self, dest: *mut u8) {///         // The offset of `self.contents` is dynamic because it depends on the alignment of T///         // which can be dynamic (if `T = dyn SomeTrait`). Therefore, we have to obtain it///         // dynamically by examining `self`, rather than using `offset_of!`.///         // SAFETY: `self` by definition points somewhere before `&self.contents` in the same///         // allocation.///         let offset_of_contents = unsafe {///             (&raw const self.contents).byte_offset_from_unsigned(self)///         // Clone the *sized* fields of `self` (just one, in this example).///         // (By cloning this first and storing it temporarily in a local variable, we avoid///         // leaking it in case of any panic, using the ordinary automatic cleanup of local///         // variables. Such a leak would be sound, but undesirable.)///         let label = self.label.clone();///         // SAFETY: The caller must provide a `dest` such that these field offsets are valid///         // to write to.///             // Clone the unsized field directly from `self` to `dest`.///             self.contents.clone_to_uninit(dest.add(offset_of_contents));///             // Now write all the sized fields.///             // Note that we only do this once all of the clone() and clone_to_uninit() calls///             // have completed, and therefore we know that there are no more possible panics;///             // this ensures no memory leaks in case of panic.///             dest.add(offset_of!(Self, label)).cast::<String>().write(label);///         // All fields of the struct have been initialized; therefore, the struct is initialized,///         // and we have satisfied our `unsafe impl CloneToUninit` obligations.///     // Construct MyDst<[u8; 4]>, then coerce to MyDst<[u8]>.///     let first: Rc<MyDst<[u8]>> = Rc::new(MyDst {///         label: String::from("hello"),///         contents: [1, 2, 3, 4],///     let mut second = first.clone();///     // make_mut() will call clone_to_uninit().///     for elem in Rc::make_mut(&mut second).contents.iter_mut() {///         *elem *= 10;///     assert_eq!(first.contents, [1, 2, 3, 4]);///     assert_eq!(second.contents, [10, 20, 30, 40]);///     assert_eq!(second.label, "hello");/// * [`Clone::clone_from`] is a safe function which may be used instead when [`Self: Sized`](Sized)///   and the destination is already initialized; it may be able to reuse allocations owned by///   the destination, whereas `clone_to_uninit` cannot, since its destination is assumed to be///   uninitialized./// * [`ToOwned`], which allocates a new destination container./// [`ToOwned`]: ../../std/borrow/trait.ToOwned.html/// [DST]: https://doc.rust-lang.org/reference/dynamically-sized-types.html/// [trait object]: https://doc.rust-lang.org/reference/types/trait-object.htmlimpl_clone"noop_method_clone"/// Shared references can be cloned, but mutable references *cannot*!/// Implementations of `Clone` for primitive types./// Implementations that cannot be described in Rust/// are implemented in `traits::SelectionContext::copy_clone_conditions()`/// in `rustc_trait_selection`.//! The `Clone` trait for types that cannot be 'implicitly copied'.//! In Rust, some simple types are "implicitly copyable" and when you//! assign them or pass them as arguments, the receiver will get a copy,//! leaving the original value in place. These types do not require//! allocation to copy and do not have finalizers (i.e., they do not//! contain owned boxes or implement [`Drop`]), so the compiler considers//! them cheap and safe to copy. For other types copies must be made//! explicitly, by convention implementing the [`Clone`] trait and calling//! the [`clone`] method.//! [`clone`]: Clone::clone//! Basic usage example://! let s = String::new(); // String type implements Clone//! let copy = s.clone(); // so we can clone it//! To easily implement the Clone trait, you can also use//! `#[derive(Clone)]`. Example://! #[derive(Clone)] // we add the Clone trait to Morpheus struct//! struct Morpheus {//!    blue_pill: f32,//!    red_pill: i64,//!    let f = Morpheus { blue_pill: 0.0, red_pill: 0 };//!    let copy = f.clone(); // and now we can clone it!/// Types where `==` & `!=` are equivalent to comparing their underlying bytes./// Importantly, this means no floating-point types, as those have different/// byte representations (like `-0` and `+0`) which compare as the same./// Since byte arrays are `Eq`, that implies that these types are probably also/// `Eq`, but that's not technically required to use this trait./// `Rhs` is *de facto* always `Self`, but the separate parameter is important/// to avoid the `specializing impl repeats parameter` error when consuming this./// - `Self` and `Rhs` have no padding./// - `Self` and `Rhs` have the same layout (size and alignment)./// - Neither `Self` nor `Rhs` have provenance, so integer comparisons are correct./// - `<Self as PartialEq<Rhs>>::{eq,ne}` are equivalent to comparing the bytes.is_bytewise_comparable// SAFETY: All the ordinary integer types have no padding, and are not pointers.// SAFETY: These have *niches*, but no *padding* and no *provenance*,// so we can compare them directly.// SAFETY: Similarly, the `NonZero` type has a niche, but no undef and no pointers,// and they compare like their underlying numeric type.// SAFETY: The `NonZero` type has the "null" optimization guaranteed, and thus// are also safe to equality-compare bitwise inside an `Option`.// The way `PartialOrd` is defined for `Option` means that this wouldn't work// for `<` or `>` on the signed types, but since we only do `==` it's fine.is_bytewise_comparable_array_length// Frustratingly, this can't be made const-generic as it gets//    error: specializing impl repeats parameter `N`// so just do it for a couple of plausibly-common ones.bytewise"cmp_partialeq_eq"/// Tests for `self` and `other` values to be equal, and is used by `==`."cmp_partialeq_ne"/// Tests for `!=`. The default implementation is almost always sufficient,/// and should not be overridden without very good reason."eq"rustc_on_unimplemented"PartialEq"/// Trait for comparisons using the equality operator./// Implementing this trait for types provides the `==` and `!=` operators for/// those types./// `x.eq(y)` can also be written `x == y`, and `x.ne(y)` can be written `x != y`./// We use the easier-to-read infix notation in the remainder of this documentation./// This trait allows for comparisons using the equality operator, for types/// that do not have a full equivalence relation. For example, in floating point/// numbers `NaN != NaN`, so floating point types implement `PartialEq` but not/// [`trait@Eq`]. Formally speaking, when `Rhs == Self`, this trait corresponds/// to a [partial equivalence relation]./// [partial equivalence relation]: https://en.wikipedia.org/wiki/Partial_equivalence_relation/// Implementations must ensure that `eq` and `ne` are consistent with each other:/// - `a != b` if and only if `!(a == b)`./// The default implementation of `ne` provides this consistency and is almost/// always sufficient. It should not be overridden without very good reason./// If [`PartialOrd`] or [`Ord`] are also implemented for `Self` and `Rhs`, their methods must also/// be consistent with `PartialEq` (see the documentation of those traits for the exact/// requirements). It's easy to accidentally make them disagree by deriving some of the traits and/// manually implementing others./// The equality relation `==` must satisfy the following conditions/// (for all `a`, `b`, `c` of type `A`, `B`, `C`):/// - **Symmetry**: if `A: PartialEq<B>` and `B: PartialEq<A>`, then **`a == b`///   implies `b == a`**; and/// - **Transitivity**: if `A: PartialEq<B>` and `B: PartialEq<C>` and `A:///   PartialEq<C>`, then **`a == b` and `b == c` implies `a == c`**.///   This must also work for longer chains, such as when `A: PartialEq<B>`, `B: PartialEq<C>`,///   `C: PartialEq<D>`, and `A: PartialEq<D>` all exist./// Note that the `B: PartialEq<A>` (symmetric) and `A: PartialEq<C>`/// (transitive) impls are not forced to exist, but these requirements apply/// whenever they do exist./// Violating these requirements is a logic error. The behavior resulting from a logic error is not/// undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these/// ## Cross-crate considerations/// Upholding the requirements stated above can become tricky when one crate implements `PartialEq`/// for a type of another crate (i.e., to allow comparing one of its own types with a type from the/// standard library). The recommendation is to never implement this trait for a foreign type. In/// other words, such a crate should do `impl PartialEq<ForeignType> for LocalType`, but it should/// *not* do `impl PartialEq<LocalType> for ForeignType`./// This avoids the problem of transitive chains that criss-cross crate boundaries: for all local/// types `T`, you may assume that no other crate will add `impl`s that allow comparing `T == U`. In/// other words, if other crates add `impl`s that allow building longer transitive chains `U1 == .../// == T == V1 == ...`, then all the types that appear to the right of `T` must be types that the/// crate defining `T` already knows about. This rules out transitive chains where downstream crates/// can add new `impl`s that "stitch together" comparisons of foreign types in ways that violate/// transitivity./// Not having such foreign `impl`s also avoids forward compatibility issues where one crate adding/// more `PartialEq` implementations can cause build failures in downstream crates./// This trait can be used with `#[derive]`. When `derive`d on structs, two/// instances are equal if all fields are equal, and not equal if any fields/// are not equal. When `derive`d on enums, two instances are equal if they/// are the same variant and all fields are equal./// ## How can I implement `PartialEq`?/// An example implementation for a domain in which two books are considered/// the same book if their ISBN matches, even if the formats differ:/// enum BookFormat {///     Paperback,///     Hardback,///     Ebook,/// struct Book {///     isbn: i32,///     format: BookFormat,/// impl PartialEq for Book {///         self.isbn == other.isbn/// let b1 = Book { isbn: 3, format: BookFormat::Paperback };/// let b2 = Book { isbn: 3, format: BookFormat::Ebook };/// let b3 = Book { isbn: 10, format: BookFormat::Paperback };/// assert!(b1 == b2);/// assert!(b1 != b3);/// ## How can I compare two different types?/// The type you can compare with is controlled by `PartialEq`'s type parameter./// For example, let's tweak our previous code a bit:/// // The derive implements <BookFormat> == <BookFormat> comparisons/// // Implement <Book> == <BookFormat> comparisons/// impl PartialEq<BookFormat> for Book {///     fn eq(&self, other: &BookFormat) -> bool {///         self.format == *other/// // Implement <BookFormat> == <Book> comparisons/// impl PartialEq<Book> for BookFormat {///     fn eq(&self, other: &Book) -> bool {///         *self == other.format/// assert!(b1 == BookFormat::Paperback);/// assert!(BookFormat::Ebook != b1);/// By changing `impl PartialEq for Book` to `impl PartialEq<BookFormat> for Book`,/// we allow `BookFormat`s to be compared with `Book`s./// A comparison like the one above, which ignores some fields of the struct,/// can be dangerous. It can easily lead to an unintended violation of the/// requirements for a partial equivalence relation. For example, if we kept/// the above implementation of `PartialEq<Book>` for `BookFormat` and added an/// implementation of `PartialEq<Book>` for `Book` (either via a `#[derive]` or/// via the manual implementation from the first example) then the result would/// violate transitivity:///     let b1 = Book { isbn: 1, format: BookFormat::Paperback };///     let b2 = Book { isbn: 2, format: BookFormat::Paperback };///     assert!(b1 == BookFormat::Paperback);///     assert!(BookFormat::Paperback == b2);///     // The following should hold by transitivity but doesn't.///     assert!(b1 == b2); // <-- PANICS/// let x: u32 = 0;/// let y: u32 = 1;/// assert_eq!(x == y, false);/// assert_eq!(x.eq(&y), false);/// [`eq`]: PartialEq::eq/// [`ne`]: PartialEq::ne/// Derive macro generating an impl of the trait [`PartialEq`]./// The behavior of this macro is described in detail [here](PartialEq#derivable).assert_receiver_is_total_eq// this method is used solely by `impl Eq or #[derive(Eq)]` to assert that every component of a// type implements `Eq` itself. The current deriving infrastructure means doing this assertion// without using a method on this trait is nearly impossible.// This should never be implemented by hand."Eq"/// Trait for comparisons corresponding to [equivalence relations](/// https://en.wikipedia.org/wiki/Equivalence_relation)./// The primary difference to [`PartialEq`] is the additional requirement for reflexivity. A type/// that implements [`PartialEq`] guarantees that for all `a`, `b` and `c`:/// - symmetric: `a == b` implies `b == a` and `a != b` implies `!(a == b)`/// - transitive: `a == b` and `b == c` implies `a == c`/// `Eq`, which builds on top of [`PartialEq`] also implies:/// - reflexive: `a == a`/// This property cannot be checked by the compiler, and therefore `Eq` is a trait without methods./// Floating point types such as [`f32`] and [`f64`] implement only [`PartialEq`] but *not* `Eq`/// because `NaN` != `NaN`./// This trait can be used with `#[derive]`. When `derive`d, because `Eq` has no extra methods, it/// is only informing the compiler that this is an equivalence relation rather than a partial/// equivalence relation. Note that the `derive` strategy requires all fields are `Eq`, which isn't/// always desired./// ## How can I implement `Eq`?/// If you cannot use the `derive` strategy, specify that your type implements `Eq`, which has no/// extra methods:/// impl Eq for Book {}/// Derive macro generating an impl of the trait [`Eq`].AssertParamIsEq// FIXME: this struct is used solely by #[derive] to// assert that every component of a type implements Eq.// This struct should never appear in user code."Ordering"/// An ordering where a compared value is less than another./// An ordering where a compared value is equal to another./// An ordering where a compared value is greater than another./// An `Ordering` is the result of a comparison between two values./// assert_eq!(1.cmp(&2), Ordering::Less);/// assert_eq!(1.cmp(&1), Ordering::Equal);/// assert_eq!(2.cmp(&1), Ordering::Greater);// This is a lang item only so that `BinOp::Cmp` in MIR can return it.// It has no special behavior, but does require that the three variants// `Less`/`Equal`/`Greater` remain `-1_i8`/`0_i8`/`+1_i8` respectively./// Returns `true` if the ordering is the `Equal` variant./// assert_eq!(Ordering::Less.is_eq(), false);/// assert_eq!(Ordering::Equal.is_eq(), true);/// assert_eq!(Ordering::Greater.is_eq(), false);/// Returns `true` if the ordering is not the `Equal` variant./// assert_eq!(Ordering::Less.is_ne(), true);/// assert_eq!(Ordering::Equal.is_ne(), false);/// assert_eq!(Ordering::Greater.is_ne(), true);is_lt/// Returns `true` if the ordering is the `Less` variant./// assert_eq!(Ordering::Less.is_lt(), true);/// assert_eq!(Ordering::Equal.is_lt(), false);/// assert_eq!(Ordering::Greater.is_lt(), false);is_gt/// Returns `true` if the ordering is the `Greater` variant./// assert_eq!(Ordering::Less.is_gt(), false);/// assert_eq!(Ordering::Equal.is_gt(), false);/// assert_eq!(Ordering::Greater.is_gt(), true);/// Returns `true` if the ordering is either the `Less` or `Equal` variant./// assert_eq!(Ordering::Less.is_le(), true);/// assert_eq!(Ordering::Equal.is_le(), true);/// assert_eq!(Ordering::Greater.is_le(), false);is_ge/// Returns `true` if the ordering is either the `Greater` or `Equal` variant./// assert_eq!(Ordering::Less.is_ge(), false);/// assert_eq!(Ordering::Equal.is_ge(), true);/// assert_eq!(Ordering::Greater.is_ge(), true);/// Reverses the `Ordering`./// * `Less` becomes `Greater`./// * `Greater` becomes `Less`./// * `Equal` becomes `Equal`./// Basic behavior:/// assert_eq!(Ordering::Less.reverse(), Ordering::Greater);/// assert_eq!(Ordering::Equal.reverse(), Ordering::Equal);/// assert_eq!(Ordering::Greater.reverse(), Ordering::Less);/// This method can be used to reverse a comparison:/// let data: &mut [_] = &mut [2, 10, 5, 8];/// // sort the array from largest to smallest./// data.sort_by(|a, b| a.cmp(b).reverse());/// let b: &mut [_] = &mut [10, 8, 5, 2];/// assert!(data == b);/// Chains two orderings./// Returns `self` when it's not `Equal`. Otherwise returns `other`./// let result = Ordering::Equal.then(Ordering::Less);/// assert_eq!(result, Ordering::Less);/// let result = Ordering::Less.then(Ordering::Equal);/// let result = Ordering::Less.then(Ordering::Greater);/// let result = Ordering::Equal.then(Ordering::Equal);/// assert_eq!(result, Ordering::Equal);/// let x: (i64, i64, i64) = (1, 2, 7);/// let y: (i64, i64, i64) = (1, 5, 3);/// let result = x.0.cmp(&y.0).then(x.1.cmp(&y.1)).then(x.2.cmp(&y.2));then_with/// Chains the ordering with the given function./// Returns `self` when it's not `Equal`. Otherwise calls `f` and returns/// let result = Ordering::Equal.then_with(|| Ordering::Less);/// let result = Ordering::Less.then_with(|| Ordering::Equal);/// let result = Ordering::Less.then_with(|| Ordering::Greater);/// let result = Ordering::Equal.then_with(|| Ordering::Equal);/// let result = x.0.cmp(&y.0).then_with(|| x.1.cmp(&y.1)).then_with(|| x.2.cmp(&y.2));/// A helper struct for reverse ordering./// This struct is a helper to be used with functions like [`Vec::sort_by_key`] and/// can be used to reverse order a part of a key./// [`Vec::sort_by_key`]: ../../std/vec/struct.Vec.html#method.sort_by_key/// let mut v = vec![1, 2, 3, 4, 5, 6];/// v.sort_by_key(|&num| (num > 3, Reverse(num)));/// assert_eq!(v, vec![3, 2, 1, 6, 5, 4]);"ord_cmp_method"/// This method returns an [`Ordering`] between `self` and `other`./// By convention, `self.cmp(&other)` returns the ordering matching the expression/// `self <operator> other` if true./// assert_eq!(5.cmp(&10), Ordering::Less);/// assert_eq!(10.cmp(&5), Ordering::Greater);/// assert_eq!(5.cmp(&5), Ordering::Equal);"cmp_ord_max"/// Compares and returns the maximum of two values./// Returns the second argument if the comparison determines them to be equal./// assert_eq!(1.max(2), 2);/// assert_eq!(2.max(2), 2);/// #[derive(Eq)]/// struct Equal(&'static str);/// impl PartialEq for Equal {///     fn eq(&self, other: &Self) -> bool { true }/// impl PartialOrd for Equal {///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(Ordering::Equal) }/// impl Ord for Equal {///     fn cmp(&self, other: &Self) -> Ordering { Ordering::Equal }/// assert_eq!(Equal("self").max(Equal("other")).0, "other");"cmp_ord_min"/// Compares and returns the minimum of two values./// Returns the first argument if the comparison determines them to be equal./// assert_eq!(1.min(2), 1);/// assert_eq!(2.min(2), 2);/// assert_eq!(Equal("self").min(Equal("other")).0, "self");/// Restrict a value to a certain interval./// Returns `max` if `self` is greater than `max`, and `min` if `self` is/// less than `min`. Otherwise this returns `self`./// Panics if `min > max`./// assert_eq!((-3).clamp(-2, 1), -2);/// assert_eq!(0.clamp(-2, 1), 0);/// assert_eq!(2.clamp(-2, 1), 1);"Ord"/// Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order)./// Implementations must be consistent with the [`PartialOrd`] implementation, and ensure `max`,/// `min`, and `clamp` are consistent with `cmp`:/// - `partial_cmp(a, b) == Some(cmp(a, b))`./// - `max(a, b) == max_by(a, b, cmp)` (ensured by the default implementation)./// - `min(a, b) == min_by(a, b, cmp)` (ensured by the default implementation)./// - For `a.clamp(min, max)`, see the [method docs](#method.clamp) (ensured by the default///   implementation)./// ## Corollaries/// From the above and the requirements of `PartialOrd`, it follows that for all `a`, `b` and `c`:/// - exactly one of `a < b`, `a == b` or `a > b` is true; and/// - `<` is transitive: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and///   `>`./// Mathematically speaking, the `<` operator defines a strict [weak order]. In cases where `==`/// conforms to mathematical equality, it also defines a strict [total order]./// [weak order]: https://en.wikipedia.org/wiki/Weak_ordering/// This trait can be used with `#[derive]`./// When `derive`d on structs, it will produce a/// [lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering based on the/// top-to-bottom declaration order of the struct's members./// When `derive`d on enums, variants are ordered primarily by their discriminants. Secondarily,/// they are ordered by their fields. By default, the discriminant is smallest for variants at the/// top, and largest for variants at the bottom. Here's an example:/// #[derive(PartialEq, Eq, PartialOrd, Ord)]///     Top,///     Bottom,/// assert!(E::Top < E::Bottom);/// However, manually setting the discriminants can override this default behavior:///     Top = 2,///     Bottom = 1,/// assert!(E::Bottom < E::Top);/// ## Lexicographical comparison/// Lexicographical comparison is an operation with the following properties:///  - Two sequences are compared element by element.///  - The first mismatching element defines which sequence is lexicographically less or greater///    than the other.///  - If one sequence is a prefix of another, the shorter sequence is lexicographically less than///    the other.///  - If two sequences have equivalent elements and are of the same length, then the sequences are///    lexicographically equal.///  - An empty sequence is lexicographically less than any non-empty sequence.///  - Two empty sequences are lexicographically equal./// ## How can I implement `Ord`?/// `Ord` requires that the type also be [`PartialOrd`], [`PartialEq`], and [`Eq`]./// Because `Ord` implies a stronger ordering relationship than [`PartialOrd`], and both `Ord` and/// [`PartialOrd`] must agree, you must choose how to implement `Ord` **first**. You can choose to/// derive it, or implement it manually. If you derive it, you should derive all four traits. If you/// implement it manually, you should manually implement all four traits, based on the/// implementation of `Ord`./// Here's an example where you want to define the `Character` comparison by `health` and/// `experience` only, disregarding the field `mana`:/// struct Character {///     health: u32,///     experience: u32,///     mana: f32,/// impl Ord for Character {///     fn cmp(&self, other: &Self) -> Ordering {///         self.experience///             .cmp(&other.experience)///             .then(self.health.cmp(&other.health))/// impl PartialOrd for Character {///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {///         Some(self.cmp(other))/// impl PartialEq for Character {///         self.health == other.health && self.experience == other.experience/// impl Eq for Character {}/// If all you need is to `slice::sort` a type by a field value, it can be simpler to use/// `slice::sort_by_key`./// ## Examples of incorrect `Ord` implementations///     health: f32,///     fn cmp(&self, other: &Self) -> std::cmp::Ordering {///         if self.health < other.health {///             Ordering::Less///         } else if self.health > other.health {///             Ordering::Greater///             Ordering::Equal///         self.health == other.health/// let a = Character { health: 4.5 };/// let b = Character { health: f32::NAN };/// // Mistake: floating-point values do not form a total order and using the built-in comparison/// // operands to implement `Ord` irregardless of that reality does not change it. Use/// // `f32::total_cmp` if you need a total order for floating-point values./// // Reflexivity requirement of `Ord` is not given./// assert!(a == a);/// assert!(b != b);/// // Antisymmetry requirement of `Ord` is not given. Only one of a < c and c < a is allowed to be/// // true, not both or neither./// assert_eq!((a < b) as u8 + (b < a) as u8, 0);///         if self.health < 50 {///             self.health.cmp(&other.health)///             self.experience.cmp(&other.experience)/// // For performance reasons implementing `PartialEq` this way is not the idiomatic way, but it/// // ensures consistent behavior between `PartialEq`, `PartialOrd` and `Ord` in this example.///         self.cmp(other) == Ordering::Equal/// let a = Character {///     health: 3,///     experience: 5,/// let b = Character {///     health: 10,///     experience: 77,/// let c = Character {///     health: 143,///     experience: 2,/// // Mistake: The implementation of `Ord` compares different fields depending on the value of/// // `self.health`, the resulting order is not total./// // Transitivity requirement of `Ord` is not given. If a is smaller than b and b is smaller than/// // c, by transitive property a must also be smaller than c./// assert!(a < b && b < c && c < a);/// assert_eq!((a < c) as u8 + (c < a) as u8, 2);/// The documentation of [`PartialOrd`] contains further examples, for example it's wrong for/// [`PartialOrd`] and [`PartialEq`] to disagree./// [`cmp`]: Ord::cmp/// Derive macro generating an impl of the trait [`Ord`]./// The behavior of this macro is described in detail [here](Ord#derivable)."cmp_partialord_cmp"/// This method returns an ordering between `self` and `other` values if one exists./// let result = 1.0.partial_cmp(&2.0);/// assert_eq!(result, Some(Ordering::Less));/// let result = 1.0.partial_cmp(&1.0);/// assert_eq!(result, Some(Ordering::Equal));/// let result = 2.0.partial_cmp(&1.0);/// assert_eq!(result, Some(Ordering::Greater));/// When comparison is impossible:/// let result = f64::NAN.partial_cmp(&1.0);/// assert_eq!(result, None);"cmp_partialord_lt"/// Tests less than (for `self` and `other`) and is used by the `<` operator./// assert_eq!(1.0 < 1.0, false);/// assert_eq!(1.0 < 2.0, true);/// assert_eq!(2.0 < 1.0, false);"cmp_partialord_le"/// Tests less than or equal to (for `self` and `other`) and is used by the/// `<=` operator./// assert_eq!(1.0 <= 1.0, true);/// assert_eq!(1.0 <= 2.0, true);/// assert_eq!(2.0 <= 1.0, false);"cmp_partialord_gt"/// Tests greater than (for `self` and `other`) and is used by the `>`/// assert_eq!(1.0 > 1.0, false);/// assert_eq!(1.0 > 2.0, false);/// assert_eq!(2.0 > 1.0, true);"cmp_partialord_ge"/// Tests greater than or equal to (for `self` and `other`) and is used by/// the `>=` operator./// assert_eq!(1.0 >= 1.0, true);/// assert_eq!(1.0 >= 2.0, false);/// assert_eq!(2.0 >= 1.0, true);__chaining_lt/// If `self == other`, returns `ControlFlow::Continue(())`./// Otherwise, returns `ControlFlow::Break(self < other)`./// This is useful for chaining together calls when implementing a lexical/// `PartialOrd::lt`, as it allows types (like primitives) which can cheaply/// check `==` and `<` separately to do rather than needing to calculate/// (then optimize out) the three-way `Ordering` result.// Added to improve the behaviour of tuples; not necessarily stabilization-track.__chaining_le/// Same as `__chaining_lt`, but for `<=` instead of `<`.__chaining_gt/// Same as `__chaining_lt`, but for `>` instead of `<`.__chaining_ge/// Same as `__chaining_lt`, but for `>=` instead of `<`."partial_ord""PartialOrd"/// Trait for types that form a [partial order](https://en.wikipedia.org/wiki/Partial_order)./// The `lt`, `le`, `gt`, and `ge` methods of this trait can be called using the `<`, `<=`, `>`, and/// `>=` operators, respectively./// This trait should **only** contain the comparison logic for a type **if one plans on only/// implementing `PartialOrd` but not [`Ord`]**. Otherwise the comparison logic should be in [`Ord`]/// and this trait implemented with `Some(self.cmp(other))`./// The methods of this trait must be consistent with each other and with those of [`PartialEq`]./// The following conditions must hold:/// 1. `a == b` if and only if `partial_cmp(a, b) == Some(Equal)`./// 2. `a < b` if and only if `partial_cmp(a, b) == Some(Less)`/// 3. `a > b` if and only if `partial_cmp(a, b) == Some(Greater)`/// 4. `a <= b` if and only if `a < b || a == b`/// 5. `a >= b` if and only if `a > b || a == b`/// 6. `a != b` if and only if `!(a == b)`./// Conditions 2–5 above are ensured by the default implementation. Condition 6 is already ensured/// by [`PartialEq`]./// If [`Ord`] is also implemented for `Self` and `Rhs`, it must also be consistent with/// `partial_cmp` (see the documentation of that trait for the exact requirements). It's easy to/// accidentally make them disagree by deriving some of the traits and manually implementing others./// The comparison relations must satisfy the following conditions (for all `a`, `b`, `c` of type/// `A`, `B`, `C`):/// - **Transitivity**: if `A: PartialOrd<B>` and `B: PartialOrd<C>` and `A: PartialOrd<C>`, then `a///   < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`. This must also///   work for longer chains, such as when `A: PartialOrd<B>`, `B: PartialOrd<C>`, `C:///   PartialOrd<D>`, and `A: PartialOrd<D>` all exist./// - **Duality**: if `A: PartialOrd<B>` and `B: PartialOrd<A>`, then `a < b` if and only if `b >///   a`./// Note that the `B: PartialOrd<A>` (dual) and `A: PartialOrd<C>` (transitive) impls are not forced/// to exist, but these requirements apply whenever they do exist./// Upholding the requirements stated above can become tricky when one crate implements `PartialOrd`/// other words, such a crate should do `impl PartialOrd<ForeignType> for LocalType`, but it should/// *not* do `impl PartialOrd<LocalType> for ForeignType`./// types `T`, you may assume that no other crate will add `impl`s that allow comparing `T < U`. In/// other words, if other crates add `impl`s that allow building longer transitive chains `U1 < .../// < T < V1 < ...`, then all the types that appear to the right of `T` must be types that the crate/// defining `T` already knows about. This rules out transitive chains where downstream crates can/// add new `impl`s that "stitch together" comparisons of foreign types in ways that violate/// more `PartialOrd` implementations can cause build failures in downstream crates./// The following corollaries follow from the above requirements:/// - irreflexivity of `<` and `>`: `!(a < a)`, `!(a > a)`/// - transitivity of `>`: if `a > b` and `b > c` then `a > c`/// - duality of `partial_cmp`: `partial_cmp(a, b) == partial_cmp(b, a).map(Ordering::reverse)`/// ## Strict and non-strict partial orders/// The `<` and `>` operators behave according to a *strict* partial order. However, `<=` and `>=`/// do **not** behave according to a *non-strict* partial order. That is because mathematically, a/// non-strict partial order would require reflexivity, i.e. `a <= a` would need to be true for/// every `a`. This isn't always the case for types that implement `PartialOrd`, for example:/// let a = f64::sqrt(-1.0);/// assert_eq!(a <= a, false);/// When `derive`d on enums, variants are primarily ordered by their discriminants. Secondarily,/// #[derive(PartialEq, PartialOrd)]/// ## How can I implement `PartialOrd`?/// `PartialOrd` only requires implementation of the [`partial_cmp`] method, with the others/// generated from default implementations./// However it remains possible to implement the others separately for types which do not have a/// total order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 == false`/// (cf. IEEE 754-2008 section 5.11)./// `PartialOrd` requires your type to be [`PartialEq`]./// If your type is [`Ord`], you can implement [`partial_cmp`] by using [`cmp`]:///     height: u32,/// impl PartialOrd for Person {/// impl Ord for Person {///         self.height.cmp(&other.height)/// impl PartialEq for Person {///         self.height == other.height/// impl Eq for Person {}/// You may also find it useful to use [`partial_cmp`] on your type's fields. Here is an example of/// `Person` types who have a floating-point `height` field that is the only field to be used for/// sorting:///     height: f64,///         self.height.partial_cmp(&other.height)/// ## Examples of incorrect `PartialOrd` implementations///         Some(self.health.cmp(&other.health))/// // Mistake: `PartialEq` and `PartialOrd` disagree with each other./// assert_eq!(a.partial_cmp(&b).unwrap(), Ordering::Equal); // a == b according to `PartialOrd`./// assert_ne!(a, b); // a != b according to `PartialEq`./// assert_eq!(x < y, true);/// assert_eq!(x.lt(&y), true);/// [`partial_cmp`]: PartialOrd::partial_cmp// FIXME(sized_hierarchy): remove thisdefault_chaining_impl/// Derive macro generating an impl of the trait [`PartialOrd`]./// The behavior of this macro is described in detail [here](PartialOrd#derivable)."cmp_min"/// Internally uses an alias to [`Ord::min`]./// assert_eq!(cmp::min(1, 2), 1);/// assert_eq!(cmp::min(2, 2), 2);/// use std::cmp::{self, Ordering};/// assert_eq!(cmp::min(Equal("v1"), Equal("v2")).0, "v1");/// Returns the minimum of two values with respect to the specified comparison function./// The parameter order is preserved when calling the `compare` function, i.e. `v1` is/// always passed as the first argument and `v2` as the second./// let abs_cmp = |x: &i32, y: &i32| x.abs().cmp(&y.abs());/// let result = cmp::min_by(2, -1, abs_cmp);/// assert_eq!(result, -1);/// let result = cmp::min_by(2, -3, abs_cmp);/// assert_eq!(result, 2);/// let result = cmp::min_by(1, -1, abs_cmp);/// assert_eq!(result, 1);/// Returns the element that gives the minimum value from the specified function./// let result = cmp::min_by_key(2, -1, |x: &i32| x.abs());/// let result = cmp::min_by_key(2, -3, |x: &i32| x.abs());/// let result = cmp::min_by_key(1, -1, |x: &i32| x.abs());"cmp_max"/// Internally uses an alias to [`Ord::max`]./// assert_eq!(cmp::max(1, 2), 2);/// assert_eq!(cmp::max(2, 2), 2);/// assert_eq!(cmp::max(Equal("v1"), Equal("v2")).0, "v2");/// Returns the maximum of two values with respect to the specified comparison function./// let result = cmp::max_by(3, -2, abs_cmp) ;/// assert_eq!(result, 3);/// let result = cmp::max_by(1, -2, abs_cmp);/// assert_eq!(result, -2);/// let result = cmp::max_by(1, -1, abs_cmp);/// Returns the element that gives the maximum value from the specified function./// let result = cmp::max_by_key(3, -2, |x: &i32| x.abs());/// let result = cmp::max_by_key(1, -2, |x: &i32| x.abs());/// let result = cmp::max_by_key(1, -1, |x: &i32| x.abs());/// Compares and sorts two values, returning minimum and maximum./// Returns `[v1, v2]` if the comparison determines them to be equal./// #![feature(cmp_minmax)]/// assert_eq!(cmp::minmax(1, 2), [1, 2]);/// assert_eq!(cmp::minmax(2, 1), [1, 2]);/// // You can destructure the result using array patterns/// let [min, max] = cmp::minmax(42, 17);/// assert_eq!(min, 17);/// assert_eq!(max, 42);/// assert_eq!(cmp::minmax(Equal("v1"), Equal("v2")).map(|v| v.0), ["v1", "v2"]);/// Returns minimum and maximum values with respect to the specified comparison function./// assert_eq!(cmp::minmax_by(-2, 1, abs_cmp), [1, -2]);/// assert_eq!(cmp::minmax_by(-1, 2, abs_cmp), [-1, 2]);/// assert_eq!(cmp::minmax_by(-2, 2, abs_cmp), [-2, 2]);/// let [min, max] = cmp::minmax_by(-42, 17, abs_cmp);/// assert_eq!(max, -42);/// Returns minimum and maximum values with respect to the specified key function./// assert_eq!(cmp::minmax_by_key(-2, 1, |x: &i32| x.abs()), [1, -2]);/// assert_eq!(cmp::minmax_by_key(-2, 2, |x: &i32| x.abs()), [-2, 2]);/// let [min, max] = cmp::minmax_by_key(-42, 17, |x: &i32| x.abs());partial_eq_impleq_implpartial_ord_methods_primitive_implpartial_ord_implord_impl// & pointers// &mut pointers// Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types//! Utilities for comparing and ordering values.//! This module contains various tools for comparing and ordering values. In//! summary://! * [`PartialEq<Rhs>`] overloads the `==` and `!=` operators. In cases where//!   `Rhs` (the right hand side's type) is `Self`, this trait corresponds to a//!   partial equivalence relation.//! * [`Eq`] indicates that the overloaded `==` operator corresponds to an//!   equivalence relation.//! * [`Ord`] and [`PartialOrd`] are traits that allow you to define total and//!   partial orderings between values, respectively. Implementing them overloads//!   the `<`, `<=`, `>`, and `>=` operators.//! * [`Ordering`] is an enum returned by the main functions of [`Ord`] and//!   [`PartialOrd`], and describes an ordering of two values (less, equal, or//!   greater).//! * [`Reverse`] is a struct that allows you to easily reverse an ordering.//! * [`max`] and [`min`] are functions that build off of [`Ord`] and allow you//!   to find the maximum or minimum of two values.//! For more details, see the respective documentation of each item in the list.//! [`max`]: Ord::max//! [`min`]: Ord::mincontracts_ensuresensurescontracts_requires/* compiler-team#759 */"contract_build_check_ensures"build_check_ensures/// This is an identity function used as part of the desugaring of the `#[ensures]` attribute./// This is an existing hack to allow users to omit the type of the return value in their ensures/// Ideally, rustc should be able to generate the type annotation./// The existing lowering logic makes it rather hard to add the explicit type annotation,/// while the function call is fairly straight forward.// Similar to `contract_check_requires`, we need to use the user-facing// `contracts` feature rather than the perma-unstable `contracts_internals`.// Const-checking doesn't honor allow_internal_unstable logic used by contract expansion.//! Unstable module containing the unstable contracts lang items and attribute macros.FloatToInt"convert_identity"/// The identity function./// Two things are important to note about this function:/// - It is not always equivalent to a closure like `|x| x`, since the///   closure may coerce `x` into a different type./// - It moves the input `x` passed to the function./// While it might seem strange to have a function that just returns back the/// input, there are some interesting uses./// Using `identity` to do nothing in a sequence of other, interesting,/// functions:/// use std::convert::identity;/// fn manipulation(x: u32) -> u32 {///     // Let's pretend that adding one is an interesting function.///     x + 1/// let _arr = &[identity, manipulation];/// Using `identity` as a "do nothing" base case in a conditional:/// # fn manipulation(x: u32) -> u32 { x + 1 }/// let do_stuff = if condition { manipulation } else { identity };/// // Do more interesting stuff.../// let _results = do_stuff(42);/// Using `identity` to keep the `Some` variants of an iterator of `Option<T>`:/// let iter = [Some(1), None, Some(3)].into_iter();/// let filtered = iter.filter_map(identity).collect::<Vec<_>>();/// assert_eq!(vec![1, 3], filtered);/// Converts this type into a shared reference of the (usually inferred) input type."AsRef"/// Used to do a cheap reference-to-reference conversion./// This trait is similar to [`AsMut`] which is used for converting between mutable references./// If you need to do a costly conversion it is better to implement [`From`] with type/// `&T` or write a custom function./// # Relation to `Borrow`/// `AsRef` has the same signature as [`Borrow`], but [`Borrow`] is different in a few aspects:/// - Unlike `AsRef`, [`Borrow`] has a blanket impl for any `T`, and can be used to accept either///   a reference or a value. (See also note on `AsRef`'s reflexibility below.)/// - [`Borrow`] also requires that [`Hash`], [`Eq`] and [`Ord`] for a borrowed value are///   equivalent to those of the owned value. For this reason, if you want to///   borrow only a single field of a struct you can implement `AsRef`, but not [`Borrow`]./// **Note: This trait must not fail**. If the conversion can fail, use a/// dedicated method which returns an [`Option<T>`] or a [`Result<T, E>`]./// # Generic Implementations/// `AsRef` auto-dereferences if the inner type is a reference or a mutable reference/// (e.g.: `foo.as_ref()` will work the same if `foo` has type `&mut Foo` or `&&mut Foo`)./// Note that due to historic reasons, the above currently does not hold generally for all/// [dereferenceable types], e.g. `foo.as_ref()` will *not* work the same as/// `Box::new(foo).as_ref()`. Instead, many smart pointers provide an `as_ref` implementation which/// simply returns a reference to the [pointed-to value] (but do not perform a cheap/// reference-to-reference conversion for that value). However, [`AsRef::as_ref`] should not be/// used for the sole purpose of dereferencing; instead ['`Deref` coercion'] can be used:/// [dereferenceable types]: core::ops::Deref/// [pointed-to value]: core::ops::Deref::Target/// ['`Deref` coercion']: core::ops::Deref#deref-coercion/// let x = Box::new(5i32);/// // Avoid this:/// // let y: &i32 = x.as_ref();/// // Better just write:/// let y: &i32 = &x;/// Types which implement [`Deref`] should consider implementing `AsRef<T>` as follows:/// [`Deref`]: core::ops::Deref/// # use core::ops::Deref;/// # struct SomeType;/// # impl Deref for SomeType {/// #     type Target = [u8];/// #     fn deref(&self) -> &[u8] {/// #         &[]/// impl<T> AsRef<T> for SomeType///     T: ?Sized,///     <SomeType as Deref>::Target: AsRef<T>,///     fn as_ref(&self) -> &T {///         self.deref().as_ref()/// # Reflexivity/// Ideally, `AsRef` would be reflexive, i.e. there would be an `impl<T: ?Sized> AsRef<T> for T`/// with [`as_ref`] simply returning its argument unchanged./// Such a blanket implementation is currently *not* provided due to technical restrictions of/// Rust's type system (it would be overlapping with another existing blanket implementation for/// `&T where T: AsRef<U>` which allows `AsRef` to auto-dereference, see "Generic Implementations"/// [`as_ref`]: AsRef::as_ref/// A trivial implementation of `AsRef<T> for T` must be added explicitly for a particular type `T`/// where needed or desired. Note, however, that not all types from `std` contain such an/// implementation, and those cannot be added by external code due to orphan rules./// By using trait bounds we can accept arguments of different types as long as they can be/// converted to the specified type `T`./// For example: By creating a generic function that takes an `AsRef<str>` we express that we/// want to accept all references that can be converted to [`&str`] as an argument./// Since both [`String`] and [`&str`] implement `AsRef<str>` we can accept both as input argument./// [`&str`]: primitive@str/// [`Borrow`]: crate::borrow::Borrow/// [`Eq`]: crate::cmp::Eq/// [`Ord`]: crate::cmp::Ord/// fn is_hello<T: AsRef<str>>(s: T) {///    assert_eq!("hello", s.as_ref());/// is_hello(s);/// let s = "hello".to_string();/// Converts this type into a mutable reference of the (usually inferred) input type."AsMut"/// Used to do a cheap mutable-to-mutable reference conversion./// This trait is similar to [`AsRef`] but used for converting between mutable/// references. If you need to do a costly conversion it is better to/// implement [`From`] with type `&mut T` or write a custom function./// `AsMut` auto-dereferences if the inner type is a mutable reference/// (e.g.: `foo.as_mut()` will work the same if `foo` has type `&mut Foo` or `&mut &mut Foo`)./// [mutably dereferenceable types], e.g. `foo.as_mut()` will *not* work the same as/// `Box::new(foo).as_mut()`. Instead, many smart pointers provide an `as_mut` implementation which/// reference-to-reference conversion for that value). However, [`AsMut::as_mut`] should not be/// used for the sole purpose of mutable dereferencing; instead ['`Deref` coercion'] can be used:/// [mutably dereferenceable types]: core::ops::DerefMut/// ['`Deref` coercion']: core::ops::DerefMut#mutable-deref-coercion/// let mut x = Box::new(5i32);/// // let y: &mut i32 = x.as_mut();/// let y: &mut i32 = &mut x;/// Types which implement [`DerefMut`] should consider to add an implementation of `AsMut<T>` as/// [`DerefMut`]: core::ops::DerefMut/// # use core::ops::{Deref, DerefMut};/// # impl DerefMut for SomeType {/// #     fn deref_mut(&mut self) -> &mut [u8] {/// #         &mut []/// impl<T> AsMut<T> for SomeType///     <SomeType as Deref>::Target: AsMut<T>,///     fn as_mut(&mut self) -> &mut T {///         self.deref_mut().as_mut()/// Ideally, `AsMut` would be reflexive, i.e. there would be an `impl<T: ?Sized> AsMut<T> for T`/// with [`as_mut`] simply returning its argument unchanged./// `&mut T where T: AsMut<U>` which allows `AsMut` to auto-dereference, see "Generic/// Implementations" above)./// [`as_mut`]: AsMut::as_mut/// A trivial implementation of `AsMut<T> for T` must be added explicitly for a particular type `T`/// Using `AsMut` as trait bound for a generic function, we can accept all mutable references that/// can be converted to type `&mut T`. Unlike [dereference], which has a single [target type],/// there can be multiple implementations of `AsMut` for a type. In particular, `Vec<T>` implements/// both `AsMut<Vec<T>>` and `AsMut<[T]>`./// In the following, the example functions `caesar` and `null_terminate` provide a generic/// interface which work with any type that can be converted by cheap mutable-to-mutable conversion/// into a byte slice (`[u8]`) or byte vector (`Vec<u8>`), respectively./// [dereference]: core::ops::DerefMut/// [target type]: core::ops::Deref::Target/// struct Document {///     info: String,///     content: Vec<u8>,/// impl<T: ?Sized> AsMut<T> for Document///     Vec<u8>: AsMut<T>,///         self.content.as_mut()/// fn caesar<T: AsMut<[u8]>>(data: &mut T, key: u8) {///     for byte in data.as_mut() {///         *byte = byte.wrapping_add(key);/// fn null_terminate<T: AsMut<Vec<u8>>>(data: &mut T) {///     // Using a non-generic inner function, which contains most of the///     // functionality, helps to minimize monomorphization overhead.///     fn doit(data: &mut Vec<u8>) {///         let len = data.len();///         if len == 0 || data[len-1] != 0 {///             data.push(0);///     doit(data.as_mut());///     let mut v: Vec<u8> = vec![1, 2, 3];///     caesar(&mut v, 5);///     assert_eq!(v, [6, 7, 8]);///     null_terminate(&mut v);///     assert_eq!(v, [6, 7, 8, 0]);///     let mut doc = Document {///         info: String::from("Example"),///         content: vec![17, 19, 8],///     caesar(&mut doc, 1);///     assert_eq!(doc.content, [18, 20, 9]);///     null_terminate(&mut doc);///     assert_eq!(doc.content, [18, 20, 9, 0]);/// Note, however, that APIs don't need to be generic. In many cases taking a `&mut [u8]` or/// `&mut Vec<u8>`, for example, is the better choice (callers need to pass the correct type then)./// Converts this type into the (usually inferred) input type."Into"/// A value-to-value conversion that consumes the input value. The/// opposite of [`From`]./// One should avoid implementing [`Into`] and implement [`From`] instead./// Implementing [`From`] automatically provides one with an implementation of [`Into`]/// thanks to the blanket implementation in the standard library./// Prefer using [`Into`] over [`From`] when specifying trait bounds on a generic function/// to ensure that types that only implement [`Into`] can be used as well./// **Note: This trait must not fail**. If the conversion can fail, use [`TryInto`]./// - [`From`]`<T> for U` implies `Into<U> for T`/// - [`Into`] is reflexive, which means that `Into<T> for T` is implemented/// # Implementing [`Into`] for conversions to external types in old versions of Rust/// Prior to Rust 1.41, if the destination type was not part of the current crate/// then you couldn't implement [`From`] directly./// For example, take this code:/// # #![allow(non_local_definitions)]/// struct Wrapper<T>(Vec<T>);/// impl<T> From<Wrapper<T>> for Vec<T> {///     fn from(w: Wrapper<T>) -> Vec<T> {///         w.0/// This will fail to compile in older versions of the language because Rust's orphaning rules/// used to be a little bit more strict. To bypass this, you could implement [`Into`] directly:/// impl<T> Into<Vec<T>> for Wrapper<T> {///     fn into(self) -> Vec<T> {/// It is important to understand that [`Into`] does not provide a [`From`] implementation/// (as [`From`] does with [`Into`]). Therefore, you should always try to implement [`From`]/// and then fall back to [`Into`] if [`From`] can't be implemented./// [`String`] implements [`Into`]`<`[`Vec`]`<`[`u8`]`>>`:/// In order to express that we want a generic function to take all arguments that can be/// converted to a specified type `T`, we can use a trait bound of [`Into`]`<T>`./// For example: The function `is_hello` takes all arguments that can be converted into a/// [`Vec`]`<`[`u8`]`>`./// fn is_hello<T: Into<Vec<u8>>>(s: T) {///    let bytes = b"hello".to_vec();///    assert_eq!(bytes, s.into());/// [`Vec`]: ../../std/vec/struct.Vec.html"from_fn"/// Converts to this type from the input type."From"/// Used to do value-to-value conversions while consuming the input value. It is the reciprocal of/// [`Into`]./// One should always prefer implementing `From` over [`Into`]/// because implementing `From` automatically provides one with an implementation of [`Into`]/// Only implement [`Into`] when targeting a version prior to Rust 1.41 and converting to a type/// outside the current crate./// `From` was not able to do these types of conversions in earlier versions because of Rust's/// orphaning rules./// See [`Into`] for more details./// The `From` trait is also very useful when performing error handling. When constructing a function/// that is capable of failing, the return type will generally be of the form `Result<T, E>`./// `From` simplifies error handling by allowing a function to return a single error type/// that encapsulates multiple error types. See the "Examples" section and [the book][book] for more/// **Note: This trait must not fail**. The `From` trait is intended for perfect conversions./// If the conversion can fail or is not perfect, use [`TryFrom`]./// - `From<T> for U` implies [`Into`]`<U> for T`/// - `From` is reflexive, which means that `From<T> for T` is implemented/// # When to implement `From`/// While there's no technical restrictions on which conversions can be done using/// a `From` implementation, the general expectation is that the conversions/// should typically be restricted as follows:/// * The conversion is *infallible*: if the conversion can fail, use [`TryFrom`]///   instead; don't provide a `From` impl that panics./// * The conversion is *lossless*: semantically, it should not lose or discard///   information. For example, `i32: From<u16>` exists, where the original///   value can be recovered using `u16: TryFrom<i32>`.  And `String: From<&str>`///   exists, where you can get something equivalent to the original value via///   `Deref`.  But `From` cannot be used to convert from `u32` to `u16`, since///   that cannot succeed in a lossless way.  (There's some wiggle room here for///   information not considered semantically relevant.  For example,///   `Box<[T]>: From<Vec<T>>` exists even though it might not preserve capacity,///   like how two vectors can be equal despite differing capacities.)/// * The conversion is *value-preserving*: the conceptual kind and meaning of///   the resulting value is the same, even though the Rust type and technical///   representation might be different.  For example `-1_i8 as u8` is *lossless*,///   since `as` casting back can recover the original value, but that conversion///   is *not* available via `From` because `-1` and `255` are different conceptual///   values (despite being identical bit patterns technically).  But///   `f32: From<i16>` *is* available because `1_i16` and `1.0_f32` are conceptually///   the same real number (despite having very different bit patterns technically).///   `String: From<char>` is available because they're both *text*, but///   `String: From<u32>` is *not* available, since `1` (a number) and `"1"`///   (text) are too different.  (Converting values to text is instead covered///   by the [`Display`](crate::fmt::Display) trait.)/// * The conversion is *obvious*: it's the only reasonable conversion between///   the two types.  Otherwise it's better to have it be a named method or///   constructor, like how [`str::as_bytes`] is a method and how integers have///   methods like [`u32::from_ne_bytes`], [`u32::from_le_bytes`], and///   [`u32::from_be_bytes`], none of which are `From` implementations.  Whereas///   there's only one reasonable way to wrap an [`Ipv6Addr`](crate::net::Ipv6Addr)///   into an [`IpAddr`](crate::net::IpAddr), thus `IpAddr: From<Ipv6Addr>` exists./// [`String`] implements `From<&str>`:/// An explicit conversion from a `&str` to a String is done as follows:/// let string = "hello".to_string();/// let other_string = String::from("hello");/// assert_eq!(string, other_string);/// While performing error handling it is often useful to implement `From` for your own error type./// By converting underlying error types to our own custom error type that encapsulates the/// underlying error type, we can return a single error type without losing information on the/// underlying cause. The '?' operator automatically converts the underlying error type to our/// custom error type with `From::from`./// use std::num;/// enum CliError {///     IoError(io::Error),///     ParseError(num::ParseIntError),/// impl From<io::Error> for CliError {///     fn from(error: io::Error) -> Self {///         CliError::IoError(error)/// impl From<num::ParseIntError> for CliError {///     fn from(error: num::ParseIntError) -> Self {///         CliError::ParseError(error)/// fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {///     let mut contents = fs::read_to_string(&file_name)?;///     let num: i32 = contents.trim().parse()?;///     Ok(num)/// [`from`]: From::from/// [book]: ../../book/ch09-00-error-handling.html/// The type returned in the event of a conversion error./// Performs the conversion."TryInto"/// An attempted conversion that consumes `self`, which may or may not be/// expensive./// Library authors should usually not directly implement this trait,/// but should prefer implementing the [`TryFrom`] trait, which offers/// greater flexibility and provides an equivalent `TryInto`/// implementation for free, thanks to a blanket implementation in the/// standard library. For more information on this, see the/// documentation for [`Into`]./// Prefer using [`TryInto`] over [`TryFrom`] when specifying trait bounds on a generic function/// to ensure that types that only implement [`TryInto`] can be used as well./// # Implementing `TryInto`/// This suffers the same restrictions and reasoning as implementing/// [`Into`], see there for details."try_from_fn""TryFrom"/// Simple and safe type conversions that may fail in a controlled/// way under some circumstances. It is the reciprocal of [`TryInto`]./// This is useful when you are doing a type conversion that may/// trivially succeed but may also need special handling./// For example, there is no way to convert an [`i64`] into an [`i32`]/// using the [`From`] trait, because an [`i64`] may contain a value/// that an [`i32`] cannot represent and so the conversion would lose data./// This might be handled by truncating the [`i64`] to an [`i32`] or by/// simply returning [`i32::MAX`], or by some other method.  The [`From`]/// trait is intended for perfect conversions, so the `TryFrom` trait/// informs the programmer when a type conversion could go bad and lets/// them decide how to handle it./// - `TryFrom<T> for U` implies [`TryInto`]`<U> for T`/// - [`try_from`] is reflexive, which means that `TryFrom<T> for T`/// is implemented and cannot fail -- the associated `Error` type for/// calling `T::try_from()` on a value of type `T` is [`Infallible`]./// When the [`!`] type is stabilized [`Infallible`] and [`!`] will be/// `TryFrom<T>` can be implemented as follows:/// struct GreaterThanZero(i32);/// impl TryFrom<i32> for GreaterThanZero {///     type Error = &'static str;///     fn try_from(value: i32) -> Result<Self, Self::Error> {///         if value <= 0 {///             Err("GreaterThanZero only accepts values greater than zero!")///             Ok(GreaterThanZero(value))/// As described, [`i32`] implements `TryFrom<`[`i64`]`>`:/// let big_number = 1_000_000_000_000i64;/// // Silently truncates `big_number`, requires detecting/// // and handling the truncation after the fact./// let smaller_number = big_number as i32;/// assert_eq!(smaller_number, -727379968);/// // Returns an error because `big_number` is too big to/// // fit in an `i32`./// let try_smaller_number = i32::try_from(big_number);/// assert!(try_smaller_number.is_err());/// // Returns `Ok(3)`./// let try_successful_smaller_number = i32::try_from(3);/// assert!(try_successful_smaller_number.is_ok());/// [`try_from`]: TryFrom::try_from// As lifts over &// As lifts over &mut// AsMut lifts over &mut/// Calls `U::from(self)`./// That is, this conversion is whatever the implementation of/// <code>[From]&lt;T&gt; for U</code> chooses to do.// From implies Into/// Returns the argument unchanged.// From (and thus Into) is reflexive"permitting this impl would forbid us from adding \
                            `impl<T> From<!> for T` later; see rust-lang/rust#64715 for details"rustc_reservation_impl/// **Stability note:** This impl does not yet exist, but we are/// "reserving space" to add it in the future. See/// [rust-lang/rust#64715][#64715] for details./// [#64715]: https://github.com/rust-lang/rust/issues/64715// TryFrom implies TryInto// Infallible conversions are semantically equivalent to fallible conversions// with an uninhabited error type./// The error type for errors that can never happen./// Since this enum has no variant, a value of this type can never actually exist./// This can be useful for generic APIs that use [`Result`] and parameterize the error type,/// to indicate that the result is always [`Ok`]./// For example, the [`TryFrom`] trait (conversion that returns a [`Result`])/// has a blanket implementation for all types where a reverse [`Into`] implementation exists./// ```ignore (illustrates std code, duplicating the impl in a doctest would be an error)/// impl<T, U> TryFrom<U> for T where U: Into<T> {///     fn try_from(value: U) -> Result<Self, Infallible> {///         Ok(U::into(value))  // Never returns `Err`/// # Future compatibility/// This enum has the same role as [the `!` “never” type][never],/// which is unstable in this version of Rust./// When `!` is stabilized, we plan to make `Infallible` a type alias to it:/// ```ignore (illustrates future std change)/// pub type Infallible = !;/// … and eventually deprecate `Infallible`./// However there is one case where `!` syntax can be used/// before `!` is stabilized as a full-fledged type: in the position of a function’s return type./// Specifically, it is possible to have implementations for two different function pointer types:/// trait MyTrait {}/// impl MyTrait for fn() -> ! {}/// impl MyTrait for fn() -> std::convert::Infallible {}/// With `Infallible` being an enum, this code is valid./// However when `Infallible` becomes an alias for the never type,/// the two `impl`s will start to overlap/// and therefore will be disallowed by the language’s trait coherence rules.//! Traits for conversions between types.//! The traits in this module provide a way to convert from one type to another type.//! Each trait serves a different purpose://! - Implement the [`AsRef`] trait for cheap reference-to-reference conversions//! - Implement the [`AsMut`] trait for cheap mutable-to-mutable conversions//! - Implement the [`From`] trait for consuming value-to-value conversions//! - Implement the [`Into`] trait for consuming value-to-value conversions to types//!   outside the current crate//! - The [`TryFrom`] and [`TryInto`] traits behave like [`From`] and [`Into`],//!   but should be implemented when the conversion can fail.//! The traits in this module are often used as trait bounds for generic functions such that to//! arguments of multiple types are supported. See the documentation of each trait for examples.//! As a library author, you should always prefer implementing [`From<T>`][`From`] or//! [`TryFrom<T>`][`TryFrom`] rather than [`Into<U>`][`Into`] or [`TryInto<U>`][`TryInto`],//! as [`From`] and [`TryFrom`] provide greater flexibility and offer//! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a//! blanket implementation in the standard library. When targeting a version prior to Rust 1.41, it//! may be necessary to implement [`Into`] or [`TryInto`] directly when converting to a type//! outside the current crate.//! # Generic Implementations//! - [`AsRef`] and [`AsMut`] auto-dereference if the inner type is a reference//!   (but not generally for all [dereferenceable types][core::ops::Deref])//! - [`From`]`<U> for T` implies [`Into`]`<T> for U`//! - [`TryFrom`]`<U> for T` implies [`TryInto`]`<T> for U`//! - [`From`] and [`Into`] are reflexive, which means that all types can//!   `into` themselves and `from` themselves//! See each trait for usage examples.// GENERIC IMPLS// FIXME (#45742): replace the above impls for &/&mut with the following more general one:// // As lifts over Deref// impl<D: ?Sized + Deref<Target: AsRef<U>>, U: ?Sized> AsRef<U> for D {//     fn as_ref(&self) -> &U {//         self.deref().as_ref()// FIXME (#45742): replace the above impl for &mut with the following more general one:// // AsMut lifts over DerefMut// impl<D: ?Sized + Deref<Target: AsMut<U>>, U: ?Sized> AsMut<U> for D {//     fn as_mut(&mut self) -> &mut U {//         self.deref_mut().as_mut()// CONCRETE IMPLS// THE NO-ERROR ERROR TYPE/// This trait being unreachable from outside the crate/// prevents other implementations of the `FloatToInt` trait,/// which allows potentially adding more trait methods after the trait is `#[stable]`.to_int_unchecked/// Supporting trait for inherent methods of `f32` and `f64` such as `to_int_unchecked`./// Typically doesn’t need to be used directly.impl_float_to_int// Conversion traits for primitive integer and float types// Conversions T -> T are covered by a blanket impl and therefore excluded// Some conversions from and to usize/isize are not implemented due to portability concerns// boolean -> integer// unsigned integer -> unsigned integer// signed integer -> signed integer// unsigned integer -> signed integer// The C99 standard defines bounds on INTPTR_MIN, INTPTR_MAX, and UINTPTR_MAX// which imply that pointer-sized integers must be at least 16 bits:// https://port70.net/~nsz/c/c99/n1256.html#7.18.2.4// signed integer -> float// unsigned integer -> float// float -> float// FIXME(f16_f128): adding additional `From<{float}>` impls to `f32` breaks inference. See// <https://github.com/rust-lang/rust/issues/123831>impl_float_from_boolr" The resulting value is positive `0.0` for `false` and `1.0` for `true` values."r"#![feature(f16)]"r#"# #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {"#r" assert_eq!(x, 0.0);"r" assert!(x.is_sign_positive());"r" assert_eq!(y, 1.0);"r"# }"// boolean -> floatr"#![feature(f128)]"impl_try_from_unbounded// no possible bounds violationimpl_try_from_lower_bounded// only negative boundsimpl_try_from_upper_bounded// unsigned to signed (only positive bound)impl_try_from_both_bounded// all other casesr" Tries to create the target number type from a source"r" number type. This returns an error if the source value"r" is outside of the range of the target type."// signed integer -> unsigned integer// usize/isizeptr_try_from_impls// Conversion traits for non-zero integer typesimpl_nonzero_int_from_nonzero_int// non-zero unsigned integer -> non-zero unsigned integer// non-zero signed integer -> non-zero signed integer// non-zero unsigned -> non-zero signed integerimpl_nonzero_int_try_from_int// integer -> non-zero integerimpl_nonzero_int_try_from_nonzero_int// unsigned non-zero integer -> unsigned non-zero integer// signed non-zero integer -> signed non-zero integer// unsigned non-zero integer -> signed non-zero integer// signed non-zero integer -> unsigned non-zero integer// RISC-V defines the possibility of a 128-bit address space (RV128).// CHERI proposes 128-bit “capabilities”. Unclear if this would be relevant to usize/isize.// https://www.cl.cam.ac.uk/research/security/ctsrd/pdfs/20171017a-cheri-poster.pdf// https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-951.pdf// Note: integers can only be represented with full precision in a float if// they fit in the significand, which is:// * 11 bits in f16// * 24 bits in f32// * 53 bits in f64// * 113 bits in f128// Lossy float conversions are not implemented at this time.// FIXME(f16_f128): The `f16`/`f128` impls `#[stable]` attributes should be changed to reference// `f16`/`f128` when they are stabilised (trait impls have to have a `#[stable]` attribute, but none// of the `f16`/`f128` impls can be used on stable as the `f16` and `f128` types are unstable).// FIXME(f16_f128): This impl would allow using `f128` on stable before it is stabilised.// impl_from!(i64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);// impl_from!(u64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);"default_fn"/// Returns the "default value" for a type./// Default values are often some kind of initial value, identity value, or anything else that/// may make sense as a default./// Using built-in default values:/// let i: i8 = Default::default();/// let (x, y): (Option<String>, f64) = Default::default();/// let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();/// Making your own:/// enum Kind {/// impl Default for Kind {///     fn default() -> Self { Kind::A }"Default"/// A trait for giving a type a useful default value./// Sometimes, you want to fall back to some kind of default value, and/// don't particularly care what it is. This comes up often with `struct`s/// that define a set of options:/// struct SomeOptions {///     bar: f32,/// How can we define some default values? You can use `Default`:///     let options: SomeOptions = Default::default();/// Now, you get all of the default values. Rust implements `Default` for various primitive types./// If you want to override a particular option, but still retain the other defaults:/// # struct SomeOptions {/// #     foo: i32,/// #     bar: f32,///     let options = SomeOptions { foo: 42, ..Default::default() };/// This trait can be used with `#[derive]` if all of the type's fields implement/// `Default`. When `derive`d, it will use the default value for each field's type./// ### `enum`s/// When using `#[derive(Default)]` on an `enum`, you need to choose which unit variant will be/// default. You do this by placing the `#[default]` attribute on the variant.///     #[default]/// You cannot use the `#[default]` attribute on non-unit or non-exhaustive variants./// The `#[default]` attribute was stabilized in Rust 1.62.0./// ## How can I implement `Default`?/// Provide an implementation for the `default()` method that returns the value of/// your type that should be the default:/// Derive macro generating an impl of the trait `Default`."Returns the default value of `()`""Returns the default value of `false`""Returns the default value of `\\x00`""Returns the default value of `Null`""Returns the default value of `0`""Returns the default value of `0.0`"//! The `Default` trait for types with a default value./// Returns the lower-level source of this error, if any./// struct SuperError {///     source: SuperErrorSideKick,/// impl fmt::Display for SuperError {///         write!(f, "SuperError is here!")/// impl Error for SuperError {///     fn source(&self) -> Option<&(dyn Error + 'static)> {///         Some(&self.source)/// struct SuperErrorSideKick;/// impl fmt::Display for SuperErrorSideKick {///         write!(f, "SuperErrorSideKick is here!")/// impl Error for SuperErrorSideKick {}/// fn get_super_error() -> Result<(), SuperError> {///     Err(SuperError { source: SuperErrorSideKick })///     match get_super_error() {///         Err(e) => {///             println!("Error: {e}");///             println!("Caused by: {}", e.source().unwrap());///         _ => println!("No error"),/// if let Err(e) = "xc".parse::<u32>() {///     // Print `e` itself, no need for description().///     eprintln!("Error: {e}");/// Provides type-based access to context intended for error reports./// Used in conjunction with [`Request::provide_value`] and [`Request::provide_ref`] to extract/// references to member variables from `dyn Error` trait objects./// use core::fmt;/// use core::error::{request_ref, Request};/// enum MyLittleTeaPot {/// struct MyBacktrace {/// impl MyBacktrace {///     fn new() -> MyBacktrace {///         # MyBacktrace {}/// struct Error {///     backtrace: MyBacktrace,/// impl fmt::Display for Error {///         write!(f, "Example Error")/// impl std::error::Error for Error {///     fn provide<'a>(&'a self, request: &mut Request<'a>) {///             .provide_ref::<MyBacktrace>(&self.backtrace);///     let backtrace = MyBacktrace::new();///     let error = Error { backtrace };///     let dyn_error = &error as &dyn std::error::Error;///     let backtrace_ref = request_ref::<MyBacktrace>(dyn_error).unwrap();///     assert!(core::ptr::eq(&error.backtrace, backtrace_ref));///     assert!(request_ref::<MyLittleTeaPot>(dyn_error).is_none());"Error"rustc_has_incoherent_inherent_impls/// `Error` is a trait representing the basic expectations for error values,/// i.e., values of type `E` in [`Result<T, E>`]./// Errors must describe themselves through the [`Display`] and [`Debug`]/// traits. Error messages are typically concise lowercase sentences without/// trailing punctuation:/// let err = "NaN".parse::<u32>().unwrap_err();/// assert_eq!(err.to_string(), "invalid digit found in string");/// # Error source/// Errors may provide cause information. [`Error::source()`] is generally/// used when errors cross "abstraction boundaries". If one module must report/// an error that is caused by an error from a lower-level module, it can allow/// accessing that error via `Error::source()`. This makes it possible for the/// high-level module to provide its own errors while also revealing some of the/// implementation for debugging./// In error types that wrap an underlying error, the underlying error/// should be either returned by the outer error's `Error::source()`, or rendered/// by the outer error's `Display` implementation, but not both./// Implementing the `Error` trait only requires that `Debug` and `Display` are implemented too./// struct ReadConfigError {///     path: PathBuf/// impl fmt::Display for ReadConfigError {///         let path = self.path.display();///         write!(f, "unable to read configuration at {path}")/// impl Error for ReadConfigError {}// This is a hack to prevent `type_id` from being overridden by `Error`// implementations, since that can enable unsound downcasting.// Copied from `any.rs`./// Forwards to the method defined on the type `dyn Error`./// Returns an iterator starting with the current error and continuing with/// recursively calling [`Error::source`]./// If you want to omit the current error and only use its sources,/// use `skip(1)`./// #![feature(error_iter)]/// struct A;/// struct B(Option<Box<dyn Error + 'static>>);/// impl fmt::Display for A {///         write!(f, "A")/// impl fmt::Display for B {///         write!(f, "B")/// impl Error for A {}/// impl Error for B {///         self.0.as_ref().map(|e| e.as_ref())/// let b = B(Some(Box::new(A)));/// // let err : Box<Error> = b.into(); // or/// let err = &b as &dyn Error;/// let mut iter = err.sources();/// assert_eq!("B".to_string(), iter.next().unwrap().to_string());/// assert_eq!("A".to_string(), iter.next().unwrap().to_string());request_value/// Requests a value of type `T` from the given `impl Error`./// Get a string value from an error./// use core::error::request_value;/// fn get_string(err: &impl Error) -> String {///     request_value::<String>(err).unwrap()/// Requests a reference of type `T` from the given `impl Error`./// Get a string reference from an error./// use core::error::Error;/// use core::error::request_ref;/// fn get_str(err: &impl Error) -> &str {///     request_ref::<str>(err).unwrap()request_by_type_tagReified/// Request a specific value by tag from the `Error`.Erased/// `Request` supports generic, type-driven access to data. Its use is currently restricted to the/// standard library in cases where trait authors wish to allow trait implementors to share generic/// information across trait boundaries. The motivating and prototypical use case is/// `core::error::Error` which would otherwise require a method per concrete type (eg./// `std::backtrace::Backtrace` instance that implementors want to expose to users)./// # Data flow/// To describe the intended data flow for Request objects, let's consider two conceptual users/// separated by API boundaries:/// * Consumer - the consumer requests objects using a Request instance; eg a crate that offers///   fancy `Error`/`Result` reporting to users wants to request a Backtrace from a given `dyn Error`./// * Producer - the producer provides objects when requested via Request; eg. a library with an///   an `Error` implementation that automatically captures backtraces at the time instances are///   created./// The consumer only needs to know where to submit their request and are expected to handle the/// request not being fulfilled by the use of `Option<T>` in the responses offered by the producer./// * A Producer initializes the value of one of its fields of a specific type. (or is otherwise///   prepared to generate a value requested). eg, `backtrace::Backtrace` or///   `std::backtrace::Backtrace`/// * A Consumer requests an object of a specific type (say `std::backtrace::Backtrace`). In the///   case of a `dyn Error` trait object (the Producer), there are functions called `request_ref` and///   `request_value` to simplify obtaining an `Option<T>` for a given type./// * The Producer, when requested, populates the given Request object which is given as a mutable///   reference./// * The Consumer extracts a value or reference to the requested type from the `Request` object///   wrapped in an `Option<T>`; in the case of `dyn Error` the aforementioned `request_ref` and `///   request_value` methods mean that `dyn Error` users don't have to deal with the `Request` type at///   all (but `Error` implementors do). The `None` case of the `Option` suggests only that the///   Producer cannot currently offer an instance of the requested type, not it can't or never will./// The best way to demonstrate this is using an example implementation of `Error`'s `provide` trait/// method:/// use core::error::Request;provide_value/// Provides a value or other type with only static lifetimes./// Provides an `u8`./// struct SomeConcreteType { field: u8 }/// impl std::fmt::Display for SomeConcreteType {///     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {///         write!(f, "{} failed", self.field)/// impl std::error::Error for SomeConcreteType {///         request.provide_value::<u8>(self.field);provide_value_with/// Provides a value or other type with only static lifetimes computed using a closure./// Provides a `String` by cloning./// struct SomeConcreteType { field: String }///         request.provide_value_with::<String>(|| self.field.clone());provide_ref/// Provides a reference. The referee type must be bounded by `'static`,/// but may be unsized./// Provides a reference to a field as a `&str`.///         request.provide_ref::<str>(&self.field);provide_ref_with/// Provides a reference computed using a closure. The referee type/// must be bounded by `'static`, but may be unsized./// struct SomeConcreteType { business: String, party: String }/// fn today_is_a_weekday() -> bool { true }///         write!(f, "{} failed", self.business)///         request.provide_ref_with::<str>(|| {///             if today_is_a_weekday() {///                 &self.business///                 &self.party/// Provides a value with the given `Type` tag.provide_with/// Provides a value with the given `Type` tag, using a closure to prevent unnecessary work.would_be_satisfied_by_value_of/// Checks if the `Request` would be satisfied if provided with a/// value of the specified type. If the type does not match or has/// already been provided, returns false./// Checks if a `u8` still needs to be provided and then provides/// struct Parent(Option<u8>);/// impl std::fmt::Display for Parent {///         write!(f, "a parent failed")/// impl std::error::Error for Parent {///         if let Some(v) = self.0 {///             request.provide_value::<u8>(v);/// struct Child {///     parent: Parent,/// impl Child {///     // Pretend that this takes a lot of resources to evaluate.///     fn an_expensive_computation(&self) -> Option<u8> {///         Some(99)/// impl std::fmt::Display for Child {///         write!(f, "child failed: \n  because of parent: {}", self.parent)/// impl std::error::Error for Child {///         // In general, we don't know if this call will provide///         // an `u8` value or not...///         self.parent.provide(request);///         // ...so we check to see if the `u8` is needed before///         // we run our expensive computation.///         if request.would_be_satisfied_by_value_of::<u8>() {///             if let Some(v) = self.an_expensive_computation() {///                 request.provide_value::<u8>(v);///         // The request will be satisfied now, regardless of if///         // the parent provided the value or we did.///         assert!(!request.would_be_satisfied_by_value_of::<u8>());/// let parent = Parent(Some(42));/// let child = Child { parent };/// assert_eq!(Some(42), request_value::<u8>(&child));/// let parent = Parent(None);/// assert_eq!(Some(99), request_value::<u8>(&child));would_be_satisfied_by_ref_of/// reference to a value of the specified type./// If the type does not match or has already been provided, returns false./// Checks if a `&str` still needs to be provided and then provides/// struct Parent(Option<String>);///         if let Some(v) = &self.0 {///             request.provide_ref::<str>(v);///     fn an_expensive_computation(&self) -> Option<&str> {///         Some(&self.name)///         write!(f, "{} failed: \n  {}", self.name, self.parent)///         // a `str` reference or not...///         // ...so we check to see if the `&str` is needed before///         if request.would_be_satisfied_by_ref_of::<str>() {///                 request.provide_ref::<str>(v);///         // the parent provided the reference or we did.///         assert!(!request.would_be_satisfied_by_ref_of::<str>());/// let parent = Parent(Some("parent".into()));/// let child = Child { parent, name: "child".into() };/// assert_eq!(Some("parent"), request_ref::<str>(&child));/// assert_eq!(Some("child"), request_ref::<str>(&child));would_be_satisfied_by/// The type of values which may be tagged by this tag for the given/// This trait is implemented by specific tag types in order to allow/// describing a type which can be requested for a given lifetime `'a`./// A few example implementations for type-driven tags can be found in this/// module, although crates may also implement their own tags for more/// complex types with internal lifetimes.MaybeSizedType/// Similar to the [`Type`] trait, but represents a type which may be unsized (i.e., has a/// `?Sized` bound). E.g., `str`./// Type-based tag for types bounded by `'static`, i.e., with no borrowed elements.MaybeSizedValue/// Type-based tag similar to [`Value`] but which may be unsized (i.e., has a `?Sized` bound)./// Type-based tag for reference types (`&'a T`, where T is represented by/// `<I as MaybeSizedType<'a>>::Reified`.//! Type tags are used to identify a type using a separate value. This module includes type tags//! for some very common types.//! Currently type tags are not exposed to the user. But in the future, if you want to use the//! Request API with more complex types (typically those including lifetime parameters), you//! will need to write your own tags.TaggedOption/// An `Option` with a type tag `I`./// Since this struct implements `Erased`, the type can be erased to make a dynamically typed/// option. The type can be checked dynamically using `Tagged::tag_id` and since this is statically/// checked for the concrete type, there is some degree of type safety.as_request/// Represents a type-erased but identifiable object./// This trait is exclusively implemented by the `TaggedOption` type.tag_id/// Returns some reference to the dynamic value if it is tagged with `I`,/// Returns some mutable reference to the dynamic value if it is tagged with `I`,/// An iterator over an [`Error`] and its sources./// If you want to omit the initial error and only process/// its sources, use `skip(1)`.TryFromFloatSecsError// Request and its methods// Type tagsHEX_DIGITS/// Escapes a character with `\x` representation./// Returns a buffer with the escaped representation and its corresponding range./// Escapes a character with `\xNN` representation./// Returns a buffer with the verbatim character and its corresponding range./// Escapes an ASCII character./// Escapes a character with `\u{NNNN}` representation.MaybeEscapedCharacterescape_seq/// Marker type to indicate that the character is always escaped,/// used to optimize the iterator implementation./// Marker type to indicate that the character may be escaped,// Invariant:// If `alive.end <= Self::LITERAL_ESCAPE_START`, `data` must contain// printable ASCII characters in the `alive` range of its `escape_seq` variant.// If `alive.end > Self::LITERAL_ESCAPE_START`, `data` must contain a// `char` in its `literal` variant, and the `alive` range must have a// length of at most `1`.ESCAPING/// An iterator over a possibly escaped character.LITERAL_ESCAPE_START/// `data.escape_seq` must contain an escape sequence in the range given by `alive`./// Returns a `char` if `self.data` contains one in its `literal` variant.to_str_unchecked/// Returns the printable ASCII characters in the `escape_seq` variant of `self.data`/// as a string./// - `self.data` must contain printable ASCII characters in its `escape_seq` variant./// - `self.alive` must be a valid range for `self.data.escape_seq`.// This is the only way to create any `EscapeIterInner` containing a `char` in// the `literal` variant of its `self.data`, meaning the `AlwaysEscaped` marker// guarantees that `self.data` contains printable ASCII characters in its// `escape_seq` variant.//! Helper code for character escaping.const_eval_select"cstr_type""CStr"// FIXME: this should not be represented with a DST slice but rather with//        just a raw `c_char` along with some form of marker to make//        this an unsized type. Essentially `sizeof(&CStr)` should be the//        same as `sizeof(&c_char)` but `CStr` should be an unsized type./// A dynamically-sized view of a C string./// The type `&CStr` represents a reference to a borrowed nul-terminated/// array of bytes. It can be constructed safely from a <code>&[[u8]]</code>/// slice, or unsafely from a raw `*const c_char`. It can be expressed as a/// literal in the form `c"Hello world"`./// The `&CStr` can then be converted to a Rust <code>&[str]</code> by performing/// UTF-8 validation, or into an owned `CString`./// `&CStr` is to `CString` as <code>&[str]</code> is to `String`: the former/// in each pair are borrowing references; the latter are owned/// Note that this structure does **not** have a guaranteed layout (the `repr(transparent)`/// notwithstanding) and should not be placed in the signatures of FFI functions./// Instead, safe wrappers of FFI functions may leverage [`CStr::as_ptr`] and the unsafe/// [`CStr::from_ptr`] constructor to provide a safe interface to other consumers./// Inspecting a foreign C string:/// use std::ffi::CStr;/// # /* Extern functions are awkward in doc comments - fake it instead/// extern "C" { fn my_string() -> *const c_char; }/// # */ unsafe extern "C" fn my_string() -> *const c_char { c"hello".as_ptr() }///     let slice = CStr::from_ptr(my_string());///     println!("string buffer size without nul terminator: {}", slice.to_bytes().len());/// Passing a Rust-originating C string:/// fn work(data: &CStr) {///     unsafe extern "C" fn work_with(s: *const c_char) {}///     unsafe { work_with(data.as_ptr()) }/// let s = c"Hello world!";/// work(&s);/// Converting a foreign C string into a Rust `String`:/// fn my_string_safe() -> String {///     let cstr = unsafe { CStr::from_ptr(my_string()) };///     // Get a copy-on-write Cow<'_, str>, then extract the///     // allocated String (or allocate a fresh one if needed).///     cstr.to_string_lossy().into_owned()/// println!("string: {}", my_string_safe());// `fn from` in `impl From<&CStr> for Box<CStr>` current implementation relies// on `CStr` being layout-compatible with `[u8]`.// However, `CStr` layout is considered an implementation detail and must not be relied upon. We// want `repr(transparent)` but we don't want it to show up in rustdoc, so we hide it under// `cfg(doc)`. This is an ad-hoc implementation of attribute privacy./// The position of the interior nul byte./// Data provided contains an interior nul byte at byte `position`./// Data provided is not nul terminated./// The slice used to create a [`CStr`] must have one and only one nul byte,/// This error is created by the [`CStr::from_bytes_with_nul`] method./// use std::ffi::{CStr, FromBytesWithNulError};/// let _: FromBytesWithNulError = CStr::from_bytes_with_nul(b"f\0oo").unwrap_err();/// An error indicating that no nul byte was present./// A slice used to create a [`CStr`] must contain a nul byte somewhere/// within the slice./// This error is created by the [`CStr::from_bytes_until_nul`] method./// Shows the underlying bytes as a normal string, with invalid UTF-8/// Wraps a raw C string with a safe C string wrapper./// This function will wrap the provided `ptr` with a `CStr` wrapper, which/// allows inspection and interoperation of non-owned C strings. The total/// size of the terminated buffer must be smaller than [`isize::MAX`] **bytes**/// in memory (a restriction from [`slice::from_raw_parts`])./// * The memory pointed to by `ptr` must contain a valid nul terminator at the///   end of the string./// * `ptr` must be [valid] for reads of bytes up to and including the nul terminator.///   This means in particular:///     * The entire memory range of this `CStr` must be contained within a single allocation!///     * `ptr` must be non-null even for a zero-length cstr./// * The memory referenced by the returned `CStr` must not be mutated for///   the duration of lifetime `'a`./// * The nul terminator must be within `isize::MAX` from `ptr`/// > **Note**: This operation is intended to be a 0-cost cast but it is/// > currently implemented with an up-front calculation of the length of/// > the string. This is not guaranteed to always be the case./// The lifetime for the returned slice is inferred from its usage. To prevent accidental misuse,/// it's suggested to tie the lifetime to whichever source lifetime is safe in the context,/// such as by providing a helper function taking the lifetime of a host value for the slice,/// or by explicit annotation./// use std::ffi::{c_char, CStr};/// fn my_string() -> *const c_char {///     c"hello".as_ptr()///     assert_eq!(slice.to_str().unwrap(), "hello");/// const HELLO_PTR: *const c_char = {///     const BYTES: &[u8] = b"Hello, world!\0";///     BYTES.as_ptr().cast()/// const HELLO: &CStr = unsafe { CStr::from_ptr(HELLO_PTR) };/// assert_eq!(c"Hello, world!", HELLO);/// [valid]: core::ptr#safety// inline is necessary for codegen to see strlen.from_bytes_until_nul/// Creates a C string wrapper from a byte slice with any number of nuls./// This method will create a `CStr` from any byte slice that contains at/// least one nul byte. Unlike with [`CStr::from_bytes_with_nul`], the caller/// does not need to know where the nul byte is located./// If the first byte is a nul character, this method will return an/// empty `CStr`. If multiple nul characters are present, the `CStr` will/// end at the first one./// If the slice only has a single nul byte at the end, this method is/// equivalent to [`CStr::from_bytes_with_nul`]./// let mut buffer = [0u8; 16];///     // Here we might call an unsafe C function that writes a string///     // into the buffer.///     let buf_ptr = buffer.as_mut_ptr();///     buf_ptr.write_bytes(b'A', 8);/// // Attempt to extract a C nul-terminated string from the buffer./// let c_str = CStr::from_bytes_until_nul(&buffer[..]).unwrap();/// assert_eq!(c_str.to_str().unwrap(), "AAAAAAAA");/// Creates a C string wrapper from a byte slice with exactly one nul/// This function will cast the provided `bytes` to a `CStr`/// wrapper after ensuring that the byte slice is nul-terminated/// and does not contain any interior nul bytes./// If the nul byte may not be at the end,/// [`CStr::from_bytes_until_nul`] can be used instead./// let cstr = CStr::from_bytes_with_nul(b"hello\0");/// assert_eq!(cstr, Ok(c"hello"));/// Creating a `CStr` without a trailing nul terminator is an error:/// let cstr = CStr::from_bytes_with_nul(b"hello");/// assert_eq!(cstr, Err(FromBytesWithNulError::NotNulTerminated));/// Creating a `CStr` with an interior nul byte is an error:/// let cstr = CStr::from_bytes_with_nul(b"he\0llo\0");/// assert_eq!(cstr, Err(FromBytesWithNulError::InteriorNul { position: 2 }));/// Unsafely creates a C string wrapper from a byte slice./// This function will cast the provided `bytes` to a `CStr` wrapper without/// performing any sanity checks./// let bytes = b"Hello world!\0";/// let cstr = unsafe { CStr::from_bytes_with_nul_unchecked(bytes) };/// assert_eq!(cstr.to_bytes_with_nul(), bytes);/// Returns the inner pointer to this C string./// The returned pointer will be valid for as long as `self` is, and points/// to a contiguous region of memory terminated with a 0 byte to represent/// the end of the string./// The type of the returned pointer is/// [`*const c_char`][crate::ffi::c_char], and whether it's/// an alias for `*const i8` or `*const u8` is platform-specific./// The returned pointer is read-only; writing to it (including passing it/// to C code that writes to it) causes undefined behavior./// It is your responsibility to make sure that the underlying memory is not/// freed too early. For example, the following code will cause undefined/// behavior when `ptr` is used inside the `unsafe` block:/// # #![expect(dangling_pointers_from_temporaries)]/// // 💀 The meaning of this entire program is undefined,/// // 💀 and nothing about its behavior is guaranteed,/// // 💀 not even that its behavior resembles the code as written,/// // 💀 just because it contains a single instance of undefined behavior!/// // 🚨 creates a dangling pointer to a temporary `CString`/// // 🚨 that is deallocated at the end of the statement/// let ptr = CString::new("Hi!".to_uppercase()).unwrap().as_ptr();/// // without undefined behavior, you would expect that `ptr` equals:/// dbg!(CStr::from_bytes_with_nul(b"HI!\0").unwrap());/// // 🙏 Possibly the program behaved as expected so far,/// // 🙏 and this just shows `ptr` is now garbage..., but/// // 💀 this violates `CStr::from_ptr`'s safety contract/// // 💀 leading to a dereference of a dangling pointer,/// // 💀 which is immediate undefined behavior./// // 💀 *BOOM*, you're dead, your entire program has no meaning./// dbg!(unsafe { CStr::from_ptr(ptr) });/// This happens because, the pointer returned by `as_ptr` does not carry any/// lifetime information, and the `CString` is deallocated immediately after/// the expression that it is part of has been evaluated./// To fix the problem, bind the `CString` to a local variable:/// let c_str = CString::new("Hi!".to_uppercase()).unwrap();/// let ptr = c_str.as_ptr();/// assert_eq!(unsafe { CStr::from_ptr(ptr) }, c"HI!");as_non_null_ptr/// We could eventually expose this publicly, if we wanted.count_bytes/// Returns the length of `self`. Like C's `strlen`, this does not include the nul terminator./// > **Note**: This method is currently implemented as a constant-time/// > cast, but it is planned to alter its definition in the future to/// > perform the length calculation whenever this method is called./// assert_eq!(c"foo".count_bytes(), 3);/// assert_eq!(c"".count_bytes(), 0);/// Returns `true` if `self.to_bytes()` has a length of 0./// assert!(!c"foo".is_empty());/// assert!(c"".is_empty());/// Converts this C string to a byte slice./// The returned slice will **not** contain the trailing nul terminator that this C/// assert_eq!(c"foo".to_bytes(), b"foo");/// Converts this C string to a byte slice containing the trailing 0 byte./// This function is the equivalent of [`CStr::to_bytes`] except that it/// will retain the trailing nul terminator instead of chopping it off./// > **Note**: This method is currently implemented as a 0-cost cast, but/// > it is planned to alter its definition in the future to perform the/// > length calculation whenever this method is called./// assert_eq!(c"foo".to_bytes_with_nul(), b"foo\0");/// Iterates over the bytes in this C string./// The returned iterator will **not** contain the trailing nul terminator/// that this C string has./// #![feature(cstr_bytes)]/// assert!(c"foo".bytes().eq(*b"foo"));/// Yields a <code>&[str]</code> slice if the `CStr` contains valid UTF-8./// function will return the corresponding <code>&[str]</code> slice. Otherwise,/// it will return an error with details of where UTF-8 validation failed./// assert_eq!(c"foo".to_str(), Ok("foo"));"this does not display the `CStr`; \
                  it returns an object that can be displayed"/// Returns an object that implements [`Display`] for safely printing a [`CStr`] that may/// contain non-Unicode data./// Behaves as if `self` were first lossily converted to a `str`, with invalid UTF-8 presented/// as the Unicode replacement character: �./// #![feature(cstr_display)]/// let cstr = c"Hello, world!";/// println!("{}", cstr.display());// `.to_bytes()` representations are compared instead of the inner `[c_char]`s,// because `c_char` is `i8` (not `u8`) on some platforms.// That is why this is implemented manually and not derived./// Calculate the length of a nul-terminated string. Defers to C's `strlen` when possible./// The pointer must point to a valid buffer that contains a NUL terminator. The NUL must be/// located within `isize::MAX` from `ptr`.// since we know the string is nul-terminated, we only need one pointer/// An iterator over the bytes of a [`CStr`], without the nul terminator./// This struct is created by the [`bytes`] method on [`CStr`]./// [`bytes`]: CStr::bytes//! [`CStr`] and its related types.// FIXME: because this is doc(inline)d, we *have* to use intra-doc links because the actual link//   depends on where the item is being documented. however, since this is libcore, we can't//   actually reference libstd or liballoc in intra-doc links. so, the best we can do is remove the//   links to `CString` and `String` for now until a solution is developedVaArgSafeVaListVaListImplc_ptrdiff_tc_ssize_t"c_void"__variant1__variant2// N.B., for LLVM to recognize the void pointer type and by extension//     functions like malloc(), we need to have it represented as i8* in//     LLVM bitcode. The enum used here ensures this and prevents misuse//     of the "raw" type by only having private variants. We need two//     variants, because the compiler complains about the repr attribute//     otherwise and we need at least one variant as otherwise the enum//     would be uninhabited and at least dereferencing such pointers would//     be UB.//! Platform-specific types, as defined by C.//! Code that interacts via FFI will almost certainly be using the//! base types provided by C, which aren't nearly as nicely defined//! as Rust's primitive types. This module provides types which will//! match those defined by C, so that code that interacts with C will//! refer to the correct types.// Link the MSVC default libc_char_definitionc_int_definitionc_long_definitioncfg_select/// Equivalent to C's `size_t` type, from `stddef.h` (or `cstddef` for C++)./// This type is currently always [`usize`], however in the future there may be/// platforms where this is not the case./// Equivalent to C's `ptrdiff_t` type, from `stddef.h` (or `cstddef` for C++)./// This type is currently always [`isize`], however in the future there may be/// Equivalent to C's `ssize_t` (on POSIX) or `SSIZE_T` (on Windows) type.//! Defines primitive types that match C's type definitions for FFI compatibility.//! This module is intentionally standalone to facilitate parsing when retrieving//! core C types.va_argva_copyva_endPhantomInvariantLifetimer" x86_64 ABI implementation of a `va_list`.""va_list"gp_offsetfp_offsetoverflow_arg_areareg_save_area// The name is WIP, using `VaListImpl` for now.// Most targets explicitly specify the layout of `va_list`, this layout is matched here.r" A wrapper for a `va_list`"r" Converts a [`VaListImpl`] into a [`VaList`] that is binary-compatible with C's `va_list`."as_va_list/// Types that are valid to read using [`VaListImpl::arg`]./// The standard library implements this trait for primitive types that are/// expected to have a variable argument application-binary interface (ABI) on all/// When C passes variable arguments, integers smaller than [`c_int`] and floats smaller/// than [`c_double`] are implicitly promoted to [`c_int`] and [`c_double`] respectively./// Implementing this trait for types that are subject to this promotion rule is invalid./// [`c_int`]: core::ffi::c_int/// [`c_double`]: core::ffi::c_double// We may unseal this trait in the future, but currently our `va_arg` implementations don't support// types with an alignment larger than 8, or with a non-scalar layout. Inline assembly can be used// to accept unsupported types in the meantime.// i8 and i16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.// u8 and u16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.// f32 is implicitly promoted to c_double in C, and cannot implement `VaArgSafe`./// Advance to and read the next variable argument./// This function is only sound to call when:/// - there is a next variable argument available./// - the next argument's type must be ABI-compatible with the type `T`./// - the next argument must have a properly initialized value of type `T`./// Calling this function with an incompatible type, an invalid value, or when there/// are no more variable arguments, is unsound./// [valid]: https://doc.rust-lang.org/nightly/nomicon/what-unsafe-does.htmlwith_copy'copy/// Copies the `va_list` at the current location.// Checks (via an assert in `compiler/rustc_ty_utils/src/abi.rs`) that the C ABI for the current// target correctly implements `rustc_pass_indirectly_in_non_rustic_abis`.//! C's "variable arguments"//! Better known as "varargs".'statePadAdapterStatePadAdapteron_newline'slot"must eventually call `finish()` on Debug builders""DebugStruct"/// A struct to help with [`fmt::Debug`](Debug) implementations./// This is useful when you wish to output a formatted struct as a part of your/// [`Debug::fmt`] implementation./// This can be constructed by the [`Formatter::debug_struct`] method.///     bar: i32,///     baz: String,/// impl fmt::Debug for Foo {///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {///         fmt.debug_struct("Foo")///            .field("bar", &self.bar)///            .field("baz", &self.baz)///            .finish()///     format!("{:?}", Foo { bar: 10, baz: "Hello World".to_string() }),///     r#"Foo { bar: 10, baz: "Hello World" }"#,debug_struct_new/// Adds a new field to the generated struct output.///     another: String,/// impl fmt::Debug for Bar {///         fmt.debug_struct("Bar")///            .field("bar", &self.bar) // We add `bar` field.///            .field("another", &self.another) // We add `another` field.///            // We even add a field which doesn't exist (because why not?).///            .field("nonexistent_field", &1)///            .finish() // We're good to go!///     format!("{:?}", Bar { bar: 10, another: "Hello World".to_string() }),///     r#"Bar { bar: 10, another: "Hello World", nonexistent_field: 1 }"#,field_with/// This method is equivalent to [`DebugStruct::field`], but formats the/// value using a provided closure rather than by calling [`Debug::fmt`].finish_non_exhaustive/// Marks the struct as non-exhaustive, indicating to the reader that there are some other/// fields that are not shown in the debug representation.///     hidden: f32,///            .finish_non_exhaustive() // Show that some other field(s) exist.///     format!("{:?}", Bar { bar: 10, hidden: 1.0 }),///     "Bar { bar: 10, .. }",/// Finishes output and returns any error encountered.///            .finish() // You need to call it to "finish" the///                      // struct formatting.///     format!("{:?}", Bar { bar: 10, baz: "Hello World".to_string() }),///     r#"Bar { bar: 10, baz: "Hello World" }"#,is_prettyempty_name/// This is useful when you wish to output a formatted tuple as a part of your/// This can be constructed by the [`Formatter::debug_tuple`] method./// struct Foo(i32, String);///         fmt.debug_tuple("Foo")///            .field(&self.0)///            .field(&self.1)///     format!("{:?}", Foo(10, "Hello World".to_string())),///     r#"Foo(10, "Hello World")"#,debug_tuple_new/// Adds a new field to the generated tuple struct output.///            .field(&self.0) // We add the first field.///            .field(&self.1) // We add the second field./// This method is equivalent to [`DebugTuple::field`], but formats the/// Marks the tuple struct as non-exhaustive, indicating to the reader that there are some/// other fields that are not shown in the debug representation.///     format!("{:?}", Foo(10, "secret!".to_owned())),///     "Foo(10, ..)",///                      // tuple formatting.DebugInner/// A helper used to print list-like items with no special formatting.entry_with/// This is useful when you wish to output a formatted set of items as a part/// of your [`Debug::fmt`] implementation./// This can be constructed by the [`Formatter::debug_set`] method./// struct Foo(Vec<i32>);///         fmt.debug_set().entries(self.0.iter()).finish()///     format!("{:?}", Foo(vec![10, 11])),///     "{10, 11}",debug_set_new/// Adds a new entry to the set output./// struct Foo(Vec<i32>, Vec<u32>);///         fmt.debug_set()///            .entry(&self.0) // Adds the first "entry".///            .entry(&self.1) // Adds the second "entry".///     format!("{:?}", Foo(vec![10, 11], vec![12, 13])),///     "{[10, 11], [12, 13]}",/// This method is equivalent to [`DebugSet::entry`], but formats the/// entry using a provided closure rather than by calling [`Debug::fmt`]./// Adds the contents of an iterator of entries to the set output.///            .entries(self.0.iter()) // Adds the first "entry".///            .entries(self.1.iter()) // Adds the second "entry".///     "{10, 11, 12, 13}",/// Marks the set as non-exhaustive, indicating to the reader that there are some other/// elements that are not shown in the debug representation.///         // Print at most two elements, abbreviate the rest///         let mut f = fmt.debug_set();///         let mut f = f.entries(self.0.iter().take(2));///         if self.0.len() > 2 {///             f.finish_non_exhaustive()///             f.finish()///     format!("{:?}", Foo(vec![1, 2, 3, 4])),///     "{1, 2, ..}",///            .entries(self.0.iter())///            .finish() // Ends the set formatting./// This is useful when you wish to output a formatted list of items as a part/// This can be constructed by the [`Formatter::debug_list`] method.///         fmt.debug_list().entries(self.0.iter()).finish()///     "[10, 11]",debug_list_new/// Adds a new entry to the list output.///         fmt.debug_list()///            .entry(&self.0) // We add the first "entry".///            .entry(&self.1) // We add the second "entry".///     "[[10, 11], [12, 13]]",/// This method is equivalent to [`DebugList::entry`], but formats the/// Adds the contents of an iterator of entries to the list output.///            .entries(self.1.iter())///     "[10, 11, 12, 13]",/// Marks the list as non-exhaustive, indicating to the reader that there are some other///         let mut f = fmt.debug_list();///     "[1, 2, ..]",///            .finish() // Ends the list formatting.// The state of newlines is tracked between keys and values/// This is useful when you wish to output a formatted map as a part of your/// This can be constructed by the [`Formatter::debug_map`] method./// struct Foo(Vec<(String, i32)>);///         fmt.debug_map().entries(self.0.iter().map(|&(ref k, ref v)| (k, v))).finish()///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),///     r#"{"A": 10, "B": 11}"#,debug_map_new/// Adds a new entry to the map output.///         fmt.debug_map()///            .entry(&"whole", &self.0) // We add the "whole" entry.///     r#"{"whole": [("A", 10), ("B", 11)]}"#,/// Adds the key part of a new entry to the map output./// This method, together with `value`, is an alternative to `entry` that/// can be used when the complete entry isn't known upfront. Prefer the `entry`/// method when it's possible to use./// `key` must be called before `value` and each call to `key` must be followed/// by a corresponding call to `value`. Otherwise this method will panic.///            .key(&"whole").value(&self.0) // We add the "whole" entry.key_with/// This method is equivalent to [`DebugMap::key`], but formats the/// key using a provided closure rather than by calling [`Debug::fmt`]./// Adds the value part of a new entry to the map output./// This method, together with `key`, is an alternative to `entry` thatvalue_with/// This method is equivalent to [`DebugMap::value`], but formats the/// Adds the contents of an iterator of entries to the map output.///            // We map our vec so each entries' first field will become///            // the "key".///            .entries(self.0.iter().map(|&(ref k, ref v)| (k, v)))/// Marks the map as non-exhaustive, indicating to the reader that there are some other/// entries that are not shown in the debug representation.///         let mut f = fmt.debug_map();///         let mut f = f.entries(self.0.iter().take(2).map(|&(ref k, ref v)| (k, v)));///     format!("{:?}", Foo(vec![///         ("A".to_string(), 10),///         ("B".to_string(), 11),///         ("C".to_string(), 12),///     ])),///     r#"{"A": 10, "B": 11, ..}"#,///            .finish() // Ends the map formatting."returns a type implementing Debug and Display, which do not have any effects unless they are used"/// Creates a type whose [`fmt::Debug`] and [`fmt::Display`] impls are/// forwarded to the provided closure./// let value = 'a';/// assert_eq!(format!("{}", value), "a");/// assert_eq!(format!("{:?}", value), "'a'");/// let wrapped = fmt::from_fn(|f| write!(f, "{value:?}"));/// assert_eq!(format!("{}", wrapped), "'a'");/// assert_eq!(format!("{:?}", wrapped), "'a'");/// Implements [`fmt::Debug`] and [`fmt::Display`] via the provided closure./// Created with [`from_fn`].flt2decnumfmtalready_rounded_value_should_use_exponential/// Determines if a value should use exponential based on its magnitude, given the precondition/// that it will not be rounded any further before it is displayed.GeneralFormatimpl_general_formatfloat_to_decimal_common_exactDecodableFloat// Don't inline this so callers don't use the stack space this function// requires unless they have to.float_to_decimal_common_shortest// Don't inline this so callers that call both this and the above won't wind// up using the combined stack space of both functions in some cases.float_to_decimal_displayfloat_to_exponential_common_exactfloat_to_exponential_common_shortestfloat_to_exponential_common// Common code of floating point LowerExp and UpperExp.float_to_general_debugfloating// FIXME(f16_f128): A fallback is used when the backend+target does not support f16 well, in order// to avoid ICEs.num_buffer"Alignment"/// Indication that contents should be left-aligned./// Indication that contents should be right-aligned./// Indication that contents should be center-aligned./// Possible alignments returned by `Formatter::align`NumBufferTrait/// The type returned by formatter methods./// struct Triangle {///     a: f32,///     b: f32,///     c: f32/// impl fmt::Display for Triangle {///         write!(f, "({}, {}, {})", self.a, self.b, self.c)/// let pythagorean_triple = Triangle { a: 3.0, b: 4.0, c: 5.0 };/// assert_eq!(format!("{pythagorean_triple}"), "(3, 4, 5)");/// The error type which is returned from formatting a message into a stream./// This type does not support transmission of an error other than that an error/// occurred. This is because, despite the existence of this error,/// string formatting is considered an infallible operation./// `fmt()` implementors should not return this `Error` unless they received it from their/// [`Formatter`]. The only time your code should create a new instance of this/// error is when implementing `fmt::Write`, in order to cancel the formatting operation when/// writing to the underlying stream fails./// Any extra information must be arranged to be transmitted through some other means,/// such as storing it in a field to be consulted after the formatting operation has been/// cancelled. (For example, this is how [`std::io::Write::write_fmt()`] propagates IO errors/// during writing.)/// This type, `fmt::Error`, should not be/// confused with [`std::io::Error`] or [`std::error::Error`], which you may also/// have in scope./// [`std::io::Error`]: ../../std/io/struct.Error.html/// [`std::io::Write::write_fmt()`]: ../../std/io/trait.Write.html#method.write_fmt/// [`std::error::Error`]: ../../std/error/trait.Error.html/// use std::fmt::{self, write};/// if let Err(fmt::Error) = write(&mut output, format_args!("Hello {}!", "world")) {///     panic!("An error occurred");/// Writes a string slice into this writer, returning whether the write/// succeeded./// This function will return an instance of [`std::fmt::Error`][Error] on error./// The purpose of that error is to abort the formatting operation when the underlying/// destination encounters some error preventing it from accepting more text;/// in particular, it does not communicate any information about *what* error occurred./// It should generally be propagated rather than handled, at least when implementing/// formatting traits./// use std::fmt::{Error, Write};/// fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {///     f.write_str(s)/// writer(&mut buf, "hola")?;/// assert_eq!(&buf, "hola");/// # std::fmt::Result::Ok(())/// This function will return an instance of [`Error`] on error./// fn writer<W: Write>(f: &mut W, c: char) -> Result<(), Error> {///     f.write_char(c)/// writer(&mut buf, 'a')?;/// writer(&mut buf, 'b')?;/// assert_eq!(&buf, "ab");/// Glue for usage of the [`write!`] macro with implementors of this trait./// This function will return an instance of [`Error`] on error. Please see/// [write_str](Write::write_str) for details.///     f.write_fmt(format_args!("{s}"))/// writer(&mut buf, "world")?;/// assert_eq!(&buf, "world");"FmtWrite"/// A trait for writing or formatting into Unicode-accepting buffers or streams./// This trait only accepts UTF-8–encoded data and is not [flushable]. If you only/// want to accept Unicode and you don't need flushing, you should implement this trait;/// otherwise you should implement [`std::io::Write`]./// [`std::io::Write`]: ../../std/io/trait.Write.html/// [flushable]: ../../std/io/trait.Write.html#tymethod.flush/// Represents the `+` flag./// Represents the `-` flag./// The signedness of a [`Formatter`] (or of a [`FormattingOptions`])./// Use lower-case hexadecimal integers for the `Debug` trait (like [the `x?` type](../../std/fmt/index.html#formatting-traits))./// Use upper-case hexadecimal integers for the `Debug` trait (like [the `X?` type](../../std/fmt/index.html#formatting-traits))./// Specifies whether the [`Debug`] trait should use lower-/upper-case/// hexadecimal or normal integers./// Flags, with the following bit fields:///   31  30  29  28  27  26  25  24  23  22  21  20                              0/// ┌───┬───────┬───┬───┬───┬───┬───┬───┬───┬───┬──────────────────────────────────┐/// │ 0 │ align │ p │ w │ X?│ x?│'0'│ # │ - │ + │               fill               │/// └───┴───────┴───┴───┴───┴───┴───┴───┴───┴───┴──────────────────────────────────┘///   │     │     │   │  └─┬───────────────────┘ └─┬──────────────────────────────┘///   │     │     │   │    │                       └─ The fill character (21 bits char).///   │     │     │   │    └─ The debug upper/lower hex, zero pad, alternate, and plus/minus flags.///   │     │     │   └─ Whether a width is set. (The value is stored separately.)///   │     │     └─ Whether a precision is set. (The value is stored separately.)///   │     ├─ 0: Align left. (<)///   │     ├─ 1: Align right. (>)///   │     ├─ 2: Align center. (^)///   │     └─ 3: Alignment not set. (default)///   └─ Always zero.// Note: This could use a pattern type with range 0x0000_0000..=0x7dd0ffff.// It's unclear if that's useful, though./// Width if width flag (bit 27) above is set. Otherwise, always 0./// Precision if precision flag (bit 28) above is set. Otherwise, always 0./// Options for formatting./// `FormattingOptions` is a [`Formatter`] without an attached [`Write`] trait./// It is mainly used to construct `Formatter` instances.SIGN_PLUS_FLAGSIGN_MINUS_FLAGALTERNATE_FLAGSIGN_AWARE_ZERO_PAD_FLAGDEBUG_LOWER_HEX_FLAGDEBUG_UPPER_HEX_FLAGWIDTH_FLAGPRECISION_FLAGALIGN_BITSALIGN_LEFTALIGN_RIGHTALIGN_CENTERALIGN_UNKNOWN// This needs to match with compiler/rustc_ast_lowering/src/format.rs./// Construct a new `FormatterBuilder` with the supplied `Write` trait/// object for output that is equivalent to the `{}` formatting/// specifier:/// - no flags,/// - filled with spaces,/// - no alignment,/// - no width,/// - no precision, and/// - no [`DebugAsHex`] output mode./// Sets or removes the sign (the `+` or the `-` flag)./// - `+`: This is intended for numeric types and indicates that the sign///   should always be printed. By default only the negative sign of signed///   values is printed, and the sign of positive or unsigned values is///   omitted. This flag indicates that the correct sign (+ or -) should///   always be printed./// - `-`: Currently not used/// Sets or unsets the `0` flag./// This is used to indicate for integer formats that the padding to width should both be done with a 0 character as well as be sign-aware/// Sets or unsets the `#` flag./// This flag indicates that the "alternate" form of printing should be/// used. The alternate forms are:/// - [`Debug`] : pretty-print the [`Debug`] formatting (adds linebreaks and indentation)/// - [`LowerHex`] as well as [`UpperHex`] - precedes the argument with a `0x`/// - [`Octal`] - precedes the argument with a `0o`/// - [`Binary`] - precedes the argument with a `0b`/// Sets the fill character./// The optional fill character and alignment is provided normally in/// conjunction with the width parameter. This indicates that if the value/// being formatted is smaller than width some extra characters will be/// printed around it./// Sets or removes the alignment./// The alignment specifies how the value being formatted should be/// positioned if it is smaller than the width of the formatter./// Sets or removes the width./// This is a parameter for the “minimum width” that the format should take/// up. If the value’s string does not fill up this many characters, then/// the padding specified by [`FormattingOptions::fill`]/[`FormattingOptions::align`]/// will be used to take up the required space./// Sets or removes the precision./// - For non-numeric types, this can be considered a “maximum width”. If///   the resulting string is longer than this width, then it is truncated///   down to this many characters and that truncated value is emitted with///   proper fill, alignment and width if those parameters are set./// - For integral types, this is ignored./// - For floating-point types, this indicates how many digits after the/// decimal point should be printed.debug_as_hex/// hexadecimal or normal integersget_sign/// Returns the current sign (the `+` or the `-` flag).get_sign_aware_zero_pad/// Returns the current `0` flag.get_alternate/// Returns the current `#` flag.get_fill/// Returns the current fill character./// Returns the current alignment./// Returns the current width.get_precision/// Returns the current precision.get_debug_as_hexcreate_formatter/// Creates a [`Formatter`] that writes its output to the given [`Write`] trait./// You may alternatively use [`Formatter::new()`]./// Same as [`FormattingOptions::new()`]."Formatter"/// A `Formatter` represents various options related to formatting. Users do not/// construct `Formatter`s directly; a mutable reference to one is passed to/// the `fmt` method of all formatting traits, like [`Debug`] and [`Display`]./// To interact with a `Formatter`, you'll call various methods to change the/// various options related to formatting. For examples, please see the/// documentation of the methods defined on `Formatter` below./// Creates a new formatter with given [`FormattingOptions`]./// If `write` is a reference to a formatter, it is recommended to use/// [`Formatter::with_options`] instead as this can borrow the underlying/// `write`, thereby bypassing one layer of indirection./// You may alternatively use [`FormattingOptions::create_formatter()`]./// Creates a new formatter based on this one with given [`FormattingOptions`]."format_arguments"/// This structure represents a safely precompiled version of a format string/// and its arguments. This cannot be generated at runtime because it cannot/// safely be done, so no constructors are given and the fields are private/// to prevent modification./// The [`format_args!`] macro will safely create an instance of this structure./// The macro validates the format string at compile-time so usage of the/// [`write()`] and [`format()`] functions can be safely performed./// You can use the `Arguments<'a>` that [`format_args!`] returns in `Debug`/// and `Display` contexts as seen below. The example also shows that `Debug`/// and `Display` format to the same thing: the interpolated format string/// in `format_args!`./// let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));/// let display = format!("{}", format_args!("{} foo {:?}", 1, 2));/// assert_eq!("1 foo 2", display);/// assert_eq!(display, debug);/// [`format()`]: ../../std/fmt/fn.format.html// Internal representation:// fmt::Arguments is represented in one of two ways:// 1) String literal representation (e.g. format_args!("hello"))//             ┌────────────────────────────────┐//   template: │           *const u8            │ ─▷ "hello"//             ├──────────────────────────────┬─┤//   args:     │             len              │1│ (lowest bit is 1; field contains `len << 1 | 1`)//             └──────────────────────────────┴─┘//   In this representation, there are no placeholders and `fmt::Arguments::as_str()` returns Some.//   The pointer points to the start of a static `str`. The length is given by `args as usize >> 1`.//   (The length of a `&str` is isize::MAX at most, so it always fits in a usize minus one bit.)//   `fmt::Arguments::from_str()` constructs this representation from a `&'static str`.// 2) Placeholders representation (e.g. format_args!("hello {name}\n"))//   template: │           *const u8            │ ─▷ b"\x06hello \xC0\x01\n\x00"//             ├────────────────────────────────┤//   args:     │     &'a [Argument<'a>; _]     0│ (lower bit is 0 due to alignment of Argument type)//             └────────────────────────────────┘//   In this representation, the template is a byte sequence encoding both the literal string pieces//   and the placeholders (including their options/flags).//   The `args` pointer points to an array of `fmt::Argument<'a>` values, of sufficient length to//   match the placeholders in the template.//   `fmt::Arguments::new()` constructs this representation from a template byte slice and a slice//   of arguments. This function is unsafe, as the template is assumed to be valid and the args//   slice is assumed to have elements matching the template.//   The template byte sequence is the concatenation of parts of the following types://   - Literal string piece://         Pieces that must be formatted verbatim (e.g. "hello " and "\n" in "hello {name}\n")//         appear literally in the template byte sequence, prefixed by their length.//         For pieces of up to 127 bytes, these are  represented as a single byte containing the//         length followed directly by the bytes of the string://         ┌───┬────────────────────────────┐//         │len│    `len` bytes (utf-8)     │ (e.g. b"\x06hello ")//         └───┴────────────────────────────┘//         For larger pieces up to u16::MAX bytes, these are  represented as a 0x80 followed by//         their length in 16-bit little endian, followed by the bytes of the string://         ┌────┬─────────┬───────────────────────────┐//         │0x80│   len   │   `len` bytes (utf-8)     │ (e.g. b"\x80\x00\x01hello … ")//         └────┴─────────┴───────────────────────────┘//         Longer pieces are split into multiple pieces of max u16::MAX bytes (at utf-8 boundaries).//   - Placeholder://         Placeholders (e.g. `{name}` in "hello {name}") are represented as a byte with the highest//         two bits set, followed by zero or more fields depending on the flags in the first byte://         ┌──────────┬┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┬┄┄┄┄┄┄┄┄┄┄┄┬┄┄┄┄┄┄┄┄┄┄┄┬┄┄┄┄┄┄┄┄┄┄┄┐//         │0b11______│       flags       ┊   width   ┊ precision ┊ arg_index ┊ (e.g. b"\xC2\x05\0")//         └────││││││┴┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┴┄┄┄┄┄┄┄┄┄┄┄┴┄┄┄┄┄┄┄┄┄┄┄┴┄┄┄┄┄┄┄┄┄┄┄┘//              ││││││        32 bit          16 bit      16 bit      16 bit//              │││││└─ flags present//              ││││└─ width present//              │││└─ precision present//              ││└─ arg_index present//              │└─ width indirect//              └─ precision indirect//         All fields other than the first byte are optional and only present when their//         corresponding flag is set in the first byte.//         So, a fully default placeholder without any options is just a single byte://         ┌──────────┐//         │0b11000000│ (b"\xC0")//         └──────────┘//         The fields are stored as little endian.//         The `flags` fields corresponds to the `flags` field of `FormattingOptions`.//         See doc comment of `FormattingOptions::flags` for details.//         The `width` and `precision` fields correspond to their respective fields in//         `FormattingOptions`. However, if their "indirect" flag is set, the field contains the//         index in the `args` array where the dynamic width or precision is stored, rather than the//         value directly.//         The `arg_index` field is the index into the `args` array for the argument to be//         formatted.//         If omitted, the flags, width and precision of the default FormattingOptions::new() are//         used.//         If the `arg_index` is omitted, the next argument in the `args` array is used (starting//         at 0).//   - End://         A single zero byte marks the end of the template://         ┌───┐//         │ 0 │ ("\0")//         └───┘//         (Note that a zero byte may also occur naturally as part of the string pieces or flags,//         width, precision and arg_index fields above. That is, the template byte sequence ends//         with a 0 byte, but isn't terminated by the first 0 byte.)// SAFETY: The caller must ensure that the provided template and args encode a valid// fmt::Arguments, as documented above.from_str_nonconst// Same as `from_str`, but not const.// Used by format_args!() expansion when arguments are inlined,// e.g. format_args!("{}", 123), which is not allowed in const."FmtArgumentsNew"/// Used by the format_args!() macro to create a fmt::Arguments object.estimated_capacity/// Estimates the length of the formatted text./// This is intended to be used for setting initial `String` capacity/// when using `format!`. Note: this is neither the lower nor upper bound./// Create a `fmt::Arguments` object for a single static string./// Formatting this `fmt::Arguments` will just produce the string as-is./// Gets the formatted string, if it has no arguments to be formatted at runtime./// This can be used to avoid allocations in some cases./// For `format_args!("just a literal")`, this function is guaranteed to/// return `Some("just a literal")`./// For most cases with placeholders, this function will return `None`./// However, the compiler may perform optimizations that can cause this/// function to return `Some(_)` even if the format string contains/// placeholders. For example, `format_args!("Hello, {}!", "world")` may be/// optimized to `format_args!("Hello, world!")`, such that `as_str()`/// returns `Some("Hello, world!")`./// The behavior for anything but the trivial case (without placeholders)/// is not guaranteed, and should not be relied upon for anything other/// than optimization./// use std::fmt::Arguments;/// fn write_str(_: &str) { /* ... */ }/// fn write_fmt(args: &Arguments<'_>) {///     if let Some(s) = args.as_str() {///         write_str(s)///         write_str(&args.to_string());/// assert_eq!(format_args!("hello").as_str(), Some("hello"));/// assert_eq!(format_args!("").as_str(), Some(""));/// assert_eq!(format_args!("{:?}", std::env::current_dir()).as_str(), None);as_statically_known_str/// Same as [`Arguments::as_str`], but will only return `Some(s)` if it can be determined at compile time.// Manually implementing these results in better error messages./// struct Position {///     longitude: f32,///     latitude: f32,/// impl fmt::Debug for Position {///         f.debug_tuple("")///          .field(&self.longitude)///          .field(&self.latitude)///          .finish()/// let position = Position { longitude: 1.987, latitude: 2.983 };/// assert_eq!(format!("{position:?}"), "(1.987, 2.983)");/// assert_eq!(format!("{position:#?}"), "(///     1.987,///     2.983,/// )");"Debug"/// `?` formatting./// `Debug` should format the output in a programmer-facing, debugging context./// Generally speaking, you should just `derive` a `Debug` implementation./// When used with the alternate format specifier `#?`, the output is pretty-printed./// For more information on formatters, see [the module-level documentation][module]./// [module]: ../../std/fmt/index.html/// This trait can be used with `#[derive]` if all fields implement `Debug`. When/// `derive`d for structs, it will use the name of the `struct`, then `{`, then a/// comma-separated list of each field's name and `Debug` value, then `}`. For/// `enum`s, it will use the name of the variant and, if applicable, `(`, then the/// `Debug` values of the fields, then `)`./// Derived `Debug` formats are not stable, and so may change with future Rust/// versions. Additionally, `Debug` implementations of types provided by the/// standard library (`std`, `core`, `alloc`, etc.) are not stable, and/// may also change with future Rust versions./// Deriving an implementation:///     x: i32,///     y: i32,/// let origin = Point { x: 0, y: 0 };///     format!("The origin is: {origin:?}"),///     "The origin is: Point { x: 0, y: 0 }",/// Manually implementing:/// impl fmt::Debug for Point {///         f.debug_struct("Point")///          .field("x", &self.x)///          .field("y", &self.y)/// There are a number of helper methods on the [`Formatter`] struct to help you with manual/// implementations, such as [`debug_struct`]./// [`debug_struct`]: Formatter::debug_struct/// Types that do not wish to use the standard suite of debug representations/// provided by the `Formatter` trait (`debug_struct`, `debug_tuple`,/// `debug_list`, `debug_set`, `debug_map`) can do something totally custom by/// manually writing an arbitrary representation to the `Formatter`./// # struct Point {/// #     x: i32,/// #     y: i32,///         write!(f, "Point [{} {}]", self.x, self.y)/// `Debug` implementations using either `derive` or the debug builder API/// on [`Formatter`] support pretty-printing using the alternate flag: `{:#?}`./// Pretty-printing with `#?`:/// let expected = "The origin is: Point {///     x: 0,///     y: 0,/// }";/// assert_eq!(format!("The origin is: {origin:#?}"), expected);/// Derive macro generating an impl of the trait `Debug`.// Separate module to reexport the macro `Debug` from prelude without the trait `Debug`./// impl fmt::Display for Position {///         write!(f, "({}, {})", self.longitude, self.latitude)///     "(1.987, 2.983)",///     format!("{}", Position { longitude: 1.987, latitude: 2.983, }),"Display"/// Format trait for an empty format, `{}`./// Implementing this trait for a type will automatically implement the/// [`ToString`][tostring] trait for the type, allowing the usage/// of the [`.to_string()`][tostring_function] method. Prefer implementing/// the `Display` trait for a type, rather than [`ToString`][tostring]./// `Display` is similar to [`Debug`], but `Display` is for user-facing/// output, and so cannot be derived./// [tostring]: ../../std/string/trait.ToString.html/// [tostring_function]: ../../std/string/trait.ToString.html#tymethod.to_string/// # Completeness and parseability/// `Display` for a type might not necessarily be a lossless or complete representation of the type./// It may omit internal state, precision, or other information the type does not consider important/// for user-facing output, as determined by the type. As such, the output of `Display` might not be/// possible to parse, and even if it is, the result of parsing might not exactly match the original/// However, if a type has a lossless `Display` implementation whose output is meant to be/// conveniently machine-parseable and not just meant for human consumption, then the type may wish/// to accept the same format in `FromStr`, and document that usage. Having both `Display` and/// `FromStr` implementations where the result of `Display` cannot be parsed with `FromStr` may/// surprise users./// # Internationalization/// Because a type can only have one `Display` implementation, it is often preferable/// to only implement `Display` when there is a single most "obvious" way that/// values can be formatted as text. This could mean formatting according to the/// "invariant" culture and "undefined" locale, or it could mean that the type/// display is designed for a specific culture/locale, such as developer logs./// If not all values have a justifiably canonical textual format or if you want/// to support alternative formats not covered by the standard set of possible/// [formatting traits], the most flexible approach is display adapters: methods/// like [`str::escape_default`] or [`Path::display`] which create a wrapper/// implementing `Display` to output the specific display format./// [formatting traits]: ../../std/fmt/index.html#formatting-traits/// [`Path::display`]: ../../std/path/struct.Path.html#method.display/// Implementing `Display` on a type:/// impl fmt::Display for Point {///         write!(f, "({}, {})", self.x, self.y)/// assert_eq!(format!("The origin is: {origin}"), "The origin is: (0, 0)");/// `o` formatting./// The `Octal` trait should format its output as a number in base-8./// For primitive signed integers (`i8` to `i128`, and `isize`),/// negative values are formatted as the two’s complement representation./// The alternate flag, `#`, adds a `0o` in front of the output./// Basic usage with `i32`:/// let x = 42; // 42 is '52' in octal/// assert_eq!(format!("{x:o}"), "52");/// assert_eq!(format!("{x:#o}"), "0o52");/// assert_eq!(format!("{:o}", -16), "37777777760");/// Implementing `Octal` on a type:/// struct Length(i32);/// impl fmt::Octal for Length {///         let val = self.0;///         fmt::Octal::fmt(&val, f) // delegate to i32's implementation/// let l = Length(9);/// assert_eq!(format!("l as octal is: {l:o}"), "l as octal is: 11");/// assert_eq!(format!("l as octal is: {l:#06o}"), "l as octal is: 0o0011");/// `b` formatting./// The `Binary` trait should format its output as a number in binary./// For primitive signed integers ([`i8`] to [`i128`], and [`isize`]),/// The alternate flag, `#`, adds a `0b` in front of the output./// Basic usage with [`i32`]:/// let x = 42; // 42 is '101010' in binary/// assert_eq!(format!("{x:b}"), "101010");/// assert_eq!(format!("{x:#b}"), "0b101010");/// assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");/// Implementing `Binary` on a type:/// impl fmt::Binary for Length {///         fmt::Binary::fmt(&val, f) // delegate to i32's implementation/// let l = Length(107);/// assert_eq!(format!("l as binary is: {l:b}"), "l as binary is: 1101011");///     // Note that the `0b` prefix added by `#` is included in the total width, so we///     // need to add two to correctly display all 32 bits.///     format!("l as binary is: {l:#034b}"),///     "l as binary is: 0b00000000000000000000000001101011"/// `x` formatting./// The `LowerHex` trait should format its output as a number in hexadecimal, with `a` through `f`/// in lower case./// The alternate flag, `#`, adds a `0x` in front of the output./// let y = 42; // 42 is '2a' in hex/// assert_eq!(format!("{y:x}"), "2a");/// assert_eq!(format!("{y:#x}"), "0x2a");/// assert_eq!(format!("{:x}", -16), "fffffff0");/// Implementing `LowerHex` on a type:/// impl fmt::LowerHex for Length {///         fmt::LowerHex::fmt(&val, f) // delegate to i32's implementation/// assert_eq!(format!("l as hex is: {l:x}"), "l as hex is: 9");/// assert_eq!(format!("l as hex is: {l:#010x}"), "l as hex is: 0x00000009");/// `X` formatting./// The `UpperHex` trait should format its output as a number in hexadecimal, with `A` through `F`/// in upper case./// let y = 42; // 42 is '2A' in hex/// assert_eq!(format!("{y:X}"), "2A");/// assert_eq!(format!("{y:#X}"), "0x2A");/// assert_eq!(format!("{:X}", -16), "FFFFFFF0");/// Implementing `UpperHex` on a type:/// impl fmt::UpperHex for Length {///         fmt::UpperHex::fmt(&val, f) // delegate to i32's implementation/// let l = Length(i32::MAX);/// assert_eq!(format!("l as hex is: {l:X}"), "l as hex is: 7FFFFFFF");/// assert_eq!(format!("l as hex is: {l:#010X}"), "l as hex is: 0x7FFFFFFF");"Pointer"/// `p` formatting./// The `Pointer` trait should format its output as a memory location. This is commonly presented/// as hexadecimal. For more information on formatters, see [the module-level documentation][module]./// Printing of pointers is not a reliable way to discover how Rust programs are implemented./// The act of reading an address changes the program itself, and may change how the data is represented/// in memory, and may affect which optimizations are applied to the code./// The printed pointer values are not guaranteed to be stable nor unique identifiers of objects./// Rust allows moving values to different memory locations, and may reuse the same memory locations/// for different purposes./// There is no guarantee that the printed value can be converted back to a pointer./// Basic usage with `&i32`:/// let x = &42;/// let address = format!("{x:p}"); // this produces something like '0x7f06092ac6d0'/// Implementing `Pointer` on a type:/// impl fmt::Pointer for Length {///         // use `as` to convert to a `*const T`, which implements Pointer, which we can use///         let ptr = self as *const Self;///         fmt::Pointer::fmt(&ptr, f)/// let l = Length(42);/// println!("l is in memory here: {l:p}");/// let l_ptr = format!("{l:018p}");/// assert_eq!(l_ptr.len(), 18);/// assert_eq!(&l_ptr[..2], "0x");/// `e` formatting./// The `LowerExp` trait should format its output in scientific notation with a lower-case `e`./// Basic usage with `f64`:/// let x = 42.0; // 42.0 is '4.2e1' in scientific notation/// assert_eq!(format!("{x:e}"), "4.2e1");/// Implementing `LowerExp` on a type:/// impl fmt::LowerExp for Length {///         let val = f64::from(self.0);///         fmt::LowerExp::fmt(&val, f) // delegate to f64's implementation/// let l = Length(100);///     format!("l in scientific notation is: {l:e}"),///     "l in scientific notation is: 1e2"///     format!("l in scientific notation is: {l:05e}"),///     "l in scientific notation is: 001e2"/// `E` formatting./// The `UpperExp` trait should format its output in scientific notation with an upper-case `E`./// let x = 42.0; // 42.0 is '4.2E1' in scientific notation/// assert_eq!(format!("{x:E}"), "4.2E1");/// Implementing `UpperExp` on a type:/// impl fmt::UpperExp for Length {///         fmt::UpperExp::fmt(&val, f) // delegate to f64's implementation///     format!("l in scientific notation is: {l:E}"),///     "l in scientific notation is: 1E2"///     format!("l in scientific notation is: {l:05E}"),///     "l in scientific notation is: 001E2"/// Takes an output stream and an `Arguments` struct that can be precompiled with/// the `format_args!` macro./// The arguments will be formatted according to the specified format string/// into the output stream provided./// fmt::write(&mut output, format_args!("Hello {}!", "world"))///     .expect("Error occurred while trying to write in String");/// assert_eq!(output, "Hello world!");/// Please note that using [`write!`] might be preferable. Example:/// write!(&mut output, "Hello {}!", "world")/// [`write!`]: crate::write!"don't forget to write the post padding"PostPadding/// Padding after the end of something. Returned by `Formatter::padding`./// Writes this post padding.wrap_bufpad_integral/// Performs the correct padding for an integer which has already been/// emitted into a str. The str should *not* contain the sign for the/// integer, that will be added by this method./// * is_nonnegative - whether the original integer was either positive or zero./// * prefix - if the '#' character (Alternate) is provided, this///   is the prefix to put in front of the number./// * buf - the byte array that the number has been formatted into/// This function will correctly account for the flags provided as well as/// the minimum width. It will not take precision into account./// struct Foo { nb: i32 }///     fn new(nb: i32) -> Foo {///         Foo {///             nb,/// impl fmt::Display for Foo {///     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {///         // We need to remove "-" from the number output.///         let tmp = self.nb.abs().to_string();///         formatter.pad_integral(self.nb >= 0, "Foo ", &tmp)/// assert_eq!(format!("{}", Foo::new(2)), "2");/// assert_eq!(format!("{}", Foo::new(-1)), "-1");/// assert_eq!(format!("{}", Foo::new(0)), "0");/// assert_eq!(format!("{:#}", Foo::new(-1)), "-Foo 1");/// assert_eq!(format!("{:0>#8}", Foo::new(-1)), "00-Foo 1");/// Takes a string slice and emits it to the internal buffer after applying/// the relevant formatting flags specified./// The flags recognized for generic strings are:/// * width - the minimum width of what to emit/// * fill/align - what to emit and where to emit it if the string///                provided needs to be padded/// * precision - the maximum length to emit, the string is truncated if it///               is longer than this length/// Notably this function ignores the `flag` parameters.///         formatter.pad("Foo")/// assert_eq!(format!("{Foo:<4}"), "Foo ");/// assert_eq!(format!("{Foo:0>4}"), "0Foo");/// Writes the pre-padding and returns the unwritten post-padding./// Callers are responsible for ensuring post-padding is written after the/// thing that is being padded.pad_formatted_parts/// Takes the formatted parts and applies the padding./// Assumes that the caller already has rendered the parts with required precision,/// so that `self.precision` can be ignored./// Any `numfmt::Part::Copy` parts in `formatted` must contain valid UTF-8.write_formatted_parts/// Writes some data to the underlying buffer contained within this///         formatter.write_str("Foo")///         // This is equivalent to:///         // write!(formatter, "Foo")/// assert_eq!(format!("{Foo}"), "Foo");/// assert_eq!(format!("{Foo:0>8}"), "Foo");/// Writes some formatted information into this instance./// struct Foo(i32);///         formatter.write_fmt(format_args!("Foo {}", self.0))/// assert_eq!(format!("{}", Foo(-1)), "Foo -1");/// assert_eq!(format!("{:0>8}", Foo(2)), "Foo 2");/// Returns flags for formatting./// Returns the character used as 'fill' whenever there is alignment.///         let c = formatter.fill();///         if let Some(width) = formatter.width() {///             for _ in 0..width {///                 write!(formatter, "{c}")?;///             write!(formatter, "{c}")/// // We set alignment to the right with ">"./// assert_eq!(format!("{Foo:G>3}"), "GGG");/// assert_eq!(format!("{Foo:t>6}"), "tttttt");/// Returns a flag indicating what form of alignment was requested./// use std::fmt::{self, Alignment};///         let s = if let Some(s) = formatter.align() {///             match s {///                 Alignment::Left    => "left",///                 Alignment::Right   => "right",///                 Alignment::Center  => "center",///             "into the void"///         write!(formatter, "{s}")/// assert_eq!(format!("{Foo:<}"), "left");/// assert_eq!(format!("{Foo:>}"), "right");/// assert_eq!(format!("{Foo:^}"), "center");/// assert_eq!(format!("{Foo}"), "into the void");/// Returns the optionally specified integer width that the output should be.///             // If we received a width, we use it///             write!(formatter, "{:width$}", format!("Foo({})", self.0), width = width)///             // Otherwise we do nothing special///             write!(formatter, "Foo({})", self.0)/// assert_eq!(format!("{:10}", Foo(23)), "Foo(23)   ");/// assert_eq!(format!("{}", Foo(23)), "Foo(23)");/// Returns the optionally specified precision for numeric types./// Alternatively, the maximum width for string types./// struct Foo(f32);///         if let Some(precision) = formatter.precision() {///             // If we received a precision, we use it.///             write!(formatter, "Foo({1:.*})", precision, self.0)///             // Otherwise we default to 2.///             write!(formatter, "Foo({:.2})", self.0)/// assert_eq!(format!("{:.4}", Foo(23.2)), "Foo(23.2000)");/// assert_eq!(format!("{}", Foo(23.2)), "Foo(23.20)");///         if formatter.sign_plus() {///             write!(formatter,///                    "Foo({}{})",///                    if self.0 < 0 { '-' } else { '+' },///                    self.0.abs())/// assert_eq!(format!("{:+}", Foo(23)), "Foo(+23)");/// assert_eq!(format!("{:+}", Foo(-23)), "Foo(-23)");///         if formatter.sign_minus() {///             // You want a minus sign? Have one!///             write!(formatter, "-Foo({})", self.0)/// assert_eq!(format!("{:-}", Foo(23)), "-Foo(23)");///         if formatter.alternate() {///             write!(formatter, "{}", self.0)/// assert_eq!(format!("{:#}", Foo(23)), "Foo(23)");/// assert_eq!(format!("{}", Foo(23)), "23");///         assert!(formatter.sign_aware_zero_pad());///         assert_eq!(formatter.width(), Some(4));///         // We ignore the formatter's options.///         write!(formatter, "{}", self.0)/// assert_eq!(format!("{:04}", Foo(23)), "23");debug_lower_hex// FIXME: Decide what public API we want for these two flags.// https://github.com/rust-lang/rust/issues/48584debug_upper_hex/// Creates a [`DebugStruct`] builder designed to assist with creation of/// [`fmt::Debug`] implementations for structs./// [`fmt::Debug`]: self::Debug///     addr: Ipv4Addr,///             .field("bar", &self.bar)///             .field("baz", &self.baz)///             .field("addr", &format_args!("{}", self.addr))///             .finish()///     "Foo { bar: 10, baz: \"Hello World\", addr: 127.0.0.1 }",///     format!("{:?}", Foo {///         bar: 10,///         baz: "Hello World".to_string(),///         addr: Ipv4Addr::new(127, 0, 0, 1),debug_struct_field1_finish/// Shrinks `derive(Debug)` code, for faster compilation and smaller/// binaries. `debug_struct_fields_finish` is more general, but this is/// faster for 1 field.debug_struct_field2_finish/// faster for 2 fields.debug_struct_field3_finish/// faster for 3 fields.debug_struct_field4_finish/// faster for 4 fields.debug_struct_field5_finish/// faster for 5 fields.debug_struct_fields_finish/// Shrinks `derive(Debug)` code, for faster compilation and smaller binaries./// For the cases not covered by `debug_struct_field[12345]_finish`./// Creates a `DebugTuple` builder designed to assist with creation of/// `fmt::Debug` implementations for tuple structs./// struct Foo<T>(i32, String, PhantomData<T>);/// impl<T> fmt::Debug for Foo<T> {///             .field(&self.0)///             .field(&self.1)///             .field(&format_args!("_"))///     "Foo(10, \"Hello\", _)",///     format!("{:?}", Foo(10, "Hello".to_string(), PhantomData::<u8>))debug_tuple_field1_finish/// binaries. `debug_tuple_fields_finish` is more general, but this is faster/// for 1 field.debug_tuple_field2_finish/// for 2 fields.debug_tuple_field3_finish/// for 3 fields.debug_tuple_field4_finish/// for 4 fields.debug_tuple_field5_finish/// for 5 fields.debug_tuple_fields_finish/// binaries. For the cases not covered by `debug_tuple_field[12345]_finish`./// Creates a `DebugList` builder designed to assist with creation of/// `fmt::Debug` implementations for list-like structures./// assert_eq!(format!("{:?}", Foo(vec![10, 11])), "[10, 11]");/// Creates a `DebugSet` builder designed to assist with creation of/// `fmt::Debug` implementations for set-like structures./// assert_eq!(format!("{:?}", Foo(vec![10, 11])), "{10, 11}");/// [`format_args!`]: crate::format_args/// In this more complex example, we use [`format_args!`] and `.debug_set()`/// to build a list of match arms:/// struct Arm<'a, L, R>(&'a (L, R));/// struct Table<'a, K, V>(&'a [(K, V)], V);/// impl<'a, L, R> fmt::Debug for Arm<'a, L, R>///     L: 'a + fmt::Debug, R: 'a + fmt::Debug///         L::fmt(&(self.0).0, fmt)?;///         fmt.write_str(" => ")?;///         R::fmt(&(self.0).1, fmt)/// impl<'a, K, V> fmt::Debug for Table<'a, K, V>///     K: 'a + fmt::Debug, V: 'a + fmt::Debug///         .entries(self.0.iter().map(Arm))///         .entry(&Arm(&(format_args!("_"), &self.1)))debug_map/// Creates a `DebugMap` builder designed to assist with creation of/// `fmt::Debug` implementations for map-like structures.///     format!("{:?}",  Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),///     r#"{"A": 10, "B": 11}"#///  );/// Returns the sign of this formatter (`+` or `-`)./// Returns the formatting options this formatter corresponds to.// Helper methods used for padding and processing formatting arguments that// all formatting traits can use.fmt_refspointer_fmt_inner/// Since the formatting will be identical for all pointer types, uses a/// non-monomorphized implementation for the actual formatting to reduce the/// amount of codegen work needed./// This uses `ptr_addr: usize` and not `ptr: *const ()` to be able to use this for/// `fn(...) -> ...` without using [problematic] "Oxford Casts"./// [problematic]: https://github.com/rust-lang/rust/issues/95489maybe_tuple_doc"This trait is implemented for tuples up to twelve items long."//! Utilities for formatting and printing strings.// Implementations of the core formatting traits// Implementation of Display/Debug for various core types// If you expected tests to be here, look instead at coretests/tests/fmt/;// it's a lot easier than creating all of the rt::Piece structures here.// There are also tests in alloctests/tests/fmt.rs, for those that need allocations.radix_integer/// Formatting of integers with a non-decimal radix.radix_integersr" Format unsigned integers in the radix."r" Format signed integers in the two’s-complement form."impl_DebugDECIMAL_PAIRS// The string of all two-digit numbers in range 00..99 is used as a lookup table.slice_buffer_to_str/// This function converts a slice of ascii characters into a `&str` starting from `offset`./// `buf` content starting from `offset` index MUST BE initialized and MUST BE asciiimpl_Displayimpl_Exp_fmt_fmt_innerr" Allows users to write an integer (in signed decimal format) into a variable `buf` of"r" type [`NumBuffer`] that is passed by the caller by mutable reference."r" #![feature(int_format_into)]"r" use core::fmt::NumBuffer;"r" let mut buf = NumBuffer::new();"r#" assert_eq!(n.format_into(&mut buf), "0");"#r#" assert_eq!(n1.format_into(&mut buf), "32");"#exp_u64// Include wasm32 in here since it doesn't reflect the native pointer size, and// often cares strongly about getting a smaller code size.exp_u128U128_MAX_DEC_N/// Format optimized for u128. Computation of 128 bits is limited by processing/// in batches of 16 decimals at a time./// Allows users to write an integer (in signed decimal format) into a variable `buf` of/// type [`NumBuffer`] that is passed by the caller by mutable reference./// #![feature(int_format_into)]/// use core::fmt::NumBuffer;/// let n = 0u128;/// let mut buf = NumBuffer::new();/// assert_eq!(n.format_into(&mut buf), "0");/// let n1 = 32u128;/// let mut buf1 = NumBuffer::new();/// assert_eq!(n1.format_into(&mut buf1), "32");/// let n2 = u128::MAX;/// let mut buf2 = NumBuffer::new();/// assert_eq!(n2.format_into(&mut buf2), u128::MAX.to_string());/// let n = 0i128;/// let n1 = i128::MIN;/// assert_eq!(n1.format_into(&mut buf), i128::MIN.to_string());/// let n2 = i128::MAX;/// assert_eq!(n2.format_into(&mut buf), i128::MAX.to_string());enc_16lsd/// Encodes the 16 least-significant decimals of n into `buf[OFFSET .. OFFSET +/// 16 ]`.div_rem_1e16/// Euclidean division plus remainder with constant 1E16 basically consumes 16/// decimals from n./// The integer division algorithm is based on the following paper://! Integer and floating-point number formatting/// Maximum number of digits in decimal base of the implemented integer./// Trait used to describe the maximum number of digits in decimal base of the implemented integer.impl_NumBufferTrait// FIXME: Once const generics feature is working, use `T::BUF_SIZE` instead of 40.// FIXME: Remove this field once we can actually use `T`./// A buffer wrapper of which the internal size is based on the maximum/// number of digits the associated integer can have./// Initializes internal buffer./// Returns the length of the internal buffer.// INVARIANT: `formatter` has type `fn(&T, _) -> _` for some `T`, and `value`// was derived from a `&'a T`.Placeholder"format_argument"/// This struct represents a generic "argument" which is taken by format_args!()./// This can be either a placeholder argument or a count argument./// * A placeholder argument contains a function to format the given value. At///   compile time it is ensured that the function and the value have the correct///   types, and then this struct is used to canonicalize arguments to one type.///   Placeholder arguments are essentially an optimized partially applied formatting///   function, equivalent to `exists T.(&T, fn(&T, &mut Formatter<'_>) -> Result`./// * A count argument contains a count for dynamic formatting parameters like///   precision and width.// To ensure pointers to this struct always have their lowest bit cleared.argument_newnew_displaynew_debug_noopnew_octalnew_lower_hexnew_upper_hexnew_binarynew_lower_expnew_upper_exp/// Format this placeholder argument./// This argument must actually be a placeholder argument.//! All types and methods in this file are used by the compiler in//! the expansion/lowering of format_args!().//! Do not modify them without understanding the consequences for the format_args!() macro./// Executes the async destructor for this type./// This method is called implicitly when the value goes out of scope,/// and cannot be called explicitly./// When this method has been called, `self` has not yet been deallocated./// That only happens after the method is over."async_drop"/// Async version of Drop trait./// When a value is no longer needed, Rust will run a "destructor" on that value./// The most common way that a value is no longer needed is when it goes out of/// scope. Destructors may still run in other circumstances, but we're going to/// focus on scope for the examples here. To learn about some of those other cases,/// please see [the reference] section on destructors./// [the reference]: https://doc.rust-lang.org/reference/destructors.html/// ## `Copy` and ([`Drop`]|`AsyncDrop`) are exclusive/// You cannot implement both [`Copy`] and ([`Drop`]|`AsyncDrop`) on the same type. Types that/// are `Copy` get implicitly duplicated by the compiler, making it very/// hard to predict when, and how often destructors will be executed. As such,/// these types cannot have destructors."async_drop_in_place"async_drop_in_place/// Async drop."future_output""poll"/// Attempts to resolve the future to a final value, registering/// the current task for wakeup if the value is not yet available./// - [`Poll::Pending`] if the future is not ready yet/// - [`Poll::Ready(val)`] with the result `val` of this future if it///   finished successfully./// Once a future has finished, clients should not `poll` it again./// When a future is not ready yet, `poll` returns `Poll::Pending` and/// stores a clone of the [`Waker`] copied from the current [`Context`]./// This [`Waker`] is then woken once the future can make progress./// For example, a future waiting for a socket to become/// readable would call `.clone()` on the [`Waker`] and store it./// When a signal arrives elsewhere indicating that the socket is readable,/// [`Waker::wake`] is called and the socket future's task is awoken./// Once a task has been woken up, it should attempt to `poll` the future/// again, which may or may not produce a final value./// Note that on multiple calls to `poll`, only the [`Waker`] from the/// [`Context`] passed to the most recent call should be scheduled to/// # Runtime characteristics/// Futures alone are *inert*; they must be *actively* `poll`ed for the/// underlying computation to make progress, meaning that each time the/// current task is woken up, it should actively re-`poll` pending futures/// that it still has an interest in./// Having said that, some Futures may represent a value that is being/// computed in a different task. In this case, the future's underlying/// computation is simply acting as a conduit for a value being computed/// by that other task, which will proceed independently of the Future./// Futures of this kind are typically obtained when spawning a new task into an/// async runtime./// The `poll` function should not be called repeatedly in a tight loop --/// instead, it should only be called when the future indicates that it is/// ready to make progress (by calling `wake()`). If you're familiar with the/// `poll(2)` or `select(2)` syscalls on Unix it's worth noting that futures/// typically do *not* suffer the same problems of "all wakeups must poll/// all events"; they are more like `epoll(4)`./// An implementation of `poll` should strive to return quickly, and should/// not block. Returning quickly prevents unnecessarily clogging up/// threads or event loops. If it is known ahead of time that a call to/// `poll` may end up taking a while, the work should be offloaded to a/// thread pool (or something similar) to ensure that `poll` can return/// quickly./// Once a future has completed (returned `Ready` from `poll`), calling its/// `poll` method again may panic, block forever, or cause other kinds of/// problems; the `Future` trait places no requirements on the effects of/// such a call. However, as the `poll` method is not marked `unsafe`,/// regardless of the future's state./// [`Poll::Ready(val)`]: Poll::Ready/// [`Waker`]: crate::task::Waker/// [`Waker::wake`]: crate::task::Waker::wake"future_trait"/// A future represents an asynchronous computation, commonly obtained by use of/// [`async`]./// A future is a value that might not have finished computing yet. This kind of/// "asynchronous value" makes it possible for a thread to continue doing useful/// work while it waits for the value to become available./// # The `poll` method/// The core method of future, `poll`, *attempts* to resolve the future into a/// final value. This method does not block if the value is not ready. Instead,/// the current task is scheduled to be woken up when it's possible to make/// further progress by `poll`ing again. The `context` passed to the `poll`/// method can provide a [`Waker`], which is a handle for waking up the current/// When using a future, you generally won't call `poll` directly, but instead/// `.await` the value./// [`async`]: ../../std/keyword.async.html/// The output that the future will produce on completion./// Which kind of future are we turning this into?"into_future"/// Creates a future from a value./// use std::future::IntoFuture;/// # async fn foo() {/// let v = async { "meow" };/// let mut fut = v.into_future();/// assert_eq!("meow", fut.await);"IntoFuture"/// Conversion into a `Future`./// By implementing `IntoFuture` for a type, you define how it will be/// converted to a future./// # `.await` desugaring/// The `.await` keyword desugars into a call to `IntoFuture::into_future`/// first before polling the future to completion. `IntoFuture` is implemented/// for all `T: Future` which means the `into_future` method will be available/// on all futures./// # Async builders/// When implementing futures manually there will often be a choice between/// implementing `Future` or `IntoFuture` for a type. Implementing `Future` is a/// good choice in most cases. But implementing `IntoFuture` is most useful when/// implementing "async builder" types, which allow their values to be modified/// multiple times before being `.await`ed./// use std::future::{ready, Ready, IntoFuture};/// /// Eventually multiply two numbers/// pub struct Multiply {///     num: u16,///     factor: u16,/// impl Multiply {///     /// Constructs a new instance of `Multiply`.///     pub fn new(num: u16, factor: u16) -> Self {///         Self { num, factor }///     /// Set the number to multiply by the factor.///     pub fn number(mut self, num: u16) -> Self {///         self.num = num;///         self///     /// Set the factor to multiply the number with.///     pub fn factor(mut self, factor: u16) -> Self {///         self.factor = factor;/// impl IntoFuture for Multiply {///     type Output = u16;///     type IntoFuture = Ready<Self::Output>;///     fn into_future(self) -> Self::IntoFuture {///         ready(self.num * self.factor)/// // NOTE: Rust does not yet have an `async fn main` function, that functionality/// // currently only exists in the ecosystem.///     let num = Multiply::new(0, 0)  // initialize the builder to number: 0, factor: 0///         .number(2)                 // change the number to 2///         .factor(2)                 // change the factor to 2///         .await;                    // convert to future and .await///     assert_eq!(num, 4);/// # Usage in trait bounds/// Using `IntoFuture` in trait bounds allows a function to be generic over both/// `Future` and `IntoFuture`. This is convenient for users of the function, so/// when they are using it they don't have to make an extra call to/// `IntoFuture::into_future` to obtain an instance of `Future`:/// /// Converts the output of a future to a string./// async fn fut_to_string<Fut>(fut: Fut) -> String///     Fut: IntoFuture,///     Fut::Output: std::fmt::Debug,///     format!("{:?}", fut.await)/// Polls multiple futures simultaneously, returning a tuple/// of all results once complete./// While `join!(a, b).await` is similar to `(a.await, b.await)`,/// `join!` polls both futures concurrently and is therefore more efficient./// #![feature(future_join)]/// use std::future::join;/// async fn one() -> usize { 1 }/// async fn two() -> usize { 2 }/// # let _ =  async {/// let x = join!(one(), two()).await;/// assert_eq!(x, (1, 2));/// `join!` is variadic, so you can pass any number of futures:/// async fn three() -> usize { 3 }/// # let _ = async {/// let x = join!(one(), two(), three()).await;/// assert_eq!(x, (1, 2, 3));// FIXME(danielhenrymantilla): a private macro should need no stability guarantee./// To be able to *name* the i-th future in the tuple (say we want the .4-th),/// the following trick will be used: `let (_, _, _, _, it, ..) = tuple;`/// In order to do that, we need to generate a `i`-long repetition of `_`,/// for each i-th fut. Hence the recursive muncher approach.Taken/// Future used by `join!` that stores it's output to/// be later taken and doesn't panic when polled after ready./// This type is public in a private module for use by the macro.// items are used by the macro"ResumeTy"ResumeTy/// This type is needed because:/// a) Coroutines cannot implement `for<'a, 'b> Coroutine<&'a mut Context<'b>>`, so we need to pass///    a raw pointer (see <https://github.com/rust-lang/rust/issues/68923>)./// b) Raw pointers and `NonNull` aren't `Send` or `Sync`, so that would make every single future///    non-Send/Sync as well, and we don't want that./// It also simplifies the HIR lowering of `.await`."get_context"//! Asynchronous basic functionality.//! Please see the fundamental [`async`] and [`await`] keywords and the [async book]//! for more information on asynchronous programming in Rust.//! [`async`]: ../../std/keyword.async.html//! [`await`]: ../../std/keyword.await.html//! [async book]: https://rust-lang.github.io/async-book//// This `struct` is created by [`pending()`]. See its/// use std::future;/// Creates a future that wraps a function returning [`Poll`]./// Polling the future delegates to the wrapped function. If the returned future is pinned, then the/// captured environment of the wrapped function is also pinned in-place, so as long as the closure/// does not move out of its captures it can soundly create pinned references to them./// use core::future::poll_fn;/// ## Capturing a pinned state/// Example of a closure wrapping inner futures:/// use core::future::{self, Future};/// use core::task::Poll;/// /// Resolves to the first future that completes. In the event of a tie, `a` wins./// fn naive_select<T>(///     a: impl Future<Output = T>,///     b: impl Future<Output = T>,/// ) -> impl Future<Output = T>///     let (mut a, mut b) = (Box::pin(a), Box::pin(b));///     future::poll_fn(move |cx| {///         if let Poll::Ready(r) = a.as_mut().poll(cx) {///             Poll::Ready(r)///         } else if let Poll::Ready(r) = b.as_mut().poll(cx) {/// let a = async { 42 };/// let v = naive_select(a, b).await;/// assert_eq!(v, 42);/// let a = future::pending();/// let b = async { 27 };/// assert_eq!(v, 27);/// assert_eq!(v, 42); // biased towards `a` in case of tie!/// This time without [`Box::pin`]ning:/// [`Box::pin`]: ../../std/boxed/struct.Box.html#method.pin///         let (mut a, mut b) = (pin!(a), pin!(b));///         future::poll_fn(move |cx| {///             if let Poll::Ready(r) = a.as_mut().poll(cx) {///                 Poll::Ready(r)///             } else if let Poll::Ready(r) = b.as_mut().poll(cx) {///                 Poll::Pending///   - Notice how, by virtue of being in an `async` context, we have been able to make the [`pin!`]///     macro work, thereby avoiding any need for the `unsafe`///     <code>[Pin::new_unchecked](&mut fut)</code> constructor./// [`pin!`]: crate::pin::pin!/// A Future that wraps a function returning [`Poll`]./// This `struct` is created by [`poll_fn()`]. See its/// A future that is immediately ready with a value./// This `struct` is created by [`ready()`]. See its/// Consumes the `Ready`, returning the wrapped value./// Will panic if this [`Ready`] was already polled to completion./// assert_eq!(a.into_inner(), 1);/// Futures created through this function are functionally similar to those/// created through `async {}`. The main difference is that futures created/// through this function are named and implement `Unpin`./// Feeds this value into the given [`Hasher`]./// use std::hash::{DefaultHasher, Hash, Hasher};/// let mut hasher = DefaultHasher::new();/// 7920.hash(&mut hasher);hash_slice/// Feeds a slice of this type into the given [`Hasher`]./// This method is meant as a convenience, but its implementation is/// also explicitly left unspecified. It isn't guaranteed to be/// equivalent to repeated calls of [`hash`] and implementations of/// [`Hash`] should keep that in mind and call [`hash`] themselves/// if the slice isn't treated as a whole unit in the [`PartialEq`]/// For example, a [`VecDeque`] implementation might naïvely call/// [`as_slices`] and then [`hash_slice`] on each slice, but this/// is wrong since the two slices can change with a call to/// [`make_contiguous`] without affecting the [`PartialEq`]/// result. Since these slices aren't treated as singular/// units, and instead part of a larger deque, this method cannot/// let numbers = [6, 28, 496, 8128];/// Hash::hash_slice(&numbers, &mut hasher);/// [`VecDeque`]: ../../std/collections/struct.VecDeque.html/// [`as_slices`]: ../../std/collections/struct.VecDeque.html#method.as_slices/// [`make_contiguous`]: ../../std/collections/struct.VecDeque.html#method.make_contiguous/// [`hash`]: Hash::hash/// [`hash_slice`]: Hash::hash_slice"Hash"/// A hashable type./// Types implementing `Hash` are able to be [`hash`]ed with an instance of/// [`Hasher`]./// ## Implementing `Hash`/// You can derive `Hash` with `#[derive(Hash)]` if all fields implement `Hash`./// The resulting hash will be the combination of the values from calling/// [`hash`] on each field./// struct Rustacean {/// If you need more control over how a value is hashed, you can of course/// implement the `Hash` trait yourself:/// use std::hash::{Hash, Hasher};///     phone: u64,/// impl Hash for Person {///         self.id.hash(state);///         self.phone.hash(state);/// ## `Hash` and `Eq`/// When implementing both `Hash` and [`Eq`], it is important that the following/// In other words, if two keys are equal, their hashes must also be equal./// [`HashMap`] and [`HashSet`] both rely on this behavior./// Thankfully, you won't need to worry about upholding this property when/// deriving both [`Eq`] and `Hash` with `#[derive(PartialEq, Eq, Hash)]`./// ## Prefix collisions/// Implementations of `hash` should ensure that the data they/// pass to the `Hasher` are prefix-free. That is,/// values which are not equal should cause two different sequences of values to be written,/// and neither of the two sequences should be a prefix of the other./// For example, the standard implementation of [`Hash` for `&str`][impl] passes an extra/// `0xFF` byte to the `Hasher` so that the values `("ab", "c")` and `("a",/// "bc")` hash differently./// Due to differences in endianness and type sizes, data fed by `Hash` to a `Hasher`/// should not be considered portable across platforms. Additionally the data passed by most/// standard library types should not be considered stable between compiler versions./// This means tests shouldn't probe hard-coded hash values or data fed to a `Hasher` and/// instead should check consistency with `Eq`./// Serialization formats intended to be portable between platforms or compiler versions should/// either avoid encoding hashes or only rely on `Hash` and `Hasher` implementations that/// provide additional guarantees./// [impl]: ../../std/primitive.str.html#impl-Hash-for-str/// Derive macro generating an impl of the trait `Hash`.// Separate module to reexport the macro `Hash` from prelude without the trait `Hash`./// Despite its name, the method does not reset the hasher’s internal/// state. Additional [`write`]s will continue from the current value./// If you need to start a fresh hash value, you will have to create/// a new hasher./// use std::hash::{DefaultHasher, Hasher};/// hasher.write(b"Cool!");/// [`write`]: Hasher::write/// Writes some data into this `Hasher`./// let data = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];/// hasher.write(&data);/// # Note to Implementers/// You generally should not do length-prefixing as part of implementing/// this method.  It's up to the [`Hash`] implementation to call/// [`Hasher::write_length_prefix`] before sequences that need it./// Writes a single `u8` into this hasher./// Writes a single `u16` into this hasher./// Writes a single `u32` into this hasher./// Writes a single `u64` into this hasher./// Writes a single `u128` into this hasher./// Writes a single `usize` into this hasher./// Writes a single `i8` into this hasher./// Writes a single `i16` into this hasher./// Writes a single `i32` into this hasher./// Writes a single `i64` into this hasher./// Writes a single `i128` into this hasher./// Writes a single `isize` into this hasher./// Writes a length prefix into this hasher, as part of being prefix-free./// If you're implementing [`Hash`] for a custom collection, call this before/// writing its contents to this `Hasher`.  That way/// `(collection![1, 2, 3], collection![4, 5])` and/// `(collection![1, 2], collection![3, 4, 5])` will provide different/// sequences of values to the `Hasher`/// The `impl<T> Hash for [T]` includes a call to this method, so if you're/// hashing a slice (or array or vector) via its `Hash::hash` method,/// you should **not** call this yourself./// This method is only for providing domain separation.  If you want to/// hash a `usize` that represents part of the *data*, then it's important/// that you pass it to [`Hasher::write_usize`] instead of to this method./// #![feature(hasher_prefixfree_extras)]/// # // Stubs to make the `impl` below pass the compiler/// # struct MyCollection<T>(Option<T>);/// # impl<T> MyCollection<T> {/// #     fn len(&self) -> usize { todo!() }/// # impl<'a, T> IntoIterator for &'a MyCollection<T> {/// #     type Item = T;/// #     type IntoIter = std::iter::Empty<T>;/// #     fn into_iter(self) -> Self::IntoIter { todo!() }/// impl<T: Hash> Hash for MyCollection<T> {///         state.write_length_prefix(self.len());///         for elt in self {///             elt.hash(state);/// If you've decided that your `Hasher` is willing to be susceptible to/// Hash-DoS attacks, then you might consider skipping hashing some or all/// of the `len` provided in the name of increased performance./// Writes a single `str` into this hasher./// If you're implementing [`Hash`], you generally do not need to call this,/// as the `impl Hash for str` does, so you should prefer that instead./// This includes the domain separator for prefix-freedom, so you should/// **not** call `Self::write_length_prefix` before calling this./// There are at least two reasonable default ways to implement this./// Which one will be the default is not yet decided, so for now/// you probably want to override it specifically./// ## The general answer/// It's always correct to implement this with a length prefix:/// # #![feature(hasher_prefixfree_extras)]/// # impl std::hash::Hasher for Foo {/// # fn finish(&self) -> u64 { unimplemented!() }/// # fn write(&mut self, _bytes: &[u8]) { unimplemented!() }/// fn write_str(&mut self, s: &str) {///     self.write_length_prefix(s.len());///     self.write(s.as_bytes());/// And, if your `Hasher` works in `usize` chunks, this is likely a very/// efficient way to do it, as anything more complicated may well end up/// slower than just running the round with the length./// ## If your `Hasher` works byte-wise/// One nice thing about `str` being UTF-8 is that the `b'\xFF'` byte/// never happens.  That means that you can append that to the byte stream/// being hashed and maintain prefix-freedom:///     self.write_u8(0xff);/// This does require that your implementation not add extra padding, and/// thus generally requires that you maintain a buffer, running a round/// only once that buffer is full (or `finish` is called)./// That's because if `write` pads data out to a fixed chunk size, it's/// likely that it does it in such a way that `"a"` and `"a\x00"` would/// end up hashing the same sequence of things, introducing conflicts./// A trait for hashing an arbitrary stream of bytes./// Instances of `Hasher` usually represent state that is changed while hashing/// `Hasher` provides a fairly basic interface for retrieving the generated hash/// (with [`finish`]), and writing integers as well as slices of bytes into an/// instance (with [`write`] and [`write_u8`] etc.). Most of the time, `Hasher`/// instances are used in conjunction with the [`Hash`] trait./// This trait provides no guarantees about how the various `write_*` methods are/// defined and implementations of [`Hash`] should not assume that they work one/// way or another. You cannot assume, for example, that a [`write_u32`] call is/// equivalent to four calls of [`write_u8`].  Nor can you assume that adjacent/// `write` calls are merged, so it's possible, for example, that/// # fn foo(hasher: &mut impl std::hash::Hasher) {/// hasher.write(&[1, 2]);/// hasher.write(&[3, 4, 5, 6]);/// hasher.write(&[1, 2, 3, 4]);/// hasher.write(&[5, 6]);/// end up producing different hashes./// Thus to produce the same hash value, [`Hash`] implementations must ensure/// for equivalent items that exactly the same sequence of calls is made -- the/// same methods with the same parameters in the same order./// [`finish`]: Hasher::finish/// [`write_u8`]: Hasher::write_u8/// [`write_u32`]: Hasher::write_u32/// Type of the hasher that will be created./// Creates a new hasher./// Each call to `build_hasher` on the same instance should produce identical/// [`Hasher`]s./// use std::hash::{BuildHasher, RandomState};/// let new_s = s.build_hasher();/// Calculates the hash of a single value./// use std::cmp::{max, min};/// use std::hash::{BuildHasher, Hash, Hasher};/// struct OrderAmbivalentPair<T: Ord>(T, T);/// impl<T: Ord + Hash> Hash for OrderAmbivalentPair<T> {///     fn hash<H: Hasher>(&self, hasher: &mut H) {///         min(&self.0, &self.1).hash(hasher);///         max(&self.0, &self.1).hash(hasher);/// // Then later, in a `#[test]` for the type.../// let bh = std::hash::RandomState::new();///     bh.hash_one(OrderAmbivalentPair(1, 2)),///     bh.hash_one(OrderAmbivalentPair(2, 1))///     bh.hash_one(OrderAmbivalentPair(10, 2)),///     bh.hash_one(&OrderAmbivalentPair(2, 10))/// A trait for creating instances of [`Hasher`]./// A `BuildHasher` is typically used (e.g., by [`HashMap`]) to create/// [`Hasher`]s for each key such that they are hashed independently of one/// another, since [`Hasher`]s contain state./// For each instance of `BuildHasher`, the [`Hasher`]s created by/// [`build_hasher`] should be identical. That is, if the same stream of bytes/// is fed into each hasher, the same output will also be generated./// use std::hash::{BuildHasher, Hasher, RandomState};/// let mut hasher_1 = s.build_hasher();/// let mut hasher_2 = s.build_hasher();/// hasher_1.write_u32(8128);/// hasher_2.write_u32(8128);/// [`build_hasher`]: BuildHasher::build_hasher/// Used to create a default [`BuildHasher`] instance for types that implement/// [`Hasher`] and [`Default`]./// `BuildHasherDefault<H>` can be used when a type `H` implements [`Hasher`] and/// [`Default`], and you need a corresponding [`BuildHasher`] instance, but none is/// defined./// Any `BuildHasherDefault` is [zero-sized]. It can be created with/// [`default`][method.default]. When using `BuildHasherDefault` with [`HashMap`] or/// [`HashSet`], this doesn't need to be done, since they implement appropriate/// [`Default`] instances themselves./// Using `BuildHasherDefault` to specify a custom [`BuildHasher`] for/// [`HashMap`]:/// use std::hash::{BuildHasherDefault, Hasher};/// struct MyHasher;/// impl Hasher for MyHasher {///     fn write(&mut self, bytes: &[u8]) {///         // Your hashing algorithm goes here!///        unimplemented!()///     fn finish(&self) -> u64 {///         unimplemented!()/// type MyBuildHasher = BuildHasherDefault<MyHasher>;/// let hash_map = HashMap::<u32, u32, MyBuildHasher>::default();/// [method.default]: BuildHasherDefault::default/// [zero-sized]: https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts/// Creates a new BuildHasherDefault for Hasher `H`.impl_writeimpl_hash_tuple//! Generic hashing support.//! This module provides a generic way to compute the [hash] of a value.//! Hashes are most commonly used with [`HashMap`] and [`HashSet`].//! [hash]: https://en.wikipedia.org/wiki/Hash_function//! [`HashMap`]: ../../std/collections/struct.HashMap.html//! [`HashSet`]: ../../std/collections/struct.HashSet.html//! The simplest way to make a type hashable is to use `#[derive(Hash)]`://! use std::hash::{DefaultHasher, Hash, Hasher};//! #[derive(Hash)]//!     id: u32,//!     phone: u64,//! let person1 = Person {//!     id: 5,//!     name: "Janet".to_string(),//!     phone: 555_666_7777,//! let person2 = Person {//!     name: "Bob".to_string(),//! assert!(calculate_hash(&person1) != calculate_hash(&person2));//! fn calculate_hash<T: Hash>(t: &T) -> u64 {//!     let mut s = DefaultHasher::new();//!     t.hash(&mut s);//!     s.finish()//! If you need more control over how a value is hashed, you need to implement//! the [`Hash`] trait://!     # #[allow(dead_code)]//! impl Hash for Person {//!     fn hash<H: Hasher>(&self, state: &mut H) {//!         self.id.hash(state);//!         self.phone.hash(state);//! assert_eq!(calculate_hash(&person1), calculate_hash(&person2));/// This is currently the default hashing function used by standard library/// (e.g., `collections::HashMap` uses it by default)./// See: <https://131002.net/siphash>/// hashing. This lets you key your hash tables from a strong RNG, such as/// [`rand::os::OsRng`](https://docs.rs/rand/latest/rand/rngs/struct.OsRng.html)./// Safety: this performs unchecked indexing of `$buf` at/// `$i..$i+size_of::<$int_ty>()`, so that must be in-bounds./// Safety: this performs unchecked indexing of `buf` at `start..start+len`, so/// that must be in-bounds.// Note: no integer hashing methods (`write_u*`, `write_i*`) are defined// for this type. We could add them, copy the `short_write` implementation// in librustc_data_structures/sip128.rs, and add `write_u*`/`write_i*`// methods to `SipHasher`, `SipHasher13`, and `DefaultHasher`. This would// greatly speed up integer hashing by those hashers, at the cost of// slightly slowing down compile speeds on some benchmarks. See #69152 for// details.// the types in this module are deprecated/// Informs the compiler that the site which is calling this function is not/// reachable, possibly enabling further optimizations./// Reaching this function is *Undefined Behavior*./// As the compiler assumes that all forms of Undefined Behavior can never/// happen, it will eliminate all branches in the surrounding code that it can/// determine will invariably lead to a call to `unreachable_unchecked()`./// If the assumptions embedded in using this function turn out to be wrong -/// that is, if the site which is calling `unreachable_unchecked()` is actually/// reachable at runtime - the compiler may have generated nonsensical machine/// instructions for this situation, including in seemingly unrelated code,/// causing difficult-to-debug problems./// Use this function sparingly. Consider using the [`unreachable!`] macro,/// which may prevent some optimizations but will safely panic in case it is/// actually reached at runtime. Benchmark your code to find out if using/// `unreachable_unchecked()` comes with a performance benefit./// `unreachable_unchecked()` can be used in situations where the compiler/// can't prove invariants that were previously established. Such situations/// have a higher chance of occurring if those invariants are upheld by/// external code that the compiler can't analyze./// fn prepare_inputs(divisors: &mut Vec<u32>) {///     // Note to future-self when making changes: The invariant established///     // here is NOT checked in `do_computation()`; if this changes, you HAVE///     // to change `do_computation()`.///     divisors.retain(|divisor| *divisor != 0)/// /// All elements of `divisor` must be non-zero./// unsafe fn do_computation(i: u32, divisors: &[u32]) -> u32 {///     divisors.iter().fold(i, |acc, divisor| {///         // Convince the compiler that a division by zero can't happen here///         // and a check is not needed below.///         if *divisor == 0 {///             // Safety: `divisor` can't be zero because of `prepare_inputs`,///             // but the compiler does not know about this. We *promise*///             // that we always call `prepare_inputs`.///             unsafe { std::hint::unreachable_unchecked() }///         // The compiler would normally introduce a check here that prevents///         // a division by zero. However, if `divisor` was zero, the branch///         // above would reach what we explicitly marked as unreachable.///         // The compiler concludes that `divisor` can't be zero at this point///         // and removes the - now proven useless - check.///         acc / divisor/// let mut divisors = vec![2, 0, 4];/// prepare_inputs(&mut divisors);/// let result = unsafe {///     // Safety: prepare_inputs() guarantees that divisors is non-zero///     do_computation(100, &divisors)/// assert_eq!(result, 12);/// While using `unreachable_unchecked()` is perfectly sound in the following/// example, as the compiler is able to prove that a division by zero is not/// possible, benchmarking reveals that `unreachable_unchecked()` provides/// no benefit over using [`unreachable!`], while the latter does not introduce/// the possibility of Undefined Behavior./// fn div_1(a: u32, b: u32) -> u32 {///     use std::hint::unreachable_unchecked;///     // `b.saturating_add(1)` is always positive (not zero),///     // hence `checked_div` will never return `None`.///     // Therefore, the else branch is unreachable.///     a.checked_div(b.saturating_add(1))///         .unwrap_or_else(|| unsafe { unreachable_unchecked() })/// assert_eq!(div_1(7, 0), 7);/// assert_eq!(div_1(9, 1), 4);/// assert_eq!(div_1(11, u32::MAX), 0);/// Makes a *soundness* promise to the compiler that `cond` holds./// This may allow the optimizer to simplify things, but it might also make the generated code/// slower. Either way, calling it will most likely make compilation take longer./// You may know this from other places as/// [`llvm.assume`](https://llvm.org/docs/LangRef.html#llvm-assume-intrinsic) or, in C,/// [`__builtin_assume`](https://clang.llvm.org/docs/LanguageExtensions.html#builtin-assume)./// This promotes a correctness requirement to a soundness requirement. Don't do that without/// very good reason./// This is a situational tool for micro-optimization, and is allowed to do nothing. Any use/// should come with a repeatable benchmark to show the value, with the expectation to drop it/// later should the optimizer get smarter and no longer need it./// The more complicated the condition, the less likely this is to be useful. For example,/// `assert_unchecked(foo.is_sorted())` is a complex enough value that the compiler is unlikely/// to be able to take advantage of it./// There's also no need to `assert_unchecked` basic properties of things.  For example, the/// compiler already knows the range of `count_ones`, so there is no benefit to/// `let n = u32::count_ones(x); assert_unchecked(n <= u32::BITS);`./// `assert_unchecked` is logically equivalent to `if !cond { unreachable_unchecked(); }`. If/// ever you are tempted to write `assert_unchecked(false)`, you should instead use/// [`unreachable_unchecked()`] directly./// `cond` must be `true`. It is immediate UB to call this with `false`./// use core::hint;/// /// `p` must be nonnull and valid/// pub unsafe fn next_value(p: *const i32) -> i32 {///     // SAFETY: caller invariants guarantee that `p` is not null///     unsafe { hint::assert_unchecked(!p.is_null()) }///     if p.is_null() {///         return -1;///         // SAFETY: caller invariants guarantee that `p` is valid///         unsafe { *p + 1 }/// Without the `assert_unchecked`, the above function produces the following with optimizations/// enabled:/// ```asm/// next_value:///         test    rdi, rdi///         je      .LBB0_1///         mov     eax, dword ptr [rdi]///         inc     eax///         ret/// .LBB0_1:///         mov     eax, -1/// Adding the assertion allows the optimizer to remove the extra check:/// This example is quite unlike anything that would be used in the real world: it is redundant/// to put an assertion right next to code that checks the same thing, and dereferencing a/// pointer already has the builtin assumption that it is nonnull. However, it illustrates the/// kind of changes the optimizer can make even when the behavior is less obviously related./// **Note**: On platforms that do not support receiving spin-loop hints this/// ```ignore-wasm/// use std::{hint, thread};/// // A shared atomic value that threads will use to coordinate/// let live = Arc::new(AtomicBool::new(false));/// // In a background thread we'll eventually set the value/// let bg_work = {///     let live = live.clone();///         // Do some work, then make the value live///         do_some_work();///         live.store(true, Ordering::Release);/// // Back on our current thread, we wait for the value to be set/// while !live.load(Ordering::Acquire) {///     // The spin loop is a hint to the CPU that we're waiting, but probably///     // not for very long///     hint::spin_loop();/// // The value is now set/// # fn do_some_work() {}/// do_some_work();/// bg_work.join()?;/// # Ok::<(), Box<dyn core::any::Any + Send + 'static>>(())/// [`thread::yield_now`]: ../../std/thread/fn.yield_now.html/// An identity function that *__hints__* to the compiler to be maximally pessimistic about what/// `black_box` could do./// Unlike [`std::convert::identity`], a Rust compiler is encouraged to assume that `black_box` can/// use `dummy` in any possible valid way that Rust code is allowed to without introducing undefined/// behavior in the calling code. This property makes `black_box` useful for writing code in which/// certain optimizations are not desired, such as benchmarks./// Note however, that `black_box` is only (and can only be) provided on a "best-effort" basis. The/// extent to which it can block optimisations may vary depending upon the platform and code-gen/// backend used. Programs cannot rely on `black_box` for *correctness*, beyond it behaving as the/// identity function. As such, it **must not be relied upon to control critical program behavior.**/// This also means that this function does not offer any guarantees for cryptographic or security/// This limitation is not specific to `black_box`; there is no mechanism in the entire Rust/// language that can provide the guarantees required for constant-time cryptography./// (There is also no such mechanism in LLVM, so the same is true for every other LLVM-based compiler.)/// [`std::convert::identity`]: crate::convert::identity/// # When is this useful?/// While not suitable in those mission-critical cases, `black_box`'s functionality can generally be/// relied upon for benchmarking, and should be used there. It will try to ensure that the/// compiler doesn't optimize away part of the intended test code based on context. For/// fn contains(haystack: &[&str], needle: &str) -> bool {///     haystack.iter().any(|x| x == &needle)/// pub fn benchmark() {///     let haystack = vec!["abc", "def", "ghi", "jkl", "mno"];///     let needle = "ghi";///         contains(&haystack, needle);/// The compiler could theoretically make optimizations like the following:/// - The `needle` and `haystack` do not change, move the call to `contains` outside the loop and///   delete the loop/// - Inline `contains`/// - `needle` and `haystack` have values known at compile time, `contains` is always true. Remove///   the call and replace with `true`/// - Nothing is done with the result of `contains`: delete this function call entirely/// - `benchmark` now has no purpose: delete this function/// It is not likely that all of the above happens, but the compiler is definitely able to make some/// optimizations that could result in a very inaccurate benchmark. This is where `black_box` comes/// in:/// use std::hint::black_box;/// // Same `contains` function.///         // Force the compiler to run `contains`, even though it is a pure function whose///         // results are unused.///         black_box(contains(///             // Prevent the compiler from making assumptions about the input.///             black_box(&haystack),///             black_box(needle),/// This essentially tells the compiler to block optimizations across any calls to `black_box`. So,/// it now:/// - Treats both arguments to `contains` as unpredictable: the body of `contains` can no longer be///   optimized based on argument values/// - Treats the call to `contains` and its result as volatile: the body of `benchmark` cannot///   optimize this away/// This makes our benchmark much more realistic to how the function would actually be used, where/// arguments are usually not known at compile time and the result is used in some way./// # How to use this/// In practice, `black_box` serves two purposes:/// 1. It prevents the compiler from making optimizations related to the value returned by `black_box`/// 2. It forces the value passed to `black_box` to be calculated, even if the return value of `black_box` is unused/// let zero = 0;/// let five = 5;/// // The compiler will see this and remove the `* five` call, because it knows that multiplying/// // any integer by 0 will result in 0./// let c = zero * five;/// // Adding `black_box` here disables the compiler's ability to reason about the first operand in the multiplication./// // It is forced to assume that it can be any possible number, so it cannot remove the `* five`/// // operation./// let c = black_box(zero) * five;/// While most cases will not be as clear-cut as the above example, it still illustrates how/// `black_box` can be used. When benchmarking a function, you usually want to wrap its inputs in/// `black_box` so the compiler cannot make optimizations that would be unrealistic in real-life/// // This is a simple function that increments its input by 1. Note that it is pure, meaning it/// // has no side-effects. This function has no effect if its result is unused. (An example of a/// // function *with* side-effects is `println!()`.)/// fn increment(x: u8) -> u8 {/// // Here, we call `increment` but discard its result. The compiler, seeing this and knowing that/// // `increment` is pure, will eliminate this function call entirely. This may not be desired,/// // though, especially if we're trying to track how much time `increment` takes to execute./// let _ = increment(black_box(5));/// // Here, we force `increment` to be executed. This is because the compiler treats `black_box`/// // as if it has side-effects, and thus must compute its input./// let _ = black_box(increment(black_box(5)));/// There may be additional situations where you want to wrap the result of a function in/// `black_box` to force its execution. This is situational though, and may not have any effect/// (such as when the function returns a zero-sized type such as [`()` unit][unit])./// Note that `black_box` has no effect on how its input is treated, only its output. As such,/// expressions passed to `black_box` may still be optimized:/// // The compiler sees this.../// let y = black_box(5 * 10);/// // ...as this. As such, it will likely simplify `5 * 10` to just `50`./// let _0 = 5 * 10;/// let y = black_box(_0);/// In the above example, the `5 * 10` expression is considered distinct from the `black_box` call,/// and thus is still optimized by the compiler. You can prevent this by moving the multiplication/// operation outside of `black_box`:/// // No assumptions can be made about either operand, so the multiplication is not optimized out./// let y = black_box(5) * black_box(10);/// During constant evaluation, `black_box` is treated as a no-op./// An identity function that causes an `unused_must_use` warning to be/// triggered if the given value is not used (returned, stored in a variable,/// etc) by the caller./// This is primarily intended for use in macro-generated code, in which a/// [`#[must_use]` attribute][must_use] either on a type or a function would not/// be convenient./// [must_use]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute/// #![feature(hint_must_use)]/// pub struct Error(/* ... */);/// #[macro_export]/// macro_rules! make_error {///     ($($args:expr),*) => {///         core::hint::must_use({///             let error = $crate::make_error(core::format_args!($($args),*));///             error/// // Implementation detail of make_error! macro./// pub fn make_error(args: fmt::Arguments<'_>) -> Error {///     Error(/* ... */)/// fn demo() -> Option<Error> {///     if true {///         // Oops, meant to write `return Some(make_error!("..."));`///         Some(make_error!("..."));/// # // Make rustdoc not wrap the whole snippet in fn main, so that $crate::make_error works/// In the above example, we'd like an `unused_must_use` lint to apply to the/// value created by `make_error!`. However, neither `#[must_use]` on a struct/// nor `#[must_use]` on a function is appropriate here, so the macro expands/// using `core::hint::must_use` instead./// - We wouldn't want `#[must_use]` on the `struct Error` because that would///   make the following unproblematic code trigger a warning:///   # struct Error;///   fn f(arg: &str) -> Result<(), Error>///   # { Ok(()) }///   #[test]///   fn t() {///       // Assert that `f` returns error if passed an empty string.///       // A value of type `Error` is unused here but that's not a problem.///       f("").unwrap_err();/// - Using `#[must_use]` on `fn make_error` can't help because the return value///   *is* used, as the right-hand side of a `let` statement. The `let`///   statement looks useless but is in fact necessary for ensuring that///   temporaries within the `format_args` expansion are not kept alive past the///   creation of the `Error`, as keeping them alive past that point can cause///   autotrait issues in async code:///   # #![feature(hint_must_use)]///   # macro_rules! make_error {///   #     ($($args:expr),*) => {///   #         core::hint::must_use({///   #             // If `let` isn't used, then `f()` produces a non-Send future.///   #             let error = make_error(core::format_args!($($args),*));///   #             error///   #         })///   #     };///   # fn make_error(args: core::fmt::Arguments<'_>) -> Error {///   #     Error///   async fn f() {///       // Using `let` inside the make_error expansion causes temporaries like///       // `unsync()` to drop at the semicolon of that `let` statement, which///       // is prior to the await point. They would otherwise stay around until///       // the semicolon on *this* statement, which is after the await point,///       // and the enclosing Future would not implement Send.///       log(make_error!("look: {:p}", unsync())).await;///   async fn log(error: Error) {/* ... */}///   // Returns something without a Sync impl.///   fn unsync() -> *const () {///       0 as *const ()///   # fn test() {///   #     fn assert_send(_: impl Send) {}///   #     assert_send(f());// <-- :)/// Hints to the compiler that a branch condition is likely to be true./// Returns the value passed to it./// It can be used with `if` or boolean `match` expressions./// When used outside of a branch condition, it may still influence a nearby branch, but/// probably will not have any effect./// It can also be applied to parts of expressions, such as `likely(a) && unlikely(b)`, or to/// compound expressions, such as `likely(a && b)`. When applied to compound expressions, it has/// the following effect:///     likely(!a) => !unlikely(a)///     likely(a && b) => likely(a) && likely(b)///     likely(a || b) => a || likely(b)/// See also the function [`cold_path()`] which may be more appropriate for idiomatic Rust code./// #![feature(likely_unlikely)]/// use core::hint::likely;/// fn foo(x: i32) {///     if likely(x > 0) {///         println!("this branch is likely to be taken");///         println!("this branch is unlikely to be taken");///     match likely(x > 0) {///         true => println!("this branch is likely to be taken"),///         false => println!("this branch is unlikely to be taken"),///     // Use outside of a branch condition may still influence a nearby branch///     let cond = likely(x != 0);///     if cond {/// Hints to the compiler that a branch condition is unlikely to be true./// compound expressions, such as `unlikely(a && b)`. When applied to compound expressions, it has///     unlikely(!a) => !likely(a)///     unlikely(a && b) => a && unlikely(b)///     unlikely(a || b) => unlikely(a) || unlikely(b)/// use core::hint::unlikely;///     if unlikely(x > 0) {///     match unlikely(x > 0) {///         true => println!("this branch is unlikely to be taken"),///         false => println!("this branch is likely to be taken"),///     let cond = unlikely(x != 0);/// Hints to the compiler that given path is cold, i.e., unlikely to be taken. The compiler may/// choose to optimize paths that are not cold at the expense of paths that are cold./// #![feature(cold_path)]/// use core::hint::cold_path;/// fn foo(x: &[i32]) {///     if let Some(first) = x.get(0) {///         // this is the fast path///         // this path is unlikely///         cold_path();/// fn bar(x: i32) -> i32 {///         1 => 10,///         2 => 100,///         3 => { cold_path(); 1000 }, // this branch is unlikely///         _ => { cold_path(); 10000 }, // this is also unlikelyselect_unpredictable/// Returns either `true_val` or `false_val` depending on the value of/// `condition`, with a hint to the compiler that `condition` is unlikely to be/// correctly predicted by a CPU’s branch predictor./// This method is functionally equivalent to/// ```ignore (this is just for illustrative purposes)/// fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {///     if b { true_val } else { false_val }/// but might generate different assembly. In particular, on platforms with/// a conditional move or select instruction (like `cmov` on x86 or `csel`/// on ARM) the optimizer might use these instructions to avoid branches,/// which can benefit performance if the branch predictor is struggling/// with predicting `condition`, such as in an implementation of binary/// Note however that this lowering is not guaranteed (on any platform) and/// should not be relied upon when trying to write cryptographic constant-time/// code. Also be aware that this lowering might *decrease* performance if/// `condition` is well-predictable. It is advisable to perform benchmarks to/// tell if this function is useful./// Distribute values evenly between two buckets:/// use std::hint;/// fn append<H: BuildHasher>(hasher: &H, v: i32, bucket_one: &mut Vec<i32>, bucket_two: &mut Vec<i32>) {///     let hash = hasher.hash_one(&v);///     let bucket = hint::select_unpredictable(hash % 2 == 0, bucket_one, bucket_two);///     bucket.push(v);/// # let hasher = std::collections::hash_map::RandomState::new();/// # let mut bucket_one = Vec::new();/// # let mut bucket_two = Vec::new();/// # append(&hasher, 42, &mut bucket_one, &mut bucket_two);/// # assert_eq!(bucket_one.len() + bucket_two.len(), 1);//! Hints to compiler that affects how code should be emitted or optimized.//! Hints may be compile time or runtime.slice_get_uncheckedClamp/// Clamps an index, guaranteeing that it will only access valid elements of the slice./// #![feature(sliceindex_wrappers)]/// use core::index::Clamp;/// let s: &[usize] = &[0, 1, 2, 3];/// assert_eq!(&3, &s[Clamp(6)]);/// assert_eq!(&[1, 2, 3], &s[Clamp(1..6)]);/// assert_eq!(&[] as &[usize], &s[Clamp(5..6)]);/// assert_eq!(&[0, 1, 2, 3], &s[Clamp(..6)]);/// assert_eq!(&[0, 1, 2, 3], &s[Clamp(..=6)]);/// assert_eq!(&[] as &[usize], &s[Clamp(6..)]);/// Always accesses the last element of the slice./// #![feature(slice_index_methods)]/// use core::index::Last;/// use core::slice::SliceIndex;/// let s = &[0, 1, 2, 3];/// assert_eq!(&3, &s[Last]);/// assert_eq!(None, Last.get(&[] as &[usize]));//! Helper types for indexing slices.forward_ref_unop// implements the unary operator "op &T"// based on "op T" where T is expected to be `Copy`ableforward_ref_binop// implements binary operators "&T op U", "T op &U", "&T op &U"// based on "T op U" where T and U are expected to be `Copy`ableforward_ref_op_assign// implements "T op= &U", based on "T op= U"// where U is expected to be `Copy`ableimpl_fn_for_zst/// Creates a zero-size type similar to a closure type, but named.BuiltinDeref/// Types with a built-in dereference operator in runtime MIR,/// aka references and raw pointers./// Must actually *be* such a type.ChangePointee//! Various traits used to restrict intrinsics to not-completely-wrong types.carrying_mul_addCarryingMulAddimpl_carrying_mul_add_by_wideningUDoubleSizewide_mul_u128disjoint_bitor/// See [`super::disjoint_bitor`]; we just need the trait indirection to handle/// different types since calling intrinsics with generics doesn't work.DisjointBitOrimpl_disjoint_bitorunchecked_funnel_shl/// See [`super::unchecked_funnel_shl`]; we just need the trait indirection to handleunchecked_funnel_shr/// See [`super::unchecked_funnel_shr`]; we just need the trait indirection to handleFunnelShiftimpl_funnel_shifts"mir_basic_block"BasicBlock/// A non-cleanup basic block./// A basic block that lies on an unwind path./// Type representing basic blocks./// All terminators will have this type as a return type. It helps achieve some type safety."mir_unwind_terminate_reason"UnwindTerminateReason/// Unwinding is just not possible given the ABI of this function.InCleanup/// We were already cleaning up for an ongoing unwind, and a *second*, *nested* unwind was/// triggered by the drop glue./// The reason we are terminating the process during unwinding.ReasonAbiReasonInCleanupUnwindActionArg// Unwind actions"mir_unwind_continue"r" An unwind action that continues unwinding."UnwindContinue"mir_unwind_unreachable"r" An unwind action that triggers undefined behavior."UnwindUnreachable"mir_unwind_terminate"r" An unwind action that terminates the execution."r" `UnwindTerminate` can also be used as a terminator."UnwindTerminate"mir_unwind_cleanup"r" An unwind action that continues execution in a given basic block."UnwindCleanupReturnToArg// Return destination for `Call`"mir_return_to"ReturnTo"mir_return"// Terminators"mir_goto"Goto"mir_unreachable""mir_drop"r" Drop the contents of a place."r" The first argument must be a place."r" The second argument must be of the form `ReturnTo(bb)`, where `bb` is the basic block that"r" will be jumped to after the destructor returns."r" The third argument describes what happens on unwind. It can be one of:"r" - [`UnwindContinue`]"r" - [`UnwindUnreachable`]"r" - [`UnwindTerminate`]"r" - [`UnwindCleanup`]""mir_call"r" Call a function."r" The first argument must be of the form `ret_val = fun(arg1, arg2, ...)`."r" will be jumped to after the function returns.""mir_tail_call"r" The argument must be of the form `fun(arg1, arg2, ...)`."TailCall"mir_unwind_resume"r" A terminator that resumes the unwinding."UnwindResume"mir_storage_live"StorageLive"mir_storage_dead"StorageDead"mir_assume""mir_checked""mir_ptr_metadata"PtrMetadata"mir_retag"Retag"mir_move""mir_static""mir_static_mut"StaticMut"mir_discriminant"r" Gets the discriminant of a place."DiscriminantDiscriminantKind"mir_set_discriminant"SetDiscriminant"mir_offset""mir_field"r" Access the field with the given index of some place."r" This only makes sense to use in conjunction with [`Variant`]. If the type you are looking to"r" access the field of does not have variants, you can use normal field projection syntax."r" There is no proper way to do a place projection to a variant in Rust, and so these two"r" functions are a workaround. You can access a field of a variant via `Field(Variant(place,"r" var_idx), field_idx)`, where `var_idx` and `field_idx` are appropriate literals. Some"r" caveats:"r"  - The return type of `Variant` is always `()`. Don't worry about that, the correct MIR will"r"    still be generated."r"  - In some situations, the return type of `Field` cannot be inferred. You may need to"r"    annotate it on the function in these cases."r"  - Since `Field` is a function call which is not a place expression, using this on the left"r"    hand side of an expression is rejected by the compiler. [`place!`] is a macro provided to"r"    work around that issue. Wrap the left hand side of an assignment in the macro to convince"r"    the compiler that it's ok."r" #![allow(internal_features)]"r" #![feature(custom_mir, core_intrinsics)]"r" use core::intrinsics::mir::*;"r#" #[custom_mir(dialect = "built")]"#r" fn unwrap_deref(opt: Option<&i32>) -> i32 {"r"     mir! {"r"             RET = *Field::<&i32>(Variant(opt, 1), 0);"r"             Return()"r" fn set(opt: &mut Option<i32>) {"r"             place!(Field(Variant(*opt, 1), 0)) = 5;""mir_variant"r" Adds a variant projection with the given index to the place."r" See [`Field`] for documentation.""mir_cast_transmute"r" Emits a `CastKind::Transmute` cast."r" Needed to test the UB when `sizeof(T) != sizeof(U)`, which can't be"r" generated via the normal `mem::transmute`."CastTransmute"mir_cast_ptr_to_ptr"r" Emits a `CastKind::PtrToPtr` cast."r" This allows bypassing normal validation to generate strange casts."CastPtrToPtr"mir_cast_unsize"r" Emits a `CastKind::PointerCoercion(Unsize)` cast."CastUnsize"mir_make_place"__internal_make_place"mir_debuginfo"__debuginfo"transparent"rustc_macro_transparencymir/// Macro for generating custom MIR./// See the module documentation for syntax details. This macro is not magic - it only transforms/// your MIR into something that is easier to parse in the compiler./// Helper macro that allows you to treat a value expression like a place expression./// See the documentation on [`Variant`] for why this is necessary and how to use it.__internal_extract_let/// Helper macro that extracts the `let` declarations out of a bunch of statements./// This macro is written using the "statement muncher" strategy. Each invocation parses the first/// statement out of the input, does the appropriate thing with it, and then recursively calls the/// same macro on the remainder of the input.__internal_remove_let/// Helper macro that removes the `let` declarations from a bunch of statements./// Because expression position macros cannot expand to statements + expressions, we need to be/// slightly creative here. The general strategy is also statement munching as above, but the output/// of the macro is "stored" in the subsequent macro invocation. Easiest understood via example:/// invoke!(///             x = 5;///             let d = e;///             Call()/// becomes///             d = e;__internal_declare_basic_blocks/// Helper macro that declares the basic blocks.//! Rustc internal tooling for hand-writing MIR.//! If for some reasons you are not writing rustc tests and have found yourself considering using//! this feature, turn back. This is *exceptionally* unstable. There is no attempt at all to make//! anything work besides those things which the rustc test suite happened to need. If you make a//! typo you'll probably ICE. Really, this is not the solution to your problems. Consider instead//! supporting the [stable MIR project group](https://github.com/rust-lang/project-stable-mir).//! The documentation for this module describes how to use this feature. If you are interested in//! hacking on the implementation, most of that documentation lives at//! `rustc_mir_build/src/build/custom/mod.rs`.//! Typical usage will look like this://! #![feature(core_intrinsics, custom_mir)]//! #![allow(internal_features)]//! use core::intrinsics::mir::*;//! #[custom_mir(dialect = "built")]//! pub fn simple(x: i32) -> i32 {//!     mir! {//!         let temp2: i32;//!             let temp1 = x;//!             Goto(my_second_block)//!         my_second_block = {//!             temp2 = Move(temp1);//!             RET = temp2;//!             Return()//! The `custom_mir` attribute tells the compiler to treat the function as being custom MIR. This//! attribute only works on functions - there is no way to insert custom MIR into the middle of//! another function. The `dialect` and `phase` parameters indicate which [version of MIR][dialect//! docs] you are inserting here. Generally you'll want to use `#![custom_mir(dialect = "built")]`//! if you want your MIR to be modified by the full MIR pipeline, or `#![custom_mir(dialect =//! "runtime", phase = "optimized")]` if you don't.//! [dialect docs]://!     https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.MirPhase.html//! The input to the [`mir!`] macro is://!  - An optional return type annotation in the form of `type RET = ...;`. This may be required//!    if the compiler cannot infer the type of RET.//!  - A possibly empty list of local declarations. Locals can also be declared inline on//!    assignments via `let`. Type inference generally works. Shadowing does not.//!  - A list of basic blocks. The first of these is the start block and is where execution begins.//!    All blocks other than the start block need to be given a name, so that they can be referred//!    to later.//!     - Each block is a list of semicolon terminated statements, followed by a terminator. The//!       syntax for the various statements and terminators is designed to be as similar as possible//!       to the syntax for analogous concepts in native Rust. See below for a list.//! #![allow(unused_assignments)]//! pub fn choose_load(a: &i32, b: &i32, c: bool) -> i32 {//!             match c {//!                 true => t,//!                 _ => f,//!         t = {//!             let temp = a;//!             Goto(load_and_exit)//!         f = {//!             temp = b;//!         load_and_exit = {//!             RET = *temp;//! fn unwrap_unchecked<T>(opt: Option<T>) -> T {//!             RET = Move(Field(Variant(opt, 1), 0));//! #[custom_mir(dialect = "runtime", phase = "optimized")]//! fn push_and_pop<T>(v: &mut Vec<T>, value: T) {//!         let _unused;//!         let popped;//!             Call(_unused = Vec::push(v, value), ReturnTo(pop), UnwindContinue())//!         pop = {//!             Call(popped = Vec::pop(v), ReturnTo(drop), UnwindContinue())//!         drop = {//!             Drop(popped, ReturnTo(ret), UnwindContinue())//!         ret = {//! fn annotated_return_type() -> (i32, bool) {//!         type RET = (i32, bool);//!             RET.0 = 1;//!             RET.1 = true;//! We can also set off compilation failures that happen in sufficiently late stages of the//! compiler://! extern crate core;//! fn borrow_error(should_init: bool) -> i32 {//!         let temp: i32;//!             match should_init {//!                 true => init,//!                 _ => use_temp,//!         init = {//!             temp = 0;//!             Goto(use_temp)//!         use_temp = {//!             RET = temp;//! error[E0381]: used binding is possibly-uninitialized//!   --> test.rs:24:13//! 8  | /     mir! {//! 9  | |         let temp: i32;//! 10 | |//! 11 | |         {//! ...  |//! 19 | |             temp = 0;//!    | |             -------- binding initialized here in some conditions//! 24 | |             RET = temp;//!    | |             ^^^^^^^^^^ value used here but it is possibly-uninitialized//! 25 | |             Return()//! 26 | |         }//! 27 | |     }//!    | |_____- binding declared here but left uninitialized//! error: aborting due to 1 previous error//! For more information about this error, try `rustc --explain E0381`.//! The lists below are an exhaustive description of how various MIR constructs can be created.//! Anything missing from the list should be assumed to not be supported, PRs welcome.//! #### Locals//!  - The `_0` return local can always be accessed via `RET`.//!  - Arguments can be accessed via their regular name.//!  - All other locals need to be declared with `let` somewhere and then can be accessed by name.//! #### Places//!  - Locals implicitly convert to places.//!  - Field accesses, derefs, and indexing work normally.//!  - Fields in variants can be accessed via the [`Variant`] and [`Field`] associated functions,//!    see their documentation for details.//! #### Operands//!  - Places implicitly convert to `Copy` operands.//!  - `Move` operands can be created via [`Move`].//!  - Const blocks, literals, named constants, and const params all just work.//!  - [`Static`] and [`StaticMut`] can be used to create `&T` and `*mut T`s to statics. These are//!    constants in MIR and the only way to access statics.//! #### Statements//!  - Assign statements work via normal Rust assignment.//!  - [`Retag`], [`StorageLive`], [`StorageDead`] statements have an associated function.//! #### Rvalues//!  - Operands implicitly convert to `Use` rvalues.//!  - `&`, `&mut`, `addr_of!`, and `addr_of_mut!` all work to create their associated rvalue.//!  - [`CastTransmute`], [`CastPtrToPtr`], [`CastUnsize`], and [`Discriminant`]//!    have associated functions.//!  - Unary and binary operations use their normal Rust syntax - `a * b`, `!c`, etc.//!  - The binary operation `Offset` can be created via [`Offset`].//!  - Checked binary operations are represented by wrapping the associated binop in [`Checked`].//!  - Array repetition syntax (`[foo; 10]`) creates the associated rvalue.//! #### Terminators//!  - [`Goto`], [`Return`], [`Unreachable`] and [`Drop`](Drop()) have associated functions.//!  - `match some_int_operand` becomes a `SwitchInt`. Each arm should be `literal => basic_block`//!     - The exception is the last arm, which must be `_ => basic_block` and corresponds to the//!       otherwise branch.//!  - [`Call`] has an associated function as well, with special syntax://!    `Call(ret_val = function(arg1, arg2, ...), ReturnTo(next_block), UnwindContinue())`.//!  - [`TailCall`] does not have a return destination or next block, so its syntax is just//!    `TailCall(function(arg1, arg2, ...))`.//! #### Debuginfo//! Debuginfo associates source code variable names (of variables that may not exist any more) with//! MIR expressions that indicate where the value of that variable is stored. The syntax to do so//! is://! debug source_var_name => expression;//! Both places and constants are supported in the `expression`.//! fn debuginfo(arg: Option<&i32>) {//!     mir!(//!         // Debuginfo for a source variable `plain_local` that just duplicates `arg`.//!         debug plain_local => arg;//!         // Debuginfo for a source variable `projection` that can be computed by dereferencing//!         // a field of `arg`.//!         debug projection => *Field::<&i32>(Variant(arg, 1), 0);//!         // Debuginfo for a source variable `constant` that always holds the value `5`.//!         debug constant => 5_usize;ConstParamTy// These imports are used for simplifying intra-doc links// These values must match the compiler's `AtomicOrdering` defined in// `rustc_middle/src/ty/consts/int.rs`!/// A type for atomic ordering parameters for intrinsics. This is a separate type from/// `atomic::Ordering` so that we can make it `ConstParamTy` and fix the values used here without a/// risk of leaking that to stable code.ORD_SUCCORD_FAILatomic_cxchg/// Stores a value if the current value is the same as the `old` value./// `T` must be an integer or pointer type./// The stabilized version of this intrinsic is available on the/// [`atomic`] types via the `compare_exchange` method./// For example, [`AtomicBool::compare_exchange`].atomic_cxchgweak/// `T` must be an integer or pointer type. The comparison may spuriously fail./// [`atomic`] types via the `compare_exchange_weak` method./// For example, [`AtomicBool::compare_exchange_weak`]./// Loads the current value of the pointer./// [`atomic`] types via the `load` method. For example, [`AtomicBool::load`]./// Stores the value at the specified memory location./// [`atomic`] types via the `store` method. For example, [`AtomicBool::store`].atomic_xchg/// Stores the value at the specified memory location, returning the old value./// [`atomic`] types via the `swap` method. For example, [`AtomicBool::swap`].atomic_xadd/// Adds to the current value, returning the previous value./// `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type./// [`atomic`] types via the `fetch_add` method. For example, [`AtomicIsize::fetch_add`].atomic_xsub/// Subtract from the current value, returning the previous value./// [`atomic`] types via the `fetch_sub` method. For example, [`AtomicIsize::fetch_sub`]./// Bitwise and with the current value, returning the previous value./// [`atomic`] types via the `fetch_and` method. For example, [`AtomicBool::fetch_and`]./// Bitwise nand with the current value, returning the previous value./// [`AtomicBool`] type via the `fetch_nand` method. For example, [`AtomicBool::fetch_nand`]./// Bitwise or with the current value, returning the previous value./// [`atomic`] types via the `fetch_or` method. For example, [`AtomicBool::fetch_or`]./// Bitwise xor with the current value, returning the previous value./// [`atomic`] types via the `fetch_xor` method. For example, [`AtomicBool::fetch_xor`]./// Maximum with the current value using a signed comparison./// `T` must be a signed integer type./// [`atomic`] signed integer types via the `fetch_max` method. For example, [`AtomicI32::fetch_max`]./// Minimum with the current value using a signed comparison./// [`atomic`] signed integer types via the `fetch_min` method. For example, [`AtomicI32::fetch_min`]./// Minimum with the current value using an unsigned comparison./// `T` must be an unsigned integer type./// [`atomic`] unsigned integer types via the `fetch_min` method. For example, [`AtomicU32::fetch_min`]./// Maximum with the current value using an unsigned comparison./// [`atomic`] unsigned integer types via the `fetch_max` method. For example, [`AtomicU32::fetch_max`]./// The stabilized version of this intrinsic is available in/// [`atomic::fence`].atomic_singlethreadfence/// An atomic fence for synchronization within a single thread./// [`atomic::compiler_fence`].intrinsic_fallback_is_specprefetch_read_data/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction/// for the given address if supported; otherwise, it is a no-op./// Prefetches have no effect on the behavior of the program but can change its performance/// characteristics./// The `LOCALITY` argument is a temporal locality specifier ranging from (0) - no locality,/// to (3) - extremely local keep in cache./// This intrinsic does not have a stable counterpart.prefetch_write_dataprefetch_read_instructionprefetch_write_instruction/// Executes a breakpoint trap, for inspection by a debugger.rustc_peek/// Magic intrinsic that derives its meaning from attributes/// attached to the function./// For example, dataflow uses this to inject static assertions so/// that `rustc_peek(potentially_uninitialized)` would actually/// double-check that dataflow did indeed compute that it is/// uninitialized at that point in the control flow./// This intrinsic should not be used outside of the compiler./// Aborts the execution of the process./// Note that, unlike most intrinsics, this is safe to call;/// it does not require an `unsafe` block./// Therefore, implementations must not require the user to uphold/// any safety invariants./// [`std::process::abort`](../../std/process/fn.abort.html) is to be preferred if possible,/// as its behavior is more user-friendly and more stable./// The current implementation of `intrinsics::abort` is to invoke an invalid instruction,/// on most platforms./// On Unix, the/// process will probably terminate with a signal like `SIGABRT`, `SIGILL`, `SIGTRAP`, `SIGSEGV` or/// `SIGBUS`.  The precise behavior is not guaranteed and not stable.rustc_intrinsic_const_stable_indirect/// Informs the optimizer that this point in the code is not reachable,/// enabling further optimizations./// N.B., this is very different from the `unreachable!()` macro: Unlike the/// macro, which panics when it is executed, it is *undefined behavior* to/// reach code marked with this function./// The stabilized version of this intrinsic is [`core::hint::unreachable_unchecked`]./// Informs the optimizer that a condition is always true./// If the condition is false, the behavior is undefined./// No code is generated for this intrinsic, but the optimizer will try/// to preserve it (and its condition) between passes, which may interfere/// with optimization of surrounding code and reduce performance. It should/// not be used if the invariant can be discovered by the optimizer on its/// own, or if it does not enable any significant optimizations./// The stabilized version of this intrinsic is [`core::hint::assert_unchecked`]./// Hints to the compiler that current code path is cold./// Hints to the compiler that branch condition is likely to be true./// Any use other than with `if` statements will probably not have an effect./// Hints to the compiler that branch condition is likely to be false./// Returns either `true_val` or `false_val` depending on condition `b` with a/// hint to the compiler that this condition is unlikely to be correctly/// predicted by a CPU's branch predictor (e.g. a binary search)./// This is otherwise functionally equivalent to `if b { true_val } else { false_val }`./// The public form of this intrinsic is [`core::hint::select_unpredictable`]./// However unlike the public form, the intrinsic will not drop the value that/// is not selected.assert_inhabited/// A guard for unsafe functions that cannot ever be executed if `T` is uninhabited:/// This will statically either panic, or do nothing. It does not *guarantee* to ever panic,/// and should only be called if an assertion failure will imply language UB in the following code.assert_zero_valid/// A guard for unsafe functions that cannot ever be executed if `T` does not permit/// zero-initialization: This will statically either panic, or do nothing. It does not *guarantee*/// to ever panic, and should only be called if an assertion failure will imply language UB in the/// following code.assert_mem_uninitialized_valid/// A guard for `std::mem::uninitialized`. This will statically either panic, or do nothing. It does/// not *guarantee* to ever panic, and should only be called if an assertion failure will imply/// language UB in the following code./// Gets a reference to a static `Location` indicating where it was called./// Consider using [`core::panic::Location::caller`] instead./// Moves a value out of scope without running drop glue./// This exists solely for [`crate::mem::forget_unsized`]; normal `forget` uses/// `ManuallyDrop` instead."import this function via `std::mem` instead"rustc_allowed_through_unstable_modules"transmute"/// Reinterprets the bits of a value of one type as another type./// Both types must have the same size. Compilation will fail if this is not guaranteed./// `transmute` is semantically equivalent to a bitwise move of one type/// into another. It copies the bits from the source value into the/// destination value, then forgets the original. Note that source and destination/// are passed by-value, which means if `Src` or `Dst` contain padding, that padding/// is *not* guaranteed to be preserved by `transmute`./// Both the argument and the result must be [valid](../../nomicon/what-unsafe-does.html) at/// their given type. Violating this condition leads to [undefined behavior][ub]. The compiler/// will generate code *assuming that you, the programmer, ensure that there will never be/// undefined behavior*. It is therefore your responsibility to guarantee that every value/// passed to `transmute` is valid at both types `Src` and `Dst`. Failing to uphold this condition/// may lead to unexpected and unstable compilation results. This makes `transmute` **incredibly/// unsafe**. `transmute` should be the absolute last resort./// Because `transmute` is a by-value operation, alignment of the *transmuted values/// themselves* is not a concern. As with any other function, the compiler already ensures/// both `Src` and `Dst` are properly aligned. However, when transmuting values that *point/// elsewhere* (such as pointers, references, boxes…), the caller has to ensure proper/// alignment of the pointed-to values./// The [nomicon](../../nomicon/transmutes.html) has additional documentation./// [ub]: ../../reference/behavior-considered-undefined.html/// # Transmutation between pointers and integers/// Special care has to be taken when transmuting between pointers and integers, e.g./// transmuting between `*const ()` and `usize`./// Transmuting *pointers to integers* in a `const` context is [undefined behavior][ub], unless/// the pointer was originally created *from* an integer. (That includes this function/// specifically, integer-to-pointer casts, and helpers like [`dangling`][crate::ptr::dangling],/// but also semantically-equivalent conversions such as punning through `repr(C)` union/// fields.) Any attempt to use the resulting value for integer operations will abort/// const-evaluation. (And even outside `const`, such transmutation is touching on many/// unspecified aspects of the Rust memory model and should be avoided. See below for/// alternatives.)/// Transmuting *integers to pointers* is a largely unspecified operation. It is likely *not*/// equivalent to an `as` cast. Doing non-zero-sized memory accesses with a pointer constructed/// this way is currently considered undefined behavior./// All this also applies when the integer is nested inside an array, tuple, struct, or enum./// However, `MaybeUninit<usize>` is not considered an integer type for the purpose of this/// section. Transmuting `*const ()` to `MaybeUninit<usize>` is fine---but then calling/// `assume_init()` on that result is considered as completing the pointer-to-integer transmute/// and thus runs into the issues discussed above./// In particular, doing a pointer-to-integer-to-pointer roundtrip via `transmute` is *not* a/// lossless process. If you want to round-trip a pointer through an integer in a way that you/// can get back the original pointer, you need to use `as` casts, or replace the integer type/// by `MaybeUninit<$int>` (and never call `assume_init()`). If you are looking for a way to/// store data of arbitrary type, also use `MaybeUninit<T>` (that will also handle uninitialized/// memory due to padding). If you specifically need to store something that is "either an/// integer or a pointer", use `*mut ()`: integers can be converted to pointers and back without/// any loss (via `as` casts or via `transmute`)./// There are a few things that `transmute` is really useful for./// Turning a pointer into a function pointer. This is *not* portable to/// machines where function pointers and data pointers have different sizes./// fn foo() -> i32 {/// // Crucially, we `as`-cast to a raw pointer before `transmute`ing to a function pointer./// // This avoids an integer-to-pointer `transmute`, which can be problematic./// // Transmuting between raw pointers and function pointers (i.e., two pointer types) is fine./// let pointer = foo as fn() -> i32 as *const ();/// let function = unsafe {///     std::mem::transmute::<*const (), fn() -> i32>(pointer)/// assert_eq!(function(), 0);/// Extending a lifetime, or shortening an invariant lifetime. This is/// advanced, very unsafe Rust!/// struct R<'a>(&'a i32);/// unsafe fn extend_lifetime<'b>(r: R<'b>) -> R<'static> {///     unsafe { std::mem::transmute::<R<'b>, R<'static>>(r) }/// unsafe fn shorten_invariant_lifetime<'b, 'c>(r: &'b mut R<'static>)///                                              -> &'b mut R<'c> {///     unsafe { std::mem::transmute::<&'b mut R<'static>, &'b mut R<'c>>(r) }/// Don't despair: many uses of `transmute` can be achieved through other means./// Below are common applications of `transmute` which can be replaced with safer/// constructs./// Turning raw bytes (`[u8; SZ]`) into `u32`, `f64`, etc.:/// # #![allow(unnecessary_transmutes)]/// let raw_bytes = [0x78, 0x56, 0x34, 0x12];/// let num = unsafe {///     std::mem::transmute::<[u8; 4], u32>(raw_bytes)/// // use `u32::from_ne_bytes` instead/// let num = u32::from_ne_bytes(raw_bytes);/// // or use `u32::from_le_bytes` or `u32::from_be_bytes` to specify the endianness/// let num = u32::from_le_bytes(raw_bytes);/// assert_eq!(num, 0x12345678);/// let num = u32::from_be_bytes(raw_bytes);/// assert_eq!(num, 0x78563412);/// Turning a pointer into a `usize`:/// let ptr = &0;/// let ptr_num_transmute = unsafe {///     std::mem::transmute::<&i32, usize>(ptr)/// // Use an `as` cast instead/// let ptr_num_cast = ptr as *const i32 as usize;/// Note that using `transmute` to turn a pointer to a `usize` is (as noted above) [undefined/// behavior][ub] in `const` contexts. Also outside of consts, this operation might not behave/// as expected -- this is touching on many unspecified aspects of the Rust memory model./// Depending on what the code is doing, the following alternatives are preferable to/// pointer-to-integer transmutation:/// - If the code just wants to store data of arbitrary type in some buffer and needs to pick a///   type for that buffer, it can use [`MaybeUninit`][crate::mem::MaybeUninit]./// - If the code actually wants to work on the address the pointer points to, it can use `as`///   casts or [`ptr.addr()`][pointer::addr]./// Turning a `*mut T` into a `&mut T`:/// let ptr: *mut i32 = &mut 0;/// let ref_transmuted = unsafe {///     std::mem::transmute::<*mut i32, &mut i32>(ptr)/// // Use a reborrow instead/// let ref_casted = unsafe { &mut *ptr };/// Turning a `&mut T` into a `&mut U`:/// let ptr = &mut 0;/// let val_transmuted = unsafe {///     std::mem::transmute::<&mut i32, &mut u32>(ptr)/// // Now, put together `as` and reborrowing - note the chaining of `as`/// // `as` is not transitive/// let val_casts = unsafe { &mut *(ptr as *mut i32 as *mut u32) };/// Turning a `&str` into a `&[u8]`:/// // this is not a good way to do this./// let slice = unsafe { std::mem::transmute::<&str, &[u8]>("Rust") };/// assert_eq!(slice, &[82, 117, 115, 116]);/// // You could use `str::as_bytes`/// let slice = "Rust".as_bytes();/// // Or, just use a byte string, if you have control over the string/// // literal/// assert_eq!(b"Rust", &[82, 117, 115, 116]);/// Turning a `Vec<&T>` into a `Vec<Option<&T>>`./// To transmute the inner type of the contents of a container, you must make sure to not/// violate any of the container's invariants. For `Vec`, this means that both the size/// *and alignment* of the inner types have to match. Other containers might rely on the/// size of the type, alignment, or even the `TypeId`, in which case transmuting wouldn't/// be possible at all without violating the container invariants./// let store = [0, 1, 2, 3];/// let v_orig = store.iter().collect::<Vec<&i32>>();/// // clone the vector as we will reuse them later/// let v_clone = v_orig.clone();/// // Using transmute: this relies on the unspecified data layout of `Vec`, which is a/// // bad idea and could cause Undefined Behavior./// // However, it is no-copy./// let v_transmuted = unsafe {///     std::mem::transmute::<Vec<&i32>, Vec<Option<&i32>>>(v_clone)/// // This is the suggested, safe way./// // It may copy the entire vector into a new one though, but also may not./// let v_collected = v_clone.into_iter()///                          .map(Some)///                          .collect::<Vec<Option<&i32>>>();/// // This is the proper no-copy, unsafe way of "transmuting" a `Vec`, without relying on the/// // data layout. Instead of literally calling `transmute`, we perform a pointer cast, but/// // in terms of converting the original inner type (`&i32`) to the new one (`Option<&i32>`),/// // this has all the same caveats. Besides the information provided above, also consult the/// // [`from_raw_parts`] documentation./// let (ptr, len, capacity) = v_clone.into_raw_parts();/// let v_from_raw = unsafe {///     Vec::from_raw_parts(ptr.cast::<*mut Option<&i32>>(), len, capacity)/// [`from_raw_parts`]: ../../std/vec/struct.Vec.html#method.from_raw_parts/// Implementing `split_at_mut`:/// use std::{slice, mem};/// // There are multiple ways to do this, and there are multiple problems/// // with the following (transmute) way./// fn split_at_mut_transmute<T>(slice: &mut [T], mid: usize)///                              -> (&mut [T], &mut [T]) {///     let len = slice.len();///     assert!(mid <= len);///         let slice2 = mem::transmute::<&mut [T], &mut [T]>(slice);///         // first: transmute is not type safe; all it checks is that T and///         // U are of the same size. Second, right here, you have two///         // mutable references pointing to the same memory.///         (&mut slice[0..mid], &mut slice2[mid..len])/// // This gets rid of the type safety problems; `&mut *` will *only* give/// // you a `&mut T` from a `&mut T` or `*mut T`./// fn split_at_mut_casts<T>(slice: &mut [T], mid: usize)///                          -> (&mut [T], &mut [T]) {///         let slice2 = &mut *(slice as *mut [T]);///         // however, you still have two mutable references pointing to///         // the same memory./// // This is how the standard library does it. This is the best method, if/// // you need to do something like this/// fn split_at_stdlib<T>(slice: &mut [T], mid: usize)///                       -> (&mut [T], &mut [T]) {///         let ptr = slice.as_mut_ptr();///         // This now has three mutable references pointing at the same///         // memory. `slice`, the rvalue ret.0, and the rvalue ret.1.///         // `slice` is never used after `let ptr = ...`, and so one can///         // treat it as "dead", and therefore, you only have two real///         // mutable slices.///         (slice::from_raw_parts_mut(ptr, mid),///          slice::from_raw_parts_mut(ptr.add(mid), len - mid))/// Like [`transmute`], but even less checked at compile-time: rather than/// giving an error for `size_of::<Src>() != size_of::<Dst>()`, it's/// **Undefined Behavior** at runtime./// Prefer normal `transmute` where possible, for the extra checking, since/// both do exactly the same thing at runtime, if they both compile./// This is not expected to ever be exposed directly to users, rather it/// may eventually be exposed through some more-constrained API./// Returns `true` if the actual type given as `T` requires drop/// glue; returns `false` if the actual type provided for `T`/// implements `Copy`./// If the actual type neither requires drop glue nor implements/// `Copy`, then the return value of this function is unspecified./// Note that, unlike most intrinsics, this can only be called at compile-time/// as backends do not have an implementation for it. The only caller (its/// stable counterpart) wraps this intrinsic call in a `const` block so that/// backends only see an evaluated constant./// The stabilized version of this intrinsic is [`mem::needs_drop`](crate::mem::needs_drop)."returns a new pointer rather than modifying its argument"/// Calculates the offset from a pointer./// This is implemented as an intrinsic to avoid converting to and from an/// integer, since the conversion would throw away aliasing information./// This can only be used with `Ptr` as a raw pointer type (`*mut` or `*const`)/// to a `Sized` pointee and with `Delta` as `usize` or `isize`.  Any other/// instantiations may arbitrarily misbehave, and that's *not* a compiler bug./// If the computed offset is non-zero, then both the starting and resulting pointer must be/// either in bounds or at the end of an allocation. If either pointer is out/// of bounds or arithmetic overflow occurs then this operation is undefined behavior./// The stabilized version of this intrinsic is [`pointer::offset`].arith_offset/// Calculates the offset from a pointer, potentially wrapping./// integer, since the conversion inhibits certain optimizations./// Unlike the `offset` intrinsic, this intrinsic does not restrict the/// resulting pointer to point into or at the end of an allocated/// object, and it wraps with two's complement arithmetic. The resulting/// value is not necessarily valid to be used to actually access memory./// The stabilized version of this intrinsic is [`pointer::wrapping_offset`].ItemPtrSlicePtr/// Projects to the `index`-th element of `slice_ptr`, as the same kind of pointer/// as the slice was provided -- so `&mut [T] → &mut T`, `&[T] → &T`,/// `*mut [T] → *mut T`, or `*const [T] → *const T` -- without a bounds check./// This is exposed via `<usize as SliceIndex>::get(_unchecked)(_mut)`,/// and isn't intended to be used elsewhere./// Expands in MIR to `{&, &mut, &raw const, &raw mut} (*slice_ptr)[index]`,/// depending on the types involved, so no backend support is needed./// - `index < PtrMetadata(slice_ptr)`, so the indexing is in-bounds for the slice/// - the resulting offsetting is in-bounds of the allocation, which is///   always the case for references, but needs to be upheld manually for pointersptr_mask/// Masks out bits of the pointer according to a mask./// Consider using [`pointer::mask`] instead.volatile_copy_nonoverlapping_memory/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with/// a size of `count` * `size_of::<T>()` and an alignment of `align_of::<T>()`./// The safety requirements are consistent with [`copy_nonoverlapping`]/// while the read and write behaviors are volatile,/// which means it will not be optimized out unless `_count` or `size_of::<T>()` is equal to zero./// [`copy_nonoverlapping`]: ptr::copy_nonoverlappingvolatile_copy_memory/// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with/// a size of `count * size_of::<T>()` and an alignment of `align_of::<T>()`./// The volatile parameter is set to `true`, so it will not be optimized out/// unless size is equal to zero.volatile_set_memory/// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a/// size of `count * size_of::<T>()` and an alignment of `align_of::<T>()`./// The safety requirements are consistent with [`write_bytes`] while the write behavior is volatile,/// [`write_bytes`]: ptr::write_bytesvolatile_load/// Performs a volatile load from the `src` pointer./// The stabilized version of this intrinsic is [`core::ptr::read_volatile`].volatile_store/// Performs a volatile store to the `dst` pointer./// The stabilized version of this intrinsic is [`core::ptr::write_volatile`]."intrinsics_unaligned_volatile_load"unaligned_volatile_load/// Performs a volatile load from the `src` pointer/// The pointer is not required to be aligned."intrinsics_unaligned_volatile_store"unaligned_volatile_store/// Returns the square root of an `f16`/// The stabilized version of this intrinsic is/// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)sqrtf32/// Returns the square root of an `f32`/// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)sqrtf64/// Returns the square root of an `f64`/// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)/// Returns the square root of an `f128`/// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)powif16/// Raises an `f16` to an integer power./// [`f16::powi`](../../std/primitive.f16.html#method.powi)powif32/// Raises an `f32` to an integer power./// [`f32::powi`](../../std/primitive.f32.html#method.powi)powif64/// Raises an `f64` to an integer power./// [`f64::powi`](../../std/primitive.f64.html#method.powi)powif128/// Raises an `f128` to an integer power./// [`f128::powi`](../../std/primitive.f128.html#method.powi)sinf16/// Returns the sine of an `f16`./// [`f16::sin`](../../std/primitive.f16.html#method.sin)sinf32/// Returns the sine of an `f32`./// [`f32::sin`](../../std/primitive.f32.html#method.sin)sinf64/// Returns the sine of an `f64`./// [`f64::sin`](../../std/primitive.f64.html#method.sin)sinf128/// Returns the sine of an `f128`./// [`f128::sin`](../../std/primitive.f128.html#method.sin)cosf16/// Returns the cosine of an `f16`./// [`f16::cos`](../../std/primitive.f16.html#method.cos)cosf32/// Returns the cosine of an `f32`./// [`f32::cos`](../../std/primitive.f32.html#method.cos)cosf64/// Returns the cosine of an `f64`./// [`f64::cos`](../../std/primitive.f64.html#method.cos)cosf128/// Returns the cosine of an `f128`./// [`f128::cos`](../../std/primitive.f128.html#method.cos)powf16/// Raises an `f16` to an `f16` power./// [`f16::powf`](../../std/primitive.f16.html#method.powf)/// Raises an `f32` to an `f32` power./// [`f32::powf`](../../std/primitive.f32.html#method.powf)powf64/// Raises an `f64` to an `f64` power./// [`f64::powf`](../../std/primitive.f64.html#method.powf)powf128/// Raises an `f128` to an `f128` power./// [`f128::powf`](../../std/primitive.f128.html#method.powf)expf16/// Returns the exponential of an `f16`./// [`f16::exp`](../../std/primitive.f16.html#method.exp)expf32/// Returns the exponential of an `f32`./// [`f32::exp`](../../std/primitive.f32.html#method.exp)expf64/// Returns the exponential of an `f64`./// [`f64::exp`](../../std/primitive.f64.html#method.exp)expf128/// Returns the exponential of an `f128`./// [`f128::exp`](../../std/primitive.f128.html#method.exp)exp2f16/// Returns 2 raised to the power of an `f16`./// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)exp2f32/// Returns 2 raised to the power of an `f32`./// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)exp2f64/// Returns 2 raised to the power of an `f64`./// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)exp2f128/// Returns 2 raised to the power of an `f128`./// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)logf16/// Returns the natural logarithm of an `f16`./// [`f16::ln`](../../std/primitive.f16.html#method.ln)logf32/// Returns the natural logarithm of an `f32`./// [`f32::ln`](../../std/primitive.f32.html#method.ln)logf64/// Returns the natural logarithm of an `f64`./// [`f64::ln`](../../std/primitive.f64.html#method.ln)logf128/// Returns the natural logarithm of an `f128`./// [`f128::ln`](../../std/primitive.f128.html#method.ln)log10f16/// Returns the base 10 logarithm of an `f16`./// [`f16::log10`](../../std/primitive.f16.html#method.log10)log10f32/// Returns the base 10 logarithm of an `f32`./// [`f32::log10`](../../std/primitive.f32.html#method.log10)log10f64/// Returns the base 10 logarithm of an `f64`./// [`f64::log10`](../../std/primitive.f64.html#method.log10)log10f128/// Returns the base 10 logarithm of an `f128`./// [`f128::log10`](../../std/primitive.f128.html#method.log10)log2f16/// Returns the base 2 logarithm of an `f16`./// [`f16::log2`](../../std/primitive.f16.html#method.log2)log2f32/// Returns the base 2 logarithm of an `f32`./// [`f32::log2`](../../std/primitive.f32.html#method.log2)log2f64/// Returns the base 2 logarithm of an `f64`./// [`f64::log2`](../../std/primitive.f64.html#method.log2)log2f128/// Returns the base 2 logarithm of an `f128`./// [`f128::log2`](../../std/primitive.f128.html#method.log2)fmaf16/// Returns `a * b + c` for `f16` values./// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)fmaf32/// Returns `a * b + c` for `f32` values./// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)fmaf64/// Returns `a * b + c` for `f64` values./// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)/// Returns `a * b + c` for `f128` values./// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)fmuladdf16/// Returns `a * b + c` for `f16` values, non-deterministically executing/// either a fused multiply-add or two operations with rounding of the/// intermediate result./// The operation is fused if the code generator determines that target/// instruction set has support for a fused operation, and that the fused/// operation is more efficient than the equivalent, separate pair of mul/// and add instructions. It is unspecified whether or not a fused operation/// is selected, and that may depend on optimization level and context, forfmuladdf32/// Returns `a * b + c` for `f32` values, non-deterministically executingfmuladdf64/// Returns `a * b + c` for `f64` values, non-deterministically executingfmuladdf128/// Returns `a * b + c` for `f128` values, non-deterministically executing/// Returns the largest integer less than or equal to an `f16`./// [`f16::floor`](../../std/primitive.f16.html#method.floor)floorf32/// Returns the largest integer less than or equal to an `f32`./// [`f32::floor`](../../std/primitive.f32.html#method.floor)floorf64/// Returns the largest integer less than or equal to an `f64`./// [`f64::floor`](../../std/primitive.f64.html#method.floor)/// Returns the largest integer less than or equal to an `f128`./// [`f128::floor`](../../std/primitive.f128.html#method.floor)/// Returns the smallest integer greater than or equal to an `f16`./// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)ceilf32/// Returns the smallest integer greater than or equal to an `f32`./// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)ceilf64/// Returns the smallest integer greater than or equal to an `f64`./// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)/// Returns the smallest integer greater than or equal to an `f128`./// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)/// Returns the integer part of an `f16`./// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)truncf32/// Returns the integer part of an `f32`./// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)truncf64/// Returns the integer part of an `f64`./// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)/// Returns the integer part of an `f128`./// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)round_ties_even_f16/// Returns the nearest integer to an `f16`. Rounds half-way cases to the number with an even/// least significant digit./// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)round_ties_even_f32/// Returns the nearest integer to an `f32`. Rounds half-way cases to the number with an even/// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)round_ties_even_f64/// Returns the nearest integer to an `f64`. Rounds half-way cases to the number with an even/// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)round_ties_even_f128/// Returns the nearest integer to an `f128`. Rounds half-way cases to the number with an even/// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)/// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero./// [`f16::round`](../../std/primitive.f16.html#method.round)roundf32/// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero./// [`f32::round`](../../std/primitive.f32.html#method.round)roundf64/// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero./// [`f64::round`](../../std/primitive.f64.html#method.round)/// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero./// [`f128::round`](../../std/primitive.f128.html#method.round)fadd_fast/// Float addition that allows optimizations based on algebraic rules./// Requires that inputs and output of the operation are finite, causing UB otherwise.fsub_fast/// Float subtraction that allows optimizations based on algebraic rules.fmul_fast/// Float multiplication that allows optimizations based on algebraic rules.fdiv_fast/// Float division that allows optimizations based on algebraic rules.frem_fast/// Float remainder that allows optimizations based on algebraic rules./// Converts with LLVM’s fptoui/fptosi, which may return undef for values out of range/// (<https://github.com/rust-lang/rust/issues/10184>)/// Stabilized as [`f32::to_int_unchecked`] and [`f64::to_int_unchecked`].fadd_algebraic/// Stabilized as [`f16::algebraic_add`], [`f32::algebraic_add`], [`f64::algebraic_add`] and [`f128::algebraic_add`].fsub_algebraic/// Stabilized as [`f16::algebraic_sub`], [`f32::algebraic_sub`], [`f64::algebraic_sub`] and [`f128::algebraic_sub`].fmul_algebraic/// Stabilized as [`f16::algebraic_mul`], [`f32::algebraic_mul`], [`f64::algebraic_mul`] and [`f128::algebraic_mul`].fdiv_algebraic/// Stabilized as [`f16::algebraic_div`], [`f32::algebraic_div`], [`f64::algebraic_div`] and [`f128::algebraic_div`].frem_algebraic/// Stabilized as [`f16::algebraic_rem`], [`f32::algebraic_rem`], [`f64::algebraic_rem`] and [`f128::algebraic_rem`].ctpop/// Returns the number of bits set in an integer type `T`/// The stabilized versions of this intrinsic are available on the integer/// primitives via the `count_ones` method. For example,/// [`u32::count_ones`]ctlz/// Returns the number of leading unset bits (zeroes) in an integer type `T`./// primitives via the `leading_zeros` method. For example,/// [`u32::leading_zeros`]/// #![feature(core_intrinsics)]/// # #![allow(internal_features)]/// use std::intrinsics::ctlz;/// let x = 0b0001_1100_u8;/// let num_leading = ctlz(x);/// assert_eq!(num_leading, 3);/// An `x` with value `0` will return the bit width of `T`./// let x = 0u16;/// assert_eq!(num_leading, 16);ctlz_nonzero/// Like `ctlz`, but extra-unsafe as it returns `undef` when/// given an `x` with value `0`./// use std::intrinsics::ctlz_nonzero;/// let num_leading = unsafe { ctlz_nonzero(x) };cttz/// Returns the number of trailing unset bits (zeroes) in an integer type `T`./// primitives via the `trailing_zeros` method. For example,/// [`u32::trailing_zeros`]/// use std::intrinsics::cttz;/// let x = 0b0011_1000_u8;/// let num_trailing = cttz(x);/// assert_eq!(num_trailing, 3);/// An `x` with value `0` will return the bit width of `T`:/// assert_eq!(num_trailing, 16);cttz_nonzero/// Like `cttz`, but extra-unsafe as it returns `undef` when/// use std::intrinsics::cttz_nonzero;/// let num_trailing = unsafe { cttz_nonzero(x) };/// Reverses the bytes in an integer type `T`./// primitives via the `swap_bytes` method. For example,/// [`u32::swap_bytes`]bitreverse/// Reverses the bits in an integer type `T`./// primitives via the `reverse_bits` method. For example,/// [`u32::reverse_bits`]three_way_compare/// Does a three-way comparison between the two arguments,/// which must be of character or integer (signed or unsigned) type./// This was originally added because it greatly simplified the MIR in `cmp`/// implementations, and then LLVM 20 added a backend intrinsic for it too./// The stabilized version of this intrinsic is [`Ord::cmp`]./// Combine two values which have no bits in common./// This allows the backend to implement it as `a + b` *or* `a | b`,/// depending which is easier to implement on a specific target./// Requires that `(a & b) == 0`, or equivalently that `(a | b) == (a + b)`./// Otherwise it's immediate UB.// the fallbacks all `assume` to tell Miriadd_with_overflow/// Performs checked integer addition./// primitives via the `overflowing_add` method. For example,/// [`u32::overflowing_add`]sub_with_overflow/// Performs checked integer subtraction/// primitives via the `overflowing_sub` method. For example,/// [`u32::overflowing_sub`]mul_with_overflow/// Performs checked integer multiplication/// primitives via the `overflowing_mul` method. For example,/// [`u32::overflowing_mul`]/// Performs full-width multiplication and addition with a carry:/// `multiplier * multiplicand + addend + carry`./// This is possible without any overflow.  For `uN`:///    MAX * MAX + MAX + MAX/// => (2ⁿ-1) × (2ⁿ-1) + (2ⁿ-1) + (2ⁿ-1)/// => (2²ⁿ - 2ⁿ⁺¹ + 1) + (2ⁿ⁺¹ - 2)/// => 2²ⁿ - 1/// For `iN`, the upper bound is MIN * MIN + MAX + MAX => 2²ⁿ⁻² + 2ⁿ - 2,/// and the lower bound is MAX * MIN + MIN + MIN => -2²ⁿ⁻² - 2ⁿ + 2ⁿ⁺¹./// This currently supports unsigned integers *only*, no signed ones./// The stabilized versions of this intrinsic are available on integers.exact_div/// Performs an exact division, resulting in undefined behavior where/// `x % y != 0` or `y == 0` or `x == T::MIN && y == -1`/// Performs an unchecked division, resulting in undefined behavior/// where `y == 0` or `x == T::MIN && y == -1`/// Safe wrappers for this intrinsic are available on the integer/// primitives via the `checked_div` method. For example,/// [`u32::checked_div`]/// Returns the remainder of an unchecked division, resulting in/// undefined behavior when `y == 0` or `x == T::MIN && y == -1`/// primitives via the `checked_rem` method. For example,/// [`u32::checked_rem`]/// Performs an unchecked left shift, resulting in undefined behavior when/// `y < 0` or `y >= N`, where N is the width of T in bits./// primitives via the `checked_shl` method. For example,/// [`u32::checked_shl`]/// Performs an unchecked right shift, resulting in undefined behavior when/// primitives via the `checked_shr` method. For example,/// [`u32::checked_shr`]/// Returns the result of an unchecked addition, resulting in/// undefined behavior when `x + y > T::MAX` or `x + y < T::MIN`./// The stable counterpart of this intrinsic is `unchecked_add` on the various/// integer types, such as [`u16::unchecked_add`] and [`i64::unchecked_add`]./// Returns the result of an unchecked subtraction, resulting in/// undefined behavior when `x - y > T::MAX` or `x - y < T::MIN`./// The stable counterpart of this intrinsic is `unchecked_sub` on the various/// integer types, such as [`u16::unchecked_sub`] and [`i64::unchecked_sub`]./// Returns the result of an unchecked multiplication, resulting in/// undefined behavior when `x * y > T::MAX` or `x * y < T::MIN`./// The stable counterpart of this intrinsic is `unchecked_mul` on the various/// integer types, such as [`u16::unchecked_mul`] and [`i64::unchecked_mul`]./// Performs rotate left./// primitives via the `rotate_left` method. For example,/// [`u32::rotate_left`]/// Performs rotate right./// primitives via the `rotate_right` method. For example,/// [`u32::rotate_right`]/// Returns (a + b) mod 2<sup>N</sup>, where N is the width of T in bits./// primitives via the `wrapping_add` method. For example,/// [`u32::wrapping_add`]/// Returns (a - b) mod 2<sup>N</sup>, where N is the width of T in bits./// primitives via the `wrapping_sub` method. For example,/// [`u32::wrapping_sub`]/// Returns (a * b) mod 2<sup>N</sup>, where N is the width of T in bits./// primitives via the `wrapping_mul` method. For example,/// [`u32::wrapping_mul`]/// Computes `a + b`, saturating at numeric bounds./// primitives via the `saturating_add` method. For example,/// [`u32::saturating_add`]/// Computes `a - b`, saturating at numeric bounds./// primitives via the `saturating_sub` method. For example,/// [`u32::saturating_sub`]/// Funnel Shift left./// Concatenates `a` and `b` (with `a` in the most significant half),/// creating an integer twice as wide. Then shift this integer left/// by `shift`), and extract the most significant half. If `a` and `b`/// are the same, this is equivalent to a rotate left operation./// It is undefined behavior if `shift` is greater than or equal to the/// bit size of `T`./// Safe versions of this intrinsic are available on the integer primitives/// via the `funnel_shl` method. For example, [`u32::funnel_shl`]./// Funnel Shift right./// creating an integer twice as wide. Then shift this integer right/// by `shift` (taken modulo the bit size of `T`), and extract the/// least significant half. If `a` and `b` are the same, this is equivalent/// to a rotate right operation./// Safer versions of this intrinsic are available on the integer primitives/// via the `funnel_shr` method. For example, [`u32::funnel_shr`]read_via_copy/// This is an implementation detail of [`crate::ptr::read`] and should/// not be used anywhere else.  See its comments for why this exists./// This intrinsic can *only* be called where the pointer is a local without/// projections (`read_via_copy(ptr)`, not `read_via_copy(*ptr)`) so that it/// trivially obeys runtime-MIR rules about derefs in operands.write_via_move/// This is an implementation detail of [`crate::ptr::write`] and should/// projections (`write_via_move(ptr, x)`, not `write_via_move(*ptr, x)`) so/// that it trivially obeys runtime-MIR rules about derefs in operands.discriminant_value/// Returns the value of the discriminant for the variant in 'v';/// if `T` has no discriminant, returns `0`./// The stabilized version of this intrinsic is [`core::mem::discriminant`]./// Rust's "try catch" construct for unwinding. Invokes the function pointer `try_fn` with the/// data pointer `data`, and calls `catch_fn` if unwinding occurs while `try_fn` runs./// Returns `1` if unwinding occurred and `catch_fn` was called; returns `0` otherwise./// `catch_fn` must not unwind./// The third argument is a function called if an unwind occurs (both Rust `panic` and foreign/// unwinds). This function takes the data pointer and a pointer to the target- and/// runtime-specific exception object that was caught./// Note that in the case of a foreign unwinding operation, the exception object data may not be/// safely usable from Rust, and should not be directly exposed via the standard library. To/// prevent unsafe access, the library implementation may either abort the process or present an/// opaque error type to the user./// For more information, see the compiler's source, as well as the documentation for the stable/// version of this intrinsic, `std::panic::catch_unwind`.nontemporal_store/// Emits a `nontemporal` store, which gives a hint to the CPU that the data should not be held/// in cache. Except for performance, this is fully equivalent to `ptr.write(val)`./// Not all architectures provide such an operation. For instance, x86 does not: while `MOVNT`/// exists, that operation is *not* equivalent to `ptr.write(val)` (`MOVNT` writes can be reordered/// in ways that are not allowed for regular writes).ptr_offset_from/// See documentation of `<*const T>::offset_from` for details.ptr_offset_from_unsigned/// See documentation of `<*const T>::offset_from_unsigned` for details.rustc_do_not_const_checkptr_guaranteed_cmp/// See documentation of `<*const T>::guaranteed_eq` for details./// Returns `2` if the result is unknown./// Returns `1` if the pointers are guaranteed equal./// Returns `0` if the pointers are guaranteed inequal.raw_eq/// Determines whether the raw bytes of the two values are equal./// This is particularly handy for arrays, since it allows things like just/// comparing `i96`s instead of forcing `alloca`s for `[6 x i16]`./// Above some backend-decided threshold this will emit calls to `memcmp`,/// like slice equality does, instead of causing massive code size./// Since this works by comparing the underlying bytes, the actual `T` is/// not particularly important.  It will be used for its size and alignment,/// but any validity restrictions will be ignored, not enforced./// It's UB to call this if any of the *bytes* in `*a` or `*b` are uninitialized./// Note that this is a stricter criterion than just the *values* being/// fully-initialized: if `T` has padding, it's UB to call this intrinsic./// At compile-time, it is furthermore UB to call this if any of the bytes/// in `*a` or `*b` have provenance./// (The implementation is allowed to branch on the results of comparisons,/// which is UB if any of their inputs are `undef`.)/// Lexicographically compare `[left, left + bytes)` and `[right, right + bytes)`/// as unsigned bytes, returning negative if `left` is less, zero if all the/// bytes match, or positive if `left` is greater./// This underlies things like `<[u8]>::cmp`, and will usually lower to `memcmp`./// `left` and `right` must each be [valid] for reads of `bytes` bytes./// Note that this applies to the whole range, not just until the first byte/// that differs.  That allows optimizations that can read in large chunks./// See documentation of [`std::hint::black_box`] for details./// [`std::hint::black_box`]: crate::hint::black_boxARGRET/// Selects which function to call depending on the context./// If this function is evaluated at compile-time, then a call to this/// intrinsic will be replaced with a call to `called_in_const`. It gets/// replaced with a call to `called_at_rt` otherwise./// This function is safe to call, but note the stability concerns below./// # Type Requirements/// The two functions must be both function items. They cannot be function/// pointers or closures. The first function must be a `const fn`./// `arg` will be the tupled arguments that will be passed to either one of/// the two functions, therefore, both functions must accept the same type of/// arguments. Both functions must return RET./// # Stability concerns/// Rust has not yet decided that `const fn` are allowed to tell whether/// they run at compile-time or at runtime. Therefore, when using this/// intrinsic anywhere that can be reached from stable, it is crucial that/// the end-to-end behavior of the stable `const fn` is the same for both/// modes of execution. (Here, Undefined Behavior is considered "the same"/// as any other behavior, so if the function exhibits UB at runtime then/// it may do whatever it wants at compile-time.)/// Here is an example of how this could cause a problem:/// #![feature(const_eval_select)]/// use std::intrinsics::const_eval_select;/// // Standard library/// pub const fn inconsistent() -> i32 {///     fn runtime() -> i32 { 1 }///     const fn compiletime() -> i32 { 2 }///     // ⚠ This code violates the required equivalence of `compiletime`///     // and `runtime`.///     const_eval_select((), compiletime, runtime)/// // User Crate/// const X: i32 = inconsistent();/// let x = inconsistent();/// assert_eq!(x, X);/// Currently such an assertion would always succeed; until Rust decides/// otherwise, that principle should not be violated./// A macro to make it easier to invoke const_eval_select. Use as follows:/// ```rust,ignore (just a macro example)/// const_eval_select!(///     @capture { arg1: i32 = some_expr, arg2: T = other_expr } -> U:///     if const #[attributes_for_const_arm] {///         // Compile-time code goes here.///     } else #[attributes_for_runtime_arm] {///         // Run-time code goes here./// The `@capture` block declares which surrounding variables / expressions can be/// used inside the `if const`./// Note that the two arms of this `if` really each become their own function, which is why the/// macro supports setting attributes for those functions. The runtime function is always/// marked as `#[inline]`./// See [`const_eval_select()`] for the rules and requirements around that intrinsic.rustc_const_stable_indirectis_val_statically_known/// Returns whether the argument's value is statically known at/// This is useful when there is a way of writing the code that will/// be *faster* when some variables have known values, but *slower*/// in the general case: an `if is_val_statically_known(var)` can be used/// to select between these two variants. The `if` will be optimized away/// and only the desired branch remains./// Formally speaking, this function non-deterministically returns `true`/// or `false`, and the caller has to ensure sound behavior for both cases./// In other words, the following code has *Undefined Behavior*:/// use std::hint::unreachable_unchecked;/// use std::intrinsics::is_val_statically_known;/// if !is_val_statically_known(0) { unsafe { unreachable_unchecked(); } }/// This also means that the following code's behavior is unspecified; it/// may panic, or it may not:/// assert_eq!(is_val_statically_known(0), is_val_statically_known(0));/// Unsafe code may not rely on `is_val_statically_known` returning any/// particular value, ever. However, the compiler will generally make it/// return `true` only if the value of the argument is actually known./// While it is safe to call, this intrinsic may behave differently in/// a `const` context than otherwise. See the [`const_eval_select()`]/// documentation for an explanation of the issues this can cause. Unlike/// `const_eval_select`, this intrinsic isn't guaranteed to behave/// deterministically even in a `const` context./// `T` must be either a `bool`, a `char`, a primitive numeric type (e.g. `f32`,/// but not `NonZeroISize`), or any thin pointer (e.g. `*mut String`)./// Any other argument types *may* cause a compiler error./// ## Pointers/// When the input is a pointer, only the pointer itself is/// ever considered. The pointee has no effect. Currently, these functions/// behave identically:/// fn foo(x: &i32) -> bool {///     is_val_statically_known(x)/// fn bar(x: &i32) -> bool {///     is_val_statically_known(///         (x as *const i32).addr()/// # _ = foo(&5_i32);/// # _ = bar(&5_i32);typed_swap_nonoverlapping/// Non-overlapping *typed* swap of a single value./// The codegen backends will replace this with a better implementation when/// `T` is a simple type that can be loaded and stored as an immediate./// The stabilized form of this intrinsic is [`crate::mem::swap`]./// * Both `x` and `y` must be [valid] for both reads and writes./// * Both `x` and `y` must be properly aligned./// * The region of memory beginning at `x` must *not* overlap with the region of memory///   beginning at `y`./// * The memory pointed by `x` and `y` must both contain values of type `T`./// Returns whether we should perform some UB-checking at runtime. This eventually evaluates to/// `cfg!(ub_checks)`, but behaves different from `cfg!` when mixing crates built with different/// flags: if the crate has UB checks enabled or carries the `#[rustc_preserve_ub_checks]`/// attribute, evaluation is delayed until monomorphization (or until the call gets inlined into/// a crate that does not delay evaluation further); otherwise it can happen any time./// The common case here is a user program built with ub_checks linked against the distributed/// sysroot which is built without ub_checks but with `#[rustc_preserve_ub_checks]`./// For code that gets monomorphized in the user crate (i.e., generic functions and functions with/// `#[inline]`), gating assertions on `ub_checks()` rather than `cfg!(ub_checks)` means that/// assertions are enabled whenever the *user crate* has UB checks enabled. However, if the/// user has UB checks disabled, the checks will still get optimized out. This intrinsic is/// primarily used by [`crate::ub_checks::assert_unsafe_precondition`].// just for UB checksoverflow_checks/// Returns whether we should perform some overflow-checking at runtime. This eventually evaluates to/// `cfg!(overflow_checks)`, but behaves different from `cfg!` when mixing crates built with different/// flags: if the crate has overflow checks enabled or carries the `#[rustc_inherit_overflow_checks]`/// The common case here is a user program built with overflow_checks linked against the distributed/// sysroot which is built without overflow_checks but with `#[rustc_inherit_overflow_checks]`./// `#[inline]`), gating assertions on `overflow_checks()` rather than `cfg!(overflow_checks)` means that/// assertions are enabled whenever the *user crate* has overflow checks enabled. However if the/// user has overflow checks disabled, the checks will still get optimized out./// Allocates a block of memory at compile time./// At runtime, just returns a null pointer./// - The `align` argument must be a power of two.///    - At compile time, a compile error occurs if this constraint is violated.///    - At runtime, it is not checked.const_deallocate/// Deallocates a memory which allocated by `intrinsics::const_allocate` at compile time./// At runtime, does nothing./// - If the `ptr` is created in an another const, this intrinsic doesn't deallocate it./// - If the `ptr` is pointing to a local variable, this intrinsic doesn't deallocate it."contract_check_requires"contract_check_requires/// Check if the pre-condition `cond` has been met./// By default, if `contract_checks` is enabled, this will panic with no unwind if the condition/// returns false./// Note that this function is a no-op during constant evaluation.// Calls to this function get inserted by an AST expansion pass, which uses the equivalent of// `#[allow_internal_unstable]` to allow using `contracts_internals` functions. Const-checking// doesn't honor `#[allow_internal_unstable]`, so for the const feature gate we use the user-facing// `contracts` feature rather than the perma-unstable `contracts_internals`"contract_check_ensures"contract_check_ensures/// Check if the post-condition `cond` has been met./// If `cond` is `None`, then no postcondition checking is performed.vtable_size/// The intrinsic will return the size stored in that vtable./// `ptr` must point to a vtable.vtable_align/// The intrinsic will return the alignment stored in that vtable./// The size of a type in bytes./// More specifically, this is the offset in bytes between successive/// items of the same type, including alignment padding./// The stabilized version of this intrinsic is [`core::mem::size_of`]./// The minimum alignment of a type./// The stabilized version of this intrinsic is [`core::mem::align_of`]."offset_of"/// The offset of a field inside a type./// This intrinsic can only be evaluated at compile-time, and should only appear in/// constants or inline const blocks./// The stabilized version of this intrinsic is [`core::mem::offset_of`]./// This intrinsic is also a lang item so `offset_of!` can desugar to calls to it.variant_count/// Returns the number of variants of the type `T` cast to a `usize`;/// if `T` has no variants, returns `0`. Uninhabited variants will be counted./// The to-be-stabilized version of this intrinsic is [`crate::mem::variant_count`]./// The size of the referenced value in bytes./// The stabilized version of this intrinsic is [`core::mem::size_of_val`]./// See [`crate::mem::size_of_val_raw`] for safety conditions./// The required alignment of the referenced value./// The stabilized version of this intrinsic is [`core::mem::align_of_val`]./// See [`crate::mem::align_of_val_raw`] for safety conditions./// Gets a static string slice containing the name of a type./// The stabilized version of this intrinsic is [`core::any::type_name`]./// Gets an identifier which is globally unique to the specified type. This/// function will return the same value for a type regardless of whichever/// crate it is invoked in./// The stabilized version of this intrinsic is [`core::any::TypeId::of`].type_id_eq/// Tests (at compile-time) if two [`crate::any::TypeId`] instances identify the/// same type. This is necessary because at const-eval time the actual discriminating/// data is opaque and cannot be inspected directly./// The stabilized version of this intrinsic is the [PartialEq] impl for [`core::any::TypeId`].aggregate_raw_ptr/// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`./// This is used to implement functions like `slice::from_raw_parts_mut` and/// `ptr::from_raw_parts` in a way compatible with the compiler being able to/// change the possible layouts of pointers./// Lowers in MIR to `Rvalue::UnaryOp` with `UnOp::PtrMetadata`./// This is used to implement functions like `ptr::metadata`."import this function via `std::ptr` instead"/// This is an accidentally-stable alias to [`ptr::copy_nonoverlapping`]; use that instead.// Note (intentionally not in the doc comment): `ptr::copy_nonoverlapping` adds some extra// debug assertions; if you are writing compiler tests or code inside the standard library// that wants to avoid those debug assertions, directly call this intrinsic instead./// This is an accidentally-stable alias to [`ptr::copy`]; use that instead.// Note (intentionally not in the doc comment): `ptr::copy` adds some extra/// This is an accidentally-stable alias to [`ptr::write_bytes`]; use that instead.// Note (intentionally not in the doc comment): `ptr::write_bytes` adds some extraminnumf16/// Returns the minimum of two `f16` values, ignoring NaN./// This behaves like IEEE 754-2008 minNum. In particular:/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal/// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically./// The stabilized version of this intrinsic is [`f16::min`].minnumf32/// Returns the minimum of two `f32` values, ignoring NaN./// The stabilized version of this intrinsic is [`f32::min`].minnumf64/// Returns the minimum of two `f64` values, ignoring NaN./// The stabilized version of this intrinsic is [`f64::min`].minnumf128/// Returns the minimum of two `f128` values, ignoring NaN./// The stabilized version of this intrinsic is [`f128::min`].minimumf16/// Returns the minimum of two `f16` values, propagating NaN./// This behaves like IEEE 754-2019 minimum. In particular:/// If one of the arguments is NaN, then a NaN is returned using the usual NaN propagation rules./// For this operation, -0.0 is considered to be strictly less than +0.0.minimumf32/// Returns the minimum of two `f32` values, propagating NaN.minimumf64/// Returns the minimum of two `f64` values, propagating NaN.minimumf128/// Returns the minimum of two `f128` values, propagating NaN.maxnumf16/// Returns the maximum of two `f16` values, ignoring NaN./// This behaves like IEEE 754-2008 maxNum. In particular:/// The stabilized version of this intrinsic is [`f16::max`].maxnumf32/// Returns the maximum of two `f32` values, ignoring NaN./// The stabilized version of this intrinsic is [`f32::max`].maxnumf64/// Returns the maximum of two `f64` values, ignoring NaN./// The stabilized version of this intrinsic is [`f64::max`].maxnumf128/// Returns the maximum of two `f128` values, ignoring NaN./// The stabilized version of this intrinsic is [`f128::max`].maximumf16/// Returns the maximum of two `f16` values, propagating NaN./// This behaves like IEEE 754-2019 maximum. In particular:maximumf32/// Returns the maximum of two `f32` values, propagating NaN.maximumf64/// Returns the maximum of two `f64` values, propagating NaN.maximumf128/// Returns the maximum of two `f128` values, propagating NaN./// Returns the absolute value of an `f16`./// [`f16::abs`](../../std/primitive.f16.html#method.abs)fabsf32/// Returns the absolute value of an `f32`./// [`f32::abs`](../../std/primitive.f32.html#method.abs)fabsf64/// Returns the absolute value of an `f64`./// [`f64::abs`](../../std/primitive.f64.html#method.abs)/// Returns the absolute value of an `f128`./// [`f128::abs`](../../std/primitive.f128.html#method.abs)/// Copies the sign from `y` to `x` for `f16` values./// [`f16::copysign`](../../std/primitive.f16.html#method.copysign)copysignf32/// Copies the sign from `y` to `x` for `f32` values./// [`f32::copysign`](../../std/primitive.f32.html#method.copysign)copysignf64/// Copies the sign from `y` to `x` for `f64` values./// [`f64::copysign`](../../std/primitive.f64.html#method.copysign)/// Copies the sign from `y` to `x` for `f128` values./// [`f128::copysign`](../../std/primitive.f128.html#method.copysign)autodiff/// Generates the LLVM body for the automatic differentiation of `f` using Enzyme,/// with `df` as the derivative function and `args` as its arguments./// Used internally as the body of `df` when expanding the `#[autodiff_forward]`/// and `#[autodiff_reverse]` attribute macros./// Type Parameters:/// - `F`: The original function to differentiate. Must be a function item./// - `G`: The derivative function. Must be a function item./// - `T`: A tuple of arguments passed to `df`./// - `R`: The return type of the derivative function./// This shows where the `autodiff` intrinsic is used during macro expansion:/// ```rust,ignore (macro example)/// #[autodiff_forward(df1, Dual, Const, Dual)]/// pub fn f1(x: &[f64], y: f64) -> f64 {/// expands to:/// #[rustc_autodiff]/// #[inline(never)]///     ::core::panicking::panic("not implemented")/// #[rustc_autodiff(Forward, 1, Dual, Const, Dual)]/// pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64) {///     ::core::intrinsics::autodiff(f1::<>, df1::<>, (x, bx_0, y))offload/// Generates the LLVM body of a wrapper function to offload a kernel `f`./// - `F`: The kernel to offload. Must be a function item./// - `T`: A tuple of arguments passed to `f`./// - `R`: The return type of the kernel./// Example usage (pseudocode):/// ```rust,ignore (pseudocode)/// fn kernel(x: *mut [f64; 128]) {///     core::intrinsics::offload(kernel_1, (x,))/// #[cfg(target_os = "linux")]///     pub fn kernel_1(array_b: *mut [f64; 128]);/// #[cfg(not(target_os = "linux"))]/// #[rustc_offload_kernel]/// extern "gpu-kernel" fn kernel_1(x: *mut [f64; 128]) {///     unsafe { (*x)[0] = 21.0 };/// For reference, see the Clang documentation on offloading:/// <https://clang.llvm.org/docs/OffloadingDesign.html>.miri_promise_symbolic_alignment/// Inform Miri that a given pointer definitely has a certain alignment./// Copies the current location of arglist `src` to the arglist `dst`./// You must check the following invariants before you call this function:/// - `dest` must be non-null and point to valid, writable memory./// - `dest` must not alias `src`./// Loads an argument of type `T` from the `va_list` `ap` and increment the/// argument `ap` points to./// Destroy the arglist `ap` after initialization with `va_start` or `va_copy`./// `ap` must not be used to access variable arguments after this call.//! Compiler intrinsics.//! The functions in this module are implementation details of `core` and should//! not be used outside of the standard library. We generally provide access to//! intrinsics via stable wrapper functions. Use these instead.//! These are the imports making intrinsics available to Rust code. The actual implementations live in the compiler.//! Some of these intrinsics are lowered to MIR in <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_transform/src/lower_intrinsics.rs>.//! The remaining intrinsics are implemented for the LLVM backend in <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs>//! and <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_llvm/src/intrinsic.rs>,//! and for const evaluation in <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_const_eval/src/interpret/intrinsics.rs>.//! # Const intrinsics//! In order to make an intrinsic unstable usable at compile-time, copy the implementation from//! <https://github.com/rust-lang/miri/blob/master/src/intrinsics> to//! <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_const_eval/src/interpret/intrinsics.rs>//! and make the intrinsic declaration below a `const fn`. This should be done in coordination with//! wg-const-eval.//! If an intrinsic is supposed to be used from a `const fn` with a `rustc_const_stable` attribute,//! `#[rustc_intrinsic_const_stable_indirect]` needs to be added to the intrinsic. Such a change requires//! T-lang approval, because it may bake a feature into the language that cannot be replicated in//! user code without compiler support.//! # Volatiles//! The volatile intrinsics provide operations intended to act on I/O//! memory, which are guaranteed to not be reordered by the compiler//! across other volatile intrinsics. See [`read_volatile`][ptr::read_volatile]//! and [`write_volatile`][ptr::write_volatile].//! # Atomics//! The atomic intrinsics provide common atomic operations on machine//! words, with multiple possible memory orderings. See the//! [atomic types][atomic] docs for details.//! # Unwinding//! Rust intrinsics may, in general, unwind. If an intrinsic can never unwind, add the//! `#[rustc_nounwind]` attribute so that the compiler can make use of this fact.//! However, even for intrinsics that may unwind, rustc assumes that a Rust intrinsics will never//! initiate a foreign (non-Rust) unwind, and thus for panic=abort we can always assume that these//! intrinsics cannot unwind.// N.B., these intrinsics take raw pointers because they mutate aliased// memory, which is not valid for either `&` or `&mut`.simd_insert/// Inserts an element into a vector, returning the updated vector./// `T` must be a vector with element type `U`, and `idx` must be `const`./// `idx` must be in-bounds of the vector.simd_extract/// Extracts an element from a vector./// `idx` must be const and in-bounds of the vector.simd_insert_dyn/// `T` must be a vector with element type `U`./// If the index is `const`, [`simd_insert`] may emit better assembly.simd_extract_dyn/// If the index is `const`, [`simd_extract`] may emit better assembly.simd_add/// Adds two simd vectors elementwise./// `T` must be a vector of integers or floats.simd_sub/// Subtracts `rhs` from `lhs` elementwise.simd_mul/// Multiplies two simd vectors elementwise.simd_div/// Divides `lhs` by `rhs` elementwise./// For integers, `rhs` must not contain any zero elements./// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior.simd_rem/// Returns remainder of two vectors elementwise.simd_shl/// Shifts vector left elementwise, with UB on overflow./// Shifts `lhs` left by `rhs`, shifting in sign bits for signed types./// `T` must be a vector of integers./// Each element of `rhs` must be less than `<int>::BITS`.simd_shr/// Shifts vector right elementwise, with UB on overflow./// Shifts `lhs` right by `rhs`, shifting in sign bits for signed types.simd_funnel_shl/// Funnel Shifts vector left elementwise, with UB on overflow./// Concatenates `a` and `b` elementwise (with `a` in the most significant half),/// creating a vector of the same length, but with each element being twice as/// wide. Then shift this vector left elementwise by `shift`, shifting in zeros,/// and extract the most significant half of each of the elements. If `a` and `b`/// are the same, this is equivalent to an elementwise rotate left operation./// Each element of `shift` must be less than `<int>::BITS`.simd_funnel_shr/// Funnel Shifts vector right elementwise, with UB on overflow./// wide. Then shift this vector right elementwise by `shift`, shifting in zeros,/// and extract the least significant half of each of the elements. If `a` and `b`/// are the same, this is equivalent to an elementwise rotate right operation.simd_and/// "And"s vectors elementwise.simd_or/// "Ors" vectors elementwise.simd_xor/// "Exclusive ors" vectors elementwise.simd_cast/// Numerically casts a vector, elementwise./// `T` and `U` must be vectors of integers or floats, and must have the same length./// When casting floats to integers, the result is truncated. Out-of-bounds result lead to UB./// When casting integers to floats, the result is rounded./// Otherwise, truncates or extends the value, maintaining the sign for signed integers./// Casting from integer types is always safe./// Casting between two float types is also always safe./// Casting floats to integers truncates, following the same rules as `to_int_unchecked`./// Specifically, each element must:/// * Not be `NaN`/// * Not be infinite/// * Be representable in the return type, after truncating off its fractional partsimd_as/// `T` and `U` be a vectors of integers or floats, and must have the same length./// Like `simd_cast`, but saturates float-to-integer conversions (NaN becomes 0)./// This matches regular `as` and is always safe./// When casting floats to integers, the result is truncated.simd_neg/// Negates a vector elementwise./// Rust panics for `-<int>::Min` due to overflow, but it is not UB with this intrinsic.simd_fabs/// Returns absolute value of a vector, elementwise./// `T` must be a vector of floating-point primitive types.simd_fmin/// Returns the minimum of two vectors, elementwise./// Follows IEEE-754 `minNum` semantics.simd_fmax/// Returns the maximum of two vectors, elementwise./// Follows IEEE-754 `maxNum` semantics.simd_eq/// Tests elementwise equality of two vectors./// `U` must be a vector of integers with the same number of elements and element size as `T`./// Returns `0` for false and `!0` for true.simd_ne/// Tests elementwise inequality equality of two vectors.simd_lt/// Tests if `x` is less than `y`, elementwise.simd_le/// Tests if `x` is less than or equal to `y`, elementwise./// Tests if `x` is greater than `y`, elementwise./// Tests if `x` is greater than or equal to `y`, elementwise.simd_shuffle/// Shuffles two vectors by const indices./// `T` must be a vector./// `U` must be a **const** vector of `u32`s. This means it must either refer to a named/// const or be given as an inline const expression (`const { ... }`)./// `V` must be a vector with the same element type as `T` and the same length as `U`./// Returns a new vector such that element `i` is selected from `xy[idx[i]]`, where `xy`/// is the concatenation of `x` and `y`. It is a compile-time error if `idx[i]` is out-of-bounds/// of `xy`.simd_gather/// Reads a vector of pointers./// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`./// `V` must be a vector of integers with the same length as `T` (but any element size)./// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, read the pointer./// Otherwise if the corresponding value in `mask` is `0`, return the corresponding value from/// `val`./// Unmasked values in `T` must be readable as if by `<ptr>::read` (e.g. aligned to the element/// type)./// `mask` must only contain `0` or `!0` values.simd_scatter/// Writes to a vector of pointers./// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, write the/// corresponding value in `val` to the pointer./// Otherwise if the corresponding value in `mask` is `0`, do nothing./// The stores happen in left-to-right order./// (This is relevant in case two of the stores overlap.)/// Unmasked values in `T` must be writeable as if by `<ptr>::write` (e.g. aligned to the elementSimdAlign// These values must match the compiler's `SimdAlign` defined in/// No alignment requirements on the pointer/// The pointer must be aligned to the element type of the SIMD vector/// The pointer must be aligned to the SIMD vector type/// A type for alignment options for SIMD masked load/store intrinsics.simd_masked_load/// `U` must be a pointer to the element type of `T`/// For each element, if the corresponding value in `mask` is `!0`, read the corresponding/// pointer offset from `ptr`./// The first element is loaded from `ptr`, the second from `ptr.wrapping_offset(1)` and so on./// `ptr` must be aligned according to the `ALIGN` parameter, see [`SimdAlign`] for details.simd_masked_store/// For each element, if the corresponding value in `mask` is `!0`, write the corresponding/// value in `val` to the pointer offset from `ptr`./// The first element is written to `ptr`, the second to `ptr.wrapping_offset(1)` and so on.simd_saturating_add/// Adds two simd vectors elementwise, with saturation./// `T` must be a vector of integer primitive types.simd_saturating_sub/// Subtracts two simd vectors elementwise, with saturation./// Subtract `rhs` from `lhs`.simd_reduce_add_ordered/// Adds elements within a vector from left to right./// `U` must be the element type of `T`./// Starting with the value `y`, add the elements of `x` and accumulate.simd_reduce_add_unordered/// Adds elements within a vector in arbitrary order. May also be re-associated with/// unordered additions on the inputs/outputs.simd_reduce_mul_ordered/// Multiplies elements within a vector from left to right./// Starting with the value `y`, multiply the elements of `x` and accumulate.simd_reduce_mul_unordered/// Multiplies elements within a vector in arbitrary order. May also be re-associated withsimd_reduce_all/// Checks if all mask values are true./// `x` must contain only `0` or `!0`.simd_reduce_any/// Checks if any mask value is true.simd_reduce_max/// Returns the maximum element of a vector./// For floating-point values, uses IEEE-754 `maxNum`.simd_reduce_min/// Returns the minimum element of a vector./// For floating-point values, uses IEEE-754 `minNum`.simd_reduce_and/// Logical "and"s all elements together.simd_reduce_or/// Logical "ors" all elements together.simd_reduce_xor/// Logical "exclusive ors" all elements together.simd_bitmask/// Truncates an integer vector to a bitmask./// `T` must be an integer vector./// `U` must be either the smallest unsigned integer with at least as many bits as the length/// of `T`, or the smallest array of `u8` with at least as many bits as the length of `T`./// Each element is truncated to a single bit and packed into the result./// No matter whether the output is an array or an unsigned integer, it is treated as a single/// contiguous list of bits. The bitmask is always packed on the least-significant side of the/// output, and padded with 0s in the most-significant bits. The order of the bits depends on/// endianness:/// * On little endian, the least significant bit corresponds to the first vector element./// * On big endian, the least significant bit corresponds to the last vector element./// For example, `[!0, 0, !0, !0]` packs to/// - `0b1101u8` or `[0b1101]` on little endian, and/// - `0b1011u8` or `[0b1011]` on big endian./// To consider a larger example,/// `[!0, 0, 0, 0, 0, 0, 0, 0, !0, !0, 0, 0, 0, 0, !0, 0]` packs to/// - `0b0100001100000001u16` or `[0b00000001, 0b01000011]` on little endian, and/// - `0b1000000011000010u16` or `[0b10000000, 0b11000010]` on big endian./// And finally, a non-power-of-2 example with multiple bytes:/// `[!0, !0, 0, !0, 0, 0, !0, 0, !0, 0]` packs to/// - `0b0101001011u16` or `[0b01001011, 0b01]` on little endian, and/// - `0b1101001010u16` or `[0b11, 0b01001010]` on big endian./// `x` must contain only `0` and `!0`.simd_select/// Selects elements from a mask./// `M` must be an integer vector with the same length as `T` (but any element size)./// For each element, if the corresponding value in `mask` is `!0`, select the element from/// `if_true`.  If the corresponding value in `mask` is `0`, select the element from/// `if_false`./// `mask` must only contain `0` and `!0`.simd_select_bitmask/// Selects elements from a bitmask./// `M` must be an unsigned integer or array of `u8`, matching `simd_bitmask`./// For each element, if the bit in `mask` is `1`, select the element from/// `if_true`.  If the corresponding bit in `mask` is `0`, select the element from/// The remaining bits of the mask are ignored./// The bitmask bit order matches `simd_bitmask`.simd_arith_offset/// Calculates the offset from a pointer vector elementwise, potentially/// wrapping./// `T` must be a vector of pointers./// `U` must be a vector of `isize` or `usize` with the same number of elements as `T`./// Operates as if by `<ptr>::wrapping_offset`.simd_cast_ptr/// Casts a vector of pointers./// `T` and `U` must be vectors of pointers with the same number of elements.simd_expose_provenance/// Exposes a vector of pointers as a vector of addresses./// `U` must be a vector of `usize` with the same length as `T`.simd_with_exposed_provenance/// Creates a vector of pointers from a vector of addresses./// `T` must be a vector of `usize`./// `U` must be a vector of pointers, with the same length as `T`.simd_bswap/// Swaps bytes of each element.simd_bitreverse/// Reverses bits of each element.simd_ctlz/// Counts the leading zeros of each element.simd_ctpop/// Counts the number of ones in each element.simd_cttz/// Counts the trailing zeros of each element.simd_ceil/// Rounds up each element to the next highest integer-valued float./// `T` must be a vector of floats.simd_floor/// Rounds down each element to the next lowest integer-valued float.simd_round/// Rounds each element to the closest integer-valued float./// Ties are resolved by rounding away from 0.simd_round_ties_even/// Ties are resolved by rounding to the number with an even least significant digitsimd_trunc/// Returns the integer part of each element as an integer-valued float./// In other words, non-integer values are truncated towards zero.simd_fsqrt/// Takes the square root of each element.simd_fma/// Computes `(x*y) + z` for each element, but without any intermediate rounding.simd_relaxed_fma/// Computes `(x*y) + z` for each element, non-deterministically executing either/// a fused multiply-add or two operations with rounding of the intermediate result./// The operation is fused if the code generator determines that target instruction/// set has support for a fused operation, and that the fused operation is more efficient/// than the equivalent, separate pair of mul and add instructions. It is unspecified/// whether or not a fused operation is selected, and that may depend on optimization/// level and context, for example. It may even be the case that some SIMD lanes get fused/// and others do not.simd_fsin// Computes the sine of each element.simd_fcos// Computes the cosine of each element.simd_fexp// Computes the exponential function of each element.simd_fexp2// Computes 2 raised to the power of each element.simd_flog10// Computes the base 10 logarithm of each element.simd_flog2// Computes the base 2 logarithm of each element.simd_flog// Computes the natural logarithm of each element.//! SIMD compiler intrinsics.//! In this module, a "vector" is any `repr(simd)` type./// The buffer's underlying data./// The length of `self.buf` which is known to be filled./// The length of `self.buf` which is known to be initialized.BorrowedBuf/// A borrowed byte buffer which is incrementally filled and initialized./// This type is a sort of "double cursor". It tracks three regions in the buffer: a region at the beginning of the/// buffer that has been logically filled with data, a region that has been initialized at some point but not yet/// logically filled, and a region at the end that is fully uninitialized. The filled region is guaranteed to be a/// subset of the initialized region./// A `BorrowedBuf` is created around some existing data (or capacity for data) via a unique reference/// (`&mut`). The `BorrowedBuf` can be configured (e.g., using `clear` or `set_init`), but cannot be/// directly written. To write into the buffer, use `unfilled` to create a `BorrowedCursor`. The cursor/// has write-only access to the unfilled portion of the buffer (you can think of it as a/// write-only iterator)./// The lifetime `'data` is a bound on the lifetime of the underlying data./// Creates a new `BorrowedBuf` from a fully initialized slice./// Creates a new `BorrowedBuf` from an uninitialized buffer./// Use `set_init` if part of the buffer is known to be already initialized.BorrowedCursor/// Creates a new `BorrowedBuf` from a cursor./// Use `BorrowedCursor::with_unfilled_buf` instead for a safer alternative./// Returns the length of the filled part of the buffer.init_len/// Returns the length of the initialized part of the buffer.into_filled/// Returns a shared reference to the filled portion of the buffer with its original lifetime.into_filled_mut/// Returns a mutable reference to the filled portion of the buffer with its original lifetime./// Returns a cursor over the unfilled part of the buffer.set_init/// Asserts that the first `n` bytes of the buffer are initialized./// `BorrowedBuf` assumes that bytes are never de-initialized, so this method does nothing when called with fewer/// The caller must ensure that the first `n` unfilled bytes of the buffer have already been initialized.// Safety invariant: we treat the type of buf as covariant in the lifetime of `BorrowedBuf` when// we create a `BorrowedCursor`. This is only safe if we never replace `buf` by assigning into// it, so don't do that!/// A writeable view of the unfilled portion of a [`BorrowedBuf`]./// The unfilled portion consists of an initialized and an uninitialized part; see [`BorrowedBuf`]/// Data can be written directly to the cursor by using [`append`](BorrowedCursor::append) or/// indirectly by getting a slice of part or all of the cursor and writing into the slice. In the/// indirect case, the caller must call [`advance`](BorrowedCursor::advance) after writing to inform/// the cursor how many bytes have been written./// Once data is written to the cursor, it becomes part of the filled portion of the underlying/// `BorrowedBuf` and can no longer be accessed or re-written by the cursor. I.e., the cursor tracks/// the unfilled part of the underlying `BorrowedBuf`./// The lifetime `'a` is a bound on the lifetime of the underlying buffer (which means it is a bound/// on the data in that buffer by transitivity)./// Reborrows this cursor by cloning it with a smaller lifetime./// Since a cursor maintains unique access to its underlying buffer, the borrowed cursor is/// not accessible while the new cursor exists./// Returns the available space in the cursor./// Returns the number of bytes written to the `BorrowedBuf` this cursor was created from./// In particular, the count returned is shared by all reborrows of the cursor.init_mut/// Returns a mutable reference to the initialized portion of the cursor./// Returns a mutable reference to the whole cursor./// The caller must not uninitialize any bytes in the initialized portion of the cursor./// Advances the cursor by asserting that `n` bytes have been filled./// After advancing, the `n` bytes are no longer accessible via the cursor and can only be/// accessed via the underlying buffer. I.e., the buffer's filled portion grows by `n` elements/// and its unfilled portion (and the capacity of this cursor) shrinks by `n` elements./// If less than `n` bytes initialized (by the cursor's point of view), `set_init` should be/// called first./// Panics if there are less than `n` bytes initialized./// The caller must ensure that the first `n` bytes of the cursor have been properlyensure_init/// Initializes all bytes in the cursor./// Asserts that the first `n` unfilled bytes of the cursor are initialized./// `BorrowedBuf` assumes that bytes are never de-initialized, so this method does nothing when/// called with fewer bytes than are already known to be initialized./// The caller must ensure that the first `n` bytes of the buffer have already been initialized./// Appends data to the cursor, advancing position within its buffer./// Panics if `self.capacity()` is less than `buf.len()`.with_unfilled_buf/// Runs the given closure with a `BorrowedBuf` containing the unfilled part/// of the cursor./// This enables inspecting what was written to the cursor./// Panics if the `BorrowedBuf` given to the closure is replaced by anotherborrowed_buf//! Traits, helpers, and type definitions for core I/O functionality.ArrayChunks/// An iterator over `N` elements of the iterator at a time./// The chunks do not overlap. If `N` does not divide the length of the/// iterator, then the last up to `N-1` elements will be omitted./// This `struct` is created by the [`array_chunks`][Iterator::array_chunks]/// method on [`Iterator`]. See its documentation for more./// Returns an iterator over the remaining elements of the original iterator/// that are not going to be returned by this iterator. The returned/// iterator will yield at most `N-1` elements./// # // Also serves as a regression test for https://github.com/rust-lang/rust/issues/123333/// # #![feature(iter_array_chunks)]/// let x = [1,2,3,4,5].into_iter().array_chunks::<2>();/// let mut rem = x.into_remainder();/// assert_eq!(rem.next(), Some(5));/// assert_eq!(rem.next(), None);impl_fold_via_try_foldAAAFFFnext_back_remainder/// Updates `self.remainder` such that `self.iter.len` is divisible by `N`.SpecFold/// Like `Iterator::by_ref`, but requiring `Sized` so it can forward generics./// Ideally this will no longer be required, eventually, but as can be seen in/// the benchmarks (as of Feb 2022 at least) `by_ref` can have performance cost.// The following implementations use UFCS-style, rather than trusting autoderef,// to avoid accidentally calling the `&mut Iterator` implementations.// These are "fused" with `Option` so we don't need separate state to track which part is// already exhausted, and we may also get niche layout for `None`. We don't use the real `Fuse`// adapter because its specialization for `FusedIterator` unconditionally descends into the// iterator, and that could be expensive to keep revisiting stuff like nested chains. It also// hurts compiler performance to add more iterator layers to `Chain`.// Only the "first" iterator is actually set `None` when exhausted, depending on whether you// iterate forward or backward. If you mix directions, then both sides may be `None`./// An iterator that links two iterators together, in a chain./// This `struct` is created by [`chain`] or [`Iterator::chain`]. See their/// use std::iter::Chain;/// use std::slice::Iter;/// let a1 = [1, 2, 3];/// let a2 = [4, 5, 6];/// let iter: Chain<Iter<'_, _>, Iter<'_, _>> = a1.iter().chain(a2.iter());/// Converts the arguments to iterators and links them together, in a chain./// See the documentation of [`Iterator::chain`] for more./// use std::iter::chain;/// let b = [4, 5, 6];/// let mut iter = chain(a, b);/// assert_eq!(iter.next(), Some(5));rustc_inherit_overflow_checks// Note: *both* must be fused to handle double-ended iterators./// Creates a `Chain` from the default values for `A` and `B`./// # use core::iter::Chain;/// # use core::slice;/// # use std::collections::{btree_set, BTreeSet};/// struct Foo<'a>(Chain<slice::Iter<'a, u8>, btree_set::Iter<'a, u8>>);/// let set = BTreeSet::<u8>::new();/// let slice: &[u8] = &[];/// let mut foo = Foo(slice.iter().chain(set.iter()));/// // take requires `Default`/// let _: Chain<_, _> = mem::take(&mut foo.0);and_then_or_cleartry_get_unchecked/// An iterator that clones the elements of an underlying iterator./// This `struct` is created by the [`cloned`] method on [`Iterator`]. See its/// [`cloned`]: Iterator::cloned/// [`Iterator`]: trait.Iterator.htmlclone_try_fold/// Creates a `Cloned` iterator from the default value of `I`/// # use core::iter::Cloned;/// let iter: Cloned<slice::Iter<'_, u8>> = Default::default();/// An iterator that copies the elements of an underlying iterator./// This `struct` is created by the [`copied`] method on [`Iterator`]. See its/// [`copied`]: Iterator::copiedcopy_foldcopy_try_foldspec_next_chunkSpecNextChunk/// Creates a `Copied` iterator from the default value of `I`/// # use core::iter::Copied;/// let iter: Copied<slice::Iter<'_, u8>> = Default::default();/// An iterator that repeats endlessly./// This `struct` is created by the [`cycle`] method on [`Iterator`]. See its/// [`cycle`]: Iterator::cycle// No `fold` override, because `fold` doesn't make much sense for `Cycle`,// and we can't do anything better than the default."Enumerate"/// An iterator that yields the current count and the element during iteration./// This `struct` is created by the [`enumerate`] method on [`Iterator`]. See its/// [`enumerate`]: Iterator::enumerate/// Retrieve the current position of the iterator./// If the iterator has not advanced, the position returned will be 0./// The position may also exceed the bounds of the iterator to allow for calculating/// the displacement of the iterator from following calls to [`Iterator::next`]./// #![feature(next_index)]/// let arr = ['a', 'b'];/// let mut iter = arr.iter().enumerate();/// assert_eq!(iter.next_index(), 0);/// assert_eq!(iter.next(), Some((0, &'a')));/// assert_eq!(iter.next_index(), 1);/// assert_eq!(iter.next(), Some((1, &'b')));/// assert_eq!(iter.next_index(), 2);/// `usize::MAX` elements either produces the wrong result or panics. If/// overflow checks are enabled, a panic is guaranteed./// Might panic if the index of the element overflows a `usize`./// Creates an `Enumerate` iterator from the default value of `I`/// # use std::iter::Enumerate;/// let iter: Enumerate<slice::Iter<'_, u8>> = Default::default();// Used for `SplitWhitespace` and `SplitAsciiWhitespace` `as_str` methods/// An iterator that filters the elements of `iter` with `predicate`./// This `struct` is created by the [`filter`] method on [`Iterator`]. See its/// [`filter`]: Iterator::filternext_chunk_droplessfilter_foldfilter_try_fold// this special case allows the compiler to make `.filter(_).count()`// branchless. Barring perfect branch prediction (which is unattainable in// the general case), this will be much faster in >90% of cases (containing// virtually all real workloads) and only a tiny bit slower in the rest.// Having this specialization thus allows us to write `.filter(p).count()`// where we would otherwise write `.map(|x| p(x) as usize).sum()`, which is// less readable and also less backwards-compatible to Rust before 1.10.// Using the branchless version will also simplify the LLVM byte code, thus// leaving more budget for LLVM optimizations./// An iterator that uses `f` to both filter and map elements from `iter`./// This `struct` is created by the [`filter_map`] method on [`Iterator`]. See its/// [`filter_map`]: Iterator::filter_mapfilter_map_foldfilter_map_try_foldOnceWithFlattenCompat/// An iterator that maps each element to an iterator, and yields the elements/// of the produced iterators./// This `struct` is created by [`Iterator::flat_map`]. See its documentation/// An iterator that flattens one level of nesting in an iterator of things/// that can be turned into iterators./// This `struct` is created by the [`flatten`] method on [`Iterator`]. See its/// [`flatten`]: Iterator::flatten()/// Creates a `Flatten` iterator from the default value of `I`./// # use std::iter::Flatten;/// let iter: Flatten<slice::Iter<'_, [u8; 4]>> = Default::default();frontiterbackiter/// Real logic of both `Flatten` and `FlatMap` which simply delegate to/// this type./// Adapts an iterator by flattening it, for use in `flatten()` and `flat_map()`.iter_fold/// Folds the inner iterators into an accumulator by applying an operation./// Folds over the inner iterators, not over their elements. Is used by the `fold`, `count`,/// and `last` methods.iter_try_fold/// Folds over the inner iterators as long as the given function returns successfully,/// always storing the most recent inner iterator in `self.frontiter`./// Folds over the inner iterators, not over their elements. Is used by the `try_fold` and/// `advance_by` methods.iter_rfold/// Folds the inner iterators into an accumulator by applying an operation, starting form the/// Folds over the inner iterators, not over their elements. Is used by the `rfold` method.iter_try_rfold/// Folds over the inner iterators in reverse order as long as the given function returns/// successfully, always storing the most recent inner iterator in `self.backiter`./// Folds over the inner iterators, not over their elements. Is used by the `try_rfold` and/// `advance_back_by` methods.// See also the `OneShot` specialization below.// FIXME(#31844): convert to an associated const once specialization supports thatConstSizeIntoIterator/// Specialization trait for iterator types that never return more than one item./// Note that we still have to deal with the possibility that the iterator was/// already exhausted before it came into our control.// These all have exactly one item, if not already consumed.// These are always empty, which is fine to optimize too.// These adapters never increase the number of items.// (There are more possible, but for now this matches BoundedSize above.)// Blanket impls pass this property through as well// (but we can't do `Box<I>` unless we expose this trait to alloc)flatten_onetry_flatten_oneadvance_by_one// Specialization: When the inner iterator `U` never returns more than one item, the `frontiter` and// `backiter` states are a waste, because they'll always have already consumed their item. So in// this impl, we completely ignore them and just focus on `self.iter`, and we only call the inner// `U::next()` one time.// It's mostly fine if we accidentally mix this with the more generic impls, e.g. by forgetting to// specialize one of the methods. If the other impl did set the front or back, we wouldn't see it// here, but it would be empty anyway; and if the other impl looked for a front or back that we// didn't bother setting, it would just see `None` (or a previous empty) and move on.// An exception to that is `advance_by(0)` and `advance_back_by(0)`, where the generic impls may set// `frontiter` or `backiter` without consuming the item, so we **must** override those.// Note: We don't actually care about `U: DoubleEndedIterator`, since forward and backward are the// same for a one-shot iterator, but we have to keep that to match the default specialization.// NOTE: for `I: FusedIterator`, we never bother setting `None`, but// we still have to be prepared for that state due to variance.// See rust-lang/rust#85863/// An iterator that yields `None` forever after the underlying iterator/// yields `None` once./// This `struct` is created by [`Iterator::fuse`]. See its documentation// Any specialized implementation here is made internal// to avoid exposing default fns outside this trait./// Creates a `Fuse` iterator from the default value of `I`./// # use std::iter::Fuse;/// let iter: Fuse<slice::Iter<'_, u8>> = Default::default();/// This is equivalent to `I::default().fuse()`[^fuse_note]; e.g. if/// `I::default()` is not an empty iterator, then this will not be/// an empty iterator./// struct Fourever;/// impl Iterator for Fourever {///     type Item = u32;///     fn next(&mut self) -> Option<u32> {///         Some(4)/// let mut iter: Fuse<Fourever> = Default::default();/// [^fuse_note]: if `I` does not override `Iterator::fuse`'s default implementation// SAFETY: `TrustedLen` requires that an accurate length is reported via `size_hint()`. As `Fuse`// is just forwarding this to the wrapped iterator `I` this property is preserved and it is safe to// implement `TrustedLen` here.// SAFETY: `TrustedRandomAccess` requires that `size_hint()` must be exact and cheap to call, and// `Iterator::__iterator_get_unchecked()` must be implemented accordingly.// This is safe to implement as `Fuse` is just forwarding these to the wrapped iterator `I`, which// preserves these properties.// Functions specific to any normal Iterators// Functions specific to DoubleEndedIteratorsFuseImpl/// Fuse specialization trait/// We only need to worry about `&mut self` methods, which/// may exhaust the iterator without consuming it./// General `Fuse` impl which sets `iter = None` when exhausted./// Specialized `Fuse` impl which doesn't bother clearing `iter` when exhausted./// However, we must still be prepared for the possibility that it was already cleared!// This is used by Flatten's SourceIter impl/// An iterator that calls a function with a reference to each element before/// yielding it./// This `struct` is created by the [`inspect`] method on [`Iterator`]. See its/// [`inspect`]: Iterator::inspectdo_inspectinspect_foldinspect_try_foldnext_item/// An iterator adapter that places a separator between all elements./// This `struct` is created by [`Iterator::intersperse`]. See its documentation/// This `struct` is created by [`Iterator::intersperse_with`]. See itsintersperse_size_hintintersperse_fold/// An iterator that maps the values of `iter` with `f`./// This `struct` is created by the [`map`] method on [`Iterator`]. See its/// [`map`]: Iterator::map/// # Notes about side effects/// The [`map`] iterator implements [`DoubleEndedIterator`], meaning that/// you can also [`map`] backwards:/// let v: Vec<i32> = [1, 2, 3].into_iter().map(|x| x + 1).rev().collect();/// assert_eq!(v, [4, 3, 2]);/// [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html/// But if your closure has state, iterating backwards may act in a way you do/// not expect. Let's go through an example. First, in the forward direction:/// let mut c = 0;/// for pair in ['a', 'b', 'c'].into_iter()///                                .map(|letter| { c += 1; (letter, c) }) {///     println!("{pair:?}");/// This will print `('a', 1), ('b', 2), ('c', 3)`./// Now consider this twist where we add a call to `rev`. This version will/// print `('c', 1), ('b', 2), ('a', 3)`. Note that the letters are reversed,/// but the values of the counter still go in order. This is because `map()` is/// still being called lazily on each item, but we are popping items off the/// back of the vector now, instead of shifting them from the front.///                                .map(|letter| { c += 1; (letter, c) })///                                .rev() {map_foldmap_try_foldMapWhile/// An iterator that only accepts elements while `predicate` returns `Some(_)`./// This `struct` is created by the [`map_while`] method on [`Iterator`]. See its/// [`map_while`]: Iterator::map_whileMapWindowsInnerMapWindows/// An iterator over the mapped windows of another iterator./// This `struct` is created by the [`Iterator::map_windows`]. See its// We fuse the inner iterator because there shouldn't be "holes" in// the sliding window. Once the iterator returns a `None`, we make// our `MapWindows` iterator return `None` forever.// Since iterators are assumed lazy, i.e. it only yields an item when// `Iterator::next()` is called, and `MapWindows` is not an exception.// Before the first iteration, we keep the buffer `None`. When the user// first call `next` or other methods that makes the iterator advance,// we collect the first `N` items yielded from the inner iterator and// put it into the buffer.// When the inner iterator has returned a `None` (i.e. fused), we take// away this `buffer` and leave it `None` to reclaim its resources.// FIXME: should we shrink the size of `buffer` using niche optimization?// Invariant: `self.buffer[self.start..self.start + N]` is initialized,// with all other elements being uninitialized. This also// implies that `self.start <= N`.// `Buffer` uses two times of space to reduce moves among the iterations.// `Buffer<T, N>` is semantically `[MaybeUninit<T>; 2 * N]`. However, due// to limitations of const generics, we use this different type. Note that// it has the same underlying memory layout.try_from_iterbuffer_ptrbuffer_mut_ptras_array_refas_uninit_array_mut/// Pushes a new item `next` to the back, and pops the front-most one./// All the elements will be shifted to the front end when pushing reaches/// the back end.// Note that even if the inner iterator not fused, the `MapWindows` is still fused,// because we don't allow "holes" in the mapping window.array_chunksby_ref_sizedmap_whilemap_windows/// A source stage in an iterator pipeline./// Retrieve the source of an iterator pipeline./// Implementations must return the same mutable reference for their lifetime, unless/// replaced by a caller./// Callers may only replace the reference when they stopped iteration and drop the/// iterator pipeline after extracting the source./// This means iterator adapters can rely on the source not changing during/// iteration but they cannot rely on it in their Drop implementations./// Implementing this method means adapters relinquish private-only access to their/// source and can only rely on guarantees made based on method receiver types./// The lack of restricted access also requires that adapters must uphold the source's/// public API even when they have access to its internals./// Callers in turn must expect the source to be in any state that is consistent with/// its public API since adapters sitting between it and the source have the same/// access. In particular an adapter may have consumed more elements than strictly necessary./// The overall goal of these requirements is to let the consumer of a pipeline use/// * whatever remains in the source after iteration has stopped/// * the memory that has become unused by advancing a consuming iterator/// [`next()`]: Iterator::next()/// This trait provides transitive access to source-stage in an iterator-adapter pipeline/// under the conditions that/// * the iterator source `S` itself implements `SourceIter<Source = S>`/// * there is a delegating implementation of this trait for each adapter in the pipeline between///   the source and the pipeline consumer./// When the source is an owning iterator struct (commonly called `IntoIter`) then/// this can be useful for specializing [`FromIterator`] implementations or recovering the/// remaining elements after an iterator has been partially exhausted./// Note that implementations do not necessarily have to provide access to the innermost/// source of a pipeline. A stateful intermediate adapter might eagerly evaluate a part/// of the pipeline and expose its internal storage as source./// The trait is unsafe because implementers must uphold additional safety properties./// See [`as_inner`] for details./// The primary use of this trait is in-place iteration. Refer to the [`vec::in_place_collect`]/// module documentation for more information./// [`vec::in_place_collect`]: ../../../../alloc/vec/in_place_collect/index.html/// Retrieving a partially consumed source:/// # #![feature(inplace_iteration)]/// # use std::iter::SourceIter;/// let mut iter = vec![9, 9, 9].into_iter().map(|i| i * i);/// let _ = iter.next();/// let mut remainder = std::mem::replace(unsafe { iter.as_inner() }, Vec::new().into_iter());/// println!("n = {} elements remaining", remainder.len());/// [`FromIterator`]: crate::iter::FromIterator/// [`as_inner`]: SourceIter::as_innerresidualGenericShunt/// An iterator adapter that produces output as long as the underlying/// iterator produces values where `Try::branch` says to `ControlFlow::Continue`./// If a `ControlFlow::Break` is encountered, the iterator stops and the/// residual is stored.try_process/// Process the given iterator as if it yielded the item's `Try::Output`/// type instead. Any `Try::Residual`s encountered will stop the inner iterator/// and be propagated back to the overall result.// SAFETY: GenericShunt::next calls `I::try_for_each`, which has to advance `iter`// in order to return `Some(_)`. Since `iter` has type `I: InPlaceIterable` it's// guaranteed that at least one item will be moved out from the underlying source."IterPeekable"/// Remember a peeked value, even if it was None./// An iterator with a `peek()` that returns an optional reference to the next/// This `struct` is created by the [`peekable`] method on [`Iterator`]. See its/// [`peekable`]: Iterator::peekable// Peekable must remember if a None has been seen in the `.peek()` method.// It ensures that `.peek(); .peek();` or `.peek(); .next();` only advances the// underlying iterator at most once. This does not by itself make the iterator// fused./// Returns a reference to the next() value without advancing the iterator./// Like [`next`], if there is a value, it is wrapped in a `Some(T)`./// But if the iteration is over, `None` is returned./// Because `peek()` returns a reference, and many iterators iterate over/// references, there can be a possibly confusing situation where the/// return value is a double reference. You can see this effect in the/// let xs = [1, 2, 3];/// let mut iter = xs.iter().peekable();/// // peek() lets us see into the future/// assert_eq!(iter.peek(), Some(&&1));/// // The iterator does not advance even if we `peek` multiple times/// assert_eq!(iter.peek(), Some(&&3));/// assert_eq!(iter.next(), Some(&3));/// // After the iterator is finished, so is `peek()`/// assert_eq!(iter.peek(), None);/// Returns a mutable reference to the next() value without advancing the iterator./// Because `peek_mut()` returns a reference, and many iterators iterate over/// return value is a double reference. You can see this effect in the examples/// let mut iter = [1, 2, 3].iter().peekable();/// // Like with `peek()`, we can see into the future without advancing the iterator./// assert_eq!(iter.peek_mut(), Some(&mut &1));/// if let Some(p) = iter.peek_mut() {///     assert_eq!(*p, &2);///     *p = &5;/// assert_eq!(iter.collect::<Vec<_>>(), vec![&5, &3]);/// Consume and return the next value of this iterator if a condition is true./// If `func` returns `true` for the next value of this iterator, consume and return it./// let mut iter = (0..5).peekable();/// // The first item of the iterator is 0; consume it./// assert_eq!(iter.next_if(|&x| x == 0), Some(0));/// // The next item returned is now 1, so `next_if` will return `None`./// assert_eq!(iter.next_if(|&x| x == 0), None);/// // `next_if` retains the next item if the predicate evaluates to `false` for it./// let mut iter = (1..20).peekable();/// while iter.next_if(|&x| x < 10).is_some() {}/// assert_eq!(iter.next(), Some(10));/// Consume and return the next item if it is equal to `expected`./// assert_eq!(iter.next_if_eq(&0), Some(0));/// // The next item returned is now 1, so `next_if_eq` will return `None`./// assert_eq!(iter.next_if_eq(&0), None);/// // `next_if_eq` retains the next item if it was not equal to `expected`.next_if_map/// Consumes the next value of this iterator and applies a function `f` on it,/// returning the result if the closure returns `Ok`./// Otherwise if the closure returns `Err` the value is put back for the next iteration./// The content of the `Err` variant is typically the original value of the closure,/// but this is not required. If a different value is returned,/// the next `peek()` or `next()` call will result in this new value./// This is similar to modifying the output of `peek_mut()`./// If the closure panics, the next value will always be consumed and dropped/// even if the panic is caught, because the closure never returned an `Err` value to put back./// See also: [`next_if_map_mut`](Self::next_if_map_mut)./// Parse the leading decimal number from an iterator of characters./// #![feature(peekable_next_if_map)]/// let mut iter = "125 GOTO 10".chars().peekable();/// let mut line_num = 0_u32;/// while let Some(digit) = iter.next_if_map(|c| c.to_digit(10).ok_or(c)) {///     line_num = line_num * 10 + digit;/// assert_eq!(line_num, 125);/// assert_eq!(iter.collect::<String>(), " GOTO 10");/// Matching custom types./// enum Node {///     Comment(String),///     Red(String),///     Green(String),///     Blue(String),/// /// Combines all consecutive `Comment` nodes into a single one./// fn combine_comments(nodes: Vec<Node>) -> Vec<Node> {///     let mut result = Vec::with_capacity(nodes.len());///     let mut iter = nodes.into_iter().peekable();///     let mut comment_text = None::<String>;///         // Typically the closure in .next_if_map() matches on the input,///         //  extracts the desired pattern into an `Ok`,///         //  and puts the rest into an `Err`.///         while let Some(text) = iter.next_if_map(|node| match node {///             Node::Comment(text) => Ok(text),///             other => Err(other),///         }) {///             comment_text.get_or_insert_default().push_str(&text);///         if let Some(text) = comment_text.take() {///             result.push(Node::Comment(text));///         if let Some(node) = iter.next() {///             result.push(node);///# assert_eq!( // hiding the test to avoid cluttering the documentation.///#     combine_comments(vec![///#         Node::Comment("The".to_owned()),///#         Node::Comment("Quick".to_owned()),///#         Node::Comment("Brown".to_owned()),///#         Node::Red("Fox".to_owned()),///#         Node::Green("Jumped".to_owned()),///#         Node::Comment("Over".to_owned()),///#         Node::Blue("The".to_owned()),///#         Node::Comment("Lazy".to_owned()),///#         Node::Comment("Dog".to_owned()),///#     ]),///#     vec![///#         Node::Comment("TheQuickBrown".to_owned()),///#         Node::Comment("LazyDog".to_owned()),///#     ],///# )next_if_map_mut/// Gives a mutable reference to the next value of the iterator and applies a function `f` to it,/// returning the result and advancing the iterator if `f` returns `Some`./// Otherwise, if `f` returns `None`, the next value is kept for the next iteration./// If `f` panics, the item that is consumed from the iterator as if `Some` was returned from `f`./// The value will be dropped./// This is similar to [`next_if_map`](Self::next_if_map), except ownership of the item is not given to `f`./// This can be preferable if `f` would copy the item anyway./// while let Some(digit) = iter.next_if_map_mut(|c| c.to_digit(10)) {/// A double-ended iterator with the direction inverted./// This `struct` is created by the [`rev`] method on [`Iterator`]. See its/// [`rev`]: Iterator::rev/// Consumes the `Rev`, returning the inner iterator./// #![feature(rev_into_inner)]/// let s = "foobar";/// let mut rev = s.chars().rev();/// assert_eq!(rev.next(), Some('r'));/// assert_eq!(rev.next(), Some('a'));/// assert_eq!(rev.next(), Some('b'));/// assert_eq!(rev.into_inner().collect::<String>(), "foo");/// Creates a `Rev` iterator from the default value of `I`/// # use core::iter::Rev;/// let iter: Rev<slice::Iter<'_, u8>> = Default::default();/// An iterator to maintain state while iterating another iterator./// This `struct` is created by the [`scan`] method on [`Iterator`]. See its/// [`scan`]: Iterator::scan/// An iterator that skips over `n` elements of `iter`./// This `struct` is created by the [`skip`] method on [`Iterator`]. See its/// [`skip`]: Iterator::skip// SAFETY: This adapter is shortening. TrustedLen requires the upper bound to be calculated correctly.// These requirements can only be satisfied when the upper bound of the inner iterator's upper// bound is never `None`. I: TrustedRandomAccess happens to provide this guarantee while// I: TrustedLen would not./// An iterator that rejects elements while `predicate` returns `true`./// This `struct` is created by the [`skip_while`] method on [`Iterator`]. See its/// [`skip_while`]: Iterator::skip_while/// This field is guaranteed to be preprocessed by the specialized `SpecRangeSetup::setup`/// in the constructor./// For most iterators that processing is a no-op, but for Range<{integer}> types it is lossy/// which means the inner iterator cannot be returned to user code./// Additionally this type-dependent preprocessing means specialized implementations/// cannot be used interchangeably.step_minus_one/// This field is `step - 1`, aka the correct amount to pass to `nth` when iterating./// It MUST NOT be `usize::MAX`, as `unsafe` code depends on being able to add one/// without the risk of overflow.  (This is important so that length calculations/// don't need to check for division-by-zero, for example.)first_take/// An iterator for stepping iterators by a custom amount./// This `struct` is created by the [`step_by`] method on [`Iterator`]. See/// [`step_by`]: Iterator::step_byoriginal_step/// The `step` that was originally passed to `Iterator::step_by(step)`,/// aka `self.step_minus_one + 1`.next_back_index// The zero-based index starting from the end of the iterator of the// last element. Used in the `DoubleEndedIterator` implementation.// StepBy can only make the iterator shorter, so the len will still fit.// This also covers the Range specializations since the ranges also implement TRASpecRangeSetupspec_nextspec_size_hintspec_nthspec_try_foldspec_foldStepByImpl/// Specialization trait to optimize `StepBy<Range<{integer}>>` iteration./// Technically this is safe to implement (look ma, no unsafe!), but in reality/// a lot of unsafe code relies on ranges over integers being correct./// For correctness *all* public StepBy methods must be specialized/// because `setup` drastically alters the meaning of the struct fields so that mixing/// different implementations would lead to incorrect results.spec_next_backspec_nth_backspec_try_rfoldspec_rfoldStepByBackImpl/// Specialization trait for double-ended iteration./// See also: `StepByImpl`/// The specializations must be implemented together with `StepByImpl`/// where applicable. I.e. if `StepBy` does support backwards iteration/// for a given iterator and that is specialized for forward iteration then/// it must also be specialized for backwards iteration.spec_int_ranges/// For these implementations, `SpecRangeSetup` calculates the number/// of iterations that will be needed and stores that in `iter.end`./// The various iterator implementations then rely on that to not need/// overflow checking, letting loops just be counted instead./// These only work for unsigned types, and will need to be reworked/// if you want to use it to specialize on signed types./// Currently these are only implemented for integers up to `usize` due to/// correctness issues around `ExactSizeIterator` impls on 16bit platforms./// And since `ExactSizeIterator` is a prerequisite for backwards iteration/// and we must consistently specialize backwards and forwards iteration/// that makes the situation complicated enough that it's not covered/// for now.spec_int_ranges_r// DoubleEndedIterator requires ExactSizeIterator, which isn't implemented for Range<u64>/// An iterator that only iterates over the first `n` iterations of `iter`./// This `struct` is created by the [`take`] method on [`Iterator`]. See its/// [`take`]: Iterator::takespec_for_eachSpecTake// Note: It may be tempting to impl DoubleEndedIterator for Take<RepeatWith>.// One must fight that temptation since such implementation wouldn’t be correct// because we have no way to return value of nth invocation of repeater followed// by n-1st without remembering all results./// An iterator that only accepts elements while `predicate` returns `true`./// This `struct` is created by the [`take_while`] method on [`Iterator`]. See its/// [`take_while`]: Iterator::take_while// index, len and a_len are only used by the specialized version of zip/// An iterator that iterates two other iterators simultaneously./// This `struct` is created by [`zip`] or [`Iterator::zip`]./// See their documentation for more.super_nth/// See the documentation of [`Iterator::zip`] for more./// use std::iter::zip;/// let ys = [4, 5, 6];/// let mut iter = zip(xs, ys);/// assert_eq!(iter.next().unwrap(), (1, 4));/// assert_eq!(iter.next().unwrap(), (2, 5));/// assert_eq!(iter.next().unwrap(), (3, 6));/// // Nested zips are also possible:/// let zs = [7, 8, 9];/// let mut iter = zip(zip(xs, ys), zs);/// assert_eq!(iter.next().unwrap(), ((1, 4), 7));/// assert_eq!(iter.next().unwrap(), ((2, 5), 8));/// assert_eq!(iter.next().unwrap(), ((3, 6), 9));// This has the same safety requirements as `Iterator::__iterator_get_unchecked`ZipImpl// Zip specialization traitzip_impl_general_defaults// Work around limitations of specialization, requiring `default` impls to be repeated// in intermediary impls.// General Zip impl// Arbitrarily selects the left side of the zip iteration as extractable "source"// it would require negative trait bounds to be able to try both// Since SourceIter forwards the left hand side we do the same hereZipFmt/// An iterator whose items are random-accessible efficiently/// The iterator's `size_hint` must be exact and cheap to call./// `TrustedRandomAccessNoCoerce::size` may not be overridden./// All subtypes and all supertypes of `Self` must also implement `TrustedRandomAccess`./// In particular, this means that types with non-invariant parameters usually can not have/// an impl for `TrustedRandomAccess` that depends on any trait bounds on such parameters, except/// for bounds that come from the respective struct/enum definition itself, or bounds involving/// traits that themselves come with a guarantee similar to this one./// If `Self: ExactSizeIterator` then `self.len()` must always produce results consistent/// with `self.size()`./// If `Self: Iterator`, then `<Self as Iterator>::__iterator_get_unchecked(&mut self, idx)`/// must be safe to call provided the following conditions are met./// 1. `0 <= idx` and `idx < self.size()`./// 2. If `Self: !Clone`, then `self.__iterator_get_unchecked(idx)` is never called with the same///    index on `self` more than once./// 3. After `self.__iterator_get_unchecked(idx)` has been called, then `self.next_back()` will///    only be called at most `self.size() - idx - 1` times. If `Self: Clone` and `self` is cloned,///    then this number is calculated for `self` and its clone individually,///    but `self.next_back()` calls that happened before the cloning count for both `self` and the clone./// 4. After `self.__iterator_get_unchecked(idx)` has been called, then only the following methods///    will be called on `self` or on any new clones of `self`:///     * `std::clone::Clone::clone`///     * `std::iter::Iterator::size_hint`///     * `std::iter::DoubleEndedIterator::next_back`///     * `std::iter::ExactSizeIterator::len`///     * `std::iter::Iterator::__iterator_get_unchecked`///     * `std::iter::TrustedRandomAccessNoCoerce::size`/// 5. If `Self` is a subtype of `T`, then `self` is allowed to be coerced///    to `T`. If `self` is coerced to `T` after `self.__iterator_get_unchecked(idx)` has already///    been called, then no methods except for the ones listed under 4. are allowed to be called///    on the resulting value of type `T`, either. Multiple such coercion steps are allowed.///    Regarding 2. and 3., the number of times `__iterator_get_unchecked(idx)` or `next_back()` is///    called on `self` and the resulting value of type `T` (and on further coercion results with///    super-supertypes) are added together and their sums must not exceed the specified bounds./// Further, given that these conditions are met, it must guarantee that:/// * It does not change the value returned from `size_hint`/// * It must be safe to call the methods listed above on `self` after calling///   `self.__iterator_get_unchecked(idx)`, assuming that the required traits are implemented./// * It must also be safe to drop `self` after calling `self.__iterator_get_unchecked(idx)`./// * If `Self` is a subtype of `T`, then it must be safe to coerce `self` to `T`.// FIXME: Clarify interaction with SourceIter/InPlaceIterable. Calling `SourceIter::as_inner`// after `__iterator_get_unchecked` is supposed to be allowed.// Convenience method./// `true` if getting an iterator element may have side effects./// Remember to take inner iterators into account./// Like [`TrustedRandomAccess`] but without any of the requirements / guarantees around/// coercions to supertypes after `__iterator_get_unchecked` (they aren’t allowed here!), and/// without the requirement that subtypes / supertypes implement `TrustedRandomAccessNoCoerce`./// This trait was created in PR #85874 to fix soundness issue #85873 without performance regressions./// It is subject to change as we might want to build a more generally useful (for performance/// optimizations) and more sophisticated trait or trait hierarchy that replaces or extends/// [`TrustedRandomAccess`] and `TrustedRandomAccessNoCoerce`./// Like `Iterator::__iterator_get_unchecked`, but doesn't require the compiler to/// know that `U: TrustedRandomAccess`./// Same requirements calling `get_unchecked` directly./// If `Self: TrustedRandomAccess`, it must be safe to call/// `Iterator::__iterator_get_unchecked(self, index)`.SpecTrustedRandomAccess// Adapted from default impl from the Iterator trait// This needs to be up here in order to be usable in the child modulesFromCoroutinefrom_coroutineonce_withSuccessorssuccessorsTrustedStep//! Composable external iteration.//! If you've found yourself with a collection of some kind, and needed to//! perform an operation on the elements of said collection, you'll quickly run//! into 'iterators'. Iterators are heavily used in idiomatic Rust code, so//! it's worth becoming familiar with them.//! * [Traits] are the core portion: these traits define what kind of iterators//! * [Functions] provide some helpful ways to create some basic iterators.//! * [Structs] are often the return types of the various methods on this//!   see '[Implementing Iterator](#implementing-iterator)'.//! [Functions]: #functions//! [Structs]: #structs//! That's it! Let's dig into iterators.//! # Iterator//! The heart and soul of this module is the [`Iterator`] trait. The core of//! [`Iterator`] looks like this://! trait Iterator {//!     fn next(&mut self) -> Option<Self::Item>;//! An iterator has a method, [`next`], which when called, returns an//! <code>[Option]\<Item></code>. Calling [`next`] will return [`Some(Item)`] as long as there//! are elements, and once they've all been exhausted, will return `None` to//! indicate that iteration is finished. Individual iterators may choose to//! resume iteration, and so calling [`next`] again may or may not eventually//! start returning [`Some(Item)`] again at some point (for example, see [`TryIter`]).//! [`Iterator`]'s full definition includes a number of other methods as well,//! but they are default methods, built on top of [`next`], and so you get//! Iterators are also composable, and it's common to chain them together to do//! more complex forms of processing. See the [Adapters](#adapters) section//! below for more details.//! [`Some(Item)`]: Some//! [`next`]: Iterator::next//! [`TryIter`]: ../../std/sync/mpsc/struct.TryIter.html//! # The three forms of iteration//! There are three common methods which can create iterators from a collection://! * `iter()`, which iterates over `&T`.//! * `iter_mut()`, which iterates over `&mut T`.//! * `into_iter()`, which iterates over `T`.//! Various things in the standard library may implement one or more of the//! three, where appropriate.//! # Implementing Iterator//! Creating an iterator of your own involves two steps: creating a `struct` to//! hold the iterator's state, and then implementing [`Iterator`] for that `struct`.//! This is why there are so many `struct`s in this module: there is one for//! each iterator and iterator adapter.//! Let's make an iterator named `Counter` which counts from `1` to `5`://! /// An iterator which counts from one to five//! // `count` at zero, we'll see why in `next()`'s implementation below.//! // Then, we implement `Iterator` for our `Counter`://! impl Iterator for Counter {//!     // next() is the only required method//!     fn next(&mut self) -> Option<Self::Item> {//!             Some(self.count)//!             None//! // And now we can use it!//! let mut counter = Counter::new();//! assert_eq!(counter.next(), Some(1));//! assert_eq!(counter.next(), Some(2));//! assert_eq!(counter.next(), Some(3));//! assert_eq!(counter.next(), Some(4));//! assert_eq!(counter.next(), Some(5));//! assert_eq!(counter.next(), None);//! Calling [`next`] this way gets repetitive. Rust has a construct which can//! call [`next`] on your iterator, until it reaches `None`. Let's go over that//! next.//! Also note that `Iterator` provides a default implementation of methods such as `nth` and `fold`//! which call `next` internally. However, it is also possible to write a custom implementation of//! methods like `nth` and `fold` if an iterator can compute them more efficiently without calling//! `next`.//! # `for` loops and `IntoIterator`//! Rust's `for` loop syntax is actually sugar for iterators. Here's a basic//! example of `for`://! let values = vec![1, 2, 3, 4, 5];//! for x in values {//!     println!("{x}");//! This will print the numbers one through five, each on their own line. But//! you'll notice something here: we never called anything on our vector to//! produce an iterator. What gives?//! There's a trait in the standard library for converting something into an//! iterator: [`IntoIterator`]. This trait has one method, [`into_iter`],//! which converts the thing implementing [`IntoIterator`] into an iterator.//! Let's take a look at that `for` loop again, and what the compiler converts//! it into://! [`into_iter`]: IntoIterator::into_iter//! Rust de-sugars this into://!     let result = match IntoIterator::into_iter(values) {//!         mut iter => loop {//!             let next;//!             match iter.next() {//!                 Some(val) => next = val,//!                 None => break,//!             let x = next;//!             let () = { println!("{x}"); };//!     result//! First, we call `into_iter()` on the value. Then, we match on the iterator//! that returns, calling [`next`] over and over until we see a `None`. At//! that point, we `break` out of the loop, and we're done iterating.//! There's one more subtle bit here: the standard library contains an//! interesting implementation of [`IntoIterator`]://! impl<I: Iterator> IntoIterator for I//! In other words, all [`Iterator`]s implement [`IntoIterator`], by just//! returning themselves. This means two things://! 1. If you're writing an [`Iterator`], you can use it with a `for` loop.//! 2. If you're creating a collection, implementing [`IntoIterator`] for it//!    will allow your collection to be used with the `for` loop.//! # Iterating by reference//! Since [`into_iter()`] takes `self` by value, using a `for` loop to iterate//! over a collection consumes that collection. Often, you may want to iterate//! over a collection without consuming it. Many collections offer methods that//! provide iterators over references, conventionally called `iter()` and//! `iter_mut()` respectively://! let mut values = vec![41];//! for x in values.iter_mut() {//!     *x += 1;//! for x in values.iter() {//!     assert_eq!(*x, 42);//! assert_eq!(values.len(), 1); // `values` is still owned by this function.//! If a collection type `C` provides `iter()`, it usually also implements//! `IntoIterator` for `&C`, with an implementation that just calls `iter()`.//! Likewise, a collection `C` that provides `iter_mut()` generally implements//! `IntoIterator` for `&mut C` by delegating to `iter_mut()`. This enables a//! convenient shorthand://! for x in &mut values {//!     //   ^ same as `values.iter_mut()`//! for x in &values {//!     //   ^ same as `values.iter()`//! assert_eq!(values.len(), 1);//! While many collections offer `iter()`, not all offer `iter_mut()`. For//! example, mutating the keys of a [`HashSet<T>`] could put the collection//! into an inconsistent state if the key hashes change, so this collection//! only offers `iter()`.//! [`into_iter()`]: IntoIterator::into_iter//! [`HashSet<T>`]: ../../std/collections/struct.HashSet.html//! # Adapters//! Functions which take an [`Iterator`] and return another [`Iterator`] are//! often called 'iterator adapters', as they're a form of the 'adapter//! pattern'.//! Common iterator adapters include [`map`], [`take`], and [`filter`].//! For more, see their documentation.//! If an iterator adapter panics, the iterator will be in an unspecified (but//! memory safe) state.  This state is also not guaranteed to stay the same//! across versions of Rust, so you should avoid relying on the exact values//! returned by an iterator which panicked.//! [`map`]: Iterator::map//! [`take`]: Iterator::take//! [`filter`]: Iterator::filter//! Iterators (and iterator [adapters](#adapters)) are *lazy*. This means that//! just creating an iterator doesn't _do_ a whole lot. Nothing really happens//! until you call [`next`]. This is sometimes a source of confusion when//! creating an iterator solely for its side effects. For example, the [`map`]//! method calls a closure on each element it iterates over://! # #![allow(map_unit_fn)]//! v.iter().map(|x| println!("{x}"));//! This will not print any values, as we only created an iterator, rather than//! using it. The compiler will warn us about this kind of behavior://! warning: unused result that must be used: iterators are lazy and//! do nothing unless consumed//! The idiomatic way to write a [`map`] for its side effects is to use a//! `for` loop or call the [`for_each`] method://! v.iter().for_each(|x| println!("{x}"));//! // or//! for x in &v {//! [`for_each`]: Iterator::for_each//! Another common way to evaluate an iterator is to use the [`collect`]//! method to produce a new collection.//! [`collect`]: Iterator::collect//! # Infinity//! Iterators do not have to be finite. As an example, an open-ended range is//! an infinite iterator://! let numbers = 0..;//! It is common to use the [`take`] iterator adapter to turn an infinite//! iterator into a finite one://! let five_numbers = numbers.take(5);//! for number in five_numbers {//!     println!("{number}");//! This will print the numbers `0` through `4`, each on their own line.//! Bear in mind that methods on infinite iterators, even those for which a//! result can be determined mathematically in finite time, might not terminate.//! Specifically, methods such as [`min`], which in the general case require//! traversing every element in the iterator, are likely not to return//! successfully for any infinite iterators.//! let ones = std::iter::repeat(1);//! let least = ones.min().unwrap(); // Oh no! An infinite loop!//! // `ones.min()` causes an infinite loop, so we won't reach this point!//! println!("The smallest number one is {least}.");//! [`min`]: Iterator::minunsafe_impl_trusted_step// Safety: All invariants are upheld.steps_between/// Returns the bounds on the number of *successor* steps required to get from `start` to `end`/// like [`Iterator::size_hint()`][Iterator::size_hint()]./// Returns `(usize::MAX, None)` if the number of steps would overflow `usize`, or is infinite./// For any `a`, `b`, and `n`:/// * `steps_between(&a, &b) == (n, Some(n))` if and only if `Step::forward_checked(&a, n) == Some(b)`/// * `steps_between(&a, &b) == (n, Some(n))` if and only if `Step::backward_checked(&b, n) == Some(a)`/// * `steps_between(&a, &b) == (n, Some(n))` only if `a <= b`///   * Corollary: `steps_between(&a, &b) == (0, Some(0))` if and only if `a == b`/// * `steps_between(&a, &b) == (0, None)` if `a > b`forward_checked/// Returns the value that would be obtained by taking the *successor*/// of `self` `count` times./// If this would overflow the range of values supported by `Self`, returns `None`./// For any `a`, `n`, and `m`:/// * `Step::forward_checked(a, n).and_then(|x| Step::forward_checked(x, m)) == Step::forward_checked(a, m).and_then(|x| Step::forward_checked(x, n))`/// * `Step::forward_checked(a, n).and_then(|x| Step::forward_checked(x, m)) == try { Step::forward_checked(a, n.checked_add(m)) }`/// For any `a` and `n`:/// * `Step::forward_checked(a, n) == (0..n).try_fold(a, |x, _| Step::forward_checked(&x, 1))`///   * Corollary: `Step::forward_checked(a, 0) == Some(a)`/// If this would overflow the range of values supported by `Self`,/// this function is allowed to panic, wrap, or saturate./// The suggested behavior is to panic when debug assertions are enabled,/// and to wrap or saturate otherwise./// Unsafe code should not rely on the correctness of behavior after overflow./// For any `a`, `n`, and `m`, where no overflow occurs:/// * `Step::forward(Step::forward(a, n), m) == Step::forward(a, n + m)`/// For any `a` and `n`, where no overflow occurs:/// * `Step::forward_checked(a, n) == Some(Step::forward(a, n))`/// * `Step::forward(a, n) == (0..n).fold(a, |x, _| Step::forward(x, 1))`///   * Corollary: `Step::forward(a, 0) == a`/// * `Step::forward(a, n) >= a`/// * `Step::backward(Step::forward(a, n), n) == a`forward_unchecked/// It is undefined behavior for this operation to overflow the/// range of values supported by `Self`. If you cannot guarantee that this/// will not overflow, use `forward` or `forward_checked` instead./// For any `a`:/// * if there exists `b` such that `b > a`, it is safe to call `Step::forward_unchecked(a, 1)`/// * if there exists `b`, `n` such that `steps_between(&a, &b) == Some(n)`,///   it is safe to call `Step::forward_unchecked(a, m)` for any `m <= n`.///   * Corollary: `Step::forward_unchecked(a, 0)` is always safe./// * `Step::forward_unchecked(a, n)` is equivalent to `Step::forward(a, n)`backward_checked/// Returns the value that would be obtained by taking the *predecessor*/// * `Step::backward_checked(a, n).and_then(|x| Step::backward_checked(x, m)) == n.checked_add(m).and_then(|x| Step::backward_checked(a, x))`/// * `Step::backward_checked(a, n).and_then(|x| Step::backward_checked(x, m)) == try { Step::backward_checked(a, n.checked_add(m)?) }`/// * `Step::backward_checked(a, n) == (0..n).try_fold(a, |x, _| Step::backward_checked(x, 1))`///   * Corollary: `Step::backward_checked(a, 0) == Some(a)`/// * `Step::backward(Step::backward(a, n), m) == Step::backward(a, n + m)`/// * `Step::backward_checked(a, n) == Some(Step::backward(a, n))`/// * `Step::backward(a, n) == (0..n).fold(a, |x, _| Step::backward(x, 1))`///   * Corollary: `Step::backward(a, 0) == a`/// * `Step::backward(a, n) <= a`/// * `Step::forward(Step::backward(a, n), n) == a`backward_unchecked/// will not overflow, use `backward` or `backward_checked` instead./// * if there exists `b` such that `b < a`, it is safe to call `Step::backward_unchecked(a, 1)`/// * if there exists `b`, `n` such that `steps_between(&b, &a) == (n, Some(n))`,///   it is safe to call `Step::backward_unchecked(a, m)` for any `m <= n`.///   * Corollary: `Step::backward_unchecked(a, 0)` is always safe./// * `Step::backward_unchecked(a, n)` is equivalent to `Step::backward(a, n)`"range_step"/// Objects that have a notion of *successor* and *predecessor* operations./// The *successor* operation moves towards values that compare greater./// The *predecessor* operation moves towards values that compare lesser.step_signed_methods// Separate impls for signed ranges because the distance within a signed range can be larger// than the signed::MAX value. Therefore `as` casting to the signed type would be incorrect.step_unsigned_methodsstep_identical_methods// These are still macro-generated because the integer literals resolve to different types.step_integer_implsrange_exact_iter_implunsafe_range_trusted_random_access_impl/// Safety: This macro must only be used on types that are `Copy` and result in ranges/// which have an exact `size_hint()` where the upper bound must not be `None`.range_incl_exact_iter_impl// Iteratorspec_advance_by// DoubleEndedIteratorspec_advance_back_byRangeIteratorImpl/// Specialization implementations for `Range`.is_sorted// These macros generate `ExactSizeIterator` impls for various range types.// * `ExactSizeIterator::len` is required to always return an exact `usize`,//   so no range can be longer than `usize::MAX`.// * For integer types in `Range<_>` this is the case for types narrower than or as wide as `usize`.//   For integer types in `RangeInclusive<_>`//   this is the case for types *strictly narrower* than `usize`//   since e.g. `(0..=u64::MAX).len()` would be `u64::MAX + 1`.// The following invariants for `Step::steps_between` exist:// > * `steps_between(&a, &b) == (n, Some(n))` only if `a <= b`// >   * Note that `a <= b` does _not_ imply `steps_between(&a, &b) != (n, None)`;// >     this is the case when it would require more than `usize::MAX` steps to// >     get to `b`// > * `steps_between(&a, &b) == (0, None)` if `a > b`// The first invariant is what is generally required for `TrustedLen` to be// sound. The note addendum satisfies an additional `TrustedLen` invariant.// > The upper bound must only be `None` if the actual iterator length is larger// > than `usize::MAX`// The second invariant logically follows the first so long as the `PartialOrd`// implementation is correct; regardless it is explicitly stated. If `a < b`// then `(0, Some(0))` is returned by `ops::Range<A: Step>::size_hint`. As such// the second invariant is upheld.// Safety: See above implementation for `ops::Range<A>`RangeInclusiveIteratorImpl/// Creates an iterator that yields nothing./// // this could have been an iterator over i32, but alas, it's just not./// let mut nope = iter::empty::<i32>();/// assert_eq!(None, nope.next());"IterEmpty"/// An iterator that yields nothing./// This `struct` is created by the [`empty()`] function. See its documentation for more.// not #[derive] because that adds a Clone bound on T,// which isn't necessary.// not #[derive] because that adds a Default bound on T,/// Creates a new iterator where each iteration calls the provided coroutine./// Similar to [`iter::from_fn`]./// [`iter::from_fn`]: crate::iter::from_fn/// #![feature(coroutines)]/// #![feature(iter_from_coroutine)]/// let it = std::iter::from_coroutine(#[coroutine] || {///     yield 1;///     yield 2;///     yield 3;/// let v: Vec<_> = it.collect();/// An iterator over the values yielded by an underlying coroutine./// This `struct` is created by the [`iter::from_coroutine()`] function. See its documentation for/// [`iter::from_coroutine()`]: from_coroutine/// Creates an iterator with the provided closure/// `F: FnMut() -> Option<T>` as its [`next`](Iterator::next) method./// The iterator will yield the `T`s returned from the closure./// This allows creating a custom iterator with any behavior/// without using the more verbose syntax of creating a dedicated type/// and implementing the [`Iterator`] trait for it./// Note that the `FromFn` iterator doesn’t make assumptions about the behavior of the closure,/// and therefore conservatively does not implement [`FusedIterator`],/// or override [`Iterator::size_hint()`] from its default `(0, None)`./// The closure can use captures and its environment to track state across iterations. Depending on/// how the iterator is used, this may require specifying the [`move`] keyword on the closure./// [`move`]: ../../std/keyword.move.html/// [`FusedIterator`]: crate::iter::FusedIterator/// Let’s re-implement the counter iterator from [module-level documentation]:/// [module-level documentation]: crate::iter/// let counter = std::iter::from_fn(move || {///     // Increment our count. This is why we started at zero.///     // Check to see if we've finished counting or not.///     if count < 6 {///         Some(count)/// assert_eq!(counter.collect::<Vec<_>>(), &[1, 2, 3, 4, 5]);/// An iterator where each iteration calls the provided closure `F: FnMut() -> Option<T>`./// This `struct` is created by the [`iter::from_fn()`] function./// [`iter::from_fn()`]: from_fn/// Creates a new closure that returns an iterator where each iteration steps the given/// generator to the next `yield` statement./// Similar to [`iter::from_fn`], but allows arbitrary control flow./// #![feature(iter_macro, coroutines)]/// let it = std::iter::iter!{|| {/// } }();/// Creates an iterator that yields an element exactly once./// This is commonly used to adapt a single value into a [`chain()`] of other/// kinds of iteration. Maybe you have an iterator that covers almost/// everything, but you need an extra special case. Maybe you have a function/// which works on iterators, but you only need to process one value./// [`chain()`]: Iterator::chain/// // one is the loneliest number/// let mut one = iter::once(1);/// assert_eq!(Some(1), one.next());/// // just one, that's all we get/// assert_eq!(None, one.next());/// Chaining together with another iterator. Let's say that we want to iterate/// over each file of the `.foo` directory, but also a configuration file,/// `.foorc`:/// let dirs = fs::read_dir(".foo")?;/// // we need to convert from an iterator of DirEntry-s to an iterator of/// // PathBufs, so we use map/// let dirs = dirs.map(|file| file.unwrap().path());/// // now, our iterator just for our config file/// let config = iter::once(PathBuf::from(".foorc"));/// // chain the two iterators together into one big iterator/// let files = dirs.chain(config);/// // this will give us all of the files in .foo as well as .foorc/// for f in files {///     println!("{f:?}");"IterOnce"/// An iterator that yields an element exactly once./// This `struct` is created by the [`once()`] function. See its documentation for more./// Creates an iterator that lazily generates a value exactly once by invoking/// the provided closure./// This is commonly used to adapt a single value coroutine into a [`chain()`] of/// other kinds of iteration. Maybe you have an iterator that covers almost/// Unlike [`once()`], this function will lazily generate the value on request./// [`once()`]: crate::iter::once/// let mut one = iter::once_with(|| 1);/// let dirs = fs::read_dir(".foo").unwrap();/// let config = iter::once_with(|| PathBuf::from(".foorc"));/// An iterator that yields a single element of type `A` by/// applying the provided closure `F: FnOnce() -> A`./// This `struct` is created by the [`once_with()`] function."iter_repeat"/// Creates a new iterator that endlessly repeats a single element./// The `repeat()` function repeats a single value over and over again./// Infinite iterators like `repeat()` are often used with adapters like/// [`Iterator::take()`], in order to make them finite./// If you know the number of repetitions in advance, consider using [`repeat_n()`]/// instead, as it is more efficient and conveys the intent more clearly./// Use [`str::repeat()`] instead of this function if you just want to repeat/// a char/string `n` times./// If the element type of the iterator you need does not implement `Clone`,/// or if you do not want to keep the repeated element in memory, you can/// instead use the [`repeat_with()`] function./// [`repeat_n()`]: crate::iter::repeat_n/// [`repeat_with()`]: crate::iter::repeat_with/// [`str::repeat()`]: ../../std/primitive.str.html#method.repeat/// // the number four 4ever:/// let mut fours = iter::repeat(4);/// assert_eq!(Some(4), fours.next());/// // yup, still four/// Going finite with [`Iterator::take()`]:/// // that last example was too many fours. Let's only have four fours./// let mut four_fours = iter::repeat(4).take(4);/// assert_eq!(Some(4), four_fours.next());/// assert_eq!(None, four_fours.next());/// An iterator that repeats an element endlessly./// This `struct` is created by the [`repeat()`] function. See its documentation for more./// Creates a new iterator that repeats a single element a given number of times./// The `repeat_n()` function repeats a single value exactly `n` times./// This is very similar to using [`repeat()`] with [`Iterator::take()`],/// but `repeat_n()` can return the original value, rather than always cloning./// [`repeat()`]: crate::iter::repeat/// // four of the number four:/// let mut four_fours = iter::repeat_n(4, 4);/// // no more fours/// For non-`Copy` types,/// let v: Vec<i32> = Vec::with_capacity(123);/// let mut it = iter::repeat_n(v, 5);///     // It starts by cloning things///     let cloned = it.next().unwrap();///     assert_eq!(cloned.len(), 0);///     assert_eq!(cloned.capacity(), 0);/// // ... but the last item is the original one/// let last = it.next().unwrap();/// assert_eq!(last.len(), 0);/// assert_eq!(last.capacity(), 123);RepeatNInner/// An iterator that repeats an element an exact number of times./// This `struct` is created by the [`repeat_n()`] function.take_element/// If we haven't already dropped the element, return it in an option./// Creates a new iterator that repeats elements of type `A` endlessly by/// Infinite iterators like `repeat_with()` are often used with adapters like/// If the element type of the iterator you need implements [`Clone`], and/// the [`repeat()`] function./// An iterator produced by `repeat_with()` is not a [`DoubleEndedIterator`]./// If you need `repeat_with()` to return a [`DoubleEndedIterator`],/// please open a GitHub issue explaining your use case./// // or which we don't want to have in memory just yet because it is expensive:/// let mut things = iter::repeat_with(|| Expensive);/// assert_eq!(Some(Expensive), things.next());/// let mut pow2 = iter::repeat_with(|| { let tmp = curr; curr *= 2; tmp })/// assert_eq!(Some(1), pow2.next());/// assert_eq!(Some(2), pow2.next());/// assert_eq!(Some(4), pow2.next());/// assert_eq!(Some(8), pow2.next());/// assert_eq!(None, pow2.next());/// An iterator that repeats elements of type `A` endlessly by/// Creates an iterator which, starting from an initial item,/// computes each successive item from the preceding one./// This iterator stores an optional item (`Option<T>`) and a successor closure (`impl FnMut(&T) -> Option<T>`)./// Its `next` method returns the stored optional item and/// if it is `Some(val)` calls the stored closure on `&val` to compute and store its successor./// The iterator will apply the closure successively to the stored option's value until the option is `None`./// This also means that once the stored option is `None` it will remain `None`,/// as the closure will not be called again, so the created iterator is a [`FusedIterator`]./// The iterator's items will be the initial item and all of its successors as calculated by the successor closure./// use std::iter::successors;/// let powers_of_10 = successors(Some(1_u16), |n| n.checked_mul(10));/// assert_eq!(powers_of_10.collect::<Vec<_>>(), &[1, 10, 100, 1_000, 10_000]);/// An iterator which, starting from an initial item,/// This `struct` is created by the [`iter::successors()`] function./// [`iter::successors()`]: successors/// Takes an iterator and generates `Self` from the elements by "summing up"/// the items./// Trait to represent types that can be created by summing up an iterator./// This trait is used to implement [`Iterator::sum()`]. Types which implement/// this trait can be generated by using the [`sum()`] method on an iterator./// Like [`FromIterator`], this trait should rarely be called directly./// [`sum()`]: Iterator::sum/// [`FromIterator`]: iter::FromIterator/// Takes an iterator and generates `Self` from the elements by multiplying/// Trait to represent types that can be created by multiplying elements of an/// This trait is used to implement [`Iterator::product()`]. Types which implement/// this trait can be generated by using the [`product()`] method on an iterator./// [`product()`]: Iterator::productinteger_sum_productsaturating_integer_sum_productfloat_sum_product"The short-circuiting behavior of this implementation is unspecified. If you care about \
                short-circuiting, use [`Iterator::fold`] directly."/// Takes each element in the [`Iterator`]: if it is an [`Err`], no further/// elements are taken, and the [`Err`] is returned. Should no [`Err`]/// occur, the sum of all elements is returned./// This sums up every integer in a vector, rejecting the sum if a negative/// element is encountered:/// let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };/// let v = vec![1, 2];/// let res: Result<i32, _> = v.iter().map(f).sum();/// assert_eq!(res, Ok(3));/// let v = vec![1, -2];/// assert_eq!(res, Err("Negative element found"));/// occur, the product of all elements is returned./// This multiplies each number in a vector of strings,/// if a string could not be parsed the operation returns `Err`:/// let nums = vec!["5", "10", "1", "2"];/// let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();/// assert_eq!(total, Ok(100));/// let nums = vec!["5", "10", "one", "2"];/// assert!(total.is_err());/// Takes each element in the [`Iterator`]: if it is a [`None`], no further/// elements are taken, and the [`None`] is returned. Should no [`None`]/// This sums up the position of the character 'a' in a vector of strings,/// if a word did not have the character 'a' the operation returns `None`:/// let words = vec!["have", "a", "great", "day"];/// let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();/// assert_eq!(total, Some(5));/// let words = vec!["have", "a", "good", "day"];/// assert_eq!(total, None);/// if a string could not be parsed the operation returns `None`:/// let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();/// assert_eq!(total, Some(100));"from_iter_fn"/// Creates a value from an iterator./// let five_fives = std::iter::repeat(5).take(5);/// let v = Vec::from_iter(five_fives);/// assert_eq!(v, vec![5, 5, 5, 5, 5]);"FromIterator"/// Conversion from an [`Iterator`]./// By implementing `FromIterator` for a type, you define how it will be/// created from an iterator. This is common for types which describe a/// collection of some kind./// If you want to create a collection from the contents of an iterator, the/// [`Iterator::collect()`] method is preferred. However, when you need to/// specify the container type, [`FromIterator::from_iter()`] can be more/// readable than using a turbofish (e.g. `::<Vec<_>>()`). See the/// [`Iterator::collect()`] documentation for more examples of its use./// See also: [`IntoIterator`]./// Using [`Iterator::collect()`] to implicitly use `FromIterator`:/// let v: Vec<i32> = five_fives.collect();/// Using [`FromIterator::from_iter()`] as a more readable alternative to/// [`Iterator::collect()`]:/// let first = (0..10).collect::<VecDeque<i32>>();/// let second = VecDeque::from_iter(0..10);/// assert_eq!(first, second);/// Implementing `FromIterator` for your type:/// // A sample collection, that's just a wrapper over Vec<T>/// struct MyCollection(Vec<i32>);/// // Let's give it some methods so we can create one and add things/// // to it./// impl MyCollection {///     fn new() -> MyCollection {///         MyCollection(Vec::new())///     fn add(&mut self, elem: i32) {///         self.0.push(elem);/// // and we'll implement FromIterator/// impl FromIterator<i32> for MyCollection {///     fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {///         let mut c = MyCollection::new();///         for i in iter {///             c.add(i);///         c/// // Now we can make a new iterator.../// let iter = (0..5).into_iter();/// // ... and make a MyCollection out of it/// let c = MyCollection::from_iter(iter);/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);/// // collect works too!/// let c: MyCollection = iter.collect();/// The type of the elements being iterated over./// Which kind of iterator are we turning this into?"into_iter"/// Creates an iterator from a value./// let v = [1, 2, 3];/// let mut iter = v.into_iter();/// assert_eq!(Some(3), iter.next());"IntoIterator"rustc_skip_during_method_dispatch/// Conversion into an [`Iterator`]./// By implementing `IntoIterator` for a type, you define how it will be/// converted to an iterator. This is common for types which describe a/// One benefit of implementing `IntoIterator` is that your type will [work/// with Rust's `for` loop syntax](crate::iter#for-loops-and-intoiterator)./// See also: [`FromIterator`]./// Implementing `IntoIterator` for your type:/// // and we'll implement IntoIterator/// impl IntoIterator for MyCollection {///     type Item = i32;///     type IntoIter = std::vec::IntoIter<Self::Item>;///     fn into_iter(self) -> Self::IntoIter {///         self.0.into_iter()/// // Now we can make a new collection.../// let mut c = MyCollection::new();/// // ... add some stuff to it .../// c.add(0);/// c.add(1);/// c.add(2);/// // ... and then turn it into an Iterator:/// for (i, n) in c.into_iter().enumerate() {///     assert_eq!(i as i32, n);/// It is common to use `IntoIterator` as a trait bound. This allows/// the input collection type to change, so long as it is still an/// iterator. Additional bounds can be specified by restricting on/// `Item`:/// fn collect_as_strings<T>(collection: T) -> Vec<String>///     T: IntoIterator,///     T::Item: std::fmt::Debug,///     collection///         .map(|item| format!("{item:?}"))///         .collect()/// Extends a collection with the contents of an iterator./// As this is the only required method for this trait, the [trait-level] docs/// contain more details./// [trait-level]: Extend/// // You can extend a String with some chars:/// let mut message = String::from("abc");/// message.extend(['d', 'e', 'f'].iter());/// assert_eq!("abcdef", &message);/// Extends a collection with exactly one element./// Reserves capacity in a collection for the given number of additional elements./// Extends a collection with one element, without checking there is enough capacity for it./// **For callers:** This must only be called when we know the collection has enough capacity/// to contain the new item, for example because we previously called `extend_reserve`./// **For implementors:** For a collection to unsafely rely on this method's safety precondition (that is,/// invoke UB if they are violated), it must implement `extend_reserve` correctly. In other words,/// callers may assume that if they `extend_reserve`ed enough space they can call this method.// This method is for internal usage only. It is only on the trait because of specialization's limitations./// Extend a collection with the contents of an iterator./// Iterators produce a series of values, and collections can also be thought/// of as a series of values. The `Extend` trait bridges this gap, allowing you/// to extend a collection by including the contents of that iterator. When/// extending a collection with an already existing key, that entry is updated/// or, in the case of collections that permit multiple entries with equal/// keys, that entry is inserted./// let mut message = String::from("The first three letters are: ");/// message.extend(&['a', 'b', 'c']);/// assert_eq!("abc", &message[29..32]);/// Implementing `Extend`:/// // since MyCollection has a list of i32s, we implement Extend for i32/// impl Extend<i32> for MyCollection {///     // This is a bit simpler with the concrete type signature: we can call///     // extend on anything which can be turned into an Iterator which gives///     // us i32s. Because we need i32s to put into MyCollection.///     fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {///         // The implementation is very straightforward: loop through the///         // iterator, and add() each element to ourselves.///         for elem in iter {///             self.add(elem);/// c.add(5);/// c.add(6);/// c.add(7);/// // let's extend our collection with three more numbers/// c.extend(vec![1, 2, 3]);/// // we've added these elements onto the end/// assert_eq!("MyCollection([5, 6, 7, 1, 2, 3])", format!("{c:?}"));/// Allows to `extend` a tuple of collections that also implement `Extend`./// See also: [`Iterator::unzip`]/// // Example given for a 2-tuple, but 1- through 12-tuples are supported/// let mut tuple = (vec![0], vec![1]);/// tuple.extend([(2, 3), (4, 5), (6, 7)]);/// assert_eq!(tuple.0, [0, 2, 4, 6]);/// assert_eq!(tuple.1, [1, 3, 5, 7]);/// // also allows for arbitrarily nested tuples as elements/// let mut nested_tuple = (vec![1], (vec![2], vec![3]));/// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);/// let (a, (b, c)) = nested_tuple;/// assert_eq!(a, [1, 4, 7]);/// assert_eq!(b, [2, 5, 8]);/// assert_eq!(c, [3, 6, 9]);ExtendT/// This trait is implemented for tuples up to twelve items long. The `impl`s for/// 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.// the other implementations are below./// This implementation turns an iterator of tuples into a tuple of types which implement/// [`Default`] and [`Extend`]./// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]/// # fn main() -> Result<(), core::num::ParseIntError> {/// let string = "1,2,123,4";/// let (numbers, lengths): (Vec<_>, Vec<_>) = string///     .split(',')///     .map(|s| s.parse().map(|n: u32| (n, s.len())))///     .collect::<Result<_, _>>()?;/// assert_eq!(numbers, [1, 2, 123, 4]);/// assert_eq!(lengths, [1, 1, 3, 1]);default_extend/// An implementation of [`extend`](Extend::extend) that calls `extend_one` or/// `extend_one_unchecked` for each element of the iterator.impl_extend_tuple// Implements `Extend` and `FromIterator` for tuples with length larger than one.ExAExBExCExDExEExFExGExHExIExJExKExL/// Removes and returns an element from the end of the iterator./// Returns `None` when there are no more elements./// The [trait-level] docs contain more details./// [trait-level]: DoubleEndedIterator/// let numbers = vec![1, 2, 3, 4, 5, 6];/// let mut iter = numbers.iter();/// assert_eq!(Some(&1), iter.next());/// assert_eq!(Some(&6), iter.next_back());/// assert_eq!(Some(&5), iter.next_back());/// assert_eq!(Some(&2), iter.next());/// assert_eq!(Some(&3), iter.next());/// assert_eq!(Some(&4), iter.next());/// assert_eq!(None, iter.next_back());/// The elements yielded by `DoubleEndedIterator`'s methods may differ from/// the ones yielded by [`Iterator`]'s methods:/// let vec = vec![(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b')];/// let uniq_by_fst_comp = || {///     let mut seen = std::collections::HashSet::new();///     vec.iter().copied().filter(move |x| seen.insert(x.0))/// assert_eq!(uniq_by_fst_comp().last(), Some((2, 'a')));/// assert_eq!(uniq_by_fst_comp().next_back(), Some((2, 'b')));///     uniq_by_fst_comp().fold(vec![], |mut v, x| {v.push(x); v}),///     vec![(1, 'a'), (2, 'a')]///     uniq_by_fst_comp().rfold(vec![], |mut v, x| {v.push(x); v}),///     vec![(2, 'b'), (1, 'c')]/// Advances the iterator from the back by `n` elements./// `advance_back_by` is the reverse version of [`advance_by`]. This method will/// eagerly skip `n` elements starting from the back by calling [`next_back`] up/// to `n` times until [`None`] is encountered./// `advance_back_by(n)` will return `Ok(())` if the iterator successfully advances by/// `n` elements, or a `Err(NonZero<usize>)` with value `k` if [`None`] is encountered, where `k`/// is remaining number of steps that could not be advanced because the iterator ran out./// If `self` is empty and `n` is non-zero, then this returns `Err(n)`./// Otherwise, `k` is always less than `n`./// Calling `advance_back_by(0)` can do meaningful work, for example [`Flatten`] can advance its/// outer iterator until it finds an inner iterator that is not empty, which then often/// allows it to return a more accurate `size_hint()` than in its initial state./// [`advance_by`]: Iterator::advance_by/// [`Flatten`]: crate::iter::Flatten/// [`next_back`]: DoubleEndedIterator::next_back/// #![feature(iter_advance_by)]/// let a = [3, 4, 5, 6];/// let mut iter = a.iter();/// assert_eq!(iter.advance_back_by(2), Ok(()));/// assert_eq!(iter.next_back(), Some(&4));/// assert_eq!(iter.advance_back_by(0), Ok(()));/// assert_eq!(iter.advance_back_by(100), Err(NonZero::new(99).unwrap())); // only `&3` was skipped/// [`Ok(())`]: Ok/// [`Err(k)`]: Err/// Returns the `n`th element from the end of the iterator./// This is essentially the reversed version of [`Iterator::nth()`]./// Although like most indexing operations, the count starts from zero, so/// `nth_back(0)` returns the first value from the end, `nth_back(1)` the/// second, and so on./// Note that all elements between the end and the returned element will be/// consumed, including the returned element. This also means that calling/// `nth_back(0)` multiple times on the same iterator will return different/// `nth_back()` will return [`None`] if `n` is greater than or equal to the/// length of the iterator./// assert_eq!(a.iter().nth_back(2), Some(&1));/// Calling `nth_back()` multiple times doesn't rewind the iterator:/// assert_eq!(iter.nth_back(1), Some(&2));/// assert_eq!(iter.nth_back(1), None);/// Returning `None` if there are less than `n + 1` elements:/// assert_eq!(a.iter().nth_back(10), None);/// This is the reverse version of [`Iterator::try_fold()`]: it takes/// elements starting from the back of the iterator./// let sum = a.iter()///     .map(|&s| s.parse::<i32>())///     .try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y)));/// assert_eq!(sum, Ok(6));/// Short-circuiting:/// let a = ["1", "rust", "3"];/// let mut it = a.iter();/// let sum = it///     .by_ref()/// assert!(sum.is_err());/// // Because it short-circuited, the remaining elements are still/// // available through the iterator./// assert_eq!(it.next_back(), Some(&"1"));/// An iterator method that reduces the iterator's elements to a single,/// final value, starting from the back./// This is the reverse version of [`Iterator::fold()`]: it takes elements/// starting from the back of the iterator./// `rfold()` takes two arguments: an initial value, and a closure with two/// arguments: an 'accumulator', and an element. The closure returns the value that/// the accumulator should have for the next iteration./// The initial value is the value the accumulator will have on the first/// After applying this closure to every element of the iterator, `rfold()`/// This operation is sometimes called 'reduce' or 'inject'./// Folding is useful whenever you have a collection of something, and want/// to produce a single value from it./// Note: `rfold()` combines elements in a *right-associative* fashion. For associative/// operators like `+`, the order the elements are combined in is not important, but for non-associative/// operators like `-` the order will affect the final result./// For a *left-associative* version of `rfold()`, see [`Iterator::fold()`]./// // the sum of all of the elements of a///            .rfold(0, |acc, &x| acc + x);/// This example demonstrates the right-associative nature of `rfold()`:/// it builds a string, starting with an initial value/// and continuing with each element from the back until the front:/// let numbers = [1, 2, 3, 4, 5];/// let zero = "0".to_string();/// let result = numbers.iter().rfold(zero, |acc, &x| {///     format!("({x} + {acc})")/// assert_eq!(result, "(1 + (2 + (3 + (4 + (5 + 0)))))");/// Searches for an element of an iterator from the back that satisfies a predicate./// `rfind()` takes a closure that returns `true` or `false`. It applies/// this closure to each element of the iterator, starting at the end, and if any/// of them return `true`, then `rfind()` returns [`Some(element)`]. If they all return/// `false`, it returns [`None`]./// `rfind()` is short-circuiting; in other words, it will stop processing/// as soon as the closure returns `true`./// Because `rfind()` takes a reference, and many iterators iterate over/// references, this leads to a possibly confusing situation where the/// argument is a double reference. You can see this effect in the/// examples below, with `&&x`./// [`Some(element)`]: Some/// assert_eq!(a.iter().rfind(|&&x| x == 2), Some(&2));/// assert_eq!(a.iter().rfind(|&&x| x == 5), None);/// Stopping at the first `true`:/// assert_eq!(iter.rfind(|&&x| x == 2), Some(&2));/// // we can still use `iter`, as there are more elements./// assert_eq!(iter.next_back(), Some(&1));"DoubleEndedIterator"/// An iterator able to yield elements from both ends./// Something that implements `DoubleEndedIterator` has one extra capability/// over something that implements [`Iterator`]: the ability to also take/// `Item`s from the back, as well as the front./// It is important to note that both back and forth work on the same range,/// and do not cross: iteration is over when they meet in the middle./// In a similar fashion to the [`Iterator`] protocol, once a/// `DoubleEndedIterator` returns [`None`] from a [`next_back()`], calling it/// again may or may not ever return [`Some`] again. [`next()`] and/// [`next_back()`] are interchangeable for this purpose./// [`next_back()`]: DoubleEndedIterator::next_back/// [`next()`]: Iterator::nextDoubleEndedIteratorRefSpec/// Helper trait to specialize `rfold` and `rtry_fold` for `&mut I where I: Sized`/// Returns the exact remaining length of the iterator./// The implementation ensures that the iterator will return exactly `len()`/// more times a [`Some(T)`] value, before returning [`None`]./// This method has a default implementation, so you usually should not/// implement it directly. However, if you can provide a more efficient/// implementation, you can do so. See the [trait-level] docs for an/// This function has the same safety guarantees as the/// [`Iterator::size_hint`] function./// [trait-level]: ExactSizeIterator/// [`Some(T)`]: Some/// // a finite range knows exactly how many times it will iterate/// let mut range = 0..5;/// assert_eq!(5, range.len());/// let _ = range.next();/// assert_eq!(4, range.len());/// Returns `true` if the iterator is empty./// This method has a default implementation using/// [`ExactSizeIterator::len()`], so you don't need to implement it yourself./// #![feature(exact_size_is_empty)]/// let mut one_element = std::iter::once(0);/// assert!(!one_element.is_empty());/// assert_eq!(one_element.next(), Some(0));/// assert!(one_element.is_empty());/// assert_eq!(one_element.next(), None);/// An iterator that knows its exact length./// Many [`Iterator`]s don't know how many times they will iterate, but some do./// If an iterator knows how many times it can iterate, providing access to/// that information can be useful. For example, if you want to iterate/// backwards, a good start is to know where the end is./// When implementing an `ExactSizeIterator`, you must also implement/// [`Iterator`]. When doing so, the implementation of [`Iterator::size_hint`]/// *must* return the exact size of the iterator./// The [`len`] method has a default implementation, so you usually shouldn't/// implement it. However, you may be able to provide a more performant/// implementation than the default, so overriding it in this case makes sense./// Note that this trait is a safe trait and as such does *not* and *cannot*/// guarantee that the returned length is correct. This means that `unsafe`/// code **must not** rely on the correctness of [`Iterator::size_hint`]. The/// unstable and unsafe [`TrustedLen`](super::marker::TrustedLen) trait gives/// this additional guarantee./// [`len`]: ExactSizeIterator::len/// # When *shouldn't* an adapter be `ExactSizeIterator`?/// If an adapter makes an iterator *longer*, then it's usually incorrect for/// that adapter to implement `ExactSizeIterator`.  The inner exact-sized/// iterator might already be `usize::MAX`-long, and thus the length of the/// longer adapted iterator would no longer be exactly representable in `usize`./// This is why [`Chain<A, B>`](crate::iter::Chain) isn't `ExactSizeIterator`,/// even when `A` and `B` are both `ExactSizeIterator`./// let five = 0..5;/// assert_eq!(5, five.len());/// In the [module-level docs], we implemented an [`Iterator`], `Counter`./// Let's implement `ExactSizeIterator` for it as well:/// [module-level docs]: crate::iter/// # struct Counter {/// #     count: usize,/// # impl Counter {/// #     fn new() -> Counter {/// #         Counter { count: 0 }/// # impl Iterator for Counter {/// #     type Item = usize;/// #     fn next(&mut self) -> Option<Self::Item> {/// #         self.count += 1;/// #         if self.count < 6 {/// #             Some(self.count)/// #         } else {/// #             None/// impl ExactSizeIterator for Counter {///     // We can easily calculate the remaining number of iterations.///     fn len(&self) -> usize {///         5 - self.count/// // And now we can use it!/// let mut counter = Counter::new();/// assert_eq!(5, counter.len());/// let _ = counter.next();/// assert_eq!(4, counter.len());_assert_is_dyn_compatible"IteratorItem""next"/// Returns [`None`] when iteration is finished. Individual iterator/// implementations may choose to resume iteration, and so calling `next()`/// again may or may not eventually start returning [`Some(Item)`] again at some/// [`Some(Item)`]: Some/// let mut iter = a.into_iter();/// // A call to next() returns the next value.../// // ... and then None once it's over./// // More calls may or may not return `None`. Here, they always will./// Advances the iterator and returns an array containing the next `N` values./// If there are not enough elements to fill the array then `Err` is returned/// containing an iterator over the remaining elements./// #![feature(iter_next_chunk)]/// let mut iter = "lorem".chars();/// assert_eq!(iter.next_chunk().unwrap(), ['l', 'o']);              // N is inferred as 2/// assert_eq!(iter.next_chunk().unwrap(), ['r', 'e', 'm']);         // N is inferred as 3/// assert_eq!(iter.next_chunk::<4>().unwrap_err().as_slice(), &[]); // N is explicitly 4/// Split a string and get the first three items./// let quote = "not all those who wander are lost";/// let [first, second, third] = quote.split_whitespace().next_chunk().unwrap();/// assert_eq!(first, "not");/// assert_eq!(second, "all");/// assert_eq!(third, "those");/// Returns the bounds on the remaining length of the iterator./// It is not enforced that an iterator implementation yields the declared/// number of elements. A buggy iterator may yield less than the lower bound/// reserving space for the elements of the iterator, but must not be/// assert_eq!((3, Some(3)), iter.size_hint());/// assert_eq!((2, Some(2)), iter.size_hint());/// A more complex example:/// // The even numbers in the range of zero to nine./// let iter = (0..10).filter(|x| x % 2 == 0);/// // We might iterate from zero to ten times. Knowing that it's five/// // exactly wouldn't be possible without executing filter()./// assert_eq!((0, Some(10)), iter.size_hint());/// // Let's add five more numbers with chain()/// let iter = (0..10).filter(|x| x % 2 == 0).chain(15..20);/// // now both bounds are increased by five/// assert_eq!((5, Some(15)), iter.size_hint());/// Returning `None` for an upper bound:/// // an infinite iterator has no upper bound/// // and the maximum possible lower bound/// let iter = 0..;/// assert_eq!((usize::MAX, None), iter.size_hint());/// Consumes the iterator, counting the number of iterations and returning it./// This method will call [`next`] repeatedly until [`None`] is encountered,/// returning the number of times it saw [`Some`]. Note that [`next`] has to be/// called at least once even if the iterator does not have any elements./// The method does no guarding against overflows, so counting elements of/// an iterator with more than [`usize::MAX`] elements either produces the/// wrong result or panics. If overflow checks are enabled, a panic is/// assert_eq!(a.iter().count(), 3);/// assert_eq!(a.iter().count(), 5);/// Consumes the iterator, returning the last element./// This method will evaluate the iterator until it returns [`None`]. While/// doing so, it keeps track of the current element. After [`None`] is/// returned, `last()` will then return the last element it saw./// assert_eq!(a.into_iter().last(), Some(3));/// assert_eq!(a.into_iter().last(), Some(5));/// Advances the iterator by `n` elements./// This method will eagerly skip `n` elements by calling [`next`] up to `n`/// times until [`None`] is encountered./// `advance_by(n)` will return `Ok(())` if the iterator successfully advances by/// `n` elements, or a `Err(NonZero<usize>)` with value `k` if [`None`] is encountered,/// where `k` is remaining number of steps that could not be advanced because the iterator ran out./// Calling `advance_by(0)` can do meaningful work, for example [`Flatten`]/// can advance its outer iterator until it finds an inner iterator that is not empty, which/// then often allows it to return a more accurate `size_hint()` than in its initial state./// let a = [1, 2, 3, 4];/// assert_eq!(iter.advance_by(2), Ok(()));/// assert_eq!(iter.advance_by(0), Ok(()));/// assert_eq!(iter.advance_by(100), Err(NonZero::new(99).unwrap())); // only `4` was skipped/// Returns the `n`th element of the iterator./// Like most indexing operations, the count starts from zero, so `nth(0)`/// returns the first value, `nth(1)` the second, and so on./// Note that all preceding elements, as well as the returned element, will be/// consumed from the iterator. That means that the preceding elements will be/// discarded, and also that calling `nth(0)` multiple times on the same iterator/// will return different elements./// `nth()` will return [`None`] if `n` is greater than or equal to the length of the/// assert_eq!(a.into_iter().nth(1), Some(2));/// Calling `nth()` multiple times doesn't rewind the iterator:/// assert_eq!(iter.nth(1), Some(2));/// assert_eq!(iter.nth(1), None);/// assert_eq!(a.into_iter().nth(10), None);/// Creates an iterator starting at the same point, but stepping by/// the given amount at each iteration./// Note 1: The first element of the iterator will always be returned,/// regardless of the step given./// Note 2: The time at which ignored elements are pulled is not fixed./// `StepBy` behaves like the sequence `self.next()`, `self.nth(step-1)`,/// `self.nth(step-1)`, …, but is also free to behave like the sequence/// `advance_n_and_return_first(&mut self, step)`,/// `advance_n_and_return_first(&mut self, step)`, …/// Which way is used may change for some iterators for performance reasons./// The second way will advance the iterator earlier and may consume more items./// `advance_n_and_return_first` is the equivalent of:/// fn advance_n_and_return_first<I>(iter: &mut I, n: usize) -> Option<I::Item>///     I: Iterator,///     let next = iter.next();///     if n > 1 {///         iter.nth(n - 2);///     next/// The method will panic if the given step is `0`./// let a = [0, 1, 2, 3, 4, 5];/// let mut iter = a.into_iter().step_by(2);/// assert_eq!(iter.next(), Some(0));/// Takes two iterators and creates a new iterator over both in sequence./// `chain()` will return a new iterator which will first iterate over/// values from the first iterator and then over values from the second/// In other words, it links two iterators together, in a chain. 🔗/// [`once`] is commonly used to adapt a single value into a chain of/// other kinds of iteration./// let s1 = "abc".chars();/// let s2 = "def".chars();/// let mut iter = s1.chain(s2);/// assert_eq!(iter.next(), Some('a'));/// assert_eq!(iter.next(), Some('b'));/// assert_eq!(iter.next(), Some('c'));/// assert_eq!(iter.next(), Some('d'));/// assert_eq!(iter.next(), Some('e'));/// assert_eq!(iter.next(), Some('f'));/// Since the argument to `chain()` uses [`IntoIterator`], we can pass/// anything that can be converted into an [`Iterator`], not just an/// [`Iterator`] itself. For example, arrays (`[T]`) implement/// [`IntoIterator`], and so can be passed to `chain()` directly:/// let mut iter = a1.into_iter().chain(a2);/// If you work with Windows API, you may wish to convert [`OsStr`] to `Vec<u16>`:/// fn os_str_to_utf16(s: &std::ffi::OsStr) -> Vec<u16> {///     use std::os::windows::ffi::OsStrExt;///     s.encode_wide().chain(std::iter::once(0)).collect()/// [`once`]: crate::iter::once/// [`OsStr`]: ../../std/ffi/struct.OsStr.html/// 'Zips up' two iterators into a single iterator of pairs./// `zip()` returns a new iterator that will iterate over two other/// iterators, returning a tuple where the first element comes from the/// first iterator, and the second element comes from the second iterator./// In other words, it zips two iterators together, into a single one./// If either iterator returns [`None`], [`next`] from the zipped iterator/// will return [`None`]./// If the zipped iterator has no more elements to return then each further attempt to advance/// it will first try to advance the first iterator at most one time and if it still yielded an item/// try to advance the second iterator at most one time./// To 'undo' the result of zipping up two iterators, see [`unzip`]./// [`unzip`]: Iterator::unzip/// let mut iter = s1.zip(s2);/// assert_eq!(iter.next(), Some(('a', 'd')));/// assert_eq!(iter.next(), Some(('b', 'e')));/// assert_eq!(iter.next(), Some(('c', 'f')));/// Since the argument to `zip()` uses [`IntoIterator`], we can pass/// [`IntoIterator`], and so can be passed to `zip()` directly:/// let mut iter = a1.into_iter().zip(a2);/// assert_eq!(iter.next(), Some((1, 4)));/// assert_eq!(iter.next(), Some((2, 5)));/// assert_eq!(iter.next(), Some((3, 6)));/// `zip()` is often used to zip an infinite iterator to a finite one./// This works because the finite iterator will eventually return [`None`],/// ending the zipper. Zipping with `(0..)` can look a lot like [`enumerate`]:/// let enumerate: Vec<_> = "foo".chars().enumerate().collect();/// let zipper: Vec<_> = (0..).zip("foo".chars()).collect();/// assert_eq!((0, 'f'), enumerate[0]);/// assert_eq!((0, 'f'), zipper[0]);/// assert_eq!((1, 'o'), enumerate[1]);/// assert_eq!((1, 'o'), zipper[1]);/// assert_eq!((2, 'o'), enumerate[2]);/// assert_eq!((2, 'o'), zipper[2]);/// If both iterators have roughly equivalent syntax, it may be more readable to use [`zip`]:/// let b = [2, 3, 4];/// let mut zipped = zip(///     a.into_iter().map(|x| x * 2).skip(1),///     b.into_iter().map(|x| x * 2).skip(1),/// assert_eq!(zipped.next(), Some((4, 6)));/// assert_eq!(zipped.next(), Some((6, 8)));/// assert_eq!(zipped.next(), None);/// compared to:/// # let a = [1, 2, 3];/// # let b = [2, 3, 4];/// let mut zipped = a///     .map(|x| x * 2)///     .skip(1)///     .zip(b.into_iter().map(|x| x * 2).skip(1));/// # assert_eq!(zipped.next(), Some((4, 6)));/// # assert_eq!(zipped.next(), Some((6, 8)));/// # assert_eq!(zipped.next(), None);/// [`zip`]: crate::iter::zip/// Creates a new iterator which places a copy of `separator` between adjacent/// items of the original iterator./// In case `separator` does not implement [`Clone`] or needs to be/// computed every time, use [`intersperse_with`]./// #![feature(iter_intersperse)]/// let mut a = [0, 1, 2].into_iter().intersperse(100);/// assert_eq!(a.next(), Some(0));   // The first element from `a`./// assert_eq!(a.next(), Some(100)); // The separator./// assert_eq!(a.next(), Some(1));   // The next element from `a`./// assert_eq!(a.next(), Some(2));   // The last element from `a`./// assert_eq!(a.next(), None);       // The iterator is finished./// `intersperse` can be very useful to join an iterator's items using a common element:/// let words = ["Hello", "World", "!"];/// let hello: String = words.into_iter().intersperse(" ").collect();/// assert_eq!(hello, "Hello World !");/// [`Clone`]: crate::clone::Clone/// [`intersperse_with`]: Iterator::intersperse_with/// Creates a new iterator which places an item generated by `separator`/// between adjacent items of the original iterator./// The closure will be called exactly once each time an item is placed/// between two adjacent items from the underlying iterator; specifically,/// the closure is not called if the underlying iterator yields less than/// two items and after the last item is yielded./// If the iterator's item implements [`Clone`], it may be easier to use/// [`intersperse`]./// struct NotClone(usize);/// let v = [NotClone(0), NotClone(1), NotClone(2)];/// let mut it = v.into_iter().intersperse_with(|| NotClone(99));/// assert_eq!(it.next(), Some(NotClone(0)));  // The first element from `v`./// assert_eq!(it.next(), Some(NotClone(99))); // The separator./// assert_eq!(it.next(), Some(NotClone(1)));  // The next element from `v`./// assert_eq!(it.next(), Some(NotClone(2)));  // The last element from `v`./// assert_eq!(it.next(), None);               // The iterator is finished./// `intersperse_with` can be used in situations where the separator needs/// to be computed:/// let src = ["Hello", "to", "all", "people", "!!"].iter().copied();/// // The closure mutably borrows its context to generate an item./// let mut happy_emojis = [" ❤️ ", " 😀 "].into_iter();/// let separator = || happy_emojis.next().unwrap_or(" 🦀 ");/// let result = src.intersperse_with(separator).collect::<String>();/// assert_eq!(result, "Hello ❤️ to 😀 all 🦀 people 🦀 !!");/// [`intersperse`]: Iterator::intersperse"IteratorMap"/// Takes a closure and creates an iterator which calls that closure on each/// `map()` transforms one iterator into another, by means of its argument:/// something that implements [`FnMut`]. It produces a new iterator which/// calls this closure on each element of the original iterator./// If you are good at thinking in types, you can think of `map()` like this:/// If you have an iterator that gives you elements of some type `A`, and/// you want an iterator of some other type `B`, you can use `map()`,/// passing a closure that takes an `A` and returns a `B`./// `map()` is conceptually similar to a [`for`] loop. However, as `map()` is/// lazy, it is best used when you're already working with other iterators./// If you're doing some sort of looping for a side effect, it's considered/// more idiomatic to use [`for`] than `map()`./// [`for`]: ../../book/ch03-05-control-flow.html#looping-through-a-collection-with-for/// let mut iter = a.iter().map(|x| 2 * x);/// If you're doing some sort of side effect, prefer [`for`] to `map()`:/// // don't do this:/// (0..5).map(|x| println!("{x}"));/// // it won't even execute, as it is lazy. Rust will warn you about this./// // Instead, use a for-loop:/// for x in 0..5 {/// Calls a closure on each element of an iterator./// This is equivalent to using a [`for`] loop on the iterator, although/// `break` and `continue` are not possible from a closure. It's generally/// more idiomatic to use a `for` loop, but `for_each` may be more legible/// when processing items at the end of longer iterator chains. In some/// cases `for_each` may also be faster than a loop, because it will use/// internal iteration on adapters like `Chain`./// (0..5).map(|x| x * 2 + 1)///       .for_each(move |x| tx.send(x).unwrap());/// let v: Vec<_> = rx.iter().collect();/// assert_eq!(v, vec![1, 3, 5, 7, 9]);/// For such a small example, a `for` loop may be cleaner, but `for_each`/// might be preferable to keep a functional style with longer iterators:/// (0..5).flat_map(|x| (x * 100)..(x * 110))///       .enumerate()///       .filter(|&(i, x)| (i + x) % 3 == 0)///       .for_each(|(i, x)| println!("{i}:{x}"));"iter_filter"/// Creates an iterator which uses a closure to determine if an element/// should be yielded./// Given an element the closure must return `true` or `false`. The returned/// iterator will yield only the elements for which the closure returns/// let a = [0i32, 1, 2];/// let mut iter = a.into_iter().filter(|x| x.is_positive());/// Because the closure passed to `filter()` takes a reference, and many/// iterators iterate over references, this leads to a possibly confusing/// situation, where the type of the closure is a double reference:/// let s = &[0, 1, 2];/// let mut iter = s.iter().filter(|x| **x > 1); // needs two *s!/// It's common to instead use destructuring on the argument to strip away one:/// let mut iter = s.iter().filter(|&x| *x > 1); // both & and */// or both:/// let mut iter = s.iter().filter(|&&x| x > 1); // two &s/// of these layers./// Note that `iter.filter(f).next()` is equivalent to `iter.find(f)`./// Creates an iterator that both filters and maps./// The returned iterator yields only the `value`s for which the supplied/// closure returns `Some(value)`./// `filter_map` can be used to make chains of [`filter`] and [`map`] more/// concise. The example below shows how a `map().filter().map()` can be/// shortened to a single call to `filter_map`./// let a = ["1", "two", "NaN", "four", "5"];/// let mut iter = a.iter().filter_map(|s| s.parse().ok());/// Here's the same example, but with [`filter`] and [`map`]:/// let mut iter = a.iter().map(|s| s.parse()).filter(|s| s.is_ok()).map(|s| s.unwrap());"enumerate_method"/// Creates an iterator which gives the current iteration count as well as/// The iterator returned yields pairs `(i, val)`, where `i` is the/// different sized integer, the [`zip`] function provides similar/// The returned iterator might panic if the to-be-returned index would/// [`zip`]: Iterator::zip/// let a = ['a', 'b', 'c'];/// let mut iter = a.into_iter().enumerate();/// assert_eq!(iter.next(), Some((0, 'a')));/// assert_eq!(iter.next(), Some((1, 'b')));/// assert_eq!(iter.next(), Some((2, 'c')));/// Creates an iterator which can use the [`peek`] and [`peek_mut`] methods/// to look at the next element of the iterator without consuming it. See/// their documentation for more information./// Note that the underlying iterator is still advanced when [`peek`] or/// [`peek_mut`] are called for the first time: In order to retrieve the/// next element, [`next`] is called on the underlying iterator, hence any/// side effects (i.e. anything other than fetching the next value) of/// the [`next`] method will occur./// let mut iter = xs.into_iter().peekable();/// assert_eq!(iter.peek(), Some(&1));/// // we can peek() multiple times, the iterator won't advance/// assert_eq!(iter.peek(), Some(&3));/// // after the iterator is finished, so is peek()/// Using [`peek_mut`] to mutate the next item without advancing the/// iterator:/// // `peek_mut()` lets us see into the future/// assert_eq!(iter.peek_mut(), Some(&mut 1));///     assert_eq!(*p, 2);///     // put a value into the iterator///     *p = 1000;/// // The value reappears as the iterator continues/// assert_eq!(iter.collect::<Vec<_>>(), vec![1000, 3]);/// [`peek`]: Peekable::peek/// [`peek_mut`]: Peekable::peek_mut/// Creates an iterator that [`skip`]s elements based on a predicate./// `skip_while()` takes a closure as an argument. It will call this/// closure on each element of the iterator, and ignore elements/// until it returns `false`./// After `false` is returned, `skip_while()`'s job is over, and the/// rest of the elements are yielded./// let a = [-1i32, 0, 1];/// let mut iter = a.into_iter().skip_while(|x| x.is_negative());/// Because the closure passed to `skip_while()` takes a reference, and many/// situation, where the type of the closure argument is a double reference:/// let s = &[-1, 0, 1];/// let mut iter = s.iter().skip_while(|x| **x < 0); // need two *s!/// Stopping after an initial `false`:/// let a = [-1, 0, 1, -2];/// let mut iter = a.into_iter().skip_while(|&x| x < 0);/// // while this would have been false, since we already got a false,/// // skip_while() isn't used any more/// assert_eq!(iter.next(), Some(-2));/// Creates an iterator that yields elements based on a predicate./// `take_while()` takes a closure as an argument. It will call this/// closure on each element of the iterator, and yield elements/// while it returns `true`./// After `false` is returned, `take_while()`'s job is over, and the/// rest of the elements are ignored./// let mut iter = a.into_iter().take_while(|x| x.is_negative());/// assert_eq!(iter.next(), Some(-1));/// Because the closure passed to `take_while()` takes a reference, and many/// let mut iter = s.iter().take_while(|x| **x < 0); // need two *s!/// assert_eq!(iter.next(), Some(&-1));/// let mut iter = a.into_iter().take_while(|&x| x < 0);/// // We have more elements that are less than zero, but since we already/// // got a false, take_while() ignores the remaining elements./// Because `take_while()` needs to look at the value in order to see if it/// should be included or not, consuming iterators will see that it is/// removed:/// let result: Vec<i32> = iter.by_ref().take_while(|&n| n != 3).collect();/// assert_eq!(result, [1, 2]);/// let result: Vec<i32> = iter.collect();/// assert_eq!(result, [4]);/// The `3` is no longer there, because it was consumed in order to see if/// the iteration should stop, but wasn't placed back into the iterator./// Creates an iterator that both yields elements based on a predicate and maps./// `map_while()` takes a closure as an argument. It will call this/// while it returns [`Some(_)`][`Some`]./// let a = [-1i32, 4, 0, 1];/// let mut iter = a.into_iter().map_while(|x| 16i32.checked_div(x));/// assert_eq!(iter.next(), Some(-16));/// Here's the same example, but with [`take_while`] and [`map`]:/// let mut iter = a.into_iter()///                 .map(|x| 16i32.checked_div(x))///                 .take_while(|x| x.is_some())///                 .map(|x| x.unwrap());/// Stopping after an initial [`None`]:/// let a = [0, 1, 2, -3, 4, 5, -6];/// let iter = a.into_iter().map_while(|x| u32::try_from(x).ok());/// let vec: Vec<_> = iter.collect();/// // We have more elements that could fit in u32 (such as 4, 5), but `map_while` returned `None` for `-3`/// // (as the `predicate` returned `None`) and `collect` stops at the first `None` encountered./// assert_eq!(vec, [0, 1, 2]);/// Because `map_while()` needs to look at the value in order to see if it/// let a = [1, 2, -3, 4];/// let result: Vec<u32> = iter.by_ref()///                            .map_while(|n| u32::try_from(n).ok())///                            .collect();/// The `-3` is no longer there, because it was consumed in order to see if/// Note that unlike [`take_while`] this iterator is **not** fused./// It is also not specified what this iterator returns after the first [`None`] is returned./// If you need a fused iterator, use [`fuse`]./// [`fuse`]: Iterator::fuse/// `skip(n)` skips elements until `n` elements are skipped or the end of the/// iterator is reached (whichever happens first). After that, all the remaining/// elements are yielded. In particular, if the original iterator is too short,/// then the returned iterator is empty./// Rather than overriding this method directly, instead override the `nth` method./// let mut iter = a.into_iter().skip(2);/// Creates an iterator that yields the first `n` elements, or fewer/// if the underlying iterator ends sooner./// `take(n)` yields elements until `n` elements are yielded or the end of/// the iterator is reached (whichever happens first)./// The returned iterator is a prefix of length `n` if the original iterator/// contains at least `n` elements, otherwise it contains all of the/// (fewer than `n`) elements of the original iterator./// let mut iter = a.into_iter().take(2);/// `take()` is often used with an infinite iterator, to make it finite:/// let mut iter = (0..).take(3);/// If less than `n` elements are available,/// `take` will limit itself to the size of the underlying iterator:/// let v = [1, 2];/// let mut iter = v.into_iter().take(5);/// Use [`by_ref`] to take from the iterator without consuming it, and then/// continue using the original iterator:/// let mut words = ["hello", "world", "of", "Rust"].into_iter();/// // Take the first two words./// let hello_world: Vec<_> = words.by_ref().take(2).collect();/// assert_eq!(hello_world, vec!["hello", "world"]);/// // Collect the rest of the words./// // We can only do this because we used `by_ref` earlier./// let of_rust: Vec<_> = words.collect();/// assert_eq!(of_rust, vec!["of", "Rust"]);/// [`by_ref`]: Iterator::by_ref/// An iterator adapter which, like [`fold`], holds internal state, but/// unlike [`fold`], produces a new iterator./// [`fold`]: Iterator::fold/// `scan()` takes two arguments: an initial value which seeds the internal/// state, and a closure with two arguments, the first being a mutable/// reference to the internal state and the second an iterator element./// The closure can assign to the internal state to share state between/// iterations./// On iteration, the closure will be applied to each element of the/// iterator and the return value from the closure, an [`Option`], is/// returned by the `next` method. Thus the closure can return/// `Some(value)` to yield `value`, or `None` to end the iteration./// let mut iter = a.into_iter().scan(1, |state, x| {///     // each iteration, we'll multiply the state by the element ...///     // ... and terminate if the state exceeds 6///     if *state > 6 {///     // ... else yield the negation of the state/// assert_eq!(iter.next(), Some(-6));/// Creates an iterator that works like map, but flattens nested structure./// The [`map`] adapter is very useful, but only when the closure/// argument produces values. If it produces an iterator instead, there's/// an extra layer of indirection. `flat_map()` will remove this extra layer/// on its own./// You can think of `flat_map(f)` as the semantic equivalent/// of [`map`]ping, and then [`flatten`]ing as in `map(f).flatten()`./// Another way of thinking about `flat_map()`: [`map`]'s closure returns/// one item for each element, and `flat_map()`'s closure returns an/// iterator for each element./// [`flatten`]: Iterator::flatten/// let words = ["alpha", "beta", "gamma"];/// // chars() returns an iterator/// let merged: String = words.iter()///                           .flat_map(|s| s.chars())///                           .collect();/// assert_eq!(merged, "alphabetagamma");/// Creates an iterator that flattens nested structure./// This is useful when you have an iterator of iterators or an iterator of/// things that can be turned into iterators and you want to remove one/// level of indirection./// let data = vec![vec![1, 2, 3, 4], vec![5, 6]];/// let flattened: Vec<_> = data.into_iter().flatten().collect();/// assert_eq!(flattened, [1, 2, 3, 4, 5, 6]);/// Mapping and then flattening:///                           .map(|s| s.chars())///                           .flatten()/// You can also rewrite this in terms of [`flat_map()`], which is preferable/// in this case since it conveys intent more clearly:/// Flattening works on any `IntoIterator` type, including `Option` and `Result`:/// let options = vec![Some(123), Some(321), None, Some(231)];/// let flattened_options: Vec<_> = options.into_iter().flatten().collect();/// assert_eq!(flattened_options, [123, 321, 231]);/// let results = vec![Ok(123), Ok(321), Err(456), Ok(231)];/// let flattened_results: Vec<_> = results.into_iter().flatten().collect();/// assert_eq!(flattened_results, [123, 321, 231]);/// Flattening only removes one level of nesting at a time:/// let d3 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];/// let d2: Vec<_> = d3.into_iter().flatten().collect();/// assert_eq!(d2, [[1, 2], [3, 4], [5, 6], [7, 8]]);/// let d1: Vec<_> = d3.into_iter().flatten().flatten().collect();/// assert_eq!(d1, [1, 2, 3, 4, 5, 6, 7, 8]);/// Here we see that `flatten()` does not perform a "deep" flatten./// Instead, only one level of nesting is removed. That is, if you/// `flatten()` a three-dimensional array, the result will be/// two-dimensional and not one-dimensional. To get a one-dimensional/// structure, you have to `flatten()` again./// [`flat_map()`]: Iterator::flat_map/// Calls the given function `f` for each contiguous window of size `N` over/// `self` and returns an iterator over the outputs of `f`. Like [`slice::windows()`],/// the windows during mapping overlap as well./// In the following example, the closure is called three times with the/// arguments `&['a', 'b']`, `&['b', 'c']` and `&['c', 'd']` respectively./// #![feature(iter_map_windows)]/// let strings = "abcd".chars()///     .map_windows(|[x, y]| format!("{}+{}", x, y))///     .collect::<Vec<String>>();/// assert_eq!(strings, vec!["a+b", "b+c", "c+d"]);/// Note that the const parameter `N` is usually inferred by the/// destructured argument in the closure./// The returned iterator yields 𝑘 − `N` + 1 items (where 𝑘 is the number of/// items yielded by `self`). If 𝑘 is less than `N`, this method yields an/// empty iterator./// The returned iterator implements [`FusedIterator`], because once `self`/// returns `None`, even if it returns a `Some(T)` again in the next iterations,/// we cannot put it into a contiguous array buffer, and thus the returned iterator/// should be fused./// [`slice::windows()`]: slice::windows/// Panics if `N` is zero. This check will most probably get changed to a/// compile time error before this method gets stabilized./// let iter = std::iter::repeat(0).map_windows(|&[]| ());/// Building the sums of neighboring numbers./// let mut it = [1, 3, 8, 1].iter().map_windows(|&[a, b]| a + b);/// assert_eq!(it.next(), Some(4));  // 1 + 3/// assert_eq!(it.next(), Some(11)); // 3 + 8/// assert_eq!(it.next(), Some(9));  // 8 + 1/// Since the elements in the following example implement `Copy`, we can/// just copy the array and get an iterator over the windows./// let mut it = "ferris".chars().map_windows(|w: &[_; 3]| *w);/// assert_eq!(it.next(), Some(['f', 'e', 'r']));/// assert_eq!(it.next(), Some(['e', 'r', 'r']));/// assert_eq!(it.next(), Some(['r', 'r', 'i']));/// assert_eq!(it.next(), Some(['r', 'i', 's']));/// You can also use this function to check the sortedness of an iterator./// For the simple case, rather use [`Iterator::is_sorted`]./// let mut it = [0.5, 1.0, 3.5, 3.0, 8.5, 8.5, f32::NAN].iter()///     .map_windows(|[a, b]| a <= b);/// assert_eq!(it.next(), Some(true));  // 0.5 <= 1.0/// assert_eq!(it.next(), Some(true));  // 1.0 <= 3.5/// assert_eq!(it.next(), Some(false)); // 3.5 <= 3.0/// assert_eq!(it.next(), Some(true));  // 3.0 <= 8.5/// assert_eq!(it.next(), Some(true));  // 8.5 <= 8.5/// assert_eq!(it.next(), Some(false)); // 8.5 <= NAN/// For non-fused iterators, they are fused after `map_windows`./// struct NonFusedIterator {///     state: i32,/// impl Iterator for NonFusedIterator {///     fn next(&mut self) -> Option<i32> {///         let val = self.state;///         self.state = self.state + 1;///         // yields `0..5` first, then only even numbers since `6..`.///         if val < 5 || val % 2 == 0 {///             Some(val)/// let mut iter = NonFusedIterator::default();/// // yields 0..5 first./// // then we can see our iterator going back and forth/// assert_eq!(iter.next(), Some(8));/// // however, with `.map_windows()`, it is fused./// let mut iter = NonFusedIterator::default()///     .map_windows(|arr: &[_; 2]| *arr);/// assert_eq!(iter.next(), Some([0, 1]));/// assert_eq!(iter.next(), Some([1, 2]));/// assert_eq!(iter.next(), Some([2, 3]));/// assert_eq!(iter.next(), Some([3, 4]));/// // it will always return `None` after the first time./// Creates an iterator which ends after the first [`None`]./// After an iterator returns [`None`], future calls may or may not yield/// [`Some(T)`] again. `fuse()` adapts an iterator, ensuring that after a/// [`None`] is given, it will always return [`None`] forever./// Note that the [`Fuse`] wrapper is a no-op on iterators that implement/// the [`FusedIterator`] trait. `fuse()` may therefore behave incorrectly/// if the [`FusedIterator`] trait is improperly implemented./// // an iterator which alternates between Some and None/// struct Alternate {/// impl Iterator for Alternate {///         // if it's even, Some(i32), else None///         (val % 2 == 0).then_some(val)/// let mut iter = Alternate { state: 0 };/// // we can see our iterator going back and forth/// // however, once we fuse it.../// let mut iter = iter.fuse();/// Does something with each element of an iterator, passing the value on./// When using iterators, you'll often chain several of them together./// While working on such code, you might want to check out what's/// happening at various parts in the pipeline. To do that, insert/// a call to `inspect()`./// It's more common for `inspect()` to be used as a debugging tool than to/// exist in your final code, but applications may find it useful in certain/// situations when errors need to be logged before being discarded.///     .cloned()///     .fold(0, |sum, i| sum + i);/// println!("{sum}");///     .inspect(|x| println!("about to filter: {x}"))///     .inspect(|x| println!("made it through filter: {x}"))/// This will print:/// 6/// about to filter: 1/// about to filter: 4/// made it through filter: 4/// about to filter: 2/// made it through filter: 2/// about to filter: 3/// Logging errors before discarding them:/// let lines = ["1", "2", "a"];/// let sum: i32 = lines///     .map(|line| line.parse::<i32>())///     .inspect(|num| {///         if let Err(ref e) = *num {///             println!("Parsing error: {e}");///     .filter_map(Result::ok)/// println!("Sum: {sum}");/// Parsing error: invalid digit found in string/// Sum: 3/// Creates a "by reference" adapter for this instance of `Iterator`./// Consuming method calls (direct or indirect calls to `next`)/// on the "by reference" adapter will consume the original iterator,/// but ownership-taking methods (those with a `self` parameter)/// only take ownership of the "by reference" iterator./// This is useful for applying ownership-taking methods/// (such as `take` in the example below)/// without giving up ownership of the original iterator,/// so you can use the original iterator afterwards./// Uses [`impl<I: Iterator + ?Sized> Iterator for &mut I { type Item = I::Item; ...}`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#impl-Iterator-for-%26mut+I)."if you really need to exhaust the iterator, consider `.for_each(drop)` instead""iterator_collect_fn"/// Transforms an iterator into a collection./// `collect()` can take anything iterable, and turn it into a relevant/// collection. This is one of the more powerful methods in the standard/// library, used in a variety of contexts./// The most basic pattern in which `collect()` is used is to turn one/// collection into another. You take a collection, call [`iter`] on it,/// do a bunch of transformations, and then `collect()` at the end./// `collect()` can also create instances of types that are not typical/// collections. For example, a [`String`] can be built from [`char`]s,/// and an iterator of [`Result<T, E>`][`Result`] items can be collected/// into `Result<Collection<T>, E>`. See the examples below for more./// Because `collect()` is so general, it can cause problems with type/// inference. As such, `collect()` is one of the few times you'll see/// the syntax affectionately known as the 'turbofish': `::<>`. This/// helps the inference algorithm understand specifically which collection/// you're trying to collect into./// let doubled: Vec<i32> = a.iter()///                          .map(|x| x * 2)///                          .collect();/// assert_eq!(vec![2, 4, 6], doubled);/// Note that we needed the `: Vec<i32>` on the left-hand side. This is because/// we could collect into, for example, a [`VecDeque<T>`] instead:/// [`VecDeque<T>`]: ../../std/collections/struct.VecDeque.html/// let doubled: VecDeque<i32> = a.iter().map(|x| x * 2).collect();/// assert_eq!(2, doubled[0]);/// assert_eq!(4, doubled[1]);/// assert_eq!(6, doubled[2]);/// Using the 'turbofish' instead of annotating `doubled`:/// let doubled = a.iter().map(|x| x * 2).collect::<Vec<i32>>();/// Because `collect()` only cares about what you're collecting into, you can/// still use a partial type hint, `_`, with the turbofish:/// let doubled = a.iter().map(|x| x * 2).collect::<Vec<_>>();/// Using `collect()` to make a [`String`]:/// let chars = ['g', 'd', 'k', 'k', 'n'];/// let hello: String = chars.into_iter()///     .map(|x| x as u8)///     .map(|x| (x + 1) as char)/// assert_eq!("hello", hello);/// If you have a list of [`Result<T, E>`][`Result`]s, you can use `collect()` to/// see if any of them failed:/// let results = [Ok(1), Err("nope"), Ok(3), Err("bad")];/// let result: Result<Vec<_>, &str> = results.into_iter().collect();/// // gives us the first error/// assert_eq!(Err("nope"), result);/// let results = [Ok(1), Ok(3)];/// // gives us the list of answers/// assert_eq!(Ok(vec![1, 3]), result);/// [`iter`]: Iterator::next/// [`char`]: type@char/// Fallibly transforms an iterator into a collection, short circuiting if/// a failure is encountered./// `try_collect()` is a variation of [`collect()`][`collect`] that allows fallible/// conversions during collection. Its main use case is simplifying conversions from/// iterators yielding [`Option<T>`][`Option`] into `Option<Collection<T>>`, or similarly for other [`Try`]/// types (e.g. [`Result`])./// Importantly, `try_collect()` doesn't require that the outer [`Try`] type also implements [`FromIterator`];/// only the inner type produced on `Try::Output` must implement it. Concretely,/// this means that collecting into `ControlFlow<_, Vec<i32>>` is valid because `Vec<i32>` implements/// [`FromIterator`], even though [`ControlFlow`] doesn't./// Also, if a failure is encountered during `try_collect()`, the iterator is still valid and/// may continue to be used, in which case it will continue iterating starting after the element that/// triggered the failure. See the last example below for an example of how this works./// Successfully collecting an iterator of `Option<i32>` into `Option<Vec<i32>>`:/// #![feature(iterator_try_collect)]/// let u = vec![Some(1), Some(2), Some(3)];/// let v = u.into_iter().try_collect::<Vec<i32>>();/// assert_eq!(v, Some(vec![1, 2, 3]));/// Failing to collect in the same way:/// let u = vec![Some(1), Some(2), None, Some(3)];/// assert_eq!(v, None);/// A similar example, but with `Result`:/// let u: Vec<Result<i32, ()>> = vec![Ok(1), Ok(2), Ok(3)];/// assert_eq!(v, Ok(vec![1, 2, 3]));/// let u = vec![Ok(1), Ok(2), Err(()), Ok(3)];/// assert_eq!(v, Err(()));/// Finally, even [`ControlFlow`] works, despite the fact that it/// doesn't implement [`FromIterator`]. Note also that the iterator can/// continue to be used, even if a failure is encountered:/// use core::ops::ControlFlow::{Break, Continue};/// let u = [Continue(1), Continue(2), Break(3), Continue(4), Continue(5)];/// let mut it = u.into_iter();/// let v = it.try_collect::<Vec<_>>();/// assert_eq!(v, Break(3));/// assert_eq!(v, Continue(vec![4, 5]));/// [`collect`]: Iterator::collectcollect_into/// Collects all the items from an iterator into a collection./// This method consumes the iterator and adds all its items to the/// passed collection. The collection is then returned, so the call chain/// can be continued./// This is useful when you already have a collection and want to add/// the iterator items to it./// This method is a convenience method to call [Extend::extend](trait.Extend.html),/// but instead of being called on a collection, it's called on an iterator./// #![feature(iter_collect_into)]/// let mut vec: Vec::<i32> = vec![0, 1];/// a.iter().map(|x| x * 2).collect_into(&mut vec);/// a.iter().map(|x| x * 10).collect_into(&mut vec);/// assert_eq!(vec, vec![0, 1, 2, 4, 6, 10, 20, 30]);/// `Vec` can have a manual set capacity to avoid reallocating it:/// let mut vec: Vec::<i32> = Vec::with_capacity(6);/// assert_eq!(6, vec.capacity());/// assert_eq!(vec, vec![2, 4, 6, 10, 20, 30]);/// The returned mutable reference can be used to continue the call chain:/// let count = a.iter().collect_into(&mut vec).iter().count();/// assert_eq!(count, vec.len());/// assert_eq!(vec, vec![1, 2, 3]);/// assert_eq!(vec, vec![1, 2, 3, 1, 2, 3]);/// Consumes an iterator, creating two collections from it./// The predicate passed to `partition()` can return `true`, or `false`./// `partition()` returns a pair, all of the elements for which it returned/// `true`, and all of the elements for which it returned `false`./// See also [`is_partitioned()`] and [`partition_in_place()`]./// [`is_partitioned()`]: Iterator::is_partitioned/// [`partition_in_place()`]: Iterator::partition_in_place/// let (even, odd): (Vec<_>, Vec<_>) = a///     .partition(|n| n % 2 == 0);/// assert_eq!(even, [2]);/// assert_eq!(odd, [1, 3]);partition_in_place/// Reorders the elements of this iterator *in-place* according to the given predicate,/// such that all those that return `true` precede all those that return `false`./// Returns the number of `true` elements found./// The relative order of partitioned items is not maintained./// The current algorithm tries to find the first element for which the predicate evaluates/// to false and the last element for which it evaluates to true, and repeatedly swaps them./// Time complexity: *O*(*n*)/// See also [`is_partitioned()`] and [`partition()`]./// [`partition()`]: Iterator::partition/// #![feature(iter_partition_in_place)]/// let mut a = [1, 2, 3, 4, 5, 6, 7];/// // Partition in-place between evens and odds/// let i = a.iter_mut().partition_in_place(|n| n % 2 == 0);/// assert_eq!(i, 3);/// assert!(a[..i].iter().all(|n| n % 2 == 0)); // evens/// assert!(a[i..].iter().all(|n| n % 2 == 1)); // oddsis_partitioned/// Checks if the elements of this iterator are partitioned according to the given predicate,/// See also [`partition()`] and [`partition_in_place()`]./// #![feature(iter_is_partitioned)]/// assert!("Iterator".chars().is_partitioned(char::is_uppercase));/// assert!(!"IntoIterator".chars().is_partitioned(char::is_uppercase));/// An iterator method that applies a function as long as it returns/// successfully, producing a single, final value./// `try_fold()` takes two arguments: an initial value, and a closure with/// two arguments: an 'accumulator', and an element. The closure either/// returns successfully, with the value that the accumulator should have/// for the next iteration, or it returns failure, with an error value that/// is propagated back to the caller immediately (short-circuiting)./// call. If applying the closure succeeded against every element of the/// iterator, `try_fold()` returns the final accumulator as success./// # Note to Implementors/// Several of the other (forward) methods have default implementations in/// terms of this one, so try to implement this explicitly if it can/// do something better than the default `for` loop implementation./// In particular, try to have this call `try_fold()` on the internal parts/// from which this iterator is composed. If multiple calls are needed,/// the `?` operator may be convenient for chaining the accumulator value/// along, but beware any invariants that need to be upheld before those/// early returns. This is a `&mut self` method, so iteration needs to be/// resumable after hitting an error here./// // the checked sum of all of the elements of the array/// let sum = a.into_iter().try_fold(0i8, |acc, x| acc.checked_add(x));/// assert_eq!(sum, Some(6));/// let a = [10, 20, 30, 100, 40, 50];/// // This sum overflows when adding the 100 element/// let sum = iter.try_fold(0i8, |acc, x| acc.checked_add(x));/// assert_eq!(sum, None);/// assert_eq!(iter.len(), 2);/// assert_eq!(iter.next(), Some(40));/// While you cannot `break` from a closure, the [`ControlFlow`] type allows/// a similar idea:/// use std::ops::ControlFlow;/// let triangular = (1..30).try_fold(0_i8, |prev, x| {///     if let Some(next) = prev.checked_add(x) {///         ControlFlow::Continue(next)///         ControlFlow::Break(prev)/// assert_eq!(triangular, ControlFlow::Break(120));/// let triangular = (1..30).try_fold(0_u64, |prev, x| {/// assert_eq!(triangular, ControlFlow::Continue(435));/// An iterator method that applies a fallible function to each item in the/// iterator, stopping at the first error and returning that error./// This can also be thought of as the fallible form of [`for_each()`]/// or as the stateless version of [`try_fold()`]./// [`for_each()`]: Iterator::for_each/// [`try_fold()`]: Iterator::try_fold/// use std::fs::rename;/// use std::io::{stdout, Write};/// let data = ["no_tea.txt", "stale_bread.json", "torrential_rain.png"];/// let res = data.iter().try_for_each(|x| writeln!(stdout(), "{x}"));/// let mut it = data.iter().cloned();/// let res = it.try_for_each(|x| rename(x, Path::new(x).with_extension("old")));/// // It short-circuited, so the remaining items are still in the iterator:/// assert_eq!(it.next(), Some("stale_bread.json"));/// The [`ControlFlow`] type can be used with this method for the situations/// in which you'd use `break` and `continue` in a normal loop:/// let r = (2..100).try_for_each(|x| {///     if 323 % x == 0 {///         return ControlFlow::Break(x)///     ControlFlow::Continue(())/// assert_eq!(r, ControlFlow::Break(17));/// `fold()` takes two arguments: an initial value, and a closure with two/// After applying this closure to every element of the iterator, `fold()`/// Note: `fold()`, and similar methods that traverse the entire iterator,/// might not terminate for infinite iterators, even on traits for which a/// result is determinable in finite time./// Note: [`reduce()`] can be used to use the first element as the initial/// value, if the accumulator type and item type is the same./// Note: `fold()` combines elements in a *left-associative* fashion. For associative/// For a *right-associative* version of `fold()`, see [`DoubleEndedIterator::rfold()`]./// In particular, try to have this call `fold()` on the internal parts/// from which this iterator is composed./// // the sum of all of the elements of the array/// let sum = a.iter().fold(0, |acc, x| acc + x);/// Let's walk through each step of the iteration here:/// | element | acc | x | result |/// |---------|-----|---|--------|/// |         | 0   |   |        |/// | 1       | 0   | 1 | 1      |/// | 2       | 1   | 2 | 3      |/// | 3       | 3   | 3 | 6      |/// And so, our final result, `6`./// This example demonstrates the left-associative nature of `fold()`:/// and continuing with each element from the front until the back:/// let result = numbers.iter().fold(zero, |acc, &x| {///     format!("({acc} + {x})")/// assert_eq!(result, "(((((0 + 1) + 2) + 3) + 4) + 5)");/// It's common for people who haven't used iterators a lot to/// use a `for` loop with a list of things to build up a result. Those/// can be turned into `fold()`s:/// let result2 = numbers.iter().fold(0, |acc, &x| acc + x);/// [`reduce()`]: Iterator::reduce/// Reduces the elements to a single one, by repeatedly applying a reducing/// If the iterator is empty, returns [`None`]; otherwise, returns the/// result of the reduction./// The reducing function is a closure with two arguments: an 'accumulator', and an element./// For iterators with at least one element, this is the same as [`fold()`]/// with the first element of the iterator as the initial accumulator value, folding/// every subsequent element into it./// [`fold()`]: Iterator::fold/// let reduced: i32 = (1..10).reduce(|acc, e| acc + e).unwrap_or(0);/// assert_eq!(reduced, 45);/// // Which is equivalent to doing it with `fold`:/// let folded: i32 = (1..10).fold(0, |acc, e| acc + e);/// assert_eq!(reduced, folded);/// Reduces the elements to a single one by repeatedly applying a reducing operation. If the/// closure returns a failure, the failure is propagated back to the caller immediately./// The return type of this method depends on the return type of the closure. If the closure/// returns `Result<Self::Item, E>`, then this function will return `Result<Option<Self::Item>,/// E>`. If the closure returns `Option<Self::Item>`, then this function will return/// `Option<Option<Self::Item>>`./// When called on an empty iterator, this function will return either `Some(None)` or/// `Ok(None)` depending on the type of the provided closure./// For iterators with at least one element, this is essentially the same as calling/// [`try_fold()`] with the first element of the iterator as the initial accumulator value./// Safely calculate the sum of a series of numbers:/// #![feature(iterator_try_reduce)]/// let numbers: Vec<usize> = vec![10, 20, 5, 23, 0];/// let sum = numbers.into_iter().try_reduce(|x, y| x.checked_add(y));/// assert_eq!(sum, Some(Some(58)));/// Determine when a reduction short circuited:/// let numbers = vec![1, 2, 3, usize::MAX, 4, 5];/// Determine when a reduction was not performed because there are no elements:/// let numbers: Vec<usize> = Vec::new();/// assert_eq!(sum, Some(None));/// Use a [`Result`] instead of an [`Option`]:/// let numbers = vec!["1", "2", "3", "4", "5"];/// let max: Result<Option<_>, <usize as std::str::FromStr>::Err> =///     numbers.into_iter().try_reduce(|x, y| {///         if x.parse::<usize>()? > y.parse::<usize>()? { Ok(x) } else { Ok(y) }/// assert_eq!(max, Ok(Some("5")));/// Tests if every element of the iterator matches a predicate./// `all()` takes a closure that returns `true` or `false`. It applies/// this closure to each element of the iterator, and if they all return/// `true`, then so does `all()`. If any of them return `false`, it/// `all()` is short-circuiting; in other words, it will stop processing/// as soon as it finds a `false`, given that no matter what else happens,/// the result will also be `false`./// An empty iterator returns `true`./// assert!(a.into_iter().all(|x| x > 0));/// assert!(!a.into_iter().all(|x| x > 2));/// Stopping at the first `false`:/// assert!(!iter.all(|x| x != 2));/// Tests if any element of the iterator matches a predicate./// `any()` takes a closure that returns `true` or `false`. It applies/// this closure to each element of the iterator, and if any of them return/// `true`, then so does `any()`. If they all return `false`, it/// `any()` is short-circuiting; in other words, it will stop processing/// as soon as it finds a `true`, given that no matter what else happens,/// the result will also be `true`./// An empty iterator returns `false`./// assert!(a.into_iter().any(|x| x > 0));/// assert!(!a.into_iter().any(|x| x > 5));/// assert!(iter.any(|x| x != 2));/// Searches for an element of an iterator that satisfies a predicate./// `find()` takes a closure that returns `true` or `false`. It applies/// `true`, then `find()` returns [`Some(element)`]. If they all return/// `find()` is short-circuiting; in other words, it will stop processing/// Because `find()` takes a reference, and many iterators iterate over/// If you need the index of the element, see [`position()`]./// [`position()`]: Iterator::position/// assert_eq!(a.into_iter().find(|&x| x == 2), Some(2));/// assert_eq!(a.into_iter().find(|&x| x == 5), None);/// assert_eq!(iter.find(|&x| x == 2), Some(2));/// Note that `iter.find(f)` is equivalent to `iter.filter(f).next()`./// Applies function to the elements of iterator and returns/// the first non-none result./// `iter.find_map(f)` is equivalent to `iter.filter_map(f).next()`./// let a = ["lol", "NaN", "2", "5"];/// let first_number = a.iter().find_map(|s| s.parse().ok());/// the first true result or the first error./// The return type of this method depends on the return type of the closure./// If you return `Result<bool, E>` from the closure, you'll get a `Result<Option<Self::Item>, E>`./// If you return `Option<bool>` from the closure, you'll get an `Option<Option<Self::Item>>`./// #![feature(try_find)]/// let a = ["1", "2", "lol", "NaN", "5"];/// let is_my_num = |s: &str, search: i32| -> Result<bool, std::num::ParseIntError> {///     Ok(s.parse::<i32>()? == search)/// let result = a.into_iter().try_find(|&s| is_my_num(s, 2));/// assert_eq!(result, Ok(Some("2")));/// let result = a.into_iter().try_find(|&s| is_my_num(s, 5));/// This also supports other types which implement [`Try`], not just [`Result`]./// let a = [3, 5, 7, 4, 9, 0, 11u32];/// let result = a.into_iter().try_find(|&x| NonZero::new(x).map(|y| y.is_power_of_two()));/// assert_eq!(result, Some(Some(4)));/// let result = a.into_iter().take(3).try_find(|&x| NonZero::new(x).map(|y| y.is_power_of_two()));/// assert_eq!(result, Some(None));/// let result = a.into_iter().rev().try_find(|&x| NonZero::new(x).map(|y| y.is_power_of_two()));/// Searches for an element in an iterator, returning its index./// `position()` takes a closure that returns `true` or `false`. It applies/// this closure to each element of the iterator, and if one of them/// returns `true`, then `position()` returns [`Some(index)`]. If all of/// them return `false`, it returns [`None`]./// `position()` is short-circuiting; in other words, it will stop/// processing as soon as it finds a `true`./// The method does no guarding against overflows, so if there are more/// than [`usize::MAX`] non-matching elements, it either produces the wrong/// result or panics. If overflow checks are enabled, a panic is/// This function might panic if the iterator has more than `usize::MAX`/// non-matching elements./// [`Some(index)`]: Some/// assert_eq!(a.into_iter().position(|x| x == 2), Some(1));/// assert_eq!(a.into_iter().position(|x| x == 5), None);/// assert_eq!(iter.position(|x| x >= 2), Some(1));/// // The returned index depends on iterator state/// assert_eq!(iter.position(|x| x == 4), Some(0));rposition/// Searches for an element in an iterator from the right, returning its/// `rposition()` takes a closure that returns `true` or `false`. It applies/// this closure to each element of the iterator, starting from the end,/// and if one of them returns `true`, then `rposition()` returns/// [`Some(index)`]. If all of them return `false`, it returns [`None`]./// `rposition()` is short-circuiting; in other words, it will stop/// assert_eq!(a.into_iter().rposition(|x| x == 3), Some(2));/// assert_eq!(a.into_iter().rposition(|x| x == 5), None);/// let a = [-1, 2, 3, 4];/// assert_eq!(iter.rposition(|x| x >= 2), Some(3));/// Returns the maximum element of an iterator./// If several elements are equally maximum, the last element is/// returned. If the iterator is empty, [`None`] is returned./// Note that [`f32`]/[`f64`] doesn't implement [`Ord`] due to NaN being/// incomparable. You can work around this by using [`Iterator::reduce`]:///     [2.4, f32::NAN, 1.3]///         .reduce(f32::max)///         .unwrap_or(0.),///     2.4/// let b: [u32; 0] = [];/// assert_eq!(a.into_iter().max(), Some(3));/// assert_eq!(b.into_iter().max(), None);/// Returns the minimum element of an iterator./// If several elements are equally minimum, the first element is returned./// If the iterator is empty, [`None`] is returned.///         .reduce(f32::min)///     1.3/// assert_eq!(a.into_iter().min(), Some(1));/// assert_eq!(b.into_iter().min(), None);/// Returns the element that gives the maximum value from the/// specified function./// assert_eq!(a.into_iter().max_by_key(|x| x.abs()).unwrap(), -10);/// Returns the element that gives the maximum value with respect to the/// specified comparison function./// assert_eq!(a.into_iter().max_by(|x, y| x.cmp(y)).unwrap(), 5);/// Returns the element that gives the minimum value from the/// If several elements are equally minimum, the first element is/// assert_eq!(a.into_iter().min_by_key(|x| x.abs()).unwrap(), 0);/// Returns the element that gives the minimum value with respect to the/// assert_eq!(a.into_iter().min_by(|x, y| x.cmp(y)).unwrap(), -10);/// Reverses an iterator's direction./// Usually, iterators iterate from left to right. After using `rev()`,/// an iterator will instead iterate from right to left./// This is only possible if the iterator has an end, so `rev()` only/// works on [`DoubleEndedIterator`]s./// let mut iter = a.into_iter().rev();/// Converts an iterator of pairs into a pair of containers./// `unzip()` consumes an entire iterator of pairs, producing two/// collections: one from the left elements of the pairs, and one/// from the right elements./// This function is, in some sense, the opposite of [`zip`]./// let a = [(1, 2), (3, 4), (5, 6)];/// let (left, right): (Vec<_>, Vec<_>) = a.into_iter().unzip();/// assert_eq!(left, [1, 3, 5]);/// assert_eq!(right, [2, 4, 6]);/// // you can also unzip multiple nested tuples at once/// let a = [(1, (2, 3)), (4, (5, 6))];/// let (x, (y, z)): (Vec<_>, (Vec<_>, Vec<_>)) = a.into_iter().unzip();/// assert_eq!(x, [1, 4]);/// assert_eq!(y, [2, 5]);/// assert_eq!(z, [3, 6]);"iter_copied"/// Creates an iterator which copies all of its elements./// This is useful when you have an iterator over `&T`, but you need an/// iterator over `T`./// let v_copied: Vec<_> = a.iter().copied().collect();/// // copied is the same as .map(|&x| x)/// let v_map: Vec<_> = a.iter().map(|&x| x).collect();/// assert_eq!(v_copied, [1, 2, 3]);/// assert_eq!(v_map, [1, 2, 3]);"iter_cloned"/// Creates an iterator which [`clone`]s all of its elements./// There is no guarantee whatsoever about the `clone` method actually/// being called *or* optimized away. So code should not depend on/// either./// let v_cloned: Vec<_> = a.iter().cloned().collect();/// assert_eq!(v_cloned, [1, 2, 3]);/// To get the best performance, try to clone late:/// let a = [vec![0_u8, 1, 2], vec![3, 4], vec![23]];/// let slower: Vec<_> = a.iter().cloned().filter(|s| s.len() == 1).collect();/// assert_eq!(&[vec![23]], &slower[..]);/// // instead call `cloned` late/// let faster: Vec<_> = a.iter().filter(|s| s.len() == 1).cloned().collect();/// assert_eq!(&[vec![23]], &faster[..]);/// Repeats an iterator endlessly./// Instead of stopping at [`None`], the iterator will instead start again,/// from the beginning. After iterating again, it will start at the/// beginning again. And again. And again. Forever. Note that in case the/// original iterator is empty, the resulting iterator will also be empty./// let mut iter = a.into_iter().cycle();///     assert_eq!(iter.next(), Some(1));///     assert_eq!(iter.next(), Some(2));///     assert_eq!(iter.next(), Some(3));/// #   break;/// Returns an iterator over `N` elements of the iterator at a time./// iterator, then the last up to `N-1` elements will be omitted and can be/// retrieved from the [`.into_remainder()`][ArrayChunks::into_remainder]/// function of the iterator./// Panics if `N` is zero./// #![feature(iter_array_chunks)]/// let mut iter = "lorem".chars().array_chunks();/// assert_eq!(iter.next(), Some(['l', 'o']));/// assert_eq!(iter.next(), Some(['r', 'e']));/// assert_eq!(iter.into_remainder().as_slice(), &['m']);/// let data = [1, 1, 2, -2, 6, 0, 3, 1];/// //          ^-----^  ^------^/// for [x, y, z] in data.iter().array_chunks() {///     assert_eq!(x + y + z, 4);/// Sums the elements of an iterator./// Takes each element, adds them together, and returns the result./// An empty iterator returns the *additive identity* ("zero") of the type,/// which is `0` for integers and `-0.0` for floats./// `sum()` can be used to sum any type implementing [`Sum`][`core::iter::Sum`],/// including [`Option`][`Option::sum`] and [`Result`][`Result::sum`]./// When calling `sum()` and a primitive integer type is being returned, this/// method will panic if the computation overflows and overflow checks are/// let sum: i32 = a.iter().sum();/// let b: Vec<f32> = vec![];/// let sum: f32 = b.iter().sum();/// assert_eq!(sum, -0.0_f32);/// Iterates over the entire iterator, multiplying all the elements/// An empty iterator returns the one value of the type./// `product()` can be used to multiply any type implementing [`Product`][`core::iter::Product`],/// including [`Option`][`Option::product`] and [`Result`][`Result::product`]./// When calling `product()` and a primitive integer type is being returned,///     (1..=n).product()/// [Lexicographically](Ord#lexicographical-comparison) compares the elements of this [`Iterator`] with those/// of another./// assert_eq!([1].iter().cmp([1].iter()), Ordering::Equal);/// assert_eq!([1].iter().cmp([1, 2].iter()), Ordering::Less);/// assert_eq!([1, 2].iter().cmp([1].iter()), Ordering::Greater);cmp_by/// of another with respect to the specified comparison function./// #![feature(iter_order_by)]/// let xs = [1, 2, 3, 4];/// let ys = [1, 4, 9, 16];/// assert_eq!(xs.into_iter().cmp_by(ys, |x, y| x.cmp(&y)), Ordering::Less);/// assert_eq!(xs.into_iter().cmp_by(ys, |x, y| (x * x).cmp(&y)), Ordering::Equal);/// assert_eq!(xs.into_iter().cmp_by(ys, |x, y| (2 * x).cmp(&y)), Ordering::Greater);/// [Lexicographically](Ord#lexicographical-comparison) compares the [`PartialOrd`] elements of/// this [`Iterator`] with those of another. The comparison works like short-circuit/// evaluation, returning a result without comparing the remaining elements./// As soon as an order can be determined, the evaluation stops and a result is returned./// assert_eq!([1.].iter().partial_cmp([1.].iter()), Some(Ordering::Equal));/// assert_eq!([1.].iter().partial_cmp([1., 2.].iter()), Some(Ordering::Less));/// assert_eq!([1., 2.].iter().partial_cmp([1.].iter()), Some(Ordering::Greater));/// For floating-point numbers, NaN does not have a total order and will result/// in `None` when compared:/// assert_eq!([f64::NAN].iter().partial_cmp([1.].iter()), None);/// The results are determined by the order of evaluation./// assert_eq!([1.0, f64::NAN].iter().partial_cmp([2.0, f64::NAN].iter()), Some(Ordering::Less));/// assert_eq!([2.0, f64::NAN].iter().partial_cmp([1.0, f64::NAN].iter()), Some(Ordering::Greater));/// assert_eq!([f64::NAN, 1.0].iter().partial_cmp([f64::NAN, 2.0].iter()), None);partial_cmp_by/// let xs = [1.0, 2.0, 3.0, 4.0];/// let ys = [1.0, 4.0, 9.0, 16.0];///     xs.iter().partial_cmp_by(ys, |x, y| x.partial_cmp(&y)),///     Some(Ordering::Less)///     xs.iter().partial_cmp_by(ys, |x, y| (x * x).partial_cmp(&y)),///     Some(Ordering::Equal)///     xs.iter().partial_cmp_by(ys, |x, y| (2.0 * x).partial_cmp(&y)),///     Some(Ordering::Greater)/// Determines if the elements of this [`Iterator`] are equal to those of/// assert_eq!([1].iter().eq([1].iter()), true);/// assert_eq!([1].iter().eq([1, 2].iter()), false);eq_by/// another with respect to the specified equality function./// assert!(xs.iter().eq_by(ys, |x, y| x * x == y));/// Determines if the elements of this [`Iterator`] are not equal to those of/// assert_eq!([1].iter().ne([1].iter()), false);/// assert_eq!([1].iter().ne([1, 2].iter()), true);/// Determines if the elements of this [`Iterator`] are [lexicographically](Ord#lexicographical-comparison)/// less than those of another./// assert_eq!([1].iter().lt([1].iter()), false);/// assert_eq!([1].iter().lt([1, 2].iter()), true);/// assert_eq!([1, 2].iter().lt([1].iter()), false);/// assert_eq!([1, 2].iter().lt([1, 2].iter()), false);/// less or equal to those of another./// assert_eq!([1].iter().le([1].iter()), true);/// assert_eq!([1].iter().le([1, 2].iter()), true);/// assert_eq!([1, 2].iter().le([1].iter()), false);/// assert_eq!([1, 2].iter().le([1, 2].iter()), true);/// greater than those of another./// assert_eq!([1].iter().gt([1].iter()), false);/// assert_eq!([1].iter().gt([1, 2].iter()), false);/// assert_eq!([1, 2].iter().gt([1].iter()), true);/// assert_eq!([1, 2].iter().gt([1, 2].iter()), false);/// greater than or equal to those of another./// assert_eq!([1].iter().ge([1].iter()), true);/// assert_eq!([1].iter().ge([1, 2].iter()), false);/// assert_eq!([1, 2].iter().ge([1].iter()), true);/// assert_eq!([1, 2].iter().ge([1, 2].iter()), true);/// Checks if the elements of this iterator are sorted./// That is, for each element `a` and its following element `b`, `a <= b` must hold. If the/// iterator yields exactly zero or one element, `true` is returned./// Note that if `Self::Item` is only `PartialOrd`, but not `Ord`, the above definition/// implies that this function returns `false` if any two consecutive items are not/// comparable./// assert!([1, 2, 2, 9].iter().is_sorted());/// assert!(![1, 3, 2, 4].iter().is_sorted());/// assert!([0].iter().is_sorted());/// assert!(std::iter::empty::<i32>().is_sorted());/// assert!(![0.0, 1.0, f32::NAN].iter().is_sorted());is_sorted_by/// Checks if the elements of this iterator are sorted using the given comparator function./// Instead of using `PartialOrd::partial_cmp`, this function uses the given `compare`/// function to determine whether two elements are to be considered in sorted order./// assert!([1, 2, 2, 9].iter().is_sorted_by(|a, b| a <= b));/// assert!(![1, 2, 2, 9].iter().is_sorted_by(|a, b| a < b));/// assert!([0].iter().is_sorted_by(|a, b| true));/// assert!([0].iter().is_sorted_by(|a, b| false));/// assert!(std::iter::empty::<i32>().is_sorted_by(|a, b| false));/// assert!(std::iter::empty::<i32>().is_sorted_by(|a, b| true));is_sorted_by_key/// Checks if the elements of this iterator are sorted using the given key extraction/// Instead of comparing the iterator's elements directly, this function compares the keys of/// the elements, as determined by `f`. Apart from that, it's equivalent to [`is_sorted`]; see/// its documentation for more information./// [`is_sorted`]: Iterator::is_sorted/// assert!(["c", "bb", "aaa"].iter().is_sorted_by_key(|s| s.len()));/// assert!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n| n.abs()));/// See [TrustedRandomAccess][super::super::TrustedRandomAccess]// The unusual name is to avoid name collisions in method resolution// see #76479."iterator""Iterator"/// A trait for dealing with iterators./// This is the main iterator trait. For more about the concept of iterators/// may want to know how to [implement `Iterator`][impl]./// [impl]: crate::iter#implementing-iteratorspec_iter_eqSpecIterEqiter_compare/// Compares two iterators element-wise using the given function./// If `ControlFlow::Continue(())` is returned from the function, the comparison moves on to the next/// elements of both iterators. Returning `ControlFlow::Break(x)` short-circuits the iteration and/// returns `ControlFlow::Break(x)`. If one of the iterators runs out of elements,/// `ControlFlow::Continue(ord)` is returned where `ord` is the result of comparing the lengths of/// the iterators./// Isolates the logic shared by ['cmp_by'](Iterator::cmp_by),/// ['partial_cmp_by'](Iterator::partial_cmp_by), and ['eq_by'](Iterator::eq_by).iter_eq/// Implements `Iterator` for mutable references to iterators, such as those produced by [`Iterator::by_ref`]./// This implementation passes all method calls on to the original iterator.IteratorRefSpec/// Helper trait to specialize `fold` and `try_fold` for `&mut I where I: Sized`/// Same as FusedIterator/// This is used for specialization. Therefore implementations must not/// be lifetime-dependent."fused_iterator"/// An iterator that always continues to yield `None` when exhausted./// Calling next on a fused iterator that has returned `None` once is guaranteed/// to return [`None`] again. This trait should be implemented by all iterators/// that behave this way because it allows optimizing [`Iterator::fuse()`]./// Note: In general, you should not use `FusedIterator` in generic bounds if/// you need a fused iterator. Instead, you should just call [`Iterator::fuse()`]/// on the iterator. If the iterator is already fused, the additional [`Fuse`]/// wrapper will be a no-op with no performance penalty./// [`Fuse`]: crate::iter::Fuse// FIXME: this should be a #[marker] and have another blanket impl for T: TrustedFused// but that ICEs iter::Fuse specializations./// An iterator that reports an accurate length using size_hint./// The iterator reports a size hint where it is either exact/// (lower bound is equal to upper bound), or the upper bound is [`None`]./// The upper bound must only be [`None`] if the actual iterator length is/// larger than [`usize::MAX`]. In that case, the lower bound must be/// [`usize::MAX`], resulting in an [`Iterator::size_hint()`] of/// `(usize::MAX, None)`./// The iterator must produce exactly the number of elements it reported/// or diverge before reaching the end./// # When *shouldn't* an adapter be `TrustedLen`?/// If an adapter makes an iterator *shorter* by a given amount, then it's/// usually incorrect for that adapter to implement `TrustedLen`.  The inner/// iterator might return more than `usize::MAX` items, but there's no way to/// know what `k` elements less than that will be, since the `size_hint` from/// the inner iterator has already saturated and lost that information./// This is why [`Skip<I>`](crate::iter::Skip) isn't `TrustedLen`, even when/// `I` implements `TrustedLen`./// This trait must only be implemented when the contract is upheld. Consumers/// of this trait must inspect [`Iterator::size_hint()`]’s upper bound./// The product of one-to-many item expansions that happen throughout the iterator pipeline./// E.g. [[u8; 4]; 4].iter().flatten().flatten() would have a `EXPAND_BY` of 16./// This is an upper bound, i.e. the transformations will produce at most this many items per/// input. It's meant for layout calculations./// The product of many-to-one item reductions that happen throughout the iterator pipeline./// E.g. [u8].iter().array_chunks::<4>().array_chunks::<4>() would have a `MERGE_BY` of 16./// This is a lower bound, i.e. the transformations will consume at least this many items per/// An iterator that when yielding an item will have taken at least one element/// from its underlying [`SourceIter`]./// Calling any method that advances the iterator, e.g.  [`next()`] or [`try_fold()`],/// guarantees that for each step at least one value of the iterator's underlying source/// has been moved out and the result of the iterator chain could be inserted/// in its place, assuming structural constraints of the source allow such an insertion./// In other words this trait indicates that an iterator pipeline can be collected in place./// [`SourceIter`]: crate::iter::SourceIter/// A type that upholds all invariants of [`Step`]./// The invariants of [`Step::steps_between()`] are a superset of the invariants/// of [`TrustedLen`]. As such, [`TrustedLen`] is implemented for all range/// types with the same generic type argument./// The implementation of [`Step`] for the given type must guarantee all/// invariants of all methods are upheld. See the [`Step`] trait's documentation/// for details. Consumers are free to rely on the invariants in unsafe code.double_endedexact_sizeunchecked_iterator/// Gets the next item from a non-empty iterator./// Because there's always a value to return, that means it can return/// the `Item` type directly, without wrapping it in an `Option`./// This can only be called if `size_hint().0 != 0`, guaranteeing that/// there's at least one item available./// Otherwise (aka when `size_hint().1 == Some(0)`), this is UB./// This has a default implementation using [`Option::unwrap_unchecked`]./// That's probably sufficient if your `next` *always* returns `Some`,/// such as for infinite iterators.  In more complicated situations, however,/// sometimes there can still be `insertvalue`/`assume`/`extractvalue`/// instructions remaining in the IR from the `Option` handling, at which/// point you might want to implement this manually instead./// [`TrustedLen`] cannot have methods, so this allows augmenting it./// It currently requires `TrustedLen` because it's unclear whether it's/// reasonably possible to depend on the `size_hint` of anything else.realcoreno_corerustc_coherence_is_core// allow using `core::` in intra-doc links/* The core prelude, not as all-encompassing as the std prelude */// The compiler expects the prelude definition to be defined before it's use statement.prelude_importrust_2024debug_assert_matches/// Unstable module containing the unstable `assert_matches` macro./// Unstable module containing the unstable `From` derive macro.autodiff_forwardautodiff_reverse// We don't export this through #[macro_export] for now, to avoid breakage./// Unstable module containing the unstable `autodiff` macro.contracts"num/shells/legacy_int_modules.rs"legacy_int_modules// FIXME false positive (https://github.com/rust-lang/rust-clippy/issues/15636)"num/f128.rs""num/f16.rs""num/f32.rs""num/f64.rs"profilingassertingunsafe_binder/* Async *//* Heap memory allocator trait */// note: does not need to be public"../../stdarch/crates/core_arch/src/mod.rs"// Pull in the `core_arch` crate directly into core. The contents of// `core_arch` are in a different repository: rust-lang/stdarch.// `core_arch` depends on core, but the contents of this module are// set up in such a way that directly pulling it here works such that the// crate uses the this crate as its core."../../portable-simd/crates/core_simd/src/mod.rs"core_simd// Pull in the `core_simd` crate directly into core. The contents of// `core_simd` are in a different repository: rust-lang/portable-simd.// `core_simd` depends on core, but the contents of this module are// crate uses this crate as its core."bool"rustc_doc_primitive" The boolean type."" The `bool` represents a value, which could only be either [`true`] or [`false`]. If you cast"" a `bool` into an integer, [`true`] will be 1 and [`false`] will be 0."" # Basic usage"" `bool` implements various traits, such as [`BitAnd`], [`BitOr`], [`Not`], etc.,"" which allow us to perform boolean operations using `&`, `|` and `!`."" [`if`] requires a `bool` value as its conditional. [`assert!`], which is an"" important macro in testing, checks whether an expression is [`true`] and panics"" if it isn\'t."" let bool_val = true & false | false;"" assert!(!bool_val);"" [`true`]: ../std/keyword.true.html"" [`false`]: ../std/keyword.false.html"" [`BitAnd`]: ops::BitAnd"" [`BitOr`]: ops::BitOr"" [`Not`]: ops::Not"" [`if`]: ../std/keyword.if.html"" A trivial example of the usage of `bool`:"" let praise_the_borrow_checker = true;"" // using the `if` conditional"" if praise_the_borrow_checker {""     println!(\"oh, yeah!\");"" } else {""     println!(\"what?!!\");"" // ... or, a match pattern"" match praise_the_borrow_checker {""     true => println!(\"keep praising!\"),""     false => println!(\"you should praise!\"),"" Also, since `bool` implements the [`Copy`] trait, we don\'t"" have to worry about the move semantics (just like the integer and float primitives)."" Now an example of `bool` cast to integer type:"" assert_eq!(true as i32, 1);"" assert_eq!(false as i32, 0);"prim_bool"never"" The `!` type, also called \"never\"."" `!` represents the type of computations which never resolve to any value at all. For example,"" the [`exit`] function `fn exit(code: i32) -> !` exits the process without ever returning, and"" so returns `!`."" `break`, `continue` and `return` expressions also have type `!`. For example we are allowed to"" write:"" #![feature(never_type)]"" # fn foo() -> u32 {"" let x: ! = {""     return 123"" Although the `let` is pointless here, it illustrates the meaning of `!`. Since `x` is never"" assigned a value (because `return` returns from the entire function), `x` can be given type"" `!`. We could also replace `return 123` with a `panic!` or a never-ending `loop` and this code"" would still be valid."" A more realistic usage of `!` is in this code:"" # fn get_a_number() -> Option<u32> { None }"" # loop {"" let num: u32 = match get_a_number() {""     Some(num) => num,""     None => break,"" Both match arms must produce values of type [`u32`], but since `break` never produces a value"" at all we know it can never produce a value which isn\'t a [`u32`]. This illustrates another"" behavior of the `!` type - expressions with type `!` will coerce into any other type."" [`u32`]: prim@u32"" [`exit`]: ../std/process/fn.exit.html"" # `!` and generics"" ## Infallible errors"" The main place you\'ll see `!` used explicitly is in generic code. Consider the [`FromStr`]"" trait:"" trait FromStr: Sized {""     type Err;""     fn from_str(s: &str) -> Result<Self, Self::Err>;"" When implementing this trait for [`String`] we need to pick a type for [`Err`]. And since"" converting a string into a string will never result in an error, the appropriate type is `!`."" (Currently the type actually used is an enum with no variants, though this is only because `!`"" was added to Rust at a later date and it may change in the future.) With an [`Err`] type of"" `!`, if we have to call [`String::from_str`] for some reason the result will be a"" [`Result<String, !>`] which we can unpack like this:"" use std::str::FromStr;"" let Ok(s) = String::from_str(\"hello\");"" Since the [`Err`] variant contains a `!`, it can never occur. This means we can exhaustively"" match on [`Result<T, !>`] by just taking the [`Ok`] variant. This illustrates another behavior"" of `!` - it can be used to \"delete\" certain enum variants from generic types like `Result`."" ## Infinite loops"" While [`Result<T, !>`] is very useful for removing errors, `!` can also be used to remove"" successes as well. If we think of [`Result<T, !>`] as \"if this function returns, it has not"" errored,\" we get a very intuitive idea of [`Result<!, E>`] as well: if the function returns, it"" *has* errored."" For example, consider the case of a simple web server, which can be simplified to:"" ```ignore (hypothetical-example)"" loop {""     let (client, request) = get_request().expect(\"disconnected\");""     let response = request.process();""     response.send(client);"" Currently, this isn\'t ideal, because we simply panic whenever we fail to get a new connection."" Instead, we\'d like to keep track of this error, like this:""     match get_request() {""         Err(err) => break err,""         Ok((client, request)) => {""             let response = request.process();""             response.send(client);""         },"" Now, when the server disconnects, we exit the loop with an error instead of panicking. While it"" might be intuitive to simply return the error, we might want to wrap it in a [`Result<!, E>`]"" instead:"" fn server_loop() -> Result<!, ConnectionError> {""     loop {""         let (client, request) = get_request()?;""         let response = request.process();""         response.send(client);"" Now, we can use `?` instead of `match`, and the return type makes a lot more sense: if the loop"" ever stops, it means that an error occurred. We don\'t even have to wrap the loop in an `Ok`"" because `!` coerces to `Result<!, ConnectionError>` automatically."" [`String::from_str`]: str::FromStr::from_str"" [`String`]: ../std/string/struct.String.html"" [`FromStr`]: str::FromStr"" # `!` and traits"" When writing your own traits, `!` should have an `impl` whenever there is an obvious `impl`"" which doesn\'t `panic!`. The reason is that functions returning an `impl Trait` where `!`"" does not have an `impl` of `Trait` cannot diverge as their only possible code path. In other"" words, they can\'t return `!` from every code path. As an example, this code doesn\'t compile:"" use std::ops::Add;"" fn foo() -> impl Add<u32> {""     unimplemented!()"" But this code does:""     if true {""         unimplemented!()""     } else {""         0"" The reason is that, in the first example, there are many possible types that `!` could coerce"" to, because many types implement `Add<u32>`. However, in the second example,"" the `else` branch returns a `0`, which the compiler infers from the return type to be of type"" `u32`. Since `u32` is a concrete type, `!` can and will be coerced to it. See issue [#36375]"" for more information on this quirk of `!`."" [#36375]: https://github.com/rust-lang/rust/issues/36375"" As it turns out, though, most traits can have an `impl` for `!`. Take [`Debug`]"" for example:"" # use std::fmt;"" # trait Debug {"" #     fn fmt(&self, formatter: &mut fmt::Formatter<\'_>) -> fmt::Result;"" impl Debug for ! {""     fn fmt(&self, formatter: &mut fmt::Formatter<\'_>) -> fmt::Result {""         *self"" Once again we\'re using `!`\'s ability to coerce into any other type, in this case"" [`fmt::Result`]. Since this method takes a `&!` as an argument we know that it can never be"" called (because there is no value of type `!` for it to be called with). Writing `*self`"" essentially tells the compiler \"We know that this code can never be run, so just treat the"" entire function body as having type [`fmt::Result`]\". This pattern can be used a lot when"" implementing traits for `!`. Generally, any trait which only has methods which take a `self`"" parameter should have such an impl."" On the other hand, one trait which would not be appropriate to implement is [`Default`]:"" trait Default {""     fn default() -> Self;"" Since `!` has no values, it has no default value either. It\'s true that we could write an"" `impl` for this which simply panics, but the same is true for any type (we could `impl"" Default` for (eg.) [`File`] by just making [`default()`] panic.)"" [`File`]: ../std/fs/struct.File.html"" [`Debug`]: fmt::Debug"" [`default()`]: Default::default"" # Never type fallback"" When the compiler sees a value of type `!` in a [coercion site], it implicitly inserts a"" coercion to allow the type checker to infer any type:"" ```rust,ignore (illustrative-and-has-placeholders)"" // this"" let x: u8 = panic!();"" // is (essentially) turned by the compiler into"" let x: u8 = absurd(panic!());"" // where absurd is a function with the following signature"" // (it\'s sound, because `!` always marks unreachable code):"" fn absurd<T>(_: !) -> T { ... }"" This can lead to compilation errors if the type cannot be inferred:"" { panic!() };"" // gets turned into this"" { absurd(panic!()) }; // error: can\'t infer the type of `absurd`"" To prevent such errors, the compiler remembers where it inserted `absurd` calls, and"" if it can\'t infer the type, it uses the fallback type instead:"" ```rust, ignore"" type Fallback = /* An arbitrarily selected type! */;"" { absurd::<Fallback>(panic!()) }"" This is what is known as \"never type fallback\"."" Historically, the fallback type was [`()`], causing confusing behavior where `!` spontaneously"" coerced to `()`, even when it would not infer `()` without the fallback. The fallback was changed"" to `!` in the [2024 edition], and will be changed in all editions at a later date."" [coercion site]: <https://doc.rust-lang.org/reference/type-coercions.html#coercion-sites>"" [`()`]: prim@unit"" [2024 edition]: <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>"prim_never"char"" A character type."" The `char` type represents a single character. More specifically, since"" \'character\' isn\'t a well-defined concept in Unicode, `char` is a \'[Unicode"" scalar value]\'."" This documentation describes a number of methods and trait implementations on the"" `char` type. For technical reasons, there is additional, separate"" documentation in [the `std::char` module](char/index.html) as well."" # Validity and Layout"" A `char` is a \'[Unicode scalar value]\', which is any \'[Unicode code point]\'"" other than a [surrogate code point]. This has a fixed numerical definition:"" code points are in the range 0 to 0x10FFFF, inclusive."" Surrogate code points, used by UTF-16, are in the range 0xD800 to 0xDFFF."" No `char` may be constructed, whether as a literal or at runtime, that is not a"" Unicode scalar value. Violating this rule causes undefined behavior."" // Each of these is a compiler error"" [\'\\u{D800}\', \'\\u{DFFF}\', \'\\u{110000}\'];"" // Panics; from_u32 returns None."" char::from_u32(0xDE01).unwrap();"" // Undefined behavior"" let _ = unsafe { char::from_u32_unchecked(0x110000) };"" Unicode scalar values are also the exact set of values that may be encoded in UTF-8. Because"" `char` values are Unicode scalar values and functions may assume [incoming `str` values are"" valid UTF-8](primitive.str.html#invariant), it is safe to store any `char` in a `str` or read"" any character from a `str` as a `char`."" The gap in valid `char` values is understood by the compiler, so in the"" below example the two ranges are understood to cover the whole range of"" possible `char` values and there is no error for a [non-exhaustive match]."" let c: char = \'a\';"" match c {""     \'\\0\' ..= \'\\u{D7FF}\' => false,""     \'\\u{E000}\' ..= \'\\u{10FFFF}\' => true,"" All Unicode scalar values are valid `char` values, but not all of them represent a real"" character. Many Unicode scalar values are not currently assigned to a character, but may be in"" the future (\"reserved\"); some will never be a character (\"noncharacters\"); and some may be given"" different meanings by different users (\"private use\")."" `char` is guaranteed to have the same size, alignment, and function call ABI as `u32` on all"" platforms."" use std::alloc::Layout;"" assert_eq!(Layout::new::<char>(), Layout::new::<u32>());"" [Unicode code point]: https://www.unicode.org/glossary/#code_point"" [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value"" [non-exhaustive match]: ../book/ch06-02-match.html#matches-are-exhaustive"" [surrogate code point]: https://www.unicode.org/glossary/#surrogate_code_point"" # Representation"" `char` is always four bytes in size. This is a different representation than"" a given character would have as part of a [`String`]. For example:"" let v = vec![\'h\', \'e\', \'l\', \'l\', \'o\'];"" // five elements times four bytes for each element"" assert_eq!(20, v.len() * size_of::<char>());"" let s = String::from(\"hello\");"" // five elements times one byte per element"" assert_eq!(5, s.len() * size_of::<u8>());"" As always, remember that a human intuition for \'character\' might not map to"" Unicode\'s definitions. For example, despite looking similar, the \'é\'"" character is one Unicode code point while \'é\' is two Unicode code points:"" let mut chars = \"é\".chars();"" // U+00e9: \'latin small letter e with acute\'"" assert_eq!(Some(\'\\u{00e9}\'), chars.next());"" assert_eq!(None, chars.next());"" let mut chars = \"é\".chars();"" // U+0065: \'latin small letter e\'"" assert_eq!(Some(\'\\u{0065}\'), chars.next());"" // U+0301: \'combining acute accent\'"" assert_eq!(Some(\'\\u{0301}\'), chars.next());"" This means that the contents of the first string above _will_ fit into a"" `char` while the contents of the second string _will not_. Trying to create"" a `char` literal with the contents of the second string gives an error:"" ```text"" error: character literal may only contain one codepoint: \'é\'"" let c = \'é\';""         ^^^"" Another implication of the 4-byte fixed size of a `char` is that"" per-`char` processing can end up using a lot more memory:"" let s = String::from(\"love: ❤️\");"" let v: Vec<char> = s.chars().collect();"" assert_eq!(12, size_of_val(&s[..]));"" assert_eq!(32, size_of_val(&v[..]));"prim_char"unit"" The `()` type, also called \"unit\"."" The `()` type has exactly one value `()`, and is used when there"" is no other meaningful value that could be returned. `()` is most"" commonly seen implicitly: functions without a `-> ...` implicitly"" have return type `()`, that is, these are equivalent:"" ```rust"" fn long() -> () {}"" fn short() {}"" The semicolon `;` can be used to discard the result of an"" expression at the end of a block, making the expression (and thus"" the block) evaluate to `()`. For example,"" fn returns_i64() -> i64 {""     1i64"" fn returns_unit() {""     1i64;"" let is_i64 = {""     returns_i64()"" let is_unit = {""     returns_i64();"prim_unit"pointer"" Raw, unsafe pointers, `*const T`, and `*mut T`."" *[See also the `std::ptr` module](ptr).*"" Working with raw pointers in Rust is uncommon, typically limited to a few patterns. Raw pointers"" can be out-of-bounds, unaligned, or [`null`]. However, when loading from or storing to a raw"" pointer, it must be [valid] for the given access and aligned. When using a field expression,"" tuple index expression, or array/slice index expression on a raw pointer, it follows the rules"" of [in-bounds pointer arithmetic][`offset`]."" Storing through a raw pointer using `*ptr = data` calls `drop` on the old value, so"" [`write`] must be used if the type has drop glue and memory is not already"" initialized - otherwise `drop` would be called on the uninitialized memory."" Use the [`null`] and [`null_mut`] functions to create null pointers, and the"" [`is_null`] method of the `*const T` and `*mut T` types to check for null."" The `*const T` and `*mut T` types also define the [`offset`] method, for"" pointer math."" # Common ways to create raw pointers"" ## 1. Coerce a reference (`&T`) or mutable reference (`&mut T`)."" let my_num: i32 = 10;"" let my_num_ptr: *const i32 = &my_num;"" let mut my_speed: i32 = 88;"" let my_speed_ptr: *mut i32 = &mut my_speed;"" To get a pointer to a boxed value, dereference the box:"" let my_num: Box<i32> = Box::new(10);"" let my_num_ptr: *const i32 = &*my_num;"" let mut my_speed: Box<i32> = Box::new(88);"" let my_speed_ptr: *mut i32 = &mut *my_speed;"" This does not take ownership of the original allocation"" and requires no resource management later,"" but you must not use the pointer after its lifetime."" ## 2. Consume a box (`Box<T>`)."" The [`into_raw`] function consumes a box and returns"" the raw pointer. It doesn\'t destroy `T` or deallocate any memory."" let my_speed: Box<i32> = Box::new(88);"" let my_speed: *mut i32 = Box::into_raw(my_speed);"" // By taking ownership of the original `Box<T>` though"" // we are obligated to put it together later to be destroyed."" unsafe {""     drop(Box::from_raw(my_speed));"" Note that here the call to [`drop`] is for clarity - it indicates"" that we are done with the given value and it should be destroyed."" ## 3. Create it using `&raw`"" Instead of coercing a reference to a raw pointer, you can use the raw borrow"" operators `&raw const` (for `*const T`) and `&raw mut` (for `*mut T`)."" These operators allow you to create raw pointers to fields to which you cannot"" create a reference (without causing undefined behavior), such as an"" unaligned field. This might be necessary if packed structs or uninitialized"" memory is involved."" #[derive(Debug, Default, Copy, Clone)]"" #[repr(C, packed)]"" struct S {""     aligned: u8,""     unaligned: u32,"" let s = S::default();"" let p = &raw const s.unaligned; // not allowed with coercion"" ## 4. Get it from C."" # mod libc {"" # pub unsafe fn malloc(_size: usize) -> *mut core::ffi::c_void { core::ptr::NonNull::dangling().as_ptr() }"" # pub unsafe fn free(_ptr: *mut core::ffi::c_void) {}"" # #[cfg(any())]"" #[allow(unused_extern_crates)]"" extern crate libc;""     let my_num: *mut i32 = libc::malloc(size_of::<i32>()) as *mut i32;""     if my_num.is_null() {""         panic!(\"failed to allocate memory\");""     libc::free(my_num as *mut core::ffi::c_void);"" Usually you wouldn\'t literally use `malloc` and `free` from Rust,"" but C APIs hand out a lot of pointers generally, so are a common source"" of raw pointers in Rust."" [`null`]: ptr::null"" [`null_mut`]: ptr::null_mut"" [`is_null`]: pointer::is_null"" [`offset`]: pointer::offset"" [`into_raw`]: ../std/boxed/struct.Box.html#method.into_raw"" [`write`]: ptr::write"" [valid]: ptr#safety"prim_pointer"array"" A fixed-size array, denoted `[T; N]`, for the element type, `T`, and the"" non-negative compile-time constant size, `N`."" There are two syntactic forms for creating an array:"" * A list with each element, i.e., `[x, y, z]`."" * A repeat expression `[expr; N]` where `N` is how many times to repeat `expr` in the array. `expr` must either be:""   * A value of a type implementing the [`Copy`] trait""   * A `const` value"" Note that `[expr; 0]` is allowed, and produces an empty array."" This will still evaluate `expr`, however, and immediately drop the resulting value, so"" be mindful of side effects."" Arrays of *any* size implement the following traits if the element type allows it:"" - [`Copy`]"" - [`Clone`]"" - [`Debug`]"" - [`IntoIterator`] (implemented for `[T; N]`, `&[T; N]` and `&mut [T; N]`)"" - [`PartialEq`], [`PartialOrd`], [`Eq`], [`Ord`]"" - [`Hash`]"" - [`AsRef`], [`AsMut`]"" - [`Borrow`], [`BorrowMut`]"" Arrays of sizes from 0 to 32 (inclusive) implement the [`Default`] trait"" if the element type allows it. As a stopgap, trait implementations are"" statically generated up to size 32."" Arrays of sizes from 1 to 12 (inclusive) implement [`From<Tuple>`], where `Tuple`"" is a homogeneous [prim@tuple] of appropriate length."" Arrays coerce to [slices (`[T]`)][slice], so a slice method may be called on"" an array. Indeed, this provides most of the API for working with arrays."" Slices have a dynamic size and do not coerce to arrays. Instead, use"" `slice.try_into().unwrap()` or `<ArrayType>::try_from(slice).unwrap()`."" Array\'s `try_from(slice)` implementations (and the corresponding `slice.try_into()`"" array implementations) succeed if the input slice length is the same as the result"" array length. They optimize especially well when the optimizer can easily determine"" the slice length, e.g. `<[u8; 4]>::try_from(&slice[4..8]).unwrap()`. Array implements"" [TryFrom](crate::convert::TryFrom) returning:"" - `[T; N]` copies from the slice\'s elements"" - `&[T; N]` references the original slice\'s elements"" - `&mut [T; N]` references the original slice\'s elements"" You can move elements out of an array with a [slice pattern]. If you want"" one element, see [`mem::replace`]."" let mut array: [i32; 3] = [0; 3];"" array[1] = 1;"" array[2] = 2;"" assert_eq!([1, 2], &array[1..]);"" // This loop prints: 0 1 2"" for x in array {""     print!(\"{x} \");"" You can also iterate over reference to the array\'s elements:"" let array: [i32; 3] = [0; 3];"" for x in &array { }"" You can use `<ArrayType>::try_from(slice)` or `slice.try_into()` to get an array from"" a slice:"" let bytes: [u8; 3] = [1, 0, 2];"" assert_eq!(1, u16::from_le_bytes(<[u8; 2]>::try_from(&bytes[0..2]).unwrap()));"" assert_eq!(512, u16::from_le_bytes(bytes[1..3].try_into().unwrap()));"" You can use a [slice pattern] to move elements out of an array:"" fn move_away(_: String) { /* Do interesting things. */ }"" let [john, roa] = [\"John\".to_string(), \"Roa\".to_string()];"" move_away(john);"" move_away(roa);"" Arrays can be created from homogeneous tuples of appropriate length:"" let tuple: (u32, u32, u32) = (1, 2, 3);"" let array: [u32; 3] = tuple.into();"" # Editions"" Prior to Rust 1.53, arrays did not implement [`IntoIterator`] by value, so the method call"" `array.into_iter()` auto-referenced into a [slice iterator](slice::iter). Right now, the old"" behavior is preserved in the 2015 and 2018 editions of Rust for compatibility, ignoring"" [`IntoIterator`] by value. In the future, the behavior on the 2015 and 2018 edition"" might be made consistent to the behavior of later editions."" ```rust,edition2018"" // Rust 2015 and 2018:"" # #![allow(array_into_iter)] // override our `deny(warnings)`"" // This creates a slice iterator, producing references to each value."" for item in array.into_iter().enumerate() {""     let (i, x): (usize, &i32) = item;""     println!(\"array[{i}] = {x}\");"" // The `array_into_iter` lint suggests this change for future compatibility:"" for item in array.iter().enumerate() {"" // You can explicitly iterate an array by value using `IntoIterator::into_iter`"" for item in IntoIterator::into_iter(array).enumerate() {""     let (i, x): (usize, i32) = item;"" Starting in the 2021 edition, `array.into_iter()` uses `IntoIterator` normally to iterate"" by value, and `iter()` should be used to iterate by reference like previous editions."" ```rust,edition2021"" // Rust 2021:"" // This iterates by reference:"" // This iterates by value:"" Future language versions might start treating the `array.into_iter()`"" syntax on editions 2015 and 2018 the same as on edition 2021. So code using"" those older editions should still be written with this change in mind, to"" prevent breakage in the future. The safest way to accomplish this is to"" avoid the `into_iter` syntax on those editions. If an edition update is not"" viable/desired, there are multiple alternatives:"" * use `iter`, equivalent to the old behavior, creating references"" * use [`IntoIterator::into_iter`], equivalent to the post-2021 behavior (Rust 1.53+)"" * replace `for ... in array.into_iter() {` with `for ... in array {`,""   equivalent to the post-2021 behavior (Rust 1.53+)"" for item in array.iter() {""     let x: &i32 = item;""     println!(\"{x}\");"" for item in IntoIterator::into_iter(array) {""     let x: i32 = item;"" for item in array {"" // IntoIter can also start a chain."" [slice]: prim@slice"" [`Hash`]: hash::Hash"" [`Borrow`]: borrow::Borrow"" [`BorrowMut`]: borrow::BorrowMut"" [slice pattern]: ../reference/patterns.html#slice-patterns"" [`From<Tuple>`]: convert::From"prim_array"slice"" A dynamically-sized view into a contiguous sequence, `[T]`."" Contiguous here means that elements are laid out so that every element is the same"" distance from its neighbors."" *[See also the `std::slice` module](crate::slice).*"" Slices are a view into a block of memory represented as a pointer and a"" // slicing a Vec"" let vec = vec![1, 2, 3];"" let int_slice = &vec[..];"" // coercing an array to a slice"" let str_slice: &[&str] = &[\"one\", \"two\", \"three\"];"" Slices are either mutable or shared. The shared slice type is `&[T]`,"" while the mutable slice type is `&mut [T]`, where `T` represents the element"" type. For example, you can mutate the block of memory that a mutable slice"" points to:"" let mut x = [1, 2, 3];"" let x = &mut x[..]; // Take a full slice of `x`."" x[1] = 7;"" assert_eq!(x, &[1, 7, 3]);"" It is possible to slice empty subranges of slices by using empty ranges (including `slice.len()..slice.len()`):"" let x = [1, 2, 3];"" let empty = &x[0..0];   // subslice before the first element"" assert_eq!(empty, &[]);"" let empty = &x[..0];    // same as &x[0..0]"" let empty = &x[1..1];   // empty subslice in the middle"" let empty = &x[3..3];   // subslice after the last element"" let empty = &x[3..];    // same as &x[3..3]"" It is not allowed to use subranges that start with lower bound bigger than `slice.len()`:"" let x = vec![1, 2, 3];"" let _ = &x[4..4];"" As slices store the length of the sequence they refer to, they have twice"" the size of pointers to [`Sized`](marker/trait.Sized.html) types."" Also see the reference on"" [dynamically sized types](../reference/dynamically-sized-types.html)."" let pointer_size = size_of::<&u8>();"" assert_eq!(2 * pointer_size, size_of::<&[u8]>());"" assert_eq!(2 * pointer_size, size_of::<*const [u8]>());"" assert_eq!(2 * pointer_size, size_of::<Box<[u8]>>());"" assert_eq!(2 * pointer_size, size_of::<Rc<[u8]>>());"" ## Trait Implementations"" Some traits are implemented for slices if the element type implements"" that trait. This includes [`Eq`], [`Hash`] and [`Ord`]."" ## Iteration"" The slices implement `IntoIterator`. The iterator yields references to the"" slice elements."" let numbers: &[i32] = &[0, 1, 2];"" for n in numbers {""     println!(\"{n} is a number!\");"" The mutable slice yields mutable references to the elements:"" let mut scores: &mut [i32] = &mut [7, 8, 9];"" for score in scores {""     *score += 1;"" This iterator yields mutable references to the slice\'s elements, so while"" the element type of the slice is `i32`, the element type of the iterator is"" `&mut i32`."" * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default""   iterators."" * Further methods that return iterators are [`.split`], [`.splitn`],""   [`.chunks`], [`.windows`] and more."" [`Hash`]: core::hash::Hash"" [`.iter`]: slice::iter"" [`.iter_mut`]: slice::iter_mut"" [`.split`]: slice::split"" [`.splitn`]: slice::splitn"" [`.chunks`]: slice::chunks"" [`.windows`]: slice::windows"prim_slice"str"" String slices."" *[See also the `std::str` module](crate::str).*"" The `str` type, also called a \'string slice\', is the most primitive string"" type. It is usually seen in its borrowed form, `&str`. It is also the type"" of string literals, `&\'static str`."" # Basic Usage"" String literals are string slices:"" let hello_world = \"Hello, World!\";"" Here we have declared a string slice initialized with a string literal."" String literals have a static lifetime, which means the string `hello_world`"" is guaranteed to be valid for the duration of the entire program."" We can explicitly specify `hello_world`\'s lifetime as well:"" let hello_world: &\'static str = \"Hello, world!\";"" A `&str` is made up of two components: a pointer to some bytes, and a"" length. You can look at these with the [`as_ptr`] and [`len`] methods:"" use std::slice;"" use std::str;"" let story = \"Once upon a time...\";"" let ptr = story.as_ptr();"" let len = story.len();"" // story has nineteen bytes"" assert_eq!(19, len);"" // We can re-build a str out of ptr and len. This is all unsafe because"" // we are responsible for making sure the two components are valid:"" let s = unsafe {""     // First, we build a &[u8]...""     let slice = slice::from_raw_parts(ptr, len);""     // ... and then convert that slice into a string slice""     str::from_utf8(slice)"" assert_eq!(s, Ok(story));"" [`as_ptr`]: str::as_ptr"" [`len`]: str::len"" Note: This example shows the internals of `&str`. `unsafe` should not be"" used to get a string slice under normal circumstances. Use `as_str`"" instead."" # Invariant"" Rust libraries may assume that string slices are always valid UTF-8."" Constructing a non-UTF-8 string slice is not immediate undefined behavior, but any function"" called on a string slice may assume that it is valid UTF-8, which means that a non-UTF-8 string"" slice can lead to undefined behavior down the road."prim_str"tuple"" A finite heterogeneous sequence, `(T, U, ..)`."" Let\'s cover each of those in turn:"" Tuples are *finite*. In other words, a tuple has a length. Here\'s a tuple"" of length `3`:"" (\"hello\", 5, \'c\');"" \'Length\' is also sometimes called \'arity\' here; each tuple of a different"" length is a different, distinct type."" Tuples are *heterogeneous*. This means that each element of the tuple can"" have a different type. In that tuple above, it has the type:"" # let _:"" (&\'static str, i32, char)"" # = (\"hello\", 5, \'c\');"" Tuples are a *sequence*. This means that they can be accessed by position;"" this is called \'tuple indexing\', and it looks like this:"" let tuple = (\"hello\", 5, \'c\');"" assert_eq!(tuple.0, \"hello\");"" assert_eq!(tuple.1, 5);"" assert_eq!(tuple.2, \'c\');"" The sequential nature of the tuple applies to its implementations of various"" traits. For example, in [`PartialOrd`] and [`Ord`], the elements are compared"" sequentially until the first non-equal set is found."" For more about tuples, see [the book](../book/ch03-02-data-types.html#the-tuple-type)."" # Trait implementations"" In this documentation the shorthand `(T₁, T₂, …, Tₙ)` is used to represent tuples of varying"" length. When that is used, any trait bound expressed on `T` applies to each element of the"" tuple independently. Note that this is a convenience notation to avoid repetitive"" documentation, not valid Rust syntax."" Due to a temporary restriction in Rust’s type system, the following traits are only"" implemented on tuples of arity 12 or less. In the future, this may change:"" * [`PartialEq`]"" * [`Eq`]"" * [`PartialOrd`]"" * [`Ord`]"" * [`Debug`]"" * [`Default`]"" * [`Hash`]"" * [`From<[T; N]>`][from]"" [from]: convert::From"" The following traits are implemented for tuples of any length. These traits have"" implementations that are automatically generated by the compiler, so are not limited by"" missing language features."" * [`Clone`]"" * [`Copy`]"" * [`Send`]"" * [`Sync`]"" * [`Unpin`]"" * [`UnwindSafe`]"" * [`RefUnwindSafe`]"" [`UnwindSafe`]: panic::UnwindSafe"" [`RefUnwindSafe`]: panic::RefUnwindSafe"" Basic usage:"" Tuples are often used as a return type when you want to return more than"" one value:"" fn calculate_point() -> (i32, i32) {""     // Don\'t do a calculation, that\'s not the point of the example""     (4, 5)"" let point = calculate_point();"" assert_eq!(point.0, 4);"" assert_eq!(point.1, 5);"" // Combining this with patterns can be nicer."" let (x, y) = calculate_point();"" assert_eq!(x, 4);"" assert_eq!(y, 5);"" Homogeneous tuples can be created from arrays of appropriate length:"" let array: [u32; 3] = [1, 2, 3];"" let tuple: (u32, u32, u32) = array.into();"prim_tuple"f16"" A 16-bit floating-point type (specifically, the \"binary16\" type defined in IEEE 754-2008)."" This type is very similar to [`prim@f32`] but has decreased precision because it uses half as many"" bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on half-precision"" values][wikipedia] for more information."" Note that most common platforms will not support `f16` in hardware without enabling extra target"" features, with the notable exception of Apple Silicon (also known as M1, M2, etc.) processors."" Hardware support on x86/x86-64 requires the avx512fp16 or avx10.1 features, while RISC-V requires"" Zfh, and Arm/AArch64 requires FEAT_FP16.  Usually the fallback implementation will be to use `f32`"" hardware if it exists, and convert between `f16` and `f32` when performing math."" *[See also the `std::f16::consts` module](crate::f16::consts).*"" [wikipedia]: https://en.wikipedia.org/wiki/Half-precision_floating-point_format"prim_f16"f32"" A 32-bit floating-point type (specifically, the \"binary32\" type defined in IEEE 754-2008)."" This type can represent a wide range of decimal numbers, like `3.5`, `27`,"" `-113.75`, `0.0078125`, `34359738368`, `0`, `-1`. So unlike integer types"" (such as `i32`), floating-point types can represent non-integer numbers,"" too."" However, being able to represent this wide range of numbers comes at the"" cost of precision: floats can only represent some of the real numbers and"" calculation with floats round to a nearby representable number. For example,"" `5.0` and `1.0` can be exactly represented as `f32`, but `1.0 / 5.0` results"" in `0.20000000298023223876953125` since `0.2` cannot be exactly represented"" as `f32`. Note, however, that printing floats with `println` and friends will"" often discard insignificant digits: `println!(\"{}\", 1.0f32 / 5.0f32)` will"" print `0.2`."" Additionally, `f32` can represent some special values:"" - −0.0: IEEE 754 floating-point numbers have a bit that indicates their sign, so −0.0 is a""   possible value. For comparison −0.0 = +0.0, but floating-point operations can carry""   the sign bit through arithmetic operations. This means −0.0 × +0.0 produces −0.0 and""   a negative number rounded to a value smaller than a float can represent also produces −0.0."" - [∞](#associatedconstant.INFINITY) and""   [−∞](#associatedconstant.NEG_INFINITY): these result from calculations""   like `1.0 / 0.0`."" - [NaN (not a number)](#associatedconstant.NAN): this value results from""   calculations like `(-1.0).sqrt()`. NaN has some potentially unexpected""   behavior:""   - It is not equal to any float, including itself! This is the reason `f32`""     doesn\'t implement the `Eq` trait.""   - It is also neither smaller nor greater than any float, making it""     impossible to sort by the default comparison operation, which is the""     reason `f32` doesn\'t implement the `Ord` trait.""   - It is also considered *infectious* as almost all calculations where one""     of the operands is NaN will also result in NaN. The explanations on this""     page only explicitly document behavior on NaN operands if this default""     is deviated from.""   - Lastly, there are multiple bit patterns that are considered NaN.""     Rust does not currently guarantee that the bit patterns of NaN are""     preserved over arithmetic operations, and they are not guaranteed to be""     portable or even fully deterministic! This means that there may be some""     surprising results upon inspecting the bit patterns,""     as the same calculations might produce NaNs with different bit patterns.""     This also affects the sign of the NaN: checking `is_sign_positive` or `is_sign_negative` on""     a NaN is the most common way to run into these surprising results.""     (Checking `x >= 0.0` or `x <= 0.0` avoids those surprises, but also how negative/positive""     zero are treated.)""     See the section below for what exactly is guaranteed about the bit pattern of a NaN."" When a primitive operation (addition, subtraction, multiplication, or"" division) is performed on this type, the result is rounded according to the"" roundTiesToEven direction defined in IEEE 754-2008. That means:"" - The result is the representable value closest to the true value, if there""   is a unique closest representable value."" - If the true value is exactly half-way between two representable values,""   the result is the one with an even least-significant binary digit."" - If the true value\'s magnitude is ≥ `f32::MAX` + 2<sup>(`f32::MAX_EXP` −""   `f32::MANTISSA_DIGITS` − 1)</sup>, the result is ∞ or −∞ (preserving the""   true value\'s sign)."" - If the result of a sum exactly equals zero, the outcome is +0.0 unless""   both arguments were negative, then it is -0.0. Subtraction `a - b` is""   regarded as a sum `a + (-b)`."" For more information on floating-point numbers, see [Wikipedia][wikipedia]."" *[See also the `std::f32::consts` module](crate::f32::consts).*"" [wikipedia]: https://en.wikipedia.org/wiki/Single-precision_floating-point_format"" # NaN bit patterns"" This section defines the possible NaN bit patterns returned by floating-point operations."" The bit pattern of a floating-point NaN value is defined by:"" - a sign bit."" - a quiet/signaling bit. Rust assumes that the quiet/signaling bit being set to `1` indicates a""   quiet NaN (QNaN), and a value of `0` indicates a signaling NaN (SNaN). In the following we""   will hence just call it the \"quiet bit\"."" - a payload, which makes up the rest of the significand (i.e., the mantissa) except for the""   quiet bit."" The rules for NaN values differ between *arithmetic* and *non-arithmetic* (or \"bitwise\")"" operations. The non-arithmetic operations are unary `-`, `abs`, `copysign`, `signum`,"" `{to,from}_bits`, `{to,from}_{be,le,ne}_bytes` and `is_sign_{positive,negative}`. These"" operations are guaranteed to exactly preserve the bit pattern of their input except for possibly"" changing the sign bit."" The following rules apply when a NaN value is returned from an arithmetic operation:"" - The result has a non-deterministic sign."" - The quiet bit and payload are non-deterministically chosen from""   the following set of options:""   - **Preferred NaN**: The quiet bit is set and the payload is all-zero.""   - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input""     operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for""     `as` casts), then""     - If the output is smaller than the input, low-order bits of the payload get dropped.""     - If the output is larger than the input, the payload gets filled up with 0s in the low-order""       bits.""   - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand""     that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the""     same rules as for \"quieting NaN propagation\" apply, with one caveat: if the output is smaller""     than the input, dropping the low-order bits may result in a payload of 0; a payload of 0 is not""     possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN""     propagation cannot occur with some inputs.""   - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific""     set of \"extra\" possible NaN payloads. The set can depend on the input operand values.""     See the table below for the concrete NaNs this set contains on various targets."" In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN"" is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input"" value. Similarly, if all input NaNs are preferred (or if there are no input NaNs) and the target"" does not have any \"extra\" NaN payloads, then the output NaN is guaranteed to be preferred."" The non-deterministic choice happens when the operation is executed; i.e., the result of a"" NaN-producing floating-point operation is a stable bit pattern (looking at these bits multiple"" times will yield consistent results), but running the same operation twice with the same inputs"" can produce different results."" These guarantees are neither stronger nor weaker than those of IEEE 754: IEEE 754 guarantees"" that an operation never returns a signaling NaN, whereas it is possible for operations like"" `SNAN * 1.0` to return a signaling NaN in Rust. Conversely, IEEE 754 makes no statement at all"" about which quiet NaN is returned, whereas Rust restricts the set of possible results to the"" ones listed above."" Unless noted otherwise, the same rules also apply to NaNs returned by other library functions"" (e.g. `min`, `minimum`, `max`, `maximum`); other aspects of their semantics and which IEEE 754"" operation they correspond to are documented with the respective functions."" When an arithmetic floating-point operation is executed in `const` context, the same rules"" apply: no guarantee is made about which of the NaN bit patterns described above will be"" returned. The result does not have to match what happens when executing the same code at"" runtime, and the result can vary depending on factors such as compiler version and flags."" ### Target-specific \"extra\" NaN values"" | `target_arch` | Extra payloads possible on this platform |"" |---------------|------------------------------------------|"" | `aarch64`, `arm`, `arm64ec`, `loongarch64`, `powerpc` (except when `target_abi = \"spe\"`), `powerpc64`, `riscv32`, `riscv64`, `s390x`, `x86`, `x86_64` | None |"" | `nvptx64` | All payloads |"" | `sparc`, `sparc64` | The all-one payload |"" | `wasm32`, `wasm64` | If all input NaNs are quiet with all-zero payload: None.<br> Otherwise: all payloads. |"" For targets not in this table, all payloads are possible."" # Algebraic operators"" Algebraic operators of the form `a.algebraic_*(b)` allow the compiler to optimize"" floating point operations using all the usual algebraic properties of real numbers --"" despite the fact that those properties do *not* hold on floating point numbers."" This can give a great performance boost since it may unlock vectorization."" The exact set of optimizations is unspecified but typically allows combining operations,"" rearranging series of operations based on mathematical properties, converting between division"" and reciprocal multiplication, and disregarding the sign of zero. This means that the results of"" elementary operations may have undefined precision, and \"non-mathematical\" values"" such as NaN, +/-Inf, or -0.0 may behave in unexpected ways, but these operations"" will never cause undefined behavior."" Because of the unpredictable nature of compiler optimizations, the same inputs may produce"" different results even within a single program run. **Unsafe code must not rely on any property"" of the return value for soundness.** However, implementations will generally do their best to"" pick a reasonable tradeoff between performance and accuracy of the result."" For example:"" # #![feature(float_algebraic)]"" # #![allow(unused_assignments)]"" # let mut x: f32 = 0.0;"" # let a: f32 = 1.0;"" # let b: f32 = 2.0;"" # let c: f32 = 3.0;"" # let d: f32 = 4.0;"" x = a.algebraic_add(b).algebraic_add(c).algebraic_add(d);"" May be rewritten as:"" x = a + b + c + d; // As written"" x = (a + c) + (b + d); // Reordered to shorten critical path and enable vectorization"prim_f32"f64"" A 64-bit floating-point type (specifically, the \"binary64\" type defined in IEEE 754-2008)."" This type is very similar to [`prim@f32`], but has increased precision by using twice as many"" bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on double-precision"" *[See also the `std::f64::consts` module](crate::f64::consts).*"" [wikipedia]: https://en.wikipedia.org/wiki/Double-precision_floating-point_format"prim_f64"f128"" A 128-bit floating-point type (specifically, the \"binary128\" type defined in IEEE 754-2008)."" This type is very similar to [`prim@f32`] and [`prim@f64`], but has increased precision by using twice"" as many bits as `f64`. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on"" quad-precision values][wikipedia] for more information."" Note that no platforms have hardware support for `f128` without enabling target specific features,"" as for all instruction set architectures `f128` is considered an optional feature.  Only Power ISA"" (\"PowerPC\") and RISC-V (via the Q extension) specify it, and only certain microarchitectures"" actually implement it. For x86-64 and AArch64, ISA support is not even specified, so it will always"" be a software implementation significantly slower than `f64`."" _Note: `f128` support is incomplete. Many platforms will not be able to link math functions. On"" x86 in particular, these functions do link but their results are always incorrect._"" *[See also the `std::f128::consts` module](crate::f128::consts).*"" [wikipedia]: https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format"prim_f128"i8"" The 8-bit signed integer type."prim_i8"i16"" The 16-bit signed integer type."prim_i16"i32"" The 32-bit signed integer type."prim_i32"i64"" The 64-bit signed integer type."prim_i64"i128"" The 128-bit signed integer type."" # ABI compatibility"" Rust\'s `i128` is expected to be ABI-compatible with C\'s `__int128` on platforms where the type"" is available, which includes most 64-bit architectures. If any platforms that do not specify"" `__int128` are updated to introduce it, the Rust `i128` ABI on relevant targets will be changed"" to match."" It is important to note that in C, `__int128` is _not_ the same as `_BitInt(128)`, and the two"" types are allowed to have different ABIs. In particular, on x86, `__int128` and `_BitInt(128)`"" do not use the same alignment. `i128` is intended to always match `__int128` and does not"" attempt to match `_BitInt(128)` on platforms without `__int128`."prim_i128"u8"" The 8-bit unsigned integer type."prim_u8"u16"" The 16-bit unsigned integer type."prim_u16"u32"" The 32-bit unsigned integer type."prim_u32"u64"" The 64-bit unsigned integer type."prim_u64"u128"" The 128-bit unsigned integer type."" Please see [the documentation for `i128`](prim@i128) for information on ABI compatibility."prim_u128"isize"" The pointer-sized signed integer type."" The size of this primitive is how many bytes it takes to reference any"" location in memory. For example, on a 32 bit target, this is 4 bytes"" and on a 64 bit target, this is 8 bytes."prim_isize"usize"" The pointer-sized unsigned integer type."prim_usize"reference"" References, `&T` and `&mut T`."" A reference represents a borrow of some owned value. You can get one by using the `&` or `&mut`"" operators on a value, or by using a [`ref`](../std/keyword.ref.html) or"" <code>[ref](../std/keyword.ref.html) [mut](../std/keyword.mut.html)</code> pattern."" For those familiar with pointers, a reference is just a pointer that is assumed to be"" aligned, not null, and pointing to memory containing a valid value of `T` - for example,"" <code>&[bool]</code> can only point to an allocation containing the integer values `1`"" ([`true`](../std/keyword.true.html)) or `0` ([`false`](../std/keyword.false.html)), but"" creating a <code>&[bool]</code> that points to an allocation containing"" the value `3` causes undefined behavior."" In fact, <code>[Option]\\<&T></code> has the same memory representation as a"" nullable but aligned pointer, and can be passed across FFI boundaries as such."" In most cases, references can be used much like the original value. Field access, method"" calling, and indexing work the same (save for mutability rules, of course). In addition, the"" comparison operators transparently defer to the referent\'s implementation, allowing references"" to be compared the same as owned values."" References have a lifetime attached to them, which represents the scope for which the borrow is"" valid. A lifetime is said to \"outlive\" another one if its representative scope is as long or"" longer than the other. The `\'static` lifetime is the longest lifetime, which represents the"" total life of the program. For example, string literals have a `\'static` lifetime because the"" text data is embedded into the binary of the program, rather than in an allocation that needs"" to be dynamically managed."" `&mut T` references can be freely coerced into `&T` references with the same referent type, and"" references with longer lifetimes can be freely coerced into references with shorter ones."" [`PartialEq`] will compare referenced values. It is possible to compare the reference address"" using reference-pointer coercion and raw pointer equality via [`ptr::eq`]."" use std::ptr;"" let five = 5;"" let other_five = 5;"" let five_ref = &five;"" let same_five_ref = &five;"" let other_five_ref = &other_five;"" assert!(five_ref == same_five_ref);"" assert!(five_ref == other_five_ref);"" assert!(ptr::eq(five_ref, same_five_ref));"" assert!(!ptr::eq(five_ref, other_five_ref));"" For more information on how to use references, see [the book\'s section on \"References and"" Borrowing\"][book-refs]."" [book-refs]: ../book/ch04-02-references-and-borrowing.html"" The following traits are implemented for all `&T`, regardless of the type of its referent:"" * [`Clone`] \\(Note that this will not defer to `T`\'s `Clone` implementation if it exists!)"" * [`Deref`]"" * [`Borrow`]"" * [`fmt::Pointer`]"" [`Deref`]: ops::Deref"" `&mut T` references get all of the above except `Copy` and `Clone` (to prevent creating"" multiple simultaneous mutable borrows), plus the following, regardless of the type of its"" referent:"" * [`DerefMut`]"" * [`BorrowMut`]"" [`DerefMut`]: ops::DerefMut"" [bool]: prim@bool"" The following traits are implemented on `&T` references if the underlying `T` also implements"" that trait:"" * All the traits in [`std::fmt`] except [`fmt::Pointer`] (which is implemented regardless of the type of its referent) and [`fmt::Write`]"" * [`AsRef`]"" * [`Fn`] \\(in addition, `&T` references get [`FnMut`] and [`FnOnce`] if `T: Fn`)"" * [`ToSocketAddrs`]"" [`std::fmt`]: fmt"" [`ToSocketAddrs`]: ../std/net/trait.ToSocketAddrs.html"" `&mut T` references get all of the above except `ToSocketAddrs`, plus the following, if `T`"" implements that trait:"" * [`AsMut`]"" * [`FnMut`] \\(in addition, `&mut T` references get [`FnOnce`] if `T: FnMut`)"" * [`fmt::Write`]"" * [`Iterator`]"" * [`DoubleEndedIterator`]"" * [`ExactSizeIterator`]"" * [`FusedIterator`]"" * [`TrustedLen`]"" * [`io::Write`]"" * [`Read`]"" * [`Seek`]"" * [`BufRead`]"" [`FusedIterator`]: iter::FusedIterator"" [`TrustedLen`]: iter::TrustedLen"" [`Seek`]: ../std/io/trait.Seek.html"" [`BufRead`]: ../std/io/trait.BufRead.html"" [`Read`]: ../std/io/trait.Read.html"" [`io::Write`]: ../std/io/trait.Write.html"" In addition, `&T` references implement [`Send`] if and only if `T` implements [`Sync`]."" Note that due to method call deref coercion, simply calling a trait method will act like they"" work on references as well as they do on owned values! The implementations described here are"" meant for generic contexts, where the final type `T` is a type parameter or otherwise not"" locally known."" For all types, `T: ?Sized`, and for all `t: &T` or `t: &mut T`, when such values cross an API"" boundary, the following invariants must generally be upheld:"" * `t` is non-null"" * `t` is aligned to `align_of_val(t)`"" * if `size_of_val(t) > 0`, then `t` is dereferenceable for `size_of_val(t)` many bytes"" If `t` points at address `a`, being \"dereferenceable\" for N bytes means that the memory range"" `[a, a + N)` is all contained within a single [allocation]."" For instance, this means that unsafe code in a safe function may assume these invariants are"" ensured of arguments passed by the caller, and it may assume that these invariants are ensured"" of return values from any safe functions it calls."" For the other direction, things are more complicated: when unsafe code passes arguments"" to safe functions or returns values from safe functions, they generally must *at least*"" not violate these invariants. The full requirements are stronger, as the reference generally"" must point to data that is safe to use as type `T`."" It is not decided yet whether unsafe code may violate these invariants temporarily on internal"" data. As a consequence, unsafe code which violates these invariants temporarily on internal data"" may be unsound or become unsound in future versions of Rust depending on how this question is"" decided."" [allocation]: ptr#allocation"prim_ref"fn"" Function pointers, like `fn(usize) -> bool`."" *See also the traits [`Fn`], [`FnMut`], and [`FnOnce`].*"" Function pointers are pointers that point to *code*, not data. They can be called"" just like functions. Like references, function pointers are, among other things, assumed to"" not be null, so if you want to pass a function pointer over FFI and be able to accommodate null"" pointers, make your type [`Option<fn()>`](core::option#options-and-pointers-nullable-pointers)"" with your required signature."" Note that FFI requires additional care to ensure that the ABI for both sides of the call match."" The exact requirements are not currently documented."" ### Safety"" Plain function pointers are obtained by casting either plain functions, or closures that don\'t"" capture an environment:"" fn add_one(x: usize) -> usize {""     x + 1"" let ptr: fn(usize) -> usize = add_one;"" assert_eq!(ptr(5), 6);"" let clos: fn(usize) -> usize = |x| x + 5;"" assert_eq!(clos(5), 10);"" In addition to varying based on their signature, function pointers come in two flavors: safe"" and unsafe. Plain `fn()` function pointers can only point to safe functions,"" while `unsafe fn()` function pointers can point to safe or unsafe functions."" unsafe fn add_one_unsafely(x: usize) -> usize {"" let safe_ptr: fn(usize) -> usize = add_one;"" //ERROR: mismatched types: expected normal fn, found unsafe fn"" //let bad_ptr: fn(usize) -> usize = add_one_unsafely;"" let unsafe_ptr: unsafe fn(usize) -> usize = add_one_unsafely;"" let really_safe_ptr: unsafe fn(usize) -> usize = add_one;"" ### ABI"" On top of that, function pointers can vary based on what ABI they use. This"" is achieved by adding the `extern` keyword before the type, followed by the"" ABI in question. The default ABI is \"Rust\", i.e., `fn()` is the exact same"" type as `extern \"Rust\" fn()`. A pointer to a function with C ABI would have"" type `extern \"C\" fn()`."" `extern \"ABI\" { ... }` blocks declare functions with ABI \"ABI\". The default"" here is \"C\", i.e., functions declared in an `extern {...}` block have \"C\""" ABI."" For more information and a list of supported ABIs, see [the nomicon\'s"" section on foreign calling conventions][nomicon-abi]."" [nomicon-abi]: ../nomicon/ffi.html#foreign-calling-conventions"" ### Variadic functions"" Extern function declarations with the \"C\" or \"cdecl\" ABIs can also be *variadic*, allowing them"" to be called with a variable number of arguments. Normal Rust functions, even those with an"" `extern \"ABI\"`, cannot be variadic. For more information, see [the nomicon\'s section on"" variadic functions][nomicon-variadic]."" [nomicon-variadic]: ../nomicon/ffi.html#variadic-functions"" ### Creating function pointers"" When `bar` is the name of a function, then the expression `bar` is *not* a"" function pointer. Rather, it denotes a value of an unnameable type that"" uniquely identifies the function `bar`. The value is zero-sized because the"" type already identifies the function. This has the advantage that \"calling\""" the value (it implements the `Fn*` traits) does not require dynamic"" dispatch."" This zero-sized type *coerces* to a regular function pointer. For example:"" fn bar(x: i32) {}"" let not_bar_ptr = bar; // `not_bar_ptr` is zero-sized, uniquely identifying `bar`"" assert_eq!(size_of_val(&not_bar_ptr), 0);"" let bar_ptr: fn(i32) = not_bar_ptr; // force coercion to function pointer"" assert_eq!(size_of_val(&bar_ptr), size_of::<usize>());"" let footgun = &bar; // this is a shared reference to the zero-sized type identifying `bar`"" The last line shows that `&bar` is not a function pointer either. Rather, it"" is a reference to the function-specific ZST. `&bar` is basically never what you"" want when `bar` is a function."" ### Casting to and from integers"" You can cast function pointers directly to integers:"" let fnptr: fn(i32) -> i32 = |x| x+2;"" let fnptr_addr = fnptr as usize;"" However, a direct cast back is not possible. You need to use `transmute`:"" # #[cfg(not(miri))] { // FIXME: use strict provenance APIs once they are stable, then remove this `cfg`"" # let fnptr: fn(i32) -> i32 = |x| x+2;"" # let fnptr_addr = fnptr as usize;"" let fnptr = fnptr_addr as *const ();"" let fnptr: fn(i32) -> i32 = unsafe { std::mem::transmute(fnptr) };"" assert_eq!(fnptr(40), 42);"" Crucially, we `as`-cast to a raw pointer before `transmute`ing to a function pointer."" This avoids an integer-to-pointer `transmute`, which can be problematic."" Transmuting between raw pointers and function pointers (i.e., two pointer types) is fine."" Note that all of this is not portable to platforms where function pointers and data pointers"" have different sizes."" ### ABI compatibility"" Generally, when a function is declared with one signature and called via a function pointer with"" a different signature, the two signatures must be *ABI-compatible* or else calling the function"" via that function pointer is Undefined Behavior. ABI compatibility is a lot stricter than merely"" having the same memory layout; for example, even if `i32` and `f32` have the same size and"" alignment, they might be passed in different registers and hence not be ABI-compatible."" ABI compatibility as a concern only arises in code that alters the type of function pointers,"" and code that imports functions via `extern` blocks. Altering the type of function pointers is"" wildly unsafe (as in, a lot more unsafe than even [`transmute_copy`][mem::transmute_copy]), and"" should only occur in the most exceptional circumstances. Most Rust code just imports functions"" via `use`. So, most likely you do not have to worry about ABI compatibility."" But assuming such circumstances, what are the rules? For this section, we are only considering"" the ABI of direct Rust-to-Rust calls (with both definition and callsite visible to the"" Rust compiler), not linking in general -- once functions are imported via `extern` blocks, there"" are more things to consider that we do not go into here. Note that this also applies to"" passing/calling functions across language boundaries via function pointers."" **Nothing in this section should be taken as a guarantee for non-Rust-to-Rust calls, even with"" types from `core::ffi` or `libc`**."" For two signatures to be considered *ABI-compatible*, they must use a compatible ABI string,"" must take the same number of arguments, and the individual argument types and the return types"" must be ABI-compatible. The ABI string is declared via `extern \"ABI\" fn(...) -> ...`; note that"" `fn name(...) -> ...` implicitly uses the `\"Rust\"` ABI string and `extern fn name(...) -> ...`"" implicitly uses the `\"C\"` ABI string."" The ABI strings are guaranteed to be compatible if they are the same, or if the caller ABI"" string is `$X-unwind` and the callee ABI string is `$X`, where `$X` is one of the following:"" \"C\", \"aapcs\", \"fastcall\", \"stdcall\", \"system\", \"sysv64\", \"thiscall\", \"vectorcall\", \"win64\"."" The following types are guaranteed to be ABI-compatible:"" - `*const T`, `*mut T`, `&T`, `&mut T`, `Box<T>` (specifically, only `Box<T, Global>`), and""   `NonNull<T>` are all ABI-compatible with each other for all `T`. They are also ABI-compatible""   with each other for _different_ `T` if they have the same metadata type (`<T as""   Pointee>::Metadata`)."" - `usize` is ABI-compatible with the `uN` integer type of the same size, and likewise `isize` is""   ABI-compatible with the `iN` integer type of the same size."" - `char` is ABI-compatible with `u32`."" - Any two `fn` (function pointer) types are ABI-compatible with each other if they have the same""   ABI string or the ABI string only differs in a trailing `-unwind`, independent of the rest of""   their signature. (This means you can pass `fn()` to a function expecting `fn(i32)`, and the""   call will be valid ABI-wise. The callee receives the result of transmuting the function pointer""   from `fn()` to `fn(i32)`; that transmutation is itself a well-defined operation, it\'s just""   almost certainly UB to later call that function pointer.)"" - Any two types with size 0 and alignment 1 are ABI-compatible."" - A `repr(transparent)` type `T` is ABI-compatible with its unique non-trivial field, i.e., the""   unique field that doesn\'t have size 0 and alignment 1 (if there is such a field)."" - `i32` is ABI-compatible with `NonZero<i32>`, and similar for all other integer types."" - If `T` is guaranteed to be subject to the [null pointer""   optimization](option/index.html#representation), and `E` is an enum satisfying the following""   requirements, then `T` and `E` are ABI-compatible. Such an enum `E` is called \"option-like\".""   - The enum `E` uses the [`Rust` representation], and is not modified by the `align` or""     `packed` representation modifiers.""   - The enum `E` has exactly two variants.""   - One variant has exactly one field, of type `T`.""   - All fields of the other variant are zero-sized with 1-byte alignment."" Furthermore, ABI compatibility satisfies the following general properties:"" - Every type is ABI-compatible with itself."" - If `T1` and `T2` are ABI-compatible and `T2` and `T3` are ABI-compatible, then so are `T1` and""   `T3` (i.e., ABI-compatibility is transitive)."" - If `T1` and `T2` are ABI-compatible, then so are `T2` and `T1` (i.e., ABI-compatibility is""   symmetric)."" More signatures can be ABI-compatible on specific targets, but that should not be relied upon"" since it is not portable and not a stable guarantee."" Noteworthy cases of types *not* being ABI-compatible in general are:"" * `bool` vs `u8`, `i32` vs `u32`, `char` vs `i32`: on some targets, the calling conventions for""   these types differ in terms of what they guarantee for the remaining bits in the register that""   are not used by the value."" * `i32` vs `f32` are not compatible either, as has already been mentioned above."" * `struct Foo(u32)` and `u32` are not compatible (without `repr(transparent)`) since structs are""   aggregate types and often passed in a different way than primitives like `i32`."" Note that these rules describe when two completely known types are ABI-compatible. When"" considering ABI compatibility of a type declared in another crate (including the standard"" library), consider that any type that has a private field or the `#[non_exhaustive]` attribute"" may change its layout as a non-breaking update unless documented otherwise -- so for instance,"" even if such a type is a 1-ZST or `repr(transparent)` right now, this might change with any"" library version bump."" If the declared signature and the signature of the function pointer are ABI-compatible, then the"" function call behaves as if every argument was [`transmute`d][mem::transmute] from the"" type in the function pointer to the type at the function declaration, and the return value is"" [`transmute`d][mem::transmute] from the type in the declaration to the type in the"" pointer. All the usual caveats and concerns around transmutation apply; for instance, if the"" function expects a `NonZero<i32>` and the function pointer uses the ABI-compatible type"" `Option<NonZero<i32>>`, and the value used for the argument is `None`, then this call is Undefined"" Behavior since transmuting `None::<NonZero<i32>>` to `NonZero<i32>` violates the non-zero"" requirement."" ### Trait implementations"" In this documentation the shorthand `fn(T₁, T₂, …, Tₙ)` is used to represent non-variadic"" function pointers of varying length. Note that this is a convenience notation to avoid"" repetitive documentation, not valid Rust syntax."" The following traits are implemented for function pointers with any number of arguments and"" any ABI."" * [`Pointer`]"" Note that while this type implements `PartialEq`, comparing function pointers is unreliable:"" pointers to the same function can compare inequal (because functions are duplicated in multiple"" codegen units), and pointers to *different* functions can compare equal (since identical"" functions can be deduplicated within a codegen unit)."" [`Pointer`]: fmt::Pointer"" [`Rust` representation]: <https://doc.rust-lang.org/reference/type-layout.html#the-rust-representation>"" In addition, all *safe* function pointers implement [`Fn`], [`FnMut`], and [`FnOnce`], because"" these traits are specially known to the compiler."prim_fn//! # The Rust Core Library//! The Rust Core Library is the dependency-free[^free] foundation of [The//! Rust Standard Library](../std/index.html). It is the portable glue//! between the language and its libraries, defining the intrinsic and//! primitive building blocks of all Rust code. It links to no//! upstream libraries, no system libraries, and no libc.//! [^free]: Strictly speaking, there are some symbols which are needed but//!          they aren't always necessary.//! The core library is *minimal*: it isn't even aware of heap allocation,//! nor does it provide concurrency or I/O. These things require//! platform integration, and this library is platform-agnostic.//! # How to use the core library//! Please note that all of these details are currently not considered stable.// FIXME: Fill me in with more detail when the interface settles//! This library is built on the assumption of a few existing symbols://! * `memcpy`, `memmove`, `memset`, `memcmp`, `bcmp`, `strlen` - These are core memory routines//!   which are generated by Rust codegen backends. Additionally, this library can make explicit//!   calls to `strlen`. Their signatures are the same as found in C, but there are extra//!   assumptions about their semantics: For `memcpy`, `memmove`, `memset`, `memcmp`, and `bcmp`, if//!   the `n` parameter is 0, the function is assumed to not be UB, even if the pointers are NULL or//!   dangling. (Note that making extra assumptions about these functions is common among compilers://!   [clang](https://reviews.llvm.org/D86993) and [GCC](https://gcc.gnu.org/onlinedocs/gcc/Standards.html#C-Language) do the same.)//!   These functions are often provided by the system libc, but can also be provided by the//!   [compiler-builtins crate](https://crates.io/crates/compiler_builtins).//!   Note that the library does not guarantee that it will always make these assumptions, so Rust//!   user code directly calling the C functions should follow the C specification! The advice for//!   Rust user code is to call the functions provided by this library instead (such as//!   `ptr::copy`).//! * Panic handler - This function takes one argument, a `&panic::PanicInfo`. It is up to consumers of this core//!   library to define this panic function; it is only required to never//!   return. You should mark your implementation using `#[panic_handler]`.//! * `rust_eh_personality` - is used by the failure mechanisms of the//!   compiler. This is often mapped to GCC's personality function, but crates//!   which do not trigger a panic can be assured that this function is never//!   called. The `lang` attribute is called `eh_personality`.// Do not check link redundancy on bootstrapping phase// Target features:/* Core modules for ownership management *//* Core language traits *//* Core types and methods on primitives */"core_panic_macro"// Expands to either `$crate::panic::panic_2015` or `$crate::panic::panic_2021`// depending on the edition of the caller."assert_eq_macro"/// Asserts that two expressions are equal to each other (using [`PartialEq`])./// Assertions are always checked in both debug and release builds, and cannot/// be disabled. See [`debug_assert_eq!`] for assertions that are disabled in/// release builds by default./// [`debug_assert_eq!`]: crate::debug_assert_eq/// Like [`assert!`], this macro has a second form, where a custom/// panic message can be provided./// let a = 3;/// let b = 1 + 2;/// assert_eq!(a, b, "we are testing addition with {} and {}", a, b);"assert_ne_macro"/// Asserts that two expressions are not equal to each other (using [`PartialEq`])./// be disabled. See [`debug_assert_ne!`] for assertions that are disabled in/// [`debug_assert_ne!`]: crate::debug_assert_ne/// let b = 2;/// assert_ne!(a, b);/// assert_ne!(a, b, "we are testing that the values are not equal");"semitransparent"/// Asserts that an expression matches the provided pattern./// This macro is generally preferable to `assert!(matches!(value, pattern))`, because it can print/// the debug representation of the actual value shape that did not meet expectations. In contrast,/// using [`assert!`] will only print that expectations were not met, but not why./// The pattern syntax is exactly the same as found in a match arm and the `matches!` macro. The/// optional if guard can be used to add additional checks that must be true for the matched value,/// otherwise this macro will panic./// be disabled. See [`debug_assert_matches!`] for assertions that are disabled in/// [`debug_assert_matches!`]: crate::assert_matches::debug_assert_matches/// On panic, this macro will print the value of the expression with its debug representation./// Like [`assert!`], this macro has a second form, where a custom panic message can be provided./// #![feature(assert_matches)]/// use std::assert_matches::assert_matches;/// let a = Some(345);/// let b = Some(56);/// assert_matches!(a, Some(_));/// assert_matches!(b, Some(_));/// assert_matches!(a, Some(345));/// assert_matches!(a, Some(345) | None);/// // assert_matches!(a, None); // panics/// // assert_matches!(b, Some(345)); // panics/// // assert_matches!(b, Some(345) | None); // panics/// assert_matches!(a, Some(x) if x > 100);/// // assert_matches!(a, Some(x) if x < 100); // panics"cfg_select"/// Selects code at compile-time based on `cfg` predicates./// This macro evaluates, at compile-time, a series of `cfg` predicates,/// selects the first that is true, and emits the code guarded by that/// predicate. The code guarded by other predicates is not emitted./// An optional trailing `_` wildcard can be used to specify a fallback. If/// none of the predicates are true, a [`compile_error`] is emitted./// #![feature(cfg_select)]/// cfg_select! {///     unix => {///         fn foo() { /* unix specific functionality */ }///     target_pointer_width = "32" => {///         fn foo() { /* non-unix, 32-bit functionality */ }///     _ => {///         fn foo() { /* fallback implementation */ }/// The `cfg_select!` macro can also be used in expression position, with or without braces on the/// right-hand side:/// let _some_string = cfg_select! {///     unix => "With great power comes great electricity bills",///     _ => { "Behind every successful diet is an unwatched pizza" }"debug_assert_macro"/// Asserts that a boolean expression is `true` at runtime./// This will invoke the [`panic!`] macro if the provided expression cannot be/// evaluated to `true` at runtime./// Like [`assert!`], this macro also has a second version, where a custom panic/// message can be provided./// # Uses/// Unlike [`assert!`], `debug_assert!` statements are only enabled in non/// optimized builds by default. An optimized build will not execute/// `debug_assert!` statements unless `-C debug-assertions` is passed to the/// compiler. This makes `debug_assert!` useful for checks that are too/// expensive to be present in a release build but may be helpful during/// development. The result of expanding `debug_assert!` is always type checked./// An unchecked assertion allows a program in an inconsistent state to keep/// running, which might have unexpected consequences but does not introduce/// unsafety as long as this only happens in safe code. The performance cost/// of assertions, however, is not measurable in general. Replacing [`assert!`]/// with `debug_assert!` is thus only encouraged after thorough profiling, and/// more importantly, only in safe code!/// // the panic message for these assertions is the stringified value of the/// // expression given./// debug_assert!(true);/// fn some_expensive_computation() -> bool {///     // Some expensive computation here/// debug_assert!(some_expensive_computation());/// // assert with a custom message/// let x = true;/// debug_assert!(x, "x wasn't true!");/// let a = 3; let b = 27;/// debug_assert!(a + b == 30, "a = {}, b = {}", a, b);"debug_assert_eq_macro"debug_assert_eq/// Asserts that two expressions are equal to each other./// Unlike [`assert_eq!`], `debug_assert_eq!` statements are only enabled in non/// `debug_assert_eq!` statements unless `-C debug-assertions` is passed to the/// compiler. This makes `debug_assert_eq!` useful for checks that are too/// development. The result of expanding `debug_assert_eq!` is always type checked./// debug_assert_eq!(a, b);"debug_assert_ne_macro"debug_assert_ne/// Asserts that two expressions are not equal to each other./// Unlike [`assert_ne!`], `debug_assert_ne!` statements are only enabled in non/// `debug_assert_ne!` statements unless `-C debug-assertions` is passed to the/// compiler. This makes `debug_assert_ne!` useful for checks that are too/// development. The result of expanding `debug_assert_ne!` is always type checked./// debug_assert_ne!(a, b);/// This macro is generally preferable to `debug_assert!(matches!(value, pattern))`, because it can/// print the debug representation of the actual value shape that did not meet expectations. In/// contrast, using [`debug_assert!`] will only print that expectations were not met, but not why./// Unlike [`assert_matches!`], `debug_assert_matches!` statements are only enabled in non optimized/// builds by default. An optimized build will not execute `debug_assert_matches!` statements unless/// `-C debug-assertions` is passed to the compiler. This makes `debug_assert_matches!` useful for/// checks that are too expensive to be present in a release build but may be helpful during/// development. The result of expanding `debug_assert_matches!` is always type checked./// use std::assert_matches::debug_assert_matches;/// debug_assert_matches!(a, Some(_));/// debug_assert_matches!(b, Some(_));/// debug_assert_matches!(a, Some(345));/// debug_assert_matches!(a, Some(345) | None);/// // debug_assert_matches!(a, None); // panics/// // debug_assert_matches!(b, Some(345)); // panics/// // debug_assert_matches!(b, Some(345) | None); // panics/// debug_assert_matches!(a, Some(x) if x > 100);/// // debug_assert_matches!(a, Some(x) if x < 100); // panics"matches_macro"/// Returns whether the given expression matches the provided pattern./// The pattern syntax is exactly the same as found in a match arm. The optional if guard can be/// used to add additional checks that must be true for the matched value, otherwise this macro will/// return `false`./// When testing that a value matches a pattern, it's generally preferable to use/// [`assert_matches!`] as it will print the debug representation of the value if the assertion/// let foo = 'f';/// assert!(matches!(foo, 'A'..='Z' | 'a'..='z'));/// let bar = Some(4);/// assert!(matches!(bar, Some(x) if x > 2));/// Unwraps a result or propagates its error./// The [`?` operator][propagating-errors] was added to replace `try!`/// and should be used instead. Furthermore, `try` is a reserved word/// in Rust 2018, so if you must use it, you will need to use the/// [raw-identifier syntax][ris]: `r#try`./// [propagating-errors]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator/// [ris]: https://doc.rust-lang.org/nightly/rust-by-example/compatibility/raw_identifiers.html/// `try!` matches the given [`Result`]. In case of the `Ok` variant, the/// expression has the value of the wrapped value./// In case of the `Err` variant, it retrieves the inner error. `try!` then/// performs conversion using `From`. This provides automatic conversion/// between specialized errors and more general ones. The resulting/// error is then immediately returned./// Because of the early return, `try!` can only be used in functions that/// return [`Result`].///     FileWriteError/// impl From<io::Error> for MyError {///     fn from(e: io::Error) -> MyError {///         MyError::FileWriteError/// // The preferred method of quick returning Errors/// fn write_to_file_question() -> Result<(), MyError> {///     let mut file = File::create("my_best_friends.txt")?;///     file.write_all(b"This is a list of my best friends.")?;/// // The previous method of quick returning Errors/// fn write_to_file_using_try() -> Result<(), MyError> {///     let mut file = r#try!(File::create("my_best_friends.txt"));///     r#try!(file.write_all(b"This is a list of my best friends."));/// // This is equivalent to:/// fn write_to_file_using_match() -> Result<(), MyError> {///     match file.write_all(b"This is a list of my best friends.") {///         Ok(v) => v,///         Err(e) => return Err(From::from(e)),"write_macro"/// Writes formatted data into a buffer./// This macro accepts a 'writer', a format string, and a list of arguments. Arguments will be/// formatted according to the specified format string and the result will be passed to the writer./// The writer may be any value with a `write_fmt` method; generally this comes from an/// implementation of either the [`fmt::Write`] or the [`io::Write`] trait. The macro/// returns whatever the `write_fmt` method returns; commonly a [`fmt::Result`], or an/// [`io::Result`]./// See [`std::fmt`] for more information on the format string syntax./// [`std::fmt`]: ../std/fmt/index.html/// [`fmt::Write`]: crate::fmt::Write/// [`io::Write`]: ../std/io/trait.Write.html/// [`fmt::Result`]: crate::fmt::Result/// [`io::Result`]: ../std/io/type.Result.html/// fn main() -> std::io::Result<()> {///     let mut w = Vec::new();///     write!(&mut w, "test")?;///     write!(&mut w, "formatted {}", "arguments")?;///     assert_eq!(w, b"testformatted arguments");/// A module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects/// implementing either, as objects do not typically implement both. However, the module must/// avoid conflict between the trait names, such as by importing them as `_` or otherwise renaming/// them:/// use std::fmt::Write as _;///     write!(&mut s, "{} {}", "abc", 123)?; // uses fmt::Write::write_fmt///     write!(&mut v, "s = {:?}", s)?; // uses io::Write::write_fmt///     assert_eq!(v, b"s = \"abc 123\"");/// If you also need the trait names themselves, such as to implement one or both on your types,/// import the containing module and then name them with a prefix:/// # #![allow(unused_imports)]/// use std::fmt::{self, Write as _};/// use std::io::{self, Write as _};/// struct Example;/// impl fmt::Write for Example {///     fn write_str(&mut self, _s: &str) -> core::fmt::Result {///          unimplemented!();/// Note: This macro can be used in `no_std` setups as well./// In a `no_std` setup you are responsible for the implementation details of the components./// use core::fmt::Write;/// impl Write for Example {/// let mut m = Example{};/// write!(&mut m, "Hello World").expect("Not written");"writeln_macro"writeln/// Writes formatted data into a buffer, with a newline appended./// (no additional CARRIAGE RETURN (`\r`/`U+000D`)./// For more information, see [`write!`]. For information on the format string syntax, see/// [`std::fmt`]./// use std::io::{Write, Result};///     writeln!(&mut w)?;///     writeln!(&mut w, "test")?;///     writeln!(&mut w, "formatted {}", "arguments")?;///     assert_eq!(&w[..], "\ntest\nformatted arguments\n".as_bytes());"unreachable_macro"// Expands to either `$crate::panic::unreachable_2015` or `$crate::panic::unreachable_2021`/// Indicates unreachable code./// This is useful any time that the compiler can't determine that some code is unreachable. For/// * Match arms with guard conditions./// * Loops that dynamically terminate./// * Iterators that dynamically terminate./// If the determination that the code is unreachable proves incorrect, the/// program immediately terminates with a [`panic!`]./// The unsafe counterpart of this macro is the [`unreachable_unchecked`] function, which/// will cause undefined behavior if the code is reached./// [`unreachable_unchecked`]: crate::hint::unreachable_unchecked/// This will always [`panic!`] because `unreachable!` is just a shorthand for `panic!` with a/// fixed, specific message./// Like `panic!`, this macro has a second form for displaying custom values./// Match arms:/// fn foo(x: Option<i32>) {///         Some(n) if n >= 0 => println!("Some(Non-negative)"),///         Some(n) if n <  0 => println!("Some(Negative)"),///         Some(_)           => unreachable!(), // compile error if commented out///         None              => println!("None")/// Iterators:/// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3///     for i in 0.. {///         if 3*i < i { panic!("u32 overflow"); }///         if x < 3*i { return i-1; }///     unreachable!("The loop should always return");"unimplemented_macro"/// Indicates unimplemented code by panicking with a message of "not implemented"./// This allows your code to type-check, which is useful if you are prototyping or/// implementing a trait that requires multiple methods which you don't plan to use all of./// The difference between `unimplemented!` and [`todo!`] is that while `todo!`/// conveys an intent of implementing the functionality later and the message is "not yet/// implemented", `unimplemented!` makes no such claims. Its message is "not implemented"./// Also, some IDEs will mark `todo!`s./// This will always [`panic!`] because `unimplemented!` is just a shorthand for `panic!` with a/// [`todo!`]: crate::todo/// Say we have a trait `Foo`:/// trait Foo {///     fn bar(&self) -> u8;///     fn baz(&self);///     fn qux(&self) -> Result<u64, ()>;/// We want to implement `Foo` for 'MyStruct', but for some reason it only makes sense/// to implement the `bar()` function. `baz()` and `qux()` will still need to be defined/// in our implementation of `Foo`, but we can use `unimplemented!` in their definitions/// to allow our code to compile./// We still want to have our program stop running if the unimplemented methods are/// # trait Foo {/// #     fn bar(&self) -> u8;/// #     fn baz(&self);/// #     fn qux(&self) -> Result<u64, ()>;/// struct MyStruct;/// impl Foo for MyStruct {///     fn bar(&self) -> u8 {///     fn baz(&self) {///         // It makes no sense to `baz` a `MyStruct`, so we have no logic here///         // at all.///         // This will display "thread 'main' panicked at 'not implemented'".///         unimplemented!();///     fn qux(&self) -> Result<u64, ()> {///         // We have some logic here,///         // We can add a message to unimplemented! to display our omission.///         // This will display:///         // "thread 'main' panicked at 'not implemented: MyStruct isn't quxable'".///         unimplemented!("MyStruct isn't quxable");///     let s = MyStruct;///     s.bar();"todo_macro"/// Indicates unfinished code./// This can be useful if you are prototyping and just/// want a placeholder to let your code pass type analysis./// The difference between [`unimplemented!`] and `todo!` is that while `todo!` conveys/// an intent of implementing the functionality later and the message is "not yet/// This will always [`panic!`] because `todo!` is just a shorthand for `panic!` with a/// Here's an example of some in-progress code. We have a trait `Foo`:/// We want to implement `Foo` on one of our types, but we also want to work on/// just `bar()` first. In order for our code to compile, we need to implement/// `baz()` and `qux()`, so we can use `todo!`:///         // Let's not worry about implementing baz() for now///         todo!();///         // We can add a message to todo! to display our omission.///         // "thread 'main' panicked at 'not yet implemented: MyStruct is not yet quxable'".///         todo!("MyStruct is not yet quxable");///     // We aren't even using baz() or qux(), so this is fine./// Causes compilation to fail with the given error message when encountered./// This macro should be used when a crate uses a conditional compilation strategy to provide/// better error messages for erroneous conditions. It's the compiler-level form of [`panic!`],/// but emits an error during *compilation* rather than at *runtime*./// Two such examples are macros and `#[cfg]` environments./// Emit a better compiler error if a macro is passed invalid values. Without the final branch,/// the compiler would still emit an error, but the error's message would not mention the two/// valid values./// macro_rules! give_me_foo_or_bar {///     (foo) => {};///     (bar) => {};///     ($x:ident) => {///         compile_error!("This macro only accepts `foo` or `bar`");/// give_me_foo_or_bar!(neither);/// // ^ will fail at compile time with message "This macro only accepts `foo` or `bar`"/// Emit a compiler error if one of a number of features isn't available./// #[cfg(not(any(feature = "foo", feature = "bar")))]/// compile_error!("Either feature \"foo\" or \"bar\" must be enabled for this crate.");"format_args_macro"allow_internal_unsafe/// Constructs parameters for the other string-formatting macros./// This macro functions by taking a formatting string literal containing/// `{}` for each additional argument passed. `format_args!` prepares the/// additional parameters to ensure the output can be interpreted as a string/// and canonicalizes the arguments into a single type. Any value that implements/// the [`Display`] trait can be passed to `format_args!`, as can any/// [`Debug`] implementation be passed to a `{:?}` within the formatting string./// This macro produces a value of type [`fmt::Arguments`]. This value can be/// passed to the macros within [`std::fmt`] for performing useful redirection./// All other formatting macros ([`format!`], [`write!`], [`println!`], etc) are/// proxied through this one. `format_args!`, unlike its derived macros, avoids/// heap allocations./// You can use the [`fmt::Arguments`] value that `format_args!` returns/// in `Debug` and `Display` contexts as seen below. The example also shows/// that `Debug` and `Display` format to the same thing: the interpolated/// format string in `format_args!`./// let args = format_args!("{} foo {:?}", 1, 2);/// let debug = format!("{args:?}");/// let display = format!("{args}");/// See [the formatting documentation in `std::fmt`](../std/fmt/index.html)/// for details of the macro argument syntax, and further information./// [`Display`]: crate::fmt::Display/// [`Debug`]: crate::fmt::Debug/// [`fmt::Arguments`]: crate::fmt::Arguments/// [`println!`]: ../std/macro.println.html/// let s = fmt::format(format_args!("hello {}", "world"));/// assert_eq!(s, format!("hello {}", "world"));/// # Argument lifetimes/// Except when no formatting arguments are used,/// the produced `fmt::Arguments` value borrows temporary values./// To allow it to be stored for later use, the arguments' lifetimes, as well as those of/// temporaries they borrow, may be [extended] when `format_args!` appears in the initializer/// expression of a `let` statement. The syntactic rules used to determine when temporaries'/// lifetimes are extended are documented in the [Reference]./// [extended]: ../reference/destructors.html#temporary-lifetime-extension/// [Reference]: ../reference/destructors.html#extending-based-on-expressionsconst_format_args/// Same as [`format_args`], but can be used in some const contexts./// This macro is used by the panic macros for the `const_panic` feature./// This macro will be removed once `format_args` is allowed in const contexts.format_args_nl/// Same as [`format_args`], but adds a newline in the end."env_macro"/// Inspects an environment variable at compile time./// This macro will expand to the value of the named environment variable at/// compile time, yielding an expression of type `&'static str`. Use/// [`std::env::var`] instead if you want to read the value at runtime./// [`std::env::var`]: ../std/env/fn.var.html/// If the environment variable is not defined, then a compilation error/// will be emitted. To not emit a compile error, use the [`option_env!`]/// macro instead. A compilation error will also be emitted if the/// environment variable is not a valid Unicode string./// let path: &'static str = env!("PATH");/// println!("the $PATH variable at the time of compiling was: {path}");/// You can customize the error message by passing a string as the second/// parameter:/// let doc: &'static str = env!("documentation", "what's that?!");/// If the `documentation` environment variable is not defined, you'll get/// the following error:/// error: what's that?!// useful for external lints"option_env_macro"option_env/// Optionally inspects an environment variable at compile time./// If the named environment variable is present at compile time, this will/// expand into an expression of type `Option<&'static str>` whose value is/// `Some` of the value of the environment variable (a compilation error/// will be emitted if the environment variable is not a valid Unicode/// string). If the environment variable is not present, then this will/// expand to `None`. See [`Option<T>`][Option] for more information on this/// type.  Use [`std::env::var`] instead if you want to read the value at/// A compile time error is only emitted when using this macro if the/// environment variable exists and is not a valid Unicode string. To also/// emit a compile error if the environment variable is not present, use the/// [`env!`] macro instead./// let key: Option<&'static str> = option_env!("SECRET_KEY");/// println!("the secret key might be: {key:?}");concat_bytes/// Concatenates literals into a byte slice./// This macro takes any number of comma-separated literals, and concatenates them all into/// one, yielding an expression of type `&[u8; _]`, which represents all of the literals/// concatenated left-to-right. The literals passed can be any combination of:/// - byte literals (`b'r'`)/// - byte strings (`b"Rust"`)/// - arrays of bytes/numbers (`[b'A', 66, b'C']`)/// #![feature(concat_bytes)]/// let s: &[u8; 6] = concat_bytes!(b'A', b"BC", [68, b'E', 70]);/// assert_eq!(s, b"ABCDEF");"macro_concat"/// Concatenates literals into a static string slice./// This macro takes any number of comma-separated literals, yielding an/// expression of type `&'static str` which represents all of the literals/// concatenated left-to-right./// Integer and floating point literals are [stringified](core::stringify) in order to be/// concatenated./// let s = concat!("test", 10, 'b', true);/// assert_eq!(s, "test10btrue");/// Expands to the line number on which it was invoked./// With [`column!`] and [`file!`], these macros provide debugging information for/// developers about the location within the source./// The expanded expression has type `u32` and is 1-based, so the first line/// in each file evaluates to 1, the second to 2, etc. This is consistent/// with error messages by common compilers or popular editors./// The returned line is *not necessarily* the line of the `line!` invocation itself,/// but rather the first macro invocation leading up to the invocation/// of the `line!` macro./// let current_line = line!();/// println!("defined on line: {current_line}");/// Expands to the column number at which it was invoked./// With [`line!`] and [`file!`], these macros provide debugging information for/// The expanded expression has type `u32` and is 1-based, so the first column/// in each line evaluates to 1, the second to 2, etc. This is consistent/// The returned column is *not necessarily* the line of the `column!` invocation itself,/// of the `column!` macro./// let current_col = column!();/// println!("defined on column: {current_col}");/// `column!` counts Unicode code points, not bytes or graphemes. As a result, the first two/// invocations return the same value, but the third does not./// let a = ("foobar", column!()).1;/// let b = ("人之初性本善", column!()).1;/// let c = ("f̅o̅o̅b̅a̅r̅", column!()).1; // Uses combining overline (U+0305)/// assert_ne!(b, c);/// Expands to the file name in which it was invoked./// With [`line!`] and [`column!`], these macros provide debugging information for/// The expanded expression has type `&'static str`, and the returned file/// is not the invocation of the `file!` macro itself, but rather the/// first macro invocation leading up to the invocation of the `file!`/// The file name is derived from the crate root's source path passed to the Rust compiler/// and the sequence the compiler takes to get from the crate root to the/// module containing `file!`, modified by any flags passed to the Rust compiler (e.g./// `--remap-path-prefix`).  If the crate's source path is relative, the initial base/// directory will be the working directory of the Rust compiler.  For example, if the source/// path passed to the compiler is `./src/lib.rs` which has a `mod foo;` with a source path of/// `src/foo/mod.rs`, then calling `file!` inside `mod foo;` will return `./src/foo/mod.rs`./// Future compiler options might make further changes to the behavior of `file!`,/// including potentially making it entirely empty. Code (e.g. test libraries)/// relying on `file!` producing an openable file path would be incompatible/// with such options, and might wish to recommend not using those options./// let this_file = file!();/// println!("defined in file: {this_file}");/// Stringifies its arguments./// This macro will yield an expression of type `&'static str` which is the/// stringification of all the tokens passed to the macro. No restrictions/// are placed on the syntax of the macro invocation itself./// Note that the expanded results of the input tokens may change in the/// future. You should be careful if you rely on the output./// let one_plus_one = stringify!(1 + 1);/// assert_eq!(one_plus_one, "1 + 1");"include_str_macro"/// Includes a UTF-8 encoded file as a string./// The file is located relative to the current file (similarly to how/// modules are found). The provided path is interpreted in a platform-specific/// way at compile time. So, for instance, an invocation with a Windows path/// containing backslashes `\` would not compile correctly on Unix./// contents of the file./// File 'spanish.in':/// adiós/// File 'main.rs':/// ```ignore (cannot-doctest-external-file-dependency)///     let my_str = include_str!("spanish.in");///     assert_eq!(my_str, "adiós\n");///     print!("{my_str}");/// Compiling 'main.rs' and running the resulting binary will print "adiós"."include_bytes_macro"include_bytes/// Includes a file as a reference to a byte array./// This macro will yield an expression of type `&'static [u8; N]` which is/// the contents of the file.///     let bytes = include_bytes!("spanish.in");///     assert_eq!(bytes, b"adi\xc3\xb3s\n");///     print!("{}", String::from_utf8_lossy(bytes));/// Expands to a string that represents the current module path./// The current module path can be thought of as the hierarchy of modules/// leading back up to the crate root. The first component of the path/// returned is the name of the crate currently being compiled./// mod test {///     pub fn foo() {///         assert!(module_path!().ends_with("test"));/// test::foo();/// Evaluates boolean combinations of configuration flags at compile-time./// In addition to the `#[cfg]` attribute, this macro is provided to allow/// boolean expression evaluation of configuration flags. This frequently/// leads to less duplicated code./// The syntax given to this macro is the same syntax as the [`cfg`]/// `cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true or false. For/// example, all blocks in an if/else expression need to be valid when `cfg!` is used for/// the condition, regardless of what `cfg!` is evaluating./// [`cfg`]: ../reference/conditional-compilation.html#the-cfg-attribute/// let my_directory = if cfg!(windows) {///     "windows-specific-directory"///     "unix-directory""include_macro"/// Parses a file as an expression or an item according to the context./// **Warning**: For multi-file Rust projects, the `include!` macro is probably not what you/// are looking for. Usually, multi-file Rust projects use/// [modules](https://doc.rust-lang.org/reference/items/modules.html). Multi-file projects and/// modules are explained in the Rust-by-Example book/// [here](https://doc.rust-lang.org/rust-by-example/mod/split.html) and the module system is/// explained in the Rust Book/// [here](https://doc.rust-lang.org/book/ch07-02-defining-modules-to-control-scope-and-privacy.html)./// The included file is placed in the surrounding code/// [unhygienically](https://doc.rust-lang.org/reference/macros-by-example.html#hygiene). If/// the included file is parsed as an expression and variables or functions share names across/// both files, it could result in variables or functions being different from what the/// included file expected./// The included file is located relative to the current file (similarly to how modules are/// found). The provided path is interpreted in a platform-specific way at compile time. So,/// for instance, an invocation with a Windows path containing backslashes `\` would not/// compile correctly on Unix./// The `include!` macro is primarily used for two purposes. It is used to include/// documentation that is written in a separate file and it is used to include [build artifacts/// usually as a result from the `build.rs`/// script](https://doc.rust-lang.org/cargo/reference/build-scripts.html#outputs-of-the-build-script)./// When using the `include` macro to include stretches of documentation, remember that the/// included file still needs to be a valid Rust syntax. It is also possible to/// use the [`include_str`] macro as `#![doc = include_str!("...")]` (at the module level) or/// `#[doc = include_str!("...")]` (at the item level) to include documentation from a plain/// text or markdown file./// Assume there are two files in the same directory with the following contents:/// File 'monkeys.in':/// ```ignore (only-for-syntax-highlight)/// ['🙈', '🙊', '🙉']///     .cycle()///     .take(6)///     .collect::<String>()///     let my_string = include!("monkeys.in");///     assert_eq!("🙈🙊🙉🙈🙊🙉", my_string);///     println!("{my_string}");/// Compiling 'main.rs' and running the resulting binary will print/// "🙈🙊🙉🙈🙊🙉"./// This macro uses forward-mode automatic differentiation to generate a new function./// It may only be applied to a function. The new function will compute the derivative/// of the function to which the macro was applied./// The expected usage syntax is:/// `#[autodiff_forward(NAME, INPUT_ACTIVITIES, OUTPUT_ACTIVITY)]`/// - `NAME`: A string that represents a valid function name./// - `INPUT_ACTIVITIES`: Specifies one valid activity for each input parameter./// - `OUTPUT_ACTIVITY`: Must not be set if the function implicitly returns nothing///   (or explicitly returns `-> ()`). Otherwise, it must be set to one of the allowed activities./// ACTIVITIES might either be `Dual` or `Const`, more options will be exposed later./// `Const` should be used on non-float arguments, or float-based arguments as an optimization/// if we are not interested in computing the derivatives with respect to this argument./// `Dual` can be used for float scalar values or for references, raw pointers, or other/// indirect input arguments. It can also be used on a scalar float return value./// If used on a return value, the generated function will return a tuple of two float scalars./// If used on an input argument, a new shadow argument of the same type will be created,/// directly following the original argument./// ### Usage examples:/// ```rust,ignore (autodiff requires a -Z flag as well as fat-lto for testing)/// #![feature(autodiff)]/// use std::autodiff::*;/// #[autodiff_forward(rb_fwd1, Dual, Const, Dual)]/// #[autodiff_forward(rb_fwd2, Const, Dual, Dual)]/// #[autodiff_forward(rb_fwd3, Dual, Dual, Dual)]/// fn rosenbrock(x: f64, y: f64) -> f64 {///     (1.0 - x).powi(2) + 100.0 * (y - x.powi(2)).powi(2)/// #[autodiff_forward(rb_inp_fwd, Dual, Dual, Dual)]/// fn rosenbrock_inp(x: f64, y: f64, out: &mut f64) {///     *out = (1.0 - x).powi(2) + 100.0 * (y - x.powi(2)).powi(2);///   let x0 = rosenbrock(1.0, 3.0); // 400.0///   let (x1, dx1) = rb_fwd1(1.0, 1.0, 3.0); // (400.0, -800.0)///   let (x2, dy1) = rb_fwd2(1.0, 3.0, 1.0); // (400.0, 400.0)///   // When seeding both arguments at once the tangent return is the sum of both.///   let (x3, dxy) = rb_fwd3(1.0, 1.0, 3.0, 1.0); // (400.0, -400.0)///   let mut out = 0.0;///   let mut dout = 0.0;///   rb_inp_fwd(1.0, 1.0, 3.0, 1.0, &mut out, &mut dout);///   // (out, dout) == (400.0, -400.0)/// We might want to track how one input float affects one or more output floats. In this case,/// the shadow of one input should be initialized to `1.0`, while the shadows of the other/// inputs should be initialized to `0.0`. The shadow of the output(s) should be initialized to/// `0.0`. After calling the generated function, the shadow of the input will be zeroed,/// while the shadow(s) of the output(s) will contain the derivatives. Forward mode is generally/// more efficient if we have more output floats marked as `Dual` than input floats./// Related information can also be found under the term "Vector-Jacobian product" (VJP)./// This macro uses reverse-mode automatic differentiation to generate a new function./// `#[autodiff_reverse(NAME, INPUT_ACTIVITIES, OUTPUT_ACTIVITY)]`/// ACTIVITIES might either be `Active`, `Duplicated` or `Const`, more options will be exposed later./// `Active` can be used for float scalar values./// If used on an input, a new float will be appended to the return tuple of the generated/// function. If the function returns a float scalar, `Active` can be used for the return as/// well. In this case a float scalar will be appended to the argument list, it works as seed./// `Duplicated` can be used on references, raw pointers, or other indirect input/// arguments. It creates a new shadow argument of the same type, following the original argument./// A const reference or pointer argument will receive a mutable reference or pointer as shadow./// #[autodiff_reverse(rb_rev, Active, Active, Active)]/// #[autodiff_reverse(rb_inp_rev, Active, Active, Duplicated)]///     let (output1, dx1, dy1) = rb_rev(1.0, 3.0, 1.0);///     dbg!(output1, dx1, dy1); // (400.0, -800.0, 400.0)///     let mut output2 = 0.0;///     let mut seed = 1.0;///     let (dx2, dy2) = rb_inp_rev(1.0, 3.0, &mut output2, &mut seed);///     // (dx2, dy2, output2, seed) == (-800.0, 400.0, 400.0, 0.0)/// We often want to track how one or more input floats affect one output float. This output can/// be a scalar return value, or a mutable reference or pointer argument. In the latter case, the/// mutable input should be marked as duplicated and its shadow initialized to `0.0`. The shadow of/// the output should be marked as active or duplicated and initialized to `1.0`. After calling/// the generated function, the shadow(s) of the input(s) will contain the derivatives. The/// shadow of the outputs ("seed") will be reset to zero./// If the function has more than one output float marked as active or duplicated, users might want to/// set one of them to `1.0` and the others to `0.0` to compute partial derivatives./// Unlike forward-mode, a call to the generated function does not reset the shadow of the/// Reverse mode is generally more efficient if we have more active/duplicated input than/// output floats./// Related information can also be found under the term "Jacobian-Vector Product" (JVP)."assert_macro"/// be disabled. See [`debug_assert!`] for assertions that are not enabled in/// Unsafe code may rely on `assert!` to enforce run-time invariants that, if/// violated could lead to unsafety./// Other use-cases of `assert!` include testing and enforcing run-time/// invariants in safe code (whose violation cannot result in unsafety)./// # Custom Messages/// This macro has a second form, where a custom panic message can/// be provided with or without arguments for formatting. See [`std::fmt`]/// for syntax for this form. Expressions used as format arguments will only/// be evaluated if the assertion fails./// assert!(true);/// fn some_computation() -> bool {/// assert!(some_computation());/// assert!(x, "x wasn't true!");/// assert!(a + b == 30, "a = {}, b = {}", a, b);log_syntax/// Prints passed tokens into the standard output.trace_macros/// Enables or disables tracing functionality used for debugging other macros./// Attribute macro used to apply derive macros./// See [the reference] for more info./// [the reference]: ../../../reference/attributes/derive.html/// Attribute macro used to apply derive macros for implementing traits/// in a const context./// Attribute macro applied to a function to turn it into a unit test./// [the reference]: ../../../reference/attributes/testing.html#the-test-attribute/// Attribute macro applied to a function to turn it into a benchmark test./// An implementation detail of the `#[test]` and `#[bench]` macros.global_allocator/// Attribute macro applied to a static to register it as a global allocator./// See also [`std::alloc::GlobalAlloc`](../../../std/alloc/trait.GlobalAlloc.html)./// Attribute macro applied to a function to give it a post-condition./// The attribute carries an argument token-tree which is/// eventually parsed as a unary closure expression that is/// invoked on a reference to the return value./// Attribute macro applied to a function to give it a precondition./// eventually parsed as an boolean expression with access to the/// function's formal parametersalloc_error_handler/// Attribute macro applied to a function to register it as a handler for allocation failure./// See also [`std::alloc::handle_alloc_error`](../../../std/alloc/fn.handle_alloc_error.html).cfg_accessible/// Keeps the item it's applied to if the passed path is accessible, and removes it otherwise.cfg_eval/// Expands all `#[cfg]` and `#[cfg_attr]` attributes in the code fragment it's applied to.define_opaque/// Provide a list of type aliases and other opaque-type-containing type definitions/// to an item with a body. This list will be used in that body to define opaque/// types' hidden types./// Can only be applied to things that have bodies.type_ascribe/// Unstable placeholder for type ascription./// Unstable placeholder for deref patterns./// Derive macro generating an impl of the trait `From`./// Currently, it can only be used on single-field structs.// Note that the macro is in a different module than the `From` trait,// to avoid triggering an unstable feature being used if someone imports// `std::convert::From`./// Definitions of built-in macros./// Most of the macro properties (stability, visibility, etc.) are taken from the source code here,/// with exception of expansion functions transforming macro inputs into outputs,/// those functions are provided by the compiler.first_tokenphantom_typephantom_lifetimer" Zero-sized type used to mark a lifetime as covariant."r" Covariant lifetimes must live at least as long as declared. See [the reference][1] for more"r" [1]: https://doc.rust-lang.org/stable/reference/subtyping.html#variance"r" Note: If `'a` is otherwise contravariant or invariant, the resulting type is invariant."r" ## Layout"r" For all `'a`, the following are guaranteed:"r" * `size_of::<PhantomCovariantLifetime<'a>>() == 0`"r" * `align_of::<PhantomCovariantLifetime<'a>>() == 1`"PhantomCovariantPhantomCovariantLifetimer" Constructs a new instance of the variance marker."Variancer" Zero-sized type used to mark a lifetime as contravariant."r" Contravariant lifetimes must live at most as long as declared. See [the reference][1] for"r" more information."r" Note: If `'a` is otherwise covariant or invariant, the resulting type is invariant."r" * `size_of::<PhantomContravariantLifetime<'a>>() == 0`"r" * `align_of::<PhantomContravariantLifetime<'a>>() == 1`"PhantomContravariantPhantomContravariantLifetimer" Zero-sized type used to mark a lifetime as invariant."r" Invariant lifetimes must be live for the exact length declared, neither shorter nor longer."r" See [the reference][1] for more information."r" * `size_of::<PhantomInvariantLifetime<'a>>() == 0`"r" * `align_of::<PhantomInvariantLifetime<'a>>() == 1`"PhantomInvariantr" Zero-sized type used to mark a type parameter as covariant."r" Types used as part of the return value from a function are covariant. If the type is _also_"r" passed as a parameter then it is [invariant][PhantomInvariant]. See [the reference][1] for"r" Note: If `T` is otherwise contravariant or invariant, the resulting type is invariant."r" For all `T`, the following are guaranteed:"r" * `size_of::<PhantomCovariant<T>>() == 0`"r" * `align_of::<PhantomCovariant<T>>() == 1`"r" Zero-sized type used to mark a type parameter as contravariant."r" Types passed as arguments to a function are contravariant. If the type is _also_ part of the"r" return value from a function then it is [invariant][PhantomInvariant]. See [the"r" reference][1] for more information."r" Note: If `T` is otherwise covariant or invariant, the resulting type is invariant."r" * `size_of::<PhantomContravariant<T>>() == 0`"r" * `align_of::<PhantomContravariant<T>>() == 1`"r" Zero-sized type used to mark a type parameter as invariant."r" Types that are both passed as an argument _and_ used as part of the return value from a"r" function are invariant. See [the reference][1] for more information."r" * `size_of::<PhantomInvariant<T>>() == 0`"r" * `align_of::<PhantomInvariant<T>>() == 1`"/// A marker trait for phantom variance types.variance/// Construct a variance marker; equivalent to [`Default::default`]./// This type can be any of the following. You generally should not need to explicitly name the/// type, however./// - [`PhantomCovariant`]/// - [`PhantomContravariant`]/// - [`PhantomInvariant`]/// - [`PhantomCovariantLifetime`]/// - [`PhantomContravariantLifetime`]/// - [`PhantomInvariantLifetime`]/// #![feature(phantom_variance_markers)]/// use core::marker::{PhantomCovariant, variance};/// struct BoundFn<F, P, R>///     F: Fn(P) -> R,///     function: F,///     parameter: P,///     return_value: PhantomCovariant<R>,/// let bound_fn = BoundFn {///     function: core::convert::identity,///     parameter: 5u8,///     return_value: variance(),UnsafePinnedmarker_impls/// Implements a given marker trait for multiple types at the same time./// The basic syntax looks like this:/// ```ignore private macro/// marker_impls! { MarkerTrait for u8, i8 }/// You can also implement `unsafe` traits/// marker_impls! { unsafe MarkerTrait for u8, i8 }/// Add attributes to all impls:/// marker_impls! {///     #[allow(lint)]///     #[unstable(feature = "marker_trait", issue = "none")]///     MarkerTrait for u8, i8/// And use generics:///     MarkerTrait for///         u8, i8,///         {T: ?Sized} *const T,///         {T: ?Sized} *mut T,///         {T: MarkerTrait} PhantomData<T>,///         u32,// Allow implementations of `UnsizedConstParamTy` even though std cannot use that feature.// empty."Send"/// Types that can be transferred across thread boundaries./// This trait is automatically implemented when the compiler determines it's/// An example of a non-`Send` type is the reference-counting pointer/// [`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point to the same/// reference-counted value, they might try to update the reference count at the/// same time, which is [undefined behavior][ub] because [`Rc`] doesn't use atomic/// operations. Its cousin [`sync::Arc`][arc] does use atomic operations (incurring/// some overhead) and thus is `Send`./// See [the Nomicon](../../nomicon/send-and-sync.html) and the [`Sync`] trait for more details./// [arc]: ../../std/sync/struct.Arc.html// Most instances arise automatically, but this instance is needed to link up `T: Sync` with// `&T: Send` (and it also removes the unsound default instance `T Send` -> `&T: Send` that would// otherwise exist)."sized"rustc_deny_explicit_implrustc_do_not_implement_via_objectrustc_coinductiveMetaSized/// Types with a constant size known at compile time./// All type parameters have an implicit bound of `Sized`. The special syntax/// `?Sized` can be used to remove this bound if it's not appropriate./// struct Bar<T: ?Sized>(T);/// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]/// struct BarUse(Bar<[i32]>); // OK/// The one exception is the implicit `Self` type of a trait. A trait does not/// have an implicit `Sized` bound as this is incompatible with [trait object]s/// where, by definition, the trait needs to work with all possible implementors,/// and thus could be any size./// Although Rust will let you bind `Sized` to a trait, you won't/// be able to use it to form a trait object later:/// trait Foo { }/// trait Bar: Sized { }/// struct Impl;/// impl Foo for Impl { }/// impl Bar for Impl { }/// let x: &dyn Foo = &Impl;    // OK/// // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot be made into an object// for Default, for example, which requires that `[T]: !Default` be evaluatable// `Sized` being coinductive, despite having supertraits, is okay as there are no user-written impls,// and we know that the supertraits are always implemented if the subtrait is just by looking at// the builtin impls.// Empty"meta_sized"/// Types with a size that can be determined from pointer metadata.// `MetaSized` being coinductive, despite having supertraits, is okay for the same reasons as// `Sized` above."pointee_sized"/// Types that may or may not have a size."unsize"/// Types that can be "unsized" to a dynamically-sized type./// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>` and/// `Unsize<dyn fmt::Debug>`./// All implementations of `Unsize` are provided automatically by the compiler./// Those implementations are:/// - Arrays `[T; N]` implement `Unsize<[T]>`./// - A type implements `Unsize<dyn Trait + 'a>` if all of these conditions are met:///   - The type implements `Trait`.///   - `Trait` is dyn-compatible[^1].///   - The type is sized.///   - The type outlives `'a`./// - Trait objects `dyn TraitA + AutoA... + 'a` implement `Unsize<dyn TraitB + AutoB... + 'b>`///    if all of these conditions are met:///   - `TraitB` is a supertrait of `TraitA`.///   - `AutoB...` is a subset of `AutoA...`.///   - `'a` outlives `'b`./// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1, ..., Un, ...>>`///   where any number of (type and const) parameters may be changed if all of these conditions///   are met:///   - Only the last field of `Foo` has a type involving the parameters `T1`, ..., `Tn`.///   - All other parameters of the struct are equal.///   - `Field<T1, ..., Tn>: Unsize<Field<U1, ..., Un>>`, where `Field<...>` stands for the actual///     type of the struct's last field./// `Unsize` is used along with [`ops::CoerceUnsized`] to allow/// "user-defined" containers such as [`Rc`] to contain dynamically-sized/// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on coercion][nomicon-coerce]/// [`ops::CoerceUnsized`]: crate::ops::CoerceUnsized/// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md/// [nomicon-coerce]: ../../nomicon/coercions.html/// [^1]: Formerly known as *object safe*."structural_peq"StructuralPartialEq/// Required trait for constants used in pattern matches./// Constants are only allowed as patterns if (a) their type implements/// `PartialEq`, and (b) interpreting the value of the constant as a pattern/// is equivalent to calling `PartialEq`. This ensures that constants used as/// patterns cannot expose implementation details in an unexpected way or/// cause semver hazards./// This trait ensures point (b)./// Any type that derives `PartialEq` automatically implements this trait./// Implementing this trait (which is unstable) is a way for type authors to explicitly allow/// comparing const values of this type; that operation will recursively compare all fields/// (including private fields), even if that behavior differs from `PartialEq`. This can make it/// semver-breaking to add further private fields to a type."copy""Copy"/// Types whose values can be duplicated simply by copying bits./// By default, variable bindings have 'move semantics.' In other/// words:/// let x = Foo;/// let y = x;/// // `x` has moved into `y`, and so cannot be used/// // println!("{x:?}"); // error: use of moved value/// However, if a type implements `Copy`, it instead has 'copy semantics':/// // We can derive a `Copy` implementation. `Clone` is also required, as it's/// // a supertrait of `Copy`./// #[derive(Debug, Copy, Clone)]/// // `y` is a copy of `x`/// println!("{x:?}"); // A-OK!/// It's important to note that in these two examples, the only difference is whether you/// are allowed to access `x` after the assignment. Under the hood, both a copy and a move/// can result in bits being copied in memory, although this is sometimes optimized away./// ## How can I implement `Copy`?/// There are two ways to implement `Copy` on your type. The simplest is to use `derive`:/// You can also implement `Copy` and `Clone` manually:/// impl Copy for MyStruct { }/// impl Clone for MyStruct {///     fn clone(&self) -> MyStruct {/// There is a small difference between the two. The `derive` strategy will also place a `Copy`/// bound on type parameters:/// struct MyStruct<T>(T);/// impl<T: Copy> Copy for MyStruct<T> { }/// This isn't always desired. For example, shared references (`&T`) can be copied regardless of/// whether `T` is `Copy`. Likewise, a generic struct containing markers such as [`PhantomData`]/// could potentially be duplicated with a bit-wise copy./// ## What's the difference between `Copy` and `Clone`?/// Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of/// `Copy` is not overloadable; it is always a simple bit-wise copy./// Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can/// provide any type-specific behavior necessary to duplicate values safely. For example,/// the implementation of [`Clone`] for [`String`] needs to copy the pointed-to string/// buffer in the heap. A simple bitwise copy of [`String`] values would merely copy the/// pointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]/// but not `Copy`./// [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement/// [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`/// (see the example above)./// ## When can my type be `Copy`?/// A type can implement `Copy` if all of its components implement `Copy`. For example, this/// struct can be `Copy`:///    x: i32,///    y: i32,/// A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`./// By contrast, consider/// # struct Point;/// struct PointList {///     points: Vec<Point>,/// The struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we/// attempt to derive a `Copy` implementation, we'll get an error:/// the trait `Copy` cannot be implemented for this type; field `points` does not implement `Copy`/// Shared references (`&T`) are also `Copy`, so a type can be `Copy`, even when it holds/// shared references of types `T` that are *not* `Copy`. Consider the following struct,/// which can implement `Copy`, because it only holds a *shared reference* to our non-`Copy`/// type `PointList` from above:/// # struct PointList;/// struct PointListWrapper<'a> {///     point_list_ref: &'a PointList,/// ## When *can't* my type be `Copy`?/// Some types can't be copied safely. For example, copying `&mut T` would create an aliased/// mutable reference. Copying [`String`] would duplicate responsibility for managing the/// [`String`]'s buffer, leading to a double free./// Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's/// managing some resource besides its own [`size_of::<T>`] bytes./// If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get/// the error [E0204]./// [E0204]: ../../error_codes/E0204.html/// ## When *should* my type be `Copy`?/// Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,/// that implementing `Copy` is part of the public API of your type. If the type might become/// non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to/// avoid a breaking API change./// the following types also implement `Copy`:///   or if all such captured values implement `Copy` themselves.///   Note that variables captured by shared reference always implement `Copy`///   while variables captured by mutable reference never implement `Copy`./// [`Vec<T>`]: ../../std/vec/struct.Vec.html/// [`size_of::<T>`]: size_of// This is unsound, but required by `hashbrown`// FIXME(joboet): change `hashbrown` to use `TrivialClone`/// Derive macro generating an impl of the trait `Copy`.// Implementations of `Copy` for primitive types.// Implementations that cannot be described in Rust// are implemented in `traits::SelectionContext::copy_clone_conditions()`// in `rustc_trait_selection`./// Shared references can be copied, but mutable references *cannot*!"bikeshed_guaranteed_no_drop"BikeshedGuaranteedNoDrop/// Marker trait for the types that are allowed in union fields and unsafe/// binder types./// Implemented for:/// * `&T`, `&mut T` for all `T`,/// * `ManuallyDrop<T>` for all `T`,/// * tuples and arrays whose elements implement `BikeshedGuaranteedNoDrop`,/// * or otherwise, all types that are `Copy`./// Notably, this doesn't include all trivially-destructible types for semver/// Bikeshed name for now. This trait does not do anything other than reflect the/// set of types that are allowed within unions for field validity.// FIXME(estebank): once support to add notes in `rustc_on_unimplemented`// lands in beta, and it has been extended to check whether a closure is// anywhere in the requirement chain, extend it as such (#48534):// on(//     closure,//     note="`{Self}` cannot be shared safely, consider marking the closure `move`"// ),"Sync""sync"/// Types for which it is safe to share references between threads./// This trait is automatically implemented when the compiler determines/// it's appropriate./// The precise definition is: a type `T` is [`Sync`] if and only if `&T` is/// [`Send`]. In other words, if there is no possibility of/// [undefined behavior][ub] (including data races) when passing/// `&T` references between threads./// As one would expect, primitive types like [`u8`] and [`f64`]/// are all [`Sync`], and so are simple aggregate types containing them,/// like tuples, structs and enums. More examples of basic [`Sync`]/// types include "immutable" types like `&T`, and those with simple/// inherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and/// most other collection types. (Generic parameters need to be [`Sync`]/// for their container to be [`Sync`].)/// A somewhat surprising consequence of the definition is that `&mut T`/// is `Sync` (if `T` is `Sync`) even though it seems like that might/// provide unsynchronized mutation. The trick is that a mutable/// reference behind a shared reference (that is, `& &mut T`)/// becomes read-only, as if it were a `& &T`. Hence there is no risk/// of a data race./// A shorter overview of how [`Sync`] and [`Send`] relate to referencing:/// * `&T` is [`Send`] if and only if `T` is [`Sync`]/// * `&mut T` is [`Send`] if and only if `T` is [`Send`]/// * `&T` and `&mut T` are [`Sync`] if and only if `T` is [`Sync`]/// Types that are not `Sync` are those that have "interior/// mutability" in a non-thread-safe form, such as [`Cell`][cell]/// and [`RefCell`][refcell]. These types allow for mutation of/// their contents even through an immutable, shared reference. For/// example the `set` method on [`Cell<T>`][cell] takes `&self`, so it requires/// only a shared reference [`&Cell<T>`][cell]. The method performs no/// synchronization, thus [`Cell`][cell] cannot be `Sync`./// Another example of a non-`Sync` type is the reference-counting/// pointer [`Rc`][rc]. Given any reference [`&Rc<T>`][rc], you can clone/// a new [`Rc<T>`][rc], modifying the reference counts in a non-atomic way./// For cases when one does need thread-safe interior mutability,/// Rust provides [atomic data types], as well as explicit locking via/// [`sync::Mutex`][mutex] and [`sync::RwLock`][rwlock]. These types/// ensure that any mutation cannot cause data races, hence the types/// are `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe/// analogue of [`Rc`][rc]./// Any types with interior mutability must also use the/// [`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which/// can be mutated through a shared reference. Failing to doing this is/// [undefined behavior][ub]. For example, [`transmute`][transmute]-ing/// from `&T` to `&mut T` is invalid./// See [the Nomicon][nomicon-send-and-sync] for more details about `Sync`./// [box]: ../../std/boxed/struct.Box.html/// [vec]: ../../std/vec/struct.Vec.html/// [cell]: crate::cell::Cell/// [refcell]: crate::cell::RefCell/// [rc]: ../../std/rc/struct.Rc.html/// [atomic data types]: crate::sync::atomic/// [unsafecell]: crate::cell::UnsafeCell/// [transmute]: crate::mem::transmute/// [nomicon-send-and-sync]: ../../nomicon/send-and-sync.html"phantom_data"/// Zero-sized type used to mark things that "act like" they own a `T`./// Adding a `PhantomData<T>` field to your type tells the compiler that your/// type acts as though it stores a value of type `T`, even though it doesn't/// really. This information is used when computing certain safety properties./// For a more in-depth explanation of how to use `PhantomData<T>`, please see/// [the Nomicon](../../nomicon/phantom-data.html)./// # A ghastly note 👻👻👻/// Though they both have scary names, `PhantomData` and 'phantom types' are/// related, but not identical. A phantom type parameter is simply a type/// parameter which is never used. In Rust, this often causes the compiler to/// complain, and the solution is to add a "dummy" use by way of `PhantomData`./// ## Unused lifetime parameters/// Perhaps the most common use case for `PhantomData` is a struct that has an/// unused lifetime parameter, typically as part of some unsafe code. For/// example, here is a struct `Slice` that has two pointers of type `*const T`,/// presumably pointing into an array somewhere:/// ```compile_fail,E0392/// struct Slice<'a, T> {///     start: *const T,///     end: *const T,/// The intention is that the underlying data is only valid for the/// lifetime `'a`, so `Slice` should not outlive `'a`. However, this/// intent is not expressed in the code, since there are no uses of/// the lifetime `'a` and hence it is not clear what data it applies/// to. We can correct this by telling the compiler to act *as if* the/// `Slice` struct contained a reference `&'a T`:///     phantom: PhantomData<&'a T>,/// This also in turn infers the lifetime bound `T: 'a`, indicating/// that any references in `T` are valid over the lifetime `'a`./// When initializing a `Slice` you simply provide the value/// `PhantomData` for the field `phantom`:/// # struct Slice<'a, T> {/// #     start: *const T,/// #     end: *const T,/// #     phantom: PhantomData<&'a T>,/// fn borrow_vec<T>(vec: &Vec<T>) -> Slice<'_, T> {///     let ptr = vec.as_ptr();///     Slice {///         start: ptr,///         end: unsafe { ptr.add(vec.len()) },///         phantom: PhantomData,/// ## Unused type parameters/// It sometimes happens that you have unused type parameters which/// indicate what type of data a struct is "tied" to, even though that/// data is not actually found in the struct itself. Here is an/// example where this arises with [FFI]. The foreign interface uses/// handles of type `*mut ()` to refer to Rust values of different/// types. We track the Rust type using a phantom type parameter on/// the struct `ExternalResource` which wraps a handle./// [FFI]: ../../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code/// # trait ResType { }/// # struct ParamType;/// # mod foreign_lib {/// #     pub fn new(_: usize) -> *mut () { 42 as *mut () }/// #     pub fn do_stuff(_: *mut (), _: usize) {}/// # fn convert_params(_: ParamType) -> usize { 42 }/// struct ExternalResource<R> {///    resource_handle: *mut (),///    resource_type: PhantomData<R>,/// impl<R: ResType> ExternalResource<R> {///         let size_of_res = size_of::<R>();///             resource_handle: foreign_lib::new(size_of_res),///             resource_type: PhantomData,///     fn do_stuff(&self, param: ParamType) {///         let foreign_params = convert_params(param);///         foreign_lib::do_stuff(self.resource_handle, foreign_params);/// ## Ownership and the drop check/// The exact interaction of `PhantomData` with drop check **may change in the future**./// Currently, adding a field of type `PhantomData<T>` indicates that your type *owns* data of type/// `T` in very rare circumstances. This in turn has effects on the Rust compiler's [drop check]/// analysis. For the exact rules, see the [drop check] documentation./// ## Layout/// For all `T`, the following are guaranteed:/// * `size_of::<PhantomData<T>>() == 0`/// * `align_of::<PhantomData<T>>() == 1`/// [drop check]: Drop#drop-check"discriminant_type"/// The type of the discriminant, which must satisfy the trait/// bounds required by `mem::Discriminant`."discriminant_kind"/// Compiler-internal trait used to indicate the type of enum discriminants./// This trait is automatically implemented for every type and does not add any/// guarantees to [`mem::Discriminant`]. It is **undefined behavior** to transmute/// between `DiscriminantKind::Discriminant` and `mem::Discriminant`./// [`mem::Discriminant`]: crate::mem::Discriminant"freeze"Freeze/// Used to determine whether a type contains/// any `UnsafeCell` internally, but not through an indirection./// This affects, for example, whether a `static` of that type is/// placed in read-only static memory or writable static memory./// This can be used to declare that a constant with a generic type/// will not contain interior mutability, and subsequently allow/// placing the constant behind references./// This trait is a core part of the language, it is just expressed as a trait in libcore for/// convenience. Do *not* implement it for other types.// FIXME: Eventually this trait should become `#[rustc_deny_explicit_impl]`.// That requires porting the impls below to native internal impls."unsafe_unpin"/// Used to determine whether a type contains any `UnsafePinned` (or `PhantomPinned`) internally,/// but not through an indirection. This affects, for example, whether we emit `noalias` metadata/// for `&mut T` or not./// This is part of [RFC 3467](https://rust-lang.github.io/rfcs/3467-unsafe-pinned.html), and is/// tracked by [#125735](https://github.com/rust-lang/rust/issues/125735)."unpin"/// Types that do not require any pinning guarantees./// For information on what "pinning" is, see the [`pin` module] documentation./// Implementing the `Unpin` trait for `T` expresses the fact that `T` is pinning-agnostic:/// it shall not expose nor rely on any pinning guarantees. This, in turn, means that a/// `Pin`-wrapped pointer to such a type can feature a *fully unrestricted* API./// In other words, if `T: Unpin`, a value of type `T` will *not* be bound by the invariants/// which pinning otherwise offers, even when "pinned" by a [`Pin<Ptr>`] pointing at it./// When a value of type `T` is pointed at by a [`Pin<Ptr>`], [`Pin`] will not restrict access/// to the pointee value like it normally would, thus allowing the user to do anything that they/// normally could with a non-[`Pin`]-wrapped `Ptr` to that value./// The idea of this trait is to alleviate the reduced ergonomics of APIs that require the use/// of [`Pin`] for soundness for some types, but which also want to be used by other types that/// don't care about pinning. The prime example of such an API is [`Future::poll`]. There are many/// [`Future`] types that don't care about pinning. These futures can implement `Unpin` and/// therefore get around the pinning related restrictions in the API, while still allowing the/// subset of [`Future`]s which *do* require pinning to be implemented soundly./// For more discussion on the consequences of [`Unpin`] within the wider scope of the pinning/// system, see the [section about `Unpin`] in the [`pin` module]./// `Unpin` has no consequence at all for non-pinned data. In particular, [`mem::replace`] happily/// moves `!Unpin` data, which would be immovable when pinned ([`mem::replace`] works for any/// `&mut T`, not just when `T: Unpin`)./// *However*, you cannot use [`mem::replace`] on `!Unpin` data which is *pinned* by being wrapped/// inside a [`Pin<Ptr>`] pointing at it. This is because you cannot (safely) use a/// [`Pin<Ptr>`] to get a `&mut T` to its pointee value, which you would need to call/// [`mem::replace`], and *that* is what makes this system work./// So this, for example, can only be done on types implementing `Unpin`:/// let mut string = "this".to_string();/// let mut pinned_string = Pin::new(&mut string);/// // We need a mutable reference to call `mem::replace`./// // We can obtain such a reference by (implicitly) invoking `Pin::deref_mut`,/// // but that is only possible because `String` implements `Unpin`./// mem::replace(&mut *pinned_string, "other".to_string());/// This trait is automatically implemented for almost every type. The compiler is free/// to take the conservative stance of marking types as [`Unpin`] so long as all of the types that/// compose its fields are also [`Unpin`]. This is because if a type implements [`Unpin`], then it/// is unsound for that type's implementation to rely on pinning-related guarantees for soundness,/// *even* when viewed through a "pinning" pointer! It is the responsibility of the implementor of/// a type that relies upon pinning for soundness to ensure that type is *not* marked as [`Unpin`]/// by adding [`PhantomPinned`] field. For more details, see the [`pin` module] docs./// [`mem::replace`]: crate::mem::replace "mem replace"/// [`Future`]: crate::future::Future "Future"/// [`Future::poll`]: crate::future::Future::poll "Future poll"/// [`Pin`]: crate::pin::Pin "Pin"/// [`Pin<Ptr>`]: crate::pin::Pin "Pin"/// [`pin` module]: crate::pin "pin module"/// [section about `Unpin`]: crate::pin#unpin "pin module docs about unpin"/// [`unsafe`]: ../../std/keyword.unsafe.html "keyword unsafe"/// A marker type which does not implement `Unpin`./// If a type contains a `PhantomPinned`, it will not implement `Unpin` by default.// FIXME(unsafe_pinned): This is *not* a stable guarantee we want to make, at least not yet.// Note that for backwards compatibility with the new [`UnsafePinned`] wrapper type, placing this// marker in your struct acts as if you wrapped the entire struct in an `UnsafePinned`. This type// will likely eventually be deprecated, and all new code should be using `UnsafePinned` instead.// This is a small hack to allow existing code which uses PhantomPinned to opt-out of noalias to// continue working. Ideally PhantomPinned could just wrap an `UnsafePinned<()>` to get the same// effect, but we can't add a new field to an already stable unit struct -- that would be a breaking// change."destruct"/// A marker for types that can be dropped./// This should be used for `[const]` bounds,/// as non-const bounds will always hold for every type."tuple_trait"/// A marker for tuple types./// The implementation of this trait is built-in and cannot be implemented/// for any user type."const_param_ty"ConstParamTy_/// A marker for types which can be used as types of `const` generic parameters./// These types must have a proper equivalence relation (`Eq`) and it must be automatically/// derived (`StructuralPartialEq`). There's a hard-coded check in the compiler ensuring/// that all fields are also `ConstParamTy`, which implies that recursively, all fields/// are `StructuralPartialEq`.// We name this differently than the derive macro so that the `adt_const_params` can// be used independently of `unsized_const_params` without requiring a full path// to the derive macro every time it is used. This should be renamed on stabilization./// Derive macro generating an impl of the trait `ConstParamTy`.// FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`"fn_ptr_addr"/// Returns the address of the function pointer."fn_ptr_trait"FnPtr/// A common trait implemented by all function pointers.// Note that while the trait is internal and unstable it is nevertheless// exposed as a public bound of the stable `core::ptr::fn_addr_eq` function."CoercePointee"CoercePointee/// Derive macro that makes a smart pointer usable with trait objects./// # What this macro does/// This macro is intended to be used with user-defined pointer types, and makes it possible to/// perform coercions on the pointee of the user-defined pointer. There are two aspects to this:/// ## Unsizing coercions of the pointee/// By using the macro, the following example will compile:/// #![feature(derive_coerce_pointee)]/// use std::marker::CoercePointee;/// #[derive(CoercePointee)]/// struct MySmartPointer<T: ?Sized>(Box<T>);/// impl<T: ?Sized> Deref for MySmartPointer<T> {///     type Target = T;///     fn deref(&self) -> &T {/// impl MyTrait for i32 {}///     let ptr: MySmartPointer<i32> = MySmartPointer(Box::new(4));///     // This coercion would be an error without the derive.///     let ptr: MySmartPointer<dyn MyTrait> = ptr;/// Without the `#[derive(CoercePointee)]` macro, this example would fail with the following error:/// error[E0308]: mismatched types///   --> src/main.rs:11:44/// 11 |     let ptr: MySmartPointer<dyn MyTrait> = ptr;///    |              ---------------------------   ^^^ expected `MySmartPointer<dyn MyTrait>`, found `MySmartPointer<i32>`///    |              |///    |              expected due to this///    = note: expected struct `MySmartPointer<dyn MyTrait>`///               found struct `MySmartPointer<i32>`///    = help: `i32` implements `MyTrait` so you could box the found value and coerce it to the trait object `Box<dyn MyTrait>`, you will have to change the expected type as well/// ## Dyn compatibility/// This macro allows you to dispatch on the user-defined pointer type. That is, traits using the/// type as a receiver are dyn-compatible. For example, this compiles:/// #![feature(arbitrary_self_types, derive_coerce_pointee)]/// // You can always define this trait. (as long as you have #![feature(arbitrary_self_types)])/// trait MyTrait {///     fn func(self: MySmartPointer<Self>);/// // But using `dyn MyTrait` requires #[derive(CoercePointee)]./// fn call_func(value: MySmartPointer<dyn MyTrait>) {///     value.func();/// If you remove the `#[derive(CoercePointee)]` annotation from the struct, then the above example/// will fail with this error message:/// error[E0038]: the trait `MyTrait` is not dyn compatible///   --> src/lib.rs:21:36/// 17 |     fn func(self: MySmartPointer<Self>);///    |                   -------------------- help: consider changing method `func`'s `self` parameter to be `&self`: `&Self`/// 21 | fn call_func(value: MySmartPointer<dyn MyTrait>) {///    |                                    ^^^^^^^^^^^ `MyTrait` is not dyn compatible/// note: for a trait to be dyn compatible it needs to allow building a vtable///       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>///   --> src/lib.rs:17:19/// 16 | trait MyTrait {///    |       ------- this trait is not dyn compatible...///    |                   ^^^^^^^^^^^^^^^^^^^^ ...because method `func`'s `self` parameter cannot be dispatched on/// # Requirements for using the macro/// This macro can only be used if:/// * The type is a `#[repr(transparent)]` struct./// * The type of its non-zero-sized field must either be a standard library pointer type///   (reference, raw pointer, `NonNull`, `Box`, `Rc`, `Arc`, etc.) or another user-defined type///   also using the `#[derive(CoercePointee)]` macro./// * Zero-sized fields must not mention any generic parameters unless the zero-sized field has///   type [`PhantomData`]./// ## Multiple type parameters/// If the type has multiple type parameters, then you must explicitly specify which one should be/// used for dynamic dispatch. For example:/// # #![feature(derive_coerce_pointee)]/// # use std::marker::{CoercePointee, PhantomData};/// struct MySmartPointer<#[pointee] T: ?Sized, U> {///     ptr: Box<T>,///     _phantom: PhantomData<U>,/// Specifying `#[pointee]` when the struct has only one type parameter is allowed, but not required./// A custom implementation of the `Rc` type:/// pub struct Rc<T: ?Sized> {///     inner: NonNull<RcInner<T>>,/// struct RcInner<T: ?Sized> {///     refcount: usize,///     value: T,/// impl<T: ?Sized> Deref for Rc<T> {///         let ptr = self.inner.as_ptr();///         unsafe { &(*ptr).value }/// impl<T> Rc<T> {///     pub fn new(value: T) -> Self {///         let inner = Box::new(RcInner {///             refcount: 1,///             value,///             inner: NonNull::from(Box::leak(inner)),/// impl<T: ?Sized> Clone for Rc<T> {///         // A real implementation would handle overflow here.///         unsafe { (*self.inner.as_ptr()).refcount += 1 };///         Self { inner: self.inner }/// impl<T: ?Sized> Drop for Rc<T> {///         unsafe { (*ptr).refcount -= 1 };///         if unsafe { (*ptr).refcount } == 0 {///             drop(unsafe { Box::from_raw(ptr) });/* compiler built-in */"coerce_pointee_validated"CoercePointeeValidated/// A trait that is implemented for ADTs with `derive(CoercePointee)` so that/// the compiler can enforce the derive impls are valid post-expansion, since/// the derive has stricter requirements than if the impls were written by hand./// This trait is not intended to be implemented by users or used other than/// validation, so it should never be stabilized.//! Primitive traits and types representing basic properties of types.//! Rust types can be classified in various useful ways according to//! their intrinsic properties. These classifications are represented//! as traits.// NOTE: for consistent error messages between `core` and `minicore`, all `diagnostic` attributes// should be replicated exactly in `minicore` (if `minicore` defines the item)./// Wrap a value and run a closure when dropped./// This is useful for quickly creating destructors inline./// # #![allow(unused)]/// #![feature(drop_guard)]/// use std::mem::DropGuard;///     // Create a new guard around a string that will///     // print its value when dropped.///     let s = String::from("Chashu likes tuna");///     let mut s = DropGuard::new(s, |s| println!("{s}"));///     // Modify the string contained in the guard.///     s.push_str("!!!");///     // The guard will be dropped here, printing:///     // "Chashu likes tuna!!!"/// Create a new instance of `DropGuard`./// let value = String::from("Chashu likes tuna");/// let guard = DropGuard::new(value, |s| println!("{s}"));/// Consumes the `DropGuard`, returning the wrapped value./// This will not execute the closure. It is typically preferred to call/// this function instead of `mem::forget` because it will return the stored/// value and drop variables captured by the closure instead of leaking their/// owned resources./// let value = String::from("Nori likes chicken");/// assert_eq!(guard.dismiss(), "Nori likes chicken");"manually_drop"/// A wrapper to inhibit the compiler from automatically calling `T`’s/// destructor. This wrapper is 0-cost./// `ManuallyDrop<T>` is guaranteed to have the same layout and bit validity as/// `T`, and is subject to the same layout optimizations as `T`. As a/// consequence, it has *no effect* on the assumptions that the compiler makes/// about its contents. For example, initializing a `ManuallyDrop<&mut T>` with/// [`mem::zeroed`] is undefined behavior. If you need to handle uninitialized/// data, use [`MaybeUninit<T>`] instead./// Note that accessing the value inside a `ManuallyDrop<T>` is safe. This means/// that a `ManuallyDrop<T>` whose content has been dropped must not be exposed/// through a public safe API. Correspondingly, `ManuallyDrop::drop` is unsafe./// # `ManuallyDrop` and drop order/// Rust has a well-defined [drop order] of values. To make sure that fields or/// locals are dropped in a specific order, reorder the declarations such that/// the implicit drop order is the correct one./// It is possible to use `ManuallyDrop` to control the drop order, but this/// requires unsafe code and is hard to do correctly in the presence of/// unwinding./// For example, if you want to make sure that a specific field is dropped after/// the others, make it the last field of a struct:/// struct Context;/// struct Widget {///     children: Vec<Widget>,///     // `context` will be dropped after `children`.///     // Rust guarantees that fields are dropped in the order of declaration.///     context: Context,/// # Interaction with `Box`/// Currently, if you have a `ManuallyDrop<T>`, where the type `T` is a `Box` or/// contains a `Box` inside, then dropping the `T` followed by moving the/// `ManuallyDrop<T>` is [considered to be undefined/// behavior](https://github.com/rust-lang/unsafe-code-guidelines/issues/245)./// That is, the following code causes undefined behavior:/// let mut x = ManuallyDrop::new(Box::new(42));///     ManuallyDrop::drop(&mut x);/// let y = x; // Undefined behavior!/// This is [likely to change in the/// future](https://rust-lang.github.io/rfcs/3336-maybe-dangling.html). In the/// meantime, consider using [`MaybeUninit`] instead./// # Safety hazards when storing `ManuallyDrop` in a struct or an enum./// Special care is needed when all of the conditions below are met:/// * A struct or enum contains a `ManuallyDrop`./// * The `ManuallyDrop` is not inside a `union`./// * The struct or enum is part of public API, or is stored in a struct or an///   enum that is part of public API./// * There is code that drops the contents of the `ManuallyDrop` field, and///   this code is outside the struct or enum's `Drop` implementation./// In particular, the following hazards may occur:/// #### Storing generic types/// If the `ManuallyDrop` contains a client-supplied generic type, the client/// might provide a `Box` as that type. This would cause undefined behavior when/// the struct or enum is later moved, as mentioned in the previous section. For/// example, the following code causes undefined behavior:/// pub struct BadOption<T> {///     // Invariant: Has been dropped if `is_some` is false.///     value: ManuallyDrop<T>,///     is_some: bool,/// impl<T> BadOption<T> {///         Self { value: ManuallyDrop::new(value), is_some: true }///     pub fn change_to_none(&mut self) {///         if self.is_some {///             self.is_some = false;///             unsafe {///                 // SAFETY: `value` hasn't been dropped yet, as per the invariant///                 // (This is actually unsound!)///                 ManuallyDrop::drop(&mut self.value);/// // In another crate:/// let mut option = BadOption::new(Box::new(42));/// option.change_to_none();/// let option2 = option; // Undefined behavior!/// #### Deriving traits/// Deriving `Debug`, `Clone`, `PartialEq`, `PartialOrd`, `Ord`, or `Hash` on/// the struct or enum could be unsound, since the derived implementations of/// these traits would access the `ManuallyDrop` field. For example, the/// following code causes undefined behavior:/// // This derive is unsound in combination with the `ManuallyDrop::drop` call./// pub struct Foo {///     value: ManuallyDrop<String>,///         let mut temp = Self {///             value: ManuallyDrop::new(String::from("Unsafe rust is hard."))///             // SAFETY: `value` hasn't been dropped yet.///             ManuallyDrop::drop(&mut temp.value);///         temp/// let foo = Foo::new();/// println!("{:?}", foo); // Undefined behavior!/// [drop order]: https://doc.rust-lang.org/reference/destructors.html/// [`mem::zeroed`]: crate::mem::zeroed/// [`MaybeUninit<T>`]: crate::mem::MaybeUninit/// [`MaybeUninit`]: crate::mem::MaybeUninit"if you don't need the wrapper, you can use `mem::forget` instead"/// Wrap a value to be manually dropped./// let mut x = ManuallyDrop::new(String::from("Hello World!"));/// x.truncate(5); // You can still safely operate on the value/// assert_eq!(*x, "Hello");/// // But `Drop` will not be run here/// # let _ = ManuallyDrop::into_inner(x);/// Extracts the value from the `ManuallyDrop` container./// This allows the value to be dropped again./// let x = ManuallyDrop::new(Box::new(()));/// let _: Box<()> = ManuallyDrop::into_inner(x); // This drops the `Box`."if you don't need the value, you can use `ManuallyDrop::drop` instead"/// Takes the value from the `ManuallyDrop<T>` container out./// This method is primarily intended for moving out values in drop./// Instead of using [`ManuallyDrop::drop`] to manually drop the value,/// you can use this method to take the value and use it however desired./// Whenever possible, it is preferable to use [`into_inner`][`ManuallyDrop::into_inner`]/// instead, which prevents duplicating the content of the `ManuallyDrop<T>`./// This function semantically moves out the contained value without preventing further usage,/// leaving the state of this container unchanged./// It is your responsibility to ensure that this `ManuallyDrop` is not used again./// Manually drops the contained value./// This is exactly equivalent to calling [`ptr::drop_in_place`] with a/// pointer to the contained value. As such, unless the contained value is a/// packed struct, the destructor will be called in-place without moving the/// value, and thus can be used to safely drop [pinned] data./// If you have ownership of the value, you can use [`ManuallyDrop::into_inner`] instead./// This function runs the destructor of the contained value. Other than changes made by/// the destructor itself, the memory is left unchanged, and so as far as the compiler is/// concerned still holds a bit-pattern which is valid for the type `T`./// However, this "zombie" value should not be exposed to safe code, and this function/// should not be called more than once. To use a value after it's been dropped, or drop/// a value multiple times, can cause Undefined Behavior (depending on what `drop` does)./// This is normally prevented by the type system, but users of `ManuallyDrop` must/// uphold those guarantees without assistance from the compiler./// [pinned]: crate::pin"maybe_uninit"/// # Initialization invariant/// The compiler, in general, assumes that a variable is properly initialized/// according to the requirements of the variable's type. For example, a variable of/// reference type must be aligned and non-null. This is an invariant that must/// *always* be upheld, even in unsafe code. As a consequence, zero-initializing a/// variable of reference type causes instantaneous [undefined behavior][ub],/// no matter whether that reference ever gets used to access memory:/// # #![allow(invalid_value)]/// use std::mem::{self, MaybeUninit};/// let x: &i32 = unsafe { mem::zeroed() }; // undefined behavior! ⚠️/// // The equivalent code with `MaybeUninit<&i32>`:/// let x: &i32 = unsafe { MaybeUninit::zeroed().assume_init() }; // undefined behavior! ⚠️/// This is exploited by the compiler for various optimizations, such as eliding/// run-time checks and optimizing `enum` layout./// Similarly, entirely uninitialized memory may have any content, while a `bool` must/// always be `true` or `false`. Hence, creating an uninitialized `bool` is undefined behavior:/// let b: bool = unsafe { mem::uninitialized() }; // undefined behavior! ⚠️/// // The equivalent code with `MaybeUninit<bool>`:/// let b: bool = unsafe { MaybeUninit::uninit().assume_init() }; // undefined behavior! ⚠️/// Moreover, uninitialized memory is special in that it does not have a fixed value ("fixed"/// meaning "it won't change without being written to"). Reading the same uninitialized byte/// multiple times can give different results. This makes it undefined behavior to have/// uninitialized data in a variable even if that variable has an integer type, which otherwise can/// hold any *fixed* bit pattern:/// let x: i32 = unsafe { mem::uninitialized() }; // undefined behavior! ⚠️/// // The equivalent code with `MaybeUninit<i32>`:/// let x: i32 = unsafe { MaybeUninit::uninit().assume_init() }; // undefined behavior! ⚠️/// On top of that, remember that most types have additional invariants beyond merely/// being considered initialized at the type level. For example, a `1`-initialized [`Vec<T>`]/// is considered initialized (under the current implementation; this does not constitute/// a stable guarantee) because the only requirement the compiler knows about it/// is that the data pointer must be non-null. Creating such a `Vec<T>` does not cause/// *immediate* undefined behavior, but will cause undefined behavior with most/// safe operations (including dropping it)./// `MaybeUninit<T>` serves to enable unsafe code to deal with uninitialized data./// It is a signal to the compiler indicating that the data here might *not*/// be initialized:/// // Create an explicitly uninitialized reference. The compiler knows that data inside/// // a `MaybeUninit<T>` may be invalid, and hence this is not UB:/// let mut x = MaybeUninit::<&i32>::uninit();/// // Set it to a valid value./// x.write(&0);/// // Extract the initialized data -- this is only allowed *after* properly/// // initializing `x`!/// let x = unsafe { x.assume_init() };/// The compiler then knows to not make any incorrect assumptions or optimizations on this code./// You can think of `MaybeUninit<T>` as being a bit like `Option<T>` but without/// any of the run-time tracking and without any of the safety checks./// ## out-pointers/// You can use `MaybeUninit<T>` to implement "out-pointers": instead of returning data/// from a function, pass it a pointer to some (uninitialized) memory to put the/// result into. This can be useful when it is important for the caller to control/// how the memory the result is stored in gets allocated, and you want to avoid/// unnecessary moves./// unsafe fn make_vec(out: *mut Vec<i32>) {///     // `write` does not drop the old contents, which is important.///     unsafe { out.write(vec![1, 2, 3]); }/// let mut v = MaybeUninit::uninit();/// unsafe { make_vec(v.as_mut_ptr()); }/// // Now we know `v` is initialized! This also makes sure the vector gets/// // properly dropped./// let v = unsafe { v.assume_init() };/// assert_eq!(&v, &[1, 2, 3]);/// ## Initializing an array element-by-element/// `MaybeUninit<T>` can be used to initialize a large array element-by-element:/// let data = {///     // Create an uninitialized array of `MaybeUninit`.///     let mut data: [MaybeUninit<Vec<u32>>; 1000] = [const { MaybeUninit::uninit() }; 1000];///     // Dropping a `MaybeUninit` does nothing, so if there is a panic during this loop,///     // we have a memory leak, but there is no memory safety issue.///     for elem in &mut data[..] {///         elem.write(vec![42]);///     // Everything is initialized. Transmute the array to the///     // initialized type.///     unsafe { mem::transmute::<_, [Vec<u32>; 1000]>(data) }/// assert_eq!(&data[0], &[42]);/// You can also work with partially initialized arrays, which could/// be found in low-level datastructures./// // Create an uninitialized array of `MaybeUninit`./// let mut data: [MaybeUninit<String>; 1000] = [const { MaybeUninit::uninit() }; 1000];/// // Count the number of elements we have assigned./// let mut data_len: usize = 0;/// for elem in &mut data[0..500] {///     elem.write(String::from("hello"));///     data_len += 1;/// // For each item in the array, drop if we allocated it./// for elem in &mut data[0..data_len] {///     unsafe { elem.assume_init_drop(); }/// ## Initializing a struct field-by-field/// You can use `MaybeUninit<T>`, and the [`std::ptr::addr_of_mut`] macro, to initialize structs field by field:/// use std::ptr::addr_of_mut;///     list: Vec<u8>,/// let foo = {///     let mut uninit: MaybeUninit<Foo> = MaybeUninit::uninit();///     let ptr = uninit.as_mut_ptr();///     // Initializing the `name` field///     // Using `write` instead of assignment via `=` to not call `drop` on the///     // old, uninitialized value.///     unsafe { addr_of_mut!((*ptr).name).write("Bob".to_string()); }///     // Initializing the `list` field///     // If there is a panic here, then the `String` in the `name` field leaks.///     unsafe { addr_of_mut!((*ptr).list).write(vec![0, 1, 2]); }///     // All the fields are initialized, so we call `assume_init` to get an initialized Foo.///     unsafe { uninit.assume_init() }///     foo,///     Foo {///         name: "Bob".to_string(),///         list: vec![0, 1, 2]/// [`std::ptr::addr_of_mut`]: crate::ptr::addr_of_mut/// `MaybeUninit<T>` is guaranteed to have the same size, alignment, and ABI as `T`:/// assert_eq!(size_of::<MaybeUninit<u64>>(), size_of::<u64>());/// assert_eq!(align_of::<MaybeUninit<u64>>(), align_of::<u64>());/// However remember that a type *containing* a `MaybeUninit<T>` is not necessarily the same/// layout; Rust does not in general guarantee that the fields of a `Foo<T>` have the same order as/// a `Foo<U>` even if `T` and `U` have the same size and alignment. Furthermore because any bit/// value is valid for a `MaybeUninit<T>` the compiler can't apply non-zero/niche-filling/// optimizations, potentially resulting in a larger size:/// assert_eq!(size_of::<Option<bool>>(), 1);/// assert_eq!(size_of::<Option<MaybeUninit<bool>>>(), 2);/// If `T` is FFI-safe, then so is `MaybeUninit<T>`./// While `MaybeUninit` is `#[repr(transparent)]` (indicating it guarantees the same size,/// alignment, and ABI as `T`), this does *not* change any of the previous caveats. `Option<T>` and/// `Option<MaybeUninit<T>>` may still have different sizes, and types containing a field of type/// `T` may be laid out (and sized) differently than if that field were `MaybeUninit<T>`./// `MaybeUninit` is a union type, and `#[repr(transparent)]` on unions is unstable (see [the/// tracking issue](https://github.com/rust-lang/rust/issues/60405)). Over time, the exact/// guarantees of `#[repr(transparent)]` on unions may evolve, and `MaybeUninit` may or may not/// remain `#[repr(transparent)]`. That said, `MaybeUninit<T>` will *always* guarantee that it has/// the same size, alignment, and ABI as `T`; it's just that the way `MaybeUninit` implements that/// guarantee may evolve./// Note that even though `T` and `MaybeUninit<T>` are ABI compatible it is still unsound to/// transmute `&mut T` to `&mut MaybeUninit<T>` and expose that to safe code because it would allow/// safe code to access uninitialized memory:/// fn unsound_transmute<T>(val: &mut T) -> &mut MaybeUninit<T> {///     unsafe { core::mem::transmute(val) }///     let mut code = 0;///     let code = &mut code;///     let code2 = unsound_transmute(code);///     *code2 = MaybeUninit::uninit();///     std::process::exit(*code); // UB! Accessing uninitialized memory./// `MaybeUninit<T>` has no validity requirements –- any sequence of [bytes] of/// the appropriate length, initialized or uninitialized, are a valid/// Moving or copying a value of type `MaybeUninit<T>` (i.e., performing a/// "typed copy") will exactly preserve the contents, including the/// [provenance], of all non-padding bytes of type `T` in the value's/// Therefore `MaybeUninit` can be used to perform a round trip of a value from/// type `T` to type `MaybeUninit<U>` then back to type `T`, while preserving/// the original value, if two conditions are met. One, type `U` must have the/// same size as type `T`. Two, for all byte offsets where type `U` has padding,/// the corresponding bytes in the representation of the value must be/// uninitialized./// For example, due to the fact that the type `[u8; size_of::<T>]` has no/// padding, the following is sound for any type `T` and will return the/// original value:/// # use core::mem::{MaybeUninit, transmute};/// # struct T;/// fn identity(t: T) -> T {///         let u: MaybeUninit<[u8; size_of::<T>()]> = transmute(t);///         transmute(u) // OK./// Note: Copying a value that contains references may implicitly reborrow them/// causing the provenance of the returned value to differ from that of the/// original. This applies equally to the trivial identity function:/// fn trivial_identity<T>(t: T) -> T { t }/// Note: Moving or copying a value whose representation has initialized bytes/// at byte offsets where the type has padding may lose the value of those/// bytes, so while the original value will be preserved, the original/// *representation* of that value as bytes may not be. Again, this applies/// equally to `trivial_identity`./// Note: Performing this round trip when type `U` has padding at byte offsets/// where the representation of the original value has initialized bytes may/// produce undefined behavior or a different value. For example, the following/// is unsound since `T` requires all bytes to be initialized:/// #[repr(C)] struct T([u8; 4]);/// #[repr(C)] struct U(u8, u16);/// fn unsound_identity(t: T) -> T {///         let u: MaybeUninit<U> = transmute(t);///         transmute(u) // UB./// Conversely, the following is sound since `T` allows uninitialized bytes in/// the representation of a value, but the round trip may alter the value:/// #[repr(C)] struct T(MaybeUninit<[u8; 4]>);/// fn non_identity(t: T) -> T {///         // May lose an initialized byte.///         transmute(u)/// [bytes]: ../../reference/memory-model.html#bytes/// [provenance]: crate::ptr#provenance// Lang item so we can wrap other types in it. This is useful for coroutines.// SAFETY: the clone implementation is a copy, see above."use `forget` to avoid running Drop code"/// Creates a new `MaybeUninit<T>` initialized with the given value./// It is safe to call [`assume_init`] on the return value of this function./// Note that dropping a `MaybeUninit<T>` will never call `T`'s drop code./// It is your responsibility to make sure `T` gets dropped if it got initialized./// let v: MaybeUninit<Vec<u8>> = MaybeUninit::new(vec![42]);/// # // Prevent leaks for Miri/// # unsafe { let _ = MaybeUninit::assume_init(v); }/// [`assume_init`]: MaybeUninit::assume_init"maybe_uninit_uninit"/// Creates a new `MaybeUninit<T>` in an uninitialized state./// See the [type-level documentation][MaybeUninit] for some examples./// let v: MaybeUninit<String> = MaybeUninit::uninit();"maybe_uninit_zeroed"/// Creates a new `MaybeUninit<T>` in an uninitialized state, with the memory being/// filled with `0` bytes. It depends on `T` whether that already makes for/// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,/// but `MaybeUninit<&'static i32>::zeroed()` is not because references must not/// be null./// Note that if `T` has padding bytes, those bytes are *not* preserved when the/// `MaybeUninit<T>` value is returned from this function, so those bytes will *not* be zeroed./// Correct usage of this function: initializing a struct with zero, where all/// fields of the struct can hold the bit-pattern 0 as a valid value./// let x = MaybeUninit::<(u8, bool)>::zeroed();/// assert_eq!(x, (0, false));/// This can be used in const contexts, such as to indicate the end of static arrays for/// plugin registration./// *Incorrect* usage of this function: calling `x.zeroed().assume_init()`/// when `0` is not a valid bit-pattern for the type:/// enum NotZero { One = 1, Two = 2 }/// let x = MaybeUninit::<(u8, NotZero)>::zeroed();/// // Inside a pair, we create a `NotZero` that does not have a valid discriminant./// // This is undefined behavior. ⚠️/// Sets the value of the `MaybeUninit<T>`./// This overwrites any previous value without dropping it, so be careful/// not to use this twice unless you want to skip running the destructor./// For your convenience, this also returns a mutable reference to the/// (now safely initialized) contents of `self`./// As the content is stored inside a `ManuallyDrop`, the destructor is not/// run for the inner data if the MaybeUninit leaves scope without a call to/// [`assume_init`], [`assume_init_drop`], or similar. Code that receives/// the mutable reference returned by this function needs to keep this in/// mind. The safety model of Rust regards leaks as safe, but they are/// usually still undesirable. This being said, the mutable reference/// behaves like any other mutable reference would, so assigning a new value/// to it will drop the old content./// [`assume_init`]: Self::assume_init/// [`assume_init_drop`]: Self::assume_init_drop/// Correct usage of this method:/// let mut x = MaybeUninit::<Vec<u8>>::uninit();///     let hello = x.write((&b"Hello, world!").to_vec());///     // Setting hello does not leak prior allocations, but drops them///     *hello = (&b"Hello").to_vec();///     hello[0] = 'h' as u8;/// // x is initialized now:/// let s = unsafe { x.assume_init() };/// assert_eq!(b"hello", s.as_slice());/// This usage of the method causes a leak:/// let mut x = MaybeUninit::<String>::uninit();/// x.write("Hello".to_string());/// # unsafe { MaybeUninit::assume_init_drop(&mut x); }/// // This leaks the contained string:/// x.write("hello".to_string());/// This method can be used to avoid unsafe in some cases. The example below/// shows a part of an implementation of a fixed sized arena that lends out/// pinned references./// With `write`, we can avoid the need to write through a raw pointer:/// use core::pin::Pin;/// struct PinArena<T> {///     memory: Box<[MaybeUninit<T>]>,/// impl <T> PinArena<T> {///     pub fn capacity(&self) -> usize {///         self.memory.len()///     pub fn push(&mut self, val: T) -> Pin<&mut T> {///         if self.len >= self.capacity() {///             panic!("Attempted to push to a full pin arena!");///         let ref_ = self.memory[self.len].write(val);///         self.len += 1;///         unsafe { Pin::new_unchecked(ref_) }/// Gets a pointer to the contained value. Reading from this pointer or turning it/// into a reference is undefined behavior unless the `MaybeUninit<T>` is initialized./// Writing to memory that this pointer (non-transitively) points to is undefined behavior/// (except inside an `UnsafeCell<T>`)./// let mut x = MaybeUninit::<Vec<u32>>::uninit();/// x.write(vec![0, 1, 2]);/// // Create a reference into the `MaybeUninit<T>`. This is okay because we initialized it./// let x_vec = unsafe { &*x.as_ptr() };/// assert_eq!(x_vec.len(), 3);/// *Incorrect* usage of this method:/// let x = MaybeUninit::<Vec<u32>>::uninit();/// // We have created a reference to an uninitialized vector! This is undefined behavior. ⚠️/// (Notice that the rules around references to uninitialized data are not finalized yet, but/// until they are, it is advisable to avoid them.)/// Gets a mutable pointer to the contained value. Reading from this pointer or turning it/// // Create a reference into the `MaybeUninit<Vec<u32>>`./// // This is okay because we initialized it./// let x_vec = unsafe { &mut *x.as_mut_ptr() };/// x_vec.push(3);/// assert_eq!(x_vec.len(), 4);"assume_init"/// Extracts the value from the `MaybeUninit<T>` container. This is a great way/// to ensure that the data will get dropped, because the resulting `T` is/// subject to the usual drop handling./// It is up to the caller to guarantee that the `MaybeUninit<T>` really is in an initialized/// state. Calling this when the content is not yet fully initialized causes immediate undefined/// behavior. The [type-level documentation][inv] contains more information about/// this initialization invariant./// [inv]: #initialization-invariant/// let mut x = MaybeUninit::<bool>::uninit();/// x.write(true);/// let x_init = unsafe { x.assume_init() };/// assert_eq!(x_init, true);/// // `x` had not been initialized yet, so this last line caused undefined behavior. ⚠️assume_init_read/// Reads the value from the `MaybeUninit<T>` container. The resulting `T` is subject/// to the usual drop handling./// Whenever possible, it is preferable to use [`assume_init`] instead, which/// prevents duplicating the content of the `MaybeUninit<T>`./// state. Calling this when the content is not yet fully initialized causes undefined/// Moreover, similar to the [`ptr::read`] function, this function creates a/// bitwise copy of the contents, regardless whether the contained type/// implements the [`Copy`] trait or not. When using multiple copies of the/// data (by calling `assume_init_read` multiple times, or first calling/// `assume_init_read` and then [`assume_init`]), it is your responsibility/// to ensure that data may indeed be duplicated./// let mut x = MaybeUninit::<u32>::uninit();/// x.write(13);/// let x1 = unsafe { x.assume_init_read() };/// // `u32` is `Copy`, so we may read multiple times./// let x2 = unsafe { x.assume_init_read() };/// assert_eq!(x1, x2);/// let mut x = MaybeUninit::<Option<Vec<u32>>>::uninit();/// x.write(None);/// // Duplicating a `None` value is okay, so we may read multiple times./// x.write(Some(vec![0, 1, 2]));/// // We now created two copies of the same vector, leading to a double-free ⚠️ when/// // they both get dropped!assume_init_drop/// Drops the contained value in place./// If you have ownership of the `MaybeUninit`, you can also use/// [`assume_init`] as an alternative./// It is up to the caller to guarantee that the `MaybeUninit<T>` really is/// in an initialized state. Calling this when the content is not yet fully/// initialized causes undefined behavior./// On top of that, all additional invariants of the type `T` must be/// satisfied, as the `Drop` implementation of `T` (or its members) may/// rely on this. For example, setting a `Vec<T>` to an invalid but/// non-null address makes it initialized (under the current implementation;/// this does not constitute a stable guarantee), because the only/// requirement the compiler knows about it is that the data pointer must be/// non-null. Dropping such a `Vec<T>` however will cause undefinedassume_init_ref/// Gets a shared reference to the contained value./// This can be useful when we want to access a `MaybeUninit` that has been/// initialized but don't have ownership of the `MaybeUninit` (preventing the use/// of `.assume_init()`)./// Calling this when the content is not yet fully initialized causes undefined/// behavior: it is up to the caller to guarantee that the `MaybeUninit<T>` really/// is in an initialized state./// ### Correct usage of this method:/// # let mut x_mu = x;/// # let mut x = &mut x_mu;/// // Initialize `x`:/// x.write(vec![1, 2, 3]);/// // Now that our `MaybeUninit<_>` is known to be initialized, it is okay to/// // create a shared reference to it:/// let x: &Vec<u32> = unsafe {///     // SAFETY: `x` has been initialized.///     x.assume_init_ref()/// assert_eq!(x, &vec![1, 2, 3]);/// # unsafe { MaybeUninit::assume_init_drop(&mut x_mu); }/// ### *Incorrect* usages of this method:/// let x_vec: &Vec<u32> = unsafe { x.assume_init_ref() };/// use std::{cell::Cell, mem::MaybeUninit};/// let b = MaybeUninit::<Cell<bool>>::uninit();/// // Initialize the `MaybeUninit` using `Cell::set`:///     b.assume_init_ref().set(true);///     //^^^^^^^^^^^^^^^ Reference to an uninitialized `Cell<bool>`: UB!assume_init_mut/// Gets a mutable (unique) reference to the contained value./// is in an initialized state. For instance, `.assume_init_mut()` cannot be used to/// initialize a `MaybeUninit`./// # #![allow(unexpected_cfgs)]/// # unsafe extern "C" fn initialize_buffer(buf: *mut [u8; 1024]) { unsafe { *buf = [0; 1024] } }/// # #[cfg(FALSE)]///     /// Initializes *all* the bytes of the input buffer.///     fn initialize_buffer(buf: *mut [u8; 1024]);/// let mut buf = MaybeUninit::<[u8; 1024]>::uninit();/// // Initialize `buf`:/// unsafe { initialize_buffer(buf.as_mut_ptr()); }/// // Now we know that `buf` has been initialized, so we could `.assume_init()` it./// // However, using `.assume_init()` may trigger a `memcpy` of the 1024 bytes./// // To assert our buffer has been initialized without copying it, we upgrade/// // the `&mut MaybeUninit<[u8; 1024]>` to a `&mut [u8; 1024]`:/// let buf: &mut [u8; 1024] = unsafe {///     // SAFETY: `buf` has been initialized.///     buf.assume_init_mut()/// // Now we can use `buf` as a normal slice:/// buf.sort_unstable();///     buf.windows(2).all(|pair| pair[0] <= pair[1]),///     "buffer is sorted",/// You cannot use `.assume_init_mut()` to initialize a value:/// let mut b = MaybeUninit::<bool>::uninit();///     *b.assume_init_mut() = true;///     // We have created a (mutable) reference to an uninitialized `bool`!///     // This is undefined behavior. ⚠️/// For instance, you cannot [`Read`] into an uninitialized buffer:/// [`Read`]: ../../std/io/trait.Read.html/// use std::{io, mem::MaybeUninit};/// fn read_chunk (reader: &'_ mut dyn io::Read) -> io::Result<[u8; 64]>///     let mut buffer = MaybeUninit::<[u8; 64]>::uninit();///     reader.read_exact(unsafe { buffer.assume_init_mut() })?;///     //                         ^^^^^^^^^^^^^^^^^^^^^^^^///     // (mutable) reference to uninitialized memory!///     // This is undefined behavior.///     Ok(unsafe { buffer.assume_init() })/// Nor can you use direct field access to do field-by-field gradual initialization:/// use std::{mem::MaybeUninit, ptr};/// let foo: Foo = unsafe {///     let mut foo = MaybeUninit::<Foo>::uninit();///     ptr::write(&mut foo.assume_init_mut().a as *mut u32, 1337);///     //              ^^^^^^^^^^^^^^^^^^^^^///     ptr::write(&mut foo.assume_init_mut().b as *mut u8, 42);///     foo.assume_init()array_assume_init/// Extracts the values from an array of `MaybeUninit` containers./// It is up to the caller to guarantee that all elements of the array are/// in an initialized state./// #![feature(maybe_uninit_array_assume_init)]/// let mut array: [MaybeUninit<i32>; 3] = [MaybeUninit::uninit(); 3];/// array[0].write(0);/// array[1].write(1);/// array[2].write(2);/// // SAFETY: Now safe as we initialised all elements/// let array = unsafe {///     MaybeUninit::array_assume_init(array)/// assert_eq!(array, [0, 1, 2]);/// Returns the contents of this `MaybeUninit` as a slice of potentially uninitialized bytes./// Note that even if the contents of a `MaybeUninit` have been initialized, the value may still/// contain padding bytes which are left uninitialized./// #![feature(maybe_uninit_as_bytes)]/// let val = 0x12345678_i32;/// let uninit = MaybeUninit::new(val);/// let uninit_bytes = uninit.as_bytes();/// let bytes = unsafe { uninit_bytes.assume_init_ref() };/// assert_eq!(bytes, val.to_ne_bytes());/// Returns the contents of this `MaybeUninit` as a mutable slice of potentially uninitialized/// let mut uninit = MaybeUninit::new(val);/// let uninit_bytes = uninit.as_bytes_mut();///     uninit_bytes[0].write(0xcd);///     uninit_bytes[3].write(0xcd);/// let val2 = unsafe { uninit.assume_init() };/// assert_eq!(val2, 0x123456cd);write_copy_of_slice/// Copies the elements from `src` to `self`,/// returning a mutable reference to the now initialized contents of `self`./// If `T` does not implement `Copy`, use [`write_clone_of_slice`] instead./// This is similar to [`slice::copy_from_slice`]./// let mut dst = [MaybeUninit::uninit(); 32];/// let src = [0; 32];/// let init = dst.write_copy_of_slice(&src);/// assert_eq!(init, src);/// let mut vec = Vec::with_capacity(32);/// let src = [0; 16];/// vec.spare_capacity_mut()[..src.len()].write_copy_of_slice(&src);/// // SAFETY: we have just copied all the elements of len into the spare capacity/// // the first src.len() elements of the vec are valid now.///     vec.set_len(src.len());/// assert_eq!(vec, src);/// [`write_clone_of_slice`]: slice::write_clone_of_slicewrite_clone_of_slice/// Clones the elements from `src` to `self`,/// Any already initialized elements will not be dropped./// If `T` implements `Copy`, use [`write_copy_of_slice`] instead./// This is similar to [`slice::clone_from_slice`] but does not drop existing elements./// This function will panic if the two slices have different lengths, or if the implementation of `Clone` panics./// If there is a panic, the already cloned elements will be dropped./// let mut dst = [const { MaybeUninit::uninit() }; 5];/// let src = ["wibbly", "wobbly", "timey", "wimey", "stuff"].map(|s| s.to_string());/// let init = dst.write_clone_of_slice(&src);/// # unsafe { std::ptr::drop_in_place(init); }/// let src = ["rust", "is", "a", "pretty", "cool", "language"].map(|s| s.to_string());/// vec.spare_capacity_mut()[..src.len()].write_clone_of_slice(&src);/// // SAFETY: we have just cloned all the elements of len into the spare capacity/// [`write_copy_of_slice`]: slice::write_copy_of_slicewrite_filled/// Fills a slice with elements by cloning `value`, returning a mutable reference to the now/// initialized contents of the slice./// Any previously initialized elements will not be dropped./// This is similar to [`slice::fill`]./// This function will panic if any call to `Clone` panics./// If such a panic occurs, any elements previously initialized during this operation will be/// #![feature(maybe_uninit_fill)]/// let mut buf = [const { MaybeUninit::uninit() }; 10];/// let initialized = buf.write_filled(1);/// assert_eq!(initialized, &mut [1; 10]);/// Fills a slice with elements returned by calling a closure for each index./// This method uses a closure to create new values. If you'd rather `Clone` a given value, use/// [slice::write_filled]. If you want to use the `Default` trait to generate values, you can/// pass [`|_| Default::default()`][Default::default] as the argument./// This function will panic if any call to the provided closure panics./// let mut buf = [const { MaybeUninit::<usize>::uninit() }; 5];/// let initialized = buf.write_with(|idx| idx + 1);/// assert_eq!(initialized, &mut [1, 2, 3, 4, 5]);/// Fills a slice with elements yielded by an iterator until either all elements have been/// initialized or the iterator is empty./// Returns two slices. The first slice contains the initialized portion of the original slice./// The second slice is the still-uninitialized remainder of the original slice./// This function panics if the iterator's `next` function panics./// Completely filling the slice:/// let mut buf = [const { MaybeUninit::uninit() }; 5];/// let iter = [1, 2, 3].into_iter().cycle();/// let (initialized, remainder) = buf.write_iter(iter);/// assert_eq!(initialized, &mut [1, 2, 3, 1, 2]);/// assert_eq!(remainder.len(), 0);/// Partially filling the slice:/// let iter = [1, 2];/// assert_eq!(initialized, &mut [1, 2]);/// assert_eq!(remainder.len(), 3);/// Checking an iterator after filling a slice:/// let mut buf = [const { MaybeUninit::uninit() }; 3];/// let mut iter = [1, 2, 3, 4, 5].into_iter();/// let (initialized, remainder) = buf.write_iter(iter.by_ref());/// assert_eq!(initialized, &mut [1, 2, 3]);/// assert_eq!(iter.as_slice(), &[4, 5]);/// let uninit = [MaybeUninit::new(0x1234u16), MaybeUninit::new(0x5678u16)];/// let val1 = u16::from_ne_bytes(bytes[0..2].try_into().unwrap());/// let val2 = u16::from_ne_bytes(bytes[2..4].try_into().unwrap());/// assert_eq!(&[val1, val2], &[0x1234u16, 0x5678u16]);/// Returns the contents of this `MaybeUninit` slice as a mutable slice of potentially/// uninitialized bytes./// let mut uninit = [MaybeUninit::<u16>::uninit(), MaybeUninit::<u16>::uninit()];/// uninit_bytes.write_copy_of_slice(&[0x12, 0x34, 0x56, 0x78]);/// let vals = unsafe { uninit.assume_init_ref() };///     assert_eq!(vals, &[0x3412u16, 0x7856u16]);///     assert_eq!(vals, &[0x1234u16, 0x5678u16]);/// Drops the contained values in place./// It is up to the caller to guarantee that every `MaybeUninit<T>` in the slice/// really is in an initialized state. Calling this when the content is not yet/// fully initialized causes undefined behavior./// behavior: it is up to the caller to guarantee that every `MaybeUninit<T>` in/// the slice really is in an initialized state./// behavior: it is up to the caller to guarantee that every `MaybeUninit<T>` in the/// slice really is in an initialized state. For instance, `.assume_init_mut()` cannot/// be used to initialize a `MaybeUninit` slice./// Transposes a `MaybeUninit<[T; N]>` into a `[MaybeUninit<T>; N]`./// let data: [MaybeUninit<u8>; 1000] = MaybeUninit::uninit().transpose();/// Transposes a `[MaybeUninit<T>; N]` into a `MaybeUninit<[T; N]>`./// let data = [MaybeUninit::<u8>::uninit(); 1000];/// let data: MaybeUninit<[u8; 1000]> = data.transpose();spec_fillSpecFillmanually_droptransmutability// This one has to be a re-export (rather than wrapping the underlying intrinsic) so that we can do// the special magic "types have equal size" check at the call site."mem_forget"/// Takes ownership and "forgets" about the value **without running its destructor**./// Any resources the value manages, such as heap memory or a file handle, will linger/// forever in an unreachable state. However, it does not guarantee that pointers/// to this memory will remain valid./// * If you want to leak memory, see [`Box::leak`]./// * If you want to obtain a raw pointer to the memory, see [`Box::into_raw`]./// * If you want to dispose of a value properly, running its destructor, see///   [`mem::drop`]./// `forget` is not marked as `unsafe`, because Rust's safety guarantees/// do not include a guarantee that destructors will always run. For example,/// a program can create a reference cycle using [`Rc`][rc], or call/// [`process::exit`][exit] to exit without running destructors. Thus, allowing/// `mem::forget` from safe code does not fundamentally change Rust's safety/// That said, leaking resources such as memory or I/O objects is usually undesirable./// The need comes up in some specialized use cases for FFI or unsafe code, but even/// then, [`ManuallyDrop`] is typically preferred./// Because forgetting a value is allowed, any `unsafe` code you write must/// allow for this possibility. You cannot return a value and expect that the/// caller will necessarily run the value's destructor./// [exit]: ../../std/process/fn.exit.html/// The canonical safe use of `mem::forget` is to circumvent a value's destructor/// implemented by the `Drop` trait. For example, this will leak a `File`, i.e. reclaim/// the space taken by the variable but never close the underlying system resource:/// let file = File::open("foo.txt").unwrap();/// mem::forget(file);/// This is useful when the ownership of the underlying resource was previously/// transferred to code outside of Rust, for example by transmitting the raw/// file descriptor to C code./// # Relationship with `ManuallyDrop`/// While `mem::forget` can also be used to transfer *memory* ownership, doing so is error-prone./// [`ManuallyDrop`] should be used instead. Consider, for example, this code:/// let mut v = vec![65, 122];/// // Build a `String` using the contents of `v`/// let s = unsafe { String::from_raw_parts(v.as_mut_ptr(), v.len(), v.capacity()) };/// // leak `v` because its memory is now managed by `s`/// mem::forget(v);  // ERROR - v is invalid and must not be passed to a function/// assert_eq!(s, "Az");/// // `s` is implicitly dropped and its memory deallocated./// There are two issues with the above example:/// * If more code were added between the construction of `String` and the invocation of///   `mem::forget()`, a panic within it would cause a double free because the same memory///   is handled by both `v` and `s`./// * After calling `v.as_mut_ptr()` and transmitting the ownership of the data to `s`,///   the `v` value is invalid. Even when a value is just moved to `mem::forget` (which won't///   inspect it), some types have strict requirements on their values that///   make them invalid when dangling or no longer owned. Using invalid values in any///   way, including passing them to or returning them from functions, constitutes///   undefined behavior and may break the assumptions made by the compiler./// Switching to `ManuallyDrop` avoids both issues:/// let v = vec![65, 122];/// // Before we disassemble `v` into its raw parts, make sure it/// // does not get dropped!/// let mut v = ManuallyDrop::new(v);/// // Now disassemble `v`. These operations cannot panic, so there cannot be a leak./// let (ptr, len, cap) = (v.as_mut_ptr(), v.len(), v.capacity());/// // Finally, build a `String`./// let s = unsafe { String::from_raw_parts(ptr, len, cap) };/// `ManuallyDrop` robustly prevents double-free because we disable `v`'s destructor/// before doing anything else. `mem::forget()` doesn't allow this because it consumes its/// argument, forcing us to call it only after extracting anything we need from `v`. Even/// if a panic were introduced between construction of `ManuallyDrop` and building the/// string (which cannot happen in the code as shown), it would result in a leak and not a/// double free. In other words, `ManuallyDrop` errs on the side of leaking instead of/// erring on the side of (double-)dropping./// Also, `ManuallyDrop` prevents us from having to "touch" `v` after transferring the/// ownership to `s` — the final step of interacting with `v` to dispose of it without/// running its destructor is entirely avoided./// [`Box`]: ../../std/boxed/struct.Box.html/// [`Box::leak`]: ../../std/boxed/struct.Box.html#method.leak/// [`Box::into_raw`]: ../../std/boxed/struct.Box.html#method.into_raw/// [`mem::drop`]: dropforget_unsized/// Like [`forget`], but also accepts unsized values./// While Rust does not permit unsized locals since its removal in [#111942] it is/// still possible to call functions with unsized values from a function argument/// or place expression./// #![feature(unsized_fn_params, forget_unsized)]/// #![allow(internal_features)]/// use std::mem::forget_unsized;/// pub fn in_place() {///     forget_unsized(*Box::<str>::from("str"));/// pub fn param(x: str) {///     forget_unsized(x);/// This works because the compiler will alter these functions to pass the parameter/// by reference instead. This trick is necessary to support `Box<dyn FnOnce()>: FnOnce()`./// See [#68304] and [#71170] for more information./// [#111942]: https://github.com/rust-lang/rust/issues/111942/// [#68304]: https://github.com/rust-lang/rust/issues/68304/// [#71170]: https://github.com/rust-lang/rust/pull/71170rustc_promotable"mem_size_of"/// Returns the size of a type in bytes./// More specifically, this is the offset in bytes between successive elements/// in an array with that item type including alignment padding. Thus, for any/// type `T` and length `n`, `[T; n]` has a size of `n * size_of::<T>()`./// In general, the size of a type is not stable across compilations, but/// specific types such as primitives are./// The following table gives the size for primitives./// Type | `size_of::<Type>()`/// ---- | ---------------/// () | 0/// bool | 1/// u8 | 1/// u16 | 2/// u32 | 4/// u64 | 8/// u128 | 16/// i8 | 1/// i16 | 2/// i32 | 4/// i64 | 8/// i128 | 16/// f32 | 4/// f64 | 8/// char | 4/// Furthermore, `usize` and `isize` have the same size./// The types [`*const T`], `&T`, [`Box<T>`], [`Option<&T>`], and `Option<Box<T>>` all have/// the same size. If `T` is `Sized`, all of those types have the same size as `usize`./// The mutability of a pointer does not change its size. As such, `&T` and `&mut T`/// have the same size. Likewise for `*const T` and `*mut T`./// # Size of `#[repr(C)]` items/// The `C` representation for items has a defined layout. With this layout,/// the size of items is also stable as long as all fields have a stable size./// ## Size of Structs/// For `struct`s, the size is determined by the following algorithm./// For each field in the struct ordered by declaration order:/// 1. Add the size of the field./// 2. Round up the current size to the nearest multiple of the next field's [alignment]./// Finally, round the size of the struct to the nearest multiple of its [alignment]./// The alignment of the struct is usually the largest alignment of all its/// fields; this can be changed with the use of `repr(align(N))`./// Unlike `C`, zero sized structs are not rounded up to one byte in size./// ## Size of Enums/// Enums that carry no data other than the discriminant have the same size as C enums/// on the platform they are compiled for./// ## Size of Unions/// The size of a union is the size of its largest field./// Unlike `C`, zero sized unions are not rounded up to one byte in size./// // Some primitives/// assert_eq!(4, size_of::<i32>());/// assert_eq!(8, size_of::<f64>());/// assert_eq!(0, size_of::<()>());/// // Some arrays/// assert_eq!(8, size_of::<[i32; 2]>());/// assert_eq!(12, size_of::<[i32; 3]>());/// assert_eq!(0, size_of::<[i32; 0]>());/// // Pointer size equality/// assert_eq!(size_of::<&i32>(), size_of::<*const i32>());/// assert_eq!(size_of::<&i32>(), size_of::<Box<i32>>());/// assert_eq!(size_of::<&i32>(), size_of::<Option<&i32>>());/// assert_eq!(size_of::<Box<i32>>(), size_of::<Option<Box<i32>>>());/// Using `#[repr(C)]`./// struct FieldStruct {///     first: u8,///     second: u16,///     third: u8/// // The size of the first field is 1, so add 1 to the size. Size is 1./// // The alignment of the second field is 2, so add 1 to the size for padding. Size is 2./// // The size of the second field is 2, so add 2 to the size. Size is 4./// // The alignment of the third field is 1, so add 0 to the size for padding. Size is 4./// // The size of the third field is 1, so add 1 to the size. Size is 5./// // Finally, the alignment of the struct is 2 (because the largest alignment amongst its/// // fields is 2), so add 1 to the size for padding. Size is 6./// assert_eq!(6, size_of::<FieldStruct>());/// struct TupleStruct(u8, u16, u8);/// // Tuple structs follow the same rules./// assert_eq!(6, size_of::<TupleStruct>());/// // Note that reordering the fields can lower the size. We can remove both padding bytes/// // by putting `third` before `second`./// struct FieldStructOptimized {///     third: u8,///     second: u16/// assert_eq!(4, size_of::<FieldStructOptimized>());/// // Union size is the size of the largest field./// union ExampleUnion {///     smaller: u8,///     larger: u16/// assert_eq!(2, size_of::<ExampleUnion>());/// [alignment]: align_of/// [`*const T`]: primitive@pointer/// [`Option<&T>`]: crate::option::Option"mem_size_of_val"/// Returns the size of the pointed-to value in bytes./// This is usually the same as [`size_of::<T>()`]. However, when `T` *has* no/// statically-known size, e.g., a slice [`[T]`][slice] or a [trait object],/// then `size_of_val` can be used to get the dynamically-known size./// assert_eq!(4, size_of_val(&5i32));/// let x: [u8; 13] = [0; 13];/// let y: &[u8] = &x;/// assert_eq!(13, size_of_val(y));/// [`size_of::<T>()`]: size_of/// then `size_of_val_raw` can be used to get the dynamically-known size.//        NOTE: the reason this is safe is that if an overflow were to occur already with size 0,//        then we would stop compilation as even the "statically known" part of the type would//        already be too big (or the call may be in dead code and optimized away, but then it//        doesn't matter).///       to a valid vtable acquired by an unsizing coercion, and the size///       of the *entire value* (dynamic tail length + statically sized prefix)///       must fit in `isize`.///       [`size_of_val`] on a reference to a type with an extern type tail./// #![feature(layout_for_ptr)]/// assert_eq!(13, unsafe { mem::size_of_val_raw(y) });min_align_of/// Returns the [ABI]-required minimum alignment of a type in bytes./// Every reference to a value of the type `T` must be a multiple of this number./// This is the alignment used for struct fields. It may be smaller than the preferred alignment./// [ABI]: https://en.wikipedia.org/wiki/Application_binary_interface/// assert_eq!(4, mem::min_align_of::<i32>());min_align_of_val/// Returns the [ABI]-required minimum alignment of the type of the value that `val` points to in/// assert_eq!(4, mem::min_align_of_val(&5i32));"mem_align_of"/// assert_eq!(4, align_of::<i32>());/// assert_eq!(4, align_of_val(&5i32));///       [`align_of_val`] on a reference to a type with an extern type tail./// assert_eq!(4, unsafe { mem::align_of_val_raw(&5i32) });"needs_drop"/// Returns `true` if dropping values of type `T` matters./// This is purely an optimization hint, and may be implemented conservatively:/// it may return `true` for types that don't actually need to be dropped./// As such always returning `true` would be a valid implementation of/// this function. However if this function actually returns `false`, then you/// can be certain dropping `T` has no side effect./// Low level implementations of things like collections, which need to manually/// drop their data, should use this function to avoid unnecessarily/// trying to drop all their contents when they are destroyed. This might not/// make a difference in release builds (where a loop that has no side-effects/// is easily detected and eliminated), but is often a big win for debug builds./// Note that [`drop_in_place`] already performs this check, so if your workload/// can be reduced to some small number of [`drop_in_place`] calls, using this is/// unnecessary. In particular note that you can [`drop_in_place`] a slice, and that/// will do a single needs_drop check for all the values./// Types like Vec therefore just `drop_in_place(&mut self[..])` without using/// `needs_drop` explicitly. Types like [`HashMap`], on the other hand, have to drop/// values one at a time and should use this API./// [`drop_in_place`]: crate::ptr::drop_in_place/// Here's an example of how a collection might make use of `needs_drop`:/// use std::{mem, ptr};/// pub struct MyCollection<T> {/// #   data: [T; 1],/// #   fn iter_mut(&mut self) -> &mut [T] { &mut self.data }/// #   fn free_buffer(&mut self) {}/// impl<T> Drop for MyCollection<T> {///             // drop the data///             if mem::needs_drop::<T>() {///                 for x in self.iter_mut() {///                     ptr::drop_in_place(x);///             self.free_buffer();"mem_zeroed"/// Returns the value of type `T` represented by the all-zero byte-pattern./// This means that, for example, the padding byte in `(u8, u16)` is not/// necessarily zeroed./// There is no guarantee that an all-zero byte-pattern represents a valid value/// of some type `T`. For example, the all-zero byte-pattern is not a valid value/// for reference types (`&T`, `&mut T`) and function pointers. Using `zeroed`/// on such types causes immediate [undefined behavior][ub] because [the Rust/// compiler assumes][inv] that there always is a valid value in a variable it/// considers initialized./// This has the same effect as [`MaybeUninit::zeroed().assume_init()`][zeroed]./// It is useful for FFI sometimes, but should generally be avoided./// [zeroed]: MaybeUninit::zeroed/// [inv]: MaybeUninit#initialization-invariant/// Correct usage of this function: initializing an integer with zero./// let x: i32 = unsafe { mem::zeroed() };/// assert_eq!(0, x);/// *Incorrect* usage of this function: initializing a reference with zero./// let _x: &i32 = unsafe { mem::zeroed() }; // Undefined behavior!/// let _y: fn() = unsafe { mem::zeroed() }; // And again!"mem_uninitialized"/// Bypasses Rust's normal memory-initialization checks by pretending to/// produce a value of type `T`, while doing nothing at all./// **This function is deprecated.** Use [`MaybeUninit<T>`] instead./// It also might be slower than using `MaybeUninit<T>` due to mitigations that were put in place to/// limit the potential harm caused by incorrect use of this function in legacy code./// The reason for deprecation is that the function basically cannot be used/// correctly: it has the same effect as [`MaybeUninit::uninit().assume_init()`][uninit]./// As the [`assume_init` documentation][assume_init] explains,/// [the Rust compiler assumes][inv] that values are properly initialized./// Truly uninitialized memory like what gets returned here/// is special in that the compiler knows that it does not have a fixed value./// This makes it undefined behavior to have uninitialized data in a variable even/// if that variable has an integer type./// Therefore, it is immediate undefined behavior to call this function on nearly all types,/// including integer types and arrays of integer types, and even if the result is unused./// [uninit]: MaybeUninit::uninit/// [assume_init]: MaybeUninit::assume_init"mem_swap"/// Swaps the values at two mutable locations, without deinitializing either one./// * If you want to swap with a default or dummy value, see [`take`]./// * If you want to swap with a passed value, returning the old value, see [`replace`]./// let mut x = 5;/// let mut y = 42;/// mem::swap(&mut x, &mut y);/// assert_eq!(42, x);/// assert_eq!(5, y);/// Replaces `dest` with the default value of `T`, returning the previous `dest` value./// * If you want to replace the values of two variables, see [`swap`]./// * If you want to replace with a passed value instead of the default value, see [`replace`]./// A simple example:/// let mut v: Vec<i32> = vec![1, 2];/// let old_v = mem::take(&mut v);/// assert_eq!(vec![1, 2], old_v);/// `take` allows taking ownership of a struct field by replacing it with an "empty" value./// Without `take` you can run into issues like these:/// ```compile_fail,E0507/// struct Buffer<T> { buf: Vec<T> }/// impl<T> Buffer<T> {///     fn get_and_reset(&mut self) -> Vec<T> {///         // error: cannot move out of dereference of `&mut`-pointer///         let buf = self.buf;///         self.buf = Vec::new();///         buf/// Note that `T` does not necessarily implement [`Clone`], so it can't even clone and reset/// `self.buf`. But `take` can be used to disassociate the original value of `self.buf` from/// `self`, allowing it to be returned:/// # struct Buffer<T> { buf: Vec<T> }///         mem::take(&mut self.buf)/// let mut buffer = Buffer { buf: vec![0, 1] };/// assert_eq!(buffer.buf.len(), 2);/// assert_eq!(buffer.get_and_reset(), vec![0, 1]);/// assert_eq!(buffer.buf.len(), 0);"if you don't need the old value, you can just assign the new value directly""mem_replace"/// Moves `src` into the referenced `dest`, returning the previous `dest` value./// Neither value is dropped./// * If you want to replace with a default value, see [`take`]./// let old_v = mem::replace(&mut v, vec![3, 4, 5]);/// assert_eq!(vec![3, 4, 5], v);/// `replace` allows consumption of a struct field by replacing it with another value./// Without `replace` you can run into issues like these:///     fn replace_index(&mut self, i: usize, v: T) -> T {///         let t = self.buf[i];///         self.buf[i] = v;///         t/// Note that `T` does not necessarily implement [`Clone`], so we can't even clone `self.buf[i]` to/// avoid the move. But `replace` can be used to disassociate the original value at that index from///         mem::replace(&mut self.buf[i], v)/// assert_eq!(buffer.buf[0], 0);/// assert_eq!(buffer.replace_index(0, 2), 0);/// assert_eq!(buffer.buf[0], 2);"mem_drop"/// Disposes of a value./// This effectively does nothing for types which implement `Copy`, e.g./// integers. Such values are copied and _then_ moved into the function, so the/// value persists after this function call./// This function is not magic; it is literally defined as/// pub fn drop<T>(_x: T) {}/// Because `_x` is moved into the function, it is automatically [dropped][drop] before/// the function returns./// [drop]: Drop/// drop(v); // explicitly drop the vector/// Since [`RefCell`] enforces the borrow rules at runtime, `drop` can/// release a [`RefCell`] borrow:/// let x = RefCell::new(1);/// let mut mutable_borrow = x.borrow_mut();/// *mutable_borrow = 1;/// drop(mutable_borrow); // relinquish the mutable borrow on this slot/// let borrow = x.borrow();/// println!("{}", *borrow);/// Integers and other types implementing [`Copy`] are unaffected by `drop`./// # #![allow(dropping_copy_types)]/// struct Foo(u8);/// let x = 1;/// let y = Foo(2);/// drop(x); // a copy of `x` is moved and dropped/// drop(y); // a copy of `y` is moved and dropped/// println!("x: {}, y: {}", x, y.0); // still available/// Bitwise-copies a value./// pub const fn copy<T: Copy>(x: &T) -> T { *x }/// It is useful when you want to pass a function pointer to a combinator, rather than defining a new closure./// #![feature(mem_copy_fn)]/// use core::mem::copy;/// let result_from_ffi_function: Result<(), &i32> = Err(&1);/// let result_copied: Result<(), i32> = result_from_ffi_function.map_err(copy);/// Interprets `src` as having type `&Dst`, and then reads `src` without moving/// the contained value./// This function will unsafely assume the pointer `src` is valid for [`size_of::<Dst>`][size_of]/// bytes by transmuting `&Src` to `&Dst` and then reading the `&Dst` (except that this is done/// in a way that is correct even when `&Dst` has stricter alignment requirements than `&Src`)./// It will also unsafely create a copy of the contained value instead of moving out of `src`./// It is not a compile-time error if `Src` and `Dst` have different sizes, but it/// is highly encouraged to only invoke this function where `Src` and `Dst` have the/// same size. This function triggers [undefined behavior][ub] if `Dst` is larger than/// `Src`.///     bar: u8,/// let foo_array = [10u8];///     // Copy the data from 'foo_array' and treat it as a 'Foo'///     let mut foo_struct: Foo = mem::transmute_copy(&foo_array);///     assert_eq!(foo_struct.bar, 10);///     // Modify the copied data///     foo_struct.bar = 20;///     assert_eq!(foo_struct.bar, 20);/// // The contents of 'foo_array' should not have changed/// assert_eq!(foo_array, [10]);/// Opaque type representing the discriminant of an enum./// See the [`discriminant`] function in this module for more information."mem_discriminant"/// Returns a value uniquely identifying the enum variant in `v`./// If `T` is not an enum, calling this function will not result in undefined behavior, but the/// return value is unspecified./// The discriminant of an enum variant may change if the enum definition changes. A discriminant/// of some variant will not change between compilations with the same compiler. See the [Reference]/// [Reference]: ../../reference/items/enumerations.html#custom-discriminant-values-for-fieldless-enumerations/// The value of a [`Discriminant<T>`] is independent of any *free lifetimes* in `T`. As such,/// reading or writing a `Discriminant<Foo<'a>>` as a `Discriminant<Foo<'b>>` (whether via/// [`transmute`] or otherwise) is always sound. Note that this is **not** true for other kinds/// of generic parameters and for higher-ranked lifetimes; `Discriminant<Foo<A>>` and/// `Discriminant<Foo<B>>` as well as `Discriminant<Bar<dyn for<'a> Trait<'a>>>` and/// `Discriminant<Bar<dyn Trait<'static>>>` may be incompatible./// This can be used to compare enums that carry data, while disregarding/// the actual data:/// enum Foo { A(&'static str), B(i32), C(i32) }/// assert_eq!(mem::discriminant(&Foo::A("bar")), mem::discriminant(&Foo::A("baz")));/// assert_eq!(mem::discriminant(&Foo::B(1)), mem::discriminant(&Foo::B(2)));/// assert_ne!(mem::discriminant(&Foo::B(3)), mem::discriminant(&Foo::C(3)));/// ## Accessing the numeric value of the discriminant/// Note that it is *undefined behavior* to [`transmute`] from [`Discriminant`] to a primitive!/// If an enum has only unit variants, then the numeric value of the discriminant can be accessed/// with an [`as`] cast:///     Foo,///     Bar,///     Baz,/// assert_eq!(0, Enum::Foo as isize);/// assert_eq!(1, Enum::Bar as isize);/// assert_eq!(2, Enum::Baz as isize);/// If an enum has opted-in to having a [primitive representation] for its discriminant,/// then it's possible to use pointers to read the memory location storing the discriminant./// That **cannot** be done for enums using the [default representation], however, as it's/// undefined what layout the discriminant has and where it's stored — it might not even be/// stored at all!/// [`as`]: ../../std/keyword.as.html/// [primitive representation]: ../../reference/type-layout.html#primitive-representations/// [default representation]: ../../reference/type-layout.html#the-default-representation///     Tuple(bool),///     Struct { a: bool },/// impl Enum {///     fn discriminant(&self) -> u8 {///         // SAFETY: Because `Self` is marked `repr(u8)`, its layout is a `repr(C)` `union`///         // between `repr(C)` structs, each of which has the `u8` discriminant as its first///         // field, so we can read the discriminant without offsetting the pointer.///         unsafe { *<*const _>::from(self).cast::<u8>() }/// let unit_like = Enum::Unit;/// let tuple_like = Enum::Tuple(true);/// let struct_like = Enum::Struct { a: false };/// assert_eq!(0, unit_like.discriminant());/// assert_eq!(1, tuple_like.discriminant());/// assert_eq!(2, struct_like.discriminant());/// // ⚠️ This is undefined behavior. Don't do this. ⚠️/// // assert_eq!(0, unsafe { std::mem::transmute::<_, u8>(std::mem::discriminant(&unit_like)) });"mem_variant_count"/// Returns the number of variants in the enum type `T`./// return value is unspecified. Equally, if `T` is an enum with more variants than `usize::MAX`/// the return value is unspecified. Uninhabited variants will be counted./// Note that an enum may be expanded with additional variants in the future/// as a non-breaking change, for example if it is marked `#[non_exhaustive]`,/// which will change the result of this function./// # #![feature(never_type)]/// # #![feature(variant_count)]/// enum Void {}/// assert_eq!(mem::variant_count::<Void>(), 0);/// assert_eq!(mem::variant_count::<Foo>(), 3);/// assert_eq!(mem::variant_count::<Option<!>>(), 2);/// assert_eq!(mem::variant_count::<Result<!, !>>(), 2);"mem_size_const""mem_align_const"IS_ZST/// `true` if this type requires no storage./// `false` if its [size](size_of) is greater than zero./// #![feature(sized_type_properties)]/// use core::mem::SizedTypeProperties;/// fn do_something_with<T>() {///     if T::IS_ZST {///         // ... special approach ...///         // ... the normal thing .../// struct MyUnit;/// assert!(MyUnit::IS_ZST);/// // For negative checks, consider using UFCS to emphasize the negation/// assert!(!<i32>::IS_ZST);/// // As it can sometimes hide in the type otherwise/// assert!(!String::IS_ZST);MAX_SLICE_LEN/// The largest safe length for a `[Self]`./// Anything larger than this would make `size_of_val` overflow `isize::MAX`,/// which is never allowed for a single object./// Provides associated constants for various useful properties of types,/// to give them a canonical form in our code and make them easier to read./// This is here only to simplify all the ZST checks we need in the library./// It's not on a stabilization track right now./// Expands to the offset in bytes of a field from the beginning of the given type./// The type may be a `struct`, `enum`, `union`, or tuple./// The field may be a nested field (`field1.field2`), but not an array index./// The field must be visible to the call site./// The offset is returned as a [`usize`]./// # Offsets of, and in, dynamically sized types/// The field’s type must be [`Sized`], but it may be located in a [dynamically sized] container./// If the field type is dynamically sized, then you cannot use `offset_of!` (since the field's/// alignment, and therefore its offset, may also be dynamic) and must take the offset from an/// actual pointer to the container instead./// # use core::mem;/// # use core::fmt::Debug;/// pub struct Struct<T: ?Sized> {///     b: T,/// #[repr(C, align(4))]/// struct Align4(u32);/// assert_eq!(mem::offset_of!(Struct<dyn Debug>, a), 0); // OK — Sized field/// assert_eq!(mem::offset_of!(Struct<Align4>, b), 4); // OK — not DST/// // assert_eq!(mem::offset_of!(Struct<dyn Debug>, b), 1);/// // ^^^ error[E0277]: ... cannot be known at compilation time/// // To obtain the offset of a !Sized field, examine a concrete value/// // instead of using offset_of!./// let value: Struct<Align4> = Struct { a: 1, b: Align4(2) };/// let ref_unsized: &Struct<dyn Debug> = &value;/// let offset_of_b = unsafe {///     (&raw const ref_unsized.b).byte_offset_from_unsigned(ref_unsized)/// assert_eq!(offset_of_b, 4);/// If you need to obtain the offset of a field of a `!Sized` type, then, since the offset may/// depend on the particular value being stored (in particular, `dyn Trait` values have a/// dynamically-determined alignment), you must retrieve the offset from a specific reference/// or pointer, and so you cannot use `offset_of!` to work without one./// # Layout is subject to change/// Note that type layout is, in general, [subject to change and/// platform-specific](https://doc.rust-lang.org/reference/type-layout.html). If/// layout stability is required, consider using an [explicit `repr` attribute]./// Rust guarantees that the offset of a given field within a given type will not/// change over the lifetime of the program. However, two different compilations of/// the same program may result in different layouts. Also, even within a single/// program execution, no guarantees are made about types which are *similar* but/// not *identical*, e.g.:/// struct Wrapper<T, U>(T, U);/// type A = Wrapper<u8, u8>;/// type B = Wrapper<u8, i8>;/// // Not necessarily identical even though `u8` and `i8` have the same layout!/// // assert_eq!(mem::offset_of!(A, 1), mem::offset_of!(B, 1));/// struct U8(u8);/// type C = Wrapper<u8, U8>;/// // Not necessarily identical even though `u8` and `U8` have the same layout!/// // assert_eq!(mem::offset_of!(A, 1), mem::offset_of!(C, 1));/// struct Empty<T>(core::marker::PhantomData<T>);/// // Not necessarily identical even though `PhantomData` always has the same layout!/// // assert_eq!(mem::offset_of!(Empty<u8>, 0), mem::offset_of!(Empty<i8>, 0));/// [explicit `repr` attribute]: https://doc.rust-lang.org/reference/type-layout.html#representations/// # Unstable features/// The following unstable features expand the functionality of `offset_of!`:/// * [`offset_of_enum`] — allows `enum` variants to be traversed as if they were fields./// * [`offset_of_slice`] — allows getting the offset of a field of type `[T]`./// assert_eq!(mem::offset_of!(FieldStruct, first), 0);/// assert_eq!(mem::offset_of!(FieldStruct, second), 2);/// assert_eq!(mem::offset_of!(FieldStruct, third), 4);/// struct NestedA {///     b: NestedB/// struct NestedB(u8);/// assert_eq!(mem::offset_of!(NestedA, b.0), 0);/// [dynamically sized]: https://doc.rust-lang.org/reference/dynamically-sized-types.html/// [`offset_of_enum`]: https://doc.rust-lang.org/nightly/unstable-book/language-features/offset-of-enum.html/// [`offset_of_slice`]: https://doc.rust-lang.org/nightly/unstable-book/language-features/offset-of-slice.html/// Create a fresh instance of the inhabited ZST type `T`./// Prefer this to [`zeroed`] or [`uninitialized`] or [`transmute_copy`]/// in places where you know that `T` is zero-sized, but don't have a bound/// (such as [`Default`]) that would allow you to instantiate it using safe code./// If you're not sure whether `T` is an inhabited ZST, then you should be/// using [`MaybeUninit`], not this function./// If `size_of::<T>() != 0`./// - `T` must be *[inhabited]*, i.e. possible to construct. This means that types///   like zero-variant enums and [`!`] are unsound to conjure./// - You must use the value only in ways which do not violate any *safety*///   invariants of the type./// While it's easy to create a *valid* instance of an inhabited ZST, since having/// no bits in its representation means there's only one possible value, that/// doesn't mean that it's always *sound* to do so./// For example, a library could design zero-sized tokens that are `!Default + !Clone`, limiting/// their creation to functions that initialize some state or establish a scope. Conjuring such a/// token could break invariants and lead to unsoundness./// #![feature(mem_conjure_zst)]/// use std::mem::conjure_zst;/// assert_eq!(unsafe { conjure_zst::<()>() }, ());/// assert_eq!(unsafe { conjure_zst::<[i32; 0]>() }, []);/// [inhabited]: https://doc.rust-lang.org/reference/glossary.html#inhabited//! Basic functions for dealing with memory.//! This module contains functions for querying the size and alignment of//! types, initializing and manipulating memory.// N.B. These trait implementations cannot be derived because we don't want any bounds on T./// Transmutes a `Src` value into a `Self`./// The safety obligations of the caller depend on the value of `ASSUME`:/// - If [`ASSUME.alignment`](Assume::alignment), the caller must guarantee///   that the addresses of references in the returned `Self` satisfy the///   alignment requirements of their referent types./// - If [`ASSUME.lifetimes`](Assume::lifetimes), the caller must guarantee///   that references in the returned `Self` will not outlive their///   referents./// - If [`ASSUME.safety`](Assume::safety), the returned value might not///   satisfy the library safety invariants of `Self`, and the caller must///   guarantee that undefined behavior does not arise from uses of the///   returned value./// - If [`ASSUME.validity`](Assume::validity), the caller must guarantee///   that `src` is a bit-valid instance of `Self`./// When satisfying the above obligations (if any), the caller must *not*/// assume that this trait provides any inherent guarantee of layout/// [portability](#portability) or [stability](#stability)."transmute_trait"NOTHINGASSUME/// Marks that `Src` is transmutable into `Self`./// This trait cannot be implemented explicitly. It is implemented on-the-fly by/// the compiler for all types `Src` and `Self` such that, given a set of safety/// obligations on the programmer (see [`Assume`]), the compiler has proved that/// the bits of a value of type `Src` can be soundly reinterpreted as a `Self`./// If `Dst: TransmuteFrom<Src, ASSUMPTIONS>`, the compiler guarantees that/// `Src` is soundly *union-transmutable* into a value of type `Dst`, provided/// that the programmer has guaranteed that the given [`ASSUMPTIONS`](Assume)/// are satisfied./// A union-transmute is any bit-reinterpretation conversion in the form of:/// pub unsafe fn transmute_via_union<Src, Dst>(src: Src) -> Dst {///     use core::mem::ManuallyDrop;///     #[repr(C)]///     union Transmute<Src, Dst> {///         src: ManuallyDrop<Src>,///         dst: ManuallyDrop<Dst>,///     let transmute = Transmute {///         src: ManuallyDrop::new(src),///     let dst = unsafe { transmute.dst };///     ManuallyDrop::into_inner(dst)/// Note that this construction is more permissive than/// [`mem::transmute_copy`](super::transmute_copy); union-transmutes permit/// conversions that extend the bits of `Src` with trailing padding to fill/// trailing uninitialized bytes of `Self`; e.g.:/// #![feature(transmutability)]/// use core::mem::{Assume, TransmuteFrom};/// let src = 42u8; // size = 1/// struct Dst(u8); // size = 2///     <Dst as TransmuteFrom<u8, { Assume::SAFETY }>>::transmute(src)/// Implementations of this trait do not provide any guarantee of portability/// across toolchains, targets or compilations. This trait may be implemented/// for certain combinations of `Src`, `Self` and `ASSUME` on some toolchains,/// targets or compilations, but not others. For example, if the layouts of/// `Src` or `Self` are non-deterministic, the presence or absence of an/// implementation of this trait may also be non-deterministic. Even if `Src`/// and `Self` have deterministic layouts (e.g., they are `repr(C)` structs),/// Rust does not specify the alignments of its primitive integer types, and/// layouts that involve these types may vary across toolchains, targets or/// compilations./// ## Stability/// Implementations of this trait do not provide any guarantee of SemVer/// stability across the crate versions that define the `Src` and `Self` types./// If SemVer stability is crucial to your application, you must consult the/// documentation of `Src` and `Self`s' defining crates. Note that the presence/// of `repr(C)`, alone, does not carry a safety invariant of SemVer stability./// Furthermore, stability does not imply portability. For example, the size of/// `usize` is stable, but not portable."transmute_opts"/// When `false`, [`TransmuteFrom`] is not implemented for transmutations/// that might violate the alignment requirements of references; e.g.:/// use core::mem::TransmuteFrom;/// assert_eq!(align_of::<[u8; 2]>(), 1);/// assert_eq!(align_of::<u16>(), 2);/// let src: &[u8; 2] = &[0xFF, 0xFF];/// // SAFETY: No safety obligations./// let dst: &u16 = unsafe {///     <_ as TransmuteFrom<_>>::transmute(src)/// When `true`, [`TransmuteFrom`] assumes that *you* have ensured/// that references in the transmuted value satisfy the alignment/// requirements of their referent types; e.g.:/// #![feature(pointer_is_aligned_to, transmutability)]/// let maybe_dst: Option<&u16> = if <*const _>::is_aligned_to(src, align_of::<u16>()) {///     // SAFETY: We have checked above that the address of `src` satisfies the///     // alignment requirements of `u16`.///     Some(unsafe {///         <_ as TransmuteFrom<_, { Assume::ALIGNMENT }>>::transmute(src)/// assert!(matches!(maybe_dst, Some(&u16::MAX) | None));/// that extend the lifetimes of references./// When `true`, [`TransmuteFrom`] assumes that *you* have ensured that/// references in the transmuted value do not outlive their referents.safety/// that might violate the library safety invariants of the destination/// type; e.g.:/// let src: u8 = 3;/// struct EvenU8 {///     // SAFETY: `val` must be an even number.///     val: u8,/// let dst: EvenU8 = unsafe {/// that undefined behavior does not arise from using the transmuted value;/// let src: u8 = 42;/// let maybe_dst: Option<EvenU8> = if src % 2 == 0 {///     // SAFETY: We have checked above that the value of `src` is even.///         <_ as TransmuteFrom<_, { Assume::SAFETY }>>::transmute(src)/// assert!(matches!(maybe_dst, Some(EvenU8 { val: 42 })));/// that might violate the language-level bit-validity invariant of the/// destination type; e.g.:/// let dst: bool = unsafe {/// that the value being transmuted is a bit-valid instance of the/// transmuted value; e.g.:/// let src: u8 = 1;/// let maybe_dst: Option<bool> = if src == 0 || src == 1 {///     // SAFETY: We have checked above that the value of `src` is a bit-valid///     // instance of `bool`.///         <_ as TransmuteFrom<_, { Assume::VALIDITY }>>::transmute(src)/// assert_eq!(maybe_dst, Some(true));/// Configurable proof assumptions of [`TransmuteFrom`]./// When `false`, the respective proof obligation belongs to the compiler. When/// `true`, the onus of the safety proof belongs to the programmer./// With this, [`TransmuteFrom`] does not assume you have ensured any safety/// obligations are met, and relies only upon its own analysis to (dis)prove/// transmutability.ALIGNMENT/// With this, [`TransmuteFrom`] assumes only that you have ensured that/// references in the transmuted value satisfy the alignment requirements of/// their referent types. See [`Assume::alignment`] for examples.LIFETIMES/// references in the transmuted value do not outlive their referents. See/// [`Assume::lifetimes`] for examples./// undefined behavior does not arise from using the transmuted value. See/// [`Assume::safety`] for examples.VALIDITY/// With this, [`TransmuteFrom`] assumes only that you have ensured that the/// value being transmuted is a bit-valid instance of the transmuted value./// See [`Assume::validity`] for examples./// Combine the assumptions of `self` and `other_assumptions`./// This is especially useful for extending [`Assume`] in generic contexts;/// #![feature(///     adt_const_params,///     generic_const_exprs,///     pointer_is_aligned_to,///     transmutability,/// #![allow(incomplete_features)]/// /// Attempts to transmute `src` to `&Dst`./// /// Returns `None` if `src` violates the alignment requirements of `&Dst`./// /// The caller guarantees that the obligations required by `ASSUME`, except/// /// alignment, are satisfied./// unsafe fn try_transmute_ref<'a, Src, Dst, const ASSUME: Assume>(src: &'a Src) -> Option<&'a Dst>///     &'a Dst: TransmuteFrom<&'a Src, { ASSUME.and(Assume::ALIGNMENT) }>,///     if <*const _>::is_aligned_to(src, align_of::<Dst>()) {///         // SAFETY: By the above dynamic check, we have ensured that the address///         // of `src` satisfies the alignment requirements of `&Dst`. By contract///         // on the caller, the safety obligations required by `ASSUME` have also///         // been satisfied.///         Some(unsafe {///             <_ as TransmuteFrom<_, { ASSUME.and(Assume::ALIGNMENT) }>>::transmute(src)/// let maybe_dst: Option<&u16> = unsafe {///     try_transmute_ref::<_, _, { Assume::NOTHING }>(src)but_not/// Remove `other_assumptions` the obligations of `self`; e.g.:/// use core::mem::Assume;/// let assumptions = Assume::ALIGNMENT.and(Assume::SAFETY);/// let to_be_removed = Assume::SAFETY.and(Assume::VALIDITY);///     assumptions.but_not(to_be_removed),///     Assume::ALIGNMENT,// FIXME(jswrenn): This const op is not actually usable. Why?// https://github.com/rust-lang/rust/pull/100726#issuecomment-1219928926/// Used for slow path in `Display` implementations when alignment is required.display_buffer"IpAddr""Ipv4Addr"/// [`FromStr`]: crate::str::FromStr"Ipv6Addr"/// Converts this address to an `IpAddr::V4` if it is an IPv4-mapped IPv6/// address, otherwise returns `self` as-is./// let localhost_v4 = Ipv4Addr::new(127, 0, 0, 1);/// assert_eq!(IpAddr::V4(localhost_v4).to_canonical(), localhost_v4);/// assert_eq!(IpAddr::V6(localhost_v4.to_ipv6_mapped()).to_canonical(), localhost_v4);as_octets/// Returns the eight-bit integers this address consists of as a slice./// #![feature(ip_as_octets)]/// use std::net::{Ipv4Addr, Ipv6Addr, IpAddr};/// assert_eq!(IpAddr::V4(Ipv4Addr::LOCALHOST).as_octets(), &[127, 0, 0, 1]);/// assert_eq!(IpAddr::V6(Ipv6Addr::LOCALHOST).as_octets(),///            &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])/// The size of an IPv4 address in bits./// assert_eq!(Ipv4Addr::BITS, 32);/// Converts an IPv4 address into a `u32` representation using native byte order./// Although IPv4 addresses are big-endian, the `u32` value will use the target platform's/// native byte order. That is, the `u32` value is an integer representation of the IPv4/// address and not an integer interpretation of the IPv4 address's big-endian bitstring. This/// means that the `u32` value masked with `0xffffff00` will set the last octet in the address/// to 0, regardless of the target platform's endianness./// assert_eq!(0x12345678, addr.to_bits());/// let addr_bits = addr.to_bits() & 0xffffff00;/// assert_eq!(Ipv4Addr::new(0x12, 0x34, 0x56, 0x00), Ipv4Addr::from_bits(addr_bits));/// Converts a native byte order `u32` into an IPv4 address./// See [`Ipv4Addr::to_bits`] for an explanation on endianness./// let addr = Ipv4Addr::from_bits(0x12345678);/// An IPv4 address representing the broadcast address: `255.255.255.255`.from_octets/// let addr = Ipv4Addr::from_octets([13u8, 12u8, 11u8, 10u8]);/// Returns the four eight-bit integers that make up this address/// as a slice./// assert_eq!(addr.as_octets(), &[127, 0, 0, 1]);/// Whether or not an address is practically reachable will depend on your/// network configuration. Most IPv4 addresses are globally reachable, unless/// they are specifically defined as *not* globally reachable./// network devices benchmarking./// This range is defined in [IETF RFC 2544] as `192.18.0.0` through/// `198.19.255.255` but [errata 423] corrects it to `198.18.0.0/15`./// Returns [`true`] if this address is reserved by IANA for future use./// [IETF RFC 1112] defines the block of reserved addresses as `240.0.0.0/4`./// This range normally includes the broadcast address `255.255.255.255`, but/// this implementation explicitly excludes it, since it is obviously not/// reserved for future use./// Uses [`Ipv4Addr::to_bits`] to convert an IPv4 address to a host byte order `u32`./// Uses [`Ipv4Addr::from_bits`] to convert a host byte order `u32` into an IPv4 address./// The size of an IPv6 address in bits./// assert_eq!(Ipv6Addr::BITS, 128);/// Converts an IPv6 address into a `u128` representation using native byte order./// Although IPv6 addresses are big-endian, the `u128` value will use the target platform's/// native byte order. That is, the `u128` value is an integer representation of the IPv6/// address and not an integer interpretation of the IPv6 address's big-endian bitstring. This/// means that the `u128` value masked with `0xffffffffffffffffffffffffffff0000_u128` will set/// the last segment in the address to 0, regardless of the target platform's endianness./// assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, addr.to_bits());/// let addr_bits = addr.to_bits() & 0xffffffffffffffffffffffffffff0000_u128;///         0x90A0, 0xB0C0, 0xD0E0, 0x0000,///     Ipv6Addr::from_bits(addr_bits));/// Converts a native byte order `u128` into an IPv6 address./// See [`Ipv6Addr::to_bits`] for an explanation on endianness./// let addr = Ipv6Addr::from_bits(0x102030405060708090A0B0C0D0E0F00D_u128);/// An IPv6 address representing the unspecified address: `::`.from_segments/// let addr = Ipv6Addr::from_segments([///     0x20du16, 0x20cu16, 0x20bu16, 0x20au16,///     0x209u16, 0x208u16, 0x207u16, 0x206u16,///         0x20d, 0x20c, 0x20b, 0x20a,///         0x209, 0x208, 0x207, 0x206,/// network configuration. Most IPv6 addresses are globally reachable, unless/// - Addresses reserved for benchmarking ([`is_benchmarking`](Ipv6Addr::is_benchmarking))/// // Addresses reserved for documentation (`2001:db8::/32` and `3fff::/20`)/// assert_eq!(Ipv6Addr::new(0x3fff, 0, 0, 0, 0, 0, 0, 0).is_global(), false);/// (`2001:db8::/32` and `3fff::/20`)./// This property is defined by [IETF RFC 3849] and [IETF RFC 9637]./// [IETF RFC 9637]: https://tools.ietf.org/html/rfc9637/// assert_eq!(Ipv6Addr::new(0x3fff, 0, 0, 0, 0, 0, 0, 0).is_documentation(), true);is_ipv4_mapped/// Returns [`true`] if the address is an IPv4-mapped address (`::ffff:0:0/96`)./// IPv4-mapped addresses can be converted to their canonical IPv4 address with/// [`to_ipv4_mapped`](Ipv6Addr::to_ipv4_mapped)./// let ipv4_mapped = Ipv4Addr::new(192, 0, 2, 255).to_ipv6_mapped();/// assert_eq!(ipv4_mapped.is_ipv4_mapped(), true);/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x2ff).is_ipv4_mapped(), true);/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_ipv4_mapped(), false);/// Converts this address to an `IpAddr::V4` if it is an IPv4-mapped address,/// otherwise returns self wrapped in an `IpAddr::V6`.///            [0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);/// let addr = Ipv6Addr::from_octets([///     0x19u8, 0x18u8, 0x17u8, 0x16u8, 0x15u8, 0x14u8, 0x13u8, 0x12u8,///     0x11u8, 0x10u8, 0x0fu8, 0x0eu8, 0x0du8, 0x0cu8, 0x0bu8, 0x0au8,///         0x1918, 0x1716, 0x1514, 0x1312,///         0x1110, 0x0f0e, 0x0d0c, 0x0b0a,/// Returns the sixteen eight-bit integers the IPv6 address consists of/// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).as_octets(),///            &[255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])/// Writes an Ipv6Addr, conforming to the canonical style described by/// [RFC 5952](https://tools.ietf.org/html/rfc5952)./// Uses [`Ipv6Addr::to_bits`] to convert an IPv6 address to a host byte order `u128`./// Uses [`Ipv6Addr::from_bits`] to convert a host byte order `u128` to an IPv6 address.bitop_impls//! Networking primitives for IP communication.//! This module provides types for IP and socket addresses.//! * [`IpAddr`] represents IP addresses of either IPv4 or IPv6; [`Ipv4Addr`] and//!   [`Ipv6Addr`] are respectively IPv4 and IPv6 addresses//! * [`SocketAddr`] represents socket addresses of either IPv4 or IPv6; [`SocketAddrV4`]//!   and [`SocketAddrV6`] are respectively IPv4 and IPv6 socket addresses/// Reads the next character from the input/// Reads the next character from the input if it matches the target.// INVARIANT: `max_digits` must be less than the number of digits that `u32`// can represent./// Reads an IPv4 address./// Reads an IPv6 address.read_ip_addr/// Reads an IP address, either IPv4 or IPv6./// Reads a `:` followed by a port in base 10.read_scope_id/// Reads a `%` followed by a scope ID in base 10.read_socket_addr_v4/// Reads an IPv4 address with a port.read_socket_addr_v6/// Reads an IPv6 address with a port.read_socket_addr/// Reads an IP address with a port.parse_ascii/// Parse an IP address from a slice of bytes./// #![feature(addr_parse_ascii)]/// assert_eq!(IpAddr::parse_ascii(b"127.0.0.1"), Ok(localhost_v4));/// assert_eq!(IpAddr::parse_ascii(b"::1"), Ok(localhost_v6));/// Parse an IPv4 address from a slice of bytes./// assert_eq!(Ipv4Addr::parse_ascii(b"127.0.0.1"), Ok(localhost));/// Parse an IPv6 address from a slice of bytes./// assert_eq!(Ipv6Addr::parse_ascii(b"::1"), Ok(localhost));/// Parse an IPv4 socket address from a slice of bytes./// assert_eq!(SocketAddrV4::parse_ascii(b"127.0.0.1:8080"), Ok(socket));/// Parse an IPv6 socket address from a slice of bytes./// assert_eq!(SocketAddrV6::parse_ascii(b"[2001:db8::1]:8080"), Ok(socket));/// Parse a socket address from a slice of bytes./// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};/// let socket_v4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);/// let socket_v6 = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 8080);/// assert_eq!(SocketAddr::parse_ascii(b"127.0.0.1:8080"), Ok(socket_v4));/// assert_eq!(SocketAddr::parse_ascii(b"[::1]:8080"), Ok(socket_v6));SocketV4SocketV6/// An error which can be returned when parsing an IP address or a socket address./// [`IpAddr`], [`Ipv4Addr`], [`Ipv6Addr`], [`SocketAddr`], [`SocketAddrV4`], and/// [`SocketAddrV6`]./// # Potential causes/// `AddrParseError` may be thrown because the provided string does not parse as the given type,/// often because it includes information only handled by a different address type./// let _foo: IpAddr = "127.0.0.1:8080".parse().expect("Cannot handle the socket port");/// [`IpAddr`] doesn't handle the port. Use [`SocketAddr`] instead./// // No problem, the `panic!` message has disappeared./// let _foo: SocketAddr = "127.0.0.1:8080".parse().expect("unreachable panic");//! A private parser implementation of IPv4, IPv6, and socket addresses.//! This module is "publicly exported" through the `FromStr` implementations/// `SocketAddr` is intended to be a portable representation of socket addresses and is likely not/// the same as the internal socket address type used by the target operating system's API. Like all/// `repr(Rust)` structs, however, its exact layout remains undefined and should not be relied upon/// between builds./// `SocketAddrV4` is intended to be a portable representation of socket addresses and is likely not/// `SocketAddrV4` provides a [`FromStr`](crate::str::FromStr) implementation./// It accepts an IPv4 address in its [textual representation], followed by a/// single `:`, followed by the port encoded as a decimal integer.  Other/// formats are not accepted./// [textual representation]: Ipv4Addr#textual-representation/// `SocketAddrV6` is intended to be a portable representation of socket addresses and is likely not/// `SocketAddrV6` provides a [`FromStr`](crate::str::FromStr) implementation,/// based on the bracketed format recommended by [IETF RFC 5952],/// with scope identifiers based on those specified in [IETF RFC 4007]./// It accepts addresses consisting of the following elements, in order:///   - A left square bracket (`[`)///   - The [textual representation] of an IPv6 address///   - _Optionally_, a percent sign (`%`) followed by the scope identifier///     encoded as a decimal integer///   - A right square bracket (`]`)///   - A colon (`:`)///   - The port, encoded as a decimal integer./// For example, the string `[2001:db8::413]:443` represents a `SocketAddrV6`/// with the address `2001:db8::413` and port `443`.  The string/// `[2001:db8::413%612]:443` represents the same address and port, with a/// scope identifier of `612`./// Other formats are not accepted./// [IETF RFC 5952]: https://tools.ietf.org/html/rfc5952#section-6/// [IETF RFC 4007]: https://tools.ietf.org/html/rfc4007#section-11/// [textual representation]: Ipv6Addr#textual-representation/// let mut with_scope = socket.clone();/// with_scope.set_scope_id(3);/// assert_eq!("[2001:db8::1%3]:8080".parse(), Ok(with_scope));full_mul_add/* carry *//// Returns `(carry', v')` such that `carry' * 2^W + v' = self * other + other2 + carry`,/// where `W` is the number of bits in `Self`.full_div_rem/* quotient *//* remainder *//// Returns `(quo, rem)` such that `borrow * 2^W + self = quo * other + rem`/// and `0 <= rem < other`, where `W` is the number of bits in `Self`.FullOps/// Arithmetic operations required by bignums.impl_full_opsSMALL_POW5/// Table of powers of 5 representable in digits. Specifically, the largest {u8, u16, u32} value/// that's a power of five, plus the corresponding exponent. Used in `mul_pow5`.define_bignumDigit32/// The digit type for `Big32x40`.r" Stack-allocated arbitrary-precision (up to certain limit) integer."r#" This is backed by a fixed-size array of given type ("digit")."#r" While the array is not very large (normally some hundred bytes),"r" copying it recklessly may result in the performance hit."r" Thus this is intentionally not `Copy`."r" All operations available to bignums panic in the case of overflows."r" The caller is responsible to use large enough bignum types."r#" One plus the offset to the maximum "digit" in use."#r" This does not decrease, so be aware of the computation order."r" `base[size..]` should be zero."r" Digits. `[a, b, c, ...]` represents `a + b*2^W + c*2^(2W) + ...`"r" where `W` is the number of bits in the digit type."Big32x40r" Makes a bignum from one digit."from_smallr" Makes a bignum from `u64` value."r" Returns the internal digits as a slice `[a, b, c, ...]` such that the numeric"r" value is `a + b * 2^W + c * 2^(2W) + ...` where `W` is the number of bits in"r" the digit type."r" Returns the `i`-th bit where bit 0 is the least significant one."r" In other words, the bit with weight `2^i`."r" Returns `true` if the bignum is zero."r" Returns the number of bits necessary to represent this value. Note that zero"r" is considered to need 0 bits."r" Adds `other` to itself and returns its own mutable reference."r" Subtracts `other` from itself and returns its own mutable reference."r" Multiplies itself by a digit-sized `other` and returns its own"r" mutable reference."r" Multiplies itself by `2^bits` and returns its own mutable reference."mul_pow2r" Multiplies itself by `5^e` and returns its own mutable reference."mul_pow5r" Multiplies itself by a number described by `other[0] + other[1] * 2^W +"r" other[2] * 2^(2W) + ...` (where `W` is the number of bits in the digit type)"r" and returns its own mutable reference."mul_digitsr" Divides itself by a digit-sized `other` and returns its own"r" mutable reference *and* the remainder."div_rem_smallBig8x3// this one is used for testing only.//! Custom arbitrary-precision number (bignum) implementation.//! This is designed to avoid the heap allocation at expense of stack memory.//! The most used bignum type, `Big32x40`, is limited by 32 × 40 = 1,280 bits//! and will take at most 160 bytes of stack memory. This is more than enough//! for round-tripping all possible finite `f64` values.//! In principle it is possible to have multiple bignum types for different//! inputs, but we don't do so to avoid the code bloat. Each bignum is still//! tracked for the actual usages, so it normally doesn't matter.// This module is only for dec2flt and flt2dec, and only public because of coretests.// It is not intended to ever be stabilized./// Reads 8 bytes as a 64-bit integer in little-endian order./// Writes a 64-bit integer as 8 bytes in little-endian order./// Calculate the difference in length between two slices.parse_digits/// Iteratively parse and consume digits from bytes./// Returns the same bytes with consumed digits being elided. Breaks on invalid digits./// Helper methods to process immutable bytes.// inlining this is crucial to remove bound checksis_8digits/// Determine if all characters in an 8-byte byte string (represented as a `u64`) are all decimal/// This does not care about the order in which the bytes were loaded./// The significant digits.p_biased/// The biased, binary exponent.BiasedFp/// A custom 64-bit floating point type, representing `m * 2^p`./// p is biased, so it be directly shifted into the exponent bits.zero_pow2/// Represent `0 ^ p`//! Common utilities, for internal use only.dec2fltRawFloatINT_POW10negative/// A floating point number with up to 64 bits of mantissa and an `i64` exponent.can_use_fast_path/// Try turning the decimal into an exact float representation, using machine-sized integers/// and floats./// The number of significant digits in the decimal./// The offset of the decimal point in the significant digits./// If the number of significant digits stored in the decimal is truncated./// Buffer of the raw digits, in the range [0, 9].DecimalSeq/// A decimal floating-point number, represented as a sequence of decimal digits./// The maximum number of digits required to unambiguously round up to a 64-bit float./// For an IEEE 754 binary64 float, this required 767 digits. So we store the max digits + 1./// for IEEE754, with `emin` being the min exponent, `p2` being the/// precision, and `b` being the radix, the number of digits follows as:///     `-emin + p2 + math.floor((emin+ 1)*math.log(2, b)-math.log(1-2**(-p2), b))`MAX_DIGITS_WITHOUT_OVERFLOW/// The max decimal digits that can be exactly represented in a 64-bit integer.DECIMAL_POINT_RANGEtry_add_digit/// Append a digit to the buffer if it fits.// FIXME(tgross35): it may be better for this to return an option// FIXME(tgross35): incrementing the digit counter even if we don't push anything// seems incorrect./// Trim trailing zeros from the buffer.// FIXME(tgross35): this could be `.rev().position()` if perf is okay/// Computes decimal * 2^shift.right_shift/// Computes decimal * 2^-shift.parse_decimal_seq/// Parse a big integer representation of the float as a decimal.number_of_digits_decimal_left_shift//! Arbitrary-precision decimal type used by fallback algorithms.//! This is only used if the fast-path (native floats) and//! the Eisel-Lemire algorithm are unable to unambiguously//! determine the float.//! The technique used is "Simple Decimal Conversion", developed//! by Nigel Tao and Ken Thompson. A detailed description of the//! algorithm can be found in "ParseNumberF64 by Simple Decimal Conversion",//! available online: <https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html>./// Lossy `as` casting between two types./// Collection of traits that allow us to be generic over integer size./// The unsigned integer with the same size as the float/// Bit width of the floatSIG_TOTAL_BITS/// The number of bits in the significand, *including* the hidden bit./// The number of bits in the significand, *excluding* the hidden bit./// Number of bits in the exponent./// Signed version of `EXP_SAT` since we convert a lot./// The exponent bias value. This is also the maximum value of the exponent./// Minimum exponent value of normal values./// Round-to-even only happens for negative values of q/// when q ≥ −4 in the 64-bit case and when q ≥ −17 in/// the 32-bit case./// When q ≥ 0,we have that 5^q ≤ 2m+1. In the 64-bit case,we/// have 5^q ≤ 2m+1 ≤ 2^54 or q ≤ 23. In the 32-bit case,we have/// 5^q ≤ 2m+1 ≤ 2^25 or q ≤ 10./// When q < 0, we have w ≥ (2m+1)×5^−q. We must have that w < 2^64/// so (2m+1)×5^−q < 2^64. We have that 2m+1 > 2^53 (64-bit case)/// or 2m+1 > 2^24 (32-bit case). Hence,we must have 2^53×5^−q < 2^64/// (64-bit) and 2^24×5^−q < 2^64 (32-bit). Hence we have 5^−q < 2^11/// or q ≥ −4 (64-bit case) and 5^−q < 2^40 or q ≥ −17 (32-bit case)./// Thus we have that we only need to round ties to even when/// we have that q ∈ [−4,23](in the 64-bit case) or q∈[−17,10]/// (in the 32-bit case). In both cases,the power of five(5^|q|)/// fits in a 64-bit word./// This is the max exponent in binary converted to the max exponent in decimal. Allows fast/// pathing anything larger than `10^LARGEST_POWER_OF_TEN`, which will round to infinity./// Smallest decimal exponent for a non-zero value. This allows for fast pathing anything/// smaller than `10^SMALLEST_POWER_OF_TEN`, which will round to zero./// The smallest power of ten is represented by `⌊log10(2^-n / (2^64 - 1))⌋`, where `n` is/// the smallest power of two. The `2^64 - 1)` denominator comes from the number of values/// that are representable by the intermediate storage format. I don't actually know _why_/// the storage format is relevant here./// The values may be calculated using the formula. Unfortunately we cannot calculate them at/// compile time since intermediates exceed the range of an `f64`./// Maximum exponent for a fast path case, or `⌊(SIG_BITS+1)/log2(5)⌋`// assuming FLT_EVAL_METHOD = 0/// Minimum exponent for a fast path case, or `-⌊(SIG_BITS+1)/log2(5)⌋`/// This is `MAX_EXPONENT_FAST_PATH + ⌊(SIG_BITS+1)/log2(10)⌋`/// Maximum mantissa for the fast-path (`1 << 53` for f64)./// Converts integer into float through an as cast./// This is only called in the fast-path algorithm, and therefore/// will not lose precision, since the value will always have/// only if the value is <= Self::MAX_MANTISSA_FAST_PATH.from_u64_bits/// Performs a raw transmutation from an integer.pow10_fast_path/// Gets a small power-of-ten for fast-path multiplication./// Returns the category that this number falls into./// Transmute to the integer representation/// Returns the mantissa, exponent and sign as integers./// This returns `(m, p, s)` such that `s * m * 2^p` represents the original float. For 0, the/// exponent will be `-(EXP_BIAS + SIG_BITS)`, which is the minimum subnormal power. For/// infinity or NaN, the exponent will be `EXP_SAT - EXP_BIAS - SIG_BITS`./// If subnormal, the mantissa will be shifted one bit to the left. Otherwise, it is returned/// with the explicit bit set but otherwise unshifted/// `s` is only ever +/-1./* general constants *//* limits related to Fast pathing *//// A helper trait to avoid duplicating basically all the conversion code for IEEE floats./// See the parent module's doc comment for why this is necessary./// Should **never ever** be implemented for other types or be used outside the `dec2flt` module.pow2_to_pow10/// Solve for `b` in `10^b = 2^a`//! Helper trait for generic float types./// Compute w * 10^q using an extended-precision float representation./// a float to an extended representation with a binary float. Thisparse_inf_nanparse_long_mantissadecimal_seq// float is used in flt2dec, and all are used in unit tests.from_str_float_implr" Converts a string in base 10 to a float."r" Accepts an optional decimal exponent."r" This function accepts strings such as"r" * '3.14'"r" * '-3.14'"r" * '2.5E10', or equivalently, '2.5e10'"r" * '2.5E-10'"r" * '5.'"r" * '.5', or, equivalently, '0.5'"r" * '7'"r" * '007'"r" * 'inf', '-inf', '+infinity', 'NaN'"r" Note that alphabetical characters are not case-sensitive."r" Leading and trailing whitespace represent an error."r" # Grammar"r" All strings that adhere to the following [EBNF] grammar when"r" lowercased will result in an [`Ok`] being returned:"r" Float  ::= Sign? ( 'inf' | 'infinity' | 'nan' | Number )"r" Number ::= ( Digit+ |"r"              Digit+ '.' Digit* |"r"              Digit* '.' Digit+ ) Exp?"r" Exp    ::= 'e' Sign? Digit+"r" Sign   ::= [+-]"r" Digit  ::= [0-9]"r" [EBNF]: https://www.w3.org/TR/REC-xml/#sec-notation"r" * src - A string"r" `Err(ParseFloatError)` if the string did not represent a valid"r" number. Otherwise, `Ok(n)` where `n` is the closest"r" representable floating-point number to the number represented"r" by `src` (following the same rules for rounding as for the"r" results of primitive operations)."/// An error which can be returned when parsing a float./// This error is used as the error type for the [`FromStr`] implementation/// for [`f32`] and [`f64`]./// if let Err(e) = f64::from_str("a.12") {///     println!("Failed conversion to f64: {e}");pfe_emptypfe_invalid// Used in unit tests, keep public.// This is much better than making FloatErrorKind and ParseFloatError::kind public.biased_fp_to_float/// Converts a `BiasedFp` to the closest machine float type./// Converts a decimal string into a floating point number.// Will be inlined into a function with `#[inline(never)]`, see above//! Converting decimal strings into IEEE 754 binary floating point numbers.//! # Problem statement//! We are given a decimal string such as `12.34e56`. This string consists of integral (`12`),//! fractional (`34`), and exponent (`56`) parts. All parts are optional and interpreted as a//! default value (1 or 0) when missing.//! We seek the IEEE 754 floating point number that is closest to the exact value of the decimal//! string. It is well-known that many decimal strings do not have terminating representations in//! base two, so we round to 0.5 units in the last place (in other words, as well as possible).//! Ties, decimal values exactly half-way between two consecutive floats, are resolved with the//! half-to-even strategy, also known as banker's rounding.//! Needless to say, this is quite hard, both in terms of implementation complexity and in terms//! of CPU cycles taken.//! First, we ignore signs. Or rather, we remove it at the very beginning of the conversion//! process and re-apply it at the very end. This is correct in all edge cases since IEEE//! floats are symmetric around zero, negating one simply flips the first bit.//! Then we remove the decimal point by adjusting the exponent: Conceptually, `12.34e56` turns//! into `1234e54`, which we describe with a positive integer `f = 1234` and an integer `e = 54`.//! The `(f, e)` representation is used by almost all code past the parsing stage.//! We then try a long chain of progressively more general and expensive special cases using//! machine-sized integers and small, fixed-sized floating point numbers (first `f32`/`f64`, then//! a type with 64 bit significand). The extended-precision algorithm//! uses the Eisel-Lemire algorithm, which uses a 128-bit (or 192-bit)//! representation that can accurately and quickly compute the vast majority//! of floats. When all these fail, we bite the bullet and resort to using//! a large-decimal representation, shifting the digits into range, calculating//! the upper significant bits and exactly round to the nearest representation.//! Another aspect that needs attention is the ``RawFloat`` trait by which almost all functions//! are parametrized. One might think that it's enough to parse to `f64` and cast the result to//! `f32`. Unfortunately this is not the world we live in, and this has nothing to do with using//! base two or half-to-even rounding.//! Consider for example two types `d2` and `d4` representing a decimal type with two decimal//! digits and four decimal digits each and take "0.01499" as input. Let's use half-up rounding.//! Going directly to two decimal digits gives `0.01`, but if we round to four digits first,//! we get `0.0150`, which is then rounded up to `0.02`. The same principle applies to other//! operations as well, if you want 0.5 ULP accuracy you need to do *everything* in full precision//! and round *exactly once, at the end*, by considering all truncated bits at once.//! Primarily, this module and its children implement the algorithms described in://! "Number Parsing at a Gigabyte per Second", available online://! <https://arxiv.org/abs/2101.11408>.//! # Other//! The conversion should *never* panic. There are assertions and explicit panics in the code,//! but they should never be triggered and only serve as internal sanity checks. Any panics should//! be considered a bug.//! There are unit tests but they are woefully inadequate at ensuring correctness, they only cover//! a small percentage of possible errors. Far more extensive tests are located in the directory//! `src/tools/test-float-parse` as a Rust program.//! A note on integer overflow: Many parts of this file perform arithmetic with the decimal//! exponent `e`. Primarily, we shift the decimal point around: Before the first decimal digit,//! after the last decimal digit, and so on. This could overflow if done carelessly. We rely on//! the parsing submodule to only hand out sufficiently small exponents, where "sufficient" means//! "such that the exponent +/- the number of decimal digits fits into a 64 bit integer".//! Larger exponents are accepted, but we don't do arithmetic with them, they are immediately//! turned into {positive,negative} {zero,infinity}.//! # Notation//! This module uses the same notation as the Lemire paper://! - `m`: binary mantissa; always nonnegative//! - `p`: binary exponent; a signed integer//! - `w`: decimal significand; always nonnegative//! - `q`: decimal exponent; a signed integer//! This gives `m * 2^p` for the binary floating-point number, with `w * 10^q` as the decimal//! equivalent.MIN_19DIGIT_INTparse_8digits/// Parse 8 digits, loaded as bytes in little-endian order./// This uses the trick where every digit is in [0x030, 0x39],/// and therefore can be parsed in 3 multiplications, much/// faster than the normal 8./// This is based off the algorithm described in "Fast numeric string to/// int", available here: <https://johnnylee-sde.github.io/Fast-numeric-string-to-int/>.try_parse_digits/// Parse digits until a non-digit character is found.try_parse_19digits/// Parse up to 19 digits (the max that can be stored in a 64-bit integer).parse_scientific/// Parse the scientific notation component of a float.parse_partial_number/// Parse a partial, non-special floating point number./// This creates a representation of the float as the/// significant digits and the decimal exponent./// Try to parse a non-special floating point number,/// as well as two slices with integer and fractional parts/// and the parsed exponent./// Try to parse a special, non-finite float.//! Functions to parse floating-point numbers./// The algorithms described here are based on "Processing Long Numbers Quickly",/// available here: <https://arxiv.org/pdf/2101.11408.pdf#section.11>.//! Slow, fallback algorithm for cases the Eisel-Lemire algorithm cannot round.//! DO NOT MODIFY: Generated by `src/etc/dec2flt_table.py`/// The integer mantissa./// The exponent in base 2./// A custom 64-bit floating point type, representing `f * 2^e`./// Returns a correctly rounded product of itself and `other`./// Normalizes itself so that the resulting mantissa is at least `2^63`.normalize_to/// Normalizes itself to have the shared exponent./// It can only decrease the exponent (and thus increase the mantissa).//! Extended precision "soft float", for internal use only./// The error type returned when a checked integral type conversion fails./// An error which can be returned when parsing an integer./// For example, this error is returned by the `from_str_radix()` functions/// on the primitive integer types (such as [`i8::from_str_radix`])/// and is used as the error type in their [`FromStr`] implementations./// Among other causes, `ParseIntError` can be thrown because of leading or trailing whitespace/// in the string e.g., when it is obtained from the standard input./// Using the [`str::trim()`] method ensures that no whitespace remains before parsing./// if let Err(e) = i32::from_str_radix("a12", 10) {///     println!("Failed conversion to i32: {e}");/// Value being parsed is empty./// This variant will be constructed when parsing an empty string./// Contains an invalid digit in its context./// Among other causes, this variant will be constructed when parsing a string that/// contains a non-ASCII char./// This variant is also constructed when a `+` or `-` is misplaced within a string/// either on its own or in the middle of a number.PosOverflow/// Integer is too large to store in target integer type.NegOverflow/// Integer is too small to store in target integer type./// Value was Zero/// This variant will be emitted when the parsing string has a value of zero, which/// would be illegal for non-zero types./// Enum to store the various types of errors that can cause parsing an integer to fail.///     println!("Failed conversion to i32: {:?}", e.kind());//! Error types for conversion to integral types."f128_consts_mod"/// The full circle constant (τ)/// Equal to 2π.PHI/// The golden ratio (φ)// Also, #[unstable(feature = "more_float_constants", issue = "146939")]EGAMMA/// The Euler-Mascheroni constant (γ)FRAC_1_SQRT_PI/// 1/sqrt(π)FRAC_1_SQRT_2PI/// 1/sqrt(2π)SQRT_3/// sqrt(3)FRAC_1_SQRT_3/// 1/sqrt(3)/// Euler's number (e)/// log<sub>2</sub>(10)/// log<sub>10</sub>(2)// FIXME: replace with mathematical constants from cmath./// Basic mathematical constants./// The radix or base of the internal representation of `f128`./// Note that the size of the mantissa in the bitwise representation is one/// smaller than this since the leading 1 is not stored explicitly./// This is the maximum <i>x</i> such that any decimal number with <i>x</i>/// significant digits can be converted to `f128` and back without loss./// Equal to floor(log<sub>10</sub>&nbsp;2<sup>[`MANTISSA_DIGITS`]&nbsp;&minus;&nbsp;1</sup>)./// [`MANTISSA_DIGITS`]: f128::MANTISSA_DIGITS"f128_epsilon"/// [Machine epsilon] value for `f128`./// This is the difference between `1.0` and the next larger representable number./// Equal to 2<sup>1&nbsp;&minus;&nbsp;[`MANTISSA_DIGITS`]</sup>./// Smallest finite `f128` value./// Equal to &minus;[`MAX`]./// [`MAX`]: f128::MAX/// Smallest positive normal `f128` value./// Equal to 2<sup>[`MIN_EXP`]&nbsp;&minus;&nbsp;1</sup>./// [`MIN_EXP`]: f128::MIN_EXP/// Largest finite `f128` value./// Equal to/// (1&nbsp;&minus;&nbsp;2<sup>&minus;[`MANTISSA_DIGITS`]</sup>)&nbsp;2<sup>[`MAX_EXP`]</sup>./// [`MAX_EXP`]: f128::MAX_EXP/// One greater than the minimum possible *normal* power of 2 exponent/// for a significand bounded by 1 ≤ x < 2 (i.e. the IEEE definition)./// This corresponds to the exact minimum possible *normal* power of 2 exponent/// for a significand bounded by 0.5 ≤ x < 1 (i.e. the C definition)./// In other words, all normal numbers representable by this type are/// greater than or equal to 0.5&nbsp;×&nbsp;2<sup><i>MIN_EXP</i></sup>./// One greater than the maximum possible power of 2 exponent/// This corresponds to the exact maximum possible power of 2 exponent/// In other words, all numbers representable by this type are/// strictly less than 2<sup><i>MAX_EXP</i></sup>./// Minimum <i>x</i> for which 10<sup><i>x</i></sup> is normal./// Equal to ceil(log<sub>10</sub>&nbsp;[`MIN_POSITIVE`])./// [`MIN_POSITIVE`]: f128::MIN_POSITIVE/// Maximum <i>x</i> for which 10<sup><i>x</i></sup> is normal./// Equal to floor(log<sub>10</sub>&nbsp;[`MAX`])."f128_nan"/// Note that IEEE 754 doesn't define just a single NaN value; a plethora of bit patterns are/// considered to be NaN. Furthermore, the standard makes a difference between a "signaling" and/// a "quiet" NaN, and allows inspecting its "payload" (the unspecified bits in the bit pattern)/// and its sign. See the [specification of NaN bit patterns](f32#nan-bit-patterns) for more/// This constant is guaranteed to be a quiet NaN (on targets that follow the Rust assumptions/// that the quiet/signaling bit being set to 1 indicates a quiet NaN). Beyond that, nothing is/// guaranteed about the specific bit pattern chosen here: both payload and sign are arbitrary./// The concrete bit pattern may change across Rust versions and target platforms./// Sign bit/// Exponent maskMAN_MASK/// Mantissa mask/// Minimum representable positive value (min subnormal)NEG_TINY_BITS/// Minimum representable negative value (min negative subnormal)/// Returns `true` if this value is NaN./// #![feature(f128)]/// # // FIXME(f16_f128): remove when `unordtf2` is available/// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {/// let nan = f128::NAN;/// let f = 7.0_f128;// > if you intended to check if the operand is NaN, use `.is_nan()` instead :)/// # // FIXME(f16_f128): remove when `eqtf2` is available/// let f = 7.0f128;/// let inf = f128::INFINITY;/// let neg_inf = f128::NEG_INFINITY;/// # // FIXME(f16_f128): remove when `lttf2` is available/// let inf: f128 = f128::INFINITY;/// let neg_inf: f128 = f128::NEG_INFINITY;/// let nan: f128 = f128::NAN;/// let min = f128::MIN_POSITIVE; // 3.362103143e-4932f128/// let max = f128::MAX;/// let lower_than_min = 1.0e-4960_f128;/// let zero = 0.0_f128;/// assert!(!f128::NAN.is_subnormal());/// assert!(!f128::INFINITY.is_subnormal());/// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number/// Returns `true` if the number is neither zero, infinite, [subnormal], or NaN./// assert!(!f128::NAN.is_normal());/// assert!(!f128::INFINITY.is_normal());/// let num = 12.4_f128;/// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with/// positive sign bit and positive infinity./// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of/// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are/// conserved over arithmetic operations, the result of `is_sign_positive` on/// a NaN might produce an unexpected or non-portable result. See the [specification/// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == 1.0`/// if you need fully portable behavior (will return `false` for all NaNs)./// let g = -7.0_f128;/// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with/// negative sign bit and negative infinity./// conserved over arithmetic operations, the result of `is_sign_negative` on/// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == -1.0`/// Returns the least number greater than `self`./// Let `TINY` be the smallest representable positive `f128`. Then,///  - if `self.is_nan()`, this returns `self`;///  - if `self` is [`NEG_INFINITY`], this returns [`MIN`];///  - if `self` is `-TINY`, this returns -0.0;///  - if `self` is -0.0 or +0.0, this returns `TINY`;///  - if `self` is [`MAX`] or [`INFINITY`], this returns [`INFINITY`];///  - otherwise the unique least value greater than `self` is returned./// The identity `x.next_up() == -(-x).next_down()` holds for all non-NaN `x`. When `x`/// is finite `x == x.next_up().next_down()` also holds./// // f128::EPSILON is the difference between 1.0 and the next number up./// assert_eq!(1.0f128.next_up(), 1.0 + f128::EPSILON);/// // But not for most numbers./// assert!(0.1f128.next_up() < 0.1 + f128::EPSILON);/// assert_eq!(4611686018427387904f128.next_up(), 4611686018427387904.000000000000001);/// This operation corresponds to IEEE-754 `nextUp`./// [`NEG_INFINITY`]: Self::NEG_INFINITY/// [`INFINITY`]: Self::INFINITY/// [`MIN`]: Self::MIN/// [`MAX`]: Self::MAX/// Returns the greatest number less than `self`.///  - if `self` is [`INFINITY`], this returns [`MAX`];///  - if `self` is `TINY`, this returns 0.0;///  - if `self` is -0.0 or +0.0, this returns `-TINY`;///  - if `self` is [`MIN`] or [`NEG_INFINITY`], this returns [`NEG_INFINITY`];///  - otherwise the unique greatest value less than `self` is returned./// The identity `x.next_down() == -(-x).next_up()` holds for all non-NaN `x`. When `x`/// is finite `x == x.next_down().next_up()` also holds./// let x = 1.0f128;/// // Clamp value into range [0, 1)./// let clamped = x.clamp(0.0, 1.0f128.next_down());/// assert!(clamped < 1.0);/// assert_eq!(clamped.next_up(), 1.0);/// This operation corresponds to IEEE-754 `nextDown`./// let x = 2.0_f128;/// let abs_difference = (x.recip() - (1.0 / x)).abs();/// assert!(abs_difference <= f128::EPSILON);/// # Unspecified precision/// The precision of this function is non-deterministic. This means it varies by platform,/// Rust version, and can even differ within the same execution from one invocation to the next./// let angle = std::f128::consts::PI;/// let angle = 180.0f128;/// let abs_difference = (angle.to_radians() - std::f128::consts::PI).abs();/// assert!(abs_difference <= 1e-30);"this returns the result of the comparison, without modifying either input"/// Returns the maximum of the two numbers, ignoring NaN./// If exactly one of the arguments is NaN, then the other argument is returned. If both/// arguments are NaN, the return value is NaN, with the bit pattern picked using the usual/// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such/// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically./// This follows the IEEE 754-2008 semantics for `maxNum`, except for handling of signaling NaNs;/// this function handles all NaNs the same way and avoids `maxNum`'s problems with associativity./// This also matches the behavior of libm’s `fmax`./// # // Using aarch64 because `reliable_f128_math` is needed/// # #[cfg(all(target_arch = "aarch64", target_os = "linux"))] {/// let y = 2.0f128;/// assert_eq!(x.max(f128::NAN), x);/// Returns the minimum of the two numbers, ignoring NaN./// This follows the IEEE 754-2008 semantics for `minNum`, except for handling of signaling NaNs;/// this function handles all NaNs the same way and avoids `minNum`'s problems with associativity./// This also matches the behavior of libm’s `fmin`./// assert_eq!(x.min(f128::NAN), x);/// Returns the maximum of the two numbers, propagating NaN./// If at least one of the arguments is NaN, the return value is NaN, with the bit pattern/// picked using the usual [rules for arithmetic operations](f32#nan-bit-patterns). Furthermore,/// `-0.0` is considered to be less than `+0.0`, making this function fully deterministic for/// non-NaN inputs./// This is in contrast to [`f128::max`] which only returns NaN when *both* arguments are NaN,/// and which does not reliably order `-0.0` and `+0.0`./// This follows the IEEE 754-2019 semantics for `maximum`./// #![feature(float_minimum_maximum)]/// assert_eq!(x.maximum(y), y);/// assert!(x.maximum(f128::NAN).is_nan());// #[unstable(feature = "float_minimum_maximum", issue = "91079")]/// Returns the minimum of the two numbers, propagating NaN./// This is in contrast to [`f128::min`] which only returns NaN when *both* arguments are NaN,/// This follows the IEEE 754-2019 semantics for `minimum`./// assert_eq!(x.minimum(y), x);/// assert!(x.minimum(f128::NAN).is_nan());/// Calculates the midpoint (average) between `self` and `rhs`./// This returns NaN when *either* argument is NaN or if a combination of/// +inf and -inf is provided as arguments./// assert_eq!(1f128.midpoint(4.0), 2.5);/// assert_eq!((-5.5f128).midpoint(8.0), 1.25);/// Rounds toward zero and converts to any primitive integer type,/// assuming that the value is finite and fits in that type./// # // FIXME(f16_f128): remove when `float*itf` is available/// let value = 4.6_f128;/// let rounded = unsafe { value.to_int_unchecked::<u16>() };/// assert_eq!(rounded, 4);/// let value = -128.9_f128;/// let rounded = unsafe { value.to_int_unchecked::<i8>() };/// assert_eq!(rounded, i8::MIN);/// The value must:/// * Be representable in the return type `Int`, after truncating off its fractional part/// Raw transmutation to `u128`./// This is currently identical to `transmute::<f128, u128>(self)` on all platforms./// See [`from_bits`](#method.from_bits) for some discussion of the/// portability of this operation (there are almost no issues)./// # // FIXME(f16_f128): enable this once const casting works/// # // assert_ne!((1f128).to_bits(), 1f128 as u128); // to_bits() is not casting!/// assert_eq!((12.5f128).to_bits(), 0x40029000000000000000000000000000);/// Raw transmutation from `u128`./// This is currently identical to `transmute::<u128, f128>(v)` on all platforms./// It turns out this is incredibly portable, for two reasons:/// * Floats and Ints have the same endianness on all supported platforms./// * IEEE 754 very precisely specifies the bit layout of floats./// However there is one caveat: prior to the 2008 version of IEEE 754, how/// to interpret the NaN signaling bit wasn't actually specified. Most platforms/// (notably x86 and ARM) picked the interpretation that was ultimately/// standardized in 2008, but some didn't (notably MIPS). As a result, all/// signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa./// #  // FIXME(f16_f128): remove when `eqtf2` is available/// let v = f128::from_bits(0x40029000000000000000000000000000);/// assert_eq!(v, 12.5);/// Returns the memory representation of this floating point number as a byte array in/// See [`from_bits`](Self::from_bits) for some discussion of the/// let bytes = 12.5f128.to_be_bytes();///     bytes,///     [0x40, 0x02, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00,///      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]/// let bytes = 12.5f128.to_le_bytes();///     [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,///      0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x02, 0x40]/// As the target platform's native endianness is used, portable code/// should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate, instead./// [`to_be_bytes`]: f128::to_be_bytes/// [`to_le_bytes`]: f128::to_le_bytes/// let bytes = 12.5f128.to_ne_bytes();///     if cfg!(target_endian = "big") {///         [0x40, 0x02, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00,///          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]///         [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,///          0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x02, 0x40]/// let value = f128::from_be_bytes(/// assert_eq!(value, 12.5);/// let value = f128::from_le_bytes(/// likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as/// [`from_be_bytes`]: f128::from_be_bytes/// [`from_le_bytes`]: f128::from_le_bytes/// let value = f128::from_ne_bytes(if cfg!(target_endian = "big") {/// [`PartialOrd`] and [`PartialEq`] implementations of `f128`. For example,/// struct GoodBoy {///     name: &'static str,///     weight: f128,/// let mut bois = vec![///     GoodBoy { name: "Pucci", weight: 0.1 },///     GoodBoy { name: "Woofer", weight: 99.0 },///     GoodBoy { name: "Yapper", weight: 10.0 },///     GoodBoy { name: "Chonk", weight: f128::INFINITY },///     GoodBoy { name: "Abs. Unit", weight: f128::NAN },///     GoodBoy { name: "Floaty", weight: -5.0 },/// bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));/// // `f128::NAN` could be positive or negative, which will affect the sort order./// if f128::NAN.is_sign_negative() {///     bois.into_iter().map(|b| b.weight)///         .zip([f128::NAN, -5.0, 0.1, 10.0, 99.0, f128::INFINITY].iter())///         .for_each(|(a, b)| assert_eq!(a.to_bits(), b.to_bits()))///         .zip([-5.0, 0.1, 10.0, 99.0, f128::INFINITY, f128::NAN].iter())"method returns a new number and does not mutate the original value"/// Note that this function returns NaN if the initial value was NaN as/// well. If the result is zero and among the three inputs `self`, `min`, and `max` there are/// zeros with different sign, either `0.0` or `-0.0` is returned non-deterministically./// # // FIXME(f16_f128): remove when `{eq,gt,unord}tf` are available/// assert!((-3.0f128).clamp(-2.0, 1.0) == -2.0);/// assert!((0.0f128).clamp(-2.0, 1.0) == 0.0);/// assert!((2.0f128).clamp(-2.0, 1.0) == 1.0);/// assert!((f128::NAN).clamp(-2.0, 1.0).is_nan());/// // These always returns zero, but the sign (which is ignored by `==`) is non-deterministic./// assert!((0.0f128).clamp(-0.0, -0.0) == 0.0);/// assert!((1.0f128).clamp(-0.0, 0.0) == 0.0);/// // This is definitely a negative zero./// assert!((-1.0f128).clamp(-0.0, 1.0).is_sign_negative());"this returns the clamped value and does not modify the original"clamp_magnitude/// Clamps this number to a symmetric range centered around zero./// The method clamps the number's magnitude (absolute value) to be at most `limit`./// This is functionally equivalent to `self.clamp(-limit, limit)`, but is more/// explicit about the intent./// Panics if `limit` is negative or NaN, as this indicates a logic error./// #![feature(clamp_magnitude)]/// assert_eq!(5.0f128.clamp_magnitude(3.0), 3.0);/// assert_eq!((-5.0f128).clamp_magnitude(3.0), -3.0);/// assert_eq!(2.0f128.clamp_magnitude(3.0), 2.0);/// assert_eq!((-2.0f128).clamp_magnitude(3.0), -2.0);/// This function always returns the precise result./// let x = 3.5_f128;/// let y = -3.5_f128;/// assert_eq!(x.abs(), x);/// assert_eq!(y.abs(), -y);/// assert!(f128::NAN.abs().is_nan());/// let f = 3.5_f128;/// assert_eq!(f128::NEG_INFINITY.signum(), -1.0);/// assert!(f128::NAN.signum().is_nan());/// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is/// If `sign` is a NaN, then this operation will still carry over its sign into the result. Note/// that IEEE 754 doesn't assign any meaning to the sign bit in case of a NaN, and as Rust/// doesn't guarantee that the bit pattern of NaNs are conserved over arithmetic operations, the/// result of `copysign` with `sign` being a NaN might produce an unexpected or non-portable/// result. See the [specification of NaN bit patterns](primitive@f32#nan-bit-patterns) for more/// assert_eq!(f.copysign(0.42), 3.5_f128);/// assert_eq!(f.copysign(-0.42), -3.5_f128);/// assert_eq!((-f).copysign(0.42), 3.5_f128);/// assert_eq!((-f).copysign(-0.42), -3.5_f128);/// assert!(f128::NAN.copysign(1.0).is_nan());algebraic_add/// See [algebraic operators](primitive@f32#algebraic-operators) for more info.algebraic_subalgebraic_mulalgebraic_divalgebraic_rem// FIXME(f16_f128): almost all methods in this `impl` are missing examples and a const// implementation. Add these once we can run code on all platforms and have f16/f128 in CTFE./// # #[cfg(not(miri))]/// # #[cfg(target_has_reliable_f128_math)] {/// let f = 3.7_f128;/// let g = 3.0_f128;/// let h = -3.7_f128;/// assert_eq!(h.floor(), -4.0);/// let f = 3.01_f128;/// let g = 4.0_f128;/// let f = 3.3_f128;/// let g = -3.3_f128;/// let i = 3.5_f128;/// let j = 4.5_f128;/// assert_eq!(h.round(), -4.0);/// assert_eq!(i.round(), 4.0);/// assert_eq!(j.round(), 5.0);round_ties_even/// Returns the nearest integer to a number. Rounds half-way cases to the number/// with an even least significant digit./// let h = 3.5_f128;/// let i = 4.5_f128;/// assert_eq!(f.round_ties_even(), 3.0);/// assert_eq!(g.round_ties_even(), -3.0);/// assert_eq!(h.round_ties_even(), 4.0);/// assert_eq!(i.round_ties_even(), 4.0);/// assert_eq!(g.trunc(), 3.0);/// assert_eq!(h.trunc(), -3.0);/// let x = 3.6_f128;/// let y = -3.6_f128;/// let abs_difference_x = (x.fract() - 0.6).abs();/// let abs_difference_y = (y.fract() - (-0.6)).abs();/// assert!(abs_difference_x <= f128::EPSILON);/// assert!(abs_difference_y <= f128::EPSILON);/// The result of this operation is guaranteed to be the rounded/// infinite-precision result. It is specified by IEEE 754 as/// `fusedMultiplyAdd` and guaranteed not to change./// let m = 10.0_f128;/// let x = 4.0_f128;/// let b = 60.0_f128;/// assert_eq!(m.mul_add(x, b), 100.0);/// assert_eq!(m * x + b, 100.0);/// let one_plus_eps = 1.0_f128 + f128::EPSILON;/// let one_minus_eps = 1.0_f128 - f128::EPSILON;/// let minus_one = -1.0_f128;/// // The exact result (1 + eps) * (1 - eps) = 1 - eps * eps./// assert_eq!(one_plus_eps.mul_add(one_minus_eps, minus_one), -f128::EPSILON * f128::EPSILON);/// // Different rounding with the non-fused multiply and add./// assert_eq!(one_plus_eps * one_minus_eps + minus_one, 0.0);/// infinite-precision result./// let a: f128 = 7.0;/// assert_eq!(a.div_euclid(b), 1.0); // 7.0 > 4.0 * 1.0/// assert_eq!((-a).div_euclid(b), -2.0); // -7.0 >= 4.0 * -2.0/// assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0/// assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0/// assert_eq!(a.rem_euclid(b), 3.0);/// assert_eq!((-a).rem_euclid(b), 1.0);/// assert_eq!(a.rem_euclid(-b), 3.0);/// assert_eq!((-a).rem_euclid(-b), 1.0);/// assert!((-f128::EPSILON).rem_euclid(3.0) != 0.0);/// Note that this function is special in that it can return non-NaN results for NaN inputs. For/// example, `f128::powi(f128::NAN, 0)` returns `1.0`. However, if an input is a *signaling*/// NaN, then the result is non-deterministically either a NaN or the result that the/// corresponding quiet NaN would produce./// let abs_difference = (x.powi(2) - (x * x)).abs();/// assert_eq!(f128::powi(f128::NAN, 0), 1.0);/// assert_eq!(f128::powi(0.0, 0), 1.0);/// infinite-precision result. It is specified by IEEE 754 as `squareRoot`/// and guaranteed not to change./// let positive = 4.0_f128;/// let negative = -4.0_f128;/// let negative_zero = -0.0_f128;/// assert_eq!(positive.sqrt(), 2.0);/// assert!(negative_zero.sqrt() == negative_zero);// Functions in this module fall into `core_float_math`// FIXME(f16_f128): all doctests must be gated to platforms that have `long double` === `_Float128`// due to https://github.com/llvm/llvm-project/issues/44744. aarch64 linux matches this.// #[unstable(feature = "core_float_math", issue = "137578")]//! Constants for the `f128` quadruple-precision floating point type.//! *[See also the `f128` primitive type][f128].*//! Mathematically significant numbers are provided in the `consts` sub-module.//! For the constants defined directly in this module//! (as distinct from those defined in the `consts` sub-module),//! new code should instead use the associated constants//! defined directly on the `f128` type."f16_consts_mod"/// The radix or base of the internal representation of `f16`./// significant digits can be converted to `f16` and back without loss./// [`MANTISSA_DIGITS`]: f16::MANTISSA_DIGITS"f16_epsilon"/// [Machine epsilon] value for `f16`./// Smallest finite `f16` value./// [`MAX`]: f16::MAX/// Smallest positive normal `f16` value./// [`MIN_EXP`]: f16::MIN_EXP/// Largest finite `f16` value./// [`MAX_EXP`]: f16::MAX_EXP/// [`MIN_POSITIVE`]: f16::MIN_POSITIVE"f16_nan"/// #![feature(f16)]/// let f = 7.0_f16;/// let f = 7.0f16;/// let inf: f16 = f16::INFINITY;/// let neg_inf: f16 = f16::NEG_INFINITY;/// let nan: f16 = f16::NAN;/// let min = f16::MIN_POSITIVE; // 6.1035e-5/// let lower_than_min = 1.0e-7_f16;/// let zero = 0.0_f16;/// assert!(!f16::NAN.is_subnormal());/// assert!(!f16::INFINITY.is_subnormal());/// let num = 12.4_f16;/// # // FIXME(f16_f128): LLVM crashes on s390x, llvm/llvm-project#50374/// let g = -7.0_f16;/// Let `TINY` be the smallest representable positive `f16`. Then,/// # // FIXME(f16_f128): ABI issues on MSVC/// // f16::EPSILON is the difference between 1.0 and the next number up./// assert_eq!(1.0f16.next_up(), 1.0 + f16::EPSILON);/// assert!(0.1f16.next_up() < 0.1 + f16::EPSILON);/// assert_eq!(4356f16.next_up(), 4360.0);/// let x = 1.0f16;/// let clamped = x.clamp(0.0, 1.0f16.next_down());/// # // FIXME(f16_f128): extendhfsf2, truncsfhf2, __gnu_h2f_ieee, __gnu_f2h_ieee missing for many platforms/// let x = 2.0_f16;/// assert!(abs_difference <= f16::EPSILON);/// let angle = std::f16::consts::PI;/// assert!(abs_difference <= 0.5);/// let angle = 180.0f16;/// let abs_difference = (angle.to_radians() - std::f16::consts::PI).abs();/// assert!(abs_difference <= 0.01);/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885/// let y = 2.0f16;/// assert_eq!(x.max(f16::NAN), x);/// assert_eq!(x.min(f16::NAN), x);/// This is in contrast to [`f16::max`] which only returns NaN when *both* arguments are NaN,/// assert!(x.maximum(f16::NAN).is_nan());/// This is in contrast to [`f16::min`] which only returns NaN when *both* arguments are NaN,/// assert!(x.minimum(f16::NAN).is_nan());/// assert_eq!(1f16.midpoint(4.0), 2.5);/// assert_eq!((-5.5f16).midpoint(8.0), 1.25);/// let value = 4.6_f16;/// let value = -128.9_f16;/// Raw transmutation to `u16`./// This is currently identical to `transmute::<f16, u16>(self)` on all platforms./// # // assert_ne!((1f16).to_bits(), 1f16 as u128); // to_bits() is not casting!/// assert_eq!((12.5f16).to_bits(), 0x4a40);/// Raw transmutation from `u16`./// This is currently identical to `transmute::<u16, f16>(v)` on all platforms./// let v = f16::from_bits(0x4a40);/// let bytes = 12.5f16.to_be_bytes();/// assert_eq!(bytes, [0x4a, 0x40]);/// let bytes = 12.5f16.to_le_bytes();/// assert_eq!(bytes, [0x40, 0x4a]);/// [`to_be_bytes`]: f16::to_be_bytes/// [`to_le_bytes`]: f16::to_le_bytes/// let bytes = 12.5f16.to_ne_bytes();///         [0x4a, 0x40]///         [0x40, 0x4a]/// let value = f16::from_be_bytes([0x4a, 0x40]);/// let value = f16::from_le_bytes([0x40, 0x4a]);/// [`from_be_bytes`]: f16::from_be_bytes/// [`from_le_bytes`]: f16::from_le_bytes///     [0x4a, 0x40]///     [0x40, 0x4a]///     weight: f16,///     GoodBoy { name: "Chonk", weight: f16::INFINITY },///     GoodBoy { name: "Abs. Unit", weight: f16::NAN },/// // `f16::NAN` could be positive or negative, which will affect the sort order./// if f16::NAN.is_sign_negative() {///         .zip([f16::NAN, -5.0, 0.1, 10.0, 99.0, f16::INFINITY].iter())///         .zip([-5.0, 0.1, 10.0, 99.0, f16::INFINITY, f16::NAN].iter())/// assert!((-3.0f16).clamp(-2.0, 1.0) == -2.0);/// assert!((0.0f16).clamp(-2.0, 1.0) == 0.0);/// assert!((2.0f16).clamp(-2.0, 1.0) == 1.0);/// assert!((f16::NAN).clamp(-2.0, 1.0).is_nan());/// assert!((0.0f16).clamp(-0.0, -0.0) == 0.0);/// assert!((1.0f16).clamp(-0.0, 0.0) == 0.0);/// assert!((-1.0f16).clamp(-0.0, 1.0).is_sign_negative());/// assert_eq!(5.0f16.clamp_magnitude(3.0), 3.0);/// assert_eq!((-5.0f16).clamp_magnitude(3.0), -3.0);/// assert_eq!(2.0f16.clamp_magnitude(3.0), 2.0);/// assert_eq!((-2.0f16).clamp_magnitude(3.0), -2.0);/// let x = 3.5_f16;/// let y = -3.5_f16;/// assert!(f16::NAN.abs().is_nan());/// let f = 3.5_f16;/// assert_eq!(f16::NEG_INFINITY.signum(), -1.0);/// assert_eq!(f.copysign(0.42), 3.5_f16);/// assert_eq!(f.copysign(-0.42), -3.5_f16);/// assert_eq!((-f).copysign(0.42), 3.5_f16);/// assert_eq!((-f).copysign(-0.42), -3.5_f16);/// assert!(f16::NAN.copysign(1.0).is_nan());/// # #[cfg(target_has_reliable_f16_math)] {/// let f = 3.7_f16;/// let g = 3.0_f16;/// let h = -3.7_f16;/// let f = 3.01_f16;/// let g = 4.0_f16;/// let f = 3.3_f16;/// let g = -3.3_f16;/// let i = 3.5_f16;/// let j = 4.5_f16;/// let h = 3.5_f16;/// let i = 4.5_f16;/// let x = 3.6_f16;/// let y = -3.6_f16;/// assert!(abs_difference_x <= f16::EPSILON);/// assert!(abs_difference_y <= f16::EPSILON);/// let m = 10.0_f16;/// let x = 4.0_f16;/// let b = 60.0_f16;/// let one_plus_eps = 1.0_f16 + f16::EPSILON;/// let one_minus_eps = 1.0_f16 - f16::EPSILON;/// let minus_one = -1.0_f16;/// assert_eq!(one_plus_eps.mul_add(one_minus_eps, minus_one), -f16::EPSILON * f16::EPSILON);/// let a: f16 = 7.0;/// assert!((-f16::EPSILON).rem_euclid(3.0) != 0.0);/// example, `f16::powi(f16::NAN, 0)` returns `1.0`. However, if an input is a *signaling*/// assert_eq!(f16::powi(f16::NAN, 0), 1.0);/// assert_eq!(f16::powi(0.0, 0), 1.0);/// let positive = 4.0_f16;/// let negative = -4.0_f16;/// let negative_zero = -0.0_f16;/// This function currently corresponds to the `cbrtf` from libc on Unix/// and Windows. Note that this might change in the future./// let x = 8.0f16;//! Constants for the `f16` half-precision floating point type.//! *[See also the `f16` primitive type][f16].*//! defined directly on the `f16` type."f32_legacy_const_radix"/// Use [`f32::RADIX`] instead./// // deprecated way/// # #[allow(deprecated, deprecated_in_future)]/// let r = std::f32::RADIX;/// // intended way/// let r = f32::RADIX;"f32_legacy_const_mantissa_dig"/// Use [`f32::MANTISSA_DIGITS`] instead./// let d = std::f32::MANTISSA_DIGITS;/// let d = f32::MANTISSA_DIGITS;"f32_legacy_const_digits"/// Use [`f32::DIGITS`] instead./// let d = std::f32::DIGITS;/// let d = f32::DIGITS;"f32_legacy_const_epsilon"/// Use [`f32::EPSILON`] instead./// let e = std::f32::EPSILON;/// let e = f32::EPSILON;"f32_legacy_const_min"/// Use [`f32::MIN`] instead./// let min = std::f32::MIN;/// let min = f32::MIN;"f32_legacy_const_min_positive"/// Use [`f32::MIN_POSITIVE`] instead./// let min = std::f32::MIN_POSITIVE;/// let min = f32::MIN_POSITIVE;"f32_legacy_const_max"/// Use [`f32::MAX`] instead./// let max = std::f32::MAX;"f32_legacy_const_min_exp"/// Use [`f32::MIN_EXP`] instead./// let min = std::f32::MIN_EXP;/// let min = f32::MIN_EXP;"f32_legacy_const_max_exp"/// Use [`f32::MAX_EXP`] instead./// let max = std::f32::MAX_EXP;/// let max = f32::MAX_EXP;"f32_legacy_const_min_10_exp"/// Use [`f32::MIN_10_EXP`] instead./// let min = std::f32::MIN_10_EXP;/// let min = f32::MIN_10_EXP;"f32_legacy_const_max_10_exp"/// Use [`f32::MAX_10_EXP`] instead./// let max = std::f32::MAX_10_EXP;/// let max = f32::MAX_10_EXP;"f32_legacy_const_nan"/// Use [`f32::NAN`] instead./// let nan = std::f32::NAN;/// let nan = f32::NAN;"f32_legacy_const_infinity"/// Use [`f32::INFINITY`] instead./// let inf = std::f32::INFINITY;"f32_legacy_const_neg_infinity"/// Use [`f32::NEG_INFINITY`] instead./// let ninf = std::f32::NEG_INFINITY;/// let ninf = f32::NEG_INFINITY;"f32_consts_mod"/// significant digits can be converted to `f32` and back without loss./// [`MANTISSA_DIGITS`]: f32::MANTISSA_DIGITS"f32_epsilon"/// [`MAX`]: f32::MAX/// [`MIN_EXP`]: f32::MIN_EXP/// [`MAX_EXP`]: f32::MAX_EXP/// [`MIN_POSITIVE`]: f32::MIN_POSITIVE"f32_nan"/// let f = 7.0_f32;/// let neg_inf = f32::NEG_INFINITY;/// let zero = 0.0_f32;/// assert!(!f32::NAN.is_subnormal());/// assert!(!f32::INFINITY.is_subnormal());/// [subnormal], or NaN./// let num = 12.4_f32;/// let g = -7.0_f32;/// let g = -7.0f32;/// Let `TINY` be the smallest representable positive `f32`. Then,/// // f32::EPSILON is the difference between 1.0 and the next number up./// assert_eq!(1.0f32.next_up(), 1.0 + f32::EPSILON);/// assert!(0.1f32.next_up() < 0.1 + f32::EPSILON);/// assert_eq!(16777216f32.next_up(), 16777218.0);/// let x = 1.0f32;/// let clamped = x.clamp(0.0, 1.0f32.next_down());/// let x = 2.0_f32;/// assert!(abs_difference <= f32::EPSILON);/// let angle = std::f32::consts::PI;/// # #[cfg(any(not(target_arch = "x86"), target_feature = "sse2"))]/// let angle = 180.0f32;/// let abs_difference = (angle.to_radians() - std::f32::consts::PI).abs();/// let y = 2.0f32;/// assert_eq!(x.max(f32::NAN), x);/// assert_eq!(x.min(f32::NAN), x);/// This is in contrast to [`f32::max`] which only returns NaN when *both* arguments are NaN,/// assert!(x.maximum(f32::NAN).is_nan());/// This is in contrast to [`f32::min`] which only returns NaN when *both* arguments are NaN,/// assert!(x.minimum(f32::NAN).is_nan());/// assert_eq!(1f32.midpoint(4.0), 2.5);/// assert_eq!((-5.5f32).midpoint(8.0), 1.25);/// let value = 4.6_f32;/// let value = -128.9_f32;/// This is currently identical to `transmute::<f32, u32>(self)` on all platforms./// assert_ne!((1f32).to_bits(), 1f32 as u32); // to_bits() is not casting!/// assert_eq!((12.5f32).to_bits(), 0x41480000);/// This is currently identical to `transmute::<u32, f32>(v)` on all platforms./// let v = f32::from_bits(0x41480000);/// let bytes = 12.5f32.to_be_bytes();/// assert_eq!(bytes, [0x41, 0x48, 0x00, 0x00]);/// let bytes = 12.5f32.to_le_bytes();/// assert_eq!(bytes, [0x00, 0x00, 0x48, 0x41]);/// [`to_be_bytes`]: f32::to_be_bytes/// [`to_le_bytes`]: f32::to_le_bytes/// let bytes = 12.5f32.to_ne_bytes();///         [0x41, 0x48, 0x00, 0x00]///         [0x00, 0x00, 0x48, 0x41]/// let value = f32::from_be_bytes([0x41, 0x48, 0x00, 0x00]);/// let value = f32::from_le_bytes([0x00, 0x00, 0x48, 0x41]);/// [`from_be_bytes`]: f32::from_be_bytes/// [`from_le_bytes`]: f32::from_le_bytes/// let value = f32::from_ne_bytes(if cfg!(target_endian = "big") {///     [0x41, 0x48, 0x00, 0x00]///     [0x00, 0x00, 0x48, 0x41]/// [`PartialOrd`] and [`PartialEq`] implementations of `f32`. For example,///     weight: f32,///     GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },///     GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },///     GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },///     GoodBoy { name: "Chonk".to_owned(), weight: f32::INFINITY },///     GoodBoy { name: "Abs. Unit".to_owned(), weight: f32::NAN },///     GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },/// // `f32::NAN` could be positive or negative, which will affect the sort order./// if f32::NAN.is_sign_negative() {///     assert!(bois.into_iter().map(|b| b.weight)///         .zip([f32::NAN, -5.0, 0.1, 10.0, 99.0, f32::INFINITY].iter())///         .all(|(a, b)| a.to_bits() == b.to_bits()))///         .zip([-5.0, 0.1, 10.0, 99.0, f32::INFINITY, f32::NAN].iter())/// assert!((-3.0f32).clamp(-2.0, 1.0) == -2.0);/// assert!((0.0f32).clamp(-2.0, 1.0) == 0.0);/// assert!((2.0f32).clamp(-2.0, 1.0) == 1.0);/// assert!((f32::NAN).clamp(-2.0, 1.0).is_nan());/// assert!((0.0f32).clamp(-0.0, -0.0) == 0.0);/// assert!((1.0f32).clamp(-0.0, 0.0) == 0.0);/// assert!((-1.0f32).clamp(-0.0, 1.0).is_sign_negative());/// assert_eq!(5.0f32.clamp_magnitude(3.0), 3.0);/// assert_eq!((-5.0f32).clamp_magnitude(3.0), -3.0);/// assert_eq!(2.0f32.clamp_magnitude(3.0), 2.0);/// assert_eq!((-2.0f32).clamp_magnitude(3.0), -2.0);/// let x = 3.5_f32;/// let y = -3.5_f32;/// assert!(f32::NAN.abs().is_nan());/// assert_eq!(f32::NEG_INFINITY.signum(), -1.0);/// assert!(f32::NAN.signum().is_nan());/// assert!(f32::NAN.copysign(1.0).is_nan());/// Experimental version of `floor` in `core`. See [`f32::floor`] for details./// #![feature(core_float_math)]/// use core::f32;/// let f = 3.7_f32;/// let g = 3.0_f32;/// let h = -3.7_f32;/// assert_eq!(f32::math::floor(f), 3.0);/// assert_eq!(f32::math::floor(g), 3.0);/// assert_eq!(f32::math::floor(h), -4.0);/// _This standalone function is for testing only./// It will be stabilized as an inherent method._/// [`f32::floor`]: ../../../std/primitive.f32.html#method.floor/// Experimental version of `ceil` in `core`. See [`f32::ceil`] for details./// let f = 3.01_f32;/// let g = 4.0_f32;/// assert_eq!(f32::math::ceil(f), 4.0);/// assert_eq!(f32::math::ceil(g), 4.0);/// [`f32::ceil`]: ../../../std/primitive.f32.html#method.ceil/// Experimental version of `round` in `core`. See [`f32::round`] for details./// let f = 3.3_f32;/// let g = -3.3_f32;/// let i = 3.5_f32;/// let j = 4.5_f32;/// assert_eq!(f32::math::round(f), 3.0);/// assert_eq!(f32::math::round(g), -3.0);/// assert_eq!(f32::math::round(h), -4.0);/// assert_eq!(f32::math::round(i), 4.0);/// assert_eq!(f32::math::round(j), 5.0);/// [`f32::round`]: ../../../std/primitive.f32.html#method.round/// Experimental version of `round_ties_even` in `core`. See [`f32::round_ties_even`] for/// let h = 3.5_f32;/// let i = 4.5_f32;/// assert_eq!(f32::math::round_ties_even(f), 3.0);/// assert_eq!(f32::math::round_ties_even(g), -3.0);/// assert_eq!(f32::math::round_ties_even(h), 4.0);/// assert_eq!(f32::math::round_ties_even(i), 4.0);/// [`f32::round_ties_even`]: ../../../std/primitive.f32.html#method.round_ties_even/// Experimental version of `trunc` in `core`. See [`f32::trunc`] for details./// assert_eq!(f32::math::trunc(f), 3.0);/// assert_eq!(f32::math::trunc(g), 3.0);/// assert_eq!(f32::math::trunc(h), -3.0);/// [`f32::trunc`]: ../../../std/primitive.f32.html#method.trunc/// Experimental version of `fract` in `core`. See [`f32::fract`] for details./// let x = 3.6_f32;/// let y = -3.6_f32;/// let abs_difference_x = (f32::math::fract(x) - 0.6).abs();/// let abs_difference_y = (f32::math::fract(y) - (-0.6)).abs();/// assert!(abs_difference_x <= f32::EPSILON);/// assert!(abs_difference_y <= f32::EPSILON);/// [`f32::fract`]: ../../../std/primitive.f32.html#method.fract/// Experimental version of `mul_add` in `core`. See [`f32::mul_add`] for details./// # // FIXME(#140515): mingw has an incorrect fma/// # // https://sourceforge.net/p/mingw-w64/bugs/848//// # #[cfg(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")))] {/// assert_eq!(f32::math::mul_add(m, x, b), 100.0);/// let one_plus_eps = 1.0_f32 + f32::EPSILON;/// let one_minus_eps = 1.0_f32 - f32::EPSILON;/// let minus_one = -1.0_f32;///     f32::math::mul_add(one_plus_eps, one_minus_eps, minus_one),///     -f32::EPSILON * f32::EPSILON/// [`f32::mul_add`]: ../../../std/primitive.f32.html#method.mul_add/// Experimental version of `div_euclid` in `core`. See [`f32::div_euclid`] for details./// let a: f32 = 7.0;/// assert_eq!(f32::math::div_euclid(a, b), 1.0); // 7.0 > 4.0 * 1.0/// assert_eq!(f32::math::div_euclid(-a, b), -2.0); // -7.0 >= 4.0 * -2.0/// assert_eq!(f32::math::div_euclid(a, -b), -1.0); // 7.0 >= -4.0 * -1.0/// assert_eq!(f32::math::div_euclid(-a, -b), 2.0); // -7.0 >= -4.0 * 2.0/// [`f32::div_euclid`]: ../../../std/primitive.f32.html#method.div_euclid/// Experimental version of `rem_euclid` in `core`. See [`f32::rem_euclid`] for details./// assert_eq!(f32::math::rem_euclid(a, b), 3.0);/// assert_eq!(f32::math::rem_euclid(-a, b), 1.0);/// assert_eq!(f32::math::rem_euclid(a, -b), 3.0);/// assert_eq!(f32::math::rem_euclid(-a, -b), 1.0);/// assert!(f32::math::rem_euclid(-f32::EPSILON, 3.0) != 0.0);/// [`f32::rem_euclid`]: ../../../std/primitive.f32.html#method.rem_euclid/// Experimental version of `powi` in `core`. See [`f32::powi`] for details./// let abs_difference = (f32::math::powi(x, 2) - (x * x)).abs();/// assert!(abs_difference <= 1e-5);/// assert_eq!(f32::math::powi(f32::NAN, 0), 1.0);/// [`f32::powi`]: ../../../std/primitive.f32.html#method.powi/// Experimental version of `sqrt` in `core`. See [`f32::sqrt`] for details./// let positive = 4.0_f32;/// let negative = -4.0_f32;/// let negative_zero = -0.0_f32;/// assert_eq!(f32::math::sqrt(positive), 2.0);/// assert!(f32::math::sqrt(negative).is_nan());/// assert_eq!(f32::math::sqrt(negative_zero), negative_zero);/// [`f32::sqrt`]: ../../../std/primitive.f32.html#method.sqrt/// Experimental version of `abs_sub` in `core`. See [`f32::abs_sub`] for details./// let x = 3.0f32;/// let y = -3.0f32;/// let abs_difference_x = (f32::math::abs_sub(x, 1.0) - 2.0).abs();/// let abs_difference_y = (f32::math::abs_sub(y, 1.0) - 0.0).abs();/// assert!(abs_difference_x <= 1e-6);/// assert!(abs_difference_y <= 1e-6);/// [`f32::abs_sub`]: ../../../std/primitive.f32.html#method.abs_sub/// Experimental version of `cbrt` in `core`. See [`f32::cbrt`] for details./// The precision of this function is non-deterministic. This means it varies by platform, Rust version, and/// can even differ within the same execution from one invocation to the next./// let x = 8.0f32;/// let abs_difference = (f32::math::cbrt(x) - 2.0).abs();/// assert!(abs_difference <= 1e-6);/// [`f32::cbrt`]: ../../../std/primitive.f32.html#method.cbrt/// Experimental implementations of floating point functions in `core`./// _The standalone functions in this module are for testing only./// They will be stabilized as inherent methods._//! Constants for the `f32` single-precision floating point type.//! *[See also the `f32` primitive type][f32].*//! defined directly on the `f32` type."f64_legacy_const_radix"/// The radix or base of the internal representation of `f64`./// Use [`f64::RADIX`] instead./// let r = std::f64::RADIX;/// let r = f64::RADIX;"f64_legacy_const_mantissa_dig"/// Use [`f64::MANTISSA_DIGITS`] instead./// let d = std::f64::MANTISSA_DIGITS;/// let d = f64::MANTISSA_DIGITS;"f64_legacy_const_digits"/// Use [`f64::DIGITS`] instead./// let d = std::f64::DIGITS;/// let d = f64::DIGITS;"f64_legacy_const_epsilon"/// [Machine epsilon] value for `f64`./// Use [`f64::EPSILON`] instead./// let e = std::f64::EPSILON;/// let e = f64::EPSILON;"f64_legacy_const_min"/// Smallest finite `f64` value./// Use [`f64::MIN`] instead./// let min = std::f64::MIN;/// let min = f64::MIN;"f64_legacy_const_min_positive"/// Smallest positive normal `f64` value./// Use [`f64::MIN_POSITIVE`] instead./// let min = std::f64::MIN_POSITIVE;/// let min = f64::MIN_POSITIVE;"f64_legacy_const_max"/// Largest finite `f64` value./// Use [`f64::MAX`] instead./// let max = std::f64::MAX;"f64_legacy_const_min_exp"/// Use [`f64::MIN_EXP`] instead./// let min = std::f64::MIN_EXP;/// let min = f64::MIN_EXP;"f64_legacy_const_max_exp"/// Use [`f64::MAX_EXP`] instead./// let max = std::f64::MAX_EXP;/// let max = f64::MAX_EXP;"f64_legacy_const_min_10_exp"/// Use [`f64::MIN_10_EXP`] instead./// let min = std::f64::MIN_10_EXP;/// let min = f64::MIN_10_EXP;"f64_legacy_const_max_10_exp"/// Use [`f64::MAX_10_EXP`] instead./// let max = std::f64::MAX_10_EXP;/// let max = f64::MAX_10_EXP;"f64_legacy_const_nan"/// Use [`f64::NAN`] instead./// let nan = std::f64::NAN;"f64_legacy_const_infinity"/// Use [`f64::INFINITY`] instead./// let inf = std::f64::INFINITY;/// let inf = f64::INFINITY;"f64_legacy_const_neg_infinity"/// Use [`f64::NEG_INFINITY`] instead./// let ninf = std::f64::NEG_INFINITY;/// let ninf = f64::NEG_INFINITY;"f64_consts_mod"/// significant digits can be converted to `f64` and back without loss./// [`MANTISSA_DIGITS`]: f64::MANTISSA_DIGITS"f64_epsilon"/// [`MAX`]: f64::MAX/// [`MIN_EXP`]: f64::MIN_EXP/// [`MAX_EXP`]: f64::MAX_EXP/// [`MIN_POSITIVE`]: f64::MIN_POSITIVE"f64_nan"/// let f = 7.0_f64;/// let f = 7.0f64;/// let neg_inf = f64::NEG_INFINITY;/// let inf: f64 = f64::INFINITY;/// let neg_inf: f64 = f64::NEG_INFINITY;/// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64/// let zero = 0.0f64;/// assert!(!f64::NAN.is_normal());/// assert!(!f64::INFINITY.is_normal());/// let num = 12.4_f64;/// let g = -7.0_f64;/// Let `TINY` be the smallest representable positive `f64`. Then,/// // f64::EPSILON is the difference between 1.0 and the next number up./// assert_eq!(1.0f64.next_up(), 1.0 + f64::EPSILON);/// assert!(0.1f64.next_up() < 0.1 + f64::EPSILON);/// assert_eq!(9007199254740992f64.next_up(), 9007199254740994.0);/// let x = 1.0f64;/// let clamped = x.clamp(0.0, 1.0f64.next_down());/// let angle = std::f64::consts::PI;/// let abs_difference = (angle.to_radians() - std::f64::consts::PI).abs();/// let y = 2.0_f64;/// assert_eq!(x.max(f64::NAN), x);/// assert_eq!(x.min(f64::NAN), x);/// This is in contrast to [`f64::max`] which only returns NaN when *both* arguments are NaN,/// assert!(x.maximum(f64::NAN).is_nan());/// This is in contrast to [`f64::min`] which only returns NaN when *both* arguments are NaN,/// assert!(x.minimum(f64::NAN).is_nan());/// assert_eq!(1f64.midpoint(4.0), 2.5);/// assert_eq!((-5.5f64).midpoint(8.0), 1.25);/// let value = 4.6_f64;/// let value = -128.9_f64;/// Raw transmutation to `u64`./// This is currently identical to `transmute::<f64, u64>(self)` on all platforms./// assert!((1f64).to_bits() != 1f64 as u64); // to_bits() is not casting!/// assert_eq!((12.5f64).to_bits(), 0x4029000000000000);/// Raw transmutation from `u64`./// This is currently identical to `transmute::<u64, f64>(v)` on all platforms./// If you don't care about signaling-ness (very likely), then there is no/// let v = f64::from_bits(0x4029000000000000);/// let bytes = 12.5f64.to_be_bytes();/// assert_eq!(bytes, [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);/// let bytes = 12.5f64.to_le_bytes();/// assert_eq!(bytes, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);/// [`to_be_bytes`]: f64::to_be_bytes/// [`to_le_bytes`]: f64::to_le_bytes/// let bytes = 12.5f64.to_ne_bytes();///         [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]///         [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]/// let value = f64::from_be_bytes([0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);/// let value = f64::from_le_bytes([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);/// [`from_be_bytes`]: f64::from_be_bytes/// [`from_le_bytes`]: f64::from_le_bytes/// let value = f64::from_ne_bytes(if cfg!(target_endian = "big") {///     [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]///     [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]/// [`PartialOrd`] and [`PartialEq`] implementations of `f64`. For example,///     weight: f64,///     GoodBoy { name: "Chonk".to_owned(), weight: f64::INFINITY },///     GoodBoy { name: "Abs. Unit".to_owned(), weight: f64::NAN },/// // `f64::NAN` could be positive or negative, which will affect the sort order./// if f64::NAN.is_sign_negative() {///         .zip([f64::NAN, -5.0, 0.1, 10.0, 99.0, f64::INFINITY].iter())///         .zip([-5.0, 0.1, 10.0, 99.0, f64::INFINITY, f64::NAN].iter())/// assert!((-3.0f64).clamp(-2.0, 1.0) == -2.0);/// assert!((0.0f64).clamp(-2.0, 1.0) == 0.0);/// assert!((2.0f64).clamp(-2.0, 1.0) == 1.0);/// assert!((f64::NAN).clamp(-2.0, 1.0).is_nan());/// assert!((0.0f64).clamp(-0.0, -0.0) == 0.0);/// assert!((1.0f64).clamp(-0.0, 0.0) == 0.0);/// assert!((-1.0f64).clamp(-0.0, 1.0).is_sign_negative());/// assert_eq!(5.0f64.clamp_magnitude(3.0), 3.0);/// assert_eq!((-5.0f64).clamp_magnitude(3.0), -3.0);/// assert_eq!(2.0f64.clamp_magnitude(3.0), 2.0);/// assert_eq!((-2.0f64).clamp_magnitude(3.0), -2.0);/// assert_eq!(f.copysign(0.42), 3.5_f64);/// assert_eq!(f.copysign(-0.42), -3.5_f64);/// assert_eq!((-f).copysign(0.42), 3.5_f64);/// assert_eq!((-f).copysign(-0.42), -3.5_f64);/// assert!(f64::NAN.copysign(1.0).is_nan());/// Experimental version of `floor` in `core`. See [`f64::floor`] for details./// use core::f64;/// assert_eq!(f64::math::floor(f), 3.0);/// assert_eq!(f64::math::floor(g), 3.0);/// assert_eq!(f64::math::floor(h), -4.0);/// [`f64::floor`]: ../../../std/primitive.f64.html#method.floor/// Experimental version of `ceil` in `core`. See [`f64::ceil`] for details./// assert_eq!(f64::math::ceil(f), 4.0);/// assert_eq!(f64::math::ceil(g), 4.0);/// [`f64::ceil`]: ../../../std/primitive.f64.html#method.ceil/// Experimental version of `round` in `core`. See [`f64::round`] for details./// assert_eq!(f64::math::round(f), 3.0);/// assert_eq!(f64::math::round(g), -3.0);/// assert_eq!(f64::math::round(h), -4.0);/// assert_eq!(f64::math::round(i), 4.0);/// assert_eq!(f64::math::round(j), 5.0);/// [`f64::round`]: ../../../std/primitive.f64.html#method.round/// Experimental version of `round_ties_even` in `core`. See [`f64::round_ties_even`] for/// let h = 3.5_f64;/// let i = 4.5_f64;/// assert_eq!(f64::math::round_ties_even(f), 3.0);/// assert_eq!(f64::math::round_ties_even(g), -3.0);/// assert_eq!(f64::math::round_ties_even(h), 4.0);/// assert_eq!(f64::math::round_ties_even(i), 4.0);/// [`f64::round_ties_even`]: ../../../std/primitive.f64.html#method.round_ties_even/// Experimental version of `trunc` in `core`. See [`f64::trunc`] for details./// assert_eq!(f64::math::trunc(f), 3.0);/// assert_eq!(f64::math::trunc(g), 3.0);/// assert_eq!(f64::math::trunc(h), -3.0);/// [`f64::trunc`]: ../../../std/primitive.f64.html#method.trunc/// Experimental version of `fract` in `core`. See [`f64::fract`] for details./// let abs_difference_x = (f64::math::fract(x) - 0.6).abs();/// let abs_difference_y = (f64::math::fract(y) - (-0.6)).abs();/// [`f64::fract`]: ../../../std/primitive.f64.html#method.fract/// Experimental version of `mul_add` in `core`. See [`f64::mul_add`] for details./// assert_eq!(f64::math::mul_add(m, x, b), 100.0);/// let one_plus_eps = 1.0_f64 + f64::EPSILON;/// let one_minus_eps = 1.0_f64 - f64::EPSILON;/// let minus_one = -1.0_f64;///     f64::math::mul_add(one_plus_eps, one_minus_eps, minus_one),///     -f64::EPSILON * f64::EPSILON/// [`f64::mul_add`]: ../../../std/primitive.f64.html#method.mul_add/// Experimental version of `div_euclid` in `core`. See [`f64::div_euclid`] for details./// assert_eq!(f64::math::div_euclid(a, b), 1.0); // 7.0 > 4.0 * 1.0/// assert_eq!(f64::math::div_euclid(-a, b), -2.0); // -7.0 >= 4.0 * -2.0/// assert_eq!(f64::math::div_euclid(a, -b), -1.0); // 7.0 >= -4.0 * -1.0/// assert_eq!(f64::math::div_euclid(-a, -b), 2.0); // -7.0 >= -4.0 * 2.0/// [`f64::div_euclid`]: ../../../std/primitive.f64.html#method.div_euclid/// Experimental version of `rem_euclid` in `core`. See [`f64::rem_euclid`] for details./// assert_eq!(f64::math::rem_euclid(a, b), 3.0);/// assert_eq!(f64::math::rem_euclid(-a, b), 1.0);/// assert_eq!(f64::math::rem_euclid(a, -b), 3.0);/// assert_eq!(f64::math::rem_euclid(-a, -b), 1.0);/// assert!(f64::math::rem_euclid(-f64::EPSILON, 3.0) != 0.0);/// [`f64::rem_euclid`]: ../../../std/primitive.f64.html#method.rem_euclid/// Experimental version of `powi` in `core`. See [`f64::powi`] for details./// let abs_difference = (f64::math::powi(x, 2) - (x * x)).abs();/// assert_eq!(f64::math::powi(f64::NAN, 0), 1.0);/// [`f64::powi`]: ../../../std/primitive.f64.html#method.powi/// Experimental version of `sqrt` in `core`. See [`f64::sqrt`] for details./// assert_eq!(f64::math::sqrt(positive), 2.0);/// assert!(f64::math::sqrt(negative).is_nan());/// assert_eq!(f64::math::sqrt(negative_zero), negative_zero);/// [`f64::sqrt`]: ../../../std/primitive.f64.html#method.sqrt/// Experimental version of `abs_sub` in `core`. See [`f64::abs_sub`] for details./// let x = 3.0_f64;/// let y = -3.0_f64;/// let abs_difference_x = (f64::math::abs_sub(x, 1.0) - 2.0).abs();/// let abs_difference_y = (f64::math::abs_sub(y, 1.0) - 0.0).abs();/// [`f64::abs_sub`]: ../../../std/primitive.f64.html#method.abs_sub/// Experimental version of `cbrt` in `core`. See [`f64::cbrt`] for details./// let abs_difference = (f64::math::cbrt(x) - 2.0).abs();/// [`f64::cbrt`]: ../../../std/primitive.f64.html#method.cbrt//! Constants for the `f64` double-precision floating point type.//! *[See also the `f64` primitive type][f64].*//! defined directly on the `f64` type./// The scaled mantissa./// The lower error range./// The upper error range./// The shared exponent in base 2.inclusive/// True when the error range is inclusive./// In IEEE 754, this is true when the original mantissa was even./// Decoded unsigned finite value, such that:/// - The original value equals to `mant * 2^exp`./// - Any number from `(mant - minus) * 2^exp` to `(mant + plus) * 2^exp` will///   round to the original value. The range is inclusive only when///   `inclusive` is `true`.FullDecodedNan/// Not-a-number./// Infinities, either positive or negative./// Zero, either positive or negative./// Finite numbers with further decoded fields./// Decoded unsigned value.min_pos_norm_value/// The minimum positive normalized value./// A floating point type which can be `decode`d./*negative?*//// Returns a sign (true when negative) and `FullDecoded` value/// from given floating point number.//! Decodes a floating-point value into individual parts and error ranges.estimate_scaling_factor/// Finds `k_0` such that `10^(k_0-1) < mant * 2^exp <= 10^(k_0+1)`./// This is used to approximate `k = ceil(log_10 (mant * 2^exp))`;/// the true `k` is either `k_0` or `k_0+1`.//! The exponent estimator.estimatordragongrisu/// Digit-generation algorithms.MAX_SIG_DIGITS/// The minimum size of buffer necessary for the shortest mode./// It is a bit non-trivial to derive, but this is one plus the maximal number of/// significant decimal digits from formatting algorithms with the shortest result./// The exact formula is `ceil(# bits in mantissa * log_10 2 + 1)`.round_up/// When `d` contains decimal digits, increase the last digit and propagate carry./// Returns a next digit when it causes the length to change.digits_to_dec_str/// Formats given decimal digits `0.<...buf...> * 10^exp` into the decimal form/// with at least given number of fractional digits. The result is stored to/// the supplied parts array and a slice of written parts is returned./// `frac_digits` can be less than the number of actual fractional digits in `buf`;/// it will be ignored and full digits will be printed. It is only used to print/// additional zeroes after rendered digits. Thus `frac_digits` of 0 means that/// it will only print given digits and nothing else.digits_to_exp_str/// Formats the given decimal digits `0.<...buf...> * 10^exp` into the exponential/// form with at least the given number of significant digits. When `upper` is `true`,/// the exponent will be prefixed by `E`; otherwise that's `e`. The result is/// stored to the supplied parts array and a slice of written parts is returned./// `min_digits` can be less than the number of actual significant digits in `buf`;/// additional zeroes after rendered digits. Thus, `min_digits == 0` means that/// it will only print the given digits and nothing else./// Prints `-` for any negative value.MinusPlus// -inf -1 -0  0  1  inf nan/// Prints `-` for any negative value, or `+` otherwise.// -inf -1 -0 +0 +1 +inf nan/// Sign formatting options.determine_sign/// Returns the static byte string corresponding to the sign to be formatted./// It can be either `""`, `"+"` or `"-"`.to_shortest_str/// Formats the given floating point number into the decimal form with at least/// given number of fractional digits. The result is stored to the supplied parts/// array while utilizing given byte buffer as a scratch. `upper` is currently/// unused but left for the future decision to change the case of non-finite values,/// i.e., `inf` and `nan`. The first part to be rendered is always a `Part::Sign`/// (which can be an empty string if no sign is rendered)./// `format_shortest` should be the underlying digit-generation function./// It should return the part of the buffer that it initialized./// You probably would want `strategy::grisu::format_shortest` for this./// `frac_digits` can be less than the number of actual fractional digits in `v`;/// The byte buffer should be at least `MAX_SIG_DIGITS` bytes long./// There should be at least 4 parts available, due to the worst case like/// `[+][0.][0000][2][0000]` with `frac_digits = 10`.to_shortest_exp_str/// Formats the given floating point number into the decimal form or/// the exponential form, depending on the resulting exponent. The result is/// stored to the supplied parts array while utilizing given byte buffer/// as a scratch. `upper` is used to determine the case of non-finite values/// (`inf` and `nan`) or the case of the exponent prefix (`e` or `E`)./// The first part to be rendered is always a `Part::Sign` (which can be/// an empty string if no sign is rendered)./// The `dec_bounds` is a tuple `(lo, hi)` such that the number is formatted/// as decimal only when `10^lo <= V < 10^hi`. Note that this is the *apparent* `V`/// instead of the actual `v`! Thus any printed exponent in the exponential form/// cannot be in this range, avoiding any confusion./// There should be at least 6 parts available, due to the worst case like/// `[+][1][.][2345][e][-][6]`.estimate_max_buf_len/// Returns a rather crude approximation (upper bound) for the maximum buffer size/// calculated from the given decoded exponent./// The exact limit is:/// - when `exp < 0`, the maximum length is `ceil(log_10 (5^-exp * (2^64 - 1)))`./// - when `exp >= 0`, the maximum length is `ceil(log_10 (2^exp * (2^64 - 1)))`./// `ceil(log_10 (x^exp * (2^64 - 1)))` is less than `ceil(log_10 (2^64 - 1)) +/// ceil(exp * log_10 x)`, which is in turn less than `20 + (1 + exp * log_10 x)`./// We use the facts that `log_10 2 < 5/16` and `log_10 5 < 12/16`, which is/// enough for our purposes./// Why do we need this? `format_exact` functions will fill the entire buffer/// unless limited by the last digit restriction, but it is possible that/// the number of digits requested is ridiculously large (say, 30,000 digits)./// The vast majority of buffer will be filled with zeroes, so we don't want to/// allocate all the buffer beforehand. Consequently, for any given arguments,/// 826 bytes of buffer should be sufficient for `f64`. Compare this with/// the actual number for the worst case: 770 bytes (when `exp = -1074`).to_exact_exp_str/// Formats given floating point number into the exponential form with/// exactly given number of significant digits. The result is stored to/// the supplied parts array while utilizing given byte buffer as a scratch./// `upper` is used to determine the case of the exponent prefix (`e` or `E`)./// `format_exact` should be the underlying digit-generation function./// You probably would want `strategy::grisu::format_exact` for this./// The byte buffer should be at least `ndigits` bytes long unless `ndigits` is/// so large that only the fixed number of digits will be ever written./// (The tipping point for `f64` is about 800, so 1000 bytes should be enough.)to_exact_fixed_str/// Formats given floating point number into the decimal form with exactly/// The byte buffer should be enough for the output unless `frac_digits` is/// (The tipping point for `f64` is about 800, and 1000 bytes should be enough.)/*!

Floating-point number to decimal conversion routines.

# Problem statement

We are given the floating-point number `v = f * 2^e` with an integer `f`,
and its bounds `minus` and `plus` such that any number between `v - minus` and
`v + plus` will be rounded to `v`. For the simplicity we assume that
this range is exclusive. Then we would like to get the unique decimal
representation `V = 0.d[0..n-1] * 10^k` such that:

- `d[0]` is non-zero.

- It's correctly rounded when parsed back: `v - minus < V < v + plus`.
  Furthermore it is shortest such one, i.e., there is no representation
  with less than `n` digits that is correctly rounded.

- It's closest to the original value: `abs(V - v) <= 10^(k-n) / 2`. Note that
  there might be two representations satisfying this uniqueness requirement,
  in which case some tie-breaking mechanism is used.

We will call this mode of operation as to the *shortest* mode. This mode is used
when there is no additional constraint, and can be thought as a "natural" mode
as it matches the ordinary intuition (it at least prints `0.1f32` as "0.1").

We have two more modes of operation closely related to each other. In these modes
we are given either the number of significant digits `n` or the last-digit
limitation `limit` (which determines the actual `n`), and we would like to get
the representation `V = 0.d[0..n-1] * 10^k` such that:

- `d[0]` is non-zero, unless `n` was zero in which case only `k` is returned.

- It's closest to the original value: `abs(V - v) <= 10^(k-n) / 2`. Again,
  there might be some tie-breaking mechanism.

When `limit` is given but not `n`, we set `n` such that `k - n = limit`
so that the last digit `d[n-1]` is scaled by `10^(k-n) = 10^limit`.
If such `n` is negative, we clip it to zero so that we will only get `k`.
We are also limited by the supplied buffer. This limitation is used to print
the number up to given number of fractional digits without knowing
the correct `k` beforehand.

We will call the mode of operation requiring `n` as to the *exact* mode,
and one requiring `limit` as to the *fixed* mode. The exact mode is a subset of
the fixed mode: the sufficiently large last-digit limitation will eventually fill
the supplied buffer and let the algorithm to return.

# Implementation overview

It is easy to get the floating point printing correct but slow (Russ Cox has
[demonstrated](https://research.swtch.com/ftoa) how it's easy), or incorrect but
fast (naïve division and modulo). But it is surprisingly hard to print
floating point numbers correctly *and* efficiently.

There are two classes of algorithms widely known to be correct.

- The "Dragon" family of algorithm is first described by Guy L. Steele Jr. and
  Jon L. White. They rely on the fixed-size big integer for their correctness.
  A slight improvement was found later, which is posthumously described by
  Robert G. Burger and R. Kent Dybvig. David Gay's `dtoa.c` routine is
  a popular implementation of this strategy.

- The "Grisu" family of algorithm is first described by Florian Loitsch.
  They use very cheap integer-only procedure to determine the close-to-correct
  representation which is at least guaranteed to be shortest. The variant,
  Grisu3, actively detects if the resulting representation is incorrect.

We implement both algorithms with necessary tweaks to suit our requirements.
In particular, published literatures are short of the actual implementation
difficulties like how to avoid arithmetic overflows. Each implementation,
available in `strategy::dragon` and `strategy::grisu` respectively,
extensively describes all necessary justifications and many proofs for them.
(It is still difficult to follow though. You have been warned.)

Both implementations expose two public functions:

- `format_shortest(decoded, buf)`, which always needs at least
  `MAX_SIG_DIGITS` digits of buffer. Implements the shortest mode.

- `format_exact(decoded, buf, limit)`, which accepts as small as
  one digit of buffer. Implements exact and fixed modes.

They try to fill the `u8` buffer with digits and returns the number of digits
written and the exponent `k`. They are total for all finite `f32` and `f64`
inputs (Grisu internally falls back to Dragon if necessary).

The rendered digits are formatted into the actual string form with
four functions:

- `to_shortest_str` prints the shortest representation, which can be padded by
  zeroes to make *at least* given number of fractional digits.

- `to_shortest_exp_str` prints the shortest representation, which can be
  padded by zeroes when its exponent is in the specified ranges,
  or can be printed in the exponential form such as `1.23e45`.

- `to_exact_exp_str` prints the exact representation with given number of
  digits in the exponential form.

- `to_exact_fixed_str` prints the fixed representation with *exactly*
  given number of fractional digits.

They all return a slice of preallocated `Part` array, which corresponds to
the individual part of strings: a fixed string, a part of rendered digits,
a number of zeroes or a small (`u16`) number. The caller is expected to
provide a large enough buffer and `Part` array, and to assemble the final
string from resulting `Part`s itself.

All algorithms and formatting functions are accompanied by extensive tests
in `coretests::num::flt2dec` module. It also shows how to use individual
functions.

*/// while this is extensively documented, this is in principle private which is// only made public for testing. do not expose us.POW5TO16// precalculated arrays of `Digit`s for 5^(2^n).POW5TO32POW5TO64POW5TO128POW5TO256mul_pow10div_2pow10div_rem_upto_16// only usable when `x < 16 * scale`; `scaleN` should be `scale.mul_small(N)`format_shortest/*digits*//*exp*//// The shortest mode implementation for Dragon.format_exact/// The exact and fixed mode implementation for Dragon.//! Almost direct (but slightly optimized) Rust translation of Figure 3 of "Printing//! Floating-Point Numbers Quickly and Accurately"[^1].//! [^1]: Burger, R. G. and Dybvig, R. K. 1996. Printing floating-point numbers//!   quickly and accurately. SIGPLAN Not. 31, 5 (May. 1996), 108-116.diy_float// see the comments in `format_shortest_opt` for the rationale.CACHED_POW10CACHED_POW10_FIRST_ECACHED_POW10_LAST_Ecached_powermax_pow10_no_more_than/// Given `x > 0`, returns `(k, 10^k)` such that `10^k <= x < 10^(k+1)`.format_shortest_opt/// The shortest mode implementation for Grisu./// It returns `None` when it would return an inexact representation otherwise./// The shortest mode implementation for Grisu with Dragon fallback./// This should be used for most cases.format_exact_opt/// The exact and fixed mode implementation for Grisu./// The exact and fixed mode implementation for Grisu with Dragon fallback.//! Rust adaptation of the Grisu3 algorithm described in "Printing Floating-Point Numbers Quickly//! and Accurately with Integers"[^1]. It uses about 1KB of precomputed table, and in turn, it's//! very quick for most inputs.//! [^1]: Florian Loitsch. 2010. Printing floating-point numbers quickly and//!   accurately with integers. SIGPLAN Not. 45, 6 (June 2010), 233-243./*
# the following Python code generates this table:
for i in xrange(-308, 333, 8):
    if i >= 0: f = 10**i; e = 0
    else: f = 2**(80-4*i) // 10**-i; e = 4 * i - 80
    l = f.bit_length()
    f = ((f << 64 >> (l-1)) + 1) >> 1; e += l - 64
    print '    (%#018x, %5d, %4d),' % (f, e, i)
*//// Given number of zero digits./// A literal number up to 5 digits./// A verbatim copy of given bytes./// Formatted parts./// Returns the exact byte length of given part./// Writes a part into the supplied buffer./// Returns the number of written bytes, or `None` if the buffer is not enough./// (It may still leave partially written bytes in the buffer; do not rely on that.)/// A byte slice representing a sign, either `""`, `"-"` or `"+"`./// Formatted parts to be rendered after a sign and optional zero padding./// Formatted result containing one or more parts./// This can be written to the byte buffer or converted to the allocated string./// Returns the exact byte length of combined formatted result./// Writes all formatted parts into the supplied buffer.//! Shared utilities used by both float and integer formatting.// 0 < val <= u8::MAXless_than_5// 0 < val < 100_000// 0 < val <= u16::MAX// 0 < val <= u32::MAX// 0 < val <= u64::MAX// 0 < val <= u128::MAX// 0 < val <= i8::MAX// 0 < val <= i16::MAX// 0 < val <= i32::MAX// 0 < val <= i64::MAX// 0 < val <= i128::MAXpanic_for_nonpositive_argument/// Instantiate this panic logic once, rather than for all the ilog methods/// on every single primitive type.//! These functions compute the integer logarithm of their type, assuming//! that someone has already checked that the value is strictly positive.U8_ISQRT_WITH_REMAINDER/// This array stores the [integer square roots](/// https://en.wikipedia.org/wiki/Integer_square_root) and remainders of each/// [`u8`](prim@u8) value. For example, `U8_ISQRT_WITH_REMAINDER[17]` will be/// `(4, 1)` because the integer square root of 17 is 4 and because 17 is 1/// higher than 4 squared."this returns the result of the operation, \
              without modifying the original"/// Returns the [integer square root](/// https://en.wikipedia.org/wiki/Integer_square_root) of any [`u8`](prim@u8)signed_fn/// Generates an `i*` function that returns the [integer square root](/// https://en.wikipedia.org/wiki/Integer_square_root) of any **nonnegative**/// input of a specific signed integer type.r" Returns the [integer square root]("r" https://en.wikipedia.org/wiki/Integer_square_root) of any"r" **nonnegative**"r" This results in undefined behavior when the input is negative.""this returns the result of the operation, \
                      without modifying the original"unsigned_fn/// Generates a `u*` function that returns the [integer square root](/// https://en.wikipedia.org/wiki/Integer_square_root) of any input of/// a specific unsigned integer type.first_stage/// Generates the first stage of the computation after normalization./// `$n` must be nonzero.middle_stage/// Generates a middle stage of the computation./// `$s` must be nonzero.last_stage/// Generates the last stage of the computation before denormalization.u16_stages/// Takes the normalized [`u16`](prim@u16) input and gets its normalized/// [integer square root](https://en.wikipedia.org/wiki/Integer_square_root)./// `n` must be nonzero.u32_stages/// Takes the normalized [`u32`](prim@u32) input and gets its normalizedu64_stages/// Takes the normalized [`u64`](prim@u64) input and gets its normalizedu128_stages/// Takes the normalized [`u128`](prim@u128) input and gets its normalizedpanic_for_negative_argument/// Instantiate this panic logic once, rather than for all the isqrt methods//! These functions use the [Karatsuba square root algorithm][1] to compute the//! [integer square root](https://en.wikipedia.org/wiki/Integer_square_root)//! for the primitive integer types.//! The signed integer functions can only handle **nonnegative** inputs, so//! that must be checked before calling those.//! [1]: <https://web.archive.org/web/20230511212802/https://inria.hal.science/inria-00072854v1/file/RR-3805.pdf>//! "Paul Zimmermann. Karatsuba Square Root. \[Research Report\] RR-3805,//! INRIA. 1999, pp.8. (inria-00072854)"//! Bindings to math functions provided by the system `libm` or by the `libm` crate, exposed//! via `compiler-builtins`.// SAFETY: These symbols have standard interfaces in C and are defined by `libm`, or are// provided by `compiler-builtins` on unsupported platforms.// FIXME(const-hack): Used because the `?` operator is not allowed in a const context.sign_dependent_expr// Use this when the generated code should differ between signed and unsigned types.// All these modules are technically private and only exposed for coretests:int_macrosuint_macros// import int_impl!int_log10int_sqrtoverflow_panic/// 100% perma-unstableZeroablePrimitiveu8_xe_bytes_doci8_xe_bytes_docusize_isize_to_xe_bytes_docusize_isize_from_xe_bytes_docmidpoint_implr" The smallest value that can be represented by this integer type"r" The largest value that can be represented by this integer type"r" The size of this integer type in bits."r" Returns the number of ones in the binary representation of `self`."r" assert_eq!(n.count_ones(), 1);"r" Returns the number of zeros in the binary representation of `self`."r" Returns the number of leading zeros in the binary representation of `self`."r" Depending on what you're doing with the value, you might also be interested in the"r" [`ilog2`] function which returns a consistent number, even if the type widens."r" assert_eq!(n.leading_zeros(), 0);"r" Returns the number of trailing zeros in the binary representation of `self`."r" assert_eq!(n.trailing_zeros(), 2);"r" Returns the number of leading ones in the binary representation of `self`."r" Returns the number of trailing ones in the binary representation of `self`."r" assert_eq!(n.trailing_ones(), 2);"r" Returns `self` with only the most significant bit set, or `0` if"r" the input is `0`."r" #![feature(isolate_most_least_significant_one)]"r" assert_eq!(n.isolate_highest_one(), 0b_01000000);"isolate_highest_oner" Returns `self` with only the least significant bit set, or `0` if"r" assert_eq!(n.isolate_lowest_one(), 0b_00000100);"isolate_lowest_oner" Returns the index of the highest bit set to one in `self`, or `None`"r" if `self` is `0`."r" #![feature(int_lowest_highest_one)]"highest_oner" Returns the index of the lowest bit set to one in `self`, or `None`"lowest_oner" Returns the bit pattern of `self` reinterpreted as an unsigned integer of the same size."r" This produces the same result as an `as` cast, but ensures that the bit-width remains"r" the same."r" Shifts the bits to the left by a specified amount, `n`,"r" wrapping the truncated bits to the end of the resulting integer."r" `rotate_left(n)` is equivalent to applying `rotate_left(1)` a total of `n` times. In"r" particular, a rotation by the number of bits in `self` returns the input value"r" unchanged."r" Please note this isn't the same operation as the `<<` shifting operator!"r" Shifts the bits to the right by a specified amount, `n`,"r" wrapping the truncated bits to the beginning of the resulting"r" integer."r" `rotate_right(n)` is equivalent to applying `rotate_right(1)` a total of `n` times. In"r" Please note this isn't the same operation as the `>>` shifting operator!"r" Reverses the byte order of the integer."r" let m = n.swap_bytes();"r" Reverses the order of bits in the integer. The least significant bit becomes the most significant bit,"r"                 second least-significant bit becomes second most-significant bit, etc."r" let m = n.reverse_bits();"r" Converts an integer from big endian to the target's endianness."r" On big endian this is a no-op. On little endian the bytes are swapped."r" See also [from_be_bytes()](Self::from_be_bytes)."r#" if cfg!(target_endian = "big") {"#r" Converts an integer from little endian to the target's endianness."r" On little endian this is a no-op. On big endian the bytes are swapped."r" See also [from_le_bytes()](Self::from_le_bytes)."r#" if cfg!(target_endian = "little") {"#r" Swaps bytes of `self` on little endian targets."r" On big endian this is a no-op."r" The returned value has the same type as `self`, and will be interpreted"r" as (a potentially different) value of a native-endian"r" See [`to_be_bytes()`](Self::to_be_bytes) for a type-safe alternative."r"     assert_eq!(n.to_be(), n)"r"     assert_eq!(n.to_be(), n.swap_bytes())"r" Swaps bytes of `self` on big endian targets."r" On little endian this is a no-op."r" See [`to_le_bytes()`](Self::to_le_bytes) for a type-safe alternative."r"     assert_eq!(n.to_le(), n)"r"     assert_eq!(n.to_le(), n.swap_bytes())"r" Checked integer addition. Computes `self + rhs`, returning `None`"r" if overflow occurred."r" Strict integer addition. Computes `self + rhs`, panicking"r" ## Overflow behavior"r" This function will always panic on overflow, regardless of whether overflow checks are enabled."r" The following panics because of overflow:"r" ```should_panic"strict_addr" Unchecked integer addition. Computes `self + rhs`, assuming overflow"r" cannot occur."r" Calling `x.unchecked_add(y)` is semantically equivalent to calling"r" `x.`[`checked_add`]`(y).`[`unwrap_unchecked`]`()`."r" If you're just trying to avoid the panic in debug mode, then **do not**"r" use this.  Instead, you're looking for [`wrapping_add`]."r" This results in undefined behavior when"r" i.e. when [`checked_add`] would return `None`."r" [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked"r" Checked addition with an unsigned integer. Computes `self + rhs`,"r" returning `None` if overflow occurred."checked_add_unsignedr" Strict addition with an unsigned integer. Computes `self + rhs`,"r" panicking if overflow occurred."strict_add_unsignedr" Checked integer subtraction. Computes `self - rhs`, returning `None` if"r" overflow occurred."r" Strict integer subtraction. Computes `self - rhs`, panicking if"strict_subr" Unchecked integer subtraction. Computes `self - rhs`, assuming overflow"r" Calling `x.unchecked_sub(y)` is semantically equivalent to calling"r" `x.`[`checked_sub`]`(y).`[`unwrap_unchecked`]`()`."r" use this.  Instead, you're looking for [`wrapping_sub`]."r" i.e. when [`checked_sub`] would return `None`."r" Checked subtraction with an unsigned integer. Computes `self - rhs`,"checked_sub_unsignedr" Strict subtraction with an unsigned integer. Computes `self - rhs`,"strict_sub_unsignedr" Checked integer multiplication. Computes `self * rhs`, returning `None` if"r" Strict integer multiplication. Computes `self * rhs`, panicking if"r" ``` should_panic"strict_mulr" Unchecked integer multiplication. Computes `self * rhs`, assuming overflow"r" Calling `x.unchecked_mul(y)` is semantically equivalent to calling"r" `x.`[`checked_mul`]`(y).`[`unwrap_unchecked`]`()`."r" use this.  Instead, you're looking for [`wrapping_mul`]."r" i.e. when [`checked_mul`] would return `None`."r" Checked integer division. Computes `self / rhs`, returning `None` if `rhs == 0`"r" or the division results in overflow."r" Strict integer division. Computes `self / rhs`, panicking"r" This function will panic if `rhs` is zero."r" The only case where such an overflow can occur is when one divides `MIN / -1` on a signed type (where"r" `MIN` is the negative minimal value for the type); this is equivalent to `-MIN`, a positive value"r" that is too large to represent in the type."r" The following panics because of division by zero:"strict_divr" Checked Euclidean division. Computes `self.div_euclid(rhs)`,"r" returning `None` if `rhs == 0` or the division results in overflow."r" Strict Euclidean division. Computes `self.div_euclid(rhs)`, panicking"strict_div_euclidr" Checked integer division without remainder. Computes `self / rhs`,"r" returning `None` if `rhs == 0`, the division results in overflow,"r" or `self % rhs != 0`."r" #![feature(exact_div)]"checked_div_exactr" Integer division without remainder. Computes `self / rhs`, returning `None` if `self % rhs != 0`."r" This function will panic  if `rhs == 0`."r" On overflow, this function will panic if overflow checks are enabled (default in debug"r" mode) and wrap if overflow checks are disabled (default in release mode)."div_exactr" Unchecked integer division without remainder. Computes `self / rhs`."r" This results in undefined behavior when `rhs == 0`, `self % rhs != 0`, or"r" i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`."unchecked_div_exactr" Checked integer remainder. Computes `self % rhs`, returning `None` if"r" `rhs == 0` or the division results in overflow."r" Strict integer remainder. Computes `self % rhs`, panicking if"r" the division results in overflow."r" The only case where such an overflow can occur is `x % y` for `MIN / -1` on a"r" signed type (where `MIN` is the negative minimal value), which is invalid due to implementation artifacts."strict_remr" Checked Euclidean remainder. Computes `self.rem_euclid(rhs)`, returning `None`"r" if `rhs == 0` or the division results in overflow."r" Strict Euclidean remainder. Computes `self.rem_euclid(rhs)`, panicking if"strict_rem_euclidr" Checked negation. Computes `-self`, returning `None` if `self == MIN`."r" Unchecked negation. Computes `-self`, assuming overflow cannot occur."r" i.e. when [`checked_neg`] would return `None`."r" Strict negation. Computes `-self`, panicking if `self == MIN`."strict_negr" Checked shift left. Computes `self << rhs`, returning `None` if `rhs` is larger"r" than or equal to the number of bits in `self`."r" Strict shift left. Computes `self << rhs`, panicking if `rhs` is larger"strict_shlr" Unchecked shift left. Computes `self << rhs`, assuming that"r" `rhs` is less than the number of bits in `self`."r" This results in undefined behavior if `rhs` is larger than"r" or equal to the number of bits in `self`,"r" i.e. when [`checked_shl`] would return `None`."r" Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`."r" If `rhs` is larger or equal to the number of bits in `self`,"r" the entire value is shifted out, and `0` is returned."unbounded_shlr" Exact shift left. Computes `self << rhs` as long as it can be reversed losslessly."r" Returns `None` if any bits that would be shifted out differ from the resulting sign bit"r" or if `rhs` >="r" Otherwise, returns `Some(self << rhs)`."r" #![feature(exact_bitshifts)]"shl_exactr" Unchecked exact shift left. Computes `self << rhs`, assuming the operation can be"r" losslessly reversed and `rhs` cannot be larger than"r" This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >="r" self.leading_ones()` i.e. when"r" would return `None`."unchecked_shl_exactr" Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is"r" larger than or equal to the number of bits in `self`."r" Strict shift right. Computes `self >> rhs`, panicking if `rhs` is"strict_shrr" Unchecked shift right. Computes `self >> rhs`, assuming that"r" i.e. when [`checked_shr`] would return `None`."r" Unbounded shift right. Computes `self >> rhs`, without bounding the value of `rhs`."r" the entire value is shifted out, which yields `0` for a positive number,"r" and `-1` for a negative number."unbounded_shrr" Exact shift right. Computes `self >> rhs` as long as it can be reversed losslessly."r" Returns `None` if any non-zero bits would be shifted out or if `rhs` >="r" Otherwise, returns `Some(self >> rhs)`."shr_exactr" Unchecked exact shift right. Computes `self >> rhs`, assuming the operation can be"r" This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >="r" i.e. when"unchecked_shr_exactr" Checked absolute value. Computes `self.abs()`, returning `None` if"r" `self == MIN`."r" Strict absolute value. Computes `self.abs()`, panicking if"strict_absr" Checked exponentiation. Computes `self.pow(exp)`, returning `None` if"r" Strict exponentiation. Computes `self.pow(exp)`, panicking if"strict_powr" Returns the square root of the number, rounded down."r" Returns `None` if `self` is negative."checked_isqrtr" bounds instead of overflowing."r" Saturating addition with an unsigned integer. Computes `self + rhs`,"r" saturating at the numeric bounds instead of overflowing."saturating_add_unsignedr" Saturating integer subtraction. Computes `self - rhs`, saturating at the"r" numeric bounds instead of overflowing."r" Saturating subtraction with an unsigned integer. Computes `self - rhs`,"saturating_sub_unsignedr" Saturating integer negation. Computes `-self`, returning `MAX` if `self == MIN`"r" instead of overflowing."r" Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self =="r" MIN` instead of overflowing."r" Saturating integer multiplication. Computes `self * rhs`, saturating at the"r" Saturating integer division. Computes `self / rhs`, saturating at the"saturating_divr" Saturating integer exponentiation. Computes `self.pow(exp)`,"r" Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the"r" boundary of the type."r" Wrapping (modular) addition with an unsigned integer. Computes"r" `self + rhs`, wrapping around at the boundary of the type."wrapping_add_unsignedr" Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the"r" Wrapping (modular) subtraction with an unsigned integer. Computes"r" `self - rhs`, wrapping around at the boundary of the type."wrapping_sub_unsignedr" Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at"r" the boundary of the type."r" assert_eq!(11i8.wrapping_mul(12), -124);"r" Wrapping (modular) division. Computes `self / rhs`, wrapping around at the"r" The only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where"r" that is too large to represent in the type. In such a case, this function returns `MIN` itself."r" assert_eq!((-128i8).wrapping_div(-1), -128);"r" Wrapping Euclidean division. Computes `self.div_euclid(rhs)`,"r" wrapping around at the boundary of the type."r" Wrapping will only occur in `MIN / -1` on a signed type (where `MIN` is the negative minimal value"r" for the type). This is equivalent to `-MIN`, a positive value that is too large to represent in the"r" type. In this case, this method returns `MIN` itself."r" assert_eq!((-128i8).wrapping_div_euclid(-1), -128);"r" Wrapping (modular) remainder. Computes `self % rhs`, wrapping around at the"r" Such wrap-around never actually occurs mathematically; implementation artifacts make `x % y`"r" invalid for `MIN / -1` on a signed type (where `MIN` is the negative minimal value). In such a case,"r" this function returns `0`."r" assert_eq!((-128i8).wrapping_rem(-1), 0);"r" Wrapping Euclidean remainder. Computes `self.rem_euclid(rhs)`, wrapping around"r" at the boundary of the type."r" Wrapping will only occur in `MIN % -1` on a signed type (where `MIN` is the negative minimal value"r" for the type). In this case, this method returns 0."r" assert_eq!((-128i8).wrapping_rem_euclid(-1), 0);"r" Wrapping (modular) negation. Computes `-self`, wrapping around at the boundary"r" of the type."r" The only case where such wrapping can occur is when one negates `MIN` on a signed type (where `MIN`"r" is the negative minimal value for the type); this is a positive value that is too large to represent"r" in the type. In such a case, this function returns `MIN` itself."r" Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes"r" any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type."r" Note that this is *not* the same as a rotate-left; the RHS of a wrapping shift-left is restricted to"r" the range of the type, rather than the bits shifted out of the LHS being returned to the other end."r" The primitive integer types all implement a [`rotate_left`](Self::rotate_left) function,"r" which may be what you want instead."r" Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`"r" removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type."r" Note that this is *not* the same as a rotate-right; the RHS of a wrapping shift-right is restricted"r" to the range of the type, rather than the bits shifted out of the LHS being returned to the other"r" end. The primitive integer types all implement a [`rotate_right`](Self::rotate_right) function,"r" assert_eq!((-128i16).wrapping_shr(64), -128);"r" Wrapping (modular) absolute value. Computes `self.abs()`, wrapping around at"r" The only case where such wrapping can occur is when one takes the absolute value of the negative"r" minimal value for the type; this is a positive value that is too large to represent in the type. In"r" such a case, this function returns `MIN` itself."r" assert_eq!((-128i8).wrapping_abs() as u8, 128);"r" Computes the absolute value of `self` without any wrapping"r" or panicking."r" assert_eq!((-128i8).unsigned_abs(), 128u8);"r" Wrapping (modular) exponentiation. Computes `self.pow(exp)`,"r" assert_eq!(3i8.wrapping_pow(5), -13);"r" assert_eq!(3i8.wrapping_pow(6), -39);"r" Calculates `self` + `rhs`."r" Returns a tuple of the addition along with a boolean indicating"r" whether an arithmetic overflow would occur. If an overflow would have"r" occurred then the wrapped value is returned."r" Calculates `self` + `rhs` + `carry` and checks for overflow."r#" Performs "ternary addition" of two integer operands and a carry-in"#r" bit, and returns a tuple of the sum along with a boolean indicating"r" whether an arithmetic overflow would occur. On overflow, the wrapped"r" value is returned."r" This allows chaining together multiple additions to create a wider"r" addition, and can be useful for bignum addition. This method should"r" only be used for the most significant word; for the less significant"r" words the unsigned method"r" should be used."r" The output boolean returned by this method is *not* a carry flag,"r" and should *not* be added to a more significant word."r" If the input carry is false, this method is equivalent to"r" [`overflowing_add`](Self::overflowing_add)."r" #![feature(bigint_helper_methods)]"r" // Only the most significant word is signed."r" // ---------"r" let carry0 = false;"r" let (sum0, carry1) = a0.carrying_add(b0, carry0);"r" assert_eq!(carry1, true);"r" let (sum1, overflow) = a1.carrying_add(b1, carry1);"r" assert_eq!(overflow, false);"r" assert_eq!((sum1, sum0), (6, 8));"r" Calculates `self` + `rhs` with an unsigned `rhs`."r" whether an arithmetic overflow would occur. If an overflow would"r" have occurred then the wrapped value is returned."overflowing_add_unsignedr" Calculates `self` - `rhs`."r" Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow"r" would occur. If an overflow would have occurred then the wrapped value is returned."r" Calculates `self` &minus; `rhs` &minus; `borrow` and checks for"r" overflow."r#" Performs "ternary subtraction" by subtracting both an integer"#r" operand and a borrow-in bit from `self`, and returns a tuple of the"r" difference along with a boolean indicating whether an arithmetic"r" overflow would occur. On overflow, the wrapped value is returned."r" This allows chaining together multiple subtractions to create a"r" wider subtraction, and can be useful for bignum subtraction. This"r" method should only be used for the most significant word; for the"r" less significant words the unsigned method"r" The output boolean returned by this method is *not* a borrow flag,"r" and should *not* be subtracted from a more significant word."r" If the input borrow is false, this method is equivalent to"r" [`overflowing_sub`](Self::overflowing_sub)."r" let borrow0 = false;"r" let (diff0, borrow1) = a0.borrowing_sub(b0, borrow0);"r" assert_eq!(borrow1, true);"r" let (diff1, overflow) = a1.borrowing_sub(b1, borrow1);"r" Calculates `self` - `rhs` with an unsigned `rhs`."r" Returns a tuple of the subtraction along with a boolean indicating"overflowing_sub_unsignedr" Calculates the multiplication of `self` and `rhs`."r" Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow"r" assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));"r" Calculates the complete product `self * rhs` without the possibility to overflow."r" This returns the low-order (wrapping) bits and the high-order (overflow) bits"r" of the result as two separate values, in that order."r" If you also need to add a carry to the wide result, then you want"r" [`Self::carrying_mul`] instead."r" Please note that this example is shared among integer types, which is why `i32` is used."r" assert_eq!(5i32.widening_mul(-2), (4294967286, -1));"r" assert_eq!(1_000_000_000i32.widening_mul(-10), (2884901888, -3));"widening_mulr#" Calculates the "full multiplication" `self * rhs + carry`"#r" without the possibility to overflow."r#" Performs "long multiplication" which takes in an extra amount to add, and may return an"#r" additional amount of overflow. This allows for chaining together multiple"r#" multiplications to create "big integers" which represent larger values."#r" If you don't need the `carry`, then you can use [`Self::widening_mul`] instead."r" assert_eq!(5i32.carrying_mul(-2, 0), (4294967286, -1));"r" assert_eq!(5i32.carrying_mul(-2, 10), (0, 0));"r" assert_eq!(1_000_000_000i32.carrying_mul(-10, 0), (2884901888, -3));"r" assert_eq!(1_000_000_000i32.carrying_mul(-10, 10), (2884901898, -3));"carrying_mulr#" Calculates the "full multiplication" `self * rhs + carry + add`"#r" If you don't need either `carry`, then you can use [`Self::widening_mul`] instead,"r" and if you only need one `carry`, then you can use [`Self::carrying_mul`] instead."r" assert_eq!(5i32.carrying_mul_add(-2, 0, 0), (4294967286, -1));"r" assert_eq!(5i32.carrying_mul_add(-2, 10, 10), (10, 0));"r" assert_eq!(1_000_000_000i32.carrying_mul_add(-10, 0, 0), (2884901888, -3));"r" assert_eq!(1_000_000_000i32.carrying_mul_add(-10, 10, 10), (2884901908, -3));"r" Calculates the divisor when `self` is divided by `rhs`."r" Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would"r" occur. If an overflow would occur then self is returned."r" Calculates the quotient of Euclidean division `self.div_euclid(rhs)`."r" occur. If an overflow would occur then `self` is returned."r" Calculates the remainder when `self` is divided by `rhs`."r" Returns a tuple of the remainder after dividing along with a boolean indicating whether an"r" arithmetic overflow would occur. If an overflow would occur then 0 is returned."r" Overflowing Euclidean remainder. Calculates `self.rem_euclid(rhs)`."r" Negates self, overflowing if this is equal to the minimum value."r" Returns a tuple of the negated version of self along with a boolean indicating whether an overflow"r" happened. If `self` is the minimum value (e.g., `i32::MIN` for values of type `i32`), then the"r" minimum value will be returned again and `true` will be returned for an overflow happening."r" Shifts self left by `rhs` bits."r" Returns a tuple of the shifted version of self along with a boolean indicating whether the shift"r" value was larger than or equal to the number of bits. If the shift value is too large, then value is"r" masked (N-1) where N is the number of bits, and this value is then used to perform the shift."r" assert_eq!(0x1i32.overflowing_shl(36), (0x10, true));"r" Shifts self right by `rhs` bits."r" assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));"r" Computes the absolute value of `self`."r" Returns a tuple of the absolute version of self along with a boolean indicating whether an overflow"r" happened. If self is the minimum value"r" then the minimum value will be returned again and true will be returned"r" for an overflow happening."r" Raises self to the power of `exp`, using exponentiation by squaring."r" Returns a tuple of the exponentiation along with a bool indicating"r" whether an overflow happened."r" assert_eq!(3i8.overflowing_pow(5), (-13, true));"r" assert_eq!(x.pow(5), 32);"r" This function will panic if `self` is negative."isqrtr" Calculates the quotient of Euclidean division of `self` by `rhs`."r" This computes the integer `q` such that `self = q * rhs + r`, with"r" `r = self.rem_euclid(rhs)` and `0 <= r < abs(rhs)`."r" In other words, the result is `self / rhs` rounded to the integer `q`"r" such that `self >= q * rhs`."r" If `self > 0`, this is equal to rounding towards zero (the default in Rust);"r" if `self < 0`, this is equal to rounding away from zero (towards +/- infinity)."r" If `rhs > 0`, this is equal to rounding towards -infinity;"r" if `rhs < 0`, this is equal to rounding towards +infinity."r" This function will panic if `rhs` is zero or if `self` is `Self::MIN`"r" and `rhs` is -1. This behavior is not affected by the `overflow-checks` flag."r" let b = 4;"r" assert_eq!(a.div_euclid(b), 1); // 7 >= 4 * 1"r" assert_eq!(a.div_euclid(-b), -1); // 7 >= -4 * -1"r" assert_eq!((-a).div_euclid(b), -2); // -7 >= 4 * -2"r" assert_eq!((-a).div_euclid(-b), 2); // -7 >= -4 * 2"r" Calculates the least nonnegative remainder of `self (mod rhs)`."r" This is done as if by the Euclidean division algorithm -- given"r" `r = self.rem_euclid(rhs)`, the result satisfies"r" `self = rhs * self.div_euclid(rhs) + r` and `0 <= r < abs(rhs)`."r" This function will panic if `rhs` is zero or if `self` is `Self::MIN` and"r" `rhs` is -1. This behavior is not affected by the `overflow-checks` flag."r" assert_eq!(a.rem_euclid(b), 3);"r" assert_eq!((-a).rem_euclid(b), 1);"r" assert_eq!(a.rem_euclid(-b), 3);"r" assert_eq!((-a).rem_euclid(-b), 1);"r" This will panic:"r" Calculates the quotient of `self` and `rhs`, rounding the result towards negative infinity."r" #![feature(int_roundings)]"r" let b = 3;"r" assert_eq!(a.div_floor(b), 2);"r" assert_eq!(a.div_floor(-b), -3);"r" assert_eq!((-a).div_floor(b), -3);"r" assert_eq!((-a).div_floor(-b), 2);"r" Calculates the quotient of `self` and `rhs`, rounding the result towards positive infinity."r" assert_eq!(a.div_ceil(b), 3);"r" assert_eq!(a.div_ceil(-b), -2);"r" assert_eq!((-a).div_ceil(b), -2);"r" assert_eq!((-a).div_ceil(-b), 3);"r" If `rhs` is positive, calculates the smallest value greater than or"r" equal to `self` that is a multiple of `rhs`. If `rhs` is negative,"r" calculates the largest value less than or equal to `self` that is a"r" multiple of `rhs`."r" multiple of `rhs`. Returns `None` if `rhs` is zero or the operation"r" would result in overflow."checked_next_multiple_ofr" Returns the logarithm of the number with respect to an arbitrary base,"r" rounded down."r" This method might not be optimized owing to implementation details;"r" `ilog2` can produce results more efficiently for base 2, and `ilog10`"r" can produce results more efficiently for base 10."r" This function will panic if `self` is less than or equal to zero,"r" or if `base` is less than 2."ilogr" Returns the base 2 logarithm of the number, rounded down."r" This function will panic if `self` is less than or equal to zero."r" Returns the base 10 logarithm of the number, rounded down."ilog10r" Returns `None` if the number is negative or zero, or if the base is not at least 2."r" `checked_ilog2` can produce results more efficiently for base 2, and"r" `checked_ilog10` can produce results more efficiently for base 10."checked_ilogr" Returns `None` if the number is negative or zero."checked_ilog2checked_ilog10r" # Overflow behavior"r" The absolute value of"r" cannot be represented as an"r" and attempting to calculate it will cause an overflow. This means"r" that code in debug mode will trigger a panic on this case and"r" optimized code will return"r" without a panic. If you do not want this behavior, consider"r" using [`unsigned_abs`](Self::unsigned_abs) instead."r" Computes the absolute difference between `self` and `other`."r" This function always returns the correct answer without overflow or"r" panics by returning an unsigned integer."r" Returns a number representing sign of `self`."r"  - `0` if the number is zero"r"  - `1` if the number is positive"r"  - `-1` if the number is negative"r" Returns `true` if `self` is positive and `false` if the number is zero or"r" negative."r" Returns `true` if `self` is negative and `false` if the number is zero or"r" positive."r" Returns the memory representation of this integer as a byte array in"r" big-endian (network) byte order."r" little-endian byte order."r" native byte order."r" As the target platform's native endianness is used, portable code"r" should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,"r" [`to_be_bytes`]: Self::to_be_bytes"r" [`to_le_bytes`]: Self::to_le_bytes"r"     bytes,"r#"     if cfg!(target_endian = "big") {"#r" Creates an integer value from its representation as a byte array in"r" big endian."r" When starting from a slice rather than an array, fallible conversion APIs can be used:"r"     *input = rest;"r" little endian."r" Creates an integer value from its memory representation as a byte"r" array in native endianness."r" likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as"r" appropriate instead."r" [`from_be_bytes`]: Self::from_be_bytes"r" [`from_le_bytes`]: Self::from_le_bytes"r" New code should prefer to use"r" Returns the smallest value that can be represented by this integer type."r" Returns the largest value that can be represented by this integer type."r" Clamps this number to a symmetric range centred around zero."r" The method clamps the number's magnitude (absolute value) to be at most `limit`."r" This is functionally equivalent to `self.clamp(-limit, limit)`, but is more"r" explicit about the intent."r" #![feature(clamp_magnitude)]"r" Calculates the midpoint (average) between `self` and `rhs`."r" `midpoint(a, b)` is `(a + b) / 2` as if it were performed in a"r" sufficiently-large signed integral type. This implies that the result is"r" always rounded towards zero and that no overflow will ever occur."ASCII_CASE_MASK/// If the bit selected by this mask is set, ascii is lower case.uint_implr" The smallest value that can be represented by this integer type."r" assert_eq!(n.count_ones(), 3);"r" assert_eq!(zero.count_ones(), 0);"r" assert_eq!(max.count_zeros(), 0);"r" assert_eq!(n.leading_zeros(), 2);"r" assert_eq!(max.leading_zeros(), 0);"r" Returns the number of trailing zeros in the binary representation"r" of `self`."r" assert_eq!(n.trailing_zeros(), 3);"r" assert_eq!(n.leading_ones(), 2);"r" assert_eq!(zero.leading_ones(), 0);"r" Returns the number of trailing ones in the binary representation"r" assert_eq!(n.trailing_ones(), 3);"r" assert_eq!(zero.trailing_ones(), 0);"r" Returns the minimum number of bits required to represent `self`."r" This method returns zero if `self` is zero."r" #![feature(uint_bit_width)]"r" Returns the bit pattern of `self` reinterpreted as a signed integer of the same size."r" Performs a left funnel shift (concatenates `self` with `rhs`, with `self`"r" making up the most significant half, then shifts the combined value left"r" by `n`, and most significant half is extracted to produce the result)."r" Please note this isn't the same operation as the `<<` shifting operator or"r" [`rotate_left`](Self::rotate_left), although `a.funnel_shl(a, n)` is *equivalent*"r" to `a.rotate_left(n)`."r" If `n` is greater than or equal to the number of bits in `self`"r" #![feature(funnel_shifts)]"funnel_shlr" Performs a right funnel shift (concatenates `self` and `rhs`, with `self`"r" making up the most significant half, then shifts the combined value right"r" by `n`, and least significant half is extracted to produce the result)."r" Please note this isn't the same operation as the `>>` shifting operator or"r" [`rotate_right`](Self::rotate_right), although `a.funnel_shr(a, n)` is *equivalent*"r" to `a.rotate_right(n)`."funnel_shrr" Returns an integer with the bit locations specified by `mask` packed"r" contiguously into the least significant bits of the result."r" #![feature(uint_gather_scatter_bits)]"r" assert_eq!(n.gather_bits(0b0010_0100), 0b0000_0011);"r" assert_eq!(n.gather_bits(0xF0), 0b0000_1011);"gather_bitsr" Returns an integer with the least significant bits of `self`"r" distributed to the bit locations specified by `mask`."r" assert_eq!(n.scatter_bits(0b0101_0101), 0b0101_0001);"r" assert_eq!(n.scatter_bits(0xF0), 0b1101_0000);"scatter_bitsr" On big endian this is a no-op. On little endian the bytes are"r" swapped."r" On little endian this is a no-op. On big endian the bytes are"r" Converts `self` to big endian from the target's endianness."r" Converts `self` to little endian from the target's endianness."r" Checked addition with a signed integer. Computes `self + rhs`,"r" Strict addition with a signed integer. Computes `self + rhs`,"r" The following panic because of overflow:"strict_add_signedr" Checked integer subtraction. Computes `self - rhs`, returning"r" `None` if overflow occurred."r" If you find yourself writing code like this:"r" # let foo = 30_u32;"r" # let bar = 20;"r" if foo >= bar {"r"     // SAFETY: just checked it will not overflow"r"     let diff = unsafe { foo.unchecked_sub(bar) };"r"     // ... use diff ..."r" Consider changing it to"r" if let Some(diff) = foo.checked_sub(bar) {"r" As that does exactly the same thing -- including telling the optimizer"r" that the subtraction cannot overflow -- but avoids needing `unsafe`."r" Checked subtraction with a signed integer. Computes `self - rhs`,"r" Strict subtraction with a signed integer. Computes `self - rhs`,"strict_sub_signedchecked_signed_diffr" Checked integer multiplication. Computes `self * rhs`, returning"r" Checked integer division. Computes `self / rhs`, returning `None`"r" if `rhs == 0`."r" Strict integer division. Computes `self / rhs`."r" Strict division on unsigned types is just normal division. There's no"r" way overflow could ever happen. This function exists so that all"r" operations are accounted for in the strict operations."r" Checked Euclidean division. Computes `self.div_euclid(rhs)`, returning `None`"r" Strict Euclidean division. Computes `self.div_euclid(rhs)`."r" operations are accounted for in the strict operations. Since, for the"r" positive integers, all common definitions of division are equal, this"r" is exactly equal to `self.strict_div(rhs)`."r" returning `None` if `rhs == 0` or if `self % rhs != 0`."r" This results in undefined behavior when `rhs == 0` or `self % rhs != 0`,"r" Checked integer remainder. Computes `self % rhs`, returning `None`"r" Strict integer remainder. Computes `self % rhs`."r" Strict remainder calculation on unsigned types is just the regular"r" remainder calculation. There's no way overflow could ever happen."r" This function exists so that all operations are accounted for in the"r" strict operations."r" Checked Euclidean modulo. Computes `self.rem_euclid(rhs)`, returning `None`"r" Strict Euclidean modulo. Computes `self.rem_euclid(rhs)`."r" Strict modulo calculation on unsigned types is just the regular"r" strict operations. Since, for the positive integers, all common"r" definitions of division are equal, this is exactly equal to"r" `self.strict_rem(rhs)`."r" Same value as `self | other`, but UB if any bit position is set in both inputs."r" This is a situational micro-optimization for places where you'd rather"r" use addition on some platforms and bitwise or on other platforms, based"r" on exactly which instructions combine better with whatever else you're"r" doing.  Note that there's no reason to bother using this for places"r" where it's clear from the operations involved that they can't overlap."r" For example, if you're combining `u16`s into a `u32` with"r" `((a as u32) << 16) | (b as u32)`, that's fine, as the backend will"r" know those sides of the `|` are disjoint without needing help."r" #![feature(disjoint_bitor)]"r" // SAFETY: `1` and `4` have no bits in common."r" Requires that `(self & other) == 0`, otherwise it's immediate UB."r" Equivalently, requires that `(self | other) == (self + other)`."unchecked_disjoint_bitorr" This function will panic if `self` is zero, or if `base` is less than 2."r" This function will panic if `self` is zero."r" Returns `None` if the number is zero, or if the base is not at least 2."r" Returns `None` if the number is zero."r" Checked negation. Computes `-self`, returning `None` unless `self =="r" 0`."r" Note that negating any positive integer will overflow."r" Strict negation. Computes `-self`, panicking unless `self =="r" Checked shift left. Computes `self << rhs`, returning `None`"r" if `rhs` is larger than or equal to the number of bits in `self`."r" losslessly reversed `rhs` cannot be larger than"r" This results in undefined behavior when `rhs > self.leading_zeros() || rhs >="r" Checked shift right. Computes `self >> rhs`, returning `None`"r" Saturating integer addition. Computes `self + rhs`, saturating at"r" the numeric bounds instead of overflowing."r" Saturating addition with a signed integer. Computes `self + rhs`,"saturating_add_signedr" Saturating integer subtraction. Computes `self - rhs`, saturating"r" at the numeric bounds instead of overflowing."r" Saturating integer subtraction. Computes `self` - `rhs`, saturating at"saturating_sub_signedr" Saturating integer multiplication. Computes `self * rhs`,"r" Wrapping (modular) addition. Computes `self + rhs`,"r" Wrapping (modular) addition with a signed integer. Computes"wrapping_add_signedr" Wrapping (modular) subtraction. Computes `self - rhs`,"r" Wrapping (modular) subtraction with a signed integer. Computes"wrapping_sub_signedr" Wrapping (modular) multiplication. Computes `self *"r" rhs`, wrapping around at the boundary of the type."r" Please note that this example is shared among integer types, which is why `u8` is used."r" assert_eq!(10u8.wrapping_mul(12), 120);"r" assert_eq!(25u8.wrapping_mul(12), 44);"r" Wrapping (modular) division. Computes `self / rhs`."r" Wrapped division on unsigned types is just normal division. There's"r" no way wrapping could ever happen. This function exists so that all"r" operations are accounted for in the wrapping operations."r" Wrapping Euclidean division. Computes `self.div_euclid(rhs)`."r" operations are accounted for in the wrapping operations. Since, for"r" the positive integers, all common definitions of division are equal,"r" this is exactly equal to `self.wrapping_div(rhs)`."r" Wrapping (modular) remainder. Computes `self % rhs`."r" Wrapped remainder calculation on unsigned types is just the regular"r" remainder calculation. There's no way wrapping could ever happen."r" wrapping operations."r" Wrapping Euclidean modulo. Computes `self.rem_euclid(rhs)`."r" Wrapped modulo calculation on unsigned types is just the regular"r" wrapping operations. Since, for the positive integers, all common"r" `self.wrapping_rem(rhs)`."r" Wrapping (modular) negation. Computes `-self`,"r" Since unsigned types do not have negative equivalents"r" all applications of this function will wrap (except for `-0`)."r" For values smaller than the corresponding signed type's maximum"r" the result is the same as casting the corresponding signed value."r" Any larger values are equivalent to `MAX + 1 - (val - MAX - 1)` where"r" `MAX` is the corresponding signed type's maximum."r" Panic-free bitwise shift-left; yields `self << mask(rhs)`,"r" where `mask` removes any high-order bits of `rhs` that"r" would cause the shift to exceed the bitwidth of the type."r" Note that this is *not* the same as a rotate-left; the"r" RHS of a wrapping shift-left is restricted to the range"r" of the type, rather than the bits shifted out of the LHS"r" being returned to the other end. The primitive integer"r" types all implement a [`rotate_left`](Self::rotate_left) function,"r" Panic-free bitwise shift-right; yields `self >> mask(rhs)`,"r" Note that this is *not* the same as a rotate-right; the"r" RHS of a wrapping shift-right is restricted to the range"r" types all implement a [`rotate_right`](Self::rotate_right) function,"r" assert_eq!(3u8.wrapping_pow(6), 217);"r" Calculates `self` + `rhs` + `carry` and returns a tuple containing"r" the sum and the output carry (in that order)."r" bit, and returns an output integer and a carry-out bit. This allows"r" chaining together multiple additions to create a wider addition, and"r" can be useful for bignum addition."r" [`overflowing_add`](Self::overflowing_add), and the output carry is"r" equal to the overflow flag. Note that although carry and overflow"r" flags are similar for unsigned integers, they are different for"r" signed integers."r" let (sum1, carry2) = a1.carrying_add(b1, carry1);"r" assert_eq!(carry2, false);"r" assert_eq!((sum1, sum0), (9, 6));"r" Calculates `self` + `rhs` with a signed `rhs`."r" Calculates `self` &minus; `rhs` &minus; `borrow` and returns a tuple"r" containing the difference and the output borrow."r" operand and a borrow-in bit from `self`, and returns an output"r" integer and a borrow-out bit. This allows chaining together multiple"r" subtractions to create a wider subtraction, and can be useful for"r" bignum subtraction."r" let (diff1, borrow2) = a1.borrowing_sub(b1, borrow1);"r" assert_eq!(borrow2, false);"r" Calculates `self` - `rhs` with a signed `rhs`"r" Returns a tuple of the multiplication along with a boolean"r" indicating whether an arithmetic overflow would occur. If an"r" overflow would have occurred then the wrapped value is returned."r" If you want the *value* of the overflow, rather than just *whether*"r" an overflow occurred, see [`Self::carrying_mul`]."r" Please note that this example is shared among integer types, which is why `u32` is used."r" assert_eq!(5u32.overflowing_mul(2), (10, false));"r" assert_eq!(1_000_000_000u32.overflowing_mul(10), (1410065408, true));""this returns the result of the operation, \
                          without modifying the original"r" Calculates the complete double-width product `self * rhs`."r" of the result as two separate values, in that order. As such,"r" `a.widening_mul(b).0` produces the same result as `a.wrapping_mul(b)`."r" If you also need to add a value and carry to the wide result, then you want"r" [`Self::carrying_mul_add`] instead."r" If you just want to know *whether* the multiplication overflowed, then you"r" want [`Self::overflowing_mul`] instead."r" Compared to other `*_mul` methods:"r" assert_eq!(5u32.widening_mul(2), (10, 0));"r" assert_eq!(1_000_000_000u32.widening_mul(10), (1410065408, 2));"r" If you also need to add a value, then use [`Self::carrying_mul_add`]."r" assert_eq!(5u32.carrying_mul(2, 0), (10, 0));"r" assert_eq!(5u32.carrying_mul(2, 10), (20, 0));"r" assert_eq!(1_000_000_000u32.carrying_mul(10, 0), (1410065408, 2));"r" assert_eq!(1_000_000_000u32.carrying_mul(10, 10), (1410065418, 2));"r" This is the core operation needed for scalar multiplication when"r" implementing it for wider-than-native types."r" fn scalar_mul_eq(little_endian_digits: &mut Vec<u16>, multiplicand: u16) {"r"     let mut carry = 0;"r"     for d in little_endian_digits.iter_mut() {"r"         (*d, carry) = d.carrying_mul(multiplicand, carry);"r"     if carry != 0 {"r"         little_endian_digits.push(carry);"r" let mut v = vec![10, 20];"r" scalar_mul_eq(&mut v, 3);"r" assert_eq!(v, [30, 60]);"r" assert_eq!(0x87654321_u64 * 0xFEED, 0x86D3D159E38D);"r" let mut v = vec![0x4321, 0x8765];"r" scalar_mul_eq(&mut v, 0xFEED);"r" assert_eq!(v, [0xE38D, 0xD159, 0x86D3]);"r" If `carry` is zero, this is similar to [`overflowing_mul`](Self::overflowing_mul),"r" except that it gives the value of the overflow instead of just whether one happened:"r" let r = u8::carrying_mul(7, 13, 0);"r" assert_eq!((r.0, r.1 != 0), u8::overflowing_mul(7, 13));"r" let r = u8::carrying_mul(13, 42, 0);"r" assert_eq!((r.0, r.1 != 0), u8::overflowing_mul(13, 42));"r" The value of the first field in the returned tuple matches what you'd get"r" by combining the [`wrapping_mul`](Self::wrapping_mul) and"r" [`wrapping_add`](Self::wrapping_add) methods:"r"     789_u16.carrying_mul(456, 123).0,"r"     789_u16.wrapping_mul(456).wrapping_add(123),"r#" Calculates the "full multiplication" `self * rhs + carry + add`."#r" This cannot overflow, as the double-width result has exactly enough"r" space for the largest possible result. This is equivalent to how, in"r" decimal, 9 × 9 + 9 + 9 = 81 + 18 = 99 = 9×10⁰ + 9×10¹ = 10² - 1."r" If you don't need the `add` part, then you can use [`Self::carrying_mul`] instead."r" Please note that this example is shared between integer types,"r" which explains why `u32` is used here."r" assert_eq!(5u32.carrying_mul_add(2, 0, 0), (10, 0));"r" assert_eq!(5u32.carrying_mul_add(2, 10, 10), (30, 0));"r" assert_eq!(1_000_000_000u32.carrying_mul_add(10, 0, 0), (1410065408, 2));"r" assert_eq!(1_000_000_000u32.carrying_mul_add(10, 10, 10), (1410065428, 2));"r#" This is the core per-digit operation for "grade school" O(n²) multiplication."#r" using `u8` for simplicity of the demonstration."r" fn quadratic_mul<const N: usize>(a: [u8; N], b: [u8; N]) -> [u8; N] {"r"     let mut out = [0; N];"r"     for j in 0..N {"r"         let mut carry = 0;"r"         for i in 0..(N - j) {"r"             (out[j + i], carry) = u8::carrying_mul_add(a[i], b[j], out[j + i], carry);"r"     out"r" // -1 * -1 == 1"r" assert_eq!(quadratic_mul([0xFF; 3], [0xFF; 3]), [1, 0, 0]);"r" assert_eq!(u32::wrapping_mul(0x9e3779b9, 0x7f4a7c15), 0xcffc982d);"r"     quadratic_mul(u32::to_le_bytes(0x9e3779b9), u32::to_le_bytes(0x7f4a7c15)),"r"     u32::to_le_bytes(0xcffc982d)"r" Returns a tuple of the divisor along with a boolean indicating"r" whether an arithmetic overflow would occur. Note that for unsigned"r" integers overflow never occurs, so the second value is always"r" `false`."r" Since, for the positive integers, all common"r" definitions of division are equal, this"r" is exactly equal to `self.overflowing_div(rhs)`."r" Returns a tuple of the remainder after dividing along with a boolean"r" indicating whether an arithmetic overflow would occur. Note that for"r" unsigned integers overflow never occurs, so the second value is"r" always `false`."r" Calculates the remainder `self.rem_euclid(rhs)` as if by Euclidean division."r" Returns a tuple of the modulo after dividing along with a boolean"r" definitions of division are equal, this operation"r" is exactly equal to `self.overflowing_rem(rhs)`."r" Negates self in an overflowing fashion."r" Returns `!self + 1` using wrapping operations to return the value"r" that represents the negation of this unsigned value. Note that for"r" positive unsigned values overflow always occurs, but negating 0 does"r" not overflow."r" Returns a tuple of the shifted version of self along with a boolean"r" indicating whether the shift value was larger than or equal to the"r" number of bits. If the shift value is too large, then value is"r" masked (N-1) where N is the number of bits, and this value is then"r" used to perform the shift."r" assert_eq!(3u8.overflowing_pow(6), (217, true));"r" Performs Euclidean division."r" is exactly equal to `self / rhs`."r" Calculates the least remainder of `self (mod rhs)`."r" is exactly equal to `self % rhs`."r" This is the same as performing `self / rhs` for all unsigned integers."r" Calculates the smallest value greater than or equal to `self` that"r" is a multiple of `rhs`."r" is a multiple of `rhs`. Returns `None` if `rhs` is zero or the"r" operation would result in overflow."r" Returns `true` if `self` is an integer multiple of `rhs`, and false otherwise."r" This function is equivalent to `self % rhs == 0`, except that it will not panic"r" for `rhs == 0`. Instead, `0.is_multiple_of(0) == true`, and for any non-zero `n`,"r" `n.is_multiple_of(0) == false`."r" Returns `true` if and only if `self == 2^k` for some unsigned integer `k`."one_less_than_next_power_of_twor" Returns the smallest power of two greater than or equal to `self`."r" When return value overflows (i.e., `self > (1 << (N-1))` for type"r" `uN`), it panics in debug mode and the return value is wrapped to 0 in"r" release mode (the only situation in which this method can return 0)."r" Returns the smallest power of two greater than or equal to `self`. If"r" the next power of two is greater than the type's maximum value,"r" `None` is returned, otherwise the power of two is wrapped in `Some`."r" Returns the smallest power of two greater than or equal to `n`. If"r" the return value is wrapped to `0`."r" #![feature(wrapping_next_power_of_two)]"wrapping_next_power_of_twor" Creates a native endian integer value from its representation"r" as a byte array in big endian."r" as a byte array in little endian."r" Creates a native endian integer value from its memory representation"r" as a byte array in native endianness."r" sufficiently-large unsigned integral type. This implies that the result is"/// let ascii = 97u8;/// let non_ascii = 150u8;/// If the value of this byte is within the ASCII range, returns it as an/// [ASCII character](ascii::Char).  Otherwise, returns `None`./// Converts this byte to an [ASCII character](ascii::Char), without/// checking whether or not it's valid./// This byte must be valid ASCII, or else this is UB./// let lowercase_a = 97u8;/// assert_eq!(65, lowercase_a.to_ascii_uppercase());/// [`make_ascii_uppercase`]: Self::make_ascii_uppercase/// let uppercase_a = 65u8;/// assert_eq!(97, uppercase_a.to_ascii_lowercase());/// [`make_ascii_lowercase`]: Self::make_ascii_lowercaseascii_change_case_unchecked/// Assumes self is ascii/// This is equivalent to `to_ascii_lowercase(a) == to_ascii_lowercase(b)`./// assert!(lowercase_a.eq_ignore_ascii_case(&uppercase_a));/// Converts this value to its ASCII upper case equivalent in-place./// [`to_ascii_uppercase`]./// let mut byte = b'a';/// byte.make_ascii_uppercase();/// assert_eq!(b'A', byte);/// [`to_ascii_uppercase`]: Self::to_ascii_uppercase/// Converts this value to its ASCII lower case equivalent in-place./// [`to_ascii_lowercase`]./// let mut byte = b'A';/// byte.make_ascii_lowercase();/// assert_eq!(b'a', byte);/// [`to_ascii_lowercase`]: Self::to_ascii_lowercase/// let uppercase_a = b'A';/// let uppercase_g = b'G';/// let a = b'a';/// let g = b'g';/// let zero = b'0';/// let percent = b'%';/// let space = b' ';/// let lf = b'\n';/// let esc = b'\x1b';/// let seven = b'7';/// let nine = b'9';/// - U+005B ..= U+0060 `` [ \ ] ^ _ ` ``, or"this returns the escaped byte as an iterator, \
                  without modifying the original"/// Returns an iterator that produces an escaped version of a `u8`,/// treating it as an ASCII character./// The behavior is identical to [`ascii::escape_default`]./// assert_eq!("0", b'0'.escape_ascii().to_string());/// assert_eq!("\\t", b'\t'.escape_ascii().to_string());/// assert_eq!("\\r", b'\r'.escape_ascii().to_string());/// assert_eq!("\\n", b'\n'.escape_ascii().to_string());/// assert_eq!("\\'", b'\''.escape_ascii().to_string());/// assert_eq!("\\\"", b'"'.escape_ascii().to_string());/// assert_eq!("\\\\", b'\\'.escape_ascii().to_string());/// assert_eq!("\\x9d", b'\x9d'.escape_ascii().to_string());is_utf8_char_boundary/// Checks if the value is a Unicode surrogate code point, which are disallowed values for [`char`]./// #![feature(utf16_extra)]/// let low_non_surrogate = 0xA000u16;/// let low_surrogate = 0xD800u16;/// let high_surrogate = 0xDC00u16;/// let high_non_surrogate = 0xE000u16;/// assert!(!low_non_surrogate.is_utf16_surrogate());/// assert!(low_surrogate.is_utf16_surrogate());/// assert!(high_surrogate.is_utf16_surrogate());/// assert!(!high_non_surrogate.is_utf16_surrogate());repeat_u8/// Returns an `usize` where every byte is equal to `x`.repeat_u16/// Returns an `usize` where every byte pair is equal to `x`./// NaN (not a number): this value results from calculations like `(-1.0).sqrt()`./// See [the documentation for `f32`](f32) for more information on the unusual properties/// of NaN./// Positive or negative infinity, which often results from dividing a nonzero number/// by zero./// Positive or negative zero./// See [the documentation for `f32`](f32) for more information on the signedness of zeroes.Subnormal/// “Subnormal” or “denormal” floating point representation (less precise, relative to/// their magnitude, than [`Normal`])./// Subnormal numbers are larger in magnitude than [`Zero`] but smaller in magnitude than all/// [`Normal`] numbers./// [`Normal`]: Self::Normal/// [`Zero`]: Self::Zero/// A regular floating point number, not any of the exceptional categories./// The smallest positive normal numbers are [`f32::MIN_POSITIVE`] and [`f64::MIN_POSITIVE`],/// and the largest positive normal numbers are [`f32::MAX`] and [`f64::MAX`]. (Unlike signed/// integers, floating point numbers are symmetric in their range, so negating any of these/// constants will produce their negative counterpart.)/// A classification of floating point numbers./// This `enum` is used as the return type for [`f32::classify`] and [`f64::classify`]. See/// their documentation for more./// let zero = 0f32;/// let sub: f32 = 1.1754942e-38;/// assert_eq!(zero.classify(), FpCategory::Zero);/// assert_eq!(sub.classify(), FpCategory::Subnormal);/// assert_eq!(nan.classify(), FpCategory::Nan);can_not_overflow/// Determines if a string of text of that length of that radix could be guaranteed to be/// stored in the given type T./// Note that if the radix is known to the compiler, it is just the check of digits.len that/// is done at runtime.from_ascii_radix_panicfrom_str_int_implr" Parses an integer from a string slice with decimal digits."r" The characters are expected to be an optional"r" sign followed by only digits. Leading and trailing non-digit characters (including"r" whitespace) represent an error. Underscores (which are accepted in Rust literals)"r" also represent an error."r" For parsing numbers in other bases, such as binary or hexadecimal,"r" see [`from_str_radix`][Self::from_str_radix]."r" use std::str::FromStr;"r" Trailing space returns error:"r" Parses an integer from a string slice with digits in a given base."r" The string is expected to be an optional"r" Digits are a subset of these characters, depending on `radix`:"r" * `0-9`"r" * `a-z`"r" * `A-Z`"r" This function panics if `radix` is not in the range from 2 to 36."r" If the string to be parsed is in base 10 (decimal),"r" [`from_str`] or [`str::parse`] can also be used."r" [`from_str`]: #method.from_str"r" [`str::parse`]: primitive.str.html#method.parse"r" Parses an integer from an ASCII-byte slice with decimal digits."r" #![feature(int_from_ascii)]"r" # #![feature(int_from_ascii)]"r" Parses an integer from an ASCII-byte slice with digits in a given base."from_ascii_radix//! Numeric traits and functions for the built-in numeric types.// import uint_impl!define_valid_range_typerustc_layout_scalar_valid_range_startrustc_layout_scalar_valid_range_endr" Constructs an instance of this type from the underlying integer"r" primitive without checking whether its zero."r" Immediate language UB if `val` is not within the valid range for this"r" type, as it violates the validity invariant."// SAFETY: 0 is within the valid rangeNonZeroU8InnerNonZeroU16InnerNonZeroU32InnerNonZeroU64InnerNonZeroU128InnerNonZeroI8InnerNonZeroI16InnerNonZeroI32InnerNonZeroI64InnerNonZeroI128InnerNonZeroCharInnerNonZeroUsizeInnerNonZeroIsizeInnerU32NotAllOnesI32NotAllOnesU64NotAllOnesI64NotAllOnesNotAllOnesHelperNotAllOnesCodePointInnerNonZeroInner/// A marker trait for primitive types which can be zero./// This is an implementation detail for <code>[NonZero]\<T></code> which may disappear or be replaced at any time./// Types implementing this trait must be primitives that are valid when zeroed./// The associated `Self::NonZeroInner` type must have the same size+align as `Self`,/// but with a niche and bit validity making it so the following `transmutes` are sound:/// - `Self::NonZeroInner` to `Option<Self::NonZeroInner>`/// - `Option<Self::NonZeroInner>` to `Self`/// (And, consequently, `Self::NonZeroInner` to `Self`.)impl_zeroable_primitiverustc_nonnull_optimization_guaranteed"NonZero"/// A value that is known not to equal zero./// This enables some memory layout optimization./// For example, `Option<NonZero<u32>>` is the same size as `u32`:/// use core::{num::NonZero};/// assert_eq!(size_of::<Option<NonZero<u32>>>(), size_of::<u32>());/// `NonZero<T>` is guaranteed to have the same layout and bit validity as `T`/// with the exception that the all-zero bit pattern is invalid./// `Option<NonZero<T>>` is guaranteed to be compatible with `T`, including in/// FFI./// Thanks to the [null pointer optimization], `NonZero<T>` and/// `Option<NonZero<T>>` are guaranteed to have the same size and alignment:/// assert_eq!(size_of::<NonZero<u32>>(), size_of::<Option<NonZero<u32>>>());/// assert_eq!(align_of::<NonZero<u32>>(), align_of::<Option<NonZero<u32>>>());/// [null pointer optimization]: crate::option#representation/// # Note on generic usage/// `NonZero<T>` can only be used with some standard library primitive types/// (such as `u8`, `i32`, and etc.). The type parameter `T` must implement the/// internal trait [`ZeroablePrimitive`], which is currently permanently unstable/// and cannot be implemented by users. Therefore, you cannot use `NonZero<T>`/// with your own types, nor can you implement traits for all `NonZero<T>`,/// only for concrete types.impl_nonzero_fmtimpl_nonzero_auto_trait// Implement auto-traits manually based on `T` to avoid docs exposing// the `ZeroablePrimitive::NonZeroInner` implementation detail.// FIXME(const_hack): the T: ~const Destruct should be inferred from the Self: ~const Destruct.// See https://github.com/rust-lang/rust/issues/144207/// Creates a non-zero if the given value is not zero./// Creates a non-zero without checking whether the value is non-zero./// This results in undefined behavior if the value is zero./// The value must not be zero./// Converts a reference to a non-zero mutable reference/// if the referenced value is not zero.from_mut_unchecked/// Converts a mutable reference to a non-zero mutable reference/// without checking whether the referenced value is non-zero./// This results in undefined behavior if the referenced value is zero./// The referenced value must not be zero./// Returns the contained value as a primitive type.nonzero_integernonzero_integer_signedness_dependent_impls// Impls for unsigned nonzero types only.// Impls for signed nonzero types only.nonzero_integer_signedness_dependent_methods// Associated items for unsigned nonzero types only.// Associated items for signed nonzero types only.// https://github.com/rust-lang/rustfmt/issues/5974r" This enables some memory layout optimization."r" # Layout"r" with the exception that `0` is not a valid instance."r" including in FFI."r" Thanks to the [null pointer optimization],"r" are guaranteed to have the same size and alignment:"r" # Compile-time creation"r" Since both [`Option::unwrap()`] and [`Option::expect()`] are `const`, it is possible to"r" define a new"r" at compile time via:"r" [null pointer optimization]: crate::option#representation"r" The size of this non-zero integer type in bits."r" # use std::num::NonZero;"r" On many architectures, this function can perform better than `leading_zeros()` on the underlying integer type, as special handling of zero can be avoided."r" # fn main() { test().unwrap(); }"r" # fn test() -> Option<()> {"r" # Some(())"r" On many architectures, this function can perform better than `trailing_zeros()` on the underlying integer type, as special handling of zero can be avoided."r" Returns `self` with only the most significant bit set."r" # use core::num::NonZero;"r" assert_eq!(a.isolate_highest_one(), b);""this returns the result of the operation, \
                        without modifying the original"r" Returns `self` with only the least significant bit set."r" assert_eq!(a.isolate_lowest_one(), b);"r" Returns the index of the highest bit set to one in `self`."r" Returns the index of the lowest bit set to one in `self`."r" assert_eq!(a.count_ones(), NonZero::new(1)?);"r" assert_eq!(b.count_ones(), NonZero::new(3)?);"r" #![feature(nonzero_bitwise)]"r" second least-significant bit becomes second most-significant bit, etc."r" The smallest value that can be represented by this non-zero"r" integer type, 1."r" The largest value that can be represented by this non-zero"r" integer type,"r" Adds an unsigned integer to a non-zero value."r" Checks for overflow and returns [`None`] on overflow."r" As a consequence, the result cannot wrap to zero."r" assert_eq!(Some(two), one.checked_add(1));"r" assert_eq!(None, max.checked_add(1));"r" assert_eq!(two, one.saturating_add(1));"r" assert_eq!(max, max.saturating_add(1));"r" Adds an unsigned integer to a non-zero value,"r" assuming overflow cannot occur."r" Overflow is unchecked, and it is undefined behavior to overflow"r" *even if the result would wrap to a non-zero value*."r" The behavior is undefined as soon as"r" #![feature(nonzero_ops)]"r" assert_eq!(two, unsafe { one.unchecked_add(1) });"r" Checks for overflow and returns [`None`]"r" if the next power of two is greater than the type’s maximum value."r" assert_eq!(Some(two), two.checked_next_power_of_two() );"r" assert_eq!(Some(four), three.checked_next_power_of_two() );"r" assert_eq!(None, max.checked_next_power_of_two() );"r" This is the same operation as"r" except that it has no failure cases to worry about"r" since this value can never be zero."r" `midpoint(a, b)` is `(a + b) >> 1` as if it were performed in a"r" always rounded towards negative infinity and that no overflow will ever occur."r" assert_eq!(one.midpoint(four), two);"r" assert_eq!(four.midpoint(one), two);"r" Returns `true` if and only if `self == (1 << k)` for some `k`."r" On many architectures, this function can perform better than `is_power_of_two()`"r" on the underlying integer type, as special handling of zero can be avoided."r" assert!(eight.is_power_of_two());"r" assert!(!ten.is_power_of_two());"r" assert_eq!(ten.isqrt(), three);"r" Multiplies two non-zero integers together."r" assert_eq!(Some(four), two.checked_mul(two));"r" assert_eq!(None, max.checked_mul(two));"r" assert_eq!(four, two.saturating_mul(two));"r" assert_eq!(max, four.saturating_mul(max));"r" Multiplies two non-zero integers together,"r" assert_eq!(four, unsafe { two.unchecked_mul(two) });"r" Raises non-zero value to an integer power."r" assert_eq!(Some(twenty_seven), three.checked_pow(3));"r" assert_eq!(None, half_max.checked_pow(3));"r" Raise non-zero value to an integer power."r" assert_eq!(twenty_seven, three.saturating_pow(3));"r" assert_eq!(max, max.saturating_pow(3));"r" Same as `self / other.get()`, but because `other` is a `NonZero<_>`,"r" there's never a runtime check for division-by-zero."r" This operation rounds towards zero, truncating any fractional"r" part of the exact result, and cannot panic."r" Same as `self /= other.get()`, but because `other` is a `NonZero<_>`,"r" This operation satisfies `n % d == n - (n / d) * d`, and cannot panic."r" The result is guaranteed to be non-zero."r" assert_eq!(one.div_ceil(max), one);"r" assert_eq!(three.div_ceil(two), two);"r" Note: While most integer types are defined for every whole"r" number between `MIN` and `MAX`, signed non-zero integers are"r#" a special case. They have a "gap" at 0."#r" Computes the absolute value of self."r" for documentation on overflow behavior."r" assert_eq!(pos, pos.abs());"r" assert_eq!(pos, neg.abs());"r" Checked absolute value."r" Checks for overflow and returns [`None`] if"r" The result cannot be zero."r" assert_eq!(Some(pos), neg.checked_abs());"r" assert_eq!(None, min.checked_abs());"r" Computes the absolute value of self,"r" with overflow information, see"r" assert_eq!((pos, false), pos.overflowing_abs());"r" assert_eq!((pos, false), neg.overflowing_abs());"r" assert_eq!((min, true), min.overflowing_abs());"r" Saturating absolute value, see"r" assert_eq!(pos, pos.saturating_abs());"r" assert_eq!(pos, neg.saturating_abs());"r" assert_eq!(max, min.saturating_abs());"r" assert_eq!(max, min_plus.saturating_abs());"r" Wrapping absolute value, see"r" assert_eq!(pos, pos.wrapping_abs());"r" assert_eq!(pos, neg.wrapping_abs());"r" assert_eq!(min, min.wrapping_abs());"r" assert_eq!(max, (-max).wrapping_abs());"r" Computes the absolute value of self"r" without any wrapping or panicking."r" assert_eq!(u_pos, i_pos.unsigned_abs());"r" assert_eq!(u_pos, i_neg.unsigned_abs());"r" assert_eq!(u_max, i_min.unsigned_abs());"r" Returns `true` if `self` is positive and `false` if the"r" number is negative."r" assert!(pos_five.is_positive());"r" assert!(!neg_five.is_positive());"r" Returns `true` if `self` is negative and `false` if the"r" number is positive."r" assert!(neg_five.is_negative());"r" assert!(!pos_five.is_negative());"r" Checked negation. Computes `-self`,"r" assert_eq!(pos_five.checked_neg(), Some(neg_five));"r" assert_eq!(min.checked_neg(), None);"r" assert_eq!(pos_five.overflowing_neg(), (neg_five, false));"r" assert_eq!(min.overflowing_neg(), (min, true));"r" Saturating negation. Computes `-self`,"r" assert_eq!(pos_five.saturating_neg(), neg_five);"r" assert_eq!(min.saturating_neg(), max);"r" assert_eq!(max.saturating_neg(), min_plus_one);"r" assert_eq!(pos_five.wrapping_neg(), neg_five);"r" assert_eq!(min.wrapping_neg(), min);"//! Definitions of integer that is known not to equal zero.//! Functions for panicking on overflow.//! In particular, these are used by the `strict_` methods on integers."Saturating"/// Provides intentionally-saturating arithmetic on `T`./// Operations like `+` on `u32` values are intended to never overflow,/// and in some debug configurations overflow is detected and results/// in a panic. While most arithmetic falls into this category, some/// code explicitly expects and relies upon saturating arithmetic./// Saturating arithmetic can be achieved either through methods like/// `saturating_add`, or through the `Saturating<T>` type, which says that/// all standard arithmetic operations on the underlying value are/// intended to have saturating semantics./// The underlying value can be retrieved through the `.0` index of the/// `Saturating` tuple./// use std::num::Saturating;/// let max = Saturating(u32::MAX);/// let one = Saturating(1u32);/// assert_eq!(u32::MAX, (max + one).0);// FIXME(30524): impl Op<T> for Saturating<T>, impl OpAssign<T> for Saturating<T>r" use std::num::Saturating;"saturating_int_implr" Returns the size of this integer type in bits."r" saturating the truncated bits to the end of the resulting"r" Please note this isn't the same operation as the `<<` shifting"r" operator!"r" let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);"r" let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);"r" assert_eq!(n.rotate_left(32), m);"r" saturating the truncated bits to the beginning of the resulting"r" Please note this isn't the same operation as the `>>` shifting"r" let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);"r" assert_eq!(n.rotate_right(4), m);"r" let n: Saturating<i16> = Saturating(0b0000000_01010101);"r" assert_eq!(n, Saturating(85));"r" assert_eq!(m, Saturating(0b01010101_00000000));"r" assert_eq!(m, Saturating(21760));"r" Reverses the bit pattern of the integer."r" Please note that this example is shared among integer types, which is why `i16`"r" is used."r" let n = Saturating(0b0000000_01010101i16);"r" assert_eq!(m.0 as u16, 0b10101010_00000000);"r" assert_eq!(m, Saturating(-22016));"r" Results that are too large are saturated:"r" assert_eq!(Saturating(3i8).pow(5), Saturating(127));"r" assert_eq!(Saturating(3i8).pow(6), Saturating(127));"saturating_int_impl_signedr" assert_eq!(n.leading_zeros(), 3);"r" Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self == MIN`"saturating_int_impl_unsignedr" Returns `true` if and only if `self == 2^k` for some `k`."//! Definitions of `Saturating<T>`.// FIXME the correct implementation is not clear. Waiting for a real world use case at https://github.com/rust-lang/libs-team/issues/230// #[allow(unused_macros)]// macro_rules! sh_impl_signed {//     ($t:ident, $f:ident) => {//         // FIXME what is the correct implementation here? see discussion https://github.com/rust-lang/rust/pull/87921#discussion_r695870065//         ////         // #[unstable(feature = "saturating_int_impl", issue = "87920")]//         // impl Shl<$f> for Saturating<$t> {//         //     type Output = Saturating<$t>;//         //     #[inline]//         //     fn shl(self, other: $f) -> Saturating<$t> {//         //         if other < 0 {//         //             Saturating(self.0.shr((-other & self::shift_max::$t as $f) as u32))//         //         } else {//         //             Saturating(self.0.shl((other & self::shift_max::$t as $f) as u32))//         //         }//         //     }//         // }//         // forward_ref_binop! { impl Shl, shl for Saturating<$t>, $f,//         // #[unstable(feature = "saturating_int_impl", issue = "87920")] }//         // impl ShlAssign<$f> for Saturating<$t> {//         //     fn shl_assign(&mut self, other: $f) {//         //         *self = *self << other;//         // forward_ref_op_assign! { impl ShlAssign, shl_assign for Saturating<$t>, $f,//         #[unstable(feature = "saturating_int_impl", issue = "87920")]//         impl Shr<$f> for Saturating<$t> {//             type Output = Saturating<$t>;//             #[inline]//             fn shr(self, other: $f) -> Saturating<$t> {//                 if other < 0 {//                     Saturating(self.0.shl((-other & self::shift_max::$t as $f) as u32))//                 } else {//                     Saturating(self.0.shr((other & self::shift_max::$t as $f) as u32))//         forward_ref_binop! { impl Shr, shr for Saturating<$t>, $f,//         #[unstable(feature = "saturating_int_impl", issue = "87920")] }//         impl ShrAssign<$f> for Saturating<$t> {//             fn shr_assign(&mut self, other: $f) {//                 *self = *self >> other;//         forward_ref_op_assign! { impl ShrAssign, shr_assign for Saturating<$t>, $f,// macro_rules! sh_impl_unsigned {//         impl Shl<$f> for Saturating<$t> {//             fn shl(self, other: $f) -> Saturating<$t> {//                 Saturating(self.0.wrapping_shl(other as u32))//         forward_ref_binop! { impl Shl, shl for Saturating<$t>, $f,//         impl ShlAssign<$f> for Saturating<$t> {//             fn shl_assign(&mut self, other: $f) {//                 *self = *self << other;//         forward_ref_op_assign! { impl ShlAssign, shl_assign for Saturating<$t>, $f,//                 Saturating(self.0.wrapping_shr(other as u32))// // FIXME (#23545): uncomment the remaining impls// macro_rules! sh_impl_all {//     ($($t:ident)*) => ($(//         //sh_impl_unsigned! { $t, u8 }//         //sh_impl_unsigned! { $t, u16 }//         //sh_impl_unsigned! { $t, u32 }//         //sh_impl_unsigned! { $t, u64 }//         //sh_impl_unsigned! { $t, u128 }//         sh_impl_unsigned! { $t, usize }//         //sh_impl_signed! { $t, i8 }//         //sh_impl_signed! { $t, i16 }//         //sh_impl_signed! { $t, i32 }//         //sh_impl_signed! { $t, i64 }//         //sh_impl_signed! { $t, i128 }//         //sh_impl_signed! { $t, isize }//     )*)// sh_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }// Related to potential Shl and ShlAssign implementation// mod shift_max {//     #![allow(non_upper_case_globals)]//     #[cfg(target_pointer_width = "16")]//     mod platform {//         pub const usize: u32 = super::u16;//         pub const isize: u32 = super::i16;//     #[cfg(target_pointer_width = "32")]//         pub const usize: u32 = super::u32;//         pub const isize: u32 = super::i32;//     #[cfg(target_pointer_width = "64")]//         pub const usize: u32 = super::u64;//         pub const isize: u32 = super::i64;//     pub const i8: u32 = (1 << 3) - 1;//     pub const i16: u32 = (1 << 4) - 1;//     pub const i32: u32 = (1 << 5) - 1;//     pub const i64: u32 = (1 << 6) - 1;//     pub const i128: u32 = (1 << 7) - 1;//     pub use self::platform::isize;//     pub const u8: u32 = i8;//     pub const u16: u32 = i16;//     pub const u32: u32 = i32;//     pub const u64: u32 = i64;//     pub const u128: u32 = i128;//     pub use self::platform::usize;legacy_int_moduler" New code should use the associated constants directly on the primitive type."r" // deprecated way"r" // intended way""Wrapping"/// code explicitly expects and relies upon modular arithmetic (e.g.,/// hashing)./// Wrapping arithmetic can be achieved either through methods like/// `wrapping_add`, or through the `Wrapping<T>` type, which says that/// intended to have wrapping semantics./// `Wrapping` tuple./// let zero = Wrapping(0u32);/// let one = Wrapping(1u32);/// assert_eq!(u32::MAX, (zero - one).0);/// `Wrapping<T>` is guaranteed to have the same layout and ABI as `T`.sh_impl_signedsh_impl_unsignedsh_impl_all// FIXME (#23545): uncomment the remaining impls// FIXME(30524): impl Op<T> for Wrapping<T>, impl OpAssign<T> for Wrapping<T>wrapping_int_implr" #![feature(wrapping_int_impl)]"r" use std::num::Wrapping;"r" wrapping the truncated bits to the end of the resulting"r" let n: Wrapping<i64> = Wrapping(0x0123456789ABCDEF);"r" let m: Wrapping<i64> = Wrapping(-0x76543210FEDCBA99);"r" let m: Wrapping<i64> = Wrapping(-0xFEDCBA987654322);"r" let n: Wrapping<i16> = Wrapping(0b0000000_01010101);"r" assert_eq!(n, Wrapping(85));"r" assert_eq!(m, Wrapping(0b01010101_00000000));"r" assert_eq!(m, Wrapping(21760));"r" let n = Wrapping(0b0000000_01010101i16);"r" assert_eq!(m, Wrapping(-22016));"r" Results that are too large are wrapped:"r" assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));"r" assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));"wrapping_int_impl_signedr" Computes the absolute value of `self`, wrapping around at"r" minimal value for the type this is a positive value that is too large to represent in the type. In"r" assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);"wrapping_int_impl_unsignedr" `uN`), overflows to `2^N = 0`."//! Definitions of `Wrapping<T>`./// The resulting type after applying the `+` operator."add"/// Performs the `+` operation./// assert_eq!(12 + 1, 13);/// The addition operator `+`./// Note that `Rhs` is `Self` by default, but this is not mandatory. For/// example, [`std::time::SystemTime`] implements `Add<Duration>`, which permits/// operations of the form `SystemTime = SystemTime + Duration`./// [`std::time::SystemTime`]: ../../std/time/struct.SystemTime.html/// ## `Add`able points/// impl Add for Point {///     type Output = Self;///     fn add(self, other: Self) -> Self {///             x: self.x + other.x,///             y: self.y + other.y,/// assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },///            Point { x: 3, y: 3 });/// ## Implementing `Add` with generics/// Here is an example of the same `Point` struct implementing the `Add` trait/// using generics./// struct Point<T> {///     x: T,///     y: T,/// // Notice that the implementation uses the associated type `Output`./// impl<T: Add<Output = T>> Add for Point<T> {///     fn add(self, other: Self) -> Self::Output {add_impl/// The resulting type after applying the `-` operator."sub"/// Performs the `-` operation./// assert_eq!(12 - 1, 11);/// The subtraction operator `-`./// example, [`std::time::SystemTime`] implements `Sub<Duration>`, which permits/// operations of the form `SystemTime = SystemTime - Duration`./// ## `Sub`tractable points/// use std::ops::Sub;/// impl Sub for Point {///     fn sub(self, other: Self) -> Self::Output {///             x: self.x - other.x,///             y: self.y - other.y,/// assert_eq!(Point { x: 3, y: 3 } - Point { x: 2, y: 3 },///            Point { x: 1, y: 0 });/// ## Implementing `Sub` with generics/// Here is an example of the same `Point` struct implementing the `Sub` trait/// impl<T: Sub<Output = T>> Sub for Point<T> {///         Point {/// assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 },///            Point { x: 1, y: 3 });sub_impl/// The resulting type after applying the `*` operator."mul"/// Performs the `*` operation./// assert_eq!(12 * 2, 24);/// The multiplication operator `*`./// Note that `Rhs` is `Self` by default, but this is not mandatory./// ## `Mul`tipliable rational numbers/// use std::ops::Mul;/// // By the fundamental theorem of arithmetic, rational numbers in lowest/// // terms are unique. So, by keeping `Rational`s in reduced form, we can/// // derive `Eq` and `PartialEq`./// #[derive(Debug, Eq, PartialEq)]/// struct Rational {///     numerator: usize,///     denominator: usize,/// impl Rational {///     fn new(numerator: usize, denominator: usize) -> Self {///         if denominator == 0 {///             panic!("Zero is an invalid denominator!");///         // Reduce to lowest terms by dividing by the greatest common///         // divisor.///         let gcd = gcd(numerator, denominator);///             numerator: numerator / gcd,///             denominator: denominator / gcd,/// impl Mul for Rational {///     // The multiplication of rational numbers is a closed operation.///     fn mul(self, rhs: Self) -> Self {///         let numerator = self.numerator * rhs.numerator;///         let denominator = self.denominator * rhs.denominator;///         Self::new(numerator, denominator)/// // Euclid's two-thousand-year-old algorithm for finding the greatest common/// // divisor./// fn gcd(x: usize, y: usize) -> usize {///     let mut x = x;///     let mut y = y;///     while y != 0 {///         let t = y;///         y = x % y;///         x = t;///     x/// assert_eq!(Rational::new(1, 2), Rational::new(2, 4));/// assert_eq!(Rational::new(2, 3) * Rational::new(3, 4),///            Rational::new(1, 2));/// ## Multiplying vectors by scalars as in linear algebra/// struct Scalar { value: usize }/// struct Vector { value: Vec<usize> }/// impl Mul<Scalar> for Vector {///     fn mul(self, rhs: Scalar) -> Self::Output {///         Self { value: self.value.iter().map(|v| v * rhs.value).collect() }/// let vector = Vector { value: vec![2, 4, 6] };/// let scalar = Scalar { value: 3 };/// assert_eq!(vector * scalar, Vector { value: vec![6, 12, 18] });mul_impl/// The resulting type after applying the `/` operator."div"/// Performs the `/` operation./// assert_eq!(12 / 2, 6);/// The division operator `/`./// ## `Div`idable rational numbers/// use std::ops::Div;/// impl Div for Rational {///     // The division of rational numbers is a closed operation.///     fn div(self, rhs: Self) -> Self::Output {///         if rhs.numerator == 0 {///             panic!("Cannot divide by zero-valued `Rational`!");///         let numerator = self.numerator * rhs.denominator;///         let denominator = self.denominator * rhs.numerator;/// assert_eq!(Rational::new(1, 2) / Rational::new(3, 4),///            Rational::new(2, 3));/// ## Dividing vectors by scalars as in linear algebra/// struct Scalar { value: f32 }/// struct Vector { value: Vec<f32> }/// impl Div<Scalar> for Vector {///     fn div(self, rhs: Scalar) -> Self::Output {///         Self { value: self.value.iter().map(|v| v / rhs.value).collect() }/// let scalar = Scalar { value: 2f32 };/// let vector = Vector { value: vec![2f32, 4f32, 6f32] };/// assert_eq!(vector / scalar, Vector { value: vec![1f32, 2f32, 3f32] });div_impl_integerr" This operation rounds towards zero, truncating any"r" fractional part of the exact result.""This operation will panic if `other == 0`.""This operation will panic if `other == 0` or the division results in overflow."div_impl_float/// The resulting type after applying the `%` operator."rem"/// Performs the `%` operation./// assert_eq!(12 % 10, 2);/// The remainder operator `%`./// This example implements `Rem` on a `SplitSlice` object. After `Rem` is/// implemented, one can use the `%` operator to find out what the remaining/// elements of the slice would be after splitting it into equal slices of a/// given length./// use std::ops::Rem;/// struct SplitSlice<'a, T> {///     slice: &'a [T],/// impl<'a, T> Rem<usize> for SplitSlice<'a, T> {///     fn rem(self, modulus: usize) -> Self::Output {///         let len = self.slice.len();///         let rem = len % modulus;///         let start = len - rem;///         Self {slice: &self.slice[start..]}/// // If we were to divide &[0, 1, 2, 3, 4, 5, 6, 7] into slices of size 3,/// // the remainder would be &[6, 7]./// assert_eq!(SplitSlice { slice: &[0, 1, 2, 3, 4, 5, 6, 7] } % 3,///            SplitSlice { slice: &[6, 7] });rem_impl_integerr" This operation satisfies `n % d == n - (n / d) * d`. The"r" result has the same sign as the left operand.""This operation will panic if `other == 0` or if `self / other` results in overflow."rem_impl_floatr" The remainder from the division of two floats."r" The remainder has the same sign as the dividend and is computed as:"r" `x - (x / y).trunc() * y`."r" let x: f32 = 50.50;"r" let y: f32 = 8.125;"r" let remainder = x - (x / y).trunc() * y;"r" // The answer to both operations is 1.75"r" assert_eq!(x % y, remainder);""neg"/// Performs the unary `-` operation./// let x: i32 = 12;/// assert_eq!(-x, -12);/// The unary negation operator `-`./// An implementation of `Neg` for `Sign`, which allows the use of `-` to/// negate its value./// use std::ops::Neg;/// enum Sign {///     Negative,///     Positive,/// impl Neg for Sign {///     fn neg(self) -> Self::Output {///             Sign::Negative => Sign::Positive,///             Sign::Zero => Sign::Zero,///             Sign::Positive => Sign::Negative,/// // A negative positive is a negative./// assert_eq!(-Sign::Positive, Sign::Negative);/// // A double negative is a positive./// assert_eq!(-Sign::Negative, Sign::Positive);/// // Zero is its own negation./// assert_eq!(-Sign::Zero, Sign::Zero);neg_impl/// Performs the `+=` operation./// let mut x: u32 = 12;/// x += 1;"add_assign"/// The addition assignment operator `+=`./// This example creates a `Point` struct that implements the `AddAssign`/// trait, and then demonstrates add-assigning to a mutable `Point`./// use std::ops::AddAssign;/// impl AddAssign for Point {///     fn add_assign(&mut self, other: Self) {///         *self = Self {/// let mut point = Point { x: 1, y: 0 };/// point += Point { x: 2, y: 3 };/// assert_eq!(point, Point { x: 3, y: 3 });add_assign_impl/// Performs the `-=` operation./// x -= 1;/// assert_eq!(x, 11);"sub_assign"/// The subtraction assignment operator `-=`./// This example creates a `Point` struct that implements the `SubAssign`/// trait, and then demonstrates sub-assigning to a mutable `Point`./// use std::ops::SubAssign;/// impl SubAssign for Point {///     fn sub_assign(&mut self, other: Self) {/// let mut point = Point { x: 3, y: 3 };/// point -= Point { x: 2, y: 3 };/// assert_eq!(point, Point {x: 1, y: 0});sub_assign_impl/// Performs the `*=` operation./// x *= 2;/// assert_eq!(x, 24);"mul_assign"/// The multiplication assignment operator `*=`./// use std::ops::MulAssign;/// struct Frequency { hertz: f64 }/// impl MulAssign<f64> for Frequency {///     fn mul_assign(&mut self, rhs: f64) {///         self.hertz *= rhs;/// let mut frequency = Frequency { hertz: 50.0 };/// frequency *= 4.0;/// assert_eq!(Frequency { hertz: 200.0 }, frequency);mul_assign_impl/// Performs the `/=` operation./// x /= 2;/// assert_eq!(x, 6);"div_assign"/// The division assignment operator `/=`./// use std::ops::DivAssign;/// impl DivAssign<f64> for Frequency {///     fn div_assign(&mut self, rhs: f64) {///         self.hertz /= rhs;/// let mut frequency = Frequency { hertz: 200.0 };/// frequency /= 4.0;/// assert_eq!(Frequency { hertz: 50.0 }, frequency);div_assign_impl/// Performs the `%=` operation./// x %= 10;/// assert_eq!(x, 2);"rem_assign"/// The remainder assignment operator `%=`./// use std::ops::RemAssign;/// struct CookieJar { cookies: u32 }/// impl RemAssign<u32> for CookieJar {///     fn rem_assign(&mut self, piles: u32) {///         self.cookies %= piles;/// let mut jar = CookieJar { cookies: 31 };/// let piles = 4;/// println!("Splitting up {} cookies into {} even piles!", jar.cookies, piles);/// jar %= piles;/// println!("{} cookies remain in the cookie jar!", jar.cookies);rem_assign_impl/// Call the [`AsyncFn`], returning a future which may borrow from the called closure.rustc_paren_sugar"async closures are lazy and do nothing unless called""async_fn"/// An async-aware version of the [`Fn`](crate::ops::Fn) trait./// All `async fn` and functions returning futures implement this trait."call_ref_future"/// Future returned by [`AsyncFnMut::async_call_mut`] and [`AsyncFn::async_call`]./// Call the [`AsyncFnMut`], returning a future which may borrow from the called closure."async_fn_mut"/// An async-aware version of the [`FnMut`](crate::ops::FnMut) trait."call_once_future"/// Future returned by [`AsyncFnOnce::async_call_once`]."async_fn_once_output"/// Output type of the called closure's future./// Call the [`AsyncFnOnce`], returning a future which may move out of the called closure."async_fn_once"/// An async-aware version of the [`FnOnce`](crate::ops::FnOnce) trait."async_fn_kind_upvars"'closure_envInputsUpvarsBorrowedUpvarsAsFnPtr// Projects a set of closure inputs (arguments), a region, and a set of upvars// (by move and by ref) to the upvars that we expect the coroutine to have// according to the `GoalKind` parameter above.// The `Upvars` parameter should be the upvars of the parent coroutine-closure,// and the `BorrowedUpvarsAsFnPtr` will be a function pointer that has the shape// `for<'env> fn() -> (&'env T, ...)`. This allows us to represent the binder// of the closure's self-capture, and these upvar types will be instantiated with// the `'closure_env` region provided to the associated type."async_fn_kind_helper"GoalKindAsyncFnKindHelper/// A helper trait that is used to enforce that the `ClosureKind` of a goal/// is within the capabilities of a `CoroutineClosure`, and which allows us/// to delay the projection of the tupled upvar types until after upvar/// analysis is complete./// The `Self` type is expected to be the `kind_ty` of the coroutine-closure,/// and thus either `?0` or `i8`/`i16`/`i32` (see docs for `ClosureKind`/// for an explanation of that). The `GoalKind` is also the same type, but/// representing the kind of the trait that the closure is being called with.internal_implementation_detail/// The resulting type after applying the `!` operator./// Performs the unary `!` operation./// assert_eq!(!true, false);/// assert_eq!(!false, true);/// assert_eq!(!1u8, 254);/// assert_eq!(!0u8, 255);"not"/// The unary logical negation operator `!`./// An implementation of `Not` for `Answer`, which enables the use of `!` to/// invert its value./// use std::ops::Not;/// enum Answer {///     Yes,///     No,/// impl Not for Answer {///     fn not(self) -> Self::Output {///             Answer::Yes => Answer::No,///             Answer::No => Answer::Yes/// assert_eq!(!Answer::Yes, Answer::No);/// assert_eq!(!Answer::No, Answer::Yes);not_impl/// The resulting type after applying the `&` operator./// Performs the `&` operation./// assert_eq!(true & false, false);/// assert_eq!(true & true, true);/// assert_eq!(5u8 & 1u8, 1);/// assert_eq!(5u8 & 2u8, 0);"bitand"/// The bitwise AND operator `&`./// An implementation of `BitAnd` for a wrapper around `bool`./// use std::ops::BitAnd;/// struct Scalar(bool);/// impl BitAnd for Scalar {///     // rhs is the "right-hand side" of the expression `a & b`///     fn bitand(self, rhs: Self) -> Self::Output {///         Self(self.0 & rhs.0)/// assert_eq!(Scalar(true) & Scalar(true), Scalar(true));/// assert_eq!(Scalar(true) & Scalar(false), Scalar(false));/// assert_eq!(Scalar(false) & Scalar(true), Scalar(false));/// assert_eq!(Scalar(false) & Scalar(false), Scalar(false));/// An implementation of `BitAnd` for a wrapper around `Vec<bool>`./// struct BooleanVector(Vec<bool>);/// impl BitAnd for BooleanVector {///     fn bitand(self, Self(rhs): Self) -> Self::Output {///         let Self(lhs) = self;///         assert_eq!(lhs.len(), rhs.len());///         Self(///             lhs.iter()///                 .zip(rhs.iter())///                 .map(|(x, y)| *x & *y)///                 .collect()/// let bv1 = BooleanVector(vec![true, true, false, false]);/// let bv2 = BooleanVector(vec![true, false, true, false]);/// let expected = BooleanVector(vec![true, false, false, false]);/// assert_eq!(bv1 & bv2, expected);bitand_impl/// The resulting type after applying the `|` operator./// Performs the `|` operation./// assert_eq!(true | false, true);/// assert_eq!(false | false, false);/// assert_eq!(5u8 | 1u8, 5);/// assert_eq!(5u8 | 2u8, 7);"bitor"/// The bitwise OR operator `|`./// An implementation of `BitOr` for a wrapper around `bool`./// use std::ops::BitOr;/// impl BitOr for Scalar {///     // rhs is the "right-hand side" of the expression `a | b`///     fn bitor(self, rhs: Self) -> Self::Output {///         Self(self.0 | rhs.0)/// assert_eq!(Scalar(true) | Scalar(true), Scalar(true));/// assert_eq!(Scalar(true) | Scalar(false), Scalar(true));/// assert_eq!(Scalar(false) | Scalar(true), Scalar(true));/// assert_eq!(Scalar(false) | Scalar(false), Scalar(false));/// An implementation of `BitOr` for a wrapper around `Vec<bool>`./// impl BitOr for BooleanVector {///     fn bitor(self, Self(rhs): Self) -> Self::Output {///                 .map(|(x, y)| *x | *y)/// let expected = BooleanVector(vec![true, true, true, false]);/// assert_eq!(bv1 | bv2, expected);bitor_impl/// The resulting type after applying the `^` operator./// Performs the `^` operation./// assert_eq!(true ^ false, true);/// assert_eq!(true ^ true, false);/// assert_eq!(5u8 ^ 1u8, 4);/// assert_eq!(5u8 ^ 2u8, 7);"bitxor"/// The bitwise XOR operator `^`./// An implementation of `BitXor` that lifts `^` to a wrapper around `bool`./// use std::ops::BitXor;/// impl BitXor for Scalar {///     // rhs is the "right-hand side" of the expression `a ^ b`///     fn bitxor(self, rhs: Self) -> Self::Output {///         Self(self.0 ^ rhs.0)/// assert_eq!(Scalar(true) ^ Scalar(true), Scalar(false));/// assert_eq!(Scalar(true) ^ Scalar(false), Scalar(true));/// assert_eq!(Scalar(false) ^ Scalar(true), Scalar(true));/// assert_eq!(Scalar(false) ^ Scalar(false), Scalar(false));/// An implementation of `BitXor` trait for a wrapper around `Vec<bool>`./// impl BitXor for BooleanVector {///     fn bitxor(self, Self(rhs): Self) -> Self::Output {///                 .map(|(x, y)| *x ^ *y)/// let expected = BooleanVector(vec![false, true, true, false]);/// assert_eq!(bv1 ^ bv2, expected);bitxor_impl/// The resulting type after applying the `<<` operator./// Performs the `<<` operation./// assert_eq!(5u8 << 1, 10);/// assert_eq!(1u8 << 1, 2);"shl"/// The left shift operator `<<`. Note that because this trait is implemented/// for all integer types with multiple right-hand-side types, Rust's type/// checker has special handling for `_ << _`, setting the result type for/// integer operations to the type of the left-hand-side operand. This means/// that though `a << b` and `a.shl(b)` are one and the same from an evaluation/// standpoint, they are different when it comes to type inference./// An implementation of `Shl` that lifts the `<<` operation on integers to a/// wrapper around `usize`./// use std::ops::Shl;/// struct Scalar(usize);/// impl Shl<Scalar> for Scalar {///     fn shl(self, Self(rhs): Self) -> Self::Output {///         Self(lhs << rhs)/// assert_eq!(Scalar(4) << Scalar(2), Scalar(16));/// An implementation of `Shl` that spins a vector leftward by a given amount./// struct SpinVector<T: Clone> {///     vec: Vec<T>,/// impl<T: Clone> Shl<usize> for SpinVector<T> {///     fn shl(self, rhs: usize) -> Self::Output {///         // Rotate the vector by `rhs` places.///         let (a, b) = self.vec.split_at(rhs);///         let mut spun_vector = vec![];///         spun_vector.extend_from_slice(b);///         spun_vector.extend_from_slice(a);///         Self { vec: spun_vector }/// assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } << 2,///            SpinVector { vec: vec![2, 3, 4, 0, 1] });shl_implshl_impl_all/// The resulting type after applying the `>>` operator./// Performs the `>>` operation./// assert_eq!(5u8 >> 1, 2);/// assert_eq!(2u8 >> 1, 1);"shr"/// The right shift operator `>>`. Note that because this trait is implemented/// checker has special handling for `_ >> _`, setting the result type for/// that though `a >> b` and `a.shr(b)` are one and the same from an evaluation/// An implementation of `Shr` that lifts the `>>` operation on integers to a/// use std::ops::Shr;/// impl Shr<Scalar> for Scalar {///     fn shr(self, Self(rhs): Self) -> Self::Output {///         Self(lhs >> rhs)/// assert_eq!(Scalar(16) >> Scalar(2), Scalar(4));/// An implementation of `Shr` that spins a vector rightward by a given amount./// impl<T: Clone> Shr<usize> for SpinVector<T> {///     fn shr(self, rhs: usize) -> Self::Output {///         let (a, b) = self.vec.split_at(self.vec.len() - rhs);/// assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } >> 2,///            SpinVector { vec: vec![3, 4, 0, 1, 2] });shr_implshr_impl_all/// Performs the `&=` operation./// let mut x = true;/// x &= false;/// assert_eq!(x, false);/// x &= true;/// assert_eq!(x, true);/// let mut x: u8 = 5;/// x &= 1;/// assert_eq!(x, 1);/// x &= 2;/// assert_eq!(x, 0);"bitand_assign"/// The bitwise AND assignment operator `&=`./// An implementation of `BitAndAssign` that lifts the `&=` operator to a/// wrapper around `bool`./// use std::ops::BitAndAssign;/// impl BitAndAssign for Scalar {///     // rhs is the "right-hand side" of the expression `a &= b`///     fn bitand_assign(&mut self, rhs: Self) {///         *self = Self(self.0 & rhs.0)/// let mut scalar = Scalar(true);/// scalar &= Scalar(true);/// assert_eq!(scalar, Scalar(true));/// scalar &= Scalar(false);/// assert_eq!(scalar, Scalar(false));/// let mut scalar = Scalar(false);/// Here, the `BitAndAssign` trait is implemented for a wrapper around/// `Vec<bool>`./// impl BitAndAssign for BooleanVector {///     // `rhs` is the "right-hand side" of the expression `a &= b`.///         assert_eq!(self.0.len(), rhs.0.len());///         *self = Self(///             self.0///                 .iter()///                 .zip(rhs.0.iter())/// let mut bv = BooleanVector(vec![true, true, false, false]);/// bv &= BooleanVector(vec![true, false, true, false]);/// assert_eq!(bv, expected);bitand_assign_impl/// Performs the `|=` operation./// x |= false;/// let mut x = false;/// x |= 1;/// assert_eq!(x, 5);/// x |= 2;/// assert_eq!(x, 7);"bitor_assign"/// The bitwise OR assignment operator `|=`./// use std::ops::BitOrAssign;/// struct PersonalPreferences {///     likes_cats: bool,///     likes_dogs: bool,/// impl BitOrAssign for PersonalPreferences {///     fn bitor_assign(&mut self, rhs: Self) {///         self.likes_cats |= rhs.likes_cats;///         self.likes_dogs |= rhs.likes_dogs;/// let mut prefs = PersonalPreferences { likes_cats: true, likes_dogs: false };/// prefs |= PersonalPreferences { likes_cats: false, likes_dogs: true };/// assert_eq!(prefs, PersonalPreferences { likes_cats: true, likes_dogs: true });bitor_assign_impl/// Performs the `^=` operation./// x ^= false;/// x ^= true;/// x ^= 1;/// assert_eq!(x, 4);/// x ^= 2;"bitxor_assign"/// The bitwise XOR assignment operator `^=`./// use std::ops::BitXorAssign;/// struct Personality {///     has_soul: bool,///     likes_knitting: bool,/// impl BitXorAssign for Personality {///     fn bitxor_assign(&mut self, rhs: Self) {///         self.has_soul ^= rhs.has_soul;///         self.likes_knitting ^= rhs.likes_knitting;/// let mut personality = Personality { has_soul: false, likes_knitting: true };/// personality ^= Personality { has_soul: true, likes_knitting: true };/// assert_eq!(personality, Personality { has_soul: true, likes_knitting: false});bitxor_assign_impl/// Performs the `<<=` operation./// x <<= 1;/// assert_eq!(x, 10);/// let mut x: u8 = 1;"shl_assign"/// The left shift assignment operator `<<=`./// An implementation of `ShlAssign` for a wrapper around `usize`./// use std::ops::ShlAssign;/// impl ShlAssign<usize> for Scalar {///     fn shl_assign(&mut self, rhs: usize) {///         self.0 <<= rhs;/// let mut scalar = Scalar(4);/// scalar <<= 2;/// assert_eq!(scalar, Scalar(16));shl_assign_implshl_assign_impl_all/// Performs the `>>=` operation./// x >>= 1;/// let mut x: u8 = 2;"shr_assign"/// The right shift assignment operator `>>=`./// An implementation of `ShrAssign` for a wrapper around `usize`./// use std::ops::ShrAssign;/// impl ShrAssign<usize> for Scalar {///     fn shr_assign(&mut self, rhs: usize) {///         self.0 >>= rhs;/// let mut scalar = Scalar(16);/// scalar >>= 2;/// assert_eq!(scalar, Scalar(4));shr_assign_implshr_assign_impl_all"ControlFlow""Continue"/// Move on to the next phase of the operation as normal."Break"/// Exit the operation without running subsequent phases.// Yes, the order of the variants doesn't match the type parameters.// They're in this order so that `ControlFlow<A, B>` <-> `Result<B, A>`// is a no-op conversion in the `Try` implementation./// Used to tell an operation whether it should exit early or go on as usual./// This is used when exposing things (like graph traversals or visitors) where/// you want the user to be able to choose whether to exit early./// Having the enum makes it clearer -- no more wondering "wait, what did `false`/// mean again?" -- and allows including a value./// Similar to [`Option`] and [`Result`], this enum can be used with the `?` operator/// to return immediately if the [`Break`] variant is present or otherwise continue normally/// with the value inside the [`Continue`] variant./// Early-exiting from [`Iterator::try_for_each`]:///     if 403 % x == 0 {/// assert_eq!(r, ControlFlow::Break(13));/// A basic tree traversal:/// pub struct TreeNode<T> {///     left: Option<Box<TreeNode<T>>>,///     right: Option<Box<TreeNode<T>>>,/// impl<T> TreeNode<T> {///     pub fn traverse_inorder<B>(&self, f: &mut impl FnMut(&T) -> ControlFlow<B>) -> ControlFlow<B> {///         if let Some(left) = &self.left {///             left.traverse_inorder(f)?;///         f(&self.value)?;///         if let Some(right) = &self.right {///             right.traverse_inorder(f)?;///         ControlFlow::Continue(())///     fn leaf(value: T) -> Option<Box<TreeNode<T>>> {///         Some(Box::new(Self { value, left: None, right: None }))/// let node = TreeNode {///     value: 0,///     left: TreeNode::leaf(1),///     right: Some(Box::new(TreeNode {///         value: -1,///         left: TreeNode::leaf(5),///         right: TreeNode::leaf(2),/// let res = node.traverse_inorder(&mut |val| {///     if *val < 0 {///         ControlFlow::Break(*val)///         sum += *val;/// assert_eq!(res, ControlFlow::Break(-1));/// [`Break`]: ControlFlow::Break/// [`Continue`]: ControlFlow::Continue// ControlFlow should not implement PartialOrd or Ord, per RFC 3058:// https://rust-lang.github.io/rfcs/3058-try-trait-v2.html#traits-for-controlflow// Note: manually specifying the residual type instead of using the default to work around// https://github.com/rust-lang/rust/issues/99940/// assert!(ControlFlow::<&str, i32>::Break("Stop right there!").is_break());/// assert!(!ControlFlow::<&str, i32>::Continue(3).is_break());/// assert!(!ControlFlow::<&str, i32>::Break("Stop right there!").is_continue());/// assert!(ControlFlow::<&str, i32>::Continue(3).is_continue());/// Converts the `ControlFlow` into an `Option` which is `Some` if the/// `ControlFlow` was `Break` and `None` otherwise./// assert_eq!(ControlFlow::<&str, i32>::Break("Stop right there!").break_value(), Some("Stop right there!"));/// assert_eq!(ControlFlow::<&str, i32>::Continue(3).break_value(), None);break_ok/// Converts the `ControlFlow` into an `Result` which is `Ok` if the/// `ControlFlow` was `Break` and `Err` if otherwise./// #![feature(control_flow_ok)]/// struct TreeNode<T> {///     fn find<'a>(&'a self, mut predicate: impl FnMut(&T) -> bool) -> Result<&'a T, ()> {///         let mut f = |t: &'a T| -> ControlFlow<&'a T> {///             if predicate(t) {///                 ControlFlow::Break(t)///                 ControlFlow::Continue(())///         self.traverse_inorder(&mut f).break_ok()///     fn traverse_inorder<'a, B>(///         &'a self,///         f: &mut impl FnMut(&'a T) -> ControlFlow<B>,///     ) -> ControlFlow<B> {///         Some(Box::new(Self {/// let res = node.find(|val: &i32| *val > 3);/// assert_eq!(res, Ok(&5));map_break/// Maps `ControlFlow<B, C>` to `ControlFlow<T, C>` by applying a function/// to the break value in case it exists.continue_value/// `ControlFlow` was `Continue` and `None` otherwise./// assert_eq!(ControlFlow::<&str, i32>::Break("Stop right there!").continue_value(), None);/// assert_eq!(ControlFlow::<&str, i32>::Continue(3).continue_value(), Some(3));continue_ok/// `ControlFlow` was `Continue` and `Err` if otherwise.///     fn validate<B>(&self, f: &mut impl FnMut(&T) -> ControlFlow<B>) -> Result<(), B> {///         self.traverse_inorder(f).continue_ok()///     fn traverse_inorder<B>(&self, f: &mut impl FnMut(&T) -> ControlFlow<B>) -> ControlFlow<B> {/// let res = node.validate(&mut |val| {///         return ControlFlow::Break("negative value detected");///     if *val > 4 {///         return ControlFlow::Break("too big value detected");/// assert_eq!(res, Err("too big value detected"));map_continue/// Maps `ControlFlow<B, C>` to `ControlFlow<B, T>` by applying a function/// to the continue value in case it exists./// Extracts the value `T` that is wrapped by `ControlFlow<T, T>`./// #![feature(control_flow_into_value)]/// assert_eq!(ControlFlow::<i32, i32>::Break(1024).into_value(), 1024);/// assert_eq!(ControlFlow::<i32, i32>::Continue(512).into_value(), 512);from_try/// Creates a `ControlFlow` from any type implementing `Try`.into_try/// Converts a `ControlFlow` into any type implementing `Try`./// These are used only as part of implementing the iterator adapters./// They have mediocre names and non-obvious semantics, so aren't/// currently on a path to potential stabilization."coroutine_state"Yielded/// The coroutine suspended with a value./// This state indicates that a coroutine has been suspended, and typically/// corresponds to a `yield` statement. The value provided in this variant/// corresponds to the expression passed to `yield` and allows coroutines to/// provide a value each time they yield./// The coroutine completed with a return value./// This state indicates that a coroutine has finished execution with the/// provided value. Once a coroutine has returned `Complete` it is/// considered a programmer error to call `resume` again./// The result of a coroutine resumption./// This enum is returned from the `Coroutine::resume` method and indicates the/// possible return values of a coroutine. Currently this corresponds to either/// a suspension point (`Yielded`) or a termination point (`Complete`)."coroutine_yield"/// The type of value this coroutine yields./// This associated type corresponds to the `yield` expression and the/// values which are allowed to be returned each time a coroutine yields./// For example an iterator-as-a-coroutine would likely have this type as/// `T`, the type being iterated over."coroutine_return"/// The type of value this coroutine returns./// This corresponds to the type returned from a coroutine either with a/// `return` statement or implicitly as the last expression of a coroutine/// literal. For example futures would use this as `Result<T, E>` as it/// represents a completed future."coroutine_resume"/// Resumes the execution of this coroutine./// This function will resume execution of the coroutine or start execution/// if it hasn't already. This call will return back into the coroutine's/// last suspension point, resuming execution from the latest `yield`. The/// coroutine will continue executing until it either yields or returns, at/// which point this function will return./// The `CoroutineState` enum returned from this function indicates what/// state the coroutine is in upon returning. If the `Yielded` variant is/// returned then the coroutine has reached a suspension point and a value/// has been yielded out. Coroutines in this state are available for/// resumption at a later point./// If `Complete` is returned then the coroutine has completely finished/// with the value provided. It is invalid for the coroutine to be resumed/// This function may panic if it is called after the `Complete` variant has/// been returned previously. While coroutine literals in the language are/// guaranteed to panic on resuming after `Complete`, this is not guaranteed/// for all implementations of the `Coroutine` trait."coroutine""coroutines are lazy and do nothing unless resumed"/// The trait implemented by builtin coroutine types./// Coroutines are currently an/// experimental language feature in Rust. Added in [RFC 2033] coroutines are/// currently intended to primarily provide a building block for async/await/// syntax but will likely extend to also providing an ergonomic definition for/// iterators and other primitives./// The syntax and semantics for coroutines is unstable and will require a/// further RFC for stabilization. At this time, though, the syntax is/// closure-like:/// #![feature(coroutine_trait)]/// #![feature(stmt_expr_attributes)]/// use std::ops::{Coroutine, CoroutineState};///     let mut coroutine = #[coroutine] || {///         yield 1;///         "foo"///     match Pin::new(&mut coroutine).resume(()) {///         CoroutineState::Yielded(1) => {}///         _ => panic!("unexpected return from resume"),///         CoroutineState::Complete("foo") => {}/// More documentation of coroutines can be found in the [unstable book]./// [RFC 2033]: https://github.com/rust-lang/rfcs/pull/2033/// [unstable book]: ../../unstable-book/language-features/coroutines.html"deref_target"/// The resulting type after dereferencing."deref_method"/// Dereferences the value."deref""Deref"/// Used for immutable dereferencing operations, like `*v`./// In addition to being used for explicit dereferencing operations with the/// (unary) `*` operator in immutable contexts, `Deref` is also used implicitly/// by the compiler in many circumstances. This mechanism is called/// ["`Deref` coercion"][coercion]. In mutable contexts, [`DerefMut`] is used and/// mutable deref coercion similarly occurs./// **Warning:** Deref coercion is a powerful language feature which has/// far-reaching implications for every type that implements `Deref`. The/// compiler will silently insert calls to `Deref::deref`. For this reason, one/// should be careful about implementing `Deref` and only do so when deref/// coercion is desirable. See [below][implementing] for advice on when this is/// typically desirable or undesirable./// Types that implement `Deref` or `DerefMut` are often called "smart/// pointers" and the mechanism of deref coercion has been specifically designed/// to facilitate the pointer-like behavior that name suggests. Often, the/// purpose of a "smart pointer" type is to change the ownership semantics/// of a contained value (for example, [`Rc`][rc] or [`Cow`][cow]) or the/// storage semantics of a contained value (for example, [`Box`][box])./// # Deref coercion/// If `T` implements `Deref<Target = U>`, and `v` is a value of type `T`, then:/// * In immutable contexts, `*v` (where `T` is neither a reference nor a raw///   pointer) is equivalent to `*Deref::deref(&v)`./// * Values of type `&T` are coerced to values of type `&U`/// * `T` implicitly implements all the methods of the type `U` which take the///   `&self` receiver./// For more details, visit [the chapter in *The Rust Programming Language*][book]/// as well as the reference sections on [the dereference operator][ref-deref-op],/// [method resolution], and [type coercions]./// # When to implement `Deref` or `DerefMut`/// The same advice applies to both deref traits. In general, deref traits/// **should** be implemented if:/// 1. a value of the type transparently behaves like a value of the target///    type;/// 1. the implementation of the deref function is cheap; and/// 1. users of the type will not be surprised by any deref coercion behavior./// In general, deref traits **should not** be implemented if:/// 1. the deref implementations could fail unexpectedly; or/// 1. the type has methods that are likely to collide with methods on the///    target type; or/// 1. committing to deref coercion as part of the public API is not desirable./// Note that there's a large difference between implementing deref traits/// generically over many target types, and doing so only for specific target/// Generic implementations, such as for [`Box<T>`][box] (which is generic over/// every type and dereferences to `T`) should be careful to provide few or no/// methods, since the target type is unknown and therefore every method could/// collide with one on the target type, causing confusion for users./// `impl<T> Box<T>` has no methods (though several associated functions),/// partly for this reason./// Specific implementations, such as for [`String`][string] (whose `Deref`/// implementation has `Target = str`) can have many methods, since avoiding/// collision is much easier. `String` and `str` both have many methods, and/// `String` additionally behaves as if it has every method of `str` because of/// deref coercion. The implementing type may also be generic while the/// implementation is still specific in this sense; for example, [`Vec<T>`][vec]/// dereferences to `[T]`, so methods of `T` are not applicable./// Consider also that deref coercion means that deref traits are a much larger/// part of a type's public API than any other trait as it is implicitly called/// by the compiler. Therefore, it is advisable to consider whether this is/// something you are comfortable supporting as a public API./// The [`AsRef`] and [`Borrow`][core::borrow::Borrow] traits have very similar/// signatures to `Deref`. It may be desirable to implement either or both of/// these, whether in addition to or rather than deref traits. See their/// **This trait's method should never unexpectedly fail**. Deref coercion means/// the compiler will often insert calls to `Deref::deref` implicitly. Failure/// during dereferencing can be extremely confusing when `Deref` is invoked/// implicitly. In the majority of uses it should be infallible, though it may/// be acceptable to panic if the type is misused through programmer error, for/// However, infallibility is not enforced and therefore not guaranteed./// As such, `unsafe` code should not rely on infallibility in general for/// [book]: ../../book/ch15-02-deref.html/// [coercion]: #deref-coercion/// [implementing]: #when-to-implement-deref-or-derefmut/// [ref-deref-op]: ../../reference/expressions/operator-expr.html#the-dereference-operator/// [method resolution]: ../../reference/expressions/method-call-expr.html/// [type coercions]: ../../reference/type-coercions.html/// [box]: ../../alloc/boxed/struct.Box.html/// [string]: ../../alloc/string/struct.String.html/// [vec]: ../../alloc/vec/struct.Vec.html/// [rc]: ../../alloc/rc/struct.Rc.html/// [cow]: ../../alloc/borrow/enum.Cow.html/// A struct with a single field which is accessible by dereferencing the/// struct DerefExample<T> {///     value: T/// impl<T> Deref for DerefExample<T> {///     fn deref(&self) -> &Self::Target {///         &self.value/// let x = DerefExample { value: 'a' };/// assert_eq!('a', *x);"noop_method_deref""deref_mut_method"/// Mutably dereferences the value."deref_mut"/// Used for mutable dereferencing operations, like in `*v = 1;`./// (unary) `*` operator in mutable contexts, `DerefMut` is also used implicitly/// ["mutable deref coercion"][coercion]. In immutable contexts, [`Deref`] is used./// far-reaching implications for every type that implements `DerefMut`. The/// compiler will silently insert calls to `DerefMut::deref_mut`. For this/// reason, one should be careful about implementing `DerefMut` and only do so/// when mutable deref coercion is desirable. See [the `Deref` docs][implementing]/// for advice on when this is typically desirable or undesirable./// Types that implement `DerefMut` or `Deref` are often called "smart/// # Mutable deref coercion/// If `T` implements `DerefMut<Target = U>`, and `v` is a value of type `T`,/// then:/// * In mutable contexts, `*v` (where `T` is neither a reference nor a raw pointer)///   is equivalent to `*DerefMut::deref_mut(&mut v)`./// * Values of type `&mut T` are coerced to values of type `&mut U`/// * `T` implicitly implements all the (mutable) methods of the type `U`./// [method resolution] and [type coercions]./// the compiler will often insert calls to `DerefMut::deref_mut` implicitly./// Failure during dereferencing can be extremely confusing when `DerefMut` is/// invoked implicitly. In the majority of uses it should be infallible, though/// it may be acceptable to panic if the type is misused through programmer/// error, for example./// [coercion]: #mutable-deref-coercion/// [implementing]: Deref#when-to-implement-deref-or-derefmut/// A struct with a single field which is modifiable by dereferencing the/// use std::ops::{Deref, DerefMut};/// struct DerefMutExample<T> {/// impl<T> Deref for DerefMutExample<T> {/// impl<T> DerefMut for DerefMutExample<T> {///     fn deref_mut(&mut self) -> &mut Self::Target {///         &mut self.value/// let mut x = DerefMutExample { value: 'a' };/// *x = 'b';/// assert_eq!('b', x.value);"deref_pure"/// Perma-unstable marker trait. Indicates that the type has a well-behaved [`Deref`]/// (and, if applicable, [`DerefMut`]) implementation. This is relied on for soundness/// of deref patterns./// FIXME(deref_patterns): The precise semantics are undecided; the rough idea is that/// successive calls to `deref`/`deref_mut` without intermediate mutation should be/// idempotent, in the sense that they return the same value as far as pattern-matching/// is concerned. Calls to `deref`/`deref_mut` must leave the pointer itself likewise"receiver_target"/// The target type on which the method may be called."receiver"/// Indicates that a struct can be used as a method receiver./// That is, a type can use this type as a type of `self`, like this:/// # // This is currently compile_fail because the compiler-side parts/// # // of arbitrary_self_types are not implemented/// use std::ops::Receiver;/// struct SmartPointer<T>(T);/// impl<T> Receiver for SmartPointer<T> {///    type Target = T;/// struct MyContainedType;/// impl MyContainedType {///   fn method(self: SmartPointer<Self>) {///   let ptr = SmartPointer(MyContainedType);///   ptr.method();/// This trait is blanket implemented for any type which implements/// [`Deref`], which includes stdlib pointer types like `Box<T>`,`Rc<T>`, `&T`,/// and `Pin<P>`. For that reason, it's relatively rare to need to/// implement this directly. You'll typically do this only if you need/// to implement a smart pointer type which can't implement [`Deref`]; perhaps/// because you're interfacing with another programming language and can't/// guarantee that references comply with Rust's aliasing rules./// When looking for method candidates, Rust will explore a chain of possible/// `Receiver`s, so for example each of the following methods work:/// use std::boxed::Box;/// // Both `Box` and `Rc` (indirectly) implement Receiver///   let t = Rc::new(Box::new(MyContainedType));///   t.method_a();///   t.method_b();///   t.method_c();///   fn method_a(&self) {///   fn method_b(self: &Box<Self>) {///   fn method_c(self: &Rc<Box<Self>>) {"legacy_receiver"/// Indicates that a struct can be used as a method receiver, without the/// `arbitrary_self_types` feature. This is implemented by stdlib pointer types like `Box<T>`,/// `Rc<T>`, `&T`, and `Pin<P>`./// This trait will shortly be removed and replaced with a more generic/// facility based around the current "arbitrary self types" unstable feature./// That new facility will use the replacement trait above called `Receiver`/// which is why this is now named `LegacyReceiver`./// Executes the destructor for this type./// and cannot be called explicitly (this is compiler error [E0040])./// However, the [`mem::drop`] function in the prelude can be/// used to call the argument's `Drop` implementation./// If this wasn't the case, `self` would be a dangling reference./// Implementations should generally avoid [`panic!`]ing, because `drop()` may itself be called/// during unwinding due to a panic, and if the `drop()` panics in that situation (a “double/// panic”), this will likely abort the program. It is possible to check [`panicking()`] first,/// which may be desirable for a `Drop` implementation that is reporting a bug of the kind/// “you didn't finish using this before it was dropped”; but most types should simply clean up/// their owned allocations or other resources and return normally from `drop()`, regardless of/// what state they are in./// Note that even if this panics, the value is considered to be dropped;/// you must not cause `drop` to be called again. This is normally automatically/// handled by the compiler, but when using unsafe code, can sometimes occur/// unintentionally, particularly when using [`ptr::drop_in_place`]./// [E0040]: ../../error_codes/E0040.html/// [`panic!`]: crate::panic!/// [`panicking()`]: ../../std/thread/fn.panicking.html"drop"/// Custom code within the destructor./// This destructor consists of two components:/// - A call to `Drop::drop` for that value, if this special `Drop` trait is implemented for its type./// - The automatically generated "drop glue" which recursively calls the destructors///   of all the fields of this value./// As Rust automatically calls the destructors of all contained fields,/// you don't have to implement `Drop` in most cases. But there are some cases where/// it is useful, for example for types which directly manage a resource./// That resource may be memory, it may be a file descriptor, it may be a network socket./// Once a value of that type is no longer going to be used, it should "clean up" its/// resource by freeing the memory or closing the file or socket. This is/// the job of a destructor, and therefore the job of `Drop::drop`./// To see destructors in action, let's take a look at the following program:/// struct HasDrop;/// impl Drop for HasDrop {///         println!("Dropping HasDrop!");/// struct HasTwoDrops {///     one: HasDrop,///     two: HasDrop,/// impl Drop for HasTwoDrops {///         println!("Dropping HasTwoDrops!");///     let _x = HasTwoDrops { one: HasDrop, two: HasDrop };///     println!("Running!");/// Rust will first call `Drop::drop` for `_x` and then for both `_x.one` and `_x.two`,/// meaning that running this will print/// Running!/// Dropping HasTwoDrops!/// Dropping HasDrop!/// Even if we remove the implementation of `Drop` for `HasTwoDrop`, the destructors of its fields are still called./// This would result in/// ```test/// ## You cannot call `Drop::drop` yourself/// Because `Drop::drop` is used to clean up a value, it may be dangerous to use this value after/// the method has been called. As `Drop::drop` does not take ownership of its input,/// Rust prevents misuse by not allowing you to call `Drop::drop` directly./// In other words, if you tried to explicitly call `Drop::drop` in the above example, you'd get a compiler error./// If you'd like to explicitly call the destructor of a value, [`mem::drop`] can be used instead./// ## Drop order/// Which of our two `HasDrop` drops first, though? For structs, it's the same/// order that they're declared: first `one`, then `two`. If you'd like to try/// this yourself, you can modify `HasDrop` above to contain some data, like an/// integer, and then use it in the `println!` inside of `Drop`. This behavior is/// guaranteed by the language./// Unlike for structs, local variables are dropped in reverse order:///         println!("Dropping Foo!")/// impl Drop for Bar {///         println!("Dropping Bar!")///     let _foo = Foo;///     let _bar = Bar;/// This will print/// Dropping Bar!/// Dropping Foo!/// Please see [the reference] for the full rules./// ## `Copy` and `Drop` are exclusive/// You cannot implement both [`Copy`] and `Drop` on the same type. Types that/// ## Drop check/// Dropping interacts with the borrow checker in subtle ways: when a type `T` is being implicitly/// dropped as some variable of this type goes out of scope, the borrow checker needs to ensure that/// calling `T`'s destructor at this moment is safe. In particular, it also needs to be safe to/// recursively drop all the fields of `T`. For example, it is crucial that code like the following/// is being rejected:/// ```compile_fail,E0597/// struct S<'a>(Cell<Option<&'a S<'a>>>, Box<i32>);/// impl Drop for S<'_> {///         if let Some(r) = self.0.get() {///             // Print the contents of the `Box` in `r`.///             println!("{}", r.1);///     // Set up two `S` that point to each other.///     let s1 = S(Cell::new(None), Box::new(42));///     let s2 = S(Cell::new(Some(&s1)), Box::new(42));///     s1.0.set(Some(&s2));///     // Now they both get dropped. But whichever is the 2nd one///     // to be dropped will access the `Box` in the first one,///     // which is a use-after-free!/// The Nomicon discusses the need for [drop check in more detail][drop check]./// To reject such code, the "drop check" analysis determines which types and lifetimes need to/// still be live when `T` gets dropped. The exact details of this analysis are not yet/// stably guaranteed and **subject to change**. Currently, the analysis works as follows:/// - If `T` has no drop glue, then trivially nothing is required to be live. This is the case if///   neither `T` nor any of its (recursive) fields have a destructor (`impl Drop`). [`PhantomData`],///   arrays of length 0 and [`ManuallyDrop`] are considered to never have a destructor, no matter///   their field type./// - If `T` has drop glue, then, for all types `U` that are *owned* by any field of `T`,///   recursively add the types and lifetimes that need to be live when `U` gets dropped. The set of///   owned types is determined by recursively traversing `T`:///   - Recursively descend through `PhantomData`, `Box`, tuples, and arrays (excluding arrays of///     length 0).///   - Stop at reference and raw pointer types as well as function pointers and function items;///     they do not own anything.///   - Stop at non-composite types (type parameters that remain generic in the current context and///     base types such as integers and `bool`); these types are owned.///   - When hitting an ADT with `impl Drop`, stop there; this type is owned.///   - When hitting an ADT without `impl Drop`, recursively descend to its fields. (For an `enum`,///     consider all fields of all variants.)/// - Furthermore, if `T` implements `Drop`, then all generic (lifetime and type) parameters of `T`///   must be live./// In the above example, the last clause implies that `'a` must be live when `S<'a>` is dropped,/// and hence the example is rejected. If we remove the `impl Drop`, the liveness requirement/// disappears and the example is accepted./// There exists an unstable way for a type to opt-out of the last clause; this is called "drop/// check eyepatch" or `may_dangle`. For more details on this nightly-only feature, see the/// [discussion in the Nomicon][nomicon]./// [`ManuallyDrop`]: crate::mem::ManuallyDrop/// [`PhantomData`]: crate::marker::PhantomData/// [drop check]: ../../nomicon/dropck.html/// [nomicon]: ../../nomicon/phantom-data.html#an-exception-the-special-case-of-the-standard-library-and-its-unstable-may_dangle/// Performs the call operation."closures are lazy and do nothing unless called"/// The version of the call operator that takes an immutable receiver./// Instances of `Fn` can be called repeatedly without mutating state./// *This trait (`Fn`) is not to be confused with [function pointers]/// (`fn`).*/// `Fn` is implemented automatically by closures which only take immutable/// references to captured variables or don't capture anything at all, as well/// as (safe) [function pointers] (with some caveats, see their documentation/// for more details). Additionally, for any type `F` that implements `Fn`, `&F`/// implements `Fn`, too./// Since both [`FnMut`] and [`FnOnce`] are supertraits of `Fn`, any/// instance of `Fn` can be used as a parameter where a [`FnMut`] or [`FnOnce`]/// is expected./// Use `Fn` as a bound when you want to accept a parameter of function-like/// type and need to call it repeatedly and without mutating state (e.g., when/// calling it concurrently). If you do not need such strict requirements, use/// [`FnMut`] or [`FnOnce`] as bounds./// See the [chapter on closures in *The Rust Programming Language*][book] for/// some more information on this topic./// Also of note is the special syntax for `Fn` traits (e.g./// `Fn(usize, bool) -> usize`). Those interested in the technical details of/// this can refer to [the relevant section in the *Rustonomicon*][nomicon]./// [book]: ../../book/ch13-01-closures.html/// [function pointers]: fn/// [nomicon]: ../../nomicon/hrtb.html/// ## Calling a closure/// let square = |x| x * x;/// assert_eq!(square(5), 25);/// ## Using a `Fn` parameter/// fn call_with_one<F>(func: F) -> usize///     where F: Fn(usize) -> usize {///     func(1)/// let double = |x| x * 2;/// assert_eq!(call_with_one(double), 2);// so that regex can rely that `&str: !FnMut`"fn_mut"/// The version of the call operator that takes a mutable receiver./// Instances of `FnMut` can be called repeatedly and may mutate state./// `FnMut` is implemented automatically by closures which take mutable/// references to captured variables, as well as all types that implement/// [`Fn`], e.g., (safe) [function pointers] (since `FnMut` is a supertrait of/// [`Fn`]). Additionally, for any type `F` that implements `FnMut`, `&mut F`/// implements `FnMut`, too./// Since [`FnOnce`] is a supertrait of `FnMut`, any instance of `FnMut` can be/// used where a [`FnOnce`] is expected, and since [`Fn`] is a subtrait of/// `FnMut`, any instance of [`Fn`] can be used where `FnMut` is expected./// Use `FnMut` as a bound when you want to accept a parameter of function-like/// type and need to call it repeatedly, while allowing it to mutate state./// If you don't want the parameter to mutate state, use [`Fn`] as a/// bound; if you don't need to call it repeatedly, use [`FnOnce`]./// ## Calling a mutably capturing closure///     let mut square_x = || x *= x;///     square_x();/// assert_eq!(x, 25);/// ## Using a `FnMut` parameter/// fn do_twice<F>(mut func: F)///     where F: FnMut()///     func();/// let mut x: usize = 1;///     let add_two_to_x = || x += 2;///     do_twice(add_two_to_x);"fn_once_output"/// The returned type after the call operator is used."fn_once"/// The version of the call operator that takes a by-value receiver./// Instances of `FnOnce` can be called, but might not be callable multiple/// times. Because of this, if the only thing known about a type is that it/// implements `FnOnce`, it can only be called once./// `FnOnce` is implemented automatically by closures that might consume captured/// variables, as well as all types that implement [`FnMut`], e.g., (safe)/// [function pointers] (since `FnOnce` is a supertrait of [`FnMut`])./// Since both [`Fn`] and [`FnMut`] are subtraits of `FnOnce`, any instance of/// [`Fn`] or [`FnMut`] can be used where a `FnOnce` is expected./// Use `FnOnce` as a bound when you want to accept a parameter of function-like/// type and only need to call it once. If you need to call the parameter/// repeatedly, use [`FnMut`] as a bound; if you also need it to not mutate/// state, use [`Fn`]./// ## Using a `FnOnce` parameter/// fn consume_with_relish<F>(func: F)///     where F: FnOnce() -> String///     // `func` consumes its captured variables, so it cannot be run more///     // than once.///     println!("Consumed: {}", func());///     println!("Delicious!");///     // Attempting to invoke `func()` again will throw a `use of moved///     // value` error for `func`./// let x = String::from("x");/// let consume_and_return_x = move || x;/// consume_with_relish(consume_and_return_x);/// // `consume_and_return_x` can no longer be invoked at this point"IndexOutput"/// The returned type after indexing./// Performs the indexing (`container[index]`) operation./// May panic if the index is out of bounds."index"/// Used for indexing operations (`container[index]`) in immutable contexts./// `container[index]` is actually syntactic sugar for `*container.index(index)`,/// but only when used as an immutable value. If a mutable value is requested,/// [`IndexMut`] is used instead. This allows nice things such as/// `let value = v[index]` if the type of `value` implements [`Copy`]./// The following example implements `Index` on a read-only `NucleotideCount`/// container, enabling individual counts to be retrieved with index syntax./// use std::ops::Index;/// enum Nucleotide {///     G,///     T,/// struct NucleotideCount {///     a: usize,///     c: usize,///     g: usize,///     t: usize,/// impl Index<Nucleotide> for NucleotideCount {///     type Output = usize;///     fn index(&self, nucleotide: Nucleotide) -> &Self::Output {///         match nucleotide {///             Nucleotide::A => &self.a,///             Nucleotide::C => &self.c,///             Nucleotide::G => &self.g,///             Nucleotide::T => &self.t,/// let nucleotide_count = NucleotideCount {a: 14, c: 9, g: 10, t: 12};/// assert_eq!(nucleotide_count[Nucleotide::A], 14);/// assert_eq!(nucleotide_count[Nucleotide::C], 9);/// assert_eq!(nucleotide_count[Nucleotide::G], 10);/// assert_eq!(nucleotide_count[Nucleotide::T], 12);/// Performs the mutable indexing (`container[index]`) operation."index_mut"/// Used for indexing operations (`container[index]`) in mutable contexts./// `container[index]` is actually syntactic sugar for/// `*container.index_mut(index)`, but only when used as a mutable value. If/// an immutable value is requested, the [`Index`] trait is used instead. This/// allows nice things such as `v[index] = value`./// A very simple implementation of a `Balance` struct that has two sides, where/// each can be indexed mutably and immutably./// use std::ops::{Index, IndexMut};/// enum Side {///     Left,///     Right,/// enum Weight {///     Kilogram(f32),///     Pound(f32),/// struct Balance {///     pub left: Weight,///     pub right: Weight,/// impl Index<Side> for Balance {///     type Output = Weight;///     fn index(&self, index: Side) -> &Self::Output {///         println!("Accessing {index:?}-side of balance immutably");///         match index {///             Side::Left => &self.left,///             Side::Right => &self.right,/// impl IndexMut<Side> for Balance {///     fn index_mut(&mut self, index: Side) -> &mut Self::Output {///         println!("Accessing {index:?}-side of balance mutably");///             Side::Left => &mut self.left,///             Side::Right => &mut self.right,/// let mut balance = Balance {///     right: Weight::Kilogram(2.5),///     left: Weight::Pound(1.5),/// // In this case, `balance[Side::Right]` is sugar for/// // `*balance.index(Side::Right)`, since we are only *reading*/// // `balance[Side::Right]`, not writing it./// assert_eq!(balance[Side::Right], Weight::Kilogram(2.5));/// // However, in this case `balance[Side::Left]` is sugar for/// // `*balance.index_mut(Side::Left)`, since we are writing/// // `balance[Side::Left]`./// balance[Side::Left] = Weight::Kilogram(3.0);/// Like a `Range<usize>`, but with a safety invariant that `start <= end`./// This means that `end - start` cannot overflow, allowing some μoptimizations./// (Normal `Range` code needs to handle degenerate ranges like `10..0`,///  which takes extra checks compared to only handling the canonical form.)/// - `start <= end`zero_to/// - Can only be called when `start < end`, aka when `len > 0`.take_prefix/// Removes the first `n` items from this range, returning them as an `IndexRange`./// If there are fewer than `n`, then the whole range is returned and/// `self` is left empty./// This is designed to help implement `Iterator::advance_by`./// Removes the last `n` items from this range, returning them as an `IndexRange`./// This is designed to help implement `Iterator::advance_back_by`.assume_range// SAFETY: Because we only deal in `usize`, our `len` is always perfect.async_functioncoroutineindex_rangetry_traitIntoBoundsOneSidedRangeOneSidedRangeBoundCoerceSharedReborrowYeet//! Overloadable operators.//! Implementing these traits allows you to overload certain operators.//! Some of these traits are imported by the prelude, so they are available in//! every Rust program. Only operators backed by traits can be overloaded. For//! example, the addition operator (`+`) can be overloaded through the [`Add`]//! trait, but since the assignment operator (`=`) has no backing trait, there//! is no way of overloading its semantics. Additionally, this module does not//! provide any mechanism to create new operators. If traitless overloading or//! custom operators are required, you should look toward macros to extend//! Rust's syntax.//! Implementations of operator traits should be unsurprising in their//! respective contexts, keeping in mind their usual meanings and//! [operator precedence]. For example, when implementing [`Mul`], the operation//! should have some resemblance to multiplication (and share expected//! properties like associativity).//! Note that the `&&` and `||` operators are currently not supported for//! overloading. Due to their short circuiting nature, they require a different//! design from traits for other operators like [`BitAnd`]. Designs for them are//! under discussion.//! Many of the operators take their operands by value. In non-generic//! contexts involving built-in types, this is usually not a problem.//! However, using these operators in generic code, requires some//! attention if values have to be reused as opposed to letting the operators//! consume them. One option is to occasionally use [`clone`].//! Another option is to rely on the types involved providing additional//! operator implementations for references. For example, for a user-defined//! type `T` which is supposed to support addition, it is probably a good//! idea to have both `T` and `&T` implement the traits [`Add<T>`][`Add`] and//! [`Add<&T>`][`Add`] so that generic code can be written without unnecessary//! This example creates a `Point` struct that implements [`Add`] and [`Sub`],//! and then demonstrates adding and subtracting two `Point`s.//! use std::ops::{Add, Sub};//! #[derive(Debug, Copy, Clone, PartialEq)]//! struct Point {//!     x: i32,//!     y: i32,//! impl Add for Point {//!     type Output = Self;//!     fn add(self, other: Self) -> Self {//!         Self {x: self.x + other.x, y: self.y + other.y}//! impl Sub for Point {//!     fn sub(self, other: Self) -> Self {//!         Self {x: self.x - other.x, y: self.y - other.y}//! assert_eq!(Point {x: 3, y: 3}, Point {x: 1, y: 0} + Point {x: 2, y: 3});//! assert_eq!(Point {x: -1, y: -3}, Point {x: 1, y: 0} - Point {x: 2, y: 3});//! See the documentation for each trait for an example implementation.//! The [`Fn`], [`FnMut`], and [`FnOnce`] traits are implemented by types that can be//! invoked like functions. Note that [`Fn`] takes `&self`, [`FnMut`] takes `&mut//! self` and [`FnOnce`] takes `self`. These correspond to the three kinds of//! methods that can be invoked on an instance: call-by-reference,//! call-by-mutable-reference, and call-by-value. The most common use of these//! traits is to act as bounds to higher-level functions that take functions or//! closures as arguments.//! Taking a [`Fn`] as a parameter://! fn call_with_one<F>(func: F) -> usize//!     where F: Fn(usize) -> usize//!     func(1)//! let double = |x| x * 2;//! assert_eq!(call_with_one(double), 2);//! Taking a [`FnMut`] as a parameter://! fn do_twice<F>(mut func: F)//!     where F: FnMut()//!     func();//! let mut x: usize = 1;//!     let add_two_to_x = || x += 2;//!     do_twice(add_two_to_x);//! assert_eq!(x, 5);//! Taking a [`FnOnce`] as a parameter://! fn consume_with_relish<F>(func: F)//!     where F: FnOnce() -> String//!     // `func` consumes its captured variables, so it cannot be run more//!     // than once//!     println!("Consumed: {}", func());//!     println!("Delicious!");//!     // Attempting to invoke `func()` again will throw a `use of moved//!     // value` error for `func`//! let x = String::from("x");//! let consume_and_return_x = move || x;//! consume_with_relish(consume_and_return_x);//! // `consume_and_return_x` can no longer be invoked at this point//! [operator precedence]: ../../reference/expressions.html#expression-precedence"RangeFull"/// An unbounded range (`..`)./// `RangeFull` is primarily used as a [slicing index], its shorthand is `..`./// It cannot serve as an [`Iterator`] because it doesn't have a starting point./// The `..` syntax is a `RangeFull`:/// assert_eq!(.., std::ops::RangeFull);/// It does not have an [`IntoIterator`] implementation, so you can't use it in/// a `for` loop directly. This won't compile:/// for i in .. {/// Used as a [slicing index], `RangeFull` produces the full array as a slice./// let arr = [0, 1, 2, 3, 4];/// assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]); // This is the `RangeFull`/// assert_eq!(arr[ .. 3], [0, 1, 2      ]);/// assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]);/// assert_eq!(arr[1..  ], [   1, 2, 3, 4]);/// assert_eq!(arr[1.. 3], [   1, 2      ]);/// assert_eq!(arr[1..=3], [   1, 2, 3   ]);/// [slicing index]: crate::slice::SliceIndex"Range"/// The lower bound of the range (inclusive)./// The upper bound of the range (exclusive)./// A (half-open) range bounded inclusively below and exclusively above/// (`start..end`)./// The range `start..end` contains all values with `start <= x < end`./// It is empty if `start >= end`./// The `start..end` syntax is a `Range`:/// assert_eq!((3..5), std::ops::Range { start: 3, end: 5 });/// assert_eq!(3 + 4 + 5, (3..6).sum());/// assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);/// assert_eq!(arr[1.. 3], [   1, 2      ]); // This is a `Range`// not Copy -- see #27186/// Returns `true` if `item` is contained in the range./// assert!(!(3..5).contains(&2));/// assert!( (3..5).contains(&3));/// assert!( (3..5).contains(&4));/// assert!(!(3..5).contains(&5));/// assert!(!(3..3).contains(&3));/// assert!(!(3..2).contains(&3));/// assert!( (0.0..1.0).contains(&0.5));/// assert!(!(0.0..1.0).contains(&f32::NAN));/// assert!(!(0.0..f32::NAN).contains(&0.5));/// assert!(!(f32::NAN..1.0).contains(&0.5));/// Returns `true` if the range contains no items./// assert!(!(3..5).is_empty());/// assert!( (3..3).is_empty());/// assert!( (3..2).is_empty());/// The range is empty if either side is incomparable:/// assert!(!(3.0..5.0).is_empty());/// assert!( (3.0..f32::NAN).is_empty());/// assert!( (f32::NAN..5.0).is_empty());"RangeFrom"/// A range only bounded inclusively below (`start..`)./// The `RangeFrom` `start..` contains all values with `x >= start`./// *Note*: Overflow in the [`Iterator`] implementation (when the contained/// data type reaches its numerical limit) is allowed to panic, wrap, or/// saturate. This behavior is defined by the implementation of the [`Step`]/// trait. For primitive integers, this follows the normal rules, and respects/// the overflow checks profile (panic in debug, wrap in release). Note also/// that overflow happens earlier than you might assume: the overflow happens/// in the call to `next` that yields the maximum value, as the range must be/// set to a state to yield the next value./// [`Step`]: crate::iter::Step/// The `start..` syntax is a `RangeFrom`:/// assert_eq!((2..), std::ops::RangeFrom { start: 2 });/// assert_eq!(2 + 3 + 4, (2..).take(3).sum());/// assert_eq!(arr[1..  ], [   1, 2, 3, 4]); // This is a `RangeFrom`/// assert!(!(3..).contains(&2));/// assert!( (3..).contains(&3));/// assert!( (3..).contains(&1_000_000_000));/// assert!( (0.0..).contains(&0.5));/// assert!(!(0.0..).contains(&f32::NAN));/// assert!(!(f32::NAN..).contains(&0.5));"RangeTo"/// A range only bounded exclusively above (`..end`)./// The `RangeTo` `..end` contains all values with `x < end`./// The `..end` syntax is a `RangeTo`:/// assert_eq!((..5), std::ops::RangeTo { end: 5 });/// // error[E0277]: the trait bound `std::ops::RangeTo<{integer}>:/// // std::iter::Iterator` is not satisfied/// for i in ..5 {/// When used as a [slicing index], `RangeTo` produces a slice of all array/// elements before the index indicated by `end`./// assert_eq!(arr[ .. 3], [0, 1, 2      ]); // This is a `RangeTo`/// assert!( (..5).contains(&-1_000_000_000));/// assert!( (..5).contains(&4));/// assert!(!(..5).contains(&5));/// assert!( (..1.0).contains(&0.5));/// assert!(!(..1.0).contains(&f32::NAN));/// assert!(!(..f32::NAN).contains(&0.5));"RangeInclusive"// Note that the fields here are not public to allow changing the// representation in the future; in particular, while we could plausibly// expose start/end, modifying them without changing (future/current)// private fields may lead to incorrect behavior, so we don't want to// support that mode.// This field is://  - `false` upon construction//  - `false` when iteration has yielded an element and the iterator is not exhausted//  - `true` when iteration has been used to exhaust the iterator// This is required to support PartialEq and Hash without a PartialOrd bound or specialization./// A range bounded inclusively below and above (`start..=end`)./// The `RangeInclusive` `start..=end` contains all values with `x >= start`/// and `x <= end`. It is empty unless `start <= end`./// This iterator is [fused], but the specific values of `start` and `end` after/// iteration has finished are **unspecified** other than that [`.is_empty()`]/// will return `true` once no more values will be produced./// [fused]: crate::iter::FusedIterator/// [`.is_empty()`]: RangeInclusive::is_empty/// The `start..=end` syntax is a `RangeInclusive`:/// assert_eq!((3..=5), std::ops::RangeInclusive::new(3, 5));/// assert_eq!(3 + 4 + 5, (3..=5).sum());/// assert_eq!(arr[1..=3], [   1, 2, 3   ]); // This is a `RangeInclusive`"range_inclusive_new"/// Creates a new inclusive range. Equivalent to writing `start..=end`./// assert_eq!(3..=5, RangeInclusive::new(3, 5));/// Returns the lower bound of the range (inclusive)./// When using an inclusive range for iteration, the values of `start()` and/// [`end()`] are unspecified after the iteration ended. To determine/// whether the inclusive range is empty, use the [`is_empty()`] method/// instead of comparing `start() > end()`./// Note: the value returned by this method is unspecified after the range/// has been iterated to exhaustion./// [`end()`]: RangeInclusive::end/// [`is_empty()`]: RangeInclusive::is_empty/// assert_eq!((3..=5).start(), &3);/// Returns the upper bound of the range (inclusive)./// When using an inclusive range for iteration, the values of [`start()`]/// and `end()` are unspecified after the iteration ended. To determine/// [`start()`]: RangeInclusive::start/// assert_eq!((3..=5).end(), &5);/// Destructures the `RangeInclusive` into (lower bound, upper (inclusive) bound)./// assert_eq!((3..=5).into_inner(), (3, 5));into_slice_range/// Converts to an exclusive `Range` for `SliceIndex` implementations./// The caller is responsible for dealing with `end == usize::MAX`./// assert!(!(3..=5).contains(&2));/// assert!( (3..=5).contains(&3));/// assert!( (3..=5).contains(&4));/// assert!( (3..=5).contains(&5));/// assert!(!(3..=5).contains(&6));/// assert!( (3..=3).contains(&3));/// assert!(!(3..=2).contains(&3));/// assert!( (0.0..=1.0).contains(&1.0));/// assert!(!(0.0..=1.0).contains(&f32::NAN));/// assert!(!(0.0..=f32::NAN).contains(&0.0));/// assert!(!(f32::NAN..=1.0).contains(&1.0));/// This method always returns `false` after iteration has finished:/// let mut r = 3..=5;/// assert!(r.contains(&3) && r.contains(&5));/// for _ in r.by_ref() {}/// // Precise field values are unspecified here/// assert!(!r.contains(&3) && !r.contains(&5));/// assert!(!(3..=5).is_empty());/// assert!(!(3..=3).is_empty());/// assert!( (3..=2).is_empty());/// assert!(!(3.0..=5.0).is_empty());/// assert!( (3.0..=f32::NAN).is_empty());/// assert!( (f32::NAN..=5.0).is_empty());/// This method returns `true` after iteration has finished:"RangeToInclusive"/// The upper bound of the range (inclusive)/// A range only bounded inclusively above (`..=end`)./// The `RangeToInclusive` `..=end` contains all values with `x <= end`./// The `..=end` syntax is a `RangeToInclusive`:/// assert_eq!((..=5), std::ops::RangeToInclusive{ end: 5 });/// It does not have an [`IntoIterator`] implementation, so you can't use it in a/// `for` loop directly. This won't compile:/// // error[E0277]: the trait bound `std::ops::RangeToInclusive<{integer}>:/// for i in ..=5 {/// When used as a [slicing index], `RangeToInclusive` produces a slice of all/// array elements up to and including the index indicated by `end`./// assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]); // This is a `RangeToInclusive`/// assert!( (..=5).contains(&-1_000_000_000));/// assert!( (..=5).contains(&5));/// assert!(!(..=5).contains(&6));/// assert!( (..=1.0).contains(&1.0));/// assert!(!(..=1.0).contains(&f32::NAN));/// assert!(!(..=f32::NAN).contains(&0.5));/// An inclusive bound./// An exclusive bound./// An infinite endpoint. Indicates that there is no bound in this direction./// An endpoint of a range of keys./// `Bound`s are range endpoints:/// use std::ops::Bound::*;/// use std::ops::RangeBounds;/// assert_eq!((..100).start_bound(), Unbounded);/// assert_eq!((1..12).start_bound(), Included(&1));/// assert_eq!((1..12).end_bound(), Excluded(&12));/// Using a tuple of `Bound`s as an argument to [`BTreeMap::range`]./// Note that in most cases, it's better to use range syntax (`1..5`) instead./// use std::ops::Bound::{Excluded, Included, Unbounded};/// for (key, value) in map.range((Excluded(3), Included(8))) {/// assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());/// [`BTreeMap::range`]: ../../std/collections/btree_map/struct.BTreeMap.html#method.range/// Converts from `&Bound<T>` to `Bound<&T>`./// Converts from `&mut Bound<T>` to `Bound<&mut T>`./// Maps a `Bound<T>` to a `Bound<U>` by applying a function to the contained value (including/// both `Included` and `Excluded`), returning a `Bound` of the same kind./// let bound_string = Included("Hello, World!");/// assert_eq!(bound_string.map(|s| s.len()), Included(13));/// use Bound::*;/// let unbounded_string: Bound<String> = Unbounded;/// assert_eq!(unbounded_string.map(|s| s.len()), Unbounded);/// Map a `Bound<&T>` to a `Bound<T>` by copying the contents of the bound./// #![feature(bound_copied)]/// assert_eq!((1..12).start_bound().copied(), Included(1));/// Map a `Bound<&T>` to a `Bound<T>` by cloning the contents of the bound./// let a1 = String::from("a");/// let (a2, a3, a4) = (a1.clone(), a1.clone(), a1.clone());/// assert_eq!(Included(&a1), (a2..).start_bound());/// assert_eq!(Included(a3), (a4..).start_bound().cloned());/// Start index bound./// Returns the start value as a `Bound`./// assert_eq!((..10).start_bound(), Unbounded);/// assert_eq!((3..10).start_bound(), Included(&3));/// End index bound./// Returns the end value as a `Bound`./// assert_eq!((3..).end_bound(), Unbounded);/// assert_eq!((3..10).end_bound(), Excluded(&10));/// One-sided ranges (`RangeFrom`, etc) always return `false`./// #![feature(range_bounds_is_empty)]/// assert!(!(3..).is_empty());/// assert!(!(..2).is_empty());/// assert!(!RangeBounds::is_empty(&(3..5)));/// assert!( RangeBounds::is_empty(&(3..3)));/// assert!( RangeBounds::is_empty(&(3..2)));/// assert!(!RangeBounds::is_empty(&(3.0..5.0)));/// assert!( RangeBounds::is_empty(&(3.0..f32::NAN)));/// assert!( RangeBounds::is_empty(&(f32::NAN..5.0)));/// But never empty if either side is unbounded:/// assert!(!(..0).is_empty());/// assert!(!(i32::MAX..).is_empty());/// assert!(!RangeBounds::<u8>::is_empty(&(..)));/// `(Excluded(a), Excluded(b))` is only empty if `a >= b`:/// assert!(!(Excluded(1), Excluded(3)).is_empty());/// assert!(!(Excluded(1), Excluded(2)).is_empty());/// assert!( (Excluded(1), Excluded(1)).is_empty());/// assert!( (Excluded(2), Excluded(1)).is_empty());/// assert!( (Excluded(3), Excluded(1)).is_empty());"RangeBounds"/// `RangeBounds` is implemented by Rust's built-in range types, produced/// by range syntax like `..`, `a..`, `..b`, `..=c`, `d..e`, or `f..=g`.into_bounds/// Convert this range into the start and end bounds./// Returns `(start_bound, end_bound)`./// #![feature(range_into_bounds)]/// use std::ops::IntoBounds;/// assert_eq!((0..5).into_bounds(), (Included(0), Excluded(5)));/// assert_eq!((..=7).into_bounds(), (Unbounded, Included(7)));/// Compute the intersection of  `self` and `other`./// assert_eq!((3..).intersect(..5), (Included(3), Excluded(5)));/// assert_eq!((-12..387).intersect(0..256), (Included(0), Excluded(256)));/// assert_eq!((1..5).intersect(..), (Included(1), Excluded(5)));/// assert_eq!((1..=9).intersect(0..10), (Included(1), Included(9)));/// assert_eq!((7..=13).intersect(8..13), (Included(8), Excluded(13)));/// Combine with `is_empty` to determine if two ranges overlap./// use std::ops::{RangeBounds, IntoBounds};/// assert!(!(3..).intersect(..5).is_empty());/// assert!(!(-12..387).intersect(0..256).is_empty());/// assert!((1..5).intersect(6..).is_empty());/// Used to convert a range into start and end bounds, consuming the/// range by value./// `IntoBounds` is implemented by Rust’s built-in range types, produced// This impl intentionally does not have `T: ?Sized`;// see https://github.com/rust-lang/rust/pull/61584 for discussion of why./// If you need to use this implementation where `T` is unsized,/// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],/// i.e. replace `start..` with `(Bound::Included(start), Bound::Unbounded)`./// i.e. replace `..end` with `(Bound::Unbounded, Bound::Excluded(end))`./// i.e. replace `start..end` with `(Bound::Included(start), Bound::Excluded(end))`./// i.e. replace `start..=end` with `(Bound::Included(start), Bound::Included(end))`./// i.e. replace `..=end` with `(Bound::Unbounded, Bound::Included(end))`.StartInclusive/// The range is bounded inclusively from below and is unbounded above./// The range is bounded exclusively from above and is unbounded below.EndInclusive/// The range is bounded inclusively from above and is unbounded below./// An internal helper for `split_off` functions indicating/// which end a `OneSidedRange` is bounded on./// An internal-only helper function for `split_off` and/// `split_off_mut` that returns the bound of the one-sided range./// `OneSidedRange` is implemented for built-in range types that are unbounded/// on one side. For example, `a..`, `..b` and `..=c` implement `OneSidedRange`,/// but `..`, `d..e`, and `f..=g` do not./// Types that implement `OneSidedRange<T>` must return `Bound::Unbounded`/// from one of `RangeBounds::start_bound` or `RangeBounds::end_bound`.// RangeToInclusive<Idx> cannot impl From<RangeTo<Idx>>// because underflow would be possible with (..0).into()"reborrow"/// Allows value to be reborrowed as exclusive, creating a copy of the value/// that disables the source for reads and writes for the lifetime of the copy./// The type of this value when reborrowed as shared."coerce_shared"/// Allows reborrowable value to be reborrowed as shared, creating a copy/// that disables the source for writes for the lifetime of the copy./// The type of the value produced by `?` when *not* short-circuiting./// The type of the value passed to [`FromResidual::from_residual`]/// as part of `?` when short-circuiting./// This represents the possible values of the `Self` type which are *not*/// represented by the `Output` type./// The choice of this type is critical to interconversion./// Unlike the `Output` type, which will often be a raw generic type,/// this type is typically a newtype of some sort to "color" the type/// so that it's distinguishable from the residuals of other types./// This is why `Result<T, E>::Residual` is not `E`, but `Result<Infallible, E>`./// That way it's distinct from `ControlFlow<E>::Residual`, for example,/// and thus `?` on `ControlFlow` cannot be used in a method returning `Result`./// If you're making a generic type `Foo<T>` that implements `Try<Output = T>`,/// then typically you can use `Foo<std::convert::Infallible>` as its `Residual`/// type: that type will have a "hole" in the correct place, and will maintain the/// "foo-ness" of the residual so other types need to opt-in to interconversion."from_output"/// Constructs the type from its `Output` type./// This should be implemented consistently with the `branch` method/// such that applying the `?` operator will get back the original value:/// `Try::from_output(x).branch() --> ControlFlow::Continue(x)`./// #![feature(try_trait_v2)]/// use std::ops::Try;/// assert_eq!(<Result<_, String> as Try>::from_output(3), Ok(3));/// assert_eq!(<Option<_> as Try>::from_output(4), Some(4));///     <std::ops::ControlFlow<String, _> as Try>::from_output(5),///     std::ops::ControlFlow::Continue(5),/// # fn make_question_mark_work() -> Option<()> {/// assert_eq!(Option::from_output(4)?, 4);/// # None }/// # make_question_mark_work();/// // This is used, for example, on the accumulator in `try_fold`:/// let r = std::iter::empty().try_fold(4, |_, ()| -> Option<_> { unreachable!() });/// assert_eq!(r, Some(4));"branch"/// Used in `?` to decide whether the operator should produce a value/// (because this returned [`ControlFlow::Continue`])/// or propagate a value back to the caller/// (because this returned [`ControlFlow::Break`])./// use std::ops::{ControlFlow, Try};/// assert_eq!(Ok::<_, String>(3).branch(), ControlFlow::Continue(3));/// assert_eq!(Err::<String, _>(3).branch(), ControlFlow::Break(Err(3)));/// assert_eq!(Some(3).branch(), ControlFlow::Continue(3));/// assert_eq!(None::<String>.branch(), ControlFlow::Break(None));/// assert_eq!(ControlFlow::<String, _>::Continue(3).branch(), ControlFlow::Continue(3));///     ControlFlow::<_, String>::Break(3).branch(),///     ControlFlow::Break(ControlFlow::Break(3)),"Try"/// The `?` operator and `try {}` blocks./// `try_*` methods typically involve a type implementing this trait.  For/// example, the closures passed to [`Iterator::try_fold`] and/// [`Iterator::try_for_each`] must return such a type./// `Try` types are typically those containing two or more categories of values,/// some subset of which are so commonly handled via early returns that it's/// worth providing a terse (but still visible) syntax to make that easy./// This is most often seen for error handling with [`Result`] and [`Option`]./// The quintessential implementation of this trait is on [`ControlFlow`]./// # Using `Try` in Generic Code/// `Iterator::try_fold` was stabilized to call back in Rust 1.27, but/// this trait is much newer.  To illustrate the various associated types and/// methods, let's implement our own version./// As a reminder, an infallible version of a fold looks something like this:/// fn simple_fold<A, T>(///     iter: impl Iterator<Item = T>,///     mut accum: A,///     mut f: impl FnMut(A, T) -> A,/// ) -> A {///     for x in iter {///         accum = f(accum, x);///     accum/// So instead of `f` returning just an `A`, we'll need it to return some other/// type that produces an `A` in the "don't short circuit" path.  Conveniently,/// that's also the type we need to return from the function./// Let's add a new generic parameter `R` for that type, and bound it to the/// output type that we want:/// # #![feature(try_trait_v2)]/// # use std::ops::Try;/// fn simple_try_fold_1<A, T, R: Try<Output = A>>(///     mut f: impl FnMut(A, T) -> R,/// ) -> R {///     todo!()/// If we get through the entire iterator, we need to wrap up the accumulator/// into the return type using [`Try::from_output`]:/// # use std::ops::{ControlFlow, Try};/// fn simple_try_fold_2<A, T, R: Try<Output = A>>(///         let cf = f(accum, x).branch();///         match cf {///             ControlFlow::Continue(a) => accum = a,///             ControlFlow::Break(_) => todo!(),///     R::from_output(accum)/// We'll also need [`FromResidual::from_residual`] to turn the residual back/// into the original type.  But because it's a supertrait of `Try`, we don't/// need to mention it in the bounds.  All types which implement `Try` can be/// recreated from their corresponding residual, so we'll just call it:/// pub fn simple_try_fold_3<A, T, R: Try<Output = A>>(///             ControlFlow::Break(r) => return R::from_residual(r),/// But this "call `branch`, then `match` on it, and `return` if it was a/// `Break`" is exactly what happens inside the `?` operator.  So rather than/// do all this manually, we can just use `?` instead:/// fn simple_try_fold<A, T, R: Try<Output = A>>(///         accum = f(accum, x)?;"from_residual"/// Constructs the type from a compatible `Residual` type./// This should be implemented consistently with the `branch` method such/// that applying the `?` operator will get back an equivalent residual:/// `FromResidual::from_residual(r).branch() --> ControlFlow::Break(r)`./// (The residual is not mandated to be *identical* when interconversion is involved.)/// use std::ops::{ControlFlow, FromResidual};/// assert_eq!(Result::<String, i64>::from_residual(Err(3_u8)), Err(3));/// assert_eq!(Option::<String>::from_residual(None), None);///     ControlFlow::<_, String>::from_residual(ControlFlow::Break(5)),///     ControlFlow::Break(5),"FromResidual"/// Used to specify which residuals can be converted into which [`crate::ops::Try`] types./// Every `Try` type needs to be recreatable from its own associated/// `Residual` type, but can also have additional `FromResidual` implementations/// to support interconversion with other `Try` types."from_yeet"from_yeet// because `Result::from_residual` has it// not-exposed but still used via lang-item/// The "return" type of this meta-function.// FIXME: ought to be implied/// Allows retrieving the canonical type implementing [`Try`] that has this type/// as its residual and allows it to hold an `O` as its output./// If you think of the `Try` trait as splitting a type into its [`Try::Output`]/// and [`Try::Residual`] components, this allows putting them back together./// `Result<T, E>: Try<Output = T, Residual = Result<Infallible, E>>`,/// and in the other direction,/// `<Result<Infallible, E> as Residual<T>>::TryType = Result<T, E>`."into_try_type"residual_into_try_type/// Used in `try {}` blocks so the type produced in the `?` desugaring/// depends on the residual type `R` and the output type of the block `O`,/// but importantly not on the contextual type the way it would be if/// we called `<_ as FromResidual>::from_residual(r)` directly.// needs to be `pub` to avoid `private type` errors// FIXME: force would be nice, but fails -- see #148915/// An adapter for implementing non-try methods via the `Try` implementation./// Conceptually the same as `Result<T, !>`, but requiring less work in trait/// solving and inhabited-ness checking and such, by being an obvious newtype/// and not having `From` bounds lying around./// Not currently planned to be exposed publicly, so just `pub(crate)`.// FIXME(const-hack): replace with `|a| NeverShortCircuit(f(a))` when const closures added.wrap_mut_1/// Wraps a unary function to produce one that wraps the output into a `NeverShortCircuit`./// This is useful for implementing infallible functions in terms of the `try_` ones,/// without accidentally capturing extra generic parameters in a closure.wrap_mut_2NeverShortCircuitResidual/// Implement `FromResidual<Yeet<T>>` on your type to enable/// `do yeet expr` syntax in functions returning your type."coerce_unsized"/// Trait that indicates that this is a pointer or a wrapper for one,/// where unsizing can be performed on the pointee./// See the [DST coercion RFC][dst-coerce] and [the nomicon entry on coercion][nomicon-coerce]/// For builtin pointer types, pointers to `T` will coerce to pointers to `U` if `T: Unsize<U>`/// by converting from a thin pointer to a fat pointer./// For custom types, the coercion here works by coercing `Foo<T>` to `Foo<U>`/// provided an impl of `CoerceUnsized<Foo<U>> for Foo<T>` exists./// Such an impl can only be written if `Foo<T>` has only a single non-phantomdata/// field involving `T`. If the type of that field is `Bar<T>`, an implementation/// of `CoerceUnsized<Bar<U>> for Bar<T>` must exist. The coercion will work by/// coercing the `Bar<T>` field into `Bar<U>` and filling in the rest of the fields/// from `Foo<T>` to create a `Foo<U>`. This will effectively drill down to a pointer/// field and coerce that./// Generally, for smart pointers you will implement/// `CoerceUnsized<Ptr<U>> for Ptr<T> where T: Unsize<U>, U: ?Sized`, with an/// optional `?Sized` bound on `T` itself. For wrapper types that directly embed `T`/// like `Cell<T>` and `RefCell<T>`, you/// can directly implement `CoerceUnsized<Wrap<U>> for Wrap<T> where T: CoerceUnsized<U>`./// This will let coercions of types like `Cell<Box<T>>` work./// [`Unsize`][unsize] is used to mark types which can be coerced to DSTs if behind/// pointers. It is implemented automatically by the compiler./// [dst-coerce]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md/// [unsize]: crate::marker::Unsize// &mut T -> &mut U// &mut T -> &U// &mut T -> *mut U// &mut T -> *const U// &T -> &U// &T -> *const U// *mut T -> *mut U// *mut T -> *const U// *const T -> *const U"dispatch_from_dyn"/// `DispatchFromDyn` is used in the implementation of dyn-compatibility[^1] checks (specifically/// allowing arbitrary self types), to guarantee that a method's receiver type can be dispatched on./// Note: `DispatchFromDyn` was briefly named `CoerceSized` (and had a slightly different/// interpretation)./// Imagine we have a trait object `t` with type `&dyn Tr`, where `Tr` is some trait with a method/// `m` defined as `fn m(&self);`. When calling `t.m()`, the receiver `t` is a wide pointer, but an/// implementation of `m` will expect a narrow pointer as `&self` (a reference to the concrete/// type). The compiler must generate an implicit conversion from the trait object/wide pointer to/// the concrete reference/narrow pointer. Implementing `DispatchFromDyn` indicates that that/// conversion is allowed and thus that the type implementing `DispatchFromDyn` is safe to use as/// the self type in an dyn-compatible method. (in the above example, the compiler will require/// `DispatchFromDyn` is implemented for `&'a U`)./// `DispatchFromDyn` does not specify the conversion from wide pointer to narrow pointer; the/// conversion is hard-wired into the compiler. For the conversion to work, the following/// properties must hold (i.e., it is only safe to implement `DispatchFromDyn` for types which have/// these properties, these are also checked by the compiler):/// * EITHER `Self` and `T` are either both references or both raw pointers; in either case, with///   the same mutability./// * OR, all of the following hold///   - `Self` and `T` must have the same type constructor, and only vary in a single type parameter///     formal (the *coerced type*, e.g., `impl DispatchFromDyn<Rc<T>> for Rc<U>` is ok and the///     single type parameter (instantiated with `T` or `U`) is the coerced type,///     `impl DispatchFromDyn<Arc<T>> for Rc<U>` is not ok).///   - The definition for `Self` must be a struct.///   - The definition for `Self` must not be `#[repr(packed)]` or `#[repr(C)]`.///   - Other than one-aligned, zero-sized fields, the definition for `Self` must have exactly one///     field and that field's type must be the coerced type. Furthermore, `Self`'s field type must///     implement `DispatchFromDyn<F>` where `F` is the type of `T`'s field type./// An example implementation of the trait:/// # #![feature(dispatch_from_dyn, unsize)]/// # use std::{ops::DispatchFromDyn, marker::Unsize};/// # struct Rc<T: ?Sized>(std::rc::Rc<T>);/// impl<T: ?Sized, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T>///     T: Unsize<U>,/// {}/// [^1]: Formerly known as *object safety*.panic_display"Option""None""Some"/// Some value of type `T`./// The `Option` type. See [the module level documentation](self) for more.// PartialEq is manually implemented equivalently"if you intended to assert that this has a value, consider `.unwrap()` instead"/// Returns `true` if the option is a [`Some`] value./// assert_eq!(x.is_some(), true);/// assert_eq!(x.is_some(), false);is_some_and/// Returns `true` if the option is a [`Some`] and the value inside of it matches a predicate./// assert_eq!(x.is_some_and(|x| x > 1), true);/// let x: Option<u32> = Some(0);/// assert_eq!(x.is_some_and(|x| x > 1), false);/// let x: Option<String> = Some("ownership".to_string());/// assert_eq!(x.as_ref().is_some_and(|x| x.len() > 1), true);/// println!("still alive {:?}", x);"if you intended to assert that this doesn't have a value, consider \
                  wrapping this in an `assert!()` instead"/// Returns `true` if the option is a [`None`] value./// assert_eq!(x.is_none(), false);/// assert_eq!(x.is_none(), true);is_none_or/// Returns `true` if the option is a [`None`] or the value inside of it matches a predicate./// assert_eq!(x.is_none_or(|x| x > 1), true);/// assert_eq!(x.is_none_or(|x| x > 1), false);/// assert_eq!(x.as_ref().is_none_or(|x| x.len() > 1), true);/// Converts from `&Option<T>` to `Option<&T>`./// Calculates the length of an <code>Option<[String]></code> as an <code>Option<[usize]></code>/// without moving the [`String`]. The [`map`] method takes the `self` argument by value,/// consuming the original, so this technique uses `as_ref` to first take an `Option` to a/// reference to the value inside the original./// [`map`]: Option::map/// [String]: ../../std/string/struct.String.html "String"/// [`String`]: ../../std/string/struct.String.html "String"/// let text: Option<String> = Some("Hello, world!".to_string());/// // First, cast `Option<String>` to `Option<&String>` with `as_ref`,/// // then consume *that* with `map`, leaving `text` on the stack./// let text_length: Option<usize> = text.as_ref().map(|s| s.len());/// println!("still can print text: {text:?}");/// Converts from `&mut Option<T>` to `Option<&mut T>`./// let mut x = Some(2);/// match x.as_mut() {///     Some(v) => *v = 42,/// assert_eq!(x, Some(42));/// Converts from <code>[Pin]<[&]Option\<T>></code> to <code>Option<[Pin]<[&]T>></code>./// [&]: reference "shared reference"/// Converts from <code>[Pin]<[&mut] Option\<T>></code> to <code>Option<[Pin]<[&mut] T>></code>./// [&mut]: reference "mutable reference"/// Returns a slice of the contained value, if any. If this is `None`, an/// empty slice is returned. This can be useful to have a single type of/// iterator over an `Option` or slice./// Note: Should you have an `Option<&T>` and wish to get a slice of `T`,/// you can unpack it via `opt.map_or(&[], std::slice::from_ref)`.///     [Some(1234).as_slice(), None.as_slice()],///     [&[1234][..], &[][..]],/// The inverse of this function is (discounting/// borrowing) [`[_]::first`](slice::first):/// for i in [Some(1234_u16), None] {///     assert_eq!(i.as_ref(), i.as_slice().first());/// Returns a mutable slice of the contained value, if any. If this is/// `None`, an empty slice is returned. This can be useful to have a/// single type of iterator over an `Option` or slice./// Note: Should you have an `Option<&mut T>` instead of a/// `&mut Option<T>`, which this method takes, you can obtain a mutable/// slice via `opt.map_or(&mut [], std::slice::from_mut)`.///     [Some(1234).as_mut_slice(), None.as_mut_slice()],///     [&mut [1234][..], &mut [][..]],/// The result is a mutable slice of zero or one items that points into/// our original `Option`:/// let mut x = Some(1234);/// x.as_mut_slice()[0] += 1;/// assert_eq!(x, Some(1235));/// The inverse of this method (discounting borrowing)/// is [`[_]::first_mut`](slice::first_mut):/// assert_eq!(Some(123).as_mut_slice().first_mut(), Some(&mut 123))"option_expect"/// Returns the contained [`Some`] value, consuming the `self` value./// Panics if the value is a [`None`] with a custom panic message provided by/// let x = Some("value");/// assert_eq!(x.expect("fruits are healthy"), "value");/// x.expect("fruits are healthy"); // panics with `fruits are healthy`/// # Recommended Message Style/// We recommend that `expect` messages are used to describe the reason you/// _expect_ the `Option` should be `Some`./// # let slice: &[u8] = &[];/// let item = slice.get(0)///     .expect("slice should not be empty");/// **Hint**: If you're having trouble remembering how to phrase expect/// error messages remember to focus on the word "should" as in "env/// variable should be set by blah" or "the given binary should be available/// and executable by the current user"./// For more detail on expect message styles and the reasoning behind our/// recommendation please refer to the section on ["Common Message/// Styles"](../../std/error/index.html#common-message-styles) in the [`std::error`](../../std/error/index.html) module docs."option_unwrap"/// Because this function may panic, its use is generally discouraged./// Panics are meant for unrecoverable errors, and/// [may abort the entire program][panic-abort]./// Instead, prefer to use pattern matching and handle the [`None`]/// case explicitly, or call [`unwrap_or`], [`unwrap_or_else`], or/// [`unwrap_or_default`]. In functions returning `Option`, you can use/// [the `?` (try) operator][try-option]./// [panic-abort]: https://doc.rust-lang.org/book/ch09-01-unrecoverable-errors-with-panic.html/// [try-option]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#where-the--operator-can-be-used/// [`unwrap_or`]: Option::unwrap_or/// [`unwrap_or_else`]: Option::unwrap_or_else/// [`unwrap_or_default`]: Option::unwrap_or_default/// Panics if the self value equals [`None`]./// let x = Some("air");/// assert_eq!(x.unwrap(), "air");/// assert_eq!(x.unwrap(), "air"); // fails/// Returns the contained [`Some`] value or a provided default./// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing/// the result of a function call, it is recommended to use [`unwrap_or_else`],/// assert_eq!(Some("car").unwrap_or("bike"), "car");/// assert_eq!(None.unwrap_or("bike"), "bike");/// Returns the contained [`Some`] value or computes it from a closure./// assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);/// assert_eq!(None.unwrap_or_else(|| 2 * k), 20);/// Returns the contained [`Some`] value or a default./// Consumes the `self` argument then, if [`Some`], returns the contained/// value, otherwise if [`None`], returns the [default value] for that/// let y: Option<u32> = Some(12);/// assert_eq!(x.unwrap_or_default(), 0);/// assert_eq!(y.unwrap_or_default(), 12);/// [default value]: Default::default/// [`parse`]: str::parse/// Returns the contained [`Some`] value, consuming the `self` value,/// without checking that the value is not [`None`]./// Calling this method on [`None`] is *[undefined behavior]*./// assert_eq!(unsafe { x.unwrap_unchecked() }, "air");/// assert_eq!(unsafe { x.unwrap_unchecked() }, "air"); // Undefined behavior!/// Maps an `Option<T>` to `Option<U>` by applying a function to a contained value (if `Some`) or returns `None` (if `None`)./// Calculates the length of an <code>Option<[String]></code> as an/// <code>Option<[usize]></code>, consuming the original:/// let maybe_some_string = Some(String::from("Hello, World!"));/// // `Option::map` takes self *by value*, consuming `maybe_some_string`/// let maybe_some_len = maybe_some_string.map(|s| s.len());/// assert_eq!(maybe_some_len, Some(13));/// assert_eq!(x.map(|s| s.len()), None);/// Calls a function with a reference to the contained value if [`Some`]./// Returns the original option./// let list = vec![1, 2, 3];/// // prints "got: 2"/// let x = list///     .get(1)///     .inspect(|x| println!("got: {x}"))///     .expect("list should be long enough");/// // prints nothing/// list.get(5).inspect(|x| println!("got: {x}"));"if you don't need the returned value, use `if let` instead"map_or/// Returns the provided default result (if none),/// or applies a function to the contained value (if any)./// Arguments passed to `map_or` are eagerly evaluated; if you are passing/// the result of a function call, it is recommended to use [`map_or_else`],/// [`map_or_else`]: Option::map_or_else/// let x = Some("foo");/// assert_eq!(x.map_or(42, |v| v.len()), 3);/// assert_eq!(x.map_or(42, |v| v.len()), 42);map_or_else/// Computes a default function result (if none), or/// applies a different function to the contained value (if any)./// # Basic examples/// let k = 21;/// assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);/// assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);/// # Handling a Result-based fallback/// A somewhat common occurrence when dealing with optional values/// in combination with [`Result<T, E>`] is the case where one wants to invoke/// a fallible fallback if the option is not present.  This example/// parses a command line argument (if present), or the contents of a file to/// an integer.  However, unlike accessing the command line argument, reading/// the file is fallible, so it must be wrapped with `Ok`./// let v: u64 = std::env::args()///    .nth(1)///    .map_or_else(|| std::fs::read_to_string("/etc/someconfig.conf"), Ok)?///    .parse()?;map_or_default/// Maps an `Option<T>` to a `U` by applying function `f` to the contained/// value if the option is [`Some`], otherwise if [`None`], returns the/// [default value] for the type `U`./// #![feature(result_option_map_or_default)]/// let x: Option<&str> = Some("hi");/// let y: Option<&str> = None;/// assert_eq!(x.map_or_default(|x| x.len()), 2);/// assert_eq!(y.map_or_default(|y| y.len()), 0);/// Transforms the `Option<T>` into a [`Result<T, E>`], mapping [`Some(v)`] to/// [`Ok(v)`] and [`None`] to [`Err(err)`]./// Arguments passed to `ok_or` are eagerly evaluated; if you are passing the/// result of a function call, it is recommended to use [`ok_or_else`], which is/// lazily evaluated./// [`Ok(v)`]: Ok/// [`Err(err)`]: Err/// [`Some(v)`]: Some/// [`ok_or_else`]: Option::ok_or_else/// assert_eq!(x.ok_or(0), Ok("foo"));/// assert_eq!(x.ok_or(0), Err(0));/// [`Ok(v)`] and [`None`] to [`Err(err())`]./// [`Err(err())`]: Err/// assert_eq!(x.ok_or_else(|| 0), Ok("foo"));/// assert_eq!(x.ok_or_else(|| 0), Err(0));/// Converts from `Option<T>` (or `&Option<T>`) to `Option<&T::Target>`./// Leaves the original Option in-place, creating a new one with a reference/// to the original one, additionally coercing the contents via [`Deref`]./// let x: Option<String> = Some("hey".to_owned());/// assert_eq!(x.as_deref(), Some("hey"));/// let x: Option<String> = None;/// assert_eq!(x.as_deref(), None);/// Converts from `Option<T>` (or `&mut Option<T>`) to `Option<&mut T::Target>`./// Leaves the original `Option` in-place, creating a new one containing a mutable reference to/// the inner type's [`Deref::Target`] type./// let mut x: Option<String> = Some("hey".to_owned());/// assert_eq!(x.as_deref_mut().map(|x| {///     x.make_ascii_uppercase();/// }), Some("HEY".to_owned().as_mut_str()));/// Returns an iterator over the possibly contained value./// let x = Some(4);/// assert_eq!(x.iter().next(), Some(&4));/// assert_eq!(x.iter().next(), None);/// Returns a mutable iterator over the possibly contained value./// let mut x = Some(4);/// match x.iter_mut().next() {/// let mut x: Option<u32> = None;/// assert_eq!(x.iter_mut().next(), None);/// Returns [`None`] if the option is [`None`], otherwise returns `optb`./// Arguments passed to `and` are eagerly evaluated; if you are passing the/// result of a function call, it is recommended to use [`and_then`], which is/// [`and_then`]: Option::and_then/// let x = Some(2);/// assert_eq!(x.and(y), None);/// let y = Some("foo");/// assert_eq!(x.and(y), Some("foo"));/// Returns [`None`] if the option is [`None`], otherwise calls `f` with the/// wrapped value and returns the result./// Some languages call this operation flatmap./// fn sq_then_to_string(x: u32) -> Option<String> {///     x.checked_mul(x).map(|sq| sq.to_string())/// assert_eq!(Some(2).and_then(sq_then_to_string), Some(4.to_string()));/// assert_eq!(Some(1_000_000).and_then(sq_then_to_string), None); // overflowed!/// assert_eq!(None.and_then(sq_then_to_string), None);/// Often used to chain fallible operations that may return [`None`]./// let arr_2d = [["A0", "A1"], ["B0", "B1"]];/// let item_0_1 = arr_2d.get(0).and_then(|row| row.get(1));/// assert_eq!(item_0_1, Some(&"A1"));/// let item_2_0 = arr_2d.get(2).and_then(|row| row.get(0));/// assert_eq!(item_2_0, None);/// Returns [`None`] if the option is [`None`], otherwise calls `predicate`/// with the wrapped value and returns:/// - [`Some(t)`] if `predicate` returns `true` (where `t` is the wrapped///   value), and/// - [`None`] if `predicate` returns `false`./// This function works similar to [`Iterator::filter()`]. You can imagine/// the `Option<T>` being an iterator over one or zero elements. `filter()`/// lets you decide which elements to keep./// fn is_even(n: &i32) -> bool {///     n % 2 == 0/// assert_eq!(None.filter(is_even), None);/// assert_eq!(Some(3).filter(is_even), None);/// assert_eq!(Some(4).filter(is_even), Some(4));/// [`Some(t)`]: Some/// Returns the option if it contains a value, otherwise returns `optb`./// Arguments passed to `or` are eagerly evaluated; if you are passing the/// result of a function call, it is recommended to use [`or_else`], which is/// [`or_else`]: Option::or_else/// let y = None;/// assert_eq!(x.or(y), Some(2));/// let x = None;/// let y = Some(100);/// assert_eq!(x.or(y), Some(100));/// assert_eq!(x.or(y), None);//FIXME(const_hack): this `T: [const] Destruct` is unnecessary, but even precise live drops can't tell// no value of type `T` gets dropped here/// Returns the option if it contains a value, otherwise calls `f` and/// returns the result./// fn nobody() -> Option<&'static str> { None }/// fn vikings() -> Option<&'static str> { Some("vikings") }/// assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians"));/// assert_eq!(None.or_else(vikings), Some("vikings"));/// assert_eq!(None.or_else(nobody), None);/// Returns [`Some`] if exactly one of `self`, `optb` is [`Some`], otherwise returns [`None`]./// let y: Option<u32> = None;/// assert_eq!(x.xor(y), Some(2));/// let y = Some(2);/// assert_eq!(x.xor(y), None);"if you intended to set a value, consider assignment instead"/// Inserts `value` into the option, then returns a mutable reference to it./// If the option already contains a value, the old value is dropped./// See also [`Option::get_or_insert`], which doesn't update the value if/// the option already contains [`Some`]./// let mut opt = None;/// let val = opt.insert(1);/// assert_eq!(*val, 1);/// assert_eq!(opt.unwrap(), 1);/// let val = opt.insert(2);/// assert_eq!(*val, 2);/// *val = 3;/// assert_eq!(opt.unwrap(), 3);/// Inserts `value` into the option if it is [`None`], then/// returns a mutable reference to the contained value./// See also [`Option::insert`], which updates the value even if/// let mut x = None;///     let y: &mut u32 = x.get_or_insert(5);///     assert_eq!(y, &5);///     *y = 7;/// assert_eq!(x, Some(7));/// Inserts the default value into the option if it is [`None`], then///     let y: &mut u32 = x.get_or_insert_default();///     assert_eq!(y, &0);/// Inserts a value computed from `f` into the option if it is [`None`],/// then returns a mutable reference to the contained value.///     let y: &mut u32 = x.get_or_insert_with(|| 5);/// Takes the value out of the option, leaving a [`None`] in its place./// let y = x.take();/// assert_eq!(y, Some(2));/// assert_eq!(y, None);take_if/// Takes the value out of the option, but only if the predicate evaluates to/// `true` on a mutable reference to the value./// In other words, replaces `self` with `None` if the predicate returns `true`./// This method operates similar to [`Option::take`] but conditional./// let mut x = Some(42);/// let prev = x.take_if(|v| if *v == 42 {///     *v += 1;/// assert_eq!(x, Some(43));/// assert_eq!(prev, None);/// let prev = x.take_if(|v| *v == 43);/// assert_eq!(prev, Some(43));/// Replaces the actual value in the option by the value given in parameter,/// returning the old value if present,/// leaving a [`Some`] in its place without deinitializing either one./// let old = x.replace(5);/// assert_eq!(old, Some(2));/// let old = x.replace(3);/// assert_eq!(old, None);/// Zips `self` with another `Option`./// If `self` is `Some(s)` and `other` is `Some(o)`, this method returns `Some((s, o))`./// let x = Some(1);/// let y = Some("hi");/// let z = None::<u8>;/// assert_eq!(x.zip(y), Some((1, "hi")));/// assert_eq!(x.zip(z), None);zip_with/// Zips `self` and another `Option` with function `f`./// If `self` is `Some(s)` and `other` is `Some(o)`, this method returns `Some(f(s, o))`./// #![feature(option_zip)]///     x: f64,///     y: f64,/// impl Point {///     fn new(x: f64, y: f64) -> Self {///         Self { x, y }/// let x = Some(17.5);/// let y = Some(42.7);/// assert_eq!(x.zip_with(y, Point::new), Some(Point { x: 17.5, y: 42.7 }));/// assert_eq!(x.zip_with(None, Point::new), None);/// Reduces two options into one, using the provided function if both are `Some`./// Otherwise, if only one of `self` and `other` is `Some`, that one is returned./// If both `self` and `other` are `None`, `None` is returned./// #![feature(option_reduce)]/// let s12 = Some(12);/// let s17 = Some(17);/// let n = None;/// let f = |a, b| a + b;/// assert_eq!(s12.reduce(s17, f), Some(29));/// assert_eq!(s12.reduce(n, f), Some(12));/// assert_eq!(n.reduce(s17, f), Some(17));/// assert_eq!(n.reduce(n, f), None);/////////////////////////////////////////////////////////////////////////// Querying the contained values// Adapter for working with references// Getting to contained values// Transforming contained values// Iterator constructors// Boolean operations on the values, eager and lazy// Entry-like operations to insert a value and return a reference// Misc/// Unzips an option containing a tuple of two options./// If `self` is `Some((a, b))` this method returns `(Some(a), Some(b))`./// Otherwise, `(None, None)` is returned./// let x = Some((1, "hi"));/// let y = None::<(u8, u32)>;/// assert_eq!(x.unzip(), (Some(1), Some("hi")));/// assert_eq!(y.unzip(), (None, None));/// Maps an `Option<&T>` to an `Option<T>` by copying the contents of the/// let opt_x = Some(&x);/// assert_eq!(opt_x, Some(&12));/// let copied = opt_x.copied();/// assert_eq!(copied, Some(12));/// Maps an `Option<&T>` to an `Option<T>` by cloning the contents of the/// let cloned = opt_x.cloned();/// assert_eq!(cloned, Some(12));/// Maps an `Option<&mut T>` to an `Option<T>` by copying the contents of the/// let mut x = 12;/// let opt_x = Some(&mut x);/// assert_eq!(opt_x, Some(&mut 12));/// Maps an `Option<&mut T>` to an `Option<T>` by cloning the contents of the/// Transposes an `Option` of a [`Result`] into a [`Result`] of an `Option`./// <code>[Some]\([Ok]\(\_))</code> is mapped to <code>[Ok]\([Some]\(\_))</code>,/// <code>[Some]\([Err]\(\_))</code> is mapped to <code>[Err]\(\_)</code>,/// and [`None`] will be mapped to <code>[Ok]\([None])</code>./// struct SomeErr;/// let x: Option<Result<i32, SomeErr>> = Some(Ok(5));/// let y: Result<Option<i32>, SomeErr> = Ok(Some(5));/// assert_eq!(x.transpose(), y);unwrap_failed// This is a separate function to reduce the code size of .expect() itself.// FIXME(const_hack): the T: [const] Destruct should be inferred from the Self: [const] Destruct in clone_from./// Returns [`None`][Option::None]./// let opt: Option<u32> = Option::default();/// assert!(opt.is_none());/// Returns a consuming iterator over the possibly contained value./// let x = Some("string");/// let v: Vec<&str> = x.into_iter().collect();/// assert_eq!(v, ["string"]);/// Moves `val` into a new [`Some`]./// let o: Option<u8> = Option::from(67);/// assert_eq!(Some(67), o);/// Converts an <code>[Option]<[String]></code> into an <code>[Option]<[usize]></code>, preserving/// the original. The [`map`] method takes the `self` argument by value, consuming the original,/// so this technique uses `from` to first take an [`Option`] to a reference/// to the value inside the original./// let s: Option<String> = Some(String::from("Hello, Rustaceans!"));/// let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());/// println!("Can still print s: {s:?}");/// assert_eq!(o, Some(18));/// Converts from `&mut Option<T>` to `Option<&mut T>`/// let mut s = Some(String::from("Hello"));/// let o: Option<&mut String> = Option::from(&mut s);/// match o {///     Some(t) => *t = String::from("Hello, Rustaceans!"),/// assert_eq!(s, Some(String::from("Hello, Rustaceans!")));// Ideally, LLVM should be able to optimize our derive code to this.// Once https://github.com/llvm/llvm-project/issues/52622 is fixed, we can// go back to deriving `PartialEq`.// Manually implementing here somewhat improves codegen for// https://github.com/rust-lang/rust/issues/49892, although still// not optimal./// An iterator over a reference to the [`Some`] variant of an [`Option`]./// This `struct` is created by the [`Option::iter`] function./// An iterator over a mutable reference to the [`Some`] variant of an [`Option`]./// This `struct` is created by the [`Option::iter_mut`] function./// An iterator over the value in [`Some`] variant of an [`Option`]./// This `struct` is created by the [`Option::into_iter`] function./// Takes each element in the [`Iterator`]: if it is [`None`][Option::None],/// no further elements are taken, and the [`None`][Option::None] is/// returned. Should no [`None`][Option::None] occur, a container of type/// `V` containing the values of each [`Option`] is returned./// Here is an example which increments every integer in a vector./// We use the checked variant of `add` that returns `None` when the/// calculation would result in an overflow./// let items = vec![0_u16, 1, 2];/// let res: Option<Vec<u16>> = items///     .map(|x| x.checked_add(1))/// assert_eq!(res, Some(vec![1, 2, 3]));/// As you can see, this will return the expected, valid items./// Here is another example that tries to subtract one from another list/// of integers, this time checking for underflow:/// let items = vec![2_u16, 1, 0];///     .map(|x| x.checked_sub(1))/// assert_eq!(res, None);/// Since the last element is zero, it would underflow. Thus, the resulting/// value is `None`./// Here is a variation on the previous example, showing that no/// further elements are taken from `iter` after the first `None`./// let items = vec![3_u16, 2, 1, 10];/// let mut shared = 0;///     .map(|x| { shared += x; x.checked_sub(2) })/// assert_eq!(shared, 6);/// Since the third element caused an underflow, no further elements were taken,/// so the final value of `shared` is 6 (= `3 + 2 + 1`), not 16.do_not_recommend/// Converts from `Option<Option<T>>` to `Option<T>`./// let x: Option<Option<u32>> = Some(Some(6));/// assert_eq!(Some(6), x.flatten());/// let x: Option<Option<u32>> = Some(None);/// assert_eq!(None, x.flatten());/// let x: Option<Option<u32>> = None;/// let x: Option<Option<Option<u32>>> = Some(Some(Some(6)));/// assert_eq!(Some(Some(6)), x.flatten());/// assert_eq!(Some(6), x.flatten().flatten());/// Transposes a `[Option<T>; N]` into a `Option<[T; N]>`./// #![feature(option_array_transpose)]/// # use std::option::Option;/// let data = [Some(0); 1000];/// let data: Option<[u8; 1000]> = data.transpose();/// assert_eq!(data, Some([0; 1000]));/// let data = [Some(0), None];/// let data: Option<[u8; 2]> = data.transpose();/// assert_eq!(data, None);//! Optional values.//! Type [`Option`] represents an optional value: every [`Option`]//! is either [`Some`] and contains a value, or [`None`], and//! does not. [`Option`] types are very common in Rust code, as//! they have a number of uses://! * Initial values//! * Return values for functions that are not defined//!   over their entire input range (partial functions)//! * Return value for otherwise reporting simple errors, where [`None`] is//!   returned on error//! * Optional struct fields//! * Struct fields that can be loaned or "taken"//! * Optional function arguments//! * Nullable pointers//! * Swapping things out of difficult situations//! [`Option`]s are commonly paired with pattern matching to query the presence//! of a value and take action, always accounting for the [`None`] case.//! fn divide(numerator: f64, denominator: f64) -> Option<f64> {//!     if denominator == 0.0 {//!         Some(numerator / denominator)//! // The return value of the function is an option//! let result = divide(2.0, 3.0);//! // Pattern match to retrieve the value//!     // The division was valid//!     Some(x) => println!("Result: {x}"),//!     // The division was invalid//!     None    => println!("Cannot divide by 0"),// FIXME: Show how `Option` is used in practice, with lots of methods//! # Options and pointers ("nullable" pointers)//! Rust's pointer types must always point to a valid location; there are//! no "null" references. Instead, Rust has *optional* pointers, like//! the optional owned box, <code>[Option]<[Box\<T>]></code>.//! [Box\<T>]: ../../std/boxed/struct.Box.html//! The following example uses [`Option`] to create an optional box of//! [`i32`]. Notice that in order to use the inner [`i32`] value, the//! `check_optional` function first needs to use pattern matching to//! determine whether the box has a value (i.e., it is [`Some(...)`][`Some`]) or//! not ([`None`]).//! let optional = None;//! check_optional(optional);//! let optional = Some(Box::new(9000));//! fn check_optional(optional: Option<Box<i32>>) {//!     match optional {//!         Some(p) => println!("has value {p}"),//!         None => println!("has no value"),//! # The question mark operator, `?`//! Similar to the [`Result`] type, when writing code that calls many functions that return the//! [`Option`] type, handling `Some`/`None` can be tedious. The question mark//! operator, [`?`], hides some of the boilerplate of propagating values//! up the call stack.//! It replaces this://! fn add_last_numbers(stack: &mut Vec<i32>) -> Option<i32> {//!     let a = stack.pop();//!     let b = stack.pop();//!     match (a, b) {//!         (Some(x), Some(y)) => Some(x + y),//!         _ => None,//! With this://!     Some(stack.pop()? + stack.pop()?)//! *It's much nicer!*//! Ending the expression with [`?`] will result in the [`Some`]'s unwrapped value, unless the//! result is [`None`], in which case [`None`] is returned early from the enclosing function.//! [`?`] can be used in functions that return [`Option`] because of the//! early return of [`None`] that it provides.//! [`?`]: crate::ops::Try//! [`Some`]: Some//! [`None`]: None//! # Representation//! Rust guarantees to optimize the following types `T` such that [`Option<T>`]//! has the same size, alignment, and [function call ABI] as `T`. It is//! therefore sound, when `T` is one of these types, to transmute a value `t` of//! type `T` to type `Option<T>` (producing the value `Some(t)`) and to//! transmute a value `Some(t)` of type `Option<T>` to type `T` (producing the//! value `t`).//! In some of these cases, Rust further guarantees the following://! - `transmute::<_, Option<T>>([0u8; size_of::<T>()])` is sound and produces//!   `Option::<T>::None`//! - `transmute::<_, [u8; size_of::<T>()]>(Option::<T>::None)` is sound and produces//!   `[0u8; size_of::<T>()]`//! These cases are identified by the second column://! | `T`                                                                 | Transmuting between `[0u8; size_of::<T>()]` and `Option::<T>::None` sound? |//! |---------------------------------------------------------------------|----------------------------------------------------------------------------|//! | [`Box<U>`] (specifically, only `Box<U, Global>`)                    | when `U: Sized`                                                            |//! | `&U`                                                                | when `U: Sized`                                                            |//! | `&mut U`                                                            | when `U: Sized`                                                            |//! | `fn`, `extern "C" fn`[^extern_fn]                                   | always                                                                     |//! | [`num::NonZero*`]                                                   | always                                                                     |//! | [`ptr::NonNull<U>`]                                                 | when `U: Sized`                                                            |//! | `#[repr(transparent)]` struct around one of the types in this list. | when it holds for the inner type                                           |//! [^extern_fn]: this remains true for `unsafe` variants, any argument/return types, and any other ABI: `[unsafe] extern "abi" fn` (_e.g._, `extern "system" fn`)//! Under some conditions the above types `T` are also null pointer optimized when wrapped in a [`Result`][result_repr].//! [`Box<U>`]: ../../std/boxed/struct.Box.html//! [`num::NonZero*`]: crate::num//! [`ptr::NonNull<U>`]: crate::ptr::NonNull//! [function call ABI]: ../primitive.fn.html#abi-compatibility//! [result_repr]: crate::result#representation//! This is called the "null pointer optimization" or NPO.//! It is further guaranteed that, for the cases above, one can//! [`mem::transmute`] from all valid values of `T` to `Option<T>` and//! from `Some::<T>(_)` to `T` (but transmuting `None::<T>` to `T`//! is undefined behavior).//! # Method overview//! In addition to working with pattern matching, [`Option`] provides a wide//! variety of different methods.//! ## Querying the variant//! The [`is_some`] and [`is_none`] methods return [`true`] if the [`Option`]//! is [`Some`] or [`None`], respectively.//! The [`is_some_and`] and [`is_none_or`] methods apply the provided function//! to the contents of the [`Option`] to produce a boolean value.//! If this is [`None`] then a default result is returned instead without executing the function.//! [`is_none`]: Option::is_none//! [`is_some`]: Option::is_some//! [`is_some_and`]: Option::is_some_and//! [`is_none_or`]: Option::is_none_or//! ## Adapters for working with references//! * [`as_ref`] converts from <code>[&][][Option]\<T></code> to <code>[Option]<[&]T></code>//! * [`as_mut`] converts from <code>[&mut] [Option]\<T></code> to <code>[Option]<[&mut] T></code>//! * [`as_deref`] converts from <code>[&][][Option]\<T></code> to//!   <code>[Option]<[&]T::[Target]></code>//! * [`as_deref_mut`] converts from <code>[&mut] [Option]\<T></code> to//!   <code>[Option]<[&mut] T::[Target]></code>//! * [`as_pin_ref`] converts from <code>[Pin]<[&][][Option]\<T>></code> to//!   <code>[Option]<[Pin]<[&]T>></code>//! * [`as_pin_mut`] converts from <code>[Pin]<[&mut] [Option]\<T>></code> to//!   <code>[Option]<[Pin]<[&mut] T>></code>//! * [`as_slice`] returns a one-element slice of the contained value, if any.//!   If this is [`None`], an empty slice is returned.//! * [`as_mut_slice`] returns a mutable one-element slice of the contained value, if any.//! [&]: reference "shared reference"//! [&mut]: reference "mutable reference"//! [Target]: Deref::Target "ops::Deref::Target"//! [`as_deref`]: Option::as_deref//! [`as_deref_mut`]: Option::as_deref_mut//! [`as_mut`]: Option::as_mut//! [`as_pin_mut`]: Option::as_pin_mut//! [`as_pin_ref`]: Option::as_pin_ref//! [`as_ref`]: Option::as_ref//! [`as_slice`]: Option::as_slice//! [`as_mut_slice`]: Option::as_mut_slice//! ## Extracting the contained value//! These methods extract the contained value in an [`Option<T>`] when it//! is the [`Some`] variant. If the [`Option`] is [`None`]://! * [`expect`] panics with a provided custom message//! * [`unwrap`] panics with a generic message//! * [`unwrap_or`] returns the provided default value//! * [`unwrap_or_default`] returns the default value of the type `T`//!   (which must implement the [`Default`] trait)//! * [`unwrap_or_else`] returns the result of evaluating the provided//!   function//! * [`unwrap_unchecked`] produces *[undefined behavior]*//! [`expect`]: Option::expect//! [`unwrap`]: Option::unwrap//! [`unwrap_or`]: Option::unwrap_or//! [`unwrap_or_default`]: Option::unwrap_or_default//! [`unwrap_or_else`]: Option::unwrap_or_else//! [`unwrap_unchecked`]: Option::unwrap_unchecked//! [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html//! ## Transforming contained values//! These methods transform [`Option`] to [`Result`]://! * [`ok_or`] transforms [`Some(v)`] to [`Ok(v)`], and [`None`] to//!   [`Err(err)`] using the provided default `err` value//! * [`ok_or_else`] transforms [`Some(v)`] to [`Ok(v)`], and [`None`] to//!   a value of [`Err`] using the provided function//! * [`transpose`] transposes an [`Option`] of a [`Result`] into a//!   [`Result`] of an [`Option`]//! [`Err(err)`]: Err//! [`Ok(v)`]: Ok//! [`Some(v)`]: Some//! [`ok_or`]: Option::ok_or//! [`ok_or_else`]: Option::ok_or_else//! [`transpose`]: Option::transpose//! These methods transform the [`Some`] variant://! * [`filter`] calls the provided predicate function on the contained//!   value `t` if the [`Option`] is [`Some(t)`], and returns [`Some(t)`]//!   if the function returns `true`; otherwise, returns [`None`]//! * [`flatten`] removes one level of nesting from an [`Option<Option<T>>`]//! * [`inspect`] method takes ownership of the [`Option`] and applies//!   the provided function to the contained value by reference if [`Some`]//! * [`map`] transforms [`Option<T>`] to [`Option<U>`] by applying the//!   provided function to the contained value of [`Some`] and leaving//!   [`None`] values unchanged//! [`Some(t)`]: Some//! [`filter`]: Option::filter//! [`flatten`]: Option::flatten//! [`inspect`]: Option::inspect//! [`map`]: Option::map//! These methods transform [`Option<T>`] to a value of a possibly//! different type `U`://! * [`map_or`] applies the provided function to the contained value of//!   [`Some`], or returns the provided default value if the [`Option`] is//!   [`None`]//! * [`map_or_else`] applies the provided function to the contained value//!   of [`Some`], or returns the result of evaluating the provided//!   fallback function if the [`Option`] is [`None`]//! [`map_or`]: Option::map_or//! [`map_or_else`]: Option::map_or_else//! These methods combine the [`Some`] variants of two [`Option`] values://! * [`zip`] returns [`Some((s, o))`] if `self` is [`Some(s)`] and the//!   provided [`Option`] value is [`Some(o)`]; otherwise, returns [`None`]//! * [`zip_with`] calls the provided function `f` and returns//!   [`Some(f(s, o))`] if `self` is [`Some(s)`] and the provided//!   [`Option`] value is [`Some(o)`]; otherwise, returns [`None`]//! [`Some(f(s, o))`]: Some//! [`Some(o)`]: Some//! [`Some(s)`]: Some//! [`Some((s, o))`]: Some//! [`zip`]: Option::zip//! [`zip_with`]: Option::zip_with//! ## Boolean operators//! These methods treat the [`Option`] as a boolean value, where [`Some`]//! acts like [`true`] and [`None`] acts like [`false`]. There are two//! categories of these methods: ones that take an [`Option`] as input, and//! ones that take a function as input (to be lazily evaluated).//! The [`and`], [`or`], and [`xor`] methods take another [`Option`] as//! input, and produce an [`Option`] as output. Only the [`and`] method can//! produce an [`Option<U>`] value having a different inner type `U` than//! [`Option<T>`].//! | method  | self      | input     | output    |//! |---------|-----------|-----------|-----------|//! | [`and`] | `None`    | (ignored) | `None`    |//! | [`and`] | `Some(x)` | `None`    | `None`    |//! | [`and`] | `Some(x)` | `Some(y)` | `Some(y)` |//! | [`or`]  | `None`    | `None`    | `None`    |//! | [`or`]  | `None`    | `Some(y)` | `Some(y)` |//! | [`or`]  | `Some(x)` | (ignored) | `Some(x)` |//! | [`xor`] | `None`    | `None`    | `None`    |//! | [`xor`] | `None`    | `Some(y)` | `Some(y)` |//! | [`xor`] | `Some(x)` | `None`    | `Some(x)` |//! | [`xor`] | `Some(x)` | `Some(y)` | `None`    |//! [`and`]: Option::and//! [`or`]: Option::or//! [`xor`]: Option::xor//! The [`and_then`] and [`or_else`] methods take a function as input, and//! only evaluate the function when they need to produce a new value. Only//! the [`and_then`] method can produce an [`Option<U>`] value having a//! different inner type `U` than [`Option<T>`].//! | method       | self      | function input | function result | output    |//! |--------------|-----------|----------------|-----------------|-----------|//! | [`and_then`] | `None`    | (not provided) | (not evaluated) | `None`    |//! | [`and_then`] | `Some(x)` | `x`            | `None`          | `None`    |//! | [`and_then`] | `Some(x)` | `x`            | `Some(y)`       | `Some(y)` |//! | [`or_else`]  | `None`    | (not provided) | `None`          | `None`    |//! | [`or_else`]  | `None`    | (not provided) | `Some(y)`       | `Some(y)` |//! | [`or_else`]  | `Some(x)` | (not provided) | (not evaluated) | `Some(x)` |//! [`and_then`]: Option::and_then//! [`or_else`]: Option::or_else//! This is an example of using methods like [`and_then`] and [`or`] in a//! pipeline of method calls. Early stages of the pipeline pass failure//! values ([`None`]) through unchanged, and continue processing on//! success values ([`Some`]). Toward the end, [`or`] substitutes an error//! message if it receives [`None`].//! # use std::collections::BTreeMap;//! let mut bt = BTreeMap::new();//! bt.insert(20u8, "foo");//! bt.insert(42u8, "bar");//! let res = [0u8, 1, 11, 200, 22]//!     .into_iter()//!     .map(|x| {//!         // `checked_sub()` returns `None` on error//!         x.checked_sub(1)//!             // same with `checked_mul()`//!             .and_then(|x| x.checked_mul(2))//!             // `BTreeMap::get` returns `None` on error//!             .and_then(|x| bt.get(&x))//!             // Substitute an error message if we have `None` so far//!             .or(Some(&"error!"))//!             .copied()//!             // Won't panic because we unconditionally used `Some` above//!     .collect::<Vec<_>>();//! assert_eq!(res, ["error!", "error!", "foo", "error!", "bar"]);//! ## Comparison operators//! If `T` implements [`PartialOrd`] then [`Option<T>`] will derive its//! [`PartialOrd`] implementation.  With this order, [`None`] compares as//! less than any [`Some`], and two [`Some`] compare the same way as their//! contained values would in `T`.  If `T` also implements//! [`Ord`], then so does [`Option<T>`].//! assert!(None < Some(0));//! assert!(Some(0) < Some(1));//! ## Iterating over `Option`//! An [`Option`] can be iterated over. This can be helpful if you need an//! iterator that is conditionally empty. The iterator will either produce//! a single value (when the [`Option`] is [`Some`]), or produce no values//! (when the [`Option`] is [`None`]). For example, [`into_iter`] acts like//! [`once(v)`] if the [`Option`] is [`Some(v)`], and like [`empty()`] if//! the [`Option`] is [`None`].//! [`empty()`]: crate::iter::empty//! [`once(v)`]: crate::iter::once//! Iterators over [`Option<T>`] come in three types://! * [`into_iter`] consumes the [`Option`] and produces the contained//!   value//! * [`iter`] produces an immutable reference of type `&T` to the//!   contained value//! * [`iter_mut`] produces a mutable reference of type `&mut T` to the//! [`into_iter`]: Option::into_iter//! [`iter`]: Option::iter//! [`iter_mut`]: Option::iter_mut//! An iterator over [`Option`] can be useful when chaining iterators, for//! example, to conditionally insert items. (It's not always necessary to//! explicitly call an iterator constructor: many [`Iterator`] methods that//! accept other iterators will also accept iterable types that implement//! [`IntoIterator`], which includes [`Option`].)//! let yep = Some(42);//! let nope = None;//! // chain() already calls into_iter(), so we don't have to do so//! let nums: Vec<i32> = (0..4).chain(yep).chain(4..8).collect();//! assert_eq!(nums, [0, 1, 2, 3, 42, 4, 5, 6, 7]);//! let nums: Vec<i32> = (0..4).chain(nope).chain(4..8).collect();//! assert_eq!(nums, [0, 1, 2, 3, 4, 5, 6, 7]);//! One reason to chain iterators in this way is that a function returning//! `impl Iterator` must have all possible return values be of the same//! concrete type. Chaining an iterated [`Option`] can help with that.//! fn make_iter(do_insert: bool) -> impl Iterator<Item = i32> {//!     // Explicit returns to illustrate return types matching//!     match do_insert {//!         true => return (0..4).chain(Some(42)).chain(4..8),//!         false => return (0..4).chain(None).chain(4..8),//! println!("{:?}", make_iter(true).collect::<Vec<_>>());//! println!("{:?}", make_iter(false).collect::<Vec<_>>());//! If we try to do the same thing, but using [`once()`] and [`empty()`],//! we can't return `impl Iterator` anymore because the concrete types of//! the return values differ.//! [`once()`]: crate::iter::once//! ```compile_fail,E0308//! # use std::iter::{empty, once};//! // This won't compile because all possible returns from the function//! // must have the same concrete type.//!     // Explicit returns to illustrate return types not matching//!         true => return (0..4).chain(once(42)).chain(4..8),//!         false => return (0..4).chain(empty()).chain(4..8),//! ## Collecting into `Option`//! [`Option`] implements the [`FromIterator`][impl-FromIterator] trait,//! which allows an iterator over [`Option`] values to be collected into an//! [`Option`] of a collection of each contained value of the original//! [`Option`] values, or [`None`] if any of the elements was [`None`].//! [impl-FromIterator]: Option#impl-FromIterator%3COption%3CA%3E%3E-for-Option%3CV%3E//! let v = [Some(2), Some(4), None, Some(8)];//! let res: Option<Vec<_>> = v.into_iter().collect();//! assert_eq!(res, None);//! let v = [Some(2), Some(4), Some(8)];//! assert_eq!(res, Some(vec![2, 4, 8]));//! [`Option`] also implements the [`Product`][impl-Product] and//! [`Sum`][impl-Sum] traits, allowing an iterator over [`Option`] values//! to provide the [`product`][Iterator::product] and//! [`sum`][Iterator::sum] methods.//! [impl-Product]: Option#impl-Product%3COption%3CU%3E%3E-for-Option%3CT%3E//! [impl-Sum]: Option#impl-Sum%3COption%3CU%3E%3E-for-Option%3CT%3E//! let v = [None, Some(1), Some(2), Some(3)];//! let res: Option<i32> = v.into_iter().sum();//! let v = [Some(1), Some(2), Some(21)];//! let res: Option<i32> = v.into_iter().product();//! assert_eq!(res, Some(42));//! ## Modifying an [`Option`] in-place//! These methods return a mutable reference to the contained value of an//! [`Option<T>`]://! * [`insert`] inserts a value, dropping any old contents//! * [`get_or_insert`] gets the current value, inserting a provided//!   default value if it is [`None`]//! * [`get_or_insert_default`] gets the current value, inserting the//!   default value of type `T` (which must implement [`Default`]) if it is//! * [`get_or_insert_with`] gets the current value, inserting a default//!   computed by the provided function if it is [`None`]//! [`get_or_insert`]: Option::get_or_insert//! [`get_or_insert_default`]: Option::get_or_insert_default//! [`get_or_insert_with`]: Option::get_or_insert_with//! [`insert`]: Option::insert//! These methods transfer ownership of the contained value of an//! [`Option`]://! * [`take`] takes ownership of the contained value of an [`Option`], if//!   any, replacing the [`Option`] with [`None`]//! * [`replace`] takes ownership of the contained value of an [`Option`],//!   if any, replacing the [`Option`] with a [`Some`] containing the//!   provided value//! [`replace`]: Option::replace//! [`take`]: Option::take//! Basic pattern matching on [`Option`]://! let msg = Some("howdy");//! // Take a reference to the contained string//! if let Some(m) = &msg {//!     println!("{}", *m);//! // Remove the contained string, destroying the Option//! let unwrapped_msg = msg.unwrap_or("default message");//! Initialize a result to [`None`] before a loop://! enum Kingdom { Plant(u32, &'static str), Animal(u32, &'static str) }//! // A list of data to search through.//! let all_the_big_things = [//!     Kingdom::Plant(250, "redwood"),//!     Kingdom::Plant(230, "noble fir"),//!     Kingdom::Plant(229, "sugar pine"),//!     Kingdom::Animal(25, "blue whale"),//!     Kingdom::Animal(19, "fin whale"),//!     Kingdom::Animal(15, "north pacific right whale"),//! // We're going to search for the name of the biggest animal,//! // but to start with we've just got `None`.//! let mut name_of_biggest_animal = None;//! let mut size_of_biggest_animal = 0;//! for big_thing in &all_the_big_things {//!     match *big_thing {//!         Kingdom::Animal(size, name) if size > size_of_biggest_animal => {//!             // Now we've found the name of some big animal//!             size_of_biggest_animal = size;//!             name_of_biggest_animal = Some(name);//!         Kingdom::Animal(..) | Kingdom::Plant(..) => ()//! match name_of_biggest_animal {//!     Some(name) => println!("the biggest animal is {name}"),//!     None => println!("there are no animals :("),// Type implementation// Trait implementations// The Option Iterators// FromIterator//! Platform-specific extensions to `core` for Darwin / Apple platforms.//! This is available on the following operating systems://! - tvOS//! - watchOS//! - visionOS//! Note: This module is called "Darwin" as that's the name of the underlying//! core OS of the above operating systems, but it should not be confused with//! the `-darwin` suffix in the `x86_64-apple-darwin` and//! `aarch64-apple-darwin` target names, which are mostly named that way for//! legacy reasons.objc_class/// Equivalent to Objective-C’s `struct objc_class` type.objc_selector/// Equivalent to Objective-C’s `struct objc_selector` type./// Equivalent to Objective-C’s `Class` type.SEL/// Equivalent to Objective-C’s `SEL` type./// Gets a reference to an Objective-C class./// This macro will yield an expression of type [`Class`] for the given class name string literal./// #![feature(darwin_objc)]/// use core::os::darwin::objc;/// let string_class = objc::class!("NSString");/// Gets a reference to an Objective-C selector./// This macro will yield an expression of type [`SEL`] for the given method name string literal./// It is similar to Objective-C’s `@selector` directive./// let alloc_sel = objc::selector!("alloc");/// let init_sel = objc::selector!("initWithCString:encoding:");//! Defines types and macros for Objective-C interoperability.//! OS-specific functionality."panic_location"// A raw pointer is used rather than a reference because the pointer is valid for one more byte// than the length stored in this pointer; the additional byte is the NUL-terminator used by// `Location::file_as_c_str`._filename/// A struct containing information about the location of a panic./// This structure is created by [`PanicHookInfo::location()`] and [`PanicInfo::location()`]./// [`PanicInfo::location()`]: crate::panic::PanicInfo::location/// [`PanicHookInfo::location()`]: ../../std/panic/struct.PanicHookInfo.html#method.location/// panic::set_hook(Box::new(|panic_info| {///     if let Some(location) = panic_info.location() {///         println!("panic occurred in file '{}' at line {}", location.file(), location.line());///         println!("panic occurred but can't get location information...");/// panic!("Normal panic");/// # Comparisons/// Comparisons for equality and ordering are made in file, line, then column priority./// Files are compared as strings, not `Path`, which could be unexpected./// See [`Location::file`]'s documentation for more discussion.caller/// Returns the source location of the caller of this function. If that function's caller is/// annotated then its call location will be returned, and so on up the stack to the first call/// within a non-tracked function body./// ```standalone_crate/// use std::panic::Location;/// ///      |1        |11       |21       |31       |41/// ///    +-|---------|---------|---------|---------|--------/// /// 15 | #[track_caller]/// /// 16 | fn new_location() -> &'static Location<'static> {/// /// 17 |     Location::caller()/// ///    |     ------------------| the value of this expression depends on the caller,/// ///    |                       | since the function is marked #[track_caller]/// /// 18 | }/// #[track_caller]/// fn new_location() -> &'static Location<'static> {///     Location::caller()/// ///      |1  |5    |11       |21       |31       |41       |51/// ///    +-|---|-----|---------|---------|---------|---------|---/// /// 29 | fn constant_location() -> &'static Location<'static> {/// /// 30 |     new_location()/// ///    |     ^ any invocation of constant_location() points here,/// ///    |       no matter the location it is called from/// /// 31 | }/// fn constant_location() -> &'static Location<'static> {///     new_location()///     //      |1  |5    |11       |21       |31       |41       |51///     //    +-|---|-----|---------|---------|---------|---------|---///     // 29 | fn constant_location() -> &'static Location<'static> {///     // 30 |     new_location()///     //    |     ^ `let constant` points here///     // 31 | }///     let constant = constant_location();///     assert_eq!(constant.file(), file!());///     assert_eq!((constant.line(), constant.column()), (30, 5));///     let constant_2 = constant_location();///         (constant.file(), constant.line(), constant.column()),///         (constant_2.file(), constant_2.line(), constant_2.column())///     //      |1        |11  |16  |21       |31///     //    +-|---------|----|----|---------|------///     // 55 |     let here = new_location();///     //    |                ^ `let here` points here, as `new_location()` is the callsite///     // 56 |     assert_eq!(here.file(), file!());///     let here = new_location();///     assert_eq!(here.file(), file!());///     assert_eq!((here.line(), here.column()), (55, 16));///     //      |1        |11       |21       ||32      |41       |51///     //    +-|---------|---------|---------||--------|---------|------///     // 64 |     let yet_another_location = new_location();///     //    |                                ^ `let yet_another_location` points here///     // 65 |     assert_eq!(here.file(), yet_another_location.file());///     let yet_another_location = new_location();///     assert_eq!(here.file(), yet_another_location.file());///         (here.line(), here.column()),///         (yet_another_location.line(), yet_another_location.column())/// Returns the name of the source file from which the panic originated./// # `&str`, not `&Path`/// The returned name refers to a source path on the compiling system, but it isn't valid to/// represent this directly as a `&Path`. The compiled code may run on a different system with/// a different `Path` implementation than the system providing the contents and this library/// does not currently have a different "host path" type./// The most surprising behavior occurs when "the same" file is reachable via multiple paths in/// the module system (usually using the `#[path = "..."]` attribute or similar), which can/// cause what appears to be identical code to return differing values from this function./// # Cross-compilation/// This value is not suitable for passing to `Path::new` or similar constructors when the host/// platform and target platform differ.///         println!("panic occurred in file '{}'", location.file());file_as_c_str/// Returns the name of the source file as a nul-terminated `CStr`./// This is useful for interop with APIs that expect C/C++ `__FILE__` or/// `std::source_location::file_name`, both of which return a nul-terminated `const char*`./// Returns the line number from which the panic originated.///         println!("panic occurred at line {}", location.line());/// Returns the column from which the panic originated.///         println!("panic occurred at column {}", location.column());"panic_info"can_unwindforce_no_backtrace/// A struct providing information about a panic./// A `PanicInfo` structure is passed to the panic handler defined by `#[panic_handler]`./// For the type used by the panic hook mechanism in `std`, see [`std::panic::PanicHookInfo`]./// [`std::panic::PanicHookInfo`]: ../../std/panic/struct.PanicHookInfo.htmlPanicMessage/// A message that was given to the `panic!()` macro./// The [`Display`] implementation of this type will format the message with the arguments/// that were given to the `panic!()` macro./// See [`PanicInfo::message`]./// The message that was given to the `panic!` macro./// The type returned by this method implements `Display`, so it can/// be passed directly to [`write!()`] and similar macros./// [`write!()`]: core::write/// ```ignore (no_std)/// #[panic_handler]/// fn panic_handler(panic_info: &PanicInfo<'_>) -> ! {///     write!(DEBUG_OUTPUT, "panicked: {}", panic_info.message());///     loop {}/// Returns information about the location from which the panic originated,/// if available./// This method will currently always return [`Some`], but this may change/// in future versions.///         println!("panic occurred in file '{}' at line {}",///             location.file(),///             location.line(),/// Returns the payload associated with the panic./// On this type, `core::panic::PanicInfo`, this method never returns anything useful./// It only exists because of compatibility with [`std::panic::PanicHookInfo`],/// which used to be the same type./// See [`std::panic::PanicHookInfo::payload`]./// [`std::panic::PanicHookInfo::payload`]: ../../std/panic/struct.PanicHookInfo.html#method.payload/// Returns whether the panic handler is allowed to unwind the stack from/// the point where the panic occurred./// This is true for most kinds of panics with the exception of panics/// caused by trying to unwind out of a `Drop` implementation or a function/// whose ABI does not support unwinding./// It is safe for a panic handler to unwind even when this function returns/// false, however this will simply cause the panic handler to be called/// Gets the formatted message, if it has no arguments to be formatted at runtime./// For `panic!("just a literal")`, this function is guaranteed to/// See [`fmt::Arguments::as_str`] for details."unwind_safe_trait"/// A marker trait which represents "panic safe" types in Rust./// This trait is implemented by default for many types and behaves similarly in/// terms of inference of implementation to the [`Send`] and [`Sync`] traits. The/// purpose of this trait is to encode what types are safe to cross a [`catch_unwind`]/// boundary with no fear of unwind safety./// [`catch_unwind`]: ../../std/panic/fn.catch_unwind.html/// ## What is unwind safety?/// In Rust a function can "return" early if it either panics or calls a/// function which transitively panics. This sort of control flow is not always/// anticipated, and has the possibility of causing subtle bugs through a/// combination of two critical components:/// 1. A data structure is in a temporarily invalid state when the thread///    panics./// 2. This broken invariant is then later observed./// Typically in Rust, it is difficult to perform step (2) because catching a/// panic involves either spawning a thread (which in turn makes it difficult/// to later witness broken invariants) or using the `catch_unwind` function in this/// module. Additionally, even if an invariant is witnessed, it typically isn't a/// problem in Rust because there are no uninitialized values (like in C or C++)./// It is possible, however, for **logical** invariants to be broken in Rust,/// which can end up causing behavioral bugs. Another key aspect of unwind safety/// in Rust is that, in the absence of `unsafe` code, a panic cannot lead to/// memory unsafety./// That was a bit of a whirlwind tour of unwind safety, but for more information/// about unwind safety and how it applies to Rust, see an [associated RFC][rfc]./// [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/1236-stabilize-catch-panic.md/// ## What is `UnwindSafe`?/// Now that we've got an idea of what unwind safety is in Rust, it's also/// important to understand what this trait represents. As mentioned above, one/// way to witness broken invariants is through the `catch_unwind` function in this/// module as it allows catching a panic and then re-using the environment of/// the closure./// Simply put, a type `T` implements `UnwindSafe` if it cannot easily allow/// witnessing a broken invariant through the use of `catch_unwind` (catching a/// panic). This trait is an auto trait, so it is automatically implemented for/// many types, and it is also structurally composed (e.g., a struct is unwind/// safe if all of its components are unwind safe)./// Note, however, that this is not an unsafe trait, so there is not a succinct/// contract that this trait is providing. Instead it is intended as more of a/// "speed bump" to alert users of `catch_unwind` that broken invariants may be/// witnessed and may need to be accounted for./// ## Who implements `UnwindSafe`?/// Types such as `&mut T` and `&RefCell<T>` are examples which are **not**/// unwind safe. The general idea is that any mutable state which can be shared/// across `catch_unwind` is not unwind safe by default. This is because it is very/// easy to witness a broken invariant outside of `catch_unwind` as the data is/// simply accessed as usual./// Types like `&Mutex<T>`, however, are unwind safe because they implement/// poisoning by default. They still allow witnessing a broken invariant, but/// they already provide their own "speed bumps" to do so./// ## When should `UnwindSafe` be used?/// It is not intended that most types or functions need to worry about this trait./// It is only used as a bound on the `catch_unwind` function and as mentioned/// above, the lack of `unsafe` means it is mostly an advisory. The/// [`AssertUnwindSafe`] wrapper struct can be used to force this trait to be/// implemented for any closed over variables passed to `catch_unwind`."ref_unwind_safe_trait"/// A marker trait representing types where a shared reference is considered/// unwind safe./// This trait is namely not implemented by [`UnsafeCell`], the root of all/// interior mutability./// This is a "helper marker trait" used to provide impl blocks for the/// [`UnwindSafe`] trait, for more information see that documentation./// A simple wrapper around a type to assert that it is unwind safe./// When using [`catch_unwind`] it may be the case that some of the closed over/// variables are not unwind safe. For example if `&mut T` is captured the/// compiler will generate a warning indicating that it is not unwind safe. It/// might not be the case, however, that this is actually a problem due to the/// specific usage of [`catch_unwind`] if unwind safety is specifically taken into/// account. This wrapper struct is useful for a quick and lightweight/// annotation that a variable is indeed unwind safe./// One way to use `AssertUnwindSafe` is to assert that the entire closure/// itself is unwind safe, bypassing all checks for all variables:/// use std::panic::{self, AssertUnwindSafe};/// let mut variable = 4;/// // This code will not compile because the closure captures `&mut variable`/// // which is not considered unwind safe by default./// // panic::catch_unwind(|| {/// //     variable += 3;/// // });/// // This, however, will compile due to the `AssertUnwindSafe` wrapper/// let result = panic::catch_unwind(AssertUnwindSafe(|| {///     variable += 3;/// Wrapping the entire closure amounts to a blanket assertion that all captured/// variables are unwind safe. This has the downside that if new captures are/// added in the future, they will also be considered unwind safe. Therefore,/// you may prefer to just wrap individual captures, as shown below. This is/// more annotation, but it ensures that if a new capture is added which is not/// unwind safe, you will get a compilation error at that time, which will/// allow you to consider whether that new capture in fact represent a bug or/// let other_capture = 3;/// let result = {///     let mut wrapper = AssertUnwindSafe(&mut variable);///     panic::catch_unwind(move || {///         **wrapper += other_capture;// Pretty simple implementations for the `RefUnwindSafe` marker trait,// basically just saying that `UnsafeCell` is the// only thing which doesn't implement it (which then transitively applies to// everything else).// Implementations of the `UnwindSafe` trait:// * By default everything is unwind safe// * pointers T contains mutability of some form are not unwind safe// * Unique, an owning pointer, lifts an implementation// * Types like Mutex/RwLock which are explicitly poisoned are unwind safe// * Our custom AssertUnwindSafe wrapper is indeed unwind safeunwind_safe"core_panic_2015_macro"panic_2015"core_panic_2021_macro"panic_2021"unreachable_2015_macro"unreachable_2015unreachable_2021abort_unwind/// Invokes a closure, aborting if the closure unwinds./// When compiled with aborting panics, this function is effectively a no-op./// With unwinding panics, an unwind results in another call into the panic/// hook followed by a process abort./// Instead of using this function, code should attempt to support unwinding./// Implementing [`Drop`] allows you to restore invariants uniformly in both/// return and unwind paths./// If an unwind can lead to logical issues but not soundness issues, you/// should allow the unwind. Opting out of [`UnwindSafe`] indicates to your/// consumers that they need to consider correctness in the face of unwinds./// If an unwind would be unsound, then this function should be used in order/// to prevent unwinds. However, note that `extern "C" fn` will automatically/// convert unwinds to aborts, so using this function isn't necessary for FFI.take_box/// Take full ownership of the contents./// The return type is actually `Box<dyn Any + Send>`, but we cannot use `Box` in core./// After this method got called, only some dummy default value is left in `self`./// Calling this method twice, or calling `get` after calling this method, is an error./// The argument is borrowed because the panic runtime (`__rust_start_panic`) only/// gets a borrowed `dyn PanicPayload`./// Just borrow the contents./// Tries to borrow the contents as `&str`, if possible without doing any allocations.PanicPayload/// An internal trait used by std to pass data from std to `panic_unwind` and/// other panic runtimes. Not intended to be stabilized any time soon, do not/// Helper macro for panicking in a `const fn`./// ```rust,ignore (just an example)/// core::macros::const_panic!("boring message", "flavored message {a} {b:?}", a: u32 = foo.len(), b: Something = bar);/// where the first message will be printed in const-eval,/// and the second message will be printed at runtime.// All uses of this macro are FIXME(const-hack)./// A version of `assert` that prints a non-formatting message in const contexts./// See [`const_panic!`].//! Panic support in the standard library."panic_fmt"panic_fmt/// The entry point for panicking with a formatted message./// This is designed to reduce the amount of code required at the call/// site as much as possible (so that `panic!()` has as low an impact/// on (e.g.) the inlining of other functions as possible), by moving/// the actual formatting into this shared place.// If panic=immediate-abort, inline the abort call,// otherwise avoid inlining because of it is cold path.// needed for const-evaluated panics// hooked by const-eval// must follow stable const rules since it is exposed to stablepanic_nounwind_fmt/// Like `panic_fmt`, but for non-unwinding panics./// Has to be a separate function so that it can carry the `rustc_nounwind` attribute.// This attribute has the key side-effect that if the panic handler ignores `can_unwind`// and unwinds anyway, we will hit the "unwinding out of nounwind function" guard,// which causes a "panic in a function that cannot unwind"."panic"/// The underlying implementation of core's `panic!` macro when no formatting is used.// Never inline unless panic=immediate-abort to avoid code// bloat at the call sites as much as possible.// used by lints and miri for panicspanic_const// We generate functions for usage by compiler-generated assertions.// Placing these functions in libcore means that all Rust programs can generate a jump into this// code rather than expanding to panic("...") above, which adds extra bloat to call sites (for the// constant string argument's pointer and length).// This is especially important when this code is called often (e.g., with -Coverflow-checks) for// reducing binary size impact.r" This is a panic called with a message that's a result of a MIR-produced Assert."panic_const_add_overflowpanic_const_sub_overflowpanic_const_mul_overflowpanic_const_div_overflowpanic_const_rem_overflowpanic_const_neg_overflowpanic_const_shr_overflowpanic_const_shl_overflowpanic_const_div_by_zeropanic_const_rem_by_zeropanic_const_coroutine_resumedpanic_const_async_fn_resumedpanic_const_async_gen_fn_resumedpanic_const_gen_fn_nonepanic_const_coroutine_resumed_panicpanic_const_async_fn_resumed_panicpanic_const_async_gen_fn_resumed_panicpanic_const_gen_fn_none_panicpanic_const_coroutine_resumed_droppanic_const_async_fn_resumed_droppanic_const_async_gen_fn_resumed_droppanic_const_gen_fn_none_drop// Separated panic constants list for async drop feature// (May be joined when the corresponding lang items will be in the bootstrap)// Unfortunately this set of strings is replicated here and in a few places in the compiler in// slightly different forms. It's not clear if there's a good way to deduplicate without adding// special cases to the compiler (e.g., a const generic function wouldn't have a single definition// shared across crates, which is exactly what we want here)."panic_nounwind"panic_nounwind/// Like `panic`, but without unwinding and track_caller to reduce the impact on codesize on the caller./// If you want `#[track_caller]` for nicer errors, call `panic_nounwind_fmt` directly.// needed by codegen for non-unwinding panicspanic_nounwind_nobacktrace/// Like `panic_nounwind`, but also inhibits showing a backtrace."unreachable_display"unreachable_display// needed for `non-fmt-panics` lint"panic_str_2015"panic_str_2015/// This exists solely for the 2015 edition `panic!` macro to trigger/// a lint on `panic!(my_str_variable);`."panic_display""panic_bounds_check"panic_bounds_check// needed by codegen for panic on OOB array/slice access"panic_misaligned_pointer_dereference"panic_misaligned_pointer_dereference// needed by codegen for panic on misaligned pointer deref// `CheckAlignment` MIR pass requires this function to never unwind"panic_null_pointer_dereference"panic_null_pointer_dereference// needed by codegen for panic on null pointer deref// `CheckNull` MIR pass requires this function to never unwind"panic_invalid_enum_construction"panic_invalid_enum_construction// needed by codegen for panic on invalid enum construction.// `CheckEnums` MIR pass requires this function to never unwind"panic_cannot_unwind"panic_cannot_unwind/// Panics because we cannot unwind out of a function./// This is a separate function to avoid the codesize impact of each crate containing the string to/// pass to `panic_nounwind`./// This function is called directly by the codegen backend, and must not have/// any extra arguments (including those synthesized by track_caller).// needed by codegen for panic in nounwind function"panic_in_cleanup"panic_in_cleanup/// Panics because we are unwinding out of a destructor during cleanup."const_panic_fmt"const_panic_fmt/// This function is used instead of panic_fmt in const eval.// needed by const-eval machine to replace calls to `panic_fmt` lang itemAssertKindassert_failed/// Internal function for `assert_eq!` and `assert_ne!` macrosassert_matches_failed/// Internal function for `assert_match!`assert_failed_inner/// Non-generic version of the above functions, to avoid code bloat.//! Panic support for core//! In core, panicking is always done with a message, resulting in a `core::panic::PanicInfo`//! containing a `fmt::Arguments`. In std, however, panicking can be done with panic_any, which//! throws a `Box<dyn Any>` containing any type of value. Because of this,//! `std::panic::PanicHookInfo` is a different type, which contains a `&dyn Any` instead of a//! `fmt::Arguments`. std's panic handler will convert the `fmt::Arguments` to a `&dyn Any`//! containing either a `&'static str` or `String` containing the formatted message.//! The core library cannot define any panic handler, but it can invoke it.//! This means that the functions inside of core are allowed to panic, but to be//! useful an upstream crate must define panicking for core to use. The current//! interface for panicking is://! fn panic_impl(pi: &core::panic::PanicInfo<'_>) -> !//! # { loop {} }//! This module contains a few other panicking functions, but these are just the//! necessary lang items for the compiler. All panics are funneled through this//! one function. The actual symbol is declared through the `#[panic_handler]` attribute.// First we define the two main entry points that all panics go through.// In the end both are just convenience wrappers around `panic_impl`.// Next we define a bunch of higher-level wrappers that all bottom out in the two core functions// above./// Creates a pattern type./// ```ignore (cannot test this from within core yet)/// type Positive = std::pat::pattern_type!(i32 is 1..);"RangeMin"/// Trait version of the inherent `MIN` assoc const."RangeMax""RangeSub"/// A compile-time helper to subtract 1 for exclusive ranges.RangePattern/// A trait implemented for integer types and `char`./// Useful in the future for generic pattern types, but/// used right now to simplify ast lowering of pattern type ranges.impl_range_pat//! Helper module for exporting the `pattern_type` macro"unsafe_pinned"/// This type provides a way to entirely opt-out of typical aliasing rules;/// specifically, `&mut UnsafePinned<T>` is not guaranteed to be a unique pointer./// This also subsumes the effects of `UnsafeCell`, i.e., `&UnsafePinned<T>` may point to data/// that is being mutated./// However, even if you define your type like `pub struct Wrapper(UnsafePinned<...>)`, it is still/// very risky to have an `&mut Wrapper` that aliases anything else. Many functions that work/// generically on `&mut T` assume that the memory that stores `T` is uniquely owned (such as/// `mem::swap`). In other words, while having aliasing with `&mut Wrapper` is not immediate/// Undefined Behavior, it is still unsound to expose such a mutable reference to code you do not/// control! Techniques such as pinning via [`Pin`] are needed to ensure soundness./// Similar to [`UnsafeCell`](crate::cell::UnsafeCell), `UnsafePinned` will not usually show up in/// the public API of a library. It is an internal implementation detail of libraries that need to/// support aliasing mutable references./// This type blocks niches the same way `UnsafeCell` does.// Override the manual `!Sync` in `UnsafeCell`./// When this type is used, that almost certainly means safe APIs need to use pinning to avoid the/// aliases from becoming invalidated. Therefore let's mark this as `!Unpin`. You can always opt/// back in to `Unpin` with an `impl` block, provided your API is still sound while unpinned./// Constructs a new instance of `UnsafePinned` which will wrap the specified value./// All access to the inner value through `&UnsafePinned<T>` or `&mut UnsafePinned<T>` or/// `Pin<&mut UnsafePinned<T>>` requires `unsafe` code./// Unwraps the value, consuming this `UnsafePinned`.get_mut_pinned/// Get read-write access to the contents of a pinned `UnsafePinned`./// Get read-write access to the contents of an `UnsafePinned`./// You should usually be using `get_mut_pinned` instead to explicitly track the fact that this/// memory is "pinned" due to there being aliases./// Get mutable access to the contents of a shared `UnsafePinned`./// aliasing rules; see [`UnsafeCell`] for more discussion and caveats./// [`UnsafeCell`]: crate::cell::UnsafeCell#aliasing-rules/// #![feature(unsafe_pinned)]/// use std::pin::UnsafePinned;///     let mut x = UnsafePinned::new(0);///     let ptr = x.get();///     x.get_mut_unchecked().write(1);///     assert_eq!(ptr.read(), 1);/// Gets an immutable pointer to the wrapped value./// The difference from [`get`] is that this function accepts a raw pointer, which is useful to/// avoid the creation of temporary references./// [`get`]: UnsafePinned::getraw_get_mut/// The difference from [`get_mut_pinned`] and [`get_mut_unchecked`] is that this function/// accepts a raw pointer, which is useful to avoid the creation of temporary references./// [`get_mut_pinned`]: UnsafePinned::get_mut_pinned/// [`get_mut_unchecked`]: UnsafePinned::get_mut_unchecked/// Creates an `UnsafePinned`, with the `Default` value for T./// Creates a new `UnsafePinned<T>` containing the given value.// #[unstable(feature = "unsafe_pinned", issue = "125735")]// Allow types that wrap `UnsafePinned` to also implement `DispatchFromDyn`// Note that currently `UnsafePinned` itself cannot be a method receiver// `self: UnsafePinned<&Self>` won't work// `self: UnsafePinned<Self>` becomes possible// FIXME(unsafe_pinned) this logic is copied from UnsafeCell, is it still sound?// `Send` and `Sync` are inherited from `T`. This is similar to `SyncUnsafeCell`, since// we eventually concluded that `UnsafeCell` implicitly making things `!Sync` is sometimes// unergonomic. A type that needs to be `!Send`/`!Sync` should really have an explicit// opt-out itself, e.g. via an `PhantomData<*mut T>` or (one day) via `impl !Send`/`impl !Sync`.// FIXME(unsafe_pinned): impl PinCoerceUnsized for UnsafePinned<T>?"pin"/// A pointer which pins its pointee in place./// [`Pin`] is a wrapper around some kind of pointer `Ptr` which makes that pointer "pin" its/// pointee value in place, thus preventing the value referenced by that pointer from being moved/// or otherwise invalidated at that place in memory unless it implements [`Unpin`]./// *See the [`pin` module] documentation for a more thorough exploration of pinning.*/// ## Pinning values with [`Pin<Ptr>`]/// In order to pin a value, we wrap a *pointer to that value* (of some type `Ptr`) in a/// [`Pin<Ptr>`]. [`Pin<Ptr>`] can wrap any pointer type, forming a promise that the **pointee**/// will not be *moved* or [otherwise invalidated][subtle-details]. If the pointee value's type/// implements [`Unpin`], we are free to disregard these requirements entirely and can wrap any/// pointer to that value in [`Pin`] directly via [`Pin::new`]. If the pointee value's type does/// not implement [`Unpin`], then Rust will not let us use the [`Pin::new`] function directly and/// we'll need to construct a [`Pin`]-wrapped pointer in one of the more specialized manners/// discussed below./// We call such a [`Pin`]-wrapped pointer a **pinning pointer** (or pinning ref, or pinning/// [`Box`], etc.) because its existence is the thing that is pinning the underlying pointee in/// place: it is the metaphorical "pin" securing the data in place on the pinboard (in memory)./// It is important to stress that the thing in the [`Pin`] is not the value which we want to pin/// itself, but rather a pointer to that value! A [`Pin<Ptr>`] does not pin the `Ptr` but rather/// the pointer's ***pointee** value*./// The most common set of types which require pinning related guarantees for soundness are the/// compiler-generated state machines that implement [`Future`] for the return value of/// `async fn`s. These compiler-generated [`Future`]s may contain self-referential pointers, one/// of the most common use cases for [`Pin`]. More details on this point are provided in the/// [`pin` module] docs, but suffice it to say they require the guarantees provided by pinning to/// be implemented soundly./// This requirement for the implementation of `async fn`s means that the [`Future`] trait/// requires all calls to [`poll`] to use a <code>self: [Pin]\<&mut Self></code> parameter instead/// of the usual `&mut self`. Therefore, when manually polling a future, you will need to pin it/// You may notice that `async fn`-sourced [`Future`]s are only a small percentage of all/// [`Future`]s that exist, yet we had to modify the signature of [`poll`] for all [`Future`]s/// to accommodate them. This is unfortunate, but there is a way that the language attempts to/// alleviate the extra friction that this API choice incurs: the [`Unpin`] trait./// The vast majority of Rust types have no reason to ever care about being pinned. These/// types implement the [`Unpin`] trait, which entirely opts all values of that type out of/// pinning-related guarantees. For values of these types, pinning a value by pointing to it with a/// [`Pin<Ptr>`] will have no actual effect./// The reason this distinction exists is exactly to allow APIs like [`Future::poll`] to take a/// [`Pin<Ptr>`] as an argument for all types while only forcing [`Future`] types that actually/// care about pinning guarantees pay the ergonomics cost. For the majority of [`Future`] types/// that don't have a reason to care about being pinned and therefore implement [`Unpin`], the/// <code>[Pin]\<&mut Self></code> will act exactly like a regular `&mut Self`, allowing direct/// access to the underlying value. Only types that *don't* implement [`Unpin`] will be restricted./// ### Pinning a value of a type that implements [`Unpin`]/// If the type of the value you need to "pin" implements [`Unpin`], you can trivially wrap any/// pointer to that value in a [`Pin`] by calling [`Pin::new`]./// // Create a value of a type that implements `Unpin`/// let mut unpin_future = std::future::ready(5);/// // Pin it by creating a pinning mutable reference to it (ready to be `poll`ed!)/// let my_pinned_unpin_future: Pin<&mut _> = Pin::new(&mut unpin_future);/// ### Pinning a value inside a [`Box`]/// The simplest and most flexible way to pin a value that does not implement [`Unpin`] is to put/// that value inside a [`Box`] and then turn that [`Box`] into a "pinning [`Box`]" by wrapping it/// in a [`Pin`]. You can do both of these in a single step using [`Box::pin`]. Let's see an/// example of using this flow to pin a [`Future`] returned from calling an `async fn`, a common/// use case as described above./// async fn add_one(x: u32) -> u32 {/// // Call the async function to get a future back/// let fut = add_one(42);/// // Pin the future inside a pinning box/// let pinned_fut: Pin<Box<_>> = Box::pin(fut);/// If you have a value which is already boxed, for example a [`Box<dyn Future>`][Box], you can pin/// that value in-place at its current memory address using [`Box::into_pin`]./// fn boxed_add_one(x: u32) -> Box<dyn Future<Output = u32>> {///     Box::new(add_one(x))/// let boxed_fut = boxed_add_one(42);/// // Pin the future inside the existing box/// let pinned_fut: Pin<Box<_>> = Box::into_pin(boxed_fut);/// There are similar pinning methods offered on the other standard library smart pointer types/// as well, like [`Rc`] and [`Arc`]./// ### Pinning a value on the stack using [`pin!`]/// There are some situations where it is desirable or even required (for example, in a `#[no_std]`/// context where you don't have access to the standard library or allocation in general) to/// pin a value which does not implement [`Unpin`] to its location on the stack. Doing so is/// possible using the [`pin!`] macro. See its documentation for more./// ## Layout and ABI/// [`Pin<Ptr>`] is guaranteed to have the same memory layout and ABI[^noalias] as `Ptr`./// [^noalias]: There is a bit of nuance here that is still being decided about whether the/// aliasing semantics of `Pin<&mut T>` should be different than `&mut T`, but this is true as of/// today./// [`pin!`]: crate::pin::pin "pin!"/// [`poll`]: crate::future::Future::poll "Future::poll"/// [`Future::poll`]: crate::future::Future::poll "Future::poll"/// [`pin` module]: self "pin module"/// [`Rc`]: ../../std/rc/struct.Rc.html "Rc"/// [`Arc`]: ../../std/sync/struct.Arc.html "Arc"/// [Box]: ../../std/boxed/struct.Box.html "Box"/// [`Box`]: ../../std/boxed/struct.Box.html "Box"/// [`Box::pin`]: ../../std/boxed/struct.Box.html#method.pin "Box::pin"/// [`Box::into_pin`]: ../../std/boxed/struct.Box.html#method.into_pin "Box::into_pin"/// [subtle-details]: self#subtle-details-and-the-drop-guarantee "pin subtle details"// Note: the `Clone` derive below causes unsoundness as it's possible to implement// `Clone` for mutable references.// See <https://internals.rust-lang.org/t/unsoundness-in-pin/11311> for more details./// Constructs a new `Pin<Ptr>` around a pointer to some data of a type that/// implements [`Unpin`]./// Unlike `Pin::new_unchecked`, this method is safe because the pointer/// `Ptr` dereferences to an [`Unpin`] type, which cancels the pinning guarantees./// let mut val: u8 = 5;/// // Since `val` doesn't care about being moved, we can safely create a "facade" `Pin`/// // which will allow `val` to participate in `Pin`-bound apis  without checking that/// // pinning guarantees are actually upheld./// let mut pinned: Pin<&mut u8> = Pin::new(&mut val);/// Unwraps this `Pin<Ptr>`, returning the underlying pointer./// Doing this operation safely requires that the data pointed at by this pinning pointer/// implements [`Unpin`] so that we can ignore the pinning invariants when unwrapping it./// let pinned: Pin<&mut u8> = Pin::new(&mut val);/// // Unwrap the pin to get the underlying mutable reference to the value. We can do/// // this because `val` doesn't care about being moved, so the `Pin` was just/// // a "facade" anyway./// let r = Pin::into_inner(pinned);/// assert_eq!(*r, 5);"new_unchecked"/// Constructs a new `Pin<Ptr>` around a reference to some data of a type that/// may or may not implement [`Unpin`]./// If `pointer` dereferences to an [`Unpin`] type, [`Pin::new`] should be used/// This constructor is unsafe because we cannot guarantee that the data/// pointed to by `pointer` is pinned. At its core, pinning a value means making the/// guarantee that the value's data will not be moved nor have its storage invalidated until/// it gets dropped. For a more thorough explanation of pinning, see the [`pin` module docs]./// If the caller that is constructing this `Pin<Ptr>` does not ensure that the data `Ptr`/// points to is pinned, that is a violation of the API contract and may lead to undefined/// behavior in later (even safe) operations./// By using this method, you are also making a promise about the [`Deref`],/// [`DerefMut`], and [`Drop`] implementations of `Ptr`, if they exist. Most importantly, they/// must not move out of their `self` arguments: `Pin::as_mut` and `Pin::as_ref`/// will call `DerefMut::deref_mut` and `Deref::deref` *on the pointer type `Ptr`*/// and expect these methods to uphold the pinning invariants./// Moreover, by calling this method you promise that the reference `Ptr`/// dereferences to will not be moved out of again; in particular, it/// must not be possible to obtain a `&mut Ptr::Target` and then/// move out of that reference (using, for example [`mem::swap`])./// For example, calling `Pin::new_unchecked` on an `&'a mut T` is unsafe because/// while you are able to pin it for the given lifetime `'a`, you have no control/// over whether it is kept pinned once `'a` ends, and therefore cannot uphold the/// guarantee that a value, once pinned, remains pinned until it is dropped:/// fn move_pinned_ref<T>(mut a: T, mut b: T) {///         let p: Pin<&mut T> = Pin::new_unchecked(&mut a);///         // This should mean the pointee `a` can never move again.///     mem::swap(&mut a, &mut b); // Potential UB down the road ⚠️///     // The address of `a` changed to `b`'s stack slot, so `a` got moved even///     // though we have previously pinned it! We have violated the pinning API contract./// A value, once pinned, must remain pinned until it is dropped (unless its type implements/// `Unpin`). Because `Pin<&mut T>` does not own the value, dropping the `Pin` will not drop/// the value and will not end the pinning contract. So moving the value after dropping the/// `Pin<&mut T>` is still a violation of the API contract./// Similarly, calling `Pin::new_unchecked` on an `Rc<T>` is unsafe because there could be/// aliases to the same data that are not subject to the pinning restrictions:/// fn move_pinned_rc<T>(mut x: Rc<T>) {///     // This should mean the pointee can never move again.///     let pin = unsafe { Pin::new_unchecked(Rc::clone(&x)) };///         let p: Pin<&T> = pin.as_ref();///     drop(pin);///     let content = Rc::get_mut(&mut x).unwrap(); // Potential UB down the road ⚠️///     // Now, if `x` was the only reference, we have a mutable reference to///     // data that we pinned above, which we could use to move it as we have///     // seen in the previous example. We have violated the pinning API contract./// ## Pinning of closure captures/// Particular care is required when using `Pin::new_unchecked` in a closure:/// `Pin::new_unchecked(&mut var)` where `var` is a by-value (moved) closure capture/// implicitly makes the promise that the closure itself is pinned, and that *all* uses/// of this closure capture respect that pinning./// fn move_pinned_closure(mut x: impl Future, cx: &mut Context<'_>) {///     // Create a closure that moves `x`, and then internally uses it in a pinned way.///     let mut closure = move || unsafe {///         let _ignore = Pin::new_unchecked(&mut x).poll(cx);///     // Call the closure, so the future can assume it has been pinned.///     closure();///     // Move the closure somewhere else. This also moves `x`!///     let mut moved = closure;///     // Calling it again means we polled the future from two different locations,///     // violating the pinning API contract.///     moved(); // Potential UB ⚠️/// When passing a closure to another API, it might be moving the closure any time, so/// `Pin::new_unchecked` on closure captures may only be used if the API explicitly documents/// that the closure is pinned./// The better alternative is to avoid all that trouble and do the pinning in the outer function/// instead (here using the [`pin!`][crate::pin::pin] macro):/// use std::pin::pin;///     let mut x = pin!(x);///     // Create a closure that captures `x: Pin<&mut _>`, which is safe to move.///     let mut closure = move || {///         let _ignore = x.as_mut().poll(cx);///     // Move the closure somewhere else.///     // Calling it again here is fine (except that we might be polling a future that already///     // returned `Poll::Ready`, but that is a separate problem).///     moved();/// [`mem::swap`]: crate::mem::swap/// [`pin` module docs]: self/// Gets a shared reference to the pinned value this [`Pin`] points to./// This is a generic method to go from `&Pin<Pointer<T>>` to `Pin<&T>`./// It is safe because, as part of the contract of `Pin::new_unchecked`,/// the pointee cannot move after `Pin<Pointer<T>>` got created./// "Malicious" implementations of `Pointer::Deref` are likewise/// ruled out by the contract of `Pin::new_unchecked`./// Gets a mutable reference to the pinned value this `Pin<Ptr>` points to./// This is a generic method to go from `&mut Pin<Pointer<T>>` to `Pin<&mut T>`./// "Malicious" implementations of `Pointer::DerefMut` are likewise/// This method is useful when doing multiple calls to functions that consume the/// pinning pointer./// # struct Type {}/// impl Type {///         // do something///     fn call_method_twice(mut self: Pin<&mut Self>) {///         // `method` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.///         self.as_mut().method();/// Gets `Pin<&mut T>` to the underlying pinned value from this nested `Pin`-pointer./// This is a generic method to go from `Pin<&mut Pin<Pointer<T>>>` to `Pin<&mut T>`. It is/// safe because the existence of a `Pin<Pointer<T>>` ensures that the pointee, `T`, cannot/// move in the future, and this method does not enable the pointee to move. "Malicious"/// implementations of `Ptr::DerefMut` are likewise ruled out by the contract of/// `Pin::new_unchecked`./// Assigns a new value to the memory location pointed to by the `Pin<Ptr>`./// This overwrites pinned data, but that is okay: the original pinned value's destructor gets/// run before being overwritten and the new value is also a valid value of the same type, so/// no pinning invariant is violated. See [the `pin` module documentation][subtle-details]/// for more information on how this upholds the pinning invariants./// println!("{}", pinned); // 5/// pinned.set(10);/// println!("{}", pinned); // 10/// [subtle-details]: self#subtle-details-and-the-drop-guarantee// These methods being in a `Ptr: DerefMut` impl block concerns semver stability.// Currently, calling e.g. `.set()` on a `Pin<&T>` sees that `Ptr: DerefMut`// doesn't hold, and goes to check for a `.set()` method on `T`. But, if the// `where Ptr: DerefMut` bound is moved to the method, rustc sees the impl block// as a valid candidate, and doesn't go on to check other candidates when it// sees that the bound on the method./// Unwraps this `Pin<Ptr>`, returning the underlying `Ptr`./// This function is unsafe. You must guarantee that you will continue to/// treat the pointer `Ptr` as pinned after you call this function, so that/// the invariants on the `Pin` type can be upheld. If the code using the/// resulting `Ptr` does not continue to maintain the pinning invariants that/// is a violation of the API contract and may lead to undefined behavior in/// later (safe) operations./// Note that you must be able to guarantee that the data pointed to by `Ptr`/// will be treated as pinned all the way until its `drop` handler is complete!/// *For more information, see the [`pin` module docs][self]*/// If the underlying data is [`Unpin`], [`Pin::into_inner`] should be usedmap_unchecked/// Constructs a new pin by mapping the interior value./// For example, if you wanted to get a `Pin` of a field of something,/// you could use this to get access to that field in one line of code./// However, there are several gotchas with these "pinning projections";/// see the [`pin` module] documentation for further details on that topic./// This function is unsafe. You must guarantee that the data you return/// will not move so long as the argument value does not move (for example,/// because it is one of the fields of that value), and also that you do/// not move out of the argument you receive to the interior function./// [`pin` module]: self#projections-and-structural-pinning/// Gets a shared reference out of a pin./// This is safe because it is not possible to move out of a shared reference./// It may seem like there is an issue here with interior mutability: in fact,/// it *is* possible to move a `T` out of a `&RefCell<T>`. However, this is/// not a problem as long as there does not also exist a `Pin<&T>` pointing/// to the inner `T` inside the `RefCell`, and `RefCell<T>` does not let you get a/// `Pin<&T>` pointer to its contents. See the discussion on ["pinning projections"]/// Note: `Pin` also implements `Deref` to the target, which can be used/// to access the inner value. However, `Deref` only provides a reference/// that lives for as long as the borrow of the `Pin`, not the lifetime of/// the reference contained in the `Pin`. This method allows turning the `Pin` into a reference/// with the same lifetime as the reference it wraps./// ["pinning projections"]: self#projections-and-structural-pinning/// Converts this `Pin<&mut T>` into a `Pin<&T>` with the same lifetime./// Gets a mutable reference to the data inside of this `Pin`./// This requires that the data inside this `Pin` is `Unpin`./// Note: `Pin` also implements `DerefMut` to the data, which can be used/// to access the inner value. However, `DerefMut` only provides a reference/// the `Pin` itself. This method allows turning the `Pin` into a reference/// with the same lifetime as the original `Pin`./// This function is unsafe. You must guarantee that you will never move/// the data out of the mutable reference you receive when you call this/// function, so that the invariants on the `Pin` type can be upheld./// If the underlying data is `Unpin`, `Pin::get_mut` should be usedmap_unchecked_mutstatic_ref/// Gets a pinning reference from a `&'static` reference./// This is safe because `T` is borrowed immutably for the `'static` lifetime, which/// never ends.static_mut/// Gets a pinning mutable reference from a static mutable reference./// This is safe because `T` is borrowed for the `'static` lifetime, whichPinHelper/// Helper that prevents downstream crates from implementing `DerefMut` for `Pin`./// The `Pin` type implements the unsafe trait `PinCoerceUnsized`, which essentially requires/// that the type does not have a malicious `Deref` or `DerefMut` impl. However, without this/// helper module, downstream crates are able to write `impl DerefMut for Pin<LocalType>` as/// long as it does not overlap with the impl provided by stdlib. This is because `Pin` is/// `#[fundamental]`, so stdlib promises to never implement traits for `Pin` that it does not/// implement today./// However, this is problematic. Downstream crates could implement `DerefMut` for/// `Pin<&LocalType>`, and they could do so maliciously. To prevent this, the implementation for/// `Pin` delegates to this helper module. Since `helper::Pin` is not `#[fundamental]`, the/// orphan rules assume that stdlib might implement `helper::DerefMut` for `helper::Pin<&_>` in/// the future. Because of this, downstream crates can no longer provide an implementation of/// `DerefMut` for `Pin<&_>`, as it might overlap with a trait impl that, according to the/// orphan rules, the stdlib could introduce without a breaking change in a future release./// See <https://github.com/rust-lang/rust/issues/85099> for the issue this fixes."PinDerefMutHelper"PinDerefMutHelper// Note: this means that any impl of `CoerceUnsized` that allows coercing from// a type that impls `Deref<Target=impl !Unpin>` to a type that impls// `Deref<Target=Unpin>` is unsound. Any such impl would probably be unsound// for other reasons, though, so we just need to take care not to allow such// impls to land in std./// Trait that indicates that this is a pointer or a wrapper for one, where/// unsizing can be performed on the pointee when it is pinned./// If this type implements `Deref`, then the concrete type returned by `deref`/// and `deref_mut` must not change without a modification. The following/// operations are not considered modifications:/// * Moving the pointer./// * Performing unsizing coercions on the pointer./// * Performing dynamic dispatch with the pointer./// * Calling `deref` or `deref_mut` on the pointer./// The concrete type of a trait object is the type that the vtable corresponds/// to. The concrete type of a slice is an array of the same element type and/// the length specified in the metadata. The concrete type of a sized type/// is the type itself."pin_macro"/// Constructs a <code>[Pin]<[&mut] T></code>, by pinning a `value: T` locally./// Unlike [`Box::pin`], this does not create a new heap allocation. As explained/// below, the element might still end up on the heap however./// The local pinning performed by this macro is usually dubbed "stack"-pinning./// Outside of `async` contexts locals do indeed get stored on the stack. In/// `async` functions or blocks however, any locals crossing an `.await` point/// are part of the state captured by the `Future`, and will use the storage of/// those. That storage can either be on the heap or on the stack. Therefore,/// local pinning is a more accurate term./// If the type of the given value does not implement [`Unpin`], then this macro/// pins the value in memory in a way that prevents moves. On the other hand,/// if the type does implement [`Unpin`], <code>[Pin]<[&mut] T></code> behaves/// like <code>[&mut] T</code>, and operations such as/// [`mem::replace()`][crate::mem::replace] or [`mem::take()`](crate::mem::take)/// will allow moves of the value./// See [the `Unpin` section of the `pin` module][self#unpin] for details./// ### Basic usage/// # use core::marker::PhantomPinned as Foo;/// use core::pin::{pin, Pin};/// fn stuff(foo: Pin<&mut Foo>) {///     // …///     # let _ = foo;/// let pinned_foo = pin!(Foo { /* … */ });/// stuff(pinned_foo);/// // or, directly:/// stuff(pin!(Foo { /* … */ }));/// ### Manually polling a `Future` (without `Unpin` bounds)///     future::Future,///     pin::pin,///     task::{Context, Poll},///     thread,/// # use std::{sync::Arc, task::Wake, thread::Thread};/// # /// A waker that wakes up the current thread when called./// # struct ThreadWaker(Thread);/// # impl Wake for ThreadWaker {/// #     fn wake(self: Arc<Self>) {/// #         self.0.unpark();/// /// Runs a future to completion./// fn block_on<Fut: Future>(fut: Fut) -> Fut::Output {///     let waker_that_unparks_thread = // …///         # Arc::new(ThreadWaker(thread::current())).into();///     let mut cx = Context::from_waker(&waker_that_unparks_thread);///     let mut pinned_fut = pin!(fut);///         match pinned_fut.as_mut().poll(&mut cx) {/// # assert_eq!(42, block_on(async { 42 }));/// ### With `Coroutine`s/// use core::{///     ops::{Coroutine, CoroutineState},/// fn coroutine_fn() -> impl Coroutine<Yield = usize, Return = ()> /* not Unpin */ {///  // Allow coroutine to be self-referential (not `Unpin`)///  // vvvvvv        so that locals can cross yield points.///     #[coroutine] static || {///         let foo = String::from("foo");///         let foo_ref = &foo; // ------+///         yield 0;                  // | <- crosses yield point!///         println!("{foo_ref}"); // <--+///         yield foo.len();///     let mut coroutine = pin!(coroutine_fn());///     match coroutine.as_mut().resume(()) {///         CoroutineState::Yielded(0) => {},///         CoroutineState::Yielded(3) => {},///     match coroutine.resume(()) {///         CoroutineState::Yielded(_) => unreachable!(),///         CoroutineState::Complete(()) => {},/// ## Remarks/// Precisely because a value is pinned to local storage, the resulting <code>[Pin]<[&mut] T></code>/// reference ends up borrowing a local tied to that block: it can't escape it./// The following, for instance, fails to compile:/// # use core::{marker::PhantomPinned as Foo, mem::drop as stuff};/// let x: Pin<&mut Foo> = {///     let x: Pin<&mut Foo> = pin!(Foo { /* … */ });/// }; // <- Foo is dropped/// stuff(x); // Error: use of dropped value/// <details><summary>Error message</summary>/// error[E0716]: temporary value dropped while borrowed///   --> src/main.rs:9:28/// 8  | let x: Pin<&mut Foo> = {///    |     - borrow later stored here/// 9  |     let x: Pin<&mut Foo> = pin!(Foo { /* … */ });///    |                            ^^^^^^^^^^^^^^^^^^^^^ creates a temporary value which is freed while still in use/// 10 |     x/// 11 | }; // <- Foo is dropped///    | - temporary value is freed at the end of this statement///    = note: consider using a `let` binding to create a longer lived value/// This makes [`pin!`] **unsuitable to pin values when intending to _return_ them**. Instead, the/// value is expected to be passed around _unpinned_ until the point where it is to be consumed,/// where it is then useful and even sensible to pin the value locally using [`pin!`]./// If you really need to return a pinned value, consider using [`Box::pin`] instead./// On the other hand, local pinning using [`pin!`] is likely to be cheaper than/// pinning into a fresh heap allocation using [`Box::pin`]. Moreover, by virtue of not/// requiring an allocator, [`pin!`] is the main non-`unsafe` `#![no_std]`-compatible [`Pin`]// `super` gets removed by rustfmt//! Types that pin data to a location in memory.//! It is sometimes useful to be able to rely upon a certain value not being able to *move*,//! in the sense that its address in memory cannot change. This is useful especially when there//! are one or more [*pointers*][pointer] pointing at that value. The ability to rely on this//! guarantee that the value a [pointer] is pointing at (its **pointee**) will//! 1. Not be *moved* out of its memory location//! 2. More generally, remain *valid* at that same memory location//! is called "pinning." We would say that a value which satisfies these guarantees has been//! "pinned," in that it has been permanently (until the end of its lifespan) attached to its//! location in memory, as though pinned to a pinboard. Pinning a value is an incredibly useful//! building block for [`unsafe`] code to be able to reason about whether a raw pointer to the//! pinned value is still valid. [As we'll see later][drop-guarantee], once a value is pinned,//! it is necessarily valid at its memory location until the end of its lifespan. This concept//! of "pinning" is necessary to implement safe interfaces on top of things like self-referential//! types and intrusive data structures which cannot currently be modeled in fully safe Rust using//! only borrow-checked [references][reference].//! "Pinning" allows us to put a *value* which exists at some location in memory into a state where//! safe code cannot *move* that value to a different location in memory or otherwise invalidate it//! at its current location (unless it implements [`Unpin`], which we will//! [talk about below][self#unpin]). Anything that wants to interact with the pinned value in a way//! that has the potential to violate these guarantees must promise that it will not actually//! violate them, using the [`unsafe`] keyword to mark that such a promise is upheld by the user//! and not the compiler. In this way, we can allow other [`unsafe`] code to rely on any pointers//! that point to the pinned value to be valid to dereference while it is pinned.//! Note that as long as you don't use [`unsafe`], it's impossible to create or misuse a pinned//! value in a way that is unsound. See the documentation of [`Pin<Ptr>`] for more//! information on the practicalities of how to pin a value and how to use that pinned value from a//! user's perspective without using [`unsafe`].//! The rest of this documentation is intended to be the source of truth for users of [`Pin<Ptr>`]//! that are implementing the [`unsafe`] pieces of an interface that relies on pinning for validity;//! users of [`Pin<Ptr>`] in safe code do not need to read it in detail.//! There are several sections to this documentation://! * [What is "*moving*"?][what-is-moving]//! * [What is "pinning"?][what-is-pinning]//! * [Address sensitivity, AKA "when do we need pinning?"][address-sensitive-values]//! * [Examples of types with address-sensitive states][address-sensitive-examples]//!   * [Self-referential struct][self-ref]//!   * [Intrusive, doubly-linked list][linked-list]//! * [Subtle details and the `Drop` guarantee][subtle-details]//! # What is "*moving*"?//! [what-is-moving]: self#what-is-moving//! When we say a value is *moved*, we mean that the compiler copies, byte-for-byte, the//! value from one location to another. In a purely mechanical sense, this is identical to//! [`Copy`]ing a value from one place in memory to another. In Rust, "move" carries with it the//! semantics of ownership transfer from one variable to another, which is the key difference//! between a [`Copy`] and a move. For the purposes of this module's documentation, however, when//! we write *move* in italics, we mean *specifically* that the value has *moved* in the mechanical//! sense of being located at a new place in memory.//! All values in Rust are trivially *moveable*. This means that the address at which a value is//! located is not necessarily stable in between borrows. The compiler is allowed to *move* a value//! to a new address without running any code to notify that value that its address//! has changed. Although the compiler will not insert memory *moves* where no semantic move has//! occurred, there are many places where a value *may* be moved. For example, when doing//! assignment or passing a value into a function.//! struct AddrTracker(Option<usize>);//! impl AddrTracker {//!     // If we haven't checked the addr of self yet, store the current//!     // address. If we have, confirm that the current address is the same//!     // as it was last time, or else panic.//!     fn check_for_move(&mut self) {//!         let current_addr = self as *mut Self as usize;//!         match self.0 {//!             None => self.0 = Some(current_addr),//!             Some(prev_addr) => assert_eq!(prev_addr, current_addr),//! // Create a tracker and store the initial address//! let mut tracker = AddrTracker::default();//! tracker.check_for_move();//! // Here we shadow the variable. This carries a semantic move, and may therefore also//! // come with a mechanical memory *move*//! let mut tracker = tracker;//! // May panic!//! // tracker.check_for_move();//! In this sense, Rust does not guarantee that `check_for_move()` will never panic, because the//! compiler is permitted to *move* `tracker` in many situations.//! Common smart-pointer types such as [`Box<T>`] and [`&mut T`] also allow *moving* the underlying//! *value* they point at: you can move out of a [`Box<T>`], or you can use [`mem::replace`] to//! move a `T` out of a [`&mut T`]. Therefore, putting a value (such as `tracker` above) behind a//! pointer isn't enough on its own to ensure that its address does not change.//! # What is "pinning"?//! [what-is-pinning]: self#what-is-pinning//! We say that a value has been *pinned* when it has been put into a state where it is guaranteed//! to remain *located at the same place in memory* from the time it is pinned until its//! [`drop`] is called.//! ## Address-sensitive values, AKA "when we need pinning"//! [address-sensitive-values]: self#address-sensitive-values-aka-when-we-need-pinning//! Most values in Rust are entirely okay with being *moved* around at-will.//! Types for which it is *always* the case that *any* value of that type can be//! *moved* at-will should implement [`Unpin`], which we will discuss more [below][self#unpin].//! [`Pin`] is specifically targeted at allowing the implementation of *safe interfaces* around//! types which have some state during which they become "address-sensitive." A value in such an//! "address-sensitive" state is *not* okay with being *moved* around at-will. Such a value must//! stay *un-moved* and valid during the address-sensitive portion of its lifespan because some//! interface is relying on those invariants to be true in order for its implementation to be sound.//! As a motivating example of a type which may become address-sensitive, consider a type which//! contains a pointer to another piece of its own data, *i.e.* a "self-referential" type. In order//! for such a type to be implemented soundly, the pointer which points into `self`'s data must be//! proven valid whenever it is accessed. But if that value is *moved*, the pointer will still//! point to the old address where the value was located and not into the new location of `self`,//! thus becoming invalid. A key example of such self-referential types are the state machines//! generated by the compiler to implement [`Future`] for `async fn`s.//! Such types that have an *address-sensitive* state usually follow a lifecycle//! that looks something like so://! 1. A value is created which can be freely moved around.//!     * e.g. calling an async function which returns a state machine implementing [`Future`]//! 2. An operation causes the value to depend on its own address not changing//!     * e.g. calling [`poll`] for the first time on the produced [`Future`]//! 3. Further pieces of the safe interface of the type use internal [`unsafe`] operations which//!    assume that the address of the value is stable//!     * e.g. subsequent calls to [`poll`]//! 4. Before the value is invalidated (e.g. deallocated), it is *dropped*, giving it a chance to//!    notify anything with pointers to itself that those pointers will be invalidated//!     * e.g. [`drop`]ping the [`Future`] [^pin-drop-future]//! There are two possible ways to ensure the invariants required for 2. and 3. above (which//! apply to any address-sensitive type, not just self-referential types) do not get broken.//! 1. Have the value detect when it is moved and update all the pointers that point to itself.//! 2. Guarantee that the address of the value does not change (and that memory is not re-used//!    for anything else) during the time that the pointers to it are expected to be valid to//!    dereference.//! Since, as we discussed, Rust can move values without notifying them that they have moved, the//! first option is ruled out.//! In order to implement the second option, we must in some way enforce its key invariant,//! *i.e.* prevent the value from being *moved* or otherwise invalidated (you may notice this//! sounds an awful lot like the definition of *pinning* a value). There are a few ways one might//! be able to enforce this invariant in Rust://! 1. Offer a wholly `unsafe` API to interact with the object, thus requiring every caller to//!    uphold the invariant themselves//! 2. Store the value that must not be moved behind a carefully managed pointer internal to//!    the object//! 3. Leverage the type system to encode and enforce this invariant by presenting a restricted//!    API surface to interact with *any* object that requires these invariants//! The first option is quite obviously undesirable, as the [`unsafe`]ty of the interface will//! become viral throughout all code that interacts with the object.//! The second option is a viable solution to the problem for some use cases, in particular//! for self-referential types. Under this model, any type that has an address sensitive state//! would ultimately store its data in something like a [`Box<T>`], carefully manage internal//! access to that data to ensure no *moves* or other invalidation occurs, and finally//! provide a safe interface on top.//! There are a couple of linked disadvantages to using this model. The most significant is that//! each individual object must assume it is *on its own* to ensure//! that its data does not become *moved* or otherwise invalidated. Since there is no shared//! contract between values of different types, an object cannot assume that others interacting//! with it will properly respect the invariants around interacting with its data and must//! therefore protect it from everyone. Because of this, *composition* of address-sensitive types//! requires at least a level of pointer indirection each time a new object is added to the mix//! (and, practically, a heap allocation).//! Although there were other reasons as well, this issue of expensive composition is the key thing//! that drove Rust towards adopting a different model. It is particularly a problem//! when one considers, for example, the implications of composing together the [`Future`]s which//! will eventually make up an asynchronous task (including address-sensitive `async fn` state//! machines). It is plausible that there could be many layers of [`Future`]s composed together,//! including multiple layers of `async fn`s handling different parts of a task. It was deemed//! unacceptable to force indirection and allocation for each layer of composition in this case.//! [`Pin<Ptr>`] is an implementation of the third option. It allows us to solve the issues//! discussed with the second option by building a *shared contractual language* around the//! guarantees of "pinning" data.//! [^pin-drop-future]: Futures themselves do not ever need to notify other bits of code that//! they are being dropped, however data structures like stack-based intrusive linked lists do.//! ## Using [`Pin<Ptr>`] to pin values//! In order to pin a value, we wrap a *pointer to that value* (of some type `Ptr`) in a//! [`Pin<Ptr>`]. [`Pin<Ptr>`] can wrap any pointer type, forming a promise that the **pointee**//! will not be *moved* or [otherwise invalidated][subtle-details].//! We call such a [`Pin`]-wrapped pointer a **pinning pointer,** (or pinning reference, or pinning//! `Box`, etc.) because its existence is the thing that is conceptually pinning the underlying//! pointee in place: it is the metaphorical "pin" securing the data in place on the pinboard//! (in memory).//! Notice that the thing wrapped by [`Pin`] is not the value which we want to pin itself, but//! rather a pointer to that value! A [`Pin<Ptr>`] does not pin the `Ptr`; instead, it pins the//! pointer's ***pointee** value*.//! ### Pinning as a library contract//! Pinning does not require nor make use of any compiler "magic"[^noalias], only a specific//! contract between the [`unsafe`] parts of a library API and its users.//! It is important to stress this point as a user of the [`unsafe`] parts of the [`Pin`] API.//! Practically, this means that performing the mechanics of "pinning" a value by creating a//! [`Pin<Ptr>`] to it *does not* actually change the way the compiler behaves towards the//! inner value! It is possible to use incorrect [`unsafe`] code to create a [`Pin<Ptr>`] to a//! value which does not actually satisfy the invariants that a pinned value must satisfy, and in//! this way lead to undefined behavior even in (from that point) fully safe code. Similarly, using//! [`unsafe`], one may get access to a bare [`&mut T`] from a [`Pin<Ptr>`] and//! use that to invalidly *move* the pinned value out. It is the job of the user of the//! [`unsafe`] parts of the [`Pin`] API to ensure these invariants are not violated.//! This differs from e.g. [`UnsafeCell`] which changes the semantics of a program's compiled//! output. A [`Pin<Ptr>`] is a handle to a value which we have promised we will not move out of,//! but Rust still considers all values themselves to be fundamentally moveable through, *e.g.*//! assignment or [`mem::replace`].//! [^noalias]: There is a bit of nuance here that is still being decided about what the aliasing//! semantics of `Pin<&mut T>` should be, but this is true as of today.//! ### How [`Pin`] prevents misuse in safe code//! In order to accomplish the goal of pinning the pointee value, [`Pin<Ptr>`] restricts access to//! the wrapped `Ptr` type in safe code. Specifically, [`Pin`] disallows the ability to access//! the wrapped pointer in ways that would allow the user to *move* the underlying pointee value or//! otherwise re-use that memory for something else without using [`unsafe`]. For example, a//! [`Pin<&mut T>`] makes it impossible to obtain the wrapped <code>[&mut] T</code> safely because//! through that <code>[&mut] T</code> it would be possible to *move* the underlying value out of//! the pointer with [`mem::replace`], etc.//! As discussed above, this promise must be upheld manually by [`unsafe`] code which interacts//! with the [`Pin<Ptr>`] so that other [`unsafe`] code can rely on the pointee value being//! *un-moved* and valid. Interfaces that operate on values which are in an address-sensitive state//! accept an argument like <code>[Pin]<[&mut] T></code> or <code>[Pin]<[Box]\<T>></code> to//! indicate this contract to the caller.//! [As discussed below][drop-guarantee], opting in to using pinning guarantees in the interface//! of an address-sensitive type has consequences for the implementation of some safe traits on//! that type as well.//! ## Interaction between [`Deref`] and [`Pin<Ptr>`]//! Since [`Pin<Ptr>`] can wrap any pointer type, it uses [`Deref`] and [`DerefMut`] in//! order to identify the type of the pinned pointee data and provide (restricted) access to it.//! A [`Pin<Ptr>`] where [`Ptr: Deref`][Deref] is a "`Ptr`-style pinning pointer" to a pinned//! [`Ptr::Target`][Target] – so, a <code>[Pin]<[Box]\<T>></code> is an owned, pinning pointer to a//! pinned `T`, and a <code>[Pin]<[Rc]\<T>></code> is a reference-counted, pinning pointer to a//! pinned `T`.//! [`Pin<Ptr>`] also uses the [`<Ptr as Deref>::Target`][Target] type information to modify the//! interface it is allowed to provide for interacting with that data (for example, when a//! pinning pointer points at pinned data which implements [`Unpin`], as//! [discussed below][self#unpin]).//! [`Pin<Ptr>`] requires that implementations of [`Deref`] and [`DerefMut`] on `Ptr` return a//! pointer to the pinned data directly and do not *move* out of the `self` parameter during their//! implementation of [`DerefMut::deref_mut`]. It is unsound for [`unsafe`] code to wrap pointer//! types with such "malicious" implementations of [`Deref`]; see [`Pin<Ptr>::new_unchecked`] for//! ## Fixing `AddrTracker`//! The guarantee of a stable address is necessary to make our `AddrTracker` example work. When//! `check_for_move` sees a <code>[Pin]<&mut AddrTracker></code>, it can safely assume that value//! will exist at that same address until said value goes out of scope, and thus multiple calls//! to it *cannot* panic.//! use std::marker::PhantomPinned;//! use std::pin::pin;//! struct AddrTracker {//!     prev_addr: Option<usize>,//!     // remove auto-implemented `Unpin` bound to mark this type as having some//!     // address-sensitive state. This is essential for our expected pinning//!     // guarantees to work, and is discussed more below.//!     _pin: PhantomPinned,//!     fn check_for_move(self: Pin<&mut Self>) {//!         let current_addr = &*self as *const Self as usize;//!         match self.prev_addr {//!             None => {//!                 // SAFETY: we do not move out of self//!                 let self_data_mut = unsafe { self.get_unchecked_mut() };//!                 self_data_mut.prev_addr = Some(current_addr);//! // 1. Create the value, not yet in an address-sensitive state//! let tracker = AddrTracker::default();//! // 2. Pin the value by putting it behind a pinning pointer, thus putting//! // it into an address-sensitive state//! let mut ptr_to_pinned_tracker: Pin<&mut AddrTracker> = pin!(tracker);//! ptr_to_pinned_tracker.as_mut().check_for_move();//! // Trying to access `tracker` or pass `ptr_to_pinned_tracker` to anything that requires//! // mutable access to a non-pinned version of it will no longer compile//! // 3. We can now assume that the tracker value will never be moved, thus//! // this will never panic!//! Note that this invariant is enforced by simply making it impossible to call code that would//! perform a move on the pinned value. This is the case since the only way to access that pinned//! value is through the pinning <code>[Pin]<[&mut] T></code>, which in turn restricts our access.//! ## [`Unpin`]//! The vast majority of Rust types have no address-sensitive states. These types//! implement the [`Unpin`] auto-trait, which cancels the restrictive effects of//! [`Pin`] when the *pointee* type `T` is [`Unpin`]. When [`T: Unpin`][Unpin],//! <code>[Pin]<[Box]\<T>></code> functions identically to a non-pinning [`Box<T>`]; similarly,//! <code>[Pin]<[&mut] T></code> would impose no additional restrictions above a regular//! [`&mut T`].//! The idea of this trait is to alleviate the reduced ergonomics of APIs that require the use//! of [`Pin`] for soundness for some types, but which also want to be used by other types that//! don't care about pinning. The prime example of such an API is [`Future::poll`]. There are many//! [`Future`] types that don't care about pinning. These futures can implement [`Unpin`] and//! therefore get around the pinning related restrictions in the API, while still allowing the//! subset of [`Future`]s which *do* require pinning to be implemented soundly.//! Note that the interaction between a [`Pin<Ptr>`] and [`Unpin`] is through the type of the//! **pointee** value, [`<Ptr as Deref>::Target`][Target]. Whether the `Ptr` type itself//! implements [`Unpin`] does not affect the behavior of a [`Pin<Ptr>`]. For example, whether or not//! [`Box`] is [`Unpin`] has no effect on the behavior of <code>[Pin]<[Box]\<T>></code>, because//! `T` is the type of the pointee value, not [`Box`]. So, whether `T` implements [`Unpin`] is//! the thing that will affect the behavior of the <code>[Pin]<[Box]\<T>></code>.//! Builtin types that are [`Unpin`] include all of the primitive types, like [`bool`], [`i32`],//! and [`f32`], references (<code>[&]T</code> and <code>[&mut] T</code>), etc., as well as many//! core and standard library types like [`Box<T>`], [`String`], and more.//! These types are marked [`Unpin`] because they do not have an address-sensitive state like the//! ones we discussed above. If they did have such a state, those parts of their interface would be//! unsound without being expressed through pinning, and they would then need to not//! implement [`Unpin`].//! The compiler is free to take the conservative stance of marking types as [`Unpin`] so long as//! all of the types that compose its fields are also [`Unpin`]. This is because if a type//! implements [`Unpin`], then it is unsound for that type's implementation to rely on//! pinning-related guarantees for soundness, *even* when viewed through a "pinning" pointer! It is//! the responsibility of the implementor of a type that relies upon pinning for soundness to//! ensure that type is *not* marked as [`Unpin`] by adding [`PhantomPinned`] field. This is//! exactly what we did with our `AddrTracker` example above. Without doing this, you *must not*//! rely on pinning-related guarantees to apply to your type!//! If you really need to pin a value of a foreign or built-in type that implements [`Unpin`],//! you'll need to create your own wrapper type around the [`Unpin`] type you want to pin and then//! opt-out of [`Unpin`] using [`PhantomPinned`].//! Exposing access to the inner field which you want to remain pinned must then be carefully//! considered as well! Remember, exposing a method that gives access to a//! <code>[Pin]<[&mut] InnerT></code> where <code>InnerT: [Unpin]</code> would allow safe code to//! trivially move the inner value out of that pinning pointer, which is precisely what you're//! seeking to prevent! Exposing a field of a pinned value through a pinning pointer is called//! "projecting" a pin, and the more general case of deciding in which cases a pin should be able//! to be projected or not is called "structural pinning." We will go into more detail about this//! [below][structural-pinning].//! # Examples of address-sensitive types//! [address-sensitive-examples]: #examples-of-address-sensitive-types//! ## A self-referential struct//! [self-ref]: #a-self-referential-struct//! [`Unmovable`]: #a-self-referential-struct//! Self-referential structs are the simplest kind of address-sensitive type.//! It is often useful for a struct to hold a pointer back into itself, which//! allows the program to efficiently track subsections of the struct.//! Below, the `slice` field is a pointer into the `data` field, which//! we could imagine being used to track a sliding window of `data` in parser//! As mentioned before, this pattern is also used extensively by compiler-generated//! [`Future`]s.//! /// This is a self-referential struct because `self.slice` points into `self.data`.//! struct Unmovable {//!     /// Backing buffer.//!     data: [u8; 64],//!     /// Points at `self.data` which we know is itself non-null. Raw pointer because we can't do//!     /// this with a normal reference.//!     slice: NonNull<[u8]>,//!     /// Suppress `Unpin` so that this cannot be moved out of a `Pin` once constructed.//! impl Unmovable {//!     /// Creates a new `Unmovable`.//!     /// To ensure the data doesn't move we place it on the heap behind a pinning Box.//!     /// Note that the data is pinned, but the `Pin<Box<Self>>` which is pinning it can//!     /// itself still be moved. This is important because it means we can return the pinning//!     /// pointer from the function, which is itself a kind of move!//!     fn new() -> Pin<Box<Self>> {//!         let res = Unmovable {//!             data: [0; 64],//!             // We only create the pointer once the data is in place//!             // otherwise it will have already moved before we even started.//!             slice: NonNull::from(&[]),//!             _pin: PhantomPinned,//!         // First we put the data in a box, which will be its final resting place//!         let mut boxed = Box::new(res);//!         // Then we make the slice field point to the proper part of that boxed data.//!         // From now on we need to make sure we don't move the boxed data.//!         boxed.slice = NonNull::from(&boxed.data);//!         // To do that, we pin the data in place by pointing to it with a pinning//!         // (`Pin`-wrapped) pointer.//!         // `Box::into_pin` makes existing `Box` pin the data in-place without moving it,//!         // so we can safely do this now *after* inserting the slice pointer above, but we have//!         // to take care that we haven't performed any other semantic moves of `res` in between.//!         let pin = Box::into_pin(boxed);//!         // Now we can return the pinned (through a pinning Box) data//!         pin//! let unmovable: Pin<Box<Unmovable>> = Unmovable::new();//! // The inner pointee `Unmovable` struct will now never be allowed to move.//! // Meanwhile, we are free to move the pointer around.//! # #[allow(unused_mut)]//! let mut still_unmoved = unmovable;//! assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data));//! // We cannot mutably dereference a `Pin<Ptr>` unless the pointee is `Unpin` or we use unsafe.//! // Since our type doesn't implement `Unpin`, this will fail to compile.//! // let mut new_unmoved = Unmovable::new();//! // std::mem::swap(&mut *still_unmoved, &mut *new_unmoved);//! ## An intrusive, doubly-linked list//! [linked-list]: #an-intrusive-doubly-linked-list//! In an intrusive doubly-linked list, the collection itself does not own the memory in which//! each of its elements is stored. Instead, each client is free to allocate space for elements it//! adds to the list in whichever manner it likes, including on the stack! Elements can live on a//! stack frame that lives shorter than the collection does provided the elements that live in a//! given stack frame are removed from the list before going out of scope.//! To make such an intrusive data structure work, every element stores pointers to its predecessor//! and successor within its own data, rather than having the list structure itself managing those//! pointers. It is in this sense that the structure is "intrusive": the details of how an//! element is stored within the larger structure "intrudes" on the implementation of the element//! type itself!//! The full implementation details of such a data structure are outside the scope of this//! documentation, but we will discuss how [`Pin`] can help to do so.//! Using such an intrusive pattern, elements may only be added when they are pinned. If we think//! about the consequences of adding non-pinned values to such a list, this becomes clear://! *Moving* or otherwise invalidating an element's data would invalidate the pointers back to it//! which are stored in the elements ahead and behind it. Thus, in order to soundly dereference//! the pointers stored to the next and previous elements, we must satisfy the guarantee that//! nothing has invalidated those pointers (which point to data that we do not own).//! Moreover, the [`Drop`][Drop] implementation of each element must in some way notify its//! predecessor and successor elements that it should be removed from the list before it is fully//! destroyed, otherwise the pointers back to it would again become invalidated.//! Crucially, this means we have to be able to rely on [`drop`] always being called before an//! element is invalidated. If an element could be deallocated or otherwise invalidated without//! calling [`drop`], the pointers to it stored in its neighboring elements would//! become invalid, which would break the data structure.//! Therefore, pinning data also comes with [the "`Drop` guarantee"][drop-guarantee].//! # Subtle details and the `Drop` guarantee//! [subtle-details]: self#subtle-details-and-the-drop-guarantee//! [drop-guarantee]: self#subtle-details-and-the-drop-guarantee//! The purpose of pinning is not *just* to prevent a value from being *moved*, but more//! generally to be able to rely on the pinned value *remaining valid **at a specific place*** in//! To do so, pinning a value adds an *additional* invariant that must be upheld in order for use//! of the pinned data to be valid, on top of the ones that must be upheld for a non-pinned value//! of the same type to be valid://! From the moment a value is pinned by constructing a [`Pin`]ning pointer to it, that value//! must *remain, **valid***, at that same address in memory, *until its [`drop`] handler is//! called.*//! There is some subtlety to this which we have not yet talked about in detail. The invariant//! described above means that, yes,//! 1. The value must not be moved out of its location in memory//! but it also implies that,//! 2. The memory location that stores the value must not get invalidated or otherwise repurposed//!    during the lifespan of the pinned value until its [`drop`] returns or panics//! This point is subtle but required for intrusive data structures to be implemented soundly.//! ## `Drop` guarantee//! There needs to be a way for a pinned value to notify any code that is relying on its pinned//! status that it is about to be destroyed. In this way, the dependent code can remove the//! pinned value's address from its data structures or otherwise change its behavior with the//! knowledge that it can no longer rely on that value existing at the location it was pinned to.//! Thus, in any situation where we may want to overwrite a pinned value, that value's [`drop`] must//! be called beforehand (unless the pinned value implements [`Unpin`], in which case we can ignore//! all of [`Pin`]'s guarantees, as usual).//! The most common storage-reuse situations occur when a value on the stack is destroyed as part//! of a function return and when heap storage is freed. In both cases, [`drop`] gets run for us//! by Rust when using standard safe code. However, for manual heap allocations or otherwise//! custom-allocated storage, [`unsafe`] code must make sure to call [`ptr::drop_in_place`] before//! deallocating and re-using said storage.//! In addition, storage "re-use"/invalidation can happen even if no storage is (de-)allocated.//! For example, if we had an [`Option`] which contained a `Some(v)` where `v` is pinned, then `v`//! would be invalidated by setting that option to `None`.//! Similarly, if a [`Vec`] was used to store pinned values and [`Vec::set_len`] was used to//! manually "kill" some elements of a vector, all of the items "killed" would become invalidated,//! which would be *undefined behavior* if those items were pinned.//! Both of these cases are somewhat contrived, but it is crucial to remember that [`Pin`]ned data//! *must* be [`drop`]ped before it is invalidated; not just to prevent memory leaks, but as a//! matter of soundness. As a corollary, the following code can *never* be made safe://! # use std::mem::ManuallyDrop;//! # struct Type;//! // Pin something inside a `ManuallyDrop`. This is fine on its own.//! let mut pin: Pin<Box<ManuallyDrop<Type>>> = Box::pin(ManuallyDrop::new(Type));//! // However, creating a pinning mutable reference to the type *inside*//! // the `ManuallyDrop` is not!//! let inner: Pin<&mut Type> = unsafe {//!     Pin::map_unchecked_mut(pin.as_mut(), |x| &mut **x)//! Because [`mem::ManuallyDrop`] inhibits the destructor of `Type`, it won't get run when the//! <code>[Box]<[ManuallyDrop]\<Type>></code> is dropped, thus violating the drop guarantee of the//! <code>[Pin]<[&mut] Type>></code>.//! Of course, *leaking* memory in such a way that its underlying storage will never get invalidated//! or re-used is still fine: [`mem::forget`]ing a [`Box<T>`] prevents its storage from ever getting//! re-used, so the [`drop`] guarantee is still satisfied.//! # Implementing an address-sensitive type.//! This section goes into detail on important considerations for implementing your own//! address-sensitive types, which are different from merely using [`Pin<Ptr>`] in a generic//! way.//! ## Implementing [`Drop`] for types with address-sensitive states//! [drop-impl]: self#implementing-drop-for-types-with-address-sensitive-states//! The [`drop`] function takes [`&mut self`], but this is called *even if that `self` has been//! pinned*! Implementing [`Drop`] for a type with address-sensitive states requires some care, because if `self` was//! indeed in an address-sensitive state before [`drop`] was called, it is as if the compiler//! automatically called [`Pin::get_unchecked_mut`].//! This can never cause a problem in purely safe code because creating a pinning pointer to//! a type which has an address-sensitive (thus does not implement `Unpin`) requires `unsafe`,//! but it is important to note that choosing to take advantage of pinning-related guarantees//! to justify validity in the implementation of your type has consequences for that type's//! [`Drop`][Drop] implementation as well: if an element of your type could have been pinned,//! you must treat [`Drop`][Drop] as implicitly taking <code>self: [Pin]<[&mut] Self></code>.//! You should implement [`Drop`] as follows://! impl Drop for Type {//!         // `new_unchecked` is okay because we know this value is never used//!         // again after being dropped.//!         inner_drop(unsafe { Pin::new_unchecked(self)});//!         fn inner_drop(this: Pin<&mut Type>) {//!             // Actual drop code goes here.//! The function `inner_drop` has the signature that [`drop`] *should* have in this situation.//! This makes sure that you do not accidentally use `self`/`this` in a way that is in conflict//! with pinning's invariants.//! Moreover, if your type is [`#[repr(packed)]`][packed], the compiler will automatically//! move fields around to be able to drop them. It might even do//! that for fields that happen to be sufficiently aligned. As a consequence, you cannot use//! pinning with a [`#[repr(packed)]`][packed] type.//! ### Implementing [`Drop`] for pointer types which will be used as [`Pin`]ning pointers//! It should further be noted that creating a pinning pointer of some type `Ptr` *also* carries//! with it implications on the way that `Ptr` type must implement [`Drop`]//! (as well as [`Deref`] and [`DerefMut`])! When implementing a pointer type that may be used as//! a pinning pointer, you must also take the same care described above not to *move* out of or//! otherwise invalidate the pointee during [`Drop`], [`Deref`], or [`DerefMut`]//! ## "Assigning" pinned data//! Although in general it is not valid to swap data or assign through a [`Pin<Ptr>`] for the same//! reason that reusing a pinned object's memory is invalid, it is possible to do validly when//! implemented with special care for the needs of the exact data structure which is being//! modified. For example, the assigning function must know how to update all uses of the pinned//! address (and any other invariants necessary to satisfy validity for that type). For//! [`Unmovable`] (from the example above), we could write an assignment function like so://! # use std::marker::PhantomPinned;//! # use std::ptr::NonNull;//! # struct Unmovable {//! #     data: [u8; 64],//! #     slice: NonNull<[u8]>,//! #     _pin: PhantomPinned,//!     // Copies the contents of `src` into `self`, fixing up the self-pointer//!     // in the process.//!     fn assign(self: Pin<&mut Self>, src: Pin<&mut Self>) {//!             let unpinned_self = Pin::into_inner_unchecked(self);//!             let unpinned_src = Pin::into_inner_unchecked(src);//!             *unpinned_self = Self {//!                 data: unpinned_src.data,//!                 slice: NonNull::from(&mut []),//!                 _pin: PhantomPinned,//!             let data_ptr = unpinned_src.data.as_ptr() as *const u8;//!             let slice_ptr = unpinned_src.slice.as_ptr() as *const u8;//!             let offset = slice_ptr.offset_from(data_ptr) as usize;//!             let len = unpinned_src.slice.as_ptr().len();//!             unpinned_self.slice = NonNull::from(&mut unpinned_self.data[offset..offset+len]);//! Even though we can't have the compiler do the assignment for us, it's possible to write//! such specialized functions for types that might need it.//! Note that it _is_ possible to assign generically through a [`Pin<Ptr>`] by way of [`Pin::set()`].//! This does not violate any guarantees, since it will run [`drop`] on the pointee value before//! assigning the new value. Thus, the [`drop`] implementation still has a chance to perform the//! necessary notifications to dependent values before the memory location of the original pinned//! value is overwritten.//! ## Projections and Structural Pinning//! [structural-pinning]: self#projections-and-structural-pinning//! With ordinary structs, it is natural that we want to add *projection* methods that allow//! borrowing one or more of the inner fields of a struct when the caller has access to a//! borrow of the whole struct://! # struct Field;//!     field: Field,//! impl Struct {//!     fn field(&mut self) -> &mut Field { &mut self.field }//! When working with address-sensitive types, it's not obvious what the signature of these//! functions should be. If `field` takes <code>self: [Pin]<[&mut Struct][&mut]></code>, should it//! return [`&mut Field`] or <code>[Pin]<[`&mut Field`]></code>? This question also arises with//! `enum`s and wrapper types like [`Vec<T>`], [`Box<T>`], and [`RefCell<T>`]. (This question//! applies just as well to shared references, but we'll examine the more common case of mutable//! references for illustration)//! It turns out that it's up to the author of `Struct` to decide which type the "projection"//! should produce. The choice must be *consistent* though: if a pin is projected to a field//! in one place, then it should very likely not be exposed elsewhere without projecting the//! pin.//! As the author of a data structure, you get to decide for each field whether pinning//! "propagates" to this field or not. Pinning that propagates is also called "structural",//! because it follows the structure of the type.//! This choice depends on what guarantees you need from the field for your [`unsafe`] code to work.//! If the field is itself address-sensitive, or participates in the parent struct's address//! sensitivity, it will need to be structurally pinned.//! A useful test is if [`unsafe`] code that consumes <code>[Pin]\<[&mut Struct][&mut]></code>//! also needs to take note of the address of the field itself, it may be evidence that that field//! is structurally pinned. Unfortunately, there are no hard-and-fast rules.//! ### Choosing pinning *not to be* structural for `field`...//! While counter-intuitive, it's often the easier choice: if you do not expose a//! <code>[Pin]<[&mut] Field></code>, you do not need to be careful about other code//! moving out of that field, you just have to ensure is that you never create pinning//! reference to that field. This does of course also mean that if you decide a field does not//! have structural pinning, you must not write [`unsafe`] code that assumes (invalidly) that the//! field *is* structurally pinned!//! Fields without structural pinning may have a projection method that turns//! <code>[Pin]<[&mut] Struct></code> into [`&mut Field`]://! # type Field = i32;//! # struct Struct { field: Field }//!     fn field(self: Pin<&mut Self>) -> &mut Field {//!         // This is okay because `field` is never considered pinned, therefore we do not//!         // need to uphold any pinning guarantees for this field in particular. Of course,//!         // we must not elsewhere assume this field *is* pinned if we choose to expose//!         // such a method!//!         unsafe { &mut self.get_unchecked_mut().field }//! You may also in this situation <code>impl [Unpin] for Struct {}</code> *even if* the type of//! `field` is not [`Unpin`]. Since we have explicitly chosen not to care about pinning guarantees//! for `field`, the way `field`'s type interacts with pinning is no longer relevant in the//! context of its use in `Struct`.//! ### Choosing pinning *to be* structural for `field`...//! The other option is to decide that pinning is "structural" for `field`,//! meaning that if the struct is pinned then so is the field.//! This allows writing a projection that creates a <code>[Pin]<[`&mut Field`]></code>, thus//! witnessing that the field is pinned://!     fn field(self: Pin<&mut Self>) -> Pin<&mut Field> {//!         // This is okay because `field` is pinned when `self` is.//!         unsafe { self.map_unchecked_mut(|s| &mut s.field) }//! Structural pinning comes with a few extra requirements://! 1.  *Structural [`Unpin`].* A struct can be [`Unpin`] only if all of its//!     structurally-pinned fields are, too. This is [`Unpin`]'s behavior by default.//!     However, as a library author, it is your responsibility not to write something like//!     <code>impl\<T> [Unpin] for Struct\<T> {}</code> and then offer a method that provides//!     structural pinning to an inner field of `T`, which may not be [`Unpin`]! (Adding *any*//!     projection operation requires unsafe code, so the fact that [`Unpin`] is a safe trait does//!     not break the principle that you only have to worry about any of this if you use//!     [`unsafe`])//! 2.  *Pinned Destruction.* As discussed [above][drop-impl], [`drop`] takes//!     [`&mut self`], but the struct (and hence its fields) might have been pinned//!     before. The destructor must be written as if its argument was//!     <code>self: [Pin]\<[`&mut Self`]></code>, instead.//!     As a consequence, the struct *must not* be [`#[repr(packed)]`][packed].//! 3.  *Structural Notice of Destruction.* You must uphold the//!     [`Drop` guarantee][drop-guarantee]: once your struct is pinned, the struct's storage cannot//!     be re-used without calling the structurally-pinned fields' destructors, as well.//!     This can be tricky, as witnessed by [`VecDeque<T>`]: the destructor of [`VecDeque<T>`]//!     can fail to call [`drop`] on all elements if one of the destructors panics. This violates//!     the [`Drop` guarantee][drop-guarantee], because it can lead to elements being deallocated//!     without their destructor being called.//!     [`VecDeque<T>`] has no pinning projections, so its destructor is sound. If it wanted//!     to provide such structural pinning, its destructor would need to abort the process if any//!     of the destructors panicked.//! 4.  You must not offer any other operations that could lead to data being *moved* out of//!     the structural fields when your type is pinned. For example, if the struct contains an//!     [`Option<T>`] and there is a [`take`][Option::take]-like operation with type//!     <code>fn([Pin]<[&mut Struct\<T>][&mut]>) -> [`Option<T>`]</code>,//!     then that operation can be used to move a `T` out of a pinned `Struct<T>` – which//!     means pinning cannot be structural for the field holding this data.//!     For a more complex example of moving data out of a pinned type,//!     imagine if [`RefCell<T>`] had a method//!     <code>fn get_pin_mut(self: [Pin]<[`&mut Self`]>) -> [Pin]<[`&mut T`]></code>.//!     Then we could do the following://!     ```compile_fail//!     # use std::cell::RefCell;//!     # use std::pin::Pin;//!     fn exploit_ref_cell<T>(rc: Pin<&mut RefCell<T>>) {//!         // Here we get pinned access to the `T`.//!         let _: Pin<&mut T> = rc.as_mut().get_pin_mut();//!         // And here we have `&mut T` to the same data.//!         let shared: &RefCell<T> = rc.into_ref().get_ref();//!         let borrow = shared.borrow_mut();//!         let content = &mut *borrow;//!     This is catastrophic: it means we can first pin the content of the//!     [`RefCell<T>`] (using <code>[RefCell]::get_pin_mut</code>) and then move that//!     content using the mutable reference we got later.//! ### Structural Pinning examples//! For a type like [`Vec<T>`], both possibilities (structural pinning or not) make//! sense. A [`Vec<T>`] with structural pinning could have `get_pin`/`get_pin_mut`//! methods to get pinning references to elements. However, it could *not* allow calling//! [`pop`][Vec::pop] on a pinned [`Vec<T>`] because that would move the (structurally//! pinned) contents! Nor could it allow [`push`][Vec::push], which might reallocate and thus also//! move the contents.//! A [`Vec<T>`] without structural pinning could//! <code>impl\<T> [Unpin] for [`Vec<T>`]</code>, because the contents are never pinned//! and the [`Vec<T>`] itself is fine with being moved as well.//! At that point pinning just has no effect on the vector at all.//! In the standard library, pointer types generally do not have structural pinning,//! and thus they do not offer pinning projections. This is why <code>[`Box<T>`]: [Unpin]</code>//! holds for all `T`. It makes sense to do this for pointer types, because moving the//! [`Box<T>`] does not actually move the `T`: the [`Box<T>`] can be freely//! movable (aka [`Unpin`]) even if the `T` is not. In fact, even <code>[Pin]<[`Box<T>`]></code> and//! <code>[Pin]<[`&mut T`]></code> are always [`Unpin`] themselves, for the same reason://! their contents (the `T`) are pinned, but the pointers themselves can be moved without moving//! the pinned data. For both [`Box<T>`] and <code>[Pin]<[`Box<T>`]></code>,//! whether the content is pinned is entirely independent of whether the//! pointer is pinned, meaning pinning is *not* structural.//! When implementing a [`Future`] combinator, you will usually need structural pinning//! for the nested futures, as you need to get pinning ([`Pin`]-wrapped) references to them to//! call [`poll`]. But if your combinator contains any other data that does not need to be pinned,//! you can make those fields not structural and hence freely access them with a//! mutable reference even when you just have <code>[Pin]<[`&mut Self`]></code>//! (such as in your own [`poll`] implementation).//! [`&mut T`]: &mut//! [`&mut self`]: &mut//! [`&mut Self`]: &mut//! [`&mut Field`]: &mut//! [Deref]: crate::ops::Deref "ops::Deref"//! [`Deref`]: crate::ops::Deref "ops::Deref"//! [Target]: crate::ops::Deref::Target "ops::Deref::Target"//! [`DerefMut`]: crate::ops::DerefMut "ops::DerefMut"//! [`mem::swap`]: crate::mem::swap "mem::swap"//! [`mem::forget`]: crate::mem::forget "mem::forget"//! [ManuallyDrop]: crate::mem::ManuallyDrop "ManuallyDrop"//! [RefCell]: crate::cell::RefCell "cell::RefCell"//! [`drop`]: Drop::drop//! [`ptr::write`]: crate::ptr::write "ptr::write"//! [`Future`]: crate::future::Future "future::Future"//! [drop-impl]: #drop-implementation//! [drop-guarantee]: #drop-guarantee//! [`poll`]: crate::future::Future::poll "future::Future::poll"//! [`unsafe`]: ../../std/keyword.unsafe.html "keyword unsafe"//! [packed]: https://doc.rust-lang.org/nomicon/other-reprs.html#reprpacked//! [`std::alloc`]: ../../std/alloc/index.html//! [`Box<T>`]: ../../std/boxed/struct.Box.html//! [Box]: ../../std/boxed/struct.Box.html "Box"//! [`Box`]: ../../std/boxed/struct.Box.html "Box"//! [Rc]: ../../std/rc/struct.Rc.html "rc::Rc"//! [`Vec<T>`]: ../../std/vec/struct.Vec.html//! [Vec]: ../../std/vec/struct.Vec.html "Vec"//! [`Vec`]: ../../std/vec/struct.Vec.html "Vec"//! [`Vec::set_len`]: ../../std/vec/struct.Vec.html#method.set_len "Vec::set_len"//! [Vec::pop]: ../../std/vec/struct.Vec.html#method.pop "Vec::pop"//! [Vec::push]: ../../std/vec/struct.Vec.html#method.push "Vec::push"//! [`Vec::set_len`]: ../../std/vec/struct.Vec.html#method.set_len//! [`VecDeque<T>`]: ../../std/collections/struct.VecDeque.html//! [VecDeque]: ../../std/collections/struct.VecDeque.html "collections::VecDeque"//! [`String`]: ../../std/string/struct.String.html "String"// The following implementations aren't derived in order to avoid soundness// issues. `&self.pointer` should not be accessible to untrusted trait// See <https://internals.rust-lang.org/t/unsoundness-in-pin/11311/73> for more details.rust_2015/// The 2015 version of the core prelude.rust_2018/// The 2018 version of the core prelude.rust_2021/// The 2021 version of the core prelude./// The 2024 version of the core prelude.rust_future/// The Future version of the core prelude.//! The core prelude//! This module is intended for users of core which do not link to std as well.//! This module is imported by default when `#![no_std]` is used in the same//! manner as the standard library's prelude.// No formatting: this file is nothing but re-exports, and their order is worth preserving.// Re-exported core operators// Re-exported functions// Re-exported types and traits// Re-exported built-in macros// Do not `doc(no_inline)` so that they become doc items on their own// (no public module for them to be re-exported from).//! The first version of the core prelude.//! See the [module-level documentation](super) for more.//! This module reexports the primitive types to allow usage that is not//! possibly shadowed by other declared types.//! This is normally only useful in macro generated code.//! An example of this is when generating a new struct and an impl for it://! pub struct bool;//! impl QueryId for bool {//!     const SOME_PROPERTY: bool = true;//! # trait QueryId { const SOME_PROPERTY: ::core::primitive::bool; }//! Note that the `SOME_PROPERTY` associated constant would not compile, as its//! type `bool` refers to the struct, rather than to the primitive bool type.//! A correct implementation could look like://! # #[allow(non_camel_case_types)]//!     const SOME_PROPERTY: ::core::primitive::bool = true;//! We also used `::core` instead of `core`, because `core` can be//! shadowed, too. Paths, starting with `::`, are searched in//! the [extern prelude] since Edition 2018.//! [extern prelude]: https://doc.rust-lang.org/nightly/reference/names/preludes.html#extern-prelude/// The boolean type./// The `bool` represents a value, which could only be either [`true`] or [`false`]. If you cast/// a `bool` into an integer, [`true`] will be 1 and [`false`] will be 0./// # Basic usage/// `bool` implements various traits, such as [`BitAnd`], [`BitOr`], [`Not`], etc.,/// which allow us to perform boolean operations using `&`, `|` and `!`./// [`if`] requires a `bool` value as its conditional. [`assert!`], which is an/// important macro in testing, checks whether an expression is [`true`] and panics/// if it isn't./// let bool_val = true & false | false;/// assert!(!bool_val);/// [`true`]: ../std/keyword.true.html/// [`false`]: ../std/keyword.false.html/// [`BitAnd`]: ops::BitAnd/// [`BitOr`]: ops::BitOr/// [`Not`]: ops::Not/// [`if`]: ../std/keyword.if.html/// A trivial example of the usage of `bool`:/// let praise_the_borrow_checker = true;/// // using the `if` conditional/// if praise_the_borrow_checker {///     println!("oh, yeah!");///     println!("what?!!");/// // ... or, a match pattern/// match praise_the_borrow_checker {///     true => println!("keep praising!"),///     false => println!("you should praise!"),/// Also, since `bool` implements the [`Copy`] trait, we don't/// have to worry about the move semantics (just like the integer and float primitives)./// Now an example of `bool` cast to integer type:/// assert_eq!(true as i32, 1);/// assert_eq!(false as i32, 0);/// The `!` type, also called "never"./// `!` represents the type of computations which never resolve to any value at all. For example,/// the [`exit`] function `fn exit(code: i32) -> !` exits the process without ever returning, and/// so returns `!`./// `break`, `continue` and `return` expressions also have type `!`. For example we are allowed to/// write:/// #![feature(never_type)]/// # fn foo() -> u32 {/// let x: ! = {///     return 123/// Although the `let` is pointless here, it illustrates the meaning of `!`. Since `x` is never/// assigned a value (because `return` returns from the entire function), `x` can be given type/// `!`. We could also replace `return 123` with a `panic!` or a never-ending `loop` and this code/// would still be valid./// A more realistic usage of `!` is in this code:/// # fn get_a_number() -> Option<u32> { None }/// # loop {/// let num: u32 = match get_a_number() {///     Some(num) => num,///     None => break,/// Both match arms must produce values of type [`u32`], but since `break` never produces a value/// at all we know it can never produce a value which isn't a [`u32`]. This illustrates another/// behavior of the `!` type - expressions with type `!` will coerce into any other type./// [`u32`]: prim@u32/// [`exit`]: ../std/process/fn.exit.html/// # `!` and generics/// ## Infallible errors/// The main place you'll see `!` used explicitly is in generic code. Consider the [`FromStr`]/// trait:/// trait FromStr: Sized {///     type Err;///     fn from_str(s: &str) -> Result<Self, Self::Err>;/// When implementing this trait for [`String`] we need to pick a type for [`Err`]. And since/// converting a string into a string will never result in an error, the appropriate type is `!`./// (Currently the type actually used is an enum with no variants, though this is only because `!`/// was added to Rust at a later date and it may change in the future.) With an [`Err`] type of/// `!`, if we have to call [`String::from_str`] for some reason the result will be a/// [`Result<String, !>`] which we can unpack like this:/// let Ok(s) = String::from_str("hello");/// Since the [`Err`] variant contains a `!`, it can never occur. This means we can exhaustively/// match on [`Result<T, !>`] by just taking the [`Ok`] variant. This illustrates another behavior/// of `!` - it can be used to "delete" certain enum variants from generic types like `Result`./// ## Infinite loops/// While [`Result<T, !>`] is very useful for removing errors, `!` can also be used to remove/// successes as well. If we think of [`Result<T, !>`] as "if this function returns, it has not/// errored," we get a very intuitive idea of [`Result<!, E>`] as well: if the function returns, it/// *has* errored./// For example, consider the case of a simple web server, which can be simplified to:/// ```ignore (hypothetical-example)///     let (client, request) = get_request().expect("disconnected");///     let response = request.process();///     response.send(client);/// Currently, this isn't ideal, because we simply panic whenever we fail to get a new connection./// Instead, we'd like to keep track of this error, like this:///     match get_request() {///         Err(err) => break err,///         Ok((client, request)) => {///             let response = request.process();///             response.send(client);/// Now, when the server disconnects, we exit the loop with an error instead of panicking. While it/// might be intuitive to simply return the error, we might want to wrap it in a [`Result<!, E>`]/// instead:/// fn server_loop() -> Result<!, ConnectionError> {///         let (client, request) = get_request()?;///         let response = request.process();///         response.send(client);/// Now, we can use `?` instead of `match`, and the return type makes a lot more sense: if the loop/// ever stops, it means that an error occurred. We don't even have to wrap the loop in an `Ok`/// because `!` coerces to `Result<!, ConnectionError>` automatically./// [`String::from_str`]: str::FromStr::from_str/// [`String`]: ../std/string/struct.String.html/// [`FromStr`]: str::FromStr/// # `!` and traits/// When writing your own traits, `!` should have an `impl` whenever there is an obvious `impl`/// which doesn't `panic!`. The reason is that functions returning an `impl Trait` where `!`/// does not have an `impl` of `Trait` cannot diverge as their only possible code path. In other/// words, they can't return `!` from every code path. As an example, this code doesn't compile:/// fn foo() -> impl Add<u32> {/// But this code does:///         0/// The reason is that, in the first example, there are many possible types that `!` could coerce/// to, because many types implement `Add<u32>`. However, in the second example,/// the `else` branch returns a `0`, which the compiler infers from the return type to be of type/// `u32`. Since `u32` is a concrete type, `!` can and will be coerced to it. See issue [#36375]/// for more information on this quirk of `!`./// [#36375]: https://github.com/rust-lang/rust/issues/36375/// As it turns out, though, most traits can have an `impl` for `!`. Take [`Debug`]/// for example:/// # trait Debug {/// #     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result;/// impl Debug for ! {/// Once again we're using `!`'s ability to coerce into any other type, in this case/// [`fmt::Result`]. Since this method takes a `&!` as an argument we know that it can never be/// called (because there is no value of type `!` for it to be called with). Writing `*self`/// essentially tells the compiler "We know that this code can never be run, so just treat the/// entire function body as having type [`fmt::Result`]". This pattern can be used a lot when/// implementing traits for `!`. Generally, any trait which only has methods which take a `self`/// parameter should have such an impl./// On the other hand, one trait which would not be appropriate to implement is [`Default`]:/// trait Default {///     fn default() -> Self;/// Since `!` has no values, it has no default value either. It's true that we could write an/// `impl` for this which simply panics, but the same is true for any type (we could `impl/// Default` for (eg.) [`File`] by just making [`default()`] panic.)/// [`File`]: ../std/fs/struct.File.html/// [`Debug`]: fmt::Debug/// [`default()`]: Default::default/// # Never type fallback/// When the compiler sees a value of type `!` in a [coercion site], it implicitly inserts a/// coercion to allow the type checker to infer any type:// FIXME: use `core::convert::absurd` here instead, once it's merged/// ```rust,ignore (illustrative-and-has-placeholders)/// // this/// let x: u8 = panic!();/// // is (essentially) turned by the compiler into/// let x: u8 = absurd(panic!());/// // where absurd is a function with the following signature/// // (it's sound, because `!` always marks unreachable code):/// fn absurd<T>(_: !) -> T { ... }/// This can lead to compilation errors if the type cannot be inferred:/// { panic!() };/// // gets turned into this/// { absurd(panic!()) }; // error: can't infer the type of `absurd`/// To prevent such errors, the compiler remembers where it inserted `absurd` calls, and/// if it can't infer the type, it uses the fallback type instead:/// type Fallback = /* An arbitrarily selected type! */;/// { absurd::<Fallback>(panic!()) }/// This is what is known as "never type fallback"./// Historically, the fallback type was [`()`], causing confusing behavior where `!` spontaneously/// coerced to `()`, even when it would not infer `()` without the fallback. The fallback was changed/// to `!` in the [2024 edition], and will be changed in all editions at a later date./// [coercion site]: <https://doc.rust-lang.org/reference/type-coercions.html#coercion-sites>/// [`()`]: prim@unit/// [2024 edition]: <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>// Required to make auto trait impls render.// See src/librustdoc/passes/collect_trait_impls.rs:collect_trait_impls/// A character type./// The `char` type represents a single character. More specifically, since/// 'character' isn't a well-defined concept in Unicode, `char` is a '[Unicode/// scalar value]'./// This documentation describes a number of methods and trait implementations on the/// `char` type. For technical reasons, there is additional, separate/// documentation in [the `std::char` module](char/index.html) as well./// # Validity and Layout/// A `char` is a '[Unicode scalar value]', which is any '[Unicode code point]'/// other than a [surrogate code point]. This has a fixed numerical definition:/// code points are in the range 0 to 0x10FFFF, inclusive./// Surrogate code points, used by UTF-16, are in the range 0xD800 to 0xDFFF./// No `char` may be constructed, whether as a literal or at runtime, that is not a/// Unicode scalar value. Violating this rule causes undefined behavior./// // Each of these is a compiler error/// ['\u{D800}', '\u{DFFF}', '\u{110000}'];/// // Panics; from_u32 returns None./// char::from_u32(0xDE01).unwrap();/// // Undefined behavior/// let _ = unsafe { char::from_u32_unchecked(0x110000) };/// Unicode scalar values are also the exact set of values that may be encoded in UTF-8. Because/// `char` values are Unicode scalar values and functions may assume [incoming `str` values are/// valid UTF-8](primitive.str.html#invariant), it is safe to store any `char` in a `str` or read/// any character from a `str` as a `char`./// The gap in valid `char` values is understood by the compiler, so in the/// below example the two ranges are understood to cover the whole range of/// possible `char` values and there is no error for a [non-exhaustive match]./// match c {///     '\0' ..= '\u{D7FF}' => false,///     '\u{E000}' ..= '\u{10FFFF}' => true,/// All Unicode scalar values are valid `char` values, but not all of them represent a real/// character. Many Unicode scalar values are not currently assigned to a character, but may be in/// the future ("reserved"); some will never be a character ("noncharacters"); and some may be given/// different meanings by different users ("private use")./// `char` is guaranteed to have the same size, alignment, and function call ABI as `u32` on all/// assert_eq!(Layout::new::<char>(), Layout::new::<u32>());/// [Unicode code point]: https://www.unicode.org/glossary/#code_point/// [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value/// [non-exhaustive match]: ../book/ch06-02-match.html#matches-are-exhaustive/// [surrogate code point]: https://www.unicode.org/glossary/#surrogate_code_point/// `char` is always four bytes in size. This is a different representation than/// a given character would have as part of a [`String`]. For example:/// let v = vec!['h', 'e', 'l', 'l', 'o'];/// // five elements times four bytes for each element/// assert_eq!(20, v.len() * size_of::<char>());/// // five elements times one byte per element/// assert_eq!(5, s.len() * size_of::<u8>());/// As always, remember that a human intuition for 'character' might not map to/// Unicode's definitions. For example, despite looking similar, the 'é'/// character is one Unicode code point while 'é' is two Unicode code points:/// let mut chars = "é".chars();/// // U+00e9: 'latin small letter e with acute'/// assert_eq!(Some('\u{00e9}'), chars.next());/// let mut chars = "é".chars();/// // U+0065: 'latin small letter e'/// assert_eq!(Some('\u{0065}'), chars.next());/// // U+0301: 'combining acute accent'/// assert_eq!(Some('\u{0301}'), chars.next());/// This means that the contents of the first string above _will_ fit into a/// `char` while the contents of the second string _will not_. Trying to create/// a `char` literal with the contents of the second string gives an error:/// error: character literal may only contain one codepoint: 'é'/// let c = 'é';///         ^^^/// Another implication of the 4-byte fixed size of a `char` is that/// per-`char` processing can end up using a lot more memory:/// let s = String::from("love: ❤️");/// let v: Vec<char> = s.chars().collect();/// assert_eq!(12, size_of_val(&s[..]));/// assert_eq!(32, size_of_val(&v[..]));/// The `()` type, also called "unit"./// The `()` type has exactly one value `()`, and is used when there/// is no other meaningful value that could be returned. `()` is most/// commonly seen implicitly: functions without a `-> ...` implicitly/// have return type `()`, that is, these are equivalent:/// fn long() -> () {}/// fn short() {}/// The semicolon `;` can be used to discard the result of an/// expression at the end of a block, making the expression (and thus/// the block) evaluate to `()`. For example,/// fn returns_i64() -> i64 {///     1i64/// fn returns_unit() {///     1i64;/// let is_i64 = {///     returns_i64()/// let is_unit = {///     returns_i64();/// Raw, unsafe pointers, `*const T`, and `*mut T`./// *[See also the `std::ptr` module](ptr).*/// Working with raw pointers in Rust is uncommon, typically limited to a few patterns. Raw pointers/// can be out-of-bounds, unaligned, or [`null`]. However, when loading from or storing to a raw/// pointer, it must be [valid] for the given access and aligned. When using a field expression,/// tuple index expression, or array/slice index expression on a raw pointer, it follows the rules/// of [in-bounds pointer arithmetic][`offset`]./// Storing through a raw pointer using `*ptr = data` calls `drop` on the old value, so/// [`write`] must be used if the type has drop glue and memory is not already/// initialized - otherwise `drop` would be called on the uninitialized memory./// Use the [`null`] and [`null_mut`] functions to create null pointers, and the/// [`is_null`] method of the `*const T` and `*mut T` types to check for null./// The `*const T` and `*mut T` types also define the [`offset`] method, for/// pointer math./// # Common ways to create raw pointers/// ## 1. Coerce a reference (`&T`) or mutable reference (`&mut T`)./// let my_num: i32 = 10;/// let my_num_ptr: *const i32 = &my_num;/// let mut my_speed: i32 = 88;/// let my_speed_ptr: *mut i32 = &mut my_speed;/// To get a pointer to a boxed value, dereference the box:/// let my_num: Box<i32> = Box::new(10);/// let my_num_ptr: *const i32 = &*my_num;/// let mut my_speed: Box<i32> = Box::new(88);/// let my_speed_ptr: *mut i32 = &mut *my_speed;/// This does not take ownership of the original allocation/// and requires no resource management later,/// but you must not use the pointer after its lifetime./// ## 2. Consume a box (`Box<T>`)./// The [`into_raw`] function consumes a box and returns/// the raw pointer. It doesn't destroy `T` or deallocate any memory./// let my_speed: Box<i32> = Box::new(88);/// let my_speed: *mut i32 = Box::into_raw(my_speed);/// // By taking ownership of the original `Box<T>` though/// // we are obligated to put it together later to be destroyed.///     drop(Box::from_raw(my_speed));/// Note that here the call to [`drop`] is for clarity - it indicates/// that we are done with the given value and it should be destroyed./// ## 3. Create it using `&raw`/// Instead of coercing a reference to a raw pointer, you can use the raw borrow/// operators `&raw const` (for `*const T`) and `&raw mut` (for `*mut T`)./// These operators allow you to create raw pointers to fields to which you cannot/// create a reference (without causing undefined behavior), such as an/// unaligned field. This might be necessary if packed structs or uninitialized/// memory is involved./// #[derive(Debug, Default, Copy, Clone)]///     aligned: u8,///     unaligned: u32,/// let s = S::default();/// let p = &raw const s.unaligned; // not allowed with coercion/// ## 4. Get it from C./// # mod libc {/// # pub unsafe fn malloc(_size: usize) -> *mut core::ffi::c_void { core::ptr::NonNull::dangling().as_ptr() }/// # pub unsafe fn free(_ptr: *mut core::ffi::c_void) {}/// #[allow(unused_extern_crates)]///     let my_num: *mut i32 = libc::malloc(size_of::<i32>()) as *mut i32;///     if my_num.is_null() {///         panic!("failed to allocate memory");///     libc::free(my_num as *mut core::ffi::c_void);/// Usually you wouldn't literally use `malloc` and `free` from Rust,/// but C APIs hand out a lot of pointers generally, so are a common source/// of raw pointers in Rust./// [`null_mut`]: ptr::null_mut/// [`is_null`]: pointer::is_null/// [`offset`]: pointer::offset/// [`into_raw`]: ../std/boxed/struct.Box.html#method.into_raw/// [`write`]: ptr::write/// [valid]: ptr#safety// unfortunately, rustdoc doesn't have fuzzy search for aliases/// A fixed-size array, denoted `[T; N]`, for the element type, `T`, and the/// non-negative compile-time constant size, `N`./// There are two syntactic forms for creating an array:/// * A list with each element, i.e., `[x, y, z]`./// * A repeat expression `[expr; N]` where `N` is how many times to repeat `expr` in the array. `expr` must either be:///   * A value of a type implementing the [`Copy`] trait///   * A `const` value/// Note that `[expr; 0]` is allowed, and produces an empty array./// Arrays of *any* size implement the following traits if the element type allows it:/// - [`IntoIterator`] (implemented for `[T; N]`, `&[T; N]` and `&mut [T; N]`)/// - [`PartialEq`], [`PartialOrd`], [`Eq`], [`Ord`]/// - [`Hash`]/// - [`AsRef`], [`AsMut`]/// - [`Borrow`], [`BorrowMut`]/// Arrays of sizes from 0 to 32 (inclusive) implement the [`Default`] trait/// if the element type allows it. As a stopgap, trait implementations are/// statically generated up to size 32./// Arrays of sizes from 1 to 12 (inclusive) implement [`From<Tuple>`], where `Tuple`/// is a homogeneous [prim@tuple] of appropriate length./// Arrays coerce to [slices (`[T]`)][slice], so a slice method may be called on/// an array. Indeed, this provides most of the API for working with arrays./// Slices have a dynamic size and do not coerce to arrays. Instead, use/// `slice.try_into().unwrap()` or `<ArrayType>::try_from(slice).unwrap()`./// Array's `try_from(slice)` implementations (and the corresponding `slice.try_into()`/// array implementations) succeed if the input slice length is the same as the result/// array length. They optimize especially well when the optimizer can easily determine/// the slice length, e.g. `<[u8; 4]>::try_from(&slice[4..8]).unwrap()`. Array implements/// [TryFrom](crate::convert::TryFrom) returning:/// - `[T; N]` copies from the slice's elements/// - `&[T; N]` references the original slice's elements/// - `&mut [T; N]` references the original slice's elements/// You can move elements out of an array with a [slice pattern]. If you want/// one element, see [`mem::replace`]./// let mut array: [i32; 3] = [0; 3];/// array[1] = 1;/// array[2] = 2;/// assert_eq!([1, 2], &array[1..]);/// // This loop prints: 0 1 2/// for x in array {///     print!("{x} ");/// You can also iterate over reference to the array's elements:/// let array: [i32; 3] = [0; 3];/// for x in &array { }/// You can use `<ArrayType>::try_from(slice)` or `slice.try_into()` to get an array from/// a slice:/// assert_eq!(1, u16::from_le_bytes(<[u8; 2]>::try_from(&bytes[0..2]).unwrap()));/// assert_eq!(512, u16::from_le_bytes(bytes[1..3].try_into().unwrap()));/// You can use a [slice pattern] to move elements out of an array:/// fn move_away(_: String) { /* Do interesting things. */ }/// let [john, roa] = ["John".to_string(), "Roa".to_string()];/// move_away(john);/// move_away(roa);/// Arrays can be created from homogeneous tuples of appropriate length:/// let tuple: (u32, u32, u32) = (1, 2, 3);/// let array: [u32; 3] = tuple.into();/// # Editions/// Prior to Rust 1.53, arrays did not implement [`IntoIterator`] by value, so the method call/// `array.into_iter()` auto-referenced into a [slice iterator](slice::iter). Right now, the old/// behavior is preserved in the 2015 and 2018 editions of Rust for compatibility, ignoring/// [`IntoIterator`] by value. In the future, the behavior on the 2015 and 2018 edition/// might be made consistent to the behavior of later editions./// ```rust,edition2018/// // Rust 2015 and 2018:/// # #![allow(array_into_iter)] // override our `deny(warnings)`/// // This creates a slice iterator, producing references to each value./// for item in array.into_iter().enumerate() {///     let (i, x): (usize, &i32) = item;///     println!("array[{i}] = {x}");/// // The `array_into_iter` lint suggests this change for future compatibility:/// for item in array.iter().enumerate() {/// // You can explicitly iterate an array by value using `IntoIterator::into_iter`/// for item in IntoIterator::into_iter(array).enumerate() {///     let (i, x): (usize, i32) = item;/// Starting in the 2021 edition, `array.into_iter()` uses `IntoIterator` normally to iterate/// by value, and `iter()` should be used to iterate by reference like previous editions./// ```rust,edition2021/// // Rust 2021:/// // This iterates by reference:/// // This iterates by value:/// Future language versions might start treating the `array.into_iter()`/// syntax on editions 2015 and 2018 the same as on edition 2021. So code using/// those older editions should still be written with this change in mind, to/// prevent breakage in the future. The safest way to accomplish this is to/// avoid the `into_iter` syntax on those editions. If an edition update is not/// viable/desired, there are multiple alternatives:/// * use `iter`, equivalent to the old behavior, creating references/// * use [`IntoIterator::into_iter`], equivalent to the post-2021 behavior (Rust 1.53+)/// * replace `for ... in array.into_iter() {` with `for ... in array {`,///   equivalent to the post-2021 behavior (Rust 1.53+)/// for item in array.iter() {///     let x: &i32 = item;/// for item in IntoIterator::into_iter(array) {///     let x: i32 = item;/// for item in array {/// // IntoIter can also start a chain./// [slice]: prim@slice/// [`Hash`]: hash::Hash/// [`Borrow`]: borrow::Borrow/// [`BorrowMut`]: borrow::BorrowMut/// [slice pattern]: ../reference/patterns.html#slice-patterns/// [`From<Tuple>`]: convert::From/// A dynamically-sized view into a contiguous sequence, `[T]`./// Contiguous here means that elements are laid out so that every element is the same/// distance from its neighbors./// *[See also the `std::slice` module](crate::slice).*/// Slices are a view into a block of memory represented as a pointer and a/// // slicing a Vec/// let vec = vec![1, 2, 3];/// let int_slice = &vec[..];/// // coercing an array to a slice/// let str_slice: &[&str] = &["one", "two", "three"];/// Slices are either mutable or shared. The shared slice type is `&[T]`,/// while the mutable slice type is `&mut [T]`, where `T` represents the element/// type. For example, you can mutate the block of memory that a mutable slice/// points to:/// let mut x = [1, 2, 3];/// let x = &mut x[..]; // Take a full slice of `x`./// x[1] = 7;/// assert_eq!(x, &[1, 7, 3]);/// It is possible to slice empty subranges of slices by using empty ranges (including `slice.len()..slice.len()`):/// let empty = &x[0..0];   // subslice before the first element/// assert_eq!(empty, &[]);/// let empty = &x[..0];    // same as &x[0..0]/// let empty = &x[1..1];   // empty subslice in the middle/// let empty = &x[3..3];   // subslice after the last element/// let empty = &x[3..];    // same as &x[3..3]/// It is not allowed to use subranges that start with lower bound bigger than `slice.len()`:/// let _ = &x[4..4];/// As slices store the length of the sequence they refer to, they have twice/// the size of pointers to [`Sized`](marker/trait.Sized.html) types./// Also see the reference on/// [dynamically sized types](../reference/dynamically-sized-types.html)./// let pointer_size = size_of::<&u8>();/// assert_eq!(2 * pointer_size, size_of::<&[u8]>());/// assert_eq!(2 * pointer_size, size_of::<*const [u8]>());/// assert_eq!(2 * pointer_size, size_of::<Box<[u8]>>());/// assert_eq!(2 * pointer_size, size_of::<Rc<[u8]>>());/// ## Trait Implementations/// Some traits are implemented for slices if the element type implements/// that trait. This includes [`Eq`], [`Hash`] and [`Ord`]./// ## Iteration/// The slices implement `IntoIterator`. The iterator yields references to the/// slice elements./// let numbers: &[i32] = &[0, 1, 2];/// for n in numbers {///     println!("{n} is a number!");/// The mutable slice yields mutable references to the elements:/// let mut scores: &mut [i32] = &mut [7, 8, 9];/// for score in scores {///     *score += 1;/// This iterator yields mutable references to the slice's elements, so while/// the element type of the slice is `i32`, the element type of the iterator is/// `&mut i32`./// * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default///   iterators./// * Further methods that return iterators are [`.split`], [`.splitn`],///   [`.chunks`], [`.windows`] and more./// [`.iter`]: slice::iter/// [`.iter_mut`]: slice::iter_mut/// [`.split`]: slice::split/// [`.splitn`]: slice::splitn/// [`.chunks`]: slice::chunks/// [`.windows`]: slice::windows/// String slices./// *[See also the `std::str` module](crate::str).*/// The `str` type, also called a 'string slice', is the most primitive string/// type. It is usually seen in its borrowed form, `&str`. It is also the type/// of string literals, `&'static str`./// # Basic Usage/// String literals are string slices:/// let hello_world = "Hello, World!";/// Here we have declared a string slice initialized with a string literal./// String literals have a static lifetime, which means the string `hello_world`/// is guaranteed to be valid for the duration of the entire program./// We can explicitly specify `hello_world`'s lifetime as well:/// let hello_world: &'static str = "Hello, world!";/// A `&str` is made up of two components: a pointer to some bytes, and a/// length. You can look at these with the [`as_ptr`] and [`len`] methods:/// use std::str;/// let story = "Once upon a time...";/// let ptr = story.as_ptr();/// let len = story.len();/// // We can re-build a str out of ptr and len. This is all unsafe because/// // we are responsible for making sure the two components are valid:/// let s = unsafe {///     // First, we build a &[u8]...///     let slice = slice::from_raw_parts(ptr, len);///     // ... and then convert that slice into a string slice///     str::from_utf8(slice)/// assert_eq!(s, Ok(story));/// [`len`]: str::len/// Note: This example shows the internals of `&str`. `unsafe` should not be/// used to get a string slice under normal circumstances. Use `as_str`/// Rust libraries may assume that string slices are always valid UTF-8./// Constructing a non-UTF-8 string slice is not immediate undefined behavior, but any function/// called on a string slice may assume that it is valid UTF-8, which means that a non-UTF-8 string/// slice can lead to undefined behavior down the road./// A finite heterogeneous sequence, `(T, U, ..)`./// Let's cover each of those in turn:/// Tuples are *finite*. In other words, a tuple has a length. Here's a tuple/// of length `3`:/// ("hello", 5, 'c');/// 'Length' is also sometimes called 'arity' here; each tuple of a different/// length is a different, distinct type./// Tuples are *heterogeneous*. This means that each element of the tuple can/// have a different type. In that tuple above, it has the type:/// # let _:/// (&'static str, i32, char)/// # = ("hello", 5, 'c');/// Tuples are a *sequence*. This means that they can be accessed by position;/// this is called 'tuple indexing', and it looks like this:/// let tuple = ("hello", 5, 'c');/// assert_eq!(tuple.0, "hello");/// assert_eq!(tuple.1, 5);/// assert_eq!(tuple.2, 'c');/// The sequential nature of the tuple applies to its implementations of various/// traits. For example, in [`PartialOrd`] and [`Ord`], the elements are compared/// sequentially until the first non-equal set is found./// For more about tuples, see [the book](../book/ch03-02-data-types.html#the-tuple-type).// Hardcoded anchor in src/librustdoc/html/format.rs// linked to as `#trait-implementations-1`/// In this documentation the shorthand `(T₁, T₂, …, Tₙ)` is used to represent tuples of varying/// length. When that is used, any trait bound expressed on `T` applies to each element of the/// tuple independently. Note that this is a convenience notation to avoid repetitive/// documentation, not valid Rust syntax./// Due to a temporary restriction in Rust’s type system, the following traits are only/// implemented on tuples of arity 12 or less. In the future, this may change:/// * [`PartialEq`]/// * [`Eq`]/// * [`PartialOrd`]/// * [`Ord`]/// * [`Debug`]/// * [`Default`]/// * [`Hash`]/// * [`From<[T; N]>`][from]/// [from]: convert::From/// The following traits are implemented for tuples of any length. These traits have/// implementations that are automatically generated by the compiler, so are not limited by/// missing language features./// * [`Clone`]/// * [`Copy`]/// * [`Send`]/// * [`Sync`]/// * [`Unpin`]/// * [`UnwindSafe`]/// * [`RefUnwindSafe`]/// [`UnwindSafe`]: panic::UnwindSafe/// [`RefUnwindSafe`]: panic::RefUnwindSafe/// Tuples are often used as a return type when you want to return more than/// one value:/// fn calculate_point() -> (i32, i32) {///     // Don't do a calculation, that's not the point of the example///     (4, 5)/// let point = calculate_point();/// assert_eq!(point.0, 4);/// assert_eq!(point.1, 5);/// // Combining this with patterns can be nicer./// let (x, y) = calculate_point();/// assert_eq!(y, 5);/// Homogeneous tuples can be created from arrays of appropriate length:/// let array: [u32; 3] = [1, 2, 3];/// let tuple: (u32, u32, u32) = array.into();/// A 16-bit floating-point type (specifically, the "binary16" type defined in IEEE 754-2008)./// This type is very similar to [`prim@f32`] but has decreased precision because it uses half as many/// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on half-precision/// values][wikipedia] for more information./// Note that most common platforms will not support `f16` in hardware without enabling extra target/// features, with the notable exception of Apple Silicon (also known as M1, M2, etc.) processors./// Hardware support on x86/x86-64 requires the avx512fp16 or avx10.1 features, while RISC-V requires/// Zfh, and Arm/AArch64 requires FEAT_FP16.  Usually the fallback implementation will be to use `f32`/// hardware if it exists, and convert between `f16` and `f32` when performing math./// *[See also the `std::f16::consts` module](crate::f16::consts).*/// [wikipedia]: https://en.wikipedia.org/wiki/Half-precision_floating-point_format/// A 32-bit floating-point type (specifically, the "binary32" type defined in IEEE 754-2008)./// This type can represent a wide range of decimal numbers, like `3.5`, `27`,/// `-113.75`, `0.0078125`, `34359738368`, `0`, `-1`. So unlike integer types/// (such as `i32`), floating-point types can represent non-integer numbers,/// too./// However, being able to represent this wide range of numbers comes at the/// cost of precision: floats can only represent some of the real numbers and/// calculation with floats round to a nearby representable number. For example,/// `5.0` and `1.0` can be exactly represented as `f32`, but `1.0 / 5.0` results/// in `0.20000000298023223876953125` since `0.2` cannot be exactly represented/// as `f32`. Note, however, that printing floats with `println` and friends will/// often discard insignificant digits: `println!("{}", 1.0f32 / 5.0f32)` will/// print `0.2`./// Additionally, `f32` can represent some special values:/// - −0.0: IEEE 754 floating-point numbers have a bit that indicates their sign, so −0.0 is a///   possible value. For comparison −0.0 = +0.0, but floating-point operations can carry///   the sign bit through arithmetic operations. This means −0.0 × +0.0 produces −0.0 and///   a negative number rounded to a value smaller than a float can represent also produces −0.0./// - [∞](#associatedconstant.INFINITY) and///   [−∞](#associatedconstant.NEG_INFINITY): these result from calculations///   like `1.0 / 0.0`./// - [NaN (not a number)](#associatedconstant.NAN): this value results from///   calculations like `(-1.0).sqrt()`. NaN has some potentially unexpected///   behavior:///   - It is not equal to any float, including itself! This is the reason `f32`///     doesn't implement the `Eq` trait.///   - It is also neither smaller nor greater than any float, making it///     impossible to sort by the default comparison operation, which is the///     reason `f32` doesn't implement the `Ord` trait.///   - It is also considered *infectious* as almost all calculations where one///     of the operands is NaN will also result in NaN. The explanations on this///     page only explicitly document behavior on NaN operands if this default///     is deviated from.///   - Lastly, there are multiple bit patterns that are considered NaN.///     Rust does not currently guarantee that the bit patterns of NaN are///     preserved over arithmetic operations, and they are not guaranteed to be///     portable or even fully deterministic! This means that there may be some///     surprising results upon inspecting the bit patterns,///     as the same calculations might produce NaNs with different bit patterns.///     This also affects the sign of the NaN: checking `is_sign_positive` or `is_sign_negative` on///     a NaN is the most common way to run into these surprising results.///     (Checking `x >= 0.0` or `x <= 0.0` avoids those surprises, but also how negative/positive///     zero are treated.)///     See the section below for what exactly is guaranteed about the bit pattern of a NaN./// When a primitive operation (addition, subtraction, multiplication, or/// division) is performed on this type, the result is rounded according to the/// roundTiesToEven direction defined in IEEE 754-2008. That means:/// - The result is the representable value closest to the true value, if there///   is a unique closest representable value./// - If the true value is exactly half-way between two representable values,///   the result is the one with an even least-significant binary digit./// - If the true value's magnitude is ≥ `f32::MAX` + 2<sup>(`f32::MAX_EXP` −///   `f32::MANTISSA_DIGITS` − 1)</sup>, the result is ∞ or −∞ (preserving the///   true value's sign)./// - If the result of a sum exactly equals zero, the outcome is +0.0 unless///   both arguments were negative, then it is -0.0. Subtraction `a - b` is///   regarded as a sum `a + (-b)`./// For more information on floating-point numbers, see [Wikipedia][wikipedia]./// *[See also the `std::f32::consts` module](crate::f32::consts).*/// [wikipedia]: https://en.wikipedia.org/wiki/Single-precision_floating-point_format/// # NaN bit patterns/// This section defines the possible NaN bit patterns returned by floating-point operations./// The bit pattern of a floating-point NaN value is defined by:/// - a sign bit./// - a quiet/signaling bit. Rust assumes that the quiet/signaling bit being set to `1` indicates a///   quiet NaN (QNaN), and a value of `0` indicates a signaling NaN (SNaN). In the following we///   will hence just call it the "quiet bit"./// - a payload, which makes up the rest of the significand (i.e., the mantissa) except for the///   quiet bit./// The rules for NaN values differ between *arithmetic* and *non-arithmetic* (or "bitwise")/// operations. The non-arithmetic operations are unary `-`, `abs`, `copysign`, `signum`,/// `{to,from}_bits`, `{to,from}_{be,le,ne}_bytes` and `is_sign_{positive,negative}`. These/// operations are guaranteed to exactly preserve the bit pattern of their input except for possibly/// changing the sign bit./// The following rules apply when a NaN value is returned from an arithmetic operation:/// - The result has a non-deterministic sign./// - The quiet bit and payload are non-deterministically chosen from///   the following set of options:///   - **Preferred NaN**: The quiet bit is set and the payload is all-zero.///   - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input///     operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for///     `as` casts), then///     - If the output is smaller than the input, low-order bits of the payload get dropped.///     - If the output is larger than the input, the payload gets filled up with 0s in the low-order///       bits.///   - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand///     that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the///     same rules as for "quieting NaN propagation" apply, with one caveat: if the output is smaller///     than the input, dropping the low-order bits may result in a payload of 0; a payload of 0 is not///     possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN///     propagation cannot occur with some inputs.///   - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific///     set of "extra" possible NaN payloads. The set can depend on the input operand values.///     See the table below for the concrete NaNs this set contains on various targets./// In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN/// is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input/// value. Similarly, if all input NaNs are preferred (or if there are no input NaNs) and the target/// does not have any "extra" NaN payloads, then the output NaN is guaranteed to be preferred./// The non-deterministic choice happens when the operation is executed; i.e., the result of a/// NaN-producing floating-point operation is a stable bit pattern (looking at these bits multiple/// times will yield consistent results), but running the same operation twice with the same inputs/// can produce different results./// These guarantees are neither stronger nor weaker than those of IEEE 754: IEEE 754 guarantees/// that an operation never returns a signaling NaN, whereas it is possible for operations like/// `SNAN * 1.0` to return a signaling NaN in Rust. Conversely, IEEE 754 makes no statement at all/// about which quiet NaN is returned, whereas Rust restricts the set of possible results to the/// ones listed above./// Unless noted otherwise, the same rules also apply to NaNs returned by other library functions/// (e.g. `min`, `minimum`, `max`, `maximum`); other aspects of their semantics and which IEEE 754/// operation they correspond to are documented with the respective functions./// When an arithmetic floating-point operation is executed in `const` context, the same rules/// apply: no guarantee is made about which of the NaN bit patterns described above will be/// returned. The result does not have to match what happens when executing the same code at/// runtime, and the result can vary depending on factors such as compiler version and flags./// ### Target-specific "extra" NaN values// FIXME: Is there a better place to put this?/// | `target_arch` | Extra payloads possible on this platform |/// |---------------|------------------------------------------|// Sorted alphabetically/// | `aarch64`, `arm`, `arm64ec`, `loongarch64`, `powerpc` (except when `target_abi = "spe"`), `powerpc64`, `riscv32`, `riscv64`, `s390x`, `x86`, `x86_64` | None |/// | `nvptx64` | All payloads |/// | `sparc`, `sparc64` | The all-one payload |/// | `wasm32`, `wasm64` | If all input NaNs are quiet with all-zero payload: None.<br> Otherwise: all payloads. |/// For targets not in this table, all payloads are possible./// # Algebraic operators/// Algebraic operators of the form `a.algebraic_*(b)` allow the compiler to optimize/// floating point operations using all the usual algebraic properties of real numbers --/// despite the fact that those properties do *not* hold on floating point numbers./// This can give a great performance boost since it may unlock vectorization./// The exact set of optimizations is unspecified but typically allows combining operations,/// rearranging series of operations based on mathematical properties, converting between division/// and reciprocal multiplication, and disregarding the sign of zero. This means that the results of/// elementary operations may have undefined precision, and "non-mathematical" values/// such as NaN, +/-Inf, or -0.0 may behave in unexpected ways, but these operations/// will never cause undefined behavior./// Because of the unpredictable nature of compiler optimizations, the same inputs may produce/// different results even within a single program run. **Unsafe code must not rely on any property/// of the return value for soundness.** However, implementations will generally do their best to/// pick a reasonable tradeoff between performance and accuracy of the result./// # #![feature(float_algebraic)]/// # #![allow(unused_assignments)]/// # let mut x: f32 = 0.0;/// # let a: f32 = 1.0;/// # let b: f32 = 2.0;/// # let c: f32 = 3.0;/// # let d: f32 = 4.0;/// x = a.algebraic_add(b).algebraic_add(c).algebraic_add(d);/// May be rewritten as:/// x = a + b + c + d; // As written/// x = (a + c) + (b + d); // Reordered to shorten critical path and enable vectorization/// A 64-bit floating-point type (specifically, the "binary64" type defined in IEEE 754-2008)./// This type is very similar to [`prim@f32`], but has increased precision by using twice as many/// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on double-precision/// *[See also the `std::f64::consts` module](crate::f64::consts).*/// [wikipedia]: https://en.wikipedia.org/wiki/Double-precision_floating-point_format/// A 128-bit floating-point type (specifically, the "binary128" type defined in IEEE 754-2008)./// This type is very similar to [`prim@f32`] and [`prim@f64`], but has increased precision by using twice/// as many bits as `f64`. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on/// quad-precision values][wikipedia] for more information./// Note that no platforms have hardware support for `f128` without enabling target specific features,/// as for all instruction set architectures `f128` is considered an optional feature.  Only Power ISA/// ("PowerPC") and RISC-V (via the Q extension) specify it, and only certain microarchitectures/// actually implement it. For x86-64 and AArch64, ISA support is not even specified, so it will always/// be a software implementation significantly slower than `f64`./// _Note: `f128` support is incomplete. Many platforms will not be able to link math functions. On/// x86 in particular, these functions do link but their results are always incorrect._/// *[See also the `std::f128::consts` module](crate::f128::consts).*/// [wikipedia]: https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format/// The 8-bit signed integer type./// The 16-bit signed integer type./// The 32-bit signed integer type./// The 64-bit signed integer type./// The 128-bit signed integer type./// # ABI compatibility/// Rust's `i128` is expected to be ABI-compatible with C's `__int128` on platforms where the type/// is available, which includes most 64-bit architectures. If any platforms that do not specify/// `__int128` are updated to introduce it, the Rust `i128` ABI on relevant targets will be changed/// to match./// It is important to note that in C, `__int128` is _not_ the same as `_BitInt(128)`, and the two/// types are allowed to have different ABIs. In particular, on x86, `__int128` and `_BitInt(128)`/// do not use the same alignment. `i128` is intended to always match `__int128` and does not/// attempt to match `_BitInt(128)` on platforms without `__int128`./// The 8-bit unsigned integer type./// The 16-bit unsigned integer type./// The 32-bit unsigned integer type./// The 64-bit unsigned integer type./// The 128-bit unsigned integer type./// Please see [the documentation for `i128`](prim@i128) for information on ABI compatibility./// The pointer-sized signed integer type./// The size of this primitive is how many bytes it takes to reference any/// location in memory. For example, on a 32 bit target, this is 4 bytes/// and on a 64 bit target, this is 8 bytes./// The pointer-sized unsigned integer type./// References, `&T` and `&mut T`./// A reference represents a borrow of some owned value. You can get one by using the `&` or `&mut`/// operators on a value, or by using a [`ref`](../std/keyword.ref.html) or/// <code>[ref](../std/keyword.ref.html) [mut](../std/keyword.mut.html)</code> pattern./// For those familiar with pointers, a reference is just a pointer that is assumed to be/// aligned, not null, and pointing to memory containing a valid value of `T` - for example,/// <code>&[bool]</code> can only point to an allocation containing the integer values `1`/// ([`true`](../std/keyword.true.html)) or `0` ([`false`](../std/keyword.false.html)), but/// creating a <code>&[bool]</code> that points to an allocation containing/// the value `3` causes undefined behavior./// In fact, <code>[Option]\<&T></code> has the same memory representation as a/// nullable but aligned pointer, and can be passed across FFI boundaries as such./// In most cases, references can be used much like the original value. Field access, method/// calling, and indexing work the same (save for mutability rules, of course). In addition, the/// comparison operators transparently defer to the referent's implementation, allowing references/// to be compared the same as owned values./// References have a lifetime attached to them, which represents the scope for which the borrow is/// valid. A lifetime is said to "outlive" another one if its representative scope is as long or/// longer than the other. The `'static` lifetime is the longest lifetime, which represents the/// total life of the program. For example, string literals have a `'static` lifetime because the/// text data is embedded into the binary of the program, rather than in an allocation that needs/// to be dynamically managed./// `&mut T` references can be freely coerced into `&T` references with the same referent type, and/// references with longer lifetimes can be freely coerced into references with shorter ones./// [`PartialEq`] will compare referenced values. It is possible to compare the reference address/// using reference-pointer coercion and raw pointer equality via [`ptr::eq`]./// let other_five = 5;/// let five_ref = &five;/// let same_five_ref = &five;/// let other_five_ref = &other_five;/// assert!(five_ref == same_five_ref);/// assert!(five_ref == other_five_ref);/// assert!(ptr::eq(five_ref, same_five_ref));/// assert!(!ptr::eq(five_ref, other_five_ref));/// For more information on how to use references, see [the book's section on "References and/// Borrowing"][book-refs]./// [book-refs]: ../book/ch04-02-references-and-borrowing.html/// The following traits are implemented for all `&T`, regardless of the type of its referent:/// * [`Clone`] \(Note that this will not defer to `T`'s `Clone` implementation if it exists!)/// * [`Deref`]/// * [`Borrow`]/// * [`fmt::Pointer`]/// `&mut T` references get all of the above except `Copy` and `Clone` (to prevent creating/// multiple simultaneous mutable borrows), plus the following, regardless of the type of its/// referent:/// * [`DerefMut`]/// * [`BorrowMut`]/// [`DerefMut`]: ops::DerefMut/// [bool]: prim@bool/// The following traits are implemented on `&T` references if the underlying `T` also implements/// that trait:/// * All the traits in [`std::fmt`] except [`fmt::Pointer`] (which is implemented regardless of the type of its referent) and [`fmt::Write`]/// * [`AsRef`]/// * [`Fn`] \(in addition, `&T` references get [`FnMut`] and [`FnOnce`] if `T: Fn`)/// * [`ToSocketAddrs`]/// [`std::fmt`]: fmt/// [`ToSocketAddrs`]: ../std/net/trait.ToSocketAddrs.html/// `&mut T` references get all of the above except `ToSocketAddrs`, plus the following, if `T`/// implements that trait:/// * [`AsMut`]/// * [`FnMut`] \(in addition, `&mut T` references get [`FnOnce`] if `T: FnMut`)/// * [`fmt::Write`]/// * [`Iterator`]/// * [`DoubleEndedIterator`]/// * [`ExactSizeIterator`]/// * [`FusedIterator`]/// * [`TrustedLen`]/// * [`io::Write`]/// * [`Read`]/// * [`Seek`]/// * [`BufRead`]/// [`FusedIterator`]: iter::FusedIterator/// [`TrustedLen`]: iter::TrustedLen/// [`Seek`]: ../std/io/trait.Seek.html/// [`BufRead`]: ../std/io/trait.BufRead.html/// [`Read`]: ../std/io/trait.Read.html/// In addition, `&T` references implement [`Send`] if and only if `T` implements [`Sync`]./// Note that due to method call deref coercion, simply calling a trait method will act like they/// work on references as well as they do on owned values! The implementations described here are/// meant for generic contexts, where the final type `T` is a type parameter or otherwise not/// locally known./// For all types, `T: ?Sized`, and for all `t: &T` or `t: &mut T`, when such values cross an API/// boundary, the following invariants must generally be upheld:/// * `t` is non-null/// * `t` is aligned to `align_of_val(t)`/// * if `size_of_val(t) > 0`, then `t` is dereferenceable for `size_of_val(t)` many bytes/// If `t` points at address `a`, being "dereferenceable" for N bytes means that the memory range/// `[a, a + N)` is all contained within a single [allocation]./// For instance, this means that unsafe code in a safe function may assume these invariants are/// ensured of arguments passed by the caller, and it may assume that these invariants are ensured/// of return values from any safe functions it calls./// For the other direction, things are more complicated: when unsafe code passes arguments/// to safe functions or returns values from safe functions, they generally must *at least*/// not violate these invariants. The full requirements are stronger, as the reference generally/// must point to data that is safe to use as type `T`./// It is not decided yet whether unsafe code may violate these invariants temporarily on internal/// data. As a consequence, unsafe code which violates these invariants temporarily on internal data/// may be unsound or become unsound in future versions of Rust depending on how this question is/// decided./// [allocation]: ptr#allocation/// Function pointers, like `fn(usize) -> bool`./// *See also the traits [`Fn`], [`FnMut`], and [`FnOnce`].*/// Function pointers are pointers that point to *code*, not data. They can be called/// just like functions. Like references, function pointers are, among other things, assumed to/// not be null, so if you want to pass a function pointer over FFI and be able to accommodate null/// pointers, make your type [`Option<fn()>`](core::option#options-and-pointers-nullable-pointers)/// with your required signature./// Note that FFI requires additional care to ensure that the ABI for both sides of the call match./// The exact requirements are not currently documented./// Plain function pointers are obtained by casting either plain functions, or closures that don't/// capture an environment:/// fn add_one(x: usize) -> usize {/// let ptr: fn(usize) -> usize = add_one;/// assert_eq!(ptr(5), 6);/// let clos: fn(usize) -> usize = |x| x + 5;/// assert_eq!(clos(5), 10);/// In addition to varying based on their signature, function pointers come in two flavors: safe/// and unsafe. Plain `fn()` function pointers can only point to safe functions,/// while `unsafe fn()` function pointers can point to safe or unsafe functions./// unsafe fn add_one_unsafely(x: usize) -> usize {/// let safe_ptr: fn(usize) -> usize = add_one;/// //ERROR: mismatched types: expected normal fn, found unsafe fn/// //let bad_ptr: fn(usize) -> usize = add_one_unsafely;/// let unsafe_ptr: unsafe fn(usize) -> usize = add_one_unsafely;/// let really_safe_ptr: unsafe fn(usize) -> usize = add_one;/// ### ABI/// On top of that, function pointers can vary based on what ABI they use. This/// is achieved by adding the `extern` keyword before the type, followed by the/// ABI in question. The default ABI is "Rust", i.e., `fn()` is the exact same/// type as `extern "Rust" fn()`. A pointer to a function with C ABI would have/// type `extern "C" fn()`./// `extern "ABI" { ... }` blocks declare functions with ABI "ABI". The default/// here is "C", i.e., functions declared in an `extern {...}` block have "C"/// ABI./// For more information and a list of supported ABIs, see [the nomicon's/// section on foreign calling conventions][nomicon-abi]./// [nomicon-abi]: ../nomicon/ffi.html#foreign-calling-conventions/// ### Variadic functions/// Extern function declarations with the "C" or "cdecl" ABIs can also be *variadic*, allowing them/// to be called with a variable number of arguments. Normal Rust functions, even those with an/// `extern "ABI"`, cannot be variadic. For more information, see [the nomicon's section on/// variadic functions][nomicon-variadic]./// [nomicon-variadic]: ../nomicon/ffi.html#variadic-functions/// ### Creating function pointers/// When `bar` is the name of a function, then the expression `bar` is *not* a/// function pointer. Rather, it denotes a value of an unnameable type that/// uniquely identifies the function `bar`. The value is zero-sized because the/// type already identifies the function. This has the advantage that "calling"/// the value (it implements the `Fn*` traits) does not require dynamic/// dispatch./// This zero-sized type *coerces* to a regular function pointer. For example:/// fn bar(x: i32) {}/// let not_bar_ptr = bar; // `not_bar_ptr` is zero-sized, uniquely identifying `bar`/// assert_eq!(size_of_val(&not_bar_ptr), 0);/// let bar_ptr: fn(i32) = not_bar_ptr; // force coercion to function pointer/// assert_eq!(size_of_val(&bar_ptr), size_of::<usize>());/// let footgun = &bar; // this is a shared reference to the zero-sized type identifying `bar`/// The last line shows that `&bar` is not a function pointer either. Rather, it/// is a reference to the function-specific ZST. `&bar` is basically never what you/// want when `bar` is a function./// ### Casting to and from integers/// You can cast function pointers directly to integers:/// let fnptr: fn(i32) -> i32 = |x| x+2;/// let fnptr_addr = fnptr as usize;/// However, a direct cast back is not possible. You need to use `transmute`:/// # #[cfg(not(miri))] { // FIXME: use strict provenance APIs once they are stable, then remove this `cfg`/// # let fnptr: fn(i32) -> i32 = |x| x+2;/// # let fnptr_addr = fnptr as usize;/// let fnptr = fnptr_addr as *const ();/// let fnptr: fn(i32) -> i32 = unsafe { std::mem::transmute(fnptr) };/// assert_eq!(fnptr(40), 42);/// Crucially, we `as`-cast to a raw pointer before `transmute`ing to a function pointer./// This avoids an integer-to-pointer `transmute`, which can be problematic./// Transmuting between raw pointers and function pointers (i.e., two pointer types) is fine./// Note that all of this is not portable to platforms where function pointers and data pointers/// have different sizes./// ### ABI compatibility/// Generally, when a function is declared with one signature and called via a function pointer with/// a different signature, the two signatures must be *ABI-compatible* or else calling the function/// via that function pointer is Undefined Behavior. ABI compatibility is a lot stricter than merely/// having the same memory layout; for example, even if `i32` and `f32` have the same size and/// alignment, they might be passed in different registers and hence not be ABI-compatible./// ABI compatibility as a concern only arises in code that alters the type of function pointers,/// and code that imports functions via `extern` blocks. Altering the type of function pointers is/// wildly unsafe (as in, a lot more unsafe than even [`transmute_copy`][mem::transmute_copy]), and/// should only occur in the most exceptional circumstances. Most Rust code just imports functions/// via `use`. So, most likely you do not have to worry about ABI compatibility./// But assuming such circumstances, what are the rules? For this section, we are only considering/// the ABI of direct Rust-to-Rust calls (with both definition and callsite visible to the/// Rust compiler), not linking in general -- once functions are imported via `extern` blocks, there/// are more things to consider that we do not go into here. Note that this also applies to/// passing/calling functions across language boundaries via function pointers./// **Nothing in this section should be taken as a guarantee for non-Rust-to-Rust calls, even with/// types from `core::ffi` or `libc`**./// For two signatures to be considered *ABI-compatible*, they must use a compatible ABI string,/// must take the same number of arguments, and the individual argument types and the return types/// must be ABI-compatible. The ABI string is declared via `extern "ABI" fn(...) -> ...`; note that/// `fn name(...) -> ...` implicitly uses the `"Rust"` ABI string and `extern fn name(...) -> ...`/// implicitly uses the `"C"` ABI string./// The ABI strings are guaranteed to be compatible if they are the same, or if the caller ABI/// string is `$X-unwind` and the callee ABI string is `$X`, where `$X` is one of the following:/// "C", "aapcs", "fastcall", "stdcall", "system", "sysv64", "thiscall", "vectorcall", "win64"./// The following types are guaranteed to be ABI-compatible:/// - `*const T`, `*mut T`, `&T`, `&mut T`, `Box<T>` (specifically, only `Box<T, Global>`), and///   `NonNull<T>` are all ABI-compatible with each other for all `T`. They are also ABI-compatible///   with each other for _different_ `T` if they have the same metadata type (`<T as///   Pointee>::Metadata`)./// - `usize` is ABI-compatible with the `uN` integer type of the same size, and likewise `isize` is///   ABI-compatible with the `iN` integer type of the same size./// - `char` is ABI-compatible with `u32`./// - Any two `fn` (function pointer) types are ABI-compatible with each other if they have the same///   ABI string or the ABI string only differs in a trailing `-unwind`, independent of the rest of///   their signature. (This means you can pass `fn()` to a function expecting `fn(i32)`, and the///   call will be valid ABI-wise. The callee receives the result of transmuting the function pointer///   from `fn()` to `fn(i32)`; that transmutation is itself a well-defined operation, it's just///   almost certainly UB to later call that function pointer.)/// - Any two types with size 0 and alignment 1 are ABI-compatible./// - A `repr(transparent)` type `T` is ABI-compatible with its unique non-trivial field, i.e., the///   unique field that doesn't have size 0 and alignment 1 (if there is such a field)./// - `i32` is ABI-compatible with `NonZero<i32>`, and similar for all other integer types./// - If `T` is guaranteed to be subject to the [null pointer///   optimization](option/index.html#representation), and `E` is an enum satisfying the following///   requirements, then `T` and `E` are ABI-compatible. Such an enum `E` is called "option-like".///   - The enum `E` uses the [`Rust` representation], and is not modified by the `align` or///     `packed` representation modifiers.///   - The enum `E` has exactly two variants.///   - One variant has exactly one field, of type `T`.///   - All fields of the other variant are zero-sized with 1-byte alignment./// Furthermore, ABI compatibility satisfies the following general properties:/// - Every type is ABI-compatible with itself./// - If `T1` and `T2` are ABI-compatible and `T2` and `T3` are ABI-compatible, then so are `T1` and///   `T3` (i.e., ABI-compatibility is transitive)./// - If `T1` and `T2` are ABI-compatible, then so are `T2` and `T1` (i.e., ABI-compatibility is///   symmetric)./// More signatures can be ABI-compatible on specific targets, but that should not be relied upon/// since it is not portable and not a stable guarantee./// Noteworthy cases of types *not* being ABI-compatible in general are:/// * `bool` vs `u8`, `i32` vs `u32`, `char` vs `i32`: on some targets, the calling conventions for///   these types differ in terms of what they guarantee for the remaining bits in the register that///   are not used by the value./// * `i32` vs `f32` are not compatible either, as has already been mentioned above./// * `struct Foo(u32)` and `u32` are not compatible (without `repr(transparent)`) since structs are///   aggregate types and often passed in a different way than primitives like `i32`./// Note that these rules describe when two completely known types are ABI-compatible. When/// considering ABI compatibility of a type declared in another crate (including the standard/// library), consider that any type that has a private field or the `#[non_exhaustive]` attribute/// may change its layout as a non-breaking update unless documented otherwise -- so for instance,/// even if such a type is a 1-ZST or `repr(transparent)` right now, this might change with any/// library version bump./// If the declared signature and the signature of the function pointer are ABI-compatible, then the/// function call behaves as if every argument was [`transmute`d][mem::transmute] from the/// type in the function pointer to the type at the function declaration, and the return value is/// [`transmute`d][mem::transmute] from the type in the declaration to the type in the/// pointer. All the usual caveats and concerns around transmutation apply; for instance, if the/// function expects a `NonZero<i32>` and the function pointer uses the ABI-compatible type/// `Option<NonZero<i32>>`, and the value used for the argument is `None`, then this call is Undefined/// Behavior since transmuting `None::<NonZero<i32>>` to `NonZero<i32>` violates the non-zero/// requirement./// ### Trait implementations/// In this documentation the shorthand `fn(T₁, T₂, …, Tₙ)` is used to represent non-variadic/// function pointers of varying length. Note that this is a convenience notation to avoid/// repetitive documentation, not valid Rust syntax./// The following traits are implemented for function pointers with any number of arguments and/// any ABI./// * [`Pointer`]/// Note that while this type implements `PartialEq`, comparing function pointers is unreliable:/// pointers to the same function can compare inequal (because functions are duplicated in multiple/// codegen units), and pointers to *different* functions can compare equal (since identical/// functions can be deduplicated within a codegen unit)./// [`Pointer`]: fmt::Pointer/// [`Rust` representation]: <https://doc.rust-lang.org/reference/type-layout.html#the-rust-representation>/// In addition, all *safe* function pointers implement [`Fn`], [`FnMut`], and [`FnOnce`], because/// these traits are specially known to the compiler."compiler_move"compiler_move/// Profiling marker for move operations./// This function is never called at runtime. When `-Z annotate-moves` is enabled,/// the compiler creates synthetic debug info that makes move operations appear as/// calls to this function in profilers./// The `SIZE` parameter encodes the size of the type being copied. It's the same as/// `size_of::<T>()`, and is only present for convenience."compiler_copy"compiler_copy/// Profiling marker for copy operations./// the compiler creates synthetic debug info that makes copy operations appear as//! Profiling markers for compiler instrumentation.AlignmentEnum/// A type storing a `usize` which is a power of two, and thus/// represents a possible alignment in the Rust abstract machine./// Note that particularly large alignments, while representable in this type,/// are likely not to be supported by actual allocators and linkers.// Alignment is `repr(usize)`, but via extra steps._alignment_can_be_structurally_matched/// The smallest possible alignment, 1./// All addresses are always aligned at least this much./// #![feature(ptr_alignment_type)]/// use std::ptr::Alignment;/// assert_eq!(Alignment::MIN.as_usize(), 1);/// Returns the alignment for a type./// This provides the same numerical value as [`align_of`],/// but in an `Alignment` instead of a `usize`./// Creates an `Alignment` from a `usize`, or returns `None` if it's/// not a power of two./// Note that `0` is not a power of two, nor a valid alignment./// Creates an `Alignment` from a power-of-two `usize`./// Equivalently, it must be `1 << exp` for some `exp` in `0..usize::BITS`./// It must *not* be zero./// Returns the alignment as a [`usize`].as_nonzero/// Returns the alignment as a <code>[NonZero]<[usize]></code>./// Returns the base-2 logarithm of the alignment./// This is always exact, as `self` represents a power of two./// assert_eq!(Alignment::of::<u8>().log2(), 0);/// assert_eq!(Alignment::new(1024).unwrap().log2(), 10);/// Returns a bit mask that can be used to match this alignment./// This is equivalent to `!(self.as_usize() - 1)`./// #![feature(ptr_mask)]/// use std::ptr::{Alignment, NonNull};/// #[repr(align(1))] struct Align1(u8);/// #[repr(align(2))] struct Align2(u16);/// #[repr(align(4))] struct Align4(u32);/// let one = <NonNull<Align1>>::dangling().as_ptr();/// let two = <NonNull<Align2>>::dangling().as_ptr();/// let four = <NonNull<Align4>>::dangling().as_ptr();/// assert_eq!(four.mask(Alignment::of::<Align1>().mask()), four);/// assert_eq!(four.mask(Alignment::of::<Align2>().mask()), four);/// assert_eq!(four.mask(Alignment::of::<Align4>().mask()), four);/// assert_ne!(one.mask(Alignment::of::<Align4>().mask()), one);// FIXME(const-hack) Remove me once `Ord::max` is usable in const/// Returns [`Alignment::MIN`], which is valid for any type._Align1Shl0_Align1Shl1_Align1Shl2_Align1Shl3_Align1Shl4_Align1Shl5_Align1Shl6_Align1Shl7_Align1Shl8_Align1Shl9_Align1Shl10_Align1Shl11_Align1Shl12_Align1Shl13_Align1Shl14_Align1Shl15_Align1Shl16_Align1Shl17_Align1Shl18_Align1Shl19_Align1Shl20_Align1Shl21_Align1Shl22_Align1Shl23_Align1Shl24_Align1Shl25_Align1Shl26_Align1Shl27_Align1Shl28_Align1Shl29_Align1Shl30_Align1Shl31_Align1Shl32_Align1Shl33_Align1Shl34_Align1Shl35_Align1Shl36_Align1Shl37_Align1Shl38_Align1Shl39_Align1Shl40_Align1Shl41_Align1Shl42_Align1Shl43_Align1Shl44_Align1Shl45_Align1Shl46_Align1Shl47_Align1Shl48_Align1Shl49_Align1Shl50_Align1Shl51_Align1Shl52_Align1Shl53_Align1Shl54_Align1Shl55_Align1Shl56_Align1Shl57_Align1Shl58_Align1Shl59_Align1Shl60_Align1Shl61_Align1Shl62_Align1Shl63"ptr_const_is_null"/// let s: &str = "Follow the rabbit";/// let ptr: *const u8 = s.as_ptr();/// assert!(!ptr.is_null());"const_ptr_cast"/// Casts to a pointer of another type.try_cast_aligned/// Try to cast to a pointer of another type by checking alignment./// If the pointer is properly aligned to the target type, it will be/// cast to the target type. Otherwise, `None` is returned./// #![feature(pointer_try_cast_aligned)]/// let x = 0u64;/// let aligned: *const u64 = &x;/// let unaligned = unsafe { aligned.byte_add(1) };/// assert!(aligned.try_cast_aligned::<u32>().is_some());/// assert!(unaligned.try_cast_aligned::<u32>().is_none());with_metadata_of/// Uses the address value in a new pointer of another type./// This operation will ignore the address part of its `meta` operand and discard existing/// metadata of `self`. For pointers to a sized types (thin pointers), this has the same effect/// as a simple cast. For pointers to an unsized type (fat pointers) this recombines the address/// with new metadata such as slice lengths or `dyn`-vtable./// The resulting pointer will have provenance of `self`. This operation is semantically the/// same as creating a new pointer with the data pointer value of `self` but the metadata of/// `meta`, being fat or thin depending on the `meta` operand./// This function is primarily useful for enabling pointer arithmetic on potentially fat/// pointers. The pointer is cast to a sized pointee to utilize offset operations and then/// recombined with its own original metadata./// #![feature(set_ptr_value)]/// let arr: [i32; 3] = [1, 2, 3];/// let mut ptr = arr.as_ptr() as *const dyn Debug;/// let thin = ptr as *const u8;///     ptr = thin.add(8).with_metadata_of(ptr);///     # assert_eq!(*(ptr as *const i32), 3);///     println!("{:?}", &*ptr); // will print "3"/// # *Incorrect* usage/// The provenance from pointers is *not* combined. The result must only be used to refer to the/// address allowed by `self`./// let x = 0u32;/// let y = 1u32;/// let x = (&x) as *const u32;/// let y = (&y) as *const u32;/// let offset = (x as usize - y as usize) / 4;/// let bad = x.wrapping_add(offset).with_metadata_of(y);/// // This dereference is UB. The pointer only has provenance for `x` but points to `y`./// println!("{:?}", unsafe { &*bad });"ptr_cast_mut"/// Changes constness without changing the type./// This is a bit safer than `as` because it wouldn't silently change the type if the code is/// refactored./// Exposes the ["provenance"][crate::ptr#provenance] part of the pointer for future use in/// [`with_exposed_provenance`] and returns the "address" portion./// This is equivalent to `self as usize`, which semantically discards provenance information./// Furthermore, this (like the `as` cast) has the implicit side-effect of marking the/// provenance as 'exposed', so on platforms that support it you can later call/// [`with_exposed_provenance`] to reconstitute the original pointer including its provenance./// Due to its inherent ambiguity, [`with_exposed_provenance`] may not be supported by tools/// that help you to stay conformant with the Rust memory model. It is recommended to use/// [Strict Provenance][crate::ptr#strict-provenance] APIs such as [`with_addr`][pointer::with_addr]/// wherever possible, in which case [`addr`][pointer::addr] should be used instead of `expose_provenance`./// On most platforms this will produce a value with the same bytes as the original pointer,/// because all the bytes are dedicated to describing the address. Platforms which need to store/// additional information in the pointer may not support this operation, since the 'expose'/// side-effect which is required for [`with_exposed_provenance`] to work is typically not/// This is an [Exposed Provenance][crate::ptr#exposed-provenance] API./// [`with_exposed_provenance`]: with_exposed_provenance/// Creates a new pointer with the given address and the [provenance][crate::ptr#provenance] of/// This is similar to a `addr as *const T` cast, but copies/// the *provenance* of `self` to the new pointer./// This avoids the inherent ambiguity of the unary cast./// This is equivalent to using [`wrapping_offset`][pointer::wrapping_offset] to offset/// `self` to the given address, and therefore has all the same capabilities and restrictions./// This is a [Strict Provenance][crate::ptr#strict-provenance] API./// Creates a new pointer by mapping `self`'s address to a new one, preserving the/// [provenance][crate::ptr#provenance] of `self`./// This is a convenience for [`with_addr`][pointer::with_addr], see that method for details./// Decompose a (possibly wide) pointer into its data pointer and metadata components./// The pointer can be later reconstructed with [`from_raw_parts`]./// let ptr: *const u8 = &10u8 as *const u8;///     let val_back = &*ptr;///     assert_eq!(val_back, &10);///     if let Some(val_back) = ptr.as_ref() {///         assert_eq!(val_back, &10);/// [`is_null`]: #method.is_null/// [`as_uninit_ref`]: #method.as_uninit_ref/// Returns a shared reference to the value behind the pointer./// If the pointer may be null or the value may be uninitialized, [`as_uninit_ref`] must be used instead./// If the pointer may be null, but the value is known to have been initialized, [`as_ref`] must be used instead./// [`as_ref`]: #method.as_ref/// When calling this method, you have to ensure that/// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)./// #![feature(ptr_as_ref_unchecked)]///     assert_eq!(ptr.as_ref_unchecked(), &10);// FIXME: mention it in the docs for `as_ref` and `as_uninit_ref` once stabilized.as_uninit_ref/// #![feature(ptr_as_uninit)]///     if let Some(val_back) = ptr.as_uninit_ref() {///         assert_eq!(val_back.assume_init(), 10);/// let s: &str = "123";///     assert_eq!(*ptr.offset(1) as char, '2');///     assert_eq!(*ptr.offset(2) as char, '3');/// Adds a signed offset in bytes to a pointer./// `count` is in units of **bytes**./// This is purely a convenience for casting to a `u8` pointer and/// using [offset][pointer::offset] on it. See that method for documentation/// and safety requirements./// For non-`Sized` pointees this operation changes only the data pointer,/// leaving the metadata untouched./// Adds a signed offset to a pointer using wrapping arithmetic./// `count` is in units of T; e.g., a `count` of 3 represents a pointer/// This operation itself is always safe, but using the resulting pointer is not./// The resulting pointer "remembers" the [allocation] that `self` points to/// (this is called "[Provenance](ptr/index.html#provenance)")./// The pointer must not be used to read or write other allocations./// In other words, `let z = x.wrapping_offset((y as isize) - (x as isize))` does *not* make `z`/// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still/// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless/// `x` and `y` point into the same allocation./// Compared to [`offset`], this method basically delays the requirement of staying within the/// same allocation: [`offset`] is immediate Undefined Behavior when crossing object/// boundaries; `wrapping_offset` produces a pointer but still leads to Undefined Behavior if a/// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`offset`]/// can be optimized better and is thus preferable in performance-sensitive code./// The delayed check only considers the value of the pointer that was dereferenced, not the/// intermediate values used during the computation of the final result. For example,/// `x.wrapping_offset(o).wrapping_offset(o.wrapping_neg())` is always the same as `x`. In other/// words, leaving the allocation and then re-entering it later is permitted./// [`offset`]: #method.offset/// [allocation]: crate::ptr#allocation/// // Iterate using a raw pointer in increments of two elements/// let data = [1u8, 2, 3, 4, 5];/// let mut ptr: *const u8 = data.as_ptr();/// let step = 2;/// let end_rounded_up = ptr.wrapping_offset(6);/// let mut out = String::new();/// while ptr != end_rounded_up {///         write!(&mut out, "{}, ", *ptr)?;///     ptr = ptr.wrapping_offset(step);/// assert_eq!(out.as_str(), "1, 3, 5, ");wrapping_byte_offset/// Adds a signed offset in bytes to a pointer using wrapping arithmetic./// using [wrapping_offset][pointer::wrapping_offset] on it. See that method/// for documentation./// This is convenience for `ptr.map_addr(|a| a & mask)`./// let v = 17_u32;/// let ptr: *const u32 = &v;/// // `u32` is 4 bytes aligned,/// // which means that lower 2 bits are always 0./// let tag_mask = 0b11;/// let ptr_mask = !tag_mask;/// // We can store something in these lower bits/// let tagged_ptr = ptr.map_addr(|a| a | 0b10);/// // Get the "tag" back/// let tag = tagged_ptr.addr() & tag_mask;/// assert_eq!(tag, 0b10);/// // Note that `tagged_ptr` is unaligned, it's UB to read from it./// // To get original pointer `mask` can be used:/// let masked_ptr = tagged_ptr.mask(ptr_mask);/// assert_eq!(unsafe { *masked_ptr }, 17);/// Calculates the distance between two pointers within the same allocation. The returned value is in/// units of T: the distance in bytes divided by `size_of::<T>()`./// This is equivalent to `(self as isize - origin as isize) / (size_of::<T>() as isize)`,/// except that it has a lot more opportunities for UB, in exchange for the compiler/// better understanding what you are doing./// The primary motivation of this method is for computing the `len` of an array/slice/// of `T` that you are currently representing as a "start" and "end" pointer/// (and "end" is "one past the end" of the array)./// In that case, `end.offset_from(start)` gets you the length of the array./// All of the following safety requirements are trivially satisfied for this usecase./// If any of the following conditions are violated, the result is Undefined Behavior:/// * `self` and `origin` must either///   * point to the same address, or///   * both be [derived from][crate::ptr#provenance] a pointer to the same [allocation], and the memory range between///     the two pointers must be in bounds of that object. (See below for an example.)/// * The distance between the pointers, in bytes, must be an exact multiple///   of the size of `T`./// As a consequence, the absolute distance between the pointers, in bytes, computed on/// mathematical integers (without "wrapping around"), cannot overflow an `isize`. This is/// implied by the in-bounds requirement, and the fact that no allocation can be larger/// than `isize::MAX` bytes./// The requirement for pointers to be derived from the same allocation is primarily/// needed for `const`-compatibility: the distance between pointers into *different* allocated/// objects is not known at compile-time. However, the requirement also exists at/// runtime and may be exploited by optimizations. If you wish to compute the difference between/// pointers that are not guaranteed to be from the same allocation, use `(self as isize -/// origin as isize) / size_of::<T>()`.// FIXME: recommend `addr()` instead of `as usize` once that is stable./// [`add`]: #method.add/// This function panics if `T` is a Zero-Sized Type ("ZST")./// let a = [0; 5];/// let ptr1: *const i32 = &a[1];/// let ptr2: *const i32 = &a[3];///     assert_eq!(ptr2.offset_from(ptr1), 2);///     assert_eq!(ptr1.offset_from(ptr2), -2);///     assert_eq!(ptr1.offset(2), ptr2);///     assert_eq!(ptr2.offset(-2), ptr1);/// *Incorrect* usage:/// let ptr1 = Box::into_raw(Box::new(0u8)) as *const u8;/// let ptr2 = Box::into_raw(Box::new(1u8)) as *const u8;/// let diff = (ptr2 as isize).wrapping_sub(ptr1 as isize);/// // Make ptr2_other an "alias" of ptr2.add(1), but derived from ptr1./// let ptr2_other = (ptr1 as *const u8).wrapping_offset(diff).wrapping_offset(1);/// assert_eq!(ptr2 as usize, ptr2_other as usize);/// // Since ptr2_other and ptr2 are derived from pointers to different objects,/// // computing their offset is undefined behavior, even though/// // they point to addresses that are in-bounds of the same object!///     let one = ptr2_other.offset_from(ptr2); // Undefined Behavior! ⚠️byte_offset_from/// units of **bytes**./// using [`offset_from`][pointer::offset_from] on it. See that method for/// documentation and safety requirements./// For non-`Sized` pointees this operation considers only the data pointers,/// ignoring the metadata.offset_from_unsigned/// Calculates the distance between two pointers within the same allocation, *where it's known that/// `self` is equal to or greater than `origin`*. The returned value is in/// units of T: the distance in bytes is divided by `size_of::<T>()`./// This computes the same value that [`offset_from`](#method.offset_from)/// would compute, but with the added precondition that the offset is/// guaranteed to be non-negative.  This method is equivalent to/// `usize::try_from(self.offset_from(origin)).unwrap_unchecked()`,/// but it provides slightly more information to the optimizer, which can/// sometimes allow it to optimize slightly better with some backends./// This method can be thought of as recovering the `count` that was passed/// to [`add`](#method.add) (or, with the parameters in the other order,/// to [`sub`](#method.sub)).  The following are all equivalent, assuming/// that their safety preconditions are met:/// # unsafe fn blah(ptr: *const i32, origin: *const i32, count: usize) -> bool { unsafe {/// ptr.offset_from_unsigned(origin) == count/// # &&/// origin.add(count) == ptr/// ptr.sub(count) == origin/// # } }/// - The distance between the pointers must be non-negative (`self >= origin`)/// - *All* the safety conditions of [`offset_from`](#method.offset_from)///   apply to this method as well; see it for the full details./// Importantly, despite the return type of this method being able to represent/// a larger offset, it's still *not permitted* to pass pointers which differ/// by more than `isize::MAX` *bytes*.  As such, the result of this method will/// always be less than or equal to `isize::MAX as usize`.///     assert_eq!(ptr2.offset_from_unsigned(ptr1), 2);///     assert_eq!(ptr1.add(2), ptr2);///     assert_eq!(ptr2.sub(2), ptr1);///     assert_eq!(ptr2.offset_from_unsigned(ptr2), 0);/// // This would be incorrect, as the pointers are not correctly ordered:/// // ptr1.offset_from_unsigned(ptr2)byte_offset_from_unsigned/// using [`offset_from_unsigned`][pointer::offset_from_unsigned] on it./// See that method for documentation and safety requirements.guaranteed_eq/// Returns whether two pointers are guaranteed to be equal./// At runtime this function behaves like `Some(self == other)`./// However, in some contexts (e.g., compile-time evaluation),/// it is not always possible to determine equality of two pointers, so this function may/// spuriously return `None` for pointers that later actually turn out to have its equality known./// But when it returns `Some`, the pointers' equality is guaranteed to be known./// The return value may change from `Some` to `None` and vice versa depending on the compiler/// version and unsafe code must not/// rely on the result of this function for soundness. It is suggested to only use this function/// for performance optimizations where spurious `None` return values by this function do not/// affect the outcome, but just the performance./// The consequences of using this method to make runtime and compile-time code behave/// differently have not been explored. This method should not be used to introduce such/// differences, and it should also not be stabilized before we have a better understanding/// of this issue.guaranteed_ne/// Returns whether two pointers are guaranteed to be inequal./// At runtime this function behaves like `Some(self != other)`./// it is not always possible to determine inequality of two pointers, so this function may/// spuriously return `None` for pointers that later actually turn out to have its inequality known./// But when it returns `Some`, the pointers' inequality is guaranteed to be known.///     assert_eq!(*ptr.add(1), b'2');///     assert_eq!(*ptr.add(2), b'3');byte_add/// Adds an unsigned offset in bytes to a pointer./// `count` is in units of bytes./// using [add][pointer::add] on it. See that method for documentation/// Subtracts an unsigned offset from a pointer./// This can only move the pointer backward (or not move it). If you need to move forward or/// backward depending on the value, then you might want [`offset`](#method.offset) instead/// which takes a signed offset./// * The offset in bytes, `count * size_of::<T>()`, computed on mathematical integers (without///   "wrapping around"), must fit in an `isize`./// * If the computed offset is non-zero, then `self` must be [derived from][crate::ptr#provenance] a pointer to some///   [allocation], and the entire memory range between `self` and the result must be in///   bounds of that allocation. In particular, this range must not "wrap around" the edge///   of the address space./// Allocations can never be larger than `isize::MAX` bytes, so if the computed offset/// stays in bounds of the allocation, it is guaranteed to satisfy the first requirement./// This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always/// safe./// Consider using [`wrapping_sub`] instead if these constraints are/// difficult to satisfy. The only advantage of this method is that it/// enables more aggressive compiler optimizations./// [`wrapping_sub`]: #method.wrapping_sub///     let end: *const u8 = s.as_ptr().add(3);///     assert_eq!(*end.sub(1), b'3');///     assert_eq!(*end.sub(2), b'2');byte_sub/// Subtracts an unsigned offset in bytes from a pointer./// using [sub][pointer::sub] on it. See that method for documentation/// Adds an unsigned offset to a pointer using wrapping arithmetic./// The resulting pointer "remembers" the [allocation] that `self` points to; it must not/// be used to read or write other allocations./// In other words, `let z = x.wrapping_add((y as usize) - (x as usize))` does *not* make `z`/// Compared to [`add`], this method basically delays the requirement of staying within the/// same allocation: [`add`] is immediate Undefined Behavior when crossing object/// boundaries; `wrapping_add` produces a pointer but still leads to Undefined Behavior if a/// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`add`]/// `x.wrapping_add(o).wrapping_sub(o)` is always the same as `x`. In other words, leaving the/// allocation and then re-entering it later is permitted./// let end_rounded_up = ptr.wrapping_add(6);///     ptr = ptr.wrapping_add(step);/// assert_eq!(out, "1, 3, 5, ");wrapping_byte_add/// Adds an unsigned offset in bytes to a pointer using wrapping arithmetic./// using [wrapping_add][pointer::wrapping_add] on it. See that method for documentation./// Subtracts an unsigned offset from a pointer using wrapping arithmetic./// In other words, `let z = x.wrapping_sub((x as usize) - (y as usize))` does *not* make `z`/// Compared to [`sub`], this method basically delays the requirement of staying within the/// same allocation: [`sub`] is immediate Undefined Behavior when crossing object/// boundaries; `wrapping_sub` produces a pointer but still leads to Undefined Behavior if a/// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`sub`]/// [`sub`]: #method.sub/// // Iterate using a raw pointer in increments of two elements (backwards)/// let start_rounded_down = ptr.wrapping_sub(2);/// ptr = ptr.wrapping_add(4);/// while ptr != start_rounded_down {///     ptr = ptr.wrapping_sub(step);/// assert_eq!(out, "5, 3, 1, ");wrapping_byte_sub/// Subtracts an unsigned offset in bytes from a pointer using wrapping arithmetic./// using [wrapping_sub][pointer::wrapping_sub] on it. See that method for documentation./// Reads the value from `self` without moving it. This leaves the/// See [`ptr::read`] for safety concerns and examples./// [`ptr::read`]: crate::ptr::read()/// Performs a volatile read of the value from `self` without moving it. This/// leaves the memory in `self` unchanged./// Volatile operations are intended to act on I/O memory, and are guaranteed/// to not be elided or reordered by the compiler across other volatile/// See [`ptr::read_volatile`] for safety concerns and examples./// [`ptr::read_volatile`]: crate::ptr::read_volatile()/// Unlike `read`, the pointer may be unaligned./// See [`ptr::read_unaligned`] for safety concerns and examples./// [`ptr::read_unaligned`]: crate::ptr::read_unaligned()/// Copies `count * size_of::<T>()` bytes from `self` to `dest`. The source/// and destination may overlap./// NOTE: this has the *same* argument order as [`ptr::copy`]./// See [`ptr::copy`] for safety concerns and examples./// [`ptr::copy`]: crate::ptr::copy()/// NOTE: this has the *same* argument order as [`ptr::copy_nonoverlapping`]./// See [`ptr::copy_nonoverlapping`] for safety concerns and examples./// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping()/// Computes the offset that needs to be applied to the pointer in order to make it aligned to/// `align`./// If it is not possible to align the pointer, the implementation returns/// `usize::MAX`./// The offset is expressed in number of `T` elements, and not bytes. The value returned can be/// used with the `wrapping_add` method./// There are no guarantees whatsoever that offsetting the pointer will not overflow or go/// beyond the allocation that the pointer points into. It is up to the caller to ensure that/// the returned offset is correct in all terms other than alignment./// The function panics if `align` is not a power-of-two./// Accessing adjacent `u8` as `u16`/// # unsafe {/// let x = [5_u8, 6, 7, 8, 9];/// let ptr = x.as_ptr();/// let offset = ptr.align_offset(align_of::<u16>());/// if offset < x.len() - 1 {///     let u16_ptr = ptr.add(offset).cast::<u16>();///     assert!(*u16_ptr == u16::from_ne_bytes([5, 6]) || *u16_ptr == u16::from_ne_bytes([6, 7]));///     // while the pointer can be aligned via `offset`, it would point///     // outside the allocation/// Returns whether the pointer is properly aligned for `T`./// // On some platforms, the alignment of i32 is less than 4./// #[repr(align(4))]/// struct AlignedI32(i32);/// let data = AlignedI32(42);/// let ptr = &data as *const AlignedI32;/// assert!(ptr.is_aligned());/// assert!(!ptr.wrapping_byte_add(1).is_aligned());/// Returns whether the pointer is aligned to `align`./// For non-`Sized` pointees this operation considers only the data pointer,/// The function panics if `align` is not a power-of-two (this includes 0)./// #![feature(pointer_is_aligned_to)]/// assert!(ptr.is_aligned_to(1));/// assert!(ptr.is_aligned_to(2));/// assert!(ptr.is_aligned_to(4));/// assert!(ptr.wrapping_byte_add(2).is_aligned_to(2));/// assert!(!ptr.wrapping_byte_add(2).is_aligned_to(4));/// assert_ne!(ptr.is_aligned_to(8), ptr.wrapping_add(1).is_aligned_to(8));cast_uninit/// Casts from a type to its maybe-uninitialized version.cast_init/// Casts from a maybe-uninitialized type to its initialized version./// This is always safe, since UB can only occur if the pointer is read/// before being initialized./// Returns the length of a raw slice./// The returned value is the number of **elements**, not the number of bytes./// This function is safe, even when the raw slice cannot be cast to a slice/// reference because the pointer is null or unaligned./// let slice: *const [i8] = ptr::slice_from_raw_parts(ptr::null(), 3);/// assert_eq!(slice.len(), 3);/// Returns `true` if the raw slice has a length of 0./// assert!(!slice.is_empty());/// Returns a raw pointer to the slice's buffer./// This is equivalent to casting `self` to `*const T`, but more type-safe./// #![feature(slice_ptr_get)]/// assert_eq!(slice.as_ptr(), ptr::null());/// Gets a raw pointer to the underlying array./// Returns a raw pointer to an element or subslice, without doing bounds/// Calling this method with an out-of-bounds index or when `self` is not dereferenceable/// is *[undefined behavior]* even if the resulting pointer is not used./// let x = &[1, 2, 4] as *const [i32];///     assert_eq!(x.get_unchecked(1), x.as_ptr().add(1));as_uninit_slicecast_array/// Casts from a pointer-to-`T` to a pointer-to-`[T; N]`./// Returns a raw pointer to the array's buffer./// #![feature(array_ptr_get)]/// let arr: *const [i8; 3] = ptr::null();/// assert_eq!(arr.as_ptr(), ptr::null());/// Returns a raw pointer to a slice containing the entire array./// let arr: *const [i32; 3] = &[1, 2, 4] as *const [i32; 3];/// let slice: *const [i32] = arr.as_slice();on_const/// Pointer equality is by address, as produced by the [`<*const T>::addr`](pointer::addr) method./// Pointer equality is an equivalence relation./// Pointer comparison is by address, as produced by the `[`<*const T>::addr`](pointer::addr)` method./// Returns the default value of [`null()`][crate::ptr::null]."metadata_type"/// The type for metadata in pointers and references to `Self`.// NOTE: Keep trait bounds in `static_assert_expected_bounds_for_metadata`// in `library/core/src/ptr/metadata.rs`// in sync with those here:// NOTE: The metadata of `dyn Trait + 'a` is `DynMetadata<dyn Trait + 'a>`// so a `'static` bound must not be added."pointee_trait"/// Provides the pointer metadata type of any pointed-to type./// # Pointer metadata/// Raw pointer types and reference types in Rust can be thought of as made of two parts:/// a data pointer that contains the memory address of the value, and some metadata./// For statically-sized types (that implement the `Sized` traits)/// as well as for `extern` types,/// pointers are said to be “thin”: metadata is zero-sized and its type is `()`./// Pointers to [dynamically-sized types][dst] are said to be “wide” or “fat”,/// they have non-zero-sized metadata:/// * For structs whose last field is a DST, metadata is the metadata for the last field/// * For the `str` type, metadata is the length in bytes as `usize`/// * For slice types like `[T]`, metadata is the length in items as `usize`/// * For trait objects like `dyn SomeTrait`, metadata is [`DynMetadata<Self>`][DynMetadata]///   (e.g. `DynMetadata<dyn SomeTrait>`)/// In the future, the Rust language may gain new kinds of types/// that have different pointer metadata./// [dst]: https://doc.rust-lang.org/nomicon/exotic-sizes.html#dynamically-sized-types-dsts/// # The `Pointee` trait/// The point of this trait is its `Metadata` associated type,/// which is `()` or `usize` or `DynMetadata<_>` as described above./// It is automatically implemented for every type./// It can be assumed to be implemented in a generic context, even without a corresponding bound./// Raw pointers can be decomposed into the data pointer and metadata components/// with their [`to_raw_parts`] method./// Alternatively, metadata alone can be extracted with the [`metadata`] function./// A reference can be passed to [`metadata`] and implicitly coerced./// A (possibly-wide) pointer can be put back together from its data pointer and metadata/// with [`from_raw_parts`] or [`from_raw_parts_mut`]./// [`to_raw_parts`]: *const::to_raw_parts// NOTE: don’t stabilize this before trait aliases are stable in the language?/// Extracts the metadata component of a pointer./// Values of type `*mut T`, `&T`, or `&mut T` can be passed directly to this function/// as they implicitly coerce to `*const T`./// #![feature(ptr_metadata)]/// assert_eq!(std::ptr::metadata("foo"), 3_usize);/// Forms a (possibly-wide) raw pointer from a data pointer and metadata./// This function is safe but the returned pointer is not necessarily safe to dereference./// For slices, see the documentation of [`slice::from_raw_parts`] for safety requirements./// For trait objects, the metadata must come from a pointer to the same underlying erased type./// If you are attempting to deconstruct a DST in a generic context to be reconstructed later,/// a thin pointer can always be obtained by casting `*const T` to `*const ()`./// [`slice::from_raw_parts`]: crate::slice::from_raw_parts/// Performs the same functionality as [`from_raw_parts`], except that a/// raw `*mut` pointer is returned, as opposed to a raw `*const` pointer./// See the documentation of [`from_raw_parts`] for more details."dyn_metadata"_vtable_ptrVTableDynMetadata/// The metadata for a `Dyn = dyn SomeTrait` trait object type./// It is a pointer to a vtable (virtual call table)/// that represents all the necessary information/// to manipulate the concrete type stored inside a trait object./// The vtable notably contains:/// * type size/// * type alignment/// * a pointer to the type’s `drop_in_place` impl (may be a no-op for plain-old-data)/// * pointers to all the methods for the type’s implementation of the trait/// Note that the first three are special because they’re necessary to allocate, drop,/// and deallocate any trait object./// It is possible to name this struct with a type parameter that is not a `dyn` trait object/// (for example `DynMetadata<u64>`) but not to obtain a meaningful value of that struct./// Note that while this type implements `PartialEq`, comparing vtable pointers is unreliable:/// pointers to vtables of the same type for the same trait can compare inequal (because vtables are/// duplicated in multiple codegen units), and pointers to vtables of *different* types/traits can/// compare equal (since identical vtables can be deduplicated within a codegen unit)./// Opaque type for accessing vtables./// Private implementation detail of `DynMetadata::size_of` etc./// There is conceptually not actually any Abstract Machine memory behind this pointer.vtable_ptr/// When `DynMetadata` appears as the metadata field of a wide pointer, the rustc_middle layout/// computation does magic and the resulting layout is *not* a `FieldsShape::Aggregate`, instead/// it is a `FieldsShape::Primitive`. This means that the same type can have different layout/// depending on whether it appears as the metadata field of a wide pointer or as a stand-alone/// type, which understandably confuses codegen and leads to ICEs when trying to project to a/// field of `DynMetadata`. To work around that issue, we use `transmute` instead of using a/// field projection./// Returns the size of the type associated with this vtable./// Returns the alignment of the type associated with this vtable./// Returns the size and alignment together as a `Layout`/// Pointers to types implementing this trait alias are “thin”./// This includes statically-`Sized` types and `extern` types./// fn this_never_panics<T: std::ptr::Thin>() {///     assert_eq!(size_of::<&T>(), size_of::<usize>())// Manual impls needed to avoid `Dyn: $Trait` bounds.const_ptr"ptr_copy_nonoverlapping"/// Copies `count * size_of::<T>()` bytes from `src` to `dst`. The source/// and destination must *not* overlap./// For regions of memory which might overlap, use [`copy`] instead./// `copy_nonoverlapping` is semantically equivalent to C's [`memcpy`], but/// with the source and destination arguments swapped,/// and `count` counting the number of `T`s instead of bytes./// The copy is "untyped" in the sense that data may be uninitialized or otherwise violate the/// requirements of `T`. The initialization state is preserved exactly./// [`memcpy`]: https://en.cppreference.com/w/c/string/byte/memcpy/// * `src` must be [valid] for reads of `count * size_of::<T>()` bytes./// * `dst` must be [valid] for writes of `count * size_of::<T>()` bytes./// * Both `src` and `dst` must be properly aligned./// * The region of memory beginning at `src` with a size of `count *///   size_of::<T>()` bytes must *not* overlap with the region of memory///   beginning at `dst` with the same size./// in the region beginning at `*src` and the region beginning at `*dst` can/// [violate memory safety][read-ownership]./// Note that even if the effectively copied size (`count * size_of::<T>()`) is/// `0`, the pointers must be properly aligned./// [`read`]: crate::ptr::read/// [read-ownership]: crate::ptr::read#ownership-of-the-returned-value/// Manually implement [`Vec::append`]:/// /// Moves all the elements of `src` into `dst`, leaving `src` empty./// fn append<T>(dst: &mut Vec<T>, src: &mut Vec<T>) {///     let src_len = src.len();///     let dst_len = dst.len();///     // Ensure that `dst` has enough capacity to hold all of `src`.///     dst.reserve(src_len);///         // The call to add is always safe because `Vec` will never///         // allocate more than `isize::MAX` bytes.///         let dst_ptr = dst.as_mut_ptr().add(dst_len);///         let src_ptr = src.as_ptr();///         // Truncate `src` without dropping its contents. We do this first,///         // to avoid problems in case something further down panics.///         src.set_len(0);///         // The two regions cannot overlap because mutable references do///         // not alias, and two different vectors cannot own the same///         // memory.///         ptr::copy_nonoverlapping(src_ptr, dst_ptr, src_len);///         // Notify `dst` that it now holds the contents of `src`.///         dst.set_len(dst_len + src_len);/// let mut a = vec!['r'];/// let mut b = vec!['u', 's', 't'];/// append(&mut a, &mut b);/// assert_eq!(a, &['r', 'u', 's', 't']);/// [`Vec::append`]: ../../std/vec/struct.Vec.html#method.append"ptr_copy"/// If the source and destination will *never* overlap,/// [`copy_nonoverlapping`] can be used instead./// `copy` is semantically equivalent to C's [`memmove`], but/// Copying takes place as if the bytes were copied from `src`/// to a temporary array and then copied from the array to `dst`./// [`memmove`]: https://en.cppreference.com/w/c/string/byte/memmove/// * `dst` must be [valid] for writes of `count * size_of::<T>()` bytes, and must remain valid even///   when `src` is read for `count * size_of::<T>()` bytes. (This means if the memory ranges///   overlap, the `dst` pointer must not be invalidated by `src` reads.)/// Like [`read`], `copy` creates a bitwise copy of `T`, regardless of/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the values/// Efficiently create a Rust vector from an unsafe buffer:/// /// * `ptr` must be correctly aligned for its type and non-zero./// /// * `ptr` must be valid for reads of `elts` contiguous elements of type `T`./// /// * Those elements must not be used after calling this function unless `T: Copy`./// unsafe fn from_buf_raw<T>(ptr: *const T, elts: usize) -> Vec<T> {///     let mut dst = Vec::with_capacity(elts);///     // SAFETY: Our precondition ensures the source is aligned and valid,///     // and `Vec::with_capacity` ensures that we have usable space to write them.///     unsafe { ptr::copy(ptr, dst.as_mut_ptr(), elts); }///     // SAFETY: We created it with this much capacity earlier,///     // and the previous `copy` has initialized these elements.///     unsafe { dst.set_len(elts); }///     dst"ptr_write_bytes"/// Sets `count * size_of::<T>()` bytes of memory starting at `dst` to/// `write_bytes` is similar to C's [`memset`], but sets `count */// size_of::<T>()` bytes to `val`./// [`memset`]: https://en.cppreference.com/w/c/string/byte/memset/// * `dst` must be properly aligned./// `0`, the pointer must be properly aligned./// Additionally, note that changing `*dst` in this way can easily lead to undefined behavior (UB)/// later if the written bytes are not a valid representation of some `T`. For instance, the/// following is an **incorrect** use of this function:///     let mut value: u8 = 0;///     let ptr: *mut bool = &mut value as *mut u8 as *mut bool;///     let _bool = ptr.read(); // This is fine, `ptr` points to a valid `bool`.///     ptr.write_bytes(42u8, 1); // This function itself does not cause UB...///     let _bool = ptr.read(); // ...but it makes this operation UB! ⚠️/// let mut vec = vec![0u32; 4];///     let vec_ptr = vec.as_mut_ptr();///     ptr::write_bytes(vec_ptr, 0xfe, 2);/// assert_eq!(vec, [0xfefefefe, 0xfefefefe, 0, 0]);"drop_in_place""ptr_drop_in_place"/// Executes the destructor (if any) of the pointed-to value./// This is almost the same as calling [`ptr::read`] and discarding/// the result, but has the following advantages:// FIXME: say something more useful than "almost the same"?// There are open questions here: `read` requires the value to be fully valid, e.g. if `T` is a// `bool` it must be 0 or 1, if it is a reference then it must be dereferenceable. `drop_in_place`// only requires that `*to_drop` be "valid for dropping" and we have not defined what that means. In// Miri it currently (May 2024) requires nothing at all for types without drop glue./// * It is *required* to use `drop_in_place` to drop unsized types like///   trait objects, because they can't be read out onto the stack and///   dropped normally./// * It is friendlier to the optimizer to do this over [`ptr::read`] when///   dropping manually allocated memory (e.g., in the implementations of///   `Box`/`Rc`/`Vec`), as the compiler doesn't need to prove that it's///   sound to elide the copy./// * It can be used to drop [pinned] data when `T` is not `repr(packed)`///   (pinned data must not be moved before it is dropped)./// Unaligned values cannot be dropped in place, they must be copied to an aligned/// location first using [`ptr::read_unaligned`]. For packed structs, this move is/// done automatically by the compiler. This means the fields of packed structs/// are not dropped in-place./// [`ptr::read`]: self::read/// [`ptr::read_unaligned`]: self::read_unaligned/// * `to_drop` must be [valid] for both reads and writes./// * `to_drop` must be properly aligned, even if `T` has size 0./// * `to_drop` must be nonnull, even if `T` has size 0./// * The value `to_drop` points to must be valid for dropping, which may mean///   it must uphold additional invariants. These invariants depend on the type///   of the value being dropped. For instance, when dropping a Box, the box's///   pointer to the heap must be valid./// * While `drop_in_place` is executing, the only way to access parts of///   `to_drop` is through the `&mut self` references supplied to the///   `Drop::drop` methods that `drop_in_place` invokes./// Additionally, if `T` is not [`Copy`], using the pointed-to value after/// calling `drop_in_place` can cause undefined behavior. Note that `*to_drop =/// foo` counts as a use because it will cause the value to be dropped/// again. [`write()`] can be used to overwrite data without causing it to be/// [valid]: self#safety/// Manually remove the last item from a vector:/// let last = Rc::new(1);/// let weak = Rc::downgrade(&last);/// let mut v = vec![Rc::new(0), last];///     // Get a raw pointer to the last element in `v`.///     let ptr = &mut v[1] as *mut _;///     // Shorten `v` to prevent the last item from being dropped. We do that first,///     // to prevent issues if the `drop_in_place` below panics.///     v.set_len(1);///     // Without a call `drop_in_place`, the last item would never be dropped,///     // and the memory it manages would be leaked./// assert_eq!(v, &[0.into()]);/// // Ensure that the last item was dropped."ptr_null"/// Creates a null raw pointer./// This function is equivalent to zero-initializing the pointer:/// `MaybeUninit::<*const T>::zeroed().assume_init()`./// The resulting pointer has the address 0./// let p: *const i32 = ptr::null();/// assert_eq!(p as usize, 0); // this pointer has the address 0"ptr_null_mut"/// Creates a null mutable raw pointer./// `MaybeUninit::<*mut T>::zeroed().assume_init()`./// let p: *mut i32 = ptr::null_mut();/// Creates a pointer with the given address and no [provenance][crate::ptr#provenance]./// This is equivalent to `ptr::null().with_addr(addr)`./// Without provenance, this pointer is not associated with any actual allocation. Such a/// no-provenance pointer may be used for zero-sized memory accesses (if suitably aligned), but/// non-zero-sized memory accesses with a no-provenance pointer are UB. No-provenance pointers are/// little more than a `usize` address in disguise./// This is different from `addr as *const T`, which creates a pointer that picks up a previously/// exposed provenance. See [`with_exposed_provenance`] for more details on that operation./// Creates a new pointer that is dangling, but non-null and well-aligned./// This is useful for initializing types which lazily allocate, like/// `Vec::new` does.without_provenance_mut/// This is equivalent to `ptr::null_mut().with_addr(addr)`./// This is different from `addr as *mut T`, which creates a pointer that picks up a previously/// exposed provenance. See [`with_exposed_provenance_mut`] for more details on that operation.// Expected semantics here.dangling_mut/// Converts an address back to a pointer, picking up some previously 'exposed'/// [provenance][crate::ptr#provenance]./// This is fully equivalent to `addr as *const T`. The provenance of the returned pointer is that/// of *some* pointer that was previously exposed by passing it to/// [`expose_provenance`][pointer::expose_provenance], or a `ptr as usize` cast. In addition, memory/// which is outside the control of the Rust abstract machine (MMIO registers, for example) is/// always considered to be accessible with an exposed provenance, so long as this memory is disjoint/// from memory that will be used by the abstract machine such as the stack, heap, and statics./// The exact provenance that gets picked is not specified. The compiler will do its best to pick/// the "right" provenance for you (whatever that may be), but currently we cannot provide any/// guarantees about which provenance the resulting pointer will have -- and therefore there/// is no definite specification for which memory the resulting pointer may access./// If there is *no* previously 'exposed' provenance that justifies the way the returned pointer/// will be used, the program has undefined behavior. In particular, the aliasing rules still apply:/// pointers and references that have been invalidated due to aliasing accesses cannot be used/// anymore, even if they have been exposed!/// Due to its inherent ambiguity, this operation may not be supported by tools that help you to/// stay conformant with the Rust memory model. It is recommended to use [Strict/// Provenance][self#strict-provenance] APIs such as [`with_addr`][pointer::with_addr] wherever/// On most platforms this will produce a value with the same bytes as the address. Platforms/// which need to store additional information in a pointer may not support this operation,/// since it is generally not possible to actually *compute* which provenance the returned/// pointer has to pick up.// this *is* the explicit provenance API one should use instead/// Converts an address back to a mutable pointer, picking up some previously 'exposed'/// This is fully equivalent to `addr as *mut T`. The provenance of the returned pointer is that"ptr_from_ref"/// Converts a reference to a raw pointer./// For `r: &T`, `from_ref(r)` is equivalent to `r as *const T` (except for the caveat noted below),/// but is a bit safer since it will never silently change type or mutability, in particular if the/// code is refactored./// The caller must ensure that the pointee outlives the pointer this function returns, or else it/// will end up dangling./// The caller must also ensure that the memory the pointer (non-transitively) points to is never/// written to (except inside an `UnsafeCell`) using this pointer or any pointer derived from it. If/// you need to mutate the pointee, use [`from_mut`]. Specifically, to turn a mutable reference `m:/// &mut T` into `*const T`, prefer `from_mut(m).cast_const()` to obtain a pointer that can later be/// used for mutation./// ## Interaction with lifetime extension/// Note that this has subtle interactions with the rules for lifetime extension of temporaries in/// tail expressions. This code is valid, albeit in a non-obvious way:/// # fn foo() -> T { 42 }/// // The temporary holding the return value of `foo` has its lifetime extended,/// // because the surrounding expression involves no function call./// let p = &foo() as *const T;/// unsafe { p.read() };/// Naively replacing the cast with `from_ref` is not valid:/// // The temporary holding the return value of `foo` does *not* have its lifetime extended,/// // because the surrounding expression involves a function call./// let p = ptr::from_ref(&foo());/// unsafe { p.read() }; // UB! Reading from a dangling pointer ⚠️/// The recommended way to write this code is to avoid relying on lifetime extension/// when raw pointers are involved:/// let x = foo();/// let p = ptr::from_ref(&x);/// Converts a mutable reference to a raw pointer./// For `r: &mut T`, `from_mut(r)` is equivalent to `r as *mut T` (except for the caveat noted/// below), but is a bit safer since it will never silently change type or mutability, in particular/// if the code is refactored./// let p = &mut foo() as *mut T;/// unsafe { p.write(T::default()) };/// Naively replacing the cast with `from_mut` is not valid:/// let p = ptr::from_mut(&mut foo());/// unsafe { p.write(T::default()) }; // UB! Writing to a dangling pointer ⚠️/// let mut x = foo();/// let p = ptr::from_mut(&mut x);"ptr_slice_from_raw_parts"/// Forms a raw slice from a pointer and a length./// The `len` argument is the number of **elements**, not the number of bytes./// This function is safe, but actually using the return value is unsafe./// See the documentation of [`slice::from_raw_parts`] for slice safety requirements./// // create a slice pointer when starting out with a pointer to the first element/// let x = [5, 6, 7];/// let raw_pointer = x.as_ptr();/// let slice = ptr::slice_from_raw_parts(raw_pointer, 3);/// assert_eq!(unsafe { &*slice }[2], 7);/// You must ensure that the pointer is valid and not null before dereferencing/// the raw slice. A slice reference must never have a null pointer, even if it's empty./// let danger: *const [u8] = ptr::slice_from_raw_parts(ptr::null(), 0);///     danger.as_ref().expect("references must not be null");"ptr_slice_from_raw_parts_mut"/// Forms a raw mutable slice from a pointer and a length./// Performs the same functionality as [`slice_from_raw_parts`], except that a/// raw mutable slice is returned, as opposed to a raw immutable slice./// See the documentation of [`slice::from_raw_parts_mut`] for slice safety requirements./// [`slice::from_raw_parts_mut`]: crate::slice::from_raw_parts_mut/// let x = &mut [5, 6, 7];/// let raw_pointer = x.as_mut_ptr();/// let slice = ptr::slice_from_raw_parts_mut(raw_pointer, 3);///     (*slice)[2] = 99; // assign a value at an index in the slice/// assert_eq!(unsafe { &*slice }[2], 99);/// let danger: *mut [u8] = ptr::slice_from_raw_parts_mut(ptr::null_mut(), 0);///     danger.as_mut().expect("references must not be null");"ptr_swap"/// Swaps the values at two mutable locations of the same type, without/// deinitializing either./// But for the following exceptions, this function is semantically/// equivalent to [`mem::swap`]:/// * It operates on raw pointers instead of references. When references are///   available, [`mem::swap`] should be preferred./// * The two pointed-to values may overlap. If the values do overlap, then the///   overlapping region of memory from `x` will be used. This is demonstrated///   in the second example below./// * The operation is "untyped" in the sense that data may be uninitialized or otherwise violate///   the requirements of `T`. The initialization state is preserved exactly./// * Both `x` and `y` must be [valid] for both reads and writes. They must remain valid even when the///   other pointer is written. (This means if the memory ranges overlap, the two pointers must not///   be subject to aliasing restrictions relative to each other.)/// Note that even if `T` has size `0`, the pointers must be properly aligned./// Swapping two non-overlapping regions:/// let mut array = [0, 1, 2, 3];/// let (x, y) = array.split_at_mut(2);/// let x = x.as_mut_ptr().cast::<[u32; 2]>(); // this is `array[0..2]`/// let y = y.as_mut_ptr().cast::<[u32; 2]>(); // this is `array[2..4]`///     ptr::swap(x, y);///     assert_eq!([2, 3, 0, 1], array);/// Swapping two overlapping regions:/// let mut array: [i32; 4] = [0, 1, 2, 3];/// let array_ptr: *mut i32 = array.as_mut_ptr();/// let x = array_ptr as *mut [i32; 3]; // this is `array[0..3]`/// let y = unsafe { array_ptr.add(1) } as *mut [i32; 3]; // this is `array[1..4]`///     // The indices `1..3` of the slice overlap between `x` and `y`.///     // Reasonable results would be for to them be `[2, 3]`, so that indices `0..3` are///     // `[1, 2, 3]` (matching `y` before the `swap`); or for them to be `[0, 1]`///     // so that indices `1..4` are `[0, 1, 2]` (matching `x` before the `swap`).///     // This implementation is defined to make the latter choice.///     assert_eq!([1, 0, 1, 2], array);"ptr_swap_nonoverlapping"/// Swaps `count * size_of::<T>()` bytes between the two regions of memory/// beginning at `x` and `y`. The two regions must *not* overlap./// The operation is "untyped" in the sense that data may be uninitialized or otherwise violate the/// * Both `x` and `y` must be [valid] for both reads and writes of `count *///   size_of::<T>()` bytes./// * The region of memory beginning at `x` with a size of `count *///   beginning at `y` with the same size./// Note that even if the effectively copied size (`count * size_of::<T>()`) is `0`,/// the pointers must be properly aligned./// let mut x = [1, 2, 3, 4];/// let mut y = [7, 8, 9];///     ptr::swap_nonoverlapping(x.as_mut_ptr(), y.as_mut_ptr(), 2);/// assert_eq!(x, [7, 8, 3, 4]);/// assert_eq!(y, [1, 2, 9]);// both implementations behave the sameswap_nonoverlapping_const/// Same behavior and safety conditions as [`swap_nonoverlapping`]rustc_no_mir_inlineswap_chunk// Don't let MIR inline this, because we really want it to keep its noalias metadataswap_nonoverlapping_bytes"ptr_replace"/// Moves `src` into the pointed `dst`, returning the previous `dst` value./// This function is semantically equivalent to [`mem::replace`] except that it/// operates on raw pointers instead of references. When references are/// available, [`mem::replace`] should be preferred./// * `dst` must be [valid] for both reads and writes./// * `dst` must point to a properly initialized value of type `T`./// Note that even if `T` has size `0`, the pointer must be properly aligned./// let mut rust = vec!['b', 'u', 's', 't'];/// // `mem::replace` would have the same effect without requiring the unsafe/// // block./// let b = unsafe {///     ptr::replace(&mut rust[0], 'r')/// assert_eq!(b, 'b');/// assert_eq!(rust, &['r', 'u', 's', 't']);"ptr_read"/// Reads the value from `src` without moving it. This leaves the/// memory in `src` unchanged./// * `src` must be [valid] for reads./// * `src` must be properly aligned. Use [`read_unaligned`] if this is not the///   case./// * `src` must point to a properly initialized value of type `T`./// let y = &x as *const i32;///     assert_eq!(std::ptr::read(y), 12);/// Manually implement [`mem::swap`]:/// fn swap<T>(a: &mut T, b: &mut T) {///         // Create a bitwise copy of the value at `a` in `tmp`.///         let tmp = ptr::read(a);///         // Exiting at this point (either by explicitly returning or by///         // calling a function which panics) would cause the value in `tmp` to///         // be dropped while the same value is still referenced by `a`. This///         // could trigger undefined behavior if `T` is not `Copy`.///         // Create a bitwise copy of the value at `b` in `a`.///         // This is safe because mutable references cannot alias.///         ptr::copy_nonoverlapping(b, a, 1);///         // As above, exiting here could trigger undefined behavior because///         // the same value is referenced by `a` and `b`.///         // Move `tmp` into `b`.///         ptr::write(b, tmp);///         // `tmp` has been moved (`write` takes ownership of its second argument),///         // so nothing is dropped implicitly here./// let mut foo = "foo".to_owned();/// let mut bar = "bar".to_owned();/// swap(&mut foo, &mut bar);/// assert_eq!(foo, "bar");/// assert_eq!(bar, "foo");/// ## Ownership of the Returned Value/// `read` creates a bitwise copy of `T`, regardless of whether `T` is [`Copy`]./// If `T` is not [`Copy`], using both the returned value and the value at/// `*src` can violate memory safety. Note that assigning to `*src` counts as a/// use because it will attempt to drop the value at `*src`./// [`write()`] can be used to overwrite data without causing it to be dropped.///     // `s2` now points to the same underlying memory as `s`.///     let mut s2: String = ptr::read(&s);///     assert_eq!(s2, "foo");///     // Assigning to `s2` causes its original value to be dropped. Beyond///     // this point, `s` must no longer be used, as the underlying memory has///     // been freed.///     s2 = String::default();///     assert_eq!(s2, "");///     // Assigning to `s` would cause the old value to be dropped again,///     // resulting in undefined behavior.///     // s = String::from("bar"); // ERROR///     // `ptr::write` can be used to overwrite a value without dropping it.///     ptr::write(&mut s, String::from("bar"));/// assert_eq!(s, "bar");"ptr_read_unaligned"/// Unlike [`read`], `read_unaligned` works with unaligned pointers./// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned/// value and the value at `*src` can [violate memory safety][read-ownership]./// [read-ownership]: read#ownership-of-the-returned-value/// ## On `packed` structs/// Attempting to create a raw pointer to an `unaligned` struct field with/// an expression such as `&packed.unaligned as *const FieldType` creates an/// intermediate unaligned reference before converting that to a raw pointer./// That this reference is temporary and immediately cast is inconsequential/// as the compiler always expects references to be properly aligned./// As a result, using `&packed.unaligned as *const FieldType` causes immediate/// *undefined behavior* in your program./// Instead you must use the `&raw const` syntax to create the pointer./// You may use that constructed pointer together with this function./// An example of what not to do and how this relates to `read_unaligned` is:/// #[repr(packed, C)]/// struct Packed {///     _padding: u8,/// let packed = Packed {///     _padding: 0x00,///     unaligned: 0x01020304,/// // Take the address of a 32-bit integer which is not aligned./// // In contrast to `&packed.unaligned as *const _`, this has no undefined behavior./// let unaligned = &raw const packed.unaligned;/// let v = unsafe { std::ptr::read_unaligned(unaligned) };/// assert_eq!(v, 0x01020304);/// Accessing unaligned fields directly with e.g. `packed.unaligned` is safe however./// Read a `usize` value from a byte buffer:/// fn read_usize(x: &[u8]) -> usize {///     assert!(x.len() >= size_of::<usize>());///     let ptr = x.as_ptr() as *const usize;///     unsafe { ptr.read_unaligned() }"ptr_write"/// Overwrites a memory location with the given value without reading or/// dropping the old value./// `write` does not drop the contents of `dst`. This is safe, but it could leak/// allocations or resources, so care should be taken not to overwrite an object/// that should be dropped./// Additionally, it does not drop `src`. Semantically, `src` is moved into the/// location pointed to by `dst`./// This is appropriate for initializing uninitialized memory, or overwriting/// memory that has previously been [`read`] from./// * `dst` must be [valid] for writes./// * `dst` must be properly aligned. Use [`write_unaligned`] if this is not the/// let y = &mut x as *mut i32;/// let z = 12;///     std::ptr::write(y, z);"ptr_write_unaligned"/// Unlike [`write()`], the pointer may be unaligned./// `write_unaligned` does not drop the contents of `dst`. This is safe, but it/// could leak allocations or resources, so care should be taken not to overwrite/// an object that should be dropped./// memory that has previously been read with [`read_unaligned`]./// Instead, you must use the `&raw mut` syntax to create the pointer./// An example of how to do it and how this relates to `write_unaligned` is:/// let mut packed: Packed = unsafe { std::mem::zeroed() };/// // In contrast to `&packed.unaligned as *mut _`, this has no undefined behavior./// let unaligned = &raw mut packed.unaligned;/// unsafe { std::ptr::write_unaligned(unaligned, 42) };/// assert_eq!({packed.unaligned}, 42); // `{...}` forces copying the field instead of creating a reference./// Accessing unaligned fields directly with e.g. `packed.unaligned` is safe however/// (as can be seen in the `assert_eq!` above)./// Write a `usize` value to a byte buffer:/// fn write_usize(x: &mut [u8], val: usize) {///     let ptr = x.as_mut_ptr() as *mut usize;///     unsafe { ptr.write_unaligned(val) }"ptr_read_volatile"/// Performs a volatile read of the value from `src` without moving it./// Volatile operations are intended to act on I/O memory. As such, they are considered externally/// observable events (just like syscalls, but less opaque), and are guaranteed to not be elided or/// reordered by the compiler across other externally observable events. With this in mind, there/// are two cases of usage that need to be distinguished:/// - When a volatile operation is used for memory inside an [allocation], it behaves exactly like///   [`read`], except for the additional guarantee that it won't be elided or reordered (see///   above). This implies that the operation will actually access memory and not e.g. be lowered to///   reusing data from a previous read. Other than that, all the usual rules for memory accesses///   apply (including provenance).  In particular, just like in C, whether an operation is volatile///   has no bearing whatsoever on questions involving concurrent accesses from multiple threads.///   Volatile accesses behave exactly like non-atomic accesses in that regard./// - Volatile operations, however, may also be used to access memory that is _outside_ of any Rust///   allocation. In this use-case, the pointer does *not* have to be [valid] for reads. This is///   typically used for CPU and peripheral registers that must be accessed via an I/O memory///   mapping, most commonly at fixed addresses reserved by the hardware. These often have special///   semantics associated to their manipulation, and cannot be used as general purpose memory.///   Here, any address value is possible, including 0 and [`usize::MAX`], so long as the semantics///   of such a read are well-defined by the target hardware. The provenance of the pointer is///   irrelevant, and it can be created with [`without_provenance`]. The access must not trap. It///   can cause side-effects, but those must not affect Rust-allocated memory in any way. This///   access is still not considered [atomic], and as such it cannot be used for inter-thread///   synchronization./// Note that volatile memory operations where T is a zero-sized type are noops and may be ignored./// [allocation]: crate::ptr#allocated-object/// [atomic]: crate::sync::atomic#memory-model-for-atomic-accesses/// Like [`read`], `read_volatile` creates a bitwise copy of `T`, regardless of whether `T` is/// [`Copy`]. If `T` is not [`Copy`], using both the returned value and the value at `*src` can/// [violate memory safety][read-ownership]. However, storing non-[`Copy`] types in volatile memory/// is almost certainly incorrect./// * `src` must be either [valid] for reads, or it must point to memory outside of all Rust///   allocations and reading from that memory must:///   - not trap, and///   - not cause any memory inside a Rust allocation to be modified./// * `src` must be properly aligned./// * Reading from `src` must produce a properly initialized value of type `T`.///     assert_eq!(std::ptr::read_volatile(y), 12);"ptr_write_volatile"/// Performs a volatile write of a memory location with the given value without reading or dropping/// the old value./// observable events (just like syscalls), and are guaranteed to not be elided or reordered by the/// compiler across other externally observable events. With this in mind, there are two cases of/// usage that need to be distinguished:///   [`write`][write()], except for the additional guarantee that it won't be elided or reordered///   (see above). This implies that the operation will actually access memory and not e.g. be///   lowered to a register access. Other than that, all the usual rules for memory accesses apply///   (including provenance). In particular, just like in C, whether an operation is volatile has no///   bearing whatsoever on questions involving concurrent access from multiple threads. Volatile///   accesses behave exactly like non-atomic accesses in that regard.///   allocation. In this use-case, the pointer does *not* have to be [valid] for writes. This is///   of such a write are well-defined by the target hardware. The provenance of the pointer is/// Note that volatile memory operations on zero-sized types (e.g., if a zero-sized type is passed/// to `write_volatile`) are noops and may be ignored./// `write_volatile` does not drop the contents of `dst`. This is safe, but it could leak/// allocations or resources, so care should be taken not to overwrite an object that should be/// dropped when operating on Rust memory. Additionally, it does not drop `src`. Semantically, `src`/// is moved into the location pointed to by `dst`./// * `dst` must be either [valid] for writes, or it must point to memory outside of all Rust///   allocations and writing to that memory must:///     std::ptr::write_volatile(y, z);/// Calculate an element-offset that increases a pointer's alignment./// Calculate an element-offset (not byte-offset) that when added to a given pointer `p`, increases `p`'s alignment to at least the given alignment `a`./// `a` must be a power of two./// This implementation has been carefully tailored to not panic. It is UB for this to panic./// The only real change that can be made here is change of `INV_TABLE_MOD_16` and associated/// constants./// If we ever decide to make it possible to call the intrinsic with `a` that is not a/// power-of-two, it will probably be more prudent to just change to a naive implementation rather/// than trying to adapt this to accommodate that change./// Any questions go to @nagisa."pointer comparison produces a value""ptr_eq"/// Compares raw pointers for equality./// This is the same as using the `==` operator, but less generic:/// the arguments have to be `*const T` raw pointers,/// not anything that implements `PartialEq`./// This can be used to compare `&T` references (which coerce to `*const T` implicitly)/// by their address rather than comparing the values they point to/// (which is what the `PartialEq for &T` implementation does)./// When comparing wide pointers, both the address and the metadata are tested for equality./// However, note that comparing trait object pointers (`*const dyn Trait`) is unreliable: pointers/// to values of the same underlying type can compare inequal (because vtables are duplicated in/// multiple codegen units), and pointers to values of *different* underlying type can compare equal/// (since identical vtables can be deduplicated within a codegen unit)./// Slices are also compared by their length (fat pointers):/// assert!(std::ptr::eq(&a[..3], &a[..3]));/// assert!(!std::ptr::eq(&a[..2], &a[..3]));/// assert!(!std::ptr::eq(&a[0..2], &a[1..3]));// it's actually clear hereaddr_eq/// Compares the *addresses* of the two pointers for equality,/// ignoring any metadata in fat pointers./// If the arguments are thin pointers of the same type,/// then this is the same as [`eq`]./// let whole: &[i32; 3] = &[1, 2, 3];/// let first: &i32 = &whole[0];/// assert!(ptr::addr_eq(whole, first));/// assert!(!ptr::eq::<dyn std::fmt::Debug>(whole, first));"function pointer comparison produces a value"fn_addr_eq/// Compares the *addresses* of the two function pointers for equality./// This is the same as `f == g`, but using this function makes clear that the potentially/// surprising semantics of function pointer comparison are involved./// There are **very few guarantees** about how functions are compiled and they have no intrinsic/// “identity”; in particular, this comparison:/// * May return `true` unexpectedly, in cases where functions are equivalent.///   For example, the following program is likely (but not guaranteed) to print `(true, true)`///   when compiled with optimization:///   let f: fn(i32) -> i32 = |x| x;///   let g: fn(i32) -> i32 = |x| x + 0;  // different closure, different body///   let h: fn(u32) -> u32 = |x| x + 0;  // different signature too///   dbg!(std::ptr::fn_addr_eq(f, g), std::ptr::fn_addr_eq(f, h)); // not guaranteed to be equal/// * May return `false` in any case.///   This is particularly likely with generic functions but may happen with any function.///   (From an implementation perspective, this is possible because functions may sometimes be///   processed more than once by the compiler, resulting in duplicate machine code.)/// Despite these false positives and false negatives, this comparison can still be useful./// Specifically, if/// * `T` is the same type as `U`, `T` is a [subtype] of `U`, or `U` is a [subtype] of `T`, and/// * `ptr::fn_addr_eq(f, g)` returns true,/// then calling `f` and calling `g` will be equivalent./// fn a() { println!("a"); }/// fn b() { println!("b"); }/// assert!(!ptr::fn_addr_eq(a as fn(), b as fn()));/// [subtype]: https://doc.rust-lang.org/reference/subtyping.html/// Hash a raw pointer./// This can be used to hash a `&T` reference (which coerces to `*const T` implicitly)/// by its address rather than the value it points to/// (which is what the `Hash for &T` implementation does)./// ptr::hash(five_ref, &mut hasher);/// let actual = hasher.finish();/// (five_ref as *const i32).hash(&mut hasher);/// let expected = hasher.finish();/// assert_eq!(actual, expected);HH/// Creates a `const` raw pointer to a place, without creating an intermediate reference./// `addr_of!(expr)` is equivalent to `&raw const expr`. The macro is *soft-deprecated*;/// use `&raw const` instead./// It is still an open question under which conditions writing through an `addr_of!`-created/// pointer is permitted. If the place `expr` evaluates to is based on a raw pointer, then the/// result of `addr_of!` inherits all permissions from that raw pointer. However, if the place is/// based on a reference, local variable, or `static`, then until all details are decided, the same/// rules as for shared references apply: it is UB to write through a pointer created with this/// operation, except for bytes located inside an `UnsafeCell`. Use `&raw mut` (or [`addr_of_mut`])/// to create a raw pointer that definitely permits mutation./// Creating a reference with `&`/`&mut` is only allowed if the pointer is properly aligned/// and points to initialized data. For cases where those requirements do not hold,/// raw pointers should be used instead. However, `&expr as *const _` creates a reference/// before casting it to a raw pointer, and that reference is subject to the same rules/// as all other references. This macro can create a raw pointer *without* creating/// a reference first./// See [`addr_of_mut`] for how to create a pointer to uninitialized data./// Doing that with `addr_of` would not make much sense since one could only/// read the data, and that would be Undefined Behavior./// The `expr` in `addr_of!(expr)` is evaluated as a place expression, but never loads from the/// place or requires the place to be dereferenceable. This means that `addr_of!((*ptr).field)`/// still requires the projection to `field` to be in-bounds, using the same rules as [`offset`]./// However, `addr_of!(*ptr)` is defined behavior even if `ptr` is null, dangling, or misaligned./// Note that `Deref`/`Index` coercions (and their mutable counterparts) are applied inside/// `addr_of!` like everywhere else, in which case a reference is created to call `Deref::deref` or/// `Index::index`, respectively. The statements above only apply when no such coercions are/// **Correct usage: Creating a pointer to unaligned data**///     f1: u8,///     f2: u16,/// let packed = Packed { f1: 1, f2: 2 };/// // `&packed.f2` would create an unaligned reference, and thus be Undefined Behavior!/// let raw_f2 = ptr::addr_of!(packed.f2);/// assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);/// **Incorrect usage: Out-of-bounds fields projection**///     field1: i32,///     field2: i32,/// let ptr: *const MyStruct = ptr::null();/// let fieldptr = unsafe { ptr::addr_of!((*ptr).field2) }; // Undefined Behavior ⚠️/// The field projection `.field2` would offset the pointer by 4 bytes,/// but the pointer is not in-bounds of an allocation for 4 bytes,/// so this offset is Undefined Behavior./// See the [`offset`] docs for a full list of requirements for inbounds pointer arithmetic; the/// same requirements apply to field projections, even inside `addr_of!`. (In particular, it makes/// no difference whether the pointer is null or dangling.)/// Creates a `mut` raw pointer to a place, without creating an intermediate reference./// `addr_of_mut!(expr)` is equivalent to `&raw mut expr`. The macro is *soft-deprecated*;/// use `&raw mut` instead./// raw pointers should be used instead. However, `&mut expr as *mut _` creates a reference/// The `expr` in `addr_of_mut!(expr)` is evaluated as a place expression, but never loads from the/// place or requires the place to be dereferenceable. This means that `addr_of_mut!((*ptr).field)`/// However, `addr_of_mut!(*ptr)` is defined behavior even if `ptr` is null, dangling, or misaligned./// `addr_of_mut!` like everywhere else, in which case a reference is created to call `Deref::deref`/// or `Index::index`, respectively. The statements above only apply when no such coercions are/// let mut packed = Packed { f1: 1, f2: 2 };/// // `&mut packed.f2` would create an unaligned reference, and thus be Undefined Behavior!/// let raw_f2 = ptr::addr_of_mut!(packed.f2);/// unsafe { raw_f2.write_unaligned(42); }/// assert_eq!({packed.f2}, 42); // `{...}` forces copying the field instead of creating a reference./// **Correct usage: Creating a pointer to uninitialized data**/// use std::{ptr, mem::MaybeUninit};/// struct Demo {///     field: bool,/// let mut uninit = MaybeUninit::<Demo>::uninit();/// // `&uninit.as_mut().field` would create a reference to an uninitialized `bool`,/// // and thus be Undefined Behavior!/// let f1_ptr = unsafe { ptr::addr_of_mut!((*uninit.as_mut_ptr()).field) };/// unsafe { f1_ptr.write(true); }/// let init = unsafe { uninit.assume_init() };/// let ptr: *mut MyStruct = ptr::null_mut();/// let fieldptr = unsafe { ptr::addr_of_mut!((*ptr).field2) }; // Undefined Behavior ⚠️/// same requirements apply to field projections, even inside `addr_of_mut!`. (In particular, it/// makes no difference whether the pointer is null or dangling.)//! Manually manage memory through raw pointers.//! *[See also the pointer primitive types](pointer).*//! Many functions in this module take raw pointers as arguments and read from or write to them. For//! this to be safe, these pointers must be *valid* for the given access. Whether a pointer is valid//! depends on the operation it is used for (read or write), and the extent of the memory that is//! accessed (i.e., how many bytes are read/written) -- it makes no sense to ask "is this pointer//! valid"; one has to ask "is this pointer valid for a given access". Most functions use `*mut T`//! and `*const T` to access only a single value, in which case the documentation omits the size and//! implicitly assumes it to be `size_of::<T>()` bytes.//! The precise rules for validity are not determined yet. The guarantees that are//! provided at this point are very minimal://! * For memory accesses of [size zero][zst], *every* pointer is valid, including the [null]//!   pointer. The following points are only concerned with non-zero-sized accesses.//! * A [null] pointer is *never* valid.//! * For a pointer to be valid, it is necessary, but not always sufficient, that the pointer be//!   *dereferenceable*. The [provenance] of the pointer is used to determine which [allocation]//!   it is derived from; a pointer is dereferenceable if the memory range of the given size//!   starting at the pointer is entirely contained within the bounds of that allocation. Note//!   that in Rust, every (stack-allocated) variable is considered a separate allocation.//! * All accesses performed by functions in this module are *non-atomic* in the sense//!   of [atomic operations] used to synchronize between threads. This means it is//!   undefined behavior to perform two concurrent accesses to the same location from different//!   threads unless both accesses only read from memory. Notice that this explicitly//!   includes [`read_volatile`] and [`write_volatile`]: Volatile accesses cannot//!   be used for inter-thread synchronization, regardless of whether they are acting on//!   Rust memory or not.//! * The result of casting a reference to a pointer is valid for as long as the//!   underlying allocation is live and no reference (just raw pointers) is used to//!   access the same memory. That is, reference and pointer accesses cannot be//!   interleaved.//! These axioms, along with careful use of [`offset`] for pointer arithmetic,//! are enough to correctly implement many useful things in unsafe code. Stronger guarantees//! will be provided eventually, as the [aliasing] rules are being determined. For more//! information, see the [book] as well as the section in the reference devoted//! to [undefined behavior][ub].//! We say that a pointer is "dangling" if it is not valid for any non-zero-sized accesses. This//! means out-of-bounds pointers, pointers to freed memory, null pointers, and pointers created with//! [`NonNull::dangling`] are all dangling.//! ## Alignment//! Valid raw pointers as defined above are not necessarily properly aligned (where//! "proper" alignment is defined by the pointee type, i.e., `*const T` must be//! aligned to `align_of::<T>()`). However, most functions require their//! arguments to be properly aligned, and will explicitly state//! this requirement in their documentation. Notable exceptions to this are//! [`read_unaligned`] and [`write_unaligned`].//! When a function requires proper alignment, it does so even if the access//! has size 0, i.e., even if memory is not actually touched. Consider using//! [`NonNull::dangling`] in such cases.//! ## Pointer to reference conversion//! When converting a pointer to a reference (e.g. via `&*ptr` or `&mut *ptr`),//! there are several rules that must be followed://! * The pointer must be properly aligned.//! * It must be non-null.//! * It must be "dereferenceable" in the sense defined above.//! * The pointer must point to a [valid value] of type `T`.//! * You must enforce Rust's aliasing rules. The exact aliasing rules are not decided yet, so we//!   only give a rough overview here. The rules also depend on whether a mutable or a shared//!   reference is being created.//!   * When creating a mutable reference, then while this reference exists, the memory it points to//!     must not get accessed (read or written) through any other pointer or reference not derived//!     from this reference.//!   * When creating a shared reference, then while this reference exists, the memory it points to//!     must not get mutated (except inside `UnsafeCell`).//! If a pointer follows all of these rules, it is said to be//! *convertible to a (mutable or shared) reference*.// ^ we use this term instead of saying that the produced reference must// be valid, as the validity of a reference is easily confused for the// validity of the thing it refers to, and while the two concepts are// closely related, they are not identical.//! These rules apply even if the result is unused!//! (The part about being initialized is not yet fully decided, but until//! it is, the only safe approach is to ensure that they are indeed initialized.)//! An example of the implications of the above rules is that an expression such//! as `unsafe { &*(0 as *const u8) }` is Immediate Undefined Behavior.//! [valid value]: ../../reference/behavior-considered-undefined.html#invalid-values//! ## Allocation//! <a id="allocated-object"></a> <!-- keep old URLs working -->//! An *allocation* is a subset of program memory which is addressable//! from Rust, and within which pointer arithmetic is possible. Examples of//! allocations include heap allocations, stack-allocated variables,//! statics, and consts. The safety preconditions of some Rust operations -//! such as `offset` and field projections (`expr.field`) - are defined in//! terms of the allocations on which they operate.//! An allocation has a base address, a size, and a set of memory//! addresses. It is possible for an allocation to have zero size, but//! such an allocation will still have a base address. The base address//! of an allocation is not necessarily unique. While it is currently the//! case that an allocation always has a set of memory addresses which is//! fully contiguous (i.e., has no "holes"), there is no guarantee that this//! will not change in the future.//! Allocations must behave like "normal" memory: in particular, reads must not have//! side-effects, and writes must become visible to other threads using the usual synchronization//! For any allocation with `base` address, `size`, and a set of//! `addresses`, the following are guaranteed://! - For all addresses `a` in `addresses`, `a` is in the range `base .. (base +//!   size)` (note that this requires `a < base + size`, not `a <= base + size`)//! - `base` is not equal to [`null()`] (i.e., the address with the numerical//!   value 0)//! - `base + size <= usize::MAX`//! - `size <= isize::MAX`//! As a consequence of these guarantees, given any address `a` within the set//! of addresses of an allocation://! - It is guaranteed that `a - base` does not overflow `isize`//! - It is guaranteed that `a - base` is non-negative//! - It is guaranteed that, given `o = a - base` (i.e., the offset of `a` within//!   the allocation), `base + o` will not wrap around the address space (in//!   other words, will not overflow `usize`)//! [`null()`]: null//! # Provenance//! Pointers are not *simply* an "integer" or "address". For instance, it's uncontroversial//! to say that a Use After Free is clearly Undefined Behavior, even if you "get lucky"//! and the freed memory gets reallocated before your read/write (in fact this is the//! worst-case scenario, UAFs would be much less concerning if this didn't happen!).//! As another example, consider that [`wrapping_offset`] is documented to "remember"//! the allocation that the original pointer points to, even if it is offset far//! outside the memory range occupied by that allocation.//! To rationalize claims like this, pointers need to somehow be *more* than just their addresses://! they must have **provenance**.//! A pointer value in Rust semantically contains the following information://! * The **address** it points to, which can be represented by a `usize`.//! * The **provenance** it has, defining the memory it has permission to access. Provenance can be//!   absent, in which case the pointer does not have permission to access any memory.//! The exact structure of provenance is not yet specified, but the permission defined by a//! pointer's provenance have a *spatial* component, a *temporal* component, and a *mutability*//! component://! * Spatial: The set of memory addresses that the pointer is allowed to access.//! * Temporal: The timespan during which the pointer is allowed to access those memory addresses.//! * Mutability: Whether the pointer may only access the memory for reads, or also access it for//!   writes. Note that this can interact with the other components, e.g. a pointer might permit//!   mutation only for a subset of addresses, or only for a subset of its maximal timespan.//! When an [allocation] is created, it has a unique Original Pointer. For alloc//! APIs this is literally the pointer the call returns, and for local variables and statics,//! this is the name of the variable/static. (This is mildly overloading the term "pointer"//! for the sake of brevity/exposition.)//! The Original Pointer for an allocation has provenance that constrains the *spatial*//! permissions of this pointer to the memory range of the allocation, and the *temporal*//! permissions to the lifetime of the allocation. Provenance is implicitly inherited by all//! pointers transitively derived from the Original Pointer through operations like [`offset`],//! borrowing, and pointer casts. Some operations may *shrink* the permissions of the derived//! provenance, limiting how much memory it can access or how long it's valid for (i.e. borrowing a//! subfield and subslicing can shrink the spatial component of provenance, and all borrowing can//! shrink the temporal component of provenance). However, no operation can ever *grow* the//! permissions of the derived provenance: even if you "know" there is a larger allocation, you//! can't derive a pointer with a larger provenance. Similarly, you cannot "recombine" two//! contiguous provenances back into one (i.e. with a `fn merge(&[T], &[T]) -> &[T]`).//! A reference to a place always has provenance over at least the memory that place occupies.//! A reference to a slice always has provenance over at least the range that slice describes.//! Whether and when exactly the provenance of a reference gets "shrunk" to *exactly* fit//! the memory it points to is not yet determined.//! A *shared* reference only ever has provenance that permits reading from memory,//! and never permits writes, except inside [`UnsafeCell`].//! Provenance can affect whether a program has undefined behavior://! * It is undefined behavior to access memory through a pointer that does not have provenance over//!   that memory. Note that a pointer "at the end" of its provenance is not actually outside its//!   provenance, it just has 0 bytes it can load/store. Zero-sized accesses do not require any//!   provenance since they access an empty range of memory.//! * It is undefined behavior to [`offset`] a pointer across a memory range that is not contained//!   in the allocation it is derived from, or to [`offset_from`] two pointers not derived//!   from the same allocation. Provenance is used to say what exactly "derived from" even//!   means: the lineage of a pointer is traced back to the Original Pointer it descends from, and//!   that identifies the relevant allocation. In particular, it's always UB to offset a//!   pointer derived from something that is now deallocated, except if the offset is 0.//! But it *is* still sound to://! * Create a pointer without provenance from just an address (see [`without_provenance`]). Such a//!   pointer cannot be used for memory accesses (except for zero-sized accesses). This can still be//!   useful for sentinel values like `null` *or* to represent a tagged pointer that will never be//!   dereferenceable. In general, it is always sound for an integer to pretend to be a pointer "for//!   fun" as long as you don't use operations on it which require it to be valid (non-zero-sized//!   offset, read, write, etc).//! * Forge an allocation of size zero at any sufficiently aligned non-null address.//!   i.e. the usual "ZSTs are fake, do what you want" rules apply.//! * [`wrapping_offset`] a pointer outside its provenance. This includes pointers//!   which have "no" provenance. In particular, this makes it sound to do pointer tagging tricks.//! * Compare arbitrary pointers by address. Pointer comparison ignores provenance and addresses//!   *are* just integers, so there is always a coherent answer, even if the pointers are dangling//!   or from different provenances. Note that if you get "lucky" and notice that a pointer at the//!   end of one allocation is the "same" address as the start of another allocation,//!   anything you do with that fact is *probably* going to be gibberish. The scope of that//!   gibberish is kept under control by the fact that the two pointers *still* aren't allowed to//!   access the other's allocation (bytes), because they still have different provenance.//! Note that the full definition of provenance in Rust is not decided yet, as this interacts//! with the as-yet undecided [aliasing] rules.//! ## Pointers Vs Integers//! From this discussion, it becomes very clear that a `usize` *cannot* accurately represent a pointer,//! and converting from a pointer to a `usize` is generally an operation which *only* extracts the//! address. Converting this address back into pointer requires somehow answering the question://! which provenance should the resulting pointer have?//! Rust provides two ways of dealing with this situation: *Strict Provenance* and *Exposed Provenance*.//! Note that a pointer *can* represent a `usize` (via [`without_provenance`]), so the right type to//! use in situations where a value is "sometimes a pointer and sometimes a bare `usize`" is a//! pointer type.//! ## Strict Provenance//! "Strict Provenance" refers to a set of APIs designed to make working with provenance more//! explicit. They are intended as substitutes for casting a pointer to an integer and back.//! Entirely avoiding integer-to-pointer casts successfully side-steps the inherent ambiguity of//! that operation. This benefits compiler optimizations, and it is pretty much a requirement for//! using tools like [Miri] and architectures like [CHERI] that aim to detect and diagnose pointer//! misuse.//! The key insight to making programming without integer-to-pointer casts *at all* viable is the//! [`with_addr`] method://!     /// Creates a new pointer with the given address.//!     /// This performs the same operation as an `addr as ptr` cast, but copies//!     /// the *provenance* of `self` to the new pointer.//!     /// This allows us to dynamically preserve and propagate this important//!     /// information in a way that is otherwise impossible with a unary cast.//!     /// This is equivalent to using `wrapping_offset` to offset `self` to the//!     /// given address, and therefore has all the same capabilities and restrictions.//!     pub fn with_addr(self, addr: usize) -> Self;//! So you're still able to drop down to the address representation and do whatever//! clever bit tricks you want *as long as* you're able to keep around a pointer//! into the allocation you care about that can "reconstitute" the provenance.//! Usually this is very easy, because you only are taking a pointer, messing with the address,//! and then immediately converting back to a pointer. To make this use case more ergonomic,//! we provide the [`map_addr`] method.//! To help make it clear that code is "following" Strict Provenance semantics, we also provide an//! [`addr`] method which promises that the returned address is not part of a//! pointer-integer-pointer roundtrip. In the future we may provide a lint for pointer<->integer//! casts to help you audit if your code conforms to strict provenance.//! ### Using Strict Provenance//! Most code needs no changes to conform to strict provenance, as the only really concerning//! operation is casts from `usize` to a pointer. For code which *does* cast a `usize` to a pointer,//! the scope of the change depends on exactly what you're doing.//! In general, you just need to make sure that if you want to convert a `usize` address to a//! pointer and then use that pointer to read/write memory, you need to keep around a pointer//! that has sufficient provenance to perform that read/write itself. In this way all of your//! casts from an address to a pointer are essentially just applying offsets/indexing.//! This is generally trivial to do for simple cases like tagged pointers *as long as you//! represent the tagged pointer as an actual pointer and not a `usize`*. For instance://!     // A flag we want to pack into our pointer//!     static HAS_DATA: usize = 0x1;//!     static FLAG_MASK: usize = !HAS_DATA;//!     // Our value, which must have enough alignment to have spare least-significant-bits.//!     let my_precious_data: u32 = 17;//!     assert!(align_of::<u32>() > 1);//!     // Create a tagged pointer//!     let ptr = &my_precious_data as *const u32;//!     let tagged = ptr.map_addr(|addr| addr | HAS_DATA);//!     // Check the flag://!     if tagged.addr() & HAS_DATA != 0 {//!         // Untag and read the pointer//!         let data = *tagged.map_addr(|addr| addr & FLAG_MASK);//!         assert_eq!(data, 17);//!         unreachable!()//! (Yes, if you've been using [`AtomicUsize`] for pointers in concurrent datastructures, you should//! be using [`AtomicPtr`] instead. If that messes up the way you atomically manipulate pointers,//! we would like to know why, and what needs to be done to fix it.)//! Situations where a valid pointer *must* be created from just an address, such as baremetal code//! accessing a memory-mapped interface at a fixed address, cannot currently be handled with strict//! provenance APIs and should use [exposed provenance](#exposed-provenance).//! ## Exposed Provenance//! As discussed above, integer-to-pointer casts are not possible with Strict Provenance APIs.//! This is by design: the goal of Strict Provenance is to provide a clear specification that we are//! confident can be formalized unambiguously and can be subject to precise formal reasoning.//! Integer-to-pointer casts do not (currently) have such a clear specification.//! However, there exist situations where integer-to-pointer casts cannot be avoided, or//! where avoiding them would require major refactoring. Legacy platform APIs also regularly assume//! that `usize` can capture all the information that makes up a pointer.//! Bare-metal platforms can also require the synthesis of a pointer "out of thin air" without//! anywhere to obtain proper provenance from.//! Rust's model for dealing with integer-to-pointer casts is called *Exposed Provenance*. However,//! the semantics of Exposed Provenance are on much less solid footing than Strict Provenance, and//! at this point it is not yet clear whether a satisfying unambiguous semantics can be defined for//! Exposed Provenance. (If that sounds bad, be reassured that other popular languages that provide//! integer-to-pointer casts are not faring any better.) Furthermore, Exposed Provenance will not//! work (well) with tools like [Miri] and [CHERI].//! Exposed Provenance is provided by the [`expose_provenance`] and [`with_exposed_provenance`] methods,//! which are equivalent to `as` casts between pointers and integers.//! - [`expose_provenance`] is a lot like [`addr`], but additionally adds the provenance of the//!   pointer to a global list of 'exposed' provenances. (This list is purely conceptual, it exists//!   for the purpose of specifying Rust but is not materialized in actual executions, except in//!   tools like [Miri].)//!   Memory which is outside the control of the Rust abstract machine (MMIO registers, for example)//!   is always considered to be exposed, so long as this memory is disjoint from memory that will//!   be used by the abstract machine such as the stack, heap, and statics.//! - [`with_exposed_provenance`] can be used to construct a pointer with one of these previously//!   'exposed' provenances. [`with_exposed_provenance`] takes only `addr: usize` as arguments, so//!   unlike in [`with_addr`] there is no indication of what the correct provenance for the returned//!   pointer is -- and that is exactly what makes integer-to-pointer casts so tricky to rigorously//!   specify! The compiler will do its best to pick the right provenance for you, but currently we//!   cannot provide any guarantees about which provenance the resulting pointer will have. Only one//!   thing is clear: if there is *no* previously 'exposed' provenance that justifies the way the//!   returned pointer will be used, the program has undefined behavior.//! If at all possible, we encourage code to be ported to [Strict Provenance] APIs, thus avoiding//! the need for Exposed Provenance. Maximizing the amount of such code is a major win for avoiding//! specification complexity and to facilitate adoption of tools like [CHERI] and [Miri] that can be//! a big help in increasing the confidence in (unsafe) Rust code. However, we acknowledge that this//! is not always possible, and offer Exposed Provenance as a way to explicit "opt out" of the//! well-defined semantics of Strict Provenance, and "opt in" to the unclear semantics of//! integer-to-pointer casts.//! [aliasing]: ../../nomicon/aliasing.html//! [allocation]: #allocation//! [provenance]: #provenance//! [book]: ../../book/ch19-01-unsafe-rust.html#dereferencing-a-raw-pointer//! [ub]: ../../reference/behavior-considered-undefined.html//! [zst]: ../../nomicon/exotic-sizes.html#zero-sized-types-zsts//! [atomic operations]: crate::sync::atomic//! [`offset`]: pointer::offset//! [`offset_from`]: pointer::offset_from//! [`wrapping_offset`]: pointer::wrapping_offset//! [`with_addr`]: pointer::with_addr//! [`map_addr`]: pointer::map_addr//! [`addr`]: pointer::addr//! [`AtomicUsize`]: crate::sync::atomic::AtomicUsize//! [`AtomicPtr`]: crate::sync::atomic::AtomicPtr//! [`expose_provenance`]: pointer::expose_provenance//! [`with_exposed_provenance`]: with_exposed_provenance//! [CHERI]: https://www.cl.cam.ac.uk/research/security/ctsrd/cheri///! [Strict Provenance]: #strict-provenance//! [`UnsafeCell`]: core::cell::UnsafeCell// There are many unsafe functions taking pointers that don't dereference them.// Some functions are defined here because they accidentally got made// available in this module on stable. See <https://github.com/rust-lang/rust/issues/15702>.// (`transmute` also falls into this category, but it cannot be wrapped due to the// check that `T` and `U` have the same size.)"ptr_is_null"/// let mut s = [1, 2, 3];/// let ptr: *mut u32 = s.as_mut_ptr();"ptr_cast"/// let mut x = 0u64;/// let aligned: *mut u64 = &mut x;/// let mut arr: [i32; 3] = [1, 2, 3];/// let mut ptr = arr.as_mut_ptr() as *mut dyn Debug;/// let thin = ptr as *mut u8;///     # assert_eq!(*(ptr as *mut i32), 3);/// let mut x = 0u32;/// let mut y = 1u32;/// let x = (&mut x) as *mut u32;/// let y = (&mut y) as *mut u32;"ptr_cast_const"cast_const/// While not strictly required (`*mut T` coerces to `*const T`), this is provided for symmetry/// with [`cast_mut`] on `*const T` and may have documentation value if used instead of implicit/// coercion./// [`cast_mut`]: pointer::cast_mut/// [without_provenance]: without_provenance_mut/// [`with_exposed_provenance_mut`] and returns the "address" portion./// [`with_exposed_provenance_mut`] to reconstitute the original pointer including its provenance./// Due to its inherent ambiguity, [`with_exposed_provenance_mut`] may not be supported by tools/// side-effect which is required for [`with_exposed_provenance_mut`] to work is typically not/// [`with_exposed_provenance_mut`]: with_exposed_provenance_mut/// This is similar to a `addr as *mut T` cast, but copies/// Creates a new pointer by mapping `self`'s address to a new one, preserving the original/// pointer's [provenance][crate::ptr#provenance]./// The pointer can be later reconstructed with [`from_raw_parts_mut`]./// let ptr: *mut u8 = &mut 10u8 as *mut u8;///     println!("We got back the value: {val_back}!");///         println!("We got back the value: {val_back}!");/// For the mutable counterpart see [`as_mut`]./// [`is_null`]: #method.is_null-1/// [`as_uninit_ref`]: pointer#method.as_uninit_ref-1/// [`as_mut`]: #method.as_mut/// For the mutable counterpart see [`as_mut_unchecked`]./// [`as_mut_unchecked`]: #method.as_mut_unchecked/// When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).///     println!("We got back the value: {}!", ptr.as_ref_unchecked());/// [`as_ref`]: pointer#method.as_ref-1/// For the mutable counterpart see [`as_uninit_mut`]./// [`as_uninit_mut`]: #method.as_uninit_mut///         println!("We got back the value: {}!", val_back.assume_init());///     assert_eq!(2, *ptr.offset(1));///     assert_eq!(3, *ptr.offset(2));/// let mut data = [1u8, 2, 3, 4, 5];/// let mut ptr: *mut u8 = data.as_mut_ptr();///         *ptr = 0;/// assert_eq!(&data, &[0, 2, 0, 4, 0]);/// let mut v = 17_u32;/// let ptr: *mut u32 = &mut v;/// // Note that `tagged_ptr` is unaligned, it's UB to read from/write to it./// unsafe { *masked_ptr = 0 };/// assert_eq!(v, 0);/// Returns `None` if the pointer is null, or else returns a unique reference to/// the value wrapped in `Some`. If the value may be uninitialized, [`as_uninit_mut`]/// must be used instead./// For the shared counterpart see [`as_ref`]./// When calling this method, you have to ensure that *either*/// the pointer is null *or*/// # Panics during const evaluation/// This method will panic during const evaluation if the pointer cannot be/// determined to be null or not. See [`is_null`] for more information./// let first_value = unsafe { ptr.as_mut().unwrap() };/// *first_value = 4;/// # assert_eq!(s, [4, 2, 3]);/// println!("{s:?}"); // It'll print: "[4, 2, 3]"./// # Null-unchecked version/// If you are sure the pointer can never be null and are looking for some kind of/// `as_mut_unchecked` that returns the `&mut T` instead of `Option<&mut T>`, know that/// you can dereference the pointer directly./// let first_value = unsafe { &mut *ptr };/// Returns a unique reference to the value behind the pointer./// If the pointer may be null or the value may be uninitialized, [`as_uninit_mut`] must be used instead./// If the pointer may be null, but the value is known to have been initialized, [`as_mut`] must be used instead./// For the shared counterpart see [`as_ref_unchecked`]./// [`as_ref_unchecked`]: #method.as_mut_unchecked/// let first_value = unsafe { ptr.as_mut_unchecked() };// FIXME: mention it in the docs for `as_mut` and `as_uninit_mut` once stabilized.as_uninit_mut/// the value wrapped in `Some`. In contrast to [`as_mut`], this does not require/// that the value has to be initialized./// For the shared counterpart see [`as_uninit_ref`]./// When calling this method, you have to ensure that *either* the pointer is null *or*/// [`offset`]: pointer#method.offset-1/// let mut a = [0; 5];/// let ptr1: *mut i32 = &mut a[1];/// let ptr2: *mut i32 = &mut a[3];/// let ptr1 = Box::into_raw(Box::new(0u8));/// let ptr2 = Box::into_raw(Box::new(1u8));/// let ptr2_other = (ptr1 as *mut u8).wrapping_offset(diff).wrapping_offset(1);/// # unsafe fn blah(ptr: *mut i32, origin: *mut i32, count: usize) -> bool { unsafe {/// let p: *mut i32 = a.as_mut_ptr();///     let ptr1: *mut i32 = p.add(1);///     let ptr2: *mut i32 = p.add(3);/// // ptr1.offset_from(ptr2)/// let mut s: String = "123".to_string();/// let ptr: *mut u8 = s.as_mut_ptr();///     assert_eq!('2', *ptr.add(1) as char);///     assert_eq!('3', *ptr.add(2) as char);///     assert_eq!('3', *end.sub(1) as char);///     assert_eq!('2', *end.sub(2) as char);/// // This loop prints "1, 3, 5, "///         print!("{}, ", *ptr);/// // This loop prints "5, 3, 1, "/// Copies `count * size_of::<T>()` bytes from `src` to `self`. The source/// NOTE: this has the *opposite* argument order of [`ptr::copy`]./// NOTE: this has the *opposite* argument order of [`ptr::copy_nonoverlapping`]./// See [`ptr::drop_in_place`] for safety concerns and examples./// [`ptr::drop_in_place`]: crate::ptr::drop_in_place()/// See [`ptr::write`] for safety concerns and examples./// [`ptr::write`]: crate::ptr::write()/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`/// bytes of memory starting at `self` to `val`./// See [`ptr::write_bytes`] for safety concerns and examples./// [`ptr::write_bytes`]: crate::ptr::write_bytes()/// Performs a volatile write of a memory location with the given value without/// reading or dropping the old value./// See [`ptr::write_volatile`] for safety concerns and examples./// [`ptr::write_volatile`]: crate::ptr::write_volatile()/// Unlike `write`, the pointer may be unaligned./// See [`ptr::write_unaligned`] for safety concerns and examples./// [`ptr::write_unaligned`]: crate::ptr::write_unaligned()/// Replaces the value at `self` with `src`, returning the old/// value, without dropping either./// See [`ptr::replace`] for safety concerns and examples./// [`ptr::replace`]: crate::ptr::replace()/// deinitializing either. They may overlap, unlike `mem::swap` which is/// otherwise equivalent./// See [`ptr::swap`] for safety concerns and examples./// [`ptr::swap`]: crate::ptr::swap()/// let mut x = [5_u8, 6, 7, 8, 9];/// let ptr = x.as_mut_ptr();///     *u16_ptr = 0;///     assert!(x == [0, 0, 7, 8, 9] || x == [5, 0, 0, 8, 9]);/// let mut data = AlignedI32(42);/// let ptr = &mut data as *mut AlignedI32;/// let slice: *mut [i8] = ptr::slice_from_raw_parts_mut(ptr::null_mut(), 3);/// Gets a raw, mutable pointer to the underlying array./// Divides one mutable raw slice into two at an index./// `mid` must be [in-bounds] of the underlying [allocation]./// Which means `self` must be dereferenceable and span a single allocation/// that is at least `mid * size_of::<T>()` bytes long. Not upholding these/// requirements is *[undefined behavior]* even if the resulting pointers are not used./// Since `len` being in-bounds it is not a safety invariant of `*mut [T]` the/// safety requirements of this method are the same as for [`split_at_mut_unchecked`]./// The explicit bounds check is only as useful as `len` is correct./// [`split_at_mut_unchecked`]: #method.split_at_mut_unchecked/// [in-bounds]: #method.add/// #![feature(raw_slice_split)]/// let ptr = &mut v as *mut [_];///     let (left, right) = ptr.split_at_mut(2);///     assert_eq!(&*left, [1, 0]);///     assert_eq!(&*right, [3, 0, 5, 6]);/// Divides one mutable raw slice into two at an index, without doing bounds checking./// [out-of-bounds index]: #method.add/// // scoped to restrict the lifetime of the borrows///     let ptr = &mut v as *mut [_];///     let (left, right) = ptr.split_at_mut_unchecked(2);///     (&mut *left)[1] = 2;///     (&mut *right)[1] = 4;/// This is equivalent to casting `self` to `*mut T`, but more type-safe./// assert_eq!(slice.as_mut_ptr(), ptr::null_mut());/// Calling this method with an [out-of-bounds index] or when `self` is not dereferenceable/// let x = &mut [1, 2, 4] as *mut [i32];///     assert_eq!(x.get_unchecked_mut(1), x.as_mut_ptr().add(1));/// For the mutable counterpart see [`as_uninit_slice_mut`](pointer::as_uninit_slice_mut)./// Returns `None` if the pointer is null, or else returns a unique slice to/// For the shared counterpart see [`as_uninit_slice`]./// [`as_uninit_slice`]: #method.as_uninit_slice-1/// all of the following is true:/// * The pointer must be [valid] for reads and writes for `ptr.len() * size_of::<T>()`///   many bytes, and it must be properly aligned. This means in particular:///     * The entire memory range of this slice must be contained within a single [allocation]!///       Slices can never span across multiple allocations.///     * The pointer must be aligned even for zero-length slices. One///       reason for this is that enum layout optimizations may rely on references///       (including slices of any length) being aligned and non-null to distinguish///       them from other data. You can obtain a pointer that is usable as `data`///       for zero-length slices using [`NonNull::dangling()`]./// * The total size `ptr.len() * size_of::<T>()` of the slice must be no larger than `isize::MAX`./// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.///   In particular, while this reference exists, the memory the pointer points to must///   not get accessed (read or written) through any other pointer./// This applies even if the result of this method is unused!/// See also [`slice::from_raw_parts_mut`][]./// let arr: *mut [i8; 3] = ptr::null_mut();/// assert_eq!(arr.as_mut_ptr(), ptr::null_mut());/// Returns a raw pointer to a mutable slice containing the entire array./// let mut arr = [1, 2, 5];/// let ptr: *mut [i32; 3] = &mut arr;///     (&mut *ptr.as_mut_slice())[..2].copy_from_slice(&[3, 4]);/// assert_eq!(arr, [3, 4, 5]);/// Pointer equality is by address, as produced by the [`<*mut T>::addr`](pointer::addr) method./// Pointer comparison is by address, as produced by the [`<*mut T>::addr`](pointer::addr) method./// Returns the default value of [`null_mut()`][crate::ptr::null_mut]."NonNull"// Remember to use `.as_ptr()` instead of `.pointer`, as field projecting to// this is banned by <https://github.com/rust-lang/compiler-team/issues/807>./// `*mut T` but non-zero and [covariant]./// This is often the correct thing to use when building data structures using/// raw pointers, but is ultimately more dangerous to use because of its additional/// properties. If you're not sure if you should use `NonNull<T>`, just use `*mut T`!/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer/// is never dereferenced. This is so that enums may use this forbidden value/// as a discriminant -- `Option<NonNull<T>>` has the same size as `*mut T`./// However the pointer may still dangle if it isn't dereferenced./// Unlike `*mut T`, `NonNull<T>` is covariant over `T`. This is usually the correct/// choice for most data structures and safe abstractions, such as `Box`, `Rc`, `Arc`, `Vec`,/// and `LinkedList`./// In rare cases, if your type exposes a way to mutate the value of `T` through a `NonNull<T>`,/// and you need to prevent unsoundness from variance (for example, if `T` could be a reference/// with a shorter lifetime), you should add a field to make your type invariant, such as/// `PhantomData<Cell<T>>` or `PhantomData<&'a mut T>`./// Example of a type that must be invariant:/// struct Invariant<T> {///     ptr: std::ptr::NonNull<T>,///     _invariant: PhantomData<Cell<T>>,/// Notice that `NonNull<T>` has a `From` instance for `&T`. However, this does/// not change the fact that mutating through a (pointer derived from a) shared/// reference is undefined behavior unless the mutation happens inside an/// [`UnsafeCell<T>`]. The same goes for creating a mutable reference from a shared/// reference. When using this `From` instance without an `UnsafeCell<T>`,/// it is your responsibility to ensure that `as_mut` is never called, and `as_ptr`/// is never used for mutation./// Thanks to the [null pointer optimization],/// `NonNull<T>` and `Option<NonNull<T>>`/// are guaranteed to have the same size and alignment:/// assert_eq!(size_of::<NonNull<i16>>(), size_of::<Option<NonNull<i16>>>());/// assert_eq!(align_of::<NonNull<i16>>(), align_of::<Option<NonNull<i16>>>());/// assert_eq!(size_of::<NonNull<str>>(), size_of::<Option<NonNull<str>>>());/// assert_eq!(align_of::<NonNull<str>>(), align_of::<Option<NonNull<str>>>());/// [`UnsafeCell<T>`]: crate::cell::UnsafeCell/// `NonNull` pointers are not `Send` because the data they reference may be aliased.// N.B., this impl is unnecessary, but should provide better error messages./// `NonNull` pointers are not `Sync` because the data they reference may be aliased./// For more details, see the equivalent method on a raw pointer, [`ptr::without_provenance_mut`]./// Creates a new `NonNull` that is dangling, but well-aligned./// let ptr = NonNull::<u32>::dangling();/// // Important: don't try to access the value of `ptr` without/// // initializing it first! The pointer is not null but isn't valid either!/// For more details, see the equivalent method on a raw pointer, [`ptr::with_exposed_provenance_mut`]./// Returns a shared references to the value. In contrast to [`as_ref`], this does not require/// [`as_ref`]: NonNull::as_ref/// [`as_uninit_mut`]: NonNull::as_uninit_mut/// Note that because the created reference is to `MaybeUninit<T>`, the/// source pointer can point to uninitialized memory./// Returns a unique references to the value. In contrast to [`as_mut`], this does not require/// [`as_mut`]: NonNull::as_mut/// [`as_uninit_ref`]: NonNull::as_uninit_ref/// Creates a new `NonNull`./// `ptr` must be non-null./// let ptr = unsafe { NonNull::new_unchecked(&mut x as *mut _) };/// *Incorrect* usage of this function:/// // NEVER DO THAT!!! This is undefined behavior. ⚠️/// let ptr = unsafe { NonNull::<u32>::new_unchecked(std::ptr::null_mut()) };/// Creates a new `NonNull` if `ptr` is non-null./// [`is_null`]: ../primitive.pointer.html#method.is_null-1/// let ptr = NonNull::<u32>::new(&mut x as *mut _).expect("ptr is null!");/// if let Some(ptr) = NonNull::<u32>::new(std::ptr::null_mut()) {///     unreachable!();/// Converts a reference to a `NonNull` pointer./// Converts a mutable reference to a `NonNull` pointer./// Performs the same functionality as [`std::ptr::from_raw_parts`], except that a/// `NonNull` pointer is returned, as opposed to a raw `*const` pointer./// See the documentation of [`std::ptr::from_raw_parts`] for more details./// [`std::ptr::from_raw_parts`]: crate::ptr::from_raw_parts/// The pointer can be later reconstructed with [`NonNull::from_raw_parts`]./// Gets the "address" portion of the pointer./// For more details, see the equivalent method on a raw pointer, [`pointer::addr`]./// [`with_exposed_provenance`][NonNull::with_exposed_provenance] and returns the "address" portion./// For more details, see the equivalent method on a raw pointer, [`pointer::expose_provenance`]./// For more details, see the equivalent method on a raw pointer, [`pointer::with_addr`]./// For more details, see the equivalent method on a raw pointer, [`pointer::map_addr`]./// Acquires the underlying `*mut` pointer./// let ptr = NonNull::new(&mut x).expect("ptr is null!");/// let x_value = unsafe { *ptr.as_ptr() };/// assert_eq!(x_value, 0);/// unsafe { *ptr.as_ptr() += 2; }/// assert_eq!(x_value, 2);/// Returns a shared reference to the value. If the value may be uninitialized, [`as_uninit_ref`]/// let ptr = NonNull::new(&mut x as *mut _).expect("ptr is null!");/// let ref_x = unsafe { ptr.as_ref() };/// println!("{ref_x}");/// [the module documentation]: crate::ptr#safety/// Returns a unique reference to the value. If the value may be uninitialized, [`as_uninit_mut`]/// let mut ptr = NonNull::new(&mut x).expect("null pointer");/// let x_ref = unsafe { ptr.as_mut() };/// assert_eq!(*x_ref, 0);/// *x_ref += 2;/// assert_eq!(*x_ref, 2);/// let ptr = NonNull::new(&mut x as *mut _).expect("null pointer");/// let casted_ptr = ptr.cast::<i8>();/// let raw_ptr: *mut i8 = casted_ptr.as_ptr();/// let aligned = NonNull::from_mut(&mut x);/// Adds an offset to a pointer./// * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`./// * If the computed offset is non-zero, then `self` must be derived from a pointer to some/// let ptr: NonNull<u32> = NonNull::new(s.as_mut_ptr()).unwrap();///     println!("{}", ptr.offset(1).read());///     println!("{}", ptr.offset(2).read());/// Calculates the offset from a pointer in bytes./// Adds an offset to a pointer (convenience for `.offset(count as isize)`)./// let ptr: NonNull<u8> = NonNull::new(s.as_ptr().cast_mut()).unwrap();///     println!("{}", ptr.add(1).read() as char);///     println!("{}", ptr.add(2).read() as char);/// Calculates the offset from a pointer in bytes (convenience for `.byte_offset(count as isize)`)./// using [`add`][NonNull::add] on it. See that method for documentation/// Subtracts an offset from a pointer (convenience for/// `.offset((count as isize).wrapping_neg())`).///     let end: NonNull<u8> = NonNull::new(s.as_ptr().cast_mut()).unwrap().add(3);///     println!("{}", end.sub(1).read() as char);///     println!("{}", end.sub(2).read() as char);/// Calculates the offset from a pointer in bytes (convenience for/// `.byte_offset((count as isize).wrapping_neg())`)./// using [`sub`][NonNull::sub] on it. See that method for documentation///   * both be *derived from* a pointer to the same [allocation], and the memory range between/// let ptr1: NonNull<u32> = NonNull::from(&a[1]);/// let ptr2: NonNull<u32> = NonNull::from(&a[3]);/// let ptr1 = NonNull::new(Box::into_raw(Box::new(0u8))).unwrap();/// let ptr2 = NonNull::new(Box::into_raw(Box::new(1u8))).unwrap();/// let diff = (ptr2.addr().get() as isize).wrapping_sub(ptr1.addr().get() as isize);/// let diff_plus_1 = diff.wrapping_add(1);/// let ptr2_other = NonNull::new(ptr1.as_ptr().wrapping_byte_offset(diff_plus_1)).unwrap();/// assert_eq!(ptr2.addr(), ptr2_other.addr());/// let one = unsafe { ptr2_other.offset_from(ptr2) }; // Undefined Behavior! ⚠️/// using [`offset_from`][NonNull::offset_from] on it. See that method for/// This method can be though of as recovering the `count` that was passed/// # unsafe fn blah(ptr: std::ptr::NonNull<u32>, origin: std::ptr::NonNull<u32>, count: usize) -> bool { unsafe {/// using [`offset_from_unsigned`][NonNull::offset_from_unsigned] on it./// The offset is expressed in number of `T` elements, and not bytes./// When this is called during compile-time evaluation (which is unstable), the implementation/// may return `usize::MAX` in cases where that can never happen at runtime. This is because the/// actual alignment of pointers is not known yet during compile-time, so an offset with/// guaranteed alignment can sometimes not be computed. For example, a buffer declared as `[u8;/// N]` might be allocated at an odd or an even address, but at compile-time this is not yet/// known, so the execution has to be correct for either choice. It is therefore impossible to/// find an offset that is guaranteed to be 2-aligned. (This behavior is subject to change, as usual/// for unstable APIs.)/// let ptr = NonNull::new(x.as_ptr() as *mut u8).unwrap();///     assert!(u16_ptr.read() == u16::from_ne_bytes([5, 6]) || u16_ptr.read() == u16::from_ne_bytes([6, 7]));/// let ptr = NonNull::<AlignedI32>::from(&data);/// assert!(!NonNull::new(ptr.as_ptr().wrapping_byte_add(1)).unwrap().is_aligned());// N.B. `wrapping_offset``, `wrapping_add`, etc are not implemented because they can wrap to null/// Creates a non-null raw slice from a thin pointer and a length./// This function is safe, but dereferencing the return value is unsafe./// let mut x = [5, 6, 7];/// let nonnull_pointer = NonNull::new(x.as_mut_ptr()).unwrap();/// let slice = NonNull::slice_from_raw_parts(nonnull_pointer, 3);/// assert_eq!(unsafe { slice.as_ref()[2] }, 7);/// (Note that this example artificially demonstrates a use of this method,/// but `let slice = NonNull::from(&x[..]);` would be a better way to write code like this.)/// Returns the length of a non-null raw slice./// This function is safe, even when the non-null raw slice cannot be dereferenced to a slice/// because the pointer does not have a valid address./// let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);/// Returns `true` if the non-null raw slice has a length of 0./// Returns a non-null pointer to the slice's buffer./// assert_eq!(slice.as_non_null_ptr(), NonNull::<i8>::dangling());/// assert_eq!(slice.as_mut_ptr(), NonNull::<i8>::dangling().as_ptr());/// Returns a shared reference to a slice of possibly uninitialized values. In contrast to/// [`as_ref`], this does not require that the value has to be initialized./// For the mutable counterpart see [`as_uninit_slice_mut`]./// [`as_uninit_slice_mut`]: NonNull::as_uninit_slice_mut/// When calling this method, you have to ensure that all of the following is true:/// * The pointer must be [valid] for reads for `ptr.len() * size_of::<T>()` many bytes,///   and it must be properly aligned. This means in particular:///     * The entire memory range of this slice must be contained within a single allocation!///   not get mutated (except inside `UnsafeCell`)./// See also [`slice::from_raw_parts`]./// Returns a unique reference to a slice of possibly uninitialized values. In contrast to/// [`as_mut`], this does not require that the value has to be initialized./// [`as_uninit_slice`]: NonNull::as_uninit_slice/// See also [`slice::from_raw_parts_mut`]./// #![feature(allocator_api, ptr_as_uninit)]/// use std::alloc::{Allocator, Layout, Global};/// let memory: NonNull<[u8]> = Global.allocate(Layout::new::<[u8; 32]>())?;/// // This is safe as `memory` is valid for reads and writes for `memory.len()` many bytes./// // Note that calling `memory.as_mut()` is not allowed here as the content may be uninitialized./// let slice: &mut [MaybeUninit<u8>] = unsafe { memory.as_uninit_slice_mut() };/// # unsafe { Global.deallocate(memory.cast(), Layout::new::<[u8; 32]>()); }/// # Ok::<_, std::alloc::AllocError>(())/// let x = &mut [1, 2, 4];/// let x = NonNull::slice_from_raw_parts(NonNull::new(x.as_mut_ptr()).unwrap(), x.len());///     assert_eq!(x.get_unchecked_mut(1).as_ptr(), x.as_non_null_ptr().as_ptr().add(1));/// Converts a `&mut T` to a `NonNull<T>`./// This conversion is safe and infallible since references cannot be null./// Converts a `&T` to a `NonNull<T>`.// NOTE: this marker has no consequences for variance, but is necessary// for dropck to understand that we logically own a `T`.// For details, see:// https://github.com/rust-lang/rfcs/blob/master/text/0769-sound-generic-drop.md#phantom-data/// A wrapper around a raw non-null `*mut T` that indicates that the possessor/// of this wrapper owns the referent. Useful for building abstractions like/// `Box<T>`, `Vec<T>`, `String`, and `HashMap<K, V>`./// Unlike `*mut T`, `Unique<T>` behaves "as if" it were an instance of `T`./// It implements `Send`/`Sync` if `T` is `Send`/`Sync`. It also implies/// the kind of strong aliasing guarantees an instance of `T` can expect:/// the referent of the pointer should not be modified without a unique path to/// its owning Unique./// If you're uncertain of whether it's correct to use `Unique` for your purposes,/// consider using `NonNull`, which has weaker semantics./// as a discriminant -- `Option<Unique<T>>` has the same size as `Unique<T>`./// Unlike `*mut T`, `Unique<T>` is covariant over `T`. This should always be correct/// for any type which upholds Unique's aliasing requirements./// `Unique` pointers are `Send` if `T` is `Send` because the data they/// reference is unaliased. Note that this aliasing invariant is/// unenforced by the type system; the abstraction using the/// `Unique` must enforce it./// `Unique` pointers are `Sync` if `T` is `Sync` because the data they/// Creates a new `Unique` that is dangling, but well-aligned./// Creates a new `Unique`./// Creates a new `Unique` if `ptr` is non-null./// Create a new `Unique` from a `NonNull` in const context./// Dereferences the content./// The resulting lifetime is bound to self so this behaves "as if"/// it were actually an instance of T that is getting borrowed. If a longer/// (unbound) lifetime is needed, use `&*my_ptr.as_ptr()`./// Mutably dereferences the content./// (unbound) lifetime is needed, use `&mut *my_ptr.as_ptr()`./// Converts a `&mut T` to a `Unique<T>`./// This conversion is infallible since references cannot be null./// Converts a `NonNull<T>` to a `Unique<T>`./// This conversion is infallible since `NonNull` cannot be null./// Fills `bytes` with random bytes./// Note that calling `fill_bytes` multiple times is not equivalent to calling `fill_bytes` once/// with a larger buffer. A `RandomSource` is allowed to return different bytes for those two/// cases. For instance, this allows a `RandomSource` to generate a word at a time and throw/// part of it away if not needed./// A source of randomness./// Samples a random value from the distribution, using the specified random source./// A trait representing a distribution of random values for a type.impl_primitive//! Random value generation./// By-value [`Range`] iterator./// Returns the remainder of the range being iterated over.RangeInclusiveIter/// By-value [`RangeInclusive`] iterator./// If the iterator is exhausted or empty, returns `None`./// Whether the first element of the iterator has yielded./// Only used when overflow checks are enabled.RangeFromIter/// By-value [`RangeFrom`] iterator.//! # Legacy range types//! The types within this module will be replaced by the types//! [`Range`], [`RangeInclusive`], [`RangeToInclusive`], and [`RangeFrom`] in the parent//! module, [`core::range`].//! The types here are equivalent to those in [`core::ops`]."RangeCopy"/// (`start..end` in a future edition)./// #![feature(new_range_api)]/// use core::range::Range;/// assert_eq!(Range::from(3..5), Range { start: 3, end: 5 });/// assert_eq!(3 + 4 + 5, Range::from(3..6).into_iter().sum());/// Creates an iterator over the elements within this range./// Shorthand for `.clone().into_iter()`/// let mut i = Range::from(3..9).iter().map(|n| n*n);/// assert_eq!(i.next(), Some(9));/// assert_eq!(i.next(), Some(16));/// assert_eq!(i.next(), Some(25));/// assert!(!Range::from(3..5).contains(&2));/// assert!( Range::from(3..5).contains(&3));/// assert!( Range::from(3..5).contains(&4));/// assert!(!Range::from(3..5).contains(&5));/// assert!(!Range::from(3..3).contains(&3));/// assert!(!Range::from(3..2).contains(&3));/// assert!( Range::from(0.0..1.0).contains(&0.5));/// assert!(!Range::from(0.0..1.0).contains(&f32::NAN));/// assert!(!Range::from(0.0..f32::NAN).contains(&0.5));/// assert!(!Range::from(f32::NAN..1.0).contains(&0.5));/// assert!(!Range::from(3..5).is_empty());/// assert!( Range::from(3..3).is_empty());/// assert!( Range::from(3..2).is_empty());/// assert!(!Range::from(3.0..5.0).is_empty());/// assert!( Range::from(3.0..f32::NAN).is_empty());/// assert!( Range::from(f32::NAN..5.0).is_empty());// #[unstable(feature = "range_into_bounds", issue = "136903")]"RangeInclusiveCopy"/// The upper bound of the range (inclusive)./// A range bounded inclusively below and above (`start..=last`)./// The `RangeInclusive` `start..=last` contains all values with `x >= start`/// and `x <= last`. It is empty unless `start <= last`./// The `start..=last` syntax is a `RangeInclusive`:/// use core::range::RangeInclusive;/// assert_eq!(RangeInclusive::from(3..=5), RangeInclusive { start: 3, last: 5 });/// assert_eq!(3 + 4 + 5, RangeInclusive::from(3..=5).into_iter().sum());/// assert!(!RangeInclusive::from(3..=5).contains(&2));/// assert!( RangeInclusive::from(3..=5).contains(&3));/// assert!( RangeInclusive::from(3..=5).contains(&4));/// assert!( RangeInclusive::from(3..=5).contains(&5));/// assert!(!RangeInclusive::from(3..=5).contains(&6));/// assert!( RangeInclusive::from(3..=3).contains(&3));/// assert!(!RangeInclusive::from(3..=2).contains(&3));/// assert!( RangeInclusive::from(0.0..=1.0).contains(&1.0));/// assert!(!RangeInclusive::from(0.0..=1.0).contains(&f32::NAN));/// assert!(!RangeInclusive::from(0.0..=f32::NAN).contains(&0.0));/// assert!(!RangeInclusive::from(f32::NAN..=1.0).contains(&1.0));/// assert!(!RangeInclusive::from(3..=5).is_empty());/// assert!(!RangeInclusive::from(3..=3).is_empty());/// assert!( RangeInclusive::from(3..=2).is_empty());/// assert!(!RangeInclusive::from(3.0..=5.0).is_empty());/// assert!( RangeInclusive::from(3.0..=f32::NAN).is_empty());/// assert!( RangeInclusive::from(f32::NAN..=5.0).is_empty());/// let mut i = RangeInclusive::from(3..=8).iter().map(|n| n*n);/// The caller is responsible for dealing with `last == usize::MAX`."RangeFromCopy"/// use core::range::RangeFrom;/// assert_eq!(RangeFrom::from(2..), core::range::RangeFrom { start: 2 });/// assert_eq!(2 + 3 + 4, RangeFrom::from(2..).into_iter().take(3).sum());/// let mut i = RangeFrom::from(3..).iter().map(|n| n*n);/// assert!(!RangeFrom::from(3..).contains(&2));/// assert!( RangeFrom::from(3..).contains(&3));/// assert!( RangeFrom::from(3..).contains(&1_000_000_000));/// assert!( RangeFrom::from(0.0..).contains(&0.5));/// assert!(!RangeFrom::from(0.0..).contains(&f32::NAN));/// assert!(!RangeFrom::from(f32::NAN..).contains(&0.5));"RangeToInclusiveCopy"/// A range only bounded inclusively above (`..=last`)./// The `RangeToInclusive` `..=last` contains all values with `x <= last`./// The `..=last` syntax is a `RangeToInclusive`:/// #![feature(new_range)]/// assert_eq!((..=5), std::range::RangeToInclusive{ last: 5 });/// // error[E0277]: the trait bound `std::range::RangeToInclusive<{integer}>:/// array elements up to and including the index indicated by `last`.//! # Experimental replacement range types//! The types within this module are meant to replace the existing//! `Range`, `RangeInclusive`, and `RangeFrom` types in a future edition.//! #![feature(new_range_api)]//! use core::range::{Range, RangeFrom, RangeInclusive};//! let arr = [0, 1, 2, 3, 4];//! assert_eq!(arr[                      ..   ], [0, 1, 2, 3, 4]);//! assert_eq!(arr[                      .. 3 ], [0, 1, 2      ]);//! assert_eq!(arr[                      ..=3 ], [0, 1, 2, 3   ]);//! assert_eq!(arr[     RangeFrom::from(1..  )], [   1, 2, 3, 4]);//! assert_eq!(arr[         Range::from(1..3 )], [   1, 2      ]);//! assert_eq!(arr[RangeInclusive::from(1..=3)], [   1, 2, 3   ]);"this `Result` may be an `Err` variant, which should be handled""Result""Ok"/// Contains the success value"Err"/// Contains the error value/// `Result` is a type that represents either success ([`Ok`]) or failure ([`Err`])."if you intended to assert that this is ok, consider `.unwrap()` instead"is_ok/// Returns `true` if the result is [`Ok`]./// let x: Result<i32, &str> = Ok(-3);/// assert_eq!(x.is_ok(), true);/// let x: Result<i32, &str> = Err("Some error message");/// assert_eq!(x.is_ok(), false);is_ok_and/// Returns `true` if the result is [`Ok`] and the value inside of it matches a predicate./// let x: Result<u32, &str> = Ok(2);/// assert_eq!(x.is_ok_and(|x| x > 1), true);/// let x: Result<u32, &str> = Ok(0);/// assert_eq!(x.is_ok_and(|x| x > 1), false);/// let x: Result<u32, &str> = Err("hey");/// let x: Result<String, &str> = Ok("ownership".to_string());/// assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);"if you intended to assert that this is err, consider `.unwrap_err()` instead"/// Returns `true` if the result is [`Err`]./// assert_eq!(x.is_err(), false);/// assert_eq!(x.is_err(), true);is_err_and/// Returns `true` if the result is [`Err`] and the value inside of it matches a predicate./// use std::io::{Error, ErrorKind};/// let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));/// assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);/// let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));/// assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);/// let x: Result<u32, Error> = Ok(123);/// let x: Result<u32, String> = Err("ownership".to_string());/// assert_eq!(x.as_ref().is_err_and(|x| x.len() > 1), true);"result_ok_method"/// Converts from `Result<T, E>` to [`Option<T>`]./// Converts `self` into an [`Option<T>`], consuming `self`,/// and discarding the error, if any./// assert_eq!(x.ok(), Some(2));/// let x: Result<u32, &str> = Err("Nothing here");/// assert_eq!(x.ok(), None);/// Converts from `Result<T, E>` to [`Option<E>`]./// Converts `self` into an [`Option<E>`], consuming `self`,/// and discarding the success value, if any./// assert_eq!(x.err(), None);/// assert_eq!(x.err(), Some("Nothing here"));/// Converts from `&Result<T, E>` to `Result<&T, &E>`./// Produces a new `Result`, containing a reference/// into the original, leaving the original in place./// assert_eq!(x.as_ref(), Ok(&2));/// let x: Result<u32, &str> = Err("Error");/// assert_eq!(x.as_ref(), Err(&"Error"));/// Converts from `&mut Result<T, E>` to `Result<&mut T, &mut E>`./// fn mutate(r: &mut Result<i32, i32>) {///     match r.as_mut() {///         Ok(v) => *v = 42,///         Err(e) => *e = 0,/// let mut x: Result<i32, i32> = Ok(2);/// mutate(&mut x);/// assert_eq!(x.unwrap(), 42);/// let mut x: Result<i32, i32> = Err(13);/// assert_eq!(x.unwrap_err(), 0);/// Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a/// contained [`Ok`] value, leaving an [`Err`] value untouched./// This function can be used to compose the results of two functions./// Print the numbers on each line of a string multiplied by two./// let line = "1\n2\n3\n4\n";/// for num in line.lines() {///     match num.parse::<i32>().map(|i| i * 2) {///         Ok(n) => println!("{n}"),///         Err(..) => {}/// Returns the provided default (if [`Err`]), or/// applies a function to the contained value (if [`Ok`])./// [`map_or_else`]: Result::map_or_else/// let x: Result<_, &str> = Ok("foo");/// let x: Result<&str, _> = Err("bar");/// Maps a `Result<T, E>` to `U` by applying fallback function `default` to/// a contained [`Err`] value, or function `f` to a contained [`Ok`] value./// This function can be used to unpack a successful result/// while handling an error./// let x : Result<_, &str> = Ok("foo");/// assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);/// let x : Result<&str, _> = Err("bar");/// assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);/// Maps a `Result<T, E>` to a `U` by applying function `f` to the contained/// value if the result is [`Ok`], otherwise if [`Err`], returns the/// let y: Result<&str, _> = Err("bar");/// assert_eq!(x.map_or_default(|x| x.len()), 3);/// Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a/// contained [`Err`] value, leaving an [`Ok`] value untouched./// This function can be used to pass through a successful result while handling/// fn stringify(x: u32) -> String { format!("error code: {x}") }/// let x: Result<u32, u32> = Ok(2);/// assert_eq!(x.map_err(stringify), Ok(2));/// let x: Result<u32, u32> = Err(13);/// assert_eq!(x.map_err(stringify), Err("error code: 13".to_string()));/// Calls a function with a reference to the contained value if [`Ok`]./// Returns the original result./// let x: u8 = "4"///     .parse::<u8>()///     .inspect(|x| println!("original: {x}"))///     .map(|x| x.pow(3))///     .expect("failed to parse number");/// Calls a function with a reference to the contained value if [`Err`]./// fn read() -> io::Result<String> {///     fs::read_to_string("address.txt")///         .inspect_err(|e| eprintln!("failed to read file: {e}"))/// Converts from `Result<T, E>` (or `&Result<T, E>`) to `Result<&<T as Deref>::Target, &E>`./// Coerces the [`Ok`] variant of the original [`Result`] via [`Deref`](crate::ops::Deref)/// and returns the new [`Result`]./// let x: Result<String, u32> = Ok("hello".to_string());/// let y: Result<&str, &u32> = Ok("hello");/// assert_eq!(x.as_deref(), y);/// let x: Result<String, u32> = Err(42);/// let y: Result<&str, &u32> = Err(&42);/// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut <T as DerefMut>::Target, &mut E>`./// Coerces the [`Ok`] variant of the original [`Result`] via [`DerefMut`](crate::ops::DerefMut)/// let mut s = "HELLO".to_string();/// let mut x: Result<String, u32> = Ok("hello".to_string());/// let y: Result<&mut str, &mut u32> = Ok(&mut s);/// assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);/// let mut i = 42;/// let mut x: Result<String, u32> = Err(42);/// let y: Result<&mut str, &mut u32> = Err(&mut i);/// The iterator yields one value if the result is [`Result::Ok`], otherwise none./// let x: Result<u32, &str> = Ok(7);/// assert_eq!(x.iter().next(), Some(&7));/// let x: Result<u32, &str> = Err("nothing!");/// let mut x: Result<u32, &str> = Ok(7);///     Some(v) => *v = 40,/// assert_eq!(x, Ok(40));/// let mut x: Result<u32, &str> = Err("nothing!");/// Returns the contained [`Ok`] value, consuming the `self` value./// Instead, prefer to use pattern matching and handle the [`Err`]/// [`unwrap_or_default`]./// [`unwrap_or`]: Result::unwrap_or/// [`unwrap_or_else`]: Result::unwrap_or_else/// [`unwrap_or_default`]: Result::unwrap_or_default/// Panics if the value is an [`Err`], with a panic message including the/// passed message, and the content of the [`Err`]./// let x: Result<u32, &str> = Err("emergency failure");/// x.expect("Testing expect"); // panics with `Testing expect: emergency failure`/// _expect_ the `Result` should be `Ok`./// let path = std::env::var("IMPORTANT_PATH")///     .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");/// For more detail on expect message styles and the reasoning behind our recommendation please/// refer to the section on ["Common Message/// Styles"](../../std/error/index.html#common-message-styles) in the/// [`std::error`](../../std/error/index.html) module docs./// Instead, prefer to use [the `?` (try) operator][try-operator], or pattern matching/// to handle the [`Err`] case explicitly, or call [`unwrap_or`],/// [`unwrap_or_else`], or [`unwrap_or_default`]./// [try-operator]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator/// Panics if the value is an [`Err`], with a panic message provided by the/// [`Err`]'s value./// assert_eq!(x.unwrap(), 2);/// x.unwrap(); // panics with `emergency failure`/// Returns the contained [`Ok`] value or a default/// Consumes the `self` argument then, if [`Ok`], returns the contained/// value, otherwise if [`Err`], returns the default value for that/// Converts a string to an integer, turning poorly-formed strings/// into 0 (the default value for integers). [`parse`] converts/// a string to any other type that implements [`FromStr`], returning an/// [`Err`] on error./// let good_year_from_input = "1909";/// let bad_year_from_input = "190blarg";/// let good_year = good_year_from_input.parse().unwrap_or_default();/// let bad_year = bad_year_from_input.parse().unwrap_or_default();/// assert_eq!(1909, good_year);/// assert_eq!(0, bad_year);expect_err/// Returns the contained [`Err`] value, consuming the `self` value./// Panics if the value is an [`Ok`], with a panic message including the/// passed message, and the content of the [`Ok`]./// let x: Result<u32, &str> = Ok(10);/// x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`/// Panics if the value is an [`Ok`], with a custom panic message provided/// by the [`Ok`]'s value./// x.unwrap_err(); // panics with `2`/// assert_eq!(x.unwrap_err(), "emergency failure");into_ok/// Returns the contained [`Ok`] value, but never panics./// Unlike [`unwrap`], this method is known to never panic on the/// result types it is implemented for. Therefore, it can be used/// instead of `unwrap` as a maintainability safeguard that will fail/// to compile if the error type of the `Result` is later changed/// to an error that can actually occur./// [`unwrap`]: Result::unwrap/// # #![feature(unwrap_infallible)]/// fn only_good_news() -> Result<String, !> {///     Ok("this is fine".into())/// let s: String = only_good_news().into_ok();/// println!("{s}");/// Returns the contained [`Err`] value, but never panics./// Unlike [`unwrap_err`], this method is known to never panic on the/// instead of `unwrap_err` as a maintainability safeguard that will fail/// to compile if the ok type of the `Result` is later changed/// to a type that can actually occur./// [`unwrap_err`]: Result::unwrap_err/// fn only_bad_news() -> Result<!, String> {///     Err("Oops, it failed".into())/// let error: String = only_bad_news().into_err();/// println!("{error}");/// Returns `res` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`./// [`and_then`]: Result::and_then/// let y: Result<&str, &str> = Err("late error");/// assert_eq!(x.and(y), Err("late error"));/// let x: Result<u32, &str> = Err("early error");/// let y: Result<&str, &str> = Ok("foo");/// assert_eq!(x.and(y), Err("early error"));/// let x: Result<u32, &str> = Err("not a 2");/// assert_eq!(x.and(y), Err("not a 2"));/// let y: Result<&str, &str> = Ok("different result type");/// assert_eq!(x.and(y), Ok("different result type"));/// Calls `op` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`./// This function can be used for control flow based on `Result` values./// fn sq_then_to_string(x: u32) -> Result<String, &'static str> {///     x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")/// assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));/// assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));/// assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));/// Often used to chain fallible operations that may return [`Err`]./// use std::{io::ErrorKind, path::Path};/// // Note: on Windows "/" maps to "C:\"/// let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());/// assert!(root_modified_time.is_ok());/// let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());/// assert!(should_fail.is_err());/// assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);/// Returns `res` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`./// [`or_else`]: Result::or_else/// let y: Result<u32, &str> = Err("late error");/// assert_eq!(x.or(y), Ok(2));/// let y: Result<u32, &str> = Ok(2);/// assert_eq!(x.or(y), Err("late error"));/// let y: Result<u32, &str> = Ok(100);/// Calls `op` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`./// This function can be used for control flow based on result values./// fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }/// fn err(x: u32) -> Result<u32, u32> { Err(x) }/// assert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));/// assert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));/// assert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));/// assert_eq!(Err(3).or_else(err).or_else(err), Err(3));/// Returns the contained [`Ok`] value or a provided default./// let default = 2;/// let x: Result<u32, &str> = Ok(9);/// assert_eq!(x.unwrap_or(default), 9);/// let x: Result<u32, &str> = Err("error");/// assert_eq!(x.unwrap_or(default), default);/// Returns the contained [`Ok`] value or computes it from a closure./// fn count(x: &str) -> usize { x.len() }/// assert_eq!(Ok(2).unwrap_or_else(count), 2);/// assert_eq!(Err("foo").unwrap_or_else(count), 3);/// Returns the contained [`Ok`] value, consuming the `self` value,/// without checking that the value is not an [`Err`]./// Calling this method on an [`Err`] is *[undefined behavior]*./// assert_eq!(unsafe { x.unwrap_unchecked() }, 2);/// unsafe { x.unwrap_unchecked() }; // Undefined behavior!unwrap_err_unchecked/// Returns the contained [`Err`] value, consuming the `self` value,/// without checking that the value is not an [`Ok`]./// Calling this method on an [`Ok`] is *[undefined behavior]*./// unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!/// assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");// Adapter for each variant// Extract a value/////////////////////////////////////////////////////////////////////////// Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the/// `Ok` part./// let val = 12;/// let x: Result<&i32, i32> = Ok(&val);/// assert_eq!(x, Ok(&12));/// let copied = x.copied();/// assert_eq!(copied, Ok(12));/// Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the/// let cloned = x.cloned();/// assert_eq!(cloned, Ok(12));/// Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the/// let mut val = 12;/// let x: Result<&mut i32, i32> = Ok(&mut val);/// assert_eq!(x, Ok(&mut 12));/// Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the/// Transposes a `Result` of an `Option` into an `Option` of a `Result`./// `Ok(None)` will be mapped to `None`./// `Ok(Some(_))` and `Err(_)` will be mapped to `Some(Ok(_))` and `Some(Err(_))`./// let x: Result<Option<i32>, SomeErr> = Ok(Some(5));/// let y: Option<Result<i32, SomeErr>> = Some(Ok(5));/// Converts from `Result<Result<T, E>, E>` to `Result<T, E>`/// let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));/// assert_eq!(Ok("hello"), x.flatten());/// let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));/// assert_eq!(Err(6), x.flatten());/// let x: Result<Result<&'static str, u32>, u32> = Err(6);/// let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));/// assert_eq!(Ok(Ok("hello")), x.flatten());/// assert_eq!(Ok("hello"), x.flatten().flatten());// This is a separate function to reduce the code size of the methods/// let x: Result<u32, &str> = Ok(5);/// let v: Vec<u32> = x.into_iter().collect();/// assert_eq!(v, [5]);/// assert_eq!(v, []);/// An iterator over a reference to the [`Ok`] variant of a [`Result`]./// The iterator yields one value if the result is [`Ok`], otherwise none./// Created by [`Result::iter`]./// An iterator over a mutable reference to the [`Ok`] variant of a [`Result`]./// Created by [`Result::iter_mut`]./// An iterator over the value in a [`Ok`] variant of a [`Result`]./// This struct is created by the [`into_iter`] method on/// [`Result`] (provided by the [`IntoIterator`] trait)./// Takes each element in the `Iterator`: if it is an `Err`, no further/// elements are taken, and the `Err` is returned. Should no `Err` occur, a/// container with the values of each `Result` is returned./// Here is an example which increments every integer in a vector,/// checking for overflow:/// let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|///     x.checked_add(1).ok_or("Overflow!")/// assert_eq!(res, Ok(vec![2, 3]));/// let v = vec![1, 2, 0];///     x.checked_sub(1).ok_or("Underflow!")/// assert_eq!(res, Err("Underflow!"));/// further elements are taken from `iter` after the first `Err`./// let v = vec![3, 2, 1, 10];/// let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {///     shared += x;///     x.checked_sub(2).ok_or("Underflow!")//! Error handling with the `Result` type.//! [`Result<T, E>`][`Result`] is the type used for returning and propagating//! errors. It is an enum with the variants, [`Ok(T)`], representing//! success and containing a value, and [`Err(E)`], representing error//! and containing an error value.//! enum Result<T, E> {//!    Ok(T),//!    Err(E),//! Functions return [`Result`] whenever errors are expected and//! recoverable. In the `std` crate, [`Result`] is most prominently used//! for [I/O](../../std/io/index.html).//! A simple function returning [`Result`] might be//! defined and used like so://! enum Version { Version1, Version2 }//! fn parse_version(header: &[u8]) -> Result<Version, &'static str> {//!     match header.get(0) {//!         None => Err("invalid header length"),//!         Some(&1) => Ok(Version::Version1),//!         Some(&2) => Ok(Version::Version2),//!         Some(_) => Err("invalid version"),//! let version = parse_version(&[1, 2, 3, 4]);//! match version {//!     Ok(v) => println!("working with version: {v:?}"),//!     Err(e) => println!("error parsing header: {e:?}"),//! Pattern matching on [`Result`]s is clear and straightforward for//! simple cases, but [`Result`] comes with some convenience methods//! that make working with it more succinct.//! // The `is_ok` and `is_err` methods do what they say.//! let good_result: Result<i32, i32> = Ok(10);//! let bad_result: Result<i32, i32> = Err(10);//! assert!(good_result.is_ok() && !good_result.is_err());//! assert!(bad_result.is_err() && !bad_result.is_ok());//! // `map` and `map_err` consume the `Result` and produce another.//! let good_result: Result<i32, i32> = good_result.map(|i| i + 1);//! let bad_result: Result<i32, i32> = bad_result.map_err(|i| i - 1);//! assert_eq!(good_result, Ok(11));//! assert_eq!(bad_result, Err(9));//! // Use `and_then` to continue the computation.//! let good_result: Result<bool, i32> = good_result.and_then(|i| Ok(i == 11));//! assert_eq!(good_result, Ok(true));//! // Use `or_else` to handle the error.//! let bad_result: Result<i32, i32> = bad_result.or_else(|i| Ok(i + 20));//! assert_eq!(bad_result, Ok(29));//! // Consume the result and return the contents with `unwrap`.//! let final_awesome_result = good_result.unwrap();//! assert!(final_awesome_result)//! # Results must be used//! A common problem with using return values to indicate errors is//! that it is easy to ignore the return value, thus failing to handle//! the error. [`Result`] is annotated with the `#[must_use]` attribute,//! which will cause the compiler to issue a warning when a Result//! value is ignored. This makes [`Result`] especially useful with//! functions that may encounter errors but don't otherwise return a//! useful value.//! Consider the [`write_all`] method defined for I/O types//! by the [`Write`] trait://! trait Write {//!     fn write_all(&mut self, bytes: &[u8]) -> Result<(), io::Error>;//! *Note: The actual definition of [`Write`] uses [`io::Result`], which//! is just a synonym for <code>[Result]<T, [io::Error]></code>.*//! This method doesn't produce a value, but the write may//! fail. It's crucial to handle the error case, and *not* write//! something like this://! # #![allow(unused_must_use)] // \o///! let mut file = File::create("valuable_data.txt").unwrap();//! // If `write_all` errors, then we'll never know, because the return//! // value is ignored.//! file.write_all(b"important message");//! If you *do* write that in Rust, the compiler will give you a//! warning (by default, controlled by the `unused_must_use` lint).//! You might instead, if you don't want to handle the error, simply//! assert success with [`expect`]. This will panic if the//! write fails, providing a marginally useful message indicating why://! file.write_all(b"important message").expect("failed to write message");//! You might also simply assert success://! # let mut file = File::create("valuable_data.txt").unwrap();//! assert!(file.write_all(b"important message").is_ok());//! Or propagate the error up the call stack with [`?`]://! fn write_message() -> io::Result<()> {//!     let mut file = File::create("valuable_data.txt")?;//!     file.write_all(b"important message")?;//! When writing code that calls many functions that return the//! [`Result`] type, the error handling can be tedious. The question mark//! operator, [`?`], hides some of the boilerplate of propagating errors//! struct Info {//!     age: i32,//!     rating: i32,//! fn write_info(info: &Info) -> io::Result<()> {//!     // Early return on error//!     let mut file = match File::create("my_best_friends.txt") {//!            Err(e) => return Err(e),//!            Ok(f) => f,//!     if let Err(e) = file.write_all(format!("name: {}\n", info.name).as_bytes()) {//!         return Err(e)//!     if let Err(e) = file.write_all(format!("age: {}\n", info.age).as_bytes()) {//!     if let Err(e) = file.write_all(format!("rating: {}\n", info.rating).as_bytes()) {//!     let mut file = File::create("my_best_friends.txt")?;//!     file.write_all(format!("name: {}\n", info.name).as_bytes())?;//!     file.write_all(format!("age: {}\n", info.age).as_bytes())?;//!     file.write_all(format!("rating: {}\n", info.rating).as_bytes())?;//! Ending the expression with [`?`] will result in the [`Ok`]'s unwrapped value, unless the result//! is [`Err`], in which case [`Err`] is returned early from the enclosing function.//! [`?`] can be used in functions that return [`Result`] because of the//! early return of [`Err`] that it provides.//! [`expect`]: Result::expect//! [`Write`]: ../../std/io/trait.Write.html "io::Write"//! [`write_all`]: ../../std/io/trait.Write.html#method.write_all "io::Write::write_all"//! [`io::Result`]: ../../std/io/type.Result.html "io::Result"//! [`Ok(T)`]: Ok//! [`Err(E)`]: Err//! [io::Error]: ../../std/io/struct.Error.html "io::Error"//! In some cases, [`Result<T, E>`] comes with size, alignment, and ABI//! guarantees. Specifically, one of either the `T` or `E` type must be a type//! that qualifies for the `Option` [representation guarantees][opt-rep] (let's//! call that type `I`), and the *other* type is a zero-sized type with//! alignment 1 (a "1-ZST").//! If that is the case, then `Result<T, E>` has the same size, alignment, and//! [function call ABI] as `I` (and therefore, as `Option<I>`). If `I` is `T`,//! it is therefore sound to transmute a value `t` of type `I` to type//! `Result<T, E>` (producing the value `Ok(t)`) and to transmute a value//! `Ok(t)` of type `Result<T, E>` to type `I` (producing the value `t`). If `I`//! is `E`, the same applies with `Ok` replaced by `Err`.//! For example, `NonZeroI32` qualifies for the `Option` representation//! guarantees and `()` is a zero-sized type with alignment 1. This means that//! both `Result<NonZeroI32, ()>` and `Result<(), NonZeroI32>` have the same//! size, alignment, and ABI as `NonZeroI32` (and `Option<NonZeroI32>`). The//! only difference between these is in the implied semantics://! * `Option<NonZeroI32>` is "a non-zero i32 might be present"//! * `Result<NonZeroI32, ()>` is "a non-zero i32 success result, if any"//! * `Result<(), NonZeroI32>` is "a non-zero i32 error result, if any"//! [opt-rep]: ../option/index.html#representation "Option Representation"//! In addition to working with pattern matching, [`Result`] provides a//! wide variety of different methods.//! The [`is_ok`] and [`is_err`] methods return [`true`] if the [`Result`]//! is [`Ok`] or [`Err`], respectively.//! The [`is_ok_and`] and [`is_err_and`] methods apply the provided function//! to the contents of the [`Result`] to produce a boolean value. If the [`Result`] does not have the expected variant//! then [`false`] is returned instead without executing the function.//! [`is_err`]: Result::is_err//! [`is_ok`]: Result::is_ok//! [`is_ok_and`]: Result::is_ok_and//! [`is_err_and`]: Result::is_err_and//! * [`as_ref`] converts from `&Result<T, E>` to `Result<&T, &E>`//! * [`as_mut`] converts from `&mut Result<T, E>` to `Result<&mut T, &mut E>`//! * [`as_deref`] converts from `&Result<T, E>` to `Result<&T::Target, &E>`//! * [`as_deref_mut`] converts from `&mut Result<T, E>` to//!   `Result<&mut T::Target, &mut E>`//! [`as_deref`]: Result::as_deref//! [`as_deref_mut`]: Result::as_deref_mut//! [`as_mut`]: Result::as_mut//! [`as_ref`]: Result::as_ref//! ## Extracting contained values//! These methods extract the contained value in a [`Result<T, E>`] when it//! is the [`Ok`] variant. If the [`Result`] is [`Err`]://! The panicking methods [`expect`] and [`unwrap`] require `E` to//! implement the [`Debug`] trait.//! [`Debug`]: crate::fmt::Debug//! [`unwrap`]: Result::unwrap//! [`unwrap_or`]: Result::unwrap_or//! [`unwrap_or_default`]: Result::unwrap_or_default//! [`unwrap_or_else`]: Result::unwrap_or_else//! [`unwrap_unchecked`]: Result::unwrap_unchecked//! is the [`Err`] variant. They require `T` to implement the [`Debug`]//! trait. If the [`Result`] is [`Ok`]://! * [`expect_err`] panics with a provided custom message//! * [`unwrap_err`] panics with a generic message//! * [`unwrap_err_unchecked`] produces *[undefined behavior]*//! [`expect_err`]: Result::expect_err//! [`unwrap_err`]: Result::unwrap_err//! [`unwrap_err_unchecked`]: Result::unwrap_err_unchecked//! These methods transform [`Result`] to [`Option`]://! * [`err`][Result::err] transforms [`Result<T, E>`] into [`Option<E>`],//!   mapping [`Err(e)`] to [`Some(e)`] and [`Ok(v)`] to [`None`]//! * [`ok`][Result::ok] transforms [`Result<T, E>`] into [`Option<T>`],//!   mapping [`Ok(v)`] to [`Some(v)`] and [`Err(e)`] to [`None`]//! * [`transpose`] transposes a [`Result`] of an [`Option`] into an//!   [`Option`] of a [`Result`]// Do NOT add link reference definitions for `err` or `ok`, because they// will generate numerous incorrect URLs for `Err` and `Ok` elsewhere, due// to case folding.//! [`Err(e)`]: Err//! [`Some(e)`]: Option::Some//! [`Some(v)`]: Option::Some//! [`transpose`]: Result::transpose//! These methods transform the contained value of the [`Ok`] variant://! * [`map`] transforms [`Result<T, E>`] into [`Result<U, E>`] by applying//!   the provided function to the contained value of [`Ok`] and leaving//!   [`Err`] values unchanged//! * [`inspect`] takes ownership of the [`Result`], applies the//!   provided function to the contained value by reference,//!   and then returns the [`Result`]//! [`map`]: Result::map//! [`inspect`]: Result::inspect//! These methods transform the contained value of the [`Err`] variant://! * [`map_err`] transforms [`Result<T, E>`] into [`Result<T, F>`] by//!   applying the provided function to the contained value of [`Err`] and//!   leaving [`Ok`] values unchanged//! * [`inspect_err`] takes ownership of the [`Result`], applies the//!   provided function to the contained value of [`Err`] by reference,//! [`map_err`]: Result::map_err//! [`inspect_err`]: Result::inspect_err//! These methods transform a [`Result<T, E>`] into a value of a possibly//!   [`Ok`], or returns the provided default value if the [`Result`] is//!   [`Err`]//!   of [`Ok`], or applies the provided default fallback function to the//!   contained value of [`Err`]//! [`map_or`]: Result::map_or//! [`map_or_else`]: Result::map_or_else//! These methods treat the [`Result`] as a boolean value, where [`Ok`]//! acts like [`true`] and [`Err`] acts like [`false`]. There are two//! categories of these methods: ones that take a [`Result`] as input, and//! The [`and`] and [`or`] methods take another [`Result`] as input, and//! produce a [`Result`] as output. The [`and`] method can produce a//! [`Result<U, E>`] value having a different inner type `U` than//! [`Result<T, E>`]. The [`or`] method can produce a [`Result<T, F>`]//! value having a different error type `F` than [`Result<T, E>`].//! | method  | self     | input     | output   |//! |---------|----------|-----------|----------|//! | [`and`] | `Err(e)` | (ignored) | `Err(e)` |//! | [`and`] | `Ok(x)`  | `Err(d)`  | `Err(d)` |//! | [`and`] | `Ok(x)`  | `Ok(y)`   | `Ok(y)`  |//! | [`or`]  | `Err(e)` | `Err(d)`  | `Err(d)` |//! | [`or`]  | `Err(e)` | `Ok(y)`   | `Ok(y)`  |//! | [`or`]  | `Ok(x)`  | (ignored) | `Ok(x)`  |//! [`and`]: Result::and//! [`or`]: Result::or//! only evaluate the function when they need to produce a new value. The//! [`and_then`] method can produce a [`Result<U, E>`] value having a//! different inner type `U` than [`Result<T, E>`]. The [`or_else`] method//! can produce a [`Result<T, F>`] value having a different error type `F`//! than [`Result<T, E>`].//! | method       | self     | function input | function result | output   |//! |--------------|----------|----------------|-----------------|----------|//! | [`and_then`] | `Err(e)` | (not provided) | (not evaluated) | `Err(e)` |//! | [`and_then`] | `Ok(x)`  | `x`            | `Err(d)`        | `Err(d)` |//! | [`and_then`] | `Ok(x)`  | `x`            | `Ok(y)`         | `Ok(y)`  |//! | [`or_else`]  | `Err(e)` | `e`            | `Err(d)`        | `Err(d)` |//! | [`or_else`]  | `Err(e)` | `e`            | `Ok(y)`         | `Ok(y)`  |//! | [`or_else`]  | `Ok(x)`  | (not provided) | (not evaluated) | `Ok(x)`  |//! [`and_then`]: Result::and_then//! [`or_else`]: Result::or_else//! If `T` and `E` both implement [`PartialOrd`] then [`Result<T, E>`] will//! derive its [`PartialOrd`] implementation.  With this order, an [`Ok`]//! compares as less than any [`Err`], while two [`Ok`] or two [`Err`]//! compare as their contained values would in `T` or `E` respectively.  If `T`//! and `E` both also implement [`Ord`], then so does [`Result<T, E>`].//! assert!(Ok(1) < Err(0));//! let x: Result<i32, ()> = Ok(0);//! let y = Ok(1);//! assert!(x < y);//! let x: Result<(), i32> = Err(0);//! let y = Err(1);//! ## Iterating over `Result`//! A [`Result`] can be iterated over. This can be helpful if you need an//! a single value (when the [`Result`] is [`Ok`]), or produce no values//! (when the [`Result`] is [`Err`]). For example, [`into_iter`] acts like//! [`once(v)`] if the [`Result`] is [`Ok(v)`], and like [`empty()`] if the//! [`Result`] is [`Err`].//! Iterators over [`Result<T, E>`] come in three types://! * [`into_iter`] consumes the [`Result`] and produces the contained//! See [Iterating over `Option`] for examples of how this can be useful.//! [Iterating over `Option`]: crate::option#iterating-over-option//! [`into_iter`]: Result::into_iter//! [`iter`]: Result::iter//! [`iter_mut`]: Result::iter_mut//! You might want to use an iterator chain to do multiple instances of an//! operation that can fail, but would like to ignore failures while//! continuing to process the successful results. In this example, we take//! advantage of the iterable nature of [`Result`] to select only the//! [`Ok`] values using [`flatten`][Iterator::flatten].//! # use std::str::FromStr;//! let mut results = vec![];//! let mut errs = vec![];//! let nums: Vec<_> = ["17", "not a number", "99", "-27", "768"]//!    .into_iter()//!    .map(u8::from_str)//!    // Save clones of the raw `Result` values to inspect//!    .inspect(|x| results.push(x.clone()))//!    // Challenge: explain how this captures only the `Err` values//!    .inspect(|x| errs.extend(x.clone().err()))//!    .flatten()//!    .collect();//! assert_eq!(errs.len(), 3);//! assert_eq!(nums, [17, 99]);//! println!("results {results:?}");//! println!("errs {errs:?}");//! println!("nums {nums:?}");//! ## Collecting into `Result`//! [`Result`] implements the [`FromIterator`][impl-FromIterator] trait,//! which allows an iterator over [`Result`] values to be collected into a//! [`Result`] of a collection of each contained value of the original//! [`Result`] values, or [`Err`] if any of the elements was [`Err`].//! [impl-FromIterator]: Result#impl-FromIterator%3CResult%3CA,+E%3E%3E-for-Result%3CV,+E%3E//! let v = [Ok(2), Ok(4), Err("err!"), Ok(8)];//! let res: Result<Vec<_>, &str> = v.into_iter().collect();//! assert_eq!(res, Err("err!"));//! let v = [Ok(2), Ok(4), Ok(8)];//! assert_eq!(res, Ok(vec![2, 4, 8]));//! [`Result`] also implements the [`Product`][impl-Product] and//! [`Sum`][impl-Sum] traits, allowing an iterator over [`Result`] values//! [impl-Product]: Result#impl-Product%3CResult%3CU,+E%3E%3E-for-Result%3CT,+E%3E//! [impl-Sum]: Result#impl-Sum%3CResult%3CU,+E%3E%3E-for-Result%3CT,+E%3E//! let v = [Err("error!"), Ok(1), Ok(2), Ok(3), Err("foo")];//! let res: Result<i32, &str> = v.into_iter().sum();//! assert_eq!(res, Err("error!"));//! let v = [Ok(1), Ok(2), Ok(21)];//! let res: Result<i32, &str> = v.into_iter().product();//! assert_eq!(res, Ok(42));// The Result Iterators/// Checks if all bytes in this slice are within the ASCII range./// An empty slice returns `true`./// If this slice [`is_ascii`](Self::is_ascii), returns it as a slice of/// [ASCII characters](`ascii::Char`), otherwise returns `None`./// Converts this slice of bytes into a slice of ASCII characters,/// Every byte in the slice must be in `0..=127`, or else this is UB./// Checks that two slices are an ASCII case-insensitive match./// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,/// but without allocating and copying temporaries./// Converts this slice to its ASCII upper case equivalent in-place./// [`to_ascii_uppercase`]: #method.to_ascii_uppercase/// Converts this slice to its ASCII lower case equivalent in-place./// [`to_ascii_lowercase`]: #method.to_ascii_lowercase"this returns the escaped bytes as an iterator, \
                  without modifying the original"/// Returns an iterator that produces an escaped version of this slice,/// treating it as an ASCII string./// let s = b"0\t\r\n'\"\\\x9d";/// let escaped = s.escape_ascii().to_string();/// assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");trim_ascii_start/// Returns a byte slice with leading ASCII whitespace bytes removed./// 'Whitespace' refers to the definition used by/// [`u8::is_ascii_whitespace`]./// assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");/// assert_eq!(b"  ".trim_ascii_start(), b"");/// assert_eq!(b"".trim_ascii_start(), b"");trim_ascii_end/// Returns a byte slice with trailing ASCII whitespace bytes removed./// assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");/// assert_eq!(b"  ".trim_ascii_end(), b"");/// assert_eq!(b"".trim_ascii_end(), b"");trim_ascii/// Returns a byte slice with leading and trailing ASCII whitespace bytes/// assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");/// assert_eq!(b"  ".trim_ascii(), b"");/// assert_eq!(b"".trim_ascii(), b"");EscapeByte/// An iterator over the escaped version of a byte slice./// This `struct` is created by the [`slice::escape_ascii`] method. See itsis_ascii_simple/// ASCII test *without* the chunk-at-a-time optimizations./// This is carefully structured to produce nice small code -- it's smaller in/// `-O` than what the "obvious" ways produces under `-C opt-level=s`.  If you/// touch it, be sure to run (and update if needed) the assembly test./// ASCII test optimized to use the `pmovmskb` instruction on `x86-64` and the/// `vmskltz.b` instruction on `loongarch64`./// Other platforms are not likely to benefit from this code structure, so they/// use SWAR techniques to test for ASCII in `usize`-sized chunks.//! Operations on ASCII `[u8]`./// Implements comparison of slices [lexicographically](Ord#lexicographical-comparison).as_underlyingnot_equalSlicePartialEq// intermediate trait for specialization of slice's PartialEq// Generic slice equality// When each element can be compared byte-wise, we can compare all the bytes// from the whole size in one call to the intrinsics.partial_compareSlicePartialOrd// intermediate trait for specialization of slice's PartialOrdchaining_ltchaining_lechaining_gtchaining_geSliceChain// intermediate trait for specialization of slice's PartialOrd chaining methodsAlwaysBreakchaining_implAlwaysApplicableOrdSliceOrdalways_applicable_ord// intermediate trait for specialization of slice's OrdUnsignedBytewiseOrd/// Marks that a type should be treated as an unsigned byte for comparisons./// * The type must be readable as an `u8`, meaning it has to have the same///   layout as `u8` and always be initialized./// * For every `x` and `y` of this type, `Ord(x, y)` must return the same///   value as `Ord::cmp(transmute::<_, u8>(x), transmute::<_, u8>(y))`.// `compare_bytes` compares a sequence of unsigned bytes lexicographically, so// use it if the requirements for `UnsignedBytewiseOrd` are fulfilled.slice_containsSliceContainsimpl_slice_contains//! Comparison traits for `[T]`.// This is the impl that we would like to have. Unfortunately it's not sound.// See `partial_ord_slice.rs`./*
impl<A> SlicePartialOrd for A
where
    A: Ord,
{
    default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
        Some(SliceOrd::compare(left, right))
    }
}
*/// Don't generate our own chaining loops for `memcmp`-able things either.slice_index_failget_offset_len_noubcheckget_offset_len_mut_noubcheckprivate_slice_index/// The output type returned by methods./// Returns a shared reference to the output at this location, if in/// Returns a mutable reference to the output at this location, if in/// Returns a pointer to the output at this location, without/// performing any bounds checking./// Calling this method with an out-of-bounds index or a dangling `slice` pointer/// Returns a mutable pointer to the output at this location, without/// Returns a shared reference to the output at this location, panicking/// if out of bounds./// Returns a mutable reference to the output at this location, panicking"SliceIndex"/// A helper trait used for indexing operations./// Implementations of this trait have to promise that if the argument/// to `get_unchecked(_mut)` is a safe reference, then so is the result./// The methods `index` and `index_mut` panic if the index is out of bounds./// Because `IndexRange` guarantees `start <= end`, fewer checks are needed here/// than there are for a general `Range<usize>` (which might be `100..3`)./// The methods `index` and `index_mut` panic if:/// - the start of the range is greater than the end of the range or/// - the end of the range is out of bounds./// The methods `index` and `index_mut` panic if the end of the range is out of bounds./// The methods `index` and `index_mut` panic if the start of the range is out of bounds./// - the end of the range is `usize::MAX` or/// Performs bounds checking of a range./// This method is similar to [`Index::index`] for slices, but it returns a/// [`Range`] equivalent to `range`. You can use this method to turn any range/// into `start` and `end` values./// `bounds` is the range of the slice to use for bounds checking. It should/// be a [`RangeTo`] range that ends at the length of the slice./// The returned [`Range`] is safe to pass to [`slice::get_unchecked`] and/// [`slice::get_unchecked_mut`] for slices with the given range./// [`Range`]: ops::Range/// [`RangeTo`]: ops::RangeTo/// [`slice::get_unchecked`]: slice::get_unchecked/// [`slice::get_unchecked_mut`]: slice::get_unchecked_mut/// Panics if `range` would be out of bounds./// #![feature(slice_range)]/// let v = [10, 40, 30];/// assert_eq!(1..2, slice::range(1..2, ..v.len()));/// assert_eq!(0..2, slice::range(..2, ..v.len()));/// assert_eq!(1..3, slice::range(1.., ..v.len()));/// Panics when [`Index::index`] would panic:/// let _ = slice::range(2..1, ..3);/// let _ = slice::range(1..4, ..3);/// let _ = slice::range(1..=usize::MAX, ..3);/// [`Index::index`]: ops::Index::index/// Performs bounds checking of a range without panicking./// This is a version of [`range()`] that returns [`None`] instead of panicking./// assert_eq!(Some(1..2), slice::try_range(1..2, ..v.len()));/// assert_eq!(Some(0..2), slice::try_range(..2, ..v.len()));/// assert_eq!(Some(1..3), slice::try_range(1.., ..v.len()));/// Returns [`None`] when [`Index::index`] would panic:/// assert_eq!(None, slice::try_range(2..1, ..3));/// assert_eq!(None, slice::try_range(1..4, ..3));/// assert_eq!(None, slice::try_range(1..=usize::MAX, ..3));into_range_unchecked/// Converts a pair of `ops::Bound`s into `ops::Range` without performing any/// bounds checking or (in debug) overflow checking./// Converts pair of `ops::Bound`s into `ops::Range`./// Returns `None` on overflowing indices./// Panics on overflowing indices.//! Indexing implementations for `[T]`.// The UbChecks are great for catching bugs in the unsafe methods, but including// them in safe indexing is unnecessary and hurts inlining and debug runtime perf.// Both the safe and unsafe public methods share these helpers,// which use intrinsics directly to get *no* extra checks.if_zst/// Convenience & performance macro for consuming the `end_or_len` field, by/// giving a `(&mut) usize` or `(&mut) NonNull<T>` depending whether `T` is/// or is not a ZST respectively./// Internally, this reads the `end` through a pointer-to-`NonNull` so that/// it'll get the appropriate non-null metadata in the backend without needing/// to call `assume` manually.// Inlining is_empty and len makes a huge performance difference// The shared definition of the `Iter` and `IterMut` iteratorsforward_iterator//! Macros used by iterators of slice.// import iterator! and forward_iterator!"SliceIter"/// if the iterator is empty.end_or_len/// For ZSTs, this is `ptr::without_provenance_mut(len)`./// Immutable slice iterator/// This struct is created by the [`iter`] method on [slices]./// // First, we need a slice to call the `iter` method on:/// let slice = &[1, 2, 3];/// // Then we call `iter` on the slice to get the `Iter` iterator,/// // and iterate over it:/// for element in slice.iter() {///     println!("{element}");/// // This for loop actually already works without calling `iter`:/// for element in slice {/// [`iter`]: slice::iter/// [slices]: slice/// // Then we call `iter` on the slice to get the `Iter` iterator:/// let mut iter = slice.iter();/// // Here `as_slice` still returns the whole slice, so this prints "[1, 2, 3]":/// println!("{:?}", iter.as_slice());/// // Now, we call the `next` method to remove the first element from the iterator:/// // Here the iterator does not contain the first element of the slice any more,/// // so `as_slice` only returns the last two elements of the slice,/// // and so this prints "[2, 3]":/// // The underlying slice has not been modified and still contains three elements,/// // so this prints "[1, 2, 3]":/// println!("{:?}", slice);r" Returns the last element and moves the end of the iterator backwards by 1."r" The iterator must not be empty"make_slicepost_inc_startpre_dec_endr" Creates an empty slice iterator."r" assert_eq!(iter.len(), 0);"/// Mutable slice iterator./// This struct is created by the [`iter_mut`] method on [slices]./// // First, we need a slice to call the `iter_mut` method on:/// let slice = &mut [1, 2, 3];/// // Then we call `iter_mut` on the slice to get the `IterMut` iterator,/// // iterate over it and increment each element value:/// for element in slice.iter_mut() {///     *element += 1;/// // We now have "[2, 3, 4]":/// println!("{slice:?}");/// [`iter_mut`]: slice::iter_mut/// To avoid creating `&mut` references that alias, this is forced/// to consume the iterator./// let mut slice = &mut [1, 2, 3];/// // Then we call `iter_mut` on the slice to get the `IterMut` struct:/// let mut iter = slice.iter_mut();/// // Now, we call the `next` method to remove the first element of the iterator,/// // unwrap and dereference what we get from `next` and increase its value by 1:/// *iter.next().unwrap() += 1;/// // so `into_slice` only returns the last two elements of the slice,/// println!("{:?}", iter.into_slice());/// // The underlying slice still contains three elements, but its first element/// // was increased by 1, so this prints "[2, 2, 3]":/// // Then we call `iter_mut` on the slice to get the `IterMut` iterator:/// // Now, we call the `next` method to remove the first element from the iterator/// // and increment its value:/// Views the underlying data as a mutable subslice of the original data./// #![feature(slice_iter_mut_as_mut_slice)]/// let mut slice: &mut [usize] = &mut [1, 2, 3];/// // First, we get the iterator:/// // Then, we get a mutable slice from it:/// let mut_slice = iter.as_mut_slice();/// // So if we check what the `as_mut_slice` method returned, we have "[1, 2, 3]":/// assert_eq!(mut_slice, &mut [1, 2, 3]);/// // We can use it to mutate the slice:/// mut_slice[0] = 4;/// mut_slice[2] = 5;/// // Next, we can move to the second element of the slice, checking that/// // it yields the value we just wrote:/// assert_eq!(iter.next(), Some(&mut 4));/// // Now `as_mut_slice` returns "[2, 5]":/// assert_eq!(iter.as_mut_slice(), &mut [2, 5]);// FIXME: Uncomment the `AsMut<[T]>` impl when this gets stabilized./// Marks the underlying iterator as complete, extracting the remaining/// portion of the slice./// An internal abstraction over the splitting iterators, so that/// splitn, splitn_mut etc can be implemented once.// Used for `SplitAsciiWhitespace` `as_str` method/// An iterator over subslices separated by elements that match a predicate/// This struct is created by the [`split`] method on [slices]./// let slice = [10, 40, 33, 20];/// let mut iter = slice.split(|num| num % 3 == 0);/// assert_eq!(iter.next(), Some(&[10, 40][..]));/// assert_eq!(iter.next(), Some(&[20][..]));/// [`split`]: slice::split/// Returns a slice which contains items not yet handled by split./// #![feature(split_as_slice)]/// let slice = [1,2,3,4,5];/// let mut split = slice.split(|v| v % 2 == 0);/// assert!(split.next().is_some());/// assert_eq!(split.as_slice(), &[3,4,5]);/// function. Unlike `Split`, it contains the matched part as a terminator/// of the subslice./// This struct is created by the [`split_inclusive`] method on [slices]./// let mut iter = slice.split_inclusive(|num| num % 3 == 0);/// assert_eq!(iter.next(), Some(&[10, 40, 33][..]));/// [`split_inclusive`]: slice::split_inclusive/// An iterator over the mutable subslices of the vector which are separated/// by elements that match `pred`./// This struct is created by the [`split_mut`] method on [slices]./// let mut v = [10, 40, 30, 20, 60, 50];/// let iter = v.split_mut(|num| *num % 3 == 0);/// [`split_mut`]: slice::split_mut/// by elements that match `pred`. Unlike `SplitMut`, it contains the matched/// parts in the ends of the subslices./// This struct is created by the [`split_inclusive_mut`] method on [slices]./// let iter = v.split_inclusive_mut(|num| *num % 3 == 0);/// [`split_inclusive_mut`]: slice::split_inclusive_mut/// function, starting from the end of the slice./// This struct is created by the [`rsplit`] method on [slices]./// let slice = [11, 22, 33, 0, 44, 55];/// let mut iter = slice.rsplit(|num| *num == 0);/// assert_eq!(iter.next(), Some(&[44, 55][..]));/// assert_eq!(iter.next(), Some(&[11, 22, 33][..]));/// [`rsplit`]: slice::rsplit/// An iterator over the subslices of the vector which are separated/// by elements that match `pred`, starting from the end of the slice./// This struct is created by the [`rsplit_mut`] method on [slices]./// let mut slice = [11, 22, 33, 0, 44, 55];/// let iter = slice.rsplit_mut(|num| *num == 0);/// [`rsplit_mut`]: slice::rsplit_mutGenericSplitN/// An private iterator over subslices separated by elements that/// match a predicate function, splitting at most a fixed number of/// function, limited to a given number of splits./// This struct is created by the [`splitn`] method on [slices]./// let slice = [10, 40, 30, 20, 60, 50];/// let mut iter = slice.splitn(2, |num| *num % 3 == 0);/// assert_eq!(iter.next(), Some(&[20, 60, 50][..]));/// [`splitn`]: slice::splitn/// An iterator over subslices separated by elements that match a/// predicate function, limited to a given number of splits, starting/// from the end of the slice./// This struct is created by the [`rsplitn`] method on [slices]./// let mut iter = slice.rsplitn(2, |num| *num % 3 == 0);/// assert_eq!(iter.next(), Some(&[50][..]));/// assert_eq!(iter.next(), Some(&[10, 40, 30, 20][..]));/// [`rsplitn`]: slice::rsplitn/// This struct is created by the [`splitn_mut`] method on [slices]./// let mut slice = [10, 40, 30, 20, 60, 50];/// let iter = slice.splitn_mut(2, |num| *num % 3 == 0);/// [`splitn_mut`]: slice::splitn_mut/// This struct is created by the [`rsplitn_mut`] method on [slices]./// let iter = slice.rsplitn_mut(2, |num| *num % 3 == 0);/// [`rsplitn_mut`]: slice::rsplitn_mut/// An iterator over overlapping subslices of length `size`./// This struct is created by the [`windows`] method on [slices]./// let slice = ['r', 'u', 's', 't'];/// let mut iter = slice.windows(2);/// assert_eq!(iter.next(), Some(&['r', 'u'][..]));/// assert_eq!(iter.next(), Some(&['u', 's'][..]));/// assert_eq!(iter.next(), Some(&['s', 't'][..]));/// [`windows`]: slice::windows/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a/// time), starting at the beginning of the slice./// When the slice len is not evenly divided by the chunk size, the last slice/// of the iteration will be the remainder./// This struct is created by the [`chunks`] method on [slices]./// let slice = ['l', 'o', 'r', 'e', 'm'];/// let mut iter = slice.chunks(2);/// assert_eq!(iter.next(), Some(&['l', 'o'][..]));/// assert_eq!(iter.next(), Some(&['r', 'e'][..]));/// assert_eq!(iter.next(), Some(&['m'][..]));/// [`chunks`]: slice::chunks/// This slice pointer must point at a valid region of `T` with at least length `v.len()`. Normally,/// those requirements would mean that we could instead use a `&mut [T]` here, but we cannot/// because `__iterator_get_unchecked` needs to return `&mut [T]`, which guarantees certain aliasing/// properties that we cannot uphold if we hold on to the full original `&mut [T]`. Wrapping a raw/// slice instead lets us hand out non-overlapping `&mut [T]` subslices of the slice we wrap./// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`/// elements at a time), starting at the beginning of the slice./// This struct is created by the [`chunks_mut`] method on [slices]./// let mut slice = ['l', 'o', 'r', 'e', 'm'];/// let iter = slice.chunks_mut(2);/// [`chunks_mut`]: slice::chunks_mut/// When the slice len is not evenly divided by the chunk size, the last/// up to `chunk_size-1` elements will be omitted but can be retrieved from/// the [`remainder`] function from the iterator./// This struct is created by the [`chunks_exact`] method on [slices]./// let mut iter = slice.chunks_exact(2);/// [`chunks_exact`]: slice::chunks_exact/// [`remainder`]: ChunksExact::remainder/// Returns the remainder of the original slice that is not going to be/// assert_eq!(iter.remainder(), &['m'][..]);// The iterator never yields from here, so this can be unique/// When the slice len is not evenly divided by the chunk size, the last up to/// `chunk_size-1` elements will be omitted but can be retrieved from the/// [`into_remainder`] function from the iterator./// This struct is created by the [`chunks_exact_mut`] method on [slices]./// let iter = slice.chunks_exact_mut(2);/// [`chunks_exact_mut`]: slice::chunks_exact_mut/// [`into_remainder`]: ChunksExactMut::into_remainder/// A windowed iterator over a slice in overlapping chunks (`N` elements at a/// time), starting at the beginning of the slice/// This struct is created by the [`array_windows`] method on [slices]./// #![feature(array_windows)]/// let slice = [0, 1, 2, 3];/// let mut iter = slice.array_windows::<2>();/// assert_eq!(iter.next(), Some(&[0, 1]));/// assert_eq!(iter.next(), Some(&[1, 2]));/// assert_eq!(iter.next(), Some(&[2, 3]));/// [`array_windows`]: slice::array_windows/// time), starting at the end of the slice./// This struct is created by the [`rchunks`] method on [slices]./// let mut iter = slice.rchunks(2);/// assert_eq!(iter.next(), Some(&['e', 'm'][..]));/// assert_eq!(iter.next(), Some(&['o', 'r'][..]));/// assert_eq!(iter.next(), Some(&['l'][..]));/// [`rchunks`]: slice::rchunks/// elements at a time), starting at the end of the slice./// This struct is created by the [`rchunks_mut`] method on [slices]./// let iter = slice.rchunks_mut(2);/// [`rchunks_mut`]: slice::rchunks_mut/// This struct is created by the [`rchunks_exact`] method on [slices]./// let mut iter = slice.rchunks_exact(2);/// [`rchunks_exact`]: slice::rchunks_exact/// [`remainder`]: RChunksExact::remainder/// assert_eq!(iter.remainder(), &['l'][..]);/// This struct is created by the [`rchunks_exact_mut`] method on [slices]./// let iter = slice.rchunks_exact_mut(2);/// [`rchunks_exact_mut`]: slice::rchunks_exact_mut/// [`into_remainder`]: RChunksExactMut::into_remainder/// An iterator over slice in (non-overlapping) chunks separated by a predicate./// This struct is created by the [`chunk_by`] method on [slices]./// [`chunk_by`]: slice::chunk_by/// An iterator over slice in (non-overlapping) mutable chunks separated/// by a predicate./// This struct is created by the [`chunk_by_mut`] method on [slices]./// [`chunk_by_mut`]: slice::chunk_by_mut//! Definitions of a bunch of iterators for `[T]`.// #[stable(feature = "slice_iter_mut_as_mut_slice", since = "FIXME")]// impl<T> AsMut<[T]> for IterMut<'_, T> {//     fn as_mut(&mut self) -> &mut [T] {//         self.as_mut_slice()LO_USIZEHI_USIZEcontains_zero_byte/// Returns `true` if `x` contains any zero byte./// From *Matters Computational*, J. Arndt:/// "The idea is to subtract one from each of the bytes and then look for/// bytes where the borrow propagated all the way to the most significant/// bit."/// Returns the first index matching the byte `x` in `text`.memchr_naivememchr_aligned// fallback impl has same behavior/// Returns the last index matching the byte `x` in `text`.// Original implementation taken from rust-memchr.// Copyright 2015 Andrew Gallant, bluss and Nicolas Koch/// Pure Rust memchr implementation, taken from rust-memchrsplit_point_of/// Calculates the direction and split point of a one-sided range./// This is a helper function for `split_off` and `split_off_mut` that returns/// the direction of the split (front or back) as well as the index at/// which to split. Returns `None` if the split index would overflow."slice_len_fn"/// Returns the number of elements in the slice./// Returns `true` if the slice has a length of 0./// let b: &[i32] = &[];/// Returns the first element of the slice, or `None` if it is empty./// assert_eq!(Some(&10), v.first());/// let w: &[i32] = &[];/// assert_eq!(None, w.first());/// Returns a mutable reference to the first element of the slice, or `None` if it is empty./// let x = &mut [0, 1, 2];/// if let Some(first) = x.first_mut() {///     *first = 5;/// assert_eq!(x, &[5, 1, 2]);/// let y: &mut [i32] = &mut [];/// assert_eq!(None, y.first_mut());/// Returns the first and all the rest of the elements of the slice, or `None` if it is empty./// let x = &[0, 1, 2];/// if let Some((first, elements)) = x.split_first() {///     assert_eq!(first, &0);///     assert_eq!(elements, &[1, 2]);/// if let Some((first, elements)) = x.split_first_mut() {///     *first = 3;///     elements[0] = 4;///     elements[1] = 5;/// assert_eq!(x, &[3, 4, 5]);/// Returns the last and all the rest of the elements of the slice, or `None` if it is empty./// if let Some((last, elements)) = x.split_last() {///     assert_eq!(last, &2);///     assert_eq!(elements, &[0, 1]);/// if let Some((last, elements)) = x.split_last_mut() {///     *last = 3;/// assert_eq!(x, &[4, 5, 3]);/// Returns the last element of the slice, or `None` if it is empty./// assert_eq!(Some(&30), v.last());/// assert_eq!(None, w.last());/// Returns a mutable reference to the last item in the slice, or `None` if it is empty./// if let Some(last) = x.last_mut() {///     *last = 10;/// assert_eq!(x, &[0, 1, 10]);/// assert_eq!(None, y.last_mut());first_chunk/// Returns an array reference to the first `N` items in the slice./// If the slice is not at least `N` in length, this will return `None`./// let u = [10, 40, 30];/// assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());/// let v: &[i32] = &[10];/// assert_eq!(None, v.first_chunk::<2>());/// assert_eq!(Some(&[]), w.first_chunk::<0>());first_chunk_mut/// Returns a mutable array reference to the first `N` items in the slice./// if let Some(first) = x.first_chunk_mut::<2>() {///     first[0] = 5;///     first[1] = 4;/// assert_eq!(x, &[5, 4, 2]);/// assert_eq!(None, x.first_chunk_mut::<4>());/// Returns an array reference to the first `N` items in the slice and the remaining slice./// if let Some((first, elements)) = x.split_first_chunk::<2>() {///     assert_eq!(first, &[0, 1]);///     assert_eq!(elements, &[2]);/// assert_eq!(None, x.split_first_chunk::<4>());/// Returns a mutable array reference to the first `N` items in the slice and the remaining/// if let Some((first, elements)) = x.split_first_chunk_mut::<2>() {///     first[0] = 3;///     elements[0] = 5;/// assert_eq!(None, x.split_first_chunk_mut::<4>());split_last_chunk/// Returns an array reference to the last `N` items in the slice and the remaining slice./// if let Some((elements, last)) = x.split_last_chunk::<2>() {///     assert_eq!(elements, &[0]);///     assert_eq!(last, &[1, 2]);/// assert_eq!(None, x.split_last_chunk::<4>());split_last_chunk_mut/// Returns a mutable array reference to the last `N` items in the slice and the remaining/// if let Some((elements, last)) = x.split_last_chunk_mut::<2>() {///     last[0] = 3;///     last[1] = 4;/// assert_eq!(x, &[5, 3, 4]);/// assert_eq!(None, x.split_last_chunk_mut::<4>());/// Returns an array reference to the last `N` items in the slice./// assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());/// assert_eq!(None, v.last_chunk::<2>());/// assert_eq!(Some(&[]), w.last_chunk::<0>());last_chunk_mut/// Returns a mutable array reference to the last `N` items in the slice./// if let Some(last) = x.last_chunk_mut::<2>() {///     last[0] = 10;///     last[1] = 20;/// assert_eq!(x, &[0, 10, 20]);/// assert_eq!(None, x.last_chunk_mut::<4>());/// Returns a reference to an element or subslice depending on the type of/// - If given a position, returns a reference to the element at that///   position or `None` if out of bounds./// - If given a range, returns the subslice corresponding to that range,///   or `None` if out of bounds./// assert_eq!(Some(&40), v.get(1));/// assert_eq!(Some(&[10, 40][..]), v.get(0..2));/// assert_eq!(None, v.get(3));/// assert_eq!(None, v.get(0..4));/// Returns a mutable reference to an element or subslice depending on the/// type of index (see [`get`]) or `None` if the index is out of bounds./// if let Some(elem) = x.get_mut(1) {///     *elem = 42;/// assert_eq!(x, &[0, 42, 2]);/// Returns a reference to an element or subslice, without doing bounds/// For a safe alternative see [`get`]./// Calling this method with an out-of-bounds index is *[undefined behavior]*/// even if the resulting reference is not used./// You can think of this like `.get(index).unwrap_unchecked()`.  It's UB/// to call `.get_unchecked(len)`, even if you immediately convert to a/// pointer.  And it's UB to call `.get_unchecked(..len + 1)`,/// `.get_unchecked(..=len)`, or similar./// let x = &[1, 2, 4];///     assert_eq!(x.get_unchecked(1), &2);/// Returns a mutable reference to an element or subslice, without doing/// For a safe alternative see [`get_mut`]./// You can think of this like `.get_mut(index).unwrap_unchecked()`.  It's/// UB to call `.get_unchecked_mut(len)`, even if you immediately convert/// to a pointer.  And it's UB to call `.get_unchecked_mut(..len + 1)`,/// `.get_unchecked_mut(..=len)`, or similar.///     let elem = x.get_unchecked_mut(1);///     *elem = 13;/// assert_eq!(x, &[1, 13, 4]);/// The caller must ensure that the slice outlives the pointer this/// Modifying the container referenced by this slice may cause its buffer/// to be reallocated, which would also make any pointers to it invalid.///         assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));/// [`as_mut_ptr`]: slice::as_mut_ptr/// Returns an unsafe mutable pointer to the slice's buffer.///         *x_ptr.add(i) += 2;/// assert_eq!(x, &[3, 4, 6]);/// Returns the two raw pointers spanning the slice./// The returned range is half-open, which means that the end pointer/// points *one past* the last element of the slice. This way, an empty/// slice is represented by two equal pointers, and the difference between/// the two pointers represents the size of the slice./// See [`as_ptr`] for warnings on using these pointers. The end pointer/// requires extra caution, as it does not point to a valid element in the/// This function is useful for interacting with foreign interfaces which/// use two pointers to refer to a range of elements in memory, as is/// common in C++./// It can also be useful to check if a pointer to an element refers to an/// element of this slice:/// let x = &a[1] as *const _;/// let y = &5 as *const _;/// assert!(a.as_ptr_range().contains(&x));/// assert!(!a.as_ptr_range().contains(&y));/// [`as_ptr`]: slice::as_ptr/// Returns the two unsafe mutable pointers spanning the slice./// See [`as_mut_ptr`] for warnings on using these pointers. The end/// pointer requires extra caution, as it does not point to a valid element/// in the slice./// Gets a reference to the underlying array./// Gets a mutable reference to the slice's underlying array./// Swaps two elements in the slice./// If `a` equals to `b`, it's guaranteed that elements won't change value./// * a - The index of the first element/// * b - The index of the second element/// Panics if `a` or `b` are out of bounds./// let mut v = ["a", "b", "c", "d", "e"];/// v.swap(2, 4);/// assert!(v == ["a", "b", "e", "d", "c"]);/// Swaps two elements in the slice, without doing bounds checking./// For a safe alternative see [`swap`]./// Calling this method with an out-of-bounds index is *[undefined behavior]*./// The caller has to ensure that `a < self.len()` and `b < self.len()`./// #![feature(slice_swap_unchecked)]/// let mut v = ["a", "b", "c", "d"];/// // SAFETY: we know that 1 and 3 are both indices of the slice/// unsafe { v.swap_unchecked(1, 3) };/// assert!(v == ["a", "d", "c", "b"]);/// [`swap`]: slice::swap/// Reverses the order of elements in the slice, in place./// let mut v = [1, 2, 3];/// v.reverse();/// assert!(v == [3, 2, 1]);"slice_iter"/// Returns an iterator over the slice./// The iterator yields all items from start to end./// let mut iterator = x.iter();/// assert_eq!(iterator.next(), Some(&1));/// assert_eq!(iterator.next(), Some(&2));/// assert_eq!(iterator.next(), Some(&4));/// Returns an iterator that allows modifying each value./// for elem in x.iter_mut() {///     *elem += 2;/// Returns an iterator over all contiguous windows of length/// `size`. The windows overlap. If the slice is shorter than/// `size`, the iterator returns no values./// Panics if `size` is zero./// let mut iter = slice.windows(3);/// assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);/// assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);/// assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);/// If the slice is shorter than `size`:/// let slice = ['f', 'o', 'o'];/// let mut iter = slice.windows(4);/// Because the [Iterator] trait cannot represent the required lifetimes,/// there is no `windows_mut` analog to `windows`;/// `[0,1,2].windows_mut(2).collect()` would violate [the rules of references]/// (though a [LendingIterator] analog is possible). You can sometimes use/// [`Cell::as_slice_of_cells`](crate::cell::Cell::as_slice_of_cells) in/// conjunction with `windows` instead:/// [the rules of references]: https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#the-rules-of-references/// [LendingIterator]: https://blog.rust-lang.org/2022/10/28/gats-stabilization.html/// let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];/// let slice = &mut array[..];/// let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();/// for w in slice_of_cells.windows(3) {///     Cell::swap(&w[0], &w[2]);/// assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);/// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the/// beginning of the slice./// The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the/// slice, then the last chunk will not have length `chunk_size`./// See [`chunks_exact`] for a variant of this iterator that returns chunks of always exactly/// `chunk_size` elements, and [`rchunks`] for the same iterator but starting at the end of the/// If your `chunk_size` is a constant, consider using [`as_chunks`] instead, which will/// give references to arrays of exactly that length, rather than slices./// Panics if `chunk_size` is zero./// assert_eq!(iter.next().unwrap(), &['l', 'o']);/// assert_eq!(iter.next().unwrap(), &['r', 'e']);/// assert_eq!(iter.next().unwrap(), &['m']);/// [`as_chunks`]: slice::as_chunks/// The chunks are mutable slices, and do not overlap. If `chunk_size` does not divide the/// length of the slice, then the last chunk will not have length `chunk_size`./// See [`chunks_exact_mut`] for a variant of this iterator that returns chunks of always/// exactly `chunk_size` elements, and [`rchunks_mut`] for the same iterator but starting at/// the end of the slice./// If your `chunk_size` is a constant, consider using [`as_chunks_mut`] instead, which will/// let v = &mut [0, 0, 0, 0, 0];/// let mut count = 1;/// for chunk in v.chunks_mut(2) {///     for elem in chunk.iter_mut() {///         *elem += count;/// assert_eq!(v, &[1, 1, 2, 2, 3]);/// [`as_chunks_mut`]: slice::as_chunks_mut/// slice, then the last up to `chunk_size-1` elements will be omitted and can be retrieved/// from the `remainder` function of the iterator./// Due to each chunk having exactly `chunk_size` elements, the compiler can often optimize the/// resulting code better than in the case of [`chunks`]./// See [`chunks`] for a variant of this iterator that also returns the remainder as a smaller/// chunk, and [`rchunks_exact`] for the same iterator but starting at the end of the slice./// assert_eq!(iter.remainder(), &['m']);/// length of the slice, then the last up to `chunk_size-1` elements will be omitted and can be/// retrieved from the `into_remainder` function of the iterator./// resulting code better than in the case of [`chunks_mut`]./// See [`chunks_mut`] for a variant of this iterator that also returns the remainder as a/// smaller chunk, and [`rchunks_exact_mut`] for the same iterator but starting at the end of/// the slice./// for chunk in v.chunks_exact_mut(2) {/// assert_eq!(v, &[1, 1, 2, 2, 0]);as_chunks_unchecked/// Splits the slice into a slice of `N`-element arrays,/// assuming that there's no remainder./// This is the inverse operation to [`as_flattened`]./// [`as_flattened`]: slice::as_flattened/// As this is `unsafe`, consider whether you could use [`as_chunks`] or/// [`as_rchunks`] instead, perhaps via something like/// `if let (chunks, []) = slice.as_chunks()` or/// `let (chunks, []) = slice.as_chunks() else { unreachable!() };`./// [`as_rchunks`]: slice::as_rchunks/// This may only be called when/// - The slice splits exactly into `N`-element chunks (aka `self.len() % N == 0`)./// - `N != 0`./// let slice: &[char] = &['l', 'o', 'r', 'e', 'm', '!'];/// let chunks: &[[char; 1]] =///     // SAFETY: 1-element chunks never have remainder///     unsafe { slice.as_chunks_unchecked() };/// assert_eq!(chunks, &[['l'], ['o'], ['r'], ['e'], ['m'], ['!']]);/// let chunks: &[[char; 3]] =///     // SAFETY: The slice length (6) is a multiple of 3/// assert_eq!(chunks, &[['l', 'o', 'r'], ['e', 'm', '!']]);/// // These would be unsound:/// // let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5/// // let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed/// starting at the beginning of the slice,/// and a remainder slice with length strictly less than `N`./// The remainder is meaningful in the division sense.  Given/// `let (chunks, remainder) = slice.as_chunks()`, then:/// - `chunks.len()` equals `slice.len() / N`,/// - `remainder.len()` equals `slice.len() % N`, and/// - `slice.len()` equals `chunks.len() * N + remainder.len()`./// You can flatten the chunks back into a slice-of-`T` with [`as_flattened`]./// Note that this check is against a const generic parameter, not a runtime/// value, and thus a particular monomorphization will either always panic/// or it will never panic./// let (chunks, remainder) = slice.as_chunks();/// assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);/// assert_eq!(remainder, &['m']);/// If you expect the slice to be an exact multiple, you can combine/// `let`-`else` with an empty slice pattern:/// let slice = ['R', 'u', 's', 't'];/// let (chunks, []) = slice.as_chunks::<2>() else {///     panic!("slice didn't have even length")/// assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);as_rchunks/// starting at the end of the slice,/// `let (remainder, chunks) = slice.as_rchunks()`, then:/// - `remainder.len()` equals `slice.len() % N`,/// - `chunks.len()` equals `slice.len() / N`, and/// let (remainder, chunks) = slice.as_rchunks();/// assert_eq!(remainder, &['l']);/// assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);as_chunks_unchecked_mut/// This is the inverse operation to [`as_flattened_mut`]./// [`as_flattened_mut`]: slice::as_flattened_mut/// As this is `unsafe`, consider whether you could use [`as_chunks_mut`] or/// [`as_rchunks_mut`] instead, perhaps via something like/// `if let (chunks, []) = slice.as_chunks_mut()` or/// `let (chunks, []) = slice.as_chunks_mut() else { unreachable!() };`./// [`as_rchunks_mut`]: slice::as_rchunks_mut/// let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];/// let chunks: &mut [[char; 1]] =///     unsafe { slice.as_chunks_unchecked_mut() };/// chunks[0] = ['L'];/// assert_eq!(chunks, &[['L'], ['o'], ['r'], ['e'], ['m'], ['!']]);/// let chunks: &mut [[char; 3]] =/// chunks[1] = ['a', 'x', '?'];/// assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);/// // let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut() // The slice length is not a multiple of 5/// // let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut() // Zero-length chunks are never allowed/// `let (chunks, remainder) = slice.as_chunks_mut()`, then:/// You can flatten the chunks back into a slice-of-`T` with [`as_flattened_mut`]./// let (chunks, remainder) = v.as_chunks_mut();/// remainder[0] = 9;/// for chunk in chunks {///     *chunk = [count; 2];/// assert_eq!(v, &[1, 1, 2, 2, 9]);as_rchunks_mut/// `let (remainder, chunks) = slice.as_rchunks_mut()`, then:/// let (remainder, chunks) = v.as_rchunks_mut();/// assert_eq!(v, &[9, 1, 1, 2, 2]);array_windows/// Returns an iterator over overlapping windows of `N` elements of a slice,/// starting at the beginning of the slice./// This is the const generic equivalent of [`windows`]./// If `N` is greater than the size of the slice, it will return no windows./// Panics if `N` is zero. This check will most probably get changed to a compile time/// error before this method gets stabilized./// let mut iter = slice.array_windows();/// assert_eq!(iter.next().unwrap(), &[0, 1]);/// assert_eq!(iter.next().unwrap(), &[1, 2]);/// assert_eq!(iter.next().unwrap(), &[2, 3]);/// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end/// of the slice./// See [`rchunks_exact`] for a variant of this iterator that returns chunks of always exactly/// `chunk_size` elements, and [`chunks`] for the same iterator but starting at the beginning/// If your `chunk_size` is a constant, consider using [`as_rchunks`] instead, which will/// assert_eq!(iter.next().unwrap(), &['e', 'm']);/// assert_eq!(iter.next().unwrap(), &['o', 'r']);/// assert_eq!(iter.next().unwrap(), &['l']);/// See [`rchunks_exact_mut`] for a variant of this iterator that returns chunks of always/// exactly `chunk_size` elements, and [`chunks_mut`] for the same iterator but starting at the/// If your `chunk_size` is a constant, consider using [`as_rchunks_mut`] instead, which will/// for chunk in v.rchunks_mut(2) {/// assert_eq!(v, &[3, 2, 2, 1, 1]);/// end of the slice./// resulting code better than in the case of [`rchunks`]./// See [`rchunks`] for a variant of this iterator that also returns the remainder as a smaller/// chunk, and [`chunks_exact`] for the same iterator but starting at the beginning of the/// assert_eq!(iter.remainder(), &['l']);/// See [`rchunks_mut`] for a variant of this iterator that also returns the remainder as a/// smaller chunk, and [`chunks_exact_mut`] for the same iterator but starting at the beginning/// for chunk in v.rchunks_exact_mut(2) {/// assert_eq!(v, &[0, 2, 2, 1, 1]);/// Returns an iterator over the slice producing non-overlapping runs/// The predicate is called for every pair of consecutive elements,/// meaning that it is called on `slice[0]` and `slice[1]`,/// followed by `slice[1]` and `slice[2]`, and so on./// let slice = &[1, 1, 1, 3, 3, 2, 2, 2];/// let mut iter = slice.chunk_by(|a, b| a == b);/// assert_eq!(iter.next(), Some(&[1, 1, 1][..]));/// assert_eq!(iter.next(), Some(&[3, 3][..]));/// assert_eq!(iter.next(), Some(&[2, 2, 2][..]));/// This method can be used to extract the sorted subslices:/// let slice = &[1, 1, 2, 3, 2, 3, 2, 3, 4];/// let mut iter = slice.chunk_by(|a, b| a <= b);/// assert_eq!(iter.next(), Some(&[1, 1, 2, 3][..]));/// assert_eq!(iter.next(), Some(&[2, 3][..]));/// assert_eq!(iter.next(), Some(&[2, 3, 4][..]));chunk_by_mut/// Returns an iterator over the slice producing non-overlapping mutable/// let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2];/// let mut iter = slice.chunk_by_mut(|a, b| a == b);/// assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));/// assert_eq!(iter.next(), Some(&mut [3, 3][..]));/// assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));/// let slice = &mut [1, 1, 2, 3, 2, 3, 2, 3, 4];/// let mut iter = slice.chunk_by_mut(|a, b| a <= b);/// assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..]));/// assert_eq!(iter.next(), Some(&mut [2, 3][..]));/// assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));/// Panics if `mid > len`.  For a non-panicking alternative see/// [`split_at_checked`](slice::split_at_checked)./// let v = ['a', 'b', 'c'];///    let (left, right) = v.split_at(0);///    assert_eq!(left, []);///    assert_eq!(right, ['a', 'b', 'c']);///     let (left, right) = v.split_at(2);///     assert_eq!(left, ['a', 'b']);///     assert_eq!(right, ['c']);///     let (left, right) = v.split_at(3);///     assert_eq!(left, ['a', 'b', 'c']);///     assert_eq!(right, []);/// [`split_at_mut_checked`](slice::split_at_mut_checked)./// let (left, right) = v.split_at_mut(2);/// assert_eq!(left, [1, 0]);/// assert_eq!(right, [3, 0, 5, 6]);/// Divides one slice into two at an index, without doing bounds checking./// For a safe alternative see [`split_at`]./// even if the resulting reference is not used. The caller has to ensure that/// `0 <= mid <= self.len()`./// [`split_at`]: slice::split_at///    let (left, right) = v.split_at_unchecked(0);///     let (left, right) = v.split_at_unchecked(2);///     let (left, right) = v.split_at_unchecked(3);/// Divides one mutable slice into two at an index, without doing bounds checking./// For a safe alternative see [`split_at_mut`]./// [`split_at_mut`]: slice::split_at_mut///     let (left, right) = v.split_at_mut_unchecked(2);///     assert_eq!(left, [1, 0]);///     assert_eq!(right, [3, 0, 5, 6]);///     left[1] = 2;///     right[1] = 4;/// Divides one slice into two at an index, returning `None` if the slice is/// too short./// If `mid ≤ len` returns a pair of slices where the first will contain all/// indices from `[0, mid)` (excluding the index `mid` itself) and the/// second will contain all indices from `[mid, len)` (excluding the index/// `len` itself)./// Otherwise, if `mid > len`, returns `None`./// let v = [1, -2, 3, -4, 5, -6];///    let (left, right) = v.split_at_checked(0).unwrap();///    assert_eq!(right, [1, -2, 3, -4, 5, -6]);///     let (left, right) = v.split_at_checked(2).unwrap();///     assert_eq!(left, [1, -2]);///     assert_eq!(right, [3, -4, 5, -6]);///     let (left, right) = v.split_at_checked(6).unwrap();///     assert_eq!(left, [1, -2, 3, -4, 5, -6]);/// assert_eq!(None, v.split_at_checked(7));split_at_mut_checked/// Divides one mutable slice into two at an index, returning `None` if the/// slice is too short./// if let Some((left, right)) = v.split_at_mut_checked(2) {/// assert_eq!(None, v.split_at_mut_checked(7));/// Returns an iterator over subslices separated by elements that match/// `pred`. The matched element is not contained in the subslices./// assert_eq!(iter.next().unwrap(), &[10, 40]);/// assert_eq!(iter.next().unwrap(), &[20]);/// If the first element is matched, an empty slice will be the first item/// returned by the iterator. Similarly, if the last element in the slice/// is matched, an empty slice will be the last item returned by the/// let slice = [10, 40, 33];/// assert_eq!(iter.next().unwrap(), &[]);/// If two matched elements are directly adjacent, an empty slice will be/// present between them:/// let slice = [10, 6, 33, 20];/// assert_eq!(iter.next().unwrap(), &[10]);/// Returns an iterator over mutable subslices separated by elements that/// match `pred`. The matched element is not contained in the subslices./// for group in v.split_mut(|num| *num % 3 == 0) {///     group[0] = 1;/// assert_eq!(v, [1, 40, 30, 1, 60, 1]);/// `pred`. The matched element is contained in the end of the previous/// subslice as a terminator./// assert_eq!(iter.next().unwrap(), &[10, 40, 33]);/// If the last element of the slice is matched,/// that element will be considered the terminator of the preceding slice./// That slice will be the last item returned by the iterator./// let slice = [3, 10, 40, 33];/// assert_eq!(iter.next().unwrap(), &[3]);/// match `pred`. The matched element is contained in the previous/// for group in v.split_inclusive_mut(|num| *num % 3 == 0) {///     let terminator_idx = group.len()-1;///     group[terminator_idx] = 1;/// assert_eq!(v, [10, 40, 1, 20, 1, 1]);/// `pred`, starting at the end of the slice and working backwards./// The matched element is not contained in the subslices./// assert_eq!(iter.next().unwrap(), &[44, 55]);/// assert_eq!(iter.next().unwrap(), &[11, 22, 33]);/// As with `split()`, if the first or last element is matched, an empty/// slice will be the first (or last) item returned by the iterator./// let v = &[0, 1, 1, 2, 3, 5, 8];/// let mut it = v.rsplit(|n| *n % 2 == 0);/// assert_eq!(it.next().unwrap(), &[]);/// assert_eq!(it.next().unwrap(), &[3, 5]);/// assert_eq!(it.next().unwrap(), &[1, 1]);/// match `pred`, starting at the end of the slice and working/// backwards. The matched element is not contained in the subslices./// let mut v = [100, 400, 300, 200, 600, 500];/// for group in v.rsplit_mut(|num| *num % 3 == 0) {///     group[0] = count;/// assert_eq!(v, [3, 400, 300, 2, 600, 1]);/// `pred`, limited to returning at most `n` items. The matched element is/// not contained in the subslices./// The last element returned, if any, will contain the remainder of the/// Print the slice split once by numbers divisible by 3 (i.e., `[10, 40]`,/// `[20, 60, 50]`):/// let v = [10, 40, 30, 20, 60, 50];/// for group in v.splitn(2, |num| *num % 3 == 0) {///     println!("{group:?}");/// Returns an iterator over mutable subslices separated by elements that match/// for group in v.splitn_mut(2, |num| *num % 3 == 0) {/// assert_eq!(v, [1, 40, 30, 1, 60, 50]);/// `pred` limited to returning at most `n` items. This starts at the end of/// the slice and works backwards. The matched element is not contained in/// the subslices./// Print the slice split once, starting from the end, by numbers divisible/// by 3 (i.e., `[50]`, `[10, 40, 30, 20]`):/// for group in v.rsplitn(2, |num| *num % 3 == 0) {/// let mut s = [10, 40, 30, 20, 60, 50];/// for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {/// assert_eq!(s, [1, 40, 30, 20, 60, 1]);/// Splits the slice on the first element that matches the specified/// If any matching elements are present in the slice, returns the prefix/// before the match and suffix after. The matching element itself is not/// included. If no elements match, returns `None`./// #![feature(slice_split_once)]/// let s = [1, 2, 3, 2, 4];/// assert_eq!(s.split_once(|&x| x == 2), Some((///     &[1][..],///     &[3, 2, 4][..]/// )));/// assert_eq!(s.split_once(|&x| x == 0), None);rsplit_once/// Splits the slice on the last element that matches the specified/// assert_eq!(s.rsplit_once(|&x| x == 2), Some((///     &[1, 2, 3][..],///     &[4][..]/// assert_eq!(s.rsplit_once(|&x| x == 0), None);/// Returns `true` if the slice contains an element with the given value./// Note that if you have a sorted slice, [`binary_search`] may be faster./// [`binary_search`]: slice::binary_search/// assert!(v.contains(&30));/// assert!(!v.contains(&50));/// If you do not have a `&T`, but some other value that you can compare/// with one (for example, `String` implements `PartialEq<str>`), you can/// use `iter().any`:/// let v = [String::from("hello"), String::from("world")]; // slice of `String`/// assert!(v.iter().any(|e| e == "hello")); // search with `&str`/// assert!(!v.iter().any(|e| e == "hi"));/// Returns `true` if `needle` is a prefix of the slice or equal to the slice./// assert!(v.starts_with(&[10]));/// assert!(v.starts_with(&[10, 40]));/// assert!(v.starts_with(&v));/// assert!(!v.starts_with(&[50]));/// assert!(!v.starts_with(&[10, 50]));/// Always returns `true` if `needle` is an empty slice:/// let v = &[10, 40, 30];/// assert!(v.starts_with(&[]));/// let v: &[u8] = &[];/// Returns `true` if `needle` is a suffix of the slice or equal to the slice./// assert!(v.ends_with(&[30]));/// assert!(v.ends_with(&[40, 30]));/// assert!(v.ends_with(&v));/// assert!(!v.ends_with(&[50]));/// assert!(!v.ends_with(&[50, 30]));/// assert!(v.ends_with(&[]));"returns the subslice without modifying the original"SlicePattern/// Returns a subslice with the prefix removed./// If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`./// If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the/// original slice, returns an empty slice./// If the slice does not start with `prefix`, returns `None`./// assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));/// assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));/// assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));/// assert_eq!(v.strip_prefix(&[50]), None);/// assert_eq!(v.strip_prefix(&[10, 50]), None);/// let prefix : &str = "he";/// assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),///            Some(b"llo".as_ref()));/// Returns a subslice with the suffix removed./// If the slice ends with `suffix`, returns the subslice before the suffix, wrapped in `Some`./// If `suffix` is empty, simply returns the original slice. If `suffix` is equal to the/// If the slice does not end with `suffix`, returns `None`./// assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));/// assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));/// assert_eq!(v.strip_suffix(&[10, 40, 30]), Some(&[][..]));/// assert_eq!(v.strip_suffix(&[50]), None);/// assert_eq!(v.strip_suffix(&[50, 30]), None);strip_circumfix/// Returns a subslice with the prefix and suffix removed./// If the slice starts with `prefix` and ends with `suffix`, returns the subslice after the/// prefix and before the suffix, wrapped in `Some`./// If the slice does not start with `prefix` or does not end with `suffix`, returns `None`./// #![feature(strip_circumfix)]/// let v = &[10, 50, 40, 30];/// assert_eq!(v.strip_circumfix(&[10], &[30]), Some(&[50, 40][..]));/// assert_eq!(v.strip_circumfix(&[10], &[40, 30]), Some(&[50][..]));/// assert_eq!(v.strip_circumfix(&[10, 50], &[40, 30]), Some(&[][..]));/// assert_eq!(v.strip_circumfix(&[50], &[30]), None);/// assert_eq!(v.strip_circumfix(&[10], &[40]), None);/// assert_eq!(v.strip_circumfix(&[], &[40, 30]), Some(&[10, 50][..]));/// assert_eq!(v.strip_circumfix(&[10, 50], &[]), Some(&[40, 30][..]));trim_prefix/// Returns a subslice with the optional prefix removed./// If the slice starts with `prefix`, returns the subslice after the prefix.  If `prefix`/// is empty or the slice does not start with `prefix`, simply returns the original slice./// If `prefix` is equal to the original slice, returns an empty slice./// #![feature(trim_prefix_suffix)]/// // Prefix present - removes it/// assert_eq!(v.trim_prefix(&[10]), &[40, 30][..]);/// assert_eq!(v.trim_prefix(&[10, 40]), &[30][..]);/// assert_eq!(v.trim_prefix(&[10, 40, 30]), &[][..]);/// // Prefix absent - returns original slice/// assert_eq!(v.trim_prefix(&[50]), &[10, 40, 30][..]);/// assert_eq!(v.trim_prefix(&[10, 50]), &[10, 40, 30][..]);/// assert_eq!(b"hello".trim_prefix(prefix.as_bytes()), b"llo".as_ref());trim_suffix/// Returns a subslice with the optional suffix removed./// If the slice ends with `suffix`, returns the subslice before the suffix.  If `suffix`/// is empty or the slice does not end with `suffix`, simply returns the original slice./// If `suffix` is equal to the original slice, returns an empty slice./// // Suffix present - removes it/// assert_eq!(v.trim_suffix(&[30]), &[10, 40][..]);/// assert_eq!(v.trim_suffix(&[40, 30]), &[10][..]);/// assert_eq!(v.trim_suffix(&[10, 40, 30]), &[][..]);/// // Suffix absent - returns original slice/// assert_eq!(v.trim_suffix(&[50]), &[10, 40, 30][..]);/// assert_eq!(v.trim_suffix(&[50, 30]), &[10, 40, 30][..]);/// Binary searches this slice for a given element./// If the slice is not sorted, the returned result is unspecified and/// one of the matches could be returned. The index is chosen/// deterministically, but is subject to change in future versions of Rust./// If the value is not found then [`Result::Err`] is returned, containing/// the index where a matching element could be inserted while maintaining/// sorted order./// [`binary_search_by`]: slice::binary_search_by/// [`binary_search_by_key`]: slice::binary_search_by_key/// [`partition_point`]: slice::partition_point/// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];/// assert_eq!(s.binary_search(&13),  Ok(9));/// assert_eq!(s.binary_search(&4),   Err(7));/// assert_eq!(s.binary_search(&100), Err(13));/// let r = s.binary_search(&1);/// assert!(match r { Ok(1..=4) => true, _ => false, });/// If you want to find that whole *range* of matching items, rather than/// an arbitrary matching one, that can be done using [`partition_point`]:/// let low = s.partition_point(|x| x < &1);/// assert_eq!(low, 1);/// let high = s.partition_point(|x| x <= &1);/// assert_eq!(high, 5);/// assert!((low..high).contains(&r.unwrap()));/// assert!(s[..low].iter().all(|&x| x < 1));/// assert!(s[low..high].iter().all(|&x| x == 1));/// assert!(s[high..].iter().all(|&x| x > 1));/// // For something not found, the "range" of equal items is empty/// assert_eq!(s.partition_point(|x| x < &11), 9);/// assert_eq!(s.partition_point(|x| x <= &11), 9);/// assert_eq!(s.binary_search(&11), Err(9));/// If you want to insert an item to a sorted vector, while maintaining/// let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];/// let idx = s.partition_point(|&x| x <= num);/// // `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`/// s.insert(idx, num);/// assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);/// Binary searches this slice with a comparator function./// If the slice is not sorted or if the comparator function does not/// slice, the returned result is unspecified and meaningless./// let seek = 13;/// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));/// let seek = 4;/// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));/// let seek = 100;/// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));/// let seek = 1;/// let r = s.binary_search_by(|probe| probe.cmp(&seek));/// Binary searches this slice with a key extraction function./// Assumes that the slice is sorted by the key, for instance with/// [`sort_by_key`] using the same key extraction function./// If the slice is not sorted by the key, the returned result is/// [`sort_by_key`]: slice::sort_by_key/// let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),///          (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),///          (1, 21), (2, 34), (4, 55)];/// assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));/// assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));/// assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));/// let r = s.binary_search_by_key(&1, |&(a, b)| b);// Lint rustdoc::broken_intra_doc_links is allowed as `slice::sort_by_key` is// in crate `alloc`, and as such doesn't exists yet when building `core`: #74481.// This breaks links when slice is displayed in core, but changing it to use relative links// would break when the item is re-exported. So allow the core links to be broken for now./// Sorts the slice in ascending order **without** preserving the initial order of equal elements./// This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not/// allocate), and *O*(*n* \* log(*n*)) worst-case./// All original elements will remain in the slice and any possible modifications via interior/// mutability are observed in the input. Same is true if the implementation of [`Ord`] for `T` panics./// `slice::sort_unstable_by` such as [`f32::total_cmp`] or [`f64::total_cmp`] that defines a/// [total order] users can sort slices containing floating-point values. Alternatively, if all/// values in the slice are guaranteed to be in a subset for which [`PartialOrd::partial_cmp`]/// forms a [total order], it's possible to sort the slice with `sort_unstable_by(|a, b|/// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which/// combines the fast average case of quicksort with the fast worst case of heapsort, achieving/// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the/// expected time to sort the data is *O*(*n* \* log(*k*))./// slice is partially sorted./// v.sort_unstable();/// Sorts the slice in ascending order with a comparison function, **without** preserving the/// initial order of equal elements./// If the comparison function `compare` does not implement a [total order], the function/// mutability are observed in the input. Same is true if `compare` panics./// May panic if the `compare` does not implement a [total order], or if/// the `compare` itself panics./// v.sort_unstable_by(|a, b| a.cmp(b));/// v.sort_unstable_by(|a, b| b.cmp(a));sort_unstable_by_key/// Sorts the slice in ascending order with a key extraction function, **without** preserving/// the initial order of equal elements./// mutability are observed in the input. Same is true if the implementation of [`Ord`] for `K` panics./// v.sort_unstable_by_key(|k| k.abs());select_nth_unstable/// Reorders the slice such that the element at `index` is at a sort-order position. All/// elements before `index` will be `<=` to this value, and all elements after will be `>=` to/// This reordering is unstable (i.e. any element that compares equal to the nth element may end/// up at that position), in-place (i.e.  does not allocate), and runs in *O*(*n*) time. This/// function is also known as "kth element" in other libraries./// Returns a triple that partitions the reordered slice:/// * The unsorted subslice before `index`, whose elements all satisfy `x <= self[index]`./// * The element at `index`./// * The unsorted subslice after `index`, whose elements all satisfy `x >= self[index]`./// The current algorithm is an introselect implementation based on [ipnsort] by Lukas Bergdoll/// and Orson Peters, which is also the basis for [`sort_unstable`]. The fallback algorithm is/// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime/// for all inputs./// [`sort_unstable`]: slice::sort_unstable/// Panics when `index >= len()`, and so always panics on empty slices./// May panic if the implementation of [`Ord`] for `T` does not implement a [total order]./// let mut v = [-5i32, 4, 2, -3, 1];/// // Find the items `<=` to the median, the median itself, and the items `>=` to it./// let (lesser, median, greater) = v.select_nth_unstable(2);/// assert!(lesser == [-3, -5] || lesser == [-5, -3]);/// assert_eq!(median, &mut 1);/// assert!(greater == [4, 2] || greater == [2, 4]);/// // We are only guaranteed the slice will be one of the following, based on the way we sort/// // about the specified index./// assert!(v == [-3, -5, 1, 2, 4] ||///         v == [-5, -3, 1, 2, 4] ||///         v == [-3, -5, 1, 4, 2] ||///         v == [-5, -3, 1, 4, 2]);select_nth_unstable_by/// Reorders the slice with a comparator function such that the element at `index` is at a/// sort-order position. All elements before `index` will be `<=` to this value, and all/// elements after will be `>=` to it, according to the comparator function./// Returns a triple partitioning the reordered slice:/// * The unsorted subslice before `index`, whose elements all satisfy///   `compare(x, self[index]).is_le()`./// * The unsorted subslice after `index`, whose elements all satisfy///   `compare(x, self[index]).is_ge()`./// May panic if `compare` does not implement a [total order]./// // Find the items `>=` to the median, the median itself, and the items `<=` to it, by using/// // a reversed comparator./// let (before, median, after) = v.select_nth_unstable_by(2, |a, b| b.cmp(a));/// assert!(before == [4, 2] || before == [2, 4]);/// assert!(after == [-3, -5] || after == [-5, -3]);/// assert!(v == [2, 4, 1, -5, -3] ||///         v == [2, 4, 1, -3, -5] ||///         v == [4, 2, 1, -5, -3] ||///         v == [4, 2, 1, -3, -5]);select_nth_unstable_by_key/// Reorders the slice with a key extraction function such that the element at `index` is at a/// sort-order position. All elements before `index` will have keys `<=` to the key at `index`,/// and all elements after will have keys `>=` to it./// * The unsorted subslice before `index`, whose elements all satisfy `f(x) <= f(self[index])`./// * The unsorted subslice after `index`, whose elements all satisfy `f(x) >= f(self[index])`./// Panics when `index >= len()`, meaning it always panics on empty slices./// May panic if `K: Ord` does not implement a total order./// // Find the items `<=` to the absolute median, the absolute median itself, and the items/// // `>=` to it./// let (lesser, median, greater) = v.select_nth_unstable_by_key(2, |a| a.abs());/// assert!(lesser == [1, 2] || lesser == [2, 1]);/// assert_eq!(median, &mut -3);/// assert!(greater == [4, -5] || greater == [-5, 4]);/// assert!(v == [1, 2, -3, 4, -5] ||///         v == [1, 2, -3, -5, 4] ||///         v == [2, 1, -3, 4, -5] ||///         v == [2, 1, -3, -5, 4]);partition_dedup/// Moves all consecutive repeated elements to the end of the slice according to the/// Returns two slices. The first contains no consecutive repeated elements./// The second contains all the duplicates in no specified order./// If the slice is sorted, the first returned slice contains no duplicates./// #![feature(slice_partition_dedup)]/// let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];/// let (dedup, duplicates) = slice.partition_dedup();/// assert_eq!(dedup, [1, 2, 3, 2, 1]);/// assert_eq!(duplicates, [2, 3, 1]);partition_dedup_by/// Moves all but the first of consecutive elements to the end of the slice satisfying/// a given equality relation./// The `same_bucket` function is passed references to two elements from the slice and/// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is moved/// at the end of the slice./// let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"];/// let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));/// assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]);/// assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);partition_dedup_by_key/// Moves all but the first of consecutive elements to the end of the slice that resolve/// to the same key./// let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];/// let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);/// assert_eq!(dedup, [10, 20, 30, 20, 11]);/// assert_eq!(duplicates, [21, 30, 13]);/// Rotates the slice in-place such that the first `mid` elements of the/// slice move to the end while the last `self.len() - mid` elements move to/// the front./// After calling `rotate_left`, the element previously at index `mid` will/// become the first element in the slice./// This function will panic if `mid` is greater than the length of the/// slice. Note that `mid == self.len()` does _not_ panic and is a no-op/// rotation./// Takes linear (in `self.len()`) time./// let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];/// a.rotate_left(2);/// assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);/// Rotating a subslice:/// a[1..5].rotate_left(1);/// assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);/// Rotates the slice in-place such that the first `self.len() - k`/// elements of the slice move to the end while the last `k` elements move/// to the front./// After calling `rotate_right`, the element previously at index/// `self.len() - k` will become the first element in the slice./// This function will panic if `k` is greater than the length of the/// slice. Note that `k == self.len()` does _not_ panic and is a no-op/// a.rotate_right(2);/// assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);/// a[1..5].rotate_right(1);/// assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);/// Fills `self` with elements by cloning `value`./// let mut buf = vec![0; 10];/// buf.fill(1);/// assert_eq!(buf, vec![1; 10]);/// Fills `self` with elements returned by calling a closure repeatedly./// This method uses a closure to create new values. If you'd rather/// [`Clone`] a given value, use [`fill`]. If you want to use the [`Default`]/// trait to generate values, you can pass [`Default::default`] as the/// [`fill`]: slice::fill/// let mut buf = vec![1; 10];/// buf.fill_with(Default::default);/// assert_eq!(buf, vec![0; 10]);/// Copies the elements from `src` into `self`./// Cloning two elements from a slice into another:/// let src = [1, 2, 3, 4];/// let mut dst = [0, 0];/// // Because the slices have to be the same length,/// // we slice the source slice from four elements/// // to two. It will panic if we don't do this./// dst.clone_from_slice(&src[2..]);/// assert_eq!(src, [1, 2, 3, 4]);/// assert_eq!(dst, [3, 4]);/// Rust enforces that there can only be one mutable reference with no/// immutable references to a particular piece of data in a particular/// scope. Because of this, attempting to use `clone_from_slice` on a/// single slice will result in a compile failure:/// let mut slice = [1, 2, 3, 4, 5];/// slice[..2].clone_from_slice(&slice[3..]); // compile fail!/// To work around this, we can use [`split_at_mut`] to create two distinct/// sub-slices from a slice:///     let (left, right) = slice.split_at_mut(2);///     left.clone_from_slice(&right[1..]);/// assert_eq!(slice, [4, 5, 3, 4, 5]);/// Copies all elements from `src` into `self`, using a memcpy./// If `T` does not implement `Copy`, use [`clone_from_slice`]./// Copying two elements from a slice into another:/// dst.copy_from_slice(&src[2..]);/// scope. Because of this, attempting to use `copy_from_slice` on a/// slice[..2].copy_from_slice(&slice[3..]); // compile fail!///     left.copy_from_slice(&right[1..]);/// [`clone_from_slice`]: slice::clone_from_slice/// Copies elements from one part of the slice to another part of itself,/// using a memmove./// `src` is the range within `self` to copy from. `dest` is the starting/// index of the range within `self` to copy to, which will have the same/// length as `src`. The two ranges may overlap. The ends of the two ranges/// must be less than or equal to `self.len()`./// This function will panic if either range exceeds the end of the slice,/// or if the end of `src` is before the start./// Copying four bytes within a slice:/// let mut bytes = *b"Hello, World!";/// bytes.copy_within(1..5, 8);/// assert_eq!(&bytes, b"Hello, Wello!");/// Swaps all elements in `self` with those in `other`./// The length of `other` must be the same as `self`./// Swapping two elements across slices:/// let mut slice1 = [0, 0];/// let mut slice2 = [1, 2, 3, 4];/// slice1.swap_with_slice(&mut slice2[2..]);/// assert_eq!(slice1, [3, 4]);/// assert_eq!(slice2, [1, 2, 0, 0]);/// Rust enforces that there can only be one mutable reference to a/// particular piece of data in a particular scope. Because of this,/// attempting to use `swap_with_slice` on a single slice will result in/// a compile failure:/// slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!/// mutable sub-slices from a slice:///     left.swap_with_slice(&mut right[1..]);/// assert_eq!(slice, [4, 5, 3, 1, 2]);align_to_offsets/// Function to calculate lengths of the middle and trailing slice for `align_to{,_mut}`./// Transmutes the slice to a slice of another type, ensuring alignment of the types is/// maintained./// This method splits the slice into three distinct slices: prefix, correctly aligned middle/// slice of a new type, and the suffix slice. The middle part will be as big as possible under/// the given alignment constraint and element size./// This method has no purpose when either input element `T` or output element `U` are/// zero-sized and will return the original slice without splitting anything./// This method is essentially a `transmute` with respect to the elements in the returned/// middle slice, so all the usual caveats pertaining to `transmute::<T, U>` also apply here.///     let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];///     let (prefix, shorts, suffix) = bytes.align_to::<u16>();///     // less_efficient_algorithm_for_bytes(prefix);///     // more_efficient_algorithm_for_aligned_shorts(shorts);///     // less_efficient_algorithm_for_bytes(suffix);/// Transmutes the mutable slice to a mutable slice of another type, ensuring alignment of the/// types is maintained.///     let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];///     let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();LANESas_simdSimdElementLaneCountSupportedLaneCount/// Splits a slice into a prefix, a middle of aligned SIMD types, and a suffix./// This is a safe wrapper around [`slice::align_to`], so inherits the same/// guarantees as that method./// This will panic if the size of the SIMD type is different from/// `LANES` times that of the scalar./// At the time of writing, the trait restrictions on `Simd<T, LANES>` keeps/// that from ever happening, as only power-of-two numbers of lanes are/// supported.  It's possible that, in the future, those restrictions might/// be lifted in a way that would make it possible to see panics from this/// method for something like `LANES == 3`./// #![feature(portable_simd)]/// use core::simd::prelude::*;/// let short = &[1, 2, 3];/// let (prefix, middle, suffix) = short.as_simd::<4>();/// assert_eq!(middle, []); // Not enough elements for anything in the middle/// // They might be split in any possible way between prefix and suffix/// let it = prefix.iter().chain(suffix).copied();/// assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);/// fn basic_simd_sum(x: &[f32]) -> f32 {///     use std::ops::Add;///     let (prefix, middle, suffix) = x.as_simd();///     let sums = f32x4::from_array([///         prefix.iter().copied().sum(),///         0.0,///         suffix.iter().copied().sum(),///     let sums = middle.iter().copied().fold(sums, f32x4::add);///     sums.reduce_sum()/// let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();/// assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);as_simd_mut/// Splits a mutable slice into a mutable prefix, a middle of aligned SIMD types,/// and a mutable suffix./// This is a safe wrapper around [`slice::align_to_mut`], so inherits the same/// This is the mutable version of [`slice::as_simd`]; see that for examples./// Checks if the elements of this slice are sorted./// slice yields exactly zero or one element, `true` is returned./// let empty: [i32; 0] = [];/// assert!([1, 2, 2, 9].is_sorted());/// assert!(![1, 3, 2, 4].is_sorted());/// assert!([0].is_sorted());/// assert!(empty.is_sorted());/// assert!(![0.0, 1.0, f32::NAN].is_sorted());/// Checks if the elements of this slice are sorted using the given comparator function./// assert!([1, 2, 2, 9].is_sorted_by(|a, b| a <= b));/// assert!(![1, 2, 2, 9].is_sorted_by(|a, b| a < b));/// assert!([0].is_sorted_by(|a, b| true));/// assert!([0].is_sorted_by(|a, b| false));/// assert!(empty.is_sorted_by(|a, b| false));/// assert!(empty.is_sorted_by(|a, b| true));/// Checks if the elements of this slice are sorted using the given key extraction function./// Instead of comparing the slice's elements directly, this function compares the keys of the/// elements, as determined by `f`. Apart from that, it's equivalent to [`is_sorted`]; see its/// [`is_sorted`]: slice::is_sorted/// assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));/// assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));/// The slice is assumed to be partitioned according to the given predicate./// This means that all elements for which the predicate returns true are at the start of the slice/// If this slice is not partitioned, the returned result is unspecified and meaningless,/// let v = [1, 2, 3, 3, 5, 6, 7];/// let i = v.partition_point(|&x| x < 5);/// assert!(v[..i].iter().all(|&x| x < 5));/// assert!(v[i..].iter().all(|&x| !(x < 5)));/// If all elements of the slice match the predicate, including if the slice/// is empty, then the length of the slice will be returned:/// let a = [2, 4, 8];/// assert_eq!(a.partition_point(|x| x < &100), a.len());/// assert_eq!(a.partition_point(|x| x < &100), 0);"method does not modify the slice if the range is out of bounds"/// Removes the subslice corresponding to the given range/// and returns a reference to it./// Returns `None` and does not modify the slice if the given/// range is out of bounds./// Note that this method only accepts one-sided ranges such as/// `2..` or `..6`, but not `2..6`./// Splitting off the first three elements of a slice:/// let mut slice: &[_] = &['a', 'b', 'c', 'd'];/// let mut first_three = slice.split_off(..3).unwrap();/// assert_eq!(slice, &['d']);/// assert_eq!(first_three, &['a', 'b', 'c']);/// Splitting off a slice starting with the third element:/// let mut tail = slice.split_off(2..).unwrap();/// assert_eq!(slice, &['a', 'b']);/// assert_eq!(tail, &['c', 'd']);/// Getting `None` when `range` is out of bounds:/// assert_eq!(None, slice.split_off(5..));/// assert_eq!(None, slice.split_off(..5));/// assert_eq!(None, slice.split_off(..=4));/// let expected: &[char] = &['a', 'b', 'c', 'd'];/// assert_eq!(Some(expected), slice.split_off(..4));split_off_mut/// let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];/// let mut first_three = slice.split_off_mut(..3).unwrap();/// assert_eq!(slice, &mut ['d']);/// assert_eq!(first_three, &mut ['a', 'b', 'c']);/// let mut tail = slice.split_off_mut(2..).unwrap();/// assert_eq!(slice, &mut ['a', 'b']);/// assert_eq!(tail, &mut ['c', 'd']);/// assert_eq!(None, slice.split_off_mut(5..));/// assert_eq!(None, slice.split_off_mut(..5));/// assert_eq!(None, slice.split_off_mut(..=4));/// let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];/// assert_eq!(Some(expected), slice.split_off_mut(..4));split_off_first/// Removes the first element of the slice and returns a reference/// Returns `None` if the slice is empty./// let mut slice: &[_] = &['a', 'b', 'c'];/// let first = slice.split_off_first().unwrap();/// assert_eq!(slice, &['b', 'c']);/// assert_eq!(first, &'a');split_off_first_mut/// Removes the first element of the slice and returns a mutable/// reference to it./// let mut slice: &mut [_] = &mut ['a', 'b', 'c'];/// let first = slice.split_off_first_mut().unwrap();/// *first = 'd';/// assert_eq!(first, &'d');split_off_last/// Removes the last element of the slice and returns a reference/// let last = slice.split_off_last().unwrap();/// assert_eq!(last, &'c');split_off_last_mut/// Removes the last element of the slice and returns a mutable/// let last = slice.split_off_last_mut().unwrap();/// *last = 'd';/// assert_eq!(last, &'d');GetDisjointMutIndex/// Returns mutable references to many indices at once, without doing any checks./// An index can be either a `usize`, a [`Range`] or a [`RangeInclusive`]. Note/// that this method takes an array, so all indices must be of the same type./// If passed an array of `usize`s this method gives back an array of mutable references/// to single elements, while if passed an array of ranges it gives back an array of/// mutable references to slices./// For a safe alternative see [`get_disjoint_mut`]./// Calling this method with overlapping or out-of-bounds indices is *[undefined behavior]*/// even if the resulting references are not used.///     let [a, b] = x.get_disjoint_unchecked_mut([0, 2]);///     *a *= 10;///     *b *= 100;/// assert_eq!(x, &[10, 2, 400]);///     let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);///     a[0] = 8;///     b[0] = 88;///     b[1] = 888;/// assert_eq!(x, &[8, 88, 888]);///     let [a, b] = x.get_disjoint_unchecked_mut([1..=2, 0..=0]);///     a[0] = 11;///     a[1] = 111;///     b[0] = 1;/// assert_eq!(x, &[1, 11, 111]);/// [`get_disjoint_mut`]: slice::get_disjoint_mut/// Returns mutable references to many indices at once./// Returns an error if any index is out-of-bounds, or if there are overlapping indices./// An empty range is not considered to overlap if it is located at the beginning or at/// the end of another range, but is considered to overlap if it is located in the middle./// This method does a O(n^2) check to check that there are no overlapping indices, so be careful/// when passing many indices./// let v = &mut [1, 2, 3];/// if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) {///     *a = 413;///     *b = 612;/// assert_eq!(v, &[413, 2, 612]);/// if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) {/// assert_eq!(v, &[8, 88, 888]);/// if let Ok([a, b]) = v.get_disjoint_mut([1..=2, 0..=0]) {/// assert_eq!(v, &[1, 11, 111]);element_offset/// Returns the index that an element reference points to./// Returns `None` if `element` does not point to the start of an element within the slice./// This method is useful for extending slice iterators like [`slice::split`]./// Note that this uses pointer arithmetic and **does not compare elements**./// To find the index of an element via comparison, use/// [`.iter().position()`](crate::iter::Iterator::position) instead./// Panics if `T` is zero-sized./// #![feature(substr_range)]/// let nums: &[u32] = &[1, 7, 1, 1];/// let num = &nums[2];/// assert_eq!(num, &1);/// assert_eq!(nums.element_offset(num), Some(2));/// Returning `None` with an unaligned element:/// let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];/// let flat_arr: &[u32] = arr.as_flattened();/// let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();/// let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();/// assert_eq!(ok_elm, &[0, 1]);/// assert_eq!(weird_elm, &[1, 2]);/// assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0/// assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1subslice_range/// Returns the range of indices that a subslice points to./// Returns `None` if `subslice` does not point within the slice or if it is not aligned with the/// elements in the slice./// This method **does not compare elements**. Instead, this method finds the location in the slice that/// `subslice` was obtained from. To find the index of a subslice via comparison, instead use/// [`.windows()`](slice::windows)[`.position()`](crate::iter::Iterator::position)./// Note that this may return a false positive (either `Some(0..0)` or `Some(self.len()..self.len())`)/// if `subslice` has a length of zero and points to the beginning or end of another, separate, slice./// let nums = &[0, 5, 10, 0, 0, 5];/// let mut iter = nums///     .split(|t| *t == 0)///     .map(|n| nums.subslice_range(n).unwrap());/// assert_eq!(iter.next(), Some(0..0));/// assert_eq!(iter.next(), Some(1..3));/// assert_eq!(iter.next(), Some(4..4));/// assert_eq!(iter.next(), Some(5..6));align_to_uninit_mut/// Transmutes the mutable uninitialized slice to a mutable uninitialized slice of/// another type, ensuring alignment of the types is maintained./// #![feature(align_to_uninit_mut)]/// pub struct BumpAllocator<'scope> {///     memory: &'scope mut [MaybeUninit<u8>],/// impl<'scope> BumpAllocator<'scope> {///     pub fn new(memory: &'scope mut [MaybeUninit<u8>]) -> Self {///         Self { memory }///     pub fn try_alloc_uninit<T>(&mut self) -> Option<&'scope mut MaybeUninit<T>> {///         let first_end = self.memory.as_ptr().align_offset(align_of::<T>()) + size_of::<T>();///         let prefix = self.memory.split_off_mut(..first_end)?;///         Some(&mut prefix.align_to_uninit_mut::<T>().1[0])///     pub fn try_alloc_u32(&mut self, value: u32) -> Option<&'scope mut u32> {///         let uninit = self.try_alloc_uninit()?;///         Some(uninit.write(value))/// let mut memory = [MaybeUninit::<u8>::uninit(); 10];/// let mut allocator = BumpAllocator::new(&mut memory);/// let v = allocator.try_alloc_u32(42);/// assert_eq!(v, Some(&mut 42));/// Takes a `&[[T; N]]`, and flattens it to a `&[T]`./// For the opposite operation, see [`as_chunks`] and [`as_rchunks`]./// This panics if the length of the resulting slice would overflow a `usize`./// This is only possible when flattening a slice of arrays of zero-sized/// assert_eq!([[1, 2, 3], [4, 5, 6]].as_flattened(), &[1, 2, 3, 4, 5, 6]);///     [[1, 2, 3], [4, 5, 6]].as_flattened(),///     [[1, 2], [3, 4], [5, 6]].as_flattened(),/// let slice_of_empty_arrays: &[[i32; 0]] = &[[], [], [], [], []];/// assert!(slice_of_empty_arrays.as_flattened().is_empty());/// let empty_slice_of_arrays: &[[u32; 10]] = &[];/// assert!(empty_slice_of_arrays.as_flattened().is_empty());/// Takes a `&mut [[T; N]]`, and flattens it to a `&mut [T]`./// For the opposite operation, see [`as_chunks_mut`] and [`as_rchunks_mut`]./// fn add_5_to_all(slice: &mut [i32]) {///     for i in slice {///         *i += 5;/// let mut array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];/// add_5_to_all(array.as_flattened_mut());/// assert_eq!(array, [[6, 7, 8], [9, 10, 11], [12, 13, 14]]);sort_floats/// Sorts the slice of floats./// This sort is in-place (i.e. does not allocate), *O*(*n* \* log(*n*)) worst-case, and uses/// the ordering defined by [`f32::total_cmp`]./// This uses the same sorting algorithm as [`sort_unstable_by`](slice::sort_unstable_by)./// #![feature(sort_floats)]/// let mut v = [2.6, -5e-8, f32::NAN, 8.29, f32::INFINITY, -1.0, 0.0, -f32::INFINITY, -0.0];/// v.sort_floats();/// let sorted = [-f32::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f32::INFINITY, f32::NAN];/// assert_eq!(&v[..8], &sorted[..8]);/// assert!(v[8].is_nan());/// the ordering defined by [`f64::total_cmp`]./// let mut v = [2.6, -5e-8, f64::NAN, 8.29, f64::INFINITY, -1.0, 0.0, -f64::INFINITY, -0.0];/// let sorted = [-f64::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f64::INFINITY, f64::NAN];copy_from_slice_impl/// Copies `src` to `dest`./// `T` must implement one of `Copy` or `TrivialClone`.spec_clone_fromCloneFromSpec/// Creates an empty slice./// Creates a mutable empty slice./// The element type of the slice being matched on./// Currently, the consumers of `SlicePattern` need a slice./// Patterns in slices - currently, only used by `strip_prefix` and `strip_suffix`.  At a future/// point, we hope to generalise `core::str::Pattern` (which at the time of writing is limited to/// `str`) to slices, and then this trait will be replaced or abolished.get_disjoint_check_valid/// This checks every index against each other, and against `len`./// This will do `binomial(N + 1, 2) = N * (N + 1) / 2 = 0, 1, 3, 6, 10, ..`/// comparison operations.IndexOutOfBounds/// An index provided was out-of-bounds for the slice.OverlappingIndices/// Two indices provided were overlapping./// The error type returned by [`get_disjoint_mut`][`slice::get_disjoint_mut`]./// It indicates one of two possible errors:/// - An index is out-of-bounds./// - The same index appeared multiple times in the array///   (or different but overlapping indices when ranges are provided)./// use std::slice::GetDisjointMutError;/// assert_eq!(v.get_disjoint_mut([0, 999]), Err(GetDisjointMutError::IndexOutOfBounds));/// assert_eq!(v.get_disjoint_mut([1, 1]), Err(GetDisjointMutError::OverlappingIndices));private_get_disjoint_mut_indexis_in_bounds/// Returns `true` if `self` is in bounds for `len` slice elements.is_overlapping/// Returns `true` if `self` overlaps with `other`./// Note that we don't consider zero-length ranges to overlap at the beginning or the end,/// but do consider them to overlap in the middle./// A helper trait for `<[T]>::get_disjoint_mut()`./// If `is_in_bounds()` returns `true` and `is_overlapping()` returns `false`,/// it must be safe to index the slice with the indices.// SAFETY: We implement `is_in_bounds()` and `is_overlapping()` correctly.//! Slice management and manipulation.//! For more details see [`std::slice`].//! [`std::slice`]: ../../std/slice/index.html"slice_from_raw_parts"/// Forms a slice from a pointer and a length./// * `data` must be non-null, [valid] for reads for `len * size_of::<T>()` many bytes,///       Slices can never span across multiple allocations. See [below](#incorrect-usage)///       for an example incorrectly not taking this into account.///     * `data` must be non-null and aligned even for zero-length slices or slices of ZSTs. One/// * `data` must point to `len` consecutive properly initialized values of type `T`./// * The memory referenced by the returned slice must not be mutated for the duration///   of lifetime `'a`, except inside an `UnsafeCell`./// * The total size `len * size_of::<T>()` of the slice must be no larger than `isize::MAX`,///   and adding that size to `data` must not "wrap around" the address space./// The lifetime for the returned slice is inferred from its usage. To/// prevent accidental misuse, it's suggested to tie the lifetime to whichever/// source lifetime is safe in the context, such as by providing a helper/// function taking the lifetime of a host value for the slice, or by explicit/// // manifest a slice for a single element/// let x = 42;/// let ptr = &x as *const _;/// let slice = unsafe { slice::from_raw_parts(ptr, 1) };/// assert_eq!(slice[0], 42);/// ### Incorrect usage/// The following `join_slices` function is **unsound** ⚠️/// fn join_slices<'a, T>(fst: &'a [T], snd: &'a [T]) -> &'a [T] {///     let fst_end = fst.as_ptr().wrapping_add(fst.len());///     let snd_start = snd.as_ptr();///     assert_eq!(fst_end, snd_start, "Slices must be contiguous!");///         // The assertion above ensures `fst` and `snd` are contiguous, but they might///         // still be contained within _different allocations_, in which case///         // creating this slice is undefined behavior.///         slice::from_raw_parts(fst.as_ptr(), fst.len() + snd.len())///     // `a` and `b` are different allocations...///     let a = 42;///     let b = 27;///     // ... which may nevertheless be laid out contiguously in memory: | a | b |///     let _ = join_slices(slice::from_ref(&a), slice::from_ref(&b)); // UB/// ### FFI: Handling null pointers/// In languages such as C++, pointers to empty collections are not guaranteed to be non-null./// When accepting such pointers, they have to be checked for null-ness to avoid undefined/// /// Sum the elements of an FFI slice./// /// If ptr is not NULL, it must be correctly aligned and/// /// point to `len` initialized items of type `f32`./// unsafe extern "C" fn sum_slice(ptr: *const f32, len: usize) -> f32 {///     let data = if ptr.is_null() {///         // `len` is assumed to be 0.///         &[]///         // SAFETY: see function docstring.///         unsafe { slice::from_raw_parts(ptr, len) }///     data.into_iter().sum()/// // This could be the result of C++'s std::vector::data():/// let ptr = std::ptr::null();/// // And this could be std::vector::size():/// let len = 0;/// assert_eq!(unsafe { sum_slice(ptr, len) }, 0.0);/// [`NonNull::dangling()`]: ptr::NonNull::dangling"slice_from_raw_parts_mut"/// mutable slice is returned./// * `data` must be non-null, [valid] for both reads and writes for `len * size_of::<T>()` many bytes,/// * The memory referenced by the returned slice must not be accessed through any other pointer///   (not derived from the return value) for the duration of lifetime `'a`.///   Both read and write accesses are forbidden."slice_from_ref"/// Converts a reference to T into a slice of length 1 (without copying)./// Forms a slice from a pointer range./// * The `start` pointer of the range must be a non-null, [valid] and properly aligned pointer///   to the first element of a slice./// * The `end` pointer must be a [valid] and properly aligned pointer to *one past*///   the last element, such that the offset from the end to the start pointer is///   the length of the slice./// * The entire memory range of this slice must be contained within a single allocation!///   Slices can never span across multiple allocations./// * The range must contain `N` consecutive properly initialized values of type `T`./// * The total length of the range must be no larger than `isize::MAX`,///   and adding that size to `start` must not "wrap around" the address space./// Note that a range created from [`slice::as_ptr_range`] fulfills these requirements./// This function panics if `T` is a Zero-Sized Type (“ZST”)./// #![feature(slice_from_ptr_range)]/// use core::slice;/// let range = x.as_ptr_range();///     assert_eq!(slice::from_ptr_range(range), &x);/// Forms a mutable slice from a pointer range./// This is the same functionality as [`from_ptr_range`], except that a/// Note that a range created from [`slice::as_mut_ptr_range`] fulfills these requirements./// let range = x.as_mut_ptr_range();///     assert_eq!(slice::from_mut_ptr_range(range), &mut [1, 2, 3]);//! Free functions to create `&[T]` and `&mut [T]`.BufTypeptr_rotate/// Rotates the range `[mid-left, mid+right)` such that the element at `mid` becomes the first/// element. Equivalently, rotates the range `left` elements to the left or `right` elements to the/// The specified range must be valid for reading and writing.ptr_rotate_memmove/// Algorithm 1 is used if `min(left, right)` is small enough to fit onto a stack buffer. The/// `min(left, right)` elements are copied onto the buffer, `memmove` is applied to the others, and/// the ones on the buffer are moved back into the hole on the opposite side of where they/// originated.ptr_rotate_gcd/// Algorithm 2 is used for small values of `left + right` or for large `T`. The elements/// are moved into their final positions one at a time starting at `mid - left` and advancing by/// `right` steps modulo `left + right`, such that only one temporary is needed. Eventually, we/// arrive back at `mid - left`. However, if `gcd(left + right, right)` is not 1, the above steps/// skipped over elements. For example:/// left = 10, right = 6/// the `^` indicates an element in its final place/// 6 7 8 9 10 11 12 13 14 15 . 0 1 2 3 4 5/// after using one step of the above algorithm (The X will be overwritten at the end of the round,/// and 12 is stored in a temporary):/// X 7 8 9 10 11 6 13 14 15 . 0 1 2 3 4 5///               ^/// after using another step (now 2 is in the temporary):/// X 7 8 9 10 11 6 13 14 15 . 0 1 12 3 4 5///               ^                 ^/// after the third step (the steps wrap around, and 8 is in the temporary):/// X 7 2 9 10 11 6 13 14 15 . 0 1 12 3 4 5///     ^         ^                 ^/// after 7 more steps, the round ends with the temporary 0 getting put in the X:/// 0 7 2 9 4 11 6 13 8 15 . 10 1 12 3 14 5/// ^   ^   ^    ^    ^       ^    ^    ^/// Fortunately, the number of skipped over elements between finalized elements is always equal, so/// we can just offset our starting position and do more rounds (the total number of rounds is the/// `gcd(left + right, right)` value). The end result is that all elements are finalized once and/// only once./// Algorithm 2 can be vectorized by chunking and performing many rounds at once, but there are too/// few rounds on average until `left + right` is enormous, and the worst case of a single/// round is always there.ptr_rotate_swap/// Algorithm 3 utilizes repeated swapping of `min(left, right)` elements./// left = 11, right = 4/// [4 5 6 7 8 9 10 11 12 13 14 . 0 1 2 3]///                  ^  ^  ^  ^   ^ ^ ^ ^ swapping the right most elements with elements to the left/// [4 5 6 7 8 9 10 . 0 1 2 3] 11 12 13 14///        ^ ^ ^  ^   ^ ^ ^ ^ swapping these/// [4 5 6 . 0 1 2 3] 7 8 9 10 11 12 13 14/// we cannot swap any more, but a smaller rotation problem is left to solve/// when `left < right` the swapping happens from the left instead.const_min// FIXME(const-hack): Use cmp::min when available in const//! This module and the contained sub-modules contains the code for efficient and robust sort//! implementations, as well as the domain adjacent implementation of `select_nth_unstable`.pivotsmallsortinsertion_sort_shift_leftpartition_at_index/// Reorders the slice such that the element at `index` is at its final sorted position.INSERTION_SORT_THRESHOLD// For small sub-slices it's faster to use a dedicated small-sort, but because it is only called at// most once, it doesn't make sense to use something more sophisticated than insertion-sort.partition_at_index_loopmin_index/// Helper function that returns the index of the minimum element in the slice using the given/// comparator function/// Helper function that returns the index of the maximum element in the slice using the givenmedian_of_medians/// Selection algorithm to select the k-th element from the slice in guaranteed O(n) time./// This is essentially a quickselect that uses Tukey's Ninther for pivot selectionmedian_of_ninthers// Optimized for when `k` lies somewhere in the middle of the slice. Selects a pivot// as close as possible to the median of the slice. For more details on how the algorithm// operates, refer to the paper <https://drops.dagstuhl.de/opus/volltexte/2017/7612/pdf/LIPIcs-SEA-2017-24.pdf>.ninther/// Moves around the 9 elements at the indices a..i, such that/// `v[d]` contains the median of the 9 elements and the other/// elements are partitioned around it.median_idx/// returns the index pointing to the median of the 3/// elements `v[a]`, `v[b]` and `v[c]`//! This module contains the implementation for `slice::select_nth_unstable`.//! It uses an introselect algorithm based on ipnsort by Lukas Bergdoll and Orson Peters,//! published at: <https://github.com/Voultapher/sort-research-rs/tree/main/ipnsort>//! The fallback algorithm used for introselect is Median of Medians using Tukey's Ninther//! for pivot selection. Using this as a fallback ensures O(n) worst case running time with//! better performance than one would get using heapsort as fallback.FreezeMarker/// SAFETY: this is safety relevant, how does this interact with the soundness holes in/// specialization?find_existing_run/// Finds a run of sorted elements starting at the beginning of the slice./// Returns the length of the run, and a bool that is false when the run/// is ascending, and true if the run strictly descending.PSEUDO_MEDIAN_REC_THRESHOLD// Recursively select a pseudomedian if above this threshold./// Selects a pivot from `v`. Algorithm taken from glidesort by Orson Peters./// This chooses a pivot by sampling an adaptive amount of points, approximating/// the quality of a median of sqrt(n) elements.median3_rec/// Calculates an approximate median of 3 elements from sections a, b, c, or/// recursively from an approximation of each, if they're large enough. By/// dividing the size of each section by 8 when recursing we have logarithmic/// recursion depth and overall sample from f(n) = 3*f(n/8) -> f(n) =/// O(n^(log(3)/log(8))) ~= O(n^0.528) elements./// SAFETY: a, b, c must point to the start of initialized regions of memory of/// at least n elements.median3/// Calculates the median of 3 elements./// SAFETY: a, b, c must be valid initialized elements.//! This module contains the logic for pivot selection.small_sort_threshold/// For which input length <= return value of this function, is it valid to call `small_sort`.small_sort/// Sorts `v` using strategies optimized for small sizes.StableSmallSortTypeImpl/// Using a trait allows us to specialize on `Freeze` which in turn allows us to make safe/// abstractions.UnstableSmallSortTypeImplUnstableSmallSortFreezeTypeImpl/// FIXME(const_trait_impl) use original ipnsort approach with choose_unstable_small_sort,/// as found here <https://github.com/Voultapher/sort-research-rs/blob/438fad5d0495f65d4b72aa87f0b62fc96611dff3/ipnsort/src/smallsort.rs#L83C10-L83C36>.CopyMarker/// SAFETY: Only used for run-time optimization heuristic.SMALL_SORT_FALLBACK_THRESHOLD/// Optimal number of comparisons, and good perf.SMALL_SORT_GENERAL_THRESHOLD/// From a comparison perspective 20 was ~2% more efficient for fully random input, but for/// wall-clock performance choosing 32 yielded better performance overall./// SAFETY: If you change this value, you have to adjust [`small_sort_general`] !SMALL_SORT_GENERAL_SCRATCH_LEN/// [`small_sort_general`] uses [`sort8_stable`] as primitive and does a kind of ping-pong merge,/// where the output of the first two [`sort8_stable`] calls is stored at the end of the scratch/// buffer. This simplifies panic handling and avoids additional copies. This affects the required/// scratch buffer size.SMALL_SORT_NETWORK_THRESHOLD/// SAFETY: If you change this value, you have to adjust [`small_sort_network`] !SMALL_SORT_NETWORK_SCRATCH_LENMAX_STACK_ARRAY_SIZE/// Using a stack array, could cause a stack overflow if the type `T` is very large. To be/// conservative we limit the usage of small-sorts that require a stack array to types that fit/// within this limit.small_sort_fallbacksmall_sort_generalsmall_sort_general_with_scratchsmall_sort_networkswap_if_less/// Swap two values in the slice pointed to by `v_base` at the position `a_pos` and `b_pos` if the/// value at position `b_pos` is less than the one at position `a_pos`./// Purposefully not marked `#[inline]`, despite us wanting it to be inlined for integers like/// types. `is_less` could be a huge function and we want to give the compiler an option to/// not inline this function. For the same reasons that this function is very perf critical/// it should be in the same module as the functions that use it.sort9_optimal/// Sorts the first 9 elements of `v` with a fast fixed function./// Should `is_less` generate substantial amounts of code the compiler can choose to not inline/// `swap_if_less`. If the code of a sort impl changes so as to call this function in multiple/// places, `#[inline(never)]` is recommended to keep binary-size in check. The current design of/// `small_sort_network` makes sure to only call this once.sort13_optimal/// Sorts the first 13 elements of `v` with a fast fixed function.insert_tail/// Sorts range [begin, tail] assuming [begin, tail) is already sorted./// begin < tail and p must be valid and initialized for all begin <= p <= tail./// Sort `v` assuming `v[..offset]` is already sorted.sort4_stable/// SAFETY: The caller MUST guarantee that `v_base` is valid for 4 reads and/// `dst` is valid for 4 writes. The result will be stored in `dst[0..4]`.sort8_stable/// SAFETY: The caller MUST guarantee that `v_base` is valid for 8 reads and/// writes, `scratch_base` and `dst` MUST be valid for 8 writes. The result will/// be stored in `dst[0..8]`.merge_upmerge_downbidirectional_merge/// Merge v assuming v[..len / 2] and v[len / 2..] are sorted./// Original idea for bi-directional merging by Igor van den Hoven (quadsort),/// adapted to only use merge up and down. In contrast to the original/// parity_merge function, it performs 2 writes instead of 4 per iteration./// The caller must guarantee that `dst` is valid for v.len() writes./// Also `v.as_ptr()` and `dst` must not alias and v.len() must be >= 2./// Note that T must be Freeze, the comparison function is evaluated on outdated/// temporary 'copies' that may not end up in the final array.panic_on_ord_violationhas_efficient_in_place_swap//! This module contains a variety of sort implementations that are optimized for small lengths.// It's important to differentiate between SMALL_SORT_THRESHOLD performance for// small slices and small-sort performance sorting small sub-slices as part of// the main quicksort loop. For the former, testing showed that the// representative benchmarks for real-world performance are cold CPU state and// not single-size hot benchmarks. For the latter the CPU will call them many// times, so hot benchmarks are fine and more realistic. And it's worth it to// optimize sorting small sub-slices with more sophisticated solutions than// insertion sort./// Sorts `v` based on comparison function `is_less`. If `eager_sort` is true,/// it will only do small-sorts and physical merges, ensuring O(N * log(N))/// worst-case complexity. `scratch.len()` must be at least/// `max(v.len() - v.len() / 2, SMALL_SORT_GENERAL_SCRATCH_LEN)` otherwise the implementation may abort./// Fully ascending and descending inputs will be sorted with exactly N - 1/// comparisons./// This is the main loop for driftsort, which uses powersort's heuristic to/// determine in which order to merge runs, see below for details.merge_tree_scale_factor// Nearly-Optimal Mergesorts: Fast, Practical Sorting Methods That Optimally// Adapt to Existing Runs by J. Ian Munro and Sebastian Wild.// This method forms a binary merge tree, where each internal node corresponds// to a splitting point between the adjacent runs that have to be merged. If we// visualize our array as the number line from 0 to 1, we want to find the// dyadic fraction with smallest denominator that lies between the midpoints of// our to-be-merged slices. The exponent in the dyadic fraction indicates the// desired depth in the binary merge tree this internal node wishes to have.// This does not always correspond to the actual depth due to the inherent// imbalance in runs, but we follow it as closely as possible.// As an optimization we rescale the number line from [0, 1) to [0, 2^62). Then// finding the simplest dyadic fraction between midpoints corresponds to finding// the most significant bit difference of the midpoints. We save scale_factor =// ceil(2^62 / n) to perform this rescaling using a multiplication, avoiding// having to repeatedly do integer divides. This rescaling isn't exact when n is// not a power of two since we use integers and not reals, but the result is// very close, and in fact when n < 2^30 the resulting tree is equivalent as the// approximation errors stay entirely in the lower order bits.// Thus for the splitting point between two adjacent slices [a, b) and [b, c)// the desired depth of the corresponding merge node is CLZ((a+b)*f ^ (b+c)*f),// where CLZ counts the number of leading zeros in an integer and f is our scale// factor. Note that we omitted the division by two in the midpoint// calculations, as this simply shifts the bits by one position (and thus always// adds one to the result), and we only care about the relative depths.// Finally, if we try to upper bound x = (a+b)*f giving x = (n-1 + n) * ceil(2^62 / n) then//    x < (2^62 / n + 1) * 2n//    x < 2^63 + 2n// So as long as n < 2^62 we find that x < 2^64, meaning our operations do notmerge_tree_depth// Note: merge_tree_depth output is < 64 when left < right as f*x and f*y must// differ in some bit, and is <= 64 always.sqrt_approxlogical_mergeDriftsortRun// Lazy logical runs as in Glidesort.create_run/// Creates a new logical run./// A logical run can either be sorted or unsorted. If there is a pre-existing/// run that clears the `min_good_run_len` threshold it is returned as a sorted/// run. If not, the result depends on the value of `eager_sort`. If it is true,/// then a sorted run of length `T::SMALL_SORT_THRESHOLD` is returned, and if it/// is false an unsorted run of length `min_good_run_len` is returned.stable_quicksort/// Compactly stores the length of a run, and whether or not it is sorted. This/// can always fit in a `usize` because the maximum slice length is [`isize::MAX`].new_sortednew_unsorted//! This module contains the hybrid top-level loop combining bottom-up Mergesort with top-down//! Quicksort./// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `scratch` as/// temporary storage, and stores the result into `v[..]`.MergeState// When dropped, copies the range `start..end` into `dst..`./// The caller MUST guarantee that `self` is initialized in a way where `start -> end` is/// the longer sub-slice and so that `dst` can be written to at least the shorter sub-slice/// length times. In addition `start -> end` and `right -> right_end` MUST be valid to be/// read. This function MUST only be called once./// The caller MUST guarantee that `self` is initialized in a way where `left_end <- dst` is/// the shorter sub-slice and so that `out` can be written to at least the shorter sub-slice/// length times. In addition `left_end <- dst` and `right_end <- end` MUST be valid to be//! This module contains logic for performing a merge of two sorted sub-slices.driftBufT/// Stable sort called driftsort by Orson Peters and Lukas Bergdoll./// Design document:/// <https://github.com/Voultapher/sort-research-rs/blob/main/writeup/driftsort_introduction/text.md>/// Upholds all safety properties outlined here:/// <https://github.com/Voultapher/sort-research-rs/blob/main/writeup/sort_safety/text.md>driftsort_main/// See [`sort`]/// Deliberately don't inline the main sorting routine entrypoint to ensure the/// inlined insertion sort i-cache footprint remains minimal./// Creates new buffer that holds at least `capacity` memory./// Returns mutable access to uninitialized memory owned by the buffer./// Abstracts owned memory buffer, so that sort code can live in core where no allocation is/// possible. This trait can then be implemented in a place that has access to allocation.//! This module contains the entry points for `slice::sort`./// Sorts `v` recursively using quicksort./// `scratch.len()` must be at least `max(v.len() - v.len() / 2, SMALL_SORT_GENERAL_SCRATCH_LEN)`/// otherwise the implementation may abort./// `limit` when initialized with `c*log(v.len())` for some c ensures we do not/// overflow the stack or go quadratic.stable_partition/// Partitions `v` using pivot `p = v[pivot_pos]` and returns the number of/// elements less than `p`. The relative order of elements that compare < p and/// those that compare >= p is preserved - it is a stable partition./// If `is_less` is not a strict total order or panics, `scratch.len() < v.len()`,/// or `pivot_pos >= v.len()`, the result and `v`'s state is sound but unspecified.scratch_base// The start of the scratch auxiliary memory.// The current element that is being looked at, scans left to right through slice.// Counts the number of elements that went to the left side, also works around:// https://github.com/rust-lang/rust/issues/117128scratch_rev// Reverse scratch output pointer.PartitionState/// `scan` and `scratch` must point to valid disjoint buffers of length `len`. The/// scan buffer must be initialized.partition_one/// Depending on the value of `towards_left` this function will write a value/// to the growing left or right side of the scratch memory. This forms the/// branchless core of the partition./// This function may be called at most `len` times. If it is called exactly/// `len` times the scratch buffer then contains a copy of each element from/// the scan buffer exactly once - a permutation, and num_left <= len.is_freezeIsFreezehas_direct_interior_mutability//! This module contains a stable quicksort and partition implementation.//! Binary-size optimized mergesort inspired by https://github.com/voultapher/tiny-sort-rs./// Never inline this, it sits the main hot-loop in `recurse` and is meant as unlikely algorithmic/// fallback.// This binary heap respects the invariant `parent >= child`.// SAFETY: The caller has to guarantee that `node <= v.len()`.//! This module contains a branchless heapsort as fallback for unstable quicksort./// Unstable sort called ipnsort by Lukas Bergdoll and Orson Peters./// <https://github.com/Voultapher/sort-research-rs/blob/main/writeup/ipnsort_introduction/text.md>ipnsort//! This module contains the entry points for `slice::sort_unstable`./// If the slice had a predecessor in the original array, it is specified as `ancestor_pivot`./// Takes the input slice `v` and re-arranges elements such that when the call returns normally/// all elements that compare true for `is_less(elem, pivot)` where `pivot == v[pivot_pos]` are/// on the left side of `v` followed by the other elements, notionally considered greater or/// equal to `pivot`./// Returns the number of elements that are compared true for `is_less(elem, pivot)`./// If `is_less` does not implement a total order the resulting order and return value are/// interior mutability will be observable. Same is true if `is_less` panics or `v.len()`/// exceeds `scratch.len()`.inst_partitionpartition_hoare_branchy_cyclic/// See [`partition`].num_lt// Counts the number of elements that compared less-than, also works around:GapGuardRaw// Gap guard that tracks the temporary duplicate in the input.partition_lomuto_branchless_cyclicGapGuard/// Ideally this wouldn't be needed and we could just use the regular GapGuard./// See comment in [`partition_lomuto_branchless_cyclic`].//! This module contains an unstable quicksort and two partition implementations.spec_fill_intvalidationsrun_utf8_validation"str_from_utf8"/// Converts a slice of bytes to a string slice./// This is an alias to [`str::from_utf8`]./// A string slice ([`&str`]) is made of bytes ([`u8`]), and a byte slice/// ([`&[u8]`][byteslice]) is made of bytes, so this function converts between/// the two. Not all byte slices are valid string slices, however: [`&str`] requires/// that it is valid UTF-8. `from_utf8()` checks to ensure that the bytes are valid/// UTF-8, and then does the conversion./// [`&str`]: str/// [byteslice]: slice/// If you are sure that the byte slice is valid UTF-8, and you don't want to/// incur the overhead of the validity check, there is an unsafe version of/// this function, [`from_utf8_unchecked`], which has the same/// behavior but skips the check./// If you need a `String` instead of a `&str`, consider/// [`String::from_utf8`][string]./// [string]: ../../std/string/struct.String.html#method.from_utf8/// Because you can stack-allocate a `[u8; N]`, and you can take a/// [`&[u8]`][byteslice] of it, this function is one way to have a/// stack-allocated string. There is an example of this in the/// examples section below./// Returns `Err` if the slice is not UTF-8 with a description as to why the/// provided slice is not UTF-8./// // We can use the ? (try) operator to check if the bytes are valid/// let sparkle_heart = str::from_utf8(&sparkle_heart)?;/// # Ok::<_, str::Utf8Error>(())/// assert!(str::from_utf8(&sparkle_heart).is_err());/// See the docs for [`Utf8Error`] for more details on the kinds of/// errors that can be returned./// A "stack allocated string":/// // some bytes, in a stack-allocated array/// let sparkle_heart = [240, 159, 146, 150];/// // We know these bytes are valid, so just use `unwrap()`./// let sparkle_heart: &str = str::from_utf8(&sparkle_heart).unwrap();"str_from_utf8_mut"/// Converts a mutable slice of bytes to a mutable string slice./// This is an alias to [`str::from_utf8_mut`]./// // "Hello, Rust!" as a mutable vector/// let mut hellorust = vec![72, 101, 108, 108, 111, 44, 32, 82, 117, 115, 116, 33];/// // As we know these bytes are valid, we can use `unwrap()`/// let outstr = str::from_utf8_mut(&mut hellorust).unwrap();/// assert_eq!("Hello, Rust!", outstr);/// // Some invalid bytes in a mutable vector/// let mut invalid = vec![128, 223];/// assert!(str::from_utf8_mut(&mut invalid).is_err());"str_from_utf8_unchecked"/// Converts a slice of bytes to a string slice without checking/// This is an alias to [`str::from_utf8_unchecked`]./// See the safe version, [`from_utf8`], for more information.///     str::from_utf8_unchecked(&sparkle_heart)"str_from_utf8_unchecked_mut"/// that the string contains valid UTF-8; mutable version./// This is an alias to [`str::from_utf8_unchecked_mut`]./// See the immutable version, [`from_utf8_unchecked()`] for documentation and safety requirements./// let mut heart = vec![240, 159, 146, 150];/// let heart = unsafe { str::from_utf8_unchecked_mut(&mut heart) };/// assert_eq!("💖", heart);/// Creates a `&str` from a pointer and a length./// The pointed-to bytes must be valid UTF-8./// If this might not be the case, use `str::from_utf8(slice::from_raw_parts(ptr, len))`,/// which will return an `Err` if the data isn't valid UTF-8./// This function is the `str` equivalent of [`slice::from_raw_parts`](crate::slice::from_raw_parts)./// See that function's documentation for safety concerns and examples./// The mutable version of this function is [`from_raw_parts_mut`]./// Creates a `&mut str` from a pointer and a length./// If this might not be the case, use `str::from_utf8_mut(slice::from_raw_parts_mut(ptr, len))`,/// This function is the `str` equivalent of [`slice::from_raw_parts_mut`](crate::slice::from_raw_parts_mut)./// The immutable version of this function is [`from_raw_parts`].//! Ways to create a `str` from bytes slice.UNROLL_INNERcount_charsdo_count_charscontains_non_continuation_byte// Checks each byte of `w` to see if it contains the first byte in a UTF-8// sequence. Bytes in `w` which are continuation bytes are left as `0x00` (e.g.// false), and bytes which are non-continuation bytes are left as `0x01` (e.g.// true)sum_bytes_in_usize// Morally equivalent to `values.to_ne_bytes().into_iter().sum::<usize>()`, but// more efficient.char_count_general_case// This is the most direct implementation of the concept of "count the number of// bytes in the string which are not continuation bytes", and is used for the// head and tail of the input string (the first and last item in the tuple// returned by `slice::align_to`).//! Code for efficiently counting the number of `char`s in a UTF-8 encoded//! string.//! Broadly, UTF-8 encodes `char`s as a "leading" byte which begins the `char`,//! followed by some number (possibly 0) of continuation bytes.//! The leading byte can have a number of bit-patterns (with the specific//! pattern indicating how many continuation bytes follow), but the continuation//! bytes are always in the format `0b10XX_XXXX` (where the `X`s can take any//! value). That is, the most significant bit is set, and the second most//! significant bit is unset.//! To count the number of characters, we can just count the number of bytes in//! the string which are not continuation bytes, which can be done many bytes at//! a time fairly easily.//! Note: Because the term "leading byte" can sometimes be ambiguous (for//! example, it could also refer to the first byte of a slice), we'll often use//! the term "non-continuation byte" to refer to these bytes in the code./// Errors which can occur when attempting to interpret a sequence of [`u8`]/// As such, the `from_utf8` family of functions and methods for both [`String`]s/// and [`&str`]s make use of this error, for example./// [`String`]: ../../std/string/struct.String.html#method.from_utf8/// [`&str`]: super::from_utf8/// This error type’s methods can be used to create functionality/// similar to `String::from_utf8_lossy` without allocating heap memory:/// fn from_utf8_lossy<F>(mut input: &[u8], mut push: F) where F: FnMut(&str) {///         match std::str::from_utf8(input) {///             Ok(valid) => {///                 push(valid);///                 break///             Err(error) => {///                 let (valid, after_valid) = input.split_at(error.valid_up_to());///                     push(std::str::from_utf8_unchecked(valid))///                 push("\u{FFFD}");///                 if let Some(invalid_sequence_length) = error.error_len() {///                     input = &after_valid[invalid_sequence_length..]///                     break/// Returns the index in the given string up to which valid UTF-8 was/// verified./// It is the maximum index such that `from_utf8(&input[..index])`/// would return `Ok(_)`./// // std::str::from_utf8 returns a Utf8Error/// let error = str::from_utf8(&sparkle_heart).unwrap_err();/// // the second byte is invalid here/// Provides more information about the failure:/// * `None`: the end of the input was reached unexpectedly.///   `self.valid_up_to()` is 1 to 3 bytes from the end of the input.///   If a byte stream (such as a file or a network socket) is being decoded incrementally,///   this could be a valid `char` whose UTF-8 byte sequence is spanning multiple chunks./// * `Some(len)`: an unexpected byte was encountered.///   The length provided is that of the invalid byte sequence///   that starts at the index given by `valid_up_to()`.///   Decoding should resume after that sequence///   (after inserting a [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD]) in case of///   lossy decoding./// [U+FFFD]: ../../std/char/constant.REPLACEMENT_CHARACTER.html/// An error returned when parsing a `bool` using [`from_str`] fails/// [`from_str`]: super::FromStr::from_str//! Defines utf8 error type.next_code_point_reverseBytesIsNotEmptyCharEscapeDebugContinueCharEscapeDefaultCharEscapeUnicodeIsAsciiWhitespaceIsNotEmptyIsWhitespaceLinesMapUnsafeBytesToStrSliceSplitchar_mod/// An iterator over the [`char`]s of a string slice./// This struct is created by the [`chars`] method on [`str`]./// This has the same lifetime as the original slice, and so the/// let mut chars = "abc".chars();front_offset/// An iterator over the [`char`]s of a string slice, and their positions./// This struct is created by the [`char_indices`] method on [`str`]./// Returns the byte position of the next character, or the length/// of the underlying string if there are no more characters./// This means that, when the iterator has not been fully consumed,/// the returned value will match the index that will be returned/// by the next call to [`next()`](Self::next)./// let mut chars = "a楽".char_indices();/// // `next()` has not been called yet, so `offset()` returns the byte/// // index of the first character of the string, which is always 0./// assert_eq!(chars.offset(), 0);/// // As expected, the first call to `next()` also returns 0 as index./// assert_eq!(chars.next(), Some((0, 'a')));/// // `next()` has been called once, so `offset()` returns the byte index/// // of the second character .../// assert_eq!(chars.offset(), 1);/// // ... which matches the index returned by the next call to `next()`./// assert_eq!(chars.next(), Some((1, '楽')));/// // Once the iterator has been consumed, `offset()` returns the length/// // in bytes of the string./// assert_eq!(chars.offset(), 4);/// assert_eq!(chars.next(), None);/// An iterator over the bytes of a string slice./// This struct is created by the [`bytes`] method on [`str`].derive_pattern_clone/// This macro generates a Clone impl for string pattern API/// wrapper types of the form X<'a, P>generate_pattern_iterators/// This macro generates two public iterator structs/// wrapping a private internal one that makes use of the `Pattern` API./// For all patterns `P: Pattern` the following items will be/// generated (generics omitted):/// struct $forward_iterator($internal_iterator);/// struct $reverse_iterator($internal_iterator);/// impl Iterator for $forward_iterator/// { /* internal ends up calling Searcher::next_match() */ }/// impl DoubleEndedIterator for $forward_iterator///       where P::Searcher: DoubleEndedSearcher/// { /* internal ends up calling Searcher::next_match_back() */ }/// impl Iterator for $reverse_iterator///       where P::Searcher: ReverseSearcher/// impl DoubleEndedIterator for $reverse_iterator/// The internal one is defined outside the macro, and has almost the same/// semantic as a DoubleEndedIterator by delegating to `pattern::Searcher` and/// `pattern::ReverseSearcher` for both forward and reverse iteration./// "Almost", because a `Searcher` and a `ReverseSearcher` for a given/// `Pattern` might not return the same elements, so actually implementing/// `DoubleEndedIterator` for it would be incorrect./// (See the docs in `str::pattern` for more details)/// However, the internal struct still represents a single ended iterator from/// either end, and depending on pattern is also a valid double ended iterator,/// so the two wrapper structs implement `Iterator`/// and `DoubleEndedIterator` depending on the concrete pattern type, leading/// to the complex impls seen above.SplitInternalallow_trailing_emptyget_endnext_inclusivenext_back_inclusiver" Created with the method [`split`]."r" [`split`]: str::split"r" Created with the method [`rsplit`]."r" [`rsplit`]: str::rsplit"/// Returns remainder of the split string./// If the iterator is empty, returns `None`./// #![feature(str_split_remainder)]/// let mut split = "Mary had a little lamb".split(' ');/// assert_eq!(split.remainder(), Some("Mary had a little lamb"));/// split.next();/// assert_eq!(split.remainder(), Some("had a little lamb"));/// split.by_ref().for_each(drop);/// assert_eq!(split.remainder(), None);/// let mut split = "Mary had a little lamb".rsplit(' ');/// assert_eq!(split.remainder(), Some("Mary had a little"));r" Created with the method [`split_terminator`]."r" [`split_terminator`]: str::split_terminator"r" Created with the method [`rsplit_terminator`]."r" [`rsplit_terminator`]: str::rsplit_terminator"/// let mut split = "A..B..".split_terminator('.');/// assert_eq!(split.remainder(), Some("A..B.."));/// assert_eq!(split.remainder(), Some(".B.."));/// let mut split = "A..B..".rsplit_terminator('.');/// assert_eq!(split.remainder(), Some("A..B"));SplitNInternal/// The number of splits remainingr" Created with the method [`splitn`]."r" [`splitn`]: str::splitn"r" Created with the method [`rsplitn`]."r" [`rsplitn`]: str::rsplitn"/// let mut split = "Mary had a little lamb".splitn(3, ' ');/// let mut split = "Mary had a little lamb".rsplitn(3, ' ');MatchIndicesInternalr" Created with the method [`match_indices`]."r" [`match_indices`]: str::match_indices"r" Created with the method [`rmatch_indices`]."r" [`rmatch_indices`]: str::rmatch_indices"MatchesInternalr" Created with the method [`matches`]."r" [`matches`]: str::matches"r" Created with the method [`rmatches`]."r" [`rmatches`]: str::rmatches"/// An iterator over the lines of a string, as string slices./// This struct is created with the [`lines`] method on [`str`]./// [`lines`]: str::lines/// Returns the remaining lines of the split string./// #![feature(str_lines_remainder)]/// let mut lines = "a\nb\nc\nd".lines();/// assert_eq!(lines.remainder(), Some("a\nb\nc\nd"));/// lines.next();/// assert_eq!(lines.remainder(), Some("b\nc\nd"));/// lines.by_ref().for_each(drop);/// assert_eq!(lines.remainder(), None);/// Created with the method [`lines_any`]./// [`lines_any`]: str::lines_any/// An iterator over the non-whitespace substrings of a string,/// This struct is created by the [`split_whitespace`] method on [`str`]./// An iterator over the non-ASCII-whitespace substrings of a string,/// This struct is created by the [`split_ascii_whitespace`] method on [`str`]./// [`split_ascii_whitespace`]: str::split_ascii_whitespace/// An iterator over the substrings of a string,/// terminated by a substring matching to a predicate function/// Unlike `Split`, it contains the matched part as a terminator/// This struct is created by the [`split_inclusive`] method on [`str`]./// [`split_inclusive`]: str::split_inclusive/// Returns remainder of the split string/// #![feature(str_split_whitespace_remainder)]/// let mut split = "Mary had a little lamb".split_whitespace();/// let mut split = "Mary had a little lamb".split_ascii_whitespace();/// #![feature(str_split_inclusive_remainder)]/// let mut split = "Mary had a little lamb".split_inclusive(' ');/// An iterator of [`u16`] over the string encoded as UTF-16./// This struct is created by the [`encode_utf16`] method on [`str`]./// [`encode_utf16`]: str::encode_utf16/// The return type of [`str::escape_debug`]./// The return type of [`str::escape_default`]./// The return type of [`str::escape_unicode`].escape_types_impls//! Iterators for `str` methods.utf8_chunks/// Creates an iterator over the contiguous valid UTF-8 ranges of this/// slice, and the non-UTF-8 fragments in between./// See the [`Utf8Chunk`] type for documentation of the items yielded by this iterator./// This function formats arbitrary but mostly-UTF-8 bytes into Rust source/// code in the form of a C-string literal (`c"..."`)./// pub fn cstr_literal(bytes: &[u8]) -> String {///     let mut repr = String::new();///     repr.push_str("c\"");///     for chunk in bytes.utf8_chunks() {///         for ch in chunk.valid().chars() {///             // Escapes \0, \t, \r, \n, \\, \', \", and uses \u{...} for non-printable characters.///             write!(repr, "{}", ch.escape_debug()).unwrap();///         for byte in chunk.invalid() {///             write!(repr, "\\x{:02X}", byte).unwrap();///     repr.push('"');///     repr///     let lit = cstr_literal(b"\xferris the \xf0\x9f\xa6\x80\x07");///     let expected = stringify!(c"\xFErris the 🦀\u{7}");///     assert_eq!(lit, expected);/// An item returned by the [`Utf8Chunks`] iterator./// A `Utf8Chunk` stores a sequence of [`u8`] up to the first broken character/// when decoding a UTF-8 string./// // An invalid UTF-8 string/// let bytes = b"foo\xF1\x80bar";/// // Decode the first `Utf8Chunk`/// let chunk = bytes.utf8_chunks().next().unwrap();/// // The first three characters are valid UTF-8/// assert_eq!("foo", chunk.valid());/// // The fourth character is broken/// assert_eq!(b"\xF1\x80", chunk.invalid());/// Returns the next validated UTF-8 substring./// This substring can be empty at the start of the string or between/// broken UTF-8 characters./// Returns the invalid sequence that caused a failure./// The returned slice will have a maximum length of 3 and starts after the/// substring given by [`valid`]. Decoding will resume after this sequence./// If empty, this is the last chunk in the string. If non-empty, an/// unexpected byte was encountered or the end of the input was reached/// unexpectedly./// Lossy decoding would replace this sequence with [`U+FFFD REPLACEMENT/// CHARACTER`]./// [`valid`]: Self::valid/// [`U+FFFD REPLACEMENT CHARACTER`]: crate::char::REPLACEMENT_CHARACTER/// An iterator used to decode a slice of mostly UTF-8 bytes to string slices/// ([`&str`]) and byte slices ([`&[u8]`][byteslice])./// This struct is created by the [`utf8_chunks`] method on bytes slices./// If you want a simple conversion from UTF-8 byte slices to string slices,/// [`from_utf8`] is easier to use./// [`utf8_chunks`]: slice::utf8_chunks/// [`from_utf8`]: super::from_utf8/// This can be used to create functionality similar to/// [`String::from_utf8_lossy`] without allocating heap memory:/// fn from_utf8_lossy<F>(input: &[u8], mut push: F) where F: FnMut(&str) {///     for chunk in input.utf8_chunks() {///         push(chunk.valid());///         if !chunk.invalid().is_empty() {///             push("\u{FFFD}");/// [`String::from_utf8_lossy`]: ../../std/string/struct.String.html#method.from_utf8_lossyslice_error_failslice_error_fail_ctslice_error_fail_rt"str_len"/// This length is in bytes, not [`char`]s or graphemes. In other words,/// it might not be what a human considers the length of the string./// let len = "foo".len();/// assert_eq!(3, len);/// assert_eq!("ƒoo".len(), 4); // fancy f!/// assert_eq!("ƒoo".chars().count(), 3);/// Returns `true` if `self` has a length of zero bytes./// let s = "";/// let s = "not empty";"str_inherent_from_utf8"/// [string]: ../std/string/struct.String.html#method.from_utf8/// # Ok::<_, std::str::Utf8Error>(())"str_inherent_from_utf8_mut""str_inherent_from_utf8_unchecked""str_inherent_from_utf8_unchecked_mut"/// Checks that `index`-th byte is the first byte in a UTF-8 code point/// sequence or the end of the string./// The start and end of the string (when `index == self.len()`) are/// considered to be boundaries./// Returns `false` if `index` is greater than `self.len()`./// let s = "Löwe 老虎 Léopard";/// // start of `老`/// assert!(s.is_char_boundary(6));/// // second byte of `ö`/// assert!(!s.is_char_boundary(2));/// // third byte of `老`/// assert!(!s.is_char_boundary(8));/// Finds the closest `x` not exceeding `index` where [`is_char_boundary(x)`] is `true`./// This method can help you truncate a string so that it's still valid UTF-8, but doesn't/// exceed a given number of bytes. Note that this is done purely at the character level/// and can still visually split graphemes, even though the underlying characters aren't/// split. For example, the emoji 🧑‍🔬 (scientist) could be split so that the string only/// includes 🧑 (person) instead./// [`is_char_boundary(x)`]: Self::is_char_boundary/// let s = "❤️🧡💛💚💙💜";/// assert_eq!(s.len(), 26);/// assert!(!s.is_char_boundary(13));/// let closest = s.floor_char_boundary(13);/// assert_eq!(closest, 10);/// assert_eq!(&s[..closest], "❤️🧡");/// Finds the closest `x` not below `index` where [`is_char_boundary(x)`] is `true`./// If `index` is greater than the length of the string, this returns the length of the string./// This method is the natural complement to [`floor_char_boundary`]. See that method/// [`floor_char_boundary`]: str::floor_char_boundary/// let closest = s.ceil_char_boundary(13);/// assert_eq!(closest, 14);/// assert_eq!(&s[..closest], "❤️🧡💛");/// Converts a string slice to a byte slice. To convert the byte slice back/// into a string slice, use the [`from_utf8`] function./// let bytes = "bors".as_bytes();/// assert_eq!(b"bors", bytes);/// Converts a mutable string slice to a mutable byte slice./// The caller must ensure that the content of the slice is valid UTF-8/// before the borrow ends and the underlying `str` is used./// Use of a `str` whose contents are not valid UTF-8 is undefined behavior./// let mut s = String::from("Hello");/// let bytes = unsafe { s.as_bytes_mut() };/// assert_eq!(b"Hello", bytes);/// Mutability:/// let mut s = String::from("🗻∈🌏");///     let bytes = s.as_bytes_mut();///     bytes[0] = 0xF0;///     bytes[1] = 0x9F;///     bytes[2] = 0x8D;///     bytes[3] = 0x94;/// assert_eq!("🍔∈🌏", s);/// Converts a string slice to a raw pointer./// As string slices are a slice of bytes, the raw pointer points to a/// [`u8`]. This pointer will be pointing to the first byte of the string/// The caller must ensure that the returned pointer is never written to./// If you need to mutate the contents of the string slice, use [`as_mut_ptr`]./// [`as_mut_ptr`]: str::as_mut_ptr/// let ptr = s.as_ptr();/// Converts a mutable string slice to a raw pointer./// It is your responsibility to make sure that the string slice only gets/// modified in a way that it remains valid UTF-8./// Returns a subslice of `str`./// This is the non-panicking alternative to indexing the `str`. Returns/// [`None`] whenever equivalent indexing operation would panic./// let v = String::from("🗻∈🌏");/// assert_eq!(Some("🗻"), v.get(0..4));/// // indices not on UTF-8 sequence boundaries/// assert!(v.get(1..).is_none());/// assert!(v.get(..8).is_none());/// // out of bounds/// assert!(v.get(..42).is_none());/// Returns a mutable subslice of `str`./// let mut v = String::from("hello");/// // correct length/// assert!(v.get_mut(0..5).is_some());/// assert!(v.get_mut(..42).is_none());/// assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v));/// assert_eq!("hello", v);///     let s = v.get_mut(0..2);///     let s = s.map(|s| {///         s.make_ascii_uppercase();///         &*s///     assert_eq!(Some("HE"), s);/// assert_eq!("HEllo", v);/// Returns an unchecked subslice of `str`./// This is the unchecked alternative to indexing the `str`./// Callers of this function are responsible that these preconditions are/// * The starting index must not exceed the ending index;/// * Indexes must be within bounds of the original slice;/// * Indexes must lie on UTF-8 sequence boundaries./// Failing that, the returned string slice may reference invalid memory or/// violate the invariants communicated by the `str` type./// let v = "🗻∈🌏";///     assert_eq!("🗻", v.get_unchecked(0..4));///     assert_eq!("∈", v.get_unchecked(4..7));///     assert_eq!("🌏", v.get_unchecked(7..11));/// Returns a mutable, unchecked subslice of `str`./// let mut v = String::from("🗻∈🌏");///     assert_eq!("🗻", v.get_unchecked_mut(0..4));///     assert_eq!("∈", v.get_unchecked_mut(4..7));///     assert_eq!("🌏", v.get_unchecked_mut(7..11));/// Creates a string slice from another string slice, bypassing safety/// This is generally not recommended, use with caution! For a safe/// alternative see [`str`] and [`Index`]./// [`Index`]: crate::ops::Index/// This new slice goes from `begin` to `end`, including `begin` but/// excluding `end`./// To get a mutable string slice instead, see the/// [`slice_mut_unchecked`] method./// [`slice_mut_unchecked`]: str::slice_mut_unchecked/// Callers of this function are responsible that three preconditions are/// * `begin` must not exceed `end`./// * `begin` and `end` must be byte positions within the string slice./// * `begin` and `end` must lie on UTF-8 sequence boundaries.///     assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));/// let s = "Hello, world!";///     assert_eq!("world", s.slice_unchecked(7, 12));slice_mut_unchecked/// alternative see [`str`] and [`IndexMut`]./// [`IndexMut`]: crate::ops::IndexMut/// To get an immutable string slice instead, see the/// [`slice_unchecked`] method./// [`slice_unchecked`]: str::slice_unchecked/// Divides one string slice into two at an index./// The argument, `mid`, should be a byte offset from the start of the/// string. It must also be on the boundary of a UTF-8 code point./// The two slices returned go from the start of the string slice to `mid`,/// and from `mid` to the end of the string slice./// To get mutable string slices instead, see the [`split_at_mut`]/// [`split_at_mut`]: str::split_at_mut/// Panics if `mid` is not on a UTF-8 code point boundary, or if it is past/// the end of the last code point of the string slice.  For a non-panicking/// alternative see [`split_at_checked`](str::split_at_checked)./// let s = "Per Martin-Löf";/// Divides one mutable string slice into two at an index./// To get immutable string slices instead, see the [`split_at`] method./// [`split_at`]: str::split_at/// alternative see [`split_at_mut_checked`](str::split_at_mut_checked)./// let mut s = "Per Martin-Löf".to_string();///     let (first, last) = s.split_at_mut(3);///     first.make_ascii_uppercase();///     assert_eq!("PER", first);///     assert_eq!(" Martin-Löf", last);/// assert_eq!("PER Martin-Löf", s);/// The argument, `mid`, should be a valid byte offset from the start of the/// string. It must also be on the boundary of a UTF-8 code point. The/// method returns `None` if that’s not the case./// To get mutable string slices instead, see the [`split_at_mut_checked`]/// [`split_at_mut_checked`]: str::split_at_mut_checked/// let (first, last) = s.split_at_checked(3).unwrap();/// assert_eq!(None, s.split_at_checked(13));  // Inside “ö”/// assert_eq!(None, s.split_at_checked(16));  // Beyond the string length/// To get immutable string slices instead, see the [`split_at_checked`] method./// [`split_at_checked`]: str::split_at_checked/// if let Some((first, last)) = s.split_at_mut_checked(3) {/// assert_eq!(None, s.split_at_mut_checked(13));  // Inside “ö”/// assert_eq!(None, s.split_at_mut_checked(16));  // Beyond the string length/// The caller must ensure that `mid` is a valid byte offset from the start/// of the string and falls on the boundary of a UTF-8 code point."str_chars"/// As a string slice consists of valid UTF-8, we can iterate through a/// string slice by [`char`]. This method returns such an iterator./// over grapheme clusters may be what you actually want. This functionality/// let word = "goodbye";/// let count = word.chars().count();/// assert_eq!(7, count);/// let mut chars = word.chars();/// let y = "y̆";/// let mut chars = y.chars();/// Returns an iterator over the [`char`]s of a string slice, and their/// positions./// string slice by [`char`]. This method returns an iterator of both/// these [`char`]s, as well as their byte positions./// The iterator yields tuples. The position is first, the [`char`] is/// let count = word.char_indices().count();/// let mut char_indices = word.char_indices();/// assert_eq!(Some((0, 'g')), char_indices.next());/// assert_eq!(Some((1, 'o')), char_indices.next());/// assert_eq!(Some((2, 'o')), char_indices.next());/// assert_eq!(Some((3, 'd')), char_indices.next());/// assert_eq!(Some((4, 'b')), char_indices.next());/// assert_eq!(Some((5, 'y')), char_indices.next());/// assert_eq!(Some((6, 'e')), char_indices.next());/// assert_eq!(None, char_indices.next());/// let yes = "y̆es";/// let mut char_indices = yes.char_indices();/// assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')/// assert_eq!(Some((1, '\u{0306}')), char_indices.next());/// // note the 3 here - the previous character took up two bytes/// assert_eq!(Some((3, 'e')), char_indices.next());/// assert_eq!(Some((4, 's')), char_indices.next());/// Returns an iterator over the bytes of a string slice./// As a string slice consists of a sequence of bytes, we can iterate/// through a string slice by byte. This method returns such an iterator./// let mut bytes = "bors".bytes();/// assert_eq!(Some(b'b'), bytes.next());/// assert_eq!(Some(b'o'), bytes.next());/// assert_eq!(Some(b'r'), bytes.next());/// assert_eq!(Some(b's'), bytes.next());/// assert_eq!(None, bytes.next());"this returns the split string as an iterator, \
                  without modifying the original""str_split_whitespace"split_whitespace/// Splits a string slice by whitespace./// The iterator returned will return string slices that are sub-slices of/// the original string slice, separated by any amount of whitespace./// 'Whitespace' is defined according to the terms of the Unicode Derived/// Core Property `White_Space`. If you only want to split on ASCII whitespace/// instead, use [`split_ascii_whitespace`]./// let mut iter = "A few words".split_whitespace();/// assert_eq!(Some("A"), iter.next());/// assert_eq!(Some("few"), iter.next());/// assert_eq!(Some("words"), iter.next());/// let mut iter = " Mary   had\ta\u{2009}little  \n\t lamb".split_whitespace();/// assert_eq!(Some("Mary"), iter.next());/// assert_eq!(Some("had"), iter.next());/// assert_eq!(Some("a"), iter.next());/// assert_eq!(Some("little"), iter.next());/// assert_eq!(Some("lamb"), iter.next());/// assert_eq!("".split_whitespace().next(), None);/// assert_eq!("   ".split_whitespace().next(), None);split_ascii_whitespace/// Splits a string slice by ASCII whitespace./// the original string slice, separated by any amount of ASCII whitespace./// This uses the same definition as [`char::is_ascii_whitespace`]./// To split by Unicode `Whitespace` instead, use [`split_whitespace`]./// let mut iter = "A few words".split_ascii_whitespace();/// Various kinds of ASCII whitespace are considered/// (see [`char::is_ascii_whitespace`]):/// let mut iter = " Mary   had\ta little  \n\t lamb".split_ascii_whitespace();/// assert_eq!("".split_ascii_whitespace().next(), None);/// assert_eq!("   ".split_ascii_whitespace().next(), None);/// Returns an iterator over the lines of a string, as string slices./// Lines are split at line endings that are either newlines (`\n`) or/// sequences of a carriage return followed by a line feed (`\r\n`)./// Line terminators are not included in the lines returned by the iterator./// Note that any carriage return (`\r`) not immediately followed by a/// line feed (`\n`) does not split a line. These carriage returns are/// thereby included in the produced lines./// The final line ending is optional. A string that ends with a final line/// ending will return the same lines as an otherwise identical string/// without a final line ending./// An empty string returns an empty iterator./// let text = "foo\r\nbar\n\nbaz\r";/// let mut lines = text.lines();/// assert_eq!(Some("foo"), lines.next());/// assert_eq!(Some("bar"), lines.next());/// assert_eq!(Some(""), lines.next());/// // Trailing carriage return is included in the last line/// assert_eq!(Some("baz\r"), lines.next());/// assert_eq!(None, lines.next());/// The final line does not require any ending:/// let text = "foo\nbar\n\r\nbaz";/// assert_eq!(Some("baz"), lines.next());/// An empty string returns an empty iterator:/// let text = "";/// assert_eq!(lines.next(), None);lines_any/// Returns an iterator over the lines of a string."this returns the encoded string as an iterator, \
                  without modifying the original"/// Returns an iterator of `u16` over the string encoded/// as native endian UTF-16 (without byte-order mark)./// let utf16_len = text.encode_utf16().count();/// The [pattern] can be a `&str`, [`char`], a slice of [`char`]s, or a/// function or closure that determines if a character matches./// [pattern]: self::pattern/// let bananas = "bananas";"str_starts_with"/// The [pattern] can be a `&str`, in which case this function will return true if/// the `&str` is a prefix of this string slice./// The [pattern] can also be a [`char`], a slice of [`char`]s, or a/// These will only be checked against the first character of this string slice./// Look at the second example below regarding behavior for slices of [`char`]s./// // Note that both of these assert successfully./// assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));/// assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));"str_ends_with"/// Returns `true` if the given pattern matches a suffix of this/// assert!(bananas.ends_with("anas"));/// assert!(!bananas.ends_with("nana"));/// let s = "Löwe 老虎 Léopard Gepardi";/// assert_eq!(s.find('L'), Some(0));/// assert_eq!(s.find('é'), Some(14));/// assert_eq!(s.find("pard"), Some(17));/// More complex patterns using point-free style and closures:/// assert_eq!(s.find(char::is_whitespace), Some(5));/// assert_eq!(s.find(char::is_lowercase), Some(1));/// assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));/// assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));/// let x: &[_] = &['1', '2'];/// assert_eq!(s.find(x), None);/// Returns the byte index for the first character of the last match of the pattern in/// assert_eq!(s.rfind('L'), Some(13));/// assert_eq!(s.rfind('é'), Some(14));/// assert_eq!(s.rfind("pard"), Some(24));/// More complex patterns with closures:/// assert_eq!(s.rfind(char::is_whitespace), Some(12));/// assert_eq!(s.rfind(char::is_lowercase), Some(20));/// assert_eq!(s.rfind(x), None);/// Returns an iterator over substrings of this string slice, separated by/// If there are no matches the full string slice is returned as the only/// item in the iterator./// # Iterator behavior/// The returned iterator will be a [`DoubleEndedIterator`] if the pattern/// allows a reverse search and forward/reverse search yields the same/// elements. This is true for, e.g., [`char`], but not for `&str`./// If the pattern allows a reverse search but its results might differ/// from a forward search, the [`rsplit`] method can be used./// [`rsplit`]: str::rsplit/// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();/// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);/// let v: Vec<&str> = "".split('X').collect();/// assert_eq!(v, [""]);/// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();/// assert_eq!(v, ["lion", "", "tiger", "leopard"]);/// let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();/// assert_eq!(v, ["lion", "tiger", "leopard"]);/// let v: Vec<&str> = "AABBCC".split("DD").collect();/// assert_eq!(v, ["AABBCC"]);/// let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();/// assert_eq!(v, ["abc", "def", "ghi"]);/// let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();/// If the pattern is a slice of chars, split on each occurrence of any of the characters:/// let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();/// assert_eq!(v, ["2020", "11", "03", "23", "59"]);/// A more complex pattern, using a closure:/// let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();/// let x = "||||a||b|c".to_string();/// let d: Vec<_> = x.split('|').collect();/// assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);/// let x = "(///)".to_string();/// let d: Vec<_> = x.split('/').collect();/// assert_eq!(d, &["(", "", "", ")"]);/// let d: Vec<_> = "010".split("0").collect();/// assert_eq!(d, &["", "1", ""]);/// When the empty string is used as a separator, it separates/// every character in the string, along with the beginning/// and end of the string./// let f: Vec<_> = "rust".split("").collect();/// assert_eq!(f, &["", "r", "u", "s", "t", ""]);/// let x = "    a  b c".to_string();/// let d: Vec<_> = x.split(' ').collect();/// assert_eq!(d, &["a", "b", "c"]);/// Differs from the iterator produced by `split` in that `split_inclusive`/// leaves the matched part as the terminator of the substring./// let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."///     .split_inclusive('\n').collect();/// assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);/// If the last element of the string is matched,/// that element will be considered the terminator of the preceding substring./// That substring will be the last item returned by the iterator./// let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"/// assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);/// Returns an iterator over substrings of the given string slice, separated/// by characters matched by a pattern and yielded in reverse order./// The returned iterator requires that the pattern supports a reverse/// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse/// search yields the same elements./// For iterating from the front, the [`split`] method can be used./// [`split`]: str::split/// let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();/// assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);/// let v: Vec<&str> = "".rsplit('X').collect();/// let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();/// assert_eq!(v, ["leopard", "tiger", "", "lion"]);/// let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();/// assert_eq!(v, ["leopard", "tiger", "lion"]);/// let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();/// assert_eq!(v, ["ghi", "def", "abc"]);split_terminator/// by characters matched by a pattern./// Equivalent to [`split`], except that the trailing substring/// is skipped if empty./// This method can be used for string data that is _terminated_,/// rather than _separated_ by a pattern./// from a forward search, the [`rsplit_terminator`] method can be used./// [`rsplit_terminator`]: str::rsplit_terminator/// let v: Vec<&str> = "A.B.".split_terminator('.').collect();/// assert_eq!(v, ["A", "B"]);/// let v: Vec<&str> = "A..B..".split_terminator(".").collect();/// assert_eq!(v, ["A", "", "B", ""]);/// let v: Vec<&str> = "A.B:C.D".split_terminator(&['.', ':'][..]).collect();/// assert_eq!(v, ["A", "B", "C", "D"]);rsplit_terminator/// Returns an iterator over substrings of `self`, separated by characters/// matched by a pattern and yielded in reverse order./// Equivalent to [`split`], except that the trailing substring is/// skipped if empty./// The returned iterator requires that the pattern supports a/// reverse search, and it will be double ended if a forward/reverse/// For iterating from the front, the [`split_terminator`] method can be/// [`split_terminator`]: str::split_terminator/// let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();/// assert_eq!(v, ["B", "A"]);/// let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();/// assert_eq!(v, ["", "B", "", "A"]);/// let v: Vec<&str> = "A.B:C.D".rsplit_terminator(&['.', ':'][..]).collect();/// assert_eq!(v, ["D", "C", "B", "A"]);/// by a pattern, restricted to returning at most `n` items./// If `n` substrings are returned, the last substring (the `n`th substring)/// will contain the remainder of the string./// The returned iterator will not be double ended, because it is/// not efficient to support./// If the pattern allows a reverse search, the [`rsplitn`] method can be/// [`rsplitn`]: str::rsplitn/// let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();/// assert_eq!(v, ["Mary", "had", "a little lambda"]);/// let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();/// assert_eq!(v, ["lion", "", "tigerXleopard"]);/// let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();/// assert_eq!(v, ["abcXdef"]);/// let v: Vec<&str> = "".splitn(1, 'X').collect();/// let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();/// assert_eq!(v, ["abc", "defXghi"]);/// Returns an iterator over substrings of this string slice, separated by a/// pattern, starting from the end of the string, restricted to returning at/// most `n` items./// The returned iterator will not be double ended, because it is not/// efficient to support./// For splitting from the front, the [`splitn`] method can be used./// [`splitn`]: str::splitn/// let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();/// assert_eq!(v, ["lamb", "little", "Mary had a"]);/// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();/// assert_eq!(v, ["leopard", "tiger", "lionX"]);/// let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();/// assert_eq!(v, ["leopard", "lion::tiger"]);/// let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();/// assert_eq!(v, ["ghi", "abc1def"]);/// assert_eq!("cfg".split_once('='), None);/// assert_eq!("cfg=".split_once('='), Some(("cfg", "")));/// assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));/// assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));/// Splits the string on the last occurrence of the specified delimiter and/// assert_eq!("cfg".rsplit_once('='), None);/// assert_eq!("cfg=".rsplit_once('='), Some(("cfg", "")));/// assert_eq!("cfg=foo".rsplit_once('='), Some(("cfg", "foo")));/// assert_eq!("cfg=foo=bar".rsplit_once('='), Some(("cfg=foo", "bar")));/// Returns an iterator over the disjoint matches of a pattern within the/// given string slice./// from a forward search, the [`rmatches`] method can be used./// [`rmatches`]: str::rmatches/// let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();/// assert_eq!(v, ["abc", "abc", "abc"]);/// let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();/// assert_eq!(v, ["1", "2", "3"]);rmatches/// Returns an iterator over the disjoint matches of a pattern within this/// string slice, yielded in reverse order./// For iterating from the front, the [`matches`] method can be used./// [`matches`]: str::matches/// let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();/// let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();/// assert_eq!(v, ["3", "2", "1"]);match_indices/// Returns an iterator over the disjoint matches of a pattern within this string/// slice as well as the index that the match starts at./// For matches of `pat` within `self` that overlap, only the indices/// corresponding to the first match are returned./// from a forward search, the [`rmatch_indices`] method can be used./// [`rmatch_indices`]: str::rmatch_indices/// let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();/// assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);/// let v: Vec<_> = "1abcabc2".match_indices("abc").collect();/// assert_eq!(v, [(1, "abc"), (4, "abc")]);/// let v: Vec<_> = "ababa".match_indices("aba").collect();/// assert_eq!(v, [(0, "aba")]); // only the first `aba`rmatch_indices/// Returns an iterator over the disjoint matches of a pattern within `self`,/// yielded in reverse order along with the index of the match./// corresponding to the last match are returned./// For iterating from the front, the [`match_indices`] method can be used./// [`match_indices`]: str::match_indices/// let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();/// assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);/// let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();/// assert_eq!(v, [(4, "abc"), (1, "abc")]);/// let v: Vec<_> = "ababa".rmatch_indices("aba").collect();/// assert_eq!(v, [(2, "aba")]); // only the last `aba`"this returns the trimmed string as a slice, \
                  without modifying the original""str_trim"/// Returns a string slice with leading and trailing whitespace removed./// Core Property `White_Space`, which includes newlines./// let s = "\n Hello\tworld\t\n";/// assert_eq!("Hello\tworld", s.trim());"this returns the trimmed string as a new slice, \
                  without modifying the original""str_trim_start"/// Returns a string slice with leading whitespace removed./// # Text directionality/// A string is a sequence of bytes. `start` in this context means the first/// position of that byte string; for a left-to-right language like English or/// Russian, this will be left side, and for right-to-left languages like/// Arabic or Hebrew, this will be the right side./// assert_eq!("Hello\tworld\t\n", s.trim_start());/// Directionality:/// let s = "  English  ";/// assert!(Some('E') == s.trim_start().chars().next());/// let s = "  עברית  ";/// assert!(Some('ע') == s.trim_start().chars().next());"str_trim_end"/// Returns a string slice with trailing whitespace removed./// A string is a sequence of bytes. `end` in this context means the last/// Russian, this will be right side, and for right-to-left languages like/// Arabic or Hebrew, this will be the left side./// assert_eq!("\n Hello\tworld", s.trim_end());/// assert!(Some('h') == s.trim_end().chars().rev().next());/// assert!(Some('ת') == s.trim_end().chars().rev().next());trim_left/// Core Property `White_Space`./// A string is a sequence of bytes. 'Left' in this context means the first/// position of that byte string; for a language like Arabic or Hebrew/// which are 'right to left' rather than 'left to right', this will be/// the _right_ side, not the left./// let s = " Hello\tworld\t";/// assert_eq!("Hello\tworld\t", s.trim_left());/// let s = "  English";/// assert!(Some('E') == s.trim_left().chars().next());/// let s = "  עברית";/// assert!(Some('ע') == s.trim_left().chars().next());trim_right/// A string is a sequence of bytes. 'Right' in this context means the last/// the _left_ side, not the right./// assert_eq!(" Hello\tworld", s.trim_right());/// let s = "English  ";/// assert!(Some('h') == s.trim_right().chars().rev().next());/// let s = "עברית  ";/// assert!(Some('ת') == s.trim_right().chars().rev().next());trim_matches/// Returns a string slice with all prefixes and suffixes that match a/// pattern repeatedly removed./// The [pattern] can be a [`char`], a slice of [`char`]s, or a function/// or closure that determines if a character matches./// assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");/// assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");/// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");/// assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");/// Returns a string slice with all prefixes that match a pattern/// repeatedly removed./// assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");/// assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");/// assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");"this returns the remaining substring as a new slice, \
                  without modifying the original"/// If the string starts with the pattern `prefix`, returns the substring after the prefix,/// wrapped in `Some`. Unlike [`trim_start_matches`], this method removes the prefix exactly once./// [`trim_start_matches`]: Self::trim_start_matches/// assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));/// assert_eq!("foo:bar".strip_prefix("bar"), None);/// assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));/// Returns a string slice with the suffix removed./// If the string ends with the pattern `suffix`, returns the substring before the suffix,/// wrapped in `Some`.  Unlike [`trim_end_matches`], this method removes the suffix exactly once./// If the string does not end with `suffix`, returns `None`./// [`trim_end_matches`]: Self::trim_end_matches/// assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));/// assert_eq!("bar:foo".strip_suffix("bar"), None);/// assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));/// Returns a string slice with the prefix and suffix removed./// If the string starts with the pattern `prefix` and ends with the pattern `suffix`, returns/// the substring after the prefix and before the suffix, wrapped in `Some`./// Unlike [`trim_start_matches`] and [`trim_end_matches`], this method removes both the prefix/// and suffix exactly once./// If the string does not start with `prefix` or does not end with `suffix`, returns `None`./// Each [pattern] can be a `&str`, [`char`], a slice of [`char`]s, or a/// assert_eq!("bar:hello:foo".strip_circumfix("bar:", ":foo"), Some("hello"));/// assert_eq!("bar:foo".strip_circumfix("foo", "foo"), None);/// assert_eq!("foo:bar;".strip_circumfix("foo:", ';'), Some("bar"));/// Returns a string slice with the optional prefix removed./// If the string starts with the pattern `prefix`, returns the substring after the prefix./// Unlike [`strip_prefix`], this method always returns `&str` for easy method chaining,/// instead of returning [`Option<&str>`]./// If the string does not start with `prefix`, returns the original string unchanged./// [`strip_prefix`]: Self::strip_prefix/// assert_eq!("foo:bar".trim_prefix("foo:"), "bar");/// assert_eq!("foofoo".trim_prefix("foo"), "foo");/// // Prefix absent - returns original string/// assert_eq!("foo:bar".trim_prefix("bar"), "foo:bar");/// // Method chaining example/// assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");/// Returns a string slice with the optional suffix removed./// If the string ends with the pattern `suffix`, returns the substring before the suffix./// Unlike [`strip_suffix`], this method always returns `&str` for easy method chaining,/// If the string does not end with `suffix`, returns the original string unchanged./// [`strip_suffix`]: Self::strip_suffix/// assert_eq!("bar:foo".trim_suffix(":foo"), "bar");/// assert_eq!("foofoo".trim_suffix("foo"), "foo");/// // Suffix absent - returns original string/// assert_eq!("bar:foo".trim_suffix("bar"), "bar:foo");trim_end_matches/// Returns a string slice with all suffixes that match a pattern/// assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");/// assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");/// assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");/// assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");/// assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");/// assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");/// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");trim_right_matches/// assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");/// assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");/// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");/// assert_eq!("1fooX".trim_right_matches(|c| c == '1' || c == 'X'), "1foo");/// Parses this string slice into another type./// Because `parse` is so general, it can cause problems with type/// inference. As such, `parse` is one of the few times you'll see/// helps the inference algorithm understand specifically which type/// you're trying to parse into./// `parse` can parse into any type that implements the [`FromStr`] trait./// Will return [`Err`] if it's not possible to parse this string slice into/// the desired type./// [`Err`]: FromStr::Err/// let four: u32 = "4".parse().unwrap();/// assert_eq!(4, four);/// Using the 'turbofish' instead of annotating `four`:/// let four = "4".parse::<u32>();/// assert_eq!(Ok(4), four);/// Failing to parse:/// let nope = "j".parse::<u32>();/// assert!(nope.is_err());/// Checks if all characters in this string are within the ASCII range./// An empty string returns `true`./// let ascii = "hello!\n";/// let non_ascii = "Grüße, Jürgen ❤";/// If this string slice [`is_ascii`](Self::is_ascii), returns it as a slice/// of [ASCII characters](`ascii::Char`), otherwise returns `None`./// Converts this string slice into a slice of [ASCII characters](ascii::Char),/// without checking whether they are valid./// Every character in this string must be ASCII, or else this is UB./// Checks that two strings are an ASCII case-insensitive match./// assert!("Ferris".eq_ignore_ascii_case("FERRIS"));/// assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));/// assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));/// Converts this string to its ASCII upper case equivalent in-place./// let mut s = String::from("Grüße, Jürgen ❤");/// s.make_ascii_uppercase();/// assert_eq!("GRüßE, JüRGEN ❤", s);/// Converts this string to its ASCII lower case equivalent in-place./// let mut s = String::from("GRÜßE, JÜRGEN ❤");/// s.make_ascii_lowercase();/// assert_eq!("grÜße, jÜrgen ❤", s);/// Returns a string slice with leading ASCII whitespace removed./// [`u8::is_ascii_whitespace`]: u8::is_ascii_whitespace/// assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");/// assert_eq!("  ".trim_ascii_start(), "");/// assert_eq!("".trim_ascii_start(), "");/// Returns a string slice with trailing ASCII whitespace removed./// assert_eq!("\r hello world\u{3000}\n ".trim_ascii_end(), "\r hello world\u{3000}");/// assert_eq!("  ".trim_ascii_end(), "");/// assert_eq!("".trim_ascii_end(), "");/// Returns a string slice with leading and trailing ASCII whitespace/// assert_eq!("\r hello world\n ".trim_ascii(), "hello world");/// assert_eq!("  ".trim_ascii(), "");/// assert_eq!("".trim_ascii(), "");"this returns the escaped string as an iterator, \
                  without modifying the original"/// Returns an iterator that escapes each char in `self` with [`char::escape_debug`]./// Note: only extended grapheme codepoints that begin the string will be/// escaped./// for c in "❤\n!".escape_debug() {/// println!("{}", "❤\n!".escape_debug());/// println!("❤\\n!");/// Using `to_string`:/// assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");/// Returns an iterator that escapes each char in `self` with [`char::escape_default`]./// for c in "❤\n!".escape_default() {/// println!("{}", "❤\n!".escape_default());/// println!("\\u{{2764}}\\n!");/// assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");/// Returns an iterator that escapes each char in `self` with [`char::escape_unicode`]./// for c in "❤\n!".escape_unicode() {/// println!("{}", "❤\n!".escape_unicode());/// println!("\\u{{2764}}\\u{{a}}\\u{{21}}");/// assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");substr_range/// Returns the range that a substring points to./// Returns `None` if `substr` does not point within `self`./// Unlike [`str::find`], **this does not search through the string**./// Instead, it uses pointer arithmetic to find where in the string/// `substr` is derived from./// This is useful for extending [`str::split`] and similar methods./// Note that this method may return false positives (typically either/// `Some(0..0)` or `Some(self.len()..self.len())`) if `substr` is a/// zero-length `str` that points at the beginning or end of another,/// independent, `str`./// let data = "a, b, b, a";/// let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());/// assert_eq!(iter.next(), Some(0..1));/// assert_eq!(iter.next(), Some(3..4));/// assert_eq!(iter.next(), Some(6..7));/// assert_eq!(iter.next(), Some(9..10));/// Returns the same string as a string slice `&str`./// This method is redundant when used directly on `&str`, but/// it helps dereferencing other string-like types to string slices,/// for example references to `Box<str>` or `Arc<str>`./// Creates an empty str/// Creates an empty mutable strr" A nameable, cloneable fn type"// This is required to make `impl From<&str> for Box<dyn Error>` and `impl<E> From<E> for Box<dyn Error>` not overlap.//! String manipulation.//! For more details, see the [`std::str`] module.//! [`std::str`]: ../../std/str/index.html/// Associated searcher for this pattern/// Constructs the associated searcher from/// `self` and the `haystack` to search in./// Checks whether the pattern matches anywhere in the haystack/// Checks whether the pattern matches at the front of the haystack/// Checks whether the pattern matches at the back of the haystack/// Removes the pattern from the front of haystack, if it matches./// Removes the pattern from the back of haystack, if it matches./// Returns the pattern as utf-8 bytes if possible./// A string pattern./// A `Pattern` expresses that the implementing type/// can be used as a string pattern for searching in a [`&str`][str]./// For example, both `'a'` and `"aa"` are patterns that/// would match at index `1` in the string `"baaaab"`./// The trait itself acts as a builder for an associated/// [`Searcher`] type, which does the actual work of finding/// occurrences of the pattern in a string./// Depending on the type of the pattern, the behavior of methods like/// [`str::find`] and [`str::contains`] can change. The table below describes/// some of those behaviors./// | Pattern type             | Match condition                           |/// |--------------------------|-------------------------------------------|/// | `&str`                   | is substring                              |/// | `char`                   | is contained in string                    |/// | `&[char]`                | any char in slice is contained in string  |/// | `F: FnMut(char) -> bool` | `F` returns `true` for a char in string   |/// | `&&str`                  | is substring                              |/// | `&String`                | is substring                              |/// // &str/// assert_eq!("abaaa".find("ba"), Some(1));/// assert_eq!("abaaa".find("bac"), None);/// // char/// assert_eq!("abaaa".find('a'), Some(0));/// assert_eq!("abaaa".find('b'), Some(1));/// assert_eq!("abaaa".find('c'), None);/// // &[char; N]/// assert_eq!("ab".find(&['b', 'a']), Some(0));/// assert_eq!("abaaa".find(&['a', 'z']), Some(0));/// assert_eq!("abaaa".find(&['c', 'd']), None);/// // &[char]/// assert_eq!("ab".find(&['b', 'a'][..]), Some(0));/// assert_eq!("abaaa".find(&['a', 'z'][..]), Some(0));/// assert_eq!("abaaa".find(&['c', 'd'][..]), None);/// // FnMut(char) -> bool/// assert_eq!("abcdef_z".find(|ch| ch > 'd' && ch < 'y'), Some(4));/// assert_eq!("abcddd_z".find(|ch| ch > 'd' && ch < 'y'), None);StringPattern/// Type returned by String and str types.CharPattern/// Type returned by char types./// Result of calling [`Pattern::as_utf8_pattern()`]./// Can be used for inspecting the contents of a [`Pattern`] in cases/// where the underlying representation can be represented as UTF-8./// Expresses that a match of the pattern has been found at/// `haystack[a..b]`./// Expresses that `haystack[a..b]` has been rejected as a possible match/// of the pattern./// Note that there might be more than one `Reject` between two `Match`es,/// there is no requirement for them to be combined into one./// Expresses that every byte of the haystack has been visited, ending/// the iteration./// Result of calling [`Searcher::next()`] or [`ReverseSearcher::next_back()`]./// Getter for the underlying string to be searched in/// Will always return the same [`&str`][str]./// Performs the next search step starting from the front./// - Returns [`Match(a, b)`][SearchStep::Match] if `haystack[a..b]` matches///   the pattern./// - Returns [`Reject(a, b)`][SearchStep::Reject] if `haystack[a..b]` can///   not match the pattern, even partially./// - Returns [`Done`][SearchStep::Done] if every byte of the haystack has///   been visited./// The stream of [`Match`][SearchStep::Match] and/// [`Reject`][SearchStep::Reject] values up to a [`Done`][SearchStep::Done]/// will contain index ranges that are adjacent, non-overlapping,/// covering the whole haystack, and laying on utf8 boundaries./// A [`Match`][SearchStep::Match] result needs to contain the whole matched/// pattern, however [`Reject`][SearchStep::Reject] results may be split up/// into arbitrary many adjacent fragments. Both ranges may have zero length./// As an example, the pattern `"aaa"` and the haystack `"cbaaaaab"`/// might produce the stream/// `[Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]`/// Finds the next [`Match`][SearchStep::Match] result. See [`next()`][Searcher::next]./// Unlike [`next()`][Searcher::next], there is no guarantee that the returned ranges/// of this and [`next_reject`][Searcher::next_reject] will overlap. This will return/// `(start_match, end_match)`, where start_match is the index of where/// the match begins, and end_match is the index after the end of the match.next_reject/// Finds the next [`Reject`][SearchStep::Reject] result. See [`next()`][Searcher::next]/// and [`next_match()`][Searcher::next_match]./// of this and [`next_match`][Searcher::next_match] will overlap./// A searcher for a string pattern./// This trait provides methods for searching for non-overlapping/// matches of a pattern starting from the front (left) of a string./// It will be implemented by associated `Searcher`/// types of the [`Pattern`] trait./// The trait is marked unsafe because the indices returned by the/// [`next()`][Searcher::next] methods are required to lie on valid utf8/// boundaries in the haystack. This enables consumers of this trait to/// slice the haystack without additional runtime checks./// Performs the next search step starting from the back./// - Returns [`Match(a, b)`][SearchStep::Match] if `haystack[a..b]`///   matches the pattern./// - Returns [`Reject(a, b)`][SearchStep::Reject] if `haystack[a..b]`///   can not match the pattern, even partially./// - Returns [`Done`][SearchStep::Done] if every byte of the haystack///   has been visited/// `[Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)]`.next_match_back/// Finds the next [`Match`][SearchStep::Match] result./// See [`next_back()`][ReverseSearcher::next_back].next_reject_back/// Finds the next [`Reject`][SearchStep::Reject] result./// A reverse searcher for a string pattern./// matches of a pattern starting from the back (right) of a string./// It will be implemented by associated [`Searcher`]/// types of the [`Pattern`] trait if the pattern supports searching/// for it from the back./// The index ranges returned by this trait are not required/// to exactly match those of the forward search in reverse./// For the reason why this trait is marked unsafe, see the/// parent trait [`Searcher`]./// A marker trait to express that a [`ReverseSearcher`]/// can be used for a [`DoubleEndedIterator`] implementation./// For this, the impl of [`Searcher`] and [`ReverseSearcher`] need/// to follow these conditions:/// - All results of `next()` need to be identical///   to the results of `next_back()` in reverse order./// - `next()` and `next_back()` need to behave as///   the two ends of a range of values, that is they///   can not "walk past each other"./// `char::Searcher` is a `DoubleEndedSearcher` because searching for a/// [`char`] only requires looking at one at a time, which behaves the same/// from both ends./// `(&str)::Searcher` is not a `DoubleEndedSearcher` because/// the pattern `"aa"` in the haystack `"aaa"` matches as either/// `"[aa]a"` or `"a[aa]"`, depending on which side it is searched.finger// safety invariant: `finger`/`finger_back` must be a valid utf8 byte index of `haystack`// This invariant can be broken *within* next_match and next_match_back, however// they must exit with fingers on valid code point boundaries./// `finger` is the current byte index of the forward search./// Imagine that it exists before the byte at its index, i.e./// `haystack[finger]` is the first byte of the slice we must inspect during/// forward searchingfinger_back/// `finger_back` is the current byte index of the reverse search./// Imagine that it exists after the byte at its index, i.e./// haystack[finger_back - 1] is the last byte of the slice we must inspect during/// forward searching (and thus the first byte to be inspected when calling next_back())./// The character being searched forutf8_size// safety invariant: `utf8_size` must be less than 5/// The number of bytes `needle` takes up when encoded in utf8.utf8_encoded/// A utf8 encoded copy of the `needle`CharSearcher/// Associated type for `<char as Pattern>::Searcher<'a>`.// let next_reject use the default implementation from the Searcher trait// let next_reject_back use the default implementation from the Searcher trait/// Searches for chars that are equal to a given [`char`]./// assert_eq!("Hello world".find('o'), Some(4));MultiCharEqMultiCharEqPatternchar_eqMultiCharEqSearcherpattern_methodssearcher_methodsCharArraySearcher/// Associated type for `<[char; N] as Pattern>::Searcher<'a>`.CharArrayRefSearcher/// Associated type for `<&[char; N] as Pattern>::Searcher<'a>`./// Searches for chars that are equal to any of the [`char`]s in the array./// assert_eq!("Hello world".find(['o', 'l']), Some(2));/// assert_eq!("Hello world".find(['h', 'w']), Some(6));/// assert_eq!("Hello world".find(&['o', 'l']), Some(2));/// assert_eq!("Hello world".find(&['h', 'w']), Some(6));CharSliceSearcher/// Associated type for `<&[char] as Pattern>::Searcher<'a>`./// Searches for chars that are equal to any of the [`char`]s in the slice./// assert_eq!("Hello world".find(&['o', 'l'][..]), Some(2));/// assert_eq!("Hello world".find(&['h', 'w'][..]), Some(6));CharPredicateSearcher/// Associated type for `<F as Pattern>::Searcher<'a>`./// Searches for [`char`]s that match the given predicate./// assert_eq!("Hello world".find(char::is_uppercase), Some(0));/// assert_eq!("Hello world".find(|c| "aeiou".contains(c)), Some(1));StrSearcher/// Delegates to the `&str` impl./// Checks whether the pattern matches at the front of the haystack./// Checks whether the pattern matches at the back of the haystack./// Non-allocating substring search./// Will handle the pattern `""` as returning empty matches at each character/// assert_eq!("Hello world".find("world"), Some(6));StrSearcherImpl/// Associated type for `<&str as Pattern>::Searcher<'a>`.EmptyNeedleTwoWaySearcheris_match_fwis_match_bw// Needed in case of an empty haystack, see #85462crit_pos/// critical factorization indexcrit_pos_back/// critical factorization index for reversed needle/// `byteset` is an extension (not part of the two way algorithm);/// it's a 64-bit "fingerprint" where each set bit `j` corresponds/// to a (byte & 63) == j present in the needle.// variables/// index into needle before which we have already matchedmemory_back/// index into needle after which we have already matched/// The internal state of the two-way substring search algorithm.byteset_createbyteset_containsTwoWayStrategy// One of the main ideas of Two-Way is that we factorize the needle into// two halves, (u, v), and begin trying to find v in the haystack by scanning// left to right. If v matches, we try to match u by scanning right to left.// How far we can jump when we encounter a mismatch is all based on the fact// that (u, v) is a critical factorization for the needle.// Follows the ideas in `next()`.// The definitions are symmetrical, with period(x) = period(reverse(x))// and local_period(u, v) = local_period(reverse(v), reverse(u)), so if (u, v)// is a critical factorization, so is (reverse(v), reverse(u)).// For the reverse case we have computed a critical factorization x = u' v'// (field `crit_pos_back`). We need |u| < period(x) for the forward case and// thus |v'| < period(x) for the reverse.// To search in reverse through the haystack, we search forward through// a reversed haystack with a reversed needle, matching first u' and then v'.maximal_suffix// Compute the maximal suffix of `arr`.// The maximal suffix is a possible critical factorization (u, v) of `arr`.// Returns (`i`, `p`) where `i` is the starting index of v and `p` is the// period of v.// `order_greater` determines if lexical order is `<` or `>`. Both// orders must be computed -- the ordering with the largest `i` gives// a critical factorization.// For long period cases, the resulting period is not exact (it is too short).reverse_maximal_suffix// Compute the maximal suffix of the reverse of `arr`.// The maximal suffix is a possible critical factorization (u', v') of `arr`.// Returns `i` where `i` is the starting index of v', from the back;// returns immediately when a period of `known_period` is reached./*
    This is the Two-Way search algorithm, which was introduced in the paper:
    Crochemore, M., Perrin, D., 1991, Two-way string-matching, Journal of the ACM 38(3):651-675.

    Here's some background information.

    A *word* is a string of symbols. The *length* of a word should be a familiar
    notion, and here we denote it for any word x by |x|.
    (We also allow for the possibility of the *empty word*, a word of length zero).

    If x is any non-empty word, then an integer p with 0 < p <= |x| is said to be a
    *period* for x iff for all i with 0 <= i <= |x| - p - 1, we have x[i] == x[i+p].
    For example, both 1 and 2 are periods for the string "aa". As another example,
    the only period of the string "abcd" is 4.

    We denote by period(x) the *smallest* period of x (provided that x is non-empty).
    This is always well-defined since every non-empty word x has at least one period,
    |x|. We sometimes call this *the period* of x.

    If u, v and x are words such that x = uv, where uv is the concatenation of u and
    v, then we say that (u, v) is a *factorization* of x.

    Let (u, v) be a factorization for a word x. Then if w is a non-empty word such
    that both of the following hold

      - either w is a suffix of u or u is a suffix of w
      - either w is a prefix of v or v is a prefix of w

    then w is said to be a *repetition* for the factorization (u, v).

    Just to unpack this, there are four possibilities here. Let w = "abc". Then we
    might have:

      - w is a suffix of u and w is a prefix of v. ex: ("lolabc", "abcde")
      - w is a suffix of u and v is a prefix of w. ex: ("lolabc", "ab")
      - u is a suffix of w and w is a prefix of v. ex: ("bc", "abchi")
      - u is a suffix of w and v is a prefix of w. ex: ("bc", "a")

    Note that the word vu is a repetition for any factorization (u,v) of x = uv,
    so every factorization has at least one repetition.

    If x is a string and (u, v) is a factorization for x, then a *local period* for
    (u, v) is an integer r such that there is some word w such that |w| = r and w is
    a repetition for (u, v).

    We denote by local_period(u, v) the smallest local period of (u, v). We sometimes
    call this *the local period* of (u, v). Provided that x = uv is non-empty, this
    is well-defined (because each non-empty word has at least one factorization, as
    noted above).

    It can be proven that the following is an equivalent definition of a local period
    for a factorization (u, v): any positive integer r such that x[i] == x[i+r] for
    all i such that |u| - r <= i <= |u| - 1 and such that both x[i] and x[i+r] are
    defined. (i.e., i > 0 and i + r < |x|).

    Using the above reformulation, it is easy to prove that

        1 <= local_period(u, v) <= period(uv)

    A factorization (u, v) of x such that local_period(u,v) = period(x) is called a
    *critical factorization*.

    The algorithm hinges on the following theorem, which is stated without proof:

    **Critical Factorization Theorem** Any word x has at least one critical
    factorization (u, v) such that |u| < period(x).

    The purpose of maximal_suffix is to find such a critical factorization.

    If the period is short, compute another factorization x = u' v' to use
    for reverse search, chosen instead so that |v'| < period(x).

*/use_early_rejectrejecting// TwoWayStrategy allows the algorithm to either skip non-matches as quickly// as possible, or to work in a mode where it emits Rejects relatively quickly.MatchOnly/// Skip to match intervals as quickly as possibleRejectAndMatch/// Emit Rejects regularlysimd_contains/// SIMD search for short needles based on/// Wojciech Muła's "SIMD-friendly algorithms for substring searching"[0]/// It skips ahead by the vector width on each iteration (rather than the needle length as two-way/// does) by probing the first and last byte of the needle for the whole vector width/// and only doing full needle comparisons when the vectorized probe indicated potential matches./// Since the x86_64 baseline only offers SSE2 we only use u8x16 here./// If we ever ship std with for x86-64-v3 or adapt this for other platforms then wider vectors/// should be evaluated./// Similarly, on LoongArch the 128-bit LSX vector extension is the baseline,/// so we also use `u8x16` there. Wider vector widths may be considered/// for future LoongArch extensions (e.g., LASX)./// For haystacks smaller than vector-size + needle length it falls back to/// a naive O(n*m) search so this implementation should not be called on larger needles./// [0]: http://0x80.pl/articles/simd-strfind.html#sse-avx2small_slice_eq/// Compares short slices for equality./// It avoids a call to libc's memcmp which is faster on long slices/// due to SIMD optimizations but it incurs a function call overhead./// Both slices must have the same length.//! The string Pattern API.//! The Pattern API provides a generic mechanism for using different pattern//! types when searching through a string.//! For more details, see the traits [`Pattern`], [`Searcher`],//! [`ReverseSearcher`], and [`DoubleEndedSearcher`].//! Although this API is unstable, it is exposed via stable APIs on the//! [`str`] type.//! [`Pattern`] is [implemented][pattern-impls] in the stable API for//! [`&str`][`str`], [`char`], slices of [`char`], and functions and closures//! implementing `FnMut(char) -> bool`.//! let s = "Can you find a needle in a haystack?";//! // &str pattern//! assert_eq!(s.find("you"), Some(4));//! // char pattern//! assert_eq!(s.find('n'), Some(2));//! // array of chars pattern//! assert_eq!(s.find(&['a', 'e', 'i', 'o', 'u']), Some(1));//! // slice of chars pattern//! assert_eq!(s.find(&['a', 'e', 'i', 'o', 'u'][..]), Some(1));//! // closure pattern//! assert_eq!(s.find(|c: char| c.is_ascii_punctuation()), Some(35));//! [pattern-impls]: Pattern#implementors// Pattern// Searcher// Impl for char// Impl for a MultiCharEq wrapper// Impl for &[char]// Todo: Change / Remove due to ambiguity in meaning.// Impl for F: FnMut(char) -> bool// Impl for &&str// Impl for &str// Two Way substring searcher/// Implements ordering of strings./// Strings are ordered  [lexicographically](Ord#lexicographical-comparison) by their byte values. This orders Unicode code/// points based on their positions in the code charts. This is not necessarily the same as/// "alphabetical" order, which varies by language and locale. Sorting strings according to/// culturally-accepted standards requires locale-specific data that is outside the scope of/// the `str` type./// Implements comparison operations on strings./// Strings are compared [lexicographically](Ord#lexicographical-comparison) by their byte values. This compares Unicode code/// "alphabetical" order, which varies by language and locale. Comparing strings according tostr_index_overflow_fail/// Implements substring slicing with syntax `&self[..]` or `&mut self[..]`./// Returns a slice of the whole string, i.e., returns `&self` or `&mut/// self`. Equivalent to `&self[0 .. len]` or `&mut self[0 .. len]`. Unlike/// other indexing operations, this can never panic./// This operation is *O*(1)./// Prior to 1.20.0, these indexing operations were still supported by/// direct implementation of `Index` and `IndexMut`./// Equivalent to `&self[0 .. len]` or `&mut self[0 .. len]`./// Implements substring slicing with syntax `&self[begin .. end]` or `&mut/// self[begin .. end]`./// Returns a slice of the given string from the byte range/// [`begin`, `end`)./// Panics if `begin` or `end` does not point to the starting byte offset of/// a character (as defined by `is_char_boundary`), if `begin > end`, or if/// `end > len`./// assert_eq!(&s[0 .. 1], "L");/// assert_eq!(&s[1 .. 9], "öwe 老");/// // these will panic:/// // byte 2 lies within `ö`:/// // &s[2 ..3];/// // byte 8 lies within `老`/// // &s[1 .. 8];/// // byte 100 is outside the string/// // &s[3 .. 100];/// Implements substring slicing for arbitrary bounds./// Returns a slice of the given string bounded by the byte indices/// provided by each bound./// Panics if `begin` or `end` (if it exists and once adjusted for/// inclusion/exclusion) does not point to the starting byte offset of/// Implements substring slicing with syntax `&self[.. end]` or `&mut/// self[.. end]`./// Returns a slice of the given string from the byte range \[0, `end`)./// Equivalent to `&self[0 .. end]` or `&mut self[0 .. end]`./// Panics if `end` does not point to the starting byte offset of a/// character (as defined by `is_char_boundary`), or if `end > len`./// Implements substring slicing with syntax `&self[begin ..]` or `&mut/// self[begin ..]`./// Returns a slice of the given string from the byte range \[`begin`, `len`)./// Equivalent to `&self[begin .. len]` or `&mut self[begin .. len]`./// Panics if `begin` does not point to the starting byte offset of/// a character (as defined by `is_char_boundary`), or if `begin > len`./// Implements substring slicing with syntax `&self[begin ..= end]` or `&mut/// self[begin ..= end]`./// [`begin`, `end`]. Equivalent to `&self [begin .. end + 1]` or `&mut/// self[begin .. end + 1]`, except if `end` has the maximum value for/// a character (as defined by `is_char_boundary`), if `end` does not point/// to the ending byte offset of a character (`end + 1` is either a starting/// byte offset or equal to `len`), if `begin > end`, or if `end >= len`./// Implements substring slicing with syntax `&self[..= end]` or `&mut/// self[..= end]`./// Returns a slice of the given string from the byte range \[0, `end`\]./// Equivalent to `&self [0 .. end + 1]`, except if `end` has the maximum/// value for `usize`./// Panics if `end` does not point to the ending byte offset of a character/// (`end + 1` is either a starting byte offset as defined by/// `is_char_boundary`, or equal to `len`), or if `end >= len`./// The associated error which can be returned from parsing."from_str_method"/// Parses a string `s` to return a value of this type./// If parsing succeeds, return the value inside [`Ok`], otherwise/// when the string is ill-formatted return an error specific to the/// inside [`Err`]. The error type is specific to the implementation of the trait./// Basic usage with [`i32`], a type that implements `FromStr`:/// let s = "5";/// let x = i32::from_str(s).unwrap();/// assert_eq!(5, x);/// Parse a value from a string/// `FromStr`'s [`from_str`] method is often used implicitly, through/// [`str`]'s [`parse`] method. See [`parse`]'s documentation for examples./// [`from_str`]: FromStr::from_str/// `FromStr` does not have a lifetime parameter, and so you can only parse types/// that do not contain a lifetime parameter themselves. In other words, you can/// parse an `i32` with `FromStr`, but not a `&i32`. You can parse a struct that/// contains an `i32`, but not one that contains an `&i32`./// # Input format and round-tripping/// The input format expected by a type's `FromStr` implementation depends on the type. Check the/// type's documentation for the input formats it knows how to parse. Note that the input format of/// a type's `FromStr` implementation might not necessarily accept the output format of its/// `Display` implementation, and even if it does, the `Display` implementation may not be lossless/// so the round-trip may lose information./// Basic implementation of `FromStr` on an example `Point` type:///     y: i32/// struct ParsePointError;/// impl FromStr for Point {///     type Err = ParsePointError;///         let (x, y) = s///             .strip_prefix('(')///             .and_then(|s| s.strip_suffix(')'))///             .and_then(|s| s.split_once(','))///             .ok_or(ParsePointError)?;///         let x_fromstr = x.parse::<i32>().map_err(|_| ParsePointError)?;///         let y_fromstr = y.parse::<i32>().map_err(|_| ParsePointError)?;///         Ok(Point { x: x_fromstr, y: y_fromstr })/// let expected = Ok(Point { x: 1, y: 2 });/// // Explicit call/// assert_eq!(Point::from_str("(1,2)"), expected);/// // Implicit calls, through parse/// assert_eq!("(1,2)".parse(), expected);/// assert_eq!("(1,2)".parse::<Point>(), expected);/// // Invalid input string/// assert!(Point::from_str("(1 2)").is_err());/// Parse a `bool` from a string./// The only accepted values are `"true"` and `"false"`. Any other input/// assert_eq!(FromStr::from_str("true"), Ok(true));/// assert_eq!(FromStr::from_str("false"), Ok(false));/// assert!(<bool as FromStr>::from_str("not even a boolean").is_err());/// Note, in many cases, the `.parse()` method on `str` is more proper./// assert_eq!("true".parse(), Ok(true));/// assert_eq!("false".parse(), Ok(false));/// assert!("not even a boolean".parse::<bool>().is_err());//! Trait implementations for `str`.utf8_first_byte/// Returns the initial codepoint accumulator for the first byte./// The first byte is special, only want bottom 5 bits for width 2, 4 bits/// for width 3, and 3 bits for width 4.utf8_acc_cont_byte/// Returns the value of `ch` updated with continuation byte `byte`.utf8_is_cont_byte/// Checks whether the byte is a UTF-8 continuation byte (i.e., starts with the/// bits `10`)./// Reads the next code point out of a byte iterator (assuming a/// UTF-8-like encoding)./// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string/// Reads the last code point out of a byte iterator (assuming aNONASCII_MASKcontains_nonascii/// Returns `true` if any byte in the word `x` is nonascii (>= 128)./// Walks through `v` checking that it's a valid UTF-8 sequence,/// returning `Ok(())` in that case, or, if it is invalid, `Err(err)`.// https://tools.ietf.org/html/rfc3629/// Given a first byte, determines how many bytes are in this UTF-8 character.CONT_MASK/// Mask of the value bits of a continuation byte.//! Operations related to UTF-8 validation."atomic_mod"AOAtomicInner/// Temporary implementation detail.AtomicPrimitive/// A marker trait for primitive types which can be modified atomically./// This is an implementation detail for <code>[Atomic]\<T></code> which may disappear or be replaced at any time./// Types implementing this trait must be primitives that can be modified atomically./// The associated `Self::AtomicInner` type must have the same size and bit validity as `Self`,/// but may have a higher alignment requirement, so the following `transmute`s are sound:/// - `&mut Self::AtomicInner` as `&mut Self`/// - `Self` as `Self::AtomicInner` or the reverseimpl_atomic_primitive/// A memory location which can be safely modified from multiple threads./// This has the same size and bit validity as the underlying type `T`. However,/// the alignment of this type is always equal to its size, even on targets where/// `T` has alignment less than its size./// For more about the differences between atomic types and non-atomic types as/// well as information about the portability of this type, please see the/// [module-level documentation]./// **Note:** This type is only available on platforms that support atomic loads/// and stores of `T`./// [module-level documentation]: crate::sync::atomicEMULATE_ATOMIC_BOOL// Some architectures don't have byte-sized atomics, which results in LLVM// emulating them using a LL/SC loop. However for AtomicBool we can take// advantage of the fact that it only ever contains 0 or 1 and use atomic OR/AND// instead, which LLVM can emulate using a larger atomic OR/AND operation.// This list should only contain architectures which have word-sized atomic-or/// atomic-and instructions but don't natively support byte-sized atomics."AtomicBool"/// A boolean type which can be safely shared between threads./// This type has the same size, alignment, and bit validity as a [`bool`]./// loads and stores of `u8`./// Creates an `AtomicBool` initialized to `false`.// Send is implicitly implemented for AtomicBool."AtomicPtr"/// A raw pointer type which can be safely shared between threads./// This type has the same size and bit validity as a `*mut T`./// loads and stores of pointers. Its size depends on the target pointer's size./// Creates a null `AtomicPtr<T>`./// No ordering constraints, only atomic operations./// Corresponds to [`memory_order_relaxed`] in C++20./// [`memory_order_relaxed`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Relaxed_ordering/// When coupled with a store, all previous operations become ordered/// before any load of this value with [`Acquire`] (or stronger) ordering./// In particular, all previous writes become visible to all threads/// that perform an [`Acquire`] (or stronger) load of this value./// Notice that using this ordering for an operation that combines loads/// and stores leads to a [`Relaxed`] load operation!/// This ordering is only applicable for operations that can perform a store./// Corresponds to [`memory_order_release`] in C++20./// [`memory_order_release`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering/// When coupled with a load, if the loaded value was written by a store operation with/// [`Release`] (or stronger) ordering, then all subsequent operations/// become ordered after that store. In particular, all subsequent loads will see data/// written before the store./// and stores leads to a [`Relaxed`] store operation!/// This ordering is only applicable for operations that can perform a load./// Corresponds to [`memory_order_acquire`] in C++20./// [`memory_order_acquire`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering/// Has the effects of both [`Acquire`] and [`Release`] together:/// For loads it uses [`Acquire`] ordering. For stores it uses the [`Release`] ordering./// Notice that in the case of `compare_and_swap`, it is possible that the operation ends up/// not performing any store and hence it has just [`Acquire`] ordering. However,/// `AcqRel` will never perform [`Relaxed`] accesses./// This ordering is only applicable for operations that combine both loads and stores./// Corresponds to [`memory_order_acq_rel`] in C++20./// [`memory_order_acq_rel`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering/// Like [`Acquire`]/[`Release`]/[`AcqRel`] (for load, store, and load-with-store/// operations, respectively) with the additional guarantee that all threads see all/// sequentially consistent operations in the same order./// Corresponds to [`memory_order_seq_cst`] in C++20./// [`memory_order_seq_cst`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Sequentially-consistent_ordering/// Atomic memory orderings/// Memory orderings specify the way atomic operations synchronize memory./// In its weakest [`Ordering::Relaxed`], only the memory directly touched by the/// operation is synchronized. On the other hand, a store-load pair of [`Ordering::SeqCst`]/// operations synchronize other memory while additionally preserving a total order of such/// operations across all threads./// Rust's memory orderings are [the same as those of/// C++20](https://en.cppreference.com/w/cpp/atomic/memory_order)./// For more information see the [nomicon]./// [nomicon]: ../../../nomicon/atomics.html/// An [`AtomicBool`] initialized to `false`./// Creates a new `AtomicBool`./// let atomic_true = AtomicBool::new(true);/// let atomic_false = AtomicBool::new(false);/// Creates a new `AtomicBool` from a pointer./// use std::sync::atomic::{self, AtomicBool};/// // Get a pointer to an allocated value/// let ptr: *mut bool = Box::into_raw(Box::new(false));/// assert!(ptr.cast::<AtomicBool>().is_aligned());///     // Create an atomic view of the allocated value///     let atomic = unsafe { AtomicBool::from_ptr(ptr) };///     // Use `atomic` for atomic operations, possibly share it with other threads///     atomic.store(true, atomic::Ordering::Relaxed);/// // It's ok to non-atomically access the value behind `ptr`,/// // since the reference to the atomic ended its lifetime in the block above/// assert_eq!(unsafe { *ptr }, true);/// // Deallocate the value/// unsafe { drop(Box::from_raw(ptr)) }/// * `ptr` must be aligned to `align_of::<AtomicBool>()` (note that this is always true, since///   `align_of::<AtomicBool>() == 1`)./// * `ptr` must be [valid] for both reads and writes for the whole lifetime `'a`./// * You must adhere to the [Memory model for atomic accesses]. In particular, it is not///   allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different///   sizes, without synchronization./// [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses/// Returns a mutable reference to the underlying [`bool`]./// let mut some_bool = AtomicBool::new(true);/// assert_eq!(*some_bool.get_mut(), true);/// *some_bool.get_mut() = false;/// assert_eq!(some_bool.load(Ordering::SeqCst), false);/// Gets atomic access to a `&mut bool`./// #![feature(atomic_from_mut)]/// let mut some_bool = true;/// let a = AtomicBool::from_mut(&mut some_bool);/// a.store(false, Ordering::Relaxed);/// assert_eq!(some_bool, false);get_mut_slice/// Gets non-atomic access to a `&mut [AtomicBool]` slice./// let mut some_bools = [const { AtomicBool::new(false) }; 10];/// let view: &mut [bool] = AtomicBool::get_mut_slice(&mut some_bools);/// assert_eq!(view, [false; 10]);/// view[..5].copy_from_slice(&[true; 5]);/// std::thread::scope(|s| {///     for t in &some_bools[..5] {///         s.spawn(move || assert_eq!(t.load(Ordering::Relaxed), true));///     for f in &some_bools[5..] {///         s.spawn(move || assert_eq!(f.load(Ordering::Relaxed), false));/// Gets atomic access to a `&mut [bool]` slice./// ```rust,ignore-wasm/// let mut some_bools = [false; 10];/// let a = &*AtomicBool::from_mut_slice(&mut some_bools);///     for i in 0..a.len() {///         s.spawn(move || a[i].store(true, Ordering::Relaxed));/// assert_eq!(some_bools, [true; 10]);/// let some_bool = AtomicBool::new(true);/// assert_eq!(some_bool.into_inner(), true);/// Loads a value from the bool./// `load` takes an [`Ordering`] argument which describes the memory ordering/// of this operation. Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`]./// Panics if `order` is [`Release`] or [`AcqRel`]./// assert_eq!(some_bool.load(Ordering::Relaxed), true);/// Stores a value into the bool./// `store` takes an [`Ordering`] argument which describes the memory ordering/// of this operation. Possible values are [`SeqCst`], [`Release`] and [`Relaxed`]./// Panics if `order` is [`Acquire`] or [`AcqRel`]./// some_bool.store(false, Ordering::Relaxed);/// assert_eq!(some_bool.load(Ordering::Relaxed), false);/// Stores a value into the bool, returning the previous value./// `swap` takes an [`Ordering`] argument which describes the memory ordering/// of this operation. All ordering modes are possible. Note that using/// [`Acquire`] makes the store part of this operation [`Relaxed`], and/// using [`Release`] makes the load part [`Relaxed`]./// **Note:** This method is only available on platforms that support atomic/// operations on `u8`./// assert_eq!(some_bool.swap(false, Ordering::Relaxed), true);/// Stores a value into the [`bool`] if the current value is the same as the `current` value./// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory/// ordering of this operation. Notice that even when using [`AcqRel`], the operation/// might fail and hence just perform an `Acquire` load, but not have `Release` semantics./// Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it/// happens, and using [`Release`] makes the load part [`Relaxed`]./// # Migrating to `compare_exchange` and `compare_exchange_weak`/// `compare_and_swap` is equivalent to `compare_exchange` with the following mapping for/// `compare_and_swap` and `compare_exchange` also differ in their return type. You can use/// `compare_exchange(...).unwrap_or_else(|x| x)` to recover the behavior of `compare_and_swap`,/// but in most cases it is more idiomatic to check whether the return value is `Ok` or `Err`/// rather than to infer success vs failure based on the value that was read./// During migration, consider whether it makes sense to use `compare_exchange_weak` instead./// `compare_exchange_weak` is allowed to fail spuriously even when the comparison succeeds,/// which allows the compiler to generate better assembly code when the compare and swap/// is used in a loop./// assert_eq!(some_bool.compare_and_swap(true, false, Ordering::Relaxed), true);/// assert_eq!(some_bool.compare_and_swap(true, true, Ordering::Relaxed), false);/// `compare_exchange` takes two [`Ordering`] arguments to describe the memory/// 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`]./// assert_eq!(some_bool.compare_exchange(true,///                                       false,///                                       Ordering::Acquire,///                                       Ordering::Relaxed),///            Ok(true));/// assert_eq!(some_bool.compare_exchange(true, true,///                                       Ordering::SeqCst,///                                       Ordering::Acquire),///            Err(false));/// # Considerations/// `compare_exchange` is a [compare-and-swap operation] and thus exhibits the usual downsides/// of CAS operations. In particular, a load of the value followed by a successful/// `compare_exchange` with the previous load *does not ensure* that other threads have not/// changed the value in the interim. This is usually important when the *equality* check in/// the `compare_exchange` is being used to check the *identity* of a value, but equality/// does not necessarily imply identity. In this case, `compare_exchange` can lead to the/// [ABA problem]./// [ABA Problem]: https://en.wikipedia.org/wiki/ABA_problem/// [compare-and-swap operation]: https://en.wikipedia.org/wiki/Compare-and-swap/// Unlike [`AtomicBool::compare_exchange`], this function is allowed to spuriously fail even when the/// comparison succeeds, which can result in more efficient code on some platforms. The/// return value is a result indicating whether the new value was written and containing the/// previous value./// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory/// let val = AtomicBool::new(false);/// let new = true;/// let mut old = val.load(Ordering::Relaxed);///     match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {///         Err(x) => old = x,/// Performs a logical "and" operation on the current value and the argument `val`, and sets/// the new value to the result./// `fetch_and` takes an [`Ordering`] argument which describes the memory ordering/// let foo = AtomicBool::new(true);/// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), true);/// assert_eq!(foo.load(Ordering::SeqCst), false);/// assert_eq!(foo.fetch_and(true, Ordering::SeqCst), true);/// assert_eq!(foo.load(Ordering::SeqCst), true);/// let foo = AtomicBool::new(false);/// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false);/// Logical "nand" with a boolean value./// Performs a logical "nand" operation on the current value and the argument `val`, and sets/// `fetch_nand` takes an [`Ordering`] argument which describes the memory ordering/// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true);/// assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true);/// assert_eq!(foo.load(Ordering::SeqCst) as usize, 0);/// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);/// Performs a logical "or" operation on the current value and the argument `val`, and sets the/// new value to the result./// `fetch_or` takes an [`Ordering`] argument which describes the memory ordering/// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true);/// assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true);/// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false);/// Performs a logical "xor" operation on the current value and the argument `val`, and sets/// `fetch_xor` takes an [`Ordering`] argument which describes the memory ordering/// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true);/// assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true);/// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);/// Logical "not" with a boolean value./// Performs a logical "not" operation on the current value, and sets/// `fetch_not` takes an [`Ordering`] argument which describes the memory ordering/// assert_eq!(foo.fetch_not(Ordering::SeqCst), true);/// assert_eq!(foo.fetch_not(Ordering::SeqCst), false);/// Returns a mutable pointer to the underlying [`bool`]./// Doing non-atomic reads and writes on the resulting boolean can be a data race./// This method is mostly useful for FFI, where the function signature may use/// `*mut bool` instead of `&AtomicBool`./// Returning an `*mut` pointer from a shared reference to this atomic is safe because the/// atomic types work with interior mutability. All modifications of an atomic change the value/// through a shared reference, and can do so safely as long as they use atomic operations. Any/// use of the returned raw pointer requires an `unsafe` block and still has to uphold the/// requirements of the [memory model].///     fn my_atomic_op(arg: *mut bool);/// let mut atomic = AtomicBool::new(true);///     my_atomic_op(atomic.as_ptr());/// [memory model]: self#memory-model-for-atomic-accesses/// new value. Returns a `Result` of `Ok(previous_value)` if the function/// returned `Some(_)`, else `Err(previous_value)`./// orderings of [`AtomicBool::compare_exchange`] respectively./// [`Acquire`] or [`Relaxed`]./// This method is not magic; it is not provided by the hardware, and does not act like a/// critical section or mutex./// It is implemented on top of an atomic [compare-and-swap operation], and thus is subject to/// the usual drawbacks of CAS operations. In particular, be careful of the [ABA problem]./// let x = AtomicBool::new(false);/// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(false));/// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(false));/// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(true));/// assert_eq!(x.load(Ordering::SeqCst), false);try_update/// See also: [`update`](`AtomicBool::update`)./// `try_update` takes two [`Ordering`] arguments to describe the memory/// #![feature(atomic_try_update)]/// assert_eq!(x.try_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(false));/// assert_eq!(x.try_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(false));/// assert_eq!(x.try_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(true));/// Fetches the value, applies a function to it that it return a new value./// The new value is stored and the old value is returned./// See also: [`try_update`](`AtomicBool::try_update`)./// the meantime, but the function will have been applied only once to the stored value./// `update` takes two [`Ordering`] arguments to describe the memory/// [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]./// **Note:** This method is only available on platforms that support atomic operations on `u8`./// assert_eq!(x.update(Ordering::SeqCst, Ordering::SeqCst, |x| !x), false);/// assert_eq!(x.update(Ordering::SeqCst, Ordering::SeqCst, |x| !x), true);/// Creates a new `AtomicPtr`./// use std::sync::atomic::AtomicPtr;/// let ptr = &mut 5;/// let atomic_ptr = AtomicPtr::new(ptr);/// Creates a new `AtomicPtr` from a pointer./// use std::sync::atomic::{self, AtomicPtr};/// let ptr: *mut *mut u8 = Box::into_raw(Box::new(std::ptr::null_mut()));/// assert!(ptr.cast::<AtomicPtr<u8>>().is_aligned());///     let atomic = unsafe { AtomicPtr::from_ptr(ptr) };///     atomic.store(std::ptr::NonNull::dangling().as_ptr(), atomic::Ordering::Relaxed);/// assert!(!unsafe { *ptr }.is_null());/// * `ptr` must be aligned to `align_of::<AtomicPtr<T>>()` (note that on some platforms this///   can be bigger than `align_of::<*mut T>()`)./// Returns a mutable reference to the underlying pointer./// use std::sync::atomic::{AtomicPtr, Ordering};/// let mut data = 10;/// let mut atomic_ptr = AtomicPtr::new(&mut data);/// let mut other_data = 5;/// *atomic_ptr.get_mut() = &mut other_data;/// assert_eq!(unsafe { *atomic_ptr.load(Ordering::SeqCst) }, 5);/// Gets atomic access to a pointer./// **Note:** This function is only available on targets where `AtomicPtr<T>` has the same alignment as `*const T`/// let mut data = 123;/// let mut some_ptr = &mut data as *mut i32;/// let a = AtomicPtr::from_mut(&mut some_ptr);/// let mut other_data = 456;/// a.store(&mut other_data, Ordering::Relaxed);/// assert_eq!(unsafe { *some_ptr }, 456);/// Gets non-atomic access to a `&mut [AtomicPtr]` slice./// let mut some_ptrs = [const { AtomicPtr::new(null_mut::<String>()) }; 10];/// let view: &mut [*mut String] = AtomicPtr::get_mut_slice(&mut some_ptrs);/// assert_eq!(view, [null_mut::<String>(); 10]);/// view///     .for_each(|(i, ptr)| *ptr = Box::into_raw(Box::new(format!("iteration#{i}"))));///     for ptr in &some_ptrs {///         s.spawn(move || {///             let ptr = ptr.load(Ordering::Relaxed);///             assert!(!ptr.is_null());///             let name = unsafe { Box::from_raw(ptr) };///             println!("Hello, {name}!");/// Gets atomic access to a slice of pointers./// let mut some_ptrs = [null_mut::<String>(); 10];/// let a = &*AtomicPtr::from_mut_slice(&mut some_ptrs);///             let name = Box::new(format!("thread{i}"));///             a[i].store(Box::into_raw(name), Ordering::Relaxed);/// for p in some_ptrs {///     let name = unsafe { Box::from_raw(p) };///     println!("Hello, {name}!");/// let mut data = 5;/// let atomic_ptr = AtomicPtr::new(&mut data);/// assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);/// Loads a value from the pointer./// let some_ptr = AtomicPtr::new(ptr);/// let value = some_ptr.load(Ordering::Relaxed);/// Stores a value into the pointer./// let other_ptr = &mut 10;/// some_ptr.store(other_ptr, Ordering::Relaxed);/// Stores a value into the pointer, returning the previous value./// operations on pointers./// let value = some_ptr.swap(other_ptr, Ordering::Relaxed);/// Stores a value into the pointer if the current value is the same as the `current` value./// let value = some_ptr.compare_and_swap(ptr, other_ptr, Ordering::Relaxed);/// let value = some_ptr.compare_exchange(ptr, other_ptr,///                                       Ordering::SeqCst, Ordering::Relaxed);/// does not necessarily imply identity. This is a particularly common case for pointers, as/// a pointer holding the same address does not imply that the same object exists at that/// address! In this case, `compare_exchange` can lead to the [ABA problem]./// Unlike [`AtomicPtr::compare_exchange`], this function is allowed to spuriously fail even when the/// let some_ptr = AtomicPtr::new(&mut 5);/// let new = &mut 10;/// let mut old = some_ptr.load(Ordering::Relaxed);///     match some_ptr.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {/// orderings of [`AtomicPtr::compare_exchange`] respectively./// the usual drawbacks of CAS operations. In particular, be careful of the [ABA problem],/// which is a particularly common pitfall for pointers!/// let ptr: *mut _ = &mut 5;/// let new: *mut _ = &mut 10;/// assert_eq!(some_ptr.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(ptr));/// let result = some_ptr.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| {///     if x == ptr {///         Some(new)/// assert_eq!(result, Ok(ptr));/// assert_eq!(some_ptr.load(Ordering::SeqCst), new);/// See also: [`update`](`AtomicPtr::update`)./// assert_eq!(some_ptr.try_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(ptr));/// let result = some_ptr.try_update(Ordering::SeqCst, Ordering::SeqCst, |x| {/// See also: [`try_update`](`AtomicPtr::try_update`)./// let result = some_ptr.update(Ordering::SeqCst, Ordering::SeqCst, |_| new);/// assert_eq!(result, ptr);/// Offsets the pointer's address by adding `val` (in units of `T`),/// returning the previous pointer./// This is equivalent to using [`wrapping_add`] to atomically perform the/// equivalent of `ptr = ptr.wrapping_add(val);`./// This method operates in units of `T`, which means that it cannot be used/// to offset the pointer by an amount which is not a multiple of/// `size_of::<T>()`. This can sometimes be inconvenient, as you may want to/// work with a deliberately misaligned pointer. In such cases, you may use/// the [`fetch_byte_add`](Self::fetch_byte_add) method instead./// `fetch_ptr_add` takes an [`Ordering`] argument which describes the/// memory ordering of this operation. All ordering modes are possible. Note/// that using [`Acquire`] makes the store part of this operation/// [`Relaxed`], and using [`Release`] makes the load part [`Relaxed`]./// **Note**: This method is only available on platforms that support atomic/// operations on [`AtomicPtr`]./// [`wrapping_add`]: pointer::wrapping_add/// use core::sync::atomic::{AtomicPtr, Ordering};/// let atom = AtomicPtr::<i64>::new(core::ptr::null_mut());/// assert_eq!(atom.fetch_ptr_add(1, Ordering::Relaxed).addr(), 0);/// // Note: units of `size_of::<i64>()`./// assert_eq!(atom.load(Ordering::Relaxed).addr(), 8);/// Offsets the pointer's address by subtracting `val` (in units of `T`),/// This is equivalent to using [`wrapping_sub`] to atomically perform the/// equivalent of `ptr = ptr.wrapping_sub(val);`./// the [`fetch_byte_sub`](Self::fetch_byte_sub) method instead./// `fetch_ptr_sub` takes an [`Ordering`] argument which describes the memory/// ordering of this operation. All ordering modes are possible. Note that/// using [`Acquire`] makes the store part of this operation [`Relaxed`],/// and using [`Release`] makes the load part [`Relaxed`]./// [`wrapping_sub`]: pointer::wrapping_sub/// let array = [1i32, 2i32];/// let atom = AtomicPtr::new(array.as_ptr().wrapping_add(1) as *mut _);/// assert!(core::ptr::eq(///     atom.fetch_ptr_sub(1, Ordering::Relaxed),///     &array[1],/// assert!(core::ptr::eq(atom.load(Ordering::Relaxed), &array[0]));/// Offsets the pointer's address by adding `val` *bytes*, returning the/// previous pointer./// This is equivalent to using [`wrapping_byte_add`] to atomically/// perform `ptr = ptr.wrapping_byte_add(val)`./// `fetch_byte_add` takes an [`Ordering`] argument which describes the/// [`wrapping_byte_add`]: pointer::wrapping_byte_add/// assert_eq!(atom.fetch_byte_add(1, Ordering::Relaxed).addr(), 0);/// // Note: in units of bytes, not `size_of::<i64>()`./// assert_eq!(atom.load(Ordering::Relaxed).addr(), 1);/// Offsets the pointer's address by subtracting `val` *bytes*, returning the/// This is equivalent to using [`wrapping_byte_sub`] to atomically/// perform `ptr = ptr.wrapping_byte_sub(val)`./// `fetch_byte_sub` takes an [`Ordering`] argument which describes the/// [`wrapping_byte_sub`]: pointer::wrapping_byte_sub/// let mut arr = [0i64, 1];/// let atom = AtomicPtr::<i64>::new(&raw mut arr[1]);/// assert_eq!(atom.fetch_byte_sub(8, Ordering::Relaxed).addr(), (&raw const arr[1]).addr());/// assert_eq!(atom.load(Ordering::Relaxed).addr(), (&raw const arr[0]).addr());/// Performs a bitwise "or" operation on the address of the current pointer,/// and the argument `val`, and stores a pointer with provenance of the/// current pointer and the resulting address./// This is equivalent to using [`map_addr`] to atomically perform/// `ptr = ptr.map_addr(|a| a | val)`. This can be used in tagged/// pointer schemes to atomically set tag bits./// **Caveat**: This operation returns the previous value. To compute the/// stored value without losing provenance, you may use [`map_addr`]. For/// example: `a.fetch_or(val).map_addr(|a| a | val)`./// `fetch_or` takes an [`Ordering`] argument which describes the memory/// This API and its claimed semantics are part of the Strict Provenance/// experiment, see the [module documentation for `ptr`][crate::ptr] for/// [`map_addr`]: pointer::map_addr/// let pointer = &mut 3i64 as *mut i64;/// let atom = AtomicPtr::<i64>::new(pointer);/// // Tag the bottom bit of the pointer./// assert_eq!(atom.fetch_or(1, Ordering::Relaxed).addr() & 1, 0);/// // Extract and untag./// let tagged = atom.load(Ordering::Relaxed);/// assert_eq!(tagged.addr() & 1, 1);/// assert_eq!(tagged.map_addr(|p| p & !1), pointer);/// Performs a bitwise "and" operation on the address of the current/// pointer, and the argument `val`, and stores a pointer with provenance of/// the current pointer and the resulting address./// `ptr = ptr.map_addr(|a| a & val)`. This can be used in tagged/// pointer schemes to atomically unset tag bits./// example: `a.fetch_and(val).map_addr(|a| a & val)`./// `fetch_and` takes an [`Ordering`] argument which describes the memory/// // A tagged pointer/// let atom = AtomicPtr::<i64>::new(pointer.map_addr(|a| a | 1));/// assert_eq!(atom.fetch_or(1, Ordering::Relaxed).addr() & 1, 1);/// // Untag, and extract the previously tagged pointer./// let untagged = atom.fetch_and(!1, Ordering::Relaxed)///     .map_addr(|a| a & !1);/// assert_eq!(untagged, pointer);/// Performs a bitwise "xor" operation on the address of the current/// `ptr = ptr.map_addr(|a| a ^ val)`. This can be used in tagged/// pointer schemes to atomically toggle tag bits./// example: `a.fetch_xor(val).map_addr(|a| a ^ val)`./// `fetch_xor` takes an [`Ordering`] argument which describes the memory/// // Toggle a tag bit on the pointer./// atom.fetch_xor(1, Ordering::Relaxed);/// assert_eq!(atom.load(Ordering::Relaxed).addr() & 1, 1);/// Returns a mutable pointer to the underlying pointer./// Doing non-atomic reads and writes on the resulting pointer can be a data race./// `*mut *mut T` instead of `&AtomicPtr<T>`.///     fn my_atomic_op(arg: *mut *mut u32);/// let mut value = 17;/// let atomic = AtomicPtr::new(&mut value);/// // SAFETY: Safe as long as `my_atomic_op` is atomic./// Converts a `bool` into an `AtomicBool`./// let atomic_bool = AtomicBool::from(true);/// assert_eq!(format!("{atomic_bool:?}"), "true")/// Converts a `*mut T` into an `AtomicPtr<T>`.if_8_bit// This macro ends up being unused on some architectures.r" An integer type which can be safely shared between threads."r" This type has the same"r" as the underlying integer type, [`"r" For more about the differences between atomic types and"r" non-atomic types as well as information about the portability of"r" this type, please see the [module-level documentation]."r" **Note:** This type is only available on platforms that support"r" atomic loads and stores of [`"r" [module-level documentation]: crate::sync::atomic""AtomicI8"r" Creates a new atomic integer."r" Creates a new reference to an atomic integer from a pointer."r" // Get a pointer to an allocated value"r" {"r"     // Create an atomic view of the allocated value"r"     // Use `atomic` for atomic operations, possibly share it with other threads"r"     atomic.store(1, atomic::Ordering::Relaxed);"r" // It's ok to non-atomically access the value behind `ptr`,"r" // since the reference to the atomic ended its lifetime in the block above"r" assert_eq!(unsafe { *ptr }, 1);"r" // Deallocate the value"r" unsafe { drop(Box::from_raw(ptr)) }"r" * `ptr` must be aligned to"r" * You must adhere to the [Memory model for atomic accesses]. In particular, it is not"r"   allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different"r"   sizes, without synchronization."r" [valid]: crate::ptr#safety"r" [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses"r" Returns a mutable reference to the underlying integer."r" assert_eq!(*some_var.get_mut(), 10);"r" *some_var.get_mut() = 5;"r" assert_eq!(some_var.load(Ordering::SeqCst), 5);"r" #![feature(atomic_from_mut)]"r" let mut some_int = 123;"r" a.store(100, Ordering::Relaxed);"r" assert_eq!(some_int, 100);"r" ```ignore-wasm"r" assert_eq!(view, [0; 10]);"r" view"r"     .iter_mut()"r"     .enumerate()"r"     .for_each(|(idx, int)| *int = idx as _);"r" std::thread::scope(|s| {"r"     some_ints"r"         .iter()"r"         .enumerate()"r"         .for_each(|(idx, int)| {"r"             s.spawn(move || assert_eq!(int.load(Ordering::Relaxed), idx as _));"r" let mut some_ints = [0; 10];"r"     for i in 0..a.len() {"r"         s.spawn(move || a[i].store(i as _, Ordering::Relaxed));"r" for (i, n) in some_ints.into_iter().enumerate() {"r"     assert_eq!(i, n as usize);"r" assert_eq!(some_var.into_inner(), 5);"r" Loads a value from the atomic integer."r" `load` takes an [`Ordering`] argument which describes the memory ordering of this operation."r" Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`]."r" assert_eq!(some_var.load(Ordering::Relaxed), 5);"r" Stores a value into the atomic integer."r" `store` takes an [`Ordering`] argument which describes the memory ordering of this operation."r"  Possible values are [`SeqCst`], [`Release`] and [`Relaxed`]."r" some_var.store(10, Ordering::Relaxed);"r" assert_eq!(some_var.load(Ordering::Relaxed), 10);"r" Stores a value into the atomic integer, returning the previous value."r" **Note**: This method is only available on platforms that support atomic operations on"r" assert_eq!(some_var.swap(10, Ordering::Relaxed), 5);"r" Stores a value into the atomic integer if the current value is the same as"r" the `current` value."r" The return value is always the previous value. If it is equal to `current`, then the"r" value was updated."r" `compare_and_swap` also takes an [`Ordering`] argument which describes the memory"r" ordering of this operation. Notice that even when using [`AcqRel`], the operation"r" might fail and hence just perform an `Acquire` load, but not have `Release` semantics."r" Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it"r" happens, and using [`Release`] makes the load part [`Relaxed`]."r" # Migrating to `compare_exchange` and `compare_exchange_weak`"r" `compare_and_swap` is equivalent to `compare_exchange` with the following mapping for"r" memory orderings:"r" Original | Success | Failure"r" -------- | ------- | -------"r" Relaxed  | Relaxed | Relaxed"r" Acquire  | Acquire | Acquire"r" Release  | Release | Relaxed"r" AcqRel   | AcqRel  | Acquire"r" SeqCst   | SeqCst  | SeqCst"r" `compare_and_swap` and `compare_exchange` also differ in their return type. You can use"r" `compare_exchange(...).unwrap_or_else(|x| x)` to recover the behavior of `compare_and_swap`,"r" but in most cases it is more idiomatic to check whether the return value is `Ok` or `Err`"r" rather than to infer success vs failure based on the value that was read."r" During migration, consider whether it makes sense to use `compare_exchange_weak` instead."r" `compare_exchange_weak` is allowed to fail spuriously even when the comparison succeeds,"r" which allows the compiler to generate better assembly code when the compare and swap"r" is used in a loop."r" assert_eq!(some_var.compare_and_swap(5, 10, Ordering::Relaxed), 5);"r" assert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);"r" The return value is a result indicating whether the new value was written and"r" containing the previous value. On success this value is guaranteed to be equal to"r" `current`."r" assert_eq!(some_var.compare_exchange(5, 10,"r"                                      Ordering::Acquire,"r"                                      Ordering::Relaxed),"r"            Ok(5));"r" assert_eq!(some_var.compare_exchange(6, 12,"r"                                      Ordering::SeqCst,"r"                                      Ordering::Acquire),"r"            Err(10));"r" `compare_exchange` is a [compare-and-swap operation] and thus exhibits the usual downsides"r" of CAS operations. In particular, a load of the value followed by a successful"r" `compare_exchange` with the previous load *does not ensure* that other threads have not"r" changed the value in the interim! This is usually important when the *equality* check in"r" the `compare_exchange` is being used to check the *identity* of a value, but equality"r" does not necessarily imply identity. This is a particularly common case for pointers, as"r" a pointer holding the same address does not imply that the same object exists at that"r" address! In this case, `compare_exchange` can lead to the [ABA problem]."r" [compare-and-swap operation]: https://en.wikipedia.org/wiki/Compare-and-swap"r" this function is allowed to spuriously fail even"r" when the comparison succeeds, which can result in more efficient code on some"r" platforms. The return value is a result indicating whether the new value was"r" written and containing the previous value."r"     let new = old * 2;"r" changed the value in the interim. This is usually important when the *equality* check in"r" Adds to the current value, returning the previous value."r" This operation wraps around on overflow."r" `fetch_add` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);"r" assert_eq!(foo.load(Ordering::SeqCst), 10);"r" Subtracts from the current value, returning the previous value."r" `fetch_sub` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);"r#" Bitwise "and" with the current value."#r#" Performs a bitwise "and" operation on the current value and the argument `val`, and"#r" sets the new value to the result."r" assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);"r" assert_eq!(foo.load(Ordering::SeqCst), 0b100001);"r#" Bitwise "nand" with the current value."#r#" Performs a bitwise "nand" operation on the current value and the argument `val`, and"#r" assert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);"r" assert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));"r#" Bitwise "or" with the current value."#r#" Performs a bitwise "or" operation on the current value and the argument `val`, and"#r" assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);"r" assert_eq!(foo.load(Ordering::SeqCst), 0b111111);"r#" Bitwise "xor" with the current value."#r#" Performs a bitwise "xor" operation on the current value and the argument `val`, and"#r" assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);"r" assert_eq!(foo.load(Ordering::SeqCst), 0b011110);"r" new value. Returns a `Result` of `Ok(previous_value)` if the function returned `Some(_)`, else"r" `Err(previous_value)`."r" Note: This may call the function multiple times if the value has been changed from other threads in"r" the meantime, as long as the function returns `Some(_)`, but the function will have been applied"r" only once to the stored value."r" `fetch_update` takes two [`Ordering`] arguments to describe the memory ordering of this operation."r" The first describes the required ordering for when the operation finally succeeds while the second"r" describes the required ordering for loads. These correspond to the success and failure orderings of"r" Using [`Acquire`] as success ordering makes the store part"r" of this operation [`Relaxed`], and using [`Release`] makes the final successful load"r" [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]."r" This method is not magic; it is not provided by the hardware, and does not act like a"r" critical section or mutex."r" It is implemented on top of an atomic [compare-and-swap operation], and thus is subject to"r" the usual drawbacks of CAS operations. In particular, be careful of the [ABA problem]"r" if this atomic integer is an index or more generally if knowledge of only the *bitwise value*"r" of the atomic is not in and of itself sufficient to ensure any required preconditions."r" assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));"r" assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));"r" assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));"r" assert_eq!(x.load(Ordering::SeqCst), 9);"r" `try_update` takes two [`Ordering`] arguments to describe the memory ordering of this operation."r" #![feature(atomic_try_update)]"r" assert_eq!(x.try_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));"r" assert_eq!(x.try_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));"r" assert_eq!(x.try_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));"r" Fetches the value, applies a function to it that it return a new value."r" The new value is stored and the old value is returned."r" the meantime, but the function will have been applied only once to the stored value."r" `update` takes two [`Ordering`] arguments to describe the memory ordering of this operation."r" [CAS operation]: https://en.wikipedia.org/wiki/Compare-and-swap"r" assert_eq!(x.update(Ordering::SeqCst, Ordering::SeqCst, |x| x + 1), 7);"r" assert_eq!(x.update(Ordering::SeqCst, Ordering::SeqCst, |x| x + 1), 8);"r" Finds the maximum of the current value and the argument `val`, and"r" `fetch_max` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_max(42, Ordering::SeqCst), 23);"r" assert_eq!(foo.load(Ordering::SeqCst), 42);"r" If you want to obtain the maximum value in one step, you can use the following:"r" let bar = 42;"r" let max_foo = foo.fetch_max(bar, Ordering::SeqCst).max(bar);"r" assert!(max_foo == 42);"r" Finds the minimum of the current value and the argument `val`, and"r" `fetch_min` takes an [`Ordering`] argument which describes the memory ordering"r" assert_eq!(foo.fetch_min(42, Ordering::Relaxed), 23);"r" assert_eq!(foo.load(Ordering::Relaxed), 23);"r" assert_eq!(foo.fetch_min(22, Ordering::Relaxed), 23);"r" assert_eq!(foo.load(Ordering::Relaxed), 22);"r" If you want to obtain the minimum value in one step, you can use the following:"r" let bar = 12;"r" let min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);"r" assert_eq!(min_foo, 12);"r" Doing non-atomic reads and writes on the resulting integer can be a data race."r" This method is mostly useful for FFI, where the function signature may use"r" Returning an `*mut` pointer from a shared reference to this atomic is safe because the"r" atomic types work with interior mutability. All modifications of an atomic change the value"r" through a shared reference, and can do so safely as long as they use atomic operations. Any"r" use of the returned raw pointer requires an `unsafe` block and still has to uphold the"r" requirements of the [memory model]."r" ```ignore (extern-declaration)"r" // SAFETY: Safe as long as `my_atomic_op` is atomic."r"     my_atomic_op(atomic.as_ptr());"r" [memory model]: self#memory-model-for-atomic-accesses""AtomicU8""AtomicI16""AtomicU16""AtomicI32""AtomicU32""AtomicI64""AtomicU64""AtomicI128""AtomicU128"atomic_int_ptr_sized"AtomicIsize""AtomicUsize"r" An [`AtomicIsize`] initialized to `0`."ATOMIC_ISIZE_INITr" An [`AtomicUsize`] initialized to `0`."/// Returns the previous value (like __sync_fetch_and_add)./// Returns the previous value (like __sync_fetch_and_sub)./// Publicly exposed for stdarch; nobody else should use this./// Updates `*dst` to the max value of `val` and the old value (signed comparison)/// Updates `*dst` to the min value of `val` and the old value (signed comparison)/// Updates `*dst` to the max value of `val` and the old value (unsigned comparison)/// Updates `*dst` to the min value of `val` and the old value (unsigned comparison)"fence"/// Fences create synchronization between themselves and atomic operations or fences in other/// threads. To achieve this, a fence prevents the compiler and CPU from reordering certain types of/// memory operations around it./// There are 3 different ways to use an atomic fence:/// - atomic - fence synchronization: an atomic operation with (at least) [`Release`] ordering///   semantics synchronizes with a fence with (at least) [`Acquire`] ordering semantics./// - fence - atomic synchronization: a fence with (at least) [`Release`] ordering semantics///   synchronizes with an atomic operation with (at least) [`Acquire`] ordering semantics./// - fence - fence synchronization: a fence with (at least) [`Release`] ordering semantics///   synchronizes with a fence with (at least) [`Acquire`] ordering semantics./// These 3 ways complement the regular, fence-less, atomic - atomic synchronization./// ## Atomic - Fence/// An atomic operation on one thread will synchronize with a fence on another thread when:/// -   on thread 1:///     -   an atomic operation 'X' with (at least) [`Release`] ordering semantics on some atomic///         object 'm',/// -   is paired on thread 2 with:///     -   an atomic read 'Y' with any order on 'm',///     -   followed by a fence 'B' with (at least) [`Acquire`] ordering semantics./// This provides a happens-before dependence between X and B.///     Thread 1                                          Thread 2/// m.store(3, Release); X ---------///                                |///                                -------------> Y  if m.load(Relaxed) == 3 {///                                               B      fence(Acquire);///                                                      ...///                                                  }/// ## Fence - Atomic/// A fence on one thread will synchronize with an atomic operation on another thread when:/// -   on thread:///     -   a fence 'A' with (at least) [`Release`] ordering semantics,///     -   followed by an atomic write 'X' with any ordering on some atomic object 'm',///     -   an atomic operation 'Y' with (at least) [`Acquire`] ordering semantics./// This provides a happens-before dependence between A and Y./// fence(Release);      A/// m.store(3, Relaxed); X ---------///                                -------------> Y  if m.load(Acquire) == 3 {/// ## Fence - Fence/// A fence on one thread will synchronize with a fence on another thread when:///     -   a fence 'A' which has (at least) [`Release`] ordering semantics,///     -   an atomic read 'Y' with any ordering on 'm',/// This provides a happens-before dependence between A and B./// fence(Release);      A --------------/// m.store(3, Relaxed); X ---------    |///                                |    |///                                     |-------> B      fence(Acquire);/// ## Mandatory Atomic/// Note that in the examples above, it is crucial that the access to `m` are atomic. Fences cannot/// be used to establish synchronization between non-atomic accesses in different threads. However,/// thanks to the happens-before relationship, any non-atomic access that happen-before the atomic/// operation or fence with (at least) [`Release`] ordering semantics are now also properly/// synchronized with any non-atomic accesses that happen-after the atomic operation or fence with/// (at least) [`Acquire`] ordering semantics./// ## Memory Ordering/// A fence which has [`SeqCst`] ordering, in addition to having both [`Acquire`] and [`Release`]/// semantics, participates in the global program order of the other [`SeqCst`] operations and/or/// fences./// Accepts [`Acquire`], [`Release`], [`AcqRel`] and [`SeqCst`] orderings./// Panics if `order` is [`Relaxed`]./// use std::sync::atomic::fence;/// use std::sync::atomic::Ordering;/// // A mutual exclusion primitive based on spinlock./// pub struct Mutex {///     flag: AtomicBool,/// impl Mutex {///     pub fn new() -> Mutex {///         Mutex {///             flag: AtomicBool::new(false),///     pub fn lock(&self) {///         // Wait until the old value is `false`.///         while self///             .flag///             .compare_exchange_weak(false, true, Ordering::Relaxed, Ordering::Relaxed)///         {}///         // This fence synchronizes-with store in `unlock`.///         fence(Ordering::Acquire);///     pub fn unlock(&self) {///         self.flag.store(false, Ordering::Release);"compiler_fence"/// A "compiler-only" atomic fence./// Like [`fence`], this function establishes synchronization with other atomic operations and/// fences. However, unlike [`fence`], `compiler_fence` only establishes synchronization with/// operations *in the same thread*. This may at first sound rather useless, since code within a/// thread is typically already totally ordered and does not need any further synchronization./// However, there are cases where code can run on the same thread without being ordered:/// - The most common case is that of a *signal handler*: a signal handler runs in the same thread///   as the code it interrupted, but it is not ordered with respect to that code. `compiler_fence`///   can be used to establish synchronization between a thread and its signal handler, the same way///   that `fence` can be used to establish synchronization across threads./// - Similar situations can arise in embedded programming with interrupt handlers, or in custom///   implementations of preemptive green threads. In general, `compiler_fence` can establish///   synchronization with code that is guaranteed to run on the same hardware CPU./// See [`fence`] for how a fence can be used to achieve synchronization. Note that just like/// [`fence`], synchronization still requires atomic operations to be used in both threads -- it is/// not possible to perform synchronization entirely with fences and non-atomic operations./// `compiler_fence` does not emit any machine code, but restricts the kinds of memory re-ordering/// the compiler is allowed to do. `compiler_fence` corresponds to [`atomic_signal_fence`] in C and/// C++./// [`atomic_signal_fence`]: https://en.cppreference.com/w/cpp/atomic/atomic_signal_fence/// Without the two `compiler_fence` calls, the read of `IMPORTANT_VARIABLE` in `signal_handler`/// is *undefined behavior* due to a data race, despite everything happening in a single thread./// This is because the signal handler is considered to run concurrently with its associated/// thread, and explicit synchronization is required to pass data between a thread and its/// signal handler. The code below uses two `compiler_fence` calls to establish the usual/// release-acquire synchronization pattern (see [`fence`] for an image)./// use std::sync::atomic::compiler_fence;/// static mut IMPORTANT_VARIABLE: usize = 0;/// static IS_READY: AtomicBool = AtomicBool::new(false);///     unsafe { IMPORTANT_VARIABLE = 42 };///     // Marks earlier writes as being released with future relaxed stores.///     compiler_fence(Ordering::Release);///     IS_READY.store(true, Ordering::Relaxed);/// fn signal_handler() {///     if IS_READY.load(Ordering::Relaxed) {///         // Acquires writes that were released with relaxed stores that we read from.///         compiler_fence(Ordering::Acquire);///         assert_eq!(unsafe { IMPORTANT_VARIABLE }, 42);spin_loop_hint/// Signals the processor that it is inside a busy-wait spin-loop ("spin lock")./// This function is deprecated in favor of [`hint::spin_loop`]./// [`hint::spin_loop`]: crate::hint::spin_loop//! Atomic types//! threads, and are the building blocks of other concurrent//! This module defines atomic versions of a select number of primitive//! types, including [`AtomicBool`], [`AtomicIsize`], [`AtomicUsize`],//! [`AtomicI8`], [`AtomicU16`], etc.//! Atomic variables are safe to share between threads (they implement [`Sync`])//! but they do not themselves provide the mechanism for sharing and follow the//! [threading model](../../../std/thread/index.html#the-threading-model) of Rust.//! The most common way to share an atomic variable is to put it into an [`Arc`][arc] (an//! [arc]: ../../../std/sync/struct.Arc.html//! Atomic types may be stored in static variables, initialized using//! the constant initializers like [`AtomicBool::new`]. Atomic statics//! are often used for lazy global initialization.//! ## Memory model for atomic accesses//! Rust atomics currently follow the same rules as [C++20 atomics][cpp], specifically the rules//! from the [`intro.races`][cpp-intro.races] section, without the "consume" memory ordering. Since//! C++ uses an object-based memory model whereas Rust is access-based, a bit of translation work//! has to be done to apply the C++ rules to Rust: whenever C++ talks about "the value of an//! object", we understand that to mean the resulting bytes obtained when doing a read. When the C++//! standard talks about "the value of an atomic object", this refers to the result of doing an//! atomic load (via the operations provided in this module). A "modification of an atomic object"//! refers to an atomic store.//! The end result is *almost* equivalent to saying that creating a *shared reference* to one of the//! Rust atomic types corresponds to creating an `atomic_ref` in C++, with the `atomic_ref` being//! destroyed when the lifetime of the shared reference ends. The main difference is that Rust//! permits concurrent atomic and non-atomic reads to the same memory as those cause no issue in the//! C++ memory model, they are just forbidden in C++ because memory is partitioned into "atomic//! objects" and "non-atomic objects" (with `atomic_ref` temporarily converting a non-atomic object//! into an atomic object).//! The most important aspect of this model is that *data races* are undefined behavior. A data race//! is defined as conflicting non-synchronized accesses where at least one of the accesses is//! non-atomic. Here, accesses are *conflicting* if they affect overlapping regions of memory and at//! least one of them is a write. (A `compare_exchange` or `compare_exchange_weak` that does not//! succeed is not considered a write.) They are *non-synchronized* if neither of them//! *happens-before* the other, according to the happens-before order of the memory model.//! The other possible cause of undefined behavior in the memory model are mixed-size accesses: Rust//! inherits the C++ limitation that non-synchronized conflicting atomic accesses may not partially//! overlap. In other words, every pair of non-synchronized atomic accesses must be either disjoint,//! access the exact same memory (including using the same access size), or both be reads.//! Each atomic access takes an [`Ordering`] which defines how the operation interacts with the//! happens-before order. These orderings behave the same as the corresponding [C++20 atomic//! orderings][cpp_memory_order]. For more information, see the [nomicon].//! [cpp]: https://en.cppreference.com/w/cpp/atomic//! [cpp-intro.races]: https://timsong-cpp.github.io/cppwp/n4868/intro.multithread#intro.races//! [cpp_memory_order]: https://en.cppreference.com/w/cpp/atomic/memory_order//! [nomicon]: ../../../nomicon/atomics.html//! ```rust,no_run undefined_behavior//! use std::sync::atomic::{AtomicU16, AtomicU8, Ordering};//! use std::mem::transmute;//! let atomic = AtomicU16::new(0);//!     // This is UB: conflicting non-synchronized accesses, at least one of which is non-atomic.//!     s.spawn(|| atomic.store(1, Ordering::Relaxed)); // atomic store//!     s.spawn(|| unsafe { atomic.as_ptr().write(2) }); // non-atomic write//!     // This is fine: the accesses do not conflict (as none of them performs any modification).//!     // In C++ this would be disallowed since creating an `atomic_ref` precludes//!     // further non-atomic accesses, but Rust does not have that limitation.//!     s.spawn(|| atomic.load(Ordering::Relaxed)); // atomic load//!     s.spawn(|| unsafe { atomic.as_ptr().read() }); // non-atomic read//!     // This is fine: `join` synchronizes the code in a way such that the atomic//!     // store happens-before the non-atomic write.//!     let handle = s.spawn(|| atomic.store(1, Ordering::Relaxed)); // atomic store//!     handle.join().expect("thread won't panic"); // synchronize//!     // This is UB: non-synchronized conflicting differently-sized atomic accesses.//!     s.spawn(|| atomic.store(1, Ordering::Relaxed));//!     s.spawn(|| unsafe {//!         let differently_sized = transmute::<&AtomicU16, &AtomicU8>(&atomic);//!         differently_sized.store(2, Ordering::Relaxed);//!     // This is fine: `join` synchronizes the code in a way such that//!     // the 1-byte store happens-before the 2-byte store.//!     let handle = s.spawn(|| atomic.store(1, Ordering::Relaxed));//!     handle.join().expect("thread won't panic");//! All atomic types in this module are guaranteed to be [lock-free] if they're//! available. This means they don't internally acquire a global mutex. Atomic//! types and operations are not guaranteed to be wait-free. This means that//! operations like `fetch_or` may be implemented with a compare-and-swap loop.//! Atomic operations may be implemented at the instruction layer with//! larger-size atomics. For example some platforms use 4-byte atomic//! instructions to implement `AtomicI8`. Note that this emulation should not//! have an impact on correctness of code, it's just something to be aware of.//! The atomic types in this module might not be available on all platforms. The//! atomic types here are all widely available, however, and can generally be//! relied upon existing. Some notable exceptions are://! * PowerPC and MIPS platforms with 32-bit pointers do not have `AtomicU64` or//!   `AtomicI64` types.//! * Legacy ARM platforms like ARMv4T and ARMv5TE have very limited hardware//!   support for atomics. The bare-metal targets disable this module//!   entirely, but the Linux targets [use the kernel] to assist (which comes//!   with a performance penalty). It's not until ARMv6K onwards that ARM CPUs//!   have support for load/store and Compare and Swap (CAS) atomics in hardware.//! * ARMv6-M and ARMv8-M baseline targets (`thumbv6m-*` and//!   `thumbv8m.base-*`) only provide `load` and `store` operations, and do//!   not support Compare and Swap (CAS) operations, such as `swap`,//!   `fetch_add`, etc. Full CAS support is available on ARMv7-M and ARMv8-M//!   Mainline (`thumbv7m-*`, `thumbv7em*` and `thumbv8m.main-*`).//! [use the kernel]: https://www.kernel.org/doc/Documentation/arm/kernel_user_helpers.txt//! Note that future platforms may be added that also do not have support for//! some atomic operations. Maximally portable code will want to be careful//! about which atomic types are used. `AtomicUsize` and `AtomicIsize` are//! generally the most portable, but even then they're not available everywhere.//! For reference, the `std` library requires `AtomicBool`s and pointer-sized atomics, although//! `core` does not.//! The `#[cfg(target_has_atomic)]` attribute can be used to conditionally//! compile based on the target's supported bit widths. It is a key-value//! option set for each supported size, with values "8", "16", "32", "64",//! "128", and "ptr" for pointer-sized atomics.//! [lock-free]: https://en.wikipedia.org/wiki/Non-blocking_algorithm//! # Atomic accesses to read-only memory//! In general, *all* atomic accesses on read-only memory are undefined behavior. For instance, attempting//! to do a `compare_exchange` that will definitely fail (making it conceptually a read-only//! operation) can still cause a segmentation fault if the underlying memory page is mapped read-only. Since//! atomic `load`s might be implemented using compare-exchange operations, even a `load` can fault//! on read-only memory.//! For the purpose of this section, "read-only memory" is defined as memory that is read-only in//! the underlying target, i.e., the pages are mapped with a read-only flag and any attempt to write//! will cause a page fault. In particular, an `&u128` reference that points to memory that is//! read-write mapped is *not* considered to point to "read-only memory". In Rust, almost all memory//! is read-write; the only exceptions are memory created by `const` items or `static` items without//! interior mutability, and memory that was specifically marked as read-only by the operating//! system via platform-specific APIs.//! As an exception from the general rule stated above, "sufficiently small" atomic loads with//! `Ordering::Relaxed` are implemented in a way that works on read-only memory, and are hence not//! undefined behavior. The exact size limit for what makes a load "sufficiently small" varies//! depending on the target://! | `target_arch` | Size limit |//! |---------------|---------|//! | `x86`, `arm`, `loongarch32`, `mips`, `mips32r6`, `powerpc`, `riscv32`, `sparc`, `hexagon` | 4 bytes |//! | `x86_64`, `aarch64`, `loongarch64`, `mips64`, `mips64r6`, `powerpc64`, `riscv64`, `sparc64`, `s390x` | 8 bytes |//! Atomics loads that are larger than this limit as well as atomic loads with ordering other//! than `Relaxed`, as well as *all* atomic loads on targets not listed in the table, might still be//! read-only under certain conditions, but that is not a stable guarantee and should not be relied//! upon.//! If you need to do an acquire load on read-only memory, you can do a relaxed load followed by an//! acquire fence instead.//! A simple spinlock://! ```ignore-wasm//! use std::{hint, thread};//!     let spinlock = Arc::new(AtomicUsize::new(1));//!     let spinlock_clone = Arc::clone(&spinlock);//!     let thread = thread::spawn(move || {//!         spinlock_clone.store(0, Ordering::Release);//!     // Wait for the other thread to release the lock//!     while spinlock.load(Ordering::Acquire) != 0 {//!         hint::spin_loop();//!     if let Err(panic) = thread.join() {//!         println!("Thread had an error: {panic:?}");//! Keep a global count of live threads://! static GLOBAL_THREAD_COUNT: AtomicUsize = AtomicUsize::new(0);//! // Note that Relaxed ordering doesn't synchronize anything//! // except the global thread counter itself.//! let old_thread_count = GLOBAL_THREAD_COUNT.fetch_add(1, Ordering::Relaxed);//! // Note that this number may not be true at the moment of printing//! // because some other thread may have changed static value already.//! println!("live threads: {}", old_thread_count + 1);// Clippy complains about the pattern of "safe function calling unsafe function taking pointers".// This happens with AtomicPtr intrinsics but is fine, as the pointers clippy is concerned about// are just normal values that get loaded/stored, but not dereferenced./// `Exclusive` provides _mutable_ access, also referred to as _exclusive_/// access to the underlying value. However, it only permits _immutable_, or _shared_/// access to the underlying value when that value is [`Sync`]./// While this may seem not very useful, it allows `Exclusive` to _unconditionally_/// implement `Sync`. Indeed, the safety requirements of `Sync` state that for `Exclusive`/// to be `Sync`, it must be sound to _share_ across threads, that is, it must be sound/// for `&Exclusive` to cross thread boundaries. By design, a `&Exclusive<T>` for non-`Sync` T/// has no API whatsoever, making it useless, thus harmless, thus memory safe./// Certain constructs like [`Future`]s can only be used with _exclusive_ access,/// and are often `Send` but not `Sync`, so `Exclusive` can be used as hint to the/// Rust compiler that something is `Sync` in practice./// Using a non-`Sync` future prevents the wrapping struct from being `Sync`:/// async fn other() {}/// fn assert_sync<T: Sync>(t: T) {}/// struct State<F> {///     future: F/// assert_sync(State {///     future: async {///         let cell = Cell::new(1);///         let cell_ref = &cell;///         other().await;///         let value = cell_ref.get();/// `Exclusive` ensures the struct is `Sync` without stripping the future of its/// functionality:/// #![feature(exclusive_wrapper)]/// use core::sync::Exclusive;///     future: Exclusive<F>///     future: Exclusive::new(async {/// ## Parallels with a mutex/// In some sense, `Exclusive` can be thought of as a _compile-time_ version of/// a mutex, as the borrow-checker guarantees that only one `&mut` can exist/// for any value. This is a parallel with the fact that/// `&` and `&mut` references together can be thought of as a _compile-time_/// version of a read-write lock.// `Exclusive` can't have derived `PartialOrd`, `Clone`, etc. impls as they would// use `&` access to the inner value, violating the `Sync` impl's safety// requirements.// See `Exclusive`'s docs for justification./// Wrap a value in an `Exclusive`/// Unwrap the value contained in the `Exclusive`/// Gets exclusive access to the underlying value./// Gets pinned exclusive access to the underlying value./// `Exclusive` is considered to _structurally pin_ the underlying/// value, which means _unpinned_ `Exclusive`s can produce _unpinned_/// access to the underlying value, but _pinned_ `Exclusive`s only/// produce _pinned_ access to the underlying value./// Build a _mutable_ reference to an `Exclusive<T>` from/// a _mutable_ reference to a `T`. This allows you to skip/// building an `Exclusive` with [`Exclusive::new`].from_pin_mut/// Build a _pinned mutable_ reference to an `Exclusive<T>` from/// a _pinned mutable_ reference to a `T`. This allows you to skip// also #98407//! Defines [`Exclusive`].ContextBuilder"this `Poll` may be a `Pending` variant, which should be handled""Poll""Ready"/// Represents that a value is immediately ready."Pending"/// Represents that a value is not ready yet./// When a function returns `Pending`, the function *must* also/// ensure that the current task is scheduled to be awoken when/// progress can be made./// Indicates whether a value is available or if the current task has been/// scheduled to receive a wakeup instead./// This is returned by [`Future::poll`](core::future::Future::poll)./// Maps a `Poll<T>` to `Poll<U>` by applying a function to a contained value./// Converts a <code>Poll<[String]></code> into a <code>Poll<[usize]></code>, consuming/// the original:/// # use core::task::Poll;/// let poll_some_string = Poll::Ready(String::from("Hello, World!"));/// // `Poll::map` takes self *by value*, consuming `poll_some_string`/// let poll_some_len = poll_some_string.map(|s| s.len());/// assert_eq!(poll_some_len, Poll::Ready(13));/// Returns `true` if the poll is a [`Poll::Ready`] value./// let x: Poll<u32> = Poll::Ready(2);/// assert_eq!(x.is_ready(), true);/// let x: Poll<u32> = Poll::Pending;/// assert_eq!(x.is_ready(), false);/// Returns `true` if the poll is a [`Pending`] value./// [`Pending`]: Poll::Pending/// assert_eq!(x.is_pending(), false);/// assert_eq!(x.is_pending(), true);/// Maps a `Poll<Result<T, E>>` to `Poll<Result<U, E>>` by applying a/// function to a contained `Poll::Ready(Ok)` value, leaving all other/// variants untouched./// let res: Poll<Result<u8, _>> = Poll::Ready("12".parse());/// let squared = res.map_ok(|n| n * n);/// assert_eq!(squared, Poll::Ready(Ok(144)));/// Maps a `Poll::Ready<Result<T, E>>` to `Poll::Ready<Result<T, U>>` by/// applying a function to a contained `Poll::Ready(Err)` value, leaving all other/// let res: Poll<Result<u8, _>> = Poll::Ready("oops".parse());/// let res = res.map_err(|_| 0_u8);/// assert_eq!(res, Poll::Ready(Err(0)));/// Maps a `Poll<Option<Result<T, E>>>` to `Poll<Option<Result<U, E>>>` by/// applying a function to a contained `Poll::Ready(Some(Ok))` value,/// leaving all other variants untouched./// let res: Poll<Option<Result<u8, _>>> = Poll::Ready(Some("12".parse()));/// assert_eq!(squared, Poll::Ready(Some(Ok(144))));/// Maps a `Poll::Ready<Option<Result<T, E>>>` to/// `Poll::Ready<Option<Result<T, F>>>` by applying a function to a/// contained `Poll::Ready(Some(Err))` value, leaving all other variants/// untouched./// let res: Poll<Option<Result<u8, _>>> = Poll::Ready(Some("oops".parse()));/// assert_eq!(res, Poll::Ready(Some(Err(0))));/// Moves the value into a [`Poll::Ready`] to make a `Poll<T>`./// assert_eq!(Poll::from(true), Poll::Ready(true));/// Extracts the successful type of a [`Poll<T>`]./// This macro bakes in propagation of [`Pending`] signals by returning early./// [`Poll<T>`]: crate::task::Poll/// [`Pending`]: crate::task::Poll::Pending/// use std::future::{self, Future};/// pub fn do_poll(cx: &mut Context<'_>) -> Poll<()> {///     # let _ = num;/// # use std::future::{self, Future};/// # pub fn do_poll(cx: &mut Context<'_>) -> Poll<()> {///     # let _ = num; // to silence unused warning/// A data pointer, which can be used to store arbitrary data as required/// by the executor. This could be e.g. a type-erased pointer to an `Arc`/// that is associated with the task./// The value of this field gets passed to all functions that are part of/// the vtable as the first parameter./// Virtual function pointer table that customizes the behavior of this waker./// A `RawWaker` allows the implementor of a task executor to create a [`Waker`]/// or a [`LocalWaker`] which provides customized wakeup behavior./// It consists of a data pointer and a [virtual function pointer table (vtable)][vtable]/// that customizes the behavior of the `RawWaker`./// `RawWaker`s are unsafe to use./// Implementing the [`Wake`] trait is a safe alternative that requires memory allocation./// [vtable]: https://en.wikipedia.org/wiki/Virtual_method_table/// [`Wake`]: ../../alloc/task/trait.Wake.html/// Creates a new `RawWaker` from the provided `data` pointer and `vtable`./// The `data` pointer can be used to store arbitrary data as required/// The value of this pointer will get passed to all functions that are part/// of the `vtable` as the first parameter./// It is important to consider that the `data` pointer must point to a/// thread safe type such as an `Arc<T: Send + Sync>`/// when used to construct a [`Waker`]. This restriction is lifted when/// constructing a [`LocalWaker`], which allows using types that do not implement/// <code>[Send] + [Sync]</code> like `Rc<T>`./// The `vtable` customizes the behavior of a `Waker` which gets created/// from a `RawWaker`. For each operation on the `Waker`, the associated/// function in the `vtable` of the underlying `RawWaker` will be called./// This function will be called when the [`RawWaker`] gets cloned, e.g. when/// the [`Waker`] in which the [`RawWaker`] is stored gets cloned./// The implementation of this function must retain all resources that are/// required for this additional instance of a [`RawWaker`] and associated/// task. Calling `wake` on the resulting [`RawWaker`] should result in a wakeup/// of the same task that would have been awoken by the original [`RawWaker`]./// This function will be called when `wake` is called on the [`Waker`]./// It must wake up the task associated with this [`RawWaker`]./// The implementation of this function must make sure to release any/// resources that are associated with this instance of a [`RawWaker`] and/// associated task./// This function will be called when `wake_by_ref` is called on the [`Waker`]./// This function is similar to `wake`, but must not consume the provided data/// This function will be called when a [`Waker`] gets dropped./// A virtual function pointer table (vtable) that specifies the behavior/// of a [`RawWaker`]./// The pointer passed to all functions inside the vtable is the `data` pointer/// from the enclosing [`RawWaker`] object./// The functions inside this struct are only intended to be called on the `data`/// pointer of a properly constructed [`RawWaker`] object from inside the/// [`RawWaker`] implementation. Calling one of the contained functions using/// any other `data` pointer will cause undefined behavior./// Note that while this type implements `PartialEq`, comparing function pointers, and hence/// comparing structs like this that contain function pointers, is unreliable: pointers to the same/// function can compare inequal (because functions are duplicated in multiple codegen units), and/// pointers to *different* functions can compare equal (since identical functions can be/// deduplicated within a codegen unit)./// # Thread safety/// If the [`RawWaker`] will be used to construct a [`Waker`] then/// these functions must all be thread-safe (even though [`RawWaker`] is/// <code>\![Send] + \![Sync]</code>). This is because [`Waker`] is <code>[Send] + [Sync]</code>,/// and it may be moved to arbitrary threads or invoked by `&` reference. For example,/// this means that if the `clone` and `drop` functions manage a reference count,/// they must do so atomically./// However, if the [`RawWaker`] will be used to construct a [`LocalWaker`] instead, then/// these functions don't need to be thread safe. This means that <code>\![Send] + \![Sync]</code>///  data can be stored in the data pointer, and reference counting does not need any atomic/// synchronization. This is because [`LocalWaker`] is not thread safe itself, so it cannot/// be sent across threads./// Creates a new `RawWakerVTable` from the provided `clone`, `wake`,/// `wake_by_ref`, and `drop` functions./// data can be stored in the data pointer, and reference counting does not need any atomic/// # `clone`/// the [`Waker`]/[`LocalWaker`] in which the [`RawWaker`] is stored gets cloned./// # `wake`/// # `wake_by_ref`/// # `drop`/// This function will be called when a [`Waker`]/[`LocalWaker`] getsExtData"Context"local_waker// Ensure we future-proof against variance changes by forcing// the lifetime to be invariant (argument-position lifetimes// are contravariant while return-position lifetimes are// covariant).// Ensure `Context` is `!Send` and `!Sync` in order to allow// for future `!Send` and / or `!Sync` fields./// The context of an asynchronous task./// Currently, `Context` only serves to provide access to a [`&Waker`](Waker)/// which can be used to wake the current task.from_waker/// Creates a new `Context` from a [`&Waker`](Waker)./// Returns a reference to the [`Waker`] for the current task./// Returns a reference to the [`LocalWaker`] for the current task./// Returns a reference to the extension data for the current task./// A Builder used to construct a `Context` instance/// with support for `LocalWaker`./// use std::task::{ContextBuilder, LocalWaker, Waker, Poll};/// let local_waker = LocalWaker::noop();/// let waker = Waker::noop();/// let mut cx = ContextBuilder::from_waker(&waker)///     .local_waker(&local_waker)/// let mut future = std::pin::pin!(async { 20 });/// let poll = future.as_mut().poll(&mut cx);/// assert_eq!(poll, Poll::Ready(20));/// Creates a ContextBuilder from a Waker./// Creates a ContextBuilder from an existing Context./// Sets the value for the waker on `Context`./// Sets the value for the local waker on `Context`./// Sets the value for the extension data on `Context`./// Builds the `Context`."Waker"/// A `Waker` is a handle for waking up a task by notifying its executor that it/// is ready to be run./// This handle encapsulates a [`RawWaker`] instance, which defines the/// executor-specific wakeup behavior./// The typical life of a `Waker` is that it is constructed by an executor, wrapped in a/// [`Context`], then passed to [`Future::poll()`]. Then, if the future chooses to return/// [`Poll::Pending`], it must also store the waker somehow and call [`Waker::wake()`] when/// the future should be polled again./// Implements [`Clone`], [`Send`], and [`Sync`]; therefore, a waker may be invoked/// from any thread, including ones not in any way managed by the executor. For example,/// this might be done to wake a future when a blocking function call completes on another/// Note that it is preferable to use `waker.clone_from(&new_waker)` instead/// of `*waker = new_waker.clone()`, as the former will avoid cloning the waker/// unnecessarily if the two wakers [wake the same task](Self::will_wake)./// Constructing a `Waker` from a [`RawWaker`] is unsafe./// [`Future::poll()`]: core::future::Future::poll/// [`Poll::Pending`]: core::task::Poll::Pending/// Wakes up the task associated with this `Waker`./// As long as the executor keeps running and the task is not finished, it is/// guaranteed that each invocation of [`wake()`](Self::wake) (or/// [`wake_by_ref()`](Self::wake_by_ref)) will be followed by at least one/// [`poll()`] of the task to which this `Waker` belongs. This makes/// it possible to temporarily yield to other tasks while running potentially/// unbounded processing loops./// Note that the above implies that multiple wake-ups may be coalesced into a/// single [`poll()`] invocation by the runtime./// Also note that yielding to competing tasks is not guaranteed: it is the/// executor’s choice which task to run and the executor may choose to run the/// current task again./// [`poll()`]: crate::future::Future::poll/// Wakes up the task associated with this `Waker` without consuming the `Waker`./// This is similar to [`wake()`](Self::wake), but may be slightly less efficient in/// the case where an owned `Waker` is available. This method should be preferred to/// calling `waker.clone().wake()`./// Returns `true` if this `Waker` and another `Waker` would awake the same task./// This function works on a best-effort basis, and may return false even/// when the `Waker`s would awaken the same task. However, if this function/// returns `true`, it is guaranteed that the `Waker`s will awaken the same task./// This function is primarily used for optimization purposes — for example,/// this type's [`clone_from`](Self::clone_from) implementation uses it to/// avoid cloning the waker when they would wake the same task anyway./// Creates a new `Waker` from the provided `data` pointer and `vtable`./// thread safe type such as an `Arc`./// The `vtable` customizes the behavior of a `Waker`. For each operation/// on the `Waker`, the associated function in the `vtable` will be called./// The behavior of the returned `Waker` is undefined if the contract defined/// in [`RawWakerVTable`]'s documentation is not upheld./// (Authors wishing to avoid unsafe code may implement the [`Wake`] trait instead, at the/// cost of a required heap allocation.)/// Creates a new `Waker` from [`RawWaker`]./// in [`RawWaker`]'s and [`RawWakerVTable`]'s documentation is not upheld./// Returns a reference to a `Waker` that does nothing when used.// Note!  Much of the documentation for this method is duplicated// in the docs for `LocalWaker::noop`.// If you edit it, consider editing the other copy too./// This is mostly useful for writing tests that need a [`Context`] to poll/// some futures, but are not expecting those futures to wake the waker or/// do not need to do anything specific if it happens./// More generally, using `Waker::noop()` to poll a future/// means discarding the notification of when the future should be polled again./// So it should only be used when such a notification will not be needed to make progress./// If an owned `Waker` is needed, `clone()` this one./// use std::task;/// let mut cx = task::Context::from_waker(task::Waker::noop());/// let mut future = Box::pin(async { 10 });/// assert_eq!(future.as_mut().poll(&mut cx), task::Poll::Ready(10));/// Gets the `data` pointer used to create this `Waker`./// Gets the `vtable` pointer used to create this `Waker`.from_fn_ptr/// Constructs a `Waker` from a function pointer./// Assigns a clone of `source` to `self`, unless [`self.will_wake(source)`][Waker::will_wake] anyway./// as it avoids cloning the waker if `self` is already the same waker./// use std::task::{Context, Poll, Waker};/// struct Waiter {///     shared: Arc<Mutex<Shared>>,/// struct Shared {///     waker: Waker,/// impl Future for Waiter {///         let mut shared = self.shared.lock().unwrap();///         // update the waker///         shared.waker.clone_from(cx.waker());///         // readiness logic .../// #       Poll::Ready(())/// A `LocalWaker` is analogous to a [`Waker`], but it does not implement [`Send`] or [`Sync`]./// Local wakers can be requested from a `Context` with the [`local_waker`] method./// The typical life of a `LocalWaker` is that it is constructed by an executor, wrapped in a/// [`Context`] using [`ContextBuilder`], then passed to [`Future::poll()`]. Then, if the future chooses to return/// [`Poll::Pending`], it must also store the waker somehow and call [`LocalWaker::wake()`] when/// Implements [`Clone`], but neither [`Send`] nor [`Sync`]; therefore, a local waker may/// not be moved to other threads. In general, when deciding to use wakers or local wakers,/// local wakers are preferable unless the waker needs to be sent across threads. This is because/// wakers can incur in additional cost related to memory synchronization./// Note that it is preferable to use `local_waker.clone_from(&new_waker)` instead/// of `*local_waker = new_waker.clone()`, as the former will avoid cloning the waker/// Usage of a local waker to implement a future analogous to `std::thread::yield_now()`./// use std::future::{Future, poll_fn};/// // a future that returns pending once./// fn yield_now() -> impl Future<Output=()> + Unpin {///     let mut yielded = false;///     poll_fn(move |cx| {///         if !yielded {///             yielded = true;///             cx.local_waker().wake_by_ref();///             return Poll::Pending;///         return Poll::Ready(())/// # async fn __() {/// yield_now().await;/// [`local_waker`]: core::task::Context::local_waker/// Wakes up the task associated with this `LocalWaker`./// [`poll()`] of the task to which this `LocalWaker` belongs. This makes/// Wakes up the task associated with this `LocalWaker` without consuming the `LocalWaker`./// Returns `true` if this `LocalWaker` and another `LocalWaker` would awake the same task./// Creates a new `LocalWaker` from the provided `data` pointer and `vtable`./// The `vtable` customizes the behavior of a `LocalWaker`. For each/// operation on the `LocalWaker`, the associated function in the `vtable`/// will be called./// Creates a new `LocalWaker` from [`RawWaker`]./// The behavior of the returned `LocalWaker` is undefined if the contract defined/// Therefore this method is unsafe./// Returns a reference to a `LocalWaker` that does nothing when used.// in the docs for `Waker::noop`./// More generally, using `LocalWaker::noop()` to poll a future/// means discarding the notification of when the future should be polled again,/// If an owned `LocalWaker` is needed, `clone()` this one./// let mut cx = ContextBuilder::from_waker(Waker::noop())///     .local_waker(LocalWaker::noop())/// assert_eq!(future.as_mut().poll(&mut cx), Poll::Ready(10));/// Gets the `data` pointer used to create this `LocalWaker`./// Gets the `vtable` pointer used to create this `LocalWaker`./// Constructs a `LocalWaker` from a function pointer.MINS_PER_HOUR"Duration"/// A `Duration` type to represent a span of time, typically used for system/// timeouts./// Each `Duration` is composed of a whole number of seconds and a fractional part/// represented in nanoseconds. If the underlying system does not support/// nanosecond-level precision, APIs binding a system timeout will typically round up/// the number of nanoseconds./// [`Duration`]s implement many common traits, including [`Add`], [`Sub`], and other/// [`ops`] traits. It implements [`Default`] by returning a zero-length `Duration`./// [`ops`]: crate::ops/// let five_seconds = Duration::new(5, 0);/// let five_seconds_and_five_nanos = five_seconds + Duration::new(0, 5);/// assert_eq!(five_seconds_and_five_nanos.as_secs(), 5);/// assert_eq!(five_seconds_and_five_nanos.subsec_nanos(), 5);/// let ten_millis = Duration::from_millis(10);/// # Formatting `Duration` values/// `Duration` intentionally does not have a `Display` impl, as there are a/// variety of ways to format spans of time for human readability. `Duration`/// provides a `Debug` impl that shows the full precision of the value./// The `Debug` output uses the non-ASCII "µs" suffix for microseconds. If your/// program output may appear in contexts that cannot rely on full Unicode/// compatibility, you may wish to format `Duration` objects yourself or use a/// crate to do so./// The duration of one second./// #![feature(duration_constants)]/// assert_eq!(Duration::SECOND, Duration::from_secs(1));/// The duration of one millisecond./// assert_eq!(Duration::MILLISECOND, Duration::from_millis(1));/// The duration of one microsecond./// assert_eq!(Duration::MICROSECOND, Duration::from_micros(1));/// The duration of one nanosecond./// assert_eq!(Duration::NANOSECOND, Duration::from_nanos(1));/// A duration of zero time./// let duration = Duration::ZERO;/// assert!(duration.is_zero());/// assert_eq!(duration.as_nanos(), 0);/// The maximum duration./// May vary by platform as necessary. Must be able to contain the difference between/// two instances of [`Instant`] or two instances of [`SystemTime`]./// This constraint gives it a value of about 584,942,417,355 years in practice,/// which is currently used on all platforms./// assert_eq!(Duration::MAX, Duration::new(u64::MAX, 1_000_000_000 - 1));/// [`Instant`]: ../../std/time/struct.Instant.html/// [`SystemTime`]: ../../std/time/struct.SystemTime.html/// Creates a new `Duration` from the specified number of whole seconds and/// additional nanoseconds./// If the number of nanoseconds is greater than 1 billion (the number of/// nanoseconds in a second), then it will carry over into the seconds provided./// This constructor will panic if the carry from the nanoseconds overflows/// the seconds counter./// Creates a new `Duration` from the specified number of whole seconds./// let duration = Duration::from_secs(5);/// assert_eq!(5, duration.as_secs());/// assert_eq!(0, duration.subsec_nanos());/// Creates a new `Duration` from the specified number of milliseconds./// let duration = Duration::from_millis(2_569);/// assert_eq!(2, duration.as_secs());/// assert_eq!(569_000_000, duration.subsec_nanos());from_micros/// Creates a new `Duration` from the specified number of microseconds./// let duration = Duration::from_micros(1_000_002);/// assert_eq!(1, duration.as_secs());/// assert_eq!(2_000, duration.subsec_nanos());from_nanos/// Creates a new `Duration` from the specified number of nanoseconds./// Note: Using this on the return value of `as_nanos()` might cause unexpected behavior:/// `as_nanos()` returns a u128, and can return values that do not fit in u64, e.g. 585 years./// Instead, consider using the pattern `Duration::new(d.as_secs(), d.subsec_nanos())`/// if you cannot copy/clone the Duration directly./// let duration = Duration::from_nanos(1_000_000_123);/// assert_eq!(123, duration.subsec_nanos());from_nanos_u128/// Panics if the given number of nanoseconds is greater than [`Duration::MAX`]./// let nanos = 10_u128.pow(24) + 321;/// let duration = Duration::from_nanos_u128(nanos);/// assert_eq!(10_u64.pow(15), duration.as_secs());/// assert_eq!(321, duration.subsec_nanos());// for `u64::try_from`from_weeks/// Creates a new `Duration` from the specified number of weeks./// Panics if the given number of weeks overflows the `Duration` size./// #![feature(duration_constructors)]/// let duration = Duration::from_weeks(4);/// assert_eq!(4 * 7 * 24 * 60 * 60, duration.as_secs());/// Creates a new `Duration` from the specified number of days./// Panics if the given number of days overflows the `Duration` size./// let duration = Duration::from_days(7);/// assert_eq!(7 * 24 * 60 * 60, duration.as_secs());/// Creates a new `Duration` from the specified number of hours./// Panics if the given number of hours overflows the `Duration` size./// let duration = Duration::from_hours(6);/// assert_eq!(6 * 60 * 60, duration.as_secs());from_mins/// Creates a new `Duration` from the specified number of minutes./// Panics if the given number of minutes overflows the `Duration` size./// let duration = Duration::from_mins(10);/// assert_eq!(10 * 60, duration.as_secs());/// Returns true if this `Duration` spans no time./// assert!(Duration::ZERO.is_zero());/// assert!(Duration::new(0, 0).is_zero());/// assert!(Duration::from_nanos(0).is_zero());/// assert!(Duration::from_secs(0).is_zero());/// assert!(!Duration::new(1, 1).is_zero());/// assert!(!Duration::from_nanos(1).is_zero());/// assert!(!Duration::from_secs(1).is_zero());/// Returns the number of _whole_ seconds contained by this `Duration`./// The returned value does not include the fractional (nanosecond) part of the/// duration, which can be obtained using [`subsec_nanos`]./// let duration = Duration::new(5, 730_023_852);/// assert_eq!(duration.as_secs(), 5);/// To determine the total number of seconds represented by the `Duration`/// including the fractional part, use [`as_secs_f64`] or [`as_secs_f32`]/// [`as_secs_f64`]: Duration::as_secs_f64/// [`as_secs_f32`]: Duration::as_secs_f32/// [`subsec_nanos`]: Duration::subsec_nanos/// Returns the fractional part of this `Duration`, in whole milliseconds./// This method does **not** return the length of the duration when/// represented by milliseconds. The returned number always represents a/// fractional portion of a second (i.e., it is less than one thousand)./// let duration = Duration::from_millis(5_432);/// assert_eq!(duration.subsec_millis(), 432);/// Returns the fractional part of this `Duration`, in whole microseconds./// represented by microseconds. The returned number always represents a/// fractional portion of a second (i.e., it is less than one million)./// let duration = Duration::from_micros(1_234_567);/// assert_eq!(duration.as_secs(), 1);/// assert_eq!(duration.subsec_micros(), 234_567);/// Returns the fractional part of this `Duration`, in nanoseconds./// represented by nanoseconds. The returned number always represents a/// fractional portion of a second (i.e., it is less than one billion)./// let duration = Duration::from_millis(5_010);/// assert_eq!(duration.subsec_nanos(), 10_000_000);/// Returns the total number of whole milliseconds contained by this `Duration`./// assert_eq!(duration.as_millis(), 5_730);as_micros/// Returns the total number of whole microseconds contained by this `Duration`./// assert_eq!(duration.as_micros(), 5_730_023);as_nanos/// Returns the total number of nanoseconds contained by this `Duration`./// assert_eq!(duration.as_nanos(), 5_730_023_852);/// Computes the absolute difference between `self` and `other`./// assert_eq!(Duration::new(100, 0).abs_diff(Duration::new(80, 0)), Duration::new(20, 0));/// assert_eq!(Duration::new(100, 400_000_000).abs_diff(Duration::new(110, 0)), Duration::new(9, 600_000_000));/// Checked `Duration` addition. Computes `self + other`, returning [`None`]/// assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));/// assert_eq!(Duration::new(1, 0).checked_add(Duration::new(u64::MAX, 0)), None);/// Saturating `Duration` addition. Computes `self + other`, returning [`Duration::MAX`]/// assert_eq!(Duration::new(0, 0).saturating_add(Duration::new(0, 1)), Duration::new(0, 1));/// assert_eq!(Duration::new(1, 0).saturating_add(Duration::new(u64::MAX, 0)), Duration::MAX);/// Checked `Duration` subtraction. Computes `self - other`, returning [`None`]/// if the result would be negative or if overflow occurred./// assert_eq!(Duration::new(0, 1).checked_sub(Duration::new(0, 0)), Some(Duration::new(0, 1)));/// assert_eq!(Duration::new(0, 0).checked_sub(Duration::new(0, 1)), None);/// Saturating `Duration` subtraction. Computes `self - other`, returning [`Duration::ZERO`]/// assert_eq!(Duration::new(0, 1).saturating_sub(Duration::new(0, 0)), Duration::new(0, 1));/// assert_eq!(Duration::new(0, 0).saturating_sub(Duration::new(0, 1)), Duration::ZERO);/// Checked `Duration` multiplication. Computes `self * other`, returning/// [`None`] if overflow occurred./// assert_eq!(Duration::new(0, 500_000_001).checked_mul(2), Some(Duration::new(1, 2)));/// assert_eq!(Duration::new(u64::MAX - 1, 0).checked_mul(2), None);/// Saturating `Duration` multiplication. Computes `self * other`, returning/// [`Duration::MAX`] if overflow occurred./// assert_eq!(Duration::new(0, 500_000_001).saturating_mul(2), Duration::new(1, 2));/// assert_eq!(Duration::new(u64::MAX - 1, 0).saturating_mul(2), Duration::MAX);/// Checked `Duration` division. Computes `self / other`, returning [`None`]/// if `other == 0`./// assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));/// assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));/// assert_eq!(Duration::new(2, 0).checked_div(0), None);/// Returns the number of seconds contained by this `Duration` as `f64`./// The returned value includes the fractional (nanosecond) part of the duration./// let dur = Duration::new(2, 700_000_000);/// assert_eq!(dur.as_secs_f64(), 2.7);/// Returns the number of seconds contained by this `Duration` as `f32`./// assert_eq!(dur.as_secs_f32(), 2.7);as_millis_f64/// Returns the number of milliseconds contained by this `Duration` as `f64`./// #![feature(duration_millis_float)]/// let dur = Duration::new(2, 345_678_000);/// assert_eq!(dur.as_millis_f64(), 2_345.678);as_millis_f32/// Returns the number of milliseconds contained by this `Duration` as `f32`./// assert_eq!(dur.as_millis_f32(), 2_345.678);/// Creates a new `Duration` from the specified number of seconds represented/// as `f64`./// This constructor will panic if `secs` is negative, overflows `Duration` or not finite./// let res = Duration::from_secs_f64(0.0);/// assert_eq!(res, Duration::new(0, 0));/// let res = Duration::from_secs_f64(1e-20);/// let res = Duration::from_secs_f64(4.2e-7);/// assert_eq!(res, Duration::new(0, 420));/// let res = Duration::from_secs_f64(2.7);/// assert_eq!(res, Duration::new(2, 700_000_000));/// let res = Duration::from_secs_f64(3e10);/// assert_eq!(res, Duration::new(30_000_000_000, 0));/// // subnormal float/// let res = Duration::from_secs_f64(f64::from_bits(1));/// // conversion uses rounding/// let res = Duration::from_secs_f64(0.999e-9);/// assert_eq!(res, Duration::new(0, 1));/// as `f32`./// let res = Duration::from_secs_f32(0.0);/// let res = Duration::from_secs_f32(1e-20);/// let res = Duration::from_secs_f32(4.2e-7);/// let res = Duration::from_secs_f32(2.7);/// assert_eq!(res, Duration::new(2, 700_000_048));/// let res = Duration::from_secs_f32(3e10);/// assert_eq!(res, Duration::new(30_000_001_024, 0));/// let res = Duration::from_secs_f32(f32::from_bits(1));/// let res = Duration::from_secs_f32(0.999e-9);/// Multiplies `Duration` by `f64`./// This method will panic if result is negative, overflows `Duration` or not finite./// assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000));/// assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0));/// Multiplies `Duration` by `f32`./// assert_eq!(dur.mul_f32(3.14), Duration::new(8, 478_000_641));/// assert_eq!(dur.mul_f32(3.14e5), Duration::new(847_800, 0));/// Divides `Duration` by `f64`./// assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611));/// assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_599));/// Divides `Duration` by `f32`./// // note that due to rounding errors result is slightly/// // different from 0.859_872_611/// assert_eq!(dur.div_f32(3.14), Duration::new(0, 859_872_580));/// assert_eq!(dur.div_f32(3.14e5), Duration::new(0, 8_599));div_duration_f64/// Divides `Duration` by `Duration` and returns `f64`./// let dur1 = Duration::new(2, 700_000_000);/// let dur2 = Duration::new(5, 400_000_000);/// assert_eq!(dur1.div_duration_f64(dur2), 0.5);div_duration_f32/// Divides `Duration` by `Duration` and returns `f32`./// assert_eq!(dur1.div_duration_f32(dur2), 0.5);sum_durationsTryFromFloatSecsErrorKind/// An error which can be returned when converting a floating-point value of seconds/// into a [`Duration`]./// This error is used as the error type for [`Duration::try_from_secs_f32`] and/// [`Duration::try_from_secs_f64`]./// if let Err(e) = Duration::try_from_secs_f32(-1.0) {///     println!("Failed conversion to Duration: {e}");// Value is negative.OverflowOrNan// Value is either too big to be represented as `Duration` or `NaN`.try_from_secs_f32/// The checked version of [`from_secs_f32`]./// [`from_secs_f32`]: Duration::from_secs_f32/// This constructor will return an `Err` if `secs` is negative, overflows `Duration` or not finite./// let res = Duration::try_from_secs_f32(0.0);/// assert_eq!(res, Ok(Duration::new(0, 0)));/// let res = Duration::try_from_secs_f32(1e-20);/// let res = Duration::try_from_secs_f32(4.2e-7);/// assert_eq!(res, Ok(Duration::new(0, 420)));/// let res = Duration::try_from_secs_f32(2.7);/// assert_eq!(res, Ok(Duration::new(2, 700_000_048)));/// let res = Duration::try_from_secs_f32(3e10);/// assert_eq!(res, Ok(Duration::new(30_000_001_024, 0)));/// // subnormal float:/// let res = Duration::try_from_secs_f32(f32::from_bits(1));/// let res = Duration::try_from_secs_f32(-5.0);/// let res = Duration::try_from_secs_f32(f32::NAN);/// let res = Duration::try_from_secs_f32(2e19);/// // the conversion uses rounding with tie resolution to even/// let res = Duration::try_from_secs_f32(0.999e-9);/// assert_eq!(res, Ok(Duration::new(0, 1)));/// // this float represents exactly 976562.5e-9/// let val = f32::from_bits(0x3A80_0000);/// let res = Duration::try_from_secs_f32(val);/// assert_eq!(res, Ok(Duration::new(0, 976_562)));/// // this float represents exactly 2929687.5e-9/// let val = f32::from_bits(0x3B40_0000);/// assert_eq!(res, Ok(Duration::new(0, 2_929_688)));/// // this float represents exactly 1.000_976_562_5/// let val = f32::from_bits(0x3F802000);/// assert_eq!(res, Ok(Duration::new(1, 976_562)));/// // this float represents exactly 1.002_929_687_5/// let val = f32::from_bits(0x3F806000);/// assert_eq!(res, Ok(Duration::new(1, 2_929_688)));try_from_secs_f64/// The checked version of [`from_secs_f64`]./// [`from_secs_f64`]: Duration::from_secs_f64/// let res = Duration::try_from_secs_f64(0.0);/// let res = Duration::try_from_secs_f64(1e-20);/// let res = Duration::try_from_secs_f64(4.2e-7);/// let res = Duration::try_from_secs_f64(2.7);/// assert_eq!(res, Ok(Duration::new(2, 700_000_000)));/// let res = Duration::try_from_secs_f64(3e10);/// assert_eq!(res, Ok(Duration::new(30_000_000_000, 0)));/// let res = Duration::try_from_secs_f64(f64::from_bits(1));/// let res = Duration::try_from_secs_f64(-5.0);/// let res = Duration::try_from_secs_f64(f64::NAN);/// let res = Duration::try_from_secs_f64(2e19);/// let res = Duration::try_from_secs_f64(0.999e-9);/// let res = Duration::try_from_secs_f64(0.999_999_999_499);/// assert_eq!(res, Ok(Duration::new(0, 999_999_999)));/// let res = Duration::try_from_secs_f64(0.999_999_999_501);/// assert_eq!(res, Ok(Duration::new(1, 0)));/// let res = Duration::try_from_secs_f64(42.999_999_999_499);/// assert_eq!(res, Ok(Duration::new(42, 999_999_999)));/// let res = Duration::try_from_secs_f64(42.999_999_999_501);/// assert_eq!(res, Ok(Duration::new(43, 0)));/// let val = f64::from_bits(0x3F50_0000_0000_0000);/// let res = Duration::try_from_secs_f64(val);/// let val = f64::from_bits(0x3F68_0000_0000_0000);/// let val = f64::from_bits(0x3FF0_0400_0000_0000);/// let val = f64::from_bits(0x3_FF00_C000_0000_000);//! Temporal quantification.//! There are multiple ways to create a new [`Duration`]://! let five_seconds = Duration::from_secs(5);//! assert_eq!(five_seconds, Duration::from_millis(5_000));//! assert_eq!(five_seconds, Duration::from_micros(5_000_000));//! assert_eq!(five_seconds, Duration::from_nanos(5_000_000_000));//! let ten_seconds = Duration::from_secs(10);//! let seven_nanos = Duration::from_nanos(7);//! let total = ten_seconds + seven_nanos;//! assert_eq!(total, Duration::new(10, 7));// Stopping criteria (1-ary tuple)// Running criteria (n-ary tuple, with n >= 2)// "Private" internal implementation// Recursive macro for implementing n-ary tuple functions and operations// Also provides implementations for tuples with lesser arity. For example, tuple_impls!(A B C)// will implement everything for (A, B, C), (A, B) and (A,).// If this is a unary tuple, it adds a doc comment.// Otherwise, it hides the docs entirely.lexical_ord// Constructs an expression that performs a lexical ordering using method `$rel`.// The values are interleaved, so the macro invocation for// `(a1, a2, a3) < (b1, b2, b3)` would be `lexical_ord!(lt, opt_is_lt, a1, b1,// a2, b2, a3, b3)` (and similarly for `lexical_cmp`)// `$chain_rel` is the chaining method from `PartialOrd` to use for all but the// final value, to produce better results for simple primitives.lexical_chain// Same parameter interleaving as `lexical_ord` abovelexical_partial_cmplexical_cmp// See core/src/primitive_docs.rs for documentation./// Checks that the preconditions of an unsafe function are followed./// The check is enabled at runtime if debug assertions are enabled when the/// caller is monomorphized. In const-eval/Miri checks implemented with this/// macro for language UB are always ignored./// This macro should be called as/// `assert_unsafe_precondition!(check_{library,language}_ub, "message", (ident: type = expr, ident: type = expr) => check_expr)`/// where each `expr` will be evaluated and passed in as function argument `ident: type`. Then all/// those arguments are passed to a function with the body `check_expr`./// Pick `check_language_ub` when this is guarding a violation of language UB, i.e., immediate UB/// according to the Rust Abstract Machine. Pick `check_library_ub` when this is guarding a violation/// of a documented library precondition that does not *immediately* lead to language UB./// If `check_library_ub` is used but the check is actually guarding language UB, the check will/// slow down const-eval/Miri and we'll get the panic message instead of the interpreter's nice/// diagnostic, but our ability to detect UB is unchanged./// But if `check_language_ub` is used when the check is actually for library UB, the check is/// omitted in const-eval/Miri and thus UB might occur undetected. Even if we eventually execute/// language UB which relies on the library UB, the backtrace Miri reports may be far removed from/// original cause./// These checks are behind a condition which is evaluated at codegen time, not expansion time like/// [`debug_assert`]. This means that a standard library built with optimizations and debug/// assertions disabled will have these checks optimized out of its monomorphizations, but if a/// caller of the standard library has debug assertions enabled and monomorphizes an expansion of/// this macro, that monomorphization will contain the check./// Since these checks cannot be optimized out in MIR, some care must be taken in both call and/// implementation to mitigate their compile-time overhead. Calls to this macro always expand to/// this structure:/// ```ignore (pseudocode)/// if ::core::intrinsics::check_language_ub() {///     precondition_check(args)/// where `precondition_check` is monomorphic with the attributes `#[rustc_nounwind]`, `#[inline]` and/// `#[rustc_no_mir_inline]`. This combination of attributes ensures that the actual check logic is/// compiled only once and generates a minimal amount of IR because the check cannot be inlined in/// MIR, but *can* be inlined and fully optimized by a codegen backend./// Callers should avoid introducing any other `let` bindings or any code outside this macro in/// order to call it. Since the precompiled standard library is built with full debuginfo and these/// variables cannot be optimized out in MIR, an innocent-looking `let` can produce enough/// debuginfo to have a measurable compile-time impact on debug builds.check_library_ub/// Checking library UB is always enabled when UB-checking is done/// (and we use a reexport so that there is no unnecessary wrapper function).check_language_ub/// Determines whether we should check for language UB./// The intention is to not do that when running in the interpreter, as that one has its own/// language UB checks which generally produce better errors.maybe_is_aligned_and_not_null/// Checks whether `ptr` is properly aligned with respect to the given alignment, and/// if `is_zst == false`, that `ptr` is not null./// In `const` this is approximate and can fail spuriously. It is primarily intended/// for `assert_unsafe_precondition!` with `check_language_ub`, in which case the/// check is anyway not executed in `const`.maybe_is_aligned/// Checks whether `ptr` is properly aligned with respect to the given alignment.is_valid_allocation_sizemaybe_is_nonoverlapping/// Checks whether the regions of memory starting at `src` and `dst` of size/// `count * size` do *not* overlap./// Note that in const-eval this function just returns `true` and therefore must/// only be used with `assert_unsafe_precondition!`, similar to `is_aligned_and_not_null`.//! Provides the [`assert_unsafe_precondition`] macro as well as some utility functions that cover//! common preconditions.case_ignorableCase_Ignorable// for use in alloc, not re-exported in std.casedCasedgrapheme_extendGrapheme_Extendwhite_spaceWhite_Space//! Unicode internals used in liballoc and libstd. Not public API.SINGLETONS0USINGLETONS0LSINGLETONS1USINGLETONS1LNORMAL0NORMAL1// NOTE: The following code was generated by "library/core/src/unicode/printable.py",//       do not edit directly!CANONICALCANONICALIZEDbitset_searchShortOffsetRunHeaderprefix_sumSOROFFSETSskip_search/// - The last element of `short_offset_runs` must be greater than `std::char::MAX`./// - The start indices of all elements in `short_offset_runs` must be less than `OFFSETS`.SHORT_OFFSET_RUNS1519lookup_slow919767BITSET_CHUNKS_MAPBITSET_INDEX_CHUNKSBITSET_CANONICALBITSET_MAPPINGWHITESPACE_MAPINDEX_MASKLOWERCASE_TABLE1462LOWERCASE_TABLE_MULTIUPPERCASE_TABLE1554UPPERCASE_TABLE_MULTI//! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!// Alphabetic      :  1723 bytes, 147369 codepoints in 759 ranges (U+0000AA - U+03347A) using skiplist// Case_Ignorable  :  1063 bytes,   2789 codepoints in 459 ranges (U+0000A8 - U+0E01F0) using skiplist// Cased           :   401 bytes,   4580 codepoints in 156 ranges (U+0000AA - U+01F18A) using skiplist// Grapheme_Extend :   899 bytes,   2232 codepoints in 383 ranges (U+000300 - U+0E01F0) using skiplist// Lowercase       :   943 bytes,   2569 codepoints in 676 ranges (U+0000AA - U+01E944) using bitset// N               :   463 bytes,   1914 codepoints in 145 ranges (U+0000B2 - U+01FBFA) using skiplist// Uppercase       :   799 bytes,   1980 codepoints in 659 ranges (U+0000C0 - U+01F18A) using bitset// White_Space     :   256 bytes,     19 codepoints in   8 ranges (U+000085 - U+003001) using cascading// to_lower        : 11708 bytes// to_upper        : 13656 bytes// Total           : 31911 bytes/// Collapses all unit items from an iterator into one./// let res: Result<()> = data.iter()///     .map(|x| writeln!(stdout(), "{x}"))IsUnitunwrap_binder/// Unwrap an unsafe binder into its underlying type.wrap_binder/// Wrap a type into an unsafe binder.//! Operators used to turn types into unsafe binders and back./// A Unicode code point: from U+0000 to U+10FFFF./// Compares with the `char` type,/// which represents a Unicode scalar value:/// a code point that is not a surrogate (U+D800 to U+DFFF)./// Format the code point as `U+` followed by four to six hexadecimal digits./// Example: `U+1F4A9`/// Unsafely creates a new `CodePoint` without checking the value./// Only use when `value` is known to be less than or equal to 0x10FFFF./// Creates a new `CodePoint` if the value is a valid code point./// Returns `None` if `value` is above 0x10FFFF./// Creates a new `CodePoint` from a `char`./// Since all Unicode scalar values are code points, this always succeeds./// Returns the numeric value of the code point.to_lead_surrogate/// Returns the numeric value of the code point if it is a leading surrogate.to_trail_surrogate/// Returns the numeric value of the code point if it is a trailing surrogate./// Optionally returns a Unicode scalar value for the code point./// Returns `None` if the code point is a surrogate (from U+D800 to U+DFFF).to_char_lossy/// Returns a Unicode scalar value for the code point./// Returns `'\u{FFFD}'` (the replacement character “�”)/// if the code point is a surrogate (from U+D800 to U+DFFF)./// A borrowed slice of well-formed WTF-8 data./// Similar to `&str`, but can additionally contain surrogate code points/// Creates a WTF-8 slice from a UTF-8 `&str` slice./// Creates a WTF-8 slice from a WTF-8 byte slice./// Since the byte slice is not checked for valid WTF-8, this functions isfrom_mut_bytes_unchecked/// Creates a mutable WTF-8 slice from a mutable WTF-8 byte slice./// Returns the length, in WTF-8 bytes.ascii_byte_at/// Returns the code point at `position` if it is in the ASCII range,/// or `b'\xFF'` otherwise./// Panics if `position` is beyond the end of the string.code_points/// Returns an iterator for the string’s code points./// Access raw bytes of WTF-8 data/// Tries to convert the string to UTF-8 and return a `&str` slice./// Returns `None` if the string contains surrogates./// Converts the WTF-8 string to potentially ill-formed UTF-16/// and return an iterator of 16-bit code units./// This is lossless:/// calling `Wtf8Buf::from_ill_formed_utf16` on the resulting code units/// would always return the original WTF-8 string.next_surrogatefinal_lead_surrogateinitial_trail_surrogate/// Returns a slice of the given string for the byte range \[`begin`..`end`)./// Panics when `begin` and `end` do not point to code point boundaries,/// or point beyond the end of the string./// Returns a slice of the given string from byte `begin` to its end./// Panics when `begin` is not at a code point boundary,/// or is beyond the end of the string./// Returns a slice of the given string from its beginning to byte `end`./// Panics when `end` is not at a code point boundary,decode_surrogateis_code_point_boundary/// Copied from str::is_char_boundarycheck_utf8_boundary/// Verify that `index` is at the edge of either a valid UTF-8 codepoint/// (i.e. a codepoint that's not a surrogate) or of the whole string./// These are the cases currently permitted by `OsStr::self_encoded_bytes`./// Splitting between surrogates is valid as far as WTF-8 is concerned, but/// we do not permit it in the public API because WTF-8 is considered an/// implementation detail./// Copied from core::str::raw::slice_unchecked/// Copied from core::str::raw::slice_error_fail/// Iterator for the code points of a WTF-8 string./// Created with the method `.code_points()`./// Generates a wide character sequence for potentially ill-formed UTF-16.// Copied from libunicode/u_str.rs//! Implementation of [the WTF-8 encoding](https://simonsapin.github.io/wtf-8/).//! This library uses Rust’s type system to maintain//! [well-formedness](https://simonsapin.github.io/wtf-8/#well-formed),//! like the `String` and `&str` types do for UTF-8.//! Since [WTF-8 must not be used//! for interchange](https://simonsapin.github.io/wtf-8/#intended-audience),//! this library deliberately does not provide access to the underlying bytes//! of WTF-8 strings,//! nor can it decode WTF-8 from arbitrary bytes.//! WTF-8 strings can be obtained from UTF-8, UTF-16, or code points.bench_downcast_refmap_arrayis_ascii_align_to// These are separate since it's easier to debug errors if they don't go through// macro expansion first.is_ascii_align_to_unrolledbranchless_to_ascii_upper_case// Lower-case ASCII 'a' is the first byte that has its highest bit set// after wrap-adding 0x1F://     b'a' + 0x1F == 0x80 == 0b1000_0000//     b'z' + 0x1F == 0x98 == 0b1001_1000// Lower-case ASCII 'z' is the last byte that has its highest bit unset// after wrap-adding 0x05://     b'a' + 0x05 == 0x66 == 0b0110_0110//     b'z' + 0x05 == 0x7F == 0b0111_1111// … except for 0xFB to 0xFF, but those are in the range of bytes// that have the highest bit unset again after adding 0x1F.// So `(byte + 0x1f) & !(byte + 5)` has its highest bit set// iff `byte` is a lower-case ASCII letter.// Lower-case ASCII letters all have the 0x20 bit set.// (Two positions right of 0x80, the highest bit.)// Unsetting that bit produces the same letter, in upper-case.// Therefore:ASCII_UPPERCASE_MAPAsciiCharacterClassCw// control// control whitespace// whitespace// digitLx// lowercase// lowercase hex digitUx// uppercase// uppercase hex digit// punctuation// Non-ASCIIASCII_CHARACTER_CLASSASCII_PATHRUST_INCANTATIONbench_ascii_escape_display_no_escapebench_ascii_escape_display_mixedbench_to_digit_radix_2bench_to_digit_radix_10bench_to_digit_radix_16bench_to_digit_radix_36bench_to_digit_radix_varbench_to_ascii_uppercasebench_to_ascii_lowercasebench_ascii_mix_to_uppercasebench_ascii_mix_to_lowercasebench_ascii_char_to_uppercasebench_ascii_char_to_lowercasebench_non_ascii_char_to_uppercasebench_non_ascii_char_to_lowercaseIoWritewrite_vec_valuewrite_vec_refwrite_vec_macro1write_vec_macro2write_vec_macro_debugwrite_str_valuewrite_str_refwrite_str_macro1write_str_macro2write_str_macro_debugwrite_str_macro_debug_asciiwrite_u128_maxwrite_u128_minwrite_u64_maxwrite_u64_minwrite_u8_maxwrite_u8_minwrite_i8_binwrite_i16_binwrite_i32_binwrite_i64_binwrite_i128_binwrite_i8_octwrite_i16_octwrite_i32_octwrite_i64_octwrite_i128_octwrite_i8_hexwrite_i16_hexwrite_i32_hexwrite_i64_hexwrite_i128_hexwrite_i64_expwrite_i128_expbench_str_under_8_bytesbench_str_of_8_bytesbench_str_over_8_bytesbench_long_strbench_u32bench_u32_keyedbench_u64bench_bytes_4bench_bytes_7bench_bytes_8bench_bytes_a_16bench_bytes_b_32bench_bytes_c_128bench_rpositionbench_skip_whilebench_multiple_takescatterbench_max_by_keybench_max_by_key2// https://www.reddit.com/r/rust/comments/31syce/using_iterators_to_find_the_index_of_the_min_or/bench_maxbench_range_step_by_sum_reduciblebench_range_step_by_loop_u32bench_range_step_by_fold_usizebench_range_step_by_fold_u16copy_zipadd_zipbench_zip_copybench_zip_addfor_each_loop/// `Iterator::for_each` implemented as a plain loop.for_each_fold/// `Iterator::for_each` implemented with `fold` for internal iteration./// (except when `by_ref()` effectively disables that optimization.)bench_for_each_chain_loopbench_for_each_chain_foldbench_for_each_chain_ref_foldbench_sums/// Helper to benchmark `sum` for iterators taken by value which/// can optimize `fold`, and by reference which cannot.bench_zip_then_skip// Checks whether Skip<Zip<A,B>> is as fast as Zip<Skip<A>, Skip<B>>, from// https://users.rust-lang.org/t/performance-difference-between-iterator-zip-and-skip-order/15743bench_skip_then_zipbench_skip_trusted_random_accessbench_filter_countbench_filter_ref_countbench_filter_chain_countbench_filter_chain_ref_countbench_partial_cmpbench_chain_partial_cmpbench_ltbench_trusted_random_access_adaptersbench_next_chunk_copied/// Exercises the iter::Copied specialization for slice::Iterbench_next_chunk_trusted_random_access/// Exercises the TrustedRandomAccess specialization in ArrayChunksbench_next_chunk_filter_evenbench_next_chunk_filter_predictably_truebench_next_chunk_filter_mostly_falsebench_next_chunk_filter_map_evenbench_next_chunk_filter_map_predictably_truebench_next_chunk_filter_map_mostly_false// wasm32 does not support benches (no time).IPV4_STRIPV4_STR_PORTIPV6_STR_FULLIPV6_STR_COMPRESSIPV6_STR_V4IPV6_STR_PORTIPV6_STR_PORT_SCOPE_IDbench_parse_ipv4bench_parse_ipv6_fullbench_parse_ipv6_compressbench_parse_ipv6_v4bench_parse_ipaddr_v4bench_parse_ipaddr_v6_fullbench_parse_ipaddr_v6_compressbench_parse_ipaddr_v6_v4bench_parse_socket_v4bench_parse_socket_v6bench_parse_socket_v6_scope_idbench_parse_socketaddr_v4bench_parse_socketaddr_v6addr_parserbench_0bench_42bench_huge_intbench_short_decimalbench_pi_longbench_pi_shortbench_1e150bench_long_decimal_and_expbench_min_subnormalbench_min_normaldecode_finitebench_small_shortestbench_big_shortestbench_small_exact_3bench_big_exact_3bench_small_exact_12bench_big_exact_12bench_small_exact_infbench_big_exact_infbench_one_exact_infbench_trailing_zero_exact_infbench_halfway_point_exact_infbench_templatebench_typebench_mask_kindint_log10_benchint_log_bench// Uses an ITERATIONS * 20 Byte stack allocationEXPONENT_MAX// Hardest native type to multiplyMAX_BASEpow_bench_templateinner_pow// This may panic if it overflows.inner_wrappinginner_overflowinginner_checked_unwrapped// This will panic if it overflows.inner_saturatingmake_const_base// +-17 ** 31 <= IntType::MAXint_sqrt_benchint_bitsint_logint_powASCII_NUMBERSfrom_str_benchfrom_str_radix_bench_xHasDtoralloc_obj_with_dtor// Overhead of dtorsstarts_with_strends_with_charends_with_strbinary_search_worst_casebinary_search_l1binary_search_l2binary_search_l3binary_search_l1_with_dupsbinary_search_l2_with_dupsbinary_search_l3_with_dupsbinary_search_l1_worst_casebinary_search_l2_worst_casebinary_search_l3_worst_casefill_byte_sizedfold_to_last// Tests the ability of the compiler to recognize that only the last slice item is needed// based on issue #106288corporadefine_bencheslibcorefilter_count_cont_bytesiterator_incrementmanual_char_lenrepeat8define_constszhru//! Exposes a number of modules with different kinds of strings.//! Each module contains `&str` constants named `TINY`, `SMALL`, `MEDIUM`,//! `LARGE`, and `HUGE`.//! - The `TINY` string is generally around 8 bytes.//! - The `SMALL` string is generally around 30-40 bytes.//! - The `MEDIUM` string is generally around 600-700 bytes.//! - The `LARGE` string is the `MEDIUM` string repeated 8x, and is around 5kb.//! - The `HUGE` string is the `LARGE` string repeated 8x (or the `MEDIUM`//!   string repeated 64x), and is around 40kb.//! Except for `mod emoji` (which is just a bunch of emoji), the strings were//! pulled from (localizations of) rust-lang.org.write_callsCountingWriterassert_fmtascii_onlyascii_escapessome_unicodemostly_unicode//! This primarily benchmarks `impl Debug for str`,//! and it also explicitly tests that we minimizes calls to the underlying `Write`r.//! While that is an implementation detail and there are no guarantees about it,//! we should still try to minimize those calls over time rather than regress them.chars_advance_by_1000chars_advance_by_0010chars_advance_by_0001str_validate_emojibench_tuple_comparison// Intentionally left empty.const_unchecked_layoutlayout_round_up_to_align_edge_caseslayout_array_edge_caseslayout_errorslayout_debug_shows_log2_of_alignmentlayout_accepts_all_valid_alignments// Running this normally doesn't do much, but it's also run in Miri, which// will double-check that these are allowed by the validity invariants.TESTany_referencedany_owningany_downcast_refany_downcast_mutany_fixed_vecany_unsizeddistinct_type_namesdyn_type_namearray_from_refarray_from_mutarray_try_fromiterator_collectiterator_rev_collectiterator_nthiterator_lastiterator_cloneiterator_fusediterator_leniterator_countiterator_flat_mapiterator_debugiterator_dropsarray_default_impl_avoids_leaks_on_panicempty_array_is_always_defaultarray_maparray_map_drop_safetycell_allows_array_cyclearray_from_fnarray_try_from_fnarray_try_from_fn_drops_inserted_elements_on_errarray_try_from_fn_drops_inserted_elements_on_paniccatch_unwind_silent// https://stackoverflow.com/a/59211505array_split_array_mutarray_rsplit_array_mutarray_split_array_ref_out_of_boundsarray_split_array_mut_out_of_boundsarray_rsplit_array_ref_out_of_boundsarray_rsplit_array_mut_out_of_boundsarray_intoiter_advance_byarray_intoiter_advance_back_byarray_mixed_equality_integersarray_mixed_equality_nansarray_into_iter_foldarray_into_iter_rfoldarray_map_drops_unmapped_elements_on_panicarray_eq// This covers the `PartialEq::<[T]>::eq` impl for `[T; N]` when it returns false.const_array_opstest_is_asciitest_to_ascii_uppercasetest_to_ascii_lowercasetest_make_ascii_lower_casetest_make_ascii_upper_casetest_eq_ignore_ascii_caseinference_works// Shorthands used by the is_ascii_* tests.assert_nonetest_is_ascii_alphabetictest_is_ascii_uppercasetest_is_ascii_lowercasetest_is_ascii_alphanumerictest_is_ascii_digittest_is_ascii_octdigittest_is_ascii_hexdigittest_is_ascii_punctuationtest_is_ascii_graphictest_is_ascii_whitespacetest_is_ascii_controltest_is_ascii_align_size_thoroughly// `is_ascii` does a good amount of pointer manipulation and has// alignment-dependent computation. This is all sanity-checked via// `debug_assert!`s, so we test various sizes/alignments thoroughly versus an// "obviously correct" baseline function.ascii_constascii_ctype_consttest_escape_asciitest_escape_ascii_itertest_invalid_u8/// Tests Display implementation for ascii::Char.test_debug_control/// Tests Debug implementation for ascii::Char./// Tests Extend implementation for ascii::Char.NoCopyNoCopyNoDebugNoDebugbool_"there is no such thing as an acquire store"store_illegal_rt_store_acquire_ordering"there is no such thing as an acquire-release store"store_illegal_rt_store_acq_rel_ordering"there is no such thing as a release load"store_illegal_rt_load_release_ordering"there is no such thing as an acquire-release load"store_illegal_rt_load_acq_rel_orderingbool_andbool_nanduint_anduint_nanduint_oruint_xoruint_min// Missing intrinsic in compiler-builtinsuint_maxint_andint_nandint_orint_xorint_minint_maxS_TRUES_INTS_UINTstatic_initatomic_access_boolatomic_alignment"there is no such thing as an acquire-release failure ordering"atomic_compare_exchange_illegal_acq_rel"there is no such thing as a release failure ordering"atomic_compare_exchange_illegal_releaseatomic_compare_exchange_weak_illegal_acq_relatomic_compare_exchange_weak_illegal_releaseatomic_and_or/* FIXME(#110395)
#[test]
fn atomic_const_from() {
    const _ATOMIC_U8: AtomicU8 = AtomicU8::from(1);
    const _ATOMIC_BOOL: AtomicBool = AtomicBool::from(true);
    const _ATOMIC_PTR: AtomicPtr<u32> = AtomicPtr::from(core::ptr::null_mut());
}
*/test_booltest_bool_nottest_bool_to_optiontest_bool_to_resultsmoketest_unsafe_cellunsafe_cell_raw_getsmoketest_cellcell_updatecell_has_sensible_showref_and_refmut_have_sensible_showdouble_imm_borrowno_mut_then_imm_borrowno_imm_then_borrow_mutno_double_borrow_mutimm_release_borrow_mutmut_release_borrow_mutdouble_borrow_single_release_no_borrow_mutdiscard_doesnt_unborrowref_clone_updates_flagref_map_does_not_update_flagref_map_split_updates_flagref_map_splitref_mut_map_splitref_map_accessorref_mut_map_accessorcell_defaultcell_setcell_replacecell_into_innercell_exteriorcell_does_not_clonerefcell_defaultunsafe_cell_unsizedrefcell_unsizedrefcell_ref_coercionrefcell_swap_borrowsrefcell_replace_borrowsrefcell_formatconst_cellsrefcell_borrowrefcell_borrow_mutNeverDroprefcell_replacerefcell_swaptest_converttest_convert_consttest_is_lowercasetest_is_uppercasetest_to_digittest_to_lowercasetest_to_uppercasetest_is_controltest_is_numerictest_encode_utf16test_len_utf16test_decode_utf16test_decode_utf16_size_hinted_iterator_specializationseu_iterator_specializationstest_from_digit_radix_too_hightest_from_digit_invalid_radixtest_to_digit_radix_too_lowtest_to_digit_radix_too_hightest_as_ascii_invalidtest_encode_utf8_raw_buffer_too_smalltest_encode_utf16_raw_buffer_too_smalltest_borrowed_clonetest_clone_to_uninit_slice_successtest_clone_to_uninit_slice_drops_on_panictest_clone_to_uninit_strtest_clone_to_uninit_cstrcstr_metadata_is_length_with_nultest_int_totalordtest_bool_totalordtest_mut_int_totalordtest_ord_max_mintest_ord_min_max_bytest_ord_min_max_by_keytest_ordering_reversetest_ordering_ordertest_ordering_thentest_ordering_then_withtest_user_defined_eqordering_constordering_structural_eqcmp_defaultconst_cmp// Aligned to two bytesunaligned_ptrconst_ptr_readmut_ptr_readmut_ptr_writeinto_as_try_intosome_stringSomeConcreteType// Test the `Request` API.test_error_generic_member_access// Test the Error.provide and request mechanisms with a by-reference trait object.test_request_constructortest_error_generic_member_access_boxed// Test the Error.provide and request mechanisms with a boxed trait object.test_error_generic_member_access_concrete// Test the Error.provide and request mechanisms with a concrete object.compares_as_u8sassert_biteqTOL/// Default tolerances. Works for values that should be near precise but not exact. Roughly/// the precision carried by `100 * 100`.TOL_PRECISE/// For operations that are near exact, usually not involving math of different/// signs.// FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy// Note these tolerances make sense around zero, but not for more extreme exponents.// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support// the intrinsics.TOL_N2/// Tolerance for results on the order of 10.0e-2TOL_0/// Tolerance for results on the order of 10.0e+0TOL_P2/// Tolerance for results on the order of 10.0e+2TOL_P4/// Tolerance for results on the order of 10.0e+4/// Unsigned int with the same size, for converting to/from bits.APPROX/// Set the default tolerance for float comparison based on the type.POWI_APPROX/// Allow looser tolerance for f32 on miri_180_TO_RADIANS_APPROX/// Allow looser tolerance for f16PI_TO_DEGREES_APPROX/// Allow for looser tolerance for f16/// Smallest numberTINY_UP/// Next smallest numberMAX_DOWN/// Exponent = 0b11...10, Significand 0b1111..10. Min val > 0NAN_MASK1/// First pattern over the mantissaNAN_MASK2/// Second pattern over the mantissaEPS_ADDEPS_MULEPS_DIVRAW_1RAW_12_DOT_5RAW_1337RAW_MINUS_14_DOT_25MUL_ADD_RESULT/// The result of 12.3.mul_add(4.5, 6.7)NEG_MUL_ADD_RESULT/// The result of (-12.3).mul_add(-4.5, -6.7)MAX_RECIP/// Reciprocal of the maximum valTestableFloat/// Miri adds some extra errors to float functions; make sure the tests still pass./// These values are purely used as a canary to test against and are thus not a stable guarantee Rust provides./// They serve as a way to get an idea of the real precision of floating point operations on different platforms.lim_for_ty/// Determine the tolerance for values of the argument type.assert_approx_eq_rt/// Verify that floats are within a tolerance of each other.assert_approx_eq_constassert_biteq_rt/// Verify that floats have the same bitwise representation. Used to avoid the default `0.0 == -0.0`/// behavior, as well as to ensure exact NaN bitpatterns.assert_biteq_const// Use the runtime version by default.// This way, they can be shadowed by the const versions.// Also make the const version available for re-exports./// Generate float tests for all our float types, for compile-time and run-time behavior./// By default all tests run for all float types. Configuration can be applied via `attrs`./// ```ignore (this is only a sketch)/// float_test! {///     name: fn_name, /* function under test *////     attrs: {///         // Apply a configuration to the test for a single type///         f16: #[cfg(target_has_reliable_f16_math)],///         // Types can be excluded with `cfg(false)`///         f64: #[cfg(false)],///     test<Float> {///         /* write tests here, using `Float` as the type */// FIXME(f16_f128): merge into `num` once the required `fmodl`/`fmodf128` function is available on// all platforms.// Separate test since the `for` loops cannot be run in `const`.// We have runtime ("rt") and const versions of these macros.// FIXME(f16): Tests involving sNaN are disabled because without optimizations, `total_cmp` is// getting incorrectly lowered to code that includes a `extend`/`trunc` round trip, which quiets// sNaNs. See: https://github.com/llvm/llvm-project/issues/104915test_singletest_multipletest_empty_non_exhaustivetest_multiple_and_non_exhaustivetest_nested_non_exhaustivetest_field_withtest_entry_errtest_invalid_key_when_entry_is_incompletetest_invalid_finish_incomplete_entrytest_invalid_value_before_keytest_multiple_non_exhaustivetest_formatting_parameters_are_forwardedtest_format_f64test_format_f64_rounds_ties_to_eventest_format_f32test_format_f32_rounds_ties_to_evenis_exponentialtest_lifetimetest_format_flagstest_pointer_formats_data_pointertest_fmt_debug_of_raw_pointerstest_fmt_debug_of_mut_referencetest_default_write_implstest_estimated_capacitypad_integral_resetstest_maybe_uninit_shortformatting_options_ctorformatting_options_flagstest_format_int_zerotest_format_int_onetest_format_int_misctest_format_int_limitstest_format_int_exp_limitstest_format_int_exp_precisiontest_format_int_flagstest_format_int_sign_paddingtest_format_debug_hex"Formatting argument out of range"test_rt_width_too_longpolledPollNpoll_nasync_fn_join_does_not_unnecessarily_move_mentioned_bindings// no need to _run_ this test, just to compile it.join_lets_control_flow_effects_such_as_try_flow_throughjoin_is_able_to_handle_temporariestest_join_function_like_value_arg_semantics/// Tests that `join!(…)` behaves "like a function": evaluating its arguments/// before applying any of its own logic./// _e.g._, `join!(async_fn(&borrowed), …)` does not consume `borrowed`;/// and `join!(opt_fut?, …)` does let that `?` refer to the callsite scope._pending_impl_all_auto_traits// just tests by whether or not this compilesMyHashertest_writer_hasherCustomHashertest_custom_statetest_indirect_hashertest_build_hasher_dyn_compatible_build_hasher_default_impl_all_auto_traitstest_write_short_works/* FIXME(#110395)
#[test]
const fn test_const_sip() {
    let val1 = 0x45;
    let val2 = 0xfeed;

    const fn const_hash<T: Hash>(x: &T) -> u64 {
        let mut st = SipHasher::new();
        x.hash(&mut st);
        st.finish()
    }

    assert!(const_hash(&(val1)) != const_hash(&(val2)));
}
*/select_unpredictable_drop"message canary"select_unpredictable_drop_on_panictest_clamptest_clamp_usizetest_clamp_range_rangetest_clamp_ops_rangetest_clamp_range_range_inclusivetest_clamp_ops_range_inclusivetest_clamp_range_range_fromtest_clamp_ops_range_fromtest_clamp_range_totest_clamp_range_range_to_inclusivetest_clamp_ops_range_to_inclusivetest_clamp_range_fulltest_typeid_sized_typestest_typeid_unsized_typestest_assume_can_be_in_const_contexts// Check that `const_assume` feature allow `assume` intrinsic// to be used in const contexts.test_write_bytes_in_const_contextstest_hints_in_const_contextstest_const_allocate_at_runtimetest_const_deallocate_at_runtimetest_three_way_compare_in_const_contextsfallback_cmacarrying_mul_add_fallback_u32carrying_mul_add_fallback_i32carrying_mul_add_fallback_u128carrying_mul_add_fallback_i128/// Test that BorrowedBuf has the correct numbers when created with new/// Test that BorrowedBuf has the correct numbers when created with uninitadvance_filledreborrow_writtencursor_set_initcursor_with_unfilled_buftest_iterator_array_chunks_infertest_iterator_array_chunks_clone_and_droptest_iterator_array_chunks_remaindertest_iterator_array_chunks_size_hinttest_iterator_array_chunks_counttest_iterator_array_chunks_next_and_next_backtest_iterator_array_chunks_rev_remaindertest_iterator_array_chunks_try_foldtest_iterator_array_chunks_foldtest_iterator_array_chunks_try_rfoldtest_iterator_array_chunks_rfoldtest_iterator_by_ref_sizedtest_chaintest_iterator_chaintest_iterator_chain_advance_bytest_iterator_chain_advance_back_bytest_iterator_chain_nthtest_iterator_chain_nth_backtest_iterator_chain_lasttest_iterator_chain_counttest_iterator_chain_findtest_iterator_chain_size_hinttest_iterator_chain_unfusedtest_chain_foldtest_chain_try_foldstest_double_ended_chaintest_clonedtest_cloned_side_effectstest_cloned_try_foldstest_copiedtest_iterator_enumeratetest_iterator_enumerate_nthtest_iterator_enumerate_nth_backtest_iterator_enumerate_counttest_iterator_enumerate_advance_bytest_iterator_enumerate_foldtest_enumerate_try_foldstest_double_ended_enumeratetest_empty_iterator_enumerate_next_indextest_iterator_filter_counttest_iterator_filter_foldtest_filter_try_foldstest_double_ended_filtertest_next_chunk_does_not_leaktest_filter_maptest_filter_map_foldtest_filter_map_try_foldstest_double_ended_filter_maptest_iterator_flat_maptest_iterator_flat_map_fold/// Tests `FlatMap::fold` with items already picked off the front and back,/// to make sure all parts of the `FlatMap` are folded correctly.test_flat_map_try_foldstest_double_ended_flat_maptest_iterator_flattentest_iterator_flatten_fold/// Tests `Flatten::fold` with items already picked off the front and back,/// to make sure all parts of the `Flatten` are folded correctly.test_flatten_try_foldstest_flatten_advance_bytest_flatten_non_fused_outertest_flatten_non_fused_innertest_double_ended_flattentest_trusted_len_flattentest_flatten_counttest_flatten_lasttest_flatten_one_shottest_flatten_one_shot_revtest_flatten_one_shot_arraystest_fuse_nthtest_fuse_lasttest_fuse_counttest_fuse_foldtest_fusetest_inspecttest_inspect_foldtest_interspersetest_intersperse_size_hinttest_fold_specialization_interspersetest_try_fold_specialization_intersperse_oktest_intersperse_withtest_intersperse_foldtest_intersperse_collect_stringtest_try_fold_specialization_intersperse_errtest_map_try_foldstest_double_ended_mapdropped_twicealive_countDropInfowas_droppedDropCheckno_iter_panic_n1no_iter_panic_n2no_iter_panic_n5panic_in_first_batchpanic_in_middlelen_equals_n//! These tests mainly make sure the elements are correctly dropped.drop_checksoutput_n1output_n2test_case_from_pr_82413_comment"array in `Iterator::map_windows` must contain more than 0 elements"check_zero_windowtest_zero_sized_type"array size of `Iterator::map_windows` is too large"test_too_large_array_sizetest_lazinessNonFused/// An iterator that panics whenever `next` or `next_back` is called/// after `None` has already been returned. This does not violate/// `Iterator`'s contract. Used to test that iterator adapters don't/// poll their inner iterators after exhausting them.Unfuse/// An iterator wrapper that panics whenever `next` or `next_back` is called/// after `None` has been returned.// alternates between `None` and `Some(())`CycleIter/// This is an iterator that follows the Iterator contract,/// but it is not fused. After having returned None once, it will start/// producing elements if .next() is called again.CountClonetest_iterator_peekabletest_iterator_peekable_counttest_iterator_peekable_nthtest_iterator_peekable_lasttest_iterator_peekable_foldtest_iterator_peekable_rfoldtest_iterator_peekable_next_if_eqtest_iterator_peekable_muttest_iterator_peekable_remember_peek_none_1test_iterator_peekable_remember_peek_none_2test_iterator_peekable_remember_peek_none_3test_peek_try_foldstest_peekable_non_fusedtest_peekable_next_if_map_mutationtest_peekable_next_if_map_panictest_iterator_scantest_iterator_skiptest_iterator_skip_doubleendedtest_iterator_skip_nthtest_skip_advance_bytest_iterator_skip_counttest_iterator_skip_lasttest_iterator_skip_foldtest_skip_try_foldstest_skip_nth_backtest_skip_non_fusedtest_skip_non_fused_nth_overflowtest_skip_overflow_wrappingtest_iterator_skip_whiletest_iterator_skip_while_foldtest_skip_while_try_foldtest_iterator_step_bytest_iterator_step_by_nthtest_iterator_step_by_nth_overflowtest_iterator_step_by_nth_try_foldtest_iterator_step_by_nth_backtest_iterator_step_by_nth_try_rfoldtest_iterator_step_by_zerotest_iterator_step_by_size_hinttest_step_by_skipDeOpttest_step_by_fold_range_specializationtest_iterator_taketest_iterator_take_nthtest_iterator_take_nth_backtest_take_advance_bytest_iterator_take_shorttest_take_try_foldstest_byref_take_consumed_itemstest_exact_size_take_repeattest_exact_size_take_repeat_withtest_reverse_on_zip// This is https://github.com/rust-lang/rust/issues/104729 with all uses of// repeat(0) were replaced by repeat(0).take(20).test_iterator_take_whiletest_take_while_foldstest_zip_nthtest_zip_nth_side_effectstest_zip_next_back_side_effectstest_zip_nth_back_side_effectstest_zip_next_back_side_effects_exhaustedtest_zip_cloned_sideffectfultest_zip_map_sideffectfultest_zip_map_rev_sideffectfultest_zip_nested_sideffectfultest_zip_nth_back_side_effects_exhaustedtest_zip_trusted_random_access_compositiontest_double_ended_ziptest_nested_zip_panic_safety/// Regression test for #137255/// A previous implementation of Zip TrustedRandomAccess specializations tried to do a lot of work/// to preserve side-effects of equalizing the iterator lengths during backwards iteration./// This lead to several cases of unsoundness, twice due to being left in an inconsistent state/// after panics./// The new implementation does not try as hard, but we still need panic-safety.test_issue_82282test_issue_82291is_trusted_lentest_multi_itertest_counter_from_itertest_functor_lawstest_monad_laws_left_identitytest_monad_laws_right_identitytest_monad_laws_associativityextend_for_unit//! Note//! ----//! You're probably viewing this file because you're adding a test (or you might//! just be browsing, in that case, hey there!).//! The iter test suite is split into two big modules, and some miscellaneous//! smaller modules. The two big modules are `adapters` and `traits`.//! `adapters` are for methods on `Iterator` that adapt the data inside the//! iterator, whether it be by emitting another iterator or returning an item//! from inside the iterator after executing a closure on each item.//! `traits` are for trait's that extend an `Iterator` (and the `Iterator`//! trait itself, mostly containing miscellaneous methods). For the most part,//! if a test in `traits` uses a specific adapter, then it should be moved to//! that adapter's test file in `adapters`.test_char_rangetest_ascii_char_rangetest_range_exhaustiontest_range_inclusive_exhaustiontest_range_nthtest_range_nth_backtest_range_from_nthtest_range_from_taketest_range_from_take_collecttest_range_inclusive_nthtest_range_inclusive_nth_backtest_range_lentest_range_inclusive_lentest_range_steptest_range_advance_bytest_range_inclusive_steptest_range_last_maxtest_range_inclusive_last_maxtest_range_mintest_range_inclusive_mintest_range_inclusive_foldstest_range_size_hinttest_range_inclusive_size_hinttest_range_trusted_random_accesstest_double_ended_rangetest_repeat_taketest_repeat_take_collect"iterator is infinite"test_repeat_counttest_repeat_lasttest_repeat_withtest_repeat_with_taketest_repeat_with_take_collecttest_successorstest_once_withtest_repeat_n_droptest_repeat_n_soundnesstest_iterator_sumtest_iterator_sum_resulttest_iterator_sum_optiontest_iterator_producttest_iterator_product_resulttest_iterator_product_optiontest_saturating_sum_producttest_iterator_rev_nth_backtest_iterator_rev_nthtest_revtest_rev_try_foldstest_rpositiontest_rev_rpositiontest_rposition_panic//! If you've made a test that happens to use one of DoubleEnded's methods, but//! it tests another adapter or trait, you should *add it to the adapter or//! trait's test file*.//! Some examples would be `adapters::cloned::test_cloned_try_folds` or//! `adapters::flat_map::test_double_ended_flat_map`, which use `try_fold` and//! `next_back`, but test their own adapter.Mod3/// A wrapper struct that implements `Eq` and `Ord` based on the wrapped/// integer modulo 3. Used to test that `Iterator::max` and `Iterator::min`/// return the correct element if some of them are equal.test_cmp_bytest_partial_cmp_bytest_eq_bytest_iterator_nthtest_iterator_nth_backtest_iterator_advance_bytest_iterator_advance_back_bytest_iterator_rev_advance_back_bytest_iterator_maxtest_iterator_mintest_iterator_size_hinttest_anytest_try_findtest_try_find_api_usabilitytest_counttest_max_by_keytest_max_bytest_min_by_keytest_min_bytest_by_reftest_iterator_rev_advance_bytest_find_maptest_try_reducetest_iterator_lentest_try_collecttest_collect_intoiter_try_collect_uses_try_fold_not_nexttest_next_chunktest_collect_into_tuplestest_collect_for_tuplestest_extend_for_tuple_side_effects_order_empty_impl_all_auto_traitstest_steps_betweentest_step_forwardtest_step_backwardonce_cell_get_mutonce_cell_dropunsync_once_cell_drop_emptypartialeq_impllazy_newlazy_type_inference// Check that we can infer `T` from closure's type."LazyCell instance has previously been poisoned"lazy_force_mut_paniclazy_force_mutaliasing_in_getreentrant_initdropck/* FIXME(#110395)
#[test]
const fn once_cell_const() {
    let _once_cell: OnceCell<u32> = OnceCell::new();
    let _once_cell: OnceCell<u32> = OnceCell::from(32);
}
*/assert_eq_const_safe/// Version of `assert_matches` that ignores fancy runtime printing in const context and uses structural equality.test_runtime_and_compiletime/// Creates a test for runtime and a test for constant-time.pin_macrostr_lossy/// Copied from `std::test_helpers::test_rng`, see that function for rationale.// Not used in all configurations.assert_eq_trailing_commaassert_escapeassert_ne_trailing_commamatches_leading_pipecfg_select_basiccfg_select_debug_assertionscfg_select_no_duplication_on_64cfg_select_optionscfg_select_two_functions_accepts_expressions_accepts_only_wildcard_allows_stmt_expr_attributes// The current implementation expands to a macro call, which allows the use of expression// statements._expression_matches_does_not_trigger_non_exhaustive_omitted_patterns_lintconst_drop_in_placesize_of_basicsize_of_16size_of_32size_of_64size_of_val_basicalign_of_basicalign_of_16align_of_32align_of_64align_of_val_basicalign_of_val_raw_packedtest_transmute_copytest_transmute_copy_shrinktest_transmute_copy_unalignedtest_transmute_copy_grow_panicstest_discriminant_send_syncassume_init_gooduninit_array_assume_inituninit_write_copy_of_sliceuninit_write_copy_of_slice_panic_ltuninit_write_copy_of_slice_panic_gtuninit_write_clone_of_sliceuninit_write_clone_of_slice_panic_ltuninit_write_clone_of_slice_panic_gtuninit_write_clone_of_slice_mid_panicuninit_write_clone_of_slice_no_dropuninit_write_filledCloneUntilPanicuninit_write_filled_panic_dropuninit_write_filled_no_drop_clonesuninit_write_withuninit_write_with_mid_panicuninit_write_with_no_dropuninit_write_iteruninit_write_iter_partialuninit_write_iter_overfilluninit_write_iter_emptyuninit_write_iter_mid_panicuninit_write_iter_no_dropuninit_const_assume_init_readconst_maybe_uninitoffset_of_dstoffset_of_packedoffset_of_projectionoffset_of_aliasconst_offset_ofoffset_of_without_const_promotionoffset_of_addrconst_maybe_uninit_zeroeddrop_guards_only_dropped_by_closure_when_rundrop_guard_into_innerdrop_guard_always_drops_value_if_closure_drop_unwindssa4sa6test_from_str_ipv4test_from_str_ipv6test_from_str_ipv4_in_ipv6test_from_str_socket_addripv4_addr_to_stringipv6_addr_to_stringipv4_to_ipv6ipv6_to_ipv4_mappedipv6_to_ipv4ip_propertiesipv4_propertiesipv6_propertiestest_ipv4_to_inttest_int_to_ipv4test_ipv6_to_inttest_int_to_ipv6ipv4_from_constructorsipv6_from_constructorsipv4_from_octetsipv6_from_segmentsipv6_from_octetsis_v4is_v6ipv4_constipv6_constip_conststructural_matchIPV4_STR_WITH_OCTALIPV4_STR_WITH_HEXIPV6_STR_V4_WITH_OCTALIPV6_STR_V4_WITH_HEXparse_ipv4parse_ipv6parse_ipparse_socket_v4parse_socket_v6parse_socketipv6_corner_casesipv6_corner_failures// Things that might not seem like failures but are// FIXME: These tests are all excellent candidates for AFL fuzz testingipv4_socket_addr_to_stringipv6_socket_addr_to_stringsocket_v4_to_strsocket_v6_to_strtest_create_nonzero_instancetest_size_nonzero_in_optiontest_match_on_nonzero_optiontest_match_option_empty_vectest_match_option_vectest_match_option_rctest_match_option_arctest_match_option_empty_stringtest_match_option_stringFOO_ATOMtest_match_nonzero_const_patterntest_from_nonzerotest_from_signed_nonzerotest_nonzero_bitortest_nonzero_bitor_assigntest_nonzero_from_int_on_successtest_nonzero_from_int_on_errnonzero_constnonzero_leading_zerostest_nonzero_isolate_highest_onetest_nonzero_isolate_lowest_onetest_nonzero_uint_divtest_nonzero_uint_remtest_signed_nonzero_negtest_nonzero_fmttest_nonzero_highest_onetest_nonzero_lowest_onetest_nonzero_bit_widthtest_from_u64_overflowtest_add_overflow_1test_add_overflow_2test_add_smalltest_add_small_overflowtest_sub_underflow_1test_sub_underflow_2test_mul_smalltest_mul_small_overflowtest_mul_pow2test_mul_pow2_overflow_1test_mul_pow2_overflow_2test_mul_pow5test_mul_pow5_overflow_1test_mul_pow5_overflow_2test_mul_digitstest_mul_digits_overflow_1test_mul_digits_overflow_2test_div_rem_smalltest_is_zerotest_get_bit_out_of_rangetest_bit_lengthtest_bit_length_32x40check_int_clamptest_clamp_magnitude_i8test_clamp_magnitude_i16test_clamp_magnitude_i32test_clamp_magnitude_i64test_clamp_magnitude_i128test_clamp_magnitude_isizecheck_float_clamptest_clamp_magnitude_f32test_clamp_magnitude_f64test_clamp_magnitude_f32_panic_negative_limittest_clamp_magnitude_f64_panic_negative_limittest_clamp_magnitude_f32_panic_nan_limittest_clamp_magnitude_f64_panic_nan_limitFPathFPATHS_F32FPATHS_F64check_fast_path_f16// FIXME(f16_f128): enable on all targets once possible.check_fast_path_f32check_fast_path_f64ldexp_f32ldexp_f64test_f16_integer_decodetest_f32_integer_decodetest_f64_integer_decodetest_f32_conststest_f64_consts/* Sanity checks of computed magic numbers */compute_float16compute_float32compute_float64compute_float_f16_roundingcompute_float_f32_roundingcompute_float_f64_roundingtest_literal// Take a float literal, turn it into a string in various ways (that are all trusted// to be correct) and see if those strings are parsed back to the value of the literal.// Requires a *polymorphic literal*, i.e., one that can serve as f64 as well as f32.ordinaryspecial_code_pathssubnormalsfast_path_correctlonely_dotexponentiated_dotlonely_signmassive_exponent// FIXME(f16_f128): remove gates once tests work on all targetsnew_decmissing_piecesinvalid_charsparse_positiveassert_float_result_bits_eqregressionissue31109issue31407f32_reff32_ownf64_reff64_owntest_estimate_scaling_factorcheck_shortesttry_exacttry_fixedcheck_exactldexpi/// Returns `x * 2^exp`. Almost same to `std::{f32,f64}::ldexp`./// This is used for testing.check_exact_onef16_shortest_sanity_testf16_exact_sanity_testf32_shortest_sanity_testf32_exact_sanity_testf64_shortest_sanity_testf64_exact_sanity_testmore_shortest_sanity_testto_string_with_partsto_shortest_str_testto_shortest_exp_str_testto_exact_exp_str_testto_exact_fixed_str_test// in the following comments, three numbers are spaced by 1 ulp apart,// and the second one is being formatted.// some tests are derived from [1].// [1] Vern Paxson, A Program for Testing IEEE Decimal-Binary Conversion//     ftp://ftp.ee.lbl.gov/testbase-report.ps.Z//  or https://www.icir.org/vern/papers/testbase-report.pdff16_random_equivalence_testf32_random_equivalence_testf64_random_equivalence_testf16_exhaustive_equivalence_testf32_exhaustive_equivalence_testshortest_random_equivalence_testshortest_f16_exhaustive_equivalence_test// Miri is to slowshortest_f32_exhaustive_equivalence_test// it is too expensiveshortest_f64_hard_random_equivalence_testexact_f16_random_equivalence_testexact_f32_random_equivalence_testexact_f64_random_equivalence_testtest_mul_pow10shortest_sanity_testexact_sanity_testtest_to_shortest_strtest_to_shortest_exp_strtest_to_exact_exp_strtest_to_exact_fixed_strtest_cached_powertest_max_pow10_no_more_thanint_moduletest_arith_operation// IEEE 754 for many tests is applied to specific bit patterns.// These generally are not applicable to NaN, however.// ToString uses the default fmt::Display impl without special concerns, and bypasses other parts// of the formatting infrastructure, which makes it ideal for testing here.assert_floats_roundtripassert_floats_bitnepreserve_signed_zero// We must preserve signs on all numbers. That includes zero.// -0 and 0 are == normally, so test bit equality.preserve_signed_infinityinfinity_to_strneg_infinity_to_strnan_to_strinfinity_from_str// "+"?("inf"|"infinity") in any case => Infinityneg_infinity_from_str// "-inf"|"-infinity" in any case => Negative Infinityqnan_from_str// ("+"|"-"")?"s"?"nan" in any case => qNaN//! IEEE 754 floating point compliance tests//! To understand IEEE 754's requirements on a programming language, one must understand that the//! requirements of IEEE 754 rest on the total programming environment, and not entirely on any//! one component. That means the hardware, language, and even libraries are considered part of//! conforming floating point support in a programming environment.//! A programming language's duty, accordingly, is://!   1. offer access to the hardware where the hardware offers support//!   2. provide operations that fulfill the remaining requirements of the standard//!   3. provide the ability to write additional software that can fulfill those requirements//! This may be fulfilled in any combination that the language sees fit. However, to claim that//! a language supports IEEE 754 is to suggest that it has fulfilled requirements 1 and 2, without//! deferring minimum requirements to libraries. This is because support for IEEE 754 is defined//! as complete support for at least one specified floating point type as an "arithmetic" and//! "interchange" format, plus specified type conversions to "external character sequences" and//! integer types.//! For our purposes,//! "interchange format"          => f32, f64//! "arithmetic format"           => f32, f64, and any "soft floats"//! "external character sequence" => str from any float//! "integer format"              => {i,u}{8,16,32,64,128}//! None of these tests are against Rust's own implementation. They are only tests against the//! standard. That is why they accept wildly diverse inputs or may seem to duplicate other tests.//! Please consider this carefully when adding, removing, or reorganizing these tests. They are//! here so that it is clear what tests are required by the standard and what can be changed.round_down_imprecise/// Rounds the argument down to the next integer, except that we account for potential imprecision/// in the input, so if `f` is very close to an integer, it will round to that.// FIXME test is broken on Miri: https://github.com/rust-lang/rust/issues/137591ilog10_loopilog10_u8ilog10_u16ilog10_u32ilog10_u64ilog10_u128ilog2_of_0_panicilog10_of_0_panicilog3_of_0_panicilog0_of_1_panicilog1_of_1_panic//! Tests for the `Integer::{ilog,log2,log10}` methods.signed_checkunsigned_checkmidpoint_obvious_impl_i8midpoint_obvious_impl_u8midpoint_order_expectation_i8midpoint_order_expectation_u8midpoint_negative_expectation//! Test the following expectations://!  - midpoint(a, b) == (a + b) / 2//!  - midpoint(a, b) == midpoint(b, a)//!  - midpoint(-a, -b) == -midpoint(a, b)const_fromfloat_iter_sum_identityieee754cfg_block/// Adds the attribute to all items in the block.assume_usize_width/// Groups items that assume the pointer width is either 16/32/64, and has to be altered if/// support for larger/smaller pointer widths are added in the future.ldexp_f16/// Return `a * 2^b`.test_num/// Helper function for testing numeric operations/// Helper function for asserting number parsing returns a specific errorfrom_str_issue7588"radix must lie in the range `[2, 36]`"test_int_from_str_overflowtest_can_not_overflowtest_leading_plustest_invalidtest_infallible_try_from_int_error_TEST_CONST_PARSEtest_impl_from// Unsigned -> Unsigned// Signed -> Signed// Unsigned -> Signed// Bool -> Integer// Signed -> Float// Unsigned -> Floattest_f32f64// Float -> Floattest_impl_try_from_always_ok/// Conversions where the full width of $source can be represented as $targettest_impl_try_from_signed_to_unsigned_upper_ok/// Conversions where max of $source can be represented as $target,test_impl_try_from_unsigned_to_signed_upper_err/// Conversions where max of $source can not be represented as $target,/// but min can.test_impl_try_from_same_sign_err/// Conversions where min/max of $source can not be represented as $target.test_impl_try_from_signed_to_unsigned_err/// Conversions where neither the min nor the max of $source can be represented by/// $target, but max/min of the target can be represented by the source.test_new_from_zero_is_nonetest_new_from_extreme_is_someimpl_defined// For types L and R, checks that a trait implementation exists for//   * binary ops: L op R, L op &R, &L op R and &L op &R//   * assign ops: &mut L op R, &mut L op &Rimpls_defined// For all specified types T, checks that a trait implementation exists for//   * binary ops: T op T, T op &T, &T op T and &T op &T//   * assign ops: &mut T op T, &mut T op &T//   * unary ops: op T and op &Ttest_arith_optest_bitoptest_bitop_assigntest_shift_innertest_shift_assign_innertest_shift_assignuint_modulewrapping_operationwrapping_assignmentwrapping_testwrapping_int_apiwrapping_constcontrol_flow_discriminants_match_resultcontrol_flow_break_okcontrol_flow_continue_ok//! Regression test that Option and ControlFlow can have downstream FromResidual impls.//! cc https://github.com/rust-lang/rust/issues/99940,//! This does NOT test that issue in general; Option and ControlFlow's FromResidual//! impls in core were changed to not be affected by that issue.test_range_fromtest_range_totest_full_rangetest_range_inclusivetest_range_to_inclusivetest_range_containstest_range_to_containstest_range_bounds_contains// This test covers `RangeBounds::contains` when the start is excluded,// which cannot be directly expressed by Rust's built-in range syntax.test_range_is_emptytest_range_inclusive_end_boundtest_range_boundstest_one_sided_range_boundtest_bound_cloned_unboundedtest_bound_cloned_includedtest_bound_cloned_excludedtest_range_syntaxtest_range_syntax_in_return_statementrange_structural_matchderef_mut_on_refderef_on_reftest_not_never// Test the Range structs and syntax.// Test Deref implementationstest_get_ptrtest_get_strtest_get_resourcetest_option_dancetest_option_too_much_dancetest_andtest_and_thentest_ortest_or_elsetest_unwraptest_unwrap_panic1test_unwrap_panic2test_unwrap_ortest_unwrap_or_elsetest_unwrap_uncheckedtest_trytest_option_as_dereftest_option_as_deref_mutoption_constoption_const_muttest_unwrap_dropzip_optionsunzip_optionszip_unzip_roundtrip// Used for test super::location_{ord, eq}. Must be in a dedicated file.no_fmt// This is used for testing column ordering of Location, hence this ugly one-liner.// We must fmt skip the entire containing module or else tidy will still complain.file_afile_bfile_cLOCATIONS// A small shuffled set of locations for testing, along with their true order.location_const_callerlocation_const_filelocation_const_linelocation_const_columnlocation_file_lifetimelocation_debuglocation_eqlocation_ord// Note: Some of the following tests depend on the source location,// so please be careful when editing this file.search_asserts// This macro makes it easier to write// tests that do a series of iterations// variant names purposely chosen to// be the same length for easy alignmentRejectsInRange/// Combined enum for the results of next() and next_match()/next_reject()test_simple_iterationtest_simple_searchSTRESS// Á, 각, ก, 😀 all end in 0x81// 🁀, ᘀ do not end in 0x81 but contain the byte// ꁁ has 0x81 as its second and third bytes.// The memchr-using implementation of next_match// and next_match_back temporarily violate// the property that the search is always on a unicode boundary,// which is fine as long as this never reaches next() or next_back().// So we test if next() is correct after each next_match() as well.test_stress_indicestest_forward_search_shared_bytestest_reverse_search_shared_bytesdouble_ended_regression_test// FIXME(Manishearth) these tests focus on single-character searching  (CharSearcher)// and on next()/next_match(), not next_reject(). This is because// the memchr changes make next_match() for single chars complex, but next_reject()// continues to use next() under the hood. We should add more test cases for all// of these, as well as tests for StrSearcher and higher level tests for str::find() (etc)pin_constref_cellpin_mut_ref// These sensible Pin coercions are possible.pin_refpin_ptrpin_ptr_mutpin_non_nullnesting_pins// These Pins should continue to compile.// Do note that these instances of Pin types cannot be used// meaningfully because all methods require a Deref/DerefMut// bounds on the pointer type and Cell, RefCell and UnsafeCell// do not implement Deref/DerefMut.stuffextension_works_through_blockextension_works_through_unsafe_blockunsize_coercionrust_2024_exprtemp_lifetimetransitive_extension// edition:2021test_const_from_raw_partstest_is_nulltest_ptr_additiontest_ptr_subtractiontest_set_memorytest_set_memory_consttest_unsized_nonnulltest_const_nonnull_newtest_variadic_fnptr// printf may not be available on other platforms// For SipHasherwrite_unaligned_dropalign_offset_zstalign_offset_stride_onealign_offset_various_stridesalign_offset_issue_103361"is_aligned_to: align is not a power-of-two"invalid_is_alignedptr_metadata_boundspointee_metadata_debugdyn_metadatanonnull_tagged_pointer_with_provenanceswap_copy_untypedtest_const_copy_ptrtest_const_swap_ptrtest_null_array_as_slicetest_ptr_from_raw_parts_in_consttest_ptr_metadata_in_constptr_swap_nonoverlapping_is_untyped_inner// See <https://github.com/rust-lang/rust/issues/134713>test_ptr_swap_nonoverlapping_is_untypedtest_ptr_defaultop1op2test_impl_maptest_impl_map_errtest_fmt_defaulttest_unwrap_or_else_panictest_unwrap_err_uncheckedtest_expect_oktest_expect_errtest_expect_err_errtest_expect_err_oktest_iter_muttest_unwrap_or_defaulttest_into_oktest_into_errtest_result_as_dereftest_result_as_deref_mutresult_constresult_const_mutresult_opt_conversionsresult_try_trait_v2_brancheq10// helper functions for const contextseq20double_u16err_to_u16_plus1inc_u8noop_u8_refadd1_resultadd5_resultplus7_u8test_const_resulttest_binary_search_by_overflowtest_binary_search_implementation_details// Test implementation specific behavior when finding equivalent elements.// It is ok to break this test but when you do a crater run is highly advisable.test_iterator_counttest_chunks_counttest_chunks_nthtest_chunks_nexttest_chunks_next_backtest_chunks_nth_backtest_chunks_lasttest_chunks_ziptest_chunks_mut_counttest_chunks_mut_nthtest_chunks_mut_nth_backtest_chunks_mut_lasttest_chunks_mut_ziptest_chunks_mut_zip_aliasingtest_chunks_exact_mut_zip_aliasingtest_chunks_zsttest_rchunks_mut_zip_aliasingtest_rchunks_exact_mut_zip_aliasingtest_chunks_exact_counttest_chunks_exact_nthtest_chunks_exact_nth_backtest_chunks_exact_lasttest_chunks_exact_remaindertest_chunks_exact_ziptest_chunks_exact_mut_counttest_chunks_exact_mut_nthtest_chunks_exact_mut_nth_backtest_chunks_exact_mut_lasttest_chunks_exact_mut_remaindertest_chunks_exact_mut_ziptest_array_windows_infertest_array_windows_counttest_array_windows_nthtest_array_windows_nth_backtest_rchunks_counttest_rchunks_nthtest_rchunks_nth_backtest_rchunks_nexttest_rchunks_next_backtest_rchunks_lasttest_rchunks_ziptest_rchunks_mut_counttest_rchunks_mut_nthtest_rchunks_mut_nth_backtest_rchunks_mut_nexttest_rchunks_mut_next_backtest_rchunks_mut_lasttest_rchunks_mut_ziptest_rchunks_exact_counttest_rchunks_exact_nthtest_rchunks_exact_nth_backtest_rchunks_exact_lasttest_rchunks_exact_remaindertest_rchunks_exact_ziptest_rchunks_exact_mut_counttest_rchunks_exact_mut_nthtest_rchunks_exact_mut_nth_backtest_rchunks_exact_mut_lasttest_rchunks_exact_mut_remaindertest_rchunks_exact_mut_zipchunks_mut_are_send_and_synctest_windows_counttest_windows_nthtest_windows_nth_backtest_windows_lasttest_windows_ziptest_iter_ref_consistency// This checks all six indexing methods, given an input range that// should succeed. (it is NOT suitable for testing invalid inputs)// Test cases for bad index operations.// panic_cases!test_find_rfindtest_iter_foldsbrute_force_rotate_test_0brute_force_rotate_test_1select_nth_unstable_zero_lengthselect_nth_unstable_past_lengthmatches_one// test fallback implementations on all platformsmatches_beginmatches_endmatches_nulmatches_past_nulno_match_emptymatches_one_reversedmatches_begin_reversedmatches_end_reversedmatches_nul_reversedmatches_past_nul_reversedno_match_empty_reversedno_match_reversedeach_alignment_reversedtest_align_to_simpletest_align_to_zsttest_align_to_non_trivialtest_align_to_empty_midtest_align_to_mut_aliasingtest_slice_partition_dedup_bytest_slice_partition_dedup_emptytest_slice_partition_dedup_onetest_slice_partition_dedup_multiple_identtest_slice_partition_dedup_partialeqtest_copy_withintest_copy_within_panics_src_too_longtest_copy_within_panics_dest_too_longtest_copy_within_panics_src_invertedtest_copy_within_panics_src_out_of_boundstest_slice_run_destructorstest_const_from_reftest_slice_fill_with_uninitindex_a_equals_lenindex_b_equals_lenindex_a_greater_than_lenindex_b_greater_than_lenswap_panicsslice_split_first_chunk_mutslice_split_last_chunk_mutsplit_as_sliceslice_split_onceslice_rsplit_oncesplit_off_testsEMPTY_MAX// unused in Miriempty_max_mut// can't be a constant due to const mutability rules// Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)test_slice_from_ptr_range"slice len overflow"test_flatten_size_overflowtest_flatten_mut_size_overflowtest_get_disjoint_mut_normal_2test_get_disjoint_mut_normal_3test_get_disjoint_mut_emptytest_get_disjoint_mut_single_firsttest_get_disjoint_mut_single_lasttest_get_disjoint_mut_oob_nonemptytest_get_disjoint_mut_oob_emptytest_get_disjoint_mut_duplicatetest_get_disjoint_mut_range_oobtest_get_disjoint_mut_range_overlappingtest_get_disjoint_mut_range_empty_at_edgetest_slice_from_raw_parts_in_const// All `str` tests live in library/alloctests/tests/str.rspoll_constwaker_constnew_overflowfrom_mins_overflowfrom_hours_overflowfrom_days_overflowfrom_weeks_overflowfrom_nanos_u128_overflowconstructor_weeksconstructor_daysconstructor_hoursconstructor_minutesmicrossub_bad1sub_bad2correct_sumdebug_formatting_extreme_valuesdebug_formatting_secsdebug_formatting_millisdebug_formatting_microsdebug_formatting_nanosdebug_formatting_precision_zerodebug_formatting_precision_twodebug_formatting_paddingdebug_formatting_precision_highduration_constfrom_neg_zerotest_waker_gettersNOP_RAWWAKERNOP_WAKERNOP_CONTEXTtest_const_wakernop_waker// https://github.com/rust-lang/rust/issues/102012#issuecomment-1915282956// All `wtf8` tests live in library/alloctests/tests/wtf8.rsANDROID_SET_ABORT_MESSAGESetAbortMessageType// Forward the abort message to libc's android_set_abort_message. We try our best to populate the// message but as this function may already be called as part of a failed allocation, it might not be// possible to do so.// Some methods of core are on purpose avoided (such as try_reserve) as these rely on the correct// resolution of rust_eh_personality which is loosely defined in panic_abort.// Weakly resolve the symbol for android_set_abort_message. This function is only available// for API >= 21.panic_runtime__rust_panic_cleanup__rust_start_panic// "Leak" the payload and shim to the relevant abort on the platform in question.// In the past this module used to contain stubs for the personality// functions of various platforms, but these where removed when personality// functions were moved to std.personalities// This... is a bit of an oddity. The tl;dr; is that this is required to link// correctly, the longer explanation is below.// Right now the binaries of core/std that we ship are all compiled with// `-C panic=unwind`. This is done to ensure that the binaries are maximally// compatible with as many situations as possible. The compiler, however,// requires a "personality function" for all functions compiled with `-C// panic=unwind`. This personality function is hardcoded to the symbol// `rust_eh_personality` and is defined by the `eh_personality` lang item.// So... why not just define that lang item here? Good question! The way that// panic runtimes are linked in is actually a little subtle in that they're// "sort of" in the compiler's crate store, but only actually linked if another// isn't actually linked. This ends up meaning that both this crate and the// panic_unwind crate can appear in the compiler's crate store, and if both// define the `eh_personality` lang item then that'll hit an error.// To handle this the compiler only requires the `eh_personality` is defined if// the panic runtime being linked in is the unwinding runtime, and otherwise// it's not required to be defined (rightfully so). In this case, however, this// library just defines this symbol so there's at least some personality// somewhere.// Essentially this symbol is just defined to get wired up to core/std// binaries, but it should never be called as we don't link in an unwinding// runtime at all.//! Implementation of Rust panics via process aborts//! When compared to the implementation via unwinding, this crate is *much*//! simpler! That being said, it's not quite as versatile, but here goes!zkvm_set_abort_message// Forward the abort message to zkVM's sys_panic. This is implemented by RISC Zero's// platform crate which exposes system calls specifically for the zkVM.//! Unwinding for unsupported target.//! Stubs that simply abort for targets that don't support unwinding otherwise.TypeInfo// This matches the layout of std::type_info in C++"\x01_ZTVN10__cxxabiv117__class_type_infoE"CLASS_TYPE_INFO_VTABLE// The leading `\x01` byte here is actually a magical signal to LLVM to// *not* apply any other mangling like prefixing with a `_` character.// This symbol is the vtable used by C++'s `std::type_info`. Objects of type// `std::type_info`, type descriptors, have a pointer to this table. Type// descriptors are referenced by the C++ EH structures defined above and// that we construct below.// Note that the real size is larger than 3 usize, but we only need our// vtable to point to the third element."eh_catch_typeinfo"EXCEPTION_TYPE_INFO// std::type_info for a rust_panic classcanary// See `gcc.rs` on why this is present. We already have a static here so just use it.caught// This is necessary because C++ code can capture our exception with// std::exception_ptr and rethrow it multiple times, possibly even in// another thread.// This needs to be an Option because the object's lifetime follows C++// semantics: when catch_unwind moves the Box out of the exception it must// still leave the exception object in a valid state because its destructor// is still going to be called by __cxa_end_catch.Exception// NOTE(nbdd0121): The `canary` field is part of stable ABI.exception_cleanup__cxa_allocate_exception__cxa_begin_catch__cxa_end_catch__cxa_throw//! Unwinding for *emscripten* target.//! Whereas Rust's usual unwinding implementation for Unix platforms//! calls into the libunwind APIs directly, on Emscripten we instead//! call into the C++ unwinding APIs. This is just an expedience since//! Emscripten's runtime always implements those APIs and does not//! implement libunwind.// In case where multiple copies of std exist in a single process,// we use address of this static variable to distinguish an exception raised by// this copy and some other copy (which needs to be treated as foreign exception)._uwe_Unwind_Exception// NOTE(nbdd0121)// There is an ABI stability requirement on this struct.// The first two field must be `_Unwind_Exception` and `canary`,// as it may be accessed by a different version of the std with a different compiler.RUST_EXCEPTION_CLASS_Unwind_Exception_Class// Rust's exception class identifier.  This is used by personality routines to// determine whether the exception was thrown by their own runtime.//! Implementation of panics backed by libgcc/libunwind (in some form).//! For background on exception handling and stack unwinding please see//! "Exception Handling in LLVM" (llvm.org/docs/ExceptionHandling.html) and//! documents linked from it.//! These are also good reads://!  * <https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html>//!  * <https://nicolasbrailo.github.io/blog/projects_texts/13exceptionsunderthehood.html>//!  * <https://www.airs.com/blog/index.php?s=exception+frames>//! ## A brief summary//! Exception handling happens in two phases: a search phase and a cleanup//! phase.//! In both phases the unwinder walks stack frames from top to bottom using//! information from the stack frame unwind sections of the current process's//! modules ("module" here refers to an OS module, i.e., an executable or a//! dynamic library).//! For each stack frame, it invokes the associated "personality routine", whose//! address is also stored in the unwind info section.//! In the search phase, the job of a personality routine is to examine//! exception object being thrown, and to decide whether it should be caught at//! that stack frame. Once the handler frame has been identified, cleanup phase//! begins.//! In the cleanup phase, the unwinder invokes each personality routine again.//! This time it decides which (if any) cleanup code needs to be run for//! the current stack frame. If so, the control is transferred to a special//! branch in the function body, the "landing pad", which invokes destructors,//! frees memory, etc. At the end of the landing pad, control is transferred//! back to the unwinder and unwinding resumes.//! Once stack has been unwound down to the handler frame level, unwinding stops//! and the last personality routine transfers control to the catch block.__rust_abort// This is defined in std::rt//! Unwinding for *hermit* target.//! Right now we don't support this, so this is just stubs."gcc.rs"__rust_drop_panic/// Handler in std called when a panic object is dropped outside of/// `catch_unwind`.__rust_foreign_exception/// Handler in std called when a foreign exception is caught.// Entry point for raising an exception, just delegates to the platform-specific//! Implementation of panics via stack unwinding//! This crate is an implementation of panics in Rust using "most native" stack//! unwinding mechanism of the platform this is being compiled for. This//! essentially gets categorized into three buckets currently://! 1. MSVC targets use SEH in the `seh.rs` file.//! 2. Emscripten uses C++ exceptions in the `emcc.rs` file.//! 3. All other targets use libunwind/libgcc in the `gcc.rs` file.//! More documentation about each implementation can be found in the respective//! module.// The type of the payload that the Miri engine propagates through unwinding for us.// Must be pointer-sized.miri_start_unwind/// Miri-provided extern function to begin unwinding.//! Unwinding panics for Miri._TypeDescriptor// This needs to be an Option because we catch the exception by reference// and its destructor is executed by the C++ runtime. When we take the Box// out of the exception, we need to leave the exception in a valid state// for its destructor to run without double-dropping the Box.// We also construct this as None for copies of the exception.ptr_t// On 64-bit systems, SEH represents pointers as 32-bit offsets from `__ImageBase`.__ImageBasepmfnUnwindpForwardCompatpCatchableTypeArray_ThrowInfonCatchableTypesarrayOfCatchableTypes_CatchableTypeArraypTypethisDisplacement_PMDsizeOrOffsetcopyFunction_CatchableTypemdisppdispvdisppVFTable// Note that we intentionally ignore name mangling rules here: we don't want C++// to be able to catch Rust panics by simply declaring a `struct rust_panic`.// When modifying, make sure that the type name string exactly matches// the one used in `compiler/rustc_codegen_llvm/src/intrinsic.rs`.THROW_INFOCATCHABLE_TYPE_ARRAYCATCHABLE_TYPE"\x01??_7type_info@@6B@"TYPE_INFO_VTABLETYPE_DESCRIPTOR// This type descriptor is only used when throwing an exception. The catch part// is handled by the try intrinsic, which generates its own TypeDescriptor.// This is fine since the MSVC runtime uses string comparison on the type name// to match TypeDescriptors rather than pointer equality.define_cleanup// Destructor used if the C++ code decides to capture the exception and drop it// without propagating it. The catch part of the try intrinsic will set the// first word of the exception object to 0 so that it is skipped by the// destructor.// Note that x86 Windows uses the "thiscall" calling convention for C++ member// functions instead of the default "C" calling convention.// The exception_copy function is a bit special here: it is invoked by the MSVC// runtime under a try/catch block and the panic that we generate here will be// used as the result of the exception copy. This is used by the C++ runtime to// support capturing exceptions with std::exception_ptr, which we can't support// because Box<dyn Any> isn't clonable. Thus we throw an exception without data,// which the C++ runtime will attempt to copy, which will once again fail, and// a std::bad_exception instance ends up in the std::exception_ptr instance.// The lack of data doesn't matter because the exception will never be rethrown// - it is purely used to signal to the C++ runtime that copying failed.throw_exception//! Windows SEH//! On Windows (currently only on MSVC), the default exception handling//! mechanism is Structured Exception Handling (SEH). This is quite different//! than Dwarf-based exception handling (e.g., what other unix platforms use) in//! terms of compiler internals, so LLVM is required to have a good deal of//! extra support for SEH.//! In a nutshell, what happens here is://! 1. The `panic` function calls the standard Windows function//!    `_CxxThrowException` to throw a C++-like exception, triggering the//!    unwinding process.//! 2. All landing pads generated by the compiler use the personality function//!    `__CxxFrameHandler3`, a function in the CRT, and the unwinding code in//!    Windows will use this personality function to execute all cleanup code on//!    the stack.//! 3. All compiler-generated calls to `invoke` have a landing pad set as a//!    `cleanuppad` LLVM instruction, which indicates the start of the cleanup//!    routine. The personality (in step 2, defined in the CRT) is responsible//!    for running the cleanup routines.//! 4. Eventually the "catch" code in the `try` intrinsic (generated by the//!    compiler) is executed and indicates that control should come back to//!    Rust. This is done via a `catchswitch` plus a `catchpad` instruction in//!    LLVM IR terms, finally returning normal control to the program with a//!    `catchret` instruction.//! Some specific differences from the gcc-based exception handling are://! * Rust has no custom personality function, it is instead *always*//!   `__CxxFrameHandler3`. Additionally, no extra filtering is performed, so we//!   end up catching any C++ exceptions that happen to look like the kind we're//!   throwing. Note that throwing an exception into Rust is undefined behavior//!   anyway, so this should be fine.//! * We've got some data to transmit across the unwinding boundary,//!   specifically a `Box<dyn Any + Send>`. Like with Dwarf exceptions//!   these two pointers are stored as a payload in the exception itself. On//!   MSVC, however, there's no need for an extra heap allocation because the//!   call stack is preserved while filter functions are being executed. This//!   means that the pointers are passed directly to `_CxxThrowException` which//!   are then recovered in the filter function to be written to the stack frame//!   of the `try` intrinsic.//! [win64]: https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64//! [llvm]: https://llvm.org/docs/ExceptionHandling.html#background-on-windows-exceptions// First up, a whole bunch of type definitions. There's a few platform-specific// oddities here, and a lot that's just blatantly copied from LLVM. The purpose// of all this is to implement the `panic` function below through a call to// `_CxxThrowException`.// This function takes two arguments. The first is a pointer to the data we're// passing in, which in this case is our trait object. Pretty easy to find! The// next, however, is more complicated. This is a pointer to a `_ThrowInfo`// structure, and it generally is just intended to just describe the exception// being thrown.// Currently the definition of this type [1] is a little hairy, and the main// oddity (and difference from the online article) is that on 32-bit the// pointers are pointers but on 64-bit the pointers are expressed as 32-bit// offsets from the `__ImageBase` symbol. The `ptr_t` and `ptr!` macro in the// modules below are used to express this.// The maze of type definitions also closely follows what LLVM emits for this// sort of operation. For example, if you compile this C++ code on MSVC and emit// the LLVM IR://      #include <stdint.h>//      struct rust_panic {//          rust_panic(const rust_panic&);//          ~rust_panic();//          uint64_t x[2];//      };//      void foo() {//          rust_panic a = {0, 1};//          throw a;// That's essentially what we're trying to emulate. Most of the constant values// below were just copied from LLVM,// In any case, these structures are all constructed in a similar manner, and// it's just somewhat verbose for us.// [1]: https://www.geoffchappell.com/studies/msvc/language/predefined/dot_prod_scalar_0// This is your barebones dot product implementation:// Take 2 vectors, multiply them element wise and *then*// go along the resulting array and add up the result.// In the next example we will see if there//  is any difference to adding and multiplying in tandem.dot_prod_scalar_1// When dealing with SIMD, it is very important to think about the amount// of data movement and when it happens. We're going over simple computation examples here, and yet// it is not trivial to understand what may or may not contribute to performance// changes. Eventually, you will need tools to inspect the generated assembly and confirm your// hypothesis and benchmarks - we will mention them later on.// With the use of `fold`, we're doing a multiplication,// and then adding it to the sum, one element from both vectors at a time.dot_prod_simd_0// We now move on to the SIMD implementations: notice the following constructs:// `array_chunks::<4>`: mapping this over the vector will let use construct SIMD vectors// `f32x4::from_array`: construct the SIMD vector from a slice// `(a * b).reduce_sum()`: Multiply both f32x4 vectors together, and then reduce them.// This approach essentially uses SIMD to produce a vector of length N/4 of all the products,// and then add those with `sum()`. This is suboptimal.// TODO: ASCII diagramsdot_prod_simd_1// There's some simple ways to improve the previous code:// 1. Make a `zero` `f32x4` SIMD vector that we will be accumulating into// So that there is only one `sum()` reduction when the last `f32x4` has been processed// 2. Exploit Fused Multiply Add so that the multiplication, addition and sinking into the reduciton// happen in the same step.// If the arrays are large, minimizing the data shuffling will lead to great perf.// If the arrays are small, handling the remainder elements when the length isn't a multiple of 4// Can become a problem.std_floatStdFloat// A lot of knowledgeable use of SIMD comes from knowing specific instructions that are// available - let's try to use the `mul_add` instruction, which is the fused-multiply-add we were looking for.dot_prod_simd_2// Finally, we will write the same operation but handling the loop remainder.dot_prod_simd_3dot_prod_simd_4// Finally, we present an iterator version for handling remainders in a scalar fashion at the end of the loop.// Unfortunately, this is allocating 1 `XMM` register on the order of `~len(a)` - we'll see how we can get around it in the// next example.dot_prod_simd_5// This version allocates a single `XMM` register for accumulation, and the folds don't allocate on top of that.// Notice the use of `mul_add`, which can do a multiply and an add operation ber iteration.//! Code taken from the `packed_simd` crate.//! Run this code with `cargo test --example dot_product`.// Add these imports to use the stdsimd library// Gotta define our own 4x4 matrix since Rust doesn't ship multidim arrays yet :^)scalar_inv4x4simd_inv4x4//! 4x4 matrix inverse// Code ported from the `packed_simd` crate// Run this code with `cargo test --example matrix_inversion`// False positive?SOLAR_MASSDAYS_PER_YEARf64x4massN_BODIESBODIESoffset_momentumenergynbody/// Benchmarks game nbody code/// Taken from the `packed_simd` crate/// Run this benchmark with `cargo test --example nbody`approx_eq_f64// Good enough for demonstration purposes, not going for strictness here.mult_avmult_atvmult_atavspectral_normpluralmask_aliasi8x1i8x2i8x4i8x8i8x16i8x32i8x64i16x1i16x2i16x4i16x8i16x16i16x32i16x64i32x1i32x2i32x16i32x32i32x64i64x1i64x2i64x4i64x8i64x16i64x32i64x64isizex1isizex2isizex4isizex8isizex16isizex32isizex64u8x1u8x2u8x4u8x8u8x16u8x32u8x64u16x1u16x2u16x4u16x8u16x32u16x64u32x1u32x2u32x32u32x64u64x1u64x16u64x32u64x64usizex1usizex2usizex4usizex8usizex16usizex32usizex64f32x1f32x32f32x64f64x1f64x2f64x8f64x16f64x32f64x64mask8x1mask8x2mask8x4mask8x8mask8x16mask8x32mask8x64mask16x1mask16x2mask16x4mask16x8mask16x16mask16x32mask16x64mask32x1mask32x2mask32x4mask32x8mask32x16mask32x32mask32x64mask64x1mask64x2mask64x4mask64x8mask64x16mask64x32mask64x64masksizex1masksizex2masksizex4masksizex8masksizex16masksizex32masksizex64/// Cast vector elements to other types./// Implementing this trait asserts that the type is a valid vector element for the `simd_cast`/// or `simd_as` intrinsics.SimdCast/// Supporting trait for `Simd::cast`.  Typically doesn't need to be used directly.// Safety: primitive number types can be cast to other primitive number types/// A `Simd<T, N>` has a debug format like the one for `[T]`:/// # #![feature(portable_simd)]/// # #[cfg(feature = "as_crate")] use core_simd::simd::Simd;/// # #[cfg(not(feature = "as_crate"))] use core::simd::Simd;/// let floats = Simd::<f32, 4>::splat(-1.0);/// assert_eq!(format!("{:?}", [-1.0; 4]), format!("{:?}", floats));/// Specifies the number of lanes in a SIMD vector as a type.BITMASK_LEN/// The number of bytes in a bitmask with this many lanes./// Statically guarantees that a lane count is marked as supported./// This trait is *sealed*: the list of implementors below is total./// Users do not have the ability to mark additional `LaneCount<N>` values as supported./// Only SIMD vectors with supported lane counts are constructable.supported_lane_count// basically all items, really//! Portable SIMD module.MaskElement/// A mask where each lane is represented by a single bit."method returns a new mask and does not mutate the original value""method returns a new bool and does not mutate the original value"test_unchecked"method returns a new vector and does not mutate the original value"from_int_uncheckedto_bitmask_integerfrom_bitmask_integer// Reverse the least significant `n` bits of `self`.// (Remaining bits must be 0.)ReverseBits// Used for bitmask bit order workaroundimpl_reverse_bitsto_bitmask_implfrom_bitmask_impl//! Masks that take up full SIMD vector registers.mask_implmax_unsigned/// Not only does this seal the `MaskElement` trait, but these functions prevent other traits/// from bleeding into the parent bounds./// For example, `eq` could be provided by requiring `MaskElement: PartialEq`, but that would/// prevent us from ever removing that bound, or from implementing `MaskElement` on/// non-`PartialEq` types in the future./// Marker trait for types that may be used as SIMD mask elements./// Type must be a signed integer.impl_element/// A SIMD vector mask for `N` elements of width specified by `Element`./// Masks represent boolean inclusion/exclusion on a per-element basis./// The layout of this type is unspecified, and may change between platforms/// and/or Rust versions, and code should not assume that it is equivalent to/// `[T; N]`./// Constructs a mask by setting all elements to the given value./// Converts an array of bools to a SIMD mask./// Converts a SIMD mask to an array of bools./// Converts a vector of integers to a mask, where 0 represents `false` and -1/// represents `true`./// All elements must be either 0 or -1./// Panics if any element is not 0 or -1./// Converts the mask to a vector of integers, where 0 represents `false` and -1/// Converts the mask to a mask of any other element size./// Tests the value of the specified element./// Panics if `index` is greater than or equal to the number of elements in the vector./// Sets the value of the specified element./// Returns true if any element is set, or false otherwise./// Returns true if all elements are set, or false otherwise."method returns a new integer and does not mutate the original value"to_bitmask/// Creates a bitmask from a mask./// Each bit is set if the corresponding element in the mask is `true`./// If the mask contains more than 64 elements, the bitmask is truncated to the first 64.from_bitmask/// Creates a mask from a bitmask./// For each bit, if it is set, the corresponding element in the mask is set to `true`./// If the mask contains more than 64 elements, the remainder are set to `false`."method returns the index and does not mutate the original value"first_set/// Finds the index of the first set element./// # #[cfg(feature = "as_crate")] use core_simd::simd;/// # #[cfg(not(feature = "as_crate"))] use core::simd;/// # use simd::mask32x8;/// assert_eq!(mask32x8::splat(false).first_set(), None);/// assert_eq!(mask32x8::splat(true).first_set(), Some(0));/// let mask = mask32x8::from_array([false, true, false, false, true, false, false, true]);/// assert_eq!(mask.first_set(), Some(1));// vector/array conversion//! Types and traits associated with masking elements of vectors.//! Types representinglane_countswizzle_dyn// commutative binary op-assignment// commutative bit binary op-assignment// non-commutative binary op-assignmentassign_ops//! Assignment operators// non-commutative bit binary op-assignmentderef_lhsderef_rhsderef_ops'rhs'lhs//! This module hacks in "implicit deref" for Simd's operators.//! Ideally, Rust would take care of this itself,//! and method calls usually handle the LHS implicitly.//! But this is not the case with arithmetic ops.impl_splatted_shifts// In the past there were inference issues when generically splatting arguments.// Enumerate them instead.// Shift operations uniquely typically only have a scalar on the right-hand side.// Here, we implement shifts for scalar RHS arguments.// unary opsSimdPartialEqshift_scalarunsafe_basewrap_bitshift/// SAFETY: This macro should not be used for anything except Shl or Shr, and passed the appropriate shift intrinsic./// It handles performing a bitand in addition to calling the shift operator, so that the result/// is well-defined: LLVM can return a poison value if you shl, lshr, or ashr if `rhs >= <Int>::BITS`/// At worst, this will maybe add another instruction and cycle,/// at best, it may open up more optimization opportunities,/// or simply be elided entirely, especially for SIMD ISAs which default to this.// FIXME: Consider implementing this in cg_llvm instead?// cg_clif defaults to this, and scalar MIR shifts also default to wrappingint_divrem_guard/// SAFETY: This macro must only be used to impl Div or Rem and given the matching intrinsic./// It guards against LLVM's UB conditions for integer div or rem using masks and selects,/// thus guaranteeing a Rust value returns instead./// |                  | LLVM | Rust/// | :--------------: | :--- | :----------/// | N {/,%} 0        | UB   | panic!()/// | <$int>::MIN / -1 | UB   | <$int>::MIN/// | <$int>::MIN % -1 | UB   | 0for_base_typesfor_base_ops// A "TokenTree muncher": takes a set of scalar types `T = {};`// type parameters for the ops it implements, `Op::fn` names,// and a macro that expands into an expr, substituting in an intrinsic.// It passes that to for_base_types, which expands an impl for the types,// using the expanded expr in the function, and recurses with itself.// tl;dr impls a set of ops::{Traits} for a set of types// Integers can always accept add, mul, sub, bitand, bitor, and bitxor.// For all of these operations, simd_* intrinsics apply wrapping logic.// We don't need any special precautions here:// Floats always accept arithmetic ops, but may become NaN."method returns a new vector and does not mutate the original inputs"/// Choose elements from two vectors./// For each element in the mask, choose the corresponding element from `true_values` if/// that element mask is true, and `false_values` if that element mask is false./// # use core::simd::{Simd, Mask};/// let a = Simd::from_array([0, 1, 2, 3]);/// let b = Simd::from_array([4, 5, 6, 7]);/// let mask = Mask::from_array([true, false, false, true]);/// let c = mask.select(a, b);/// assert_eq!(c.to_array(), [0, 5, 6, 3]);"method returns a new mask and does not mutate the original inputs"select_mask/// Choose elements from two masks./// # use core::simd::Mask;/// let a = Mask::<i32, 4>::from_array([true, true, false, false]);/// let b = Mask::<i32, 4>::from_array([false, false, true, true]);/// let mask = Mask::<i32, 4>::from_array([true, false, false, true]);/// let c = mask.select_mask(a, b);/// assert_eq!(c.to_array(), [true, false, true, false]);SimdConstPtrSimdMutPtr/// The mask type returned by each comparison./// Test if each element is equal to the corresponding element in `other`./// Test if each element is not equal to the corresponding element in `other`./// Parallel `PartialEq`.impl_number/// Test if each element is less than the corresponding element in `other`./// Test if each element is less than or equal to the corresponding element in `other`./// Test if each element is greater than the corresponding element in `other`./// Test if each element is greater than or equal to the corresponding element in `other`.SimdPartialOrd/// Parallel `PartialOrd`.simd_max/// Returns the element-wise maximum with `other`./// Returns the element-wise minimum with `other`.simd_clamp/// Restrict each element to a certain interval./// For each element, returns `max` if `self` is greater than `max`, and `min` if `self` is/// less than `min`. Otherwise returns `self`./// Panics if `min > max` on any element.SimdOrd/// Parallel `Ord`.//! Traits for comparing and ordering vectors./// Mask type used for manipulating this SIMD vector type./// Scalar type contained by this SIMD vector type./// Bit representation of this SIMD vector type./// A SIMD vector with a different element type./// Performs elementwise conversion of this vector's elements to another SIMD-valid type./// This follows the semantics of Rust's `as` conversion for floats (truncating or saturating/// at the limits) for each element./// # use simd::prelude::*;/// let floats: Simd<f32, 4> = Simd::from_array([1.9, -4.5, f32::INFINITY, f32::NAN]);/// let ints = floats.cast::<i32>();/// assert_eq!(ints, Simd::from_array([1, -4, i32::MAX, 0]));/// // Formally equivalent, but `Simd::cast` can optimize better./// assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));/// // The float conversion does not round-trip./// let floats_again = ints.cast();/// assert_ne!(floats, floats_again);/// assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));/// Rounds toward zero and converts to the same-width integer type, assuming that/// the value is finite and fits in that type./// * Not be NaN/// If these requirements are infeasible or costly, consider using the safe function [cast],/// which saturates on conversion./// [cast]: Simd::cast/// Raw transmutation to an unsigned integer vector type with the/// same size and number of elements./// Raw transmutation from an unsigned integer vector type with the/// Produces a vector where every element has the absolute value of the/// equivalently-indexed element in `self`./// Takes the reciprocal (inverse) of each element, `1/x`./// Converts each element from radians to degrees./// Converts each element from degrees to radians./// Returns true for each element if it has a positive sign, including/// `+0.0`, `NaN`s with positive sign bit and positive infinity./// Returns true for each element if it has a negative sign, including/// `-0.0`, `NaN`s with negative sign bit and negative infinity./// Returns true for each element if its value is `NaN`./// Returns true for each element if its value is positive infinity or negative infinity./// Returns true for each element if its value is neither infinite nor `NaN`./// Returns true for each element if its value is subnormal./// Returns true for each element if its value is neither zero, infinite,/// subnormal, nor `NaN`./// Replaces each element with a number that represents its sign./// * `1.0` if the number is positive, `+0.0`, or `INFINITY`/// * `-1.0` if the number is negative, `-0.0`, or `NEG_INFINITY`/// * `NAN` if the number is `NAN`/// Returns each element with the magnitude of `self` and the sign of `sign`./// For any element containing a `NAN`, a `NAN` with the sign of `sign` is returned./// Returns the minimum of each element./// If one of the values is `NAN`, then the other value is returned./// Returns the maximum of each element./// Restrict each element to a certain interval unless it is NaN./// For each element in `self`, returns the corresponding element in `max` if the element is/// greater than `max`, and the corresponding element in `min` if the element is less/// than `min`.  Otherwise returns the element in `self`.reduce_sum/// Returns the sum of the elements of the vector./// let v = f32x2::from_array([1., 2.]);/// assert_eq!(v.reduce_sum(), 3.);reduce_product/// Reducing multiply.  Returns the product of the elements of the vector./// let v = f32x2::from_array([3., 4.]);/// assert_eq!(v.reduce_product(), 12.);/// Returns the maximum element in the vector./// Returns values based on equality, so a vector containing both `0.` and `-0.` may/// return either./// This function will not return `NaN` unless all elements are `NaN`./// assert_eq!(v.reduce_max(), 2.);/// // NaN values are skipped.../// let v = f32x2::from_array([1., f32::NAN]);/// assert_eq!(v.reduce_max(), 1.);/// // ...unless all values are NaN/// let v = f32x2::from_array([f32::NAN, f32::NAN]);/// assert!(v.reduce_max().is_nan());reduce_min/// Returns the minimum element in the vector./// let v = f32x2::from_array([3., 7.]);/// assert_eq!(v.reduce_min(), 3.);/// assert_eq!(v.reduce_min(), 1.);/// assert!(v.reduce_min().is_nan());SimdFloat/// Operations on SIMD vectors of floats.impl_traitSimdUint/// A SIMD vector of unsigned integers with the same element size./// This follows the semantics of Rust's `as` conversion for casting integers (wrapping to/// other integer types, and saturating to float types)./// Lanewise saturating add./// use core::i32::{MIN, MAX};/// let x = Simd::from_array([MIN, 0, 1, MAX]);/// let max = Simd::splat(MAX);/// let unsat = x + max;/// let sat = x.saturating_add(max);/// assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));/// assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));/// Lanewise saturating subtract./// let x = Simd::from_array([MIN, -2, -1, MAX]);/// let unsat = x - max;/// let sat = x.saturating_sub(max);/// assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));/// assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));/// Lanewise absolute value, implemented in Rust./// Every element becomes its absolute value./// let xs = Simd::from_array([MIN, MIN + 1, -5, 0]);/// assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));/// Lanewise absolute difference./// Every element becomes the absolute difference of `self` and `second`./// let a = Simd::from_array([MIN, MAX, 100, -100]);/// let b = Simd::from_array([MAX, MIN, -80, -120]);/// assert_eq!(a.abs_diff(b), Simd::from_array([u32::MAX, u32::MAX, 180, 20]));/// Lanewise saturating absolute value, implemented in Rust./// As abs(), except the MIN value becomes MAX instead of itself./// let xs = Simd::from_array([MIN, -2, 0, 3]);/// let unsat = xs.abs();/// let sat = xs.saturating_abs();/// assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));/// assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));/// Lanewise saturating negation, implemented in Rust./// As neg(), except the MIN value becomes MAX instead of itself./// let x = Simd::from_array([MIN, -2, 3, MAX]);/// let unsat = -x;/// let sat = x.saturating_neg();/// assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));/// assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));/// Returns true for each positive element and false if it is zero or negative./// Returns true for each negative element and false if it is zero or positive./// Returns numbers representing the sign of each element./// Returns the sum of the elements of the vector, with wrapping addition./// let v = i32x4::from_array([1, 2, 3, 4]);/// assert_eq!(v.reduce_sum(), 10);/// // SIMD integer addition is always wrapping/// let v = i32x4::from_array([i32::MAX, 1, 0, 0]);/// assert_eq!(v.reduce_sum(), i32::MIN);/// Returns the product of the elements of the vector, with wrapping multiplication./// assert_eq!(v.reduce_product(), 24);/// // SIMD integer multiplication is always wrapping/// let v = i32x4::from_array([i32::MAX, 2, 1, 1]);/// assert!(v.reduce_product() < i32::MAX);/// assert_eq!(v.reduce_max(), 4);/// assert_eq!(v.reduce_min(), 1);reduce_and/// Returns the cumulative bitwise "and" across the elements of the vector.reduce_or/// Returns the cumulative bitwise "or" across the elements of the vector.reduce_xor/// Returns the cumulative bitwise "xor" across the elements of the vector./// Reverses the byte order of each element./// Reverses the order of bits in each elemnent./// The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc./// Returns the number of ones in the binary representation of each element./// Returns the number of zeros in the binary representation of each element./// Returns the number of leading zeros in the binary representation of each element./// Returns the number of trailing zeros in the binary representation of each element./// Returns the number of leading ones in the binary representation of each element./// Returns the number of trailing ones in the binary representation of each element.SimdInt/// Operations on SIMD vectors of signed integers./// Wrapping negation./// Like [`u32::wrapping_neg`], all applications of this function will wrap, with the exception/// of `-0`./// use core::u32::MAX;/// let x = Simd::from_array([2, 1, 0, MAX]);/// assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));/// assert_eq!(sat, max);/// assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));/// assert_eq!(sat, Simd::splat(0));/// let a = Simd::from_array([0, MAX, 100, 20]);/// let b = Simd::from_array([MAX, 0, 80, 200]);/// assert_eq!(a.abs_diff(b), Simd::from_array([MAX, MAX, 20, 180]));/// Operations on SIMD vectors of unsigned integers.//! Traits for vectors with numeric elements.simd_swizzle//! The portable SIMD prelude.//! Includes important traits and types to be imported with a glob://! use std::simd::prelude::*;/// Vector of `usize` with the same number of elements./// Vector of `isize` with the same number of elements.CastPtr/// Vector of const pointers with the same number of elements.MutPtr/// Vector of mutable pointers to the same type./// Returns `true` for each element that is null./// Equivalent to calling [`pointer::cast`] on each element./// Equivalent to calling [`pointer::cast_mut`] on each element./// This method discards pointer semantic metadata, so the result cannot be/// directly cast into a valid pointer./// This method semantically discards *provenance* and/// *address-space* information. To properly restore that information, use [`Self::with_addr`]./// Equivalent to calling [`pointer::addr`] on each element./// Converts an address to a pointer without giving it any provenance./// non-zero-sized memory accesses with a no-provenance pointer are UB. No-provenance pointers/// are little more than a usize address in disguise./// This is different from [`Self::with_exposed_provenance`], which creates a pointer that picks up a/// previously exposed provenance./// Equivalent to calling [`core::ptr::without_provenance`] on each element./// Creates a new pointer with the given address./// This performs the same operation as a cast, but copies the *address-space* and/// *provenance* of `self` to the new pointer./// Equivalent to calling [`pointer::with_addr`] on each element./// Exposes the "provenance" part of the pointer for future use in/// [`Self::with_exposed_provenance`] and returns the "address" portion./// Converts an address back to a pointer, picking up a previously "exposed" provenance./// Equivalent to calling [`core::ptr::with_exposed_provenance`] on each element./// Calculates the offset from a pointer using wrapping arithmetic./// Equivalent to calling [`pointer::wrapping_offset`] on each element./// Equivalent to calling [`pointer::wrapping_add`] on each element./// Equivalent to calling [`pointer::wrapping_sub`] on each element./// Operations on SIMD vectors of constant pointers./// Vector of constant pointers to the same type./// Equivalent to calling [`pointer::cast_const`] on each element./// Equivalent to calling [`core::ptr::with_exposed_provenance_mut`] on each element./// Operations on SIMD vectors of mutable pointers.//! Traits for vectors of pointers./// Constructs a new SIMD vector by copying elements from selected elements in other vectors./// When swizzling one vector, elements are selected like [`Swizzle::swizzle`]./// When swizzling two vectors, elements are selected like [`Swizzle::concat_swizzle`]./// With a single SIMD vector, the const array specifies element indices in that vector:/// # use core::simd::{u32x2, u32x4, simd_swizzle};/// let v = u32x4::from_array([10, 11, 12, 13]);/// // Keeping the same size/// let r: u32x4 = simd_swizzle!(v, [3, 0, 1, 2]);/// assert_eq!(r.to_array(), [13, 10, 11, 12]);/// // Changing the number of elements/// let r: u32x2 = simd_swizzle!(v, [3, 1]);/// assert_eq!(r.to_array(), [13, 11]);/// With two input SIMD vectors, the const array specifies element indices in the concatenation of/// those vectors:/// # use simd::{u32x2, u32x4, simd_swizzle};/// let a = u32x4::from_array([0, 1, 2, 3]);/// let b = u32x4::from_array([4, 5, 6, 7]);/// let r: u32x4 = simd_swizzle!(a, b, [0, 1, 6, 7]);/// assert_eq!(r.to_array(), [0, 1, 6, 7]);/// let r: u32x2 = simd_swizzle!(a, b, [0, 4]);/// assert_eq!(r.to_array(), [0, 4]);INDEX/// Map from the elements of the input vector to the output vector./// Creates a new vector from the elements of `vector`./// Lane `i` of the output is `vector[Self::INDEX[i]]`.concat_swizzle/// Creates a new vector from the elements of `first` and `second`./// Lane `i` of the output is `concat[Self::INDEX[i]]`, where `concat` is the concatenation of/// `first` and `second`.swizzle_mask/// Creates a new mask from the elements of `mask`./// Element `i` of the output is `mask[Self::INDEX[i]]`.concat_swizzle_mask/// Creates a new mask from the elements of `first` and `second`./// Element `i` of the output is `concat[Self::INDEX[i]]`, where `concat` is the concatenation ofSwizzle/// Creates a vector from the elements of another vector./// Reverse the order of the elements in the vector.rotate_elements_left/// Rotates the vector such that the first `OFFSET` elements of the slice move to the end/// while the last `self.len() - OFFSET` elements move to the front. After calling `rotate_elements_left`,/// the element previously at index `OFFSET` will become the first element in the slice./// let x = a.rotate_elements_left::<3>();/// assert_eq!(x.to_array(), [3, 0, 1, 2]);/// let y = a.rotate_elements_left::<7>();/// assert_eq!(y.to_array(), [3, 0, 1, 2]);rotate_elements_right/// Rotates the vector such that the first `self.len() - OFFSET` elements of the vector move to/// the end while the last `OFFSET` elements move to the front. After calling `rotate_elements_right`,/// the element previously at index `self.len() - OFFSET` will become the first element in the slice./// let x = a.rotate_elements_right::<3>();/// assert_eq!(x.to_array(), [1, 2, 3, 0]);/// let y = a.rotate_elements_right::<7>();/// assert_eq!(y.to_array(), [1, 2, 3, 0]);shift_elements_left/// Shifts the vector elements to the left by `OFFSET`, filling in with/// `padding` from the right./// let x = a.shift_elements_left::<3>(255);/// assert_eq!(x.to_array(), [3, 255, 255, 255]);/// let y = a.shift_elements_left::<7>(255);/// assert_eq!(y.to_array(), [255, 255, 255, 255]);shift_elements_right/// Shifts the vector elements to the right by `OFFSET`, filling in with/// `padding` from the left./// let x = a.shift_elements_right::<3>(255);/// assert_eq!(x.to_array(), [255, 255, 255, 0]);/// let y = a.shift_elements_right::<7>(255);/// Interleave two vectors./// The resulting vectors contain elements taken alternatively from `self` and `other`, first/// filling the first result, and then the second./// The reverse of this operation is [`Simd::deinterleave`]./// # use core::simd::Simd;/// let (x, y) = a.interleave(b);/// assert_eq!(x.to_array(), [0, 4, 1, 5]);/// assert_eq!(y.to_array(), [2, 6, 3, 7]);deinterleave/// Deinterleave two vectors./// The first result takes every other element of `self` and then `other`, starting with/// the first element./// The second result takes every other element of `self` and then `other`, starting with/// the second element./// The reverse of this operation is [`Simd::interleave`]./// # use simd::Simd;/// let a = Simd::from_array([0, 4, 1, 5]);/// let b = Simd::from_array([2, 6, 3, 7]);/// let (x, y) = a.deinterleave(b);/// assert_eq!(x.to_array(), [0, 1, 2, 3]);/// assert_eq!(y.to_array(), [4, 5, 6, 7]);/// Resize a vector./// If `M` > `N`, extends the length of a vector, setting the new elements to `value`./// If `M` < `N`, truncates the vector to the first `M` elements./// # use simd::u32x4;/// let x = u32x4::from_array([0, 1, 2, 3]);/// assert_eq!(x.resize::<8>(9).to_array(), [0, 1, 2, 3, 9, 9, 9, 9]);/// assert_eq!(x.resize::<2>(9).to_array(), [0, 1]);/// Extract a vector from another vector./// assert_eq!(x.extract::<1, 2>().to_array(), [1, 2]);/// Reverse the order of the elements in the mask./// Rotates the mask such that the first `OFFSET` elements of the slice move to the end/// Rotates the mask such that the first `self.len() - OFFSET` elements of the mask move to/// Shifts the mask elements to the left by `OFFSET`, filling in with/// Shifts the mask elements to the right by `OFFSET`, filling in with/// Interleave two masks./// The resulting masks contain elements taken alternatively from `self` and `other`, first/// The reverse of this operation is [`Mask::deinterleave`]./// # use simd::mask32x4;/// let a = mask32x4::from_array([false, true, false, true]);/// let b = mask32x4::from_array([false, false, true, true]);/// assert_eq!(x.to_array(), [false, false, true, false]);/// assert_eq!(y.to_array(), [false, true, true, true]);/// Deinterleave two masks./// The reverse of this operation is [`Mask::interleave`]./// assert_eq!(x.to_array(), [false, false, false, true]);/// assert_eq!(y.to_array(), [true, true, false, true]);/// Resize a mask./// If `M` > `N`, extends the length of a mask, setting the new elements to `value`./// If `M` < `N`, truncates the mask to the first `M` elements./// let x = mask32x4::from_array([false, true, true, false]);/// assert_eq!(x.resize::<8>(true).to_array(), [false, true, true, false, true, true, true, true]);/// assert_eq!(x.resize::<2>(true).to_array(), [false, true]);/// assert_eq!(x.extract::<1, 2>().to_array(), [true, true]);/// Swizzle a vector of bytes according to the index vector./// Indices within range select the appropriate byte./// Indices "out of bounds" instead select 0./// Note that the current implementation is selected during build-time/// of the standard library, so `cargo build -Zbuild-std` may be necessary/// to unlock better performance, especially for larger vectors./// A planned compiler improvement will enable using `#[target_feature]` instead.avx2_pshufb/// "vpshufb like it was meant to be" on AVX2/// This requires AVX2 to worktransize/// This sets up a call to an architecture-specific function, and in doing so/// it persuades rustc that everything is the correct size. Which it is./// This would not be needed if one could convince Rust that, by matching on N,/// N is that value, and thus it would be valid to substitute e.g. 16./// The correctness of this function hinges on the sizes agreeing in actuality.zeroing_idxs/// Make indices that yield 0 for x86/// This type, reinterpreted as bytes./// Returns the memory representation of this integer as a byte array in native byte/// Returns the memory representation of this integer as a byte array in big-endian/// (network) byte order./// Returns the memory representation of this integer as a byte array in little-endian/// byte order./// Creates a native endian integer value from its memory representation as a byte array/// in native endianness./// Creates an integer value from its representation as a byte array in big endian./// Creates an integer value from its representation as a byte array in little endian./// Converts SIMD vectors to vectors of bytesimpl_to_bytes/// A SIMD vector with the shape of `[T; N]` but the operations of `T`./// `Simd<T, N>` supports the operators (+, *, etc.) that `T` does in "elementwise" fashion./// These take the element at each index from the left-hand side and right-hand side,/// perform the operation, then return the result in the same index in a vector of equal size./// However, `Simd` differs from normal iteration and normal arrays:/// - `Simd<T, N>` executes `N` operations in a single step with no `break`s/// - `Simd<T, N>` can have an alignment greater than `T`, for better mechanical sympathy/// By always imposing these constraints on `Simd`, it is easier to compile elementwise operations/// into machine instructions that can themselves be executed in parallel./// # use core::simd::{Simd};/// # use core::array;/// let a: [i32; 4] = [-2, 0, 2, 4];/// let b = [10, 9, 8, 7];/// let sum = array::from_fn(|i| a[i] + b[i]);/// let prod = array::from_fn(|i| a[i] * b[i]);/// // `Simd<T, N>` implements `From<[T; N]>`/// let (v, w) = (Simd::from(a), Simd::from(b));/// // Which means arrays implement `Into<Simd<T, N>>`./// assert_eq!(v + w, sum.into());/// assert_eq!(v * w, prod.into());/// `Simd` with integer elements treats operators as wrapping, as if `T` was [`Wrapping<T>`]./// Thus, `Simd` does not implement `wrapping_add`, because that is the default behavior./// This means there is no warning on overflows, even in "debug" builds./// For most applications where `Simd` is appropriate, it is "not a bug" to wrap,/// and even "debug builds" are unlikely to tolerate the loss of performance./// You may want to consider using explicitly checked arithmetic if such is required./// Division by zero on integers still causes a panic, so/// you may want to consider using `f32` or `f64` if that is unacceptable./// [`Wrapping<T>`]: core::num::Wrapping/// `Simd<T, N>` has a layout similar to `[T; N]` (identical "shapes"), with a greater alignment./// `[T; N]` is aligned to `T`, but `Simd<T, N>` will have an alignment based on both `T` and `N`./// Thus it is sound to [`transmute`] `Simd<T, N>` to `[T; N]` and should optimize to "zero cost",/// but the reverse transmutation may require a copy the compiler cannot simply elide./// # ABI "Features"/// Due to Rust's safety guarantees, `Simd<T, N>` is currently passed and returned via memory,/// not SIMD registers, except as an optimization. Using `#[inline]` on functions that accept/// `Simd<T, N>` or return it is recommended, at the cost of code generation time, as/// inlining SIMD-using functions can omit a large function prolog or epilog and thus/// improve both speed and code size. The need for this may be corrected in the future./// Using `#[inline(always)]` still requires additional care./// # Safe SIMD with Unsafe Rust/// Operations with `Simd` are typically safe, but there are many reasons to want to combine SIMD with `unsafe` code./// Care must be taken to respect differences between `Simd` and other types it may be transformed into or derived from./// In particular, the layout of `Simd<T, N>` may be similar to `[T; N]`, and may allow some transmutations,/// but references to `[T; N]` are not interchangeable with those to `Simd<T, N>`./// Thus, when using `unsafe` Rust to read and write `Simd<T, N>` through [raw pointers], it is a good idea to first try with/// [`read_unaligned`] and [`write_unaligned`]. This is because:/// - [`read`] and [`write`] require full alignment (in this case, `Simd<T, N>`'s alignment)/// - `Simd<T, N>` is often read from or written to [`[T]`](slice) and other types aligned to `T`/// - combining these actions violates the `unsafe` contract and explodes the program into///   a puff of **undefined behavior**/// - the compiler can implicitly adjust layouts to make unaligned reads or writes fully aligned///   if it sees the optimization/// - most contemporary processors with "aligned" and "unaligned" read and write instructions///   exhibit no performance difference if the "unaligned" variant is aligned at runtime/// Less obligations mean unaligned reads and writes are less likely to make the program unsound,/// and may be just as fast as stricter alternatives./// When trying to guarantee alignment, [`[T]::as_simd`][as_simd] is an option for/// converting `[T]` to `[Simd<T, N>]`, and allows soundly operating on an aligned SIMD body,/// but it may cost more time when handling the scalar head and tail./// If these are not enough, it is most ideal to design data structures to be already aligned/// to `align_of::<Simd<T, N>>()` before using `unsafe` Rust to read or write./// Other ways to compensate for these facts, like materializing `Simd` to or from an array first,/// are handled by safe methods like [`Simd::from_array`] and [`Simd::from_slice`]./// [`transmute`]: core::mem::transmute/// [raw pointers]: pointer/// [`read_unaligned`]: pointer::read_unaligned/// [`write_unaligned`]: pointer::write_unaligned/// [`read`]: pointer::read/// [`write`]: pointer::write/// [as_simd]: slice::as_simd// NOTE: Accessing the inner array directly in any way (e.g. by using the `.0` field syntax) or// directly constructing an instance of the type (i.e. `let vector = Simd(array)`) should be// avoided, as it will likely become illegal on `#[repr(simd)]` structs in the future. It also// causes rustc to emit illegal LLVM IR in some cases./// Number of elements in this vector./// Returns the number of elements in this SIMD vector./// let v = u32x4::splat(0);/// Constructs a new SIMD vector with all elements set to the given value./// let v = u32x4::splat(8);/// assert_eq!(v.as_array(), &[8, 8, 8, 8]);/// Returns an array reference containing the entire SIMD vector./// # use core::simd::{Simd, u64x4};/// let v: u64x4 = Simd::from_array([0, 1, 2, 3]);/// assert_eq!(v.as_array(), &[0, 1, 2, 3]);/// Returns a mutable array reference containing the entire SIMD vector./// Loads a vector from an array of `T`./// This function is necessary since `repr(simd)` has padding for non-power-of-2 vectors (at the time of writing)./// With padding, `read_unaligned` will read past the end of an array of N elements./// Reading `ptr` must be safe, as if by `<*const [T; N]>::read`./// Store a vector to an array of `T`./// See `load` as to why this function is necessary./// Writing to `ptr` must be safe, as if by `<*mut [T; N]>::write`./// Converts an array to a SIMD vector./// Converts a SIMD vector to an array./// Converts a slice to a SIMD vector containing `slice[..N]`./// Panics if the slice's length is less than the vector's `Simd::N`./// Use `load_or_default` for an alternative that does not panic./// # use core::simd::u32x4;/// let source = vec![1, 2, 3, 4, 5, 6];/// let v = u32x4::from_slice(&source);/// assert_eq!(v.as_array(), &[1, 2, 3, 4]);/// Writes a SIMD vector to the first `N` elements of a slice./// let mut dest = vec![0; 6];/// let v = u32x4::from_array([1, 2, 3, 4]);/// v.copy_to_slice(&mut dest);/// assert_eq!(&dest, &[1, 2, 3, 4, 0, 0]);load_or_default/// Reads contiguous elements from `slice`. Elements are read so long as they're in-bounds for/// the `slice`. Otherwise, the default value for the element type is returned./// let vec: Vec<i32> = vec![10, 11];/// let result = Simd::<i32, 4>::load_or_default(&vec);/// assert_eq!(result, Simd::from_array([10, 11, 0, 0]));/// the `slice`. Otherwise, the corresponding value from `or` is passed through./// let or = Simd::from_array([-5, -4, -3, -2]);/// let result = Simd::load_or(&vec, or);/// assert_eq!(result, Simd::from_array([10, 11, -3, -2]));load_select_or_default/// Reads contiguous elements from `slice`. Each element is read from memory if its/// corresponding element in `enable` is `true`./// When the element is disabled or out of bounds for the slice, that memory location/// is not accessed and the corresponding value from `or` is passed through./// # use simd::{Simd, Mask};/// let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];/// let enable = Mask::from_array([true, true, false, true]);/// let result = Simd::load_select(&vec, enable, or);/// assert_eq!(result, Simd::from_array([10, 11, -3, 13]));load_selectload_select_unchecked/// When the element is disabled, that memory location is not accessed and the corresponding/// value from `or` is passed through./// Enabled loads must not exceed the length of `slice`.load_select_ptr/// Reads contiguous elements starting at `ptr`. Each element is read from memory if its/// Enabled `ptr` elements must be safe to read as if by `std::ptr::read`.gather_or/// Reads from potentially discontiguous indices in `slice` to construct a SIMD vector./// If an index is out-of-bounds, the element is instead selected from the `or` vector./// let idxs = Simd::from_array([9, 3, 0, 5]);  // Note the index that is out-of-bounds/// let alt = Simd::from_array([-5, -4, -3, -2]);/// let result = Simd::gather_or(&vec, idxs, alt);/// assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));gather_or_default/// Reads from indices in `slice` to construct a SIMD vector./// If an index is out-of-bounds, the element is set to the default given by `T: Default`./// let result = Simd::gather_or_default(&vec, idxs);/// assert_eq!(result, Simd::from_array([0, 13, 10, 15]));gather_select/// The mask `enable`s all `true` indices and disables all `false` indices./// If an index is disabled or is out-of-bounds, the element is selected from the `or` vector./// let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index/// let enable = Mask::from_array([true, true, true, false]); // Includes a masked element/// let result = Simd::gather_select(&vec, enable, idxs, alt);/// assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));gather_select_unchecked/// If an index is disabled, the element is selected from the `or` vector./// Calling this function with an `enable`d out-of-bounds index is *[undefined behavior]*/// even if the resulting value is not used./// # use simd::{Simd, cmp::SimdPartialOrd, Mask};/// // If this mask was used to gather, it would be unsound. Let's fix that./// let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));/// // The out-of-bounds index has been masked, so it's safe to gather now./// let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };gather_ptr/// Reads elementwise from pointers into a SIMD vector./// Each read must satisfy the same conditions as [`core::ptr::read`]./// let values = [6, 2, 4, 9];/// let offsets = Simd::from_array([1, 0, 0, 3]);/// let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);/// let gathered = unsafe { Simd::gather_ptr(source) };/// assert_eq!(gathered, Simd::from_array([2, 6, 6, 9]));gather_select_ptr/// Conditionally read elementwise from pointers into a SIMD vector./// The mask `enable`s all `true` pointers and disables all `false` pointers./// If a pointer is disabled, the element is selected from the `or` vector,/// and no read is performed./// Enabled elements must satisfy the same conditions as [`core::ptr::read`]./// let gathered = unsafe { Simd::gather_select_ptr(source, enable, Simd::splat(0)) };/// assert_eq!(gathered, Simd::from_array([2, 6, 0, 9]));store_select/// Conditionally write contiguous elements to `slice`. The `enable` mask controls/// which elements are written, as long as they're in-bounds of the `slice`./// If the element is disabled or out of bounds, no memory access to that location/// let mut arr = [0i32; 4];/// let write = Simd::from_array([-5, -4, -3, -2]);/// let enable = Mask::from_array([false, true, true, true]);/// write.store_select(&mut arr[..3], enable);/// assert_eq!(arr, [0, -4, -3, 0]);store_select_unchecked/// which elements are written./// Every enabled element must be in bounds for the `slice`./// unsafe { write.store_select_unchecked(&mut arr, enable) };/// assert_eq!(arr, [0, -4, -3, -2]);store_select_ptr/// Conditionally write contiguous elements starting from `ptr`./// The `enable` mask controls which elements are written./// When disabled, the memory location corresponding to that element is not accessed./// Memory addresses for element are calculated [`pointer::wrapping_offset`] and/// each enabled element must satisfy the same conditions as [`core::ptr::write`]./// Writes the values in a SIMD vector to potentially discontiguous indices in `slice`./// If an index is out-of-bounds, the write is suppressed without panicking./// If two elements in the scattered vector would write to the same index/// only the last element is guaranteed to actually be written./// let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];/// let idxs = Simd::from_array([9, 3, 0, 0]); // Note the duplicate index./// let vals = Simd::from_array([-27, 82, -41, 124]);/// vals.scatter(&mut vec, idxs); // two logical writes means the last wins./// assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);scatter_select/// Writes values from a SIMD vector to multiple potentially discontiguous indices in `slice`./// If an enabled index is out-of-bounds, the write is suppressed without panicking./// If two enabled elements in the scattered vector would write to the same index,/// let idxs = Simd::from_array([9, 3, 0, 0]); // Includes an out-of-bounds index/// vals.scatter_select(&mut vec, enable, idxs); // The last write is masked, thus omitted./// assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);scatter_select_unchecked/// Calling this function with an enabled out-of-bounds index is *[undefined behavior]*,/// and may lead to memory corruption./// let idxs = Simd::from_array([9, 3, 0, 0]);/// let enable = Mask::from_array([true, true, true, false]); // Masks the final index/// // If this mask was used to scatter, it would be unsound. Let's fix that./// // We have masked the OOB index, so it's safe to scatter now./// unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }/// // The second write to index 0 was masked, thus omitted.scatter_ptr/// Writes pointers elementwise into a SIMD vector./// Each write must satisfy the same conditions as [`core::ptr::write`]./// # use simd::{Simd, ptr::SimdMutPtr};/// let mut values = [0; 4];/// let offset = Simd::from_array([3, 2, 1, 0]);/// let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);/// unsafe { Simd::from_array([6, 3, 5, 7]).scatter_ptr(ptrs); }/// assert_eq!(values, [7, 5, 3, 6]);scatter_select_ptr/// Conditionally write pointers elementwise into a SIMD vector./// If a pointer is disabled, the write to its pointee is skipped./// Enabled pointers must satisfy the same conditions as [`core::ptr::write`]./// # use simd::{Mask, Simd, ptr::SimdMutPtr};/// let enable = Mask::from_array([true, true, false, false]);/// unsafe { Simd::from_array([6, 3, 5, 7]).scatter_select_ptr(ptrs, enable); }/// assert_eq!(values, [0, 0, 3, 6]);/// Lexicographic order. For the SIMD elementwise minimum and maximum, use simd_min and simd_max instead.// array references// slice references/// The mask element type corresponding to this element type./// Marker trait for types that may be used as SIMD vector elements./// This trait, when implemented, asserts the compiler can monomorphize/// `#[repr(simd)]` structs with the marked type as an element./// Strictly, it is valid to impl if the vector will not be miscompiled./// Practically, it is user-unfriendly to impl it if the vector won't compile,/// even when no soundness guarantees are broken by allowing the user to try.// Safety: u8 is a valid SIMD element type, and is supported by this API// Safety: u16 is a valid SIMD element type, and is supported by this API// Safety: u32 is a valid SIMD element type, and is supported by this API// Safety: u64 is a valid SIMD element type, and is supported by this API// Safety: usize is a valid SIMD element type, and is supported by this API// Safety: i8 is a valid SIMD element type, and is supported by this API// Safety: i16 is a valid SIMD element type, and is supported by this API// Safety: i32 is a valid SIMD element type, and is supported by this API// Safety: i64 is a valid SIMD element type, and is supported by this API// Safety: isize is a valid SIMD element type, and is supported by this API// Safety: f32 is a valid SIMD element type, and is supported by this API// Safety: f64 is a valid SIMD element type, and is supported by this API// Safety: (thin) const pointers are valid SIMD element types, and are supported by this API// Fat pointers may be supported in the future.// Safety: (thin) mut pointers are valid SIMD element types, and are supported by this APIlane_indicesmask_up_tofrom_transmutesimd32p32p64__m512__m512d/// Provides implementations of `From<$a> for $b` and `From<$b> for $a` that transmutes the value./// Conversions to x86's SIMD types.// Test that we handle all our "auto-deref" cases correctly.cast_types// The hypothesis is that widening conversions aren't terribly interesting.ops_macrosimpl_float_testsimpl_signed_testsmask_ops_implmask_testsmask_macrosmask8mask16mask32mask64masksizemasked_load_storetest_mask_apimask_apiimpl_unary_op_test/// Implements a test on a unary operation using proptest./// Compares the vector operation to the equivalent scalar operation.impl_binary_op_test/// Implements a test on a binary operation using proptest.impl_binary_checked_op_test/// Like `impl_binary_op_test`, but allows providing a function for rejecting particular inputs/// (like the `proptest_assume` macro).impl_common_integer_tests/// Implement tests for signed integers.impl_unsigned_tests/// Implement tests for unsigned integers./// Implement tests for floating point numbers.common_teststest_lanesfloat_rounding_testinterleave_one// portable-simd#298make_runnerprop_assert_biteqswizzle_dyn_scalar_verScalarResultmatch_simd_with_fallbackSwizzleStrategyBitEqtest_swizzles_2test_runnerTestCaseResultswizzled_strategyUniformArrayStrategybyte_convert/// Elementwise fused multiply-add. Computes `(self * a) + b` with only one rounding error,/// yielding a more accurate result than an unfused multiply-add./// Using `mul_add` *may* be more performant than an unfused multiply-add if the target/// architecture has a dedicated `fma` CPU instruction.  However, this is not always/// true, and will be heavily dependent on designing algorithms with specific target/// hardware in mind./// Produces a vector where every element has the square root value/// of the equivalently-indexed element in `self`/// Produces a vector where every element has the sine of the value/// in the equivalently-indexed element in `self`./// Produces a vector where every element has the cosine of the value/// Produces a vector where every element has the exponential (base e) of the value/// Produces a vector where every element has the exponential (base 2) of the value/// Produces a vector where every element has the natural logarithm of the value/// Produces a vector where every element has the logarithm with respect to an arbitrary/// in the equivalently-indexed elements in `self` and `base`./// Produces a vector where every element has the base-2 logarithm of the value/// Produces a vector where every element has the base-10 logarithm of the value/// Returns the smallest integer greater than or equal to each element./// Returns the largest integer value less than or equal to each element./// Rounds to the nearest integer value. Ties round toward zero./// Returns the floating point's integer value, with its fractional part removed./// Returns the floating point's fractional value, with its integer part removed./// This trait provides a possibly-temporary implementation of float functions/// that may, in the absence of hardware support, canonicalize to calling an/// operating system's `math.h` dynamically-loaded library (also known as a/// shared object). As these conditionally require runtime support, they/// should only appear in binaries built assuming OS support: `std`./// However, there is no reason SIMD types, in general, need OS support,/// as for many architectures an embedded binary may simply configure that/// support itself. This means these types must be visible in `core`/// but have these functions available in `std`./// [`f32`] and [`f64`] achieve a similar trick by using "lang items", but/// due to compiler limitations, it is harder to implement this approach for/// abstract data types like [`Simd`]. From that need, this trait is born./// It is possible this trait will be replaced in some manner in the future,/// when either the compiler or its supporting runtime functions are improved./// For now this trait is available to permit experimentation with SIMD float/// operations that may lack hardware support, such as `mul_add`.unary_testbinary_testternary_testimpl_testsNewTreeValueTreeTestRunner"strategies do nothing unless used"shrinkerlast_shrinkerArrayValueTreenew_treecomplicate//! Generic-length array strategy.// Adapted from proptest's array code// Copyright 2017 Jason Lingleimpl_integer_biteqimpl_float_biteqBitEqWrapperBitEqEitherWrapper//! Compare numeric types by exact bit value.FlushSubnormalsdefault_strategy/// Specifies the default strategy for testing a type./// This strategy should be what "makes sense" to test.impl_numtest_1/// Test a function that takes a single value.test_2/// Test a function that takes two values.test_3test_unary_elementwise/// Test a unary vector function against a unary scalar function, applied elementwise.test_unary_elementwise_flush_subnormals/// Where subnormals are flushed, use approximate equality.test_unary_mask_elementwiseScalar1Scalar2Vector1Vector2test_binary_elementwise/// Test a binary vector function against a binary scalar function, applied elementwise.test_binary_elementwise_flush_subnormalstest_binary_mask_elementwisetest_binary_scalar_rhs_elementwise/// Test a binary vector-scalar function against a binary scalar function, applied elementwise.test_binary_scalar_lhs_elementwiseScalar3Vector3test_ternary_elementwise/// Test a ternary vector function against a ternary scalar function, applied elementwise.test_lanes_helper/// Expand a const-generic test into separate tests for each possible lane count.test_lanes_panic/// Expand a const-generic `#[should_panic]` test into separate tests for each possible lane count.impl_elsein_buggy_qemu/// AltiVec should flush subnormal inputs to zero, but QEMU seems to only flush outputs./// https://gitlab.com/qemu-project/qemu/-/issues/1779flush_in//! Strategies for `u128` and `i128`, since proptest doesn't provide them for the wasm target.PAGE// The arenas start with PAGE-sized chunks, and then each new chunk is twice as// big as its predecessor, up until we reach HUGE_PAGE-sized chunks, whereupon// we stop growing. This scales well, from arenas that are barely used up to// arenas that are used for 100s of MiBs. Note also that the chosen sizes match// the usual sizes of pages and huge pages on Linux.HUGE_PAGE/// A minimal arena allocator inspired by `rustc_arena::DroplessArena`./// This is unfortunately a complete re-implementation rather than a dependency/// as it is difficult to depend on crates from within `proc_macro`, due to it/// being built at the same time as `std`./// This arena doesn't have support for allocating anything other than byte/// slices, as that is all that is necessary./// Add a new chunk with at least `additional` free bytes.alloc_raw_without_grow/// Allocates a byte slice with specified size from the current memory/// chunk. Returns `None` if there is no free space left to satisfy thealloc_rawalloc_str// arena allocator//! A minimal arena allocator inspired by `rustc_arena::DroplessArena`.//! This is unfortunately a minimal re-implementation rather than a dependency//! as it is difficult to depend on crates from within `proc_macro`, due to it//! being built at the same time as `std`.extend_from_array// We have the array method separate from extending from a slice. This is// because in the case of small arrays, codegen can be more efficient// (avoiding a memmove call). With extend_from_slice, LLVM at least// currently is not able to make that optimization.//! Buffer management for same-process client<->server communication.define_client_handleswith_api_handle_typesFreeFunctionsHandleCountersCOUNTERSdef_sitedefine_client_sidewith_apiinjected_env_vartrack_env_vartrack_pathliteral_from_strexpand_exprfrom_token_treeconcat_treesconcat_streamsinto_treeslocal_filesave_spanrecover_proc_macro_spannormalize_and_validate_identcached_buffer/// Reusable buffer (only `clear`-ed, never shrunk), primarily/// used for making requests./// Server-side function that the client uses to make requests.ExpnGlobals/// Provided globals for this macro expansion.BRIDGE_STATE'bridgehandle_countersBridgeConfig/// A client-side RPC entry-point, which may be using a different `proc_macro`/// from the one used by the server, but can be invoked compatibly./// Note that the (phantom) `I` ("input") and `O` ("output") type parameters/// decorate the `Client<I, O>` with the RPC "interface" of the entry-point, but/// do not themselves participate in ABI, at all, only facilitate type-checking./// E.g. `Client<TokenStream, TokenStream>` is the common proc macro interface,/// used for `#[proc_macro] fn foo(input: TokenStream) -> TokenStream`,/// indicating that the RPC input and output will be serialized token streams,/// and forcing the use of APIs that take/return `S::TokenStream`, server-side.maybe_install_panic_hookrun_client/// Client-side helper for handling client panics, entering the bridge,/// deserializing input and serializing output.// FIXME(eddyb) maybe replace `Bridge::enter` with this?expand1expand2trait_nameCustomDerivecustom_derivebang//! Client-side types.// FIXME(eddyb) generate these impls by pattern-matching on the// names of methods - also could use the presence of `fn drop`// to distinguish between 'owned and 'interned, above.// Alternatively, special "modes" could be listed of types in with_api// instead of pattern matching on methods, here and in server decl.// Prevent Send and Sync impls.// The `'a` lifetime parameter represents the lifetime of `Env`.//! Closure type (equivalent to `&mut dyn FnMut(A) -> R`) that's `repr(C)`./// A speedy hash algorithm for use within rustc. The hashmap in alloc by/// default uses SipHash which isn't quite as speedy as we want. In the compiler/// we're not really worried about DOS attempts, so we use a fast//! This is a copy of the `rustc_hash` crate, adapted to work as a module.//! If in the future it becomes more reasonable to add dependencies to//! `proc_macro`, this module should be removed and replaced with a dependency//! on the `rustc_hash` crate.fxhashOwnedStore/// A store that associates values of type `T` with numeric handles. A value can/// be looked up using its handle.internerInternedStore/// Like `OwnedStore`, but avoids storing any value more than once.//! Server-side handles and storage for per-handle data./// Higher-order macro describing the server RPC API, allowing automatic/// generation of type-safe Rust APIs, both client-side and server-side./// `with_api!(MySelf, my_self, my_macro)` expands to:/// ```rust,ignore (pseudo-code)/// my_macro! {///     Literal {///         fn character(ch: char) -> MySelf::Literal;///         fn span(my_self: &MySelf::Literal) -> MySelf::Span;///         fn set_span(my_self: &mut MySelf::Literal, span: MySelf::Span);/// The first two arguments serve to customize the arguments names/// and argument/return types, to enable several different usecases:/// If `my_self` is just `self`, then each `fn` signature can be used/// as-is for a method. If it's anything else (`self_` in practice),/// then the signatures don't have a special `self` argument, and/// can, therefore, have a different one introduced./// If `MySelf` is just `Self`, then the types are only valid inside/// a trait or a trait impl, where the trait has associated types/// for each of the API types. If non-associated types are desired,/// a module name (`self` in practice) can be used instead of `Self`.// Similar to `with_api`, but only lists the types requiring handles, and they// are divided into the two storage categories.selfless_reify/// Buffer used to pass initial input to the client.force_show_panics/// If 'true', always invoke the default panic hook/// Configuration for establishing an active connection between a server and a/// client.  The server creates the bridge config (`run_server` in `server.rs`),/// then passes it to the client through the function pointer in the `run` field/// of `client::Client`. The client constructs a local `Bridge` from the config/// in TLS during its execution (`Bridge::{enter, with}` in `client.rs`).declare_tagsrpc_encode_decodeapi_tagsUnmarked/// Helper to wrap associated types to allow trait impl dispatch./// That is, normally a pair of impls for `T::Foo` and `T::Bar`/// can overlap, but if the impls are, instead, on types like/// `Marked<T::Foo, Foo>` and `Marked<T::Bar, Bar>`, they can't.unmarkUnmark/// Unwrap types wrapped by `Mark::mark` (see `Mark` for details).mark_noopLitKindStrRawByteStrRawCStrRawErrWithGuar// This should have an `ErrorGuaranteed`, except that type isn't available// in this crate. (Imagine it is there.) Hence the `WithGuar` suffix. Must// only be constructed in `LitKind::from_internal`, where an// `ErrorGuaranteed` is available.mark_compoundcompound_traitsentirefrom_singleSy/// Globals provided alongside the initial inputs for a macro expansion./// Provides values such as spans which are used frequently to avoid RPC.//! Internal interface for communicating between a `proc_macro` client//! (a proc macro crate) and a `proc_macro` server (a compiler front-end).//! Serialization (with C ABI buffers) and unique integer handles are employed//! to allow safely interfacing between two copies of `proc_macro` built//! (from the same source) by different compilers with potentially mismatching//! Rust ABIs (e.g., stage0/bin/rustc vs stage1/bin/rustc during bootstrap).StaticStr/// Simplified version of panic payloads, ignoring/// types other than `&'static str` and `String`.//! Serialization for client-server communication.define_reify_functions// FIXME(eddyb) this could be `trait` impls except for the `const fn` requirement._reify_to_extern_c_fn_unaryreify_to_extern_c_fn_hrt_bridge//! Abstraction for creating `fn` pointers from any callable that *effectively*//! has the equivalent of implementing `Default`, even if the compiler neither//! provides `Default` nor allows reifying closures (i.e. creating `fn` pointers)//! other than those with absolutely no captures.//! More specifically, for a closure-like type to be "effectively `Default`"://! * it must be a ZST (zero-sized type): no information contained within, so//!   that `Default`'s return value (if it were implemented) is unambiguous//! * it must be `Copy`: no captured "unique ZST tokens" or any other similar//!   types that would make duplicating values at will unsound//!   * combined with the ZST requirement, this confers a kind of "telecopy"//!     ability: similar to `Copy`, but without keeping the value around, and//!     instead "reconstructing" it (a noop given it's a ZST) when needed//! * it must be *provably* inhabited: no captured uninhabited types or any//!   other types that cannot be constructed by the user of this abstraction//!   * the proof is a value of the closure-like type itself, in a sense the//!     "seed" for the "telecopy" process made possible by ZST + `Copy`//!   * this requirement is the only reason an abstraction limited to a specific//!     usecase is required: ZST + `Copy` can be checked with *at worst* a panic//!     at the "attempted `::default()` call" time, but that doesn't guarantee//!     that the value can be soundly created, and attempting to use the typical//!     "proof ZST token" approach leads yet again to having a ZST + `Copy` type//!     that is not proof of anything without a value (i.e. isomorphic to a//!     newtype of the type it's trying to prove the inhabitation of)//! A more flexible (and safer) solution to the general problem could exist once//! `const`-generic parameters can have type parameters in their types://! ```rust,ignore (needs future const-generics)//! extern "C" fn ffi_wrapper<//!     A, R,//!     F: Fn(A) -> R,//!     const f: F, // <-- this `const`-generic is not yet allowed//! >(arg: A) -> R {//!     f(arg)define_server_handlesTypesHandleStoreMarkedTypesassociated_fn/// Declare an associated fn of one of the traits below, adding necessary/// default bodies.declare_server_traitsr" Intern a symbol received from RPC"intern_symbolr" Recover the string value of a symbol, and invoke a callback with it."with_symbol_stringdefine_mark_types_implshandle_storedefine_dispatcher_implDispatcherTraitrun_bridge_and_clientExecutionStrategyr" While running a proc-macro with the same-thread executor, this flag will"r" be set, forcing nested proc-macro invocations (e.g. due to"r" `TokenStream::expand_expr`) to be run using a cross-thread executor."r" This is required as the thread-local state in the proc_macro client does"r" not handle being re-entered, and will invalidate all `Symbol`s when"r" entering a nested macro."ALREADY_RUNNING_SAME_THREADRunningSameThreadGuard/// Keep `ALREADY_RUNNING_SAME_THREAD` (see also its documentation)/// set to `true`, preventing same-thread reentrance.cross_threadMaybeCrossThreadMessagePipeSameThreadCrossThread/// Creates a new pair of endpoints for the message pipe./// Send a message to the other endpoint of this pipe./// Receive a message from the other endpoint of this pipe./// Returns `None` if the other end of the pipe has been destroyed, and no/// message was received./// A message pipe used for communicating between server and client threads.//! Server-side traits./// Handle for a symbol string stored within the Interner./// Intern a new `Symbol`new_ident/// Creates a new `Symbol` for an identifier./// Validates and normalizes before converting it to a symbol./// Run a callback with the symbol's string value.invalidate_all/// Clear out the thread-local symbol interner, making all previously/// created symbols invalid such that `with` will panic when called on them.is_valid_ascii_ident/// Checks if the ident is a valid ASCII identifier./// This is a short-circuit which is cheap to implement within the/// proc-macro client to avoid RPC when creating simple idents, but may/// return `false` for a valid identifier if it contains non-ASCIIcan_be_raw// Mimics the behavior of `Symbol::can_be_raw` from `rustc_span`INTERNERInterner// SAFETY: These `'static` lifetimes are actually references to data owned// by the Arena. This is safe, as we never return them as static references// from `Interner`.sym_base// The offset to apply to symbol names stored in the interner. This is used// to ensure that symbol names are not re-used after the interner is// cleared./// Basic interner for a `Symbol`, inspired by the one in `rustc_span`./// Reads a symbol's value from the store while it is held./// Clear all symbols from the store, invalidating them such that `get` will/// panic if they are accessed in the future.//! Client-side interner used for symbols.//! This is roughly based on the symbol interner from `rustc_span` and the//! DroplessArena from `rustc_arena`. It is unfortunately a complete//! copy/re-implementation rather than a dependency as it is difficult to depend//! on crates from within `proc_macro`, due to it being built at the same time//! as `std`.//! If at some point in the future it becomes easier to add dependencies to//! proc_macro, this module should probably be removed or simplified./// An error./// A warning./// A note./// A help message./// An enum representing a diagnostic level./// Converts `self` into a `Vec<Span>`.MultiSpan/// Trait implemented by types that can be converted into a set of `Span`s./// A structure representing a diagnostic message and associated childrendiagnostic_child_methods/// Iterator over the children diagnostics of a `Diagnostic`./// Creates a new diagnostic with the given `level` and `message`./// Creates a new diagnostic with the given `level` and `message` pointing to/// the given set of `spans`.span_warning/// Returns the diagnostic `level` for `self`.set_level/// Sets the level in `self` to `level`./// Returns the message in `self`./// Sets the message in `self` to `message`./// Returns the `Span`s in `self`.set_spans/// Sets the `Span`s in `self` to `spans`./// Returns an iterator over the children diagnostics of `self`./// Emit the diagnostic./// Produce \'./// Produce \".escape_nonascii/// Produce \x escapes for non-ASCII, and use \x rather than \u for ASCII/// control characters.EscapeOptionsescape_single_byteescape_single_charConversionErrorKindFailedToUnescape/// The literal failed to be escaped, take a look at [`EscapeError`] for more information.InvalidLiteralKind/// Trying to convert a literal with the wrong type./// Errors returned when trying to retrieve a literal unescaped value./// Determines whether proc_macro has been made accessible to the currently/// running program./// The proc_macro crate is only intended for use inside the implementation of/// procedural macros. All the functions in this crate panic if invoked from/// outside of a procedural macro, such as from a build script or unit test or/// ordinary Rust binary./// With consideration for Rust libraries that are designed to support both/// macro and non-macro use cases, `proc_macro::is_available()` provides a/// non-panicking way to detect whether the infrastructure required to use the/// API of proc_macro is presently available. Returns true if invoked from/// inside of a procedural macro, false if invoked from any other binary./// The main type provided by this crate, representing an abstract stream of/// tokens, or, more specifically, a sequence of token trees./// The type provides interfaces for iterating over those token trees and, conversely,/// collecting a number of token trees into one stream./// This is both the input and output of `#[proc_macro]`, `#[proc_macro_attribute]`/// and `#[proc_macro_derive]` definitions.ExpandError/// Error returned from `TokenStream::expand_expr`./// Parses this `TokenStream` as an expression and attempts to expand any/// macros within it. Returns the expanded `TokenStream`./// Currently only expressions expanding to literals will succeed, although/// this may be relaxed in the future./// NOTE: In error conditions, `expand_expr` may leave macros unexpanded,/// report an error, failing compilation, and/or return an `Err(..)`. The/// specific behavior for any error condition, and what conditions are/// considered errors, is unspecified and may change in the future./// Attempts to break the string into tokens and parse those tokens into a token stream./// May fail for a number of reasons, for example, if the string contains unbalanced delimiters/// or characters not existing in the language./// All tokens in the parsed stream get `Span::call_site()` spans./// NOTE: some errors may cause panics instead of returning `LexError`. We reserve the right to/// change these errors into `LexError`s later.// clippy doesn't see the specialization/// Prints the token stream as a string that is supposed to be losslessly convertible back/// into the same token stream (modulo spans), except for possibly `TokenTree::Group`s/// with `Delimiter::None` delimiters and negative numeric literals./// Note: the exact form of the output is subject to change, e.g. there might/// be changes in the whitespace used between tokens. Therefore, you should/// *not* do any kind of simple substring matching on the output string (as/// produced by `to_string`) to implement a proc macro, because that matching/// might stop working if such changes happen. Instead, you should work at the/// `TokenTree` level, e.g. matching against `TokenTree::Ident`,/// `TokenTree::Punct`, or `TokenTree::Literal`.quote_spantree_to_bridge_tree/// Creates a token stream containing a single token tree.treesConcatTreesHelper/// Non-generic helper for implementing `FromIterator<TokenTree>` and/// `Extend<TokenTree>` with less monomorphization in calling crates.ConcatStreamsHelper/// Non-generic helper for implementing `FromIterator<TokenStream>` and/// `Extend<TokenStream>` with less monomorphization in calling crates./// A "flattening" operation on token streams, collects token trees/// from multiple token streams into a single stream.extend_items/// The iteration is "shallow", e.g., the iterator doesn't recurse into delimited groups,/// and returns whole groups as token trees./// `quote!(..)` accepts arbitrary tokens and expands into a `TokenStream` describing the input./// For example, `quote!(a + b)` will produce an expression, that, when evaluated, constructs/// the `TokenStream` `[Ident("a"), Punct('+', Alone), Ident("b")]`./// Unquoting is done with `$`, and works by taking the single next ident as the unquoted term./// To quote `$` itself, use `$$`.diagnostic_method/// A span that resolves at the macro definition site./// Identifiers created with this span will be resolved as if they were written/// directly at the macro call location (call-site hygiene) and other code/// at the macro call site will be able to refer to them as well./// A span that represents `macro_rules` hygiene, and sometimes resolves at the macro/// definition site (local variables, labels, `$crate`) and sometimes at the macro/// call site (everything else)./// The span location is taken from the call-site./// The `Span` for the tokens in the previous macro expansion from which/// `self` was generated from, if any./// The span for the origin source code that `self` was generated from. If/// this `Span` wasn't generated from other macro expansions then the return/// value is the same as `*self`./// Returns the span's byte position range in the source file./// Creates an empty span pointing to directly before this span./// Creates an empty span pointing to directly after this span./// The one-indexed line of the source file where the span starts./// To obtain the line of the span's end, use `span.end().line()`./// The one-indexed column of the source file where the span starts./// To obtain the column of the span's end, use `span.end().column()`./// The path to the source file in which this span occurs, for display purposes./// This might not correspond to a valid file system path./// It might be remapped (e.g. `"/src/lib.rs"`) or an artificial path (e.g. `"<command line>"`)./// The path to the source file in which this span occurs on the local file system./// This is the actual path on disk. It is unaffected by path remapping./// This path should not be embedded in the output of the macro; prefer `file()` instead./// Creates a new span encompassing `self` and `other`./// Compares two spans to see if they're equal./// Returns the source text behind a span. This preserves the original source/// code, including spaces and comments. It only returns a result if the span/// corresponds to real source code./// Note: The observable result of a macro should only rely on the tokens and/// not on this source text. The result of this function is a best effort to/// be used for diagnostics only.// Used by the implementation of `Span::quote`r" Creates a new `Diagnostic` with the given `message` at the span"r" `self`."/// A single token or a delimited sequence of token trees (e.g., `[1, (), ..]`)./// Prints the token tree as a string that is supposed to be losslessly convertible back/// into the same token tree (modulo spans), except for possibly `TokenTree::Group`s/// A `Group` internally contains a `TokenStream` which is surrounded by `Delimiter`s./// An invisible delimiter, that may, for example, appear around tokens coming from a/// "macro variable" `$var`. It is important to preserve operator priorities in cases like/// `$var * 3` where `$var` is `1 + 2`./// Invisible delimiters might not survive roundtrip of a token stream through a string./// A `Punct` is a single punctuation character such as `+`, `-` or `#`./// Multi-character operators like `+=` are represented as two instances of `Punct` with different/// forms of `Spacing` returned./// A `Punct` token can join with the following token to form a multi-character operator./// In token streams constructed using proc macro interfaces, `Joint` punctuation tokens can be/// followed by any other tokens. However, in token streams parsed from source code, the/// compiler will only set spacing to `Joint` in the following cases./// - When a `Punct` is immediately followed by another `Punct` without a whitespace. E.g. `+`///   is `Joint` in `+=` and `++`./// - When a single quote `'` is immediately followed by an identifier without a whitespace.///   E.g. `'` is `Joint` in `'lifetime`./// This list may be extended in the future to enable more token combinations./// A `Punct` token cannot join with the following token to form a multi-character operator./// `Alone` punctuation tokens can be followed by any other tokens. In token streams parsed/// from source code, the compiler will set spacing to `Alone` in all cases not covered by the/// conditions for `Joint` above. E.g. `+` is `Alone` in `+ =`, `+ident` and `+()`. In/// particular, tokens not followed by anything will be marked as `Alone`./// Indicates whether a `Punct` token can join with the following token/// to form a multi-character operator./// The `ch` argument must be a valid punctuation character permitted by the language,/// otherwise the function will panic./// Returns the spacing of this punctuation character, indicating whether it can be potentially/// combined into a multi-character operator with the following token (`Joint`), or whether the/// operator has definitely ended (`Alone`)./// Prints the punctuation character as a string that should be losslessly convertible/// back into the same character./// An identifier (`ident`)./// language (including keywords, e.g. `self` or `fn`). Otherwise, the function will panic./// As of this time `Span::call_site()` explicitly opts-in to "call-site" hygiene/// meaning that identifiers created with this span will be resolved as if they were written/// directly at the location of the macro call, and other code at the macro call site will be/// able to refer to them as well./// Later spans like `Span::def_site()` will allow to opt-in to "definition-site" hygiene/// meaning that identifiers created with this span will be resolved at the location of the/// macro definition and other code at the macro call site will not be able to refer to them./// Same as `Ident::new`, but creates a raw identifier (`r#ident`)./// The `string` argument be a valid identifier permitted by the language/// (including keywords, e.g. `fn`). Keywords which are usable in path segments/// (e.g. `self`, `super`) are not supported, and will cause a panic./// Returns the span of this `Ident`, encompassing the entire string returned/// by [`to_string`](ToString::to_string)./// Configures the span of this `Ident`, possibly changing its hygiene context./// A literal string (`"hello"`), byte string (`b"hello"`), C string (`c"hello"`),/// character (`'a'`), byte character (`b'a'`), an integer or floating point number/// with or without a suffix (`1`, `1u8`, `2.3`, `2.3f32`)./// Boolean literals like `true` and `false` do not belong here, they are `Ident`s.r" also suffixed at the end."r" Literals created from negative numbers might not survive round-trips through"r" `TokenStream` or strings and may be broken into two tokens (`-` and positive literal)."r" `Literal::u32_unsuffixed(1)`."r" Literals created from negative numbers might not survive rountrips through"/// Literals created from negative numbers might not survive rountrips through/// `TokenStream` or strings and may be broken into two tokens (`-` and positive literal)./// This function requires that the specified float is finite, for/// example if it is infinity or NaN this function will panic./// Returns a `Span` that is a subset of `self.span()` containing only the/// source bytes in range `range`. Returns `None` if the would-be trimmed/// span is outside the bounds of `self`.// FIXME(SergioBenitez): check that the byte range starts and ends at a// UTF-8 boundary of the source. otherwise, it's likely that a panic will// occur elsewhere when the source text is printed.// FIXME(SergioBenitez): there is no way for the user to know what// `self.span()` actually maps to, so this method can currently only be// called blindly. For example, `to_string()` for the character 'c' returns// "'\u{63}'"; there is no way for the user to know whether the source text// was 'c' or whether it was '\u{63}'.with_symbol_and_suffixwith_stringify_parts/// Invokes the callback with a `&[&str]` consisting of each part of the/// literal's representation. This is done to allow the `ToString` and/// `Display` implementations to borrow references to symbol values, and/// both be optimized to reduce overhead./// Returns the unescaped string value if the current literal is a string or a string literal.cstr_value/// Returns the unescaped string value if the current literal is a c-string or a c-string/// literal.byte_str_value/// Returns the unescaped string value if the current literal is a byte string or a byte string/// Parse a single literal from its stringified representation./// In order to parse successfully, the input string must not contain anything/// but the literal token. Specifically, it must not contain whitespace or/// comments in addition to the literal./// The resulting literal token will have a `Span::call_site()` span./// NOTE: some errors may cause panics instead of returning `LexError`. We/// Prints the literal as a string that should be losslessly convertible/// back into the same literal (except for possible rounding for floating point literals)./// Retrieve an environment variable and add it to build dependency info./// The build system executing the compiler will know that the variable was accessed during/// compilation, and will be able to rerun the build when the value of that variable changes./// Besides the dependency tracking this function should be equivalent to `env::var` from the/// standard library, except that the argument must be UTF-8.tracked_env/// Tracked access to environment variables./// Track a file explicitly./// Commonly used for tracking asset preprocessing.tracked_path/// Tracked access to additional files.//! A support library for macro authors when defining new macros.//! This library, provided by the standard distribution, provides the types//! consumed in the interfaces of procedurally defined macro definitions such as//! function-like macros `#[proc_macro]`, macro attributes `#[proc_macro_attribute]` and//! custom derive attributes`#[proc_macro_derive]`.//! See [the book] for more.//! [the book]: ../book/ch19-06-macros.html#procedural-macros-for-generating-code-from-attributes// Can't use FxHashMap when compiled as part of the standard libraryminimal_quote_ttminimal_quote_tsminimal_quote/// Simpler version of the real `quote!` macro, implemented solely/// through `macro_rules`, for bootstrapping the real implementation/// (see the `quote` function), which does not have access to the/// real `quote!` macro due to the `proc_macro` crate not being/// able to depend on itself./// Note: supported tokens are a subset of the real `quote!`, but/// unquoting is different: instead of `$x`, this uses `(@ expr)`./// Quote a `TokenStream` into a `TokenStream`./// This is the actual implementation of the `quote!()` proc macro./// It is loaded by the compiler in `register_builtin_macros`.collect_meta_vars/// Helper function to support macro repetitions like `$( CONTENTS ) SEP_OPT *` in `quote!`./// Recursively collects all `Ident`s (meta-variables) that follow a `$`/// from the given `CONTENTS` stream, preserving their order of appearance./// Quote a `Span` into a `TokenStream`./// This is needed to implement a custom quoter.//! # Quasiquoter//! This file contains the implementation internals of the quasiquoter provided by `quote!`.//! This quasiquoter uses macros 2.0 hygiene to reliably access//! items from `proc_macro`, to build a `proc_macro::TokenStream`./// #![feature(proc_macro_totokens)]/// use proc_macro::{Spacing, Punct, TokenStream, TokenTree, ToTokens};///                 tokens.extend(iter::once(TokenTree::from(Punct::new(':', Spacing::Joint))));///                 tokens.extend(iter::once(TokenTree::from(Punct::new(':', Spacing::Alone))));/// [`quote!`]: crate::quote!tracked_env_vartracked_env_var_or_fallback//! Compiles the profiler part of the `compiler-rt` library.//! Loosely based on://! - LLVM's `compiler-rt/lib/profile/CMakeLists.txt`//! - <https://github.com/rust-lang/compiler-builtins/blob/master/build.rs>.profiler_runtime// Other attributes:".eh_frame"link_section__EH_FRAME_BEGIN__// Marks beginning of the stack frame unwind info sectionOBJ// Scratch space for unwinder's internal book-keeping.// This is defined as `struct object` in $GCC/libgcc/unwind-dw2-fde.h.impl_copy__register_frame_info__deregister_frame_info".ctors.65535"P_INIT// .ctors.* : C initialization callbacks".dtors.65535"P_UNINIT// .dtors.* : C termination callbacks// MinGW's startup objects (crt0.o / dllcrt0.o) will invoke global constructors in the// .ctors and .dtors sections on startup and exit. In the case of DLLs, this is done when// the DLL is loaded and unloaded.// The linker will sort the sections, which ensures that our callbacks are located at the// end of the list. Since constructors are run in reverse order, this ensures that our// callbacks are the first and last ones executed.mingw_init// MinGW-specific init/uninit routine registration// Unwind info registration/deregistration routines.eh_frames// Frame unwind info registration// Each module's image contains a frame unwind info section (usually// ".eh_frame").  When a module is loaded/unloaded into the process, the// unwinder must be informed about the location of this section in memory. The// methods of achieving that vary by the platform.  On some (e.g., Linux), the// unwinder can discover unwind info sections on its own (by dynamically// enumerating currently loaded modules via the dl_iterate_phdr() API and// finding their ".eh_frame" sections); Others, like Windows, require modules// to actively register their unwind info sections via unwinder API.// rsbegin.o and rsend.o are the so called "compiler runtime startup objects".// They contain code needed to correctly initialize the compiler runtime.// When an executable or dylib image is linked, all user code and libraries are// "sandwiched" between these two object files, so code or data from rsbegin.o// become first in the respective sections of the image, whereas code and data// from rsend.o become the last ones. This effect can be used to place symbols// at the beginning or at the end of a section, as well as to insert any required// headers or footers.// Note that the actual module entry point is located in the C runtime startup// object (usually called `crtX.o`), which then invokes initialization callbacks// of other runtime components (registered via yet another special image section).__EH_FRAME_END__// Terminate the frame unwind info section with a 0 as a sentinel;// this would be the 'length' field in a real FDE.// See rsbegin.rs for details.// Rename the crate to avoid conflicting with the alloc module in alloc.// See rustc-std-workspace-core for why this crate is needed.// Crate must be brought into scope so it appears in the crate graph for anything that// depends on `rustc-std-workspace-core`.new_dropnew_insert_dropgrow_by_insertionfind_existingfind_nonexistinghashmap_as_queueget_remove_insertset_opsset_differenceset_is_subsetset_intersectionset_symmetric_differencebench_path_cmp_fast_path_buf_sort// Miri isn't fast...bench_path_cmp_fast_path_longbench_path_cmp_fast_path_shortbench_path_components_iterbench_path_file_namebench_path_hashsetbench_path_hashset_missbench_hash_path_shortbench_hash_path_longbench_instant_threadedalloc_crate/// The default memory allocator provided by the operating system./// This is based on `malloc` on Unix platforms and `HeapAlloc` on Windows,/// plus related functions. However, it is not valid to mix use of the backing/// system allocator with `System`, as this implementation may include extra/// work, such as to serve alignment requests greater than the alignment/// provided directly by the backing system allocator./// This type implements the [`GlobalAlloc`] trait. Currently the default/// global allocator is unspecified. Libraries, however, like `cdylib`s and/// `staticlib`s are guaranteed to use the [`System`] by default and as such/// work as if they had this definition:/// static A: System = System;///     let a = Box::new(4); // Allocates from the system allocator.///     println!("{a}");/// You can also define your own wrapper around `System` if you'd like, such as/// keeping track of the number of all bytes allocated:/// use std::alloc::{System, GlobalAlloc, Layout};/// struct Counter;/// static ALLOCATED: AtomicUsize = AtomicUsize::new(0);/// unsafe impl GlobalAlloc for Counter {///         let ret = unsafe { System.alloc(layout) };///         if !ret.is_null() {///             ALLOCATED.fetch_add(layout.size(), Relaxed);///     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {///         unsafe { System.dealloc(ptr, layout); }///         ALLOCATED.fetch_sub(layout.size(), Relaxed);/// static A: Counter = Counter;///     println!("allocated bytes before main: {}", ALLOCATED.load(Relaxed));/// It can also be used directly to allocate memory independently of whatever/// global allocator has been selected for a Rust program. For example if a Rust/// program opts in to using jemalloc as the global allocator, `System` will/// still allocate memory using `malloc` and `HeapAlloc`.// The Allocator impl checks the layout size to be non-zero and forwards to the GlobalAlloc impl,// which is in `std::sys::*::alloc`.HOOK/// Registers a custom allocation error hook, replacing any that was previously registered./// The allocation error hook is invoked when an infallible memory allocation fails — that is,/// as a consequence of calling [`handle_alloc_error`] — before the runtime aborts./// The allocation error hook is a global resource. [`take_alloc_error_hook`] may be used to/// retrieve a previously registered hook and wrap or discard it./// # What the provided `hook` function should expect/// The hook function is provided with a [`Layout`] struct which contains information/// about the allocation that failed./// The hook function may choose to panic or abort; in the event that it returns normally, this/// will cause an immediate abort./// Since [`take_alloc_error_hook`] is a safe function that allows retrieving the hook, the hook/// function must be _sound_ to call even if no memory allocations were attempted./// # The default hook/// The default hook, used if [`set_alloc_error_hook`] is never called, prints a message to/// standard error (and then returns, causing the runtime to abort the process)./// Compiler options may cause it to panic instead, and the default behavior may be changed/// to panicking in future versions of Rust./// #![feature(alloc_error_hook)]/// use std::alloc::{Layout, set_alloc_error_hook};/// fn custom_alloc_error_hook(layout: Layout) {///    panic!("memory allocation of {} bytes failed", layout.size());/// set_alloc_error_hook(custom_alloc_error_hook);take_alloc_error_hook/// Unregisters the current allocation error hook, returning it./// *See also the function [`set_alloc_error_hook`].*/// If no custom hook is registered, the default hook will be returned.default_alloc_error_hookrust_oom__rdl_alloc__rdl_dealloc__rdl_realloc__rdl_alloc_zeroed// These magic symbol names are used as a fallback for implementing the// `__rust_alloc` etc symbols (see `src/liballoc/alloc.rs`) when there is// no `#[global_allocator]` attribute.// for symbol names src/librustc_ast/expand/allocator.rs// for signatures src/librustc_allocator/lib.rs// linkage directives are provided as part of the current compiler allocator// ABI__default_lib_allocator//! Memory allocation APIs.//! In a given program, the standard library has one “global” memory allocator//! that is used for example by `Box<T>` and `Vec<T>`.//! Currently the default global allocator is unspecified. Libraries, however,//! like `cdylib`s and `staticlib`s are guaranteed to use the [`System`] by//! # The `#[global_allocator]` attribute//! This attribute allows configuring the choice of global allocator.//! You can use this to implement a completely custom global allocator//! to route all[^system-alloc] default allocation requests to a custom object.//! use std::alloc::{GlobalAlloc, System, Layout};//! struct MyAllocator;//! unsafe impl GlobalAlloc for MyAllocator {//!     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {//!         unsafe { System.alloc(layout) }//!     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {//!         unsafe { System.dealloc(ptr, layout) }//! #[global_allocator]//! static GLOBAL: MyAllocator = MyAllocator;//!     // This `Vec` will allocate memory through `GLOBAL` above//!     let mut v = Vec::new();//!     v.push(1);//! The attribute is used on a `static` item whose type implements the//! [`GlobalAlloc`] trait. This type can be provided by an external library://! ```rust,ignore (demonstrates crates.io usage)//! use jemallocator::Jemalloc;//! static GLOBAL: Jemalloc = Jemalloc;//! fn main() {}//! The `#[global_allocator]` can only be used once in a crate//! or its recursive dependencies.//! [^system-alloc]: Note that the Rust standard library internals may still//! directly call [`System`] when necessary (for example for the runtime//! support typically required to implement a global allocator, see [re-entrance] on [`GlobalAlloc`]//! for more details).//! [re-entrance]: trait.GlobalAlloc.html#re-entrance/// Container type for copied ASCII characters./// This method is deprecated in favor of the identically-named/// inherent methods on `u8`, `char`, `[u8]` and `str`./// [`str::to_uppercase`]./// [`make_ascii_uppercase`]: AsciiExt::make_ascii_uppercase/// [`str::to_lowercase`]./// [`make_ascii_lowercase`]: AsciiExt::make_ascii_lowercase/// [`to_ascii_uppercase`]: AsciiExt::to_ascii_uppercase/// [`to_ascii_lowercase`]: AsciiExt::to_ascii_lowercase/// Extension methods for ASCII-subset only operations./// Be aware that operations on seemingly non-ASCII characters can sometimes/// have unexpected results. Consider this example:/// use std::ascii::AsciiExt;/// assert_eq!(AsciiExt::to_ascii_uppercase("café"), "CAFÉ");/// assert_eq!(AsciiExt::to_ascii_uppercase("café"), "CAFé");/// In the first example, the lowercased string is represented `"cafe\u{301}"`/// (the last character is an acute accent [combining character]). Unlike the/// other characters in the string, the combining character will not get mapped/// to an uppercase variant, resulting in `"CAFE\u{301}"`. In the second/// example, the lowercased string is represented `"caf\u{e9}"` (the last/// character is a single Unicode character representing an 'e' with an acute/// accent). Since the last character is defined outside the scope of ASCII,/// it will not get mapped to an uppercase variant, resulting in `"CAF\u{e9}"`./// [combining character]: https://en.wikipedia.org/wiki/Combining_characterdelegating_ascii_methods//! The [`AsciiExt`] trait provides methods that allow for character//! operations that only act on the ASCII subset and leave non-ASCII characters//! alone.generate_fake_framestest_framesbacktrace_unwind_safebacktrace_rsoutput_filenameset_image_base/// A captured OS thread stack backtrace./// This type represents a stack backtrace for an OS thread captured at a/// previous point in time. In some instances the `Backtrace` type may/// internally be empty due to configuration. For more information see/// `Backtrace::capture`./// Capturing a backtrace is not supported, likely because it's not/// implemented for the current platform./// Capturing a backtrace has been disabled through either the/// `RUST_LIB_BACKTRACE` or `RUST_BACKTRACE` environment variables.Captured/// A backtrace has been captured and the `Backtrace` should print/// reasonable information when rendered./// The current status of a backtrace, indicating whether it was captured or/// whether it is empty for some other reason.LazyResolveactual_startRawFrame/// A single frame of a backtrace.ActualBytesOrWide/// Returns whether backtrace captures are enabled through environment/// Captures a stack backtrace of the current thread./// This function will capture a stack backtrace of the current OS thread of/// execution, returning a `Backtrace` type which can be later used to print/// the entire stack trace or render it to a string./// This function will be a noop if the `RUST_BACKTRACE` or/// `RUST_LIB_BACKTRACE` backtrace variables are both not set. If either/// environment variable is set and enabled then this function will actually/// capture a backtrace. Capturing a backtrace can be both memory intensive/// and slow, so these environment variables allow liberally using/// `Backtrace::capture` and only incurring a slowdown when the environment/// variables are set./// To forcibly capture a backtrace regardless of environment variables, use/// the `Backtrace::force_capture` function.force_capture/// Forcibly captures a full backtrace, regardless of environment variable/// This function behaves the same as `capture` except that it ignores the/// values of the `RUST_BACKTRACE` and `RUST_LIB_BACKTRACE` environment/// variables, always capturing a backtrace./// Note that capturing a backtrace can be an expensive operation on some/// platforms, so this should be used with caution in performance-sensitive/// parts of code./// Forcibly captures a disabled backtrace, regardless of environment/// variable configuration.// Capture a backtrace which start just before the function addressed by// `ip`/// Returns the status of this backtrace, indicating whether this backtrace/// request was unsupported, disabled, or a stack trace was actually/// captured./// Returns an iterator over the backtrace frames.lazy_resolve//! Support for capturing a stack backtrace of an OS thread//! This module contains the support necessary to capture a stack backtrace of a//! running OS thread from the OS thread itself. The `Backtrace` type supports//! capturing a stack trace via the `Backtrace::capture` and//! `Backtrace::force_capture` functions.//! A backtrace is typically quite handy to attach to errors (e.g. types//! implementing `std::error::Error`) to get a causal chain of where an error//! was generated.//! ## Accuracy//! Backtraces are attempted to be as accurate as possible, but no guarantees//! are provided about the exact accuracy of a backtrace. Instruction pointers,//! symbol names, filenames, line numbers, etc, may all be incorrect when//! reported. Accuracy is attempted on a best-effort basis, however, any bug//! reports are always welcome to indicate areas of improvement!//! For most platforms a backtrace with a filename/line number requires that//! programs be compiled with debug information. Without debug information//! filenames/line numbers will not be reported.//! ## Platform support//! Not all platforms that std compiles for support capturing backtraces. Some//! platforms simply do nothing when capturing a backtrace. To check whether the//! platform supports capturing backtraces you can consult the `BacktraceStatus`//! enum as a result of `Backtrace::status`.//! Like above with accuracy platform support is done on a best effort basis.//! Sometimes libraries might not be available at runtime or something may go//! wrong which would cause a backtrace to not be captured. Please feel free to//! report issues with platforms where a backtrace cannot be captured though!//! ## Environment Variables//! The `Backtrace::capture` function might not actually capture a backtrace by//! default. Its behavior is governed by two environment variables://! * `RUST_LIB_BACKTRACE` - if this is set to `0` then `Backtrace::capture`//!   will never capture a backtrace. Any other value set will enable//!   `Backtrace::capture`.//! * `RUST_BACKTRACE` - if `RUST_LIB_BACKTRACE` is not set, then this variable//!   is consulted with the same rules of `RUST_LIB_BACKTRACE`.//! * If neither of the above env vars are set, then `Backtrace::capture` will//!   be disabled.//! Capturing a backtrace can be a quite expensive runtime operation, so the//! environment variables allow either forcibly disabling this runtime//! performance hit or allow selectively enabling it in some programs.//! Note that the `Backtrace::force_capture` function can be used to ignore//! these environment variables. Also note that the state of environment//! variables is cached once the first backtrace is created, so altering//! `RUST_LIB_BACKTRACE` or `RUST_BACKTRACE` at runtime might not actually change//! how backtraces are captured.// NB: A note on resolution of a backtrace:// Backtraces primarily happen in two steps, one is where we actually capture// the stack backtrace, giving us a list of instruction pointers corresponding// to stack frames. Next we take these instruction pointers and, one-by-one,// turn them into a human readable name (like `main`).// The first phase can be somewhat expensive (walking the stack), especially// on MSVC where debug information is consulted to return inline frames each as// their own frame. The second phase, however, is almost always extremely// expensive (on the order of milliseconds sometimes) when it's consulting debug// information.// We attempt to amortize this cost as much as possible by delaying resolution// of an address to a human readable name for as long as possible. When// `Backtrace::create` is called to capture a backtrace it doesn't actually// perform any symbol resolution, but rather we lazily resolve symbols only just// before they're needed for printing. This way we can make capturing a// backtrace and throwing it away much cheaper, but actually printing a// backtrace is still basically the same cost.// This strategy comes at the cost of some synchronization required inside of a// `Backtrace`, but that's a relatively small price to pay relative to capturing// a backtrace or actually symbolizing it.realstd_assert_hashmap_is_unwind_safe// https://github.com/rust-lang/rust/issues/62301// Android used in CI has a broken dlmalloceq_sortedEqSortedconsuming_nothingconsuming_allconst_with_hasher/// A [hash map] implemented with quadratic probing and SIMD lookup./// By default, `HashMap` uses a hashing algorithm selected to provide/// resistance against HashDoS attacks. The algorithm is randomly seeded, and a/// reasonable best-effort is made to generate this seed from a high quality,/// secure source of randomness provided by the host without blocking the/// program. Because of this, the randomness of the seed depends on the output/// quality of the system's random number coroutine when the seed is created./// In particular, seeds generated when the system's entropy pool is abnormally/// low such as during system boot may be of a lower quality./// The default hashing algorithm is currently SipHash 1-3, though this is/// subject to change at any point in the future. While its performance is very/// competitive for medium sized keys, other hashing algorithms will outperform/// it for small keys such as integers as well as large keys such as long/// strings, though those algorithms will typically *not* protect against/// attacks such as HashDoS./// [`default`], [`with_hasher`], and [`with_capacity_and_hasher`] methods./// There are many alternative [hashing algorithms available on crates.io]./// Violating this property is a logic error./// It is also a logic error for a key to be modified in such a way that the key's/// The behavior resulting from either logic error is not specified, but will/// be encapsulated to the `HashMap` that observed the logic error and not/// The hash table implementation is a Rust port of Google's [SwissTable]./// The original C++ version of SwissTable can be found [here], and this/// [CppCon talk] gives an overview of how the algorithm works./// [hash map]: crate::collections#use-a-hashmap-when/// [hashing algorithms available on crates.io]: https://crates.io/keywords/hasher/// [SwissTable]: https://abseil.io/blog/20180927-swisstables/// [here]: https://github.com/abseil/abseil-cpp/blob/master/absl/container/internal/raw_hash_set.h/// [CppCon talk]: https://www.youtube.com/watch?v=ncHmEUmJZf4///         Some(review) => println!("{book}: {review}"),///         None => println!("{book} is unreviewed.")///     println!("{book}: \"{review}\"");/// A `HashMap` with a known list of items can be initialized from an array:/// let solar_distance = HashMap::from([/// `HashMap` implements an [`Entry` API](#method.entry), which allows/// for complex methods of getting, setting, updating and removing keys and/// ## Usage with custom key types/// [`default`]: Default::default/// [`with_hasher`]: Self::with_hasher/// [`with_capacity_and_hasher`]: Self::with_capacity_and_hasher/// let vikings = HashMap::from([///     (Viking::new("Einar", "Norway"), 25),///     (Viking::new("Olaf", "Denmark"), 24),///     (Viking::new("Harald", "Iceland"), 12),///     println!("{viking:?} has {health} hp");/// # Usage in `const` and `static`/// As explained above, `HashMap` is randomly seeded: each `HashMap` instance uses a different seed,/// which means that `HashMap::new` normally cannot be used in a `const` or `static` initializer./// However, if you need to use a `HashMap` in a `const` or `static` initializer while retaining/// random seed generation, you can wrap the `HashMap` in [`LazyLock`]./// Alternatively, you can construct a `HashMap` in a `const` or `static` initializer using a different/// hasher that does not rely on a random seed. **Be aware that a `HashMap` created this way is not/// resistant to HashDoS attacks!**/// [`LazyLock`]: crate::sync::LazyLock/// use std::hash::{BuildHasherDefault, DefaultHasher};/// use std::sync::{LazyLock, Mutex};/// // HashMaps with a fixed, non-random hasher/// const NONRANDOM_EMPTY_MAP: HashMap<String, Vec<i32>, BuildHasherDefault<DefaultHasher>> =///     HashMap::with_hasher(BuildHasherDefault::new());/// static NONRANDOM_MAP: Mutex<HashMap<String, Vec<i32>, BuildHasherDefault<DefaultHasher>>> =///     Mutex::new(HashMap::with_hasher(BuildHasherDefault::new()));/// // HashMaps using LazyLock to retain random seeding/// const RANDOM_EMPTY_MAP: LazyLock<HashMap<String, Vec<i32>>> =///     LazyLock::new(HashMap::new);/// static RANDOM_MAP: LazyLock<Mutex<HashMap<String, Vec<i32>>>> =///     LazyLock::new(|| Mutex::new(HashMap::new()));/// `capacity`. If `capacity` is zero, the hash map will not allocate./// use std::hash::RandomState;/// Creates an empty `HashMap` with at least the specified capacity, using/// The `hasher` passed should implement the [`BuildHasher`] trait forrustc_lint_query_instability///     println!("{key}");///     println!("{val}");/// let mut map = HashMap::from([///     println!("key: {key} val: {val}");/// In the current implementation, iterating over map takes O(capacity) time/// mutable borrow on the map to optimize its implementation./// Creates an iterator which uses a closure to determine if an element (key-value pair) should be removed./// Use [`retain`] with a negated predicate if you do not need the returned iterator./// [`retain`]: HashMap::retain/// Splitting a map into even and odd keys, reusing the original map:/// let extracted: HashMap<i32, i32> = map.extract_if(|k, _v| k % 2 == 0).collect();/// let mut evens = extracted.keys().copied().collect::<Vec<_>>();/// let mut odds = map.keys().copied().collect::<Vec<_>>();/// let mut map: HashMap<i32, i32> = (0..8).map(|x| (x, x*10)).collect();/// In the current implementation, this operation takes O(capacity) time/// in the `HashMap`. The collection may reserve more space to speculatively/// avoid frequent reallocations. After calling `reserve`,/// avoid frequent reallocations. After calling `try_reserve`,/// it returns `Ok(())`./// map.try_reserve(10).expect("why is the test harness OOMing on a handful of bytes?");///     letters.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);///     name: &'static str, // ignored by equality and hashing operations/// impl Hash for S {/// This method performs a check to ensure there are no duplicate keys, which currently has a time-complexity of O(n^2),/// so be careful when passing many keys./// Creates an empty `HashMap<K, V, S>`, with the `Default` value for the hasher./// Converts a `[(K, V); N]` into a `HashMap<K, V>`.// Note: as what is currently the most convenient built-in way to construct// a HashMap, a simple usage of this function must not *require* the user// to provide a type annotation in order to infer the third type parameter// (the hasher parameter, conventionally "S").// To that end, this impl is defined using RandomState as the concrete// type of S, rather than being generic over `S: BuildHasher + Default`.// It is expected that users who want to specify a hasher will manually use// `with_capacity_and_hasher`.// If type parameter defaults worked on impls, and if type parameter// defaults could be mixed with const generics, then perhaps// this could be generalized.// See also the equivalent impl on HashSet./// An iterator over the entries of a `HashMap`./// [`iter`]: HashMap::iter/// let iter = map.iter();/// A mutable iterator over the entries of a `HashMap`./// [`iter_mut`]: HashMap::iter_mut/// let iter = map.iter_mut();/// An owning iterator over the entries of a `HashMap`./// let iter = map.into_iter();/// An iterator over the keys of a `HashMap`./// [`keys`]: HashMap::keys/// let iter_keys = map.keys();/// An iterator over the values of a `HashMap`./// [`values`]: HashMap::values/// let iter_values = map.values();/// A draining iterator over the entries of a `HashMap`./// [`drain`]: HashMap::drain/// let iter = map.drain();"iterators are lazy and do nothing unless consumed; \
    use `retain` to remove and discard elements"/// A draining, filtering iterator over the entries of a `HashMap`./// This `struct` is created by the [`extract_if`] method on [`HashMap`]./// [`extract_if`]: HashMap::extract_if/// let iter = map.extract_if(|_k, v| *v % 2 == 0);/// A mutable iterator over the values of a `HashMap`./// [`values_mut`]: HashMap::values_mut/// let iter_values = map.values_mut();/// An owning iterator over the keys of a `HashMap`./// [`into_keys`]: HashMap::into_keys/// let iter_keys = map.into_keys();/// An owning iterator over the values of a `HashMap`./// [`into_values`]: HashMap::into_values/// let iter_keys = map.into_values();/// [`entry`]: HashMap::entry/// let vec: Vec<(&str, i32)> = map.into_iter().collect();/// let value = "hoho";/// map.entry("poneyland").or_insert_with(|| value);/// assert_eq!(map["poneyland"], "hoho");/// use std::collections::hash_map::Entry;/// [`into_mut`]: Self::into_mut/// [`get_mut`]: Self::get_mut///     o.insert_entry(37);/// Constructs a `HashMap<K, V>` from an iterator of key-value pairs.map_try_reserve_error//! Unordered containers, implemented as hash-tablestest_insert_does_not_overwrite_the_value/// A [hash set] implemented as a `HashMap` where the value is `()`./// be encapsulated to the `HashSet` that observed the logic error and not/// [`Eq`] and [`Hash`]. We must also derive [`PartialEq`],/// which is required if [`Eq`] is derived.///     println!("{x:?}");/// A `HashSet` with a known list of items can be initialized from an array:/// let viking_names = HashSet::from(["Einar", "Olaf", "Harald"]);/// [hash set]: crate::collections#use-the-set-variant-of-any-of-these-maps-when/// [`HashMap`]: crate::collections::HashMap/// Like `HashMap`, `HashSet` is randomly seeded: each `HashSet` instance uses a different seed,/// which means that `HashSet::new` cannot be used in const context. To construct a `HashSet` in the/// initializer of a `const` or `static` item, you will have to use a different hasher that does not/// involve a random seed, as demonstrated in the following example. **A `HashSet` constructed this/// way is not resistant against HashDoS!**/// const EMPTY_SET: HashSet<String, BuildHasherDefault<DefaultHasher>> =///     HashSet::with_hasher(BuildHasherDefault::new());/// static SET: Mutex<HashSet<String, BuildHasherDefault<DefaultHasher>>> =///     Mutex::new(HashSet::with_hasher(BuildHasherDefault::new()));/// `capacity`. If `capacity` is zero, the hash set will not allocate./// In the current implementation, iterating over set takes O(capacity) time/// Clears the set, returning all elements as an iterator. Keeps the/// drops the remaining elements. The returned iterator keeps a mutable/// borrow on the set to optimize its implementation./// let mut set = HashSet::from([1, 2, 3]);///     println!("{i}");/// [`retain`]: HashSet::retain/// Splitting a set into even and odd values, reusing the original set:/// let extracted: HashSet<i32> = set.extract_if(|v| v % 2 == 0).collect();/// let mut evens = extracted.into_iter().collect::<Vec<_>>();/// let mut set = HashSet::from([1, 2, 3, 4, 5, 6]);/// assert_eq!(set, HashSet::from([2, 4, 6]));/// Creates an empty `HashSet` with at least the specified capacity, using/// let hasher: &RandomState = set.hasher();/// in the `HashSet`. The collection may reserve more space to speculatively/// set.try_reserve(10).expect("why is the test harness OOMing on a handful of bytes?");/// let a = HashSet::from([1, 2, 3]);/// let b = HashSet::from([4, 2, 3, 4]);///     println!("{x}"); // Print 1/// When an equal element is present in `self` and `other`/// then the resulting `Intersection` may yield references to/// one or the other. This can be relevant if `T` contains fields which/// are not compared by its `Eq` implementation, and may hold different/// value between the two equal copies of `T` in the two sets./// let set = HashSet::from([1, 2, 3]);/// #![feature(hash_set_entry)]/// use std::collections::hash_set::Entry::*;/// let sup = HashSet::from([1, 2, 3]);/// let sub = HashSet::from([1, 2]);/// - If the set did not previously contain this value, `true` is returned./// - If the set already contained this value, `false` is returned,///   and the set is not modified: original value is not replaced,///   and the value passed as argument is dropped./// Converts a `[T; N]` into a `HashSet<T>`.// a HashSet, a simple usage of this function must not *require* the user// See also the equivalent impl on HashMap./// let b = HashSet::from([3, 4, 5]);/// let b = HashSet::from([2, 3, 4]);/// [`iter`]: HashSet::iter/// [`drain`]: HashSet::drain/// let mut a = HashSet::from([1, 2, 3]);/// let mut drain = a.drain();/// A draining, filtering iterator over the items of a `HashSet`./// This `struct` is created by the [`extract_if`] method on [`HashSet`]./// [`extract_if`]: HashSet::extract_if/// let mut extract_ifed = a.extract_if(|v| v % 2 == 0);/// [`intersection`]: HashSet::intersection/// let mut intersection = a.intersection(&b);/// [`difference`]: HashSet::difference/// let mut difference = a.difference(&b);/// [`symmetric_difference`]: HashSet::symmetric_difference/// let mut intersection = a.symmetric_difference(&b);/// [`union`]: HashSet::union/// let mut union_iter = a.union(&b);/// use std::collections::hash_set::{Entry, HashSet};/// let mut set = HashSet::from(["a", "b"]);/// use std::collections::hash_set::HashSet;/// use std::collections::hash_set::Entry;// FIXME(#82080) The deprecation here is only theoretical, and does not actually produce a warning.//! Rust's standard collection library provides efficient implementations of the//! most common general purpose programming data structures. By using the//! standard implementations, it should be possible for two libraries to//! communicate without significant data conversion.//! To get this out of the way: you should probably just use [`Vec`] or [`HashMap`].//! These two collections cover most use cases for generic data storage and//! processing. They are exceptionally good at doing what they do. All the other//! collections in the standard library have specific use cases where they are//! the optimal choice, but these cases are borderline *niche* in comparison.//! Even when `Vec` and `HashMap` are technically suboptimal, they're probably a//! good enough choice to get started.//! Rust's collections can be grouped into four major categories://! * Sequences: [`Vec`], [`VecDeque`], [`LinkedList`]//! * Maps: [`HashMap`], [`BTreeMap`]//! * Sets: [`HashSet`], [`BTreeSet`]//! * Misc: [`BinaryHeap`]//! # When Should You Use Which Collection?//! These are fairly high-level and quick break-downs of when each collection//! should be considered. Detailed discussions of strengths and weaknesses of//! individual collections can be found on their own documentation pages.//! ### Use a [`Vec`] when://! * You want to collect items up to be processed or sent elsewhere later, and//!   don't care about any properties of the actual values being stored.//! * You want a sequence of elements in a particular order, and will only be//!   appending to (or near) the end.//! * You want a stack.//! * You want a resizable array.//! * You want a heap-allocated array.//! ### Use a [`VecDeque`] when://! * You want a [`Vec`] that supports efficient insertion at both ends of the//!   sequence.//! * You want a queue.//! * You want a double-ended queue (deque).//! ### Use a [`LinkedList`] when://! * You want a [`Vec`] or [`VecDeque`] of unknown size, and can't tolerate//!   amortization.//! * You want to efficiently split and append lists.//! * You are *absolutely* certain you *really*, *truly*, want a doubly linked//!   list.//! ### Use a [`HashMap`] when://! * You want to associate arbitrary keys with an arbitrary value.//! * You want a cache.//! * You want a map, with no extra functionality.//! ### Use a [`BTreeMap`] when://! * You want a map sorted by its keys.//! * You want to be able to get a range of entries on-demand.//! * You're interested in what the smallest or largest key-value pair is.//! * You want to find the largest or smallest key that is smaller or larger//!   than something.//! ### Use the `Set` variant of any of these `Map`s when://! * You just want to remember which keys you've seen.//! * There is no meaningful value to associate with your keys.//! * You just want a set.//! ### Use a [`BinaryHeap`] when://! * You want to store a bunch of elements, but only ever want to process the//!   "biggest" or "most important" one at any given time.//! * You want a priority queue.//! Choosing the right collection for the job requires an understanding of what//! each collection is good at. Here we briefly summarize the performance of//! different collections for certain important operations. For further details,//! see each type's documentation, and note that the names of actual methods may//! differ from the tables below on certain collections.//! Throughout the documentation, we will adhere to the following conventions//! for operation notation://! * The collection's size is denoted by `n`.//! * If a second collection is involved, its size is denoted by `m`.//! * Item indices are denoted by `i`.//! * Operations which have an *amortized* cost are suffixed with a `*`.//! * Operations with an *expected* cost are suffixed with a `~`.//! Calling operations that add to a collection will occasionally require a//! collection to be resized - an extra operation that takes *O*(*n*) time.//! *Amortized* costs are calculated to account for the time cost of such resize//! operations *over a sufficiently large series of operations*. An individual//! operation may be slower or faster due to the sporadic nature of collection//! resizing, however the average cost per operation will approach the amortized//! cost.//! Rust's collections never automatically shrink, so removal operations aren't//! amortized.//! [`HashMap`] uses *expected* costs. It is theoretically possible, though very//! unlikely, for [`HashMap`] to experience significantly worse performance than//! the expected cost. This is due to the probabilistic nature of hashing - i.e.//! it is possible to generate a duplicate hash given some input key that will//! require extra computation to correct.//! ## Cost of Collection Operations//! |                | get(i)                 | insert(i)               | remove(i)              | append(Vec(m))    | split_off(i)           | range           | append       |//! |----------------|------------------------|-------------------------|------------------------|-------------------|------------------------|-----------------|--------------|//! | [`Vec`]        | *O*(1)                 | *O*(*n*-*i*)*           | *O*(*n*-*i*)           | *O*(*m*)*         | *O*(*n*-*i*)           | N/A             | N/A          |//! | [`VecDeque`]   | *O*(1)                 | *O*(min(*i*, *n*-*i*))* | *O*(min(*i*, *n*-*i*)) | *O*(*m*)*         | *O*(min(*i*, *n*-*i*)) | N/A             | N/A          |//! | [`LinkedList`] | *O*(min(*i*, *n*-*i*)) | *O*(min(*i*, *n*-*i*))  | *O*(min(*i*, *n*-*i*)) | *O*(1)            | *O*(min(*i*, *n*-*i*)) | N/A             | N/A          |//! | [`HashMap`]    | *O*(1)~                | *O*(1)~*                | *O*(1)~                | N/A               | N/A                    | N/A             | N/A          |//! | [`BTreeMap`]   | *O*(log(*n*))          | *O*(log(*n*))           | *O*(log(*n*))          | N/A               | N/A                    | *O*(log(*n*))   | *O*(*n*+*m*) |//! Note that where ties occur, [`Vec`] is generally going to be faster than//! [`VecDeque`], and [`VecDeque`] is generally going to be faster than//! [`LinkedList`].//! For Sets, all operations have the cost of the equivalent Map operation.//! # Correct and Efficient Usage of Collections//! Of course, knowing which collection is the right one for the job doesn't//! instantly permit you to use it correctly. Here are some quick tips for//! efficient and correct usage of the standard collections in general. If//! you're interested in how to use a specific collection in particular, consult//! its documentation for detailed discussion and code examples.//! ## Capacity Management//! Many collections provide several constructors and methods that refer to//! "capacity". These collections are generally built on top of an array.//! Optimally, this array would be exactly the right size to fit only the//! elements stored in the collection, but for the collection to do this would//! be very inefficient. If the backing array was exactly the right size at all//! times, then every time an element is inserted, the collection would have to//! grow the array to fit it. Due to the way memory is allocated and managed on//! most computers, this would almost surely require allocating an entirely new//! array and copying every single element from the old one into the new one.//! Hopefully you can see that this wouldn't be very efficient to do on every//! Most collections therefore use an *amortized* allocation strategy. They//! generally let themselves have a fair amount of unoccupied space so that they//! only have to grow on occasion. When they do grow, they allocate a//! substantially larger array to move the elements into so that it will take a//! while for another grow to be required. While this strategy is great in//! general, it would be even better if the collection *never* had to resize its//! backing array. Unfortunately, the collection itself doesn't have enough//! information to do this itself. Therefore, it is up to us programmers to give//! it hints.//! Any `with_capacity` constructor will instruct the collection to allocate//! enough space for the specified number of elements. Ideally this will be for//! exactly that many elements, but some implementation details may prevent//! this. See collection-specific documentation for details. In general, use//! `with_capacity` when you know exactly how many elements will be inserted, or//! at least have a reasonable upper-bound on that number.//! When anticipating a large influx of elements, the `reserve` family of//! methods can be used to hint to the collection how much room it should make//! for the coming items. As with `with_capacity`, the precise behavior of//! these methods will be specific to the collection of interest.//! For optimal performance, collections will generally avoid shrinking//! themselves. If you believe that a collection will not soon contain any more//! elements, or just really need the memory, the `shrink_to_fit` method prompts//! the collection to shrink the backing array to the minimum size capable of//! holding its elements.//! Finally, if ever you're interested in what the actual capacity of the//! collection is, most collections provide a `capacity` method to query this//! information on demand. This can be useful for debugging purposes, or for//! use with the `reserve` methods.//! ## Iterators//! [Iterators][crate::iter]//! are a powerful and robust mechanism used throughout Rust's//! standard libraries. Iterators provide a sequence of values in a generic,//! safe, efficient and convenient way. The contents of an iterator are usually//! *lazily* evaluated, so that only the values that are actually needed are//! ever actually produced, and no allocation need be done to temporarily store//! them. Iterators are primarily consumed using a `for` loop, although many//! functions also take iterators where a collection or sequence of values is//! All of the standard collections provide several iterators for performing//! bulk manipulation of their contents. The three primary iterators almost//! every collection should provide are `iter`, `iter_mut`, and `into_iter`.//! Some of these are not provided on collections where it would be unsound or//! unreasonable to provide them.//! `iter` provides an iterator of immutable references to all the contents of a//! collection in the most "natural" order. For sequence collections like [`Vec`],//! this means the items will be yielded in increasing order of index starting//! at 0. For ordered collections like [`BTreeMap`], this means that the items//! will be yielded in sorted order. For unordered collections like [`HashMap`],//! the items will be yielded in whatever order the internal representation made//! most convenient. This is great for reading through all the contents of the//! let vec = vec![1, 2, 3, 4];//! for x in vec.iter() {//!    println!("vec contained {x:?}");//! `iter_mut` provides an iterator of *mutable* references in the same order as//! `iter`. This is great for mutating all the contents of the collection.//! let mut vec = vec![1, 2, 3, 4];//! for x in vec.iter_mut() {//!    *x += 1;//! `into_iter` transforms the actual collection into an iterator over its//! contents by-value. This is great when the collection itself is no longer//! needed, and the values are needed elsewhere. Using `extend` with `into_iter`//! is the main way that contents of one collection are moved into another.//! `extend` automatically calls `into_iter`, and takes any <code>T: [IntoIterator]</code>.//! Calling `collect` on an iterator itself is also a great way to convert one//! collection into another. Both of these methods should internally use the//! capacity management tools discussed in the previous section to do this as//! efficiently as possible.//! let mut vec1 = vec![1, 2, 3, 4];//! let vec2 = vec![10, 20, 30, 40];//! vec1.extend(vec2);//! use std::collections::VecDeque;//! let vec = [1, 2, 3, 4];//! let buf: VecDeque<_> = vec.into_iter().collect();//! Iterators also provide a series of *adapter* methods for performing common//! threads to sequences. Among the adapters are functional favorites like `map`,//! `fold`, `skip` and `take`. Of particular interest to collections is the//! `rev` adapter, which reverses any iterator that supports this operation. Most//! collections provide reversible iterators as the way to iterate over them in//! reverse order.//! for x in vec.iter().rev() {//! Several other collection methods also return iterators to yield a sequence//! of results but avoid allocating an entire collection to store the result in.//! This provides maximum flexibility as//! [`collect`][crate::iter::Iterator::collect] or//! [`extend`][crate::iter::Extend::extend] can be called to//! "pipe" the sequence into any collection if desired. Otherwise, the sequence//! can be looped over with a `for` loop. The iterator can also be discarded//! after partial use, preventing the computation of the unused items.//! ## Entries//! The `entry` API is intended to provide an efficient mechanism for//! manipulating the contents of a map conditionally on the presence of a key or//! not. The primary motivating use case for this is to provide efficient//! accumulator maps. For instance, if one wishes to maintain a count of the//! number of times each key has been seen, they will have to perform some//! conditional logic on whether this is the first time the key has been seen or//! not. Normally, this would require a `find` followed by an `insert`,//! effectively duplicating the search effort on each insertion.//! When a user calls `map.entry(key)`, the map will search for the key and//! then yield a variant of the `Entry` enum.//! If a `Vacant(entry)` is yielded, then the key *was not* found. In this case//! the only valid operation is to `insert` a value into the entry. When this is//! done, the vacant entry is consumed and converted into a mutable reference to//! the value that was inserted. This allows for further manipulation of the//! value beyond the lifetime of the search itself. This is useful if complex//! logic needs to be performed on the value regardless of whether the value was//! just inserted.//! If an `Occupied(entry)` is yielded, then the key *was* found. In this case,//! the user has several options: they can `get`, `insert` or `remove` the//! value of the occupied entry. Additionally, they can convert the occupied//! entry into a mutable reference to its value, providing symmetry to the//! vacant `insert` case.//! Here are the two primary ways in which `entry` is used. First, a simple//! example where the logic performed on the values is trivial.//! #### Counting the number of times each character in a string occurs//! use std::collections::btree_map::BTreeMap;//! let mut count = BTreeMap::new();//! let message = "she sells sea shells by the sea shore";//! for c in message.chars() {//!     *count.entry(c).or_insert(0) += 1;//! assert_eq!(count.get(&'s'), Some(&8));//! println!("Number of occurrences of each character");//! for (char, count) in &count {//!     println!("{char}: {count}");//! When the logic to be performed on the value is more complex, we may simply//! use the `entry` API to ensure that the value is initialized and perform the//! logic afterwards.//! #### Tracking the inebriation of customers at a bar//! // A client of the bar. They have a blood alcohol level.//! struct Person { blood_alcohol: f32 }//! // All the orders made to the bar, by client ID.//! let orders = vec![1, 2, 1, 2, 3, 4, 1, 2, 2, 3, 4, 1, 1, 1];//! // Our clients.//! let mut blood_alcohol = BTreeMap::new();//! for id in orders {//!     // If this is the first time we've seen this customer, initialize them//!     // with no blood alcohol. Otherwise, just retrieve them.//!     let person = blood_alcohol.entry(id).or_insert(Person { blood_alcohol: 0.0 });//!     // Reduce their blood alcohol level. It takes time to order and drink a beer!//!     person.blood_alcohol *= 0.9;//!     // Check if they're sober enough to have another beer.//!     if person.blood_alcohol > 0.3 {//!         // Too drunk... for now.//!         println!("Sorry {id}, I have to cut you off");//!         // Have another!//!         person.blood_alcohol += 0.1;//! # Insert and complex keys//! If we have a more complex key, calls to `insert` will//! not update the value of the key. For example://! use std::hash::{Hash, Hasher};//!     b: &'static str,//! // we will compare `Foo`s by their `a` value only.//! impl PartialEq for Foo {//!     fn eq(&self, other: &Self) -> bool { self.a == other.a }//! impl Eq for Foo {}//! // we will hash `Foo`s by their `a` value only.//! impl Hash for Foo {//!     fn hash<H: Hasher>(&self, h: &mut H) { self.a.hash(h); }//! impl PartialOrd for Foo {//!     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { self.a.partial_cmp(&other.a) }//! impl Ord for Foo {//!     fn cmp(&self, other: &Self) -> Ordering { self.a.cmp(&other.a) }//! let mut map = BTreeMap::new();//! map.insert(Foo { a: 1, b: "baz" }, 99);//! // We already have a Foo with an a of 1, so this will be updating the value.//! map.insert(Foo { a: 1, b: "xyz" }, 100);//! // The value has been updated...//! assert_eq!(map.values().next().unwrap(), &100);//! // ...but the key hasn't changed. b is still "baz", not "xyz".//! assert_eq!(map.keys().next().unwrap().b, "baz");env_impos_imp/// Returns the current working directory as a [`PathBuf`]./// This function [currently] corresponds to the `getcwd` function on Unix/// and the `GetCurrentDirectoryW` function on Windows./// [currently]: crate::io#platform-specific-behavior/// Returns an [`Err`] if the current working directory value is invalid./// Possible cases:/// * Current directory does not exist./// * There are insufficient permissions to access the current directory.///     let path = env::current_dir()?;///     println!("The current directory is {}", path.display());set_current_dir/// Changes the current working directory to the specified path./// This function [currently] corresponds to the `chdir` function on Unix/// and the `SetCurrentDirectoryW` function on Windows./// Returns an [`Err`] if the operation fails./// let root = Path::new("/");/// assert!(env::set_current_dir(&root).is_ok());/// println!("Successfully changed working directory to {}!", root.display());VarsOsVars/// An iterator over a snapshot of the environment variables of this process./// This structure is created by [`env::vars()`]. See its documentation for more./// [`env::vars()`]: vars/// This structure is created by [`env::vars_os()`]. See its documentation for more./// [`env::vars_os()`]: vars_os/// Returns an iterator of (variable, value) pairs of strings, for all the/// environment variables of the current process./// The returned iterator contains a snapshot of the process's environment/// variables at the time of this invocation. Modifications to environment/// variables afterwards will not be reflected in the returned iterator./// While iterating, the returned iterator will panic if any key or value in the/// environment is not valid unicode. If this is not desired, consider using/// [`env::vars_os()`]./// // Print all environment variables./// for (key, value) in std::env::vars() {vars_os/// Returns an iterator of (variable, value) pairs of OS strings, for all the/// Note that the returned iterator will not check if the environment variables/// are valid Unicode. If you want to panic on invalid UTF-8,/// use the [`vars`] function instead./// for (key, value) in std::env::vars_os() {///     println!("{key:?}: {value:?}");/// Fetches the environment variable `key` from the current process./// Returns [`VarError::NotPresent`] if:/// - The variable is not set./// - The variable's name contains an equal sign or NUL (`'='` or `'\0'`)./// Returns [`VarError::NotUnicode`] if the variable's value is not valid/// Unicode. If this is not desired, consider using [`var_os`]./// Use [`env!`] or [`option_env!`] instead if you want to check environment/// variables at compile time./// let key = "HOME";/// match env::var(key) {///     Ok(val) => println!("{key}: {val:?}"),///     Err(e) => println!("couldn't interpret {key}: {e}"),_var/// Fetches the environment variable `key` from the current process, returning/// [`None`] if the variable isn't set or if there is another error./// It may return `None` if the environment variable's name contains/// the equal sign character (`=`) or the NUL character./// Note that this function will not check if the environment variable/// is valid Unicode. If you want to have an error on invalid UTF-8,/// use the [`var`] function instead./// match env::var_os(key) {///     Some(val) => println!("{key}: {val:?}"),///     None => println!("{key} is not defined in the environment.")/// If expecting a delimited variable (such as `PATH`), [`split_paths`]/// can be used to separate items._var_os/// The specified environment variable was not present in the current/// process's environment./// The specified environment variable was found, but it did not contain/// valid unicode data. The found data is returned as a payload of this/// The error type for operations interacting with environment variables./// Possibly returned from [`env::var()`]./// [`env::var()`]: varrustc_deprecated_safe_2024/// Sets the environment variable `key` to the value `value` for the currently running/// This function is safe to call in a single-threaded program./// This function is also always safe to call on Windows, in single-threaded/// and multi-threaded programs./// In multi-threaded programs on other operating systems, the only safe option is/// to not use `set_var` or `remove_var` at all./// The exact requirement is: you/// must ensure that there are no other threads concurrently writing or/// *reading*(!) the environment through functions or global variables other/// than the ones in this module. The problem is that these operating systems/// do not provide a thread-safe way to read the environment, and most C/// libraries, including libc itself, do not advertise which functions read/// from the environment. Even functions from the Rust standard library may/// read the environment without going through this module, e.g. for DNS/// lookups from [`std::net::ToSocketAddrs`]. No stable guarantee is made about/// which functions may read from the environment in future versions of a/// library. All this makes it not practically possible for you to guarantee/// that no other thread will read the environment, so the only safe option is/// to not use `set_var` or `remove_var` in multi-threaded programs at all./// Discussion of this unsafety on Unix may be found in:///  - [Austin Group Bugzilla (for POSIX)](https://austingroupbugs.net/view.php?id=188)///  - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)/// To pass an environment variable to a child process, you can instead use [`Command::env`]./// [`std::net::ToSocketAddrs`]: crate::net::ToSocketAddrs/// [`Command::env`]: crate::process::Command::env/// This function may panic if `key` is empty, contains an ASCII equals sign `'='`/// or the NUL character `'\0'`, or when `value` contains the NUL character./// let key = "KEY";///     env::set_var(key, "VALUE");/// assert_eq!(env::var(key), Ok("VALUE".to_string()));remove_var/// Removes an environment variable from the environment of the currently running process.///  - [Austin Group Bugzilla](https://austingroupbugs.net/view.php?id=188)/// To prevent a child process from inheriting an environment variable, you can/// instead use [`Command::env_remove`] or [`Command::env_clear`]./// [`Command::env_remove`]: crate::process::Command::env_remove/// [`Command::env_clear`]: crate::process::Command::env_clear/// This function may panic if `key` is empty, contains an ASCII equals sign/// `'='` or the NUL character `'\0'`, or when the value contains the NUL///     env::remove_var(key);/// assert!(env::var(key).is_err());SplitPaths/// An iterator that splits an environment variable into paths according to/// platform-specific conventions./// The iterator element type is [`PathBuf`]./// This structure is created by [`env::split_paths()`]. See its/// [`env::split_paths()`]: split_paths/// Parses input according to platform conventions for the `PATH`/// Returns an iterator over the paths contained in `unparsed`. The iterator/// element type is [`PathBuf`]./// On most Unix platforms, the separator is `:` and on Windows it is `;`. This/// also performs unquoting on Windows./// [`join_paths`] can be used to recombine elements./// This will panic on systems where there is no delimited `PATH` variable,/// such as UEFI./// let key = "PATH";///     Some(paths) => {///         for path in env::split_paths(&paths) {///             println!("'{}'", path.display());/// The error type for operations on the `PATH` variable. Possibly returned from/// [`env::join_paths()`]./// [`env::join_paths()`]: join_paths/// Joins a collection of [`Path`]s appropriately for the `PATH`/// Returns an [`Err`] (containing an error message) if one of the input/// [`Path`]s contains an invalid character for constructing the `PATH`/// variable (a double quote on Windows or a colon on Unix), or if the system/// does not have a `PATH`-like variable (e.g. UEFI or WASI)./// Joining paths on a Unix-like platform:/// fn main() -> Result<(), env::JoinPathsError> {///     let paths = [Path::new("/bin"), Path::new("/usr/bin")];///     let path_os_string = env::join_paths(paths.iter())?;///     assert_eq!(path_os_string, OsString::from("/bin:/usr/bin"));/// Joining a path containing a colon on a Unix-like platform results in an/// error:/// let paths = [Path::new("/bin"), Path::new("/usr/bi:n")];/// assert!(env::join_paths(paths.iter()).is_err());/// Using `env::join_paths()` with [`env::split_paths()`] to append an item to/// the `PATH` environment variable:///     if let Some(path) = env::var_os("PATH") {///         let mut paths = env::split_paths(&path).collect::<Vec<_>>();///         paths.push(PathBuf::from("/home/xyz/bin"));///         let new_path = env::join_paths(paths)?;///         unsafe { env::set_var("PATH", &new_path); }/// Returns the path of the current user's home directory if known./// This may return `None` if getting the directory fails or if the platform does not have user home directories./// For storing user data and configuration it is often preferable to use more specific directories./// For example, [XDG Base Directories] on Unix or the `LOCALAPPDATA` and `APPDATA` environment variables on Windows./// [XDG Base Directories]: https://specifications.freedesktop.org/basedir-spec/latest//// - Returns the value of the 'HOME' environment variable if it is set///   (and not an empty string)./// - Otherwise, it tries to determine the home directory by invoking the `getpwuid_r` function///   using the UID of the current user. An empty home directory field returned from the///   `getpwuid_r` function is considered to be a valid value./// - Returns `None` if the current user has no entry in the /etc/passwd file./// - Returns the value of the 'USERPROFILE' environment variable if it is set, and is not an empty string./// - Otherwise, [`GetUserProfileDirectory`][msdn] is used to return the path. This may change in the future./// [msdn]: https://docs.microsoft.com/en-us/windows/win32/api/userenv/nf-userenv-getuserprofiledirectorya/// In UWP (Universal Windows Platform) targets this function is unimplemented and always returns `None`./// Before Rust 1.85.0, this function used to return the value of the 'HOME' environment variable/// on Windows, which in Cygwin or Mingw environments could return non-standard paths like `/home/you`/// instead of `C:\Users\you`./// match env::home_dir() {///     Some(path) => println!("Your home directory, probably: {}", path.display()),///     None => println!("Impossible to get your home dir!"),/// Returns the path of a temporary directory./// The temporary directory may be shared among users, or between processes/// with different privileges; thus, the creation of any files or directories/// in the temporary directory must use a secure method to create a uniquely/// named file. Creating a file or directory with a fixed or predictable name/// may result in "insecure temporary file" security vulnerabilities. Consider/// using a crate that securely creates temporary files or directories./// Note that the returned value may be a symbolic link, not a directory./// On Unix, returns the value of the `TMPDIR` environment variable if it is/// set, otherwise the value is OS-specific:/// - On Android, there is no global temporary folder (it is usually allocated///   per-app), it will return the application's cache dir if the program runs///   in application's namespace and system version is Android 13 (or above), or///   `/data/local/tmp` otherwise./// - On Darwin-based OSes (macOS, iOS, etc) it returns the directory provided///   by `confstr(_CS_DARWIN_USER_TEMP_DIR, ...)`, as recommended by [Apple's///   security guidelines][appledoc]./// - On all other unix-based OSes, it returns `/tmp`./// On Windows, the behavior is equivalent to that of [`GetTempPath2`][GetTempPath2] //// [`GetTempPath`][GetTempPath], which this function uses internally./// [changes]: io#platform-specific-behavior/// [GetTempPath2]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-gettemppath2a/// [GetTempPath]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-gettemppatha/// [appledoc]: https://developer.apple.com/library/archive/documentation/Security/Conceptual/SecureCodingGuide/Articles/RaceConditions.html#//apple_ref/doc/uid/TP40002585-SW10///     let dir = env::temp_dir();///     println!("Temporary directory: {}", dir.display());current_exe/// Returns the full filesystem path of the current running executable./// If the executable was invoked through a symbolic link, some platforms will/// return the path of the symbolic link and other platforms will return the/// path of the symbolic link’s target./// If the executable is renamed while it is running, platforms may return the/// path at the time it was loaded instead of the new path./// Acquiring the path of the current executable is a platform-specific operation/// that can fail for a good number of reasons. Some errors can include, but not/// be limited to, filesystem operations failing or general syscall failures./// The output of this function should not be trusted for anything/// that might have security implications. Basically, if users can run/// the executable, they can change the output arbitrarily./// As an example, you can easily introduce a race condition. It goes/// 1. You get the path to the current executable using `current_exe()`, and///    store it in a variable./// 2. Time passes. A malicious actor removes the current executable, and///    replaces it with a malicious one./// 3. You then use the stored path to re-execute the current///    executable./// You expected to safely execute the current executable, but you're/// instead executing something completely different. The code you/// just executed run with your privileges./// This sort of behavior has been known to [lead to privilege escalation] when/// used incorrectly./// [lead to privilege escalation]: https://securityvulns.com/Wdocument183.html/// match env::current_exe() {///     Ok(exe_path) => println!("Path of this executable is: {}",///                              exe_path.display()),///     Err(e) => println!("failed to get current exe path: {e}"),ArgsOs/// An iterator over the arguments of a process, yielding a [`String`] value for/// each argument./// This struct is created by [`env::args()`]. See its documentation/// The first element is traditionally the path of the executable, but it can be/// set to arbitrary text, and might not even exist. This means this property/// should not be relied upon for security purposes./// [`env::args()`]: args/// An iterator over the arguments of a process, yielding an [`OsString`] value/// for each argument./// This struct is created by [`env::args_os()`]. See its documentation/// [`env::args_os()`]: args_os/// Returns the arguments that this program was started with (normally passed/// via the command line)./// set to arbitrary text, and might not even exist. This means this property should/// not be relied upon for security purposes./// On Unix systems the shell usually expands unquoted arguments with glob patterns/// (such as `*` and `?`). On Windows this is not done, and such arguments are/// passed as-is./// On glibc Linux systems, arguments are retrieved by placing a function in `.init_array`./// glibc passes `argc`, `argv`, and `envp` to functions in `.init_array`, as a non-standard/// extension. This allows `std::env::args` to work even in a `cdylib` or `staticlib`, as it/// does on macOS and Windows./// The returned iterator will panic during iteration if any argument to the/// process is not valid Unicode. If this is not desired,/// use the [`args_os`] function instead./// // Prints each argument on a separate line/// for argument in env::args() {///     println!("{argument}");/// extension. This allows `std::env::args_os` to work even in a `cdylib` or `staticlib`, as it/// Note that the returned iterator will not check if the arguments to the/// process are valid Unicode. If you want to panic on invalid UTF-8,/// use the [`args`] function instead./// for argument in env::args_os() {///     println!("{argument:?}");// Methods which skip args cannot simply delegate to the inner iterator,// because `env::args` states that we will "panic during iteration if any// argument to the process is not valid Unicode".// This offers two possible interpretations:// - a skipped argument is never encountered "during iteration"// - even a skipped argument is encountered "during iteration"// As a panic can be observed, we err towards validating even skipped// arguments for now, though this is not explicitly promised by the API.env_constsARCH/// A string describing the architecture of the CPU that is currently in use./// An example value may be: `"x86"`, `"arm"` or `"riscv64"`./// <details><summary>Full list of possible values</summary>/// * `"x86"`/// * `"x86_64"`/// * `"arm"`/// * `"aarch64"`/// * `"m68k"`/// * `"mips"`/// * `"mips32r6"`/// * `"mips64"`/// * `"mips64r6"`/// * `"csky"`/// * `"powerpc"`/// * `"powerpc64"`/// * `"riscv32"`/// * `"riscv64"`/// * `"s390x"`/// * `"sparc"`/// * `"sparc64"`/// * `"hexagon"`/// * `"loongarch32"`/// * `"loongarch64"`/// A string describing the family of the operating system./// An example value may be: `"unix"`, or `"windows"`./// This value may be an empty string if the family is unknown./// * `"unix"`/// * `"windows"`/// * `"itron"`/// * `"wasm"`/// * `""`OS/// A string describing the specific operating system in use./// An example value may be: `"linux"`, or `"freebsd"`./// * `"linux"`/// * `"macos"`/// * `"android"`/// * `"ios"`/// * `"openbsd"`/// * `"freebsd"`/// * `"netbsd"`/// * `"wasi"`/// * `"hermit"`/// * `"aix"`/// * `"apple"`/// * `"dragonfly"`/// * `"emscripten"`/// * `"espidf"`/// * `"fortanix"`/// * `"uefi"`/// * `"fuchsia"`/// * `"haiku"`/// * `"watchos"`/// * `"visionos"`/// * `"tvos"`/// * `"horizon"`/// * `"hurd"`/// * `"illumos"`/// * `"l4re"`/// * `"nto"`/// * `"redox"`/// * `"solaris"`/// * `"solid_asp3"`/// * `"vexos"`/// * `"vita"`/// * `"vxworks"`/// * `"xous"`/// Specifies the filename prefix, if any, used for shared libraries on this platform./// This is either `"lib"` or an empty string. (`""`)./// Specifies the filename suffix, if any, used for shared libraries on this platform./// An example value may be: `".so"`, `".elf"`, or `".dll"`./// The possible values are identical to those of [`DLL_EXTENSION`], but with the leading period included.DLL_EXTENSION/// Specifies the file extension, if any, used for shared libraries on this platform that goes after the dot./// An example value may be: `"so"`, `"elf"`, or `"dll"`./// * `"so"`/// * `"dylib"`/// * `"dll"`/// * `"sgxs"`/// * `"a"`/// * `"elf"`/// * `""` (an empty string)EXE_SUFFIX/// Specifies the filename suffix, if any, used for executable binaries on this platform./// An example value may be: `".exe"`, or `".efi"`./// The possible values are identical to those of [`EXE_EXTENSION`], but with the leading period included./// Specifies the file extension, if any, used for executable binaries on this platform./// An example value may be: `"exe"`, or an empty string (`""`)./// * `"bin"`/// * `"exe"`/// * `"efi"`/// * `"js"`/// Constants associated with the current target//! Inspection and manipulation of the process's environment.//! This module contains functions to inspect various aspects such as//! environment variables, process arguments, the current directory, and various//! other important directories.//! There are several functions and structs in this module that have a//! counterpart ending in `os`. Those ending in `os` will return an [`OsString`]//! and those without will return a [`String`]./// The error being reported.show_backtrace/// Whether a backtrace should be included as part of the report./// Whether the report should be pretty-printed.Report/// An error reporter that prints an error and its sources./// Report also exposes configuration options for formatting the error sources, either entirely on a/// single line, or in multi-line format with each source on a new line./// `Report` only requires that the wrapped error implement `Error`. It doesn't require that the/// wrapped error be `Send`, `Sync`, or `'static`./// #![feature(error_reporter)]/// use std::error::{Error, Report};///         Err(e) => println!("Error: {}", Report::new(e)),/// This example produces the following output:/// Error: SuperError is here!: SuperErrorSideKick is here!/// ## Output consistency/// Report prints the same output via `Display` and `Debug`, so it works well with/// [`Result::unwrap`]/[`Result::expect`] which print their `Err` variant via `Debug`:/// use std::error::Report;/// # struct SuperError {/// #     source: SuperErrorSideKick,/// # impl fmt::Display for SuperError {/// #     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {/// #         write!(f, "SuperError is here!")/// # impl Error for SuperError {/// #     fn source(&self) -> Option<&(dyn Error + 'static)> {/// #         Some(&self.source)/// # struct SuperErrorSideKick;/// # impl fmt::Display for SuperErrorSideKick {/// #         write!(f, "SuperErrorSideKick is here!")/// # impl Error for SuperErrorSideKick {}/// # fn get_super_error() -> Result<(), SuperError> {/// #     Err(SuperError { source: SuperErrorSideKick })/// get_super_error().map_err(Report::new).unwrap();/// thread 'main' panicked at src/error.rs:34:40:/// called `Result::unwrap()` on an `Err` value: SuperError is here!: SuperErrorSideKick is here!/// note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace/// ## Return from `main`/// `Report` also implements `From` for all types that implement [`Error`]; this when combined with/// the `Debug` output means `Report` is an ideal starting place for formatting errors returned/// from `main`./// fn main() -> Result<(), Report<SuperError>> {///     get_super_error()?;/// **Note**: `Report`s constructed via `?` and `From` will be configured to use the single line/// output format. If you want to make sure your `Report`s are pretty printed and include backtrace/// you will need to manually convert and enable those flags.///     get_super_error()///         .map_err(Report::from)///         .map_err(|r| r.pretty(true).show_backtrace(true))?;/// Error: SuperError is here!///       SuperErrorSideKick is here!/// Creates a new `Report` from an input error./// Enable pretty-printing the report across multiple lines./// let error = SuperError { source: SuperErrorSideKick };/// let report = Report::new(error).pretty(true);/// eprintln!("Error: {report:?}");/// When there are multiple source errors the causes will be numbered in order of iteration/// starting from the outermost error./// # struct SuperErrorSideKick {/// #     source: SuperErrorSideKickSideKick,/// # impl Error for SuperErrorSideKick {/// # struct SuperErrorSideKickSideKick;/// # impl fmt::Display for SuperErrorSideKickSideKick {/// #         write!(f, "SuperErrorSideKickSideKick is here!")/// # impl Error for SuperErrorSideKickSideKick { }/// let source = SuperErrorSideKickSideKick;/// let source = SuperErrorSideKick { source };/// let error = SuperError { source };///    0: SuperErrorSideKick is here!///    1: SuperErrorSideKickSideKick is here!/// Display backtrace if available when using pretty output format./// **Note**: Report will search for the first `Backtrace` it can find starting from the/// outermost error. In this example it will display the backtrace from the second error in the/// sources, `SuperErrorSideKick`./// use std::error::Request;/// struct SuperErrorSideKick {///     backtrace: Backtrace,/// impl SuperErrorSideKick {///     fn new() -> SuperErrorSideKick {///         SuperErrorSideKick { backtrace: Backtrace::force_capture() }/// impl Error for SuperErrorSideKick {///         request.provide_ref::<Backtrace>(&self.backtrace);/// // The rest of the example is unchanged .../// let source = SuperErrorSideKick::new();/// let report = Report::new(error).pretty(true).show_backtrace(true);/// This example produces something similar to the following output:///    0: rust_out::main::_doctest_main_src_error_rs_1158_0::SuperErrorSideKick::new///    1: rust_out::main::_doctest_main_src_error_rs_1158_0///    2: rust_out::main///    3: core::ops::function::FnOnce::call_once///    4: std::sys::backtrace::__rust_begin_short_backtrace///    5: std::rt::lang_start::{{closure}}///    6: std::panicking::try///    7: std::rt::lang_start_internal///    8: std::rt::lang_start///    9: main///   10: __libc_start_main///   11: _startfmt_singleline/// Format the report as a single line.fmt_multiline/// Format the report as multiple lines, with each error cause on its own line.// This type intentionally outputs the same format for `Display` and `Debug`for// situations where you unwrap a `Report` or return it from main./// Wrapper type for indenting the inner source.//! [`CStr`], [`CString`], and related types.//! [`OsString`] and [`OsStr`] are useful when you need to transfer//! strings to and from the operating system itself, or when capturing//! the output of external commands. Conversions between [`OsString`],//! [`OsStr`] and Rust strings work similarly to those for [`CString`]//! and [`CStr`].//! * [`OsString`] losslessly represents an owned platform string. However, this//! representation is not necessarily in a form native to the platform.//! In the Rust standard library, various APIs that transfer strings to/from the operating//! system use [`OsString`] instead of plain strings. For example,//! [`env::var_os()`] is used to query environment variables; it//! returns an <code>[Option]<[OsString]></code>. If the environment variable//! exists you will get a <code>[Some]\(os_string)</code>, which you can//! *then* try to convert to a Rust string. This yields a [`Result`], so that//! your code can detect errors in case the environment variable did//! not in fact contain valid Unicode data.//! * [`OsStr`] losslessly represents a borrowed reference to a platform string.//! However, this representation is not necessarily in a form native to the platform.//! It can be converted into a UTF-8 Rust string slice in a similar way to//! [`OsString`].//! # Conversions//! ## On Unix//! On Unix, [`OsStr`] implements the//! <code>std::os::unix::ffi::[OsStrExt][unix.OsStrExt]</code> trait, which//! augments it with two methods, [`from_bytes`] and [`as_bytes`].//! These do inexpensive conversions from and to byte slices.//! Additionally, on Unix [`OsString`] implements the//! <code>std::os::unix::ffi::[OsStringExt][unix.OsStringExt]</code> trait,//! which provides [`from_vec`] and [`into_vec`] methods that consume//! their arguments, and take or produce vectors of [`u8`].//! ## On Windows//! An [`OsStr`] can be losslessly converted to a native Windows string. And//! a native Windows string can be losslessly converted to an [`OsString`].//! On Windows, [`OsStr`] implements the//! <code>std::os::windows::ffi::[OsStrExt][windows.OsStrExt]</code> trait,//! which provides an [`encode_wide`] method. This provides an//! iterator that can be [`collect`]ed into a vector of [`u16`]. After a nul//! characters is appended, this is the same as a native Windows string.//! Additionally, on Windows [`OsString`] implements the//! <code>std::os::windows:ffi::[OsStringExt][windows.OsStringExt]</code>//! trait, which provides a [`from_wide`] method to convert a native Windows//! string (without the terminating nul character) to an [`OsString`].//! ## Other platforms//! Many other platforms provide their own extension traits in a//! `std::os::*::ffi` module.//! ## On all platforms//! On all platforms, [`OsStr`] consists of a sequence of bytes that is encoded as a superset of//! UTF-8; see [`OsString`] for more details on its encoding on different platforms.//! For limited, inexpensive conversions from and to bytes, see [`OsStr::as_encoded_bytes`] and//! [`OsStr::from_encoded_bytes_unchecked`].//! For basic string processing, see [`OsStr::slice_encoded_bytes`].//! [`env::set_var()`]: crate::env::set_var "env::set_var"//! [`env::var_os()`]: crate::env::var_os "env::var_os"//! [unix.OsStringExt]: crate::os::unix::ffi::OsStringExt "os::unix::ffi::OsStringExt"//! [`from_vec`]: crate::os::unix::ffi::OsStringExt::from_vec "os::unix::ffi::OsStringExt::from_vec"//! [`into_vec`]: crate::os::unix::ffi::OsStringExt::into_vec "os::unix::ffi::OsStringExt::into_vec"//! [unix.OsStrExt]: crate::os::unix::ffi::OsStrExt "os::unix::ffi::OsStrExt"//! [`from_bytes`]: crate::os::unix::ffi::OsStrExt::from_bytes "os::unix::ffi::OsStrExt::from_bytes"//! [`as_bytes`]: crate::os::unix::ffi::OsStrExt::as_bytes "os::unix::ffi::OsStrExt::as_bytes"//! [`OsStrExt`]: crate::os::unix::ffi::OsStrExt "os::unix::ffi::OsStrExt"//! [windows.OsStrExt]: crate::os::windows::ffi::OsStrExt "os::windows::ffi::OsStrExt"//! [`encode_wide`]: crate::os::windows::ffi::OsStrExt::encode_wide "os::windows::ffi::OsStrExt::encode_wide"//! [`collect`]: crate::iter::Iterator::collect "iter::Iterator::collect"//! [windows.OsStringExt]: crate::os::windows::ffi::OsStringExt "os::windows::ffi::OsStringExt"//! [`from_wide`]: crate::os::windows::ffi::OsStringExt::from_wide "os::windows::ffi::OsStringExt::from_wide"test_os_string_with_capacitytest_os_string_cleartest_os_string_leaktest_os_string_capacitytest_os_string_reservetest_os_string_reserve_exacttest_os_string_jointest_os_string_defaulttest_os_str_is_emptytest_os_str_lentest_os_str_defaulttest_os_str_clone_intoslice_encoded_bytesslice_out_of_boundsslice_mid_charslice_invalid_dataslice_partial_utf8slice_invalid_edgeslice_between_surrogatesslice_surrogate_edgesys_commonAsInnerFromInnerIntoInner/// A type that can represent owned, mutable platform-native strings, but is/// cheaply inter-convertible with Rust strings./// The need for this type arises from the fact that:/// * On Unix systems, strings are often arbitrary sequences of non-zero///   bytes, in many cases interpreted as UTF-8./// * On Windows, strings are often arbitrary sequences of non-zero 16-bit///   values, interpreted as UTF-16 when it is valid to do so./// * In Rust, strings are always valid UTF-8, which may contain zeros./// `OsString` and [`OsStr`] bridge this gap by simultaneously representing Rust/// and platform-native string values, and in particular allowing a Rust string/// to be converted into an "OS" string with no cost if possible. A consequence/// of this is that `OsString` instances are *not* `NUL` terminated; in order/// to pass to e.g., Unix system call, you should create a [`CStr`]./// `OsString` is to <code>&[OsStr]</code> as [`String`] is to <code>&[str]</code>: the former/// Note, `OsString` and [`OsStr`] internally do not necessarily hold strings in/// the form native to the platform; While on Unix, strings are stored as a/// sequence of 8-bit values, on Windows, where strings are 16-bit value based/// as just discussed, strings are also actually stored as a sequence of 8-bit/// values, encoded in a less-strict variant of UTF-8. This is useful to/// understand when handling capacity and length values./// # Capacity of `OsString`/// Capacity uses units of UTF-8 bytes for OS strings which were created from valid unicode, and/// uses units of bytes in an unspecified encoding for other contents. On a given target, all/// `OsString` and `OsStr` values use the same units for capacity, so the following will work:/// use std::ffi::{OsStr, OsString};/// fn concat_os_strings(a: &OsStr, b: &OsStr) -> OsString {///     let mut ret = OsString::with_capacity(a.len() + b.len()); // This will allocate///     ret.push(a); // This will not allocate further///     ret.push(b); // This will not allocate further///     ret/// # Creating an `OsString`/// **From a Rust string**: `OsString` implements/// <code>[From]<[String]></code>, so you can use <code>my_string.[into]\()</code> to/// create an `OsString` from a normal Rust string./// **From slices:** Just like you can start with an empty Rust/// [`String`] and then [`String::push_str`] some <code>&[str]</code>/// sub-string slices into it, you can create an empty `OsString` with/// the [`OsString::new`] method and then push string slices into it with the/// [`OsString::push`] method./// # Extracting a borrowed reference to the whole OS string/// You can use the [`OsString::as_os_str`] method to get an <code>&[OsStr]</code> from/// an `OsString`; this is effectively a borrowed reference to the/// whole string./// # Conversions/// See the [module's toplevel documentation about conversions][conversions] for a discussion on/// the traits which `OsString` implements for [conversions] from/to native representations./// [conversions]: super#conversions/// [into]: Into::into/// Allows extension traits within `std`./// Borrowed reference to an OS string (see [`OsString`])./// This type represents a borrowed reference to a string in the operating system's preferred/// `&OsStr` is to [`OsString`] as <code>&[str]</code> is to [`String`]: the/// former in each pair are borrowed references; the latter are owned strings./// the traits which `OsStr` implements for [conversions] from/to native representations.// `OsStr::from_inner` and `impl CloneToUninit for OsStr` current implementation relies// on `OsStr` being layout-compatible with `Slice`.// However, `OsStr` layout is considered an implementation detail and must not be relied upon./// Constructs a new empty `OsString`./// let os_string = OsString::new();from_encoded_bytes_unchecked/// Converts bytes to an `OsString` without checking that the bytes contains/// valid [`OsStr`]-encoded data./// The byte encoding is an unspecified, platform-specific, self-synchronizing superset of UTF-8./// By being a self-synchronizing superset of UTF-8, this encoding is also a superset of 7-bit/// ASCII./// See the [module's toplevel documentation about conversions][conversions] for safe,/// cross-platform [conversions] from/to native representations./// As the encoding is unspecified, callers must pass in bytes that originated as a mixture of/// validated UTF-8 and bytes from [`OsStr::as_encoded_bytes`] from within the same Rust version/// built for the same target platform.  For example, reconstructing an `OsString` from bytes sent/// over the network or stored in a file will likely violate these safety rules./// Due to the encoding being self-synchronizing, the bytes from [`OsStr::as_encoded_bytes`] can be/// split either immediately before or immediately after any valid non-empty UTF-8 substring./// let os_str = OsStr::new("Mary had a little lamb");/// let bytes = os_str.as_encoded_bytes();/// let words = bytes.split(|b| *b == b' ');/// let words: Vec<&OsStr> = words.map(|word| {///     // SAFETY:///     // - Each `word` only contains content that originated from `OsStr::as_encoded_bytes`///     // - Only split with ASCII whitespace which is a non-empty UTF-8 substring///     unsafe { OsStr::from_encoded_bytes_unchecked(word) }/// Converts to an [`OsStr`] slice./// use std::ffi::{OsString, OsStr};/// let os_string = OsString::from("foo");/// let os_str = OsStr::new("foo");/// assert_eq!(os_string.as_os_str(), os_str);into_encoded_bytes/// Converts the `OsString` into a byte vector.  To convert the byte vector back into an/// `OsString`, use the [`OsString::from_encoded_bytes_unchecked`] function./// Note: As the encoding is unspecified, any sub-slice of bytes that is not valid UTF-8 should/// be treated as opaque and only comparable within the same Rust version built for the same/// target platform.  For example, sending the bytes over the network or storing it in a file/// will likely result in incompatible data.  See [`OsString`] for more encoding details/// and [`std::ffi`] for platform-specific, specified conversions./// [`std::ffi`]: crate::ffi/// Converts the `OsString` into a [`String`] if it contains valid Unicode data./// On failure, ownership of the original `OsString` is returned./// let string = os_string.into_string();/// assert_eq!(string, Ok(String::from("foo")));/// Extends the string with the given <code>&[OsStr]</code> slice./// let mut os_string = OsString::from("foo");/// os_string.push("bar");/// assert_eq!(&os_string, "foobar");/// Creates a new `OsString` with at least the given capacity./// The string will be able to hold at least `capacity` length units of other/// OS strings without reallocating. This method is allowed to allocate for/// more units than `capacity`. If `capacity` is 0, the string will not/// See the main `OsString` documentation information about encoding and capacity units./// let mut os_string = OsString::with_capacity(10);/// let capacity = os_string.capacity();/// // This push is done without reallocating/// os_string.push("foo");/// assert_eq!(capacity, os_string.capacity());/// Truncates the `OsString` to zero length./// assert_eq!(&os_string, "foo");/// os_string.clear();/// assert_eq!(&os_string, "");/// Returns the capacity this `OsString` can hold without reallocating./// let os_string = OsString::with_capacity(10);/// assert!(os_string.capacity() >= 10);/// Reserves capacity for at least `additional` more capacity to be inserted/// in the given `OsString`. Does nothing if the capacity is/// already sufficient./// The collection may reserve more space to speculatively avoid frequent reallocations./// let mut s = OsString::new();/// Tries to reserve capacity for at least `additional` more length units/// in the given `OsString`. The string may reserve more space to speculatively avoid/// greater than or equal to `self.len() + additional` if it returns `Ok(())`./// Does nothing if capacity is already sufficient. This method preserves/// the contents even if an error occurs./// fn process_data(data: &str) -> Result<OsString, TryReserveError> {///     let mut s = OsString::new();///     s.try_reserve(OsStr::new(data).len())?;///     s.push(data);/// # process_data("123").expect("why is the test harness OOMing on 3 bytes?");/// Reserves the minimum capacity for at least `additional` more capacity to/// be inserted in the given `OsString`. Does nothing if the capacity is/// [`reserve`]: OsString::reserve/// more length units in the given `OsString`. After calling/// Note that the allocator may give the `OsString` more space than it/// [`try_reserve`]: OsString::try_reserve///     s.try_reserve_exact(OsStr::new(data).len())?;/// Shrinks the capacity of the `OsString` to match its length./// let mut s = OsString::from("foo");/// Shrinks the capacity of the `OsString` with a lower bound.into_boxed_os_str/// Converts this `OsString` into a boxed [`OsStr`]./// let s = OsString::from("hello");/// let b: Box<OsStr> = s.into_boxed_os_str();/// Consumes and leaks the `OsString`, returning a mutable reference to the contents,/// `&'a mut OsStr`./// The caller has free choice over the returned lifetime, including 'static./// Indeed, this function is ideally used for data that lives for the remainder of/// the program’s life, as dropping the returned reference will cause a memory leak./// It does not reallocate or shrink the `OsString`, so the leaked allocation may include/// unused capacity that is not part of the returned slice. If you want to discard excess/// capacity, call [`into_boxed_os_str`], and then [`Box::leak`] instead./// However, keep in mind that trimming the capacity may result in a reallocation and copy./// [`into_boxed_os_str`]: Self::into_boxed_os_str/// Truncate the `OsString` to the specified length./// Panics if `len` does not lie on a valid `OsStr` boundary/// (as described in [`OsStr::slice_encoded_bytes`])./// Provides plumbing to `Vec::extend_from_slice` without giving full/// mutable access to the `Vec`./// The slice must be valid for the platform encoding (as described in/// [`OsStr::from_encoded_bytes_unchecked`])./// This bypasses the encoding-dependent surrogate joining, so either/// `self` must not end with a leading surrogate half, or `other` must not/// start with a trailing surrogate half./// Converts a [`String`] into an [`OsString`]./// Copies any value implementing <code>[AsRef]&lt;[OsStr]&gt;</code>/// into a newly allocated [`OsString`]./// Constructs an empty `OsString`./// Coerces into an `OsStr` slice./// Converts a slice of bytes to an OS string slice without checking that the string contains/// valid `OsStr`-encoded data./// built for the same target platform.  For example, reconstructing an `OsStr` from bytes sent/// Yields a <code>&[str]</code> slice if the `OsStr` is valid Unicode./// This conversion may entail doing a check for UTF-8 validity./// assert_eq!(os_str.to_str(), Some("foo"));/// Converts an `OsStr` to a <code>[Cow]<[str]></code>./// Any non-UTF-8 sequences are replaced with/// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD]./// [U+FFFD]: crate::char::REPLACEMENT_CHARACTER/// Calling `to_string_lossy` on an `OsStr` with invalid unicode:/// // Note, due to differences in how Unix and Windows represent strings,/// // we are forced to complicate this example, setting up example `OsStr`s/// // with different source data and via different platform extensions./// // Understand that in reality you could end up with such example invalid/// // sequences simply through collecting user command line arguments, for/// // example./// #[cfg(unix)] {///     use std::ffi::OsStr;///     use std::os::unix::ffi::OsStrExt;///     // Here, the values 0x66 and 0x6f correspond to 'f' and 'o'///     // respectively. The value 0x80 is a lone continuation byte, invalid///     // in a UTF-8 sequence.///     let source = [0x66, 0x6f, 0x80, 0x6f];///     let os_str = OsStr::from_bytes(&source[..]);///     assert_eq!(os_str.to_string_lossy(), "fo�o");/// #[cfg(windows)] {///     use std::ffi::OsString;///     use std::os::windows::prelude::*;///     // Here the values 0x0066 and 0x006f correspond to 'f' and 'o'///     // respectively. The value 0xD800 is a lone surrogate half, invalid///     // in a UTF-16 sequence.///     let source = [0x0066, 0x006f, 0xD800, 0x006f];///     let os_string = OsString::from_wide(&source[..]);///     let os_str = os_string.as_os_str();/// Copies the slice into an owned [`OsString`]./// let os_string = os_str.to_os_string();/// assert_eq!(os_string, OsString::from("foo"));/// Checks whether the `OsStr` is empty./// let os_str = OsStr::new("");/// assert!(os_str.is_empty());/// assert!(!os_str.is_empty());/// Returns the length of this `OsStr`./// Note that this does **not** return the number of bytes in the string in/// OS string form./// The length returned is that of the underlying storage used by `OsStr`./// As discussed in the [`OsString`] introduction, [`OsString`] and `OsStr`/// store strings in a form best suited for cheap inter-conversion between/// native-platform and Rust string forms, which may differ significantly/// from both of them, including in storage size and encoding./// This number is simply useful for passing to other methods, like/// [`OsString::with_capacity`] to avoid reallocations./// assert_eq!(os_str.len(), 0);/// assert_eq!(os_str.len(), 3);/// Converts a <code>[Box]<[OsStr]></code> into an [`OsString`] without copying or allocating.as_encoded_bytes/// Converts an OS string slice to a byte slice.  To convert the byte slice back into an OS/// string slice, use the [`OsStr::from_encoded_bytes_unchecked`] function./// target platform.  For example, sending the slice over the network or storing it in a file/// will likely result in incompatible byte slices.  See [`OsString`] for more encoding details/// Takes a substring based on a range that corresponds to the return value of/// [`OsStr::as_encoded_bytes`]./// The range's start and end must lie on valid `OsStr` boundaries./// A valid `OsStr` boundary is one of:/// - The start of the string/// - The end of the string/// - Immediately before a valid non-empty UTF-8 substring/// - Immediately after a valid non-empty UTF-8 substring/// Panics if `range` does not lie on valid `OsStr` boundaries or if it/// exceeds the end of the string./// #![feature(os_str_slice)]/// let os_str = OsStr::new("foo=bar");/// if let Some(index) = bytes.iter().position(|b| *b == b'=') {///     let key = os_str.slice_encoded_bytes(..index);///     let value = os_str.slice_encoded_bytes(index + 1..);///     assert_eq!(key, "foo");///     assert_eq!(value, "bar");/// [`OsStr::to_ascii_lowercase`]./// let mut s = OsString::from("GRÜßE, JÜRGEN ❤");/// [`OsStr::to_ascii_uppercase`]./// let mut s = OsString::from("Grüße, Jürgen ❤");"to lowercase the value in-place, use `make_ascii_lowercase`"/// To lowercase the value in-place, use [`OsStr::make_ascii_lowercase`]./// let s = OsString::from("Grüße, Jürgen ❤");"to uppercase the value in-place, use `make_ascii_uppercase`"/// To uppercase the value in-place, use [`OsStr::make_ascii_uppercase`]./// let ascii = OsString::from("hello!\n");/// let non_ascii = OsString::from("Grüße, Jürgen ❤");/// assert!(OsString::from("Ferris").eq_ignore_ascii_case("FERRIS"));/// assert!(OsString::from("Ferrös").eq_ignore_ascii_case("FERRöS"));/// assert!(!OsString::from("Ferrös").eq_ignore_ascii_case("FERRÖS"));"this does not display the `OsStr`; \
                  it returns an object that can be displayed"/// Returns an object that implements [`Display`] for safely printing an/// [`OsStr`] that may contain non-Unicode data. This may perform lossy/// conversion, depending on the platform.  If you would like an/// implementation which escapes the [`OsStr`] please use [`Debug`]/// let s = OsStr::new("Hello, world!");/// println!("{}", s.display());/// Copies the string into a newly allocated <code>[Box]&lt;[OsStr]&gt;</code>./// Converts a `Cow<'a, OsStr>` into a <code>[Box]&lt;[OsStr]&gt;</code>,/// Converts a <code>[Box]<[OsStr]></code> into an [`OsString`] without copying or/// Converts an [`OsString`] into a <code>[Box]<[OsStr]></code> without copying or allocating./// Converts an [`OsString`] into an <code>[Arc]<[OsStr]></code> by moving the [`OsString`]/// Copies the string into a newly allocated <code>[Arc]&lt;[OsStr]&gt;</code>./// Converts an [`OsString`] into an <code>[Rc]<[OsStr]></code> by moving the [`OsString`]/// Copies the string into a newly allocated <code>[Rc]&lt;[OsStr]&gt;</code>./// Moves the string into a [`Cow::Owned`]./// Converts the string reference into a [`Cow::Borrowed`]./// Converts a `Cow<'a, OsStr>` into an [`OsString`],/// Tries to convert an `&OsStr` to a `&str`./// let as_str = <&str>::try_from(os_str).unwrap();/// assert_eq!(as_str, "foo");/// Creates an empty `OsStr`./// Helper struct for safely printing an [`OsStr`] with [`format!`] and `{}`./// An [`OsStr`] might contain non-Unicode data. This `struct` implements the/// [`Display`] trait in a way that mitigates that. It is created by the/// [`display`](OsStr::display) method on [`OsStr`]. This may perform lossy/// conversion, depending on the platform. If you would like an implementation/// which escapes the [`OsStr`] please use [`Debug`] instead.//! The [`OsStr`] and [`OsString`] types and associated utilities.// FIXME (#19470): cannot provide PartialOrd<OsStr> for str until we// have more flexible coherence rules.FileTimesjunction_pointerror_containsgot_symlink_permission// Several test fail on windows if the user does not have permission to// create symlinks (the `SeCreateSymbolicLinkPrivilege`). Instead of// disabling these test on Windows, use this function to test whether we// have permission, and return otherwise. This way, we still don't run these// tests most of the time, but at least we do if the user has the right// permissions.file_test_io_smoke_testinvalid_path_raisesfile_test_iounlinking_invalid_path_should_raise_conditionfile_test_io_non_positional_readfile_test_io_seek_and_tell_smoke_testfile_test_io_seek_and_writefile_lock_multiple_sharedfile_lock_blockingfile_lock_dropfile_lock_dupfile_lock_double_unlockfile_lock_blocking_asyncfile_try_lock_asyncfile_test_io_seek_shakedownfile_test_io_eoffile_test_io_read_write_attest_read_buf_attest_read_buf_exact_atset_get_unix_permissionsfile_test_io_seek_read_writetest_seek_read_buffile_test_read_buffile_test_stat_is_correct_on_is_filefile_test_stat_is_correct_on_is_dirfile_test_fileinfo_false_when_checking_is_file_on_a_directoryfile_test_fileinfo_check_exists_before_and_after_file_creationfile_test_directoryinfo_check_exists_before_and_after_mkdirfile_test_directoryinfo_readdirfile_create_new_already_exists_errormkdir_path_already_exists_errorrecursive_mkdirrecursive_mkdir_failureconcurrent_recursive_mkdirrecursive_mkdir_slashrecursive_mkdir_dotrecursive_mkdir_emptyrecursive_rmdirrecursive_rmdir_of_symlinkrecursive_rmdir_of_file_failsrecursive_rmdir_of_file_symlink// only Windows makes a distinction between file and directory symlinks.recursive_rmdir_toctou// takes too much timeunicode_path_is_dirunicode_path_existscopy_file_does_not_existcopy_src_does_not_existcopy_file_okcopy_file_dst_dircopy_file_dst_existscopy_file_src_dircopy_file_preserves_perm_bitscopy_file_preserves_streamscopy_file_returns_metadata_lencopy_file_follows_dst_symlinksymlinks_worksymlink_noexistreadlink_not_symlinklinks_workchmod_worksfchmod_workssync_doesnt_kill_anythingtruncate_worksopen_flavorsbinary_filewrite_then_readfile_try_cloneunlink_readonlymkdir_trailing_slashcanonicalize_works_simplerealpath_worksrealpath_works_trickydir_entry_methodsdir_entry_debugread_dir_not_foundfile_open_not_foundcreate_dir_all_with_junctionsmetadata_access_timessymlink_hard_link/// Test creating hard links to symlinks.create_dir_long_paths/// Ensure `fs::create_dir` works on Windows with longer paths.read_large_dir/// Ensure ReadDir works on large directories./// Regression test for https://github.com/rust-lang/rust/issues/93384.hiberfil_sys/// Test the fallback for getting the metadata of files like hiberfil.sys that/// Windows holds a special lock on, preventing normal means of querying/// metadata. See #96980./// Note this fails in CI because `hiberfil.sys` does not actually exist there./// Therefore it's marked as ignored.test_eq_direntry_metadata/// Test that two different ways of obtaining the FileType give the same result./// Cf. https://github.com/rust-lang/rust/issues/104900test_eq_windows_file_type/// Test that windows file type equality is not affected by attributes unrelated/// to the file type.test_read_dir_infinite_loop/// Regression test for https://github.com/rust-lang/rust/issues/50619.rename_directorytest_file_timestest_file_times_pre_epoch_with_nanoswindows_unix_socket_existstest_hidden_file_truncationtest_rename_file_over_open_file// See https://github.com/rust-lang/rust/pull/131072 for more details about why// these two tests are disabled under Windows 7 here.test_rename_directory_to_non_empty_directorytest_rename_symlinktest_rename_junctiontest_open_options_invalid_combinationstest_fs_set_timestest_fs_set_times_follows_symlinktest_fs_set_times_nofollowfs_impAsInnerMut/// An object providing access to an open file on the filesystem./// it was opened with. Files also implement [`Seek`] to alter the logical cursor/// that the file contains internally./// Files are automatically closed when they go out of scope.  Errors detected/// on closing are ignored by the implementation of `Drop`.  Use the method/// [`sync_all`] if these errors must be manually handled./// `File` does not buffer reads and writes. For efficiency, consider wrapping the/// file in a [`BufReader`] or [`BufWriter`] when performing many small [`read`]/// or [`write`] calls, unless unbuffered reads and writes are required./// Creates a new file and write bytes to it (you can also use [`write`]):///     let mut file = File::create("foo.txt")?;///     file.write_all(b"Hello, world!")?;/// Reads the contents of a file into a [`String`] (you can also use [`read`]):///     let mut file = File::open("foo.txt")?;///     let mut contents = String::new();///     file.read_to_string(&mut contents)?;///     assert_eq!(contents, "Hello, world!");/// Using a buffered [`Read`]er:///     let file = File::open("foo.txt")?;///     let mut buf_reader = BufReader::new(file);///     buf_reader.read_to_string(&mut contents)?;/// Note that, although read and write methods require a `&mut File`, because/// of the interfaces for [`Read`] and [`Write`], the holder of a `&File` can/// still modify the file, either through methods that take `&File` or by/// retrieving the underlying OS object and modifying the file that way./// Additionally, many operating systems allow concurrent modification of files/// by different processes. Avoid assuming that holding a `&File` means that the/// file will not change./// On Windows, the implementation of [`Read`] and [`Write`] traits for `File`/// perform synchronous I/O operations. Therefore the underlying file must not/// have been opened for asynchronous I/O (e.g. by using `FILE_FLAG_OVERLAPPED`)./// [`BufReader`]: io::BufReader/// [`BufWriter`]: io::BufWriter/// [`sync_all`]: File::sync_all/// [`write`]: File::write/// [`read`]: File::read/// The lock could not be acquired due to an I/O error on the file. The standard library will/// not return an [`ErrorKind::WouldBlock`] error inside [`TryLockError::Error`]/// [`ErrorKind::WouldBlock`]: io::ErrorKind::WouldBlock/// The lock could not be acquired at this time because it is held by another handle/process./// An enumeration of possible errors which can occur while trying to acquire a lock/// from the [`try_lock`] method and [`try_lock_shared`] method on a [`File`]./// [`try_lock`]: File::try_lock/// [`try_lock_shared`]: File::try_lock_shared/// Metadata information about a file./// This structure is returned from the [`metadata`] or/// [`symlink_metadata`] function or method and represents known/// metadata about a file such as its permissions, size, modification/// times, etc./// Iterator over the entries in a directory./// This iterator is returned from the [`read_dir`] function of this module and/// will yield instances of <code>[io::Result]<[DirEntry]></code>. Through a [`DirEntry`]/// information like the entry's path and possibly other metadata can be/// learned./// The order in which this iterator returns entries is platform and filesystem/// dependent./// This [`io::Result`] will be an [`Err`] if an error occurred while fetching/// the next entry from the OS./// Entries returned by the [`ReadDir`] iterator./// On Unix, the `DirEntry` struct contains an internal reference to the open/// directory. Holding `DirEntry` objects will consume a file handle even/// after the `ReadDir` iterator is dropped./// Generally speaking, when using `OpenOptions`, you'll first call/// [`OpenOptions::new`], then chain calls to methods to set each option, then/// call [`OpenOptions::open`], passing the path of the file you're trying to/// open. This will give you a [`io::Result`] with a [`File`] inside that you/// can further operate on./// let file = OpenOptions::new().read(true).open("foo.txt");///             .read(true)///             .write(true)///             .create(true)///             .open("foo.txt");/// Representation of the various timestamps on a file.FilePermissions/// Representation of the various permissions on a file./// This module only currently provides one bit of information,/// [`Permissions::readonly`], which is exposed on all currently supported/// platforms. Unix-specific functionality, such as mode bits, is available/// through the [`PermissionsExt`] trait./// [`PermissionsExt`]: crate::os::unix::fs::PermissionsExt/// A structure representing a type of file with accessors for each file type./// It is returned by [`Metadata::file_type`] method./// A builder used to create directories in various manners./// This builder also supports platform-specific options./// with fewer imports and without an intermediate variable./// [`read_to_end`]: Read::read_to_end/// While reading from the file, this function handles [`io::ErrorKind::Interrupted`]/// with automatic retries. See [io::Read] documentation for details./// fn main() -> Result<(), Box<dyn std::error::Error + 'static>> {///     let data: Vec<u8> = fs::read("image.jpg")?;///     assert_eq!(data[0..3], [0xFF, 0xD8, 0xFF]);/// Reads the entire contents of a file into a string./// This is a convenience function for using [`File::open`] and [`read_to_string`]/// [`read_to_string`]: Read::read_to_string/// If the contents of the file are not valid UTF-8, then an error will also be///     let message: String = fs::read_to_string("message.txt")?;///     println!("{}", message);/// Writes a slice as the entire contents of a file./// This function will create a file if it does not exist,/// and will entirely replace its contents if it does./// Depending on the platform, this function may fail if the/// full directory path does not exist./// This is a convenience function for using [`File::create`] and [`write_all`]/// with fewer imports./// [`write_all`]: Write::write_all///     fs::write("foo.txt", b"Lorem ipsum")?;///     fs::write("bar.txt", "dolor sit")?;/// Changes the timestamps of the file or directory at the specified path./// This function will attempt to set the access and modification times/// to the times specified. If the path refers to a symbolic link, this function/// will follow the link and change the timestamps of the target file./// This function currently corresponds to the `utimensat` function on Unix platforms, the/// `setattrlist` function on Apple platforms, and the `SetFileTime` function on Windows./// This function will return an error if the user lacks permission to change timestamps on the/// target file or symlink. It may also return an error if the OS does not support it./// #![feature(fs_set_times)]/// use std::fs::{self, FileTimes};///     let now = SystemTime::now();///     let times = FileTimes::new()///         .set_accessed(now)///         .set_modified(now);///     fs::set_times("foo.txt", times)?;set_times_nofollow/// Changes the timestamps of the file or symlink at the specified path./// to the times specified. Differ from `set_times`, if the path refers to a symbolic link,/// this function will change the timestamps of the symlink itself, not the target file./// This function currently corresponds to the `utimensat` function with `AT_SYMLINK_NOFOLLOW` on/// Unix platforms, the `setattrlist` function with `FSOPT_NOFOLLOW` on Apple platforms, and the/// `SetFileTime` function on Windows.///     fs::set_times_nofollow("symlink.txt", times)?;/// See the [`OpenOptions::open`] method for more details./// If you only need to read the entire file contents,/// consider [`std::fs::read()`][self::read] or/// [`std::fs::read_to_string()`][self::read_to_string] instead.///     let mut f = File::open("foo.txt")?;///     let mut data = vec![];///     f.read_to_end(&mut data)?;open_buffered/// Attempts to open a file in read-only mode with buffering./// See the [`OpenOptions::open`] method, the [`BufReader`][io::BufReader] type,/// and the [`BufRead`][io::BufRead] trait for more details./// This function will return an error if `path` does not already exist,/// or if memory allocation fails for the new buffer./// #![feature(file_buffered)]/// use std::io::BufRead;///     let mut f = File::open_buffered("foo.txt")?;///     assert!(f.capacity() > 0);///     for (line, i) in f.lines().zip(1..) {///         println!("{i:6}: {}", line?);/// and will truncate it if it does./// See the [`OpenOptions::open`] function for more details./// See also [`std::fs::write()`][self::write] for a simple function to/// create a file with some given data.///     let mut f = File::create("foo.txt")?;///     f.write_all(&1234_u32.to_be_bytes())?;create_buffered/// Opens a file in write-only mode with buffering./// See the [`OpenOptions::open`] method and the/// [`BufWriter`][io::BufWriter] type for more details.///     let mut f = File::create_buffered("foo.txt")?;///     for i in 0..100 {///         writeln!(&mut f, "{i}")?;///     f.flush()?;/// Creates a new file in read-write mode; error if the file exists./// This function will create a file if it does not exist, or return an error if it does. This/// way, if the call succeeds, the file returned is guaranteed to be new./// If a file exists at the target location, creating a new file will fail with [`AlreadyExists`]/// or another error based on the situation. See [`OpenOptions::open`] for a/// non-exhaustive list of likely errors./// This option is useful because it is atomic. Otherwise between checking whether a file/// exists and creating a new one, the file may have been created by another process (a [TOCTOU]/// race condition / attack)./// This can also be written using/// `File::options().read(true).write(true).create_new(true).open(...)`./// [`AlreadyExists`]: crate::io::ErrorKind::AlreadyExists/// [TOCTOU]: self#time-of-check-to-time-of-use-toctou///     let mut f = File::create_new("foo.txt")?;///     f.write_all("Hello, world!".as_bytes())?;/// Returns a new OpenOptions object./// This function returns a new OpenOptions object that you can use to///     let mut f = File::options().append(true).open("example.log")?;///     writeln!(&mut f, "new line")?;/// Attempts to sync all OS-internal file content and metadata to disk./// This function will attempt to ensure that all in-memory data reaches the/// This can be used to handle errors that would otherwise only be caught/// when the `File` is closed, as dropping a `File` will ignore all errors./// Note, however, that `sync_all` is generally more expensive than closing/// a file by dropping it, because the latter is not required to block until/// the data has been written to the filesystem./// If synchronizing the metadata is not required, use [`sync_data`] instead./// [`sync_data`]: File::sync_data///     f.write_all(b"Hello, world!")?;///     f.sync_all()?;/// This function is similar to [`sync_all`], except that it might not/// [`sync_all`].///     f.sync_data()?;/// Acquire an exclusive lock on the file. Blocks until the lock can be acquired./// This acquires an exclusive lock; no other file handle to this file may acquire another lock./// This lock may be advisory or mandatory. This lock is meant to interact with [`lock`],/// [`try_lock`], [`lock_shared`], [`try_lock_shared`], and [`unlock`]. Its interactions with/// other methods, such as [`read`] and [`write`] are platform specific, and it may or may not/// cause non-lockholders to block./// If this file handle/descriptor, or a clone of it, already holds a lock the exact behavior/// is unspecified and platform dependent, including the possibility that it will deadlock./// However, if this method returns, then an exclusive lock is held./// If the file is not open for writing, it is unspecified whether this function returns an error./// The lock will be released when this file (along with any other file descriptors/handles/// duplicated or inherited from it) is closed, or if the [`unlock`] method is called./// This function currently corresponds to the `flock` function on Unix with the `LOCK_EX` flag,/// and the `LockFileEx` function on Windows with the `LOCKFILE_EXCLUSIVE_LOCK` flag. Note that,/// this [may change in the future][changes]./// On Windows, locking a file will fail if the file is opened only for append. To lock a file,/// open it with one of `.read(true)`, `.read(true).append(true)`, or `.write(true)`./// [`lock`]: File::lock/// [`lock_shared`]: File::lock_shared/// [`unlock`]: File::unlock/// [`read`]: Read::read/// [`write`]: Write::write///     let f = File::create("foo.txt")?;///     f.lock()?;/// Acquire a shared (non-exclusive) lock on the file. Blocks until the lock can be acquired./// This acquires a shared lock; more than one file handle may hold a shared lock, but none may/// hold an exclusive lock at the same time./// If this file handle/descriptor, or a clone of it, already holds a lock, the exact behavior/// However, if this method returns, then a shared lock is held./// This function currently corresponds to the `flock` function on Unix with the `LOCK_SH` flag,/// and the `LockFileEx` function on Windows. Note that, this///     let f = File::open("foo.txt")?;///     f.lock_shared()?;/// Try to acquire an exclusive lock on the file./// Returns `Err(TryLockError::WouldBlock)` if a different lock is already held on this file/// (via another handle/descriptor)./// However, if this method returns `Ok(())`, then it has acquired an exclusive lock./// This function currently corresponds to the `flock` function on Unix with the `LOCK_EX` and/// `LOCK_NB` flags, and the `LockFileEx` function on Windows with the `LOCKFILE_EXCLUSIVE_LOCK`/// and `LOCKFILE_FAIL_IMMEDIATELY` flags. Note that, this/// use std::fs::{File, TryLockError};///     // Explicit handling of the WouldBlock error///     match f.try_lock() {///         Ok(_) => (),///         Err(TryLockError::WouldBlock) => (), // Lock not acquired///         Err(TryLockError::Error(err)) => return Err(err),///     // Alternately, propagate the error as an io::Error///     f.try_lock()?;/// Try to acquire a shared (non-exclusive) lock on the file./// If this file handle, or a clone of it, already holds a lock, the exact behavior is/// unspecified and platform dependent, including the possibility that it will deadlock./// However, if this method returns `Ok(())`, then it has acquired a shared lock./// This function currently corresponds to the `flock` function on Unix with the `LOCK_SH` and/// `LOCK_NB` flags, and the `LockFileEx` function on Windows with the/// `LOCKFILE_FAIL_IMMEDIATELY` flag. Note that, this///     match f.try_lock_shared() {///     f.try_lock_shared()?;/// Release all locks on the file./// All locks are released when the file (along with any other file descriptors/handles/// duplicated or inherited from it) is closed. This method allows releasing locks without/// closing the file./// If no lock is currently held via this file descriptor/handle, this method may return an/// error, or may return successfully without taking any action./// This function currently corresponds to the `flock` function on Unix with the `LOCK_UN` flag,/// and the `UnlockFile` function on Windows. Note that, this///     f.unlock()?;/// Truncates or extends the underlying file, updating the size of/// this file to become `size`./// If the `size` is less than the current file's size, then the file will/// be shrunk. If it is greater than the current file's size, then the file/// will be extended to `size` and have all of the intermediate data filled/// in with 0s./// The file's cursor isn't changed. In particular, if the cursor was at the/// end and the file is shrunk using this operation, the cursor will now be/// past the end./// This function will return an error if the file is not opened for writing./// Also, [`std::io::ErrorKind::InvalidInput`](crate::io::ErrorKind::InvalidInput)/// will be returned if the desired length would cause an overflow due to/// the implementation specifics.///     f.set_len(10)?;/// Note that this method alters the content of the underlying file, even/// though it takes `&self` rather than `&mut self`.///     let metadata = f.metadata()?;/// as the existing `File` instance. Reads, writes, and seeks will affect/// both `File` instances simultaneously./// Creates two handles for a file named `foo.txt`:///     let file_copy = file.try_clone()?;/// Assuming there’s a file named `foo.txt` with contents `abcdef\n`, create/// two handles, seek one of them, and read the remaining bytes from the/// other handle:/// use std::io::SeekFrom;///     let mut file_copy = file.try_clone()?;///     file.seek(SeekFrom::Start(3))?;///     let mut contents = vec![];///     file_copy.read_to_end(&mut contents)?;///     assert_eq!(contents, b"def\n");///     use std::fs::File;///     let mut perms = file.metadata()?.permissions();///     perms.set_readonly(true);///     file.set_permissions(perms)?;/// Note that this method alters the permissions of the underlying file,/// even though it takes `&self` rather than `&mut self`./// Changes the timestamps of the underlying file./// This function currently corresponds to the `futimens` function on Unix (falling back to/// `futimes` on macOS before 10.13) and the `SetFileTime` function on Windows. Note that this/// On most platforms, including UNIX and Windows platforms, this function can also change the/// timestamps of a directory. To get a `File` representing a directory in order to call/// `set_times`, open the directory with `File::open` without attempting to obtain write/// permission./// underlying file. It may also return an error in other os-specific unspecified cases./// This function may return an error if the operating system lacks support to change one or/// more of the timestamps set in the `FileTimes` structure.///     use std::fs::{self, File, FileTimes};///     let src = fs::metadata("src")?;///     let dest = File::open("dest")?;///         .set_accessed(src.accessed()?)///         .set_modified(src.modified()?);///     dest.set_times(times)?;/// Changes the modification time of the underlying file./// This is an alias for `set_times(FileTimes::new().set_modified(time))`.buffer_capacity_required/// Indicates how much extra capacity is needed to read the rest of the file./// Reads some bytes from the file./// See [`Read::read`] docs for more info./// This function currently corresponds to the `read` function on Unix and/// the `NtReadFile` function on Windows. Note that this [may change in/// Like `read`, except that it reads into a slice of buffers./// See [`Read::read_vectored`] docs for more info./// This function currently corresponds to the `readv` function on Unix and/// falls back to the `read` implementation on Windows. Note that thisis_read_vectored/// Determines if `File` has an efficient `read_vectored` implementation./// See [`Read::is_read_vectored`] docs for more info./// This function currently returns `true` on Unix an `false` on Windows.// Reserves space in the buffer based on the file size when available./// Writes some bytes to the file./// See [`Write::write`] docs for more info./// This function currently corresponds to the `write` function on Unix and/// the `NtWriteFile` function on Windows. Note that this [may change in/// Like `write`, except that it writes into a slice of buffers./// See [`Write::write_vectored`] docs for more info./// This function currently corresponds to the `writev` function on Unix/// and falls back to the `write` implementation on Windows. Note that this/// Determines if `File` has an efficient `write_vectored` implementation./// See [`Write::is_write_vectored`] docs for more info./// Flushes the file, ensuring that all intermediately buffered contents/// reach their destination./// See [`Write::flush`] docs for more info./// Since a `File` structure doesn't contain any buffers, this function is/// currently a no-op on Unix and Windows. Note that this [may change in/// Seek to an offset, in bytes in a file./// See [`Seek::seek`] docs for more info./// This function currently corresponds to the `lseek64` function on Unix/// and the `SetFilePointerEx` function on Windows. Note that this [may/// change in the future][changes]./// Returns the length of this file (in bytes)./// See [`Seek::stream_len`] docs for more info./// This function currently corresponds to the `statx` function on Linux/// (with fallbacks) and the `GetFileSizeEx` function on Windows. Note that/// let file = options.read(true).open("foo.txt");/// If the file already exists, any write calls on it will overwrite its/// contents, without truncating it./// let file = OpenOptions::new().write(true).open("foo.txt");/// of overwriting previous contents./// Note that setting `.write(true).append(true)` has the same effect as/// setting only `.append(true)`./// Append mode guarantees that writes will be positioned at the current end of file,/// even when there are other processes or threads appending to the same file. This is/// unlike <code>[seek]\([SeekFrom]::[End]\(0))</code> followed by `write()`, which/// has a race between seeking and writing during which another writer can write, with/// our `write()` overwriting their data./// Keep in mind that this does not necessarily guarantee that data appended by/// different processes or threads does not interleave. The amount of data accepted a/// single `write()` call depends on the operating system and file system. A/// successful `write()` is allowed to write only part of the given data, so even if/// you're careful to provide the whole message in a single call to `write()`, there/// is no guarantee that it will be written out in full. If you rely on the filesystem/// accepting the message in a single write, make sure that all data that belongs/// together is written in one operation. This can be done by concatenating strings/// before passing them to [`write()`]./// <code>[Seek]::[stream_position]</code>), and restore it before the next read./// This function doesn't create the file if it doesn't exist. Use the/// [`OpenOptions::create`] method to do so./// [`write()`]: Write::write "io::Write::write"/// [`flush()`]: Write::flush "io::Write::flush"/// [stream_position]: Seek::stream_position "io::Seek::stream_position"/// [seek]: Seek::seek "io::Seek::seek"/// [Current]: SeekFrom::Current "io::SeekFrom::Current"/// [End]: SeekFrom::End "io::SeekFrom::End"/// let file = OpenOptions::new().append(true).open("foo.txt");/// If a file is successfully opened with this option set to true, it will truncate/// let file = OpenOptions::new().write(true).truncate(true).open("foo.txt");/// Sets the option to create a new file, or open it if it already exists./// In order for the file to be created, [`OpenOptions::write`] or/// [`OpenOptions::append`] access must be used./// If `.create(true)` is set without `.write(true)` or `.append(true)`,/// calling [`open`](Self::open) will fail with [`InvalidInput`](io::ErrorKind::InvalidInput) error./// let file = OpenOptions::new().write(true).create(true).open("foo.txt");/// Sets the option to create a new file, failing if it already exists./// No file is allowed to exist at the target location, also no (dangling) symlink. In this/// created by another process (a [TOCTOU] race condition / attack)./// The file must be opened with write or append access in order to create/// a new file./// [`AlreadyExists`]: io::ErrorKind::AlreadyExists/// let file = OpenOptions::new().write(true)///                              .create_new(true)///                              .open("foo.txt");/// with their [`io::ErrorKind`]. The mapping to [`io::ErrorKind`]s is not/// part of the compatibility contract of the function.///   without write access, create without write or append access,///   no access mode set, etc.)./// The following errors don't match any existing [`io::ErrorKind`] at the moment:/// * One of the directory components of the specified file path/// * Filesystem-level errors: full disk, write permission/// [`InvalidInput`]: io::ErrorKind::InvalidInput/// [`NotFound`]: io::ErrorKind::NotFound/// [`PermissionDenied`]: io::ErrorKind::PermissionDenied/// Returns the file type for this metadata.///     use std::fs;///     let metadata = fs::metadata("foo.txt")?;///     println!("{:?}", metadata.file_type());/// Returns `true` if this metadata is for a directory. The/// result is mutually exclusive to the result of/// [`Metadata::is_file`], and will be false for symlink metadata/// obtained from [`symlink_metadata`].///     assert!(!metadata.is_dir());/// Returns `true` if this metadata is for a regular file. The/// [`Metadata::is_dir`], and will be false for symlink metadata/// When the goal is simply to read from (or write to) the source, the most/// reliable way to test the source can be read (or written to) is to open/// it. Only using `is_file` can break workflows like `diff <( prog_a )` on/// a Unix-like system for example. See [`File::open`] or/// [`OpenOptions::open`] for more information.///     assert!(metadata.is_file());/// Returns `true` if this metadata is for a symbolic link./// use std::os::unix::fs::symlink;///     let link_path = Path::new("link");///     symlink("/origin_does_not_exist/", link_path)?;///     let metadata = fs::symlink_metadata(link_path)?;///     assert!(metadata.is_symlink());/// Returns the size of the file, in bytes, this metadata is for.///     assert_eq!(0, metadata.len());/// Returns the permissions of the file this metadata is for.///     assert!(!metadata.permissions().readonly());/// Returns the last modification time listed in this metadata./// This field might not be available on all platforms, and will return an/// `Err` on platforms where it is not available.///     if let Ok(time) = metadata.modified() {///         println!("{time:?}");///         println!("Not supported on this platform");accessed/// Returns the last access time of this metadata./// Note that not all platforms will keep this field update in a file's/// metadata, for example Windows has an option to disable updating this/// time when files are accessed and Linux similarly has `noatime`.///     if let Ok(time) = metadata.accessed() {/// Returns the creation time listed in this metadata./// The returned value corresponds to the `btime` field of `statx` on/// Linux kernel starting from to 4.11, the `birthtime` field of `stat` on other/// Unix platforms, and the `ftCreationTime` field on Windows platforms./// `Err` on platforms or filesystems where it is not available.///     if let Ok(time) = metadata.created() {///         println!("Not supported on this platform or filesystem");/// Creates a new `FileTimes` with no times set./// Using the resulting `FileTimes` in [`File::set_times`] will not modify any timestamps.set_accessed/// Set the last access time of a file./// Set the last modified time of a file.// For implementing OS extension traits in `std::os`"call `set_readonly` to modify the readonly flag"readonly/// Returns `true` if these permissions describe a readonly (unwritable) file./// This function does not take Access Control Lists (ACLs), Unix group/// membership and other nuances into account./// Therefore the return value of this function cannot be relied upon/// to predict whether attempts to read or write the file will actually succeed./// On Windows this returns [`FILE_ATTRIBUTE_READONLY`](https://docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants)./// If `FILE_ATTRIBUTE_READONLY` is set then writes to the file will fail/// but the user may still have permission to change this flag. If/// `FILE_ATTRIBUTE_READONLY` is *not* set then writes may still fail due/// to lack of write permission./// The behavior of this attribute for directories depends on the Windows/// # Unix (including macOS)/// On Unix-based platforms this checks if *any* of the owner, group or others/// write permission bits are set. It does not consider anything else, including:/// * Whether the current user is in the file's assigned group./// * Permissions granted by ACL./// * That `root` user can write to files that do not have any write bits set./// * Writable files on a filesystem that is mounted read-only./// The [`PermissionsExt`] trait gives direct access to the permission bits but/// also does not read ACLs.///     assert_eq!(false, metadata.permissions().readonly());set_readonly/// Modifies the readonly flag for this set of permissions. If the/// `readonly` argument is `true`, using the resulting `Permission` will/// update file permissions to forbid writing. Conversely, if it's `false`,/// using the resulting `Permission` will update file permissions to allow/// This operation does **not** modify the files attributes. This only/// changes the in-memory value of these attributes for this `Permissions`/// instance. To modify the files attributes use the [`set_permissions`]/// function which commits these attribute changes to the file./// `set_readonly(false)` makes the file *world-writable* on Unix./// You can use the [`PermissionsExt`] trait on Unix to avoid this issue./// It also does not take Access Control Lists (ACLs) or Unix group/// membership into account./// On Windows this sets or clears [`FILE_ATTRIBUTE_READONLY`](https://docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants)./// `FILE_ATTRIBUTE_READONLY` is *not* set then the write may still fail if/// the user does not have permission to write to the file./// In Windows 7 and earlier this attribute prevents deleting empty/// directories. It does not prevent modifying the directory contents./// On later versions of Windows this attribute is ignored for directories./// On Unix-based platforms this sets or clears the write access bit for/// the owner, group *and* others, equivalent to `chmod a+w <file>`/// or `chmod a-w <file>` respectively. The latter will grant write access/// to all users! You can use the [`PermissionsExt`] trait on Unix/// to avoid this issue.///     let mut permissions = metadata.permissions();///     permissions.set_readonly(true);///     // filesystem doesn't change, only the in memory state of the///     // readonly permission///     // just this particular `permissions`.///     assert_eq!(true, permissions.readonly());/// Tests whether this file type represents a directory. The/// result is mutually exclusive to the results of/// [`is_file`] and [`is_symlink`]; only zero or one of these/// tests may pass./// [`is_file`]: FileType::is_file/// [`is_symlink`]: FileType::is_symlink///     let file_type = metadata.file_type();///     assert_eq!(file_type.is_dir(), false);/// Tests whether this file type represents a regular file./// The result is mutually exclusive to the results of/// [`is_dir`] and [`is_symlink`]; only zero or one of these/// [`is_dir`]: FileType::is_dir///     assert_eq!(file_type.is_file(), true);/// Tests whether this file type represents a symbolic link./// [`is_dir`] and [`is_file`]; only zero or one of these/// The underlying [`Metadata`] struct needs to be retrieved/// with the [`fs::symlink_metadata`] function and not the/// [`fs::metadata`] function. The [`fs::metadata`] function/// follows symbolic links, so [`is_symlink`] would always/// return `false` for the target file./// [`fs::metadata`]: metadata/// [`fs::symlink_metadata`]: symlink_metadata///     let metadata = fs::symlink_metadata("foo.txt")?;///     assert_eq!(file_type.is_symlink(), false);///     for entry in fs::read_dir(".")? {///         let dir = entry?;///         println!("{:?}", dir.path());/// symlink. To traverse symlinks use [`fs::metadata`] or [`fs::File::metadata`]./// [`fs::File::metadata`]: File::metadata/// if let Ok(entries) = fs::read_dir(".") {///     for entry in entries {///         if let Ok(entry) = entry {///             // Here, `entry` is a `DirEntry`.///             if let Ok(metadata) = entry.metadata() {///                 // Now let's show our entry's permissions!///                 println!("{:?}: {:?}", entry.path(), metadata.permissions());///                 println!("Couldn't get metadata for {:?}", entry.path());///             if let Ok(file_type) = entry.file_type() {///                 // Now let's show our entry's file type!///                 println!("{:?}: {:?}", entry.path(), file_type);///                 println!("Couldn't get file type for {:?}", entry.path());/// Returns the file name of this directory entry without any/// leading path component(s)./// As an example,/// the output of the function will result in "foo" for all the following paths:/// - "./foo"/// - "/the/foo"/// - "../../foo"///             println!("{:?}", entry.file_name());/// Note that there is no/// guarantee that the file is immediately deleted (e.g., depending on/// platform, other open file descriptors may prevent immediate removal)./// This function currently corresponds to the `unlink` function on Unix./// On Windows, `DeleteFile` is used or `CreateFileW` and `SetInformationByHandle` for readonly files./// * `path` points to a directory./// * The file doesn't exist./// * The user lacks permissions to remove the file./// This function will only ever return an error of kind `NotFound` if the given/// path does not exist. Note that the inverse is not true,/// ie. if a path does not exist, its removal may fail for a number of reasons,/// such as insufficient permissions.///     fs::remove_file("a.txt")?;/// This function currently corresponds to the `stat` function on Unix/// and the `GetFileInformationByHandle` function on Windows.///     let attr = fs::metadata("/some/file/path.txt")?;/// Queries the metadata about a file without following symlinks./// This function currently corresponds to the `lstat` function on Unix///     let attr = fs::symlink_metadata("/some/file/path.txt")?;/// This function currently corresponds to the `rename` function on Unix/// and the `MoveFileExW` or `SetFileInformationByHandle` function on Windows./// Because of this, the behavior when both `from` and `to` exist differs. On/// Unix, if `from` is a directory, `to` must also be an (empty) directory. If/// `from` is not a directory, `to` must also be not a directory. The behavior/// on Windows is the same on Windows 10 1607 and higher if `FileRenameInfoEx`/// is supported by the filesystem; otherwise, `from` can be anything, but/// `to` must *not* be a directory./// * `from` does not exist./// * The user lacks permissions to view contents./// * `from` and `to` are on separate filesystems.///     fs::rename("a.txt", "b.txt")?; // Rename a.txt to b.txt/// Copies the contents of one file to another. This function will also/// copy the permission bits of the original file to the destination file./// This function will **overwrite** the contents of `to`./// Note that if `from` and `to` both point to the same file, then the file/// will likely get truncated by this operation./// On success, the total number of bytes copied is returned and it is equal to/// the length of the `to` file as reported by `metadata`./// If you want to copy the contents of one file to another and you’re/// working with [`File`]s, see the [`io::copy`](io::copy()) function./// This function currently corresponds to the `open` function in Unix/// with `O_RDONLY` for `from` and `O_WRONLY`, `O_CREAT`, and `O_TRUNC` for `to`./// `O_CLOEXEC` is set for returned file descriptors./// On Linux (including Android), this function attempts to use `copy_file_range(2)`,/// and falls back to reading and writing if that is not possible./// On Windows, this function currently corresponds to `CopyFileEx`. Alternate/// NTFS streams are copied but only the size of the main stream is returned by/// On MacOS, this function corresponds to `fclonefileat` and `fcopyfile`./// Note that platform-specific behavior [may change in the future][changes]./// * `from` is neither a regular file nor a symlink to a regular file./// * The current process does not have the permission rights to read///   `from` or write `to`./// * The parent directory of `to` doesn't exist.///     fs::copy("foo.txt", "bar.txt")?;  // Copy foo.txt to bar.txt/// The `link` path will be a link pointing to the `original` path. Note that/// systems often require these two paths to both be located on the same/// filesystem./// If `original` names a symbolic link, it is platform-specific whether the/// symbolic link is followed. On platforms where it's possible to not follow/// it, it is not followed, and the created hard link points to the symbolic/// link itself./// This function currently corresponds the `CreateHardLink` function on Windows./// On most Unix systems, it corresponds to the `linkat` function with no flags./// On Android, VxWorks, and Redox, it instead corresponds to the `link` function./// On MacOS, it uses the `linkat` function if it is available, but on very old/// systems where `linkat` is not available, `link` is selected at runtime instead./// * The 'link' path already exists.///     fs::hard_link("a.txt", "b.txt")?; // Hard link a.txt to b.txtsoft_link/// On Windows, this will be a file symlink, not a directory symlink;/// for this reason, the platform-specific [`std::os::unix::fs::symlink`]/// and [`std::os::windows::fs::symlink_file`] or [`symlink_dir`] should be/// used instead to make the intent explicit./// [`std::os::unix::fs::symlink`]: crate::os::unix::fs::symlink/// [`std::os::windows::fs::symlink_file`]: crate::os::windows::fs::symlink_file/// [`symlink_dir`]: crate::os::windows::fs::symlink_dir///     fs::soft_link("a.txt", "b.txt")?;/// This function currently corresponds to the `readlink` function on Unix/// and the `CreateFile` function with `FILE_FLAG_OPEN_REPARSE_POINT` and/// `FILE_FLAG_BACKUP_SEMANTICS` flags on Windows./// * `path` is not a symbolic link.///     let path = fs::read_link("a.txt")?;/// [path]: https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file///     let path = fs::canonicalize("../a/../foo.txt")?;/// and the `CreateDirectoryW` function on Windows.///     fs::create_dir("/some/dir")?;/// Recursively create a directory and all of its parent components if they/// This function is not atomic. If it returns an error, any parent components it was able to create/// will remain./// If the empty path is passed to this function, it always succeeds without/// creating any directories./// This function currently corresponds to multiple calls to the `mkdir`/// function on Unix and the `CreateDirectoryW` function on Windows./// The function will return an error if any directory specified in path does not exist and/// could not be created. There may be other error conditions; see [`fs::create_dir`] for specifics./// [`fs::create_dir`]: create_dir///     fs::create_dir_all("/some/dir")?;/// If you want to remove a directory that is not empty, as well as all/// of its contents recursively, consider using [`remove_dir_all`]/// This function currently corresponds to the `rmdir` function on Unix/// and the `RemoveDirectory` function on Windows./// * `path` doesn't exist./// * `path` isn't a directory./// * The user lacks permissions to remove the directory at the provided `path`./// * The directory isn't empty.///     fs::remove_dir("/some/dir")?;/// Removes a directory at this path, after removing all its contents. Use/// carefully!/// This function does **not** follow symbolic links and it will simply remove the/// symbolic link itself./// These implementation details [may change in the future][changes]./// - "Unix-like": By default, this function currently corresponds to/// `openat`, `fdopendir`, `unlinkat` and `lstat`/// on Unix-family platforms, except where noted otherwise./// - "Windows": This function currently corresponds to `CreateFileW`,/// `GetFileInformationByHandleEx`, `SetFileInformationByHandle`, and `NtCreateFile`./// ## Time-of-check to time-of-use (TOCTOU) race conditions/// See the [module-level TOCTOU explanation](self#time-of-check-to-time-of-use-toctou)./// On most platforms, `fs::remove_dir_all` protects against symlink TOCTOU races by default./// However, on the following platforms, this protection is not provided and the function should/// not be used in security-sensitive contexts:/// - **Miri**: Even when emulating targets where the underlying implementation will protect against///   TOCTOU races, Miri will not do so./// - **Redox OS**: This function does not protect against TOCTOU races, as Redox does not implement///   the required platform support to do so./// See [`fs::remove_file`] and [`fs::remove_dir`]./// [`remove_dir_all`] will fail if [`remove_dir`] or [`remove_file`] fail on *any* constituent/// paths, *including* the root `path`. Consequently,/// - The directory you are deleting *must* exist, meaning that this function is *not idempotent*./// - [`remove_dir_all`] will fail if the `path` is *not* a directory./// Consider ignoring the error if validating the removal is not required for your use case./// This function may return [`io::ErrorKind::DirectoryNotEmpty`] if the directory is concurrently/// written into, which typically indicates some contents were removed but not all./// [`io::ErrorKind::NotFound`] is only returned if no removal occurs./// [`fs::remove_file`]: remove_file/// [`fs::remove_dir`]: remove_dir///     fs::remove_dir_all("/some/dir")?;/// Returns an iterator over the entries within a directory./// The iterator will yield instances of <code>[io::Result]<[DirEntry]></code>./// New errors may be encountered after an iterator is initially constructed./// Entries for the current and parent directories (typically `.` and `..`) are/// The order in which `read_dir` returns entries can change between calls. If reproducible/// ordering is required, the entries should be explicitly sorted./// This function currently corresponds to the `opendir` function on Unix/// and the `FindFirstFileEx` function on Windows. Advancing the iterator/// currently corresponds to `readdir` on Unix and `FindNextFile` on Windows./// * The provided `path` doesn't exist./// * The process lacks permissions to view the contents./// * The `path` points at a non-directory file./// use std::fs::{self, DirEntry};/// // one possible implementation of walking a directory only visiting files/// fn visit_dirs(dir: &Path, cb: &dyn Fn(&DirEntry)) -> io::Result<()> {///     if dir.is_dir() {///         for entry in fs::read_dir(dir)? {///             let entry = entry?;///             let path = entry.path();///             if path.is_dir() {///                 visit_dirs(&path, cb)?;///                 cb(&entry);///     let mut entries = fs::read_dir(".")?///         .map(|res| res.map(|e| e.path()))///         .collect::<Result<Vec<_>, io::Error>>()?;///     // The order in which `read_dir` returns entries is not guaranteed. If reproducible///     // ordering is required the entries should be explicitly sorted.///     entries.sort();///     // The entries have now been sorted by their path./// This function currently corresponds to the `chmod` function on Unix/// and the `SetFileAttributes` function on Windows./// ## Symlinks/// On UNIX-like systems, this function will update the permission bits/// of the file pointed to by the symlink./// Note that this behavior can lead to privilege escalation vulnerabilities,/// where the ability to create a symlink in one directory allows you to/// cause the permissions of another file or directory to be modified./// For this reason, using this function with symlinks should be avoided./// When possible, permissions should be set at creation time instead./// # Rationale/// POSIX does not specify an `lchmod` function,/// and symlinks can be followed regardless of what permission bits are set./// * The user lacks the permission to change attributes of the file.///     let mut perms = fs::metadata("foo.txt")?.permissions();///     fs::set_permissions("foo.txt", perms)?;set_permissions_nofollow/// Set the permissions of a file, unless it is a symlink./// Note that the non-final path elements are allowed to be symlinks./// Currently unimplemented on Windows./// On Unix platforms, this results in a [`FilesystemLoop`] error if the last element is a symlink./// This behavior may change in the future./// [`FilesystemLoop`]: crate::io::ErrorKind::FilesystemLoop/// use std::fs::DirBuilder;/// Indicates that directories should be created recursively, creating all/// parent directories. Parents that do not exist are created with the same/// security and permissions settings./// Creates the specified directory with the options configured in this/// use std::fs::{self, DirBuilder};/// let path = "/tmp/foo/bar/baz";///     .create(path).unwrap();/// assert!(fs::metadata(path).unwrap().is_dir());_create/// As opposed to the [`Path::exists`] method, this will only return `Ok(true)` or `Ok(false)`/// if the path was _verified_ to exist or not exist. If its existence can neither be confirmed/// nor denied, an `Err(_)` will be propagated instead. This can be the case if e.g. listing/// permission is denied on one of the parent directories./// Note that while this avoids some pitfalls of the `exists()` method, it still can not/// prevent time-of-check to time-of-use ([TOCTOU]) bugs. You should only use it in scenarios/// where those bugs are not an issue./// assert!(!fs::exists("does_not_exist.txt").expect("Can't check existence of file does_not_exist.txt"));/// assert!(fs::exists("/root/secret_file.txt").is_err());/// [`Path::exists`]: crate::path::Path::exists//! Filesystem manipulation operations.//! This module contains basic methods to manipulate the contents of the local//! filesystem. All methods in this module represent cross-platform filesystem//! operations. Extra platform-specific functionality can be found in the//! extension traits of `std::os::$platform`.//! # Time of Check to Time of Use (TOCTOU)//! Many filesystem operations are subject to a race condition known as "Time of Check to Time of Use"//! (TOCTOU). This occurs when a program checks a condition (like file existence or permissions)//! and then uses the result of that check to make a decision, but the condition may have changed//! between the check and the use.//! For example, checking if a file exists and then creating it if it doesn't is vulnerable to//! TOCTOU - another process could create the file between your check and creation attempt.//! Another example is with symbolic links: when removing a directory, if another process replaces//! the directory with a symbolic link between the check and the removal operation, the removal//! might affect the wrong location. This is why operations like [`remove_dir_all`] need to use//! atomic operations to prevent such race conditions.//! To avoid TOCTOU issues://! - Be aware that metadata operations (like [`metadata`] or [`symlink_metadata`]) may be affected by//! changes made by other processes.//! - Use atomic operations when possible (like [`File::create_new`] instead of checking existence then creating).//! - Keep file open for the duration of operations.// In addition to the `impl`s here, `File` also has `impl`s for// `AsFd`/`From<OwnedFd>`/`Into<OwnedFd>` and// `AsRawFd`/`IntoRawFd`/`FromRawFd`, on Unix and WASI, and// `AsHandle`/`From<OwnedHandle>`/`Into<OwnedHandle>` and// `AsRawHandle`/`IntoRawHandle`/`FromRawHandle` on Windows.hashmap_random_keys/// `RandomState` is the default state for [`HashMap`] types./// A particular instance `RandomState` will create the same instances of/// [`Hasher`], but the hashers created by two different `RandomState`/// Constructs a new `RandomState` that is initialized with random keys.// rand/// The default [`Hasher`] used by [`RandomState`]./// The internal algorithm is not specified, and so it and its hashes should/// not be relied upon over releases./// Creates a new `DefaultHasher`./// This hasher is not guaranteed to be the same as all other/// `DefaultHasher` instances, but is the same as all other `DefaultHasher`/// instances created through `new` or `default`./// Creates a new `DefaultHasher` using [`new`]./// [`new`]: DefaultHasher::new// The underlying `SipHasher13` doesn't override the other// `write_*` methods, so it's ok not to forward them here./// Constructs a new `RandomState`.//! This module exists to isolate [`RandomState`] and [`DefaultHasher`] outside of the//! [`collections`] module without actually publicly exporting them, so that parts of that//! implementation can more easily be moved to the [`alloc`] crate.//! Although its items are public and contain stability attributes, they can't actually be accessed//! outside this crate.//! [`collections`]: crate::collections// The buffer.// The current seek offset into `buf`, must always be <= `filled`.// Each call to `fill_buf` sets `filled` to indicate how many bytes at the start of `buf` are// initialized with bytes from a read.// This is the max number of bytes returned across all `fill_buf` calls. We track this so that we// can accurately tell `read_buf` how many bytes of buf are initialized, to bypass as much of its// defensive initialization as possible. Note that while this often the same as `filled`, it// doesn't need to be. Calls to `fill_buf` are not required to actually fill the buffer, and// omitting this is a huge perf regression for `Read` impls that do not.consume_with/// If there are `amt` bytes available in the buffer, pass a slice containing those bytes to/// `visitor` and return true. If there are not enough bytes available, return false.unconsume/// Read more bytes into the buffer without discarding any of its contentsbackshift/// Remove bytes that have already been read from the buffer.//! An encapsulation of `BufReader`'s buffer management logic.//! This module factors out the basic functionality of `BufReader` in order to protect two core//! invariants://! * `filled` bytes of `buf` are always initialized//! * `pos` is always <= `filled`//! Since this module encapsulates the buffer management logic, we can ensure that the range//! `pos..filled` is always a valid index into the initialized region of the buffer. This means//! that user code which wants to do reads from a `BufReader` via `buffer` + `consume` can do so//! without encountering any runtime bounds checks.SpecReadByteuninlined_slow_read_byte/// The `BufReader<R>` struct adds buffering to any reader./// It can be excessively inefficient to work directly with a [`Read`] instance./// For example, every call to [`read`][`TcpStream::read`] on [`TcpStream`]/// results in a system call. A `BufReader<R>` performs large, infrequent reads on/// the underlying [`Read`] and maintains an in-memory buffer of the results./// `BufReader<R>` can improve the speed of programs that make *small* and/// *repeated* read calls to the same file or network socket. It does not/// help when reading very large amounts at once, or reading just one or a few/// times. It also provides no advantage when reading from a source that is/// already in memory, like a <code>[Vec]\<u8></code>./// When the `BufReader<R>` is dropped, the contents of its buffer will be/// discarded. Creating multiple instances of a `BufReader<R>` on the same/// stream can cause data loss. Reading from the underlying reader after/// unwrapping the `BufReader<R>` with [`BufReader::into_inner`] can also cause/// data loss./// [`TcpStream::read`]: crate::net::TcpStream::read/// [`TcpStream`]: crate::net::TcpStream///     let f = File::open("log.txt")?;///     let mut reader = BufReader::new(f);///     let mut line = String::new();///     let len = reader.read_line(&mut line)?;///     println!("First line is {len} bytes long");/// Creates a new `BufReader<R>` with a default buffer capacity. The default is currently 8 KiB,///     let reader = BufReader::new(f);try_new_buffer/// Creates a new `BufReader<R>` with the specified buffer capacity./// Creating a buffer with ten bytes of capacity:///     let reader = BufReader::with_capacity(10, f);/// Attempt to look ahead `n` bytes./// `n` must be less than or equal to `capacity`./// The returned slice may be less than `n` bytes long if/// end of file is reached./// After calling this method, you may call [`consume`](BufRead::consume)/// with a value less than or equal to `n` to advance over some or all of/// the returned bytes./// #![feature(bufreader_peek)]/// use std::io::{Read, BufReader};/// let mut bytes = &b"oh, hello there"[..];/// let mut rdr = BufReader::with_capacity(6, &mut bytes);/// assert_eq!(rdr.peek(2).unwrap(), b"oh");/// rdr.read(&mut buf[..]).unwrap();/// assert_eq!(&buf, b"oh, ");/// assert_eq!(rdr.peek(5).unwrap(), b"hello");/// rdr.read_to_string(&mut s).unwrap();/// assert_eq!(&s, "hello there");/// assert_eq!(rdr.peek(1).unwrap().len(), 0);///     let f1 = File::open("log.txt")?;///     let reader = BufReader::new(f1);///     let f2 = reader.get_ref();///     let mut reader = BufReader::new(f1);///     let f2 = reader.get_mut();/// Unlike [`fill_buf`], this will not attempt to fill the buffer if it is empty./// [`fill_buf`]: BufRead::fill_buf/// use std::io::{BufReader, BufRead};///     assert!(reader.buffer().is_empty());///     if reader.fill_buf()?.len() > 0 {///         assert!(!reader.buffer().is_empty());/// Returns the number of bytes the internal buffer can hold at once.///     let capacity = reader.capacity();///     let buffer = reader.fill_buf()?;///     assert!(buffer.len() <= capacity);/// Unwraps this `BufReader<R>`, returning the underlying reader./// Note that any leftover data in the internal buffer is lost. Therefore,/// a following read from the underlying reader may lead to data loss.///     let f2 = reader.into_inner();spec_read_byte// Small read_exacts from a BufReader are extremely common when used with a deserializer.// The default implementation calls read in a loop, which results in surprisingly poor code// generation for the common path where the buffer has enough bytes to fill the passed-in// buffer.read_buf_exact// The inner reader might have an optimized `read_to_end`. Drain our buffer and then// delegate to the inner implementation./// The position used for seeking with <code>[SeekFrom::Current]\(_)</code> is the/// position the underlying reader would be at if the `BufReader<R>` had no/// [`BufReader::into_inner()`] immediately after a seek yields the underlying reader/// To seek without discarding the internal buffer, use [`BufReader::seek_relative`]./// See [`std::io::Seek`] for more details./// Note: In the edge case where you're seeking with <code>[SeekFrom::Current]\(n)</code>/// [`Err`], the underlying reader will be left at the same position it would/// have if you called `seek` with <code>[SeekFrom::Current]\(0)</code>./// [`std::io::Seek`]: Seek/// Returns the current seek position from the start of the stream./// The value returned is equivalent to `self.seek(SeekFrom::Current(0))`/// but does not flush the internal buffer. Due to this optimization the/// function does not guarantee that calling `.into_inner()` immediately/// afterwards will yield the underlying reader at the same position. Use/// [`BufReader::seek`] instead if you require that guarantee./// This function will panic if the position of the inner reader is smaller/// than the amount of buffered data. That can happen if the inner reader/// has an incorrect implementation of [`Seek::stream_position`], or if the/// position has gone out of sync due to calling [`Seek::seek`] directly on///     io::{self, BufRead, BufReader, Seek},///     let mut f = BufReader::new(File::open("foo.txt")?);///     let before = f.stream_position()?;///     f.read_line(&mut String::new())?;///     let after = f.stream_position()?;///     println!("The first line was {} bytes long", after - before);/// Seeks relative to the current position./// If the new position lies within the buffer, the buffer will not be/// flushed, allowing for more efficient seeks. This method does not return/// the location of the underlying reader, so the caller must track this/// information themselves if it is required.IntoInnerError// The buffer. Avoid using this like a normal `Vec` in common code paths.// That is, don't use `buf.push`, `buf.extend_from_slice`, or any other// methods that require bounds checking or the like. This makes an enormous// difference to performance (we may want to stop using a `Vec` entirely).// #30888: If the inner writer panics in a call to write, we don't want to// write the buffered data a second time in BufWriter's destructor. This// flag tells the Drop impl if it should skip the flush./// Wraps a writer and buffers its output./// It can be excessively inefficient to work directly with something that/// implements [`Write`]. For example, every call to/// [`write`][`TcpStream::write`] on [`TcpStream`] results in a system call. A/// `BufWriter<W>` keeps an in-memory buffer of data and writes it to an underlying/// writer in large, infrequent batches./// `BufWriter<W>` can improve the speed of programs that make *small* and/// *repeated* write calls to the same file or network socket. It does not/// help when writing very large amounts at once, or writing just one or a few/// times. It also provides no advantage when writing to a destination that is/// in memory, like a <code>[Vec]\<u8></code>./// It is critical to call [`flush`] before `BufWriter<W>` is dropped. Though/// dropping will attempt to flush the contents of the buffer, any errors/// that happen in the process of dropping will be ignored. Calling [`flush`]/// ensures that the buffer is empty and thus dropping will not even attempt/// file operations./// Let's write the numbers one through ten to a [`TcpStream`]:/// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();///     stream.write(&[i+1]).unwrap();/// Because we're not buffering, we write each one in turn, incurring the/// overhead of a system call per byte written. We can fix this with a/// `BufWriter<W>`:/// use std::io::BufWriter;/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());/// stream.flush().unwrap();/// By wrapping the stream with a `BufWriter<W>`, these ten writes are all grouped/// together by the buffer and will all be written out in one system call when/// the `stream` is flushed./// [`TcpStream::write`]: crate::net::TcpStream::write/// [`flush`]: BufWriter::flush/// Creates a new `BufWriter<W>` with a default buffer capacity. The default is currently 8 KiB,/// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());/// Creates a new `BufWriter<W>` with at least the specified buffer capacity./// Creating a buffer with a buffer of at least a hundred bytes./// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();/// let mut buffer = BufWriter::with_capacity(100, stream);/// Unwraps this `BufWriter<W>`, returning the underlying writer./// The buffer is written out before returning the writer./// An [`Err`] will be returned if an error occurs while flushing the buffer./// // unwrap the TcpStream and flush the buffer/// let stream = buffer.into_inner().unwrap();WriterPanicked/// Disassembles this `BufWriter<W>`, returning the underlying writer, and any buffered but/// unwritten data./// If the underlying writer panicked, it is not known what portion of the data was written./// In this case, we return `WriterPanicked` for the buffered data (from which the buffer/// contents can still be recovered)./// `into_parts` makes no attempt to flush data and cannot fail./// use std::io::{BufWriter, Write};/// let mut buffer = [0u8; 10];/// let mut stream = BufWriter::new(buffer.as_mut());/// write!(stream, "too much data").unwrap();/// stream.flush().expect_err("it doesn't fit");/// let (recovered_writer, buffered_data) = stream.into_parts();/// assert_eq!(recovered_writer.len(), 0);/// assert_eq!(&buffered_data.unwrap(), b"ata");/// Send data in our local buffer into the inner writer, looping as/// necessary until either it's all been sent or an error occurs./// Because all the data in the buffer has been reported to our owner as/// "successfully written" (by returning nonzero success values from/// `write`), any 0-length writes from `inner` must be reported as i/o/// errors from this method./// Buffer some data without flushing it, regardless of the size of the/// data. Writes as much as possible without exceeding capacity. Returns/// the number of bytes written./// // we can use reference just like buffer/// let reference = buffer.get_ref();/// let reference = buffer.get_mut();/// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());/// // See how many bytes are currently buffered/// let bytes_buffered = buf_writer.buffer().len();/// Returns a mutable reference to the internal buffer./// This can be used to write data directly into the buffer without triggering writers/// to the underlying writer./// That the buffer is a `Vec` is an implementation detail./// Callers should not modify the capacity as there currently is no public API to do so/// and thus any capacity changes would be unexpected by the user./// Returns the number of bytes the internal buffer can hold without flushing./// // Check the capacity of the inner buffer/// let capacity = buf_writer.capacity();/// // Calculate how many bytes can be written without flushing/// let without_flush = capacity - buf_writer.buffer().len();write_cold// Ensure this function does not get inlined into `write`, so that it// remains inlineable and its common path remains as short as possible.// If this function ends up being called frequently relative to `write`,// it's likely a sign that the client is using an improperly sized buffer// or their write patterns are somewhat pathological.write_all_cold// Ensure this function does not get inlined into `write_all`, so that it// If this function ends up being called frequently relative to `write_all`,// SAFETY: Requires `buf.len() <= self.buf.capacity() - self.buf.len()`,// i.e., that input buffer length is less than or equal to spare capacity./// Error returned for the buffered data from `BufWriter::into_parts`, when the underlying/// writer has previously panicked.  Contains the (possibly partly written) buffered data./// use std::io::{self, BufWriter, Write};/// use std::panic::{catch_unwind, AssertUnwindSafe};/// struct PanickingWriter;/// impl Write for PanickingWriter {///   fn write(&mut self, buf: &[u8]) -> io::Result<usize> { panic!() }///   fn flush(&mut self) -> io::Result<()> { panic!() }/// let mut stream = BufWriter::new(PanickingWriter);/// write!(stream, "some data").unwrap();/// let result = catch_unwind(AssertUnwindSafe(|| {///     stream.flush().unwrap()/// assert!(matches!(recovered_writer, PanickingWriter));/// assert_eq!(buffered_data.unwrap_err().into_inner(), b"some data");/// Returns the perhaps-unwritten data.  Some of this data may have been written by the/// panicking call(s) to the underlying writer, so simply writing it again is not a good idea.LineWriterShim/// Wraps a writer and buffers output to it, flushing whenever a newline/// (`0x0a`, `'\n'`) is detected./// The [`BufWriter`] struct wraps a writer and buffers its output./// But it only does this batched write when it goes out of scope, or when the/// internal buffer is full. Sometimes, you'd prefer to write each line as it's/// completed, rather than the entire buffer at once. Enter `LineWriter`. It/// does exactly that./// Like [`BufWriter`], a `LineWriter`’s buffer will also be flushed when the/// `LineWriter` goes out of scope or when its internal buffer is full./// If there's still a partial line in the buffer when the `LineWriter` is/// dropped, it will flush those contents./// We can use `LineWriter` to write one line at a time, significantly/// reducing the number of actual writes to the file./// use std::io::LineWriter;///     let road_not_taken = b"I shall be telling this with a sigh/// Somewhere ages and ages hence:/// Two roads diverged in a wood, and I -/// I took the one less traveled by,/// And that has made all the difference.";///     let file = File::create("poem.txt")?;///     let mut file = LineWriter::new(file);///     file.write_all(b"I shall be telling this with a sigh")?;///     // No bytes are written until a newline is encountered (or///     // the internal buffer is filled).///     assert_eq!(fs::read_to_string("poem.txt")?, "");///     file.write_all(b"\n")?;///         fs::read_to_string("poem.txt")?,///         "I shall be telling this with a sigh\n",///     // Write the rest of the poem.///     file.write_all(b"Somewhere ages and ages hence:/// And that has made all the difference.")?;///     // The last line of the poem doesn't end in a newline, so///     // we have to flush or drop the `LineWriter` to finish///     // writing.///     file.flush()?;///     // Confirm the whole poem was written.///     assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]);/// Creates a new `LineWriter`.///     let file = LineWriter::new(file);/// Creates a new `LineWriter` with at least the specified capacity for the///     let file = LineWriter::with_capacity(100, file);/// Caution must be taken when calling methods on the mutable reference/// returned as extra writes could corrupt the output stream.///     // we can use reference just like file///     let reference = file.get_mut();/// Unwraps this `LineWriter`, returning the underlying writer./// The internal buffer is written out before returning the writer.///     let writer: LineWriter<File> = LineWriter::new(file);///     let file: File = writer.into_inner()?;///     let reference = file.get_ref();/// Private helper struct for implementing the line-buffered writing logic./// This shim temporarily wraps a BufWriter, and uses its internals to/// implement a line-buffered writer (specifically by using the internal/// methods like write_to_buf and flush_buf). In this way, a more/// efficient abstraction can be created than one that only had access to/// `write` and `flush`, without needlessly duplicating a lot of the/// implementation details of BufWriter. This also allows existing/// `BufWriters` to be temporarily given line-buffering logic; this is what/// enables Stdout to be alternately in line-buffered or block-buffered mode./// Gets a reference to the inner writer (that is, the writer/// wrapped by the BufWriter)./// Gets a mutable reference to the inner writer (that is, the writer/// wrapped by the BufWriter). Be careful with this writer, as writes to/// it will bypass the buffer./// Gets the content currently buffered in self.buffer/// Flushes the buffer iff the last byte is a newline (indicating that an/// earlier write only succeeded partially, and we want to retry flushing/// the buffered line before continuing with a subsequent write)./// Writes some data into this BufReader with line buffering./// This means that, if any newlines are present in the data, the data up to/// the last newline is sent directly to the underlying writer, and data/// after it is buffered. Returns the number of bytes written./// This function operates on a "best effort basis"; in keeping with the/// convention of `Write::write`, it makes at most one attempt to write/// new data to the underlying writer. If that write only reports a partial/// success, the remaining data will be buffered./// Because this function attempts to send completed lines to the underlying/// writer, it will also flush the existing buffer if it ends with a/// newline, even if the incoming data does not contain any newlines./// Writes some vectored data into this BufReader with line buffering./// and including the buffer containing the last newline is sent directly to/// the inner writer, and the data after it is buffered. Returns the number/// of bytes written./// new data to the underlying writer./// writer, it will also flush the existing buffer if it contains any/// newlines./// Because sorting through an array of `IoSlice` can be a bit convoluted,/// This method differs from write in the following ways:/// - It attempts to write the full content of all the buffers up to and///   including the one containing the last newline. This means that it///   may attempt to write a partial line, that buffer has data past the///   newline./// - If the write only reports partial success, it does not attempt to///   find the precise location of the written bytes and buffer the rest./// If the underlying vector doesn't support vectored writing, we instead/// simply write the first non-empty buffer with `write`. This way, we/// get the benefits of more granular partial-line handling without losing/// anything in efficiency/// after it is buffered./// newlines, even if the incoming data does not contain any newlines.bufwriterlinewriterlinewritershim/// An error returned by [`BufWriter::into_inner`] which combines an error that/// happened while writing out the buffer, and the buffered writer object/// which may be used to recover from the condition./// // do stuff with the stream/// // we want to get our `TcpStream` back, so let's try:/// let stream = match stream.into_inner() {///     Ok(s) => s,///         // Here, e is an IntoInnerError///         panic!("An error occurred");/// Constructs a new IntoInnerError/// Helper to construct a new IntoInnerError; intended to help with/// adapters that wrap other adapters/// Returns the error which caused the call to [`BufWriter::into_inner()`]/// This error was returned when attempting to write the internal buffer.///         // Here, e is an IntoInnerError, let's log the inner error.///         // We'll just 'log' to stdout for this example.///         println!("{}", e.error());///         panic!("An unexpected error occurred.");/// Returns the buffered writer instance which generated the error./// The returned object can be used for error recovery, such as/// re-inspecting the buffer.///         // Here, e is an IntoInnerError, let's re-examine the buffer:///         let buffer = e.into_inner();///         // do stuff to try to recover///         // afterwards, let's just return the stream///         buffer.into_inner().unwrap()/// Consumes the [`IntoInnerError`] and returns the error which caused the call to/// [`BufWriter::into_inner()`] to fail.  Unlike `error`, this can be used to/// obtain ownership of the underlying error./// use std::io::{BufWriter, ErrorKind, Write};/// let mut not_enough_space = [0u8; 10];/// let mut stream = BufWriter::new(not_enough_space.as_mut());/// write!(stream, "this cannot be actually written").unwrap();/// let into_inner_err = stream.into_inner().expect_err("now we discover it's too small");/// let err = into_inner_err.into_error();/// assert_eq!(err.kind(), ErrorKind::WriteZero);/// [`BufWriter::into_inner()`] to fail, and the underlying writer./// This can be used to simply obtain ownership of the underlying error; it can also be used for/// advanced error recovery./// let (err, recovered_writer) = into_inner_err.into_parts();/// assert_eq!(recovered_writer.buffer(), b"t be actually written");//! Buffering wrappers for I/O traitsShortReader/// A dummy reader intended at testing short-reads propagation.// FIXME: rustfmt and tidy disagree about the correct formatting of this// function. This leads to issues for users with editors configured to// rustfmt-on-save.test_buffered_readertest_buffered_reader_read_buftest_buffered_reader_seektest_buffered_reader_seek_relativetest_buffered_reader_stream_positiontest_buffered_reader_stream_position_panictest_buffered_reader_invalidated_after_readtest_buffered_reader_invalidated_after_seektest_buffered_reader_seek_underflowtest_buffered_reader_seek_underflow_discard_buffer_between_seekstest_buffered_reader_read_to_end_consumes_buffertest_buffered_reader_read_to_string_consumes_buffertest_buffered_writertest_buffered_writer_inner_flushestest_buffered_writer_seektest_read_untiltest_line_buffertest_read_linetest_short_readsdont_panic_in_drop_on_panicked_flushpanic_in_write_doesnt_flush_in_dropbench_buffered_readerbench_buffered_reader_small_readsbench_buffered_writer// Writes append to this slicealways_write_error// If true, writes will always be an erroralways_flush_error// If true, flushes will always be an erroraccept_prefix// If set, only up to this number of bytes will be written in a single// call to `write`max_writes// If set, counts down with each write, and writes return an error// when it hits 0error_after_max_writes// If set, attempting to write when max_writes == Some(0) will be an// error; otherwise, it will return Ok(0).ProgrammableSink/// A simple `Write` target, designed to be wrapped by `LineWriter` //// `BufWriter` / etc, that can have its `write` & `flush` behavior/// configurederroneous_flush_retried/// Previously the `LineWriter` could successfully write some bytes but/// then fail to report that it has done so. Additionally, an erroneous/// flush after a successful write was permanently ignored./// Test that a line writer correctly reports the number of written bytes,/// and that it attempts to flush buffered lines from previous writes/// before processing new data/// Regression test for #37807line_vectoredline_vectored_partial_and_errorsline_vectored_ignored/// Test that, in cases where vectored writing is not enabled, the/// LineWriter uses the normal `write` call, which more-correctly handles/// partial linespartial_write_buffers_line/// Test that, given this input:/// Line 1\n/// Line 2\n/// Line 3\n/// Line 4/// And given a result that only writes to midway through Line 2/// That only up to the end of Line 3 is buffered/// This behavior is desirable because it prevents flushing partial linespartial_line_buffered_after_line_write/// Line 3/// And given that the full write of lines 1 and 2 was successful/// That data up to Line 3 is bufferedlong_line_flushed/// Test that for calls to LineBuffer::write where the passed bytes do not contain/// a newline and on their own are greater in length than the internal buffer, the/// passed bytes are immediately written to the inner writer.line_long_tail_not_flushed/// Test that, given a very long partial line *after* successfully/// flushing a complete line, no additional writes take place. This assures/// the property that `write` should make at-most-one attempt to write/// new data.line_full_buffer_flushed// Test that appending to a full buffer emits a single write, flushing the buffer.line_buffer_write0_error/// Test that, if an attempt to pre-flush buffered data returns Ok(0),/// this is propagated as an error.line_buffer_write0_normal/// Test that, if a write returns Ok(0) after a successful pre-flush, this/// is propagated as Ok(0)line_write_all/// LineWriter has a custom `write_all`; make sure it works correctlyline_write_all_errorpartial_multiline_buffering/// Under certain circumstances, the old implementation of LineWriter/// would try to buffer "to the last newline" but be forced to buffer/// less than that, leading to inappropriate partial line writes./// Regression test for that issue.partial_multiline_buffering_without_full_line/// Same as test_partial_multiline_buffering, but in the event NO full lines/// fit in the buffer, just buffer as much as possibleRecordedEventWriteRecordersingle_formatted_write/// Test that a normal, formatted writeln only results in a single write/// call to the underlying writer. A naive implementation of/// LineWriter::write_all results in two writes: one of the buffered data,/// and another of the final substring in the formatted setbufreader_full_initializebufwriter_aliasing/// This is a regression test for https://github.com/rust-lang/rust/issues/127584.copy_copiesobserved_bufferWriteObservercopy_specializes_bufwritercopy_specializes_bufreadercopy_specializes_to_veccopy_specializes_from_vecdequecopy_specializes_from_slicebench_copy_buf_reader// no /devio_benchesCopyStatekernel_copy/// This function will continuously read data from `reader` and then/// write it into `writer` in a streaming fashion until `reader`/// returns EOF./// On success, the total number of bytes that were copied from/// `reader` to `writer` is returned./// working with filesystem paths, see the [`fs::copy`] function./// [`fs::copy`]: crate::fs::copy/// This function will return an error immediately if any call to [`read`] or/// [`write`] returns an error. All instances of [`ErrorKind::Interrupted`] are/// handled by this function and the underlying operation is retried./// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted///     let mut reader: &[u8] = b"hello";///     let mut writer: Vec<u8> = vec![];///     io::copy(&mut reader, &mut writer)?;///     assert_eq!(&b"hello"[..], &writer[..]);/// On Linux (including Android), this function uses `copy_file_range(2)`,/// `sendfile(2)` or `splice(2)` syscalls to move data directly between file/// descriptors if possible./// [changes]: crate::io#platform-specific-behaviorgeneric_copy/// The userspace read-write-loop implementation of `io::copy` that is used when/// OS-specific specializations for copy offloading are not available or not applicable.BufferedReaderSpec/// Specialization of the read-write loop that reuses the internal/// buffer of a BufReader. If there's no buffer then the writer side/// should be used instead.BufferedWriterSpec/// Specialization of the read-write loop that either uses a stack buffer/// or reuses the internal buffer of a BufWriterstack_buffer_copytest_vec_writertest_mem_writertest_mem_writer_preallocatedtest_mem_mut_writertest_slice_writertest_slice_writer_vectoredtest_box_slice_writertest_box_slice_writer_vectoredtest_array_writertest_array_writer_vectoredtest_buf_writertest_buf_writer_vectoredtest_buf_writer_seektest_buf_writer_errortest_mem_readertest_mem_reader_vectoredtest_boxed_slice_readertest_boxed_slice_reader_vectoredtest_slice_readertest_slice_reader_vectoredtest_read_exacttest_buf_readerseek_past_endseek_past_i64seek_before_0test_seekable_mem_writervec_seek_past_endvec_seek_before_0vec_seek_and_write_past_usize_maxconst_cursorbench_write_vecbench_write_vec_vectored/// [`Seek`] implementation./// <code>[AsRef]<\[u8]></code>, to allow them to implement [`Read`] and/or [`Write`],/// The standard library implements some I/O traits on various types which/// are commonly used as a buffer, like <code>Cursor<[Vec]\<u8>></code> and/// <code>Cursor<[&\[u8\]][bytes]></code>./// We may want to write bytes to a [`File`] in our production/// code, but use an in-memory buffer in our tests. We can do this with/// `Cursor`:/// [bytes]: crate::slice "slice"/// [`File`]: crate::fs::File/// use std::io::{self, SeekFrom};/// // a library function we've written/// fn write_ten_bytes_at_end<W: Write + Seek>(mut writer: W) -> io::Result<()> {///     writer.seek(SeekFrom::End(-10))?;///         writer.write(&[i])?;///     // all went well/// # fn foo() -> io::Result<()> {/// // Here's some code that uses this library function./// // We might want to use a BufReader here for efficiency, but let's/// // keep this example focused./// let mut file = File::create("foo.txt")?;/// // First, we need to allocate 10 bytes to be able to write into./// file.set_len(10)?;/// write_ten_bytes_at_end(&mut file)?;/// // now let's write a test/// fn test_writes_bytes() {///     // setting up a real File is much slower than an in-memory buffer,///     // let's use a cursor instead///     use std::io::Cursor;///     let mut buff = Cursor::new(vec![0; 15]);///     write_ten_bytes_at_end(&mut buff).unwrap();///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);/// Cursor initial position is `0` even if underlying buffer (e.g., [`Vec`])/// is not empty. So writing to cursor starts with overwriting [`Vec`]/// buff.seek(SeekFrom::Current(2)).unwrap();/// buff.seek(SeekFrom::Current(-1)).unwrap();/// Splits the underlying slice at the cursor position and returns them./// #![feature(cursor_split)]/// assert_eq!(buff.split(), ([].as_slice(), [1, 2, 3, 4, 5].as_slice()));/// assert_eq!(buff.split(), ([1, 2].as_slice(), [3, 4, 5].as_slice()));/// buff.set_position(6);/// assert_eq!(buff.split(), ([1, 2, 3, 4, 5].as_slice(), [].as_slice()));/// Splits the underlying slice at the cursor position and returns them/// assert_eq!(buff.split_mut(), ([].as_mut_slice(), [1, 2, 3, 4, 5].as_mut_slice()));/// assert_eq!(buff.split_mut(), ([1, 2].as_mut_slice(), [3, 4, 5].as_mut_slice()));/// assert_eq!(buff.split_mut(), ([1, 2, 3, 4, 5].as_mut_slice(), [].as_mut_slice()));slice_write// Non-resizing write implementationslice_write_vectoredslice_write_allslice_write_all_vectoredreserve_and_pad/// Reserves the required space, and pads the vec with 0s if necessary.vec_write_all_unchecked/// Writes the slice to the vec without allocating./// `vec` must have `buf.len()` spare capacity.vec_write_all/// Resizing `write_all` implementation for [`Cursor`]./// Cursor is allowed to have a pre-allocated and initialised/// vector body, but with a position of 0. This means the [`Write`]/// will overwrite the contents of the vec./// This also allows for the vec body to be empty, but with a position of N./// This means that [`Write`] will pad the vec with 0 initially,/// before writing anything from that pointvec_write_all_vectored/// Resizing `write_all_vectored` implementation for [`Cursor`].ErrorDataSimpleMessage// The 2 least-significant bits are used as tag.TAG_SIMPLE_MESSAGETAG_CUSTOMTAG_OSTAG_SIMPLE/// The internal representation./// See the module docs for more, this is just a way to hack in a check that we/// indeed are not unwind-safe./// fn is_unwind_safe<T: core::panic::UnwindSafe>() {}/// is_unwind_safe::<std::io::Error>();// All the types `Repr` stores internally are Send + Sync, and so is it.new_osnew_simple_messagedecode_repr// Shared helper to decode a `Repr`'s internal pointer into an ErrorData.// Safety: `ptr`'s bits should be encoded as described in the document at the// top (it should `some_repr.0`)kind_from_prim// This compiles to the same code as the check+transmute, but doesn't require// unsafe, or to hard-code max ErrorKind or its size in a way the compiler// couldn't verify.// Some static checking to alert us if a change breaks any of the assumptions// that our encoding relies on for correctness and soundness. (Some of these are// a bit overly thorough/cautious, admittedly)// If any of these are hit on a platform that std supports, we should likely// just use `repr_unpacked.rs` there instead (unless the fix is easy).// The bitpacking we use requires pointers be exactly 64 bits.// We also require pointers and usize be the same size.// `Custom` and `SimpleMessage` need to be thin pointers.// And they must have sufficient alignment.&// This is obviously true (`TAG_CUSTOM` is `0b01`), but in `Repr::new_custom` we// offset a pointer by this value, and expect it to both be within the same// object, and to not wrap around the address space. See the comment in that// function for further details.// Actually, at the moment we use `ptr::wrapping_add`, not `ptr::add`, so this// check isn't needed for that one, although the assertion that we don't// actually wrap around in that wrapping_add does simplify the safety reasoning// elsewhere considerably.// These two store a payload which is allowed to be zero, so they must be// non-zero to preserve the `NonNull`'s range invariant.// We can't tag `SimpleMessage`s, the tag must be 0.// Check that the point of all of this still holds.// We'd check against `io::Error`, but *technically* it's allowed to vary,// as it's not `#[repr(transparent)]`/`#[repr(C)]`. We could add that, but// the `#[repr()]` would show up in rustdoc, which might be seen as a stable// commitment.//! This is a densely packed error representation which is used on targets with//! 64-bit pointers.//! (Note that `bitpacked` vs `unpacked` here has no relationship to//! `#[repr(packed)]`, it just refers to attempting to use any available bits in//! a more clever manner than `rustc`'s default layout algorithm would).//! Conceptually, it stores the same data as the "unpacked" equivalent we use on//! other targets. Specifically, you can imagine it as an optimized version of//! the following enum (which is roughly equivalent to what's stored by//! `repr_unpacked::Repr`, e.g. `super::ErrorData<Box<Custom>>`)://! ```ignore (exposition-only)//! enum ErrorData {//!    Os(i32),//!    Simple(ErrorKind),//!    SimpleMessage(&'static SimpleMessage),//!    Custom(Box<Custom>),//! However, it packs this data into a 64bit non-zero value.//! This optimization not only allows `io::Error` to occupy a single pointer,//! but improves `io::Result` as well, especially for situations like//! `io::Result<()>` (which is now 64 bits) or `io::Result<u64>` (which is now//! 128 bits), which are quite common.//! # Layout//! Tagged values are 64 bits, with the 2 least significant bits used for the//! tag. This means there are 4 "variants"://! - **Tag 0b00**: The first variant is equivalent to//!   `ErrorData::SimpleMessage`, and holds a `&'static SimpleMessage` directly.//!   `SimpleMessage` has an alignment >= 4 (which is requested with//!   `#[repr(align)]` and checked statically at the bottom of this file), which//!   means every `&'static SimpleMessage` should have the both tag bits as 0,//!   meaning its tagged and untagged representation are equivalent.//!   This means we can skip tagging it, which is necessary as this variant can//!   be constructed from a `const fn`, which probably cannot tag pointers (or//!   at least it would be difficult).//! - **Tag 0b01**: The other pointer variant holds the data for//!   `ErrorData::Custom` and the remaining 62 bits are used to store a//!   `Box<Custom>`. `Custom` also has alignment >= 4, so the bottom two bits//!   are free to use for the tag.//!   The only important thing to note is that `ptr::wrapping_add` and//!   `ptr::wrapping_sub` are used to tag the pointer, rather than bitwise//!   operations. This should preserve the pointer's provenance, which would//!   otherwise be lost.//! - **Tag 0b10**: Holds the data for `ErrorData::Os(i32)`. We store the `i32`//!   in the pointer's most significant 32 bits, and don't use the bits `2..32`//!   for anything. Using the top 32 bits is just to let us easily recover the//!   `i32` code with the correct sign.//! - **Tag 0b11**: Holds the data for `ErrorData::Simple(ErrorKind)`. This//!   stores the `ErrorKind` in the top 32 bits as well, although it doesn't//!   occupy nearly that many. Most of the bits are unused here, but it's not//!   like we need them for anything else yet.//! # Use of `NonNull<()>`//! Everything is stored in a `NonNull<()>`, which is odd, but actually serves a//! purpose.//! Conceptually you might think of this more like://! union Repr {//!     // holds integer (Simple/Os) variants, and//!     // provides access to the tag bits.//!     bits: NonZero<u64>,//!     // Tag is 0, so this is stored untagged.//!     msg: &'static SimpleMessage,//!     // Tagged (offset) `Box<Custom>` pointer.//!     tagged_custom: NonNull<()>,//! But there are a few problems with this://! 1. Union access is equivalent to a transmute, so this representation would//!    require we transmute between integers and pointers in at least one//!    direction, which may be UB (and even if not, it is likely harder for a//!    compiler to reason about than explicit ptr->int operations).//! 2. Even if all fields of a union have a niche, the union itself doesn't,//!    although this may change in the future. This would make things like//!    `io::Result<()>` and `io::Result<usize>` larger, which defeats part of//!    the motivation of this bitpacking.//! Storing everything in a `NonZero<usize>` (or some other integer) would be a//! bit more traditional for pointer tagging, but it would lose provenance//! information, couldn't be constructed from a `const fn`, and would probably//! run into other issues as well.//! The `NonNull<()>` seems like the only alternative, even if it's fairly odd//! to use a pointer type to store something that may hold an integer, some of//! the time.//! This is a fairly simple unpacked error representation that's used on//! non-64bit targets, where the packed 64 bit representation wouldn't work, and//! would have no benefit.const_errordecode_error_kindtest_debug_errortest_downcastingtest_os_packingtest_errorkind_packingtest_simple_message_packingBojjitest_custom_error_packingtest_std_io_error_downcastrepr_bitpacked/// A specialized [`Result`] type for I/O operations./// This type is broadly used across [`std::io`] for any operation which may/// produce an error./// This type alias is generally used to avoid writing out [`io::Error`] directly and/// is otherwise a direct mapping to [`Result`]./// While usual Rust style is to import types directly, aliases of [`Result`]/// often are not, to make it easier to distinguish between them. [`Result`] is/// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias/// will generally use `io::Result` instead of shadowing the [prelude]'s import/// of [`std::result::Result`][`Result`]./// [`std::io`]: crate::io/// [`io::Error`]: Error/// [`Result`]: crate::result::Result/// [prelude]: crate::prelude/// A convenience function that bubbles an `io::Result` to its caller:/// fn get_string() -> io::Result<String> {///     let mut buffer = String::new();///     io::stdin().read_line(&mut buffer)?;/// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and/// associated traits./// Errors mostly originate from the underlying OS, but custom instances of/// `Error` can be created with crafted error messages and a particular value of/// [`Read`]: crate::io::Read/// [`Write`]: crate::io::Write/// [`Seek`]: crate::io::SeekREAD_EXACT_EOFUNKNOWN_THREAD_COUNTUNSUPPORTED_PLATFORMWRITE_ALL_EOFZERO_TIMEOUTNO_ADDRESSES/// Common errors constants for use in std/// Converts a [`alloc::ffi::NulError`] into a [`Error`]./// Converts `TryReserveError` to an error with [`ErrorKind::OutOfMemory`]./// `TryReserveError` won't be available as the error `source()`,/// but this may change in the future.// Only derive debug in tests, to make sure it// doesn't accidentally get printed./// The type of raw OS error codes returned by [`Error::raw_os_error`]./// This is an [`i32`] on all currently supported platforms, but platforms/// added in the future (such as UEFI) may use a different primitive type like/// [`usize`]. Use `as`or [`into`] conversions where applicable to ensure maximum/// portability./// [`into`]: Into::into// `#[repr(align(4))]` is probably redundant, it should have that value or// higher already. We include it just because repr_bitpacked.rs's encoding// requires an alignment >= 4 (note that `#[repr(align)]` will not reduce the// alignment required by the struct, only increase it).// If we add more variants to ErrorData, this can be increased to 8, but it// should probably be behind `#[cfg_attr(target_pointer_width = "64", ...)]` or// whatever cfg we're using to enable the `repr_bitpacked` code, since only the// that version needs the alignment, and 8 is higher than the alignment we'll// have on 32 bit platforms.// (For the sake of being explicit: the alignment requirement here only matters// if `error/repr_bitpacked.rs` is in use — for the unpacked repr it doesn't// matter at all)/// Creates a new I/O error from a known kind of error and a string literal./// Contrary to [`Error::new`], this macro does not allocate and can be used in/// `const` contexts./// #![feature(io_const_error)]/// use std::io::{const_error, Error, ErrorKind};/// const FAIL: Error = const_error!(ErrorKind::Unsupported, "tried something that never works");/// fn not_here() -> Result<(), Error> {///     Err(FAIL)// As with `SimpleMessage`: `#[repr(align(4))]` here is just because// repr_bitpacked's encoding requires it. In practice it almost certainly be// already be this high or higher./// An entity was not found, often a file./// The operation lacked the necessary privileges to complete./// The connection was refused by the remote server.ConnectionReset/// The connection was reset by the remote server./// The remote host is not reachable./// The network containing the remote host is not reachable.ConnectionAborted/// The connection was aborted (terminated) by the remote server./// The network operation failed because it was not connected yet.AddrInUse/// A socket address could not be bound because the address is already in/// use elsewhere.AddrNotAvailable/// A nonexistent interface was requested or the requested address was not/// local.NetworkDown/// The system's networking is down./// The operation failed because a pipe was closed./// An entity already exists, often a file./// The operation needs to block to complete, but the blocking operation was/// requested to not occur.NotADirectory/// A filesystem object is, unexpectedly, not a directory./// For example, a filesystem path was specified where one of the intermediate directory/// components was, in fact, a plain file.IsADirectory/// The filesystem object is, unexpectedly, a directory./// A directory was specified when a non-directory was expected.DirectoryNotEmpty/// A non-empty directory was specified where an empty directory was expected.ReadOnlyFilesystem/// The filesystem or storage medium is read-only, but a write operation was attempted.FilesystemLoop/// Loop in the filesystem or IO subsystem; often, too many levels of symbolic links./// There was a loop (or excessively long chain) resolving a filesystem object/// or file IO object./// On Unix this is usually the result of a symbolic link loop; or, of exceeding the/// system-specific limit on the depth of symlink traversal.StaleNetworkFileHandle/// Stale network file handle./// With some network filesystems, notably NFS, an open file (or directory) can be invalidated/// by problems with the network or server./// Data not valid for the operation were encountered./// Unlike [`InvalidInput`], this typically means that the operation/// parameters were valid, however the error was caused by malformed/// For example, a function that reads a file into a string will error with/// `InvalidData` if the file's contents are not valid UTF-8./// [`InvalidInput`]: ErrorKind::InvalidInput/// The I/O operation's timeout expired, causing it to be canceled.WriteZero/// An error returned when an operation could not be completed because a/// call to [`write`] returned [`Ok(0)`]./// This typically means that an operation could only succeed if it wrote a/// particular number of bytes but only a smaller number of bytes could be/// [`write`]: crate::io::Write::write/// [`Ok(0)`]: OkStorageFull/// The underlying storage (typically, a filesystem) is full./// This does not include out of quota errors.NotSeekable/// Seek on unseekable file./// Seeking was attempted on an open file handle which is not suitable for seeking - for/// example, on Unix, a named pipe opened with `File::open`.QuotaExceeded/// Filesystem quota or some other kind of quota was exceeded.FileTooLarge/// File larger than allowed or supported./// This might arise from a hard limit of the underlying filesystem or file access API, or from/// an administratively imposed resource limitation.  Simple disk full, and out of quota, have/// their own errors.ResourceBusy/// Resource is busy.ExecutableFileBusy/// Executable file is busy./// An attempt was made to write to a file which is also in use as a running program.  (Not all/// operating systems detect this situation.)Deadlock/// Deadlock (avoided)./// A file locking operation would result in deadlock.  This situation is typically detected, if/// at all, on a best-effort basis.CrossesDevices/// Cross-device or cross-filesystem (hard) link or rename./// Too many (hard) links to the same filesystem object./// The filesystem does not support making so many hardlinks to the same file./// A filename was invalid./// This error can also occur if a length limit for a name was exceeded.ArgumentListTooLong/// Program argument list too long./// When trying to run an external program, a system or process limit on the size of the/// arguments would have been exceeded./// This operation was interrupted./// Interrupted operations can typically be retried./// This operation is unsupported on this platform./// This means that the operation can never succeed.// ErrorKinds which are primarily categorisations for OS error// codes should be added above./// An error returned when an operation could not be completed because an/// "end of file" was reached prematurely./// This typically means that an operation could only succeed if it read a/// read./// An operation could not be completed, because it failed/// to allocate enough memory./// The operation was partially successful and needs to be checked/// later on due to not blocking.// "Unusual" error kinds which do not correspond simply to (sets// of) OS error codes, should be added just above this comment.// `Other` and `Uncategorized` should remain at the end:/// A custom error that does not fall under any other I/O error kind./// This can be used to construct your own [`Error`]s that do not match any/// This [`ErrorKind`] is not used by the standard library./// Errors from the standard library that do not fall under any of the I/O/// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern./// New [`ErrorKind`]s might be added in the future for some of those.Uncategorized/// Any I/O error from the standard library that's not part of this list./// Errors that are `Uncategorized` now may move to a different or a new/// [`ErrorKind`] variant in the future. It is not recommended to match/// an error against `Uncategorized`; use a wildcard match (`_`) instead./// A list specifying general categories of I/O error./// This list is intended to grow over time and it is not recommended to/// exhaustively match against it./// It is used with the [`io::Error`] type./// # Handling errors and matching on `ErrorKind`/// In application code, use `match` for the `ErrorKind` values you are/// expecting; use `_` to match "all other errors"./// In comprehensive and thorough tests that want to verify that a test doesn't/// return any known incorrect error kind, you may want to cut-and-paste the/// current full list of errors from here into your test code, and then match/// `_` as the correct case. This seems counterintuitive, but it will make your/// tests more robust. In particular, if you want to verify that your code does/// produce an unrecognized error kind, the robust solution is to check for all/// the recognized error kinds and fail in those cases./// Shows a human-readable description of the `ErrorKind`./// This is similar to `impl Display for Error`, but doesn't require first converting to Error./// assert_eq!("entity not found", ErrorKind::NotFound.to_string());/// Converts an [`ErrorKind`] into an [`Error`]./// This conversion creates a new error with a simple representation of error kind./// let not_found = ErrorKind::NotFound;/// let error = Error::from(not_found);/// assert_eq!("entity not found", format!("{error}"));/// Intended for use for errors not exposed to the user, where allocating onto/// the heap (for normal construction via Error::new) is too costly./// Creates a new I/O error from a known kind of error as well as an/// arbitrary error payload./// This function is used to generically create I/O errors which do not/// originate from the OS itself. The `error` argument is an arbitrary/// payload which will be contained in this [`Error`]./// Note that this function allocates memory on the heap./// If no extra payload is required, use the `From` conversion from/// `ErrorKind`./// // errors can be created from strings/// let custom_error = Error::new(ErrorKind::Other, "oh no!");/// // errors can also be created from other errors/// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);/// // creating an error without payload (and without memory allocation)/// let eof_error = Error::from(ErrorKind::UnexpectedEof);/// Creates a new I/O error from an arbitrary error payload./// originate from the OS itself. It is a shortcut for [`Error::new`]/// with [`ErrorKind::Other`]./// let custom_error = Error::other("oh no!");/// let custom_error2 = Error::other(custom_error);from_static_message/// Creates a new I/O error from a known kind of error as well as a constant/// You should not use this directly, and instead use the `const_error!`/// macro: `io::const_error!(ErrorKind::Something, "some_message")`./// This function should maybe change to `from_static_message<const MSG: &'static/// str>(kind: ErrorKind)` in the future, when const generics allow that./// Returns an error representing the last OS error which occurred./// This function reads the value of `errno` for the target platform (e.g./// `GetLastError` on Windows) and will return a corresponding instance of/// [`Error`] for the error code./// This should be called immediately after a call to a platform function,/// otherwise the state of the error value is indeterminate. In particular,/// other standard library functions may call platform functions that may/// (or may not) reset the error value even if they succeed./// let os_error = Error::last_os_error();/// println!("last OS error: {os_error:?}");/// Creates a new instance of an [`Error`] from a particular OS error code./// # if cfg!(target_os = "linux") {/// let error = io::Error::from_raw_os_error(22);/// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);/// On Windows:/// # if cfg!(windows) {/// let error = io::Error::from_raw_os_error(10022);/// Returns the OS error that this error represents (if any)./// If this [`Error`] was constructed via [`last_os_error`] or/// [`from_raw_os_error`], then this function will return [`Some`], otherwise/// it will return [`None`]./// [`last_os_error`]: Error::last_os_error/// [`from_raw_os_error`]: Error::from_raw_os_error/// fn print_os_error(err: &Error) {///     if let Some(raw_os_err) = err.raw_os_error() {///         println!("raw OS error: {raw_os_err:?}");///         println!("Not an OS error");///     // Will print "raw OS error: ...".///     print_os_error(&Error::last_os_error());///     // Will print "Not an OS error".///     print_os_error(&Error::new(ErrorKind::Other, "oh no!"));/// Returns a reference to the inner error wrapped by this error (if any)./// If this [`Error`] was constructed via [`new`] then this function will/// return [`Some`], otherwise it will return [`None`]./// [`new`]: Error::new/// fn print_error(err: &Error) {///     if let Some(inner_err) = err.get_ref() {///         println!("Inner error: {inner_err:?}");///         println!("No inner error");///     // Will print "No inner error".///     print_error(&Error::last_os_error());///     // Will print "Inner error: ...".///     print_error(&Error::new(ErrorKind::Other, "oh no!"));/// Returns a mutable reference to the inner error wrapped by this error/// use std::{error, fmt};/// use std::fmt::Display;/// struct MyError {///     v: String,/// impl MyError {///     fn new() -> MyError {///         MyError {///             v: "oh no!".to_string()///     fn change_message(&mut self, new_message: &str) {///         self.v = new_message.to_string();/// impl error::Error for MyError {}/// impl Display for MyError {///         write!(f, "MyError: {}", self.v)/// fn change_error(mut err: Error) -> Error {///     if let Some(inner_err) = err.get_mut() {///         inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");///     err///         println!("Inner error: {inner_err}");///     print_error(&change_error(Error::last_os_error()));///     print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));/// Consumes the `Error`, returning its inner error (if any)./// If this [`Error`] was constructed via [`new`] or [`other`],/// then this function will return [`Some`],/// otherwise it will return [`None`]./// [`other`]: Error::other/// fn print_error(err: Error) {///     if let Some(inner_err) = err.into_inner() {///     print_error(Error::last_os_error());///     print_error(Error::new(ErrorKind::Other, "oh no!"));/// Attempts to downcast the custom boxed error to `E`./// If this [`Error`] contains a custom boxed error,/// then it would attempt downcasting on the boxed error,/// otherwise it will return [`Err`]./// If the custom boxed error has the same type as `E`, it will return [`Ok`],/// otherwise it will also return [`Err`]./// This method is meant to be a convenience routine for calling/// `Box<dyn Error + Sync + Send>::downcast` on the custom boxed error, returned by/// [`Error::into_inner`].///     SomeOtherVariant,/// impl fmt::Display for E {/// #    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {/// #        todo!()/// impl Error for E {}/// impl From<io::Error> for E {///     fn from(err: io::Error) -> E {///         err.downcast::<E>()///             .unwrap_or_else(E::Io)/// impl From<E> for io::Error {///     fn from(err: E) -> io::Error {///         match err {///             E::Io(io_error) => io_error,///             e => io::Error::new(io::ErrorKind::Other, e),/// let e = E::SomeOtherVariant;/// // Convert it to an io::Error/// let io_error = io::Error::from(e);/// // Cast it back to the original variant/// let e = E::from(io_error);/// assert!(matches!(e, E::SomeOtherVariant));/// let io_error = io::Error::from(io::ErrorKind::AlreadyExists);/// // Convert it to E/// assert_eq!(io_error.kind(), io::ErrorKind::AlreadyExists);/// assert!(io_error.get_ref().is_none());/// assert!(io_error.raw_os_error().is_none());/// Returns the corresponding [`ErrorKind`] for this error./// This may be a value set by Rust code constructing custom `io::Error`s,/// or if this `io::Error` was sourced from the operating system,/// it will be a value inferred from the system's error encoding./// See [`last_os_error`] for more details.///     println!("{:?}", err.kind());///     // As no error has (visibly) occurred, this may print anything!///     // It likely prints a placeholder for unidentified (non-)errors.///     // Will print "AddrInUse".///     print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));is_interrupted_assert_error_is_sync_sendbench_read_slicebench_write_slicebench_read_vechas_data_leftskip_until/// Read is implemented for `&[u8]` by copying from the slice./// Note that reading updates the slice to point to the yet unread part./// The slice will be empty when EOF is reached./// Write is implemented for `&mut [u8]` by copying into the slice, overwriting/// its data./// Note that writing updates the slice to point to the yet unwritten part./// The slice will be empty when it has been completely overwritten./// If the number of bytes to be written exceeds the size of the slice, write operations will/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of/// kind `ErrorKind::WriteZero`./// Write is implemented for `Vec<u8>` by appending to the vector./// The vector will grow as needed./// Fill `buf` with the contents of the "front" slice as returned by/// [`as_slices`][`VecDeque::as_slices`]. If the contained byte slices of the `VecDeque` are/// discontiguous, multiple calls to `read` will be needed to read the entire content./// Read is implemented for `VecDeque<u8>` by consuming bytes from the front of the `VecDeque`./// Returns the contents of the "front" slice as returned by/// discontiguous, multiple calls to `fill_buf` will be needed to read the entire content./// BufRead is implemented for `VecDeque<u8>` by reading bytes from the front of the `VecDeque`./// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.// =============================================================================// Forwarding implementations// In-memory buffer implementationsattempt_print_to_stderr_eprint_printset_output_capturetry_set_output_captureappend_to_string// Several `read_to_string` and `read_line` methods in the standard library will// append data into a `String` buffer, but we need to be pretty careful when// doing this. The implementation will just call `.as_mut_vec()` and then// delegate to a byte-oriented reading method, but we must ensure that when// returning we never leave `buf` in a state such that it contains invalid UTF-8// in its bounds.// To this end, we use an RAII guard (to protect against panics) which updates// the length of the string when it is dropped. This guard initially truncates// the string to the prior length and only after we've validated that the// new contents are valid UTF-8 do we allow it to set a longer length.// The unsafety in this function is twofold:// 1. We're looking at the raw bytes of `buf`, so we take on the burden of UTF-8//    checks.// 2. We're passing a raw buffer to the function `f`, and it is expected that//    the function only *appends* bytes to the buffer. We'll get undefined//    behavior if existing bytes are overwritten to have non-UTF-8 data.default_read_to_end// Here we must serve many masters with conflicting goals:// - avoid allocating unless necessary// - avoid overallocating if we know the exact size (#89165)// - avoid passing large buffers to readers that always initialize the free capacity if they perform short reads (#23815, #23820)// - pass large buffers to readers that do not initialize the spare capacity. this can amortize per-call overheads// - and finally pass not-too-small and not-too-large buffers to Windows read APIs because they manage to suffer from both problems//   at the same time, i.e. small reads suffer from syscall overhead, all reads incur costs proportional to buffer size (#110650)default_read_to_stringdefault_read_vectoreddefault_write_vectoreddefault_read_exactdefault_read_bufdefault_read_buf_exactdefault_write_fmt/// Pull some bytes from this source into the specified buffer, returning/// This function does not provide any guarantees about whether it blocks/// waiting for data, but if an object needs to block for a read and cannot,/// it will typically signal this via an [`Err`] return value./// If the return value of this method is [`Ok(n)`], then implementations must/// guarantee that `0 <= n <= buf.len()`. A nonzero `n` value indicates/// that the buffer `buf` has been filled in with `n` bytes of data from this/// source. If `n` is `0`, then it can indicate one of two scenarios:/// 1. This reader has reached its "end of file" and will likely no longer///    be able to produce bytes. Note that this does not mean that the///    reader will *always* no longer be able to produce bytes. As an example,///    on Linux, this method will call the `recv` syscall for a [`TcpStream`],///    where returning zero indicates the connection was shut down correctly. While///    for [`File`], it is possible to reach the end of file and get zero as result,///    but if more data is appended to the file, future calls to `read` will return///    more data./// It is not an error if the returned value `n` is smaller than the buffer size,/// even when the reader is not at the end of the stream yet./// This may happen for example because fewer bytes are actually available right now/// (e. g. being close to end-of-file) or because read() was interrupted by a signal./// As this trait is safe to implement, callers in unsafe code cannot rely on/// `n <= buf.len()` for safety./// Extra care needs to be taken when `unsafe` functions are used to access the read bytes./// Callers have to ensure that no unchecked out-of-bounds accesses are possible even if/// `n > buf.len()`./// *Implementations* of this method can make no assumptions about the contents of `buf` when/// this function is called. It is recommended that implementations only write data to `buf`/// instead of reading its contents./// Correspondingly, however, *callers* of this method in unsafe code must not assume/// any guarantees about how the implementation uses `buf`. The trait is safe to implement,/// so it is possible that the code that's supposed to write to the buffer might also read/// from it. It is your responsibility to make sure that `buf` is initialized/// before calling `read`. Calling `read` with an uninitialized `buf` (of the kind one/// obtains via [`MaybeUninit<T>`]) is not safe, and can lead to undefined behavior./// If this function encounters any form of I/O or other error, an error/// variant will be returned. If an error is returned then it must be/// guaranteed that no bytes were read./// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the read/// operation should be retried if there is nothing else to do./// [`File`]s implement `Read`:/// [`Ok(n)`]: Ok///     let mut buffer = [0; 10];///     // read up to 10 bytes///     let n = f.read(&mut buffer[..])?;///     println!("The bytes: {:?}", &buffer[..n]);/// written to possibly being only partially filled. This method must/// behave equivalently to a single call to `read` with concatenated/// The default implementation calls `read` with either the first nonempty/// Determines if this `Read`er has an efficient `read_vectored`/// If a `Read`er does not override the default `read_vectored`/// Reads all bytes until EOF in this source, placing them into `buf`./// All bytes read from this source will be appended to the specified buffer/// `buf`. This function will continuously call [`read()`] to append more data to/// `buf` until [`read()`] returns either [`Ok(0)`] or an error of/// non-[`ErrorKind::Interrupted`] kind./// If successful, this function will return the total number of bytes read./// If this function encounters an error of the kind/// [`ErrorKind::Interrupted`] then the error is ignored and the operation/// If any other read error is encountered then this function immediately/// returns. Any bytes which have already been read will be appended to/// [`read()`]: Read::read///     // read the whole file///     f.read_to_end(&mut buffer)?;/// (See also the [`std::fs::read`] convenience function for reading from a/// file.)/// [`std::fs::read`]: crate::fs::read/// ## Implementing `read_to_end`/// When implementing the `io::Read` trait, it is recommended to allocate/// memory using [`Vec::try_reserve`]. However, this behavior is not guaranteed/// by all implementations, and `read_to_end` may not handle out-of-memory/// situations gracefully./// # use std::io::{self, BufRead};/// # struct Example { example_datasource: io::Empty } impl Example {/// # fn get_some_data_for_the_example(&self) -> &'static [u8] { &[] }/// fn read_to_end(&mut self, dest_vec: &mut Vec<u8>) -> io::Result<usize> {///     let initial_vec_len = dest_vec.len();///         let src_buf = self.example_datasource.fill_buf()?;///         if src_buf.is_empty() {///         dest_vec.try_reserve(src_buf.len())?;///         dest_vec.extend_from_slice(src_buf);///         // Any irreversible side effects should happen after `try_reserve` succeeds,///         // to avoid losing data on allocation error.///         let read = src_buf.len();///         self.example_datasource.consume(read);///     Ok(dest_vec.len() - initial_vec_len)/// # Usage Notes/// `read_to_end` attempts to read a source until EOF, but many sources are continuous streams/// that do not send EOF. In these cases, `read_to_end` will block indefinitely. Standard input/// is one such stream which may be finite if piped, but is typically continuous. For example,/// `cat file | my-rust-program` will correctly terminate with an `EOF` upon closure of cat./// Reading user input or running programs that remain open indefinitely will never terminate/// the stream with `EOF` (e.g. `yes | my-rust-program`)./// Using `.lines()` with a [`BufReader`] or using [`read`] can provide a better solution///[`read`]: Read::read/// [`Vec::try_reserve`]: crate::vec::Vec::try_reserve/// Reads all bytes until EOF in this source, appending them to `buf`./// If successful, this function returns the number of bytes which were read/// and appended to `buf`./// If the data in this stream is *not* valid UTF-8 then an error is/// returned and `buf` is unchanged./// See [`read_to_end`] for other error semantics.///     f.read_to_string(&mut buffer)?;/// (See also the [`std::fs::read_to_string`] convenience function for/// reading from a file.)/// `read_to_string` attempts to read a source until EOF, but many sources are continuous streams/// that do not send EOF. In these cases, `read_to_string` will block indefinitely. Standard input/// [`std::fs::read_to_string`]: crate::fs::read_to_string/// This function reads as many bytes as necessary to completely fill the/// specified buffer `buf`./// instead of reading its contents. The documentation on [`read`] has a more detailed/// explanation of this subject./// If this function encounters an "end of file" before completely filling/// the buffer, it returns an error of the kind [`ErrorKind::UnexpectedEof`]./// The contents of `buf` are unspecified in this case./// returns. The contents of `buf` are unspecified in this case./// If this function returns an error, it is unspecified how many bytes it/// has read, but it will never read more than would be necessary to/// completely fill the buffer.///     // read exactly 10 bytes///     f.read_exact(&mut buffer)?;/// Pull some bytes from this source into the specified buffer./// This is equivalent to the [`read`](Read::read) method, except that it is passed a [`BorrowedCursor`] rather than `[u8]` to allow use/// with uninitialized buffers. The new data will be appended to any existing contents of `buf`./// The default implementation delegates to `read`./// This method makes it possible to return both data and an error but it is advised against./// Reads the exact number of bytes required to fill `cursor`./// This is similar to the [`read_exact`](Read::read_exact) method, except/// that it is passed a [`BorrowedCursor`] rather than `[u8]` to allow use/// with uninitialized buffers./// If this function encounters an error of the kind [`ErrorKind::Interrupted`]/// then the error is ignored and the operation will continue./// If this function returns an error, all bytes read will be appended to `cursor`./// Creates a "by reference" adapter for this instance of `Read`./// The returned adapter also implements `Read` and will simply borrow this/// current reader.///     let mut other_buffer = Vec::new();///         let reference = f.by_ref();///         // read at most 5 bytes///         reference.take(5).read_to_end(&mut buffer)?;///     } // drop our &mut reference so we can use f again///     // original file still usable, read the rest///     f.read_to_end(&mut other_buffer)?;/// Transforms this `Read` instance to an [`Iterator`] over its bytes./// The returned type implements [`Iterator`] where the [`Item`] is/// <code>[Result]<[u8], [io::Error]></code>./// The yielded item is [`Ok`] if a byte was successfully read and [`Err`]/// otherwise. EOF is mapped to returning [`None`] from this iterator./// The default implementation calls `read` for each byte,/// which can be very inefficient for data that's not in memory,/// such as [`File`]. Consider using a [`BufReader`] in such cases./// [`Item`]: Iterator::Item/// [`File`]: crate::fs::File "fs::File"/// [Result]: crate::result::Result "Result"/// [io::Error]: self::Error "io::Error"///     let f = BufReader::new(File::open("foo.txt")?);///     for byte in f.bytes() {///         println!("{}", byte?);/// The returned `Read` instance will first read all bytes from this object///     let f1 = File::open("foo.txt")?;///     let f2 = File::open("bar.txt")?;///     let mut handle = f1.chain(f2);///     // read the value into a String. We could use any Read method here,///     // this is just one example.///     handle.read_to_string(&mut buffer)?;/// This function returns a new instance of `Read` which will read at most/// `limit` bytes, after which it will always return EOF ([`Ok(0)`]). Any/// read errors will not count towards the number of bytes read and future/// calls to [`read()`] may succeed.///     let mut buffer = [0; 5];///     // read at most five bytes///     let mut handle = f.take(5);///     handle.read(&mut buffer)?;read_array/// Read and return a fixed array of bytes from this source./// This function uses an array sized based on a const generic size known at compile time. You/// can specify the size with turbofish (`reader.read_array::<8>()`), or let type inference/// determine the number of bytes needed based on how the return value gets used. For instance,/// this function works well with functions like [`u64::from_le_bytes`] to turn an array of/// bytes into an integer of the same size./// Like `read_exact`, if this function encounters an "end of file" before reading the desired/// number of bytes, it returns an error of the kind [`ErrorKind::UnexpectedEof`]./// #![feature(read_array)]///     let mut buf = Cursor::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2]);///     let x = u64::from_le_bytes(buf.read_array()?);///     let y = u32::from_be_bytes(buf.read_array()?);///     let z = u16::from_be_bytes(buf.read_array()?);///     assert_eq!(x, 0x807060504030201);///     assert_eq!(y, 0x9080706);///     assert_eq!(z, 0x504);/// The `Read` trait allows for reading bytes from a source./// Implementors of the `Read` trait are called 'readers'./// Readers are defined by one required method, [`read()`]. Each call to [`read()`]/// will attempt to pull bytes from this source into a provided buffer. A/// number of other methods are implemented in terms of [`read()`], giving/// implementors a number of ways to read bytes while only needing to implement/// a single method./// Readers are intended to be composable with one another. Many implementors/// throughout [`std::io`] take and provide types which implement the `Read`/// Please note that each call to [`read()`] may involve a system call, and/// therefore, using something that implements [`BufRead`], such as/// [`BufReader`], will be more efficient./// Repeated calls to the reader use the same cursor, so for example/// calling `read_to_end` twice on a [`File`] will only return the file's/// contents once. It's recommended to first call `rewind()` in that case.///     f.read(&mut buffer)?;///     // read into a String, so that you don't need to do the conversion.///     // and more! See the other methods for more details./// Read from [`&str`] because [`&[u8]`][prim@slice] implements `Read`:///     let mut b = "This string will be read".as_bytes();///     b.read(&mut buffer)?;///     // etc... it works exactly as a File does!/// [`&str`]: prim@str/// [`std::io`]: self/// Reads all bytes from a [reader][Read] into a new [`String`]./// This is a convenience function for [`Read::read_to_string`]. Using this/// function avoids having to create a variable first and provides more type/// safety since you can only get the buffer out if there were no errors. (If you/// use [`Read::read_to_string`] you have to remember to check whether the read/// succeeded because otherwise your buffer will be empty or only partially full.)/// The downside of this function's increased ease of use and type safety is/// that it gives you less control over performance. For example, you can't/// pre-allocate memory like you can using [`String::with_capacity`] and/// [`Read::read_to_string`]. Also, you can't re-use the buffer if an error/// occurs while reading./// In many cases, this function's performance will be adequate and the ease of use/// and type safety tradeoffs will be worth it. However, there are cases where you/// need more control over performance, and in those cases you should definitely use/// [`Read::read_to_string`] directly./// Note that in some special cases, such as when reading files, this function will/// pre-allocate memory based on the size of the input it is reading. In those/// cases, the performance should be as good as if you had used/// [`Read::read_to_string`] with a manually pre-allocated buffer./// This function forces you to handle errors because the output (the `String`)/// is wrapped in a [`Result`]. See [`Read::read_to_string`] for the errors/// that can occur. If any error occurs, you will get an [`Err`], so you/// don't have to worry about your buffer being empty or partially full.///     let stdin = io::read_to_string(io::stdin())?;///     println!("Stdin was:");///     println!("{stdin}");/// A buffer type used with `Read::read_vectored`./// It is semantically a wrapper around a `&mut [u8]`, but is guaranteed to be/// ABI compatible with the `iovec` type on Unix platforms and `WSABUF` on/// Creates a new `IoSliceMut` wrapping a byte slice./// Advance the internal cursor of the slice./// Also see [`IoSliceMut::advance_slices`] to advance the cursors of/// Panics when trying to advance beyond the end of the slice./// use std::io::IoSliceMut;/// let mut data = [1; 8];/// let mut buf = IoSliceMut::new(&mut data);/// // Mark 3 bytes as read./// buf.advance(3);/// assert_eq!(buf.deref(), [1; 5].as_ref());advance_slices/// Advance a slice of slices./// Shrinks the slice to remove any `IoSliceMut`s that are fully advanced over./// If the cursor ends up in the middle of an `IoSliceMut`, it is modified/// to start at that cursor./// For example, if we have a slice of two 8-byte `IoSliceMut`s, and we advance by 10 bytes,/// the result will only include the second `IoSliceMut`, advanced by 2 bytes./// Panics when trying to advance beyond the end of the slices./// let mut buf1 = [1; 8];/// let mut buf2 = [2; 16];/// let mut buf3 = [3; 8];/// let mut bufs = &mut [///     IoSliceMut::new(&mut buf1),///     IoSliceMut::new(&mut buf2),///     IoSliceMut::new(&mut buf3),/// // Mark 10 bytes as read./// IoSliceMut::advance_slices(&mut bufs, 10);/// assert_eq!(bufs[0].deref(), [2; 14].as_ref());/// assert_eq!(bufs[1].deref(), [3; 8].as_ref());/// Get the underlying bytes as a mutable slice with the original lifetime./// #![feature(io_slice_as_bytes)]/// let mut data = *b"abcdef";/// let io_slice = IoSliceMut::new(&mut data);/// io_slice.into_slice()[0] = b'A';/// assert_eq!(&data, b"Abcdef");/// A buffer type used with `Write::write_vectored`./// It is semantically a wrapper around a `&[u8]`, but is guaranteed to be/// Also see [`IoSlice::advance_slices`] to advance the cursors of multiple/// let data = [1; 8];/// let mut buf = IoSlice::new(&data);/// Shrinks the slice to remove any `IoSlice`s that are fully advanced over./// If the cursor ends up in the middle of an `IoSlice`, it is modified/// For example, if we have a slice of two 8-byte `IoSlice`s, and we advance by 10 bytes,/// the result will only include the second `IoSlice`, advanced by 2 bytes./// let buf1 = [1; 8];/// let buf2 = [2; 16];/// let buf3 = [3; 8];///     IoSlice::new(&buf1),///     IoSlice::new(&buf2),///     IoSlice::new(&buf3),/// // Mark 10 bytes as written./// IoSlice::advance_slices(&mut bufs, 10);/// Get the underlying bytes as a slice with the original lifetime./// This doesn't borrow from `self`, so is less restrictive than calling/// `.deref()`, which does./// let data = b"abcdef";/// let mut io_slice = IoSlice::new(data);/// let tail = &io_slice.as_slice()[3..];/// // This works because `tail` doesn't borrow `io_slice`/// io_slice = IoSlice::new(tail);/// assert_eq!(io_slice.as_slice(), b"def");/// Writes a buffer into this writer, returning how many bytes were written./// This function will attempt to write the entire contents of `buf`, but/// the entire write might not succeed, or the write may also generate an/// error. Typically, a call to `write` represents one attempt to write to/// any wrapped object./// Calls to `write` are not guaranteed to block waiting for data to be/// written, and a write which would otherwise block can be indicated through/// an [`Err`] variant./// If this method consumed `n > 0` bytes of `buf` it must return [`Ok(n)`]./// If the return value is `Ok(n)` then `n` must satisfy `n <= buf.len()`./// A return value of `Ok(0)` typically means that the underlying object is/// no longer able to accept bytes and will likely not be able to in the/// future as well, or that the buffer provided is empty./// Each call to `write` may generate an I/O error indicating that the/// operation could not be completed. If an error is returned then no bytes/// in the buffer were written to this writer./// It is **not** considered an error if the entire buffer could not be/// written to this writer./// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the/// write operation should be retried if there is nothing else to do.///     let mut buffer = File::create("foo.txt")?;///     // Writes some prefix of the byte string, not necessarily all of it.///     buffer.write(b"some bytes")?;/// Like [`write`], except that it writes from a slice of buffers./// The default implementation calls [`write`] with either the first nonempty///     let data1 = [1; 8];///     let data2 = [15; 8];///     let io_slice1 = IoSlice::new(&data1);///     let io_slice2 = IoSlice::new(&data2);///     buffer.write_vectored(&[io_slice1, io_slice2])?;/// Determines if this `Write`r has an efficient [`write_vectored`]/// If a `Write`r does not override the default [`write_vectored`]/// [`write_vectored`]: Write::write_vectored/// Flushes this output stream, ensuring that all intermediately buffered/// contents reach their destination./// It is considered an error if not all bytes could be written due to/// I/O errors or EOF being reached.///     let mut buffer = BufWriter::new(File::create("foo.txt")?);///     buffer.write_all(b"some bytes")?;///     buffer.flush()?;/// Attempts to write an entire buffer into this writer./// This method will continuously call [`write`] until there is no more data/// to be written or an error of non-[`ErrorKind::Interrupted`] kind is/// returned. This method will not return until the entire buffer has been/// successfully written or such an error occurs. The first error that is/// not of [`ErrorKind::Interrupted`] kind generated from this method will be/// If the buffer contains no data, this will never call [`write`]./// This function will return the first error of/// non-[`ErrorKind::Interrupted`] kind that [`write`] returns./// Attempts to write multiple buffers into this writer./// This method will continuously call [`write_vectored`] until there is no/// more data to be written or an error of non-[`ErrorKind::Interrupted`]/// kind is returned. This method will not return until all buffers have/// been successfully written or such an error occurs. The first error that/// is not of [`ErrorKind::Interrupted`] kind generated from this method/// If the buffer contains no data, this will never call [`write_vectored`]./// Unlike [`write_vectored`], this takes a *mutable* reference to/// a slice of [`IoSlice`]s, not an immutable one. That's because we need to/// modify the slice to keep track of the bytes already written./// Once this function returns, the contents of `bufs` are unspecified, as/// this depends on how many calls to [`write_vectored`] were necessary. It is/// best to understand this function as taking ownership of `bufs` and to/// not use `bufs` afterwards. The underlying buffers, to which the/// [`IoSlice`]s point (but not the [`IoSlice`]s themselves), are unchanged and/// can be reused./// #![feature(write_all_vectored)]/// use std::io::{Write, IoSlice};/// let bufs = &mut [///     IoSlice::new(&[1]),///     IoSlice::new(&[2, 3]),///     IoSlice::new(&[4, 5, 6]),/// writer.write_all_vectored(bufs)?;/// // Note: the contents of `bufs` is now undefined, see the Notes section./// assert_eq!(writer, &[1, 2, 3, 4, 5, 6]);/// Writes a formatted string into this writer, returning any error/// This method is primarily used to interface with the/// [`format_args!()`] macro, and it is rare that this should/// explicitly be called. The [`write!()`] macro should be favored to/// invoke this method instead./// This function internally uses the [`write_all`] method on/// this trait and hence will continuously write data so long as no errors/// are received. This also means that partial writes are not indicated in/// this signature./// This function will return any I/O error reported while formatting.///     // this call///     write!(buffer, "{:.*}", 2, 1.234567)?;///     // turns into this:///     buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;/// Creates a "by reference" adapter for this instance of `Write`./// The returned adapter also implements `Write` and will simply borrow this/// current writer.///     let reference = buffer.by_ref();///     // we can use reference just like our original buffer///     reference.write_all(b"some bytes")?;/// A trait for objects which are byte-oriented sinks./// Implementors of the `Write` trait are sometimes called 'writers'./// Writers are defined by two required methods, [`write`] and [`flush`]:/// * The [`write`] method will attempt to write some data into the object,///   returning how many bytes were successfully written./// * The [`flush`] method is useful for adapters and explicit buffers///   themselves for ensuring that all buffered data has been pushed out to the///   'true sink'./// Writers are intended to be composable with one another. Many implementors/// throughout [`std::io`] take and provide types which implement the `Write`/// [`flush`]: Write::flush///     let data = b"some bytes";///     while pos < data.len() {///         let bytes_written = buffer.write(&data[pos..])?;///         pos += bytes_written;/// The trait also provides convenience methods like [`write_all`], which calls/// `write` in a loop until its entire input has been written./// Seek to an offset, in bytes, in a stream./// Seeking can fail, for example because it might involve flushing a buffer./// Rewind to the beginning of a stream./// This is a convenience method, equivalent to `seek(SeekFrom::Start(0))`./// Rewinding can fail, for example because it might involve flushing a buffer./// let mut f = OpenOptions::new()///     .open("foo.txt")?;/// let hello = "Hello!\n";/// write!(f, "{hello}")?;/// f.rewind()?;/// f.read_to_string(&mut buf)?;/// assert_eq!(&buf, hello);/// Returns the length of this stream (in bytes)./// The default implementation uses up to three seek operations. If this/// method returns successfully, the seek position is unchanged (i.e. the/// position before calling this method is the same as afterwards)./// However, if this method returns an error, the seek position is/// If you need to obtain the length of *many* streams and you don't care/// about the seek position afterwards, you can reduce the number of seek/// operations by simply calling `seek(SeekFrom::End(0))` and using its/// return value (it is also the stream length)./// Note that length of a stream can change over time (for example, when/// data is appended to a file). So calling this method multiple times does/// not necessarily return the same length each time./// #![feature(seek_stream_len)]///     io::{self, Seek},///     let len = f.stream_len()?;///     println!("The file is currently {len} bytes long");/// This is equivalent to `self.seek(SeekFrom::Current(offset))` but/// doesn't return the new position which can allow some implementations/// such as [`BufReader`] to perform more efficient seeks.///     f.seek_relative(10)?;///     assert_eq!(f.stream_position()?, 10);/// [`BufReader`]: crate::io::BufReader/// The `Seek` trait provides a cursor which can be moved within a stream of/// The stream typically has a fixed size, allowing seeking relative to either/// end or the current offset./// [`File`]s implement `Seek`:///     // move the cursor 42 bytes from the start of the file///     f.seek(SeekFrom::Start(42))?;stream_len_default/// It is possible to seek beyond the end of an object, but it's an error to/// seek before byte 0./// Returns the contents of the internal buffer, filling it with more data, via `Read` methods, if empty./// This is a lower-level method and is meant to be used together with [`consume`],/// which can be used to mark bytes that should not be returned by subsequent calls to `read`./// [`consume`]: BufRead::consume/// Returns an empty buffer when the stream has reached EOF./// This function will return an I/O error if a `Read` method was called, but returned an error./// A locked standard input implements `BufRead`:/// let stdin = io::stdin();/// let mut stdin = stdin.lock();/// let buffer = stdin.fill_buf()?;/// // work with buffer/// println!("{buffer:?}");/// // mark the bytes we worked with as read/// let length = buffer.len();/// stdin.consume(length);/// Marks the given `amount` of additional bytes from the internal buffer as having been read./// Subsequent calls to `read` only return bytes that have not been marked as read./// This is a lower-level method and is meant to be used together with [`fill_buf`],/// which can be used to fill the internal buffer via `Read` methods./// It is a logic error if `amount` exceeds the number of unread bytes in the internal buffer, which is returned by [`fill_buf`]./// Since `consume()` is meant to be used with [`fill_buf`],/// that method's example includes an example of `consume()`./// Checks if there is any data left to be `read`./// This function may fill the buffer to check for data,/// so this function returns `Result<bool>`, not `bool`./// The default implementation calls `fill_buf` and checks that the/// returned slice is empty (which means that there is no data left,/// since EOF is reached)./// Examples/// #![feature(buf_read_has_data_left)]/// while stdin.has_data_left()? {///     stdin.read_line(&mut line)?;///     // work with line///     println!("{line:?}");/// Reads all bytes into `buf` until the delimiter `byte` or EOF is reached./// This function is blocking and should be used carefully: it is possible for/// an attacker to continuously send bytes without ever sending the delimiter/// or EOF./// This function will ignore all instances of [`ErrorKind::Interrupted`] and/// will otherwise return any errors returned by [`fill_buf`]./// If an I/O error is encountered then all bytes read so far will be/// present in `buf` and its length will have been adjusted appropriately./// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In/// this example, we use [`Cursor`] to read all the bytes in a byte slice/// in hyphen delimited segments:/// use std::io::{self, BufRead};/// let mut cursor = io::Cursor::new(b"lorem-ipsum");/// let num_bytes = cursor.read_until(b'-', &mut buf)///     .expect("reading from cursor won't fail");/// Skips all bytes until the delimiter `byte` or EOF is reached./// This function will read (and discard) bytes from the underlying stream until the/// delimiter or EOF is found./// If successful, this function will return the total number of bytes read,/// including the delimiter byte if found./// This is useful for efficiently skipping data such as NUL-terminated strings/// in binary file formats without buffering./// this example, we use [`Cursor`] to read some NUL-terminated information/// about Ferris from a binary string, skipping the fun fact:/// let mut cursor = io::Cursor::new(b"Ferris\0Likes long walks on the beach\0Crustacean\0!");/// // read name/// let mut name = Vec::new();/// let num_bytes = cursor.read_until(b'\0', &mut name)/// assert_eq!(num_bytes, 7);/// assert_eq!(name, b"Ferris\0");/// // skip fun fact/// let num_bytes = cursor.skip_until(b'\0')/// assert_eq!(num_bytes, 30);/// // read animal type/// let mut animal = Vec::new();/// let num_bytes = cursor.read_until(b'\0', &mut animal)/// assert_eq!(num_bytes, 11);/// assert_eq!(animal, b"Crustacean\0");/// // reach EOF/// assert_eq!(num_bytes, 1);/// Reads all bytes until a newline (the `0xA` byte) is reached, and append/// them to the provided `String` buffer./// Previous content of the buffer will be preserved. To avoid appending to/// the buffer, you need to [`clear`] it first./// newline delimiter (the `0xA` byte) or EOF is found. Once found, all bytes/// If this function returns [`Ok(0)`], the stream has reached EOF./// an attacker to continuously send bytes without ever sending a newline/// or EOF. You can use [`take`] to limit the maximum number of bytes read./// [`clear`]: String::clear/// [`take`]: crate::io::Read::take/// [`read_until`]: BufRead::read_until/// this example, we use [`Cursor`] to read all the lines in a byte slice:/// let mut cursor = io::Cursor::new(b"foo\nbar");/// let num_bytes = cursor.read_line(&mut buf)/// Returns an iterator over the contents of this reader split on the byte/// `byte`./// The iterator returned from this function will return instances of/// <code>[io::Result]<[Vec]\<u8>></code>. Each vector returned will *not* have/// the delimiter byte at the end./// This function will yield errors whenever [`read_until`] would have/// also yielded an error./// [io::Result]: self::Result "io::Result"/// this example, we use [`Cursor`] to iterate over all hyphen delimited/// segments in a byte slice/// let cursor = io::Cursor::new(b"lorem-ipsum-dolor");/// let mut split_iter = cursor.split(b'-').map(|l| l.unwrap());/// assert_eq!(split_iter.next(), Some(b"lorem".to_vec()));/// assert_eq!(split_iter.next(), Some(b"ipsum".to_vec()));/// assert_eq!(split_iter.next(), Some(b"dolor".to_vec()));/// assert_eq!(split_iter.next(), None);/// Returns an iterator over the lines of this reader./// The iterator returned from this function will yield instances of/// <code>[io::Result]<[String]></code>. Each string returned will *not* have a newline/// byte (the `0xA` byte) or `CRLF` (`0xD`, `0xA` bytes) at the end./// this example, we use [`Cursor`] to iterate over all the lines in a byte/// let cursor = io::Cursor::new(b"lorem\nipsum\r\ndolor");/// let mut lines_iter = cursor.lines().map(|l| l.unwrap());/// assert_eq!(lines_iter.next(), Some(String::from("lorem")));/// assert_eq!(lines_iter.next(), Some(String::from("ipsum")));/// assert_eq!(lines_iter.next(), Some(String::from("dolor")));/// assert_eq!(lines_iter.next(), None);/// Each line of the iterator has the same error semantics as [`BufRead::read_line`]./// A `BufRead` is a type of `Read`er which has an internal buffer, allowing it/// to perform extra ways of reading./// For example, reading line-by-line is inefficient without using a buffer, so/// if you want to read by line, you'll need `BufRead`, which includes a/// [`read_line`] method as well as a [`lines`] iterator./// for line in stdin.lock().lines() {/// If you have something that implements [`Read`], you can use the [`BufReader`/// type][`BufReader`] to turn it into a `BufRead`./// For example, [`File`] implements [`Read`], but not `BufRead`./// [`BufReader`] to the rescue!/// [`read_line`]: BufRead::read_line/// [`lines`]: BufRead::lines/// use std::io::{self, BufReader};///     let f = BufReader::new(f);///     for line in f.lines() {///         let line = line?;///         println!("{line}");/// Adapter to chain together two readers./// This struct is generally created by calling [`chain`] on a reader./// Please see the documentation of [`chain`] for more details./// [`chain`]: Read::chain///     let mut foo_file = File::open("foo.txt")?;///     let mut bar_file = File::open("bar.txt")?;///     let chain = foo_file.chain(bar_file);///     let (foo_file, bar_file) = chain.into_inner();///     let (foo_file, bar_file) = chain.get_ref();///     let mut chain = foo_file.chain(bar_file);///     let (foo_file, bar_file) = chain.get_mut();// We don't override `read_to_string` here because an UTF-8 sequence could// be split between the two parts of the chain// We don't override `read_line` here because an UTF-8 sequence could be// split between the two parts of the chain/// Reader adapter which limits the bytes read from an underlying reader./// This struct is generally created by calling [`take`] on a reader./// Please see the documentation of [`take`] for more details./// [`take`]: Read::take/// Returns the number of bytes that can be read before this instance will/// return EOF./// this method if the underlying [`Read`] instance reaches EOF.///     let handle = f.take(5);///     println!("limit: {}", handle.limit());/// Returns the number of bytes read so far.///     handle.set_limit(10);///     assert_eq!(handle.limit(), 10);///     let mut handle = file.take(5);///     let file = handle.into_inner();///     let file = handle.get_ref();///     let file = handle.get_mut();/// An iterator over `u8` values of a reader./// This struct is generally created by calling [`bytes`] on a reader./// Please see the documentation of [`bytes`] for more details./// [`bytes`]: Read::bytes// Not `#[inline]`. This function gets inlined even without it, but having// the inline annotation can result in worse code generation. See #116785./// For the specialization of `Bytes::next`.inlined_slow_read_byte/// Reads a single byte in a slow, generic way. This is used by the default/// `spec_read_byte`.// Used by `BufReader::spec_read_byte`, for which the `inline(never)` is// important./// An iterator over the contents of an instance of `BufRead` split on a/// This struct is generally created by calling [`split`] on a `BufRead`./// Please see the documentation of [`split`] for more details./// [`split`]: BufRead::split/// An iterator over the lines of an instance of `BufRead`./// This struct is generally created by calling [`lines`] on a `BufRead`./// Please see the documentation of [`lines`] for more details.//! The `std::io` module contains a number of common things you'll need//! when doing input and output. The most core part of this module is//! the [`Read`] and [`Write`] traits, which provide the//! most general interface for reading and writing input and output.//! ## Read and Write//! Because they are traits, [`Read`] and [`Write`] are implemented by a number//! of other types, and you can implement them for your types too. As such,//! you'll see a few different types of I/O throughout the documentation in//! this module: [`File`]s, [`TcpStream`]s, and sometimes even [`Vec<T>`]s. For//! example, [`Read`] adds a [`read`][`Read::read`] method, which we can use on//! [`File`]s://!     let mut f = File::open("foo.txt")?;//!     let n = f.read(&mut buffer)?;//! [`Read`] and [`Write`] are so important, implementors of the two traits have a//! nickname: readers and writers. So you'll sometimes see 'a reader' instead//! of 'a type that implements the [`Read`] trait'. Much easier!//! ## Seek and BufRead//! Beyond that, there are two important traits that are provided: [`Seek`]//! and [`BufRead`]. Both of these build on top of a reader to control//! how the reading happens. [`Seek`] lets you control where the next byte is//! coming from://! use std::io::SeekFrom;//!     // skip to the last 10 bytes of the file//!     f.seek(SeekFrom::End(-10))?;//! [`BufRead`] uses an internal buffer to provide a number of other ways to read, but//! to show it off, we'll need to talk about buffers in general. Keep reading!//! ## BufReader and BufWriter//! `std::io` comes with two structs, [`BufReader`] and [`BufWriter`], which wrap//! readers and writers. The wrapper uses a buffer, reducing the number of//! calls and providing nicer methods for accessing exactly what you want.//! For example, [`BufReader`] works with the [`BufRead`] trait to add extra//! methods to any reader://!     let f = File::open("foo.txt")?;//!     reader.read_line(&mut buffer)?;//!     println!("{buffer}");//! to [`write`][`Write::write`]://!     let f = File::create("foo.txt")?;//!         // write a byte to the buffer//!         writer.write(&[42])?;//!     } // the buffer is flushed once writer goes out of scope//! ## Standard input and output//! A very common source of input is standard input://!     let mut input = String::new();//!     io::stdin().read_line(&mut input)?;//!     println!("You typed: {}", input.trim());//! Note that you cannot use the [`?` operator] in functions that do not return//! a [`Result<T, E>`][`Result`]. Instead, you can call [`.unwrap()`]//! or `match` on the return value to catch any possible errors://! let mut input = String::new();//! io::stdin().read_line(&mut input).unwrap();//! And a very common source of output is standard output://!     io::stdout().write(&[42])?;//! Of course, using [`io::stdout`] directly is less common than something like//! [`println!`].//! ## Iterator types//! A large number of the structures provided by `std::io` are for various//! ways of iterating over I/O. For example, [`Lines`] is used to split over//! lines://!     let reader = BufReader::new(f);//!     for line in reader.lines() {//!         println!("{}", line?);//! ## Functions//! There are a number of [functions][functions-list] that offer access to various//! features. For example, we can use three of these functions to copy everything//! from standard input to standard output://!     io::copy(&mut io::stdin(), &mut io::stdout())?;//! [functions-list]: #functions-1//! ## io::Result//! Last, but certainly not least, is [`io::Result`]. This type is used//! as the return type of many `std::io` functions that can cause an error, and//! can be returned from your own functions as well. Many of the examples in this//! module use the [`?` operator]://! fn read_input() -> io::Result<()> {//! The return type of `read_input()`, [`io::Result<()>`][`io::Result`], is a very//! common type for functions which don't have a 'real' return value, but do want to//! return errors if they happen. In this case, the only purpose of this function is//! to read the line and print it, so we use `()`.//! ## Platform-specific behavior//! Many I/O functions throughout the standard library are documented to indicate//! what various library or syscalls they are delegated to. This is done to help//! applications both understand what's happening under the hood as well as investigate//! any possibly unclear semantics. Note, however, that this is informative, not a binding//! contract. The implementation of many of these functions are subject to change over//! time and may call fewer or more syscalls/library functions.//! ## I/O Safety//! Rust follows an I/O safety discipline that is comparable to its memory safety discipline. This//! means that file descriptors can be *exclusively owned*. (Here, "file descriptor" is meant to//! subsume similar concepts that exist across a wide range of operating systems even if they might//! use a different name, such as "handle".) An exclusively owned file descriptor is one that no//! other code is allowed to access in any way, but the owner is allowed to access and even close//! it any time. A type that owns its file descriptor should usually close it in its `drop`//! function. Types like [`File`] own their file descriptor. Similarly, file descriptors//! can be *borrowed*, granting the temporary right to perform operations on this file descriptor.//! This indicates that the file descriptor will not be closed for the lifetime of the borrow, but//! it does *not* imply any right to close this file descriptor, since it will likely be owned by//! someone else.//! The platform-specific parts of the Rust standard library expose types that reflect these//! concepts, see [`os::unix`] and [`os::windows`].//! To uphold I/O safety, it is crucial that no code acts on file descriptors it does not own or//! borrow, and no code closes file descriptors it does not own. In other words, a safe function//! that takes a regular integer, treats it as a file descriptor, and acts on it, is *unsound*.//! Not upholding I/O safety and acting on a file descriptor without proof of ownership can lead to//! misbehavior and even Undefined Behavior in code that relies on ownership of its file//! descriptors: a closed file descriptor could be re-allocated, so the original owner of that file//! descriptor is now working on the wrong file. Some code might even rely on fully encapsulating//! its file descriptors with no operations being performed by any other part of the program.//! Note that exclusive ownership of a file descriptor does *not* imply exclusive ownership of the//! underlying kernel object that the file descriptor references (also called "open file description" on//! some operating systems). File descriptors basically work like [`Arc`]: when you receive an owned//! file descriptor, you cannot know whether there are any other file descriptors that reference the//! same kernel object. However, when you create a new kernel object, you know that you are holding//! the only reference to it. Just be careful not to lend it to anyone, since they can obtain a//! clone and then you can no longer know what the reference count is! In that sense, [`OwnedFd`] is//! like `Arc` and [`BorrowedFd<'a>`] is like `&'a Arc` (and similar for the Windows types). In//! particular, given a `BorrowedFd<'a>`, you are not allowed to close the file descriptor -- just//! like how, given a `&'a Arc`, you are not allowed to decrement the reference count and//! potentially free the underlying object. There is no equivalent to `Box` for file descriptors in//! the standard library (that would be a type that guarantees that the reference count is `1`),//! however, it would be possible for a crate to define a type with those semantics.//! [`io::stdout`]: stdout//! [`io::Result`]: self::Result//! [`?` operator]: ../../book/appendix-02-operators.html//! [`Result`]: crate::result::Result//! [`.unwrap()`]: crate::result::Result::unwrap//! [`os::unix`]: ../os/unix/io/index.html//! [`os::windows`]: ../os/windows/io/index.html//! [`OwnedFd`]: ../os/fd/struct.OwnedFd.html//! [`BorrowedFd<'a>`]: ../os/fd/struct.BorrowedFd.html//! [`Arc`]: crate::sync::Arcpipe_creation_clone_and_rwanonymous_pipeAnonPipepipe_inner/// Creates an anonymous pipe./// A pipe is a one-way data channel provided by the OS, which works across processes. A pipe is/// typically used to communicate between two or more separate processes, as there are better,/// faster ways to communicate within a single process./// * A read on a [`PipeReader`] blocks until the pipe is non-empty./// * A write on a [`PipeWriter`] blocks when the pipe is full./// * When all copies of a [`PipeWriter`] are closed, a read on the corresponding [`PipeReader`]///   returns EOF./// * [`PipeWriter`] can be shared, and multiple processes or threads can write to it at once, but///   writes (above a target-specific threshold) may have their data interleaved./// * [`PipeReader`] can be shared, and multiple processes or threads can read it at once. Any///   given byte will only get consumed by one reader. There are no guarantees about data///   interleaving./// * Portable applications cannot assume any atomicity of messages larger than a single byte./// This function currently corresponds to the `pipe` function on Unix and the/// `CreatePipe` function on Windows./// # Capacity/// Pipe capacity is platform dependent. To quote the Linux [man page]:/// > Different implementations have different limits for the pipe capacity. Applications should/// > not rely on a particular capacity: an application should be designed so that a reading process/// > consumes data as soon as it is available, so that a writing process does not remain blocked./// # #[cfg(miri)] fn main() {}/// use std::io::{Read, Write, pipe};/// let (ping_reader, mut ping_writer) = pipe()?;/// let (mut pong_reader, pong_writer) = pipe()?;/// // Spawn a child process that echoes its input./// let mut echo_command = Command::new("cat");/// echo_command.stdin(ping_reader);/// echo_command.stdout(pong_writer);/// let mut echo_child = echo_command.spawn()?;/// // Send input to the child process. Note that because we're writing all the input before we/// // read any output, this could deadlock if the child's input and output pipe buffers both/// // filled up. Those buffers are usually at least a few KB, so "hello" is fine, but for longer/// // inputs we'd need to read and write at the same time, e.g. using threads./// ping_writer.write_all(b"hello")?;/// // `cat` exits when it reads EOF from stdin, but that can't happen while any ping writer/// // remains open. We need to drop our ping writer, or read_to_string will deadlock below./// drop(ping_writer);/// // The pong reader can't report EOF while any pong writer remains open. Our Command object is/// // holding a pong writer, and again read_to_string will deadlock if we don't drop it./// drop(echo_command);/// // Block until `cat` closes its stdout (a pong writer)./// pong_reader.read_to_string(&mut buf)?;/// assert_eq!(&buf, "hello");/// // At this point we know `cat` has exited, but we still need to wait to clean up the "zombie"./// echo_child.wait()?;/// [man page]: https://man7.org/linux/man-pages/man7/pipe.7.html/// Read end of an anonymous pipe./// Write end of an anonymous pipe./// Creates a new [`PipeReader`] instance that shares the same underlying file description./// use std::io::{pipe, Write};/// const NUM_SLOT: u8 = 2;/// const NUM_PROC: u8 = 5;/// const OUTPUT: &str = "work.txt";/// let mut jobs = vec![];/// let (reader, mut writer) = pipe()?;/// // Write NUM_SLOT characters the pipe./// writer.write_all(&[b'|'; NUM_SLOT as usize])?;/// // Spawn several processes that read a character from the pipe, do some work, then/// // write back to the pipe. When the pipe is empty, the processes block, so only/// // NUM_SLOT processes can be working at any given time./// for _ in 0..NUM_PROC {///     jobs.push(///         Command::new("bash")///             .args(["-c",///                 &format!(///                      "read -n 1\n\///                       echo -n 'x' >> '{OUTPUT}'\n\///                       echo -n '|'",///                 ),///             ])///             .stdin(reader.try_clone()?)///             .stdout(writer.try_clone()?)///             .spawn()?,/// // Wait for all jobs to finish./// for mut job in jobs {///     job.wait()?;/// // Check our work and clean up./// let xs = fs::read_to_string(OUTPUT)?;/// fs::remove_file(OUTPUT)?;/// assert_eq!(xs, "x".repeat(NUM_PROC.into()));/// Creates a new [`PipeWriter`] instance that shares the same underlying file description./// use std::io::{pipe, Read};/// let (mut reader, writer) = pipe()?;/// // Spawn a process that writes to stdout and stderr./// let mut peer = Command::new("bash")///         "-c",///         "echo -n foo\n\///          echo -n bar >&2"///     .stdout(writer.try_clone()?)///     .stderr(writer)/// // Read and check the result./// let mut msg = String::new();/// reader.read_to_string(&mut msg)?;/// assert_eq!(&msg, "foobar");/// peer.wait()?;//! The I/O Prelude.//! The purpose of this module is to alleviate imports of many common I/O traits//! by adding a glob import to the top of I/O heavy modules://! # #![allow(unused_imports)]stdout_unwind_safestdoutlock_unwind_safestderr_unwind_safestderrlock_unwind_safeassert_unwind_safepanic_doesnt_poisontest_lock_stderrtest_lock_stdintest_lock_stdout// Helper trait to make lock testing function generic.StdioOwnedLocktest_lock// Tests locking on stdio handles by starting two threads and checking that// they block each other appropriately.ReentrantLockReentrantLockGuardLocalStreamr" Used by the test crate to capture the output of the print macros and panics."OUTPUT_CAPTUREOUTPUT_CAPTURE_USED/// Flag to indicate OUTPUT_CAPTURE is used./// If it is None and was never set on any thread, this flag is set to false,/// and OUTPUT_CAPTURE can be safely ignored on all threads, saving some time/// and memory registering an unused thread local./// Note about memory ordering: This contains information about whether a/// thread local variable might be in use. Although this is a global flag, the/// memory ordering between threads does not matter: we only want this flag to/// have a consistent order between set_output_capture and print_to *within/// the same thread*. Within the same thread, things always have a perfectly/// consistent order. So Ordering::Relaxed is fine.StdinRaw/// A handle to a raw instance of the standard input stream of this process./// This handle is not synchronized or buffered in any fashion. Constructed via/// the `std::io::stdio::stdin_raw` function.StdoutRaw/// A handle to a raw instance of the standard output stream of this process./// the `std::io::stdio::stdout_raw` function.StderrRaw/// the `std::io::stdio::stderr_raw` function.stdin_raw/// Constructs a new raw handle to the standard input of this process./// The returned handle does not interact with any other handles created nor/// handles returned by `std::io::stdin`. Data buffered by the `std::io::stdin`/// handles is **not** available to raw handles returned from this function./// The returned handle has no external synchronization or buffering.stdout_raw/// Constructs a new raw handle to the standard output stream of this process./// handles returned by `std::io::stdout`. Note that data is buffered by the/// `std::io::stdout` handles so writes which happen via this raw handle may/// appear before previous writes./// The returned handle has no external synchronization or buffering layered on/// top.stderr_raw/// Constructs a new raw handle to the standard error stream of this process./// handles returned by `std::io::stderr`.handle_ebadf/// A handle to the standard input stream of a process./// Each handle is a shared reference to a global buffer of input data to this/// process. A handle can be `lock`'d to gain full access to [`BufRead`] methods/// (e.g., `.lines()`). Reads to this handle are otherwise locked with respect/// to other reads./// This handle implements the `Read` trait, but beware that concurrent reads/// of `Stdin` must be executed with care./// Created by the [`io::stdin`] method./// [`io::stdin`]: stdin/// ### Note: Windows Portability Considerations/// When operating in a console, the Windows implementation of this stream does not support/// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return/// In a process with a detached console, such as one using/// `#![windows_subsystem = "windows"]`, or in a child process spawned from such a process,/// the contained handle will be null. In such cases, the standard library's `Read` and/// `Write` will do nothing and silently succeed. All other I/O operations, via the/// standard library or via raw Windows API calls, will fail.///     let stdin = io::stdin(); // We get `Stdin` here.///     stdin.read_line(&mut buffer)?;"if unused stdin will immediately unlock"/// A locked reference to the [`Stdin`] handle./// This handle implements both the [`Read`] and [`BufRead`] traits, and/// is constructed via the [`Stdin::lock`] method.///         let mut handle = stdin.lock(); // We get `StdinLock` here.///         handle.read_line(&mut buffer)?;///     } // `StdinLock` is dropped here./// Constructs a new handle to the standard input of the current process./// Each handle returned is a reference to a shared global buffer whose access/// is synchronized via a mutex. If you need more explicit control over/// locking, see the [`Stdin::lock`] method./// Using implicit synchronization:/// Using explicit synchronization:///     let stdin = io::stdin();///     let mut handle = stdin.lock();///     handle.read_line(&mut buffer)?;/// Locks this handle to the standard input stream, returning a readable/// guard./// The lock is released when the returned lock goes out of scope. The/// returned guard also implements the [`Read`] and [`BufRead`] traits for/// accessing the underlying data./// Locks this handle and reads a line of input, appending it to the specified buffer./// For detailed semantics of this method, see the documentation on/// [`BufRead::read_line`]. In particular:/// * Previous content of the buffer will be preserved. To avoid appending///   to the buffer, you need to [`clear`] it first./// * The trailing newline character, if any, is included in the buffer./// let mut input = String::new();/// match io::stdin().read_line(&mut input) {///     Ok(n) => {///         println!("{n} bytes read");///         println!("{input}");///     Err(error) => println!("error: {error}"),/// You can run the example one of two ways:/// - Pipe some text to it, e.g., `printf foo | path/to/executable`/// - Give it text interactively by running the executable directly,///   in which case it will wait for the Enter key to be pressed before///   continuing/// Consumes this handle and returns an iterator over input lines./// [`BufRead::lines`]./// let lines = io::stdin().lines();/// for line in lines {///     println!("got a line: {}", line.unwrap());as_mut_buf// only used by platform-dependent io::copy specializations, i.e. unused on some platforms// FIXME: this should be LineWriter or BufWriter depending on the state of//        stdout (tty or not). Note that if this is not line buffered it//        should also flush-on-panic or some form of flush-on-abort./// A handle to the global standard output stream of the current process./// Each handle shares a global buffer of data to be written to the standard/// output stream. Access is also synchronized via a lock and explicit control/// over locking is available via the [`lock`] method./// By default, the handle is line-buffered when connected to a terminal, meaning/// it flushes automatically when a newline (`\n`) is encountered. For immediate/// output, you can manually call the [`flush`] method. When the handle goes out/// of scope, the buffer is automatically flushed./// Created by the [`io::stdout`] method./// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return/// [`lock`]: Stdout::lock/// [`io::stdout`]: stdout"if unused stdout will immediately unlock"/// A locked reference to the [`Stdout`] handle./// This handle implements the [`Write`] trait, and is constructed via/// the [`Stdout::lock`] method. See its documentation for more.STDOUT/// Constructs a new handle to the standard output of the current process./// locking, see the [`Stdout::lock`] method.///     io::stdout().write_all(b"hello world")?;///     let stdout = io::stdout();///     let mut handle = stdout.lock();///     handle.write_all(b"hello world")?;/// Ensuring output is flushed immediately:///     let mut stdout = io::stdout();///     stdout.write_all(b"hello, ")?;///     stdout.flush()?;                // Manual flush///     stdout.write_all(b"world!\n")?; // Automatically flushed// Flush the data and disable buffering during shutdown// by replacing the line writer by one with zero// buffering capacity./// Locks this handle to the standard output stream, returning a writable/// returned guard also implements the `Write` trait for writing data.///     let mut stdout = io::stdout().lock();///     stdout.write_all(b"hello world")?;/// A handle to the standard error stream of a process./// For more information, see the [`io::stderr`] method./// [`io::stderr`]: stderr"if unused stderr will immediately unlock"/// A locked reference to the [`Stderr`] handle./// This handle implements the [`Write`] trait and is constructed via/// the [`Stderr::lock`] method. See its documentation for more./// Constructs a new handle to the standard error of the current process./// This handle is not buffered.///     io::stderr().write_all(b"hello world")?;///     let stderr = io::stderr();///     let mut handle = stderr.lock();/// Locks this handle to the standard error stream, returning a writable/// returned guard also implements the [`Write`] trait for writing data./// fn foo() -> io::Result<()> {/// Sets the thread-local output capture buffer and returns the old one./// Tries to set the thread-local output capture buffer and returns the old one./// This may fail once thread-local destructors are called. It's used in panic/// handling instead of `set_output_capture`./// Writes `args` to the capture buffer if enabled and possible, or `global_s`/// otherwise. `label` identifies the stream in a panic message./// This function is used to print error messages, so it takes extra/// care to avoid causing a panic when `OUTPUT_CAPTURE` is unusable./// For instance, if the TLS key for output capturing is already destroyed, or/// if the local stream is in use by another thread, it will just fall back to/// the global stream./// However, if the actual I/O causes an error, this function does panic./// Writing to non-blocking stdout/stderr can cause an error, which will lead/// this function to panic.print_to_buffer_if_capture_used/// Used by impl Termination for Result to print error after `main` or a test/// has returned. Should avoid panicking, although we can't help it if one of/// the Display impls inside args decides to./// An example of a type for which `IsTerminal` is implemented is [`Stdin`]:/// use std::io::{self, IsTerminal, Write};///     // Indicate that the user is prompted for input, if this is a terminal.///     if stdin.is_terminal() {///         print!("> ");///         io::stdout().flush()?;///     let mut name = String::new();///     let _ = stdin.read_line(&mut name)?;///     println!("Hello {}", name.trim_end());/// The example can be run in two ways:/// - If you run this example by piping some text to it, e.g. `echo "foo" | path/to/executable`///   it will print: `Hello foo`./// - If you instead run the example interactively by running `path/to/executable` directly, it will///   prompt for input./// [`Stdin`]: crate::io::Stdinbuf_read_has_data_leftread_exact_sliceborrowed_cursor_advance_overflowtake_eofBr1Br2cmp_bufreadchain_bufreadchain_splitted_charbufreader_size_hintempty_size_hintslice_size_hinttake_size_hintchain_empty_size_hintchain_size_hintchain_zero_length_read_is_not_eofbench_read_to_endseek_lenseek_positiontake_seektake_seek_errorExampleHugeRangeOfZeroestake_seek_big_offsetsExampleSliceReader// A simple example reader which uses the default implementation of// read_to_end.test_read_to_end_capacityio_slice_mut_advance_slicesio_slice_mut_advance_slices_empty_sliceio_slice_mut_advance_slices_beyond_total_lengthio_slice_advance_slicesio_slice_advance_slices_empty_sliceio_slice_advance_slices_beyond_total_lengthio_slice_as_sliceio_slice_into_slice/// Creates a new writer that reads from at most `n_bufs` and reads"number of read bytes exceeds limit"test_take_wrong_length// Issue 94981slice_read_exact_eofcursor_read_exact_eofbench_take_readbench_take_read_bufread_buf_broken_read// Issue #120603read_buf_full_readDataAndErrorReaderread_buf_data_and_error_takeread_buf_data_and_error_bufread_buf_data_and_error_read_to_endread_to_end_errortry_oom_errorErrorDisplayPanicDisplaytest_sinkingsink_sinksempty_readsempty_seeksempty_sinksrepeat_repeatstake_some_bytesconst_utils/// `Empty` ignores any data written via [`Write`], and will always be empty/// (returning zero bytes) when read via [`Read`]./// This struct is generally created by calling [`empty()`]. Please/// see the documentation of [`empty()`] for more details./// Creates a value that is always at EOF for reads, and ignores all data written./// All calls to [`write`] on the returned instance will return [`Ok(buf.len())`]/// All calls to [`read`] from the returned reader will return [`Ok(0)`]./// [`Ok(buf.len())`]: Ok/// let num_bytes = io::empty().write(&buffer).unwrap();/// io::empty().read_to_string(&mut buffer).unwrap();/// A reader which yields one byte over and over and over and over and over and.../// This struct is generally created by calling [`repeat()`]. Please/// see the documentation of [`repeat()`] for more details./// io::repeat(0b101).read_exact(&mut buffer).unwrap();/// This function is not supported by `io::Repeat`, because there's no end of its data/// A writer which will move data into the void./// This struct is generally created by calling [`sink()`]. Please/// see the documentation of [`sink()`] for more details./// let num_bytes = io::sink().write(&buffer).unwrap();as_keyword/// Cast between types, rename an import, or qualify paths to associated items./// # Type casting/// `as` is most commonly used to turn primitive types into other primitive types, but it has other/// uses that include turning pointers into addresses, addresses into pointers, and pointers into/// other pointers./// let thing1: u8 = 89.0 as u8;/// assert_eq!('B' as u32, 66);/// assert_eq!(thing1 as char, 'Y');/// let thing2: f32 = thing1 as f32 + 10.5;/// assert_eq!(true as u8 + thing2 as u8, 100);/// In general, any cast that can be performed via ascribing the type can also be done using `as`,/// so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (note: `let x: u32/// = 123` would be best in that situation). The same is not true in the other direction, however;/// explicitly using `as` allows a few more coercions that aren't allowed implicitly, such as/// changing the type of a raw pointer or turning closures into raw pointers./// `as` can be seen as the primitive for `From` and `Into`: `as` only works  with primitives/// (`u8`, `bool`, `str`, pointers, ...) whereas `From` and `Into`  also works with types like/// `String` or `Vec`./// `as` can also be used with the `_` placeholder when the destination type can be inferred. Note/// that this can cause inference breakage and usually such code should use an explicit type for/// both clarity and stability. This is most useful when converting pointers using `as *const _` or/// `as *mut _` though the [`cast`][const-cast] method is recommended over `as *const _` and it is/// [the same][mut-cast] for `as *mut _`: those methods make the intent clearer./// # Renaming imports/// `as` is also used to rename imports in [`use`] and [`extern crate`][`crate`] statements:/// use std::{mem as memory, net as network};/// // Now you can use the names `memory` and `network` to refer to `std::mem` and `std::net`./// # Qualifying paths/// You'll also find with `From` and `Into`, and indeed all traits, that `as` is used for the/// _fully qualified path_, a means of disambiguating associated items, i.e. functions,/// constants, and types.  For example, if you have a type which implements two traits with identical/// method names (e.g. `Into::<u32>::into` and `Into::<u64>::into`), you can clarify which method/// you'll use with `<MyThing as Into<u32>>::into(my_thing)`[^as-use-from].  This is quite verbose,/// but fortunately, Rust's type inference usually saves you from needing this, although it is/// occasionally necessary, especially with methods that return a generic type like `Into::into` or/// methods that don't take `self`.  It's more common to use in macros where it can provide necessary/// hygiene./// [^as-use-from]: You should probably never use this syntax with `Into` and instead write/// `T::from(my_thing)`.  It just happens that there aren't any great examples for this syntax in/// the standard library.  Also, at time of writing, the compiler tends to suggest fully-qualified/// paths to fix ambiguous `Into::into` calls, so the example should hopefully be familiar./// # Further reading/// For more information on what `as` is capable of, see the Reference on [type cast expressions],/// [renaming imported entities], [renaming `extern` crates]/// and [qualified paths]./// [type cast expressions]: ../reference/expressions/operator-expr.html#type-cast-expressions/// [renaming imported entities]: https://doc.rust-lang.org/reference/items/use-declarations.html#as-renames/// [renaming `extern` crates]: https://doc.rust-lang.org/reference/items/extern-crates.html#r-items.extern-crate.as/// [qualified paths]: ../reference/paths.html#qualified-paths/// [`crate`]: keyword.crate.html/// [`use`]: keyword.use.html/// [const-cast]: pointer::cast/// [mut-cast]: primitive.pointer.html#method.cast-1break_keyword/// Exit early from a loop or labelled block./// When `break` is encountered, execution of the associated loop body is/// immediately terminated./// let mut last = 0;/// for x in 1..100 {///     if x > 12 {///     last = x;/// assert_eq!(last, 12);/// println!("{last}");/// A break expression is normally associated with the innermost loop enclosing the/// `break` but a label can be used to specify which enclosing loop is affected./// 'outer: for i in 1..=5 {///     println!("outer iteration (i): {i}");///     '_inner: for j in 1..=200 {///         println!("    inner iteration (j): {j}");///         if j >= 3 {///             // breaks from inner loop, lets outer loop continue.///         if i >= 2 {///             // breaks from outer loop, and directly to "Bye".///             break 'outer;/// println!("Bye.");/// When associated with `loop`, a break expression may be used to return a value from that loop./// This is only valid with `loop` and not with any other type of loop./// If no value is specified for `break;` it returns `()`./// Every `break` within a loop must return the same type./// let (mut a, mut b) = (1, 1);/// let result = loop {///     if b > 10 {///         break b;///     let c = a + b;///     a = b;///     b = c;/// // first number in Fibonacci sequence over 10:/// assert_eq!(result, 13);/// println!("{result}");/// It is also possible to exit from any *labelled* block returning the value early./// let inputs = vec!["Cow", "Cat", "Dog", "Snake", "Cod"];///     let result = 'filter: {///         if input.len() > 3 {///             break 'filter Err("Too long");///         if !input.contains("C") {///             break 'filter Err("No Cs");///         Ok(input.to_uppercase())///     results.push(result);/// // [Ok("COW"), Ok("CAT"), Err("No Cs"), Err("Too long"), Ok("COD")]/// println!("{:?}", results)/// For more details consult the [Reference on "break expression"] and the [Reference on "break and/// loop values"]./// [Reference on "break expression"]: ../reference/expressions/loop-expr.html#break-expressions/// [Reference on "break and loop values"]:/// ../reference/expressions/loop-expr.html#break-and-loop-valuesconst_keyword/// Compile-time constants, compile-time blocks, compile-time evaluable functions, and raw pointers./// ## Compile-time constants/// Sometimes a certain value is used many times throughout a program, and it can become/// inconvenient to copy it over and over. What's more, it's not always possible or desirable to/// make it a variable that gets carried around to each function that needs it. In these cases, the/// `const` keyword provides a convenient alternative to code duplication:/// const THING: u32 = 0xABAD1DEA;/// let foo = 123 + THING;/// Constants must be explicitly typed; unlike with `let`, you can't ignore their type and let the/// compiler figure it out. Any constant value can be defined in a `const`, which in practice happens/// to be most things that would be reasonable to have in a constant (barring `const fn`s). For/// example, you can't have a [`File`] as a `const`./// The only lifetime allowed in a constant is `'static`, which is the lifetime that encompasses/// all others in a Rust program. For example, if you wanted to define a constant string, it would/// look like this:/// const WORDS: &'static str = "hello rust!";/// Thanks to static lifetime elision, you usually don't have to explicitly use `'static`:/// const WORDS: &str = "hello convenience!";/// `const` items look remarkably similar to `static` items, which introduces some confusion as/// to which one should be used at which times. To put it simply, constants are inlined wherever/// they're used, making using them identical to simply replacing the name of the `const` with its/// value. Static variables, on the other hand, point to a single location in memory, which all/// accesses share. This means that, unlike with constants, they can't have destructors, and act as/// a single value across the entire codebase./// Constants, like statics, should always be in `SCREAMING_SNAKE_CASE`./// For more detail on `const`, see the [Rust Book] or the [Reference]./// ## Compile-time blocks/// The `const` keyword can also be used to define a block of code that is evaluated at compile time./// This is useful for ensuring certain computations are completed before optimizations happen, as well as/// before runtime. For more details, see the [Reference][const-blocks]./// ## Compile-time evaluable functions/// The other main use of the `const` keyword is in `const fn`. This marks a function as being/// callable in the body of a `const` or `static` item and in array initializers (commonly called/// "const contexts"). `const fn` are restricted in the set of operations they can perform, to/// ensure that they can be evaluated at compile-time. See the [Reference][const-eval] for more/// detail./// Turning a `fn` into a `const fn` has no effect on run-time uses of that function./// ## Other uses of `const`/// The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const/// T` and `*mut T`. More about `const` as used in raw pointers can be read at the Rust docs for the [pointer primitive]./// [pointer primitive]: pointer/// [Rust Book]: ../book/ch03-01-variables-and-mutability.html#constants/// [Reference]: ../reference/items/constant-items.html/// [const-blocks]: ../reference/expressions/block-expr.html#const-blocks/// [const-eval]: ../reference/const_eval.htmlcontinue_keyword/// Skip to the next iteration of a loop./// When `continue` is encountered, the current iteration is terminated, returning control to the/// loop head, typically continuing with the next iteration./// // Printing odd numbers by skipping even ones/// for number in 1..=10 {///     if number % 2 == 0 {///     println!("{number}");/// Like `break`, `continue` is normally associated with the innermost enclosing loop, but labels/// may be used to specify the affected loop./// // Print Odd numbers under 30 with unit <= 5/// 'tens: for ten in 0..3 {///     '_units: for unit in 0..=9 {///         if unit % 2 == 0 {///             continue;///         if unit > 5 {///             continue 'tens;///         println!("{}", ten * 10 + unit);/// See [continue expressions] from the reference for more details./// [continue expressions]: ../reference/expressions/loop-expr.html#continue-expressionscrate_keyword/// A Rust binary or library./// The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are/// used to specify a dependency on a crate external to the one it's declared in. Crates are the/// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can/// be read about crates in the [Reference]./// ```rust ignore/// extern crate rand;/// extern crate my_crate as thing;/// extern crate std; // implicitly added to the root of every Rust project/// The `as` keyword can be used to change what the crate is referred to as in your project. If a/// crate name includes a dash, it is implicitly imported with the dashes replaced by underscores./// `crate` can also be used as in conjunction with `pub` to signify that the item it's attached to/// is public only to other members of the same crate it's in./// pub(crate) use std::io::Error as IoError;/// pub(crate) enum CoolMarkerType { }/// pub struct PublicThing {///     pub(crate) semi_secret_thing: bool,/// `crate` is also used to represent the absolute path of a module, where `crate` refers to the/// root of the current crate. For instance, `crate::foo::bar` refers to the name `bar` inside the/// module `foo`, from anywhere else in the same crate./// [Reference]: ../reference/items/extern-crates.htmlelse_keyword/// What expression to evaluate when an [`if`] condition evaluates to [`false`]./// `else` expressions are optional. When no else expressions are supplied it is assumed to evaluate/// to the unit type `()`./// The type that the `else` blocks evaluate to must be compatible with the type that the `if` block/// evaluates to./// As can be seen below, `else` must be followed by either: `if`, `if let`, or a block `{}` and it/// will return the value of that expression./// let result = if true == false {///     "oh no"/// } else if "something" == "other thing" {///     "oh dear"/// } else if let Some(200) = "blarg".parse::<i32>().ok() {///     "uh oh"///     println!("Sneaky side effect.");///     "phew, nothing's broken"/// Here's another example but here we do not try and return an expression:/// if true == false {///     println!("oh no");///     println!("oh dear");///     println!("uh oh");///     println!("phew, nothing's broken");/// The above is _still_ an expression but it will always evaluate to `()`./// There is possibly no limit to the number of `else` blocks that could follow an `if` expression/// however if you have several then a [`match`] expression might be preferable./// Read more about control flow in the [Rust Book]./// [Rust Book]: ../book/ch03-05-control-flow.html#handling-multiple-conditions-with-else-if/// [`match`]: keyword.match.html/// [`false`]: keyword.false.html/// [`if`]: keyword.if.htmlenum_keyword/// A type that can be any one of several variants./// Enums in Rust are similar to those of other compiled languages like C, but have important/// differences that make them considerably more powerful. What Rust calls enums are more commonly/// known as [Algebraic Data Types][ADT] if you're coming from a functional programming background./// The important detail is that each enum variant can have data to go along with it./// # struct Coord;/// enum SimpleEnum {///     FirstVariant,///     SecondVariant,///     ThirdVariant,/// enum Location {///     Unknown,///     Anonymous,///     Known(Coord),/// enum ComplexEnum {///     Nothing,///     Something(u32),///     LotsOfThings {///         usual_struct_stuff: bool,///         blah: String,/// enum EmptyEnum { }/// The first enum shown is the usual kind of enum you'd find in a C-style language. The second/// shows off a hypothetical example of something storing location data, with `Coord` being any/// other type that's needed, for example a struct. The third example demonstrates the kind of/// data a variant can store, ranging from nothing, to a tuple, to an anonymous struct./// Instantiating enum variants involves explicitly using the enum's name as its namespace,/// followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above./// When data follows along with a variant, such as with rust's built-in [`Option`] type, the data/// is added as the type describes, for example `Option::Some(123)`. The same follows with/// struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff:/// true, blah: "hello!".to_string(), }`. Empty Enums are similar to [`!`] in that they cannot be/// instantiated at all, and are used mainly to mess with the type system in interesting ways./// For more information, take a look at the [Rust Book] or the [Reference]/// [ADT]: https://en.wikipedia.org/wiki/Algebraic_data_type/// [Rust Book]: ../book/ch06-01-defining-an-enum.html/// [Reference]: ../reference/items/enumerations.htmlextern_keyword/// Link to or import external code./// The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`]/// keyword to make your Rust code aware of other Rust crates in your project, i.e., `extern crate/// lazy_static;`. The other use is in foreign function interfaces (FFI)./// `extern` is used in two different contexts within FFI. The first is in the form of external/// blocks, for declaring function interfaces that Rust code can call foreign code by. This use/// of `extern` is unsafe, since we are asserting to the compiler that all function declarations/// are correct. If they are not, using these items may lead to undefined behavior./// // SAFETY: The function declarations given below are in/// // line with the header files of `my_c_library`./// #[link(name = "my_c_library")]/// unsafe extern "C" {///     fn my_c_function(x: i32) -> bool;/// This code would attempt to link with `libmy_c_library.so` on unix-like systems and/// `my_c_library.dll` on Windows at runtime, and panic if it can't find something to link to. Rust/// code could then use `my_c_function` as if it were any other unsafe Rust function. Working with/// non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs./// The mirror use case of FFI is also done via the `extern` keyword:/// #[unsafe(no_mangle)]/// pub extern "C" fn callable_from_c(x: i32) -> bool {///     x % 3 == 0/// If compiled as a dylib, the resulting .so could then be linked to from a C library, and the/// function could be used as if it was from any other library./// For more information on FFI, check the [Rust book] or the [Reference]./// [Rust book]:/// ../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code/// [Reference]: ../reference/items/external-blocks.htmlfalse_keyword/// A value of type [`bool`] representing logical **false**./// `false` is the logical opposite of [`true`]./// See the documentation for [`true`] for more information./// [`true`]: keyword.true.htmlfn_keyword/// A function or function pointer./// Functions are the primary way code is executed within Rust. Function blocks, usually just/// called functions, can be defined in a variety of different places and be assigned many/// different attributes and modifiers./// Standalone functions that just sit within a module not attached to anything else are common,/// but most functions will end up being inside [`impl`] blocks, either on another type itself, or/// as a trait impl for that type./// fn standalone_function() {///     // code/// pub fn public_thing(argument: bool) -> String {///     # "".to_string()/// impl Thing {///             foo: 42,/// In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`,/// functions can also declare a list of type parameters along with trait bounds that they fall/// fn generic_function<T: Clone>(x: T) -> (T, T, T) {///     (x.clone(), x.clone(), x.clone())/// fn generic_where<T>(x: T) -> T///     where T: std::ops::Add<Output = T> + Copy///     x + x + x/// Declaring trait bounds in the angle brackets is functionally identical to using a `where`/// clause. It's up to the programmer to decide which works better in each situation, but `where`/// tends to be better when things get longer than one line./// Along with being made public via `pub`, `fn` can also have an [`extern`] added for use in/// For more information on the various types of functions and how they're used, consult the [Rust/// book] or the [Reference]./// [`impl`]: keyword.impl.html/// [`extern`]: keyword.extern.html/// [Rust book]: ../book/ch03-03-how-functions-work.html/// [Reference]: ../reference/items/functions.htmlfor_keyword/// Iteration with [`in`], trait implementation with [`impl`], or [higher-ranked trait bounds]/// (`for<'a>`)./// The `for` keyword is used in many syntactic locations:/// * `for` is used in for-in-loops (see below)./// * `for` is used when implementing traits as in `impl Trait for Type` (see [`impl`] for more info///   on that)./// * `for` is also used for [higher-ranked trait bounds] as in `for<'a> &'a T: PartialEq<i32>`./// for-in-loops, or to be more precise, iterator loops, are a simple syntactic sugar over a common/// practice within Rust, which is to loop over anything that implements [`IntoIterator`] until the/// iterator returned by `.into_iter()` returns `None` (or the loop body uses `break`)./// for i in 0..5 {///     println!("{}", i * 2);/// for i in std::iter::repeat(5) {///     println!("turns out {i} never stops being 5");///     break; // would loop forever otherwise/// 'outer: for x in 5..50 {///     for y in 0..10 {///         if x == y {/// As shown in the example above, `for` loops (along with all other loops) can be tagged, using/// similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the/// same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely/// not a goto./// A `for` loop expands as shown:/// # fn code() { }/// # let iterator = 0..2;/// for loop_variable in iterator {///     code()///     let result = match IntoIterator::into_iter(iterator) {///         mut iter => loop {///             match iter.next() {///                 None => break,///                 Some(loop_variable) => { code(); },/// More details on the functionality shown can be seen at the [`IntoIterator`] docs./// For more information on for-loops, see the [Rust book] or the [Reference]./// See also, [`loop`], [`while`]./// [`in`]: keyword.in.html/// [`loop`]: keyword.loop.html/// [`while`]: keyword.while.html/// [higher-ranked trait bounds]: ../reference/trait-bounds.html#higher-ranked-trait-bounds/// ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for/// [Reference]: ../reference/expressions/loop-expr.html#iterator-loopsif_keyword/// Evaluate a block if a condition holds./// `if` is a familiar construct to most programmers, and is the main way you'll often do logic in/// your code. However, unlike in most languages, `if` blocks can also act as expressions./// # let rude = true;/// if 1 == 2 {///     println!("whoops, mathematics broke");///     println!("everything's fine!");/// let greeting = if rude {///     "sup nerd."///     "hello, friend!"/// if let Ok(x) = "123".parse::<i32>() {///     println!("{} double that and you get {}!", greeting, x * 2);/// Shown above are the three typical forms an `if` block comes in. First is the usual kind of/// thing you'd see in many languages, with an optional `else` block. Second uses `if` as an/// expression, which is only possible if all branches return the same type. An `if` expression can/// be used everywhere you'd expect. The third kind of `if` block is an `if let` block, which/// behaves similarly to using a `match` expression:/// if let Some(x) = Some(123) {///     # let _ = x;///     // something else/// match Some(123) {///     Some(x) => {///         // code///         # let _ = x;///         // something else/// Each kind of `if` expression can be mixed and matched as needed./// The `if` keyword is used in one other place in Rust, namely as a part of pattern matching/// itself, allowing patterns such as `Some(x) if x > 200` to be used./// For more information on `if` expressions, see the [Rust book] or the [Reference]./// [Rust book]: ../book/ch03-05-control-flow.html#if-expressions/// [Reference]: ../reference/expressions/if-expr.htmlimpl_keyword/// Implementations of functionality for a type, or a type implementing some functionality./// There are two uses of the keyword `impl`:///  * An `impl` block is an item that is used to implement some functionality for a type.///  * An `impl Trait` in a type-position can be used to designate a type that implements a trait called `Trait`./// # Implementing Functionality for a Type/// The `impl` keyword is primarily used to define implementations on types. Inherent/// implementations are standalone, while trait implementations are used to implement traits for/// types, or other traits./// An implementation consists of definitions of functions and consts. A function defined in an/// `impl` block can be standalone, meaning it would be called like `Vec::new()`. If the function/// takes `self`, `&self`, or `&mut self` as its first argument, it can also be called using/// method-call syntax, a familiar feature to any object-oriented programmer, like `vec.len()`./// ## Inherent Implementations///     number: i32,///     fn boo() {///         println!("boo! Example::boo() was called!");///     fn answer(&mut self) {///         self.number += 42;///     fn get_number(&self) -> i32 {///         self.number/// It matters little where an inherent implementation is defined;/// its functionality is in scope wherever its implementing type is./// trait Thingy {///     fn do_thingy(&self);/// impl Thingy for Example {///     fn do_thingy(&self) {///         println!("doing a thing! also, number is {}!", self.number);/// It matters little where a trait implementation is defined;/// its functionality can be brought into scope by importing the trait it implements./// For more information on implementations, see the [Rust book][book1] or the [Reference]./// # Designating a Type that Implements Some Functionality/// The other use of the `impl` keyword is in `impl Trait` syntax, which can be understood to mean/// "any (or some) concrete type that implements Trait"./// It can be used as the type of a variable declaration,/// in [argument position](https://rust-lang.github.io/rfcs/1951-expand-impl-trait.html)/// or in [return position](https://rust-lang.github.io/rfcs/3425-return-position-impl-trait-in-traits.html)./// One pertinent use case is in working with closures, which have unnameable types./// fn thing_returning_closure() -> impl Fn(i32) -> bool {///     println!("here's a closure for you!");///     |x: i32| x % 3 == 0/// For more information on `impl Trait` syntax, see the [Rust book][book2]./// [book1]: ../book/ch05-03-method-syntax.html/// [Reference]: ../reference/items/implementations.html/// [book2]: ../book/ch10-02-traits.html#returning-types-that-implement-traitsin_keyword/// Iterate over a series of values with [`for`]./// The expression immediately following `in` must implement the [`IntoIterator`] trait./// ## Literal Examples:///    * `for _ in 1..3 {}` - Iterate over an exclusive range up to but excluding 3.///    * `for _ in 1..=3 {}` - Iterate over an inclusive range up to and including 3./// (Read more about [range patterns])/// [`IntoIterator`]: ../book/ch13-04-performance.html/// [range patterns]: ../reference/patterns.html?highlight=range#range-patterns/// [`for`]: keyword.for.html/// The other use of `in` is with the keyword `pub`. It allows users to declare an item as visible/// only within a given scope./// ## Literal Example:///    * `pub(in crate::outer_mod) fn outer_mod_visible_fn() {}` - fn is visible in `outer_mod`/// Starting with the 2018 edition, paths for `pub(in path)` must start with `crate`, `self` or/// `super`. The 2015 edition may also use paths starting with `::` or modules from the crate root./// For more information, see the [Reference]./// [Reference]: ../reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubselflet_keyword/// Bind a value to a variable./// The primary use for the `let` keyword is in `let` statements, which are used to introduce a new/// set of variables into the current scope, as given by a pattern./// let thing1: i32 = 100;/// let thing2 = 200 + thing1;/// let mut changing_thing = true;/// changing_thing = false;/// let (part1, part2) = ("first", "second");///     a: bool,/// let Example { a, b: _ } = Example {///     a: true,///     b: 10004,/// assert!(a);/// The pattern is most commonly a single variable, which means no pattern matching is done and/// the expression given is bound to the variable. Apart from that, patterns used in `let` bindings/// can be as complicated as needed, given that the pattern is exhaustive. See the [Rust/// book][book1] for more information on pattern matching. The type of the pattern is optionally/// given afterwards, but if left blank is automatically inferred by the compiler if possible./// Variables in Rust are immutable by default, and require the `mut` keyword to be made mutable./// Multiple variables can be defined with the same name, known as shadowing. This doesn't affect/// the original variable in any way beyond being unable to directly access it beyond the point of/// shadowing. It continues to remain in scope, getting dropped only when it falls out of scope./// Shadowed variables don't need to have the same type as the variables shadowing them./// let shadowing_example = true;/// let shadowing_example = 123.4;/// let shadowing_example = shadowing_example as u32;/// let mut shadowing_example = format!("cool! {shadowing_example}");/// shadowing_example += " something else!"; // not shadowing/// Other places the `let` keyword is used include along with [`if`], in the form of `if let`/// expressions. They're useful if the pattern being matched isn't exhaustive, such as with/// enumerations. `while let` also exists, which runs a loop with a pattern matched value until/// that pattern can't be matched./// For more information on the `let` keyword, see the [Rust book][book2] or the [Reference]/// [book1]: ../book/ch06-02-match.html/// [book2]: ../book/ch18-01-all-the-places-for-patterns.html#let-statements/// [Reference]: ../reference/statements.html#let-statementsloop_keyword/// Loop indefinitely./// `loop` is used to define the simplest kind of loop supported in Rust. It runs the code inside/// it until the code uses `break` or the program exits.///     println!("hello world forever!");///     # break;/// let mut i = 1;///     println!("i is {i}");///     if i > 100 {///     i *= 2;/// assert_eq!(i, 128);/// Unlike the other kinds of loops in Rust (`while`, `while let`, and `for`), loops can be used as/// expressions that return values via `break`./// let something = loop {///         break i;/// assert_eq!(something, 128);/// Every `break` in a loop has to have the same type. When it's not explicitly giving something,/// `break;` returns `()`./// For more information on `loop` and loops in general, see the [Reference]./// See also, [`for`], [`while`]./// [Reference]: ../reference/expressions/loop-expr.htmlmatch_keyword/// Control flow based on pattern matching./// `match` can be used to run code conditionally. Every pattern must/// be handled exhaustively either explicitly or by using wildcards like/// `_` in the `match`. Since `match` is an expression, values can also be/// let opt = Option::None::<usize>;/// let x = match opt {///     Some(int) => int,///     None => 10,/// let a_number = Option::Some(10);/// match a_number {///     Some(x) if x <= 5 => println!("0 to 5 num = {x}"),///     Some(x @ 6..=10) => println!("6 to 10 num = {x}"),///     None => panic!(),///     // all other numbers/// `match` can be used to gain access to the inner members of an enum/// and use them directly./// enum Outer {///     Double(Option<u8>, Option<String>),///     Single(Option<u8>),///     Empty/// let get_inner = Outer::Double(None, Some(String::new()));/// match get_inner {///     Outer::Double(None, Some(st)) => println!("{st}"),///     Outer::Single(opt) => println!("{opt:?}"),/// For more information on `match` and matching in general, see the [Reference]./// [Reference]: ../reference/expressions/match-expr.htmlmod_keyword/// Organize code into [modules]./// Use `mod` to create new [modules] to encapsulate code, including other/// modules:/// mod foo {///     mod bar {///         type MyType = (u8, u8);///         fn baz() {}/// Like [`struct`]s and [`enum`]s, a module and its content are private by/// default, inaccessible to code outside of the module./// To learn more about allowing access, see the documentation for the [`pub`]/// keyword./// [`enum`]: keyword.enum.html/// [`pub`]: keyword.pub.html/// [`struct`]: keyword.struct.html/// [modules]: ../reference/items/modules.htmlmove_keyword/// Capture a [closure]'s environment by value./// `move` converts any variables captured by reference or mutable reference/// to variables captured by value./// let data = vec![1, 2, 3];/// let closure = move || println!("captured {data:?} by value");/// // data is no longer available, it is owned by the closure/// Note: `move` closures may still implement [`Fn`] or [`FnMut`], even though/// they capture variables by `move`. This is because the traits implemented by/// a closure type are determined by *what* the closure does with captured/// values, not *how* it captures them:/// fn create_fn() -> impl Fn() {///     let text = "Fn".to_owned();///     move || println!("This is a: {text}")/// let fn_plain = create_fn();/// fn_plain();/// `move` is often used when [threads] are involved.///     println!("captured {data:?} by value")/// // data was moved to the spawned thread, so we cannot use it here/// `move` is also valid before an async block./// let capture = "hello".to_owned();/// let block = async move {///     println!("rust says {capture} from async block");/// For more information on the `move` keyword, see the [closures][closure] section/// of the Rust book or the [threads] section./// [closure]: ../book/ch13-01-closures.html/// [threads]: ../book/ch16-01-threads.html#using-move-closures-with-threadsmut_keyword/// A mutable variable, reference, or pointer./// `mut` can be used in several situations. The first is mutable variables,/// which can be used anywhere you can bind a value to a variable name. Some/// examples:/// // A mutable variable in the parameter list of a function./// fn foo(mut x: u8, y: u8) -> u8 {///     x += y;/// // Modifying a mutable variable./// # #[allow(unused_assignments)]/// let mut a = 5;/// a = 6;/// assert_eq!(foo(3, 4), 7);/// assert_eq!(a, 6);/// The second is mutable references. They can be created from `mut` variables/// and must be unique: no other variables can have a mutable reference, nor a/// shared reference./// // Taking a mutable reference./// fn push_two(v: &mut Vec<u8>) {///     v.push(2);/// // A mutable reference cannot be taken to a non-mutable variable./// let mut v = vec![0, 1];/// // Passing a mutable reference./// push_two(&mut v);/// assert_eq!(v, vec![0, 1, 2]);/// ```rust,compile_fail,E0502/// let mut_ref_v = &mut v;/// let ref_v = &v;/// mut_ref_v.push(2);/// Mutable raw pointers work much like mutable references, with the added/// possibility of not pointing to a valid object. The syntax is `*mut Type`./// More information on mutable references and pointers can be found in the [Reference]./// [Reference]: ../reference/types/pointer.html#mutable-references-mutpub_keyword/// Make an item visible to others./// The keyword `pub` makes any module, function, or data structure accessible from inside/// of external modules. The `pub` keyword may also be used in a `use` declaration to re-export/// an identifier from a namespace./// For more information on the `pub` keyword, please see the visibility section/// of the [reference] and for some examples, see [Rust by Example]./// [reference]:../reference/visibility-and-privacy.html?highlight=pub#visibility-and-privacy/// [Rust by Example]:../rust-by-example/mod/visibility.htmlref_keyword/// Bind by reference during pattern matching./// `ref` annotates pattern bindings to make them borrow rather than move./// It is **not** a part of the pattern as far as matching is concerned: it does/// not affect *whether* a value is matched, only *how* it is matched./// By default, [`match`] statements consume all they can, which can sometimes/// be a problem, when you don't really need the value to be moved and owned:/// ```compile_fail,E0382/// let maybe_name = Some(String::from("Alice"));/// // The variable 'maybe_name' is consumed here .../// match maybe_name {///     Some(n) => println!("Hello, {n}"),///     _ => println!("Hello, world"),/// // ... and is now unavailable./// println!("Hello again, {}", maybe_name.unwrap_or("world".into()));/// Using the `ref` keyword, the value is only borrowed, not moved, making it/// available for use after the [`match`] statement:/// // Using `ref`, the value is borrowed, not moved ...///     Some(ref n) => println!("Hello, {n}"),/// // ... so it's available here!/// # `&` vs `ref`/// - `&` denotes that your pattern expects a reference to an object. Hence `&`/// is a part of said pattern: `&Foo` matches different objects than `Foo` does./// - `ref` indicates that you want a reference to an unpacked value. It is not/// matched against: `Foo(ref foo)` matches the same objects as `Foo(foo)`./// See also the [Reference] for more information./// [Reference]: ../reference/patterns.html#identifier-patternsreturn_keyword/// Returns a value from a function./// A `return` marks the end of an execution path in a function:///     return 3;/// assert_eq!(foo(), 3);/// `return` is not needed when the returned value is the last expression in the/// function. In this case the `;` is omitted:/// `return` returns from the function immediately (an "early return"):/// use std::io::{Error, ErrorKind, Read, Result};///     let mut file = match File::open("foo.txt") {///         Ok(f) => f,///     let size = match file.read_to_string(&mut contents) {///         Ok(s) => s,///     if contents.contains("impossible!") {///         return Err(Error::new(ErrorKind::Other, "oh no!"));///     if size > 9000 {///         return Err(Error::new(ErrorKind::Other, "over 9000!"));/// Within [closures] and [`async`] blocks, `return` returns a value from within the closure or/// `async` block, not from the parent function:///     let closure = || {///         return 5;///     let future = async {///         return 10;///     return 15;/// assert_eq!(foo(), 15);/// [closures]: ../book/ch13-01-closures.html/// [`async`]: ../std/keyword.async.htmlbecome_keyword/// Perform a tail-call of a function./// `feature(explicit_tail_calls)` is currently incomplete and may not work properly./// When tail calling a function, instead of its stack frame being added to the/// stack, the stack frame of the caller is directly replaced with the callee's./// This means that as long as a loop in a call graph only uses tail calls, the/// stack growth will be bounded./// This is useful for writing functional-style code (since it prevents recursion/// from exhausting resources) or for code optimization (since a tail call/// *might* be cheaper than a normal call, tail calls can be used in a similar/// manner to computed goto)./// Example of using `become` to implement functional-style `fold`:/// #![feature(explicit_tail_calls)]/// #![expect(incomplete_features)]/// fn fold<T: Copy, S>(slice: &[T], init: S, f: impl Fn(S, T) -> S) -> S {///     match slice {///         // without `become`, on big inputs this could easily overflow the///         // stack. using a tail call guarantees that the stack will not grow unboundedly///         [first, rest @ ..] => become fold(rest, f(init, *first), f),///         [] => init,/// Compilers can already perform "tail call optimization" -- they can replace normal/// calls with tail calls, although there are no guarantees that this will be done./// However, to perform TCO, the call needs to be the last thing that happens/// in the functions and be returned from it. This requirement is often broken/// by drop code for locals, which is run after computing the return expression:/// fn example() {///     let string = "meow".to_owned();///     println!("{string}");///     return help(); // this is *not* the last thing that happens in `example`.../// // ... because it is desugared to this:/// fn example_desugared() {///     let tmp = help();///     drop(string);///     return tmp;/// fn help() {}/// For this reason, `become` also changes the drop order, such that locals are/// dropped *before* evaluating the call./// In order to guarantee that the compiler can perform a tail call, `become`/// currently has these requirements:/// 1. callee and caller must have the same ABI, arguments, and return type/// 2. callee and caller must not have varargs/// 3. caller must not be marked with `#[track_caller]`///    - callee is allowed to be marked with `#[track_caller]` as otherwise///      adding `#[track_caller]` would be a breaking change. if callee is///      marked with `#[track_caller]` a tail call is not guaranteed./// 4. callee and caller cannot be a closure///    (unless it's coerced to a function pointer)/// It is possible to tail-call a function pointer:/// enum Inst { Inc, Dec }/// fn dispatch(stream: &[Inst], state: u32) -> u32 {///     const TABLE: &[fn(&[Inst], u32) -> u32] = &[increment, decrement];///         [inst, rest @ ..] => become TABLE[*inst as usize](rest, state),///         [] => state,/// fn increment(stream: &[Inst], state: u32) -> u32 {///     become dispatch(stream, state + 1)/// fn decrement(stream: &[Inst], state: u32) -> u32 {///     become dispatch(stream, state - 1)/// let program = &[Inst::Inc, Inst::Inc, Inst::Dec, Inst::Inc];/// assert_eq!(dispatch(program, 0), 2);self_keyword/// The receiver of a method, or the current module./// `self` is used in two situations: referencing the current module and marking/// the receiver of a method./// In paths, `self` can be used to refer to the current module, either in a/// [`use`] statement or in a path to access an element:/// Is functionally the same as:/// Using `self` to access an element in the current module:/// fn foo() {}/// fn bar() {///     self::foo()/// `self` as the current receiver for a method allows to omit the parameter/// type most of the time. With the exception of this particularity, `self` is/// used much like any other parameter:///     // No `self`.///         Self(0)///     // Consuming `self`.///     fn consume(self) -> Self {///         Self(self.0 + 1)///     // Borrowing `self`.///     fn borrow(&self) -> &i32 {///     // Borrowing `self` mutably.///     fn borrow_mut(&mut self) -> &mut i32 {/// // This method must be called with a `Type::` prefix./// assert_eq!(foo.0, 0);/// // Those two calls produces the same result./// let foo = Foo::consume(foo);/// assert_eq!(foo.0, 1);/// let foo = foo.consume();/// assert_eq!(foo.0, 2);/// // Borrowing is handled automatically with the second syntax./// let borrow_1 = Foo::borrow(&foo);/// let borrow_2 = foo.borrow();/// assert_eq!(borrow_1, borrow_2);/// // Borrowing mutably is handled automatically too with the second syntax./// let mut foo = Foo::new();/// *Foo::borrow_mut(&mut foo) += 1;/// *foo.borrow_mut() += 1;/// Note that this automatic conversion when calling `foo.method()` is not/// limited to the examples above. See the [Reference] for more information./// [Reference]: ../reference/items/associated-items.html#methodsself_upper_keyword// FIXME: Once rustdoc can handle URL conflicts on case insensitive file systems, we can replace// these two lines with `#[doc(keyword = "Self")]` and update `is_doc_keyword` in// `CheckAttrVisitor`./// The implementing type within a [`trait`] or [`impl`] block, or the current type within a type/// definition./// Within a type definition:///     elem: i32,///     // `Self` is a `Node` here.///     next: Option<Box<Self>>,/// In an [`impl`] block:/// assert_eq!(Foo::new().0, Foo(0).0);/// Generic parameters are implicit with `Self`:/// struct Wrap<T> {///     elem: T,/// impl<T> Wrap<T> {///     fn new(elem: T) -> Self {///         Self { elem }/// In a [`trait`] definition and related [`impl`] block:/// trait Example {///     fn example() -> Self;/// impl Example for Foo {///     fn example() -> Self {///         Self(42)/// assert_eq!(Foo::example().0, Foo(42).0);/// [`trait`]: keyword.trait.htmlstatic_keyword/// A static item is a value which is valid for the entire duration of your/// program (a `'static` lifetime)./// On the surface, `static` items seem very similar to [`const`]s: both contain/// a value, both require type annotations and both can only be initialized with/// constant functions and values. However, `static`s are notably different in/// that they represent a location in memory. That means that you can have/// references to `static` items and potentially even modify them, making them/// essentially global variables./// Static items do not call [`drop`] at the end of the program./// There are two types of `static` items: those declared in association with/// the [`mut`] keyword and those without./// Static items cannot be moved:/// ```rust,compile_fail,E0507/// static VEC: Vec<u32> = vec![];/// fn move_vec(v: Vec<u32>) -> Vec<u32> {///     v/// // This line causes an error/// move_vec(VEC);/// # Simple `static`s/// Accessing non-[`mut`] `static` items is considered safe, but some/// restrictions apply. Most notably, the type of a `static` value needs to/// implement the [`Sync`] trait, ruling out interior mutability containers/// like [`RefCell`]. See the [Reference] for more information./// static FOO: [i32; 5] = [1, 2, 3, 4, 5];/// let r1 = &FOO as *const _;/// let r2 = &FOO as *const _;/// // With a strictly read-only static, references will have the same address/// // A static item can be used just like a variable in many cases/// println!("{FOO:?}");/// # Mutable `static`s/// If a `static` item is declared with the [`mut`] keyword, then it is allowed/// to be modified by the program. However, accessing mutable `static`s can/// cause undefined behavior in a number of ways, for example due to data races/// in a multithreaded context. As such, all accesses to mutable `static`s/// require an [`unsafe`] block./// When possible, it's often better to use a non-mutable `static` with an/// interior mutable type such as [`Mutex`], [`OnceLock`], or an [atomic]./// Despite their unsafety, mutable `static`s are necessary in many contexts:/// they can be used to represent global state shared by the whole program or in/// [`extern`] blocks to bind to variables from C libraries./// In an [`extern`] block:///     static mut ERROR_MESSAGE: *mut std::os::raw::c_char;/// Mutable `static`s, just like simple `static`s, have some restrictions that/// apply to them. See the [Reference] for more information./// [`const`]: keyword.const.html/// [`mut`]: keyword.mut.html/// [`unsafe`]: keyword.unsafe.html/// [`Mutex`]: sync::Mutex/// [`OnceLock`]: sync::OnceLock/// [`RefCell`]: cell::RefCell/// [atomic]: sync::atomic/// [Reference]: ../reference/items/static-items.htmlstruct_keyword/// A type that is composed of other types./// Structs in Rust come in three flavors: Structs with named fields, tuple structs, and unit/// structs./// struct Regular {///     field1: f32,///     field2: String,///     pub field3: bool/// struct Tuple(u32, String);/// struct Unit;/// Regular structs are the most commonly used. Each field defined within them has a name and a/// type, and once defined can be accessed using `example_struct.field` syntax. The fields of a/// struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding/// `pub` to a field makes it visible to code in other modules, as well as allowing it to be/// directly accessed and modified./// Tuple structs are similar to regular structs, but its fields have no names. They are used like/// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax. For accessing/// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`,/// etc, starting at zero./// Unit structs are most commonly used as marker. They have a size of zero bytes, but unlike empty/// enums they can be instantiated, making them isomorphic to the unit type `()`. Unit structs are/// useful when you need to implement a trait on something, but don't need to store any data inside/// # Instantiation/// Structs can be instantiated in different ways, all of which can be mixed and/// matched as needed. The most common way to make a new struct is via a constructor method such as/// `new()`, but when that isn't available (or you're writing the constructor itself), struct/// literal syntax is used:/// # struct Foo { field1: f32, field2: String, etc: bool }/// let example = Foo {///     field1: 42.0,///     field2: "blah".to_string(),///     etc: true,/// It's only possible to directly instantiate a struct using struct literal syntax when all of its/// fields are visible to you./// There are a handful of shortcuts provided to make writing constructors more convenient, most/// common of which is the Field Init shorthand. When there is a variable and a field of the same/// name, the assignment can be simplified from `field: field` into simply `field`. The following/// example of a hypothetical constructor demonstrates this:///     admin: bool,/// impl User {///     pub fn new(name: String) -> Self {///             admin: false,/// Another shortcut for struct instantiation is available, used when you need to make a new/// struct that has the same values as most of a previous struct of the same type, called struct/// update syntax:/// # struct Foo { field1: String, field2: () }/// # let thing = Foo { field1: "".to_string(), field2: () };/// let updated_thing = Foo {///     field1: "a new value".to_string(),///     ..thing/// Tuple structs are instantiated in the same way as tuples themselves, except with the struct's/// name as a prefix: `Foo(123, false, 0.1)`./// Empty structs are instantiated with just their name, and don't need anything else. `let thing =/// EmptyStruct;`/// # Style conventions/// Structs are always written in UpperCamelCase, with few exceptions. While the trailing comma on a/// struct's list of fields can be omitted, it's usually kept for convenience in adding and/// removing fields down the line./// For more information on structs, take a look at the [Rust Book][book] or the/// [Reference][reference]./// [`PhantomData`]: marker::PhantomData/// [book]: ../book/ch05-01-defining-structs.html/// [reference]: ../reference/items/structs.htmlsuper_keyword/// The parent of the current [module]./// mod a {///     pub fn foo() {}/// mod b {///         super::a::foo(); // call a's foo function/// It is also possible to use `super` multiple times: `super::super::foo`,/// going up the ancestor chain./// See the [Reference] for more information./// [module]: ../reference/items/modules.html/// [Reference]: ../reference/paths.html#supertrait_keyword/// A common interface for a group of types./// A `trait` is like an interface that data types can implement. When a type/// implements a trait it can be treated abstractly as that trait using generics/// or trait objects./// Traits can be made up of three varieties of associated items:/// - functions and methods/// - types/// - constants/// Traits may also contain additional type parameters. Those type parameters/// or the trait itself can be constrained by other traits./// Traits can serve as markers or carry other logical semantics that/// aren't expressed through their items. When a type implements that/// trait it is promising to uphold its contract. [`Send`] and [`Sync`] are two/// such marker traits present in the standard library./// See the [Reference][Ref-Traits] for a lot more information on traits./// Traits are declared using the `trait` keyword. Types can implement them/// using [`impl`] `Trait` [`for`] `Type`:/// trait Zero {///     const ZERO: Self;///     fn is_zero(&self) -> bool;/// impl Zero for i32 {///     const ZERO: Self = 0;///     fn is_zero(&self) -> bool {///         *self == Self::ZERO/// assert_eq!(i32::ZERO, 0);/// assert!(i32::ZERO.is_zero());/// assert!(!4.is_zero());/// With an associated type:/// trait Builder {///     type Built;///     fn build(&self) -> Self::Built;/// Traits can be generic, with constraints or without:/// trait MaybeFrom<T> {///     fn maybe_from(value: T) -> Option<Self>///         Self: Sized;/// Traits can build upon the requirements of other traits. In the example/// below `Iterator` is a **supertrait** and `ThreeIterator` is a **subtrait**:/// trait ThreeIterator: Iterator {///     fn next_three(&mut self) -> Option<[Self::Item; 3]>;/// Traits can be used in functions, as parameters:/// fn debug_iter<I: Iterator>(it: I) where I::Item: std::fmt::Debug {///     for elem in it {///         println!("{elem:#?}");/// // u8_len_1, u8_len_2 and u8_len_3 are equivalent/// fn u8_len_1(val: impl Into<Vec<u8>>) -> usize {///     val.into().len()/// fn u8_len_2<T: Into<Vec<u8>>>(val: T) -> usize {/// fn u8_len_3<T>(val: T) -> usize///     T: Into<Vec<u8>>,/// Or as return types:/// fn from_zero_to(v: u8) -> impl Iterator<Item = u8> {///     (0..v).into_iter()/// The use of the [`impl`] keyword in this position allows the function writer/// to hide the concrete type as an implementation detail which can change/// without breaking user's code./// # Trait objects/// A *trait object* is an opaque value of another type that implements a set of/// traits. A trait object implements all specified traits as well as their/// supertraits (if any)./// The syntax is the following: `dyn BaseTrait + AutoTrait1 + ... AutoTraitN`./// Only one `BaseTrait` can be used so this will not compile:/// ```rust,compile_fail,E0225/// trait A {}/// trait B {}/// let _: Box<dyn A + B>;/// Neither will this, which is a syntax error:/// let _: Box<dyn A + dyn B>;/// On the other hand, this is correct:/// let _: Box<dyn A + Send + Sync>;/// The [Reference][Ref-Trait-Objects] has more information about trait objects,/// their limitations and the differences between editions./// # Unsafe traits/// Some traits may be unsafe to implement. Using the [`unsafe`] keyword in/// front of the trait's declaration is used to mark this:/// unsafe trait UnsafeTrait {}/// unsafe impl UnsafeTrait for i32 {}/// # Differences between the 2015 and 2018 editions/// In the 2015 edition the parameters pattern was not needed for traits:/// ```rust,edition2015/// # #![allow(anonymous_parameters)]/// trait Tr {///     fn f(i32);/// This behavior is no longer valid in edition 2018./// [Ref-Traits]: ../reference/items/traits.html/// [Ref-Trait-Objects]: ../reference/types/trait-object.htmltrue_keyword/// A value of type [`bool`] representing logical **true**./// Logically `true` is not equal to [`false`]./// ## Control structures that check for **true**/// Several of Rust's control structures will check for a `bool` condition evaluating to **true**.///   * The condition in an [`if`] expression must be of type `bool`.///     Whenever that condition evaluates to **true**, the `if` expression takes///     on the value of the first block. If however, the condition evaluates///     to `false`, the expression takes on value of the `else` block if there is one.///   * [`while`] is another control flow construct expecting a `bool`-typed condition.///     As long as the condition evaluates to **true**, the `while` loop will continually///     evaluate its associated block.///   * [`match`] arms can have guard clauses on them./// [`match`]: ../reference/expressions/match-expr.html#match-guardstype_keyword/// Define an [alias] for an existing type./// The syntax is `type Name = ExistingType;`./// `type` does **not** create a new type:/// type Meters = u32;/// type Kilograms = u32;/// let m: Meters = 3;/// let k: Kilograms = 3;/// assert_eq!(m, k);/// A type can be generic:/// # use std::sync::{Arc, Mutex};/// type ArcMutex<T> = Arc<Mutex<T>>;/// In traits, `type` is used to declare an [associated type]:/// trait Iterator {///     // associated type declaration///     type Item;///     fn next(&mut self) -> Option<Self::Item>;/// struct Once<T>(Option<T>);/// impl<T> Iterator for Once<T> {///     // associated type definition///     type Item = T;///     fn next(&mut self) -> Option<Self::Item> {///         self.0.take()/// [associated type]: ../reference/items/associated-items.html#associated-types/// [alias]: ../reference/items/type-aliases.htmlunsafe_keyword/// Code or interfaces whose [memory safety] cannot be verified by the type/// The `unsafe` keyword has two uses:/// - to declare the existence of contracts the compiler can't check (`unsafe fn` and `unsafe/// trait`),/// - and to declare that a programmer has checked that these contracts have been upheld (`unsafe/// {}` and `unsafe impl`, but also `unsafe fn` -- see below)./// # Unsafe abilities/// **No matter what, Safe Rust can't cause Undefined Behavior**. This is/// referred to as [soundness]: a well-typed program actually has the desired/// properties. The [Nomicon][nomicon-soundness] has a more detailed explanation/// on the subject./// To ensure soundness, Safe Rust is restricted enough that it can be/// automatically checked. Sometimes, however, it is necessary to write code/// that is correct for reasons which are too clever for the compiler to/// understand. In those cases, you need to use Unsafe Rust./// Here are the abilities Unsafe Rust has in addition to Safe Rust:/// - Dereference [raw pointers]/// - Implement `unsafe` [`trait`]s/// - Call `unsafe` functions/// - Mutate [`static`]s (including [`extern`]al ones)/// - Access fields of [`union`]s/// However, this extra power comes with extra responsibilities: it is now up to/// you to ensure soundness. The `unsafe` keyword helps by clearly marking the/// pieces of code that need to worry about this./// ## The different meanings of `unsafe`/// Not all uses of `unsafe` are equivalent: some are here to mark the existence/// of a contract the programmer must check, others are to say "I have checked/// the contract, go ahead and do this". The following/// [discussion on Rust Internals] has more in-depth explanations about this but/// here is a summary of the main points:/// - `unsafe fn`: calling this function means abiding by a contract the/// compiler cannot enforce./// - `unsafe trait`: implementing the [`trait`] means abiding by a/// contract the compiler cannot enforce./// - `unsafe {}`: the contract necessary to call the operations inside the/// block has been checked by the programmer and is guaranteed to be respected./// - `unsafe impl`: the contract necessary to implement the trait has been/// checked by the programmer and is guaranteed to be respected./// See the [Rustonomicon] and the [Reference] for more information./// ## Marking elements as `unsafe`/// `unsafe` can be used on functions. Note that functions and statics declared/// in [`extern`] blocks are implicitly marked as `unsafe` (but not functions/// declared as `extern "something" fn ...`). Mutable statics are always unsafe,/// wherever they are declared. Methods can also be declared as `unsafe`:/// static mut FOO: &str = "hello";/// unsafe fn unsafe_fn() {}///     fn unsafe_extern_fn();///     static BAR: *mut u32;/// trait SafeTraitWithUnsafeMethod {///     unsafe fn unsafe_method(&self);/// struct S;/// impl S {///     unsafe fn unsafe_method_on_struct() {}/// Traits can also be declared as `unsafe`:/// Since `unsafe fn` and `unsafe trait` indicate that there is a safety/// contract that the compiler cannot enforce, documenting it is important. The/// standard library has many examples of this, like the following which is an/// extract from [`Vec::set_len`]. The `# Safety` section explains the contract/// that must be fulfilled to safely call the function./// ```rust,ignore (stub-to-show-doc-example)/// /// Forces the length of the vector to `new_len`./// /// This is a low-level operation that maintains none of the normal/// /// invariants of the type. Normally changing the length of a vector/// /// is done using one of the safe operations instead, such as/// /// `truncate`, `resize`, `extend`, or `clear`./// /// - `new_len` must be less than or equal to `capacity()`./// /// - The elements at `old_len..new_len` must be initialized./// pub unsafe fn set_len(&mut self, new_len: usize)/// ## Using `unsafe {}` blocks and `impl`s/// Performing `unsafe` operations requires an `unsafe {}` block:/// #![deny(unsafe_op_in_unsafe_fn)]/// /// Dereference the given pointer./// /// `ptr` must be aligned and must not be dangling./// unsafe fn deref_unchecked(ptr: *const i32) -> i32 {///     // SAFETY: the caller is required to ensure that `ptr` is aligned and dereferenceable.///     unsafe { *ptr }/// let b = &a as *const _;/// // SAFETY: `a` has not been dropped and references are always aligned,/// // so `b` is a valid address./// unsafe { assert_eq!(*b, deref_unchecked(b)); };/// ## `unsafe` and traits/// The interactions of `unsafe` and traits can be surprising, so let us contrast the/// two combinations of safe `fn` in `unsafe trait` and `unsafe fn` in safe trait using two/// /// `make_even` must return an even number./// unsafe trait MakeEven {///     fn make_even(&self) -> i32;/// // SAFETY: Our `make_even` always returns something even./// unsafe impl MakeEven for i32 {///     fn make_even(&self) -> i32 {///         self << 1/// fn use_make_even(x: impl MakeEven) {///     if x.make_even() % 2 == 1 {///         // SAFETY: this can never happen, because all `MakeEven` implementations///         // ensure that `make_even` returns something even.///         unsafe { std::hint::unreachable_unchecked() };/// Note how the safety contract of the trait is upheld by the implementation, and is itself used to/// uphold the safety contract of the unsafe function `unreachable_unchecked` called by/// `use_make_even`. `make_even` itself is a safe function because its *callers* do not have to/// worry about any contract, only the *implementation* of `MakeEven` is required to uphold a/// certain contract. `use_make_even` is safe because it can use the promise made by `MakeEven`/// implementations to uphold the safety contract of the `unsafe fn unreachable_unchecked` it calls./// It is also possible to have `unsafe fn` in a regular safe `trait`:/// trait Indexable {///     const LEN: usize;///     /// # Safety///     //////     /// The caller must ensure that `idx < LEN`.///     unsafe fn idx_unchecked(&self, idx: usize) -> i32;/// // The implementation for `i32` doesn't need to do any contract reasoning./// impl Indexable for i32 {///     const LEN: usize = 1;///     /// See `Indexable` for the safety contract.///     unsafe fn idx_unchecked(&self, idx: usize) -> i32 {///         debug_assert_eq!(idx, 0);/// // The implementation for arrays exploits the function contract to/// // make use of `get_unchecked` on slices and avoid a run-time check./// impl Indexable for [i32; 42] {///     const LEN: usize = 42;///         // SAFETY: As per this trait's documentation, the caller ensures///         // that `idx < 42`.///         unsafe { *self.get_unchecked(idx) }/// // The implementation for the never type declares a length of 0,/// // which means `idx_unchecked` can never be called./// impl Indexable for ! {///     const LEN: usize = 0;///         // that `idx < 0`, which is impossible, so this is dead code.///         unsafe { std::hint::unreachable_unchecked() }/// fn use_indexable<I: Indexable>(x: I, idx: usize) -> i32 {///     if idx < I::LEN {///         // SAFETY: We have checked that `idx < I::LEN`.///         unsafe { x.idx_unchecked(idx) }///         panic!("index out-of-bounds")/// This time, `use_indexable` is safe because it uses a run-time check to discharge the safety/// contract of `idx_unchecked`. Implementing `Indexable` is safe because when writing/// `idx_unchecked`, we don't have to worry: our *callers* need to discharge a proof obligation/// (like `use_indexable` does), but the *implementation* of `get_unchecked` has no proof obligation/// to contend with. Of course, the implementation may choose to call other unsafe operations, and/// then it needs an `unsafe` *block* to indicate it discharged the proof obligations of its/// callees. For that purpose it can make use of the contract that all its callers must uphold --/// the fact that `idx < LEN`./// Note that unlike normal `unsafe fn`, an `unsafe fn` in a trait implementation does not get to/// just pick an arbitrary safety contract! It *has* to use the safety contract defined by the trait/// (or one with weaker preconditions)./// Formally speaking, an `unsafe fn` in a trait is a function with *preconditions* that go beyond/// those encoded by the argument types (such as `idx < LEN`), whereas an `unsafe trait` can declare/// that some of its functions have *postconditions* that go beyond those encoded in the return type/// (such as returning an even integer). If a trait needs a function with both extra precondition/// and extra postcondition, then it needs an `unsafe fn` in an `unsafe trait`./// [`static`]: keyword.static.html/// [`union`]: keyword.union.html/// [raw pointers]: ../reference/types/pointer.html/// [memory safety]: ../book/ch19-01-unsafe-rust.html/// [Rustonomicon]: ../nomicon/index.html/// [nomicon-soundness]: ../nomicon/safe-unsafe-meaning.html/// [soundness]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#soundness-of-code--of-a-library/// [Reference]: ../reference/unsafety.html/// [discussion on Rust Internals]: https://internals.rust-lang.org/t/what-does-unsafe-mean/6696use_keyword/// Import or rename items from other crates or modules, use values under ergonomic clones/// semantic, or specify precise capturing with `use<..>`./// ## Importing items/// The `use` keyword is employed to shorten the path required to refer to a module item./// The keyword may appear in modules, blocks, and even functions, typically at the top./// The most basic usage of the keyword is `use path::to::item;`,/// though a number of convenient shortcuts are supported:///   * Simultaneously binding a list of paths with a common prefix,///     using the glob-like brace syntax `use a::b::{c, d, e::f, g::h::i};`///   * Simultaneously binding a list of paths with a common prefix and their common parent module,///     using the [`self`] keyword, such as `use a::b::{self, c, d::e};`///   * Rebinding the target name as a new local name, using the syntax `use p::q::r as x;`.///     This can also be used with the last two features: `use a::b::{self as ab, c as abc}`.///   * Binding all paths matching a given prefix,///     using the asterisk wildcard syntax `use a::b::*;`.///   * Nesting groups of the previous features multiple times,///     such as `use a::b::{self as ab, c, d::{*, e::f}};`///   * Reexporting with visibility modifiers such as `pub use a::b;`///   * Importing with `_` to only import the methods of a trait without binding it to a name///     (to avoid conflict for example): `use ::std::io::Read as _;`./// Using path qualifiers like [`crate`], [`super`] or [`self`] is supported: `use crate::a::b;`./// Note that when the wildcard `*` is used on a type, it does not import its methods (though/// for `enum`s it imports the variants, as shown in the example below)./// ```compile_fail,edition2018/// enum ExampleEnum {///     VariantA,///     VariantB,/// impl ExampleEnum {///         Self::VariantA/// use ExampleEnum::*;/// // Compiles./// let _ = VariantA;/// // Does not compile!/// let n = new();/// For more information on `use` and paths in general, see the [Reference][ref-use-decls]./// The differences about paths and the `use` keyword between the 2015 and 2018 editions/// can also be found in the [Reference][ref-use-decls]./// ## Precise capturing/// The `use<..>` syntax is used within certain `impl Trait` bounds to control which generic/// parameters are captured. This is important for return-position `impl Trait` (RPIT) types,/// as it affects borrow checking by controlling which generic parameters can be used in the/// hidden type./// For example, the following function demonstrates an error without precise capturing in/// Rust 2021 and earlier editions:/// ```rust,compile_fail,edition2021/// fn f(x: &()) -> impl Sized { x }/// By using `use<'_>` for precise capturing, it can be resolved:/// fn f(x: &()) -> impl Sized + use<'_> { x }/// This syntax specifies that the elided lifetime be captured and therefore available for/// use in the hidden type./// In Rust 2024, opaque types automatically capture all lifetime parameters in scope./// `use<..>` syntax serves as an important way of opting-out of that default./// For more details about precise capturing, see the [Reference][ref-impl-trait]./// ## Ergonomic clones/// Use a values, copying its content if the value implements `Copy`, cloning the contents if the/// value implements `UseCloned` or moving it otherwise./// [`self`]: keyword.self.html/// [`super`]: keyword.super.html/// [ref-use-decls]: ../reference/items/use-declarations.html/// [ref-impl-trait]: ../reference/types/impl-trait.htmlwhere_keyword/// Add constraints that must be upheld to use an item./// `where` allows specifying constraints on lifetime and generic parameters./// The [RFC] introducing `where` contains detailed information about the/// `where` can be used for constraints with traits:/// fn new<T: Default>() -> T {///     T::default()/// fn new_where<T>() -> T///     T: Default,/// assert_eq!(0.0, new());/// assert_eq!(0.0, new_where());/// assert_eq!(0, new());/// assert_eq!(0, new_where());/// `where` can also be used for lifetimes./// This compiles because `longer` outlives `shorter`, thus the constraint is/// respected:/// fn select<'short, 'long>(s1: &'short str, s2: &'long str, second: bool) -> &'short str///     'long: 'short,///     if second { s2 } else { s1 }/// let outer = String::from("Long living ref");/// let longer = &outer;///     let inner = String::from("Short living ref");///     let shorter = &inner;///     assert_eq!(select(shorter, longer, false), shorter);///     assert_eq!(select(shorter, longer, true), longer);/// On the other hand, this will not compile because the `where 'b: 'a` clause/// is missing: the `'b` lifetime is not known to live at least as long as `'a`/// which means this function cannot ensure it always returns a valid reference:/// fn select<'a, 'b>(s1: &'a str, s2: &'b str, second: bool) -> &'a str/// `where` can also be used to express more complicated constraints that cannot/// be written with the `<T: Trait>` syntax:/// fn first_or_default<I>(mut i: I) -> I::Item///     I::Item: Default,///     i.next().unwrap_or_else(I::Item::default)/// assert_eq!(first_or_default([1, 2, 3].into_iter()), 1);/// assert_eq!(first_or_default(Vec::<i32>::new().into_iter()), 0);/// `where` is available anywhere generic and lifetime parameters are available,/// as can be seen with the [`Cow`](crate::borrow::Cow) type from the standard/// library:/// pub enum Cow<'a, B>///     B: ToOwned + ?Sized,///     Borrowed(&'a B),///     Owned(<B as ToOwned>::Owned),/// [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/0135-where.mdwhile_keyword/// Loop while a condition is upheld./// A `while` expression is used for predicate loops. The `while` expression runs the conditional/// expression before running the loop body, then runs the loop body if the conditional/// expression evaluates to `true`, or exits the loop otherwise./// let mut counter = 0;/// while counter < 10 {///     println!("{counter}");///     counter += 1;/// Like the [`for`] expression, we can use `break` and `continue`. A `while` expression/// cannot break with a value and always evaluates to `()` unlike [`loop`]./// while i < 100 {///     if i == 64 {///         break; // Exit when `i` is 64./// As `if` expressions have their pattern matching variant in `if let`, so too do `while`/// expressions with `while let`. The `while let` expression matches the pattern against the/// expression, then runs the loop body if pattern matching succeeds, or exits the loop otherwise./// We can use `break` and `continue` in `while let` expressions just like in `while`./// let mut counter = Some(0);/// while let Some(i) = counter {///     if i == 10 {///         counter = None;///         println!("{i}");///         counter = Some (i + 1);/// For more information on `while` and loops in general, see the [reference]./// See also, [`for`], [`loop`]./// [reference]: ../reference/expressions/loop-expr.html#predicate-loopsasync_keyword/// Returns a [`Future`] instead of blocking the current thread./// Use `async` in front of `fn`, `closure`, or a `block` to turn the marked code into a `Future`./// As such the code will not be run immediately, but will only be evaluated when the returned/// future is [`.await`]ed./// We have written an [async book] detailing `async`/`await` and trade-offs compared to using threads./// ## Control Flow/// [`return`] statements and [`?`][try operator] operators within `async` blocks do not cause/// a return from the parent function; rather, they cause the `Future` returned by the block to/// return with that value./// For example, the following Rust function will return `5`, causing `x` to take the [`!` type][never type]:/// #[expect(unused_variables)]/// fn example() -> i32 {///     let x = {/// In contrast, the following asynchronous function assigns a `Future<Output = i32>` to `x`, and/// only returns `5` when `x` is `.await`ed:/// async fn example() -> i32 {///     let x = async {///     x.await/// Code using `?` behaves similarly - it causes the `async` block to return a [`Result`] without/// affecting the parent function./// Note that you cannot use `break` or `continue` from within an `async` block to affect the/// control flow of a loop in the parent function./// Control flow in `async` blocks is documented further in the [async book][async book blocks]./// ## Editions/// `async` is a keyword from the 2018 edition onwards./// It is available for use in stable Rust from version 1.39 onwards./// [`Future`]: future::Future/// [`.await`]: ../std/keyword.await.html/// [async book]: https://rust-lang.github.io/async-book//// [`return`]: ../std/keyword.return.html/// [try operator]: ../reference/expressions/operator-expr.html#r-expr.try/// [never type]: ../reference/types/never.html/// [`Result`]: result::Result/// [async book blocks]: https://rust-lang.github.io/async-book/part-guide/more-async-await.html#async-blocksawait_keyword/// Suspend execution until the result of a [`Future`] is ready./// `.await`ing a future will suspend the current function's execution until the executor/// has run the future to completion./// Read the [async book] for details on how [`async`]/`await` and executors work./// `await` is a keyword from the 2018 edition onwards.dyn_keyword/// `dyn` is a prefix of a [trait object]'s type./// The `dyn` keyword is used to highlight that calls to methods on the associated `Trait`/// are [dynamically dispatched]. To use the trait this way, it must be *dyn compatible*[^1]./// Unlike generic parameters or `impl Trait`, the compiler does not know the concrete type that/// is being passed. That is, the type has been [erased]./// As such, a `dyn Trait` reference contains _two_ pointers./// One pointer goes to the data (e.g., an instance of a struct)./// Another pointer goes to a map of method call names to function pointers/// (known as a virtual method table or vtable)./// At run-time, when a method needs to be called on the `dyn Trait`, the vtable is consulted to get/// the function pointer and then that function pointer is called./// See the Reference for more information on [trait objects][ref-trait-obj]/// and [dyn compatibility][ref-dyn-compat]./// ## Trade-offs/// The above indirection is the additional runtime cost of calling a function on a `dyn Trait`./// Methods called by dynamic dispatch generally cannot be inlined by the compiler./// However, `dyn Trait` is likely to produce smaller code than `impl Trait` / generic parameters as/// the method won't be duplicated for each concrete type./// [trait object]: ../book/ch17-02-trait-objects.html/// [dynamically dispatched]: https://en.wikipedia.org/wiki/Dynamic_dispatch/// [ref-trait-obj]: ../reference/types/trait-object.html/// [ref-dyn-compat]: ../reference/items/traits.html#dyn-compatibility/// [erased]: https://en.wikipedia.org/wiki/Type_erasureunion_keyword/// The [Rust equivalent of a C-style union][union]./// A `union` looks like a [`struct`] in terms of declaration, but all of its/// fields exist in the same memory, superimposed over one another. For instance,/// if we wanted some bits in memory that we sometimes interpret as a `u32` and/// sometimes as an `f32`, we could write:/// union IntOrFloat {///     i: u32,///     f: f32,/// let mut u = IntOrFloat { f: 1.0 };/// // Reading the fields of a union is always unsafe/// assert_eq!(unsafe { u.i }, 1065353216);/// // Updating through any of the field will modify all of them/// u.i = 1073741824;/// assert_eq!(unsafe { u.f }, 2.0);/// # Matching on unions/// It is possible to use pattern matching on `union`s. A single field name must/// be used and it must match the name of one of the `union`'s field./// Like reading from a `union`, pattern matching on a `union` requires `unsafe`./// let u = IntOrFloat { f: 1.0 };///     match u {///         IntOrFloat { i: 10 } => println!("Found exactly ten!"),///         // Matching the field `f` provides an `f32`.///         IntOrFloat { f } => println!("Found f = {f} !"),/// # References to union fields/// All fields in a `union` are all at the same place in memory which means/// borrowing one borrows the entire `union`, for the same lifetime:/// let f = unsafe { &u.f };/// // This will not compile because the field has already been borrowed, even/// // if only immutably/// let i = unsafe { &mut u.i };/// *i = 10;/// println!("f = {f} and i = {i}");/// See the [Reference][union] for more information on `union`s./// [union]: ../reference/items/unions.html// 2018 Edition keywordsneeds_panic_runtimedefault_lib_allocator// The Rust prelude// The compiler expects the prelude definition to be defined before its use statement.// Explicitly import the prelude. The compiler uses this same unstable attribute// to import the prelude implicitly when building crates that depend on std.// macros from `alloc` are not used on all platforms// Many compiler tests depend on libc being pulled in by std// so include it here even if it's unused.// We always need an unwinder currently for backtraces// The standard macros that are not built-in to the compiler.// The runtime entry point and a few unstable public functions used by the// compiler"../../portable-simd/crates/std_float/src/lib.rs"// Pull in `std_float` crate  into std. The contents of// `std_float` are in a different repository: rust-lang/portable-simd./// This macro handles automatic differentiation./// This module provides support for automatic differentiation.// The `no_inline`-attribute is required to make the documentation of all// targets available.// See https://github.com/rust-lang/rust/pull/57808#issuecomment-457390549 for// more information.// Note (#82861): required for correct documentationis_aarch64_feature_detectedis_arm_feature_detectedis_loongarch_feature_detectedis_riscv_feature_detectedis_s390x_feature_detectedis_mips_feature_detectedis_mips64_feature_detectedis_powerpc_feature_detectedis_powerpc64_feature_detected// This was stabilized in the crate root so we have to keep it there.// Platform-abstraction modules// Private support modules"../../backtrace/src/lib.rs"// Re-export built-in macros defined through core.// Re-export macros defined in core.// Re-export unstable derive macro defined through core.// Include a number of private modules that exist solely to provide// the rustdoc documentation for primitive types. Using `include!`// because rustdoc only looks for these modules at the crate level." Cast between types, rename an import, or qualify paths to associated items."" # Type casting"" `as` is most commonly used to turn primitive types into other primitive types, but it has other"" uses that include turning pointers into addresses, addresses into pointers, and pointers into"" other pointers."" let thing1: u8 = 89.0 as u8;"" assert_eq!(\'B\' as u32, 66);"" assert_eq!(thing1 as char, \'Y\');"" let thing2: f32 = thing1 as f32 + 10.5;"" assert_eq!(true as u8 + thing2 as u8, 100);"" In general, any cast that can be performed via ascribing the type can also be done using `as`,"" so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (note: `let x: u32"" = 123` would be best in that situation). The same is not true in the other direction, however;"" explicitly using `as` allows a few more coercions that aren\'t allowed implicitly, such as"" changing the type of a raw pointer or turning closures into raw pointers."" `as` can be seen as the primitive for `From` and `Into`: `as` only works  with primitives"" (`u8`, `bool`, `str`, pointers, ...) whereas `From` and `Into`  also works with types like"" `String` or `Vec`."" `as` can also be used with the `_` placeholder when the destination type can be inferred. Note"" that this can cause inference breakage and usually such code should use an explicit type for"" both clarity and stability. This is most useful when converting pointers using `as *const _` or"" `as *mut _` though the [`cast`][const-cast] method is recommended over `as *const _` and it is"" [the same][mut-cast] for `as *mut _`: those methods make the intent clearer."" # Renaming imports"" `as` is also used to rename imports in [`use`] and [`extern crate`][`crate`] statements:"" # #[allow(unused_imports)]"" use std::{mem as memory, net as network};"" // Now you can use the names `memory` and `network` to refer to `std::mem` and `std::net`."" # Qualifying paths"" You\'ll also find with `From` and `Into`, and indeed all traits, that `as` is used for the"" _fully qualified path_, a means of disambiguating associated items, i.e. functions,"" constants, and types.  For example, if you have a type which implements two traits with identical"" method names (e.g. `Into::<u32>::into` and `Into::<u64>::into`), you can clarify which method"" you\'ll use with `<MyThing as Into<u32>>::into(my_thing)`[^as-use-from].  This is quite verbose,"" but fortunately, Rust\'s type inference usually saves you from needing this, although it is"" occasionally necessary, especially with methods that return a generic type like `Into::into` or"" methods that don\'t take `self`.  It\'s more common to use in macros where it can provide necessary"" hygiene."" [^as-use-from]: You should probably never use this syntax with `Into` and instead write"" `T::from(my_thing)`.  It just happens that there aren\'t any great examples for this syntax in"" the standard library.  Also, at time of writing, the compiler tends to suggest fully-qualified"" paths to fix ambiguous `Into::into` calls, so the example should hopefully be familiar."" # Further reading"" For more information on what `as` is capable of, see the Reference on [type cast expressions],"" [renaming imported entities], [renaming `extern` crates]"" and [qualified paths]."" [type cast expressions]: ../reference/expressions/operator-expr.html#type-cast-expressions"" [renaming imported entities]: https://doc.rust-lang.org/reference/items/use-declarations.html#as-renames"" [renaming `extern` crates]: https://doc.rust-lang.org/reference/items/extern-crates.html#r-items.extern-crate.as"" [qualified paths]: ../reference/paths.html#qualified-paths"" [`crate`]: keyword.crate.html"" [`use`]: keyword.use.html"" [const-cast]: pointer::cast"" [mut-cast]: primitive.pointer.html#method.cast-1"" Exit early from a loop or labelled block."" When `break` is encountered, execution of the associated loop body is"" immediately terminated."" let mut last = 0;"" for x in 1..100 {""     if x > 12 {""         break;""     last = x;"" assert_eq!(last, 12);"" println!(\"{last}\");"" A break expression is normally associated with the innermost loop enclosing the"" `break` but a label can be used to specify which enclosing loop is affected."" \'outer: for i in 1..=5 {""     println!(\"outer iteration (i): {i}\");""     \'_inner: for j in 1..=200 {""         println!(\"    inner iteration (j): {j}\");""         if j >= 3 {""             // breaks from inner loop, lets outer loop continue.""             break;""         if i >= 2 {""             // breaks from outer loop, and directly to \"Bye\".""             break \'outer;"" println!(\"Bye.\");"" When associated with `loop`, a break expression may be used to return a value from that loop."" This is only valid with `loop` and not with any other type of loop."" If no value is specified for `break;` it returns `()`."" Every `break` within a loop must return the same type."" let (mut a, mut b) = (1, 1);"" let result = loop {""     if b > 10 {""         break b;""     let c = a + b;""     a = b;""     b = c;"" // first number in Fibonacci sequence over 10:"" assert_eq!(result, 13);"" println!(\"{result}\");"" It is also possible to exit from any *labelled* block returning the value early."" let inputs = vec![\"Cow\", \"Cat\", \"Dog\", \"Snake\", \"Cod\"];"" let mut results = vec![];"" for input in inputs {""     let result = \'filter: {""         if input.len() > 3 {""             break \'filter Err(\"Too long\");""         };""         if !input.contains(\"C\") {""             break \'filter Err(\"No Cs\");""         Ok(input.to_uppercase())""     };""     results.push(result);"" // [Ok(\"COW\"), Ok(\"CAT\"), Err(\"No Cs\"), Err(\"Too long\"), Ok(\"COD\")]"" println!(\"{:?}\", results)"" For more details consult the [Reference on \"break expression\"] and the [Reference on \"break and"" loop values\"]."" [Reference on \"break expression\"]: ../reference/expressions/loop-expr.html#break-expressions"" [Reference on \"break and loop values\"]:"" ../reference/expressions/loop-expr.html#break-and-loop-values"" Compile-time constants, compile-time blocks, compile-time evaluable functions, and raw pointers."" ## Compile-time constants"" Sometimes a certain value is used many times throughout a program, and it can become"" inconvenient to copy it over and over. What\'s more, it\'s not always possible or desirable to"" make it a variable that gets carried around to each function that needs it. In these cases, the"" `const` keyword provides a convenient alternative to code duplication:"" const THING: u32 = 0xABAD1DEA;"" let foo = 123 + THING;"" Constants must be explicitly typed; unlike with `let`, you can\'t ignore their type and let the"" compiler figure it out. Any constant value can be defined in a `const`, which in practice happens"" to be most things that would be reasonable to have in a constant (barring `const fn`s). For"" example, you can\'t have a [`File`] as a `const`."" [`File`]: crate::fs::File"" The only lifetime allowed in a constant is `\'static`, which is the lifetime that encompasses"" all others in a Rust program. For example, if you wanted to define a constant string, it would"" look like this:"" const WORDS: &\'static str = \"hello rust!\";"" Thanks to static lifetime elision, you usually don\'t have to explicitly use `\'static`:"" const WORDS: &str = \"hello convenience!\";"" `const` items look remarkably similar to `static` items, which introduces some confusion as"" to which one should be used at which times. To put it simply, constants are inlined wherever"" they\'re used, making using them identical to simply replacing the name of the `const` with its"" value. Static variables, on the other hand, point to a single location in memory, which all"" accesses share. This means that, unlike with constants, they can\'t have destructors, and act as"" a single value across the entire codebase."" Constants, like statics, should always be in `SCREAMING_SNAKE_CASE`."" For more detail on `const`, see the [Rust Book] or the [Reference]."" ## Compile-time blocks"" The `const` keyword can also be used to define a block of code that is evaluated at compile time."" This is useful for ensuring certain computations are completed before optimizations happen, as well as"" before runtime. For more details, see the [Reference][const-blocks]."" ## Compile-time evaluable functions"" The other main use of the `const` keyword is in `const fn`. This marks a function as being"" callable in the body of a `const` or `static` item and in array initializers (commonly called"" \"const contexts\"). `const fn` are restricted in the set of operations they can perform, to"" ensure that they can be evaluated at compile-time. See the [Reference][const-eval] for more"" detail."" Turning a `fn` into a `const fn` has no effect on run-time uses of that function."" ## Other uses of `const`"" The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const"" T` and `*mut T`. More about `const` as used in raw pointers can be read at the Rust docs for the [pointer primitive]."" [pointer primitive]: pointer"" [Rust Book]: ../book/ch03-01-variables-and-mutability.html#constants"" [Reference]: ../reference/items/constant-items.html"" [const-blocks]: ../reference/expressions/block-expr.html#const-blocks"" [const-eval]: ../reference/const_eval.html"" Skip to the next iteration of a loop."" When `continue` is encountered, the current iteration is terminated, returning control to the"" loop head, typically continuing with the next iteration."" // Printing odd numbers by skipping even ones"" for number in 1..=10 {""     if number % 2 == 0 {""         continue;""     println!(\"{number}\");"" Like `break`, `continue` is normally associated with the innermost enclosing loop, but labels"" may be used to specify the affected loop."" // Print Odd numbers under 30 with unit <= 5"" \'tens: for ten in 0..3 {""     \'_units: for unit in 0..=9 {""         if unit % 2 == 0 {""             continue;""         if unit > 5 {""             continue \'tens;""         println!(\"{}\", ten * 10 + unit);"" See [continue expressions] from the reference for more details."" [continue expressions]: ../reference/expressions/loop-expr.html#continue-expressions"" A Rust binary or library."" The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are"" used to specify a dependency on a crate external to the one it\'s declared in. Crates are the"" fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can"" be read about crates in the [Reference]."" ```rust ignore"" extern crate rand;"" extern crate my_crate as thing;"" extern crate std; // implicitly added to the root of every Rust project"" The `as` keyword can be used to change what the crate is referred to as in your project. If a"" crate name includes a dash, it is implicitly imported with the dashes replaced by underscores."" `crate` can also be used as in conjunction with `pub` to signify that the item it\'s attached to"" is public only to other members of the same crate it\'s in."" pub(crate) use std::io::Error as IoError;"" pub(crate) enum CoolMarkerType { }"" pub struct PublicThing {""     pub(crate) semi_secret_thing: bool,"" `crate` is also used to represent the absolute path of a module, where `crate` refers to the"" root of the current crate. For instance, `crate::foo::bar` refers to the name `bar` inside the"" module `foo`, from anywhere else in the same crate."" [Reference]: ../reference/items/extern-crates.html"" What expression to evaluate when an [`if`] condition evaluates to [`false`]."" `else` expressions are optional. When no else expressions are supplied it is assumed to evaluate"" to the unit type `()`."" The type that the `else` blocks evaluate to must be compatible with the type that the `if` block"" evaluates to."" As can be seen below, `else` must be followed by either: `if`, `if let`, or a block `{}` and it"" will return the value of that expression."" let result = if true == false {""     \"oh no\""" } else if \"something\" == \"other thing\" {""     \"oh dear\""" } else if let Some(200) = \"blarg\".parse::<i32>().ok() {""     \"uh oh\"""     println!(\"Sneaky side effect.\");""     \"phew, nothing\'s broken\""" Here\'s another example but here we do not try and return an expression:"" if true == false {""     println!(\"oh no\");""     println!(\"oh dear\");""     println!(\"uh oh\");""     println!(\"phew, nothing\'s broken\");"" The above is _still_ an expression but it will always evaluate to `()`."" There is possibly no limit to the number of `else` blocks that could follow an `if` expression"" however if you have several then a [`match`] expression might be preferable."" Read more about control flow in the [Rust Book]."" [Rust Book]: ../book/ch03-05-control-flow.html#handling-multiple-conditions-with-else-if"" [`match`]: keyword.match.html"" [`false`]: keyword.false.html"" [`if`]: keyword.if.html"" A type that can be any one of several variants."" Enums in Rust are similar to those of other compiled languages like C, but have important"" differences that make them considerably more powerful. What Rust calls enums are more commonly"" known as [Algebraic Data Types][ADT] if you\'re coming from a functional programming background."" The important detail is that each enum variant can have data to go along with it."" # struct Coord;"" enum SimpleEnum {""     FirstVariant,""     SecondVariant,""     ThirdVariant,"" enum Location {""     Unknown,""     Anonymous,""     Known(Coord),"" enum ComplexEnum {""     Nothing,""     Something(u32),""     LotsOfThings {""         usual_struct_stuff: bool,""         blah: String,"" enum EmptyEnum { }"" The first enum shown is the usual kind of enum you\'d find in a C-style language. The second"" shows off a hypothetical example of something storing location data, with `Coord` being any"" other type that\'s needed, for example a struct. The third example demonstrates the kind of"" data a variant can store, ranging from nothing, to a tuple, to an anonymous struct."" Instantiating enum variants involves explicitly using the enum\'s name as its namespace,"" followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above."" When data follows along with a variant, such as with rust\'s built-in [`Option`] type, the data"" is added as the type describes, for example `Option::Some(123)`. The same follows with"" struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff:"" true, blah: \"hello!\".to_string(), }`. Empty Enums are similar to [`!`] in that they cannot be"" instantiated at all, and are used mainly to mess with the type system in interesting ways."" For more information, take a look at the [Rust Book] or the [Reference]"" [ADT]: https://en.wikipedia.org/wiki/Algebraic_data_type"" [Rust Book]: ../book/ch06-01-defining-an-enum.html"" [Reference]: ../reference/items/enumerations.html"" Link to or import external code."" The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`]"" keyword to make your Rust code aware of other Rust crates in your project, i.e., `extern crate"" lazy_static;`. The other use is in foreign function interfaces (FFI)."" `extern` is used in two different contexts within FFI. The first is in the form of external"" blocks, for declaring function interfaces that Rust code can call foreign code by. This use"" of `extern` is unsafe, since we are asserting to the compiler that all function declarations"" are correct. If they are not, using these items may lead to undefined behavior."" // SAFETY: The function declarations given below are in"" // line with the header files of `my_c_library`."" #[link(name = \"my_c_library\")]"" unsafe extern \"C\" {""     fn my_c_function(x: i32) -> bool;"" This code would attempt to link with `libmy_c_library.so` on unix-like systems and"" `my_c_library.dll` on Windows at runtime, and panic if it can\'t find something to link to. Rust"" code could then use `my_c_function` as if it were any other unsafe Rust function. Working with"" non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs."" The mirror use case of FFI is also done via the `extern` keyword:"" #[unsafe(no_mangle)]"" pub extern \"C\" fn callable_from_c(x: i32) -> bool {""     x % 3 == 0"" If compiled as a dylib, the resulting .so could then be linked to from a C library, and the"" function could be used as if it was from any other library."" For more information on FFI, check the [Rust book] or the [Reference]."" [Rust book]:"" ../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code"" [Reference]: ../reference/items/external-blocks.html"" A value of type [`bool`] representing logical **false**."" `false` is the logical opposite of [`true`]."" See the documentation for [`true`] for more information."" [`true`]: keyword.true.html"" A function or function pointer."" Functions are the primary way code is executed within Rust. Function blocks, usually just"" called functions, can be defined in a variety of different places and be assigned many"" different attributes and modifiers."" Standalone functions that just sit within a module not attached to anything else are common,"" but most functions will end up being inside [`impl`] blocks, either on another type itself, or"" as a trait impl for that type."" fn standalone_function() {""     // code"" pub fn public_thing(argument: bool) -> String {""     # \"\".to_string()"" struct Thing {""     foo: i32,"" impl Thing {""         Self {""             foo: 42,"" In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`,"" functions can also declare a list of type parameters along with trait bounds that they fall"" into."" fn generic_function<T: Clone>(x: T) -> (T, T, T) {""     (x.clone(), x.clone(), x.clone())"" fn generic_where<T>(x: T) -> T""     where T: std::ops::Add<Output = T> + Copy""     x + x + x"" Declaring trait bounds in the angle brackets is functionally identical to using a `where`"" clause. It\'s up to the programmer to decide which works better in each situation, but `where`"" tends to be better when things get longer than one line."" Along with being made public via `pub`, `fn` can also have an [`extern`] added for use in"" FFI."" For more information on the various types of functions and how they\'re used, consult the [Rust"" book] or the [Reference]."" [`impl`]: keyword.impl.html"" [`extern`]: keyword.extern.html"" [Rust book]: ../book/ch03-03-how-functions-work.html"" [Reference]: ../reference/items/functions.html"" Iteration with [`in`], trait implementation with [`impl`], or [higher-ranked trait bounds]"" (`for<\'a>`)."" The `for` keyword is used in many syntactic locations:"" * `for` is used in for-in-loops (see below)."" * `for` is used when implementing traits as in `impl Trait for Type` (see [`impl`] for more info""   on that)."" * `for` is also used for [higher-ranked trait bounds] as in `for<\'a> &\'a T: PartialEq<i32>`."" for-in-loops, or to be more precise, iterator loops, are a simple syntactic sugar over a common"" practice within Rust, which is to loop over anything that implements [`IntoIterator`] until the"" iterator returned by `.into_iter()` returns `None` (or the loop body uses `break`)."" for i in 0..5 {""     println!(\"{}\", i * 2);"" for i in std::iter::repeat(5) {""     println!(\"turns out {i} never stops being 5\");""     break; // would loop forever otherwise"" \'outer: for x in 5..50 {""     for y in 0..10 {""         if x == y {"" As shown in the example above, `for` loops (along with all other loops) can be tagged, using"" similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the"" same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely"" not a goto."" A `for` loop expands as shown:"" # fn code() { }"" # let iterator = 0..2;"" for loop_variable in iterator {""     code()""     let result = match IntoIterator::into_iter(iterator) {""         mut iter => loop {""             match iter.next() {""                 None => break,""                 Some(loop_variable) => { code(); },""             };""     result"" More details on the functionality shown can be seen at the [`IntoIterator`] docs."" For more information on for-loops, see the [Rust book] or the [Reference]."" See also, [`loop`], [`while`]."" [`in`]: keyword.in.html"" [`loop`]: keyword.loop.html"" [`while`]: keyword.while.html"" [higher-ranked trait bounds]: ../reference/trait-bounds.html#higher-ranked-trait-bounds"" ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for"" [Reference]: ../reference/expressions/loop-expr.html#iterator-loops"" Evaluate a block if a condition holds."" `if` is a familiar construct to most programmers, and is the main way you\'ll often do logic in"" your code. However, unlike in most languages, `if` blocks can also act as expressions."" # let rude = true;"" if 1 == 2 {""     println!(\"whoops, mathematics broke\");""     println!(\"everything\'s fine!\");"" let greeting = if rude {""     \"sup nerd.\"""     \"hello, friend!\""" if let Ok(x) = \"123\".parse::<i32>() {""     println!(\"{} double that and you get {}!\", greeting, x * 2);"" Shown above are the three typical forms an `if` block comes in. First is the usual kind of"" thing you\'d see in many languages, with an optional `else` block. Second uses `if` as an"" expression, which is only possible if all branches return the same type. An `if` expression can"" be used everywhere you\'d expect. The third kind of `if` block is an `if let` block, which"" behaves similarly to using a `match` expression:"" if let Some(x) = Some(123) {""     # let _ = x;""     // something else"" match Some(123) {""     Some(x) => {""         // code""         # let _ = x;""     },""     _ => {""         // something else"" Each kind of `if` expression can be mixed and matched as needed."" The `if` keyword is used in one other place in Rust, namely as a part of pattern matching"" itself, allowing patterns such as `Some(x) if x > 200` to be used."" For more information on `if` expressions, see the [Rust book] or the [Reference]."" [Rust book]: ../book/ch03-05-control-flow.html#if-expressions"" [Reference]: ../reference/expressions/if-expr.html"" Implementations of functionality for a type, or a type implementing some functionality."" There are two uses of the keyword `impl`:""  * An `impl` block is an item that is used to implement some functionality for a type.""  * An `impl Trait` in a type-position can be used to designate a type that implements a trait called `Trait`."" # Implementing Functionality for a Type"" The `impl` keyword is primarily used to define implementations on types. Inherent"" implementations are standalone, while trait implementations are used to implement traits for"" types, or other traits."" An implementation consists of definitions of functions and consts. A function defined in an"" `impl` block can be standalone, meaning it would be called like `Vec::new()`. If the function"" takes `self`, `&self`, or `&mut self` as its first argument, it can also be called using"" method-call syntax, a familiar feature to any object-oriented programmer, like `vec.len()`."" ## Inherent Implementations"" struct Example {""     number: i32,"" impl Example {""     fn boo() {""         println!(\"boo! Example::boo() was called!\");""     fn answer(&mut self) {""         self.number += 42;""     fn get_number(&self) -> i32 {""         self.number"" It matters little where an inherent implementation is defined;"" its functionality is in scope wherever its implementing type is."" trait Thingy {""     fn do_thingy(&self);"" impl Thingy for Example {""     fn do_thingy(&self) {""         println!(\"doing a thing! also, number is {}!\", self.number);"" It matters little where a trait implementation is defined;"" its functionality can be brought into scope by importing the trait it implements."" For more information on implementations, see the [Rust book][book1] or the [Reference]."" # Designating a Type that Implements Some Functionality"" The other use of the `impl` keyword is in `impl Trait` syntax, which can be understood to mean"" \"any (or some) concrete type that implements Trait\"."" It can be used as the type of a variable declaration,"" in [argument position](https://rust-lang.github.io/rfcs/1951-expand-impl-trait.html)"" or in [return position](https://rust-lang.github.io/rfcs/3425-return-position-impl-trait-in-traits.html)."" One pertinent use case is in working with closures, which have unnameable types."" fn thing_returning_closure() -> impl Fn(i32) -> bool {""     println!(\"here\'s a closure for you!\");""     |x: i32| x % 3 == 0"" For more information on `impl Trait` syntax, see the [Rust book][book2]."" [book1]: ../book/ch05-03-method-syntax.html"" [Reference]: ../reference/items/implementations.html"" [book2]: ../book/ch10-02-traits.html#returning-types-that-implement-traits"" Iterate over a series of values with [`for`]."" The expression immediately following `in` must implement the [`IntoIterator`] trait."" ## Literal Examples:""    * `for _ in 1..3 {}` - Iterate over an exclusive range up to but excluding 3.""    * `for _ in 1..=3 {}` - Iterate over an inclusive range up to and including 3."" (Read more about [range patterns])"" [`IntoIterator`]: ../book/ch13-04-performance.html"" [range patterns]: ../reference/patterns.html?highlight=range#range-patterns"" [`for`]: keyword.for.html"" The other use of `in` is with the keyword `pub`. It allows users to declare an item as visible"" only within a given scope."" ## Literal Example:""    * `pub(in crate::outer_mod) fn outer_mod_visible_fn() {}` - fn is visible in `outer_mod`"" Starting with the 2018 edition, paths for `pub(in path)` must start with `crate`, `self` or"" `super`. The 2015 edition may also use paths starting with `::` or modules from the crate root."" For more information, see the [Reference]."" [Reference]: ../reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself"" Bind a value to a variable."" The primary use for the `let` keyword is in `let` statements, which are used to introduce a new"" set of variables into the current scope, as given by a pattern."" let thing1: i32 = 100;"" let thing2 = 200 + thing1;"" let mut changing_thing = true;"" changing_thing = false;"" let (part1, part2) = (\"first\", \"second\");""     a: bool,""     b: u64,"" let Example { a, b: _ } = Example {""     a: true,""     b: 10004,"" assert!(a);"" The pattern is most commonly a single variable, which means no pattern matching is done and"" the expression given is bound to the variable. Apart from that, patterns used in `let` bindings"" can be as complicated as needed, given that the pattern is exhaustive. See the [Rust"" book][book1] for more information on pattern matching. The type of the pattern is optionally"" given afterwards, but if left blank is automatically inferred by the compiler if possible."" Variables in Rust are immutable by default, and require the `mut` keyword to be made mutable."" Multiple variables can be defined with the same name, known as shadowing. This doesn\'t affect"" the original variable in any way beyond being unable to directly access it beyond the point of"" shadowing. It continues to remain in scope, getting dropped only when it falls out of scope."" Shadowed variables don\'t need to have the same type as the variables shadowing them."" let shadowing_example = true;"" let shadowing_example = 123.4;"" let shadowing_example = shadowing_example as u32;"" let mut shadowing_example = format!(\"cool! {shadowing_example}\");"" shadowing_example += \" something else!\"; // not shadowing"" Other places the `let` keyword is used include along with [`if`], in the form of `if let`"" expressions. They\'re useful if the pattern being matched isn\'t exhaustive, such as with"" enumerations. `while let` also exists, which runs a loop with a pattern matched value until"" that pattern can\'t be matched."" For more information on the `let` keyword, see the [Rust book][book2] or the [Reference]"" [book1]: ../book/ch06-02-match.html"" [book2]: ../book/ch18-01-all-the-places-for-patterns.html#let-statements"" [Reference]: ../reference/statements.html#let-statements"" Loop indefinitely."" `loop` is used to define the simplest kind of loop supported in Rust. It runs the code inside"" it until the code uses `break` or the program exits.""     println!(\"hello world forever!\");""     # break;"" let mut i = 1;""     println!(\"i is {i}\");""     if i > 100 {""     i *= 2;"" assert_eq!(i, 128);"" Unlike the other kinds of loops in Rust (`while`, `while let`, and `for`), loops can be used as"" expressions that return values via `break`."" let something = loop {""         break i;"" assert_eq!(something, 128);"" Every `break` in a loop has to have the same type. When it\'s not explicitly giving something,"" `break;` returns `()`."" For more information on `loop` and loops in general, see the [Reference]."" See also, [`for`], [`while`]."" [Reference]: ../reference/expressions/loop-expr.html"" Control flow based on pattern matching."" `match` can be used to run code conditionally. Every pattern must"" be handled exhaustively either explicitly or by using wildcards like"" `_` in the `match`. Since `match` is an expression, values can also be"" let opt = Option::None::<usize>;"" let x = match opt {""     Some(int) => int,""     None => 10,"" assert_eq!(x, 10);"" let a_number = Option::Some(10);"" match a_number {""     Some(x) if x <= 5 => println!(\"0 to 5 num = {x}\"),""     Some(x @ 6..=10) => println!(\"6 to 10 num = {x}\"),""     None => panic!(),""     // all other numbers""     _ => panic!(),"" `match` can be used to gain access to the inner members of an enum"" and use them directly."" enum Outer {""     Double(Option<u8>, Option<String>),""     Single(Option<u8>),""     Empty"" let get_inner = Outer::Double(None, Some(String::new()));"" match get_inner {""     Outer::Double(None, Some(st)) => println!(\"{st}\"),""     Outer::Single(opt) => println!(\"{opt:?}\"),"" For more information on `match` and matching in general, see the [Reference]."" [Reference]: ../reference/expressions/match-expr.html"" Organize code into [modules]."" Use `mod` to create new [modules] to encapsulate code, including other"" modules:"" mod foo {""     mod bar {""         type MyType = (u8, u8);""         fn baz() {}"" Like [`struct`]s and [`enum`]s, a module and its content are private by"" default, inaccessible to code outside of the module."" To learn more about allowing access, see the documentation for the [`pub`]"" keyword."" [`enum`]: keyword.enum.html"" [`pub`]: keyword.pub.html"" [`struct`]: keyword.struct.html"" [modules]: ../reference/items/modules.html"" Capture a [closure]\'s environment by value."" `move` converts any variables captured by reference or mutable reference"" to variables captured by value."" let data = vec![1, 2, 3];"" let closure = move || println!(\"captured {data:?} by value\");"" // data is no longer available, it is owned by the closure"" Note: `move` closures may still implement [`Fn`] or [`FnMut`], even though"" they capture variables by `move`. This is because the traits implemented by"" a closure type are determined by *what* the closure does with captured"" values, not *how* it captures them:"" fn create_fn() -> impl Fn() {""     let text = \"Fn\".to_owned();""     move || println!(\"This is a: {text}\")"" let fn_plain = create_fn();"" fn_plain();"" `move` is often used when [threads] are involved."" std::thread::spawn(move || {""     println!(\"captured {data:?} by value\")"" }).join().unwrap();"" // data was moved to the spawned thread, so we cannot use it here"" `move` is also valid before an async block."" let capture = \"hello\".to_owned();"" let block = async move {""     println!(\"rust says {capture} from async block\");"" For more information on the `move` keyword, see the [closures][closure] section"" of the Rust book or the [threads] section."" [closure]: ../book/ch13-01-closures.html"" [threads]: ../book/ch16-01-threads.html#using-move-closures-with-threads"" A mutable variable, reference, or pointer."" `mut` can be used in several situations. The first is mutable variables,"" which can be used anywhere you can bind a value to a variable name. Some"" examples:"" // A mutable variable in the parameter list of a function."" fn foo(mut x: u8, y: u8) -> u8 {""     x += y;""     x"" // Modifying a mutable variable."" # #[allow(unused_assignments)]"" let mut a = 5;"" a = 6;"" assert_eq!(foo(3, 4), 7);"" assert_eq!(a, 6);"" The second is mutable references. They can be created from `mut` variables"" and must be unique: no other variables can have a mutable reference, nor a"" shared reference."" // Taking a mutable reference."" fn push_two(v: &mut Vec<u8>) {""     v.push(2);"" // A mutable reference cannot be taken to a non-mutable variable."" let mut v = vec![0, 1];"" // Passing a mutable reference."" push_two(&mut v);"" assert_eq!(v, vec![0, 1, 2]);"" ```rust,compile_fail,E0502"" let mut_ref_v = &mut v;"" # #[allow(unused)]"" let ref_v = &v;"" mut_ref_v.push(2);"" Mutable raw pointers work much like mutable references, with the added"" possibility of not pointing to a valid object. The syntax is `*mut Type`."" More information on mutable references and pointers can be found in the [Reference]."" [Reference]: ../reference/types/pointer.html#mutable-references-mut"" Make an item visible to others."" The keyword `pub` makes any module, function, or data structure accessible from inside"" of external modules. The `pub` keyword may also be used in a `use` declaration to re-export"" an identifier from a namespace."" For more information on the `pub` keyword, please see the visibility section"" of the [reference] and for some examples, see [Rust by Example]."" [reference]:../reference/visibility-and-privacy.html?highlight=pub#visibility-and-privacy"" [Rust by Example]:../rust-by-example/mod/visibility.html"" Bind by reference during pattern matching."" `ref` annotates pattern bindings to make them borrow rather than move."" It is **not** a part of the pattern as far as matching is concerned: it does"" not affect *whether* a value is matched, only *how* it is matched."" By default, [`match`] statements consume all they can, which can sometimes"" be a problem, when you don\'t really need the value to be moved and owned:"" ```compile_fail,E0382"" let maybe_name = Some(String::from(\"Alice\"));"" // The variable \'maybe_name\' is consumed here ..."" match maybe_name {""     Some(n) => println!(\"Hello, {n}\"),""     _ => println!(\"Hello, world\"),"" // ... and is now unavailable."" println!(\"Hello again, {}\", maybe_name.unwrap_or(\"world\".into()));"" Using the `ref` keyword, the value is only borrowed, not moved, making it"" available for use after the [`match`] statement:"" // Using `ref`, the value is borrowed, not moved ...""     Some(ref n) => println!(\"Hello, {n}\"),"" // ... so it\'s available here!"" # `&` vs `ref`"" - `&` denotes that your pattern expects a reference to an object. Hence `&`"" is a part of said pattern: `&Foo` matches different objects than `Foo` does."" - `ref` indicates that you want a reference to an unpacked value. It is not"" matched against: `Foo(ref foo)` matches the same objects as `Foo(foo)`."" See also the [Reference] for more information."" [Reference]: ../reference/patterns.html#identifier-patterns"" Returns a value from a function."" A `return` marks the end of an execution path in a function:"" fn foo() -> i32 {""     return 3;"" assert_eq!(foo(), 3);"" `return` is not needed when the returned value is the last expression in the"" function. In this case the `;` is omitted:""     3"" `return` returns from the function immediately (an \"early return\"):"" use std::fs::File;"" use std::io::{Error, ErrorKind, Read, Result};"" fn main() -> Result<()> {""     let mut file = match File::open(\"foo.txt\") {""         Ok(f) => f,""         Err(e) => return Err(e),""     let mut contents = String::new();""     let size = match file.read_to_string(&mut contents) {""         Ok(s) => s,""     if contents.contains(\"impossible!\") {""         return Err(Error::new(ErrorKind::Other, \"oh no!\"));""     if size > 9000 {""         return Err(Error::new(ErrorKind::Other, \"over 9000!\"));""     assert_eq!(contents, \"Hello, world!\");""     Ok(())"" Within [closures] and [`async`] blocks, `return` returns a value from within the closure or"" `async` block, not from the parent function:""     let closure = || {""         return 5;""     let future = async {""         return 10;""     return 15;"" assert_eq!(foo(), 15);"" [closures]: ../book/ch13-01-closures.html"" [`async`]: ../std/keyword.async.html"" Perform a tail-call of a function."" <div class=\"warning\">"" `feature(explicit_tail_calls)` is currently incomplete and may not work properly."" </div>"" When tail calling a function, instead of its stack frame being added to the"" stack, the stack frame of the caller is directly replaced with the callee\'s."" This means that as long as a loop in a call graph only uses tail calls, the"" stack growth will be bounded."" This is useful for writing functional-style code (since it prevents recursion"" from exhausting resources) or for code optimization (since a tail call"" *might* be cheaper than a normal call, tail calls can be used in a similar"" manner to computed goto)."" Example of using `become` to implement functional-style `fold`:"" #![feature(explicit_tail_calls)]"" #![expect(incomplete_features)]"" fn fold<T: Copy, S>(slice: &[T], init: S, f: impl Fn(S, T) -> S) -> S {""     match slice {""         // without `become`, on big inputs this could easily overflow the""         // stack. using a tail call guarantees that the stack will not grow unboundedly""         [first, rest @ ..] => become fold(rest, f(init, *first), f),""         [] => init,"" Compilers can already perform \"tail call optimization\" -- they can replace normal"" calls with tail calls, although there are no guarantees that this will be done."" However, to perform TCO, the call needs to be the last thing that happens"" in the functions and be returned from it. This requirement is often broken"" by drop code for locals, which is run after computing the return expression:"" fn example() {""     let string = \"meow\".to_owned();""     println!(\"{string}\");""     return help(); // this is *not* the last thing that happens in `example`..."" // ... because it is desugared to this:"" fn example_desugared() {""     let tmp = help();""     drop(string);""     return tmp;"" fn help() {}"" For this reason, `become` also changes the drop order, such that locals are"" dropped *before* evaluating the call."" In order to guarantee that the compiler can perform a tail call, `become`"" currently has these requirements:"" 1. callee and caller must have the same ABI, arguments, and return type"" 2. callee and caller must not have varargs"" 3. caller must not be marked with `#[track_caller]`""    - callee is allowed to be marked with `#[track_caller]` as otherwise""      adding `#[track_caller]` would be a breaking change. if callee is""      marked with `#[track_caller]` a tail call is not guaranteed."" 4. callee and caller cannot be a closure""    (unless it\'s coerced to a function pointer)"" It is possible to tail-call a function pointer:"" #[derive(Copy, Clone)]"" enum Inst { Inc, Dec }"" fn dispatch(stream: &[Inst], state: u32) -> u32 {""     const TABLE: &[fn(&[Inst], u32) -> u32] = &[increment, decrement];""     match stream {""         [inst, rest @ ..] => become TABLE[*inst as usize](rest, state),""         [] => state,"" fn increment(stream: &[Inst], state: u32) -> u32 {""     become dispatch(stream, state + 1)"" fn decrement(stream: &[Inst], state: u32) -> u32 {""     become dispatch(stream, state - 1)"" let program = &[Inst::Inc, Inst::Inc, Inst::Dec, Inst::Inc];"" assert_eq!(dispatch(program, 0), 2);"" The receiver of a method, or the current module."" `self` is used in two situations: referencing the current module and marking"" the receiver of a method."" In paths, `self` can be used to refer to the current module, either in a"" [`use`] statement or in a path to access an element:"" # #![allow(unused_imports)]"" use std::io::{self, Read};"" Is functionally the same as:"" use std::io;"" use std::io::Read;"" Using `self` to access an element in the current module:"" # #![allow(dead_code)]"" fn foo() {}"" fn bar() {""     self::foo()"" `self` as the current receiver for a method allows to omit the parameter"" type most of the time. With the exception of this particularity, `self` is"" used much like any other parameter:"" struct Foo(i32);""     // No `self`.""     fn new() -> Self {""         Self(0)""     // Consuming `self`.""     fn consume(self) -> Self {""         Self(self.0 + 1)""     // Borrowing `self`.""     fn borrow(&self) -> &i32 {""         &self.0""     // Borrowing `self` mutably.""     fn borrow_mut(&mut self) -> &mut i32 {""         &mut self.0"" // This method must be called with a `Type::` prefix."" let foo = Foo::new();"" assert_eq!(foo.0, 0);"" // Those two calls produces the same result."" let foo = Foo::consume(foo);"" assert_eq!(foo.0, 1);"" let foo = foo.consume();"" assert_eq!(foo.0, 2);"" // Borrowing is handled automatically with the second syntax."" let borrow_1 = Foo::borrow(&foo);"" let borrow_2 = foo.borrow();"" assert_eq!(borrow_1, borrow_2);"" // Borrowing mutably is handled automatically too with the second syntax."" let mut foo = Foo::new();"" *Foo::borrow_mut(&mut foo) += 1;"" *foo.borrow_mut() += 1;"" Note that this automatic conversion when calling `foo.method()` is not"" limited to the examples above. See the [Reference] for more information."" [Reference]: ../reference/items/associated-items.html#methods"" The implementing type within a [`trait`] or [`impl`] block, or the current type within a type"" definition."" Within a type definition:"" struct Node {""     elem: i32,""     // `Self` is a `Node` here.""     next: Option<Box<Self>>,"" In an [`impl`] block:"" assert_eq!(Foo::new().0, Foo(0).0);"" Generic parameters are implicit with `Self`:"" struct Wrap<T> {""     elem: T,"" impl<T> Wrap<T> {""     fn new(elem: T) -> Self {""         Self { elem }"" In a [`trait`] definition and related [`impl`] block:"" trait Example {""     fn example() -> Self;"" impl Example for Foo {""     fn example() -> Self {""         Self(42)"" assert_eq!(Foo::example().0, Foo(42).0);"" [`trait`]: keyword.trait.html"" A static item is a value which is valid for the entire duration of your"" program (a `\'static` lifetime)."" On the surface, `static` items seem very similar to [`const`]s: both contain"" a value, both require type annotations and both can only be initialized with"" constant functions and values. However, `static`s are notably different in"" that they represent a location in memory. That means that you can have"" references to `static` items and potentially even modify them, making them"" essentially global variables."" Static items do not call [`drop`] at the end of the program."" There are two types of `static` items: those declared in association with"" the [`mut`] keyword and those without."" Static items cannot be moved:"" ```rust,compile_fail,E0507"" static VEC: Vec<u32> = vec![];"" fn move_vec(v: Vec<u32>) -> Vec<u32> {""     v"" // This line causes an error"" move_vec(VEC);"" # Simple `static`s"" Accessing non-[`mut`] `static` items is considered safe, but some"" restrictions apply. Most notably, the type of a `static` value needs to"" implement the [`Sync`] trait, ruling out interior mutability containers"" like [`RefCell`]. See the [Reference] for more information."" static FOO: [i32; 5] = [1, 2, 3, 4, 5];"" let r1 = &FOO as *const _;"" let r2 = &FOO as *const _;"" // With a strictly read-only static, references will have the same address"" assert_eq!(r1, r2);"" // A static item can be used just like a variable in many cases"" println!(\"{FOO:?}\");"" # Mutable `static`s"" If a `static` item is declared with the [`mut`] keyword, then it is allowed"" to be modified by the program. However, accessing mutable `static`s can"" cause undefined behavior in a number of ways, for example due to data races"" in a multithreaded context. As such, all accesses to mutable `static`s"" require an [`unsafe`] block."" When possible, it\'s often better to use a non-mutable `static` with an"" interior mutable type such as [`Mutex`], [`OnceLock`], or an [atomic]."" Despite their unsafety, mutable `static`s are necessary in many contexts:"" they can be used to represent global state shared by the whole program or in"" [`extern`] blocks to bind to variables from C libraries."" In an [`extern`] block:"" ```rust,no_run""     static mut ERROR_MESSAGE: *mut std::os::raw::c_char;"" Mutable `static`s, just like simple `static`s, have some restrictions that"" apply to them. See the [Reference] for more information."" [`const`]: keyword.const.html"" [`mut`]: keyword.mut.html"" [`unsafe`]: keyword.unsafe.html"" [`Mutex`]: sync::Mutex"" [`OnceLock`]: sync::OnceLock"" [`RefCell`]: cell::RefCell"" [atomic]: sync::atomic"" [Reference]: ../reference/items/static-items.html"" A type that is composed of other types."" Structs in Rust come in three flavors: Structs with named fields, tuple structs, and unit"" structs."" struct Regular {""     field1: f32,""     field2: String,""     pub field3: bool"" struct Tuple(u32, String);"" struct Unit;"" Regular structs are the most commonly used. Each field defined within them has a name and a"" type, and once defined can be accessed using `example_struct.field` syntax. The fields of a"" struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding"" `pub` to a field makes it visible to code in other modules, as well as allowing it to be"" directly accessed and modified."" Tuple structs are similar to regular structs, but its fields have no names. They are used like"" tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax. For accessing"" individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`,"" etc, starting at zero."" Unit structs are most commonly used as marker. They have a size of zero bytes, but unlike empty"" enums they can be instantiated, making them isomorphic to the unit type `()`. Unit structs are"" useful when you need to implement a trait on something, but don\'t need to store any data inside"" it."" # Instantiation"" Structs can be instantiated in different ways, all of which can be mixed and"" matched as needed. The most common way to make a new struct is via a constructor method such as"" `new()`, but when that isn\'t available (or you\'re writing the constructor itself), struct"" literal syntax is used:"" # struct Foo { field1: f32, field2: String, etc: bool }"" let example = Foo {""     field1: 42.0,""     field2: \"blah\".to_string(),""     etc: true,"" It\'s only possible to directly instantiate a struct using struct literal syntax when all of its"" fields are visible to you."" There are a handful of shortcuts provided to make writing constructors more convenient, most"" common of which is the Field Init shorthand. When there is a variable and a field of the same"" name, the assignment can be simplified from `field: field` into simply `field`. The following"" example of a hypothetical constructor demonstrates this:"" struct User {""     name: String,""     admin: bool,"" impl User {""     pub fn new(name: String) -> Self {""             name,""             admin: false,"" Another shortcut for struct instantiation is available, used when you need to make a new"" struct that has the same values as most of a previous struct of the same type, called struct"" update syntax:"" # struct Foo { field1: String, field2: () }"" # let thing = Foo { field1: \"\".to_string(), field2: () };"" let updated_thing = Foo {""     field1: \"a new value\".to_string(),""     ..thing"" Tuple structs are instantiated in the same way as tuples themselves, except with the struct\'s"" name as a prefix: `Foo(123, false, 0.1)`."" Empty structs are instantiated with just their name, and don\'t need anything else. `let thing ="" EmptyStruct;`"" # Style conventions"" Structs are always written in UpperCamelCase, with few exceptions. While the trailing comma on a"" struct\'s list of fields can be omitted, it\'s usually kept for convenience in adding and"" removing fields down the line."" For more information on structs, take a look at the [Rust Book][book] or the"" [Reference][reference]."" [`PhantomData`]: marker::PhantomData"" [book]: ../book/ch05-01-defining-structs.html"" [reference]: ../reference/items/structs.html"" The parent of the current [module]."" mod a {""     pub fn foo() {}"" mod b {""     pub fn foo() {""         super::a::foo(); // call a\'s foo function"" It is also possible to use `super` multiple times: `super::super::foo`,"" going up the ancestor chain."" See the [Reference] for more information."" [module]: ../reference/items/modules.html"" [Reference]: ../reference/paths.html#super"" A common interface for a group of types."" A `trait` is like an interface that data types can implement. When a type"" implements a trait it can be treated abstractly as that trait using generics"" or trait objects."" Traits can be made up of three varieties of associated items:"" - functions and methods"" - types"" - constants"" Traits may also contain additional type parameters. Those type parameters"" or the trait itself can be constrained by other traits."" Traits can serve as markers or carry other logical semantics that"" aren\'t expressed through their items. When a type implements that"" trait it is promising to uphold its contract. [`Send`] and [`Sync`] are two"" such marker traits present in the standard library."" See the [Reference][Ref-Traits] for a lot more information on traits."" Traits are declared using the `trait` keyword. Types can implement them"" using [`impl`] `Trait` [`for`] `Type`:"" trait Zero {""     const ZERO: Self;""     fn is_zero(&self) -> bool;"" impl Zero for i32 {""     const ZERO: Self = 0;""     fn is_zero(&self) -> bool {""         *self == Self::ZERO"" assert_eq!(i32::ZERO, 0);"" assert!(i32::ZERO.is_zero());"" assert!(!4.is_zero());"" With an associated type:"" trait Builder {""     type Built;""     fn build(&self) -> Self::Built;"" Traits can be generic, with constraints or without:"" trait MaybeFrom<T> {""     fn maybe_from(value: T) -> Option<Self>""     where""         Self: Sized;"" Traits can build upon the requirements of other traits. In the example"" below `Iterator` is a **supertrait** and `ThreeIterator` is a **subtrait**:"" trait ThreeIterator: Iterator {""     fn next_three(&mut self) -> Option<[Self::Item; 3]>;"" Traits can be used in functions, as parameters:"" fn debug_iter<I: Iterator>(it: I) where I::Item: std::fmt::Debug {""     for elem in it {""         println!(\"{elem:#?}\");"" // u8_len_1, u8_len_2 and u8_len_3 are equivalent"" fn u8_len_1(val: impl Into<Vec<u8>>) -> usize {""     val.into().len()"" fn u8_len_2<T: Into<Vec<u8>>>(val: T) -> usize {"" fn u8_len_3<T>(val: T) -> usize"" where""     T: Into<Vec<u8>>,"" Or as return types:"" fn from_zero_to(v: u8) -> impl Iterator<Item = u8> {""     (0..v).into_iter()"" The use of the [`impl`] keyword in this position allows the function writer"" to hide the concrete type as an implementation detail which can change"" without breaking user\'s code."" # Trait objects"" A *trait object* is an opaque value of another type that implements a set of"" traits. A trait object implements all specified traits as well as their"" supertraits (if any)."" The syntax is the following: `dyn BaseTrait + AutoTrait1 + ... AutoTraitN`."" Only one `BaseTrait` can be used so this will not compile:"" ```rust,compile_fail,E0225"" trait A {}"" trait B {}"" let _: Box<dyn A + B>;"" Neither will this, which is a syntax error:"" ```rust,compile_fail"" let _: Box<dyn A + dyn B>;"" On the other hand, this is correct:"" let _: Box<dyn A + Send + Sync>;"" The [Reference][Ref-Trait-Objects] has more information about trait objects,"" their limitations and the differences between editions."" # Unsafe traits"" Some traits may be unsafe to implement. Using the [`unsafe`] keyword in"" front of the trait\'s declaration is used to mark this:"" unsafe trait UnsafeTrait {}"" unsafe impl UnsafeTrait for i32 {}"" # Differences between the 2015 and 2018 editions"" In the 2015 edition the parameters pattern was not needed for traits:"" ```rust,edition2015"" # #![allow(anonymous_parameters)]"" trait Tr {""     fn f(i32);"" This behavior is no longer valid in edition 2018."" [Ref-Traits]: ../reference/items/traits.html"" [Ref-Trait-Objects]: ../reference/types/trait-object.html"" A value of type [`bool`] representing logical **true**."" Logically `true` is not equal to [`false`]."" ## Control structures that check for **true**"" Several of Rust\'s control structures will check for a `bool` condition evaluating to **true**.""   * The condition in an [`if`] expression must be of type `bool`.""     Whenever that condition evaluates to **true**, the `if` expression takes""     on the value of the first block. If however, the condition evaluates""     to `false`, the expression takes on value of the `else` block if there is one.""   * [`while`] is another control flow construct expecting a `bool`-typed condition.""     As long as the condition evaluates to **true**, the `while` loop will continually""     evaluate its associated block.""   * [`match`] arms can have guard clauses on them."" [`match`]: ../reference/expressions/match-expr.html#match-guards"" Define an [alias] for an existing type."" The syntax is `type Name = ExistingType;`."" `type` does **not** create a new type:"" type Meters = u32;"" type Kilograms = u32;"" let m: Meters = 3;"" let k: Kilograms = 3;"" assert_eq!(m, k);"" A type can be generic:"" # use std::sync::{Arc, Mutex};"" type ArcMutex<T> = Arc<Mutex<T>>;"" In traits, `type` is used to declare an [associated type]:"" trait Iterator {""     // associated type declaration""     type Item;""     fn next(&mut self) -> Option<Self::Item>;"" struct Once<T>(Option<T>);"" impl<T> Iterator for Once<T> {""     // associated type definition""     type Item = T;""     fn next(&mut self) -> Option<Self::Item> {""         self.0.take()"" [associated type]: ../reference/items/associated-items.html#associated-types"" [alias]: ../reference/items/type-aliases.html"" Code or interfaces whose [memory safety] cannot be verified by the type"" system."" The `unsafe` keyword has two uses:"" - to declare the existence of contracts the compiler can\'t check (`unsafe fn` and `unsafe"" trait`),"" - and to declare that a programmer has checked that these contracts have been upheld (`unsafe"" {}` and `unsafe impl`, but also `unsafe fn` -- see below)."" # Unsafe abilities"" **No matter what, Safe Rust can\'t cause Undefined Behavior**. This is"" referred to as [soundness]: a well-typed program actually has the desired"" properties. The [Nomicon][nomicon-soundness] has a more detailed explanation"" on the subject."" To ensure soundness, Safe Rust is restricted enough that it can be"" automatically checked. Sometimes, however, it is necessary to write code"" that is correct for reasons which are too clever for the compiler to"" understand. In those cases, you need to use Unsafe Rust."" Here are the abilities Unsafe Rust has in addition to Safe Rust:"" - Dereference [raw pointers]"" - Implement `unsafe` [`trait`]s"" - Call `unsafe` functions"" - Mutate [`static`]s (including [`extern`]al ones)"" - Access fields of [`union`]s"" However, this extra power comes with extra responsibilities: it is now up to"" you to ensure soundness. The `unsafe` keyword helps by clearly marking the"" pieces of code that need to worry about this."" ## The different meanings of `unsafe`"" Not all uses of `unsafe` are equivalent: some are here to mark the existence"" of a contract the programmer must check, others are to say \"I have checked"" the contract, go ahead and do this\". The following"" [discussion on Rust Internals] has more in-depth explanations about this but"" here is a summary of the main points:"" - `unsafe fn`: calling this function means abiding by a contract the"" compiler cannot enforce."" - `unsafe trait`: implementing the [`trait`] means abiding by a"" contract the compiler cannot enforce."" - `unsafe {}`: the contract necessary to call the operations inside the"" block has been checked by the programmer and is guaranteed to be respected."" - `unsafe impl`: the contract necessary to implement the trait has been"" checked by the programmer and is guaranteed to be respected."" See the [Rustonomicon] and the [Reference] for more information."" ## Marking elements as `unsafe`"" `unsafe` can be used on functions. Note that functions and statics declared"" in [`extern`] blocks are implicitly marked as `unsafe` (but not functions"" declared as `extern \"something\" fn ...`). Mutable statics are always unsafe,"" wherever they are declared. Methods can also be declared as `unsafe`:"" static mut FOO: &str = \"hello\";"" unsafe fn unsafe_fn() {}""     fn unsafe_extern_fn();""     static BAR: *mut u32;"" trait SafeTraitWithUnsafeMethod {""     unsafe fn unsafe_method(&self);"" struct S;"" impl S {""     unsafe fn unsafe_method_on_struct() {}"" Traits can also be declared as `unsafe`:"" Since `unsafe fn` and `unsafe trait` indicate that there is a safety"" contract that the compiler cannot enforce, documenting it is important. The"" standard library has many examples of this, like the following which is an"" extract from [`Vec::set_len`]. The `# Safety` section explains the contract"" that must be fulfilled to safely call the function."" ```rust,ignore (stub-to-show-doc-example)"" /// Forces the length of the vector to `new_len`."" ///"" /// This is a low-level operation that maintains none of the normal"" /// invariants of the type. Normally changing the length of a vector"" /// is done using one of the safe operations instead, such as"" /// `truncate`, `resize`, `extend`, or `clear`."" /// # Safety"" /// - `new_len` must be less than or equal to `capacity()`."" /// - The elements at `old_len..new_len` must be initialized."" pub unsafe fn set_len(&mut self, new_len: usize)"" ## Using `unsafe {}` blocks and `impl`s"" Performing `unsafe` operations requires an `unsafe {}` block:"" #![deny(unsafe_op_in_unsafe_fn)]"" /// Dereference the given pointer."" /// `ptr` must be aligned and must not be dangling."" unsafe fn deref_unchecked(ptr: *const i32) -> i32 {""     // SAFETY: the caller is required to ensure that `ptr` is aligned and dereferenceable.""     unsafe { *ptr }"" let a = 3;"" let b = &a as *const _;"" // SAFETY: `a` has not been dropped and references are always aligned,"" // so `b` is a valid address."" unsafe { assert_eq!(*b, deref_unchecked(b)); };"" ## `unsafe` and traits"" The interactions of `unsafe` and traits can be surprising, so let us contrast the"" two combinations of safe `fn` in `unsafe trait` and `unsafe fn` in safe trait using two"" /// `make_even` must return an even number."" unsafe trait MakeEven {""     fn make_even(&self) -> i32;"" // SAFETY: Our `make_even` always returns something even."" unsafe impl MakeEven for i32 {""     fn make_even(&self) -> i32 {""         self << 1"" fn use_make_even(x: impl MakeEven) {""     if x.make_even() % 2 == 1 {""         // SAFETY: this can never happen, because all `MakeEven` implementations""         // ensure that `make_even` returns something even.""         unsafe { std::hint::unreachable_unchecked() };"" Note how the safety contract of the trait is upheld by the implementation, and is itself used to"" uphold the safety contract of the unsafe function `unreachable_unchecked` called by"" `use_make_even`. `make_even` itself is a safe function because its *callers* do not have to"" worry about any contract, only the *implementation* of `MakeEven` is required to uphold a"" certain contract. `use_make_even` is safe because it can use the promise made by `MakeEven`"" implementations to uphold the safety contract of the `unsafe fn unreachable_unchecked` it calls."" It is also possible to have `unsafe fn` in a regular safe `trait`:"" # #![feature(never_type)]"" trait Indexable {""     const LEN: usize;""     /// # Safety""     ///""     /// The caller must ensure that `idx < LEN`.""     unsafe fn idx_unchecked(&self, idx: usize) -> i32;"" // The implementation for `i32` doesn\'t need to do any contract reasoning."" impl Indexable for i32 {""     const LEN: usize = 1;""     /// See `Indexable` for the safety contract.""     unsafe fn idx_unchecked(&self, idx: usize) -> i32 {""         debug_assert_eq!(idx, 0);"" // The implementation for arrays exploits the function contract to"" // make use of `get_unchecked` on slices and avoid a run-time check."" impl Indexable for [i32; 42] {""     const LEN: usize = 42;""         // SAFETY: As per this trait\'s documentation, the caller ensures""         // that `idx < 42`.""         unsafe { *self.get_unchecked(idx) }"" // The implementation for the never type declares a length of 0,"" // which means `idx_unchecked` can never be called."" impl Indexable for ! {""     const LEN: usize = 0;""         // that `idx < 0`, which is impossible, so this is dead code.""         unsafe { std::hint::unreachable_unchecked() }"" fn use_indexable<I: Indexable>(x: I, idx: usize) -> i32 {""     if idx < I::LEN {""         // SAFETY: We have checked that `idx < I::LEN`.""         unsafe { x.idx_unchecked(idx) }""         panic!(\"index out-of-bounds\")"" This time, `use_indexable` is safe because it uses a run-time check to discharge the safety"" contract of `idx_unchecked`. Implementing `Indexable` is safe because when writing"" `idx_unchecked`, we don\'t have to worry: our *callers* need to discharge a proof obligation"" (like `use_indexable` does), but the *implementation* of `get_unchecked` has no proof obligation"" to contend with. Of course, the implementation may choose to call other unsafe operations, and"" then it needs an `unsafe` *block* to indicate it discharged the proof obligations of its"" callees. For that purpose it can make use of the contract that all its callers must uphold --"" the fact that `idx < LEN`."" Note that unlike normal `unsafe fn`, an `unsafe fn` in a trait implementation does not get to"" just pick an arbitrary safety contract! It *has* to use the safety contract defined by the trait"" (or one with weaker preconditions)."" Formally speaking, an `unsafe fn` in a trait is a function with *preconditions* that go beyond"" those encoded by the argument types (such as `idx < LEN`), whereas an `unsafe trait` can declare"" that some of its functions have *postconditions* that go beyond those encoded in the return type"" (such as returning an even integer). If a trait needs a function with both extra precondition"" and extra postcondition, then it needs an `unsafe fn` in an `unsafe trait`."" [`static`]: keyword.static.html"" [`union`]: keyword.union.html"" [raw pointers]: ../reference/types/pointer.html"" [memory safety]: ../book/ch19-01-unsafe-rust.html"" [Rustonomicon]: ../nomicon/index.html"" [nomicon-soundness]: ../nomicon/safe-unsafe-meaning.html"" [soundness]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#soundness-of-code--of-a-library"" [Reference]: ../reference/unsafety.html"" [discussion on Rust Internals]: https://internals.rust-lang.org/t/what-does-unsafe-mean/6696"" Import or rename items from other crates or modules, use values under ergonomic clones"" semantic, or specify precise capturing with `use<..>`."" ## Importing items"" The `use` keyword is employed to shorten the path required to refer to a module item."" The keyword may appear in modules, blocks, and even functions, typically at the top."" The most basic usage of the keyword is `use path::to::item;`,"" though a number of convenient shortcuts are supported:""   * Simultaneously binding a list of paths with a common prefix,""     using the glob-like brace syntax `use a::b::{c, d, e::f, g::h::i};`""   * Simultaneously binding a list of paths with a common prefix and their common parent module,""     using the [`self`] keyword, such as `use a::b::{self, c, d::e};`""   * Rebinding the target name as a new local name, using the syntax `use p::q::r as x;`.""     This can also be used with the last two features: `use a::b::{self as ab, c as abc}`.""   * Binding all paths matching a given prefix,""     using the asterisk wildcard syntax `use a::b::*;`.""   * Nesting groups of the previous features multiple times,""     such as `use a::b::{self as ab, c, d::{*, e::f}};`""   * Reexporting with visibility modifiers such as `pub use a::b;`""   * Importing with `_` to only import the methods of a trait without binding it to a name""     (to avoid conflict for example): `use ::std::io::Read as _;`."" Using path qualifiers like [`crate`], [`super`] or [`self`] is supported: `use crate::a::b;`."" Note that when the wildcard `*` is used on a type, it does not import its methods (though"" for `enum`s it imports the variants, as shown in the example below)."" ```compile_fail,edition2018"" enum ExampleEnum {""     VariantA,""     VariantB,"" impl ExampleEnum {""         Self::VariantA"" use ExampleEnum::*;"" // Compiles."" let _ = VariantA;"" // Does not compile!"" let n = new();"" For more information on `use` and paths in general, see the [Reference][ref-use-decls]."" The differences about paths and the `use` keyword between the 2015 and 2018 editions"" can also be found in the [Reference][ref-use-decls]."" ## Precise capturing"" The `use<..>` syntax is used within certain `impl Trait` bounds to control which generic"" parameters are captured. This is important for return-position `impl Trait` (RPIT) types,"" as it affects borrow checking by controlling which generic parameters can be used in the"" hidden type."" For example, the following function demonstrates an error without precise capturing in"" Rust 2021 and earlier editions:"" ```rust,compile_fail,edition2021"" fn f(x: &()) -> impl Sized { x }"" By using `use<\'_>` for precise capturing, it can be resolved:"" fn f(x: &()) -> impl Sized + use<\'_> { x }"" This syntax specifies that the elided lifetime be captured and therefore available for"" use in the hidden type."" In Rust 2024, opaque types automatically capture all lifetime parameters in scope."" `use<..>` syntax serves as an important way of opting-out of that default."" For more details about precise capturing, see the [Reference][ref-impl-trait]."" ## Ergonomic clones"" Use a values, copying its content if the value implements `Copy`, cloning the contents if the"" value implements `UseCloned` or moving it otherwise."" [`self`]: keyword.self.html"" [`super`]: keyword.super.html"" [ref-use-decls]: ../reference/items/use-declarations.html"" [ref-impl-trait]: ../reference/types/impl-trait.html"" Add constraints that must be upheld to use an item."" `where` allows specifying constraints on lifetime and generic parameters."" The [RFC] introducing `where` contains detailed information about the"" `where` can be used for constraints with traits:"" fn new<T: Default>() -> T {""     T::default()"" fn new_where<T>() -> T""     T: Default,"" assert_eq!(0.0, new());"" assert_eq!(0.0, new_where());"" assert_eq!(0, new());"" assert_eq!(0, new_where());"" `where` can also be used for lifetimes."" This compiles because `longer` outlives `shorter`, thus the constraint is"" respected:"" fn select<\'short, \'long>(s1: &\'short str, s2: &\'long str, second: bool) -> &\'short str""     \'long: \'short,""     if second { s2 } else { s1 }"" let outer = String::from(\"Long living ref\");"" let longer = &outer;""     let inner = String::from(\"Short living ref\");""     let shorter = &inner;""     assert_eq!(select(shorter, longer, false), shorter);""     assert_eq!(select(shorter, longer, true), longer);"" On the other hand, this will not compile because the `where \'b: \'a` clause"" is missing: the `\'b` lifetime is not known to live at least as long as `\'a`"" which means this function cannot ensure it always returns a valid reference:"" fn select<\'a, \'b>(s1: &\'a str, s2: &\'b str, second: bool) -> &\'a str"" `where` can also be used to express more complicated constraints that cannot"" be written with the `<T: Trait>` syntax:"" fn first_or_default<I>(mut i: I) -> I::Item""     I: Iterator,""     I::Item: Default,""     i.next().unwrap_or_else(I::Item::default)"" assert_eq!(first_or_default([1, 2, 3].into_iter()), 1);"" assert_eq!(first_or_default(Vec::<i32>::new().into_iter()), 0);"" `where` is available anywhere generic and lifetime parameters are available,"" as can be seen with the [`Cow`](crate::borrow::Cow) type from the standard"" library:"" pub enum Cow<\'a, B>""     B: ToOwned + ?Sized,""     Borrowed(&\'a B),""     Owned(<B as ToOwned>::Owned),"" [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md"" Loop while a condition is upheld."" A `while` expression is used for predicate loops. The `while` expression runs the conditional"" expression before running the loop body, then runs the loop body if the conditional"" expression evaluates to `true`, or exits the loop otherwise."" let mut counter = 0;"" while counter < 10 {""     println!(\"{counter}\");""     counter += 1;"" Like the [`for`] expression, we can use `break` and `continue`. A `while` expression"" cannot break with a value and always evaluates to `()` unlike [`loop`]."" while i < 100 {""     if i == 64 {""         break; // Exit when `i` is 64."" As `if` expressions have their pattern matching variant in `if let`, so too do `while`"" expressions with `while let`. The `while let` expression matches the pattern against the"" expression, then runs the loop body if pattern matching succeeds, or exits the loop otherwise."" We can use `break` and `continue` in `while let` expressions just like in `while`."" let mut counter = Some(0);"" while let Some(i) = counter {""     if i == 10 {""         counter = None;""         println!(\"{i}\");""         counter = Some (i + 1);"" For more information on `while` and loops in general, see the [reference]."" See also, [`for`], [`loop`]."" [reference]: ../reference/expressions/loop-expr.html#predicate-loops"" Returns a [`Future`] instead of blocking the current thread."" Use `async` in front of `fn`, `closure`, or a `block` to turn the marked code into a `Future`."" As such the code will not be run immediately, but will only be evaluated when the returned"" future is [`.await`]ed."" We have written an [async book] detailing `async`/`await` and trade-offs compared to using threads."" ## Control Flow"" [`return`] statements and [`?`][try operator] operators within `async` blocks do not cause"" a return from the parent function; rather, they cause the `Future` returned by the block to"" return with that value."" For example, the following Rust function will return `5`, causing `x` to take the [`!` type][never type]:"" #[expect(unused_variables)]"" fn example() -> i32 {""     let x = {"" In contrast, the following asynchronous function assigns a `Future<Output = i32>` to `x`, and"" only returns `5` when `x` is `.await`ed:"" async fn example() -> i32 {""     let x = async {""     x.await"" Code using `?` behaves similarly - it causes the `async` block to return a [`Result`] without"" affecting the parent function."" Note that you cannot use `break` or `continue` from within an `async` block to affect the"" control flow of a loop in the parent function."" Control flow in `async` blocks is documented further in the [async book][async book blocks]."" ## Editions"" `async` is a keyword from the 2018 edition onwards."" It is available for use in stable Rust from version 1.39 onwards."" [`Future`]: future::Future"" [`.await`]: ../std/keyword.await.html"" [async book]: https://rust-lang.github.io/async-book/"" [`return`]: ../std/keyword.return.html"" [try operator]: ../reference/expressions/operator-expr.html#r-expr.try"" [never type]: ../reference/types/never.html"" [`Result`]: result::Result"" [async book blocks]: https://rust-lang.github.io/async-book/part-guide/more-async-await.html#async-blocks"" Suspend execution until the result of a [`Future`] is ready."" `.await`ing a future will suspend the current function\'s execution until the executor"" has run the future to completion."" Read the [async book] for details on how [`async`]/`await` and executors work."" `await` is a keyword from the 2018 edition onwards."" `dyn` is a prefix of a [trait object]\'s type."" The `dyn` keyword is used to highlight that calls to methods on the associated `Trait`"" are [dynamically dispatched]. To use the trait this way, it must be *dyn compatible*[^1]."" Unlike generic parameters or `impl Trait`, the compiler does not know the concrete type that"" is being passed. That is, the type has been [erased]."" As such, a `dyn Trait` reference contains _two_ pointers."" One pointer goes to the data (e.g., an instance of a struct)."" Another pointer goes to a map of method call names to function pointers"" (known as a virtual method table or vtable)."" At run-time, when a method needs to be called on the `dyn Trait`, the vtable is consulted to get"" the function pointer and then that function pointer is called."" See the Reference for more information on [trait objects][ref-trait-obj]"" and [dyn compatibility][ref-dyn-compat]."" ## Trade-offs"" The above indirection is the additional runtime cost of calling a function on a `dyn Trait`."" Methods called by dynamic dispatch generally cannot be inlined by the compiler."" However, `dyn Trait` is likely to produce smaller code than `impl Trait` / generic parameters as"" the method won\'t be duplicated for each concrete type."" [trait object]: ../book/ch17-02-trait-objects.html"" [dynamically dispatched]: https://en.wikipedia.org/wiki/Dynamic_dispatch"" [ref-trait-obj]: ../reference/types/trait-object.html"" [ref-dyn-compat]: ../reference/items/traits.html#dyn-compatibility"" [erased]: https://en.wikipedia.org/wiki/Type_erasure"" [^1]: Formerly known as *object safe*."" The [Rust equivalent of a C-style union][union]."" A `union` looks like a [`struct`] in terms of declaration, but all of its"" fields exist in the same memory, superimposed over one another. For instance,"" if we wanted some bits in memory that we sometimes interpret as a `u32` and"" sometimes as an `f32`, we could write:"" union IntOrFloat {""     i: u32,""     f: f32,"" let mut u = IntOrFloat { f: 1.0 };"" // Reading the fields of a union is always unsafe"" assert_eq!(unsafe { u.i }, 1065353216);"" // Updating through any of the field will modify all of them"" u.i = 1073741824;"" assert_eq!(unsafe { u.f }, 2.0);"" # Matching on unions"" It is possible to use pattern matching on `union`s. A single field name must"" be used and it must match the name of one of the `union`\'s field."" Like reading from a `union`, pattern matching on a `union` requires `unsafe`."" let u = IntOrFloat { f: 1.0 };""     match u {""         IntOrFloat { i: 10 } => println!(\"Found exactly ten!\"),""         // Matching the field `f` provides an `f32`.""         IntOrFloat { f } => println!(\"Found f = {f} !\"),"" # References to union fields"" All fields in a `union` are all at the same place in memory which means"" borrowing one borrows the entire `union`, for the same lifetime:"" let f = unsafe { &u.f };"" // This will not compile because the field has already been borrowed, even"" // if only immutably"" let i = unsafe { &mut u.i };"" *i = 10;"" println!(\"f = {f} and i = {i}\");"" See the [Reference][union] for more information on `union`s."" [union]: ../reference/items/unions.html"// the rustdoc documentation for the existing keywords. Using `include!`__restricted_std_workaround// This is required to avoid an unstable error when `restricted-std` is not// enabled. The use of #![feature(restricted_std)] in rustc-std-workspace-std// is unconditional, so the unstable feature needs to be defined somewhere./// prevents outside implementations of our extension traits./// This allows adding more trait methods in the future.//! # The Rust Standard Library//! The Rust Standard Library is the foundation of portable Rust software, a//! set of minimal and battle-tested shared abstractions for the [broader Rust//! ecosystem][crates.io]. It offers core types, like [`Vec<T>`] and//! [`Option<T>`], library-defined [operations on language//! primitives](#primitives), [standard macros](#macros), [I/O] and//! [multithreading], among [many other things][other].//! `std` is available to all Rust crates by default. Therefore, the//! standard library can be accessed in [`use`] statements through the path//! `std`, as in [`use std::env`].//! # How to read this documentation//! If you already know the name of what you are looking for, the fastest way to//! find it is to use the <a href="#" onclick="window.searchState.focus();">search//! button</a> at the top of the page.//! Otherwise, you may want to jump to one of these useful sections://! * [`std::*` modules](#modules)//! * [Primitive types](#primitives)//! * [Standard macros](#macros)//! * [The Rust Prelude]//! If this is your first time, the documentation for the standard library is//! written to be casually perused. Clicking on interesting things should//! generally lead you to interesting places. Still, there are important bits//! you don't want to miss, so read on for a tour of the standard library and//! its documentation!//! Once you are familiar with the contents of the standard library you may//! begin to find the verbosity of the prose distracting. At this stage in your//! development you may want to press the//! "<svg style="width:0.75rem;height:0.75rem" viewBox="0 0 12 12" stroke="currentColor" fill="none"><path d="M2,2l4,4l4,-4M2,6l4,4l4,-4"/></svg>&nbsp;Summary"//! button near the top of the page to collapse it into a more skimmable view.//! While you are looking at the top of the page, also notice the//! "Source" link. Rust's API documentation comes with the source//! code and you are encouraged to read it. The standard library source is//! generally high quality and a peek behind the curtains is//! often enlightening.//! # What is in the standard library documentation?//! First of all, The Rust Standard Library is divided into a number of focused//! modules, [all listed further down this page](#modules). These modules are//! the bedrock upon which all of Rust is forged, and they have mighty names//! like [`std::slice`] and [`std::cmp`]. Modules' documentation typically//! includes an overview of the module along with examples, and are a smart//! place to start familiarizing yourself with the library.//! Second, implicit methods on [primitive types] are documented here. This can//! be a source of confusion for two reasons://! 1. While primitives are implemented by the compiler, the standard library//!    implements methods directly on the primitive types (and it is the only//!    library that does so), which are [documented in the section on//!    primitives](#primitives).//! 2. The standard library exports many modules *with the same name as//!    primitive types*. These define additional items related to the primitive//!    type, but not the all-important methods.//! So for example there is a [page for the primitive type//! `char`](primitive::char) that lists all the methods that can be called on//! characters (very useful), and there is a [page for the module//! `std::char`](crate::char) that documents iterator and error types created by these methods//! (rarely useful).//! Note the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also//! called 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually//! calls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref//! coercions][deref-coercions].//! Third, the standard library defines [The Rust Prelude], a small collection//! of items - mostly traits - that are imported into every module of every//! crate. The traits in the prelude are pervasive, making the prelude//! documentation a good entry point to learning about the library.//! And finally, the standard library exports a number of standard macros, and//! [lists them on this page](#macros) (technically, not all of the standard//! macros are defined by the standard library - some are defined by the//! compiler - but they are documented here the same). Like the prelude, the//! standard macros are imported by default into all crates.//! # Contributing changes to the documentation//! Check out the Rust contribution guidelines [here](//! https://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).//! The source for this documentation can be found on//! [GitHub](https://github.com/rust-lang/rust) in the 'library/std/' directory.//! To contribute changes, make sure you read the guidelines first, then submit//! pull-requests for your suggested changes.//! Contributions are appreciated! If you see a part of the docs that can be//! improved, submit a PR, or chat with us first on [Zulip][rust-zulip]//! #docs.//! # A Tour of The Rust Standard Library//! The rest of this crate documentation is dedicated to pointing out notable//! features of The Rust Standard Library.//! ## Containers and collections//! The [`option`] and [`result`] modules define optional and error-handling//! types, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines//! Rust's iterator trait, [`Iterator`], which works with the [`for`] loop to//! access collections.//! The standard library exposes three common ways to deal with contiguous//! regions of memory://! * [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.//! * [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.//! * [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous//!   storage, whether heap-allocated or not.//! Slices can only be handled through some kind of *pointer*, and as such come//! in many flavors such as://! * `&[T]` - *shared slice*//! * `&mut [T]` - *mutable slice*//! * [`Box<[T]>`][owned slice] - *owned slice*//! [`str`], a UTF-8 string slice, is a primitive type, and the standard library//! defines many methods for it. Rust [`str`]s are typically accessed as//! immutable references: `&str`. Use the owned [`String`] for building and//! mutating strings.//! For converting to strings use the [`format!`] macro, and for converting from//! strings use the [`FromStr`] trait.//! Data may be shared by placing it in a reference-counted box or the [`Rc`]//! type, and if further contained in a [`Cell`] or [`RefCell`], may be mutated//! as well as shared. Likewise, in a concurrent setting it is common to pair an//! atomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same//! effect.//! The [`collections`] module defines maps, sets, linked lists and other//! typical collection types, including the common [`HashMap<K, V>`].//! ## Platform abstractions and I/O//! Besides basic data types, the standard library is largely concerned with//! abstracting over differences in common platforms, most notably Windows and//! Unix derivatives.//! Common types of I/O, including [files], [TCP], and [UDP], are defined in//! the [`io`], [`fs`], and [`net`] modules.//! The [`thread`] module contains Rust's threading abstractions. [`sync`]//! contains further primitive shared memory types, including [`atomic`], [`mpmc`] and//! [`mpsc`], which contains the channel types for message passing.//! # Use before and after `main()`//! Many parts of the standard library are expected to work before and after `main()`;//! but this is not guaranteed or ensured by tests. It is recommended that you write your own tests//! and run them on each platform you wish to support.//! This means that use of `std` before/after main, especially of features that interact with the//! OS or global state, is exempted from stability and portability guarantees and instead only//! provided on a best-effort basis. Nevertheless bug reports are appreciated.//! On the other hand `core` and `alloc` are most likely to work in such environments with//! the caveat that any hookable behavior such as panics, oom handling or allocators will also//! depend on the compatibility of the hooks.//! Some features may also behave differently outside main, e.g. stdio could become unbuffered,//! some panics might turn into aborts, backtraces might not get symbolicated or similar.//! Non-exhaustive list of known limitations://! - after-main use of thread-locals, which also affects additional features://!   - [`thread::current()`]//! - under UNIX, before main, file descriptors 0, 1, and 2 may be unchanged//!   (they are guaranteed to be open during main,//!    and are opened to /dev/null O_RDWR if they weren't open on program start)//! [I/O]: io//! [TCP]: net::TcpStream//! [The Rust Prelude]: prelude//! [UDP]: net::UdpSocket//! [`Arc`]: sync::Arc//! [owned slice]: boxed//! [`Cell`]: cell::Cell//! [`FromStr`]: str::FromStr//! [`HashMap<K, V>`]: collections::HashMap//! [`Mutex`]: sync::Mutex//! [`Option<T>`]: option::Option//! [`Rc`]: rc::Rc//! [`RefCell`]: cell::RefCell//! [`Result<T, E>`]: result::Result//! [`Vec<T>`]: vec::Vec//! [`atomic`]: sync::atomic//! [`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for//! [`str`]: prim@str//! [`mpmc`]: sync::mpmc//! [`mpsc`]: sync::mpsc//! [`std::cmp`]: cmp//! [`std::slice`]: mod@slice//! [`use std::env`]: env/index.html//! [`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html//! [crates.io]: https://crates.io//! [deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods//! [files]: fs::File//! [multithreading]: thread//! [other]: #what-is-in-the-standard-library-documentation//! [primitive types]: ../book/ch03-02-data-types.html//! [rust-zulip]: https://rust-lang.zulipchat.com///! [array]: prim@array//! [slice]: prim@slice// Don't link to std. We are std.// Tell the compiler to link to either panic_abort or panic_unwind// Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind`// std may use features in a platform-specific way// Library features (core):// Library features (alloc):// Library features (unwind):// Library features (std_detect):// Only for re-exporting:// Only used in tests/benchmarks:// Only for const-ness:/// Prints to the standard output./// necessary to use [`io::stdout().flush()`][flush] to ensure the output is emitted/// The `print!` macro will lock the standard output on each call. If you call/// To avoid this, lock stdout with [`io::stdout().lock()`][lock]:/// let mut lock = stdout().lock();/// See the formatting documentation in [`std::fmt`](crate::fmt)/// for details of the macro argument syntax./// [flush]: crate::io::Write::flush/// [`println!`]: crate::println/// [`eprint!`]: crate::eprint/// [lock]: crate::io::Stdout/// Panics if writing to `io::stdout()` fails./// io::stdout().flush().unwrap();/// Prints to the standard output, with a newline./// The `println!` macro will lock the standard output on each call. If you call/// [`std::fmt`]: crate::fmt/// [`eprintln!`]: crate::eprintln/// Panics if writing to [`io::stdout`] fails./// [`io::stdout`]: crate::io::stdout/// Prints to the standard error./// [`io::stderr`] instead of [`io::stdout`]. See [`print!`] for/// [`io::stderr`]: crate::io::stderr/// Panics if writing to `io::stderr` fails./// Writing to non-blocking stderr can cause an error, which will lead/// Prints to the standard error, with a newline./// [`io::stderr`] instead of [`io::stdout`]. See [`println!`] for// NOTE: We cannot use `concat!` to make a static string as a format argument// of `eprintln!` because `file!` could contain a `{` or// `$val` expression could be a block (`{ .. }`), in which case the `eprintln!`// will be malformed./// Prints and returns the value of a given expression for quick and dirty/// debugging./// An example:/// let a = 2;/// let b = dbg!(a * 2) + 1;/// //      ^-- prints: [src/main.rs:2:9] a * 2 = 4/// assert_eq!(b, 5);/// The macro works by using the `Debug` implementation of the type of/// the given expression to print the value to [stderr] along with the/// source location of the macro invocation as well as the source code/// of the expression./// Invoking the macro on an expression moves and takes ownership of it/// before returning the evaluated expression unchanged. If the type/// of the expression does not implement `Copy` and you don't want/// to give up ownership, you can instead borrow with `dbg!(&expr)`/// for some expression `expr`./// The `dbg!` macro works exactly the same in release builds./// This is useful when debugging issues that only occur in release/// builds or when debugging in release mode is significantly faster./// Note that the macro is intended as a debugging tool and therefore you/// should avoid having uses of it in version control for long periods/// (other than in tests and similar)./// Debug output from production code is better done with other facilities/// such as the [`debug!`] macro from the [`log`] crate./// The exact output printed by this macro should not be relied upon/// and is subject to future changes./// # Further examples/// With a method call:/// fn foo(n: usize) {///     if let Some(_) = dbg!(n.checked_sub(4)) {/// foo(3)/// This prints to [stderr]:/// ```text,ignore/// [src/main.rs:2:22] n.checked_sub(4) = None/// Naive factorial implementation:///     if dbg!(n <= 1) {///         dbg!(1)///         dbg!(n * factorial(n - 1))/// dbg!(factorial(4));/// [src/main.rs:2:8] n <= 1 = false/// [src/main.rs:2:8] n <= 1 = true/// [src/main.rs:3:9] 1 = 1/// [src/main.rs:7:9] n * factorial(n - 1) = 2/// [src/main.rs:7:9] n * factorial(n - 1) = 6/// [src/main.rs:7:9] n * factorial(n - 1) = 24/// [src/main.rs:9:1] factorial(4) = 24/// The `dbg!(..)` macro moves the input:/// /// A wrapper around `usize` which importantly is not Copyable./// struct NoCopy(usize);/// let a = NoCopy(42);/// let _ = dbg!(a); // <-- `a` is moved here./// let _ = dbg!(a); // <-- `a` is moved again; error!/// You can also use `dbg!()` without a value to just print the/// file and line whenever it's reached./// Finally, if you want to `dbg!(..)` multiple values, it will treat them as/// a tuple (and return it, too):/// assert_eq!(dbg!(1usize, 2u32), (1, 2));/// However, a single argument with a trailing comma will still not be treated/// as a tuple, following the convention of ignoring trailing commas in macro/// invocations. You can use a 1-tuple directly if you need one:/// assert_eq!(1, dbg!(1u32,)); // trailing comma ignored/// assert_eq!((1,), dbg!((1u32,))); // 1-tuple/// [stderr]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)/// [`debug!`]: https://docs.rs/log/*/log/macro.debug.html/// [`log`]: https://crates.io/crates/log//! Standard library macros//! This module contains a set of macros which are exported from the standard//! library. Each macro is available for use when linking against the standard// ignore-tidy-dbg/// Returns the system hostname./// This can error out in platform-specific error cases;/// for example, uefi and wasm, where hostnames aren't/// # Underlying system calls/// | Platform | System call                                                                                             |/// |----------|---------------------------------------------------------------------------------------------------------|/// | UNIX     | [`gethostname`](https://www.man7.org/linux/man-pages/man2/gethostname.2.html)                           |/// | Windows  | [`GetHostNameW`](https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-gethostnamew) |tsato_socket_addr_socketaddrIntoIncoming/// The reading portion of the [`TcpStream`] should be shut down./// All currently blocked and future [reads] will return <code>[Ok]\(0)</code>./// [reads]: crate::io::Read "io::Read"/// The writing portion of the [`TcpStream`] should be shut down./// All currently blocked and future [writes] will return an error./// [writes]: crate::io::Write "io::Write"/// Both the reading and the writing portions of the [`TcpStream`] should be shut down./// See [`Shutdown::Read`] and [`Shutdown::Write`] for more information./// Possible values which can be passed to the [`TcpStream::shutdown`] method.//! Networking primitives for TCP/UDP communication.//! This module provides networking functionality for the Transmission Control and User//! Datagram Protocols, as well as types for IP and socket addresses and functions related//! to network properties.//! * [`ToSocketAddrs`] is a trait that is used for generic address resolution when interacting//!   with networking objects like [`TcpListener`], [`TcpStream`] or [`UdpSocket`]//! * Other types are return or parameter types for various methods in this module//! Rust disables inheritance of socket objects to child processes by default when possible.  For//! example, through the use of the `CLOEXEC` flag in UNIX systems or the `HANDLE_FLAG_INHERIT`//! flag on Windows.to_socket_addr_ipaddr_u16to_socket_addr_str_u16to_socket_addr_strto_socket_addr_stringbind_udp_socket_bad/// Returned iterator over socket addresses which this type may correspond/// Converts this object to an iterator of resolved [`SocketAddr`]s./// The returned iterator might not actually yield any values depending on the/// outcome of any resolution performed./// Note that this function may block the current thread while resolution is/// [`SocketAddr`] values./// This trait is used for generic address resolution when constructing network/// objects. By default it is implemented for the following types:///  * [`SocketAddr`]: [`to_socket_addrs`] is the identity function.///  * [`SocketAddrV4`], [`SocketAddrV6`], <code>([IpAddr], [u16])</code>,///    <code>([Ipv4Addr], [u16])</code>, <code>([Ipv6Addr], [u16])</code>:///    [`to_socket_addrs`] constructs a [`SocketAddr`] trivially.///  * <code>(&[str], [u16])</code>: <code>&[str]</code> should be either a string representation///    of an [`IpAddr`] address as expected by [`FromStr`] implementation or a host///    name. [`u16`] is the port number.///  * <code>&[str]</code>: the string should be either a string representation of a///    [`SocketAddr`] as expected by its [`FromStr`] implementation or a string like///    `<host_name>:<port>` pair where `<port>` is a [`u16`] value.///  * <code>&[[SocketAddr]]</code>: all [`SocketAddr`] values in the slice will be used./// This trait allows constructing network objects like [`TcpStream`] or/// [`UdpSocket`] easily with values of various types for the bind/connection/// address. It is needed because sometimes one type is more appropriate than/// the other: for simple uses a string like `"localhost:12345"` is much nicer/// than manual construction of the corresponding [`SocketAddr`], but sometimes/// [`SocketAddr`] value is *the* main source of the address, and converting it to/// some other type (e.g., a string) just for it to be converted back to/// [`SocketAddr`] in constructor methods is pointless./// Addresses returned by the operating system that are not IP addresses are/// silently ignored./// [`FromStr`]: crate::str::FromStr "std::str::FromStr"/// [`TcpStream`]: crate::net::TcpStream "net::TcpStream"/// [`to_socket_addrs`]: ToSocketAddrs::to_socket_addrs/// [`UdpSocket`]: crate::net::UdpSocket "net::UdpSocket"/// Creating a [`SocketAddr`] iterator that yields one item:/// use std::net::{ToSocketAddrs, SocketAddr};/// let addr = SocketAddr::from(([127, 0, 0, 1], 443));/// let mut addrs_iter = addr.to_socket_addrs().unwrap();/// assert_eq!(Some(addr), addrs_iter.next());/// assert!(addrs_iter.next().is_none());/// Creating a [`SocketAddr`] iterator from a hostname:/// use std::net::{SocketAddr, ToSocketAddrs};/// // assuming 'localhost' resolves to 127.0.0.1/// let mut addrs_iter = "localhost:443".to_socket_addrs().unwrap();/// assert_eq!(addrs_iter.next(), Some(SocketAddr::from(([127, 0, 0, 1], 443))));/// // assuming 'foo' does not resolve/// assert!("foo:443".to_socket_addrs().is_err());/// Creating a [`SocketAddr`] iterator that yields multiple items:/// let addr1 = SocketAddr::from(([0, 0, 0, 0], 80));/// let addr2 = SocketAddr::from(([127, 0, 0, 1], 443));/// let addrs = vec![addr1, addr2];/// let mut addrs_iter = (&addrs[..]).to_socket_addrs().unwrap();/// assert_eq!(Some(addr1), addrs_iter.next());/// assert_eq!(Some(addr2), addrs_iter.next());/// Attempting to create a [`SocketAddr`] iterator from an improperly formatted/// socket address `&str` (missing the port):/// use std::net::ToSocketAddrs;/// let err = "127.0.0.1".to_socket_addrs().unwrap_err();/// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);/// [`TcpStream::connect`] is an example of a function that utilizes/// `ToSocketAddrs` as a trait bound on its parameter in order to accept/// different types:/// use std::net::{TcpStream, Ipv4Addr};/// let stream = TcpStream::connect(("127.0.0.1", 443));/// let stream = TcpStream::connect("127.0.0.1:443");/// let stream = TcpStream::connect((Ipv4Addr::new(127, 0, 0, 1), 443));/// [`TcpStream::connect`]: crate::net::TcpStream::connect// accepts strings like 'localhost:12345'next_test_ip4next_test_ip6each_ipbind_errorconnect_timeout_error// FIXME: https://github.com/fortanix/rust-sgx/issues/31listen_localhostconnect_loopbackread_eofwrite_closemultiple_connect_serialmultiple_connect_interleaved_greedy_schedulemultiple_connect_interleaved_lazy_schedulesocket_and_peer_namepartial_readdouble_bindtcp_clone_smoketcp_clone_two_readtcp_clone_two_writeshutdown_smoke// FIXME: https://github.com/fortanix/rust-sgx/issues/110close_readwrite_smokeclose_read_wakes_up// On windows, shutdown will not wake up blocking I/O operations.clone_while_readingclone_accept_smokeclone_accept_concurrenttimeouts// FIXME: re-enabled openbsd tests once their socket timeout code//        no longer has rounding errors.// VxWorks ignores SO_SNDTIMEO.// timeout not supportedtest_read_timeouttest_read_with_timeouttest_timeout_zero_duration// Ensure the `set_read_timeout` and `set_write_timeout` calls return errors// when passed zero Durations// linger not supportednet_imp/// A TCP stream between a local and a remote socket./// After creating a `TcpStream` by either [`connect`]ing to a remote host or/// [`accept`]ing a connection on a [`TcpListener`], data can be transmitted/// by [reading] and [writing] to it./// The connection will be closed when the value is dropped. The reading and writing/// portions of the connection can also be shut down individually with the [`shutdown`]/// The Transmission Control Protocol is specified in [IETF RFC 793]./// [`accept`]: TcpListener::accept/// [`connect`]: TcpStream::connect/// [reading]: Read/// [`shutdown`]: TcpStream::shutdown/// [writing]: Write///     let mut stream = TcpStream::connect("127.0.0.1:34254")?;///     stream.write(&[1])?;///     stream.read(&mut [0; 128])?;/// } // the stream is closed here/// # Platform-specific Behavior/// On Unix, writes to the underlying socket in `SOCK_STREAM` mode are made with/// `MSG_NOSIGNAL` flag. This suppresses the emission of the  `SIGPIPE` signal when writing/// to disconnected socket. In some cases, getting a `SIGPIPE` would trigger process termination./// A TCP socket server, listening for connections./// After creating a `TcpListener` by [`bind`]ing it to a socket address, it listens/// for incoming TCP connections. These can be accepted by calling [`accept`] or by/// iterating over the [`Incoming`] iterator returned by [`incoming`][`TcpListener::incoming`]./// [`bind`]: TcpListener::bind/// fn handle_client(stream: TcpStream) {///     let listener = TcpListener::bind("127.0.0.1:80")?;///     // accept connections and process them serially///         handle_client(stream?);/// An iterator that infinitely [`accept`]s connections on a [`TcpListener`]./// This `struct` is created by the [`TcpListener::incoming`] method./// This `struct` is created by the [`TcpListener::into_incoming`] method./// Opens a TCP connection to a remote host./// `addr` is an address of the remote host. Anything which implements/// [`ToSocketAddrs`] trait can be supplied for the address; see this trait/// If `addr` yields multiple addresses, `connect` will be attempted with/// each of the addresses until a connection is successful. If none of/// the addresses result in a successful connection, the error returned from/// the last connection attempt (the last address) is returned./// Open a TCP connection to `127.0.0.1:8080`:/// if let Ok(stream) = TcpStream::connect("127.0.0.1:8080") {///     println!("Connected to the server!");///     println!("Couldn't connect to server...");/// Open a TCP connection to `127.0.0.1:8080`. If the connection fails, open/// a TCP connection to `127.0.0.1:8081`:/// use std::net::{SocketAddr, TcpStream};/// let addrs = [///     SocketAddr::from(([127, 0, 0, 1], 8080)),///     SocketAddr::from(([127, 0, 0, 1], 8081)),/// if let Ok(stream) = TcpStream::connect(&addrs[..]) {/// Opens a TCP connection to a remote host with a timeout./// Unlike `connect`, `connect_timeout` takes a single [`SocketAddr`] since/// timeout must be applied to individual addresses./// It is an error to pass a zero `Duration` to this function./// Unlike other methods on `TcpStream`, this does not correspond to a/// single system call. It instead calls `connect` in nonblocking mode and/// then uses an OS-specific mechanism to await the completion of the/// connection request./// use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpStream};/// let stream = TcpStream::connect("127.0.0.1:8080")///                        .expect("Couldn't connect to the server...");/// assert_eq!(stream.peer_addr().unwrap(),///            SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));/// use std::net::{IpAddr, Ipv4Addr, TcpStream};/// assert_eq!(stream.local_addr().unwrap().ip(),///            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));/// documentation of [`Shutdown`])./// Calling this function multiple times may result in different behavior,/// depending on the operating system. On Linux, the second call will/// return `Ok(())`, but on macOS, it will return `ErrorKind::NotConnected`./// This may change in the future./// use std::net::{Shutdown, TcpStream};/// stream.shutdown(Shutdown::Both).expect("shutdown call failed");/// let stream_clone = stream.try_clone().expect("clone failed...");/// If the value specified is [`None`], then [`read`] calls will block/// indefinitely. An [`Err`] is returned if the zero [`Duration`] is/// passed to this method./// Platforms may return a different error code whenever a read times out as/// a result of setting this option. For example Unix typically returns an/// error of the kind [`WouldBlock`], but Windows may return [`TimedOut`]./// [`TimedOut`]: io::ErrorKind::TimedOut/// stream.set_read_timeout(None).expect("set_read_timeout call failed");/// An [`Err`] is returned if the zero [`Duration`] is passed to this/// let stream = TcpStream::connect("127.0.0.1:8080").unwrap();/// let result = stream.set_read_timeout(Some(Duration::new(0, 0)));/// assert_eq!(err.kind(), io::ErrorKind::InvalidInput)/// If the value specified is [`None`], then [`write`] calls will block/// Platforms may return a different error code whenever a write times out/// as a result of setting this option. For example Unix typically returns/// an error of the kind [`WouldBlock`], but Windows may return [`TimedOut`]./// stream.set_write_timeout(None).expect("set_write_timeout call failed");/// let result = stream.set_write_timeout(Some(Duration::new(0, 0)));/// If the timeout is [`None`], then [`read`] calls will block indefinitely./// Some platforms do not provide access to the current timeout./// assert_eq!(stream.read_timeout().unwrap(), None);/// If the timeout is [`None`], then [`write`] calls will block indefinitely./// assert_eq!(stream.write_timeout().unwrap(), None);/// let stream = TcpStream::connect("127.0.0.1:8000")/// let len = stream.peek(&mut buf).expect("peek failed");/// Sets the value of the `SO_LINGER` option on this socket./// This value controls how the socket is closed when data remains/// to be sent. If `SO_LINGER` is set, the socket will remain open/// for the specified duration as the system attempts to send pending data./// Otherwise, the system may close the socket immediately, or wait for a/// default timeout./// #![feature(tcp_linger)]/// stream.set_linger(Some(Duration::from_secs(0))).expect("set_linger call failed");/// Gets the value of the `SO_LINGER` option on this socket./// For more information about this option, see [`TcpStream::set_linger`]./// assert_eq!(stream.linger().unwrap(), Some(Duration::from_secs(0)));/// stream.set_nodelay(true).expect("set_nodelay call failed");/// For more information about this option, see [`TcpStream::set_nodelay`]./// assert_eq!(stream.nodelay().unwrap_or(false), true);/// stream.set_ttl(100).expect("set_ttl call failed");/// For more information about this option, see [`TcpStream::set_ttl`]./// assert_eq!(stream.ttl().unwrap_or(0), 100);/// Gets the value of the `SO_ERROR` option on this socket./// stream.take_error().expect("No error was expected...");/// This will result in `read`, `write`, `recv` and `send` system operations/// becoming nonblocking, i.e., immediately returning from their calls./// If the IO operation is successful, `Ok` is returned and no further/// action is required. If the IO operation could not be completed and needs/// to be retried, an error with kind [`io::ErrorKind::WouldBlock`] is/// On Unix platforms, calling this method corresponds to calling `fcntl`/// `FIONBIO`. On Windows calling this method corresponds to calling/// `ioctlsocket` `FIONBIO`./// Reading bytes from a TCP stream in non-blocking mode:/// let mut stream = TcpStream::connect("127.0.0.1:7878")///     .expect("Couldn't connect to the server...");/// stream.set_nonblocking(true).expect("set_nonblocking call failed");/// # fn wait_for_fd() { unimplemented!() }///     match stream.read_to_end(&mut buf) {///         Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {///             // wait until network socket is ready, typically implemented///             // via platform-specific APIs such as epoll or IOCP///             wait_for_fd();///         Err(e) => panic!("encountered IO error: {e}"),/// println!("bytes: {buf:?}");/// Creates a new `TcpListener` which will be bound to the specified/// The returned listener is ready for accepting connections./// to this listener. The port allocated can be queried via the/// [`TcpListener::local_addr`] method./// The address type can be any implementor of [`ToSocketAddrs`] trait. See/// its documentation for concrete examples./// If `addr` yields multiple addresses, `bind` will be attempted with/// each of the addresses until one succeeds and returns the listener. If/// none of the addresses succeed in creating a listener, the error returned/// from the last attempt (the last address) is returned./// Creates a TCP listener bound to `127.0.0.1:80`:/// let listener = TcpListener::bind("127.0.0.1:80").unwrap();/// Creates a TCP listener bound to `127.0.0.1:80`. If that fails, create a/// TCP listener bound to `127.0.0.1:443`:///     SocketAddr::from(([127, 0, 0, 1], 80)),///     SocketAddr::from(([127, 0, 0, 1], 443)),/// let listener = TcpListener::bind(&addrs[..]).unwrap();/// Creates a TCP listener bound to a port assigned by the operating system/// at `127.0.0.1`./// let socket = TcpListener::bind("127.0.0.1:0").unwrap();/// use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener};/// let listener = TcpListener::bind("127.0.0.1:8080").unwrap();/// assert_eq!(listener.local_addr().unwrap(),/// The returned [`TcpListener`] is a reference to the same socket that this/// object references. Both handles can be used to accept incoming/// connections and options set on one listener will affect the other./// let listener_clone = listener.try_clone().unwrap();/// This function will block the calling thread until a new TCP connection/// is established. When established, the corresponding [`TcpStream`] and the/// match listener.accept() {///     Ok((_socket, addr)) => println!("new client: {addr:?}"),///     Err(e) => println!("couldn't get client: {e:?}"),/// Returns an iterator over the connections being received on this/// listener./// The returned iterator will never return [`None`] and will also not yield/// the peer's [`SocketAddr`] structure. Iterating over it is equivalent to/// calling [`TcpListener::accept`] in a loop./// fn handle_connection(stream: TcpStream) {///    //...///         match stream {///             Ok(stream) => {///                 handle_connection(stream);///             Err(e) => { /* connection failed */ }/// Turn this into an iterator over the connections being received on this/// #![feature(tcplistener_into_incoming)]/// fn listen_on(port: u16) -> impl Iterator<Item = TcpStream> {///     let listener = TcpListener::bind(("127.0.0.1", port)).unwrap();///     listener.into_incoming()///         .filter_map(Result::ok) /* Ignore failed connections *////     for stream in listen_on(80) {///         /* handle the connection here *//// listener.set_ttl(100).expect("could not set TTL");/// For more information about this option, see [`TcpListener::set_ttl`]./// assert_eq!(listener.ttl().unwrap_or(0), 100);/// listener.take_error().expect("No error was expected");/// This will result in the `accept` operation becoming nonblocking,/// i.e., immediately returning from their calls. If the IO operation is/// successful, `Ok` is returned and no further action is required. If the/// IO operation could not be completed and needs to be retried, an error/// with kind [`io::ErrorKind::WouldBlock`] is returned./// Bind a TCP listener to an address, listen for connections, and read/// bytes in nonblocking mode:/// let listener = TcpListener::bind("127.0.0.1:7878").unwrap();/// listener.set_nonblocking(true).expect("Cannot set non-blocking");/// # fn handle_connection(stream: std::net::TcpStream) { unimplemented!() }///         Ok(s) => {///             // do something with the TcpStream///             handle_connection(s);// In addition to the `impl`s here, `TcpStream` also has `impl`s for// `AsSocket`/`From<OwnedSocket>`/`Into<OwnedSocket>` and// `AsRawSocket`/`IntoRawSocket`/`FromRawSocket` on Windows.// In addition to the `impl`s here, `TcpListener` also has `impl`s forBASE_PORTcompare_ignore_zoneid// not used on emscriptensocket_smoke_test_ip4socket_peerudp_clone_smokeudp_clone_two_readudp_clone_two_write// FIXME: re-enabled openbsd/netbsd tests once their socket timeout codeconnect_send_recvconnect_send_peek_recv// peek not supported// peek_from not supported/// A UDP socket./// After creating a `UdpSocket` by [`bind`]ing it to a socket address, data can be/// [sent to] and [received from] any other socket address./// Although UDP is a connectionless protocol, this implementation provides an interface/// to set an address where data should be sent and received from. After setting a remote/// address with [`connect`], data can be sent to and received from that address with/// [`send`] and [`recv`]./// As stated in the User Datagram Protocol's specification in [IETF RFC 768], UDP is/// an unordered, unreliable protocol; refer to [`TcpListener`] and [`TcpStream`] for TCP/// [`bind`]: UdpSocket::bind/// [`connect`]: UdpSocket::connect/// [IETF RFC 768]: https://tools.ietf.org/html/rfc768/// [`recv`]: UdpSocket::recv/// [received from]: UdpSocket::recv_from/// [`send`]: UdpSocket::send/// [sent to]: UdpSocket::send_to/// [`TcpListener`]: crate::net::TcpListener///         let socket = UdpSocket::bind("127.0.0.1:34254")?;///         // Receives a single datagram message on the socket. If `buf` is too small to hold///         // the message, it will be cut off.///         let mut buf = [0; 10];///         let (amt, src) = socket.recv_from(&mut buf)?;///         // Redeclare `buf` as slice of the received data and send reverse data back to origin.///         let buf = &mut buf[..amt];///         buf.reverse();///         socket.send_to(buf, &src)?;///     } // the socket is closed here/// each of the addresses until one succeeds and returns the socket. If none/// of the addresses succeed in creating a socket, the error returned from/// the last attempt (the last address) is returned./// Creates a UDP socket bound to `127.0.0.1:3400`:/// let socket = UdpSocket::bind("127.0.0.1:3400").expect("couldn't bind to address");/// Creates a UDP socket bound to `127.0.0.1:3400`. If the socket cannot be/// bound to that address, create a UDP socket bound to `127.0.0.1:3401`:/// use std::net::{SocketAddr, UdpSocket};///     SocketAddr::from(([127, 0, 0, 1], 3400)),///     SocketAddr::from(([127, 0, 0, 1], 3401)),/// let socket = UdpSocket::bind(&addrs[..]).expect("couldn't bind to address");/// Creates a UDP socket bound to a port assigned by the operating system/// let socket = UdpSocket::bind("127.0.0.1:0").unwrap();/// Note that `bind` declares the scope of your network connection./// You can only receive datagrams from and send datagrams to/// participants in that view of the network./// For instance, binding to a loopback address as in the example/// above will prevent you from sending datagrams to another device/// in your local network./// In order to limit your view of the network the least, `bind` to/// [`Ipv4Addr::UNSPECIFIED`] or [`Ipv6Addr::UNSPECIFIED`]./// Receives a single datagram message on the socket. On success, returns the number/// of bytes read and the origin./// The function must be called with valid byte array `buf` of sufficient size to/// hold the message bytes. If a message is too long to fit in the supplied buffer,/// excess bytes may be discarded./// let socket = UdpSocket::bind("127.0.0.1:34254").expect("couldn't bind to address");/// let (number_of_bytes, src_addr) = socket.recv_from(&mut buf)///                                         .expect("Didn't receive data");/// let filled_buf = &mut buf[..number_of_bytes];/// Receives a single datagram message on the socket, without removing it from the/// queue. On success, returns the number of bytes read and the origin./// Do not use this function to implement busy waiting, instead use `libc::poll` to/// synchronize IO events on one or more sockets./// let (number_of_bytes, src_addr) = socket.peek_from(&mut buf)/// number of bytes written. Note that the operating system may refuse/// buffers larger than 65507. However, partial writes are not possible/// until buffer sizes above `i32::MAX`./// This will return an error when the IP version of the local socket/// does not match that returned from [`ToSocketAddrs`]./// See [Issue #34202] for more details./// socket.send_to(&[0; 10], "127.0.0.1:4242").expect("couldn't send data");/// [Issue #34202]: https://github.com/rust-lang/rust/issues/34202/// use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket};/// socket.connect("192.168.0.1:41203").expect("couldn't connect to address");/// assert_eq!(socket.peer_addr().unwrap(),///            SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 168, 0, 1), 41203)));/// If the socket isn't connected, it will return a [`NotConnected`] error./// [`NotConnected`]: io::ErrorKind::NotConnected/// assert_eq!(socket.peer_addr().unwrap_err().kind(),///            std::io::ErrorKind::NotConnected);/// assert_eq!(socket.local_addr().unwrap(),///            SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 34254)));/// The returned `UdpSocket` is a reference to the same socket that this/// object references. Both handles will read and write the same port, and/// options set on one socket will be propagated to the other./// let socket_clone = socket.try_clone().expect("couldn't clone the socket");/// [`read`]: io::Read::read/// socket.set_read_timeout(None).expect("set_read_timeout call failed");/// let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();/// let result = socket.set_read_timeout(Some(Duration::new(0, 0)));/// [`write`]: io::Write::write/// socket.set_write_timeout(None).expect("set_write_timeout call failed");/// let result = socket.set_write_timeout(Some(Duration::new(0, 0)));/// assert_eq!(socket.read_timeout().unwrap(), None);/// assert_eq!(socket.write_timeout().unwrap(), None);/// socket.set_broadcast(false).expect("set_broadcast call failed");/// For more information about this option, see [`UdpSocket::set_broadcast`]./// assert_eq!(socket.broadcast().unwrap(), false);/// Note that this might not have any effect on IPv6 sockets./// socket.set_multicast_loop_v4(false).expect("set_multicast_loop_v4 call failed");/// For more information about this option, see [`UdpSocket::set_multicast_loop_v4`]./// assert_eq!(socket.multicast_loop_v4().unwrap(), false);/// socket.set_multicast_ttl_v4(42).expect("set_multicast_ttl_v4 call failed");/// For more information about this option, see [`UdpSocket::set_multicast_ttl_v4`]./// assert_eq!(socket.multicast_ttl_v4().unwrap(), 42);/// Note that this might not have any affect on IPv4 sockets./// socket.set_multicast_loop_v6(false).expect("set_multicast_loop_v6 call failed");/// For more information about this option, see [`UdpSocket::set_multicast_loop_v6`]./// assert_eq!(socket.multicast_loop_v6().unwrap(), false);/// socket.set_ttl(42).expect("set_ttl call failed");/// For more information about this option, see [`UdpSocket::set_ttl`]./// assert_eq!(socket.ttl().unwrap(), 42);/// multicast group. If it's equal to [`UNSPECIFIED`](Ipv4Addr::UNSPECIFIED)/// then an appropriate interface is chosen by the system./// For more information about this option, see [`UdpSocket::join_multicast_v4`]./// For more information about this option, see [`UdpSocket::join_multicast_v6`]./// match socket.take_error() {///     Ok(Some(error)) => println!("UdpSocket error: {error:?}"),///     Ok(None) => println!("No error"),///     Err(error) => println!("UdpSocket.take_error failed: {error:?}"),/// Connects this UDP socket to a remote address, allowing the `send` and/// `recv` syscalls to be used to send data and also applies filters to only/// receive data from the specified address./// each of the addresses until the underlying OS function returns no/// error. Note that usually, a successful `connect` call does not specify/// that there is a remote server listening on the port, rather, such an/// error would only be detected after the first send. If the OS returns an/// error for each of the specified addresses, the error returned from the/// last connection attempt (the last address) is returned./// Creates a UDP socket bound to `127.0.0.1:3400` and connect the socket to/// `127.0.0.1:8080`:/// socket.connect("127.0.0.1:8080").expect("connect function failed");/// Unlike in the TCP case, passing an array of addresses to the `connect`/// function of a UDP socket is not a useful thing to do: The OS will be/// unable to determine whether something is listening on the remote/// address without the application sending data./// If your first `connect` is to a loopback address, subsequent/// `connect`s to non-loopback addresses might fail, depending/// on the platform./// Sends data on the socket to the remote address to which it is connected./// On success, returns the number of bytes written. Note that the operating/// system may refuse buffers larger than 65507. However, partial writes are/// not possible until buffer sizes above `i32::MAX`./// [`UdpSocket::connect`] will connect this socket to a remote address. This/// socket.send(&[0, 1, 2]).expect("couldn't send message");/// Receives a single datagram message on the socket from the remote address to/// which it is connected. On success, returns the number of bytes read./// match socket.recv(&mut buf) {///     Ok(received) => println!("received {received} bytes {:?}", &buf[..received]),///     Err(e) => println!("recv function failed: {e:?}"),/// Receives single datagram on the socket from the remote address to which it is/// connected, without removing the message from input queue. On success, returns/// the number of bytes peeked./// This method will fail if the socket is not connected. The `connect` method/// will connect this socket to a remote address./// match socket.peek(&mut buf) {///     Ok(received) => println!("received {received} bytes"),///     Err(e) => println!("peek function failed: {e:?}"),/// Moves this UDP socket into or out of nonblocking mode./// This will result in `recv`, `recv_from`, `send`, and `send_to` system/// operations becoming nonblocking, i.e., immediately returning from their/// calls. If the IO operation is successful, `Ok` is returned and no/// further action is required. If the IO operation could not be completed/// and needs to be retried, an error with kind/// [`io::ErrorKind::WouldBlock`] is returned./// Creates a UDP socket bound to `127.0.0.1:7878` and read bytes in/// nonblocking mode:/// let socket = UdpSocket::bind("127.0.0.1:7878").unwrap();/// socket.set_nonblocking(true).unwrap();/// let (num_bytes_read, _) = loop {///     match socket.recv_from(&mut buf) {///         Ok(n) => break n,/// println!("bytes: {:?}", &buf[..num_bytes_read]);// In addition to the `impl`s here, `UdpSocket` also has `impl`s forcmath/// example, `f128::powf(f128::NAN, 0.0)` returns `1.0`. However, if an input is a *signaling*/// let abs_difference = (x.powf(2.0) - (x * x)).abs();/// assert_eq!(f128::powf(1.0, f128::NAN), 1.0);/// assert_eq!(f128::powf(f128::NAN, 0.0), 1.0);/// assert_eq!(f128::powf(0.0, 0.0), 1.0);/// let one = 1.0f128;/// let f = 2.0f128;/// This returns NaN when the number is negative, and negative infinity when number is zero./// Non-positive values:/// assert_eq!(0_f128.ln(), f128::NEG_INFINITY);/// assert!((-42_f128).ln().is_nan());/// let five = 5.0f128;/// // log5(5) - 1 == 0/// let abs_difference = (five.log(5.0) - 1.0).abs();/// assert_eq!(0_f128.log(10.0), f128::NEG_INFINITY);/// assert!((-42_f128).log(10.0).is_nan());/// let two = 2.0f128;/// assert_eq!(0_f128.log2(), f128::NEG_INFINITY);/// assert!((-42_f128).log2().is_nan());/// let ten = 10.0f128;/// assert_eq!(0_f128.log10(), f128::NEG_INFINITY);/// assert!((-42_f128).log10().is_nan());/// This function currently corresponds to the `cbrtf128` from libc on Unix/// let x = 8.0f128;/// This function currently corresponds to the `hypotf128` from libc on Unix/// let x = 2.0f128;/// let y = 3.0f128;/// let x = std::f128::consts::FRAC_PI_2;/// let x = 2.0 * std::f128::consts::PI;/// This function currently corresponds to the `tanf128` from libc on Unix and/// Windows. Note that this might change in the future./// let x = std::f128::consts::FRAC_PI_4;/// This function currently corresponds to the `asinf128` from libc on Unix/// let f = std::f128::consts::FRAC_PI_4;/// let abs_difference = (f.sin().asin() - f).abs();/// This function currently corresponds to the `acosf128` from libc on Unix/// let abs_difference = (f.cos().acos() - std::f128::consts::FRAC_PI_4).abs();/// This function currently corresponds to the `atanf128` from libc on Unix/// let f = 1.0f128;///  | `x`     | `y`     | Piecewise Definition | Range         |///  |---------|---------|----------------------|---------------|///  | `>= +0` | `>= +0` | `arctan(y/x)`        | `[+0, +pi/2]` |///  | `>= +0` | `<= -0` | `arctan(y/x)`        | `[-pi/2, -0]` |///  | `<= -0` | `>= +0` | `arctan(y/x) + pi`   | `[+pi/2, +pi]`|///  | `<= -0` | `<= -0` | `arctan(y/x) - pi`   | `[-pi, -pi/2]`|/// This function currently corresponds to the `atan2f128` from libc on Unix/// let x1 = 3.0f128;/// let y1 = -3.0f128;/// let x2 = -3.0f128;/// let y2 = 3.0f128;/// let abs_difference_1 = (y1.atan2(x1) - (-std::f128::consts::FRAC_PI_4)).abs();/// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f128::consts::FRAC_PI_4)).abs();/// assert!(abs_difference_1 <= f128::EPSILON);/// assert!(abs_difference_2 <= f128::EPSILON);/// This function currently corresponds to the `(f128::sin(x),/// f128::cos(x))`. Note that this might change in the future./// assert!(abs_difference_0 <= f128::EPSILON);/// This function currently corresponds to the `expm1f128` from libc on Unix/// let x = 1e-8_f128;/// let abs_difference = (x.exp_m1() - approx).abs();/// This returns NaN when `n < -1.0`, and negative infinity when `n == -1.0`./// This function currently corresponds to the `log1pf128` from libc on Unix/// let abs_difference = (x.ln_1p() - approx).abs();/// Out-of-range values:/// assert_eq!((-1.0_f128).ln_1p(), f128::NEG_INFINITY);/// assert!((-2.0_f128).ln_1p().is_nan());/// This function currently corresponds to the `sinhf128` from libc on Unix/// let e = std::f128::consts::E;/// This function currently corresponds to the `coshf128` from libc on Unix/// This function currently corresponds to the `tanhf128` from libc on Unix/// let x = std::f128::consts::FRAC_PI_6;/// let f = x.tanh().atanh();/// Gamma function./// This function currently corresponds to the `tgammaf128` from libc on Unix/// #![feature(float_gamma)]/// let x = 5.0f128;/// let abs_difference = (x.gamma() - 24.0).abs();// #[unstable(feature = "float_gamma", issue = "99842")]ln_gamma/// Natural logarithm of the absolute value of the gamma function/// The integer part of the tuple indicates the sign of the gamma function./// This function currently corresponds to the `lgammaf128_r` from libc on Unix/// let abs_difference = (x.ln_gamma().0 - 0.0).abs();/// Error function./// This function currently corresponds to the `erff128` from libc on Unix/// #![feature(float_erf)]/// /// The error function relates what percent of a normal distribution lies/// /// within `x` standard deviations (scaled by `1/sqrt(2)`)./// fn within_standard_deviations(x: f128) -> f128 {///     (x * std::f128::consts::FRAC_1_SQRT_2).erf() * 100.0/// // 68% of a normal distribution is within one standard deviation/// assert!((within_standard_deviations(1.0) - 68.269).abs() < 0.01);/// // 95% of a normal distribution is within two standard deviations/// assert!((within_standard_deviations(2.0) - 95.450).abs() < 0.01);/// // 99.7% of a normal distribution is within three standard deviations/// assert!((within_standard_deviations(3.0) - 99.730).abs() < 0.01);// #[unstable(feature = "float_erf", issue = "136321")]/// Complementary error function./// This function currently corresponds to the `erfcf128` from libc on Unix/// let x: f128 = 0.123;/// let one = x.erf() + x.erfc();/// let abs_difference = (one - 1.0).abs();//! *[See also the `f128` primitive type](primitive@f128).*/// example, `f16::powf(f16::NAN, 0.0)` returns `1.0`. However, if an input is a *signaling*/// assert_eq!(f16::powf(1.0, f16::NAN), 1.0);/// assert_eq!(f16::powf(f16::NAN, 0.0), 1.0);/// assert_eq!(f16::powf(0.0, 0.0), 1.0);/// let one = 1.0f16;/// let f = 2.0f16;/// assert_eq!(0_f16.ln(), f16::NEG_INFINITY);/// assert!((-42_f16).ln().is_nan());/// let five = 5.0f16;/// assert_eq!(0_f16.log(10.0), f16::NEG_INFINITY);/// assert!((-42_f16).log(10.0).is_nan());/// let two = 2.0f16;/// assert_eq!(0_f16.log2(), f16::NEG_INFINITY);/// assert!((-42_f16).log2().is_nan());/// let ten = 10.0f16;/// assert_eq!(0_f16.log10(), f16::NEG_INFINITY);/// assert!((-42_f16).log10().is_nan());/// This function currently corresponds to the `hypotf` from libc on Unix/// let x = 2.0f16;/// let y = 3.0f16;/// let x = std::f16::consts::FRAC_PI_2;/// let x = 2.0 * std::f16::consts::PI;/// This function currently corresponds to the `tanf` from libc on Unix and/// let x = std::f16::consts::FRAC_PI_4;/// This function currently corresponds to the `asinf` from libc on Unix/// let f = std::f16::consts::FRAC_PI_4;/// This function currently corresponds to the `acosf` from libc on Unix/// let abs_difference = (f.cos().acos() - std::f16::consts::FRAC_PI_4).abs();/// This function currently corresponds to the `atanf` from libc on Unix/// let f = 1.0f16;/// This function currently corresponds to the `atan2f` from libc on Unix/// let x1 = 3.0f16;/// let y1 = -3.0f16;/// let x2 = -3.0f16;/// let y2 = 3.0f16;/// let abs_difference_1 = (y1.atan2(x1) - (-std::f16::consts::FRAC_PI_4)).abs();/// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f16::consts::FRAC_PI_4)).abs();/// assert!(abs_difference_1 <= f16::EPSILON);/// assert!(abs_difference_2 <= f16::EPSILON);/// This function currently corresponds to the `(f16::sin(x),/// f16::cos(x))`. Note that this might change in the future./// assert!(abs_difference_0 <= f16::EPSILON);/// This function currently corresponds to the `expm1f` from libc on Unix/// let x = 1e-4_f16;/// assert!(abs_difference < 1e-4);/// This function currently corresponds to the `log1pf` from libc on Unix/// assert_eq!((-1.0_f16).ln_1p(), f16::NEG_INFINITY);/// assert!((-2.0_f16).ln_1p().is_nan());/// This function currently corresponds to the `sinhf` from libc on Unix/// let e = std::f16::consts::E;/// This function currently corresponds to the `coshf` from libc on Unix/// This function currently corresponds to the `tanhf` from libc on Unix/// let x = std::f16::consts::FRAC_PI_6;/// This function currently corresponds to the `tgammaf` from libc on Unix/// let x = 5.0f16;/// This function currently corresponds to the `lgamma_r` from libc on Unix/// This function currently corresponds to the `erff` from libc on Unix/// fn within_standard_deviations(x: f16) -> f16 {///     (x * std::f16::consts::FRAC_1_SQRT_2).erf() * 100.0/// assert!((within_standard_deviations(1.0) - 68.269).abs() < 0.1);/// assert!((within_standard_deviations(2.0) - 95.450).abs() < 0.1);/// assert!((within_standard_deviations(3.0) - 99.730).abs() < 0.1);/// This function currently corresponds to the `erfcf` from libc on Unix/// let x: f16 = 0.123;//! *[See also the `f16` primitive type](primitive@f16).*/// assert_eq!(one_plus_eps.mul_add(one_minus_eps, minus_one), -f32::EPSILON * f32::EPSILON);/// assert!((-f32::EPSILON).rem_euclid(3.0) != 0.0);/// example, `f32::powi(f32::NAN, 0)` returns `1.0`. However, if an input is a *signaling*/// assert_eq!(f32::powi(f32::NAN, 0), 1.0);/// assert_eq!(f32::powi(0.0, 0), 1.0);/// example, `f32::powf(f32::NAN, 0.0)` returns `1.0`. However, if an input is a *signaling*/// assert_eq!(f32::powf(1.0, f32::NAN), 1.0);/// assert_eq!(f32::powf(f32::NAN, 0.0), 1.0);/// assert_eq!(f32::powf(0.0, 0.0), 1.0);/// let one = 1.0f32;/// let f = 2.0f32;/// assert_eq!(0_f32.ln(), f32::NEG_INFINITY);/// assert!((-42_f32).ln().is_nan());/// let five = 5.0f32;/// assert_eq!(0_f32.log(10.0), f32::NEG_INFINITY);/// assert!((-42_f32).log(10.0).is_nan());/// let two = 2.0f32;/// assert_eq!(0_f32.log2(), f32::NEG_INFINITY);/// assert!((-42_f32).log2().is_nan());/// let ten = 10.0f32;/// assert_eq!(0_f32.log10(), f32::NEG_INFINITY);/// assert!((-42_f32).log10().is_nan());/// * If `self <= other`: `0.0`/// This function currently corresponds to the `fdimf` from libc on Unix/// let x = 2.0f32;/// let y = 3.0f32;/// let x = std::f32::consts::FRAC_PI_2;/// let x = 2.0 * std::f32::consts::PI;/// let x = std::f32::consts::FRAC_PI_4;/// let f = std::f32::consts::FRAC_PI_4;/// let abs_difference = (f.cos().acos() - std::f32::consts::FRAC_PI_4).abs();/// let f = 1.0f32;/// let x1 = 3.0f32;/// let y1 = -3.0f32;/// let x2 = -3.0f32;/// let y2 = 3.0f32;/// let abs_difference_1 = (y1.atan2(x1) - (-std::f32::consts::FRAC_PI_4)).abs();/// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f32::consts::FRAC_PI_4)).abs();/// assert!(abs_difference_1 <= 1e-5);/// assert!(abs_difference_2 <= 1e-5);/// This function currently corresponds to the `(f32::sin(x),/// f32::cos(x))`. Note that this might change in the future./// assert!(abs_difference_0 <= 1e-4);/// assert!(abs_difference_1 <= 1e-4);/// let x = 1e-8_f32;/// assert_eq!((-1.0_f32).ln_1p(), f32::NEG_INFINITY);/// assert!((-2.0_f32).ln_1p().is_nan());/// let e = std::f32::consts::E;/// let x = std::f32::consts::FRAC_PI_6;/// let x = 5.0f32;/// fn within_standard_deviations(x: f32) -> f32 {///     (x * std::f32::consts::FRAC_1_SQRT_2).erf() * 100.0/// let x: f32 = 0.123;//! *[See also the `f32` primitive type](primitive@f32).*/// assert_eq!(one_plus_eps.mul_add(one_minus_eps, minus_one), -f64::EPSILON * f64::EPSILON);/// assert!((-f64::EPSILON).rem_euclid(3.0) != 0.0);/// example, `f64::powi(f64::NAN, 0)` returns `1.0`. However, if an input is a *signaling*/// assert!(abs_difference <= 1e-14);/// assert_eq!(f64::powi(f64::NAN, 0), 1.0);/// assert_eq!(f64::powi(0.0, 0), 1.0);/// example, `f64::powf(f64::NAN, 0.0)` returns `1.0`. However, if an input is a *signaling*/// assert_eq!(f64::powf(1.0, f64::NAN), 1.0);/// assert_eq!(f64::powf(f64::NAN, 0.0), 1.0);/// assert_eq!(f64::powf(0.0, 0.0), 1.0);/// assert_eq!(0_f64.ln(), f64::NEG_INFINITY);/// assert!((-42_f64).ln().is_nan());/// let abs_difference = (twenty_five.log(5.0) - 2.0).abs();/// assert_eq!(0_f64.log(10.0), f64::NEG_INFINITY);/// assert!((-42_f64).log(10.0).is_nan());/// let abs_difference = (four.log2() - 2.0).abs();/// assert_eq!(0_f64.log2(), f64::NEG_INFINITY);/// assert!((-42_f64).log2().is_nan());/// let abs_difference = (hundred.log10() - 2.0).abs();/// assert_eq!(0_f64.log10(), f64::NEG_INFINITY);/// assert!((-42_f64).log10().is_nan());/// This function currently corresponds to the `fdim` from libc on Unix and/// This function currently corresponds to the `cbrt` from libc on Unix and/// This function currently corresponds to the `hypot` from libc on Unix/// This function currently corresponds to the `tan` from libc on Unix and/// This function currently corresponds to the `asin` from libc on Unix and/// This function currently corresponds to the `acos` from libc on Unix and/// let abs_difference = (f.cos().acos() - std::f64::consts::FRAC_PI_4).abs();/// This function currently corresponds to the `atan` from libc on Unix and/// This function currently corresponds to the `atan2` from libc on Unix/// let abs_difference_1 = (y1.atan2(x1) - (-std::f64::consts::FRAC_PI_4)).abs();/// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f64::consts::FRAC_PI_4)).abs();/// This function currently corresponds to the `(f64::sin(x),/// f64::cos(x))`. Note that this might change in the future./// This function currently corresponds to the `expm1` from libc on Unix/// This function currently corresponds to the `log1p` from libc on Unix/// assert_eq!((-1.0_f64).ln_1p(), f64::NEG_INFINITY);/// assert!((-2.0_f64).ln_1p().is_nan());/// This function currently corresponds to the `sinh` from libc on Unix/// This function currently corresponds to the `cosh` from libc on Unix/// This function currently corresponds to the `tanh` from libc on Unix/// let x = std::f64::consts::FRAC_PI_6;/// This function currently corresponds to the `tgamma` from libc on Unix/// let x = 5.0f64;/// assert!(abs_difference <= 1e-10);/// let x = 2.0f64;/// assert!(abs_difference <= f64::EPSILON);/// This function currently corresponds to the `erf` from libc on Unix/// fn within_standard_deviations(x: f64) -> f64 {///     (x * std::f64::consts::FRAC_1_SQRT_2).erf() * 100.0/// This function currently corresponds to the `erfc` from libc on Unix/// let x: f64 = 0.123;//! *[See also the `f64` primitive type](primitive@f64).*//! Additional functionality for numerics.//! This module provides some extra types that are useful when doing numerical//! work. See the individual documentation for each piece for more information./// Returns the device ID on which this file resides./// use std::os::aix::fs::MetadataExt;///     let meta = fs::metadata("some_file")?;///     println!("{}", meta.st_dev());/// Returns the inode number.///     println!("{}", meta.st_ino());/// Returns the file type and mode.///     println!("{}", meta.st_mode());/// Returns the number of hard links to file.///     println!("{}", meta.st_nlink());/// Returns the user ID of the file owner.///     println!("{}", meta.st_uid());/// Returns the group ID of the file owner.///     println!("{}", meta.st_gid());/// Returns the device ID that this file represents. Only relevant for special file.///     println!("{}", meta.st_rdev());/// Returns the size of the file (if it is a regular file or a symbolic link) in bytes./// The size of a symbolic link is the length of the pathname it contains,/// without a terminating null byte.///     println!("{}", meta.st_size());/// Returns the last access time of the file, in seconds since Unix Epoch.///     println!("{}", meta.st_atime());/// Returns the last access time of the file, in nanoseconds since [`st_atime`]./// [`st_atime`]: Self::st_atime///     println!("{}", meta.st_atime_nsec());/// Returns the last modification time of the file, in seconds since Unix Epoch.///     println!("{}", meta.st_mtime());/// Returns the last modification time of the file, in nanoseconds since [`st_mtime`]./// [`st_mtime`]: Self::st_mtime///     println!("{}", meta.st_mtime_nsec());/// Returns the last status change time of the file, in seconds since Unix Epoch.///     println!("{}", meta.st_ctime());/// Returns the last status change time of the file, in nanoseconds since [`st_ctime`]./// [`st_ctime`]: Self::st_ctime///     println!("{}", meta.st_ctime_nsec());/// Returns the "preferred" block size for efficient filesystem I/O.///     println!("{}", meta.st_blksize());/// Returns the number of blocks allocated to the file, 512-byte units.///     println!("{}", meta.st_blocks());/// OS-specific extensions to [`fs::Metadata`]./// [`fs::Metadata`]: crate::fs::Metadata//! AIX specific extensions to primitives in the [`std::fs`] module.//! [`std::fs`]: crate::fs//! AIX specific definitions.//! AIX specific raw type definitions.as_raw_stat/// Gain a reference to the underlying `stat` structure which contains/// the raw information returned by the OS./// The contents of the returned `stat` are **not** consistent across/// Unix platforms. The `os::unix::fs::MetadataExt` trait contains the/// cross-Unix abstractions contained within the raw stat.//! Android-specific definitionslinux_extUnixSocketExtTcpStreamExt//! Android-specific networking functionality.//! Android-specific raw type definitions//! Cygwin-specific definitions//! Cygwin-specific networking functionality.//! There are some limitations of Unix domain sockets on Cygwin://! * The syscalls `accept` and `connect` need//! [handshake](https://inbox.sourceware.org/cygwin/Z_UERXFI1g-1v3p2@calimero.vinschen.de/T/#t).//! * Cannot bind to abstract addr.//! * Unbounded unix socket has an abstract local addr.//! * Doesn't support recvmsg with control data.//! Cygwin-specific raw type definitions.// Only available on macOS and iOS, since they were stably exposed there.st_qspareset_created/// Set the creation time of a file.FileTimesExt/// OS-specific extensions to [`fs::FileTimes`].//! Darwin-specific extension traits to [`fs`].// deprecated, but used for public reexport under `std::os::unix::raw`, as// well as `std::os::macos`/`std::os::ios`, because those modules precede the// decision to remove these.//! Platform-specific extensions to `std` for Darwin / Apple platforms.darwin// We can't generate an intra-doc link for this automatically since `core::os::darwin` isn't// compiled into `core` on every platform even though it's documented on every platform.// We just link to it directly in the module documentation above instead.//! This module re-exports all the items in [`core::os::darwin::objc`].//! [`core::os::darwin::objc`]: ../../../../core/os/darwin/objc/index.html "mod core::os::darwin::objc"//! Apple-specific raw type definitions//! Dragonfly-specific definitions//! Dragonfly-specific raw type definitions//! Linux-specific definitions//! Emscripten-specific raw type definitionsst_spare4//! Definitions for the ESP-IDF framework.//! Raw type definitions for the ESP-IDF framework.// Implementations for `AsRawFd` etc. for network types.impl_as_raw_fdimpl_from_raw_fdimpl_into_raw_fdValidRawFd/// # use std::os::fd::{AsFd, BorrowedFd};/// Takes ownership of a [`File`](fs::File)'s underlying file descriptor./// Returns a [`File`](fs::File) that takes ownership of the given/// Takes ownership of a [`TcpStream`](crate::net::TcpStream)'s socket file descriptor./// Takes ownership of a [`TcpListener`](crate::net::TcpListener)'s socket file descriptor./// Takes ownership of a [`UdpSocket`](crate::net::UdpSocket)'s file descriptor./// This impl allows implementing traits that require `AsFd` on Arc./// # #[cfg(any(unix, target_os = "wasi"))] mod group_cfg {/// # use std::os::wasi::io::AsFd;/// trait MyTrait: AsFd {}/// impl MyTrait for Arc<UdpSocket> {}/// impl MyTrait for Box<UdpSocket> {}/// use std::os::fd::{AsRawFd, RawFd};/// // Note that `raw_fd` is only valid as long as `f` exists./// use std::os::fd::{FromRawFd, IntoRawFd, RawFd};"losing the raw file descriptor may leak resources"/// use std::os::fd::{IntoRawFd, RawFd};/// This impl allows implementing traits that require `AsRawFd` on Arc./// # use std::os::wasi::io::AsRawFd;/// trait MyTrait: AsRawFd {test_raw_fdtest_fdtest_niche_optimizations/// Wrapper struct to force 16-byte alignment./// Wrapper struct to force 128-byte alignment.Align512/// Wrapper struct to force 512-byte alignment.ENCLU_EREPORTENCLU_EGETKEYegetkey/// Call the `EGETKEY` instruction to obtain a 128-bit secret key.ereport/// Call the `EREPORT` instruction./// This creates a cryptographic report describing the contents of the current/// enclave. The report may be verified by the enclave described in/// `targetinfo`.//! SGX-specific access to architectural features.//! The functionality in this module is further documented in the Intel//! Software Developer's Manual, Volume 3, Chapter 40."../unix/ffi/os_str.rs"//! SGX-specific extension to the primitives in the `std::ffi` module//! use std::ffi::OsString;//! use std::os::fortanix_sgx::ffi::OsStringExt;//! let bytes = b"foo".to_vec();//! // OsStringExt::from_vec//! let os_string = OsString::from_vec(bytes);//! assert_eq!(os_string.to_str(), Some("foo"));//! // OsStringExt::into_vec//! let bytes = os_string.into_vec();//! assert_eq!(bytes, b"foo");//! use std::os::fortanix_sgx::ffi::OsStrExt;//! let bytes = b"foo";//! // OsStrExt::from_bytes//! let os_str = OsStr::from_bytes(bytes);//! assert_eq!(os_str.to_str(), Some("foo"));//! // OsStrExt::as_bytes//! let bytes = os_str.as_bytes();TryIntoInner/// This method does **not** pass ownership of the raw file descriptor/// to the caller. The descriptor is only guaranteed to be valid while/// the original object has not yet been destroyed./// A trait to extract the raw SGX file descriptor from an underlying/// An associated type that contains relevant metadata for `Self`./// descriptor and metadata.// FIXME: say something about `metadata`.try_into_raw_fd/// Consumes this object, returning the raw underlying file descriptor, if/// this object is not cloned./// This function **transfers ownership** of the underlying file descriptor/// to the caller. Callers are then the unique owners of the file descriptor/// and must close the descriptor once it's no longer needed./// Unlike other platforms, on SGX, the file descriptor is shared between/// all clones of an object. To avoid race conditions, this function will/// only return `Ok` when called on the final clone.TryIntoRawFd/// Local address of the TCP stream/// Peer address of the TCP streamTcpStreamMetadata/// Metadata for `TcpStream`./// Local address of the TCP listenerTcpListenerMetadata/// Metadata for `TcpListener`.//! SGX-specific extensions to general I/O primitives//! SGX file descriptors behave differently from Unix file descriptors. See the//! description of [`TryIntoRawFd`] for more details./// Primitives for allocating memory in userspace as well as copying data/// to and from user memory.ByteBufferEV_RETURNQ_NOT_EMPTYEV_USERCALLQ_NOT_FULLFD_STDERRFD_STDINFD_STDOUTFifoDescriptorRESULT_SUCCESSRegisterArgumentUSERCALL_USER_DEFINEDUsercallUsercallsUsercallNrsWAIT_NOasync_queuesbind_streamconnect_streamdo_usercallinsecure_timelaunch_threadread_alloc/// Lowest-level interfaces to usercalls and usercall ABI type definitions./// Low-level interfaces to usercalls. See the [ABI documentation] for more/// [ABI documentation]: https://docs.rs/fortanix-sgx-abi//// Functions for querying mapping information for pointers./// Functions for querying thread-related information.//! Functionality specific to the `x86_64-fortanix-unknown-sgx` target.//! This includes functions to deal with memory isolation, usercalls, and the//! SGX instruction set.//! FreeBSD-specific definitionslocal_creds_persistent/// Query the current setting of socket option `LOCAL_CREDS_PERSISTENT`.set_local_creds_persistent/// Enable or disable socket option `LOCAL_CREDS_PERSISTENT`./// This option enables the credentials of the sending process to be/// received as a control message in [`AncillaryData`]./// [`AncillaryData`]: net::AncillaryData/// #![feature(unix_socket_ancillary_data)]/// use std::os::freebsd::net::UnixSocketExt;///     let sock = UnixDatagram::unbound()?;///     sock.set_local_creds_persistent(true).expect("set_local_creds_persistent failed");acceptfilter/// Gets a filter name if one had been set previously on the socket.set_acceptfilter/// Set or disable a filter on the socket to filter incoming connections/// to defer it before accept(2)/// FreeBSD-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]/// and [`UnixStream`]./// [`UnixDatagram`]: net::UnixDatagram/// [`UnixStream`]: net::UnixStream//! FreeBSD-specific networking functionality.//! FreeBSD-specific raw type definitions//! Fuchsia-specific definitionsst_pad5//! Fuchsia-specific raw type definitionsst_crtimest_crtime_nsec//! Haiku-specific definitions// Use the direct definition of usize, instead of uintptr_t like in libc//! Haiku-specific raw type definitions//! HermitCore-specific extension to the primitives in the `std::ffi` module//! use std::os::hermit::ffi::OsStringExt;//! use std::os::hermit::ffi::OsStrExt;/// A prelude for conveniently writing platform-specific code./// Includes all extension traits, and some important type definitions.//! Definitions for Horizon OS// This exists for parity with other `raw` modules, but isn't actually used.//! Horizon OS raw type definitions/// use std::os::hurd::fs::MetadataExt;//! Hurd-specific extensions to primitives in the [`std::fs`] module.//! Hurd-specific definitions//! Hurd-specific raw type definitions//! illumos-specific definitionsso_exclbind/// Enables exclusive binding on the socket./// If true and if the socket had been set with `SO_REUSEADDR`,/// it neutralises its effect./// See [`man 3 tcp`](https://docs.oracle.com/cd/E88353_01/html/E37843/setsockopt-3c.html)exclbind/// Get the bind exclusivity bind state of the socket./// illumos-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]//! illumos-specific networking functionality.//! illumos-specific raw type definitions/// iOS-specific raw type definitions//! iOS-specific definitions/// The contents of the returned [`stat`] are **not** consistent across/// [`stat`]: struct@crate::os::linux::raw::stat/// use std::os::linux::fs::MetadataExt;///     let stat = meta.as_raw_stat();//! L4Re-specific extensions to primitives in the [`std::fs`] module.//! L4Re-specific definitions.//! L4Re-specific raw type definitions.//! Linux-specific extensions to primitives in the [`std::fs`] module.//! Linux-specific definitions.//! Linux-specific networking functionality.InnerPidFd/// This type represents a file descriptor that refers to a process./// A `PidFd` can be obtained by setting the corresponding option on [`Command`]/// with [`create_pidfd`]. Subsequently, the created pidfd can be retrieved/// from the [`Child`] by calling [`pidfd`] or [`into_pidfd`]./// #![feature(linux_pidfd)]/// use std::os::linux::process::{CommandExt, ChildExt};///     .create_pidfd(true)///     .expect("Failed to spawn child");/// let pidfd = child///     .into_pidfd()///     .expect("Failed to retrieve pidfd");/// // The file descriptor will be closed when `pidfd` is dropped./// Refer to the man page of [`pidfd_open(2)`] for further details./// [`Command`]: process::Command/// [`create_pidfd`]: CommandExt::create_pidfd/// [`Child`]: process::Child/// [`pidfd`]: fn@ChildExt::pidfd/// [`into_pidfd`]: ChildExt::into_pidfd/// [`pidfd_open(2)`]: https://man7.org/linux/man-pages/man2/pidfd_open.2.html/// Unlike [`Child::kill`] it is possible to attempt to kill/// reaped children since PidFd does not suffer from pid recycling/// races. But doing so will return an Error./// [`Child::kill`]: process::Child::kill/// Waits for the child to exit completely, returning the status that it exited with./// Unlike [`Child::wait`] it does not ensure that the stdin handle is closed./// Additionally it will not return an `ExitStatus` if the child/// has already been reaped. Instead an error will be returned./// [`Child::wait`]: process::Child::wait/// Attempts to collect the exit status of the child if it has already exited./// Unlike [`Child::try_wait`] this method will return an Error/// if the child has already been reaped./// [`Child::try_wait`]: process::Child::try_wait/// Obtains a reference to the [`PidFd`] created for this [`Child`], if available./// A pidfd will only be available if its creation was requested with/// [`create_pidfd`] when the corresponding [`Command`] was created./// Even if requested, a pidfd may not be available due to an older/// version of Linux being in use, or if some other error occurred.into_pidfd/// Returns the [`PidFd`] created for this [`Child`], if available./// Otherwise self is returned./// Taking ownership of the PidFd consumes the Child to avoid pid reuse/// races. Use [`pidfd`] and [`BorrowedFd::try_clone_to_owned`] if/// you don't want to disassemble the Child yet./// [`pidfd`]: ChildExt::pidfdChildExt/// Os-specific extensions for [`Child`]create_pidfd/// Sets whether a [`PidFd`](struct@PidFd) should be created for the [`Child`]/// spawned by this [`Command`]./// By default, no pidfd will be created./// The pidfd can be retrieved from the child with [`pidfd`] or [`into_pidfd`]./// A pidfd will only be created if it is possible to do so/// in a guaranteed race-free manner. Otherwise, [`pidfd`] will return an error./// If a pidfd has been successfully created and not been taken from the `Child`/// then calls to `kill()`, `wait()` and `try_wait()` will use the pidfd/// instead of the pid. This can prevent pid recycling races, e.g./// those  caused by rogue libraries in the same process prematurely reaping/// zombie children via `waitpid(-1, ...)` calls./// Os-specific extensions for [`Command`]//! Linux-specific extensions to primitives in the [`std::process`] module.//! [`std::process`]: crate::process//! Linux-specific raw type definitions./// macOS-specific raw type definitions//! macOS-specific definitions// unix// linux// The code below could be written clearer using `cfg_if!`. However, the items below are// publicly exported by `std` and external tools can have trouble analysing them because of the use// of a macro that is not vendored by Rust and included in the toolchain.// See https://github.com/rust-analyzer/rust-analyzer/issues/6038.// On certain platforms right now the "main modules" modules that are// documented don't compile (missing things in `libc` which is empty),// so just omit them with an empty module and add the "unstable" attribute./// Yields the underlying UTF-8 string of this [`OsString`]./// OS strings on Motor OS are guaranteed to be UTF-8, so are just strings./// Motor OS–specific extensions to [`OsString`]./// This trait is sealed: it cannot be implemented outside the standard library./// Gets the underlying UTF-8 string view of the [`OsStr`] slice.//! Motor OS-specific extensions to primitives in the [`std::ffi`] module.sys_handle/// Extracts the main thread raw handle, without taking ownershipfrom_abstract_name/// Creates a Unix socket address in the abstract namespace./// The abstract namespace is a Linux-specific extension that allows Unix/// sockets to be bound without creating an entry in the filesystem./// Abstract sockets are unaffected by filesystem layout or permissions,/// and no cleanup is necessary when the socket is closed./// An abstract socket address name may contain any bytes, including zero./// Returns an error if the name is longer than `SUN_LEN - 1`./// use std::os::unix::net::{UnixListener, SocketAddr};/// use std::os::linux::net::SocketAddrExt;/// use std::os::android::net::SocketAddrExt;///     let addr = SocketAddr::from_abstract_name(b"hidden")?;///     let listener = match UnixListener::bind_addr(&addr) {///         Ok(sock) => sock,///             println!("Couldn't bind: {err:?}");as_abstract_name/// Returns the contents of this address if it is in the abstract namespace.///     let name = b"hidden";///     let name_addr = SocketAddr::from_abstract_name(name)?;///     let socket = UnixListener::bind_addr(&name_addr)?;///     let local_addr = socket.local_addr().expect("Couldn't get local address");///     assert_eq!(local_addr.as_abstract_name(), Some(&name[..]));/// Platform-specific extensions to [`SocketAddr`].//! Linux and Android-specific extensions to socket addresses.//! Linux, Android and Cygwin-specific networking functionality./// Query the current setting of socket option `SO_PASSCRED`./// Enable or disable socket option `SO_PASSCRED`./// use std::os::linux::net::UnixSocketExt;/// use std::os::android::net::UnixSocketExt;///     sock.set_passcred(true).expect("set_passcred failed");/// Linux-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]//! Linux and Android-specific socket functionality./// Enable or disable `TCP_QUICKACK`./// This flag causes Linux to eagerly send ACKs rather than delaying them./// Linux may reset this flag after further operations on the socket./// See [`man 7 tcp`](https://man7.org/linux/man-pages/man7/tcp.7.html) and/// [TCP delayed acknowledgement](https://en.wikipedia.org/wiki/TCP_delayed_acknowledgment)/// use std::os::linux::net::TcpStreamExt;/// use std::os::android::net::TcpStreamExt;///         .expect("Couldn't connect to the server...");/// stream.set_quickack(true).expect("set_quickack call failed");/// Gets the value of the `TCP_QUICKACK` option on this socket./// For more information about this option, see [`TcpStreamExt::set_quickack`]./// assert_eq!(stream.quickack().unwrap_or(false), true);set_deferaccept/// A socket listener will be awakened solely when data arrives./// The `accept` argument set the maximum delay until the/// data is available to read, reducing the number of short lived/// connections without data to process./// Contrary to other platforms `SO_ACCEPTFILTER` feature equivalent, there is/// no necessity to set it after the `listen` call./// Note that the delay is expressed as Duration from user's perspective/// the call rounds it down to the nearest second expressible as a `c_int`./// See [`man 7 tcp`](https://man7.org/linux/man-pages/man7/tcp.7.html)/// ```no run/// #![feature(tcp_deferaccept)]/// stream.set_deferaccept(Duration::from_secs(1u64)).expect("set_deferaccept call failed");deferaccept/// Gets the accept delay value of the `TCP_DEFER_ACCEPT` option./// For more information about this option, see [`TcpStreamExt::set_deferaccept`]./// assert_eq!(stream.deferaccept().unwrap(), Duration::from_secs(1u64));/// Os-specific extensions for [`TcpStream`]/// [`TcpStream`]: net::TcpStream//! Linux and Android-specific tcp extensions to primitives in the [`std::net`] module.//! [`std::net`]: crate::net// See cfg macros in `library/std/src/os/mod.rs` for why these platforms must// be special-cased during rustdoc generation.//! OS-specific networking functionality.//! OpenBSD-specific definitionslocal_creds/// Query the current setting of socket option `LOCAL_CREDS`.set_local_creds/// Enable or disable socket option `LOCAL_CREDS`./// use std::os::netbsd::net::UnixSocketExt;///     sock.set_local_creds(true).expect("set_local_creds failed");/// NetBSD-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]//! NetBSD-specific networking functionality.//! NetBSD-specific raw type definitions//! NuttX raw type definitions//! OpenBSD-specific raw type definitionsalias_core_ffi//! Compatibility module for C platform-specific types. Use [`core::ffi`] instead./// [`stat`]: crate::os::redox::raw::stat/// use std::os::redox::fs::MetadataExt;//! Redox-specific definitions//! Redox-specific raw type definitions/// use std::os::rtems::fs::MetadataExt;//! rtems raw type definitions//! Solaris-specific definitions/// solaris-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]//! solaris-specific networking functionality.//! Solaris-specific raw type definitions//! SOLID-specific extension to the primitives in the `std::ffi` module//! use std::os::solid::ffi::OsStringExt;//! use std::os::solid::ffi::OsStrExt;// The max of this is -2, in two's complement. -1 is `SOLID_NET_INVALID_FD`./// A borrowed SOLID Sockets file descriptor./// descriptor, so it can be used in FFI in places where a socket is passed as/// an argument, it is not captured or consumed, and it never has the value/// `SOLID_NET_INVALID_FD`./// rather than an `OwnedFd`. It just makes a trivial copy of the raw/// An owned SOLID Sockets file descriptor./// the returned `BorrowedFd`, and it must not have the value/// A trait to borrow the SOLID Sockets file descriptor from an underlyingimpl_owned_fd_traits/// # #[cfg(target_os = "solid_asp3")] mod group_cfg {/// # use std::os::solid::io::AsFd;/// A trait to extract the raw SOLID Sockets file descriptor from an underlying//! SOLID-specific extensions to general I/O primitives//! Just like raw pointers, raw SOLID Sockets file descriptors point to//! resources with dynamic lifetimes, and they can dangle if they outlive their//! resources or be forged if they're created from invalid values.//! This module provides three types for representing raw file descriptors//! with different ownership properties: raw, borrowed, and owned, which are//! analogous to types used for representing pointers://! | Type               | Analogous to |//! | ------------------ | ------------ |//! | [`RawFd`]          | `*const _`   |//! | [`BorrowedFd<'a>`] | `&'a _`      |//! | [`OwnedFd`]        | `Box<_>`     |//! Like raw pointers, `RawFd` values are primitive values. And in new code,//! they should be considered unsafe to do I/O on (analogous to dereferencing//! them). Rust did not always provide this guidance, so existing code in the//! Rust ecosystem often doesn't mark `RawFd` usage as unsafe. Once the//! `io_safety` feature is stable, libraries will be encouraged to migrate,//! either by adding `unsafe` to APIs that dereference `RawFd` values, or by//! using to `BorrowedFd` or `OwnedFd` instead.//! Like references, `BorrowedFd` values are tied to a lifetime, to ensure//! that they don't outlive the resource they point to. These are safe to//! use. `BorrowedFd` values may be used in APIs which provide safe access to//! any system call except for://!  - `close`, because that would end the dynamic lifetime of the resource//!    without ending the lifetime of the file descriptor.//!  - `dup2`/`dup3`, in the second argument, because this argument is//!    closed and assigned a new resource, which may break the assumptions//!    other code using that file descriptor.//! `BorrowedFd` values may be used in APIs which provide safe access to `dup`//! system calls, so types implementing `AsFd` or `From<OwnedFd>` should not//! assume they always have exclusive access to the underlying file//! description.//! Like boxes, `OwnedFd` values conceptually own the resource they point to,//! and free (close) it when they are dropped.//! [`BorrowedFd<'a>`]: crate::os::solid::io::BorrowedFdSYSTEM_TABLEIMAGE_HANDLEBOOT_SERVICES_FLAG// Flag to check if BootServices are still valid.// Start with assuming that they are not availableinit_globals/// Initializes the global System Table and Image Handle pointers./// The standard library requires access to the UEFI System Table and the Application Image Handle/// to operate. Those are provided to UEFI Applications via their application entry point. By/// calling `init_globals()`, those pointers are retained by the standard library for future use./// Thus this function must be called before any of the standard library services are used./// The pointers are never exposed to any entity outside of this application and it is guaranteed/// that, once the application exited, these pointers are never dereferenced again./// Callers are required to ensure the pointers are valid for the entire lifetime of this/// application. In particular, UEFI Boot Services must not be exited while an application with the/// standard library is loaded./// Calling this function more than once will panic.system_table/// Gets the SystemTable Pointer./// If you want to use `BootServices` then please use [`boot_services`] as it performs some/// additional checks./// Note: This function panics if the System Table or Image Handle is not initialized.image_handle/// Gets the ImageHandle Pointer.boot_services/// Gets the BootServices Pointer./// This function also checks if `ExitBootServices` has already been called.try_system_table/// This function is mostly intended for places where panic is not an option.try_image_handle/// Gets the SystemHandle Pointer./// This function is mostly intended for places where panicking is not an option.disable_boot_services//! UEFI-specific extensions to the primitives in `std::env` module"../windows/ffi.rs"//! Platform-specific extensions to `std` for UEFI.//! Unix-specific extensions to primitives in the [`std::ffi`] module.//! use std::os::unix::ffi::OsStringExt;//! use std::os::unix::ffi::OsStrExt;//! [`std::ffi`]: crate::ffi/// Creates an [`OsString`] from a byte vector./// See the module documentation for an example./// Yields the underlying byte vector of this [`OsString`]./// Platform-specific extensions to [`OsString`]./// Creates an [`OsStr`] from a byte slice./// Gets the underlying byte view of the [`OsStr`] slice./// Platform-specific extensions to [`OsStr`].// Note: this file is currently reused in other `std::os::{platform}::ffi` modules to reduce duplication.// Keep this in mind when applying changes to this file that only apply to `unix`.read_vectored_atwrite_vectored_at// Used for `File::read` on intra-doc links/// Reads a number of bytes starting from a given offset./// The offset is relative to the start of the file and thus independent/// from the current cursor./// The current file cursor is not affected by this function./// Note that similar to [`File::read`], it is not an error to return with a/// short read./// [`File::read`]: fs::File::read/// use std::os::unix::prelude::FileExt;///     let mut buf = [0u8; 8];///     // We now read 8 bytes from the offset 10.///     let num_bytes_read = file.read_at(&mut buf, 10)?;///     println!("read {num_bytes_read} bytes: {buf:?}");/// Like `read_at`, except that it reads into a slice of buffers./// written to possibly being only partially filled. This method must behave/// equivalently to a single call to read with concatenated buffers.read_exact_at/// Reads the exact number of bytes required to fill `buf` from the given offset./// Similar to [`io::Read::read_exact`] but uses [`read_at`] instead of `read`./// [`read_at`]: FileExt::read_at/// [`io::ErrorKind::Interrupted`] then the error is ignored and the operation/// the buffer, it returns an error of the kind [`io::ErrorKind::UnexpectedEof`].///     // We now read exactly 8 bytes from the offset 10.///     file.read_exact_at(&mut buf, 10)?;///     println!("read {} bytes: {:?}", buf.len(), buf);read_buf_at/// Reads some bytes starting from a given offset into the buffer./// This equivalent to the [`read_at`](FileExt::read_at) method, except that it is passed a/// [`BorrowedCursor`] rather than `&mut [u8]` to allow use with uninitialized buffers. The new/// data will be appended to any existing contents of `buf`./// #![feature(core_io_borrowed_buf)]/// #![feature(read_buf_at)]/// use std::io::BorrowedBuf;/// use std::os::unix::prelude::*;///     let mut file = File::open("pi.txt")?;///     // Read some bytes starting from offset 2///     let mut buf: [MaybeUninit<u8>; 10] = [MaybeUninit::uninit(); 10];///     let mut buf = BorrowedBuf::from(buf.as_mut_slice());///     file.read_buf_at(buf.unfilled(), 2)?;///     assert!(buf.filled().starts_with(b"1"));read_buf_exact_at/// Reads the exact number of bytes required to fill the buffer from a given offset./// This is equivalent to the [`read_exact_at`](FileExt::read_exact_at) method, except that it/// is passed a [`BorrowedCursor`] rather than `&mut [u8]` to allow use with uninitialized/// buffers. The new data will be appended to any existing contents of `buf`.///     // Read exactly 10 bytes starting from offset 2///     file.read_buf_exact_at(buf.unfilled(), 2)?;///     assert_eq!(buf.filled(), b"1415926535");/// Writes a number of bytes starting from a given offset./// When writing beyond the end of the file, the file is appropriately/// extended and the intermediate bytes are initialized with the value 0./// Note that similar to [`File::write`], it is not an error to return a/// short write./// # Bug/// On some systems, `write_at` utilises [`pwrite64`] to write to files./// However, this syscall has a [bug] where files opened with the `O_APPEND`/// flag fail to respect the offset parameter, always appending to the end/// of the file instead./// It is possible to inadvertently set this flag, like in the example below./// Therefore, it is important to be vigilant while changing options to mitigate/// unexpected behavior.///     // Open a file with the append option (sets the `O_APPEND` flag)///     let file = File::options().append(true).open("foo.txt")?;///     // We attempt to write at offset 10; instead appended to EOF///     file.write_at(b"sushi", 10)?;///     // foo.txt is 5 bytes long instead of 15/// [`File::write`]: fs::File::write/// [`pwrite64`]: https://man7.org/linux/man-pages/man2/pwrite.2.html/// [bug]: https://man7.org/linux/man-pages/man2/pwrite.2.html#BUGS///     let file = File::create("foo.txt")?;///     // We now write at the offset 10./// Like `write_at`, except that it writes from a slice of buffers./// Data is copied from each buffer in order, with the final buffer read/// from possibly being only partially consumed. This method must behave as/// a call to `write_at` with the buffers concatenated would.write_all_at/// Attempts to write an entire buffer starting from a given offset./// This method will continuously call [`write_at`] until there is no more data/// to be written or an error of non-[`io::ErrorKind::Interrupted`] kind is/// not of [`io::ErrorKind::Interrupted`] kind generated from this method will be/// non-[`io::ErrorKind::Interrupted`] kind that [`write_at`] returns./// [`write_at`]: FileExt::write_at///     file.write_all_at(b"sushi", 10)?;/// Unix-specific extensions to [`fs::File`]./// Returns the mode permission bits/// Sets the mode permission bits.from_mode/// Creates a new instance from the given mode permission bits./// Unix-specific extensions to [`fs::Permissions`]./// use std::fs::{File, Permissions};/// use std::io::{ErrorKind, Result as IoResult};/// use std::os::unix::fs::PermissionsExt;/// fn main() -> IoResult<()> {///     let name = "test_file_for_permissions";///     // make sure file does not exist///     let _ = std::fs::remove_file(name);///         File::open(name).unwrap_err().kind(),///         ErrorKind::NotFound,///         "file already exists"///     // full read/write/execute mode bits for owner of file///     // that we want to add to existing mode bits///     let my_mode = 0o700;///     // create new file with specified permissions///         let file = File::create(name)?;///         let mut permissions = file.metadata()?.permissions();///         eprintln!("Current permissions: {:o}", permissions.mode());///         // make sure new permissions are not already set///         assert!(///             permissions.mode() & my_mode != my_mode,///             "permissions already set"///         // either use `set_mode` to change an existing Permissions struct///         permissions.set_mode(permissions.mode() | my_mode);///         // or use `from_mode` to construct a new Permissions struct///         permissions = Permissions::from_mode(permissions.mode() | my_mode);///         // write new permissions to file///         file.set_permissions(permissions)?;///     let permissions = File::open(name)?.metadata()?.permissions();///     eprintln!("New permissions: {:o}", permissions.mode());///     // assert new permissions were set///         permissions.mode() & my_mode,///         my_mode,///         "new permissions not set"/// use std::fs::Permissions;/// // read/write for owner and read for others/// let my_mode = 0o644;/// let mut permissions = Permissions::from_mode(my_mode);/// assert_eq!(permissions.mode(), my_mode);/// // read/write/execute for owner/// let other_mode = 0o700;/// permissions.set_mode(other_mode);/// assert_eq!(permissions.mode(), other_mode);/// If a new file is created as part of an `OpenOptions::open` call then this/// use std::os::unix::fs::OpenOptionsExt;/// options.mode(0o644); // Give read/write for owner and read for others./// let file = options.open("foo.txt");/// Pass custom flags to the `flags` argument of `open`./// This function overwrites any previously-set custom flags./// # mod libc { pub const O_NOFOLLOW: i32 = 0; }/// Unix-specific extensions to [`fs::OpenOptions`]./// Returns the ID of the device containing the file./// use std::os::unix::fs::MetadataExt;///     let dev_id = meta.dev();///     let inode = meta.ino();/// Returns the rights applied to this file.///     let mode = meta.mode();///     let user_has_write_access      = mode & 0o200;///     let user_has_read_write_access = mode & 0o600;///     let group_has_read_access      = mode & 0o040;///     let others_have_exec_access    = mode & 0o001;/// Returns the number of hard links pointing to this file.///     let nb_hard_links = meta.nlink();/// Returns the user ID of the owner of this file.///     let user_id = meta.uid();/// Returns the group ID of the owner of this file.///     let group_id = meta.gid();/// Returns the device ID of this file (if it is a special one).///     let device_id = meta.rdev();/// Returns the total size of this file in bytes.///     let file_size = meta.size();///     let last_access_time = meta.atime();atime_nsec/// Returns the last access time of the file, in nanoseconds since [`atime`]./// [`atime`]: MetadataExt::atime///     let nano_last_access_time = meta.atime_nsec();///     let last_modification_time = meta.mtime();mtime_nsec/// Returns the last modification time of the file, in nanoseconds since [`mtime`]./// [`mtime`]: MetadataExt::mtime///     let nano_last_modification_time = meta.mtime_nsec();///     let last_status_change_time = meta.ctime();ctime_nsec/// Returns the last status change time of the file, in nanoseconds since [`ctime`]./// [`ctime`]: MetadataExt::ctime///     let nano_last_status_change_time = meta.ctime_nsec();/// Returns the block size for filesystem I/O.///     let block_size = meta.blksize();/// Returns the number of blocks allocated to the file, in 512-byte units./// Please note that this may be smaller than `st_size / 512` when the file has holes.///     let blocks = meta.blocks();/// Unix-specific extensions to [`fs::Metadata`]./// Returns `true` if this file type is a block device./// use std::os::unix::fs::FileTypeExt;///     let meta = fs::metadata("block_device_file")?;///     let file_type = meta.file_type();///     assert!(file_type.is_block_device());/// Returns `true` if this file type is a char device.///     let meta = fs::metadata("char_device_file")?;///     assert!(file_type.is_char_device());/// Returns `true` if this file type is a fifo.///     let meta = fs::metadata("fifo_file")?;///     assert!(file_type.is_fifo());/// Returns `true` if this file type is a socket.///     let meta = fs::metadata("unix.socket")?;///     assert!(file_type.is_socket());/// Unix-specific extensions for [`fs::FileType`]./// Adds support for special Unix file types such as block/character devices,/// pipes, and sockets./// use std::os::unix::fs::DirEntryExt;///             println!("{:?}: {}", entry.file_name(), entry.ino());/// Unix-specific extension methods for [`fs::DirEntry`].file_name_ref/// Returns a reference to the underlying `OsStr` of this entry's filename./// #![feature(dir_entry_ext2)]/// use std::os::unix::fs::DirEntryExt2;///     let mut entries = fs::read_dir(".")?.collect::<Result<Vec<_>, io::Error>>()?;///     entries.sort_unstable_by(|a, b| a.file_name_ref().cmp(b.file_name_ref()));///     for p in entries {///         println!("{p:?}");DirEntryExt2/// Sealed Unix-specific extension methods for [`fs::DirEntry`]./// use std::os::unix::fs;///     fs::symlink("a.txt", "b.txt")?;/// Sets the mode to create new directories with. This option defaults to/// 0o777./// use std::os::unix::fs::DirBuilderExt;/// Unix-specific extensions to [`fs::DirBuilder`]./// Change the owner and group of the specified path./// Specifying either the uid or gid as `None` will leave it unchanged./// Changing the owner typically requires privileges, such as root or a specific capability./// Changing the group typically requires either being the owner and a member of the group, or/// having privileges./// Be aware that changing owner clears the `suid` and `sgid` permission bits in most cases/// according to POSIX, usually even if the user is root. The sgid is not cleared when/// the file is non-group-executable. See: <https://www.man7.org/linux/man-pages/man2/chown.2.html>/// This call may also clear file capabilities, if there was any./// If called on a symbolic link, this will change the owner and group of the link target. To/// change the owner and group of the link itself, see [`lchown`].///     fs::chown("/sandbox", Some(0), Some(0))?;/// Change the owner and group of the file referenced by the specified open file descriptor./// For semantics and required privileges, see [`chown`].///     let f = std::fs::File::open("/file")?;///     fs::fchown(&f, Some(0), Some(0))?;/// Change the owner and group of the specified path, without dereferencing symbolic links./// Identical to [`chown`], except that if called on a symbolic link, this will change the owner/// and group of the link itself rather than the owner and group of the link target.///     fs::lchown("/symlink", Some(0), Some(0))?;/// Change the root directory of the current process to the specified path./// This typically requires privileges, such as root or a specific capability./// This does not change the current working directory; you should call/// [`std::env::set_current_dir`][`crate::env::set_current_dir`] afterwards.///     fs::chroot("/sandbox")?;///     std::env::set_current_dir("/")?;///     // continue working in sandbox/// Create a FIFO special file at the specified path with the specified mode./// # #![feature(unix_mkfifo)]/// # #[cfg(not(unix))]/// # use std::{/// #     os::unix::fs::{mkfifo, PermissionsExt},/// #     fs::{File, Permissions, remove_file},/// #     io::{Write, Read},/// # let _ = remove_file("/tmp/fifo");/// mkfifo("/tmp/fifo", Permissions::from_mode(0o774))?;/// let mut wx = File::options().read(true).write(true).open("/tmp/fifo")?;/// let mut rx = File::open("/tmp/fifo")?;/// wx.write_all(b"hello, world!")?;/// drop(wx);/// rx.read_to_string(&mut s)?;/// assert_eq!(s, "hello, world!");//! Unix-specific extensions to primitives in the [`std::fs`] module.//! Unix-specific extensions to general I/O primitives.//! Just like raw pointers, raw file descriptors point to resources with//! dynamic lifetimes, and they can dangle if they outlive their resources//! or be forged if they're created from invalid values.//! This module provides three types for representing file descriptors,//! analogous to types used for representing pointers. These types reflect concepts of [I/O//! safety][io-safety] on Unix.//! | [`BorrowedFd<'a>`] | `&'a Arc<_>` |//! | [`OwnedFd`]        | `Arc<_>`     |//! Rust ecosystem often doesn't mark `RawFd` usage as unsafe.//! Libraries are encouraged to migrate,//! The use of `Arc` for borrowed/owned file descriptors may be surprising. Unix file descriptors//! are mere references to internal kernel objects called "open file descriptions", and the same//! open file description can be referenced by multiple file descriptors (e.g. if `dup` is used).//! State such as the offset within the file is shared among all file descriptors that refer to the//! same open file description, and the kernel internally does reference-counting to only close the//! underlying resource once all file descriptors referencing it are closed. That's why `Arc` (and//! not `Box`) is the closest Rust analogy to an "owned" file descriptor.//!    without ending the lifetime of the file descriptor. (Equivalently://!    an `&Arc<_>` cannot be `drop`ed.)//!    closed and assigned a new resource, which may break the assumptions of//! `BorrowedFd` values may be used in APIs which provide safe access to `dup` system calls, so code//! working with `OwnedFd` cannot assume to have exclusive access to the underlying open file//! description. (Equivalently: `&Arc` may be used in APIs that provide safe access to `clone`, so//! code working with an `Arc` cannot assume that the reference count is 1.)//! `BorrowedFd` values may also be used with `mmap`, since `mmap` uses the//! provided file descriptor in a manner similar to `dup` and does not require//! the `BorrowedFd` passed to it to live for the lifetime of the resulting//! mapping. That said, `mmap` is unsafe for other reasons: it operates on raw//! pointers, and it can have undefined behavior if the underlying storage is//! mutated. Mutations may come from other processes, or from the same process//! if the API provides `BorrowedFd` access, since as mentioned earlier,//! `BorrowedFd` values may be used in APIs which provide safe access to any//! system call. Consequently, code using `mmap` and presenting a safe API must//! take full responsibility for ensuring that safe Rust code cannot evoke//! undefined behavior through it.//! Like `Arc`, `OwnedFd` values conceptually own one reference to the resource they point to,//! and decrement the reference count when they are dropped (by calling `close`).//! When the reference count reaches 0, the underlying open file description will be freed//! by the kernel.//! See the [`io` module docs][io-safety] for a general explanation of I/O safety.//! ## `/proc/self/mem` and similar OS features//! Some platforms have special files, such as `/proc/self/mem`, which//! provide read and write access to the process's memory. Such reads//! and writes happen outside the control of the Rust compiler, so they do not//! uphold Rust's memory safety guarantees.//! This does not mean that all APIs that might allow `/proc/self/mem`//! to be opened and read from or written must be `unsafe`. Rust's safety guarantees//! only cover what the program itself can do, and not what entities outside//! the program can do to it. `/proc/self/mem` is considered to be such an//! external entity, along with `/proc/self/fd/*`, debugging interfaces, and people with physical//! access to the hardware. This is true even in cases where the program is controlling the external//! entity.//! If you desire to comprehensively prevent programs from reaching out and//! causing external entities to reach back in and violate memory safety, it's//! necessary to use *sandboxing*, which is outside the scope of `std`.//! [`BorrowedFd<'a>`]: crate::os::unix::io::BorrowedFd//! [io-safety]: crate::io#io-safetytest_raw_fd_layout//! Platform-specific extensions to `std` for Unix platforms.//! Provides access to platform-level information on Unix platforms, and//! exposes Unix-specific functions that would otherwise be inappropriate as//! part of the core `std` library.//! It exposes more ways to deal with platform-specific strings ([`OsStr`],//! [`OsString`]), allows to set permissions more granularly, extract low-level//! file descriptors from files and sockets, and has platform-specific helpers//! for spawning processes.//! use std::os::unix::prelude::*;//! fn main() -> std::io::Result<()> {//!     let fd = f.as_raw_fd();//!     // use fd with native unix bindings//! [`OsStr`]: crate::ffi::OsStr//! [`OsString`]: crate::ffi::OsStringSUN_PATH_OFFSET/// An address associated with a Unix socket./// let socket = match UnixListener::bind("/tmp/sock") {///     Ok(sock) => sock,///         println!("Couldn't bind: {e:?}");///         return/// let addr = socket.local_addr().expect("Couldn't get local address");from_pathname/// Returns an error if the path is longer than `SUN_LEN` or if it contains/// NULL bytes./// use std::os::unix::net::SocketAddr;/// let address = SocketAddr::from_pathname("/path/to/socket")?;/// assert_eq!(address.as_pathname(), Some(Path::new("/path/to/socket")));/// Creating a `SocketAddr` with a NULL byte results in an error./// assert!(SocketAddr::from_pathname("/path/with/\0/bytes").is_err());/// A named address:///     let socket = UnixListener::bind("/tmp/sock")?;///     let addr = socket.local_addr().expect("Couldn't get local address");///     assert_eq!(addr.is_unnamed(), false);/// An unnamed address:///     let socket = UnixDatagram::unbound()?;///     assert_eq!(addr.is_unnamed(), true);/// With a pathname:///     assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/sock")));/// Without a pathname:///     assert_eq!(addr.as_pathname(), None);recv_vectored_with_ancillary_fromSocketAncillarysend_vectored_with_ancillary_toadd_to_ancillary_dataAncillaryDataIter/// Creates `AncillaryDataIter` struct to iterate through the data unit in the control message./// `data` must contain a valid control message.SocketCred/// Unix credential./// Creates a Unix credential struct./// PID, UID and GID is set to 0./// Set the PID.get_pid/// Gets the current PID.set_uid/// Set the UID./// Gets the current UID.set_gid/// Set the GID.get_gid/// Gets the current GID./// This control message contains file descriptors./// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_RIGHTS`./// This control message contains unix credentials./// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_CREDENTIALS` or `SCM_CREDS`.AncillaryError/// The error type which is returned from parsing the type a control message.AncillaryData/// This enum represent one control message of variable type.as_rights/// Creates an `AncillaryData::ScmRights` variant./// `data` must contain a valid control message and the control message must be type of/// `SOL_SOCKET` and level of `SCM_RIGHTS`.as_credentials/// Creates an `AncillaryData::ScmCredentials` variant./// `SOL_SOCKET` and level of `SCM_CREDENTIALS` or `SCM_CREDS`.try_from_cmsghdr/// This struct is used to iterate through the control messages./// A Unix socket Ancillary data struct./// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};///     let sock = UnixStream::connect("/tmp/sock")?;///     let mut fds = [0; 8];///     let mut ancillary_buffer = [0; 128];///     let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);///     let mut buf = [1; 8];///     let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];///     sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;///     for ancillary_result in ancillary.messages() {///         if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {///             for fd in scm_rights {///                 println!("receive file descriptor: {fd}");/// Creates an ancillary data with the given buffer./// use std::os::unix::net::SocketAncillary;/// let mut ancillary_buffer = [0; 128];/// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);/// Returns `true` if the ancillary data is empty./// Returns the number of used bytes./// Returns the iterator of the control messages./// Is `true` if during a recv operation the ancillary was truncated./// use std::os::unix::net::{UnixStream, SocketAncillary};///     println!("Is truncated: {}", ancillary.truncated());add_fds/// Add file descriptors to the ancillary data./// The function returns `true` if there was enough space in the buffer./// If there was not enough space then no file descriptors was appended./// Technically, that means this operation adds a control message with the level `SOL_SOCKET`/// and type `SCM_RIGHTS`.///     ancillary.add_fds(&[sock.as_raw_fd()][..]);///     let buf = [1; 8];///     let mut bufs = &mut [IoSlice::new(&buf[..])][..];///     sock.send_vectored_with_ancillary(bufs, &mut ancillary)?;add_creds/// Add credentials to the ancillary data./// The function returns `true` if there is enough space in the buffer./// If there is not enough space then no credentials will be appended./// and type `SCM_CREDENTIALS`, `SCM_CREDS`, or `SCM_CREDS2`./// Clears the ancillary data, removing all values.///     let mut fds1 = [0; 8];///     let mut fds2 = [0; 8];///     ancillary.clear();// FIXME: This is currently disabled on *BSD.///     let socket = UnixDatagram::bind("/path/to/my/socket")?;///     socket.send_to(b"hello world", "/path/to/other/socket")?;///     let mut buf = [0; 100];///     let (count, address) = socket.recv_from(&mut buf)?;///     println!("socket {:?} sent {:?}", address, &buf[..count]);/// let sock = match UnixDatagram::bind("/path/to/the/socket") {/// Creates a Unix datagram socket bound to an address./// use std::os::unix::net::{UnixDatagram};///     let sock1 = UnixDatagram::bind("path/to/socket")?;///     let addr = sock1.local_addr()?;///     let sock2 = match UnixDatagram::bind_addr(&addr) {/// let sock = match UnixDatagram::unbound() {///         println!("Couldn't unbound: {e:?}");/// Returns two `UnixDatagrams`s which are connected to each other./// let (sock1, sock2) = match UnixDatagram::pair() {///     Ok((sock1, sock2)) => (sock1, sock2),/// Connects the socket to the specified path address./// The [`send`] method may be used to send data to the specified address./// [`recv`] and [`recv_from`] will only receive data from that address./// [`send`]: UnixDatagram::send/// [`recv`]: UnixDatagram::recv/// [`recv_from`]: UnixDatagram::recv_from///     match sock.connect("/path/to/the/socket") {///             println!("Couldn't connect: {e:?}");///             return Err(e)/// Connects the socket to an address.///     let bound = UnixDatagram::bind("/path/to/socket")?;///     let addr = bound.local_addr()?;///     match sock.connect_addr(&addr) {/// The returned `UnixDatagram` is a reference to the same socket that this/// connections and options set on one side will affect the other.///     let sock = UnixDatagram::bind("/path/to/the/socket")?;///     let sock_copy = sock.try_clone().expect("try_clone failed");///     let addr = sock.local_addr().expect("Couldn't get local address");/// The [`connect`] method will connect the socket to a peer./// [`connect`]: UnixDatagram::connect///     sock.connect("/path/to/the/socket")?;///     let addr = sock.peer_addr().expect("Couldn't get peer address");recv_from_flags///     let (size, sender) = sock.recv_from(buf.as_mut_slice())?;///     println!("received {size} bytes from {sender:?}");///     sock.recv(buf.as_mut_slice()).expect("recv function failed");/// Receives data and ancillary data from socket./// On success, returns the number of bytes read, if the data was truncated and the address from whence the msg came./// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};///     let mut buf1 = [1; 8];///     let mut buf2 = [2; 16];///     let mut buf3 = [3; 8];///     let mut bufs = &mut [///         IoSliceMut::new(&mut buf1),///         IoSliceMut::new(&mut buf2),///         IoSliceMut::new(&mut buf3),///     ][..];///     let (size, _truncated, sender) = sock.recv_vectored_with_ancillary_from(bufs, &mut ancillary)?;///     println!("received {size}");recv_vectored_with_ancillary/// On success, returns the number of bytes read and if the data was truncated.///     let (size, _truncated) = sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;///     sock.send_to(b"omelette au fromage", "/some/sock").expect("send_to function failed");/// Sends data on the socket to the specified [SocketAddr]./// [SocketAddr]: crate::os::unix::net::SocketAddr///     sock.send_to_addr(b"bacon egg and cheese", &addr).expect("send_to_addr function failed");///     sock.connect("/some/sock").expect("Couldn't connect");///     sock.send(b"omelette au fromage").expect("send_to function failed");/// Sends data and ancillary data on the socket to the specified address./// use std::os::unix::net::{UnixDatagram, SocketAncillary};///     let buf1 = [1; 8];///     let buf2 = [2; 16];///     let buf3 = [3; 8];///     let bufs = &[///         IoSlice::new(&buf1),///         IoSlice::new(&buf2),///         IoSlice::new(&buf3),///     let fds = [0, 1, 2];///     ancillary.add_fds(&fds[..]);///     sock.send_vectored_with_ancillary_to(bufs, &mut ancillary, "/some/sock")///         .expect("send_vectored_with_ancillary_to function failed");send_vectored_with_ancillary/// Sends data and ancillary data on the socket.///     sock.send_vectored_with_ancillary(bufs, &mut ancillary)///         .expect("send_vectored_with_ancillary function failed");/// Sets the read timeout for the socket./// If the provided value is [`None`], then [`recv`] and [`recv_from`] calls will/// block indefinitely. An [`Err`] is returned if the zero [`Duration`]/// is passed to this method.///     sock.set_read_timeout(Some(Duration::new(1, 0)))///         .expect("set_read_timeout function failed");///     let result = socket.set_read_timeout(Some(Duration::new(0, 0)));///     let err = result.unwrap_err();///     assert_eq!(err.kind(), io::ErrorKind::InvalidInput);/// Sets the write timeout for the socket./// If the provided value is [`None`], then [`send`] and [`send_to`] calls will/// block indefinitely. An [`Err`] is returned if the zero [`Duration`] is passed to this/// [`send_to`]: UnixDatagram::send_to///     sock.set_write_timeout(Some(Duration::new(1, 0)))///         .expect("set_write_timeout function failed");///     let result = socket.set_write_timeout(Some(Duration::new(0, 0)));///     assert_eq!(sock.read_timeout()?, Some(Duration::new(1, 0)));///     assert_eq!(sock.write_timeout()?, Some(Duration::new(1, 0)));/// Moves the socket into or out of nonblocking mode.///     sock.set_nonblocking(true).expect("set_nonblocking function failed");/// Set the id of the socket for network filtering purpose/// #![feature(unix_set_mark)]///     sock.set_mark(32)?;///     if let Ok(Some(err)) = sock.take_error() {///         println!("Got error: {err:?}");/// (see the documentation of [`Shutdown`]).///     sock.shutdown(Shutdown::Both).expect("shutdown function failed");/// #![feature(unix_socket_peek)]///     let socket = UnixDatagram::bind("/tmp/sock")?;///     let len = socket.peek(&mut buf).expect("peek failed");///     let (len, addr) = socket.peek_from(&mut buf).expect("peek failed");/// Takes ownership of a [`UnixDatagram`]'s socket file descriptor./// A structure representing a Unix domain socket server./// use std::os::unix::net::{UnixStream, UnixListener};/// fn handle_client(stream: UnixStream) {///     let listener = UnixListener::bind("/path/to/the/socket")?;///     // accept connections and process them, spawning a new thread for each one///                 /* connection succeeded *////                 thread::spawn(|| handle_client(stream));///             Err(err) => {///                 /* connection failed *//// Creates a new `UnixListener` bound to the specified socket./// let listener = match UnixListener::bind("/path/to/the/socket") {///         println!("Couldn't connect: {e:?}");/// Creates a new `UnixListener` bound to the specified [`socket address`]./// [`socket address`]: crate::os::unix::net::SocketAddr/// use std::os::unix::net::{UnixListener};///     let listener1 = UnixListener::bind("path/to/socket")?;///     let addr = listener1.local_addr()?;///     let listener2 = match UnixListener::bind_addr(&addr) {/// This function will block the calling thread until a new Unix connection/// is established. When established, the corresponding [`UnixStream`] and/// the remote peer's address will be returned./// [`UnixStream`]: crate::os::unix::net::UnixStream///     match listener.accept() {///         Ok((socket, addr)) => println!("Got a client: {addr:?}"),///         Err(e) => println!("accept function failed: {e:?}"),/// The returned `UnixListener` is a reference to the same socket that this///     let listener_copy = listener.try_clone().expect("try_clone failed");///     let addr = listener.local_addr().expect("Couldn't get local address");///     listener.set_nonblocking(true).expect("Couldn't set non blocking");///     let listener = UnixListener::bind("/tmp/sock")?;///     if let Ok(Some(err)) = listener.take_error() {/// # Platform specific/// On Redox this always returns `None`./// Returns an iterator over incoming connections./// The iterator will never return [`None`] and will also not yield the/// peer's [`SocketAddr`] structure./// Takes ownership of a [`UnixListener`]'s socket file descriptor./// An iterator over incoming connections to a [`UnixListener`]./// It will never return [`None`].ancillary//! Unix-specific networking functionality./// A Unix stream socket.///     let mut stream = UnixStream::connect("/path/to/my/socket")?;///     stream.write_all(b"hello world")?;///     let mut response = String::new();///     stream.read_to_string(&mut response)?;///     println!("{response}");/// # `SIGPIPE`/// Writes to the underlying socket in `SOCK_STREAM` mode are made with `MSG_NOSIGNAL` flag./// This suppresses the emission of the  `SIGPIPE` signal when writing to disconnected socket./// In some cases getting a `SIGPIPE` would trigger process termination./// let socket = match UnixStream::connect("/tmp/sock") {/// Connects to the socket specified by [`address`]./// [`address`]: crate::os::unix::net::SocketAddr/// use std::os::unix::net::{UnixListener, UnixStream};///     let addr = listener.local_addr()?;///     let sock = match UnixStream::connect_addr(&addr) {/// let (sock1, sock2) = match UnixStream::pair() {///         println!("Couldn't create a pair of sockets: {e:?}");/// The returned `UnixStream` is a reference to the same stream that this///     let socket = UnixStream::connect("/tmp/sock")?;///     let sock_copy = socket.try_clone().expect("Couldn't clone socket");///     let addr = socket.peer_addr().expect("Couldn't get peer address");/// Gets the peer credentials for this Unix domain socket./// #![feature(peer_credentials_unix_socket)]///     let peer_cred = socket.peer_cred().expect("Couldn't get peer credentials");/// If the provided value is [`None`], then [`read`] calls will block/// indefinitely. An [`Err`] is returned if the zero [`Duration`] is passed to this///     socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");/// If the provided value is [`None`], then [`write`] calls will block///     socket.set_write_timeout(Some(Duration::new(1, 0)))///         .expect("Couldn't set write timeout");///     assert_eq!(socket.read_timeout()?, Some(Duration::new(1, 0)));///     assert_eq!(socket.write_timeout()?, Some(Duration::new(1, 0)));///     socket.set_nonblocking(true).expect("Couldn't set nonblocking");///     socket.shutdown(Shutdown::Both).expect("shutdown function failed");///     let size = socket.recv_vectored_with_ancillary(bufs, &mut ancillary)?;///     socket.send_vectored_with_ancillary(bufs, &mut ancillary)/// Takes ownership of a [`UnixStream`]'s socket file descriptor.cygwinor_panic// Android SELinux rules prevent creating Unix socketsvectoredlong_path// Cygwin connect needs handshaketest_unix_stream_timeout_zero_durationtest_unix_datagramtest_unnamed_unix_datagram// Cygwin autobinds an addresstest_unix_datagram_connect_to_recv_addrtest_connect_unix_datagramtest_unix_datagram_recvdatagram_pairtest_unix_datagram_timeout_zero_durationabstract_socket_addr_debugabstract_namespace_not_allowed_connecttest_abstract_stream_connect// Cygwin cannot bind to abstract addrtest_abstract_stream_itertest_abstract_datagram_bind_send_to_addrtest_abstract_datagram_connect_addrtest_abstract_name_too_longtest_abstract_no_pathname_and_not_unnamedtest_unix_stream_peektest_unix_datagram_peektest_unix_datagram_peek_fromtest_send_vectored_fds_unix_streamtest_send_vectored_with_ancillary_to_unix_datagram// Cygwin recvmsg doesn't support Unix socketstest_send_vectored_with_ancillary_unix_datagramtest_socket_pairtest_socket_pair_pidsRetType/// The UID part of the peer credential. This is the effective UID of the process at the domain/// socket's endpoint./// The GID part of the peer credential. This is the effective GID of the process at the domain/// The PID part of the peer credential. This field is optional because the PID part of the/// peer credentials is not supported on every platform. On platforms where the mechanism to/// discover the PID exists, this field will be populated to the PID of the process at the/// domain socket's endpoint. Otherwise, it will be set to None./// Credentials for a UNIX process for credentials passing.// NOTE: Code in this file is heavily based on work done in PR 13 from the tokio-uds repository on//       GitHub.//       For reference, the link is here: https://github.com/tokio-rs/tokio-uds/pull/13//       Credit to Martin Habovštiak (GitHub username Kixunil) and contributors for this work.UserId/// This will also trigger a call to `setgroups(0, NULL)` in the child/// process if no groups have been specified./// This removes supplementary groups that might have given the child/// unwanted permissions./// Sets the supplementary group IDs for the calling process. Translates to/// a `setgroups` call in the child process./// # Notes and Safety/// like `malloc`, accessing environment variables through [`std::env`]/// or acquiring a mutex are not guaranteed to work (due to/// Note that the list of allocating functions includes [`Error::new`] and/// [`Error::other`]. To signal a non-trivial error, prefer [`panic!`]./// For further details refer to the [POSIX fork() specification]/// and the equivalent documentation for any targeted/// platform, especially the requirements around *async-signal-safety*./// Panicking in the closure is safe only if all the format arguments for the/// panic message can be safely formatted; this is because although/// `Command` calls [`std::panic::always_abort`](crate::panic::always_abort)/// before calling the pre_exec hook, panic will still try to format the/// panic message./// locations might not appear where intended./// [POSIX fork() specification]:///     https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html/// [`std::env`]: mod@crate::env/// [`Error::new`]: crate::io::Error::new/// [`Error::other`]: crate::io::Error::otherbefore_exec/// `before_exec` used to be a safe method, but it needs to be unsafe since the closure may only/// perform operations that are *async-signal-safe*. Hence it got deprecated in favor of the/// unsafe [`pre_exec`]. Meanwhile, Rust gained the ability to make an existing safe method/// fully unsafe in a new edition, which is how `before_exec` became `unsafe`. It still also/// remains deprecated; `pre_exec` should be used instead./// [`pre_exec`]: CommandExt::pre_exec/// [`process::exit`] – no destructors on the current stack or any other/// descriptors will be to inherit them from the current process./// Pressing Ctrl-C in a terminal will send SIGINT to all processes in/// the current foreground process group. By spawning the `sleep`/// subprocess in a new process group, it will not receive SIGINT from the/// terminal./// The parent process could install a signal handler and manage the/// subprocess on its own terms./// use std::os::unix::process::CommandExt;/// Command::new("sleep")///     .spawn()?///     .wait()?;/// # Ok::<_, Box<dyn std::error::Error>>(())/// Set the root of the child process. This calls `chroot` in the child process before executing/// the command./// This happens before changing to the directory specified with/// [`process::Command::current_dir`], and that directory will be relative to the new root./// If no directory has been specified with [`process::Command::current_dir`], this will set the/// directory to `/`, to avoid leaving the current directory outside the chroot. (This is an/// intentional difference from the underlying `chroot` system call.)/// Unix-specific extensions to the [`process::Command`] builder./// Creates a new `ExitStatus` or `ExitStatusError` from the raw underlying integer status/// value from `wait`/// The value should be a **wait status, not an exit status**./// Panics on an attempt to make an `ExitStatusError` from a wait status of `0`./// Making an `ExitStatus` always succeeds and never panics./// If the process was terminated by a signal, returns that signal./// In other words, if `WIFSIGNALED`, this returns `WTERMSIG`.core_dumped/// If the process was terminated by a signal, says whether it dumped core.stopped_signal/// If the process was stopped by a signal, returns that signal./// In other words, if `WIFSTOPPED`, this returns `WSTOPSIG`.  This is only possible if the status came from/// a `wait` system call which was passed `WUNTRACED`, and was then converted into an `ExitStatus`./// Whether the process was continued from a stopped status./// Ie, `WIFCONTINUED`.  This is only possible if the status came from a `wait` system call/// which was passed `WCONTINUED`, and was then converted into an `ExitStatus`./// Returns the underlying raw `wait` status./// The returned integer is a **wait status, not an exit status**./// Unix-specific extensions to [`process::ExitStatus`] and/// [`ExitStatusError`](process::ExitStatusError)./// On Unix, `ExitStatus` **does not necessarily represent an exit status**, as/// passed to the `_exit` system call or returned by/// [`ExitStatus::code()`](crate::process::ExitStatus::code).  It represents **any wait status**/// as returned by one of the `wait` family of system/// A Unix wait status (a Rust `ExitStatus`) can represent a Unix exit status, but can also/// represent other kinds of process event.ExitStatusError/// Sends a signal to a child process./// This function will return an error if the signal is invalid. The integer values associated/// with signals are implementation-specific, so it's encouraged to use a crate that provides/// posix bindings./// #![feature(unix_send_signal)]/// use std::{io, os::unix::process::ChildExt, process::{Command, Stdio}};/// use libc::SIGTERM;///     # if cfg!(not(all(target_vendor = "apple", not(target_os = "macos")))) {///     let child = Command::new("cat").stdin(Stdio::piped()).spawn()?;///     child.send_signal(SIGTERM)?;/// Takes ownership of a file descriptor and returns a [`Stdio`](process::Stdio)/// that can attach a stream to it./// Takes ownership of a [`ChildStdin`](crate::process::ChildStdin)'s file descriptor./// Creates a `ChildStdin` from the provided `OwnedFd`./// The provided file descriptor must point to a pipe/// with the `CLOEXEC` flag set./// Takes ownership of a [`ChildStdout`](crate::process::ChildStdout)'s file descriptor./// Creates a `ChildStdout` from the provided `OwnedFd`./// Takes ownership of a [`ChildStderr`](crate::process::ChildStderr)'s file descriptor./// Creates a `ChildStderr` from the provided `OwnedFd`./// Returns the OS-assigned process identifier associated with this process's parent.//! Unix-specific extensions to primitives in the [`std::process`] module.//! Unix-specific primitives available on all unix platforms./// Extracts the raw pthread_t without taking ownership/// Consumes the thread, returning the raw pthread_t/// This function **transfers ownership** of the underlying pthread_t to/// the caller. Callers are then the unique owners of the pthread_t and/// must either detach or join the pthread_t once it's no longer needed./// Unix-specific extensions to [`JoinHandle`].//! Unix-specific extensions to primitives in the [`std::thread`] module.//! [`std::thread`]: crate::thread//! Definitions for vita//! vita raw type definitionsst_attrib//! VxWorks-specific definitions//! VxWorks-specific raw type definitions//! WASI-specific extensions to primitives in the [`std::ffi`] module/// Note that similar to [`File::read_vectored`], it is not an error to/// return with a short read./// Reads the exact number of byte required to fill `buf` from the given offset./// Similar to [`Read::read_exact`] but uses [`read_at`] instead of `read`./// Note that similar to [`File::write_vectored`], it is not an error to return afdstat_set_flags/// Adjusts the flags associated with this file./// This corresponds to the `fd_fdstat_set_flags` syscall.fdstat_set_rights/// Adjusts the rights associated with this file./// This corresponds to the `fd_fdstat_set_rights` syscall./// Provides file advisory information on a file descriptor./// This corresponds to the `fd_advise` syscall./// Forces the allocation of space in a file./// This corresponds to the `fd_allocate` syscall.create_directory/// This corresponds to the `path_create_directory` syscall./// Reads the contents of a symbolic link./// This corresponds to the `path_readlink` syscall.metadata_at/// Returns the attributes of a file or directory./// This corresponds to the `path_filestat_get` syscall./// Unlinks a file./// This corresponds to the `path_unlink_file` syscall.remove_directory/// Removes a directory./// This corresponds to the `path_remove_directory` syscall./// WASI-specific extensions to [`File`].lookup_flags/// Pass custom `dirflags` argument to `path_open`./// This option configures the `dirflags` argument to the/// `path_open` syscall which `OpenOptions` will eventually call. The/// `dirflags` argument configures how the file is looked up, currently/// primarily affecting whether symlinks are followed or not./// By default this value is `__WASI_LOOKUP_SYMLINK_FOLLOW`, or symlinks are/// followed. You can call this method with 0 to disable following symlinks/// Indicates whether `OpenOptions` must open a directory or not./// This method will configure whether the `__WASI_O_DIRECTORY` flag is/// passed when opening a file. When passed it will require that the opened/// path is a directory./// This option is by default `false`dsync/// Indicates whether `__WASI_FDFLAG_DSYNC` is passed in the `fs_flags`/// field of `path_open`./// Indicates whether `__WASI_FDFLAG_NONBLOCK` is passed in the `fs_flags`rsync/// Indicates whether `__WASI_FDFLAG_RSYNC` is passed in the `fs_flags`/// Indicates whether `__WASI_FDFLAG_SYNC` is passed in the `fs_flags`fs_rights_base/// Indicates the value that should be passed in for the `fs_rights_base`/// parameter of `path_open`./// This option defaults based on the `read` and `write` configuration of/// this `OpenOptions` builder. If this method is called, however, the/// exact mask passed in will be used instead.fs_rights_inheriting/// Indicates the value that should be passed in for the/// `fs_rights_inheriting` parameter of `path_open`./// The default for this option is the same value as what will be passed/// for the `fs_rights_base` parameter but if this method is called then/// the specified value will be used instead.open_at/// Open a file or directory./// This corresponds to the `path_open` syscall./// WASI-specific extensions to [`fs::OpenOptions`]./// Returns the `st_dev` field of the internal `filestat_t`/// Returns the `st_ino` field of the internal `filestat_t`/// Returns the `st_nlink` field of the internal `filestat_t`/// Returns the `st_size` field of the internal `filestat_t`atim/// Returns the `st_atim` field of the internal `filestat_t`mtim/// Returns the `st_mtim` field of the internal `filestat_t`ctim/// Returns the `st_ctim` field of the internal `filestat_t`/// WASI-specific extensions to [`fs::Metadata`]./// Returns `true` if this file type is a character device.is_socket_dgram/// Returns `true` if this file type is a socket datagram.is_socket_stream/// Returns `true` if this file type is a socket stream./// Returns `true` if this file type is any type of socket./// WASI-specific extensions for [`fs::FileType`]./// Adds support for special WASI file types such as block/character devices,/// Returns the underlying `d_ino` field of the `dirent_t`/// WASI-specific extension methods for [`fs::DirEntry`]./// Creates a hard link./// This corresponds to the `path_link` syscall./// Renames a file or directory./// This corresponds to the `path_rename` syscall./// Creates a symbolic link./// This corresponds to the `path_symlink` syscall.symlink_path/// This is a convenience API similar to `std::os::unix::fs::symlink` and/// `std::os::windows::fs::symlink_file` and `std::os::windows::fs::symlink_dir`.osstr2str//! WASI-specific extensions to primitives in the [`std::fs`] module.// FIXME: bind fd_fdstat_get - need to define a custom return type// FIXME: bind fd_readdir - can't return `ReadDir` since we only have entry name// FIXME: bind fd_filestat_set_times maybe? - on crates.io for unix// FIXME: bind path_filestat_set_times maybe? - on crates.io for unix// FIXME: bind poll_oneoff maybe? - probably should wait for I/O to settle// FIXME: bind random_get maybe? - on crates.io for unix// Tests for this module//! WASI-specific extensions to general I/O primitives.//! Platform-specific extensions to `std` for the WebAssembly System Interface (WASI).//! Provides access to platform-level information on WASI, and exposes//! WASI-specific functions that would otherwise be inappropriate as//! It exposes more ways to deal with platform-specific strings (`OsStr`,//! `OsString`), allows to set permissions more granularly, extract low-level//! use std::os::wasi::prelude::*;//!     // use fd with native WASI bindingssock_accept/// Accept a socket./// This corresponds to the `sock_accept` syscall.TcpListenerExt/// WASI-specific extensions to [`std::net::TcpListener`]./// [`std::net::TcpListener`]: crate::net::TcpListener//! WASI-specific networking functionality//! Platform-specific extensions to `std` for Preview 2 of the WebAssembly System Interface (WASI).//! This module is currently empty, but will be filled over time as wasi-libc support for WASI Preview 2 is stabilized./// Creates an `OsString` from a potentially ill-formed UTF-16 slice of/// 16-bit code units./// This is lossless: calling [`OsStrExt::encode_wide`] on the resulting string/// use std::os::windows::prelude::*;/// // UTF-16 encoding for "Unicode"./// let source = [0x0055, 0x006E, 0x0069, 0x0063, 0x006F, 0x0064, 0x0065];/// let string = OsString::from_wide(&source[..]);/// Windows-specific extensions to [`OsString`]./// Re-encodes an `OsStr` as a wide character sequence, i.e., potentially/// ill-formed UTF-16./// This is lossless: calling [`OsStringExt::from_wide`] and then/// `encode_wide` on the result will yield the original code units./// Note that the encoding does not add a final null terminator./// let result: Vec<u16> = string.encode_wide().collect();/// assert_eq!(&source[..], &result[..]);/// Windows-specific extensions to [`OsStr`]./// Iterator returned by [`OsStrExt::encode_wide`].//! Windows-specific extensions to primitives in the [`std::ffi`] module.//! For historical reasons, the Windows API uses a form of potentially//! ill-formed UTF-16 encoding for strings. Specifically, the 16-bit//! code units in Windows strings may contain [isolated surrogate code//! points which are not paired together][ill-formed-utf-16]. The//! Unicode standard requires that surrogate code points (those in the//! range U+D800 to U+DFFF) always be *paired*, because in the UTF-16//! encoding a *surrogate code unit pair* is used to encode a single//! character. For compatibility with code that does not enforce//! these pairings, Windows does not enforce them, either.//! While it is not always possible to convert such a string losslessly into//! a valid UTF-16 string (or even UTF-8), it is often desirable to be//! able to round-trip such a string from and to Windows APIs//! losslessly. For example, some Rust code may be "bridging" some//! Windows APIs together, just passing `WCHAR` strings among those//! APIs without ever really looking into the strings.//! If Rust code *does* need to look into those strings, it can//! convert them to valid UTF-8, possibly lossily, by substituting//! invalid sequences with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], as is//! conventionally done in other Rust APIs that deal with string//! encodings.//! # `OsStringExt` and `OsStrExt`//! [`OsString`] is the Rust wrapper for owned strings in the//! preferred representation of the operating system. On Windows,//! this struct gets augmented with an implementation of the//! [`OsStringExt`] trait, which has an [`OsStringExt::from_wide`] method. This//! lets you create an [`OsString`] from a `&[u16]` slice; presumably//! you get such a slice out of a `WCHAR` Windows API.//! Similarly, [`OsStr`] is the Rust wrapper for borrowed strings from//! preferred representation of the operating system. On Windows, the//! [`OsStrExt`] trait provides the [`OsStrExt::encode_wide`] method, which//! outputs an [`EncodeWide`] iterator. You can [`collect`] this//! iterator, for example, to obtain a `Vec<u16>`; you can later get a//! pointer to this vector's contents and feed it to Windows APIs.//! These traits, along with [`OsString`] and [`OsStr`], work in//! conjunction so that it is possible to **round-trip** strings from//! Windows and back, with no loss of data, even if the strings are//! ill-formed UTF-16.//! [ill-formed-utf-16]: https://simonsapin.github.io/wtf-8/#ill-formed-utf-16//! [`collect`]: crate::iter::Iterator::collect//! [U+FFFD]: crate::char::REPLACEMENT_CHARACTERseek_read/// Seeks to a given position and reads a number of bytes./// from the current cursor. The current cursor **is** affected by this/// function, it is set to the end of the read./// Reading beyond the end of the file will always return with a length of/// 0\./// Note that similar to `File::read`, it is not an error to return with a/// short read. When returning from such a short read, the file pointer is/// still updated.///     // Read 10 bytes, starting 72 bytes from the///     // start of the file.///     file.seek_read(&mut buffer[..], 72)?;seek_read_buf/// Seeks to a given position and reads some bytes into the buffer./// This is equivalent to the [`seek_read`](FileExt::seek_read) method, except that it is passed/// a [`BorrowedCursor`] rather than `&mut [u8]` to allow use with uninitialized buffers. The/// new data will be appended to any existing contents of `buf`./// Reading beyond the end of the file will always succeed without reading any bytes.///     file.seek_read_buf(buf.unfilled(), 2)?;seek_write/// Seeks to a given position and writes a number of bytes./// function, it is set to the end of the write./// extended and the intermediate bytes are set to zero./// Note that similar to `File::write`, it is not an error to return a/// short write. When returning from such a short write, the file pointer/// is still updated.///     // Write a byte string starting 72 bytes from///     // the start of the file.///     buffer.seek_write(b"some bytes", 72)?;/// Windows-specific extensions to [`fs::File`].access_mode/// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`]/// with the specified value./// This will override the `read`, `write`, and `append` flags on the/// `OpenOptions` structure. This method provides fine-grained control over/// the permissions to read, write and append data, attributes (like hidden/// and system), and extended attributes./// // Open without read and write permission, for example if you only need/// // to call `stat` on the file/// let file = OpenOptions::new().access_mode(0).open("foo.txt");share_mode/// Overrides the `dwShareMode` argument to the call to [`CreateFile`] with/// the specified value./// By default `share_mode` is set to/// `FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE`. This allows/// other processes to read, write, and delete/rename the same file/// while it is open. Removing any of the flags will prevent other/// processes from performing the corresponding operation until the file/// handle is closed./// // Do not allow others to read or modify this file while we have it open/// // for writing.///     .share_mode(0)///     .open("foo.txt");/// Sets extra flags for the `dwFileFlags` argument to the call to/// [`CreateFile2`] to the specified value (or combines it with/// `attributes` and `security_qos_flags` to set the `dwFlagsAndAttributes`/// for [`CreateFile`])./// This option overwrites any previously set custom flags./// # #[cfg(for_demonstration_only)]/// # mod winapi { pub const FILE_FLAG_DELETE_ON_CLOSE: u32 = 0x04000000; }///     .custom_flags(winapi::FILE_FLAG_DELETE_ON_CLOSE)/// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2/// Sets the `dwFileAttributes` argument to the call to [`CreateFile2`] to/// the specified value (or combines it with `custom_flags` and/// `security_qos_flags` to set the `dwFlagsAndAttributes` for/// [`CreateFile`])./// If a _new_ file is created because it does not yet exist and/// `.create(true)` or `.create_new(true)` are specified, the new file is/// given the attributes declared with `.attributes()`./// If an _existing_ file is opened with `.create(true).truncate(true)`, its/// existing attributes are preserved and combined with the ones declared/// with `.attributes()`./// In all other cases the attributes get ignored./// # mod winapi { pub const FILE_ATTRIBUTE_HIDDEN: u32 = 2; }///     .attributes(winapi::FILE_ATTRIBUTE_HIDDEN)/// Sets the `dwSecurityQosFlags` argument to the call to [`CreateFile2`] to/// the specified value (or combines it with `custom_flags` and `attributes`/// to set the `dwFlagsAndAttributes` for [`CreateFile`])./// By default `security_qos_flags` is not set. It should be specified when/// opening a named pipe, to control to which degree a server process can/// act on behalf of a client process (security impersonation level)./// # mod winapi { pub const SECURITY_IDENTIFICATION: u32 = 0; }///     // Sets the flag value to `SecurityIdentification`.///     .security_qos_flags(winapi::SECURITY_IDENTIFICATION)///     .open(r"\\.\pipe\MyPipe");/// [Impersonation Levels]:///     https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level/// Windows-specific extensions to [`fs::OpenOptions`].file_attributes/// Returns the value of the `dwFileAttributes` field of this metadata./// This field contains the file system attribute information for a file/// or directory. For possible values and their descriptions, see/// [File Attribute Constants] in the Windows Dev Center.///     let attributes = metadata.file_attributes();/// [File Attribute Constants]:///     https://docs.microsoft.com/windows/win32/fileio/file-attribute-constantscreation_time/// Returns the value of the `ftCreationTime` field of this metadata./// The returned 64-bit value is equivalent to a [`FILETIME`] struct,/// which represents the number of 100-nanosecond intervals since/// January 1, 1601 (UTC). The struct is automatically/// converted to a `u64` value, as that is the recommended way/// to use it./// If the underlying filesystem does not support creation time, the/// returned value is 0.///     let creation_time = metadata.creation_time();/// [`FILETIME`]: https://docs.microsoft.com/windows/win32/api/minwinbase/ns-minwinbase-filetimelast_access_time/// Returns the value of the `ftLastAccessTime` field of this metadata./// For a file, the value specifies the last time that a file was read/// from or written to. For a directory, the value specifies when/// the directory was created. For both files and directories, the/// specified date is correct, but the time of day is always set to/// midnight./// If the underlying filesystem does not support last access time, the///     let last_access_time = metadata.last_access_time();last_write_time/// Returns the value of the `ftLastWriteTime` field of this metadata./// For a file, the value specifies the last time that a file was written/// to. For a directory, the structure specifies when the directory was/// If the underlying filesystem does not support the last write time,/// the returned value is 0.///     let last_write_time = metadata.last_write_time();/// Returns the value of the `nFileSize` fields of this/// The returned value does not have meaning for directories.///     let file_size = metadata.file_size();volume_serial_number/// Returns the value of the `dwVolumeSerialNumber` field of this/// This will return `None` if the `Metadata` instance was created from a/// call to `DirEntry::metadata`. If this `Metadata` was created by using/// `fs::metadata` or `File::metadata`, then this will return `Some`.number_of_links/// Returns the value of the `nNumberOfLinks` field of this/// Returns the value of the `nFileIndex` fields of thischange_time/// Returns the value of the `ChangeTime` fields of this metadata./// `ChangeTime` is the last time file metadata was changed, such as/// renames, attributes, etc./// This will return `None` if `Metadata` instance was created from a call to/// `DirEntry::metadata` or if the `target_vendor` is outside the current platform/// support for this api./// Windows-specific extensions to [`fs::Metadata`]./// The data members that this trait exposes correspond to the members/// of the [`BY_HANDLE_FILE_INFORMATION`] structure./// [`BY_HANDLE_FILE_INFORMATION`]:///     https://docs.microsoft.com/windows/win32/api/fileapi/ns-fileapi-by_handle_file_informationis_symlink_dir/// Returns `true` if this file type is a symbolic link that is also a directory.is_symlink_file/// Returns `true` if this file type is a symbolic link that is also a file./// Windows-specific extensions to [`fs::FileType`]./// On Windows, a symbolic link knows whether it is a file or directory./// Windows-specific extensions to [`fs::FileTimes`]./// Creates a new symlink to a non-directory file on the filesystem./// The `original` path should not be a directory or a symlink to a directory,/// otherwise the symlink will be broken. Use [`symlink_dir`] for directories./// This function currently corresponds to [`CreateSymbolicLinkW`][CreateSymbolicLinkW]./// [CreateSymbolicLinkW]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createsymboliclinkw/// use std::os::windows::fs;///     fs::symlink_file("a.txt", "b.txt")?;/// Windows treats symlink creation as a [privileged action][symlink-security],/// therefore this function is likely to fail unless the user makes changes to/// their system to permit symlink creation. Users can try enabling Developer/// Mode, granting the `SeCreateSymbolicLinkPrivilege` privilege, or running/// the process as an administrator./// [symlink-security]: https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-symbolic-links/// Creates a new symlink to a directory on the filesystem./// The `original` path must be a directory or a symlink to a directory,/// otherwise the symlink will be broken. Use [`symlink_file`] for other files.///     fs::symlink_dir("a", "b")?;/// Creates a junction point./// The `link` path will be a directory junction pointing to the original path./// If `link` is a relative path then it will be made absolute prior to creating the junction point./// The `original` path must be a directory or a link to a directory, otherwise the junction point will be broken./// If either path is not a local file path then this will fail.//! Windows-specific extensions to primitives in the [`std::fs`] module./// it is not captured or consumed./// Returns a `BorrowedHandle` holding the given raw handle.// The empty field prevents constructing this, and allows extending it in the future./// Borrows the handle./// use std::os::windows::io::{AsHandle, BorrowedHandle};/// let borrowed_handle: BorrowedHandle<'_> = f.as_handle();/// A trait to borrow the handle from an underlying object./// This impl allows implementing traits that require `AsHandle` on Arc./// # #[cfg(windows)] mod group_cfg {/// # use std::os::windows::io::AsHandle;/// trait MyTrait: AsHandle {}/// impl MyTrait for Arc<File> {}/// impl MyTrait for Box<File> {}/// Takes ownership of a [`File`](fs::File)'s underlying file handle./// Returns a [`File`](fs::File) that takes ownership of the given handle./// Takes ownership of a [`ChildStdin`](crate::process::ChildStdin)'s file handle./// Takes ownership of a [`ChildStdout`](crate::process::ChildStdout)'s file handle./// Takes ownership of a [`ChildStderr`](crate::process::ChildStderr)'s file handle.//! Owned and borrowed OS handles.//! Windows-specific extensions to general I/O primitives.//! Just like raw pointers, raw Windows handles and sockets point to resources//! with dynamic lifetimes, and they can dangle if they outlive their resources//! This module provides three types for representing raw handles and sockets//! safety][io-safety] on Windows.//! | Type                   | Analogous to |//! | ---------------------- | ------------ |//! | [`RawHandle`]          | `*const _`   |//! | [`RawSocket`]          | `*const _`   |//! |                        |              |//! | [`BorrowedHandle<'a>`] | `&'a _`      |//! | [`BorrowedSocket<'a>`] | `&'a _`      |//! | [`OwnedHandle`]        | `Box<_>`     |//! | [`OwnedSocket`]        | `Box<_>`     |//! Like raw pointers, `RawHandle` and `RawSocket` values are primitive values.//! And in new code, they should be considered unsafe to do I/O on (analogous//! to dereferencing them). Rust did not always provide this guidance, so//! existing code in the Rust ecosystem often doesn't mark `RawHandle` and//! `RawSocket` usage as unsafe.//! Libraries are encouraged to migrate, either by adding `unsafe` to APIs//! that dereference `RawHandle` and `RawSocket` values, or by using to//! `BorrowedHandle`, `BorrowedSocket`, `OwnedHandle`, or `OwnedSocket`.//! Like references, `BorrowedHandle` and `BorrowedSocket` values are tied to a//! lifetime, to ensure that they don't outlive the resource they point to.//! These are safe to use. `BorrowedHandle` and `BorrowedSocket` values may be//! used in APIs which provide safe access to any system call except for//! `CloseHandle`, `closesocket`, or any other call that would end the//! dynamic lifetime of the resource without ending the lifetime of the//! handle or socket.//! `BorrowedHandle` and `BorrowedSocket` values may be used in APIs which//! provide safe access to `DuplicateHandle` and `WSADuplicateSocketW` and//! related functions, so types implementing `AsHandle`, `AsSocket`,//! `From<OwnedHandle>`, or `From<OwnedSocket>` should not assume they always//! have exclusive access to the underlying object.//! Like boxes, `OwnedHandle` and `OwnedSocket` values conceptually own the//! resource they point to, and free (close) it when they are dropped.//! [`BorrowedHandle<'a>`]: crate::os::windows::io::BorrowedHandle//! [`BorrowedSocket<'a>`]: crate::os::windows::io::BorrowedSocket/// Raw HANDLEs./// Extracts the raw handle./// This function is typically used to **borrow** an owned handle./// raw handle to the caller, and the handle is only guaranteed/// This function may return null, such as when called on [`Stdin`],/// [`Stdout`], or [`Stderr`] when the console is detached./// However, borrowing is not strictly required. See [`AsHandle::as_handle`]/// for an API which strictly borrows a handle./// [`Stdin`]: io::Stdin/// [`Stdout`]: io::Stdout/// [`Stderr`]: io::Stderr/// Extracts raw handles./// Constructs a new I/O object from the specified raw handle./// This function is typically used to **consume ownership** of the handle/// given, passing responsibility for closing the handle to the returned/// `From<OwnedHandle>::from` implementation for an API which strictly/// The `handle` passed in must:///   - be an [owned handle][io-safety]; in particular, it must be open.///   - be a handle for a resource that may be freed via [`CloseHandle`]///     (as opposed to `RegCloseKey` or other close functions)./// Note that the handle *may* have the value `INVALID_HANDLE_VALUE` (-1),/// which is sometimes a valid handle value. See [here] for the full story./// Constructs I/O objects from raw handles."losing the raw handle may leak resources"/// Consumes this object, returning the raw underlying handle./// handle to the caller. When used in this way, callers are then the unique/// owners of the handle and must close it once it's no longer needed./// `Into<OwnedHandle>::into` implementation for an API which strictly/// its raw `HANDLE`.stdio_handle// Translate a handle returned from `GetStdHandle` into a handle to return to// the user."losing the raw socket may leak resources"ValidRawSocket// The max here is -2, in two's complement. -1 is `INVALID_SOCKET`./// The resource pointed to by `socket` must remain open for the duration of// FIXME(strict_provenance_magic): we defined RawSocket to be a u64 ;-;/// Returns the last error from the Windows socket interface./// This impl allows implementing traits that require `AsSocket` on Arc./// # use std::os::windows::io::AsSocket;/// trait MyTrait: AsSocket {}/// Takes ownership of a [`TcpStream`](crate::net::TcpStream)'s socket./// Takes ownership of a [`TcpListener`](crate::net::TcpListener)'s socket./// Takes ownership of a [`UdpSocket`](crate::net::UdpSocket)'s underlying socket.//! Owned and borrowed OS sockets.test_niche_optimizations_socket//! Platform-specific extensions to `std` for Windows.//! Provides access to platform-level information for Windows, and exposes//! Windows-specific idioms that would otherwise be inappropriate as part//! the core `std` library. These extensions allow developers to use//! `std` types and idioms with Windows in a way that the normal//! platform-agnostic idioms would not normally support.//! use std::os::windows::prelude::*;//!     let handle = f.as_raw_handle();//!     // use handle with native windows bindings/// Takes ownership of a handle and returns a [`Stdio`](process::Stdio)/// Takes ownership of a [`Child`](process::Child)'s process handle./// Creates a `ChildStdin` from the provided `OwnedHandle`./// The provided handle must be asynchronous, as reading and/// writing from and to it is implemented using asynchronous APIs./// Creates a `ChildStdout` from the provided `OwnedHandle`./// Creates a `ChildStderr` from the provided `OwnedHandle`./// Creates a new `ExitStatus` from the raw underlying `u32` return value of/// Windows-specific extensions to [`process::ExitStatus`].show_window/// Sets the field `wShowWindow` of [STARTUPINFO][1] that is passed to `CreateProcess`./// Allowed values are the ones listed in/// <https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow>/// [1]: <https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfow>force_quotes/// Forces all arguments to be wrapped in quote (`"`) characters./// This is useful for passing arguments to [MSYS2/Cygwin][1] based/// executables: these programs will expand unquoted arguments containing/// wildcard characters (`?` and `*`) by searching for any file paths/// matching the wildcard pattern./// Adding quotes has no effect when passing arguments to programs/// that use [msvcrt][2]. This includes programs built with both/// MinGW and MSVC./// [1]: <https://github.com/msys2/MSYS2-packages/issues/2176>/// [2]: <https://msdn.microsoft.com/en-us/library/17w5ykft.aspx>/// This is useful for passing arguments to applications that don't follow/// the standard C run-time escaping rules, such as `cmd.exe /c`./// # Batch files/// Note the `cmd /c` command line has slightly different escaping rules than batch files/// themselves. If possible, it may be better to write complex arguments to a temporary/// `.bat` file, with appropriate escaping, and simply run that using:/// # use std::process::Command;/// # let temp_bat_file = "";/// let output = Command::new("cmd").args(["/c", &format!("\"{temp_bat_file}\"")]).output();/// Run a batch script using both trusted and untrusted arguments./// // `my_script_path` is a path to known bat file./// // `user_name` is an untrusted name given by the user./// fn run_script(///     my_script_path: &str,///     user_name: &str,/// ) -> Result<std::process::Output, std::io::Error> {///     use std::io::{Error, ErrorKind};///     use std::os::windows::process::CommandExt;///     // Create the command line, making sure to quote the script path.///     // This assumes the fixed arguments have been tested to work with the script we're using.///     let mut cmd_args = format!(r#""{my_script_path}" "--features=[a,b,c]""#);///     // Make sure the user name is safe. In particular we need to be///     // cautious of ascii symbols that cmd may interpret specially.///     // Here we only allow alphanumeric characters.///     if !user_name.chars().all(|c| c.is_alphanumeric()) {///         return Err(Error::new(ErrorKind::InvalidInput, "invalid user name"));///     // now we have validated the user name, let's add that too.///     cmd_args.push_str(" --user ");///     cmd_args.push_str(user_name);///     // call cmd.exe and return the output///     Command::new("cmd.exe")///         .arg("/c")///         // surround the entire command in an extra pair of quotes, as required by cmd.exe.///         .raw_arg(&format!("\"{cmd_args}\""))async_pipes/// When [`process::Command`] creates pipes, request that our side is always async./// By default [`process::Command`] may choose to use pipes where both ends/// are opened for synchronous read or write operations. By using/// `async_pipes(true)`, this behavior is overridden so that our side is/// always async./// This is important because if doing async I/O a pipe or a file has to be/// opened for async access./// The end of the pipe sent to the child process will always be synchronous/// regardless of this option./// #![feature(windows_process_extensions_async_pipes)]/// use std::os::windows::process::CommandExt;/// use std::process::{Command, Stdio};/// # let program = "";/// Command::new(program)///     .async_pipes(true)///     .stdin(Stdio::piped())///     .stderr(Stdio::piped());spawn_with_attributes/// Executes the command as a child process with the given/// [`ProcThreadAttributeList`], returning a handle to it./// This method enables the customization of attributes for the spawned/// child process on Windows systems./// Attributes offer extended configurability for process creation,/// but their usage can be intricate and potentially unsafe./// By default, stdin, stdout, and stderr are inherited from the parent/// #![feature(windows_process_extensions_raw_attribute)]/// use std::os::windows::io::AsRawHandle;/// use std::os::windows::process::{CommandExt, ProcThreadAttributeList};/// # struct ProcessDropGuard(std::process::Child);/// # impl Drop for ProcessDropGuard {/// #     fn drop(&mut self) {/// #         let _ = self.0.kill();/// let parent = Command::new("cmd").spawn()?;/// let parent_process_handle = parent.as_raw_handle();/// # let parent = ProcessDropGuard(parent);/// const PROC_THREAD_ATTRIBUTE_PARENT_PROCESS: usize = 0x00020000;/// let mut attribute_list = ProcThreadAttributeList::build()///     .attribute(PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &parent_process_handle)///     .finish()/// let mut child = Command::new("cmd").spawn_with_attributes(&attribute_list)?;/// # child.kill()?;/// # Ok::<(), std::io::Error>(())startupinfo_fullscreen/// When true, sets the `STARTF_RUNFULLSCREEN` flag on the [STARTUPINFO][1] struct before passing it to `CreateProcess`./// [1]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoastartupinfo_untrusted_source/// When true, sets the `STARTF_UNTRUSTEDSOURCE` flag on the [STARTUPINFO][1] struct before passing it to `CreateProcess`.startupinfo_force_feedback/// When specified, sets the following flags on the [STARTUPINFO][1] struct before passing it to `CreateProcess`:/// - If `Some(true)`, sets `STARTF_FORCEONFEEDBACK`/// - If `Some(false)`, sets `STARTF_FORCEOFFFEEDBACK`/// - If `None`, does not set any flagsinherit_handles/// If this flag is set to `true`, each inheritable handle in the calling/// process is inherited by the new process. If the flag is `false`, the/// handles are not inherited./// The default value for this flag is `true`./// **Note** that inherited handles have the same value and access rights/// as the original handles. For additional discussion of inheritable handles,/// see the [Remarks][1] section of the `CreateProcessW` documentation./// [1]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw#remarks/// Windows-specific extensions to the [`process::Command`] builder.main_thread_handle/// Creates a new `ExitCode` from the raw underlying `u32` return value of/// The exit code should not be 259, as this conflicts with the `STILL_ACTIVE`/// macro returned from the `GetExitCodeProcess` function to signal that the/// process has yet to run to completion.ExitCodeExt/// Windows-specific extensions to [`process::ExitCode`].attribute_list_lifetime_marker/// A wrapper around windows [`ProcThreadAttributeList`][1]./// [1]: <https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-initializeprocthreadattributelist>ProcThreadAttributeListBuilder/// Creates a new builder for constructing a [`ProcThreadAttributeList`]./// Returns a pointer to the underling attribute list./// Deletes the attribute list./// This method calls [`DeleteProcThreadAttributeList`][1] to delete the/// underlying attribute list./// [1]: <https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-deleteprocthreadattributelist>ProcThreadAttributeValue/// Builder for constructing a [`ProcThreadAttributeList`]./// Sets an attribute on the attribute list./// The `attribute` parameter specifies the raw attribute to be set, while/// the `value` parameter holds the value associated with that attribute./// Please refer to the [Windows documentation][1] for a list of valid attributes./// The maximum number of attributes is the value of [`u32::MAX`]. If this/// limit is exceeded, the call to [`Self::finish`] will return an `Error`/// indicating that the maximum number of attributes has been exceeded./// # Safety Note/// Remember that improper use of attributes can lead to undefined behavior/// or security vulnerabilities. Always consult the documentation and ensure/// proper attribute values are used./// [1]: <https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-updateprocthreadattribute#parameters>raw_attribute/// Sets a raw attribute on the attribute list./// This function is useful for setting attributes with pointers or sizes/// that cannot be derived directly from their values./// This function is marked as `unsafe` because it deals with raw pointers/// and sizes. It is the responsibility of the caller to ensure the value/// lives longer than the resulting [`ProcThreadAttributeList`] as well as/// the validity of the size parameter./// use std::ffi::c_void;/// use std::os::windows::raw::HANDLE;/// pub struct COORD {///     pub X: i16,///     pub Y: i16,/// unsafe extern "system" {///     fn CreatePipe(///         hreadpipe: *mut HANDLE,///         hwritepipe: *mut HANDLE,///         lppipeattributes: *const c_void,///         nsize: u32,///     ) -> i32;///     fn CreatePseudoConsole(///         size: COORD,///         hinput: HANDLE,///         houtput: HANDLE,///         dwflags: u32,///         phpc: *mut isize,///     fn CloseHandle(hobject: HANDLE) -> i32;/// let [mut input_read_side, mut output_write_side, mut output_read_side, mut input_write_side] =///     [unsafe { std::mem::zeroed::<HANDLE>() }; 4];///     CreatePipe(&mut input_read_side, &mut input_write_side, std::ptr::null(), 0);///     CreatePipe(&mut output_read_side, &mut output_write_side, std::ptr::null(), 0);/// let size = COORD { X: 60, Y: 40 };/// let mut h_pc = unsafe { std::mem::zeroed() };/// unsafe { CreatePseudoConsole(size, input_read_side, output_write_side, 0, &mut h_pc) };/// unsafe { CloseHandle(input_read_side) };/// unsafe { CloseHandle(output_write_side) };/// const PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE: usize = 131094;/// let attribute_list = unsafe {///     ProcThreadAttributeList::build()///         .raw_attribute(///             PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,///             h_pc as *const c_void,///             size_of::<isize>(),///         .finish()?/// Finalizes the construction of the `ProcThreadAttributeList`./// Returns an error if the maximum number of attributes is exceeded/// or if there is an I/O error during initialization./// Wrapper around the value data to be used as a Process Thread Attribute.//! Windows-specific extensions to primitives in the [`std::process`] module.//! Windows-specific primitives.//! Windows-specific extensions to primitives in the [`std::thread`] module./// Flags to be passed to the MapMemory struct./// Note that it is an error to have memory be/// writable and not readable.FREE/// Free this memoryRESERVE/// Immediately allocate this memory.  Otherwise it will/// be demand-paged.  This is implicitly set when `phys`/// is not 0./// Allow the CPU to read from this page./// Allow the CPU to write to this page./// Allow the CPU to execute from this page./// Returns the union of the two sets of flags./// Adds the set of flags./// Returns the left flags, but with all the right flags toggled./// Toggles the set of flags./// Returns the intersection between the two sets of flags./// Disables all flags disabled in the set./// Returns the set difference of the two sets of flags./// Disables all flags enabled in the set./// Returns the complement of this set of flags.memoryflagsSyscallMapMemoryUpdateMemoryFlagsReceiveMessageSendMessageUnmapMemoryReturnMemoryTrySendMessageTryConnectJoinThreadAdjustProcessLimitReturnScalar/// Indicates a particular syscall number as used by the Xous kernel.SyscallResultMemoryRangeMemoryReturnedScalar5/// Copies of these invocation types here for when we're running/// in environments without libxous.BadAlignmentMemoryInUseInterruptNotFoundInterruptInUseServerExistsServerNotFoundProcessNotFoundProcessNotChildProcessTerminatedServerQueueFullThreadNotAvailableUnhandledSyscallInvalidSyscallShareViolationInvalidThreadInvalidPidUseBeforeInitDoubleFreeDebugInProgressInvalidLimit/// A list of all known errors that may be returned by the Xous kernel.InvokeTypeLendMutLendBlockingScalar/// Indicates the type of Message that is sent when making a `SendMessage` syscall./// A representation of a connection to a Xous service.ServerAddressErrorServerAddressHeapMaximum/// Limits that can be passed to `AdjustLimit`lend_mut_impllend_muttry_lend_mutlend_impllendtry_lendtry_scalarblocking_scalar_implblocking_scalartry_blocking_scalarconnect_impl/// Connects to a Xous server represented by the specified `address`./// The current thread will block until the server is available. Returns/// an error if the server cannot accept any more connections.try_connect/// Attempts to connect to a Xous server represented by the specified `address`./// If the server does not exist then None is returned./// Terminates the current process and returns the specified code to the parent process.do_yield/// Suspends the current thread and allow another thread to run. This thread may/// continue executing again immediately if there are no other threads available/// to run on the system.map_memory/// Allocates memory from the system./// An optional physical and/or virtual address may be specified in order to/// ensure memory is allocated at specific offsets, otherwise the kernel will/// select an address./// This function is safe unless a virtual address is specified. In that case,/// the kernel will return an alias to the existing range. This violates Rust's/// pointer uniqueness guarantee.unmap_memory/// Destroys the given memory, returning it to the compiler./// Safety: The memory pointed to by `range` should not be used after this/// function returns, even if this function returns Err().update_memory_flags/// Adjusts the memory flags for the given range./// This can be used to remove flags from a given region in order to harden/// memory access. Note that flags may only be removed and may never be added./// Safety: The memory pointed to by `range` may become inaccessible or have its/// mutability removed. It is up to the caller to ensure that the flags specified/// by `new_flags` are upheld, otherwise the program will crash.create_thread/// Creates a thread with a given stack and up to four arguments.join_thread/// Waits for the given thread to terminate and returns the exit code from that thread./// Gets the current thread's ID.adjust_limit/// Adjusts the given `knob` limit to match the new value `new`. The current value must/// match the `current` in order for this to take effect./// The new value is returned as a result of this call. If the call fails, then the old/// value is returned. In either case, this function returns successfully./// An error is generated if the `knob` is not a valid limit, or if the call/// would not succeed.DnsLendMutRawLookupdns_server/// Returns a `Connection` to the DNS lookup server. This server is used for/// querying domain name values.group_or_null/// Group a `usize` worth of bytes into a `usize` and return it, beginning from/// `offset` * sizeof(usize) bytes from the start. For example,/// `group_or_null([1,2,3,4,5,6,7,8], 1)` on a 32-bit system will return a/// `usize` with 5678 packed into it.LogScalarBeginPanic/// A panic occurred, and a panic log is forthcomingAppendPanicMessage/// Some number of bytes will be appended to the log messageLogLendStandardOutputStandardErrorlog_server/// Returns a `Connection` to the log server, which is used for printing messages to/// the console and reporting panics./// If the log server has not yet started, this will block until the server is/// running. It is safe to call this multiple times, because the address is/// shared among all threads in a process.NetBlockingScalar/* fd */StdGetTtlUdp/* ttl */StdSetTtlUdp/* 36 */StdGetTtlTcpStdSetTtlTcpStdGetNodelayStdSetNodelayStdTcpCloseStdUdpClose/* 34 *//* how */StdTcpStreamShutdownNetLendMutStdTcpConnectStdTcpTx/* 30 *//* nonblocking */StdTcpPeek/* 31 */StdTcpRxStdGetAddressStdUdpBindStdUdpRx/* 40 */StdUdpTxStdTcpListenStdTcpAcceptnet_server/// Returns a `Connection` to the Network server. This server provides all/// OS-level networking functions.SystimeScalarGetUtcTimeMssystime_server/// Returns a `Connection` to the systime server. This server is used for reporting the/// realtime clock.TicktimerScalarElapsedMsSleepMs/* cookie */LockMutexUnlockMutex/* timeout (ms) */WaitForCondition/* count */NotifyConditionFreeMutexFreeConditionticktimer_server/// Returns a `Connection` to the ticktimer server. This server is used for synchronization/// primitives such as sleep, Mutex, and Condvar.systimeticktimerNAME_MAX_LENGTH// By making this repr(C), the layout of this struct becomes well-defined// and no longer shifts around.// By marking it as `align(4096)` we define that it will be page-aligned,// meaning it can be sent between processes. We make sure to pad out the// entire struct so that memory isn't leaked to the name server.connect_with_name_implconnect_with_nametry_connect_with_name/// Attempts to connect to a server by name. If the server does not exist, this will/// block until the server is created./// Note that this is different from connecting to a server by address. Server/// addresses are always 16 bytes long, whereas server names are arbitrary-length/// strings up to 64 bytes in length./// immediately return `None`.NAME_SERVER_CONNECTIONname_server/// Returns a `Connection` to the name server. If the name server has not been started,/// then this call will block until the name server has been started. The `Connection`/// will be shared among all connections in a process, so it is safe to call thistry_name_serverPanicHookInfo/// `PanicInfo` has been renamed to [`PanicHookInfo`] to avoid confusion with/// [`core::panic::PanicInfo`]./// `PanicHookInfo` structure is passed to a panic hook set by the [`set_hook`] function.///     println!("panic occurred: {panic_info}");/// panic!("critical system failure");/// [`set_hook`]: ../../std/panic/fn.set_hook.html/// This will commonly, but not always, be a `&'static str` or [`String`]./// If you only care about such payloads, use [`payload_as_str`] instead./// A invocation of the `panic!()` macro in Rust 2021 or later will always result in a/// panic payload of type `&'static str` or `String`./// Only an invocation of [`panic_any`]/// (or, in Rust 2018 and earlier, `panic!(x)` where `x` is something other than a string)/// can result in a panic payload other than a `&'static str` or `String`./// [`payload_as_str`]: PanicHookInfo::payload_as_str///     if let Some(s) = panic_info.payload().downcast_ref::<&str>() {///         println!("panic occurred: {s:?}");///     } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {///         println!("panic occurred");payload_as_str/// Returns the payload associated with the panic, if it is a string./// This returns the payload if it is of type `&'static str` or `String`./// panic payload where `payload_as_str` returns `Some`./// can result in a panic payload where `payload_as_str` returns `None`./// std::panic::set_hook(Box::new(|panic_info| {///     if let Some(s) = panic_info.payload_as_str() {update_hookset_hooktake_hookpanic_any/// Panics the current thread with the given message as the panic payload./// The message can be of any (`Any + Send`) type, not just strings./// The message is wrapped in a `Box<'static + Any + Send>`, which can be/// accessed later using [`PanicHookInfo::payload`]./// See the [`panic!`] macro for more information about panicking./// Invokes a closure, capturing the cause of an unwinding panic if one occurs./// This function will return `Ok` with the closure's result if the closure does/// not panic, and will return `Err(cause)` if the closure panics. The `cause`/// returned is the object with which panic was originally invoked./// Rust functions that are expected to be called from foreign code that does/// not support unwinding (such as C compiled with `-fno-exceptions`) should be/// defined using `extern "C"`, which ensures that if the Rust code panics, it/// is automatically caught and the process is aborted. If this is the desired/// behavior, it is not necessary to use `catch_unwind` explicitly. This/// function should instead be used when more graceful error-handling is needed./// It is **not** recommended to use this function for a general try/catch/// mechanism. The [`Result`] type is more appropriate to use for functions that/// can fail on a regular basis. Additionally, this function is not guaranteed/// to catch all panics, see the "Notes" section below./// The closure provided is required to adhere to the [`UnwindSafe`] trait to/// ensure that all captured variables are safe to cross this boundary. The/// purpose of this bound is to encode the concept of [exception safety][rfc] in/// the type system. Most usage of this function should not need to worry about/// this bound as programs are naturally unwind safe without `unsafe` code. If/// it becomes a problem the [`AssertUnwindSafe`] wrapper struct can be used to/// quickly assert that the usage here is indeed unwind safe./// This function **might not catch all Rust panics**. A Rust panic is not/// always implemented via unwinding, but can be implemented by aborting the/// process as well. This function *only* catches unwinding panics, not those/// that abort the process./// If a custom panic hook has been set, it will be invoked before the panic is/// caught, before unwinding./// Although unwinding into Rust code with a foreign exception (e.g. an/// exception thrown from C++ code, or a `panic!` in Rust code compiled or/// linked with a different runtime) via an appropriate ABI (e.g. `"C-unwind"`)/// is permitted, catching such an exception using this function will have one/// of two behaviors, and it is unspecified which will occur:/// * The process aborts, after executing all destructors of `f` and the///   functions it called./// * The function returns a `Result::Err` containing an opaque type./// Finally, be **careful in how you drop the result of this function**. If it/// is `Err`, it contains the panic payload, and dropping that may in turn/// panic!/// let result = panic::catch_unwind(|| {///     println!("hello!");///     panic!("oh no!");/// Triggers a panic without invoking the panic hook./// This is designed to be used in conjunction with [`catch_unwind`] to, for/// example, carry a panic across a layer of C code./// Note that panics in Rust are not always implemented via unwinding, but they/// may be implemented by aborting the process. If this function is called when/// panics are implemented this way then this function will abort the process,/// not trigger an unwind.///     if 1 != 2 {///         panic!("oh no!");/// if let Err(err) = result {///     panic::resume_unwind(err);always_abort/// Makes all future panics abort directly without running the panic hook or unwinding./// There is no way to undo this; the effect lasts until the process exits or/// execs (or the equivalent)./// # Use after fork/// This function is particularly useful for calling after `libc::fork`.  After `fork`, in a/// multithreaded program it is (on many platforms) not safe to call the allocator.  It is also/// generally highly undesirable for an unwind to unwind past the `fork`, because that results in/// the unwind propagating to code that was only ever expecting to run in the parent./// `panic::always_abort()` helps avoid both of these.  It directly avoids any further unwinding,/// and if there is a panic, the abort will occur without allocating provided that the arguments to/// panic can be formatted without allocating./// #![feature(panic_always_abort)]/// panic::always_abort();/// let _ = panic::catch_unwind(|| {///     panic!("inside the catch");/// // We will have aborted already, due to the panic.BacktraceStyle/// Prints a terser backtrace which ideally only contains relevant/// Prints a backtrace with all possible information./// Disable collecting and displaying backtraces./// The configuration for whether and how the default panic hook will capture/// and display the backtrace.SHOULD_CAPTURE// Tracks whether we should/can capture a backtrace, and how we should display// that backtrace.// Internally stores equivalent of an Option<BacktraceStyle>.set_backtrace_style/// Configures whether the default panic hook will capture and display a/// backtrace./// The default value for this setting may be set by the `RUST_BACKTRACE`/// environment variable; see the details in [`get_backtrace_style`].get_backtrace_style/// Checks whether the standard library's panic hook will capture and print a/// This function will, if a backtrace style has not been set via/// [`set_backtrace_style`], read the environment variable `RUST_BACKTRACE` to/// determine a default value for the backtrace formatting:/// The first call to `get_backtrace_style` may read the `RUST_BACKTRACE`/// environment variable if `set_backtrace_style` has not been called to/// override the default value. After a call to `set_backtrace_style` or/// `get_backtrace_style`, any changes to `RUST_BACKTRACE` will have no effect./// `RUST_BACKTRACE` is read according to these rules:/// * `0` for `BacktraceStyle::Off`/// * `full` for `BacktraceStyle::Full`/// * `1` for `BacktraceStyle::Short`/// * Other values are currently `BacktraceStyle::Short`, but this may change in///   the future/// Returns `None` if backtraces aren't currently supported.nonpoisonpanic_outputEMPTY_PANIC// This forces codegen of the function called by panic!() inside the std crate, rather than in// downstream crates. Primarily this is useful for rustc's codegen tests, which rely on noticing// complete removal of panic from generated IR. Since begin_panic is inline(never), it's only// codegen'd once per crate-graph so this pushes that to std rather than our codegen test crates.// (See https://github.com/rust-lang/rust/pull/123244 for more info on why).// If this is causing problems we can also modify those codegen tests to use a crate type like// cdylib which doesn't export "Rust" symbols to downstream linkage units./// `PanicPayload` lazily performs allocation only when needed (this avoids/// allocations when using the "abort" panic runtime)./// This function is called by the panic runtime if FFI code catches a Rust/// panic but doesn't rethrow it. We don't support this case since it messes/// with our panic count./// This function is called by the panic runtime if it catches an exception/// object which does not correspond to a Rust panic./// Registers a custom panic hook, replacing the previously registered hook./// The panic hook is invoked when a thread panics, but before the panic runtime/// is invoked. As such, the hook will run with both the aborting and unwinding/// runtimes./// The default hook, which is registered at startup, prints a message to standard error and/// generates a backtrace if requested. This behavior can be customized using the `set_hook` function./// The current hook can be retrieved while reinstating the default hook with the [`take_hook`]/// [`take_hook`]: ./fn.take_hook.html/// The hook is provided with a `PanicHookInfo` struct which contains information/// about the origin of the panic, including the payload passed to `panic!` and/// the source code location from which the panic originated./// The panic hook is a global resource./// Panics if called from a panicking thread./// The following will print "Custom panic hook":/// panic::set_hook(Box::new(|_| {///     println!("Custom panic hook");/// Unregisters the current panic hook and returns it, registering the default hook/// in its place./// *See also the function [`set_hook`].*/// [`set_hook`]: ./fn.set_hook.html/// If the default hook is registered it will be returned, but remain registered./// The following will print "Normal panic":/// let _ = panic::take_hook();/// Atomic combination of [`take_hook`] and [`set_hook`]. Use this to replace the panic handler with/// a new panic handler that does something and then executes the old handler./// The following will print the custom message, and then the normal output of panic./// #![feature(panic_update_hook)]/// // Equivalent to/// // let prev = panic::take_hook();/// // panic::set_hook(Box::new(move |info| {/// //     println!("...");/// //     prev(info);/// // }));/// panic::update_hook(move |prev, info| {///     println!("Print custom message and execute panic handler as usual");///     prev(info);/// panic!("Custom and then normal");default_hook/// The default panic handler.ALWAYS_ABORT_FLAGMustAbortAlwaysAbortPanicInHook/// A reason for forcing an immediate abort on panic.LOCAL_PANIC_COUNT// Panic count for the current thread and whether a panic hook is currently// being executed..GLOBAL_PANIC_COUNT// Sum of panic counts from all threads. The purpose of this is to have// a fast path in `count_is_zero` (which is used by `panicking`). In any particular// thread, if that thread currently views `GLOBAL_PANIC_COUNT` as being zero,// then `LOCAL_PANIC_COUNT` in that thread is zero. This invariant holds before// and after increase and decrease, but not necessarily during their execution.// Additionally, the top bit of GLOBAL_PANIC_COUNT (GLOBAL_ALWAYS_ABORT_FLAG)// records whether panic::always_abort() has been called. This can only be// set, never cleared.// panic::always_abort() is usually called to prevent memory allocations done by// the panic handling in the child created by `libc::fork`.// Memory allocations performed in a child created with `libc::fork` are undefined// behavior in most operating systems.// Accessing LOCAL_PANIC_COUNT in a child created by `libc::fork` would lead to a memory// allocation. Only GLOBAL_PANIC_COUNT can be accessed in this situation. This is// sufficient because a child process will always have exactly one thread only.// See also #85261 for details.// This could be viewed as a struct containing a single bit and an n-1-bit// value, but if we wrote it like that it would be more than a single word,// and even a newtype around usize would be clumsy because we need atomics.// But we use such a tuple for the return type of increase().// Stealing a bit is fine because it just amounts to assuming that each// panicking thread consumes at least 2 bytes of address space.// Increases the global and local panic count, and returns whether an// immediate abort is required.// This also updates thread-local state to keep track of whether a panic// hook is currently executing.finished_panic_hookset_always_abort// Disregards ALWAYS_ABORT_FLAGcount_is_zerois_zero_slow_path// Slow path is in a separate function to reduce the amount of code// inlined from `count_is_zero`./// Invoke a closure, capturing the cause of an unwinding panic if one occurs./// Determines whether the current thread is unwinding because of panic./// Entry point of panics from the core crate (`panic_impl` lang item).begin_panic/// This is the entry point of panicking for the non-format-string variants of/// panic!() and assert!(). In particular, this is the only entry point that supports/// arbitrary payloads, not just format strings.// lang item for CTFE panic support// never inline unless panic=immediate-abort to avoid code// bloat at the call sites as much as possiblepanic_with_hook/// Central point for dispatching panics./// Executes the primary logic for a panic, including checking for recursive/// panics, panic hooks, and finally dispatching to the panic runtime to either/// abort or unwind./// This is the entry point for `resume_unwind`./// It just forwards the payload to the panic runtime.rust_panic/// A function with a fixed suffix (through `rustc_std_internal_symbol`)/// on which to slap yer breakpoints.//! Implementation of various bits and pieces of the `panic!` macro and//! associated runtime pieces.//! Specifically, this module contains the implementation of://! * Panic hooks//! * Executing a panic up to doing the actual implementation//! * Shims around "try"// Binary interface to the panic runtime that the standard library depends on.// The standard library is tagged with `#![needs_panic_runtime]` (introduced in// RFC 1513) to indicate that it requires some other crate tagged with// `#![panic_runtime]` to exist somewhere. Each panic runtime is intended to// implement these symbols (with the same signatures) so we can get matched up// to them.// One day this may look a little less ad-hoc with the compiler helping out to// hook up these functions, but it is not this day!HAS_PREFIXESMAIN_SEP_STRis_sep_byteis_verbatim_sepparse_prefix/// Verbatim prefix, e.g., `\\?\cat_pics`./// Verbatim prefixes consist of `\\?\` immediately followed by the givenVerbatimUNC/// Verbatim prefix using Windows' _**U**niform **N**aming **C**onvention_,/// e.g., `\\?\UNC\server\share`./// Verbatim UNC prefixes consist of `\\?\UNC\` immediately followed by the/// server's hostname and a share name.VerbatimDisk/// Verbatim disk prefix, e.g., `\\?\C:`./// Verbatim disk prefixes consist of `\\?\` immediately followed by the/// drive letter and `:`.DeviceNS/// Device namespace prefix, e.g., `\\.\COM42`./// Device namespace prefixes consist of `\\.\` (possibly using `/`/// instead of `\`), immediately followed by the device name.UNC/// Prefix using Windows' _**U**niform **N**aming **C**onvention_, e.g./// `\\server\share`./// UNC prefixes consist of the server's hostname and a share name./// Prefix `C:` for the given disk drive./// Windows path prefixes, e.g., `C:` or `\\server\share`./// Windows uses a variety of path prefix styles, including references to drive/// volumes (like `C:`), network shared folders (like `\\server\share`), and/// others. In addition, some path prefixes are "verbatim" (i.e., prefixed with/// `\\?\`), in which case `/` is *not* treated as a separator and essentially/// no normalization is performed./// use std::path::{Component, Path, Prefix};/// use std::path::Prefix::*;/// fn get_path_prefix(s: &str) -> Prefix<'_> {///     let path = Path::new(s);///     match path.components().next().unwrap() {///         Component::Prefix(prefix_component) => prefix_component.kind(),///         _ => panic!(),/// assert_eq!(Verbatim(OsStr::new("pictures")),///            get_path_prefix(r"\\?\pictures\kittens"));/// assert_eq!(VerbatimUNC(OsStr::new("server"), OsStr::new("share")),///            get_path_prefix(r"\\?\UNC\server\share"));/// assert_eq!(VerbatimDisk(b'C'), get_path_prefix(r"\\?\c:\"));/// assert_eq!(DeviceNS(OsStr::new("BrainInterface")),///            get_path_prefix(r"\\.\BrainInterface"));/// assert_eq!(UNC(OsStr::new("server"), OsStr::new("share")),///            get_path_prefix(r"\\server\share"));/// assert_eq!(Disk(b'C'), get_path_prefix(r"C:\Users\Rust\Pictures\Ferris"));is_verbatim/// Determines if the prefix is verbatim, i.e., begins with `\\?\`./// assert!(Verbatim(OsStr::new("pictures")).is_verbatim());/// assert!(VerbatimUNC(OsStr::new("server"), OsStr::new("share")).is_verbatim());/// assert!(VerbatimDisk(b'C').is_verbatim());/// assert!(!DeviceNS(OsStr::new("BrainInterface")).is_verbatim());/// assert!(!UNC(OsStr::new("server"), OsStr::new("share")).is_verbatim());/// assert!(!Disk(b'C').is_verbatim());is_drivehas_implicit_root/// Determines whether the character is one of the permitted path/// separators for the current platform./// use std::path;/// assert!(path::is_separator('/')); // '/' works for both Unix and Windows/// assert!(!path::is_separator('❤'));MAIN_SEPARATOR/// The primary separator of path components for the current platform./// For example, `/` on Unix and `\` on Windows.MAIN_SEPARATOR_STRiter_after// Iterate through `iter` while it matches `prefix`; return `None` if `prefix`// is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving// `iter` after having exhausted `prefix`.has_physical_root/// Says whether the first byte after the prefix is a separator.rsplit_file_at_dot// basic workhorse for splitting stem and extensionsplit_file_at_dotvalidate_extension/// Checks whether the string is valid as a file extension, or panics otherwise.StartDir// c:// / or . or nothing// foo/bar/baz/// Component parsing works by a double-ended state machine; the cursors at the/// front and back of the path each keep track of what parts of the path have/// been consumed so far./// Going front to back, a path is made up of a prefix, a starting/// directory component, and a body (of normal components)/// The prefix as an unparsed `OsStr` slice./// The parsed prefix data.PrefixComponent/// A structure wrapping a Windows path prefix as well as its unparsed string/// In addition to the parsed [`Prefix`] information returned by [`kind`],/// `PrefixComponent` also holds the raw and unparsed [`OsStr`] slice,/// returned by [`as_os_str`]./// Instances of this `struct` can be obtained by matching against the/// [`Prefix` variant] on [`Component`]./// Does not occur on Unix./// let path = Path::new(r"c:\you\later\");/// match path.components().next().unwrap() {///     Component::Prefix(prefix_component) => {///         assert_eq!(Prefix::Disk(b'C'), prefix_component.kind());///         assert_eq!(OsStr::new("c:"), prefix_component.as_os_str());/// [`as_os_str`]: PrefixComponent::as_os_str/// [`kind`]: PrefixComponent::kind/// [`Prefix` variant]: Component::Prefix/// Returns the parsed prefix data./// See [`Prefix`]'s documentation for more information on the different/// kinds of prefixes./// Returns the raw [`OsStr`] slice for this prefix./// A Windows path prefix, e.g., `C:` or `\\server\share`./// There is a large variety of prefix types, see [`Prefix`]'s documentationRootDir/// The root directory component, appears after any prefix and before anything else./// It represents a separator that designates that a path starts from root.CurDir/// A reference to the current directory, i.e., `.`.ParentDir/// A reference to the parent directory, i.e., `..`./// A normal component, e.g., `a` and `b` in `a/b`./// This variant is the most common one, it represents references to files/// or directories./// A single component of a path./// A `Component` roughly corresponds to a substring between path separators/// (`/` or `\`)./// This `enum` is created by iterating over [`Components`], which in turn is/// created by the [`components`](Path::components) method on [`Path`]./// use std::path::{Component, Path};/// let path = Path::new("/tmp/foo/bar.txt");/// let components = path.components().collect::<Vec<_>>();/// assert_eq!(&components, &[///     Component::RootDir,///     Component::Normal("tmp".as_ref()),///     Component::Normal("foo".as_ref()),///     Component::Normal("bar.txt".as_ref()),/// Extracts the underlying [`OsStr`] slice./// let path = Path::new("./tmp/foo/bar.txt");/// let components: Vec<_> = path.components().map(|comp| comp.as_os_str()).collect();/// assert_eq!(&components, &[".", "tmp", "foo", "bar.txt"]);// The path left to parse components from// The prefix as it was originally parsed, if any// true if path *physically* has a root separator; for most Windows// prefixes, it may have a "logical" root separator for the purposes of// normalization, e.g., \\server\share == \\server\share\.// The iterator is double-ended, and these two states keep track of what has// been produced from either end/// An iterator over the [`Component`]s of a [`Path`]./// This `struct` is created by the [`components`] method on [`Path`]./// for component in path.components() {///     println!("{component:?}");/// [`components`]: Path::components/// An iterator over the [`Component`]s of a [`Path`], as [`OsStr`] slices./// This `struct` is created by the [`iter`] method on [`Path`]./// [`iter`]: Path::iter// how long is the prefix, if any?prefix_verbatimprefix_remaining/// how much of the prefix is left from the point of view of iteration?len_before_body// Given the iteration so far, how much of the pre-State::Body path is left?// is the iteration complete?/// Extracts a slice corresponding to the portion of the path remaining for iteration./// let mut components = Path::new("/tmp/foo/bar.txt").components();/// components.next();/// assert_eq!(Path::new("foo/bar.txt"), components.as_path());has_root/// Is the *original* path rooted?include_cur_dir/// Should the normalized path include a leading . ?parse_single_component// parse a given byte sequence following the OsStr encoding into the// corresponding path componentparse_next_component// parse a component from the left, saying how many bytes to consume to// remove the componentparse_next_component_back// parse a component from the right, saying how many bytes to consume to// trim away repeated separators (i.e., empty components) on the left// trim away repeated separators (i.e., empty components) on the right/// let mut iter = Path::new("/tmp/foo/bar.txt").iter();/// assert_eq!(Path::new("foo/bar.txt"), iter.as_path());compare_componentsAncestors/// An iterator over [`Path`] and its ancestors./// This `struct` is created by the [`ancestors`] method on [`Path`]./// let path = Path::new("/foo/bar");/// for ancestor in path.ancestors() {///     println!("{}", ancestor.display());/// [`ancestors`]: Path::ancestors/// An owned, mutable path (akin to [`String`])./// This type provides methods like [`push`] and [`set_extension`] that mutate/// the path in place. It also implements [`Deref`] to [`Path`], meaning that/// all methods on [`Path`] slices are available on `PathBuf` values as well./// [`push`]: PathBuf::push/// [`set_extension`]: PathBuf::set_extension/// More details about the overall approach can be found in/// the [module documentation](self)./// You can use [`push`] to build up a `PathBuf` from/// components:/// let mut path = PathBuf::new();/// path.push(r"C:\");/// path.push("windows");/// path.push("system32");/// path.set_extension("dll");/// However, [`push`] is best used for dynamic situations. This is a better way/// to do this when you know all of the components ahead of time:/// let path: PathBuf = [r"C:\", "windows", "system32.dll"].iter().collect();/// We can still do better than this! Since these are all strings, we can use/// `From::from`:/// let path = PathBuf::from(r"C:\windows\system32.dll");/// Which method works best depends on what kind of situation you're in./// Note that `PathBuf` does not always sanitize arguments, for example/// [`push`] allows paths built from strings which include separators:/// path.push(r"..\otherdir");/// The behavior of `PathBuf` may be changed to a panic on such inputs/// in the future. [`Extend::extend`] should be used to add multi-part paths./// Allocates an empty `PathBuf`./// let path = PathBuf::new();/// Creates a new `PathBuf` with a given capacity used to create the/// internal [`OsString`]. See [`with_capacity`] defined on [`OsString`]./// let mut path = PathBuf::with_capacity(10);/// let capacity = path.capacity();/// assert_eq!(capacity, path.capacity());/// [`with_capacity`]: OsString::with_capacity/// Coerces to a [`Path`] slice./// use std::path::{Path, PathBuf};/// let p = PathBuf::from("/test");/// assert_eq!(Path::new("/test"), p.as_path());/// Consumes and leaks the `PathBuf`, returning a mutable reference to the contents,/// `&'a mut Path`./// the program's life, as dropping the returned reference will cause a memory leak./// It does not reallocate or shrink the `PathBuf`, so the leaked allocation may include/// capacity, call [`into_boxed_path`], and then [`Box::leak`] instead./// [`into_boxed_path`]: Self::into_boxed_path/// Extends `self` with `path`./// If `path` is absolute, it replaces the current path./// * if `path` has a root but no prefix (e.g., `\windows`), it///   replaces everything except for the prefix (if any) of `self`./// * if `path` has a prefix but no root, it replaces `self`./// * if `self` has a verbatim prefix (e.g. `\\?\C:\windows`)///   and `path` is not empty, the new path is normalized: all references///   to `.` and `..` are removed./// Consider using [`Path::join`] if you need a new `PathBuf` instead of/// using this function on a cloned `PathBuf`./// Pushing a relative path extends the existing path:/// let mut path = PathBuf::from("/tmp");/// path.push("file.bk");/// assert_eq!(path, PathBuf::from("/tmp/file.bk"));/// Pushing an absolute path replaces the existing path:/// path.push("/etc");/// assert_eq!(path, PathBuf::from("/etc"));_push/// Truncates `self` to [`self.parent`]./// Returns `false` and does nothing if [`self.parent`] is [`None`]./// Otherwise, returns `true`./// [`self.parent`]: Path::parent/// let mut p = PathBuf::from("/spirited/away.rs");/// p.pop();/// assert_eq!(Path::new("/spirited"), p);/// assert_eq!(Path::new("/"), p);set_trailing_sep/// Sets whether the path has a trailing [separator](MAIN_SEPARATOR)./// The value returned by [`has_trailing_sep`](Path::has_trailing_sep) will be equivalent to/// the provided value if possible./// #![feature(path_trailing_sep)]/// let mut p = PathBuf::from("dir");/// assert!(!p.has_trailing_sep());/// p.set_trailing_sep(false);/// p.set_trailing_sep(true);/// assert!(p.has_trailing_sep());/// p = PathBuf::from("/");push_trailing_sep/// Adds a trailing [separator](MAIN_SEPARATOR) to the path./// This acts similarly to [`Path::with_trailing_sep`], but mutates the underlying `PathBuf`./// p.push_trailing_sep();/// p = PathBuf::from("dir/");/// assert_eq!(p.as_os_str(), OsStr::new("dir/"));pop_trailing_sep/// Removes a trailing [separator](MAIN_SEPARATOR) from the path, if possible./// This acts similarly to [`Path::trim_trailing_sep`], but mutates the underlying `PathBuf`./// let mut p = PathBuf::from("dir//");/// assert_eq!(p.as_os_str(), OsStr::new("dir//"));/// p.pop_trailing_sep();/// assert_eq!(p.as_os_str(), OsStr::new("dir"));set_file_name/// Updates [`self.file_name`] to `file_name`./// If [`self.file_name`] was [`None`], this is equivalent to pushing/// `file_name`./// Otherwise it is equivalent to calling [`pop`] and then pushing/// `file_name`. The new path will be a sibling of the original path./// (That is, it will have the same parent.)/// The argument is not sanitized, so can include separators. This/// behavior may be changed to a panic in the future./// [`self.file_name`]: Path::file_name/// [`pop`]: PathBuf::pop/// let mut buf = PathBuf::from("/");/// assert!(buf.file_name() == None);/// buf.set_file_name("foo.txt");/// assert!(buf == PathBuf::from("/foo.txt"));/// assert!(buf.file_name().is_some());/// buf.set_file_name("bar.txt");/// assert!(buf == PathBuf::from("/bar.txt"));/// buf.set_file_name("baz");/// assert!(buf == PathBuf::from("/baz"));/// buf.set_file_name("../b/c.txt");/// assert!(buf == PathBuf::from("/../b/c.txt"));/// assert!(buf == PathBuf::from("/../b/baz"));_set_file_name/// Updates [`self.extension`] to `Some(extension)` or to `None` if/// `extension` is empty./// Returns `false` and does nothing if [`self.file_name`] is [`None`],/// returns `true` and updates the extension otherwise./// If [`self.extension`] is [`None`], the extension is added; otherwise/// it is replaced./// If `extension` is the empty string, [`self.extension`] will be [`None`]/// afterwards, not `Some("")`./// Panics if the passed extension contains a path separator (see/// [`is_separator`])./// The new `extension` may contain dots and will be used in its entirety,/// but only the part after the final dot will be reflected in/// [`self.extension`]./// If the file stem contains internal dots and `extension` is empty, part/// of the old file stem will be considered the new [`self.extension`]./// See the examples below./// [`self.extension`]: Path::extension/// let mut p = PathBuf::from("/feel/the");/// p.set_extension("force");/// assert_eq!(Path::new("/feel/the.force"), p.as_path());/// p.set_extension("dark.side");/// assert_eq!(Path::new("/feel/the.dark.side"), p.as_path());/// p.set_extension("cookie");/// assert_eq!(Path::new("/feel/the.dark.cookie"), p.as_path());/// p.set_extension("");/// assert_eq!(Path::new("/feel/the.dark"), p.as_path());/// assert_eq!(Path::new("/feel/the"), p.as_path());_set_extension/// Append [`self.extension`] with `extension`./// The appended `extension` may contain dots and will be used in its entirety,/// p.add_extension("formatted");/// assert_eq!(Path::new("/feel/the.formatted"), p.as_path());/// p.add_extension("dark.side");/// assert_eq!(Path::new("/feel/the.formatted.dark.side"), p.as_path());/// assert_eq!(Path::new("/feel/the.formatted.dark.cookie"), p.as_path());/// assert_eq!(Path::new("/feel/the.formatted.dark"), p.as_path());/// p.add_extension("");_add_extensionas_mut_os_string/// Yields a mutable reference to the underlying [`OsString`] instance./// let mut path = PathBuf::from("/foo");/// path.push("bar");/// assert_eq!(path, Path::new("/foo/bar"));/// // OsString's `push` does not add a separator./// path.as_mut_os_string().push("baz");/// assert_eq!(path, Path::new("/foo/barbaz"));/// Consumes the `PathBuf`, yielding its internal [`OsString`] storage./// let p = PathBuf::from("/the/head");/// let os_str = p.into_os_string();into_boxed_path/// Converts this `PathBuf` into a [boxed](Box) [`Path`]./// Invokes [`capacity`] on the underlying instance of [`OsString`]./// [`capacity`]: OsString::capacity/// Invokes [`clear`] on the underlying instance of [`OsString`]./// [`clear`]: OsString::clear/// Invokes [`reserve`] on the underlying instance of [`OsString`]./// Invokes [`try_reserve`] on the underlying instance of [`OsString`]./// Invokes [`reserve_exact`] on the underlying instance of [`OsString`]./// [`reserve_exact`]: OsString::reserve_exact/// Invokes [`try_reserve_exact`] on the underlying instance of [`OsString`]./// [`try_reserve_exact`]: OsString::try_reserve_exact/// Invokes [`shrink_to_fit`] on the underlying instance of [`OsString`]./// [`shrink_to_fit`]: OsString::shrink_to_fit/// Invokes [`shrink_to`] on the underlying instance of [`OsString`]./// [`shrink_to`]: OsString::shrink_to/// Creates a boxed [`Path`] from a reference./// This will allocate and clone `path` to it./// Creates a boxed [`Path`] from a clone-on-write pointer./// Converting from a `Cow::Owned` does not clone or allocate./// Converts a <code>[Box]&lt;[Path]&gt;</code> into a [`PathBuf`]./// Converts a [`PathBuf`] into a <code>[Box]&lt;[Path]&gt;</code>./// This conversion currently should not allocate memory,/// but this behavior is not guaranteed on all platforms or in all future versions./// Converts a borrowed [`OsStr`] to a [`PathBuf`]./// Allocates a [`PathBuf`] and copies the data into it./// Converts an [`OsString`] into a [`PathBuf`]./// Converts a [`PathBuf`] into an [`OsString`]/// Converts a [`String`] into a [`PathBuf`]/// Creates a new `PathBuf` from the [`Path`] elements of an iterator./// This uses [`push`](Self::push) to add each element, so can be used to adjoin multiple path/// [components](Components)./// let path = PathBuf::from_iter(["/tmp", "foo", "bar"]);/// assert_eq!(path, PathBuf::from("/tmp/foo/bar"));/// See documentation for [`push`](Self::push) for more details on how the path is constructed./// Extends `self` with [`Path`] elements from `iter`./// path.extend(["foo", "bar", "file.txt"]);/// assert_eq!(path, PathBuf::from("/tmp/foo/bar/file.txt"));/// Creates a clone-on-write pointer from a reference to/// [`Path`]./// This conversion does not clone or allocate./// Creates a clone-on-write pointer from an owned/// instance of [`PathBuf`]./// [`PathBuf`]./// Converts a clone-on-write pointer to an owned path./// Converts a [`PathBuf`] into an <code>[Arc]<[Path]></code> by moving the [`PathBuf`] data/// into a new [`Arc`] buffer./// Converts a [`Path`] into an [`Arc`] by copying the [`Path`] data into a new [`Arc`] buffer./// Converts a [`PathBuf`] into an <code>[Rc]<[Path]></code> by moving the [`PathBuf`] data into/// a new [`Rc`] buffer./// Converts a [`Path`] into an [`Rc`] by copying the [`Path`] data into a new [`Rc`] buffer./// A slice of a path (akin to [`str`])./// This type supports a number of operations for inspecting a path, including/// breaking the path into its components (separated by `/` on Unix and by either/// `/` or `\` on Windows), extracting the file name, determining whether the path/// is absolute, and so on./// This is an *unsized* type, meaning that it must always be used behind a/// pointer like `&` or [`Box`]. For an owned version of this type,/// see [`PathBuf`]./// // Note: this example does work on Windows/// let path = Path::new("./foo/bar.txt");/// let parent = path.parent();/// assert_eq!(parent, Some(Path::new("./foo")));/// let file_stem = path.file_stem();/// assert_eq!(file_stem, Some(OsStr::new("bar")));/// let extension = path.extension();/// assert_eq!(extension, Some(OsStr::new("txt")));// `Path::new` and `impl CloneToUninit for Path` current implementation relies// on `Path` being layout-compatible with `OsStr`.// However, `Path` layout is considered an implementation detail and must not be relied upon.StripPrefixError/// An error returned from [`Path::strip_prefix`] if the prefix was not found./// This `struct` is created by the [`strip_prefix`] method on [`Path`]./// [`strip_prefix`]: Path::strip_prefixNormalizeError/// An error returned from [`Path::normalize_lexically`] if a `..` parent reference/// would escape the path.from_u8_slice// The following (private!) function allows construction of a path from a u8// slice, which is only safe when it is known to follow the OsStr encoding.// The following (private!) function reveals the byte encoding used for OsStr./// Directly wraps a string slice as a `Path` slice./// This is a cost-free conversion./// Path::new("foo.txt");/// You can create `Path`s from `String`s, or even other `Path`s:/// let string = String::from("foo.txt");/// let from_string = Path::new(&string);/// let from_path = Path::new(&from_string);/// assert_eq!(from_string, from_path);/// Yields the underlying [`OsStr`] slice./// let os_str = Path::new("foo.txt").as_os_str();/// assert_eq!(os_str, std::ffi::OsStr::new("foo.txt"));as_mut_os_str/// Yields a mutable reference to the underlying [`OsStr`] slice./// let mut path = PathBuf::from("Foo.TXT");/// assert_ne!(path, Path::new("foo.txt"));/// path.as_mut_os_str().make_ascii_lowercase();/// assert_eq!(path, Path::new("foo.txt"));/// Yields a [`&str`] slice if the `Path` is valid unicode./// Note that validation is performed because non-UTF-8 strings are/// perfectly valid for some OS./// let path = Path::new("foo.txt");/// assert_eq!(path.to_str(), Some("foo.txt"));/// Converts a `Path` to a [`Cow<str>`]./// [U+FFFD]: super::char::REPLACEMENT_CHARACTER/// Calling `to_string_lossy` on a `Path` with valid unicode:/// assert_eq!(path.to_string_lossy(), "foo.txt");/// Had `path` contained invalid unicode, the `to_string_lossy` call might/// have returned `"fo�.txt"`.to_path_buf/// Converts a `Path` to an owned [`PathBuf`]./// let path_buf = Path::new("foo.txt").to_path_buf();/// assert_eq!(path_buf, PathBuf::from("foo.txt"));/// Returns `true` if the `Path` is absolute, i.e., if it is independent of/// * On Unix, a path is absolute if it starts with the root, so/// `is_absolute` and [`has_root`] are equivalent./// * On Windows, a path is absolute if it has a prefix and starts with the/// root: `c:\windows` is absolute, while `c:temp` and `\temp` are not./// assert!(!Path::new("foo.txt").is_absolute());/// [`has_root`]: Path::has_rootis_relative/// Returns `true` if the `Path` is relative, i.e., not absolute./// See [`is_absolute`]'s documentation for more details./// assert!(Path::new("foo.txt").is_relative());/// [`is_absolute`]: Path::is_absolute/// Returns `true` if the `Path` has a root./// * On Unix, a path has a root if it begins with `/`./// * On Windows, a path has a root if it:///     * has no prefix and begins with a separator, e.g., `\windows`///     * has a prefix followed by a separator, e.g., `c:\windows` but not `c:windows`///     * has any non-disk prefix, e.g., `\\server\share`/// assert!(Path::new("/etc/passwd").has_root());/// Returns the `Path` without its final component, if there is one./// This means it returns `Some("")` for relative paths with one component./// Returns [`None`] if the path terminates in a root or prefix, or if it's/// let parent = path.parent().unwrap();/// assert_eq!(parent, Path::new("/foo"));/// let grand_parent = parent.parent().unwrap();/// assert_eq!(grand_parent, Path::new("/"));/// assert_eq!(grand_parent.parent(), None);/// let relative_path = Path::new("foo/bar");/// let parent = relative_path.parent();/// assert_eq!(parent, Some(Path::new("foo")));/// let grand_parent = parent.and_then(Path::parent);/// assert_eq!(grand_parent, Some(Path::new("")));/// let great_grand_parent = grand_parent.and_then(Path::parent);/// assert_eq!(great_grand_parent, None);/// Produces an iterator over `Path` and its ancestors./// The iterator will yield the `Path` that is returned if the [`parent`] method is used zero/// or more times. If the [`parent`] method returns [`None`], the iterator will do likewise./// The iterator will always yield at least one value, namely `Some(&self)`. Next it will yield/// `&self.parent()`, `&self.parent().and_then(Path::parent)` and so on./// let mut ancestors = Path::new("/foo/bar").ancestors();/// assert_eq!(ancestors.next(), Some(Path::new("/foo/bar")));/// assert_eq!(ancestors.next(), Some(Path::new("/foo")));/// assert_eq!(ancestors.next(), Some(Path::new("/")));/// assert_eq!(ancestors.next(), None);/// let mut ancestors = Path::new("../foo/bar").ancestors();/// assert_eq!(ancestors.next(), Some(Path::new("../foo/bar")));/// assert_eq!(ancestors.next(), Some(Path::new("../foo")));/// assert_eq!(ancestors.next(), Some(Path::new("..")));/// assert_eq!(ancestors.next(), Some(Path::new("")));/// [`parent`]: Path::parent/// Returns the final component of the `Path`, if there is one./// If the path is a normal file, this is the file name. If it's the path of a directory, this/// is the directory name./// Returns [`None`] if the path terminates in `..`./// assert_eq!(Some(OsStr::new("bin")), Path::new("/usr/bin/").file_name());/// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("tmp/foo.txt").file_name());/// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());/// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());/// assert_eq!(None, Path::new("foo.txt/..").file_name());/// assert_eq!(None, Path::new("/").file_name());/// Returns a path that, when joined onto `base`, yields `self`./// If `base` is not a prefix of `self` (i.e., [`starts_with`]/// returns `false`), returns [`Err`]./// [`starts_with`]: Path::starts_with/// let path = Path::new("/test/haha/foo.txt");/// assert_eq!(path.strip_prefix("/"), Ok(Path::new("test/haha/foo.txt")));/// assert_eq!(path.strip_prefix("/test"), Ok(Path::new("haha/foo.txt")));/// assert_eq!(path.strip_prefix("/test/"), Ok(Path::new("haha/foo.txt")));/// assert_eq!(path.strip_prefix("/test/haha/foo.txt"), Ok(Path::new("")));/// assert_eq!(path.strip_prefix("/test/haha/foo.txt/"), Ok(Path::new("")));/// assert!(path.strip_prefix("test").is_err());/// assert!(path.strip_prefix("/te").is_err());/// assert!(path.strip_prefix("/haha").is_err());/// let prefix = PathBuf::from("/test/");/// assert_eq!(path.strip_prefix(prefix), Ok(Path::new("haha/foo.txt")));_strip_prefix/// Determines whether `base` is a prefix of `self`./// Only considers whole path components to match./// let path = Path::new("/etc/passwd");/// assert!(path.starts_with("/etc"));/// assert!(path.starts_with("/etc/"));/// assert!(path.starts_with("/etc/passwd"));/// assert!(path.starts_with("/etc/passwd/")); // extra slash is okay/// assert!(path.starts_with("/etc/passwd///")); // multiple extra slashes are okay/// assert!(!path.starts_with("/e"));/// assert!(!path.starts_with("/etc/passwd.txt"));/// assert!(!Path::new("/etc/foo.rs").starts_with("/etc/foo"));_starts_with/// Determines whether `child` is a suffix of `self`./// let path = Path::new("/etc/resolv.conf");/// assert!(path.ends_with("resolv.conf"));/// assert!(path.ends_with("etc/resolv.conf"));/// assert!(path.ends_with("/etc/resolv.conf"));/// assert!(!path.ends_with("/resolv.conf"));/// assert!(!path.ends_with("conf")); // use .extension() instead_ends_with/// Checks whether the `Path` is empty./// #![feature(path_is_empty)]/// let path = Path::new("");/// assert!(path.is_empty());/// let path = Path::new("foo");/// assert!(!path.is_empty());/// let path = Path::new(".");file_stem/// Extracts the stem (non-extension) portion of [`self.file_name`]./// The stem is:/// * [`None`], if there is no file name;/// * The entire file name if there is no embedded `.`;/// * The entire file name if the file name begins with `.` and has no other `.`s within;/// * Otherwise, the portion of the file name before the final `.`/// assert_eq!("foo", Path::new("foo.rs").file_stem().unwrap());/// assert_eq!("foo.tar", Path::new("foo.tar.gz").file_stem().unwrap());/// This method is similar to [`Path::file_prefix`], which extracts the portion of the file name/// before the *first* `.`/// [`Path::file_prefix`]: Path::file_prefixfile_prefix/// Extracts the prefix of [`self.file_name`]./// The prefix is:/// * The portion of the file name before the first non-beginning `.`;/// * The portion of the file name before the second `.` if the file name begins with `.`/// assert_eq!("foo", Path::new("foo.rs").file_prefix().unwrap());/// assert_eq!("foo", Path::new("foo.tar.gz").file_prefix().unwrap());/// assert_eq!(".config", Path::new(".config").file_prefix().unwrap());/// assert_eq!(".config", Path::new(".config.toml").file_prefix().unwrap());/// This method is similar to [`Path::file_stem`], which extracts the portion of the file name/// before the *last* `.`/// [`Path::file_stem`]: Path::file_stem/// Extracts the extension (without the leading dot) of [`self.file_name`], if possible./// The extension is:/// * [`None`], if there is no embedded `.`;/// * [`None`], if the file name begins with `.` and has no other `.`s within;/// * Otherwise, the portion of the file name after the final `.`/// assert_eq!("rs", Path::new("foo.rs").extension().unwrap());/// assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap());has_trailing_sep/// Checks whether the path ends in a trailing [separator](MAIN_SEPARATOR)./// This is generally done to ensure that a path is treated as a directory, not a file,/// although it does not actually guarantee that such a path is a directory on the underlying/// file system./// Despite this behavior, two paths are still considered the same in Rust whether they have a/// trailing separator or not./// assert!(Path::new("dir/").has_trailing_sep());/// assert!(!Path::new("file.rs").has_trailing_sep());with_trailing_sep/// Ensures that a path has a trailing [separator](MAIN_SEPARATOR),/// allocating a [`PathBuf`] if necessary./// The resulting path will return true for [`has_trailing_sep`](Self::has_trailing_sep)./// assert_eq!(Path::new("dir//").with_trailing_sep().as_os_str(), OsStr::new("dir//"));/// assert_eq!(Path::new("dir/").with_trailing_sep().as_os_str(), OsStr::new("dir/"));/// assert!(!Path::new("dir").has_trailing_sep());/// assert!(Path::new("dir").with_trailing_sep().has_trailing_sep());trim_trailing_sep/// Trims a trailing [separator](MAIN_SEPARATOR) from a path, if possible./// The resulting path will return false for [`has_trailing_sep`](Self::has_trailing_sep) for/// most paths./// Some paths, like `/`, cannot be trimmed in this way./// assert_eq!(Path::new("dir//").trim_trailing_sep().as_os_str(), OsStr::new("dir"));/// assert_eq!(Path::new("dir/").trim_trailing_sep().as_os_str(), OsStr::new("dir"));/// assert_eq!(Path::new("dir").trim_trailing_sep().as_os_str(), OsStr::new("dir"));/// assert_eq!(Path::new("/").trim_trailing_sep().as_os_str(), OsStr::new("/"));/// assert_eq!(Path::new("//").trim_trailing_sep().as_os_str(), OsStr::new("//"));/// Creates an owned [`PathBuf`] with `path` adjoined to `self`./// See [`PathBuf::push`] for more details on what it means to adjoin a path./// assert_eq!(Path::new("/etc").join("passwd"), PathBuf::from("/etc/passwd"));/// assert_eq!(Path::new("/etc").join("/bin/sh"), PathBuf::from("/bin/sh"));_joinwith_file_name/// Creates an owned [`PathBuf`] like `self` but with the given file name./// See [`PathBuf::set_file_name`] for more details./// let path = Path::new("/tmp/foo.png");/// assert_eq!(path.with_file_name("bar"), PathBuf::from("/tmp/bar"));/// assert_eq!(path.with_file_name("bar.txt"), PathBuf::from("/tmp/bar.txt"));/// let path = Path::new("/tmp");/// assert_eq!(path.with_file_name("var"), PathBuf::from("/var"));_with_file_name/// Creates an owned [`PathBuf`] like `self` but with the given extension./// See [`PathBuf::set_extension`] for more details./// let path = Path::new("foo.rs");/// assert_eq!(path.with_extension("txt"), Path::new("foo.txt"));/// assert_eq!(path.with_extension(""), Path::new("foo"));/// Handling multiple extensions:/// let path = Path::new("foo.tar.gz");/// assert_eq!(path.with_extension("xz"), Path::new("foo.tar.xz"));/// assert_eq!(path.with_extension("").with_extension("txt"), Path::new("foo.txt"));/// Adding an extension where one did not exist:/// assert_eq!(path.with_extension("rs"), Path::new("foo.rs"));_with_extensionwith_added_extension/// Creates an owned [`PathBuf`] like `self` but with the extension added./// See [`PathBuf::add_extension`] for more details./// assert_eq!(path.with_added_extension("txt"), PathBuf::from("foo.rs.txt"));/// assert_eq!(path.with_added_extension(""), PathBuf::from("foo.tar.gz"));/// assert_eq!(path.with_added_extension("xz"), PathBuf::from("foo.tar.gz.xz"));/// assert_eq!(path.with_added_extension("").with_added_extension("txt"), PathBuf::from("foo.tar.gz.txt"));/// Produces an iterator over the [`Component`]s of the path./// When parsing the path, there is a small amount of normalization:/// * Repeated separators are ignored, so `a/b` and `a//b` both have///   `a` and `b` as components./// * Occurrences of `.` are normalized away, except if they are at the///   beginning of the path. For example, `a/./b`, `a/b/`, `a/b/.` and///   `a/b` all have `a` and `b` as components, but `./a/b` starts with///   an additional [`CurDir`] component./// * Trailing separators are normalized away, so `/a/b` and `/a/b/` are equivalent./// Note that no other normalization takes place; in particular, `a/c`/// and `a/b/../c` are distinct, to account for the possibility that `b`/// is a symbolic link (so its parent isn't `a`)./// use std::path::{Path, Component};/// let mut components = Path::new("/tmp/foo.txt").components();/// assert_eq!(components.next(), Some(Component::RootDir));/// assert_eq!(components.next(), Some(Component::Normal(OsStr::new("tmp"))));/// assert_eq!(components.next(), Some(Component::Normal(OsStr::new("foo.txt"))));/// assert_eq!(components.next(), None)/// [`CurDir`]: Component::CurDir/// Produces an iterator over the path's components viewed as [`OsStr`]/// slices./// For more information about the particulars of how the path is separated/// into components, see [`components`]./// use std::path::{self, Path};/// let mut it = Path::new("/tmp/foo.txt").iter();/// assert_eq!(it.next(), Some(OsStr::new(&path::MAIN_SEPARATOR.to_string())));/// assert_eq!(it.next(), Some(OsStr::new("tmp")));/// assert_eq!(it.next(), Some(OsStr::new("foo.txt")));/// assert_eq!(it.next(), None)"this does not display the path, \
                  it returns an object that can be displayed"/// Returns an object that implements [`Display`] for safely printing paths/// that may contain non-Unicode data. This may perform lossy conversion,/// depending on the platform.  If you would like an implementation which/// escapes the path please use [`Debug`] instead./// let path = Path::new("/tmp/foo.rs");/// println!("{}", path.display());/// Queries the file system to get information about a file, directory, etc./// This is an alias to [`fs::metadata`]./// let path = Path::new("/Minas/tirith");/// let metadata = path.metadata().expect("metadata call failed");/// println!("{:?}", metadata.file_type());/// This is an alias to [`fs::symlink_metadata`]./// let metadata = path.symlink_metadata().expect("symlink_metadata call failed");/// Returns the canonical, absolute form of the path with all intermediate/// This is an alias to [`fs::canonicalize`]./// This method will return an error in the following situations, but is not/// let path = Path::new("/foo/test/../test/bar.rs");/// assert_eq!(path.canonicalize().unwrap(), PathBuf::from("/foo/test/bar.rs"));normalize_lexically/// Normalize a path, including `..` without traversing the filesystem./// Returns an error if normalization would leave leading `..` components./// This function always resolves `..` to the "lexical" parent./// That is "a/b/../c" will always resolve to `a/c` which can change the meaning of the path./// In particular, `a/c` and `a/b/../c` are distinct on many systems because `b` may be a symbolic link, so its parent isn't `a`./// [`path::absolute`](absolute) is an alternative that preserves `..`./// Or [`Path::canonicalize`] can be used to resolve any `..` by querying the filesystem./// This is an alias to [`fs::read_link`]./// let path = Path::new("/laputa/sky_castle.rs");/// let path_link = path.read_link().expect("read_link call failed");/// The iterator will yield instances of <code>[io::Result]<[fs::DirEntry]></code>. New/// errors may be encountered after an iterator is initially constructed./// This is an alias to [`fs::read_dir`]./// let path = Path::new("/laputa");/// for entry in path.read_dir().expect("read_dir call failed") {///     if let Ok(entry) = entry {///         println!("{:?}", entry.path());/// Returns `true` if the path points at an existing entity./// Warning: this method may be error-prone, consider using [`try_exists()`] instead!/// It also has a risk of introducing time-of-check to time-of-use ([TOCTOU]) bugs./// If you cannot access the metadata of the file, e.g. because of a/// permission error or broken symbolic links, this will return `false`./// assert!(!Path::new("does_not_exist.txt").exists());/// This is a convenience function that coerces errors to false. If you want to/// check errors, call [`Path::try_exists`]./// [`try_exists()`]: Self::try_exists/// [TOCTOU]: fs#time-of-check-to-time-of-use-toctou/// [`Path::exists()`] only checks whether or not a path was both found and readable. By/// contrast, `try_exists` will return `Ok(true)` or `Ok(false)`, respectively, if the path/// was _verified_ to exist or not exist. If its existence can neither be confirmed nor/// denied, it will propagate an `Err(_)` instead. This can be the case if e.g. listing/// This is an alias for [`std::fs::exists`](crate::fs::exists)./// assert!(!Path::new("does_not_exist.txt").try_exists().expect("Can't check existence of file does_not_exist.txt"));/// assert!(Path::new("/root/secret_file.txt").try_exists().is_err());/// [`exists()`]: Self::exists/// Returns `true` if the path exists on disk and is pointing at a regular file./// assert_eq!(Path::new("./is_a_directory/").is_file(), false);/// assert_eq!(Path::new("a_file.txt").is_file(), true);/// check errors, call [`fs::metadata`] and handle its [`Result`]. Then call/// [`fs::Metadata::is_file`] if it was [`Ok`]./// a Unix-like system for example. See [`fs::File::open`] or/// [`fs::OpenOptions::open`] for more information./// Returns `true` if the path exists on disk and is pointing at a directory./// assert_eq!(Path::new("./is_a_directory/").is_dir(), true);/// assert_eq!(Path::new("a_file.txt").is_dir(), false);/// [`fs::Metadata::is_dir`] if it was [`Ok`]./// Returns `true` if the path exists on disk and is pointing at a symbolic link./// This function will not traverse symbolic links./// In case of a broken symbolic link this will also return true./// If you cannot access the directory containing the file, e.g., because of a/// permission error, this will return false./// let link_path = Path::new("link");/// symlink("/origin_does_not_exist/", link_path).unwrap();/// assert_eq!(link_path.is_symlink(), true);/// assert_eq!(link_path.exists(), false);/// check errors, call [`fs::symlink_metadata`] and handle its [`Result`]. Then call/// [`fs::Metadata::is_symlink`] if it was [`Ok`]./// Converts a [`Box<Path>`](Box) into a [`PathBuf`] without copying or/// Helper struct for safely printing paths with [`format!`] and `{}`./// A [`Path`] might contain non-Unicode data. This `struct` implements the/// [`display`](Path::display) method on [`Path`]. This may perform lossy/// which escapes the path please use [`Debug`] instead.impl_cmp_os_str/// Makes the path absolute without accessing the filesystem./// If the path is relative, the current directory is used as the base directory./// All intermediate components will be resolved according to platform-specific/// rules, but unlike [`canonicalize`][crate::fs::canonicalize], this does not/// resolve symlinks and may succeed even if the path does not exist./// If the `path` is empty or getting the/// [current directory][crate::env::current_dir] fails, then an error will be/// On POSIX platforms, the path is resolved using [POSIX semantics][posix-semantics],/// except that it stops short of resolving symlinks. This means it will keep `..`/// components and trailing separators./// On Windows, for verbatim paths, this will simply return the path as given. For other/// paths, this is currently equivalent to calling/// [`GetFullPathNameW`][windows-path]./// On Cygwin, this is currently equivalent to calling [`cygwin_conv_path`][cygwin-path]/// with mode `CCP_WIN_A_TO_POSIX`, and then being processed like other POSIX platforms./// If a Windows path is given, it will be converted to an absolute POSIX path without/// keeping `..`./// Note that these [may change in the future][changes]./// This function may return an error in the following situations:/// * If `path` is syntactically invalid; in particular, if it is empty./// * If getting the [current directory][crate::env::current_dir] fails./// ## POSIX paths///     use std::path::{self, Path};///     // Relative to absolute///     let absolute = path::absolute("foo/./bar")?;///     assert!(absolute.ends_with("foo/bar"));///     // Absolute to absolute///     let absolute = path::absolute("/foo//test/.././bar.rs")?;///     assert_eq!(absolute, Path::new("/foo/test/../bar.rs"));/// ## Windows paths/// # #[cfg(windows)]///     assert!(absolute.ends_with(r"foo\bar"));///     let absolute = path::absolute(r"C:\foo//test\..\./bar.rs")?;///     assert_eq!(absolute, Path::new(r"C:\foo\bar.rs"));/// # #[cfg(not(windows))]/// [posix-semantics]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13/// [windows-path]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfullpathnamew/// [cygwin-path]: https://cygwin.com/cygwin-api/func-cygwin-conv-path.html//! Cross-platform path manipulation.//! This module provides two types, [`PathBuf`] and [`Path`] (akin to [`String`]//! and [`str`]), for working with paths abstractly. These types are thin wrappers//! around [`OsString`] and [`OsStr`] respectively, meaning that they work directly//! on strings according to the local platform's path syntax.//! Paths can be parsed into [`Component`]s by iterating over the structure//! returned by the [`components`] method on [`Path`]. [`Component`]s roughly//! correspond to the substrings between path separators (`/` or `\`). You can//! reconstruct an equivalent path from components with the [`push`] method on//! [`PathBuf`]; note that the paths may differ syntactically by the//! normalization described in the documentation for the [`components`] method.//! ## Case sensitivity//! Unless otherwise indicated path methods that do not access the filesystem,//! such as [`Path::starts_with`] and [`Path::ends_with`], are case sensitive no//! matter the platform or filesystem. An exception to this is made for Windows//! drive letters.//! ## Simple usage//! Path manipulation includes both parsing components from slices and building//! new owned paths.//! To parse a path, you can create a [`Path`] slice from a [`str`]//! slice and start asking questions://! let path = Path::new("/tmp/foo/bar.txt");//! let parent = path.parent();//! assert_eq!(parent, Some(Path::new("/tmp/foo")));//! let file_stem = path.file_stem();//! assert_eq!(file_stem, Some(OsStr::new("bar")));//! let extension = path.extension();//! assert_eq!(extension, Some(OsStr::new("txt")));//! To build or modify paths, use [`PathBuf`]://! // This way works...//! let mut path = PathBuf::from("c:\\");//! path.push("windows");//! path.push("system32");//! path.set_extension("dll");//! // ... but push is best used if you don't know everything up//! // front. If you do, this way is better://! let path: PathBuf = ["c:\\", "windows", "system32.dll"].iter().collect();//! [`components`]: Path::components//! [`push`]: PathBuf::push// GENERAL NOTES// Parsing in this module is done by directly transmuting OsStr to [u8] slices,// taking advantage of the fact that OsStr always encodes ASCII characters// as-is.  Eventually, this transmutation should be replaced by direct uses of// OsStr APIs for parsing, but it will take a while for those to become// Windows Prefixes// Exposed parsing helpers// Misc helpers// Cross-platform, iterator-independent parsing// The core iterators// Basic types and traits/// The 2015 version of the prelude of The Rust Standard Library./// The 2018 version of the prelude of The Rust Standard Library./// The 2021 version of the prelude of The Rust Standard Library./// The 2024 version of the prelude of The Rust Standard Library./// The Future version of the prelude of The Rust Standard Library.//! # The Rust Prelude//! Rust comes with a variety of things in its standard library. However, if//! you had to manually import every single thing that you used, it would be//! very verbose. But importing a lot of things that a program never uses isn't//! good either. A balance needs to be struck.//! The *prelude* is the list of things that Rust automatically imports into//! every Rust program. It's kept as small as possible, and is focused on//! things, particularly traits, which are used in almost every single Rust//! program.//! # Other preludes//! Preludes can be seen as a pattern to make using multiple types more//! convenient. As such, you'll find other preludes in the standard library,//! such as [`std::io::prelude`]. Various libraries in the Rust ecosystem may//! also define their own preludes.//! [`std::io::prelude`]: crate::io::prelude//! The difference between 'the prelude' and these other preludes is that they//! are not automatically `use`'d, and must be imported manually. This is still//! easier than importing all of their constituent components.//! # Prelude contents//! The items included in the prelude depend on the edition of the crate.//! The first version of the prelude is used in Rust 2015 and Rust 2018,//! and lives in [`std::prelude::v1`].//! [`std::prelude::rust_2015`] and [`std::prelude::rust_2018`] re-export this prelude.//! It re-exports the following://! * <code>[std::marker]::{[Copy], [Send], [Sized], [Sync], [Unpin]}</code>,//!   marker traits that indicate fundamental properties of types.//! * <code>[std::ops]::{[Fn], [FnMut], [FnOnce]}</code>, and their analogous//!   async traits, <code>[std::ops]::{[AsyncFn], [AsyncFnMut], [AsyncFnOnce]}</code>.//! * <code>[std::ops]::[Drop]</code>, for implementing destructors.//! * <code>[std::mem]::[drop]</code>, a convenience function for explicitly//!   dropping a value.//! * <code>[std::mem]::{[size_of], [size_of_val]}</code>, to get the size of//!   a type or value.//! * <code>[std::mem]::{[align_of], [align_of_val]}</code>, to get the//!   alignment of a type or value.//! * <code>[std::boxed]::[Box]</code>, a way to allocate values on the heap.//! * <code>[std::borrow]::[ToOwned]</code>, the conversion trait that defines//!   [`to_owned`], the generic method for creating an owned type from a//!   borrowed type.//! * <code>[std::clone]::[Clone]</code>, the ubiquitous trait that defines//!   [`clone`][Clone::clone], the method for producing a copy of a value.//! * <code>[std::cmp]::{[PartialEq], [PartialOrd], [Eq], [Ord]}</code>, the//!   comparison traits, which implement the comparison operators and are often//!   seen in trait bounds.//! * <code>[std::convert]::{[AsRef], [AsMut], [Into], [From]}</code>, generic//!   conversions, used by savvy API authors to create overloaded methods.//! * <code>[std::default]::[Default]</code>, types that have default values.//! * <code>[std::iter]::{[Iterator], [Extend], [IntoIterator], [DoubleEndedIterator], [ExactSizeIterator]}</code>,//!   iterators of various//!   kinds.//! * <code>[std::option]::[Option]::{[self][Option], [Some], [None]}</code>, a//!   type which expresses the presence or absence of a value. This type is so//!   commonly used, its variants are also exported.//! * <code>[std::result]::[Result]::{[self][Result], [Ok], [Err]}</code>, a type//!   for functions that may succeed or fail. Like [`Option`], its variants are//!   exported as well.//! * <code>[std::string]::{[String], [ToString]}</code>, heap-allocated strings.//! * <code>[std::vec]::[Vec]</code>, a growable, heap-allocated vector.//! The prelude used in Rust 2021, [`std::prelude::rust_2021`], includes all of the above,//! and in addition re-exports://! * <code>[std::convert]::{[TryFrom], [TryInto]}</code>.//! * <code>[std::iter]::[FromIterator]</code>.//! The prelude used in Rust 2024, [`std::prelude::rust_2024`], includes all of the above,//! * <code>[std::future]::{[Future], [IntoFuture]}</code>.//! [std::borrow]: crate::borrow//! [std::boxed]: crate::boxed//! [std::clone]: crate::clone//! [std::cmp]: crate::cmp//! [std::convert]: crate::convert//! [std::default]: crate::default//! [std::future]: crate::future//! [std::iter]: crate::iter//! [std::marker]: crate::marker//! [std::mem]: crate::mem//! [std::ops]: crate::ops//! [std::option]: crate::option//! [`std::prelude::v1`]: v1//! [`std::prelude::rust_2015`]: rust_2015//! [`std::prelude::rust_2018`]: rust_2018//! [`std::prelude::rust_2021`]: rust_2021//! [`std::prelude::rust_2024`]: rust_2024//! [std::result]: crate::result//! [std::slice]: crate::slice//! [std::string]: crate::string//! [std::vec]: mod@crate::vec//! [`to_owned`]: crate::borrow::ToOwned::to_owned//! [book-closures]: ../../book/ch13-01-closures.html//! [book-dtor]: ../../book/ch15-03-drop.html//! [book-enums]: ../../book/ch06-01-defining-an-enum.html//! [book-iter]: ../../book/ch13-02-iterators.html//! [Future]: crate::future::Future//! [IntoFuture]: crate::future::IntoFuture// Do not `doc(no_inline)` either.//! The first version of the prelude of The Rust Standard Library.// The file so far is equivalent to core/src/prelude/v1.rs. It is duplicated// rather than glob imported because we want docs to show these re-exports as// pointing to within `std`.// Below are the items from the alloc crate.known_commandshell_cmdsmoke_failureexit_reported_rightsignal_reported_rightstdout_worksset_current_dir_worksstdin_workschild_stdout_read_buftest_process_statustest_process_output_fail_to_starttest_process_output_outputtest_process_output_errortest_finish_oncetest_wait_with_output_onceenv_cmdtest_override_envtest_add_to_envtest_capture_env_at_spawntest_interior_nul_in_progname_is_error// Regression tests for #30858.test_interior_nul_in_arg_is_errortest_interior_nul_in_args_is_errortest_interior_nul_in_current_dir_is_errortest_interior_nul_in_env_key_is_error// Regression tests for #30862.test_interior_nul_in_env_value_is_errortest_command_implements_send_syncenv_empty// Ensure that starting a process with no environment variables works on Windows.// This will fail if the environment block is ill-formed.run_bat_script// See issue #91991run_canonical_bat_script// See issue #95178terminate_exited_process/// The handle for writing to the child's standard input (stdin), if it/// ```ignore (incomplete)/// let stdin = child.stdin.take().expect("handle present");/// functions on `child` while using `stdin`./// let stdout = child.stdout.take().expect("handle present");/// let stderr = child.stderr.take().expect("handle present");/// Representation of a running or exited child process./// This structure is used to represent and manage child processes. A child/// process is created via the [`Command`] struct, which configures the/// spawning process and can itself be constructed using a builder-style/// There is no implementation of [`Drop`] for child processes,/// so if you do not ensure the `Child` has exited then it will continue to/// run, even after the `Child` handle to the child process has gone out of/// Calling [`wait`] (or other functions that wrap around it) will make/// the parent process wait until the child has actually exited before/// continuing./// On some systems, calling [`wait`] or similar is necessary for the OS to/// release resources. A process that terminated but has not been waited on is/// still around as a "zombie". Leaving too many zombies around may exhaust/// global resources (for example process IDs)./// The standard library does *not* automatically wait on child processes (not/// even if the `Child` is dropped), it is up to the application developer to do/// so. As a consequence, dropping `Child` handles without waiting on them first/// is not recommended in long-running applications./// let mut child = Command::new("/bin/cat")///     .arg("file.txt")///     .expect("failed to execute child");/// let ecode = child.wait().expect("failed to wait on child");/// assert!(ecode.success());/// [`wait`]: Child::waitStdioPipes/// The pipes connected to a spawned process./// Used to pass pipe handles between this module and [`imp`]./// This struct is used in the [`stdin`] field on [`Child`]./// When an instance of `ChildStdin` is [dropped], the `ChildStdin`'s underlying/// file handle will be closed. If the child process was blocked on input prior/// to being dropped, it will become unblocked after dropping./// [`stdin`]: Child::stdin/// [dropped]: Drop/// This struct is used in the [`stdout`] field on [`Child`]./// When an instance of `ChildStdout` is [dropped], the `ChildStdout`'s/// underlying file handle will be closed./// [`stdout`]: Child::stdout/// A handle to a child process's stderr./// This struct is used in the [`stderr`] field on [`Child`]./// When an instance of `ChildStderr` is [dropped], the `ChildStderr`'s/// [`stderr`]: Child::stderr/// A process builder, providing fine-grained control/// over how a new process should be spawned./// A default configuration can be/// generated using `Command::new(program)`, where `program` gives a path to the/// program to be executed. Additional builder methods allow the configuration/// to be changed (for example, by adding arguments) prior to spawning:/// # if cfg!(not(all(target_vendor = "apple", not(target_os = "macos")))) {///     Command::new("cmd")///         .args(["/C", "echo hello"])///         .expect("failed to execute process")///     Command::new("sh")///         .arg("-c")///         .arg("echo hello")/// let hello = output.stdout;/// `Command` can be reused to spawn multiple processes. The builder methods/// change the command without needing to immediately spawn the process./// let mut echo_hello = Command::new("sh");/// echo_hello.arg("-c").arg("echo hello");/// let hello_1 = echo_hello.output().expect("failed to execute process");/// let hello_2 = echo_hello.output().expect("failed to execute process");/// Similarly, you can call builder methods after spawning a process and then/// spawn a new process with the modified settings./// let mut list_dir = Command::new("ls");/// // Execute `ls` in the current directory of the program./// list_dir.status().expect("process failed to execute");/// // Change `ls` to execute in the root directory./// list_dir.current_dir("/");/// // And then execute `ls` again but in the root directory./// * Inherit stdin/stdout/stderr for [`spawn`] or [`status`], but create pipes for [`output`]/// [`spawn`]: Self::spawn/// [`status`]: Self::status/// [`output`]: Self::output/// (see issue #37519)./// Note on Windows: For executable files with the .exe extension,/// it can be omitted when specifying the program for this Command./// However, if the file has a different extension,/// a filename including the extension needs to be provided,/// otherwise the file won't be found./// Command::new("sh")///     .expect("sh command failed to start");/// [`Command::new`] is only intended to accept the path of the program. If you pass a program/// path along with arguments like `Command::new("ls -l").spawn()`, it will try to search for/// `ls -l` literally. The arguments need to be passed separately, such as via [`arg`] or/// [`args`]./// Command::new("ls")///     .arg("-l") // arg passed separately///     .expect("ls command failed to start");/// [`arg`]: Self::arg/// [`args`]: Self::args/// # std::process::Command::new("sh")/// .arg("-C /path/to/repo")/// .arg("-C")/// .arg("/path/to/repo")/// [`args`]: Command::args/// Note that the argument is not passed through a shell, but given/// literally to the program. This means that shell syntax like quotes,/// escaped characters, word splitting, glob patterns, variable substitution,/// etc. have no effect./// On Windows, use caution with untrusted inputs. Most applications use the/// standard convention for decoding arguments passed to them. These are safe to/// use with `arg`. However, some applications such as `cmd.exe` and `.bat` files/// use a non-standard way of decoding arguments. They are therefore vulnerable/// to malicious input./// In the case of `cmd.exe` this is especially important because a malicious/// argument can potentially run arbitrary shell commands./// See [Windows argument splitting][windows-args] for more details/// or [`raw_arg`] for manually implementing non-standard argument encoding./// [`raw_arg`]: crate::os::windows::process::CommandExt::raw_arg/// [windows-args]: crate::process#windows-argument-splitting///     .arg("-l")///     .arg("-a")/// [`arg`]: Command::arg/// Note that the arguments are not passed through a shell, but given/// escaped characters, word splitting, glob patterns, variable substitution, etc./// have no effect.///     .args(["-l", "-a"])/// Inserts or updates an explicit environment variable mapping./// This method allows you to add an environment variable mapping to the spawned process or/// overwrite a previously set value. You can use [`Command::envs`] to set multiple environment/// variables simultaneously./// Child processes will inherit environment variables from their parent process by default./// Environment variables explicitly set using [`Command::env`] take precedence over inherited/// variables. You can disable environment variable inheritance entirely using/// [`Command::env_clear`] or for a single key using [`Command::env_remove`]./// Note that environment variable names are case-insensitive (but/// case-preserving) on Windows and case-sensitive on all other platforms.///     .env("PATH", "/bin")/// Inserts or updates multiple explicit environment variable mappings./// This method allows you to add multiple environment variable mappings to the spawned process/// or overwrite previously set values. You can use [`Command::env`] to set a single environment/// Environment variables explicitly set using [`Command::envs`] take precedence over inherited/// Note that environment variable names are case-insensitive (but case-preserving) on Windows/// Command::new("printenv")///     .stdin(Stdio::null())///     .stdout(Stdio::inherit())///     .env_clear()///     .envs(&filtered_env)///     .expect("printenv failed to start");/// Removes an explicitly set environment variable and prevents inheriting it from a parent/// This method will remove the explicit value of an environment variable set via/// [`Command::env`] or [`Command::envs`]. In addition, it will prevent the spawned child/// process from inheriting that environment variable from its parent process./// After calling [`Command::env_remove`], the value associated with its key from/// [`Command::get_envs`] will be [`None`]./// To clear all explicitly set environment variables and disable all environment variable/// inheritance, you can use [`Command::env_clear`]./// Prevent any inherited `GIT_DIR` variable from changing the target of the `git` command,/// while allowing all other variables, like `GIT_AUTHOR_NAME`./// Command::new("git")///     .arg("commit")///     .env_remove("GIT_DIR")/// Clears all explicitly set environment variables and prevents inheriting any parent process/// This method will remove all explicitly added environment variables set via [`Command::env`]/// or [`Command::envs`]. In addition, it will prevent the spawned child process from inheriting/// any environment variable from its parent process./// After calling [`Command::env_clear`], the iterator from [`Command::get_envs`] will be/// You can use [`Command::env_remove`] to clear a single mapping./// The behavior of `sort` is affected by `LANG` and `LC_*` environment variables./// Clearing the environment makes `sort`'s behavior independent of the parent processes' language./// Command::new("sort")///     .current_dir("/bin")/// [`canonicalize`]: crate::fs::canonicalize/// Configuration for the child process's standard input (stdin) handle./// Defaults to [`inherit`] when used with [`spawn`] or [`status`], and/// defaults to [`piped`] when used with [`output`]./// [`inherit`]: Stdio::inherit/// [`piped`]: Stdio::piped/// Configuration for the child process's standard output (stdout) handle.///     .stdout(Stdio::null())/// Configuration for the child process's standard error (stderr) handle.///     .stderr(Stdio::null())/// By default, stdout and stderr are captured (and used to provide the/// resulting output). Stdin is not inherited from the parent and any/// attempt by the child process to read from the stdin stream will result/// in the stream immediately closing./// let output = Command::new("/bin/cat")///     .output()?;/// println!("status: {}", output.status);/// io::stdout().write_all(&output.stdout)?;/// io::stderr().write_all(&output.stderr)?;/// assert!(output.status.success());/// # io::Result::Ok(())/// Executes a command as a child process, waiting for it to finish and/// collecting its status./// let status = Command::new("/bin/cat")///     .expect("failed to execute process");/// println!("process finished with: {status}");/// assert!(status.success());get_program/// Returns the path to the program that was given to [`Command::new`]./// let cmd = Command::new("echo");/// assert_eq!(cmd.get_program(), "echo");CommandArgs/// Returns an iterator of the arguments that will be passed to the program./// This does not include the path to the program as the first argument;/// it only includes the arguments specified with [`Command::arg`] and/// [`Command::args`]./// cmd.arg("first").arg("second");/// let args: Vec<&OsStr> = cmd.get_args().collect();/// assert_eq!(args, &["first", "second"]);get_envsCommandEnvs/// Returns an iterator of the environment variables explicitly set for the child process./// Environment variables explicitly set using [`Command::env`], [`Command::envs`], and/// [`Command::env_remove`] can be retrieved with this method./// Note that this output does not include environment variables inherited from the parent/// Each element is a tuple key/value pair `(&OsStr, Option<&OsStr>)`. A [`None`] value/// indicates its key was explicitly removed via [`Command::env_remove`]. The associated key for/// the [`None`] value will no longer inherit from its parent process./// An empty iterator can indicate that no explicit mappings were added or that/// [`Command::env_clear`] was called. After calling [`Command::env_clear`], the child process/// will not inherit any environment variables from its parent process./// cmd.env("TERM", "dumb").env_remove("TZ");/// let envs: Vec<(&OsStr, Option<&OsStr>)> = cmd.get_envs().collect();/// assert_eq!(envs, &[///     (OsStr::new("TERM"), Some(OsStr::new("dumb"))),///     (OsStr::new("TZ"), None)/// Returns the working directory for the child process./// This returns [`None`] if the working directory will not be changed./// assert_eq!(cmd.get_current_dir(), None);/// cmd.current_dir("/bin");/// assert_eq!(cmd.get_current_dir(), Some(Path::new("/bin")));get_env_clear/// Returns whether the environment will be cleared for the child process./// This returns `true` if [`Command::env_clear`] was called, and `false` otherwise./// When `true`, the child process will not inherit any environment variables from/// its parent process./// #![feature(command_resolved_envs)]/// assert_eq!(cmd.get_env_clear(), false);/// assert_eq!(cmd.get_env_clear(), true);/// Format the program and arguments of a Command for display. Any/// non-utf8 data is lossily converted using the utf8 replacement/// The default format approximates a shell invocation of the program along with its/// arguments. It does not include most of the other command properties. The output is not guaranteed to work/// (e.g. due to lack of shell-escaping or differences in path resolution)./// On some platforms you can use [the alternate syntax] to show more fields./// Note that the debug implementation is platform-specific./// [the alternate syntax]: fmt#sign0/// An iterator over the command arguments./// This struct is created by [`Command::get_args`]. See its documentation for/// An iterator over the command environment variables./// [`Command::get_envs`][crate::process::Command::get_envs]. See its/// The status (exit code) of the process./// The data that the process wrote to stdout./// The data that the process wrote to stderr./// The output of a finished process./// This is returned in a Result by either the [`output`] method of a/// [`Command`], or the [`wait_with_output`] method of a [`Child`]/// [`output`]: Command::output/// [`wait_with_output`]: Child::wait_with_outputexit_ok/// Returns an error if a nonzero exit status was received./// If the [`Command`] exited successfully,/// `self` is returned./// This is equivalent to calling [`exit_ok`](ExitStatus::exit_ok)/// on [`Output.status`](Output::status)./// Note that this will throw away the [`Output::stderr`] field in the error case./// If the child process outputs useful informantion to stderr, you can:/// * Use `cmd.stderr(Stdio::inherit())` to forward the///   stderr child process to the parent's stderr,///   usually printing it to console where the user can see it.///   This is usually correct for command-line applications./// * Capture `stderr` using a custom error type.///   This is usually correct for libraries./// #![feature(exit_status_error)]/// # #[cfg(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos")))))] {/// assert!(Command::new("false").output().unwrap().exit_ok().is_err());// If either stderr or stdout are valid utf8 strings it prints the valid// strings, otherwise it prints the byte sequence instead/// Describes what to do with a standard I/O stream for a child process when/// passed to the [`stdin`], [`stdout`], and [`stderr`] methods of [`Command`]./// [`stdin`]: Command::stdin/// [`stdout`]: Command::stdout/// [`stderr`]: Command::stderrpiped/// A new pipe should be arranged to connect the parent and child processes./// With stdout:/// let output = Command::new("echo")///     .expect("Failed to execute command");/// assert_eq!(String::from_utf8_lossy(&output.stdout), "Hello, world!\n");/// // Nothing echoed to console/// With stdin:/// let mut child = Command::new("rev")///     .expect("Failed to spawn child process");/// let mut stdin = child.stdin.take().expect("Failed to open stdin");///     stdin.write_all("Hello, world!".as_bytes()).expect("Failed to write to stdin");/// let output = child.wait_with_output().expect("Failed to read stdout");/// assert_eq!(String::from_utf8_lossy(&output.stdout), "!dlrow ,olleH");/// Writing more than a pipe buffer's worth of input to stdin without also reading/// stdout and stderr at the same time may cause a deadlock./// This is an issue when running any program that doesn't guarantee that it reads/// its entire stdin before writing more than a pipe buffer's worth of output./// The size of a pipe buffer varies on different targets./// The child inherits from the corresponding parent descriptor./// assert_eq!(String::from_utf8_lossy(&output.stdout), "");/// // "Hello, world!" echoed to console/// let output = Command::new("rev")///     .stdin(Stdio::inherit())/// print!("You piped in the reverse of: ");/// This stream will be ignored. This is the equivalent of attaching the/// stream to `/dev/null`./// // Ignores any piped-in inputmakes_pipe/// Returns `true` if this requires [`Command`] to create a new pipe./// #![feature(stdio_makes_pipe)]/// let io = Stdio::piped();/// assert_eq!(io.makes_pipe(), true);/// Converts a [`ChildStdin`] into a [`Stdio`]./// `ChildStdin` will be converted to `Stdio` using `Stdio::from` under the hood./// let reverse = Command::new("rev")///     .expect("failed reverse command");/// let _echo = Command::new("echo")///     .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here///     .expect("failed echo command");/// // "!dlrow ,olleH" echoed to console/// Converts a [`ChildStdout`] into a [`Stdio`]./// `ChildStdout` will be converted to `Stdio` using `Stdio::from` under the hood./// let hello = Command::new("echo")///     .stdin(hello.stdout.unwrap())  // Converted into a Stdio here/// assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");/// Converts a [`ChildStderr`] into a [`Stdio`].///     .arg("non_existing_file.txt")/// let cat = Command::new("cat")///     .arg("-")///     .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here///     String::from_utf8_lossy(&cat.stdout),///     "rev: cannot open non_existing_file.txt: No such file or directory\n"/// Converts a [`File`](fs::File) into a [`Stdio`]./// `File` will be converted to `Stdio` using `Stdio::from` under the hood./// // With the `foo.txt` file containing "Hello, world!"/// let file = File::open("foo.txt")?;///     .stdin(file)  // Implicit File conversion into a Stdio/// assert_eq!(reverse.stdout, b"!dlrow ,olleH");/// Redirect command stdout/stderr to our stdout/// # fn test() -> Result<(), Box<dyn std::error::Error>> {/// let output = Command::new("whoami")// "whoami" is a command which exists on both Unix and Windows,// and which succeeds, producing some stdout output but no stderr.///     .stdout(io::stdout())/// output.status.exit_ok()?;/// assert!(output.stdout.is_empty());/// # if cfg!(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos"))))) {/// #     test().unwrap();/// Redirect command stdout/stderr to our stderr///     .stdout(io::stderr())/// Describes the result of a process after it has terminated./// This `struct` is used to represent the exit status or other termination of a child process./// Child processes are created via the [`Command`] struct and their exit/// status is exposed through the [`status`] method, or the [`wait`] method/// of a [`Child`] process./// An `ExitStatus` represents every possible disposition of a process.  On Unix this/// is the **wait status**.  It is *not* simply an *exit status* (a value passed to `exit`)./// For proper error reporting of failed processes, print the value of `ExitStatus` or/// `ExitStatusError` using their implementations of [`Display`](crate::fmt::Display)./// # Differences from `ExitCode`/// [`ExitCode`] is intended for terminating the currently running process, via/// the `Termination` trait, in contrast to `ExitStatus`, which represents the/// termination of a child process. These APIs are separate due to platform/// compatibility differences and their expected usage; it is not generally/// possible to exactly reproduce an `ExitStatus` from a child for the current/// process after the fact./// [`status`]: Command::status// We speak slightly loosely (here and in various other places in the stdlib docs) about `exit`// vs `_exit`.  Naming of Unix system calls is not standardised across Unices, so terminology is a// matter of convention and tradition.  For clarity we usually speak of `exit`, even when we might// mean an underlying system call such as `_exit`./// The default value is one which indicates successful completion./// Was termination successful?  Returns a `Result`./// # if cfg!(all(unix, not(all(target_vendor = "apple", not(target_os = "macos"))))) {/// let status = Command::new("ls")///     .arg("/dev/nonexistent")///     .expect("ls could not be executed");/// println!("ls: {status}");/// status.exit_ok().expect_err("/dev/nonexistent could be listed!");/// # } // cfg!(unix)/// Was termination successful? Signal termination is not considered a/// success, and success is defined as a zero exit status./// let status = Command::new("mkdir")///     .arg("projects")///     .expect("failed to execute mkdir");/// if status.success() {///     println!("'projects/' directory created");///     println!("failed to create 'projects/' directory: {status}");/// Returns the exit code of the process, if any./// In Unix terms the return value is the **exit status**: the value passed to `exit`, if the/// process finished by calling `exit`.  Note that on Unix the exit status is truncated to 8/// bits, and that values that didn't come from a program's call to `exit` may be invented by the/// runtime system (often, for example, 255, 254, 127 or 126)./// On Unix, this will return `None` if the process was terminated by a signal./// [`ExitStatusExt`](crate::os::unix::process::ExitStatusExt) is an/// extension trait for extracting any such signal, and other details, from the `ExitStatus`./// match status.code() {///     Some(code) => println!("Exited with status code: {code}"),///     None => println!("Process terminated by signal")/// Describes the result of a process after it has failed/// Produced by the [`.exit_ok`](ExitStatus::exit_ok) method on [`ExitStatus`]./// use std::process::{Command, ExitStatusError};/// fn run(cmd: &str) -> Result<(), ExitStatusError> {///     Command::new(cmd).status().unwrap().exit_ok()?;/// run("true").unwrap();/// run("false").unwrap_err();// The definition of imp::ExitStatusError should ideally be such that// Result<(), imp::ExitStatusError> has an identical representation to imp::ExitStatus./// Reports the exit code, if applicable, from an `ExitStatusError`./// On Unix, this will return `None` if the process was terminated by a signal.  If you want to/// handle such situations specially, consider using methods from/// [`ExitStatusExt`](crate::os::unix::process::ExitStatusExt)./// If the process finished by calling `exit` with a nonzero value, this will return/// that exit status./// If the error was something else, it will return `None`./// If the process exited successfully (ie, by calling `exit(0)`), there is no/// `ExitStatusError`.  So the return value from `ExitStatusError::code()` is always nonzero./// let bad = Command::new("false").status().unwrap().exit_ok().unwrap_err();/// assert_eq!(bad.code(), Some(1));/// # } // #[cfg(unix)]code_nonzero/// Reports the exit code, if applicable, from an `ExitStatusError`, as a [`NonZero`]./// This is exactly like [`code()`](Self::code), except that it returns a <code>[NonZero]<[i32]></code>./// Plain `code`, returning a plain integer, is provided because it is often more convenient./// The returned value from `code()` is indeed also nonzero; use `code_nonzero()` when you want/// a type-level guarantee of nonzeroness./// assert_eq!(bad.code_nonzero().unwrap(), NonZero::new(1).unwrap());into_status/// Converts an `ExitStatusError` (back) to an `ExitStatus`./// This type represents the status code the current process can return/// to its parent under normal termination./// `ExitCode` is intended to be consumed only by the standard library (via/// [`Termination::report()`]). For forwards compatibility with potentially/// unusual targets, this type currently does not provide `Eq`, `Hash`, or/// access to the raw value. This type does provide `PartialEq` for/// comparison, but note that there may potentially be multiple failure/// codes, some of which will _not_ compare equal to `ExitCode::FAILURE`./// The standard library provides the canonical `SUCCESS` and `FAILURE`/// exit codes as well as `From<u8> for ExitCode` for constructing other/// arbitrary exit codes./// Numeric values used in this type don't have portable meanings, and/// different platforms may mask different amounts of them./// For the platform's canonical successful and unsuccessful codes, see/// the [`SUCCESS`] and [`FAILURE`] associated items./// [`SUCCESS`]: ExitCode::SUCCESS/// [`FAILURE`]: ExitCode::FAILURE/// # Differences from `ExitStatus`/// `ExitCode` is intended for terminating the currently running process, via/// the `Termination` trait, in contrast to [`ExitStatus`], which represents the/// `ExitCode` can be returned from the `main` function of a crate, as it implements/// [`Termination`]:/// use std::process::ExitCode;/// # fn check_foo() -> bool { true }/// fn main() -> ExitCode {///     if !check_foo() {///         return ExitCode::from(42);///     ExitCode::SUCCESS/// The canonical `ExitCode` for successful termination on this platform./// Note that a `()`-returning `main` implicitly results in a successful/// termination, so there's no need to return this from `main` unless/// you're also returning other possible codes./// The canonical `ExitCode` for unsuccessful termination on this platform./// If you're only returning this and `SUCCESS` from `main`, consider/// instead returning `Err(_)` and `Ok(())` respectively, which will/// return the same codes (but will also `eprintln!` the error).exit_process/// Exit the current process with the given `ExitCode`./// Note that this has the same caveats as [`process::exit()`][exit], namely that this function/// terminates the process immediately, so no destructors on the current stack or any other/// thread's stack will be run. Also see those docs for some important notes on interop with C/// code. If a clean shutdown is needed, it is recommended to simply return this ExitCode from/// the `main` function, as demonstrated in the [type documentation](#examples)./// # Differences from `process::exit()`/// `process::exit()` accepts any `i32` value as the exit code for the process; however, there/// are platforms that only use a subset of that value (see [`process::exit` platform-specific/// behavior][exit#platform-specific-behavior]). `ExitCode` exists because of this; only/// `ExitCode`s that are supported by a majority of our platforms can be created, so those/// problems don't exist (as much) with this method./// #![feature(exitcode_exit_method)]/// # use std::process::ExitCode;/// # enum UhOhError { GenericProblem, Specific, WithCode { exit_code: ExitCode, _x: () } }/// # impl fmt::Display for UhOhError {/// #     fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result { unimplemented!() }/// // there's no way to gracefully recover from an UhOhError, so we just/// // print a message and exit/// fn handle_unrecoverable_error(err: UhOhError) -> ! {///     eprintln!("UH OH! {err}");///     let code = match err {///         UhOhError::GenericProblem => ExitCode::FAILURE,///         UhOhError::Specific => ExitCode::from(3),///         UhOhError::WithCode { exit_code, .. } => exit_code,///     code.exit_process()// This is private/perma-unstable because ExitCode is opaque; we don't know that i32 will serve// all usecases, for example windows seems to use u32, unix uses the 8-15th bits of an i32, we// likely want to isolate users anything that could restrict the platform specific// representation of an ExitCode// More info: https://internals.rust-lang.org/t/mini-pre-rfc-redesigning-process-exitstatus/5426/// Converts an `ExitCode` into an i32/// The default value is [`ExitCode::SUCCESS`]/// Constructs an `ExitCode` from an arbitrary u8 value./// Forces the child process to exit. If the child has already exited, `Ok(())`/// The mapping to [`ErrorKind`]s is not part of the compatibility contract of the function./// let mut command = Command::new("yes");/// if let Ok(mut child) = command.spawn() {///     child.kill().expect("command couldn't be killed");///     println!("yes command didn't start");/// [`ErrorKind`]: io::ErrorKind/// let mut command = Command::new("ls");/// if let Ok(child) = command.spawn() {///     println!("Child's ID is {}", child.id());///     println!("ls command didn't start");///     child.wait().expect("command wasn't running");///     println!("Child has finished its execution!");/// Note that unlike `wait`, this function will not attempt to drop stdin./// match child.try_wait() {///     Ok(Some(status)) => println!("exited with: {status}"),///     Ok(None) => {///         println!("status not ready yet, let's really wait");///         let res = child.wait();///         println!("result: {res:?}");///     Err(e) => println!("error attempting to wait: {e}"),/// Simultaneously waits for the child to exit and collect all remaining/// output on the stdout/stderr handles, returning an `Output`/// In order to capture the output into this `Result<Output>` it is/// necessary to create new pipes between parent and child. Use/// `stdout(Stdio::piped())` or `stderr(Stdio::piped())`, respectively./// let child = Command::new("/bin/cat")/// let output = child///     .wait_with_output()///     .expect("failed to wait on child");/// Terminates the current process with the specified exit code./// This function will never return and will immediately terminate the current/// process. The exit code is passed through to the underlying OS and will be/// available for consumption by another process./// Note that because this function never returns, and that it terminates the/// process, no destructors on the current stack or any other thread's stack/// will be run. If a clean shutdown is needed it is recommended to only call/// this function at a known point where there are no more destructors left/// to run; or, preferably, simply return a type implementing [`Termination`]/// (such as [`ExitCode`] or `Result`) from the `main` function and avoid this/// function altogether:/// # use std::io::Error as MyError;/// fn main() -> Result<(), MyError> {/// In its current implementation, this function will execute exit handlers registered with `atexit`/// as well as other platform-specific exit handlers (e.g. `fini` sections of ELF shared objects)./// This means that Rust requires that all exit handlers are safe to execute at any time. In/// particular, if an exit handler cleans up some state that might be concurrently accessed by other/// threads, it is required that the exit handler performs suitable synchronization with those/// threads. (The alternative to this requirement would be to not run exit handlers at all, which is/// considered undesirable. Note that returning from `main` also calls `exit`, so making `exit` an/// unsafe operation is not an option.)/// ## Platform-specific behavior/// **Unix**: On Unix-like platforms, it is unlikely that all 32 bits of `exit`/// will be visible to a parent process inspecting the exit code. On most/// Unix-like platforms, only the eight least-significant bits are considered./// For example, the exit code for this example will be `0` on Linux, but `256`/// on Windows:/// process::exit(0x0100);/// ### Safe interop with C code/// On Unix, this function is currently implemented using the `exit` C function [`exit`][C-exit]. As/// of C23, the C standard does not permit multiple threads to call `exit` concurrently. Rust/// mitigates this with a lock, but if C code calls `exit`, that can still cause undefined behavior./// Note that returning from `main` is equivalent to calling `exit`./// Therefore, it is undefined behavior to have two concurrent threads perform the following/// without synchronization:/// - One thread calls Rust's `exit` function or returns from Rust's `main` function/// - Another thread calls the C function `exit` or `quick_exit`, or returns from C's `main` function/// Note that if a binary contains multiple copies of the Rust runtime (e.g., when combining/// multiple `cdylib` or `staticlib`), they each have their own separate lock, so from the/// perspective of code running in one of the Rust runtimes, the "outside" Rust code is basically C/// code, and concurrent `exit` again causes undefined behavior./// Individual C implementations might provide more guarantees than the standard and permit concurrent/// calls to `exit`; consult the documentation of your C implementation for details./// For some of the on-going discussion to make `exit` thread-safe in C, see:/// - [Rust issue #126600](https://github.com/rust-lang/rust/issues/126600)/// - [Austin Group Bugzilla (for POSIX)](https://austingroupbugs.net/view.php?id=1845)/// - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=31997)/// [C-exit]: https://en.cppreference.com/w/c/program/exit/// Terminates the process in an abnormal fashion./// The function will never return and will immediately terminate the current/// process in a platform specific "abnormal" manner. As a consequence,/// no destructors on the current stack or any other thread's stack/// will be run, Rust IO buffers (eg, from `BufWriter`) will not be flushed,/// and C stdio buffers will (on most platforms) not be flushed./// This is in contrast to the default behavior of [`panic!`] which unwinds/// the current thread's stack and calls all destructors./// When `panic="abort"` is set, either as an argument to `rustc` or in a/// crate's Cargo.toml, [`panic!`] and `abort` are similar. However,/// [`panic!`] will still call the [panic hook] while `abort` will not./// If a clean shutdown is needed it is recommended to only call/// to run./// The process's termination will be similar to that from the C `abort()`/// function.  On Unix, the process will terminate with signal `SIGABRT`, which/// typically means that the shell prints "Aborted".///     println!("aborting");///     process::abort();///     // execution never gets here/// The `abort` function terminates the process, so the destructor will not/// get run on the example below:///         println!("This will never be printed!");///     let _x = HasDrop;///     // the destructor implemented for HasDrop will never get run/// [panic hook]: crate::panic::set_hook/// Returns the OS-assigned process identifier associated with this process./// println!("My pid is {}", process::id());/// Is called to get the representation of the value as status code./// This status code is returned to the operating system./// A trait for implementing arbitrary return types in the `main` function./// The C-main function only supports returning integers./// So, every type implementing the `Termination` trait has to be converted/// to an integer./// The default implementations are returning `libc::EXIT_SUCCESS` to indicate/// a successful execution. In case of a failure, `libc::EXIT_FAILURE` is returned./// Because different runtimes have different specifications on the return value/// of the `main` function, this trait is likely to be available only on/// standard library's runtime for convenience. Other runtimes are not required/// to provide similar functionality.//! A module for working with processes.//! This module is mostly concerned with spawning and interacting with child//! processes, but it also provides [`abort`] and [`exit`] for terminating the//! current process.//! # Spawning a process//! The [`Command`] struct is used to configure and spawn processes://! let output = Command::new("echo")//!     .arg("Hello world")//!     .output()//!     .expect("Failed to execute command");//! assert_eq!(b"Hello world\n", output.stdout.as_slice());//! Several methods on [`Command`], such as [`spawn`] or [`output`], can be used//! to spawn a process. In particular, [`output`] spawns the child process and//! waits until the process terminates, while [`spawn`] will return a [`Child`]//! that represents the spawned child process.//! # Handling I/O//! The [`stdout`], [`stdin`], and [`stderr`] of a child process can be//! configured by passing an [`Stdio`] to the corresponding method on//! [`Command`]. Once spawned, they can be accessed from the [`Child`]. For//! example, piping output from one command into another command can be done//! like so://! use std::process::{Command, Stdio};//! // stdout must be configured with `Stdio::piped` in order to use//! // `echo_child.stdout`//! let echo_child = Command::new("echo")//!     .arg("Oh no, a tpyo!")//!     .spawn()//!     .expect("Failed to start echo process");//! // Note that `echo_child` is moved here, but we won't be needing//! // `echo_child` anymore//! let echo_out = echo_child.stdout.expect("Failed to open echo stdout");//! let mut sed_child = Command::new("sed")//!     .arg("s/tpyo/typo/")//!     .stdin(Stdio::from(echo_out))//!     .expect("Failed to start sed process");//! let output = sed_child.wait_with_output().expect("Failed to wait on sed");//! assert_eq!(b"Oh no, a typo!\n", output.stdout.as_slice());//! Note that [`ChildStderr`] and [`ChildStdout`] implement [`Read`] and//! [`ChildStdin`] implements [`Write`]://! let mut child = Command::new("/bin/cat")//!     .stdin(Stdio::piped())//!     .expect("failed to execute child");//! // If the child process fills its stdout buffer, it may end up//! // waiting until the parent reads the stdout, and not be able to//! // read stdin in the meantime, causing a deadlock.//! // Writing from another thread ensures that stdout is being read//! // at the same time, avoiding the problem.//! let mut stdin = child.stdin.take().expect("failed to get stdin");//! std::thread::spawn(move || {//!     stdin.write_all(b"test").expect("failed to write to stdin");//! let output = child//!     .wait_with_output()//!     .expect("failed to wait on child");//! assert_eq!(b"test", output.stdout.as_slice());//! # Windows argument splitting//! On Unix systems arguments are passed to a new process as an array of strings,//! but on Windows arguments are passed as a single commandline string and it is//! up to the child process to parse it into an array. Therefore the parent and//! child processes must agree on how the commandline string is encoded.//! Most programs use the standard C run-time `argv`, which in practice results//! in consistent argument handling. However, some programs have their own way of//! parsing the commandline string. In these cases using [`arg`] or [`args`] may//! result in the child process seeing a different array of arguments than the//! parent process intended.//! Two ways of mitigating this are://! * Validate untrusted input so that only a safe subset is allowed.//! * Use [`raw_arg`] to build a custom commandline. This bypasses the escaping//!   rules used by [`arg`] so should be used with due caution.//! `cmd.exe` and `.bat` files use non-standard argument parsing and are especially//! vulnerable to malicious input as they may be used to run arbitrary shell//! commands. Untrusted arguments should be restricted as much as possible.//! For examples on handling this see [`raw_arg`].//! ### Batch file special handling//! On Windows, `Command` uses the Windows API function [`CreateProcessW`] to//! spawn new processes. An undocumented feature of this function is that//! when given a `.bat` file as the application to run, it will automatically//! convert that into running `cmd.exe /c` with the batch file as the next argument.//! For historical reasons Rust currently preserves this behavior when using//! [`Command::new`], and escapes the arguments according to `cmd.exe` rules.//! Due to the complexity of `cmd.exe` argument handling, it might not be//! possible to safely escape some special characters, and using them will result//! in an error being returned at process spawn. The set of unescapeable//! special characters might change between releases.//! Also note that running batch scripts in this way may be removed in the//! future and so should not be relied upon.//! [`spawn`]: Command::spawn//! [`output`]: Command::output//! [`stdout`]: Command::stdout//! [`stdin`]: Command::stdin//! [`stderr`]: Command::stderr//! [`Write`]: io::Write//! [`Read`]: io::Read//! [`arg`]: Command::arg//! [`args`]: Command::args//! [`raw_arg`]: crate::os::windows::process::CommandExt::raw_arg//! [`CreateProcessW`]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw// In addition to the `impl`s here, `ChildStdin` also has `impl`s for// In addition to the `impl`s here, `ChildStdout` also has `impl`s for// In addition to the `impl`s here, `ChildStderr` also has `impl`s for/// The default random source./// This asks the system for random data suitable for cryptographic purposes/// such as key generation. If security is a concern, consult the platform/// documentation below for the specific guarantees your target provides./// The high quality of randomness provided by this source means it can be quite/// slow on some targets. If you need a large quantity of random numbers and/// security is not a concern,  consider using an alternative random number/// generator (potentially seeded from this one)./// # Underlying sources/// Platform               | Source/// -----------------------|---------------------------------------------------------------/// Linux                  | [`getrandom`] or [`/dev/urandom`] after polling `/dev/random`/// Windows                | [`ProcessPrng`](https://learn.microsoft.com/en-us/windows/win32/seccng/processprng)/// Apple                  | `CCRandomGenerateBytes`/// DragonFly              | [`arc4random_buf`](https://man.dragonflybsd.org/?command=arc4random)/// ESP-IDF                | [`esp_fill_random`](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/random.html#_CPPv415esp_fill_randomPv6size_t)/// FreeBSD                | [`arc4random_buf`](https://man.freebsd.org/cgi/man.cgi?query=arc4random)/// Fuchsia                | [`cprng_draw`](https://fuchsia.dev/reference/syscalls/cprng_draw)/// Haiku                  | `arc4random_buf`/// Illumos                | [`arc4random_buf`](https://www.illumos.org/man/3C/arc4random)/// NetBSD                 | [`arc4random_buf`](https://man.netbsd.org/arc4random.3)/// OpenBSD                | [`arc4random_buf`](https://man.openbsd.org/arc4random.3)/// Solaris                | [`arc4random_buf`](https://docs.oracle.com/cd/E88353_01/html/E37843/arc4random-3c.html)/// Vita                   | `arc4random_buf`/// Hermit                 | `read_entropy`/// Horizon, Cygwin        | `getrandom`/// AIX, Hurd, L4Re, QNX   | `/dev/urandom`/// Redox                  | `/scheme/rand`/// RTEMS                  | [`arc4random_buf`](https://docs.rtems.org/branches/master/bsp-howto/getentropy.html)/// SGX                    | [`rdrand`](https://en.wikipedia.org/wiki/RDRAND)/// SOLID                  | `SOLID_RNG_SampleRandomBytes`/// TEEOS                  | `TEE_GenerateRandom`/// UEFI                   | [`EFI_RNG_PROTOCOL`](https://uefi.org/specs/UEFI/2.10/37_Secure_Technologies.html#random-number-generator-protocol)/// VxWorks                | `randABytes` after waiting for `randSecure` to become ready/// WASI                   | [`random_get`](https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#-random_getbuf-pointeru8-buf_len-size---result-errno)/// ZKVM                   | `sys_rand`/// Note that the sources used might change over time./// Consult the documentation for the underlying operations on your supported/// targets to determine whether they provide any particular desired properties,/// such as support for reseeding on VM fork operations./// [`getrandom`]: https://www.man7.org/linux/man-pages/man2/getrandom.2.html/// [`/dev/urandom`]: https://www.man7.org/linux/man-pages/man4/random.4.html/// Generates a random value from a distribution, using the default random source./// This is a convenience function for `dist.sample(&mut DefaultRandomSource)` and will sample/// according to the same distribution as the underlying [`Distribution`] trait implementation. See/// [`DefaultRandomSource`] for more information about how randomness is sourced./// Generating a [version 4/variant 1 UUID] represented as text:/// #![feature(random)]/// use std::random::random;/// let bits: u128 = random(..);/// let g1 = (bits >> 96) as u32;/// let g2 = (bits >> 80) as u16;/// let g3 = (0x4000 | (bits >> 64) & 0x0fff) as u16;/// let g4 = (0x8000 | (bits >> 48) & 0x3fff) as u16;/// let g5 = (bits & 0xffffffffffff) as u64;/// let uuid = format!("{g1:08x}-{g2:04x}-{g3:04x}-{g4:04x}-{g5:012x}");/// println!("{uuid}");/// [version 4/variant 1 UUID]: https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)// This function is needed by the panic runtime.rtprintpanic// Prints to the "panic output", depending on the platform this may be:// - the standard error output// - some dedicated platform specific output// - nothing (so this macro is a no-op)rtabortrtassertrtunwraphandle_rt_panic// One-time runtime initialization.// Runs before `main`.// SAFETY: must be called only once during runtime initialization.// NOTE: this is not guaranteed to run, for example when Rust code is called externally.// # The `sigpipe` parameter// Since 2014, the Rust runtime on Unix has set the `SIGPIPE` handler to// `SIG_IGN`. Applications have good reasons to want a different behavior// though, so there is a `-Zon-broken-pipe` compiler flag that// can be used to select how `SIGPIPE` shall be setup (if changed at all) before// `fn main()` is called. See <https://github.com/rust-lang/rust/issues/97889>// for more info.// The `sigpipe` parameter to this function gets its value via the code that// rustc generates to invoke `fn lang_start()`. The reason we have `sigpipe` for// all platforms and not only Unix, is because std is not allowed to have `cfg`// directives as this high level. See the module docs in// `src/tools/tidy/src/pal.rs` for more info. On all other platforms, `sigpipe`// has a value, but its value is ignored.// Even though it is an `u8`, it only ever has 4 values. These are documented in// `compiler/rustc_session/src/config/sigpipe.rs`.thread_cleanup/// Clean up the thread-local runtime state. This *should* be run after all other/// code managed by the Rust runtime, but will not cause UB if that condition is/// not fulfilled. Also note that this function is not guaranteed to be run, but/// skipping it will cause leaks and therefore is to be avoided.// One-time runtime cleanup.// Runs after `main` or at program exit.// NOTE: this is not guaranteed to run, for example when the program aborts.lang_start_internal// To reduce the generated code of the new `lang_start`, this function is doing// the real work."start"lang_start//! Runtime services//! The `rt` module provides a narrow set of runtime services,//! including the global heap (exported in `heap`) and unwinding and//! backtrace support. The APIs in this module are highly unstable,//! and should be considered as private implementation details for the//! time being./// let n = 10;/// let barrier = Barrier::new(n);///     for _ in 0..n {///         // You will NOT see any interleaving.///         s.spawn(|| {///             barrier.wait();/// A barrier will block all threads which call [`wait()`] until the `n`th thread calls [`wait()`],/// and then wake up all threads at once.OnceExclusiveState// We use the state of a Once as discriminant value. Upon creation, the state is// "incomplete" and `f` contains the initialization closure. In the first call to// `call_once`, `f` is taken and run. If it succeeds, `value` is set and the state// is changed to "complete". If it panics, the Once is poisoned, so none of the// two fields is initialized.// FIXME(nonpoison_once): if possible, switch to nonpoison version once it is available/// This type is a thread-safe [`LazyCell`], and can be used in statics./// Since initialization may be called from multiple threads, any/// dereferencing call will block the calling thread if another/// initialization routine is currently running./// [`LazyCell`]: crate::cell::LazyCell/// If the initialization closure passed to [`LazyLock::new`] panics, the lock will be poisoned./// Once the lock is poisoned, any threads that attempt to access this lock (via a dereference/// difference, however, is that poisoning in `LazyLock` is _unrecoverable_. All future accesses of/// the lock from other threads will panic, whereas a type in [`std::sync::poison`] like/// [`force()`]: LazyLock::force/// [`std::sync::poison`]: crate::sync::poison/// [`std::sync::poison::Mutex`]: crate::sync::poison::Mutex/// [`PoisonError::into_inner()`]: crate::sync::poison::PoisonError::into_inner/// Initialize static variables with `LazyLock`./// use std::sync::LazyLock;/// // Note: static items do not call [`Drop`] on program termination, so this won't be deallocated./// // this is fine, as the OS can deallocate the terminated program faster than we can free memory/// // but tools like valgrind might report "memory leaks" as it isn't obvious this is intentional./// static DEEP_THOUGHT: LazyLock<String> = LazyLock::new(|| {/// # mod another_crate {/// #     pub fn great_question() -> String { "42".to_string() }///     // M3 Ultra takes about 16 million years in --release config///     another_crate::great_question()/// // The `String` is built, stored in the `LazyLock`, and returned as `&String`./// let _ = &*DEEP_THOUGHT;/// Initialize fields with `LazyLock`./// struct UseCellLock {///     number: LazyLock<u32>,///     let lock: LazyLock<u32> = LazyLock::new(|| 0u32);///     let data = UseCellLock { number: lock };///     println!("{}", *data.number);/// let lazy = LazyLock::new(|| hello.to_uppercase());/// Consumes this `LazyLock` returning the stored value./// Panics if the lock is poisoned./// assert_eq!(LazyLock::into_inner(lazy).ok(), Some("HELLO, WORLD!".to_string()));/// panic is propagated to the caller, and the lock becomes poisoned. This will cause all future/// accesses of the lock (via [`force()`] or a dereference) to panic./// [`new()`]: LazyLock::new/// let mut lazy = LazyLock::new(|| 92);/// let p = LazyLock::force_mut(&mut lazy);/// result. This is equivalent to the `Deref` impl, but is explicit./// let lazy = LazyLock::new(|| 92);/// assert_eq!(LazyLock::force(&lazy), &92);/// assert_eq!(LazyLock::get_mut(&mut lazy), None);/// let _ = LazyLock::force(&lazy);/// *LazyLock::get_mut(&mut lazy).unwrap() = 44;/// assert_eq!(LazyLock::get(&lazy), None);/// assert_eq!(LazyLock::get(&lazy), Some(&92));// We never create a `&F` from a `&LazyLock<T, F>` so it is fine// to not impl `Sync` for `F`.// These come from `core` & `alloc` and only in one flavor: no poisoning.mpmclazy_lockreentrant_lock// These exist only in one flavor: no poisoning.// These exist only with poisoning.// These exist in both flavors: with and without poisoning.// The historical default is the version with poisoning./// It is returned by the [`wait_timeout`] method./// [`wait_timeout`]: Condvar::wait_timeout/// Returns `true` if the wait was known to have timed out./// This example spawns a thread which will sleep 20 milliseconds before/// updating a boolean value and then notifying the condvar./// The main thread will wait with a 10 millisecond timeout on the condvar/// and will leave the loop upon timeout./// use std::sync::{Arc, Condvar, Mutex};/// let pair2 = Arc::clone(&pair);///     let (lock, cvar) = &*pair2;///     // Let's wait 20 milliseconds before notifying the condvar.///     thread::sleep(Duration::from_millis(20));///     let mut started = lock.lock().unwrap();///     // We update the boolean value./// // Wait for the thread to start up./// let (lock, cvar) = &*pair;///     // Let's put a timeout on the condvar's wait.///     let result = cvar.wait_timeout(lock.lock().unwrap(), Duration::from_millis(10)).unwrap();///     // 10 milliseconds have passed.///     if result.1.timed_out() {///         // timed out now and we can leave.///         break/// # let _ = handle.join();//! Useful synchronization primitives.//! ## The need for synchronization//! Conceptually, a Rust program is a series of operations which will//! be executed on a computer. The timeline of events happening in the//! program is consistent with the order of the operations in the code.//! Consider the following code, operating on some global static variables://! // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint//! #![allow(static_mut_refs)]//! static mut A: u32 = 0;//! static mut B: u32 = 0;//! static mut C: u32 = 0;//!         A = 3;//!         B = 4;//!         A = A + B;//!         C = B;//!         println!("{A} {B} {C}");//!         C = A;//! It appears as if some variables stored in memory are changed, an addition//! is performed, result is stored in `A` and the variable `C` is//! modified twice.//! When only a single thread is involved, the results are as expected://! the line `7 4 4` gets printed.//! As for what happens behind the scenes, when optimizations are enabled the//! final generated machine code might look very different from the code://! - The first store to `C` might be moved before the store to `A` or `B`,//!   _as if_ we had written `C = 4; A = 3; B = 4`.//! - Assignment of `A + B` to `A` might be removed, since the sum can be stored//!   in a temporary location until it gets printed, with the global variable//!   never getting updated.//! - The final result could be determined just by looking at the code//!   at compile time, so [constant folding] might turn the whole//!   block into a simple `println!("7 4 4")`.//! The compiler is allowed to perform any combination of these//! optimizations, as long as the final optimized code, when executed,//! produces the same results as the one without optimizations.//! Due to the [concurrency] involved in modern computers, assumptions//! about the program's execution order are often wrong. Access to//! global variables can lead to nondeterministic results, **even if**//! compiler optimizations are disabled, and it is **still possible**//! to introduce synchronization bugs.//! Note that thanks to Rust's safety guarantees, accessing global (static)//! variables requires `unsafe` code, assuming we don't use any of the//! synchronization primitives in this module.//! [constant folding]: https://en.wikipedia.org/wiki/Constant_folding//! [concurrency]: https://en.wikipedia.org/wiki/Concurrency_(computer_science)//! ## Out-of-order execution//! Instructions can execute in a different order from the one we define, due to//! various reasons://! - The **compiler** reordering instructions: If the compiler can issue an//!   instruction at an earlier point, it will try to do so. For example, it//!   might hoist memory loads at the top of a code block, so that the CPU can//!   start [prefetching] the values from memory.//!   In single-threaded scenarios, this can cause issues when writing//!   signal handlers or certain kinds of low-level code.//!   Use [compiler fences] to prevent this reordering.//! - A **single processor** executing instructions [out-of-order]://!   Modern CPUs are capable of [superscalar] execution,//!   i.e., multiple instructions might be executing at the same time,//!   even though the machine code describes a sequential process.//!   This kind of reordering is handled transparently by the CPU.//! - A **multiprocessor** system executing multiple hardware threads//!   at the same time: In multi-threaded scenarios, you can use two//!   kinds of primitives to deal with synchronization://!   - [memory fences] to ensure memory accesses are made visible to//!   other CPUs in the right order.//!   - [atomic operations] to ensure simultaneous access to the same//!   memory location doesn't lead to undefined behavior.//! [prefetching]: https://en.wikipedia.org/wiki/Cache_prefetching//! [compiler fences]: crate::sync::atomic::compiler_fence//! [out-of-order]: https://en.wikipedia.org/wiki/Out-of-order_execution//! [superscalar]: https://en.wikipedia.org/wiki/Superscalar_processor//! [memory fences]: crate::sync::atomic::fence//! ## Higher-level synchronization objects//! Most of the low-level synchronization primitives are quite error-prone and//! inconvenient to use, which is why the standard library also exposes some//! higher-level synchronization objects.//! These abstractions can be built out of lower-level primitives.//! For efficiency, the sync objects in the standard library are usually//! implemented with help from the operating system's kernel, which is//! able to reschedule the threads while they are blocked on acquiring//! a lock.//! The following is an overview of the available synchronization//! objects://! - [`Arc`]: Atomically Reference-Counted pointer, which can be used//!   in multithreaded environments to prolong the lifetime of some//!   data until all the threads have finished using it.//! - [`Barrier`]: Ensures multiple threads will wait for each other//!   to reach a point in the program, before continuing execution all//!   together.//! - [`Condvar`]: Condition Variable, providing the ability to block//!   a thread while waiting for an event to occur.//! - [`mpsc`]: Multi-producer, single-consumer queues, used for//!   message-based communication. Can provide a lightweight//!   inter-thread synchronisation mechanism, at the cost of some//!   extra memory.//! - [`mpmc`]: Multi-producer, multi-consumer queues, used for//! - [`Mutex`]: Mutual Exclusion mechanism, which ensures that at//!   most one thread at a time is able to access some data.//! - [`Once`]: Used for a thread-safe, one-time global initialization routine.//!   Mostly useful for implementing other types like [`OnceLock`].//! - [`OnceLock`]: Used for thread-safe, one-time initialization of a//!   variable, with potentially different initializers based on the caller.//! - [`LazyLock`]: Used for thread-safe, one-time initialization of a//!   variable, using one nullary initializer function provided at creation.//! - [`RwLock`]: Provides a mutual exclusion mechanism which allows//!   multiple readers at the same time, while allowing only one//!   writer at a time. In some cases, this can be more efficient than//!   a mutex.//! [`Condvar`]: crate::sync::Condvar//! [`mpmc`]: crate::sync::mpmc//! [`Once`]: crate::sync::Once//! [`OnceLock`]: crate::sync::OnceLock//! [`RwLock`]: crate::sync::RwLock// No formatting: this file is just re-exports, and their order is worth preserving.// `pub(crate)` for the `sys::sync::once` implementations and `LazyLock`.// Note: in the future we will change the default version in `std::sync` to the non-poisoning// version over an edition.// See https://github.com/rust-lang/rust/issues/134645#issuecomment-3324577500 for more details.// FIXME(sync_poison_mod): remove all `#[doc(inline)]` once the modules are stabilized./// The message in this slot. Either read out in `read` or dropped through/// `discard_all_messages`.// This is intentional./// Disconnects receivers and wakes up all blocked senders./// May only be called once upon dropping the last receiver. The/// destruction of all other receivers must have been observed with acquire/// ordering or stronger./// `tail` should be the current (and therefore last) value of `tail`./// # Panicking/// If a destructor panics, the remaining messages are leaked, matching the/// behavior of the unbounded channel./// This method must only be called when dropping the last receiver. The/// This may only be called from the thread this `Context` belongs to.//! Thread-local channel context./// Creates a new asynchronous channel, returning the sender/receiver halves./// All data sent on the [`Sender`] will become available on the [`Receiver`] in/// the same order as it was sent, and no [`send`] will block the calling thread/// (this channel has an "infinite buffer", unlike [`sync_channel`], which will/// block after its buffer limit is reached). [`recv`] will block until a message/// is available while there is at least one [`Sender`] alive (including clones)./// The [`Sender`] can be cloned to [`send`] to the same channel multiple times./// The [`Receiver`] also can be cloned to have multi receivers./// If the [`Receiver`] is disconnected while trying to [`send`] with the/// [`Sender`], the [`send`] method will return a [`SendError`]. Similarly, if the/// [`Sender`] is disconnected while trying to [`recv`], the [`recv`] method will/// return a [`RecvError`]./// [`recv`]: Receiver::recv/// #![feature(mpmc_channel)]/// use std::sync::mpmc::channel;/// // Spawn off an expensive computation/// #   fn expensive_computation() {}///     sender.send(expensive_computation()).unwrap();/// // Do some useful work for a while/// // Let's see what that answer was/// println!("{:?}", receiver.recv().unwrap());/// Creates a new synchronous, bounded channel./// All data sent on the [`Sender`] will become available on the [`Receiver`]/// in the same order as it was sent. Like asynchronous [`channel`]s, the/// [`Receiver`] will block until a message becomes available. `sync_channel`/// differs greatly in the semantics of the sender, however./// This channel has an internal buffer on which messages will be queued./// `bound` specifies the buffer size. When the internal buffer becomes full,/// future sends will *block* waiting for the buffer to open up. Note that a/// buffer size of 0 is valid, in which case this becomes "rendezvous channel"/// where each [`send`] will not return until a [`recv`] is paired with it./// The [`Sender`] can be cloned to [`send`] to the same channel multiple/// times. The [`Receiver`] also can be cloned to have multi receivers./// Like asynchronous channels, if the [`Receiver`] is disconnected while trying/// to [`send`] with the [`Sender`], the [`send`] method will return a/// [`SendError`]. Similarly, If the [`Sender`] is disconnected while trying/// to [`recv`], the [`recv`] method will return a [`RecvError`]./// use std::sync::mpsc::sync_channel;/// let (sender, receiver) = sync_channel(1);/// // this returns immediately/// sender.send(1).unwrap();///     // this will block until the previous message has been received///     sender.send(2).unwrap();/// assert_eq!(receiver.recv().unwrap(), 1);/// assert_eq!(receiver.recv().unwrap(), 2);/// The sending-half of Rust's synchronous [`channel`] type./// Messages can be sent through this channel with [`send`]./// Note: all senders (the original and its clones) need to be dropped for the receiver/// to stop blocking to receive messages with [`Receiver::recv`]./// let sender2 = sender.clone();/// // First thread owns sender///     sender.send(1).unwrap();/// // Second thread owns sender2///     sender2.send(2).unwrap();/// let msg = receiver.recv().unwrap();/// let msg2 = receiver.recv().unwrap();/// assert_eq!(3, msg + msg2);/// use std::sync::mpmc::{channel, Receiver, Sender};/// let (sender, _receiver): (Sender<i32>, Receiver<i32>) = channel();/// assert!(sender.try_send(1).is_ok());/// A successful send occurs when it is determined that the other end of/// the channel has not hung up already. An unsuccessful send would be one/// where the corresponding receiver has already been deallocated. Note/// that a return value of [`Err`] means that the data will never be/// received, but a return value of [`Ok`] does *not* mean that the data/// will be received. It is possible for the corresponding receiver to/// hang up immediately after this function returns [`Ok`]. However, if/// the channel is zero-capacity, it acts as a rendezvous channel and a/// return value of [`Ok`] means that the data has been received./// If the channel is full and not disconnected, this call will block until/// the send operation can proceed. If the channel becomes disconnected,/// this call will wake up and return an error. The returned error contains/// If called on a zero-capacity channel, this method will wait for a receive/// operation to appear on the other side of the channel./// // This send is always successful/// tx.send(1).unwrap();/// // This send will fail because the receiver is gone/// assert!(tx.send(1).is_err());/// tx.send_timeout(1, Duration::from_millis(400)).unwrap();/// let t = Instant::now() + Duration::from_millis(400);/// tx.send_deadline(1, t).unwrap();/// use std::sync::mpmc;/// let (send, _recv) = mpmc::channel();/// let tx1 = send.clone();/// let tx2 = send.clone();/// assert!(tx1.is_empty());///     tx2.send(1u8).unwrap();/// handle.join().unwrap();/// assert!(!tx1.is_empty());/// let (send, _recv) = mpmc::sync_channel(1);/// let (tx1, tx2) = (send.clone(), send.clone());/// assert!(!tx1.is_full());/// assert!(tx1.is_full());/// assert_eq!(tx1.len(), 0);/// assert_eq!(tx1.len(), 1);/// let (send, _recv) = mpmc::sync_channel(3);/// assert_eq!(tx1.capacity(), Some(3));/// let (tx1, _) = mpmc::channel::<i32>();/// let (tx2, _) = mpmc::channel::<i32>();/// assert!(tx1.same_channel(&tx1));/// assert!(!tx1.same_channel(&tx2));/// The receiving half of Rust's [`channel`] (or [`sync_channel`]) type./// Different threads can share this [`Receiver`] by cloning it./// Messages sent to the channel can be retrieved using [`recv`]./// let (send, recv) = channel();/// let tx_thread = thread::spawn(move || {///     send.send("Hello world!").unwrap();///     thread::sleep(Duration::from_secs(2)); // block for two seconds///     send.send("Delayed for 2 seconds").unwrap();/// let (rx1, rx2) = (recv.clone(), recv.clone());/// let rx_thread_1 = thread::spawn(move || {///     println!("{}", rx1.recv().unwrap()); // Received immediately/// let rx_thread_2 = thread::spawn(move || {///     println!("{}", rx2.recv().unwrap()); // Received after 2 seconds/// tx_thread.join().unwrap();/// rx_thread_1.join().unwrap();/// rx_thread_2.join().unwrap();/// An iterator over messages on a [`Receiver`], created by [`iter`]./// This iterator will block whenever [`next`] is called,/// waiting for a new message, and [`None`] will be returned/// when the corresponding channel has hung up./// [`iter`]: Receiver::iter///     send.send(1u8).unwrap();///     send.send(2u8).unwrap();///     send.send(3u8).unwrap();/// for x in recv.iter() {///     println!("Got: {x}");/// An iterator that attempts to yield all pending values for a [`Receiver`],/// created by [`try_iter`]./// [`None`] will be returned when there are no pending values remaining or/// if the corresponding channel has hung up./// This iterator will never block the caller in order to wait for data to/// become available. Instead, it will return [`None`]./// [`try_iter`]: Receiver::try_iter/// // Nothing is in the buffer yet/// assert!(receiver.try_iter().next().is_none());/// println!("Nothing in the buffer...");/// println!("Going to sleep...");/// thread::sleep(Duration::from_secs(2)); // block for two seconds/// for x in receiver.try_iter() {/// An owning iterator over messages on a [`Receiver`],/// created by [`into_iter`]./// This iterator will block whenever [`next`]/// is called, waiting for a new message, and [`None`] will be/// returned if the corresponding channel has hung up./// [`into_iter`]: Receiver::into_iter/// for x in recv.into_iter() {/// This method will never block the caller in order to wait for data to/// become available. Instead, this will always return immediately with a/// possible option of pending data on the channel./// block on a receiver./// Compared with [`recv`], this function has two failure cases instead of one/// (one for disconnection, one for an empty buffer)./// [`recv`]: Self::recv/// use std::sync::mpmc::{Receiver, channel};/// let (_, receiver): (_, Receiver<i32>) = channel();/// assert!(receiver.try_recv().is_err());/// Attempts to wait for a value on this receiver, returning an error if the/// corresponding channel has hung up./// This function will always block the current thread if there is no data/// available and it's possible for more data to be sent (at least one sender/// still exists). Once a message is sent to the corresponding [`Sender`],/// this receiver will wake up and return that message./// If the corresponding [`Sender`] has disconnected, or it disconnects while/// this call is blocking, this call will wake up and return [`Err`] to/// indicate that no more messages can ever be received on this channel./// However, since channels are buffered, messages sent before the disconnect/// will still be properly received./// let (send, recv) = mpmc::channel();/// assert_eq!(Ok(1), recv.recv());/// Buffering behavior:/// use std::sync::mpmc::RecvError;///     send.send(2).unwrap();///     send.send(3).unwrap();///     drop(send);/// // wait for the thread to join so we ensure the sender is dropped/// assert_eq!(Ok(2), recv.recv());/// assert_eq!(Ok(3), recv.recv());/// assert_eq!(Err(RecvError), recv.recv());/// corresponding channel has hung up, or if it waits more than `timeout`./// Successfully receiving value before encountering timeout:///     send.send('a').unwrap();///     recv.recv_timeout(Duration::from_millis(400)),///     Ok('a')/// Receiving an error upon reaching timeout:///     thread::sleep(Duration::from_millis(800));///     Err(mpmc::RecvTimeoutError::Timeout)/// corresponding channel has hung up, or if `deadline` is reached./// available and it's possible for more data to be sent. Once a message is/// sent to the corresponding [`Sender`], then this receiver will wake up/// and return that message./// Successfully receiving value before reaching deadline:///     recv.recv_deadline(Instant::now() + Duration::from_millis(400)),/// Receiving an error upon reaching deadline:/// Returns an iterator that will attempt to yield all pending values./// It will return `None` if there are no more pending values or if the/// channel has hung up. The iterator will never [`panic!`] or block the/// user by waiting for values./// // nothing is in the buffer yet/// // block for two seconds/// let mut iter = receiver.try_iter();/// assert!(recv.is_empty());/// assert!(!recv.is_empty());/// let (send, recv) = mpmc::sync_channel(1);/// assert!(!recv.is_full());/// assert!(recv.is_full());/// assert_eq!(recv.len(), 0);/// assert_eq!(recv.len(), 1);/// let (send, recv) = mpmc::sync_channel(3);/// assert_eq!(recv.capacity(), Some(3));/// let (_, rx1) = mpmc::channel::<i32>();/// let (_, rx2) = mpmc::channel::<i32>();/// assert!(rx1.same_channel(&rx1));/// assert!(!rx1.same_channel(&rx2));/// Returns an iterator that will block waiting for messages, but never/// [`panic!`]. It will return [`None`] when the channel has hung up.///     send.send(1).unwrap();/// let mut iter = recv.iter();//! Multi-producer, multi-consumer FIFO queue communication primitives.//! This module provides message-based communication over channels, concretely//! defined by two types://! * [`Sender`]//! * [`Receiver`]//! [`Sender`]s are used to send data to a set of [`Receiver`]s. Both//! sender and receiver are cloneable (multi-producer) such that many threads can send//! simultaneously to receivers (multi-consumer).//! These channels come in two flavors://! 1. An asynchronous, infinitely buffered channel. The [`channel`] function//!    will return a `(Sender, Receiver)` tuple where all sends will be//!    **asynchronous** (they never block). The channel conceptually has an//!    infinite buffer.//! 2. A synchronous, bounded channel. The [`sync_channel`] function will//!    return a `(Sender, Receiver)` tuple where the storage for pending//!    messages is a pre-allocated buffer of a fixed size. All sends will be//!    **synchronous** by blocking until there is buffer space available. Note//!    that a bound of 0 is allowed, causing the channel to become a "rendezvous"//!    channel where each sender atomically hands off a message to a receiver.//! ## Disconnection//! The send and receive operations on channels will all return a [`Result`]//! indicating whether the operation succeeded or not. An unsuccessful operation//! is normally indicative of the other half of a channel having "hung up" by//! being dropped in its corresponding thread.//! Once half of a channel has been deallocated, most operations can no longer//! continue to make progress, so [`Err`] will be returned. Many applications//! will continue to [`unwrap`] the results returned from this module,//! instigating a propagation of failure among threads if one unexpectedly dies.//! Simple usage://! #![feature(mpmc_channel)]//! use std::sync::mpmc::channel;//! // Create a simple streaming channel//! assert_eq!(rx.recv().unwrap(), 10);//! Shared usage://!     // Create a shared channel that can be sent along from many threads//!     // where tx is the sending half (tx for transmission), and rx is the receiving//!     // half (rx for receiving).//!     let (tx, rx) = channel();//!     for i in 0..10 {//!         s.spawn(move || {//!             tx.send(i).unwrap();//!         let rx1 = rx.clone();//!         let rx2 = rx.clone();//!             let j = rx1.recv().unwrap();//!             assert!(0 <= j && j < 10);//!             let j = rx2.recv().unwrap();//! Propagating panics://! // The call to recv() will return an error because the channel has already//! // hung up (or been deallocated)//! let (tx, rx) = channel::<i32>();//! drop(tx);//! assert!(rx.recv().is_err());// This module is used as the implementation for the channels in `sync::mpsc`.// The implementation comes from the crossbeam-channel crate:// Copyright (c) 2019 The Crossbeam Project Developers// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY/// Temporary data that gets initialized during a blocking operation, and is consumed by/// and is alive for the entire duration of a blocking operation./// Current state of a blocking operation.waker_current_thread_id// Ensure that thread_local init with `const { 0 }` still has unique address at run-time// x86, wasm and riscv have 64-byte cache line size.// - https://github.com/golang/go/blob/5e31f78c8a4ed1b872ddc194f0cd1ae931b37d7e/src/internal/cpu/cpu_riscv64.go#L7/// Performs quadratic backoff in spin loops.spin_light/// Backs off using lightweight spinning./// This method should be used for retrying an operation because another thread made/// progress. i.e. on CAS failure.spin_heavy/// Backs off using heavyweight spinning./// This method should be used in blocking loops where parking the thread is not an option./// Returns a unique id for the current thread./// This half can only be owned by one thread./// println!("{}", recv.recv().unwrap()); // Received immediately/// println!("Waiting...");/// println!("{}", recv.recv().unwrap()); // Received after 2 seconds// The receiver port can be sent from place to place, so long as it// is not used to receive non-sendable things./// The sending-half of Rust's asynchronous [`channel`] type.// The send port can be sent from place to place, so long as it// is not used to send non-sendable things./// The sending-half of Rust's synchronous [`sync_channel`] type./// Messages can be sent through this channel with [`send`] or [`try_send`]./// [`send`] will block if there is no space in the internal buffer./// [`send`]: SyncSender::send/// [`try_send`]: SyncSender::try_send/// // Create a sync_channel with buffer size 2/// let (sync_sender, receiver) = sync_channel(2);/// let sync_sender2 = sync_sender.clone();/// // First thread owns sync_sender///     sync_sender.send(1).unwrap();///     sync_sender.send(2).unwrap();/// // Second thread owns sync_sender2///     sync_sender2.send(3).unwrap();///     // thread will now block since the buffer is full///     println!("Thread unblocked!");/// let mut msg;/// msg = receiver.recv().unwrap();/// println!("message {msg} received");/// // "Thread unblocked!" will be printed now/// An error returned from the [`Sender::send`] or [`SyncSender::send`]/// function on **channel**s./// A **send** operation can only fail if the receiving end of a channel is/// disconnected, implying that the data could never be received. The error/// contains the data being sent as a payload so it can be recovered./// The [`recv`] operation can only fail if the sending half of a/// [`channel`] (or [`sync_channel`]) is disconnected, implying that no further/// messages will ever be received./// This enumeration is the list of the possible reasons that [`try_recv`] could/// not return data when called. This can occur with both a [`channel`] and/// a [`sync_channel`]./// This enumeration is the list of possible errors that made [`recv_timeout`]/// unable to return data when called. This can occur with both a [`channel`] and/// [`recv_timeout`]: Receiver::recv_timeout/// The data could not be sent on the [`sync_channel`] because it would require that/// the callee block to send the data./// If this is a buffered channel, then the buffer is full at this time. If/// this is not a buffered channel, then there is no [`Receiver`] available to/// acquire the data./// This [`sync_channel`]'s receiving half has disconnected, so the data could not be/// sent. The data is returned back to the callee in this case./// [`try_send`] method./// The [`Sender`] can be cloned to [`send`] to the same channel multiple times, but/// only one [`Receiver`] is supported./// All data sent on the [`SyncSender`] will become available on the [`Receiver`]/// The [`SyncSender`] can be cloned to [`send`] to the same channel multiple/// times, but only one [`Receiver`] is supported./// to [`send`] with the [`SyncSender`], the [`send`] method will return a/// [`SendError`]. Similarly, If the [`SyncSender`] is disconnected while trying/// hang up immediately after this function returns [`Ok`]./// This method will never block the current thread./// assert_eq!(tx.send(1).unwrap_err().0, 1);/// Clone a sender to send to other threads./// Note, be aware of the lifetime of the sender because all senders/// (including the original) need to be dropped in order for/// [`Receiver::recv`] to stop blocking./// Sends a value on this synchronous channel./// This function will *block* until space in the internal buffer becomes/// available or a receiver is available to hand off the message to./// Note that a successful send does *not* guarantee that the receiver will/// ever see the data if there is a buffer on this channel. Items may be/// enqueued in the internal buffer for the receiver to receive at a later/// time. If the buffer size is 0, however, the channel becomes a rendezvous/// channel and it guarantees that the receiver has indeed received/// the data if this function returns success./// This function will never panic, but it may return [`Err`] if the/// [`Receiver`] has disconnected and is no longer able to receive/// // Create a rendezvous sync_channel with buffer size 0/// let (sync_sender, receiver) = sync_channel(0);///    println!("sending message...");///    sync_sender.send(1).unwrap();///    // Thread is now blocked until the message is received///    println!("...message received!");/// assert_eq!(1, msg);/// Attempts to send a value on this channel without blocking./// This method differs from [`send`] by returning immediately if the/// channel's buffer is full or no receiver is waiting to acquire some/// data. Compared with [`send`], this function has two failure cases/// instead of one (one for disconnection, one for a full buffer)./// See [`send`] for notes about guarantees of whether the/// receiver has received the data or not if this function is successful./// [`send`]: Self::send/// // Create a sync_channel with buffer size 1/// let (sync_sender, receiver) = sync_channel(1);/// let handle1 = thread::spawn(move || {///     // Thread blocked/// let handle2 = thread::spawn(move || {///     // This will return an error and send///     // no message if the buffer is full///     let _ = sync_sender2.try_send(3);/// // Third message may have never been sent/// match receiver.try_recv() {///     Ok(msg) => println!("message {msg} received"),///     Err(_) => println!("the third message was never sent"),/// // Wait for threads to complete/// handle1.join().unwrap();/// handle2.join().unwrap();// Attempts to send for a value on this receiver, returning an error if the// corresponding channel has hung up, or if it waits more than `timeout`.// This method is currently only used for tests./// Attempts to return a pending value on this receiver without blocking./// use std::sync::mpsc::{Receiver, channel};/// still exists). Once a message is sent to the corresponding [`Sender`]/// (or [`SyncSender`]), this receiver will wake up and return that/// let (send, recv) = mpsc::channel();/// use std::sync::mpsc::RecvError;///     Err(mpsc::RecvTimeoutError::Timeout)/// sent to the corresponding [`Sender`] (or [`SyncSender`]), then this/// receiver will wake up and return that message./// #![feature(deadline_api)]/// Converts a `SendError<T>` into a `TrySendError<T>`./// This conversion always returns a `TrySendError::Disconnected` containing the data in the `SendError<T>`./// No data is allocated on the heap./// Converts a `RecvError` into a `TryRecvError`./// This conversion always returns `TryRecvError::Disconnected`./// Converts a `RecvError` into a `RecvTimeoutError`./// This conversion always returns `RecvTimeoutError::Disconnected`.//! Multi-producer, single-consumer FIFO queue communication primitives.//! defined among three types://! * [`SyncSender`]//! A [`Sender`] or [`SyncSender`] is used to send data to a [`Receiver`]. Both//! senders are clone-able (multi-producer) such that many threads can send//! simultaneously to one receiver (single-consumer).//!    return a `(SyncSender, Receiver)` tuple where the storage for pending//! // Create a shared channel that can be sent along from many threads//! // where tx is the sending half (tx for transmission), and rx is the receiving//! // half (rx for receiving).//! for i in 0..10 {//!         tx.send(i).unwrap();//!     let j = rx.recv().unwrap();//!     assert!(0 <= j && j < 10);//! Synchronous channels://! use std::sync::mpsc::sync_channel;//! let (tx, rx) = sync_channel::<i32>(0);//!     // This will wait for the parent thread to start receiving//!     tx.send(53).unwrap();//! rx.recv().unwrap();//! Unbounded receive loop://! let (tx, rx) = sync_channel(3);//! for _ in 0..3 {//!     // It would be the same without thread and clone here//!     // since there will still be one `tx` left.//!     // cloned tx dropped within thread//!     thread::spawn(move || tx.send("ok").unwrap());//! // Drop the last sender to stop `rx` waiting for message.//! // The program will not complete if we comment this out.//! // **All** `tx` needs to be dropped for `rx` to have `Err`.//! // Unbounded receiver waiting for all senders to complete.//! while let Ok(msg) = rx.recv() {//!     println!("{msg}");//! println!("completed");// MPSC channels are built as a wrapper around MPMC channels, which// were ported from the `crossbeam-channel` crate. MPMC channels are// not exposed publicly, but if you are curious about the implementation,// that's where everything is.// Sender// SyncSender// Receiver/// For more information about condition variables, check out the documentation for the poisoning/// variant of this type at [`poison::Condvar`]./// Note that this `Condvar` does **not** propagate information about threads that panic while/// holding a lock. If you need this functionality, see [`poison::Mutex`] and [`poison::Condvar`]./// #![feature(nonpoison_mutex)]/// #![feature(nonpoison_condvar)]/// use std::sync::nonpoison::{Mutex, Condvar};/// // Inside of our lock, spawn a new thread, and then wait for it to start.///     // We notify the condvar that the value has changed./// while !*started {/// [`poison::Mutex`]: crate::sync::poison::Mutex/// [`poison::Condvar`]: crate::sync::poison::Condvar/// use std::sync::Condvar;/// `guard`) and block the current thread. This means that any calls/// to [`notify_one`] or [`notify_all`] which happen logically after the/// mutex is unlocked are candidates to wake this thread up. When this/// function call returns, the lock specified will have been re-acquired./// Note that this function is susceptible to spurious wakeups. Condition/// variables normally have a boolean predicate associated with them, and/// the predicate must always be checked each time this function returns to/// protect against spurious wakeups./// This function may [`panic!`] if it is used with more than one mutex/// over time./// [`notify_one`]: Self::notify_one/// [`notify_all`]: Self::notify_all/// // As long as the value inside the `Mutex<bool>` is `false`, we wait./// Blocks the current thread until the provided condition becomes false./// `condition` is checked immediately; if not met (returns `true`), this/// will [`wait`] for the next notification then check again. This repeats/// until `condition` returns `false`, in which case this function returns./// let pair = Arc::new((Mutex::new(true), Condvar::new()));///     let mut pending = lock.lock();///     *pending = false;/// // As long as the value inside the `Mutex<bool>` is `true`, we wait./// let mut guard = lock.lock();/// cvar.wait_while(&mut guard, |pending| { *pending });/// The semantics of this function are equivalent to [`wait`] except that/// the thread will be blocked for roughly no longer than `dur`. This/// preemption or platform differences that might not cause the maximum/// amount of time waited to be precisely `dur`./// the system time. This function is susceptible to spurious wakeups./// Condition variables normally have a boolean predicate associated with/// them, and the predicate must always be checked each time this function/// returns to protect against spurious wakeups.  Furthermore, since the timeout/// is given relative to the moment this function is called, it needs to be adjusted/// when this function is called in a loop. The [`wait_timeout_while`] method/// lets you wait with a timeout while a predicate is true, taking care of all these concerns./// The returned [`WaitTimeoutResult`] value indicates if the timeout is/// Like [`wait`], the lock specified will have been re-acquired when this function/// [`wait_timeout_while`]: Self::wait_timeout_while/// // as long as the value inside the `Mutex<bool>` is `false`, we wait///     let result = cvar.wait_timeout(&mut started, Duration::from_millis(10));///     // 10 milliseconds have passed, or maybe the value changed!///     if *started == true {///         // We received the notification and the value has been updated, we can leave.wait_timeout_while/// The semantics of this function are equivalent to [`wait_while`] except/// that the thread will be blocked for roughly no longer than `dur`. This/// known to have elapsed without the condition being met./// Like [`wait_while`], the lock specified will have been re-acquired when this/// function returns, regardless of whether the timeout elapsed or not./// [`wait_while`]: Self::wait_while/// [`wait_timeout`]: Self::wait_timeout/// let result = cvar.wait_timeout_while(///     &mut guard,///     Duration::from_millis(100),///     |&mut pending| pending,/// if result.timed_out() {///     // timed-out without the condition ever evaluating to false./// // access the locked mutex via guard/// be woken up from its call to [`wait`] or [`wait_timeout`]. Calls to/// To wake up all threads, see [`notify_all`]./// To wake up only one thread, see [`notify_one`].///     cvar.notify_all();/// Creates a `Condvar` which is ready to be waited on and notified./// A mutual exclusion primitive useful for protecting shared data that does not keep track of/// lock poisoning./// For more information about mutexes, check out the documentation for the poisoning variant of/// this lock at [`poison::Mutex`]./// Note that this `Mutex` does **not** propagate threads that panic while holding the lock via/// poisoning. If you need this functionality, see [`poison::Mutex`]./// use std::sync::{Arc, nonpoison::Mutex};/// let mutex = Arc::new(Mutex::new(0u32));///     let m = Arc::clone(&mutex);///     let handle = thread::spawn(move || {///         let mut guard = m.lock();///         panic!("panic from thread {n} {guard}")///     handles.push(handle);/// for h in handles {///     let _ = h.join();/// println!("Finished, locked {} times", mutex.lock());/// `T` must be `Send` for a [`Mutex`] to be `Send` because it is possible to acquire/// the owned `T` from the `Mutex` via [`into_inner`]./// [`into_inner`]: Mutex::into_inner/// `T` must be `Send` for [`Mutex`] to be `Sync`./// This ensures that the protected data can be accessed safely from multiple threads/// without causing data races or other unsafe behavior./// [`Mutex<T>`] provides mutable access to `T` to one thread at a time. However, it's essential/// for `T` to be `Send` because it's not safe for non-`Send` structures to be accessed in/// this manner. For instance, consider [`Rc`], a non-atomic reference counted smart pointer,/// which is not `Send`. With `Rc`, we can have multiple copies pointing to the same heap/// allocation with a non-atomic reference count. If we were to use `Mutex<Rc<_>>`, it would/// only protect one instance of `Rc` from shared access, leaving other copies vulnerable/// to potential data races./// Also note that it is not necessary for `T` to be `Sync` as `&T` is only made available/// to one thread at a time if `T` is not `Sync`./// [`Rc`]: crate::rc::Rc"holding a MutexGuard across suspend \
                      points can cause deadlocks, delays, \
                      and cause Futures to not implement `Send`"/// [`Deref`] and [`DerefMut`] implementations./// This structure is created by the [`lock`] and [`try_lock`] methods on/// [`Mutex`]./// [`lock`]: Mutex::lock/// [`try_lock`]: Mutex::try_lock/// A [`MutexGuard`] is not `Send` to maximize platform portability./// On platforms that use POSIX threads (commonly referred to as pthreads) there is a requirement to/// release mutex locks on the same thread they were acquired./// For this reason, [`MutexGuard`] must not implement `Send` to prevent it being dropped from/// another thread./// `T` must be `Sync` for a [`MutexGuard<T>`] to be `Sync`/// because it is possible to get a `&T` from `&MutexGuard` (via `Deref`)."holding a MappedMutexGuard across suspend \
                      points can cause deadlocks, delays, \
                      and cause Futures to not implement `Send`"// NB: we use a pointer instead of `&'a mut T` to avoid `noalias` violations, because a// `MappedMutexGuard` argument doesn't hold uniqueness for its whole scope, only until it drops.// `NonNull` is covariant over `T`, so we add a `PhantomData<&'a mut T>` field// below for the correct variance over `T` (invariance)._variance/// subfield of the protected data. When this structure is dropped (falls out/// of scope), the lock will be unlocked./// The main difference between `MappedMutexGuard` and [`MutexGuard`] is that the/// former cannot be used with [`Condvar`], since that could introduce soundness issues if the/// locked object is modified by another thread while the `Mutex` is unlocked./// This structure is created by the [`map`] and [`filter_map`] methods on/// [`map`]: MutexGuard::map/// [`filter_map`]: MutexGuard::filter_map/// [`Condvar`]: crate::sync::nonpoison::Condvar// #[unstable(feature = "nonpoison_mutex", issue = "134645")]/// use std::sync::nonpoison::Mutex;/// Returns the contained value by cloning it./// #![feature(lock_value_accessors)]/// let mut mutex = Mutex::new(7);/// assert_eq!(mutex.get_cloned(), 7);/// mutex.set(11);/// assert_eq!(mutex.get_cloned(), 11);/// Replaces the contained value with `value`, and returns the old contained value./// assert_eq!(mutex.replace(11), 7);/// the mutex. Upon returning, the thread is the only thread with the lock/// The exact behavior on locking a mutex in the thread which already holds/// the lock is left unspecified. However, this function will not return on/// the second call (it might panic or deadlock, for example)./// This function might panic when called if the lock is already held by/// let mutex = Arc::new(Mutex::new(0));/// let c_mutex = Arc::clone(&mutex);///     *c_mutex.lock() = 10;/// }).join().expect("thread::spawn failed");/// assert_eq!(*mutex.lock(), 10);/// This function does not block. If the lock could not be acquired at this time, then/// [`WouldBlock`] is returned. Otherwise, an RAII guard is returned./// The lock will be unlocked when the guard is dropped./// If the mutex could not be acquired because it is already locked, then this call will return/// the [`WouldBlock`] error.///     let mut lock = c_mutex.try_lock();///     if let Ok(ref mut mutex) = lock {///         **mutex = 10;///         println!("try_lock failed");/// assert_eq!(*mutex.lock().unwrap(), 10);/// The returned pointer is always non-null and properly aligned, but it is/// the user's responsibility to ensure that any reads and writes through it/// are properly synchronized to avoid data races, and that it is not read/// or written through after the mutex is dropped./// Acquires the mutex and provides mutable access to the underlying data by passing/// a mutable reference to the given closure./// This method acquires the lock, calls the provided closure with a mutable reference/// to the data, and returns the result of the closure. The lock is released after/// the closure completes, even if it panics./// #![feature(lock_value_accessors, nonpoison_mutex)]/// let mutex = Mutex::new(2);/// let result = mutex.with_mut(|data| {///     *data += 3;///     *data + 5/// assert_eq!(*mutex.lock(), 5);/// assert_eq!(result, 10);/// This is equivalent to [`Mutex::new`]./// Creates a `Mutex<T>`, with the `Default` value for T.'mutexguard_lock/// For use in [`nonpoison::condvar`](super::condvar)./// Makes a [`MappedMutexGuard`] for a component of the borrowed data, e.g./// an enum variant./// The `Mutex` is already locked, so this cannot fail./// `MutexGuard::map(...)`. A method would interfere with methods of the/// same name on the contents of the `MutexGuard` used through `Deref`./// Makes a [`MappedMutexGuard`] for a component of the borrowed data. The/// original guard is returned as an `Err(...)` if the closure returns/// `MutexGuard::filter_map(...)`. A method would interfere with methods of the/// `MappedMutexGuard::map(...)`. A method would interfere with methods of the/// `MappedMutexGuard::filter_map(...)`. A method would interfere with methods of the/// The inner [`sys::RwLock`] that synchronizes thread access to the protected data./// The lock-protected data./// A reader-writer lock that does not keep track of lock poisoning./// For more information about reader-writer locks, check out the documentation for the poisoning/// variant of this lock (which can be found at [`poison::RwLock`])./// [`poison::RwLock`]: crate::sync::poison::RwLock/// #![feature(nonpoison_rwlock)]/// use std::sync::nonpoison::RwLock;"holding a RwLockReadGuard across suspend \
                      points can cause deadlocks, delays, \
                      and cause Futures to not implement `Send`"/// A pointer to the data protected by the `RwLock`. Note that we use a pointer here instead of/// `&'rwlock T` to avoid `noalias` violations, because a `RwLockReadGuard` instance only holds/// immutability until it drops, not for its whole scope./// `NonNull` is preferable over `*const T` to allow for niche optimizations. `NonNull` is also/// covariant over `T`, just like we would have with `&T`.inner_lock/// A reference to the internal [`sys::RwLock`] that we have read-locked./// This structure is created by the [`read`] and [`try_read`] methods on/// [`read`]: RwLock::read/// [`try_read`]: RwLock::try_read"holding a RwLockWriteGuard across suspend \
                      points can cause deadlocks, delays, \
                      and cause Future's to not implement `Send`"/// A reference to the [`RwLock`] that we have write-locked./// This structure is created by the [`write`] and [`try_write`] methods/// [`write`]: RwLock::write/// [`try_write`]: RwLock::try_write"holding a MappedRwLockReadGuard across suspend \
                      points can cause deadlocks, delays, \
                      and cause Futures to not implement `Send`"/// `&'rwlock T` to avoid `noalias` violations, because a `MappedRwLockReadGuard` instance only/// holds immutability until it drops, not for its whole scope./// dropped, which can point to a subfield of the protected data./// This structure is created by the [`map`] and [`filter_map`] methods/// on [`RwLockReadGuard`]./// [`map`]: RwLockReadGuard::map/// [`filter_map`]: RwLockReadGuard::filter_map// #[unstable(feature = "nonpoison_rwlock", issue = "134645")]"holding a MappedRwLockWriteGuard across suspend \
                      points can cause deadlocks, delays, \
                      and cause Future's to not implement `Send`"/// `&'rwlock T` to avoid `noalias` violations, because a `MappedRwLockWriteGuard` instance only/// holds uniquneness until it drops, not for its whole scope./// `NonNull` is preferable over `*const T` to allow for niche optimizations./// `NonNull` is covariant over `T`, so we add a `PhantomData<&'rwlock mut T>` field here to/// enforce the correct invariance over `T`./// A reference to the internal [`sys::RwLock`] that we have write-locked./// on [`RwLockWriteGuard`]./// [`map`]: RwLockWriteGuard::map/// [`filter_map`]: RwLockWriteGuard::filter_map/// let mut lock = RwLock::new(7);/// assert_eq!(lock.get_cloned(), 7);/// lock.set(11);/// assert_eq!(lock.get_cloned(), 11);/// assert_eq!(lock.replace(11), 7);/// This function might panic when called if the lock is already held by the current thread./// let c_lock = Arc::clone(&lock);/// let n = lock.read();/// If the access could not be granted at this time, then `Err` is returned./// This function does not provide any guarantees with respect to the ordering/// of whether contentious readers or writers will acquire the lock first./// This function will return the [`WouldBlock`] error if the `RwLock` could/// not be acquired because it was already locked exclusively./// let mut n = lock.write();/// If the lock could not be acquired at this time, then `Err` is returned./// not be acquired because it was already locked./// [`WouldBlock`]: WouldBlock/// let lock = RwLock::new(String::new());///     let mut s = lock.write();/// assert_eq!(lock.into_inner(), "modified");/// take place -- the mutable borrow statically guarantees no new locks can be acquired/// while this reference exists. Note that this method does not clear any previously abandoned/// locks (e.g., via [`forget()`] on a [`RwLockReadGuard`] or [`RwLockWriteGuard`])./// let mut lock = RwLock::new(0);/// or written through after the lock is dropped./// Locks this `RwLock` with shared read access to the underlying data by passing/// a reference to the given closure./// This method acquires the lock, calls the provided closure with a reference/// #![feature(lock_value_accessors, nonpoison_rwlock)]/// let rwlock = RwLock::new(2);/// let result = rwlock.with(|data| *data + 3);/// assert_eq!(result, 5);/// Locks this `RwLock` with exclusive write access to the underlying data by passing/// let result = rwlock.with_mut(|data| {/// assert_eq!(*rwlock.read(), 5);/// Creates a new `RwLock<T>`, with the `Default` value for T./// This is equivalent to [`RwLock::new`]./// Creates a new instance of `RwLockReadGuard<T>` from a `RwLock<T>`./// This function is safe if and only if the same thread has successfully and safely called/// `lock.inner.read()`, `lock.inner.try_read()`, or `lock.inner.downgrade()` before/// instantiating this object./// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data, e.g./// The `RwLock` is already locked for reading, so this cannot fail./// `RwLockReadGuard::map(...)`. A method would interfere with methods of/// the same name on the contents of the `RwLockReadGuard` used through/// `Deref`./// If the closure panics, the guard will be dropped (unlocked)./// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data. The/// `RwLockReadGuard::filter_map(...)`. A method would interfere with methods/// of the same name on the contents of the `RwLockReadGuard` used through/// Creates a new instance of `RwLockWriteGuard<T>` from a `RwLock<T>`./// `lock.inner.write()`, `lock.inner.try_write()`, or `lock.inner.try_upgrade` before/// Downgrades a write-locked `RwLockWriteGuard` into a read-locked [`RwLockReadGuard`]./// Since we have the `RwLockWriteGuard`, the [`RwLock`] must already be locked for writing, so/// this method cannot fail./// After downgrading, other readers will be allowed to read the protected data./// `downgrade` takes ownership of the `RwLockWriteGuard` and returns a [`RwLockReadGuard`]./// use std::sync::nonpoison::{RwLock, RwLockWriteGuard};/// let rw = RwLock::new(0);/// let mut write_guard = rw.write();/// *write_guard = 42;/// let read_guard = RwLockWriteGuard::downgrade(write_guard);/// assert_eq!(42, *read_guard);/// `downgrade` will _atomically_ change the state of the [`RwLock`] from exclusive mode into/// shared mode. This means that it is impossible for another writing thread to get in between a/// thread calling `downgrade` and any reads it performs after downgrading./// let rw = Arc::new(RwLock::new(1));/// // Put the lock in write mode./// let mut main_write_guard = rw.write();/// let rw_clone = rw.clone();/// let evil_handle = std::thread::spawn(move || {///     // This will not return until the main thread drops the `main_read_guard`.///     let mut evil_guard = rw_clone.write();///     assert_eq!(*evil_guard, 2);///     *evil_guard = 3;/// *main_write_guard = 2;/// // Atomically downgrade the write guard into a read guard./// let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);/// // Since `downgrade` is atomic, the writer thread cannot have changed the protected data./// assert_eq!(*main_read_guard, 2, "`downgrade` was not atomic");/// # drop(main_read_guard);/// # evil_handle.join().unwrap();/// # let final_check = rw.read();/// # assert_eq!(*final_check, 3);/// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data, e.g./// The `RwLock` is already locked for writing, so this cannot fail./// `RwLockWriteGuard::map(...)`. A method would interfere with methods of/// the same name on the contents of the `RwLockWriteGuard` used through/// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data. The/// `RwLockWriteGuard::filter_map(...)`. A method would interfere with methods/// of the same name on the contents of the `RwLockWriteGuard` used through/// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data,/// e.g. an enum variant./// `MappedRwLockReadGuard::map(...)`. A method would interfere with/// methods of the same name on the contents of the `MappedRwLockReadGuard`/// used through `Deref`./// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data./// The original guard is returned as an `Err(...)` if the closure returns/// `MappedRwLockReadGuard::filter_map(...)`. A method would interfere with/// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data,/// `MappedRwLockWriteGuard::map(...)`. A method would interfere with/// methods of the same name on the contents of the `MappedRwLockWriteGuard`/// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data./// `MappedRwLockWriteGuard::filter_map(...)`. A method would interfere with// Guards/// A type alias for the result of a nonblocking locking method./// A lock could not be acquired at this time because the operation would otherwise block.//! Non-poisoning synchronous locks.//! The difference from the locks in the [`poison`] module is that the locks in this module will not//! become poisoned when a thread panics while holding a guard.//! [`poison`]: super::poison/// A low-level synchronization primitive for one-time global execution./// Previously this was the only "execute once" synchronization in `std`./// Other libraries implemented novel synchronizing types with `Once`, like/// [`OnceLock<T>`] or [`LazyLock<T, F>`], before those were added to `std`./// `OnceLock<T>` in particular supersedes `Once` in functionality and should/// be preferred for the common case where the `Once` is associated with data./// This type can only be constructed with [`Once::new()`]./// use std::sync::Once;/// [`OnceLock<T>`]: crate::sync::OnceLock/// [`LazyLock<T, F>`]: crate::sync::LazyLock/// State yielded to [`Once::call_once_force()`]’s closure parameter. The state/// can be used to query the poison status of the [`Once`]./// Used for the internal implementation of `sys::sync::once` on different platforms and the/// [`LazyLock`](crate::sync::LazyLock) implementation./// Initialization value for static [`Once`] values./// use std::sync::{Once, ONCE_INIT};/// static START: Once = ONCE_INIT;/// has run and completed (it might not be the closure specified). It is also/// If the given closure recursively invokes `call_once` on the same [`Once`]/// instance, the exact behavior is not specified: allowed outcomes are/// a panic or a deadlock./// // in a synchronized fashion (e.g., write once or read all) then we're/// The closure `f` will only be executed once even if this is called/// it will *poison* this [`Once`] instance, causing all future invocations of/// This is similar to [poisoning with mutexes][poison], but this mechanism/// is guaranteed to never skip panics within `f`./// [poison]: struct.Mutex.html#poisoning/// Performs the same function as [`call_once()`] except ignores poisoning./// Unlike [`call_once()`], if this [`Once`] has been poisoned (i.e., a previous/// call to [`call_once()`] or [`call_once_force()`] caused a panic), calling/// [`call_once_force()`] will still invoke the closure `f` and will _not_/// result in an immediate panic. If `f` panics, the [`Once`] will remain/// in a poison state. If `f` does _not_ panic, the [`Once`] will no/// longer be in a poison state and all future calls to [`call_once()`] or/// [`call_once_force()`] will be no-ops./// The closure `f` is yielded a [`OnceState`] structure which can be used/// to query the poison status of the [`Once`]./// [`call_once()`]: Once::call_once/// [`call_once_force()`]: Once::call_once_force/// // poison the once/// let handle = thread::spawn(|| {///     INIT.call_once(|| panic!());/// assert!(handle.join().is_err());/// // poisoning propagates///     INIT.call_once(|| {});/// // call_once_force will still run and reset the poisoned state/// INIT.call_once_force(|state| {///     assert!(state.is_poisoned());/// // once any success happens, we stop propagating the poison/// INIT.call_once(|| {});/// Returns `true` if some [`call_once()`] call has completed/// successfully. Specifically, `is_completed` will return false in/// the following situations:///   * [`call_once()`] was not called at all,///   * [`call_once()`] was called, but has not yet completed,///   * the [`Once`] instance is poisoned/// This function returning `false` does not mean that [`Once`] has not been/// executed. For example, it may have been executed in the time between/// when `is_completed` starts executing and when it returns, in which case/// the `false` return value would be stale (but still permissible)./// assert_eq!(INIT.is_completed(), false);/// INIT.call_once(|| {///     assert_eq!(INIT.is_completed(), false);/// assert_eq!(INIT.is_completed(), true);/// Blocks the current thread until initialization has completed./// static READY: Once = Once::new();/// let thread = thread::spawn(|| {///     READY.wait();///     println!("everything is ready");/// READY.call_once(|| println!("performing setup"));/// If this [`Once`] has been poisoned because an initialization closure has/// panicked, this method will also panic. Use [`wait_force`](Self::wait_force)/// if this behavior is not desired.wait_force/// Blocks the current thread until initialization has completed, ignoring/// poisoning./// If this [`Once`] has been poisoned, this function blocks until it/// becomes completed, unlike [`Once::wait()`], which panics in this case./// Returns the current state of the `Once` instance./// Since this takes a mutable reference, no initialization can currently/// be running, so the state must be either "incomplete", "poisoned" or/// "complete"./// Sets current state of the `Once` instance./// Returns `true` if the associated [`Once`] was poisoned prior to the/// invocation of the closure passed to [`Once::call_once_force()`]./// A poisoned [`Once`]:/// An unpoisoned [`Once`]:///     assert!(!state.is_poisoned());/// Poison the associated [`Once`] without explicitly panicking.// NOTE: This is currently only exposed for `OnceLock`.//! A "once initialization" primitive//! This primitive is meant to be used to run one-time initialization. An//! example use case would be for initializing an FFI library.// FIXME(nonpoison_once): switch to nonpoison version once it is available// Whether or not the value is initialized is tracked by `once.is_completed()`./// `PhantomData` to make sure dropck understands we're dropping T in our Drop impl./// use std::sync::OnceLock;/// struct A<'a>(&'a str);/// impl<'a> Drop for A<'a> {///     fn drop(&mut self) {}/// let cell = OnceLock::new();///     let s = String::new();///     let _ = cell.set(A(&s));/// A synchronization primitive which can nominally be written to only once./// This type is a thread-safe [`OnceCell`], and can be used in statics./// In many simple cases, you can use [`LazyLock<T, F>`] instead to get the benefits of this type/// with less effort: `LazyLock<T, F>` "looks like" `&T` because it initializes with `F` on deref!/// Where OnceLock shines is when LazyLock is too simple to support a given case, as LazyLock/// doesn't allow additional inputs to its function after you call [`LazyLock::new(|| ...)`]./// A `OnceLock` can be thought of as a safe abstraction over uninitialized data that becomes/// Unlike [`Mutex`](crate::sync::Mutex), `OnceLock` is never poisoned on panic./// [`OnceCell`]: crate::cell::OnceCell/// [`LazyLock::new(|| ...)`]: crate::sync::LazyLock::new/// Writing to a `OnceLock` from a separate thread:/// static CELL: OnceLock<usize> = OnceLock::new();/// // `OnceLock` has not been written to yet./// // Spawn a thread and write to `OnceLock`.///     let value = CELL.get_or_init(|| 12345);///     assert_eq!(value, &12345);/// .join()/// // `OnceLock` now contains the value.///     CELL.get(),///     Some(&12345),/// You can use `OnceLock` to implement a type that requires "append-only" logic:/// use std::sync::{OnceLock, atomic::{AtomicU32, Ordering}};/// struct OnceList<T> {///     data: OnceLock<T>,///     next: OnceLock<Box<OnceList<T>>>,/// impl<T> OnceList<T> {///     const fn new() -> OnceList<T> {///         OnceList { data: OnceLock::new(), next: OnceLock::new() }///     fn push(&self, value: T) {///         // FIXME: this impl is concise, but is also slow for long lists or many threads.///         // as an exercise, consider how you might improve on it while preserving the behavior///         if let Err(value) = self.data.set(value) {///             let next = self.next.get_or_init(|| Box::new(OnceList::new()));///             next.push(value)///     fn contains(&self, example: &T) -> bool///         T: PartialEq,///         self.data.get().map(|item| item == example).filter(|v| *v).unwrap_or_else(|| {///             self.next.get().map(|next| next.contains(example)).unwrap_or(false)/// // Let's exercise this new Sync append-only list by doing a little counting/// static LIST: OnceList<u32> = OnceList::new();/// static COUNTER: AtomicU32 = AtomicU32::new(0);/// # const LEN: u32 = if cfg!(miri) { 50 } else { 1000 };/// const LEN: u32 = 1000;///     for _ in 0..thread::available_parallelism().unwrap().get() {///             while let i @ 0..LEN = COUNTER.fetch_add(1, Ordering::Relaxed) {///                 LIST.push(i);/// for i in 0..LEN {///     assert!(LIST.contains(&i));/// Returns `None` if the cell is uninitialized, or being initialized./// This method never blocks./// This method never blocks. Since it borrows the `OnceLock` mutably,/// it is statically guaranteed that no active borrows to the `OnceLock`/// exist, including from other threads./// Blocks the current thread until the cell is initialized./// Waiting for a computation on another thread to finish:/// let value = OnceLock::new();///     s.spawn(|| value.set(1 + 1));///     let result = value.wait();///     assert_eq!(result, &2);/// May block if another thread is currently attempting to initialize the cell. The cell is/// guaranteed to contain a value when `set` returns, though not necessarily the one provided./// Returns `Ok(())` if the cell was uninitialized and/// `Err(value)` if the cell was already initialized./// static CELL: OnceLock<i32> = OnceLock::new();/// Initializes the contents of the cell to `value` if the cell was uninitialized,/// then returns a reference to it./// guaranteed to contain a value when `try_insert` returns, though not necessarily the/// one provided./// Returns `Ok(&value)` if the cell was uninitialized and/// `Err((&current_value, value))` if it was already initialized.///         assert_eq!(CELL.try_insert(92), Ok(&92));///     assert_eq!(CELL.try_insert(62), Err((&92, 62)));/// Gets the contents of the cell, initializing it to `f()` if the cell/// was uninitialized./// will be executed if the function doesn't panic./// it to `f()` if the cell was uninitialized./// let mut cell = OnceLock::new();/// If `f()` panics, the panic is propagated to the caller, and/// let mut cell: OnceLock<u32> = OnceLock::new();/// *value.unwrap() += 2;/// Consumes the `OnceLock`, returning the wrapped value. Returns/// `None` if the cell was uninitialized./// let cell: OnceLock<String> = OnceLock::new();/// Takes the value out of this `OnceLock`, moving it back to an uninitialized state./// Has no effect and returns `None` if the `OnceLock` was uninitialized./// Since this method borrows the `OnceLock` mutably, it is statically guaranteed that/// no active borrows to the `OnceLock` exist, including from other threads./// let mut cell: OnceLock<String> = OnceLock::new();/// The cell must be initialized// Thread A creates a `OnceLock` and shares it with///     assert_eq!(OnceLock::<()>::new(), OnceLock::default());/// Creates a new cell with its contents set to `value`./// # fn main() -> Result<(), i32> {/// let a = OnceLock::from(3);/// let b = OnceLock::new();/// b.set(3)?;/// Equality for two `OnceLock`s./// Two `OnceLock`s are equal if they either both contain values and their/// values are equal, or if neither contains a value./// let five = OnceLock::new();/// five.set(5).unwrap();/// let also_five = OnceLock::new();/// also_five.set(5).unwrap();/// assert!(five == also_five);/// assert!(OnceLock::<u32>::new() == OnceLock::<u32>::new());/// determining that a thread must block./// Functions in this module will block the current **thread** of execution./// Note that any attempt to use multiple mutexes on the same condition/// variable may result in a runtime panic./// use std::sync::{Arc, Mutex, Condvar};/// let mut started = lock.lock().unwrap();///     started = cvar.wait(started).unwrap();/// This function will return an error if the mutex being waited on is/// poisoned when this thread re-acquires the lock. For more information,/// see information about [poisoning] on the [`Mutex`] type./// [poisoning]: super::Mutex#poisoning/// [`Mutex`]: super::Mutex///     let mut pending = lock.lock().unwrap();/// let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();wait_timeout_ms/// The semantics of this function are equivalent to [`wait`]/// except that the thread will be blocked for roughly no longer/// than `ms` milliseconds. This method should not be used for/// precise timing due to anomalies such as preemption or platform/// differences that might not cause the maximum amount of time/// waited to be precisely `ms`./// The returned boolean is `false` only if the timeout is known/// to have elapsed./// Like [`wait`], the lock specified will be re-acquired when this function///     let result = cvar.wait_timeout_ms(started, 10).unwrap();///     started = result.0;/// returns to protect against spurious wakeups. Furthermore, since the timeout///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();/// Like [`wait_while`], the lock specified will be re-acquired when this///     lock.lock().unwrap(),/// if result.1.timed_out() {/// // access the locked mutex via result.0/// mutex can be created via a [`new`] constructor. Each mutex has a type parameter/// which represents the data that it is protecting. The data can only be accessed/// through the RAII guards returned from [`lock`] and [`try_lock`], which/// guarantees that the data is only ever accessed when the mutex is locked./// The mutexes in this module implement a strategy called "poisoning" where a/// mutex becomes poisoned if it recognizes that the thread holding it has/// panicked./// Once a mutex is poisoned, all other threads are unable to access the data by/// default as it is likely tainted (some invariant is not being upheld). For a/// mutex, this means that the [`lock`] and [`try_lock`] methods return a/// [`Result`] which indicates whether a mutex has been poisoned or not. Most/// usage of a mutex will simply [`unwrap()`] these results, propagating panics/// among threads to ensure that a possibly invalid invariant is not witnessed./// Poisoning is only advisory: the [`PoisonError`] type has an [`into_inner`]/// method which will return the guard that would have otherwise been returned/// on a successful lock. This allows access to the data, despite the lock being/// poisoned./// In addition, the panic detection is not ideal, so even unpoisoned mutexes/// need to be handled with care, since certain panics may have been skipped./// Here is a non-exhaustive list of situations where this might occur:/// - If a mutex is locked while a panic is underway, e.g. within a [`Drop`]///   implementation or a [panic hook], panicking for the second time while the///   lock is held will leave the mutex unpoisoned. Note that while double panic///   usually aborts the program, [`catch_unwind`] can prevent this./// - Locking and unlocking the mutex across different panic contexts, e.g. by///   storing the guard to a [`Cell`] within [`Drop::drop`] and accessing it///   outside, or vice versa, can affect poisoning status in an unexpected way./// - Foreign exceptions do not currently trigger poisoning even in absence of///   other panics./// While this rarely happens in realistic code, `unsafe` code cannot rely on/// poisoning for soundness, since the behavior of poisoning can depend on/// outside context. Here's an example of **incorrect** use of poisoning:/// struct MutexBox<T> {///     data: Mutex<*mut T>,/// impl<T> MutexBox<T> {///             data: Mutex::new(Box::into_raw(Box::new(value))),///     pub fn replace_with(&self, f: impl FnOnce(T) -> T) {///         let ptr = self.data.lock().expect("poisoned");///         // While `f` is running, the data is moved out of `*ptr`. If `f`///         // panics, `*ptr` keeps pointing at a dropped value. The intention///         // is that this will poison the mutex, so the following calls to///         // `replace_with` will panic without reading `*ptr`. But since///         // poisoning is not guaranteed to occur if this is run from a panic///         // hook, this can lead to use-after-free.///             (*ptr).write(f((*ptr).read()));/// [`new`]: Self::new/// [`lock`]: Self::lock/// [`try_lock`]: Self::try_lock/// [`unwrap()`]: Result::unwrap/// [`PoisonError`]: super::PoisonError/// [`into_inner`]: super::PoisonError::into_inner/// [`catch_unwind`]: crate::panic::catch_unwind/// for _ in 0..N {///         // We unwrap() the return value to assert that we are not expecting///         // threads to ever fail while holding the lock.///         let mut data = data.lock().unwrap();/// To recover from a poisoned mutex:/// let lock = Arc::new(Mutex::new(0_u32));/// let lock2 = Arc::clone(&lock);/// let _ = thread::spawn(move || -> () {///     // This thread will acquire the mutex first, unwrapping the result of///     // `lock` because the lock has not been poisoned.///     let _guard = lock2.lock().unwrap();///     // This panic while holding the lock (`_guard` is in scope) will poison///     // the mutex.///     panic!();/// // The lock is poisoned by this point, but the returned result can be/// // pattern matched on to return the underlying guard on both branches./// let mut guard = match lock.lock() {///     Ok(guard) => guard,///     Err(poisoned) => poisoned.into_inner(),/// *guard += 1;/// To unlock a mutex guard sooner than the end of the enclosing scope,/// either create an inner scope or drop the guard manually./// const N: usize = 3;/// let data_mutex = Arc::new(Mutex::new(vec![1, 2, 3, 4]));/// let res_mutex = Arc::new(Mutex::new(0));/// let mut threads = Vec::with_capacity(N);/// (0..N).for_each(|_| {///     let data_mutex_clone = Arc::clone(&data_mutex);///     let res_mutex_clone = Arc::clone(&res_mutex);///     threads.push(thread::spawn(move || {///         // Here we use a block to limit the lifetime of the lock guard.///         let result = {///             let mut data = data_mutex_clone.lock().unwrap();///             // This is the result of some important and long-ish work.///             let result = data.iter().fold(0, |acc, x| acc + x * 2);///             data.push(result);///             result///             // The mutex guard gets dropped here, together with any other values///             // created in the critical section.///         // The guard created here is a temporary dropped at the end of the statement, i.e.///         // the lock would not remain being held even if the thread did some additional work.///         *res_mutex_clone.lock().unwrap() += result;/// let mut data = data_mutex.lock().unwrap();/// // This is the result of some important and long-ish work./// let result = data.iter().fold(0, |acc, x| acc + x * 2);/// data.push(result);/// // We drop the `data` explicitly because it's not necessary anymore and the/// // thread still has work to do. This allows other threads to start working on/// // the data immediately, without waiting for the rest of the unrelated work/// // to be done here./// // It's even more important here than in the threads because we `.join` the/// // threads after that. If we had not dropped the mutex guard, a thread could/// // be waiting forever for it, causing a deadlock./// // As in the threads, a block could have been used instead of calling the/// // `drop` function./// drop(data);/// // Here the mutex guard is not assigned to a variable and so, even if the/// // scope does not end after this line, the mutex is still released: there is/// // no deadlock./// *res_mutex.lock().unwrap() += result;/// threads.into_iter().for_each(|thread| {///     thread///         .join()///         .expect("The thread creating or execution failed !")/// assert_eq!(*res_mutex.lock().unwrap(), 800);poison_flag/// former cannot be used with [`Condvar`], since that/// thread while the `Mutex` is unlocked./// [`Condvar`]: crate::sync::Condvar/// If another user of this mutex panicked while holding the mutex, then/// this call will return an error instead./// assert_eq!(mutex.get_cloned().unwrap(), 7);/// this call will return an error containing the provided `value` instead./// mutex.set(11).unwrap();/// assert_eq!(mutex.get_cloned().unwrap(), 11);/// assert_eq!(mutex.replace(11).unwrap(), 7);/// this call will return an error once the mutex is acquired. The acquired/// mutex guard will be contained in the returned error.///     *c_mutex.lock().unwrap() = 10;/// If the lock could not be acquired at this time, then [`Err`] is returned./// this call will return the [`Poisoned`] error if the mutex would/// otherwise be acquired. An acquired lock guard will be contained/// in the returned error./// If the mutex could not be acquired because it is already locked, then/// this call will return the [`WouldBlock`] error./// [`Poisoned`]: TryLockError::Poisoned/// [`WouldBlock`]: TryLockError::WouldBlock/// Determines whether the mutex is poisoned./// If another thread is active, the mutex can still become poisoned at any/// time. You should not trust a `false` value for program correctness/// without additional synchronization.///     let _lock = c_mutex.lock().unwrap();///     panic!(); // the mutex gets poisoned/// assert_eq!(mutex.is_poisoned(), true);clear_poison/// Clear the poisoned state from a mutex./// If the mutex is poisoned, it will remain poisoned until this function is called. This/// allows recovering from a poisoned state and marking that it has recovered. For example, if/// the value is overwritten by a known-good value, then the mutex can be marked as/// un-poisoned. Or possibly, the value could be inspected to determine if it is in a/// consistent state, and if so the poison is removed./// let x = mutex.lock().unwrap_or_else(|mut e| {///     **e.get_mut() = 1;///     mutex.clear_poison();///     e.into_inner()/// assert_eq!(mutex.is_poisoned(), false);/// assert_eq!(*x, 1);/// this call will return an error containing the underlying data/// assert_eq!(mutex.into_inner().unwrap(), 0);/// while this reference exists. Note that this method does not clear any previous abandoned locks/// (e.g., via [`forget()`] on a [`MutexGuard`])./// this call will return an error containing a mutable reference to the/// underlying data instead./// *mutex.get_mut().unwrap() = 10;guard_poison/// A flag denoting if this `RwLock` has been poisoned./// that acquire the lock, therefore blocking any threads waiting for the lock to/// become available. An `RwLock` will allow any number of readers to acquire the/// lock as long as a writer is not holding the lock./// The priority policy of the lock is dependent on the underlying operating/// system's implementation, and this type does not guarantee that any/// particular policy will be used. In particular, a writer which is waiting to/// acquire the lock in `write` might or might not block concurrent calls to/// `read`, e.g.:/// // Thread 1              |  // Thread 2/// let _rg1 = lock.read();  |///                          |  // will block///                          |  let _wg = lock.write();/// // may deadlock          |/// let _rg2 = lock.read();  |/// required that `T` satisfies [`Send`] to be shared across threads and/// [`Sync`] to allow concurrent access through readers. The RAII guards/// returned from the locking methods implement [`Deref`] (and [`DerefMut`]/// An `RwLock`, like [`Mutex`], will [usually] become poisoned on a panic. Note,/// however, that an `RwLock` may only be poisoned if a panic occurs while it is/// locked exclusively (write mode). If a panic occurs in any reader, then the/// lock will not be poisoned./// [usually]: super::Mutex#poisoning/// use std::sync::RwLock;/// The poison guard. See the [`poison`] module for more information./// A reference to the original `RwLock`'s poison state.poison_guard/// This function will return an error if the `RwLock` is poisoned. An/// `RwLock` is poisoned whenever a writer panics while holding an exclusive/// assert_eq!(lock.get_cloned().unwrap(), 7);/// This function will return an error containing the provided `value` if/// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer/// panics while holding an exclusive lock./// lock.set(11).unwrap();/// assert_eq!(lock.get_cloned().unwrap(), 11);/// assert_eq!(lock.replace(11).unwrap(), 7);/// lock. The failure will occur immediately after the lock has been/// acquired. The acquired lock guard will be contained in the returned/// use std::sync::{Arc, RwLock};/// This function will return the [`Poisoned`] error if the `RwLock` is/// poisoned. An `RwLock` is poisoned whenever a writer panics while holding/// an exclusive lock. `Poisoned` will only be returned if the lock would/// have otherwise been acquired. An acquired lock guard will be contained/// lock. An error will be returned when the lock is acquired. The acquired/// lock guard will be contained in the returned error./// Determines whether the lock is poisoned./// If another thread is active, the lock can still become poisoned at any/// let lock = Arc::new(RwLock::new(0));/// Clear the poisoned state from a lock./// If the lock is poisoned, it will remain poisoned until this function is called. This allows/// recovering from a poisoned state and marking that it has recovered. For example, if the/// value is overwritten by a known-good value, then the lock can be marked as un-poisoned. Or/// possibly, the value could be inspected to determine if it is in a consistent state, and if/// so the poison is removed./// let guard = lock.write().unwrap_or_else(|mut e| {///     lock.clear_poison();/// assert_eq!(lock.is_poisoned(), false);/// assert_eq!(*guard, 1);/// This function will return an error containing the underlying data if/// panics while holding an exclusive lock. An error will only be returned/// if the lock would have otherwise been acquired./// This function will return an error containing a mutable reference to/// the underlying data if the `RwLock` is poisoned. An `RwLock` is/// poisoned whenever a writer panics while holding an exclusive lock./// An error will only be returned if the lock would have otherwise been/// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be/// use std::sync::{RwLock, RwLockWriteGuard};/// let mut write_guard = rw.write().unwrap();/// use std::sync::{Arc, RwLock, RwLockWriteGuard};/// let mut main_write_guard = rw.write().unwrap();///     let mut evil_guard = rw_clone.write().unwrap();/// # let final_check = rw.read().unwrap();/// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned./// Checks the flag for an unguarded borrow, where we only care about existing poison./// Checks the flag for a guarded borrow, where we may also set poison when `done`./// A type of error which can be returned whenever a lock is acquired./// Both [`Mutex`]es and [`RwLock`]s are poisoned whenever a thread fails while the lock/// is held. The precise semantics for when a lock is poisoned is documented on/// each lock. For a lock in the poisoned state, unless the state is cleared manually,/// all future acquisitions will return this error./// // poison the mutex///     let mut data = c_mutex.lock().unwrap();///     *data = 2;/// match mutex.lock() {///     Err(p_err) => {///         let data = p_err.get_ref();///         println!("recovered: {data}");/// [`Mutex`]: crate::sync::Mutex/// [`RwLock`]: crate::sync::RwLock/// The lock could not be acquired because another thread failed while holding/// the lock./// The lock could not be acquired at this time because the operation would/// otherwise block./// An enumeration of possible errors associated with a [`TryLockResult`] which/// can occur while trying to acquire a lock, from the [`try_lock`] method on a/// [`Mutex`] or the [`try_read`] and [`try_write`] methods on an [`RwLock`]./// [`try_lock`]: crate::sync::Mutex::try_lock/// [`try_read`]: crate::sync::RwLock::try_read/// [`try_write`]: crate::sync::RwLock::try_write/// A type alias for the result of a lock method which can be poisoned./// The [`Ok`] variant of this result indicates that the primitive was not/// poisoned, and the operation result is contained within. The [`Err`] variant indicates/// that the primitive was poisoned. Note that the [`Err`] variant *also* carries/// an associated value assigned by the lock method, and it can be acquired through the/// [`into_inner`] method. The semantics of the associated value depends on the corresponding/// lock method./// [`into_inner`]: PoisonError::into_inner/// For more information, see [`LockResult`]. A `TryLockResult` doesn't/// necessarily hold the associated guard in the [`Err`] type as the lock might not/// have been acquired for other reasons./// Creates a `PoisonError`./// This is generally created by methods like [`Mutex::lock`](crate::sync::Mutex::lock)/// or [`RwLock::read`](crate::sync::RwLock::read)./// This method may panic if std was built with `panic="abort"`./// Consumes this error indicating that a lock is poisoned, returning the/// associated data./// let mutex = Arc::new(Mutex::new(HashSet::new()));///     data.insert(10);/// let p_err = mutex.lock().unwrap_err();/// let data = p_err.into_inner();/// println!("recovered {} items", data.len());/// Reaches into this error indicating that a lock is poisoned, returning a/// reference to the associated data./// mutable reference to the associated data.//! Synchronization objects that employ poisoning.//! # Poisoning//! All synchronization objects in this module implement a strategy called//! "poisoning" where a primitive becomes poisoned if it recognizes that some//! thread has panicked while holding the exclusive access granted by the//! primitive. This information is then propagated to all other threads//! to signify that the data protected by this primitive is likely tainted//! (some invariant is not being upheld).//! The specifics of how this "poisoned" state affects other threads and whether//! the panics are recognized reliably or on a best-effort basis depend on the//! primitive. See [Overview](#overview) below.//! The synchronization objects in this module have alternative implementations that do not employ//! poisoning in the [`std::sync::nonpoison`] module.//! [`std::sync::nonpoison`]: crate::sync::nonpoison//! Below is a list of synchronization objects provided by this module//! with a high-level overview for each object and a description//! of how it employs "poisoning".//!   Condition variables are typically associated with//!   a boolean predicate (a condition) and a mutex.//!   This implementation is associated with [`poison::Mutex`](Mutex),//!   which employs poisoning.//!   For this reason, [`Condvar::wait()`] will return a [`LockResult`],//!   just like [`poison::Mutex::lock()`](Mutex::lock) does.//!   Panicking while holding the lock typically poisons the mutex, but it is//!   not guaranteed to detect this condition in all circumstances.//!   [`Mutex::lock()`] returns a [`LockResult`], providing a way to deal with//!   the poisoned state. See [`Mutex`'s documentation](Mutex#poisoning) for more.//!   This implementation, like [`Mutex`], usually becomes poisoned on a panic.//!   Note, however, that an `RwLock` may only be poisoned if a panic occurs//!   while it is locked exclusively (write mode). If a panic occurs in any reader,//!   then the lock will not be poisoned.//! Note that the [`Once`] type also employs poisoning, but since it has non-poisoning `force`//! methods available on it, there is no separate `nonpoison` and `poison` version.// If we are not unwinding, `PoisonError` is uninhabited.// Note that the Ordering uses to access the `failed` field of `Flag` below is// always `Relaxed`, and that's because this isn't actually protecting any data,// it's just a flag whether we've panicked or not.// The actual location that this matters is when a mutex is **locked** which is// where we have external synchronization ensuring that we see memory// reads/writes to this flag.// As a result, if it matters, we should see the correct value for `failed` in// all cases.current_id/// A re-entrant mutual exclusion lock/// This lock will block *other* threads waiting for the lock to become/// available. The thread which has already locked the mutex can lock it/// multiple times without blocking, preventing a common source of deadlocks./// Allow recursively calling a function needing synchronization from within/// a callback (this is how [`StdoutLock`](crate::io::StdoutLock) is currently/// implemented):/// #![feature(reentrant_lock)]/// use std::sync::ReentrantLock;/// pub struct Log {///     data: RefCell<String>,/// impl Log {///     pub fn append(&self, msg: &str) {///         self.data.borrow_mut().push_str(msg);/// static LOG: ReentrantLock<Log> = ReentrantLock::new(Log { data: RefCell::new(String::new()) });/// pub fn with_log<R>(f: impl FnOnce(&Log) -> R) -> R {///     let log = LOG.lock();///     f(&*log)/// with_log(|log| {///     log.append("Hello");///     with_log(|log| log.append(" there!"));// # Implementation details// The 'owner' field tracks which thread has locked the mutex.// We use thread::current_id() as the thread identifier, which is just the// current thread's ThreadId, so it's unique across the process lifetime.// If `owner` is set to the identifier of the current thread,// we assume the mutex is already locked and instead of locking it again,// we increment `lock_count`.// When unlocking, we decrement `lock_count`, and only unlock the mutex when// it reaches zero.// `lock_count` is protected by the mutex and only accessed by the thread that has// locked the mutex, so needs no synchronization.// `owner` can be checked by other threads that want to see if they already// hold the lock, so needs to be atomic. If it compares equal, we're on the// same thread that holds the mutex and memory access can use relaxed ordering// since we're not dealing with multiple threads. If it's not equal,// synchronization is left to the mutex, making relaxed memory ordering for// the `owner` field fine in all cases.// On systems without 64 bit atomics we also store the address of a TLS variable// along the 64-bit TID. We then first check that address against the address// of that variable on the current thread, and only if they compare equal do we// compare the actual TIDs. Because we only ever read the TID on the same thread// that it was written on (or a thread sharing the TLS block with that writer thread),// we don't need to further synchronize the TID accesses, so they can be regular 64-bit// non-atomic accesses.// Because of the `UnsafeCell`, these traits are not implemented automatically"if unused the ReentrantLock will immediately unlock"/// An RAII implementation of a "scoped lock" of a re-entrant lock. When this/// structure is dropped (falls out of scope), the lock will be unlocked./// [`Deref`] implementation./// This structure is created by the [`lock`](ReentrantLock::lock) method on/// [`ReentrantLock`]./// # Mutability/// Unlike [`MutexGuard`](super::MutexGuard), `ReentrantLockGuard` does not/// implement [`DerefMut`](crate::ops::DerefMut), because implementation of/// the trait would violate Rust’s reference aliasing rules. Use interior/// mutability (usually [`RefCell`](crate::cell::RefCell)) in order to mutate/// the guarded data./// Creates a new re-entrant lock in an unlocked state ready for use./// let lock = ReentrantLock::new(0);/// assert_eq!(lock.into_inner(), 0);/// Acquires the lock, blocking the current thread until it is able to do/// so./// This function will block the caller until it is available to acquire/// the lock. Upon returning, the thread is the only thread with the lock/// held. When the thread calling this method already holds the lock, the/// call succeeds without blocking./// use std::sync::{Arc, ReentrantLock};/// let lock = Arc::new(ReentrantLock::new(Cell::new(0)));///     c_lock.lock().set(10);/// assert_eq!(lock.lock().get(), 10);/// Since this call borrows the `ReentrantLock` mutably, no actual locking/// needs to take place -- the mutable borrow statically guarantees no locks/// let mut lock = ReentrantLock::new(0);/// Otherwise, an RAII guard is returned.// FIXME maybe make it a public part of the API?/// the user's responsibility to ensure that any reads through it are/// properly synchronized to avoid data races, and that it is not read/// through after the lock is dropped.increment_lock_count// The minimum alignment guaranteed by the architecture. This value is used to// add fast paths for low alignment values.realloc_fallbackpalsgx_memwaitqueue"_ZN16__rust_internals3std3sys5alloc3sgx8DLMALLOCE"DLMALLOCdlmallocDlmalloc// Using a SpinMutex because we never want to exit the enclave waiting for the// allocator.// The current allocator here is the `dlmalloc` crate which we've got included// in the rust-lang/rust repository as a submodule. The crate is a port of// dlmalloc.c from C to Rust.// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests/// Allocs system resourcesfree_partcan_release_partallocates_zeros__rust_c_alloc// The following functions are needed by libunwind. These symbols are named// in pre-link args for the target specification, so keep that in sync.__rust_c_deallocloaded_image//! Global Allocator for UEFI.//! Uses [r-efi-alloc](https://crates.io/crates/r-efi-alloc)__heap_start__heap_endVexos// FIXME(static_mut_refs): Do not allow `static_mut_refs` lint// Symbols for heap section boundaries defined in the target's linkerscriptSyncDlmallocDropLock// no atomics, no threads, that's easy!//! This is an implementation of a global allocator on wasm targets when//! emscripten or wasi is not in use. In that situation there's no actual runtime//! for us to lean on for allocation, so instead we provide our own!//! The wasm instruction set has two instructions for getting the current//! amount of memory and growing the amount of memory. These instructions are the//! foundation on which we're able to build an allocator, so we do so! Note that//! the instructions are also pretty "global" and this is the "global" allocator//! after all!//! The current allocator here is the `dlmalloc` crate which we've got included//! in the rust-lang/rust repository as a submodule. The crate is a port of//! dlmalloc.c from C to Rust and is basically just so we can have "pure Rust"//! for now which is currently technically required (can't link with C yet).//! The crate itself provides a global allocator which on wasm has no//! synchronization as there are no threads!alloc_header// Flag to indicate that the memory returned by `HeapAlloc` should be zeroed.// Get a handle to the default heap of the current process, or null if the operation fails.// SAFETY: Successful calls to this function within the same process are assumed to// always return the same handle, which remains valid for the entire lifetime of the process.// See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-getprocessheap// Allocate a block of `dwBytes` bytes of memory from a given heap `hHeap`.// The allocated memory may be uninitialized, or zeroed if `dwFlags` is// set to `HEAP_ZERO_MEMORY`.// Returns a pointer to the newly-allocated memory or null if the operation fails.// The returned pointer will be aligned to at least `MIN_ALIGN`.//  - `hHeap` must be a non-null handle returned by `GetProcessHeap`.//  - `dwFlags` must be set to either zero or `HEAP_ZERO_MEMORY`.// Note that `dwBytes` is allowed to be zero, contrary to some other allocators.// See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-heapalloc// Reallocate a block of memory behind a given pointer `lpMem` from a given heap `hHeap`,// to a block of at least `dwBytes` bytes, either shrinking the block in place,// or allocating at a new location, copying memory, and freeing the original location.// Returns a pointer to the reallocated memory or null if the operation fails.// If the operation fails the given block will never have been freed.//  - `dwFlags` must be set to zero.//  - `lpMem` must be a non-null pointer to an allocated block returned by `HeapAlloc` or//     `HeapReAlloc`, that has not already been freed.// If the block was successfully reallocated at a new location, pointers pointing to// the freed memory, such as `lpMem`, must not be dereferenced ever again.// See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-heaprealloc// Free a block of memory behind a given pointer `lpMem` from a given heap `hHeap`.// Returns a nonzero value if the operation is successful, and zero if the operation fails.//  - `lpMem` must be a pointer to an allocated block returned by `HeapAlloc` or `HeapReAlloc`,//     that has not already been freed.// If the block was successfully freed, pointers pointing to the freed memory, such as `lpMem`,// must not be dereferenced ever again.// Note that `lpMem` is allowed to be null, which will not cause the operation to fail.// See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-heapfreeget_process_heapprocess_heap_alloc// We pass this argument to match the ABI of `HeapAlloc`,// Header containing a pointer to the start of an allocated block.// SAFETY: Size and alignment must be <= `MIN_ALIGN`.// Allocate a block of optionally zeroed memory for a given `layout`.// SAFETY: Returns a pointer satisfying the guarantees of `System` about allocated pointers,// or null if the operation fails. If this returns non-null `HEAP` will have been successfully// initialized.// All pointers returned by this allocator have, in addition to the guarantees of `GlobalAlloc`, the// following properties:// If the pointer was allocated or reallocated with a `layout` specifying an alignment <= `MIN_ALIGN`// the pointer will be aligned to at least `MIN_ALIGN` and point to the start of the allocated block.// If the pointer was allocated or reallocated with a `layout` specifying an alignment > `MIN_ALIGN`// the pointer will be aligned to the specified alignment and not point to the start of the allocated block.// Instead there will be a header readable directly before the returned pointer, containing the actual// location of the start of the block.// Heap memory management on Windows is done by using the system Heap API (heapapi.h)// See https://docs.microsoft.com/windows/win32/api/heapapi/"_ZN16__rust_internals3std3sys4xous5alloc8DLMALLOCE"anon_pipe//! Platform-dependent command line arguments abstraction."_ZN16__rust_internals3std3sys3sgx4args4ARGSE"ARGSArgsStore// FIXME: this module systematically confuses pointers and integersparse_lp_cmd_line/// Implements the UEFI command-line argument parsing algorithm./// This implementation is based on what is defined in Section 3.4 of/// [UEFI Shell Specification](https://uefi.org/sites/default/files/resources/UEFI_Shell_Spec_2_0.pdf)/// Returns None in the following cases:/// - Invalid UTF-16 (unpaired surrogate)/// - Empty/improper arguments/// One-time global initialization./// Returns the command line argumentsARGC// The system-provided argc and argv, which we store in static memory// here so that we can defer the work of parsing them until its actually// needed.// Note that we never mutate argv/argc, the argv array, or the argv// strings, which allows the code in this file to be very simple.ARGV".init_array.00099"ARGV_INIT_ARRAY/// glibc passes argc, argv, and envp to functions in .init_array, as a non-standard extension./// This allows `std::env::args` to work even in a `cdylib`, as it does on macOS and Windows.argc_argv//! Global initialization and retrieval of command line arguments.//! On some platforms these are stored during runtime startup,//! and on some they are retrieved from the system on demand.// runtime init functions not used during testingmaybe_argschksingle_wordsofficial_exampleswhitespace_behaviorgenius_quotespost_2008// from https://daviddeley.com/autohotkey/parameters/parameters.htm#WINCRULESEXensure_no_nulsfill_utf16_bufget_long_pathto_u16sWStrUnits/// Implements the Windows command-line argument parsing algorithm./// Microsoft's documentation for the Windows CLI argument format can be found at/// <https://docs.microsoft.com/en-us/cpp/cpp/main-function-command-line-args?view=msvc-160#parsing-c-command-line-arguments>/// A more in-depth explanation is here:/// <https://daviddeley.com/autohotkey/parameters/parameters.htm#WIN>/// Windows includes a function to do command line parsing in shell32.dll./// However, this is not used for two reasons:/// 1. Linking with that DLL causes the process to be registered as a GUI application./// GUI applications add a bunch of overhead, even if no windows are drawn. See/// <https://randomascii.wordpress.com/2018/12/03/a-not-called-function-can-cause-a-5x-slowdown/>./// 2. It does not follow the modern C/C++ argv rules outlined in the first two links above./// This function was tested for equivalence to the C/C++ parsing rules using an/// extensive test suite available at/// <https://github.com/ChrisDenton/winarg/tree/std>./// Add quotes (if needed)/// Append raw string without quoting// Every arg is quoted// Whitespace and empty args are quoted// Arg appended without any changes (#29494)append_argappend_bat_argmake_bat_command_lineto_user_path/// Takes a path and tries to return a non-verbatim path./// This is necessary because cmd.exe does not support verbatim paths.from_wide_to_user_path//! The Windows command line is just a string//! <https://docs.microsoft.com/en-us/archive/blogs/larryosterman/the-windows-command-line-is-just-a-string>//! This module implements the parsing necessary to turn that string into a list of arguments.get_application_parametersMAX_NB_FRAMES/// Max number of frames to print.BacktraceLock/// Prints the current backtrace._print_fmt/// This function is not Sync. The caller must hold a mutex lock, or there must be only one thread in the program.__rust_begin_short_backtrace/// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`. Note that/// this is only inline(never) when backtraces in std are enabled, otherwise/// it's fine to optimize away.__rust_end_short_backtrace/// Prints the filename of the backtrace frame./// See also `output`.//! Common code for printing backtraces.acosf128asinf128atanf128atan2f128cbrtf128coshf128expm1f128hypotf128log1pf128sinhf128tanf128tanhf128tgammaf128lgammaf128_rerff128erfcf128// These symbols are all defined by `libm`,// or by `compiler-builtins` on unsupported platforms.ENV/// Returns a vector of (variable, value) byte-vector pairs for all the//! Platform-dependent environment variables abstraction.motor"_ZN16__rust_internals3std3sys3pal3sgx2os3ENVE""_ZN16__rust_internals3std3sys3pal3sgx2os8ENV_INITE"ENV_INITEnvStoreget_env_storecreate_env_storesolidsmall_c_stringrun_with_cstrENV_LOCKenv_read_lockcvt_env/// In kmclib, `setenv` and `unsetenv` don't always set `errno`, so this/// function just returns a generic error.unsupported_errChar16uefi_env// Use the `environ` static which is part of POSIX.EnvIterator"unsupported.rs"unsupported_envcfg_unordered// Replaces the #[else] gate with #[cfg(not(any(…)))] of all the other gates.// This ensures that they must be mutually exclusive and do not have precedence// like cfg_select!.//! Constants associated with each target.// Keep entries sorted alphabetically and mutually exclusive.r" Mitigation for <https://github.com/rust-lang/rust/issues/126600>"r" On glibc, `libc::exit` has been observed to not always be thread-safe."r" It is currently unclear whether that is a glibc bug or allowed by the standard."r" To mitigate this problem, we ensure that only one"r" Rust thread calls `libc::exit` (or returns from `main`) by calling this function before"r" calling `libc::exit` (or returning from `main`)."r" Technically, this is not enough to ensure soundness, since other code directly calling"r" `libc::exit` will still race with this."r" *This function does not itself call `libc::exit`.* This is so it can also be used"r" to guard returning from `main`."r" This function will return only the first time it is called in a process."r" * If it is called again on the same thread as the first call, it will abort."r" * If it is called again on a different thread, it will wait in a loop"r"   (waiting for the process to exit)."unique_thread_exitduplicate_path//! Platform-dependent file descriptor abstraction.map_motor_errorfortanix_sgx_abi/// Extracts the actual file descriptor without closing it.limit_vector_count// The maximum read limit on most POSIX-like systems is `SSIZE_MAX`,// with the man page quoting that if the count of bytes to read is// greater than `SSIZE_MAX` the result is "unspecified".// On Apple targets however, apparently the 64-bit libc is either buggy or// intentionally showing odd behavior by rejecting any read with a size// larger than INT_MAX. To handle both of these the read size is capped on// both platforms.err2ioWasiFdIovecciovecCiovecdatasyncFdflagsset_rightsRightsLookupflagsOflagsDircookiefilestat_getFilestatfilestat_set_timesFstflagsfilestat_set_sizepath_filestat_getpath_filestat_set_timesunlink_filesock_recvRiflagsRoflagssock_sendSiflagssock_shutdown// FIXME: __wasi_fd_fdstat_getignore_notfoundNOT_FILE_ERRORremove_dir_all_recursive// not used on all platformsstat_structrun_path_with_cstrstat_valfrom_statInnerReadDir// all DirEntry's will have a reference to this struct/// path to the entry/// 64-bit inode number/// File type/// name of the entry// generic// system-specificfile_name_os_strget_access_modeget_creation_modeopen_cfile_attrset_permdebug_assert_fd_is_openCachedFileMetadatawith_native_pathrt_filetypert_permmoto_rtrt_open_optionsrt_fdRtFdparent_pathCIntNotMinusOne/// A file descriptor.dirpS_DIRFILE_PERMISSIONS_MASKfile_time// Bool indicates if file is readonly// Bool indicates if directoryfrom_uefiUefiBoxto_attr// Symlinks are not supported in UEFIis_mode_validsimple_file_systemopen_volume_from_device_pathBorrowedDevicePath/// Open Filesystem volume given a devicepath to the volume, or a file/directory in the/// volume. The path provided should be absolute UEFI device path, without any UEFI shell/// mappings./// 1. The volume as a UEFI File/// 2. Path relative to the volume./// For example, given "PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/\abc\run.efi",/// this will open the volume "PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)"/// and return the remaining file path "\abc\run.efi".open_volume// Open volume on device_handle using SIMPLE_FILE_SYSTEM_PROTOCOLpath_best_match/// A helper to check that target path is a descendent of source. It is expected to be used with/// absolute UEFI device paths without any UEFI shell mappings./// Returns the path relative to source/// For example, given "PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/" and/// "PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/\abc\run.efi", this will return/// "\abc\run.efi"/// An implementation of mkdir to allow creating new directory without having to open the/// volume twice (once for checking and once for creating)uefi_to_systemtime/// EDK2 FAT driver uses EFI_UNSPECIFIED_TIMEZONE to represent localtime. So for proper/// conversion to SystemTime, we use the current time to get the timezone in such cases.systemtime_to_uefi/// Convert to UEFI Time with the current timezone.uefi_fstest_debug_permissionscfg_has_statx// FIXME: This should be available on Linux with all `target_env`.// But currently only glibc exposes `statx` fn and structs.// We don't want to import unverified raw C structs here directly.// https://github.com/rust-lang/rust/pull/67774statx_extra_fieldsStatxExtraFieldstry_statxdirent64_min// We need to store an owned copy of the entry name on platforms that use// readdir() (not readdir_r()), because a) struct dirent may use a flexible// array to store the name, b) it lives only until the next readdir() call.// Define a minimal subset of fields we need from `dirent64`, especially since// we're not using the immediate `d_name` on these targets. Keeping this as an// `entry` field in `DirEntry` helps reduce the `cfg` boilerplate elsewhere.from_stat64masked/// Aborts the process if a file desceriptor is not open, if debug asserts are enabled/// Many IO syscalls can't be fully trusted about EBADF error codes because those/// might get bubbled up from a remote FUSE server rather than the file descriptor/// in the current process being invalid./// So we check file flags instead which live on the file descriptor and not the underlying file./// The downside is that it costs an extra syscall, so we only do it for debug.name_cstrfile_time_to_timespec// Format in octal, followed by the mode format used in `ls -l`.// References://   https://pubs.opengroup.org/onlinepubs/009696899/utilities/ls.html//   https://www.gnu.org/software/libc/manual/html_node/Testing-File-Type.html//   https://www.gnu.org/software/libc/manual/html_node/Permission-Bits.html//   0o100664 (-rw-rw-r--)open_fromset_times_implopen_to_and_set_permissionscfmremove_dir_impl// Fallback for REDOX, ESP-ID, Horizon, Vita, Vxworks and Miri// miri has some special hacks here that make things unused.unsupported_fsvex_sdkFIL/// VEXos file descriptor./// This stores an opaque pointer to a [FatFs file object structure] managed by VEXos/// representing an open file on disk./// [FatFs file object structure]: https://github.com/Xilinx/embeddedsw/blob/master/lib/sw_services/xilffs/src/include/ff.h?rgh-link-date=2025-09-23T20%3A03%3A43Z#L215/// Since this platform uses a pointer to to an internal filesystem structure with a lifetime/// associated with it (rather than a UNIX-style file descriptor table), care must be taken to/// ensure that the pointer held by `FileDesc` is valid for as long as it exists.// SAFETY: VEXos's FDs can be used on a thread other than the one they were created on.// SAFETY: We assume an environment without threads (i.e. no RTOS).// (If there were threads, it is possible that a mutex would be required.)// Cannot use `copy` from `common` here, since `File::set_permissions` is unsupported on this target.map_fresultFRESULTReadDirInnerReadDirStatenext_read_offsetFillBuffer/// Fill `buf` with `buf.len()` bytes starting from `next_read_offset`.ProcessEntryRunUntilExhaustion/// There is no more data to get in [`Self::FillBuffer`]; keep returning/// entries via ProcessEntry until `buf` is exhausted.Direntdirflagsfdflagsoflagsrights_baserights_inheritingFiletypeas_wasiInodefdflagto_wasi_timestamp_or_nowopen_parent/// Attempts to open a bare path `p`./// WASI has no fundamental capability to do this. All syscalls and operations/// are relative to already-open file descriptors. The C library, however,/// manages a map of pre-opened file descriptors to their path, and then the C/// library provides an API to look at this. In other words, when you want to/// open a path `p`, you have to find a previously opened file descriptor in a/// global table and then see if `p` is relative to that file descriptor./// This function, if successful, will return two items:/// * The first is a `ManuallyDrop<WasiFd>`. This represents a pre-opened file///   descriptor which we don't have ownership of, but we can use. You shouldn't///   actually drop the `fd`./// * The second is a path that should be a part of `p` and represents a///   relative traversal from the file descriptor specified to the desired///   location `p`./// If successful you can use the returned file descriptor to perform/// file-descriptor-relative operations on the path returned as well. The/// `rights` argument indicates what operations are desired on the returned file/// descriptor, and if successful the returned file descriptor should have the/// appropriate rights for performing `rights` actions./// Note that this can fail if `p` doesn't look like it can be opened relative/// to any pre-opened file descriptor.DirBuffUnicodeStrRefWinErrorunicode_strMAX_RETRIES// The maximum number of times to spin when waiting for deletes to complete.nt_open_file/// A wrapper around a raw NtOpenFile call./// This isn't completely safe because `OBJECT_ATTRIBUTES` contains raw pointers.open_link_no_reparse/// Open the file `path` in the directory `parent`, requesting the given `access` rights./// `options` will be OR'd with `FILE_OPEN_REPARSE_POINT`.open_dir/// A simple retry loop that keeps running `f` while it fails with the given/// error code or until `MAX_RETRIES` is reached.remove_dir_all_iterative//! The Windows implementation of std::fs::remove_dir_all.//! This needs to address two issues://! - It must not be possible to trick this into deleting files outside of//!   the parent directory (see CVE-2022-21658).//! - It should not fail if many threads or processes call `remove_dir_all`//!   on the same path.//! The first is handled by using the low-level `NtOpenFile` API to open a file//! relative to a parent directory.//! The second is trickier. Deleting a file works by setting its "disposition"//! to delete. However, it isn't actually deleted until the file is closed.//! During the gap between these two events, the file is in a kind of limbo//! state where it still exists in the filesystem but anything trying to open//! it fails with an error.//! The mitigations we use here are://! - When attempting to open the file, we treat ERROR_DELETE_PENDING as a//!   successful delete.//! - If the file still hasn't been removed from the filesystem by the time we//!   attempt to delete the parent directory, we try to wait for it to finish.//!   We can't wait indefinitely though so after some number of spins, we give//!   up and return an error.//! In short, we can't guarantee this will always succeed in the event of a//! race but we do make a best effort such that it *should* do so.set_file_information_by_handletruncate_utf16_at_nulWCStrmaybe_verbatimreparse_tagis_directoryFindNextFileHandleinherit_handleget_flags_and_attributesopen_nativeacquire_lockLOCK_FILE_FLAGSreparse_pointREPARSE_DATA_BUFFER// NB: returned pointer is derived from `space`, and has provenance to// match. A raw pointer is returned rather than a reference in order to// avoid narrowing provenance to the actual `REPARSE_DATA_BUFFER`.basic_infoFILE_BASIC_INFO/// Gets only basic file information such as attributes and file times./// Deletes the file, consuming the file handle to ensure the delete occurs/// as immediately as possible./// This attempts to use `posix_delete` but falls back to `win32_delete`/// if that is not supported by the filesystem.posix_delete/// Delete using POSIX semantics./// Files will be deleted as soon as the handle is closed. This is supported/// for Windows 10 1607 (aka RS1) and later. However some filesystem/// drivers will not support it even then, e.g. FAT32./// If the operation is not supported for this filesystem or OS version/// then errors will be `ERROR_NOT_SUPPORTED` or `ERROR_INVALID_PARAMETER`.win32_delete/// Delete a file using win32 semantics. The file won't actually be deleted/// until all file handles are closed. However, marking a file for deletion/// will prevent anyone from opening a new handle to the file.fill_dir_buff/// Fill the given buffer with as many directory entries as will fit./// This will remember its position and continue from the last call unless/// `restart` is set to `true`./// The returned bool indicates if there are more entries or not./// It is an error if `self` is not a directory./// # Symlinks and other reparse points/// On Windows a file is either a directory or a non-directory./// A symlink directory is simply an empty directory with some "reparse" metadata attached./// So if you open a link (not its target) and iterate the directory,/// you will always iterate an empty directory regardless of the target./// A buffer for holding directory entries.DirBuffIter/// Returns a `DirBuffIter`./// An iterator over entries stored in a `DirBuff`./// Currently only returns file names (UTF-16 encoded).from_maybe_unalignedmodified_u64accessed_u64created_u64changed_u64symlink_innerReparsePointas_flag// Try to see if a file exists but, unlike `exists`, report I/O errors.//! A buffer type used with `Write::write_vectored` for UEFI Networking APIs. Vectored writing to//! File is not supported as of UEFI Spec 2.11.handle_is_consolemsys_tty_oncopy_specializationcopies_append_mode_sinkdont_splice_pipes_from_filesbench_file_to_file_copybench_file_to_socket_copybench_file_to_uds_copybench_socket_pipe_socket_copyFdMetaNoneObtained/// We don't have any metadata because the stat syscall failed/// This type represents either the inferred `FileType` of a `RawFd` based on the source/// type from which it was extracted or the actual metadata/// The methods on this type only provide hints, due to `AsRawFd` and `FromRawFd` the inferred/// type may be wrong.FdHandlemaybe_fifopotential_sendfile_sourcecopy_file_range_candidatesafe_kernel_copy/// Returns true either if changes made to the source after a sendfile/splice call won't become/// visible in the sink or the source has explicitly opted into such behavior (e.g. by splicing/// a file into a pipe, the pipe being the source in this case)./// This will prevent File -> Pipe and File -> Socket splicing/sendfile optimizations to uphold/// the Read/Write API semantics of io::copy./// Note: This is not 100% airtight, the caller can use the RawFd conversion methods to turn a/// regular file into a TcpSocket which will be treated as a socket here without checking.CopyParamsCopierSpecCopyCopyReadCopyWritedrain_to/// Implementations that contain buffers (i.e. `BufReader`) must transfer data from their internal/// buffers into `writer` until either the buffers are emptied or `limit` bytes have been/// transferred, whichever occurs sooner./// If nested buffers are present the outer buffers must be drained first./// This is necessary to directly bypass the wrapper types while preserving the data order/// when operating directly on the underlying file descriptors./// Updates `Take` wrappers to remove the number of bytes copied.min_limit/// The minimum of the limit of all `Take<_>` wrappers, `u64::MAX` otherwise./// This method does not account for data `BufReader` buffers and would underreport/// the limit of a `Take<BufReader<Take<_>>>` type. Thus its result is only valid/// after draining the buffers via `drain_to`./// Extracts the file descriptor and hints/metadata, delegating through wrappers if necessary.fd_to_metaCopyResultupdate_takeINVALID_FD/// Invalid file descriptor./// Valid file descriptors are guaranteed to be positive numbers (see `open()` manpage)/// while negative values are used to indicate errors./// Thus -1 will never be overlap with a valid open file.copy_regular_files/// Linux-specific implementation that will attempt to use copy_file_range for copy offloading./// As the name says, it only works on regular files./// Callers must handle fallback to a generic copy loop./// `Fallback` may indicate non-zero number of bytes already written/// if one of the files' cursor +`max_len` would exceed u64::MAX (`EOVERFLOW`).SpliceModeSendfilesendfile_splice/// performs splice or sendfile between file descriptors/// Does _not_ fall back to a generic copy loop.//! This module contains specializations that can offload `io::copy()` operations on file descriptor//! containing types (`File`, `TcpStream`, etc.) to more efficient syscalls than `read(2)` and `write(2)`.//! Specialization is only applied to wholly std-owned types so that user code can't observe//! that the `Read` and `Write` traits are not used.//! Since a copy operation involves a reader and writer side where each can consist of different types//! and also involve generic wrappers (e.g. `Take`, `BufReader`) it is not practical to specialize//! a single method on all possible combinations.//! Instead readers and writers are handled separately by the `CopyRead` and `CopyWrite` specialization//! traits and then specialized on by the `Copier::copy` method.//! `Copier` uses the specialization traits to unpack the underlying file descriptors and//! additional prerequisites and constraints imposed by the wrapper types.//! Once it has obtained all necessary pieces and brought any wrapper types into a state where they//! can be safely bypassed it will attempt to use the `copy_file_range(2)`,//! `sendfile(2)` or `splice(2)` syscalls to move data directly between file descriptors.//! Since those syscalls have requirements that cannot be fully checked in advance it attempts//! to use them one after another (guided by hints) to figure out which one works and//! falls back to the generic read-write copy loop if none of them does.//! Once a working syscall is found for a pair of file descriptors it will be called in a loop//! until the copy operation is completed.//! Advantages of using these syscalls://! * fewer context switches since reads and writes are coalesced into a single syscall//!   and more bytes are transferred per syscall. This translates to higher throughput//!   and fewer CPU cycles, at least for sufficiently large transfers to amortize the initial probing.//! * `copy_file_range` creates reflink copies on CoW filesystems, thus moving less data and//!   consuming less disk space//! * `sendfile` and `splice` can perform zero-copy IO under some circumstances while//!   a naive copy loop would move every byte through the CPU.//! Drawbacks://! * copy operations smaller than the default buffer size can under some circumstances, especially//!   on older kernels, incur more syscalls than the naive approach would. As mentioned above//!   the syscall selection is guided by hints to minimize this possibility but they are not perfect.//! * optimizations only apply to std types. If a user adds a custom wrapper type, e.g. to report//!   progress, they can hit a performance cliff.//! * complexity// Bare metal platforms usually have very small amounts of RAM// (in the order of hundreds of KB)configure_builtins/// The configure builtins provides runtime support compiler-builtin features/// which require dynamic initialization to work as expected, e.g. aarch64/// outline-atomics./// The PAL (platform abstraction layer) contains platform-specific abstractions/// for implementing the features in the other submodules, e.g. UNIX fileexit_guardplatform_version// FIXME(117276): remove this, move feature implementations into individual//                submodules.// Make sure that this is used on some platforms at least.each_addrnetc// We want to re-use as much of Rust's stdlib code as possible,// and most of it is unixy, but with a lot of nesting.LookupHostinto_netcfrom_netcsgx_ineffectiveDEFAULT_FAKE_TTL/// Converts each address in `addr` into a hostname./// SGX doesn't support DNS resolution but rather accepts hostnames in/// the same place as socket addresses. So, to make e.g./// TcpStream::connect("example.com:80")`/// work, the DNS lookup returns a special error (`NonIpSockAddr`) instead,/// which contains the hostname being looked up. When `.to_socket_addrs()`/// fails, we inspect the error and try recover the hostname from it. If that/// succeeds, we thus continue with the hostname./// This is a terrible hack and leads to buggy code. For instance, when users/// use the result of `.to_socket_addrs()` in their own `ToSocketAddrs`/// implementation to select from a list of possible URLs, the only URL used/// will be that of the last item tried.// FIXME: This is a terrible, terrible hack. Fixing this requires Fortanix to// add a method for resolving addresses.addr_to_sockaddr// `Inner` includes `peer_addr` so that a `TcpStream` maybe correctly// reconstructed if `Socket::try_into_inner` fails.NonIpSockAddrsocket_addr_from_csocket_addr_to_cwrlen_tcvt_gai// This is used by sys_common code to abstract over Windows and Unix.IpV4MultiCastTypeip_v4_addr_to_cip_v6_addr_to_cip_v4_addr_from_cip_v6_addr_from_csocket_addr_v4_to_csocket_addr_v6_to_csocket_addr_v4_from_csocket_addr_v6_from_c/// A type with the same memory layout as `c::sockaddr`. Used in converting Rust level/// type over using `c::sockaddr_storage` is that this type is exactly as large as it/// needs to be and not a lot larger. And it can be initialized more cleanly from Rust.addr_family/// Converts the C socket address stored in `storage` to a Rust `SocketAddr`./// * `storage` must contain a valid C socket address whose length is no larger///   than `len`./// Sets the value of a socket option./// `T` must be the type associated with the given socket option./// Gets the value of a socket option.sockname/// Wraps a call to a platform function that returns a socket address./// * if `f` returns a success (i.e. `cvt` returns `Ok` when called on the///   return value), the buffer provided to `f` must have been initialized///   with a valid C socket address, the length of which must be written///   to the second argument.// address conversions// sockaddr and misc bindings// lookup_host// TCP streams// TCP listeners// UDPsocketsis_minus_oneIsMinusOneimpl_is_minus_one/// A variant of `cvt` for `getaddrinfo` which return 0 for a success./// Just to provide the same interface as sys/pal/unix/net.rs/// Returns the last error from the network subsystem.// This method is used by sys_common code to abstract over targets.no_lookup_host_duplicates// bionic libc makes no use of this flagon_resolver_failure// In versions of glibc prior to 2.26, there's a bug where the DNS resolver// will cache the contents of /etc/resolv.conf, so changes to that file on disk// can be ignored by a long-running program. That can break DNS lookups on e.g.// laptops where the network comes and goes. See// https://sourceware.org/bugzilla/show_bug.cgi?id=984. Note however that some// distros including Debian have patched glibc to fix this for a long time.// A workaround for this bug is to call the res_init libc function, to clear// the cached configs. Unfortunately, while we believe glibc's implementation// of res_init is thread-safe, we know that other implementations are not// (https://github.com/rust-lang/rust/issues/43592). Code here in std could// try to synchronize its res_init calls with a Mutex, but that wouldn't// protect programs that call into libc in other ways. So instead of calling// res_init unconditionally, we call it only when we detect we're linking// against glibc version < 2.26. (That is, when we both know its needed and// believe it's thread-safe).WasiSocketwinsock// re-exports from Windows API bindings.// The following two structs use a union in the generated bindings but// our cross-platform code expects a normal field so it's redefined here.// As a consequence, we also need to redefine other structs that use this struct.//! BSD socket compatibility shim//! Some Windows API types are not quite what's expected by our cross-platform//! net code. E.g. naming differences or different pointer types.tcp4TYPE_OF_SERVICETIME_TO_LIVEservice_bindingServiceProtocolDEFAULT_ADDRIpv4Addressget_mode_dataConfigDataTransmitDataread_innerReceiveDatawait_or_cancelCompletionToken/// Wait for an event to finish. This is checked by an atomic boolean that is supposed to be set/// to true in the event callback./// Optionally, allow specifying a timeout./// If a timeout is provided, the operation (specified by its `EFI_TCP4_COMPLETION_TOKEN`) is/// canceled and Error of kind TimedOut is returned./// Pointer to a valid `EFI_TCP4_COMPLETION_TOKEN`/// Abort an asynchronous connection, listen, transmission or receive request./// If token is NULL, then all pending tokens issued by EFI_TCP4_PROTOCOL.Connect(),/// EFI_TCP4_PROTOCOL.Accept(), EFI_TCP4_PROTOCOL.Transmit() or EFI_TCP4_PROTOCOL.Receive() are/// aborted./// Pointer to a valid `EFI_TCP4_COMPLETION_TOKEN` or NULLcreate_evtOwnedEventwait_for_flag"efiapi"toggle_atomic_flagLookupHostQuerytcpstreamtcplistenerNetErrorUnaddressable// Ok = 0,SocketInUse// AccessDenied = 3,// Finished = 5,// AlreadyUsed = 7,// this structure needs to be synchronized with what's in net/src/api.rsSendDataGetAddressunimpl/// This returns the raw fd of a Listener, so that it can also be used by the/// accept routine to replenish the Listener object after its handle has been converted into/// a TcpStream object.ReadOrPeek// millisecondssockaddr_to_buffrom_listenerread_or_peek// in milliseconds. The setting applies only to `recv` calls after the timeout is set.// in milliseconds. The setting applies only to `send` calls after the timeout is set.recv_inner// ------------- smoltcp base stack does not have multicast or broadcast support ---------------/// This module contains the implementations of `TcpStream`, `TcpListener` and/// `UdpSocket` as well as related functionality like DNS resolving.slice_debug_output/// Provides plumbing to `Vec::truncate` without giving full mutable access/// to the `Vec`./// The length must be at an `OsStr` boundary, according to/// `Slice::check_public_boundary`./// `OsStr::from_encoded_bytes_unchecked`). This encoding has no safetycheck_public_boundary//! The underlying OsString/OsStr implementation on Unix and many other//! systems: just a `Vec<u8>`/`[u8]`./// `OsStr::from_encoded_bytes_unchecked`). For this encoding, that means/// `other` must be valid UTF-8.from_mut_str//! An OsString/OsStr implementation that is guaranteed to be UTF-8./// `other` must be valid WTF-8./// Additionally, this method bypasses the WTF-8 surrogate joining, so/// either `self` must not end with a leading surrogate half, or `other`/// must not start with a trailing surrogate half.//! The underlying OsString/OsStr implementation on Windows is a//! wrapper around the "WTF-8" encoding; see the `wtf8` module for more.// This module contains code that is shared between all platforms, mostly utility or fallback code.// This explicitly does not include code that is shared between only a few platforms,// such as when reusing an implementation from `unix` or `unsupported`.// In those cases the desired code should be included directly using the #[path] attribute,// not moved to this module.// Currently `sys_common` contains a lot of code that should live in this module,// ideally `sys_common` would only contain platform-independent abstractions on top of `sys`.// Progress on this is tracked in #84187.// Make sure to stay under 4096 so the compiler doesn't insert a probe frame:// https://docs.rs/compiler_builtins/latest/compiler_builtins/probestack/index.htmlNUL_ERRrun_with_cstr_stack/// `bytes` must have a length less than `MAX_STACK_ALLOCATION`.run_with_cstr_allocatingstack_allocation_worksstack_allocation_failsheap_allocation_worksheap_allocation_failsbench_stack_path_allocbench_heap_path_allocFutex/// An atomic for use as a futex that is at least 32-bits but may be larger/// Must be the underlying type of FutexSmallFutexSmallPrimitive/// An atomic for use as a futex that is at least 8-bits but may be larger./// Must be the underlying type of SmallFutexfutex_wake_all"../unsupported/pipe.rs"abort_internal// SAFETY: must be called only once during runtime cleanup.runtime_entryIsNegativeimpl_is_negative//! System bindings for HermitCore//! This module contains the facade (aka platform-specific) implementations of//! OS level functionality for HermitCore.//! This is all super highly experimental and not actually intended for//! wide/production use yet, it's still all in the experimental category. This//! will likely change over time.//! Currently all functions here are basically stubs that immediately return//! errors. The hope is that with a portability lint we can turn actually just//! remove all this and just omit parts of the standard library if we're//! compiling for wasm. That way it's a compile time error for something that's//! guaranteed to be a runtime error!NSEC_PER_SECsub_timespecchecked_sub_instant/// underlying data structure. See [`Instant::checked_add`] for a version without panic./// Returns the amount of time elapsed from another instant to this one,/// or zero duration if that instant is later than this one./// Previous Rust versions panicked when `other` was later than `self`. Currently this/// method saturates. Future versions may reintroduce the panic in some circumstances./// See [Monotonicity]./// [Monotonicity]: Instant#monotonicitysub_timeint_tuint_tbool_t/// Kernel object IDTSK_SELF/// The current task.RELTIM/// Relative timeTMO/// Timeout (a valid `RELTIM` value or `TMO_FEVR`)TMO_FEVR/// The infinite timeout valueTMAX_RELTIM/// The maximum valid value of `RELTIM`SYSTIM/// System time/// Error code typeER_ID/// Error code type, `ID` on success/// Service call operational modeTWF_ORW/// OR waiting condition for an eventflagATR/// Object attributesTA_FIFO/// FIFO wait orderTA_WSGL/// Only one task is allowed to be in the waiting state for the eventflagTA_CLR/// The eventflag’s bit pattern is cleared when a task is released from the/// waiting state for that eventflag.FLGPTN/// Bit pattern of an eventflag/// Task or interrupt priorityTPRI_SELF/// The special value of `PRI` representing the current task's priority.TA_INHERIT/// Use the priority inheritance protocolTA_ACT/// Activate the task on creationTMAX_MAXSEM/// The maximum count of a semaphoreEXINF/// Callback parameter/// Task entrypointE_OK// Error codesE_SYSE_NOSPTE_RSFNE_RSATRE_PARE_IDE_CTXE_MACVE_OACVE_ILUSEE_NOMEME_NOIDE_NORESE_OBJE_NOEXSE_QOVRE_RLWAIE_TMOUTE_DLTE_CLSE_RASTERE_WBLKE_BOVRE_COMMsematrisemcntmaxsemT_CSEMflgatriflgptnT_CFLGmtxatrceilpriT_CMTXtskatrexinfitskpristkszstkT_CTSK"__asp3_acre_tsk"acre_tsk"__asp3_get_tid"get_tid"__asp3_dly_tsk"dly_tsk"__asp3_ter_tsk"ter_tsk"__asp3_del_tsk"del_tsk"__asp3_get_pri"get_pri"__asp3_rot_rdq"rot_rdq"__asp3_slp_tsk"slp_tsk"__asp3_tslp_tsk"tslp_tsk"__asp3_wup_tsk"wup_tsk"__asp3_unl_cpu"unl_cpu"__asp3_dis_dsp"dis_dsp"__asp3_ena_dsp"ena_dsp"__asp3_sns_dsp"sns_dsp"__asp3_get_tim"get_tim"__asp3_acre_flg"acre_flg"__asp3_del_flg"del_flg"__asp3_set_flg"set_flg"__asp3_clr_flg"clr_flg"__asp3_wai_flg"wai_flg"__asp3_twai_flg"twai_flg"__asp3_acre_mtx"acre_mtx"__asp3_del_mtx"del_mtx"__asp3_loc_mtx"loc_mtx"__asp3_ploc_mtx"ploc_mtx"__asp3_tloc_mtx"tloc_mtx"__asp3_unl_mtx"unl_mtxexd_tsk//! ABI for μITRON derivativeserItronError/// Wraps a μITRON error code./// Constructs `ItronError` from the specified error code. Returns `None` if the/// error code does not represent a failure or warning.err_if_negative/// Returns `Ok(er)` if `er` represents a success or `Err(_)` otherwise./// Gets the raw error code./// Describe the specified μITRON error code. Returns `None` if it's an/// undefined error code.expect_success/// Similar to `ItronError::err_if_negative(er).expect()` except that, while/// panicking, it prints the message to `panic_output` and aborts the program/// instead. This ensures the error message is not obscured by double/// This is useful for diagnosing creation failures of synchronization/// primitives that are used by `std`'s internal mechanisms. Such failures/// are common when the system is mis-configured to provide a too-small pool for/// kernel objects.expect_success_aborting/// Similar to `ItronError::err_if_negative(er).expect()` but aborts instead./// Use this where panicking is not allowed or the effect of the failure/// would be persistent.fail_aborting/// A mutex implemented by `dis_dsp` (for intra-core synchronization) and a/// spinlock (for inter-core synchronization).with_locked/// Acquire a lock.SpinIdOnceCell/// `OnceCell<(abi::ID, T)>` implemented by `dis_dsp` (for intra-core/// synchronization) and a spinlock (for inter-core synchronization)./// It's assumed that `0` is not a valid ID, and all kernel/// object IDs fall into range `1..=usize::MAX`.ID_UNINIT/// Assign the content without checking if it's already initialized or/// being initialized./// Warning: `f` must not perform a blocking operation, which/// includes panicking./// Gets the ID of the task in Running state. Panics on failure.current_task_id_aborting/// Gets the ID of the task in Running state. Aborts on failure.try_current_task_id/// Gets the ID of the task in Running state.task_priority/// Gets the specified task's priority. Panics on failure.try_task_priority/// Gets the specified task's priority.with_tmosreltim2durtest_dur2reltimstest_dur2tmosdur2reltims/// Split `Duration` into zero or more `RELTIM`s.dur2tmos/// Split `Duration` into one or more `TMO`s./// Split `Duration` into one or more API calls with timeout.with_tmos_strong/// Split `Duration` into one or more API calls with timeout. This function can/// handle spurious wakeups.FULL_BACKTRACE_DEFAULT//! Platform-dependent platform abstraction.//! The `std::sys` module is the abstracted interface through which//! `std` talks to the underlying operating system. It has different//! implementations for different operating system families, today//! just Unix and Windows, and initial support for Redox.//! The centralization of platform-specific code in this module is//! enforced by the "platform abstraction layer" tidy script in//! `tools/tidy/src/pal.rs`.//! This module is closely related to the platform-independent system//! integration code in `std::sys_common`. See that module's//! documentation for details.//! In the future it would be desirable for the independent//! implementations of this module to be extracted to their own crates//! that `std` can link to, thus enabling their implementation//! out-of-tree via crate replacement. Though due to the complex//! inter-dependencies within `std` that will be a challenging goal to//! achieve.motor_start// NOTE: Motor OS uses moto_rt::start() to initialize runtime (see above).rel_ptr// Do not remove inline: will result in relocation failurerel_ptr_mutENCLAVE_SIZEHEAP_BASEHEAP_SIZEheap_base/// Returns the base memory address of the heapheap_size/// Returns the size of the heap// For the same reason we use inline ASM here instead of an extern static to// locate the base/// Returns address at which current enclave is loaded.is_enclave_range/// Returns `true` if the specified memory range is in the enclave./// For safety, this function also checks whether the range given overflows,/// returning `false` if so.is_user_range/// Returns `true` if the specified memory range is in userspace.// runtime featuresreloc// library featuresEntryReturntcs_init// FIXME: this item should only exist if this is linked into an executable// (main function exists). If this is a library, the crate author should be// able to specify thisexit_with_codeabort_reentry// RT initialization logic is not compiled for testUserReftake_debug_panic_buf_ptrSgxPanicOutputempty_user_slicerelocate_elf_rela/// Gets the ID for the current thread. The ID is guaranteed to be unique among/// all currently running threads in the enclave, and it is guaranteed to be/// constant for the lifetime of the thread. More specifically for SGX, there/// is a one-to-one correspondence of the ID to the address of the TCS.sync_bitsetUSIZE_BITSTLS_KEYSTLS_KEYS_BITSET_SIZE// Same as POSIX minimum"_ZN16__rust_internals3std3sys3pal3sgx3abi3tls14TLS_KEY_IN_USEE"TLS_KEY_IN_USESyncBitset"_ZN16__rust_internals3std3sys3pal3sgx3abi3tls14TLS_DESTRUCTORE"TLS_DESTRUCTORget_tls_ptrset_tls_ptrActiveTlstest_dataset_get_clear/// A bitset that can be used synchronously.SYNC_BITSET_INITSyncBitsetIter/// Not atomic./// Sets any unset bit. Not atomic. Returns `None` if all bits were/// observed to be set.elem_idxUserSafeSized/// A type that can be safely read from or written to userspace./// Non-exhaustive list of specific requirements for reading and writing:/// * **Type is `Copy`** (and therefore also not `Drop`). Copies will be///   created when copying from/to userspace. Destructors will not be called./// * **No references or Rust-style owned pointers** (`Vec`, `Arc`, etc.). When///   reading from userspace, references into enclave memory must not be///   created. Also, only enclave memory is considered managed by the Rust///   compiler's static analysis. When reading from userspace, there can be no///   guarantee that the value correctly adheres to the expectations of the///   type. When writing to userspace, memory addresses of data in enclave///   memory must not be leaked for confidentiality reasons. `User` and///   `UserRef` are also not allowed for the same reasons./// * **No fat pointers.** When reading from userspace, the size or vtable///   pointer could be automatically interpreted and used by the code. When///   writing to userspace, memory addresses of data in enclave memory (such///   as vtable pointers) must not be leaked for confidentiality reasons./// Non-exhaustive list of specific requirements for reading from userspace:/// * **Any bit pattern is valid** for this type (no `enum`s). There can be no///   type, so any value must be valid for this type./// Non-exhaustive list of specific requirements for writing to userspace:/// * **No pointers to enclave memory.** Memory addresses of data in enclave///   memory must not be leaked for confidentiality reasons./// * **No internal padding.** Padding might contain previously-initialized///   secret data stored at that memory location and must not be leaked for///   confidentiality reasons./// Equivalent to `align_of::<Self>`.from_raw_sized_unchecked/// Constructs a pointer to `Self` given a memory range in user space./// N.B., this takes a size, not a length!/// The caller must ensure the memory range is in user memory, is the/// correct size and is correctly aligned and points to the right type.from_raw_sized/// Constructs a pointer to `Self` given a memory range./// The caller must ensure the memory range points to the correct type./// This function panics if:/// * the pointer is not aligned./// * the pointer is null./// * the pointed-to range does not fit in the address space./// * the pointed-to range is not in user memory.check_ptr/// Checks if a pointer may point to `Self` in user memory./// The caller must ensure the memory range points to the correct type and/// length (if this is a slice).UserSafe/// A type that can be represented in memory as one or more `UserSafeSized`s./// * the element size is not a factor of the size/// A reference to some type in userspace memory. `&UserRef<T>` is equivalent/// to `&T` in enclave memory. Access to the memory is only allowed by copying/// to avoid TOCTTOU issues. After copying, code should make sure to completely/// check the value before use./// It is also possible to obtain a mutable reference `&mut UserRef<T>`. Unlike/// regular mutable references, these are not exclusive. Userspace may always/// write to the backing memory at any time, so it can't be assumed that there/// the pointed-to memory is uniquely borrowed. The two different reference types/// are used solely to indicate intent: a mutable reference is for writing to/// user memory, an immutable reference for reading from user memory./// An owned type in userspace memory. `User<T>` is equivalent to `Box<T>` in/// enclave memory. Access to the memory is only allowed by copying to avoid/// TOCTTOU issues. The user memory will be freed when the value is dropped./// After copying, code should make sure to completely check the value beforenew_userrefNewUserRef/// Returns a pointer for writing to the value.UserSafeCopyDestination/// A type which can a destination for safely copying from userspace./// Requires that `T` and `Self` have identical layouts.new_uninit_bytes// This function returns memory that is practically uninitialized, but is// not considered "unspecified" or "undefined" for purposes of an// optimizing compiler. This is achieved by returning a pointer from// from outside as obtained by `super::alloc`.new_from_enclave/// Copies `val` into freshly allocated space in user memory./// Creates an owned `User<T>` from a raw pointer./// The caller must ensure `ptr` points to `T`, is freeable with the `free`/// usercall and the alignment of `T`, and is uniquely owned./// * The pointer is not aligned/// * The pointer is null/// * The pointed-to range is not in user memory/// Converts this value into a raw pointer. The value will no longer be/// automatically freed./// Allocates space for `T` in user memory./// Allocates space for a `[T]` of `n` elements in user memory./// Creates an owned `User<[T]>` from a raw thin pointer and a slice length./// The caller must ensure `ptr` points to `len` elements of `T`, is/// freeable with the `free` usercall and the alignment of `T`, and is/// uniquely owned./// * The pointed-to range does not fit in the address spaceu64_align_to_guaranteed/// Divide the slice `(ptr, len)` into three parts, where the middle part is/// aligned to `u64`./// The return values `(prefix_len, mid_len, suffix_len)` add back up to `len`./// The return values are such that the memory region `(ptr + prefix_len,/// mid_len)` is the largest possible region where `ptr + prefix_len` is aligned/// to `u64` and `mid_len` is a multiple of the byte size of `u64`. This means/// that `prefix_len` and `suffix_len` are guaranteed to be less than the byte/// size of `u64`, and that `(ptr, prefix_len)` and `(ptr + prefix_len +/// mid_len, suffix_len)` don't straddle an alignment boundary.// Standard Rust functions such as `<[u8]>::align_to::<u64>` and// `<*const u8>::align_offset` aren't _guaranteed_ to compute the largest// possible middle region, and as such can't be used.copy_quadwordscopy_to_userspace/// Copies `len` bytes of data from enclave pointer `src` to userspace `dst`/// This function mitigates stale data vulnerabilities by ensuring all writes to untrusted memory are either:///  - preceded by the VERW instruction and followed by the MFENCE; LFENCE instruction sequence///  - or are in multiples of 8 bytes, aligned to an 8-byte boundary/// * The `src` pointer is null/// * The `dst` pointer is null/// * The `src` memory range is not in enclave memory/// * The `dst` memory range is not in user memory///  - https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00615.html///  - https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/technical-documentation/processor-mmio-stale-data-vulnerabilities.html#inpage-nav-3-2-2copy_from_userspace/// Copies `len` bytes of data from userspace pointer `src` to enclave pointer `dst`/// This function mitigates AEPIC leak vulnerabilities by ensuring all reads from untrusted memory are 8-byte aligned/// * The `src` memory range is not in user memory/// * The `dst` memory range is not in enclave memory///  - https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00657.html///  - https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/advisory-guidance/stale-data-read-from-xapic.html/// Creates a `&UserRef<[T]>` from a raw pointer./// The caller must ensure `ptr` points to `T`./// Creates a `&mut UserRef<[T]>` from a raw pointer. See the struct/// documentation for the nuances regarding a `&mut UserRef<T>`.copy_from_enclave/// Copies `val` into user memory./// This function panics if the destination doesn't have the same size as/// the source. This can happen for dynamically-sized types such as slices.copy_to_enclave/// Copies the value from user memory and place it into `dest`.as_raw_ptr/// Obtain a raw pointer from this reference.as_raw_mut_ptrto_enclave/// Copies the value from user memory into enclave memory./// Creates a `&UserRef<[T]>` from a raw thin pointer and a slice length./// The caller must ensure `ptr` points to `n` elements of `T`./// Creates a `&mut UserRef<[T]>` from a raw thin pointer and a slice length./// See the struct documentation for the nuances regarding a/// `&mut UserRef<T>`./// Obtain a raw pointer to the first element of this user slice./// Obtain the number of elements in this user slice.append_to_enclave_vec/// Copies the value from user memory and appends it to `dest`./// Copies the value from user memory into a vector in enclave memory.// FIXME: should be implied by [T]: UserSafe?/// Immutable user slice iterator/// This struct is created by the `iter` method on `UserRef<[T]>`./// Mutable user slice iterator/// This struct is created by the `iter_mut` method on `UserRef<[T]>`.copy_user_buffer/// Copies the user memory range pointed to by the user `ByteBuffer` to/// enclave memory./// This function panics if, in the user `ByteBuffer`:/// Usercall `read`. See the ABI documentation for more information./// This will do a single `read` usercall and scatter the read data among/// `bufs`. To read to a single buffer, just pass a slice of length one./// Usercall `read` with an uninitialized buffer. See the ABI documentation for/// Usercall `read_alloc`. See the ABI documentation for more information./// Usercall `write`. See the ABI documentation for more information./// This will do a single `write` usercall and gather the written data from/// `bufs`. To write from a single buffer, just pass a slice of length one./// Usercall `flush`. See the ABI documentation for more information./// Usercall `close`. See the ABI documentation for more information.string_from_bytebuffer/// Usercall `bind_stream`. See the ABI documentation for more information./// Usercall `accept_stream`. See the ABI documentation for more information./// Usercall `connect_stream`. See the ABI documentation for more information./// Usercall `launch_thread`. See the ABI documentation for more information./// Usercall `exit`. See the ABI documentation for more information./// Usercall `wait`. See the ABI documentation for more information./// Makes an effort to wait for a non-spurious event at least as long as/// Note that in general there is no guarantee about accuracy of time and/// timeouts in SGX model. The enclave runner serving usercalls may lie about/// current time and/or ignore timeout values./// Once the event is observed, `should_wake_up` will be used to determine/// whether or not the event was spurious./// Usercall `send`. See the ABI documentation for more information./// Usercall `insecure_time`. See the ABI documentation for more information./// Usercall `alloc`. See the ABI documentation for more information.check_os_error/// Return typefrom_sgx_result/// Translate the raw result of an SGX usercall.FromSgxResultUsercallReturnusercall/// Performs the raw usercall operation as defined in the ABI calling convention./// The caller must ensure to pass parameters appropriate for the usercall `nr`/// and to observe all requirements specified in the ABI./// Panics if `nr` is `0`./// A value passed or returned in a CPU register.from_register/// Translate a Register to Self.into_register/// Translate self to a Register./// Translate a type from/to Register to be used as an argument.from_registers/// Translate a pair of Registers to the raw usercall return value.define_usercallsdefine_rareturn_type_is_abortenclave_usercalls_internal_define_usercalls// In this macro: using `$r:tt` because `$r:ty` doesn't match ! in `return_type_is_abort`invoke_with_usercallstest_copy_to_userspace_functiontest_copy_from_userspace_function// Verify that the byte pattern libunwind uses to initialize an RwLock is// equivalent to the value of RwLock::new(). If the value changes,// `src/UnwindRustSgx.h` in libunwind needs to be changed too.__rust_rwlock_rdlock__rust_rwlock_wrlock__rust_rwlock_unlock__rust_print_err//! The functions in this module are needed by libunwind. These symbols are named//! in pre-link args for the target specification, so keep that in sync.libunwind_integrationthread_parking/// This function is used to implement functionality that simply doesn't exist./// Programs relying on this functionality will need to deal with the error./// This function is used to implement various functions that doesn't exist,/// but the lack of which might not be reason for error. If no error is/// returned, the program might very well be able to function normally. This is/// what happens when `SGX_INEFFECTIVE_ERROR` is set to `true`. If it is/// `false`, the behavior is the same as `unsupported`.// This function is needed by libunwind. The symbol is named in// pre-link args for the target specification, so keep that in sync.// Note: contrary to the `__rust_abort` in `crate::rt`, this uses `no_mangle`//       because it is actually used from C code. Because symbols annotated with//       #[rustc_std_internal_symbol] get mangled, this will not lead to linker//       conflicts.//! System bindings for the Fortanix SGX platform//! OS level functionality for Fortanix SGX.// FIXME: this entire module systematically confuses pointers and integersspin_mutexunsafe_listtry_lock_or_falseUnsafeListUnsafeListEntry/// TCS address of the thread that is waiting/// Whether this thread has been notified to be awokenWaitEntry/// An queue entry in a `WaitQueue`.WaitQueueWaitVariable/// Data stored with a `WaitQueue` alongside it. This ensures accesses to the/// queue and the data are synchronized, since the type itself is not `Sync`./// Consumers of this API should use a synchronization primitive for shared/// access, such as `SpinMutex`.lock_varlock_var_mutNotifiedTcs_countmutex_guardnotified_tcsWaitGuard/// An RAII guard that will notify a set of target threads as well as unlock/// a mutex on drop.// We use an inner Mutex here to protect the data in the face of spurious// wakeups./// A queue of threads that are waiting on some synchronization primitive./// `UnsafeList` entries are allocated on the waiting thread's stack. This/// avoids any global locking that might happen in the heap allocator. This is/// safe because the waiting thread will not return from that stack frame until/// after it is notified. The notifying thread ensures to clean up any/// references to the list entries before sending the wakeup event./// Adds the calling thread to the `WaitVariable`'s wait queue, then wait/// until a wakeup event./// This function does not return until this thread has been awoken. When `before_wait` panics,/// this function will abort./// until a wakeup event or timeout. If event was observed, returns true./// If not, it will remove the calling thread from the wait queue./// When `before_wait` panics, this function will abort./// Either find the next waiter on the wait queue, or return the mutex/// guard unchanged./// If a waiter is found, a `WaitGuard` is returned which will notify the/// waiter when it is dropped./// Either find any and all waiters on the wait queue, or return the mutex/// If at least one waiter is found, a `WaitGuard` is returned which will/// notify all waiters when it is dropped.//! A simple queue implementation for synchronization primitives.//! This queue is used to implement condition variable and mutexes.//! Users of this API are expected to use the `WaitVariable<T>` type. Since//! that type is not `Sync`, it needs to be protected by e.g., a `SpinMutex` to//! allow shared access.//! Since userspace may send spurious wake-ups, the wakeup event state is//! recorded in the enclave. The wakeup event state is protected by a spinlock.//! The queue and associated wait state are stored in a `WaitVariable`./// Lock the Mutex or return false.//! Trivial spinlock-based implementation of `sync::Mutex`.// FIXME: Perhaps use Intel TSX to avoid locking?assert_empty/// List must be valid.init_emptypush_poppush_removepush_remove_popcomplex_pushes_popshead_tailhead_tail_entry// WARNING: self-referential struct!/// Pushes an entry onto the back of the list./// The entry must remain allocated until the entry is removed from the/// list AND the caller who popped is done using the entry. Special/// care must be taken in the caller of `push` to ensure unwinding does/// not destroy the stack frame containing the entry./// Pops an entry from the front of the list./// The caller must make sure to synchronize ending the borrow of the/// return value and deallocation of the containing entry./// Removes an entry from the list./// The caller must ensure that `entry` has been pushed onto `self`/// prior to this call and has not moved since then.//! A doubly-linked list where callers are in charge of memory allocation//! of the nodes in the list.SOLID_MAX_PATHSOLID_FS_OpenSOLID_FS_CloseSOLID_FS_ReadSOLID_FS_WriteSOLID_FS_LseekSOLID_FS_SyncSOLID_FS_FtellSOLID_FS_FeofSOLID_FS_FsizeSOLID_FS_TruncateSOLID_FS_OpenDirSOLID_FS_CloseDirSOLID_FS_ReadDirSOLID_FS_StatSOLID_FS_UnlinkSOLID_FS_RenameSOLID_FS_ChmodSOLID_FS_UtimeSOLID_FS_Mkdir//! `solid_fs.h`itron// `solid_types.h`SOLID_ERR_NOTFOUNDSOLID_ERR_NOTSUPPORTEDSOLID_ERR_EBADFSOLID_ERR_INVALIDCONTENTSOLID_ERR_NOTUSEDSOLID_ERR_ALREADYUSEDSOLID_ERR_OUTOFBOUNDSOLID_ERR_BADSEQUENCESOLID_ERR_UNKNOWNDEVICESOLID_ERR_BUSYSOLID_ERR_TIMEOUTSOLID_ERR_INVALIDACCESSSOLID_ERR_NOTREADYSOLID_RTC_TIME// `solid_rtc.h`SOLID_RTC_ReadTimeSOLID_LOG_writeSOLID_TLS_AddDestructorrwl_loc_rdlrwl_loc_wrlrwl_ploc_rdlrwl_ploc_wrlrwl_unl_rwlrwl_acre_rwlrwl_del_rwl// `solid_log.h`// `solid_mem.h`// `solid_rng.h`// `rwlock.h`SOLID_NET_ERR_BASEsin_lensin6_lens2_lens2_data1s2_data2SOLID_NET_FD_SETSIZE/// This value can be chosen by an applicationnum_fds"SOLID_NET_StrError"SOLID_NET_GetLastError"SOLID_NET_Accept""SOLID_NET_Bind""SOLID_NET_Connect""SOLID_NET_Close""SOLID_NET_Dup""SOLID_NET_GetPeerName""SOLID_NET_GetSockName""SOLID_NET_GetSockOpt""SOLID_NET_SetSockOpt""SOLID_NET_Ioctl""SOLID_NET_Listen""SOLID_NET_Recv""SOLID_NET_Read""SOLID_NET_Readv""SOLID_NET_RecvFrom""SOLID_NET_Send""SOLID_NET_SendMsg""SOLID_NET_SendTo""SOLID_NET_Shutdown""SOLID_NET_Socket""SOLID_NET_Write""SOLID_NET_Writev""SOLID_NET_FreeAddrInfo""SOLID_NET_GetAddrInfo""SOLID_NET_Select"SolidError/// Describe the specified SOLID error code. Returns `None` if it's an/// The SOLID error codes are a superset of μITRON error codes."../itron"// `error` is `pub(crate)` so that it can be accessed by `itron/error.rs` as// `crate::sys::error`as_io_error// `solid` directly maps `errno`s to μITRON error codes.from_time_t"../unix/time.rs""../unix/sync"// Trusted Applications are loaded as dynamic libraries on Teeos,// so this should never be called.// this is not guaranteed to run, for example when the program aborts.// Note: code below is 1:1 copied from unix/mod.rscvt_nz//! System bindings for the Teeos platform//! OS level functionality for Teeos.// Hardcoded to return 4096, since `sysconf` is only implemented as a stub.//! Implementation of `std::os` functionality for teeos// Everything below are stubs and copied from unsupported.rs"../unsupported/common.rs""../unsupported/os.rs""../unsupported/time.rs"//! System bindings for the Trusty OS.device_path_to_textBootInstallMultipleProtocolInterfacesBootUninstallMultipleProtocolInterfaceslocate_handles/// Locates Handles with a particular Protocol GUID./// Implemented using `EFI_BOOT_SERVICES.LocateHandles()`./// Returns an array of [Handles](r_efi::efi::Handle) that support a specified protocol.open_protocol/// Open Protocol on a handle./// Internally just a call to `EFI_BOOT_SERVICES.OpenProtocol()`./// Queries a handle to determine if it supports a specified protocol. If the protocol is/// supported by the handle, it opens the protocol on behalf of the calling agent./// The protocol is opened with the attribute GET_PROTOCOL, which means the caller is not required/// to close the protocol interface with `EFI_BOOT_SERVICES.CloseProtocol()`image_handle_protocol/// Gets the Protocol for current system handle./// Note: Some protocols need to be manually freed. It is the caller's responsibility to do so.device_node_to_textruntime_servicesRuntimeServices/// Gets RuntimeServices.OwnedDevicePathDevicePathIteratorDevicePathNodesub_typeis_end_instanceOwnedProtocol/// Protocols installed by Rust side on a handle.// FIXME: Consider using unsafe trait for matching protocol with guidOwnedTablefrom_table_headerTableHeaderfrom_tableSystemTableos_string_from_raw/// Create OsString from a pointer to NULL terminated UTF-16 stringos_string_to_raw/// Create NULL terminated UTF-16 stringopen_shellget_device_path_from_map/// Get device path protocol associated with shell mapping./// returns None in case no such mapping is existsservice_guidchild_handle/// Helper for UEFI Protocols which are created and destroyed using/// [EFI_SERVICE_BINDING_PROTOCOL](https://uefi.org/specs/UEFI/2.11/11_Protocols_UEFI_Driver_Model.html#efi-service-binding-protocol)create_childTplEventNotify/// SAFETY: Assumes that ptr is a non-null valid UEFI eventipv4_to_r_efiipv4_from_r_efi/// This type is intended for use with ZSTs. Since such types are unsized, a reference to such types/// is not valid in Rust. Thus, only pointers should be used when interacting with such types.//! Contains most of the shared UEFI specific stuff. Some of this might be moved to `std::os::uefi`//! if needed but no point in adding extra public API when there is not Std support for UEFI in the//! first place//! Some Nomenclature//! * Protocol://! - Protocols serve to enable communication between separately built modules, including drivers.//! - Every protocol has a GUID associated with it. The GUID serves as the name for the protocol.//! - Protocols are produced and consumed.//! - More information about protocols can be found [here](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/3_foundation/36_protocols_and_handles)EXIT_BOOT_SERVICE_EVENT/// - must be called only once during runtime initialization./// - argc must be 2./// - argv must be &[Handle, *mut SystemTable]./// this is not guaranteed to run, for example when the program aborts./// - must be called only once during runtime cleanup.exit_boot_service_handler/// Disable access to BootServices if `EVT_SIGNAL_EXIT_BOOT_SERVICES` is signaled//! Platform-specific extensions to `std` for UEFI platforms.//! Provides access to platform-level information on UEFI platforms, and//! exposes UEFI-specific functions that would otherwise be inappropriate asloaded_image_device_pathsystem_time_internalto_uefiSECS_IN_MINUTEMAX_UEFI_TIMEuefi_time_cmp// UEFI Time cannot implement Eq due to uninitilaized pad1 and pad2systemtime_startsystemtime_utc_startsystemtime_endmin_timemax_timeio_slice_singleio_slice_mut_singleio_slice_multiio_slice_basicio_slice_mut_basic//! These tests are not run automatically right now. Please run these tests manually by copying them//! to a separate project when modifying any related code.// UEFI IoSlice and IoSliceMut Tests// Strictly speaking, vectored read/write types for UDP4, UDP6, TCP4, TCP6 are defined// separately in the UEFI Spec. However, they have the same signature. These tests just ensure// that `IoSlice` and `IoSliceMut` are compatible with the vectored types for all the// networking protocols./// When a Timezone is specified, the stored Duration is in UTC. If timezone is unspecified, then/// the timezone is assumed to be in UTC./// UEFI SystemTime is stored as Duration from 1900-01-01-00:00:00 with timezone -1440 as anchorto_uefi_loose/// Create UEFI Time with the closest timezone (minute offset) that still allows the time to beSECS_IN_HOURSECS_IN_DAYSYSTEMTIME_TIMEZONE/// This algorithm is a modified form of the one described in the post/// https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html/// The changes are to use 1900-01-01-00:00:00 with timezone -1440 as anchor instead of UNIX/// epoch used in the original algorithm./// This algorithm is a modified version of the one described in the post:/// https://howardhinnant.github.io/date_algorithms.html#clive_from_daysmul_div_u64NS_PER_SECtimestamp_protocoltimestamp_rdtscinstant_internalzx_time_tZX_TIME_INFINITEzx_clock_get_monotoniczx_handle_tZX_HANDLE_INVALIDzx_handle_close/// A safe wrapper around `zx_handle_t`.zx_futex_tzx_object_wait_onezx_signals_tzx_futex_waitzx_futex_wakezx_futex_wake_single_ownerzx_thread_selfZX_PROP_NAMEzx_object_set_propertyZX_OBJECT_SIGNAL_3ZX_TASK_TERMINATEDzx_object_info_topic_t// The upper four bits gives the minor version.ZX_INFO_PROCESSzx_info_process_flags_treturn_codezx_info_process_t// Returned for topic ZX_INFO_PROCESSzx_object_get_infolocal_fdtarget_fdfdio_spawn_action_tfdio_spawn_etcfdio_fd_clonefdio_fd_createzx_task_killFDIO_SPAWN_CLONE_JOBFDIO_SPAWN_CLONE_LDSVCFDIO_SPAWN_CLONE_NAMESPACEFDIO_SPAWN_CLONE_ENVIRONFDIO_SPAWN_CLONE_UTC_CLOCKFDIO_SPAWN_ACTION_TRANSFER_FDZX_OKZX_ERR_NOT_SUPPORTEDZX_ERR_INVALID_ARGSZX_ERR_BAD_HANDLEZX_ERR_WRONG_TYPEZX_ERR_BAD_STATEZX_ERR_TIMED_OUTzx_cvt//////////// Time ///////////////// Handles /////////////// Futex //////////////////// Properties //// Signals ///////////////////// Object info /////////////////// Processes //// fdio_spawn_etc flags// fdio_spawn_etc actions////////////// Errors ///// Waits for a `futex_wake` operation to wake us./// Returns directly if the futex doesn't hold the expected value./// Returns false on timeout, and true in all other cases./// Wakes up one thread that's blocked on `futex_wait` on this futex./// Returns true if this actually woke up such a thread,/// or false if no thread was waiting on this futex./// On some platforms, this always returns false./// Wakes up all threads that are waiting on `futex_wait` on this futex.test_command_pidfdtest_pidfdprobe_pidfd_supportstack_overflow// See `fn init()` in `library/std/src/rt.rs` for docs on `sigpipe`.ON_BROKEN_PIPE_FLAG_USED// This is set (up to once) in reset_sigpipe.on_broken_pipe_flag_used/// Converts native return values to Result using the *-1 means error is in `errno`*  convention./// Non-error values are `Ok`-wrapped./// `-1` → look at `errno` → retry on `EINTR`. Otherwise `Ok()`-wrap the closure return value.// Not used on all platforms./// Zero means `Ok()`, all other values are treated as raw OS errors. Does not look at `errno`.// libc::abort() will run the SIGABRT handler.  That's fine because anyone who// installs a SIGABRT handler already has to expect it to run in Very Bad// situations (eg, malloc crashing).// Current glibc's abort() function unblocks SIGABRT, raises SIGABRT, clears the// SIGABRT handler and raises it again, and then starts to get creative.// See the public documentation for `intrinsics::abort()` and `process::abort()`// for further discussion.// There is confusion about whether libc::abort() flushes stdio streams.// libc::abort() is required by ISO C 99 (7.14.1.1p5) to be async-signal-safe,// so flushing streams is at least extremely hard, if not entirely impossible.// However, some versions of POSIX (eg IEEE Std 1003.1-2001) required abort to// do so.  In 1003.1-2004 this was fixed.// glibc's implementation did the flush, unsafely, before glibc commit// 91e7cf982d01 `abort: Do not flush stdio streams [BZ #15436]` by Florian// Weimer.  According to glibc's NEWS://    The abort function terminates the process immediately, without flushing//    stdio streams.  Previous glibc versions used to flush streams, resulting//    in deadlocks and further data corruption.  This change also affects//    process aborts as the result of assertion failures.// This is an accurate description of the problem.  The only solution for// program with nontrivial use of C stdio is a fixed libc - one which does not// try to flush in abort - since even libc-internal errors, and assertion// failures generated from C, will go via abort().// On systems with old, buggy, libcs, the impact can be severe for a// multithreaded C program.  It is much less severe for Rust, because Rust// stdlib doesn't use libc stdio buffering.  In a typical Rust program, which// does not use C stdio, even a buggy libc::abort() is, in fact, safe.test_glibc_versiontest_parse_glibc_versiontest_confstr// Smoke check `confstr`, do it for several hint values, to ensure our resizing// logic is correct.PATH_SEPARATORffi_const// SAFETY: this will always return the same pointer on a given thread./// Sets the platform-specific value of errno// needed for readdir and syscall!// but not all target cfgs actually end up using it/// Gets a detailed string description for the given error number.// This can't just be `impl Iterator` because that requires `'a` to be live on// drop (see #146045).glibc_versionparse_glibc_version// Returns Some((major, minor)) if the string is a valid "x.y" version,// ignoring any extra dot-separated parts. Otherwise return None.//! Implementation of `std::os` functionality for unix systems// lots of cfg code here// FIXME: This function seems legitimately unused.as_file_desc// Anonymous pipesguard_page_rangeSPIN_LOCKTHREAD_INFO// This uses a `BTreeMap` instead of a hashmap since it supports constant// initialization and automatically reduces the amount of memory used when// items are removed.UnlockOnDropwith_current_info/// Get the current thread's information, if available./// Calling this function might freeze other threads if they attempt to modify/// their thread information. Thus, the caller should ensure that the process/// is aborted shortly after this function is called./// This function is guaranteed to be async-signal-safe if `f` is too.spin_lock_in_setupset_current_infodelete_current_info//! TLS, but async-signal-safe.//! Unfortunately, because thread local storage isn't async-signal-safe, we//! cannot soundly use it in our stack overflow handler. While this works//! without problems on most platforms, it can lead to undefined behaviour//! on others (such as GNU/Linux). Luckily, the POSIX specification documents//! two thread-specific values that can be accessed in asynchronous signal//! handlers: the value of `pthread_self()` and the address of `errno`. As//! `pthread_t` is an opaque platform-specific type, we use the address of//! `errno` here. As it is thread-specific and does not change over the//! lifetime of a thread, we can use `&errno` as a key for a `BTreeMap`//! that stores thread-specific data.//! Concurrent access to this map is synchronized by two locks – an outer//! [`Mutex`] and an inner spin lock that also remembers the identity of//! the lock owner://! * The spin lock is the primary means of synchronization: since it only//!   uses native atomics, it can be soundly used inside the signal handle//!   as opposed to [`Mutex`], which might not be async-signal-safe.//! * The [`Mutex`] prevents busy-waiting in the setup logic, as all accesses//!   there are performed with the [`Mutex`] held, which makes the spin-lock//!   redundant in the common case.//! * Finally, by using the `errno` address as the locked value of the spin//!   lock, we can detect cases where a SIGSEGV occurred while the thread//!   info is being modified.make_handler// This is intentionally not enabled on iOS/tvOS/watchOS/visionOS, as it uses// several symbols that might lead to rejections from the App Store, namely// `sigaction`, `sigaltstack`, `sysctlbyname`, `mmap`, `munmap` and `mprotect`.// This might be overly cautious, though it is also what Swift does (and they// usually have fewer qualms about forwards compatibility, since the runtime// is shipped with the OS):// <https://github.com/apple/swift/blob/swift-5.10-RELEASE/stdlib/public/runtime/CrashHandlerMacOS.cpp>TIMESPEC_MAXTIMESPEC_MAX_CAPPED/// `init` must have been called on this instance./// * `init` must have been called on this instance./// * `mutex` must be locked by the current thread./// * This condition variable may only be used with the same mutex.// Apple platforms (since macOS version 10.4 and iOS version 2.0) have// `pthread_cond_timedwait_relative_np`, a non-standard extension that// measures timeouts based on the monotonic clock and is thus resilient// against wall-clock changes.PRECISE_TIMEOUTCLOCK/// May only be called once per instance of `Self`.// `pthread_cond_timedwait_relative_np` measures the timeout// based on the monotonic clock.// `pthread_condattr_setclock` is unfortunately not supported on these platforms./// * If `init` was not called on this instance, reentrant locking causes///   undefined behaviour./// * Destroying a locked mutex causes undefined behaviour./// The mutex must be locked by the current thread.AttrGuard___lwp_park60// Only used on NetBSD. If other platforms start using id-based parking, use// separate modules for each platform.// Used for pthread condvar timeoutsCLOCK_IDinto_timespec/// A pointer to the nul-terminated name of the symbol.// Use a pointer instead of `&'static CStr` to save space.DlsymWeak/// If the signature of `F` does not match the signature of the symbol (if/// it exists), calling the function pointer returned by `get()` isweak_linkage// GNU/Linux needs the `dlsym` variant to avoid linking to private glibc symbols.//! Some I/O operations we do in std require newer versions of OSes but we need//! to maintain binary compatibility with older releases for now. In order to//! use the new functionality when available we use this module for detection.//! really workable with ELF. Otherwise, use dlsym to get the symbol value at//! and to avoid creating dependencies on GLIBC_PRIVATE symbols. It assumes that//! we've been dynamically linked to the library the symbol comes from, but that//! is currently always the case for things like libpthread/libc.//! A long time ago this used weak linkage for the __pthread_get_minstack//! dependency on libc6 (#23628) because it is GLIBC_PRIVATE. We now use `dlsym`//! for a runtime lookup of that symbol to avoid the ELF versioned dependency.// This file is included by both implementations of `weak!`.weak_existingweak_missingweak_ptrExternWeakunix_traitsunsupported_commonunsupported_osunsupported_time"../wasm/atomics/futex.rs"//! System bindings for the wasm/web platform//! OS level functionality for wasm.// The following exports are listed individually to work around Rust's glob// import conflict rules. If we glob export `helpers` and `common` together,// then the compiler complains about conflicts.__wasilibc_get_environ// Add a few symbols not in upstream `libc` just yet.Clockidfrom_wasi_timestampto_wasi_timestampFORCE_CODEGEN_OF_CABI_REALLOC"weak"cabi_realloc//! This module contains a canonical definition of the `cabi_realloc` function//! for the component model.//! The component model's canonical ABI for representing datatypes in memory//! makes use of this function when transferring lists and strings, for example.//! This function behaves like C's `realloc` but also takes alignment into//! account.//! Components are notably not required to export this function, but nearly//! all components end up doing so currently. This definition in the standard//! library removes the need for all compilations to define this themselves.//! More information about the canonical ABI can be found at//! <https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md>//! Note that the name of this function is not standardized in the canonical ABI//! at this time. Instead it's a convention of the "componentization process"//! where a core wasm module is converted to a component to use this name.//! Additionally this is not the only possible definition of this function, so//! this is defined as a "weak" symbol. This means that other definitions are//! allowed to overwrite it if they are present in a compilation."../wasip1/os.rs""../wasip1/helpers.rs"//! System bindings for the wasi preview 2 target.//! This is the next evolution of the original wasi target, and is intended to//! replace that target over time.//! To begin with, this target mirrors the wasi target 1 to 1, but over//! time this will change significantly.as_duration/// Wait for a futex_wake operation to wake us."atomics/futex.rs"//! OS level functionality for wasm. Note that this wasm is *not* the emscripten//! or wasi wasm, so we have no runtime here.wide_strcheck_utf16test_utf16_macros/// Creates a null-terminated UTF-16 string from a str./// Creates a UTF-16 string from a str without null termination.utf16_len/// Gets the UTF-16 length of a UTF-8 string, for use in the wide_str macro.UTF16_LEN/// Const convert UTF-8 to UTF-16, for use in the wide_str macro./// Note that this is designed for use in const contexts so is not optimized.win32_size_of/// Helper method for getting the size of `T` as a u32./// Errors at compile time if the size would overflow./// While a type larger than u32::MAX is unlikely, it is possible if only because of a bug./// However, one key motivation for this function is to avoid the temptation to/// use frequent `as` casts. This is risky because they are too powerful./// For example, the following will compile today:/// `size_of::<u64> as u32`/// Note that `size_of` is never actually called, instead a function pointer is/// converted to a `u32`. Clippy would warn about this but, alas, it's not run/// on the standard library./// The type of information to set./// A pointer to the file information to set./// The size of the type pointed to by `as_ptr`.SetFileInformation/// The `SetFileInformationByHandle` function takes a generic parameter by/// making the user specify the type (class), a pointer to the data and its/// size. This trait allows attaching that information to a Rust type so that/// [`set_file_information_by_handle`] can be called safely./// This trait is designed so that it can support variable sized types./// However, currently Rust's std only uses fixed sized structures./// * `as_ptr` must return a pointer to memory that is readable up to `size` bytes./// * `CLASS` must accurately reflect the type pointed to by `as_ptr`. E.g./// the `FILE_BASIC_INFO` structure has the class `FileBasicInfo`.SizedSetFileInformation/// Helper trait for implementing `SetFileInformation` for statically sized types.// SAFETY: FILE_BASIC_INFO, FILE_END_OF_FILE_INFO, FILE_ALLOCATION_INFO,// FILE_DISPOSITION_INFO, FILE_DISPOSITION_INFO_EX and FILE_IO_PRIORITY_HINT_INFO// are all plain `repr(C)` structs that only contain primitive types.// The given information classes correctly match with the struct.FILE_END_OF_FILE_INFOFILE_ALLOCATION_INFOFILE_DISPOSITION_INFOFILE_DISPOSITION_INFO_EXFILE_IO_PRIORITY_HINT_INFOget_last_error/// Gets the error from the last function./// This must be called immediately after the function that sets the error to/// avoid the risk of another function overwriting it./// An error code as returned by [`get_last_error`]./// This is usually a 16-bit Win32 error code but may be a 32-bit HRESULT or NTSTATUS./// Check the documentation of the Windows API function being called for expected errors./// Success is not an error./// Some Windows APIs do use this to distinguish between a zero return and an error return/// but we should never return this to users as an error.ACCESS_DENIEDBAD_NETPATHBAD_NET_NAMECANT_ACCESS_FILEDELETE_PENDINGDIR_NOT_EMPTYFILE_NOT_FOUNDINSUFFICIENT_BUFFERINVALID_FUNCTIONNOT_SUPPORTEDNO_MORE_FILESOPERATION_ABORTEDPATH_NOT_FOUNDSHARING_VIOLATION// Error code constants.// The constant names should be the same as the winapi constants except for the leading `ERROR_`.// Due to the sheer number of codes, error codes should only be added here on an as-needed basis.// However, they should never be removed as the assumption is they may be useful again in the future./// A wrapper around a UNICODE_STRING that is equivalent to `&[u16]`./// It is preferable to use the `unicode_str!` macro as that contains mitigations for  #143078./// If the MaximumLength field of the underlying UNICODE_STRING is greater than/// the Length field then you can test if the string is null terminated by inspecting/// the u16 directly after the string. You cannot otherwise depend on nul termination.EMPTY_STRING_NULL_TERMINATEDfrom_slice_with_nul/// Returns a pointer to the underlying UNICODE_STRING/// Create a UnicodeStringRef from a literal str or a u16 array./// To mitigate #143078, when using a literal str the created UNICODE_STRING/// will be nul terminated. The MaximumLength field of the UNICODE_STRING will/// be set greater than the Length field to indicate that a nul may be present./// If using a u16 array, the array is used exactly as provided and you cannot/// count on the string being nul terminated./// This should generally be used for strings that come from the OS./// **NOTE:** we lack a UNICODE_STRING builder type as we don't currently have/// a use for it. If needing to dynamically build a UNICODE_STRING, the builder/// should try to ensure there's a nul one past the end of the string.//! # Safe(r) wrappers around Windows API functions.//! This module contains fairly thin wrappers around Windows API functions,//! aimed at centralising safety instead of having unsafe blocks spread//! throughout higher level code. This makes it much easier to audit FFI safety.//! Not all functions can be made completely safe without more context but in//! such cases we should still endeavour to reduce the caller's burden of safety//! as much as possible.//! ## Guidelines for wrappers//! Items here should be named similarly to their raw Windows API name, except//! that they follow Rust's case conventions. E.g. function names are//! lower_snake_case. The idea here is that it should be easy for a Windows//! C/C++ programmer to identify the underlying function that's being wrapped//! while not looking too out of place in Rust code.//! Every use of an `unsafe` block must have a related SAFETY comment, even if//! it's trivially safe (for example, see `get_last_error`). Public unsafe//! functions must document what the caller has to do to call them safely.//! Avoid unchecked `as` casts. For integers, either assert that the integer//! is in range or use `try_into` instead. For pointers, prefer to use//! `ptr.cast::<Type>()` when possible.//! This module must only depend on core and not on std types as the eventual//! hope is to have std depend on sys and not the other way around.//! However, some amount of glue code may currently be necessary so such code//! should go in sys/pal/windows/mod.rs rather than here. See `IoResult` as an example.PROCESS_CREATION_FLAGSAclRevisionSbz1AclSizeAceCountSbz2dwFileAttributesftCreationTimeftLastAccessTimeftLastWriteTimedwVolumeSerialNumbernFileSizeHighnFileSizeLownNumberOfLinksnFileIndexHighnFileIndexLowLPPROGRESS_ROUTINE_CALLBACK_REASONCOMPARESTRING_RESULTCONSOLE_MODEnInitialCharsdwCtrlWakeupMaskdwControlKeyStateCOPYFILE_FLAGSCOPYPROGRESSROUTINE_PROGRESSFILE_CREATION_DISPOSITIONCREATE_SECURE_PROCESSCSTR_EQUALCSTR_GREATER_THANCSTR_LESS_THANDNS_ERROR_ADDRESS_REQUIREDDNS_ERROR_CLIENT_SUBNET_ALREADY_EXISTSDNS_ERROR_CLIENT_SUBNET_DOES_NOT_EXISTDNS_ERROR_CLIENT_SUBNET_IS_ACCESSEDDNS_ERROR_DEFAULT_VIRTUALIZATION_INSTANCEDNS_ERROR_INVAILD_VIRTUALIZATION_INSTANCE_NAMEDNS_ERROR_INVALID_CLIENT_SUBNET_NAMEDNS_ERROR_POLICY_ALREADY_EXISTSDNS_ERROR_POLICY_DOES_NOT_EXISTDNS_ERROR_POLICY_INVALID_CRITERIADNS_ERROR_POLICY_INVALID_CRITERIA_CLIENT_SUBNETDNS_ERROR_POLICY_INVALID_CRITERIA_FQDNDNS_ERROR_POLICY_INVALID_CRITERIA_INTERFACEDNS_ERROR_POLICY_INVALID_CRITERIA_NETWORK_PROTOCOLDNS_ERROR_POLICY_INVALID_CRITERIA_QUERY_TYPEDNS_ERROR_POLICY_INVALID_CRITERIA_TIME_OF_DAYDNS_ERROR_POLICY_INVALID_CRITERIA_TRANSPORT_PROTOCOLDNS_ERROR_POLICY_INVALID_NAMEDNS_ERROR_POLICY_INVALID_SETTINGSDNS_ERROR_POLICY_INVALID_WEIGHTDNS_ERROR_POLICY_LOCKEDDNS_ERROR_POLICY_MISSING_CRITERIADNS_ERROR_POLICY_PROCESSING_ORDER_INVALIDDNS_ERROR_POLICY_SCOPE_MISSINGDNS_ERROR_POLICY_SCOPE_NOT_ALLOWEDDNS_ERROR_RRL_INVALID_IPV4_PREFIXDNS_ERROR_RRL_INVALID_IPV6_PREFIXDNS_ERROR_RRL_INVALID_LEAK_RATEDNS_ERROR_RRL_INVALID_TC_RATEDNS_ERROR_RRL_INVALID_WINDOW_SIZEDNS_ERROR_RRL_LEAK_RATE_LESSTHAN_TC_RATEDNS_ERROR_RRL_NOT_ENABLEDDNS_ERROR_SERVERSCOPE_IS_REFERENCEDDNS_ERROR_SUBNET_ALREADY_EXISTSDNS_ERROR_SUBNET_DOES_NOT_EXISTDNS_ERROR_VIRTUALIZATION_INSTANCE_ALREADY_EXISTSDNS_ERROR_VIRTUALIZATION_INSTANCE_DOES_NOT_EXISTDNS_ERROR_VIRTUALIZATION_TREE_LOCKEDDNS_ERROR_ZONESCOPE_IS_REFERENCEDERROR_ACCESS_DENIED_APPDATAERROR_ALREADY_HAS_STREAM_IDERROR_APPEXEC_APP_COMPAT_BLOCKERROR_APPEXEC_CALLER_WAIT_TIMEOUTERROR_APPEXEC_CALLER_WAIT_TIMEOUT_LICENSINGERROR_APPEXEC_CALLER_WAIT_TIMEOUT_RESOURCESERROR_APPEXEC_CALLER_WAIT_TIMEOUT_TERMINATIONERROR_APPEXEC_CONDITION_NOT_SATISFIEDERROR_APPEXEC_HANDLE_INVALIDATEDERROR_APPEXEC_HOST_ID_MISMATCHERROR_APPEXEC_INVALID_HOST_GENERATIONERROR_APPEXEC_INVALID_HOST_STATEERROR_APPEXEC_NO_DONORERROR_APPEXEC_UNEXPECTED_PROCESS_REGISTRATIONERROR_APPEXEC_UNKNOWN_USERERROR_APPX_FILE_NOT_ENCRYPTEDERROR_BLOCKED_BY_PARENTAL_CONTROLSERROR_BLOCK_SHAREDERROR_BLOCK_SOURCE_WEAK_REFERENCE_INVALIDERROR_BLOCK_TARGET_WEAK_REFERENCE_INVALIDERROR_BLOCK_TOO_MANY_REFERENCESERROR_BLOCK_WEAK_REFERENCE_INVALIDERROR_BYPASSIO_FLT_NOT_SUPPORTEDERROR_CALLBACK_INVOKE_INLINEERROR_CANT_CLEAR_ENCRYPTION_FLAGERROR_CAPAUTHZ_CHANGE_TYPEERROR_CAPAUTHZ_DB_CORRUPTEDERROR_CAPAUTHZ_NOT_AUTHORIZEDERROR_CAPAUTHZ_NOT_DEVUNLOCKEDERROR_CAPAUTHZ_NOT_PROVISIONEDERROR_CAPAUTHZ_NO_POLICYERROR_CAPAUTHZ_SCCD_DEV_MODE_REQUIREDERROR_CAPAUTHZ_SCCD_INVALID_CATALOGERROR_CAPAUTHZ_SCCD_NO_AUTH_ENTITYERROR_CAPAUTHZ_SCCD_NO_CAPABILITY_MATCHERROR_CAPAUTHZ_SCCD_PARSE_ERRORERROR_CASE_DIFFERING_NAMES_IN_DIRERROR_CASE_SENSITIVE_PATHERROR_CERTIFICATE_VALIDATION_PREFERENCE_CONFLICTERROR_CHILD_PROCESS_BLOCKEDERROR_CIMFS_IMAGE_CORRUPTERROR_CIMFS_IMAGE_VERSION_NOT_SUPPORTEDERROR_CLOUD_FILE_ACCESS_DENIEDERROR_CLOUD_FILE_ALREADY_CONNECTEDERROR_CLOUD_FILE_AUTHENTICATION_FAILEDERROR_CLOUD_FILE_CONNECTED_PROVIDER_ONLYERROR_CLOUD_FILE_DEHYDRATION_DISALLOWEDERROR_CLOUD_FILE_INCOMPATIBLE_HARDLINKSERROR_CLOUD_FILE_INSUFFICIENT_RESOURCESERROR_CLOUD_FILE_INVALID_REQUESTERROR_CLOUD_FILE_IN_USEERROR_CLOUD_FILE_METADATA_CORRUPTERROR_CLOUD_FILE_METADATA_TOO_LARGEERROR_CLOUD_FILE_NETWORK_UNAVAILABLEERROR_CLOUD_FILE_NOT_IN_SYNCERROR_CLOUD_FILE_NOT_SUPPORTEDERROR_CLOUD_FILE_NOT_UNDER_SYNC_ROOTERROR_CLOUD_FILE_PINNEDERROR_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCHERROR_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGEERROR_CLOUD_FILE_PROPERTY_CORRUPTERROR_CLOUD_FILE_PROPERTY_LOCK_CONFLICTERROR_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTEDERROR_CLOUD_FILE_PROVIDER_NOT_RUNNINGERROR_CLOUD_FILE_PROVIDER_TERMINATEDERROR_CLOUD_FILE_READ_ONLY_VOLUMEERROR_CLOUD_FILE_REQUEST_ABORTEDERROR_CLOUD_FILE_REQUEST_CANCELEDERROR_CLOUD_FILE_REQUEST_TIMEOUTERROR_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPTERROR_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBSERROR_CLOUD_FILE_UNSUCCESSFULERROR_CLOUD_FILE_US_MESSAGE_TIMEOUTERROR_CLOUD_FILE_VALIDATION_FAILEDERROR_COMPRESSION_NOT_BENEFICIALERROR_CONTAINER_ASSIGNEDERROR_CPU_SET_INVALIDERROR_CROSS_PARTITION_VIOLATIONERROR_DAX_MAPPING_EXISTSERROR_DEVICE_HINT_NAME_BUFFER_TOO_SMALLERROR_DEVICE_IN_MAINTENANCEERROR_DEVICE_RESET_REQUIREDERROR_DLP_POLICY_DENIES_OPERATIONERROR_DLP_POLICY_SILENTLY_FAILERROR_DLP_POLICY_WARNS_AGAINST_OPERATIONERROR_DPL_NOT_SUPPORTED_FOR_USERERROR_DS_MISSING_FOREST_TRUSTERROR_DS_PER_ATTRIBUTE_AUTHZ_FAILED_DURING_ADDERROR_DS_VALUE_KEY_NOT_UNIQUEERROR_EDP_DPL_POLICY_CANT_BE_SATISFIEDERROR_EDP_POLICY_DENIES_OPERATIONERROR_ENCLAVE_NOT_TERMINATEDERROR_ENCLAVE_VIOLATIONERROR_ENCRYPTED_FILE_NOT_SUPPORTEDERROR_ENCRYPTING_METADATA_DISALLOWEDERROR_ENCRYPTION_DISABLEDERROR_EXTERNAL_SYSKEY_NOT_SUPPORTEDERROR_FILE_METADATA_OPTIMIZATION_IN_PROGRESSERROR_FILE_NOT_SUPPORTEDERROR_FILE_PROTECTED_UNDER_DPLERROR_FILE_SNAP_INVALID_PARAMETERERROR_FILE_SNAP_IN_PROGRESSERROR_FILE_SNAP_IO_NOT_COORDINATEDERROR_FILE_SNAP_MODIFY_NOT_SUPPORTEDERROR_FILE_SNAP_UNEXPECTED_ERRORERROR_FILE_SNAP_USER_SECTION_NOT_SUPPORTEDERROR_FILE_SYSTEM_VIRTUALIZATION_BUSYERROR_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATIONERROR_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPTERROR_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWNERROR_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLEERROR_FS_METADATA_INCONSISTENTERROR_FT_READ_FAILUREERROR_FT_READ_FROM_COPY_FAILUREERROR_GDI_HANDLE_LEAKERROR_HANDLE_REVOKEDERROR_HAS_SYSTEM_CRITICAL_FILESERROR_INDEX_OUT_OF_BOUNDSERROR_INSUFFICIENT_VIRTUAL_ADDR_RESOURCESERROR_JOB_NO_CONTAINERERROR_LINUX_SUBSYSTEM_NOT_PRESENTERROR_LINUX_SUBSYSTEM_UPDATE_REQUIREDERROR_LOCAL_POLICY_MODIFICATION_NOT_SUPPORTEDERROR_LOST_MODE_LOGON_RESTRICTIONERROR_MARKED_TO_DISALLOW_WRITESERROR_NETWORK_ACCESS_DENIED_EDPERROR_NOT_A_CLOUD_FILEERROR_NOT_A_CLOUD_SYNC_ROOTERROR_NOT_A_DAX_VOLUMEERROR_NOT_DAX_MAPPABLEERROR_NOT_SAME_OBJECTERROR_NOT_SUPPORTED_ON_DAXERROR_NOT_SUPPORTED_WITH_AUDITINGERROR_NOT_SUPPORTED_WITH_BTTERROR_NOT_SUPPORTED_WITH_BYPASSIOERROR_NOT_SUPPORTED_WITH_CACHED_HANDLEERROR_NOT_SUPPORTED_WITH_COMPRESSIONERROR_NOT_SUPPORTED_WITH_DEDUPLICATIONERROR_NOT_SUPPORTED_WITH_ENCRYPTIONERROR_NOT_SUPPORTED_WITH_MONITORINGERROR_NOT_SUPPORTED_WITH_REPLICATIONERROR_NOT_SUPPORTED_WITH_SNAPSHOTERROR_NOT_SUPPORTED_WITH_VIRTUALIZATIONERROR_NO_BYPASSIO_DRIVER_SUPPORTERROR_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUNDERROR_NO_SUCH_DEVICEERROR_NO_TASK_QUEUEERROR_NO_WORK_DONEERROR_OBJECT_IS_IMMUTABLEERROR_PAGEFILE_NOT_SUPPORTEDERROR_PARTITION_TERMINATINGERROR_PNP_QUERY_REMOVE_DEVICE_TIMEOUTERROR_PNP_QUERY_REMOVE_RELATED_DEVICE_TIMEOUTERROR_PNP_QUERY_REMOVE_UNRELATED_DEVICE_TIMEOUTERROR_QUOTA_ACTIVITYERROR_REPARSE_POINT_ENCOUNTEREDERROR_RETURN_ADDRESS_HIJACK_ATTEMPTERROR_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTEDERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSETERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGEERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETERERROR_SECTION_DIRECT_MAP_ONLYERROR_SECURITY_DENIES_OPERATIONERROR_SERVER_TRANSPORT_CONFLICTERROR_SESSION_KEY_TOO_SHORTERROR_SET_CONTEXT_DENIEDERROR_SHUTDOWN_DISKS_NOT_IN_MAINTENANCE_MODEERROR_SMB1_NOT_AVAILABLEERROR_SMB_GUEST_LOGON_BLOCKEDERROR_SMR_GARBAGE_COLLECTION_REQUIREDERROR_SPARSE_FILE_NOT_SUPPORTEDERROR_SRC_SRV_DLL_LOAD_FAILEDERROR_STORAGE_LOST_DATA_PERSISTENCEERROR_STORAGE_RESERVE_ALREADY_EXISTSERROR_STORAGE_RESERVE_DOES_NOT_EXISTERROR_STORAGE_RESERVE_ID_INVALIDERROR_STORAGE_RESERVE_NOT_EMPTYERROR_STORAGE_STACK_ACCESS_DENIEDERROR_STORAGE_TOPOLOGY_ID_MISMATCHERROR_STRICT_CFG_VIOLATIONERROR_TIME_SENSITIVE_THREADERROR_UNEXPECTED_NTCACHEMANAGER_ERRORERROR_UNSATISFIED_DEPENDENCIESERROR_UNTRUSTED_MOUNT_POINTERROR_VOLUME_NOT_CLUSTER_ALIGNEDERROR_VOLUME_NOT_SUPPORTEDERROR_VOLUME_WRITE_ACCESS_DENIEDERROR_WEAK_WHFBKEY_BLOCKEDERROR_WIP_ENCRYPTION_FAILEDERROR_WOF_FILE_RESOURCE_TABLE_CORRUPTERROR_WOF_WIM_HEADER_CORRUPTERROR_WOF_WIM_RESOURCE_TABLE_CORRUPTContextRecordExceptionCollidedUnwindExceptionContinueExecutionExceptionContinueSearchExceptionNestedExceptionFACILITY_CODEfd_countAllocationSizeFileAttributesReparseTagFILE_ATTRIBUTE_TAG_INFOLastAccessTimeLastWriteTimeChangeTimeSET_FILE_POINTER_MOVE_METHODFILE_COMPLETE_IF_OPLOCKEDNTCREATEFILE_CREATE_OPTIONSFILE_CONTAINS_EXTENDED_CREATE_INFORMATIONFILE_CREATENTCREATEFILE_CREATE_DISPOSITIONFILE_CREATE_TREE_CONNECTIONFILE_DELETE_ON_CLOSEFILE_DIRECTORY_FILEFILE_DISALLOW_EXCLUSIVEFILE_DISPOSITION_FLAG_DELETEFILE_DISPOSITION_INFO_EX_FLAGSFILE_DISPOSITION_FLAG_DO_NOT_DELETEFILE_DISPOSITION_FLAG_FORCE_IMAGE_SECTION_CHECKFILE_DISPOSITION_FLAG_IGNORE_READONLY_ATTRIBUTEFILE_DISPOSITION_FLAG_ON_CLOSEFILE_DISPOSITION_FLAG_POSIX_SEMANTICSDeleteFileNextEntryOffsetFileNameLengthEaSizeShortNameLengthShortNameFILE_ID_BOTH_DIR_INFOPriorityHintPRIORITY_HINTFILE_NAME_NORMALIZEDGETFINALPATHNAMEBYHANDLE_FLAGSFILE_NAME_OPENEDFILE_NON_DIRECTORY_FILEFILE_NO_COMPRESSIONFILE_NO_EA_KNOWLEDGEFILE_NO_INTERMEDIATE_BUFFERINGFILE_OPEN_BY_FILE_IDFILE_OPEN_FOR_BACKUP_INTENTFILE_OPEN_FOR_FREE_SPACE_QUERYFILE_OPEN_IFFILE_OPEN_NO_RECALLFILE_OPEN_REPARSE_POINTFILE_OPEN_REQUIRING_OPLOCKFILE_OVERWRITEFILE_OVERWRITE_IFFILE_PIPE_ACCEPT_REMOTE_CLIENTSFILE_PIPE_BYTE_STREAM_MODEFILE_PIPE_BYTE_STREAM_TYPEFILE_PIPE_COMPLETE_OPERATIONFILE_PIPE_MESSAGE_MODEFILE_PIPE_MESSAGE_TYPEFILE_PIPE_QUEUE_OPERATIONFILE_PIPE_REJECT_REMOTE_CLIENTSFILE_RANDOM_ACCESSFILE_RENAME_FLAG_POSIX_SEMANTICSFILE_RENAME_FLAG_REPLACE_IF_EXISTSFILE_RENAME_INFO_0RootDirectoryFILE_RENAME_INFOReplaceIfExistsFILE_RESERVE_OPFILTERFILE_SEQUENTIAL_ONLYFILE_SESSION_AWAREFILE_SHARE_MODEFILE_SHARE_NONENumberOfLinksDeletePendingFILE_STANDARD_INFOFILE_SUPERSEDEFILE_SYNCHRONOUS_IO_ALERTFILE_SYNCHRONOUS_IO_NONALERTFILE_TYPEFILE_WRITE_THROUGHFIND_FIRST_EX_FLAGSFORMAT_MESSAGE_OPTIONSFileAlignmentInfoFileAllocationInfoFileAttributeTagInfoFileBasicInfoFileCaseSensitiveInfoFileCompressionInfoFileDispositionInfoFileDispositionInfoExFileEndOfFileInfoFileFullDirectoryInfoFileFullDirectoryRestartInfoFileIdBothDirectoryInfoFileIdBothDirectoryRestartInfoFileIdExtdDirectoryInfoFileIdExtdDirectoryRestartInfoFileIdInfoFileIoPriorityHintInfoFileNameInfoFileNormalizedNameInfoFileRemoteProtocolInfoFileRenameInfoFileRenameInfoExFileStandardInfoFileStorageInfoFileStreamInfoFindExInfoBasicFindExSearchNameMatchGENERIC_ACCESS_RIGHTSHANDLE_FLAGSINIT_ONCE_INIT_FAILEDS_unS_un_bIN_ADDR_0_0S_un_wIN_ADDR_0_1S_addrs_b1s_b2s_b3s_b4s_w1s_w2IPPROTO_CBTIPPROTO_ICLFXBMIPPROTO_IPV4IPPROTO_RESERVED_IPSECIPPROTO_RESERVED_IPSECOFFLOADIPPROTO_RESERVED_MAXIPPROTO_RESERVED_RAWIPPROTO_RESERVED_WNVIPPROTO_RMMULTI_BYTE_TO_WIDE_CHAR_FLAGSMOVE_FILE_FLAGSSEND_RECV_FLAGSMaximumFileInfoByHandleClassNAMED_PIPE_MODEObjectNameOBJECT_ATTRIBUTE_FLAGSSecurityQualityOfServiceInternalHighOVERLAPPED_0hEventOVERLAPPED_0_0OffsetHighPIO_APC_ROUTINEPROCESSOR_ARCHITECTUREhProcesshThreaddwProcessIddwThreadIdWINSOCK_SHUTDOWN_HOWRevisionSaclDaclImpersonationLevelContextTrackingModeEffectiveOnly__ss_pad1SOCKADDR_UNWINSOCK_SOCKET_TYPESTACK_SIZE_PARAM_IS_A_RESERVATIONTHREAD_CREATION_FLAGSSTARTUPINFOW_FLAGSStartupInfolpAttributeListlpReservedlpDesktoplpTitledwXdwYdwXSizedwYSizedwXCountCharsdwYCountCharsdwFillAttributewShowWindowcbReserved2lpReserved2hStdInputhStdOutputhStdErrorSTD_HANDLESYMBOLIC_LINK_FLAGSSYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATESYMBOLIC_LINK_FLAG_DIRECTORYSYMLINK_FLAG_RELATIVESYSTEM_INFO_0dwOemIdSYSTEM_INFO_0_0THREAD_CREATE_RUN_IMMEDIATELYTHREAD_CREATE_SUSPENDEDTOKEN_ACCESS_MASKTOKEN_ACCESS_SYSTEM_SECURITYTOKEN_DELETETOKEN_READ_CONTROLTOKEN_WRITE_DACTOKEN_WRITE_OWNERMaximumLengthVOLUME_NAME_GUIDVOLUME_NAME_NONEdwReserved0dwReserved1cFileNamecAlternateFileNameWSA_ERRORwVersionwHighVersionszDescriptionszSystemStatusiMaxSocketsiMaxUdpDglpVendorInfoChainLenChainEntriesdwServiceFlags1dwServiceFlags2dwServiceFlags3dwServiceFlags4dwProviderFlagsProviderIddwCatalogEntryIdProtocolChainiVersioniAddressFamilyiMaxSockAddriMinSockAddriSocketTypeiProtocoliProtocolMaxOffsetiNetworkByteOrderiSecuritySchemedwMessageSizedwProviderReservedszProtocol// Bindings generated by `windows-bindgen` 0.61.1// ignore-tidy-filelength// https://learn.microsoft.com/en-us/cpp/c-runtime-library/exit-success-exit-failure?view=msvc-170INIT_ONCE_STATIC_INIT// Some windows_sys types have different signs than the types we use.nt_success// Equivalent to the `NT_SUCCESS` C preprocessor macro.// See: https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/using-ntstatus-valuesReparseDataLength/// NB: Use carefully! In general using this as a reference is likely to get the/// provenance wrong for the `rest` field!SubstituteNameOffsetSubstituteNameLengthPrintNameOffsetPrintNameLengthPathBufferSYMBOLIC_LINK_REPARSE_BUFFER/// provenance wrong for the `PathBuffer` field!MOUNT_POINT_REPARSE_BUFFER// Desktop specific functions & typescompat_fn_with_fallback// Functions that aren't available on every version of Windows that we support,// but we still use them and just provide some form of a fallback implementation.// Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library.compat_fn_optional// These are loaded by `load_synch_functions`.//! C definitions used by libnative that don't belong in liblibc// Use raw-dylib to import ProcessPrng as we can't rely on there being an import library.".CRT$XCT"INIT_TABLE_ENTRY// This uses a static initializer to preload some imported functions.// The CRT (C runtime) executes static initializers before `main`// is called (for binaries) and before `DllMain` is called (for DLLs).// It works by contributing a global symbol to the `.CRT$XCT` section.// The linker builds a table of all static initializer functions.// The CRT startup code then iterates that table, calling each// initializer function.// NOTE: User code should instead use .CRT$XCU to reliably run after std's initializer.// If you're reading this and would like a guarantee here, please// file an issue for discussion; currently we don't guarantee any functionality// before main.// See https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-initialization?view=msvc-170/// Preload some imported functions./// Note that any functions included here will be unconditionally loaded in/// the final binary, regardless of whether or not they're actually used./// Therefore, this should be limited to `compat_fn_optional` functions which/// must be preloaded or any functions where lazier loading demonstrates a/// negative performance impact in practical situations./// Currently we only preload `WaitOnAddress` and `WakeByAddressSingle`.ansi_str/// Helper macro for creating CStrs from literals and symbol names.const_cstr_from_bytes/// Creates a C string wrapper from a byte slice, in a constant context./// This is a utility function used by the [`ansi_str`] macro./// Panics if the slice is not null terminated or contains nulls, except as the last item/// Represents a loaded module./// Note that the modules std depends on must not be unloaded./// Therefore a `Module` is always valid for the lifetime of std./// Try to get a handle to a loaded module./// This should only be use for modules that exist for the lifetime of std/// (e.g. kernel32 and ntdll).proc_address// Try to get the address of a function./// Load a function or use a fallback implementation if that fails./// Optionally loaded functions./// Relies on the functions being pre-loaded elsewhere.load_synch_functions/// Load all needed functions from "api-ms-win-core-synch-l1-2-0".//! A "compatibility layer" for supporting older versions of Windows//! The standard library uses some Windows API functions that are not present//! on older versions of Windows.  (Note that the oldest version of Windows//! that Rust supports is Windows 7 (client) and Windows Server 2008 (server).)//! This module implements a form of delayed DLL import binding, using//! `GetModuleHandle` and `GetProcAddress` to look up DLL entry points at//! This is implemented simply by storing a function pointer in an atomic.//! Loading and calling this function will have little or no overhead//! compared with calling any other dynamically imported function.//! The stored function pointer starts out as an importer function which will//! swap itself with the real function when it's called for the first time. If//! the real function can't be imported then a fallback function is used in its//! place. While this is low cost for the happy path (where the function is//! already loaded) it does mean there's some overhead the first time the//! function is called. In the worst case, multiple threads may all end up//! importing the same function unnecessarily.Futexableunsafe_waitable_intwake_by_address_singlewake_by_address_alloverlapped_handle_fallback/// Test the synchronous fallback for overlapped I/O./// An owned container for `HANDLE` object, closing them on Drop./// All methods are inherited through a `Deref` impl to `RawHandle`new_eventoverlapped_resultcancel_iosynchronous_read/// Performs a synchronous read./// If the handle is opened for asynchronous I/O then this abort the process./// See #81357./// If `offset` is `None` then the current file position is used.synchronous_write/// Performs a synchronous write./// Map a [`Result<T, WinError>`] to [`io::Result<T>`](crate::io::Result<T>).unrolled_find_u16s// Many Windows APIs follow a pattern of where we hand a buffer and then they// will report back to us how large the buffer should be or how many bytes// currently reside in the buffer. This function is an abstraction over these// functions by making them easier to call.// The first callback, `f1`, is passed a (pointer, len) pair which can be// passed to a syscall. The `ptr` is valid for `len` items (u16 in this case).// The closure is expected to:// - On success, return the actual length of the written data *without* the null terminator.//   This can be 0. In this case the last_error must be left unchanged.// - On insufficient buffer space,//   - either return the required length *with* the null terminator,//   - or set the last-error to ERROR_INSUFFICIENT_BUFFER and return `len`.// - On other failure, return 0 and set last_error.// This is how most but not all syscalls indicate the required buffer space.// Other syscalls may need translation to match this protocol.// Once the syscall has completed (errors bail out early) the second closure is// passed the data which has been read from the syscall. The return value// from this closure is then the return value of the function.os2path/// Use `__fastfail` to abort the process/// In Windows 8 and later, this will terminate the process immediately without/// running any in-process exception handlers. In earlier versions of Windows,/// this sequence of instructions will be treated as an access violation, which/// will still terminate the process but might run some exception handlers./// https://docs.microsoft.com/en-us/cpp/intrinsics/fastfail// inline assembly does not work in Miri/// Align the inner value to 8 bytes./// This is enough for almost all of the buffers we're likely to work with in/// the Windows APIs we use.ntstatus_error// tests `error_string` abovemust_yield//! Implementation of `std::os` functionality for Windows.ourstheirs/// Although this looks similar to `anon_pipe` in the Unix module it's actually/// subtly different. Here we'll return two pipes in the `Pipes` return value,/// but one is intended for "us" where as the other is intended for "someone/// else"./// Currently the only use case for this function is pipes for stdio on/// processes in the standard library, so "ours" is the one that'll stay in our/// process whereas "theirs" will be inherited to a child./// The ours/theirs pipes are *not* specifically readable or writable. Each/// one only supports a read or a write, but which is which depends on the/// boolean flag given. If `ours_readable` is `true`, then `ours` is readable and/// `theirs` is writable. Conversely, if `ours_readable` is `false`, then `ours`/// is writable and `theirs` is readable./// Also note that the `ours` pipe is always a handle opened up in overlapped/// mode. This means that technically speaking it should only ever be used/// with `OVERLAPPED` instances, but also works out ok if it's only ever used/// once at a time (which we do indeed guarantee).spawn_pipe_relay/// Takes an asynchronous source pipe and returns a synchronous pipe suitable/// for sending to a child process./// This is achieved by creating a new set of pipes and spawning a thread that/// relays messages between the source and the synchronous pipe.alertable_io_internal/// Synchronizes asynchronous reads or writes using our anonymous pipe./// This is a wrapper around [`ReadFileEx`] or [`WriteFileEx`] that uses/// [Asynchronous Procedure Call] (APC) to synchronize reads or writes./// Note: This should not be used for handles we don't create./// `buf` must be a pointer to a buffer that's valid for reads or writes/// up to `len` bytes. The `AlertableIoFn` must be either `ReadFileEx` or `WriteFileEx`/// [`ReadFileEx`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfileex/// [`WriteFileEx`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefileex/// [Asynchronous Procedure Call]: https://docs.microsoft.com/en-us/windows/win32/sync/asynchronous-procedure-calls// needs a stable addressAsyncPipeNotReading/// Executes an overlapped read operation./// Must not currently be reading, and returns whether the pipe is currently/// at EOF or not. If the pipe is not at EOF then `result()` must be called/// to complete the read later on (may block), but if the pipe is at EOF/// then `result()` should not be called as it will just block forever./// Wait for the result of the overlapped operation previously executed./// Takes a parameter `wait` which indicates if this pipe is currently being/// read whether the function should block waiting for the read to complete./// Returns values:/// * `true` - finished any pending read and the pipe is not at EOF (keep///            going)/// * `false` - finished any pending read and pipe is at EOF (stop issuing///             reads)/// Finishes out reading this pipe entirely./// Waits for any pending and schedule read, and then calls `read_to_end`/// if necessary to read all the remaining information.reserve_stack/// Reserve stack space for use in stack overflow exceptions.vectored_handlerINTERVALS_PER_SEC// This duration is relative to an arbitrary microsecond epoch// from the winapi QueryPerformanceCounter function.INTERVALS_TO_UNIX_EPOCHchecked_dur2intervalsintervals2durPerformanceCounterInstant// Per microsoft docs, the margin of error for cross-thread time comparisons// using QueryPerformanceCounter is 1 "tick" -- defined as 1/frequency().// Reference: https://docs.microsoft.com/en-us/windows/desktop/SysInfo//                   /acquiring-high-resolution-time-stampsperf_counterWaitableTimer/// A timer you can wait on.high_resolution/// Creates a high-resolution timer. Will fail before Windows 10, version 1803.WSA_STARTED/// Checks whether the Windows socket interface has been started already, and/// if not, starts it./// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1)/// and if so, returns the last error from the Windows socket interface. This/// function must be called before another call to the socket API is made.create_args_testbasic_arg_parsing/// Xous passes a pointer to the parameter block as the second argument./// This is used for passing flags such as environment variables. The/// format of the argument block is:/// struct BlockHeader {///     /// Magic number that identifies this block. Must be printable ASCII.///     magic: [u8; 4],///     /// The size of the data block. Does not include this header. May be 0.///     size: u32,///     /// The contents of this block. Varies depending on the block type.///     data: [u8; 0],/// There is a BlockHeader at the start that has magic `AppP`, and the data/// that follows is the number of blocks present:/// struct ApplicationParameters {///     magic: b"AppP",///     size: 4u32,///     /// The size of the entire application slice, in bytes, including all headers///     length: u32,///     /// Number of application parameters present. Must be at least 1 (this block)///     entries: (parameter_count as u32).to_bytes_le(),/// struct EnvironmentBlock {///     magic: b"EnvB",///     /// Total number of bytes, excluding this header///     size: 2+data.len(),///     /// The number of environment variables///     count: u16,///     /// Environment variable iteration/// Environment variables are present in an `EnvB` block. The `data` section is/// a sequence of bytes of the form:///      (u16 /* key_len */; [0u8; key_len as usize] /* key */,///       u16 /* val_len */ [0u8; val_len as usize])/// struct ArgumentList {///     magic: b"ArgL",///     /// The number of arguments variables///     /// Argument variable iteration/// Args are just an array of strings that represent command line arguments./// They are a sequence of the form:///      (u16 /* val_len */ [0u8; val_len as usize])ENV_MAGIC/// Magic number indicating we have an environment blockARGS_MAGIC/// Command line arguments listPARAMS_MAGIC/// Magic number indicating the loader has passed application parameters_entriesApplicationParametersnew_from_ptrApplicationParameterApplicationParameterErrorEnvironmentBlockEnvironmentEntryArgumentEntryXousErrorPARAMS_ADDRESSEhFrameFinderEH_FRAME_ADDRESSEH_FRAME_SETTINGSeh_unwindingc_compatDIGEST_WORDSSTDINSTDERRJOURNAL/// Standard IO file descriptors for use with sys_read and sys_write.sys_halt// Wrappers around syscalls provided by risc0-zkvm-platform:sys_outputsys_sha_compresssys_sha_buffersys_randsys_panicsys_logsys_cycle_countsys_readsys_writesys_getenvsys_argcsys_argvsys_alloc_words// Allocate memory from global HEAP.sys_alloc_aligned//! ABI definitions for symbols exported by risc0-zkvm-platform.// Included here so we don't have to depend on risc0-zkvm-platform.// FIXME: Should we move this to the "libc" crate?  It seems like other// architectures put a lot of this kind of stuff there.  But there's// currently no risc0 fork of the libc crate, so we'd either have to// fork it or upstream it.//! System bindings for the risc0 zkvm platform//! OS level functionality for zkvm./// Cygwin always prefers `/` over `\`, and it always converts all `/` to `\`/// internally when calling Win32 APIs. Therefore, the server component of path/// `\\?\UNC\localhost/share` is `localhost/share` on Win32, but `localhost`/// on Cygwin.windows_prefixMAIN_SEPcygwin_conv_path// Doc: https://cygwin.com/cygwin-api/func-cygwin-conv-path.html// Src: https://github.com/cygwin/cygwin/blob/718a15ba50e0d01c79800bd658c2477f9a603540/winsup/cygwin/path.cc#L3902// * `what` should be `CCP_WIN_A_TO_POSIX` here// * `from` is null-terminated UTF-8 path// * `to` is buffer, the buffer size is `size`.// Converts a path to an absolute POSIX path, no matter the input is Win32 path or POSIX path.CCP_WIN_A_TO_POSIX/// Make a POSIX path absolute.FORWARD_SLASHCOLON/// UEFI paths can be of 4 types:/// 1. Absolute Shell Path: Uses shell mappings (eg: `FS0:`). Does not exist if UEFI shell not present.///    It can be identified with `:`.///    Eg: FS0:\abc\run.efi/// 2. Absolute Device Path: this is what we want///    It can be identified with `/`.///    Eg: PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/\abc\run.efi/// 3: Relative root: path relative to the current volume.///    It will start with `\`.///    Eg: \abc\run.efi/// 4: Relative///    Eg: run.efi/// The algorithm is mostly taken from edk2 UEFI shell implementation and is/// somewhat simple. Check for the path type in order./// The volume mapping in Absolute Shell Path (not the rest of the path) can be converted to Device/// Path Protocol using `EFI_SHELL->GetDevicePathFromMap`. The rest of the path (Relative root/// path), can just be appended to the remaining path./// For Relative root, we get the current volume (either in Shell Mapping, or Device Path Protocol/// form) and join it with the relative root path. We then recurse the function to resolve the Shell/// Mapping if present./// For Relative paths, we use the current working directory to construct/// the new path and recurse the function to resolve the Shell mapping if present./// Finally, at the end, we get the 2nd form, i.e. Absolute Device Path, which can be used in the/// normal UEFI APIs such as file, process, etc./// Eg: PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/\abc\run.efi/// Make a POSIX path absolute without changing its semantics.test_parse_next_componenttest_parse_prefix_verbatimtest_parse_prefix_verbatim_devicetest_windows_prefix_components// See #93586 for more information.broken_unc_path/// See #101358./// Note that the exact behavior here may change in the future./// In which case this test will need to adjusted.test_is_absolute_exact/// A null terminated wide string.from_wchars_with_null_unchecked/// Convert a slice to a WCStr without checks./// Though it is memory safe, the slice should also not contain interior nulls/// as this may lead to unwanted truncation./// The slice must end in a null.is_file_name/// Returns true if `path` looks like a lone filename.has_trailing_slashappend_suffix/// Appends a suffix to a path./// Can be used to append an extension without removing an existing extension./// Returns a UTF-16 encoded path capable of bypassing the legacy `MAX_PATH` limits./// This path may or may not have a verbatim prefix./// Gets a normalized absolute path that can bypass path length limits./// Setting prefer_verbatim to true suggests a stronger preference for verbatim/// paths even when not strictly necessary. This allows the Windows API to avoid/// repeating our work. However, if the path may be given back to users or/// passed to other application then it's preferable to use non-verbatim paths/// when possible. Non-verbatim paths are better understood by users and handled/// by more software./// Make a Windows path absolute.is_absolute_exact/// Test that the path is absolute, fully qualified and unchanged when processed by the Windows API./// - `C:\path\to\file` will return true./// - `C:\path\to\nul` returns false because the Windows API will convert it to \\.\NUL/// - `C:\path\to\..\file` returns false because it will be resolved to `C:\path\file`./// This is a useful property because it means the path can be converted from and to and verbatim/// path just by changing the prefix.PrefixParserPrefixParserSliceprefix_bytesparse_drive// Parses a drive prefix, e.g. "C:" and "C:\whatever"parse_drive_exact// Parses a drive prefix exactly, e.g. "C:"// Parse the next path component.// Returns the next component and the rest of the path excluding the component and separator.// Does not recognize `/` as a separator character on Windows if `verbatim` is true.//! Parse Windows prefixes, for both Windows and Cygwin.DwarfReaderfunc_start// Current instruction pointerget_text_start// Pointer to the current functionget_data_start// Get pointer to the code section// Get pointer to the data sectionEHContextLPad/// Landing pad.EHActionCatchTerminateUSING_SJLJ_EXCEPTIONS/// 32-bit ARM Darwin platforms uses SjLj exceptions./// The exception is watchOS armv7k (specifically that subarchitecture), which/// instead uses DWARF Call Frame Information (CFI) unwinding./// <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.4/clang/lib/Driver/ToolChains/Darwin.cpp#L3107-L3119>find_eh_actioninterpret_cs_actionread_encoded_offset/// Reads an offset (`usize`) from `reader` whose encoding is described by `encoding`./// `encoding` must be a [DWARF Exception Header Encoding as described by the LSB spec][LSB-dwarf-ext]./// In addition the upper ("application") part must be zero./// Returns `Err` if `encoding`/// * is not a valid DWARF Exception Header Encoding,/// * is `DW_EH_PE_omit`, or/// * has a non-zero application part./// [LSB-dwarf-ext]: https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.htmlread_encoded_pointer/// Reads a pointer from `reader` whose encoding is described by `encoding`./// * combines `DW_EH_PE_absptr` or `DW_EH_PE_aligned` application part with an integer encoding///   (not `DW_EH_PE_absptr`) in the value format part.//! Parsing of GCC-style Language-Specific Data Area (LSDA)//! For details see://!  * <https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html>//!  * <https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html>//!  * <https://itanium-cxx-abi.github.io/cxx-abi/exceptions.pdf>//!  * <https://www.airs.com/blog/archives/460>//!  * <https://www.airs.com/blog/archives/464>//! A reference implementation may be found in the GCC source tree//! (`<root>/libgcc/unwind-c.c` as of this writing).eh/// Read a type T and then bump the pointer by that amount./// DWARF streams are "packed", so all types must be read at align 1./// ULEB128 and SLEB128 encodings are defined in Section 7.6 - "Variable Length Data".//! Utilities for parsing DWARF-encoded data streams.//! See <http://www.dwarfstd.org>,//! DWARF-4 standard, Section 7 - "Data Representation"// This module is used only by x86_64-pc-windows-gnu for now, but we// are compiling it everywhere to avoid regressions.dwarf_reader_Unwind_Action// This is required by the compiler to exist (e.g., it's a lang item), but it's// never actually called by the compiler.  Emscripten EH doesn't use a// personality function at all, it instead uses __cxa_find_matching_catch.// Wasm error handling would use __gxx_personality_wasm0.//! On Emscripten Rust panics are wrapped in C++ exceptions, so we just forward//! to `__gxx_personality_v0` which is provided by Emscripten.UNWIND_DATA_REGr" Default personality routine, which is used directly on most targets"r" and indirectly on Windows x86_64 and AArch64 via SEH."rust_eh_personality_implr" personality fn called by [Itanium C++ ABI Exception Handling][itanium-eh]"r" The personality routine for most non-Windows targets. This will be called by"r" the unwinding library:"r#" - "In the search phase, the framework repeatedly calls the personality routine,"#r"   with the _UA_SEARCH_PHASE flag as described below, first for the current PC"r#"   and register state, and then unwinding a frame to a new PC at each step...""#r#" - "If the search phase reports success, the framework restarts in the cleanup"#r"    phase. Again, it repeatedly calls the personality routine, with the"r"   _UA_CLEANUP_PHASE flag as described below, first for the current PC and"r#"   register state, and then unwinding a frame to a new PC at each step..."i"#r" [itanium-eh]: https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html"// Register ids were lifted from LLVM's TargetLowering::getExceptionPointerRegister()// and TargetLowering::getExceptionSelectorRegister() for each architecture,// then mapped to DWARF register numbers via register definition tables// (typically <arch>RegisterInfo.td, search for "DwarfRegNum").// See also https://llvm.org/docs/WritingAnLLVMBackend.html#defining-a-register.// EAX, EDX// RAX, RDX// R0, R1 / X0, X1// D0, D1// A0, A1// R0, R1// R3, R4 / X3, X4// R6, R7// I0, I1// x10, x11// a0, a1// The following code is based on GCC's C and C++ personality routines.  For reference, see:// https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_personality.cc// https://github.com/gcc-mirror/gcc/blob/trunk/libgcc/unwind-c.cgcc//! This module contains the implementation of the `eh_personality` lang item.//! The actual implementation is heavily dependent on the target since Rust//! tries to use the native stack unwinding mechanism whenever possible.//! This personality function is still required with `-C panic=abort` because//! it is used to catch foreign exceptions from `extern "C-unwind"` and turn//! them into aborts.//! Additionally, ARM EHABI uses the personality function when generating//! backtraces.root_relative// MacTypes.hCFTypeID// CoreFoundation/CFError.hkCFPropertyListImmutable// CoreFoundation/CFPropertyList.hCFPropertyListFormatCFPropertyListRef// CoreFoundation/CFString.h// CoreFoundation/CFDictionary.hCFHandle/// An open handle to the dynamically loaded CoreFoundation framework./// This is `dlopen`ed, and later `dlclose`d. This is done to try to avoid/// "leaking" the CoreFoundation symbols to the rest of the user's binary if/// they decided to not link CoreFoundation themselves./// It is also faster to look up symbols directly via this handle than with/// `RTLD_DEFAULT`.dlsym_fn/// Link to the CoreFoundation dylib, and look up symbols from that.//! Minimal utilities for interfacing with a dynamically loaded CoreFoundation.public_externOSVersion/// The version of the operating system./// We use a packed u32 here to allow for fast comparisons and to match Mach-O's `LC_BUILD_VERSION`.pack_os_version/// Combine parts of a version into an [`OSVersion`]./// The size of the parts are inherently limited by Mach-O's `LC_BUILD_VERSION`.pack_i32_os_version/// [`pack_os_version`], but takes `i32` and saturates./// Instead of using e.g. `major as u16`, which truncates./// Get the current OS version, packed according to [`pack_os_version`]./// # Semantics/// The reported version on macOS might be 10.16 if the SDK version of the binary is less than 11.0./// This is a workaround that Apple implemented to handle applications that assumed that macOS/// versions would always start with "10", see:/// <https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.81.4/libsyscall/wrappers/system-version-compat.c>/// It _is_ possible to get the real version regardless of the SDK version of the binary, this is/// what Zig does:/// <https://github.com/ziglang/zig/blob/0.13.0/lib/std/zig/system/darwin/macos.zig>/// We choose to not do that, and instead follow Apple's behaviour here, and return 10.16 when/// compiled with an older SDK; the user should instead upgrade their tooling./// NOTE: `rustc` currently doesn't set the right SDK version when linking with ld64, so this will/// have the wrong behaviour with `-Clinker=ld` on x86_64. But that's a `rustc` bug:/// <https://github.com/rust-lang/rust/issues/129432>lookup_version/// Look up the os version./// Aborts if reading or parsing the version fails (or if the system was out of memory)./// We deliberately choose to abort, as having this silently return an invalid OS version would be/// impossible for a user to debug.// The lookup is costly and should be on the cold path because of the cache in `current_version`.// Micro-optimization: We use `extern "C"` to abort on panic, allowing `current_version` (inlined)// to be free of unwind handling. Aborting is required for `__isPlatformVersionAtLeast` anyhow.version_from_sysctl/// Read the version from `kern.osproductversion` or `kern.iossupportversion`./// This is faster than `version_from_plist`, since it doesn't need to invoke `dlsym`.version_from_plist/// Look up the current OS version(s) from `/System/Library/CoreServices/SystemVersion.plist`./// More specifically, from the `ProductVersion` and `iOSSupportVersion` keys, and from/// `$IPHONE_SIMULATOR_ROOT/System/Library/CoreServices/SystemVersion.plist` on the simulator./// This file was introduced in macOS 10.3, which is well below the minimum supported version by/// `rustc`, which is (at the time of writing) macOS 10.12./// We do roughly the same thing in here as `compiler-rt`, and dynamically look up CoreFoundation/// utilities for parsing PLists (to avoid having to re-implement that in here, as pulling in a full/// PList parser into `std` seems costly)./// If this is found to be undesirable, we _could_ possibly hack it by parsing the PList manually/// (it seems to use the plain-text "xml1" encoding/format in all versions), but that seems brittle.parse_version_from_plist/// Parse OS version from the given PList./// Split out from [`version_from_plist`] to allow for testing.string_version_key/// Look up a string key in a CFDictionary, and convert it to an [`OSVersion`].parse_os_version/// Parse an OS version from a bytestring like b"10.1" or b"14.3.7"./// Get a path relative to the root directory in which all files for the current env are located.__isPlatformVersionAtLeast/// Whether the current platform's OS version is higher than or equal to the given version./// The first argument is the _base_ Mach-O platform (i.e. `PLATFORM_MACOS`, `PLATFORM_IOS`, etc.,/// but not `PLATFORM_IOSSIMULATOR` or `PLATFORM_MACCATALYST`) of the invoking binary./// Arguments are specified statically by Clang. Inlining with LTO should allow the versions to be/// combined into a single `u32`, which should make comparisons faster, and should make the/// `BASE_TARGET_PLATFORM` check a no-op.// SAFETY: The signature is the same as what Clang expects, and we export weakly to allow linking// both this and `libclang_rt.*.a`, similar to how `compiler-builtins` does it:// https://github.com/rust-lang/compiler-builtins/blob/0.1.113/src/macros.rs#L494// NOTE: This symbol has a workaround in the compiler's symbol mangling to avoid mangling it, while// still not exposing it from non-cdylib (like `#[no_mangle]` would).// NOTE: Making this a weak symbol might not be entirely the right solution for this, `compiler_rt`// doesn't do that, it instead makes the symbol have "hidden" visibility. But since this is placed// in `libstd`, which might be used as a dylib, we cannot do the same here.// extern "C" is correct, Clang assumes the function cannot unwind:// https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/clang/lib/CodeGen/CGObjC.cpp#L3980// If an error happens in this, we instead abort the process.__isOSVersionAtLeast/// Old entry point for availability. Used when compiling with older Clang versions.// SAFETY: Same as for `__isPlatformVersionAtLeast`.//! # Runtime version checking ABI for other compilers.//! The symbols in this file are useful for us to expose to allow linking code written in the//! following languages when using their version checking functionality://! - Clang's `__builtin_available` macro.//! - Objective-C's `@available`.//! - Swift's `#available`,//! Without Rust exposing these symbols, the user would encounter a linker error when linking to//! C/Objective-C/Swift libraries using these features.//! The presence of these symbols is mostly considered a quality-of-implementation detail, and//! should not be relied upon to be available. The intended effect is that linking with code built//! with Clang's `__builtin_available` (or similar) will continue to work. For example, we may//! decide to remove `__isOSVersionAtLeast` if support for Clang 11 (Xcode 11) is dropped.//! The original discussion of this feature can be found at://! - <https://lists.llvm.org/pipermail/cfe-dev/2016-July/049851.html>//! - <https://reviews.llvm.org/D27827>//! - <https://reviews.llvm.org/D30136>//! And the upstream implementation of these can be found in `compiler-rt`://! <https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/compiler-rt/lib/builtins/os_version_check.c>//! Ideally, these symbols should probably have been a part of Apple's `libSystem.dylib`, both//! because their implementation is quite complex, using allocation, environment variables, file//! access and dynamic library loading (and emitting all of this into every binary).//! The reason why Apple chose to not do that originally is lost to the sands of time, but a good//! reason would be that implementing it as part of `compiler-rt` allowed them to back-deploy this//! to older OSes immediately.//! In Rust's case, while we may provide a feature similar to `@available` in the future, we will//! probably do so as a macro exposed by `std` (and not as a compiler builtin). So implementing this//! in `std` makes sense, since then we can implement it using `std` utilities, and we can avoid//! having `compiler-builtins` depend on `libSystem.dylib`.//! This does mean that users that attempt to link C/Objective-C/Swift code _and_ use `#![no_std]`//! in all their crates may get a linker error because these symbols are missing. Using `no_std` is//! quite uncommon on Apple systems though, so it's probably fine to not support this use-case.//! The workaround would be to link `libclang_rt.osx.a` or otherwise use Clang's `compiler-rt`.//! See also discussion in <https://github.com/rust-lang/compiler-builtins/pull/794>.//! ## Implementation details//! NOTE: Since macOS 10.15, `libSystem.dylib` _has_ actually provided the undocumented//! `_availability_version_check` via `libxpc` for doing the version lookup (zippered, which is why//! it requires a platform parameter to differentiate between macOS and Mac Catalyst), though its//! usage may be a bit dangerous, see://! - <https://reviews.llvm.org/D150397>//! - <https://github.com/llvm/llvm-project/issues/64227>//! Besides, we'd need to implement the version lookup via PList to support older versions anyhow,//! so we might as well use that everywhere (since it can also be optimized more after inlining).test_general_availabletest_saturatingcompare_against_sw_verssysctl_same_as_in_plistlookup_idempotentparse_plist/// Test parsing a bunch of different PLists found in the wild, to ensure that/// if we decide to parse it without CoreFoundation in the future, that it/// would continue to work, even on older platforms."SystemVersion.plist did not contain a dictionary at the top level"invalid_plistempty_plist//! Runtime lookup of operating system / platform version.//! Related to [RFC 3750](https://github.com/rust-lang/rfcs/pull/3750), which//! does version detection at compile-time.//! See also the `os_info` crate.// In the future, we could expand this module with:// - `RtlGetVersion` on Windows.// - `__system_property_get` on Android.EnvKeysaw_pathCommandEnv/// Stores a set of changes to an environment// Capture the current environment with these changes appliedis_unchangedcapture_if_changed// The following functions build up changesdoes_clearhave_changed_pathmaybe_saw_path// This module is shared by all platforms, but nearly all platforms except for// the "normal" UNIX ones leave some of this code unused.InheritMakePipeinto_rtenv_mutsimple_text_inputsimple_text_outputprogcreate_pipeuefi_command_internalPipeProtocolcreate_stdinInputProtocolstart_imageset_stdoutset_stderrset_stdinstdout_initstdout_inheritstderr_initstderr_inheritstdin_initstdin_inheritupdate_st_crc32ProtocolResetoutput_stringProtocolOutputStringProtocolTestStringquery_modeProtocolQueryModeProtocolSetModeProtocolSetAttributeclear_screenProtocolClearScreenProtocolSetCursorPositionenable_cursorProtocolEnableCursorreset_nulloutput_string_nullread_key_strokeProtocolReadKeyStrokewait_for_keynull_resetnull_read_keyInputKeyempty_notifycreate_argsenv_changes/// Create a map of environment variable changes. Allows efficient setting and rolling back of/// environment variable changes./// Entry: (Old Value, New Value)// CommandCStringArray/// Helper type to manage ownership of the strings within a C-style array./// This type manages an array of C-string pointers terminated by a null/// pointer. The pointer to the array (as returned by `as_ptr`) can be used as/// a value of `argv` or `environ`./// Creates a new `CStringArray` with enough capacity to hold `capacity`/// Replace the string at position `index`./// Push an additional string to the array./// Returns a pointer to the C-string array managed by this type.CStringIter/// Returns an iterator over all `CStr`s contained in this array.// SAFETY: `CStringArray` is basically just a `Vec<CString>`/// An iterator over all `CStr`s contained in a `CStringArray`.test_process_masktest_process_group_posix_spawntest_process_group_no_posix_spawntest_setsid_posix_spawntest_setsid_no_posix_spawntest_program_kindunix_exit_statuses// Test that Rust std handles wait status values (`ExitStatus`) the way that Unix does,// at least for the values which represent a Unix exit status (`ExitCode`).// Should work on every #[cfg(unix)] platform.  However:cstring_arrayDEV_NULL// Android with api less than 21 define sig* functions inline, so it is not// available for dynamic link. Implementing sigemptyset and sigaddset allow us// to support older Android version (independent of libc version).// The following implementations are based on// https://github.com/aosp-mirror/platform_bionic/blob/ad8dcd6023294b646e5a8288c0ed431b0845da49/libc/include/android/legacy_signal_inlines.hprogram_kindProgramKindsaw_nulclosurespgroupChildPipes// passed to do_exec() with configuration of what the child stdio should look// likePathLookup/// A program that would be looked up on the PATH (e.g. `ls`)/// A relative path (e.g. `my-dir/foo`, `../foo`, `./foo`)/// An absolute path.set_arg_0get_create_pidfdget_program_kindget_program_cstrget_pgroupget_chrootget_setsidget_closurescapture_envenv_saw_pathprogram_is_pathsetup_ioos2cconstruct_envpto_child_stdio// show all attributes but `self.closures` which does not implement `Debug`// and `self.argv` which is not useful for debuggingdo_exec// FIXME: The actually-Unix implementation in unix.rs uses WSTOPSIG, WCOREDUMP et al.// I infer from the implementation of `success`, `code` and `signal` above that these are not// available on Fuchsia.// It does not appear that Fuchsia is Unix-like enough to implement ExitStatus (or indeed many// other things from std::os::unix) properly. This veneer is always going to be a bodge. So// while I don't know if these implementations are actually correct, I think they will do for// now at least./// Converts a raw `c_int` to a type-safe `ExitStatus` by wrapping it without copying.// Processesexitstatus_display_teststest_command_fork_no_unwind// Many of the other aspects of this situation, including heap alloc concurrency// safety etc., are tested in tests/ui/process/process-panic-after-fork.rsdo_fork// Attempts to fork the process. If successful, returns Ok((0, -1))// in the child, and Ok((child_pid, -1)) in the parent.// And at this point we've reached a special time in the life of the// child. The child must now be considered hamstrung and unable to// do anything other than syscalls really. Consider the following// scenario://      1. Thread A of process 1 grabs the malloc() mutex//      2. Thread B of process 1 forks(), creating thread C//      3. Thread C of process 2 then attempts to malloc()//      4. The memory of process 2 is the same as the memory of//         process 1, so the mutex is locked.// This situation looks a lot like deadlock, right? It turns out// that this is what pthread_atfork() takes care of, which is// presumably implemented across platforms. The first thing that// threads to *before* forking is to do things like grab the malloc// mutex, and then after the fork they unlock it.// Despite this information, libnative's spawn has been witnessed to// deadlock on both macOS and FreeBSD. I'm not entirely sure why, but// all collected backtraces point at malloc/free traffic in the// child spawned process.// For this reason, the block of code below should contain 0// invocations of either malloc of free (or their related friends).// As an example of not having malloc/free traffic, we don't close// this file descriptor by dropping the FileDesc (which contains an// allocation). Instead we just close it manually. This will never// have the drop glue anyway because this code never returns (the// child will either exec() or invoke libc::exit)// Only support platforms for which posix_spawn() can return ENOENT// directly.send_pidfdrecv_pidfd// On Linux, stores the pidfd created for this child.// This is None if the user did not request pidfd creation,// or if the pidfd could not be created for some reason// (e.g. the `pidfd_open` syscall was not available)./// The unique ID of the process (this should never be negative)./// `pidfd` must either be -1 (representing no file descriptor) or a valid, exclusively owned file/// descriptor (See [I/O Safety])./// [I/O Safety]: crate::io#io-safety/// Unix exit statuses// This is not actually an "exit status" in Unix terminology.  Rather, it is a "wait status".// See the discussion in comments and doc comments for `std::process::ExitStatus`.from_waitid_siginfosignal_string/// Converts a signal number to a readable, searchable name./// This string should be displayed right after the signal number./// If a signal is unrecognized, it returns the empty string, so that/// you just get the number like "0". If it is recognized, you'll get/// something like "9 (SIGKILL)".linux_child_extcompare_with_linux// Test that our emulation exactly matches Linux// This test runs *on Linux* but it tests// the implementation used on non-Unix `#[cfg(unix)]` platforms.// I.e. we're using Linux as a proxy for "trad unix".// Note that tests in this file are run on Linux as well as on platforms using unsupportedwait_status/// Emulated wait status for use by `unsupported.rs`/// Uses the "traditional unix" encoding.  For use on platfors which are `#[cfg(unix)]`/// but do not actually support subprocesses at all./// These platforms aren't Unix, but are simply pretending to be for porting convenience./// So, we provide a faithful pretence here./// Converts a raw `c_int` to a type-safe `ExitStatus` by wrapping it"wait_status/tests.rs"// needed because this module is also imported through #[path] for testing purposes//! Emulated wait status for non-Unix #[cfg(unix) platforms//! Separate module to facilitate testing against a real Unix implementation./// The unique id of the process (this should never be negative).ParentStdoutParentStderrInheritFile// This variant exists only for the Debug impl// show all attributesmake_command_linetest_raw_argstest_thread_handletest_make_command_linewindows_env_unicode_case// On Windows, environment args are case preserving but comparisons are case-insensitive.// See: #85242windows_exe_resolver// UWP applications run in a restricted environment which means this test may not work.// This stores a UTF-16 encoded string to workaround the mismatch between// Rust's OsString (WTF-8) and the Windows API string type (UTF-16).// Normally converting on every API call is acceptable but here// `c::CompareStringOrdinal` will be called for every use of `==`.// Comparing Windows environment variable keys[1] are behaviorally the// composition of two operations[2]:// 1. Case-fold both strings. This is done using a language-independent// uppercase mapping that's unique to Windows (albeit based on data from an// older Unicode spec). It only operates on individual UTF-16 code units so// surrogates are left unchanged. This uppercase mapping can potentially change// between Windows versions.// 2. Perform an ordinal comparison of the strings. A comparison using ordinal// is just a comparison based on the numerical value of each UTF-16 code unit[3].// Because the case-folding mapping is unique to Windows and not guaranteed to// be stable, we ask the OS to compare the strings for us. This is done by// calling `CompareStringOrdinal`[4] with `bIgnoreCase` set to `TRUE`.// [1] https://docs.microsoft.com/en-us/dotnet/standard/base-types/best-practices-strings#choosing-a-stringcomparison-member-for-your-method-call// [2] https://docs.microsoft.com/en-us/dotnet/standard/base-types/best-practices-strings#stringtoupper-and-stringtolower// [3] https://docs.microsoft.com/en-us/dotnet/api/system.stringcomparison?view=net-5.0#System_StringComparison_Ordinal// [4] https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-comparestringordinal// Environment variable keys should preserve their original case even though// they are compared using a caseless string mapping.// not currently exposed in std::processforce_quotes_enabledfrom_stdio_idInheritSpecificresolve_exe// Resolve `exe_path` to the executable name.// * If the path is simply a file name then use the paths given by `search_paths` to find the executable.// * Otherwise use the `exe_path` as given.// This function may also append `.exe` to the name. The rationale for doing so is as follows:// It is a very strong convention that Windows executables have the `exe` extension.// In Rust, it is common to omit this extension.// Therefore this functions first assumes `.exe` was intended.// It falls back to the plain file name if a full path is given and the extension is omitted// or if only a file name is given and it already contains an extension.// Calls `f` for every path that should be used to find an executable.// Returns once `f` returns the path to an executable or all paths have been searched.program_exists/// Checks if a file exists without following symlinks.to_handle/// A value representing a child process./// The lifetime of this value is linked to the lifetime of the actual/// process - the Process destructor calls self.finish() which waits/// for the process to terminate./// Converts a raw `u32` to a type-safe `ExitStatus` by wrapping it without copying.zeroed_startupinfozeroed_process_information// Produces a wide string *without terminating null*; returns an error if// `prog` or any of the `args` contain a nul.command_prompt// Get `cmd.exe` for use with bat scripts, encoded as a UTF-16 string.make_envpmake_dirp//! Random data on Apple platforms.//! `CCRandomGenerateBytes` calls into `CCRandomCopyBytes` with `kCCRandomDefault`.//! `CCRandomCopyBytes` manages a CSPRNG which is seeded from the kernel's CSPRNG.//! We use `CCRandomGenerateBytes` instead of `SecCopyBytes` because it is accessible via//! `libSystem` (libc) while the other needs to link to `Security.framework`.//! Note that technically, `arc4random_buf` is available as well, but that calls//! into the same system service anyway, and `CCRandomGenerateBytes` has been//! proven to be App Store-compatible.//! Random data generation with `arc4random_buf`.//! Contrary to its name, `arc4random` doesn't actually use the horribly-broken//! RC4 cypher anymore, at least not on modern systems, but rather something//! like ChaCha20 with continual reseeding from the OS. That makes it an ideal//! source of large quantities of cryptographically secure data, which is exactly//! what we need for `DefaultRandomSource`. Unfortunately, it's not available//! on all UNIX systems, most notably Linux (until recently, but it's just a//! wrapper for `getrandom`. Since we need to hook into `getrandom` directly//! for `HashMap` keys anyway, we just keep our version).// FIXME: move these to libc (except Haiku, that one needs to link to libbsd.so).//! Random data generation using the Zircon kernel.//! Fuchsia, as always, is quite nice and provides exactly the API we need://! <https://fuchsia.dev/reference/syscalls/cprng_draw>.//! Random data generation through `getentropy`.//! Since issue 8 (2024), the POSIX specification mandates the existence of the//! `getentropy` function, which fills a slice of up to `GETENTROPY_MAX` bytes//! (256 on all known platforms) with random data. Unfortunately, it's only//! meant to be used to seed other CPRNGs, which we don't have, so we only use//! it where `arc4random_buf` and friends aren't available or secure (currently//! that's only the case on Emscripten).//! Random data generation with the Linux kernel.//! The first interface random data interface to be introduced on Linux were//! the `/dev/random` and `/dev/urandom` special files. As paths can become//! unreachable when inside a chroot and when the file descriptors are exhausted,//! this was not enough to provide userspace with a reliable source of randomness,//! so when the OpenBSD 5.6 introduced the `getentropy` syscall, Linux 3.17 got//! its very own `getrandom`  syscall to match.[^1] Unfortunately, even if our//! minimum supported version were high enough, we still couldn't rely on the//! syscall being available, as it is blocked in `seccomp` by default.//! The question is therefore which of the random sources to use. Historically,//! the kernel contained two pools: the blocking and non-blocking pool. The//! blocking pool used entropy estimation to limit the amount of available//! bytes, while the non-blocking pool, once initialized using the blocking//! pool, uses a CPRNG to return an unlimited number of random bytes. With a//! strong enough CPRNG however, the entropy estimation didn't contribute that//! much towards security while being an excellent vector for DoS attacks. Thus,//! the blocking pool was removed in kernel version 5.6.[^2] That patch did not//! magically increase the quality of the non-blocking pool, however, so we can//! safely consider it strong enough even in older kernel versions and use it//! unconditionally.//! One additional consideration to make is that the non-blocking pool is not//! always initialized during early boot. We want the best quality of randomness//! for the output of `DefaultRandomSource` so we simply wait until it is//! initialized. When `HashMap` keys however, this represents a potential source//! of deadlocks, as the additional entropy may only be generated once the//! program makes forward progress. In that case, we just use the best random//! data the system has available at the time.//! So in conclusion, we always want the output of the non-blocking pool, but//! may need to wait until it is initialized. The default behavior of `getrandom`//! is to wait until the non-blocking pool is initialized and then draw from there,//! so if `getrandom` is available, we use its default to generate the bytes. For//! `HashMap`, however, we need to specify the `GRND_INSECURE` flags, but that//! is only available starting with kernel version 5.6. Thus, if we detect that//! the flag is unsupported, we try `GRND_NONBLOCK` instead, which will only//! succeed if the pool is initialized. If it isn't, we fall back to the file//! access method.//! The behavior of `/dev/urandom` is inverse to that of `getrandom`: it always//! yields data, even when the pool is not initialized. For generating `HashMap`//! keys, this is not important, so we can use it directly. For secure data//! however, we need to wait until initialization, which we can do by `poll`ing//! `/dev/random`.//! TLDR: our fallback strategies are://! Secure data                                 | `HashMap` keys//! --------------------------------------------|------------------//! getrandom(0)                                | getrandom(GRND_INSECURE)//! poll("/dev/random") && read("/dev/urandom") | getrandom(GRND_NONBLOCK)//!                                             | read("/dev/urandom")//! [^1]: <https://lwn.net/Articles/606141/>//! [^2]: <https://lwn.net/Articles/808575/>// FIXME(in 2040 or so): once the minimum kernel version is 5.6, remove the// `GRND_NONBLOCK` fallback and use `/dev/random` instead of `/dev/urandom`// when secure data is required._rdrand16_step_rdrand32_step_rdrand64_stepRETRIESrdrand64rdrand32rdrand16TEE_GenerateRandomtrusty_rng_secure_randrng_protocol/// Port from [getrandom](https://github.com/rust-random/getrandom/blob/master/src/backends/rdrand.rs)//! Random data from `/dev/urandom`//! Before `getentropy` was standardized in 2024, UNIX didn't have a standardized//! way of getting random data, so systems just followed the precedent set by//! Linux and exposed random devices at `/dev/random` and `/dev/urandom`. Thus,//! for the few systems that support neither `arc4random_buf` nor `getentropy`//! yet, we just read from the file.STDIN_BUF_SIZEis_ebadfwith_std_fdunsupported_stdioKCALL_DEBUG_CMD_PUT_BYTESdebug_callsurrogateincomplete_utf8IncompleteUtf8// Implemented for use in Stdin::read.// UTF-16 character should occupy 4 bytes at most in UTF-8simple_text_input_readwait_stdin// Keep the default write_fmt so the `fmt::Arguments` are still evaluated.STDIO_CHANNELSTDOUT_BUF_SIZEwasip2clierror_to_ioutf16_to_utf8zero_size_read// Don't cache handles but get them fresh for every read/write. This allows us to track changes to// the value over time (such as if a process calls `SetStdHandle` while it's running). See #40490.// Apparently Windows doesn't handle large reads on stdin or writes to stdout/stderr well (see// #13304 for details).// From MSDN (2011): "The storage for this buffer is allocated from a shared heap for the// process that is 64 KB in size. The maximum size of the buffer will depend on heap usage."// We choose the cap at 8 KiB because libuv does the same, and it seems to be acceptable so far.// The standard buffer size of BufReader for Stdin should be able to hold 3x more bytes than there// are `u16`'s in MAX_BUFFER_SIZE. This ensures the read data can always be completely decoded from// UTF-16 to UTF-8.is_consoleis_utf8_console/// Returns true if the attached console's code page is currently UTF-8.write_console_utf16write_valid_utf8_to_consolewrite_u16sread_u16s_fixup_surrogates// We assume that if the last `u16` is an unpaired surrogate they got sliced apart by our// buffer size, and keep it around for the next read hoping to put them together.// This is a best effort, and might not work if we are not the only reader on Stdin.read_u16s// Returns `Ok(n)` if it initialized `n` values in `buf`.PanicWriter// Tests show that this does not seem to be reliably called at the end of a panic// print, so, we can't rely on this to e.g. trigger a graphics update.// The value of this atomic is simply incremented on every notification.// This is used by `.wait()` to not miss any notifications after// unlocking the mutex and before waiting for notifications.wait_optional_timeout// All the memory orderings here are `Relaxed`,// because synchronization is done by unlocking and locking the mutex.waiter_queueWaiterQueueListHead// These fields are only accessed through `&[mut] WaiterQueue`./// The waiting task's ID. Will be zeroed when the task is woken up/// and removed from a queue.///  - The caller must own `*waiter_ptr`. The caller will lose the///    ownership until `*waiter_ptr` is removed from `self`.///  - `*waiter_ptr` must be valid until it's removed from the queue.///  - `*waiter_ptr` must not have been previously inserted to a `WaiterQueue`./// Given a `Waiter` that was previously inserted to `self`, remove/// it from `self` if it's still there.is_queued/// Given a `Waiter` that was previously inserted to `self`, return a/// flag indicating whether it's still in `self`.//! POSIX conditional variable implementation based on user-space wait queues.// The implementation is inspired by the queue-based implementation shown in// Andrew D. Birrell's paper "Implementing Condition Variables with Semaphores"// FIXME: `UnsafeList` is not movable.NOTIFY_TRIESnotify_somewait_ms/// Unlock the given Mutex and wait for the notification. Wait at most/// `ms` milliseconds, or pass `0` to wait forever./// Returns `true` if the condition was received, `false` if it timed out// The implementation is inspired by Andrew D. Birrell's paper// "Implementing Condition Variables with Semaphores"// Only used on some platforms.CONTESTED_BIT// The lowest two bits of a `zx_handle_t` are always set, so the lowest bit is used to mark the// mutex as contested by clearing it.UNLOCKED// This can never be a valid `zx_handle_t`.to_owneris_contestedmark_contestedlock_contested/// `thread_self` must be the handle for the current thread.//! A priority inheriting mutex for Fuchsia.//! This is a port of the [mutex in Fuchsia's libsync]. Contrary to the original,//! it does not abort the process when reentrant locking is detected, but deadlocks.//! Priority inheritance is achieved by storing the owning thread's handle in an//! atomic variable. Fuchsia's futex operations support setting an owner thread//! for a futex, which can boost that thread's priority while the futex is waited//! libsync is licenced under the following BSD-style licence://! Copyright 2016 The Fuchsia Authors.//! Redistribution and use in source and binary forms, with or without//! modification, are permitted provided that the following conditions are//! met://!    * Redistributions of source code must retain the above copyright//!      notice, this list of conditions and the following disclaimer.//!    * Redistributions in binary form must reproduce the above//!      copyright notice, this list of conditions and the following//!      disclaimer in the documentation and/or other materials provided//!      with the distribution.//! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS//! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT//! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR//! A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT//! OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,//! SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT//! LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,//! DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY//! THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT//! (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE//! OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.//! [mutex in Fuchsia's libsync]: https://cs.opensource.google/fuchsia/fuchsia/+/main:zircon/system/ulib/sync/mutex.cCONTENDED// locked, no other threads waiting// Make this a diagnostic item for Miri's concurrency model checker.lock_contended// locked, and other threads waiting (contended)mtx/// The ID of the underlying mutex objectnew_mtx/// Creates a mutex object. This function never panics./// Gets the inner mutex's ID, which is lazily created.//! Mutex implementation backed by μITRON mutexes. Assumes `acre_mtx` and//! `TA_INHERIT` are available.// This platform has no threads, so we can use a Cell here.// no threads on this platform// Implementation according to “Operating Systems: Three Easy Pieces”, chapter 28srwlock//! System Mutexes//! The Windows implementation of mutexes is a little odd and it might not be//! immediately obvious what's going on. The primary oddness is that SRWLock is//! used instead of CriticalSection, and this is done because://! 1. SRWLock is several times faster than CriticalSection according to//!    benchmarks performed on both Windows 8 and Windows 7.//! 2. CriticalSection allows recursive locking while SRWLock deadlocks. The//!    Unix implementation deadlocks so consistency is preferred. See #19962 for//!    more details.//! 3. While CriticalSection is fair and SRWLock is not, the current Rust policy//!    is that there are no guarantees of fairness./// The "locked" value indicates how many threads are waiting on this/// Mutex. Possible values are:///     0: The lock is unlocked///     1: The lock is locked and uncontended///   >=2: The lock is locked and contended/// A lock is "contended" when there is more than one thread waiting/// for a lock, or it is locked for long periods of time. Rather than/// spinning, these locks send a Message to the ticktimer server/// requesting that they be woken up when a lock is unlocked.contended/// Whether this Mutex ever was contended, and therefore made a trip/// to the ticktimer server. If this was never set, then we were never/// on the slow path and can skip deregistering the mutex.try_lock_or_poison/// No initialization has run yet, and no thread is currently using the Once./// Some thread has previously attempted to initialize the Once, but it panicked,/// so the Once is now poisoned. There are no other threads currently accessing/// this Once./// Some thread is currently attempting to run initialization. It may succeed,/// so all future threads need to wait for it to finish./// Initialization has completed and all future calls should finish immediately./// By choosing this state as the all-zero state the `is_completed` check can be/// a bit faster on some platforms./// May only be set if the state is not COMPLETE.set_state_tostate_and_queuedset_state_on_drop_toCompletionGuard// On some platforms, the OS is very nice and handles the waiter queue for us.// This means we only need one atomic value with 4 states:// An additional bit indicates whether there are waiting threads:// Threads wait by setting the QUEUED bit and calling `futex_wait` on the state// variable. When the running thread finishes, it will wake all waiting threads using// `futex_wake_all`.// A "once" is a relatively simple primitive, and it's also typically provided// by the OS as well (see `pthread_once` or `InitOnceExecuteOnce`). The OS// primitives, however, tend to have surprising restrictions, such as the Unix// one doesn't allow an argument to be passed to the function.// As a result, we end up implementing it ourselves in the standard library.// This also gives us the opportunity to optimize the implementation a bit which// should help the fast path on call sites.// Safety: threads are not supported on this platform.StateAndQueuestate_and_queue// Four states that a Once can be in, encoded into the lower bits of// `state_and_queue` in the Once structure. By choosing COMPLETE as the all-zero// state the `is_completed` check can be a bit faster on some platforms.// Representation of a node in the linked list of waiters, used while in the// RUNNING state.// Note: `Waiter` can't hold a mutable pointer to the next thread, because then// `wait` would both hand out a mutable reference to its `Waiter` node, and keep// a shared reference to check `signaled`. Instead we hold shared references and// use interior mutability.// Head of a linked list of waiters.// Every node is a struct on the stack of a waiting thread.// Will wake up the waiters when it gets dropped, i.e. also on panic.to_queue// Each `Once` has one word of atomic state, and this state is CAS'd on to// determine what to do. There are four possible state of a `Once`:// * Incomplete - no initialization has run yet, and no thread is currently//                using the Once.// * Poisoned - some thread has previously attempted to initialize the Once, but//              it panicked, so the Once is now poisoned. There are no other//              threads currently accessing this Once.// * Running - some thread is currently attempting to run initialization. It may//             succeed, so all future threads need to wait for it to finish.//             Note that this state is accompanied with a payload, described//             below.// * Complete - initialization has completed and all future calls should finish//              immediately.// With 4 states we need 2 bits to encode this, and we use the remaining bits// in the word we have allocated as a queue of threads waiting for the thread// responsible for entering the RUNNING state. This queue is just a linked list// of Waiter nodes which is monotonically increasing in size. Each node is// allocated on the stack, and whenever the running closure finishes it will// consume the entire queue and notify all waiters they should try again.// You'll find a few more details in the implementation, but that's the gist of// it!// Futex orderings:// When running `Once` we deal with multiple atomics:// `Once.state_and_queue` and an unknown number of `Waiter.signaled`.// * `state_and_queue` is used (1) as a state flag, (2) for synchronizing the//   result of the `Once`, and (3) for synchronizing `Waiter` nodes.//     - At the end of the `call` function we have to make sure the result//       of the `Once` is acquired. So every load which can be the only one to//       load COMPLETED must have at least acquire ordering, which means all//       three of them.//     - `WaiterQueue::drop` is the only place that may store COMPLETED, and//       must do so with release ordering to make the result available.//     - `wait` inserts `Waiter` nodes as a pointer in `state_and_queue`, and//       needs to make the nodes available with release ordering. The load in//       its `compare_exchange` can be relaxed because it only has to compare//       the atomic, not to read other data.//     - `WaiterQueue::drop` must see the `Waiter` nodes, so it must load//       `state_and_queue` with acquire ordering.//     - There is just one store where `state_and_queue` is used only as a//       state flag, without having to synchronize data: switching the state//       from INCOMPLETE to RUNNING in `call`. This store can be Relaxed,//       but the read has to be Acquire because of the requirements mentioned//       above.// * `Waiter.signaled` is both used as a flag, and to protect a field with//   interior mutability in `Waiter`. `Waiter.thread` is changed in//   `WaiterQueue::drop` which then sets `signaled` with release ordering.//   After `wait` loads `signaled` with acquire ordering and sees it is true,//   it needs to see the changes to drop the `Waiter` struct correctly.// * There is one place where the two atomics `Once.state_and_queue` and//   `Waiter.signaled` come together, and might be reordered by the compiler or//   processor. Because both use acquire ordering such a reordering is not//   allowed, so no need for `SeqCst`./// Gets access to the value, assuming it is already initialized and this/// initialization has been observed by the current thread./// Since all modifications to the pointer have already been observed, the/// pointer load in this function can be performed with relaxed ordering,/// potentially allowing the optimizer to turn code like this:/// once_box.get_or_init(|| Box::pin(42));/// unsafe { once_box.get_unchecked() }/// into/// once_box.get_or_init(|| Box::pin(42))/// This causes undefined behavior if the assumption above is violated.//! A racily-initialized alternative to `OnceLock<Box<T>>`.//! This is used to implement synchronization primitives that need allocation,//! like the pthread versions.// The state consists of a 30-bit reader counter, a 'readers waiting' flag, and a 'writers waiting' flag.// Bits 0..30://   0: Unlocked//   1..=0x3FFF_FFFE: Locked by N readers//   0x3FFF_FFFF: Write locked// Bit 30: Readers are waiting on this futex.// Bit 31: Writers are waiting on the writer_notify futex.writer_notify// The 'condition variable' to notify writers through.// Incremented on every signal.READ_LOCKEDWRITE_LOCKEDDOWNGRADEMAX_READERS// READ_LOCKED - WRITE_LOCKEDREADERS_WAITINGWRITERS_WAITINGis_unlockedis_write_lockedhas_readers_waitinghas_writers_waitingis_read_lockableis_read_lockable_after_wakeuphas_reached_max_readers/// The `RwLock` must be read-locked (N readers) in order to call this.read_contended/// The `RwLock` must be write-locked (single writer) in order to call this.write_contendedwake_writer_or_readers/// Wakes up waiting threads after unlocking./// If both are waiting, this will wake up only one writer, but will fall/// back to waking up readers if there was no writer to wake up.wake_writer/// This wakes one writer and returns true if we woke up a writer that was/// blocked on futex_wait./// If this returns false, it might still be the case that we notified a/// writer that was about to go to sleep.spin_until/// Spin for a while, but stop directly at the given condition.spin_writespin_read/// The atomic lock state./// The inner lock state.QUEUE_LOCKEDDOWNGRADEDNODE_MASKSPIN_COUNT/// Locking uses exponential backoff. `SPIN_COUNT` indicates how many times the locking operation/// will be retried./// In other words, `spin_loop` will be called `2.pow(SPIN_COUNT) - 1` times.write_lock/// Marks the state as write-locked, if possible.read_lock/// Marks the state as read-locked, if possible.to_node/// Converts a `State` into a `Node` by masking out the bottom bits of the state, assuming that the/// state points to a queue node./// The state must contain a valid pointer to a queue node.AtomicLink/// The representation of a thread waiting on the lock queue./// We initialize these `Node`s on thread execution stacks to avoid allocation./// Note that we need an alignment of 16 to ensure that the last 4 bits of any/// pointers to `Node`s are always zeroed (for the bit flags described in the/// module-level documentation)./// An atomic node pointer with relaxed operations./// Creates a new queue node./// Prepare this node for waiting./// Wait until this node is marked as [`complete`](Node::complete)d by another thread./// May only be called from the thread that created the node./// Atomically mark this node as completed./// `node` must point to a valid `Node`, and the node may not outlive this call.find_tail_and_add_backlinks/// Traverse the queue and find the tail, adding backlinks to the queue while traversing./// This may be called from multiple threads at the same time as long as the queue is not being/// modified (this happens when unlocking multiple readers)./// * `head` must point to a node in a valid queue./// * `head` must be in front of the previous head node that was used to perform the last removal./// * The part of the queue starting with `head` must not be modified during this call.complete_all/// [`complete`](Node::complete)s all threads in the queue ending with `tail`./// * `tail` must be a valid tail of a fully linked queue./// * The current thread must have exclusive access to that queue.PanicGuard/// A type to guard against the unwinds of stacks that nodes are located on due to panics./// The public inner `RwLock` type.read_unlock_contended/// * There must be threads queued on the lock./// * `state` must be a pointer to a node in a valid queue./// * There cannot be a `downgrade` in progress.unlock_contended/// * The lock must be exclusively owned by this thread./// * The lock must be write-locked by this thread./// Downgrades the lock from write-locked to read-locked in the case that there are threads/// waiting on the wait queue./// This function will either wake up all of the waiters on the wait queue or designate the/// current holder of the queue lock to wake up all of the waiters instead. Once the waiters/// wake up, they will continue in the execution loop of `lock_contended`.unlock_queue/// Unlocks the queue. Wakes up all threads if a downgrade was requested, otherwise wakes up the/// next eligible thread(s) if the lock is unlocked./// * The queue lock must be held by the current thread.//! Efficient read-write locking without `pthread_rwlock_t`.//! The readers-writer lock provided by the `pthread` library has a number of problems which make it//! a suboptimal choice for `std`://! * It is non-movable, so it needs to be allocated (lazily, to make the constructor `const`).//! * `pthread` is an external library, meaning the fast path of acquiring an uncontended lock//! cannot be inlined.//! * Some platforms (at least glibc before version 2.25) have buggy implementations that can easily//! lead to undefined behaviour in safe Rust code when not properly guarded against.//! * On some platforms (e.g. macOS), the lock is very slow.//! Therefore, we implement our own [`RwLock`]! Naively, one might reach for a spinlock, but those//! can be quite [problematic] when the lock is contended.//! Instead, this [`RwLock`] copies its implementation strategy from the Windows [SRWLOCK] and the//! [usync] library implementations.//! Spinning is still used for the fast path, but it is bounded: after spinning fails, threads will//! locklessly add an information structure ([`Node`]) containing a [`Thread`] handle into a queue//! of waiters associated with the lock. The lock owner, upon releasing the lock, will scan through//! the queue and wake up threads as appropriate, and the newly-awoken threads will then try to//! acquire the lock themselves.//! The resulting [`RwLock`] is://! * adaptive, since it spins before doing any heavyweight parking operations//! * allocation-free, modulo the per-thread [`Thread`] handle, which is allocated anyways when//! using threads created by `std`//! * writer-preferring, even if some readers may still slip through//! * unfair, which reduces context-switching and thus drastically improves performance//! and also quite fast in most cases.//! [problematic]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html//! [SRWLOCK]: https://learn.microsoft.com/en-us/windows/win32/sync/slim-reader-writer--srw--locks//! [usync]: https://crates.io/crates/usync//! ## State//! A single [`AtomicPtr`] is used as state variable. The lowest four bits are used to indicate the//! meaning of the remaining bits://! | [`LOCKED`] | [`QUEUED`] | [`QUEUE_LOCKED`] | [`DOWNGRADED`] | Remaining    |                                                                                                                             |//! |------------|:-----------|:-----------------|:---------------|:-------------|:----------------------------------------------------------------------------------------------------------------------------|//! | 0          | 0          | 0                | 0              | 0            | The lock is unlocked, no threads are waiting                                                                                |//! | 1          | 0          | 0                | 0              | 0            | The lock is write-locked, no threads waiting                                                                                |//! | 1          | 0          | 0                | 0              | n > 0        | The lock is read-locked with n readers                                                                                      |//! | 0          | 1          | *                | 0              | `*mut Node`  | The lock is unlocked, but some threads are waiting. Only writers may lock the lock                                          |//! | 1          | 1          | *                | *              | `*mut Node`  | The lock is locked, but some threads are waiting. If the lock is read-locked, the last queue node contains the reader count |//! ## Waiter Queue//! When threads are waiting on the lock (the `QUEUE` bit is set), the lock state points to a queue//! of waiters, which is implemented as a linked list of nodes stored on the stack to avoid memory//! To enable lock-free enqueuing of new nodes to the queue, the linked list is singly-linked upon//! creation.//! When the lock is read-locked, the lock count (number of readers) is stored in the last link of//! the queue. Threads have to traverse the queue to find the last element upon releasing the lock.//! To avoid having to traverse the entire list every time we want to access the reader count, a//! pointer to the found tail is cached in the (current) first element of the queue.//! Also, while the lock is unfair for performance reasons, it is still best to wake the tail node//! first (FIFO ordering). Since we always pop nodes off the tail of the queue, we must store//! backlinks to previous nodes so that we can update the `tail` field of the (current) first//! element of the queue. Adding backlinks is done at the same time as finding the tail (via the//! function [`find_tail_and_add_backlinks`]), and thus encountering a set tail field on a node//! indicates that all following nodes in the queue are initialized.//! TLDR: Here's a diagram of what the queue looks like://! state//!   │//!   ▼//! ╭───────╮ next ╭───────╮ next ╭───────╮ next ╭───────╮//! │       ├─────►│       ├─────►│       ├─────►│ count │//! │       │      │       │      │       │      │       │//! │       │      │       │◄─────┤       │◄─────┤       │//! ╰───────╯      ╰───────╯ prev ╰───────╯ prev ╰───────╯//!                      │                           ▲//!                      └───────────────────────────┘//!                                  tail//! Invariants://! 1. At least one node must contain a non-null, current `tail` field.//! 2. The first non-null `tail` field must be valid and current.//! 3. All nodes preceding this node must have a correct, non-null `next` field.//! 4. All nodes following this node must have a correct, non-null `prev` field.//! Access to the queue is controlled by the `QUEUE_LOCKED` bit. Threads will try to set this bit//! in two cases: one is when a thread enqueues itself and eagerly adds backlinks to the queue//! (which drastically improves performance), and the other is after a thread unlocks the lock to//! wake up the next waiter(s).//! `QUEUE_LOCKED` is set atomically at the same time as the enqueuing/unlocking operations. The//! thread releasing the `QUEUE_LOCKED` bit will check the state of the lock (in particular, whether//! a downgrade was requested using the [`DOWNGRADED`] bit) and wake up waiters as appropriate. This//! guarantees forward progress even if the unlocking thread could not acquire the queue lock.//! ## Memory Orderings//! To properly synchronize changes to the data protected by the lock, the lock is acquired and//! released with [`Acquire`] and [`Release`] ordering, respectively. To propagate the//! initialization of nodes, changes to the queue lock are also performed using these orderings.rwl// Safety: `num_readers` is protected by `mtx_num_readers`new_rwl//! A readers-writer lock implementation backed by the SOLID kernel extension.dispatch_semaphore_tdispatch_time_tDISPATCH_TIME_NOWDISPATCH_TIME_FOREVERdispatch_timedispatch_semaphore_createdispatch_semaphore_waitdispatch_semaphore_signaldispatch_releasenew_in_place// Does not need `Pin`, but other implementation do.//! Thread parking for Darwin-based systems.//! Darwin actually has futex syscalls (`__ulock_wait`/`__ulock_wake`), but they//! cannot be used in `std` because they are non-public (their use will lead to//! rejection from the App Store).//! Therefore, we need to look for other synchronization primitives. Luckily, Darwin//! supports semaphores, which allow us to implement the behavior we need with//! only one primitive (as opposed to a mutex-condvar pair). We use the semaphore//! provided by libdispatch, as the underlying Mach semaphore is only dubiously//! public.// Contained in libSystem.dylib, which is linked by default./// Constructs the futex parker. The UNIX parker implementation/// requires this to happen in-place.// Assumes this is only called by the thread that owns the Parker,// which means that `self.state != PARKED`.// which means that `self.state != PARKED`. This implementation doesn't// require `Pin`, but other implementations do.// This implementation doesn't require `Pin`, but other implementations do.// Notes about memory ordering:// Memory ordering is only relevant for the relative ordering of operations// between different variables. Even Ordering::Relaxed guarantees a// monotonic/consistent order when looking at just a single atomic variable.// So, since this parker is just a single atomic variable, we only need to look// at the ordering guarantees we need to provide to the 'outside world'.// The only memory ordering guarantee that parking and unparking provide, is// that things which happened before unpark() are visible on the thread// returning from park() afterwards. Otherwise, it was effectively unparked// before unpark() was called while still consuming the 'token'.// In other words, unpark() needs to synchronize with the part of park() that// consumes the token and returns.// This is done with a release-acquire synchronization, by using// Ordering::Release when writing NOTIFIED (the 'token') in unpark(), and using// Ordering::Acquire when checking for this state in park()./// Creates a new thread parker. UNIX requires this to happen in-place.init_tid/// * must always be called from the same thread/// * must be called before the state is set to PARKED//! Thread parking using thread ids.//! Some platforms (notably NetBSD) have thread parking primitives whose semantics//! match those offered by `thread::park`, with the difference that the thread to//! be unparked is referenced by a platform-specific thread id. Since the thread//! parker is constructed before that id is known, an atomic state variable is used//! to manage the park state and propagate the thread id. This also avoids platform//! calls in the case where `unpark` is called before `park`./// Constructs the UNIX parker in-place./// The constructed parker must never be moved.// This implementation doesn't require `unsafe`, but other implementations// may assume this is only called by the thread that owns the Parker.// For memory ordering, see futex.rs// may assume this is only called by the thread that owns the Parker. Use// `Pin` to guarantee a stable address for the mutex and condition variable.//! Thread parking without `futex` using the `pthread` synchronization primitives./// Constructs the Windows parker. The UNIX parker implementation// which means that `self.state != PARKED`. This implementation doesn't require `Pin`,// but other implementations do.// Ordering::Acquire when reading this state in park() after waking up.keyed_event_handlekeyed_events// Thread parker implementation for Windows.// This uses WaitOnAddress and WakeByAddressSingle if available (Windows 8+).// This modern API is exactly the same as the futex syscalls the Linux thread// parker uses. When These APIs are available, the implementation of this// thread parker matches the Linux thread parker exactly.// However, when the modern API is not available, this implementation falls// back to NT Keyed Events, which are similar, but have some important// differences. These are available since Windows XP.// WaitOnAddress first checks the state of the thread parker to make sure it no// WakeByAddressSingle calls can be missed between updating the parker state// and calling the function.// NtWaitForKeyedEvent does not have this option, and unconditionally blocks// without checking the parker state first. Instead, NtReleaseKeyedEvent// (unlike WakeByAddressSingle) *blocks* until it woke up a thread waiting for// it by NtWaitForKeyedEvent. This way, we can be sure no events are missed,// but we need to be careful not to block unpark() if park_timeout() was woken// up by a timeout instead of unpark().// Unlike WaitOnAddress, NtWaitForKeyedEvent/NtReleaseKeyedEvent operate on a// HANDLE (created with NtCreateKeyedEvent). This means that we can be sure// a successfully awoken park() was awoken by unpark() and not a// NtReleaseKeyedEvent call from some other code, as these events are not only// matched by the key (address of the parker (state)), but also by this HANDLE.// We lazily allocate this handle the first time it is needed.// The fast path (calling park() after unpark() was already called) and the// possible states are the same for both implementations. This is used here to// make sure the fast path does not even check which API to use, but can return// right away, independent of the used API. Only the slow paths (which will// actually block/wake a thread) check which API is available and have// different implementations.// Unfortunately, NT Keyed Events are an undocumented Windows API. However:// - This API is relatively simple with obvious behavior, and there are//   several (unofficial) articles documenting the details. [1]// - `parking_lot` has been using this API for years (on Windows versions//   before Windows 8). [2] Many big projects extensively use parking_lot,//   such as servo and the Rust compiler itself.// - It is the underlying API used by Windows SRW locks and Windows critical//   sections. [3] [4]// - The source code of the implementations of Wine, ReactOs, and Windows XP//   are available and match the expected behavior.// - The main risk with an undocumented API is that it might change in the//   future. But since we only use it for older versions of Windows, that's not//   a problem.// - Even if these functions do not block or wake as we expect (which is//   unlikely, see all previous points), this implementation would still be//   memory safe. The NT Keyed Events API is only used to sleep/block in the//   right place.// [1]: http://www.locklessinc.com/articles/keyed_events/// [2]: https://github.com/Amanieu/parking_lot/commit/43abbc964e// [3]: https://docs.microsoft.com/en-us/archive/msdn-magazine/2012/november/windows-with-c-the-evolution-of-synchronization-in-windows-and-c// [4]: Windows Internals, Part 1, ISBN 9780735671300ThreadInitDEFAULT_MIN_STACK_SIZEnew_with_coreidcurrent_os_idsys_threadtask_queueJoinNotifierwait_notify"_ZN16__rust_internals3std3sys3pal3sgx6thread10TASK_QUEUEE"TASK_QUEUE/// Notify the waiter. The waiter is either notified right away (if/// currently blocked in `Waiter::wait()`) or later when it calls the/// `Waiter::wait()` method./// Wait for a notification. If `Notifier::notify()` has already been/// called, this will return immediately, otherwise the current thread/// is blocked until notified./// This module provides a synchronization primitive that does not use thread/// local variables. This is needed for signaling that a thread has finished/// execution. The signal is sent once all TLS destructors have finished at/// which point no new thread locals should be created.// unsafe: see thread::Builder::spawn_unchecked for safety requirements// why is this necessary?p_innerThreadInner/// The ID of the underlying task.// Safety: There's nothing in `Thread` that ties it to the original creator. It//         can be dropped by any threads.// Safety: `Thread` provides no methods that take `&self`./// This field is used on thread creation to pass initialization data from/// `Thread::new` to the created task./// A state machine. Each transition is annotated with `[...]` in the/// source code.///    <P>: parent, <C>: child, (?): don't-care///       DETACHED (-1)  -------------------->  EXITED (?)///                        <C>finish/exd_tsk///          | <P>detach///       INIT (0)  ----------------------->  FINISHED (-1)///                        <C>finish///          |                                    |///          | <P>join/slp_tsk                    | <P>join/del_tsk///          |                                    | <P>detach/del_tsk///          v                                    v///       JOINING                              JOINED (?)///     (parent_tid)///                                            ^///             \                             ////              \  <C>finish/wup_tsk        / <P>slp_tsk-complete/ter_tsk///               \                         /                      & del_tsk///                \                       ////                 '--> JOIN_FINALIZE ---'///                          (-1)/// State data shared between a parent thread and child thread. It's dropped on/// a transition to one of the final states.// Safety: The only `!Sync` field, `ThreadInner::init`, is only touched by//         the task represented by `ThreadInner`.LIFECYCLE_INITLIFECYCLE_FINISHEDLIFECYCLE_DETACHEDLIFECYCLE_JOIN_FINALIZELIFECYCLE_DETACHED_OR_JOINEDLIFECYCLE_EXITED_OR_FINISHED_OR_JOIN_FINALIZE// 64KiB for 32-bit ISAs, 128KiB for 64-bit ISAs./// See `thread::Builder::spawn_unchecked` for safety requirements.terminate_and_delete_task/// Terminates and deletes the specified task./// This function will abort if `deleted_task` refers to the calling task./// It is assumed that the specified task is solely managed by the caller -/// i.e., other threads must not "resuscitate" the specified task or delete it/// prematurely while this function is still in progress. It is allowed for the/// specified task to exit by its own./// The task must be safe to terminate. This is in general not true/// because there might be pinned references to the task's stack.terminate_and_delete_current_task/// Terminates and deletes the calling task./// Atomicity is not required - i.e., it can be assumed that other threads won't/// `ter_tsk` the calling task while this function is still in progress. (This/// property makes it easy to implement this operation on μITRON-derived kernels/// that don't support `exd_tsk`.)//! Thread implementation backed by μITRON tasks. Assumes `acre_tsk` and//! `exd_tsk` are available.// there's no single value for `JOINING`TEE_Waitmin_stack_size// Some platforms may have pthread_t as a pointer in which case we still want// a thread to be Send/Sync/// must join, because no pthread_detach supported/// only main thread could wait for sometime in teeosMAX_WITH_NULtruncate_cstr// Any unix that has clock_nanosleep// If this list changes update the MIRI chock_nanosleep shim/// Returns cgroup CPU quota in core-equivalents, rounded down or usize::MAX if the quota cannot/// be determined or is not set.quota_v2quota_v1find_mountpoint/// Scan mountinfo for cgroup v1 mountpoint with a cpu controller/// If the cgroupfs is a bind mount then `group_path` is adjusted to skip/// over the already-included prefix//! Currently not covered//! * cgroup v2 in non-standard mountpoints//! * paths containing control characters or spaces, since those would be escaped in procfs//!   output and we don't unescapecgroups// glibc >= 2.15 has a __pthread_get_minstack() function that returns// PTHREAD_STACK_MIN plus bytes needed for thread-local storage.// We need that information to avoid blowing up when a small stack// is created in an application with big thread-local storage requirements.// See #6233 for rationale and details.// 0 indicates that the stack size configured in the ESP-IDF/NuttX menuconfig system should be useddummy_init_call// Silence dead code warnings for the otherwise unused ThreadInit::init() call.pthread_attr_union__i==__vi__s// defined in wasi-libc// https://github.com/WebAssembly/wasi-libc/blob/a6f871343313220b76009827ed0153586361c0d5/libc-top-half/musl/include/alltypes.h.in#L108__uset_name_wide/// `name` must end with a zero valueMIN_STACK_SIZEGUARD_PAGE_SIZE//! Destructor registration for Linux-like systems.//! Since what appears to be version 2.18, glibc has shipped the//! `__cxa_thread_atexit_impl` symbol which GCC and clang both use to invoke//! destructors in C++ thread_local globals. This function does exactly what//! we want: it schedules a callback which will be run at thread exit with the//! provided argument.//! Unfortunately, our minimum supported glibc version (at the time of writing)//! is 2.17, so we can only link this symbol weakly and need to use the//! [`list`](super::list) destructor implementation as fallback.DTORS/// The [`guard`] module contains platform-specific functions which will run this/// function on thread exit if [`guard::enable`] has been called./// May only be run on thread exit to guarantee that there are no live references/// to TLS variables while they are destroyed.//! macOS allows registering destructors through _tlv_atexit. But since calling//! it while TLS destructors are running is UB, we still need to keep our own//! list of destructors.LazyKey//! A lot of UNIX platforms don't have a specialized way to register TLS//! destructors for native TLS. Instead, we use one TLS key with a destructor//! that will run all native TLS destructors in the destructor list.//! SOLID, just like macOS, has an API to register TLS destructors. But since//! it does not allow specifying an argument to that function, and will not run//! destructors for terminated tasks, we still keep our own list."_tls_used"TLS_USED".CRT$XLB"// Miri only considers explicitly `#[used]` statics for `lookup_link_section`tls_callback//! Support for Windows TLS destructors.//! Unfortunately, Windows does not provide a nice API to provide a destructor//! for a TLS variable. Thus, the solution here ended up being a little more//! obscure, but fear not, the internet has informed me [1][2] that this solution//! is not unique (no way I could have thought of it as well!). The key idea is//! to insert some hook somewhere to run arbitrary code on thread termination.//! With this in place we'll be able to run anything we like, including all//! TLS destructors!//! In order to realize this, all TLS destructors are tracked by *us*, not the//! Windows runtime. This means that we have a global list of destructors for//! each TLS key or variable that we know about.//! # What's up with CRT$XLB?//! For anything about TLS destructors to work on Windows, we have to be able//! to run *something* when a thread exits. To do so, we place a very special//! static in a very special location. If this is encoded in just the right//! way, the kernel's loader is apparently nice enough to run some function//! of ours whenever a thread exits! How nice of the kernel!//! Lots of detailed information can be found in source [1] above, but the//! gist of it is that this is leveraging a feature of Microsoft's PE format//! (executable format) which is not actually used by any compilers today.//! This apparently translates to any callbacks in the ".CRT$XLB" section//! being run on certain events.//! So after all that, we use the compiler's `#[link_section]` feature to place//! a callback pointer into the magic section so it ends up being called.//! # What's up with this callback?//! The callback specified receives a number of parameters from... someone!//! (the kernel? the runtime? I'm not quite sure!) There are a few events that//! this gets invoked for, but we're currently only interested on when a//! thread or a process "detaches" (exits). The process part happens for the//! last thread and the thread part happens for any normal thread.//! # The article mentions weird stuff about "/INCLUDE"?//! It sure does! Specifically we're talking about this quote://! ```quote//! The Microsoft run-time library facilitates this process by defining a//! memory image of the TLS Directory and giving it the special name//! “__tls_used” (Intel x86 platforms) or “_tls_used” (other platforms). The//! linker looks for this memory image and uses the data there to create the//! TLS Directory. Other compilers that support TLS and work with the//! Microsoft linker must use this same technique.//! Basically what this means is that if we want support for our TLS//! destructors/our hook being called then we need to make sure the linker does//! not omit this symbol. Otherwise it will omit it and our callback won't be//! wired up.//! We don't actually use the `/INCLUDE` linker flag here like the article//! mentions because the Rust compiler doesn't propagate linker flags, but//! instead we use a shim function which performs a volatile 1-byte load from//! the address of the _tls_used symbol to ensure it sticks around.//! [1]: https://www.codeproject.com/Articles/8113/Thread-Local-Storage-The-C-Way//! [2]: https://github.com/ChromiumWebApps/chromium/blob/master/base/threading/thread_local_storage_win.cc#L42/// Inner static TLS key (internals)./// Destructor for the TLS value./// A type for TLS keys that are statically allocated./// This is basically a `LazyLock<Key>`, but avoids blocking and circular/// dependencies with the rest of `std`.KEY_SENTVAL// Define a sentinel value that is likely not to be returned// as a TLS key.lazy_init//! A `LazyKey` implementation using racy initialization.//! Unfortunately, none of the platforms currently supported by `std` allows//! creating TLS keys at compile-time. Thus we need a way to lazily create keys.//! Instead of blocking API like `OnceLock`, we use racy initialization, which//! should be more lightweight and avoids circular dependencies with the rest of//! `std`.AbiKey/// The key value shifted up by one. Since TLS_OUT_OF_INDEXES == u32::MAX/// is not a valid key value, this allows us to use zero as sentinel value/// without risking overflow./// Currently, destructors cannot be unregistered, so we cannot use racy/// initialization for keys. Instead, we need synchronize initialization./// Use the Windows-provided `Once` since it does not require TLS.register_dtor/// Should only be called once per key, otherwise loops or breaks may occur in/// the linked list.run_dtors/// This will and must only be run by the destructor callback in [`guard`].//! Implementation of `LazyKey` for Windows.//! Windows has no native support for running destructors so we manage our own//! list of destructors to keep track of how to destroy keys. We then install a//! callback later to get invoked whenever a thread exits, running all//! appropriate destructors (see the [`guard`](guard) module documentation).//! This will likely need to be improved over time, but this module attempts a//! "poor man's" destructor callback system. Once we've got a list of what to//! run, we iterate over all keys, check their values, and then run destructors//! if the values turn out to be non null (setting them to null just beforehand).//! We do this a few times in a loop to basically match Unix semantics. If we//! don't reach a fixed point after a short while then we just inevitably leak//! something.//! The list is implemented as an atomic single-linked list of `LazyKey`s and//! does not support unregistration. Unfortunately, this means that we cannot//! use racy initialization for creating the keys in `LazyKey`, as that could//! result in destructors being missed. Hence, we synchronize the creation of//! keys with destructors through [`INIT_ONCE`](c::INIT_ONCE) (`std`'s//! [`Once`](crate::sync::Once) cannot be used since it might use TLS itself).//! For keys without destructors, racy initialization suffices.// FIXME: investigate using a fixed-size array instead, as the maximum number//        of keys is [limited to 1088](https://learn.microsoft.com/en-us/windows/win32/ProcThread/thread-local-storage).TLS_MEMORY_SIZE"_ZN16__rust_internals3std3sys4xous16thread_local_key13TLS_KEY_INDEXE"TLS_KEY_INDEX/// TLS keys start at `1`. Index `0` is unused"_ZN16__rust_internals3std3sys4xous16thread_local_key9DTORSE"tls_ptr_addrtls_table/// Creates an area of memory that's unique per thread. This area will/// contain all thread local pointers.destroy_tls// This is marked inline(never) to prevent dealloc calls from being reordered// to after the TLS has been destroyed.// See https://github.com/rust-lang/rust/pull/144465#pullrequestreview-3289729950// for more context.//! Thread Local Storage//! Currently, we are limited to 1023 TLS entries. The entries//! live in a page of memory that's unique per-process, and is//! stored in the `$tp` register. If this register is 0, then//! TLS has not been initialized and thread cleanup can be skipped.//! The index into this register is the `key`. This key is identical//! between all threads, but indexes a different offset within this//! pointer.//! # Dtor registration (stolen from Windows)//! Xous has no native support for running destructors so we manage our own//! list of destructors to keep track of how to destroy keys. When a thread//! or the process exits, `run_dtors` is called, which will iterate through//! the list and run the destructors.//! Currently unregistration from this list is not supported. A destructor can be//! registered but cannot be unregistered. There's various simplifying reasons//! for doing this, the big ones being://! 1. Currently we don't even support deallocating TLS keys, so normal operation//!    doesn't need to deallocate a destructor.//! 2. There is no point in time where we know we can unregister a destructor//!    because it could always be getting run by some remote thread.//! Typically processes have a statically known set of TLS keys which is pretty//! small, and we'd want to keep this memory alive for the whole process anyway//! really.//! Perhaps one day we can fold the `Box` here into a static allocation,//! expanding the `LazyKey` structure to contain not only a slot for the TLS//! key but also a slot for the destructor queue on windows. An optimization for//! another day!// FIXME(joboet): implement support for native TLS instead.EagerStorageLazyStoragethread_local_innerLocalPointerlocal_pointer/// The native TLS implementation needs a way to register destructors for its data./// This module contains platform-specific implementations of that register./// It turns out however that most platforms don't have a way to register a/// destructor for each variable. On these platforms, we keep track of the/// destructors ourselves and register (through the [`guard`] module) only a/// single callback that runs all of the destructors in the list./// This module provides a way to schedule the execution of the destructor list/// and the [runtime cleanup](crate::rt::thread_cleanup) function. Calling `enable`/// should ensure that these functions are called at the right times.racy/// `const`-creatable TLS keys./// Most OSs without native TLS will provide a library-based way to create TLS/// storage. For each TLS variable, we create a key, which can then be used to/// reference an entry in a thread-local table. This then associates each key/// with a pointer which we can get and set to store our data.abort_on_dtor_unwind/// Run a callback in a scenario which must not unwind (such as a `extern "C"/// fn` declared in a user crate). If the callback unwinds anyway, then/// `rtabort` with a message about thread local panicking on drop.//! Implementation of the `thread_local` macro.//! There are three different thread-local implementations://! * Some targets lack threading support, and hence have only one thread, so//!   the TLS data is stored in a normal `static`.//! * Some targets support TLS natively via the dynamic linker and C runtime.//! * On some targets, the OS provides a library-based TLS implementation. The//!   TLS data is heap-allocated and referenced using a TLS key.//! Each implementation provides a macro which generates the `LocalKey` `const`//! used to reference the TLS variable, along with the necessary helper structs//! to track the initialization/destruction state of the variable.//! Additionally, this module contains abstractions for the OS interfaces used//! for these implementations.Alive// This field must be first, for correctness of `#[rustc_align_static]`/// Gets a pointer to the TLS value. If the TLS variable has been destroyed,/// a null pointer is returned./// The resulting pointer may not be used after thread destruction has/// occurred./// The `self` reference must remain valid until the TLS destructor is run./// Transition an `Alive` TLS variable into the `Destroyed` state, dropping its/// * Must only be called at thread destruction./// * `ptr` must point to an instance of `Storage` with `Alive` state and be///   valid for accessing that instance.DestroyedState/// Gets a pointer to the TLS value, potentially initializing it with the/// provided parameters. If the TLS variable has been destroyed, a null/// pointer is returned./// The resulting pointer may not be used after reentrant inialialization/// or thread destruction has occurred.get_or_init_slow/// * `ptr` must point to an instance of `Storage<T, ()>` and be valid for///   accessing that instance.eager__new//! Thread local support for platforms with native TLS.//! To achieve the best performance, we choose from four different types for//! the TLS variable, depending on the method of initialization used (`const`//! or lazy) and the drop requirements of the stored type://! |         | `Drop`               | `!Drop`             |//! |--------:|:--------------------:|:-------------------:|//! | `const` | `EagerStorage<T>`    | `T`                 |//! | lazy    | `LazyStorage<T, ()>` | `LazyStorage<T, !>` |//! For `const` initialization and `!Drop` types, we simply use `T` directly,//! but for other situations, we implement a state machine to handle//! initialization of the variable and its destructor and destruction.//! Upon accessing the TLS variable, the current state is compared://! 1. If the state is `Initial`, initialize the storage, transition the state//!    to `Alive` and (if applicable) register the destructor, and return a//!    reference to the value.//! 2. If the state is `Alive`, initialization was previously completed, so//!    return a reference to the value.//! 3. If the state is `Destroyed`, the destructor has been run already, so//!    return [`None`].//! The TLS destructor sets the state to `Destroyed` and drops the current value.//! To simplify the code, we make `LazyStorage` generic over the destroyed state//! and use the `!` type (never type) as type parameter for `!Drop` types. This//! eliminates the `Destroyed` state for these values, which can allow more niche//! optimizations to occur for the `State` enum. For `Drop` types, `()` is used.// Required for correctness of `#[rustc_align_static]`// SAFETY: the target doesn't have threads.Destroying/// provided parameters./// has occurred.//! On some targets like wasm there's no threads, so no need to generate//! thread locals and we can instead just use plain statics!/// Use a regular global static to store this key; the state provided will then be/// thread-local./// INVARIANT: ALIGN must be a valid alignment, and no less than `value_align::<T>`.// INVARIANT: if this value is stored under a TLS key, `key` must be that `key`.value_alignAlignedSystemBox/// Equivalent to `Box<Value<T>, System>`, but potentially over-aligned.try_initialize/// * `key` must be the result of calling `self.key.force()`/// * `ptr` must be the current value associated with `key`.destroy_value/// A trait for viewing representations from std types/// A trait for extracting representations from std types/// A trait for creating std types from internal representations// Computes (value*numerator)/denom without overflow, as long as both (numerator*denom) and the// overall result fit into i64 (which is the case for our time conversions).//! Platform-independent platform abstraction//! This is the platform-independent portion of the standard library's//! platform abstraction layer, whereas `std::sys` is the//! platform-specific portion.//! The relationship between `std::sys_common`, `std::sys` and the//! rest of `std` is complex, with dependencies going in all//! directions: `std` depending on `sys_common`, `sys_common`//! depending on `sys`, and `sys` depending on `sys_common` and `std`.//! This is because `sys_common` not only contains platform-independent code,//! but also code that is shared between the different platforms in `sys`.//! Ideally all that shared code should be moved to `sys::common`,//! and the dependencies between `std`, `sys_common` and `sys` all would form a DAG.//! Progress on this is tracked in #84187.// common error constructorstest_muldivlpwstr// The pointer must never be null...// ...and the memory it points to must be valid for this lifetime./// A safe iterator over a LPWSTR/// (aka a pointer to a series of UTF-16 code units terminated by a NULL)./// Creates the iterator. Returns `None` if `lpwstr` is null./// SAFETY: `lpwstr` must point to a null-terminated wide string that lives/// at least as long as the lifetime of this struct.advance_while/// Advance the iterator while `predicate` returns true./// Returns the number of items it advanced by.// This can never return zero as that marks the end of the string.//! This module contains constructs to work with 16-bit characters (UCS-2 or UTF-16)/// Test-only replacement for `rand::thread_rng()`, which is unusable for/// us, as we want to allow running stdlib tests on tier-3 targets which may/// not have `getrandom` support./// Does a bit of a song and dance to ensure that the seed is different on/// each call (as some tests sadly rely on this), but doesn't try that hard./// This is duplicated in the `core`, `alloc` test suites (as well as/// `std`'s integration tests), but figuring out a mechanism to share these/// seems far more painful than copy-pasting a 7 line function a couple/// times, given that even under a perma-unstable feature, I don't think we/// want to expose types from `rand` from `std`.// for `test_rng`"must eventually spawn the thread"/// A name for the thread-to-be, for identification in panic messages/// The size of the stack for the spawned thread in bytes/// Skip running and inheriting the thread spawn hooks/// Thread factory, which can be used in order to configure the properties of/// a new thread./// Methods can be chained on it in order to configure it./// The two configurations available are:/// - [`name`]: specifies an [associated name for the thread][naming-threads]/// - [`stack_size`]: specifies the [desired stack size for the thread][stack-size]/// The [`spawn`] method will take ownership of the builder and create an/// [`io::Result`] to the thread handle with the given configuration./// The [`thread::spawn`] free function uses a `Builder` with default/// configuration and [`unwrap`]s its return value./// You may want to use [`spawn`] instead of [`thread::spawn`], when you want/// to recover from a failure to launch a thread, indeed the free function will/// panic where the `Builder` method will return a [`io::Result`]./// let builder = thread::Builder::new();/// let handler = builder.spawn(|| {///     // thread code/// handler.join().unwrap();/// [`stack_size`]: Builder::stack_size/// [`thread::spawn`]: super::spawn/// [`io::Result`]: crate::io::Result/// [`unwrap`]: crate::result::Result::unwrap/// [naming-threads]: ./index.html#naming-threads/// [stack-size]: ./index.html#stack-size/// Generates the base configuration for spawning a thread, from which/// configuration methods can be chained./// let builder = thread::Builder::new()///                               .name("foo".into())///                               .stack_size(32 * 1024);/// Names the thread-to-be. Currently the name is used for identification/// only in panic messages./// For more information about named threads, see/// [this module-level documentation][naming-threads].///     .name("foo".into());///     assert_eq!(thread::current().name(), Some("foo"))/// Sets the size of the stack (in bytes) for the new thread./// The actual stack size may be greater than this value if/// the platform specifies a minimal stack size./// For more information about the stack size for threads, see/// [this module-level documentation][stack-size]./// let builder = thread::Builder::new().stack_size(32 * 1024);/// Disables running and inheriting [spawn hooks]./// Use this if the parent thread is in no way relevant for the child thread./// For example, when lazily spawning threads for a thread pool./// [spawn hooks]: super::add_spawn_hook/// Spawns a new thread by taking ownership of the `Builder`, and returns an/// [`io::Result`] to its [`JoinHandle`]./// The spawned thread may outlive the caller (unless the caller thread/// is the main thread; the whole process is terminated when the main/// thread finishes). The join handle can be used to block on/// termination of the spawned thread, including recovering its panics./// For a more complete documentation see [`thread::spawn`]./// Unlike the [`spawn`] free function, this method yields an/// [`spawn`]: super::spawn/// Spawns a new thread without any lifetime restrictions by taking ownership/// of the `Builder`, and returns an [`io::Result`] to its [`JoinHandle`]./// This method is identical to [`thread::Builder::spawn`][`Builder::spawn`],/// except for the relaxed lifetime bounds, which render it unsafe./// The caller has to ensure that the spawned thread does not outlive any/// references in the supplied thread closure and its return type./// This can be guaranteed in two ways:/// - ensure that [`join`][`JoinHandle::join`] is called before any referenced/// data is dropped/// - use only types with `'static` lifetime bounds, i.e., those with no or only/// `'static` references (both [`thread::Builder::spawn`][`Builder::spawn`]/// and [`thread::spawn`] enforce this property statically)/// let thread_x = &x;/// let handler = unsafe {///     builder.spawn_unchecked(move || {///         println!("x = {}", *thread_x);///     }).unwrap()/// // caller has to ensure `join()` is called, otherwise/// // it is possible to access freed memory if `x` gets/// // dropped before the thread closure is executed!CHEAP/// Persistent storage for the thread ID./// We store the thread ID so that it never gets destroyed during the lifetime/// of a thread, either using `#[thread_local]` or multiple `local_pointer!`s./// Tries to set the thread handle for the current thread. Fails if a handle was/// already set or if the thread ID of `thread` would change an already-set ID./// Gets the unique identifier of the thread which invokes it./// Calling this function may be more efficient than accessing the current/// thread id through the current thread handle. i.e. `thread::current().id()`./// This function will always succeed, will always return the same value for/// one thread and is guaranteed not to call the global allocator./// #![feature(current_thread_id)]/// let other_thread = thread::spawn(|| {///     thread::current_id()/// let other_thread_id = other_thread.join().unwrap();/// assert_ne!(thread::current_id(), other_thread_id);/// Gets the OS thread ID of the thread that invokes it, if available. If not, return the Rust/// thread ID./// We use a `u64` to all possible platform IDs without excess `cfg`; most use `int`, some use a/// pointer, and Apple uses `uint64_t`. This is a "best effort" approach for diagnostics and is/// allowed to fall back to a non-OS ID (such as the Rust thread ID) or a non-unique ID (such as a/// PID) if the thread ID cannot be retrieved./// Gets a reference to the handle of the thread that invokes it, if the handlewith_current_name/// Run a function with the current thread's name./// Modulo thread local accesses, this function is safe to call from signal/// handlers and in similar circumstances where allocations are not possible.current_or_unnamed/// Gets a handle to the thread that invokes it. If the handle stored in thread-/// local storage was already destroyed, this creates a new unnamed temporary/// handle to allow thread parking in nearly all situations./// Gets a handle to the thread that invokes it./// Getting a handle to the current thread with `thread::current()`:/// let handler = thread::Builder::new()///     .name("named thread".into())///     .spawn(|| {///         let handle = thread::current();///         assert_eq!(handle.name(), Some("named thread"));init_currentdrop_current/// This should be run in [`crate::rt::thread_cleanup`] to reset the thread/// Spawns a new thread, returning a [`JoinHandle`] for it./// The join handle provides a [`join`] method that can be used to join the spawned/// thread. If the spawned thread panics, [`join`] will return an [`Err`] containing/// the argument given to [`panic!`]./// If the join handle is dropped, the spawned thread will implicitly be *detached*./// In this case, the spawned thread may no longer be joined./// (It is the responsibility of the program to either eventually join threads it/// creates or detach them; otherwise, a resource leak will result.)/// This function creates a thread with the default parameters of [`Builder`]./// To specify the new thread's stack size or the name, use [`Builder::spawn`]./// As you can see in the signature of `spawn` there are two constraints on/// both the closure given to `spawn` and its return value, let's explain them:/// - The `'static` constraint means that the closure and its return value///   must have a lifetime of the whole program execution. The reason for this///   is that threads can outlive the lifetime they have been created in.///   Indeed if the thread, and by extension its return value, can outlive their///   caller, we need to make sure that they will be valid afterwards, and since///   we *can't* know when it will return we need to have them valid as long as///   possible, that is until the end of the program, hence the `'static`///   lifetime./// - The [`Send`] constraint is because the closure will need to be passed///   *by value* from the thread where it is spawned to the new thread. Its///   return value will need to be passed from the new thread to the thread///   where it is `join`ed.///   As a reminder, the [`Send`] marker trait expresses that it is safe to be///   passed from thread to thread. [`Sync`] expresses that it is safe to have a///   reference be passed from thread to thread./// Panics if the OS fails to create a thread; use [`Builder::spawn`]/// Creating a thread./// let handler = thread::spawn(|| {/// As mentioned in the module documentation, threads are usually made to/// communicate using [`channels`], here is how it usually looks./// This example also shows how to use `move`, in order to give ownership/// of values to a thread./// let sender = thread::spawn(move || {///     tx.send("Hello, thread".to_owned())///         .expect("Unable to send on channel");/// let receiver = thread::spawn(move || {///     let value = rx.recv().expect("Unable to receive from channel");///     println!("{value}");/// sender.join().expect("The sender thread has panicked");/// receiver.join().expect("The receiver thread has panicked");/// A thread can also return a value through its [`JoinHandle`], you can use/// this to make asynchronous computations (futures might be more appropriate/// though)./// let computation = thread::spawn(|| {///     // Some expensive computation./// let result = computation.join().unwrap();/// This function has the same minimal guarantee regarding "foreign" unwinding operations (e.g./// an exception thrown from C++ code, or a `panic!` in Rust code compiled or linked with a/// different runtime) as [`catch_unwind`]; namely, if the thread created with `thread::spawn`/// unwinds all the way to the root with such an exception, one of two behaviors are possible,/// and it is unspecified which will occur:/// * The process aborts./// * The process does not abort, and [`join`] will return a `Result::Err`///   containing an opaque type./// [`channels`]: crate::sync::mpsc/// [`join`]: JoinHandle::join/// [`Err`]: crate::result::Result::Err/// Cooperatively gives up a timeslice to the OS scheduler./// This calls the underlying OS scheduler's yield primitive, signaling/// that the calling thread is willing to give up its remaining timeslice/// so that the OS may schedule other threads on the CPU./// A drawback of yielding in a loop is that if the OS does not have any/// other ready threads to run on the current CPU, the thread will effectively/// busy-wait, which wastes CPU time and energy./// Therefore, when waiting for events of interest, a programmer's first/// choice should be to use synchronization devices such as [`channel`]s,/// [`Condvar`]s, [`Mutex`]es or [`join`] since these primitives are/// implemented in a blocking manner, giving up the CPU until the event/// of interest has occurred which avoids repeated yielding./// `yield_now` should thus be used only rarely, mostly in situations where/// repeated polling is required because there is no other suitable way to/// learn when an event of interest has occurred./// thread::yield_now();/// [`channel`]: crate::sync::mpsc/// A common use of this feature is to poison shared resources when writing/// unsafe code, by checking `panicking` when the `drop` is called./// This is usually not needed when writing safe code, as [`Mutex`es][Mutex]/// already poison themselves when a thread panics while holding the lock./// This can also be used in multithreaded applications, in order to send a/// message to other threads warning that a thread has panicked (e.g., for/// monitoring purposes)./// struct SomeStruct;/// impl Drop for SomeStruct {///         if thread::panicking() {///             println!("dropped while unwinding");///             println!("dropped while not unwinding");///     print!("a: ");///     let a = SomeStruct;///     print!("b: ");///     let b = SomeStruct;///     panic!()/// [Mutex]: crate::sync::Mutexsleep_ms/// Uses [`sleep`]./// Puts the current thread to sleep for at least the specified amount of time./// The thread may sleep longer than the duration specified due to scheduling/// specifics or platform-dependent functionality. It will never sleep less./// This function is blocking, and should not be used in `async` functions./// On Unix platforms, the underlying syscall may be interrupted by a/// spurious wakeup or signal handler. To ensure the sleep occurs for at least/// the specified duration, this function may invoke that system call multiple/// // Let's sleep for 2 seconds:/// thread::sleep_ms(2000);/// Platforms which do not support nanosecond precision for sleeping will/// have `dur` rounded up to the nearest granularity of time they can sleep for./// Currently, specifying a zero duration on Unix platforms returns immediately/// without invoking the underlying [`nanosleep`] syscall, whereas on Windows/// platforms the underlying [`Sleep`] syscall is always invoked./// If the intention is to yield the current time-slice you may want to use/// [`yield_now`] instead./// [`nanosleep`]: https://linux.die.net/man/2/nanosleep/// [`Sleep`]: https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleep/// let ten_millis = time::Duration::from_millis(10);/// let now = time::Instant::now();/// thread::sleep(ten_millis);/// assert!(now.elapsed() >= ten_millis);/// Puts the current thread to sleep until the specified deadline has passed./// The thread may still be asleep after the deadline specified due to/// scheduling specifics or platform-dependent functionality. It will never/// wake before./// In most cases this function will call an OS specific function. Where that/// is not supported [`sleep`] is used. Those platforms are referred to as other/// in the table below./// # Underlying System calls/// The following system calls are [currently] being used:/// |  Platform |               System call                                            |/// |-----------|----------------------------------------------------------------------|/// | Linux     | [clock_nanosleep] (Monotonic clock)                                  |/// | BSD except OpenBSD | [clock_nanosleep] (Monotonic Clock)]                        |/// | Android   | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Solaris   | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Illumos   | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Dragonfly | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Hurd      | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Fuchsia   | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Vxworks   | [clock_nanosleep] (Monotonic Clock)]                                 |/// | Other     | `sleep_until` uses [`sleep`] and does not issue a syscall itself     |/// [clock_nanosleep]: https://linux.die.net/man/3/clock_nanosleep/// **Disclaimer:** These system calls might change over time./// A simple game loop that limits the game to 60 frames per second./// #![feature(thread_sleep_until)]/// # fn update() {}/// # fn render() {}/// let max_fps = 60.0;/// let frame_time = Duration::from_secs_f32(1.0/max_fps);/// let mut next_frame = Instant::now();///     thread::sleep_until(next_frame);///     next_frame += frame_time;///     update();///     render();/// A slow API we must not call too fast and which takes a few/// tries before succeeding. By using `sleep_until` the time the/// API call takes does not influence when we retry or when we give up/// # enum Status {/// #     Ready(usize),/// #     Waiting,/// # fn slow_web_api_call() -> Status { Status::Ready(42) }/// # const MAX_DURATION: Duration = Duration::from_secs(10);/// # fn try_api_call() -> Result<usize, ()> {/// let deadline = Instant::now() + MAX_DURATION;/// let delay = Duration::from_millis(250);/// let mut next_attempt = Instant::now();///     if Instant::now() > deadline {///         break Err(());///     if let Status::Ready(data) = slow_web_api_call() {///         break Ok(data);///     next_attempt = deadline.min(next_attempt + delay);///     thread::sleep_until(next_attempt);/// # let _data = try_api_call();/// Used to ensure that `park` and `park_timeout` do not unwind, as that can/// cause undefined behavior if not handled correctly (see #102398 for context)./// Blocks unless or until the current thread's token is made available./// A call to `park` does not guarantee that the thread will remain parked/// forever, and callers should be prepared for this possibility. However,/// it is guaranteed that this function will not panic (it may abort the/// process if the implementation encounters some rare errors)./// # `park` and `unpark`/// Every thread is equipped with some basic low-level blocking support, via the/// [`thread::park`][`park`] function and [`thread::Thread::unpark`][`unpark`]/// method. [`park`] blocks the current thread, which can then be resumed from/// another thread by calling the [`unpark`] method on the blocked thread's/// Conceptually, each [`Thread`] handle has an associated token, which is/// initially not present:/// * The [`thread::park`][`park`] function blocks the current thread unless or///   until the token is available for its thread handle, at which point it///   atomically consumes the token. It may also return *spuriously*, without///   consuming the token. [`thread::park_timeout`] does the same, but allows///   specifying a maximum time to block the thread for./// * The [`unpark`] method on a [`Thread`] atomically makes the token available///   if it wasn't already. Because the token can be held by a thread even if it is currently not///   parked, [`unpark`] followed by [`park`] will result in the second call returning immediately.///   However, note that to rely on this guarantee, you need to make sure that your `unpark` happens///   after all `park` that may be done by other data structures!/// The API is typically used by acquiring a handle to the current thread, placing that handle in a/// shared data structure so that other threads can find it, and then `park`ing in a loop. When some/// desired condition is met, another thread calls [`unpark`] on the handle. The last bullet point/// above guarantees that even if the `unpark` occurs before the thread is finished `park`ing, it/// will be woken up properly./// Note that the coordination via the shared data structure is crucial: If you `unpark` a thread/// without first establishing that it is about to be `park`ing within your code, that `unpark` may/// get consumed by a *different* `park` in the same thread, leading to a deadlock. This also means/// you must not call unknown code between setting up for parking and calling `park`; for instance,/// if you invoke `println!`, that may itself call `park` and thus consume your `unpark` and cause a/// The motivation for this design is twofold:/// * It avoids the need to allocate mutexes and condvars when building new///   synchronization primitives; the threads already provide basic///   blocking/signaling./// * It can be implemented very efficiently on many platforms./// # Memory Ordering/// Calls to `unpark` _synchronize-with_ calls to `park`, meaning that memory/// operations performed before a call to `unpark` are made visible to the thread that/// consumes the token and returns from `park`. Note that all `park` and `unpark`/// operations for a given thread form a total order and _all_ prior `unpark` operations/// synchronize-with `park`./// In atomic ordering terms, `unpark` performs a `Release` operation and `park`/// performs the corresponding `Acquire` operation. Calls to `unpark` for the same/// thread form a [release sequence]./// Note that being unblocked does not imply a call was made to `unpark`, because/// wakeups can also be spurious. For example, a valid, but inefficient,/// implementation could have `park` and `unpark` return immediately without doing anything,/// making *all* wakeups spurious./// use std::sync::atomic::{Ordering, AtomicBool};/// static QUEUED: AtomicBool = AtomicBool::new(false);/// static FLAG: AtomicBool = AtomicBool::new(false);/// let parked_thread = thread::spawn(move || {///     println!("Thread spawned");///     // Signal that we are going to `park`. Between this store and our `park`, there may///     // be no other `park`, or else that `park` could consume our `unpark` token!///     QUEUED.store(true, Ordering::Release);///     // We want to wait until the flag is set. We *could* just spin, but using///     // park/unpark is more efficient.///     while !FLAG.load(Ordering::Acquire) {///         // We can *not* use `println!` here since that could use thread parking internally.///         thread::park();///         // We *could* get here spuriously, i.e., way before the 10ms below are over!///         // But that is no problem, we are in a loop until the flag is set anyway.///     println!("Flag received");/// // Let some time pass for the thread to be spawned./// thread::sleep(Duration::from_millis(10));/// // Ensure the thread is about to park./// // This is crucial! It guarantees that the `unpark` below is not consumed/// // by some other code in the parked thread (e.g. inside `println!`)./// while !QUEUED.load(Ordering::Acquire) {///     // Spinning is of course inefficient; in practice, this would more likely be///     // a dequeue where we have no work to do if there's nobody queued.///     std::hint::spin_loop();/// // Set the flag, and let the thread wake up./// // There is no race condition here: if `unpark`/// // happens first, `park` will return immediately./// // There is also no other `park` that could consume this token,/// // since we waited until the other thread got queued./// // Hence there is no risk of a deadlock./// FLAG.store(true, Ordering::Release);/// println!("Unpark the thread");/// parked_thread.thread().unpark();/// parked_thread.join().unwrap();/// [`Thread`]: super::Thread/// [`unpark`]: super::Thread::unpark/// [`thread::park_timeout`]: park_timeout/// [release sequence]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release_sequencepark_timeout_ms/// Uses [`park_timeout`]./// Blocks unless or until the current thread's token is made available or/// the specified duration has been reached (may wake spuriously)./// The semantics of this function are equivalent to [`park`] except/// amount of time waited to be precisely `ms` long./// See the [park documentation][`park`] for more detail./// The semantics of this function are equivalent to [`park`][park] except/// amount of time waited to be precisely `dur` long./// See the [park documentation][park] for more details./// Platforms which do not support nanosecond precision for sleeping will have/// `dur` rounded up to the nearest granularity of time they can sleep for./// Waiting for the complete expiration of the timeout:/// use std::thread::park_timeout;/// let timeout = Duration::from_secs(2);/// let beginning_park = Instant::now();/// let mut timeout_remaining = timeout;///     park_timeout(timeout_remaining);///     let elapsed = beginning_park.elapsed();///     println!("restarting park_timeout after {elapsed:?}");///     timeout_remaining = timeout - elapsed;/// Returns an estimate of the default amount of parallelism a program should use./// Parallelism is a resource. A given machine provides a certain capacity for/// parallelism, i.e., a bound on the number of computations it can perform/// simultaneously. This number often corresponds to the amount of CPUs a/// computer has, but it may diverge in various cases./// Host environments such as VMs or container orchestrators may want to/// restrict the amount of parallelism made available to programs in them. This/// is often done to limit the potential impact of (unintentionally)/// resource-intensive programs on other programs running on the same machine./// The purpose of this API is to provide an easy and portable way to query/// the default amount of parallelism the program should use. Among other things it/// does not expose information on NUMA regions, does not account for/// differences in (co)processor capabilities or current system load,/// and will not modify the program's global state in order to more accurately/// query the amount of available parallelism./// Where both fixed steady-state and burst limits are available the steady-state/// capacity will be used to ensure more predictable latencies./// Resource limits can be changed during the runtime of a program, therefore the value is/// not cached and instead recomputed every time this function is called. It should not be/// called from hot code./// The value returned by this function should be considered a simplified/// approximation of the actual amount of parallelism available at any given/// time. To get a more detailed or precise overview of the amount of/// parallelism available to the program, you may wish to use/// platform-specific APIs as well. The following platform limitations currently/// apply to `available_parallelism`:/// - It may undercount the amount of parallelism available on systems with more///   than 64 logical CPUs. However, programs typically need specific support to///   take advantage of more than 64 logical CPUs, and in the absence of such///   support, the number returned by this function accurately reflects the///   number of logical CPUs the program can use by default./// - It may overcount the amount of parallelism available on systems limited by///   process-wide affinity masks, or job object limitations./// - It may overcount the amount of parallelism available when limited by a///   process-wide affinity mask or cgroup quotas and `sched_getaffinity()` or cgroup fs can't be///   queried, e.g. due to sandboxing./// - It may undercount the amount of parallelism if the current thread's affinity mask///   does not reflect the process' cpuset, e.g. due to pinned threads./// - If the process is in a cgroup v1 cpu controller, this may need to///   scan mountpoints to find the corresponding cgroup v1 controller,///   which may take time on systems with large numbers of mountpoints.///   (This does not apply to cgroup v2, or to processes not in a///   cgroup.)/// - It does not attempt to take `ulimit` into account. If there is a limit set on the number of///   threads, `available_parallelism` cannot know how much of that limit a Rust program should///   take, or know in a reliable and race-free way how much of that limit is already taken./// On all targets:/// - It may overcount the amount of parallelism available when running in a VM/// with CPU usage limits (e.g. an overcommitted host)./// This function will, but is not limited to, return errors in the following/// cases:/// - If the amount of parallelism is not known for the target platform./// - If the program lacks permission to query the amount of parallelism made///   available to it./// use std::{io, thread};///     let count = thread::available_parallelism()?.get();///     assert!(count >= 1_usize);// Alias for a previous name we gave this API on unstable.// Alias for C++ `std::thread::hardware_concurrency`.// Alias for a popular ecosystem crate which provides similar functionality.//! Free functions./// A unique identifier for a running thread./// A `ThreadId` is an opaque object that uniquely identifies each thread/// created during the lifetime of a process. `ThreadId`s are guaranteed not to/// be reused, even when a thread terminates. `ThreadId`s are under the control/// of Rust's standard library and there may not be any relationship between/// `ThreadId` and the underlying platform's notion of a thread identifier --/// the two concepts cannot, therefore, be used interchangeably. A `ThreadId`/// can be retrieved from the [`id`] method on a [`Thread`].///     thread::current().id()/// assert!(thread::current().id() != other_thread_id);/// [`id`]: super::Thread::id// Generate a new unique thread ID./// This returns a numeric identifier for the thread identified by this/// `ThreadId`./// As noted in the documentation for the type itself, it is essentially an/// opaque ID, but is guaranteed to be unique for each thread. The returned/// value is entirely opaque -- only equality testing is stable. Note that/// it is not guaranteed which values new threads will return, and this may/// change across Rust versions.JoinInner/// An owned permission to join on a thread (block on its termination)./// A `JoinHandle` *detaches* the associated thread when it is dropped, which/// means that there is no longer any handle to the thread and no way to `join`/// on it./// Due to platform restrictions, it is not possible to [`Clone`] this/// handle: the ability to join a thread is a uniquely-owned permission./// This `struct` is created by the [`thread::spawn`] function and the/// [`thread::Builder::spawn`] method./// Creation from [`thread::spawn`]:/// let join_handle: thread::JoinHandle<_> = thread::spawn(|| {///     // some work here/// Creation from [`thread::Builder::spawn`]:/// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {/// A thread being detached and outliving the thread that spawned it:/// let original_thread = thread::spawn(|| {///     let _detached_thread = thread::spawn(|| {///         // Here we sleep to make sure that the first thread returns before.///         thread::sleep(Duration::from_millis(10));///         // This will be called, even though the JoinHandle is dropped.///         println!("♫ Still alive ♫");/// original_thread.join().expect("The thread being joined has panicked");/// println!("Original thread is joined.");/// // We make sure that the new thread has time to run, before the main/// // thread returns./// thread::sleep(Duration::from_millis(1000));/// [`thread::Builder::spawn`]: super::Builder::spawn/// Extracts a handle to the underlying thread./// let thread = join_handle.thread();/// println!("thread id: {:?}", thread.id());/// This function will return immediately if the associated thread has already finished./// In terms of [atomic memory orderings],  the completion of the associated/// thread synchronizes with this function returning. In other words, all/// operations performed by that thread [happen/// before](https://doc.rust-lang.org/nomicon/atomics.html#data-accesses) all/// operations that happen after `join` returns./// If the associated thread panics, [`Err`] is returned with the parameter given/// to [`panic!`] (though see the Notes below)./// [atomic memory orderings]: crate::sync::atomic/// This function may panic on some platforms if a thread attempts to join/// itself or otherwise may create a deadlock with joining threads./// join_handle.join().expect("Couldn't join on the associated thread");/// If a "foreign" unwinding operation (e.g. an exception thrown from C++/// code, or a `panic!` in Rust code compiled or linked with a different/// runtime) unwinds all the way to the thread root, the process may be/// aborted; see the Notes on [`thread::spawn`]. If the process is not/// aborted, this function will return a `Result::Err` containing an opaque/// Checks if the associated thread has finished running its main function./// `is_finished` supports implementing a non-blocking join operation, by checking/// `is_finished`, and calling `join` if it returns `true`. This function does not block. To/// block while waiting on the thread to finish, use [`join`][Self::join]./// This might return `true` for a brief moment after the thread's main/// function has returned, but before the thread itself has stopped running./// However, once this returns `true`, [`join`][Self::join] can be expected/// to return quickly, without blocking for any significant amount of time.ScopeDataspawnhookrust_start/// The data passed to the spawned thread for thread initialization. Any thread/// implementation should start a new thread by calling .init() on this before/// doing anything else to ensure the current thread is properly initialized and/// the global allocator works./// Initialize the 'current thread' mechanism on this thread, returning the/// Rust entry point.// This packet is used to communicate the return value between the spawned// thread and the rest of the program. It is shared through an `Arc` and// there's no need for a mutex here because synchronization happens with `join()`// (the caller will never read this packet until the thread has exited).// An Arc to the packet is stored into a `JoinInner` which in turns is placed// in `JoinHandle`.// Due to the usage of `UnsafeCell` we need to manually implement Sync.// The type `T` should already always be Send (otherwise the thread could not// have been created) and the Packet is Sync because all access to the// `UnsafeCell` synchronized (by the `join()` boundary), and `ScopeData` is Sync./// Inner representation for JoinHandle//! The inner logic for thread spawning and joining.// This outer `LocalKey<T>` type is what's going to be stored in statics,// but actual data inside will sometimes be tagged with #[thread_local].// It's not valid for a true static to reference a #[thread_local] static,// so we get around that by exposing an accessor through a layer of function// indirection (this thunk).// Note that the thunk is itself unsafe because the returned lifetime of the// slot where data lives, `'static`, is not actually valid. The lifetime// here is actually slightly shorter than the currently running thread!// Although this is an extra layer of indirection, it should in theory be// trivially devirtualizable by LLVM because the value of `inner` never// changes and the constant should be readonly within a crate. This mainly// only runs into problems when TLS statics are exported across crates./// A thread local storage (TLS) key which owns its contents./// This key uses the fastest implementation available on the target platform./// It is instantiated with the [`thread_local!`] macro and the/// primary method is the [`with`] method, though there are helpers to make/// working with [`Cell`] types easier./// The [`with`] method yields a reference to the contained value which cannot/// outlive the current thread or escape the given closure./// [`thread_local!`]: crate::thread_local/// # Initialization and Destruction/// Initialization is dynamically performed on the first call to a setter (e.g./// [`with`]) within a thread, and values that implement [`Drop`] get/// destructed when a thread exits. Some platform-specific caveats apply, which/// are explained below./// Note that, should the destructor panic, the whole process will be [aborted]./// On platforms where initialization requires memory allocation, this is/// performed directly through [`System`], allowing the [global allocator]/// to make use of thread local storage./// A `LocalKey`'s initializer cannot recursively depend on itself. Using a/// `LocalKey` in this way may cause panics, aborts, or infinite recursion on/// the first call to `with`./// [`System`]: crate::alloc::System/// [global allocator]: crate::alloc/// [aborted]: crate::process::abort/// # Single-thread Synchronization/// Though there is no potential race with other threads, it is still possible to/// obtain multiple references to the thread-local data in different places on/// the call stack. For this reason, only shared (`&T`) references may be obtained./// To allow obtaining an exclusive mutable reference (`&mut T`), typically a/// [`Cell`] or [`RefCell`] is used (see the [`std::cell`] for more information/// on how exactly this works). To make this easier there are specialized/// implementations for [`LocalKey<Cell<T>>`] and [`LocalKey<RefCell<T>>`]./// [`std::cell`]: `crate::cell`/// [`LocalKey<Cell<T>>`]: struct.LocalKey.html#impl-LocalKey<Cell<T>>/// [`LocalKey<RefCell<T>>`]: struct.LocalKey.html#impl-LocalKey<RefCell<T>>/// // explicit `const {}` block enables more efficient initialization/// thread_local!(static FOO: Cell<u32> = const { Cell::new(1) });/// assert_eq!(FOO.get(), 1);/// FOO.set(2);/// // each thread starts out with the initial value of 1/// let t = thread::spawn(move || {///     assert_eq!(FOO.get(), 1);///     FOO.set(3);/// // wait for the thread to complete and bail out on panic/// // we retain our original value of 2 despite the child thread/// assert_eq!(FOO.get(), 2);/// Note that a "best effort" is made to ensure that destructors for types/// stored in thread local storage are run, but not all platforms can guarantee/// that destructors will be run for all types in thread local storage. For/// example, there are a number of known caveats where destructors are not run:/// 1. On Unix systems when pthread-based TLS is being used, destructors will///    not be run for TLS values on the main thread when it exits. Note that the///    application will exit immediately after the main thread exits as well./// 2. On all platforms it's possible for TLS to re-initialize other TLS slots///    during destruction. Some platforms ensure that this cannot happen///    infinitely by preventing re-initialization of any slot that has been///    destroyed, but not all platforms have this guard. Those platforms that do///    not guard typically have a synthetic limit after which point no more///    destructors are run./// 3. When the process exits on Windows systems, TLS destructors may only be///    run on the thread that causes the process to exit. This is because the///    other threads may be forcibly terminated./// ## Synchronization in thread-local destructors/// On Windows, synchronization operations (such as [`JoinHandle::join`]) in/// thread local destructors are prone to deadlocks and so should be avoided./// This is because the [loader lock] is held while a destructor is run. The/// lock is acquired whenever a thread starts or exits or when a DLL is loaded/// or unloaded. Therefore these events are blocked for as long as a thread/// local destructor is running./// [loader lock]: https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-best-practices/// [`JoinHandle::join`]: crate::thread::JoinHandle::join/// [`with`]: LocalKey::with/// Declare a new thread local storage key of type [`std::thread::LocalKey`]./// The macro wraps any number of static declarations and makes them thread local./// Publicity and attributes for each static are allowed. Example:/// use std::cell::{Cell, RefCell};///     pub static FOO: Cell<u32> = const { Cell::new(1) };///     static BAR: RefCell<Vec<f32>> = RefCell::new(vec![1.0, 2.0]);/// BAR.with_borrow(|v| assert_eq!(v[1], 2.0));/// Note that only shared references (`&T`) to the inner data may be obtained, so a/// type such as [`Cell`] or [`RefCell`] is typically used to allow mutating access./// This macro supports a special `const {}` syntax that can be used/// when the initialization expression can be evaluated as a constant./// This can enable a more efficient thread local implementation that/// can avoid lazy initialization. For types that do not/// [need to be dropped][crate::mem::needs_drop], this can enable an/// even more efficient implementation that does not need to/// track any additional state.///     pub static FOO: RefCell<Vec<u32>> = const { RefCell::new(Vec::new()) };/// FOO.with_borrow(|v| assert_eq!(v.len(), 0));/// See [`LocalKey` documentation][`std::thread::LocalKey`] for more/// [`std::thread::LocalKey`]: crate::thread::LocalKey/// An error returned by [`LocalKey::try_with`](struct.LocalKey.html#method.try_with).panic_access_error// This ensures the panicking code is outlined from `with` for `LocalKey`./// Acquires a reference to the value in this TLS key./// This will lazily initialize the value if this thread has not referenced/// this key yet./// This function will `panic!()` if the key currently has its/// destructor running, and it **may** panic if the destructor has/// previously been run for this thread.///     pub static STATIC: String = String::from("I am");///     STATIC.with(|original_value| format!("{original_value} initialized")),///     "I am initialized",/// this key yet. If the key has been destroyed (which may happen if this is called/// in a destructor), this function will return an [`AccessError`]./// This function will still `panic!()` if the key is uninitialized and the/// key's initializer panics.///     STATIC.try_with(|original_value| format!("{original_value} initialized")),///     Ok(String::from("I am initialized")),initialize_with/// Acquires a reference to the value in this TLS key, initializing it with/// `init` if it wasn't already initialized on this thread./// If `init` was used to initialize the thread local variable, `None` is/// passed as the first argument to `f`. If it was already initialized,/// `Some(init)` is passed to `f`./// This function will panic if the key currently has its destructor/// running, and it **may** panic if the destructor has previously been run/// for this thread./// Sets or initializes the contained value./// Unlike the other methods, this will *not* run the lazy initializer of/// the thread local. Instead, it will be directly initialized with the/// given value if it wasn't initialized yet./// Panics if the key currently has its destructor running,/// and it **may** panic if the destructor has previously been run for this thread.///     static X: Cell<i32> = panic!("!");/// // Calling X.get() here would result in a panic./// X.set(123); // But X.set() is fine, as it skips the initializer above./// assert_eq!(X.get(), 123);///     static X: Cell<i32> = const { Cell::new(1) };/// assert_eq!(X.get(), 1);/// Takes the contained value, leaving `Default::default()` in its place.///     static X: Cell<Option<i32>> = const { Cell::new(Some(1)) };/// assert_eq!(X.take(), Some(1));/// assert_eq!(X.take(), None);/// Replaces the contained value, returning the old value./// assert_eq!(X.replace(2), 1);/// assert_eq!(X.replace(3), 2);/// #![feature(local_key_cell_update)]///     static X: Cell<i32> = const { Cell::new(5) };/// X.update(|x| x + 1);/// assert_eq!(X.get(), 6);with_borrow/// Acquires a reference to the contained value.///     static X: RefCell<Vec<i32>> = RefCell::new(Vec::new());/// X.with_borrow(|v| assert!(v.is_empty()));with_borrow_mut/// Acquires a mutable reference to the contained value./// X.with_borrow_mut(|v| v.push(1));/// X.with_borrow(|v| assert_eq!(*v, vec![1]));///     static X: RefCell<Vec<i32>> = panic!("!");/// // Calling X.with() here would result in a panic./// X.set(vec![1, 2, 3]); // But X.set() is fine, as it skips the initializer above./// X.with_borrow(|v| assert_eq!(*v, vec![1, 2, 3]));/// let a = X.take();/// assert_eq!(a, vec![1]);/// let prev = X.replace(vec![1, 2, 3]);/// assert!(prev.is_empty());//! Thread local storager" May only be called once."//! Store the ID of the main thread.//! The thread handle for the main thread is created lazily, and this might even//! happen pre-main. Since not every platform has a way to identify the main//! thread when that happens – macOS's `pthread_main_np` function being a notable//! exception – we cannot assign it the right name right then. Instead, in our//! runtime startup code, we remember the thread ID of the main thread (through//! this modules `set` function) and use it to identify the main thread from then//! on. This works reliably and has the additional advantage that we can report//! the right thread name on main even after the thread handle has been destroyed.//! Note however that this also means that the name reported in pre-main functions//! will be incorrect, but that's just something we have to live with.add_spawn_hook// Implementation details used by the thread_local!{} macro./// A specialized [`Result`] type for threads./// Indicates the manner in which a thread exited./// The value contained in the `Result::Err` variant/// is the value the thread panicked with;/// that is, the argument the `panic!` macro was called with./// Unlike with normal errors, this value doesn't implement/// the [`Error`](crate::error::Error) trait./// Thus, a sensible way to handle a thread panic is to either:/// 1. propagate the panic with [`std::panic::resume_unwind`]/// 2. or in case the thread is intended to be a subsystem boundary/// that is supposed to isolate system-level failures,/// match on the `Err` variant and handle the panic in an appropriate way/// A thread that completes without panicking is considered to exit successfully./// Matching on the result of a joined thread:/// use std::{fs, thread, panic};/// fn copy_in_thread() -> thread::Result<()> {///         fs::copy("foo.txt", "bar.txt").unwrap();///     }).join()///     match copy_in_thread() {///         Ok(_) => println!("copy succeeded"),///         Err(e) => panic::resume_unwind(e),/// [`std::panic::resume_unwind`]: crate::panic::resume_unwind_assert_sync_and_send//! Native threads.//! ## The threading model//! An executing Rust program consists of a collection of native OS threads,//! each with their own stack and local state. Threads can be named, and//! provide some built-in support for low-level synchronization.//! Communication between threads can be done through//! [channels], Rust's message-passing types, along with [other forms of thread//! synchronization](../../std/sync/index.html) and shared-memory data//! structures. In particular, types that are guaranteed to be//! threadsafe are easily shared between threads using the//! atomically-reference-counted container, [`Arc`].//! Fatal logic errors in Rust cause *thread panic*, during which//! a thread will unwind the stack, running destructors and freeing//! owned resources. While not meant as a 'try/catch' mechanism, panics//! in Rust can nonetheless be caught (unless compiling with `panic=abort`) with//! [`catch_unwind`](../../std/panic/fn.catch_unwind.html) and recovered//! from, or alternatively be resumed with//! [`resume_unwind`](../../std/panic/fn.resume_unwind.html). If the panic//! is not caught the thread will exit, but the panic may optionally be//! detected from a different thread with [`join`]. If the main thread panics//! without the panic being caught, the application will exit with a//! non-zero exit code.//! When the main thread of a Rust program terminates, the entire program shuts//! down, even if other threads are still running. However, this module provides//! convenient facilities for automatically waiting for the termination of a//! thread (i.e., join).//! ## Spawning a thread//! A new thread can be spawned using the [`thread::spawn`][`spawn`] function://!     // some work here//! In this example, the spawned thread is "detached," which means that there is//! no way for the program to learn when the spawned thread completes or otherwise//! terminates.//! To learn when a thread completes, it is necessary to capture the [`JoinHandle`]//! object that is returned by the call to [`spawn`], which provides//! a `join` method that allows the caller to wait for the completion of the//! spawned thread://! let thread_join_handle = thread::spawn(move || {//! // some work here//! let res = thread_join_handle.join();//! The [`join`] method returns a [`thread::Result`] containing [`Ok`] of the final//! value produced by the spawned thread, or [`Err`] of the value given to//! a call to [`panic!`] if the thread panicked.//! Note that there is no parent/child relationship between a thread that spawns a//! new thread and the thread being spawned.  In particular, the spawned thread may or//! may not outlive the spawning thread, unless the spawning thread is the main thread.//! ## Configuring threads//! A new thread can be configured before it is spawned via the [`Builder`] type,//! which currently allows you to set the name and stack size for the thread://! thread::Builder::new().name("thread1".to_string()).spawn(move || {//!     println!("Hello, world!");//! ## The `Thread` type//! Threads are represented via the [`Thread`] type, which you can get in one of//! two ways://! * By spawning a new thread, e.g., using the [`thread::spawn`][`spawn`]//!   function, and calling [`thread`][`JoinHandle::thread`] on the [`JoinHandle`].//! * By requesting the current thread, using the [`thread::current`] function.//! The [`thread::current`] function is available even for threads not spawned//! by the APIs of this module.//! ## Thread-local storage//! This module also provides an implementation of thread-local storage for Rust//! programs. Thread-local storage is a method of storing data into a global//! variable that each thread in the program will have its own copy of.//! Threads do not share this data, so accesses do not need to be synchronized.//! A thread-local key owns the value it contains and will destroy the value when the//! thread exits. It is created with the [`thread_local!`] macro and can contain any//! value that is `'static` (no borrowed pointers). It provides an accessor function,//! [`with`], that yields a shared reference to the value to the specified//! closure. Thread-local keys allow only shared access to values, as there would be no//! way to guarantee uniqueness if mutable borrows were allowed. Most values//! will want to make use of some form of **interior mutability** through the//! [`Cell`] or [`RefCell`] types.//! ## Naming threads//! Threads are able to have associated names for identification purposes. By default, spawned//! threads are unnamed. To specify a name for a thread, build the thread with [`Builder`] and pass//! the desired thread name to [`Builder::name`]. To retrieve the thread name from within the//! thread, use [`Thread::name`]. A couple of examples where the name of a thread gets used://! * If a panic occurs in a named thread, the thread name will be printed in the panic message.//! * The thread name is provided to the OS where applicable (e.g., `pthread_setname_np` in//!   unix-like platforms).//! ## Stack size//! The default stack size is platform-dependent and subject to change.//! Currently, it is 2 MiB on all Tier-1 platforms.//! There are two ways to manually specify the stack size for spawned threads://! * Build the thread with [`Builder`] and pass the desired stack size to [`Builder::stack_size`].//! * Set the `RUST_MIN_STACK` environment variable to an integer representing the desired stack//!   size (in bytes). Note that setting [`Builder::stack_size`] will override this. Be aware that//!   changes to `RUST_MIN_STACK` may be ignored after program start.//! Note that the stack size of the main thread is *not* determined by Rust.//! [channels]: crate::sync::mpsc//! [`join`]: JoinHandle::join//! [`Ok`]: crate::result::Result::Ok//! [`Err`]: crate::result::Result::Err//! [`thread::current`]: current::current//! [`thread::Result`]: Result//! [`unpark`]: Thread::unpark//! [`thread::park_timeout`]: park_timeout//! [`Cell`]: crate::cell::Cell//! [`RefCell`]: crate::cell::RefCell//! [`with`]: LocalKey::with//! [`thread_local!`]: crate::thread_local// Under `test`, `__FastLocalKeyInner` seems unused./// Invariance over 'scope, to make sure 'scope cannot shrink,/// which is necessary for soundness./// Without invariance, this would compile fine but be unsound:/// ```compile_fail,E0373///     s.spawn(|| {///         let a = String::from("abcd");///         s.spawn(|| println!("{a:?}")); // might run after `a` is dropped/// A scope to spawn scoped threads in./// See [`scope`] for details./// An owned permission to join on a scoped thread (block on its termination)./// See [`Scope::spawn`] for details.num_running_threadsa_thread_panickedincrement_num_running_threadsdecrement_num_running_threads/// Creates a scope for spawning scoped threads./// The function passed to `scope` will be provided a [`Scope`] object,/// through which scoped threads can be [spawned][`Scope::spawn`]./// Unlike non-scoped threads, scoped threads can borrow non-`'static` data,/// as the scope guarantees all threads will be joined at the end of the scope./// All threads spawned within the scope that haven't been manually joined/// will be automatically joined before this function returns./// If any of the automatically joined threads panicked, this function will panic./// If you want to handle panics from spawned threads,/// [`join`][ScopedJoinHandle::join] them before the end of the scope./// let mut a = vec![1, 2, 3];///         println!("hello from the first scoped thread");///         // We can borrow `a` here.///         dbg!(&a);///         println!("hello from the second scoped thread");///         // We can even mutably borrow `x` here,///         // because no other threads are using it.///         x += a[0] + a[2];///     println!("hello from the main thread");/// // After the scope, we can modify and access our variables again:/// a.push(4);/// assert_eq!(x, a.len());/// Scoped threads involve two lifetimes: `'scope` and `'env`./// The `'scope` lifetime represents the lifetime of the scope itself./// That is: the time during which new scoped threads may be spawned,/// and also the time during which they might still be running./// Once this lifetime ends, all scoped threads are joined./// This lifetime starts within the `scope` function, before `f` (the argument to `scope`) starts./// It ends after `f` returns and all scoped threads have been joined, but before `scope` returns./// The `'env` lifetime represents the lifetime of whatever is borrowed by the scoped threads./// This lifetime must outlast the call to `scope`, and thus cannot be smaller than `'scope`./// It can be as small as the call to `scope`, meaning that anything that outlives this call,/// such as local variables defined right before the scope, can be borrowed by the scoped threads./// The `'env: 'scope` bound is part of the definition of the `Scope` type./// Spawns a new thread within a scope, returning a [`ScopedJoinHandle`] for it./// Unlike non-scoped threads, threads spawned with this function may/// borrow non-`'static` data from the outside the scope. See [`scope`] for/// the panic payload./// If the join handle is dropped, the spawned thread will be implicitly joined at the/// end of the scope. In that case, if the spawned thread panics, [`scope`] will/// panic after all threads are joined./// To specify the new thread's stack size or the name, use [`Builder::spawn_scoped`]./// Panics if the OS fails to create a thread; use [`Builder::spawn_scoped`]/// [`join`]: ScopedJoinHandle::join/// Spawns a new scoped thread using the settings set through this `Builder`./// Unlike [`Scope::spawn`], this method yields an [`io::Result`] to/// capture any failure to create the thread at the OS level.///     thread::Builder::new()///         .name("first".to_string())///         .spawn_scoped(s, ||///         println!("hello from the {:?} scoped thread", thread::current().name());///         .name("second".to_string())///     let t = s.spawn(|| {///         println!("hello");///     println!("thread id: {:?}", t.thread().id());/// In terms of [atomic memory orderings], the completion of the associated/// thread synchronizes with this function returning./// In other words, all operations performed by that thread/// [happen before](https://doc.rust-lang.org/nomicon/atomics.html#data-accesses)/// all operations that happen after `join` returns./// If the associated thread panics, [`Err`] is returned with the panic payload.///         panic!("oh no");///     assert!(t.join().is_err());r" A thread local linked list of spawn hooks."r" It is a linked list of Arcs, such that it can very cheaply be inherited by spawned threads."r" (That technically makes it a set of linked lists with shared tails, so a linked tree.)"SPAWN_HOOKSSpawnHooksSpawnHook// Manually implement drop to prevent deep recursion when dropping linked Arc list./// Registers a function to run for every newly thread spawned./// The hook is executed in the parent thread, and returns a function/// that will be executed in the new thread./// The hook is called with the `Thread` handle for the new thread./// The hook will only be added for the current thread and is inherited by the threads it spawns./// In other words, adding a hook has no effect on already running threads (other than the current/// thread) and the threads they might spawn in the future./// Hooks can only be added, not removed./// The hooks will run in reverse order, starting with the most recently added./// #![feature(thread_spawn_hook)]/// std::thread::add_spawn_hook(|_| {///     ..; // This will run in the parent (spawning) thread.///         ..; // This will run it the child (spawned) thread./// A spawn hook can be used to "inherit" a thread local from the parent thread:///     static X: Cell<u32> = Cell::new(0);/// // This needs to be done once in the main thread before spawning any threads.///     // Get the value of X in the spawning thread.///     let value = X.get();///     // Set the value of X in the newly spawned thread.///     move || X.set(value)/// X.set(123);///     assert_eq!(X.get(), 123);run_spawn_hooksChildSpawnHooks/// Runs all the spawn hooks./// Called on the parent thread./// Returns the functions to be called on the newly spawned thread.to_run/// The results of running the spawn hooks./// This struct is sent to the new thread./// It contains the inherited hooks and the closures to be run.// This is run on the newly spawned thread, directly at the start.test_unnamed_threadtest_named_threadtest_named_thread_truncationtest_invalid_named_threadtest_run_basictest_is_finishedtest_join_panictest_spawn_schedtest_spawn_sched_childs_on_default_schedavoid_copying_the_bodytest_avoid_copying_the_body_spawntest_avoid_copying_the_body_thread_spawntest_avoid_copying_the_body_jointest_child_doesnt_ref_parenttest_simple_newsched_spawntest_try_panic_message_string_literaltest_try_panic_any_message_owned_strtest_try_panic_any_message_anytest_try_panic_any_message_unit_structtest_park_unpark_beforetest_park_unpark_called_other_threadtest_park_timeout_unpark_beforetest_park_timeout_unpark_not_calledtest_park_timeout_unpark_called_other_threadsleep_ms_smoketest_size_of_option_thread_idtest_thread_id_equaltest_thread_id_not_equaltest_thread_os_id_not_equaltest_scoped_threads_drop_result_before_jointest_scoped_threads_nllscope_join_race// Regression test for https://github.com/rust-lang/rust/issues/98498.// relies on Miri's data race detectortest_minimal_thread_stack// Test that the smallest value for stack_size works on Windows.// !!! These tests are dangerous. If something is buggy, they will hang, !!!// !!! instead of exiting cleanly. This might wedge the buildbots.       !!!ThreadNameString/// Like a `String` it's guaranteed UTF-8 and like a `CString` it's null terminated.thread_name_string// This module ensures private fields are kept private, which is necessary to enforce the safety requirements./// The internal representation of a `Thread` handle/// We explicitly set the alignment for our guarantee in Thread::into_raw. This/// allows applications to stuff extra metadata bits into the alignment, which/// can be rather useful when working with atomics.// We use the System allocator such that creating or dropping this handle// does not interfere with a potential Global allocator using thread-local// storage./// A handle to a thread./// Threads are represented via the `Thread` type, which you can get in one of/// two ways:/// * By spawning a new thread, e.g., using the [`thread::spawn`]///   function, and calling [`thread`] on the [`JoinHandle`]./// * By requesting the current thread, using the [`thread::current`] function./// The [`thread::current`] function is available even for threads not spawned/// by the APIs of this module./// There is usually no need to create a `Thread` struct yourself, one/// should instead use a function like `spawn` to create new threads, see the/// docs of [`Builder`] and [`spawn`] for more details./// [`thread`]: super::JoinHandle::thread/// [`JoinHandle`]: super::JoinHandle/// [`thread::current`]: super::current::current/// [`Builder`]: super::Builder/// Like the public [`park`], but callable on any handle. This is used to/// allow parking in TLS destructors./// May only be called from the thread to which this handle belongs./// [`park`]: super::park/// Like the public [`park_timeout`], but callable on any handle. This is/// used to allow parking in TLS destructors./// [`park_timeout`]: super::park_timeout/// Atomically makes the handle's token available if it is not already./// Every thread is equipped with some basic low-level blocking support, via/// the [`park`] function and the `unpark()` method. These can be used as a/// more CPU-efficient implementation of a spinlock./// See the [park documentation] for more details./// let parked_thread = thread::Builder::new()///         println!("Parking thread");///         QUEUED.store(true, Ordering::Release);///         println!("Thread unparked");/// // Wait until the other thread is queued./// [park documentation]: super::park/// Gets the thread's unique identifier./// Gets the thread's name./// Threads by default have no name specified:///     assert!(thread::current().name().is_none());/// Thread with a specified name:/// Consumes the `Thread`, returning a raw pointer./// To avoid a memory leak the pointer must be converted/// back into a `Thread` using [`Thread::from_raw`]. The pointer is/// guaranteed to be aligned to at least 8 bytes./// #![feature(thread_raw)]/// let thread = thread::current();/// let id = thread.id();/// let ptr = Thread::into_raw(thread);///     assert_eq!(Thread::from_raw(ptr).id(), id);/// Constructs a `Thread` from a raw pointer./// The raw pointer must have been previously returned/// by a call to [`Thread::into_raw`]./// This function is unsafe because improper use may lead/// to memory unsafety, even if the returned `Thread` is never/// Creating a `Thread` from a pointer other than one returned/// from [`Thread::into_raw`] is **undefined behavior**./// Calling this function twice on the same raw pointer can lead/// to a double-free if both `Thread` instances are dropped./// Opaque and useful only with [`Duration`]./// Instants are always guaranteed, barring [platform bugs], to be no less than any previously/// measured instant when created, and are often useful for tasks such as measuring/// Note, however, that instants are **not** guaranteed to be **steady**. In other/// words, each tick of the underlying clock might not be the same length (e.g./// As part of this non-guarantee it is also not specified whether system suspends count as/// elapsed time or not. The behavior varies across platforms and Rust versions.///    let now = Instant::now();///    // we sleep for 2 seconds///    sleep(Duration::new(2, 0));///    // it prints '2'///    println!("{}", now.elapsed().as_secs());/// [platform bugs]: Instant#monotonicity/// # OS-specific behaviors/// An `Instant` is a wrapper around system-specific types and it may behave/// differently depending on the underlying operating system. For example,/// the following snippet is fine on Linux but panics on macOS:/// let days_per_10_millennia = 365_2425;/// let solar_seconds_per_day = 60 * 60 * 24;/// let millennium_in_solar_seconds = 31_556_952_000;/// assert_eq!(millennium_in_solar_seconds, days_per_10_millennia * solar_seconds_per_day / 10);/// let duration = Duration::new(millennium_in_solar_seconds, 0);/// println!("{:?}", now + duration);/// For cross-platform code, you can comfortably use durations of up to around one hundred years./// The following system calls are [currently] being used by `now()` to find out/// the current time:/// | SGX       | [`insecure_time` usercall]. More information on [timekeeping in SGX] |/// | UNIX      | [clock_gettime] with `CLOCK_MONOTONIC`                               |/// | Darwin    | [clock_gettime] with `CLOCK_UPTIME_RAW`                              |/// | VXWorks   | [clock_gettime] with `CLOCK_MONOTONIC`                               |/// | SOLID     | `get_tim`                                                            |/// | WASI      | [__wasi_clock_time_get] with `monotonic`                             |/// | Windows   | [QueryPerformanceCounter]                                            |/// [QueryPerformanceCounter]: https://docs.microsoft.com/en-us/windows/win32/api/profileapi/nf-profileapi-queryperformancecounter/// [`insecure_time` usercall]: https://edp.fortanix.com/docs/api/fortanix_sgx_abi/struct.Usercalls.html#method.insecure_time/// [timekeeping in SGX]: https://edp.fortanix.com/docs/concepts/rust-std/#codestdtimecode/// [__wasi_clock_time_get]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#clock_time_get/// [clock_gettime]: https://linux.die.net/man/3/clock_gettime/// > Note: mathematical operations like [`add`] may panic if the underlying/// > structure cannot represent the new point in time./// [`add`]: Instant::add/// ## Monotonicity/// On all platforms `Instant` will try to use an OS API that guarantees monotonic behavior/// if available, which is the case for all [tier 1] platforms./// In practice such guarantees are – under rare circumstances – broken by hardware, virtualization/// or operating system bugs. To work around these bugs and platforms not offering monotonic clocks/// [`duration_since`], [`elapsed`] and [`sub`] saturate to zero. In older Rust versions this/// lead to a panic instead. [`checked_duration_since`] can be used to detect and handle situations/// where monotonicity is violated, or `Instant`s are subtracted in the wrong order./// This workaround obscures programming errors where earlier and later instants are accidentally/// swapped. For this reason future Rust versions may reintroduce panics./// [tier 1]: https://doc.rust-lang.org/rustc/platform-support.html/// [`duration_since`]: Instant::duration_since/// [`elapsed`]: Instant::elapsed/// [`sub`]: Instant::sub/// [`checked_duration_since`]: Instant::checked_duration_since/// A measurement of the system clock, useful for talking to/// external entities like the file system or other processes./// Distinct from the [`Instant`] type, this time measurement **is not/// monotonic**. This means that you can save a file to the file system, then/// save another file to the file system, **and the second file has a/// `SystemTime` measurement earlier than the first**. In other words, an/// operation that happens after another operation in real time may have an/// earlier `SystemTime`!/// Consequently, comparing two `SystemTime` instances to learn about the/// duration between them returns a [`Result`] instead of an infallible [`Duration`]/// to indicate that this sort of time drift may happen and needs to be handled./// Although a `SystemTime` cannot be directly inspected, the [`UNIX_EPOCH`]/// constant is provided in this module as an anchor in time to learn/// information about a `SystemTime`. By calculating the duration from this/// fixed point in time, a `SystemTime` can be converted to a human-readable time,/// or perhaps some other string representation./// The size of a `SystemTime` struct may vary depending on the target operating/// A `SystemTime` does not count leap seconds./// `SystemTime::now()`'s behavior around a leap second/// is the same as the operating system's wall clock./// The precise behavior near a leap second/// (e.g. whether the clock appears to run slow or fast, or stop, or jump)/// depends on platform and configuration,/// so should not be relied on.///    let now = SystemTime::now();///    match now.elapsed() {///        Ok(elapsed) => {///            // it prints '2'///            println!("{}", elapsed.as_secs());///        Err(e) => {///            // the system clock went backwards!///            println!("Great Scott! {e:?}");/// The precision of `SystemTime` can depend on the underlying OS-specific time format./// For example, on Windows the time is represented in 100 nanosecond intervals whereas Linux/// can represent nanosecond intervals./// | UNIX      | [clock_gettime (Realtime Clock)]                                     |/// | Darwin    | [clock_gettime (Realtime Clock)]                                     |/// | VXWorks   | [clock_gettime (Realtime Clock)]                                     |/// | SOLID     | `SOLID_RTC_ReadTime`                                                 |/// | WASI      | [__wasi_clock_time_get (Realtime Clock)]                             |/// | Windows   | [GetSystemTimePreciseAsFileTime] / [GetSystemTimeAsFileTime]         |/// [clock_gettime (Realtime Clock)]: https://linux.die.net/man/3/clock_gettime/// [__wasi_clock_time_get (Realtime Clock)]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#clock_time_get/// [GetSystemTimePreciseAsFileTime]: https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimepreciseasfiletime/// [GetSystemTimeAsFileTime]: https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimeasfiletime/// [`add`]: SystemTime::add/// [`UNIX_EPOCH`]: SystemTime::UNIX_EPOCH/// An error returned from the `duration_since` and `elapsed` methods on/// `SystemTime`, used to learn how far in the opposite direction a system time/// lies./// let sys_time = SystemTime::now();/// sleep(Duration::from_secs(1));/// let new_sys_time = SystemTime::now();/// match sys_time.duration_since(new_sys_time) {///     Ok(_) => {}///     Err(e) => println!("SystemTimeError difference: {:?}", e.duration()),/// Previous Rust versions panicked when `earlier` was later than `self`. Currently this/// println!("{:?}", new_now.duration_since(now));/// println!("{:?}", now.duration_since(new_now)); // 0ns/// or None if that instant is later than this one./// Due to [monotonicity bugs], even under correct logical ordering of the passed `Instant`s,/// this method can return `None`./// [monotonicity bugs]: Instant#monotonicity/// println!("{:?}", new_now.checked_duration_since(now));/// println!("{:?}", now.checked_duration_since(new_now)); // None/// println!("{:?}", new_now.saturating_duration_since(now));/// println!("{:?}", now.saturating_duration_since(new_now)); // 0ns/// Returns the amount of time elapsed since this instant./// Previous Rust versions panicked when the current time was earlier than self. Currently this/// method returns a Duration of zero in that case. Future versions may reintroduce the panic./// let three_secs = Duration::from_secs(3);/// sleep(three_secs);/// assert!(instant.elapsed() >= three_secs);// Used by platform specific `sleep_until` implementations such as the one used on Linux./// An anchor in time which can be used to create new `SystemTime` instances or/// learn about where in time a `SystemTime` lies.// NOTE! this documentation is duplicated, here and in std::time::UNIX_EPOCH.// The two copies are not quite identical, because of the difference in naming./// This constant is defined to be "1970-01-01 00:00:00 UTC" on all systems with/// respect to the system clock. Using `duration_since` on an existing/// `SystemTime` instance can tell how far away from this point in time a/// measurement lies, and using `UNIX_EPOCH + duration` can be used to create a/// `SystemTime` instance to represent another fixed point in time./// `duration_since(UNIX_EPOCH).unwrap().as_secs()` returns/// the number of non-leap seconds since the start of 1970 UTC./// This is a POSIX `time_t` (as a `u64`),/// and is the same time representation as used in many Internet protocols./// match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {///     Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()),///     Err(_) => panic!("SystemTime before UNIX EPOCH!"),/// Returns the system time corresponding to "now"./// Returns the amount of time elapsed from an earlier point in time./// This function may fail because measurements taken earlier are not/// guaranteed to always be before later measurements (due to anomalies such/// as the system clock being adjusted either forwards or backwards)./// [`Instant`] can be used to measure elapsed time without this risk of failure./// If successful, <code>[Ok]\([Duration])</code> is returned where the duration represents/// the amount of time elapsed from the specified measurement to this one./// Returns an [`Err`] if `earlier` is later than `self`, and the error/// contains how far from `self` the time is./// let difference = new_sys_time.duration_since(sys_time)///     .expect("Clock may have gone backwards");/// println!("{difference:?}");/// Returns the difference from this system time to the/// current clock time./// This function may fail as the underlying system clock is susceptible to/// drift and updates (e.g., the system clock could go backwards), so this/// function might not always succeed. If successful, <code>[Ok]\([Duration])</code> is/// returned where the duration represents the amount of time elapsed from/// this time measurement to the current time./// To measure elapsed time reliably, use [`Instant`] instead./// Returns an [`Err`] if `self` is later than the current system time, and/// the error contains how far from the current system time `self` is./// let one_sec = Duration::from_secs(1);/// sleep(one_sec);/// assert!(sys_time.elapsed().unwrap() >= one_sec);/// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`/// underlying data structure. See [`SystemTime::checked_add`] for a version without panic.// NOTE! this documentation is duplicated, here and in SystemTime::UNIX_EPOCH./// [`SystemTime`] instance can tell how far away from this point in time a/// [`SystemTime`] instance to represent another fixed point in time./// use std::time::{SystemTime, UNIX_EPOCH};/// match SystemTime::now().duration_since(UNIX_EPOCH) {/// Returns the positive duration which represents how far forward the/// second system time was from the first./// A `SystemTimeError` is returned from the [`SystemTime::duration_since`]/// and [`SystemTime::elapsed`] methods whenever the second system time/// represents a point later in time than the `self` of the method call.//! Using [`Instant`] to calculate how long a function took to run://! ```ignore (incomplete)//! let now = Instant::now();//! // Calling a slow function, it may take a while//! slow_function();//! let elapsed_time = now.elapsed();//! println!("Running slow_function() took {} seconds.", elapsed_time.as_secs());//! Make sure that a `std` macro `hash_map!` does not cause ambiguity//! with a local glob import with the same name.//! See regression https://github.com/rust-lang/rust/issues/147971builtin_clone// Test that `Clone` is correctly implemented for builtin types.// Also test that cloning an array or a tuple is done right, i.e.// each component is cloned.// Copied from std::test_helpersCurrentDir// On some platforms, setting the current directory will prevent deleting it.// So this helper ensures the current directory is reset.create_dir_all_bare// File system access on Windows not supported by Miri//! Note that this test changes the current directory so//! should not be in the same process as other tests.test_self_exe_pathsplit_paths_windowssplit_paths_unixjoin_paths_unixjoin_paths_windowsargs_debugargs_os_debugvars_debugvars_os_debugmake_rand_nametest_set_vartest_remove_vartest_set_var_overwritetest_var_bigtest_env_set_get_hugetest_env_set_varenv_home_dirtest_env_get_set_multithreaded// miri shouldn't detect any data race in this fn// These tests are in a separate integration test as they modify the environment,// and would otherwise cause some other tests to fail.BazFueq_multidispatchdowncastingSuperErrorSideKickSuperErrorsingle_line_formattingmulti_line_formattingerror_with_no_sources_formats_single_line_correctlyerror_with_no_sources_formats_multi_line_correctlyerror_with_backtrace_outputs_correctly_with_one_sourceerror_with_backtrace_outputs_correctly_with_two_sourcesnew_with_sourceerror_formats_single_line_with_rude_display_implerror_formats_multi_line_with_rude_display_implerrors_that_start_with_newline_formats_correctlyerrors_with_multiple_writes_on_same_line_dont_insert_erroneous_newlineserrors_with_string_interpolation_formats_correctlyempty_lines_mid_messageonly_one_sourceTOL_IMPR/// Tolerances for math that is allowed to be imprecise, usually due to multiple chainedassert_f128_biteq/// Compare by representationtest_num_f128test_gammatest_ln_gammatest_real_consts// Many math functions allow for less accurate results, so the next tolerance up is usedassert_f16_biteqAPPROX_DELTAassert_f32_biteqassert_f64_biteq/// Verify that floats are within a tolerance of each other, 1.0e-6 by default.// for reliable_f16_f128test_stack_assigntest_heap_littest_heap_assigntest_heap_logcheck_loglog_knows_the_names_of_variants_in_stdminmax_stabilitytest_saturating_add_uinttest_saturating_sub_uinttest_saturating_add_inttest_saturating_sub_inttest_checked_addtest_checked_subtest_checked_multest_is_power_of_twotest_next_power_of_twotest_checked_next_power_of_twotest_uint_to_str_overflowtest_uint_from_str_overflowpanic_safety_traitstest_pathbuf_leaktest_decompositions_unixtest_decompositions_windowstest_decompositions_cygwin// Unix paths are tested in `test_decompositions_unix` above.test_stem_exttest_prefix_exttest_set_file_nametest_set_extensiontest_add_extensiontest_with_extensiontest_with_added_extensiontest_eq_receiverstest_comparetest_components_debugtest_clone_intodisplay_format_flagstest_unix_absolutetest_windows_absolute"path separator"test_extension_path_septest_extension_path_sep_alternatetest_only_separators// Test: Only separators (e.g., "/" or "\\")// This test checks how Path handles a string that consists only of path separators.// It should recognize the root and not treat it as a normal component.test_non_ascii_unicode// Test: Non-ASCII/Unicode// This test verifies that Path can handle Unicode and non-ASCII characters in the path.// It ensures that such paths are not rejected or misinterpreted.test_embedded_newline// Test: Embedded newlines// This test verifies that newlines within path components are preserved and do not break path parsing.// It ensures that Path treats newlines as normal characters.compare_path_like_to_str_like/// See issue#146183 and issue#146940test_trim_trailing_sepissue_15149// Process spawning not supported by Miri, Emscripten and wasiaarch64_linuxpowerpc_linuxpowerpc64_linuxs390x_linuxx86_all//! These tests just check that the macros are available in std.seq_compareslice_from_array// This intends to use the unsizing coercion from array to slice, but it only// works if we resolve `<&[u8]>::from` as the reflexive `From<T> for T`. In// #113238, we found that gimli had added its own `From<EndianSlice> for &[u8]`// that affected all `std/backtrace` users.switch_stdout_toswitch_stdout// dup/SetStdHandle not supported by Miri/// Asserts that `Barrier` is ref unwind safe./// See <https://github.com/rust-lang/rust/issues/146087>.nonpoison_and_poison_unwrap_testpoison_notify_one// No threads.nonpoison_notify_onepoison_notify_allnonpoison_notify_allpoison_test_mutex_arc_condvarnonpoison_test_mutex_arc_condvarpoison_wait_whilenonpoison_wait_whilepoison_wait_timeout_waitnonpoison_wait_timeout_waitpoison_wait_timeout_while_waitnonpoison_wait_timeout_while_waitpoison_wait_timeout_while_instant_satisfynonpoison_wait_timeout_while_instant_satisfypoison_wait_timeout_while_wakenonpoison_wait_timeout_while_wakepoison_wait_timeout_wakenonpoison_wait_timeout_wakepoison_timeout_nanoseconds// Some platforms internally cast the timeout duration into nanoseconds.// If they fail to consider overflow during the conversion (I'm looking// at you, macOS), `wait_timeout` will return immediately and indicate a// timeout for durations that are slightly longer than u64::MAX nanoseconds.// `std` should guard against this by clamping the timeout.// See #37440 for context.nonpoison_timeout_nanosecondstest_arc_condvar_poisonspawn_and_waitlazy_defaultsync_lazy_newsync_lazy_defaultstatic_sync_lazystatic_sync_lazy_via_fnis_sync_sendlazy_poisoninglazy_lock_deref_panic/// Verifies that when a `LazyLock` is poisoned, it panics with the correct error message ("LazyLock/// instance has previously been poisoned") instead of the underlying `Once` error message.lazy_lock_deref_mut_paniclazy_lock_preserves_closure_panic_message/// Verifies that when the initialization closure panics with a custom message, that message is/// preserved and not overridden by `LazyLock`.mpsc_sync"../common/mod.rs"result_unwrap/// A macro that generates two test cases for both the poison and nonpoison locks./// To write a test that tests both `poison` and `nonpoison` locks, import any of the types/// under both `poison` and `nonpoison` using the module name `locks` instead. For example, write/// `use locks::Mutex;` instead of `use std::sync::poiosn::Mutex`. This will import the correct type/// for each test variant./// Write a test as normal in the `test_body`, but instead of calling `unwrap` on `poison` methods/// that return a `LockResult` or similar, call the function `maybe_unwrap(...)` on the result./// For example, call `maybe_unwrap(mutex.lock())` instead of `mutex.lock().unwrap()` or/// `maybe_unwrap(rwlock.read())` instead of `rwlock.read().unwrap()`./// For the `poison` types, `maybe_unwrap` will simply unwrap the `Result` (usually this is a form/// of `LockResult`, but it could also be other kinds of results). For the `nonpoison` types, it is/// a no-op (the identity function)./// The test names will be prefiex with `poison_` or `nonpoison_`./// Important: most attributes (except `cfg`) will not work properly! (They are only applied to the first test.)/// See <https://github.com/rust-lang/rust/pull/146433> for more information.// For concatenating identifiers in macros.stress_factordrop_fulldrop_full_sharedsmoke_sharedsmoke_threadssmoke_port_gonesmoke_receiver_clonesmoke_receiver_clone_port_gonesmoke_shared_port_gonesmoke_shared_port_gone2port_gone_concurrentport_gone_concurrent_sharedsmoke_chan_gonesmoke_chan_gone_sharedchan_gone_concurrentreceiver_cloningstress_sharedsend_from_outside_runtimerecv_from_outside_runtimeno_runtimeoneshot_single_thread_close_port_firstoneshot_single_thread_close_chan_firstoneshot_single_thread_send_port_closeoneshot_single_thread_recv_chan_closeoneshot_single_thread_send_then_recvoneshot_single_thread_try_send_openoneshot_single_thread_try_send_closedoneshot_single_thread_try_recv_openoneshot_single_thread_try_recv_closedoneshot_single_thread_peek_dataoneshot_single_thread_peek_closeoneshot_single_thread_peek_openoneshot_multi_task_recv_then_sendoneshot_multi_task_recv_then_closeoneshot_multi_thread_close_stressoneshot_multi_thread_send_close_stressoneshot_multi_thread_recv_close_stressoneshot_multi_thread_send_recv_stressstream_send_recv_stressoneshot_single_thread_recv_timeoutstress_recv_timeout_two_threadsrecv_timeout_upgradestress_recv_timeout_sharedvery_long_recv_timeout_wont_panicrecv_a_lotshared_recv_timeoutshared_chan_stresstest_nested_recv_itertest_recv_iter_breaktest_recv_try_itertest_recv_into_iter_ownedtest_recv_into_iter_borrowedtry_recv_statesdestroy_upgraded_shared_port_when_sender_still_active// This bug used to end up in a livelock inside of the Receiver destructor// because the internal state of the Shared packet was corruptedissue_32114issue_39364oneshot_single_thread_try_send_closed2oneshot_single_thread_try_recv_closed_with_datasend1send2send3send4try_send1try_send2try_send3issue_15761drop_unreceived// Nonpoison & Poison TestsNonCopyNeedsDrop// Ensure that old values that are replaced by `set` are correctly dropped.// Requires unwinding support.new_poisoned_mutex/// Creates a mutex that is immediately poisoned.test_into_inner_poisontest_get_cloned_poisontest_get_mut_poisontest_set_poisontest_replace_poisontest_mutex_arc_poisontest_mutex_arc_poison_mappedpanic_while_mapping_unlocked_poisontest_mutex_with_mut// Poison Testswait_on_poisonedwait_force_on_poisonedsync_once_cellsync_once_cell_get_mutsync_once_cell_dropsync_once_cell_drop_emptyeval_once_macrosync_once_cell_does_not_leak_partially_constructed_boxes// Non-poison & Poison Tests// FIXME: On macOS we use a provenance-incorrect implementation and Miri// catches that issue with a chance of around 1/1000.// See <https://github.com/rust-lang/rust/issues/121950> for details.// FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.nonpoison_test_rwlock_try_writepoison_test_rwlock_try_writenew_poisoned_rwlock/// Creates a rwlock that is immediately poisoned.test_rw_arc_poison_wrtest_rw_arc_poison_mapped_w_rtest_rw_arc_poison_wwtest_rw_arc_poison_mapped_w_wtest_rw_arc_no_poison_mapped_r_rtest_rw_arc_no_poison_mapped_r_wpanic_while_mapping_read_unlocked_no_poisonpanic_while_mapping_write_unlocked_poisontest_rwlock_withtest_rwlock_with_mutsleep_very_long// Miri does not like the thread leakthread_local_containing_const_statementsthread_local_hygeiene// Include an ignore list on purpose, so that new platforms don't miss ithashmaprefcell_vecdynamic_testssmoke_no_dtorsmoke_dtorcircularself_referentialdtors_in_dtors_in_dtors// Note that this test will deadlock if TLS destructors aren't run (this// requires the destructor to be run to pass the test).dtors_in_dtors_in_dtors_const_initjoin_orders_after_tls_destructors// This test tests that TLS destructors have run before the thread joins. The// test has no false positives (meaning: if the test fails, there's actually// an ordering problem). It may have false negatives, where the test passes but// join is not guaranteed to be after the TLS destructors. However, false// negatives should be exceedingly rare due to judicious use of// thread::yield_now and running the test several times.thread_current_in_dtor// Test that thread::current is still available in TLS destructors.// The test won't currently work without target_thread_local, aka with slow tls.// The runtime tries very hard to drop last the TLS variable that keeps the information about the// current thread, by using several tricks like deferring the drop to a later round of TLS destruction.// However, this only seems to work with fast tls.// With slow TLS, it seems that multiple libc implementations will just set the value to null the first// time they encounter it, regardless of it having a destructor or not. This means that trying to// retrieve it later in a drop impl of another TLS variable will not work.// ** Apple libc: https://github.com/apple-oss-distributions/libpthread/blob/c032e0b076700a0a47db75528a282b8d3a06531a/src/pthread_tsd.c#L293// Sets the variable to null if it has a destructor and the value is not null. However, all variables// created with pthread_key_create are marked as having a destructor, even if the fn ptr called with// it is null.// ** glibc: https://github.com/bminor/glibc/blob/e5893e6349541d871e8a25120bca014551d13ff5/nptl/nptl_deallocate_tsd.c#L59// ** musl: https://github.com/kraj/musl/blob/1880359b54ff7dd9f5016002bfdae4b136007dde/src/thread/pthread_key_create.c#L87instant_monotonicinstant_monotonic_concurrentinstant_elapsedinstant_mathinstant_math_is_associativeinstant_duration_since_saturatesinstant_checked_duration_since_nopanicinstant_saturating_duration_since_nopanicsystem_time_mathsystem_time_elapsedsince_epochbig_mathsystem_time_duration_since_max_range_on_unixNTtype_name_unsized/// Tests that [`std::any::type_name`] supports unsized types.volatile_fat_ptrwin_delete_self/// Attempting to delete a running binary should return an error on Windows.// `remove_file` does not work in Miri on Windowsos_string_must_know_it_isnt_utf8_issue_126291//! An external testsr" Check for the presence of a CPU feature at runtime."r" When the feature is known to be enabled at compile time (e.g. via `-Ctarget-feature`)"r" the macro expands to `true`."r" This macro takes one argument which is a string literal of the feature being tested for."r" The feature names are mostly taken from their FEAT_* definitions in the [ARM Architecture"r" Reference Manual][docs]."r" Currently most features are only supported on linux-based platforms: on other platforms the"r" runtime check will always return `false`."r" ## Supported arguments"r#" * `"aes"` - FEAT_AES & FEAT_PMULL"#r#" * `"asimd"` or "neon" - FEAT_AdvSIMD"#r#" * `"bf16"` - FEAT_BF16"#r#" * `"bti"` - FEAT_BTI"#r#" * `"crc"` - FEAT_CRC"#r#" * `"cssc"` - FEAT_CSSC"#r#" * `"dit"` - FEAT_DIT"#r#" * `"dotprod"` - FEAT_DotProd"#r#" * `"dpb"` - FEAT_DPB"#r#" * `"dpb2"` - FEAT_DPB2"#r#" * `"ecv"` - FEAT_ECV"#r#" * `"f32mm"` - FEAT_F32MM"#r#" * `"f64mm"` - FEAT_F64MM"#r#" * `"faminmax"` - FEAT_FAMINMAX"#r#" * `"fcma"` - FEAT_FCMA"#r#" * `"fhm"` - FEAT_FHM"#r#" * `"flagm"` - FEAT_FLAGM"#r#" * `"flagm2"` - FEAT_FLAGM2"#r#" * `"fp"` - FEAT_FP"#r#" * `"fp16"` - FEAT_FP16"#r#" * `"fp8"` - FEAT_FP8"#r#" * `"fp8dot2"` - FEAT_FP8DOT2"#r#" * `"fp8dot4"` - FEAT_FP8DOT4"#r#" * `"fp8fma"` - FEAT_FP8FMA"#r#" * `"fpmr"` - FEAT_FPMR"#r#" * `"frintts"` - FEAT_FRINTTS"#r#" * `"hbc"` - FEAT_HBC"#r#" * `"i8mm"` - FEAT_I8MM"#r#" * `"jsconv"` - FEAT_JSCVT"#r#" * `"lse"` - FEAT_LSE"#r#" * `"lse128"` - FEAT_LSE128"#r#" * `"lse2"` - FEAT_LSE2"#r#" * `"lut"` - FEAT_LUT"#r#" * `"mops"` - FEAT_MOPS"#r#" * `"mte"` - FEAT_MTE & FEAT_MTE2"#r#" * `"paca"` - FEAT_PAuth (address authentication)"#r#" * `"pacg"` - FEAT_Pauth (generic authentication)"#r#" * `"pauth-lr"` - FEAT_PAuth_LR"#r#" * `"pmull"` - FEAT_PMULL"#r#" * `"rand"` - FEAT_RNG"#r#" * `"rcpc"` - FEAT_LRCPC"#r#" * `"rcpc2"` - FEAT_LRCPC2"#r#" * `"rcpc3"` - FEAT_LRCPC3"#r#" * `"rdm"` - FEAT_RDM"#r#" * `"sb"` - FEAT_SB"#r#" * `"sha2"` - FEAT_SHA1 & FEAT_SHA256"#r#" * `"sha3"` - FEAT_SHA512 & FEAT_SHA3"#r#" * `"sm4"` - FEAT_SM3 & FEAT_SM4"#r#" * `"sme"` - FEAT_SME"#r#" * `"sme-b16b16"` - FEAT_SME_B16B16"#r#" * `"sme-f16f16"` - FEAT_SME_F16F16"#r#" * `"sme-f64f64"` - FEAT_SME_F64F64"#r#" * `"sme-f8f16"` - FEAT_SME_F8F16"#r#" * `"sme-f8f32"` - FEAT_SME_F8F32"#r#" * `"sme-fa64"` - FEAT_SME_FA64"#r#" * `"sme-i16i64"` - FEAT_SME_I16I64"#r#" * `"sme-lutv2"` - FEAT_SME_LUTv2"#r#" * `"sme2"` - FEAT_SME2"#r#" * `"sme2p1"` - FEAT_SME2p1"#r#" * `"ssbs"` - FEAT_SSBS & FEAT_SSBS2"#r#" * `"ssve-fp8dot2"` - FEAT_SSVE_FP8DOT2"#r#" * `"ssve-fp8dot4"` - FEAT_SSVE_FP8DOT4"#r#" * `"ssve-fp8fma"` - FEAT_SSVE_FP8FMA"#r#" * `"sve"` - FEAT_SVE"#r#" * `"sve-b16b16"` - FEAT_SVE_B16B16 (SVE or SME Z-targeting instructions)"#r#" * `"sve2"` - FEAT_SVE2"#r#" * `"sve2-aes"` - FEAT_SVE_AES & FEAT_SVE_PMULL128 (SVE2 AES crypto)"#r#" * `"sve2-bitperm"` - FEAT_SVE2_BitPerm"#r#" * `"sve2-sha3"` - FEAT_SVE2_SHA3"#r#" * `"sve2-sm4"` - FEAT_SVE2_SM4"#r#" * `"sve2p1"` - FEAT_SVE2p1"#r#" * `"tme"` - FEAT_TME"#r#" * `"wfxt"` - FEAT_WFxT"#r" [docs]: https://developer.arm.com/documentation/ddi0487/latest"//! Aarch64 run-time features.//! Run-time feature detection on ARM Aarch32.r" Supported arguments are:"r#" * `"32s"`"#r#" * `"f"`"#r#" * `"d"`"#r#" * `"frecipe"`"#r#" * `"div32"`"#r#" * `"lsx"`"#r#" * `"lasx"`"#r#" * `"lam-bh"`"#r#" * `"lamcas"`"#r#" * `"ld-seq-sa"`"#r#" * `"scq"`"#r#" * `"lbt"`"#r#" * `"lvz"`"#r#" * `"ual"`"#//! Run-time feature detection on LoongArch.//! Run-time feature detection on MIPS.//! Run-time feature detection on MIPS64.// Export the macros for all supported architectures.loongarch//! Run-time feature detection on PowerPC.//! Run-time feature detection on PowerPC64.r" RISC-V standard defined the base sets and the extension sets."r" The base sets are RV32I, RV64I, RV32E or RV128I. Any RISC-V platform"r" must support one base set and/or multiple extension sets."r" Any RISC-V standard instruction sets can be in state of either ratified,"r" frozen or draft. The version and status of current standard instruction"r" sets can be checked out from preface section of the [ISA manual]."r" Platform may define and support their own custom instruction sets with"r" ISA prefix X. These sets are highly platform specific and should be"r" detected with their own platform support crates."r" [ISA manual]: https://riscv.org/specifications/ratified/"r" # Platform-specific/agnostic Behavior and Availability"r" Runtime detection depends on the platform-specific feature detection"r" facility and its availability per feature is"r" highly platform/version-specific."r" Still, a best-effort attempt is performed to enable subset/dependent"r" features if a superset feature is enabled regardless of the platform."r#" For instance, if the A extension (`"a"`) is enabled, its subsets (the"#r#" Zalrsc and Zaamo extensions; `"zalrsc"` and `"zaamo"`) are also enabled."#r#" Likewise, if the F extension (`"f"`) is enabled, one of its dependencies"#r#" (the Zicsr extension `"zicsr"`) is also enabled."#r" # Unprivileged Specification"r" The supported ratified RISC-V instruction sets are as follows (OS"r" columns denote runtime feature detection support with or without the"r" minimum supported version):"r" | Literal    | Base    | Linux      |"r" |:---------- |:------- |:---------- |"r#" | `"rv32e"`  | RV32E   | No         |"#r#" | `"rv32i"`  | RV32I   | Yes [^ima] |"#r#" | `"rv64i"`  | RV64I   | Yes [^ima] |"#r" | Literal         | Extension   | Linux               |"r" |:--------------- |:----------- |:------------------- |"r#" | `"a"`           | A           | Yes [^ima]          |"#r#" | `"b"`           | B           | 6.5                 |"#r#" | `"c"`           | C           | Yes                 |"#r#" | `"d"`           | D           | Yes                 |"#r#" | `"f"`           | F           | Yes                 |"#r#" | `"m"`           | M           | Yes [^ima]          |"#r#" | `"q"`           | Q           | No                  |"#r#" | `"v"`           | V           | 6.5                 |"#r#" | `"zaamo"`       | Zaamo       | 6.15 [^ima] [^dep]  |"#r#" | `"zabha"`       | Zabha       | 6.16                |"#r#" | `"zacas"`       | Zacas       | 6.8                 |"#r#" | `"zalrsc"`      | Zalrsc      | 6.15 [^ima] [^dep]  |"#r#" | `"zawrs"`       | Zawrs       | 6.11                |"#r#" | `"zba"`         | Zba         | 6.5                 |"#r#" | `"zbb"`         | Zbb         | 6.5                 |"#r#" | `"zbc"`         | Zbc         | 6.8                 |"#r#" | `"zbkb"`        | Zbkb        | 6.8                 |"#r#" | `"zbkc"`        | Zbkc        | 6.8                 |"#r#" | `"zbkx"`        | Zbkx        | 6.8                 |"#r#" | `"zbs"`         | Zbs         | 6.5                 |"#r#" | `"zca"`         | Zca         | 6.11 [^dep]         |"#r#" | `"zcb"`         | Zcb         | 6.11                |"#r#" | `"zcd"`         | Zcd         | 6.11 [^dep]         |"#r#" | `"zcf"`         | Zcf         | 6.11 [^dep]         |"#r#" | `"zcmop"`       | Zcmop       | 6.11                |"#r#" | `"zdinx"`       | Zdinx       | No                  |"#r#" | `"zfa"`         | Zfa         | 6.8                 |"#r#" | `"zfbfmin"`     | Zfbfmin     | 6.15                |"#r#" | `"zfh"`         | Zfh         | 6.8                 |"#r#" | `"zfhmin"`      | Zfhmin      | 6.8                 |"#r#" | `"zfinx"`       | Zfinx       | No                  |"#r#" | `"zhinx"`       | Zhinx       | No                  |"#r#" | `"zhinxmin"`    | Zhinxmin    | No                  |"#r#" | `"zicbom"`      | Zicbom      | 6.15                |"#r#" | `"zicboz"`      | Zicboz      | 6.7                 |"#r#" | `"zicntr"`      | Zicntr      | 6.15 [^ima] [^cntr] |"#r#" | `"zicond"`      | Zicond      | 6.8                 |"#r#" | `"zicsr"`       | Zicsr       | No [^ima] [^dep]    |"#r#" | `"zifencei"`    | Zifencei    | No [^ima]           |"#r#" | `"zihintntl"`   | Zihintntl   | 6.8                 |"#r#" | `"zihintpause"` | Zihintpause | 6.10                |"#r#" | `"zihpm"`       | Zihpm       | 6.15 [^cntr]        |"#r#" | `"zimop"`       | Zimop       | 6.11                |"#r#" | `"zk"`          | Zk          | No [^zkr]           |"#r#" | `"zkn"`         | Zkn         | 6.8                 |"#r#" | `"zknd"`        | Zknd        | 6.8                 |"#r#" | `"zkne"`        | Zkne        | 6.8                 |"#r#" | `"zknh"`        | Zknh        | 6.8                 |"#r#" | `"zkr"`         | Zkr         | No [^zkr]           |"#r#" | `"zks"`         | Zks         | 6.8                 |"#r#" | `"zksed"`       | Zksed       | 6.8                 |"#r#" | `"zksh"`        | Zksh        | 6.8                 |"#r#" | `"zkt"`         | Zkt         | 6.8                 |"#r#" | `"ztso"`        | Ztso        | 6.8                 |"#r#" | `"zvbb"`        | Zvbb        | 6.8                 |"#r#" | `"zvbc"`        | Zvbc        | 6.8                 |"#r#" | `"zve32f"`      | Zve32f      | 6.11 [^dep]         |"#r#" | `"zve32x"`      | Zve32x      | 6.11 [^dep]         |"#r#" | `"zve64d"`      | Zve64d      | 6.11 [^dep]         |"#r#" | `"zve64f"`      | Zve64f      | 6.11 [^dep]         |"#r#" | `"zve64x"`      | Zve64x      | 6.11 [^dep]         |"#r#" | `"zvfbfmin"`    | Zvfbfmin    | 6.15                |"#r#" | `"zvfbfwma"`    | Zvfbfwma    | 6.15                |"#r#" | `"zvfh"`        | Zvfh        | 6.8                 |"#r#" | `"zvfhmin"`     | Zvfhmin     | 6.8                 |"#r#" | `"zvkb"`        | Zvkb        | 6.8                 |"#r#" | `"zvkg"`        | Zvkg        | 6.8                 |"#r#" | `"zvkn"`        | Zvkn        | 6.8                 |"#r#" | `"zvknc"`       | Zvknc       | 6.8                 |"#r#" | `"zvkned"`      | Zvkned      | 6.8                 |"#r#" | `"zvkng"`       | Zvkng       | 6.8                 |"#r#" | `"zvknha"`      | Zvknha      | 6.8                 |"#r#" | `"zvknhb"`      | Zvknhb      | 6.8                 |"#r#" | `"zvks"`        | Zvks        | 6.8                 |"#r#" | `"zvksc"`       | Zvksc       | 6.8                 |"#r#" | `"zvksed"`      | Zvksed      | 6.8                 |"#r#" | `"zvksg"`       | Zvksg       | 6.8                 |"#r#" | `"zvksh"`       | Zvksh       | 6.8                 |"#r#" | `"zvkt"`        | Zvkt        | 6.8                 |"#r" [^ima]: Or enabled when the IMA base behavior is detected on the Linux"r" kernel version 6.4 or later (for bases, the only matching one -- either"r#" `"rv32i"` or `"rv64i"` -- is enabled)."#r" [^cntr]: Even if this extension is available, it does not necessarily"r" mean all performance counters are accessible."r" For example, accesses to all performance counters except `time`"r" (wall-clock) are blocked by default on the Linux kernel"r" version 6.6 or later."r" Also beware that, even if performance counters like `cycle` and"r" `instret` are accessible, their value can be unreliable (e.g. returning"r" the constant value) under certain circumstances."r" [^dep]: Or enabled as a dependency of another extension (a superset)"r" even if runtime detection of this feature itself is not supported (as"r" long as the runtime detection of the superset is supported)."r" [^zkr]: Linux does not report existence of this extension even if"r" supported by the hardware mainly because the `seed` CSR on the Zkr"r" extension (which provides hardware-based randomness) is normally"r" inaccessible from the user mode."r" For the Zk extension features except this CSR, check existence of both"r#" `"zkn"` and `"zkt"` features instead."#r" There's also bases and extensions marked as standard instruction set,"r" but they are in frozen or draft state. These instruction sets are also"r" reserved by this macro and can be detected in the future platforms."r" Draft RISC-V instruction sets:"r#" * RV128I: `"rv128i"`"#r#" * J: `"j"`"#r#" * P: `"p"`"#r#" * Zam: `"zam"`"#r" # Performance Hints"r" The two features below define performance hints for unaligned"r" scalar/vector memory accesses, respectively.  If enabled, it denotes that"r" corresponding unaligned memory access is reasonably fast."r#" * `"unaligned-scalar-mem"`"#r"   * Runtime detection requires Linux kernel version 6.4 or later."r#" * `"unaligned-vector-mem"`"#r"   * Runtime detection requires Linux kernel version 6.13 or later."//! Run-time feature detection on RISC-V.//! Run-time feature detection on s390x.r" Runtime detection currently relies mostly on the `cpuid` instruction."r" This macro only takes one argument which is a string literal of the feature"r" being tested for. The feature names supported are the lowercase versions of"r" the ones defined by Intel in [their documentation][docs]."r" This macro supports the same names that `#[target_feature]` supports. Unlike"r" `#[target_feature]`, however, this macro does not support names separated"r" with a comma. Instead testing for multiple features must be done through"r" separate macro invocations for now."r#" * `"aes"`"#r#" * `"pclmulqdq"`"#r#" * `"rdrand"`"#r#" * `"rdseed"`"#r#" * `"tsc"`"#r#" * `"mmx"`"#r#" * `"sse"`"#r#" * `"sse2"`"#r#" * `"sse3"`"#r#" * `"ssse3"`"#r#" * `"sse4.1"`"#r#" * `"sse4.2"`"#r#" * `"sse4a"`"#r#" * `"sha"`"#r#" * `"avx"`"#r#" * `"avx2"`"#r#" * `"sha512"`"#r#" * `"sm3"`"#r#" * `"sm4"`"#r#" * `"avx512f"`"#r#" * `"avx512cd"`"#r#" * `"avx512er"`"#r#" * `"avx512pf"`"#r#" * `"avx512bw"`"#r#" * `"avx512dq"`"#r#" * `"avx512vl"`"#r#" * `"avx512ifma"`"#r#" * `"avx512vbmi"`"#r#" * `"avx512vpopcntdq"`"#r#" * `"avx512vbmi2"`"#r#" * `"gfni"`"#r#" * `"vaes"`"#r#" * `"vpclmulqdq"`"#r#" * `"avx512vnni"`"#r#" * `"avx512bitalg"`"#r#" * `"avx512bf16"`"#r#" * `"avx512vp2intersect"`"#r#" * `"avx512fp16"`"#r#" * `"avxvnni"`"#r#" * `"avxifma"`"#r#" * `"avxneconvert"`"#r#" * `"avxvnniint8"`"#r#" * `"avxvnniint16"`"#r#" * `"amx-tile"`"#r#" * `"amx-int8"`"#r#" * `"amx-bf16"`"#r#" * `"amx-fp16"`"#r#" * `"amx-complex"`"#r#" * `"amx-avx512"`"#r#" * `"amx-fp8"`"#r#" * `"amx-movrs"`"#r#" * `"amx-tf32"`"#r#" * `"f16c"`"#r#" * `"fma"`"#r#" * `"bmi1"`"#r#" * `"bmi2"`"#r#" * `"abm"`"#r#" * `"lzcnt"`"#r#" * `"tbm"`"#r#" * `"popcnt"`"#r#" * `"fxsr"`"#r#" * `"xsave"`"#r#" * `"xsaveopt"`"#r#" * `"xsaves"`"#r#" * `"xsavec"`"#r#" * `"cmpxchg16b"`"#r#" * `"kl"`"#r#" * `"widekl"`"#r#" * `"adx"`"#r#" * `"rtm"`"#r#" * `"movbe"`"#r#" * `"ermsb"`"#r#" * `"movrs"`"#r#" * `"xop"`"#r" [docs]: https://software.intel.com/sites/landingpage/IntrinsicsGuide"r" Each variant denotes a position in a bitset for a particular feature."r" PLEASE: do not use this, it is an implementation detail subject"r" to change."r" AES (Advanced Encryption Standard New Instructions AES-NI)"r" CLMUL (Carry-less Multiplication)"r" RDRAND"r" RDSEED"r" TSC (Time Stamp Counter)"r" MMX (MultiMedia eXtensions)"mmxr" SSE (Streaming SIMD Extensions)"r" SSE2 (Streaming SIMD Extensions 2)"r" SSE3 (Streaming SIMD Extensions 3)"sse3r" SSSE3 (Supplemental Streaming SIMD Extensions 3)"r" SSE4.1 (Streaming SIMD Extensions 4.1)"sse4_1r" SSE4.2 (Streaming SIMD Extensions 4.2)"sse4_2r" SSE4a (Streaming SIMD Extensions 4a)"sse4ar" SHA"r" AVX (Advanced Vector Extensions)"r" AVX2 (Advanced Vector Extensions 2)"r" SHA512"r" SM3"r" SM4"sm4r" AVX-512 F (Foundation)"avx512fr" AVX-512 CD (Conflict Detection Instructions)"avx512cdr" AVX-512 ER (Expo nential and Reciprocal Instructions)"avx512err" AVX-512 PF (Prefetch Instructions)"avx512pfr" AVX-512 BW (Byte and Word Instructions)"avx512bwr" AVX-512 DQ (Doubleword and Quadword)"avx512dqr" AVX-512 VL (Vector Length Extensions)"avx512vlr" AVX-512 IFMA (Integer Fused Multiply Add)"avx512ifmar" AVX-512 VBMI (Vector Byte Manipulation Instructions)"avx512vbmir" AVX-512 VPOPCNTDQ (Vector Population Count Doubleword and Quadword)"avx512vpopcntdqr" AVX-512 VBMI2 (Additional byte, word, dword and qword capabilities)"avx512vbmi2r" AVX-512 GFNI (Galois Field New Instruction)"gfnir" AVX-512 VAES (Vector AES instruction)"vaesr" AVX-512 VPCLMULQDQ (Vector PCLMULQDQ instructions)"vpclmulqdqr" AVX-512 VNNI (Vector Neural Network Instructions)"avx512vnnir" AVX-512 BITALG (Support for VPOPCNT\[B,W\] and VPSHUFBITQMB)"avx512bitalgr" AVX-512 BF16 (BFLOAT16 instructions)"avx512bf16r" AVX-512 P2INTERSECT"avx512vp2intersectr" AVX-512 FP16 (FLOAT16 instructions)"avx512fp16r" AVX-IFMA (Integer Fused Multiply Add)"avxifmar" AVX-NE-CONVERT (Exceptionless Convert)"avxneconvertr" AVX-VNNI (Vector Neural Network Instructions)"avxvnnir" AVX-VNNI_INT8 (VNNI with 16-bit Integers)"avxvnniint16r" AVX-VNNI_INT16 (VNNI with 8-bit integers)"avxvnniint8r" AMX (Advanced Matrix Extensions) - Tile load/store"amx_tiler" AMX-INT8 (Operations on 8-bit integers)"amx_int8r" AMX-BF16 (BFloat16 Operations)"amx_bf16r" AMX-FP16 (Float16 Operations)"amx_fp16r" AMX-COMPLEX (Complex number Operations)"amx_complexr" AMX-AVX512 (AVX512 operations extended to matrices)"amx_avx512r" AMX-FP8 (Float8 Operations)"amx_fp8r" AMX-MOVRS (Matrix MOVERS operations)"amx_movrsr" AMX-TF32 (TensorFloat32 Operations)"amx_tf32r" APX-F (Advanced Performance Extensions - Foundation)"apxfr" AVX10.1"avx10_1r" AVX10.2"avx10_2r" F16C (Conversions between IEEE-754 `binary16` and `binary32` formats)"f16cr" FMA (Fused Multiply Add)"r" BMI1 (Bit Manipulation Instructions 1)"bmi1r" BMI2 (Bit Manipulation Instructions 2)"bmi2r" ABM (Advanced Bit Manipulation) / LZCNT (Leading Zero Count)"lzcntr" TBM (Trailing Bit Manipulation)"tbmr" POPCNT (Population Count)"popcntr" FXSR (Floating-point context fast save and restore)"fxsrr" XSAVE (Save Processor Extended States)"xsaver" XSAVEOPT (Save Processor Extended States Optimized)"xsaveoptr" XSAVES (Save Processor Extended States Supervisor)"xsavesr" XSAVEC (Save Processor Extended States Compacted)"xsavecr" CMPXCH16B (16-byte compare-and-swap instruction)"r" Intel Key Locker"klr" Intel Key Locker Wide"wideklr" ADX, Intel ADX (Multi-Precision Add-Carry Instruction Extensions)"adxr" RTM, Intel (Restricted Transactional Memory)"rtmr" MOVBE (Move Data After Swapping Bytes)"movber" MOVRS (Move data with the read-shared hint)"movrsr" ERMSB, Enhanced REP MOVSB and STOSB"ermsbr" XOP: eXtended Operations (AMD)"xop_lastr" Each function performs run-time feature detection for a single"r" feature. This allow us to use stability attributes on a per feature"r" basis."r" PLEASE: do not use this, it is an implementation detail"r" subject to change."__is_feature_detected//! This module implements minimal run-time feature detection for x86.//! The features are detected using the `detect_features` function below.//! This function uses the CPUID instruction to read the feature flags from the//! CPU and encodes them in a `usize` where each bit position represents//! whether a feature is available (bit is set) or unavailable (bit is cleared).//! The enum `Feature` is used to map bit positions to feature names, and the//! the `__crate::detect::check_for!` macro is used to map string literals (e.g.,//! "avx") to these bit positions (e.g., `Feature::avx`).//! The run-time feature detection is performed by the//! `__crate::detect::check_for(Feature) -> bool` function. On its first call,//! this functions queries the CPU for the available features and stores them//! in a global `AtomicUsize` variable. The query is performed by just checking//! whether the feature bit in this global variable is set or cleared./// Tests the `bit` of `x`.//! Bit manipulation utilities./// Sets the `bit` of `x`.test_bitunset_bit/// Unset the `bit of `x`.CACHE_CAPACITY/// Maximum number of features that can be cached.Initializer/// This type is used to initialize the cache// The derived `Default` implementation will initialize the field to zero,// which is what we want./// Tests the `bit` of the cache./// Sets the `bit` of the cache./// Unsets the `bit` of the cache.// NOTE: the `debug_assert!` would catch that we do not add more Features than// the one fitting our cache.CACHE/// This global variable is a cache of the features supported by the CPU.// Note: the third slot is only used in x86// Another Slot can be added if needed without any change to `Initializer`/// Feature cache with capacity for `size_of::<usize>() * 8 - 1` features./// Note: 0 is used to represent an uninitialized cache, and (at least) the most/// significant bit is set on any cache which has been initialized./// Note: we use `Relaxed` atomic operations, because we are only interested in/// the effects of operations on a single memory location. That is, we only need/// "modification order", and not the full-blown "happens before".INITIALIZED_BIT/// Creates an uninitialized cache./// Is the `bit` in the cache set? Returns `None` if the cache has not been initialized./// Initializes the cache.do_initializedetect_and_initialize// We only have to detect features once, and it's fairly costly, so hint to LLVM// that it should assume that cache hits are more common than misses (which is// the point of caching). It's possibly unfortunate that this function needs to// reach across modules like this to call `os::detect_features`, but it produces// the best code out of several attempted variants.// The `Initializer` that the cache was initialized with is returned, so that// the caller can call `test()` on it without having to load the value from the// cache again./// Tests the `bit` of the storage. If the storage has not been initialized,/// initializes it with the result of `os::detect_features()`./// On its first invocation, it detects the CPU features and caches them in the/// `CACHE` global variable as an `AtomicU64`./// It uses the `Feature` variant to index into this variable as a bitset. If/// the bit is set, the feature is enabled, and otherwise it is disabled./// If the feature `std_detect_env_override` is enabled looks for the env/// variable `RUST_STD_DETECT_UNSTABLE` and uses its content to disable/// Features that would had been otherwise detected.//! Caches run-time feature detection so that it only needs to be computeddetect_featurecheck_cfg_feature// This module needs to be public because the `is_{arch}_feature_detected!`// macros expand calls to items within it in user crates."os/other.rs"check_for/// Performs run-time feature detection./// Returns an `Iterator<Item=(&'static str, bool)>` where/// `Item.0` is the feature name, and `Item.1` is a `bool` which/// is `true` if the feature is supported by the host and `false` otherwise.//! This module implements run-time feature detection.//! The `is_{arch}_feature_detected!("feature-name")` macros take the name of a//! feature as a string-literal, and return a boolean indicating whether the//! feature is enabled at run-time or not.//! These macros do two things://! * map the string-literal into an integer stored as a `Feature` enum,//! * call a `os::check_for(x: Feature)` function that returns `true` if the//! feature is enabled.//! The `Feature` enums are also implemented in the `arch/{target_arch}.rs`//! The `check_for` functions are, in general, Operating System dependent. Most//! architectures do not allow user-space programs to query the feature bits//! due to security concerns (x86 is the big exception). These functions are//! implemented in the `os/{target_os}.rs` modules./// Try to read the features from the system registers./// This will cause SIGILL if the current OS is not trapping the mrs instruction.parse_system_registersbits_shift//! Run-time feature detection for Aarch64 on any OS that emulates the mrs instruction.//! On FreeBSD >= 12.0, Linux >= 4.11 and other operating systems, it is possible to use//! privileged system registers from userspace to check CPU feature support.//! AArch64 system registers ID_AA64ISAR0_EL1, ID_AA64PFR0_EL1, ID_AA64ISAR1_EL1//! have bits dedicated to features like AdvSIMD, CRC32, AES, atomics (LSE), etc.//! Each part of the register indicates the level of support for a certain feature, e.g.//! when ID_AA64ISAR0_EL1\[7:4\] is >= 1, AES is supported; when it's >= 2, PMULL is supported.//! For proper support of [SoCs where different cores have different capabilities](https://medium.com/@jadr2ddude/a-big-little-problem-a-tale-of-big-little-gone-wrong-e7778ce744bb),//! the OS has to always report only the features supported by all cores, like [FreeBSD does](https://reviews.freebsd.org/D17137#393947).//! References://! - [Zircon implementation](https://fuchsia.googlesource.com/zircon/+/master/kernel/arch/arm64/feature.cpp)//! - [Linux documentation](https://www.kernel.org/doc/Documentation/arm64/cpu-feature-registers.txt)//! - [ARM documentation](https://developer.arm.com/documentation/ddi0601/2022-12/AArch64-Registers?lang=en)_sysctlbyname/// Try to read the features using sysctlbyname.//! Run-time feature detection for aarch64 on Darwin (macOS/iOS/tvOS/watchOS/visionOS).//! <https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics>//! Run-time feature detection for Aarch64 on FreeBSD.// Defined in machine/elf.h.// https://github.com/freebsd/freebsd-src/blob/deb63adf945d446ed91a9d84124c71f15ae571d1/sys/arm/include/elf.h/// Try to read the features from the auxiliary vector//! Run-time feature detection for ARM on FreeBSDhwcaphwcap2AuxVec/// Cache HWCAP bitfields of the ELF Auxiliary Vector./// If an entry cannot be read all the bits in the bitfield are set to zero./// This should be interpreted as all the features being disabled./// ELF Auxiliary Vector/// The auxiliary vector is a memory region in a running ELF program's stack/// composed of (key: usize, value: usize) pairs./// The keys used in the aux vector are platform dependent. For FreeBSD, they are/// defined in [sys/elf_common.h][elf_common_h]. The hardware capabilities of a given/// CPU can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys./// Note that run-time feature detection is not invoked for features that can/// be detected at compile-time./// [elf_common.h]: https://svnweb.freebsd.org/base/release/12.0.0/sys/sys/elf_common.h?revision=341707archauxv/// Tries to read the `key` from the auxiliary vector.//! Parses ELF auxiliary vectors.//! Run-time feature detection on FreeBSD//! Run-time feature detection for PowerPC on FreeBSD.auxv_from_filebaseline_hwcapsAtHwcap// The baseline hwcaps used in the (artificial) auxv test files.linux_empty_hwcap2_aarch64linux_no_hwcap2_aarch64linux_hwcap2_aarch64/// Try to read the features from the auxiliary vector.// AT_HWCAPasimd// evtstrm: No LLVM support.fphpasimdhpasimdrdm// cpuid: No LLVM support.jscvtfcmalrcpcdcpopasimddpsvefhmdituscatilrcpcflagmssbspacapacgdcpodp// AT_HWCAP2sve2sveaessvepmullsvebitpermsvesha3svesm4flagm2frintsvef32mm// svei8mm: See i8mm feature.svef64mmi8mm// svebf16: See bf16 feature.// dgh: No LLVM support.btimteecvsme// afp: bool,// rpres: bool,// mte3: bool,smei16i64smef64f64smefa64// smei8i32: bool,// smef16f32: bool,// smeb16f32: bool,// smef32f32: bool,wfxtcssc// ebf16: bool,// sveebf16: bool,sve2p1// rprfm: bool,sme2sme2p1smeb16b16// smei16i32: bool,// smebi32i32: bool,smef16f16mopshbcsveb16b16lrcpc3lse128fpmrfaminmaxf8cvtf8fmaf8dp4f8dp2f8e4m3f8e5m2smelutv2smef8f16smef8f32smesf8fmasmesf8dp4smesf8dp2// pauthlr: bool,/// These values are part of the platform-specific [asm/hwcap.h][hwcap] ./// The names match those used for cpuinfo./// [hwcap]: https://github.com/torvalds/linux/blob/master/arch/arm64/include/uapi/asm/hwcap.h/// Reads AtHwcap from the auxiliary vector./// Initializes the cache from the feature -bits./// The feature dependencies here come directly from LLVM's feature definitions:/// https://github.com/llvm/llvm-project/blob/main/llvm/lib/Target/AArch64/AArch64.td//! Run-time feature detection for Aarch64 on Linux.//! Run-time feature detection for ARM on Linux.auxv_crate// FIXME: on mips/mips64 getauxval returns 0, and /proc/self/auxv// does not always contain the AT_HWCAP key under qemu.auxv_dumpauxv_dump_procfsauxv_crate_procfs/// Key to access the CPU Hardware capabilities bitfield./// Key to access the CPU Hardware capabilities 2 bitfield./// The keys used in the aux vector are platform dependent. For Linux, they are/// defined in [linux/auxvec.h][auxvec_h]. The hardware capabilities of a given/// There is no perfect way of reading the auxiliary vector./// - If the `std_detect_dlsym_getauxval` cargo feature is enabled, this will use///   `getauxval` if its linked to the binary, and otherwise proceed to a fallback implementation.///   When `std_detect_dlsym_getauxval` is disabled, this will assume that `getauxval` is///   linked to the binary - if that is not the case the behavior is undefined./// - Otherwise, if the `std_detect_file_io` cargo feature is enabled, it will///   try to read `/proc/self/auxv`./// - If that fails, this function returns an error.///  Note: The `std_detect_dlsym_getauxval` cargo feature is ignored on/// `*-linux-{gnu,musl,ohos}*` and `*-android*` targets because we can safely assume `getauxval`/// is linked to the binary./// - `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))///   have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html)./// - `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))///   use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)/// - `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)/// - `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))///   have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49)./// For more information about when `getauxval` is available check the great/// [`auxv` crate documentation][auxv_docs]./// [auxvec_h]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/auxvec.h/// [auxv_docs]: https://docs.rs/auxv/0.3.3/auxv//// Tries to read the `key` from the auxiliary vector by calling the/// `getauxval` function. If the function is not linked, this function return `Err`./// Tries to read the auxiliary vector from the `file`. If this fails, this/// function returns `Err`.auxv_from_file_bytes/// Read auxiliary vector from a slice of bytes.auxv_from_buf/// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this//! Run-time feature detection for LoongArch on Linux.//! Run-time feature detection for MIPS on Linux.//! Run-time feature detection on Linux//! Run-time feature detection for PowerPC on Linux.imply_features// See <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/prctl.h?h=v6.16>// for runtime status query constants.// key is overwritten to -1 if not supported by riscv_hwprobe syscall.RISCV_HWPROBE_KEY_BASE_BEHAVIORRISCV_HWPROBE_BASE_BEHAVIOR_IMARISCV_HWPROBE_KEY_IMA_EXT_0RISCV_HWPROBE_IMA_FDRISCV_HWPROBE_IMA_CRISCV_HWPROBE_IMA_VRISCV_HWPROBE_EXT_ZBARISCV_HWPROBE_EXT_ZBBRISCV_HWPROBE_EXT_ZBSRISCV_HWPROBE_EXT_ZICBOZRISCV_HWPROBE_EXT_ZBCRISCV_HWPROBE_EXT_ZBKBRISCV_HWPROBE_EXT_ZBKCRISCV_HWPROBE_EXT_ZBKXRISCV_HWPROBE_EXT_ZKNDRISCV_HWPROBE_EXT_ZKNERISCV_HWPROBE_EXT_ZKNHRISCV_HWPROBE_EXT_ZKSEDRISCV_HWPROBE_EXT_ZKSHRISCV_HWPROBE_EXT_ZKTRISCV_HWPROBE_EXT_ZVBBRISCV_HWPROBE_EXT_ZVBCRISCV_HWPROBE_EXT_ZVKBRISCV_HWPROBE_EXT_ZVKGRISCV_HWPROBE_EXT_ZVKNEDRISCV_HWPROBE_EXT_ZVKNHARISCV_HWPROBE_EXT_ZVKNHBRISCV_HWPROBE_EXT_ZVKSEDRISCV_HWPROBE_EXT_ZVKSHRISCV_HWPROBE_EXT_ZVKTRISCV_HWPROBE_EXT_ZFHRISCV_HWPROBE_EXT_ZFHMINRISCV_HWPROBE_EXT_ZIHINTNTLRISCV_HWPROBE_EXT_ZVFHRISCV_HWPROBE_EXT_ZVFHMINRISCV_HWPROBE_EXT_ZFARISCV_HWPROBE_EXT_ZTSORISCV_HWPROBE_EXT_ZACASRISCV_HWPROBE_EXT_ZICONDRISCV_HWPROBE_EXT_ZIHINTPAUSERISCV_HWPROBE_EXT_ZVE32XRISCV_HWPROBE_EXT_ZVE32FRISCV_HWPROBE_EXT_ZVE64XRISCV_HWPROBE_EXT_ZVE64FRISCV_HWPROBE_EXT_ZVE64DRISCV_HWPROBE_EXT_ZIMOPRISCV_HWPROBE_EXT_ZCARISCV_HWPROBE_EXT_ZCBRISCV_HWPROBE_EXT_ZCDRISCV_HWPROBE_EXT_ZCFRISCV_HWPROBE_EXT_ZCMOPRISCV_HWPROBE_EXT_ZAWRSRISCV_HWPROBE_EXT_ZICNTR// Excluded because it only reports the existence of `prctl`-based pointer masking control.// const RISCV_HWPROBE_EXT_SUPM: u64 = 1 << 49;RISCV_HWPROBE_EXT_ZIHPMRISCV_HWPROBE_EXT_ZFBFMINRISCV_HWPROBE_EXT_ZVFBFMINRISCV_HWPROBE_EXT_ZVFBFWMARISCV_HWPROBE_EXT_ZICBOMRISCV_HWPROBE_EXT_ZAAMORISCV_HWPROBE_EXT_ZALRSCRISCV_HWPROBE_EXT_ZABHARISCV_HWPROBE_KEY_CPUPERF_0RISCV_HWPROBE_MISALIGNED_FASTRISCV_HWPROBE_MISALIGNED_MASKRISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERFRISCV_HWPROBE_MISALIGNED_SCALAR_FASTRISCV_HWPROBE_KEY_MISALIGNED_VECTOR_PERFRISCV_HWPROBE_MISALIGNED_VECTOR_FAST_riscv_hwprobe/// Read list of supported features from (1) the auxiliary vector/// and (2) the results of `riscv_hwprobe` and `prctl` system calls.//! Run-time feature detection for RISC-V on Linux.//! On RISC-V, detection using auxv only supports single-letter extensions.//! So, we use riscv_hwprobe that supports multi-letter extensions if available.//! <https://www.kernel.org/doc/html/latest/arch/riscv/hwprobe.html>// See <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/uapi/asm/hwprobe.h?h=v6.16>// for riscv_hwprobe struct and hardware probing constants.esan3zarchstflemsaldispeimmdfphpageetf3ehhigh_gprstevxrsvxrs_bcdvxrs_extvxrs_ext2vxrs_pdedfltvxrs_pde2nnpapci_miosieExtendedFacilityList/// Initializes the cache from the feature bits./// These values are part of the platform-specific [asm/elf.h][kernel], and are a selection of the/// fields found in the [Facility Indications]./// [Facility Indications]: https://www.ibm.com/support/pages/sites/default/files/2021-05/SA22-7871-10.pdf#page=63/// [kernel]: https://github.com/torvalds/linux/blob/b62cef9a5c673f1b8083159f5dc03c1c5daced2f/arch/s390/include/asm/elf.h#L129//! Run-time feature detection for s390x on Linux.CPU_ID_AA64ISAR0// Defined in machine/cpu.h.// https://github.com/openbsd/src/blob/72ccc03bd11da614f31f7ff76e3f6fce99bc1c79/sys/arch/arm64/include/cpu.h#L25-L40CPU_ID_AA64ISAR1CPU_ID_AA64MMFR2CPU_ID_AA64PFR0//! Run-time feature detection for Aarch64 on OpenBSD.//! OpenBSD doesn't trap the mrs instruction, but exposes the system registers through sysctl.//! https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8//! https://github.com/golang/go/commit/cd54ef1f61945459486e9eea2f016d99ef1da925/// The keys used in the aux vector are platform dependent. For OpenBSD, they are/// defined in [machine/elf.h][elfh]. The hardware capabilities of a given CPU/// can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys./// [elf.h]: https://github.com/openbsd/src/blob/master/sys/arch/arm64/include/elf.h/// [elf.h]: https://github.com/openbsd/src/blob/master/sys/arch/powerpc64/include/elf.h//! Run-time feature detection on OpenBSD//! Run-time feature detection for PowerPC on OpenBSD.//! Other operating systemssimple_directsimple_indirectcomplex_zcdgroup_simple_forwardgroup_simple_backwardgroup_complex_convergence/// Imply features by the given set of enabled features./// Note that it does not perform any consistency checks including existence of/// conflicting extensions and/or complicated requirements.  Eliminating such/// inconsistencies is the responsibility of the feature detection logic and/// its provider(s)."riscv/tests.rs"//! Run-time feature detection utility for RISC-V.//! On RISC-V, full feature detection needs a help of one or more//! feature detection mechanisms (usually provided by the operating system).//! RISC-V architecture defines many extensions and some have dependency to others.//! More importantly, some of them cannot be enabled without resolving such//! dependencies due to limited set of features that such mechanisms provide.//! This module provides an OS-independent utility to process such relations//! between RISC-V extensions./// Try to read the features using IsProcessorFeaturePresent.//! Run-time feature detection for Aarch64 on Windows./// Run-time feature detection on x86 works by using the CPUID instruction./// The [CPUID Wikipedia page][wiki_cpuid] contains/// all the information about which flags to set to query which values, and in/// which registers these are reported./// The definitive references are:/// - [Intel 64 and IA-32 Architectures Software Developer's Manual Volume 2:///   Instruction Set Reference, A-Z][intel64_ref]./// - [AMD64 Architecture Programmer's Manual, Volume 3: General-Purpose and///   System Instructions][amd64_ref]./// [wiki_cpuid]: https://en.wikipedia.org/wiki/CPUID/// [intel64_ref]: http://www.intel.de/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf/// [amd64_ref]: http://support.amd.com/TechDocs/24594.pdf//! x86 run-time feature detection is OS independent.// rust-lang/rust#83888: removing `extern crate` gives an error that `vec_spare>//! Run-time feature detection for the Rust standard library.//! To detect whether a feature is enabled in the system running the binary//! use one of the appropriate macro for the target://! * `x86` and `x86_64`: [`is_x86_feature_detected`]//! * `arm`: [`is_arm_feature_detected`]//! * `aarch64`: [`is_aarch64_feature_detected`]//! * `riscv`: [`is_riscv_feature_detected`]//! * `mips`: [`is_mips_feature_detected`]//! * `mips64`: [`is_mips64_feature_detected`]//! * `powerpc`: [`is_powerpc_feature_detected`]//! * `powerpc64`: [`is_powerpc64_feature_detected`]//! * `loongarch`: [`is_loongarch_feature_detected`]//! * `s390x`: [`is_s390x_feature_detected`]arm_freebsdaarch64_windowsaarch64_bsdaarch64_darwinriscv_linuxpowerpc64_linux_or_bsdx86_deprecatedassert_instrinstrInvoc//! Implementation of the `#[assert_instr]` macro//! This macro is used when testing the `stdarch` crate and is used to generate//! test cases to assert that functions do indeed contain the instructions that//! we're expecting them to contain.//! The procedural macro here is relatively simple, it simply appends a//! `#[test]` function to the original token stream which asserts that the//! function itself contains the relevant instruction.// Just allow the warning: anyone soundly using the intrinsics has to enable// the target feature, and that will generate a warning for them.prefetcharm_sharedstdarch_test//! AArch64 intrinsics.//! The reference for NEON is [Arm's NEON Intrinsics Reference][arm_ref]. The//! [Arm's NEON Intrinsics Online Database][arm_dat] is also useful.//! [arm_ref]: http://infocenter.arm.com/help/topic/com.arm.doc.ihi0073a/IHI0073A_arm_neon_intrinsics_ref.pdf//! [arm_dat]: https://developer.arm.com/technologies/neon/intrinsics"unadjusted"irg_gmi_ldg_stg_addg_subp___arm_mte_create_random_tag/// Return a pointer containing a randomly generated logical address tag./// `src`: A pointer containing an address./// `mask`: A mask where each of the lower 16 bits specifies logical///         tags which must be excluded from consideration. Zero excludes no///         tags./// The returned pointer contains a copy of the `src` address, but with a/// randomly generated logical tag, excluding any specified by `mask`./// SAFETY: The pointer provided by this intrinsic will be invalid until the memory/// has been appropriately tagged with `__arm_mte_set_tag`. If using that intrinsic/// on the provided pointer is itself invalid, then it will be permanently invalid/// and Undefined Behavior to dereference it.__arm_mte_increment_tag/// Return a pointer with the logical address tag offset by a value./// `src`: A pointer containing an address and a logical tag./// `OFFSET`: A compile-time constant value in the range [0, 15]./// Adds offset to the logical address tag in `src`, wrapping if the result is/// outside of the valid 16 tags./// SAFETY: See `__arm_mte_create_random_tag`.__arm_mte_exclude_tag/// Add a logical tag to the set of excluded logical tags./// `excluded`: A mask where the lower 16 bits each specify currently-excluded///             logical tags./// Adds the logical tag stored in `src` to the set in `excluded`, and returns__arm_mte_set_tag/// Store an allocation tag for the 16-byte granule of memory./// `tag_address`: A pointer containing an address and a logical tag, which///                must be 16-byte aligned./// SAFETY: `tag_address` must be 16-byte aligned. The tag will apply to the/// entire 16-byte memory granule.__arm_mte_get_tag/// Load an allocation tag from memory, returning a new pointer with the/// corresponding logical tag./// `address`: A pointer containing an address from which allocation tag memory///            is read. This does not need to be 16-byte aligned.__arm_mte_ptrdiff/// Calculate the difference between the address parts of two pointers, ignoring/// the tags, and sign-extending the result.test_arm_mte_create_random_tag// FIXME: MSVC  `dumpbin` doesn't support MTEtest_arm_mte_increment_tagtest_arm_mte_exclude_tagtest_arm_mte_set_tagtest_arm_mte_get_tagtest_arm_mte_ptrdiff//! AArch64 Memory tagging intrinsics//! [ACLE documentation](https://arm-software.github.io/acle/main/acle.html#markdown-toc-mte-intrinsics)"CRC32-C single round checksum for quad words (64 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32cd)"__crc32cd"CRC32 single round checksum for quad words (64 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32d)"__crc32d"Floating-point JavaScript convert to signed fixed-point, rounding toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__jcvt)"__jcvt"Signed Absolute difference and Accumulate Long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_s8)"vabal_high_s8int16x8_tint8x16_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_s16)"vabal_high_s16int32x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_s32)"vabal_high_s32int64x2_t"Unsigned Absolute difference and Accumulate Long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_u8)"vabal_high_u8uint16x8_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_u16)"vabal_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_u32)"vabal_high_u32"Absolute difference between the arguments of Floating""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_f64)"vabd_f64float64x1_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_f64)"vabdq_f64"Floating-point absolute difference""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdd_f64)"vabdd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabds_f32)"vabds_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdh_f16)"vabdh_f16"Signed Absolute difference Long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_s16)"vabdl_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_s32)"vabdl_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_s8)"vabdl_high_s8"Unsigned Absolute difference Long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_u8)"vabdl_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_u16)"vabdl_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_u32)"vabdl_high_u32"Floating-point absolute value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_f64)"vabs_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_f64)"vabsq_f64"Absolute Value (wrapping).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s64)"vabs_s64int64x1_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s64)"vabsq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsd_s64)"vabsd_s64"Add""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddd_s64)"vaddd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddd_u64)"vaddd_u64"Signed Add Long across Vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_s16)"vaddlv_s16int16x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_s16)"vaddlvq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_s32)"vaddlvq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_s32)"vaddlv_s32int32x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_s8)"vaddlv_s8int8x8_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_s8)"vaddlvq_s8"Unsigned Add Long across Vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_u16)"vaddlv_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_u16)"vaddlvq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_u32)"vaddlvq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_u32)"vaddlv_u32uint32x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_u8)"vaddlv_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_u8)"vaddlvq_u8"Floating-point add across vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_f32)"vaddv_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_f32)"vaddvq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_f64)"vaddvq_f64"Add across vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_s32)"vaddv_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_s8)"vaddv_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s8)"vaddvq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_s16)"vaddv_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s16)"vaddvq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s32)"vaddvq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_u32)"vaddv_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_u8)"vaddv_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u8)"vaddvq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_u16)"vaddv_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u16)"vaddvq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u32)"vaddvq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s64)"vaddvq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u64)"vaddvq_u64"Multi-vector floating-point absolute maximum""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vamax_f32)"vamax_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vamaxq_f32)"vamaxq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vamaxq_f64)"vamaxq_f64"Multi-vector floating-point absolute minimum""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vamin_f32)"vamin_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaminq_f32)"vaminq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaminq_f64)"vaminq_f64"Bit clear and exclusive OR""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_s8)"vbcaxq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_s16)"vbcaxq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_s32)"vbcaxq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_s64)"vbcaxq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_u8)"vbcaxq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_u16)"vbcaxq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_u32)"vbcaxq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbcaxq_u64)"vbcaxq_u64"Floating-point complex add""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcadd_rot270_f16)"vcadd_rot270_f16float16x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaddq_rot270_f16)"vcaddq_rot270_f16float16x8_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcadd_rot270_f32)"vcadd_rot270_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaddq_rot270_f32)"vcaddq_rot270_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaddq_rot270_f64)"vcaddq_rot270_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcadd_rot90_f16)"vcadd_rot90_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaddq_rot90_f16)"vcaddq_rot90_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcadd_rot90_f32)"vcadd_rot90_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaddq_rot90_f32)"vcaddq_rot90_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaddq_rot90_f64)"vcaddq_rot90_f64"Floating-point absolute compare greater than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcage_f64)"vcage_f64uint64x1_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcageq_f64)"vcageq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaged_f64)"vcaged_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcages_f32)"vcages_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcageh_f16)"vcageh_f16"Floating-point absolute compare greater than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagt_f64)"vcagt_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagtq_f64)"vcagtq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagtd_f64)"vcagtd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagts_f32)"vcagts_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagth_f16)"vcagth_f16"Floating-point absolute compare less than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcale_f64)"vcale_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaleq_f64)"vcaleq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaled_f64)"vcaled_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcales_f32)"vcales_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaleh_f16)"vcaleh_f16"Floating-point absolute compare less than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalt_f64)"vcalt_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaltq_f64)"vcaltq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaltd_f64)"vcaltd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalts_f32)"vcalts_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalth_f16)"vcalth_f16"Floating-point compare equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_f64)"vceq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_f64)"vceqq_f64"Compare bitwise Equal (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s64)"vceq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s64)"vceqq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u64)"vceq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u64)"vceqq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_p64)"vceq_p64poly64x1_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_p64)"vceqq_p64poly64x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqd_f64)"vceqd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqs_f32)"vceqs_f32"Compare bitwise equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqd_s64)"vceqd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqd_u64)"vceqd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqh_f16)"vceqh_f16"Floating-point compare bitwise equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_f16)"vceqz_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_f16)"vceqzq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_f32)"vceqz_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_f32)"vceqzq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_f64)"vceqz_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_f64)"vceqzq_f64"Signed compare bitwise equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_s8)"vceqz_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_s8)"vceqzq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_s16)"vceqz_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_s16)"vceqzq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_s32)"vceqz_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_s32)"vceqzq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_s64)"vceqz_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_s64)"vceqzq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_p8)"vceqz_p8poly8x8_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_p8)"vceqzq_p8poly8x16_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_p64)"vceqz_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_p64)"vceqzq_p64"Unsigned compare bitwise equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_u8)"vceqz_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_u8)"vceqzq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_u16)"vceqz_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_u16)"vceqzq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_u32)"vceqz_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_u32)"vceqzq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqz_u64)"vceqz_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzq_u64)"vceqzq_u64"Compare bitwise equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzd_s64)"vceqzd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzd_u64)"vceqzd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzh_f16)"vceqzh_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzs_f32)"vceqzs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqzd_f64)"vceqzd_f64"Floating-point compare greater than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_f64)"vcge_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_f64)"vcgeq_f64"Compare signed greater than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s64)"vcge_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s64)"vcgeq_s64"Compare unsigned greater than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u64)"vcge_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u64)"vcgeq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcged_f64)"vcged_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcges_f32)"vcges_f32"Compare greater than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcged_s64)"vcged_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcged_u64)"vcged_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeh_f16)"vcgeh_f16"Floating-point compare greater than or equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_f32)"vcgez_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_f32)"vcgezq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_f64)"vcgez_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_f64)"vcgezq_f64"Compare signed greater than or equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_s8)"vcgez_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_s8)"vcgezq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_s16)"vcgez_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_s16)"vcgezq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_s32)"vcgez_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_s32)"vcgezq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_s64)"vcgez_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_s64)"vcgezq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezd_f64)"vcgezd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezs_f32)"vcgezs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezd_s64)"vcgezd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezh_f16)"vcgezh_f16"Floating-point compare greater than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_f64)"vcgt_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_f64)"vcgtq_f64"Compare signed greater than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s64)"vcgt_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s64)"vcgtq_s64"Compare unsigned greater than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u64)"vcgt_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u64)"vcgtq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtd_f64)"vcgtd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgts_f32)"vcgts_f32"Compare greater than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtd_s64)"vcgtd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtd_u64)"vcgtd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgth_f16)"vcgth_f16"Floating-point compare greater than zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_f32)"vcgtz_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_f32)"vcgtzq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_f64)"vcgtz_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_f64)"vcgtzq_f64"Compare signed greater than zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_s8)"vcgtz_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_s8)"vcgtzq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_s16)"vcgtz_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_s16)"vcgtzq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_s32)"vcgtz_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_s32)"vcgtzq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_s64)"vcgtz_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_s64)"vcgtzq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzd_f64)"vcgtzd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzs_f32)"vcgtzs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzd_s64)"vcgtzd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzh_f16)"vcgtzh_f16"Floating-point compare less than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_f64)"vcle_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_f64)"vcleq_f64"Compare signed less than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s64)"vcle_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s64)"vcleq_s64"Compare unsigned less than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u64)"vcle_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u64)"vcleq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcled_f64)"vcled_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcles_f32)"vcles_f32"Compare less than or equal""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcled_u64)"vcled_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcled_s64)"vcled_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleh_f16)"vcleh_f16"Floating-point compare less than or equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_f32)"vclez_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_f32)"vclezq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_f64)"vclez_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_f64)"vclezq_f64"Compare signed less than or equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_s8)"vclez_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_s8)"vclezq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_s16)"vclez_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_s16)"vclezq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_s32)"vclez_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_s32)"vclezq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_s64)"vclez_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_s64)"vclezq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezd_f64)"vclezd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezs_f32)"vclezs_f32"Compare less than or equal to zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezd_s64)"vclezd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezh_f16)"vclezh_f16"Floating-point compare less than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_f64)"vclt_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_f64)"vcltq_f64"Compare signed less than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s64)"vclt_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s64)"vcltq_s64"Compare unsigned less than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u64)"vclt_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u64)"vcltq_u64"Compare less than""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltd_u64)"vcltd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltd_s64)"vcltd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclth_f16)"vclth_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclts_f32)"vclts_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltd_f64)"vcltd_f64"Floating-point compare less than zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_f32)"vcltz_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_f32)"vcltzq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_f64)"vcltz_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_f64)"vcltzq_f64"Compare signed less than zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_s8)"vcltz_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_s8)"vcltzq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_s16)"vcltz_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_s16)"vcltzq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_s32)"vcltz_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_s32)"vcltzq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_s64)"vcltz_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_s64)"vcltzq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzd_f64)"vcltzd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzs_f32)"vcltzs_f32"Compare less than zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzd_s64)"vcltzd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzh_f16)"vcltzh_f16"Floating-point complex multiply accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_f16)"vcmla_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_f16)"vcmlaq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_f32)"vcmla_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_f32)"vcmlaq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_f64)"vcmlaq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_lane_f16)"rustc_legacy_const_genericsLANEvcmla_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_lane_f16)"vcmlaq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_lane_f32)"vcmla_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_lane_f32)"vcmlaq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_laneq_f16)"vcmla_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_laneq_f16)"vcmlaq_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_laneq_f32)"vcmla_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_laneq_f32)"vcmlaq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot180_f16)"vcmla_rot180_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_f16)"vcmlaq_rot180_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot180_f32)"vcmla_rot180_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_f32)"vcmlaq_rot180_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_f64)"vcmlaq_rot180_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot180_lane_f16)"vcmla_rot180_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_lane_f16)"vcmlaq_rot180_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot180_lane_f32)"vcmla_rot180_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_lane_f32)"vcmlaq_rot180_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot180_laneq_f16)"vcmla_rot180_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_laneq_f16)"vcmlaq_rot180_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot180_laneq_f32)"vcmla_rot180_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot180_laneq_f32)"vcmlaq_rot180_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot270_f16)"vcmla_rot270_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_f16)"vcmlaq_rot270_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot270_f32)"vcmla_rot270_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_f32)"vcmlaq_rot270_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_f64)"vcmlaq_rot270_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot270_lane_f16)"vcmla_rot270_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_lane_f16)"vcmlaq_rot270_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot270_lane_f32)"vcmla_rot270_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_lane_f32)"vcmlaq_rot270_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot270_laneq_f16)"vcmla_rot270_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_laneq_f16)"vcmlaq_rot270_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot270_laneq_f32)"vcmla_rot270_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot270_laneq_f32)"vcmlaq_rot270_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot90_f16)"vcmla_rot90_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_f16)"vcmlaq_rot90_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot90_f32)"vcmla_rot90_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_f32)"vcmlaq_rot90_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_f64)"vcmlaq_rot90_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot90_lane_f16)"vcmla_rot90_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_lane_f16)"vcmlaq_rot90_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot90_lane_f32)"vcmla_rot90_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_lane_f32)"vcmlaq_rot90_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot90_laneq_f16)"vcmla_rot90_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_laneq_f16)"vcmlaq_rot90_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmla_rot90_laneq_f32)"vcmla_rot90_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcmlaq_rot90_laneq_f32)"vcmlaq_rot90_laneq_f32"Insert vector element from another vector element""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_f32)"LANE1LANE2vcopy_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_s8)"vcopy_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_s16)"vcopy_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_s32)"vcopy_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_u8)"vcopy_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_u16)"vcopy_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_u32)"vcopy_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_p8)"vcopy_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_p16)"vcopy_lane_p16poly16x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_f32)"vcopy_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_s8)"vcopy_laneq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_s16)"vcopy_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_s32)"vcopy_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_u8)"vcopy_laneq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_u16)"vcopy_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_u32)"vcopy_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_p8)"vcopy_laneq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_p16)"vcopy_laneq_p16poly16x8_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_f32)"vcopyq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_f64)"vcopyq_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s64)"vcopyq_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u64)"vcopyq_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_p64)"vcopyq_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s8)"vcopyq_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s16)"vcopyq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s32)"vcopyq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u8)"vcopyq_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u16)"vcopyq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u32)"vcopyq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_p8)"vcopyq_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_p16)"vcopyq_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_f32)"vcopyq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_f64)"vcopyq_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s8)"vcopyq_laneq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s16)"vcopyq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s32)"vcopyq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s64)"vcopyq_laneq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u8)"vcopyq_laneq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u16)"vcopyq_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u32)"vcopyq_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u64)"vcopyq_laneq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_p8)"vcopyq_laneq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_p16)"vcopyq_laneq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_p64)"vcopyq_laneq_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_f64)"vcreate_f64"Floating-point convert""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_f64)"vcvt_f32_f64"Floating-point convert to higher precision long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f64_f32)"vcvt_f64_f32"Fixed-point convert to floating-point""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f64_s64)"vcvt_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f64_s64)"vcvtq_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f64_u64)"vcvt_f64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f64_u64)"vcvtq_f64_u64"Floating-point convert to lower precision""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_high_f16_f32)"vcvt_high_f16_f32"Floating-point convert to higher precision""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_high_f32_f16)"vcvt_high_f32_f16"Floating-point convert to lower precision narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_high_f32_f64)"vcvt_high_f32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_high_f64_f32)"vcvt_high_f64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_f64_s64)"vcvt_n_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_f64_s64)"vcvtq_n_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_f64_u64)"vcvt_n_f64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_f64_u64)"vcvtq_n_f64_u64"Floating-point convert to fixed-point, rounding toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_s64_f64)"vcvt_n_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_s64_f64)"vcvtq_n_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_u64_f64)"vcvt_n_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_u64_f64)"vcvtq_n_u64_f64"Floating-point convert to signed fixed-point, rounding toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_s64_f64)"vcvt_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_s64_f64)"vcvtq_s64_f64"Floating-point convert to unsigned fixed-point, rounding toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_u64_f64)"vcvt_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_u64_f64)"vcvtq_u64_f64"Floating-point convert to signed integer, rounding to nearest with ties to away""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_s16_f16)"vcvta_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_s16_f16)"vcvtaq_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_s32_f32)"vcvta_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_s32_f32)"vcvtaq_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_s64_f64)"vcvta_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_s64_f64)"vcvtaq_s64_f64"Floating-point convert to unsigned integer, rounding to nearest with ties to away""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_u16_f16)"vcvta_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_u16_f16)"vcvtaq_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_u32_f32)"vcvta_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_u32_f32)"vcvtaq_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_u64_f64)"vcvta_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_u64_f64)"vcvtaq_u64_f64"Floating-point convert to integer, rounding to nearest with ties to away""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtah_s16_f16)"vcvtah_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtah_s32_f16)"vcvtah_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtah_s64_f16)"vcvtah_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtah_u16_f16)"vcvtah_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtah_u32_f16)"vcvtah_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtah_u64_f16)"vcvtah_u64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtas_s32_f32)"vcvtas_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtad_s64_f64)"vcvtad_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtas_u32_f32)"vcvtas_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtad_u64_f64)"vcvtad_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_f64_s64)"vcvtd_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_f32_s32)"vcvts_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_f16_s16)"vcvth_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_f16_s32)"vcvth_f16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_f16_s64)"vcvth_f16_s64"Unsigned fixed-point convert to floating-point""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_f16_u16)"vcvth_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_f16_u32)"vcvth_f16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_f16_u64)"vcvth_f16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_f16_s16)"vcvth_n_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_f16_s32)"vcvth_n_f16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_f16_s64)"vcvth_n_f16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_f16_u16)"vcvth_n_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_f16_u32)"vcvth_n_f16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_f16_u64)"vcvth_n_f16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_s16_f16)"vcvth_n_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_s32_f16)"vcvth_n_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_s64_f16)"vcvth_n_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_u16_f16)"vcvth_n_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_u32_f16)"vcvth_n_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_n_u64_f16)"vcvth_n_u64_f16"Floating-point convert to signed fixed-point""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_s16_f16)"vcvth_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_s32_f16)"vcvth_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_s64_f16)"vcvth_s64_f16"Floating-point convert to unsigned fixed-point""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_u16_f16)"vcvth_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_u32_f16)"vcvth_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvth_u64_f16)"vcvth_u64_f16"Floating-point convert to signed integer, rounding toward minus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_s16_f16)"vcvtm_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_s16_f16)"vcvtmq_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_s32_f32)"vcvtm_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_s32_f32)"vcvtmq_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_s64_f64)"vcvtm_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_s64_f64)"vcvtmq_s64_f64"Floating-point convert to unsigned integer, rounding toward minus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_u16_f16)"vcvtm_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_u16_f16)"vcvtmq_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_u32_f32)"vcvtm_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_u32_f32)"vcvtmq_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_u64_f64)"vcvtm_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_u64_f64)"vcvtmq_u64_f64"Floating-point convert to integer, rounding towards minus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmh_s16_f16)"vcvtmh_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmh_s32_f16)"vcvtmh_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmh_s64_f16)"vcvtmh_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmh_u16_f16)"vcvtmh_u16_f16"Floating-point convert to unsigned integer, rounding towards minus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmh_u32_f16)"vcvtmh_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmh_u64_f16)"vcvtmh_u64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtms_s32_f32)"vcvtms_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmd_s64_f64)"vcvtmd_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtms_u32_f32)"vcvtms_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmd_u64_f64)"vcvtmd_u64_f64"Floating-point convert to signed integer, rounding to nearest with ties to even""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_s16_f16)"vcvtn_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_s16_f16)"vcvtnq_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_s32_f32)"vcvtn_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_s32_f32)"vcvtnq_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_s64_f64)"vcvtn_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_s64_f64)"vcvtnq_s64_f64"Floating-point convert to unsigned integer, rounding to nearest with ties to even""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_u16_f16)"vcvtn_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_u16_f16)"vcvtnq_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_u32_f32)"vcvtn_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_u32_f32)"vcvtnq_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_u64_f64)"vcvtn_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_u64_f64)"vcvtnq_u64_f64"Floating-point convert to integer, rounding to nearest with ties to even""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnh_s16_f16)"vcvtnh_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnh_s32_f16)"vcvtnh_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnh_s64_f16)"vcvtnh_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnh_u16_f16)"vcvtnh_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnh_u32_f16)"vcvtnh_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnh_u64_f16)"vcvtnh_u64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtns_s32_f32)"vcvtns_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnd_s64_f64)"vcvtnd_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtns_u32_f32)"vcvtns_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnd_u64_f64)"vcvtnd_u64_f64"Floating-point convert to signed integer, rounding to plus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_s16_f16)"vcvtp_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_s16_f16)"vcvtpq_s16_f16"Floating-point convert to signed integer, rounding toward plus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_s32_f32)"vcvtp_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_s32_f32)"vcvtpq_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_s64_f64)"vcvtp_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_s64_f64)"vcvtpq_s64_f64"Floating-point convert to unsigned integer, rounding to plus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_u16_f16)"vcvtp_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_u16_f16)"vcvtpq_u16_f16"Floating-point convert to unsigned integer, rounding toward plus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_u32_f32)"vcvtp_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_u32_f32)"vcvtpq_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_u64_f64)"vcvtp_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_u64_f64)"vcvtpq_u64_f64"Floating-point convert to integer, rounding to plus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtph_s16_f16)"vcvtph_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtph_s32_f16)"vcvtph_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtph_s64_f16)"vcvtph_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtph_u16_f16)"vcvtph_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtph_u32_f16)"vcvtph_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtph_u64_f16)"vcvtph_u64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtps_s32_f32)"vcvtps_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpd_s64_f64)"vcvtpd_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtps_u32_f32)"vcvtps_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpd_u64_f64)"vcvtpd_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_f32_u32)"vcvts_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_f64_u64)"vcvtd_f64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_n_f32_s32)"vcvts_n_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_n_f64_s64)"vcvtd_n_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_n_f32_u32)"vcvts_n_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_n_f64_u64)"vcvtd_n_f64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_n_s32_f32)"vcvts_n_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_n_s64_f64)"vcvtd_n_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_n_u32_f32)"vcvts_n_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_n_u64_f64)"vcvtd_n_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_s32_f32)"vcvts_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_s64_f64)"vcvtd_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_u32_f32)"vcvts_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtd_u64_f64)"vcvtd_u64_f64"Floating-point convert to lower precision narrow, rounding to odd""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtx_f32_f64)"vcvtx_f32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtx_high_f32_f64)"vcvtx_high_f32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtxd_f32_f64)"vcvtxd_f32_f64"Divide""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdiv_f16)"vdiv_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivq_f16)"vdivq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdiv_f32)"vdiv_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivq_f32)"vdivq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdiv_f64)"vdiv_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivq_f64)"vdivq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivh_f16)"vdivh_f16"Dot product arithmetic (indexed)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdot_laneq_s32)"vdot_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdotq_laneq_s32)"vdotq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdot_laneq_u32)"vdot_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdotq_laneq_u32)"vdotq_laneq_u32"Set all vector lanes to the same value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_f64)"vdup_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_p64)"vdup_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_f64)"vdup_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_p64)"vdup_laneq_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupb_lane_s8)"vdupb_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_laneq_s16)"vduph_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupb_lane_u8)"vdupb_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_laneq_u16)"vduph_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupb_lane_p8)"vdupb_lane_p8p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_laneq_p16)"vduph_laneq_p16p16"Extract an element from a vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupb_laneq_s8)"vdupb_laneq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupb_laneq_u8)"vdupb_laneq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupb_laneq_p8)"vdupb_laneq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupd_lane_f64)"vdupd_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupd_lane_s64)"vdupd_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupd_lane_u64)"vdupd_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_lane_f16)"vduph_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_laneq_f16)"vduph_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_f64)"vdupq_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_p64)"vdupq_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_f64)"vdupq_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_p64)"vdupq_laneq_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdups_lane_f32)"vdups_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupd_laneq_f64)"vdupd_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdups_lane_s32)"vdups_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupd_laneq_s64)"vdupd_laneq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdups_lane_u32)"vdups_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupd_laneq_u64)"vdupd_laneq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdups_laneq_f32)"vdups_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_lane_s16)"vduph_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdups_laneq_s32)"vdups_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_lane_u16)"vduph_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdups_laneq_u32)"vdups_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vduph_lane_p16)"vduph_lane_p16"Three-way exclusive OR""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_s8)"veor3q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_s16)"veor3q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_s32)"veor3q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_s64)"veor3q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_u8)"veor3q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_u16)"veor3q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_u32)"veor3q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor3q_u64)"veor3q_u64"Extract vector from pair of vectors""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_f64)"vextq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_p64)"vextq_p64"Floating-point fused Multiply-Add to accumulator(vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_f64)"vfma_f64"Floating-point fused multiply-add to accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_lane_f16)"vfma_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_laneq_f16)"vfma_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_lane_f16)"vfmaq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_laneq_f16)"vfmaq_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_lane_f32)"vfma_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_laneq_f32)"vfma_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_lane_f32)"vfmaq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_laneq_f32)"vfmaq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_laneq_f64)"vfmaq_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_lane_f64)"vfma_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_laneq_f64)"vfma_laneq_f64"Floating-point fused Multiply-Subtract from accumulator.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_n_f16)"vfma_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_n_f16)"vfmaq_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_n_f64)"vfma_n_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmad_lane_f64)"vfmad_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmah_f16)"vfmah_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmah_lane_f16)"vfmah_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmah_laneq_f16)"vfmah_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_f64)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_lane_f64)"vfmaq_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_n_f64)"vfmaq_n_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmas_lane_f32)"vfmas_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmas_laneq_f32)"vfmas_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmad_laneq_f64)"vfmad_laneq_f64"Floating-point fused Multiply-Add Long to accumulator (vector).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_high_f16)"vfmlal_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlalq_high_f16)"vfmlalq_high_f16"Floating-point fused Multiply-Add Long to accumulator (by element).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_lane_high_f16)"vfmlal_lane_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_laneq_high_f16)"vfmlal_laneq_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlalq_lane_high_f16)"vfmlalq_lane_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlalq_laneq_high_f16)"vfmlalq_laneq_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_lane_low_f16)"vfmlal_lane_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_laneq_low_f16)"vfmlal_laneq_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlalq_lane_low_f16)"vfmlalq_lane_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlalq_laneq_low_f16)"vfmlalq_laneq_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_low_f16)"vfmlal_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlalq_low_f16)"vfmlalq_low_f16"Floating-point fused Multiply-Subtract Long from accumulator (vector).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlsl_high_f16)"vfmlsl_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlslq_high_f16)"vfmlslq_high_f16"Floating-point fused Multiply-Subtract Long from accumulator (by element).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlsl_lane_high_f16)"vfmlsl_lane_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlsl_laneq_high_f16)"vfmlsl_laneq_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlslq_lane_high_f16)"vfmlslq_lane_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlslq_laneq_high_f16)"vfmlslq_laneq_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlsl_lane_low_f16)"vfmlsl_lane_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlsl_laneq_low_f16)"vfmlsl_laneq_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlslq_lane_low_f16)"vfmlslq_lane_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlslq_laneq_low_f16)"vfmlslq_laneq_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlsl_low_f16)"vfmlsl_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlslq_low_f16)"vfmlslq_low_f16"Floating-point fused multiply-subtract from accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_f64)"vfms_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_lane_f16)"vfms_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_laneq_f16)"vfms_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_lane_f16)"vfmsq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_laneq_f16)"vfmsq_laneq_f16"Floating-point fused multiply-subtract to accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_lane_f32)"vfms_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_laneq_f32)"vfms_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_lane_f32)"vfmsq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_laneq_f32)"vfmsq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_laneq_f64)"vfmsq_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_lane_f64)"vfms_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_laneq_f64)"vfms_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_n_f16)"vfms_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_n_f16)"vfmsq_n_f16"Floating-point fused Multiply-subtract to accumulator(vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_n_f64)"vfms_n_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsh_f16)"vfmsh_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsh_lane_f16)"vfmsh_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsh_laneq_f16)"vfmsh_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_f64)"vfmsq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_lane_f64)"vfmsq_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_n_f64)"vfmsq_n_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmss_lane_f32)"vfmss_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmss_laneq_f32)"vfmss_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsd_lane_f64)"vfmsd_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsd_laneq_f64)"vfmsd_laneq_f64"Load multiple single-element structures to one, two, three, or four registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f16)""## Safety""  * Neon instrinsic unsafe"vld1_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f16)"vld1q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f32)"vld1_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f64)"vld1_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f64)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s8)"vld1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s8)"vld1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s16)"vld1_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s16)"vld1q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s32)"vld1_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s32)"vld1q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s64)"vld1_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s64)"vld1q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u8)"vld1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u8)"vld1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u16)"vld1_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u16)"vld1q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u32)"vld1_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u32)"vld1q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u64)"vld1_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u64)"vld1q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p8)"vld1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p8)"vld1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p16)"vld1_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p16)"vld1q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p64)"vld1_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p64)"vld1q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f64_x2)"vld1_f64_x2float64x1x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f64_x3)"vld1_f64_x3float64x1x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f64_x4)"vld1_f64_x4float64x1x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f64_x2)"vld1q_f64_x2float64x2x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f64_x3)"vld1q_f64_x3float64x2x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f64_x4)"vld1q_f64_x4float64x2x4_t"Load single 2-element structure and replicate to all lanes of two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_f64)"vld2_dup_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_f64)"vld2q_dup_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_s64)"vld2q_dup_s64int64x2x2_t"Load multiple 2-element structures to two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_f64)"vld2_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_f64)"vld2_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_s64)"vld2_lane_s64int64x1x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_p64)"vld2_lane_p64poly64x1x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_u64)"vld2_lane_u64uint64x1x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_p64)"vld2q_dup_p64poly64x2x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_u64)"vld2q_dup_u64uint64x2x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_f64)"vld2q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_s64)"vld2q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_f64)"vld2q_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_s8)"vld2q_lane_s8int8x16x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_s64)"vld2q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_p64)"vld2q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_u8)"vld2q_lane_u8uint8x16x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_u64)"vld2q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_p8)"vld2q_lane_p8poly8x16x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_p64)"vld2q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_u64)"vld2q_u64"Load single 3-element structure and replicate to all lanes of three registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_f64)"vld3_dup_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_f64)"vld3q_dup_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_s64)"vld3q_dup_s64int64x2x3_t"Load multiple 3-element structures to three registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_f64)"vld3_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_f64)"vld3_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_p64)"vld3_lane_p64poly64x1x3_t"Load multiple 3-element structures to two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_s64)"vld3_lane_s64int64x1x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_u64)"vld3_lane_u64uint64x1x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_p64)"vld3q_dup_p64poly64x2x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_u64)"vld3q_dup_u64uint64x2x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_f64)"vld3q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_s64)"vld3q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_f64)"vld3q_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_p64)"vld3q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_s8)"vld3q_lane_s8int8x16x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_s64)"vld3q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_u8)"vld3q_lane_u8uint8x16x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_u64)"vld3q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_p8)"vld3q_lane_p8poly8x16x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_p64)"vld3q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_u64)"vld3q_u64"Load single 4-element structure and replicate to all lanes of four registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_f64)"vld4_dup_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_f64)"vld4q_dup_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_s64)"vld4q_dup_s64int64x2x4_t"Load multiple 4-element structures to four registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_f64)"vld4_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_f64)"vld4_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_s64)"vld4_lane_s64int64x1x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_p64)"vld4_lane_p64poly64x1x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_u64)"vld4_lane_u64uint64x1x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_p64)"vld4q_dup_p64poly64x2x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_u64)"vld4q_dup_u64uint64x2x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_f64)"vld4q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_s64)"vld4q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_f64)"vld4q_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_s8)"vld4q_lane_s8int8x16x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_s64)"vld4q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_p64)"vld4q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_u8)"vld4q_lane_u8uint8x16x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_u64)"vld4q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_p8)"vld4q_lane_p8poly8x16x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_p64)"vld4q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_u64)"vld4q_u64"Lookup table read with 2-bit indices""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2_lane_s8)"vluti2_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2q_lane_s8)"vluti2q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2_lane_s16)"vluti2_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2q_lane_s16)"vluti2q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2_lane_u8)"vluti2_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2q_lane_u8)"vluti2q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2_lane_u16)"vluti2_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2q_lane_u16)"vluti2q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2_lane_p8)"vluti2_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2q_lane_p8)"vluti2q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2_lane_p16)"vluti2_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti2q_lane_p16)"vluti2q_lane_p16"Lookup table read with 4-bit indices""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_f16_x2)"vluti4q_lane_f16_x2float16x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_u16_x2)"vluti4q_lane_u16_x2uint16x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_p16_x2)"vluti4q_lane_p16_x2poly16x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_s16_x2)"vluti4q_lane_s16_x2int16x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_s8)"vluti4q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_u8)"vluti4q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_lane_p8)"vluti4q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_f16_x2)"vluti4q_laneq_f16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_u16_x2)"vluti4q_laneq_u16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_p16_x2)"vluti4q_laneq_p16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_s16_x2)"vluti4q_laneq_s16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_s8)"vluti4q_laneq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_u8)"vluti4q_laneq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vluti4q_laneq_p8)"vluti4q_laneq_p8"Maximum (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_f64)"vmax_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_f64)"vmaxq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxh_f16)"vmaxh_f16"Floating-point Maximum Number (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnm_f64)"vmaxnm_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmq_f64)"vmaxnmq_f64"Floating-point Maximum Number""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmh_f16)"vmaxnmh_f16"Floating-point maximum number across vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmv_f16)"vmaxnmv_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmvq_f16)"vmaxnmvq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmv_f32)"vmaxnmv_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmvq_f64)"vmaxnmvq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmvq_f32)"vmaxnmvq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_f16)"vmaxv_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_f16)"vmaxvq_f16"Horizontal vector max.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_f32)"vmaxv_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_f32)"vmaxvq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_f64)"vmaxvq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_s8)"vmaxv_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_s8)"vmaxvq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_s16)"vmaxv_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_s16)"vmaxvq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_s32)"vmaxv_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_s32)"vmaxvq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_u8)"vmaxv_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_u8)"vmaxvq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_u16)"vmaxv_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_u16)"vmaxvq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_u32)"vmaxv_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_u32)"vmaxvq_u32"Minimum (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_f64)"vmin_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_f64)"vminq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminh_f16)"vminh_f16"Floating-point Minimum Number (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnm_f64)"vminnm_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmq_f64)"vminnmq_f64"Floating-point Minimum Number""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmh_f16)"vminnmh_f16"Floating-point minimum number across vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmv_f16)"vminnmv_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmvq_f16)"vminnmvq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmv_f32)"vminnmv_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmvq_f64)"vminnmvq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmvq_f32)"vminnmvq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_f16)"vminv_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_f16)"vminvq_f16"Horizontal vector min.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_f32)"vminv_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_f32)"vminvq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_f64)"vminvq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_s8)"vminv_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_s8)"vminvq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_s16)"vminv_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_s16)"vminvq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_s32)"vminv_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_s32)"vminvq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_u8)"vminv_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_u8)"vminvq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_u16)"vminv_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_u16)"vminvq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_u32)"vminv_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_u32)"vminvq_u32"Floating-point multiply-add to accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_f64)"vmla_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_f64)"vmlaq_f64"Multiply-add long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_s16)"vmlal_high_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_s16)"vmlal_high_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_s32)"vmlal_high_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_s32)"vmlal_high_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_u16)"vmlal_high_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_u16)"vmlal_high_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_u32)"vmlal_high_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_u32)"vmlal_high_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_n_s16)"vmlal_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_n_s32)"vmlal_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_n_u16)"vmlal_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_n_u32)"vmlal_high_n_u32"Signed multiply-add long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_s8)"vmlal_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_s16)"vmlal_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_s32)"vmlal_high_s32"Unsigned multiply-add long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_u8)"vmlal_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_u16)"vmlal_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_u32)"vmlal_high_u32"Floating-point multiply-subtract from accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_f64)"vmls_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_f64)"vmlsq_f64"Multiply-subtract long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_s16)"vmlsl_high_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_s16)"vmlsl_high_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_s32)"vmlsl_high_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_s32)"vmlsl_high_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_u16)"vmlsl_high_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_u16)"vmlsl_high_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_u32)"vmlsl_high_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_u32)"vmlsl_high_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_n_s16)"vmlsl_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_n_s32)"vmlsl_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_n_u16)"vmlsl_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_n_u32)"vmlsl_high_n_u32"Signed multiply-subtract long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_s8)"vmlsl_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_s16)"vmlsl_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_s32)"vmlsl_high_s32"Unsigned multiply-subtract long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_u8)"vmlsl_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_u16)"vmlsl_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_u32)"vmlsl_high_u32"Vector move""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_s8)"vmovl_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_s16)"vmovl_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_s32)"vmovl_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_u8)"vmovl_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_u16)"vmovl_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_u32)"vmovl_high_u32"Extract narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_s16)"vmovn_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_s32)"vmovn_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_s64)"vmovn_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_u16)"vmovn_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_u32)"vmovn_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_u64)"vmovn_high_u64"Multiply""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_f64)"vmul_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_f64)"vmulq_f64"Floating-point multiply""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_f64)"vmul_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_f16)"vmul_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_f16)"vmulq_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_f64)"vmul_laneq_f64"Vector multiply by scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_f64)"vmul_n_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_f64)"vmulq_n_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuld_lane_f64)"vmuld_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulh_f16)"vmulh_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulh_lane_f16)"vmulh_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulh_laneq_f16)"vmulh_laneq_f16"Multiply long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_s16)"vmull_high_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_s16)"vmull_high_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_s32)"vmull_high_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_s32)"vmull_high_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_u16)"vmull_high_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_u16)"vmull_high_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_u32)"vmull_high_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_u32)"vmull_high_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_n_s16)"vmull_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_n_s32)"vmull_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_n_u16)"vmull_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_n_u32)"vmull_high_n_u32"Polynomial multiply long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_p64)"vmull_high_p64p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_p8)"vmull_high_p8"Signed multiply long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_s8)"vmull_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_s16)"vmull_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_s32)"vmull_high_s32"Unsigned multiply long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_u8)"vmull_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_u16)"vmull_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_u32)"vmull_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_p64)"vmull_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_f64)"vmulq_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_f64)"vmulq_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuls_lane_f32)"vmuls_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuls_laneq_f32)"vmuls_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuld_laneq_f64)"vmuld_laneq_f64"Floating-point multiply extended""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_f16)"vmulx_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_f16)"vmulxq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_f32)"vmulx_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_f32)"vmulxq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_f64)"vmulx_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_f64)"vmulxq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_lane_f16)"vmulx_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_laneq_f16)"vmulx_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_lane_f16)"vmulxq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_laneq_f16)"vmulxq_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_lane_f32)"vmulx_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_laneq_f32)"vmulx_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_lane_f32)"vmulxq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_laneq_f32)"vmulxq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_laneq_f64)"vmulxq_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_lane_f64)"vmulx_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_laneq_f64)"vmulx_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_n_f16)"vmulx_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_n_f16)"vmulxq_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxd_f64)"vmulxd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxs_f32)"vmulxs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxd_lane_f64)"vmulxd_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxd_laneq_f64)"vmulxd_laneq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxs_lane_f32)"vmulxs_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxs_laneq_f32)"vmulxs_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxh_f16)"vmulxh_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxh_lane_f16)"vmulxh_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxh_laneq_f16)"vmulxh_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_lane_f64)"vmulxq_lane_f64"Negate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_f64)"vneg_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_f64)"vnegq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s64)"vneg_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s64)"vnegq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegd_s64)"vnegd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegh_f16)"vnegh_f16"Floating-point add pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddd_f64)"vpaddd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadds_f32)"vpadds_f32"Add pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddd_s64)"vpaddd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddd_u64)"vpaddd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_f16)"vpaddq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_f32)"vpaddq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_f64)"vpaddq_f64"Add Pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s8)"vpaddq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s16)"vpaddq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s32)"vpaddq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s64)"vpaddq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u8)"vpaddq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u16)"vpaddq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u32)"vpaddq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u64)"vpaddq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_f16)"vpmax_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_f16)"vpmaxq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnm_f16)"vpmaxnm_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmq_f16)"vpmaxnmq_f16"Floating-point Maximum Number Pairwise (vector).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnm_f32)"vpmaxnm_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmq_f32)"vpmaxnmq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmq_f64)"vpmaxnmq_f64"Floating-point maximum number pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmqd_f64)"vpmaxnmqd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnms_f32)"vpmaxnms_f32"Folding maximum of adjacent pairs""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_f32)"vpmaxq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_f64)"vpmaxq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_s8)"vpmaxq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_s16)"vpmaxq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_s32)"vpmaxq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u8)"vpmaxq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u16)"vpmaxq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u32)"vpmaxq_u32"Floating-point maximum pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxqd_f64)"vpmaxqd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxs_f32)"vpmaxs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_f16)"vpmin_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_f16)"vpminq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnm_f16)"vpminnm_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmq_f16)"vpminnmq_f16"Floating-point Minimum Number Pairwise (vector).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnm_f32)"vpminnm_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmq_f32)"vpminnmq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmq_f64)"vpminnmq_f64"Floating-point minimum number pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmqd_f64)"vpminnmqd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnms_f32)"vpminnms_f32"Folding minimum of adjacent pairs""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_f32)"vpminq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_f64)"vpminq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_s8)"vpminq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_s16)"vpminq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_s32)"vpminq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_u8)"vpminq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_u16)"vpminq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_u32)"vpminq_u32"Floating-point minimum pairwise""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminqd_f64)"vpminqd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmins_f32)"vpmins_f32"Signed saturating Absolute value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s64)"vqabs_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s64)"vqabsq_s64"Signed saturating absolute value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsb_s8)"vqabsb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsh_s16)"vqabsh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabss_s32)"vqabss_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsd_s64)"vqabsd_s64"Saturating add""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddb_s8)"vqaddb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddh_s16)"vqaddh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddb_u8)"vqaddb_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddh_u16)"vqaddh_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadds_s32)"vqadds_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddd_s64)"vqaddd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadds_u32)"vqadds_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddd_u64)"vqaddd_u64"Signed saturating doubling multiply-add long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_lane_s16)"vqdmlal_high_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_laneq_s16)"vqdmlal_high_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_lane_s32)"vqdmlal_high_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_laneq_s32)"vqdmlal_high_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_n_s16)"vqdmlal_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_s16)"vqdmlal_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_n_s32)"vqdmlal_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_high_s32)"vqdmlal_high_s32"Vector widening saturating doubling multiply accumulate with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_laneq_s16)"vqdmlal_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_laneq_s32)"vqdmlal_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlalh_lane_s16)"vqdmlalh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlalh_laneq_s16)"vqdmlalh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlals_lane_s32)"vqdmlals_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlals_laneq_s32)"vqdmlals_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlalh_s16)"vqdmlalh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlals_s32)"vqdmlals_s32"Signed saturating doubling multiply-subtract long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_lane_s16)"vqdmlsl_high_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_laneq_s16)"vqdmlsl_high_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_lane_s32)"vqdmlsl_high_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_laneq_s32)"vqdmlsl_high_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_n_s16)"vqdmlsl_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_s16)"vqdmlsl_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_n_s32)"vqdmlsl_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_high_s32)"vqdmlsl_high_s32"Vector widening saturating doubling multiply subtract with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_laneq_s16)"vqdmlsl_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_laneq_s32)"vqdmlsl_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlslh_lane_s16)"vqdmlslh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlslh_laneq_s16)"vqdmlslh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsls_lane_s32)"vqdmlsls_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsls_laneq_s32)"vqdmlsls_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlslh_s16)"vqdmlslh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsls_s32)"vqdmlsls_s32"Vector saturating doubling multiply high by scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_lane_s16)"vqdmulh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_lane_s16)"vqdmulhq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_lane_s32)"vqdmulh_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_lane_s32)"vqdmulhq_lane_s32"Signed saturating doubling multiply returning high half""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhh_lane_s16)"vqdmulhh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhh_laneq_s16)"vqdmulhh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhh_s16)"vqdmulhh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhs_s32)"vqdmulhs_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhs_lane_s32)"vqdmulhs_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhs_laneq_s32)"vqdmulhs_laneq_s32"Signed saturating doubling multiply long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_lane_s16)"vqdmull_high_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_laneq_s32)"vqdmull_high_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_lane_s32)"vqdmull_high_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_laneq_s16)"vqdmull_high_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_n_s16)"vqdmull_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_n_s32)"vqdmull_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_s16)"vqdmull_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_high_s32)"vqdmull_high_s32"Vector saturating doubling long multiply by scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_laneq_s16)"vqdmull_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_laneq_s32)"vqdmull_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmullh_lane_s16)"vqdmullh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulls_laneq_s32)"vqdmulls_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmullh_laneq_s16)"vqdmullh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmullh_s16)"vqdmullh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulls_lane_s32)"vqdmulls_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulls_s32)"vqdmulls_s32"Signed saturating extract narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_high_s16)"vqmovn_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_high_s32)"vqmovn_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_high_s64)"vqmovn_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_high_u16)"vqmovn_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_high_u32)"vqmovn_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_high_u64)"vqmovn_high_u64"Saturating extract narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovnd_s64)"vqmovnd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovnd_u64)"vqmovnd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovnh_s16)"vqmovnh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovns_s32)"vqmovns_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovnh_u16)"vqmovnh_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovns_u32)"vqmovns_u32"Signed saturating extract unsigned narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovun_high_s16)"vqmovun_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovun_high_s32)"vqmovun_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovun_high_s64)"vqmovun_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovunh_s16)"vqmovunh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovuns_s32)"vqmovuns_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovund_s64)"vqmovund_s64"Signed saturating negate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s64)"vqneg_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s64)"vqnegq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegb_s8)"vqnegb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegh_s16)"vqnegh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegs_s32)"vqnegs_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegd_s64)"vqnegd_s64"Signed saturating rounding doubling multiply accumulate returning high half""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlah_lane_s16)"vqrdmlah_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlah_lane_s32)"vqrdmlah_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlah_laneq_s16)"vqrdmlah_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlah_laneq_s32)"vqrdmlah_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahq_lane_s16)"vqrdmlahq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahq_lane_s32)"vqrdmlahq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahq_laneq_s16)"vqrdmlahq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahq_laneq_s32)"vqrdmlahq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlah_s16)"vqrdmlah_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahq_s16)"vqrdmlahq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlah_s32)"vqrdmlah_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahq_s32)"vqrdmlahq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahh_lane_s16)"vqrdmlahh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahh_laneq_s16)"vqrdmlahh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahs_lane_s32)"vqrdmlahs_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahs_laneq_s32)"vqrdmlahs_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahh_s16)"vqrdmlahh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlahs_s32)"vqrdmlahs_s32"Signed saturating rounding doubling multiply subtract returning high half""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlsh_lane_s16)"vqrdmlsh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlsh_lane_s32)"vqrdmlsh_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlsh_laneq_s16)"vqrdmlsh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlsh_laneq_s32)"vqrdmlsh_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshq_lane_s16)"vqrdmlshq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshq_lane_s32)"vqrdmlshq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshq_laneq_s16)"vqrdmlshq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshq_laneq_s32)"vqrdmlshq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlsh_s16)"vqrdmlsh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshq_s16)"vqrdmlshq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlsh_s32)"vqrdmlsh_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshq_s32)"vqrdmlshq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshh_lane_s16)"vqrdmlshh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshh_laneq_s16)"vqrdmlshh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshs_lane_s32)"vqrdmlshs_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshs_laneq_s32)"vqrdmlshs_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshh_s16)"vqrdmlshh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmlshs_s32)"vqrdmlshs_s32"Signed saturating rounding doubling multiply returning high half""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhh_lane_s16)"vqrdmulhh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhh_laneq_s16)"vqrdmulhh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhs_lane_s32)"vqrdmulhs_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhs_laneq_s32)"vqrdmulhs_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhh_s16)"vqrdmulhh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhs_s32)"vqrdmulhs_s32"Signed saturating rounding shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlb_s8)"vqrshlb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlh_s16)"vqrshlh_s16"Unsigned signed saturating rounding shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlb_u8)"vqrshlb_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlh_u16)"vqrshlh_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshld_s64)"vqrshld_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshls_s32)"vqrshls_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshls_u32)"vqrshls_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshld_u64)"vqrshld_u64"Signed saturating rounded shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_s16)"vqrshrn_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_s32)"vqrshrn_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_s64)"vqrshrn_high_n_s64"Unsigned saturating rounded shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_u16)"vqrshrn_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_u32)"vqrshrn_high_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_u64)"vqrshrn_high_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnd_n_u64)"vqrshrnd_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnh_n_u16)"vqrshrnh_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrns_n_u32)"vqrshrns_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnh_n_s16)"vqrshrnh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrns_n_s32)"vqrshrns_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnd_n_s64)"vqrshrnd_n_s64"Signed saturating rounded shift right unsigned narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_high_n_s16)"vqrshrun_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_high_n_s32)"vqrshrun_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_high_n_s64)"vqrshrun_high_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrund_n_s64)"vqrshrund_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrunh_n_s16)"vqrshrunh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshruns_n_s32)"vqrshruns_n_s32"Signed saturating shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_n_s8)"vqshlb_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshld_n_s64)"vqshld_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_n_s16)"vqshlh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_n_s32)"vqshls_n_s32"Unsigned saturating shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_n_u8)"vqshlb_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshld_n_u64)"vqshld_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_n_u16)"vqshlh_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_n_u32)"vqshls_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_s8)"vqshlb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_s16)"vqshlh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_s32)"vqshls_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_u8)"vqshlb_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_u16)"vqshlh_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_u32)"vqshls_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshld_s64)"vqshld_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshld_u64)"vqshld_u64"Signed saturating shift left unsigned""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlub_n_s8)"vqshlub_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlud_n_s64)"vqshlud_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluh_n_s16)"vqshluh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlus_n_s32)"vqshlus_n_s32"Signed saturating shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_s16)"vqshrn_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_s32)"vqshrn_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_s64)"vqshrn_high_n_s64"Unsigned saturating shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_u16)"vqshrn_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_u32)"vqshrn_high_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_u64)"vqshrn_high_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnd_n_s64)"vqshrnd_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnd_n_u64)"vqshrnd_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnh_n_s16)"vqshrnh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrns_n_s32)"vqshrns_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnh_n_u16)"vqshrnh_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrns_n_u32)"vqshrns_n_u32"Signed saturating shift right unsigned narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_high_n_s16)"vqshrun_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_high_n_s32)"vqshrun_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_high_n_s64)"vqshrun_high_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrund_n_s64)"vqshrund_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrunh_n_s16)"vqshrunh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshruns_n_s32)"vqshruns_n_s32"Saturating subtract""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubb_s8)"vqsubb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubh_s16)"vqsubh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubb_u8)"vqsubb_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubh_u16)"vqsubh_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubs_s32)"vqsubs_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubd_s64)"vqsubd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubs_u32)"vqsubs_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubd_u64)"vqsubd_u64"Table look-up""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1)"vqtbl1"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1q)"vqtbl1q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1_s8)"vqtbl1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1q_s8)"vqtbl1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1_u8)"vqtbl1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1q_u8)"vqtbl1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1_p8)"vqtbl1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl1q_p8)"vqtbl1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2)"vqtbl2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2q)"vqtbl2q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2_s8)"vqtbl2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2q_s8)"vqtbl2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2_u8)"vqtbl2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2q_u8)"vqtbl2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2_p8)"vqtbl2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl2q_p8)"vqtbl2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3)"vqtbl3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3q)"vqtbl3q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3_s8)"vqtbl3_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3q_s8)"vqtbl3q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3_u8)"vqtbl3_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3q_u8)"vqtbl3q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3_p8)"vqtbl3_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl3q_p8)"vqtbl3q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4)"vqtbl4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4q)"vqtbl4q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4_s8)"vqtbl4_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4q_s8)"vqtbl4q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4_u8)"vqtbl4_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4q_u8)"vqtbl4q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4_p8)"vqtbl4_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbl4q_p8)"vqtbl4q_p8"Extended table look-up""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1)"vqtbx1"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1q)"vqtbx1q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1_s8)"vqtbx1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1q_s8)"vqtbx1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1_u8)"vqtbx1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1q_u8)"vqtbx1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1_p8)"vqtbx1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx1q_p8)"vqtbx1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2)"vqtbx2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2q)"vqtbx2q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2_s8)"vqtbx2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2q_s8)"vqtbx2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2_u8)"vqtbx2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2q_u8)"vqtbx2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2_p8)"vqtbx2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx2q_p8)"vqtbx2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3)"vqtbx3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3q)"vqtbx3q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3_s8)"vqtbx3_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3q_s8)"vqtbx3q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3_u8)"vqtbx3_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3q_u8)"vqtbx3q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3_p8)"vqtbx3_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx3q_p8)"vqtbx3q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4)"vqtbx4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4q)"vqtbx4q"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4_s8)"vqtbx4_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4q_s8)"vqtbx4q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4_u8)"vqtbx4_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4q_u8)"vqtbx4q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4_p8)"vqtbx4_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqtbx4q_p8)"vqtbx4q_p8"Rotate and exclusive OR""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrax1q_u64)"vrax1q_u64"Reverse bit order""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbit_s8)"vrbit_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbitq_s8)"vrbitq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbit_u8)"vrbit_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbitq_u8)"vrbitq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbit_p8)"vrbit_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbitq_p8)"vrbitq_p8"Reciprocal estimate.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_f64)"vrecpe_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_f64)"vrecpeq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecped_f64)"vrecped_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpes_f32)"vrecpes_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeh_f16)"vrecpeh_f16"Floating-point reciprocal step""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecps_f64)"vrecps_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsq_f64)"vrecpsq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsd_f64)"vrecpsd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpss_f32)"vrecpss_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsh_f16)"vrecpsh_f16"Floating-point reciprocal exponent""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpxd_f64)"vrecpxd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpxs_f32)"vrecpxs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpxh_f16)"vrecpxh_f16"Vector reinterpret cast operation""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_f16)"vreinterpret_f64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_f16)"vreinterpretq_f64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f64)"vreinterpret_f16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f64)"vreinterpretq_f16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p128)"vreinterpretq_f64_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_f32)"vreinterpret_f64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f32)"vreinterpret_p64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_f32)"vreinterpretq_f64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f32)"vreinterpretq_p64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_f64)"vreinterpret_f32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f64)"vreinterpret_s8_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f64)"vreinterpret_s16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f64)"vreinterpret_s32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f64)"vreinterpret_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f64)"vreinterpret_u8_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f64)"vreinterpret_u16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f64)"vreinterpret_u32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f64)"vreinterpret_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f64)"vreinterpret_p8_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f64)"vreinterpret_p16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f64)"vreinterpret_p64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f64)"vreinterpretq_p128_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f64)"vreinterpretq_f32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f64)"vreinterpretq_s8_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f64)"vreinterpretq_s16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f64)"vreinterpretq_s32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f64)"vreinterpretq_s64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f64)"vreinterpretq_u8_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f64)"vreinterpretq_u16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f64)"vreinterpretq_u32_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f64)"vreinterpretq_u64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f64)"vreinterpretq_p8_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f64)"vreinterpretq_p16_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f64)"vreinterpretq_p64_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s8)"vreinterpret_f64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s8)"vreinterpretq_f64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s16)"vreinterpret_f64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s16)"vreinterpretq_f64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s32)"vreinterpret_f64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s32)"vreinterpretq_f64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s64)"vreinterpret_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s64)"vreinterpret_p64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s64)"vreinterpretq_f64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s64)"vreinterpretq_p64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u8)"vreinterpret_f64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u8)"vreinterpretq_f64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u16)"vreinterpret_f64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u16)"vreinterpretq_f64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u32)"vreinterpret_f64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u32)"vreinterpretq_f64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u64)"vreinterpret_f64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u64)"vreinterpret_p64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u64)"vreinterpretq_f64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u64)"vreinterpretq_p64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p8)"vreinterpret_f64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p8)"vreinterpretq_f64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p16)"vreinterpret_f64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p16)"vreinterpretq_f64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p64)"vreinterpret_f32_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p64)"vreinterpret_f64_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p64)"vreinterpret_s64_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p64)"vreinterpret_u64_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p64)"vreinterpretq_f32_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p64)"vreinterpretq_f64_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p64)"vreinterpretq_s64_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p64)"vreinterpretq_u64_p64"Floating-point round to 32-bit integer, using current rounding mode""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32x_f32)"vrnd32x_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32xq_f32)"vrnd32xq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32xq_f64)"vrnd32xq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32x_f64)"vrnd32x_f64"Floating-point round to 32-bit integer toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32z_f32)"vrnd32z_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32zq_f32)"vrnd32zq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32zq_f64)"vrnd32zq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32z_f64)"vrnd32z_f64"Floating-point round to 64-bit integer, using current rounding mode""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64x_f32)"vrnd64x_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64xq_f32)"vrnd64xq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64xq_f64)"vrnd64xq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64x_f64)"vrnd64x_f64"Floating-point round to 64-bit integer toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64z_f32)"vrnd64z_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64zq_f32)"vrnd64zq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64zq_f64)"vrnd64zq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd64z_f64)"vrnd64z_f64"Floating-point round to integral, toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd_f16)"vrnd_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndq_f16)"vrndq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd_f32)"vrnd_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndq_f32)"vrndq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd_f64)"vrnd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndq_f64)"vrndq_f64"Floating-point round to integral, to nearest with ties to away""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnda_f16)"vrnda_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndaq_f16)"vrndaq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnda_f32)"vrnda_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndaq_f32)"vrndaq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnda_f64)"vrnda_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndaq_f64)"vrndaq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndah_f16)"vrndah_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndh_f16)"vrndh_f16"Floating-point round to integral, using current rounding mode""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndi_f16)"vrndi_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndiq_f16)"vrndiq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndi_f32)"vrndi_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndiq_f32)"vrndiq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndi_f64)"vrndi_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndiq_f64)"vrndiq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndih_f16)"vrndih_f16"Floating-point round to integral, toward minus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndm_f16)"vrndm_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmq_f16)"vrndmq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndm_f32)"vrndm_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmq_f32)"vrndmq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndm_f64)"vrndm_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmq_f64)"vrndmq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmh_f16)"vrndmh_f16"Floating-point round to integral, to nearest with ties to even""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f64)"vrndn_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndnq_f64)"vrndnq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndnh_f16)"vrndnh_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndns_f32)"vrndns_f32"Floating-point round to integral, toward plus infinity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndp_f16)"vrndp_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndpq_f16)"vrndpq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndp_f32)"vrndp_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndpq_f32)"vrndpq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndp_f64)"vrndp_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndpq_f64)"vrndpq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndph_f16)"vrndph_f16"Floating-point round to integral exact, using current rounding mode""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndx_f16)"vrndx_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndxq_f16)"vrndxq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndx_f32)"vrndx_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndxq_f32)"vrndxq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndx_f64)"vrndx_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndxq_f64)"vrndxq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndxh_f16)"vrndxh_f16"Signed rounding shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshld_s64)"vrshld_s64"Unsigned rounding shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshld_u64)"vrshld_u64"Signed rounding shift right""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrd_n_s64)"vrshrd_n_s64"Unsigned rounding shift right""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrd_n_u64)"vrshrd_n_u64"Rounding shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_s16)"vrshrn_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_s32)"vrshrn_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_s64)"vrshrn_high_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_u16)"vrshrn_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_u32)"vrshrn_high_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_u64)"vrshrn_high_n_u64"Reciprocal square-root estimate.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_f64)"vrsqrte_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_f64)"vrsqrteq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrted_f64)"vrsqrted_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtes_f32)"vrsqrtes_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteh_f16)"vrsqrteh_f16"Floating-point reciprocal square root step""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrts_f64)"vrsqrts_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsq_f64)"vrsqrtsq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsd_f64)"vrsqrtsd_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtss_f32)"vrsqrtss_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsh_f16)"vrsqrtsh_f16"Signed rounding shift right and accumulate.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsrad_n_s64)"vrsrad_n_s64"Unsigned rounding shift right and accumulate.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsrad_n_u64)"vrsrad_n_u64"Rounding subtract returning high narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_s16)"vrsubhn_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_s32)"vrsubhn_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_s64)"vrsubhn_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_u16)"vrsubhn_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_u32)"vrsubhn_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_u64)"vrsubhn_high_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_f64)"vset_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_f64)"vsetq_lane_f64"SHA512 hash update part 2""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512h2q_u64)""SHA512 hash update part 1""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512hq_u64)""SHA512 schedule update 0""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512su0q_u64)""SHA512 schedule update 1""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512su1q_u64)""Signed Shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshld_s64)"vshld_s64"Unsigned Shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshld_u64)"vshld_u64"Signed shift left long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_s8)"vshll_high_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_s16)"vshll_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_s32)"vshll_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_u8)"vshll_high_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_u16)"vshll_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_u32)"vshll_high_n_u32"Shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_s16)"vshrn_high_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_s32)"vshrn_high_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_s64)"vshrn_high_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_u16)"vshrn_high_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_u32)"vshrn_high_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_u64)"vshrn_high_n_u64"Shift Left and Insert (immediate)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_s8)"vsli_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_s8)"vsliq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_s16)"vsli_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_s16)"vsliq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_s32)"vsli_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_s32)"vsliq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_s64)"vsli_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_s64)"vsliq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_u8)"vsli_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_u8)"vsliq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_u16)"vsli_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_u16)"vsliq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_u32)"vsli_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_u32)"vsliq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_u64)"vsli_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_u64)"vsliq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_p8)"vsli_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_p8)"vsliq_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_p16)"vsli_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_p16)"vsliq_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsli_n_p64)"vsli_n_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsliq_n_p64)"vsliq_n_p64"Shift left and insert""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vslid_n_s64)"vslid_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vslid_n_u64)"vslid_n_u64"SM3PARTW1""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3partw1q_u32)"vsm3partw1q_u32"SM3PARTW2""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3partw2q_u32)"vsm3partw2q_u32"SM3SS1""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3ss1q_u32)"vsm3ss1q_u32"SM3TT1A""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3tt1aq_u32)"IMM2vsm3tt1aq_u32"SM3TT1B""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3tt1bq_u32)"vsm3tt1bq_u32"SM3TT2A""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3tt2aq_u32)"vsm3tt2aq_u32"SM3TT2B""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm3tt2bq_u32)"vsm3tt2bq_u32"SM4 key""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm4ekeyq_u32)"vsm4ekeyq_u32"SM4 encode""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsm4eq_u32)"vsm4eq_u32"Unsigned saturating Accumulate of Signed value.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u8)"vsqadd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u8)"vsqaddq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u16)"vsqadd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u16)"vsqaddq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u32)"vsqadd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u32)"vsqaddq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u64)"vsqadd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u64)"vsqaddq_u64"Unsigned saturating accumulate of signed value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddb_u8)"vsqaddb_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddh_u16)"vsqaddh_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddd_u64)"vsqaddd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadds_u32)"vsqadds_u32"Calculates the square root of each lane.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrt_f16)"vsqrt_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrtq_f16)"vsqrtq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrt_f32)"vsqrt_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrtq_f32)"vsqrtq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrt_f64)"vsqrt_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrtq_f64)"vsqrtq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrth_f16)"vsqrth_f16"Shift Right and Insert (immediate)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s8)"vsri_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s8)"vsriq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s16)"vsri_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s16)"vsriq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s32)"vsri_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s32)"vsriq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s64)"vsri_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s64)"vsriq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u8)"vsri_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u8)"vsriq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u16)"vsri_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u16)"vsriq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u32)"vsri_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u32)"vsriq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u64)"vsri_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u64)"vsriq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_p8)"vsri_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_p8)"vsriq_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_p16)"vsri_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_p16)"vsriq_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_p64)"vsri_n_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_p64)"vsriq_n_p64"Shift right and insert""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsrid_n_s64)"vsrid_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsrid_n_u64)"vsrid_n_u64"Store multiple single-element structures from one, two, three, or four registers.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f16)"vst1_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f16)"vst1q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f32)"vst1q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f64)"vst1_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f64)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s8)"vst1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s8)"vst1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s16)"vst1_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s16)"vst1q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s32)"vst1_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s32)"vst1q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s64)"vst1_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s64)"vst1q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u8)"vst1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u8)"vst1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u16)"vst1_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u16)"vst1q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u32)"vst1_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u32)"vst1q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u64)"vst1_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u64)"vst1q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p8)"vst1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p8)"vst1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p16)"vst1_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p16)"vst1q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p64)"vst1_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p64)"vst1q_p64"Store multiple single-element structures to one, two, three, or four registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f64_x2)"vst1_f64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f64_x2)"vst1q_f64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f64_x3)"vst1_f64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f64_x3)"vst1q_f64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f64_x4)"vst1_f64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f64_x4)"vst1q_f64_x4"Store multiple single-element structures from one, two, three, or four registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_f64)"vst1_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_f64)"vst1q_lane_f64"Store multiple 2-element structures from two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_f64)"vst2_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_f64)"vst2_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_s64)"vst2_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_p64)"vst2_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_u64)"vst2_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_f64)"vst2q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_s64)"vst2q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_f64)"vst2q_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_s8)"vst2q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_s64)"vst2q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_p64)"vst2q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_u8)"vst2q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_u64)"vst2q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_p8)"vst2q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_p64)"vst2q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_u64)"vst2q_u64"Store multiple 3-element structures from three registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_f64)"vst3_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_f64)"vst3_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_s64)"vst3_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_p64)"vst3_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_u64)"vst3_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_f64)"vst3q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_s64)"vst3q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_f64)"vst3q_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_s8)"vst3q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_s64)"vst3q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_p64)"vst3q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_u8)"vst3q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_u64)"vst3q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_p8)"vst3q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_p64)"vst3q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_u64)"vst3q_u64"Store multiple 4-element structures from four registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_f64)"vst4_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_f64)"vst4_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_s64)"vst4_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_p64)"vst4_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_u64)"vst4_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_f64)"vst4q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_s64)"vst4q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_f64)"vst4q_lane_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_s8)"vst4q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_s64)"vst4q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_p64)"vst4q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_u8)"vst4q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_u64)"vst4q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_p8)"vst4q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_p64)"vst4q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_u64)"vst4q_u64"Subtract""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_f64)"vsub_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_f64)"vsubq_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubd_s64)"vsubd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubd_u64)"vsubd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubh_f16)"vsubh_f16"Signed Subtract Long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_s8)"vsubl_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_s16)"vsubl_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_s32)"vsubl_high_s32"Unsigned Subtract Long""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_u8)"vsubl_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_u16)"vsubl_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_u32)"vsubl_high_u32"Signed Subtract Wide""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_s8)"vsubw_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_s16)"vsubw_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_s32)"vsubw_high_s32"Unsigned Subtract Wide""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_u8)"vsubw_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_u16)"vsubw_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_u32)"vsubw_high_u32"Dot product index form with signed and unsigned integers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsudot_laneq_s32)"vsudot_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsudotq_laneq_s32)"vsudotq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl1_s8)"vtbl1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl1_u8)"vtbl1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl1_p8)"vtbl1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl2_s8)"vtbl2_s8int8x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl2_u8)"vtbl2_u8uint8x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl2_p8)"vtbl2_p8poly8x8x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl3_s8)"vtbl3_s8int8x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl3_u8)"vtbl3_u8uint8x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl3_p8)"vtbl3_p8poly8x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl4_s8)"vtbl4_s8int8x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl4_u8)"vtbl4_u8uint8x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl4_p8)"vtbl4_p8poly8x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx1_s8)"vtbx1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx1_u8)"vtbx1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx1_p8)"vtbx1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx2_s8)"vtbx2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx2_u8)"vtbx2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx2_p8)"vtbx2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx3_s8)"vtbx3_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx3_u8)"vtbx3_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx3_p8)"vtbx3_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx4_s8)"vtbx4_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx4_u8)"vtbx4_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx4_p8)"vtbx4_p8"Transpose vectors""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_f16)"vtrn1_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_f16)"vtrn1q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_f32)"vtrn1_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_f64)"vtrn1q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_s32)"vtrn1_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s64)"vtrn1q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_u32)"vtrn1_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u64)"vtrn1q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_p64)"vtrn1q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_f32)"vtrn1q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_s8)"vtrn1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s8)"vtrn1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_s16)"vtrn1_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s16)"vtrn1q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s32)"vtrn1q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_u8)"vtrn1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u8)"vtrn1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_u16)"vtrn1_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u16)"vtrn1q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u32)"vtrn1q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_p8)"vtrn1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_p8)"vtrn1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_p16)"vtrn1_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_p16)"vtrn1q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_f16)"vtrn2_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_f16)"vtrn2q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_f32)"vtrn2_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_f64)"vtrn2q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_s32)"vtrn2_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s64)"vtrn2q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_u32)"vtrn2_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_u64)"vtrn2q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_p64)"vtrn2q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_f32)"vtrn2q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_s8)"vtrn2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s8)"vtrn2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_s16)"vtrn2_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s16)"vtrn2q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s32)"vtrn2q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_u8)"vtrn2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_u8)"vtrn2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_u16)"vtrn2_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_u16)"vtrn2q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_u32)"vtrn2q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_p8)"vtrn2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_p8)"vtrn2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_p16)"vtrn2_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_p16)"vtrn2q_p16"Signed compare bitwise Test bits nonzero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s64)"vtst_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s64)"vtstq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_p64)"vtst_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_p64)"vtstq_p64"Unsigned compare bitwise Test bits nonzero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u64)"vtst_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u64)"vtstq_u64"Compare bitwise test bits nonzero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstd_s64)"vtstd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstd_u64)"vtstd_u64"Signed saturating Accumulate of Unsigned value.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s8)"vuqadd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s8)"vuqaddq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s16)"vuqadd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s16)"vuqaddq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s32)"vuqadd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s32)"vuqaddq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s64)"vuqadd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s64)"vuqaddq_s64"Signed saturating accumulate of unsigned value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddb_s8)"vuqaddb_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddh_s16)"vuqaddh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddd_s64)"vuqaddd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadds_s32)"vuqadds_s32"Dot product index form with unsigned and signed integers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusdot_laneq_s32)"vusdot_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusdotq_laneq_s32)"vusdotq_laneq_s32"Unzip vectors""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_f16)"vuzp1_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_f16)"vuzp1q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_f32)"vuzp1_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_f64)"vuzp1q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_s32)"vuzp1_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s64)"vuzp1q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_u32)"vuzp1_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u64)"vuzp1q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_p64)"vuzp1q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_f32)"vuzp1q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_s8)"vuzp1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s8)"vuzp1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_s16)"vuzp1_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s16)"vuzp1q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s32)"vuzp1q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_u8)"vuzp1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u8)"vuzp1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_u16)"vuzp1_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u16)"vuzp1q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u32)"vuzp1q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_p8)"vuzp1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_p8)"vuzp1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_p16)"vuzp1_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_p16)"vuzp1q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_f16)"vuzp2_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_f16)"vuzp2q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_f32)"vuzp2_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_f64)"vuzp2q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_s32)"vuzp2_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s64)"vuzp2q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_u32)"vuzp2_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u64)"vuzp2q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_p64)"vuzp2q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_f32)"vuzp2q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_s8)"vuzp2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s8)"vuzp2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_s16)"vuzp2_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s16)"vuzp2q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s32)"vuzp2q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_u8)"vuzp2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u8)"vuzp2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_u16)"vuzp2_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u16)"vuzp2q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u32)"vuzp2q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_p8)"vuzp2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_p8)"vuzp2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_p16)"vuzp2_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_p16)"vuzp2q_p16"Exclusive OR and rotate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vxarq_u64)"IMM6vxarq_u64"Zip vectors""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_f16)"vzip1_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_f16)"vzip1q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_f32)"vzip1_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_f32)"vzip1q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_f64)"vzip1q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_s8)"vzip1_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s8)"vzip1q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_s16)"vzip1_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s16)"vzip1q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_s32)"vzip1_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s32)"vzip1q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s64)"vzip1q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_u8)"vzip1_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u8)"vzip1q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_u16)"vzip1_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u16)"vzip1q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_u32)"vzip1_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u32)"vzip1q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u64)"vzip1q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_p8)"vzip1_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_p8)"vzip1q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_p16)"vzip1_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_p16)"vzip1q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_p64)"vzip1q_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_f16)"vzip2_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_f16)"vzip2q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_f32)"vzip2_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_f32)"vzip2q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_f64)"vzip2q_f64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_s8)"vzip2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s8)"vzip2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_s16)"vzip2_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s16)"vzip2q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_s32)"vzip2_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s32)"vzip2q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s64)"vzip2q_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_u8)"vzip2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u8)"vzip2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_u16)"vzip2_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u16)"vzip2q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_u32)"vzip2_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u32)"vzip2q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u64)"vzip2q_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_p8)"vzip2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_p8)"vzip2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_p16)"vzip2_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_p16)"vzip2q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_p64)"vzip2q_p64// This code is automatically generated. DO NOT MODIFY.// Instead, modify `crates/stdarch-gen-arm/spec/` and run the following command to re-generate this file:// cargo run --bin=stdarch-gen-arm -- crates/stdarch-gen-arm/spec/// ARM-specific type containing two `float64x1_t` vectors./// ARM-specific type containing three `float64x1_t` vectors./// ARM-specific type containing four `float64x1_t` vectors./// ARM-specific type containing two `float64x2_t` vectors./// ARM-specific type containing three `float64x2_t` vectors./// ARM-specific type containing four `float64x2_t` vectors.vcopy_lane_s64/// Duplicate vector element to vector or scalarvcopy_lane_u64vcopy_lane_p64vcopy_lane_f64vcopy_laneq_s64vcopy_laneq_u64vcopy_laneq_p64vcopy_laneq_f64vld1_dup_f64/// Load multiple single-element structures to one, two, three, or four registersvld1q_dup_f64vld1_lane_f64/// Load one single-element structure to one lane of one register.vld1q_lane_f64vbsl_f64/// Bitwise Select instructions. This instruction sets each bit in the destination SIMD&FP register/// to the corresponding bit from the first source SIMD&FP register when the original/// destination bit was 1, otherwise from the second source SIMD&FP register.vbsl_p64/// Bitwise Select.vbslq_f64/// Bitwise Select. (128-bit)vbslq_p64vadd_f64/// Vector add.vadd_s64vadd_u64vext_p64/// Extract vector from pair of vectorsvext_f64vdup_n_p64vdup_n_f64vdupq_n_p64vdupq_n_f64vmov_n_p64vmov_n_f64vmovq_n_p64vget_high_f64vget_high_p64vget_low_f64vget_low_p64IMM5vget_lane_f64vgetq_lane_f64vcombine_f64/// Vector combinevshld_n_s64/// Shift leftvshld_n_u64vshrd_n_s64/// Signed shift rightvshrd_n_u64/// Unsigned shift rightvsrad_n_s64/// Signed shift right and accumulatevsrad_n_u64/// Unsigned shift right and accumulatesimd_testtest_vadd_f64test_vaddq_f64test_vadd_s64test_vadd_u64test_vaddd_s64test_vaddd_u64test_vext_p64test_vext_f64test_vshld_n_s64test_vshld_n_u64test_vshrd_n_s64test_vshrd_n_u64test_vsrad_n_s64test_vsrad_n_u64test_vdup_n_f64test_vdup_n_p64test_vdupq_n_f64test_vdupq_n_p64test_vmov_n_p64test_vmov_n_f64test_vmovq_n_p64test_vmovq_n_f64test_vget_high_f64test_vget_high_p64test_vget_low_f64test_vget_low_p64test_vget_lane_f64test_vgetq_lane_f64test_vcopy_lane_s64test_vcopy_lane_u64test_vcopy_lane_p64test_vcopy_lane_f64test_vcopy_laneq_s64test_vcopy_laneq_u64test_vcopy_laneq_p64test_vcopy_laneq_f64test_vbsl_f64test_vbsl_p64test_vbslq_f64test_vbslq_p64test_vld1_f64test_vld1q_f64test_vld1_dup_f64test_vld1q_dup_f64test_vld1_lane_f64test_vld1q_lane_f64test_vst1_f64test_vst1q_f64"../../arm_shared/neon/table_lookup_tests.rs"table_lookup_tests"../../arm_shared/neon/shift_and_insert_tests.rs"shift_and_insert_tests"../../arm_shared/neon/load_tests.rs"load_tests"../../arm_shared/neon/store_tests.rs"store_tests//! ARMv8 ASIMD intrinsics// FIXME: replace neon with asimd"llvm.prefetch"_PREFETCH_READ/// See [`prefetch`](fn._prefetch.html)._PREFETCH_WRITE_PREFETCH_LOCALITY0_PREFETCH_LOCALITY1_PREFETCH_LOCALITY2_PREFETCH_LOCALITY3_prefetch/// Fetch the cache line that contains address `p` using the given `RW` and `LOCALITY`./// The `RW` must be one of:/// * [`_PREFETCH_READ`](constant._PREFETCH_READ.html): the prefetch is preparing///   for a read./// * [`_PREFETCH_WRITE`](constant._PREFETCH_WRITE.html): the prefetch is preparing///   for a write./// The `LOCALITY` must be one of:/// * [`_PREFETCH_LOCALITY0`](constant._PREFETCH_LOCALITY0.html): Streaming or///   non-temporal prefetch, for data that is used only once./// * [`_PREFETCH_LOCALITY1`](constant._PREFETCH_LOCALITY1.html): Fetch into level 3 cache./// * [`_PREFETCH_LOCALITY2`](constant._PREFETCH_LOCALITY2.html): Fetch into level 2 cache./// * [`_PREFETCH_LOCALITY3`](constant._PREFETCH_LOCALITY3.html): Fetch into level 1 cache./// The prefetch memory instructions signal to the memory system that memory accesses/// from a specified address are likely to occur in the near future. The memory system/// can respond by taking actions that are expected to speed up the memory access when/// they do occur, such as preloading the specified address into one or more caches./// Because these signals are only hints, it is valid for a particular CPU to treat/// any or all prefetch instructions as a NOP./// [Arm's documentation](https://developer.arm.com/documentation/den0024/a/the-a64-instruction-set/memory-access-instructions/prefetching-memory?lang=en)// FIXME: Replace this with the standard ACLE __pld/__pldx/__pli/__plix intrinsicsV_u64V_f64to64to128gen_test_fngen_fill_fn"llvm.arm.smulbb"arm_smulbb"llvm.arm.smulbt"arm_smulbt"llvm.arm.smultb"arm_smultb"llvm.arm.smultt"arm_smultt"llvm.arm.smulwb"arm_smulwb"llvm.arm.smulwt"arm_smulwt"llvm.arm.qadd"arm_qadd"llvm.arm.qsub"arm_qsub"llvm.arm.smlabb"arm_smlabb"llvm.arm.smlabt"arm_smlabt"llvm.arm.smlatb"arm_smlatb"llvm.arm.smlatt"arm_smlatt"llvm.arm.smlawb"arm_smlawb"llvm.arm.smlawt"arm_smlawt__smulbb/// Insert a SMULBB instruction/// Returns the equivalent of a\[0\] * b\[0\]/// where \[0\] is the lower 16 bits and \[1\] is the upper 16 bits.__smultb/// Insert a SMULTB instruction/// Returns the equivalent of a\[0\] * b\[1\]__smulbt/// Returns the equivalent of a\[1\] * b\[0\]__smultt/// Insert a SMULTT instruction/// Returns the equivalent of a\[1\] * b\[1\]__smulwb/// Insert a SMULWB instruction/// Multiplies the 32-bit signed first operand with the low halfword/// (as a 16-bit signed integer) of the second operand./// Return the top 32 bits of the 48-bit product__smulwt/// Insert a SMULWT instruction/// Multiplies the 32-bit signed first operand with the high halfword__qadd/// Signed saturating addition/// Returns the 32-bit saturating signed equivalent of a + b./// Sets the Q flag if saturation occurs.__qsub/// Signed saturating subtraction/// Returns the 32-bit saturating signed equivalent of a - b.__qdbl/// Insert a QADD instruction/// Returns the 32-bit saturating signed equivalent of a + a__smlabb/// Insert a SMLABB instruction/// Returns the equivalent of a\[0\] * b\[0\] + c/// Sets the Q flag if overflow occurs on the addition.__smlabt/// Insert a SMLABT instruction/// Returns the equivalent of a\[0\] * b\[1\] + c__smlatb/// Insert a SMLATB instruction/// Returns the equivalent of a\[1\] * b\[0\] + c__smlatt/// Insert a SMLATT instruction/// Returns the equivalent of a\[1\] * b\[1\] + c__smlawb/// Insert a SMLAWB instruction/// Returns the equivalent of (a * b\[0\] + (c << 16)) >> 16__smlawt/// Insert a SMLAWT instruction/// Returns the equivalent of (a * b\[1\] + (c << 16)) >> 16smulbbsmulbtsmultbsmulttsmulwbsmulwtqaddqsubqdblsmlabbsmlabtsmlatbsmlattsmlawbsmlawt//! # References://! - Section 8.3 "16-bit multiplications"//! Intrinsics that could live here://! - \[x\] __smulbb//! - \[x\] __smulbt//! - \[x\] __smultb//! - \[x\] __smultt//! - \[x\] __smulwb//! - \[x\] __smulwt//! - \[x\] __qadd//! - \[x\] __qsub//! - \[x\] __qdbl//! - \[x\] __smlabb//! - \[x\] __smlabt//! - \[x\] __smlatb//! - \[x\] __smlatt//! - \[x\] __smlawb//! - \[x\] __smlawt// Supported arches: 6, 7-M. See Section 10.1 of ACLE (e.g. SSAT)dsp// Supported arches: 5TE, 7E-M. See Section 10.1 of ACLE (e.g. QADD)// We also include the A profile even though DSP is deprecated on that profile as of ACLE 2.0 (see// section 5.4.7)// Here we workaround the difference between LLVM's +dsp and ACLE's __ARM_FEATURE_DSP by gating on// '+v5te' rather than on '+dsp'// Deprecated in ACLE 2.0 for the A profile but fully supported on the M and R profiles, says// Section 5.4.9 of ACLE. We'll expose these for the A profile even if deprecated//! ARM intrinsics.//! The reference for NEON is [ARM's NEON Intrinsics Reference][arm_ref]. The//! [ARM's NEON Intrinsics Online Database][arm_dat] is also useful."llvm.arm.neon.vbsl.v8i8"vbsl_s8_"llvm.arm.neon.vbsl.v16i8"vbslq_s8___ssat/// Saturates a 32-bit signed integer to a signed integer with a given/// bit width.__usat/// Saturates a 32-bit signed integer to an unsigned integer with a given"llvm.arm.ssat"arm_ssat"llvm.arm.usat"arm_usattest_ssattest_usat//! - Section 8.4 "Saturating intrinsics"int8x4_t/// ARM-specific vector of four packed `i8` packed into a 32-bit integer.uint8x4_t/// ARM-specific vector of four packed `u8` packed into a 32-bit integer.int16x2_t/// ARM-specific vector of two packed `i16` packed into a 32-bit integer.uint16x2_t/// ARM-specific vector of two packed `u16` packed into a 32-bit integer.dsp_call"llvm.arm.qadd8"arm_qadd8"llvm.arm.qsub8"arm_qsub8"llvm.arm.qsub16"arm_qsub16"llvm.arm.qadd16"arm_qadd16"llvm.arm.qasx"arm_qasx"llvm.arm.qsax"arm_qsax"llvm.arm.sadd16"arm_sadd16"llvm.arm.sadd8"arm_sadd8"llvm.arm.smlad"arm_smlad"llvm.arm.smlsd"arm_smlsd"llvm.arm.sasx"arm_sasx"llvm.arm.sel"arm_sel"llvm.arm.shadd8"arm_shadd8"llvm.arm.shadd16"arm_shadd16"llvm.arm.shsub8"arm_shsub8"llvm.arm.ssub8"arm_ssub8"llvm.arm.usub8"arm_usub8"llvm.arm.shsub16"arm_shsub16"llvm.arm.smuad"arm_smuad"llvm.arm.smuadx"arm_smuadx"llvm.arm.smusd"arm_smusd"llvm.arm.smusdx"arm_smusdx"llvm.arm.usad8"arm_usad8__qadd8/// Saturating four 8-bit integer additions/// Returns the 8-bit signed equivalent of/// res\[0\] = a\[0\] + b\[0\]/// res\[1\] = a\[1\] + b\[1\]/// res\[2\] = a\[2\] + b\[2\]/// res\[3\] = a\[3\] + b\[3\]__qsub8/// Saturating two 8-bit integer subtraction/// res\[0\] = a\[0\] - b\[0\]/// res\[1\] = a\[1\] - b\[1\]/// res\[2\] = a\[2\] - b\[2\]/// res\[3\] = a\[3\] - b\[3\]__qsub16/// Saturating two 16-bit integer subtraction/// Returns the 16-bit signed equivalent of__qadd16/// Saturating two 16-bit integer additions__qasx/// Returns the 16-bit signed saturated equivalent of/// res\[0\] = a\[0\] - b\[1\]/// res\[1\] = a\[1\] + b\[0\]__qsax/// res\[0\] = a\[0\] + b\[1\]/// res\[1\] = a\[1\] - b\[0\]__sadd16/// and the GE bits of the APSR are set.__sadd8/// Returns the 8-bit signed saturated equivalent of__smlad/// Dual 16-bit Signed Multiply with Addition of products/// and 32-bit accumulation./// res = a\[0\] * b\[0\] + a\[1\] * b\[1\] + c__smlsd/// Dual 16-bit Signed Multiply with Subtraction  of products/// and 32-bit accumulation and overflow detection./// res = a\[0\] * b\[0\] - a\[1\] * b\[1\] + c__sasx__sel/// Select bytes from each operand according to APSR GE flags/// Returns the equivalent of/// res\[0\] = GE\[0\] ? a\[0\] : b\[0\]/// res\[1\] = GE\[1\] ? a\[1\] : b\[1\]/// res\[2\] = GE\[2\] ? a\[2\] : b\[2\]/// res\[3\] = GE\[3\] ? a\[3\] : b\[3\]/// where GE are bits of APSR__shadd8/// Signed halving parallel byte-wise addition./// res\[0\] = (a\[0\] + b\[0\]) / 2/// res\[1\] = (a\[1\] + b\[1\]) / 2/// res\[2\] = (a\[2\] + b\[2\]) / 2/// res\[3\] = (a\[3\] + b\[3\]) / 2__shadd16/// Signed halving parallel halfword-wise addition.__shsub8/// Signed halving parallel byte-wise subtraction./// res\[0\] = (a\[0\] - b\[0\]) / 2/// res\[1\] = (a\[1\] - b\[1\]) / 2/// res\[2\] = (a\[2\] - b\[2\]) / 2/// res\[3\] = (a\[3\] - b\[3\]) / 2__usub8/// Inserts a `USUB8` instruction./// Returns the 8-bit unsigned equivalent of/// res\[0\] = a\[0\] - a\[0\]/// res\[1\] = a\[1\] - a\[1\]/// res\[2\] = a\[2\] - a\[2\]/// res\[3\] = a\[3\] - a\[3\]/// where \[0\] is the lower 8 bits and \[3\] is the upper 8 bits./// The GE bits of the APSR are set.__ssub8/// Inserts a `SSUB8` instruction.__shsub16/// Signed halving parallel halfword-wise subtraction.__smuad/// Signed Dual Multiply Add./// res = a\[0\] * b\[0\] + a\[1\] * b\[1\]/// and sets the Q flag if overflow occurs on the addition.__smuadx/// Signed Dual Multiply Add Reversed./// res = a\[0\] * b\[1\] + a\[1\] * b\[0\]__smusd/// Signed Dual Multiply Subtract./// res = a\[0\] * b\[0\] - a\[1\] * b\[1\]__smusdx/// Signed Dual Multiply Subtract Reversed./// res = a\[0\] * b\[1\] - a\[1\] * b\[0\]__usad8/// Sum of 8-bit absolute differences./// res = abs(a\[0\] - b\[0\]) + abs(a\[1\] - b\[1\]) +\///          (a\[2\] - b\[2\]) + (a\[3\] - b\[3\])__usada8/// Sum of 8-bit absolute differences and constant.///          (a\[2\] - b\[2\]) + (a\[3\] - b\[3\]) + cqadd8qsub8qadd16qsub16qasxqsaxsadd16sadd8sasxsmladsmlsdshadd8shadd16shsub8ssub8usub8shsub16smuadsmuadxsmusdsmusdxusad8usad8a//! - Section 8.5 "32-bit SIMD intrinsics" of ACLE//! Intrinsics that could live here//! - \[x\] __sel//! - \[ \] __ssat16//! - \[ \] __usat16//! - \[ \] __sxtab16//! - \[ \] __sxtb16//! - \[ \] __uxtab16//! - \[ \] __uxtb16//! - \[x\] __qadd8//! - \[x\] __qsub8//! - \[x\] __sadd8//! - \[x\] __shadd8//! - \[x\] __shsub8//! - \[x\] __ssub8//! - \[ \] __uadd8//! - \[ \] __uhadd8//! - \[ \] __uhsub8//! - \[ \] __uqadd8//! - \[ \] __uqsub8//! - \[x\] __usub8//! - \[x\] __usad8//! - \[x\] __usada8//! - \[x\] __qadd16//! - \[x\] __qasx//! - \[x\] __qsax//! - \[x\] __qsub16//! - \[x\] __sadd16//! - \[x\] __sasx//! - \[x\] __shadd16//! - \[ \] __shasx//! - \[ \] __shsax//! - \[x\] __shsub16//! - \[ \] __ssax//! - \[ \] __ssub16//! - \[ \] __uadd16//! - \[ \] __uasx//! - \[ \] __uhadd16//! - \[ \] __uhasx//! - \[ \] __uhsax//! - \[ \] __uhsub16//! - \[ \] __uqadd16//! - \[ \] __uqasx//! - \[x\] __uqsax//! - \[ \] __uqsub16//! - \[ \] __usax//! - \[ \] __usub16//! - \[x\] __smlad//! - \[ \] __smladx//! - \[ \] __smlald//! - \[ \] __smlaldx//! - \[x\] __smlsd//! - \[ \] __smlsdx//! - \[ \] __smlsld//! - \[ \] __smlsldx//! - \[x\] __smuad//! - \[x\] __smuadx//! - \[x\] __smusd//! - \[x\] __smusdxSY/// Full system is the required shareability domain, reads and writes are the/// required access typesdmb_dsb__isbIsb//! Access types available on all architectures__dmbDmb__dsbDsb// Reference: ARM11 MPCore Processor Technical Reference Manual (ARM DDI 0360E) Section 3.5 "Summary// of CP15 instructions"cp15// CP15 instruction// Dedicated instructionsnot_mclass/// Generates a DMB (data memory barrier) instruction or equivalent CP15 instruction./// DMB ensures the observed ordering of memory accesses. Memory accesses of the specified type/// issued before the DMB are guaranteed to be observed (in the specified scope) before memory/// accesses issued after the DMB./// For example, DMB should be used between storing data, and updating a flag variable that makes/// that data available to another core./// The __dmb() intrinsic also acts as a compiler memory barrier of the appropriate type./// Generates a DSB (data synchronization barrier) instruction or equivalent CP15 instruction./// DSB ensures the completion of memory accesses. A DSB behaves as the equivalent DMB and has/// additional properties. After a DSB instruction completes, all memory accesses of the specified/// type issued before the DSB are guaranteed to have completed./// The __dsb() intrinsic also acts as a compiler memory barrier of the appropriate type./// Generates an ISB (instruction synchronization barrier) instruction or equivalent CP15/// This instruction flushes the processor pipeline fetch buffers, so that following instructions/// are fetched from cache or memory./// An ISB is needed after some system maintenance operations. An ISB is also needed before/// transferring control to code that has been loaded or modified in memory, for example by an/// overlay mechanism or just-in-time code generator.  (Note that if instruction and data caches are/// separate, privileged cache maintenance operations would be needed in order to unify the caches.)/// The only supported argument for the __isb() intrinsic is 15, corresponding to the SY (full/// system) scope of the ISB instruction.dmbdsbisb// See Section 7.3  Memory barriers of ACLEISHISHSTISHLDNSHSTNSHLDOSHOSHSTOSHLD// we put these in a module to prevent weirdness with glob re-exports// Reference: Section 7.4 "Hints" of ACLE/// Full system is the required shareability domain, writes are the required/// access type/// Inner Shareable is the required shareability domain, reads and writes are/// the required access types/// Inner Shareable is the required shareability domain, writes are the required/// Non-shareable is the required shareability domain, reads and writes are the/// Non-shareable is the required shareability domain, writes are the required/// Outer Shareable is the required shareability domain, reads and writes are/// Outer Shareable is the required shareability domain, writes are the required//! Access types available on v7 and v8 but not on v7(E)-M or v8-M/// Full system is the required shareability domain, reads are the required/// Inner Shareable is the required shareability domain, reads are the required/// Non-shareable is the required shareability domain, reads are the required/// Outer Shareable is the required shareability domain, reads are the required__wfi/// Generates a WFI (wait for interrupt) hint instruction, or nothing./// The WFI instruction allows (but does not require) the processor to enter a/// low-power state until one of a number of asynchronous events occurs.// Section 10.1 of ACLE says that the supported arches are: 8, 6K, 6-M// LLVM says "instruction requires: armv6k"__wfe/// Generates a WFE (wait for event) hint instruction, or nothing./// The WFE instruction allows (but does not require) the processor to enter a/// low-power state until some event occurs such as a SEV being issued by/// another processor.__sev/// Generates a SEV (send a global event) hint instruction./// This causes an event to be signaled to all processors in a multiprocessor/// system. It is a NOP on a uniprocessor system.// Section 10.1 of ACLE says that the supported arches are: 8, 6K, 6-M, 7-M__sevl/// Generates a send a local event hint instruction./// This causes an event to be signaled to only the processor executing this/// instruction. In a multiprocessor system, it is not required to affect the/// other processors.// LLVM says "instruction requires: armv8"__yield/// Generates a YIELD hint instruction./// This enables multithreading software to indicate to the hardware that it is/// performing a task, for example a spin-lock, that could be swapped out to/// improve overall system performance.__nop/// Generates an unspecified no-op instruction./// Note that not all architectures provide a distinguished NOP instruction. On/// those that do, it is unspecified whether this intrinsic generates it or/// another instruction. It is not guaranteed that inserting this instruction/// will increase execution time.HINT_NOP// from LLVM 7.0.1's lib/Target/ARM/{ARMInstrThumb,ARMInstrInfo,ARMInstrThumb2}.tdHINT_YIELDHINT_WFEHINT_WFIHINT_SEVHINT_SEVL// # References// - Section 7.4 "Hints" of ACLE// - Section 7.7 "NOP" of ACLE// 8, 7 and 6-M are supported via dedicated instructions like DMB. All other arches are supported// via CP15 instructions. See Section 10.1 of ACLE//! ARM C Language Extensions (ACLE)//! # Developer notes//! Below is a list of built-in targets that are representative of the different ARM//! architectures; the list includes the `target_feature`s they possess.//! - `armv4t-unknown-linux-gnueabi` - **ARMv4** - `+v4t`//! - `armv5te-unknown-linux-gnueabi` - **ARMv5TE** - `+v4t +v5te`//! - `arm-unknown-linux-gnueabi` - **ARMv6** - `+v4t +v5te +v6`//! - `thumbv6m-none-eabi` - **ARMv6-M** - `+v4t +v5te +v6 +thumb-mode +mclass`//! - `armv7-unknown-linux-gnueabihf` - **ARMv7-A** - `+v4t +v5te +v6 +v6k +v6t2 +v7 +dsp +thumb2 +aclass`//! - `armv7r-none-eabi` - **ARMv7-R** - `+v4t +v5te +v6 +v6k +v6t2  +v7 +dsp +thumb2 +rclass`//! - `thumbv7m-none-eabi` - **ARMv7-M** - `+v4t +v5te +v6 +v6k +v6t2 +v7 +thumb2 +thumb-mode +mclass`//! - `thumbv7em-none-eabi` - **ARMv7E-M** - `+v4t +v5te +v6 +v6k +v6t2 +v7 +dsp +thumb2 +thumb-mode +mclass`//! - `thumbv8m.main-none-eabi` - **ARMv8-M** - `+v4t +v5te +v6 +v6k +v6t2 +v7 +thumb2 +thumb-mode +mclass`//! - `armv8r-none-eabi` - **ARMv8-R** - `+v4t +v5te +v6 +v6k +v6t2 +v7 +v8 +thumb2 +rclass`//! - `aarch64-unknown-linux-gnu` - **ARMv8-A (AArch64)** - `+fp +neon`//! Section 10.1 of ACLE says://! - "In the sequence of Arm architectures { v5, v5TE, v6, v6T2, v7 } each architecture includes//!   its predecessor's instruction set."//! - "In the sequence of Thumb-only architectures { v6-M, v7-M, v7E-M } each architecture includes//! From that info and from looking at how LLVM features work (using custom targets) we can identify//! features that are subsets of others://! Legend: `a < b` reads as "`a` is a subset of `b`"; this means that if `b` is enabled then `a` is//! enabled as well.//! - `v4t < v5te < v6 < v6k < v6t2 < v7 < v8`//! - `v6 < v8m < v6t2`//! - `v7 < v8m.main`//! *NOTE*: Section 5.4.7 of ACLE says://! - "__ARM_FEATURE_DSP is defined to 1 if the DSP (v5E) instructions are supported and the//!   intrinsics defined in Saturating intrinsics are available."//! This does *not* match how LLVM uses the '+dsp' feature; this feature is not set for v5te//! targets so we have to work around this difference.//! - [ACLE Q2 2018](https://developer.arm.com/docs/101028/latest)// Only for 'neon' submodule"CRC32 single round checksum for bytes (8 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32b)"__crc32b"CRC32-C single round checksum for bytes (8 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32cb)"__crc32cb"CRC32-C single round checksum for bytes (16 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32ch)"__crc32ch"CRC32-C single round checksum for bytes (32 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32cw)"__crc32cw"CRC32 single round checksum for bytes (16 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32h)"__crc32h"CRC32 single round checksum for bytes (32 bits).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32w)"__crc32w"Signed Add and Accumulate Long Pairwise.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadal_s8)"priv_vpadal_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadalq_s8)"priv_vpadalq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadal_s16)"priv_vpadal_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadalq_s16)"priv_vpadalq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadal_s32)"priv_vpadal_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadalq_s32)"priv_vpadalq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadal_u8)"priv_vpadal_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadalq_u8)"priv_vpadalq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadal_u16)"priv_vpadal_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadalq_u16)"priv_vpadalq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadal_u32)"priv_vpadal_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/priv_vpadalq_u32)"priv_vpadalq_u32"Absolute difference and accumulate (64-bit)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_s16)"vaba_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_s32)"vaba_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_s8)"vaba_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_u16)"vaba_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_u32)"vaba_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_u8)"vaba_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_s8)"vabal_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_s16)"vabal_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_s32)"vabal_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_u8)"vabal_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_u16)"vabal_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_u32)"vabal_u32"Absolute difference and accumulate (128-bit)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_s16)"vabaq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_s32)"vabaq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_s8)"vabaq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_u16)"vabaq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_u32)"vabaq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_u8)"vabaq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_f16)"vabd_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_f16)"vabdq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_f32)"vabd_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_f32)"vabdq_f32"Absolute difference between the arguments""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_s8)"vabd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_s8)"vabdq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_s16)"vabd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_s16)"vabdq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_s32)"vabd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_s32)"vabdq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_u8)"vabd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_u8)"vabdq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_u16)"vabd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_u16)"vabdq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_u32)"vabd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_u32)"vabdq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_s8)"vabdl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_s16)"vabdl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_s32)"vabdl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_u8)"vabdl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_u16)"vabdl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_u32)"vabdl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_f16)"vabs_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_f16)"vabsq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_f32)"vabs_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_f32)"vabsq_f32"Absolute value (wrapping).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s8)"vabs_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s8)"vabsq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s16)"vabs_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s16)"vabsq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s32)"vabs_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s32)"vabsq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsh_f16)"vabsh_f16"Floating-point Add (vector).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_f16)"vadd_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_f16)"vaddq_f16"Vector add.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s16)"vadd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s32)"vadd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s8)"vadd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u16)"vadd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u32)"vadd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u8)"vadd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s16)"vaddq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s32)"vaddq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s64)"vaddq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s8)"vaddq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u16)"vaddq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u32)"vaddq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u64)"vaddq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u8)"vaddq_u8"Bitwise exclusive OR""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_p8)"vadd_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p8)"vaddq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_p16)"vadd_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p16)"vaddq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_p64)"vadd_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p64)"vaddq_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddh_f16)"vaddh_f16"Add returning High Narrow (high half).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_s16)"vaddhn_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_s32)"vaddhn_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_s64)"vaddhn_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_u16)"vaddhn_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_u32)"vaddhn_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_u64)"vaddhn_high_u64"Add returning High Narrow.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_s16)"vaddhn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_s32)"vaddhn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_s64)"vaddhn_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_u16)"vaddhn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_u32)"vaddhn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_u64)"vaddhn_u64"Signed Add Long (vector, high half).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_s16)"vaddl_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_s32)"vaddl_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_s8)"vaddl_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_u16)"vaddl_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_u32)"vaddl_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_u8)"vaddl_high_u8"Add Long (vector).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_s16)"vaddl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_s32)"vaddl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_s8)"vaddl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_u16)"vaddl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_u32)"vaddl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_u8)"vaddl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p128)"vaddq_p128"Add Wide (high half).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_s16)"vaddw_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_s32)"vaddw_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_s8)"vaddw_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_u16)"vaddw_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_u32)"vaddw_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_u8)"vaddw_high_u8"Add Wide""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_s16)"vaddw_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_s32)"vaddw_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_s8)"vaddw_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_u16)"vaddw_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_u32)"vaddw_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_u8)"vaddw_u8"AES single round encryption.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaesdq_u8)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaeseq_u8)""AES inverse mix columns.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaesimcq_u8)""AES mix columns.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaesmcq_u8)""Vector bitwise and""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s8)"vand_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s8)"vandq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s16)"vand_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s16)"vandq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s32)"vand_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s32)"vandq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s64)"vand_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s64)"vandq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u8)"vand_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u8)"vandq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u16)"vand_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u16)"vandq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u32)"vand_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u32)"vandq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u64)"vand_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u64)"vandq_u64"Vector bitwise bit clear.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s16)"vbic_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s32)"vbic_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s64)"vbic_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s8)"vbic_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s16)"vbicq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s32)"vbicq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s64)"vbicq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s8)"vbicq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u16)"vbic_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u32)"vbic_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u64)"vbic_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u8)"vbic_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u16)"vbicq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u32)"vbicq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u64)"vbicq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u8)"vbicq_u8"Bitwise Select.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_f16)"vbsl_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_f16)"vbslq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_f32)"vbsl_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_p16)"vbsl_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_p8)"vbsl_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s16)"vbsl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s32)"vbsl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s64)"vbsl_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s8)"vbsl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_f32)"vbslq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_p16)"vbslq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_p8)"vbslq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s16)"vbslq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s32)"vbslq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s64)"vbslq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s8)"vbslq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u16)"vbsl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u32)"vbsl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u64)"vbsl_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u8)"vbsl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u16)"vbslq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u32)"vbslq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u64)"vbslq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u8)"vbslq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcage_f16)"vcage_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcageq_f16)"vcageq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcage_f32)"vcage_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcageq_f32)"vcageq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagt_f16)"vcagt_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagtq_f16)"vcagtq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagt_f32)"vcagt_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagtq_f32)"vcagtq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcale_f16)"vcale_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaleq_f16)"vcaleq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcale_f32)"vcale_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaleq_f32)"vcaleq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalt_f16)"vcalt_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaltq_f16)"vcaltq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalt_f32)"vcalt_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaltq_f32)"vcaltq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_f16)"vceq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_f16)"vceqq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_f32)"vceq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_f32)"vceqq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s8)"vceq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s8)"vceqq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s16)"vceq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s16)"vceqq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s32)"vceq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s32)"vceqq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u8)"vceq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u8)"vceqq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u16)"vceq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u16)"vceqq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u32)"vceq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u32)"vceqq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_p8)"vceq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_p8)"vceqq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_f16)"vcge_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_f16)"vcgeq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_f32)"vcge_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_f32)"vcgeq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s8)"vcge_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s8)"vcgeq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s16)"vcge_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s16)"vcgeq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s32)"vcge_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s32)"vcgeq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u8)"vcge_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u8)"vcgeq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u16)"vcge_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u16)"vcgeq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u32)"vcge_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u32)"vcgeq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgez_f16)"vcgez_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgezq_f16)"vcgezq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_f16)"vcgt_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_f16)"vcgtq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_f32)"vcgt_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_f32)"vcgtq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s8)"vcgt_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s8)"vcgtq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s16)"vcgt_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s16)"vcgtq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s32)"vcgt_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s32)"vcgtq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u8)"vcgt_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u8)"vcgtq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u16)"vcgt_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u16)"vcgtq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u32)"vcgt_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u32)"vcgtq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtz_f16)"vcgtz_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtzq_f16)"vcgtzq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_f16)"vcle_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_f16)"vcleq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_f32)"vcle_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_f32)"vcleq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s8)"vcle_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s8)"vcleq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s16)"vcle_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s16)"vcleq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s32)"vcle_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s32)"vcleq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u8)"vcle_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u8)"vcleq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u16)"vcle_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u16)"vcleq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u32)"vcle_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u32)"vcleq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclez_f16)"vclez_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclezq_f16)"vclezq_f16"Count leading sign bits""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_s8)"vcls_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_s8)"vclsq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_s16)"vcls_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_s16)"vclsq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_s32)"vcls_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_s32)"vclsq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_u8)"vcls_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_u8)"vclsq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_u16)"vcls_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_u16)"vclsq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_u32)"vcls_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_u32)"vclsq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_f16)"vclt_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_f16)"vcltq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_f32)"vclt_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_f32)"vcltq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s8)"vclt_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s8)"vcltq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s16)"vclt_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s16)"vcltq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s32)"vclt_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s32)"vcltq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u8)"vclt_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u8)"vcltq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u16)"vclt_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u16)"vcltq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u32)"vclt_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u32)"vcltq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltz_f16)"vcltz_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltzq_f16)"vcltzq_f16"Count leading zero bits""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_s8)"vclz_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_s8)"vclzq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_s16)"vclz_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_s16)"vclzq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_s32)"vclz_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_s32)"vclzq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_u16)"vclz_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_u16)"vclzq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_u32)"vclz_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_u32)"vclzq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_u8)"vclz_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_u8)"vclzq_u8"Population count per byte.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcnt_s8)"vcnt_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcntq_s8)"vcntq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcnt_u8)"vcnt_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcntq_u8)"vcntq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcnt_p8)"vcnt_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcntq_p8)"vcntq_p8"Join two smaller vectors into a single larger vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_f16)"vcombine_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_f32)"vcombine_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_s8)"vcombine_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_s16)"vcombine_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_s32)"vcombine_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_s64)"vcombine_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_u8)"vcombine_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_u16)"vcombine_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_u32)"vcombine_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_u64)"vcombine_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_p8)"vcombine_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_p16)"vcombine_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_p64)"vcombine_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_f16)"vcreate_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_f32)"vcreate_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_s8)"vcreate_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_s16)"vcreate_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_s32)"vcreate_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_s64)"vcreate_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_u8)"vcreate_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_u16)"vcreate_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_u32)"vcreate_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_u64)"vcreate_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_p8)"vcreate_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_p16)"vcreate_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcreate_p64)"vcreate_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f16_f32)"vcvt_f16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f16_s16)"vcvt_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f16_s16)"vcvtq_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f16_u16)"vcvt_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f16_u16)"vcvtq_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_f16)"vcvt_f32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_s32)"vcvt_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f32_s32)"vcvtq_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_u32)"vcvt_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f32_u32)"vcvtq_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_f16_s16)"vcvt_n_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_f16_s16)"vcvtq_n_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_f16_u16)"vcvt_n_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_f16_u16)"vcvtq_n_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_f32_s32)"vcvt_n_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_f32_s32)"vcvtq_n_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_f32_u32)"vcvt_n_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_f32_u32)"vcvtq_n_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_s16_f16)"vcvt_n_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_s16_f16)"vcvtq_n_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_s32_f32)"vcvt_n_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_s32_f32)"vcvtq_n_s32_f32"Fixed-point convert to unsigned fixed-point, rounding toward zero""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_u16_f16)"vcvt_n_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_u16_f16)"vcvtq_n_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_n_u32_f32)"vcvt_n_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_n_u32_f32)"vcvtq_n_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_s16_f16)"vcvt_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_s16_f16)"vcvtq_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_s32_f32)"vcvt_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_s32_f32)"vcvtq_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_u16_f16)"vcvt_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_u16_f16)"vcvtq_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_u32_f32)"vcvt_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_u32_f32)"vcvtq_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdot_lane_s32)"vdot_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdotq_lane_s32)"vdotq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdot_lane_u32)"vdot_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdotq_lane_u32)"vdotq_lane_u32"Dot product arithmetic (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdot_s32)"vdot_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdotq_s32)"vdotq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdot_u32)"vdot_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdotq_u32)"vdotq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_f16)"vdup_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_f16)"vdupq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_f32)"vdup_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s32)"vdup_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u32)"vdup_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_f32)"vdupq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s32)"vdupq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u32)"vdupq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_p16)"vdup_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s16)"vdup_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u16)"vdup_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_p16)"vdupq_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s16)"vdupq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u16)"vdupq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_p8)"vdup_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s8)"vdup_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u8)"vdup_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_p8)"vdupq_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s8)"vdupq_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u8)"vdupq_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s64)"vdup_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u64)"vdup_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_f16)"vdup_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_f16)"vdupq_laneq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_f32)"vdup_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s32)"vdup_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u32)"vdup_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_f32)"vdupq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_s32)"vdupq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_u32)"vdupq_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_p16)"vdup_laneq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s16)"vdup_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u16)"vdup_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_p16)"vdupq_laneq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_s16)"vdupq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_u16)"vdupq_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_p8)"vdup_laneq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s8)"vdup_laneq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u8)"vdup_laneq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_p8)"vdupq_laneq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_s8)"vdupq_laneq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_u8)"vdupq_laneq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s64)"vdup_laneq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u64)"vdup_laneq_u64"Create a new vector with all lanes set to a value""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_f16)"vdup_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_f16)"vdupq_n_f16"Duplicate vector element to vector or scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_f32)"vdup_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_p16)"vdup_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_p8)"vdup_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s16)"vdup_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s32)"vdup_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s64)"vdup_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s8)"vdup_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u16)"vdup_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u32)"vdup_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u64)"vdup_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u8)"vdup_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_f32)"vdupq_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_p16)"vdupq_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_p8)"vdupq_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s16)"vdupq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s32)"vdupq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s64)"vdupq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s8)"vdupq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u16)"vdupq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u32)"vdupq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u64)"vdupq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u8)"vdupq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_f32_vfp4)"vdup_n_f32_vfp4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_f32_vfp4)"vdupq_n_f32_vfp4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s64)"vdupq_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u64)"vdupq_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_s64)"vdupq_laneq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_u64)"vdupq_laneq_u64"Vector bitwise exclusive or (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s8)"veor_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s8)"veorq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s16)"veor_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s16)"veorq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s32)"veor_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s32)"veorq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s64)"veor_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s64)"veorq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u8)"veor_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u8)"veorq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u16)"veor_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u16)"veorq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u32)"veor_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u32)"veorq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u64)"veor_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u64)"veorq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_f16)"vext_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_f32)"vext_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s32)"vext_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_u32)"vext_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s64)"vext_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_u64)"vext_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s8)"vext_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s16)"vextq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_u8)"vext_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_u16)"vextq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_p8)"vext_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_p16)"vextq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_f16)"vextq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_f32)"vextq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s16)"vext_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s32)"vextq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_u16)"vext_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_u32)"vextq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_p16)"vext_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s64)"vextq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_u64)"vextq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s8)"vextq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_u8)"vextq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_p8)"vextq_p8"Floating-point fused Multiply-Add to accumulator (vector)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_f16)"vfma_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_f16)"vfmaq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_f32)"vfma_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_n_f32)"vfma_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_n_f32)"vfmaq_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_f16)"vfms_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_f16)"vfmsq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_f32)"vfms_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_f32)"vfmsq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_n_f32)"vfms_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_n_f32)"vfmsq_n_f32"Duplicate vector element to vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_f16)"vget_high_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_f16)"vget_low_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_p16)"vget_high_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_p8)"vget_high_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_s16)"vget_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_s32)"vget_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_s8)"vget_high_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_u16)"vget_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_u32)"vget_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_u8)"vget_high_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_s64)"vget_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_u64)"vget_high_u64"Duplicate vector element to scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_f16)"vget_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_f16)"vgetq_lane_f16"Move vector element to general-purpose register""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_f32)"vget_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_p16)"vget_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_p8)"vget_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s16)"vget_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s32)"vget_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s8)"vget_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u16)"vget_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u32)"vget_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u8)"vget_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_f32)"vgetq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_p16)"vgetq_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_p64)"vgetq_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_p8)"vgetq_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s16)"vgetq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s32)"vgetq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s64)"vgetq_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s8)"vgetq_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u16)"vgetq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u32)"vgetq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u64)"vgetq_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u8)"vgetq_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_p64)"vget_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s64)"vget_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u64)"vget_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_p16)"vget_low_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_p8)"vget_low_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_s16)"vget_low_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_s32)"vget_low_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_s8)"vget_low_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_u16)"vget_low_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_u32)"vget_low_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_u8)"vget_low_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_s64)"vget_low_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_u64)"vget_low_u64"Halving add""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_s8)"vhadd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_s8)"vhaddq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_s16)"vhadd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_s16)"vhaddq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_s32)"vhadd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_s32)"vhaddq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_u8)"vhadd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_u8)"vhaddq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_u16)"vhadd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_u16)"vhaddq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_u32)"vhadd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_u32)"vhaddq_u32"Signed halving subtract""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_s16)"vhsub_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_s16)"vhsubq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_s32)"vhsub_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_s32)"vhsubq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_s8)"vhsub_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_s8)"vhsubq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_u8)"vhsub_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_u8)"vhsubq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_u16)"vhsub_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_u16)"vhsubq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_u32)"vhsub_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_u32)"vhsubq_u32"Load one single-element structure and replicate to all lanes of one register""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_f16)"vld1_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_f16)"vld1q_dup_f16"Load one single-element structure and Replicate to all lanes (of one register).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_f32)"vld1_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_p16)"vld1_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_p8)"vld1_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s16)"vld1_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s32)"vld1_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s8)"vld1_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u16)"vld1_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u32)"vld1_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u8)"vld1_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_f32)"vld1q_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_p16)"vld1q_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_p8)"vld1q_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s16)"vld1q_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s32)"vld1q_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s64)"vld1q_dup_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s8)"vld1q_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u16)"vld1q_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u32)"vld1q_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u64)"vld1q_dup_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u8)"vld1q_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_p64)"vld1_dup_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s64)"vld1_dup_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u64)"vld1_dup_u64"Load multiple single-element structures to one, two, three, or four registers.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f16_x2)"vld1_f16_x2float16x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f16_x3)"vld1_f16_x3float16x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f16_x4)"vld1_f16_x4float16x4x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f16_x2)"vld1q_f16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f16_x3)"vld1q_f16_x3float16x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f16_x4)"vld1q_f16_x4float16x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f32_x2)"vld1_f32_x2float32x2x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f32_x3)"vld1_f32_x3float32x2x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f32_x4)"vld1_f32_x4float32x2x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f32_x2)"vld1q_f32_x2float32x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f32_x3)"vld1q_f32_x3float32x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f32_x4)"vld1q_f32_x4float32x4x4_t"Load one single-element structure to one lane of one register""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_f16)"vld1_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_f16)"vld1q_lane_f16"Load one single-element structure to one lane of one register.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_f32)"vld1_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_p16)"vld1_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_p8)"vld1_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s16)"vld1_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s32)"vld1_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s64)"vld1_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s8)"vld1_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u16)"vld1_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u32)"vld1_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u64)"vld1_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u8)"vld1_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_f32)"vld1q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_p16)"vld1q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_p8)"vld1q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s16)"vld1q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s32)"vld1q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s64)"vld1q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s8)"vld1q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u16)"vld1q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u32)"vld1q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u64)"vld1q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u8)"vld1q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_p64)"vld1_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_p64)"vld1q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p64_x2)"vld1_p64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p64_x3)"vld1_p64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p64_x4)"vld1_p64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p64_x2)"vld1q_p64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p64_x3)"vld1q_p64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p64_x4)"vld1q_p64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s8_x2)"vld1_s8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s8_x3)"vld1_s8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s8_x4)"vld1_s8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s8_x2)"vld1q_s8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s8_x3)"vld1q_s8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s8_x4)"vld1q_s8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s16_x2)"vld1_s16_x2int16x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s16_x3)"vld1_s16_x3int16x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s16_x4)"vld1_s16_x4int16x4x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s16_x2)"vld1q_s16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s16_x3)"vld1q_s16_x3int16x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s16_x4)"vld1q_s16_x4int16x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s32_x2)"vld1_s32_x2int32x2x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s32_x3)"vld1_s32_x3int32x2x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s32_x4)"vld1_s32_x4int32x2x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s32_x2)"vld1q_s32_x2int32x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s32_x3)"vld1q_s32_x3int32x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s32_x4)"vld1q_s32_x4int32x4x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s64_x2)"vld1_s64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s64_x3)"vld1_s64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s64_x4)"vld1_s64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s64_x2)"vld1q_s64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s64_x3)"vld1q_s64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s64_x4)"vld1q_s64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u8_x2)"vld1_u8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u8_x3)"vld1_u8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u8_x4)"vld1_u8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u8_x2)"vld1q_u8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u8_x3)"vld1q_u8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u8_x4)"vld1q_u8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u16_x2)"vld1_u16_x2uint16x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u16_x3)"vld1_u16_x3uint16x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u16_x4)"vld1_u16_x4uint16x4x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u16_x2)"vld1q_u16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u16_x3)"vld1q_u16_x3uint16x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u16_x4)"vld1q_u16_x4uint16x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u32_x2)"vld1_u32_x2uint32x2x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u32_x3)"vld1_u32_x3uint32x2x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u32_x4)"vld1_u32_x4uint32x2x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u32_x2)"vld1q_u32_x2uint32x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u32_x3)"vld1q_u32_x3uint32x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u32_x4)"vld1q_u32_x4uint32x4x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u64_x2)"vld1_u64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u64_x3)"vld1_u64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u64_x4)"vld1_u64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u64_x2)"vld1q_u64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u64_x3)"vld1q_u64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u64_x4)"vld1q_u64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p8_x2)"vld1_p8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p8_x3)"vld1_p8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p8_x4)"vld1_p8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p8_x2)"vld1q_p8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p8_x3)"vld1q_p8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p8_x4)"vld1q_p8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p16_x2)"vld1_p16_x2poly16x4x2_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p16_x3)"vld1_p16_x3poly16x4x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_p16_x4)"vld1_p16_x4poly16x4x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p16_x2)"vld1q_p16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p16_x3)"vld1q_p16_x3poly16x8x3_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_p16_x4)"vld1q_p16_x4poly16x8x4_t"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_v1i64)"vld1_v1i64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_v2f32)"vld1_v2f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_v2i32)"vld1_v2i32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_v4i16)"vld1_v4i16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_v8i8)"vld1_v8i8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_v16i8)"vld1q_v16i8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_v2i64)"vld1q_v2i64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_v4f32)"vld1q_v4f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_v4i32)"vld1q_v4i32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_v8i16)"vld1q_v8i16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_v4f16)"vld1_v4f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_v8f16)"vld1q_v8f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_p64)"vld1q_dup_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_f16)"vld2_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_f16)"vld2q_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_f32)"vld2_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_f32)"vld2q_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_s8)"vld2_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_s8)"vld2q_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_s16)"vld2_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_s16)"vld2q_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_s32)"vld2_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_s32)"vld2q_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_p64)"vld2_dup_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_s64)"vld2_dup_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_u64)"vld2_dup_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_u8)"vld2_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_u8)"vld2q_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_u16)"vld2_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_u16)"vld2q_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_u32)"vld2_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_u32)"vld2q_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_p8)"vld2_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_p8)"vld2q_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_dup_p16)"vld2_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_dup_p16)"vld2q_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_f16)"vld2_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_f16)"vld2q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_f32)"vld2_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_f32)"vld2q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_s8)"vld2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_s8)"vld2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_s16)"vld2_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_s16)"vld2q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_s32)"vld2_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_s32)"vld2q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_f16)"vld2_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_f16)"vld2q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_f32)"vld2_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_f32)"vld2q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_s8)"vld2_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_s16)"vld2_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_s16)"vld2q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_s32)"vld2_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_s32)"vld2q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_u8)"vld2_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_u16)"vld2_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_u16)"vld2q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_u32)"vld2_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_u32)"vld2q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_p8)"vld2_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_lane_p16)"vld2_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_lane_p16)"vld2q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_p64)"vld2_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_s64)"vld2_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_u64)"vld2_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_u8)"vld2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_u8)"vld2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_u16)"vld2_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_u16)"vld2q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_u32)"vld2_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_u32)"vld2q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_p8)"vld2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_p8)"vld2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2_p16)"vld2_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld2q_p16)"vld2q_p16"Load single 3-element structure and replicate to all lanes of two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_f16)"vld3_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_f16)"vld3q_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_f32)"vld3_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_f32)"vld3q_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_s8)"vld3_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_s8)"vld3q_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_s16)"vld3_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_s16)"vld3q_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_s32)"vld3_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_s32)"vld3q_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_s64)"vld3_dup_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_p64)"vld3_dup_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_u64)"vld3_dup_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_u8)"vld3_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_u8)"vld3q_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_u16)"vld3_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_u16)"vld3q_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_u32)"vld3_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_u32)"vld3q_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_p8)"vld3_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_p8)"vld3q_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_dup_p16)"vld3_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_dup_p16)"vld3q_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_f16)"vld3_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_f16)"vld3q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_f32)"vld3_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_f32)"vld3q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_s8)"vld3_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_s8)"vld3q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_s16)"vld3_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_s16)"vld3q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_s32)"vld3_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_s32)"vld3q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_f16)"vld3_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_f16)"vld3q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_f32)"vld3_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_f32)"vld3q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_s8)"vld3_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_s16)"vld3_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_s16)"vld3q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_s32)"vld3_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_s32)"vld3q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_u8)"vld3_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_u16)"vld3_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_u16)"vld3q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_u32)"vld3_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_u32)"vld3q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_p8)"vld3_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_lane_p16)"vld3_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_lane_p16)"vld3q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_p64)"vld3_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_s64)"vld3_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_u64)"vld3_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_u8)"vld3_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_u8)"vld3q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_u16)"vld3_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_u16)"vld3q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_u32)"vld3_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_u32)"vld3q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_p8)"vld3_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_p8)"vld3q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3_p16)"vld3_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld3q_p16)"vld3q_p16"Load single 4-element structure and replicate to all lanes of two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_f16)"vld4_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_f16)"vld4q_dup_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_f32)"vld4_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_f32)"vld4q_dup_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_s8)"vld4_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_s8)"vld4q_dup_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_s16)"vld4_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_s16)"vld4q_dup_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_s32)"vld4_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_s32)"vld4q_dup_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_s64)"vld4_dup_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_p64)"vld4_dup_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_u64)"vld4_dup_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_u8)"vld4_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_u8)"vld4q_dup_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_u16)"vld4_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_u16)"vld4q_dup_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_u32)"vld4_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_u32)"vld4q_dup_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_p8)"vld4_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_p8)"vld4q_dup_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_dup_p16)"vld4_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_dup_p16)"vld4q_dup_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_f16)"vld4_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_f16)"vld4q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_f32)"vld4_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_f32)"vld4q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_s8)"vld4_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_s8)"vld4q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_s16)"vld4_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_s16)"vld4q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_s32)"vld4_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_s32)"vld4q_s32"Load multiple 4-element structures to two registers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_f16)"vld4_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_f16)"vld4q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_f32)"vld4_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_f32)"vld4q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_s8)"vld4_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_s16)"vld4_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_s16)"vld4q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_s32)"vld4_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_s32)"vld4q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_u8)"vld4_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_u16)"vld4_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_u16)"vld4q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_u32)"vld4_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_u32)"vld4q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_p8)"vld4_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_lane_p16)"vld4_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_lane_p16)"vld4q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_p64)"vld4_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_s64)"vld4_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_u64)"vld4_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_u8)"vld4_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_u8)"vld4q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_u16)"vld4_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_u16)"vld4q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_u32)"vld4_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_u32)"vld4q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_p8)"vld4_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_p8)"vld4q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4_p16)"vld4_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld4q_p16)"vld4q_p16"Store SIMD&FP register (immediate offset)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vldrq_p128)"vldrq_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_f16)"vmax_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_f16)"vmaxq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_f32)"vmax_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_f32)"vmaxq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_s8)"vmax_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_s8)"vmaxq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_s16)"vmax_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_s16)"vmaxq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_s32)"vmax_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_s32)"vmaxq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_u8)"vmax_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_u8)"vmaxq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_u16)"vmax_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_u16)"vmaxq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_u32)"vmax_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_u32)"vmaxq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnm_f16)"vmaxnm_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmq_f16)"vmaxnmq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnm_f32)"vmaxnm_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmq_f32)"vmaxnmq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_f16)"vmin_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_f16)"vminq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_f32)"vmin_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_f32)"vminq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_s8)"vmin_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_s8)"vminq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_s16)"vmin_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_s16)"vminq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_s32)"vmin_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_s32)"vminq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_u8)"vmin_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_u8)"vminq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_u16)"vmin_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_u16)"vminq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_u32)"vmin_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_u32)"vminq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnm_f16)"vminnm_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmq_f16)"vminnmq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnm_f32)"vminnm_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmq_f32)"vminnmq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_f32)"vmla_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_f32)"vmlaq_f32"Vector multiply accumulate with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_f32)"vmla_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_f32)"vmla_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_f32)"vmlaq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_f32)"vmlaq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_s16)"vmla_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_u16)"vmla_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_s16)"vmla_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_u16)"vmla_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_s16)"vmlaq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_u16)"vmlaq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_s16)"vmlaq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_u16)"vmlaq_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_s32)"vmla_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_u32)"vmla_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_s32)"vmla_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_u32)"vmla_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_s32)"vmlaq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_u32)"vmlaq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_s32)"vmlaq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_u32)"vmlaq_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_f32)"vmla_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_f32)"vmlaq_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_s16)"vmla_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_s16)"vmlaq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_u16)"vmla_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_u16)"vmlaq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_s32)"vmla_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_s32)"vmlaq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_u32)"vmla_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_u32)"vmlaq_n_u32"Multiply-add to accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_s8)"vmla_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_s8)"vmlaq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_s16)"vmla_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_s16)"vmlaq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_s32)"vmla_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_s32)"vmlaq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_u8)"vmla_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_u8)"vmlaq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_u16)"vmla_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_u16)"vmlaq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_u32)"vmla_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_u32)"vmlaq_u32"Vector widening multiply accumulate with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_s16)"vmlal_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_s16)"vmlal_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_s32)"vmlal_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_s32)"vmlal_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_u16)"vmlal_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_u16)"vmlal_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_u32)"vmlal_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_u32)"vmlal_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_n_s16)"vmlal_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_n_s32)"vmlal_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_n_u16)"vmlal_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_n_u32)"vmlal_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_s8)"vmlal_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_s16)"vmlal_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_s32)"vmlal_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_u8)"vmlal_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_u16)"vmlal_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_u32)"vmlal_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_f32)"vmls_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_f32)"vmlsq_f32"Vector multiply subtract with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_f32)"vmls_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_f32)"vmls_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_f32)"vmlsq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_f32)"vmlsq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_s16)"vmls_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_u16)"vmls_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_s16)"vmls_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_u16)"vmls_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_s16)"vmlsq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_u16)"vmlsq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_s16)"vmlsq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_u16)"vmlsq_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_s32)"vmls_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_u32)"vmls_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_s32)"vmls_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_u32)"vmls_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_s32)"vmlsq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_u32)"vmlsq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_s32)"vmlsq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_u32)"vmlsq_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_f32)"vmls_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_f32)"vmlsq_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_s16)"vmls_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_s16)"vmlsq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_u16)"vmls_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_u16)"vmlsq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_s32)"vmls_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_s32)"vmlsq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_u32)"vmls_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_u32)"vmlsq_n_u32"Multiply-subtract from accumulator""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_s8)"vmls_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_s8)"vmlsq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_s16)"vmls_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_s16)"vmlsq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_s32)"vmls_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_s32)"vmlsq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_u8)"vmls_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_u8)"vmlsq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_u16)"vmls_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_u16)"vmlsq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_u32)"vmls_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_u32)"vmlsq_u32"Vector widening multiply subtract with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_s16)"vmlsl_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_s16)"vmlsl_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_s32)"vmlsl_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_s32)"vmlsl_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_u16)"vmlsl_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_u16)"vmlsl_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_u32)"vmlsl_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_u32)"vmlsl_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_n_s16)"vmlsl_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_n_s32)"vmlsl_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_n_u16)"vmlsl_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_n_u32)"vmlsl_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_s8)"vmlsl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_s16)"vmlsl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_s32)"vmlsl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_u8)"vmlsl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_u16)"vmlsl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_u32)"vmlsl_u32"8-bit integer matrix multiply-accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmmlaq_s32)"vmmlaq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmmlaq_u32)"vmmlaq_u32"Duplicate element to vector""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_f16)"vmov_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_f16)"vmovq_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_f32)"vmov_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_p16)"vmov_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_p8)"vmov_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_s16)"vmov_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_s32)"vmov_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_s64)"vmov_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_s8)"vmov_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_u16)"vmov_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_u32)"vmov_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_u64)"vmov_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmov_n_u8)"vmov_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_f32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_p16)"vmovq_n_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_p8)"vmovq_n_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_s16)"vmovq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_s32)"vmovq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_s64)"vmovq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_s8)"vmovq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_u16)"vmovq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_u32)"vmovq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_u64)"vmovq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovq_n_u8)"vmovq_n_u8"Vector long move.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_s16)"vmovl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_s32)"vmovl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_s8)"vmovl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_u16)"vmovl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_u32)"vmovl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_u8)"vmovl_u8"Vector narrow integer.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_s16)"vmovn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_s32)"vmovn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_s64)"vmovn_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_u16)"vmovn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_u32)"vmovn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_u64)"vmovn_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_f16)"vmul_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_f16)"vmulq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_f32)"vmul_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_f32)"vmulq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_f16)"vmul_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_f16)"vmulq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_f32)"vmul_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_f32)"vmul_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_f32)"vmulq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_f32)"vmulq_laneq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_s16)"vmul_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_s16)"vmulq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_s32)"vmul_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_s32)"vmulq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_u16)"vmul_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_u16)"vmulq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_u32)"vmul_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_u32)"vmulq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_s16)"vmul_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_s16)"vmulq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_s32)"vmul_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_s32)"vmulq_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_u16)"vmul_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_u16)"vmulq_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_u32)"vmul_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_u32)"vmulq_laneq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_f16)"vmul_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_f16)"vmulq_n_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_f32)"vmul_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_f32)"vmulq_n_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_s16)"vmul_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_s16)"vmulq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_s32)"vmul_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_s32)"vmulq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_u16)"vmul_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_u16)"vmulq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_u32)"vmul_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_u32)"vmulq_n_u32"Polynomial multiply""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_p8)"vmul_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_p8)"vmulq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_s16)"vmul_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_s16)"vmulq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_u16)"vmul_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_u16)"vmulq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_s32)"vmul_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_s32)"vmulq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_u32)"vmul_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_u32)"vmulq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_s8)"vmul_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_s8)"vmulq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_u8)"vmul_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_u8)"vmulq_u8"Vector long multiply by scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_s16)"vmull_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_s16)"vmull_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_s32)"vmull_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_s32)"vmull_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_u16)"vmull_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_u16)"vmull_laneq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_u32)"vmull_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_u32)"vmull_laneq_u32"Vector long multiply with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_n_s16)"vmull_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_n_s32)"vmull_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_n_u16)"vmull_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_n_u32)"vmull_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_p8)"vmull_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_s16)"vmull_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_s32)"vmull_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_s8)"vmull_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_u8)"vmull_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_u16)"vmull_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_u32)"vmull_u32"Vector bitwise not.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_p8)"vmvn_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s16)"vmvn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s32)"vmvn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s8)"vmvn_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u16)"vmvn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u32)"vmvn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u8)"vmvn_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_p8)"vmvnq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s16)"vmvnq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s32)"vmvnq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s8)"vmvnq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u16)"vmvnq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u32)"vmvnq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u8)"vmvnq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_f16)"vneg_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_f16)"vnegq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_f32)"vneg_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_f32)"vnegq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s8)"vneg_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s8)"vnegq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s16)"vneg_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s16)"vnegq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s32)"vneg_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s32)"vnegq_s32"Vector bitwise inclusive OR NOT""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s16)"vorn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s32)"vorn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s64)"vorn_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s8)"vorn_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s16)"vornq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s32)"vornq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s64)"vornq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s8)"vornq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u16)"vorn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u32)"vorn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u64)"vorn_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u8)"vorn_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u16)"vornq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u32)"vornq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u64)"vornq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u8)"vornq_u8"Vector bitwise or (immediate, inclusive)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s8)"vorr_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s8)"vorrq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s16)"vorr_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s16)"vorrq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s32)"vorr_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s32)"vorrq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s64)"vorr_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s64)"vorrq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u8)"vorr_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u8)"vorrq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u16)"vorr_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u16)"vorrq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u32)"vorr_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u32)"vorrq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u64)"vorr_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u64)"vorrq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_s8)"vpadal_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_s8)"vpadalq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_s16)"vpadal_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_s16)"vpadalq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_s32)"vpadal_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_s32)"vpadalq_s32"Unsigned Add and Accumulate Long Pairwise.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_u8)"vpadal_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_u8)"vpadalq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_u16)"vpadal_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_u16)"vpadalq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_u32)"vpadal_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_u32)"vpadalq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_f16)"vpadd_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_f32)"vpadd_f32"Add pairwise.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_s8)"vpadd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_s16)"vpadd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_s32)"vpadd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_u8)"vpadd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_u16)"vpadd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_u32)"vpadd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_s8)"vpaddl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_s8)"vpaddlq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_s16)"vpaddl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_s16)"vpaddlq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_s32)"vpaddl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_s32)"vpaddlq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_u8)"vpaddl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_u8)"vpaddlq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_u16)"vpaddl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_u16)"vpaddlq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_u32)"vpaddl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_u32)"vpaddlq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_f32)"vpmax_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_s8)"vpmax_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_s16)"vpmax_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_s32)"vpmax_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_u8)"vpmax_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_u16)"vpmax_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_u32)"vpmax_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_f32)"vpmin_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_s8)"vpmin_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_s16)"vpmin_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_s32)"vpmin_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_u8)"vpmin_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_u16)"vpmin_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_u32)"vpmin_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s8)"vqabs_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s8)"vqabsq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s16)"vqabs_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s16)"vqabsq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s32)"vqabs_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s32)"vqabsq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s8)"vqadd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s8)"vqaddq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s16)"vqadd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s16)"vqaddq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s32)"vqadd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s32)"vqaddq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s64)"vqadd_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s64)"vqaddq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u8)"vqadd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u8)"vqaddq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u16)"vqadd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u16)"vqaddq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u32)"vqadd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u32)"vqaddq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u64)"vqadd_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u64)"vqaddq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_lane_s16)"vqdmlal_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_lane_s32)"vqdmlal_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_n_s16)"vqdmlal_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_n_s32)"vqdmlal_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_s16)"vqdmlal_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_s32)"vqdmlal_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_lane_s16)"vqdmlsl_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_lane_s32)"vqdmlsl_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_n_s16)"vqdmlsl_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_n_s32)"vqdmlsl_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_s16)"vqdmlsl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlsl_s32)"vqdmlsl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_laneq_s16)"vqdmulh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_laneq_s16)"vqdmulhq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_laneq_s32)"vqdmulh_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_laneq_s32)"vqdmulhq_laneq_s32"Vector saturating doubling multiply high with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_n_s16)"vqdmulh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_n_s16)"vqdmulhq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_n_s32)"vqdmulh_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_n_s32)"vqdmulhq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_s16)"vqdmulh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_s16)"vqdmulhq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulh_s32)"vqdmulh_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmulhq_s32)"vqdmulhq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_lane_s16)"vqdmull_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_lane_s32)"vqdmull_lane_s32"Vector saturating doubling long multiply with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_n_s16)"vqdmull_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_n_s32)"vqdmull_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_s16)"vqdmull_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmull_s32)"vqdmull_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_s16)"vqmovn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_s32)"vqmovn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_s64)"vqmovn_s64"Unsigned saturating extract narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_u16)"vqmovn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_u32)"vqmovn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovn_u64)"vqmovn_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovun_s16)"vqmovun_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovun_s32)"vqmovun_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqmovun_s64)"vqmovun_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s8)"vqneg_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s8)"vqnegq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s16)"vqneg_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s16)"vqnegq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s32)"vqneg_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s32)"vqnegq_s32"Vector rounding saturating doubling multiply high by scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_lane_s16)"vqrdmulh_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_lane_s32)"vqrdmulh_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_laneq_s16)"vqrdmulh_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_laneq_s32)"vqrdmulh_laneq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_lane_s16)"vqrdmulhq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_lane_s32)"vqrdmulhq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_laneq_s16)"vqrdmulhq_laneq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_laneq_s32)"vqrdmulhq_laneq_s32"Vector saturating rounding doubling multiply high with scalar""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_n_s16)"vqrdmulh_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_n_s16)"vqrdmulhq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_n_s32)"vqrdmulh_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_n_s32)"vqrdmulhq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_s16)"vqrdmulh_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_s16)"vqrdmulhq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulh_s32)"vqrdmulh_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrdmulhq_s32)"vqrdmulhq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s8)"vqrshl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s8)"vqrshlq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s16)"vqrshl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s16)"vqrshlq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s32)"vqrshl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s32)"vqrshlq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s64)"vqrshl_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s64)"vqrshlq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u8)"vqrshl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u8)"vqrshlq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u16)"vqrshl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u16)"vqrshlq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u32)"vqrshl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u32)"vqrshlq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u64)"vqrshl_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u64)"vqrshlq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_s16)"vqrshrn_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_s32)"vqrshrn_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_s64)"vqrshrn_n_s64"Unsigned signed saturating rounded shift right narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_u16)"vqrshrn_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_u32)"vqrshrn_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_u64)"vqrshrn_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_n_s16)"vqrshrun_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_n_s32)"vqrshrun_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_n_s64)"vqrshrun_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s8)"vqshl_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s8)"vqshlq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s16)"vqshl_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s16)"vqshlq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s32)"vqshl_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s32)"vqshlq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s64)"vqshl_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s64)"vqshlq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u8)"vqshl_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u8)"vqshlq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u16)"vqshl_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u16)"vqshlq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u32)"vqshl_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u32)"vqshlq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u64)"vqshl_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u64)"vqshlq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s8)"vqshl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s8)"vqshlq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s16)"vqshl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s16)"vqshlq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s32)"vqshl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s32)"vqshlq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s64)"vqshl_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s64)"vqshlq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u8)"vqshl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u8)"vqshlq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u16)"vqshl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u16)"vqshlq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u32)"vqshl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u32)"vqshlq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u64)"vqshl_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u64)"vqshlq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s8)"vqshlu_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s8)"vqshluq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s16)"vqshlu_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s16)"vqshluq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s32)"vqshlu_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s32)"vqshluq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s64)"vqshlu_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s64)"vqshluq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_s16)"vqshrn_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_s32)"vqshrn_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_s64)"vqshrn_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_u16)"vqshrn_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_u32)"vqshrn_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_u64)"vqshrn_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_n_s16)"vqshrun_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_n_s32)"vqshrun_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_n_s64)"vqshrun_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s8)"vqsub_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s8)"vqsubq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s16)"vqsub_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s16)"vqsubq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s32)"vqsub_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s32)"vqsubq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s64)"vqsub_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s64)"vqsubq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u8)"vqsub_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u8)"vqsubq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u16)"vqsub_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u16)"vqsubq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u32)"vqsub_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u32)"vqsubq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u64)"vqsub_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u64)"vqsubq_u64"Rounding Add returning High Narrow (high half).""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s16)"vraddhn_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s32)"vraddhn_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s64)"vraddhn_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_u16)"vraddhn_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_u32)"vraddhn_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_u64)"vraddhn_high_u64"Rounding Add returning High Narrow.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_s16)"vraddhn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_s32)"vraddhn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_s64)"vraddhn_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_u16)"vraddhn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_u32)"vraddhn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_u64)"vraddhn_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_f16)"vrecpe_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_f16)"vrecpeq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_f32)"vrecpe_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_f32)"vrecpeq_f32"Unsigned reciprocal estimate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_u32)"vrecpe_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_u32)"vrecpeq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecps_f16)"vrecps_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsq_f16)"vrecpsq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecps_f32)"vrecps_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsq_f32)"vrecpsq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_f16)"vreinterpret_f32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f16)"vreinterpret_s8_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f16)"vreinterpret_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f16)"vreinterpret_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f16)"vreinterpret_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f16)"vreinterpret_u8_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f16)"vreinterpret_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f16)"vreinterpret_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f16)"vreinterpret_u64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f16)"vreinterpret_p8_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f16)"vreinterpret_p16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f16)"vreinterpretq_f32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f16)"vreinterpretq_s8_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f16)"vreinterpretq_s16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f16)"vreinterpretq_s32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f16)"vreinterpretq_s64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f16)"vreinterpretq_u8_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f16)"vreinterpretq_u16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f16)"vreinterpretq_u32_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f16)"vreinterpretq_u64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f16)"vreinterpretq_p8_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f16)"vreinterpretq_p16_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f32)"vreinterpret_f16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f32)"vreinterpretq_f16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s8)"vreinterpret_f16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s8)"vreinterpretq_f16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s16)"vreinterpret_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s16)"vreinterpretq_f16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s32)"vreinterpret_f16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s32)"vreinterpretq_f16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s64)"vreinterpret_f16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s64)"vreinterpretq_f16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u8)"vreinterpret_f16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u8)"vreinterpretq_f16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u16)"vreinterpret_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u16)"vreinterpretq_f16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u32)"vreinterpret_f16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u32)"vreinterpretq_f16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u64)"vreinterpret_f16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u64)"vreinterpretq_f16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p8)"vreinterpret_f16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p8)"vreinterpretq_f16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p16)"vreinterpret_f16_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p16)"vreinterpretq_f16_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p128)"vreinterpretq_f16_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f16)"vreinterpret_p64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f16)"vreinterpretq_p128_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f16)"vreinterpretq_p64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p64)"vreinterpret_f16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p64)"vreinterpretq_f16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p128)"vreinterpretq_f32_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f32)"vreinterpret_s8_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f32)"vreinterpret_s16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f32)"vreinterpret_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f32)"vreinterpret_s64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f32)"vreinterpret_u8_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f32)"vreinterpret_u16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f32)"vreinterpret_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f32)"vreinterpret_u64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f32)"vreinterpret_p8_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f32)"vreinterpret_p16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f32)"vreinterpretq_p128_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f32)"vreinterpretq_s8_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f32)"vreinterpretq_s16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f32)"vreinterpretq_s32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f32)"vreinterpretq_s64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f32)"vreinterpretq_u8_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f32)"vreinterpretq_u16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f32)"vreinterpretq_u32_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f32)"vreinterpretq_u64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f32)"vreinterpretq_p8_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f32)"vreinterpretq_p16_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s8)"vreinterpret_f32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s8)"vreinterpret_s16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s8)"vreinterpret_s32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s8)"vreinterpret_s64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s8)"vreinterpret_u8_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s8)"vreinterpret_u16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s8)"vreinterpret_u32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s8)"vreinterpret_u64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s8)"vreinterpret_p8_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s8)"vreinterpret_p16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s8)"vreinterpretq_f32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s8)"vreinterpretq_s16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s8)"vreinterpretq_s32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s8)"vreinterpretq_s64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s8)"vreinterpretq_u8_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s8)"vreinterpretq_u16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s8)"vreinterpretq_u32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s8)"vreinterpretq_u64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s8)"vreinterpretq_p8_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s8)"vreinterpretq_p16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s16)"vreinterpret_f32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s16)"vreinterpret_s8_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s16)"vreinterpret_s32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s16)"vreinterpret_s64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s16)"vreinterpret_u8_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s16)"vreinterpret_u16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s16)"vreinterpret_u32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s16)"vreinterpret_u64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s16)"vreinterpret_p8_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s16)"vreinterpret_p16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s16)"vreinterpretq_f32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s16)"vreinterpretq_s8_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s16)"vreinterpretq_s32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s16)"vreinterpretq_s64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s16)"vreinterpretq_u8_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s16)"vreinterpretq_u16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s16)"vreinterpretq_u32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s16)"vreinterpretq_u64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s16)"vreinterpretq_p8_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s16)"vreinterpretq_p16_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s32)"vreinterpret_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s32)"vreinterpret_s8_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s32)"vreinterpret_s16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s32)"vreinterpret_s64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s32)"vreinterpret_u8_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s32)"vreinterpret_u16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s32)"vreinterpret_u32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s32)"vreinterpret_u64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s32)"vreinterpret_p8_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s32)"vreinterpret_p16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s32)"vreinterpretq_f32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s32)"vreinterpretq_s8_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s32)"vreinterpretq_s16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s32)"vreinterpretq_s64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s32)"vreinterpretq_u8_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s32)"vreinterpretq_u16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s32)"vreinterpretq_u32_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s32)"vreinterpretq_u64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s32)"vreinterpretq_p8_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s32)"vreinterpretq_p16_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s64)"vreinterpret_f32_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s64)"vreinterpret_s8_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s64)"vreinterpret_s16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s64)"vreinterpret_s32_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s64)"vreinterpret_u8_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s64)"vreinterpret_u16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s64)"vreinterpret_u32_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s64)"vreinterpret_u64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s64)"vreinterpret_p8_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s64)"vreinterpret_p16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s64)"vreinterpretq_f32_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s64)"vreinterpretq_s8_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s64)"vreinterpretq_s16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s64)"vreinterpretq_s32_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s64)"vreinterpretq_u8_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s64)"vreinterpretq_u16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s64)"vreinterpretq_u32_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s64)"vreinterpretq_u64_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s64)"vreinterpretq_p8_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s64)"vreinterpretq_p16_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u8)"vreinterpret_f32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u8)"vreinterpret_s8_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u8)"vreinterpret_s16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u8)"vreinterpret_s32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u8)"vreinterpret_s64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u8)"vreinterpret_u16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u8)"vreinterpret_u32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u8)"vreinterpret_u64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u8)"vreinterpret_p8_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u8)"vreinterpret_p16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u8)"vreinterpretq_f32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u8)"vreinterpretq_s8_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u8)"vreinterpretq_s16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u8)"vreinterpretq_s32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u8)"vreinterpretq_s64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u8)"vreinterpretq_u16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u8)"vreinterpretq_u32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u8)"vreinterpretq_u64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u8)"vreinterpretq_p8_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u8)"vreinterpretq_p16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u16)"vreinterpret_f32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u16)"vreinterpret_s8_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u16)"vreinterpret_s16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u16)"vreinterpret_s32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u16)"vreinterpret_s64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u16)"vreinterpret_u8_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u16)"vreinterpret_u32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u16)"vreinterpret_u64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u16)"vreinterpret_p8_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u16)"vreinterpret_p16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u16)"vreinterpretq_f32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u16)"vreinterpretq_s8_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u16)"vreinterpretq_s16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u16)"vreinterpretq_s32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u16)"vreinterpretq_s64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u16)"vreinterpretq_u8_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u16)"vreinterpretq_u32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u16)"vreinterpretq_u64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u16)"vreinterpretq_p8_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u16)"vreinterpretq_p16_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u32)"vreinterpret_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u32)"vreinterpret_s8_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u32)"vreinterpret_s16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u32)"vreinterpret_s32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u32)"vreinterpret_s64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u32)"vreinterpret_u8_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u32)"vreinterpret_u16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u32)"vreinterpret_u64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u32)"vreinterpret_p8_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u32)"vreinterpret_p16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u32)"vreinterpretq_f32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u32)"vreinterpretq_s8_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u32)"vreinterpretq_s16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u32)"vreinterpretq_s32_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u32)"vreinterpretq_s64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u32)"vreinterpretq_u8_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u32)"vreinterpretq_u16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u32)"vreinterpretq_u64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u32)"vreinterpretq_p8_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u32)"vreinterpretq_p16_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u64)"vreinterpret_f32_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u64)"vreinterpret_s8_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u64)"vreinterpret_s16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u64)"vreinterpret_s32_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u64)"vreinterpret_s64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u64)"vreinterpret_u8_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u64)"vreinterpret_u16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u64)"vreinterpret_u32_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u64)"vreinterpret_p8_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u64)"vreinterpret_p16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u64)"vreinterpretq_f32_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u64)"vreinterpretq_s8_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u64)"vreinterpretq_s16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u64)"vreinterpretq_s32_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u64)"vreinterpretq_s64_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u64)"vreinterpretq_u8_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u64)"vreinterpretq_u16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u64)"vreinterpretq_u32_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u64)"vreinterpretq_p8_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u64)"vreinterpretq_p16_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p8)"vreinterpret_f32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p8)"vreinterpret_s8_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p8)"vreinterpret_s16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p8)"vreinterpret_s32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p8)"vreinterpret_s64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p8)"vreinterpret_u8_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p8)"vreinterpret_u16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p8)"vreinterpret_u32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p8)"vreinterpret_u64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p8)"vreinterpret_p16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p8)"vreinterpretq_f32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p8)"vreinterpretq_s8_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p8)"vreinterpretq_s16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p8)"vreinterpretq_s32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p8)"vreinterpretq_s64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p8)"vreinterpretq_u8_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p8)"vreinterpretq_u16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p8)"vreinterpretq_u32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p8)"vreinterpretq_u64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p8)"vreinterpretq_p16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p16)"vreinterpret_f32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p16)"vreinterpret_s8_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p16)"vreinterpret_s16_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p16)"vreinterpret_s32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p16)"vreinterpret_s64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p16)"vreinterpret_u8_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p16)"vreinterpret_u16_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p16)"vreinterpret_u32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p16)"vreinterpret_u64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p16)"vreinterpret_p8_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p16)"vreinterpretq_f32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p16)"vreinterpretq_s8_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p16)"vreinterpretq_s16_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p16)"vreinterpretq_s32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p16)"vreinterpretq_s64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p16)"vreinterpretq_u8_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p16)"vreinterpretq_u16_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p16)"vreinterpretq_u32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p16)"vreinterpretq_u64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p16)"vreinterpretq_p8_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p128)"vreinterpretq_s8_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p128)"vreinterpretq_s16_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p128)"vreinterpretq_s32_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p128)"vreinterpretq_s64_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p128)"vreinterpretq_u8_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p128)"vreinterpretq_u16_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p128)"vreinterpretq_u32_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p128)"vreinterpretq_u64_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p128)"vreinterpretq_p8_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p128)"vreinterpretq_p16_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p128)"vreinterpretq_p64_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s8)"vreinterpret_p64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s8)"vreinterpretq_p128_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s8)"vreinterpretq_p64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s16)"vreinterpret_p64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s16)"vreinterpretq_p128_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s16)"vreinterpretq_p64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s32)"vreinterpret_p64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s32)"vreinterpretq_p128_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s32)"vreinterpretq_p64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s64)"vreinterpretq_p128_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u8)"vreinterpret_p64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u8)"vreinterpretq_p128_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u8)"vreinterpretq_p64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u16)"vreinterpret_p64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u16)"vreinterpretq_p128_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u16)"vreinterpretq_p64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u32)"vreinterpret_p64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u32)"vreinterpretq_p128_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u32)"vreinterpretq_p64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u64)"vreinterpretq_p128_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p8)"vreinterpret_p64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p8)"vreinterpretq_p128_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p8)"vreinterpretq_p64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p16)"vreinterpret_p64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p16)"vreinterpretq_p128_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p16)"vreinterpretq_p64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p64)"vreinterpret_s8_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p64)"vreinterpret_s16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p64)"vreinterpret_s32_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p64)"vreinterpret_u8_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p64)"vreinterpret_u16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p64)"vreinterpret_u32_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p64)"vreinterpret_p8_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p64)"vreinterpret_p16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p64)"vreinterpretq_p128_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p64)"vreinterpretq_s8_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p64)"vreinterpretq_s16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p64)"vreinterpretq_s32_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p64)"vreinterpretq_u8_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p64)"vreinterpretq_u16_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p64)"vreinterpretq_u32_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p64)"vreinterpretq_p8_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p64)"vreinterpretq_p16_p64"Reversing vector elements (swap endianness)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16_p8)"vrev16_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16_s8)"vrev16_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16_u8)"vrev16_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16q_p8)"vrev16q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16q_s8)"vrev16q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16q_u8)"vrev16q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32_p16)"vrev32_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32_p8)"vrev32_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32_s16)"vrev32_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32_s8)"vrev32_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32_u16)"vrev32_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32_u8)"vrev32_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32q_p16)"vrev32q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32q_p8)"vrev32q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32q_s16)"vrev32q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32q_s8)"vrev32q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32q_u16)"vrev32q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev32q_u8)"vrev32q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_f32)"vrev64_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_p16)"vrev64_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_p8)"vrev64_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_s16)"vrev64_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_s32)"vrev64_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_s8)"vrev64_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_u16)"vrev64_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_u32)"vrev64_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_u8)"vrev64_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_f32)"vrev64q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_p16)"vrev64q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_p8)"vrev64q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_s16)"vrev64q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_s32)"vrev64q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_s8)"vrev64q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_u16)"vrev64q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_u32)"vrev64q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_u8)"vrev64q_u8"Reverse elements in 64-bit doublewords""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64_f16)"vrev64_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev64q_f16)"vrev64q_f16"Rounding halving add""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_s8)"vrhadd_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_s8)"vrhaddq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_s16)"vrhadd_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_s16)"vrhaddq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_s32)"vrhadd_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_s32)"vrhaddq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_u8)"vrhadd_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_u8)"vrhaddq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_u16)"vrhadd_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_u16)"vrhaddq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_u32)"vrhadd_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_u32)"vrhaddq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f16)"vrndn_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndnq_f16)"vrndnq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f32)"vrndn_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndnq_f32)"vrndnq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s8)"vrshl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s8)"vrshlq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s16)"vrshl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s16)"vrshlq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s32)"vrshl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s32)"vrshlq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s64)"vrshl_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s64)"vrshlq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u8)"vrshl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u8)"vrshlq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u16)"vrshl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u16)"vrshlq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u32)"vrshl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u32)"vrshlq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u64)"vrshl_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u64)"vrshlq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s8)"vrshr_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s8)"vrshrq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s16)"vrshr_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s16)"vrshrq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s32)"vrshr_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s32)"vrshrq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s64)"vrshr_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s64)"vrshrq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u8)"vrshr_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u8)"vrshrq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u16)"vrshr_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u16)"vrshrq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u32)"vrshr_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u32)"vrshrq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u64)"vrshr_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u64)"vrshrq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_s16)"vrshrn_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_s32)"vrshrn_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_s64)"vrshrn_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_u16)"vrshrn_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_u32)"vrshrn_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_u64)"vrshrn_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_f16)"vrsqrte_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_f16)"vrsqrteq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_f32)"vrsqrte_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_f32)"vrsqrteq_f32"Unsigned reciprocal square root estimate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_u32)"vrsqrte_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_u32)"vrsqrteq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrts_f16)"vrsqrts_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsq_f16)"vrsqrtsq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrts_f32)"vrsqrts_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsq_f32)"vrsqrtsq_f32"Signed rounding shift right and accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s8)"vrsra_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s8)"vrsraq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s16)"vrsra_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s16)"vrsraq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s32)"vrsra_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s32)"vrsraq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s64)"vrsra_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s64)"vrsraq_n_s64"Unsigned rounding shift right and accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u8)"vrsra_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u8)"vrsraq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u16)"vrsra_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u16)"vrsraq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u32)"vrsra_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u32)"vrsraq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u64)"vrsra_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u64)"vrsraq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_s16)"vrsubhn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_s32)"vrsubhn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_s64)"vrsubhn_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_u16)"vrsubhn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_u32)"vrsubhn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_u64)"vrsubhn_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_f16)"vset_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_f16)"vsetq_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_f32)"vset_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_f32)"vsetq_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s8)"vset_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s8)"vsetq_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s16)"vset_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s16)"vsetq_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s32)"vset_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s32)"vsetq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s64)"vsetq_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u8)"vset_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u8)"vsetq_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u16)"vset_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u16)"vsetq_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u32)"vset_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u32)"vsetq_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u64)"vsetq_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_p8)"vset_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_p8)"vsetq_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_p16)"vset_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_p16)"vsetq_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_p64)"vset_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s64)"vset_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u64)"vset_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_p64)"vsetq_lane_p64"SHA1 hash update accelerator, choose.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1cq_u32)"vsha1cq_u32"SHA1 fixed rotate.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1h_u32)"vsha1h_u32"SHA1 hash update accelerator, majority""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1mq_u32)"vsha1mq_u32"SHA1 hash update accelerator, parity""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1pq_u32)"vsha1pq_u32"SHA1 schedule update accelerator, first part.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1su0q_u32)"vsha1su0q_u32"SHA1 schedule update accelerator, second part.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1su1q_u32)"vsha1su1q_u32"SHA1 schedule update accelerator, upper part.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256h2q_u32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256hq_u32)""SHA256 schedule update accelerator, first part.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256su0q_u32)""SHA256 schedule update accelerator, second part.""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256su1q_u32)""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v16i8)"vshiftins_v16i8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v1i64)"vshiftins_v1i64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v2i32)"vshiftins_v2i32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v2i64)"vshiftins_v2i64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v4i16)"vshiftins_v4i16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v4i32)"vshiftins_v4i32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v8i16)"vshiftins_v8i16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshiftins_v8i8)"vshiftins_v8i8"Shift left""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s8)"vshl_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s8)"vshlq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s16)"vshl_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s16)"vshlq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s32)"vshl_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s32)"vshlq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s64)"vshl_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s64)"vshlq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u8)"vshl_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u8)"vshlq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u16)"vshl_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u16)"vshlq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u32)"vshl_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u32)"vshlq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u64)"vshl_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u64)"vshlq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s8)"vshl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s8)"vshlq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s16)"vshl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s16)"vshlq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s32)"vshl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s32)"vshlq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s64)"vshl_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s64)"vshlq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u8)"vshl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u8)"vshlq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u16)"vshl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u16)"vshlq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u32)"vshl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u32)"vshlq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u64)"vshl_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u64)"vshlq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_s16)"vshll_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_s32)"vshll_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_s8)"vshll_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_u16)"vshll_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_u32)"vshll_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_u8)"vshll_n_u8"Shift right""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s8)"vshr_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s8)"vshrq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s16)"vshr_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s16)"vshrq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s32)"vshr_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s32)"vshrq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s64)"vshr_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s64)"vshrq_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u8)"vshr_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u8)"vshrq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u16)"vshr_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u16)"vshrq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u32)"vshr_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u32)"vshrq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u64)"vshr_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u64)"vshrq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_s16)"vshrn_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_s32)"vshrn_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_s64)"vshrn_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_u16)"vshrn_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_u32)"vshrn_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_u64)"vshrn_n_u64"Signed shift right and accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s8)"vsra_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s8)"vsraq_n_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s16)"vsra_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s16)"vsraq_n_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s32)"vsra_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s32)"vsraq_n_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s64)"vsra_n_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s64)"vsraq_n_s64"Unsigned shift right and accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u8)"vsra_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u8)"vsraq_n_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u16)"vsra_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u16)"vsraq_n_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u32)"vsra_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u32)"vsraq_n_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u64)"vsra_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u64)"vsraq_n_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f16_x2)"vst1_f16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f16_x2)"vst1q_f16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f16_x3)"vst1_f16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f16_x3)"vst1q_f16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f16_x4)"vst1_f16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f16_x4)"vst1q_f16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f32_x2)"vst1_f32_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f32_x2)"vst1q_f32_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f32_x3)"vst1_f32_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f32_x3)"vst1q_f32_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f32_x4)"vst1_f32_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f32_x4)"vst1q_f32_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_f16)"vst1_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_f16)"vst1q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_f32)"vst1_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_f32)"vst1q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s8)"vst1_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s8)"vst1q_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s16)"vst1_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s16)"vst1q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s32)"vst1_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s32)"vst1q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s64)"vst1q_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u8)"vst1_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u8)"vst1q_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u16)"vst1_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u16)"vst1q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u32)"vst1_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u32)"vst1q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u64)"vst1q_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_p8)"vst1_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_p8)"vst1q_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_p16)"vst1_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_p16)"vst1q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_p64)"vst1_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s64)"vst1_lane_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u64)"vst1_lane_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p64_x2)"vst1_p64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p64_x3)"vst1_p64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p64_x4)"vst1_p64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p64_x2)"vst1q_p64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p64_x3)"vst1q_p64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p64_x4)"vst1q_p64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s8_x2)"vst1_s8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s8_x2)"vst1q_s8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s16_x2)"vst1_s16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s16_x2)"vst1q_s16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s32_x2)"vst1_s32_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s32_x2)"vst1q_s32_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s64_x2)"vst1_s64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s64_x2)"vst1q_s64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s8_x3)"vst1_s8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s8_x3)"vst1q_s8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s16_x3)"vst1_s16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s16_x3)"vst1q_s16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s32_x3)"vst1_s32_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s32_x3)"vst1q_s32_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s64_x3)"vst1_s64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s64_x3)"vst1q_s64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s8_x4)"vst1_s8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s8_x4)"vst1q_s8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s16_x4)"vst1_s16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s16_x4)"vst1q_s16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s32_x4)"vst1_s32_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s32_x4)"vst1q_s32_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s64_x4)"vst1_s64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s64_x4)"vst1q_s64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u8_x2)"vst1_u8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u8_x3)"vst1_u8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u8_x4)"vst1_u8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u8_x2)"vst1q_u8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u8_x3)"vst1q_u8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u8_x4)"vst1q_u8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u16_x2)"vst1_u16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u16_x3)"vst1_u16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u16_x4)"vst1_u16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u16_x2)"vst1q_u16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u16_x3)"vst1q_u16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u16_x4)"vst1q_u16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u32_x2)"vst1_u32_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u32_x3)"vst1_u32_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u32_x4)"vst1_u32_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u32_x2)"vst1q_u32_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u32_x3)"vst1q_u32_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u32_x4)"vst1q_u32_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u64_x2)"vst1_u64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u64_x3)"vst1_u64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u64_x4)"vst1_u64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u64_x2)"vst1q_u64_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u64_x3)"vst1q_u64_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u64_x4)"vst1q_u64_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p8_x2)"vst1_p8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p8_x3)"vst1_p8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p8_x4)"vst1_p8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p8_x2)"vst1q_p8_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p8_x3)"vst1q_p8_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p8_x4)"vst1q_p8_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p16_x2)"vst1_p16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p16_x3)"vst1_p16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_p16_x4)"vst1_p16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p16_x2)"vst1q_p16_x2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p16_x3)"vst1q_p16_x3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_p16_x4)"vst1q_p16_x4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_v1i64)"vst1_v1i64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_v2f32)"vst1_v2f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_v2i32)"vst1_v2i32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_v4i16)"vst1_v4i16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_v8i8)"vst1_v8i8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_v16i8)"vst1q_v16i8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_v2i64)"vst1q_v2i64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_v4f32)"vst1q_v4f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_v4i32)"vst1q_v4i32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_v8i16)"vst1q_v8i16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_v4f16)"vst1_v4f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_v8f16)"vst1q_v8f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_p64)"vst1q_lane_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_f16)"vst2_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_f16)"vst2q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_f32)"vst2_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_f32)"vst2q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_s8)"vst2_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_s8)"vst2q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_s16)"vst2_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_s16)"vst2q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_s32)"vst2_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_s32)"vst2q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_f16)"vst2_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_f16)"vst2q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_f32)"vst2_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_f32)"vst2q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_s8)"vst2_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_s16)"vst2_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_s16)"vst2q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_s32)"vst2_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_s32)"vst2q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_u8)"vst2_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_u16)"vst2_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_u16)"vst2q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_u32)"vst2_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_u32)"vst2q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_p8)"vst2_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_lane_p16)"vst2_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_lane_p16)"vst2q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_p64)"vst2_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_s64)"vst2_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_u64)"vst2_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_u8)"vst2_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_u8)"vst2q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_u16)"vst2_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_u16)"vst2q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_u32)"vst2_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_u32)"vst2q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_p8)"vst2_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_p8)"vst2q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2_p16)"vst2_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst2q_p16)"vst2q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_f16)"vst3_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_f16)"vst3q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_f32)"vst3_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_f32)"vst3q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_s8)"vst3_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_s8)"vst3q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_s16)"vst3_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_s16)"vst3q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_s32)"vst3_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_s32)"vst3q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_f16)"vst3_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_f16)"vst3q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_f32)"vst3_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_f32)"vst3q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_s8)"vst3_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_s16)"vst3_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_s16)"vst3q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_s32)"vst3_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_s32)"vst3q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_u8)"vst3_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_u16)"vst3_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_u16)"vst3q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_u32)"vst3_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_u32)"vst3q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_p8)"vst3_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_lane_p16)"vst3_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_lane_p16)"vst3q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_p64)"vst3_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_s64)"vst3_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_u64)"vst3_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_u8)"vst3_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_u8)"vst3q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_u16)"vst3_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_u16)"vst3q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_u32)"vst3_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_u32)"vst3q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_p8)"vst3_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_p8)"vst3q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3_p16)"vst3_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst3q_p16)"vst3q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_f16)"vst4_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_f16)"vst4q_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_f32)"vst4_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_f32)"vst4q_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_s8)"vst4_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_s8)"vst4q_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_s16)"vst4_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_s16)"vst4q_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_s32)"vst4_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_s32)"vst4q_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_f16)"vst4_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_f16)"vst4q_lane_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_f32)"vst4_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_f32)"vst4q_lane_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_s8)"vst4_lane_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_s16)"vst4_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_s16)"vst4q_lane_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_s32)"vst4_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_s32)"vst4q_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_u8)"vst4_lane_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_u16)"vst4_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_u16)"vst4q_lane_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_u32)"vst4_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_u32)"vst4q_lane_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_p8)"vst4_lane_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_lane_p16)"vst4_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_lane_p16)"vst4q_lane_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_p64)"vst4_p64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_s64)"vst4_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_u64)"vst4_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_u8)"vst4_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_u8)"vst4q_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_u16)"vst4_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_u16)"vst4q_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_u32)"vst4_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_u32)"vst4q_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_p8)"vst4_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_p8)"vst4q_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4_p16)"vst4_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst4q_p16)"vst4q_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vstrq_p128)"vstrq_p128"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_f16)"vsub_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_f16)"vsubq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_f32)"vsub_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_f32)"vsubq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s16)"vsub_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s16)"vsubq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u16)"vsub_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u16)"vsubq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s32)"vsub_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s32)"vsubq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u32)"vsub_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u32)"vsubq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s64)"vsub_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s64)"vsubq_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u64)"vsub_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u64)"vsubq_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s8)"vsub_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s8)"vsubq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u8)"vsub_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u8)"vsubq_u8"Subtract returning high narrow""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_s16)"vsubhn_high_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_s32)"vsubhn_high_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_s64)"vsubhn_high_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_u16)"vsubhn_high_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_u32)"vsubhn_high_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_u64)"vsubhn_high_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_s16)"vsubhn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_s32)"vsubhn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_s64)"vsubhn_s64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_u16)"vsubhn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_u32)"vsubhn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_u64)"vsubhn_u64"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_s8)"vsubl_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_s16)"vsubl_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_s32)"vsubl_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_u8)"vsubl_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_u16)"vsubl_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_u32)"vsubl_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_s8)"vsubw_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_s16)"vsubw_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_s32)"vsubw_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_u8)"vsubw_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_u16)"vsubw_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_u32)"vsubw_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsudot_lane_s32)"vsudot_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsudotq_lane_s32)"vsudotq_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl1)"vtbl1"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl2)"vtbl2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl3)"vtbl3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbl4)"vtbl4"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx1)"vtbx1"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx2)"vtbx2"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx3)"vtbx3"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtbx4)"vtbx4"Transpose elements""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_f16)"vtrn_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_f16)"vtrnq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_f32)"vtrn_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_s32)"vtrn_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_u32)"vtrn_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_f32)"vtrnq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_s8)"vtrn_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_s8)"vtrnq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_s16)"vtrn_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_s16)"vtrnq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_s32)"vtrnq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_u8)"vtrn_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_u8)"vtrnq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_u16)"vtrn_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_u16)"vtrnq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_u32)"vtrnq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_p8)"vtrn_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_p8)"vtrnq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn_p16)"vtrn_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrnq_p16)"vtrnq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s8)"vtst_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s8)"vtstq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s16)"vtst_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s16)"vtstq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s32)"vtst_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s32)"vtstq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_p8)"vtst_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_p8)"vtstq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_p16)"vtst_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_p16)"vtstq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u8)"vtst_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u8)"vtstq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u16)"vtst_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u16)"vtstq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u32)"vtst_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u32)"vtstq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusdot_lane_s32)"vusdot_lane_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusdotq_lane_s32)"vusdotq_lane_s32"Dot product vector form with unsigned and signed integers""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusdot_s32)"vusdot_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusdotq_s32)"vusdotq_s32"Unsigned and signed 8-bit integer matrix multiply-accumulate""[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vusmmlaq_s32)"vusmmlaq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_f16)"vuzp_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_f16)"vuzpq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_f32)"vuzp_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_s32)"vuzp_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_u32)"vuzp_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_f32)"vuzpq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_s8)"vuzp_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_s8)"vuzpq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_s16)"vuzp_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_s16)"vuzpq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_s32)"vuzpq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_u8)"vuzp_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_u8)"vuzpq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_u16)"vuzp_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_u16)"vuzpq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_u32)"vuzpq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_p8)"vuzp_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_p8)"vuzpq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp_p16)"vuzp_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzpq_p16)"vuzpq_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_f16)"vzip_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_f16)"vzipq_f16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_f32)"vzip_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_s32)"vzip_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_u32)"vzip_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_s8)"vzip_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_s16)"vzip_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_u8)"vzip_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_u16)"vzip_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_p8)"vzip_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip_p16)"vzip_p16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_f32)"vzipq_f32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_s8)"vzipq_s8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_s16)"vzipq_s16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_s32)"vzipq_s32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_u8)"vzipq_u8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_u16)"vzipq_u16"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_u32)"vzipq_u32"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_p8)"vzipq_p8"[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzipq_p16)"vzipq_p16test_vld1_s8test_vld1q_s8test_vld1_s16test_vld1q_s16test_vld1_s32test_vld1q_s32test_vld1_s64test_vld1q_s64test_vld1_u8test_vld1q_u8test_vld1_u16test_vld1q_u16test_vld1_u32test_vld1q_u32test_vld1_u64test_vld1q_u64test_vld1_p8test_vld1q_p8test_vld1_p16test_vld1q_p16test_vld1_p64test_vld1q_p64test_vld1_f32test_vld1q_f32//! Tests for ARM+v7+neon load (vld1) intrinsics.//! These are included in `{arm, aarch64}::neon`.AsUnsignedas_signedAsSignedimpl_sign_conversions_neon/// Arm-specific type containing two `int8x8_t` vectors./// Arm-specific type containing three `int8x8_t` vectors./// Arm-specific type containing four `int8x8_t` vectors./// Arm-specific type containing two `int8x16_t` vectors./// Arm-specific type containing three `int8x16_t` vectors./// Arm-specific type containing four `int8x16_t` vectors./// Arm-specific type containing two `uint8x8_t` vectors./// Arm-specific type containing three `uint8x8_t` vectors./// Arm-specific type containing four `uint8x8_t` vectors./// Arm-specific type containing two `uint8x16_t` vectors./// Arm-specific type containing three `uint8x16_t` vectors./// Arm-specific type containing four `uint8x16_t` vectors./// Arm-specific type containing two `poly8x8_t` vectors./// Arm-specific type containing three `poly8x8_t` vectors./// Arm-specific type containing four `poly8x8_t` vectors./// Arm-specific type containing two `poly8x16_t` vectors./// Arm-specific type containing three `poly8x16_t` vectors./// Arm-specific type containing four `poly8x16_t` vectors./// Arm-specific type containing two `int16x4_t` vectors./// Arm-specific type containing three `int16x4_t` vectors./// Arm-specific type containing four `int16x4_t` vectors./// Arm-specific type containing two `int16x8_t` vectors./// Arm-specific type containing three `int16x8_t` vectors./// Arm-specific type containing four `int16x8_t` vectors./// Arm-specific type containing two `uint16x4_t` vectors./// Arm-specific type containing three `uint16x4_t` vectors./// Arm-specific type containing four `uint16x4_t` vectors./// Arm-specific type containing two `uint16x8_t` vectors./// Arm-specific type containing three `uint16x8_t` vectors./// Arm-specific type containing four `uint16x8_t` vectors./// Arm-specific type containing two `poly16x4_t` vectors./// Arm-specific type containing three `poly16x4_t` vectors./// Arm-specific type containing four `poly16x4_t` vectors./// Arm-specific type containing two `poly16x8_t` vectors./// Arm-specific type containing three `poly16x8_t` vectors./// Arm-specific type containing four `poly16x8_t` vectors./// Arm-specific type containing two `int32x2_t` vectors./// Arm-specific type containing three `int32x2_t` vectors./// Arm-specific type containing four `int32x2_t` vectors./// Arm-specific type containing two `int32x4_t` vectors./// Arm-specific type containing three `int32x4_t` vectors./// Arm-specific type containing four `int32x4_t` vectors./// Arm-specific type containing two `uint32x2_t` vectors./// Arm-specific type containing three `uint32x2_t` vectors./// Arm-specific type containing four `uint32x2_t` vectors./// Arm-specific type containing two `uint32x4_t` vectors./// Arm-specific type containing three `uint32x4_t` vectors./// Arm-specific type containing four `uint32x4_t` vectors./// Arm-specific type containing two `float16x4_t` vectors./// Arm-specific type containing three `float16x4_t` vectors./// Arm-specific type containing four `float16x4_t` vectors./// Arm-specific type containing two `float16x8_t` vectors./// Arm-specific type containing three `float16x8_t` vectors./// Arm-specific type containing four `float16x8_t` vectors./// Arm-specific type containing two `float32x2_t` vectors./// Arm-specific type containing three `float32x2_t` vectors./// Arm-specific type containing four `float32x2_t` vectors./// Arm-specific type containing two `float32x4_t` vectors./// Arm-specific type containing three `float32x4_t` vectors./// Arm-specific type containing four `float32x4_t` vectors./// Arm-specific type containing two `int64x1_t` vectors./// Arm-specific type containing three `int64x1_t` vectors./// Arm-specific type containing four `int64x1_t` vectors./// Arm-specific type containing two `int64x2_t` vectors./// Arm-specific type containing three `int64x2_t` vectors./// Arm-specific type containing four `int64x2_t` vectors./// Arm-specific type containing two `uint64x1_t` vectors./// Arm-specific type containing three `uint64x1_t` vectors./// Arm-specific type containing four `uint64x1_t` vectors./// Arm-specific type containing two `uint64x2_t` vectors./// Arm-specific type containing three `uint64x2_t` vectors./// Arm-specific type containing four `uint64x2_t` vectors./// Arm-specific type containing two `poly64x1_t` vectors./// Arm-specific type containing three `poly64x1_t` vectors./// Arm-specific type containing four `poly64x1_t` vectors./// Arm-specific type containing two `poly64x2_t` vectors./// Arm-specific type containing three `poly64x2_t` vectors./// Arm-specific type containing four `poly64x2_t` vectors.test_vld1_lane_s8test_vld1q_lane_s8test_vld1_lane_s16test_vld1q_lane_s16test_vld1_lane_s32test_vld1q_lane_s32test_vld1_lane_s64test_vld1q_lane_s64test_vld1_lane_u8test_vld1q_lane_u8test_vld1_lane_u16test_vld1q_lane_u16test_vld1_lane_u32test_vld1q_lane_u32test_vld1_lane_u64test_vld1q_lane_u64test_vld1_lane_p8test_vld1q_lane_p8test_vld1_lane_p16test_vld1q_lane_p16test_vld1_lane_p64test_vld1q_lane_p64test_vld1_lane_f32test_vld1q_lane_f32test_vld1_dup_s8test_vld1q_dup_s8test_vld1_dup_s16test_vld1q_dup_s16test_vld1_dup_s32test_vld1q_dup_s32test_vld1_dup_s64test_vld1q_dup_s64test_vld1_dup_u8test_vld1q_dup_u8test_vld1_dup_u16test_vld1q_dup_u16test_vld1_dup_u32test_vld1q_dup_u32test_vld1_dup_u64test_vld1q_dup_u64test_vld1_dup_p8test_vld1q_dup_p8test_vld1_dup_p16test_vld1q_dup_p16test_vld1_dup_p64test_vld1q_dup_p64test_vld1_dup_f32test_vld1q_dup_f32test_vget_lane_u8test_vgetq_lane_u32test_vgetq_lane_s32test_vget_lane_u64test_vgetq_lane_u16test_vget_lane_s8test_vget_lane_p8test_vget_lane_p16test_vget_lane_s16test_vget_lane_u16test_vget_lane_f32test_vget_lane_s32test_vget_lane_u32test_vget_lane_s64test_vget_lane_p64test_vgetq_lane_s8test_vgetq_lane_p8test_vgetq_lane_u8test_vgetq_lane_s16test_vgetq_lane_p16test_vgetq_lane_f32test_vgetq_lane_s64test_vgetq_lane_p64test_vext_s64test_vext_u64test_vget_high_s8test_vget_high_s16test_vget_high_s32test_vget_high_s64test_vget_high_u8test_vget_high_u16test_vget_high_u32test_vget_high_u64test_vget_high_p8test_vget_high_p16test_vget_high_f32test_vget_low_s8test_vget_low_s16test_vget_low_s32test_vget_low_s64test_vget_low_u8test_vget_low_u16test_vget_low_u32test_vget_low_u64test_vget_low_p8test_vget_low_p16test_vget_low_f32test_vdupq_n_s8test_vdupq_n_s16test_vdupq_n_s32test_vdupq_n_s64test_vdupq_n_u8test_vdupq_n_u16test_vdupq_n_u32test_vdupq_n_u64test_vdupq_n_p8test_vdupq_n_p16test_vdupq_n_f32test_vdup_n_s8test_vdup_n_s16test_vdup_n_s32test_vdup_n_s64test_vdup_n_u8test_vdup_n_u16test_vdup_n_u32test_vdup_n_u64test_vdup_n_p8test_vdup_n_p16test_vdup_n_f32test_vldrq_p128test_vstrq_p128test_vmov_n_s8test_vmov_n_s16test_vmov_n_s32test_vmov_n_s64test_vmov_n_u8test_vmov_n_u16test_vmov_n_u32test_vmov_n_u64test_vmov_n_p8test_vmov_n_p16test_vmov_n_f32test_vmovq_n_s8test_vmovq_n_s16test_vmovq_n_s32test_vmovq_n_s64test_vmovq_n_u8test_vmovq_n_u16test_vmovq_n_u32test_vmovq_n_u64test_vmovq_n_p8test_vmovq_n_p16test_vmovq_n_f32test_vgetq_lane_u64test_vadd_s8test_vaddq_s8test_vadd_s16test_vaddq_s16test_vadd_s32test_vaddq_s32test_vadd_u8test_vaddq_u8test_vadd_u16test_vaddq_u16test_vadd_u32test_vaddq_u32test_vadd_f32test_vaddq_f32test_vaddl_s8test_vaddl_s16test_vaddl_s32test_vaddl_u8test_vaddl_u16test_vaddl_u32test_vaddl_high_s8test_vaddl_high_s16test_vaddl_high_s32test_vaddl_high_u8test_vaddl_high_u16test_vaddl_high_u32test_vaddw_s8test_vaddw_s16test_vaddw_s32test_vaddw_u8test_vaddw_u16test_vaddw_u32test_vaddw_high_s8test_vaddw_high_s16test_vaddw_high_s32test_vaddw_high_u8test_vaddw_high_u16test_vaddw_high_u32test_vmvn_s8test_vmvnq_s8test_vmvn_s16test_vmvnq_s16test_vmvn_s32test_vmvnq_s32test_vmvn_u8test_vmvnq_u8test_vmvn_u16test_vmvnq_u16test_vmvn_u32test_vmvnq_u32test_vmvn_p8test_vmvnq_p8test_vbic_s8test_vbicq_s8test_vbic_s16test_vbicq_s16test_vbic_s32test_vbicq_s32test_vbic_s64test_vbicq_s64test_vbic_u8test_vbicq_u8test_vbic_u16test_vbicq_u16test_vbic_u32test_vbicq_u32test_vbic_u64test_vbicq_u64test_vbsl_s8test_vbsl_s16test_vbsl_s32test_vbsl_s64test_vbsl_u8test_vbsl_u16test_vbsl_u32test_vbsl_u64test_vbsl_f32test_vbsl_p8test_vbsl_p16test_vbslq_s8test_vbslq_s16test_vbslq_s32test_vbslq_s64test_vbslq_u8test_vbslq_u16test_vbslq_u32test_vbslq_u64test_vbslq_f32test_vbslq_p8test_vbslq_p16test_vorn_s8test_vornq_s8test_vorn_s16test_vornq_s16test_vorn_s32test_vornq_s32test_vorn_s64test_vornq_s64test_vorn_u8test_vornq_u8test_vorn_u16test_vornq_u16test_vorn_u32test_vornq_u32test_vorn_u64test_vornq_u64test_vmovn_s16test_vmovn_s32test_vmovn_s64test_vmovn_u16test_vmovn_u32test_vmovn_u64test_vmovl_s8test_vmovl_s16test_vmovl_s32test_vmovl_u8test_vmovl_u16test_vmovl_u32test_vand_s8test_vandq_s8test_vand_s16test_vandq_s16test_vand_s32test_vandq_s32test_vand_s64test_vandq_s64test_vand_u8test_vandq_u8test_vand_u16test_vandq_u16test_vand_u32test_vandq_u32test_vand_u64test_vandq_u64test_vorr_s8test_vorrq_s8test_vorr_s16test_vorrq_s16test_vorr_s32test_vorrq_s32test_vorr_s64test_vorrq_s64test_vorr_u8test_vorrq_u8test_vorr_u16test_vorrq_u16test_vorr_u32test_vorrq_u32test_vorr_u64test_vorrq_u64test_veor_s8test_veorq_s8test_veor_s16test_veorq_s16test_veor_s32test_veorq_s32test_veor_s64test_veorq_s64test_veor_u8test_veorq_u8test_veor_u16test_veorq_u16test_veor_u32test_veorq_u32test_veor_u64test_veorq_u64test_vceq_s8test_vceqq_s8test_vceq_s16test_vceqq_s16test_vceq_s32test_vceqq_s32test_vceq_u8test_vceqq_u8test_vceq_u16test_vceqq_u16test_vceq_u32test_vceqq_u32test_vceq_f32test_vceqq_f32test_vcgt_s8test_vcgtq_s8test_vcgt_s16test_vcgtq_s16test_vcgt_s32test_vcgtq_s32test_vcgt_u8test_vcgtq_u8test_vcgt_u16test_vcgtq_u16test_vcgt_u32test_vcgtq_u32test_vcgt_f32test_vcgtq_f32test_vclt_s8test_vcltq_s8test_vclt_s16test_vcltq_s16test_vclt_s32test_vcltq_s32test_vclt_u8test_vcltq_u8test_vclt_u16test_vcltq_u16test_vclt_u32test_vcltq_u32test_vclt_f32test_vcltq_f32test_vcle_s8test_vcleq_s8test_vcle_s16test_vcleq_s16test_vcle_s32test_vcleq_s32test_vcle_u8test_vcleq_u8test_vcle_u16test_vcleq_u16test_vcle_u32test_vcleq_u32test_vcle_f32test_vcleq_f32test_vcge_s8test_vcgeq_s8test_vcge_s16test_vcgeq_s16test_vcge_s32test_vcgeq_s32test_vcge_u8test_vcgeq_u8test_vcge_u16test_vcgeq_u16test_vcge_u32test_vcgeq_u32test_vcge_f32test_vcgeq_f32test_vqsub_s8test_vqsubq_s8test_vqsub_s16test_vqsubq_s16test_vqsub_s32test_vqsubq_s32test_vqsub_u8test_vqsubq_u8test_vqsub_u16test_vqsubq_u16test_vqsub_u32test_vqsubq_u32test_vhadd_s8test_vhaddq_s8test_vhadd_s16test_vhaddq_s16test_vhadd_s32test_vhaddq_s32test_vhadd_u8test_vhaddq_u8test_vhadd_u16test_vhaddq_u16test_vhadd_u32test_vhaddq_u32test_vrhadd_s8test_vrhaddq_s8test_vrhadd_s16test_vrhaddq_s16test_vrhadd_s32test_vrhaddq_s32test_vrhadd_u8test_vrhaddq_u8test_vrhadd_u16test_vrhaddq_u16test_vrhadd_u32test_vrhaddq_u32test_vqadd_s8test_vqaddq_s8test_vqadd_s16test_vqaddq_s16test_vqadd_s32test_vqaddq_s32test_vqadd_u8test_vqaddq_u8test_vqadd_u16test_vqaddq_u16test_vqadd_u32test_vqaddq_u32test_vmul_s8test_vmulq_s8test_vmul_s16test_vmulq_s16test_vmul_s32test_vmulq_s32test_vmul_u8test_vmulq_u8test_vmul_u16test_vmulq_u16test_vmul_u32test_vmulq_u32test_vmul_f32test_vmulq_f32test_vsub_s8test_vsubq_s8test_vsub_s16test_vsubq_s16test_vsub_s32test_vsubq_s32test_vsub_u8test_vsubq_u8test_vsub_u16test_vsubq_u16test_vsub_u32test_vsubq_u32test_vsub_f32test_vsubq_f32test_vhsub_s8test_vhsubq_s8test_vhsub_s16test_vhsubq_s16test_vhsub_s32test_vhsubq_s32test_vhsub_u8test_vhsubq_u8test_vhsub_u16test_vhsubq_u16test_vhsub_u32test_vhsubq_u32test_vaba_s8test_vaba_s16test_vaba_s32test_vaba_u8test_vaba_u16test_vaba_u32test_vabaq_s8test_vabaq_s16test_vabaq_s32test_vabaq_u8test_vabaq_u16test_vabaq_u32test_vrev16_s8test_vrev16q_s8test_vrev16_u8test_vrev16q_u8test_vrev16_p8test_vrev16q_p8test_vrev32_s8test_vrev32q_s8test_vrev32_u8test_vrev32q_u8test_vrev32_s16test_vrev32q_s16test_vrev32_p16test_vrev32q_p16test_vrev32_u16test_vrev32q_u16test_vrev32_p8test_vrev32q_p8test_vrev64_s8test_vrev64q_s8test_vrev64_s16test_vrev64q_s16test_vrev64_s32test_vrev64q_s32test_vrev64_u8test_vrev64q_u8test_vrev64_u16test_vrev64q_u16test_vrev64_u32test_vrev64q_u32test_vrev64_f32test_vrev64q_f32test_vrev64_p8test_vrev64q_p8test_vrev64_p16test_vrev64q_p16test_vcombinefp16// note: poly32x4 does not exist, and neither does vcombine_p32//! ARMv7 NEON intrinsicstest_vslitest_vsri//! Tests for ARM+v7+neon shift and insert (vsli[q]_n, vsri[q]_n) intrinsics.//test_vsli!(test_vsli_n_p64, i64 => vsli_n_p64([333333], [1028], 45));//test_vsli!(test_vsliq_n_p64, i64 => vsliq_n_p64([333333, 52023], [1028, 99814], 33));//test_vsri!(test_vsri_n_p64, i64 => vsri_n_p64([333333], [1028], 45));//test_vsri!(test_vsriq_n_p64, i64 => vsriq_n_p64([333333, 52023], [1028, 99814], 33));test_vst1_s8test_vst1q_s8test_vst1_s16test_vst1q_s16test_vst1_s32test_vst1q_s32test_vst1_s64test_vst1q_s64test_vst1_u8test_vst1q_u8test_vst1_u16test_vst1q_u16test_vst1_u32test_vst1q_u32test_vst1_u64test_vst1q_u64test_vst1_p8test_vst1q_p8test_vst1_p16test_vst1q_p16test_vst1_p64test_vst1q_p64test_vst1_f32test_vst1q_f32//! Tests for ARM+v7+neon store (vst1) intrinsics.test_vtbltest_vtbx//! Tests for ARM+v7+neon table lookup (vtbl, vtbx) intrinsics.// ARM+v7+neon and AArch64+neon tests// Aarch64 testsV_u8V_u16V_u32V_i8V_i16V_i32V_i64V_f32"llvm.loongarch.cacop.w"__cacop"llvm.loongarch.csrrd.w"__csrrd"llvm.loongarch.csrwr.w"__csrwr"llvm.loongarch.csrxchg.w"__csrxchgIMM_S12cacop/// Generates the cache operation instructionIMM14csrrd/// Reads the CSRcsrwr/// Writes the CSRcsrxchg/// Exchanges the CSR//! `LoongArch32` intrinsics"llvm.loongarch.lasx.xvsll.b"__lasx_xvsll_b__v32i8"llvm.loongarch.lasx.xvsll.h"__lasx_xvsll_h__v16i16"llvm.loongarch.lasx.xvsll.w"__lasx_xvsll_w__v8i32"llvm.loongarch.lasx.xvsll.d"__lasx_xvsll_d__v4i64"llvm.loongarch.lasx.xvslli.b"__lasx_xvslli_b"llvm.loongarch.lasx.xvslli.h"__lasx_xvslli_h"llvm.loongarch.lasx.xvslli.w"__lasx_xvslli_w"llvm.loongarch.lasx.xvslli.d"__lasx_xvslli_d"llvm.loongarch.lasx.xvsra.b"__lasx_xvsra_b"llvm.loongarch.lasx.xvsra.h"__lasx_xvsra_h"llvm.loongarch.lasx.xvsra.w"__lasx_xvsra_w"llvm.loongarch.lasx.xvsra.d"__lasx_xvsra_d"llvm.loongarch.lasx.xvsrai.b"__lasx_xvsrai_b"llvm.loongarch.lasx.xvsrai.h"__lasx_xvsrai_h"llvm.loongarch.lasx.xvsrai.w"__lasx_xvsrai_w"llvm.loongarch.lasx.xvsrai.d"__lasx_xvsrai_d"llvm.loongarch.lasx.xvsrar.b"__lasx_xvsrar_b"llvm.loongarch.lasx.xvsrar.h"__lasx_xvsrar_h"llvm.loongarch.lasx.xvsrar.w"__lasx_xvsrar_w"llvm.loongarch.lasx.xvsrar.d"__lasx_xvsrar_d"llvm.loongarch.lasx.xvsrari.b"__lasx_xvsrari_b"llvm.loongarch.lasx.xvsrari.h"__lasx_xvsrari_h"llvm.loongarch.lasx.xvsrari.w"__lasx_xvsrari_w"llvm.loongarch.lasx.xvsrari.d"__lasx_xvsrari_d"llvm.loongarch.lasx.xvsrl.b"__lasx_xvsrl_b"llvm.loongarch.lasx.xvsrl.h"__lasx_xvsrl_h"llvm.loongarch.lasx.xvsrl.w"__lasx_xvsrl_w"llvm.loongarch.lasx.xvsrl.d"__lasx_xvsrl_d"llvm.loongarch.lasx.xvsrli.b"__lasx_xvsrli_b"llvm.loongarch.lasx.xvsrli.h"__lasx_xvsrli_h"llvm.loongarch.lasx.xvsrli.w"__lasx_xvsrli_w"llvm.loongarch.lasx.xvsrli.d"__lasx_xvsrli_d"llvm.loongarch.lasx.xvsrlr.b"__lasx_xvsrlr_b"llvm.loongarch.lasx.xvsrlr.h"__lasx_xvsrlr_h"llvm.loongarch.lasx.xvsrlr.w"__lasx_xvsrlr_w"llvm.loongarch.lasx.xvsrlr.d"__lasx_xvsrlr_d"llvm.loongarch.lasx.xvsrlri.b"__lasx_xvsrlri_b"llvm.loongarch.lasx.xvsrlri.h"__lasx_xvsrlri_h"llvm.loongarch.lasx.xvsrlri.w"__lasx_xvsrlri_w"llvm.loongarch.lasx.xvsrlri.d"__lasx_xvsrlri_d"llvm.loongarch.lasx.xvbitclr.b"__lasx_xvbitclr_b__v32u8"llvm.loongarch.lasx.xvbitclr.h"__lasx_xvbitclr_h__v16u16"llvm.loongarch.lasx.xvbitclr.w"__lasx_xvbitclr_w__v8u32"llvm.loongarch.lasx.xvbitclr.d"__lasx_xvbitclr_d__v4u64"llvm.loongarch.lasx.xvbitclri.b"__lasx_xvbitclri_b"llvm.loongarch.lasx.xvbitclri.h"__lasx_xvbitclri_h"llvm.loongarch.lasx.xvbitclri.w"__lasx_xvbitclri_w"llvm.loongarch.lasx.xvbitclri.d"__lasx_xvbitclri_d"llvm.loongarch.lasx.xvbitset.b"__lasx_xvbitset_b"llvm.loongarch.lasx.xvbitset.h"__lasx_xvbitset_h"llvm.loongarch.lasx.xvbitset.w"__lasx_xvbitset_w"llvm.loongarch.lasx.xvbitset.d"__lasx_xvbitset_d"llvm.loongarch.lasx.xvbitseti.b"__lasx_xvbitseti_b"llvm.loongarch.lasx.xvbitseti.h"__lasx_xvbitseti_h"llvm.loongarch.lasx.xvbitseti.w"__lasx_xvbitseti_w"llvm.loongarch.lasx.xvbitseti.d"__lasx_xvbitseti_d"llvm.loongarch.lasx.xvbitrev.b"__lasx_xvbitrev_b"llvm.loongarch.lasx.xvbitrev.h"__lasx_xvbitrev_h"llvm.loongarch.lasx.xvbitrev.w"__lasx_xvbitrev_w"llvm.loongarch.lasx.xvbitrev.d"__lasx_xvbitrev_d"llvm.loongarch.lasx.xvbitrevi.b"__lasx_xvbitrevi_b"llvm.loongarch.lasx.xvbitrevi.h"__lasx_xvbitrevi_h"llvm.loongarch.lasx.xvbitrevi.w"__lasx_xvbitrevi_w"llvm.loongarch.lasx.xvbitrevi.d"__lasx_xvbitrevi_d"llvm.loongarch.lasx.xvadd.b"__lasx_xvadd_b"llvm.loongarch.lasx.xvadd.h"__lasx_xvadd_h"llvm.loongarch.lasx.xvadd.w"__lasx_xvadd_w"llvm.loongarch.lasx.xvadd.d"__lasx_xvadd_d"llvm.loongarch.lasx.xvaddi.bu"__lasx_xvaddi_bu"llvm.loongarch.lasx.xvaddi.hu"__lasx_xvaddi_hu"llvm.loongarch.lasx.xvaddi.wu"__lasx_xvaddi_wu"llvm.loongarch.lasx.xvaddi.du"__lasx_xvaddi_du"llvm.loongarch.lasx.xvsub.b"__lasx_xvsub_b"llvm.loongarch.lasx.xvsub.h"__lasx_xvsub_h"llvm.loongarch.lasx.xvsub.w"__lasx_xvsub_w"llvm.loongarch.lasx.xvsub.d"__lasx_xvsub_d"llvm.loongarch.lasx.xvsubi.bu"__lasx_xvsubi_bu"llvm.loongarch.lasx.xvsubi.hu"__lasx_xvsubi_hu"llvm.loongarch.lasx.xvsubi.wu"__lasx_xvsubi_wu"llvm.loongarch.lasx.xvsubi.du"__lasx_xvsubi_du"llvm.loongarch.lasx.xvmax.b"__lasx_xvmax_b"llvm.loongarch.lasx.xvmax.h"__lasx_xvmax_h"llvm.loongarch.lasx.xvmax.w"__lasx_xvmax_w"llvm.loongarch.lasx.xvmax.d"__lasx_xvmax_d"llvm.loongarch.lasx.xvmaxi.b"__lasx_xvmaxi_b"llvm.loongarch.lasx.xvmaxi.h"__lasx_xvmaxi_h"llvm.loongarch.lasx.xvmaxi.w"__lasx_xvmaxi_w"llvm.loongarch.lasx.xvmaxi.d"__lasx_xvmaxi_d"llvm.loongarch.lasx.xvmax.bu"__lasx_xvmax_bu"llvm.loongarch.lasx.xvmax.hu"__lasx_xvmax_hu"llvm.loongarch.lasx.xvmax.wu"__lasx_xvmax_wu"llvm.loongarch.lasx.xvmax.du"__lasx_xvmax_du"llvm.loongarch.lasx.xvmaxi.bu"__lasx_xvmaxi_bu"llvm.loongarch.lasx.xvmaxi.hu"__lasx_xvmaxi_hu"llvm.loongarch.lasx.xvmaxi.wu"__lasx_xvmaxi_wu"llvm.loongarch.lasx.xvmaxi.du"__lasx_xvmaxi_du"llvm.loongarch.lasx.xvmin.b"__lasx_xvmin_b"llvm.loongarch.lasx.xvmin.h"__lasx_xvmin_h"llvm.loongarch.lasx.xvmin.w"__lasx_xvmin_w"llvm.loongarch.lasx.xvmin.d"__lasx_xvmin_d"llvm.loongarch.lasx.xvmini.b"__lasx_xvmini_b"llvm.loongarch.lasx.xvmini.h"__lasx_xvmini_h"llvm.loongarch.lasx.xvmini.w"__lasx_xvmini_w"llvm.loongarch.lasx.xvmini.d"__lasx_xvmini_d"llvm.loongarch.lasx.xvmin.bu"__lasx_xvmin_bu"llvm.loongarch.lasx.xvmin.hu"__lasx_xvmin_hu"llvm.loongarch.lasx.xvmin.wu"__lasx_xvmin_wu"llvm.loongarch.lasx.xvmin.du"__lasx_xvmin_du"llvm.loongarch.lasx.xvmini.bu"__lasx_xvmini_bu"llvm.loongarch.lasx.xvmini.hu"__lasx_xvmini_hu"llvm.loongarch.lasx.xvmini.wu"__lasx_xvmini_wu"llvm.loongarch.lasx.xvmini.du"__lasx_xvmini_du"llvm.loongarch.lasx.xvseq.b"__lasx_xvseq_b"llvm.loongarch.lasx.xvseq.h"__lasx_xvseq_h"llvm.loongarch.lasx.xvseq.w"__lasx_xvseq_w"llvm.loongarch.lasx.xvseq.d"__lasx_xvseq_d"llvm.loongarch.lasx.xvseqi.b"__lasx_xvseqi_b"llvm.loongarch.lasx.xvseqi.h"__lasx_xvseqi_h"llvm.loongarch.lasx.xvseqi.w"__lasx_xvseqi_w"llvm.loongarch.lasx.xvseqi.d"__lasx_xvseqi_d"llvm.loongarch.lasx.xvslt.b"__lasx_xvslt_b"llvm.loongarch.lasx.xvslt.h"__lasx_xvslt_h"llvm.loongarch.lasx.xvslt.w"__lasx_xvslt_w"llvm.loongarch.lasx.xvslt.d"__lasx_xvslt_d"llvm.loongarch.lasx.xvslti.b"__lasx_xvslti_b"llvm.loongarch.lasx.xvslti.h"__lasx_xvslti_h"llvm.loongarch.lasx.xvslti.w"__lasx_xvslti_w"llvm.loongarch.lasx.xvslti.d"__lasx_xvslti_d"llvm.loongarch.lasx.xvslt.bu"__lasx_xvslt_bu"llvm.loongarch.lasx.xvslt.hu"__lasx_xvslt_hu"llvm.loongarch.lasx.xvslt.wu"__lasx_xvslt_wu"llvm.loongarch.lasx.xvslt.du"__lasx_xvslt_du"llvm.loongarch.lasx.xvslti.bu"__lasx_xvslti_bu"llvm.loongarch.lasx.xvslti.hu"__lasx_xvslti_hu"llvm.loongarch.lasx.xvslti.wu"__lasx_xvslti_wu"llvm.loongarch.lasx.xvslti.du"__lasx_xvslti_du"llvm.loongarch.lasx.xvsle.b"__lasx_xvsle_b"llvm.loongarch.lasx.xvsle.h"__lasx_xvsle_h"llvm.loongarch.lasx.xvsle.w"__lasx_xvsle_w"llvm.loongarch.lasx.xvsle.d"__lasx_xvsle_d"llvm.loongarch.lasx.xvslei.b"__lasx_xvslei_b"llvm.loongarch.lasx.xvslei.h"__lasx_xvslei_h"llvm.loongarch.lasx.xvslei.w"__lasx_xvslei_w"llvm.loongarch.lasx.xvslei.d"__lasx_xvslei_d"llvm.loongarch.lasx.xvsle.bu"__lasx_xvsle_bu"llvm.loongarch.lasx.xvsle.hu"__lasx_xvsle_hu"llvm.loongarch.lasx.xvsle.wu"__lasx_xvsle_wu"llvm.loongarch.lasx.xvsle.du"__lasx_xvsle_du"llvm.loongarch.lasx.xvslei.bu"__lasx_xvslei_bu"llvm.loongarch.lasx.xvslei.hu"__lasx_xvslei_hu"llvm.loongarch.lasx.xvslei.wu"__lasx_xvslei_wu"llvm.loongarch.lasx.xvslei.du"__lasx_xvslei_du"llvm.loongarch.lasx.xvsat.b"__lasx_xvsat_b"llvm.loongarch.lasx.xvsat.h"__lasx_xvsat_h"llvm.loongarch.lasx.xvsat.w"__lasx_xvsat_w"llvm.loongarch.lasx.xvsat.d"__lasx_xvsat_d"llvm.loongarch.lasx.xvsat.bu"__lasx_xvsat_bu"llvm.loongarch.lasx.xvsat.hu"__lasx_xvsat_hu"llvm.loongarch.lasx.xvsat.wu"__lasx_xvsat_wu"llvm.loongarch.lasx.xvsat.du"__lasx_xvsat_du"llvm.loongarch.lasx.xvadda.b"__lasx_xvadda_b"llvm.loongarch.lasx.xvadda.h"__lasx_xvadda_h"llvm.loongarch.lasx.xvadda.w"__lasx_xvadda_w"llvm.loongarch.lasx.xvadda.d"__lasx_xvadda_d"llvm.loongarch.lasx.xvsadd.b"__lasx_xvsadd_b"llvm.loongarch.lasx.xvsadd.h"__lasx_xvsadd_h"llvm.loongarch.lasx.xvsadd.w"__lasx_xvsadd_w"llvm.loongarch.lasx.xvsadd.d"__lasx_xvsadd_d"llvm.loongarch.lasx.xvsadd.bu"__lasx_xvsadd_bu"llvm.loongarch.lasx.xvsadd.hu"__lasx_xvsadd_hu"llvm.loongarch.lasx.xvsadd.wu"__lasx_xvsadd_wu"llvm.loongarch.lasx.xvsadd.du"__lasx_xvsadd_du"llvm.loongarch.lasx.xvavg.b"__lasx_xvavg_b"llvm.loongarch.lasx.xvavg.h"__lasx_xvavg_h"llvm.loongarch.lasx.xvavg.w"__lasx_xvavg_w"llvm.loongarch.lasx.xvavg.d"__lasx_xvavg_d"llvm.loongarch.lasx.xvavg.bu"__lasx_xvavg_bu"llvm.loongarch.lasx.xvavg.hu"__lasx_xvavg_hu"llvm.loongarch.lasx.xvavg.wu"__lasx_xvavg_wu"llvm.loongarch.lasx.xvavg.du"__lasx_xvavg_du"llvm.loongarch.lasx.xvavgr.b"__lasx_xvavgr_b"llvm.loongarch.lasx.xvavgr.h"__lasx_xvavgr_h"llvm.loongarch.lasx.xvavgr.w"__lasx_xvavgr_w"llvm.loongarch.lasx.xvavgr.d"__lasx_xvavgr_d"llvm.loongarch.lasx.xvavgr.bu"__lasx_xvavgr_bu"llvm.loongarch.lasx.xvavgr.hu"__lasx_xvavgr_hu"llvm.loongarch.lasx.xvavgr.wu"__lasx_xvavgr_wu"llvm.loongarch.lasx.xvavgr.du"__lasx_xvavgr_du"llvm.loongarch.lasx.xvssub.b"__lasx_xvssub_b"llvm.loongarch.lasx.xvssub.h"__lasx_xvssub_h"llvm.loongarch.lasx.xvssub.w"__lasx_xvssub_w"llvm.loongarch.lasx.xvssub.d"__lasx_xvssub_d"llvm.loongarch.lasx.xvssub.bu"__lasx_xvssub_bu"llvm.loongarch.lasx.xvssub.hu"__lasx_xvssub_hu"llvm.loongarch.lasx.xvssub.wu"__lasx_xvssub_wu"llvm.loongarch.lasx.xvssub.du"__lasx_xvssub_du"llvm.loongarch.lasx.xvabsd.b"__lasx_xvabsd_b"llvm.loongarch.lasx.xvabsd.h"__lasx_xvabsd_h"llvm.loongarch.lasx.xvabsd.w"__lasx_xvabsd_w"llvm.loongarch.lasx.xvabsd.d"__lasx_xvabsd_d"llvm.loongarch.lasx.xvabsd.bu"__lasx_xvabsd_bu"llvm.loongarch.lasx.xvabsd.hu"__lasx_xvabsd_hu"llvm.loongarch.lasx.xvabsd.wu"__lasx_xvabsd_wu"llvm.loongarch.lasx.xvabsd.du"__lasx_xvabsd_du"llvm.loongarch.lasx.xvmul.b"__lasx_xvmul_b"llvm.loongarch.lasx.xvmul.h"__lasx_xvmul_h"llvm.loongarch.lasx.xvmul.w"__lasx_xvmul_w"llvm.loongarch.lasx.xvmul.d"__lasx_xvmul_d"llvm.loongarch.lasx.xvmadd.b"__lasx_xvmadd_b"llvm.loongarch.lasx.xvmadd.h"__lasx_xvmadd_h"llvm.loongarch.lasx.xvmadd.w"__lasx_xvmadd_w"llvm.loongarch.lasx.xvmadd.d"__lasx_xvmadd_d"llvm.loongarch.lasx.xvmsub.b"__lasx_xvmsub_b"llvm.loongarch.lasx.xvmsub.h"__lasx_xvmsub_h"llvm.loongarch.lasx.xvmsub.w"__lasx_xvmsub_w"llvm.loongarch.lasx.xvmsub.d"__lasx_xvmsub_d"llvm.loongarch.lasx.xvdiv.b"__lasx_xvdiv_b"llvm.loongarch.lasx.xvdiv.h"__lasx_xvdiv_h"llvm.loongarch.lasx.xvdiv.w"__lasx_xvdiv_w"llvm.loongarch.lasx.xvdiv.d"__lasx_xvdiv_d"llvm.loongarch.lasx.xvdiv.bu"__lasx_xvdiv_bu"llvm.loongarch.lasx.xvdiv.hu"__lasx_xvdiv_hu"llvm.loongarch.lasx.xvdiv.wu"__lasx_xvdiv_wu"llvm.loongarch.lasx.xvdiv.du"__lasx_xvdiv_du"llvm.loongarch.lasx.xvhaddw.h.b"__lasx_xvhaddw_h_b"llvm.loongarch.lasx.xvhaddw.w.h"__lasx_xvhaddw_w_h"llvm.loongarch.lasx.xvhaddw.d.w"__lasx_xvhaddw_d_w"llvm.loongarch.lasx.xvhaddw.hu.bu"__lasx_xvhaddw_hu_bu"llvm.loongarch.lasx.xvhaddw.wu.hu"__lasx_xvhaddw_wu_hu"llvm.loongarch.lasx.xvhaddw.du.wu"__lasx_xvhaddw_du_wu"llvm.loongarch.lasx.xvhsubw.h.b"__lasx_xvhsubw_h_b"llvm.loongarch.lasx.xvhsubw.w.h"__lasx_xvhsubw_w_h"llvm.loongarch.lasx.xvhsubw.d.w"__lasx_xvhsubw_d_w"llvm.loongarch.lasx.xvhsubw.hu.bu"__lasx_xvhsubw_hu_bu"llvm.loongarch.lasx.xvhsubw.wu.hu"__lasx_xvhsubw_wu_hu"llvm.loongarch.lasx.xvhsubw.du.wu"__lasx_xvhsubw_du_wu"llvm.loongarch.lasx.xvmod.b"__lasx_xvmod_b"llvm.loongarch.lasx.xvmod.h"__lasx_xvmod_h"llvm.loongarch.lasx.xvmod.w"__lasx_xvmod_w"llvm.loongarch.lasx.xvmod.d"__lasx_xvmod_d"llvm.loongarch.lasx.xvmod.bu"__lasx_xvmod_bu"llvm.loongarch.lasx.xvmod.hu"__lasx_xvmod_hu"llvm.loongarch.lasx.xvmod.wu"__lasx_xvmod_wu"llvm.loongarch.lasx.xvmod.du"__lasx_xvmod_du"llvm.loongarch.lasx.xvrepl128vei.b"__lasx_xvrepl128vei_b"llvm.loongarch.lasx.xvrepl128vei.h"__lasx_xvrepl128vei_h"llvm.loongarch.lasx.xvrepl128vei.w"__lasx_xvrepl128vei_w"llvm.loongarch.lasx.xvrepl128vei.d"__lasx_xvrepl128vei_d"llvm.loongarch.lasx.xvpickev.b"__lasx_xvpickev_b"llvm.loongarch.lasx.xvpickev.h"__lasx_xvpickev_h"llvm.loongarch.lasx.xvpickev.w"__lasx_xvpickev_w"llvm.loongarch.lasx.xvpickev.d"__lasx_xvpickev_d"llvm.loongarch.lasx.xvpickod.b"__lasx_xvpickod_b"llvm.loongarch.lasx.xvpickod.h"__lasx_xvpickod_h"llvm.loongarch.lasx.xvpickod.w"__lasx_xvpickod_w"llvm.loongarch.lasx.xvpickod.d"__lasx_xvpickod_d"llvm.loongarch.lasx.xvilvh.b"__lasx_xvilvh_b"llvm.loongarch.lasx.xvilvh.h"__lasx_xvilvh_h"llvm.loongarch.lasx.xvilvh.w"__lasx_xvilvh_w"llvm.loongarch.lasx.xvilvh.d"__lasx_xvilvh_d"llvm.loongarch.lasx.xvilvl.b"__lasx_xvilvl_b"llvm.loongarch.lasx.xvilvl.h"__lasx_xvilvl_h"llvm.loongarch.lasx.xvilvl.w"__lasx_xvilvl_w"llvm.loongarch.lasx.xvilvl.d"__lasx_xvilvl_d"llvm.loongarch.lasx.xvpackev.b"__lasx_xvpackev_b"llvm.loongarch.lasx.xvpackev.h"__lasx_xvpackev_h"llvm.loongarch.lasx.xvpackev.w"__lasx_xvpackev_w"llvm.loongarch.lasx.xvpackev.d"__lasx_xvpackev_d"llvm.loongarch.lasx.xvpackod.b"__lasx_xvpackod_b"llvm.loongarch.lasx.xvpackod.h"__lasx_xvpackod_h"llvm.loongarch.lasx.xvpackod.w"__lasx_xvpackod_w"llvm.loongarch.lasx.xvpackod.d"__lasx_xvpackod_d"llvm.loongarch.lasx.xvshuf.b"__lasx_xvshuf_b"llvm.loongarch.lasx.xvshuf.h"__lasx_xvshuf_h"llvm.loongarch.lasx.xvshuf.w"__lasx_xvshuf_w"llvm.loongarch.lasx.xvshuf.d"__lasx_xvshuf_d"llvm.loongarch.lasx.xvand.v"__lasx_xvand_v"llvm.loongarch.lasx.xvandi.b"__lasx_xvandi_b"llvm.loongarch.lasx.xvor.v"__lasx_xvor_v"llvm.loongarch.lasx.xvori.b"__lasx_xvori_b"llvm.loongarch.lasx.xvnor.v"__lasx_xvnor_v"llvm.loongarch.lasx.xvnori.b"__lasx_xvnori_b"llvm.loongarch.lasx.xvxor.v"__lasx_xvxor_v"llvm.loongarch.lasx.xvxori.b"__lasx_xvxori_b"llvm.loongarch.lasx.xvbitsel.v"__lasx_xvbitsel_v"llvm.loongarch.lasx.xvbitseli.b"__lasx_xvbitseli_b"llvm.loongarch.lasx.xvshuf4i.b"__lasx_xvshuf4i_b"llvm.loongarch.lasx.xvshuf4i.h"__lasx_xvshuf4i_h"llvm.loongarch.lasx.xvshuf4i.w"__lasx_xvshuf4i_w"llvm.loongarch.lasx.xvreplgr2vr.b"__lasx_xvreplgr2vr_b"llvm.loongarch.lasx.xvreplgr2vr.h"__lasx_xvreplgr2vr_h"llvm.loongarch.lasx.xvreplgr2vr.w"__lasx_xvreplgr2vr_w"llvm.loongarch.lasx.xvreplgr2vr.d"__lasx_xvreplgr2vr_d"llvm.loongarch.lasx.xvpcnt.b"__lasx_xvpcnt_b"llvm.loongarch.lasx.xvpcnt.h"__lasx_xvpcnt_h"llvm.loongarch.lasx.xvpcnt.w"__lasx_xvpcnt_w"llvm.loongarch.lasx.xvpcnt.d"__lasx_xvpcnt_d"llvm.loongarch.lasx.xvclo.b"__lasx_xvclo_b"llvm.loongarch.lasx.xvclo.h"__lasx_xvclo_h"llvm.loongarch.lasx.xvclo.w"__lasx_xvclo_w"llvm.loongarch.lasx.xvclo.d"__lasx_xvclo_d"llvm.loongarch.lasx.xvclz.b"__lasx_xvclz_b"llvm.loongarch.lasx.xvclz.h"__lasx_xvclz_h"llvm.loongarch.lasx.xvclz.w"__lasx_xvclz_w"llvm.loongarch.lasx.xvclz.d"__lasx_xvclz_d"llvm.loongarch.lasx.xvfadd.s"__lasx_xvfadd_s__v8f32"llvm.loongarch.lasx.xvfadd.d"__lasx_xvfadd_d__v4f64"llvm.loongarch.lasx.xvfsub.s"__lasx_xvfsub_s"llvm.loongarch.lasx.xvfsub.d"__lasx_xvfsub_d"llvm.loongarch.lasx.xvfmul.s"__lasx_xvfmul_s"llvm.loongarch.lasx.xvfmul.d"__lasx_xvfmul_d"llvm.loongarch.lasx.xvfdiv.s"__lasx_xvfdiv_s"llvm.loongarch.lasx.xvfdiv.d"__lasx_xvfdiv_d"llvm.loongarch.lasx.xvfcvt.h.s"__lasx_xvfcvt_h_s"llvm.loongarch.lasx.xvfcvt.s.d"__lasx_xvfcvt_s_d"llvm.loongarch.lasx.xvfmin.s"__lasx_xvfmin_s"llvm.loongarch.lasx.xvfmin.d"__lasx_xvfmin_d"llvm.loongarch.lasx.xvfmina.s"__lasx_xvfmina_s"llvm.loongarch.lasx.xvfmina.d"__lasx_xvfmina_d"llvm.loongarch.lasx.xvfmax.s"__lasx_xvfmax_s"llvm.loongarch.lasx.xvfmax.d"__lasx_xvfmax_d"llvm.loongarch.lasx.xvfmaxa.s"__lasx_xvfmaxa_s"llvm.loongarch.lasx.xvfmaxa.d"__lasx_xvfmaxa_d"llvm.loongarch.lasx.xvfclass.s"__lasx_xvfclass_s"llvm.loongarch.lasx.xvfclass.d"__lasx_xvfclass_d"llvm.loongarch.lasx.xvfsqrt.s"__lasx_xvfsqrt_s"llvm.loongarch.lasx.xvfsqrt.d"__lasx_xvfsqrt_d"llvm.loongarch.lasx.xvfrecip.s"__lasx_xvfrecip_s"llvm.loongarch.lasx.xvfrecip.d"__lasx_xvfrecip_d"llvm.loongarch.lasx.xvfrecipe.s"__lasx_xvfrecipe_s"llvm.loongarch.lasx.xvfrecipe.d"__lasx_xvfrecipe_d"llvm.loongarch.lasx.xvfrsqrte.s"__lasx_xvfrsqrte_s"llvm.loongarch.lasx.xvfrsqrte.d"__lasx_xvfrsqrte_d"llvm.loongarch.lasx.xvfrint.s"__lasx_xvfrint_s"llvm.loongarch.lasx.xvfrint.d"__lasx_xvfrint_d"llvm.loongarch.lasx.xvfrsqrt.s"__lasx_xvfrsqrt_s"llvm.loongarch.lasx.xvfrsqrt.d"__lasx_xvfrsqrt_d"llvm.loongarch.lasx.xvflogb.s"__lasx_xvflogb_s"llvm.loongarch.lasx.xvflogb.d"__lasx_xvflogb_d"llvm.loongarch.lasx.xvfcvth.s.h"__lasx_xvfcvth_s_h"llvm.loongarch.lasx.xvfcvth.d.s"__lasx_xvfcvth_d_s"llvm.loongarch.lasx.xvfcvtl.s.h"__lasx_xvfcvtl_s_h"llvm.loongarch.lasx.xvfcvtl.d.s"__lasx_xvfcvtl_d_s"llvm.loongarch.lasx.xvftint.w.s"__lasx_xvftint_w_s"llvm.loongarch.lasx.xvftint.l.d"__lasx_xvftint_l_d"llvm.loongarch.lasx.xvftint.wu.s"__lasx_xvftint_wu_s"llvm.loongarch.lasx.xvftint.lu.d"__lasx_xvftint_lu_d"llvm.loongarch.lasx.xvftintrz.w.s"__lasx_xvftintrz_w_s"llvm.loongarch.lasx.xvftintrz.l.d"__lasx_xvftintrz_l_d"llvm.loongarch.lasx.xvftintrz.wu.s"__lasx_xvftintrz_wu_s"llvm.loongarch.lasx.xvftintrz.lu.d"__lasx_xvftintrz_lu_d"llvm.loongarch.lasx.xvffint.s.w"__lasx_xvffint_s_w"llvm.loongarch.lasx.xvffint.d.l"__lasx_xvffint_d_l"llvm.loongarch.lasx.xvffint.s.wu"__lasx_xvffint_s_wu"llvm.loongarch.lasx.xvffint.d.lu"__lasx_xvffint_d_lu"llvm.loongarch.lasx.xvreplve.b"__lasx_xvreplve_b"llvm.loongarch.lasx.xvreplve.h"__lasx_xvreplve_h"llvm.loongarch.lasx.xvreplve.w"__lasx_xvreplve_w"llvm.loongarch.lasx.xvreplve.d"__lasx_xvreplve_d"llvm.loongarch.lasx.xvpermi.w"__lasx_xvpermi_w"llvm.loongarch.lasx.xvandn.v"__lasx_xvandn_v"llvm.loongarch.lasx.xvneg.b"__lasx_xvneg_b"llvm.loongarch.lasx.xvneg.h"__lasx_xvneg_h"llvm.loongarch.lasx.xvneg.w"__lasx_xvneg_w"llvm.loongarch.lasx.xvneg.d"__lasx_xvneg_d"llvm.loongarch.lasx.xvmuh.b"__lasx_xvmuh_b"llvm.loongarch.lasx.xvmuh.h"__lasx_xvmuh_h"llvm.loongarch.lasx.xvmuh.w"__lasx_xvmuh_w"llvm.loongarch.lasx.xvmuh.d"__lasx_xvmuh_d"llvm.loongarch.lasx.xvmuh.bu"__lasx_xvmuh_bu"llvm.loongarch.lasx.xvmuh.hu"__lasx_xvmuh_hu"llvm.loongarch.lasx.xvmuh.wu"__lasx_xvmuh_wu"llvm.loongarch.lasx.xvmuh.du"__lasx_xvmuh_du"llvm.loongarch.lasx.xvsllwil.h.b"__lasx_xvsllwil_h_b"llvm.loongarch.lasx.xvsllwil.w.h"__lasx_xvsllwil_w_h"llvm.loongarch.lasx.xvsllwil.d.w"__lasx_xvsllwil_d_w"llvm.loongarch.lasx.xvsllwil.hu.bu"__lasx_xvsllwil_hu_bu"llvm.loongarch.lasx.xvsllwil.wu.hu"__lasx_xvsllwil_wu_hu"llvm.loongarch.lasx.xvsllwil.du.wu"__lasx_xvsllwil_du_wu"llvm.loongarch.lasx.xvsran.b.h"__lasx_xvsran_b_h"llvm.loongarch.lasx.xvsran.h.w"__lasx_xvsran_h_w"llvm.loongarch.lasx.xvsran.w.d"__lasx_xvsran_w_d"llvm.loongarch.lasx.xvssran.b.h"__lasx_xvssran_b_h"llvm.loongarch.lasx.xvssran.h.w"__lasx_xvssran_h_w"llvm.loongarch.lasx.xvssran.w.d"__lasx_xvssran_w_d"llvm.loongarch.lasx.xvssran.bu.h"__lasx_xvssran_bu_h"llvm.loongarch.lasx.xvssran.hu.w"__lasx_xvssran_hu_w"llvm.loongarch.lasx.xvssran.wu.d"__lasx_xvssran_wu_d"llvm.loongarch.lasx.xvsrarn.b.h"__lasx_xvsrarn_b_h"llvm.loongarch.lasx.xvsrarn.h.w"__lasx_xvsrarn_h_w"llvm.loongarch.lasx.xvsrarn.w.d"__lasx_xvsrarn_w_d"llvm.loongarch.lasx.xvssrarn.b.h"__lasx_xvssrarn_b_h"llvm.loongarch.lasx.xvssrarn.h.w"__lasx_xvssrarn_h_w"llvm.loongarch.lasx.xvssrarn.w.d"__lasx_xvssrarn_w_d"llvm.loongarch.lasx.xvssrarn.bu.h"__lasx_xvssrarn_bu_h"llvm.loongarch.lasx.xvssrarn.hu.w"__lasx_xvssrarn_hu_w"llvm.loongarch.lasx.xvssrarn.wu.d"__lasx_xvssrarn_wu_d"llvm.loongarch.lasx.xvsrln.b.h"__lasx_xvsrln_b_h"llvm.loongarch.lasx.xvsrln.h.w"__lasx_xvsrln_h_w"llvm.loongarch.lasx.xvsrln.w.d"__lasx_xvsrln_w_d"llvm.loongarch.lasx.xvssrln.bu.h"__lasx_xvssrln_bu_h"llvm.loongarch.lasx.xvssrln.hu.w"__lasx_xvssrln_hu_w"llvm.loongarch.lasx.xvssrln.wu.d"__lasx_xvssrln_wu_d"llvm.loongarch.lasx.xvsrlrn.b.h"__lasx_xvsrlrn_b_h"llvm.loongarch.lasx.xvsrlrn.h.w"__lasx_xvsrlrn_h_w"llvm.loongarch.lasx.xvsrlrn.w.d"__lasx_xvsrlrn_w_d"llvm.loongarch.lasx.xvssrlrn.bu.h"__lasx_xvssrlrn_bu_h"llvm.loongarch.lasx.xvssrlrn.hu.w"__lasx_xvssrlrn_hu_w"llvm.loongarch.lasx.xvssrlrn.wu.d"__lasx_xvssrlrn_wu_d"llvm.loongarch.lasx.xvfrstpi.b"__lasx_xvfrstpi_b"llvm.loongarch.lasx.xvfrstpi.h"__lasx_xvfrstpi_h"llvm.loongarch.lasx.xvfrstp.b"__lasx_xvfrstp_b"llvm.loongarch.lasx.xvfrstp.h"__lasx_xvfrstp_h"llvm.loongarch.lasx.xvshuf4i.d"__lasx_xvshuf4i_d"llvm.loongarch.lasx.xvbsrl.v"__lasx_xvbsrl_v"llvm.loongarch.lasx.xvbsll.v"__lasx_xvbsll_v"llvm.loongarch.lasx.xvextrins.b"__lasx_xvextrins_b"llvm.loongarch.lasx.xvextrins.h"__lasx_xvextrins_h"llvm.loongarch.lasx.xvextrins.w"__lasx_xvextrins_w"llvm.loongarch.lasx.xvextrins.d"__lasx_xvextrins_d"llvm.loongarch.lasx.xvmskltz.b"__lasx_xvmskltz_b"llvm.loongarch.lasx.xvmskltz.h"__lasx_xvmskltz_h"llvm.loongarch.lasx.xvmskltz.w"__lasx_xvmskltz_w"llvm.loongarch.lasx.xvmskltz.d"__lasx_xvmskltz_d"llvm.loongarch.lasx.xvsigncov.b"__lasx_xvsigncov_b"llvm.loongarch.lasx.xvsigncov.h"__lasx_xvsigncov_h"llvm.loongarch.lasx.xvsigncov.w"__lasx_xvsigncov_w"llvm.loongarch.lasx.xvsigncov.d"__lasx_xvsigncov_d"llvm.loongarch.lasx.xvfmadd.s"__lasx_xvfmadd_s"llvm.loongarch.lasx.xvfmadd.d"__lasx_xvfmadd_d"llvm.loongarch.lasx.xvfmsub.s"__lasx_xvfmsub_s"llvm.loongarch.lasx.xvfmsub.d"__lasx_xvfmsub_d"llvm.loongarch.lasx.xvfnmadd.s"__lasx_xvfnmadd_s"llvm.loongarch.lasx.xvfnmadd.d"__lasx_xvfnmadd_d"llvm.loongarch.lasx.xvfnmsub.s"__lasx_xvfnmsub_s"llvm.loongarch.lasx.xvfnmsub.d"__lasx_xvfnmsub_d"llvm.loongarch.lasx.xvftintrne.w.s"__lasx_xvftintrne_w_s"llvm.loongarch.lasx.xvftintrne.l.d"__lasx_xvftintrne_l_d"llvm.loongarch.lasx.xvftintrp.w.s"__lasx_xvftintrp_w_s"llvm.loongarch.lasx.xvftintrp.l.d"__lasx_xvftintrp_l_d"llvm.loongarch.lasx.xvftintrm.w.s"__lasx_xvftintrm_w_s"llvm.loongarch.lasx.xvftintrm.l.d"__lasx_xvftintrm_l_d"llvm.loongarch.lasx.xvftint.w.d"__lasx_xvftint_w_d"llvm.loongarch.lasx.xvffint.s.l"__lasx_xvffint_s_l"llvm.loongarch.lasx.xvftintrz.w.d"__lasx_xvftintrz_w_d"llvm.loongarch.lasx.xvftintrp.w.d"__lasx_xvftintrp_w_d"llvm.loongarch.lasx.xvftintrm.w.d"__lasx_xvftintrm_w_d"llvm.loongarch.lasx.xvftintrne.w.d"__lasx_xvftintrne_w_d"llvm.loongarch.lasx.xvftinth.l.s"__lasx_xvftinth_l_s"llvm.loongarch.lasx.xvftintl.l.s"__lasx_xvftintl_l_s"llvm.loongarch.lasx.xvffinth.d.w"__lasx_xvffinth_d_w"llvm.loongarch.lasx.xvffintl.d.w"__lasx_xvffintl_d_w"llvm.loongarch.lasx.xvftintrzh.l.s"__lasx_xvftintrzh_l_s"llvm.loongarch.lasx.xvftintrzl.l.s"__lasx_xvftintrzl_l_s"llvm.loongarch.lasx.xvftintrph.l.s"__lasx_xvftintrph_l_s"llvm.loongarch.lasx.xvftintrpl.l.s"__lasx_xvftintrpl_l_s"llvm.loongarch.lasx.xvftintrmh.l.s"__lasx_xvftintrmh_l_s"llvm.loongarch.lasx.xvftintrml.l.s"__lasx_xvftintrml_l_s"llvm.loongarch.lasx.xvftintrneh.l.s"__lasx_xvftintrneh_l_s"llvm.loongarch.lasx.xvftintrnel.l.s"__lasx_xvftintrnel_l_s"llvm.loongarch.lasx.xvfrintrne.s"__lasx_xvfrintrne_s"llvm.loongarch.lasx.xvfrintrne.d"__lasx_xvfrintrne_d"llvm.loongarch.lasx.xvfrintrz.s"__lasx_xvfrintrz_s"llvm.loongarch.lasx.xvfrintrz.d"__lasx_xvfrintrz_d"llvm.loongarch.lasx.xvfrintrp.s"__lasx_xvfrintrp_s"llvm.loongarch.lasx.xvfrintrp.d"__lasx_xvfrintrp_d"llvm.loongarch.lasx.xvfrintrm.s"__lasx_xvfrintrm_s"llvm.loongarch.lasx.xvfrintrm.d"__lasx_xvfrintrm_d"llvm.loongarch.lasx.xvld"__lasx_xvld"llvm.loongarch.lasx.xvst"__lasx_xvst"llvm.loongarch.lasx.xvstelm.b"__lasx_xvstelm_b"llvm.loongarch.lasx.xvstelm.h"__lasx_xvstelm_h"llvm.loongarch.lasx.xvstelm.w"__lasx_xvstelm_w"llvm.loongarch.lasx.xvstelm.d"__lasx_xvstelm_d"llvm.loongarch.lasx.xvinsve0.w"__lasx_xvinsve0_w"llvm.loongarch.lasx.xvinsve0.d"__lasx_xvinsve0_d"llvm.loongarch.lasx.xvpickve.w"__lasx_xvpickve_w"llvm.loongarch.lasx.xvpickve.d"__lasx_xvpickve_d"llvm.loongarch.lasx.xvssrlrn.b.h"__lasx_xvssrlrn_b_h"llvm.loongarch.lasx.xvssrlrn.h.w"__lasx_xvssrlrn_h_w"llvm.loongarch.lasx.xvssrlrn.w.d"__lasx_xvssrlrn_w_d"llvm.loongarch.lasx.xvssrln.b.h"__lasx_xvssrln_b_h"llvm.loongarch.lasx.xvssrln.h.w"__lasx_xvssrln_h_w"llvm.loongarch.lasx.xvssrln.w.d"__lasx_xvssrln_w_d"llvm.loongarch.lasx.xvorn.v"__lasx_xvorn_v"llvm.loongarch.lasx.xvldi"__lasx_xvldi"llvm.loongarch.lasx.xvldx"__lasx_xvldx"llvm.loongarch.lasx.xvstx"__lasx_xvstx"llvm.loongarch.lasx.xvextl.qu.du"__lasx_xvextl_qu_du"llvm.loongarch.lasx.xvinsgr2vr.w"__lasx_xvinsgr2vr_w"llvm.loongarch.lasx.xvinsgr2vr.d"__lasx_xvinsgr2vr_d"llvm.loongarch.lasx.xvreplve0.b"__lasx_xvreplve0_b"llvm.loongarch.lasx.xvreplve0.h"__lasx_xvreplve0_h"llvm.loongarch.lasx.xvreplve0.w"__lasx_xvreplve0_w"llvm.loongarch.lasx.xvreplve0.d"__lasx_xvreplve0_d"llvm.loongarch.lasx.xvreplve0.q"__lasx_xvreplve0_q"llvm.loongarch.lasx.vext2xv.h.b"__lasx_vext2xv_h_b"llvm.loongarch.lasx.vext2xv.w.h"__lasx_vext2xv_w_h"llvm.loongarch.lasx.vext2xv.d.w"__lasx_vext2xv_d_w"llvm.loongarch.lasx.vext2xv.w.b"__lasx_vext2xv_w_b"llvm.loongarch.lasx.vext2xv.d.h"__lasx_vext2xv_d_h"llvm.loongarch.lasx.vext2xv.d.b"__lasx_vext2xv_d_b"llvm.loongarch.lasx.vext2xv.hu.bu"__lasx_vext2xv_hu_bu"llvm.loongarch.lasx.vext2xv.wu.hu"__lasx_vext2xv_wu_hu"llvm.loongarch.lasx.vext2xv.du.wu"__lasx_vext2xv_du_wu"llvm.loongarch.lasx.vext2xv.wu.bu"__lasx_vext2xv_wu_bu"llvm.loongarch.lasx.vext2xv.du.hu"__lasx_vext2xv_du_hu"llvm.loongarch.lasx.vext2xv.du.bu"__lasx_vext2xv_du_bu"llvm.loongarch.lasx.xvpermi.q"__lasx_xvpermi_q"llvm.loongarch.lasx.xvpermi.d"__lasx_xvpermi_d"llvm.loongarch.lasx.xvperm.w"__lasx_xvperm_w"llvm.loongarch.lasx.xvldrepl.b"__lasx_xvldrepl_b"llvm.loongarch.lasx.xvldrepl.h"__lasx_xvldrepl_h"llvm.loongarch.lasx.xvldrepl.w"__lasx_xvldrepl_w"llvm.loongarch.lasx.xvldrepl.d"__lasx_xvldrepl_d"llvm.loongarch.lasx.xvpickve2gr.w"__lasx_xvpickve2gr_w"llvm.loongarch.lasx.xvpickve2gr.wu"__lasx_xvpickve2gr_wu"llvm.loongarch.lasx.xvpickve2gr.d"__lasx_xvpickve2gr_d"llvm.loongarch.lasx.xvpickve2gr.du"__lasx_xvpickve2gr_du"llvm.loongarch.lasx.xvaddwev.q.d"__lasx_xvaddwev_q_d"llvm.loongarch.lasx.xvaddwev.d.w"__lasx_xvaddwev_d_w"llvm.loongarch.lasx.xvaddwev.w.h"__lasx_xvaddwev_w_h"llvm.loongarch.lasx.xvaddwev.h.b"__lasx_xvaddwev_h_b"llvm.loongarch.lasx.xvaddwev.q.du"__lasx_xvaddwev_q_du"llvm.loongarch.lasx.xvaddwev.d.wu"__lasx_xvaddwev_d_wu"llvm.loongarch.lasx.xvaddwev.w.hu"__lasx_xvaddwev_w_hu"llvm.loongarch.lasx.xvaddwev.h.bu"__lasx_xvaddwev_h_bu"llvm.loongarch.lasx.xvsubwev.q.d"__lasx_xvsubwev_q_d"llvm.loongarch.lasx.xvsubwev.d.w"__lasx_xvsubwev_d_w"llvm.loongarch.lasx.xvsubwev.w.h"__lasx_xvsubwev_w_h"llvm.loongarch.lasx.xvsubwev.h.b"__lasx_xvsubwev_h_b"llvm.loongarch.lasx.xvsubwev.q.du"__lasx_xvsubwev_q_du"llvm.loongarch.lasx.xvsubwev.d.wu"__lasx_xvsubwev_d_wu"llvm.loongarch.lasx.xvsubwev.w.hu"__lasx_xvsubwev_w_hu"llvm.loongarch.lasx.xvsubwev.h.bu"__lasx_xvsubwev_h_bu"llvm.loongarch.lasx.xvmulwev.q.d"__lasx_xvmulwev_q_d"llvm.loongarch.lasx.xvmulwev.d.w"__lasx_xvmulwev_d_w"llvm.loongarch.lasx.xvmulwev.w.h"__lasx_xvmulwev_w_h"llvm.loongarch.lasx.xvmulwev.h.b"__lasx_xvmulwev_h_b"llvm.loongarch.lasx.xvmulwev.q.du"__lasx_xvmulwev_q_du"llvm.loongarch.lasx.xvmulwev.d.wu"__lasx_xvmulwev_d_wu"llvm.loongarch.lasx.xvmulwev.w.hu"__lasx_xvmulwev_w_hu"llvm.loongarch.lasx.xvmulwev.h.bu"__lasx_xvmulwev_h_bu"llvm.loongarch.lasx.xvaddwod.q.d"__lasx_xvaddwod_q_d"llvm.loongarch.lasx.xvaddwod.d.w"__lasx_xvaddwod_d_w"llvm.loongarch.lasx.xvaddwod.w.h"__lasx_xvaddwod_w_h"llvm.loongarch.lasx.xvaddwod.h.b"__lasx_xvaddwod_h_b"llvm.loongarch.lasx.xvaddwod.q.du"__lasx_xvaddwod_q_du"llvm.loongarch.lasx.xvaddwod.d.wu"__lasx_xvaddwod_d_wu"llvm.loongarch.lasx.xvaddwod.w.hu"__lasx_xvaddwod_w_hu"llvm.loongarch.lasx.xvaddwod.h.bu"__lasx_xvaddwod_h_bu"llvm.loongarch.lasx.xvsubwod.q.d"__lasx_xvsubwod_q_d"llvm.loongarch.lasx.xvsubwod.d.w"__lasx_xvsubwod_d_w"llvm.loongarch.lasx.xvsubwod.w.h"__lasx_xvsubwod_w_h"llvm.loongarch.lasx.xvsubwod.h.b"__lasx_xvsubwod_h_b"llvm.loongarch.lasx.xvsubwod.q.du"__lasx_xvsubwod_q_du"llvm.loongarch.lasx.xvsubwod.d.wu"__lasx_xvsubwod_d_wu"llvm.loongarch.lasx.xvsubwod.w.hu"__lasx_xvsubwod_w_hu"llvm.loongarch.lasx.xvsubwod.h.bu"__lasx_xvsubwod_h_bu"llvm.loongarch.lasx.xvmulwod.q.d"__lasx_xvmulwod_q_d"llvm.loongarch.lasx.xvmulwod.d.w"__lasx_xvmulwod_d_w"llvm.loongarch.lasx.xvmulwod.w.h"__lasx_xvmulwod_w_h"llvm.loongarch.lasx.xvmulwod.h.b"__lasx_xvmulwod_h_b"llvm.loongarch.lasx.xvmulwod.q.du"__lasx_xvmulwod_q_du"llvm.loongarch.lasx.xvmulwod.d.wu"__lasx_xvmulwod_d_wu"llvm.loongarch.lasx.xvmulwod.w.hu"__lasx_xvmulwod_w_hu"llvm.loongarch.lasx.xvmulwod.h.bu"__lasx_xvmulwod_h_bu"llvm.loongarch.lasx.xvaddwev.d.wu.w"__lasx_xvaddwev_d_wu_w"llvm.loongarch.lasx.xvaddwev.w.hu.h"__lasx_xvaddwev_w_hu_h"llvm.loongarch.lasx.xvaddwev.h.bu.b"__lasx_xvaddwev_h_bu_b"llvm.loongarch.lasx.xvmulwev.d.wu.w"__lasx_xvmulwev_d_wu_w"llvm.loongarch.lasx.xvmulwev.w.hu.h"__lasx_xvmulwev_w_hu_h"llvm.loongarch.lasx.xvmulwev.h.bu.b"__lasx_xvmulwev_h_bu_b"llvm.loongarch.lasx.xvaddwod.d.wu.w"__lasx_xvaddwod_d_wu_w"llvm.loongarch.lasx.xvaddwod.w.hu.h"__lasx_xvaddwod_w_hu_h"llvm.loongarch.lasx.xvaddwod.h.bu.b"__lasx_xvaddwod_h_bu_b"llvm.loongarch.lasx.xvmulwod.d.wu.w"__lasx_xvmulwod_d_wu_w"llvm.loongarch.lasx.xvmulwod.w.hu.h"__lasx_xvmulwod_w_hu_h"llvm.loongarch.lasx.xvmulwod.h.bu.b"__lasx_xvmulwod_h_bu_b"llvm.loongarch.lasx.xvhaddw.q.d"__lasx_xvhaddw_q_d"llvm.loongarch.lasx.xvhaddw.qu.du"__lasx_xvhaddw_qu_du"llvm.loongarch.lasx.xvhsubw.q.d"__lasx_xvhsubw_q_d"llvm.loongarch.lasx.xvhsubw.qu.du"__lasx_xvhsubw_qu_du"llvm.loongarch.lasx.xvmaddwev.q.d"__lasx_xvmaddwev_q_d"llvm.loongarch.lasx.xvmaddwev.d.w"__lasx_xvmaddwev_d_w"llvm.loongarch.lasx.xvmaddwev.w.h"__lasx_xvmaddwev_w_h"llvm.loongarch.lasx.xvmaddwev.h.b"__lasx_xvmaddwev_h_b"llvm.loongarch.lasx.xvmaddwev.q.du"__lasx_xvmaddwev_q_du"llvm.loongarch.lasx.xvmaddwev.d.wu"__lasx_xvmaddwev_d_wu"llvm.loongarch.lasx.xvmaddwev.w.hu"__lasx_xvmaddwev_w_hu"llvm.loongarch.lasx.xvmaddwev.h.bu"__lasx_xvmaddwev_h_bu"llvm.loongarch.lasx.xvmaddwod.q.d"__lasx_xvmaddwod_q_d"llvm.loongarch.lasx.xvmaddwod.d.w"__lasx_xvmaddwod_d_w"llvm.loongarch.lasx.xvmaddwod.w.h"__lasx_xvmaddwod_w_h"llvm.loongarch.lasx.xvmaddwod.h.b"__lasx_xvmaddwod_h_b"llvm.loongarch.lasx.xvmaddwod.q.du"__lasx_xvmaddwod_q_du"llvm.loongarch.lasx.xvmaddwod.d.wu"__lasx_xvmaddwod_d_wu"llvm.loongarch.lasx.xvmaddwod.w.hu"__lasx_xvmaddwod_w_hu"llvm.loongarch.lasx.xvmaddwod.h.bu"__lasx_xvmaddwod_h_bu"llvm.loongarch.lasx.xvmaddwev.q.du.d"__lasx_xvmaddwev_q_du_d"llvm.loongarch.lasx.xvmaddwev.d.wu.w"__lasx_xvmaddwev_d_wu_w"llvm.loongarch.lasx.xvmaddwev.w.hu.h"__lasx_xvmaddwev_w_hu_h"llvm.loongarch.lasx.xvmaddwev.h.bu.b"__lasx_xvmaddwev_h_bu_b"llvm.loongarch.lasx.xvmaddwod.q.du.d"__lasx_xvmaddwod_q_du_d"llvm.loongarch.lasx.xvmaddwod.d.wu.w"__lasx_xvmaddwod_d_wu_w"llvm.loongarch.lasx.xvmaddwod.w.hu.h"__lasx_xvmaddwod_w_hu_h"llvm.loongarch.lasx.xvmaddwod.h.bu.b"__lasx_xvmaddwod_h_bu_b"llvm.loongarch.lasx.xvrotr.b"__lasx_xvrotr_b"llvm.loongarch.lasx.xvrotr.h"__lasx_xvrotr_h"llvm.loongarch.lasx.xvrotr.w"__lasx_xvrotr_w"llvm.loongarch.lasx.xvrotr.d"__lasx_xvrotr_d"llvm.loongarch.lasx.xvadd.q"__lasx_xvadd_q"llvm.loongarch.lasx.xvsub.q"__lasx_xvsub_q"llvm.loongarch.lasx.xvaddwev.q.du.d"__lasx_xvaddwev_q_du_d"llvm.loongarch.lasx.xvaddwod.q.du.d"__lasx_xvaddwod_q_du_d"llvm.loongarch.lasx.xvmulwev.q.du.d"__lasx_xvmulwev_q_du_d"llvm.loongarch.lasx.xvmulwod.q.du.d"__lasx_xvmulwod_q_du_d"llvm.loongarch.lasx.xvmskgez.b"__lasx_xvmskgez_b"llvm.loongarch.lasx.xvmsknz.b"__lasx_xvmsknz_b"llvm.loongarch.lasx.xvexth.h.b"__lasx_xvexth_h_b"llvm.loongarch.lasx.xvexth.w.h"__lasx_xvexth_w_h"llvm.loongarch.lasx.xvexth.d.w"__lasx_xvexth_d_w"llvm.loongarch.lasx.xvexth.q.d"__lasx_xvexth_q_d"llvm.loongarch.lasx.xvexth.hu.bu"__lasx_xvexth_hu_bu"llvm.loongarch.lasx.xvexth.wu.hu"__lasx_xvexth_wu_hu"llvm.loongarch.lasx.xvexth.du.wu"__lasx_xvexth_du_wu"llvm.loongarch.lasx.xvexth.qu.du"__lasx_xvexth_qu_du"llvm.loongarch.lasx.xvrotri.b"__lasx_xvrotri_b"llvm.loongarch.lasx.xvrotri.h"__lasx_xvrotri_h"llvm.loongarch.lasx.xvrotri.w"__lasx_xvrotri_w"llvm.loongarch.lasx.xvrotri.d"__lasx_xvrotri_d"llvm.loongarch.lasx.xvextl.q.d"__lasx_xvextl_q_d"llvm.loongarch.lasx.xvsrlni.b.h"__lasx_xvsrlni_b_h"llvm.loongarch.lasx.xvsrlni.h.w"__lasx_xvsrlni_h_w"llvm.loongarch.lasx.xvsrlni.w.d"__lasx_xvsrlni_w_d"llvm.loongarch.lasx.xvsrlni.d.q"__lasx_xvsrlni_d_q"llvm.loongarch.lasx.xvsrlrni.b.h"__lasx_xvsrlrni_b_h"llvm.loongarch.lasx.xvsrlrni.h.w"__lasx_xvsrlrni_h_w"llvm.loongarch.lasx.xvsrlrni.w.d"__lasx_xvsrlrni_w_d"llvm.loongarch.lasx.xvsrlrni.d.q"__lasx_xvsrlrni_d_q"llvm.loongarch.lasx.xvssrlni.b.h"__lasx_xvssrlni_b_h"llvm.loongarch.lasx.xvssrlni.h.w"__lasx_xvssrlni_h_w"llvm.loongarch.lasx.xvssrlni.w.d"__lasx_xvssrlni_w_d"llvm.loongarch.lasx.xvssrlni.d.q"__lasx_xvssrlni_d_q"llvm.loongarch.lasx.xvssrlni.bu.h"__lasx_xvssrlni_bu_h"llvm.loongarch.lasx.xvssrlni.hu.w"__lasx_xvssrlni_hu_w"llvm.loongarch.lasx.xvssrlni.wu.d"__lasx_xvssrlni_wu_d"llvm.loongarch.lasx.xvssrlni.du.q"__lasx_xvssrlni_du_q"llvm.loongarch.lasx.xvssrlrni.b.h"__lasx_xvssrlrni_b_h"llvm.loongarch.lasx.xvssrlrni.h.w"__lasx_xvssrlrni_h_w"llvm.loongarch.lasx.xvssrlrni.w.d"__lasx_xvssrlrni_w_d"llvm.loongarch.lasx.xvssrlrni.d.q"__lasx_xvssrlrni_d_q"llvm.loongarch.lasx.xvssrlrni.bu.h"__lasx_xvssrlrni_bu_h"llvm.loongarch.lasx.xvssrlrni.hu.w"__lasx_xvssrlrni_hu_w"llvm.loongarch.lasx.xvssrlrni.wu.d"__lasx_xvssrlrni_wu_d"llvm.loongarch.lasx.xvssrlrni.du.q"__lasx_xvssrlrni_du_q"llvm.loongarch.lasx.xvsrani.b.h"__lasx_xvsrani_b_h"llvm.loongarch.lasx.xvsrani.h.w"__lasx_xvsrani_h_w"llvm.loongarch.lasx.xvsrani.w.d"__lasx_xvsrani_w_d"llvm.loongarch.lasx.xvsrani.d.q"__lasx_xvsrani_d_q"llvm.loongarch.lasx.xvsrarni.b.h"__lasx_xvsrarni_b_h"llvm.loongarch.lasx.xvsrarni.h.w"__lasx_xvsrarni_h_w"llvm.loongarch.lasx.xvsrarni.w.d"__lasx_xvsrarni_w_d"llvm.loongarch.lasx.xvsrarni.d.q"__lasx_xvsrarni_d_q"llvm.loongarch.lasx.xvssrani.b.h"__lasx_xvssrani_b_h"llvm.loongarch.lasx.xvssrani.h.w"__lasx_xvssrani_h_w"llvm.loongarch.lasx.xvssrani.w.d"__lasx_xvssrani_w_d"llvm.loongarch.lasx.xvssrani.d.q"__lasx_xvssrani_d_q"llvm.loongarch.lasx.xvssrani.bu.h"__lasx_xvssrani_bu_h"llvm.loongarch.lasx.xvssrani.hu.w"__lasx_xvssrani_hu_w"llvm.loongarch.lasx.xvssrani.wu.d"__lasx_xvssrani_wu_d"llvm.loongarch.lasx.xvssrani.du.q"__lasx_xvssrani_du_q"llvm.loongarch.lasx.xvssrarni.b.h"__lasx_xvssrarni_b_h"llvm.loongarch.lasx.xvssrarni.h.w"__lasx_xvssrarni_h_w"llvm.loongarch.lasx.xvssrarni.w.d"__lasx_xvssrarni_w_d"llvm.loongarch.lasx.xvssrarni.d.q"__lasx_xvssrarni_d_q"llvm.loongarch.lasx.xvssrarni.bu.h"__lasx_xvssrarni_bu_h"llvm.loongarch.lasx.xvssrarni.hu.w"__lasx_xvssrarni_hu_w"llvm.loongarch.lasx.xvssrarni.wu.d"__lasx_xvssrarni_wu_d"llvm.loongarch.lasx.xvssrarni.du.q"__lasx_xvssrarni_du_q"llvm.loongarch.lasx.xbnz.b"__lasx_xbnz_b"llvm.loongarch.lasx.xbnz.d"__lasx_xbnz_d"llvm.loongarch.lasx.xbnz.h"__lasx_xbnz_h"llvm.loongarch.lasx.xbnz.v"__lasx_xbnz_v"llvm.loongarch.lasx.xbnz.w"__lasx_xbnz_w"llvm.loongarch.lasx.xbz.b"__lasx_xbz_b"llvm.loongarch.lasx.xbz.d"__lasx_xbz_d"llvm.loongarch.lasx.xbz.h"__lasx_xbz_h"llvm.loongarch.lasx.xbz.v"__lasx_xbz_v"llvm.loongarch.lasx.xbz.w"__lasx_xbz_w"llvm.loongarch.lasx.xvfcmp.caf.d"__lasx_xvfcmp_caf_d"llvm.loongarch.lasx.xvfcmp.caf.s"__lasx_xvfcmp_caf_s"llvm.loongarch.lasx.xvfcmp.ceq.d"__lasx_xvfcmp_ceq_d"llvm.loongarch.lasx.xvfcmp.ceq.s"__lasx_xvfcmp_ceq_s"llvm.loongarch.lasx.xvfcmp.cle.d"__lasx_xvfcmp_cle_d"llvm.loongarch.lasx.xvfcmp.cle.s"__lasx_xvfcmp_cle_s"llvm.loongarch.lasx.xvfcmp.clt.d"__lasx_xvfcmp_clt_d"llvm.loongarch.lasx.xvfcmp.clt.s"__lasx_xvfcmp_clt_s"llvm.loongarch.lasx.xvfcmp.cne.d"__lasx_xvfcmp_cne_d"llvm.loongarch.lasx.xvfcmp.cne.s"__lasx_xvfcmp_cne_s"llvm.loongarch.lasx.xvfcmp.cor.d"__lasx_xvfcmp_cor_d"llvm.loongarch.lasx.xvfcmp.cor.s"__lasx_xvfcmp_cor_s"llvm.loongarch.lasx.xvfcmp.cueq.d"__lasx_xvfcmp_cueq_d"llvm.loongarch.lasx.xvfcmp.cueq.s"__lasx_xvfcmp_cueq_s"llvm.loongarch.lasx.xvfcmp.cule.d"__lasx_xvfcmp_cule_d"llvm.loongarch.lasx.xvfcmp.cule.s"__lasx_xvfcmp_cule_s"llvm.loongarch.lasx.xvfcmp.cult.d"__lasx_xvfcmp_cult_d"llvm.loongarch.lasx.xvfcmp.cult.s"__lasx_xvfcmp_cult_s"llvm.loongarch.lasx.xvfcmp.cun.d"__lasx_xvfcmp_cun_d"llvm.loongarch.lasx.xvfcmp.cune.d"__lasx_xvfcmp_cune_d"llvm.loongarch.lasx.xvfcmp.cune.s"__lasx_xvfcmp_cune_s"llvm.loongarch.lasx.xvfcmp.cun.s"__lasx_xvfcmp_cun_s"llvm.loongarch.lasx.xvfcmp.saf.d"__lasx_xvfcmp_saf_d"llvm.loongarch.lasx.xvfcmp.saf.s"__lasx_xvfcmp_saf_s"llvm.loongarch.lasx.xvfcmp.seq.d"__lasx_xvfcmp_seq_d"llvm.loongarch.lasx.xvfcmp.seq.s"__lasx_xvfcmp_seq_s"llvm.loongarch.lasx.xvfcmp.sle.d"__lasx_xvfcmp_sle_d"llvm.loongarch.lasx.xvfcmp.sle.s"__lasx_xvfcmp_sle_s"llvm.loongarch.lasx.xvfcmp.slt.d"__lasx_xvfcmp_slt_d"llvm.loongarch.lasx.xvfcmp.slt.s"__lasx_xvfcmp_slt_s"llvm.loongarch.lasx.xvfcmp.sne.d"__lasx_xvfcmp_sne_d"llvm.loongarch.lasx.xvfcmp.sne.s"__lasx_xvfcmp_sne_s"llvm.loongarch.lasx.xvfcmp.sor.d"__lasx_xvfcmp_sor_d"llvm.loongarch.lasx.xvfcmp.sor.s"__lasx_xvfcmp_sor_s"llvm.loongarch.lasx.xvfcmp.sueq.d"__lasx_xvfcmp_sueq_d"llvm.loongarch.lasx.xvfcmp.sueq.s"__lasx_xvfcmp_sueq_s"llvm.loongarch.lasx.xvfcmp.sule.d"__lasx_xvfcmp_sule_d"llvm.loongarch.lasx.xvfcmp.sule.s"__lasx_xvfcmp_sule_s"llvm.loongarch.lasx.xvfcmp.sult.d"__lasx_xvfcmp_sult_d"llvm.loongarch.lasx.xvfcmp.sult.s"__lasx_xvfcmp_sult_s"llvm.loongarch.lasx.xvfcmp.sun.d"__lasx_xvfcmp_sun_d"llvm.loongarch.lasx.xvfcmp.sune.d"__lasx_xvfcmp_sune_d"llvm.loongarch.lasx.xvfcmp.sune.s"__lasx_xvfcmp_sune_s"llvm.loongarch.lasx.xvfcmp.sun.s"__lasx_xvfcmp_sun_s"llvm.loongarch.lasx.xvpickve.d.f"__lasx_xvpickve_d_f"llvm.loongarch.lasx.xvpickve.w.f"__lasx_xvpickve_w_f"llvm.loongarch.lasx.xvrepli.b"__lasx_xvrepli_b"llvm.loongarch.lasx.xvrepli.d"__lasx_xvrepli_d"llvm.loongarch.lasx.xvrepli.h"__lasx_xvrepli_h"llvm.loongarch.lasx.xvrepli.w"__lasx_xvrepli_wlasx_xvsll_bm256ilasx_xvsll_hlasx_xvsll_wlasx_xvsll_dIMM3lasx_xvslli_bIMM4lasx_xvslli_hlasx_xvslli_wlasx_xvslli_dlasx_xvsra_blasx_xvsra_hlasx_xvsra_wlasx_xvsra_dlasx_xvsrai_blasx_xvsrai_hlasx_xvsrai_wlasx_xvsrai_dlasx_xvsrar_blasx_xvsrar_hlasx_xvsrar_wlasx_xvsrar_dlasx_xvsrari_blasx_xvsrari_hlasx_xvsrari_wlasx_xvsrari_dlasx_xvsrl_blasx_xvsrl_hlasx_xvsrl_wlasx_xvsrl_dlasx_xvsrli_blasx_xvsrli_hlasx_xvsrli_wlasx_xvsrli_dlasx_xvsrlr_blasx_xvsrlr_hlasx_xvsrlr_wlasx_xvsrlr_dlasx_xvsrlri_blasx_xvsrlri_hlasx_xvsrlri_wlasx_xvsrlri_dlasx_xvbitclr_blasx_xvbitclr_hlasx_xvbitclr_wlasx_xvbitclr_dlasx_xvbitclri_blasx_xvbitclri_hlasx_xvbitclri_wlasx_xvbitclri_dlasx_xvbitset_blasx_xvbitset_hlasx_xvbitset_wlasx_xvbitset_dlasx_xvbitseti_blasx_xvbitseti_hlasx_xvbitseti_wlasx_xvbitseti_dlasx_xvbitrev_blasx_xvbitrev_hlasx_xvbitrev_wlasx_xvbitrev_dlasx_xvbitrevi_blasx_xvbitrevi_hlasx_xvbitrevi_wlasx_xvbitrevi_dlasx_xvadd_blasx_xvadd_hlasx_xvadd_wlasx_xvadd_dlasx_xvaddi_bulasx_xvaddi_hulasx_xvaddi_wulasx_xvaddi_dulasx_xvsub_blasx_xvsub_hlasx_xvsub_wlasx_xvsub_dlasx_xvsubi_bulasx_xvsubi_hulasx_xvsubi_wulasx_xvsubi_dulasx_xvmax_blasx_xvmax_hlasx_xvmax_wlasx_xvmax_dIMM_S5lasx_xvmaxi_blasx_xvmaxi_hlasx_xvmaxi_wlasx_xvmaxi_dlasx_xvmax_bulasx_xvmax_hulasx_xvmax_wulasx_xvmax_dulasx_xvmaxi_bulasx_xvmaxi_hulasx_xvmaxi_wulasx_xvmaxi_dulasx_xvmin_blasx_xvmin_hlasx_xvmin_wlasx_xvmin_dlasx_xvmini_blasx_xvmini_hlasx_xvmini_wlasx_xvmini_dlasx_xvmin_bulasx_xvmin_hulasx_xvmin_wulasx_xvmin_dulasx_xvmini_bulasx_xvmini_hulasx_xvmini_wulasx_xvmini_dulasx_xvseq_blasx_xvseq_hlasx_xvseq_wlasx_xvseq_dlasx_xvseqi_blasx_xvseqi_hlasx_xvseqi_wlasx_xvseqi_dlasx_xvslt_blasx_xvslt_hlasx_xvslt_wlasx_xvslt_dlasx_xvslti_blasx_xvslti_hlasx_xvslti_wlasx_xvslti_dlasx_xvslt_bulasx_xvslt_hulasx_xvslt_wulasx_xvslt_dulasx_xvslti_bulasx_xvslti_hulasx_xvslti_wulasx_xvslti_dulasx_xvsle_blasx_xvsle_hlasx_xvsle_wlasx_xvsle_dlasx_xvslei_blasx_xvslei_hlasx_xvslei_wlasx_xvslei_dlasx_xvsle_bulasx_xvsle_hulasx_xvsle_wulasx_xvsle_dulasx_xvslei_bulasx_xvslei_hulasx_xvslei_wulasx_xvslei_dulasx_xvsat_blasx_xvsat_hlasx_xvsat_wlasx_xvsat_dlasx_xvsat_bulasx_xvsat_hulasx_xvsat_wulasx_xvsat_dulasx_xvadda_blasx_xvadda_hlasx_xvadda_wlasx_xvadda_dlasx_xvsadd_blasx_xvsadd_hlasx_xvsadd_wlasx_xvsadd_dlasx_xvsadd_bulasx_xvsadd_hulasx_xvsadd_wulasx_xvsadd_dulasx_xvavg_blasx_xvavg_hlasx_xvavg_wlasx_xvavg_dlasx_xvavg_bulasx_xvavg_hulasx_xvavg_wulasx_xvavg_dulasx_xvavgr_blasx_xvavgr_hlasx_xvavgr_wlasx_xvavgr_dlasx_xvavgr_bulasx_xvavgr_hulasx_xvavgr_wulasx_xvavgr_dulasx_xvssub_blasx_xvssub_hlasx_xvssub_wlasx_xvssub_dlasx_xvssub_bulasx_xvssub_hulasx_xvssub_wulasx_xvssub_dulasx_xvabsd_blasx_xvabsd_hlasx_xvabsd_wlasx_xvabsd_dlasx_xvabsd_bulasx_xvabsd_hulasx_xvabsd_wulasx_xvabsd_dulasx_xvmul_blasx_xvmul_hlasx_xvmul_wlasx_xvmul_dlasx_xvmadd_blasx_xvmadd_hlasx_xvmadd_wlasx_xvmadd_dlasx_xvmsub_blasx_xvmsub_hlasx_xvmsub_wlasx_xvmsub_dlasx_xvdiv_blasx_xvdiv_hlasx_xvdiv_wlasx_xvdiv_dlasx_xvdiv_bulasx_xvdiv_hulasx_xvdiv_wulasx_xvdiv_dulasx_xvhaddw_h_blasx_xvhaddw_w_hlasx_xvhaddw_d_wlasx_xvhaddw_hu_bulasx_xvhaddw_wu_hulasx_xvhaddw_du_wulasx_xvhsubw_h_blasx_xvhsubw_w_hlasx_xvhsubw_d_wlasx_xvhsubw_hu_bulasx_xvhsubw_wu_hulasx_xvhsubw_du_wulasx_xvmod_blasx_xvmod_hlasx_xvmod_wlasx_xvmod_dlasx_xvmod_bulasx_xvmod_hulasx_xvmod_wulasx_xvmod_dulasx_xvrepl128vei_blasx_xvrepl128vei_hlasx_xvrepl128vei_wIMM1lasx_xvrepl128vei_dlasx_xvpickev_blasx_xvpickev_hlasx_xvpickev_wlasx_xvpickev_dlasx_xvpickod_blasx_xvpickod_hlasx_xvpickod_wlasx_xvpickod_dlasx_xvilvh_blasx_xvilvh_hlasx_xvilvh_wlasx_xvilvh_dlasx_xvilvl_blasx_xvilvl_hlasx_xvilvl_wlasx_xvilvl_dlasx_xvpackev_blasx_xvpackev_hlasx_xvpackev_wlasx_xvpackev_dlasx_xvpackod_blasx_xvpackod_hlasx_xvpackod_wlasx_xvpackod_dlasx_xvshuf_blasx_xvshuf_hlasx_xvshuf_wlasx_xvshuf_dlasx_xvand_vIMM8lasx_xvandi_blasx_xvor_vlasx_xvori_blasx_xvnor_vlasx_xvnori_blasx_xvxor_vlasx_xvxori_blasx_xvbitsel_vlasx_xvbitseli_blasx_xvshuf4i_blasx_xvshuf4i_hlasx_xvshuf4i_wlasx_xvreplgr2vr_blasx_xvreplgr2vr_hlasx_xvreplgr2vr_wlasx_xvreplgr2vr_dlasx_xvpcnt_blasx_xvpcnt_hlasx_xvpcnt_wlasx_xvpcnt_dlasx_xvclo_blasx_xvclo_hlasx_xvclo_wlasx_xvclo_dlasx_xvclz_blasx_xvclz_hlasx_xvclz_wlasx_xvclz_dlasx_xvfadd_sm256lasx_xvfadd_dm256dlasx_xvfsub_slasx_xvfsub_dlasx_xvfmul_slasx_xvfmul_dlasx_xvfdiv_slasx_xvfdiv_dlasx_xvfcvt_h_slasx_xvfcvt_s_dlasx_xvfmin_slasx_xvfmin_dlasx_xvfmina_slasx_xvfmina_dlasx_xvfmax_slasx_xvfmax_dlasx_xvfmaxa_slasx_xvfmaxa_dlasx_xvfclass_slasx_xvfclass_dlasx_xvfsqrt_slasx_xvfsqrt_dlasx_xvfrecip_slasx_xvfrecip_dlasx_xvfrecipe_slasx_xvfrecipe_dlasx_xvfrsqrte_slasx_xvfrsqrte_dlasx_xvfrint_slasx_xvfrint_dlasx_xvfrsqrt_slasx_xvfrsqrt_dlasx_xvflogb_slasx_xvflogb_dlasx_xvfcvth_s_hlasx_xvfcvth_d_slasx_xvfcvtl_s_hlasx_xvfcvtl_d_slasx_xvftint_w_slasx_xvftint_l_dlasx_xvftint_wu_slasx_xvftint_lu_dlasx_xvftintrz_w_slasx_xvftintrz_l_dlasx_xvftintrz_wu_slasx_xvftintrz_lu_dlasx_xvffint_s_wlasx_xvffint_d_llasx_xvffint_s_wulasx_xvffint_d_lulasx_xvreplve_blasx_xvreplve_hlasx_xvreplve_wlasx_xvreplve_dlasx_xvpermi_wlasx_xvandn_vlasx_xvneg_blasx_xvneg_hlasx_xvneg_wlasx_xvneg_dlasx_xvmuh_blasx_xvmuh_hlasx_xvmuh_wlasx_xvmuh_dlasx_xvmuh_bulasx_xvmuh_hulasx_xvmuh_wulasx_xvmuh_dulasx_xvsllwil_h_blasx_xvsllwil_w_hlasx_xvsllwil_d_wlasx_xvsllwil_hu_bulasx_xvsllwil_wu_hulasx_xvsllwil_du_wulasx_xvsran_b_hlasx_xvsran_h_wlasx_xvsran_w_dlasx_xvssran_b_hlasx_xvssran_h_wlasx_xvssran_w_dlasx_xvssran_bu_hlasx_xvssran_hu_wlasx_xvssran_wu_dlasx_xvsrarn_b_hlasx_xvsrarn_h_wlasx_xvsrarn_w_dlasx_xvssrarn_b_hlasx_xvssrarn_h_wlasx_xvssrarn_w_dlasx_xvssrarn_bu_hlasx_xvssrarn_hu_wlasx_xvssrarn_wu_dlasx_xvsrln_b_hlasx_xvsrln_h_wlasx_xvsrln_w_dlasx_xvssrln_bu_hlasx_xvssrln_hu_wlasx_xvssrln_wu_dlasx_xvsrlrn_b_hlasx_xvsrlrn_h_wlasx_xvsrlrn_w_dlasx_xvssrlrn_bu_hlasx_xvssrlrn_hu_wlasx_xvssrlrn_wu_dlasx_xvfrstpi_blasx_xvfrstpi_hlasx_xvfrstp_blasx_xvfrstp_hlasx_xvshuf4i_dlasx_xvbsrl_vlasx_xvbsll_vlasx_xvextrins_blasx_xvextrins_hlasx_xvextrins_wlasx_xvextrins_dlasx_xvmskltz_blasx_xvmskltz_hlasx_xvmskltz_wlasx_xvmskltz_dlasx_xvsigncov_blasx_xvsigncov_hlasx_xvsigncov_wlasx_xvsigncov_dlasx_xvfmadd_slasx_xvfmadd_dlasx_xvfmsub_slasx_xvfmsub_dlasx_xvfnmadd_slasx_xvfnmadd_dlasx_xvfnmsub_slasx_xvfnmsub_dlasx_xvftintrne_w_slasx_xvftintrne_l_dlasx_xvftintrp_w_slasx_xvftintrp_l_dlasx_xvftintrm_w_slasx_xvftintrm_l_dlasx_xvftint_w_dlasx_xvffint_s_llasx_xvftintrz_w_dlasx_xvftintrp_w_dlasx_xvftintrm_w_dlasx_xvftintrne_w_dlasx_xvftinth_l_slasx_xvftintl_l_slasx_xvffinth_d_wlasx_xvffintl_d_wlasx_xvftintrzh_l_slasx_xvftintrzl_l_slasx_xvftintrph_l_slasx_xvftintrpl_l_slasx_xvftintrmh_l_slasx_xvftintrml_l_slasx_xvftintrneh_l_slasx_xvftintrnel_l_slasx_xvfrintrne_slasx_xvfrintrne_dlasx_xvfrintrz_slasx_xvfrintrz_dlasx_xvfrintrp_slasx_xvfrintrp_dlasx_xvfrintrm_slasx_xvfrintrm_dlasx_xvldlasx_xvstIMM_S8lasx_xvstelm_blasx_xvstelm_hlasx_xvstelm_wlasx_xvstelm_dlasx_xvinsve0_wlasx_xvinsve0_dlasx_xvpickve_wlasx_xvpickve_dlasx_xvssrlrn_b_hlasx_xvssrlrn_h_wlasx_xvssrlrn_w_dlasx_xvssrln_b_hlasx_xvssrln_h_wlasx_xvssrln_w_dlasx_xvorn_vIMM_S13lasx_xvldilasx_xvldxlasx_xvstxlasx_xvextl_qu_dulasx_xvinsgr2vr_wlasx_xvinsgr2vr_dlasx_xvreplve0_blasx_xvreplve0_hlasx_xvreplve0_wlasx_xvreplve0_dlasx_xvreplve0_qlasx_vext2xv_h_blasx_vext2xv_w_hlasx_vext2xv_d_wlasx_vext2xv_w_blasx_vext2xv_d_hlasx_vext2xv_d_blasx_vext2xv_hu_bulasx_vext2xv_wu_hulasx_vext2xv_du_wulasx_vext2xv_wu_bulasx_vext2xv_du_hulasx_vext2xv_du_bulasx_xvpermi_qlasx_xvpermi_dlasx_xvperm_wlasx_xvldrepl_bIMM_S11lasx_xvldrepl_hIMM_S10lasx_xvldrepl_wIMM_S9lasx_xvldrepl_dlasx_xvpickve2gr_wlasx_xvpickve2gr_wulasx_xvpickve2gr_dlasx_xvpickve2gr_dulasx_xvaddwev_q_dlasx_xvaddwev_d_wlasx_xvaddwev_w_hlasx_xvaddwev_h_blasx_xvaddwev_q_dulasx_xvaddwev_d_wulasx_xvaddwev_w_hulasx_xvaddwev_h_bulasx_xvsubwev_q_dlasx_xvsubwev_d_wlasx_xvsubwev_w_hlasx_xvsubwev_h_blasx_xvsubwev_q_dulasx_xvsubwev_d_wulasx_xvsubwev_w_hulasx_xvsubwev_h_bulasx_xvmulwev_q_dlasx_xvmulwev_d_wlasx_xvmulwev_w_hlasx_xvmulwev_h_blasx_xvmulwev_q_dulasx_xvmulwev_d_wulasx_xvmulwev_w_hulasx_xvmulwev_h_bulasx_xvaddwod_q_dlasx_xvaddwod_d_wlasx_xvaddwod_w_hlasx_xvaddwod_h_blasx_xvaddwod_q_dulasx_xvaddwod_d_wulasx_xvaddwod_w_hulasx_xvaddwod_h_bulasx_xvsubwod_q_dlasx_xvsubwod_d_wlasx_xvsubwod_w_hlasx_xvsubwod_h_blasx_xvsubwod_q_dulasx_xvsubwod_d_wulasx_xvsubwod_w_hulasx_xvsubwod_h_bulasx_xvmulwod_q_dlasx_xvmulwod_d_wlasx_xvmulwod_w_hlasx_xvmulwod_h_blasx_xvmulwod_q_dulasx_xvmulwod_d_wulasx_xvmulwod_w_hulasx_xvmulwod_h_bulasx_xvaddwev_d_wu_wlasx_xvaddwev_w_hu_hlasx_xvaddwev_h_bu_blasx_xvmulwev_d_wu_wlasx_xvmulwev_w_hu_hlasx_xvmulwev_h_bu_blasx_xvaddwod_d_wu_wlasx_xvaddwod_w_hu_hlasx_xvaddwod_h_bu_blasx_xvmulwod_d_wu_wlasx_xvmulwod_w_hu_hlasx_xvmulwod_h_bu_blasx_xvhaddw_q_dlasx_xvhaddw_qu_dulasx_xvhsubw_q_dlasx_xvhsubw_qu_dulasx_xvmaddwev_q_dlasx_xvmaddwev_d_wlasx_xvmaddwev_w_hlasx_xvmaddwev_h_blasx_xvmaddwev_q_dulasx_xvmaddwev_d_wulasx_xvmaddwev_w_hulasx_xvmaddwev_h_bulasx_xvmaddwod_q_dlasx_xvmaddwod_d_wlasx_xvmaddwod_w_hlasx_xvmaddwod_h_blasx_xvmaddwod_q_dulasx_xvmaddwod_d_wulasx_xvmaddwod_w_hulasx_xvmaddwod_h_bulasx_xvmaddwev_q_du_dlasx_xvmaddwev_d_wu_wlasx_xvmaddwev_w_hu_hlasx_xvmaddwev_h_bu_blasx_xvmaddwod_q_du_dlasx_xvmaddwod_d_wu_wlasx_xvmaddwod_w_hu_hlasx_xvmaddwod_h_bu_blasx_xvrotr_blasx_xvrotr_hlasx_xvrotr_wlasx_xvrotr_dlasx_xvadd_qlasx_xvsub_qlasx_xvaddwev_q_du_dlasx_xvaddwod_q_du_dlasx_xvmulwev_q_du_dlasx_xvmulwod_q_du_dlasx_xvmskgez_blasx_xvmsknz_blasx_xvexth_h_blasx_xvexth_w_hlasx_xvexth_d_wlasx_xvexth_q_dlasx_xvexth_hu_bulasx_xvexth_wu_hulasx_xvexth_du_wulasx_xvexth_qu_dulasx_xvrotri_blasx_xvrotri_hlasx_xvrotri_wlasx_xvrotri_dlasx_xvextl_q_dlasx_xvsrlni_b_hlasx_xvsrlni_h_wlasx_xvsrlni_w_dIMM7lasx_xvsrlni_d_qlasx_xvsrlrni_b_hlasx_xvsrlrni_h_wlasx_xvsrlrni_w_dlasx_xvsrlrni_d_qlasx_xvssrlni_b_hlasx_xvssrlni_h_wlasx_xvssrlni_w_dlasx_xvssrlni_d_qlasx_xvssrlni_bu_hlasx_xvssrlni_hu_wlasx_xvssrlni_wu_dlasx_xvssrlni_du_qlasx_xvssrlrni_b_hlasx_xvssrlrni_h_wlasx_xvssrlrni_w_dlasx_xvssrlrni_d_qlasx_xvssrlrni_bu_hlasx_xvssrlrni_hu_wlasx_xvssrlrni_wu_dlasx_xvssrlrni_du_qlasx_xvsrani_b_hlasx_xvsrani_h_wlasx_xvsrani_w_dlasx_xvsrani_d_qlasx_xvsrarni_b_hlasx_xvsrarni_h_wlasx_xvsrarni_w_dlasx_xvsrarni_d_qlasx_xvssrani_b_hlasx_xvssrani_h_wlasx_xvssrani_w_dlasx_xvssrani_d_qlasx_xvssrani_bu_hlasx_xvssrani_hu_wlasx_xvssrani_wu_dlasx_xvssrani_du_qlasx_xvssrarni_b_hlasx_xvssrarni_h_wlasx_xvssrarni_w_dlasx_xvssrarni_d_qlasx_xvssrarni_bu_hlasx_xvssrarni_hu_wlasx_xvssrarni_wu_dlasx_xvssrarni_du_qlasx_xbnz_blasx_xbnz_dlasx_xbnz_hlasx_xbnz_vlasx_xbnz_wlasx_xbz_blasx_xbz_dlasx_xbz_hlasx_xbz_vlasx_xbz_wlasx_xvfcmp_caf_dlasx_xvfcmp_caf_slasx_xvfcmp_ceq_dlasx_xvfcmp_ceq_slasx_xvfcmp_cle_dlasx_xvfcmp_cle_slasx_xvfcmp_clt_dlasx_xvfcmp_clt_slasx_xvfcmp_cne_dlasx_xvfcmp_cne_slasx_xvfcmp_cor_dlasx_xvfcmp_cor_slasx_xvfcmp_cueq_dlasx_xvfcmp_cueq_slasx_xvfcmp_cule_dlasx_xvfcmp_cule_slasx_xvfcmp_cult_dlasx_xvfcmp_cult_slasx_xvfcmp_cun_dlasx_xvfcmp_cune_dlasx_xvfcmp_cune_slasx_xvfcmp_cun_slasx_xvfcmp_saf_dlasx_xvfcmp_saf_slasx_xvfcmp_seq_dlasx_xvfcmp_seq_slasx_xvfcmp_sle_dlasx_xvfcmp_sle_slasx_xvfcmp_slt_dlasx_xvfcmp_slt_slasx_xvfcmp_sne_dlasx_xvfcmp_sne_slasx_xvfcmp_sor_dlasx_xvfcmp_sor_slasx_xvfcmp_sueq_dlasx_xvfcmp_sueq_slasx_xvfcmp_sule_dlasx_xvfcmp_sule_slasx_xvfcmp_sult_dlasx_xvfcmp_sult_slasx_xvfcmp_sun_dlasx_xvfcmp_sune_dlasx_xvfcmp_sune_slasx_xvfcmp_sun_slasx_xvpickve_d_flasx_xvpickve_w_flasx_xvrepli_blasx_xvrepli_dlasx_xvrepli_hlasx_xvrepli_w// Instead, modify `crates/stdarch-gen-loongarch/lasx.spec` and run the following command to re-generate this file:// OUT_DIR=`pwd`/crates/core_arch cargo run -p stdarch-gen-loongarch -- crates/stdarch-gen-loongarch/lasx.spec//! LoongArch64 LASX intrinsicstest_lasx_xvsll_btest_lasx_xvsll_htest_lasx_xvsll_wtest_lasx_xvsll_dtest_lasx_xvslli_btest_lasx_xvslli_htest_lasx_xvslli_wtest_lasx_xvslli_dtest_lasx_xvsra_btest_lasx_xvsra_htest_lasx_xvsra_wtest_lasx_xvsra_dtest_lasx_xvsrai_btest_lasx_xvsrai_htest_lasx_xvsrai_wtest_lasx_xvsrai_dtest_lasx_xvsrar_btest_lasx_xvsrar_htest_lasx_xvsrar_wtest_lasx_xvsrar_dtest_lasx_xvsrari_btest_lasx_xvsrari_htest_lasx_xvsrari_wtest_lasx_xvsrari_dtest_lasx_xvsrl_btest_lasx_xvsrl_htest_lasx_xvsrl_wtest_lasx_xvsrl_dtest_lasx_xvsrli_btest_lasx_xvsrli_htest_lasx_xvsrli_wtest_lasx_xvsrli_dtest_lasx_xvsrlr_btest_lasx_xvsrlr_htest_lasx_xvsrlr_wtest_lasx_xvsrlr_dtest_lasx_xvsrlri_btest_lasx_xvsrlri_htest_lasx_xvsrlri_wtest_lasx_xvsrlri_dtest_lasx_xvbitclr_btest_lasx_xvbitclr_htest_lasx_xvbitclr_wtest_lasx_xvbitclr_dtest_lasx_xvbitclri_btest_lasx_xvbitclri_htest_lasx_xvbitclri_wtest_lasx_xvbitclri_dtest_lasx_xvbitset_btest_lasx_xvbitset_htest_lasx_xvbitset_wtest_lasx_xvbitset_dtest_lasx_xvbitseti_btest_lasx_xvbitseti_htest_lasx_xvbitseti_wtest_lasx_xvbitseti_dtest_lasx_xvbitrev_btest_lasx_xvbitrev_htest_lasx_xvbitrev_wtest_lasx_xvbitrev_dtest_lasx_xvbitrevi_btest_lasx_xvbitrevi_htest_lasx_xvbitrevi_wtest_lasx_xvbitrevi_dtest_lasx_xvadd_btest_lasx_xvadd_htest_lasx_xvadd_wtest_lasx_xvadd_dtest_lasx_xvaddi_butest_lasx_xvaddi_hutest_lasx_xvaddi_wutest_lasx_xvaddi_dutest_lasx_xvsub_btest_lasx_xvsub_htest_lasx_xvsub_wtest_lasx_xvsub_dtest_lasx_xvsubi_butest_lasx_xvsubi_hutest_lasx_xvsubi_wutest_lasx_xvsubi_dutest_lasx_xvmax_btest_lasx_xvmax_htest_lasx_xvmax_wtest_lasx_xvmax_dtest_lasx_xvmaxi_btest_lasx_xvmaxi_htest_lasx_xvmaxi_wtest_lasx_xvmaxi_dtest_lasx_xvmax_butest_lasx_xvmax_hutest_lasx_xvmax_wutest_lasx_xvmax_dutest_lasx_xvmaxi_butest_lasx_xvmaxi_hutest_lasx_xvmaxi_wutest_lasx_xvmaxi_dutest_lasx_xvmin_btest_lasx_xvmin_htest_lasx_xvmin_wtest_lasx_xvmin_dtest_lasx_xvmini_btest_lasx_xvmini_htest_lasx_xvmini_wtest_lasx_xvmini_dtest_lasx_xvmin_butest_lasx_xvmin_hutest_lasx_xvmin_wutest_lasx_xvmin_dutest_lasx_xvmini_butest_lasx_xvmini_hutest_lasx_xvmini_wutest_lasx_xvmini_dutest_lasx_xvseq_btest_lasx_xvseq_htest_lasx_xvseq_wtest_lasx_xvseq_dtest_lasx_xvseqi_btest_lasx_xvseqi_htest_lasx_xvseqi_wtest_lasx_xvseqi_dtest_lasx_xvslt_btest_lasx_xvslt_htest_lasx_xvslt_wtest_lasx_xvslt_dtest_lasx_xvslti_btest_lasx_xvslti_htest_lasx_xvslti_wtest_lasx_xvslti_dtest_lasx_xvslt_butest_lasx_xvslt_hutest_lasx_xvslt_wutest_lasx_xvslt_dutest_lasx_xvslti_butest_lasx_xvslti_hutest_lasx_xvslti_wutest_lasx_xvslti_dutest_lasx_xvsle_btest_lasx_xvsle_htest_lasx_xvsle_wtest_lasx_xvsle_dtest_lasx_xvslei_btest_lasx_xvslei_htest_lasx_xvslei_wtest_lasx_xvslei_dtest_lasx_xvsle_butest_lasx_xvsle_hutest_lasx_xvsle_wutest_lasx_xvsle_dutest_lasx_xvslei_butest_lasx_xvslei_hutest_lasx_xvslei_wutest_lasx_xvslei_dutest_lasx_xvsat_btest_lasx_xvsat_htest_lasx_xvsat_wtest_lasx_xvsat_dtest_lasx_xvsat_butest_lasx_xvsat_hutest_lasx_xvsat_wutest_lasx_xvsat_dutest_lasx_xvadda_btest_lasx_xvadda_htest_lasx_xvadda_wtest_lasx_xvadda_dtest_lasx_xvsadd_btest_lasx_xvsadd_htest_lasx_xvsadd_wtest_lasx_xvsadd_dtest_lasx_xvsadd_butest_lasx_xvsadd_hutest_lasx_xvsadd_wutest_lasx_xvsadd_dutest_lasx_xvavg_btest_lasx_xvavg_htest_lasx_xvavg_wtest_lasx_xvavg_dtest_lasx_xvavg_butest_lasx_xvavg_hutest_lasx_xvavg_wutest_lasx_xvavg_dutest_lasx_xvavgr_btest_lasx_xvavgr_htest_lasx_xvavgr_wtest_lasx_xvavgr_dtest_lasx_xvavgr_butest_lasx_xvavgr_hutest_lasx_xvavgr_wutest_lasx_xvavgr_dutest_lasx_xvssub_btest_lasx_xvssub_htest_lasx_xvssub_wtest_lasx_xvssub_dtest_lasx_xvssub_butest_lasx_xvssub_hutest_lasx_xvssub_wutest_lasx_xvssub_dutest_lasx_xvabsd_btest_lasx_xvabsd_htest_lasx_xvabsd_wtest_lasx_xvabsd_dtest_lasx_xvabsd_butest_lasx_xvabsd_hutest_lasx_xvabsd_wutest_lasx_xvabsd_dutest_lasx_xvmul_btest_lasx_xvmul_htest_lasx_xvmul_wtest_lasx_xvmul_dtest_lasx_xvmadd_btest_lasx_xvmadd_htest_lasx_xvmadd_wtest_lasx_xvmadd_dtest_lasx_xvmsub_btest_lasx_xvmsub_htest_lasx_xvmsub_wtest_lasx_xvmsub_dtest_lasx_xvdiv_btest_lasx_xvdiv_htest_lasx_xvdiv_wtest_lasx_xvdiv_dtest_lasx_xvdiv_butest_lasx_xvdiv_hutest_lasx_xvdiv_wutest_lasx_xvdiv_dutest_lasx_xvhaddw_h_btest_lasx_xvhaddw_w_htest_lasx_xvhaddw_d_wtest_lasx_xvhaddw_hu_butest_lasx_xvhaddw_wu_hutest_lasx_xvhaddw_du_wutest_lasx_xvhsubw_h_btest_lasx_xvhsubw_w_htest_lasx_xvhsubw_d_wtest_lasx_xvhsubw_hu_butest_lasx_xvhsubw_wu_hutest_lasx_xvhsubw_du_wutest_lasx_xvmod_btest_lasx_xvmod_htest_lasx_xvmod_wtest_lasx_xvmod_dtest_lasx_xvmod_butest_lasx_xvmod_hutest_lasx_xvmod_wutest_lasx_xvmod_dutest_lasx_xvrepl128vei_btest_lasx_xvrepl128vei_htest_lasx_xvrepl128vei_wtest_lasx_xvrepl128vei_dtest_lasx_xvpickev_btest_lasx_xvpickev_htest_lasx_xvpickev_wtest_lasx_xvpickev_dtest_lasx_xvpickod_btest_lasx_xvpickod_htest_lasx_xvpickod_wtest_lasx_xvpickod_dtest_lasx_xvilvh_btest_lasx_xvilvh_htest_lasx_xvilvh_wtest_lasx_xvilvh_dtest_lasx_xvilvl_btest_lasx_xvilvl_htest_lasx_xvilvl_wtest_lasx_xvilvl_dtest_lasx_xvpackev_btest_lasx_xvpackev_htest_lasx_xvpackev_wtest_lasx_xvpackev_dtest_lasx_xvpackod_btest_lasx_xvpackod_htest_lasx_xvpackod_wtest_lasx_xvpackod_dtest_lasx_xvshuf_btest_lasx_xvshuf_htest_lasx_xvshuf_wtest_lasx_xvshuf_dtest_lasx_xvand_vtest_lasx_xvandi_btest_lasx_xvor_vtest_lasx_xvori_btest_lasx_xvnor_vtest_lasx_xvnori_btest_lasx_xvxor_vtest_lasx_xvxori_btest_lasx_xvbitsel_vtest_lasx_xvbitseli_btest_lasx_xvshuf4i_btest_lasx_xvshuf4i_htest_lasx_xvshuf4i_wtest_lasx_xvreplgr2vr_btest_lasx_xvreplgr2vr_htest_lasx_xvreplgr2vr_wtest_lasx_xvreplgr2vr_dtest_lasx_xvpcnt_btest_lasx_xvpcnt_htest_lasx_xvpcnt_wtest_lasx_xvpcnt_dtest_lasx_xvclo_btest_lasx_xvclo_htest_lasx_xvclo_wtest_lasx_xvclo_dtest_lasx_xvclz_btest_lasx_xvclz_htest_lasx_xvclz_wtest_lasx_xvclz_dtest_lasx_xvfadd_stest_lasx_xvfadd_dtest_lasx_xvfsub_stest_lasx_xvfsub_dtest_lasx_xvfmul_stest_lasx_xvfmul_dtest_lasx_xvfdiv_stest_lasx_xvfdiv_dtest_lasx_xvfcvt_h_stest_lasx_xvfcvt_s_dtest_lasx_xvfmin_stest_lasx_xvfmin_dtest_lasx_xvfmina_stest_lasx_xvfmina_dtest_lasx_xvfmax_stest_lasx_xvfmax_dtest_lasx_xvfmaxa_stest_lasx_xvfmaxa_dtest_lasx_xvfclass_stest_lasx_xvfclass_dtest_lasx_xvfsqrt_stest_lasx_xvfsqrt_dtest_lasx_xvfrecip_stest_lasx_xvfrecip_dtest_lasx_xvfrecipe_stest_lasx_xvfrecipe_dtest_lasx_xvfrsqrte_stest_lasx_xvfrsqrte_dtest_lasx_xvfrint_stest_lasx_xvfrint_dtest_lasx_xvfrsqrt_stest_lasx_xvfrsqrt_dtest_lasx_xvflogb_stest_lasx_xvflogb_dtest_lasx_xvfcvth_s_htest_lasx_xvfcvth_d_stest_lasx_xvfcvtl_s_htest_lasx_xvfcvtl_d_stest_lasx_xvftint_w_stest_lasx_xvftint_l_dtest_lasx_xvftint_wu_stest_lasx_xvftint_lu_dtest_lasx_xvftintrz_w_stest_lasx_xvftintrz_l_dtest_lasx_xvftintrz_wu_stest_lasx_xvftintrz_lu_dtest_lasx_xvffint_s_wtest_lasx_xvffint_d_ltest_lasx_xvffint_s_wutest_lasx_xvffint_d_lutest_lasx_xvreplve_btest_lasx_xvreplve_htest_lasx_xvreplve_wtest_lasx_xvreplve_dtest_lasx_xvpermi_wtest_lasx_xvandn_vtest_lasx_xvneg_btest_lasx_xvneg_htest_lasx_xvneg_wtest_lasx_xvneg_dtest_lasx_xvmuh_btest_lasx_xvmuh_htest_lasx_xvmuh_wtest_lasx_xvmuh_dtest_lasx_xvmuh_butest_lasx_xvmuh_hutest_lasx_xvmuh_wutest_lasx_xvmuh_dutest_lasx_xvsllwil_h_btest_lasx_xvsllwil_w_htest_lasx_xvsllwil_d_wtest_lasx_xvsllwil_hu_butest_lasx_xvsllwil_wu_hutest_lasx_xvsllwil_du_wutest_lasx_xvsran_b_htest_lasx_xvsran_h_wtest_lasx_xvsran_w_dtest_lasx_xvssran_b_htest_lasx_xvssran_h_wtest_lasx_xvssran_w_dtest_lasx_xvssran_bu_htest_lasx_xvssran_hu_wtest_lasx_xvssran_wu_dtest_lasx_xvsrarn_b_htest_lasx_xvsrarn_h_wtest_lasx_xvsrarn_w_dtest_lasx_xvssrarn_b_htest_lasx_xvssrarn_h_wtest_lasx_xvssrarn_w_dtest_lasx_xvssrarn_bu_htest_lasx_xvssrarn_hu_wtest_lasx_xvssrarn_wu_dtest_lasx_xvsrln_b_htest_lasx_xvsrln_h_wtest_lasx_xvsrln_w_dtest_lasx_xvssrln_bu_htest_lasx_xvssrln_hu_wtest_lasx_xvssrln_wu_dtest_lasx_xvsrlrn_b_htest_lasx_xvsrlrn_h_wtest_lasx_xvsrlrn_w_dtest_lasx_xvssrlrn_bu_htest_lasx_xvssrlrn_hu_wtest_lasx_xvssrlrn_wu_dtest_lasx_xvfrstpi_btest_lasx_xvfrstpi_htest_lasx_xvfrstp_btest_lasx_xvfrstp_htest_lasx_xvshuf4i_dtest_lasx_xvbsrl_vtest_lasx_xvbsll_vtest_lasx_xvextrins_btest_lasx_xvextrins_htest_lasx_xvextrins_wtest_lasx_xvextrins_dtest_lasx_xvmskltz_btest_lasx_xvmskltz_htest_lasx_xvmskltz_wtest_lasx_xvmskltz_dtest_lasx_xvsigncov_btest_lasx_xvsigncov_htest_lasx_xvsigncov_wtest_lasx_xvsigncov_dtest_lasx_xvfmadd_stest_lasx_xvfmadd_dtest_lasx_xvfmsub_stest_lasx_xvfmsub_dtest_lasx_xvfnmadd_stest_lasx_xvfnmadd_dtest_lasx_xvfnmsub_stest_lasx_xvfnmsub_dtest_lasx_xvftintrne_w_stest_lasx_xvftintrne_l_dtest_lasx_xvftintrp_w_stest_lasx_xvftintrp_l_dtest_lasx_xvftintrm_w_stest_lasx_xvftintrm_l_dtest_lasx_xvftint_w_dtest_lasx_xvffint_s_ltest_lasx_xvftintrz_w_dtest_lasx_xvftintrp_w_dtest_lasx_xvftintrm_w_dtest_lasx_xvftintrne_w_dtest_lasx_xvftinth_l_stest_lasx_xvftintl_l_stest_lasx_xvffinth_d_wtest_lasx_xvffintl_d_wtest_lasx_xvftintrzh_l_stest_lasx_xvftintrzl_l_stest_lasx_xvftintrph_l_stest_lasx_xvftintrpl_l_stest_lasx_xvftintrmh_l_stest_lasx_xvftintrml_l_stest_lasx_xvftintrneh_l_stest_lasx_xvftintrnel_l_stest_lasx_xvfrintrne_stest_lasx_xvfrintrne_dtest_lasx_xvfrintrz_stest_lasx_xvfrintrz_dtest_lasx_xvfrintrp_stest_lasx_xvfrintrp_dtest_lasx_xvfrintrm_stest_lasx_xvfrintrm_dtest_lasx_xvldtest_lasx_xvsttest_lasx_xvstelm_btest_lasx_xvstelm_htest_lasx_xvstelm_wtest_lasx_xvstelm_dtest_lasx_xvinsve0_wtest_lasx_xvinsve0_dtest_lasx_xvpickve_wtest_lasx_xvpickve_dtest_lasx_xvssrlrn_b_htest_lasx_xvssrlrn_h_wtest_lasx_xvssrlrn_w_dtest_lasx_xvssrln_b_htest_lasx_xvssrln_h_wtest_lasx_xvssrln_w_dtest_lasx_xvorn_vtest_lasx_xvlditest_lasx_xvldxtest_lasx_xvstxtest_lasx_xvextl_qu_dutest_lasx_xvinsgr2vr_wtest_lasx_xvinsgr2vr_dtest_lasx_xvreplve0_btest_lasx_xvreplve0_htest_lasx_xvreplve0_wtest_lasx_xvreplve0_dtest_lasx_xvreplve0_qtest_lasx_vext2xv_h_btest_lasx_vext2xv_w_htest_lasx_vext2xv_d_wtest_lasx_vext2xv_w_btest_lasx_vext2xv_d_htest_lasx_vext2xv_d_btest_lasx_vext2xv_hu_butest_lasx_vext2xv_wu_hutest_lasx_vext2xv_du_wutest_lasx_vext2xv_wu_butest_lasx_vext2xv_du_hutest_lasx_vext2xv_du_butest_lasx_xvpermi_qtest_lasx_xvpermi_dtest_lasx_xvperm_wtest_lasx_xvldrepl_btest_lasx_xvldrepl_htest_lasx_xvldrepl_wtest_lasx_xvldrepl_dtest_lasx_xvpickve2gr_wtest_lasx_xvpickve2gr_wutest_lasx_xvpickve2gr_dtest_lasx_xvpickve2gr_dutest_lasx_xvaddwev_q_dtest_lasx_xvaddwev_d_wtest_lasx_xvaddwev_w_htest_lasx_xvaddwev_h_btest_lasx_xvaddwev_q_dutest_lasx_xvaddwev_d_wutest_lasx_xvaddwev_w_hutest_lasx_xvaddwev_h_butest_lasx_xvsubwev_q_dtest_lasx_xvsubwev_d_wtest_lasx_xvsubwev_w_htest_lasx_xvsubwev_h_btest_lasx_xvsubwev_q_dutest_lasx_xvsubwev_d_wutest_lasx_xvsubwev_w_hutest_lasx_xvsubwev_h_butest_lasx_xvmulwev_q_dtest_lasx_xvmulwev_d_wtest_lasx_xvmulwev_w_htest_lasx_xvmulwev_h_btest_lasx_xvmulwev_q_dutest_lasx_xvmulwev_d_wutest_lasx_xvmulwev_w_hutest_lasx_xvmulwev_h_butest_lasx_xvaddwod_q_dtest_lasx_xvaddwod_d_wtest_lasx_xvaddwod_w_htest_lasx_xvaddwod_h_btest_lasx_xvaddwod_q_dutest_lasx_xvaddwod_d_wutest_lasx_xvaddwod_w_hutest_lasx_xvaddwod_h_butest_lasx_xvsubwod_q_dtest_lasx_xvsubwod_d_wtest_lasx_xvsubwod_w_htest_lasx_xvsubwod_h_btest_lasx_xvsubwod_q_dutest_lasx_xvsubwod_d_wutest_lasx_xvsubwod_w_hutest_lasx_xvsubwod_h_butest_lasx_xvmulwod_q_dtest_lasx_xvmulwod_d_wtest_lasx_xvmulwod_w_htest_lasx_xvmulwod_h_btest_lasx_xvmulwod_q_dutest_lasx_xvmulwod_d_wutest_lasx_xvmulwod_w_hutest_lasx_xvmulwod_h_butest_lasx_xvaddwev_d_wu_wtest_lasx_xvaddwev_w_hu_htest_lasx_xvaddwev_h_bu_btest_lasx_xvmulwev_d_wu_wtest_lasx_xvmulwev_w_hu_htest_lasx_xvmulwev_h_bu_btest_lasx_xvaddwod_d_wu_wtest_lasx_xvaddwod_w_hu_htest_lasx_xvaddwod_h_bu_btest_lasx_xvmulwod_d_wu_wtest_lasx_xvmulwod_w_hu_htest_lasx_xvmulwod_h_bu_btest_lasx_xvhaddw_q_dtest_lasx_xvhaddw_qu_dutest_lasx_xvhsubw_q_dtest_lasx_xvhsubw_qu_dutest_lasx_xvmaddwev_q_dtest_lasx_xvmaddwev_d_wtest_lasx_xvmaddwev_w_htest_lasx_xvmaddwev_h_btest_lasx_xvmaddwev_q_dutest_lasx_xvmaddwev_d_wutest_lasx_xvmaddwev_w_hutest_lasx_xvmaddwev_h_butest_lasx_xvmaddwod_q_dtest_lasx_xvmaddwod_d_wtest_lasx_xvmaddwod_w_htest_lasx_xvmaddwod_h_btest_lasx_xvmaddwod_q_dutest_lasx_xvmaddwod_d_wutest_lasx_xvmaddwod_w_hutest_lasx_xvmaddwod_h_butest_lasx_xvmaddwev_q_du_dtest_lasx_xvmaddwev_d_wu_wtest_lasx_xvmaddwev_w_hu_htest_lasx_xvmaddwev_h_bu_btest_lasx_xvmaddwod_q_du_dtest_lasx_xvmaddwod_d_wu_wtest_lasx_xvmaddwod_w_hu_htest_lasx_xvmaddwod_h_bu_btest_lasx_xvrotr_btest_lasx_xvrotr_htest_lasx_xvrotr_wtest_lasx_xvrotr_dtest_lasx_xvadd_qtest_lasx_xvsub_qtest_lasx_xvaddwev_q_du_dtest_lasx_xvaddwod_q_du_dtest_lasx_xvmulwev_q_du_dtest_lasx_xvmulwod_q_du_dtest_lasx_xvmskgez_btest_lasx_xvmsknz_btest_lasx_xvexth_h_btest_lasx_xvexth_w_htest_lasx_xvexth_d_wtest_lasx_xvexth_q_dtest_lasx_xvexth_hu_butest_lasx_xvexth_wu_hutest_lasx_xvexth_du_wutest_lasx_xvexth_qu_dutest_lasx_xvrotri_btest_lasx_xvrotri_htest_lasx_xvrotri_wtest_lasx_xvrotri_dtest_lasx_xvextl_q_dtest_lasx_xvsrlni_b_htest_lasx_xvsrlni_h_wtest_lasx_xvsrlni_w_dtest_lasx_xvsrlni_d_qtest_lasx_xvsrlrni_b_htest_lasx_xvsrlrni_h_wtest_lasx_xvsrlrni_w_dtest_lasx_xvsrlrni_d_qtest_lasx_xvssrlni_b_htest_lasx_xvssrlni_h_wtest_lasx_xvssrlni_w_dtest_lasx_xvssrlni_d_qtest_lasx_xvssrlni_bu_htest_lasx_xvssrlni_hu_wtest_lasx_xvssrlni_wu_dtest_lasx_xvssrlni_du_qtest_lasx_xvssrlrni_b_htest_lasx_xvssrlrni_h_wtest_lasx_xvssrlrni_w_dtest_lasx_xvssrlrni_d_qtest_lasx_xvssrlrni_bu_htest_lasx_xvssrlrni_hu_wtest_lasx_xvssrlrni_wu_dtest_lasx_xvssrlrni_du_qtest_lasx_xvsrani_b_htest_lasx_xvsrani_h_wtest_lasx_xvsrani_w_dtest_lasx_xvsrani_d_qtest_lasx_xvsrarni_b_htest_lasx_xvsrarni_h_wtest_lasx_xvsrarni_w_dtest_lasx_xvsrarni_d_qtest_lasx_xvssrani_b_htest_lasx_xvssrani_h_wtest_lasx_xvssrani_w_dtest_lasx_xvssrani_d_qtest_lasx_xvssrani_bu_htest_lasx_xvssrani_hu_wtest_lasx_xvssrani_wu_dtest_lasx_xvssrani_du_qtest_lasx_xvssrarni_b_htest_lasx_xvssrarni_h_wtest_lasx_xvssrarni_w_dtest_lasx_xvssrarni_d_qtest_lasx_xvssrarni_bu_htest_lasx_xvssrarni_hu_wtest_lasx_xvssrarni_wu_dtest_lasx_xvssrarni_du_qtest_lasx_xbnz_btest_lasx_xbnz_dtest_lasx_xbnz_htest_lasx_xbnz_vtest_lasx_xbnz_wtest_lasx_xbz_btest_lasx_xbz_dtest_lasx_xbz_htest_lasx_xbz_vtest_lasx_xbz_wtest_lasx_xvfcmp_caf_dtest_lasx_xvfcmp_caf_stest_lasx_xvfcmp_ceq_dtest_lasx_xvfcmp_ceq_stest_lasx_xvfcmp_cle_dtest_lasx_xvfcmp_cle_stest_lasx_xvfcmp_clt_dtest_lasx_xvfcmp_clt_stest_lasx_xvfcmp_cne_dtest_lasx_xvfcmp_cne_stest_lasx_xvfcmp_cor_dtest_lasx_xvfcmp_cor_stest_lasx_xvfcmp_cueq_dtest_lasx_xvfcmp_cueq_stest_lasx_xvfcmp_cule_dtest_lasx_xvfcmp_cule_stest_lasx_xvfcmp_cult_dtest_lasx_xvfcmp_cult_stest_lasx_xvfcmp_cun_dtest_lasx_xvfcmp_cune_dtest_lasx_xvfcmp_cune_stest_lasx_xvfcmp_cun_stest_lasx_xvfcmp_saf_dtest_lasx_xvfcmp_saf_stest_lasx_xvfcmp_seq_dtest_lasx_xvfcmp_seq_stest_lasx_xvfcmp_sle_dtest_lasx_xvfcmp_sle_stest_lasx_xvfcmp_slt_dtest_lasx_xvfcmp_slt_stest_lasx_xvfcmp_sne_dtest_lasx_xvfcmp_sne_stest_lasx_xvfcmp_sor_dtest_lasx_xvfcmp_sor_stest_lasx_xvfcmp_sueq_dtest_lasx_xvfcmp_sueq_stest_lasx_xvfcmp_sule_dtest_lasx_xvfcmp_sule_stest_lasx_xvfcmp_sult_dtest_lasx_xvfcmp_sult_stest_lasx_xvfcmp_sun_dtest_lasx_xvfcmp_sune_dtest_lasx_xvfcmp_sune_stest_lasx_xvfcmp_sun_stest_lasx_xvpickve_d_ftest_lasx_xvpickve_w_ftest_lasx_xvrepli_btest_lasx_xvrepli_dtest_lasx_xvrepli_htest_lasx_xvrepli_w// See crates/stdarch-gen-loongarch/README.mdv32i8// These type aliases are provided solely for transitional compatibility.// They are temporary and will be removed when appropriate.v16i16v8i32v4i64v32u8v16u16v8u32v4u64v8f32v4f64"llvm.loongarch.lsx.vsll.b"__lsx_vsll_b__v16i8"llvm.loongarch.lsx.vsll.h"__lsx_vsll_h__v8i16"llvm.loongarch.lsx.vsll.w"__lsx_vsll_w__v4i32"llvm.loongarch.lsx.vsll.d"__lsx_vsll_d__v2i64"llvm.loongarch.lsx.vslli.b"__lsx_vslli_b"llvm.loongarch.lsx.vslli.h"__lsx_vslli_h"llvm.loongarch.lsx.vslli.w"__lsx_vslli_w"llvm.loongarch.lsx.vslli.d"__lsx_vslli_d"llvm.loongarch.lsx.vsra.b"__lsx_vsra_b"llvm.loongarch.lsx.vsra.h"__lsx_vsra_h"llvm.loongarch.lsx.vsra.w"__lsx_vsra_w"llvm.loongarch.lsx.vsra.d"__lsx_vsra_d"llvm.loongarch.lsx.vsrai.b"__lsx_vsrai_b"llvm.loongarch.lsx.vsrai.h"__lsx_vsrai_h"llvm.loongarch.lsx.vsrai.w"__lsx_vsrai_w"llvm.loongarch.lsx.vsrai.d"__lsx_vsrai_d"llvm.loongarch.lsx.vsrar.b"__lsx_vsrar_b"llvm.loongarch.lsx.vsrar.h"__lsx_vsrar_h"llvm.loongarch.lsx.vsrar.w"__lsx_vsrar_w"llvm.loongarch.lsx.vsrar.d"__lsx_vsrar_d"llvm.loongarch.lsx.vsrari.b"__lsx_vsrari_b"llvm.loongarch.lsx.vsrari.h"__lsx_vsrari_h"llvm.loongarch.lsx.vsrari.w"__lsx_vsrari_w"llvm.loongarch.lsx.vsrari.d"__lsx_vsrari_d"llvm.loongarch.lsx.vsrl.b"__lsx_vsrl_b"llvm.loongarch.lsx.vsrl.h"__lsx_vsrl_h"llvm.loongarch.lsx.vsrl.w"__lsx_vsrl_w"llvm.loongarch.lsx.vsrl.d"__lsx_vsrl_d"llvm.loongarch.lsx.vsrli.b"__lsx_vsrli_b"llvm.loongarch.lsx.vsrli.h"__lsx_vsrli_h"llvm.loongarch.lsx.vsrli.w"__lsx_vsrli_w"llvm.loongarch.lsx.vsrli.d"__lsx_vsrli_d"llvm.loongarch.lsx.vsrlr.b"__lsx_vsrlr_b"llvm.loongarch.lsx.vsrlr.h"__lsx_vsrlr_h"llvm.loongarch.lsx.vsrlr.w"__lsx_vsrlr_w"llvm.loongarch.lsx.vsrlr.d"__lsx_vsrlr_d"llvm.loongarch.lsx.vsrlri.b"__lsx_vsrlri_b"llvm.loongarch.lsx.vsrlri.h"__lsx_vsrlri_h"llvm.loongarch.lsx.vsrlri.w"__lsx_vsrlri_w"llvm.loongarch.lsx.vsrlri.d"__lsx_vsrlri_d"llvm.loongarch.lsx.vbitclr.b"__lsx_vbitclr_b__v16u8"llvm.loongarch.lsx.vbitclr.h"__lsx_vbitclr_h__v8u16"llvm.loongarch.lsx.vbitclr.w"__lsx_vbitclr_w__v4u32"llvm.loongarch.lsx.vbitclr.d"__lsx_vbitclr_d__v2u64"llvm.loongarch.lsx.vbitclri.b"__lsx_vbitclri_b"llvm.loongarch.lsx.vbitclri.h"__lsx_vbitclri_h"llvm.loongarch.lsx.vbitclri.w"__lsx_vbitclri_w"llvm.loongarch.lsx.vbitclri.d"__lsx_vbitclri_d"llvm.loongarch.lsx.vbitset.b"__lsx_vbitset_b"llvm.loongarch.lsx.vbitset.h"__lsx_vbitset_h"llvm.loongarch.lsx.vbitset.w"__lsx_vbitset_w"llvm.loongarch.lsx.vbitset.d"__lsx_vbitset_d"llvm.loongarch.lsx.vbitseti.b"__lsx_vbitseti_b"llvm.loongarch.lsx.vbitseti.h"__lsx_vbitseti_h"llvm.loongarch.lsx.vbitseti.w"__lsx_vbitseti_w"llvm.loongarch.lsx.vbitseti.d"__lsx_vbitseti_d"llvm.loongarch.lsx.vbitrev.b"__lsx_vbitrev_b"llvm.loongarch.lsx.vbitrev.h"__lsx_vbitrev_h"llvm.loongarch.lsx.vbitrev.w"__lsx_vbitrev_w"llvm.loongarch.lsx.vbitrev.d"__lsx_vbitrev_d"llvm.loongarch.lsx.vbitrevi.b"__lsx_vbitrevi_b"llvm.loongarch.lsx.vbitrevi.h"__lsx_vbitrevi_h"llvm.loongarch.lsx.vbitrevi.w"__lsx_vbitrevi_w"llvm.loongarch.lsx.vbitrevi.d"__lsx_vbitrevi_d"llvm.loongarch.lsx.vadd.b"__lsx_vadd_b"llvm.loongarch.lsx.vadd.h"__lsx_vadd_h"llvm.loongarch.lsx.vadd.w"__lsx_vadd_w"llvm.loongarch.lsx.vadd.d"__lsx_vadd_d"llvm.loongarch.lsx.vaddi.bu"__lsx_vaddi_bu"llvm.loongarch.lsx.vaddi.hu"__lsx_vaddi_hu"llvm.loongarch.lsx.vaddi.wu"__lsx_vaddi_wu"llvm.loongarch.lsx.vaddi.du"__lsx_vaddi_du"llvm.loongarch.lsx.vsub.b"__lsx_vsub_b"llvm.loongarch.lsx.vsub.h"__lsx_vsub_h"llvm.loongarch.lsx.vsub.w"__lsx_vsub_w"llvm.loongarch.lsx.vsub.d"__lsx_vsub_d"llvm.loongarch.lsx.vsubi.bu"__lsx_vsubi_bu"llvm.loongarch.lsx.vsubi.hu"__lsx_vsubi_hu"llvm.loongarch.lsx.vsubi.wu"__lsx_vsubi_wu"llvm.loongarch.lsx.vsubi.du"__lsx_vsubi_du"llvm.loongarch.lsx.vmax.b"__lsx_vmax_b"llvm.loongarch.lsx.vmax.h"__lsx_vmax_h"llvm.loongarch.lsx.vmax.w"__lsx_vmax_w"llvm.loongarch.lsx.vmax.d"__lsx_vmax_d"llvm.loongarch.lsx.vmaxi.b"__lsx_vmaxi_b"llvm.loongarch.lsx.vmaxi.h"__lsx_vmaxi_h"llvm.loongarch.lsx.vmaxi.w"__lsx_vmaxi_w"llvm.loongarch.lsx.vmaxi.d"__lsx_vmaxi_d"llvm.loongarch.lsx.vmax.bu"__lsx_vmax_bu"llvm.loongarch.lsx.vmax.hu"__lsx_vmax_hu"llvm.loongarch.lsx.vmax.wu"__lsx_vmax_wu"llvm.loongarch.lsx.vmax.du"__lsx_vmax_du"llvm.loongarch.lsx.vmaxi.bu"__lsx_vmaxi_bu"llvm.loongarch.lsx.vmaxi.hu"__lsx_vmaxi_hu"llvm.loongarch.lsx.vmaxi.wu"__lsx_vmaxi_wu"llvm.loongarch.lsx.vmaxi.du"__lsx_vmaxi_du"llvm.loongarch.lsx.vmin.b"__lsx_vmin_b"llvm.loongarch.lsx.vmin.h"__lsx_vmin_h"llvm.loongarch.lsx.vmin.w"__lsx_vmin_w"llvm.loongarch.lsx.vmin.d"__lsx_vmin_d"llvm.loongarch.lsx.vmini.b"__lsx_vmini_b"llvm.loongarch.lsx.vmini.h"__lsx_vmini_h"llvm.loongarch.lsx.vmini.w"__lsx_vmini_w"llvm.loongarch.lsx.vmini.d"__lsx_vmini_d"llvm.loongarch.lsx.vmin.bu"__lsx_vmin_bu"llvm.loongarch.lsx.vmin.hu"__lsx_vmin_hu"llvm.loongarch.lsx.vmin.wu"__lsx_vmin_wu"llvm.loongarch.lsx.vmin.du"__lsx_vmin_du"llvm.loongarch.lsx.vmini.bu"__lsx_vmini_bu"llvm.loongarch.lsx.vmini.hu"__lsx_vmini_hu"llvm.loongarch.lsx.vmini.wu"__lsx_vmini_wu"llvm.loongarch.lsx.vmini.du"__lsx_vmini_du"llvm.loongarch.lsx.vseq.b"__lsx_vseq_b"llvm.loongarch.lsx.vseq.h"__lsx_vseq_h"llvm.loongarch.lsx.vseq.w"__lsx_vseq_w"llvm.loongarch.lsx.vseq.d"__lsx_vseq_d"llvm.loongarch.lsx.vseqi.b"__lsx_vseqi_b"llvm.loongarch.lsx.vseqi.h"__lsx_vseqi_h"llvm.loongarch.lsx.vseqi.w"__lsx_vseqi_w"llvm.loongarch.lsx.vseqi.d"__lsx_vseqi_d"llvm.loongarch.lsx.vslti.b"__lsx_vslti_b"llvm.loongarch.lsx.vslt.b"__lsx_vslt_b"llvm.loongarch.lsx.vslt.h"__lsx_vslt_h"llvm.loongarch.lsx.vslt.w"__lsx_vslt_w"llvm.loongarch.lsx.vslt.d"__lsx_vslt_d"llvm.loongarch.lsx.vslti.h"__lsx_vslti_h"llvm.loongarch.lsx.vslti.w"__lsx_vslti_w"llvm.loongarch.lsx.vslti.d"__lsx_vslti_d"llvm.loongarch.lsx.vslt.bu"__lsx_vslt_bu"llvm.loongarch.lsx.vslt.hu"__lsx_vslt_hu"llvm.loongarch.lsx.vslt.wu"__lsx_vslt_wu"llvm.loongarch.lsx.vslt.du"__lsx_vslt_du"llvm.loongarch.lsx.vslti.bu"__lsx_vslti_bu"llvm.loongarch.lsx.vslti.hu"__lsx_vslti_hu"llvm.loongarch.lsx.vslti.wu"__lsx_vslti_wu"llvm.loongarch.lsx.vslti.du"__lsx_vslti_du"llvm.loongarch.lsx.vsle.b"__lsx_vsle_b"llvm.loongarch.lsx.vsle.h"__lsx_vsle_h"llvm.loongarch.lsx.vsle.w"__lsx_vsle_w"llvm.loongarch.lsx.vsle.d"__lsx_vsle_d"llvm.loongarch.lsx.vslei.b"__lsx_vslei_b"llvm.loongarch.lsx.vslei.h"__lsx_vslei_h"llvm.loongarch.lsx.vslei.w"__lsx_vslei_w"llvm.loongarch.lsx.vslei.d"__lsx_vslei_d"llvm.loongarch.lsx.vsle.bu"__lsx_vsle_bu"llvm.loongarch.lsx.vsle.hu"__lsx_vsle_hu"llvm.loongarch.lsx.vsle.wu"__lsx_vsle_wu"llvm.loongarch.lsx.vsle.du"__lsx_vsle_du"llvm.loongarch.lsx.vslei.bu"__lsx_vslei_bu"llvm.loongarch.lsx.vslei.hu"__lsx_vslei_hu"llvm.loongarch.lsx.vslei.wu"__lsx_vslei_wu"llvm.loongarch.lsx.vslei.du"__lsx_vslei_du"llvm.loongarch.lsx.vsat.b"__lsx_vsat_b"llvm.loongarch.lsx.vsat.h"__lsx_vsat_h"llvm.loongarch.lsx.vsat.w"__lsx_vsat_w"llvm.loongarch.lsx.vsat.d"__lsx_vsat_d"llvm.loongarch.lsx.vsat.bu"__lsx_vsat_bu"llvm.loongarch.lsx.vsat.hu"__lsx_vsat_hu"llvm.loongarch.lsx.vsat.wu"__lsx_vsat_wu"llvm.loongarch.lsx.vsat.du"__lsx_vsat_du"llvm.loongarch.lsx.vadda.b"__lsx_vadda_b"llvm.loongarch.lsx.vadda.h"__lsx_vadda_h"llvm.loongarch.lsx.vadda.w"__lsx_vadda_w"llvm.loongarch.lsx.vadda.d"__lsx_vadda_d"llvm.loongarch.lsx.vsadd.b"__lsx_vsadd_b"llvm.loongarch.lsx.vsadd.h"__lsx_vsadd_h"llvm.loongarch.lsx.vsadd.w"__lsx_vsadd_w"llvm.loongarch.lsx.vsadd.d"__lsx_vsadd_d"llvm.loongarch.lsx.vsadd.bu"__lsx_vsadd_bu"llvm.loongarch.lsx.vsadd.hu"__lsx_vsadd_hu"llvm.loongarch.lsx.vsadd.wu"__lsx_vsadd_wu"llvm.loongarch.lsx.vsadd.du"__lsx_vsadd_du"llvm.loongarch.lsx.vavg.b"__lsx_vavg_b"llvm.loongarch.lsx.vavg.h"__lsx_vavg_h"llvm.loongarch.lsx.vavg.w"__lsx_vavg_w"llvm.loongarch.lsx.vavg.d"__lsx_vavg_d"llvm.loongarch.lsx.vavg.bu"__lsx_vavg_bu"llvm.loongarch.lsx.vavg.hu"__lsx_vavg_hu"llvm.loongarch.lsx.vavg.wu"__lsx_vavg_wu"llvm.loongarch.lsx.vavg.du"__lsx_vavg_du"llvm.loongarch.lsx.vavgr.b"__lsx_vavgr_b"llvm.loongarch.lsx.vavgr.h"__lsx_vavgr_h"llvm.loongarch.lsx.vavgr.w"__lsx_vavgr_w"llvm.loongarch.lsx.vavgr.d"__lsx_vavgr_d"llvm.loongarch.lsx.vavgr.bu"__lsx_vavgr_bu"llvm.loongarch.lsx.vavgr.hu"__lsx_vavgr_hu"llvm.loongarch.lsx.vavgr.wu"__lsx_vavgr_wu"llvm.loongarch.lsx.vavgr.du"__lsx_vavgr_du"llvm.loongarch.lsx.vssub.b"__lsx_vssub_b"llvm.loongarch.lsx.vssub.h"__lsx_vssub_h"llvm.loongarch.lsx.vssub.w"__lsx_vssub_w"llvm.loongarch.lsx.vssub.d"__lsx_vssub_d"llvm.loongarch.lsx.vssub.bu"__lsx_vssub_bu"llvm.loongarch.lsx.vssub.hu"__lsx_vssub_hu"llvm.loongarch.lsx.vssub.wu"__lsx_vssub_wu"llvm.loongarch.lsx.vssub.du"__lsx_vssub_du"llvm.loongarch.lsx.vabsd.b"__lsx_vabsd_b"llvm.loongarch.lsx.vabsd.h"__lsx_vabsd_h"llvm.loongarch.lsx.vabsd.w"__lsx_vabsd_w"llvm.loongarch.lsx.vabsd.d"__lsx_vabsd_d"llvm.loongarch.lsx.vabsd.bu"__lsx_vabsd_bu"llvm.loongarch.lsx.vabsd.hu"__lsx_vabsd_hu"llvm.loongarch.lsx.vabsd.wu"__lsx_vabsd_wu"llvm.loongarch.lsx.vabsd.du"__lsx_vabsd_du"llvm.loongarch.lsx.vmul.b"__lsx_vmul_b"llvm.loongarch.lsx.vmul.h"__lsx_vmul_h"llvm.loongarch.lsx.vmul.w"__lsx_vmul_w"llvm.loongarch.lsx.vmul.d"__lsx_vmul_d"llvm.loongarch.lsx.vmadd.b"__lsx_vmadd_b"llvm.loongarch.lsx.vmadd.h"__lsx_vmadd_h"llvm.loongarch.lsx.vmadd.w"__lsx_vmadd_w"llvm.loongarch.lsx.vmadd.d"__lsx_vmadd_d"llvm.loongarch.lsx.vmsub.b"__lsx_vmsub_b"llvm.loongarch.lsx.vmsub.h"__lsx_vmsub_h"llvm.loongarch.lsx.vmsub.w"__lsx_vmsub_w"llvm.loongarch.lsx.vmsub.d"__lsx_vmsub_d"llvm.loongarch.lsx.vdiv.b"__lsx_vdiv_b"llvm.loongarch.lsx.vdiv.h"__lsx_vdiv_h"llvm.loongarch.lsx.vdiv.w"__lsx_vdiv_w"llvm.loongarch.lsx.vdiv.d"__lsx_vdiv_d"llvm.loongarch.lsx.vdiv.bu"__lsx_vdiv_bu"llvm.loongarch.lsx.vdiv.hu"__lsx_vdiv_hu"llvm.loongarch.lsx.vdiv.wu"__lsx_vdiv_wu"llvm.loongarch.lsx.vdiv.du"__lsx_vdiv_du"llvm.loongarch.lsx.vhaddw.h.b"__lsx_vhaddw_h_b"llvm.loongarch.lsx.vhaddw.w.h"__lsx_vhaddw_w_h"llvm.loongarch.lsx.vhaddw.d.w"__lsx_vhaddw_d_w"llvm.loongarch.lsx.vhaddw.hu.bu"__lsx_vhaddw_hu_bu"llvm.loongarch.lsx.vhaddw.wu.hu"__lsx_vhaddw_wu_hu"llvm.loongarch.lsx.vhaddw.du.wu"__lsx_vhaddw_du_wu"llvm.loongarch.lsx.vhsubw.h.b"__lsx_vhsubw_h_b"llvm.loongarch.lsx.vhsubw.w.h"__lsx_vhsubw_w_h"llvm.loongarch.lsx.vhsubw.d.w"__lsx_vhsubw_d_w"llvm.loongarch.lsx.vhsubw.hu.bu"__lsx_vhsubw_hu_bu"llvm.loongarch.lsx.vhsubw.wu.hu"__lsx_vhsubw_wu_hu"llvm.loongarch.lsx.vhsubw.du.wu"__lsx_vhsubw_du_wu"llvm.loongarch.lsx.vmod.b"__lsx_vmod_b"llvm.loongarch.lsx.vmod.h"__lsx_vmod_h"llvm.loongarch.lsx.vmod.w"__lsx_vmod_w"llvm.loongarch.lsx.vmod.d"__lsx_vmod_d"llvm.loongarch.lsx.vmod.bu"__lsx_vmod_bu"llvm.loongarch.lsx.vmod.hu"__lsx_vmod_hu"llvm.loongarch.lsx.vmod.wu"__lsx_vmod_wu"llvm.loongarch.lsx.vmod.du"__lsx_vmod_du"llvm.loongarch.lsx.vreplve.b"__lsx_vreplve_b"llvm.loongarch.lsx.vreplve.h"__lsx_vreplve_h"llvm.loongarch.lsx.vreplve.w"__lsx_vreplve_w"llvm.loongarch.lsx.vreplve.d"__lsx_vreplve_d"llvm.loongarch.lsx.vreplvei.b"__lsx_vreplvei_b"llvm.loongarch.lsx.vreplvei.h"__lsx_vreplvei_h"llvm.loongarch.lsx.vreplvei.w"__lsx_vreplvei_w"llvm.loongarch.lsx.vreplvei.d"__lsx_vreplvei_d"llvm.loongarch.lsx.vpickev.b"__lsx_vpickev_b"llvm.loongarch.lsx.vpickev.h"__lsx_vpickev_h"llvm.loongarch.lsx.vpickev.w"__lsx_vpickev_w"llvm.loongarch.lsx.vpickev.d"__lsx_vpickev_d"llvm.loongarch.lsx.vpickod.b"__lsx_vpickod_b"llvm.loongarch.lsx.vpickod.h"__lsx_vpickod_h"llvm.loongarch.lsx.vpickod.w"__lsx_vpickod_w"llvm.loongarch.lsx.vpickod.d"__lsx_vpickod_d"llvm.loongarch.lsx.vilvh.b"__lsx_vilvh_b"llvm.loongarch.lsx.vilvh.h"__lsx_vilvh_h"llvm.loongarch.lsx.vilvh.w"__lsx_vilvh_w"llvm.loongarch.lsx.vilvh.d"__lsx_vilvh_d"llvm.loongarch.lsx.vilvl.b"__lsx_vilvl_b"llvm.loongarch.lsx.vilvl.h"__lsx_vilvl_h"llvm.loongarch.lsx.vilvl.w"__lsx_vilvl_w"llvm.loongarch.lsx.vilvl.d"__lsx_vilvl_d"llvm.loongarch.lsx.vpackev.b"__lsx_vpackev_b"llvm.loongarch.lsx.vpackev.h"__lsx_vpackev_h"llvm.loongarch.lsx.vpackev.w"__lsx_vpackev_w"llvm.loongarch.lsx.vpackev.d"__lsx_vpackev_d"llvm.loongarch.lsx.vpackod.b"__lsx_vpackod_b"llvm.loongarch.lsx.vpackod.h"__lsx_vpackod_h"llvm.loongarch.lsx.vpackod.w"__lsx_vpackod_w"llvm.loongarch.lsx.vpackod.d"__lsx_vpackod_d"llvm.loongarch.lsx.vshuf.h"__lsx_vshuf_h"llvm.loongarch.lsx.vshuf.w"__lsx_vshuf_w"llvm.loongarch.lsx.vshuf.d"__lsx_vshuf_d"llvm.loongarch.lsx.vand.v"__lsx_vand_v"llvm.loongarch.lsx.vandi.b"__lsx_vandi_b"llvm.loongarch.lsx.vor.v"__lsx_vor_v"llvm.loongarch.lsx.vori.b"__lsx_vori_b"llvm.loongarch.lsx.vnor.v"__lsx_vnor_v"llvm.loongarch.lsx.vnori.b"__lsx_vnori_b"llvm.loongarch.lsx.vxor.v"__lsx_vxor_v"llvm.loongarch.lsx.vxori.b"__lsx_vxori_b"llvm.loongarch.lsx.vbitsel.v"__lsx_vbitsel_v"llvm.loongarch.lsx.vbitseli.b"__lsx_vbitseli_b"llvm.loongarch.lsx.vshuf4i.b"__lsx_vshuf4i_b"llvm.loongarch.lsx.vshuf4i.h"__lsx_vshuf4i_h"llvm.loongarch.lsx.vshuf4i.w"__lsx_vshuf4i_w"llvm.loongarch.lsx.vreplgr2vr.b"__lsx_vreplgr2vr_b"llvm.loongarch.lsx.vreplgr2vr.h"__lsx_vreplgr2vr_h"llvm.loongarch.lsx.vreplgr2vr.w"__lsx_vreplgr2vr_w"llvm.loongarch.lsx.vreplgr2vr.d"__lsx_vreplgr2vr_d"llvm.loongarch.lsx.vpcnt.b"__lsx_vpcnt_b"llvm.loongarch.lsx.vpcnt.h"__lsx_vpcnt_h"llvm.loongarch.lsx.vpcnt.w"__lsx_vpcnt_w"llvm.loongarch.lsx.vpcnt.d"__lsx_vpcnt_d"llvm.loongarch.lsx.vclo.b"__lsx_vclo_b"llvm.loongarch.lsx.vclo.h"__lsx_vclo_h"llvm.loongarch.lsx.vclo.w"__lsx_vclo_w"llvm.loongarch.lsx.vclo.d"__lsx_vclo_d"llvm.loongarch.lsx.vclz.b"__lsx_vclz_b"llvm.loongarch.lsx.vclz.h"__lsx_vclz_h"llvm.loongarch.lsx.vclz.w"__lsx_vclz_w"llvm.loongarch.lsx.vclz.d"__lsx_vclz_d"llvm.loongarch.lsx.vpickve2gr.b"__lsx_vpickve2gr_b"llvm.loongarch.lsx.vpickve2gr.h"__lsx_vpickve2gr_h"llvm.loongarch.lsx.vpickve2gr.w"__lsx_vpickve2gr_w"llvm.loongarch.lsx.vpickve2gr.d"__lsx_vpickve2gr_d"llvm.loongarch.lsx.vpickve2gr.bu"__lsx_vpickve2gr_bu"llvm.loongarch.lsx.vpickve2gr.hu"__lsx_vpickve2gr_hu"llvm.loongarch.lsx.vpickve2gr.wu"__lsx_vpickve2gr_wu"llvm.loongarch.lsx.vpickve2gr.du"__lsx_vpickve2gr_du"llvm.loongarch.lsx.vinsgr2vr.b"__lsx_vinsgr2vr_b"llvm.loongarch.lsx.vinsgr2vr.h"__lsx_vinsgr2vr_h"llvm.loongarch.lsx.vinsgr2vr.w"__lsx_vinsgr2vr_w"llvm.loongarch.lsx.vinsgr2vr.d"__lsx_vinsgr2vr_d"llvm.loongarch.lsx.vfadd.s"__lsx_vfadd_s__v4f32"llvm.loongarch.lsx.vfadd.d"__lsx_vfadd_d__v2f64"llvm.loongarch.lsx.vfsub.s"__lsx_vfsub_s"llvm.loongarch.lsx.vfsub.d"__lsx_vfsub_d"llvm.loongarch.lsx.vfmul.s"__lsx_vfmul_s"llvm.loongarch.lsx.vfmul.d"__lsx_vfmul_d"llvm.loongarch.lsx.vfdiv.s"__lsx_vfdiv_s"llvm.loongarch.lsx.vfdiv.d"__lsx_vfdiv_d"llvm.loongarch.lsx.vfcvt.h.s"__lsx_vfcvt_h_s"llvm.loongarch.lsx.vfcvt.s.d"__lsx_vfcvt_s_d"llvm.loongarch.lsx.vfmin.s"__lsx_vfmin_s"llvm.loongarch.lsx.vfmin.d"__lsx_vfmin_d"llvm.loongarch.lsx.vfmina.s"__lsx_vfmina_s"llvm.loongarch.lsx.vfmina.d"__lsx_vfmina_d"llvm.loongarch.lsx.vfmax.s"__lsx_vfmax_s"llvm.loongarch.lsx.vfmax.d"__lsx_vfmax_d"llvm.loongarch.lsx.vfmaxa.s"__lsx_vfmaxa_s"llvm.loongarch.lsx.vfmaxa.d"__lsx_vfmaxa_d"llvm.loongarch.lsx.vfclass.s"__lsx_vfclass_s"llvm.loongarch.lsx.vfclass.d"__lsx_vfclass_d"llvm.loongarch.lsx.vfsqrt.s"__lsx_vfsqrt_s"llvm.loongarch.lsx.vfsqrt.d"__lsx_vfsqrt_d"llvm.loongarch.lsx.vfrecip.s"__lsx_vfrecip_s"llvm.loongarch.lsx.vfrecip.d"__lsx_vfrecip_d"llvm.loongarch.lsx.vfrecipe.s"__lsx_vfrecipe_s"llvm.loongarch.lsx.vfrecipe.d"__lsx_vfrecipe_d"llvm.loongarch.lsx.vfrsqrte.s"__lsx_vfrsqrte_s"llvm.loongarch.lsx.vfrsqrte.d"__lsx_vfrsqrte_d"llvm.loongarch.lsx.vfrint.s"__lsx_vfrint_s"llvm.loongarch.lsx.vfrint.d"__lsx_vfrint_d"llvm.loongarch.lsx.vfrsqrt.s"__lsx_vfrsqrt_s"llvm.loongarch.lsx.vfrsqrt.d"__lsx_vfrsqrt_d"llvm.loongarch.lsx.vflogb.s"__lsx_vflogb_s"llvm.loongarch.lsx.vflogb.d"__lsx_vflogb_d"llvm.loongarch.lsx.vfcvth.s.h"__lsx_vfcvth_s_h"llvm.loongarch.lsx.vfcvth.d.s"__lsx_vfcvth_d_s"llvm.loongarch.lsx.vfcvtl.s.h"__lsx_vfcvtl_s_h"llvm.loongarch.lsx.vfcvtl.d.s"__lsx_vfcvtl_d_s"llvm.loongarch.lsx.vftint.w.s"__lsx_vftint_w_s"llvm.loongarch.lsx.vftint.l.d"__lsx_vftint_l_d"llvm.loongarch.lsx.vftint.wu.s"__lsx_vftint_wu_s"llvm.loongarch.lsx.vftint.lu.d"__lsx_vftint_lu_d"llvm.loongarch.lsx.vftintrz.w.s"__lsx_vftintrz_w_s"llvm.loongarch.lsx.vftintrz.l.d"__lsx_vftintrz_l_d"llvm.loongarch.lsx.vftintrz.wu.s"__lsx_vftintrz_wu_s"llvm.loongarch.lsx.vftintrz.lu.d"__lsx_vftintrz_lu_d"llvm.loongarch.lsx.vffint.s.w"__lsx_vffint_s_w"llvm.loongarch.lsx.vffint.d.l"__lsx_vffint_d_l"llvm.loongarch.lsx.vffint.s.wu"__lsx_vffint_s_wu"llvm.loongarch.lsx.vffint.d.lu"__lsx_vffint_d_lu"llvm.loongarch.lsx.vandn.v"__lsx_vandn_v"llvm.loongarch.lsx.vneg.b"__lsx_vneg_b"llvm.loongarch.lsx.vneg.h"__lsx_vneg_h"llvm.loongarch.lsx.vneg.w"__lsx_vneg_w"llvm.loongarch.lsx.vneg.d"__lsx_vneg_d"llvm.loongarch.lsx.vmuh.b"__lsx_vmuh_b"llvm.loongarch.lsx.vmuh.h"__lsx_vmuh_h"llvm.loongarch.lsx.vmuh.w"__lsx_vmuh_w"llvm.loongarch.lsx.vmuh.d"__lsx_vmuh_d"llvm.loongarch.lsx.vmuh.bu"__lsx_vmuh_bu"llvm.loongarch.lsx.vmuh.hu"__lsx_vmuh_hu"llvm.loongarch.lsx.vmuh.wu"__lsx_vmuh_wu"llvm.loongarch.lsx.vmuh.du"__lsx_vmuh_du"llvm.loongarch.lsx.vsllwil.h.b"__lsx_vsllwil_h_b"llvm.loongarch.lsx.vsllwil.w.h"__lsx_vsllwil_w_h"llvm.loongarch.lsx.vsllwil.d.w"__lsx_vsllwil_d_w"llvm.loongarch.lsx.vsllwil.hu.bu"__lsx_vsllwil_hu_bu"llvm.loongarch.lsx.vsllwil.wu.hu"__lsx_vsllwil_wu_hu"llvm.loongarch.lsx.vsllwil.du.wu"__lsx_vsllwil_du_wu"llvm.loongarch.lsx.vsran.b.h"__lsx_vsran_b_h"llvm.loongarch.lsx.vsran.h.w"__lsx_vsran_h_w"llvm.loongarch.lsx.vsran.w.d"__lsx_vsran_w_d"llvm.loongarch.lsx.vssran.b.h"__lsx_vssran_b_h"llvm.loongarch.lsx.vssran.h.w"__lsx_vssran_h_w"llvm.loongarch.lsx.vssran.w.d"__lsx_vssran_w_d"llvm.loongarch.lsx.vssran.bu.h"__lsx_vssran_bu_h"llvm.loongarch.lsx.vssran.hu.w"__lsx_vssran_hu_w"llvm.loongarch.lsx.vssran.wu.d"__lsx_vssran_wu_d"llvm.loongarch.lsx.vsrarn.b.h"__lsx_vsrarn_b_h"llvm.loongarch.lsx.vsrarn.h.w"__lsx_vsrarn_h_w"llvm.loongarch.lsx.vsrarn.w.d"__lsx_vsrarn_w_d"llvm.loongarch.lsx.vssrarn.b.h"__lsx_vssrarn_b_h"llvm.loongarch.lsx.vssrarn.h.w"__lsx_vssrarn_h_w"llvm.loongarch.lsx.vssrarn.w.d"__lsx_vssrarn_w_d"llvm.loongarch.lsx.vssrarn.bu.h"__lsx_vssrarn_bu_h"llvm.loongarch.lsx.vssrarn.hu.w"__lsx_vssrarn_hu_w"llvm.loongarch.lsx.vssrarn.wu.d"__lsx_vssrarn_wu_d"llvm.loongarch.lsx.vsrln.b.h"__lsx_vsrln_b_h"llvm.loongarch.lsx.vsrln.h.w"__lsx_vsrln_h_w"llvm.loongarch.lsx.vsrln.w.d"__lsx_vsrln_w_d"llvm.loongarch.lsx.vssrln.bu.h"__lsx_vssrln_bu_h"llvm.loongarch.lsx.vssrln.hu.w"__lsx_vssrln_hu_w"llvm.loongarch.lsx.vssrln.wu.d"__lsx_vssrln_wu_d"llvm.loongarch.lsx.vsrlrn.b.h"__lsx_vsrlrn_b_h"llvm.loongarch.lsx.vsrlrn.h.w"__lsx_vsrlrn_h_w"llvm.loongarch.lsx.vsrlrn.w.d"__lsx_vsrlrn_w_d"llvm.loongarch.lsx.vssrlrn.bu.h"__lsx_vssrlrn_bu_h"llvm.loongarch.lsx.vssrlrn.hu.w"__lsx_vssrlrn_hu_w"llvm.loongarch.lsx.vssrlrn.wu.d"__lsx_vssrlrn_wu_d"llvm.loongarch.lsx.vfrstpi.b"__lsx_vfrstpi_b"llvm.loongarch.lsx.vfrstpi.h"__lsx_vfrstpi_h"llvm.loongarch.lsx.vfrstp.b"__lsx_vfrstp_b"llvm.loongarch.lsx.vfrstp.h"__lsx_vfrstp_h"llvm.loongarch.lsx.vshuf4i.d"__lsx_vshuf4i_d"llvm.loongarch.lsx.vbsrl.v"__lsx_vbsrl_v"llvm.loongarch.lsx.vbsll.v"__lsx_vbsll_v"llvm.loongarch.lsx.vextrins.b"__lsx_vextrins_b"llvm.loongarch.lsx.vextrins.h"__lsx_vextrins_h"llvm.loongarch.lsx.vextrins.w"__lsx_vextrins_w"llvm.loongarch.lsx.vextrins.d"__lsx_vextrins_d"llvm.loongarch.lsx.vmskltz.b"__lsx_vmskltz_b"llvm.loongarch.lsx.vmskltz.h"__lsx_vmskltz_h"llvm.loongarch.lsx.vmskltz.w"__lsx_vmskltz_w"llvm.loongarch.lsx.vmskltz.d"__lsx_vmskltz_d"llvm.loongarch.lsx.vsigncov.b"__lsx_vsigncov_b"llvm.loongarch.lsx.vsigncov.h"__lsx_vsigncov_h"llvm.loongarch.lsx.vsigncov.w"__lsx_vsigncov_w"llvm.loongarch.lsx.vsigncov.d"__lsx_vsigncov_d"llvm.loongarch.lsx.vfmadd.s"__lsx_vfmadd_s"llvm.loongarch.lsx.vfmadd.d"__lsx_vfmadd_d"llvm.loongarch.lsx.vfmsub.s"__lsx_vfmsub_s"llvm.loongarch.lsx.vfmsub.d"__lsx_vfmsub_d"llvm.loongarch.lsx.vfnmadd.s"__lsx_vfnmadd_s"llvm.loongarch.lsx.vfnmadd.d"__lsx_vfnmadd_d"llvm.loongarch.lsx.vfnmsub.s"__lsx_vfnmsub_s"llvm.loongarch.lsx.vfnmsub.d"__lsx_vfnmsub_d"llvm.loongarch.lsx.vftintrne.w.s"__lsx_vftintrne_w_s"llvm.loongarch.lsx.vftintrne.l.d"__lsx_vftintrne_l_d"llvm.loongarch.lsx.vftintrp.w.s"__lsx_vftintrp_w_s"llvm.loongarch.lsx.vftintrp.l.d"__lsx_vftintrp_l_d"llvm.loongarch.lsx.vftintrm.w.s"__lsx_vftintrm_w_s"llvm.loongarch.lsx.vftintrm.l.d"__lsx_vftintrm_l_d"llvm.loongarch.lsx.vftint.w.d"__lsx_vftint_w_d"llvm.loongarch.lsx.vffint.s.l"__lsx_vffint_s_l"llvm.loongarch.lsx.vftintrz.w.d"__lsx_vftintrz_w_d"llvm.loongarch.lsx.vftintrp.w.d"__lsx_vftintrp_w_d"llvm.loongarch.lsx.vftintrm.w.d"__lsx_vftintrm_w_d"llvm.loongarch.lsx.vftintrne.w.d"__lsx_vftintrne_w_d"llvm.loongarch.lsx.vftintl.l.s"__lsx_vftintl_l_s"llvm.loongarch.lsx.vftinth.l.s"__lsx_vftinth_l_s"llvm.loongarch.lsx.vffinth.d.w"__lsx_vffinth_d_w"llvm.loongarch.lsx.vffintl.d.w"__lsx_vffintl_d_w"llvm.loongarch.lsx.vftintrzl.l.s"__lsx_vftintrzl_l_s"llvm.loongarch.lsx.vftintrzh.l.s"__lsx_vftintrzh_l_s"llvm.loongarch.lsx.vftintrpl.l.s"__lsx_vftintrpl_l_s"llvm.loongarch.lsx.vftintrph.l.s"__lsx_vftintrph_l_s"llvm.loongarch.lsx.vftintrml.l.s"__lsx_vftintrml_l_s"llvm.loongarch.lsx.vftintrmh.l.s"__lsx_vftintrmh_l_s"llvm.loongarch.lsx.vftintrnel.l.s"__lsx_vftintrnel_l_s"llvm.loongarch.lsx.vftintrneh.l.s"__lsx_vftintrneh_l_s"llvm.loongarch.lsx.vfrintrne.s"__lsx_vfrintrne_s"llvm.loongarch.lsx.vfrintrne.d"__lsx_vfrintrne_d"llvm.loongarch.lsx.vfrintrz.s"__lsx_vfrintrz_s"llvm.loongarch.lsx.vfrintrz.d"__lsx_vfrintrz_d"llvm.loongarch.lsx.vfrintrp.s"__lsx_vfrintrp_s"llvm.loongarch.lsx.vfrintrp.d"__lsx_vfrintrp_d"llvm.loongarch.lsx.vfrintrm.s"__lsx_vfrintrm_s"llvm.loongarch.lsx.vfrintrm.d"__lsx_vfrintrm_d"llvm.loongarch.lsx.vstelm.b"__lsx_vstelm_b"llvm.loongarch.lsx.vstelm.h"__lsx_vstelm_h"llvm.loongarch.lsx.vstelm.w"__lsx_vstelm_w"llvm.loongarch.lsx.vstelm.d"__lsx_vstelm_d"llvm.loongarch.lsx.vaddwev.d.w"__lsx_vaddwev_d_w"llvm.loongarch.lsx.vaddwev.w.h"__lsx_vaddwev_w_h"llvm.loongarch.lsx.vaddwev.h.b"__lsx_vaddwev_h_b"llvm.loongarch.lsx.vaddwod.d.w"__lsx_vaddwod_d_w"llvm.loongarch.lsx.vaddwod.w.h"__lsx_vaddwod_w_h"llvm.loongarch.lsx.vaddwod.h.b"__lsx_vaddwod_h_b"llvm.loongarch.lsx.vaddwev.d.wu"__lsx_vaddwev_d_wu"llvm.loongarch.lsx.vaddwev.w.hu"__lsx_vaddwev_w_hu"llvm.loongarch.lsx.vaddwev.h.bu"__lsx_vaddwev_h_bu"llvm.loongarch.lsx.vaddwod.d.wu"__lsx_vaddwod_d_wu"llvm.loongarch.lsx.vaddwod.w.hu"__lsx_vaddwod_w_hu"llvm.loongarch.lsx.vaddwod.h.bu"__lsx_vaddwod_h_bu"llvm.loongarch.lsx.vaddwev.d.wu.w"__lsx_vaddwev_d_wu_w"llvm.loongarch.lsx.vaddwev.w.hu.h"__lsx_vaddwev_w_hu_h"llvm.loongarch.lsx.vaddwev.h.bu.b"__lsx_vaddwev_h_bu_b"llvm.loongarch.lsx.vaddwod.d.wu.w"__lsx_vaddwod_d_wu_w"llvm.loongarch.lsx.vaddwod.w.hu.h"__lsx_vaddwod_w_hu_h"llvm.loongarch.lsx.vaddwod.h.bu.b"__lsx_vaddwod_h_bu_b"llvm.loongarch.lsx.vsubwev.d.w"__lsx_vsubwev_d_w"llvm.loongarch.lsx.vsubwev.w.h"__lsx_vsubwev_w_h"llvm.loongarch.lsx.vsubwev.h.b"__lsx_vsubwev_h_b"llvm.loongarch.lsx.vsubwod.d.w"__lsx_vsubwod_d_w"llvm.loongarch.lsx.vsubwod.w.h"__lsx_vsubwod_w_h"llvm.loongarch.lsx.vsubwod.h.b"__lsx_vsubwod_h_b"llvm.loongarch.lsx.vsubwev.d.wu"__lsx_vsubwev_d_wu"llvm.loongarch.lsx.vsubwev.w.hu"__lsx_vsubwev_w_hu"llvm.loongarch.lsx.vsubwev.h.bu"__lsx_vsubwev_h_bu"llvm.loongarch.lsx.vsubwod.d.wu"__lsx_vsubwod_d_wu"llvm.loongarch.lsx.vsubwod.w.hu"__lsx_vsubwod_w_hu"llvm.loongarch.lsx.vsubwod.h.bu"__lsx_vsubwod_h_bu"llvm.loongarch.lsx.vaddwev.q.d"__lsx_vaddwev_q_d"llvm.loongarch.lsx.vaddwod.q.d"__lsx_vaddwod_q_d"llvm.loongarch.lsx.vaddwev.q.du"__lsx_vaddwev_q_du"llvm.loongarch.lsx.vaddwod.q.du"__lsx_vaddwod_q_du"llvm.loongarch.lsx.vsubwev.q.d"__lsx_vsubwev_q_d"llvm.loongarch.lsx.vsubwod.q.d"__lsx_vsubwod_q_d"llvm.loongarch.lsx.vsubwev.q.du"__lsx_vsubwev_q_du"llvm.loongarch.lsx.vsubwod.q.du"__lsx_vsubwod_q_du"llvm.loongarch.lsx.vaddwev.q.du.d"__lsx_vaddwev_q_du_d"llvm.loongarch.lsx.vaddwod.q.du.d"__lsx_vaddwod_q_du_d"llvm.loongarch.lsx.vmulwev.d.w"__lsx_vmulwev_d_w"llvm.loongarch.lsx.vmulwev.w.h"__lsx_vmulwev_w_h"llvm.loongarch.lsx.vmulwev.h.b"__lsx_vmulwev_h_b"llvm.loongarch.lsx.vmulwod.d.w"__lsx_vmulwod_d_w"llvm.loongarch.lsx.vmulwod.w.h"__lsx_vmulwod_w_h"llvm.loongarch.lsx.vmulwod.h.b"__lsx_vmulwod_h_b"llvm.loongarch.lsx.vmulwev.d.wu"__lsx_vmulwev_d_wu"llvm.loongarch.lsx.vmulwev.w.hu"__lsx_vmulwev_w_hu"llvm.loongarch.lsx.vmulwev.h.bu"__lsx_vmulwev_h_bu"llvm.loongarch.lsx.vmulwod.d.wu"__lsx_vmulwod_d_wu"llvm.loongarch.lsx.vmulwod.w.hu"__lsx_vmulwod_w_hu"llvm.loongarch.lsx.vmulwod.h.bu"__lsx_vmulwod_h_bu"llvm.loongarch.lsx.vmulwev.d.wu.w"__lsx_vmulwev_d_wu_w"llvm.loongarch.lsx.vmulwev.w.hu.h"__lsx_vmulwev_w_hu_h"llvm.loongarch.lsx.vmulwev.h.bu.b"__lsx_vmulwev_h_bu_b"llvm.loongarch.lsx.vmulwod.d.wu.w"__lsx_vmulwod_d_wu_w"llvm.loongarch.lsx.vmulwod.w.hu.h"__lsx_vmulwod_w_hu_h"llvm.loongarch.lsx.vmulwod.h.bu.b"__lsx_vmulwod_h_bu_b"llvm.loongarch.lsx.vmulwev.q.d"__lsx_vmulwev_q_d"llvm.loongarch.lsx.vmulwod.q.d"__lsx_vmulwod_q_d"llvm.loongarch.lsx.vmulwev.q.du"__lsx_vmulwev_q_du"llvm.loongarch.lsx.vmulwod.q.du"__lsx_vmulwod_q_du"llvm.loongarch.lsx.vmulwev.q.du.d"__lsx_vmulwev_q_du_d"llvm.loongarch.lsx.vmulwod.q.du.d"__lsx_vmulwod_q_du_d"llvm.loongarch.lsx.vhaddw.q.d"__lsx_vhaddw_q_d"llvm.loongarch.lsx.vhaddw.qu.du"__lsx_vhaddw_qu_du"llvm.loongarch.lsx.vhsubw.q.d"__lsx_vhsubw_q_d"llvm.loongarch.lsx.vhsubw.qu.du"__lsx_vhsubw_qu_du"llvm.loongarch.lsx.vmaddwev.d.w"__lsx_vmaddwev_d_w"llvm.loongarch.lsx.vmaddwev.w.h"__lsx_vmaddwev_w_h"llvm.loongarch.lsx.vmaddwev.h.b"__lsx_vmaddwev_h_b"llvm.loongarch.lsx.vmaddwev.d.wu"__lsx_vmaddwev_d_wu"llvm.loongarch.lsx.vmaddwev.w.hu"__lsx_vmaddwev_w_hu"llvm.loongarch.lsx.vmaddwev.h.bu"__lsx_vmaddwev_h_bu"llvm.loongarch.lsx.vmaddwod.d.w"__lsx_vmaddwod_d_w"llvm.loongarch.lsx.vmaddwod.w.h"__lsx_vmaddwod_w_h"llvm.loongarch.lsx.vmaddwod.h.b"__lsx_vmaddwod_h_b"llvm.loongarch.lsx.vmaddwod.d.wu"__lsx_vmaddwod_d_wu"llvm.loongarch.lsx.vmaddwod.w.hu"__lsx_vmaddwod_w_hu"llvm.loongarch.lsx.vmaddwod.h.bu"__lsx_vmaddwod_h_bu"llvm.loongarch.lsx.vmaddwev.d.wu.w"__lsx_vmaddwev_d_wu_w"llvm.loongarch.lsx.vmaddwev.w.hu.h"__lsx_vmaddwev_w_hu_h"llvm.loongarch.lsx.vmaddwev.h.bu.b"__lsx_vmaddwev_h_bu_b"llvm.loongarch.lsx.vmaddwod.d.wu.w"__lsx_vmaddwod_d_wu_w"llvm.loongarch.lsx.vmaddwod.w.hu.h"__lsx_vmaddwod_w_hu_h"llvm.loongarch.lsx.vmaddwod.h.bu.b"__lsx_vmaddwod_h_bu_b"llvm.loongarch.lsx.vmaddwev.q.d"__lsx_vmaddwev_q_d"llvm.loongarch.lsx.vmaddwod.q.d"__lsx_vmaddwod_q_d"llvm.loongarch.lsx.vmaddwev.q.du"__lsx_vmaddwev_q_du"llvm.loongarch.lsx.vmaddwod.q.du"__lsx_vmaddwod_q_du"llvm.loongarch.lsx.vmaddwev.q.du.d"__lsx_vmaddwev_q_du_d"llvm.loongarch.lsx.vmaddwod.q.du.d"__lsx_vmaddwod_q_du_d"llvm.loongarch.lsx.vrotr.b"__lsx_vrotr_b"llvm.loongarch.lsx.vrotr.h"__lsx_vrotr_h"llvm.loongarch.lsx.vrotr.w"__lsx_vrotr_w"llvm.loongarch.lsx.vrotr.d"__lsx_vrotr_d"llvm.loongarch.lsx.vadd.q"__lsx_vadd_q"llvm.loongarch.lsx.vsub.q"__lsx_vsub_q"llvm.loongarch.lsx.vldrepl.b"__lsx_vldrepl_b"llvm.loongarch.lsx.vldrepl.h"__lsx_vldrepl_h"llvm.loongarch.lsx.vldrepl.w"__lsx_vldrepl_w"llvm.loongarch.lsx.vldrepl.d"__lsx_vldrepl_d"llvm.loongarch.lsx.vmskgez.b"__lsx_vmskgez_b"llvm.loongarch.lsx.vmsknz.b"__lsx_vmsknz_b"llvm.loongarch.lsx.vexth.h.b"__lsx_vexth_h_b"llvm.loongarch.lsx.vexth.w.h"__lsx_vexth_w_h"llvm.loongarch.lsx.vexth.d.w"__lsx_vexth_d_w"llvm.loongarch.lsx.vexth.q.d"__lsx_vexth_q_d"llvm.loongarch.lsx.vexth.hu.bu"__lsx_vexth_hu_bu"llvm.loongarch.lsx.vexth.wu.hu"__lsx_vexth_wu_hu"llvm.loongarch.lsx.vexth.du.wu"__lsx_vexth_du_wu"llvm.loongarch.lsx.vexth.qu.du"__lsx_vexth_qu_du"llvm.loongarch.lsx.vrotri.b"__lsx_vrotri_b"llvm.loongarch.lsx.vrotri.h"__lsx_vrotri_h"llvm.loongarch.lsx.vrotri.w"__lsx_vrotri_w"llvm.loongarch.lsx.vrotri.d"__lsx_vrotri_d"llvm.loongarch.lsx.vextl.q.d"__lsx_vextl_q_d"llvm.loongarch.lsx.vsrlni.b.h"__lsx_vsrlni_b_h"llvm.loongarch.lsx.vsrlni.h.w"__lsx_vsrlni_h_w"llvm.loongarch.lsx.vsrlni.w.d"__lsx_vsrlni_w_d"llvm.loongarch.lsx.vsrlni.d.q"__lsx_vsrlni_d_q"llvm.loongarch.lsx.vsrlrni.b.h"__lsx_vsrlrni_b_h"llvm.loongarch.lsx.vsrlrni.h.w"__lsx_vsrlrni_h_w"llvm.loongarch.lsx.vsrlrni.w.d"__lsx_vsrlrni_w_d"llvm.loongarch.lsx.vsrlrni.d.q"__lsx_vsrlrni_d_q"llvm.loongarch.lsx.vssrlni.b.h"__lsx_vssrlni_b_h"llvm.loongarch.lsx.vssrlni.h.w"__lsx_vssrlni_h_w"llvm.loongarch.lsx.vssrlni.w.d"__lsx_vssrlni_w_d"llvm.loongarch.lsx.vssrlni.d.q"__lsx_vssrlni_d_q"llvm.loongarch.lsx.vssrlni.bu.h"__lsx_vssrlni_bu_h"llvm.loongarch.lsx.vssrlni.hu.w"__lsx_vssrlni_hu_w"llvm.loongarch.lsx.vssrlni.wu.d"__lsx_vssrlni_wu_d"llvm.loongarch.lsx.vssrlni.du.q"__lsx_vssrlni_du_q"llvm.loongarch.lsx.vssrlrni.b.h"__lsx_vssrlrni_b_h"llvm.loongarch.lsx.vssrlrni.h.w"__lsx_vssrlrni_h_w"llvm.loongarch.lsx.vssrlrni.w.d"__lsx_vssrlrni_w_d"llvm.loongarch.lsx.vssrlrni.d.q"__lsx_vssrlrni_d_q"llvm.loongarch.lsx.vssrlrni.bu.h"__lsx_vssrlrni_bu_h"llvm.loongarch.lsx.vssrlrni.hu.w"__lsx_vssrlrni_hu_w"llvm.loongarch.lsx.vssrlrni.wu.d"__lsx_vssrlrni_wu_d"llvm.loongarch.lsx.vssrlrni.du.q"__lsx_vssrlrni_du_q"llvm.loongarch.lsx.vsrani.b.h"__lsx_vsrani_b_h"llvm.loongarch.lsx.vsrani.h.w"__lsx_vsrani_h_w"llvm.loongarch.lsx.vsrani.w.d"__lsx_vsrani_w_d"llvm.loongarch.lsx.vsrani.d.q"__lsx_vsrani_d_q"llvm.loongarch.lsx.vsrarni.b.h"__lsx_vsrarni_b_h"llvm.loongarch.lsx.vsrarni.h.w"__lsx_vsrarni_h_w"llvm.loongarch.lsx.vsrarni.w.d"__lsx_vsrarni_w_d"llvm.loongarch.lsx.vsrarni.d.q"__lsx_vsrarni_d_q"llvm.loongarch.lsx.vssrani.b.h"__lsx_vssrani_b_h"llvm.loongarch.lsx.vssrani.h.w"__lsx_vssrani_h_w"llvm.loongarch.lsx.vssrani.w.d"__lsx_vssrani_w_d"llvm.loongarch.lsx.vssrani.d.q"__lsx_vssrani_d_q"llvm.loongarch.lsx.vssrani.bu.h"__lsx_vssrani_bu_h"llvm.loongarch.lsx.vssrani.hu.w"__lsx_vssrani_hu_w"llvm.loongarch.lsx.vssrani.wu.d"__lsx_vssrani_wu_d"llvm.loongarch.lsx.vssrani.du.q"__lsx_vssrani_du_q"llvm.loongarch.lsx.vssrarni.b.h"__lsx_vssrarni_b_h"llvm.loongarch.lsx.vssrarni.h.w"__lsx_vssrarni_h_w"llvm.loongarch.lsx.vssrarni.w.d"__lsx_vssrarni_w_d"llvm.loongarch.lsx.vssrarni.d.q"__lsx_vssrarni_d_q"llvm.loongarch.lsx.vssrarni.bu.h"__lsx_vssrarni_bu_h"llvm.loongarch.lsx.vssrarni.hu.w"__lsx_vssrarni_hu_w"llvm.loongarch.lsx.vssrarni.wu.d"__lsx_vssrarni_wu_d"llvm.loongarch.lsx.vssrarni.du.q"__lsx_vssrarni_du_q"llvm.loongarch.lsx.vpermi.w"__lsx_vpermi_w"llvm.loongarch.lsx.vld"__lsx_vld"llvm.loongarch.lsx.vst"__lsx_vst"llvm.loongarch.lsx.vssrlrn.b.h"__lsx_vssrlrn_b_h"llvm.loongarch.lsx.vssrlrn.h.w"__lsx_vssrlrn_h_w"llvm.loongarch.lsx.vssrlrn.w.d"__lsx_vssrlrn_w_d"llvm.loongarch.lsx.vssrln.b.h"__lsx_vssrln_b_h"llvm.loongarch.lsx.vssrln.h.w"__lsx_vssrln_h_w"llvm.loongarch.lsx.vssrln.w.d"__lsx_vssrln_w_d"llvm.loongarch.lsx.vorn.v"__lsx_vorn_v"llvm.loongarch.lsx.vldi"__lsx_vldi"llvm.loongarch.lsx.vshuf.b"__lsx_vshuf_b"llvm.loongarch.lsx.vldx"__lsx_vldx"llvm.loongarch.lsx.vstx"__lsx_vstx"llvm.loongarch.lsx.vextl.qu.du"__lsx_vextl_qu_du"llvm.loongarch.lsx.bnz.b"__lsx_bnz_b"llvm.loongarch.lsx.bnz.d"__lsx_bnz_d"llvm.loongarch.lsx.bnz.h"__lsx_bnz_h"llvm.loongarch.lsx.bnz.v"__lsx_bnz_v"llvm.loongarch.lsx.bnz.w"__lsx_bnz_w"llvm.loongarch.lsx.bz.b"__lsx_bz_b"llvm.loongarch.lsx.bz.d"__lsx_bz_d"llvm.loongarch.lsx.bz.h"__lsx_bz_h"llvm.loongarch.lsx.bz.v"__lsx_bz_v"llvm.loongarch.lsx.bz.w"__lsx_bz_w"llvm.loongarch.lsx.vfcmp.caf.d"__lsx_vfcmp_caf_d"llvm.loongarch.lsx.vfcmp.caf.s"__lsx_vfcmp_caf_s"llvm.loongarch.lsx.vfcmp.ceq.d"__lsx_vfcmp_ceq_d"llvm.loongarch.lsx.vfcmp.ceq.s"__lsx_vfcmp_ceq_s"llvm.loongarch.lsx.vfcmp.cle.d"__lsx_vfcmp_cle_d"llvm.loongarch.lsx.vfcmp.cle.s"__lsx_vfcmp_cle_s"llvm.loongarch.lsx.vfcmp.clt.d"__lsx_vfcmp_clt_d"llvm.loongarch.lsx.vfcmp.clt.s"__lsx_vfcmp_clt_s"llvm.loongarch.lsx.vfcmp.cne.d"__lsx_vfcmp_cne_d"llvm.loongarch.lsx.vfcmp.cne.s"__lsx_vfcmp_cne_s"llvm.loongarch.lsx.vfcmp.cor.d"__lsx_vfcmp_cor_d"llvm.loongarch.lsx.vfcmp.cor.s"__lsx_vfcmp_cor_s"llvm.loongarch.lsx.vfcmp.cueq.d"__lsx_vfcmp_cueq_d"llvm.loongarch.lsx.vfcmp.cueq.s"__lsx_vfcmp_cueq_s"llvm.loongarch.lsx.vfcmp.cule.d"__lsx_vfcmp_cule_d"llvm.loongarch.lsx.vfcmp.cule.s"__lsx_vfcmp_cule_s"llvm.loongarch.lsx.vfcmp.cult.d"__lsx_vfcmp_cult_d"llvm.loongarch.lsx.vfcmp.cult.s"__lsx_vfcmp_cult_s"llvm.loongarch.lsx.vfcmp.cun.d"__lsx_vfcmp_cun_d"llvm.loongarch.lsx.vfcmp.cune.d"__lsx_vfcmp_cune_d"llvm.loongarch.lsx.vfcmp.cune.s"__lsx_vfcmp_cune_s"llvm.loongarch.lsx.vfcmp.cun.s"__lsx_vfcmp_cun_s"llvm.loongarch.lsx.vfcmp.saf.d"__lsx_vfcmp_saf_d"llvm.loongarch.lsx.vfcmp.saf.s"__lsx_vfcmp_saf_s"llvm.loongarch.lsx.vfcmp.seq.d"__lsx_vfcmp_seq_d"llvm.loongarch.lsx.vfcmp.seq.s"__lsx_vfcmp_seq_s"llvm.loongarch.lsx.vfcmp.sle.d"__lsx_vfcmp_sle_d"llvm.loongarch.lsx.vfcmp.sle.s"__lsx_vfcmp_sle_s"llvm.loongarch.lsx.vfcmp.slt.d"__lsx_vfcmp_slt_d"llvm.loongarch.lsx.vfcmp.slt.s"__lsx_vfcmp_slt_s"llvm.loongarch.lsx.vfcmp.sne.d"__lsx_vfcmp_sne_d"llvm.loongarch.lsx.vfcmp.sne.s"__lsx_vfcmp_sne_s"llvm.loongarch.lsx.vfcmp.sor.d"__lsx_vfcmp_sor_d"llvm.loongarch.lsx.vfcmp.sor.s"__lsx_vfcmp_sor_s"llvm.loongarch.lsx.vfcmp.sueq.d"__lsx_vfcmp_sueq_d"llvm.loongarch.lsx.vfcmp.sueq.s"__lsx_vfcmp_sueq_s"llvm.loongarch.lsx.vfcmp.sule.d"__lsx_vfcmp_sule_d"llvm.loongarch.lsx.vfcmp.sule.s"__lsx_vfcmp_sule_s"llvm.loongarch.lsx.vfcmp.sult.d"__lsx_vfcmp_sult_d"llvm.loongarch.lsx.vfcmp.sult.s"__lsx_vfcmp_sult_s"llvm.loongarch.lsx.vfcmp.sun.d"__lsx_vfcmp_sun_d"llvm.loongarch.lsx.vfcmp.sune.d"__lsx_vfcmp_sune_d"llvm.loongarch.lsx.vfcmp.sune.s"__lsx_vfcmp_sune_s"llvm.loongarch.lsx.vfcmp.sun.s"__lsx_vfcmp_sun_s"llvm.loongarch.lsx.vrepli.b"__lsx_vrepli_b"llvm.loongarch.lsx.vrepli.d"__lsx_vrepli_d"llvm.loongarch.lsx.vrepli.h"__lsx_vrepli_h"llvm.loongarch.lsx.vrepli.w"__lsx_vrepli_wlsx_vsll_blsx_vsll_hlsx_vsll_wlsx_vsll_dlsx_vslli_blsx_vslli_hlsx_vslli_wlsx_vslli_dlsx_vsra_blsx_vsra_hlsx_vsra_wlsx_vsra_dlsx_vsrai_blsx_vsrai_hlsx_vsrai_wlsx_vsrai_dlsx_vsrar_blsx_vsrar_hlsx_vsrar_wlsx_vsrar_dlsx_vsrari_blsx_vsrari_hlsx_vsrari_wlsx_vsrari_dlsx_vsrl_blsx_vsrl_hlsx_vsrl_wlsx_vsrl_dlsx_vsrli_blsx_vsrli_hlsx_vsrli_wlsx_vsrli_dlsx_vsrlr_blsx_vsrlr_hlsx_vsrlr_wlsx_vsrlr_dlsx_vsrlri_blsx_vsrlri_hlsx_vsrlri_wlsx_vsrlri_dlsx_vbitclr_blsx_vbitclr_hlsx_vbitclr_wlsx_vbitclr_dlsx_vbitclri_blsx_vbitclri_hlsx_vbitclri_wlsx_vbitclri_dlsx_vbitset_blsx_vbitset_hlsx_vbitset_wlsx_vbitset_dlsx_vbitseti_blsx_vbitseti_hlsx_vbitseti_wlsx_vbitseti_dlsx_vbitrev_blsx_vbitrev_hlsx_vbitrev_wlsx_vbitrev_dlsx_vbitrevi_blsx_vbitrevi_hlsx_vbitrevi_wlsx_vbitrevi_dlsx_vadd_blsx_vadd_hlsx_vadd_wlsx_vadd_dlsx_vaddi_bulsx_vaddi_hulsx_vaddi_wulsx_vaddi_dulsx_vsub_blsx_vsub_hlsx_vsub_wlsx_vsub_dlsx_vsubi_bulsx_vsubi_hulsx_vsubi_wulsx_vsubi_dulsx_vmax_blsx_vmax_hlsx_vmax_wlsx_vmax_dlsx_vmaxi_blsx_vmaxi_hlsx_vmaxi_wlsx_vmaxi_dlsx_vmax_bulsx_vmax_hulsx_vmax_wulsx_vmax_dulsx_vmaxi_bulsx_vmaxi_hulsx_vmaxi_wulsx_vmaxi_dulsx_vmin_blsx_vmin_hlsx_vmin_wlsx_vmin_dlsx_vmini_blsx_vmini_hlsx_vmini_wlsx_vmini_dlsx_vmin_bulsx_vmin_hulsx_vmin_wulsx_vmin_dulsx_vmini_bulsx_vmini_hulsx_vmini_wulsx_vmini_dulsx_vseq_blsx_vseq_hlsx_vseq_wlsx_vseq_dlsx_vseqi_blsx_vseqi_hlsx_vseqi_wlsx_vseqi_dlsx_vslti_blsx_vslt_blsx_vslt_hlsx_vslt_wlsx_vslt_dlsx_vslti_hlsx_vslti_wlsx_vslti_dlsx_vslt_bulsx_vslt_hulsx_vslt_wulsx_vslt_dulsx_vslti_bulsx_vslti_hulsx_vslti_wulsx_vslti_dulsx_vsle_blsx_vsle_hlsx_vsle_wlsx_vsle_dlsx_vslei_blsx_vslei_hlsx_vslei_wlsx_vslei_dlsx_vsle_bulsx_vsle_hulsx_vsle_wulsx_vsle_dulsx_vslei_bulsx_vslei_hulsx_vslei_wulsx_vslei_dulsx_vsat_blsx_vsat_hlsx_vsat_wlsx_vsat_dlsx_vsat_bulsx_vsat_hulsx_vsat_wulsx_vsat_dulsx_vadda_blsx_vadda_hlsx_vadda_wlsx_vadda_dlsx_vsadd_blsx_vsadd_hlsx_vsadd_wlsx_vsadd_dlsx_vsadd_bulsx_vsadd_hulsx_vsadd_wulsx_vsadd_dulsx_vavg_blsx_vavg_hlsx_vavg_wlsx_vavg_dlsx_vavg_bulsx_vavg_hulsx_vavg_wulsx_vavg_dulsx_vavgr_blsx_vavgr_hlsx_vavgr_wlsx_vavgr_dlsx_vavgr_bulsx_vavgr_hulsx_vavgr_wulsx_vavgr_dulsx_vssub_blsx_vssub_hlsx_vssub_wlsx_vssub_dlsx_vssub_bulsx_vssub_hulsx_vssub_wulsx_vssub_dulsx_vabsd_blsx_vabsd_hlsx_vabsd_wlsx_vabsd_dlsx_vabsd_bulsx_vabsd_hulsx_vabsd_wulsx_vabsd_dulsx_vmul_blsx_vmul_hlsx_vmul_wlsx_vmul_dlsx_vmadd_blsx_vmadd_hlsx_vmadd_wlsx_vmadd_dlsx_vmsub_blsx_vmsub_hlsx_vmsub_wlsx_vmsub_dlsx_vdiv_blsx_vdiv_hlsx_vdiv_wlsx_vdiv_dlsx_vdiv_bulsx_vdiv_hulsx_vdiv_wulsx_vdiv_dulsx_vhaddw_h_blsx_vhaddw_w_hlsx_vhaddw_d_wlsx_vhaddw_hu_bulsx_vhaddw_wu_hulsx_vhaddw_du_wulsx_vhsubw_h_blsx_vhsubw_w_hlsx_vhsubw_d_wlsx_vhsubw_hu_bulsx_vhsubw_wu_hulsx_vhsubw_du_wulsx_vmod_blsx_vmod_hlsx_vmod_wlsx_vmod_dlsx_vmod_bulsx_vmod_hulsx_vmod_wulsx_vmod_dulsx_vreplve_blsx_vreplve_hlsx_vreplve_wlsx_vreplve_dlsx_vreplvei_blsx_vreplvei_hlsx_vreplvei_wlsx_vreplvei_dlsx_vpickev_blsx_vpickev_hlsx_vpickev_wlsx_vpickev_dlsx_vpickod_blsx_vpickod_hlsx_vpickod_wlsx_vpickod_dlsx_vilvh_blsx_vilvh_hlsx_vilvh_wlsx_vilvh_dlsx_vilvl_blsx_vilvl_hlsx_vilvl_wlsx_vilvl_dlsx_vpackev_blsx_vpackev_hlsx_vpackev_wlsx_vpackev_dlsx_vpackod_blsx_vpackod_hlsx_vpackod_wlsx_vpackod_dlsx_vshuf_hlsx_vshuf_wlsx_vshuf_dlsx_vand_vlsx_vandi_blsx_vor_vlsx_vori_blsx_vnor_vlsx_vnori_blsx_vxor_vlsx_vxori_blsx_vbitsel_vlsx_vbitseli_blsx_vshuf4i_blsx_vshuf4i_hlsx_vshuf4i_wlsx_vreplgr2vr_blsx_vreplgr2vr_hlsx_vreplgr2vr_wlsx_vreplgr2vr_dlsx_vpcnt_blsx_vpcnt_hlsx_vpcnt_wlsx_vpcnt_dlsx_vclo_blsx_vclo_hlsx_vclo_wlsx_vclo_dlsx_vclz_blsx_vclz_hlsx_vclz_wlsx_vclz_dlsx_vpickve2gr_blsx_vpickve2gr_hlsx_vpickve2gr_wlsx_vpickve2gr_dlsx_vpickve2gr_bulsx_vpickve2gr_hulsx_vpickve2gr_wulsx_vpickve2gr_dulsx_vinsgr2vr_blsx_vinsgr2vr_hlsx_vinsgr2vr_wlsx_vinsgr2vr_dlsx_vfadd_sm128lsx_vfadd_dm128dlsx_vfsub_slsx_vfsub_dlsx_vfmul_slsx_vfmul_dlsx_vfdiv_slsx_vfdiv_dlsx_vfcvt_h_slsx_vfcvt_s_dlsx_vfmin_slsx_vfmin_dlsx_vfmina_slsx_vfmina_dlsx_vfmax_slsx_vfmax_dlsx_vfmaxa_slsx_vfmaxa_dlsx_vfclass_slsx_vfclass_dlsx_vfsqrt_slsx_vfsqrt_dlsx_vfrecip_slsx_vfrecip_dlsx_vfrecipe_slsx_vfrecipe_dlsx_vfrsqrte_slsx_vfrsqrte_dlsx_vfrint_slsx_vfrint_dlsx_vfrsqrt_slsx_vfrsqrt_dlsx_vflogb_slsx_vflogb_dlsx_vfcvth_s_hlsx_vfcvth_d_slsx_vfcvtl_s_hlsx_vfcvtl_d_slsx_vftint_w_slsx_vftint_l_dlsx_vftint_wu_slsx_vftint_lu_dlsx_vftintrz_w_slsx_vftintrz_l_dlsx_vftintrz_wu_slsx_vftintrz_lu_dlsx_vffint_s_wlsx_vffint_d_llsx_vffint_s_wulsx_vffint_d_lulsx_vandn_vlsx_vneg_blsx_vneg_hlsx_vneg_wlsx_vneg_dlsx_vmuh_blsx_vmuh_hlsx_vmuh_wlsx_vmuh_dlsx_vmuh_bulsx_vmuh_hulsx_vmuh_wulsx_vmuh_dulsx_vsllwil_h_blsx_vsllwil_w_hlsx_vsllwil_d_wlsx_vsllwil_hu_bulsx_vsllwil_wu_hulsx_vsllwil_du_wulsx_vsran_b_hlsx_vsran_h_wlsx_vsran_w_dlsx_vssran_b_hlsx_vssran_h_wlsx_vssran_w_dlsx_vssran_bu_hlsx_vssran_hu_wlsx_vssran_wu_dlsx_vsrarn_b_hlsx_vsrarn_h_wlsx_vsrarn_w_dlsx_vssrarn_b_hlsx_vssrarn_h_wlsx_vssrarn_w_dlsx_vssrarn_bu_hlsx_vssrarn_hu_wlsx_vssrarn_wu_dlsx_vsrln_b_hlsx_vsrln_h_wlsx_vsrln_w_dlsx_vssrln_bu_hlsx_vssrln_hu_wlsx_vssrln_wu_dlsx_vsrlrn_b_hlsx_vsrlrn_h_wlsx_vsrlrn_w_dlsx_vssrlrn_bu_hlsx_vssrlrn_hu_wlsx_vssrlrn_wu_dlsx_vfrstpi_blsx_vfrstpi_hlsx_vfrstp_blsx_vfrstp_hlsx_vshuf4i_dlsx_vbsrl_vlsx_vbsll_vlsx_vextrins_blsx_vextrins_hlsx_vextrins_wlsx_vextrins_dlsx_vmskltz_blsx_vmskltz_hlsx_vmskltz_wlsx_vmskltz_dlsx_vsigncov_blsx_vsigncov_hlsx_vsigncov_wlsx_vsigncov_dlsx_vfmadd_slsx_vfmadd_dlsx_vfmsub_slsx_vfmsub_dlsx_vfnmadd_slsx_vfnmadd_dlsx_vfnmsub_slsx_vfnmsub_dlsx_vftintrne_w_slsx_vftintrne_l_dlsx_vftintrp_w_slsx_vftintrp_l_dlsx_vftintrm_w_slsx_vftintrm_l_dlsx_vftint_w_dlsx_vffint_s_llsx_vftintrz_w_dlsx_vftintrp_w_dlsx_vftintrm_w_dlsx_vftintrne_w_dlsx_vftintl_l_slsx_vftinth_l_slsx_vffinth_d_wlsx_vffintl_d_wlsx_vftintrzl_l_slsx_vftintrzh_l_slsx_vftintrpl_l_slsx_vftintrph_l_slsx_vftintrml_l_slsx_vftintrmh_l_slsx_vftintrnel_l_slsx_vftintrneh_l_slsx_vfrintrne_slsx_vfrintrne_dlsx_vfrintrz_slsx_vfrintrz_dlsx_vfrintrp_slsx_vfrintrp_dlsx_vfrintrm_slsx_vfrintrm_dlsx_vstelm_blsx_vstelm_hlsx_vstelm_wlsx_vstelm_dlsx_vaddwev_d_wlsx_vaddwev_w_hlsx_vaddwev_h_blsx_vaddwod_d_wlsx_vaddwod_w_hlsx_vaddwod_h_blsx_vaddwev_d_wulsx_vaddwev_w_hulsx_vaddwev_h_bulsx_vaddwod_d_wulsx_vaddwod_w_hulsx_vaddwod_h_bulsx_vaddwev_d_wu_wlsx_vaddwev_w_hu_hlsx_vaddwev_h_bu_blsx_vaddwod_d_wu_wlsx_vaddwod_w_hu_hlsx_vaddwod_h_bu_blsx_vsubwev_d_wlsx_vsubwev_w_hlsx_vsubwev_h_blsx_vsubwod_d_wlsx_vsubwod_w_hlsx_vsubwod_h_blsx_vsubwev_d_wulsx_vsubwev_w_hulsx_vsubwev_h_bulsx_vsubwod_d_wulsx_vsubwod_w_hulsx_vsubwod_h_bulsx_vaddwev_q_dlsx_vaddwod_q_dlsx_vaddwev_q_dulsx_vaddwod_q_dulsx_vsubwev_q_dlsx_vsubwod_q_dlsx_vsubwev_q_dulsx_vsubwod_q_dulsx_vaddwev_q_du_dlsx_vaddwod_q_du_dlsx_vmulwev_d_wlsx_vmulwev_w_hlsx_vmulwev_h_blsx_vmulwod_d_wlsx_vmulwod_w_hlsx_vmulwod_h_blsx_vmulwev_d_wulsx_vmulwev_w_hulsx_vmulwev_h_bulsx_vmulwod_d_wulsx_vmulwod_w_hulsx_vmulwod_h_bulsx_vmulwev_d_wu_wlsx_vmulwev_w_hu_hlsx_vmulwev_h_bu_blsx_vmulwod_d_wu_wlsx_vmulwod_w_hu_hlsx_vmulwod_h_bu_blsx_vmulwev_q_dlsx_vmulwod_q_dlsx_vmulwev_q_dulsx_vmulwod_q_dulsx_vmulwev_q_du_dlsx_vmulwod_q_du_dlsx_vhaddw_q_dlsx_vhaddw_qu_dulsx_vhsubw_q_dlsx_vhsubw_qu_dulsx_vmaddwev_d_wlsx_vmaddwev_w_hlsx_vmaddwev_h_blsx_vmaddwev_d_wulsx_vmaddwev_w_hulsx_vmaddwev_h_bulsx_vmaddwod_d_wlsx_vmaddwod_w_hlsx_vmaddwod_h_blsx_vmaddwod_d_wulsx_vmaddwod_w_hulsx_vmaddwod_h_bulsx_vmaddwev_d_wu_wlsx_vmaddwev_w_hu_hlsx_vmaddwev_h_bu_blsx_vmaddwod_d_wu_wlsx_vmaddwod_w_hu_hlsx_vmaddwod_h_bu_blsx_vmaddwev_q_dlsx_vmaddwod_q_dlsx_vmaddwev_q_dulsx_vmaddwod_q_dulsx_vmaddwev_q_du_dlsx_vmaddwod_q_du_dlsx_vrotr_blsx_vrotr_hlsx_vrotr_wlsx_vrotr_dlsx_vadd_qlsx_vsub_qlsx_vldrepl_blsx_vldrepl_hlsx_vldrepl_wlsx_vldrepl_dlsx_vmskgez_blsx_vmsknz_blsx_vexth_h_blsx_vexth_w_hlsx_vexth_d_wlsx_vexth_q_dlsx_vexth_hu_bulsx_vexth_wu_hulsx_vexth_du_wulsx_vexth_qu_dulsx_vrotri_blsx_vrotri_hlsx_vrotri_wlsx_vrotri_dlsx_vextl_q_dlsx_vsrlni_b_hlsx_vsrlni_h_wlsx_vsrlni_w_dlsx_vsrlni_d_qlsx_vsrlrni_b_hlsx_vsrlrni_h_wlsx_vsrlrni_w_dlsx_vsrlrni_d_qlsx_vssrlni_b_hlsx_vssrlni_h_wlsx_vssrlni_w_dlsx_vssrlni_d_qlsx_vssrlni_bu_hlsx_vssrlni_hu_wlsx_vssrlni_wu_dlsx_vssrlni_du_qlsx_vssrlrni_b_hlsx_vssrlrni_h_wlsx_vssrlrni_w_dlsx_vssrlrni_d_qlsx_vssrlrni_bu_hlsx_vssrlrni_hu_wlsx_vssrlrni_wu_dlsx_vssrlrni_du_qlsx_vsrani_b_hlsx_vsrani_h_wlsx_vsrani_w_dlsx_vsrani_d_qlsx_vsrarni_b_hlsx_vsrarni_h_wlsx_vsrarni_w_dlsx_vsrarni_d_qlsx_vssrani_b_hlsx_vssrani_h_wlsx_vssrani_w_dlsx_vssrani_d_qlsx_vssrani_bu_hlsx_vssrani_hu_wlsx_vssrani_wu_dlsx_vssrani_du_qlsx_vssrarni_b_hlsx_vssrarni_h_wlsx_vssrarni_w_dlsx_vssrarni_d_qlsx_vssrarni_bu_hlsx_vssrarni_hu_wlsx_vssrarni_wu_dlsx_vssrarni_du_qlsx_vpermi_wlsx_vldlsx_vstlsx_vssrlrn_b_hlsx_vssrlrn_h_wlsx_vssrlrn_w_dlsx_vssrln_b_hlsx_vssrln_h_wlsx_vssrln_w_dlsx_vorn_vlsx_vldilsx_vshuf_blsx_vldxlsx_vstxlsx_vextl_qu_dulsx_bnz_blsx_bnz_dlsx_bnz_hlsx_bnz_vlsx_bnz_wlsx_bz_blsx_bz_dlsx_bz_hlsx_bz_vlsx_bz_wlsx_vfcmp_caf_dlsx_vfcmp_caf_slsx_vfcmp_ceq_dlsx_vfcmp_ceq_slsx_vfcmp_cle_dlsx_vfcmp_cle_slsx_vfcmp_clt_dlsx_vfcmp_clt_slsx_vfcmp_cne_dlsx_vfcmp_cne_slsx_vfcmp_cor_dlsx_vfcmp_cor_slsx_vfcmp_cueq_dlsx_vfcmp_cueq_slsx_vfcmp_cule_dlsx_vfcmp_cule_slsx_vfcmp_cult_dlsx_vfcmp_cult_slsx_vfcmp_cun_dlsx_vfcmp_cune_dlsx_vfcmp_cune_slsx_vfcmp_cun_slsx_vfcmp_saf_dlsx_vfcmp_saf_slsx_vfcmp_seq_dlsx_vfcmp_seq_slsx_vfcmp_sle_dlsx_vfcmp_sle_slsx_vfcmp_slt_dlsx_vfcmp_slt_slsx_vfcmp_sne_dlsx_vfcmp_sne_slsx_vfcmp_sor_dlsx_vfcmp_sor_slsx_vfcmp_sueq_dlsx_vfcmp_sueq_slsx_vfcmp_sule_dlsx_vfcmp_sule_slsx_vfcmp_sult_dlsx_vfcmp_sult_slsx_vfcmp_sun_dlsx_vfcmp_sune_dlsx_vfcmp_sune_slsx_vfcmp_sun_slsx_vrepli_blsx_vrepli_dlsx_vrepli_hlsx_vrepli_w// Instead, modify `crates/stdarch-gen-loongarch/lsx.spec` and run the following command to re-generate this file:// OUT_DIR=`pwd`/crates/core_arch cargo run -p stdarch-gen-loongarch -- crates/stdarch-gen-loongarch/lsx.spec//! LoongArch64 LSX intrinsicstest_lsx_vsll_btest_lsx_vsll_htest_lsx_vsll_wtest_lsx_vsll_dtest_lsx_vslli_btest_lsx_vslli_htest_lsx_vslli_wtest_lsx_vslli_dtest_lsx_vsra_btest_lsx_vsra_htest_lsx_vsra_wtest_lsx_vsra_dtest_lsx_vsrai_btest_lsx_vsrai_htest_lsx_vsrai_wtest_lsx_vsrai_dtest_lsx_vsrar_btest_lsx_vsrar_htest_lsx_vsrar_wtest_lsx_vsrar_dtest_lsx_vsrari_btest_lsx_vsrari_htest_lsx_vsrari_wtest_lsx_vsrari_dtest_lsx_vsrl_btest_lsx_vsrl_htest_lsx_vsrl_wtest_lsx_vsrl_dtest_lsx_vsrli_btest_lsx_vsrli_htest_lsx_vsrli_wtest_lsx_vsrli_dtest_lsx_vsrlr_btest_lsx_vsrlr_htest_lsx_vsrlr_wtest_lsx_vsrlr_dtest_lsx_vsrlri_btest_lsx_vsrlri_htest_lsx_vsrlri_wtest_lsx_vsrlri_dtest_lsx_vbitclr_btest_lsx_vbitclr_htest_lsx_vbitclr_wtest_lsx_vbitclr_dtest_lsx_vbitclri_btest_lsx_vbitclri_htest_lsx_vbitclri_wtest_lsx_vbitclri_dtest_lsx_vbitset_btest_lsx_vbitset_htest_lsx_vbitset_wtest_lsx_vbitset_dtest_lsx_vbitseti_btest_lsx_vbitseti_htest_lsx_vbitseti_wtest_lsx_vbitseti_dtest_lsx_vbitrev_btest_lsx_vbitrev_htest_lsx_vbitrev_wtest_lsx_vbitrev_dtest_lsx_vbitrevi_btest_lsx_vbitrevi_htest_lsx_vbitrevi_wtest_lsx_vbitrevi_dtest_lsx_vadd_btest_lsx_vadd_htest_lsx_vadd_wtest_lsx_vadd_dtest_lsx_vaddi_butest_lsx_vaddi_hutest_lsx_vaddi_wutest_lsx_vaddi_dutest_lsx_vsub_btest_lsx_vsub_htest_lsx_vsub_wtest_lsx_vsub_dtest_lsx_vsubi_butest_lsx_vsubi_hutest_lsx_vsubi_wutest_lsx_vsubi_dutest_lsx_vmax_btest_lsx_vmax_htest_lsx_vmax_wtest_lsx_vmax_dtest_lsx_vmaxi_btest_lsx_vmaxi_htest_lsx_vmaxi_wtest_lsx_vmaxi_dtest_lsx_vmax_butest_lsx_vmax_hutest_lsx_vmax_wutest_lsx_vmax_dutest_lsx_vmaxi_butest_lsx_vmaxi_hutest_lsx_vmaxi_wutest_lsx_vmaxi_dutest_lsx_vmin_btest_lsx_vmin_htest_lsx_vmin_wtest_lsx_vmin_dtest_lsx_vmini_btest_lsx_vmini_htest_lsx_vmini_wtest_lsx_vmini_dtest_lsx_vmin_butest_lsx_vmin_hutest_lsx_vmin_wutest_lsx_vmin_dutest_lsx_vmini_butest_lsx_vmini_hutest_lsx_vmini_wutest_lsx_vmini_dutest_lsx_vseq_btest_lsx_vseq_htest_lsx_vseq_wtest_lsx_vseq_dtest_lsx_vseqi_btest_lsx_vseqi_htest_lsx_vseqi_wtest_lsx_vseqi_dtest_lsx_vslti_btest_lsx_vslt_btest_lsx_vslt_htest_lsx_vslt_wtest_lsx_vslt_dtest_lsx_vslti_htest_lsx_vslti_wtest_lsx_vslti_dtest_lsx_vslt_butest_lsx_vslt_hutest_lsx_vslt_wutest_lsx_vslt_dutest_lsx_vslti_butest_lsx_vslti_hutest_lsx_vslti_wutest_lsx_vslti_dutest_lsx_vsle_btest_lsx_vsle_htest_lsx_vsle_wtest_lsx_vsle_dtest_lsx_vslei_btest_lsx_vslei_htest_lsx_vslei_wtest_lsx_vslei_dtest_lsx_vsle_butest_lsx_vsle_hutest_lsx_vsle_wutest_lsx_vsle_dutest_lsx_vslei_butest_lsx_vslei_hutest_lsx_vslei_wutest_lsx_vslei_dutest_lsx_vsat_btest_lsx_vsat_htest_lsx_vsat_wtest_lsx_vsat_dtest_lsx_vsat_butest_lsx_vsat_hutest_lsx_vsat_wutest_lsx_vsat_dutest_lsx_vadda_btest_lsx_vadda_htest_lsx_vadda_wtest_lsx_vadda_dtest_lsx_vsadd_btest_lsx_vsadd_htest_lsx_vsadd_wtest_lsx_vsadd_dtest_lsx_vsadd_butest_lsx_vsadd_hutest_lsx_vsadd_wutest_lsx_vsadd_dutest_lsx_vavg_btest_lsx_vavg_htest_lsx_vavg_wtest_lsx_vavg_dtest_lsx_vavg_butest_lsx_vavg_hutest_lsx_vavg_wutest_lsx_vavg_dutest_lsx_vavgr_btest_lsx_vavgr_htest_lsx_vavgr_wtest_lsx_vavgr_dtest_lsx_vavgr_butest_lsx_vavgr_hutest_lsx_vavgr_wutest_lsx_vavgr_dutest_lsx_vssub_btest_lsx_vssub_htest_lsx_vssub_wtest_lsx_vssub_dtest_lsx_vssub_butest_lsx_vssub_hutest_lsx_vssub_wutest_lsx_vssub_dutest_lsx_vabsd_btest_lsx_vabsd_htest_lsx_vabsd_wtest_lsx_vabsd_dtest_lsx_vabsd_butest_lsx_vabsd_hutest_lsx_vabsd_wutest_lsx_vabsd_dutest_lsx_vmul_btest_lsx_vmul_htest_lsx_vmul_wtest_lsx_vmul_dtest_lsx_vmadd_btest_lsx_vmadd_htest_lsx_vmadd_wtest_lsx_vmadd_dtest_lsx_vmsub_btest_lsx_vmsub_htest_lsx_vmsub_wtest_lsx_vmsub_dtest_lsx_vdiv_btest_lsx_vdiv_htest_lsx_vdiv_wtest_lsx_vdiv_dtest_lsx_vdiv_butest_lsx_vdiv_hutest_lsx_vdiv_wutest_lsx_vdiv_dutest_lsx_vhaddw_h_btest_lsx_vhaddw_w_htest_lsx_vhaddw_d_wtest_lsx_vhaddw_hu_butest_lsx_vhaddw_wu_hutest_lsx_vhaddw_du_wutest_lsx_vhsubw_h_btest_lsx_vhsubw_w_htest_lsx_vhsubw_d_wtest_lsx_vhsubw_hu_butest_lsx_vhsubw_wu_hutest_lsx_vhsubw_du_wutest_lsx_vmod_btest_lsx_vmod_htest_lsx_vmod_wtest_lsx_vmod_dtest_lsx_vmod_butest_lsx_vmod_hutest_lsx_vmod_wutest_lsx_vmod_dutest_lsx_vreplve_btest_lsx_vreplve_htest_lsx_vreplve_wtest_lsx_vreplve_dtest_lsx_vreplvei_btest_lsx_vreplvei_htest_lsx_vreplvei_wtest_lsx_vreplvei_dtest_lsx_vpickev_btest_lsx_vpickev_htest_lsx_vpickev_wtest_lsx_vpickev_dtest_lsx_vpickod_btest_lsx_vpickod_htest_lsx_vpickod_wtest_lsx_vpickod_dtest_lsx_vilvh_btest_lsx_vilvh_htest_lsx_vilvh_wtest_lsx_vilvh_dtest_lsx_vilvl_btest_lsx_vilvl_htest_lsx_vilvl_wtest_lsx_vilvl_dtest_lsx_vpackev_btest_lsx_vpackev_htest_lsx_vpackev_wtest_lsx_vpackev_dtest_lsx_vpackod_btest_lsx_vpackod_htest_lsx_vpackod_wtest_lsx_vpackod_dtest_lsx_vshuf_htest_lsx_vshuf_wtest_lsx_vshuf_dtest_lsx_vand_vtest_lsx_vandi_btest_lsx_vor_vtest_lsx_vori_btest_lsx_vnor_vtest_lsx_vnori_btest_lsx_vxor_vtest_lsx_vxori_btest_lsx_vbitsel_vtest_lsx_vbitseli_btest_lsx_vshuf4i_btest_lsx_vshuf4i_htest_lsx_vshuf4i_wtest_lsx_vreplgr2vr_btest_lsx_vreplgr2vr_htest_lsx_vreplgr2vr_wtest_lsx_vreplgr2vr_dtest_lsx_vpcnt_btest_lsx_vpcnt_htest_lsx_vpcnt_wtest_lsx_vpcnt_dtest_lsx_vclo_btest_lsx_vclo_htest_lsx_vclo_wtest_lsx_vclo_dtest_lsx_vclz_btest_lsx_vclz_htest_lsx_vclz_wtest_lsx_vclz_dtest_lsx_vpickve2gr_btest_lsx_vpickve2gr_htest_lsx_vpickve2gr_wtest_lsx_vpickve2gr_dtest_lsx_vpickve2gr_butest_lsx_vpickve2gr_hutest_lsx_vpickve2gr_wutest_lsx_vpickve2gr_dutest_lsx_vinsgr2vr_btest_lsx_vinsgr2vr_htest_lsx_vinsgr2vr_wtest_lsx_vinsgr2vr_dtest_lsx_vfadd_stest_lsx_vfadd_dtest_lsx_vfsub_stest_lsx_vfsub_dtest_lsx_vfmul_stest_lsx_vfmul_dtest_lsx_vfdiv_stest_lsx_vfdiv_dtest_lsx_vfcvt_h_stest_lsx_vfcvt_s_dtest_lsx_vfmin_stest_lsx_vfmin_dtest_lsx_vfmina_stest_lsx_vfmina_dtest_lsx_vfmax_stest_lsx_vfmax_dtest_lsx_vfmaxa_stest_lsx_vfmaxa_dtest_lsx_vfclass_stest_lsx_vfclass_dtest_lsx_vfsqrt_stest_lsx_vfsqrt_dtest_lsx_vfrecip_stest_lsx_vfrecip_dtest_lsx_vfrecipe_stest_lsx_vfrecipe_dtest_lsx_vfrsqrte_stest_lsx_vfrsqrte_dtest_lsx_vfrint_stest_lsx_vfrint_dtest_lsx_vfrsqrt_stest_lsx_vfrsqrt_dtest_lsx_vflogb_stest_lsx_vflogb_dtest_lsx_vfcvth_s_htest_lsx_vfcvth_d_stest_lsx_vfcvtl_s_htest_lsx_vfcvtl_d_stest_lsx_vftint_w_stest_lsx_vftint_l_dtest_lsx_vftint_wu_stest_lsx_vftint_lu_dtest_lsx_vftintrz_w_stest_lsx_vftintrz_l_dtest_lsx_vftintrz_wu_stest_lsx_vftintrz_lu_dtest_lsx_vffint_s_wtest_lsx_vffint_d_ltest_lsx_vffint_s_wutest_lsx_vffint_d_lutest_lsx_vandn_vtest_lsx_vneg_btest_lsx_vneg_htest_lsx_vneg_wtest_lsx_vneg_dtest_lsx_vmuh_btest_lsx_vmuh_htest_lsx_vmuh_wtest_lsx_vmuh_dtest_lsx_vmuh_butest_lsx_vmuh_hutest_lsx_vmuh_wutest_lsx_vmuh_dutest_lsx_vsllwil_h_btest_lsx_vsllwil_w_htest_lsx_vsllwil_d_wtest_lsx_vsllwil_hu_butest_lsx_vsllwil_wu_hutest_lsx_vsllwil_du_wutest_lsx_vsran_b_htest_lsx_vsran_h_wtest_lsx_vsran_w_dtest_lsx_vssran_b_htest_lsx_vssran_h_wtest_lsx_vssran_w_dtest_lsx_vssran_bu_htest_lsx_vssran_hu_wtest_lsx_vssran_wu_dtest_lsx_vsrarn_b_htest_lsx_vsrarn_h_wtest_lsx_vsrarn_w_dtest_lsx_vssrarn_b_htest_lsx_vssrarn_h_wtest_lsx_vssrarn_w_dtest_lsx_vssrarn_bu_htest_lsx_vssrarn_hu_wtest_lsx_vssrarn_wu_dtest_lsx_vsrln_b_htest_lsx_vsrln_h_wtest_lsx_vsrln_w_dtest_lsx_vssrln_bu_htest_lsx_vssrln_hu_wtest_lsx_vssrln_wu_dtest_lsx_vsrlrn_b_htest_lsx_vsrlrn_h_wtest_lsx_vsrlrn_w_dtest_lsx_vssrlrn_bu_htest_lsx_vssrlrn_hu_wtest_lsx_vssrlrn_wu_dtest_lsx_vfrstpi_btest_lsx_vfrstpi_htest_lsx_vfrstp_btest_lsx_vfrstp_htest_lsx_vshuf4i_dtest_lsx_vbsrl_vtest_lsx_vbsll_vtest_lsx_vextrins_btest_lsx_vextrins_htest_lsx_vextrins_wtest_lsx_vextrins_dtest_lsx_vmskltz_btest_lsx_vmskltz_htest_lsx_vmskltz_wtest_lsx_vmskltz_dtest_lsx_vsigncov_btest_lsx_vsigncov_htest_lsx_vsigncov_wtest_lsx_vsigncov_dtest_lsx_vfmadd_stest_lsx_vfmadd_dtest_lsx_vfmsub_stest_lsx_vfmsub_dtest_lsx_vfnmadd_stest_lsx_vfnmadd_dtest_lsx_vfnmsub_stest_lsx_vfnmsub_dtest_lsx_vftintrne_w_stest_lsx_vftintrne_l_dtest_lsx_vftintrp_w_stest_lsx_vftintrp_l_dtest_lsx_vftintrm_w_stest_lsx_vftintrm_l_dtest_lsx_vftint_w_dtest_lsx_vffint_s_ltest_lsx_vftintrz_w_dtest_lsx_vftintrp_w_dtest_lsx_vftintrm_w_dtest_lsx_vftintrne_w_dtest_lsx_vftintl_l_stest_lsx_vftinth_l_stest_lsx_vffinth_d_wtest_lsx_vffintl_d_wtest_lsx_vftintrzl_l_stest_lsx_vftintrzh_l_stest_lsx_vftintrpl_l_stest_lsx_vftintrph_l_stest_lsx_vftintrml_l_stest_lsx_vftintrmh_l_stest_lsx_vftintrnel_l_stest_lsx_vftintrneh_l_stest_lsx_vfrintrne_stest_lsx_vfrintrne_dtest_lsx_vfrintrz_stest_lsx_vfrintrz_dtest_lsx_vfrintrp_stest_lsx_vfrintrp_dtest_lsx_vfrintrm_stest_lsx_vfrintrm_dtest_lsx_vstelm_btest_lsx_vstelm_htest_lsx_vstelm_wtest_lsx_vstelm_dtest_lsx_vaddwev_d_wtest_lsx_vaddwev_w_htest_lsx_vaddwev_h_btest_lsx_vaddwod_d_wtest_lsx_vaddwod_w_htest_lsx_vaddwod_h_btest_lsx_vaddwev_d_wutest_lsx_vaddwev_w_hutest_lsx_vaddwev_h_butest_lsx_vaddwod_d_wutest_lsx_vaddwod_w_hutest_lsx_vaddwod_h_butest_lsx_vaddwev_d_wu_wtest_lsx_vaddwev_w_hu_htest_lsx_vaddwev_h_bu_btest_lsx_vaddwod_d_wu_wtest_lsx_vaddwod_w_hu_htest_lsx_vaddwod_h_bu_btest_lsx_vsubwev_d_wtest_lsx_vsubwev_w_htest_lsx_vsubwev_h_btest_lsx_vsubwod_d_wtest_lsx_vsubwod_w_htest_lsx_vsubwod_h_btest_lsx_vsubwev_d_wutest_lsx_vsubwev_w_hutest_lsx_vsubwev_h_butest_lsx_vsubwod_d_wutest_lsx_vsubwod_w_hutest_lsx_vsubwod_h_butest_lsx_vaddwev_q_dtest_lsx_vaddwod_q_dtest_lsx_vaddwev_q_dutest_lsx_vaddwod_q_dutest_lsx_vsubwev_q_dtest_lsx_vsubwod_q_dtest_lsx_vsubwev_q_dutest_lsx_vsubwod_q_dutest_lsx_vaddwev_q_du_dtest_lsx_vaddwod_q_du_dtest_lsx_vmulwev_d_wtest_lsx_vmulwev_w_htest_lsx_vmulwev_h_btest_lsx_vmulwod_d_wtest_lsx_vmulwod_w_htest_lsx_vmulwod_h_btest_lsx_vmulwev_d_wutest_lsx_vmulwev_w_hutest_lsx_vmulwev_h_butest_lsx_vmulwod_d_wutest_lsx_vmulwod_w_hutest_lsx_vmulwod_h_butest_lsx_vmulwev_d_wu_wtest_lsx_vmulwev_w_hu_htest_lsx_vmulwev_h_bu_btest_lsx_vmulwod_d_wu_wtest_lsx_vmulwod_w_hu_htest_lsx_vmulwod_h_bu_btest_lsx_vmulwev_q_dtest_lsx_vmulwod_q_dtest_lsx_vmulwev_q_dutest_lsx_vmulwod_q_dutest_lsx_vmulwev_q_du_dtest_lsx_vmulwod_q_du_dtest_lsx_vhaddw_q_dtest_lsx_vhaddw_qu_dutest_lsx_vhsubw_q_dtest_lsx_vhsubw_qu_dutest_lsx_vmaddwev_d_wtest_lsx_vmaddwev_w_htest_lsx_vmaddwev_h_btest_lsx_vmaddwev_d_wutest_lsx_vmaddwev_w_hutest_lsx_vmaddwev_h_butest_lsx_vmaddwod_d_wtest_lsx_vmaddwod_w_htest_lsx_vmaddwod_h_btest_lsx_vmaddwod_d_wutest_lsx_vmaddwod_w_hutest_lsx_vmaddwod_h_butest_lsx_vmaddwev_d_wu_wtest_lsx_vmaddwev_w_hu_htest_lsx_vmaddwev_h_bu_btest_lsx_vmaddwod_d_wu_wtest_lsx_vmaddwod_w_hu_htest_lsx_vmaddwod_h_bu_btest_lsx_vmaddwev_q_dtest_lsx_vmaddwod_q_dtest_lsx_vmaddwev_q_dutest_lsx_vmaddwod_q_dutest_lsx_vmaddwev_q_du_dtest_lsx_vmaddwod_q_du_dtest_lsx_vrotr_btest_lsx_vrotr_htest_lsx_vrotr_wtest_lsx_vrotr_dtest_lsx_vadd_qtest_lsx_vsub_qtest_lsx_vldrepl_btest_lsx_vldrepl_htest_lsx_vldrepl_wtest_lsx_vldrepl_dtest_lsx_vmskgez_btest_lsx_vmsknz_btest_lsx_vexth_h_btest_lsx_vexth_w_htest_lsx_vexth_d_wtest_lsx_vexth_q_dtest_lsx_vexth_hu_butest_lsx_vexth_wu_hutest_lsx_vexth_du_wutest_lsx_vexth_qu_dutest_lsx_vrotri_btest_lsx_vrotri_htest_lsx_vrotri_wtest_lsx_vrotri_dtest_lsx_vextl_q_dtest_lsx_vsrlni_b_htest_lsx_vsrlni_h_wtest_lsx_vsrlni_w_dtest_lsx_vsrlni_d_qtest_lsx_vsrlrni_b_htest_lsx_vsrlrni_h_wtest_lsx_vsrlrni_w_dtest_lsx_vsrlrni_d_qtest_lsx_vssrlni_b_htest_lsx_vssrlni_h_wtest_lsx_vssrlni_w_dtest_lsx_vssrlni_d_qtest_lsx_vssrlni_bu_htest_lsx_vssrlni_hu_wtest_lsx_vssrlni_wu_dtest_lsx_vssrlni_du_qtest_lsx_vssrlrni_b_htest_lsx_vssrlrni_h_wtest_lsx_vssrlrni_w_dtest_lsx_vssrlrni_d_qtest_lsx_vssrlrni_bu_htest_lsx_vssrlrni_hu_wtest_lsx_vssrlrni_wu_dtest_lsx_vssrlrni_du_qtest_lsx_vsrani_b_htest_lsx_vsrani_h_wtest_lsx_vsrani_w_dtest_lsx_vsrani_d_qtest_lsx_vsrarni_b_htest_lsx_vsrarni_h_wtest_lsx_vsrarni_w_dtest_lsx_vsrarni_d_qtest_lsx_vssrani_b_htest_lsx_vssrani_h_wtest_lsx_vssrani_w_dtest_lsx_vssrani_d_qtest_lsx_vssrani_bu_htest_lsx_vssrani_hu_wtest_lsx_vssrani_wu_dtest_lsx_vssrani_du_qtest_lsx_vssrarni_b_htest_lsx_vssrarni_h_wtest_lsx_vssrarni_w_dtest_lsx_vssrarni_d_qtest_lsx_vssrarni_bu_htest_lsx_vssrarni_hu_wtest_lsx_vssrarni_wu_dtest_lsx_vssrarni_du_qtest_lsx_vpermi_wtest_lsx_vldtest_lsx_vsttest_lsx_vssrlrn_b_htest_lsx_vssrlrn_h_wtest_lsx_vssrlrn_w_dtest_lsx_vssrln_b_htest_lsx_vssrln_h_wtest_lsx_vssrln_w_dtest_lsx_vorn_vtest_lsx_vlditest_lsx_vshuf_btest_lsx_vldxtest_lsx_vstxtest_lsx_vextl_qu_dutest_lsx_bnz_btest_lsx_bnz_dtest_lsx_bnz_htest_lsx_bnz_vtest_lsx_bnz_wtest_lsx_bz_btest_lsx_bz_dtest_lsx_bz_htest_lsx_bz_vtest_lsx_bz_wtest_lsx_vfcmp_caf_dtest_lsx_vfcmp_caf_stest_lsx_vfcmp_ceq_dtest_lsx_vfcmp_ceq_stest_lsx_vfcmp_cle_dtest_lsx_vfcmp_cle_stest_lsx_vfcmp_clt_dtest_lsx_vfcmp_clt_stest_lsx_vfcmp_cne_dtest_lsx_vfcmp_cne_stest_lsx_vfcmp_cor_dtest_lsx_vfcmp_cor_stest_lsx_vfcmp_cueq_dtest_lsx_vfcmp_cueq_stest_lsx_vfcmp_cule_dtest_lsx_vfcmp_cule_stest_lsx_vfcmp_cult_dtest_lsx_vfcmp_cult_stest_lsx_vfcmp_cun_dtest_lsx_vfcmp_cune_dtest_lsx_vfcmp_cune_stest_lsx_vfcmp_cun_stest_lsx_vfcmp_saf_dtest_lsx_vfcmp_saf_stest_lsx_vfcmp_seq_dtest_lsx_vfcmp_seq_stest_lsx_vfcmp_sle_dtest_lsx_vfcmp_sle_stest_lsx_vfcmp_slt_dtest_lsx_vfcmp_slt_stest_lsx_vfcmp_sne_dtest_lsx_vfcmp_sne_stest_lsx_vfcmp_sor_dtest_lsx_vfcmp_sor_stest_lsx_vfcmp_sueq_dtest_lsx_vfcmp_sueq_stest_lsx_vfcmp_sule_dtest_lsx_vfcmp_sule_stest_lsx_vfcmp_sult_dtest_lsx_vfcmp_sult_stest_lsx_vfcmp_sun_dtest_lsx_vfcmp_sune_dtest_lsx_vfcmp_sune_stest_lsx_vfcmp_sun_stest_lsx_vrepli_btest_lsx_vrepli_dtest_lsx_vrepli_htest_lsx_vrepli_wv16i8v8i16v4i32v2i64v16u8v8u16v4u32v2u64v4f32v2f64lasxlsxrdtime_d/// Reads the 64-bit stable counter value and the counter ID"llvm.loongarch.crc.w.d.w"__crc_w_d_w"llvm.loongarch.crcc.w.d.w"__crcc_w_d_w"llvm.loongarch.cacop.d""llvm.loongarch.csrrd.d""llvm.loongarch.csrwr.d""llvm.loongarch.csrxchg.d""llvm.loongarch.iocsrrd.d"__iocsrrd_d"llvm.loongarch.iocsrwr.d"__iocsrwr_d"llvm.loongarch.asrtle.d"__asrtle"llvm.loongarch.asrtgt.d"__asrtgt"llvm.loongarch.lddir.d"__lddir"llvm.loongarch.ldpte.d"__ldptecrc_w_d_w/// Calculate the CRC value using the IEEE 802.3 polynomial (0xEDB88320)crcc_w_d_w/// Calculate the CRC value using the Castagnoli polynomial (0x82F63B78)iocsrrd_d/// Reads the 64-bit IO-CSRiocsrwr_d/// Writes the 64-bit IO-CSRasrtle/// Generates the less-than-or-equal asseration instructionasrtgt/// Generates the greater-than asseration instructionlddir/// Loads the page table directory entryldpte/// Loads the page table entry//! `LoongArch64` intrinsicsrdtimel_w/// Reads the lower 32-bit stable counter value and the counter IDrdtimeh_w/// Reads the upper 32-bit stable counter value and the counter ID"llvm.loongarch.crc.w.b.w"__crc_w_b_w"llvm.loongarch.crc.w.h.w"__crc_w_h_w"llvm.loongarch.crc.w.w.w"__crc_w_w_w"llvm.loongarch.crcc.w.b.w"__crcc_w_b_w"llvm.loongarch.crcc.w.h.w"__crcc_w_h_w"llvm.loongarch.crcc.w.w.w"__crcc_w_w_w"llvm.loongarch.dbar"__dbar"llvm.loongarch.ibar"__ibar"llvm.loongarch.movgr2fcsr"__movgr2fcsr"llvm.loongarch.movfcsr2gr"__movfcsr2gr"llvm.loongarch.iocsrrd.b"__iocsrrd_b"llvm.loongarch.iocsrrd.h"__iocsrrd_h"llvm.loongarch.iocsrrd.w"__iocsrrd_w"llvm.loongarch.iocsrwr.b"__iocsrwr_b"llvm.loongarch.iocsrwr.h"__iocsrwr_h"llvm.loongarch.iocsrwr.w"__iocsrwr_w"llvm.loongarch.break"__break"llvm.loongarch.cpucfg"__cpucfg"llvm.loongarch.syscall"__syscall"llvm.loongarch.frecipe.s"__frecipe_s"llvm.loongarch.frecipe.d"__frecipe_d"llvm.loongarch.frsqrte.s"__frsqrte_s"llvm.loongarch.frsqrte.d"__frsqrte_dcrc_w_b_wcrc_w_h_wcrc_w_w_wcrcc_w_b_wcrcc_w_h_wcrcc_w_w_wIMM15dbar/// Generates the memory barrier instructionibar/// Generates the instruction-fetch barrier instructionmovgr2fcsr/// Moves data from a GPR to the FCSRmovfcsr2gr/// Moves data from a FCSR to the GPRiocsrrd_b/// Reads the 8-bit IO-CSRiocsrrd_h/// Reads the 16-bit IO-CSRiocsrrd_w/// Reads the 32-bit IO-CSRiocsrwr_b/// Writes the 8-bit IO-CSRiocsrwr_h/// Writes the 16-bit IO-CSRiocsrwr_w/// Writes the 32-bit IO-CSR/// Generates the breakpoint instructioncpucfg/// Reads the CPU configuration register/// Generates the syscall instructionfrecipe_s/// Calculate the approximate single-precision result of 1.0 dividedfrecipe_d/// Calculate the approximate double-precision result of 1.0 dividedfrsqrte_s/// Calculate the approximate single-precision result of dividing 1.0 by the square rootfrsqrte_d/// Calculate the approximate double-precision result of dividing 1.0 by the square root//! `Shared LoongArch` intrinsicsstatic_assert_uimm_bitsstatic_assert_simm_bitsSimdShuffleIdx//! Utility macros.// Building this module (even if unused) for non-fp64 targets fails with an LLVM// error.break_/// Generates the trap instruction `BREAK`//! MIPS"llvm.mips.add.a.b"msa_add_a_b"llvm.mips.add.a.h"msa_add_a_h"llvm.mips.add.a.w"msa_add_a_w"llvm.mips.add.a.d"msa_add_a_d"llvm.mips.adds.a.b"msa_adds_a_b"llvm.mips.adds.a.h"msa_adds_a_h"llvm.mips.adds.a.w"msa_adds_a_w"llvm.mips.adds.a.d"msa_adds_a_d"llvm.mips.adds.s.b"msa_adds_s_b"llvm.mips.adds.s.h"msa_adds_s_h"llvm.mips.adds.s.w"msa_adds_s_w"llvm.mips.adds.s.d"msa_adds_s_d"llvm.mips.adds.u.b"msa_adds_u_b"llvm.mips.adds.u.h"msa_adds_u_h"llvm.mips.adds.u.w"msa_adds_u_w"llvm.mips.adds.u.d"msa_adds_u_d"llvm.mips.addv.b"msa_addv_b"llvm.mips.addv.h"msa_addv_h"llvm.mips.addv.w"msa_addv_w"llvm.mips.addv.d"msa_addv_d"llvm.mips.addvi.b"msa_addvi_b"llvm.mips.addvi.h"msa_addvi_h"llvm.mips.addvi.w"msa_addvi_w"llvm.mips.addvi.d"msa_addvi_d"llvm.mips.and.v"msa_and_v"llvm.mips.andi.b"msa_andi_b"llvm.mips.asub.s.b"msa_asub_s_b"llvm.mips.asub.s.h"msa_asub_s_h"llvm.mips.asub.s.w"msa_asub_s_w"llvm.mips.asub.s.d"msa_asub_s_d"llvm.mips.asub.u.b"msa_asub_u_b"llvm.mips.asub.u.h"msa_asub_u_h"llvm.mips.asub.u.w"msa_asub_u_w"llvm.mips.asub.u.d"msa_asub_u_d"llvm.mips.ave.s.b"msa_ave_s_b"llvm.mips.ave.s.h"msa_ave_s_h"llvm.mips.ave.s.w"msa_ave_s_w"llvm.mips.ave.s.d"msa_ave_s_d"llvm.mips.ave.u.b"msa_ave_u_b"llvm.mips.ave.u.h"msa_ave_u_h"llvm.mips.ave.u.w"msa_ave_u_w"llvm.mips.ave.u.d"msa_ave_u_d"llvm.mips.aver.s.b"msa_aver_s_b"llvm.mips.aver.s.h"msa_aver_s_h"llvm.mips.aver.s.w"msa_aver_s_w"llvm.mips.aver.s.d"msa_aver_s_d"llvm.mips.aver.u.b"msa_aver_u_b"llvm.mips.aver.u.h"msa_aver_u_h"llvm.mips.aver.u.w"msa_aver_u_w"llvm.mips.aver.u.d"msa_aver_u_d"llvm.mips.bclr.b"msa_bclr_b"llvm.mips.bclr.h"msa_bclr_h"llvm.mips.bclr.w"msa_bclr_w"llvm.mips.bclr.d"msa_bclr_d"llvm.mips.bclri.b"msa_bclri_b"llvm.mips.bclri.h"msa_bclri_h"llvm.mips.bclri.w"msa_bclri_w"llvm.mips.bclri.d"msa_bclri_d"llvm.mips.binsl.b"msa_binsl_b"llvm.mips.binsl.h"msa_binsl_h"llvm.mips.binsl.w"msa_binsl_w"llvm.mips.binsl.d"msa_binsl_d"llvm.mips.binsli.b"msa_binsli_b"llvm.mips.binsli.h"msa_binsli_h"llvm.mips.binsli.w"msa_binsli_w"llvm.mips.binsli.d"msa_binsli_d"llvm.mips.binsr.b"msa_binsr_b"llvm.mips.binsr.h"msa_binsr_h"llvm.mips.binsr.w"msa_binsr_w"llvm.mips.binsr.d"msa_binsr_d"llvm.mips.binsri.b"msa_binsri_b"llvm.mips.binsri.h"msa_binsri_h"llvm.mips.binsri.w"msa_binsri_w"llvm.mips.binsri.d"msa_binsri_d"llvm.mips.bmnz.v"msa_bmnz_v"llvm.mips.bmnzi.b"msa_bmnzi_b"llvm.mips.bmz.v"msa_bmz_v"llvm.mips.bmzi.b"msa_bmzi_b"llvm.mips.bneg.b"msa_bneg_b"llvm.mips.bneg.h"msa_bneg_h"llvm.mips.bneg.w"msa_bneg_w"llvm.mips.bneg.d"msa_bneg_d"llvm.mips.bnegi.b"msa_bnegi_b"llvm.mips.bnegi.h"msa_bnegi_h"llvm.mips.bnegi.w"msa_bnegi_w"llvm.mips.bnegi.d"msa_bnegi_d"llvm.mips.bnz.b"msa_bnz_b"llvm.mips.bnz.h"msa_bnz_h"llvm.mips.bnz.w"msa_bnz_w"llvm.mips.bnz.d"msa_bnz_d"llvm.mips.bnz.v"msa_bnz_v"llvm.mips.bsel.v"msa_bsel_v"llvm.mips.bseli.b"msa_bseli_b"llvm.mips.bset.b"msa_bset_b"llvm.mips.bset.h"msa_bset_h"llvm.mips.bset.w"msa_bset_w"llvm.mips.bset.d"msa_bset_d"llvm.mips.bseti.b"msa_bseti_b"llvm.mips.bseti.h"msa_bseti_h"llvm.mips.bseti.w"msa_bseti_w"llvm.mips.bseti.d"msa_bseti_d"llvm.mips.bz.b"msa_bz_b"llvm.mips.bz.h"msa_bz_h"llvm.mips.bz.w"msa_bz_w"llvm.mips.bz.d"msa_bz_d"llvm.mips.bz.v"msa_bz_v"llvm.mips.ceq.b"msa_ceq_b"llvm.mips.ceq.h"msa_ceq_h"llvm.mips.ceq.w"msa_ceq_w"llvm.mips.ceq.d"msa_ceq_d"llvm.mips.ceqi.b"msa_ceqi_b"llvm.mips.ceqi.h"msa_ceqi_h"llvm.mips.ceqi.w"msa_ceqi_w"llvm.mips.ceqi.d"msa_ceqi_d"llvm.mips.cfcmsa"msa_cfcmsa"llvm.mips.cle.s.b"msa_cle_s_b"llvm.mips.cle.s.h"msa_cle_s_h"llvm.mips.cle.s.w"msa_cle_s_w"llvm.mips.cle.s.d"msa_cle_s_d"llvm.mips.cle.u.b"msa_cle_u_b"llvm.mips.cle.u.h"msa_cle_u_h"llvm.mips.cle.u.w"msa_cle_u_w"llvm.mips.cle.u.d"msa_cle_u_d"llvm.mips.clei.s.b"msa_clei_s_b"llvm.mips.clei.s.h"msa_clei_s_h"llvm.mips.clei.s.w"msa_clei_s_w"llvm.mips.clei.s.d"msa_clei_s_d"llvm.mips.clei.u.b"msa_clei_u_b"llvm.mips.clei.u.h"msa_clei_u_h"llvm.mips.clei.u.w"msa_clei_u_w"llvm.mips.clei.u.d"msa_clei_u_d"llvm.mips.clt.s.b"msa_clt_s_b"llvm.mips.clt.s.h"msa_clt_s_h"llvm.mips.clt.s.w"msa_clt_s_w"llvm.mips.clt.s.d"msa_clt_s_d"llvm.mips.clt.u.b"msa_clt_u_b"llvm.mips.clt.u.h"msa_clt_u_h"llvm.mips.clt.u.w"msa_clt_u_w"llvm.mips.clt.u.d"msa_clt_u_d"llvm.mips.clti.s.b"msa_clti_s_b"llvm.mips.clti.s.h"msa_clti_s_h"llvm.mips.clti.s.w"msa_clti_s_w"llvm.mips.clti.s.d"msa_clti_s_d"llvm.mips.clti.u.b"msa_clti_u_b"llvm.mips.clti.u.h"msa_clti_u_h"llvm.mips.clti.u.w"msa_clti_u_w"llvm.mips.clti.u.d"msa_clti_u_d"llvm.mips.copy.s.b"msa_copy_s_b"llvm.mips.copy.s.h"msa_copy_s_h"llvm.mips.copy.s.w"msa_copy_s_w"llvm.mips.copy.s.d"msa_copy_s_d"llvm.mips.copy.u.b"msa_copy_u_b"llvm.mips.copy.u.h"msa_copy_u_h"llvm.mips.copy.u.w"msa_copy_u_w"llvm.mips.copy.u.d"msa_copy_u_d"llvm.mips.ctcmsa"msa_ctcmsa"llvm.mips.div.s.b"msa_div_s_b"llvm.mips.div.s.h"msa_div_s_h"llvm.mips.div.s.w"msa_div_s_w"llvm.mips.div.s.d"msa_div_s_d"llvm.mips.div.u.b"msa_div_u_b"llvm.mips.div.u.h"msa_div_u_h"llvm.mips.div.u.w"msa_div_u_w"llvm.mips.div.u.d"msa_div_u_d"llvm.mips.dotp.s.h"msa_dotp_s_h"llvm.mips.dotp.s.w"msa_dotp_s_w"llvm.mips.dotp.s.d"msa_dotp_s_d"llvm.mips.dotp.u.h"msa_dotp_u_h"llvm.mips.dotp.u.w"msa_dotp_u_w"llvm.mips.dotp.u.d"msa_dotp_u_d"llvm.mips.dpadd.s.h"msa_dpadd_s_h"llvm.mips.dpadd.s.w"msa_dpadd_s_w"llvm.mips.dpadd.s.d"msa_dpadd_s_d"llvm.mips.dpadd.u.h"msa_dpadd_u_h"llvm.mips.dpadd.u.w"msa_dpadd_u_w"llvm.mips.dpadd.u.d"msa_dpadd_u_d"llvm.mips.dpsub.s.h"msa_dpsub_s_h"llvm.mips.dpsub.s.w"msa_dpsub_s_w"llvm.mips.dpsub.s.d"msa_dpsub_s_d"llvm.mips.dpsub.u.h"msa_dpsub_u_h"llvm.mips.dpsub.u.w"msa_dpsub_u_w"llvm.mips.dpsub.u.d"msa_dpsub_u_d"llvm.mips.fadd.w"msa_fadd_w"llvm.mips.fadd.d"msa_fadd_d"llvm.mips.fcaf.w"msa_fcaf_w"llvm.mips.fcaf.d"msa_fcaf_d"llvm.mips.fceq.w"msa_fceq_w"llvm.mips.fceq.d"msa_fceq_d"llvm.mips.fclass.w"msa_fclass_w"llvm.mips.fclass.d"msa_fclass_d"llvm.mips.fcle.w"msa_fcle_w"llvm.mips.fcle.d"msa_fcle_d"llvm.mips.fclt.w"msa_fclt_w"llvm.mips.fclt.d"msa_fclt_d"llvm.mips.fcne.w"msa_fcne_w"llvm.mips.fcne.d"msa_fcne_d"llvm.mips.fcor.w"msa_fcor_w"llvm.mips.fcor.d"msa_fcor_d"llvm.mips.fcueq.w"msa_fcueq_w"llvm.mips.fcueq.d"msa_fcueq_d"llvm.mips.fcule.w"msa_fcule_w"llvm.mips.fcule.d"msa_fcule_d"llvm.mips.fcult.w"msa_fcult_w"llvm.mips.fcult.d"msa_fcult_d"llvm.mips.fcun.w"msa_fcun_w"llvm.mips.fcun.d"msa_fcun_d"llvm.mips.fcune.w"msa_fcune_w"llvm.mips.fcune.d"msa_fcune_d"llvm.mips.fdiv.w"msa_fdiv_w"llvm.mips.fdiv.d"msa_fdiv_d"llvm.mips.fexdo.w"msa_fexdo_w// FIXME: 16-bit floats// #[link_name = "llvm.mips.fexdo.h"]// fn msa_fexdo_h(a: v4f32, b: v4f32) -> f16x8;"llvm.mips.fexp2.w"msa_fexp2_w"llvm.mips.fexp2.d"msa_fexp2_d"llvm.mips.fexupl.d"msa_fexupl_d// #[link_name = "llvm.mips.fexupl.w"]// fn msa_fexupl_w(a: f16x8) -> v4f32;"llvm.mips.fexupr.d"msa_fexupr_d// #[link_name = "llvm.mips.fexupr.w"]// fn msa_fexupr_w(a: f16x8) -> v4f32;"llvm.mips.ffint.s.w"msa_ffint_s_w"llvm.mips.ffint.s.d"msa_ffint_s_d"llvm.mips.ffint.u.w"msa_ffint_u_w"llvm.mips.ffint.u.d"msa_ffint_u_d"llvm.mips.ffql.w"msa_ffql_w"llvm.mips.ffql.d"msa_ffql_d"llvm.mips.ffqr.w"msa_ffqr_w"llvm.mips.ffqr.d"msa_ffqr_d"llvm.mips.fill.b"msa_fill_b"llvm.mips.fill.h"msa_fill_h"llvm.mips.fill.w"msa_fill_w"llvm.mips.fill.d"msa_fill_d"llvm.mips.flog2.w"msa_flog2_w"llvm.mips.flog2.d"msa_flog2_d"llvm.mips.fmadd.w"msa_fmadd_w"llvm.mips.fmadd.d"msa_fmadd_d"llvm.mips.fmax.w"msa_fmax_w"llvm.mips.fmax.d"msa_fmax_d"llvm.mips.fmax.a.w"msa_fmax_a_w"llvm.mips.fmax.a.d"msa_fmax_a_d"llvm.mips.fmin.w"msa_fmin_w"llvm.mips.fmin.d"msa_fmin_d"llvm.mips.fmin.a.w"msa_fmin_a_w"llvm.mips.fmin.a.d"msa_fmin_a_d"llvm.mips.fmsub.w"msa_fmsub_w"llvm.mips.fmsub.d"msa_fmsub_d"llvm.mips.fmul.w"msa_fmul_w"llvm.mips.fmul.d"msa_fmul_d"llvm.mips.frint.w"msa_frint_w"llvm.mips.frint.d"msa_frint_d"llvm.mips.frcp.w"msa_frcp_w"llvm.mips.frcp.d"msa_frcp_d"llvm.mips.frsqrt.w"msa_frsqrt_w"llvm.mips.frsqrt.d"msa_frsqrt_d"llvm.mips.fsaf.w"msa_fsaf_w"llvm.mips.fsaf.d"msa_fsaf_d"llvm.mips.fseq.w"msa_fseq_w"llvm.mips.fseq.d"msa_fseq_d"llvm.mips.fsle.w"msa_fsle_w"llvm.mips.fsle.d"msa_fsle_d"llvm.mips.fslt.w"msa_fslt_w"llvm.mips.fslt.d"msa_fslt_d"llvm.mips.fsne.w"msa_fsne_w"llvm.mips.fsne.d"msa_fsne_d"llvm.mips.fsor.w"msa_fsor_w"llvm.mips.fsor.d"msa_fsor_d"llvm.mips.fsqrt.w"msa_fsqrt_w"llvm.mips.fsqrt.d"msa_fsqrt_d"llvm.mips.fsub.w"msa_fsub_w"llvm.mips.fsub.d"msa_fsub_d"llvm.mips.fsueq.w"msa_fsueq_w"llvm.mips.fsueq.d"msa_fsueq_d"llvm.mips.fsule.w"msa_fsule_w"llvm.mips.fsule.d"msa_fsule_d"llvm.mips.fsult.w"msa_fsult_w"llvm.mips.fsult.d"msa_fsult_d"llvm.mips.fsun.w"msa_fsun_w"llvm.mips.fsun.d"msa_fsun_d"llvm.mips.fsune.w"msa_fsune_w"llvm.mips.fsune.d"msa_fsune_d"llvm.mips.ftint.s.w"msa_ftint_s_w"llvm.mips.ftint.s.d"msa_ftint_s_d"llvm.mips.ftint.u.w"msa_ftint_u_w"llvm.mips.ftint.u.d"msa_ftint_u_d"llvm.mips.ftq.h"msa_ftq_h"llvm.mips.ftq.w"msa_ftq_w"llvm.mips.ftrunc.s.w"msa_ftrunc_s_w"llvm.mips.ftrunc.s.d"msa_ftrunc_s_d"llvm.mips.ftrunc.u.w"msa_ftrunc_u_w"llvm.mips.ftrunc.u.d"msa_ftrunc_u_d"llvm.mips.hadd.s.h"msa_hadd_s_h"llvm.mips.hadd.s.w"msa_hadd_s_w"llvm.mips.hadd.s.d"msa_hadd_s_d"llvm.mips.hadd.u.h"msa_hadd_u_h"llvm.mips.hadd.u.w"msa_hadd_u_w"llvm.mips.hadd.u.d"msa_hadd_u_d"llvm.mips.hsub.s.h"msa_hsub_s_h"llvm.mips.hsub.s.w"msa_hsub_s_w"llvm.mips.hsub.s.d"msa_hsub_s_d"llvm.mips.hsub.u.h"msa_hsub_u_h"llvm.mips.hsub.u.w"msa_hsub_u_w"llvm.mips.hsub.u.d"msa_hsub_u_d"llvm.mips.ilvev.b"msa_ilvev_b"llvm.mips.ilvev.h"msa_ilvev_h"llvm.mips.ilvev.w"msa_ilvev_w"llvm.mips.ilvev.d"msa_ilvev_d"llvm.mips.ilvl.b"msa_ilvl_b"llvm.mips.ilvl.h"msa_ilvl_h"llvm.mips.ilvl.w"msa_ilvl_w"llvm.mips.ilvl.d"msa_ilvl_d"llvm.mips.ilvod.b"msa_ilvod_b"llvm.mips.ilvod.h"msa_ilvod_h"llvm.mips.ilvod.w"msa_ilvod_w"llvm.mips.ilvod.d"msa_ilvod_d"llvm.mips.ilvr.b"msa_ilvr_b"llvm.mips.ilvr.h"msa_ilvr_h"llvm.mips.ilvr.w"msa_ilvr_w"llvm.mips.ilvr.d"msa_ilvr_d"llvm.mips.insert.b"msa_insert_b"llvm.mips.insert.h"msa_insert_h"llvm.mips.insert.w"msa_insert_w"llvm.mips.insert.d"msa_insert_d"llvm.mips.insve.b"msa_insve_b"llvm.mips.insve.h"msa_insve_h"llvm.mips.insve.w"msa_insve_w"llvm.mips.insve.d"msa_insve_d"llvm.mips.ld.b"msa_ld_b"llvm.mips.ld.h"msa_ld_h"llvm.mips.ld.w"msa_ld_w"llvm.mips.ld.d"msa_ld_d"llvm.mips.ldi.b"msa_ldi_b"llvm.mips.ldi.h"msa_ldi_h"llvm.mips.ldi.w"msa_ldi_w"llvm.mips.ldi.d"msa_ldi_d"llvm.mips.madd.q.h"msa_madd_q_h"llvm.mips.madd.q.w"msa_madd_q_w"llvm.mips.maddr.q.h"msa_maddr_q_h"llvm.mips.maddr.q.w"msa_maddr_q_w"llvm.mips.maddv.b"msa_maddv_b"llvm.mips.maddv.h"msa_maddv_h"llvm.mips.maddv.w"msa_maddv_w"llvm.mips.maddv.d"msa_maddv_d"llvm.mips.max.a.b"msa_max_a_b"llvm.mips.max.a.h"msa_max_a_h"llvm.mips.max.a.w"msa_max_a_w"llvm.mips.max.a.d"msa_max_a_d"llvm.mips.max.s.b"msa_max_s_b"llvm.mips.max.s.h"msa_max_s_h"llvm.mips.max.s.w"msa_max_s_w"llvm.mips.max.s.d"msa_max_s_d"llvm.mips.max.u.b"msa_max_u_b"llvm.mips.max.u.h"msa_max_u_h"llvm.mips.max.u.w"msa_max_u_w"llvm.mips.max.u.d"msa_max_u_d"llvm.mips.maxi.s.b"msa_maxi_s_b"llvm.mips.maxi.s.h"msa_maxi_s_h"llvm.mips.maxi.s.w"msa_maxi_s_w"llvm.mips.maxi.s.d"msa_maxi_s_d"llvm.mips.maxi.u.b"msa_maxi_u_b"llvm.mips.maxi.u.h"msa_maxi_u_h"llvm.mips.maxi.u.w"msa_maxi_u_w"llvm.mips.maxi.u.d"msa_maxi_u_d"llvm.mips.min.a.b"msa_min_a_b"llvm.mips.min.a.h"msa_min_a_h"llvm.mips.min.a.w"msa_min_a_w"llvm.mips.min.a.d"msa_min_a_d"llvm.mips.min.s.b"msa_min_s_b"llvm.mips.min.s.h"msa_min_s_h"llvm.mips.min.s.w"msa_min_s_w"llvm.mips.min.s.d"msa_min_s_d"llvm.mips.min.u.b"msa_min_u_b"llvm.mips.min.u.h"msa_min_u_h"llvm.mips.min.u.w"msa_min_u_w"llvm.mips.min.u.d"msa_min_u_d"llvm.mips.mini.s.b"msa_mini_s_b"llvm.mips.mini.s.h"msa_mini_s_h"llvm.mips.mini.s.w"msa_mini_s_w"llvm.mips.mini.s.d"msa_mini_s_d"llvm.mips.mini.u.b"msa_mini_u_b"llvm.mips.mini.u.h"msa_mini_u_h"llvm.mips.mini.u.w"msa_mini_u_w"llvm.mips.mini.u.d"msa_mini_u_d"llvm.mips.mod.s.b"msa_mod_s_b"llvm.mips.mod.s.h"msa_mod_s_h"llvm.mips.mod.s.w"msa_mod_s_w"llvm.mips.mod.s.d"msa_mod_s_d"llvm.mips.mod.u.b"msa_mod_u_b"llvm.mips.mod.u.h"msa_mod_u_h"llvm.mips.mod.u.w"msa_mod_u_w"llvm.mips.mod.u.d"msa_mod_u_d"llvm.mips.move.v"msa_move_v"llvm.mips.msub.q.h"msa_msub_q_h"llvm.mips.msub.q.w"msa_msub_q_w"llvm.mips.msubr.q.h"msa_msubr_q_h"llvm.mips.msubr.q.w"msa_msubr_q_w"llvm.mips.msubv.b"msa_msubv_b"llvm.mips.msubv.h"msa_msubv_h"llvm.mips.msubv.w"msa_msubv_w"llvm.mips.msubv.d"msa_msubv_d"llvm.mips.mul.q.h"msa_mul_q_h"llvm.mips.mul.q.w"msa_mul_q_w"llvm.mips.mulr.q.h"msa_mulr_q_h"llvm.mips.mulr.q.w"msa_mulr_q_w"llvm.mips.mulv.b"msa_mulv_b"llvm.mips.mulv.h"msa_mulv_h"llvm.mips.mulv.w"msa_mulv_w"llvm.mips.mulv.d"msa_mulv_d"llvm.mips.nloc.b"msa_nloc_b"llvm.mips.nloc.h"msa_nloc_h"llvm.mips.nloc.w"msa_nloc_w"llvm.mips.nloc.d"msa_nloc_d"llvm.mips.nlzc.b"msa_nlzc_b"llvm.mips.nlzc.h"msa_nlzc_h"llvm.mips.nlzc.w"msa_nlzc_w"llvm.mips.nlzc.d"msa_nlzc_d"llvm.mips.nor.v"msa_nor_v"llvm.mips.nori.b"msa_nori_b"llvm.mips.or.v"msa_or_v"llvm.mips.ori.b"msa_ori_b"llvm.mips.pckev.b"msa_pckev_b"llvm.mips.pckev.h"msa_pckev_h"llvm.mips.pckev.w"msa_pckev_w"llvm.mips.pckev.d"msa_pckev_d"llvm.mips.pckod.b"msa_pckod_b"llvm.mips.pckod.h"msa_pckod_h"llvm.mips.pckod.w"msa_pckod_w"llvm.mips.pckod.d"msa_pckod_d"llvm.mips.pcnt.b"msa_pcnt_b"llvm.mips.pcnt.h"msa_pcnt_h"llvm.mips.pcnt.w"msa_pcnt_w"llvm.mips.pcnt.d"msa_pcnt_d"llvm.mips.sat.s.b"msa_sat_s_b"llvm.mips.sat.s.h"msa_sat_s_h"llvm.mips.sat.s.w"msa_sat_s_w"llvm.mips.sat.s.d"msa_sat_s_d"llvm.mips.sat.u.b"msa_sat_u_b"llvm.mips.sat.u.h"msa_sat_u_h"llvm.mips.sat.u.w"msa_sat_u_w"llvm.mips.sat.u.d"msa_sat_u_d"llvm.mips.shf.b"msa_shf_b"llvm.mips.shf.h"msa_shf_h"llvm.mips.shf.w"msa_shf_w"llvm.mips.sld.b"msa_sld_b"llvm.mips.sld.h"msa_sld_h"llvm.mips.sld.w"msa_sld_w"llvm.mips.sld.d"msa_sld_d"llvm.mips.sldi.b"msa_sldi_b"llvm.mips.sldi.h"msa_sldi_h"llvm.mips.sldi.w"msa_sldi_w"llvm.mips.sldi.d"msa_sldi_d"llvm.mips.sll.b"msa_sll_b"llvm.mips.sll.h"msa_sll_h"llvm.mips.sll.w"msa_sll_w"llvm.mips.sll.d"msa_sll_d"llvm.mips.slli.b"msa_slli_b"llvm.mips.slli.h"msa_slli_h"llvm.mips.slli.w"msa_slli_w"llvm.mips.slli.d"msa_slli_d"llvm.mips.splat.b"msa_splat_b"llvm.mips.splat.h"msa_splat_h"llvm.mips.splat.w"msa_splat_w"llvm.mips.splat.d"msa_splat_d"llvm.mips.splati.b"msa_splati_b"llvm.mips.splati.h"msa_splati_h"llvm.mips.splati.w"msa_splati_w"llvm.mips.splati.d"msa_splati_d"llvm.mips.sra.b"msa_sra_b"llvm.mips.sra.h"msa_sra_h"llvm.mips.sra.w"msa_sra_w"llvm.mips.sra.d"msa_sra_d"llvm.mips.srai.b"msa_srai_b"llvm.mips.srai.h"msa_srai_h"llvm.mips.srai.w"msa_srai_w"llvm.mips.srai.d"msa_srai_d"llvm.mips.srar.b"msa_srar_b"llvm.mips.srar.h"msa_srar_h"llvm.mips.srar.w"msa_srar_w"llvm.mips.srar.d"msa_srar_d"llvm.mips.srari.b"msa_srari_b"llvm.mips.srari.h"msa_srari_h"llvm.mips.srari.w"msa_srari_w"llvm.mips.srari.d"msa_srari_d"llvm.mips.srl.b"msa_srl_b"llvm.mips.srl.h"msa_srl_h"llvm.mips.srl.w"msa_srl_w"llvm.mips.srl.d"msa_srl_d"llvm.mips.srli.b"msa_srli_b"llvm.mips.srli.h"msa_srli_h"llvm.mips.srli.w"msa_srli_w"llvm.mips.srli.d"msa_srli_d"llvm.mips.srlr.b"msa_srlr_b"llvm.mips.srlr.h"msa_srlr_h"llvm.mips.srlr.w"msa_srlr_w"llvm.mips.srlr.d"msa_srlr_d"llvm.mips.srlri.b"msa_srlri_b"llvm.mips.srlri.h"msa_srlri_h"llvm.mips.srlri.w"msa_srlri_w"llvm.mips.srlri.d"msa_srlri_d"llvm.mips.st.b"msa_st_b"llvm.mips.st.h"msa_st_h"llvm.mips.st.w"msa_st_w"llvm.mips.st.d"msa_st_d"llvm.mips.subs.s.b"msa_subs_s_b"llvm.mips.subs.s.h"msa_subs_s_h"llvm.mips.subs.s.w"msa_subs_s_w"llvm.mips.subs.s.d"msa_subs_s_d"llvm.mips.subs.u.b"msa_subs_u_b"llvm.mips.subs.u.h"msa_subs_u_h"llvm.mips.subs.u.w"msa_subs_u_w"llvm.mips.subs.u.d"msa_subs_u_d"llvm.mips.subsus.u.b"msa_subsus_u_b"llvm.mips.subsus.u.h"msa_subsus_u_h"llvm.mips.subsus.u.w"msa_subsus_u_w"llvm.mips.subsus.u.d"msa_subsus_u_d"llvm.mips.subsuu.s.b"msa_subsuu_s_b"llvm.mips.subsuu.s.h"msa_subsuu_s_h"llvm.mips.subsuu.s.w"msa_subsuu_s_w"llvm.mips.subsuu.s.d"msa_subsuu_s_d"llvm.mips.subv.b"msa_subv_b"llvm.mips.subv.h"msa_subv_h"llvm.mips.subv.w"msa_subv_w"llvm.mips.subv.d"msa_subv_d"llvm.mips.subvi.b"msa_subvi_b"llvm.mips.subvi.h"msa_subvi_h"llvm.mips.subvi.w"msa_subvi_w"llvm.mips.subvi.d"msa_subvi_d"llvm.mips.vshf.b"msa_vshf_b"llvm.mips.vshf.h"msa_vshf_h"llvm.mips.vshf.w"msa_vshf_w"llvm.mips.vshf.d"msa_vshf_d"llvm.mips.xor.v"msa_xor_v"llvm.mips.xori.b"msa_xori_b__msa_add_a_b/// Vector Add Absolute Values./// The absolute values of the elements in vector in `a` (sixteen signed 8-bit integer numbers)/// are added to the absolute values of the elements in vector `b` (sixteen signed 8-bit integer numbers)./// The result is written to vector (sixteen signed 8-bit integer numbers).__msa_add_a_h/// Vector Add Absolute Values/// The absolute values of the elements in vector in `a` (eight signed 16-bit integer numbers)/// are added to the absolute values of the elements in vector `b` (eight signed 16-bit integer numbers)./// The result is written to vector (eight signed 16-bit integer numbers).__msa_add_a_w/// The absolute values of the elements in vector in `a` (four signed 32-bit integer numbers)/// are added to the absolute values of the elements in vector `b` (four signed 32-bit integer numbers)./// The result is written to vector (four signed 32-bit integer numbers).__msa_add_a_d/// The absolute values of the elements in vector in `a` (two signed 64-bit integer numbers)/// are added to the absolute values of the elements in vector `b` (two signed 64-bit integer numbers)./// The result is written to vector (two signed 64-bit integer numbers).__msa_adds_a_b/// Signed Saturated Vector Saturated Add of Absolute Values/// The saturated signed result is written to vector (sixteen signed 8-bit integer numbers).__msa_adds_a_h/// Vector Saturated Add of Absolute Values/// The saturated signed result is written to vector (eight signed 16-bit integer numbers).__msa_adds_a_w/// The saturated signed result is written to vector (four signed 32-bit integer numbers).__msa_adds_a_d/// The saturated signed result is written to vector (two signed 64-bit integer numbers).__msa_adds_s_b/// Vector Signed Saturated Add of Signed Values/// The elements in vector in `a` (sixteen signed 8-bit integer numbers)/// are added to the elements in vector `b` (sixteen signed 8-bit integer numbers)./// Signed arithmetic is performed and overflows clamp to the largest and/or smallest/// representable signed values before writing the result to vector (sixteen signed 8-bit integer numbers).__msa_adds_s_h/// The elements in vector in `a` (eight signed 16-bit integer numbers)/// are added to the elements in vector `b` (eight signed 16-bit integer numbers)./// representable signed values before writing the result to vector (eight signed 16-bit integer numbers).__msa_adds_s_w/// The elements in vector in `a` (four signed 32-bit integer numbers)/// are added to the elements in vector `b` (four signed 32-bit integer numbers)./// representable signed values before writing the result to vector (four signed 32-bit integer numbers).__msa_adds_s_d/// The elements in vector in `a` (two signed 64-bit integer numbers)/// are added to the elements in vector `b` (two signed 64-bit integer numbers)./// representable signed values before writing the result to vector (two signed 64-bit integer numbers).__msa_adds_u_b/// Vector Unsigned Saturated Add of Unsigned Values/// The elements in vector in `a` (sixteen unsigned 8-bit integer numbers)/// are added to the elements in vector `b` (sixteen unsigned 8-bit integer numbers)./// representable signed values before writing the result to vector (sixteen unsigned 8-bit integer numbers).__msa_adds_u_h/// The elements in vector in `a` (eight unsigned 16-bit integer numbers)/// are added to the elements in vector `b` (eight unsigned 16-bit integer numbers)./// representable signed values before writing the result to vector (eight unsigned 16-bit integer numbers).__msa_adds_u_w/// The elements in vector in `a` (four unsigned 32-bit integer numbers)/// are added to the elements in vector `b` (four unsigned 32-bit integer numbers)./// representable signed values before writing the result to vector (four unsigned 32-bit integer numbers).__msa_adds_u_d/// The elements in vector in `a` (two unsigned 64-bit integer numbers)/// are added to the elements in vector `b` (two unsigned 64-bit integer numbers)./// representable signed values before writing the result to vector (two unsigned 64-bit integer numbers).__msa_addv_b/// Vector Add__msa_addv_h__msa_addv_w__msa_addv_d__msa_addvi_b/// Immediate Add/// The 5-bit immediate unsigned value `imm5` is added to the elements/// vector in `a` (sixteen signed 8-bit integer numbers).__msa_addvi_h/// vector in `a` (eight signed 16-bit integer numbers).__msa_addvi_w/// vector in `a` (four signed 32-bit integer numbers).__msa_addvi_d/// vector in `a` (two signed 64-bit integer numbers).__msa_and_v/// Vector Logical And/// Each bit of vector `a` (sixteen unsigned 8-bit integer numbers)/// is combined with the corresponding bit of vector `b` (sixteen unsigned 8-bit integer numbers)/// in a bitwise logical AND operation./// The result is written to vector (sixteen unsigned 8-bit integer numbers).__msa_andi_b/// Immediate Logical And/// Each byte element of vector `a` (sixteen unsigned 8-bit integer numbers)/// is combined with the 8-bit immediate i8 (signed 8-bit integer number) in a bitwise logical AND operation.__msa_asub_s_b/// Vector Absolute Values of Signed Subtract/// The signed elements in vector `a` (sixteen signed 8-bit integer numbers)/// are subtracted from the signed elements in vector `b` (sixteen signed 8-bit integer numbers)./// The absolute value of the signed result is written to vector (sixteen signed 8-bit integer numbers).__msa_asub_s_h/// The signed elements in vector `a` (eight signed 16-bit integer numbers)/// are subtracted from the signed elements in vector `b` (eight signed 16-bit integer numbers)./// The absolute value of the signed result is written to vector (eight signed 16-bit integer numbers).__msa_asub_s_w/// The signed elements in vector `a` (four signed 32-bit integer numbers)/// are subtracted from the signed elements in vector `b` (four signed 32-bit integer numbers)./// The absolute value of the signed result is written to vector (four signed 32-bit integer numbers).__msa_asub_s_d/// The signed elements in vector `a` (two signed 64-bit integer numbers)/// are subtracted from the signed elements in vector `b` (two signed 64-bit integer numbers)./// The absolute value of the signed result is written to vector (two signed 64-bit integer numbers).__msa_asub_u_b/// Vector Absolute Values of Unsigned Subtract/// The unsigned elements in vector `a` (sixteen unsigned 8-bit integer numbers)/// are subtracted from the unsigned elements in vector `b` (sixteen unsigned 8-bit integer numbers)./// The absolute value of the unsigned result is written to vector (sixteen unsigned 8-bit integer numbers).__msa_asub_u_h/// The unsigned elements in vector `a` (eight unsigned 16-bit integer numbers)/// are subtracted from the unsigned elements in vector `b` (eight unsigned 16-bit integer numbers)./// The absolute value of the unsigned result is written to vector (eight unsigned 16-bit integer numbers).__msa_asub_u_w/// The unsigned elements in vector `a` (four unsigned 32-bit integer numbers)/// are subtracted from the unsigned elements in vector `b` (four unsigned 32-bit integer numbers)./// The absolute value of the unsigned result is written to vector (four unsigned 32-bit integer numbers).__msa_asub_u_d/// The unsigned elements in vector `a` (two unsigned 64-bit integer numbers)/// are subtracted from the unsigned elements in vector `b` (two unsigned 64-bit integer numbers)./// The absolute value of the unsigned result is written to vector (two unsigned 64-bit integer numbers).__msa_ave_s_b/// Vector Signed Average/// The elements in vector `a` (sixteen signed 8-bit integer numbers)/// The addition is done signed with full precision, i.e. the result has one extra bit./// Signed division by 2 (or arithmetic shift right by one bit) is performed before/// writing the result to vector (sixteen signed 8-bit integer numbers).__msa_ave_s_h/// The elements in vector `a` (eight signed 16-bit integer numbers)/// writing the result to vector (eight signed 16-bit integer numbers).__msa_ave_s_w/// The elements in vector `a` (four signed 32-bit integer numbers)/// writing the result to vector (four signed 32-bit integer numbers).__msa_ave_s_d/// The elements in vector `a` (two signed 64-bit integer numbers)/// writing the result to vector (two signed 64-bit integer numbers).__msa_ave_u_b/// Vector Unsigned Average/// The elements in vector `a` (sixteen unsigned 8-bit integer numbers)/// The addition is done unsigned with full precision, i.e. the result has one extra bit./// Unsigned division by 2 (or logical shift right by one bit) is performed before/// writing the result to vector (sixteen unsigned 8-bit integer numbers).__msa_ave_u_h/// The elements in vector `a` (eight unsigned 16-bit integer numbers)/// writing the result to vector (eight unsigned 16-bit integer numbers).__msa_ave_u_w/// The elements in vector `a` (four unsigned 32-bit integer numbers)/// writing the result to vector (four unsigned 32-bit integer numbers).__msa_ave_u_d/// The elements in vector `a` (two unsigned 64-bit integer numbers)/// writing the result to vector (two unsigned 64-bit integer numbers).__msa_aver_s_b/// Vector Signed Average Rounded/// The addition of the elements plus 1 (for rounding) is done signed with full precision,/// i.e. the result has one extra bit.__msa_aver_s_h__msa_aver_s_w__msa_aver_s_d__msa_aver_u_b/// Vector Unsigned Average Rounded/// The addition of the elements plus 1 (for rounding) is done unsigned with full precision,__msa_aver_u_h__msa_aver_u_w__msa_aver_u_d__msa_bclr_b/// Vector Bit Clear/// Clear (set to 0) one bit in each element of vector `a` (sixteen unsigned 8-bit integer numbers)./// The bit position is given by the elements in `b` (sixteen unsigned 8-bit integer numbers)/// modulo the size of the element in bits.__msa_bclr_h/// Clear (set to 0) one bit in each element of vector `a` (eight unsigned 16-bit integer numbers)./// The bit position is given by the elements in `b` (eight unsigned 16-bit integer numbers)/// The result is written to vector (eight unsigned 16-bit integer numbers).__msa_bclr_w/// Clear (set to 0) one bit in each element of vector `a` (four unsigned 32-bit integer numbers)./// The bit position is given by the elements in `b` (four unsigned 32-bit integer numbers)/// The result is written to vector (four unsigned 32-bit integer numbers).__msa_bclr_d/// Clear (set to 0) one bit in each element of vector `a` (two unsigned 64-bit integer numbers)./// The bit position is given by the elements in `b` (two unsigned 64-bit integer numbers)/// The result is written to vector (two unsigned 64-bit integer numbers).__msa_bclri_b/// Immediate Bit Clear/// The bit position is given by the immediate `m` modulo the size of the element in bits.__msa_bclri_h__msa_bclri_w__msa_bclri_d__msa_binsl_b/// Vector Bit Insert Left/// Copy most significant (left) bits in each element of vector `b` (sixteen unsigned 8-bit integer numbers)/// to elements in vector `a` (sixteen unsigned 8-bit integer numbers) while preserving the least significant (right) bits./// The number of bits to copy is given by the elements in vector `c` (sixteen unsigned 8-bit integer numbers)/// modulo the size of the element in bits plus 1.__msa_binsl_h/// Copy most significant (left) bits in each element of vector `b` (eight unsigned 16-bit integer numbers)/// to elements in vector `a` (eight unsigned 16-bit integer numbers) while preserving the least significant (right) bits./// The number of bits to copy is given by the elements in vector `c` (eight unsigned 16-bit integer numbers)__msa_binsl_w/// Copy most significant (left) bits in each element of vector `b` (four unsigned 32-bit integer numbers)/// to elements in vector `a` (four unsigned 32-bit integer numbers) while preserving the least significant (right) bits./// The number of bits to copy is given by the elements in vector `c` (four unsigned 32-bit integer numbers)__msa_binsl_d/// Copy most significant (left) bits in each element of vector `b` (two unsigned 64-bit integer numbers)/// to elements in vector `a` (two unsigned 64-bit integer numbers) while preserving the least significant (right) bits./// The number of bits to copy is given by the elements in vector `c` (two unsigned 64-bit integer numbers)__msa_binsli_b/// Immediate Bit Insert Left/// The number of bits to copy is given by the immediate `imm3` modulo the size of the element in bits plus 1.__msa_binsli_h/// The number of bits to copy is given by the immediate `imm4` modulo the size of the element in bits plus 1.__msa_binsli_w/// The number of bits to copy is given by the immediate `imm5` modulo the size of the element in bits plus 1.__msa_binsli_d/// The number of bits to copy is given by the immediate `imm6` modulo the size of the element in bits plus 1.__msa_binsr_b/// Vector Bit Insert Right/// Copy most significant (right) bits in each element of vector `b` (sixteen unsigned 8-bit integer numbers)/// to elements in vector `a` (sixteen unsigned 8-bit integer numbers) while preserving the least significant (left) bits.__msa_binsr_h/// Copy most significant (right) bits in each element of vector `b` (eight unsigned 16-bit integer numbers)/// to elements in vector `a` (eight unsigned 16-bit integer numbers) while preserving the least significant (left) bits.__msa_binsr_w/// Copy most significant (right) bits in each element of vector `b` (four unsigned 32-bit integer numbers)/// to elements in vector `a` (four unsigned 32-bit integer numbers) while preserving the least significant (left) bits.__msa_binsr_d/// Copy most significant (right) bits in each element of vector `b` (two unsigned 64-bit integer numbers)/// to elements in vector `a` (two unsigned 64-bit integer numbers) while preserving the least significant (left) bits.__msa_binsri_b/// Immediate Bit Insert Right__msa_binsri_h__msa_binsri_w__msa_binsri_d__msa_bmnz_v/// Vector Bit Move If Not Zero/// Copy to destination vector `a` (sixteen unsigned 8-bit integer numbers) all bits from source vector/// `b` (sixteen unsigned 8-bit integer numbers) for which the corresponding bits from target vector `c`/// (sixteen unsigned 8-bit integer numbers) are 1 and leaves unchanged all destination bits/// for which the corresponding target bits are 0.__msa_bmnzi_b/// Immediate Bit Move If Not Zero/// `b` (sixteen unsigned 8-bit integer numbers) for which the corresponding bits from immediate `imm8`/// are 1 and leaves unchanged all destination bits for which the corresponding target bits are 0.__msa_bmz_v/// Vector Bit Move If Zero/// (sixteen unsigned 8-bit integer numbers) are 0 and leaves unchanged all destination bits/// for which the corresponding target bits are 1.__msa_bmzi_b/// Immediate Bit Move If Zero/// are 0 and leaves unchanged all destination bits for which the corresponding immediate bits are 1.__msa_bneg_b/// Vector Bit Negate/// Negate (complement) one bit in each element of vector `a` (sixteen unsigned 8-bit integer numbers)./// The bit position is given by the elements in vector `b` (sixteen unsigned 8-bit integer numbers)__msa_bneg_h/// Negate (complement) one bit in each element of vector `a` (eight unsigned 16-bit integer numbers)./// The bit position is given by the elements in vector `b` (eight unsigned 16-bit integer numbers)__msa_bneg_w/// Negate (complement) one bit in each element of vector `a` (four unsigned 32-bit integer numbers)./// The bit position is given by the elements in vector `b` (four unsigned 32-bit integer numbers)__msa_bneg_d/// Negate (complement) one bit in each element of vector `a` (two unsigned 64-bit integer numbers)./// The bit position is given by the elements in vector `b` (two unsigned 64-bit integer numbers)__msa_bnegi_b/// Immediate Bit Negate/// The bit position is given by immediate `imm3` modulo the size of the element in bits.__msa_bnegi_h/// The bit position is given by immediate `imm4` modulo the size of the element in bits.__msa_bnegi_w/// The bit position is given by immediate `imm5` modulo the size of the element in bits.__msa_bnegi_d/// The bit position is given by immediate `imm6` modulo the size of the element in bits.__msa_bnz_b/// Immediate Branch If All Elements Are Not Zero/// PC-relative branch if all elements in `a` (sixteen unsigned 8-bit integer numbers) are not zero.__msa_bnz_h/// PC-relative branch if all elements in `a` (eight unsigned 16-bit integer numbers) are not zero.__msa_bnz_w/// PC-relative branch if all elements in `a` (four unsigned 32-bit integer numbers) are not zero.__msa_bnz_d/// PC-relative branch if all elements in `a` (two unsigned 64-bit integer numbers) are not zero.__msa_bnz_v/// Immediate Branch If Not Zero (At Least One Element of Any Format Is Not Zero)/// PC-relative branch if at least one bit in `a` (four unsigned 32-bit integer numbers) are not zero./// i.e at least one element is not zero regardless of the data format.__msa_bsel_v/// Vector Bit Select/// Selectively copy bits from the source vectors `b` (eight unsigned 16-bit integer numbers)/// and `c` (eight unsigned 16-bit integer numbers)/// into destination vector `a` (eight unsigned 16-bit integer numbers) based on the corresponding bit in `a`:/// if 0 copies the bit from `b`, if 1 copies the bit from `c`.__msa_bseli_b/// Immediate Bit Select/// Selectively copy bits from the 8-bit immediate `imm8` and `c` (eight unsigned 16-bit integer numbers)__msa_bset_b/// Vector Bit Set/// Set to 1 one bit in each element of vector `a` (sixteen unsigned 8-bit integer numbers).__msa_bset_h/// Set to 1 one bit in each element of vector `a` (eight unsigned 16-bit integer numbers).__msa_bset_w/// Set to 1 one bit in each element of vector `a` (four unsigned 32-bit integer numbers).__msa_bset_d/// Set to 1 one bit in each element of vector `a` (two unsigned 64-bit integer numbers).__msa_bseti_b/// Immediate Bit Set/// The bit position is given by immediate `imm3`./// The result is written to vector `a` (sixteen unsigned 8-bit integer numbers).__msa_bseti_h/// The bit position is given by immediate `imm4`./// The result is written to vector `a` (eight unsigned 16-bit integer numbers).__msa_bseti_w/// The bit position is given by immediate `imm5`./// The result is written to vector `a` (four unsigned 32-bit integer numbers).__msa_bseti_d/// The bit position is given by immediate `imm6`./// The result is written to vector `a` (two unsigned 64-bit integer numbers).__msa_bz_b/// Immediate Branch If At Least One Element Is Zero/// PC-relative branch if at least one element in `a` (sixteen unsigned 8-bit integer numbers) is zero.__msa_bz_h/// PC-relative branch if at least one element in `a` (eight unsigned 16-bit integer numbers) is zero.__msa_bz_w/// PC-relative branch if at least one element in `a` (four unsigned 32-bit integer numbers) is zero.__msa_bz_d/// PC-relative branch if at least one element in `a` (two unsigned 64-bit integer numbers) is zero.__msa_bz_v/// Immediate Branch If Zero (All Elements of Any Format Are Zero)/// PC-relative branch if all elements in `a` (sixteen unsigned 8-bit integer numbers) bits are zero,/// i.e. all elements are zero regardless of the data format.__msa_ceq_b/// Vector Compare Equal/// Set all bits to 1 in vector (sixteen signed 8-bit integer numbers) elements/// if the corresponding `a` (sixteen signed 8-bit integer numbers) and `b` (sixteen signed 8-bit integer numbers)/// elements are equal, otherwise set all bits to 0.__msa_ceq_h/// Set all bits to 1 in vector (eight signed 16-bit integer numbers) elements/// if the corresponding `a` (eight signed 16-bit integer numbers) and `b` (eight signed 16-bit integer numbers)__msa_ceq_w/// Set all bits to 1 in vector (four signed 32-bit integer numbers) elements/// if the corresponding `a` (four signed 32-bit integer numbers) and `b` (four signed 32-bit integer numbers)__msa_ceq_d/// Set all bits to 1 in vector (two signed 64-bit integer numbers) elements/// if the corresponding `a` (two signed 64-bit integer numbers) and `b` (two signed 64-bit integer numbers)__msa_ceqi_b/// Immediate Compare Equal/// if the corresponding `a` (sixteen signed 8-bit integer numbers) the 5-bit signed immediate imm_s5/// are equal, otherwise set all bits to 0.__msa_ceqi_h/// if the corresponding `a` (eight signed 16-bit integer numbers) the 5-bit signed immediate imm_s5__msa_ceqi_w/// if the corresponding `a` (four signed 32-bit integer numbers) the 5-bit signed immediate imm_s5__msa_ceqi_d/// if the corresponding `a` (two signed 64-bit integer numbers) the 5-bit signed immediate imm_s5__msa_cfcmsa/// GPR Copy from MSA Control Register/// The sign extended content of MSA control register cs is copied to GPR rd./// Can not be tested in user mode__msa_cle_s_b/// Vector Compare Signed Less Than or Equal/// if the corresponding `a` (sixteen signed 8-bit integer numbers) element/// are signed less than or equal to `b` (sixteen signed 8-bit integer numbers) element./// Otherwise set all bits to 0.__msa_cle_s_h/// if the corresponding `a` (eight signed 16-bit integer numbers) element/// are signed less than or equal to `b` (eight signed 16-bit integer numbers) element.__msa_cle_s_w/// if the corresponding `a` (four signed 32-bit integer numbers) element/// are signed less than or equal to `b` (four signed 32-bit integer numbers) element.__msa_cle_s_d/// if the corresponding `a` (two signed 64-bit integer numbers) element/// are signed less than or equal to `b` (two signed 64-bit integer numbers) element.__msa_cle_u_b/// Vector Compare Unsigned Less Than or Equal/// if the corresponding `a` (sixteen unsigned 8-bit integer numbers) element/// are unsigned less than or equal to `b` (sixteen unsigned 8-bit integer numbers) element.__msa_cle_u_h/// if the corresponding `a` (eight unsigned 16-bit integer numbers) element/// are unsigned less than or equal to `b` (eight unsigned 16-bit integer numbers) element.__msa_cle_u_w/// if the corresponding `a` (four unsigned 32-bit integer numbers) element/// are unsigned less than or equal to `b` (four unsigned 32-bit integer numbers) element.__msa_cle_u_d/// if the corresponding `a` (two unsigned 64-bit integer numbers) element/// are unsigned less than or equal to `b` (two unsigned 64-bit integer numbers) element.__msa_clei_s_b/// Immediate Compare Signed Less Than or Equal/// is less than or equal to the 5-bit signed immediate imm_s5,/// otherwise set all bits to 0.__msa_clei_s_h__msa_clei_s_w__msa_clei_s_d__msa_clei_u_b/// Immediate Compare Unsigned Less Than or Equal/// is unsigned less than or equal to the 5-bit unsigned immediate `imm5`,__msa_clei_u_h__msa_clei_u_w__msa_clei_u_d__msa_clt_s_b/// Vector Compare Signed Less Than/// are signed less than `b` (sixteen signed 8-bit integer numbers) element.__msa_clt_s_h/// are signed less than `b` (eight signed 16-bit integer numbers) element.__msa_clt_s_w/// are signed less than `b` (four signed 32-bit integer numbers) element.__msa_clt_s_d/// are signed less than `b` (two signed 64-bit integer numbers) element.__msa_clt_u_b/// Vector Compare Unsigned Less Than/// are unsigned less than `b` (sixteen unsigned 8-bit integer numbers) element.__msa_clt_u_h/// are unsigned less than `b` (eight unsigned 16-bit integer numbers) element.__msa_clt_u_w/// are unsigned less than `b` (four unsigned 32-bit integer numbers) element.__msa_clt_u_d/// are unsigned less than `b` (two unsigned 64-bit integer numbers) element.__msa_clti_s_b/// Immediate Compare Signed Less Than/// is less than the 5-bit signed immediate imm_s5,__msa_clti_s_h__msa_clti_s_w__msa_clti_s_d__msa_clti_u_b/// Immediate Compare Unsigned Less Than/// is unsigned less than the 5-bit unsigned immediate `imm5`,__msa_clti_u_h__msa_clti_u_w__msa_clti_u_d__msa_copy_s_b/// Element Copy to GPR Signed/// Sign-extend element `imm4` of vector `a` (sixteen signed 8-bit integer numbers)/// and copy the result to GPR rd.__msa_copy_s_h/// Sign-extend element `imm3` of vector `a` (eight signed 16-bit integer numbers)__msa_copy_s_w/// Sign-extend element `imm2` of vector `a` (four signed 32-bit integer numbers)__msa_copy_s_d/// Sign-extend element `imm1` of vector `a` (two signed 64-bit integer numbers)__msa_copy_u_b/// Element Copy to GPR Unsigned/// Zero-extend element `imm4` of vector `a` (sixteen signed 8-bit integer numbers)__msa_copy_u_h/// Zero-extend element `imm3` of vector `a` (eight signed 16-bit integer numbers)__msa_copy_u_w/// Zero-extend element `imm2` of vector `a` (four signed 32-bit integer numbers)__msa_copy_u_d/// Zero-extend element `imm1` of vector `a` (two signed 64-bit integer numbers)__msa_ctcmsa/// GPR Copy to MSA Control Register/// The content of the least significant 31 bits of GPR `imm1` is copied to/// MSA control register cd.__msa_div_s_b/// Vector Signed Divide/// The signed integer elements in vector `a` (sixteen signed 8-bit integer numbers)/// are divided by signed integer elements in vector `b` (sixteen signed 8-bit integer numbers).__msa_div_s_h/// The signed integer elements in vector `a` (eight signed 16-bit integer numbers)/// are divided by signed integer elements in vector `b` (eight signed 16-bit integer numbers).__msa_div_s_w/// The signed integer elements in vector `a` (four signed 32-bit integer numbers)/// are divided by signed integer elements in vector `b` (four signed 32-bit integer numbers).__msa_div_s_d/// The signed integer elements in vector `a` (two signed 64-bit integer numbers)/// are divided by signed integer elements in vector `b` (two signed 64-bit integer numbers).__msa_div_u_b/// Vector Unsigned Divide/// The unsigned integer elements in vector `a` (sixteen unsigned 8-bit integer numbers)/// are divided by unsigned integer elements in vector `b` (sixteen unsigned 8-bit integer numbers).__msa_div_u_h/// The unsigned integer elements in vector `a` (eight unsigned 16-bit integer numbers)/// are divided by unsigned integer elements in vector `b` (eight unsigned 16-bit integer numbers).__msa_div_u_w/// The unsigned integer elements in vector `a` (four unsigned 32-bit integer numbers)/// are divided by unsigned integer elements in vector `b` (four unsigned 32-bit integer numbers).__msa_div_u_d/// The unsigned integer elements in vector `a` (two unsigned 64-bit integer numbers)/// are divided by unsigned integer elements in vector `b` (two unsigned 64-bit integer numbers).__msa_dotp_s_h/// Vector Signed Dot Product/// are multiplied by signed integer elements in vector `b` (sixteen signed 8-bit integer numbers)/// producing a result the size of the input operands. The multiplication results of/// adjacent odd/even elements are added and stored to the destination/// vector (eight signed 16-bit integer numbers).__msa_dotp_s_w/// are multiplied by signed integer elements in vector `b` (eight signed 16-bit integer numbers)/// vector (four signed 32-bit integer numbers).__msa_dotp_s_d/// are multiplied by signed integer elements in vector `b` (four signed 32-bit integer numbers)/// vector (two signed 64-bit integer numbers).__msa_dotp_u_h/// Vector Unsigned Dot Product/// are multiplied by unsigned integer elements in vector `b` (sixteen unsigned 8-bit integer numbers)/// vector (eight unsigned 16-bit integer numbers).__msa_dotp_u_w/// are multiplied by unsigned integer elements in vector `b` (eight unsigned 16-bit integer numbers)/// vector (four unsigned 32-bit integer numbers).__msa_dotp_u_d/// are multiplied by unsigned integer elements in vector `b` (four unsigned 32-bit integer numbers)/// vector (two unsigned 64-bit integer numbers).__msa_dpadd_s_h/// Vector Signed Dot Product and Add/// The signed integer elements in vector `b` (sixteen signed 8-bit integer numbers)/// are multiplied by signed integer elements in vector `c` (sixteen signed 8-bit integer numbers)/// producing a result twice the size of the input operands. The multiplication results/// of adjacent odd/even elements are added to the vector `a` (eight signed 16-bit integer numbers).__msa_dpadd_s_w/// The signed integer elements in vector `b` (eight signed 16-bit integer numbers)/// are multiplied by signed integer elements in vector `c` (eight signed 16-bit integer numbers)/// of adjacent odd/even elements are added to the vector `a` (four signed 32-bit integer numbers).__msa_dpadd_s_d/// The signed integer elements in vector `b` (four signed 32-bit integer numbers)/// are multiplied by signed integer elements in vector `c` (four signed 32-bit integer numbers)/// of adjacent odd/even elements are added to the vector `a` (two signed 64-bit integer numbers).__msa_dpadd_u_h/// Vector Unsigned Dot Product and Add/// The unsigned integer elements in vector `b` (sixteen unsigned 8-bit integer numbers)/// are multiplied by unsigned integer elements in vector `c` (sixteen unsigned 8-bit integer numbers)/// of adjacent odd/even elements are added to the vector `a` (eight unsigned 16-bit integer numbers).__msa_dpadd_u_w/// The unsigned integer elements in vector `b` (eight unsigned 16-bit integer numbers)/// are multiplied by unsigned integer elements in vector `c` (eight unsigned 16-bit integer numbers)/// of adjacent odd/even elements are added to the vector `a` (four unsigned 32-bit integer numbers).__msa_dpadd_u_d/// The unsigned integer elements in vector `b` (four unsigned 32-bit integer numbers)/// are multiplied by unsigned integer elements in vector `c` (four unsigned 32-bit integer numbers)/// of adjacent odd/even elements are added to the vector `a` (two unsigned 64-bit integer numbers).__msa_dpsub_s_h/// of adjacent odd/even elements are subtracted from the integer elements in vector `a`/// (eight signed 16-bit integer numbers).__msa_dpsub_s_w/// (four signed 32-bit integer numbers).__msa_dpsub_s_d/// (two signed 64-bit integer numbers).__msa_dpsub_u_h__msa_dpsub_u_w__msa_dpsub_u_d__msa_fadd_w/// Vector Floating-Point Addition/// The floating-point elements in vector `a` (four 32-bit floating point numbers)/// are added to the floating-point elements in `bc` (four 32-bit floating point numbers)./// The result is written to vector (four 32-bit floating point numbers).__msa_fadd_d/// The floating-point elements in vector `a` (two 64-bit floating point numbers)/// are added to the floating-point elements in `bc` (two 64-bit floating point numbers)./// The result is written to vector (two 64-bit floating point numbers).__msa_fcaf_w/// Vector Floating-Point Quiet Compare Always False/// Set all bits to 0 in vector (four signed 32-bit integer numbers)./// Signaling NaN elements in `a` (four 32-bit floating point numbers)/// or `b` (four 32-bit floating point numbers) signal Invalid Operation exception.__msa_fcaf_d/// Set all bits to 0 in vector (two signed 64-bit integer numbers)./// Signaling NaN elements in `a` (two 64-bit floating point numbers)/// or `b` (two 64-bit floating point numbers) signal Invalid Operation exception.__msa_fceq_w/// Vector Floating-Point Quiet Compare Equal/// Set all bits to 1 in vector (four signed 32-bit integer numbers)/// elements if the corresponding in `a` (four 32-bit floating point numbers)/// and `b` (four 32-bit floating point numbers) elements are ordered and equal,__msa_fceq_d/// Set all bits to 1 in vector (two signed 64-bit integer numbers)/// elements if the corresponding in `a` (two 64-bit floating point numbers)/// and `b` (two 64-bit floating point numbers) elements are ordered and equal,__msa_fclass_w/// Vector Floating-Point Class Mask/// Store in each element of vector (four signed 32-bit integer numbers)/// a bit mask reflecting the floating-point class of the corresponding element of vector/// `a` (four 32-bit floating point numbers)./// The mask has 10 bits as follows. Bits 0 and 1 indicate NaN values: signaling NaN (bit 0) and quiet NaN (bit 1)./// Bits 2, 3, 4, 5 classify negative values: infinity (bit 2), normal (bit 3), subnormal (bit 4), and zero (bit 5)./// Bits 6, 7, 8, 9 classify positive values: infinity (bit 6), normal (bit 7), subnormal (bit 8), and zero (bit 9).__msa_fclass_d/// Store in each element of vector (two signed 64-bit integer numbers)/// `a` (two 64-bit floating point numbers).__msa_fcle_w/// Vector Floating-Point Quiet Compare Less or Equal/// elements if the corresponding `a` (four 32-bit floating point numbers) elements are ordered/// and either less than or equal to `b` (four 32-bit floating point numbers) elements,__msa_fcle_d/// elements if the corresponding `a` (two 64-bit floating point numbers) elements are ordered/// and either less than or equal to `b` (two 64-bit floating point numbers) elements,__msa_fclt_w/// Vector Floating-Point Quiet Compare Less Than/// and less than `b` (four 32-bit floating point numbers) elements,__msa_fclt_d/// and less than `b` (two 64-bit floating point numbers) elements,__msa_fcne_w/// Vector Floating-Point Quiet Compare Not Equal/// elements if the corresponding `a` (four 32-bit floating point numbers) and/// `b` (four 32-bit floating point numbers) elements are ordered and not equal,__msa_fcne_d/// elements if the corresponding `a` (two 64-bit floating point numbers) and/// `b` (two 64-bit floating point numbers) elements are ordered and not equal,__msa_fcor_w/// Vector Floating-Point Quiet Compare Ordered/// `b` (four 32-bit floating point numbers) elements are ordered, i.e. both elements are not NaN values,__msa_fcor_d/// `b` (two 64-bit floating point numbers) elements are ordered, i.e. both elements are not NaN values,__msa_fcueq_w/// Vector Floating-Point Quiet Compare Unordered or Equal/// `b` (four 32-bit floating point numbers) elements are unordered or equal,__msa_fcueq_d/// `b` (two 64-bit floating point numbers) elements are unordered or equal,__msa_fcule_w/// Vector Floating-Point Quiet Compare Unordered or Less or Equal/// elements if the corresponding elements in `a` (four 32-bit floating point numbers)/// are unordered or less than or equal to `b` (four 32-bit floating point numbers) elements,__msa_fcule_d/// elements if the corresponding elements in `a` (two 64-bit floating point numbers)/// are unordered or less than or equal to `b` (two 64-bit floating point numbers) elements,__msa_fcult_w/// Vector Floating-Point Quiet Compare Unordered or Less Than/// are unordered or less than `b` (four 32-bit floating point numbers) elements,__msa_fcult_d/// are unordered or less than `b` (two 64-bit floating point numbers) elements,__msa_fcun_w/// Vector Floating-Point Quiet Compare Unordered/// elements if the corresponding `a` (four 32-bit floating point numbers)/// and `b` (four 32-bit floating point numbers) elements are unordered,/// i.e. at least one element is a NaN value, otherwise set all bits to 0.__msa_fcun_d/// elements if the corresponding `a` (two 64-bit floating point numbers)/// and `b` (two 64-bit floating point numbers) elements are unordered,__msa_fcune_w/// Vector Floating-Point Quiet Compare Unordered or Not Equal/// and `b` (four 32-bit floating point numbers) elements are unordered or not equal,__msa_fcune_d/// and `b` (two 64-bit floating point numbers) elements are unordered or not equal,__msa_fdiv_w/// Vector Floating-Point Division/// are divided by the floating-point elements in vector `b` (four 32-bit floating point numbers).__msa_fdiv_d/// are divided by the floating-point elements in vector `b` (two 64-bit floating point numbers).__msa_fexdo_w/// Vector Floating-Point Down-Convert Interchange Format/// and vector `b` (two 64-bit floating point numbers) are down-converted/// to a smaller interchange format, i.e. from 64-bit to 32-bit, or from 32-bit to 16-bit.__msa_fexp2_w/// are scaled, i.e. multiplied, by 2 to the power of integer elements in vector `b`__msa_fexp2_d__msa_fexupl_d/// Vector Floating-Point Up-Convert Interchange Format Left/// The left half floating-point elements in vector `a` (four 32-bit floating point numbers)/// are up-converted to a larger interchange format,/// i.e. from 16-bit to 32-bit, or from 32-bit to 64-bit.__msa_fexupr_d/// The right half floating-point elements in vector `a` (four 32-bit floating point numbers)__msa_ffint_s_w/// Vector Floating-Point Round and Convert from Signed Integer/// are converted to floating-point values.__msa_ffint_s_d__msa_ffint_u_w/// Vector Floating-Point Round and Convert from Unsigned Integer__msa_ffint_u_d__msa_ffql_w/// Vector Floating-Point Convert from Fixed-Point Left/// The left half fixed-point elements in vector `a` (eight signed 16-bit integer numbers)/// are up-converted to floating-point data format./// i.e. from 16-bit Q15 to 32-bit floating-point, or from 32-bit Q31 to 64-bit floating-point.__msa_ffql_d/// The left half fixed-point elements in vector `a` (four signed 32-bit integer numbers)__msa_ffqr_w/// The right half fixed-point elements in vector `a` (eight signed 16-bit integer numbers)__msa_ffqr_d/// The right half fixed-point elements in vector `a` (four signed 32-bit integer numbers)__msa_fill_b/// Vector Fill from GPR/// Replicate GPR rs value to all elements in vector (sixteen signed 8-bit integer numbers)./// If the source GPR is wider than the destination data format, the destination's elements/// will be set to the least significant bits of the GPR.__msa_fill_h/// Replicate GPR rs value to all elements in vector (eight signed 16-bit integer numbers).__msa_fill_w/// Replicate GPR rs value to all elements in vector (four signed 32-bit integer numbers).__msa_fill_d/// Replicate GPR rs value to all elements in vector (two signed 64-bit integer numbers).__msa_flog2_w/// Vector Floating-Point Base 2 Logarithm/// The signed integral base 2 exponents of floating-point elements in vector `a`/// (four 32-bit floating point numbers) are written as floating-point values to vector elements/// (four 32-bit floating point numbers).__msa_flog2_d/// (two 64-bit floating point numbers) are written as floating-point values to vector elements/// (two 64-bit floating point numbers).__msa_fmadd_w/// Vector Floating-Point Multiply-Add/// The floating-point elements in vector `b` (four 32-bit floating point numbers)/// multiplied by floating-point elements in vector `c` (four 32-bit floating point numbers)/// are added to the floating-point elements in vector `a` (four 32-bit floating point numbers).__msa_fmadd_d/// The floating-point elements in vector `b` (two 64-bit floating point numbers)/// multiplied by floating-point elements in vector `c` (two 64-bit floating point numbers)/// are added to the floating-point elements in vector `a` (two 64-bit floating point numbers).__msa_fmax_w/// Vector Floating-Point Maximum/// The largest values between corresponding floating-point elements in vector `a`/// (four 32-bit floating point numbers) and vector `b` (four 32-bit floating point numbers)/// are written to vector (four 32-bit floating point numbers).__msa_fmax_d/// (two 64-bit floating point numbers) and vector `b` (two 64-bit floating point numbers)/// are written to vector (two 64-bit floating point numbers).__msa_fmax_a_w/// Vector Floating-Point Maximum Based on Absolute Values/// The value with the largest magnitude, i.e. absolute value, between corresponding/// floating-point elements in vector `a` (four 32-bit floating point numbers)/// and vector `b` (four 32-bit floating point numbers)__msa_fmax_a_d/// floating-point elements in vector `a` (two 64-bit floating point numbers)/// and vector `b` (two 64-bit floating point numbers)__msa_fmin_w/// Vector Floating-Point Minimum/// The smallest values between corresponding floating-point elements in vector `a`__msa_fmin_d__msa_fmin_a_w/// Vector Floating-Point Minimum Based on Absolute Values/// The value with the smallest magnitude, i.e. absolute value, between corresponding__msa_fmin_a_d__msa_fmsub_w/// Vector Floating-Point Multiply-Sub/// are subtracted from the floating-point elements in vector `a` (four 32-bit floating point numbers).__msa_fmsub_d/// are subtracted from the floating-point elements in vector `a` (two 64-bit floating point numbers).__msa_fmul_w/// Vector Floating-Point Multiplication/// The floating-point elements in vector `a` (four 32-bit floating point numbers) are/// multiplied by floating-point elements in vector `b` (four 32-bit floating point numbers).__msa_fmul_d/// The floating-point elements in vector `a` (two 64-bit floating point numbers) are/// multiplied by floating-point elements in vector `b` (two 64-bit floating point numbers).__msa_frint_w/// Vector Floating-Point Round to Integer/// are rounded to an integral valued floating-point number in the same format based/// on the rounding mode bits RM in MSA Control and Status Register MSACSR.__msa_frint_d__msa_frcp_w/// Vector Approximate Floating-Point Reciprocal/// The reciprocals of floating-point elements in vector `a` (four 32-bit floating point numbers)/// are calculated and the result is written to vector (four 32-bit floating point numbers).__msa_frcp_d/// The reciprocals of floating-point elements in vector `a` (two 64-bit floating point numbers)/// are calculated and the result is written to vector (two 64-bit floating point numbers).__msa_frsqrt_w/// Vector Approximate Floating-Point Reciprocal of Square Root/// The reciprocals of the square roots of floating-point elements in vector `a` (four 32-bit floating point numbers)__msa_frsqrt_d/// The reciprocals of the square roots of floating-point elements in vector `a` (two 64-bit floating point numbers)__msa_fsaf_w/// Vector Floating-Point Signaling Compare Always False/// Set all bits to 0 in vector (four signed 32-bit integer numbers) elements./// Signaling and quiet NaN elements in vector `a` (four 32-bit floating point numbers)/// In case of a floating-point exception, the default result has all bits set to 0.__msa_fsaf_d/// Set all bits to 0 in vector (two signed 64-bit integer numbers) elements./// Signaling and quiet NaN elements in vector `a` (two 64-bit floating point numbers)__msa_fseq_w/// Vector Floating-Point Signaling Compare Equal/// if the corresponding `a` (four 32-bit floating point numbers)/// and `b` (four 32-bit floating point numbers) elements are equal, otherwise set all bits to 0.__msa_fseq_d/// if the corresponding `a` (two 64-bit floating point numbers)/// and `b` (two 64-bit floating point numbers) elements are equal, otherwise set all bits to 0.__msa_fsle_w/// Vector Floating-Point Signaling Compare Less or Equal/// if the corresponding `a` (four 32-bit floating point numbers) elements/// are less than or equal to `b` (four 32-bit floating point numbers) elements, otherwise set all bits to 0.__msa_fsle_d/// if the corresponding `a` (two 64-bit floating point numbers) elements/// are less than or equal to `b` (two 64-bit floating point numbers) elements, otherwise set all bits to 0.__msa_fslt_w/// Vector Floating-Point Signaling Compare Less Than/// are less than `b` (four 32-bit floating point numbers) elements, otherwise set all bits to 0.__msa_fslt_d/// are less than `b` (two 64-bit floating point numbers) elements, otherwise set all bits to 0.__msa_fsne_w/// Vector Floating-Point Signaling Compare Not Equal/// if the corresponding `a` (four 32-bit floating point numbers) and/// `b` (four 32-bit floating point numbers) elements are not equal, otherwise set all bits to 0.__msa_fsne_d/// if the corresponding `a` (two 64-bit floating point numbers) and/// `b` (two 64-bit floating point numbers) elements are not equal, otherwise set all bits to 0.__msa_fsor_w/// Vector Floating-Point Signaling Compare Ordered/// `b` (four 32-bit floating point numbers) elements are ordered,/// i.e. both elements are not NaN values, otherwise set all bits to 0.__msa_fsor_d/// `b` (two 64-bit floating point numbers) elements are ordered,__msa_fsqrt_w/// Vector Floating-Point Square Root/// The square roots of floating-point elements in vector `a`/// (four 32-bit floating point numbers) are written to vector/// (four 32-bit floating point numbers) elements are ordered,.__msa_fsqrt_d/// (two 64-bit floating point numbers) are written to vector/// (two 64-bit floating point numbers) elements are ordered,.__msa_fsub_w/// Vector Floating-Point Subtraction/// are subtracted from the floating-point elements in vector `a`__msa_fsub_d__msa_fsueq_w__msa_fsueq_d__msa_fsule_w/// Vector Floating-Point Signaling Compare Unordered or Less or Equal/// if the corresponding `a` (four 32-bit floating point numbers) elements are/// unordered or less than or equal to `b` (four 32-bit floating point numbers) elements,__msa_fsule_d/// if the corresponding `a` (two 64-bit floating point numbers) elements are/// unordered or less than or equal to `b` (two 64-bit floating point numbers) elements,__msa_fsult_w/// Vector Floating-Point Signaling Compare Unordered or Less Than__msa_fsult_d__msa_fsun_w/// Vector Floating-Point Signaling Compare Unordered/// `b` (four 32-bit floating point numbers) elements are unordered,__msa_fsun_d/// `b` (two 64-bit floating point numbers) elements are unordered,__msa_fsune_w/// Vector Floating-Point Signaling Compare Unordered or Not Equal/// `b` (four 32-bit floating point numbers) elements are unordered or not equal,__msa_fsune_d/// `b` (two 64-bit floating point numbers) elements are unordered or not equal,__msa_ftint_s_w/// Vector Floating-Point Convert to Signed Integer///The elements in vector `a` (four 32-bit floating point numbers)/// are rounded and converted to signed integer values based on the/// rounding mode bits RM in MSA Control and Status Register MSACSR.__msa_ftint_s_d///The elements in vector `a` (two 64-bit floating point numbers)__msa_ftint_u_w/// Vector Floating-Point Convert to Unsigned Integer/// The elements in vector `a` (four 32-bit floating point numbers)__msa_ftint_u_d/// The elements in vector `a` (two 64-bit floating point numbers)__msa_ftq_h/// Vector Floating-Point Convert to Fixed-Point/// and `b` (four 32-bit floating point numbers) are down-converted to a fixed-point/// representation, i.e. from 64-bit floating-point to 32-bit Q31 fixed-point/// representation, or from 32-bit floating-point to 16-bit Q15 fixed-point representation.__msa_ftq_w/// and `b` (two 64-bit floating point numbers) are down-converted to a fixed-point__msa_ftrunc_s_w/// Vector Floating-Point Truncate and Convert to Signed Integer/// are truncated, i.e. rounded toward zero, to signed integer values.__msa_ftrunc_s_d__msa_ftrunc_u_w/// Vector Floating-Point Truncate and Convert to Unsigned Integer/// are truncated, i.e. rounded toward zero, to unsigned integer values.__msa_ftrunc_u_d__msa_hadd_s_h/// Vector Signed Horizontal Add/// The sign-extended odd elements in vector `a` (sixteen signed 8-bit integer numbers)/// are added to the sign-extended even elements in vector `b` (sixteen signed 8-bit integer numbers)/// producing a result twice the size of the input operands.__msa_hadd_s_w/// The sign-extended odd elements in vector `a` (eight signed 16-bit integer numbers)/// are added to the sign-extended even elements in vector `b` (eight signed 16-bit integer numbers)__msa_hadd_s_d/// The sign-extended odd elements in vector `a` (four signed 32-bit integer numbers)/// are added to the sign-extended even elements in vector `b` (four signed 32-bit integer numbers)__msa_hadd_u_h/// Vector Unsigned Horizontal Add/// The zero-extended odd elements in vector `a` (sixteen unsigned 8-bit integer numbers)/// are added to the zero-extended even elements in vector `b` (sixteen unsigned 8-bit integer numbers)__msa_hadd_u_w/// The zero-extended odd elements in vector `a` (eight unsigned 16-bit integer numbers)/// are added to the zero-extended even elements in vector `b` (eight unsigned 16-bit integer numbers)__msa_hadd_u_d/// The zero-extended odd elements in vector `a` (four unsigned 32-bit integer numbers)/// are added to the zero-extended even elements in vector `b` (four unsigned 32-bit integer numbers)__msa_hsub_s_h/// Vector Signed Horizontal Subtract/// The sign-extended odd elements in vector `b` (sixteen signed 8-bit integer numbers)/// are subtracted from the sign-extended elements in vector `a` (sixteen signed 8-bit integer numbers)__msa_hsub_s_w/// The sign-extended odd elements in vector `b` (eight signed 16-bit integer numbers)/// are subtracted from the sign-extended elements in vector `a` (eight signed 16-bit integer numbers)__msa_hsub_s_d/// The sign-extended odd elements in vector `b` (four signed 32-bit integer numbers)/// are subtracted from the sign-extended elements in vector `a` (four signed 32-bit integer numbers)__msa_hsub_u_h/// Vector Unsigned Horizontal Subtract/// The zero-extended odd elements in vector `b` (sixteen unsigned 8-bit integer numbers)/// are subtracted from the zero-extended elements in vector `a` (sixteen unsigned 8-bit integer numbers)__msa_hsub_u_w/// The zero-extended odd elements in vector `b` (eight unsigned 16-bit integer numbers)/// are subtracted from the zero-extended elements in vector `a` (eight unsigned 16-bit integer numbers)__msa_hsub_u_d/// The zero-extended odd elements in vector `b` (four unsigned 32-bit integer numbers)/// are subtracted from the zero-extended elements in vector `a` (four unsigned 32-bit integer numbers)__msa_ilvev_b/// Vector Interleave Even/// Even elements in vectors `a` (sixteen signed 8-bit integer numbers)/// and vector `b` (sixteen signed 8-bit integer numbers) are copied to the result/// (sixteen signed 8-bit integer numbers)/// alternating one element from `a` with one element from `b`.__msa_ilvev_h/// Even elements in vectors `a` (eight signed 16-bit integer numbers)/// and vector `b` (eight signed 16-bit integer numbers) are copied to the result/// (eight signed 16-bit integer numbers)__msa_ilvev_w/// Even elements in vectors `a` (four signed 32-bit integer numbers)/// and vector `b` (four signed 32-bit integer numbers) are copied to the result/// (four signed 32-bit integer numbers)__msa_ilvev_d/// Even elements in vectors `a` (two signed 64-bit integer numbers)/// and vector `b` (two signed 64-bit integer numbers) are copied to the result/// (two signed 64-bit integer numbers)__msa_ilvl_b/// Vector Interleave Left/// The left half elements in vectors `a` (sixteen signed 8-bit integer numbers)__msa_ilvl_h/// The left half elements in vectors `a` (eight signed 16-bit integer numbers)__msa_ilvl_w/// The left half elements in vectors `a` (four signed 32-bit integer numbers)__msa_ilvl_d/// The left half elements in vectors `a` (two signed 64-bit integer numbers)__msa_ilvod_b/// Vector Interleave Odd/// Odd elements in vectors `a` (sixteen signed 8-bit integer numbers)__msa_ilvod_h/// Odd elements in vectors `a` (eight signed 16-bit integer numbers)__msa_ilvod_w/// Odd elements in vectors `a` (four signed 32-bit integer numbers)__msa_ilvod_d/// Odd elements in vectors `a` (two signed 64-bit integer numbers)__msa_ilvr_b/// Vector Interleave Right/// The right half elements in vectors `a` (sixteen signed 8-bit integer numbers)__msa_ilvr_h/// The right half elements in vectors `a` (eight signed 16-bit integer numbers)__msa_ilvr_w/// The right half elements in vectors `a` (four signed 32-bit integer numbers)__msa_ilvr_d/// The right half elements in vectors `a` (two signed 64-bit integer numbers)__msa_insert_b/// GPR Insert Element/// Set element `imm4` in vector `a` (sixteen signed 8-bit integer numbers) to GPR `c` value./// All other elements in vector `a` are unchanged. If the source GPR is wider than the/// destination data format, the destination's elements will be set to the least significant bits of the GPR.__msa_insert_h/// Set element `imm3` in vector `a` (eight signed 16-bit integer numbers) to GPR `c` value.__msa_insert_w/// Set element `imm2` in vector `a` (four signed 32-bit integer numbers) to GPR `c` value.__msa_insert_d/// Set element `imm1` in vector `a` (two signed 64-bit integer numbers) to GPR `c` value.__msa_insve_b/// Element Insert Element/// Set element `imm1` in the result vector `a` (sixteen signed 8-bit integer numbers) to element 0/// in vector `c` (sixteen signed 8-bit integer numbers) value./// All other elements in vector `a` are unchanged.__msa_insve_h/// Set element `imm1` in the result vector `a` (eight signed 16-bit integer numbers) to element 0/// in vector `c` (eight signed 16-bit integer numbers) value.__msa_insve_w/// Set element `imm1` in the result vector `a` (four signed 32-bit integer numbers) to element 0/// in vector `c` (four signed 32-bit integer numbers) value.__msa_insve_d/// Set element `imm1` in the result vector `a` (two signed 64-bit integer numbers) to element 0/// in vector `c` (two signed 64-bit integer numbers) value.__msa_ld_b/// Vector Load/// The WRLEN / 8 bytes at the effective memory location addressed by the base/// `mem_addr` and the 10-bit signed immediate offset `imm_s10` are fetched and placed in/// the vector (sixteen signed 8-bit integer numbers) value.__msa_ld_h/// `mem_addr` and the 10-bit signed immediate offset `imm_s11` are fetched and placed in/// the vector (eight signed 16-bit integer numbers) value.__msa_ld_w/// `mem_addr` and the 10-bit signed immediate offset `imm_s12` are fetched and placed in/// the vector (four signed 32-bit integer numbers) value.__msa_ld_d/// `mem_addr` and the 10-bit signed immediate offset `imm_s13` are fetched and placed in/// the vector (two signed 64-bit integer numbers) value.__msa_ldi_b/// Immediate Load/// The signed immediate imm_s10 is replicated in all vector/// (sixteen signed 8-bit integer numbers) elements. For byte elements,/// only the least significant 8 bits of imm_s10 will be used.__msa_ldi_h/// (eight signed 16-bit integer numbers) elements. For byte elements,__msa_ldi_w/// (four signed 32-bit integer numbers) elements. For byte elements,__msa_ldi_d/// (two signed 64-bit integer numbers) elements. For byte elements,__msa_madd_q_h/// Vector Fixed-Point Multiply and Add/// The products of fixed-point elements in `b` (eight signed 16-bit integer numbers)/// by fixed-point elements in vector `c` (eight signed 16-bit integer numbers)/// are added to the fixed-point elements in vector `a` (eight signed 16-bit integer numbers)./// The multiplication result is not saturated, i.e. exact (-1) * (-1) = 1 is added to the destination./// The saturated fixed-point results are stored to vector `a`.__msa_madd_q_w/// The products of fixed-point elements in `b` (four signed 32-bit integer numbers)/// by fixed-point elements in vector `c` (four signed 32-bit integer numbers)/// are added to the fixed-point elements in vector `a` (four signed 32-bit integer numbers).__msa_maddr_q_h/// Vector Fixed-Point Multiply and Add Rounded/// The rounded and saturated fixed-point results are stored to vector `a`.__msa_maddr_q_w__msa_maddv_b/// Vector Multiply and Add/// The integer elements in vector `b` (sixteen signed 8-bit integer numbers)/// are multiplied by integer elements in vector `c` (sixteen signed 8-bit integer numbers)/// and added to the integer elements in vector `a` (sixteen signed 8-bit integer numbers)./// The most significant half of the multiplication result is discarded.__msa_maddv_h/// The integer elements in vector `b` (eight signed 16-bit integer numbers)/// are multiplied by integer elements in vector `c` (eight signed 16-bit integer numbers)/// and added to the integer elements in vector `a` (eight signed 16-bit integer numbers).__msa_maddv_w/// The integer elements in vector `b` (four signed 32-bit integer numbers)/// are multiplied by integer elements in vector `c` (four signed 32-bit integer numbers)/// and added to the integer elements in vector `a` (four signed 32-bit integer numbers).__msa_maddv_d/// The integer elements in vector `b` (two signed 64-bit integer numbers)/// are multiplied by integer elements in vector `c` (two signed 64-bit integer numbers)/// and added to the integer elements in vector `a` (two signed 64-bit integer numbers).__msa_max_a_b/// Vector Maximum Based on Absolute Values/// signed elements in vector `a` (sixteen signed 8-bit integer numbers) and/// `b` (sixteen signed 8-bit integer numbers) are written to vector/// (sixteen signed 8-bit integer numbers).__msa_max_a_h/// signed elements in vector `a` (eight signed 16-bit integer numbers) and/// `b` (eight signed 16-bit integer numbers) are written to vector__msa_max_a_w/// signed elements in vector `a` (four signed 32-bit integer numbers) and/// `b` (four signed 32-bit integer numbers) are written to vector__msa_max_a_d/// signed elements in vector `a` (two signed 64-bit integer numbers) and/// `b` (two signed 64-bit integer numbers) are written to vector__msa_max_s_b/// Vector Signed Maximum/// Maximum values between signed elements in vector `a` (sixteen signed 8-bit integer numbers)/// and signed elements in vector `b` (sixteen signed 8-bit integer numbers) are written to vector__msa_max_s_h/// Maximum values between signed elements in vector `a` (eight signed 16-bit integer numbers)/// and signed elements in vector `b` (eight signed 16-bit integer numbers) are written to vector__msa_max_s_w/// Maximum values between signed elements in vector `a` (four signed 32-bit integer numbers)/// and signed elements in vector `b` (four signed 32-bit integer numbers) are written to vector__msa_max_s_d/// Maximum values between signed elements in vector `a` (two signed 64-bit integer numbers)/// and signed elements in vector `b` (two signed 64-bit integer numbers) are written to vector__msa_max_u_b/// Vector Unsigned Maximum/// Maximum values between unsigned elements in vector `a` (sixteen unsigned 8-bit integer numbers)/// and unsigned elements in vector `b` (sixteen unsigned 8-bit integer numbers) are written to vector/// (sixteen unsigned 8-bit integer numbers).__msa_max_u_h/// Maximum values between unsigned elements in vector `a` (eight unsigned 16-bit integer numbers)/// and unsigned elements in vector `b` (eight unsigned 16-bit integer numbers) are written to vector/// (eight unsigned 16-bit integer numbers).__msa_max_u_w/// Maximum values between unsigned elements in vector `a` (four unsigned 32-bit integer numbers)/// and unsigned elements in vector `b` (four unsigned 32-bit integer numbers) are written to vector/// (four unsigned 32-bit integer numbers).__msa_max_u_d/// Maximum values between unsigned elements in vector `a` (two unsigned 64-bit integer numbers)/// and unsigned elements in vector `b` (two unsigned 64-bit integer numbers) are written to vector/// (two unsigned 64-bit integer numbers).__msa_maxi_s_b/// Immediate Signed Maximum/// and the 5-bit signed immediate imm_s5 are written to vector__msa_maxi_s_h__msa_maxi_s_w__msa_maxi_s_d__msa_maxi_u_b/// Immediate Unsigned Maximum/// and the 5-bit unsigned immediate `imm5` are written to vector__msa_maxi_u_h__msa_maxi_u_w__msa_maxi_u_d__msa_min_a_b/// Vector Minimum Based on Absolute Value__msa_min_a_h__msa_min_a_w__msa_min_a_d__msa_min_s_b/// Vector Signed Minimum/// Minimum values between signed elements in vector `a` (sixteen signed 8-bit integer numbers)__msa_min_s_h/// Minimum values between signed elements in vector `a` (eight signed 16-bit integer numbers)__msa_min_s_w/// Minimum values between signed elements in vector `a` (four signed 32-bit integer numbers)__msa_min_s_d/// Minimum values between signed elements in vector `a` (two signed 64-bit integer numbers)__msa_mini_s_b/// Immediate Signed Minimum__msa_mini_s_h__msa_mini_s_w__msa_mini_s_d__msa_min_u_b/// Vector Unsigned Minimum/// Minimum values between unsigned elements in vector `a` (sixteen unsigned 8-bit integer numbers)__msa_min_u_h/// Minimum values between unsigned elements in vector `a` (eight unsigned 16-bit integer numbers)__msa_min_u_w/// Minimum values between unsigned elements in vector `a` (four unsigned 32-bit integer numbers)__msa_min_u_d/// Minimum values between unsigned elements in vector `a` (two unsigned 64-bit integer numbers)__msa_mini_u_b/// Immediate Unsigned Minimum__msa_mini_u_h__msa_mini_u_w__msa_mini_u_d__msa_mod_s_b/// Vector Signed Modulo/// The remainder of the same sign as the dividend is written to vector/// (sixteen signed 8-bit integer numbers). If a divisor element vector `b` is zero,/// the result value is UNPREDICTABLE.__msa_mod_s_h/// (eight signed 16-bit integer numbers). If a divisor element vector `b` is zero,__msa_mod_s_w/// (four signed 32-bit integer numbers). If a divisor element vector `b` is zero,__msa_mod_s_d/// (two signed 64-bit integer numbers). If a divisor element vector `b` is zero,__msa_mod_u_b/// Vector Unsigned Modulo/// (sixteen unsigned 8-bit integer numbers). If a divisor element vector `b` is zero,__msa_mod_u_h/// (eight unsigned 16-bit integer numbers). If a divisor element vector `b` is zero,__msa_mod_u_w/// (four unsigned 32-bit integer numbers). If a divisor element vector `b` is zero,__msa_mod_u_d/// (two unsigned 64-bit integer numbers). If a divisor element vector `b` is zero,__msa_move_v/// Vector Move/// Copy all WRLEN bits in vector `a` (eight signed 16-bit integer numbers)/// to vector (eight signed 16-bit integer numbers).__msa_msub_q_h/// Vector Fixed-Point Multiply and Subtract/// The product of fixed-point elements in vector `c` (eight signed 16-bit integer numbers)/// by fixed-point elements in vector `b` (eight signed 16-bit integer numbers)/// are subtracted from the fixed-point elements in vector `a`/// (eight signed 16-bit integer numbers). The multiplication result is not saturated,/// i.e. exact (-1) * (-1) = 1 is subtracted from the destination./// The saturated fixed-point results are stored back to vector `a`.__msa_msub_q_w/// The product of fixed-point elements in vector `c` (four signed 32-bit integer numbers)/// by fixed-point elements in vector `b` (four signed 32-bit integer numbers)/// (four signed 32-bit integer numbers). The multiplication result is not saturated,__msa_msubr_q_h/// Vector Fixed-Point Multiply and Subtract Rounded/// The rounded and saturated fixed-point results are stored back to vector `a`.__msa_msubr_q_w__msa_msubv_b/// Vector Multiply and Subtract/// The integer elements in vector `c` (sixteen signed 8-bit integer numbers)/// are multiplied by integer elements in vector `b` (sixteen signed 8-bit integer numbers)/// and subtracted from the integer elements in vector `a` (sixteen signed 8-bit integer numbers).__msa_msubv_h/// The integer elements in vector `c` (eight signed 16-bit integer numbers)/// are multiplied by integer elements in vector `b` (eight signed 16-bit integer numbers)/// and subtracted from the integer elements in vector `a` (eight signed 16-bit integer numbers).__msa_msubv_w/// The integer elements in vector `c` (four signed 32-bit integer numbers)/// are multiplied by integer elements in vector `b` (four signed 32-bit integer numbers)/// and subtracted from the integer elements in vector `a` (four signed 32-bit integer numbers).__msa_msubv_d/// The integer elements in vector `c` (two signed 64-bit integer numbers)/// are multiplied by integer elements in vector `b` (two signed 64-bit integer numbers)/// and subtracted from the integer elements in vector `a` (two signed 64-bit integer numbers).__msa_mul_q_h/// Vector Fixed-Point Multiply/// The fixed-point elements in vector `a` (eight signed 16-bit integer numbers)/// multiplied by fixed-point elements in vector `b` (eight signed 16-bit integer numbers).__msa_mul_q_w/// The fixed-point elements in vector `a` (four signed 32-bit integer numbers)/// multiplied by fixed-point elements in vector `b` (four signed 32-bit integer numbers).__msa_mulr_q_h/// Vector Fixed-Point Multiply Rounded/// The rounded result is written to vector (eight signed 16-bit integer numbers).__msa_mulr_q_w/// The rounded result is written to vector (four signed 32-bit integer numbers).__msa_mulv_b/// Vector Multiply/// The integer elements in vector `a` (sixteen signed 8-bit integer numbers)/// are multiplied by integer elements in vector `b` (sixteen signed 8-bit integer numbers).__msa_mulv_h/// The integer elements in vector `a` (eight signed 16-bit integer numbers)/// are multiplied by integer elements in vector `b` (eight signed 16-bit integer numbers).__msa_mulv_w/// The integer elements in vector `a` (four signed 32-bit integer numbers)/// are multiplied by integer elements in vector `b` (four signed 32-bit integer numbers).__msa_mulv_d/// The integer elements in vector `a` (two signed 64-bit integer numbers)/// are multiplied by integer elements in vector `b` (two signed 64-bit integer numbers).__msa_nloc_b/// Vector Leading Ones Count/// The number of leading ones for elements in vector `a` (sixteen signed 8-bit integer numbers)/// is stored to the elements in vector (sixteen signed 8-bit integer numbers).__msa_nloc_h/// The number of leading ones for elements in vector `a` (eight signed 16-bit integer numbers)/// is stored to the elements in vector (eight signed 16-bit integer numbers).__msa_nloc_w/// The number of leading ones for elements in vector `a` (four signed 32-bit integer numbers)/// is stored to the elements in vector (four signed 32-bit integer numbers).__msa_nloc_d/// The number of leading ones for elements in vector `a` (two signed 64-bit integer numbers)/// is stored to the elements in vector (two signed 64-bit integer numbers).__msa_nlzc_b/// Vector Leading Zeros Count/// The number of leading zeros for elements in vector `a` (sixteen signed 8-bit integer numbers)__msa_nlzc_h/// The number of leading zeros for elements in vector `a` (eight signed 16-bit integer numbers)__msa_nlzc_w/// The number of leading zeros for elements in vector `a` (four signed 32-bit integer numbers)__msa_nlzc_d/// The number of leading zeros for elements in vector `a` (two signed 64-bit integer numbers)__msa_nor_v/// Vector Logical Negated Or/// in a bitwise logical NOR operation. The result is written to vector__msa_nori_b/// Immediate Logical Negated Or/// is combined with the 8-bit immediate `imm8`__msa_or_v/// Vector Logical Or/// in a bitwise logical OR operation. The result is written to vector__msa_ori_b/// Immediate Logical Or__msa_pckev_b/// Vector Pack Even/// are copied to the left half of the result vector and even elements in vector `b`/// (sixteen signed 8-bit integer numbers) are copied to the right half of the result vector.__msa_pckev_h/// (eight signed 16-bit integer numbers) are copied to the right half of the result vector.__msa_pckev_w/// (four signed 32-bit integer numbers) are copied to the right half of the result vector.__msa_pckev_d/// (two signed 64-bit integer numbers) are copied to the right half of the result vector.__msa_pckod_b/// Vector Pack Odd/// are copied to the left half of the result vector and odd elements in vector `b`__msa_pckod_h__msa_pckod_w__msa_pckod_d__msa_pcnt_b/// Vector Population Count/// The number of bits set to 1 for elements in vector `a` (sixteen signed 8-bit integer numbers)/// is stored to the elements in the result vector (sixteen signed 8-bit integer numbers).__msa_pcnt_h/// The number of bits set to 1 for elements in vector `a` (eight signed 16-bit integer numbers)/// is stored to the elements in the result vector (eight signed 16-bit integer numbers).__msa_pcnt_w/// The number of bits set to 1 for elements in vector `a` (four signed 32-bit integer numbers)/// is stored to the elements in the result vector (four signed 32-bit integer numbers).__msa_pcnt_d/// The number of bits set to 1 for elements in vector `a` (two signed 64-bit integer numbers)/// is stored to the elements in the result vector (two signed 64-bit integer numbers).__msa_sat_s_b/// Immediate Signed Saturate/// Signed elements in vector `a` (sixteen signed 8-bit integer numbers)/// are saturated to signed values of `imm3+1` bits without changing the data width./// The result is stored in the vector (sixteen signed 8-bit integer numbers).__msa_sat_s_h/// Signed elements in vector `a` (eight signed 16-bit integer numbers)/// are saturated to signed values of `imm4+1` bits without changing the data width./// The result is stored in the vector (eight signed 16-bit integer numbers).__msa_sat_s_w/// Signed elements in vector `a` (four signed 32-bit integer numbers)/// are saturated to signed values of `imm5+1` bits without changing the data width./// The result is stored in the vector (four signed 32-bit integer numbers).__msa_sat_s_d/// Signed elements in vector `a` (two signed 64-bit integer numbers)/// are saturated to signed values of `imm6+1` bits without changing the data width./// The result is stored in the vector (two signed 64-bit integer numbers).__msa_sat_u_b/// Immediate Unsigned Saturate/// Unsigned elements in vector `a` (sixteen unsigned 8-bit integer numbers)/// are saturated to unsigned values of `imm3+1` bits without changing the data width./// The result is stored in the vector (sixteen unsigned 8-bit integer numbers).__msa_sat_u_h/// Unsigned elements in vector `a` (eight unsigned 16-bit integer numbers)/// are saturated to unsigned values of `imm4+1` bits without changing the data width./// The result is stored in the vector (eight unsigned 16-bit integer numbers).__msa_sat_u_w/// Unsigned elements in vector `a` (four unsigned 32-bit integer numbers)/// are saturated to unsigned values of `imm5+1` bits without changing the data width./// The result is stored in the vector (four unsigned 32-bit integer numbers).__msa_sat_u_d/// Unsigned elements in vector `a` (two unsigned 64-bit integer numbers)/// are saturated to unsigned values of `imm6+1` bits without changing the data width./// The result is stored in the vector (two unsigned 64-bit integer numbers).__msa_shf_b/// Immediate Set Shuffle Elements/// The set shuffle instruction works on 4-element sets./// All sets are shuffled in the same way: the element i82i+1..2i in `a`/// (sixteen signed 8-bit integer numbers) is copied over the element i in result vector/// (sixteen signed 8-bit integer numbers), where i is 0, 1, 2, 3.__msa_shf_h/// (eight signed 16-bit integer numbers) is copied over the element i in result vector/// (eight signed 16-bit integer numbers), where i is 0, 1, 2, 3.__msa_shf_w/// (four signed 32-bit integer numbers) is copied over the element i in result vector/// (four signed 32-bit integer numbers), where i is 0, 1, 2, 3.__msa_sld_b/// GPR Columns Slide/// Vector registers `a` (sixteen signed 8-bit integer numbers) and `b`/// (sixteen signed 8-bit integer numbers) contain 2-dimensional byte arrays (rectangles)/// stored row-wise with as many rows as bytes in integer data format df./// The two source rectangles `b` and `a` are concatenated horizontally in the order/// they appear in the syntax, i.e. first `a` and then `b`. Place a new destination/// rectangle over `b` and then slide it to the left over the concatenation of `a` and `b`/// by the number of columns given in GPR `c`./// GPR `c` value is interpreted modulo the number of columns in destination rectangle,/// or equivalently, the number of data format df elements in the destination vector.__msa_sld_h/// Vector registers `a` (eight signed 16-bit integer numbers) and `b`/// (eight signed 16-bit integer numbers) contain 2-dimensional byte arrays (rectangles)__msa_sld_w/// Vector registers `a` (four signed 32-bit integer numbers) and `b`/// (four signed 32-bit integer numbers) contain 2-dimensional byte arrays (rectangles)__msa_sld_d/// Vector registers `a` (two signed 64-bit integer numbers) and `b`/// (two signed 64-bit integer numbers) contain 2-dimensional byte arrays (rectangles)__msa_sldi_b/// Immediate Columns Slide/// by `imm1` columns.__msa_sldi_h__msa_sldi_w__msa_sldi_d__msa_sll_b/// Vector Shift Left/// are shifted left by the number of bits the elements in vector `b`/// (sixteen signed 8-bit integer numbers) specify modulo the size of the/// element in bits. The result is written to vector (sixteen signed 8-bit integer numbers).__msa_sll_h/// (eight signed 16-bit integer numbers) specify modulo the size of the/// element in bits. The result is written to vector (eight signed 16-bit integer numbers).__msa_sll_w/// (four signed 32-bit integer numbers) specify modulo the size of the/// element in bits. The result is written to vector (four signed 32-bit integer numbers).__msa_sll_d/// (two signed 64-bit integer numbers) specify modulo the size of the/// element in bits. The result is written to vector (two signed 64-bit integer numbers).__msa_slli_b/// Immediate Shift Left/// are shifted left by `imm4` bits.__msa_slli_h/// are shifted left by `imm3` bits.__msa_slli_w/// are shifted left by `imm2` bits.__msa_slli_d/// are shifted left by `imm1` bits.__msa_splat_b/// GPR Element Splat/// Replicate vector `a` (sixteen signed 8-bit integer numbers)/// element with index given by GPR `b` to all elements in vector/// (sixteen signed 8-bit integer numbers) GPR `b` value is interpreted/// modulo the number of data format df elements in the destination vector.__msa_splat_h/// Replicate vector `a` (eight signed 16-bit integer numbers)/// (eight signed 16-bit integer numbers) GPR `b` value is interpreted__msa_splat_w/// Replicate vector `a` (four signed 32-bit integer numbers)/// (four signed 32-bit integer numbers) GPR `b` value is interpreted__msa_splat_d/// Replicate vector `a` (two signed 64-bit integer numbers)/// (two signed 64-bit integer numbers) GPR `b` value is interpreted__msa_splati_b/// Immediate Element Splat/// Replicate element `imm4` in vector `a` (sixteen signed 8-bit integer numbers)/// to all elements in vector (sixteen signed 8-bit integer numbers).__msa_splati_h/// Replicate element `imm3` in vector `a` (eight signed 16-bit integer numbers)/// to all elements in vector (eight signed 16-bit integer numbers).__msa_splati_w/// Replicate element `imm2` in vector `a` (four signed 32-bit integer numbers)/// to all elements in vector (four signed 32-bit integer numbers).__msa_splati_d/// Replicate element `imm1` in vector `a` (two signed 64-bit integer numbers)/// to all elements in vector (two signed 64-bit integer numbers).__msa_sra_b/// Vector Shift Right Arithmetic/// are shifted right arithmetic by the number of bits the elements in vector `b`/// element in bits.The result is written to vector (sixteen signed 8-bit integer numbers).__msa_sra_h/// element in bits.The result is written to vector (eight signed 16-bit integer numbers).__msa_sra_w/// element in bits.The result is written to vector (four signed 32-bit integer numbers).__msa_sra_d/// element in bits.The result is written to vector (two signed 64-bit integer numbers).__msa_srai_b/// Immediate Shift Right Arithmetic/// are shifted right arithmetic by `imm3` bits.__msa_srai_h/// are shifted right arithmetic by `imm4` bits.__msa_srai_w/// are shifted right arithmetic by `imm5` bits.__msa_srai_d/// are shifted right arithmetic by `imm6` bits.__msa_srar_b/// Vector Shift Right Arithmetic Rounded/// element in bits.The most significant discarded bit is added to the shifted/// value (for rounding) and the result is written to vector (sixteen signed 8-bit integer numbers).__msa_srar_h/// value (for rounding) and the result is written to vector (eight signed 16-bit integer numbers).__msa_srar_w/// value (for rounding) and the result is written to vector (four signed 32-bit integer numbers).__msa_srar_d/// value (for rounding) and the result is written to vector (two signed 64-bit integer numbers).__msa_srari_b/// Immediate Shift Right Arithmetic Rounded/// are shifted right arithmetic by `imm3` bits.The most significant/// discarded bit is added to the shifted value (for rounding) and/// the result is written to vector (sixteen signed 8-bit integer numbers).__msa_srari_h/// are shifted right arithmetic by `imm4` bits.The most significant/// the result is written to vector (eight signed 16-bit integer numbers).__msa_srari_w/// are shifted right arithmetic by `imm5` bits.The most significant/// the result is written to vector (four signed 32-bit integer numbers).__msa_srari_d/// are shifted right arithmetic by `imm6` bits.The most significant/// the result is written to vector (two signed 64-bit integer numbers).__msa_srl_b/// Vector Shift Right Logical/// are shifted right logical by the number of bits the elements in vector `b`__msa_srl_h__msa_srl_w__msa_srl_d__msa_srli_b/// Immediate Shift Right Logical/// are shifted right logical by `imm4` bits.__msa_srli_h/// are shifted right logical by `imm3` bits.__msa_srli_w/// are shifted right logical by `imm2` bits.__msa_srli_d/// are shifted right logical by `imm1` bits.__msa_srlr_b/// Vector Shift Right Logical Rounded__msa_srlr_h__msa_srlr_w__msa_srlr_d__msa_srlri_b/// Immediate Shift Right Logical Rounded/// are shifted right logical by `imm6` bits.The most significant__msa_srlri_h__msa_srlri_w__msa_srlri_d__msa_st_b/// Vector Store/// The WRLEN / 8 bytes in vector `a` (sixteen signed 8-bit integer numbers)/// are stored as elements of data format df at the effective memory location/// addressed by the base `mem_addr` and the 10-bit signed immediate offset `imm_s10`.__msa_st_h/// The WRLEN / 8 bytes in vector `a` (eight signed 16-bit integer numbers)/// addressed by the base `mem_addr` and the 11-bit signed immediate offset `imm_s11`.__msa_st_w/// The WRLEN / 8 bytes in vector `a` (four signed 32-bit integer numbers)/// addressed by the base `mem_addr` and the 12-bit signed immediate offset `imm_s12`.__msa_st_d/// The WRLEN / 8 bytes in vector `a` (two signed 64-bit integer numbers)/// addressed by the base `mem_addr` and the 13-bit signed immediate offset `imm_s13`.__msa_subs_s_b/// Vector Signed Saturated Subtract of Signed Values/// The elements in vector `b` (sixteen signed 8-bit integer numbers)/// are subtracted from the elements in vector `a` (sixteen signed 8-bit integer numbers).__msa_subs_s_h/// The elements in vector `b` (eight signed 16-bit integer numbers)/// are subtracted from the elements in vector `a` (eight signed 16-bit integer numbers).__msa_subs_s_w/// The elements in vector `b` (four signed 32-bit integer numbers)/// are subtracted from the elements in vector `a` (four signed 32-bit integer numbers).__msa_subs_s_d/// The elements in vector `b` (two signed 64-bit integer numbers)/// are subtracted from the elements in vector `a` (two signed 64-bit integer numbers).__msa_subs_u_b/// Vector Unsigned Saturated Subtract of Unsigned Values/// The elements in vector `b` (sixteen unsigned 8-bit integer numbers)/// are subtracted from the elements in vector `a` (sixteen unsigned 8-bit integer numbers)./// Unsigned arithmetic is performed and under-flows clamp to 0 before writing/// the result to vector (sixteen unsigned 8-bit integer numbers).__msa_subs_u_h/// The elements in vector `b` (eight unsigned 16-bit integer numbers)/// are subtracted from the elements in vector `a` (eight unsigned 16-bit integer numbers)./// the result to vector (eight unsigned 16-bit integer numbers).__msa_subs_u_w/// The elements in vector `b` (four unsigned 32-bit integer numbers)/// are subtracted from the elements in vector `a` (four unsigned 32-bit integer numbers)./// the result to vector (four unsigned 32-bit integer numbers).__msa_subs_u_d/// The elements in vector `b` (two unsigned 64-bit integer numbers)/// are subtracted from the elements in vector `a` (two unsigned 64-bit integer numbers)./// the result to vector (two unsigned 64-bit integer numbers).__msa_subsus_u_b/// Vector Unsigned Saturated Subtract of Signed from Unsigned/// The signed elements in vector `b` (sixteen signed 8-bit integer numbers)/// are subtracted from the unsigned elements in vector `a` (sixteen unsigned 8-bit integer numbers)./// The signed result is unsigned saturated and written to/// to vector (sixteen unsigned 8-bit integer numbers).__msa_subsus_u_h/// The signed elements in vector `b` (eight signed 16-bit integer numbers)/// are subtracted from the unsigned elements in vector `a` (eight unsigned 16-bit integer numbers)./// to vector (eight unsigned 16-bit integer numbers).__msa_subsus_u_w/// The signed elements in vector `b` (four signed 6432it integer numbers)/// are subtracted from the unsigned elements in vector `a` (four unsigned 32-bit integer numbers)./// to vector (four unsigned 32-bit integer numbers).__msa_subsus_u_d/// The signed elements in vector `b` (two signed 64-bit integer numbers)/// are subtracted from the unsigned elements in vector `a` (two unsigned 64-bit integer numbers)./// to vector (two unsigned 64-bit integer numbers).__msa_subsuu_s_b/// Vector Signed Saturated Subtract of Unsigned Values/// The unsigned elements in vector `b` (sixteen unsigned 8-bit integer numbers)/// The signed result is signed saturated and written to__msa_subsuu_s_h/// The unsigned elements in vector `b` (eight unsigned 16-bit integer numbers)__msa_subsuu_s_w/// The unsigned elements in vector `b` (four unsigned 32-bit integer numbers)__msa_subsuu_s_d/// The unsigned elements in vector `b` (two unsigned 64-bit integer numbers)__msa_subv_b/// Vector Subtract__msa_subv_h__msa_subv_w__msa_subv_d__msa_subvi_b/// Immediate Subtract/// The 5-bit immediate unsigned value `imm5`__msa_subvi_h__msa_subvi_w__msa_subvi_d__msa_vshf_b/// Vector Data Preserving Shuffle/// The vector shuffle instructions selectively copy data elements from the/// concatenation of vectors `b` (sixteen signed 8-bit integer numbers)/// and `c` (sixteen signed 8-bit integer numbers) in to vector `a`/// (sixteen signed 8-bit integer numbers) based on the corresponding control element in `a`./// The least significant 6 bits in `a` control elements modulo the number of elements in/// the concatenated vectors `b`, `a` specify the index of the source element./// If bit 6 or bit 7 is 1, there will be no copy, but rather the destination element is set to 0.__msa_vshf_h/// concatenation of vectors `b` (eight signed 16-bit integer numbers)/// and `c` (eight signed 16-bit integer numbers) in to vector `a`/// (eight signed 16-bit integer numbers) based on the corresponding control element in `a`.__msa_vshf_w/// concatenation of vectors `b` (four signed 32-bit integer numbers)/// and `c` (four signed 32-bit integer numbers) in to vector `a`/// (four signed 32-bit integer numbers) based on the corresponding control element in `a`.__msa_vshf_d/// concatenation of vectors `b` (two signed 64-bit integer numbers)/// and `c` (two signed 64-bit integer numbers) in to vector `a`/// (two signed 64-bit integer numbers) based on the corresponding control element in `a`.__msa_xor_v/// Vector Logical Exclusive Or/// in a bitwise logical XOR operation. The result is written to vector__msa_xori_b/// Immediate Logical Exclusive Or/// Each byte of vector `a` (sixteen unsigned 8-bit integer numbers)test_msa_add_a_btest_msa_add_a_htest_msa_add_a_wtest_msa_add_a_dtest_msa_adds_a_btest_msa_adds_a_htest_msa_adds_a_wtest_msa_adds_a_dtest_msa_adds_s_btest_msa_adds_s_htest_msa_adds_s_wtest_msa_adds_s_dtest_msa_adds_u_btest_msa_adds_u_htest_msa_adds_u_wtest_msa_adds_u_dtest_msa_addv_btest_msa_addv_htest_msa_addv_wtest_msa_addv_dtest_msa_addvi_btest_msa_addvi_htest_msa_addvi_wtest_msa_addvi_dtest_msa_and_vtest_msa_andi_btest_msa_asub_s_btest_msa_asub_s_htest_msa_asub_s_wtest_msa_asub_s_dtest_msa_asub_u_btest_msa_asub_u_htest_msa_asub_u_wtest_msa_asub_u_dtest_msa_ave_s_btest_msa_ave_s_htest_msa_ave_s_wtest_msa_ave_s_dtest_msa_ave_u_btest_msa_ave_u_htest_msa_ave_u_wtest_msa_ave_u_dtest_msa_aver_s_btest_msa_aver_s_htest_msa_aver_s_wtest_msa_aver_s_dtest_msa_aver_u_btest_msa_aver_u_htest_msa_aver_u_wtest_msa_aver_u_dtest_msa_bclr_btest_msa_bclr_htest_msa_bclr_wtest_msa_bclr_dtest_msa_bclri_btest_msa_bclri_htest_msa_bclri_wtest_msa_bclri_dtest_msa_binsl_btest_msa_binsl_htest_msa_binsl_wtest_msa_binsl_dtest_msa_binsli_btest_msa_binsli_htest_msa_binsli_wtest_msa_binsli_dtest_msa_binsr_btest_msa_binsr_htest_msa_binsr_wtest_msa_binsr_dtest_msa_binsri_btest_msa_binsri_htest_msa_binsri_wtest_msa_binsri_dtest_msa_bmnz_vtest_msa_bmnzi_btest_msa_bmz_vtest_msa_bmzi_btest_msa_bneg_btest_msa_bneg_htest_msa_bneg_wtest_msa_bneg_dtest_msa_bnegi_btest_msa_bnegi_htest_msa_bnegi_wtest_msa_bnegi_dtest_msa_bnz_btest_msa_bnz_htest_msa_bnz_wtest_msa_bnz_dtest_msa_bnz_vtest_msa_bsel_vtest_msa_bseli_btest_msa_bset_btest_msa_bset_htest_msa_bset_wtest_msa_bset_dtest_msa_bseti_btest_msa_bseti_htest_msa_bseti_wtest_msa_bseti_dtest_msa_bz_btest_msa_bz_htest_msa_bz_wtest_msa_bz_dtest_msa_bz_vtest_msa_ceq_btest_msa_ceq_htest_msa_ceq_wtest_msa_ceq_dtest_msa_ceqi_btest_msa_ceqi_htest_msa_ceqi_wtest_msa_cle_s_btest_msa_cle_s_htest_msa_cle_s_wtest_msa_cle_s_dtest_msa_cle_u_btest_msa_cle_u_htest_msa_cle_u_wtest_msa_cle_u_dtest_msa_clei_s_btest_msa_clei_s_htest_msa_clei_s_wtest_msa_clei_u_btest_msa_clei_u_htest_msa_clei_u_wtest_msa_clei_u_dtest_msa_clt_s_btest_msa_clt_s_htest_msa_clt_s_wtest_msa_clt_s_dtest_msa_clt_u_btest_msa_clt_u_htest_msa_clt_u_wtest_msa_clt_u_dtest_msa_clti_s_btest_msa_clti_s_htest_msa_clti_s_wtest_msa_clti_u_btest_msa_clti_u_htest_msa_clti_u_wtest_msa_clti_u_dtest_msa_copy_s_btest_msa_copy_s_htest_msa_copy_s_wtest_msa_copy_s_dtest_msa_copy_u_btest_msa_copy_u_htest_msa_copy_u_wtest_msa_copy_u_dtest_msa_div_s_btest_msa_div_s_htest_msa_div_s_wtest_msa_div_s_dtest_msa_div_u_btest_msa_div_u_htest_msa_div_u_wtest_msa_div_u_dtest_msa_dotp_s_htest_msa_dotp_s_wtest_msa_dotp_s_dtest_msa_dotp_u_htest_msa_dotp_u_wtest_msa_dotp_u_dtest_msa_dpadd_s_htest_msa_dpadd_s_wtest_msa_dpadd_s_dtest_msa_dpadd_u_htest_msa_dpadd_u_wtest_msa_dpadd_u_dtest_msa_dpsub_s_htest_msa_dpsub_s_wtest_msa_dpsub_s_dtest_msa_dpsub_u_htest_msa_dpsub_u_wtest_msa_dpsub_u_dtest_msa_fadd_wtest_msa_fadd_dtest_msa_fcaf_w// Only observed beahiour should be SIGFPE signal// Can not be testedtest_msa_fcaf_dtest_msa_fceq_wtest_msa_fceq_dtest_msa_fclass_wtest_msa_fclass_dtest_msa_fcle_wtest_msa_fcle_dtest_msa_fclt_wtest_msa_fclt_dtest_msa_fcne_wtest_msa_fcne_dtest_msa_fcor_wtest_msa_fcor_dtest_msa_fcueq_wtest_msa_fcueq_dtest_msa_fcule_wtest_msa_fcule_dtest_msa_fcult_wtest_msa_fcult_dtest_msa_fcun_wtest_msa_fcun_dtest_msa_fcune_wtest_msa_fcune_dtest_msa_fdiv_wtest_msa_fdiv_dtest_msa_fexdo_wtest_msa_fexp2_wtest_msa_fexp2_dtest_msa_fexupl_dtest_msa_fexupr_dtest_msa_ffint_s_wtest_msa_ffint_s_dtest_msa_ffint_u_wtest_msa_ffint_u_dtest_msa_ffql_wtest_msa_ffql_dtest_msa_ffqr_wtest_msa_ffqr_dtest_msa_fill_btest_msa_fill_htest_msa_fill_wtest_msa_fill_dtest_msa_flog2_wtest_msa_flog2_dtest_msa_fmadd_wtest_msa_fmadd_dtest_msa_fmax_wtest_msa_fmax_dtest_msa_fmax_a_wtest_msa_fmax_a_dtest_msa_fmin_wtest_msa_fmin_dtest_msa_fmin_a_wtest_msa_fmin_a_dtest_msa_fmsub_wtest_msa_fmsub_dtest_msa_fmul_wtest_msa_fmul_dtest_msa_frint_wtest_msa_frint_dtest_msa_frcp_wtest_msa_frcp_dtest_msa_frsqrt_wtest_msa_frsqrt_dtest_msa_fsaf_wtest_msa_fsaf_dtest_msa_fseq_wtest_msa_fseq_dtest_msa_fsle_wtest_msa_fsle_dtest_msa_fslt_wtest_msa_fslt_dtest_msa_fsne_wtest_msa_fsne_dtest_msa_fsor_wtest_msa_fsor_dtest_msa_fsqrt_wtest_msa_fsqrt_dtest_msa_fsub_wtest_msa_fsub_dtest_msa_fsueq_wtest_msa_fsueq_dtest_msa_fsule_wtest_msa_fsule_dtest_msa_fsult_wtest_msa_fsult_dtest_msa_fsun_wtest_msa_fsun_dtest_msa_fsune_wtest_msa_fsune_dtest_msa_ftint_s_wtest_msa_ftint_s_dtest_msa_ftint_u_wtest_msa_ftint_u_dtest_msa_ftq_htest_msa_ftq_wtest_msa_ftrunc_s_wtest_msa_ftrunc_s_dtest_msa_ftrunc_u_wtest_msa_ftrunc_u_dtest_msa_hadd_s_htest_msa_hadd_s_wtest_msa_hadd_s_dtest_msa_hadd_u_htest_msa_hadd_u_wtest_msa_hadd_u_dtest_msa_hsub_s_htest_msa_hsub_s_wtest_msa_hsub_s_dtest_msa_hsub_u_htest_msa_hsub_u_wtest_msa_hsub_u_dtest_msa_ilvev_btest_msa_ilvev_htest_msa_ilvev_wtest_msa_ilvev_dtest_msa_ilvl_btest_msa_ilvl_htest_msa_ilvl_wtest_msa_ilvl_dtest_msa_ilvod_btest_msa_ilvod_htest_msa_ilvod_wtest_msa_ilvod_dtest_msa_ilvr_btest_msa_ilvr_htest_msa_ilvr_wtest_msa_ilvr_dtest_msa_insert_btest_msa_insert_htest_msa_insert_wtest_msa_insert_dtest_msa_insve_btest_msa_insve_htest_msa_insve_wtest_msa_insve_dtest_msa_ld_btest_msa_ld_htest_msa_ld_wtest_msa_ld_dtest_msa_ldi_btest_msa_ldi_htest_msa_ldi_wtest_msa_madd_q_htest_msa_madd_q_wtest_msa_maddr_q_htest_msa_maddr_q_wtest_msa_maddv_btest_msa_maddv_htest_msa_maddv_wtest_msa_maddv_dtest_msa_max_a_btest_msa_max_a_htest_msa_max_a_wtest_msa_max_a_dtest_msa_max_s_btest_msa_max_s_htest_msa_max_s_wtest_msa_max_s_dtest_msa_max_u_btest_msa_max_u_htest_msa_max_u_wtest_msa_max_u_dtest_msa_maxi_s_btest_msa_maxi_s_htest_msa_maxi_s_wtest_msa_maxi_u_btest_msa_maxi_u_htest_msa_maxi_u_wtest_msa_maxi_u_dtest_msa_min_a_btest_msa_min_a_htest_msa_min_a_wtest_msa_min_a_dtest_msa_min_s_btest_msa_min_s_htest_msa_min_s_wtest_msa_min_s_dtest_msa_mini_s_btest_msa_mini_s_htest_msa_mini_s_wtest_msa_min_u_btest_msa_min_u_htest_msa_min_u_wtest_msa_min_u_dtest_msa_mini_u_btest_msa_mini_u_htest_msa_mini_u_wtest_msa_mini_u_dtest_msa_mod_s_btest_msa_mod_s_htest_msa_mod_s_wtest_msa_mod_s_dtest_msa_mod_u_btest_msa_mod_u_htest_msa_mod_u_wtest_msa_mod_u_dtest_msa_move_vtest_msa_msub_q_htest_msa_msub_q_wtest_msa_msubr_q_htest_msa_msubr_q_wtest_msa_msubv_btest_msa_msubv_htest_msa_msubv_wtest_msa_msubv_dtest_msa_mul_q_htest_msa_mul_q_wtest_msa_mulr_q_htest_msa_mulr_q_wtest_msa_mulv_btest_msa_mulv_htest_msa_mulv_wtest_msa_mulv_dtest_msa_nloc_btest_msa_nloc_htest_msa_nloc_wtest_msa_nloc_dtest_msa_nlzc_btest_msa_nlzc_htest_msa_nlzc_wtest_msa_nlzc_dtest_msa_nor_vtest_msa_nori_btest_msa_or_vtest_msa_ori_btest_msa_pckev_btest_msa_pckev_htest_msa_pckev_wtest_msa_pckev_dtest_msa_pckod_btest_msa_pckod_htest_msa_pckod_wtest_msa_pckod_dtest_msa_pcnt_btest_msa_pcnt_htest_msa_pcnt_wtest_msa_pcnt_dtest_msa_sat_s_btest_msa_sat_s_htest_msa_sat_s_wtest_msa_sat_s_dtest_msa_sat_u_btest_msa_sat_u_htest_msa_sat_u_wtest_msa_sat_u_dtest_msa_shf_btest_msa_shf_htest_msa_shf_wtest_msa_sld_btest_msa_sld_htest_msa_sld_wtest_msa_sld_dtest_msa_sldi_btest_msa_sldi_htest_msa_sldi_wtest_msa_sldi_dtest_msa_sll_btest_msa_sll_htest_msa_sll_wtest_msa_sll_dtest_msa_slli_btest_msa_slli_htest_msa_slli_wtest_msa_slli_dtest_msa_splat_btest_msa_splat_htest_msa_splat_wtest_msa_splat_dtest_msa_splati_btest_msa_splati_htest_msa_splati_wtest_msa_splati_dtest_msa_sra_btest_msa_sra_htest_msa_sra_wtest_msa_sra_dtest_msa_srai_btest_msa_srai_htest_msa_srai_wtest_msa_srai_dtest_msa_srar_btest_msa_srar_htest_msa_srar_wtest_msa_srar_dtest_msa_srari_btest_msa_srari_htest_msa_srari_wtest_msa_srari_dtest_msa_srl_btest_msa_srl_htest_msa_srl_wtest_msa_srl_dtest_msa_srli_btest_msa_srli_htest_msa_srli_wtest_msa_srli_dtest_msa_srlr_btest_msa_srlr_htest_msa_srlr_wtest_msa_srlr_dtest_msa_srlri_btest_msa_srlri_htest_msa_srlri_wtest_msa_srlri_dtest_msa_st_btest_msa_st_htest_msa_st_wtest_msa_st_dtest_msa_subs_s_btest_msa_subs_s_htest_msa_subs_s_wtest_msa_subs_s_dtest_msa_subs_u_btest_msa_subs_u_htest_msa_subs_u_wtest_msa_subs_u_dtest_msa_subsus_u_btest_msa_subsus_u_htest_msa_subsus_u_wtest_msa_subsus_u_dtest_msa_subsuu_s_btest_msa_subsuu_s_htest_msa_subsuu_s_wtest_msa_subsuu_s_dtest_msa_subv_btest_msa_subv_htest_msa_subv_wtest_msa_subv_dtest_msa_subvi_btest_msa_subvi_htest_msa_subvi_wtest_msa_subvi_dtest_msa_vshf_btest_msa_vshf_htest_msa_vshf_wtest_msa_vshf_dtest_msa_xor_vtest_msa_xori_b// FIXME: https://reviews.llvm.org/D59884// If target type is i64, negative immediate loses the sign// Test passes if 4294967293 is used instead -3 in vector `a`// #[simd_test(enable = "msa")]// unsafe fn test_msa_ceqi_d() {//     #[rustfmt::skip]//     let a = i64x2::new(-3, 2);//     let r = i64x2::new(-1, 0);//     assert_eq!(r, mem::transmute(__msa_ceqi_d(mem::transmute(a), -3)));// Can not be tested in user mode// unsafe fn test_msa_cfcmsa() {//     let r = 5;//     assert_eq!(r, mem::transmute(__msa_cfcmsa(5));// -3 is represented as 4294967293// unsafe fn test_msa_clei_s_d() {//     let a = i64x2::new(-3, 11);//     assert_eq!(r, mem::transmute(__msa_clei_s_d(mem::transmute(a), -3)));// unsafe fn test_msa_clti_s_d() {//     let a = i64x2::new(-5, -2);//     assert_eq!(r, mem::transmute(__msa_clti_s_d(mem::transmute(a), -3)));// unsafe fn test_msa_ctcmsa() {/*// FIXME: 16-bit floats
    #[simd_test(enable = "msa")]
    unsafe fn test_msa_fexdo_h() {
        #[rustfmt::skip]
        let a = f32x4::new(20.5, 2.3, 4.5, 5.4);
        #[rustfmt::skip]
        let b = f32x4::new(1.1, 1.0, 1.0, 1.0);
        let r = i16x8::new(1, 9, 30, 51, 1, 9, 30, 51);

        assert_eq!(r, mem::transmute(__msa_fexdo_h(mem::transmute(a), mem::transmute(b))));
    }*/// unsafe fn test_msa_fexupl_w() {//     let a = f16x8(1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5);//     let r = f32x4::new(5.5, 6.5, 7.5, 8.5);//     assert_eq!(r, mem::transmute(__msa_fexupl_w(mem::transmute(a))));//     #[simd_test(enable = "msa")]// unsafe fn test_msa_fexupr_w() {//     let r = f32x4::new(1.5, 2.5, 3.5, 4.5);//     assert_eq!(r, mem::transmute(__msa_fexupr_w(mem::transmute(a))));// Test passes if 4294967185 is used instead -111 in vector `r`// unsafe fn test_msa_ldi_d() {//     let r = i64x2::new(-111, -111);//     assert_eq!(r, mem::transmute(__msa_ldi_d(-111)));// Test passes if 4294967293 is used instead -3 in vector `r`// unsafe fn test_msa_maxi_s_d() {//     let a = i64x2::new(1, -8);//     let r = i64x2::new(-3, -3);//     assert_eq!(r, mem::transmute(__msa_maxi_s_d(mem::transmute(a), -3)));// unsafe fn test_msa_mini_s_d() {//     let r = i64x2::new(-1, -3);//     assert_eq!(r, mem::transmute(__msa_mini_s_d(mem::transmute(a), -3)));//! MIPS SIMD Architecture intrinsics//! The reference is [MIPS Architecture for Programmers Volume IV-j: The//! MIPS32 SIMD Architecture Module Revision 1.12][msa_ref].//! [msa_ref]: http://cdn2.imgtec.com/documentation/MD00866-2B-MSA32-AFP-01.12.pdf/* FIXME: 16-bit float
/// Vector Floating-Point Down-Convert Interchange Format
///
/// The floating-point elements in vector `a` (four 64-bit floating point numbers)
/// and vector `b` (four 64-bit floating point numbers) are down-converted
/// to a smaller interchange format, i.e. from 64-bit to 32-bit, or from 32-bit to 16-bit.
/// The result is written to vector (8 16-bit floating point numbers).
///
#[inline]
#[target_feature(enable = "msa")]
#[cfg_attr(test, assert_instr(fexdo.h))]
    #[unstable(feature = "stdarch_mips", issue = "111198")] pub unsafe fn __msa_fexdo_h(a: v4f32, b: v4f32) -> f16x8 {
    msa_fexdo_h(a, mem::transmute(b))
}*//* FIXME: 16-bit float
/// Vector Floating-Point Up-Convert Interchange Format Left
///
/// The left half floating-point elements in vector `a` (two 16-bit floating point numbers)
/// are up-converted to a larger interchange format,
/// i.e. from 16-bit to 32-bit, or from 32-bit to 64-bit.
/// The result is written to vector (four 32-bit floating point numbers).
///
#[inline]
#[target_feature(enable = "msa")]
#[cfg_attr(test, assert_instr(fexupl.w))]
    #[unstable(feature = "stdarch_mips", issue = "111198")] pub unsafe fn __msa_fexupl_w(a: f16x8) -> v4f32 {
    msa_fexupl_w(a)
}*//* FIXME: 16-bit float
/// Vector Floating-Point Up-Convert Interchange Format Left
///
/// The right half floating-point elements in vector `a` (two 16-bit floating point numbers)
/// are up-converted to a larger interchange format,
/// i.e. from 16-bit to 32-bit, or from 32-bit to 64-bit.
/// The result is written to vector (four 32-bit floating point numbers).
///
#[inline]
#[target_feature(enable = "msa")]
#[cfg_attr(test, assert_instr(fexupr.w))]
    #[unstable(feature = "stdarch_mips", issue = "111198")] pub unsafe fn __msa_fexupr_w(a: f16x8) -> v4f32 {
    msa_fexupr_w(a)
} *//// Platform-specific intrinsics for the `x86_64` platform./// See the [module documentation](../index.html) for more details.//! `core_arch`"llvm.nvvm.barrier0"syncthreads"llvm.nvvm.read.ptx.sreg.ntid.x"block_dim_x"llvm.nvvm.read.ptx.sreg.ntid.y"block_dim_y"llvm.nvvm.read.ptx.sreg.ntid.z"block_dim_z"llvm.nvvm.read.ptx.sreg.ctaid.x"block_idx_x"llvm.nvvm.read.ptx.sreg.ctaid.y"block_idx_y"llvm.nvvm.read.ptx.sreg.ctaid.z"block_idx_z"llvm.nvvm.read.ptx.sreg.nctaid.x"grid_dim_x"llvm.nvvm.read.ptx.sreg.nctaid.y"grid_dim_y"llvm.nvvm.read.ptx.sreg.nctaid.z"grid_dim_z"llvm.nvvm.read.ptx.sreg.tid.x"thread_idx_x"llvm.nvvm.read.ptx.sreg.tid.y"thread_idx_y"llvm.nvvm.read.ptx.sreg.tid.z"thread_idx_z_syncthreads/// Synchronizes all threads in the block._block_dim_x/// x-th thread-block dimension._block_dim_y/// y-th thread-block dimension._block_dim_z/// z-th thread-block dimension._block_idx_x/// x-th thread-block index._block_idx_y/// y-th thread-block index._block_idx_z/// z-th thread-block index._grid_dim_x/// x-th block-grid dimension._grid_dim_y/// y-th block-grid dimension._grid_dim_z/// z-th block-grid dimension._thread_idx_x/// x-th thread index._thread_idx_y/// y-th thread index._thread_idx_z/// z-th thread index./// Generates the trap instruction `TRAP`/// Print formatted output from a kernel to a host-side output stream./// Syscall arguments:/// * `status`: The status value that is returned by `vprintf`./// * `format`: A pointer to the format specifier input (uses common `printf` format)./// * `valist`: A pointer to the valist input./// struct PrintArgs(f32, f32, f32, i32);/// vprintf(///     "int(%f + %f) = int(%f) = %d\n".as_ptr(),///     transmute(&PrintArgs(a, b, a + b, (a + b) as i32)),/// Sources:/// [Programming Guide](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#formatted-output),/// [PTX Interoperability](https://docs.nvidia.com/cuda/ptx-writers-guide-to-interoperability/index.html#system-calls)./// Allocate memory dynamically from a fixed-size heap in global memory./// The CUDA in-kernel `malloc()` function allocates at least `size` bytes/// from the device heap and returns a pointer to the allocated memory/// or `NULL` if insufficient memory exists to fulfill the request./// The returned pointer is guaranteed to be aligned to a 16-byte boundary./// The memory allocated by a given CUDA thread via `malloc()` remains allocated/// for the lifetime of the CUDA context, or until it is explicitly released/// by a call to `free()`. It can be used by any other CUDA threads/// even from subsequent kernel launches./// [Programming Guide](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#dynamic-global-memory-allocation-and-operations),// FIXME(denzp): assign `malloc` and `nothrow` attributes./// Free previously dynamically allocated memory./// The CUDA in-kernel `free()` function deallocates the memory pointed to by `ptr`,/// which must have been returned by a previous call to `malloc()`. If `ptr` is NULL,/// the call to `free()` is ignored./// Any CUDA thread may free memory allocated by another thread, but care should be taken/// to ensure that the same pointer is not freed more than once. Repeated calls to `free()`/// with the same `ptr` has undefined behavior.// FIXME(denzp): assign `nothrow` attribute.__assertfail// Internal declaration of the syscall. Exported variant has// the `char_size` parameter set to `1` (single char size in bytes).__assert_fail/// Syscall to be used whenever the *assert expression produces a `false` value*./// * `message`: The pointer to the string that should be output./// * `file`: The pointer to the file name string associated with the assert./// * `line`: The line number associated with the assert./// * `function`: The pointer to the function name string associated with the assert./// Source://! NVPTX intrinsics (experimental)//! These intrinsics form the foundation of the CUDA//! programming model.//! The reference is the [CUDA C Programming Guide][cuda_c]. Relevant is also//! the [LLVM NVPTX Backend documentation][llvm_docs].//! [cuda_c]://! http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html//! [llvm_docs]://! https://llvm.org/docs/NVPTXUsage.html// Basic CUDA syscall declarations."llvm.minimum.v2f16"llvm_f16x2_minimumf16x2"llvm.maximum.v2f16"llvm_f16x2_maximumf16x2_add/// Add two values, round to nearest even/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-add>/// Corresponds to the CUDA C intrinsics:///  - [`__hadd2`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g921c795176eaa31265bd80ef4fe4b8e6)///  - [`__hadd2_rn`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g6cd8ddb2c3d670e1a10c3eb2e7644f82)f16x2_sub/// Subtract two values, round to nearest even/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-sub>///  - [`__hsub2`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1ga5536c9c3d853d8c8b9de60e18b41e54)///  - [`__hsub2_rn`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g8adc164c68d553354f749f0f0645a874)f16x2_mul/// Multiply two values, round to nearest even/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-mul>///  - [`__hmul2`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g70de3f2ee48babe4e0969397ac17708e)///  - [`__hmul2_rn`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g99f8fe23a4b4c6898d6faf999afaa76e)f16x2_fma/// Fused multiply-add, round to nearest even/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-fma>///  - [`__fma2`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g43628ba21ded8b1e188a367348008dab)///  - [`__fma2_rn`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC_1g43628ba21ded8b1e188a367348008dab)f16x2_neg/// Arithmetic negate/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-neg>/// Corresponds to the CUDA C intrinsic [`__hmin2`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__COMPARISON.html#group__CUDA__MATH____HALF2__COMPARISON_1g9e17a33f96061804166f3fbd395422b6)f16x2_min/// Find the minimum of two values/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-min>f16x2_min_nan/// Find the minimum of two values, NaNs pass through./// Corresponds to the CUDA C intrinsic [`__hmin2_nan`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__COMPARISON.html#group__CUDA__MATH____HALF2__COMPARISON_1g8bb8f58e9294cc261d2f42c4d5aecd6b)f16x2_max/// Find the maximum of two values/// <https://docs.nvidia.com/cuda/parallel-thread-execution/#half-precision-floating-point-instructions-max>/// Corresponds to the CUDA C intrinsic [`__hmax2`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__COMPARISON.html#group__CUDA__MATH____HALF2__COMPARISON_1g59fc7fc7975d8127b202444a05e57e3d)f16x2_max_nan/// Find the maximum of two values, NaNs pass through./// Corresponds to the CUDA C intrinsic [`__hmax2_nan`](https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH____HALF2__COMPARISON.html#group__CUDA__MATH____HALF2__COMPARISON_1g41623db7850e3074fd9daa80a14c3897)//! NVPTX Packed data types (SIMD)//! Packed Data Types is what PTX calls SIMD types. See [PTX ISA (Packed Data Types)](https://docs.nvidia.com/cuda/parallel-thread-execution/#packed-data-types) for a full reference.// Note: #[assert_instr] tests are not actually being run on nvptx due to being a `no_std` target incapable of running tests. Something like FileCheck would be appropriate for verifying the correct instruction is used."llvm.ppc.altivec.lvx"lvxvector_unsigned_int"llvm.ppc.altivec.lvebx"lvebxvector_signed_char"llvm.ppc.altivec.lvehx"lvehxvector_signed_short"llvm.ppc.altivec.lvewx"lvewxvector_signed_int"llvm.ppc.altivec.lvxl"lvxl"llvm.ppc.altivec.stvx"stvx"llvm.ppc.altivec.stvebx"stvebx"llvm.ppc.altivec.stvehx"stvehx"llvm.ppc.altivec.stvewx"stvewx"llvm.ppc.altivec.stvxl"stvxl"llvm.ppc.altivec.vperm"vpermvector_unsigned_char"llvm.ppc.altivec.vmhaddshs"vmhaddshs"llvm.ppc.altivec.vmhraddshs"vmhraddshs"llvm.ppc.altivec.vmsumuhs"vmsumuhsvector_unsigned_short"llvm.ppc.altivec.vmsumshs"vmsumshs"llvm.ppc.altivec.vmsumubm"vmsumubm"llvm.ppc.altivec.vmsummbm"vmsummbm"llvm.ppc.altivec.vmsumuhm"vmsumuhm"llvm.ppc.altivec.vmsumshm"vmsumshm"llvm.ppc.altivec.vnmsubfp"vnmsubfpvector_float"llvm.ppc.altivec.vsum2sws"vsum2sws"llvm.ppc.altivec.vsum4ubs"vsum4ubs"llvm.ppc.altivec.vsum4sbs"vsum4sbs"llvm.ppc.altivec.vsum4shs"vsum4shs"llvm.ppc.altivec.vmuleub"vmuleub"llvm.ppc.altivec.vmulesb"vmulesb"llvm.ppc.altivec.vmuleuh"vmuleuh"llvm.ppc.altivec.vmulesh"vmulesh"llvm.ppc.altivec.vmuloub"vmuloub"llvm.ppc.altivec.vmulosb"vmulosb"llvm.ppc.altivec.vmulouh"vmulouh"llvm.ppc.altivec.vmulosh"vmulosh"llvm.smax.v16i8"vmaxsb"llvm.smax.v8i16"vmaxsh"llvm.smax.v4i32"vmaxsw"llvm.umax.v16i8"vmaxub"llvm.umax.v8i16"vmaxuh"llvm.umax.v4i32"vmaxuw"llvm.smin.v16i8"vminsb"llvm.smin.v8i16"vminsh"llvm.smin.v4i32"vminsw"llvm.umin.v16i8"vminub"llvm.umin.v8i16"vminuh"llvm.umin.v4i32"vminuw"llvm.ppc.altivec.vsubsbs"vsubsbs"llvm.ppc.altivec.vsubshs"vsubshs"llvm.ppc.altivec.vsubsws"vsubsws"llvm.ppc.altivec.vsububs"vsububs"llvm.ppc.altivec.vsubuhs"vsubuhs"llvm.ppc.altivec.vsubuws"vsubuws"llvm.ppc.altivec.vsubcuw"vsubcuw"llvm.ppc.altivec.vaddcuw"vaddcuw"llvm.ppc.altivec.vaddsbs"vaddsbs"llvm.ppc.altivec.vaddshs"vaddshs"llvm.ppc.altivec.vaddsws"vaddsws"llvm.ppc.altivec.vaddubs"vaddubs"llvm.ppc.altivec.vadduhs"vadduhs"llvm.ppc.altivec.vadduws"vadduws"llvm.ppc.altivec.vavgsb"vavgsb"llvm.ppc.altivec.vavgsh"vavgsh"llvm.ppc.altivec.vavgsw"vavgsw"llvm.ppc.altivec.vavgub"vavgub"llvm.ppc.altivec.vavguh"vavguh"llvm.ppc.altivec.vavguw"vavguw"llvm.ppc.altivec.vcmpbfp"vcmpbfp"llvm.ppc.altivec.vcmpequb"vcmpequbvector_bool_char"llvm.ppc.altivec.vcmpequh"vcmpequhvector_bool_short"llvm.ppc.altivec.vcmpequw"vcmpequwvector_bool_int"llvm.ppc.altivec.vcmpneb"vcmpneb"llvm.ppc.altivec.vcmpneh"vcmpneh"llvm.ppc.altivec.vcmpnew"vcmpnew"llvm.ppc.altivec.vcmpgefp"vcmpgefp"llvm.ppc.altivec.vcmpgtub"vcmpgtub"llvm.ppc.altivec.vcmpgtuh"vcmpgtuh"llvm.ppc.altivec.vcmpgtuw"vcmpgtuw"llvm.ppc.altivec.vcmpgtsb"vcmpgtsb"llvm.ppc.altivec.vcmpgtsh"vcmpgtsh"llvm.ppc.altivec.vcmpgtsw"vcmpgtsw"llvm.ppc.altivec.vexptefp"vexptefp"llvm.ppc.altivec.vcmpequb.p"vcmpequb_p"llvm.ppc.altivec.vcmpequh.p"vcmpequh_p"llvm.ppc.altivec.vcmpequw.p"vcmpequw_p"llvm.ppc.altivec.vcmpeqfp.p"vcmpeqfp_p"llvm.ppc.altivec.vcmpgtub.p"vcmpgtub_p"llvm.ppc.altivec.vcmpgtuh.p"vcmpgtuh_p"llvm.ppc.altivec.vcmpgtuw.p"vcmpgtuw_p"llvm.ppc.altivec.vcmpgtsb.p"vcmpgtsb_p"llvm.ppc.altivec.vcmpgtsh.p"vcmpgtsh_p"llvm.ppc.altivec.vcmpgtsw.p"vcmpgtsw_p"llvm.ppc.altivec.vcmpgefp.p"vcmpgefp_p"llvm.ppc.altivec.vcmpgtfp.p"vcmpgtfp_p"llvm.ppc.altivec.vcmpbfp.p"vcmpbfp_p"llvm.ppc.altivec.vcfsx"vcfsx"llvm.ppc.altivec.vcfux"vcfux"llvm.ppc.altivec.vctsxs"vctsxs"llvm.ppc.altivec.vctuxs"vctuxs"llvm.ppc.altivec.vpkshss"vpkshss"llvm.ppc.altivec.vpkshus"vpkshus"llvm.ppc.altivec.vpkuhus"vpkuhus"llvm.ppc.altivec.vpkswss"vpkswss"llvm.ppc.altivec.vpkswus"vpkswus"llvm.ppc.altivec.vpkuwus"vpkuwus"llvm.ppc.altivec.vupkhsb"vupkhsb"llvm.ppc.altivec.vupklsb"vupklsb"llvm.ppc.altivec.vupkhsh"vupkhsh"llvm.ppc.altivec.vupklsh"vupklsh"llvm.ppc.altivec.mfvscr"mfvscr"llvm.ppc.altivec.vlogefp"vlogefp"llvm.ppc.altivec.vsl"vsl"llvm.ppc.altivec.vslo"vslo"llvm.ppc.altivec.vsrab"vsrab"llvm.ppc.altivec.vsrah"vsrah"llvm.ppc.altivec.vsraw"vsraw"llvm.ppc.altivec.vsr"vsr"llvm.ppc.altivec.vsro"vsro"llvm.ppc.altivec.vslv"vslv"llvm.ppc.altivec.vsrv"vsrv"llvm.nearbyint.v4f32"vrfinIDXvec_insertVectorInsertidx_in_vecimpl_vec_insertvec_extractVectorExtractimpl_vec_extractimpl_vec_cmpimpl_vec_any_allvec_ldvec_ldlVectorLdimpl_vec_ldvec_ldeVectorLdeimpl_vec_ldevec_stvec_stlVectorStimpl_vec_stvec_steVectorSteimpl_vec_stevec_xlVectorXlimpl_vec_xlvec_xstVectorXstimpl_vec_xsttest_implvec_cmpgtVectorCmpGtvec_cmpeqVectorCmpEqimpl_cmpnevec_cmpneVectorCmpNevcmpequb_allvcmpequb_anyvcmpequh_allvcmpequh_anyvcmpequw_allvcmpequw_anyvec_all_eqVectorAllEqvcmpeqfp_all// TODO: vsx encodingvec_any_eqVectorAnyEqvcmpeqfp_anyvcmpgesb_allvcmpgesb_anyvcmpgesh_allvcmpgesh_anyvcmpgesw_allvcmpgesw_anyvcmpgeub_allvcmpgeub_anyvcmpgeuh_allvcmpgeuh_anyvcmpgeuw_allvcmpgeuw_anyvec_all_geVectorAllGevcmpgefp_allvec_any_geVectorAnyGevcmpgefp_anyvcmpgtsb_allvcmpgtsb_anyvcmpgtsh_allvcmpgtsh_anyvcmpgtsw_allvcmpgtsw_anyvcmpgtub_allvcmpgtub_anyvcmpgtuh_allvcmpgtuh_anyvcmpgtuw_allvcmpgtuw_anyvec_all_gtVectorAllGtvcmpgtfp_allvec_any_gtVectorAnyGtvcmpgtfp_anyvcmpneub_allvcmpneub_anyvcmpneuh_allvcmpneuh_anyvcmpneuw_allvcmpneuw_anyvec_all_neVectorAllNevcmpnefp_allvec_any_neVectorAnyNevcmpnefp_anyvec_avgVectorAvgimpl_vec_traitandcvec_andcVectorAndcorcvec_orcVectorOrcvec_andVectorAndvec_addsVectorAddsvec_subsVectorSubsvec_absVectorAbsimpl_absvec_abs_f32vec_abssVectorAbssimpl_abssvspltbvsplthvspltwIMMvec_splatVectorSplatimpl_vec_splatsplatsvec_splatsVectorSplatsimpl_vec_splatsvec_subVectorSubvec_subcVectorSubcvec_minVectorMinvec_maxVectorMaxvec_vmuleubvec_vmulesbvec_vmuleuhvec_vmuleshvec_mulVectorMulvec_vmuluwmvec_xvmulspvec_muleVectorMulevec_vmuloubvec_vmulosbvec_vmulouhvec_vmuloshvec_muloVectorMulovec_vsum4ubsvec_vsum4sbsvec_vsum4shsvec_sum4sVectorSum4svec_vsum2swsvec_vnmsubfpvec_vmaddfpvec_vmsumubmvec_vmsummbmvec_vmsumuhmvec_vmsumshmvec_msumVectorMsumvec_vmsumuhsvec_vmsumshsvec_msumsVectorMsumsvec_vpermVectorPermvector_permvec_addVectorAddvec_add_bc_scvec_add_sc_scvec_add_bc_ucvec_add_uc_ucvec_add_bs_ssvec_add_ss_ssvec_add_bs_usvec_add_us_usvec_add_bi_sivec_add_si_sivec_add_bi_uivec_add_ui_uivec_add_float_floatvec_addeVectorAddevec_mladdVectorMladdmladdvector_mladdvec_orVectorOrvec_xorVectorXorvector_vnorvec_norVectorNorvector_vnandvec_nandVectorNandvec_vselvec_selVectorSelvector_selvec_ctf_i32vec_ctf_u32vec_ctfVectorCtfvec_vmrglbvec_vmrglhvec_vmrglwvec_vmrghbvec_vmrghhvec_vmrghwvec_mergehVectorMergehvec_mergelVectorMergelvec_vpkuhumvec_vpkuwumvec_packVectorPackvec_vpkshssvec_vpkshusvec_vpkuhusvec_vpkswssvec_vpkswusvec_vpkuwusvec_packsVectorPacksvec_packsuVectorPacksuimpl_vec_unpackvec_unpackhVectorUnpackhvec_unpacklVectorUnpacklimpl_vec_shiftvec_slVectorSlvec_srVectorSrvec_sraVectorSraUIMM4vec_sldUIMM2vec_sldwVectorSldvsldoixxsldwi// TODO: collapse the two once generic_const_exprs are usable.impl_vec_sldimpl_vec_shift_longvec_sllVectorSllvec_srlVectorSrlimpl_vec_shift_octectvec_sloVectorSlovec_sroVectorSrovec_cntlzVectorCntlzimpl_vec_cntlzimpl_vrlvec_rlVectorRlimpl_vec_rlvec_roundVectorRound// All/Any GreaterEqual// All/Any Greater Than// All/Any Elements Not Equal/// Vector Insert/// ## Purpose/// Returns a copy of vector b with element c replaced by the value of a./// ## Result value/// r contains a copy of vector b with element c replaced by the value of a./// This function uses modular arithmetic on c to determine the element number./// For example, if c is out of range, the compiler uses c modulo the number of/// elements in the vector to determine the element position./// Vector Extract/// Returns the value of the bth element of vector a./// The value of each element of r is the element of a at position b modulo the number of/// elements of a./// Vector Merge Low/// Vector Merge High/// Vector Pack/// Vector Pack Saturated/// Vector Pack Saturated Unsigned/// Vector Unpack High/// Vector Unpack Low/// Vector Shift Right/// Vector Shift Right Algebraic/// Vector Shift Left Double/// ## Endian considerations/// This intrinsic is not endian-neutral, so uses of vec_sld in/// big-endian code must be rewritten for little-endian targets./// Historically, vec_sld could be used to shift by amounts not a multiple of the element size/// for most types, in which case the purpose of the shift is difficult to determine and difficult/// to automatically rewrite efficiently for little endian./// So the concatenation of a and b is done in big-endian fashion (left to right), and the shift is/// always to the left. This will generally produce surprising results for little-endian targets./// Vector Shift Left Double by Words/// This intrinsic is not endian-neutral, so uses of vec_sldw in/// The concatenation of a and b is done in big-endian fashion (left to right), and the shift is/// always to the left. This will generally produce surprising results for little- endian targets./// Vector Shift Left Long/// This intrinsic is not endian-neutral, so uses of vec_sll in big-endian/// code must be rewritten for little-endian targets./// Vector Shift Right Long/// This intrinsic is not endian-neutral, so uses of vec_srl in big-endian/// Vector Shift Left by Octets/// This intrinsic is not endian-neutral, so uses of vec_slo in big-endian code must be rewritten/// for little-endian targets. The shift count is in element 15 of b for big-endian, but in element/// 0 of b for little-endian./// Vector Shift Right by Octets/// This intrinsic is not endian-neutral, so uses of vec_sro in big-endian code must be rewrittenvec_slv/// Vector Shift Left Variable/// Let v be a 17-byte vector formed from a in bytes `[0:15]` and a zero byte in element 16./// Then each byte element i of r is determined as follows. The start bit sb is/// obtained from bits 5:7 of byte element i of b. Then the contents of bits sb:sb+7 of the/// halfword in byte elements i:i+1 of v are placed into byte element i of r./// All bit and byte element numbers are specified in big-endian order. This intrinsic is not/// endian-neutral.vec_srv/// Vector Shift Right Variable/// Let v be a 17-byte vector formed from a zero byte in element 0 and the elements of/// a in bytes `[1:16]`. Then each byte element i of r is determined as follows. The start bit sb is/// obtained from bits 5:7 of byte element i of b. Then the contents of bits (8 – sb):(15 – sb) of/// the halfword in byte elements i:i+1 of v are placed into byte element i of r./// Vector Load Indexed./// Vector Load Indexed Least Recently Used./// Vector Load Element Indexed./// Vector Store Indexed/// Stores a 16-byte vector into memory at the address specified by a displacement and a/// pointer, ignoring the four low-order bits of the calculated address./// ## Operation/// A memory address is obtained by adding b and c, and masking off the four low-order/// bits of the result. The 16-byte vector in a is stored to the resultant memory address./// Vector Store Indexed Least Recently Used/// Stores a 16-byte vector into memory at the address specified by a displacement and/// a pointer, ignoring the four low-order bits of the calculated address, and marking the cache/// line containing the address as least frequently used./// A memory address is obtained by adding b and c, and masking off the four/// low-order bits of the result. The 16-byte vector in a is stored to the resultant memory/// address, and the containing cache line is marked as least frequently used./// This intrinsic can be used to indicate the last access to a portion of memory, as a hint to the/// data cache controller that the associated cache line can be replaced without performance loss./// Vector Store Element Indexed/// Stores a single element from a 16-byte vector into memory at the address specified by/// a displacement and a pointer, aligned to the element size./// The integer value b is added to the pointer value c. The resulting address is/// rounded down to the nearest address that is a multiple of es, where es is 1 for char pointers,/// 2 for short pointers, and 4 for float or int pointers. An element offset eo is calculated by/// taking the resultant address modulo 16. The vector element of a at offset eo is stored to the/// resultant address./// Be careful to note that the address (b+c) is aligned to an element boundary. Do not attempt/// to store unaligned data with this intrinsic./// VSX Unaligned Load/// VSX Unaligned Storevec_loge/// Vector Base-2 Logarithm Estimatevec_floor/// Vector floor.vec_expte/// Vector expte.vec_cmplt/// Vector cmplt.vec_cmple/// Vector cmple./// Vector cmpgt.vec_cmpge/// Vector cmpge./// Vector cmpeq./// Vector Compare Not Equal/// For each element of r, the value of each bit is 1 if the corresponding elements/// of a and b are not equal. Otherwise, the value of each bit is 0.vec_cmpb/// Vector cmpb.vec_ceil/// Vector ceil./// Vector avg./// Vector andc./// Vector OR with Complement/// Performs a bitwise OR of the first vector with the bitwise-complemented second vector./// r is the bitwise OR of a and the bitwise complement of b./// Vector and./// Vector or./// Vector NAND/// Performs a bitwise NAND of two vectors./// r is the bitwise NAND of a and b./// Vector nor./// Vector xor./// Vector adds.vec_addc/// Vector addc./// Vector abs./// Vector abss./// Vector Rotate Left/// Rotates each element of a vector left by a given number of bits./// Each element of r is obtained by rotating the corresponding element of a left by/// the number of bits specified by the corresponding element of b./// Vector Round/// Returns a vector containing the rounded values of the corresponding elements of the/// source vector./// Each element of r contains the value of the corresponding element of a, rounded/// to the nearest representable floating-point integer, using IEEE round-to-nearest/// rounding./// The current floating-point rounding mode is ignored./// Vector Splat/// Vector splats./// Vector sub./// Vector Subtract Carryout/// Returns a vector wherein each element contains the carry produced by subtracting the/// corresponding elements of the two source vectors./// The value of each element of r is the complement of the carry produced by subtract- ing the/// value of the corresponding element of b from the value of the corresponding element of a. The/// value is 0 if a borrow occurred, or 1 if no borrow occurred./// Vector subs./// Vector min./// Vector max.vec_mfvscr/// Move From Vector Status and Control Register./// Vector Add Extended/// The value of each element of r is produced by adding the corresponding elements of/// a and b with a carry specified in the corresponding element of c (1 if there is a carry, 0/// otherwise)./// Vector Convert to Floating-Pointvec_cts/// Vector Convert to Signed Integervec_ctu/// Vector Convert to Unsigned Integervec_perm/// Vector permute.vec_sum2s/// Vector Sum Across Partial (1/2) Saturated// Even and Odd are swapped in little-endian/// Vector Multiply Even/// Vector Multiply Odd/// Endian-biased intrinsics/// Compute the products of corresponding elements of two vectors./// Each element of r receives the product of the corresponding elements of a and b.vec_madds/// Vector Multiply Add Saturated/// Vector Multiply Low and Add Unsigned Half Wordvec_mradds/// Vector Multiply Round and Add Saturated/// Vector Multiply Sum/// Vector Multiply Sum Saturatedvec_madd/// Vector Multiply Addvec_nmsub/// Vector Negative Multiply Subtract/// Vector Select/// Returns a vector selecting bits from two source vectors depending on the corresponding/// bit values of a third source vector./// Each bit of r has the value of the corresponding bit of a if the corresponding/// bit of c is 0. Otherwise, the bit of r has the value of the corresponding bit of b./// Vector Sum Across Partial (1/4) Saturated/// Vector All Elements Equal/// Vector All Elements Greater or Equal/// Vector Any Element Greater or Equal/// Vector All Elements Greater Than/// Vector Any Element Greater Thanvec_all_in/// Vector All Invec_all_le/// Vector All Elements Less Than or Equalvec_any_le/// Vector Any Element Less Than or Equalvec_all_lt/// Vector All Elements Less Thanvec_any_lt/// Vector Any Element Less Thanvec_all_nan/// All Elements Not a Numbervec_any_nan/// Any Elements Not a Number/// Vector All Elements Not Equal/// Vector Any Elements Not Equalvec_all_nge/// All Elements Not Greater Than or Equalvec_all_ngt/// All Elements Not Greater Thanvec_all_nle/// All Elements Not Less Than or Equalvec_all_nlt/// All Elements Not Less Thanvec_all_numeric/// All Elements Numericvec_any_nge/// Any Elements Not Greater Than or Equalvec_any_ngt/// Any Elements Not Greater Thanvec_any_nle/// Any Elements Not Less Than or Equalvec_any_nlt/// Any Elements Not Less Thanvec_any_numeric/// Any Elements Numeric/// Vector Count Leading Zeros/// Returns a vector containing the number of most-significant bits equal to zero of each/// corresponding element of the source vector./// The value of each element of r is set to the number of leading zeros of the/// corresponding element of a.vec_any_out/// Any Element Out of Boundstest_vec_2test_vec_1test_vec_ldtest_vec_xltest_vec_xsttest_vec_ldltest_vec_lde_u8test_vec_lde_u16test_vec_lde_u32test_vec_cmpbtest_vec_ceiltest_vec_avgtest_vec_addstest_vec_abstest_vec_absstest_vec_splatstest_vec_splattest_vec_subtest_vec_substest_vec_mintest_vec_maxtest_vec_permtest_vec_maddstest_vec_madd_floattest_vec_nmsub_floattest_vec_mraddstest_vec_mladdtest_vec_msum_unsigned_chartest_vec_msum_signed_chartest_vec_msum_unsigned_shorttest_vec_msum_signed_shorttest_vec_msums_unsignedtest_vec_msums_signedtest_vec_sum2stest_vec_sum4s_unsigned_chartest_vec_sum4s_signed_chartest_vec_sum4s_signed_shorttest_vec_mule_unsigned_chartest_vec_mule_signed_chartest_vec_mule_unsigned_shorttest_vec_mule_signed_shorttest_vec_mulo_unsigned_chartest_vec_mulo_signed_chartest_vec_mulo_unsigned_shorttest_vec_mulo_signed_shortvec_add_i32x4_i32x4test_vec_ctutest_vec_cts//! PowerPC AltiVec intrinsics.//! AltiVec is a brandname trademarked by Freescale (previously Motorola) for//! the standard `Category:Vector` part of the Power ISA v.2.03 specification.//! This Category is also known as VMX (used by IBM), and "Velocity Engine" (a//! brand name previously used by Apple).//! The references are: [POWER ISA v2.07B (for POWER8 & POWER8 with NVIDIA//! NVlink)] and [POWER ISA v3.0B (for POWER9)].//! [POWER ISA v2.07B (for POWER8 & POWER8 with NVIDIA NVlink)]: https://ibm.box.com/s/jd5w15gz301s5b5dt375mshpq9c3lh4u//! [POWER ISA v3.0B (for POWER9)]: https://ibm.box.com/s/1hzcwkwf8rbju5h9iyf44wm94amnlcrvs_t_lt_t_lt_t_st_ut_baltivecvsx//! PowerPC intrinsicsvec_xxpermdiVectorPermDIxxpermdivector_signed_long// xxpermdi has an big-endian bias and extended mnemonicsvec_mergeevec_mergeoVectorMergeEomergeemergeovec_mergeeoDM//#[rustc_legacy_const_generics(2)]/// Vector Merge Even/// Merges the even-numbered values from two vectors./// The even-numbered elements of a are stored into the even-numbered elements of r./// The even-numbered elements of b are stored into the odd-numbered elements of r./// Vector Merge Odd/// Merges the odd-numbered values from two vectors./// The odd-numbered elements of a are stored into the even-numbered elements of r./// The odd-numbered elements of b are stored into the odd-numbered elements of r.test_vec_xxpermdi//! PowerPC Vector Scalar eXtensions (VSX) intrinsics.//! PowerPC 64//! The reference is the [64-Bit ELF V2 ABI Specification - Power//! Architecture].//! [64-Bit ELF V2 ABI Specification - Power Architecture]: http://openpowerfoundation.org/wp-content/uploads/resources/leabi/leabi-20170510.pdf"llvm.ppc.vsx.lxvl"lxvl"llvm.ppc.vsx.stxvl"stxvlvec_lxvlvec_xl_lenVectorXloadsimpl_vsx_loadsvec_stxvlvec_xst_lenVectorXstoresimpl_stores/// Vector Load with Length/// Loads a vector of a specified byte length./// Loads the number of bytes specified by b from the address specified in a./// Initializes elements in order from the byte stream (as defined by the endianness of the/// target). Any bytes of elements that cannot be initialized from the number of loaded bytes have/// a zero value./// Between 0 and 16 bytes, inclusive, will be loaded. The length is specified by the/// least-significant byte of b, as min (b mod 256, 16). The behavior is undefined if the length/// argument is outside of the range 0–255, or if it is not a multiple of the vector element size./// vec_xl_len should not be used to load from cache-inhibited memory./// Vector Store with Length/// Stores a vector of a specified byte length./// Stores the number of bytes specified by c of the vector a to the address specified/// in b. The bytes are obtained starting from the lowest-numbered byte of the lowest-numbered/// element (as defined by the endianness of the target). All bytes of an element are accessed/// before proceeding to the next higher element./// Between 0 and 16 bytes, inclusive, will be stored. The length is specified by the/// least-significant byte of c, as min (c mod 256, 16). The behavior is undefined if the length/// vec_xst_len should not be used to store to cache-inhibited memory.zk//! RISC-V RV32 specific intrinsics"llvm.riscv.aes32esi"_aes32esi"llvm.riscv.aes32esmi"_aes32esmi"llvm.riscv.aes32dsi"_aes32dsi"llvm.riscv.aes32dsmi"_aes32dsmi"llvm.riscv.zip.i32"_zip"llvm.riscv.unzip.i32"_unzip"llvm.riscv.sha512sig0h"_sha512sig0h"llvm.riscv.sha512sig0l"_sha512sig0l"llvm.riscv.sha512sig1h"_sha512sig1h"llvm.riscv.sha512sig1l"_sha512sig1l"llvm.riscv.sha512sum0r"_sha512sum0r"llvm.riscv.sha512sum1r"_sha512sum1raes32esi/// AES final round encryption instruction for RV32./// This instruction sources a single byte from rs2 according to bs. To this it applies the/// forward AES SBox operation, before XOR’ing the result with rs1. This instruction must/// always be implemented such that its execution latency does not depend on the data being/// operated on./// Source: RISC-V Cryptography Extensions Volume I: Scalar & Entropy Source Instructions/// Version: v1.0.1/// Section: 3.3/// The `BS` parameter is expected to be a constant value and only the bottom 2 bits of `bs` are// See #1464// #[cfg_attr(test, assert_instr(aes32esi, BS = 0))]aes32esmi/// AES middle round encryption instruction for RV32 with./// forward AES SBox operation, and a partial forward MixColumn, before XOR’ing the result with/// rs1. This instruction must always be implemented such that its execution latency does not/// depend on the data being operated on./// Section: 3.4/// The `bs` parameter is expected to be a constant value and only the bottom 2 bits of `bs` are// #[cfg_attr(test, assert_instr(aes32esmi, BS = 0))]aes32dsi/// AES final round decryption instruction for RV32./// inverse AES SBox operation, and XOR’s the result with rs1. This instruction must always be/// implemented such that its execution latency does not depend on the data being operated on./// Section: 3.1// #[cfg_attr(test, assert_instr(aes32dsi, BS = 0))]aes32dsmi/// AES middle round decryption instruction for RV32./// inverse AES SBox operation, and a partial inverse MixColumn, before XOR’ing the result with/// Section: 3.2// #[cfg_attr(test, assert_instr(aes32dsmi, BS = 0))]/// Place upper/lower halves of the source register into odd/even bits of the destination/// respectivley./// This instruction places bits in the low half of the source register into the even bit/// positions of the destination, and bits in the high half of the source register into the odd/// bit positions of the destination. It is the inverse of the unzip instruction. This/// instruction is available only on RV32./// Section: 3.49// #[cfg_attr(test, assert_instr(zip))]/// Place odd and even bits of the source word into upper/lower halves of the destination./// This instruction places the even bits of the source register into the low half of the/// destination, and the odd bits of the source into the high bits of the destination. It is/// the inverse of the zip instruction. This instruction is available only on RV32./// Section: 3.45sha512sig0h/// Implements the high half of the Sigma0 transformation, as used in the SHA2-512 hash/// function \[49\] (Section 4.1.3)./// This instruction is implemented on RV32 only. Used to compute the Sigma0 transform of the/// SHA2-512 hash function in conjunction with the sha512sig0l instruction. The transform is a/// 64-bit to 64-bit function, so the input and output are each represented by two 32-bit/// registers. This instruction must always be implemented such that its execution latency does/// not depend on the data being operated on./// Section: 3.31// #[cfg_attr(test, assert_instr(sha512sig0h))]sha512sig0l/// Implements the low half of the Sigma0 transformation, as used in the SHA2-512 hash function/// \[49\] (Section 4.1.3)./// SHA2-512 hash function in conjunction with the sha512sig0h instruction. The transform is a/// Section: 3.32// #[cfg_attr(test, assert_instr(sha512sig0l))]sha512sig1h/// Implements the high half of the Sigma1 transformation, as used in the SHA2-512 hash/// This instruction is implemented on RV32 only. Used to compute the Sigma1 transform of the/// SHA2-512 hash function in conjunction with the sha512sig1l instruction. The transform is a/// Section: 3.33// #[cfg_attr(test, assert_instr(sha512sig1h))]sha512sig1l/// Implements the low half of the Sigma1 transformation, as used in the SHA2-512 hash function/// SHA2-512 hash function in conjunction with the sha512sig1h instruction. The transform is a/// Section: 3.34sha512sum0r/// Implements the Sum0 transformation, as used in the SHA2-512 hash function \[49\] (Section/// 4.1.3)./// This instruction is implemented on RV32 only. Used to compute the Sum0 transform of the/// SHA2-512 hash function. The transform is a 64-bit to 64-bit function, so the input and/// output is represented by two 32-bit registers. This instruction must always be implemented/// such that its execution latency does not depend on the data being operated on./// Section: 3.35// #[cfg_attr(test, assert_instr(sha512sum0r))]sha512sum1r/// Implements the Sum1 transformation, as used in the SHA2-512 hash function \[49\] (Section/// This instruction is implemented on RV32 only. Used to compute the Sum1 transform of the/// Section: 3.36// #[cfg_attr(test, assert_instr(sha512sum1r))]hlv_wu/// Loads virtual machine memory by unsigned word integer/// This instruction performs an explicit memory access as though `V=1`;/// i.e., with the address translation and protection, and the endianness, that apply to memory/// accesses in either VS-mode or VU-mode./// This operation is not available under RV32 base instruction set./// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.WU`/// instruction which is effectively a dereference to any memory address.hlv_d/// Loads virtual machine memory by double integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.D`hsv_d/// Stores virtual machine memory by double integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HSV.D`//! RISC-V RV64 specific intrinsics"llvm.riscv.aes64es"_aes64es"llvm.riscv.aes64esm"_aes64esm"llvm.riscv.aes64ds"_aes64ds"llvm.riscv.aes64dsm"_aes64dsm"llvm.riscv.aes64ks1i"_aes64ks1i"llvm.riscv.aes64ks2"_aes64ks2"llvm.riscv.aes64im"_aes64im"llvm.riscv.sha512sig0"_sha512sig0"llvm.riscv.sha512sig1"_sha512sig1"llvm.riscv.sha512sum0"_sha512sum0"llvm.riscv.sha512sum1"_sha512sum1aes64es/// AES final round encryption instruction for RV64./// Uses the two 64-bit source registers to represent the entire AES state, and produces half/// of the next round output, applying the ShiftRows and SubBytes steps. This instruction must/// Section: 3.7aes64esm/// AES middle round encryption instruction for RV64./// of the next round output, applying the ShiftRows, SubBytes and MixColumns steps. This/// instruction must always be implemented such that its execution latency does not depend on/// the data being operated on./// Section: 3.8aes64ds/// AES final round decryption instruction for RV64./// of the next round output, applying the Inverse ShiftRows and SubBytes steps. This/// Section: 3.5aes64dsm/// AES middle round decryption instruction for RV64./// of the next round output, applying the Inverse ShiftRows, SubBytes and MixColumns steps./// This instruction must always be implemented such that its execution latency does not depend/// on the data being operated on./// Section: 3.6RNUMaes64ks1i/// This instruction implements part of the KeySchedule operation for the AES Block cipher/// involving the SBox operation./// This instruction implements the rotation, SubBytes and Round Constant addition steps of the/// AES block cipher Key Schedule. This instruction must always be implemented such that its/// execution latency does not depend on the data being operated on. Note that rnum must be in/// the range 0x0..0xA. The values 0xB..0xF are reserved./// Section: 3.10/// The `RNUM` parameter is expected to be a constant value inside the range of `0..=10`.aes64ks2/// This instruction implements part of the KeySchedule operation for the AES Block cipher./// This instruction implements the additional XOR’ing of key words as part of the AES block/// cipher Key Schedule. This instruction must always be implemented such that its execution/// latency does not depend on the data being operated on./// Section: 3.11aes64im/// This instruction accelerates the inverse MixColumns step of the AES Block Cipher, and is used to aid creation of/// the decryption KeySchedule./// The instruction applies the inverse MixColumns transformation to two columns of the state array, packed/// into a single 64-bit register. It is used to create the inverse cipher KeySchedule, according to the equivalent/// inverse cipher construction in (Page 23, Section 5.3.5). This instruction must always be implemented/// Section: 3.9sha512sig0/// Implements the Sigma0 transformation function as used in the SHA2-512 hash function \[49\]/// (Section 4.1.3)./// This instruction is supported for the RV64 base architecture. It implements the Sigma0/// transform of the SHA2-512 hash function. \[49\]. This instruction must always be/// Section: 3.37sha512sig1/// Implements the Sigma1 transformation function as used in the SHA2-512 hash function \[49\]/// This instruction is supported for the RV64 base architecture. It implements the Sigma1/// Section: 3.38sha512sum0/// Implements the Sum0 transformation function as used in the SHA2-512 hash function \[49\]/// This instruction is supported for the RV64 base architecture. It implements the Sum0/// Section: 3.39sha512sum1/// Implements the Sum1 transformation function as used in the SHA2-512 hash function \[49\]/// This instruction is supported for the RV64 base architecture. It implements the Sum1/// Section: 3.40zb/// Generates the `PAUSE` instruction/// The PAUSE instruction is a HINT that indicates the current hart's rate of instruction retirement/// should be temporarily reduced or paused. The duration of its effect must be bounded and may be zero./// Generates the `NOP` instruction/// The NOP instruction does not change any architecturally visible state, except for/// advancing the `pc` and incrementing any applicable performance counters.wfi/// Generates the `WFI` instruction/// The WFI instruction provides a hint to the implementation that the current hart can be stalled/// until an interrupt might need servicing. This instruction is a hint,/// and a legal implementation is to simply implement WFI as a NOP.fence_i/// Generates the `FENCE.I` instruction/// A FENCE.I instruction ensures that a subsequent instruction fetch on a RISC-V hart will see/// any previous data stores already visible to the same RISC-V hart./// FENCE.I does not ensure that other RISC-V harts' instruction fetches will observe the/// local hart's stores in a multiprocessor system.sfence_vma/// Supervisor memory management fence for given virtual address and address space/// The fence orders only reads and writes made to leaf page table entries corresponding to/// the virtual address in parameter `vaddr`, for the address space identified by integer parameter/// `asid`. Accesses to global mappings are not ordered. The fence also invalidates all/// address-translation cache entries that contain leaf page table entries corresponding to the/// virtual address in parameter `vaddr` and that match the address space identified by integer/// parameter `asid`, except for entries containing global mappings.sfence_vma_vaddr/// Supervisor memory management fence for given virtual address/// the virtual address in parameter `vaddr`, for all address spaces./// The fence also invalidates all address-translation cache entries that contain leaf page/// table entries corresponding to the virtual address in parameter `vaddr`, for all address spaces.sfence_vma_asid/// Supervisor memory management fence for given address space/// The fence orders all reads and writes made to any level of the page tables,/// but only for the address space identified by integer parameter `asid`./// Accesses to global mappings are not ordered. The fence also invalidates all/// address-translation cache entries matching the address space identified by integersfence_vma_all/// Supervisor memory management fence for all address spaces and virtual addresses/// The fence orders all reads and writes made to any level of the page/// tables, for all address spaces. The fence also invalidates all address-translation cache entries,/// for all address spaces.sinval_vma/// Invalidate supervisor translation cache for given virtual address and address space/// This instruction invalidates any address-translation cache entries that an/// `SFENCE.VMA` instruction with the same values of `vaddr` and `asid` would invalidate.sinval_vma_vaddr/// Invalidate supervisor translation cache for given virtual addresssinval_vma_asid/// Invalidate supervisor translation cache for given address spacesinval_vma_all/// Invalidate supervisor translation cache for all address spaces and virtual addressessfence_w_inval/// Generates the `SFENCE.W.INVAL` instruction/// This instruction guarantees that any previous stores already visible to the current RISC-V hart/// are ordered before subsequent `SINVAL.VMA` instructions executed by the same hart.sfence_inval_ir/// Generates the `SFENCE.INVAL.IR` instruction/// This instruction guarantees that any previous SINVAL.VMA instructions executed by the current hart/// are ordered before subsequent implicit references by that hart to the memory-management data structures.hlv_b/// Loads virtual machine memory by signed byte integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.B`hlv_bu/// Loads virtual machine memory by unsigned byte integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.BU`hlv_h/// Loads virtual machine memory by signed half integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.H`hlv_hu/// Loads virtual machine memory by unsigned half integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.HU`hlvx_hu/// Accesses virtual machine instruction by unsigned half integer/// the memory being read must be executable in both stages of address translation,/// but read permission is not required./// This function is unsafe for it accesses the virtual supervisor or user via a `HLVX.HU`hlv_w/// Loads virtual machine memory by signed word integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLV.W`hlvx_wu/// Accesses virtual machine instruction by unsigned word integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HLVX.WU`hsv_b/// Stores virtual machine memory by byte integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HSV.B`hsv_h/// Stores virtual machine memory by half integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HSV.H`hsv_w/// Stores virtual machine memory by word integer/// This function is unsafe for it accesses the virtual supervisor or user via a `HSV.W`hfence_vvma/// Hypervisor memory management fence for given guest virtual address and guest address space/// Guarantees that any previous stores already visible to the current hart are ordered before all/// implicit reads by that hart done for VS-stage address translation for instructions that:/// - are subsequent to the `HFENCE.VVMA`, and/// - execute when `hgatp.VMID` has the same setting as it did when `HFENCE.VVMA` executed./// This fence specifies a single guest virtual address, and a single guest address-space identifier.hfence_vvma_vaddr/// Hypervisor memory management fence for given guest virtual address/// This fence specifies a single guest virtual address.hfence_vvma_asid/// Hypervisor memory management fence for given guest address space/// This fence specifies a single guest address-space identifier.hfence_vvma_all/// Hypervisor memory management fence for all guest address spaces and guest virtual addresses/// This fence applies to any guest address spaces and guest virtual addresses.hfence_gvma/// Hypervisor memory management fence for guest physical address and virtual machine/// Guarantees that any previous stores already visible to the current hart are ordered before all implicit reads/// by that hart done for G-stage address translation for instructions that follow the HFENCE.GVMA./// This fence specifies a single guest physical address, **shifted right by 2 bits**, and a single virtual machine/// by virtual machine identifier (VMID).hfence_gvma_gaddr/// Hypervisor memory management fence for guest physical address/// This fence specifies a single guest physical address; **the physical address should be shifted right by 2 bits**.hfence_gvma_vmid/// Hypervisor memory management fence for given virtual machine/// This fence specifies a single virtual machine by virtual machine identifier (VMID).hfence_gvma_all/// Hypervisor memory management fence for all virtual machines and guest physical addresses/// This fence specifies all guest physical addresses and all virtual machines.hinval_vvma/// Invalidate hypervisor translation cache for given guest virtual address and guest address space/// `HFENCE.VVMA` instruction with the same values of `vaddr` and `asid` would invalidate.hinval_vvma_vaddr/// Invalidate hypervisor translation cache for given guest virtual addresshinval_vvma_asid/// Invalidate hypervisor translation cache for given guest address spacehinval_vvma_all/// Invalidate hypervisor translation cache for all guest address spaces and guest virtual addresseshinval_gvma/// Invalidate hypervisor translation cache for guest physical address and virtual machine/// `HFENCE.GVMA` instruction with the same values of `gaddr` and `vmid` would invalidate.hinval_gvma_gaddr/// Invalidate hypervisor translation cache for guest physical addresshinval_gvma_vmid/// Invalidate hypervisor translation cache for given virtual machinehinval_gvma_all/// Invalidate hypervisor translation cache for all virtual machines and guest physical addressesfrrm/// Reads the floating-point rounding mode register `frm`/// According to "F" Standard Extension for Single-Precision Floating-Point, Version 2.2,/// the rounding mode field is defined as listed in the table below:/// | Rounding Mode | Mnemonic | Meaning |/// |:-------------|:----------|:---------|/// | 000 | RNE | Round to Nearest, ties to Even |/// | 001 | RTZ | Round towards Zero |/// | 010 | RDN | Round Down (towards −∞) |/// | 011 | RUP | Round Up (towards +∞) |/// | 100 | RMM | Round to Nearest, ties to Max Magnitude |/// | 101 |     | _Reserved for future use._ |/// | 110 |     | _Reserved for future use._ |/// | 111 | DYN | In Rounding Mode register, _reserved_. |//! Shared RISC-V intrinsics//! ## Missing floating-point register instructions//! We are deliberately *not* providing instructions that could change the floating-point rounding//! mode or exception behavior or read the accrued exceptions flags: `frcsr`, `fscsr`, `fsrm`,//! `frflags`, `fsflags`.//! Rust makes no guarantees whatsoever about the contents of the accrued exceptions register: Rust//! floating-point operations may or may not result in this register getting updated with exception//! state, and the register can change between two invocations of this function even when no//! floating-point operations appear in the source code (since floating-point operations appearing//! earlier or later can be reordered).//! Modifying the rounding mode leads to **immediate Undefined Behavior**: Rust assumes that the//! default rounding mode is always set and will optimize accordingly. This even applies when the//! rounding mode is altered and later reset to its original value without any floating-point//! operations appearing in the source code between those operations (since floating-point//! operations appearing earlier or later can be reordered).//! If you need to perform some floating-point operations and check whether they raised an//! exception, use a single inline assembly block for the entire sequence of operations.//! If you need to perform some floating-point operations under a differen rounding mode, use a//! single inline assembly block and make sure to restore the original rounding mode before the end//! of the block.add16/// Adds packed 16-bit signed numbers, discarding overflow bitsradd16/// Halves the sum of packed 16-bit signed numbers, dropping least bitsuradd16/// Halves the sum of packed 16-bit unsigned numbers, dropping least bitskadd16/// Adds packed 16-bit signed numbers, saturating at the numeric boundsukadd16/// Adds packed 16-bit unsigned numbers, saturating at the numeric boundssub16/// Subtracts packed 16-bit signed numbers, discarding overflow bitsrsub16/// Halves the subtraction result of packed 16-bit signed numbers, dropping least bitsursub16/// Halves the subtraction result of packed 16-bit unsigned numbers, dropping least bitsksub16/// Subtracts packed 16-bit signed numbers, saturating at the numeric boundsuksub16/// Subtracts packed 16-bit unsigned numbers, saturating at the numeric boundscras16/// Cross adds and subtracts packed 16-bit signed numbers, discarding overflow bitsrcras16/// Cross halves of adds and subtracts packed 16-bit signed numbers, dropping least bitsurcras16/// Cross halves of adds and subtracts packed 16-bit unsigned numbers, dropping least bitskcras16/// Cross adds and subtracts packed 16-bit signed numbers, saturating at the numeric boundsukcras16/// Cross adds and subtracts packed 16-bit unsigned numbers, saturating at the numeric boundscrsa16/// Cross subtracts and adds packed 16-bit signed numbers, discarding overflow bitsrcrsa16/// Cross halves of subtracts and adds packed 16-bit signed numbers, dropping least bitsurcrsa16/// Cross halves of subtracts and adds packed 16-bit unsigned numbers, dropping least bitskcrsa16/// Cross subtracts and adds packed 16-bit signed numbers, saturating at the numeric boundsukcrsa16/// Cross subtracts and adds packed 16-bit unsigned numbers, saturating at the numeric boundsstas16/// Straight adds and subtracts packed 16-bit signed numbers, discarding overflow bitsrstas16/// Straight halves of adds and subtracts packed 16-bit signed numbers, dropping least bitsurstas16/// Straight halves of adds and subtracts packed 16-bit unsigned numbers, dropping least bitskstas16/// Straight adds and subtracts packed 16-bit signed numbers, saturating at the numeric boundsukstas16/// Straight adds and subtracts packed 16-bit unsigned numbers, saturating at the numeric boundsstsa16/// Straight subtracts and adds packed 16-bit signed numbers, discarding overflow bitsrstsa16/// Straight halves of subtracts and adds packed 16-bit signed numbers, dropping least bitsurstsa16/// Straight halves of subtracts and adds packed 16-bit unsigned numbers, dropping least bitskstsa16/// Straight subtracts and adds packed 16-bit signed numbers, saturating at the numeric boundsukstsa16/// Straight subtracts and adds packed 16-bit unsigned numbers, saturating at the numeric bounds/// Adds packed 8-bit signed numbers, discarding overflow bitsradd8/// Halves the sum of packed 8-bit signed numbers, dropping least bitsuradd8/// Halves the sum of packed 8-bit unsigned numbers, dropping least bitskadd8/// Adds packed 8-bit signed numbers, saturating at the numeric boundsukadd8/// Adds packed 8-bit unsigned numbers, saturating at the numeric boundssub8/// Subtracts packed 8-bit signed numbers, discarding overflow bitsrsub8/// Halves the subtraction result of packed 8-bit signed numbers, dropping least bitsursub8/// Halves the subtraction result of packed 8-bit unsigned numbers, dropping least bitsksub8/// Subtracts packed 8-bit signed numbers, saturating at the numeric boundsuksub8/// Subtracts packed 8-bit unsigned numbers, saturating at the numeric boundssra16/// Arithmetic right shift packed 16-bit elements without rounding upsra16u/// Arithmetic right shift packed 16-bit elements with rounding upsrl16/// Logical right shift packed 16-bit elements without rounding upsrl16u/// Logical right shift packed 16-bit elements with rounding upsll16/// Logical left shift packed 16-bit elements, discarding overflow bitsksll16/// Logical left shift packed 16-bit elements, saturating at the numeric boundskslra16/// Logical saturating left then arithmetic right shift packed 16-bit elementskslra16usra8/// Arithmetic right shift packed 8-bit elements without rounding upsra8u/// Arithmetic right shift packed 8-bit elements with rounding upsrl8/// Logical right shift packed 8-bit elements without rounding upsrl8u/// Logical right shift packed 8-bit elements with rounding upsll8/// Logical left shift packed 8-bit elements, discarding overflow bitsksll8/// Logical left shift packed 8-bit elements, saturating at the numeric boundskslra8/// Logical saturating left then arithmetic right shift packed 8-bit elementskslra8ucmpeq16/// Compare equality for packed 16-bit elementsscmplt16/// Compare whether 16-bit packed signed integers are less than the othersscmple16/// Compare whether 16-bit packed signed integers are less than or equal to the othersucmplt16/// Compare whether 16-bit packed unsigned integers are less than the othersucmple16/// Compare whether 16-bit packed unsigned integers are less than or equal to the otherscmpeq8/// Compare equality for packed 8-bit elementsscmplt8/// Compare whether 8-bit packed signed integers are less than the othersscmple8/// Compare whether 8-bit packed signed integers are less than or equal to the othersucmplt8/// Compare whether 8-bit packed unsigned integers are less than the othersucmple8/// Compare whether 8-bit packed unsigned integers are less than or equal to the otherssmin16/// Get minimum values from 16-bit packed signed integersumin16/// Get minimum values from 16-bit packed unsigned integerssmax16/// Get maximum values from 16-bit packed signed integersumax16/// Get maximum values from 16-bit packed unsigned integerskabs16/// Compute the absolute value of packed 16-bit signed integersclrs16/// Count the number of redundant sign bits of the packed 16-bit elementsclz16/// Count the number of leading zero bits of the packed 16-bit elements/// Swap the 16-bit halfwords within each 32-bit word of a registersmin8/// Get minimum values from 8-bit packed signed integersumin8/// Get minimum values from 8-bit packed unsigned integerssmax8/// Get maximum values from 8-bit packed signed integersumax8/// Get maximum values from 8-bit packed unsigned integerskabs8/// Compute the absolute value of packed 8-bit signed integersclrs8/// Count the number of redundant sign bits of the packed 8-bit elementsclz8/// Count the number of leading zero bits of the packed 8-bit elements/// Swap the 8-bit bytes within each 16-bit halfword of a register.sunpkd810/// Unpack first and zeroth into two 16-bit signed halfwords in each 32-bit chunksunpkd820/// Unpack second and zeroth into two 16-bit signed halfwords in each 32-bit chunksunpkd830/// Unpack third and zeroth into two 16-bit signed halfwords in each 32-bit chunksunpkd831/// Unpack third and first into two 16-bit signed halfwords in each 32-bit chunksunpkd832/// Unpack third and second into two 16-bit signed halfwords in each 32-bit chunkzunpkd810/// Unpack first and zeroth into two 16-bit unsigned halfwords in each 32-bit chunkzunpkd820/// Unpack second and zeroth into two 16-bit unsigned halfwords in each 32-bit chunkzunpkd830/// Unpack third and zeroth into two 16-bit unsigned halfwords in each 32-bit chunkzunpkd831/// Unpack third and first into two 16-bit unsigned halfwords in each 32-bit chunkzunpkd832/// Unpack third and second into two 16-bit unsigned halfwords in each 32-bit chunkpkbt16/// Pack two 16-bit data from bottom and top half from 32-bit chunkspktb16/// Pack two 16-bit data from top and bottom half from 32-bit chunksclrs32/// Count the number of redundant sign bits of the packed 32-bit elementsclz32/// Count the number of leading zero bits of the packed 32-bit elementspbsad/// Calculate the sum of absolute difference of unsigned 8-bit data elementspbsada/// Calculate and accumulate the sum of absolute difference of unsigned 8-bit data elementssmaqa/// Multiply signed 8-bit elements and add 16-bit elements on results for packed 32-bit chunksumaqa/// Multiply unsigned 8-bit elements and add 16-bit elements on results for packed 32-bit chunkssmaqasu/// Multiply signed to unsigned 8-bit and add 16-bit elements on results for packed 32-bit chunkskaddh/// Adds signed lower 16-bit content of two registers with Q15 saturationksubh/// Subtracts signed lower 16-bit content of two registers with Q15 saturationukaddh/// Adds signed lower 16-bit content of two registers with U16 saturationuksubh/// Subtracts signed lower 16-bit content of two registers with U16 saturation//! RISC-V Packed SIMD intrinsics; shared part.//! RV64 only part is placed in riscv64 folder.// FIXME: Currently the P extension is still unratified, so there is no support// for it in the upstream LLVM for now, and thus no LLVM built-in functions or// serialization of instructions are provided.// We add `assert_instr(unknown)` to each function so that we can at least make// sure they compile. Since there is no serialization yet, we can only write// "unknown" here, so that if LLVM upstream provides support for the P extension// at some point in the future, we can know in time and then update our/* todo: sclip16, uclip16 *//* todo: sclip8, uclip8 */// todo: pkbb16, pktt16"llvm.riscv.orc.b.i32"_orc_b_32"llvm.riscv.clmul.i32"_clmul_32"llvm.riscv.clmulh.i32"_clmulh_32"llvm.riscv.clmulr.i32"_clmulr_32"llvm.riscv.orc.b.i64"_orc_b_64"llvm.riscv.clmul.i64"_clmul_64"llvm.riscv.clmulh.i64"_clmulh_64"llvm.riscv.clmulr.i64"_clmulr_64orc_b/// Bitwise OR-Combine, byte granule/// Combines the bits within every byte through a reciprocal bitwise logical OR. This sets the bits of each byte in/// the result rd to all zeros if no bit within the respective byte of rs is set, or to all ones if any bit within the/// respective byte of rs is set./// Source: RISC-V Bit-Manipulation ISA-extensions/// Version: v1.0.0/// Section: 2.24/// Carry-less multiply (low-part)/// clmul produces the lower half of the 2·XLEN carry-less product./// Section: 2.11clmulh/// Carry-less multiply (high-part)/// clmulh produces the upper half of the 2·XLEN carry-less product./// Section: 2.12clmulr/// Carry-less multiply (reversed)/// clmulr produces bits 2·XLEN−2:XLEN-1 of the 2·XLEN carry-less product./// Section: 2.13"llvm.riscv.sm4ed"_sm4ed"llvm.riscv.sm4ks"_sm4ks"llvm.riscv.sm3p0"_sm3p0"llvm.riscv.sm3p1"_sm3p1"llvm.riscv.sha256sig0"_sha256sig0"llvm.riscv.sha256sig1"_sha256sig1"llvm.riscv.sha256sum0"_sha256sum0"llvm.riscv.sha256sum1"_sha256sum1"llvm.riscv.xperm8.i32"_xperm8_32"llvm.riscv.xperm4.i32"_xperm4_32"llvm.riscv.xperm8.i64"_xperm8_64"llvm.riscv.xperm4.i64"_xperm4_64xperm8/// Byte-wise lookup of indicies into a vector in registers./// The xperm8 instruction operates on bytes. The rs1 register contains a vector of XLEN/8/// 8-bit elements. The rs2 register contains a vector of XLEN/8 8-bit indexes. The result is/// each element in rs2 replaced by the indexed element in rs1, or zero if the index into rs2/// is out of bounds./// Section: 3.47xperm4/// Nibble-wise lookup of indicies into a vector./// The xperm4 instruction operates on nibbles. The rs1 register contains a vector of XLEN/4/// 4-bit elements. The rs2 register contains a vector of XLEN/4 4-bit indexes. The result is/// Section: 3.48sha256sig0/// Implements the Sigma0 transformation function as used in the SHA2-256 hash function \[49\]/// (Section 4.1.2)./// This instruction is supported for both RV32 and RV64 base architectures. For RV32, the/// entire XLEN source register is operated on. For RV64, the low 32 bits of the source/// register are operated on, and the result sign extended to XLEN bits. Though named for/// SHA2-256, the instruction works for both the SHA2-224 and SHA2-256 parameterisations as/// described in \[49\]. This instruction must always be implemented such that its execution/// Section: 3.27sha256sig1/// Implements the Sigma1 transformation function as used in the SHA2-256 hash function \[49\]/// Section: 3.28sha256sum0/// Implements the Sum0 transformation function as used in the SHA2-256 hash function \[49\]/// Section: 3.29sha256sum1/// Implements the Sum1 transformation function as used in the SHA2-256 hash function \[49\]/// Section: 3.30sm4ed/// Accelerates the block encrypt/decrypt operation of the SM4 block cipher \[5, 31\]./// Implements a T-tables in hardware style approach to accelerating the SM4 round function. A/// byte is extracted from rs2 based on bs, to which the SBox and linear layer transforms are/// applied, before the result is XOR’d with rs1 and written back to rd. This instruction/// exists on RV32 and RV64 base architectures. On RV64, the 32-bit result is sign extended to/// XLEN bits. This instruction must always be implemented such that its execution latency does/// Section: 3.43/// # Details/// Accelerates the round function `F` in the SM4 block cipher algorithm/// This instruction is included in extension `Zksed`. It's defined as:/// SM4ED(x, a, BS) = x ⊕ T(ai)/// ... where/// ai = a.bytes[BS]/// T(ai) = L(τ(ai))/// bi = τ(ai) = SM4-S-Box(ai)/// ci = L(bi) = bi ⊕ (bi ≪ 2) ⊕ (bi ≪ 10) ⊕ (bi ≪ 18) ⊕ (bi ≪ 24)/// SM4ED = (ci ≪ (BS * 8)) ⊕ x/// where `⊕` represents 32-bit xor, and `≪ k` represents rotate left by `k` bits./// As is defined above, `T` is a combined transformation of non linear S-Box transform `τ`/// and linear layer transform `L`./// In the SM4 algorithm, the round function `F` is defined as:/// F(x0, x1, x2, x3, rk) = x0 ⊕ T(x1 ⊕ x2 ⊕ x3 ⊕ rk)/// T(A) = L(τ(A))/// B = τ(A) = (SM4-S-Box(a0), SM4-S-Box(a1), SM4-S-Box(a2), SM4-S-Box(a3))/// C = L(B) = B ⊕ (B ≪ 2) ⊕ (B ≪ 10) ⊕ (B ≪ 18) ⊕ (B ≪ 24)/// It can be implemented by `sm4ed` instruction like:/// # #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]/// # fn round_function(x0: u32, x1: u32, x2: u32, x3: u32, rk: u32) -> u32 {/// # #[cfg(target_arch = "riscv32")] use core::arch::riscv32::sm4ed;/// # #[cfg(target_arch = "riscv64")] use core::arch::riscv64::sm4ed;/// let a = x1 ^ x2 ^ x3 ^ rk;/// let c0 = sm4ed(x0, a, 0);/// let c1 = sm4ed(c0, a, 1); // c1 represents c[0..=1], etc./// let c2 = sm4ed(c1, a, 2);/// let c3 = sm4ed(c2, a, 3);/// return c3; // c3 represents c[0..=3]sm4ks/// Accelerates the Key Schedule operation of the SM4 block cipher \[5, 31\] with `bs=0`./// Implements a T-tables in hardware style approach to accelerating the SM4 Key Schedule. A/// Section: 3.44sm3p0/// Implements the P0 transformation function as used in the SM3 hash function [4, 30]./// This instruction is supported for the RV32 and RV64 base architectures. It implements the/// P0 transform of the SM3 hash function [4, 30]. This instruction must always be implemented/// Section: 3.41/// `P0` transformation function as is used in the SM3 hash algorithm/// This function is included in `Zksh` extension. It's defined as:/// P0(X) = X ⊕ (X ≪ 9) ⊕ (X ≪ 17)/// In the SM3 algorithm, the `P0` transformation is used as `E ← P0(TT2)` when the/// compression function `CF` uses the intermediate value `TT2` to calculate/// the variable `E` in one iteration for subsequent processes.sm3p1/// Implements the P1 transformation function as used in the SM3 hash function [4, 30]./// P1 transform of the SM3 hash function [4, 30]. This instruction must always be implemented/// Section: 3.42/// `P1` transformation function as is used in the SM3 hash algorithm/// P1(X) = X ⊕ (X ≪ 15) ⊕ (X ≪ 23)/// In the SM3 algorithm, the `P1` transformation is used to expand message,/// where expanded word `Wj` can be generated from the previous words./// The whole process can be described as the following pseudocode:/// FOR j=16 TO 67///     Wj ← P1(Wj−16 ⊕ Wj−9 ⊕ (Wj−3 ≪ 15)) ⊕ (Wj−13 ≪ 7) ⊕ Wj−6/// ENDFORl_t_t// FIXME remove when more tests are added//! `s390x` intrinsicsPackedTuplenearbyint_v4f32"llvm.nearbyint.v2f64"nearbyint_v2f64vector_double"llvm.roundeven.v4f32"roundeven_v4f32"llvm.roundeven.v2f64"roundeven_v2f64"llvm.s390.vsra"vsra"llvm.s390.vsrl"vsrl"llvm.s390.vsl""llvm.s390.vsrab""llvm.s390.vsrlb"vsrlb"llvm.s390.vslb"vslb"llvm.s390.vsrd"vsrd"llvm.s390.verimb"verimb"llvm.s390.verimh"verimh"llvm.s390.verimf"verimf"llvm.s390.verimg"verimgvector_signed_long_long"llvm.s390.vperm""llvm.s390.vsumb"vsumb"llvm.s390.vsumh"vsumh"llvm.s390.vsumgh"vsumghvector_unsigned_long_long"llvm.s390.vsumgf"vsumgf"llvm.s390.vsumqf"vsumqf"llvm.s390.vsumqg"vsumqg"llvm.s390.vaccq"vaccq"llvm.s390.vacccq"vacccq"llvm.s390.vscbiq"vscbiq"llvm.s390.vsbiq"vsbiq"llvm.s390.vsbcbiq"vsbcbiq"llvm.s390.vacq"vacq"llvm.s390.vscbib"vscbib"llvm.s390.vscbih"vscbih"llvm.s390.vscbif"vscbif"llvm.s390.vscbig"vscbig"llvm.s390.vfaeb"vfaeb"llvm.s390.vfaeh"vfaeh"llvm.s390.vfaef"vfaef"llvm.s390.vfaezb"vfaezb"llvm.s390.vfaezh"vfaezh"llvm.s390.vfaezf"vfaezf"llvm.s390.vfaebs"vfaebs"llvm.s390.vfaehs"vfaehs"llvm.s390.vfaefs"vfaefs"llvm.s390.vfaezbs"vfaezbs"llvm.s390.vfaezhs"vfaezhs"llvm.s390.vfaezfs"vfaezfs"llvm.s390.vll"vll"llvm.s390.vstl"vstl"llvm.s390.vlrl"vlrl"llvm.s390.vstrl"vstrl"llvm.s390.lcbb"lcbb"llvm.s390.vlbb"vlbb"llvm.s390.vpksh"vpksh"llvm.s390.vpksf"vpksf"llvm.s390.vpksg"vpksg"llvm.s390.vpklsh"vpklsh"llvm.s390.vpklsf"vpklsf"llvm.s390.vpklsg"vpklsg"llvm.s390.vpkshs"vpkshs"llvm.s390.vpksfs"vpksfs"llvm.s390.vpksgs"vpksgs"llvm.s390.vpklshs"vpklshs"llvm.s390.vpklsfs"vpklsfs"llvm.s390.vpklsgs"vpklsgs"llvm.s390.vavgb"vavgb"llvm.s390.vavgh"vavgh"llvm.s390.vavgf"vavgf"llvm.s390.vavgg"vavgg"llvm.s390.vavglb"vavglb"llvm.s390.vavglh"vavglh"llvm.s390.vavglf"vavglf"llvm.s390.vavglg"vavglg"llvm.s390.vcksm"vcksm"llvm.s390.vmhb"vmhb"llvm.s390.vmhh"vmhh"llvm.s390.vmhf"vmhf"llvm.s390.vmlhb"vmlhb"llvm.s390.vmlhh"vmlhh"llvm.s390.vmlhf"vmlhf"llvm.s390.vmaeb"vmaeb"llvm.s390.vmaeh"vmaeh"llvm.s390.vmaef"vmaef"llvm.s390.vmaleb"vmaleb"llvm.s390.vmaleh"vmaleh"llvm.s390.vmalef"vmalef"llvm.s390.vmaob"vmaob"llvm.s390.vmaoh"vmaoh"llvm.s390.vmaof"vmaof"llvm.s390.vmalob"vmalob"llvm.s390.vmaloh"vmaloh"llvm.s390.vmalof"vmalof"llvm.s390.vmahb"vmahb"llvm.s390.vmahh"vmahh"llvm.s390.vmahf"vmahf"llvm.s390.vmalhb"vmalhb"llvm.s390.vmalhh"vmalhh"llvm.s390.vmalhf"vmalhf"llvm.s390.vmalb"vmalb"llvm.s390.vmalh"vmalh"llvm.s390.vmalf"vmalf"llvm.s390.vmallb"vmallb"llvm.s390.vmallh"vmallh"llvm.s390.vmallf"vmallf"llvm.s390.vgfmb"vgfmb"llvm.s390.vgfmh"vgfmh"llvm.s390.vgfmf"vgfmf"llvm.s390.vgfmg"vgfmg"llvm.s390.vgfmab"vgfmab"llvm.s390.vgfmah"vgfmah"llvm.s390.vgfmaf"vgfmaf"llvm.s390.vgfmag"vgfmag"llvm.s390.vbperm"vbperm"llvm.s390.vftcisb"vftcisb"llvm.s390.vftcidb"vftcidbvector_bool_long_long"llvm.s390.vtm"vtm"llvm.s390.vstrsb"vstrsb"llvm.s390.vstrsh"vstrsh"llvm.s390.vstrsf"vstrsf"llvm.s390.vstrszb"vstrszb"llvm.s390.vstrszh"vstrszh"llvm.s390.vstrszf"vstrszf"llvm.s390.vistrb"vistrb"llvm.s390.vistrh"vistrh"llvm.s390.vistrf"vistrf"llvm.s390.vistrbs"vistrbs"llvm.s390.vistrhs"vistrhs"llvm.s390.vistrfs"vistrfs"llvm.s390.vmslg"vmslg"llvm.s390.vstrcb"vstrcb"llvm.s390.vstrch"vstrch"llvm.s390.vstrcf"vstrcf"llvm.s390.vstrcbs"vstrcbs"llvm.s390.vstrchs"vstrchs"llvm.s390.vstrcfs"vstrcfs"llvm.s390.vstrczb"vstrczb"llvm.s390.vstrczh"vstrczh"llvm.s390.vstrczf"vstrczf"llvm.s390.vstrczbs"vstrczbs"llvm.s390.vstrczhs"vstrczhs"llvm.s390.vstrczfs"vstrczfs"llvm.s390.vfeeb"vfeeb"llvm.s390.vfeeh"vfeeh"llvm.s390.vfeef"vfeef"llvm.s390.vfeezb"vfeezb"llvm.s390.vfeezh"vfeezh"llvm.s390.vfeezf"vfeezf"llvm.s390.vfeebs"vfeebs"llvm.s390.vfeehs"vfeehs"llvm.s390.vfeefs"vfeefs"llvm.s390.vfeezbs"vfeezbs"llvm.s390.vfeezhs"vfeezhs"llvm.s390.vfeezfs"vfeezfs"llvm.s390.vfeneb"vfeneb"llvm.s390.vfeneh"vfeneh"llvm.s390.vfenef"vfenef"llvm.s390.vfenezb"vfenezb"llvm.s390.vfenezh"vfenezh"llvm.s390.vfenezf"vfenezf"llvm.s390.vfenebs"vfenebs"llvm.s390.vfenehs"vfenehs"llvm.s390.vfenefs"vfenefs"llvm.s390.vfenezbs"vfenezbs"llvm.s390.vfenezhs"vfenezhs"llvm.s390.vfenezfs"vfenezfsShuffleMaskmerge_lowmerge_highevenoddunpack_lowunpack_highgenmaskgenmasksvalidate_block_boundaryFindImmEqIdxNeIdxva_floatimpl_subvs_floatimpl_maximpl_minvec_nabsVectorNabsvec_nabs_f32vec_nabs_f64VectorNmsubvec_nmsub_f32vec_nmsub_f64vec_nmaddVectorNmaddvec_nmadd_f32vec_nmadd_f64vrepbvrephvrepfvrepgimpl_bool_vec_splatsvec_cnttzvec_popcntCountBitsimpl_count_bitsnornandeqvvec_eqvVectorEqv// `simd_round_ties_even` is implemented as `llvm.rint`.vec_roundcVectorRoundcvec_rintVectorRintvec_trunc// same as vec_roundzVectorTrunc// same as vec_roundpVectorCeil// same as vec_roundmVectorFloorimpl_vec_shift_bytevec_slbVectorSlbvec_srabVectorSrabvec_srbVectorSrbvec_sralVectorSralimpl_rottest_rot_immvec_rliVectorRliimpl_rot_immvec_rl_maskVectorRlMaskimpl_rl_maskvec_reveVectorReveReverseMaskimpl_revevec_revbVectorRevbimpl_mergevec_sum_u128VectorSumU128vec_vsumqfvec_vsumqgvec_sum2VectorSum2vec_sum4VectorSum4vec_sqrtVectorSqrtvfae_wrapperimpl_vfaevec_find_any_eqVectorFindAnyEqvec_find_any_neVectorFindAnyNevec_find_any_eq_or_0_idxVectorFindAnyEqOrZeroIdxvec_find_any_ne_or_0_idxVectorFindAnyNeOrZeroIdxvec_find_any_eq_idxVectorFindAnyEqIdxvec_find_any_ne_idxVectorFindAnyNeIdxvfaes_wrappervec_find_any_eq_ccVectorFindAnyEqCCvec_find_any_ne_ccVectorFindAnyNeCCvec_find_any_eq_idx_ccVectorFindAnyEqIdxCCvec_find_any_ne_idx_ccVectorFindAnyNeIdxCCvec_find_any_eq_or_0_idx_ccVectorFindAnyEqOrZeroIdxCCvec_find_any_ne_or_0_idx_ccVectorFindAnyNeOrZeroIdxCCtest_vector_loadtest_vector_storeElementTypevec_load_lenBLOCK_BOUNDARYvec_load_bndryVectorLoadvec_store_lenVectorStoreimpl_load_storetest_vec_load_lentest_vec_load_bndrytest_vec_store_lenvec_load_pairVectorLoadPairvpkhvpkfvpkgvpacksuhvpacksufvpacksugimpl_vector_packs_ccvec_packs_ccVectorPacksCCimpl_vector_packsu_ccvec_packsu_ccVectorPacksuCCvec_msubVectorMaddsimd_fms// NOTE: `vuplh` is used for "unpack logical high", hence `vuplhw`.impl_vec_mul_even_oddvec_mulhVectorMulhvec_meaddVectorMeaddvec_moaddVectorMoaddvec_mhaddVectorMhaddsimd_mladdvec_gfmsumVectorGfmsumvec_gfmsum_accumVectorGfmsumAccumvgefvgegvec_gather_elementVectorGatherElementimpl_vec_gather_elementvscefvscegvec_scatter_elementVectorScatterElementimpl_vec_scatter_elementimpl_vec_selvec_fp_test_data_classVectorFpTestDataClassVectorCompareimpl_vec_compare// NOTE: this implementation is currently non-optimal, but it does work for floats even with// only `vector` enabled.// - https://github.com/llvm/llvm-project/issues/129434// - https://github.com/llvm/llvm-project/issues/130424vec_test_maskVectorTestMaskimpl_vec_test_maskvec_search_string_ccvec_search_string_until_zero_ccVectorSearchStringimpl_vec_search_stringvcdgbvcdlgbvec_doubleVectorDoublevcefbvcelfbvec_floatVectorFloatvec_extend_s64VectorExtendSigned64vsegbvseghvsegfvec_signedVectorSignedvec_unsignedVectorUnsignedvec_cp_until_zeroVectorCopyUntilZerovec_cp_until_zero_ccVectorCopyUntilZeroCCimpl_vec_copy_until_zero_ccvec_srdbVectorSrdbvec_sldbtest_vec_sldtest_vec_sldwtest_vec_sldbtest_vec_srdbvstrcvstrczvstrcsvstrczsVectorCompareRangevalidate_compare_range_immimpl_compare_rangeVectorComparePredicateimpl_compare_predicateVectorEqualityimpl_compare_equalityvec_cmpeq_idxvec_cmpne_idxvec_cmpeq_idx_ccvec_cmpne_idx_ccvec_cmpeq_or_0_idxvec_cmpne_or_0_idxvec_cmpeq_or_0_idx_ccvec_cmpne_or_0_idx_ccVectorEqualityIdximpl_compare_equality_idxvlgvbvlgvhvlgvfvlgvgvec_promoteVectorPromotevlvgbvlvghvlvgfvlvggvec_insert_and_zeroVectorInsertAndZerovllezbvllezhvllezfvllezgimpl_extract_insert// Z vector intrinsic      C23 math.h  LLVM IR         ISO/IEC 60559 operation        inexact  vfidb parameters// vec_rint                rint        llvm.rint       roundToIntegralExact           yes      0, 0// vec_roundc              nearbyint   llvm.nearbyint  n/a                            no       4, 0// vec_floor / vec_roundm  floor       llvm.floor      roundToIntegralTowardNegative  no       4, 7// vec_ceil / vec_roundp   ceil        llvm.ceil       roundToIntegralTowardPositive  no       4, 6// vec_trunc / vec_roundz  trunc       llvm.trunc      roundToIntegralTowardZero      no       4, 5// vec_round               roundeven   llvm.roundeven  roundToIntegralTiesToEven      no       4, 4// n/a                     round       llvm.round      roundToIntegralTiesAway        no       4, 1// FIXME(llvm): https://github.com/llvm/llvm-project/issues/153655// Other targets can use a min/max for the saturation + a truncation.// NOTE: VectorSigned and VectorUnsigned make strong safety assumptions around floats.// This is what C provides, but even IBM does not clearly document these constraints.// https://doc.rust-lang.org/std/intrinsics/simd/fn.simd_cast.html__lcbb/// Load Count to Block Boundary/// Vector Count Trailing Zeros/// Computes the population count (number of set bits) in each element of the input./// Vector Maximum/// Vector  Minimum/// Vector Absolute/// Vector Negative Absolute/// Vector Negative Multiply Add/// Vector Square Root/// Vector Splats/// Vector AND/// Vector OR/// Vector XOR/// Vector NOR/// Vector XNOR/// Vector ANDC/// Vector Floor/// Vector Ceil/// Vector Truncate/// Returns a vector containing the truncated values of the corresponding elements of the given vector./// Each element of the result contains the value of the corresponding element of a, truncated to an integral value./// Returns a vector containing the rounded values to the nearest representable floating-point integer,/// using IEEE round-to-nearest rounding, of the corresponding elements of the given vector/// Vector Round to Current/// Returns a vector by using the current rounding mode to round every/// floating-point element in the given vector to integer.vec_roundm/// Vector Round toward Negative Infinity/// Returns a vector containing the largest representable floating-point integral values less/// than or equal to the values of the corresponding elements of the given vector.vec_roundp/// Vector Round toward Positive Infinity/// Returns a vector containing the smallest representable floating-point integral values greatervec_roundz/// Vector Round toward Zero/// Vector Round to Integer/// Returns a vector by using the current rounding mode to round every floating-point element in the given vector to integer./// Vector Average/// Vector Shift Left by Byte/// Vector Shift Right by Byte/// Vector Shift Right Algebraic by Byte/// Vector Element Rotate Left/// Performs a left shift for a vector by a given number of bits. Each element of the result is obtained by shifting the corresponding/// element of a left by the number of bits specified by the last 3 bits of every byte of b. The bits that are shifted out are replaced by zeros./// Performs a right shift for a vector by a given number of bits. Each element of the result is obtained by shifting the corresponding/// element of a right by the number of bits specified by the last 3 bits of every byte of b. The bits that are shifted out are replaced by zeros./// Performs an algebraic right shift for a vector by a given number of bits. Each element of the result is obtained by shifting the corresponding/// element of a right by the number of bits specified by the last 3 bits of every byte of b. The bits that are shifted out are replaced by copies of/// the most significant bit of the element of a./// Vector Element Rotate Left Immediate/// Rotates each element of a vector left by a given number of bits. Each element of the result is obtained by rotating the corresponding element/// of a left by the number of bits specified by b, modulo the number of bits in the element./// Vector Reverse Elements/// Returns a vector with the elements of the input vector in reversed order./// Vector Byte Reverse/// Returns a vector where each vector element contains the corresponding byte-reversed vector element of the input vector./// Merges the most significant ("high") halves of two vectors./// Merges the least significant ("low") halves of two vectors./// Vector Pack Saturated Condition Code/// Vector Pack Saturated Unsigned Condition Codevec_genmask/// Vector Generate Byte Mask/// Generates byte masks for elements in the return vector. For each bit in a, if the bit is one, all bit positions/// in the corresponding byte element of d are set to ones. Otherwise, if the bit is zero, the corresponding byte element is set to zero.vec_genmasks_8/// Vector Generate Mask (Byte)vec_genmasks_16/// Vector Generate Mask (Halfword)vec_genmasks_32/// Vector Generate Mask (Word)vec_genmasks_64/// Vector Generate Mask (Doubleword)/// Vector Permute/// Returns a vector that contains some elements of two vectors, in the order specified by a third vector./// Each byte of the result is selected by using the least significant 5 bits of the corresponding byte of c as an index into the concatenated bytes of a and b./// Note: The vector generate mask built-in function [`vec_genmask`] could help generate the mask c./// Vector Sum Across Quadword/// Returns a vector containing the results of performing a sum across all the elements in each of the quadword of vector a,/// and the rightmost word or doubleword element of the b. The result is an unsigned 128-bit integer./// Vector Sum Across Doubleword/// Returns a vector containing the results of performing a sum across all the elements in each of the doubleword of vector a,/// and the rightmost sub-element of the corresponding doubleword of b./// Vector Sum Across Word/// Returns a vector containing the results of performing a sum across all the elements in each of the word of vector a,/// and the rightmost sub-element of the corresponding word of b.vec_add_u128/// Vector Addition unsigned 128-bits/// Adds unsigned quadword values./// This function operates on the vectors as 128-bit unsigned integers. It returns low 128 bits of a + b.vec_sub_u128/// Vector Subtract unsigned 128-bits/// Subtracts unsigned quadword values./// This function operates on the vectors as 128-bit unsigned integers. It returns low 128 bits of a - b./// Returns a vector containing the borrow produced by subtracting each of corresponding elements of b from a./// On each resulting element, the value is 0 if a borrow occurred, or 1 if no borrow occurred.vec_subc_u128/// Vector Subtract Carryout unsigned 128-bits/// Gets the carry bit of the 128-bit subtraction of two quadword values./// This function operates on the vectors as 128-bit unsigned integers. It returns a vector containing the borrow produced by subtracting b from a, as unsigned 128-bits integers./// If no borrow occurred, the bit 127 of d is 1; otherwise it is set to 0. All other bits of d are 0.vec_addc_u128/// Vector Add Compute Carryout unsigned 128-bitsvec_adde_u128/// Vector Add With Carry unsigned 128-bitsvec_addec_u128/// Vector Add With Carry Compute Carry unsigned 128-bitsvec_sube_u128/// Vector Subtract with Carryout/// Subtracts unsigned quadword values with carry bit from a previous operation./// This function operates on the vectors as 128-bit unsigned integers. It returns a vector containing the result of subtracting of b from a,/// and the carryout bit from a previous operation./// Note: Only the borrow indication bit (127-bit) of c is used, and the other bits are ignored.vec_subec_u128/// Vector Subtract with Carryout, Carryout/// Gets the carry bit of the 128-bit subtraction of two quadword values with carry bit from the previous operation./// It returns a vector containing the carryout produced from the result of subtracting of b from a,/// and the carryout bit from a previous operation. If no borrow occurred, the 127-bit of d is 1, otherwise 0./// All other bits of d are 0.vec_splat_s8/// Vector Splat Signed Bytevec_splat_s16/// Vector Splat Signed Halfwordvec_splat_s32/// Vector Splat Signed Wordvec_splat_s64/// Vector Splat Signed Doublewordvec_splat_u8/// Vector Splat Unsigned Bytevec_splat_u16/// Vector Splat Unsigned Halfwordvec_splat_u32/// Vector Splat Unsigned Wordvec_splat_u64/// Vector Splat Unsigned Doublewordvec_find_anyvec_find_any_cc/// Vector Load Pair/// Vector Load to Block Boundaryvec_load_len_r/// Vector Load Rightmost with Lengthvec_store_len_r/// Vector Store Rightmost with Length/// Vector Multiply and Add Even/// Vector Multiply and Add Odd/// Vector Multiply and Add High/// Vector Multiply and Add Lowvec_checksum/// Vector Checksum/// Vector Multiply High/// Vector Galois Field Multiply Sumvec_gfmsum_128/// Vector Galois Field Multiply Sum 128-bitsvec_gfmsum_accum_128/// Vector Galois Field Multiply Sum and Accumulate 128-bitsvec_bperm_u128/// Vector Bit Permute/// Vector Gather Element__VEC_CLASS_FP_ZERO_P__VEC_CLASS_FP_ZERO_N__VEC_CLASS_FP_ZERO__VEC_CLASS_FP_NORMAL_P__VEC_CLASS_FP_NORMAL_N__VEC_CLASS_FP_NORMAL__VEC_CLASS_FP_SUBNORMAL_P__VEC_CLASS_FP_SUBNORMAL_N__VEC_CLASS_FP_SUBNORMAL__VEC_CLASS_FP_INFINITY_P__VEC_CLASS_FP_INFINITY_N__VEC_CLASS_FP_INFINITY__VEC_CLASS_FP_QNAN_P__VEC_CLASS_FP_QNAN_N__VEC_CLASS_FP_QNAN__VEC_CLASS_FP_SNAN_P__VEC_CLASS_FP_SNAN_N__VEC_CLASS_FP_SNAN__VEC_CLASS_FP_NAN__VEC_CLASS_FP_NOT_NORMAL/// Vector Floating-Point Test Data Class/// You can use the `__VEC_CLASS_FP_*` constants as the argument for this operand/// Vector Test under Mask/// Vector Search String/// Vector Search String Until Zerovec_doublee/// Vector Convert from float (even elements) to double// FIXME: this emits `vflls` where `vldeb` is expected// #[cfg_attr(all(test, target_feature = "vector-enhancements-1"), assert_instr(vldeb))]vec_floate/// Vector Convert from double to float (even elements)// FIXME: the C version uses a shuffle mask with poison; we can't do that// #[cfg_attr(all(test, target_feature = "vector-enhancements-1"), assert_instr(vledb))]/// Vector Convert from int to float/// Vector Convert from long long to double/// Vector Sign Extend to Doubleword/// Vector Convert floating point to signed/// Vector Convert floating point to unsigned/// Vector Copy Until Zerovec_msum_u128/// Vector Multiply Sum Logical/// Vector Shift Left Double by Byte/// Vector Shift Left Double by Word/// Vector Shift Left Double by Bit/// Vector Shift Right Double by Bitvec_cmprg/// Vector Compare Rangesvec_cmpnrg/// Vector Compare Not in Rangesvec_cmprg_idx/// Vector Compare Ranges Indexvec_cmpnrg_idx/// Vector Compare Not in Ranges Indexvec_cmprg_cc/// Vector Compare Ranges with Condition Codevec_cmpnrg_cc/// Vector Compare Not in Ranges with Condition Codevec_cmprg_idx_cc/// Vector Compare Ranges Index with Condition Codevec_cmpnrg_idx_cc/// Vector Compare Not in Ranges Index with Condition Codevec_cmprg_or_0_idx/// Vector Compare Ranges or Zero Indexvec_cmpnrg_or_0_idx/// Vector Compare Not in Ranges or Zero Indexvec_cmprg_or_0_idx_cc/// Vector Compare Ranges or Zero Index with Condition Codevec_cmpnrg_or_0_idx_cc/// Vector Compare Not in Ranges or Zero Index with Condition Code/// Vector Compare Greater Than/// Vector Compare Greater Than or Equal/// Vector Compare Less/// Vector Compare Less Than or Equal/// Vector Compare Equal Index/// Vector Compare Not Equal Index/// Vector Compare Equal Index with Condition Code/// Vector Compare Not Equal Index with Condition Code/// Vector Compare Equal or Zero Index/// Vector Compare Not Equal or Zero Index/// Vector Compare Equal or Zero Index with Condition Code/// Vector Compare Not Equal or Zero Index with Condition Code/// All Elements Equal/// All Elements Not Equal/// Any Element Equal/// Any Element Not Equal/// All Elements Less Than/// All Elements Less Than or Equal/// All Elements Greater Than/// All Elements Greater Than or Equal/// Any Elements Less Than/// Any Elements Less Than or Equal/// Any Elements Greater Than/// Any Elements Greater Than or Equal/// Vector Insert and Zero/// Vector Promotereverse_maskmergel_maskmergeh_maskpack_masktest_vec_masktest_genmaskstest_vec_multest_vec_find_any_eq_cctest_vec_find_any_ne_cctest_vec_find_any_eq_idx_cctest_vec_find_any_ne_idx_cctest_vec_find_any_eq_or_0_idx_cctest_vec_find_any_ne_or_0_idx_cctest_vector_lcbbtest_vec_addc_u128test_vec_subc_u128test_vec_gfmsum_128test_vec_bperm_u128test_vec_seltest_vec_gather_elementtest_vec_fp_test_data_classtest_vec_fp_any_all_nan_numerictest_vec_test_masktest_vec_search_string_cctest_vec_search_string_until_zero_cctest_vec_doubleetest_vec_floatetest_vec_extend_s64test_vec_signedtest_vec_unsignedtest_vec_cp_until_zerotest_vec_cp_until_zero_cctest_vec_msum_u128GTtest_vec_cmprgtest_vec_cmpnrgtest_vec_cmprg_idxtest_vec_cmpnrg_idxtest_vec_cmprg_or_0_idxtest_vec_cmpnrg_or_0_idxtest_vec_meaddtest_vec_moaddtest_vec_mhaddtest_vec_extracttest_vec_inserttest_vec_promotetest_vec_insert_and_zero//! s390x vector intrinsics.//! For more info see the [Reference Summary] or the online [IBM docs].//! [Reference Summary]: https://www.ibm.com/support/pages/sites/default/files/2021-05/SA22-7871-10.pdf//! [IBM docs]: https://www.ibm.com/docs/en/zos/2.4.0?topic=support-vector-built-in-functionssimd_tysimd_m_tyr" A value of this type where all elements are zeroed out."r" Extract the element at position `index`."r" `index` is not a constant so this is not efficient!"r" Use for testing only."f16x4f16x8m8x16bool_to_internalm16x8m32x4m64x2f16x16m8x32m16x16m32x8f16x32// 1024-bit wide types:debug_simd_finish/// Used to continue `Debug`ging SIMD types as `MySimd(1, 2, 3, 4)`, as they/// were before moving to array-based simd.//! Internal `#[repr(simd)]` types// 16-bit wide types:// 32-bit wide types:// 64-bit wide types:// 128-bit wide types:// 256-bit wide types:// 512-bit wide types:"llvm.wasm.memory.atomic.wait32"llvm_atomic_wait_i32"llvm.wasm.memory.atomic.wait64"llvm_atomic_wait_i64"llvm.wasm.memory.atomic.notify"llvm_atomic_notifymemory_atomic_wait32/// Corresponding intrinsic to wasm's [`memory.atomic.wait32` instruction][instr]/// This function, when called, will block the current thread if the memory/// pointed to by `ptr` is equal to `expression` (performing this action/// atomically)./// The argument `timeout_ns` is a maximum number of nanoseconds the calling/// thread will be blocked for, if it blocks. If the timeout is negative then/// the calling thread will be blocked forever./// The calling thread can only be woken up with a call to the `wake` intrinsic/// once it has been blocked. Changing the memory behind `ptr` will not wake/// the thread once it's blocked./// * 0 - indicates that the thread blocked and then was woken up/// * 1 - the loaded value from `ptr` didn't match `expression`, the thread///   didn't block/// * 2 - the thread blocked, but the timeout expired./// [instr]: https://webassembly.github.io/threads/core/syntax/instructions.html#syntax-instr-atomic-memorymemory_atomic_wait64/// Corresponding intrinsic to wasm's [`memory.atomic.wait64` instruction][instr]memory_atomic_notify/// Corresponding intrinsic to wasm's [`memory.atomic.notify` instruction][instr]/// This function will notify a number of threads blocked on the address/// indicated by `ptr`. Threads previously blocked with the `i32_atomic_wait`/// and `i64_atomic_wait` functions above will be woken up./// The `waiters` argument indicates how many waiters should be woken up (a/// maximum). If the value is zero no waiters are woken up./// Returns the number of waiters which were actually notified."llvm.wasm.memory.grow"llvm_memory_grow"llvm.wasm.memory.size"llvm_memory_sizeMEMmemory_size/// Corresponding intrinsic to wasm's [`memory.size` instruction][instr]/// This function, when called, will return the current memory size in units of/// pages. The current WebAssembly page size is 65536 bytes (64 KB)./// The argument `MEM` is the numerical index of which memory to return the/// size of. Note that currently the WebAssembly specification only supports one/// memory, so it is required that zero is passed in. The argument is present to/// be forward-compatible with future WebAssembly revisions. If a nonzero/// argument is passed to this function it will currently unconditionally abort./// [instr]: http://webassembly.github.io/spec/core/exec/instructions.html#exec-memory-sizememory_grow/// Corresponding intrinsic to wasm's [`memory.grow` instruction][instr]/// This function, when called, will attempt to grow the default linear memory/// by the specified `delta` of pages. The current WebAssembly page size is/// 65536 bytes (64 KB). If memory is successfully grown then the previous size/// of memory, in pages, is returned. If memory cannot be grown then/// `usize::MAX` is returned./// [instr]: http://webassembly.github.io/spec/core/exec/instructions.html#exec-memory-growrelaxed_simd/// Generates the [`unreachable`] instruction, which causes an unconditional [trap]./// This function is safe to call and immediately aborts the execution./// [`unreachable`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-control/// [trap]: https://webassembly.github.io/spec/core/intro/overview.html#trapf32_ceil/// Generates the [`f32.ceil`] instruction, returning the smallest integer greater than or equal to `a`./// This method is useful when targeting `no_std` and is equivalent to [`std::f32::ceil()`]./// [`std::f32::ceil()`]: https://doc.rust-lang.org/std/primitive.f32.html#method.ceil/// [`f32.ceil`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf32_floor/// Generates the [`f32.floor`] instruction, returning the largest integer less than or equal to `a`./// This method is useful when targeting `no_std` and is equivalent to [`std::f32::floor()`]./// [`std::f32::floor()`]: https://doc.rust-lang.org/std/primitive.f32.html#method.floor/// [`f32.floor`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf32_trunc/// Generates the [`f32.trunc`] instruction, roundinging to the nearest integer towards zero./// This method is useful when targeting `no_std` and is equivalent to [`std::f32::trunc()`]./// [`std::f32::trunc()`]: https://doc.rust-lang.org/std/primitive.f32.html#method.trunc/// [`f32.trunc`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf32_nearest/// Generates the [`f32.nearest`] instruction, roundinging to the nearest integer. Rounds half-way/// cases to the number with an even least significant digit./// This method is useful when targeting `no_std` and is equivalent to [`std::f32::round_ties_even()`]./// [`std::f32::round_ties_even()`]: https://doc.rust-lang.org/std/primitive.f32.html#method.round_ties_even/// [`f32.nearest`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf32_sqrt/// Generates the [`f32.sqrt`] instruction, returning the square root of the number `a`./// This method is useful when targeting `no_std` and is equivalent to [`std::f32::sqrt()`]./// [`std::f32::sqrt()`]: https://doc.rust-lang.org/std/primitive.f32.html#method.sqrt/// [`f32.sqrt`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf64_ceil/// Generates the [`f64.ceil`] instruction, returning the smallest integer greater than or equal to `a`./// This method is useful when targeting `no_std` and is equivalent to [`std::f64::ceil()`]./// [`std::f64::ceil()`]: https://doc.rust-lang.org/std/primitive.f64.html#method.ceil/// [`f64.ceil`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf64_floor/// Generates the [`f64.floor`] instruction, returning the largest integer less than or equal to `a`./// This method is useful when targeting `no_std` and is equivalent to [`std::f64::floor()`]./// [`std::f64::floor()`]: https://doc.rust-lang.org/std/primitive.f64.html#method.floor/// [`f64.floor`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf64_trunc/// Generates the [`f64.trunc`] instruction, roundinging to the nearest integer towards zero./// This method is useful when targeting `no_std` and is equivalent to [`std::f64::trunc()`]./// [`std::f64::trunc()`]: https://doc.rust-lang.org/std/primitive.f64.html#method.trunc/// [`f64.trunc`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf64_nearest/// Generates the [`f64.nearest`] instruction, roundinging to the nearest integer. Rounds half-way/// This method is useful when targeting `no_std` and is equivalent to [`std::f64::round_ties_even()`]./// [`std::f64::round_ties_even()`]: https://doc.rust-lang.org/std/primitive.f64.html#method.round_ties_even/// [`f64.nearest`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numericf64_sqrt/// Generates the [`f64.sqrt`] instruction, returning the square root of the number `a`./// This method is useful when targeting `no_std` and is equivalent to [`std::f64::sqrt()`]./// [`std::f64::sqrt()`]: https://doc.rust-lang.org/std/primitive.f64.html#method.sqrt/// [`f64.sqrt`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-numeric//! WASM32 intrinsics"llvm.wasm.relaxed.swizzle"llvm_relaxed_swizzle"llvm.wasm.relaxed.trunc.signed"llvm_relaxed_trunc_signed"llvm.wasm.relaxed.trunc.unsigned"llvm_relaxed_trunc_unsigned"llvm.wasm.relaxed.trunc.signed.zero"llvm_relaxed_trunc_signed_zero"llvm.wasm.relaxed.trunc.unsigned.zero"llvm_relaxed_trunc_unsigned_zero"llvm.wasm.relaxed.madd.v4f32"llvm_f32x4_fma"llvm.wasm.relaxed.nmadd.v4f32"llvm_f32x4_fms"llvm.wasm.relaxed.madd.v2f64"llvm_f64x2_fma"llvm.wasm.relaxed.nmadd.v2f64"llvm_f64x2_fms"llvm.wasm.relaxed.laneselect.v16i8"llvm_i8x16_laneselect"llvm.wasm.relaxed.laneselect.v8i16"llvm_i16x8_laneselect"llvm.wasm.relaxed.laneselect.v4i32"llvm_i32x4_laneselect"llvm.wasm.relaxed.laneselect.v2i64"llvm_i64x2_laneselect"llvm.wasm.relaxed.min.v4f32"llvm_f32x4_relaxed_min"llvm.wasm.relaxed.min.v2f64"llvm_f64x2_relaxed_min"llvm.wasm.relaxed.max.v4f32"llvm_f32x4_relaxed_max"llvm.wasm.relaxed.max.v2f64"llvm_f64x2_relaxed_max"llvm.wasm.relaxed.q15mulr.signed"llvm_relaxed_q15mulr_signed"llvm.wasm.relaxed.dot.i8x16.i7x16.signed"llvm_i16x8_relaxed_dot_i8x16_i7x16_s"llvm.wasm.relaxed.dot.i8x16.i7x16.add.signed"llvm_i32x4_relaxed_dot_i8x16_i7x16_add_si8x16_relaxed_swizzle/// A relaxed version of `i8x16_swizzle(a, s)` which selects lanes from `a`/// using indices in `s`./// Indices in the range `[0,15]` will select the `i`-th element of `a`./// If the high bit of any element of `s` is set (meaning 128 or greater) then/// the corresponding output lane is guaranteed to be zero. Otherwise if the/// element of `s` is within the range `[16,128)` then the output lane is either/// 0 or `a[s[i] % 16]` depending on the implementation.u8x16_relaxed_swizzlei32x4_relaxed_trunc_f32x4/// A relaxed version of `i32x4_trunc_sat_f32x4(a)` converts the `f32` lanes/// of `a` to signed 32-bit integers./// Values which don't fit in 32-bit integers or are NaN may have the same/// result as `i32x4_trunc_sat_f32x4` or may return `i32::MIN`.u32x4_relaxed_trunc_f32x4/// A relaxed version of `u32x4_trunc_sat_f32x4(a)` converts the `f32` lanes/// of `a` to unsigned 32-bit integers./// Values which don't fit in 32-bit unsigned integers or are NaN may have the/// same result as `u32x4_trunc_sat_f32x4` or may return `u32::MAX`.i32x4_relaxed_trunc_f64x2_zero/// A relaxed version of `i32x4_trunc_sat_f64x2_zero(a)` converts the `f64`/// lanes of `a` to signed 32-bit integers and the upper two lanes are zero.u32x4_relaxed_trunc_f64x2_zero/// A relaxed version of `u32x4_trunc_sat_f64x2_zero(a)` converts the `f64`/// lanes of `a` to unsigned 32-bit integers and the upper two lanes are zero.f32x4_relaxed_madd/// Computes `a * b + c` with either one rounding or two roundings.f32x4_relaxed_nmadd/// Computes `-a * b + c` with either one rounding or two roundings.f64x2_relaxed_maddf64x2_relaxed_nmaddi8x16_relaxed_laneselect/// A relaxed version of `v128_bitselect` where this either behaves the same as/// `v128_bitselect` or the high bit of each lane `m` is inspected and the/// corresponding lane of `a` is chosen if the bit is 1 or the lane of `b` is/// chosen if it's zero./// If the `m` mask's lanes are either all-one or all-zero then this instruction/// is the same as `v128_bitselect`.u8x16_relaxed_laneselecti16x8_relaxed_laneselectu16x8_relaxed_laneselecti32x4_relaxed_laneselectu32x4_relaxed_laneselecti64x2_relaxed_laneselectu64x2_relaxed_laneselectf32x4_relaxed_min/// A relaxed version of `f32x4_min` which is either `f32x4_min` or/// `f32x4_pmin`.f32x4_relaxed_max/// A relaxed version of `f32x4_max` which is either `f32x4_max` or/// `f32x4_pmax`.f64x2_relaxed_min/// A relaxed version of `f64x2_min` which is either `f64x2_min` or/// `f64x2_pmin`.f64x2_relaxed_max/// A relaxed version of `f64x2_max` which is either `f64x2_max` or/// `f64x2_pmax`.i16x8_relaxed_q15mulr/// A relaxed version of `i16x8_relaxed_q15mulr` where if both lanes are/// `i16::MIN` then the result is either `i16::MIN` or `i16::MAX`.u16x8_relaxed_q15mulri16x8_relaxed_dot_i8x16_i7x16/// A relaxed dot-product instruction./// This instruction will perform pairwise products of the 8-bit values in `a`/// and `b` and then accumulate adjacent pairs into 16-bit results producing a/// final `i16x8` vector. The bytes of `a` are always interpreted as signed and/// the bytes in `b` may be interpreted as signed or unsigned. If the top bit in/// `b` isn't set then the value is the same regardless of whether it's signed/// or unsigned./// The accumulation into 16-bit values may be saturated on some platforms, and/// on other platforms it may wrap-around on overflow.u16x8_relaxed_dot_i8x16_i7x16i32x4_relaxed_dot_i8x16_i7x16_add/// Similar to [`i16x8_relaxed_dot_i8x16_i7x16`] except that the intermediate/// `i16x8` result is fed into `i32x4_extadd_pairwise_i16x8` followed by/// `i32x4_add` to add the value `c` to the result.u32x4_relaxed_dot_i8x16_i7x16_addtest_relaxed_swizzletest_relaxed_trunctest_madd"llvm.wasm.swizzle"llvm_swizzle"llvm.wasm.bitselect.v16i8"llvm_bitselect"llvm.wasm.anytrue.v16i8"llvm_any_true_i8x16"llvm.wasm.alltrue.v16i8"llvm_i8x16_all_true"llvm.wasm.bitmask.v16i8"llvm_bitmask_i8x16"llvm.wasm.narrow.signed.v16i8.v8i16"llvm_narrow_i8x16_s"llvm.wasm.narrow.unsigned.v16i8.v8i16"llvm_narrow_i8x16_u"llvm.wasm.avgr.unsigned.v16i8"llvm_avgr_u_i8x16"llvm.wasm.extadd.pairwise.signed.v8i16"llvm_i16x8_extadd_pairwise_i8x16_s"llvm.wasm.extadd.pairwise.unsigned.v8i16"llvm_i16x8_extadd_pairwise_i8x16_u"llvm.wasm.q15mulr.sat.signed"llvm_q15mulr"llvm.wasm.alltrue.v8i16"llvm_i16x8_all_true"llvm.wasm.bitmask.v8i16"llvm_bitmask_i16x8"llvm.wasm.narrow.signed.v8i16.v4i32"llvm_narrow_i16x8_s"llvm.wasm.narrow.unsigned.v8i16.v4i32"llvm_narrow_i16x8_u"llvm.wasm.avgr.unsigned.v8i16"llvm_avgr_u_i16x8"llvm.wasm.extadd.pairwise.signed.v4i32"llvm_i32x4_extadd_pairwise_i16x8_s"llvm.wasm.extadd.pairwise.unsigned.v4i32"llvm_i32x4_extadd_pairwise_i16x8_u"llvm.wasm.alltrue.v4i32"llvm_i32x4_all_true"llvm.wasm.bitmask.v4i32"llvm_bitmask_i32x4"llvm.wasm.dot"llvm_i32x4_dot_i16x8_s"llvm.wasm.alltrue.v2i64"llvm_i64x2_all_true"llvm.wasm.bitmask.v2i64"llvm_bitmask_i64x2llvm_f32x4_nearest"llvm.minimum.v4f32"llvm_f32x4_min"llvm.maximum.v4f32"llvm_f32x4_maxllvm_f64x2_nearest"llvm.minimum.v2f64"llvm_f64x2_min"llvm.maximum.v2f64"llvm_f64x2_maxv128_load/// Loads a `v128` vector from the given heap address./// This intrinsic will emit a load with an alignment of 1. While this is/// provided for completeness it is not strictly necessary, you can also load/// the pointer directly:/// let a: &v128 = ...;/// let value = unsafe { v128_load(a) };/// // .. is the same as ../// let value = *a;/// The alignment of the load can be configured by doing a manual load without/// this intrinsic./// This intrinsic is unsafe because it takes a raw pointer as an argument, and/// the pointer must be valid to load 16 bytes from. Note that there is no/// alignment requirement on this pointer since this intrinsic performs a/// 1-aligned load.i16x8_load_extend_i8x8/// Load eight 8-bit integers and sign extend each one to a 16-bit lane/// the pointer must be valid to load 8 bytes from. Note that there is noi16x8_load_extend_u8x8/// Load eight 8-bit integers and zero extend each one to a 16-bit laneu16x8_load_extend_u8x8i32x4_load_extend_i16x4/// Load four 16-bit integers and sign extend each one to a 32-bit lanei32x4_load_extend_u16x4/// Load four 16-bit integers and zero extend each one to a 32-bit laneu32x4_load_extend_u16x4i64x2_load_extend_i32x2/// Load two 32-bit integers and sign extend each one to a 64-bit lanei64x2_load_extend_u32x2/// Load two 32-bit integers and zero extend each one to a 64-bit laneu64x2_load_extend_u32x2v128_load8_splat/// Load a single element and splat to all lanes of a v128 vector./// While this intrinsic is provided for completeness it can also be replaced/// with `u8x16_splat(*m)` and it should generate equivalent code (and also not/// require `unsafe`)./// the pointer must be valid to load 1 byte from. Note that there is nov128_load16_splat/// with `u16x8_splat(*m)` and it should generate equivalent code (and also not/// the pointer must be valid to load 2 bytes from. Note that there is nov128_load32_splat/// with `u32x4_splat(*m)` and it should generate equivalent code (and also not/// the pointer must be valid to load 4 bytes from. Note that there is nov128_load64_splat/// with `u64x2_splat(*m)` and it should generate equivalent code (and also notv128_load32_zero/// Load a 32-bit element into the low bits of the vector and sets all other/// bits to zero./// This intrinsic is provided for completeness and is equivalent to `u32x4(*m,/// 0, 0, 0)` (which doesn't require `unsafe`).v128_load64_zero/// Load a 64-bit element into the low bits of the vector and sets all other/// This intrinsic is provided for completeness and is equivalent to/// `u64x2_replace_lane::<0>(u64x2(0, 0), *m)` (which doesn't require `unsafe`).v128_store/// Stores a `v128` vector to the given heap address./// This intrinsic will emit a store with an alignment of 1. While this is/// provided for completeness it is not strictly necessary, you can also store/// let a: &mut v128 = ...;/// unsafe { v128_store(a, value) };/// *a = value;/// The alignment of the store can be configured by doing a manual store without/// the pointer must be valid to store 16 bytes to. Note that there is no/// 1-aligned store.v128_load8_lane/// Loads an 8-bit value from `m` and sets lane `L` of `v` to that value./// `u8x16_replace_lane::<L>(v, *m)` (which doesn't require `unsafe`).v128_load16_lane/// Loads a 16-bit value from `m` and sets lane `L` of `v` to that value./// `u16x8_replace_lane::<L>(v, *m)` (which doesn't require `unsafe`).v128_load32_lane/// Loads a 32-bit value from `m` and sets lane `L` of `v` to that value./// `u32x4_replace_lane::<L>(v, *m)` (which doesn't require `unsafe`).v128_load64_lane/// Loads a 64-bit value from `m` and sets lane `L` of `v` to that value./// `u64x2_replace_lane::<L>(v, *m)` (which doesn't require `unsafe`).v128_store8_lane/// Stores the 8-bit value from lane `L` of `v` into `m`/// `*m = u8x16_extract_lane::<L>(v)` (which doesn't require `unsafe`)./// the pointer must be valid to store 1 byte to. Note that there is nov128_store16_lane/// Stores the 16-bit value from lane `L` of `v` into `m`/// `*m = u16x8_extract_lane::<L>(v)` (which doesn't require `unsafe`)./// the pointer must be valid to store 2 bytes to. Note that there is nov128_store32_lane/// Stores the 32-bit value from lane `L` of `v` into `m`/// `*m = u32x4_extract_lane::<L>(v)` (which doesn't require `unsafe`)./// the pointer must be valid to store 4 bytes to. Note that there is nov128_store64_lane/// Stores the 64-bit value from lane `L` of `v` into `m`/// `*m = u64x2_extract_lane::<L>(v)` (which doesn't require `unsafe`)./// the pointer must be valid to store 8 bytes to. Note that there is no/// Materializes a SIMD value from the provided operands./// If possible this will generate a `v128.const` instruction, otherwise it may/// be lowered to a sequence of instructions to materialize the vector value.I0I4I5I6I7I9I10I12I13I14I15i8x16_shuffle/// Returns a new vector with lanes selected from the lanes of the two input/// vectors `$a` and `$b` specified in the 16 immediate operands./// The `$a` and `$b` expressions must have type `v128`, and this function/// generates a wasm instruction that is encoded with 16 bytes providing the/// indices of the elements to return. The indices `i` in range [0, 15] select/// the `i`-th element of `a`. The indices in range [16, 31] select the `i -/// 16`-th element of `b`./// Note that this is a macro due to the codegen requirements of all of the/// index expressions `$i*` must be constant. A compiler error will be/// generated if any of the expressions are not constant./// All indexes `$i*` must have the type `u32`.u8x16_shufflei16x8_shuffle/// Same as [`i8x16_shuffle`], except operates as if the inputs were eight/// 16-bit integers, only taking 8 indices to shuffle./// Indices in the range [0, 7] select from `a` while [8, 15] select from `b`./// Note that this will generate the `i8x16.shuffle` instruction, since there/// is no native `i16x8.shuffle` instruction (there is no need for one since/// `i8x16.shuffle` suffices).u16x8_shufflei32x4_shuffle/// Same as [`i8x16_shuffle`], except operates as if the inputs were four/// 32-bit integers, only taking 4 indices to shuffle./// Indices in the range [0, 3] select from `a` while [4, 7] select from `b`./// is no native `i32x4.shuffle` instruction (there is no need for one sinceu32x4_shufflei64x2_shuffle/// Same as [`i8x16_shuffle`], except operates as if the inputs were two/// 64-bit integers, only taking 2 indices to shuffle./// Indices in the range [0, 1] select from `a` while [2, 3] select from `b`./// Note that this will generate the `v8x16.shuffle` instruction, since there/// is no native `i64x2.shuffle` instruction (there is no need for one sinceu64x2_shufflei8x16_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 16 packed i8 numbers./// Extracts the scalar value of lane specified in the immediate mode operand/// `N` from `a`. If `N` is out of bounds then it is a compile time error.u8x16_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 16 packed u8 numbers.i8x16_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 16 packed i8 numbers./// Replaces the scalar value of lane specified in the immediate mode operandu8x16_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 16 packed u8 numbers.i16x8_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 8 packed i16 numbers./// Extracts a the scalar value of lane specified in the immediate mode operandu16x8_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 8 packed u16 numbers.i16x8_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 8 packed i16 numbers.u16x8_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 8 packed u16 numbers.i32x4_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 4 packed i32 numbers.u32x4_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 4 packed u32 numbers.i32x4_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 4 packed i32 numbers.u32x4_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 4 packed u32 numbers.i64x2_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 2 packed i64 numbers.u64x2_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 2 packed u64 numbers.i64x2_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 2 packed i64 numbers.u64x2_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 2 packed u64 numbers.f32x4_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 4 packed f32 numbers./// Extracts the scalar value of lane specified fn the immediate mode operandf32x4_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 4 packed f32 numbers./// Replaces the scalar value of lane specified fn the immediate mode operandf64x2_extract_lane/// Extracts a lane from a 128-bit vector interpreted as 2 packed f64 numbers./// `N` from `a`. If `N` fs out of bounds then it is a compile time error.f64x2_replace_lane/// Replaces a lane from a 128-bit vector interpreted as 2 packed f64 numbers.i8x16_swizzle/// Returns a new vector with lanes selected from the lanes of the first input/// vector `a` specified in the second input vector `s`./// The indices `i` in range [0, 15] select the `i`-th element of `a`. For/// indices outside of the range the resulting lane is 0.u8x16_swizzlei8x16_splat/// Creates a vector with identical lanes./// Constructs a vector with `x` replicated to all 16 lanes.u8x16_splati16x8_splat/// Construct a vector with `x` replicated to all 8 lanes.u16x8_splati32x4_splat/// Constructs a vector with `x` replicated to all 4 lanes.u32x4_splati64x2_splat/// Construct a vector with `x` replicated to all 2 lanes.u64x2_splatf32x4_splatf64x2_splat/// Constructs a vector with `x` replicated to all 2 lanes.i8x16_eq/// Compares two 128-bit vectors as if they were two vectors of 16 eight-bit/// Returns a new vector where each lane is all ones if the corresponding input elements/// were equal, or all zeros otherwise.i8x16_ne/// were not equal, or all zeros otherwise.u8x16_equ8x16_nei8x16_lt/// signed integers./// Returns a new vector where each lane is all ones if the lane-wise left/// element is less than the right element, or all zeros otherwise.u8x16_lti8x16_gt/// element is greater than the right element, or all zeros otherwise.u8x16_gti8x16_leu8x16_lei8x16_geu8x16_gei16x8_eq/// Compares two 128-bit vectors as if they were two vectors of 8 sixteen-biti16x8_neu16x8_equ16x8_nei16x8_ltu16x8_lti16x8_gtu16x8_gti16x8_leu16x8_lei16x8_geu16x8_gei32x4_eq/// Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-biti32x4_neu32x4_equ32x4_nei32x4_ltu32x4_lti32x4_gtu32x4_gti32x4_leu32x4_lei32x4_geu32x4_gei64x2_eq/// Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-biti64x2_neu64x2_equ64x2_nei64x2_lti64x2_gti64x2_lei64x2_gef32x4_eqf32x4_nef32x4_ltf32x4_gtf32x4_lef32x4_gef64x2_eqf64x2_nef64x2_ltf64x2_gtf64x2_lef64x2_gev128_not/// Flips each bit of the 128-bit input vector.v128_and/// Performs a bitwise and of the two input 128-bit vectors, returning the/// resulting vector.v128_andnot/// Bitwise AND of bits of `a` and the logical inverse of bits of `b`./// This operation is equivalent to `v128.and(a, v128.not(b))`v128_or/// Performs a bitwise or of the two input 128-bit vectors, returning thev128_xor/// Performs a bitwise xor of the two input 128-bit vectors, returning thev128_bitselect/// Use the bitmask in `c` to select bits from `v1` when 1 and `v2` when 0.v128_any_true/// Returns `true` if any bit in `a` is set, or `false` otherwise.i8x16_abs/// Lane-wise wrapping absolute value.i8x16_neg/// Negates a 128-bit vectors interpreted as sixteen 8-bit signed integersi8x16_popcnt/// Count the number of bits set to one within each lane.u8x16_popcnti8x16_all_true/// Returns true if all lanes are non-zero, false otherwise.u8x16_all_truei8x16_bitmask/// Extracts the high bit for each lane in `a` and produce a scalar mask with/// all bits concatenated.u8x16_bitmaski8x16_narrow_i16x8/// Converts two input vectors into a smaller lane vector by narrowing each/// Signed saturation to 0x7f or 0x80 is used and the input lanes are always/// interpreted as signed integers.u8x16_narrow_i16x8/// Signed saturation to 0x00 or 0xff is used and the input lanes are alwaysi8x16_shl/// Shifts each lane to the left by the specified number of bits./// Only the low bits of the shift amount are used if the shift amount is/// greater than the lane width.u8x16_shli8x16_shr/// Shifts each lane to the right by the specified number of bits, sign/// extending.u8x16_shr/// Shifts each lane to the right by the specified number of bits, shifting in/// zeros.i8x16_add/// Adds two 128-bit vectors as if they were two packed sixteen 8-bit integers.u8x16_addi8x16_add_sat/// Adds two 128-bit vectors as if they were two packed sixteen 8-bit signed/// integers, saturating on overflow to `i8::MAX`.u8x16_add_sat/// Adds two 128-bit vectors as if they were two packed sixteen 8-bit unsigned/// integers, saturating on overflow to `u8::MAX`.i8x16_sub/// Subtracts two 128-bit vectors as if they were two packed sixteen 8-bit integers.u8x16_subi8x16_sub_sat/// Subtracts two 128-bit vectors as if they were two packed sixteen 8-bit/// signed integers, saturating on overflow to `i8::MIN`.u8x16_sub_sat/// unsigned integers, saturating on overflow to 0.i8x16_min/// Compares lane-wise signed integers, and returns the minimum of/// each pair.u8x16_min/// Compares lane-wise unsigned integers, and returns the minimum ofi8x16_max/// Compares lane-wise signed integers, and returns the maximum ofu8x16_max/// Compares lane-wise unsigned integers, and returns the maximum ofu8x16_avgr/// Lane-wise rounding average.i16x8_extadd_pairwise_i8x16/// Integer extended pairwise addition producing extended results/// (twice wider results than the inputs).i16x8_extadd_pairwise_u8x16u16x8_extadd_pairwise_u8x16i16x8_absi16x8_neg/// Negates a 128-bit vectors interpreted as eight 16-bit signed integersi16x8_q15mulr_sat/// Lane-wise saturating rounding multiplication in Q15 format.i16x8_all_trueu16x8_all_truei16x8_bitmasku16x8_bitmaski16x8_narrow_i32x4/// Signed saturation to 0x7fff or 0x8000 is used and the input lanes are alwaysu16x8_narrow_i32x4/// Signed saturation to 0x0000 or 0xffff is used and the input lanes are alwaysi16x8_extend_low_i8x16/// Converts low half of the smaller lane vector to a larger lane/// vector, sign extended.i16x8_extend_high_i8x16/// Converts high half of the smaller lane vector to a larger lanei16x8_extend_low_u8x16/// vector, zero extended.u16x8_extend_low_u8x16i16x8_extend_high_u8x16u16x8_extend_high_u8x16i16x8_shlu16x8_shli16x8_shru16x8_shri16x8_add/// Adds two 128-bit vectors as if they were two packed eight 16-bit integers.u16x8_addi16x8_add_sat/// Adds two 128-bit vectors as if they were two packed eight 16-bit signed/// integers, saturating on overflow to `i16::MAX`.u16x8_add_sat/// Adds two 128-bit vectors as if they were two packed eight 16-bit unsigned/// integers, saturating on overflow to `u16::MAX`.i16x8_sub/// Subtracts two 128-bit vectors as if they were two packed eight 16-bit integers.u16x8_subi16x8_sub_sat/// Subtracts two 128-bit vectors as if they were two packed eight 16-bit/// signed integers, saturating on overflow to `i16::MIN`.u16x8_sub_sati16x8_mul/// Multiplies two 128-bit vectors as if they were two packed eight 16-bitu16x8_muli16x8_minu16x8_mini16x8_maxu16x8_maxu16x8_avgri16x8_extmul_low_i8x16/// Lane-wise integer extended multiplication producing twice wider result than/// the inputs./// Equivalent of `i16x8_mul(i16x8_extend_low_i8x16(a), i16x8_extend_low_i8x16(b))`i16x8_extmul_high_i8x16/// Equivalent of `i16x8_mul(i16x8_extend_high_i8x16(a), i16x8_extend_high_i8x16(b))`i16x8_extmul_low_u8x16/// Equivalent of `i16x8_mul(i16x8_extend_low_u8x16(a), i16x8_extend_low_u8x16(b))`u16x8_extmul_low_u8x16i16x8_extmul_high_u8x16/// Equivalent of `i16x8_mul(i16x8_extend_high_u8x16(a), i16x8_extend_high_u8x16(b))`u16x8_extmul_high_u8x16i32x4_extadd_pairwise_i16x8i32x4_extadd_pairwise_u16x8u32x4_extadd_pairwise_u16x8i32x4_absi32x4_neg/// Negates a 128-bit vectors interpreted as four 32-bit signed integersi32x4_all_trueu32x4_all_truei32x4_bitmasku32x4_bitmaski32x4_extend_low_i16x8i32x4_extend_high_i16x8i32x4_extend_low_u16x8u32x4_extend_low_u16x8i32x4_extend_high_u16x8u32x4_extend_high_u16x8i32x4_shlu32x4_shli32x4_shru32x4_shri32x4_add/// Adds two 128-bit vectors as if they were two packed four 32-bit integers.u32x4_addi32x4_sub/// Subtracts two 128-bit vectors as if they were two packed four 32-bit integers.u32x4_subi32x4_mul/// Multiplies two 128-bit vectors as if they were two packed four 32-bitu32x4_muli32x4_minu32x4_mini32x4_maxu32x4_maxi32x4_dot_i16x8/// Lane-wise multiply signed 16-bit integers in the two input vectors and add/// adjacent pairs of the full 32-bit results.i32x4_extmul_low_i16x8/// Equivalent of `i32x4_mul(i32x4_extend_low_i16x8_s(a), i32x4_extend_low_i16x8_s(b))`i32x4_extmul_high_i16x8/// Equivalent of `i32x4_mul(i32x4_extend_high_i16x8_s(a), i32x4_extend_high_i16x8_s(b))`i32x4_extmul_low_u16x8/// Equivalent of `i32x4_mul(i32x4_extend_low_u16x8(a), i32x4_extend_low_u16x8(b))`u32x4_extmul_low_u16x8i32x4_extmul_high_u16x8/// Equivalent of `i32x4_mul(i32x4_extend_high_u16x8(a), i32x4_extend_high_u16x8(b))`u32x4_extmul_high_u16x8i64x2_absi64x2_neg/// Negates a 128-bit vectors interpreted as two 64-bit signed integersi64x2_all_trueu64x2_all_truei64x2_bitmasku64x2_bitmaski64x2_extend_low_i32x4i64x2_extend_high_i32x4i64x2_extend_low_u32x4u64x2_extend_low_u32x4i64x2_extend_high_u32x4u64x2_extend_high_u32x4i64x2_shlu64x2_shli64x2_shru64x2_shri64x2_add/// Adds two 128-bit vectors as if they were two packed two 64-bit integers.u64x2_addi64x2_sub/// Subtracts two 128-bit vectors as if they were two packed two 64-bit integers.u64x2_subi64x2_mul/// Multiplies two 128-bit vectors as if they were two packed two 64-bit integers.u64x2_muli64x2_extmul_low_i32x4/// Equivalent of `i64x2_mul(i64x2_extend_low_i32x4_s(a), i64x2_extend_low_i32x4_s(b))`i64x2_extmul_high_i32x4/// Equivalent of `i64x2_mul(i64x2_extend_high_i32x4_s(a), i64x2_extend_high_i32x4_s(b))`i64x2_extmul_low_u32x4/// Equivalent of `i64x2_mul(i64x2_extend_low_i32x4_u(a), i64x2_extend_low_i32x4_u(b))`u64x2_extmul_low_u32x4i64x2_extmul_high_u32x4/// Equivalent of `i64x2_mul(i64x2_extend_high_i32x4_u(a), i64x2_extend_high_i32x4_u(b))`u64x2_extmul_high_u32x4f32x4_ceil/// Lane-wise rounding to the nearest integral value not smaller than the input.f32x4_floor/// Lane-wise rounding to the nearest integral value not greater than the input.f32x4_trunc/// Lane-wise rounding to the nearest integral value with the magnitude not/// larger than the input.f32x4_nearest/// Lane-wise rounding to the nearest integral value; if two values are equally/// near, rounds to the even one.f32x4_abs/// Calculates the absolute value of each lane of a 128-bit vector interpreted/// as four 32-bit floating point numbers.f32x4_neg/// Negates each lane of a 128-bit vector interpreted as four 32-bit floating/// point numbers.f32x4_sqrt/// Calculates the square root of each lane of a 128-bit vector interpreted as/// four 32-bit floating point numbers.f32x4_add/// Lane-wise addition of two 128-bit vectors interpreted as four 32-bitf32x4_sub/// Lane-wise subtraction of two 128-bit vectors interpreted as four 32-bitf32x4_mul/// Lane-wise multiplication of two 128-bit vectors interpreted as four 32-bitf32x4_div/// Lane-wise division of two 128-bit vectors interpreted as four 32-bitf32x4_min/// Calculates the lane-wise minimum of two 128-bit vectors interpretedf32x4_maxf32x4_pmin/// Lane-wise minimum value, defined as `b < a ? b : a`f32x4_pmax/// Lane-wise maximum value, defined as `a < b ? b : a`f64x2_ceilf64x2_floorf64x2_truncf64x2_nearestf64x2_abs/// as two 64-bit floating point numbers.f64x2_neg/// Negates each lane of a 128-bit vector interpreted as two 64-bit floatingf64x2_sqrt/// two 64-bit floating point numbers.f64x2_add/// Lane-wise add of two 128-bit vectors interpreted as two 64-bitf64x2_sub/// Lane-wise subtract of two 128-bit vectors interpreted as two 64-bitf64x2_mul/// Lane-wise multiply of two 128-bit vectors interpreted as two 64-bitf64x2_div/// Lane-wise divide of two 128-bit vectors interpreted as two 64-bitf64x2_minf64x2_max/// Calculates the lane-wise maximum of two 128-bit vectors interpretedf64x2_pminf64x2_pmaxi32x4_trunc_sat_f32x4/// Converts a 128-bit vector interpreted as four 32-bit floating point numbers/// into a 128-bit vector of four 32-bit signed integers./// NaN is converted to 0 and if it's out of bounds it becomes the nearest/// representable intger.u32x4_trunc_sat_f32x4/// into a 128-bit vector of four 32-bit unsigned integers.f32x4_convert_i32x4/// Converts a 128-bit vector interpreted as four 32-bit signed integers into a/// 128-bit vector of four 32-bit floating point numbers.f32x4_convert_u32x4/// Converts a 128-bit vector interpreted as four 32-bit unsigned integers into ai32x4_trunc_sat_f64x2_zero/// Saturating conversion of the two double-precision floating point lanes to/// two lower integer lanes using the IEEE `convertToIntegerTowardZero`/// The two higher lanes of the result are initialized to zero. If any input/// lane is a NaN, the resulting lane is 0. If the rounded integer value of a/// lane is outside the range of the destination type, the result is saturated/// to the nearest representable integer value.u32x4_trunc_sat_f64x2_zerof64x2_convert_low_i32x4/// Lane-wise conversion from integer to floating point.f64x2_convert_low_u32x4f32x4_demote_f64x2_zero/// Conversion of the two double-precision floating point lanes to two lower/// single-precision lanes of the result. The two higher lanes of the result are/// initialized to zero. If the conversion result is not representable as a/// single-precision floating point number, it is rounded to the nearest-even/// representable number.f64x2_promote_low_f32x4/// Conversion of the two lower single-precision floating point lanes to the two/// double-precision lanes of the result._C1_C2_C3_C4_C5_C6_C7_C8_C9_C10test_loadtest_load_extendtest_load_splattest_load_zerotest_storetest_load_lanetest_store_lanetest_i8x16test_extract// tests extract and replace lanestest_swizzletest_splattest_bitmaskstest_narrowtest_dottest_binoptest_unopavgrAvgrimpl_avgrIsNantest_boptest_bopstest_uopv128_bitwise_logical_opstest_bool_redtest_convtest_conversionstest_popcnttest_promote_demotetest_extmultest_q15mulr_sat_stest_extadd//! This module implements the [WebAssembly `SIMD128` ISA].//! [WebAssembly `SIMD128` ISA]://! https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md_lzcnt_u32/// Counts the leading most significant zero bits./// When the operand is zero, it returns its size in bits./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_lzcnt_u32)_popcnt32/// Counts the bits that are set./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_popcnt32)//! Advanced Bit Manipulation (ABM) instructions//! The POPCNT and LZCNT have their own CPUID bits to indicate support.//! The references are://! - [Intel 64 and IA-32 Architectures Software Developer's Manual Volume 2://!   Instruction Set Reference, A-Z][intel64_ref].//! - [AMD64 Architecture Programmer's Manual, Volume 3: General-Purpose and//!   System Instructions][amd64_ref].//! [Wikipedia][wikipedia_bmi] provides a quick overview of the instructions//! [intel64_ref]: http://www.intel.de/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf//! [amd64_ref]: http://support.amd.com/TechDocs/24594.pdf//! [wikipedia_bmi]://! https://en.wikipedia.org/wiki/Bit_Manipulation_Instruction_Sets#ABM_.28Advanced_Bit_Manipulation.29"llvm.x86.addcarry.32"llvm_addcarry_u32"llvm.x86.subborrow.32"llvm_subborrow_u32_addcarry_u32/// Adds unsigned 32-bit integers `a` and `b` with unsigned 8-bit carry-in `c_in`/// (carry or overflow flag), and store the unsigned 32-bit result in `out`, and the carry-out/// is returned (carry or overflow flag)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_addcarry_u32)_addcarryx_u32/// (carry or overflow flag), and store the unsigned 32-bit result in `out`, and/// the carry-out is returned (carry or overflow flag)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_addcarryx_u32)_subborrow_u32/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_subborrow_u32)"llvm.x86.aesni.aesdec"aesdec"llvm.x86.aesni.aesdeclast"aesdeclast"llvm.x86.aesni.aesenc""llvm.x86.aesni.aesenclast"aesenclast"llvm.x86.aesni.aesimc"aesimc"llvm.x86.aesni.aeskeygenassist"aeskeygenassist_mm_aesdec_si128/// Performs one round of an AES decryption flow on data (state) in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesdec_si128)_mm_aesdeclast_si128/// Performs the last round of an AES decryption flow on data (state) in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesdeclast_si128)_mm_aesenc_si128/// Performs one round of an AES encryption flow on data (state) in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesenc_si128)_mm_aesenclast_si128/// Performs the last round of an AES encryption flow on data (state) in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesenclast_si128)_mm_aesimc_si128/// Performs the `InvMixColumns` transformation on `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesimc_si128)_mm_aeskeygenassist_si128/// Assist in expanding the AES cipher key./// Assist in expanding the AES cipher key by computing steps towards/// generating a round key for encryption cipher using data from `a` and an/// 8-bit round constant `IMM8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aeskeygenassist_si128)//! AES New Instructions (AES-NI)//! The intrinsics here correspond to those in the `wmmintrin.h` C header.//! The reference is [Intel 64 and IA-32 Architectures Software Developer's//! Manual Volume 2: Instruction Set Reference, A-Z][intel64_ref]./// Adds packed double-precision (64-bit) floating-point elements/// in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_add_pd)_mm256_add_ps/// Adds packed single-precision (32-bit) floating-point elements in `a` and/// `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_add_ps)_mm256_and_pd/// Computes the bitwise AND of a packed double-precision (64-bit)/// floating-point elements in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_and_pd)// See https://github.com/rust-lang/stdarch/issues/71_mm256_and_ps/// Computes the bitwise AND of packed single-precision (32-bit) floating-point/// elements in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_and_ps)_mm256_or_pd/// Computes the bitwise OR packed double-precision (64-bit) floating-point/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_or_pd)// See <https://github.com/rust-lang/stdarch/issues/71>._mm256_or_ps/// Computes the bitwise OR packed single-precision (32-bit) floating-point/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_or_ps)_mm256_shuffle_pd/// Shuffles double-precision (64-bit) floating-point elements within 128-bit/// lanes using the control in `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_pd)_mm256_shuffle_ps/// Shuffles single-precision (32-bit) floating-point elements in `a` within/// 128-bit lanes using the control in `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_ps)_mm256_andnot_pd/// Computes the bitwise NOT of packed double-precision (64-bit) floating-point/// elements in `a`, and then AND with `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_andnot_pd)_mm256_andnot_ps/// Computes the bitwise NOT of packed single-precision (32-bit) floating-point/// elements in `a`/// and then AND with `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_andnot_ps)_mm256_max_pd/// Compares packed double-precision (64-bit) floating-point elements/// in `a` and `b`, and returns packed maximum values/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_pd)_mm256_max_ps/// Compares packed single-precision (32-bit) floating-point elements in `a`/// and `b`, and returns packed maximum values/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_ps)_mm256_min_pd/// in `a` and `b`, and returns packed minimum values/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_pd)_mm256_min_ps/// and `b`, and returns packed minimum values/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_ps)_mm256_mul_pd/// Multiplies packed double-precision (64-bit) floating-point elements/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mul_pd)_mm256_mul_ps/// Multiplies packed single-precision (32-bit) floating-point elements in `a` and/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mul_ps)_mm256_addsub_pd/// Alternatively adds and subtracts packed double-precision (64-bit)/// floating-point elements in `a` to/from packed elements in `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_addsub_pd)_mm256_addsub_ps/// Alternatively adds and subtracts packed single-precision (32-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_addsub_ps)_mm256_sub_pd/// Subtracts packed double-precision (64-bit) floating-point elements in `b`/// from packed elements in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sub_pd)_mm256_sub_ps/// Subtracts packed single-precision (32-bit) floating-point elements in `b`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sub_ps)_mm256_div_ps/// Computes the division of each of the 8 packed 32-bit floating-point elements/// in `a` by the corresponding packed elements in `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_div_ps)_mm256_div_pd/// Computes the division of each of the 4 packed 64-bit floating-point elements/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_div_pd)ROUNDING_mm256_round_pd/// Rounds packed double-precision (64-bit) floating point elements in `a`/// according to the flag `ROUNDING`. The value of `ROUNDING` may be as follows:/// - `0x00`: Round to the nearest whole number./// - `0x01`: Round down, toward negative infinity./// - `0x02`: Round up, toward positive infinity./// - `0x03`: Truncate the values./// For a complete list of options, check [the LLVM docs][llvm_docs]./// [llvm_docs]: https://github.com/llvm-mirror/clang/blob/dcd8d797b20291f1a6b3e0ddda085aa2bbb382a8/lib/Headers/avxintrin.h#L382/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_round_pd)_mm256_ceil_pd/// toward positive infinity./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_ceil_pd)_mm256_floor_pd/// toward negative infinity./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_floor_pd)_mm256_round_ps/// Rounds packed single-precision (32-bit) floating point elements in `a`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_round_ps)_mm256_ceil_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_ceil_ps)_mm256_floor_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_floor_ps)_mm256_sqrt_ps/// Returns the square root of packed single-precision (32-bit) floating point/// elements in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sqrt_ps)_mm256_sqrt_pd/// Returns the square root of packed double-precision (64-bit) floating point/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sqrt_pd)_mm256_blend_pd/// Blends packed double-precision (64-bit) floating-point elements from/// `a` and `b` using control mask `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blend_pd)// Note: LLVM7 prefers single-precision blend instructions when// possible, see: https://bugs.llvm.org/show_bug.cgi?id=38194// #[cfg_attr(test, assert_instr(vblendpd, imm8 = 9))]_mm256_blend_ps/// Blends packed single-precision (32-bit) floating-point elements from/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blend_ps)_mm256_blendv_pd/// `a` and `b` using `c` as a mask./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blendv_pd)_mm256_blendv_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blendv_ps)_mm256_dp_ps/// Conditionally multiplies the packed single-precision (32-bit) floating-point/// elements in `a` and `b` using the high 4 bits in `imm8`,/// sum the four products, and conditionally return the sum///  using the low 4 bits of `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_dp_ps)_mm256_hadd_pd/// Horizontal addition of adjacent pairs in the two packed vectors/// of 4 64-bit floating points `a` and `b`./// In the result, sums of elements from `a` are returned in even locations,/// while sums of elements from `b` are returned in odd locations./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hadd_pd)_mm256_hadd_ps/// of 8 32-bit floating points `a` and `b`./// In the result, sums of elements from `a` are returned in locations of/// indices 0, 1, 4, 5; while sums of elements from `b` are locations/// 2, 3, 6, 7./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hadd_ps)_mm256_hsub_pd/// Horizontal subtraction of adjacent pairs in the two packed vectors/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hsub_pd)_mm256_hsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hsub_ps)_mm256_xor_pd/// Computes the bitwise XOR of packed double-precision (64-bit) floating-point/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_xor_pd)_mm256_xor_ps/// Computes the bitwise XOR of packed single-precision (32-bit) floating-point/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_xor_ps)_CMP_EQ_OQ/// Equal (ordered, non-signaling)_CMP_LT_OS/// Less-than (ordered, signaling)_CMP_LE_OS/// Less-than-or-equal (ordered, signaling)_CMP_UNORD_Q/// Unordered (non-signaling)_CMP_NEQ_UQ/// Not-equal (unordered, non-signaling)_CMP_NLT_US/// Not-less-than (unordered, signaling)_CMP_NLE_US/// Not-less-than-or-equal (unordered, signaling)_CMP_ORD_Q/// Ordered (non-signaling)_CMP_EQ_UQ/// Equal (unordered, non-signaling)_CMP_NGE_US/// Not-greater-than-or-equal (unordered, signaling)_CMP_NGT_US/// Not-greater-than (unordered, signaling)_CMP_FALSE_OQ/// False (ordered, non-signaling)_CMP_NEQ_OQ/// Not-equal (ordered, non-signaling)_CMP_GE_OS/// Greater-than-or-equal (ordered, signaling)_CMP_GT_OS/// Greater-than (ordered, signaling)_CMP_TRUE_UQ/// True (unordered, non-signaling)_CMP_EQ_OS/// Equal (ordered, signaling)_CMP_LT_OQ/// Less-than (ordered, non-signaling)_CMP_LE_OQ/// Less-than-or-equal (ordered, non-signaling)_CMP_UNORD_S/// Unordered (signaling)_CMP_NEQ_US/// Not-equal (unordered, signaling)_CMP_NLT_UQ/// Not-less-than (unordered, non-signaling)_CMP_NLE_UQ/// Not-less-than-or-equal (unordered, non-signaling)_CMP_ORD_S/// Ordered (signaling)_CMP_EQ_US/// Equal (unordered, signaling)_CMP_NGE_UQ/// Not-greater-than-or-equal (unordered, non-signaling)_CMP_NGT_UQ/// Not-greater-than (unordered, non-signaling)_CMP_FALSE_OS/// False (ordered, signaling)_CMP_NEQ_OS/// Not-equal (ordered, signaling)_CMP_GE_OQ/// Greater-than-or-equal (ordered, non-signaling)_CMP_GT_OQ/// Greater-than (ordered, non-signaling)_CMP_TRUE_US/// True (unordered, signaling)_mm_cmp_pd/// Compares packed double-precision (64-bit) floating-point/// elements in `a` and `b` based on the comparison operand/// specified by `IMM5`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_pd)// TODO Validate vcmppd_mm256_cmp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_pd)_mm_cmp_ps/// Compares packed single-precision (32-bit) floating-point/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_ps)// TODO Validate vcmpps_mm256_cmp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_ps)_mm_cmp_sd/// Compares the lower double-precision (64-bit) floating-point element in/// `a` and `b` based on the comparison operand specified by `IMM5`,/// store the result in the lower element of returned vector,/// and copies the upper element from `a` to the upper element of returned/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_sd)// TODO Validate vcmpsd_mm_cmp_ss/// Compares the lower single-precision (32-bit) floating-point element in/// and copies the upper 3 packed elements from `a` to the upper elements of/// returned vector./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_ss)// TODO Validate vcmpss_mm256_cvtepi32_pd/// Converts packed 32-bit integers in `a` to packed double-precision (64-bit)/// floating-point elements./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi32_pd)_mm256_cvtepi32_ps/// Converts packed 32-bit integers in `a` to packed single-precision (32-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi32_ps)_mm256_cvtpd_ps/// Converts packed double-precision (64-bit) floating-point elements in `a`/// to packed single-precision (32-bit) floating-point elements./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtpd_ps)_mm256_cvtps_epi32/// Converts packed single-precision (32-bit) floating-point elements in `a`/// to packed 32-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtps_epi32)_mm256_cvtps_pd/// to packed double-precision (64-bit) floating-point elements./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtps_pd)_mm256_cvtsd_f64/// Returns the first element of the input vector of `[4 x double]`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsd_f64)//#[cfg_attr(test, assert_instr(movsd))] FIXME_mm256_cvttpd_epi32/// to packed 32-bit integers with truncation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttpd_epi32)_mm256_cvtpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtpd_epi32)_mm256_cvttps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttps_epi32)/// Extracts 128 bits (composed of 4 packed single-precision (32-bit)/// floating-point elements) from `a`, selected with `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extractf128_ps)/// Extracts 128 bits (composed of 2 packed double-precision (64-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extractf128_pd)_mm256_extractf128_si256/// Extracts 128 bits (composed of integer data) from `a`, selected with `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extractf128_si256)_mm256_extract_epi32/// Extracts a 32-bit integer from `a`, selected with `INDEX`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extract_epi32)// This intrinsic has no corresponding instruction._mm256_cvtsi256_si32/// Returns the first element of the input vector of `[8 x i32]`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsi256_si32)_mm256_zeroall/// Zeroes the contents of all XMM or YMM registers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_zeroall)_mm256_zeroupper/// Zeroes the upper 128 bits of all YMM registers;/// the lower 128-bits of the registers are unmodified./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_zeroupper)_mm256_permutevar_ps/// Shuffles single-precision (32-bit) floating-point elements in `a`/// within 128-bit lanes using the control in `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutevar_ps)_mm_permutevar_ps/// using the control in `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutevar_ps)_mm256_permute_ps/// within 128-bit lanes using the control in `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute_ps)_mm_permute_ps/// using the control in `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permute_ps)_mm256_permutevar_pd/// Shuffles double-precision (64-bit) floating-point elements in `a`/// within 256-bit lanes using the control in `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutevar_pd)_mm_permutevar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutevar_pd)_mm256_permute_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute_pd)_mm_permute_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permute_pd)_mm256_permute2f128_ps/// Shuffles 256 bits (composed of 8 packed single-precision (32-bit)/// floating-point elements) selected by `imm8` from `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute2f128_ps)_mm256_permute2f128_pd/// Shuffles 256 bits (composed of 4 packed double-precision (64-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute2f128_pd)_mm256_permute2f128_si256/// Shuffles 128-bits (composed of integer data) selected by `imm8`/// from `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute2f128_si256)_mm256_broadcast_ss/// Broadcasts a single-precision (32-bit) floating-point element from memory/// to all elements of the returned vector./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_ss)_mm_broadcast_ss/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcast_ss)_mm256_broadcast_sd/// Broadcasts a double-precision (64-bit) floating-point element from memory/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_sd)_mm256_broadcast_ps/// Broadcasts 128 bits from memory (composed of 4 packed single-precision/// (32-bit) floating-point elements) to all elements of the returned vector./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_ps)_mm256_broadcast_pd/// Broadcasts 128 bits from memory (composed of 2 packed double-precision/// (64-bit) floating-point elements) to all elements of the returned vector./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_pd)_mm256_insertf128_ps/// Copies `a` to result, then inserts 128 bits (composed of 4 packed/// single-precision (32-bit) floating-point elements) from `b` into result/// at the location specified by `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insertf128_ps)_mm256_insertf128_pd/// Copies `a` to result, then inserts 128 bits (composed of 2 packed/// double-precision (64-bit) floating-point elements) from `b` into result/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insertf128_pd)_mm256_insertf128_si256/// Copies `a` to result, then inserts 128 bits from `b` into result/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insertf128_si256)_mm256_insert_epi8/// Copies `a` to result, and inserts the 8-bit integer `i` into result/// at the location specified by `index`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insert_epi8)_mm256_insert_epi16/// Copies `a` to result, and inserts the 16-bit integer `i` into result/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insert_epi16)_mm256_insert_epi32/// Copies `a` to result, and inserts the 32-bit integer `i` into result/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insert_epi32)_mm256_load_pd/// Loads 256-bits (composed of 4 packed double-precision (64-bit)/// floating-point elements) from memory into result./// `mem_addr` must be aligned on a 32-byte boundary or a/// general-protection exception may be generated./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_load_pd)_mm256_store_pd/// Stores 256-bits (composed of 4 packed double-precision (64-bit)/// floating-point elements) from `a` into memory./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_store_pd)_mm256_load_ps/// Loads 256-bits (composed of 8 packed single-precision (32-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_load_ps)_mm256_store_ps/// Stores 256-bits (composed of 8 packed single-precision (32-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_store_ps)/// `mem_addr` does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu_pd)_mm256_storeu_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu_pd)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu_ps)_mm256_storeu_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu_ps)_mm256_load_si256/// Loads 256-bits of integer data from memory into result./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_load_si256)// FIXME vmovdqa expected_mm256_store_si256/// Stores 256-bits of integer data from `a` into memory./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_store_si256)_mm256_loadu_si256/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu_si256)// FIXME vmovdqu expected_mm256_storeu_si256/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu_si256)_mm256_maskload_pd/// Loads packed double-precision (64-bit) floating-point elements from memory/// into result using `mask` (elements are zeroed out when the high bit of the/// corresponding element is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskload_pd)_mm256_maskstore_pd/// Stores packed double-precision (64-bit) floating-point elements from `a`/// into memory using `mask`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskstore_pd)_mm_maskload_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskload_pd)_mm_maskstore_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskstore_pd)_mm256_maskload_ps/// Loads packed single-precision (32-bit) floating-point elements from memory/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskload_ps)_mm256_maskstore_ps/// Stores packed single-precision (32-bit) floating-point elements from `a`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskstore_ps)_mm_maskload_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskload_ps)_mm_maskstore_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskstore_ps)_mm256_movehdup_ps/// Duplicate odd-indexed single-precision (32-bit) floating-point elements/// from `a`, and returns the results./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movehdup_ps)_mm256_moveldup_ps/// Duplicate even-indexed single-precision (32-bit) floating-point elements/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_moveldup_ps)_mm256_movedup_pd/// Duplicate even-indexed double-precision (64-bit) floating-point elements/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movedup_pd)_mm256_lddqu_si256/// Loads 256-bits of integer data from unaligned memory into result./// This intrinsic may perform better than `_mm256_loadu_si256` when the/// data crosses a cache line boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_lddqu_si256)_mm256_stream_si256/// Moves integer data from a 256-bit integer vector to a 32-byte/// aligned memory location. To minimize caching, the data is flagged as/// non-temporal (unlikely to be used again soon)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_stream_si256)/// # Safety of non-temporal stores/// After using this intrinsic, but before any other access to the memory that this intrinsic/// mutates, a call to [`_mm_sfence`] must be performed by the thread that used the intrinsic. In/// particular, functions that call this intrinsic should generally call `_mm_sfence` before they/// See [`_mm_sfence`] for details._mm256_stream_pd/// Moves double-precision values from a 256-bit vector of `[4 x double]`/// to a 32-byte aligned memory location. To minimize caching, the data is/// flagged as non-temporal (unlikely to be used again soon)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_stream_pd)_mm256_stream_ps/// Moves single-precision floating point values from a 256-bit vector/// of `[8 x float]` to a 32-byte aligned memory location. To minimize/// caching, the data is flagged as non-temporal (unlikely to be used again/// soon)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_stream_ps)_mm256_rcp_ps/// Computes the approximate reciprocal of packed single-precision (32-bit)/// floating-point elements in `a`, and returns the results. The maximum/// relative error for this approximation is less than 1.5*2^-12./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rcp_ps)_mm256_rsqrt_ps/// Computes the approximate reciprocal square root of packed single-precision/// (32-bit) floating-point elements in `a`, and returns the results./// The maximum relative error for this approximation is less than 1.5*2^-12./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rsqrt_ps)_mm256_unpackhi_pd/// Unpacks and interleave double-precision (64-bit) floating-point elements/// from the high half of each 128-bit lane in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpackhi_pd)_mm256_unpackhi_ps/// Unpacks and interleave single-precision (32-bit) floating-point elements/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpackhi_ps)_mm256_unpacklo_pd/// from the low half of each 128-bit lane in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpacklo_pd)_mm256_unpacklo_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpacklo_ps)_mm256_testz_si256/// Computes the bitwise AND of 256 bits (representing integer data) in `a` and/// `b`, and set `ZF` to 1 if the result is zero, otherwise set `ZF` to 0./// Computes the bitwise NOT of `a` and then AND with `b`, and set `CF` to 1 if/// the result is zero, otherwise set `CF` to 0. Return the `ZF` value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testz_si256)_mm256_testc_si256/// the result is zero, otherwise set `CF` to 0. Return the `CF` value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testc_si256)_mm256_testnzc_si256/// the result is zero, otherwise set `CF` to 0. Return 1 if both the `ZF` and/// `CF` values are zero, otherwise return 0./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testnzc_si256)_mm256_testz_pd/// Computes the bitwise AND of 256 bits (representing double-precision (64-bit)/// floating-point elements) in `a` and `b`, producing an intermediate 256-bit/// value, and set `ZF` to 1 if the sign bit of each 64-bit element in the/// intermediate value is zero, otherwise set `ZF` to 0. Compute the bitwise/// NOT of `a` and then AND with `b`, producing an intermediate value, and set/// `CF` to 1 if the sign bit of each 64-bit element in the intermediate value/// is zero, otherwise set `CF` to 0. Return the `ZF` value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testz_pd)_mm256_testc_pd/// is zero, otherwise set `CF` to 0. Return the `CF` value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testc_pd)_mm256_testnzc_pd/// is zero, otherwise set `CF` to 0. Return 1 if both the `ZF` and `CF` values/// are zero, otherwise return 0./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testnzc_pd)_mm_testz_pd/// Computes the bitwise AND of 128 bits (representing double-precision (64-bit)/// floating-point elements) in `a` and `b`, producing an intermediate 128-bit/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testz_pd)_mm_testc_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testc_pd)_mm_testnzc_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testnzc_pd)_mm256_testz_ps/// Computes the bitwise AND of 256 bits (representing single-precision (32-bit)/// value, and set `ZF` to 1 if the sign bit of each 32-bit element in the/// `CF` to 1 if the sign bit of each 32-bit element in the intermediate value/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testz_ps)_mm256_testc_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testc_ps)_mm256_testnzc_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testnzc_ps)_mm_testz_ps/// Computes the bitwise AND of 128 bits (representing single-precision (32-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testz_ps)_mm_testc_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testc_ps)_mm_testnzc_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testnzc_ps)_mm256_movemask_pd/// Sets each bit of the returned mask based on the most significant bit of the/// corresponding packed double-precision (64-bit) floating-point element in/// `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movemask_pd)_mm256_movemask_ps/// corresponding packed single-precision (32-bit) floating-point element in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movemask_ps)/// Returns vector of type __m256d with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setzero_pd)/// Returns vector of type __m256 with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setzero_ps)_mm256_setzero_si256/// Returns vector of type __m256i with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setzero_si256)_mm256_set_pd/// Sets packed double-precision (64-bit) floating-point elements in returned/// vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_pd)_mm256_set_ps/// Sets packed single-precision (32-bit) floating-point elements in returned/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_ps)_mm256_set_epi8/// Sets packed 8-bit integers in returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_epi8)_mm256_set_epi16/// Sets packed 16-bit integers in returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_epi16)_mm256_set_epi32/// Sets packed 32-bit integers in returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_epi32)_mm256_set_epi64x/// Sets packed 64-bit integers in returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_epi64x)_mm256_setr_pd/// vector with the supplied values in reverse order./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_pd)_mm256_setr_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_ps)_mm256_setr_epi8/// Sets packed 8-bit integers in returned vector with the supplied values in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_epi8)_mm256_setr_epi16/// Sets packed 16-bit integers in returned vector with the supplied values in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_epi16)_mm256_setr_epi32/// Sets packed 32-bit integers in returned vector with the supplied values in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_epi32)_mm256_setr_epi64x/// Sets packed 64-bit integers in returned vector with the supplied values in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_epi64x)_mm256_set1_pd/// Broadcasts double-precision (64-bit) floating-point value `a` to all/// elements of returned vector./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set1_pd)_mm256_set1_ps/// Broadcasts single-precision (32-bit) floating-point value `a` to all/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set1_ps)_mm256_set1_epi8/// Broadcasts 8-bit integer `a` to all elements of returned vector./// This intrinsic may generate the `vpbroadcastb`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set1_epi8)_mm256_set1_epi16/// Broadcasts 16-bit integer `a` to all elements of returned vector./// This intrinsic may generate the `vpbroadcastw`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set1_epi16)//#[cfg_attr(test, assert_instr(vpshufb))]_mm256_set1_epi32/// Broadcasts 32-bit integer `a` to all elements of returned vector./// This intrinsic may generate the `vpbroadcastd`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set1_epi32)_mm256_set1_epi64x/// Broadcasts 64-bit integer `a` to all elements of returned vector./// This intrinsic may generate the `vpbroadcastq`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set1_epi64x)_mm256_castpd_ps/// Cast vector of type __m256d to type __m256./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castpd_ps)// This intrinsic is only used for compilation and does not generate any// instructions, thus it has zero latency._mm256_castps_pd/// Cast vector of type __m256 to type __m256d./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castps_pd)_mm256_castps_si256/// Casts vector of type __m256 to type __m256i./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castps_si256)_mm256_castsi256_ps/// Casts vector of type __m256i to type __m256./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castsi256_ps)_mm256_castpd_si256/// Casts vector of type __m256d to type __m256i./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castpd_si256)_mm256_castsi256_pd/// Casts vector of type __m256i to type __m256d./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castsi256_pd)/// Casts vector of type __m256 to type __m128./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castps256_ps128)/// Casts vector of type __m256d to type __m128d./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castpd256_pd128)_mm256_castsi256_si128/// Casts vector of type __m256i to type __m128i./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castsi256_si128)_mm256_castps128_ps256/// Casts vector of type __m128 to type __m256;/// the upper 128 bits of the result are undefined./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castps128_ps256)_mm256_castpd128_pd256/// Casts vector of type __m128d to type __m256d;/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castpd128_pd256)_mm256_castsi128_si256/// Casts vector of type __m128i to type __m256i;/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castsi128_si256)_mm256_zextps128_ps256/// Constructs a 256-bit floating-point vector of `[8 x float]` from a/// 128-bit floating-point vector of `[4 x float]`. The lower 128 bits contain/// the value of the source vector. The upper 128 bits are set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_zextps128_ps256)_mm256_zextsi128_si256/// Constructs a 256-bit integer vector from a 128-bit integer vector./// The lower 128 bits contain the value of the source vector. The upper/// 128 bits are set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_zextsi128_si256)_mm256_zextpd128_pd256/// Constructs a 256-bit floating-point vector of `[4 x double]` from a/// 128-bit floating-point vector of `[2 x double]`. The lower 128 bits/// contain the value of the source vector. The upper 128 bits are set/// to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_zextpd128_pd256)_mm256_undefined_ps/// Returns vector of type `__m256` with indeterminate elements./// Despite using the word "undefined" (following Intel's naming scheme), this non-deterministically/// picks some valid value and is not equivalent to [`mem::MaybeUninit`]./// In practice, this is typically equivalent to [`mem::zeroed`]./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_undefined_ps)_mm256_undefined_pd/// Returns vector of type `__m256d` with indeterminate elements./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_undefined_pd)_mm256_undefined_si256/// Returns vector of type __m256i with with indeterminate elements./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_undefined_si256)_mm256_set_m128/// Sets packed __m256 returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_m128)_mm256_set_m128d/// Sets packed __m256d returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_m128d)_mm256_set_m128i/// Sets packed __m256i returned vector with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_set_m128i)_mm256_setr_m128/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_m128)_mm256_setr_m128d/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_m128d)_mm256_setr_m128i/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_setr_m128i)_mm256_loadu2_m128/// Loads two 128-bit values (composed of 4 packed single-precision (32-bit)/// floating-point elements) from memory, and combine them into a 256-bit/// `hiaddr` and `loaddr` do not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu2_m128)_mm256_loadu2_m128d/// Loads two 128-bit values (composed of 2 packed double-precision (64-bit)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu2_m128d)_mm256_loadu2_m128i/// Loads two 128-bit values (composed of integer data) from memory, and combine/// them into a 256-bit value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu2_m128i)_mm256_storeu2_m128/// Stores the high and low 128-bit halves (each composed of 4 packed/// single-precision (32-bit) floating-point elements) from `a` into memory two/// different 128-bit locations./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu2_m128)_mm256_storeu2_m128d/// Stores the high and low 128-bit halves (each composed of 2 packed/// double-precision (64-bit) floating-point elements) from `a` into memory two/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu2_m128d)_mm256_storeu2_m128i/// Stores the high and low 128-bit halves (each composed of integer data) from/// `a` into memory two different 128-bit locations./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu2_m128i)_mm256_cvtss_f32/// Returns the first element of the input vector of `[8 x float]`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtss_f32)//#[cfg_attr(test, assert_instr(movss))] FIXME"llvm.x86.avx.round.pd.256"roundpd256"llvm.x86.avx.round.ps.256"roundps256"llvm.x86.avx.dp.ps.256"vdpps"llvm.x86.sse2.cmp.pd"vcmppd"llvm.x86.avx.cmp.pd.256"vcmppd256"llvm.x86.sse.cmp.ps"vcmpps"llvm.x86.avx.cmp.ps.256"vcmpps256"llvm.x86.sse2.cmp.sd"vcmpsd"llvm.x86.sse.cmp.ss"vcmpss"llvm.x86.avx.cvt.ps2dq.256"vcvtps2dq"llvm.x86.avx.cvtt.pd2dq.256"vcvttpd2dq"llvm.x86.avx.cvt.pd2dq.256"vcvtpd2dq"llvm.x86.avx.cvtt.ps2dq.256"vcvttps2dq"llvm.x86.avx.vzeroall"vzeroall"llvm.x86.avx.vzeroupper"vzeroupper"llvm.x86.avx.vpermilvar.ps.256"vpermilps256"llvm.x86.avx.vpermilvar.ps"vpermilps"llvm.x86.avx.vpermilvar.pd.256"vpermilpd256"llvm.x86.avx.vpermilvar.pd"vpermilpd"llvm.x86.avx.ldu.dq.256"vlddqu"llvm.x86.avx.rcp.ps.256"vrcpps"llvm.x86.avx.rsqrt.ps.256"vrsqrtps"llvm.x86.avx.ptestnzc.256"ptestnzc256"llvm.x86.avx.vtestz.pd.256"vtestzpd256"llvm.x86.avx.vtestc.pd.256"vtestcpd256"llvm.x86.avx.vtestnzc.pd.256"vtestnzcpd256"llvm.x86.avx.vtestnzc.pd"vtestnzcpd"llvm.x86.avx.vtestz.ps.256"vtestzps256"llvm.x86.avx.vtestc.ps.256"vtestcps256"llvm.x86.avx.vtestnzc.ps.256"vtestnzcps256"llvm.x86.avx.vtestnzc.ps"vtestnzcps"llvm.x86.avx.min.ps.256"vminps"llvm.x86.avx.max.ps.256"vmaxps"llvm.x86.avx.min.pd.256"vminpd"llvm.x86.avx.max.pd.256"vmaxpd//! Advanced Vector Extensions (AVX)//!   Instruction Set Reference, A-Z][intel64_ref]. - [AMD64 Architecture//!   Programmer's Manual, Volume 3: General-Purpose and System//!   Instructions][amd64_ref].//! [Wikipedia][wiki] provides a quick overview of the instructions available.//! [wiki]: https://en.wikipedia.org/wiki/Advanced_Vector_Extensions// LLVM intrinsics used in the above functions_mm256_abs_epi32/// Computes the absolute values of packed 32-bit integers in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_abs_epi32)_mm256_abs_epi16/// Computes the absolute values of packed 16-bit integers in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_abs_epi16)_mm256_abs_epi8/// Computes the absolute values of packed 8-bit integers in `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_abs_epi8)_mm256_add_epi64/// Adds packed 64-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_add_epi64)_mm256_add_epi32/// Adds packed 32-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_add_epi32)_mm256_add_epi16/// Adds packed 16-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_add_epi16)_mm256_add_epi8/// Adds packed 8-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_add_epi8)_mm256_adds_epi8/// Adds packed 8-bit integers in `a` and `b` using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_adds_epi8)_mm256_adds_epi16/// Adds packed 16-bit integers in `a` and `b` using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_adds_epi16)_mm256_adds_epu8/// Adds packed unsigned 8-bit integers in `a` and `b` using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_adds_epu8)_mm256_adds_epu16/// Adds packed unsigned 16-bit integers in `a` and `b` using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_adds_epu16)_mm256_alignr_epi8/// Concatenates pairs of 16-byte blocks in `a` and `b` into a 32-byte temporary/// result, shifts the result right by `n` bytes, and returns the low 16 bytes./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_alignr_epi8)_mm256_and_si256/// Computes the bitwise AND of 256 bits (representing integer data)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_and_si256)_mm256_andnot_si256/// Computes the bitwise NOT of 256 bits (representing integer data)/// in `a` and then AND with `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_andnot_si256)_mm256_avg_epu16/// Averages packed unsigned 16-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_avg_epu16)_mm256_avg_epu8/// Averages packed unsigned 8-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_avg_epu8)_mm_blend_epi32/// Blends packed 32-bit integers from `a` and `b` using control mask `IMM4`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blend_epi32)_mm256_blend_epi32/// Blends packed 32-bit integers from `a` and `b` using control mask `IMM8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blend_epi32)_mm256_blend_epi16/// Blends packed 16-bit integers from `a` and `b` using control mask `IMM8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blend_epi16)_mm256_blendv_epi8/// Blends packed 8-bit integers from `a` and `b` using `mask`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_blendv_epi8)_mm_broadcastb_epi8/// Broadcasts the low packed 8-bit integer from `a` to all elements of/// the 128-bit returned value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastb_epi8)_mm256_broadcastb_epi8/// the 256-bit returned value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastb_epi8)_mm_broadcastd_epi32// N.B., `simd_shuffle4` with integer data types for `a` and `b` is// often compiled to `vbroadcastss`./// Broadcasts the low packed 32-bit integer from `a` to all elements of/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastd_epi32)_mm256_broadcastd_epi32// N.B., `simd_shuffle4`` with integer data types for `a` and `b` is/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastd_epi32)_mm_broadcastq_epi64/// Broadcasts the low packed 64-bit integer from `a` to all elements of/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastq_epi64)// Emits `vmovddup` instead of `vpbroadcastq`// See https://github.com/rust-lang/stdarch/issues/791_mm256_broadcastq_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastq_epi64)_mm_broadcastsd_pd/// Broadcasts the low double-precision (64-bit) floating-point element/// from `a` to all elements of the 128-bit returned value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastsd_pd)_mm256_broadcastsd_pd/// from `a` to all elements of the 256-bit returned value./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastsd_pd)_mm_broadcastsi128_si256/// Broadcasts 128 bits of integer data from a to all 128-bit lanes in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastsi128_si256)_mm256_broadcastsi128_si256// N.B., `broadcastsi128_si256` is often compiled to `vinsertf128` or// `vbroadcastf128`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastsi128_si256)_mm_broadcastss_ps/// Broadcasts the low single-precision (32-bit) floating-point element/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastss_ps)_mm256_broadcastss_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastss_ps)_mm_broadcastw_epi16/// Broadcasts the low packed 16-bit integer from a to all elements of/// the 128-bit returned value/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastw_epi16)_mm256_broadcastw_epi16/// the 256-bit returned value/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastw_epi16)_mm256_cmpeq_epi64/// Compares packed 64-bit integers in `a` and `b` for equality./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi64)_mm256_cmpeq_epi32/// Compares packed 32-bit integers in `a` and `b` for equality./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi32)_mm256_cmpeq_epi16/// Compares packed 16-bit integers in `a` and `b` for equality./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi16)_mm256_cmpeq_epi8/// Compares packed 8-bit integers in `a` and `b` for equality./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi8)_mm256_cmpgt_epi64/// Compares packed 64-bit integers in `a` and `b` for greater-than./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi64)_mm256_cmpgt_epi32/// Compares packed 32-bit integers in `a` and `b` for greater-than./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi32)_mm256_cmpgt_epi16/// Compares packed 16-bit integers in `a` and `b` for greater-than./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi16)_mm256_cmpgt_epi8/// Compares packed 8-bit integers in `a` and `b` for greater-than./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi8)_mm256_cvtepi16_epi32/// Sign-extend 16-bit integers to 32-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi16_epi32)_mm256_cvtepi16_epi64/// Sign-extend 16-bit integers to 64-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi16_epi64)_mm256_cvtepi32_epi64/// Sign-extend 32-bit integers to 64-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi32_epi64)_mm256_cvtepi8_epi16/// Sign-extend 8-bit integers to 16-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi8_epi16)_mm256_cvtepi8_epi32/// Sign-extend 8-bit integers to 32-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi8_epi32)_mm256_cvtepi8_epi64/// Sign-extend 8-bit integers to 64-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi8_epi64)_mm256_cvtepu16_epi32/// Zeroes extend packed unsigned 16-bit integers in `a` to packed 32-bit/// integers, and stores the results in `dst`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu16_epi32)_mm256_cvtepu16_epi64/// Zero-extend the lower four unsigned 16-bit integers in `a` to 64-bit/// integers. The upper four elements of `a` are unused./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu16_epi64)_mm256_cvtepu32_epi64/// Zero-extend unsigned 32-bit integers in `a` to 64-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu32_epi64)_mm256_cvtepu8_epi16/// Zero-extend unsigned 8-bit integers in `a` to 16-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu8_epi16)_mm256_cvtepu8_epi32/// Zero-extend the lower eight unsigned 8-bit integers in `a` to 32-bit/// integers. The upper eight elements of `a` are unused./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu8_epi32)_mm256_cvtepu8_epi64/// Zero-extend the lower four unsigned 8-bit integers in `a` to 64-bit/// integers. The upper twelve elements of `a` are unused./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu8_epi64)_mm256_extracti128_si256/// Extracts 128 bits (of integer data) from `a` selected with `IMM1`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extracti128_si256)_mm256_hadd_epi16/// Horizontally adds adjacent pairs of 16-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hadd_epi16)_mm256_hadd_epi32/// Horizontally adds adjacent pairs of 32-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hadd_epi32)_mm256_hadds_epi16/// Horizontally adds adjacent pairs of 16-bit integers in `a` and `b`/// using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hadds_epi16)_mm256_hsub_epi16/// Horizontally subtract adjacent pairs of 16-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hsub_epi16)_mm256_hsub_epi32/// Horizontally subtract adjacent pairs of 32-bit integers in `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hsub_epi32)_mm256_hsubs_epi16/// Horizontally subtract adjacent pairs of 16-bit integers in `a` and `b`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_hsubs_epi16)_mm_i32gather_epi32/// Returns values from `slice` at offsets determined by `offsets * scale`,/// `scale` should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i32gather_epi32)_mm_mask_i32gather_epi32/// `scale` should be 1, 2, 4 or 8. If mask is set, load the value from `src` in/// that position instead./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i32gather_epi32)_mm256_i32gather_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i32gather_epi32)_mm256_mask_i32gather_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i32gather_epi32)_mm_i32gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i32gather_ps)_mm_mask_i32gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i32gather_ps)_mm256_i32gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i32gather_ps)_mm256_mask_i32gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i32gather_ps)_mm_i32gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i32gather_epi64)_mm_mask_i32gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i32gather_epi64)_mm256_i32gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i32gather_epi64)_mm256_mask_i32gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i32gather_epi64)_mm_i32gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i32gather_pd)_mm_mask_i32gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i32gather_pd)_mm256_i32gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i32gather_pd)_mm256_mask_i32gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i32gather_pd)_mm_i64gather_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i64gather_epi32)_mm_mask_i64gather_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i64gather_epi32)_mm256_i64gather_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i64gather_epi32)_mm256_mask_i64gather_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i64gather_epi32)_mm_i64gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i64gather_ps)_mm_mask_i64gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i64gather_ps)_mm256_i64gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i64gather_ps)_mm256_mask_i64gather_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i64gather_ps)_mm_i64gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i64gather_epi64)_mm_mask_i64gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i64gather_epi64)_mm256_i64gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i64gather_epi64)_mm256_mask_i64gather_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i64gather_epi64)_mm_i64gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_i64gather_pd)_mm_mask_i64gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_i64gather_pd)_mm256_i64gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i64gather_pd)_mm256_mask_i64gather_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_i64gather_pd)_mm256_inserti128_si256/// Copies `a` to `dst`, then insert 128 bits (of integer data) from `b` at the/// location specified by `IMM1`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_inserti128_si256)_mm256_madd_epi16/// Multiplies packed signed 16-bit integers in `a` and `b`, producing/// intermediate signed 32-bit integers. Horizontally add adjacent pairs/// of intermediate 32-bit integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_madd_epi16)_mm256_maddubs_epi16/// Vertically multiplies each unsigned 8-bit integer from `a` with the/// corresponding signed 8-bit integer from `b`, producing intermediate/// signed 16-bit integers. Horizontally add adjacent pairs of intermediate/// signed 16-bit integers/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maddubs_epi16)_mm_maskload_epi32/// Loads packed 32-bit integers from memory pointed by `mem_addr` using `mask`/// (elements are zeroed out when the highest bit is not set in the/// corresponding element)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskload_epi32)_mm256_maskload_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskload_epi32)_mm_maskload_epi64/// Loads packed 64-bit integers from memory pointed by `mem_addr` using `mask`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskload_epi64)_mm256_maskload_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskload_epi64)_mm_maskstore_epi32/// Stores packed 32-bit integers from `a` into memory pointed by `mem_addr`/// using `mask` (elements are not stored when the highest bit is not set/// in the corresponding element)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskstore_epi32)_mm256_maskstore_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskstore_epi32)_mm_maskstore_epi64/// Stores packed 64-bit integers from `a` into memory pointed by `mem_addr`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskstore_epi64)_mm256_maskstore_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskstore_epi64)_mm256_max_epi16/// Compares packed 16-bit integers in `a` and `b`, and returns the packed/// maximum values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epi16)_mm256_max_epi32/// Compares packed 32-bit integers in `a` and `b`, and returns the packed/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epi32)_mm256_max_epi8/// Compares packed 8-bit integers in `a` and `b`, and returns the packed/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epi8)_mm256_max_epu16/// Compares packed unsigned 16-bit integers in `a` and `b`, and returns/// the packed maximum values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epu16)_mm256_max_epu32/// Compares packed unsigned 32-bit integers in `a` and `b`, and returns/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epu32)_mm256_max_epu8/// Compares packed unsigned 8-bit integers in `a` and `b`, and returns/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epu8)_mm256_min_epi16/// minimum values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epi16)_mm256_min_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epi32)_mm256_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epi8)_mm256_min_epu16/// the packed minimum values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epu16)_mm256_min_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epu32)_mm256_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epu8)_mm256_movemask_epi8/// Creates mask from the most significant bit of each 8-bit element in `a`,/// return the result./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movemask_epi8)_mm256_mpsadbw_epu8/// Computes the sum of absolute differences (SADs) of quadruplets of unsigned/// 8-bit integers in `a` compared to those in `b`, and stores the 16-bit/// results in dst. Eight SADs are performed for each 128-bit lane using one/// quadruplet from `b` and eight quadruplets from `a`. One quadruplet is/// selected from `b` starting at on the offset specified in `imm8`. Eight/// quadruplets are formed from sequential 8-bit integers selected from `a`/// starting at the offset specified in `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mpsadbw_epu8)_mm256_mul_epi32/// Multiplies the low 32-bit integers from each packed 64-bit element in/// `a` and `b`/// Returns the 64-bit results./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mul_epi32)_mm256_mul_epu32/// Multiplies the low unsigned 32-bit integers from each packed 64-bit/// element in `a` and `b`/// Returns the unsigned 64-bit results./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mul_epu32)_mm256_mulhi_epi16/// Multiplies the packed 16-bit integers in `a` and `b`, producing/// intermediate 32-bit integers and returning the high 16 bits of the/// intermediate integers./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mulhi_epi16)_mm256_mulhi_epu16/// Multiplies the packed unsigned 16-bit integers in `a` and `b`, producing/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mulhi_epu16)_mm256_mullo_epi16/// intermediate 32-bit integers, and returns the low 16 bits of the/// intermediate integers/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mullo_epi16)_mm256_mullo_epi32/// Multiplies the packed 32-bit integers in `a` and `b`, producing/// intermediate 64-bit integers, and returns the low 32 bits of the/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mullo_epi32)_mm256_mulhrs_epi16/// Multiplies packed 16-bit integers in `a` and `b`, producing/// intermediate signed 32-bit integers. Truncate each intermediate/// integer to the 18 most significant bits, round by adding 1, and/// return bits `[16:1]`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mulhrs_epi16)_mm256_or_si256/// Computes the bitwise OR of 256 bits (representing integer data) in `a`/// and `b`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_or_si256)_mm256_packs_epi16/// Converts packed 16-bit integers from `a` and `b` to packed 8-bit integers/// using signed saturation/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_packs_epi16)_mm256_packs_epi32/// Converts packed 32-bit integers from `a` and `b` to packed 16-bit integers/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_packs_epi32)_mm256_packus_epi16/// using unsigned saturation/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_packus_epi16)_mm256_packus_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_packus_epi32)_mm256_permutevar8x32_epi32/// Permutes packed 32-bit integers from `a` according to the content of `b`./// The last 3 bits of each integer of `b` are used as addresses into the 8/// integers of `a`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutevar8x32_epi32)_mm256_permute4x64_epi64/// Permutes 64-bit integers from `a` using control mask `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute4x64_epi64)_mm256_permute2x128_si256/// Shuffles 128-bits of integer data selected by `imm8` from `a` and `b`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute2x128_si256)_mm256_permute4x64_pd/// Shuffles 64-bit floating-point elements in `a` across lanes using the/// control in `imm8`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permute4x64_pd)_mm256_permutevar8x32_ps/// Shuffles eight 32-bit floating-point elements in `a` across lanes using/// the corresponding 32-bit integer index in `idx`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutevar8x32_ps)_mm256_sad_epu8/// Computes the absolute differences of packed unsigned 8-bit integers in `a`/// and `b`, then horizontally sum each consecutive 8 differences to/// produce four unsigned 16-bit integers, and pack these unsigned 16-bit/// integers in the low 16 bits of the 64-bit return value/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sad_epu8)_mm256_shuffle_epi8/// Shuffles bytes from `a` according to the content of `b`./// For each of the 128-bit low and high halves of the vectors, the last/// 4 bits of each byte of `b` are used as addresses into the respective/// low or high 16 bytes of `a`. That is, the halves are shuffled separately./// In addition, if the highest significant bit of a byte of `b` is set, the/// respective destination byte is set to 0./// Picturing `a` and `b` as `[u8; 32]`, `_mm256_shuffle_epi8` is logically/// equivalent to:/// fn mm256_shuffle_epi8(a: [u8; 32], b: [u8; 32]) -> [u8; 32] {///     let mut r = [0; 32];///     for i in 0..16 {///         // if the most significant bit of b is set,///         // then the destination byte is set to 0.///         if b[i] & 0x80 == 0u8 {///             r[i] = a[(b[i] % 16) as usize];///         if b[i + 16] & 0x80 == 0u8 {///             r[i + 16] = a[(b[i + 16] % 16 + 16) as usize];///     r/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_epi8)_mm256_shuffle_epi32/// Shuffles 32-bit integers in 128-bit lanes of `a` using the control in/// `imm8`./// #[cfg(target_arch = "x86")]/// use std::arch::x86::*;/// #[cfg(target_arch = "x86_64")]/// use std::arch::x86_64::*;/// #     if is_x86_feature_detected!("avx2") {/// #         #[target_feature(enable = "avx2")]/// #         unsafe fn worker() {/// let a = _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);/// let c1 = _mm256_shuffle_epi32(a, 0b00_11_10_01);/// let c2 = _mm256_shuffle_epi32(a, 0b01_00_10_11);/// let expected1 = _mm256_setr_epi32(1, 2, 3, 0, 5, 6, 7, 4);/// let expected2 = _mm256_setr_epi32(3, 2, 0, 1, 7, 6, 4, 5);/// assert_eq!(_mm256_movemask_epi8(_mm256_cmpeq_epi8(c1, expected1)), !0);/// assert_eq!(_mm256_movemask_epi8(_mm256_cmpeq_epi8(c2, expected2)), !0);/// #         unsafe { worker(); }/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_epi32)_mm256_shufflehi_epi16/// Shuffles 16-bit integers in the high 64 bits of 128-bit lanes of `a` using/// the control in `imm8`. The low 64 bits of 128-bit lanes of `a` are copied/// to the output./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shufflehi_epi16)_mm256_shufflelo_epi16/// Shuffles 16-bit integers in the low 64 bits of 128-bit lanes of `a` using/// the control in `imm8`. The high 64 bits of 128-bit lanes of `a` are copied/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shufflelo_epi16)_mm256_sign_epi16/// Negates packed 16-bit integers in `a` when the corresponding signed/// 16-bit integer in `b` is negative, and returns the results./// Results are zeroed out when the corresponding element in `b` is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sign_epi16)_mm256_sign_epi32/// Negates packed 32-bit integers in `a` when the corresponding signed/// 32-bit integer in `b` is negative, and returns the results./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sign_epi32)_mm256_sign_epi8/// Negates packed 8-bit integers in `a` when the corresponding signed/// 8-bit integer in `b` is negative, and returns the results./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sign_epi8)_mm256_sll_epi16/// Shifts packed 16-bit integers in `a` left by `count` while/// shifting in zeros, and returns the result/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sll_epi16)_mm256_sll_epi32/// Shifts packed 32-bit integers in `a` left by `count` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sll_epi32)_mm256_sll_epi64/// Shifts packed 64-bit integers in `a` left by `count` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sll_epi64)_mm256_slli_epi16/// Shifts packed 16-bit integers in `a` left by `IMM8` while/// shifting in zeros, return the results;/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_slli_epi16)_mm256_slli_epi32/// Shifts packed 32-bit integers in `a` left by `IMM8` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_slli_epi32)_mm256_slli_epi64/// Shifts packed 64-bit integers in `a` left by `IMM8` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_slli_epi64)_mm256_slli_si256/// Shifts 128-bit lanes in `a` left by `imm8` bytes while shifting in zeros./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_slli_si256)_mm256_bslli_epi128/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_bslli_epi128)_mm_sllv_epi32/// Shifts packed 32-bit integers in `a` left by the amount/// specified by the corresponding element in `count` while/// shifting in zeros, and returns the result./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sllv_epi32)_mm256_sllv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sllv_epi32)_mm_sllv_epi64/// Shifts packed 64-bit integers in `a` left by the amount/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sllv_epi64)_mm256_sllv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sllv_epi64)_mm256_sra_epi16/// Shifts packed 16-bit integers in `a` right by `count` while/// shifting in sign bits./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sra_epi16)_mm256_sra_epi32/// Shifts packed 32-bit integers in `a` right by `count` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sra_epi32)_mm256_srai_epi16/// Shifts packed 16-bit integers in `a` right by `IMM8` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srai_epi16)_mm256_srai_epi32/// Shifts packed 32-bit integers in `a` right by `IMM8` while/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srai_epi32)_mm_srav_epi32/// Shifts packed 32-bit integers in `a` right by the amount specified by the/// corresponding element in `count` while shifting in sign bits./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srav_epi32)_mm256_srav_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srav_epi32)_mm256_srli_si256/// Shifts 128-bit lanes in `a` right by `imm8` bytes while shifting in zeros./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srli_si256)_mm256_bsrli_epi128/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_bsrli_epi128)_mm256_srl_epi16/// Shifts packed 16-bit integers in `a` right by `count` while shifting in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srl_epi16)_mm256_srl_epi32/// Shifts packed 32-bit integers in `a` right by `count` while shifting in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srl_epi32)_mm256_srl_epi64/// Shifts packed 64-bit integers in `a` right by `count` while shifting in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srl_epi64)_mm256_srli_epi16/// Shifts packed 16-bit integers in `a` right by `IMM8` while shifting in/// zeros/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srli_epi16)_mm256_srli_epi32/// Shifts packed 32-bit integers in `a` right by `IMM8` while shifting in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srli_epi32)_mm256_srli_epi64/// Shifts packed 64-bit integers in `a` right by `IMM8` while shifting in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srli_epi64)_mm_srlv_epi32/// Shifts packed 32-bit integers in `a` right by the amount specified by/// the corresponding element in `count` while shifting in zeros,/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srlv_epi32)_mm256_srlv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srlv_epi32)_mm_srlv_epi64/// Shifts packed 64-bit integers in `a` right by the amount specified by/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srlv_epi64)_mm256_srlv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srlv_epi64)_mm256_stream_load_si256/// Load 256-bits of integer data from memory into dst using a non-temporal memory hint. mem_addr/// must be aligned on a 32-byte boundary or a general-protection exception may be generated. To/// minimize caching, the data is flagged as non-temporal (unlikely to be used again soon)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_stream_load_si256)_mm256_sub_epi16/// Subtract packed 16-bit integers in `b` from packed 16-bit integers in `a`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sub_epi16)_mm256_sub_epi32/// Subtract packed 32-bit integers in `b` from packed 32-bit integers in `a`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sub_epi32)_mm256_sub_epi64/// Subtract packed 64-bit integers in `b` from packed 64-bit integers in `a`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sub_epi64)_mm256_sub_epi8/// Subtract packed 8-bit integers in `b` from packed 8-bit integers in `a`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sub_epi8)_mm256_subs_epi16/// Subtract packed 16-bit integers in `b` from packed 16-bit integers in/// `a` using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_subs_epi16)_mm256_subs_epi8/// Subtract packed 8-bit integers in `b` from packed 8-bit integers in/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_subs_epi8)_mm256_subs_epu16/// Subtract packed unsigned 16-bit integers in `b` from packed 16-bit/// integers in `a` using saturation./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_subs_epu16)_mm256_subs_epu8/// Subtract packed unsigned 8-bit integers in `b` from packed 8-bit/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_subs_epu8)_mm256_unpackhi_epi8/// Unpacks and interleave 8-bit integers from the high half of each/// 128-bit lane in `a` and `b`./// let a = _mm256_setr_epi8(///     0, 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,/// let b = _mm256_setr_epi8(///     0, -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,/// let c = _mm256_unpackhi_epi8(a, b);/// let expected = _mm256_setr_epi8(///     8, -8, 9, -9, 10, -10, 11, -11, 12, -12, 13, -13, 14, -14, 15, -15,///     24, -24, 25, -25, 26, -26, 27, -27, 28, -28, 29, -29, 30, -30, 31,///     -31,/// assert_eq!(_mm256_movemask_epi8(_mm256_cmpeq_epi8(c, expected)), !0);/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpackhi_epi8)_mm256_unpacklo_epi8/// Unpacks and interleave 8-bit integers from the low half of each/// 128-bit lane of `a` and `b`./// let c = _mm256_unpacklo_epi8(a, b);///     0, 0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7, 16, -16, 17,///     -17, 18, -18, 19, -19, 20, -20, 21, -21, 22, -22, 23, -23,/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpacklo_epi8)_mm256_unpackhi_epi16/// Unpacks and interleave 16-bit integers from the high half of each/// let a = _mm256_setr_epi16(///     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,/// let b = _mm256_setr_epi16(/// let c = _mm256_unpackhi_epi16(a, b);/// let expected = _mm256_setr_epi16(///     4, -4, 5, -5, 6, -6, 7, -7, 12, -12, 13, -13, 14, -14, 15, -15,/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpackhi_epi16)_mm256_unpacklo_epi16/// Unpacks and interleave 16-bit integers from the low half of each/// let c = _mm256_unpacklo_epi16(a, b);///     0, 0, 1, -1, 2, -2, 3, -3, 8, -8, 9, -9, 10, -10, 11, -11,/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpacklo_epi16)_mm256_unpackhi_epi32/// Unpacks and interleave 32-bit integers from the high half of each/// let b = _mm256_setr_epi32(0, -1, -2, -3, -4, -5, -6, -7);/// let c = _mm256_unpackhi_epi32(a, b);/// let expected = _mm256_setr_epi32(2, -2, 3, -3, 6, -6, 7, -7);/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpackhi_epi32)_mm256_unpacklo_epi32/// Unpacks and interleave 32-bit integers from the low half of each/// let c = _mm256_unpacklo_epi32(a, b);/// let expected = _mm256_setr_epi32(0, 0, 1, -1, 4, -4, 5, -5);/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpacklo_epi32)_mm256_unpackhi_epi64/// Unpacks and interleave 64-bit integers from the high half of each/// let a = _mm256_setr_epi64x(0, 1, 2, 3);/// let b = _mm256_setr_epi64x(0, -1, -2, -3);/// let c = _mm256_unpackhi_epi64(a, b);/// let expected = _mm256_setr_epi64x(1, -1, 3, -3);/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpackhi_epi64)_mm256_unpacklo_epi64/// Unpacks and interleave 64-bit integers from the low half of each/// let c = _mm256_unpacklo_epi64(a, b);/// let expected = _mm256_setr_epi64x(0, 0, 2, -2);/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_unpacklo_epi64)_mm256_xor_si256/// Computes the bitwise XOR of 256 bits (representing integer data)/// in `a` and `b`/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_xor_si256)_mm256_extract_epi8/// Extracts an 8-bit integer from `a`, selected with `INDEX`. Returns a 32-bit/// integer containing the zero-extended integer data./// See [LLVM commit D20468](https://reviews.llvm.org/D20468)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extract_epi8)_mm256_extract_epi16/// Extracts a 16-bit integer from `a`, selected with `INDEX`. Returns a 32-bit/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extract_epi16)"llvm.x86.avx2.phadd.sw"phaddsw"llvm.x86.avx2.phsub.sw"phsubsw"llvm.x86.avx2.pmadd.wd"pmaddwd"llvm.x86.avx2.pmadd.ub.sw"pmaddubsw"llvm.x86.avx2.mpsadbw"mpsadbw"llvm.x86.avx2.pmul.hr.sw"pmulhrsw"llvm.x86.avx2.packsswb"packsswb"llvm.x86.avx2.packssdw"packssdw"llvm.x86.avx2.packuswb"packuswb"llvm.x86.avx2.packusdw"packusdw"llvm.x86.avx2.psad.bw"psadbw"llvm.x86.avx2.psign.b"psignb"llvm.x86.avx2.psign.w"psignw"llvm.x86.avx2.psign.d"psignd"llvm.x86.avx2.psll.w"psllw"llvm.x86.avx2.psll.d"pslld"llvm.x86.avx2.psll.q"psllq"llvm.x86.avx2.psra.w"psraw"llvm.x86.avx2.psra.d"psrad"llvm.x86.avx2.psrl.w"psrlw"llvm.x86.avx2.psrl.d"psrld"llvm.x86.avx2.psrl.q"psrlq"llvm.x86.avx2.pshuf.b"pshufb"llvm.x86.avx2.permd"permd"llvm.x86.avx2.permps"permps"llvm.x86.avx2.gather.d.d"pgatherdd"llvm.x86.avx2.gather.d.d.256"vpgatherdd"llvm.x86.avx2.gather.d.q"pgatherdq"llvm.x86.avx2.gather.d.q.256"vpgatherdq"llvm.x86.avx2.gather.q.d"pgatherqd"llvm.x86.avx2.gather.q.d.256"vpgatherqd"llvm.x86.avx2.gather.q.q"pgatherqq"llvm.x86.avx2.gather.q.q.256"vpgatherqq"llvm.x86.avx2.gather.d.pd"pgatherdpd"llvm.x86.avx2.gather.d.pd.256"vpgatherdpd"llvm.x86.avx2.gather.q.pd"pgatherqpd"llvm.x86.avx2.gather.q.pd.256"vpgatherqpd"llvm.x86.avx2.gather.d.ps"pgatherdps"llvm.x86.avx2.gather.d.ps.256"vpgatherdps"llvm.x86.avx2.gather.q.ps"pgatherqps"llvm.x86.avx2.gather.q.ps.256"vpgatherqps//! Advanced Vector Extensions 2 (AVX)//! AVX2 expands most AVX commands to 256-bit wide vector registers and//! adds [FMA](https://en.wikipedia.org/wiki/Fused_multiply-accumulate).//! Wikipedia's [AVX][wiki_avx] and [FMA][wiki_fma] pages provide a quick//! overview of the instructions available.//! [wiki_avx]: https://en.wikipedia.org/wiki/Advanced_Vector_Extensions//! [wiki_fma]: https://en.wikipedia.org/wiki/Fused_multiply-accumulate"llvm.x86.avx512bf16.cvtne2ps2bf16.128"cvtne2ps2bf16"llvm.x86.avx512bf16.cvtne2ps2bf16.256"cvtne2ps2bf16_256"llvm.x86.avx512bf16.cvtne2ps2bf16.512"cvtne2ps2bf16_512"llvm.x86.avx512bf16.cvtneps2bf16.256"cvtneps2bf16_256"llvm.x86.avx512bf16.cvtneps2bf16.512"cvtneps2bf16_512"llvm.x86.avx512bf16.dpbf16ps.128"dpbf16ps"llvm.x86.avx512bf16.dpbf16ps.256"dpbf16ps_256"llvm.x86.avx512bf16.dpbf16ps.512"dpbf16ps_512_mm_cvtne2ps_pbh__m128bh/// Convert packed single-precision (32-bit) floating-point elements in two 128-bit vectors/// a and b to packed BF16 (16-bit) floating-point elements, and store the results in a/// 128-bit wide vector./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651&avx512techs=AVX512_BF16&text=_mm_cvtne2ps_pbh)_mm_mask_cvtne2ps_pbh__mmask8/// Convert packed single-precision (32-bit) floating-point elements in two vectors/// a and b to packed BF16 (16-bit) floating-point elements, and store the results/// in single vector dst using writemask k (elements are copied from src when the/// corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651&avx512techs=AVX512_BF16&text=_mm_mask_cvtne2ps_pbh)_mm_maskz_cvtne2ps_pbh/// in single vector dst using zeromask k (elements are zeroed out when the corresponding/// mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651&avx512techs=AVX512_BF16&text=_mm_maskz_cvtne2ps_pbh)_mm256_cvtne2ps_pbh__m256bh/// Convert packed single-precision (32-bit) floating-point elements in two 256-bit vectors/// 256-bit wide vector./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654&avx512techs=AVX512_BF16&text=_mm256_cvtne2ps_pbh)_mm256_mask_cvtne2ps_pbh__mmask16/// Convert packed single-precision (32-bit) floating-point elements in two vectors a and b/// to packed BF16 (16-bit) floating-point elements and store the results in single vector/// dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654&avx512techs=AVX512_BF16&text=_mm256_mask_cvtne2ps_pbh)_mm256_maskz_cvtne2ps_pbh/// to packed BF16 (16-bit) floating-point elements, and store the results in single vector/// dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654&avx512techs=AVX512_BF16&text=_mm256_maskz_cvtne2ps_pbh)_mm512_cvtne2ps_pbh__m512bh/// Convert packed single-precision (32-bit) floating-point elements in two 512-bit vectors/// 512-bit wide vector./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657&avx512techs=AVX512_BF16&text=_mm512_cvtne2ps_pbh)_mm512_mask_cvtne2ps_pbh__mmask32/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657&avx512techs=AVX512_BF16&text=_mm512_mask_cvtne2ps_pbh)_mm512_maskz_cvtne2ps_pbh/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657&avx512techs=AVX512_BF16&text=_mm512_maskz_cvtne2ps_pbh)_mm256_cvtneps_pbh/// Convert packed single-precision (32-bit) floating-point elements in a to packed BF16 (16-bit)/// floating-point elements, and store the results in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm256_cvtneps_pbh)_mm256_mask_cvtneps_pbh/// floating-point elements, and store the results in dst using writemask k/// (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm256_mask_cvtneps_pbh)_mm256_maskz_cvtneps_pbh/// floating-point elements, and store the results in dst using zeromask k/// (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm256_maskz_cvtneps_pbh)_mm512_cvtneps_pbh/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm512_cvtneps_pbh)_mm512_mask_cvtneps_pbh/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm512_mask_cvtneps_pbh)_mm512_maskz_cvtneps_pbh/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm512_maskz_cvtneps_pbh)_mm_dpbf16_ps/// Compute dot-product of BF16 (16-bit) floating-point pairs in a and b,/// accumulating the intermediate single-precision (32-bit) floating-point elements/// with elements in src, and store the results in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm_dpbf16_ps)_mm_mask_dpbf16_ps/// with elements in src, and store the results in dst using writemask k/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm_mask_dpbf16_ps)_mm_maskz_dpbf16_ps/// with elements in src, and store the results in dst using zeromask k/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm_maskz_dpbf16_ps)_mm256_dpbf16_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm256_dpbf16_ps)_mm256_mask_dpbf16_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm256_mask_dpbf16_ps)_mm256_maskz_dpbf16_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm256_maskz_dpbf16_ps)_mm512_dpbf16_ps/// with elements in src, and store the results in dst.Compute dot-product of BF16 (16-bit)/// floating-point pairs in a and b, accumulating the intermediate single-precision (32-bit)/// floating-point elements with elements in src, and store the results in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm512_dpbf16_ps)_mm512_mask_dpbf16_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm512_mask_dpbf16_ps)_mm512_maskz_dpbf16_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769,1651,1654,1657,1660&avx512techs=AVX512_BF16&text=_mm512_maskz_dpbf16_ps)_mm512_cvtpbh_ps/// Converts packed BF16 (16-bit) floating-point elements in a to packed single-precision (32-bit)/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_cvtpbh_ps)_mm512_mask_cvtpbh_ps/// floating-point elements, and store the results in dst using writemask k (elements are copied/// from src when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_cvtpbh_ps)_mm512_maskz_cvtpbh_ps/// floating-point elements, and store the results in dst using zeromask k (elements are zeroed out/// when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_maskz_cvtpbh_ps)_mm256_cvtpbh_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_cvtpbh_ps)_mm256_mask_cvtpbh_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_cvtpbh_ps)_mm256_maskz_cvtpbh_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_maskz_cvtpbh_ps)_mm_cvtpbh_ps/// Converts packed BF16 (16-bit) floating-point elements in a to single-precision (32-bit) floating-point/// elements, and store the results in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpbh_ps)_mm_mask_cvtpbh_ps/// elements, and store the results in dst using writemask k (elements are copied from src when the corresponding/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_cvtpbh_ps)_mm_maskz_cvtpbh_ps/// elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_maskz_cvtpbh_ps)_mm_cvtsbh_ss/// Converts a single BF16 (16-bit) floating-point element in a to a single-precision (32-bit) floating-point/// element, and store the result in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsbh_ss)_mm_cvtneps_pbh/// Converts packed single-precision (32-bit) floating-point elements in a to packed BF16 (16-bit)/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtneps_pbh)_mm_mask_cvtneps_pbh/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_cvtneps_pbh)_mm_maskz_cvtneps_pbh/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_maskz_cvtneps_pbh)_mm_cvtness_sbh/// Converts a single-precision (32-bit) floating-point element in a to a BF16 (16-bit) floating-point/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtness_sbh)//! [AVX512BF16 intrinsics].//! [AVX512BF16 intrinsics]: https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=1769&avx512techs=AVX512_BF16__mmask64"llvm.x86.avx512.mask.vpshufbitqmb.512"bitshuffle_512"llvm.x86.avx512.mask.vpshufbitqmb.256"bitshuffle_256"llvm.x86.avx512.mask.vpshufbitqmb.128"bitshuffle_128_mm512_popcnt_epi16/// For each packed 16-bit integer maps the value to the number of logical 1 bits./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_popcnt_epi16)_mm512_maskz_popcnt_epi16/// Uses the writemask in k - elements are zeroed in the result if the corresponding mask bit is not set./// Otherwise the computation result is written into the result./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_popcnt_epi16)_mm512_mask_popcnt_epi16/// Uses the writemask in k - elements are copied from src if the corresponding mask bit is not set./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_popcnt_epi16)_mm256_popcnt_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_popcnt_epi16)_mm256_maskz_popcnt_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_popcnt_epi16)_mm256_mask_popcnt_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_popcnt_epi16)_mm_popcnt_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_popcnt_epi16)_mm_maskz_popcnt_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_popcnt_epi16)_mm_mask_popcnt_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_popcnt_epi16)_mm512_popcnt_epi8/// For each packed 8-bit integer maps the value to the number of logical 1 bits./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_popcnt_epi8)_mm512_maskz_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_popcnt_epi8)_mm512_mask_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_popcnt_epi8)_mm256_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_popcnt_epi8)_mm256_maskz_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_popcnt_epi8)_mm256_mask_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_popcnt_epi8)_mm_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_popcnt_epi8)_mm_maskz_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_popcnt_epi8)_mm_mask_popcnt_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_popcnt_epi8)_mm512_bitshuffle_epi64_mask/// Considers the input `b` as packed 64-bit integers and `c` as packed 8-bit integers./// Then groups 8 8-bit values from `c`as indices into the bits of the corresponding 64-bit integer./// It then selects these bits and packs them into the output./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_bitshuffle_epi64_mask)_mm512_mask_bitshuffle_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_bitshuffle_epi64_mask)_mm256_bitshuffle_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_bitshuffle_epi64_mask)_mm256_mask_bitshuffle_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_bitshuffle_epi64_mask)_mm_bitshuffle_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_bitshuffle_epi64_mask)_mm_mask_bitshuffle_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_bitshuffle_epi64_mask)//! Bit-oriented Algorithms (BITALG)//! The intrinsics here correspond to those in the `immintrin.h` C header._mm512_abs_epi16/// Compute the absolute value of packed signed 16-bit integers in a, and store the unsigned results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_abs_epi16&expand=30)_mm512_mask_abs_epi16/// Compute the absolute value of packed signed 16-bit integers in a, and store the unsigned results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_abs_epi16&expand=31)_mm512_maskz_abs_epi16/// Compute the absolute value of packed signed 16-bit integers in a, and store the unsigned results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_abs_epi16&expand=32)_mm256_mask_abs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_abs_epi16&expand=28)_mm256_maskz_abs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_abs_epi16&expand=29)_mm_mask_abs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_abs_epi16&expand=25)_mm_maskz_abs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_abs_epi16&expand=26)_mm512_abs_epi8/// Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_abs_epi8&expand=57)_mm512_mask_abs_epi8/// Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_abs_epi8&expand=58)_mm512_maskz_abs_epi8/// Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_abs_epi8&expand=59)_mm256_mask_abs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_abs_epi8&expand=55)_mm256_maskz_abs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_abs_epi8&expand=56)_mm_mask_abs_epi8/// Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_abs_epi8&expand=52)_mm_maskz_abs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_abs_epi8&expand=53)_mm512_add_epi16/// Add packed 16-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_epi16&expand=91)_mm512_mask_add_epi16/// Add packed 16-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_epi16&expand=92)_mm512_maskz_add_epi16/// Add packed 16-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_epi16&expand=93)_mm256_mask_add_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_add_epi16&expand=89)_mm256_maskz_add_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_add_epi16&expand=90)_mm_mask_add_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_add_epi16&expand=86)_mm_maskz_add_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_add_epi16&expand=87)_mm512_add_epi8/// Add packed 8-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_epi8&expand=118)_mm512_mask_add_epi8/// Add packed 8-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_epi8&expand=119)_mm512_maskz_add_epi8/// Add packed 8-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_epi8&expand=120)_mm256_mask_add_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_add_epi8&expand=116)_mm256_maskz_add_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_add_epi8&expand=117)_mm_mask_add_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_add_epi8&expand=113)_mm_maskz_add_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_add_epi8&expand=114)_mm512_adds_epu16/// Add packed unsigned 16-bit integers in a and b using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_adds_epu16&expand=197)_mm512_mask_adds_epu16/// Add packed unsigned 16-bit integers in a and b using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_adds_epu16&expand=198)_mm512_maskz_adds_epu16/// Add packed unsigned 16-bit integers in a and b using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_adds_epu16&expand=199)_mm256_mask_adds_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_adds_epu16&expand=195)_mm256_maskz_adds_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_adds_epu16&expand=196)_mm_mask_adds_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_adds_epu16&expand=192)_mm_maskz_adds_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_adds_epu16&expand=193)_mm512_adds_epu8/// Add packed unsigned 8-bit integers in a and b using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_adds_epu8&expand=206)_mm512_mask_adds_epu8/// Add packed unsigned 8-bit integers in a and b using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_adds_epu8&expand=207)_mm512_maskz_adds_epu8/// Add packed unsigned 8-bit integers in a and b using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_adds_epu8&expand=208)_mm256_mask_adds_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_adds_epu8&expand=204)_mm256_maskz_adds_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_adds_epu8&expand=205)_mm_mask_adds_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_adds_epu8&expand=201)_mm_maskz_adds_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_adds_epu8&expand=202)_mm512_adds_epi16/// Add packed signed 16-bit integers in a and b using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_adds_epi16&expand=179)_mm512_mask_adds_epi16/// Add packed signed 16-bit integers in a and b using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_adds_epi16&expand=180)_mm512_maskz_adds_epi16/// Add packed signed 16-bit integers in a and b using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_adds_epi16&expand=181)_mm256_mask_adds_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_adds_epi16&expand=177)_mm256_maskz_adds_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_adds_epi16&expand=178)_mm_mask_adds_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_adds_epi16&expand=174)_mm_maskz_adds_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_adds_epi16&expand=175)_mm512_adds_epi8/// Add packed signed 8-bit integers in a and b using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_adds_epi8&expand=188)_mm512_mask_adds_epi8/// Add packed signed 8-bit integers in a and b using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_adds_epi8&expand=189)_mm512_maskz_adds_epi8/// Add packed signed 8-bit integers in a and b using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_adds_epi8&expand=190)_mm256_mask_adds_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_adds_epi8&expand=186)_mm256_maskz_adds_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_adds_epi8&expand=187)_mm_mask_adds_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_adds_epi8&expand=183)_mm_maskz_adds_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_adds_epi8&expand=184)_mm512_sub_epi16/// Subtract packed 16-bit integers in b from packed 16-bit integers in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_epi16&expand=5685)_mm512_mask_sub_epi16/// Subtract packed 16-bit integers in b from packed 16-bit integers in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_epi16&expand=5683)_mm512_maskz_sub_epi16/// Subtract packed 16-bit integers in b from packed 16-bit integers in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_epi16&expand=5684)_mm256_mask_sub_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sub_epi16&expand=5680)_mm256_maskz_sub_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sub_epi16&expand=5681)_mm_mask_sub_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sub_epi16&expand=5677)_mm_maskz_sub_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sub_epi16&expand=5678)_mm512_sub_epi8/// Subtract packed 8-bit integers in b from packed 8-bit integers in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_epi8&expand=5712)_mm512_mask_sub_epi8/// Subtract packed 8-bit integers in b from packed 8-bit integers in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_epi8&expand=5710)_mm512_maskz_sub_epi8/// Subtract packed 8-bit integers in b from packed 8-bit integers in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_epi8&expand=5711)_mm256_mask_sub_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sub_epi8&expand=5707)_mm256_maskz_sub_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sub_epi8&expand=5708)_mm_mask_sub_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sub_epi8&expand=5704)_mm_maskz_sub_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sub_epi8&expand=5705)_mm512_subs_epu16/// Subtract packed unsigned 16-bit integers in b from packed unsigned 16-bit integers in a using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_subs_epu16&expand=5793)_mm512_mask_subs_epu16/// Subtract packed unsigned 16-bit integers in b from packed unsigned 16-bit integers in a using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_subs_epu16&expand=5791)_mm512_maskz_subs_epu16/// Subtract packed unsigned 16-bit integers in b from packed unsigned 16-bit integers in a using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_subs_epu16&expand=5792)_mm256_mask_subs_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_subs_epu16&expand=5788)_mm256_maskz_subs_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_subs_epu16&expand=5789)_mm_mask_subs_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_subs_epu16&expand=5785)_mm_maskz_subs_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_subs_epu16&expand=5786)_mm512_subs_epu8/// Subtract packed unsigned 8-bit integers in b from packed unsigned 8-bit integers in a using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_subs_epu8&expand=5802)_mm512_mask_subs_epu8/// Subtract packed unsigned 8-bit integers in b from packed unsigned 8-bit integers in a using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_subs_epu8&expand=5800)_mm512_maskz_subs_epu8/// Subtract packed unsigned 8-bit integers in b from packed unsigned 8-bit integers in a using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_subs_epu8&expand=5801)_mm256_mask_subs_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_subs_epu8&expand=5797)_mm256_maskz_subs_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_subs_epu8&expand=5798)_mm_mask_subs_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_subs_epu8&expand=5794)_mm_maskz_subs_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_subs_epu8&expand=5795)_mm512_subs_epi16/// Subtract packed signed 16-bit integers in b from packed 16-bit integers in a using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_subs_epi16&expand=5775)_mm512_mask_subs_epi16/// Subtract packed signed 16-bit integers in b from packed 16-bit integers in a using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_subs_epi16&expand=5773)_mm512_maskz_subs_epi16/// Subtract packed signed 16-bit integers in b from packed 16-bit integers in a using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_subs_epi16&expand=5774)_mm256_mask_subs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_subs_epi16&expand=5770)_mm256_maskz_subs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_subs_epi16&expand=5771)_mm_mask_subs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_subs_epi16&expand=5767)_mm_maskz_subs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_subs_epi16&expand=5768)_mm512_subs_epi8/// Subtract packed signed 8-bit integers in b from packed 8-bit integers in a using saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_subs_epi8&expand=5784)_mm512_mask_subs_epi8/// Subtract packed signed 8-bit integers in b from packed 8-bit integers in a using saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_subs_epi8&expand=5782)_mm512_maskz_subs_epi8/// Subtract packed signed 8-bit integers in b from packed 8-bit integers in a using saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_subs_epi8&expand=5783)_mm256_mask_subs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_subs_epi8&expand=5779)_mm256_maskz_subs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_subs_epi8&expand=5780)_mm_mask_subs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_subs_epi8&expand=5776)_mm_maskz_subs_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_subs_epi8&expand=5777)_mm512_mulhi_epu16/// Multiply the packed unsigned 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mulhi_epu16&expand=3973)_mm512_mask_mulhi_epu16/// Multiply the packed unsigned 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mulhi_epu16&expand=3971)_mm512_maskz_mulhi_epu16/// Multiply the packed unsigned 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mulhi_epu16&expand=3972)_mm256_mask_mulhi_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mulhi_epu16&expand=3968)_mm256_maskz_mulhi_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mulhi_epu16&expand=3969)_mm_mask_mulhi_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mulhi_epu16&expand=3965)_mm_maskz_mulhi_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mulhi_epu16&expand=3966)_mm512_mulhi_epi16/// Multiply the packed signed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mulhi_epi16&expand=3962)_mm512_mask_mulhi_epi16/// Multiply the packed signed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mulhi_epi16&expand=3960)_mm512_maskz_mulhi_epi16/// Multiply the packed signed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mulhi_epi16&expand=3961)_mm256_mask_mulhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mulhi_epi16&expand=3957)_mm256_maskz_mulhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mulhi_epi16&expand=3958)_mm_mask_mulhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mulhi_epi16&expand=3954)_mm_maskz_mulhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mulhi_epi16&expand=3955)_mm512_mulhrs_epi16/// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Truncate each intermediate integer to the 18 most significant bits, round by adding 1, and store bits \[16:1\] to dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mulhrs_epi16&expand=3986)_mm512_mask_mulhrs_epi16/// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Truncate each intermediate integer to the 18 most significant bits, round by adding 1, and store bits \[16:1\] to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mulhrs_epi16&expand=3984)_mm512_maskz_mulhrs_epi16/// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Truncate each intermediate integer to the 18 most significant bits, round by adding 1, and store bits \[16:1\] to dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mulhrs_epi16&expand=3985)_mm256_mask_mulhrs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mulhrs_epi16&expand=3981)_mm256_maskz_mulhrs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mulhrs_epi16&expand=3982)_mm_mask_mulhrs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mulhrs_epi16&expand=3978)_mm_maskz_mulhrs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mulhrs_epi16&expand=3979)_mm512_mullo_epi16/// Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mullo_epi16&expand=3996)_mm512_mask_mullo_epi16/// Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mullo_epi16&expand=3994)_mm512_maskz_mullo_epi16/// Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mullo_epi16&expand=3995)_mm256_mask_mullo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mullo_epi16&expand=3991)_mm256_maskz_mullo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mullo_epi16&expand=3992)_mm_mask_mullo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mullo_epi16&expand=3988)_mm_maskz_mullo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mullo_epi16&expand=3989)_mm512_max_epu16/// Compare packed unsigned 16-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epu16&expand=3609)_mm512_mask_max_epu16/// Compare packed unsigned 16-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epu16&expand=3607)_mm512_maskz_max_epu16/// Compare packed unsigned 16-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epu16&expand=3608)_mm256_mask_max_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epu16&expand=3604)_mm256_maskz_max_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epu16&expand=3605)_mm_mask_max_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epu16&expand=3601)_mm_maskz_max_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epu16&expand=3602)_mm512_max_epu8/// Compare packed unsigned 8-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epu8&expand=3636)_mm512_mask_max_epu8/// Compare packed unsigned 8-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epu8&expand=3634)_mm512_maskz_max_epu8/// Compare packed unsigned 8-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epu8&expand=3635)_mm256_mask_max_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epu8&expand=3631)_mm256_maskz_max_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epu8&expand=3632)_mm_mask_max_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epu8&expand=3628)_mm_maskz_max_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epu8&expand=3629)_mm512_max_epi16/// Compare packed signed 16-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epi16&expand=3573)_mm512_mask_max_epi16/// Compare packed signed 16-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epi16&expand=3571)_mm512_maskz_max_epi16/// Compare packed signed 16-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epi16&expand=3572)_mm256_mask_max_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epi16&expand=3568)_mm256_maskz_max_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epi16&expand=3569)_mm_mask_max_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epi16&expand=3565)_mm_maskz_max_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epi16&expand=3566)_mm512_max_epi8/// Compare packed signed 8-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epi8&expand=3600)_mm512_mask_max_epi8/// Compare packed signed 8-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epi8&expand=3598)_mm512_maskz_max_epi8/// Compare packed signed 8-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epi8&expand=3599)_mm256_mask_max_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epi8&expand=3595)_mm256_maskz_max_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epi8&expand=3596)_mm_mask_max_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epi8&expand=3592)_mm_maskz_max_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epi8&expand=3593)_mm512_min_epu16/// Compare packed unsigned 16-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epu16&expand=3723)_mm512_mask_min_epu16/// Compare packed unsigned 16-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epu16&expand=3721)_mm512_maskz_min_epu16/// Compare packed unsigned 16-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epu16&expand=3722)_mm256_mask_min_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epu16&expand=3718)_mm256_maskz_min_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epu16&expand=3719)_mm_mask_min_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epu16&expand=3715)_mm_maskz_min_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epu16&expand=3716)_mm512_min_epu8/// Compare packed unsigned 8-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epu8&expand=3750)_mm512_mask_min_epu8/// Compare packed unsigned 8-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epu8&expand=3748)_mm512_maskz_min_epu8/// Compare packed unsigned 8-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epu8&expand=3749)_mm256_mask_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epu8&expand=3745)_mm256_maskz_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epu8&expand=3746)_mm_mask_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epu8&expand=3742)_mm_maskz_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epu8&expand=3743)_mm512_min_epi16/// Compare packed signed 16-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epi16&expand=3687)_mm512_mask_min_epi16/// Compare packed signed 16-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epi16&expand=3685)_mm512_maskz_min_epi16/// Compare packed signed 16-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epi16&expand=3686)_mm256_mask_min_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epi16&expand=3682)_mm256_maskz_min_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epi16&expand=3683)_mm_mask_min_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epi16&expand=3679)_mm_maskz_min_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epi16&expand=3680)_mm512_min_epi8/// Compare packed signed 8-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epi8&expand=3714)_mm512_mask_min_epi8/// Compare packed signed 8-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epi8&expand=3712)_mm512_maskz_min_epi8/// Compare packed signed 8-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epi8&expand=3713)_mm256_mask_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epi8&expand=3709)_mm256_maskz_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epi8&expand=3710)_mm_mask_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epi8&expand=3706)_mm_maskz_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epi8&expand=3707)_mm512_cmplt_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_epu16_mask&expand=1050)_mm512_mask_cmplt_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epu16_mask&expand=1051)_mm256_cmplt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epu16_mask&expand=1050)_mm256_mask_cmplt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epu16_mask&expand=1049)_mm_cmplt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epu16_mask&expand=1018)_mm_mask_cmplt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epu16_mask&expand=1019)_mm512_cmplt_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm512_cmplt_epu8_mask&expand=1068)_mm512_mask_cmplt_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epu8_mask&expand=1069)_mm256_cmplt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epu8_mask&expand=1066)_mm256_mask_cmplt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epu8_mask&expand=1067)_mm_cmplt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epu8_mask&expand=1064)_mm_mask_cmplt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epu8_mask&expand=1065)_mm512_cmplt_epi16_mask/// Compare packed signed 16-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_epi16_mask&expand=1022)_mm512_mask_cmplt_epi16_mask/// Compare packed signed 16-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epi16_mask&expand=1023)_mm256_cmplt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epi16_mask&expand=1020)_mm256_mask_cmplt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epi16_mask&expand=1021)_mm_cmplt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epi16_mask&expand=1018)_mm_mask_cmplt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epi16_mask&expand=1019)_mm512_cmplt_epi8_mask/// Compare packed signed 8-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_epi8_mask&expand=1044)_mm512_mask_cmplt_epi8_mask/// Compare packed signed 8-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epi8_mask&expand=1045)_mm256_cmplt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epi8_mask&expand=1042)_mm256_mask_cmplt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epi8_mask&expand=1043)_mm_cmplt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epi8_mask&expand=1040)_mm_mask_cmplt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epi8_mask&expand=1041)_mm512_cmpgt_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epu16_mask&expand=927)_mm512_mask_cmpgt_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epu16_mask&expand=928)_mm256_cmpgt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epu16_mask&expand=925)_mm256_mask_cmpgt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epu16_mask&expand=926)_mm_cmpgt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epu16_mask&expand=923)_mm_mask_cmpgt_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epu16_mask&expand=924)_mm512_cmpgt_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epu8_mask&expand=945)_mm512_mask_cmpgt_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epu8_mask&expand=946)_mm256_cmpgt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epu8_mask&expand=943)_mm256_mask_cmpgt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epu8_mask&expand=944)_mm_cmpgt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epu8_mask&expand=941)_mm_mask_cmpgt_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epu8_mask&expand=942)_mm512_cmpgt_epi16_mask/// Compare packed signed 16-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epi16_mask&expand=897)_mm512_mask_cmpgt_epi16_mask/// Compare packed signed 16-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epi16_mask&expand=898)_mm256_cmpgt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi16_mask&expand=895)_mm256_mask_cmpgt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epi16_mask&expand=896)_mm_cmpgt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epi16_mask&expand=893)_mm_mask_cmpgt_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epi16_mask&expand=894)_mm512_cmpgt_epi8_mask/// Compare packed signed 8-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epi8_mask&expand=921)_mm512_mask_cmpgt_epi8_mask/// Compare packed signed 8-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epi8_mask&expand=922)_mm256_cmpgt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi8_mask&expand=919)_mm256_mask_cmpgt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epi8_mask&expand=920)_mm_cmpgt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epi8_mask&expand=917)_mm_mask_cmpgt_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epi8_mask&expand=918)_mm512_cmple_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epu16_mask&expand=989)_mm512_mask_cmple_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_epu16_mask&expand=990)_mm256_cmple_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmple_epu16_mask&expand=987)_mm256_mask_cmple_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmple_epu16_mask&expand=988)_mm_cmple_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_epu16_mask&expand=985)_mm_mask_cmple_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmple_epu16_mask&expand=986)_mm512_cmple_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and store the results in mask vector k.   /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epu8_mask&expand=1007)_mm512_mask_cmple_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_epu8_mask&expand=1008)_mm256_cmple_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmple_epu8_mask&expand=1005)_mm256_mask_cmple_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmple_epu8_mask&expand=1006)_mm_cmple_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_epu8_mask&expand=1003)_mm_mask_cmple_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmple_epu8_mask&expand=1004)_mm512_cmple_epi16_mask/// Compare packed signed 16-bit integers in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epi16_mask&expand=965)_mm512_mask_cmple_epi16_mask/// Compare packed signed 16-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_epi16_mask&expand=966)_mm256_cmple_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmple_epi16_mask&expand=963)_mm256_mask_cmple_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmple_epi16_mask&expand=964)_mm_cmple_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_epi16_mask&expand=961)_mm_mask_cmple_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmple_epi16_mask&expand=962)_mm512_cmple_epi8_mask/// Compare packed signed 8-bit integers in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epi8_mask&expand=983)_mm512_mask_cmple_epi8_mask/// Compare packed signed 8-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_epi8_mask&expand=984)_mm256_cmple_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmple_epi8_mask&expand=981)_mm256_mask_cmple_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmple_epi8_mask&expand=982)_mm_cmple_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_epi8_mask&expand=979)_mm_mask_cmple_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmple_epi8_mask&expand=980)_mm512_cmpge_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpge_epu16_mask&expand=867)_mm512_mask_cmpge_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpge_epu16_mask&expand=868)_mm256_cmpge_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpge_epu16_mask&expand=865)_mm256_mask_cmpge_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpge_epu16_mask&expand=866)_mm_cmpge_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_epu16_mask&expand=863)_mm_mask_cmpge_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpge_epu16_mask&expand=864)_mm512_cmpge_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpge_epu8_mask&expand=885)_mm512_mask_cmpge_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpge_epu8_mask&expand=886)_mm256_cmpge_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpge_epu8_mask&expand=883)_mm256_mask_cmpge_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpge_epu8_mask&expand=884)_mm_cmpge_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_epu8_mask&expand=881)_mm_mask_cmpge_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpge_epu8_mask&expand=882)_mm512_cmpge_epi16_mask/// Compare packed signed 16-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpge_epi16_mask&expand=843)_mm512_mask_cmpge_epi16_mask/// Compare packed signed 16-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpge_epi16_mask&expand=844)_mm256_cmpge_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpge_epi16_mask&expand=841)_mm256_mask_cmpge_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpge_epi16_mask&expand=842)_mm_cmpge_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_epi16_mask&expand=839)_mm_mask_cmpge_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpge_epi16_mask&expand=840)_mm512_cmpge_epi8_mask/// Compare packed signed 8-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpge_epi8_mask&expand=861)_mm512_mask_cmpge_epi8_mask/// Compare packed signed 8-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpge_epi8_mask&expand=862)_mm256_cmpge_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpge_epi8_mask&expand=859)_mm256_mask_cmpge_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpge_epi8_mask&expand=860)_mm_cmpge_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_epi8_mask&expand=857)_mm_mask_cmpge_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpge_epi8_mask&expand=858)_mm512_cmpeq_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_epu16_mask&expand=801)_mm512_mask_cmpeq_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_epu16_mask&expand=802)_mm256_cmpeq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epu16_mask&expand=799)_mm256_mask_cmpeq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpeq_epu16_mask&expand=800)_mm_cmpeq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epu16_mask&expand=797)_mm_mask_cmpeq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpeq_epu16_mask&expand=798)_mm512_cmpeq_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_epu8_mask&expand=819)_mm512_mask_cmpeq_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_epu8_mask&expand=820)_mm256_cmpeq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epu8_mask&expand=817)_mm256_mask_cmpeq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpeq_epu8_mask&expand=818)_mm_cmpeq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epu8_mask&expand=815)_mm_mask_cmpeq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpeq_epu8_mask&expand=816)_mm512_cmpeq_epi16_mask/// Compare packed signed 16-bit integers in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_epi16_mask&expand=771)_mm512_mask_cmpeq_epi16_mask/// Compare packed signed 16-bit integers in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_epi16_mask&expand=772)_mm256_cmpeq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi16_mask&expand=769)_mm256_mask_cmpeq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpeq_epi16_mask&expand=770)_mm_cmpeq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epi16_mask&expand=767)_mm_mask_cmpeq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpeq_epi16_mask&expand=768)_mm512_cmpeq_epi8_mask/// Compare packed signed 8-bit integers in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_epi8_mask&expand=795)_mm512_mask_cmpeq_epi8_mask/// Compare packed signed 8-bit integers in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_epi8_mask&expand=796)_mm256_cmpeq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi8_mask&expand=793)_mm256_mask_cmpeq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpeq_epi8_mask&expand=794)_mm_cmpeq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epi8_mask&expand=791)_mm_mask_cmpeq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpeq_epi8_mask&expand=792)_mm512_cmpneq_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_epu16_mask&expand=1106)_mm512_mask_cmpneq_epu16_mask/// Compare packed unsigned 16-bit integers in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_epu16_mask&expand=1107)_mm256_cmpneq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpneq_epu16_mask&expand=1104)_mm256_mask_cmpneq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpneq_epu16_mask&expand=1105)_mm_cmpneq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_epu16_mask&expand=1102)_mm_mask_cmpneq_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpneq_epu16_mask&expand=1103)_mm512_cmpneq_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_epu8_mask&expand=1124)_mm512_mask_cmpneq_epu8_mask/// Compare packed unsigned 8-bit integers in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_epu8_mask&expand=1125)_mm256_cmpneq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpneq_epu8_mask&expand=1122)_mm256_mask_cmpneq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpneq_epu8_mask&expand=1123)_mm_cmpneq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_epu8_mask&expand=1120)_mm_mask_cmpneq_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpneq_epu8_mask&expand=1121)_mm512_cmpneq_epi16_mask/// Compare packed signed 16-bit integers in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_epi16_mask&expand=1082)_mm512_mask_cmpneq_epi16_mask/// Compare packed signed 16-bit integers in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_epi16_mask&expand=1083)_mm256_cmpneq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpneq_epi16_mask&expand=1080)_mm256_mask_cmpneq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpneq_epi16_mask&expand=1081)_mm_cmpneq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_epi16_mask&expand=1078)_mm_mask_cmpneq_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpneq_epi16_mask&expand=1079)_mm512_cmpneq_epi8_mask/// Compare packed signed 8-bit integers in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_epi8_mask&expand=1100)_mm512_mask_cmpneq_epi8_mask/// Compare packed signed 8-bit integers in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_epi8_mask&expand=1101)_mm256_cmpneq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpneq_epi8_mask&expand=1098)_mm256_mask_cmpneq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpneq_epi8_mask&expand=1099)_mm_cmpneq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_epi8_mask&expand=1096)_mm_mask_cmpneq_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpneq_epi8_mask&expand=1097)_mm512_cmp_epu16_mask/// Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by `IMM8`, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_epu16_mask&expand=715)_mm512_mask_cmp_epu16_mask/// Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_epu16_mask&expand=716)_mm256_cmp_epu16_mask/// Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_epu16_mask&expand=713)_mm256_mask_cmp_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_epu16_mask&expand=714)_mm_cmp_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_epu16_mask&expand=711)_mm_mask_cmp_epu16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_epu16_mask&expand=712)_mm512_cmp_epu8_mask/// Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_epu8_mask&expand=733)_mm512_mask_cmp_epu8_mask/// Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_epu8_mask&expand=734)_mm256_cmp_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_epu8_mask&expand=731)_mm256_mask_cmp_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_epu8_mask&expand=732)_mm_cmp_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_epu8_mask&expand=729)_mm_mask_cmp_epu8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_epu8_mask&expand=730)_mm512_cmp_epi16_mask/// Compare packed signed 16-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_epi16_mask&expand=691)_mm512_mask_cmp_epi16_mask/// Compare packed signed 16-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_epi16_mask&expand=692)_mm256_cmp_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_epi16_mask&expand=689)_mm256_mask_cmp_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_epi16_mask&expand=690)_mm_cmp_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_epi16_mask&expand=687)_mm_mask_cmp_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_epi16_mask&expand=688)_mm512_cmp_epi8_mask/// Compare packed signed 8-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_epi8_mask&expand=709)_mm512_mask_cmp_epi8_mask/// Compare packed signed 8-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_epi8_mask&expand=710)_mm256_cmp_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_epi8_mask&expand=707)_mm256_mask_cmp_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_epi8_mask&expand=708)_mm_cmp_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_epi8_mask&expand=705)_mm_mask_cmp_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_epi8_mask&expand=706)_mm256_reduce_add_epi16/// Reduce the packed 16-bit integers in a by addition. Returns the sum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_add_epi16)_mm256_mask_reduce_add_epi16/// Reduce the packed 16-bit integers in a by addition using mask k. Returns the sum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_add_epi16)_mm_reduce_add_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_add_epi16)_mm_mask_reduce_add_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_add_epi16)_mm256_reduce_add_epi8/// Reduce the packed 8-bit integers in a by addition. Returns the sum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_add_epi8)_mm256_mask_reduce_add_epi8/// Reduce the packed 8-bit integers in a by addition using mask k. Returns the sum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_add_epi8)_mm_reduce_add_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_add_epi8)_mm_mask_reduce_add_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_add_epi8)_mm256_reduce_and_epi16/// Reduce the packed 16-bit integers in a by bitwise AND. Returns the bitwise AND of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_and_epi16)_mm256_mask_reduce_and_epi16/// Reduce the packed 16-bit integers in a by bitwise AND using mask k. Returns the bitwise AND of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_and_epi16)_mm_reduce_and_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_and_epi16)_mm_mask_reduce_and_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_and_epi16)_mm256_reduce_and_epi8/// Reduce the packed 8-bit integers in a by bitwise AND. Returns the bitwise AND of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_and_epi8)_mm256_mask_reduce_and_epi8/// Reduce the packed 8-bit integers in a by bitwise AND using mask k. Returns the bitwise AND of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_and_epi8)_mm_reduce_and_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_and_epi8)_mm_mask_reduce_and_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_and_epi8)_mm256_reduce_max_epi16/// Reduce the packed 16-bit integers in a by maximum. Returns the maximum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_max_epi16)_mm256_mask_reduce_max_epi16/// Reduce the packed 16-bit integers in a by maximum using mask k. Returns the maximum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_max_epi16)_mm_reduce_max_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_max_epi16)_mm_mask_reduce_max_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_max_epi16)_mm256_reduce_max_epi8/// Reduce the packed 8-bit integers in a by maximum. Returns the maximum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_max_epi8)_mm256_mask_reduce_max_epi8/// Reduce the packed 8-bit integers in a by maximum using mask k. Returns the maximum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_max_epi8)_mm_reduce_max_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_max_epi8)_mm_mask_reduce_max_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_max_epi8)_mm256_reduce_max_epu16/// Reduce the packed unsigned 16-bit integers in a by maximum. Returns the maximum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_max_epu16)_mm256_mask_reduce_max_epu16/// Reduce the packed unsigned 16-bit integers in a by maximum using mask k. Returns the maximum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_max_epu16)_mm_reduce_max_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_max_epu16)_mm_mask_reduce_max_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_max_epu16)_mm256_reduce_max_epu8/// Reduce the packed unsigned 8-bit integers in a by maximum. Returns the maximum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_max_epu8)_mm256_mask_reduce_max_epu8/// Reduce the packed unsigned 8-bit integers in a by maximum using mask k. Returns the maximum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_max_epu8)_mm_reduce_max_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_max_epu8)_mm_mask_reduce_max_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_max_epu8)_mm256_reduce_min_epi16/// Reduce the packed 16-bit integers in a by minimum. Returns the minimum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_min_epi16)_mm256_mask_reduce_min_epi16/// Reduce the packed 16-bit integers in a by minimum using mask k. Returns the minimum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_min_epi16)_mm_reduce_min_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_min_epi16)_mm_mask_reduce_min_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_min_epi16)_mm256_reduce_min_epi8/// Reduce the packed 8-bit integers in a by minimum. Returns the minimum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_min_epi8)_mm256_mask_reduce_min_epi8/// Reduce the packed 8-bit integers in a by minimum using mask k. Returns the minimum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_min_epi8)_mm_reduce_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_min_epi8)_mm_mask_reduce_min_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_min_epi8)_mm256_reduce_min_epu16/// Reduce the packed unsigned 16-bit integers in a by minimum. Returns the minimum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_min_epu16)_mm256_mask_reduce_min_epu16/// Reduce the packed unsigned 16-bit integers in a by minimum using mask k. Returns the minimum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_min_epu16)_mm_reduce_min_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_min_epu16)_mm_mask_reduce_min_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_min_epu16)_mm256_reduce_min_epu8/// Reduce the packed unsigned 8-bit integers in a by minimum. Returns the minimum of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_min_epu8)_mm256_mask_reduce_min_epu8/// Reduce the packed unsigned 8-bit integers in a by minimum using mask k. Returns the minimum of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_min_epu8)_mm_reduce_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_min_epu8)_mm_mask_reduce_min_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_min_epu8)_mm256_reduce_mul_epi16/// Reduce the packed 16-bit integers in a by multiplication. Returns the product of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_mul_epi16)_mm256_mask_reduce_mul_epi16/// Reduce the packed 16-bit integers in a by multiplication using mask k. Returns the product of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_mul_epi16)_mm_reduce_mul_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_mul_epi16)_mm_mask_reduce_mul_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_mul_epi16)_mm256_reduce_mul_epi8/// Reduce the packed 8-bit integers in a by multiplication. Returns the product of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_mul_epi8)_mm256_mask_reduce_mul_epi8/// Reduce the packed 8-bit integers in a by multiplication using mask k. Returns the product of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_mul_epi8)_mm_reduce_mul_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_mul_epi8)_mm_mask_reduce_mul_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_mul_epi8)_mm256_reduce_or_epi16/// Reduce the packed 16-bit integers in a by bitwise OR. Returns the bitwise OR of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_or_epi16)_mm256_mask_reduce_or_epi16/// Reduce the packed 16-bit integers in a by bitwise OR using mask k. Returns the bitwise OR of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_or_epi16)_mm_reduce_or_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_or_epi16)_mm_mask_reduce_or_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_or_epi16)_mm256_reduce_or_epi8/// Reduce the packed 8-bit integers in a by bitwise OR. Returns the bitwise OR of all elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_or_epi8)_mm256_mask_reduce_or_epi8/// Reduce the packed 8-bit integers in a by bitwise OR using mask k. Returns the bitwise OR of all active elements in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_or_epi8)_mm_reduce_or_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_or_epi8)_mm_mask_reduce_or_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_or_epi8)_mm512_loadu_epi16/// Load 512-bits (composed of 32 packed 16-bit integers) from memory into dst. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_loadu_epi16&expand=3368)//should be vmovdqu16_mm256_loadu_epi16/// Load 256-bits (composed of 16 packed 16-bit integers) from memory into dst. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu_epi16&expand=3365)_mm_loadu_epi16/// Load 128-bits (composed of 8 packed 16-bit integers) from memory into dst. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_epi16&expand=3362)_mm512_loadu_epi8/// Load 512-bits (composed of 64 packed 8-bit integers) from memory into dst. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_loadu_epi8&expand=3395)//should be vmovdqu8_mm256_loadu_epi8/// Load 256-bits (composed of 32 packed 8-bit integers) from memory into dst. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_loadu_epi8&expand=3392)_mm_loadu_epi8/// Load 128-bits (composed of 16 packed 8-bit integers) from memory into dst. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_epi8&expand=3389)_mm512_storeu_epi16/// Store 512-bits (composed of 32 packed 16-bit integers) from a into memory. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_storeu_epi16&expand=5622)_mm256_storeu_epi16/// Store 256-bits (composed of 16 packed 16-bit integers) from a into memory. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu_epi16&expand=5620)_mm_storeu_epi16/// Store 128-bits (composed of 8 packed 16-bit integers) from a into memory. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_epi16&expand=5618)_mm512_storeu_epi8/// Store 512-bits (composed of 64 packed 8-bit integers) from a into memory. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_storeu_epi8&expand=5640)_mm256_storeu_epi8/// Store 256-bits (composed of 32 packed 8-bit integers) from a into memory. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_storeu_epi8&expand=5638)_mm_storeu_epi8/// Store 128-bits (composed of 16 packed 8-bit integers) from a into memory. mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_epi8&expand=5636)_mm512_mask_loadu_epi16/// Load packed 16-bit integers from memory into dst using writemask k/// mem_addr does not need to be aligned on any particular boundary./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_loadu_epi16)_mm512_maskz_loadu_epi16/// Load packed 16-bit integers from memory into dst using zeromask k/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_loadu_epi16)_mm512_mask_loadu_epi8/// Load packed 8-bit integers from memory into dst using writemask k/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_loadu_epi8)_mm512_maskz_loadu_epi8/// Load packed 8-bit integers from memory into dst using zeromask k/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_loadu_epi8)_mm256_mask_loadu_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_loadu_epi16)_mm256_maskz_loadu_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_loadu_epi16)_mm256_mask_loadu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_loadu_epi8)_mm256_maskz_loadu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_loadu_epi8)_mm_mask_loadu_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_loadu_epi16)_mm_maskz_loadu_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_loadu_epi16)_mm_mask_loadu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_loadu_epi8)_mm_maskz_loadu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_loadu_epi8)_mm512_mask_storeu_epi16/// Store packed 16-bit integers from a into memory using writemask k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_storeu_epi16)_mm512_mask_storeu_epi8/// Store packed 8-bit integers from a into memory using writemask k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_storeu_epi8)_mm256_mask_storeu_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_storeu_epi16)_mm256_mask_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_storeu_epi8)_mm_mask_storeu_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_storeu_epi16)_mm_mask_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_storeu_epi8)_mm512_madd_epi16/// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_madd_epi16&expand=3511)_mm512_mask_madd_epi16/// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_madd_epi16&expand=3512)_mm512_maskz_madd_epi16/// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_madd_epi16&expand=3513)_mm256_mask_madd_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_madd_epi16&expand=3509)_mm256_maskz_madd_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_madd_epi16&expand=3510)_mm_mask_madd_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_madd_epi16&expand=3506)_mm_maskz_madd_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_madd_epi16&expand=3507)_mm512_maddubs_epi16/// Vertically multiply each unsigned 8-bit integer from a with the corresponding signed 8-bit integer from b, producing intermediate signed 16-bit integers. Horizontally add adjacent pairs of intermediate signed 16-bit integers, and pack the saturated results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maddubs_epi16&expand=3539)_mm512_mask_maddubs_epi16/// Multiply packed unsigned 8-bit integers in a by packed signed 8-bit integers in b, producing intermediate signed 16-bit integers. Horizontally add adjacent pairs of intermediate signed 16-bit integers, and pack the saturated results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_maddubs_epi16&expand=3540)_mm512_maskz_maddubs_epi16/// Multiply packed unsigned 8-bit integers in a by packed signed 8-bit integers in b, producing intermediate signed 16-bit integers. Horizontally add adjacent pairs of intermediate signed 16-bit integers, and pack the saturated results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_maddubs_epi16&expand=3541)_mm256_mask_maddubs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_maddubs_epi16&expand=3537)_mm256_maskz_maddubs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_maddubs_epi16&expand=3538)_mm_mask_maddubs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_maddubs_epi16&expand=3534)_mm_maskz_maddubs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_maddubs_epi16&expand=3535)_mm512_packs_epi32/// Convert packed signed 32-bit integers from a and b to packed 16-bit integers using signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_packs_epi32&expand=4091)_mm512_mask_packs_epi32/// Convert packed signed 32-bit integers from a and b to packed 16-bit integers using signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_packs_epi32&expand=4089)_mm512_maskz_packs_epi32/// Convert packed signed 32-bit integers from a and b to packed 16-bit integers using signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_packs_epi32&expand=4090)_mm256_mask_packs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_packs_epi32&expand=4086)_mm256_maskz_packs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_packs_epi32&expand=4087)_mm_mask_packs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_packs_epi32&expand=4083)_mm_maskz_packs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_packs_epi32&expand=4084)_mm512_packs_epi16/// Convert packed signed 16-bit integers from a and b to packed 8-bit integers using signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_packs_epi16&expand=4082)_mm512_mask_packs_epi16/// Convert packed signed 16-bit integers from a and b to packed 8-bit integers using signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_packs_epi16&expand=4080)_mm512_maskz_packs_epi16/// Convert packed signed 16-bit integers from a and b to packed 8-bit integers using signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_packs_epi16&expand=4081)_mm256_mask_packs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_packs_epi16&expand=4077)_mm256_maskz_packs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=#text=_mm256_maskz_packs_epi16&expand=4078)_mm_mask_packs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_packs_epi16&expand=4074)_mm_maskz_packs_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_packs_epi16&expand=4075)_mm512_packus_epi32/// Convert packed signed 32-bit integers from a and b to packed 16-bit integers using unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_packus_epi32&expand=4130)_mm512_mask_packus_epi32/// Convert packed signed 32-bit integers from a and b to packed 16-bit integers using unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_packus_epi32&expand=4128)_mm512_maskz_packus_epi32/// Convert packed signed 32-bit integers from a and b to packed 16-bit integers using unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_packus_epi32&expand=4129)_mm256_mask_packus_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_packus_epi32&expand=4125)_mm256_maskz_packus_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_packus_epi32&expand=4126)_mm_mask_packus_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_packus_epi32&expand=4122)_mm_maskz_packus_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_packus_epi32&expand=4123)_mm512_packus_epi16/// Convert packed signed 16-bit integers from a and b to packed 8-bit integers using unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_packus_epi16&expand=4121)_mm512_mask_packus_epi16/// Convert packed signed 16-bit integers from a and b to packed 8-bit integers using unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_packus_epi16&expand=4119)_mm512_maskz_packus_epi16/// Convert packed signed 16-bit integers from a and b to packed 8-bit integers using unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_packus_epi16&expand=4120)_mm256_mask_packus_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_packus_epi16&expand=4116)_mm256_maskz_packus_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_packus_epi16&expand=4117)_mm_mask_packus_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_packus_epi16&expand=4113)_mm_maskz_packus_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_packus_epi16&expand=4114)_mm512_avg_epu16/// Average packed unsigned 16-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_avg_epu16&expand=388)_mm512_mask_avg_epu16/// Average packed unsigned 16-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_avg_epu16&expand=389)_mm512_maskz_avg_epu16/// Average packed unsigned 16-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_avg_epu16&expand=390)_mm256_mask_avg_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_avg_epu16&expand=386)_mm256_maskz_avg_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_avg_epu16&expand=387)_mm_mask_avg_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_avg_epu16&expand=383)_mm_maskz_avg_epu16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_avg_epu16&expand=384)_mm512_avg_epu8/// Average packed unsigned 8-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_avg_epu8&expand=397)_mm512_mask_avg_epu8/// Average packed unsigned 8-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_avg_epu8&expand=398)_mm512_maskz_avg_epu8/// Average packed unsigned 8-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_avg_epu8&expand=399)_mm256_mask_avg_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_avg_epu8&expand=395)_mm256_maskz_avg_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_avg_epu8&expand=396)_mm_mask_avg_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_avg_epu8&expand=392)_mm_maskz_avg_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_avg_epu8&expand=393)_mm512_sll_epi16/// Shift packed 16-bit integers in a left by count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sll_epi16&expand=5271)_mm512_mask_sll_epi16/// Shift packed 16-bit integers in a left by count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sll_epi16&expand=5269)_mm512_maskz_sll_epi16/// Shift packed 16-bit integers in a left by count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sll_epi16&expand=5270)_mm256_mask_sll_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sll_epi16&expand=5266)_mm256_maskz_sll_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sll_epi16&expand=5267)_mm_mask_sll_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sll_epi16&expand=5263)_mm_maskz_sll_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sll_epi16&expand=5264)_mm512_slli_epi16/// Shift packed 16-bit integers in a left by imm8 while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_slli_epi16&expand=5301)_mm512_mask_slli_epi16/// Shift packed 16-bit integers in a left by imm8 while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_slli_epi16&expand=5299)_mm512_maskz_slli_epi16/// Shift packed 16-bit integers in a left by imm8 while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_slli_epi16&expand=5300)_mm256_mask_slli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_slli_epi16&expand=5296)_mm256_maskz_slli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_slli_epi16&expand=5297)_mm_mask_slli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_slli_epi16&expand=5293)_mm_maskz_slli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_slli_epi16&expand=5294)_mm512_sllv_epi16/// Shift packed 16-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sllv_epi16&expand=5333)_mm512_mask_sllv_epi16/// Shift packed 16-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sllv_epi16&expand=5331)_mm512_maskz_sllv_epi16/// Shift packed 16-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sllv_epi16&expand=5332)_mm256_sllv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sllv_epi16&expand=5330)_mm256_mask_sllv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sllv_epi16&expand=5328)_mm256_maskz_sllv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sllv_epi16&expand=5329)_mm_sllv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sllv_epi16&expand=5327)_mm_mask_sllv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sllv_epi16&expand=5325)_mm_maskz_sllv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sllv_epi16&expand=5326)_mm512_srl_epi16/// Shift packed 16-bit integers in a right by count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srl_epi16&expand=5483)_mm512_mask_srl_epi16/// Shift packed 16-bit integers in a right by count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srl_epi16&expand=5481)_mm512_maskz_srl_epi16/// Shift packed 16-bit integers in a right by count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srl_epi16&expand=5482)_mm256_mask_srl_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srl_epi16&expand=5478)_mm256_maskz_srl_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srl_epi16&expand=5479)_mm_mask_srl_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srl_epi16&expand=5475)_mm_maskz_srl_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srl_epi16&expand=5476)_mm512_srli_epi16/// Shift packed 16-bit integers in a right by imm8 while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srli_epi16&expand=5513)_mm512_mask_srli_epi16/// Shift packed 16-bit integers in a right by imm8 while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srli_epi16&expand=5511)_mm512_maskz_srli_epi16/// Shift packed 16-bit integers in a right by imm8 while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srli_epi16&expand=5512)_mm256_mask_srli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srli_epi16&expand=5508)_mm256_maskz_srli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srli_epi16&expand=5509)_mm_mask_srli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srli_epi16&expand=5505)_mm_maskz_srli_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srli_epi16&expand=5506)_mm512_srlv_epi16/// Shift packed 16-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srlv_epi16&expand=5545)_mm512_mask_srlv_epi16/// Shift packed 16-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srlv_epi16&expand=5543)_mm512_maskz_srlv_epi16/// Shift packed 16-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srlv_epi16&expand=5544)_mm256_srlv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srlv_epi16&expand=5542)_mm256_mask_srlv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srlv_epi16&expand=5540)_mm256_maskz_srlv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srlv_epi16&expand=5541)_mm_srlv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srlv_epi16&expand=5539)_mm_mask_srlv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srlv_epi16&expand=5537)_mm_maskz_srlv_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srlv_epi16&expand=5538)_mm512_sra_epi16/// Shift packed 16-bit integers in a right by count while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sra_epi16&expand=5398)_mm512_mask_sra_epi16/// Shift packed 16-bit integers in a right by count while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sra_epi16&expand=5396)_mm512_maskz_sra_epi16/// Shift packed 16-bit integers in a right by count while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sra_epi16&expand=5397)_mm256_mask_sra_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sra_epi16&expand=5393)_mm256_maskz_sra_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sra_epi16&expand=5394)_mm_mask_sra_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sra_epi16&expand=5390)_mm_maskz_sra_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sra_epi16&expand=5391)_mm512_srai_epi16/// Shift packed 16-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srai_epi16&expand=5427)_mm512_mask_srai_epi16/// Shift packed 16-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srai_epi16&expand=5425)_mm512_maskz_srai_epi16/// Shift packed 16-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srai_epi16&expand=5426)_mm256_mask_srai_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srai_epi16&expand=5422)_mm256_maskz_srai_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srai_epi16&expand=5423)_mm_mask_srai_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srai_epi16&expand=5419)_mm_maskz_srai_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srai_epi16&expand=5420)_mm512_srav_epi16/// Shift packed 16-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srav_epi16&expand=5456)_mm512_mask_srav_epi16/// Shift packed 16-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srav_epi16&expand=5454)_mm512_maskz_srav_epi16/// Shift packed 16-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srav_epi16&expand=5455)_mm256_srav_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srav_epi16&expand=5453)_mm256_mask_srav_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srav_epi16&expand=5451)_mm256_maskz_srav_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srav_epi16&expand=5452)_mm_srav_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srav_epi16&expand=5450)_mm_mask_srav_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srav_epi16&expand=5448)_mm_maskz_srav_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srav_epi16&expand=5449)_mm512_permutex2var_epi16/// Shuffle 16-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex2var_epi16&expand=4226)//vpermi2w or vpermt2w_mm512_mask_permutex2var_epi16/// Shuffle 16-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex2var_epi16&expand=4223)_mm512_maskz_permutex2var_epi16/// Shuffle 16-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex2var_epi16&expand=4225)_mm512_mask2_permutex2var_epi16/// Shuffle 16-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from idx when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask2_permutex2var_epi16&expand=4224)_mm256_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex2var_epi16&expand=4222)_mm256_mask_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex2var_epi16&expand=4219)_mm256_maskz_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex2var_epi16&expand=4221)_mm256_mask2_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask2_permutex2var_epi16&expand=4220)_mm_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutex2var_epi16&expand=4218)_mm_mask_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutex2var_epi16&expand=4215)_mm_maskz_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutex2var_epi16&expand=4217)_mm_mask2_permutex2var_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask2_permutex2var_epi16&expand=4216)_mm512_permutexvar_epi16/// Shuffle 16-bit integers in a across lanes using the corresponding index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutexvar_epi16&expand=4295)_mm512_mask_permutexvar_epi16/// Shuffle 16-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutexvar_epi16&expand=4293)_mm512_maskz_permutexvar_epi16/// Shuffle 16-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutexvar_epi16&expand=4294)_mm256_permutexvar_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutexvar_epi16&expand=4292)_mm256_mask_permutexvar_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutexvar_epi16&expand=4290)_mm256_maskz_permutexvar_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutexvar_epi16&expand=4291)_mm_permutexvar_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutexvar_epi16&expand=4289)_mm_mask_permutexvar_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutexvar_epi16&expand=4287)_mm_maskz_permutexvar_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutexvar_epi16&expand=4288)_mm512_mask_blend_epi16/// Blend packed 16-bit integers from a and b using control mask k, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_blend_epi16&expand=430)//should be vpblendmw_mm256_mask_blend_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_blend_epi16&expand=429)_mm_mask_blend_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_blend_epi16&expand=427)_mm512_mask_blend_epi8/// Blend packed 8-bit integers from a and b using control mask k, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_blend_epi8&expand=441)//should be vpblendmb_mm256_mask_blend_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_blend_epi8&expand=440)_mm_mask_blend_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_blend_epi8&expand=439)_mm512_broadcastw_epi16/// Broadcast the low packed 16-bit integer from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastw_epi16&expand=587)_mm512_mask_broadcastw_epi16/// Broadcast the low packed 16-bit integer from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcastw_epi16&expand=588)_mm512_maskz_broadcastw_epi16/// Broadcast the low packed 16-bit integer from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcastw_epi16&expand=589)_mm256_mask_broadcastw_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcastw_epi16&expand=585)_mm256_maskz_broadcastw_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcastw_epi16&expand=586)_mm_mask_broadcastw_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_broadcastw_epi16&expand=582)_mm_maskz_broadcastw_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_broadcastw_epi16&expand=583)_mm512_broadcastb_epi8/// Broadcast the low packed 8-bit integer from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastb_epi8&expand=536)_mm512_mask_broadcastb_epi8/// Broadcast the low packed 8-bit integer from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcastb_epi8&expand=537)_mm512_maskz_broadcastb_epi8/// Broadcast the low packed 8-bit integer from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcastb_epi8&expand=538)_mm256_mask_broadcastb_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcastb_epi8&expand=534)_mm256_maskz_broadcastb_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcastb_epi8&expand=535)_mm_mask_broadcastb_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_broadcastb_epi8&expand=531)_mm_maskz_broadcastb_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_broadcastb_epi8&expand=532)_mm512_unpackhi_epi16/// Unpack and interleave 16-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpackhi_epi16&expand=6012)_mm512_mask_unpackhi_epi16/// Unpack and interleave 16-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpackhi_epi16&expand=6010)_mm512_maskz_unpackhi_epi16/// Unpack and interleave 16-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpackhi_epi16&expand=6011)_mm256_mask_unpackhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpackhi_epi16&expand=6007)_mm256_maskz_unpackhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpackhi_epi16&expand=6008)_mm_mask_unpackhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpackhi_epi16&expand=6004)_mm_maskz_unpackhi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpackhi_epi16&expand=6005)_mm512_unpackhi_epi8/// Unpack and interleave 8-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpackhi_epi8&expand=6039)_mm512_mask_unpackhi_epi8/// Unpack and interleave 8-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpackhi_epi8&expand=6037)_mm512_maskz_unpackhi_epi8/// Unpack and interleave 8-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpackhi_epi8&expand=6038)_mm256_mask_unpackhi_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpackhi_epi8&expand=6034)_mm256_maskz_unpackhi_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpackhi_epi8&expand=6035)_mm_mask_unpackhi_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpackhi_epi8&expand=6031)_mm_maskz_unpackhi_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpackhi_epi8&expand=6032)_mm512_unpacklo_epi16/// Unpack and interleave 16-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpacklo_epi16&expand=6069)_mm512_mask_unpacklo_epi16/// Unpack and interleave 16-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpacklo_epi16&expand=6067)_mm512_maskz_unpacklo_epi16/// Unpack and interleave 16-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpacklo_epi16&expand=6068)_mm256_mask_unpacklo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpacklo_epi16&expand=6064)_mm256_maskz_unpacklo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpacklo_epi16&expand=6065)_mm_mask_unpacklo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpacklo_epi16&expand=6061)_mm_maskz_unpacklo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpacklo_epi16&expand=6062)_mm512_unpacklo_epi8/// Unpack and interleave 8-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpacklo_epi8&expand=6096)_mm512_mask_unpacklo_epi8/// Unpack and interleave 8-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpacklo_epi8&expand=6094)_mm512_maskz_unpacklo_epi8/// Unpack and interleave 8-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpacklo_epi8&expand=6095)_mm256_mask_unpacklo_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpacklo_epi8&expand=6091)_mm256_maskz_unpacklo_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpacklo_epi8&expand=6092)_mm_mask_unpacklo_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpacklo_epi8&expand=6088)_mm_maskz_unpacklo_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpacklo_epi8&expand=6089)_mm512_mask_mov_epi16/// Move packed 16-bit integers from a into dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mov_epi16&expand=3795)_mm512_maskz_mov_epi16/// Move packed 16-bit integers from a into dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mov_epi16&expand=3796)_mm256_mask_mov_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mov_epi16&expand=3793)_mm256_maskz_mov_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mov_epi16&expand=3794)_mm_mask_mov_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mov_epi16&expand=3791)_mm_maskz_mov_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mov_epi16&expand=3792)_mm512_mask_mov_epi8/// Move packed 8-bit integers from a into dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mov_epi8&expand=3813)_mm512_maskz_mov_epi8/// Move packed 8-bit integers from a into dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mov_epi8&expand=3814)_mm256_mask_mov_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mov_epi8&expand=3811)_mm256_maskz_mov_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mov_epi8&expand=3812)_mm_mask_mov_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mov_epi8&expand=3809)_mm_maskz_mov_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mov_epi8&expand=3810)_mm512_mask_set1_epi16/// Broadcast 16-bit integer a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_set1_epi16&expand=4942)_mm512_maskz_set1_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_set1_epi16&expand=4943)_mm256_mask_set1_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_set1_epi16&expand=4939)_mm256_maskz_set1_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_set1_epi16&expand=4940)_mm_mask_set1_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_set1_epi16&expand=4936)_mm_maskz_set1_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_set1_epi16&expand=4937)_mm512_mask_set1_epi8/// Broadcast 8-bit integer a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_set1_epi8&expand=4970)_mm512_maskz_set1_epi8/// Broadcast 8-bit integer a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_set1_epi8&expand=4971)_mm256_mask_set1_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_set1_epi8&expand=4967)_mm256_maskz_set1_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_set1_epi8&expand=4968)_mm_mask_set1_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_set1_epi8&expand=4964)_mm_maskz_set1_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_set1_epi8&expand=4965)_mm512_shufflelo_epi16/// Shuffle 16-bit integers in the low 64 bits of 128-bit lanes of a using the control in imm8. Store the results in the low 64 bits of 128-bit lanes of dst, with the high 64 bits of 128-bit lanes being copied from a to dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shufflelo_epi16&expand=5221)_mm512_mask_shufflelo_epi16/// Shuffle 16-bit integers in the low 64 bits of 128-bit lanes of a using the control in imm8. Store the results in the low 64 bits of 128-bit lanes of dst, with the high 64 bits of 128-bit lanes being copied from a to dst, using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shufflelo_epi16&expand=5219)_mm512_maskz_shufflelo_epi16/// Shuffle 16-bit integers in the low 64 bits of 128-bit lanes of a using the control in imm8. Store the results in the low 64 bits of 128-bit lanes of dst, with the high 64 bits of 128-bit lanes being copied from a to dst, using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shufflelo_epi16&expand=5220)_mm256_mask_shufflelo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shufflelo_epi16&expand=5216)_mm256_maskz_shufflelo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shufflelo_epi16&expand=5217)_mm_mask_shufflelo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_shufflelo_epi16&expand=5213)_mm_maskz_shufflelo_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_shufflelo_epi16&expand=5214)_mm512_shufflehi_epi16/// Shuffle 16-bit integers in the high 64 bits of 128-bit lanes of a using the control in imm8. Store the results in the high 64 bits of 128-bit lanes of dst, with the low 64 bits of 128-bit lanes being copied from a to dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shufflehi_epi16&expand=5212)_mm512_mask_shufflehi_epi16/// Shuffle 16-bit integers in the high 64 bits of 128-bit lanes of a using the control in imm8. Store the results in the high 64 bits of 128-bit lanes of dst, with the low 64 bits of 128-bit lanes being copied from a to dst, using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shufflehi_epi16&expand=5210)_mm512_maskz_shufflehi_epi16/// Shuffle 16-bit integers in the high 64 bits of 128-bit lanes of a using the control in imm8. Store the results in the high 64 bits of 128-bit lanes of dst, with the low 64 bits of 128-bit lanes being copied from a to dst, using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shufflehi_epi16&expand=5211)_mm256_mask_shufflehi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shufflehi_epi16&expand=5207)_mm256_maskz_shufflehi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shufflehi_epi16&expand=5208)_mm_mask_shufflehi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_shufflehi_epi16&expand=5204)_mm_maskz_shufflehi_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_shufflehi_epi16&expand=5205)_mm512_shuffle_epi8/// Shuffle packed 8-bit integers in a according to shuffle control mask in the corresponding 8-bit element of b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_epi8&expand=5159)_mm512_mask_shuffle_epi8/// Shuffle 8-bit integers in a within 128-bit lanes using the control in the corresponding 8-bit element of b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_epi8&expand=5157)_mm512_maskz_shuffle_epi8/// Shuffle packed 8-bit integers in a according to shuffle control mask in the corresponding 8-bit element of b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_epi8&expand=5158)_mm256_mask_shuffle_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_epi8&expand=5154)_mm256_maskz_shuffle_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_epi8&expand=5155)_mm_mask_shuffle_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_shuffle_epi8&expand=5151)_mm_maskz_shuffle_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_shuffle_epi8&expand=5152)_mm512_test_epi16_mask/// Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in result mask k if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_test_epi16_mask&expand=5884)_mm512_mask_test_epi16_mask/// Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_test_epi16_mask&expand=5883)_mm256_test_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_test_epi16_mask&expand=5882)_mm256_mask_test_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_test_epi16_mask&expand=5881)_mm_test_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_test_epi16_mask&expand=5880)_mm_mask_test_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_test_epi16_mask&expand=5879)_mm512_test_epi8_mask/// Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in result mask k if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_test_epi8_mask&expand=5902)_mm512_mask_test_epi8_mask/// Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_test_epi8_mask&expand=5901)_mm256_test_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_test_epi8_mask&expand=5900)_mm256_mask_test_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_test_epi8_mask&expand=5899)_mm_test_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_test_epi8_mask&expand=5898)_mm_mask_test_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_test_epi8_mask&expand=5897)_mm512_testn_epi16_mask/// Compute the bitwise NAND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in result mask k if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_testn_epi16_mask&expand=5915)_mm512_mask_testn_epi16_mask/// Compute the bitwise NAND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_testn_epi16_mask&expand=5914)_mm256_testn_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testn_epi16_mask&expand=5913)_mm256_mask_testn_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_testn_epi16_mask&expand=5912)_mm_testn_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testn_epi16_mask&expand=5911)_mm_mask_testn_epi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_testn_epi16_mask&expand=5910)_mm512_testn_epi8_mask/// Compute the bitwise NAND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in result mask k if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_testn_epi8_mask&expand=5933)_mm512_mask_testn_epi8_mask/// Compute the bitwise NAND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_testn_epi8_mask&expand=5932)_mm256_testn_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testn_epi8_mask&expand=5931)_mm256_mask_testn_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_testn_epi8_mask&expand=5930)_mm_testn_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testn_epi8_mask&expand=5929)_mm_mask_testn_epi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_testn_epi8_mask&expand=5928)_store_mask64/// Store 64-bit mask from a into memory./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_store_mask64&expand=5578)//should be kmovq_store_mask32/// Store 32-bit mask from a into memory./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_store_mask32&expand=5577)//should be kmovd_load_mask64/// Load 64-bit mask from memory into k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_load_mask64&expand=3318)_load_mask32/// Load 32-bit mask from memory into k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_load_mask32&expand=3317)_mm512_sad_epu8/// Compute the absolute differences of packed unsigned 8-bit integers in a and b, then horizontally sum each consecutive 8 differences to produce eight unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low 16 bits of 64-bit elements in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sad_epu8&expand=4855)_mm512_dbsad_epu8/// Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in a compared to those in b, and store the 16-bit results in dst. Four SADs are performed on four 8-bit quadruplets for each 64-bit lane. The first two SADs use the lower 8-bit quadruplet of the lane from a, and the last two SADs use the uppper 8-bit quadruplet of the lane from a. Quadruplets from b are selected from within 128-bit lanes according to the control in imm8, and each SAD in each 64-bit lane uses the selected quadruplet at 8-bit offsets./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_dbsad_epu8&expand=2114)_mm512_mask_dbsad_epu8/// Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in a compared to those in b, and store the 16-bit results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). Four SADs are performed on four 8-bit quadruplets for each 64-bit lane. The first two SADs use the lower 8-bit quadruplet of the lane from a, and the last two SADs use the uppper 8-bit quadruplet of the lane from a. Quadruplets from b are selected from within 128-bit lanes according to the control in imm8, and each SAD in each 64-bit lane uses the selected quadruplet at 8-bit offsets./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_dbsad_epu8&expand=2115)_mm512_maskz_dbsad_epu8/// Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in a compared to those in b, and store the 16-bit results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Four SADs are performed on four 8-bit quadruplets for each 64-bit lane. The first two SADs use the lower 8-bit quadruplet of the lane from a, and the last two SADs use the uppper 8-bit quadruplet of the lane from a. Quadruplets from b are selected from within 128-bit lanes according to the control in imm8, and each SAD in each 64-bit lane uses the selected quadruplet at 8-bit offsets./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_dbsad_epu8&expand=2116)_mm256_dbsad_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_dbsad_epu8&expand=2111)_mm256_mask_dbsad_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_dbsad_epu8&expand=2112)_mm256_maskz_dbsad_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_dbsad_epu8&expand=2113)_mm_dbsad_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_dbsad_epu8&expand=2108)_mm_mask_dbsad_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_dbsad_epu8&expand=2109)_mm_maskz_dbsad_epu8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_dbsad_epu8&expand=2110)_mm512_movepi16_mask/// Set each bit of mask register k based on the most significant bit of the corresponding packed 16-bit integer in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movepi16_mask&expand=3873)_mm256_movepi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movepi16_mask&expand=3872)_mm_movepi16_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movepi16_mask&expand=3871)_mm512_movepi8_mask/// Set each bit of mask register k based on the most significant bit of the corresponding packed 8-bit integer in a./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movepi8_mask&expand=3883)_mm256_movepi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movepi8_mask&expand=3882)// should be vpmovb2m but compiled to vpmovmskb in the test shim because that takes less cycles than// using vpmovb2m plus converting the mask register to a standard register._mm_movepi8_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movepi8_mask&expand=3881)_mm512_movm_epi16/// Set each packed 16-bit integer in dst to all ones or all zeros based on the value of the corresponding bit in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movm_epi16&expand=3886)_mm256_movm_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movm_epi16&expand=3885)_mm_movm_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movm_epi16&expand=3884)_mm512_movm_epi8/// Set each packed 8-bit integer in dst to all ones or all zeros based on the value of the corresponding bit in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movm_epi8&expand=3895)_mm256_movm_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movm_epi8&expand=3894)_mm_movm_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movm_epi8&expand=3893)_cvtmask32_u32/// Convert 32-bit mask a into an integer value, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#_cvtmask32_u32)_cvtu32_mask32/// Convert integer value a into an 32-bit mask, and store the result in k./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_cvtu32_mask32)_kadd_mask32/// Add 32-bit masks in a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kadd_mask32&expand=3207)_kadd_mask64/// Add 64-bit masks in a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kadd_mask64&expand=3208)_kand_mask32/// Compute the bitwise AND of 32-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kand_mask32&expand=3213)_kand_mask64/// Compute the bitwise AND of 64-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kand_mask64&expand=3214)_knot_mask32/// Compute the bitwise NOT of 32-bit mask a, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_knot_mask32&expand=3234)_knot_mask64/// Compute the bitwise NOT of 64-bit mask a, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_knot_mask64&expand=3235)_kandn_mask32/// Compute the bitwise NOT of 32-bit masks a and then AND with b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kandn_mask32&expand=3219)_kandn_mask64/// Compute the bitwise NOT of 64-bit masks a and then AND with b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kandn_mask64&expand=3220)_kor_mask32/// Compute the bitwise OR of 32-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kor_mask32&expand=3240)_kor_mask64/// Compute the bitwise OR of 64-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kor_mask64&expand=3241)_kxor_mask32/// Compute the bitwise XOR of 32-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kxor_mask32&expand=3292)_kxor_mask64/// Compute the bitwise XOR of 64-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kxor_mask64&expand=3293)_kxnor_mask32/// Compute the bitwise XNOR of 32-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kxnor_mask32&expand=3286)_kxnor_mask64/// Compute the bitwise XNOR of 64-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kxnor_mask64&expand=3287)_kortest_mask32_u8/// Compute the bitwise OR of 32-bit masks a and b. If the result is all zeros, store 1 in dst, otherwise/// store 0 in dst. If the result is all ones, store 1 in all_ones, otherwise store 0 in all_ones./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortest_mask32_u8)_kortest_mask64_u8/// Compute the bitwise OR of 64-bit masks a and b. If the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortest_mask64_u8)_kortestc_mask32_u8/// Compute the bitwise OR of 32-bit masks a and b. If the result is all ones, store 1 in dst, otherwise/// store 0 in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestc_mask32_u8)_kortestc_mask64_u8/// Compute the bitwise OR of 64-bit masks a and b. If the result is all ones, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestc_mask64_u8)_kortestz_mask32_u8/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestz_mask32_u8)_kortestz_mask64_u8/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestz_mask64_u8)_kshiftli_mask32/// Shift the bits of 32-bit mask a left by count while shifting in zeros, and store the least significant 32 bits of the result in k./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftli_mask32)_kshiftli_mask64/// Shift the bits of 64-bit mask a left by count while shifting in zeros, and store the least significant 32 bits of the result in k./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftli_mask64)_kshiftri_mask32/// Shift the bits of 32-bit mask a right by count while shifting in zeros, and store the least significant 32 bits of the result in k./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftri_mask32)_kshiftri_mask64/// Shift the bits of 64-bit mask a right by count while shifting in zeros, and store the least significant 32 bits of the result in k./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftri_mask64)_ktest_mask32_u8/// Compute the bitwise AND of 32-bit masks a and b, and if the result is all zeros, store 1 in dst,/// otherwise store 0 in dst. Compute the bitwise NOT of a and then AND with b, if the result is all/// zeros, store 1 in and_not, otherwise store 0 in and_not./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktest_mask32_u8)_ktest_mask64_u8/// Compute the bitwise AND of 64-bit masks a and b, and if the result is all zeros, store 1 in dst,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktest_mask64_u8)_ktestc_mask32_u8/// Compute the bitwise NOT of 32-bit mask a and then AND with 16-bit mask b, if the result is all/// zeros, store 1 in dst, otherwise store 0 in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestc_mask32_u8)_ktestc_mask64_u8/// Compute the bitwise NOT of 64-bit mask a and then AND with 8-bit mask b, if the result is all/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestc_mask64_u8)_ktestz_mask32_u8/// Compute the bitwise AND of 32-bit masks a and  b, if the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestz_mask32_u8)_ktestz_mask64_u8/// Compute the bitwise AND of 64-bit masks a and  b, if the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestz_mask64_u8)_mm512_kunpackw/// Unpack and interleave 16 bits from masks a and b, and store the 32-bit result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kunpackw)// generate normal and code instead of kunpckwd_mm512_kunpackd/// Unpack and interleave 32 bits from masks a and b, and store the 64-bit result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kunpackd)// generate normal and code instead of kunpckdq_mm512_cvtepi16_epi8/// Convert packed 16-bit integers in a to packed 8-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi16_epi8&expand=1407)_mm512_mask_cvtepi16_epi8/// Convert packed 16-bit integers in a to packed 8-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi16_epi8&expand=1408)_mm512_maskz_cvtepi16_epi8/// Convert packed 16-bit integers in a to packed 8-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi16_epi8&expand=1409)_mm256_cvtepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi16_epi8&expand=1404)_mm256_mask_cvtepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi16_epi8&expand=1405)_mm256_maskz_cvtepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi16_epi8&expand=1406)_mm_cvtepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi16_epi8&expand=1401)_mm_mask_cvtepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi16_epi8&expand=1402)_mm_maskz_cvtepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi16_epi8&expand=1403)_mm512_cvtsepi16_epi8/// Convert packed signed 16-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsepi16_epi8&expand=1807)_mm512_mask_cvtsepi16_epi8/// Convert packed signed 16-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi16_epi8&expand=1808)_mm512_maskz_cvtsepi16_epi8/// Convert packed signed 16-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtsepi16_epi8&expand=1809)_mm256_cvtsepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsepi16_epi8&expand=1804)_mm256_mask_cvtsepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi16_epi8&expand=1805)_mm256_maskz_cvtsepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtsepi16_epi8&expand=1806)_mm_cvtsepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsepi16_epi8&expand=1801)_mm_mask_cvtsepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi16_epi8&expand=1802)_mm_maskz_cvtsepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtsepi16_epi8&expand=1803)_mm512_cvtusepi16_epi8/// Convert packed unsigned 16-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtusepi16_epi8&expand=2042)_mm512_mask_cvtusepi16_epi8/// Convert packed unsigned 16-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi16_epi8&expand=2043)_mm512_maskz_cvtusepi16_epi8/// Convert packed unsigned 16-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtusepi16_epi8&expand=2044)_mm256_cvtusepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtusepi16_epi8&expand=2039)_mm256_mask_cvtusepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi16_epi8&expand=2040)_mm256_maskz_cvtusepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtusepi16_epi8&expand=2041)_mm_cvtusepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtusepi16_epi8&expand=2036)_mm_mask_cvtusepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi16_epi8&expand=2037)_mm_maskz_cvtusepi16_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtusepi16_epi8&expand=2038)_mm512_cvtepi8_epi16/// Sign extend packed 8-bit integers in a to packed 16-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi8_epi16&expand=1526)_mm512_mask_cvtepi8_epi16/// Sign extend packed 8-bit integers in a to packed 16-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi8_epi16&expand=1527)_mm512_maskz_cvtepi8_epi16/// Sign extend packed 8-bit integers in a to packed 16-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi8_epi16&expand=1528)_mm256_mask_cvtepi8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi8_epi16&expand=1524)_mm256_maskz_cvtepi8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi8_epi16&expand=1525)_mm_mask_cvtepi8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi8_epi16&expand=1521)_mm_maskz_cvtepi8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi8_epi16&expand=1522)_mm512_cvtepu8_epi16/// Zero extend packed unsigned 8-bit integers in a to packed 16-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu8_epi16&expand=1612)_mm512_mask_cvtepu8_epi16/// Zero extend packed unsigned 8-bit integers in a to packed 16-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu8_epi16&expand=1613)_mm512_maskz_cvtepu8_epi16/// Zero extend packed unsigned 8-bit integers in a to packed 16-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu8_epi16&expand=1614)_mm256_mask_cvtepu8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu8_epi16&expand=1610)_mm256_maskz_cvtepu8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu8_epi16&expand=1611)_mm_mask_cvtepu8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu8_epi16&expand=1607)_mm_maskz_cvtepu8_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu8_epi16&expand=1608)_mm512_bslli_epi128/// Shift 128-bit lanes in a left by imm8 bytes while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_bslli_epi128&expand=591)_mm512_bsrli_epi128/// Shift 128-bit lanes in a right by imm8 bytes while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_bsrli_epi128&expand=594)_mm512_alignr_epi8/// Concatenate pairs of 16-byte blocks in a and b into a 32-byte temporary result, shift the result right by imm8 bytes, and store the low 16 bytes in dst./// Unlike [`_mm_alignr_epi8`], [`_mm256_alignr_epi8`] functions, where the entire input vectors are concatenated to the temporary result,/// this concatenation happens in 4 steps, where each step builds 32-byte temporary result./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_alignr_epi8&expand=263)_mm512_mask_alignr_epi8/// Concatenate pairs of 16-byte blocks in a and b into a 32-byte temporary result, shift the result right by imm8 bytes, and store the low 16 bytes in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_alignr_epi8&expand=264)_mm512_maskz_alignr_epi8/// Concatenate pairs of 16-byte blocks in a and b into a 32-byte temporary result, shift the result right by imm8 bytes, and store the low 16 bytes in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_alignr_epi8&expand=265)_mm256_mask_alignr_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_alignr_epi8&expand=261)_mm256_maskz_alignr_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_alignr_epi8&expand=262)_mm_mask_alignr_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_alignr_epi8&expand=258)_mm_maskz_alignr_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_alignr_epi8&expand=259)_mm512_mask_cvtsepi16_storeu_epi8/// Convert packed signed 16-bit integers in a to packed 8-bit integers with signed saturation, and store the active results (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi16_storeu_epi8&expand=1812)_mm256_mask_cvtsepi16_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi16_storeu_epi8&expand=1811)_mm_mask_cvtsepi16_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi16_storeu_epi8&expand=1810)_mm512_mask_cvtepi16_storeu_epi8/// Convert packed 16-bit integers in a to packed 8-bit integers with truncation, and store the active results (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi16_storeu_epi8&expand=1412)_mm256_mask_cvtepi16_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi16_storeu_epi8&expand=1411)_mm_mask_cvtepi16_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi16_storeu_epi8&expand=1410)_mm512_mask_cvtusepi16_storeu_epi8/// Convert packed unsigned 16-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the active results (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi16_storeu_epi8&expand=2047)_mm256_mask_cvtusepi16_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi16_storeu_epi8&expand=2046)_mm_mask_cvtusepi16_storeu_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi16_storeu_epi8&expand=2045)"llvm.x86.avx512.pmul.hr.sw.512"vpmulhrsw"llvm.x86.avx512.pmaddw.d.512"vpmaddwd"llvm.x86.avx512.pmaddubs.w.512"vpmaddubsw"llvm.x86.avx512.packssdw.512"vpackssdw"llvm.x86.avx512.packsswb.512"vpacksswb"llvm.x86.avx512.packusdw.512"vpackusdw"llvm.x86.avx512.packuswb.512"vpackuswb"llvm.x86.avx512.psll.w.512"vpsllw"llvm.x86.avx512.psrl.w.512"vpsrlw"llvm.x86.avx512.psra.w.512"vpsraw"llvm.x86.avx512.vpermi2var.hi.512"vpermi2w"llvm.x86.avx512.vpermi2var.hi.256"vpermi2w256"llvm.x86.avx512.vpermi2var.hi.128"vpermi2w128"llvm.x86.avx512.permvar.hi.512"vpermw"llvm.x86.avx512.permvar.hi.256"vpermw256"llvm.x86.avx512.permvar.hi.128"vpermw128"llvm.x86.avx512.pshuf.b.512"vpshufb"llvm.x86.avx512.psad.bw.512"vpsadbw"llvm.x86.avx512.dbpsadbw.512"vdbpsadbw"llvm.x86.avx512.dbpsadbw.256"vdbpsadbw256"llvm.x86.avx512.dbpsadbw.128"vdbpsadbw128"llvm.x86.avx512.mask.pmovs.wb.512"vpmovswb"llvm.x86.avx512.mask.pmovs.wb.256"vpmovswb256"llvm.x86.avx512.mask.pmovs.wb.128"vpmovswb128"llvm.x86.avx512.mask.pmovus.wb.512"vpmovuswb"llvm.x86.avx512.mask.pmovus.wb.256"vpmovuswb256"llvm.x86.avx512.mask.pmovus.wb.128"vpmovuswb128"llvm.x86.avx512.mask.pmovs.wb.mem.512"vpmovswbmem"llvm.x86.avx512.mask.pmovs.wb.mem.256"vpmovswbmem256"llvm.x86.avx512.mask.pmovs.wb.mem.128"vpmovswbmem128"llvm.x86.avx512.mask.pmov.wb.mem.512"vpmovwbmem"llvm.x86.avx512.mask.pmov.wb.mem.256"vpmovwbmem256"llvm.x86.avx512.mask.pmov.wb.mem.128"vpmovwbmem128"llvm.x86.avx512.mask.pmovus.wb.mem.512"vpmovuswbmem"llvm.x86.avx512.mask.pmovus.wb.mem.256"vpmovuswbmem256"llvm.x86.avx512.mask.pmovus.wb.mem.128"vpmovuswbmem128_mm512_broadcastmw_epi32/// Broadcast the low 16-bits from input mask k to all 32-bit elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastmw_epi32&expand=553)// should be vpbroadcastmw2d_mm256_broadcastmw_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastmw_epi32&expand=552)_mm_broadcastmw_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastmw_epi32&expand=551)_mm512_broadcastmb_epi64/// Broadcast the low 8-bits from input mask k to all 64-bit elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastmb_epi64&expand=550)// should be vpbroadcastmb2q_mm256_broadcastmb_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcastmb_epi64&expand=549)_mm_broadcastmb_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcastmb_epi64&expand=548)_mm512_conflict_epi32/// Test each 32-bit element of a for equality with all other elements in a closer to the least significant bit. Each element's comparison forms a zero extended bit vector in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_conflict_epi32&expand=1248)_mm512_mask_conflict_epi32/// Test each 32-bit element of a for equality with all other elements in a closer to the least significant bit using writemask k (elements are copied from src when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_conflict_epi32&expand=1249)_mm512_maskz_conflict_epi32/// Test each 32-bit element of a for equality with all other elements in a closer to the least significant bit using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_conflict_epi32&expand=1250)_mm256_conflict_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_conflict_epi32&expand=1245)_mm256_mask_conflict_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_conflict_epi32&expand=1246)_mm256_maskz_conflict_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_conflict_epi32&expand=1247)_mm_conflict_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_conflict_epi32&expand=1242)_mm_mask_conflict_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_conflict_epi32&expand=1243)_mm_maskz_conflict_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_conflict_epi32&expand=1244)_mm512_conflict_epi64/// Test each 64-bit element of a for equality with all other elements in a closer to the least significant bit. Each element's comparison forms a zero extended bit vector in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_conflict_epi64&expand=1257)_mm512_mask_conflict_epi64/// Test each 64-bit element of a for equality with all other elements in a closer to the least significant bit using writemask k (elements are copied from src when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_conflict_epi64&expand=1258)_mm512_maskz_conflict_epi64/// Test each 64-bit element of a for equality with all other elements in a closer to the least significant bit using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_conflict_epi64&expand=1259)_mm256_conflict_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_conflict_epi64&expand=1254)_mm256_mask_conflict_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_conflict_epi64&expand=1255)_mm256_maskz_conflict_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_conflict_epi64&expand=1256)_mm_conflict_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_conflict_epi64&expand=1251)_mm_mask_conflict_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_conflict_epi64&expand=1252)_mm_maskz_conflict_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_conflict_epi64&expand=1253)_mm512_lzcnt_epi32/// Counts the number of leading zero bits in each packed 32-bit integer in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_lzcnt_epi32&expand=3491)_mm512_mask_lzcnt_epi32/// Counts the number of leading zero bits in each packed 32-bit integer in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_lzcnt_epi32&expand=3492)_mm512_maskz_lzcnt_epi32/// Counts the number of leading zero bits in each packed 32-bit integer in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_lzcnt_epi32&expand=3493)_mm256_lzcnt_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_lzcnt_epi32&expand=3488)_mm256_mask_lzcnt_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_lzcnt_epi32&expand=3489)_mm256_maskz_lzcnt_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_lzcnt_epi32&expand=3490)_mm_lzcnt_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_lzcnt_epi32&expand=3485)_mm_mask_lzcnt_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_lzcnt_epi32&expand=3486)_mm_maskz_lzcnt_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_lzcnt_epi32&expand=3487)_mm512_lzcnt_epi64/// Counts the number of leading zero bits in each packed 64-bit integer in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_lzcnt_epi64&expand=3500)_mm512_mask_lzcnt_epi64/// Counts the number of leading zero bits in each packed 64-bit integer in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_lzcnt_epi64&expand=3501)_mm512_maskz_lzcnt_epi64/// Counts the number of leading zero bits in each packed 64-bit integer in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_lzcnt_epi64&expand=3502)_mm256_lzcnt_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_lzcnt_epi64&expand=3497)_mm256_mask_lzcnt_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_lzcnt_epi64&expand=3498)_mm256_maskz_lzcnt_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_lzcnt_epi64&expand=3499)_mm_lzcnt_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_lzcnt_epi64&expand=3494)_mm_mask_lzcnt_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_lzcnt_epi64&expand=3495)_mm_maskz_lzcnt_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_lzcnt_epi64&expand=3496)"llvm.x86.avx512.conflict.d.512"vpconflictd"llvm.x86.avx512.conflict.d.256"vpconflictd256"llvm.x86.avx512.conflict.d.128"vpconflictd128"llvm.x86.avx512.conflict.q.512"vpconflictq"llvm.x86.avx512.conflict.q.256"vpconflictq256"llvm.x86.avx512.conflict.q.128"vpconflictq128_mm_mask_and_pd/// Compute the bitwise AND of packed double-precision (64-bit) floating point numbers in a and b/// and store the results in dst using writemask k (elements are copied from src if the corresponding/// bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_and_pd&ig_expand=288)_mm_maskz_and_pd/// Compute the bitwise AND of packed double-precision (64-bit) floating point numbers in a and b and/// store the results in dst using zeromask k (elements are zeroed out if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_and_pd&ig_expand=289)_mm256_mask_and_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_and_pd&ig_expand=291)_mm256_maskz_and_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_and_pd&ig_expand=292)_mm512_and_pd/// and store the results in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_and_pd&ig_expand=293)_mm512_mask_and_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_and_pd&ig_expand=294)_mm512_maskz_and_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_and_pd&ig_expand=295)_mm_mask_and_ps/// Compute the bitwise AND of packed single-precision (32-bit) floating point numbers in a and b/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_and_ps&ig_expand=297)_mm_maskz_and_ps/// Compute the bitwise AND of packed single-precision (32-bit) floating point numbers in a and b and/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_and_ps&ig_expand=298)_mm256_mask_and_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_and_ps&ig_expand=300)_mm256_maskz_and_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_and_ps&ig_expand=301)_mm512_and_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_and_ps&ig_expand=303)_mm512_mask_and_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_and_ps&ig_expand=304)_mm512_maskz_and_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_and_ps&ig_expand=305)_mm_mask_andnot_pd/// Compute the bitwise NOT of packed double-precision (64-bit) floating point numbers in a and then/// bitwise AND with b and store the results in dst using writemask k (elements are copied from src if the/// corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_andnot_pd&ig_expand=326)_mm_maskz_andnot_pd/// bitwise AND with b and store the results in dst using zeromask k (elements are zeroed out if the/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_andnot_pd&ig_expand=327)_mm256_mask_andnot_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_andnot_pd&ig_expand=329)_mm256_maskz_andnot_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_andnot_pd&ig_expand=330)_mm512_andnot_pd/// bitwise AND with b and store the results in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_andnot_pd&ig_expand=331)_mm512_mask_andnot_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_andnot_pd&ig_expand=332)_mm512_maskz_andnot_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_andnot_pd&ig_expand=333)_mm_mask_andnot_ps/// Compute the bitwise NOT of packed single-precision (32-bit) floating point numbers in a and then/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_andnot_ps&ig_expand=335)_mm_maskz_andnot_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_andnot_ps&ig_expand=336)_mm256_mask_andnot_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_andnot_ps&ig_expand=338)_mm256_maskz_andnot_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_andnot_ps&ig_expand=339)_mm512_andnot_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_andnot_ps&ig_expand=340)_mm512_mask_andnot_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_andnot_ps&ig_expand=341)_mm512_maskz_andnot_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_andnot_ps&ig_expand=342)_mm_mask_or_pd/// Compute the bitwise OR of packed double-precision (64-bit) floating point numbers in a and b/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_or_pd&ig_expand=4824)_mm_maskz_or_pd/// Compute the bitwise OR of packed double-precision (64-bit) floating point numbers in a and b and/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_or_pd&ig_expand=4825)_mm256_mask_or_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_or_pd&ig_expand=4827)_mm256_maskz_or_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_or_pd&ig_expand=4828)_mm512_or_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_or_pd&ig_expand=4829)_mm512_mask_or_pd/// store the results in dst using writemask k (elements are copied from src if the corresponding/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_or_pd&ig_expand=4830)_mm512_maskz_or_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_or_pd&ig_expand=4831)_mm_mask_or_ps/// Compute the bitwise OR of packed single-precision (32-bit) floating point numbers in a and b/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_or_ps&ig_expand=4833)_mm_maskz_or_ps/// Compute the bitwise OR of packed single-precision (32-bit) floating point numbers in a and b and/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_or_ps&ig_expand=4834)_mm256_mask_or_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_or_ps&ig_expand=4836)_mm256_maskz_or_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_or_ps&ig_expand=4837)_mm512_or_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_or_ps&ig_expand=4838)_mm512_mask_or_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_or_ps&ig_expand=4839)_mm512_maskz_or_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_or_ps&ig_expand=4840)_mm_mask_xor_pd/// Compute the bitwise XOR of packed double-precision (64-bit) floating point numbers in a and b/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_xor_pd&ig_expand=7094)_mm_maskz_xor_pd/// Compute the bitwise XOR of packed double-precision (64-bit) floating point numbers in a and b and/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_xor_pd&ig_expand=7095)_mm256_mask_xor_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_xor_pd&ig_expand=7097)_mm256_maskz_xor_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_xor_pd&ig_expand=7098)_mm512_xor_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_xor_pd&ig_expand=7102)_mm512_mask_xor_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_xor_pd&ig_expand=7100)_mm512_maskz_xor_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_xor_pd&ig_expand=7101)_mm_mask_xor_ps/// Compute the bitwise XOR of packed single-precision (32-bit) floating point numbers in a and b/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_xor_ps&ig_expand=7103)_mm_maskz_xor_ps/// Compute the bitwise XOR of packed single-precision (32-bit) floating point numbers in a and b and/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_xor_ps&ig_expand=7104)_mm256_mask_xor_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_xor_ps&ig_expand=7106)_mm256_maskz_xor_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_xor_ps&ig_expand=7107)_mm512_xor_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_xor_ps&ig_expand=7111)_mm512_mask_xor_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_xor_ps&ig_expand=7109)_mm512_maskz_xor_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_xor_ps&ig_expand=7110)_mm256_broadcast_f32x2/// Broadcasts the lower 2 packed single-precision (32-bit) floating-point elements from a to all/// elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_f32x2&ig_expand=509)_mm256_mask_broadcast_f32x2/// elements of dst using writemask k (elements are copied from src if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcast_f32x2&ig_expand=510)_mm256_maskz_broadcast_f32x2/// elements of dst using zeromask k (elements are zeroed out if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcast_f32x2&ig_expand=511)_mm512_broadcast_f32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_f32x2&ig_expand=512)_mm512_mask_broadcast_f32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_f32x2&ig_expand=513)_mm512_maskz_broadcast_f32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_f32x2&ig_expand=514)_mm512_broadcast_f32x8/// Broadcasts the 8 packed single-precision (32-bit) floating-point elements from a to all/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_f32x8&ig_expand=521)_mm512_mask_broadcast_f32x8/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_f32x8&ig_expand=522)_mm512_maskz_broadcast_f32x8/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_f32x8&ig_expand=523)_mm256_broadcast_f64x2/// Broadcasts the 2 packed double-precision (64-bit) floating-point elements from a to all/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_f64x2&ig_expand=524)_mm256_mask_broadcast_f64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcast_f64x2&ig_expand=525)_mm256_maskz_broadcast_f64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcast_f64x2&ig_expand=526)_mm512_broadcast_f64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_f64x2&ig_expand=527)_mm512_mask_broadcast_f64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_f64x2&ig_expand=528)_mm512_maskz_broadcast_f64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_f64x2&ig_expand=529)_mm_broadcast_i32x2/// Broadcasts the lower 2 packed 32-bit integers from a to all elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_broadcast_i32x2&ig_expand=533)_mm_mask_broadcast_i32x2/// Broadcasts the lower 2 packed 32-bit integers from a to all elements of dst using writemask k/// (elements are copied from src if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_broadcast_i32x2&ig_expand=534)_mm_maskz_broadcast_i32x2/// Broadcasts the lower 2 packed 32-bit integers from a to all elements of dst using zeromask k/// (elements are zeroed out if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_broadcast_i32x2&ig_expand=535)_mm256_broadcast_i32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_i32x2&ig_expand=536)_mm256_mask_broadcast_i32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcast_i32x2&ig_expand=537)_mm256_maskz_broadcast_i32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcast_i32x2&ig_expand=538)_mm512_broadcast_i32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_i32x2&ig_expand=539)_mm512_mask_broadcast_i32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_i32x2&ig_expand=540)_mm512_maskz_broadcast_i32x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_i32x2&ig_expand=541)_mm512_broadcast_i32x8/// Broadcasts the 8 packed 32-bit integers from a to all elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_i32x8&ig_expand=548)_mm512_mask_broadcast_i32x8/// Broadcasts the 8 packed 32-bit integers from a to all elements of dst using writemask k/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_i32x8&ig_expand=549)_mm512_maskz_broadcast_i32x8/// Broadcasts the 8 packed 32-bit integers from a to all elements of dst using zeromask k/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_i32x8&ig_expand=550)_mm256_broadcast_i64x2/// Broadcasts the 2 packed 64-bit integers from a to all elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_i64x2&ig_expand=551)_mm256_mask_broadcast_i64x2/// Broadcasts the 2 packed 64-bit integers from a to all elements of dst using writemask k/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcast_i64x2&ig_expand=552)_mm256_maskz_broadcast_i64x2/// Broadcasts the 2 packed 64-bit integers from a to all elements of dst using zeromask k/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcast_i64x2&ig_expand=553)_mm512_broadcast_i64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_i64x2&ig_expand=554)_mm512_mask_broadcast_i64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_i64x2&ig_expand=555)_mm512_maskz_broadcast_i64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_i64x2&ig_expand=556)_mm512_extractf32x8_ps/// Extracts 256 bits (composed of 8 packed single-precision (32-bit) floating-point elements) from a,/// selected with IMM8, and stores the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extractf32x8_ps&ig_expand=2946)_mm512_mask_extractf32x8_ps/// selected with IMM8, and stores the result in dst using writemask k (elements are copied from src/// if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extractf32x8_ps&ig_expand=2947)_mm512_maskz_extractf32x8_ps/// selected with IMM8, and stores the result in dst using zeromask k (elements are zeroed out if the/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extractf32x8_ps&ig_expand=2948)_mm256_extractf64x2_pd/// Extracts 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from a,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extractf64x2_pd&ig_expand=2949)_mm256_mask_extractf64x2_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_extractf64x2_pd&ig_expand=2950)_mm256_maskz_extractf64x2_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_extractf64x2_pd&ig_expand=2951)_mm512_extractf64x2_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extractf64x2_pd&ig_expand=2952)_mm512_mask_extractf64x2_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extractf64x2_pd&ig_expand=2953)_mm512_maskz_extractf64x2_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extractf64x2_pd&ig_expand=2954)_mm512_extracti32x8_epi32/// Extracts 256 bits (composed of 8 packed 32-bit integers) from a, selected with IMM8, and stores/// the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extracti32x8_epi32&ig_expand=2965)_mm512_mask_extracti32x8_epi32/// the result in dst using writemask k (elements are copied from src if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extracti32x8_epi32&ig_expand=2966)_mm512_maskz_extracti32x8_epi32/// the result in dst using zeromask k (elements are zeroed out if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extracti32x8_epi32&ig_expand=2967)_mm256_extracti64x2_epi64/// Extracts 128 bits (composed of 2 packed 64-bit integers) from a, selected with IMM8, and stores/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extracti64x2_epi64&ig_expand=2968)_mm256_mask_extracti64x2_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_extracti64x2_epi64&ig_expand=2969)_mm256_maskz_extracti64x2_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_extracti64x2_epi64&ig_expand=2970)_mm512_extracti64x2_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extracti64x2_epi64&ig_expand=2971)_mm512_mask_extracti64x2_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extracti64x2_epi64&ig_expand=2972)_mm512_maskz_extracti64x2_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extracti64x2_epi64&ig_expand=2973)_mm512_insertf32x8/// Copy a to dst, then insert 256 bits (composed of 8 packed single-precision (32-bit) floating-point/// elements) from b into dst at the location specified by IMM8./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_insertf32x8&ig_expand=3850)_mm512_mask_insertf32x8/// Copy a to tmp, then insert 256 bits (composed of 8 packed single-precision (32-bit) floating-point/// elements) from b into tmp at the location specified by IMM8, and copy tmp to dst using writemask k/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_insertf32x8&ig_expand=3851)_mm512_maskz_insertf32x8/// elements) from b into tmp at the location specified by IMM8, and copy tmp to dst using zeromask k/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_insertf32x8&ig_expand=3852)_mm256_insertf64x2/// Copy a to dst, then insert 128 bits (composed of 2 packed double-precision (64-bit) floating-point/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insertf64x2&ig_expand=3853)_mm256_mask_insertf64x2/// Copy a to tmp, then insert 128 bits (composed of 2 packed double-precision (64-bit) floating-point/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_insertf64x2&ig_expand=3854)_mm256_maskz_insertf64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_insertf64x2&ig_expand=3855)_mm512_insertf64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_insertf64x2&ig_expand=3856)_mm512_mask_insertf64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_insertf64x2&ig_expand=3857)_mm512_maskz_insertf64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_insertf64x2&ig_expand=3858)_mm512_inserti32x8/// Copy a to dst, then insert 256 bits (composed of 8 packed 32-bit integers) from b into dst at the/// location specified by IMM8./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_inserti32x8&ig_expand=3869)_mm512_mask_inserti32x8/// Copy a to tmp, then insert 256 bits (composed of 8 packed 32-bit integers) from b into tmp at the/// location specified by IMM8, and copy tmp to dst using writemask k (elements are copied from src if/// the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_inserti32x8&ig_expand=3870)_mm512_maskz_inserti32x8/// location specified by IMM8, and copy tmp to dst using zeromask k (elements are zeroed out if the/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_inserti32x8&ig_expand=3871)_mm256_inserti64x2/// Copy a to dst, then insert 128 bits (composed of 2 packed 64-bit integers) from b into dst at the/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_inserti64x2&ig_expand=3872)_mm256_mask_inserti64x2/// Copy a to tmp, then insert 128 bits (composed of 2 packed 64-bit integers) from b into tmp at the/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_inserti64x2&ig_expand=3873)_mm256_maskz_inserti64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_inserti64x2&ig_expand=3874)_mm512_inserti64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_inserti64x2&ig_expand=3875)_mm512_mask_inserti64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_inserti64x2&ig_expand=3876)_mm512_maskz_inserti64x2/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_inserti64x2&ig_expand=3877)_mm512_cvt_roundepi64_pd/// Convert packed signed 64-bit integers in a to packed double-precision (64-bit) floating-point elements,/// and store the results in dst. Rounding is done according to the ROUNDING parameter, which can be one of:/// * [`_MM_FROUND_TO_NEAREST_INT`] | [`_MM_FROUND_NO_EXC`] : round to nearest and suppress exceptions/// * [`_MM_FROUND_TO_NEG_INF`] | [`_MM_FROUND_NO_EXC`] : round down and suppress exceptions/// * [`_MM_FROUND_TO_POS_INF`] | [`_MM_FROUND_NO_EXC`] : round up and suppress exceptions/// * [`_MM_FROUND_TO_ZERO`] | [`_MM_FROUND_NO_EXC`] : truncate and suppress exceptions/// * [`_MM_FROUND_CUR_DIRECTION`] : use `MXCSR.RC` - see [`_MM_SET_ROUNDING_MODE`]/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundepi64_pd&ig_expand=1437)_mm512_mask_cvt_roundepi64_pd/// and store the results in dst using writemask k (elements are copied from src if the corresponding bit is/// not set). Rounding is done according to the ROUNDING parameter, which can be one of:/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundepi64_pd&ig_expand=1438)_mm512_maskz_cvt_roundepi64_pd/// and store the results in dst using zeromask k (elements are zeroed out if the corresponding bit is not set)./// Rounding is done according to the ROUNDING parameter, which can be one of:/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundepi64_pd&ig_expand=1439)_mm_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi64_pd&ig_expand=1705)_mm_mask_cvtepi64_pd/// not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi64_pd&ig_expand=1706)_mm_maskz_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi64_pd&ig_expand=1707)_mm256_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi64_pd&ig_expand=1708)_mm256_mask_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi64_pd&ig_expand=1709)_mm256_maskz_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi64_pd&ig_expand=1710)_mm512_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi64_pd&ig_expand=1711)_mm512_mask_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi64_pd&ig_expand=1712)_mm512_maskz_cvtepi64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi64_pd&ig_expand=1713)_mm512_cvt_roundepi64_ps/// Convert packed signed 64-bit integers in a to packed single-precision (32-bit) floating-point elements,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundepi64_ps&ig_expand=1443)_mm512_mask_cvt_roundepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundepi64_ps&ig_expand=1444)_mm512_maskz_cvt_roundepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundepi64_ps&ig_expand=1445)_mm_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi64_ps&ig_expand=1723)_mm_mask_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi64_ps&ig_expand=1724)_mm_maskz_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi64_ps&ig_expand=1725)_mm256_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi64_ps&ig_expand=1726)_mm256_mask_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi64_ps&ig_expand=1727)_mm256_maskz_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi64_ps&ig_expand=1728)_mm512_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi64_ps&ig_expand=1729)_mm512_mask_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi64_ps&ig_expand=1730)_mm512_maskz_cvtepi64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi64_ps&ig_expand=1731)_mm512_cvt_roundepu64_pd/// Convert packed unsigned 64-bit integers in a to packed double-precision (64-bit) floating-point elements,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundepu64_pd&ig_expand=1455)_mm512_mask_cvt_roundepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundepu64_pd&ig_expand=1456)_mm512_maskz_cvt_roundepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundepu64_pd&ig_expand=1457)_mm_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu64_pd&ig_expand=1827)_mm_mask_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu64_pd&ig_expand=1828)_mm_maskz_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu64_pd&ig_expand=1829)_mm256_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu64_pd&ig_expand=1830)_mm256_mask_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu64_pd&ig_expand=1831)_mm256_maskz_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu64_pd&ig_expand=1832)_mm512_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu64_pd&ig_expand=1833)_mm512_mask_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu64_pd&ig_expand=1834)_mm512_maskz_cvtepu64_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu64_pd&ig_expand=1835)_mm512_cvt_roundepu64_ps/// Convert packed unsigned 64-bit integers in a to packed single-precision (32-bit) floating-point elements,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundepu64_ps&ig_expand=1461)_mm512_mask_cvt_roundepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundepu64_ps&ig_expand=1462)_mm512_maskz_cvt_roundepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundepu64_ps&ig_expand=1463)_mm_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu64_ps&ig_expand=1845)_mm_mask_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu64_ps&ig_expand=1846)_mm_maskz_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu64_ps&ig_expand=1847)_mm256_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu64_ps&ig_expand=1848)_mm256_mask_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu64_ps&ig_expand=1849)_mm256_maskz_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu64_ps&ig_expand=1850)_mm512_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu64_ps&ig_expand=1851)_mm512_mask_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu64_ps&ig_expand=1852)_mm512_maskz_cvtepu64_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu64_ps&ig_expand=1853)_mm512_cvt_roundpd_epi64/// Convert packed double-precision (64-bit) floating-point elements in a to packed signed 64-bit integers,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundpd_epi64&ig_expand=1472)_mm512_mask_cvt_roundpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundpd_epi64&ig_expand=1473)_mm512_maskz_cvt_roundpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundpd_epi64&ig_expand=1474)_mm_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpd_epi64&ig_expand=1941)_mm_mask_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtpd_epi64&ig_expand=1942)_mm_maskz_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtpd_epi64&ig_expand=1943)_mm256_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtpd_epi64&ig_expand=1944)_mm256_mask_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtpd_epi64&ig_expand=1945)_mm256_maskz_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtpd_epi64&ig_expand=1946)_mm512_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpd_epi64&ig_expand=1947)_mm512_mask_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpd_epi64&ig_expand=1948)_mm512_maskz_cvtpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtpd_epi64&ig_expand=1949)_mm512_cvt_roundps_epi64/// Convert packed single-precision (32-bit) floating-point elements in a to packed signed 64-bit integers,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundps_epi64&ig_expand=1514)_mm512_mask_cvt_roundps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundps_epi64&ig_expand=1515)_mm512_maskz_cvt_roundps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundps_epi64&ig_expand=1516)_mm_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_epi64&ig_expand=2075)_mm_mask_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtps_epi64&ig_expand=2076)_mm_maskz_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtps_epi64&ig_expand=2077)_mm256_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtps_epi64&ig_expand=2078)_mm256_mask_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtps_epi64&ig_expand=2079)_mm256_maskz_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtps_epi64&ig_expand=2080)_mm512_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtps_epi64&ig_expand=2081)_mm512_mask_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtps_epi64&ig_expand=2082)_mm512_maskz_cvtps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtps_epi64&ig_expand=2083)_mm512_cvt_roundpd_epu64/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 64-bit integers,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundpd_epu64&ig_expand=1478)_mm512_mask_cvt_roundpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundpd_epu64&ig_expand=1479)_mm512_maskz_cvt_roundpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundpd_epu64&ig_expand=1480)_mm_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpd_epu64&ig_expand=1959)_mm_mask_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtpd_epu64&ig_expand=1960)_mm_maskz_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtpd_epu64&ig_expand=1961)_mm256_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtpd_epu64&ig_expand=1962)_mm256_mask_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtpd_epu64&ig_expand=1963)_mm256_maskz_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtpd_epu64&ig_expand=1964)_mm512_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpd_epu64&ig_expand=1965)_mm512_mask_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpd_epu64&ig_expand=1966)_mm512_maskz_cvtpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtpd_epu64&ig_expand=1967)_mm512_cvt_roundps_epu64/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 64-bit integers,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundps_epu64&ig_expand=1520)_mm512_mask_cvt_roundps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundps_epu64&ig_expand=1521)_mm512_maskz_cvt_roundps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundps_epu64&ig_expand=1522)_mm_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_epu64&ig_expand=2093)_mm_mask_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtps_epu64&ig_expand=2094)_mm_maskz_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtps_epu64&ig_expand=2095)_mm256_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtps_epu64&ig_expand=2096)_mm256_mask_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtps_epu64&ig_expand=2097)_mm256_maskz_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtps_epu64&ig_expand=2098)_mm512_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtps_epu64&ig_expand=2099)_mm512_mask_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtps_epu64&ig_expand=2100)_mm512_maskz_cvtps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtps_epu64&ig_expand=2101)SAE_mm512_cvtt_roundpd_epi64/// Convert packed double-precision (64-bit) floating-point elements in a to packed signed 64-bit integers/// with truncation, and store the result in dst. Exceptions can be suppressed by passing _MM_FROUND_NO_EXC/// to the sae parameter./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundpd_epi64&ig_expand=2264)_mm512_mask_cvtt_roundpd_epi64/// with truncation, and store the result in dst using writemask k (elements are copied from src if the/// corresponding bit is not set). Exceptions can be suppressed by passing _MM_FROUND_NO_EXC to the sae parameter./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundpd_epi64&ig_expand=2265)_mm512_maskz_cvtt_roundpd_epi64/// with truncation, and store the result in dst using zeromask k (elements are zeroed out if the corresponding/// bit is not set). Exceptions can be suppressed by passing _MM_FROUND_NO_EXC to the sae parameter./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundpd_epi64&ig_expand=2266)_mm_cvttpd_epi64/// with truncation, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttpd_epi64&ig_expand=2329)_mm_mask_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttpd_epi64&ig_expand=2330)_mm_maskz_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttpd_epi64&ig_expand=2331)_mm256_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttpd_epi64&ig_expand=2332)_mm256_mask_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttpd_epi64&ig_expand=2333)_mm256_maskz_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttpd_epi64&ig_expand=2334)_mm512_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttpd_epi64&ig_expand=2335)_mm512_mask_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttpd_epi64&ig_expand=2336)_mm512_maskz_cvttpd_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttpd_epi64&ig_expand=2337)_mm512_cvtt_roundps_epi64/// Convert packed single-precision (32-bit) floating-point elements in a to packed signed 64-bit integers/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundps_epi64&ig_expand=2294)_mm512_mask_cvtt_roundps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundps_epi64&ig_expand=2295)_mm512_maskz_cvtt_roundps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundps_epi64&ig_expand=2296)_mm_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttps_epi64&ig_expand=2420)_mm_mask_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttps_epi64&ig_expand=2421)_mm_maskz_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttps_epi64&ig_expand=2422)_mm256_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttps_epi64&ig_expand=2423)_mm256_mask_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttps_epi64&ig_expand=2424)_mm256_maskz_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttps_epi64&ig_expand=2425)_mm512_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttps_epi64&ig_expand=2426)_mm512_mask_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttps_epi64&ig_expand=2427)_mm512_maskz_cvttps_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttps_epi64&ig_expand=2428)_mm512_cvtt_roundpd_epu64/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 64-bit integers/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundpd_epu64&ig_expand=1965)_mm512_mask_cvtt_roundpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundpd_epu64&ig_expand=1966)_mm512_maskz_cvtt_roundpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundpd_epu64&ig_expand=1967)_mm_cvttpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttpd_epu64&ig_expand=2347)_mm_mask_cvttpd_epu64/// with truncation, and store the result in dst using writemask k (elements are copied from src if the corresponding/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttpd_epu64&ig_expand=2348)_mm_maskz_cvttpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttpd_epu64&ig_expand=2349)_mm256_cvttpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttpd_epu64&ig_expand=2350)_mm256_mask_cvttpd_epu64/// with truncation, and store the results in dst using writemask k (elements are copied from src if the corresponding/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttpd_epu64&ig_expand=2351)_mm256_maskz_cvttpd_epu64/// with truncation, and store the results in dst using zeromask k (elements are zeroed out if the corresponding/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttpd_epu64&ig_expand=2352)_mm512_cvttpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttpd_epu64&ig_expand=2353)_mm512_mask_cvttpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttpd_epu64&ig_expand=2354)_mm512_maskz_cvttpd_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttpd_epu64&ig_expand=2355)_mm512_cvtt_roundps_epu64/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 64-bit integers/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundps_epu64&ig_expand=2300)_mm512_mask_cvtt_roundps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundps_epu64&ig_expand=2301)_mm512_maskz_cvtt_roundps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundps_epu64&ig_expand=2302)_mm_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttps_epu64&ig_expand=2438)_mm_mask_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttps_epu64&ig_expand=2439)_mm_maskz_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttps_epu64&ig_expand=2440)_mm256_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttps_epu64&ig_expand=2441)_mm256_mask_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttps_epu64&ig_expand=2442)_mm256_maskz_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttps_epu64&ig_expand=2443)_mm512_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttps_epu64&ig_expand=2444)_mm512_mask_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttps_epu64&ig_expand=2445)_mm512_maskz_cvttps_epu64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttps_epu64&ig_expand=2446)_mm_mullo_epi64/// Multiply packed 64-bit integers in `a` and `b`, producing intermediate 128-bit integers, and store/// the low 64 bits of the intermediate integers in `dst`./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mullo_epi64&ig_expand=4778)_mm_mask_mullo_epi64/// the low 64 bits of the intermediate integers in `dst` using writemask `k` (elements are copied from/// `src` if the corresponding bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mullo_epi64&ig_expand=4776)_mm_maskz_mullo_epi64/// the low 64 bits of the intermediate integers in `dst` using zeromask `k` (elements are zeroed out if/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mullo_epi64&ig_expand=4777)_mm256_mullo_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mullo_epi64&ig_expand=4781)_mm256_mask_mullo_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mullo_epi64&ig_expand=4779)_mm256_maskz_mullo_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mullo_epi64&ig_expand=4780)_mm512_mullo_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mullo_epi64&ig_expand=4784)_mm512_mask_mullo_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mullo_epi64&ig_expand=4782)_mm512_maskz_mullo_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mullo_epi64&ig_expand=4783)_cvtmask8_u32/// Convert 8-bit mask a to a 32-bit integer value and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_cvtmask8_u32&ig_expand=1891)_cvtu32_mask8/// Convert 32-bit integer value a to an 8-bit mask and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_cvtu32_mask8&ig_expand=2467)_kadd_mask16/// Add 16-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kadd_mask16&ig_expand=3903)_kadd_mask8/// Add 8-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kadd_mask8&ig_expand=3906)_kand_mask8/// Bitwise AND of 8-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kand_mask8&ig_expand=3911)_kandn_mask8/// Bitwise AND NOT of 8-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kandn_mask8&ig_expand=3916)_knot_mask8/// Bitwise NOT of 8-bit mask a, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_knot_mask8&ig_expand=3922)_kor_mask8/// Bitwise OR of 8-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kor_mask8&ig_expand=3927)_kxnor_mask8/// Bitwise XNOR of 8-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kxnor_mask8&ig_expand=3969)_kxor_mask8/// Bitwise XOR of 8-bit masks a and b, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kxor_mask8&ig_expand=3974)_kortest_mask8_u8/// Compute the bitwise OR of 8-bit masks a and b. If the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortest_mask8_u8&ig_expand=3931)_kortestc_mask8_u8/// Compute the bitwise OR of 8-bit masks a and b. If the result is all ones, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestc_mask8_u8&ig_expand=3936)_kortestz_mask8_u8/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestz_mask8_u8&ig_expand=3941)_kshiftli_mask8/// Shift 8-bit mask a left by count bits while shifting in zeros, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftli_mask8&ig_expand=3945)_kshiftri_mask8/// Shift 8-bit mask a right by count bits while shifting in zeros, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftri_mask8&ig_expand=3949)_ktest_mask16_u8/// Compute the bitwise AND of 16-bit masks a and b, and if the result is all zeros, store 1 in dst,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktest_mask16_u8&ig_expand=3950)_ktest_mask8_u8/// Compute the bitwise AND of 8-bit masks a and b, and if the result is all zeros, store 1 in dst,/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktest_mask8_u8&ig_expand=3953)_ktestc_mask16_u8/// Compute the bitwise NOT of 16-bit mask a and then AND with 16-bit mask b, if the result is all/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestc_mask16_u8&ig_expand=3954)_ktestc_mask8_u8/// Compute the bitwise NOT of 8-bit mask a and then AND with 8-bit mask b, if the result is all/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestc_mask8_u8&ig_expand=3957)_ktestz_mask16_u8/// Compute the bitwise AND of 16-bit masks a and  b, if the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestz_mask16_u8&ig_expand=3958)_ktestz_mask8_u8/// Compute the bitwise AND of 8-bit masks a and  b, if the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_ktestz_mask8_u8&ig_expand=3961)_load_mask8/// Load 8-bit mask from memory/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_load_mask8&ig_expand=3999)_store_mask8/// Store 8-bit mask to memory/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_store_mask8&ig_expand=6468)_mm_movepi32_mask/// Set each bit of mask register k based on the most significant bit of the corresponding packed 32-bit/// integer in a./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movepi32_mask&ig_expand=4612)_mm256_movepi32_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movepi32_mask&ig_expand=4613)_mm512_movepi32_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movepi32_mask&ig_expand=4614)_mm_movepi64_mask/// Set each bit of mask register k based on the most significant bit of the corresponding packed 64-bit/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movepi64_mask&ig_expand=4615)_mm256_movepi64_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movepi64_mask&ig_expand=4616)_mm512_movepi64_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movepi64_mask&ig_expand=4617)_mm_movm_epi32/// Set each packed 32-bit integer in dst to all ones or all zeros based on the value of the corresponding/// bit in k./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movm_epi32&ig_expand=4625)_mm256_movm_epi32/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movm_epi32&ig_expand=4626)_mm512_movm_epi32/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movm_epi32&ig_expand=4627)_mm_movm_epi64/// Set each packed 64-bit integer in dst to all ones or all zeros based on the value of the corresponding/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movm_epi64&ig_expand=4628)_mm256_movm_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_movm_epi64&ig_expand=4629)_mm512_movm_epi64/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movm_epi64&ig_expand=4630)_mm512_range_round_pd/// Calculate the max, min, absolute max, or absolute min (depending on control in imm8) for packed/// double-precision (64-bit) floating-point elements in a and b, and store the results in dst./// Lower 2 bits of IMM8 specifies the operation control:///     00 = min, 01 = max, 10 = absolute min, 11 = absolute max./// Upper 2 bits of IMM8 specifies the sign control:///     00 = sign from a, 01 = sign from compare result, 10 = clear sign bit, 11 = set sign bit./// Exceptions can be suppressed by passing _MM_FROUND_NO_EXC in the sae parameter./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_range_round_pd&ig_expand=5210)_mm512_mask_range_round_pd/// double-precision (64-bit) floating-point elements in a and b, and store the results in dst using/// writemask k (elements are copied from src to dst if the corresponding mask bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_range_round_pd&ig_expand=5208)_mm512_maskz_range_round_pd/// zeromask k (elements are zeroed out if the corresponding mask bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_range_round_pd&ig_expand=5209)_mm_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_range_pd&ig_expand=5192)_mm_mask_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_range_pd&ig_expand=5190)_mm_maskz_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_range_pd&ig_expand=5191)_mm256_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_range_pd&ig_expand=5195)_mm256_mask_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_range_pd&ig_expand=5193)_mm256_maskz_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_range_pd&ig_expand=5194)_mm512_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_range_pd&ig_expand=5198)_mm512_mask_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_range_pd&ig_expand=5196)_mm512_maskz_range_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_range_pd&ig_expand=5197)_mm512_range_round_ps/// single-precision (32-bit) floating-point elements in a and b, and store the results in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_range_round_ps&ig_expand=5213)_mm512_mask_range_round_ps/// single-precision (32-bit) floating-point elements in a and b, and store the results in dst using/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_range_round_ps&ig_expand=5211)_mm512_maskz_range_round_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_range_round_ps&ig_expand=5212)_mm_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_range_ps&ig_expand=5201)_mm_mask_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_range_ps&ig_expand=5199)_mm_maskz_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_range_ps&ig_expand=5200)_mm256_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_range_ps&ig_expand=5204)_mm256_mask_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_range_ps&ig_expand=5202)_mm256_maskz_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_range_ps&ig_expand=5203)_mm512_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_range_ps&ig_expand=5207)_mm512_mask_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_range_ps&ig_expand=5205)_mm512_maskz_range_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_range_ps&ig_expand=5206)_mm_range_round_sd/// Calculate the max, min, absolute max, or absolute min (depending on control in imm8) for the lower/// double-precision (64-bit) floating-point element in a and b, store the result in the lower element/// of dst, and copy the upper element from a to the upper element of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_range_round_sd&ig_expand=5216)_mm_mask_range_round_sd/// of dst using writemask k (the element is copied from src when mask bit 0 is not set), and copy the/// upper element from a to the upper element of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_range_round_sd&ig_expand=5214)_mm_maskz_range_round_sd/// of dst using zeromask k (the element is zeroed out when mask bit 0 is not set), and copy the upper/// element from a to the upper element of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_range_round_sd&ig_expand=5215)_mm_mask_range_sd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_range_sd&ig_expand=5220)_mm_maskz_range_sd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_range_sd&ig_expand=5221)_mm_range_round_ss/// single-precision (32-bit) floating-point element in a and b, store the result in the lower element/// of dst, and copy the upper 3 packed elements from a to the upper elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_range_round_ss&ig_expand=5219)_mm_mask_range_round_ss/// upper 3 packed elements from a to the upper elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_range_round_ss&ig_expand=5217)_mm_maskz_range_round_ss/// 3 packed elements from a to the upper elements of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_range_round_ss&ig_expand=5218)_mm_mask_range_ss/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_range_ss&ig_expand=5222)_mm_maskz_range_ss/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_range_ss&ig_expand=5223)_mm512_reduce_round_pd/// Extract the reduced argument of packed double-precision (64-bit) floating-point elements in a by/// the number of bits specified by imm8, and store the results in dst./// Rounding is done according to the imm8 parameter, which can be one of:/// * [`_MM_FROUND_TO_NEAREST_INT`] : round to nearest/// * [`_MM_FROUND_TO_NEG_INF`] : round down/// * [`_MM_FROUND_TO_POS_INF`] : round up/// * [`_MM_FROUND_TO_ZERO`] : truncate/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_reduce_round_pd&ig_expand=5438)_mm512_mask_reduce_round_pd/// the number of bits specified by imm8, and store the results in dst using writemask k (elements are/// copied from src to dst if the corresponding mask bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_reduce_round_pd&ig_expand=5436)_mm512_maskz_reduce_round_pd/// the number of bits specified by imm8, and store the results in dst using zeromask k (elements are/// zeroed out if the corresponding mask bit is not set)./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_reduce_round_pd&ig_expand=5437)_mm_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_pd&ig_expand=5411)_mm_mask_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_pd&ig_expand=5409)_mm_maskz_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_reduce_pd&ig_expand=5410)_mm256_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_pd&ig_expand=5414)_mm256_mask_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_pd&ig_expand=5412)_mm256_maskz_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_reduce_pd&ig_expand=5413)_mm512_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_reduce_pd&ig_expand=5417)_mm512_mask_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_reduce_pd&ig_expand=5415)_mm512_maskz_reduce_pd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_reduce_pd&ig_expand=5416)_mm512_reduce_round_ps/// Extract the reduced argument of packed single-precision (32-bit) floating-point elements in a by/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_reduce_round_ps&ig_expand=5444)_mm512_mask_reduce_round_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_reduce_round_ps&ig_expand=5442)_mm512_maskz_reduce_round_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_reduce_round_ps&ig_expand=5443)_mm_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_ps&ig_expand=5429)_mm_mask_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_ps&ig_expand=5427)_mm_maskz_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_reduce_ps&ig_expand=5428)_mm256_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_reduce_ps&ig_expand=5432)_mm256_mask_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_reduce_ps&ig_expand=5430)_mm256_maskz_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_reduce_ps&ig_expand=5431)_mm512_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_reduce_ps&ig_expand=5435)_mm512_mask_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_reduce_ps&ig_expand=5433)_mm512_maskz_reduce_ps/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_reduce_ps&ig_expand=5434)_mm_reduce_round_sd/// Extract the reduced argument of the lower double-precision (64-bit) floating-point element in b/// by the number of bits specified by imm8, store the result in the lower element of dst, and copy/// the upper element from a to the upper element of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_round_sd&ig_expand=5447)_mm_mask_reduce_round_sd/// by the number of bits specified by imm8, store the result in the lower element of dst using writemask/// k (the element is copied from src when mask bit 0 is not set), and copy the upper element from a/// to the upper element of dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_round_sd&ig_expand=5445)_mm_maskz_reduce_round_sd/// by the number of bits specified by imm8, store the result in the lower element of dst using zeromask/// k (the element is zeroed out when mask bit 0 is not set), and copy the upper element from a/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_reduce_round_sd&ig_expand=5446)_mm_reduce_sd/// by the number of bits specified by imm8, store the result in the lower element of dst using, and/// copy the upper element from a./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_sd&ig_expand=5456)_mm_mask_reduce_sd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_sd&ig_expand=5454)_mm_maskz_reduce_sd/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_reduce_sd&ig_expand=5455)_mm_reduce_round_ss/// Extract the reduced argument of the lower single-precision (32-bit) floating-point element in b/// the upper element from a./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_round_ss&ig_expand=5453)_mm_mask_reduce_round_ss/// k (the element is copied from src when mask bit 0 is not set), and copy the upper element from a./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_round_ss&ig_expand=5451)_mm_maskz_reduce_round_ss/// k (the element is zeroed out when mask bit 0 is not set), and copy the upper element from a./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_reduce_round_ss&ig_expand=5452)_mm_reduce_ss/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_reduce_ss&ig_expand=5462)_mm_mask_reduce_ss/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_reduce_ss&ig_expand=5460)_mm_maskz_reduce_ss/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_reduce_ss&ig_expand=5461)_mm_fpclass_pd_mask/// Test packed double-precision (64-bit) floating-point elements in a for special categories specified/// by imm8, and store the results in mask vector k./// imm can be a combination of:///     - 0x01 // QNaN///     - 0x02 // Positive Zero///     - 0x04 // Negative Zero///     - 0x08 // Positive Infinity///     - 0x10 // Negative Infinity///     - 0x20 // Denormal///     - 0x40 // Negative///     - 0x80 // SNaN/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_fpclass_pd_mask&ig_expand=3493)_mm_mask_fpclass_pd_mask/// by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fpclass_pd_mask&ig_expand=3494)_mm256_fpclass_pd_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_fpclass_pd_mask&ig_expand=3495)_mm256_mask_fpclass_pd_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fpclass_pd_mask&ig_expand=3496)_mm512_fpclass_pd_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fpclass_pd_mask&ig_expand=3497)_mm512_mask_fpclass_pd_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fpclass_pd_mask&ig_expand=3498)_mm_fpclass_ps_mask/// Test packed single-precision (32-bit) floating-point elements in a for special categories specified/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_fpclass_ps_mask&ig_expand=3505)_mm_mask_fpclass_ps_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fpclass_ps_mask&ig_expand=3506)_mm256_fpclass_ps_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_fpclass_ps_mask&ig_expand=3507)_mm256_mask_fpclass_ps_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fpclass_ps_mask&ig_expand=3508)_mm512_fpclass_ps_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fpclass_ps_mask&ig_expand=3509)_mm512_mask_fpclass_ps_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fpclass_ps_mask&ig_expand=3510)_mm_fpclass_sd_mask/// Test the lower double-precision (64-bit) floating-point element in a for special categories specified/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_fpclass_sd_mask&ig_expand=3511)_mm_mask_fpclass_sd_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fpclass_sd_mask&ig_expand=3512)_mm_fpclass_ss_mask/// Test the lower single-precision (32-bit) floating-point element in a for special categories specified/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_fpclass_ss_mask&ig_expand=3515)_mm_mask_fpclass_ss_mask/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fpclass_ss_mask&ig_expand=3516)"llvm.x86.avx512.sitofp.round.v2f64.v2i64"vcvtqq2pd_128"llvm.x86.avx512.sitofp.round.v4f64.v4i64"vcvtqq2pd_256"llvm.x86.avx512.sitofp.round.v8f64.v8i64"vcvtqq2pd_512"llvm.x86.avx512.mask.cvtqq2ps.128"vcvtqq2ps_128"llvm.x86.avx512.sitofp.round.v4f32.v4i64"vcvtqq2ps_256"llvm.x86.avx512.sitofp.round.v8f32.v8i64"vcvtqq2ps_512"llvm.x86.avx512.uitofp.round.v2f64.v2i64"vcvtuqq2pd_128"llvm.x86.avx512.uitofp.round.v4f64.v4i64"vcvtuqq2pd_256"llvm.x86.avx512.uitofp.round.v8f64.v8i64"vcvtuqq2pd_512"llvm.x86.avx512.mask.cvtuqq2ps.128"vcvtuqq2ps_128"llvm.x86.avx512.uitofp.round.v4f32.v4i64"vcvtuqq2ps_256"llvm.x86.avx512.uitofp.round.v8f32.v8i64"vcvtuqq2ps_512"llvm.x86.avx512.mask.cvtpd2qq.128"vcvtpd2qq_128"llvm.x86.avx512.mask.cvtpd2qq.256"vcvtpd2qq_256"llvm.x86.avx512.mask.cvtpd2qq.512"vcvtpd2qq_512"llvm.x86.avx512.mask.cvtps2qq.128"vcvtps2qq_128"llvm.x86.avx512.mask.cvtps2qq.256"vcvtps2qq_256"llvm.x86.avx512.mask.cvtps2qq.512"vcvtps2qq_512"llvm.x86.avx512.mask.cvtpd2uqq.128"vcvtpd2uqq_128"llvm.x86.avx512.mask.cvtpd2uqq.256"vcvtpd2uqq_256"llvm.x86.avx512.mask.cvtpd2uqq.512"vcvtpd2uqq_512"llvm.x86.avx512.mask.cvtps2uqq.128"vcvtps2uqq_128"llvm.x86.avx512.mask.cvtps2uqq.256"vcvtps2uqq_256"llvm.x86.avx512.mask.cvtps2uqq.512"vcvtps2uqq_512"llvm.x86.avx512.mask.cvttpd2qq.128"vcvttpd2qq_128"llvm.x86.avx512.mask.cvttpd2qq.256"vcvttpd2qq_256"llvm.x86.avx512.mask.cvttpd2qq.512"vcvttpd2qq_512"llvm.x86.avx512.mask.cvttps2qq.128"vcvttps2qq_128"llvm.x86.avx512.mask.cvttps2qq.256"vcvttps2qq_256"llvm.x86.avx512.mask.cvttps2qq.512"vcvttps2qq_512"llvm.x86.avx512.mask.cvttpd2uqq.128"vcvttpd2uqq_128"llvm.x86.avx512.mask.cvttpd2uqq.256"vcvttpd2uqq_256"llvm.x86.avx512.mask.cvttpd2uqq.512"vcvttpd2uqq_512"llvm.x86.avx512.mask.cvttps2uqq.128"vcvttps2uqq_128"llvm.x86.avx512.mask.cvttps2uqq.256"vcvttps2uqq_256"llvm.x86.avx512.mask.cvttps2uqq.512"vcvttps2uqq_512"llvm.x86.avx512.mask.range.pd.128"vrangepd_128"llvm.x86.avx512.mask.range.pd.256"vrangepd_256"llvm.x86.avx512.mask.range.pd.512"vrangepd_512"llvm.x86.avx512.mask.range.ps.128"vrangeps_128"llvm.x86.avx512.mask.range.ps.256"vrangeps_256"llvm.x86.avx512.mask.range.ps.512"vrangeps_512"llvm.x86.avx512.mask.range.sd"vrangesd"llvm.x86.avx512.mask.range.ss"vrangess"llvm.x86.avx512.mask.reduce.pd.128"vreducepd_128"llvm.x86.avx512.mask.reduce.pd.256"vreducepd_256"llvm.x86.avx512.mask.reduce.pd.512"vreducepd_512"llvm.x86.avx512.mask.reduce.ps.128"vreduceps_128"llvm.x86.avx512.mask.reduce.ps.256"vreduceps_256"llvm.x86.avx512.mask.reduce.ps.512"vreduceps_512"llvm.x86.avx512.mask.reduce.sd"vreducesd"llvm.x86.avx512.mask.reduce.ss"vreducess"llvm.x86.avx512.mask.fpclass.pd.128"vfpclasspd_128"llvm.x86.avx512.mask.fpclass.pd.256"vfpclasspd_256"llvm.x86.avx512.mask.fpclass.pd.512"vfpclasspd_512"llvm.x86.avx512.mask.fpclass.ps.128"vfpclassps_128"llvm.x86.avx512.mask.fpclass.ps.256"vfpclassps_256"llvm.x86.avx512.mask.fpclass.ps.512"vfpclassps_512"llvm.x86.avx512.mask.fpclass.sd"vfpclasssd"llvm.x86.avx512.mask.fpclass.ss"vfpclassss// And //// Andnot// Or// Xor// Broadcast// Extract// Insert// Convert// Multiply-Low// Mask Registers// Range// Reduce// FP-Class_mm512_abs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_abs_epi32&expand=39)_mm512_mask_abs_epi32/// Computes the absolute value of packed 32-bit integers in `a`, and store the/// unsigned results in `dst` using writemask `k` (elements are copied from/// `src` when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_abs_epi32&expand=40)_mm512_maskz_abs_epi32/// unsigned results in `dst` using zeromask `k` (elements are zeroed out when/// the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_abs_epi32&expand=41)_mm256_mask_abs_epi32/// Compute the absolute value of packed signed 32-bit integers in a, and store the unsigned results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_abs_epi32&expand=37)_mm256_maskz_abs_epi32/// Compute the absolute value of packed signed 32-bit integers in a, and store the unsigned results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_abs_epi32&expand=38)_mm_mask_abs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_abs_epi32&expand=34)_mm_maskz_abs_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_abs_epi32&expand=35)_mm512_abs_epi64/// Compute the absolute value of packed signed 64-bit integers in a, and store the unsigned results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_abs_epi64&expand=48)_mm512_mask_abs_epi64/// Compute the absolute value of packed signed 64-bit integers in a, and store the unsigned results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_abs_epi64&expand=49)_mm512_maskz_abs_epi64/// Compute the absolute value of packed signed 64-bit integers in a, and store the unsigned results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_abs_epi64&expand=50)_mm256_abs_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_abs_epi64&expand=45)_mm256_mask_abs_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_abs_epi64&expand=46)_mm256_maskz_abs_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_abs_epi64)_mm_abs_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_epi64)_mm_mask_abs_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_abs_epi64)_mm_maskz_abs_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_abs_epi64)_mm512_abs_ps/// Finds the absolute value of each packed single-precision (32-bit) floating-point element in v2, storing the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_abs_ps&expand=65)_mm512_mask_abs_ps/// Finds the absolute value of each packed single-precision (32-bit) floating-point element in v2, storing the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_abs_ps&expand=66)_mm512_abs_pd/// Finds the absolute value of each packed double-precision (64-bit) floating-point element in v2, storing the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_abs_pd&expand=60)_mm512_mask_abs_pd/// Finds the absolute value of each packed double-precision (64-bit) floating-point element in v2, storing the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_abs_pd&expand=61)_mm512_mask_mov_epi32/// Move packed 32-bit integers from a to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mov_epi32&expand=3801)_mm512_maskz_mov_epi32/// Move packed 32-bit integers from a into dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mov_epi32&expand=3802)_mm256_mask_mov_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mov_epi32&expand=3799)_mm256_maskz_mov_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mov_epi32&expand=3800)_mm_mask_mov_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mov_epi32&expand=3797)_mm_maskz_mov_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mov_epi32&expand=3798)_mm512_mask_mov_epi64/// Move packed 64-bit integers from a to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mov_epi64&expand=3807)_mm512_maskz_mov_epi64/// Move packed 64-bit integers from a into dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mov_epi64&expand=3808)_mm256_mask_mov_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mov_epi64&expand=3805)_mm256_maskz_mov_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mov_epi64&expand=3806)_mm_mask_mov_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mov_epi64&expand=3803)_mm_maskz_mov_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mov_epi64&expand=3804)_mm512_mask_mov_ps/// Move packed single-precision (32-bit) floating-point elements from a to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mov_ps&expand=3825)_mm512_maskz_mov_ps/// Move packed single-precision (32-bit) floating-point elements from a into dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mov_ps&expand=3826)_mm256_mask_mov_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mov_ps&expand=3823)_mm256_maskz_mov_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mov_ps&expand=3824)_mm_mask_mov_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mov_ps&expand=3821)_mm_maskz_mov_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mov_ps&expand=3822)_mm512_mask_mov_pd/// Move packed double-precision (64-bit) floating-point elements from a to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mov_pd&expand=3819)_mm512_maskz_mov_pd/// Move packed double-precision (64-bit) floating-point elements from a into dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mov_pd&expand=3820)_mm256_mask_mov_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mov_pd&expand=3817)_mm256_maskz_mov_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mov_pd&expand=3818)_mm_mask_mov_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mov_pd&expand=3815)_mm_maskz_mov_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mov_pd&expand=3816)_mm512_add_epi32/// Add packed 32-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_epi32&expand=100)_mm512_mask_add_epi32/// Add packed 32-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_epi32&expand=101)_mm512_maskz_add_epi32/// Add packed 32-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_epi32&expand=102)_mm256_mask_add_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_add_epi32&expand=98)_mm256_maskz_add_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_add_epi32&expand=99)_mm_mask_add_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_add_epi32&expand=95)_mm_maskz_add_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_add_epi32&expand=96)_mm512_add_epi64/// Add packed 64-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_epi64&expand=109)_mm512_mask_add_epi64/// Add packed 64-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_epi64&expand=110)_mm512_maskz_add_epi64/// Add packed 64-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_epi64&expand=111)_mm256_mask_add_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_add_epi64&expand=107)_mm256_maskz_add_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_add_epi64&expand=108)_mm_mask_add_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_add_epi64&expand=104)_mm_maskz_add_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_add_epi64&expand=105)_mm512_add_ps/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_ps&expand=139)_mm512_mask_add_ps/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_ps&expand=140)_mm512_maskz_add_ps/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_ps&expand=141)_mm256_mask_add_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_add_ps&expand=137)_mm256_maskz_add_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_add_ps&expand=138)_mm_mask_add_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_add_ps&expand=134)_mm_maskz_add_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_add_ps&expand=135)_mm512_add_pd/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_pd&expand=127)_mm512_mask_add_pd/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_pd&expand=128)_mm512_maskz_add_pd/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_pd&expand=129)_mm256_mask_add_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_add_pd&expand=125)_mm256_maskz_add_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_add_pd&expand=126)_mm_mask_add_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_add_pd&expand=122)_mm_maskz_add_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_add_pd&expand=123)_mm512_sub_epi32/// Subtract packed 32-bit integers in b from packed 32-bit integers in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_epi32&expand=5694)_mm512_mask_sub_epi32/// Subtract packed 32-bit integers in b from packed 32-bit integers in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_epi32&expand=5692)_mm512_maskz_sub_epi32/// Subtract packed 32-bit integers in b from packed 32-bit integers in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_epi32&expand=5693)_mm256_mask_sub_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sub_epi32&expand=5689)_mm256_maskz_sub_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sub_epi32&expand=5690)_mm_mask_sub_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sub_epi32&expand=5686)_mm_maskz_sub_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sub_epi32&expand=5687)_mm512_sub_epi64/// Subtract packed 64-bit integers in b from packed 64-bit integers in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_epi64&expand=5703)_mm512_mask_sub_epi64/// Subtract packed 64-bit integers in b from packed 64-bit integers in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_epi64&expand=5701)_mm512_maskz_sub_epi64/// Subtract packed 64-bit integers in b from packed 64-bit integers in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_epi64&expand=5702)_mm256_mask_sub_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sub_epi64&expand=5698)_mm256_maskz_sub_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sub_epi64&expand=5699)_mm_mask_sub_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sub_epi64&expand=5695)_mm_maskz_sub_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sub_epi64&expand=5696)_mm512_sub_ps/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_ps&expand=5733)_mm512_mask_sub_ps/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_ps&expand=5731)_mm512_maskz_sub_ps/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_ps&expand=5732)_mm256_mask_sub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sub_ps&expand=5728)_mm256_maskz_sub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sub_ps&expand=5729)_mm_mask_sub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sub_ps&expand=5725)_mm_maskz_sub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sub_ps&expand=5726)_mm512_sub_pd/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_pd&expand=5721)_mm512_mask_sub_pd/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_pd&expand=5719)_mm512_maskz_sub_pd/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_pd&expand=5720)_mm256_mask_sub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sub_pd&expand=5716)_mm256_maskz_sub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sub_pd&expand=5717)_mm_mask_sub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sub_pd&expand=5713)_mm_maskz_sub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sub_pd&expand=5714)_mm512_mul_epi32/// Multiply the low signed 32-bit integers from each packed 64-bit element in a and b, and store the signed 64-bit results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mul_epi32&expand=3907)_mm512_mask_mul_epi32/// Multiply the low signed 32-bit integers from each packed 64-bit element in a and b, and store the signed 64-bit results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mul_epi32&expand=3905)_mm512_maskz_mul_epi32/// Multiply the low signed 32-bit integers from each packed 64-bit element in a and b, and store the signed 64-bit results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mul_epi32&expand=3906)_mm256_mask_mul_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mul_epi32&expand=3902)_mm256_maskz_mul_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mul_epi32&expand=3903)_mm_mask_mul_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mul_epi32&expand=3899)_mm_maskz_mul_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mul_epi32&expand=3900)_mm512_mullo_epi32/// Multiply the packed 32-bit integers in a and b, producing intermediate 64-bit integers, and store the low 32 bits of the intermediate integers in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mullo_epi32&expand=4005)_mm512_mask_mullo_epi32/// Multiply the packed 32-bit integers in a and b, producing intermediate 64-bit integers, and store the low 32 bits of the intermediate integers in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mullo_epi32&expand=4003)_mm512_maskz_mullo_epi32/// Multiply the packed 32-bit integers in a and b, producing intermediate 64-bit integers, and store the low 32 bits of the intermediate integers in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mullo_epi32&expand=4004)_mm256_mask_mullo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mullo_epi32&expand=4000)_mm256_maskz_mullo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mullo_epi32&expand=4001)_mm_mask_mullo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mullo_epi32&expand=3997)_mm_maskz_mullo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mullo_epi32&expand=3998)_mm512_mullox_epi64/// Multiplies elements in packed 64-bit integer vectors a and b together, storing the lower 64 bits of the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mullox_epi64&expand=4017)/// This intrinsic generates a sequence of instructions, which may perform worse than a native instruction. Consider the performance impact of this intrinsic._mm512_mask_mullox_epi64/// Multiplies elements in packed 64-bit integer vectors a and b together, storing the lower 64 bits of the result in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mullox_epi64&expand=4016)_mm512_mul_epu32/// Multiply the low unsigned 32-bit integers from each packed 64-bit element in a and b, and store the unsigned 64-bit results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mul_epu32&expand=3916)_mm512_mask_mul_epu32/// Multiply the low unsigned 32-bit integers from each packed 64-bit element in a and b, and store the unsigned 64-bit results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mul_epu32&expand=3914)_mm512_maskz_mul_epu32/// Multiply the low unsigned 32-bit integers from each packed 64-bit element in a and b, and store the unsigned 64-bit results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mul_epu32&expand=3915)_mm256_mask_mul_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mul_epu32&expand=3911)_mm256_maskz_mul_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mul_epu32&expand=3912)_mm_mask_mul_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mul_epu32&expand=3908)_mm_maskz_mul_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mul_epu32&expand=3909)_mm512_mul_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mul_ps&expand=3934)_mm512_mask_mul_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mul_ps&expand=3932)_mm512_maskz_mul_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mul_ps&expand=3933)_mm256_mask_mul_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mul_ps&expand=3929)_mm256_maskz_mul_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mul_ps&expand=3930)_mm_mask_mul_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mul_ps&expand=3926)_mm_maskz_mul_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mul_ps&expand=3927)_mm512_mul_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mul_pd&expand=3925)_mm512_mask_mul_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mul_pd&expand=3923)_mm512_maskz_mul_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mul_pd&expand=3924)_mm256_mask_mul_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_mul_pd&expand=3920)_mm256_maskz_mul_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_mul_pd&expand=3921)_mm_mask_mul_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_mul_pd&expand=3917)_mm_maskz_mul_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_mul_pd&expand=3918)_mm512_div_ps/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_div_ps&expand=2162)_mm512_mask_div_ps/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_div_ps&expand=2163)_mm512_maskz_div_ps/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_div_ps&expand=2164)_mm256_mask_div_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_div_ps&expand=2160)_mm256_maskz_div_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_div_ps&expand=2161)_mm_mask_div_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_div_ps&expand=2157)_mm_maskz_div_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_div_ps&expand=2158)_mm512_div_pd/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_div_pd&expand=2153)_mm512_mask_div_pd/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_div_pd&expand=2154)_mm512_maskz_div_pd/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_div_pd&expand=2155)_mm256_mask_div_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_div_pd&expand=2151)_mm256_maskz_div_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_div_pd&expand=2152)_mm_mask_div_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_div_pd&expand=2148)_mm_maskz_div_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_div_pd&expand=2149)_mm512_max_epi32/// Compare packed signed 32-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epi32&expand=3582)_mm512_mask_max_epi32/// Compare packed signed 32-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epi32&expand=3580)_mm512_maskz_max_epi32/// Compare packed signed 32-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epi32&expand=3581)_mm256_mask_max_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epi32&expand=3577)_mm256_maskz_max_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epi32&expand=3578)_mm_mask_max_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epi32&expand=3574)_mm_maskz_max_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epi32&expand=3575)_mm512_max_epi64/// Compare packed signed 64-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epi64&expand=3591)_mm512_mask_max_epi64/// Compare packed signed 64-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epi64&expand=3589)_mm512_maskz_max_epi64/// Compare packed signed 64-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epi64&expand=3590)_mm256_max_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epi64&expand=3588)_mm256_mask_max_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epi64&expand=3586)_mm256_maskz_max_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epi64&expand=3587)_mm_max_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epi64&expand=3585)_mm_mask_max_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epi64&expand=3583)_mm_maskz_max_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epi64&expand=3584)_mm512_max_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_ps&expand=3655)_mm512_mask_max_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_ps&expand=3653)_mm512_maskz_max_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_ps&expand=3654)_mm256_mask_max_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_ps&expand=3650)_mm256_maskz_max_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_ps&expand=3651)_mm_mask_max_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_ps&expand=3647)_mm_maskz_max_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_ps&expand=3648)_mm512_max_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_pd&expand=3645)_mm512_mask_max_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_pd&expand=3643)_mm512_maskz_max_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_pd&expand=3644)_mm256_mask_max_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_pd&expand=3640)_mm256_maskz_max_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_pd&expand=3641)_mm_mask_max_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_pd&expand=3637)_mm_maskz_max_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_pd&expand=3638)_mm512_max_epu32/// Compare packed unsigned 32-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epu32&expand=3618)_mm512_mask_max_epu32/// Compare packed unsigned 32-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epu32&expand=3616)_mm512_maskz_max_epu32/// Compare packed unsigned 32-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epu32&expand=3617)_mm256_mask_max_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epu32&expand=3613)_mm256_maskz_max_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epu32&expand=3614)_mm_mask_max_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epu32&expand=3610)_mm_maskz_max_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epu32&expand=3611)_mm512_max_epu64/// Compare packed unsigned 64-bit integers in a and b, and store packed maximum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_epu64&expand=3627)_mm512_mask_max_epu64/// Compare packed unsigned 64-bit integers in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_epu64&expand=3625)_mm512_maskz_max_epu64/// Compare packed unsigned 64-bit integers in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_epu64&expand=3626)_mm256_max_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_max_epu64&expand=3624)_mm256_mask_max_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_max_epu64&expand=3622)_mm256_maskz_max_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_max_epu64&expand=3623)_mm_max_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epu64&expand=3621)_mm_mask_max_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_max_epu64&expand=3619)_mm_maskz_max_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_max_epu64&expand=3620)_mm512_min_epi32/// Compare packed signed 32-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epi32&expand=3696)_mm512_mask_min_epi32/// Compare packed signed 32-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epi32&expand=3694)_mm512_maskz_min_epi32/// Compare packed signed 32-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epi32&expand=3695)_mm256_mask_min_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epi32&expand=3691)_mm256_maskz_min_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epi32&expand=3692)_mm_mask_min_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epi32&expand=3688)_mm_maskz_min_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epi32&expand=3689)_mm512_min_epi64/// Compare packed signed 64-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epi64&expand=3705)_mm512_mask_min_epi64/// Compare packed signed 64-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epi64&expand=3703)_mm512_maskz_min_epi64/// Compare packed signed 64-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epi64&expand=3704)_mm256_min_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epi64&expand=3702)_mm256_mask_min_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epi64&expand=3700)_mm256_maskz_min_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epi64&expand=3701)_mm_min_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epi64)_mm_mask_min_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epi64)_mm_maskz_min_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epi64)_mm512_min_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_ps&expand=3769)_mm512_mask_min_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_ps&expand=3767)_mm512_maskz_min_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_ps&expand=3768)_mm256_mask_min_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_ps&expand=3764)_mm256_maskz_min_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_ps&expand=3765)_mm_mask_min_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_ps&expand=3761)_mm_maskz_min_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_ps&expand=3762)_mm512_min_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_pd&expand=3759)_mm512_mask_min_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_pd&expand=3757)_mm512_maskz_min_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_pd&expand=3758)_mm256_mask_min_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_pd&expand=3754)_mm256_maskz_min_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_pd&expand=3755)_mm_mask_min_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_pd&expand=3751)_mm_maskz_min_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_pd&expand=3752)_mm512_min_epu32/// Compare packed unsigned 32-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epu32&expand=3732)_mm512_mask_min_epu32/// Compare packed unsigned 32-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epu32&expand=3730)_mm512_maskz_min_epu32/// Compare packed unsigned 32-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epu32&expand=3731)_mm256_mask_min_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epu32&expand=3727)_mm256_maskz_min_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epu32&expand=3728)_mm_mask_min_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epu32&expand=3724)_mm_maskz_min_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epu32&expand=3725)_mm512_min_epu64/// Compare packed unsigned 64-bit integers in a and b, and store packed minimum values in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_epu64&expand=3741)_mm512_mask_min_epu64/// Compare packed unsigned 64-bit integers in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_epu64&expand=3739)_mm512_maskz_min_epu64/// Compare packed unsigned 64-bit integers in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_epu64&expand=3740)_mm256_min_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_min_epu64&expand=3738)_mm256_mask_min_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_min_epu64&expand=3736)_mm256_maskz_min_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_min_epu64&expand=3737)_mm_min_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epu64&expand=3735)_mm_mask_min_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_min_epu64&expand=3733)_mm_maskz_min_epu64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_min_epu64&expand=3734)_mm512_sqrt_ps/// Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sqrt_ps&expand=5371)_mm512_mask_sqrt_ps/// Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sqrt_ps&expand=5369)_mm512_maskz_sqrt_ps/// Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sqrt_ps&expand=5370)_mm256_mask_sqrt_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sqrt_ps&expand=5366)_mm256_maskz_sqrt_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sqrt_ps&expand=5367)_mm_mask_sqrt_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sqrt_ps&expand=5363)_mm_maskz_sqrt_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sqrt_ps&expand=5364)_mm512_sqrt_pd/// Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sqrt_pd&expand=5362)_mm512_mask_sqrt_pd/// Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sqrt_pd&expand=5360)_mm512_maskz_sqrt_pd/// Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sqrt_pd&expand=5361)_mm256_mask_sqrt_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sqrt_pd&expand=5357)_mm256_maskz_sqrt_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sqrt_pd&expand=5358)_mm_mask_sqrt_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sqrt_pd&expand=5354)_mm_maskz_sqrt_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sqrt_pd&expand=5355)_mm512_fmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmadd_ps&expand=2557)//vfmadd132ps or vfmadd213ps or vfmadd231ps_mm512_mask_fmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmadd_ps&expand=2558)_mm512_maskz_fmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmadd_ps&expand=2560)_mm512_mask3_fmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmadd_ps&expand=2559)_mm256_mask_fmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmadd_ps&expand=2554)_mm256_maskz_fmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmadd_ps&expand=2556)_mm256_mask3_fmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmadd_ps&expand=2555)_mm_mask_fmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmadd_ps&expand=2550)_mm_maskz_fmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmadd_ps&expand=2552)_mm_mask3_fmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmadd_ps&expand=2551)_mm512_fmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmadd_pd&expand=2545)//vfmadd132pd or vfmadd213pd or vfmadd231pd_mm512_mask_fmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmadd_pd&expand=2546)_mm512_maskz_fmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmadd_pd&expand=2548)_mm512_mask3_fmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmadd_pd&expand=2547)_mm256_mask_fmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmadd_pd&expand=2542)_mm256_maskz_fmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmadd_pd&expand=2544)_mm256_mask3_fmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmadd_pd&expand=2543)_mm_mask_fmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmadd_pd&expand=2538)_mm_maskz_fmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmadd_pd&expand=2540)_mm_mask3_fmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmadd_pd&expand=2539)_mm512_fmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsub_ps&expand=2643)//vfmsub132ps or vfmsub213ps or vfmsub231ps, clang generate vfmadd, gcc generate vfmsub_mm512_mask_fmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsub_ps&expand=2644)_mm512_maskz_fmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsub_ps&expand=2646)_mm512_mask3_fmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsub_ps&expand=2645)_mm256_mask_fmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmsub_ps&expand=2640)_mm256_maskz_fmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmsub_ps&expand=2642)_mm256_mask3_fmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmsub_ps&expand=2641)_mm_mask_fmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmsub_ps&expand=2636)_mm_maskz_fmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmsub_ps&expand=2638)_mm_mask3_fmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmsub_ps&expand=2637)_mm512_fmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsub_pd&expand=2631)//vfmsub132pd or vfmsub213pd or vfmsub231pd. clang fmadd, gcc fmsub_mm512_mask_fmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsub_pd&expand=2632)_mm512_maskz_fmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsub_pd&expand=2634)_mm512_mask3_fmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsub_pd&expand=2633)_mm256_mask_fmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmsub_pd&expand=2628)_mm256_maskz_fmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmsub_pd&expand=2630)_mm256_mask3_fmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmsub_pd&expand=2629)_mm_mask_fmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmsub_pd&expand=2624)_mm_maskz_fmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmsub_pd&expand=2626)_mm_mask3_fmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmsub_pd&expand=2625)_mm512_fmaddsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmaddsub_ps&expand=2611)//vfmaddsub132ps or vfmaddsub213ps or vfmaddsub231ps_mm512_mask_fmaddsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmaddsub_ps&expand=2612)_mm512_maskz_fmaddsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmaddsub_ps&expand=2614)_mm512_mask3_fmaddsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmaddsub_ps&expand=2613)_mm256_mask_fmaddsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmaddsub_ps&expand=2608)_mm256_maskz_fmaddsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmaddsub_ps&expand=2610)_mm256_mask3_fmaddsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmaddsub_ps&expand=2609)_mm_mask_fmaddsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmaddsub_ps&expand=2604)_mm_maskz_fmaddsub_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/IntrinsicsGuide/#text=_mm_maskz_fmaddsub_ps&expand=2606)_mm_mask3_fmaddsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmaddsub_ps&expand=2605)_mm512_fmaddsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmaddsub_pd&expand=2599)//vfmaddsub132pd or vfmaddsub213pd or vfmaddsub231pd_mm512_mask_fmaddsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmaddsub_pd&expand=2600)_mm512_maskz_fmaddsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmaddsub_pd&expand=2602)_mm512_mask3_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmaddsub_pd&expand=2613)_mm256_mask_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmaddsub_pd&expand=2596)_mm256_maskz_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmaddsub_pd&expand=2598)_mm256_mask3_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmaddsub_pd&expand=2597)_mm_mask_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmaddsub_pd&expand=2592)_mm_maskz_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmaddsub_pd&expand=2594)_mm_mask3_fmaddsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmaddsub_pd&expand=2593)_mm512_fmsubadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsubadd_ps&expand=2691)//vfmsubadd132ps or vfmsubadd213ps or vfmsubadd231ps_mm512_mask_fmsubadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsubadd_ps&expand=2692)_mm512_maskz_fmsubadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsubadd_ps&expand=2694)_mm512_mask3_fmsubadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsubadd_ps&expand=2693)_mm256_mask_fmsubadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmsubadd_ps&expand=2688)_mm256_maskz_fmsubadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmsubadd_ps&expand=2690)_mm256_mask3_fmsubadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmsubadd_ps&expand=2689)_mm_mask_fmsubadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmsubadd_ps&expand=2684)_mm_maskz_fmsubadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmsubadd_ps&expand=2686)_mm_mask3_fmsubadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmsubadd_ps&expand=2685)_mm512_fmsubadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsubadd_pd&expand=2679)//vfmsubadd132pd or vfmsubadd213pd or vfmsubadd231pd_mm512_mask_fmsubadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsubadd_pd&expand=2680)_mm512_maskz_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsubadd_pd&expand=2682)_mm512_mask3_fmsubadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsubadd_pd&expand=2681)_mm256_mask_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fmsubadd_pd&expand=2676)_mm256_maskz_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fmsubadd_pd&expand=2678)_mm256_mask3_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fmsubadd_pd&expand=2677)_mm_mask_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fmsubadd_pd&expand=2672)_mm_maskz_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fmsubadd_pd&expand=2674)_mm_mask3_fmsubadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fmsubadd_pd&expand=2673)_mm512_fnmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmadd_ps&expand=2723)//vfnmadd132ps or vfnmadd213ps or vfnmadd231ps_mm512_mask_fnmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmadd_ps&expand=2724)_mm512_maskz_fnmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmadd_ps&expand=2726)_mm512_mask3_fnmadd_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmadd_ps&expand=2725)_mm256_mask_fnmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fnmadd_ps&expand=2720)_mm256_maskz_fnmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fnmadd_ps&expand=2722)_mm256_mask3_fnmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fnmadd_ps&expand=2721)_mm_mask_fnmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fnmadd_ps&expand=2716)_mm_maskz_fnmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fnmadd_ps&expand=2718)_mm_mask3_fnmadd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fnmadd_ps&expand=2717)_mm512_fnmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmadd_pd&expand=2711)//vfnmadd132pd or vfnmadd213pd or vfnmadd231pd_mm512_mask_fnmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmadd_pd&expand=2712)_mm512_maskz_fnmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmadd_pd&expand=2714)_mm512_mask3_fnmadd_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmadd_pd&expand=2713)_mm256_mask_fnmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fnmadd_pd&expand=2708)_mm256_maskz_fnmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fnmadd_pd&expand=2710)_mm256_mask3_fnmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fnmadd_pd&expand=2709)_mm_mask_fnmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fnmadd_pd&expand=2704)_mm_maskz_fnmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fnmadd_pd&expand=2706)_mm_mask3_fnmadd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fnmadd_pd&expand=2705)_mm512_fnmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmsub_ps&expand=2771)//vfnmsub132ps or vfnmsub213ps or vfnmsub231ps_mm512_mask_fnmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmsub_ps&expand=2772)_mm512_maskz_fnmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmsub_ps&expand=2774)_mm512_mask3_fnmsub_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmsub_ps&expand=2773)_mm256_mask_fnmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fnmsub_ps&expand=2768)_mm256_maskz_fnmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fnmsub_ps&expand=2770)_mm256_mask3_fnmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fnmsub_ps&expand=2769)_mm_mask_fnmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fnmsub_ps&expand=2764)_mm_maskz_fnmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fnmsub_ps&expand=2766)_mm_mask3_fnmsub_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fnmsub_ps&expand=2765)_mm512_fnmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmsub_pd&expand=2759)//vfnmsub132pd or vfnmsub213pd or vfnmsub231pd_mm512_mask_fnmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmsub_pd&expand=2760)_mm512_maskz_fnmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmsub_pd&expand=2762)_mm512_mask3_fnmsub_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmsub_pd&expand=2761)_mm256_mask_fnmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fnmsub_pd&expand=2756)_mm256_maskz_fnmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fnmsub_pd&expand=2758)_mm256_mask3_fnmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask3_fnmsub_pd&expand=2757)_mm_mask_fnmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fnmsub_pd&expand=2752)_mm_maskz_fnmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fnmsub_pd&expand=2754)_mm_mask3_fnmsub_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask3_fnmsub_pd&expand=2753)_mm512_rcp14_ps/// Compute the approximate reciprocal of packed single-precision (32-bit) floating-point elements in a, and store the results in dst. The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rcp14_ps&expand=4502)_mm512_mask_rcp14_ps/// Compute the approximate reciprocal of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rcp14_ps&expand=4500)_mm512_maskz_rcp14_ps/// Compute the approximate reciprocal of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rcp14_ps&expand=4501)_mm256_rcp14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rcp14_ps&expand=4499)_mm256_mask_rcp14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rcp14_ps&expand=4497)_mm256_maskz_rcp14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rcp14_ps&expand=4498)_mm_rcp14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rcp14_ps&expand=4496)_mm_mask_rcp14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rcp14_ps&expand=4494)_mm_maskz_rcp14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rcp14_ps&expand=4495)_mm512_rcp14_pd/// Compute the approximate reciprocal of packed double-precision (64-bit) floating-point elements in a, and store the results in dst. The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rcp14_pd&expand=4493)_mm512_mask_rcp14_pd/// Compute the approximate reciprocal of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rcp14_pd&expand=4491)_mm512_maskz_rcp14_pd/// Compute the approximate reciprocal of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rcp14_pd&expand=4492)_mm256_rcp14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rcp14_pd&expand=4490)_mm256_mask_rcp14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rcp14_pd&expand=4488)_mm256_maskz_rcp14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rcp14_pd&expand=4489)_mm_rcp14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rcp14_pd&expand=4487)_mm_mask_rcp14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rcp14_pd&expand=4485)_mm_maskz_rcp14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rcp14_pd&expand=4486)_mm512_rsqrt14_ps/// Compute the approximate reciprocal square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst. The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rsqrt14_ps&expand=4819)_mm512_mask_rsqrt14_ps/// Compute the approximate reciprocal square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rsqrt14_ps&expand=4817)_mm512_maskz_rsqrt14_ps/// Compute the approximate reciprocal square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rsqrt14_ps&expand=4818)_mm256_rsqrt14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rsqrt14_ps)_mm256_mask_rsqrt14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rsqrt14_ps&expand=4815)_mm256_maskz_rsqrt14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rsqrt14_ps&expand=4816)_mm_rsqrt14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rsqrt14_ps)_mm_mask_rsqrt14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rsqrt14_ps&expand=4813)_mm_maskz_rsqrt14_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rsqrt14_ps&expand=4814)_mm512_rsqrt14_pd/// Compute the approximate reciprocal square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst. The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rsqrt14_pd&expand=4812)_mm512_mask_rsqrt14_pd/// Compute the approximate reciprocal square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rsqrt14_pd&expand=4810)_mm512_maskz_rsqrt14_pd/// Compute the approximate reciprocal square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). The maximum relative error for this approximation is less than 2^-14./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rsqrt14_pd&expand=4811)_mm256_rsqrt14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rsqrt14_pd)_mm256_mask_rsqrt14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rsqrt14_pd&expand=4808)_mm256_maskz_rsqrt14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rsqrt14_pd&expand=4809)_mm_rsqrt14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rsqrt14_pd)_mm_mask_rsqrt14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rsqrt14_pd&expand=4806)_mm_maskz_rsqrt14_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rsqrt14_pd&expand=4807)_mm512_getexp_ps/// Convert the exponent of each packed single-precision (32-bit) floating-point element in a to a single-precision (32-bit) floating-point number representing the integer exponent, and store the results in dst. This intrinsic essentially calculates floor(log2(x)) for each element./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getexp_ps&expand=2844)_mm512_mask_getexp_ps/// Convert the exponent of each packed single-precision (32-bit) floating-point element in a to a single-precision (32-bit) floating-point number representing the integer exponent, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getexp_ps&expand=2845)_mm512_maskz_getexp_ps/// Convert the exponent of each packed single-precision (32-bit) floating-point element in a to a single-precision (32-bit) floating-point number representing the integer exponent, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getexp_ps&expand=2846)_mm256_getexp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_getexp_ps&expand=2841)_mm256_mask_getexp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_getexp_ps&expand=2842)_mm256_maskz_getexp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_getexp_ps&expand=2843)_mm_getexp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_getexp_ps&expand=2838)_mm_mask_getexp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_getexp_ps&expand=2839)_mm_maskz_getexp_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_getexp_ps&expand=2840)_mm512_getexp_pd/// Convert the exponent of each packed double-precision (64-bit) floating-point element in a to a double-precision (64-bit) floating-point number representing the integer exponent, and store the results in dst. This intrinsic essentially calculates floor(log2(x)) for each element./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getexp_pd&expand=2835)_mm512_mask_getexp_pd/// Convert the exponent of each packed double-precision (64-bit) floating-point element in a to a double-precision (64-bit) floating-point number representing the integer exponent, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getexp_pd&expand=2836)_mm512_maskz_getexp_pd/// Convert the exponent of each packed double-precision (64-bit) floating-point element in a to a double-precision (64-bit) floating-point number representing the integer exponent, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getexp_pd&expand=2837)_mm256_getexp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_getexp_pd&expand=2832)_mm256_mask_getexp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_getexp_pd&expand=2833)_mm256_maskz_getexp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_getexp_pd&expand=2834)_mm_getexp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_getexp_pd&expand=2829)_mm_mask_getexp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_getexp_pd&expand=2830)_mm_maskz_getexp_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_getexp_pd&expand=2831)_mm512_roundscale_ps/// Round packed single-precision (32-bit) floating-point elements in a to the number of fraction bits specified by imm8, and store the results in dst.\/// Rounding is done according to the imm8\[2:0\] parameter, which can be one of:\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_roundscale_ps&expand=4784)_mm512_mask_roundscale_ps/// Round packed single-precision (32-bit) floating-point elements in a to the number of fraction bits specified by imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_roundscale_ps&expand=4782)_mm512_maskz_roundscale_ps/// Round packed single-precision (32-bit) floating-point elements in a to the number of fraction bits specified by imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_roundscale_ps&expand=4783)_mm256_roundscale_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_roundscale_ps&expand=4781)_mm256_mask_roundscale_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_roundscale_ps&expand=4779)_mm256_maskz_roundscale_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_roundscale_ps&expand=4780)_mm_roundscale_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_roundscale_ps&expand=4778)_mm_mask_roundscale_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_roundscale_ps&expand=4776)_mm_maskz_roundscale_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_roundscale_ps&expand=4777)_mm512_roundscale_pd/// Round packed double-precision (64-bit) floating-point elements in a to the number of fraction bits specified by imm8, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_roundscale_pd&expand=4775)_mm512_mask_roundscale_pd/// Round packed double-precision (64-bit) floating-point elements in a to the number of fraction bits specified by imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_roundscale_pd&expand=4773)_mm512_maskz_roundscale_pd/// Round packed double-precision (64-bit) floating-point elements in a to the number of fraction bits specified by imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_roundscale_pd&expand=4774)_mm256_roundscale_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_roundscale_pd&expand=4772)_mm256_mask_roundscale_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_roundscale_pd&expand=4770)_mm256_maskz_roundscale_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_roundscale_pd&expand=4771)_mm_roundscale_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_roundscale_pd&expand=4769)_mm_mask_roundscale_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_roundscale_pd&expand=4767)_mm_maskz_roundscale_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_roundscale_pd&expand=4768)_mm512_scalef_ps/// Scale the packed single-precision (32-bit) floating-point elements in a using values from b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_scalef_ps&expand=4883)_mm512_mask_scalef_ps/// Scale the packed single-precision (32-bit) floating-point elements in a using values from b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_scalef_ps&expand=4881)_mm512_maskz_scalef_ps/// Scale the packed single-precision (32-bit) floating-point elements in a using values from b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_scalef_ps&expand=4882)_mm256_scalef_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_scalef_ps&expand=4880)_mm256_mask_scalef_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_scalef_ps&expand=4878)_mm256_maskz_scalef_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_scalef_ps&expand=4879)_mm_scalef_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_scalef_ps&expand=4877)_mm_mask_scalef_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_scalef_ps&expand=4875)_mm_maskz_scalef_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_scalef_ps&expand=4876)_mm512_scalef_pd/// Scale the packed double-precision (64-bit) floating-point elements in a using values from b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_scalef_pd&expand=4874)_mm512_mask_scalef_pd/// Scale the packed double-precision (64-bit) floating-point elements in a using values from b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_scalef_pd&expand=4872)_mm512_maskz_scalef_pd/// Scale the packed double-precision (64-bit) floating-point elements in a using values from b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_scalef_pd&expand=4873)_mm256_scalef_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_scalef_pd&expand=4871)_mm256_mask_scalef_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_scalef_pd&expand=4869)_mm256_maskz_scalef_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_scalef_pd&expand=4870)_mm_scalef_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_scalef_pd&expand=4868)_mm_mask_scalef_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_scalef_pd&expand=4866)_mm_maskz_scalef_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_scalef_pd&expand=4867)_mm512_fixupimm_ps/// Fix up packed single-precision (32-bit) floating-point elements in a and b using packed 32-bit integers in c, and store the results in dst. imm8 is used to set the required flags reporting./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fixupimm_ps&expand=2499)_mm512_mask_fixupimm_ps/// Fix up packed single-precision (32-bit) floating-point elements in a and b using packed 32-bit integers in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set). imm8 is used to set the required flags reporting./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fixupimm_ps&expand=2500)_mm512_maskz_fixupimm_ps/// Fix up packed single-precision (32-bit) floating-point elements in a and b using packed 32-bit integers in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). imm8 is used to set the required flags reporting./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fixupimm_ps&expand=2501)_mm256_fixupimm_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_fixupimm_ps&expand=2496)_mm256_mask_fixupimm_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fixupimm_ps&expand=2497)_mm256_maskz_fixupimm_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fixupimm_ps&expand=2498)_mm_fixupimm_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_fixupimm_ps&expand=2493)_mm_mask_fixupimm_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fixupimm_ps&expand=2494)_mm_maskz_fixupimm_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fixupimm_ps&expand=2495)_mm512_fixupimm_pd/// Fix up packed double-precision (64-bit) floating-point elements in a and b using packed 64-bit integers in c, and store the results in dst. imm8 is used to set the required flags reporting./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fixupimm_pd&expand=2490)_mm512_mask_fixupimm_pd/// Fix up packed double-precision (64-bit) floating-point elements in a and b using packed 64-bit integers in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set). imm8 is used to set the required flags reporting./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fixupimm_pd&expand=2491)_mm512_maskz_fixupimm_pd/// Fix up packed double-precision (64-bit) floating-point elements in a and b using packed 64-bit integers in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). imm8 is used to set the required flags reporting./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fixupimm_pd&expand=2492)_mm256_fixupimm_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_fixupimm_pd&expand=2487)_mm256_mask_fixupimm_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_fixupimm_pd&expand=2488)_mm256_maskz_fixupimm_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_fixupimm_pd&expand=2489)_mm_fixupimm_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_fixupimm_pd&expand=2484)_mm_mask_fixupimm_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_fixupimm_pd&expand=2485)_mm_maskz_fixupimm_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_fixupimm_pd&expand=2486)_mm512_ternarylogic_epi32/// Bitwise ternary logic that provides the capability to implement any three-operand binary function; the specific binary function is specified by value in imm8. For each bit in each packed 32-bit integer, the corresponding bit from a, b, and c are used to form a 3 bit index into imm8, and the value at that bit in imm8 is written to the corresponding bit in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_ternarylogic_epi32&expand=5867)_mm512_mask_ternarylogic_epi32/// Bitwise ternary logic that provides the capability to implement any three-operand binary function; the specific binary function is specified by value in imm8. For each bit in each packed 32-bit integer, the corresponding bit from src, a, and b are used to form a 3 bit index into imm8, and the value at that bit in imm8 is written to the corresponding bit in dst using writemask k at 32-bit granularity (32-bit elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_ternarylogic_epi32&expand=5865)_mm512_maskz_ternarylogic_epi32/// Bitwise ternary logic that provides the capability to implement any three-operand binary function; the specific binary function is specified by value in imm8. For each bit in each packed 32-bit integer, the corresponding bit from a, b, and c are used to form a 3 bit index into imm8, and the value at that bit in imm8 is written to the corresponding bit in dst using zeromask k at 32-bit granularity (32-bit elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_ternarylogic_epi32&expand=5866)_mm256_ternarylogic_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_ternarylogic_epi32&expand=5864)_mm256_mask_ternarylogic_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_ternarylogic_epi32&expand=5862)_mm256_maskz_ternarylogic_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_ternarylogic_epi32&expand=5863)_mm_ternarylogic_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ternarylogic_epi32&expand=5861)_mm_mask_ternarylogic_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_ternarylogic_epi32&expand=5859)_mm_maskz_ternarylogic_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_ternarylogic_epi32&expand=5860)_mm512_ternarylogic_epi64/// Bitwise ternary logic that provides the capability to implement any three-operand binary function; the specific binary function is specified by value in imm8. For each bit in each packed 64-bit integer, the corresponding bit from a, b, and c are used to form a 3 bit index into imm8, and the value at that bit in imm8 is written to the corresponding bit in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_ternarylogic_epi64&expand=5876)_mm512_mask_ternarylogic_epi64/// Bitwise ternary logic that provides the capability to implement any three-operand binary function; the specific binary function is specified by value in imm8. For each bit in each packed 64-bit integer, the corresponding bit from src, a, and b are used to form a 3 bit index into imm8, and the value at that bit in imm8 is written to the corresponding bit in dst using writemask k at 64-bit granularity (64-bit elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_ternarylogic_epi64&expand=5874)_mm512_maskz_ternarylogic_epi64/// Bitwise ternary logic that provides the capability to implement any three-operand binary function; the specific binary function is specified by value in imm8. For each bit in each packed 64-bit integer, the corresponding bit from a, b, and c are used to form a 3 bit index into imm8, and the value at that bit in imm8 is written to the corresponding bit in dst using zeromask k at 64-bit granularity (64-bit elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_ternarylogic_epi64&expand=5875)_mm256_ternarylogic_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_ternarylogic_epi64&expand=5873)_mm256_mask_ternarylogic_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_ternarylogic_epi64&expand=5871)_mm256_maskz_ternarylogic_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_ternarylogic_epi64&expand=5872)_mm_ternarylogic_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ternarylogic_epi64&expand=5870)_mm_mask_ternarylogic_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_ternarylogic_epi64&expand=5868)_mm_maskz_ternarylogic_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_ternarylogic_epi64&expand=5869)NORM_MM_MANTISSA_NORM_ENUMSIGN_MM_MANTISSA_SIGN_ENUM_mm512_getmant_ps/// Normalize the mantissas of packed single-precision (32-bit) floating-point elements in a, and store the results in dst. This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign./// The mantissa is normalized to the interval specified by interv, which can take the following values:///    _MM_MANT_NORM_1_2     // interval [1, 2)///    _MM_MANT_NORM_p5_2    // interval [0.5, 2)///    _MM_MANT_NORM_p5_1    // interval [0.5, 1)///    _MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)/// The sign is determined by sc which can take the following values:///    _MM_MANT_SIGN_src     // sign = sign(src)///    _MM_MANT_SIGN_zero    // sign = 0///    _MM_MANT_SIGN_nan     // dst = NaN if sign(src) = 1/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getmant_ps&expand=2880)_mm512_mask_getmant_ps/// Normalize the mantissas of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign.\/// The mantissa is normalized to the interval specified by interv, which can take the following values:\///    _MM_MANT_NORM_1_2     // interval [1, 2)\///    _MM_MANT_NORM_p5_2    // interval [0.5, 2)\///    _MM_MANT_NORM_p5_1    // interval [0.5, 1)\///    _MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)\/// The sign is determined by sc which can take the following values:\///    _MM_MANT_SIGN_src     // sign = sign(src)\///    _MM_MANT_SIGN_zero    // sign = 0\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getmant_ps&expand=2881)_mm512_maskz_getmant_ps/// Normalize the mantissas of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getmant_ps&expand=2882)_mm256_getmant_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_getmant_ps&expand=2877)_mm256_mask_getmant_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_getmant_ps&expand=2878)_mm256_maskz_getmant_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_getmant_ps&expand=2879)_mm_getmant_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_getmant_ps&expand=2874)_mm_mask_getmant_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_getmant_ps&expand=2875)_mm_maskz_getmant_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_getmant_ps&expand=2876)_mm512_getmant_pd/// Normalize the mantissas of packed double-precision (64-bit) floating-point elements in a, and store the results in dst. This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getmant_pd&expand=2871)_mm512_mask_getmant_pd/// Normalize the mantissas of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getmant_pd&expand=2872)_mm512_maskz_getmant_pd/// Normalize the mantissas of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getmant_pd&expand=2873)_mm256_getmant_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_getmant_pd&expand=2868)_mm256_mask_getmant_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_getmant_pd&expand=2869)_mm256_maskz_getmant_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_getmant_pd&expand=2870)_mm_getmant_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_getmant_pd&expand=2865)_mm_mask_getmant_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_getmant_pd&expand=2866)_mm_maskz_getmant_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_getmant_pd&expand=2867)_mm512_add_round_ps/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.\/// Rounding is done according to the rounding\[3:0\] parameter, which can be one of:\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_round_ps&expand=145)_mm512_mask_add_round_ps/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_round_ps&expand=146)_mm512_maskz_add_round_ps/// Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_round_ps&expand=147)_mm512_add_round_pd/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_add_round_pd&expand=142)_mm512_mask_add_round_pd/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_add_round_pd&expand=143)_mm512_maskz_add_round_pd/// Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_add_round_pd&expand=144)_mm512_sub_round_ps/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_round_ps&expand=5739)_mm512_mask_sub_round_ps/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_round_ps&expand=5737)_mm512_maskz_sub_round_ps/// Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_round_ps&expand=5738)_mm512_sub_round_pd/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sub_round_pd&expand=5736)_mm512_mask_sub_round_pd/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sub_round_pd&expand=5734)_mm512_maskz_sub_round_pd/// Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sub_round_pd&expand=5735)_mm512_mul_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mul_round_ps&expand=3940)_mm512_mask_mul_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mul_round_ps&expand=3938)_mm512_maskz_mul_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mul_round_ps&expand=3939)_mm512_mul_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mul_round_pd&expand=3937)_mm512_mask_mul_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_mul_round_pd&expand=3935)_mm512_maskz_mul_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_mul_round_pd&expand=3939)_mm512_div_round_ps/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_div_round_ps&expand=2168)_mm512_mask_div_round_ps/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_div_round_ps&expand=2169)_mm512_maskz_div_round_ps/// Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_div_round_ps&expand=2170)_mm512_div_round_pd/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, =and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_div_round_pd&expand=2165)_mm512_mask_div_round_pd/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_div_round_pd&expand=2166)_mm512_maskz_div_round_pd/// Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_div_round_pd&expand=2167)_mm512_sqrt_round_ps/// Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sqrt_round_ps&expand=5377)_mm512_mask_sqrt_round_ps/// Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sqrt_round_ps&expand=5375)_mm512_maskz_sqrt_round_ps/// Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sqrt_round_ps&expand=5376)_mm512_sqrt_round_pd/// Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sqrt_round_pd&expand=5374)_mm512_mask_sqrt_round_pd/// Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sqrt_round_pd&expand=5372)_mm512_maskz_sqrt_round_pd/// Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sqrt_round_pd&expand=5373)_mm512_fmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmadd_round_ps&expand=2565)_mm512_mask_fmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmadd_round_ps&expand=2566)_mm512_maskz_fmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in a using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmadd_round_ps&expand=2568)_mm512_mask3_fmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmadd_round_ps&expand=2567)_mm512_fmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmadd_round_pd&expand=2561)_mm512_mask_fmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmadd_round_pd&expand=2562)_mm512_maskz_fmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmadd_round_pd&expand=2564)_mm512_mask3_fmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmadd_round_pd&expand=2563)_mm512_fmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsub_round_ps&expand=2651)//vfmsub132ps or vfmsub213ps or vfmsub231ps, clang generates vfmadd, gcc generates vfmsub_mm512_mask_fmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsub_round_ps&expand=2652)_mm512_maskz_fmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsub_round_ps&expand=2654)_mm512_mask3_fmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsub_round_ps&expand=2653)_mm512_fmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsub_round_pd&expand=2647)//vfmsub132pd or vfmsub213pd or vfmsub231pd. clang generates fmadd, gcc generates fmsub_mm512_mask_fmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsub_round_pd&expand=2648)_mm512_maskz_fmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsub_round_pd&expand=2650)_mm512_mask3_fmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsub_round_pd&expand=2649)_mm512_fmaddsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmaddsub_round_ps&expand=2619)_mm512_mask_fmaddsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmaddsub_round_ps&expand=2620)_mm512_maskz_fmaddsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmaddsub_round_ps&expand=2622)_mm512_mask3_fmaddsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmaddsub_round_ps&expand=2621)_mm512_fmaddsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmaddsub_round_pd&expand=2615)_mm512_mask_fmaddsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmaddsub_round_pd&expand=2616)_mm512_maskz_fmaddsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively add and subtract packed elements in c to/from the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmaddsub_round_pd&expand=2618)_mm512_mask3_fmaddsub_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmaddsub_round_pd&expand=2617)_mm512_fmsubadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsubadd_round_ps&expand=2699)_mm512_mask_fmsubadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsubadd_round_ps&expand=2700)_mm512_maskz_fmsubadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsubadd_round_ps&expand=2702)_mm512_mask3_fmsubadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsubadd_round_ps&expand=2701)_mm512_fmsubadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fmsubadd_round_pd&expand=2695)_mm512_mask_fmsubadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fmsubadd_round_pd&expand=2696)_mm512_maskz_fmsubadd_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fmsubadd_round_pd&expand=2698)_mm512_mask3_fmsubadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, alternatively subtract and add packed elements in c from/to the intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fmsubadd_round_pd&expand=2697)_mm512_fnmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmadd_round_ps&expand=2731)_mm512_mask_fnmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmadd_round_ps&expand=2732)_mm512_maskz_fnmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmadd_round_ps&expand=2734)_mm512_mask3_fnmadd_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmadd_round_ps&expand=2733)_mm512_fnmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmadd_round_pd&expand=2711)_mm512_mask_fnmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmadd_round_pd&expand=2728)_mm512_maskz_fnmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmadd_round_pd&expand=2730)_mm512_mask3_fnmadd_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, add the negated intermediate result to packed elements in c, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmadd_round_pd&expand=2729)_mm512_fnmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmsub_round_ps&expand=2779)_mm512_mask_fnmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmsub_round_ps&expand=2780)_mm512_maskz_fnmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmsub_round_ps&expand=2782)_mm512_mask3_fnmsub_round_ps/// Multiply packed single-precision (32-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmsub_round_ps&expand=2781)_mm512_fnmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fnmsub_round_pd&expand=2775)_mm512_mask_fnmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fnmsub_round_pd&expand=2776)_mm512_maskz_fnmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fnmsub_round_pd&expand=2778)_mm512_mask3_fnmsub_round_pd/// Multiply packed double-precision (64-bit) floating-point elements in a and b, subtract packed elements in c from the negated intermediate result, and store the results in dst using writemask k (elements are copied from c when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask3_fnmsub_round_pd&expand=2777)_mm512_max_round_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_round_ps&expand=3662)_mm512_mask_max_round_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_round_ps&expand=3660)_mm512_maskz_max_round_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_round_ps&expand=3661)_mm512_max_round_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_max_round_pd&expand=3659)_mm512_mask_max_round_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_max_round_pd&expand=3657)_mm512_maskz_max_round_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_max_round_pd&expand=3658)_mm512_min_round_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_round_ps&expand=3776)_mm512_mask_min_round_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_round_ps&expand=3774)_mm512_maskz_min_round_ps/// Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_round_ps&expand=3775)_mm512_min_round_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_min_round_pd&expand=3773)_mm512_mask_min_round_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_min_round_pd&expand=3771)_mm512_maskz_min_round_pd/// Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_min_round_pd&expand=3772)_mm512_getexp_round_ps/// Convert the exponent of each packed single-precision (32-bit) floating-point element in a to a single-precision (32-bit) floating-point number representing the integer exponent, and store the results in dst. This intrinsic essentially calculates floor(log2(x)) for each element.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getexp_round_ps&expand=2850)_mm512_mask_getexp_round_ps/// Convert the exponent of each packed single-precision (32-bit) floating-point element in a to a single-precision (32-bit) floating-point number representing the integer exponent, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getexp_round_ps&expand=2851)_mm512_maskz_getexp_round_ps/// Convert the exponent of each packed single-precision (32-bit) floating-point element in a to a single-precision (32-bit) floating-point number representing the integer exponent, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getexp_round_ps&expand=2852)_mm512_getexp_round_pd/// Convert the exponent of each packed double-precision (64-bit) floating-point element in a to a double-precision (64-bit) floating-point number representing the integer exponent, and store the results in dst. This intrinsic essentially calculates floor(log2(x)) for each element.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getexp_round_pd&expand=2847)_mm512_mask_getexp_round_pd/// Convert the exponent of each packed double-precision (64-bit) floating-point element in a to a double-precision (64-bit) floating-point number representing the integer exponent, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getexp_round_pd&expand=2848)_mm512_maskz_getexp_round_pd/// Convert the exponent of each packed double-precision (64-bit) floating-point element in a to a double-precision (64-bit) floating-point number representing the integer exponent, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). This intrinsic essentially calculates floor(log2(x)) for each element.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getexp_round_pd&expand=2849)_mm512_roundscale_round_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_roundscale_round_ps&expand=4790)_mm512_mask_roundscale_round_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_roundscale_round_ps&expand=4788)_mm512_maskz_roundscale_round_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_roundscale_round_ps&expand=4789)_mm512_roundscale_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_roundscale_round_pd&expand=4787)_mm512_mask_roundscale_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_roundscale_round_pd&expand=4785)_mm512_maskz_roundscale_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_roundscale_round_pd&expand=4786)_mm512_scalef_round_ps/// Scale the packed single-precision (32-bit) floating-point elements in a using values from b, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_scalef_round_ps&expand=4889)_mm512_mask_scalef_round_ps/// Scale the packed single-precision (32-bit) floating-point elements in a using values from b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_scalef_round_ps&expand=4887)_mm512_maskz_scalef_round_ps/// Scale the packed single-precision (32-bit) floating-point elements in a using values from b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_scalef_round_ps&expand=4888)_mm512_scalef_round_pd/// Scale the packed double-precision (64-bit) floating-point elements in a using values from b, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_scalef_round_pd&expand=4886)_mm512_mask_scalef_round_pd/// Scale the packed double-precision (64-bit) floating-point elements in a using values from b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_scalef_round_pd&expand=4884)_mm512_maskz_scalef_round_pd/// Scale the packed double-precision (64-bit) floating-point elements in a using values from b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_scalef_round_pd&expand=4885)_mm512_fixupimm_round_ps/// Fix up packed single-precision (32-bit) floating-point elements in a and b using packed 32-bit integers in c, and store the results in dst. imm8 is used to set the required flags reporting.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fixupimm_round_ps&expand=2505)_mm512_mask_fixupimm_round_ps/// Fix up packed single-precision (32-bit) floating-point elements in a and b using packed 32-bit integers in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set). imm8 is used to set the required flags reporting.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fixupimm_round_ps&expand=2506)_mm512_maskz_fixupimm_round_ps/// Fix up packed single-precision (32-bit) floating-point elements in a and b using packed 32-bit integers in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). imm8 is used to set the required flags reporting.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fixupimm_round_ps&expand=2507)_mm512_fixupimm_round_pd/// Fix up packed double-precision (64-bit) floating-point elements in a and b using packed 64-bit integers in c, and store the results in dst. imm8 is used to set the required flags reporting.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_fixupimm_round_pd&expand=2502)_mm512_mask_fixupimm_round_pd/// Fix up packed double-precision (64-bit) floating-point elements in a and b using packed 64-bit integers in c, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set). imm8 is used to set the required flags reporting.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_fixupimm_round_pd&expand=2503)_mm512_maskz_fixupimm_round_pd/// Fix up packed double-precision (64-bit) floating-point elements in a and b using packed 64-bit integers in c, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set). imm8 is used to set the required flags reporting.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_fixupimm_round_pd&expand=2504)_mm512_getmant_round_ps/// Normalize the mantissas of packed single-precision (32-bit) floating-point elements in a, and store the results in dst. This intrinsic essentially calculates ±(2^k)*|x.significand|, where k depends on the interval range defined by interv and the sign depends on sc and the source sign.\///    _MM_MANT_SIGN_nan     // dst = NaN if sign(src) = 1\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getmant_round_ps&expand=2886)_mm512_mask_getmant_round_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getmant_round_ps&expand=2887)_mm512_maskz_getmant_round_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getmant_round_ps&expand=2888)_mm512_getmant_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_getmant_round_pd&expand=2883)_mm512_mask_getmant_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_getmant_round_pd&expand=2884)_mm512_maskz_getmant_round_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_getmant_round_pd&expand=2885)_mm512_cvtps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtps_epi32&expand=1737)_mm512_mask_cvtps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtps_epi32&expand=1738)_mm512_maskz_cvtps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtps_epi32&expand=1739)_mm256_mask_cvtps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtps_epi32&expand=1735)_mm256_maskz_cvtps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtps_epi32&expand=1736)_mm_mask_cvtps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtps_epi32&expand=1732)_mm_maskz_cvtps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtps_epi32&expand=1733)_mm512_cvtps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtps_epu32&expand=1755)_mm512_mask_cvtps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtps_epu32&expand=1756)_mm512_maskz_cvtps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtps_epu32&expand=1343)_mm256_cvtps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtps_epu32&expand=1752)_mm256_mask_cvtps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtps_epu32&expand=1753)_mm256_maskz_cvtps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtps_epu32&expand=1754)_mm_cvtps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_epu32&expand=1749)_mm_mask_cvtps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtps_epu32&expand=1750)_mm_maskz_cvtps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtps_epu32&expand=1751)_mm512_cvtps_pd/// Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtps_pd&expand=1769)_mm512_mask_cvtps_pd/// Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtps_pd&expand=1770)_mm512_maskz_cvtps_pd/// Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtps_pd&expand=1771)_mm512_cvtpslo_pd/// Performs element-by-element conversion of the lower half of packed single-precision (32-bit) floating-point elements in v2 to packed double-precision (64-bit) floating-point elements, storing the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpslo_pd&expand=1784)_mm512_mask_cvtpslo_pd/// Performs element-by-element conversion of the lower half of packed single-precision (32-bit) floating-point elements in v2 to packed double-precision (64-bit) floating-point elements, storing the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpslo_pd&expand=1785)_mm512_cvtpd_ps/// Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpd_ps&expand=1712)_mm512_mask_cvtpd_ps/// Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpd_ps&expand=1713)_mm512_maskz_cvtpd_ps/// Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtpd_ps&expand=1714)_mm256_mask_cvtpd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtpd_ps&expand=1710)_mm256_maskz_cvtpd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtpd_ps&expand=1711)_mm_mask_cvtpd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtpd_ps&expand=1707)_mm_maskz_cvtpd_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtpd_ps&expand=1708)_mm512_cvtpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpd_epi32&expand=1675)_mm512_mask_cvtpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpd_epi32&expand=1676)_mm512_maskz_cvtpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtpd_epi32&expand=1677)_mm256_mask_cvtpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtpd_epi32&expand=1673)_mm256_maskz_cvtpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtpd_epi32&expand=1674)_mm_mask_cvtpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtpd_epi32&expand=1670)_mm_maskz_cvtpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtpd_epi32&expand=1671)_mm512_cvtpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpd_epu32&expand=1693)_mm512_mask_cvtpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpd_epu32&expand=1694)_mm512_maskz_cvtpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtpd_epu32&expand=1695)_mm256_cvtpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtpd_epu32&expand=1690)_mm256_mask_cvtpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtpd_epu32&expand=1691)_mm256_maskz_cvtpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtpd_epu32&expand=1692)_mm_cvtpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpd_epu32&expand=1687)_mm_mask_cvtpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtpd_epu32&expand=1688)_mm_maskz_cvtpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtpd_epu32&expand=1689)_mm512_cvtpd_pslo/// Performs an element-by-element conversion of packed double-precision (64-bit) floating-point elements in v2 to single-precision (32-bit) floating-point elements and stores them in dst. The elements are stored in the lower half of the results vector, while the remaining upper half locations are set to 0./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtpd_pslo&expand=1715)_mm512_mask_cvtpd_pslo/// Performs an element-by-element conversion of packed double-precision (64-bit) floating-point elements in v2 to single-precision (32-bit) floating-point elements and stores them in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). The elements are stored in the lower half of the results vector, while the remaining upper half locations are set to 0./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtpd_pslo&expand=1716)_mm512_cvtepi8_epi32/// Sign extend packed 8-bit integers in a to packed 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi8_epi32&expand=1535)_mm512_mask_cvtepi8_epi32/// Sign extend packed 8-bit integers in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi8_epi32&expand=1536)_mm512_maskz_cvtepi8_epi32/// Sign extend packed 8-bit integers in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi8_epi32&expand=1537)_mm256_mask_cvtepi8_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi8_epi32&expand=1533)_mm256_maskz_cvtepi8_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi8_epi32&expand=1534)_mm_mask_cvtepi8_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi8_epi32&expand=1530)_mm_maskz_cvtepi8_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi8_epi32&expand=1531)_mm512_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi8_epi64&expand=1544)_mm512_mask_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi8_epi64&expand=1545)_mm512_maskz_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi8_epi64&expand=1546)_mm256_mask_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 4 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi8_epi64&expand=1542)_mm256_maskz_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 4 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi8_epi64&expand=1543)_mm_mask_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 2 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi8_epi64&expand=1539)_mm_maskz_cvtepi8_epi64/// Sign extend packed 8-bit integers in the low 2 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi8_epi64&expand=1540)_mm512_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in a to packed 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu8_epi32&expand=1621)_mm512_mask_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu8_epi32&expand=1622)_mm512_maskz_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu8_epi32&expand=1623)_mm256_mask_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in the low 8 bytes of a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu8_epi32&expand=1619)_mm256_maskz_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in the low 8 bytes of a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/IntrinsicsGuide/#text=_mm256_maskz_cvtepu8_epi32&expand=1620)_mm_mask_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in the low 4 bytes of a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu8_epi32&expand=1616)_mm_maskz_cvtepu8_epi32/// Zero extend packed unsigned 8-bit integers in th elow 4 bytes of a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/IntrinsicsGuide/#text=_mm_maskz_cvtepu8_epi32&expand=1617)_mm512_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 8 byte sof a to packed 64-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu8_epi64&expand=1630)_mm512_mask_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu8_epi64&expand=1631)_mm512_maskz_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu8_epi64&expand=1632)_mm256_mask_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 4 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu8_epi64&expand=1628)_mm256_maskz_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 4 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu8_epi64&expand=1629)_mm_mask_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 2 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu8_epi64&expand=1625)_mm_maskz_cvtepu8_epi64/// Zero extend packed unsigned 8-bit integers in the low 2 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu8_epi64&expand=1626)_mm512_cvtepi16_epi32/// Sign extend packed 16-bit integers in a to packed 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi16_epi32&expand=1389)_mm512_mask_cvtepi16_epi32/// Sign extend packed 16-bit integers in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi16_epi32&expand=1390)_mm512_maskz_cvtepi16_epi32/// Sign extend packed 16-bit integers in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi16_epi32&expand=1391)_mm256_mask_cvtepi16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi16_epi32&expand=1387)_mm256_maskz_cvtepi16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi16_epi32&expand=1388)_mm_mask_cvtepi16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi16_epi32&expand=1384)_mm_maskz_cvtepi16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi16_epi32&expand=1385)_mm512_cvtepi16_epi64/// Sign extend packed 16-bit integers in a to packed 64-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi16_epi64&expand=1398)_mm512_mask_cvtepi16_epi64/// Sign extend packed 16-bit integers in a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi16_epi64&expand=1399)_mm512_maskz_cvtepi16_epi64/// Sign extend packed 16-bit integers in a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi16_epi64&expand=1400)_mm256_mask_cvtepi16_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi16_epi64&expand=1396)_mm256_maskz_cvtepi16_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi16_epi64&expand=1397)_mm_mask_cvtepi16_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi16_epi64&expand=1393)_mm_maskz_cvtepi16_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi16_epi64&expand=1394)_mm512_cvtepu16_epi32/// Zero extend packed unsigned 16-bit integers in a to packed 32-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu16_epi32&expand=1553)_mm512_mask_cvtepu16_epi32/// Zero extend packed unsigned 16-bit integers in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu16_epi32&expand=1554)_mm512_maskz_cvtepu16_epi32/// Zero extend packed unsigned 16-bit integers in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu16_epi32&expand=1555)_mm256_mask_cvtepu16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu16_epi32&expand=1551)_mm256_maskz_cvtepu16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu16_epi32&expand=1552)_mm_mask_cvtepu16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu16_epi32&expand=1548)_mm_maskz_cvtepu16_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu16_epi32&expand=1549)_mm512_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in a to packed 64-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu16_epi64&expand=1562)_mm512_mask_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu16_epi64&expand=1563)_mm512_maskz_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu16_epi64&expand=1564)_mm256_mask_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu16_epi64&expand=1560)_mm256_maskz_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu16_epi64&expand=1561)_mm_mask_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in the low 4 bytes of a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu16_epi64&expand=1557)_mm_maskz_cvtepu16_epi64/// Zero extend packed unsigned 16-bit integers in the low 4 bytes of a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu16_epi64&expand=1558)_mm512_cvtepi32_epi64/// Sign extend packed 32-bit integers in a to packed 64-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi32_epi64&expand=1428)_mm512_mask_cvtepi32_epi64/// Sign extend packed 32-bit integers in a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi32_epi64&expand=1429)_mm512_maskz_cvtepi32_epi64/// Sign extend packed 32-bit integers in a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi32_epi64&expand=1430)_mm256_mask_cvtepi32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi32_epi64&expand=1426)_mm256_maskz_cvtepi32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi32_epi64&expand=1427)_mm_mask_cvtepi32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi32_epi64&expand=1423)_mm_maskz_cvtepi32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi32_epi64&expand=1424)_mm512_cvtepu32_epi64/// Zero extend packed unsigned 32-bit integers in a to packed 64-bit integers, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu32_epi64&expand=1571)_mm512_mask_cvtepu32_epi64/// Zero extend packed unsigned 32-bit integers in a to packed 64-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu32_epi64&expand=1572)_mm512_maskz_cvtepu32_epi64/// Zero extend packed unsigned 32-bit integers in a to packed 64-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu32_epi64&expand=1573)_mm256_mask_cvtepu32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu32_epi64&expand=1569)_mm256_maskz_cvtepu32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu32_epi64&expand=1570)_mm_mask_cvtepu32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu32_epi64&expand=1566)_mm_maskz_cvtepu32_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu32_epi64&expand=1567)_mm512_cvtepi32_ps/// Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi32_ps&expand=1455)_mm512_mask_cvtepi32_ps/// Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi32_ps&expand=1456)_mm512_maskz_cvtepi32_ps/// Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi32_ps&expand=1457)_mm256_mask_cvtepi32_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi32_ps&expand=1453)_mm256_maskz_cvtepi32_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi32_ps&expand=1454)_mm_mask_cvtepi32_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi32_ps&expand=1450)_mm_maskz_cvtepi32_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi32_ps&expand=1451)_mm512_cvtepi32_pd/// Convert packed signed 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi32_pd&expand=1446)_mm512_mask_cvtepi32_pd/// Convert packed signed 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi32_pd&expand=1447)_mm512_maskz_cvtepi32_pd/// Convert packed signed 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi32_pd&expand=1448)_mm256_mask_cvtepi32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi32_pd&expand=1444)_mm256_maskz_cvtepi32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi32_pd&expand=1445)_mm_mask_cvtepi32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi32_pd&expand=1441)_mm_maskz_cvtepi32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi32_pd&expand=1442)_mm512_cvtepu32_ps/// Convert packed unsigned 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu32_ps&expand=1583)_mm512_mask_cvtepu32_ps/// Convert packed unsigned 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu32_ps&expand=1584)_mm512_maskz_cvtepu32_ps/// Convert packed unsigned 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu32_ps&expand=1585)_mm512_cvtepu32_pd/// Convert packed unsigned 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu32_pd&expand=1580)_mm512_mask_cvtepu32_pd/// Convert packed unsigned 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu32_pd&expand=1581)_mm512_maskz_cvtepu32_pd/// Convert packed unsigned 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepu32_pd&expand=1582)_mm256_cvtepu32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepu32_pd&expand=1577)_mm256_mask_cvtepu32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepu32_pd&expand=1578)_mm256_maskz_cvtepu32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepu32_pd&expand=1579)_mm_cvtepu32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu32_pd&expand=1574)_mm_mask_cvtepu32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepu32_pd&expand=1575)_mm_maskz_cvtepu32_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepu32_pd&expand=1576)_mm512_cvtepi32lo_pd/// Performs element-by-element conversion of the lower half of packed 32-bit integer elements in v2 to packed double-precision (64-bit) floating-point elements, storing the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi32lo_pd&expand=1464)_mm512_mask_cvtepi32lo_pd/// Performs element-by-element conversion of the lower half of packed 32-bit integer elements in v2 to packed double-precision (64-bit) floating-point elements, storing the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi32lo_pd&expand=1465)_mm512_cvtepu32lo_pd/// Performs element-by-element conversion of the lower half of packed 32-bit unsigned integer elements in v2 to packed double-precision (64-bit) floating-point elements, storing the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepu32lo_pd&expand=1586)_mm512_mask_cvtepu32lo_pd/// Performs element-by-element conversion of the lower half of 32-bit unsigned integer elements in v2 to packed double-precision (64-bit) floating-point elements, storing the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepu32lo_pd&expand=1587)_mm512_cvtepi32_epi16/// Convert packed 32-bit integers in a to packed 16-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi32_epi16&expand=1419)_mm512_mask_cvtepi32_epi16/// Convert packed 32-bit integers in a to packed 16-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi32_epi16&expand=1420)_mm512_maskz_cvtepi32_epi16/// Convert packed 32-bit integers in a to packed 16-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi32_epi16&expand=1421)_mm256_cvtepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi32_epi16&expand=1416)_mm256_mask_cvtepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi32_epi16&expand=1417)_mm256_maskz_cvtepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi32_epi16&expand=1418)_mm_cvtepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi32_epi16&expand=1413)_mm_mask_cvtepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi32_epi16&expand=1414)_mm_maskz_cvtepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi32_epi16&expand=1415)_mm512_cvtepi32_epi8/// Convert packed 32-bit integers in a to packed 8-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi32_epi8&expand=1437)_mm512_mask_cvtepi32_epi8/// Convert packed 32-bit integers in a to packed 8-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi32_epi8&expand=1438)_mm512_maskz_cvtepi32_epi8/// Convert packed 32-bit integers in a to packed 8-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi32_epi8&expand=1439)_mm256_cvtepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi32_epi8&expand=1434)_mm256_mask_cvtepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi32_epi8&expand=1435)_mm256_maskz_cvtepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi32_epi8&expand=1436)_mm_cvtepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi32_epi8&expand=1431)_mm_mask_cvtepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi32_epi8&expand=1432)_mm_maskz_cvtepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi32_epi8&expand=1433)_mm512_cvtepi64_epi32/// Convert packed 64-bit integers in a to packed 32-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi64_epi32&expand=1481)_mm512_mask_cvtepi64_epi32/// Convert packed 64-bit integers in a to packed 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi64_epi32&expand=1482)_mm512_maskz_cvtepi64_epi32/// Convert packed 64-bit integers in a to packed 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi64_epi32&expand=1483)_mm256_cvtepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi64_epi32&expand=1478)_mm256_mask_cvtepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi64_epi32&expand=1479)_mm256_maskz_cvtepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi64_epi32&expand=1480)_mm_cvtepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi64_epi32&expand=1475)_mm_mask_cvtepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi64_epi32&expand=1476)_mm_maskz_cvtepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi64_epi32&expand=1477)_mm512_cvtepi64_epi16/// Convert packed 64-bit integers in a to packed 16-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi64_epi16&expand=1472)_mm512_mask_cvtepi64_epi16/// Convert packed 64-bit integers in a to packed 16-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi64_epi16&expand=1473)_mm512_maskz_cvtepi64_epi16/// Convert packed 64-bit integers in a to packed 16-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi64_epi16&expand=1474)_mm256_cvtepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi64_epi16&expand=1469)_mm256_mask_cvtepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi64_epi16&expand=1470)_mm256_maskz_cvtepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi64_epi16&expand=1471)_mm_cvtepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi64_epi16&expand=1466)_mm_mask_cvtepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi64_epi16&expand=1467)_mm_maskz_cvtepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi64_epi16&expand=1468)_mm512_cvtepi64_epi8/// Convert packed 64-bit integers in a to packed 8-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtepi64_epi8&expand=1490)_mm512_mask_cvtepi64_epi8/// Convert packed 64-bit integers in a to packed 8-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtepi64_epi8&expand=1491)_mm512_maskz_cvtepi64_epi8/// Convert packed 64-bit integers in a to packed 8-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtepi64_epi8&expand=1492)_mm256_cvtepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtepi64_epi8&expand=1487)_mm256_mask_cvtepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtepi64_epi8&expand=1488)_mm256_maskz_cvtepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtepi64_epi8&expand=1489)_mm_cvtepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi64_epi8&expand=1484)_mm_mask_cvtepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtepi64_epi8&expand=1485)_mm_maskz_cvtepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtepi64_epi8&expand=1486)_mm512_cvtsepi32_epi16/// Convert packed signed 32-bit integers in a to packed 16-bit integers with signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsepi32_epi16&expand=1819)_mm512_mask_cvtsepi32_epi16/// Convert packed signed 32-bit integers in a to packed 16-bit integers with signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi32_epi16&expand=1820)_mm512_maskz_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtsepi32_epi16&expand=1819)_mm256_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsepi32_epi16&expand=1816)_mm256_mask_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi32_epi16&expand=1817)_mm256_maskz_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtsepi32_epi16&expand=1818)_mm_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsepi32_epi16&expand=1813)_mm_mask_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi32_epi16&expand=1814)_mm_maskz_cvtsepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtsepi32_epi16&expand=1815)_mm512_cvtsepi32_epi8/// Convert packed signed 32-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsepi32_epi8&expand=1828)_mm512_mask_cvtsepi32_epi8/// Convert packed signed 32-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi32_epi8&expand=1829)_mm512_maskz_cvtsepi32_epi8/// Convert packed signed 32-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtsepi32_epi8&expand=1830)_mm256_cvtsepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsepi32_epi8&expand=1825)_mm256_mask_cvtsepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi32_epi8&expand=1826)_mm256_maskz_cvtsepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtsepi32_epi8&expand=1827)_mm_cvtsepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsepi32_epi8&expand=1822)_mm_mask_cvtsepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi32_epi8&expand=1823)_mm_maskz_cvtsepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtsepi32_epi8&expand=1824)_mm512_cvtsepi64_epi32/// Convert packed signed 64-bit integers in a to packed 32-bit integers with signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsepi64_epi32&expand=1852)_mm512_mask_cvtsepi64_epi32/// Convert packed signed 64-bit integers in a to packed 32-bit integers with signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi64_epi32&expand=1853)_mm512_maskz_cvtsepi64_epi32/// Convert packed signed 64-bit integers in a to packed 32-bit integers with signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtsepi64_epi32&expand=1854)_mm256_cvtsepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsepi64_epi32&expand=1849)_mm256_mask_cvtsepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi64_epi32&expand=1850)_mm256_maskz_cvtsepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtsepi64_epi32&expand=1851)_mm_cvtsepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsepi64_epi32&expand=1846)_mm_mask_cvtsepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi64_epi32&expand=1847)_mm_maskz_cvtsepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtsepi64_epi32&expand=1848)_mm512_cvtsepi64_epi16/// Convert packed signed 64-bit integers in a to packed 16-bit integers with signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsepi64_epi16&expand=1843)_mm512_mask_cvtsepi64_epi16/// Convert packed signed 64-bit integers in a to packed 16-bit integers with signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi64_epi16&expand=1844)_mm512_maskz_cvtsepi64_epi16/// Convert packed signed 64-bit integers in a to packed 16-bit integers with signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtsepi64_epi16&expand=1845)_mm256_cvtsepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsepi64_epi16&expand=1840)_mm256_mask_cvtsepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi64_epi16&expand=1841)_mm256_maskz_cvtsepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtsepi64_epi16&expand=1842)_mm_cvtsepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsepi64_epi16&expand=1837)_mm_mask_cvtsepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi64_epi16&expand=1838)_mm_maskz_cvtsepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtsepi64_epi16&expand=1839)_mm512_cvtsepi64_epi8/// Convert packed signed 64-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsepi64_epi8&expand=1861)_mm512_mask_cvtsepi64_epi8/// Convert packed signed 64-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtsepi64_epi8&expand=1862)_mm512_maskz_cvtsepi64_epi8/// Convert packed signed 64-bit integers in a to packed 8-bit integers with signed saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtsepi64_epi8&expand=1863)_mm256_cvtsepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtsepi64_epi8&expand=1858)_mm256_mask_cvtsepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtsepi64_epi8&expand=1859)_mm256_maskz_cvtsepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtsepi64_epi8&expand=1860)_mm_cvtsepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsepi64_epi8&expand=1855)_mm_mask_cvtsepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtsepi64_epi8&expand=1856)_mm_maskz_cvtsepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtsepi64_epi8&expand=1857)_mm512_cvtusepi32_epi16/// Convert packed unsigned 32-bit integers in a to packed unsigned 16-bit integers with unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtusepi32_epi16&expand=2054)_mm512_mask_cvtusepi32_epi16/// Convert packed unsigned 32-bit integers in a to packed unsigned 16-bit integers with unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi32_epi16&expand=2055)_mm512_maskz_cvtusepi32_epi16/// Convert packed unsigned 32-bit integers in a to packed unsigned 16-bit integers with unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtusepi32_epi16&expand=2056)_mm256_cvtusepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtusepi32_epi16&expand=2051)_mm256_mask_cvtusepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi32_epi16&expand=2052)_mm256_maskz_cvtusepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtusepi32_epi16&expand=2053)_mm_cvtusepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtusepi32_epi16&expand=2048)_mm_mask_cvtusepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi32_epi16&expand=2049)_mm_maskz_cvtusepi32_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtusepi32_epi16&expand=2050)_mm512_cvtusepi32_epi8/// Convert packed unsigned 32-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtusepi32_epi8&expand=2063)_mm512_mask_cvtusepi32_epi8/// Convert packed unsigned 32-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi32_epi8&expand=2064)_mm512_maskz_cvtusepi32_epi8/// Convert packed unsigned 32-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtusepi32_epi8&expand=2065)_mm256_cvtusepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtusepi32_epi8&expand=2060)_mm256_mask_cvtusepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi32_epi8&expand=2061)_mm256_maskz_cvtusepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtusepi32_epi8&expand=2062)_mm_cvtusepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtusepi32_epi8&expand=2057)_mm_mask_cvtusepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi32_epi8&expand=2058)_mm_maskz_cvtusepi32_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtusepi32_epi8&expand=2059)_mm512_cvtusepi64_epi32/// Convert packed unsigned 64-bit integers in a to packed unsigned 32-bit integers with unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtusepi64_epi32&expand=2087)_mm512_mask_cvtusepi64_epi32/// Convert packed unsigned 64-bit integers in a to packed unsigned 32-bit integers with unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi64_epi32&expand=2088)_mm512_maskz_cvtusepi64_epi32/// Convert packed unsigned 64-bit integers in a to packed unsigned 32-bit integers with unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtusepi64_epi32&expand=2089)_mm256_cvtusepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtusepi64_epi32&expand=2084)_mm256_mask_cvtusepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi64_epi32&expand=2085)_mm256_maskz_cvtusepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtusepi64_epi32&expand=2086)_mm_cvtusepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtusepi64_epi32&expand=2081)_mm_mask_cvtusepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi64_epi32&expand=2082)_mm_maskz_cvtusepi64_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtusepi64_epi32&expand=2083)_mm512_cvtusepi64_epi16/// Convert packed unsigned 64-bit integers in a to packed unsigned 16-bit integers with unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtusepi64_epi16&expand=2078)_mm512_mask_cvtusepi64_epi16/// Convert packed unsigned 64-bit integers in a to packed unsigned 16-bit integers with unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi64_epi16&expand=2079)_mm512_maskz_cvtusepi64_epi16/// Convert packed unsigned 64-bit integers in a to packed unsigned 16-bit integers with unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtusepi64_epi16&expand=2080)_mm256_cvtusepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtusepi64_epi16&expand=2075)_mm256_mask_cvtusepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi64_epi16&expand=2076)_mm256_maskz_cvtusepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtusepi64_epi16&expand=2077)_mm_cvtusepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtusepi64_epi16&expand=2072)_mm_mask_cvtusepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi64_epi16&expand=2073)_mm_maskz_cvtusepi64_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtusepi64_epi16&expand=2074)_mm512_cvtusepi64_epi8/// Convert packed unsigned 64-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtusepi64_epi8&expand=2096)_mm512_mask_cvtusepi64_epi8/// Convert packed unsigned 64-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtusepi64_epi8&expand=2097)_mm512_maskz_cvtusepi64_epi8/// Convert packed unsigned 64-bit integers in a to packed unsigned 8-bit integers with unsigned saturation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtusepi64_epi8&expand=2098)_mm256_cvtusepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvtusepi64_epi8&expand=2093)_mm256_mask_cvtusepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtusepi64_epi8&expand=2094)_mm256_maskz_cvtusepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtusepi64_epi8&expand=2095)_mm_cvtusepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtusepi64_epi8&expand=2090)_mm_mask_cvtusepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtusepi64_epi8&expand=2091)_mm_maskz_cvtusepi64_epi8/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtusepi64_epi8&expand=2092)_mm512_cvt_roundps_epi32/// Rounding is done according to the rounding\[3:0\] parameter, which can be one of:/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundps_epi32&expand=1335)_mm512_mask_cvt_roundps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundps_epi32&expand=1336)_mm512_maskz_cvt_roundps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundps_epi32&expand=1337)_mm512_cvt_roundps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundps_epu32&expand=1341)_mm512_mask_cvt_roundps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundps_epu32&expand=1342)_mm512_maskz_cvt_roundps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundps_epu32&expand=1343)_mm512_cvt_roundps_pd/// Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundps_pd&expand=1347)_mm512_mask_cvt_roundps_pd/// Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundps_pd&expand=1336)_mm512_maskz_cvt_roundps_pd/// Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundps_pd&expand=1337)_mm512_cvt_roundpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundpd_epi32&expand=1315)_mm512_mask_cvt_roundpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundpd_epi32&expand=1316)_mm512_maskz_cvt_roundpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/IntrinsicsGuide/#text=_mm512_maskz_cvt_roundpd_epi32&expand=1317)_mm512_cvt_roundpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundpd_epu32&expand=1321)_mm512_mask_cvt_roundpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundpd_epu32&expand=1322)_mm512_maskz_cvt_roundpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/IntrinsicsGuide/#text=_mm512_maskz_cvt_roundpd_epu32&expand=1323)_mm512_cvt_roundpd_ps/// Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundpd_ps&expand=1327)_mm512_mask_cvt_roundpd_ps/// Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundpd_ps&expand=1328)_mm512_maskz_cvt_roundpd_ps/// Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundpd_ps&expand=1329)_mm512_cvt_roundepi32_ps/// Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundepi32_ps&expand=1294)_mm512_mask_cvt_roundepi32_ps/// Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundepi32_ps&expand=1295)_mm512_maskz_cvt_roundepi32_ps/// Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundepi32_ps&expand=1296)_mm512_cvt_roundepu32_ps/// Convert packed unsigned 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundepu32_ps&expand=1303)_mm512_mask_cvt_roundepu32_ps/// Convert packed unsigned 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundepu32_ps&expand=1304)_mm512_maskz_cvt_roundepu32_ps/// Convert packed unsigned 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundepu32_ps&expand=1305)_mm512_cvt_roundps_ph/// Convert packed single-precision (32-bit) floating-point elements in a to packed half-precision (16-bit) floating-point elements, and store the results in dst.\///  * [`_MM_FROUND_TO_NEAREST_INT`] // round to nearest///  * [`_MM_FROUND_TO_NEG_INF`]     // round down///  * [`_MM_FROUND_TO_POS_INF`]    // round up///  * [`_MM_FROUND_TO_ZERO`]        // truncate///  * [`_MM_FROUND_CUR_DIRECTION`]    // use MXCSR.RC; see [`_MM_SET_ROUNDING_MODE`]///  * [`_MM_FROUND_TO_NEAREST_INT`] | [`_MM_FROUND_NO_EXC`] // round to nearest, and suppress exceptions///  * [`_MM_FROUND_TO_NEG_INF`] | [`_MM_FROUND_NO_EXC`]     // round down, and suppress exceptions///  * [`_MM_FROUND_TO_POS_INF`] | [`_MM_FROUND_NO_EXC`]     // round up, and suppress exceptions///  * [`_MM_FROUND_TO_ZERO`] | [`_MM_FROUND_NO_EXC`]        // truncate, and suppress exceptions///  * [`_MM_FROUND_CUR_DIRECTION`] | [`_MM_FROUND_NO_EXC`]  // use MXCSR.RC and suppress exceptions; see [`_MM_SET_ROUNDING_MODE`]/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundps_ph&expand=1354)_mm512_mask_cvt_roundps_ph/// Convert packed single-precision (32-bit) floating-point elements in a to packed half-precision (16-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundps_ph&expand=1355)_mm512_maskz_cvt_roundps_ph/// Convert packed single-precision (32-bit) floating-point elements in a to packed half-precision (16-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundps_ph&expand=1356)_mm256_mask_cvt_roundps_ph/// Rounding is done according to the imm8\[2:0\] parameter, which can be one of:/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvt_roundps_ph&expand=1352)_mm256_maskz_cvt_roundps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvt_roundps_ph&expand=1353)_mm_mask_cvt_roundps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvt_roundps_ph&expand=1350)_mm_maskz_cvt_roundps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvt_roundps_ph&expand=1351)_mm512_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtps_ph&expand=1778)_mm512_mask_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtps_ph&expand=1779)_mm512_maskz_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtps_ph&expand=1780)_mm256_mask_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtps_ph&expand=1776)_mm256_maskz_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtps_ph&expand=1777)_mm_mask_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtps_ph&expand=1773)_mm_maskz_cvtps_ph/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtps_ph&expand=1774)_mm512_cvt_roundph_ps/// Convert packed half-precision (16-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvt_roundph_ps&expand=1332)_mm512_mask_cvt_roundph_ps/// Convert packed half-precision (16-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvt_roundph_ps&expand=1333)_mm512_maskz_cvt_roundph_ps/// Convert packed half-precision (16-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvt_roundph_ps&expand=1334)_mm512_cvtph_ps/// Convert packed half-precision (16-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtph_ps&expand=1723)_mm512_mask_cvtph_ps/// Convert packed half-precision (16-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtph_ps&expand=1724)_mm512_maskz_cvtph_ps/// Convert packed half-precision (16-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtph_ps&expand=1725)_mm256_mask_cvtph_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvtph_ps&expand=1721)_mm256_maskz_cvtph_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvtph_ps&expand=1722)_mm_mask_cvtph_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvtph_ps&expand=1718)_mm_maskz_cvtph_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvtph_ps&expand=1719)_mm512_cvtt_roundps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundps_epi32&expand=1916)_mm512_mask_cvtt_roundps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundps_epi32&expand=1917)_mm512_maskz_cvtt_roundps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundps_epi32&expand=1918)_mm512_cvtt_roundps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundps_epu32&expand=1922)_mm512_mask_cvtt_roundps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundps_epu32&expand=1923)_mm512_maskz_cvtt_roundps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundps_epu32&expand=1924)_mm512_cvtt_roundpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundpd_epi32&expand=1904)_mm512_mask_cvtt_roundpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundpd_epi32&expand=1905)_mm512_maskz_cvtt_roundpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundpd_epi32&expand=1918)_mm512_cvtt_roundpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtt_roundpd_epu32&expand=1910)_mm512_mask_cvtt_roundpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvtt_roundpd_epu32&expand=1911)_mm512_cvttps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttps_epi32&expand=1984)_mm512_mask_cvttps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttps_epi32&expand=1985)_mm512_maskz_cvttps_epi32/// Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttps_epi32&expand=1986)_mm256_mask_cvttps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttps_epi32&expand=1982)_mm256_maskz_cvttps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttps_epi32&expand=1983)_mm_mask_cvttps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttps_epi32&expand=1979)_mm_maskz_cvttps_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttps_epi32&expand=1980)_mm512_cvttps_epu32/// Convert packed single-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttps_epu32&expand=2002)_mm512_mask_cvttps_epu32/// Convert packed double-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttps_epu32&expand=2003)_mm512_maskz_cvttps_epu32/// Convert packed double-precision (32-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttps_epu32&expand=2004)_mm256_cvttps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttps_epu32&expand=1999)_mm256_mask_cvttps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttps_epu32&expand=2000)_mm256_maskz_cvttps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttps_epu32&expand=2001)_mm_cvttps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttps_epu32&expand=1996)_mm_mask_cvttps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttps_epu32&expand=1997)_mm_maskz_cvttps_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttps_epu32&expand=1998)_mm512_maskz_cvtt_roundpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvtt_roundpd_epu32&expand=1912)_mm512_cvttpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttpd_epi32&expand=1947)_mm512_mask_cvttpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttpd_epi32&expand=1948)_mm512_maskz_cvttpd_epi32/// Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttpd_epi32&expand=1949)_mm256_mask_cvttpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttpd_epi32&expand=1945)_mm256_maskz_cvttpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttpd_epi32&expand=1946)_mm_mask_cvttpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttpd_epi32&expand=1942)_mm_maskz_cvttpd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttpd_epi32&expand=1943)_mm512_cvttpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvttpd_epu32&expand=1965)_mm512_mask_cvttpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cvttpd_epu32&expand=1966)_mm512_maskz_cvttpd_epu32/// Convert packed double-precision (64-bit) floating-point elements in a to packed unsigned 32-bit integers with truncation, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_cvttpd_epu32&expand=1967)_mm256_cvttpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cvttpd_epu32&expand=1962)_mm256_mask_cvttpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cvttpd_epu32&expand=1963)_mm256_maskz_cvttpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_cvttpd_epu32&expand=1964)_mm_cvttpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttpd_epu32&expand=1959)_mm_mask_cvttpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cvttpd_epu32&expand=1960)_mm_maskz_cvttpd_epu32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_cvttpd_epu32&expand=1961)_mm512_setzero_pd/// Returns vector of type `__m512d` with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setzero_pd&expand=5018)_mm512_setzero_ps/// Returns vector of type `__m512` with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setzero_ps&expand=5021)_mm512_setzero/// Return vector of type `__m512` with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setzero&expand=5014)_mm512_setzero_si512/// Returns vector of type `__m512i` with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setzero_si512&expand=5024)_mm512_setzero_epi32/// Return vector of type `__m512i` with all elements set to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setzero_epi32&expand=5015)_mm512_setr_epi32/// Sets packed 32-bit integers in `dst` with the supplied values in reverse/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr_epi32&expand=4991)_mm512_set_epi8/// Set packed 8-bit integers in dst with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set_epi8&expand=4915)_mm512_set_epi16/// Set packed 16-bit integers in dst with the supplied values./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set_epi16&expand=4905)_mm512_set4_epi32/// Set packed 32-bit integers in dst with the repeated 4 element sequence./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set4_epi32&expand=4982)_mm512_set4_ps/// Set packed single-precision (32-bit) floating-point elements in dst with the repeated 4 element sequence./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set4_ps&expand=4985)_mm512_set4_pd/// Set packed double-precision (64-bit) floating-point elements in dst with the repeated 4 element sequence./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set4_pd&expand=4984)_mm512_setr4_epi32/// Set packed 32-bit integers in dst with the repeated 4 element sequence in reverse order./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr4_epi32&expand=5009)_mm512_setr4_ps/// Set packed single-precision (32-bit) floating-point elements in dst with the repeated 4 element sequence in reverse order./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr4_ps&expand=5012)_mm512_setr4_pd/// Set packed double-precision (64-bit) floating-point elements in dst with the repeated 4 element sequence in reverse order./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr4_pd&expand=5011)_mm512_set_epi64/// Set packed 64-bit integers in dst with the supplied values./// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set_epi64&expand=4910)_mm512_setr_epi64/// Set packed 64-bit integers in dst with the supplied values in reverse order./// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr_epi64&expand=4993)_mm512_i32gather_pd/// Gather double-precision (64-bit) floating-point elements from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32gather_pd&expand=3002)_mm512_mask_i32gather_pd/// Gather double-precision (64-bit) floating-point elements from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32gather_pd&expand=3003)_mm512_i64gather_pd/// Gather double-precision (64-bit) floating-point elements from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64gather_pd&expand=3092)_mm512_mask_i64gather_pd/// Gather double-precision (64-bit) floating-point elements from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64gather_pd&expand=3093)_mm512_i64gather_ps/// Gather single-precision (32-bit) floating-point elements from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64gather_ps&expand=3100)_mm512_mask_i64gather_ps/// Gather single-precision (32-bit) floating-point elements from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64gather_ps&expand=3101)_mm512_i32gather_ps/// Gather single-precision (32-bit) floating-point elements from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32gather_ps&expand=3010)_mm512_mask_i32gather_ps/// Gather single-precision (32-bit) floating-point elements from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32gather_ps&expand=3011)_mm512_i32gather_epi32/// Gather 32-bit integers from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32gather_epi32&expand=2986)_mm512_mask_i32gather_epi32/// Gather 32-bit integers from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32gather_epi32&expand=2987)_mm512_i32gather_epi64/// Gather 64-bit integers from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32gather_epi64&expand=2994)_mm512_mask_i32gather_epi64/// Gather 64-bit integers from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32gather_epi64&expand=2995)_mm512_i64gather_epi64/// Gather 64-bit integers from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64gather_epi64&expand=3084)_mm512_mask_i64gather_epi64/// Gather 64-bit integers from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64gather_epi64&expand=3085)_mm512_i64gather_epi32/// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst. scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64gather_epi32&expand=3074)_mm512_mask_i64gather_epi32/// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). Gathered elements are merged into dst using writemask k (elements are copied from src when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64gather_epi32&expand=3075)_mm512_i32scatter_pd/// Scatter double-precision (64-bit) floating-point elements from a into memory using 32-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32scatter_pd&expand=3044)_mm512_mask_i32scatter_pd/// Scatter double-precision (64-bit) floating-point elements from a into memory using 32-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32scatter_pd&expand=3045)_mm512_i64scatter_pd/// Scatter double-precision (64-bit) floating-point elements from a into memory using 64-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64scatter_pd&expand=3122)_mm512_mask_i64scatter_pd/// Scatter double-precision (64-bit) floating-point elements from a into memory using 64-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64scatter_pd&expand=3123)_mm512_i32scatter_ps/// Scatter single-precision (32-bit) floating-point elements from a into memory using 32-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32scatter_ps&expand=3050)_mm512_mask_i32scatter_ps/// Scatter single-precision (32-bit) floating-point elements from a into memory using 32-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32scatter_ps&expand=3051)_mm512_i64scatter_ps/// Scatter single-precision (32-bit) floating-point elements from a into memory using 64-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64scatter_ps&expand=3128)_mm512_mask_i64scatter_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64scatter_ps&expand=3129)_mm512_i32scatter_epi64/// Scatter 64-bit integers from a into memory using 32-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32scatter_epi64&expand=3038)_mm512_mask_i32scatter_epi64/// Scatter 64-bit integers from a into memory using 32-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32scatter_epi64&expand=3039)_mm512_i64scatter_epi64/// Scatter 64-bit integers from a into memory using 64-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64scatter_epi64&expand=3116)_mm512_mask_i64scatter_epi64/// Scatter 64-bit integers from a into memory using 64-bit indices. 64-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64scatter_epi64&expand=3117)_mm512_i32scatter_epi32/// Scatter 32-bit integers from a into memory using 32-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i32scatter_epi32&expand=3032)_mm512_mask_i32scatter_epi32/// Scatter 32-bit integers from a into memory using 32-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 32-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i32scatter_epi32&expand=3033)_mm512_i64scatter_epi32/// Scatter 32-bit integers from a into memory using 64-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_i64scatter_epi32&expand=3108)_mm512_mask_i64scatter_epi32/// Scatter 32-bit integers from a into memory using 64-bit indices. 32-bit elements are stored at addresses starting at base_addr and offset by each 64-bit element in vindex (each index is scaled by the factor in scale) subject to mask k (elements are not stored when the corresponding mask bit is not set). scale should be 1, 2, 4 or 8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_i64scatter_epi32&expand=3109)_mm512_i32logather_epi64/// Loads 8 64-bit integer elements from memory starting at location base_addr at packed 32-bit integer/// indices stored in the lower half of vindex scaled by scale and stores them in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_i32logather_epi64)_mm512_mask_i32logather_epi64/// indices stored in the lower half of vindex scaled by scale and stores them in dst using writemask k/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_i32logather_epi64)_mm512_i32logather_pd/// Loads 8 double-precision (64-bit) floating-point elements from memory starting at location base_addr/// at packed 32-bit integer indices stored in the lower half of vindex scaled by scale and stores them in dst./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_i32logather_pd)_mm512_mask_i32logather_pd/// at packed 32-bit integer indices stored in the lower half of vindex scaled by scale and stores them in dst/// using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_i32logather_pd)_mm512_i32loscatter_epi64/// Stores 8 64-bit integer elements from a to memory starting at location base_addr at packed 32-bit integer/// indices stored in the lower half of vindex scaled by scale./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_i32loscatter_epi64)_mm512_mask_i32loscatter_epi64/// indices stored in the lower half of vindex scaled by scale using writemask k (elements whose corresponding/// mask bit is not set are not written to memory)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_i32loscatter_epi64)_mm512_i32loscatter_pd/// Stores 8 double-precision (64-bit) floating-point elements from a to memory starting at location base_addr/// at packed 32-bit integer indices stored in the lower half of vindex scaled by scale./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_i32loscatter_pd)_mm512_mask_i32loscatter_pd/// at packed 32-bit integer indices stored in the lower half of vindex scaled by scale using writemask k/// (elements whose corresponding mask bit is not set are not written to memory)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_i32loscatter_pd)_mm256_i32scatter_epi32/// Stores 8 32-bit integer elements from a to memory starting at location base_addr at packed 32-bit integer/// indices stored in vindex scaled by scale/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i32scatter_epi32)_mm256_mask_i32scatter_epi32/// indices stored in vindex scaled by scale using writemask k (elements whose corresponding mask bit is not set/// are not written to memory)./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i32scatter_epi32)_mm256_i32scatter_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_i32scatter_epi64&expand=4099)_mm256_mask_i32scatter_epi64/// Stores 4 64-bit integer elements from a to memory starting at location base_addr at packed 32-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i32scatter_epi64)_mm256_i32scatter_pd/// Stores 4 double-precision (64-bit) floating-point elements from a to memory starting at location base_addr/// at packed 32-bit integer indices stored in vindex scaled by scale/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i32scatter_pd)_mm256_mask_i32scatter_pd/// at packed 32-bit integer indices stored in vindex scaled by scale using writemask k (elements whose corresponding/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i32scatter_pd)_mm256_i32scatter_ps/// Stores 8 single-precision (32-bit) floating-point elements from a to memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i32scatter_ps)_mm256_mask_i32scatter_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i32scatter_ps)_mm256_i64scatter_epi32/// Stores 4 32-bit integer elements from a to memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i64scatter_epi32)_mm256_mask_i64scatter_epi32/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i64scatter_epi32)_mm256_i64scatter_epi64/// Stores 4 64-bit integer elements from a to memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i64scatter_epi64)_mm256_mask_i64scatter_epi64/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i64scatter_epi64)_mm256_i64scatter_pd/// at packed 64-bit integer indices stored in vindex scaled by scale/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i64scatter_pd)_mm256_mask_i64scatter_pd/// at packed 64-bit integer indices stored in vindex scaled by scale using writemask k (elements whose corresponding/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i64scatter_pd)_mm256_i64scatter_ps/// Stores 4 single-precision (32-bit) floating-point elements from a to memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_i64scatter_ps)_mm256_mask_i64scatter_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_i64scatter_ps)_mm256_mmask_i32gather_epi32/// Loads 8 32-bit integer elements from memory starting at location base_addr at packed 32-bit integer/// indices stored in vindex scaled by scale using writemask k (elements are copied from src when the corresponding/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i32gather_epi32)_mm256_mmask_i32gather_epi64/// Loads 4 64-bit integer elements from memory starting at location base_addr at packed 32-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i32gather_epi64)_mm256_mmask_i32gather_pd/// Loads 4 double-precision (64-bit) floating-point elements from memory starting at location base_addr/// at packed 32-bit integer indices stored in vindex scaled by scale using writemask k (elements are copied/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i32gather_pd)_mm256_mmask_i32gather_ps/// Loads 8 single-precision (32-bit) floating-point elements from memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i32gather_ps)_mm256_mmask_i64gather_epi32/// Loads 4 32-bit integer elements from memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i64gather_epi32)_mm256_mmask_i64gather_epi64/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i64gather_epi64)_mm256_mmask_i64gather_pd/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i64gather_pd)_mm256_mmask_i64gather_ps/// Loads 4 single-precision (32-bit) floating-point elements from memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mmask_i64gather_ps)_mm_i32scatter_epi32/// Stores 4 32-bit integer elements from a to memory starting at location base_addr at packed 32-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i32scatter_epi32)_mm_mask_i32scatter_epi32/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i32scatter_epi32)_mm_i32scatter_epi64/// Stores 2 64-bit integer elements from a to memory starting at location base_addr at packed 32-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i32scatter_epi64)_mm_mask_i32scatter_epi64/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i32scatter_epi64)_mm_i32scatter_pd/// Stores 2 double-precision (64-bit) floating-point elements from a to memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i32scatter_pd)_mm_mask_i32scatter_pd/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i32scatter_pd)_mm_i32scatter_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i32scatter_ps)_mm_mask_i32scatter_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i32scatter_ps)_mm_i64scatter_epi32/// Stores 2 32-bit integer elements from a to memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i64scatter_epi32)_mm_mask_i64scatter_epi32/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i64scatter_epi32)_mm_i64scatter_epi64/// Stores 2 64-bit integer elements from a to memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i64scatter_epi64)_mm_mask_i64scatter_epi64/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i64scatter_epi64)_mm_i64scatter_pd/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i64scatter_pd)_mm_mask_i64scatter_pd/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i64scatter_pd)_mm_i64scatter_ps/// Stores 2 single-precision (32-bit) floating-point elements from a to memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_i64scatter_ps)_mm_mask_i64scatter_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_i64scatter_ps)_mm_mmask_i32gather_epi32/// Loads 4 32-bit integer elements from memory starting at location base_addr at packed 32-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i32gather_epi32)_mm_mmask_i32gather_epi64/// Loads 2 64-bit integer elements from memory starting at location base_addr at packed 32-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i32gather_epi64)_mm_mmask_i32gather_pd/// Loads 2 double-precision (64-bit) floating-point elements from memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i32gather_pd)_mm_mmask_i32gather_ps/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i32gather_ps)_mm_mmask_i64gather_epi32/// Loads 2 32-bit integer elements from memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i64gather_epi32)_mm_mmask_i64gather_epi64/// Loads 2 64-bit integer elements from memory starting at location base_addr at packed 64-bit integer/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i64gather_epi64)_mm_mmask_i64gather_pd/// at packed 64-bit integer indices stored in vindex scaled by scale using writemask k (elements are copied/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i64gather_pd)_mm_mmask_i64gather_ps/// Loads 2 single-precision (32-bit) floating-point elements from memory starting at location base_addr/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mmask_i64gather_ps)_mm512_mask_compress_epi32/// Contiguously store the active 32-bit integers in a (those with their respective bit set in writemask k) to dst, and pass through the remaining elements from src./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compress_epi32&expand=1198)_mm512_maskz_compress_epi32/// Contiguously store the active 32-bit integers in a (those with their respective bit set in zeromask k) to dst, and set the remaining elements to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_compress_epi32&expand=1199)_mm256_mask_compress_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compress_epi32&expand=1196)_mm256_maskz_compress_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_compress_epi32&expand=1197)_mm_mask_compress_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compress_epi32&expand=1194)_mm_maskz_compress_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_compress_epi32&expand=1195)_mm512_mask_compress_epi64/// Contiguously store the active 64-bit integers in a (those with their respective bit set in writemask k) to dst, and pass through the remaining elements from src./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compress_epi64&expand=1204)_mm512_maskz_compress_epi64/// Contiguously store the active 64-bit integers in a (those with their respective bit set in zeromask k) to dst, and set the remaining elements to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_compress_epi64&expand=1205)_mm256_mask_compress_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compress_epi64&expand=1202)_mm256_maskz_compress_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_compress_epi64&expand=1203)_mm_mask_compress_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compress_epi64&expand=1200)_mm_maskz_compress_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_compress_epi64&expand=1201)_mm512_mask_compress_ps/// Contiguously store the active single-precision (32-bit) floating-point elements in a (those with their respective bit set in writemask k) to dst, and pass through the remaining elements from src./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compress_ps&expand=1222)_mm512_maskz_compress_ps/// Contiguously store the active single-precision (32-bit) floating-point elements in a (those with their respective bit set in zeromask k) to dst, and set the remaining elements to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_compress_ps&expand=1223)_mm256_mask_compress_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compress_ps&expand=1220)_mm256_maskz_compress_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_compress_ps&expand=1221)_mm_mask_compress_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compress_ps&expand=1218)_mm_maskz_compress_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_compress_ps&expand=1219)_mm512_mask_compress_pd/// Contiguously store the active double-precision (64-bit) floating-point elements in a (those with their respective bit set in writemask k) to dst, and pass through the remaining elements from src./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compress_pd&expand=1216)_mm512_maskz_compress_pd/// Contiguously store the active double-precision (64-bit) floating-point elements in a (those with their respective bit set in zeromask k) to dst, and set the remaining elements to zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_compress_pd&expand=1217)_mm256_mask_compress_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compress_pd&expand=1214)_mm256_maskz_compress_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_compress_pd&expand=1215)_mm_mask_compress_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compress_pd&expand=1212)_mm_maskz_compress_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_compress_pd&expand=1213)_mm512_mask_compressstoreu_epi32/// Contiguously store the active 32-bit integers in a (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compressstoreu_epi32)_mm256_mask_compressstoreu_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compressstoreu_epi32)_mm_mask_compressstoreu_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compressstoreu_epi32)_mm512_mask_compressstoreu_epi64/// Contiguously store the active 64-bit integers in a (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compressstoreu_epi64)_mm256_mask_compressstoreu_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compressstoreu_epi64)_mm_mask_compressstoreu_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compressstoreu_epi64)_mm512_mask_compressstoreu_ps/// Contiguously store the active single-precision (32-bit) floating-point elements in a (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compressstoreu_ps)_mm256_mask_compressstoreu_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compressstoreu_ps)_mm_mask_compressstoreu_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compressstoreu_ps)_mm512_mask_compressstoreu_pd/// Contiguously store the active double-precision (64-bit) floating-point elements in a (those with their respective bit set in writemask k) to unaligned memory at base_addr./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_compressstoreu_pd)_mm256_mask_compressstoreu_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_compressstoreu_pd)_mm_mask_compressstoreu_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_compressstoreu_pd)_mm512_mask_expand_epi32/// Load contiguous active 32-bit integers from a (those with their respective bit set in mask k), and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_expand_epi32&expand=2316)_mm512_maskz_expand_epi32/// Load contiguous active 32-bit integers from a (those with their respective bit set in mask k), and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_expand_epi32&expand=2317)_mm256_mask_expand_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_expand_epi32&expand=2314)_mm256_maskz_expand_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_expand_epi32&expand=2315)_mm_mask_expand_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_expand_epi32&expand=2312)_mm_maskz_expand_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_expand_epi32&expand=2313)_mm512_mask_expand_epi64/// Load contiguous active 64-bit integers from a (those with their respective bit set in mask k), and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_expand_epi64&expand=2322)_mm512_maskz_expand_epi64/// Load contiguous active 64-bit integers from a (those with their respective bit set in mask k), and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_expand_epi64&expand=2323)_mm256_mask_expand_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_expand_epi64&expand=2320)_mm256_maskz_expand_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_expand_epi64&expand=2321)_mm_mask_expand_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_expand_epi64&expand=2318)_mm_maskz_expand_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_expand_epi64&expand=2319)_mm512_mask_expand_ps/// Load contiguous active single-precision (32-bit) floating-point elements from a (those with their respective bit set in mask k), and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_expand_ps&expand=2340)_mm512_maskz_expand_ps/// Load contiguous active single-precision (32-bit) floating-point elements from a (those with their respective bit set in mask k), and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_expand_ps&expand=2341)_mm256_mask_expand_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_expand_ps&expand=2338)_mm256_maskz_expand_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_expand_ps&expand=2339)_mm_mask_expand_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_expand_ps&expand=2336)_mm_maskz_expand_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_expand_ps&expand=2337)_mm512_mask_expand_pd/// Load contiguous active double-precision (64-bit) floating-point elements from a (those with their respective bit set in mask k), and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_expand_pd&expand=2334)_mm512_maskz_expand_pd/// Load contiguous active double-precision (64-bit) floating-point elements from a (those with their respective bit set in mask k), and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_expand_pd&expand=2335)_mm256_mask_expand_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_expand_pd&expand=2332)_mm256_maskz_expand_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_expand_pd&expand=2333)_mm_mask_expand_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_expand_pd&expand=2330)_mm_maskz_expand_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_expand_pd&expand=2331)_mm512_rol_epi32/// Rotate the bits in each packed 32-bit integer in a to the left by the number of bits specified in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rol_epi32&expand=4685)_mm512_mask_rol_epi32/// Rotate the bits in each packed 32-bit integer in a to the left by the number of bits specified in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rol_epi32&expand=4683)_mm512_maskz_rol_epi32/// Rotate the bits in each packed 32-bit integer in a to the left by the number of bits specified in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rol_epi32&expand=4684)_mm256_rol_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rol_epi32&expand=4682)_mm256_mask_rol_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rol_epi32&expand=4680)_mm256_maskz_rol_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rol_epi32&expand=4681)_mm_rol_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rol_epi32&expand=4679)_mm_mask_rol_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rol_epi32&expand=4677)_mm_maskz_rol_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rol_epi32&expand=4678)_mm512_ror_epi32/// Rotate the bits in each packed 32-bit integer in a to the right by the number of bits specified in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_ror_epi32&expand=4721)_mm512_mask_ror_epi32/// Rotate the bits in each packed 32-bit integer in a to the right by the number of bits specified in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_ror_epi32&expand=4719)_mm512_maskz_ror_epi32/// Rotate the bits in each packed 32-bit integer in a to the right by the number of bits specified in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_ror_epi32&expand=4720)_mm256_ror_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_ror_epi32&expand=4718)_mm256_mask_ror_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_ror_epi32&expand=4716)_mm256_maskz_ror_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_ror_epi32&expand=4717)_mm_ror_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ror_epi32&expand=4715)_mm_mask_ror_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_ror_epi32&expand=4713)_mm_maskz_ror_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_ror_epi32&expand=4714)_mm512_rol_epi64/// Rotate the bits in each packed 64-bit integer in a to the left by the number of bits specified in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rol_epi64&expand=4694)_mm512_mask_rol_epi64/// Rotate the bits in each packed 64-bit integer in a to the left by the number of bits specified in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rol_epi64&expand=4692)_mm512_maskz_rol_epi64/// Rotate the bits in each packed 64-bit integer in a to the left by the number of bits specified in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rol_epi64&expand=4693)_mm256_rol_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rol_epi64&expand=4691)_mm256_mask_rol_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rol_epi64&expand=4689)_mm256_maskz_rol_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rol_epi64&expand=4690)_mm_rol_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rol_epi64&expand=4688)_mm_mask_rol_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rol_epi64&expand=4686)_mm_maskz_rol_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rol_epi64&expand=4687)_mm512_ror_epi64/// Rotate the bits in each packed 64-bit integer in a to the right by the number of bits specified in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_ror_epi64&expand=4730)_mm512_mask_ror_epi64/// Rotate the bits in each packed 64-bit integer in a to the right by the number of bits specified in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_ror_epi64&expand=4728)_mm512_maskz_ror_epi64/// Rotate the bits in each packed 64-bit integer in a to the right by the number of bits specified in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_ror_epi64&expand=4729)_mm256_ror_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_ror_epi64&expand=4727)_mm256_mask_ror_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_ror_epi64&expand=4725)_mm256_maskz_ror_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_ror_epi64&expand=4726)_mm_ror_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ror_epi64&expand=4724)_mm_mask_ror_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_ror_epi64&expand=4722)_mm_maskz_ror_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_ror_epi64&expand=4723)_mm512_slli_epi32/// Shift packed 32-bit integers in a left by imm8 while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_slli_epi32&expand=5310)_mm512_mask_slli_epi32/// Shift packed 32-bit integers in a left by imm8 while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_slli_epi32&expand=5308)_mm512_maskz_slli_epi32/// Shift packed 32-bit integers in a left by imm8 while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_slli_epi32&expand=5309)_mm256_mask_slli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_slli_epi32&expand=5305)_mm256_maskz_slli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_slli_epi32&expand=5306)_mm_mask_slli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_slli_epi32&expand=5302)_mm_maskz_slli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_slli_epi32&expand=5303)_mm512_srli_epi32/// Shift packed 32-bit integers in a right by imm8 while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srli_epi32&expand=5522)_mm512_mask_srli_epi32/// Shift packed 32-bit integers in a right by imm8 while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srli_epi32&expand=5520)_mm512_maskz_srli_epi32/// Shift packed 32-bit integers in a right by imm8 while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srli_epi32&expand=5521)_mm256_mask_srli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srli_epi32&expand=5517)_mm256_maskz_srli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srli_epi32&expand=5518)_mm_mask_srli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srli_epi32&expand=5514)_mm_maskz_srli_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srli_epi32&expand=5515)_mm512_slli_epi64/// Shift packed 64-bit integers in a left by imm8 while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_slli_epi64&expand=5319)_mm512_mask_slli_epi64/// Shift packed 64-bit integers in a left by imm8 while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_slli_epi64&expand=5317)_mm512_maskz_slli_epi64/// Shift packed 64-bit integers in a left by imm8 while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_slli_epi64&expand=5318)_mm256_mask_slli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_slli_epi64&expand=5314)_mm256_maskz_slli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_slli_epi64&expand=5315)_mm_mask_slli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_slli_epi64&expand=5311)_mm_maskz_slli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_slli_epi64&expand=5312)_mm512_srli_epi64/// Shift packed 64-bit integers in a right by imm8 while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srli_epi64&expand=5531)_mm512_mask_srli_epi64/// Shift packed 64-bit integers in a right by imm8 while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srli_epi64&expand=5529)_mm512_maskz_srli_epi64/// Shift packed 64-bit integers in a right by imm8 while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srli_epi64&expand=5530)_mm256_mask_srli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srli_epi64&expand=5526)_mm256_maskz_srli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srli_epi64&expand=5527)_mm_mask_srli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srli_epi64&expand=5523)_mm_maskz_srli_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srli_epi64&expand=5524)_mm512_sll_epi32/// Shift packed 32-bit integers in a left by count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sll_epi32&expand=5280)_mm512_mask_sll_epi32/// Shift packed 32-bit integers in a left by count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sll_epi32&expand=5278)_mm512_maskz_sll_epi32/// Shift packed 32-bit integers in a left by count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sll_epi32&expand=5279)_mm256_mask_sll_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sll_epi32&expand=5275)_mm256_maskz_sll_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sll_epi32&expand=5276)_mm_mask_sll_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sll_epi32&expand=5272)_mm_maskz_sll_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sll_epi32&expand=5273)_mm512_srl_epi32/// Shift packed 32-bit integers in a right by count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srl_epi32&expand=5492)_mm512_mask_srl_epi32/// Shift packed 32-bit integers in a right by count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srl_epi32&expand=5490)_mm512_maskz_srl_epi32/// Shift packed 32-bit integers in a right by count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srl_epi32&expand=5491)_mm256_mask_srl_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srl_epi32&expand=5487)_mm256_maskz_srl_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srl_epi32&expand=5488)_mm_mask_srl_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srl_epi32&expand=5484)_mm_maskz_srl_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srl_epi32&expand=5485)_mm512_sll_epi64/// Shift packed 64-bit integers in a left by count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sll_epi64&expand=5289)_mm512_mask_sll_epi64/// Shift packed 64-bit integers in a left by count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sll_epi64&expand=5287)_mm512_maskz_sll_epi64/// Shift packed 64-bit integers in a left by count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sll_epi64&expand=5288)_mm256_mask_sll_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sll_epi64&expand=5284)_mm256_maskz_sll_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sll_epi64&expand=5285)_mm_mask_sll_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sll_epi64&expand=5281)_mm_maskz_sll_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sll_epi64&expand=5282)_mm512_srl_epi64/// Shift packed 64-bit integers in a right by count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srl_epi64&expand=5501)_mm512_mask_srl_epi64/// Shift packed 64-bit integers in a right by count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srl_epi64&expand=5499)_mm512_maskz_srl_epi64/// Shift packed 64-bit integers in a right by count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srl_epi64&expand=5500)_mm256_mask_srl_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srl_epi64&expand=5496)_mm256_maskz_srl_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srl_epi64&expand=5497)_mm_mask_srl_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srl_epi64&expand=5493)_mm_maskz_srl_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srl_epi64&expand=5494)_mm512_sra_epi32/// Shift packed 32-bit integers in a right by count while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sra_epi32&expand=5407)_mm512_mask_sra_epi32/// Shift packed 32-bit integers in a right by count while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sra_epi32&expand=5405)_mm512_maskz_sra_epi32/// Shift packed 32-bit integers in a right by count while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sra_epi32&expand=5406)_mm256_mask_sra_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sra_epi32&expand=5402)_mm256_maskz_sra_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sra_epi32&expand=5403)_mm_mask_sra_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sra_epi32&expand=5399)_mm_maskz_sra_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sra_epi32&expand=5400)_mm512_sra_epi64/// Shift packed 64-bit integers in a right by count while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sra_epi64&expand=5416)_mm512_mask_sra_epi64/// Shift packed 64-bit integers in a right by count while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sra_epi64&expand=5414)_mm512_maskz_sra_epi64/// Shift packed 64-bit integers in a right by count while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sra_epi64&expand=5415)_mm256_sra_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_sra_epi64&expand=5413)_mm256_mask_sra_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sra_epi64&expand=5411)_mm256_maskz_sra_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sra_epi64&expand=5412)_mm_sra_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sra_epi64&expand=5410)_mm_mask_sra_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sra_epi64&expand=5408)_mm_maskz_sra_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sra_epi64&expand=5409)_mm512_srai_epi32/// Shift packed 32-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srai_epi32&expand=5436)_mm512_mask_srai_epi32/// Shift packed 32-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srai_epi32&expand=5434)_mm512_maskz_srai_epi32/// Shift packed 32-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srai_epi32&expand=5435)_mm256_mask_srai_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srai_epi32&expand=5431)_mm256_maskz_srai_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srai_epi32&expand=5432)_mm_mask_srai_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srai_epi32&expand=5428)_mm_maskz_srai_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srai_epi32&expand=5429)_mm512_srai_epi64/// Shift packed 64-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srai_epi64&expand=5445)_mm512_mask_srai_epi64/// Shift packed 64-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srai_epi64&expand=5443)_mm512_maskz_srai_epi64/// Shift packed 64-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srai_epi64&expand=5444)_mm256_srai_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srai_epi64&expand=5442)_mm256_mask_srai_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srai_epi64&expand=5440)_mm256_maskz_srai_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srai_epi64&expand=5441)_mm_srai_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srai_epi64&expand=5439)_mm_mask_srai_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srai_epi64&expand=5437)_mm_maskz_srai_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srai_epi64&expand=5438)_mm512_srav_epi32/// Shift packed 32-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srav_epi32&expand=5465)_mm512_mask_srav_epi32/// Shift packed 32-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srav_epi32&expand=5463)_mm512_maskz_srav_epi32/// Shift packed 32-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srav_epi32&expand=5464)_mm256_mask_srav_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srav_epi32&expand=5460)_mm256_maskz_srav_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srav_epi32&expand=5461)_mm_mask_srav_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srav_epi32&expand=5457)_mm_maskz_srav_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srav_epi32&expand=5458)_mm512_srav_epi64/// Shift packed 64-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srav_epi64&expand=5474)_mm512_mask_srav_epi64/// Shift packed 64-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srav_epi64&expand=5472)_mm512_maskz_srav_epi64/// Shift packed 64-bit integers in a right by the amount specified by the corresponding element in count while shifting in sign bits, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srav_epi64&expand=5473)_mm256_srav_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_srav_epi64&expand=5471)_mm256_mask_srav_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srav_epi64&expand=5469)_mm256_maskz_srav_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srav_epi64&expand=5470)_mm_srav_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srav_epi64&expand=5468)_mm_mask_srav_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srav_epi64&expand=5466)_mm_maskz_srav_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srav_epi64&expand=5467)_mm512_rolv_epi32/// Rotate the bits in each packed 32-bit integer in a to the left by the number of bits specified in the corresponding element of b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rolv_epi32&expand=4703)_mm512_mask_rolv_epi32/// Rotate the bits in each packed 32-bit integer in a to the left by the number of bits specified in the corresponding element of b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rolv_epi32&expand=4701)_mm512_maskz_rolv_epi32/// Rotate the bits in each packed 32-bit integer in a to the left by the number of bits specified in the corresponding element of b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rolv_epi32&expand=4702)_mm256_rolv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rolv_epi32&expand=4700)_mm256_mask_rolv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rolv_epi32&expand=4698)_mm256_maskz_rolv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rolv_epi32&expand=4699)_mm_rolv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rolv_epi32&expand=4697)_mm_mask_rolv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rolv_epi32&expand=4695)_mm_maskz_rolv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rolv_epi32&expand=4696)_mm512_rorv_epi32/// Rotate the bits in each packed 32-bit integer in a to the right by the number of bits specified in the corresponding element of b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rorv_epi32&expand=4739)_mm512_mask_rorv_epi32/// Rotate the bits in each packed 32-bit integer in a to the right by the number of bits specified in the corresponding element of b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rorv_epi32&expand=4737)_mm512_maskz_rorv_epi32/// Rotate the bits in each packed 32-bit integer in a to the right by the number of bits specified in the corresponding element of b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rorv_epi32&expand=4738)_mm256_rorv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rorv_epi32&expand=4736)_mm256_mask_rorv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rorv_epi32&expand=4734)_mm256_maskz_rorv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rorv_epi32&expand=4735)_mm_rorv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rorv_epi32&expand=4733)_mm_mask_rorv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rorv_epi32&expand=4731)_mm_maskz_rorv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rorv_epi32&expand=4732)_mm512_rolv_epi64/// Rotate the bits in each packed 64-bit integer in a to the left by the number of bits specified in the corresponding element of b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rolv_epi64&expand=4712)_mm512_mask_rolv_epi64/// Rotate the bits in each packed 64-bit integer in a to the left by the number of bits specified in the corresponding element of b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rolv_epi64&expand=4710)_mm512_maskz_rolv_epi64/// Rotate the bits in each packed 64-bit integer in a to the left by the number of bits specified in the corresponding element of b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rolv_epi64&expand=4711)_mm256_rolv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rolv_epi64&expand=4709)_mm256_mask_rolv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rolv_epi64&expand=4707)_mm256_maskz_rolv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rolv_epi64&expand=4708)_mm_rolv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rolv_epi64&expand=4706)_mm_mask_rolv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rolv_epi64&expand=4704)_mm_maskz_rolv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rolv_epi64&expand=4705)_mm512_rorv_epi64/// Rotate the bits in each packed 64-bit integer in a to the right by the number of bits specified in the corresponding element of b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_rorv_epi64&expand=4748)_mm512_mask_rorv_epi64/// Rotate the bits in each packed 64-bit integer in a to the right by the number of bits specified in the corresponding element of b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_rorv_epi64&expand=4746)_mm512_maskz_rorv_epi64/// Rotate the bits in each packed 64-bit integer in a to the right by the number of bits specified in the corresponding element of b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_rorv_epi64&expand=4747)_mm256_rorv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_rorv_epi64&expand=4745)_mm256_mask_rorv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_rorv_epi64&expand=4743)_mm256_maskz_rorv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_rorv_epi64&expand=4744)_mm_rorv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rorv_epi64&expand=4742)_mm_mask_rorv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_rorv_epi64&expand=4740)_mm_maskz_rorv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_rorv_epi64&expand=4741)_mm512_sllv_epi32/// Shift packed 32-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sllv_epi32&expand=5342)_mm512_mask_sllv_epi32/// Shift packed 32-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sllv_epi32&expand=5340)_mm512_maskz_sllv_epi32/// Shift packed 32-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sllv_epi32&expand=5341)_mm256_mask_sllv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sllv_epi32&expand=5337)_mm256_maskz_sllv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sllv_epi32&expand=5338)_mm_mask_sllv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sllv_epi32&expand=5334)_mm_maskz_sllv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sllv_epi32&expand=5335)_mm512_srlv_epi32/// Shift packed 32-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srlv_epi32&expand=5554)_mm512_mask_srlv_epi32/// Shift packed 32-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srlv_epi32&expand=5552)_mm512_maskz_srlv_epi32/// Shift packed 32-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srlv_epi32&expand=5553)_mm256_mask_srlv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srlv_epi32&expand=5549)_mm256_maskz_srlv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srlv_epi32&expand=5550)_mm_mask_srlv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srlv_epi32&expand=5546)_mm_maskz_srlv_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srlv_epi32&expand=5547)_mm512_sllv_epi64/// Shift packed 64-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_sllv_epi64&expand=5351)_mm512_mask_sllv_epi64/// Shift packed 64-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_sllv_epi64&expand=5349)_mm512_maskz_sllv_epi64/// Shift packed 64-bit integers in a left by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_sllv_epi64&expand=5350)_mm256_mask_sllv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_sllv_epi64&expand=5346)_mm256_maskz_sllv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_sllv_epi64&expand=5347)_mm_mask_sllv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_sllv_epi64&expand=5343)_mm_maskz_sllv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_sllv_epi64&expand=5344)_mm512_srlv_epi64/// Shift packed 64-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_srlv_epi64&expand=5563)_mm512_mask_srlv_epi64/// Shift packed 64-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_srlv_epi64&expand=5561)_mm512_maskz_srlv_epi64/// Shift packed 64-bit integers in a right by the amount specified by the corresponding element in count while shifting in zeros, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_srlv_epi64&expand=5562)_mm256_mask_srlv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_srlv_epi64&expand=5558)_mm256_maskz_srlv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_srlv_epi64&expand=5559)_mm_mask_srlv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_srlv_epi64&expand=5555)_mm_maskz_srlv_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_srlv_epi64&expand=5556)_mm512_permute_ps/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permute_ps&expand=4170)_mm512_mask_permute_ps/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permute_ps&expand=4168)_mm512_maskz_permute_ps/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permute_ps&expand=4169)_mm256_mask_permute_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permute_ps&expand=4165)_mm256_maskz_permute_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permute_ps&expand=4166)_mm_mask_permute_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permute_ps&expand=4162)_mm_maskz_permute_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permute_ps&expand=4163)_mm512_permute_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permute_pd&expand=4161)_mm512_mask_permute_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permute_pd&expand=4159)_mm512_maskz_permute_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permute_pd&expand=4160)_mm256_mask_permute_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permute_pd&expand=4156)_mm256_maskz_permute_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permute_pd&expand=4157)_mm_mask_permute_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permute_pd&expand=4153)_mm_maskz_permute_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permute_pd&expand=4154)_mm512_permutex_epi64/// Shuffle 64-bit integers in a within 256-bit lanes using the control in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex_epi64&expand=4208)//should be vpermq_mm512_mask_permutex_epi64/// Shuffle 64-bit integers in a within 256-bit lanes using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex_epi64&expand=4206)_mm512_maskz_permutex_epi64/// Shuffle 64-bit integers in a within 256-bit lanes using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex_epi64&expand=4207)_mm256_permutex_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex_epi64&expand=4205)_mm256_mask_permutex_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex_epi64&expand=4203)_mm256_maskz_permutex_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex_epi64&expand=4204)_mm512_permutex_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 256-bit lanes using the control in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex_pd&expand=4214)//should be vpermpd_mm512_mask_permutex_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 256-bit lanes using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex_pd&expand=4212)_mm512_maskz_permutex_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 256-bit lanes using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex_pd&expand=4213)_mm256_permutex_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex_pd&expand=4211)_mm256_mask_permutex_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex_pd&expand=4209)_mm256_maskz_permutex_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex_pd&expand=4210)_mm512_permutevar_epi32/// Shuffle 32-bit integers in a across lanes using the corresponding index in idx, and store the results in dst. Note that this intrinsic shuffles across 128-bit lanes, unlike past intrinsics that use the permutevar name. This intrinsic is identical to _mm512_permutexvar_epi32, and it is recommended that you use that intrinsic name./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutevar_epi32&expand=4182)//should be vpermd_mm512_mask_permutevar_epi32/// Shuffle 32-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set). Note that this intrinsic shuffles across 128-bit lanes, unlike past intrinsics that use the permutevar name. This intrinsic is identical to _mm512_mask_permutexvar_epi32, and it is recommended that you use that intrinsic name./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutevar_epi32&expand=4181)_mm512_permutevar_ps/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutevar_ps&expand=4200)_mm512_mask_permutevar_ps/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutevar_ps&expand=4198)_mm512_maskz_permutevar_ps/// Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutevar_ps&expand=4199)_mm256_mask_permutevar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm256_mask_permutevar_ps&expand=4195)_mm256_maskz_permutevar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutevar_ps&expand=4196)_mm_mask_permutevar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutevar_ps&expand=4192)_mm_maskz_permutevar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutevar_ps&expand=4193)_mm512_permutevar_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutevar_pd&expand=4191)_mm512_mask_permutevar_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutevar_pd&expand=4189)_mm512_maskz_permutevar_pd/// Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutevar_pd&expand=4190)_mm256_mask_permutevar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutevar_pd&expand=4186)_mm256_maskz_permutevar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutevar_pd&expand=4187)_mm_mask_permutevar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutevar_pd&expand=4183)_mm_maskz_permutevar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutevar_pd&expand=4184)_mm512_permutexvar_epi32/// Shuffle 32-bit integers in a across lanes using the corresponding index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutexvar_epi32&expand=4301)_mm512_mask_permutexvar_epi32/// Shuffle 32-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutexvar_epi32&expand=4299)_mm512_maskz_permutexvar_epi32/// Shuffle 32-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutexvar_epi32&expand=4300)_mm256_permutexvar_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutexvar_epi32&expand=4298)_mm256_mask_permutexvar_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutexvar_epi32&expand=4296)_mm256_maskz_permutexvar_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutexvar_epi32&expand=4297)_mm512_permutexvar_epi64/// Shuffle 64-bit integers in a across lanes using the corresponding index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutexvar_epi64&expand=4307)_mm512_mask_permutexvar_epi64/// Shuffle 64-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutexvar_epi64&expand=4305)_mm512_maskz_permutexvar_epi64/// Shuffle 64-bit integers in a across lanes using the corresponding index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutexvar_epi64&expand=4306)_mm256_permutexvar_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutexvar_epi64&expand=4304)_mm256_mask_permutexvar_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutexvar_epi64&expand=4302)_mm256_maskz_permutexvar_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutexvar_epi64&expand=4303)_mm512_permutexvar_ps/// Shuffle single-precision (32-bit) floating-point elements in a across lanes using the corresponding index in idx./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutexvar_ps&expand=4200)_mm512_mask_permutexvar_ps/// Shuffle single-precision (32-bit) floating-point elements in a across lanes using the corresponding index in idx, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutexvar_ps&expand=4326)_mm512_maskz_permutexvar_ps/// Shuffle single-precision (32-bit) floating-point elements in a across lanes using the corresponding index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutexvar_ps&expand=4327)_mm256_permutexvar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutexvar_ps&expand=4325)_mm256_mask_permutexvar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutexvar_ps&expand=4323)_mm256_maskz_permutexvar_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutexvar_ps&expand=4324)_mm512_permutexvar_pd/// Shuffle double-precision (64-bit) floating-point elements in a across lanes using the corresponding index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutexvar_pd&expand=4322)_mm512_mask_permutexvar_pd/// Shuffle double-precision (64-bit) floating-point elements in a across lanes using the corresponding index in idx, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutexvar_pd&expand=4320)_mm512_maskz_permutexvar_pd/// Shuffle double-precision (64-bit) floating-point elements in a across lanes using the corresponding index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutexvar_pd&expand=4321)_mm256_permutexvar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutexvar_pd&expand=4319)_mm256_mask_permutexvar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutexvar_pd&expand=4317)_mm256_maskz_permutexvar_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutexvar_pd&expand=4318)_mm512_permutex2var_epi32/// Shuffle 32-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex2var_epi32&expand=4238)//vpermi2d or vpermt2d_mm512_mask_permutex2var_epi32/// Shuffle 32-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex2var_epi32&expand=4235)_mm512_maskz_permutex2var_epi32/// Shuffle 32-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex2var_epi32&expand=4237)_mm512_mask2_permutex2var_epi32/// Shuffle 32-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from idx when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask2_permutex2var_epi32&expand=4236)_mm256_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex2var_epi32&expand=4234)_mm256_mask_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex2var_epi32&expand=4231)_mm256_maskz_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex2var_epi32&expand=4233)_mm256_mask2_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask2_permutex2var_epi32&expand=4232)_mm_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutex2var_epi32&expand=4230)_mm_mask_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutex2var_epi32&expand=4227)_mm_maskz_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutex2var_epi32&expand=4229)_mm_mask2_permutex2var_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask2_permutex2var_epi32&expand=4228)_mm512_permutex2var_epi64/// Shuffle 64-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex2var_epi64&expand=4250)//vpermi2q or vpermt2q_mm512_mask_permutex2var_epi64/// Shuffle 64-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex2var_epi64&expand=4247)_mm512_maskz_permutex2var_epi64/// Shuffle 64-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex2var_epi64&expand=4249)_mm512_mask2_permutex2var_epi64/// Shuffle 64-bit integers in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from idx when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask2_permutex2var_epi64&expand=4248)_mm256_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex2var_epi64&expand=4246)_mm256_mask_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex2var_epi64&expand=4243)_mm256_maskz_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex2var_epi64&expand=4245)_mm256_mask2_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask2_permutex2var_epi64&expand=4244)_mm_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutex2var_epi64&expand=4242)_mm_mask_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutex2var_epi64&expand=4239)_mm_maskz_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutex2var_epi64&expand=4241)_mm_mask2_permutex2var_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask2_permutex2var_epi64&expand=4240)_mm512_permutex2var_ps/// Shuffle single-precision (32-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex2var_ps&expand=4286)//vpermi2ps or vpermt2ps_mm512_mask_permutex2var_ps/// Shuffle single-precision (32-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex2var_ps&expand=4283)_mm512_maskz_permutex2var_ps/// Shuffle single-precision (32-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex2var_ps&expand=4285)_mm512_mask2_permutex2var_ps/// Shuffle single-precision (32-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from idx when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask2_permutex2var_ps&expand=4284)//should be vpermi2ps, but it shows vpermt2ps_mm256_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex2var_ps&expand=4282)_mm256_mask_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex2var_ps&expand=4279)_mm256_maskz_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex2var_ps&expand=4281)_mm256_mask2_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask2_permutex2var_ps&expand=4280)_mm_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutex2var_ps&expand=4278)_mm_mask_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutex2var_ps&expand=4275)_mm_maskz_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutex2var_ps&expand=4277)_mm_mask2_permutex2var_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask2_permutex2var_ps&expand=4276)_mm512_permutex2var_pd/// Shuffle double-precision (64-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_permutex2var_pd&expand=4274)//vpermi2pd or vpermt2pd_mm512_mask_permutex2var_pd/// Shuffle double-precision (64-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from a when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_permutex2var_pd&expand=4271)_mm512_maskz_permutex2var_pd/// Shuffle double-precision (64-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_permutex2var_pd&expand=4273)_mm512_mask2_permutex2var_pd/// Shuffle double-precision (64-bit) floating-point elements in a and b across lanes using the corresponding selector and index in idx, and store the results in dst using writemask k (elements are copied from idx when the corresponding mask bit is not set)/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask2_permutex2var_pd&expand=4272)//should be vpermi2pd, but it shows vpermt2pd_mm256_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_permutex2var_pd&expand=4270)_mm256_mask_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_permutex2var_pd&expand=4267)_mm256_maskz_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_permutex2var_pd&expand=4269)_mm256_mask2_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask2_permutex2var_pd&expand=4268)_mm_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_permutex2var_pd&expand=4266)_mm_mask_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_permutex2var_pd&expand=4263)_mm_maskz_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_permutex2var_pd&expand=4265)_mm_mask2_permutex2var_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask2_permutex2var_pd&expand=4264)_MM_PERM_ENUM_mm512_shuffle_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_epi32&expand=5150)//should be vpshufd_mm512_mask_shuffle_epi32/// Shuffle 32-bit integers in a within 128-bit lanes using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_epi32&expand=5148)_mm512_maskz_shuffle_epi32/// Shuffle 32-bit integers in a within 128-bit lanes using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_epi32&expand=5149)_mm256_mask_shuffle_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_epi32&expand=5145)_mm256_maskz_shuffle_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_epi32&expand=5146)_mm_mask_shuffle_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_shuffle_epi32&expand=5142)_mm_maskz_shuffle_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_shuffle_epi32&expand=5143)_mm512_shuffle_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_ps&expand=5203)_mm512_mask_shuffle_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_ps&expand=5201)_mm512_maskz_shuffle_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_ps&expand=5202)_mm256_mask_shuffle_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_ps&expand=5198)_mm256_maskz_shuffle_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_ps&expand=5199)_mm_mask_shuffle_ps/// Shuffle single-precision (32-bit) floating-point elements in a using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_shuffle_ps&expand=5195)_mm_maskz_shuffle_ps/// Shuffle single-precision (32-bit) floating-point elements in a using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_shuffle_ps&expand=5196)_mm512_shuffle_pd/// Shuffle double-precision (64-bit) floating-point elements within 128-bit lanes using the control in imm8, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_pd&expand=5192)_mm512_mask_shuffle_pd/// Shuffle double-precision (64-bit) floating-point elements within 128-bit lanes using the control in imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_pd&expand=5190)_mm512_maskz_shuffle_pd/// Shuffle double-precision (64-bit) floating-point elements within 128-bit lanes using the control in imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_pd&expand=5191)_mm256_mask_shuffle_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_pd&expand=5187)_mm256_maskz_shuffle_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_pd&expand=5188)_mm_mask_shuffle_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_shuffle_pd&expand=5184)_mm_maskz_shuffle_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_shuffle_pd&expand=5185)_mm512_shuffle_i32x4/// Shuffle 128-bits (composed of 4 32-bit integers) selected by imm8 from a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_i32x4&expand=5177)//should be vshufi32x4_mm512_mask_shuffle_i32x4/// Shuffle 128-bits (composed of 4 32-bit integers) selected by imm8 from a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_i32x4&expand=5175)_mm512_maskz_shuffle_i32x4/// Shuffle 128-bits (composed of 4 32-bit integers) selected by imm8 from a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_i32x4&expand=5176)_mm256_shuffle_i32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_i32x4&expand=5174)_mm256_mask_shuffle_i32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_i32x4&expand=5172)_mm256_maskz_shuffle_i32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_i32x4&expand=5173)_mm512_shuffle_i64x2/// Shuffle 128-bits (composed of 2 64-bit integers) selected by imm8 from a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_i64x2&expand=5183)_mm512_mask_shuffle_i64x2/// Shuffle 128-bits (composed of 2 64-bit integers) selected by imm8 from a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_i64x2&expand=5181)_mm512_maskz_shuffle_i64x2/// Shuffle 128-bits (composed of 2 64-bit integers) selected by imm8 from a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_i64x2&expand=5182)_mm256_shuffle_i64x2/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_i64x2&expand=5180)//should be vshufi64x2_mm256_mask_shuffle_i64x2/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_i64x2&expand=5178)_mm256_maskz_shuffle_i64x2/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_i64x2&expand=5179)_mm512_shuffle_f32x4/// Shuffle 128-bits (composed of 4 single-precision (32-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_f32x4&expand=5165)//should be vshuff32x4, but generate vshuff64x2_mm512_mask_shuffle_f32x4/// Shuffle 128-bits (composed of 4 single-precision (32-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_f32x4&expand=5163)_mm512_maskz_shuffle_f32x4/// Shuffle 128-bits (composed of 4 single-precision (32-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_f32x4&expand=5164)_mm256_shuffle_f32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_f32x4&expand=5162)//should be vshuff32x4_mm256_mask_shuffle_f32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_f32x4&expand=5160)_mm256_maskz_shuffle_f32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_f32x4&expand=5161)_mm512_shuffle_f64x2/// Shuffle 128-bits (composed of 2 double-precision (64-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_shuffle_f64x2&expand=5171)_mm512_mask_shuffle_f64x2/// Shuffle 128-bits (composed of 2 double-precision (64-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_shuffle_f64x2&expand=5169)_mm512_maskz_shuffle_f64x2/// Shuffle 128-bits (composed of 2 double-precision (64-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_shuffle_f64x2&expand=5170)_mm256_shuffle_f64x2/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_shuffle_f64x2&expand=5168)//should be vshuff64x2_mm256_mask_shuffle_f64x2/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_shuffle_f64x2&expand=5166)_mm256_maskz_shuffle_f64x2/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_shuffle_f64x2&expand=5167)_mm512_extractf32x4_ps/// Extract 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from a, selected with imm8, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extractf32x4_ps&expand=2442)_mm512_mask_extractf32x4_ps/// Extract 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from a, selected with imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extractf32x4_ps&expand=2443)_mm512_maskz_extractf32x4_ps/// Extract 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from a, selected with imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extractf32x4_ps&expand=2444)//should be vextractf32x4_mm256_extractf32x4_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extractf32x4_ps&expand=2439)_mm256_mask_extractf32x4_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_extractf32x4_ps&expand=2440)_mm256_maskz_extractf32x4_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_extractf32x4_ps&expand=2441)//should be vextracti64x4_mm512_extracti64x4_epi64/// Extract 256 bits (composed of 4 packed 64-bit integers) from a, selected with IMM1, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extracti64x4_epi64&expand=2473)_mm512_mask_extracti64x4_epi64/// Extract 256 bits (composed of 4 packed 64-bit integers) from a, selected with IMM1, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extracti64x4_epi64&expand=2474)_mm512_maskz_extracti64x4_epi64/// Extract 256 bits (composed of 4 packed 64-bit integers) from a, selected with IMM1, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extracti64x4_epi64&expand=2475)_mm512_extractf64x4_pd/// Extract 256 bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a, selected with imm8, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extractf64x4_pd&expand=2454)_mm512_mask_extractf64x4_pd/// Extract 256 bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a, selected with imm8, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extractf64x4_pd&expand=2455)_mm512_maskz_extractf64x4_pd/// Extract 256 bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a, selected with imm8, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extractf64x4_pd&expand=2456)//should be vextracti32x4_mm512_extracti32x4_epi32/// Extract 128 bits (composed of 4 packed 32-bit integers) from a, selected with IMM2, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_extracti32x4_epi32&expand=2461)_mm512_mask_extracti32x4_epi32/// Extract 128 bits (composed of 4 packed 32-bit integers) from a, selected with IMM2, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_extracti32x4_epi32&expand=2462)_mm512_maskz_extracti32x4_epi32/// Extract 128 bits (composed of 4 packed 32-bit integers) from a, selected with IMM2, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_extracti32x4_epi32&expand=2463)_mm256_extracti32x4_epi32/// Extract 128 bits (composed of 4 packed 32-bit integers) from a, selected with IMM1, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_extracti32x4_epi32&expand=2458)_mm256_mask_extracti32x4_epi32/// Extract 128 bits (composed of 4 packed 32-bit integers) from a, selected with IMM1, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_extracti32x4_epi32&expand=2459)_mm256_maskz_extracti32x4_epi32/// Extract 128 bits (composed of 4 packed 32-bit integers) from a, selected with IMM1, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_extracti32x4_epi32&expand=2460)_mm512_moveldup_ps/// Duplicate even-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_moveldup_ps&expand=3862)_mm512_mask_moveldup_ps/// Duplicate even-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_moveldup_ps&expand=3860)_mm512_maskz_moveldup_ps/// Duplicate even-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_moveldup_ps&expand=3861)_mm256_mask_moveldup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_moveldup_ps&expand=3857)_mm256_maskz_moveldup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_moveldup_ps&expand=3858)_mm_mask_moveldup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_moveldup_ps&expand=3854)_mm_maskz_moveldup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_moveldup_ps&expand=3855)_mm512_movehdup_ps/// Duplicate odd-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movehdup_ps&expand=3852)_mm512_mask_movehdup_ps/// Duplicate odd-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_movehdup_ps&expand=3850)_mm512_maskz_movehdup_ps/// Duplicate odd-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_movehdup_ps&expand=3851)_mm256_mask_movehdup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_movehdup_ps&expand=3847)_mm256_maskz_movehdup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_movehdup_ps&expand=3848)_mm_mask_movehdup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_movehdup_ps&expand=3844)_mm_maskz_movehdup_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_movehdup_ps&expand=3845)_mm512_movedup_pd/// Duplicate even-indexed double-precision (64-bit) floating-point elements from a, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_movedup_pd&expand=3843)_mm512_mask_movedup_pd/// Duplicate even-indexed double-precision (64-bit) floating-point elements from a, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_movedup_pd&expand=3841)_mm512_maskz_movedup_pd/// Duplicate even-indexed double-precision (64-bit) floating-point elements from a, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_movedup_pd&expand=3842)_mm256_mask_movedup_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_movedup_pd&expand=3838)_mm256_maskz_movedup_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_movedup_pd&expand=3839)_mm_mask_movedup_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_movedup_pd&expand=3835)_mm_maskz_movedup_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_movedup_pd&expand=3836)_mm512_inserti32x4/// Copy a to dst, then insert 128 bits (composed of 4 packed 32-bit integers) from b into dst at the location specified by imm8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_inserti32x4&expand=3174)//should be vinserti32x4_mm512_mask_inserti32x4/// Copy a to tmp, then insert 128 bits (composed of 4 packed 32-bit integers) from b into tmp at the location specified by imm8. Store tmp to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_inserti32x4&expand=3175)_mm512_maskz_inserti32x4/// Copy a to tmp, then insert 128 bits (composed of 4 packed 32-bit integers) from b into tmp at the location specified by imm8. Store tmp to dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_inserti32x4&expand=3176)_mm256_inserti32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_inserti32x4&expand=3171)_mm256_mask_inserti32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_inserti32x4&expand=3172)_mm256_maskz_inserti32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_inserti32x4&expand=3173)_mm512_inserti64x4/// Copy a to dst, then insert 256 bits (composed of 4 packed 64-bit integers) from b into dst at the location specified by imm8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_inserti64x4&expand=3186)//should be vinserti64x4_mm512_mask_inserti64x4/// Copy a to tmp, then insert 256 bits (composed of 4 packed 64-bit integers) from b into tmp at the location specified by imm8. Store tmp to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_inserti64x4&expand=3187)_mm512_maskz_inserti64x4/// Copy a to tmp, then insert 256 bits (composed of 4 packed 64-bit integers) from b into tmp at the location specified by imm8. Store tmp to dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_inserti64x4&expand=3188)_mm512_insertf32x4/// Copy a to dst, then insert 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from b into dst at the location specified by imm8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_insertf32x4&expand=3155)_mm512_mask_insertf32x4/// Copy a to tmp, then insert 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from b into tmp at the location specified by imm8. Store tmp to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_insertf32x4&expand=3156)_mm512_maskz_insertf32x4/// Copy a to tmp, then insert 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from b into tmp at the location specified by imm8. Store tmp to dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_insertf32x4&expand=3157)//should be vinsertf32x4_mm256_insertf32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_insertf32x4&expand=3152)_mm256_mask_insertf32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_insertf32x4&expand=3153)_mm256_maskz_insertf32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_insertf32x4&expand=3154)_mm512_insertf64x4/// Copy a to dst, then insert 256 bits (composed of 4 packed double-precision (64-bit) floating-point elements) from b into dst at the location specified by imm8./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_insertf64x4&expand=3167)_mm512_mask_insertf64x4/// Copy a to tmp, then insert 256 bits (composed of 4 packed double-precision (64-bit) floating-point elements) from b into tmp at the location specified by imm8. Store tmp to dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_insertf64x4&expand=3168)_mm512_maskz_insertf64x4/// Copy a to tmp, then insert 256 bits (composed of 4 packed double-precision (64-bit) floating-point elements) from b into tmp at the location specified by imm8. Store tmp to dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_insertf64x4&expand=3169)_mm512_unpackhi_epi32/// Unpack and interleave 32-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpackhi_epi32&expand=6021)//should be vpunpckhdq_mm512_mask_unpackhi_epi32/// Unpack and interleave 32-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpackhi_epi32&expand=6019)_mm512_maskz_unpackhi_epi32/// Unpack and interleave 32-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpackhi_epi32&expand=6020)_mm256_mask_unpackhi_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpackhi_epi32&expand=6016)_mm256_maskz_unpackhi_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpackhi_epi32&expand=6017)_mm_mask_unpackhi_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpackhi_epi32&expand=6013)_mm_maskz_unpackhi_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpackhi_epi32&expand=6014)_mm512_unpackhi_epi64/// Unpack and interleave 64-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpackhi_epi64&expand=6030)//should be vpunpckhqdq_mm512_mask_unpackhi_epi64/// Unpack and interleave 64-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpackhi_epi64&expand=6028)_mm512_maskz_unpackhi_epi64/// Unpack and interleave 64-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpackhi_epi64&expand=6029)_mm256_mask_unpackhi_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpackhi_epi64&expand=6025)_mm256_maskz_unpackhi_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpackhi_epi64&expand=6026)_mm_mask_unpackhi_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpackhi_epi64&expand=6022)_mm_maskz_unpackhi_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpackhi_epi64&expand=6023)_mm512_unpackhi_ps/// Unpack and interleave single-precision (32-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpackhi_ps&expand=6060)_mm512_mask_unpackhi_ps/// Unpack and interleave single-precision (32-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpackhi_ps&expand=6058)_mm512_maskz_unpackhi_ps/// Unpack and interleave single-precision (32-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpackhi_ps&expand=6059)_mm256_mask_unpackhi_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpackhi_ps&expand=6055)_mm256_maskz_unpackhi_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpackhi_ps&expand=6056)_mm_mask_unpackhi_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpackhi_ps&expand=6052)_mm_maskz_unpackhi_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpackhi_ps&expand=6053)_mm512_unpackhi_pd/// Unpack and interleave double-precision (64-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpackhi_pd&expand=6048)_mm512_mask_unpackhi_pd/// Unpack and interleave double-precision (64-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpackhi_pd&expand=6046)_mm512_maskz_unpackhi_pd/// Unpack and interleave double-precision (64-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpackhi_pd&expand=6047)_mm256_mask_unpackhi_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpackhi_pd&expand=6043)_mm256_maskz_unpackhi_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpackhi_pd&expand=6044)_mm_mask_unpackhi_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpackhi_pd&expand=6040)_mm_maskz_unpackhi_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpackhi_pd&expand=6041)_mm512_unpacklo_epi32/// Unpack and interleave 32-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpacklo_epi32&expand=6078)//should be vpunpckldq_mm512_mask_unpacklo_epi32/// Unpack and interleave 32-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpacklo_epi32&expand=6076)_mm512_maskz_unpacklo_epi32/// Unpack and interleave 32-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpacklo_epi32&expand=6077)_mm256_mask_unpacklo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpacklo_epi32&expand=6073)_mm256_maskz_unpacklo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpacklo_epi32&expand=6074)_mm_mask_unpacklo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpacklo_epi32&expand=6070)_mm_maskz_unpacklo_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpacklo_epi32&expand=6071)_mm512_unpacklo_epi64/// Unpack and interleave 64-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpacklo_epi64&expand=6087)//should be vpunpcklqdq_mm512_mask_unpacklo_epi64/// Unpack and interleave 64-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpacklo_epi64&expand=6085)_mm512_maskz_unpacklo_epi64/// Unpack and interleave 64-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpacklo_epi64&expand=6086)_mm256_mask_unpacklo_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpacklo_epi64&expand=6082)_mm256_maskz_unpacklo_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpacklo_epi64&expand=6083)_mm_mask_unpacklo_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpacklo_epi64&expand=6079)_mm_maskz_unpacklo_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpacklo_epi64&expand=6080)_mm512_unpacklo_ps/// Unpack and interleave single-precision (32-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpacklo_ps&expand=6117)_mm512_mask_unpacklo_ps/// Unpack and interleave single-precision (32-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpacklo_ps&expand=6115)_mm512_maskz_unpacklo_ps/// Unpack and interleave single-precision (32-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpacklo_ps&expand=6116)_mm256_mask_unpacklo_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpacklo_ps&expand=6112)_mm256_maskz_unpacklo_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpacklo_ps&expand=6113)_mm_mask_unpacklo_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpacklo_ps&expand=6109)_mm_maskz_unpacklo_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpacklo_ps&expand=6110)_mm512_unpacklo_pd/// Unpack and interleave double-precision (64-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_unpacklo_pd&expand=6105)_mm512_mask_unpacklo_pd/// Unpack and interleave double-precision (64-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_unpacklo_pd&expand=6103)_mm512_maskz_unpacklo_pd/// Unpack and interleave double-precision (64-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_unpacklo_pd&expand=6104)_mm256_mask_unpacklo_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_unpacklo_pd&expand=6100)_mm256_maskz_unpacklo_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_unpacklo_pd&expand=6101)_mm_mask_unpacklo_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_unpacklo_pd&expand=6097)_mm_maskz_unpacklo_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_unpacklo_pd&expand=6098)_mm512_castps128_ps512/// Cast vector of type __m128 to type __m512; the upper 384 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps128_ps512&expand=621)_mm512_castps256_ps512/// Cast vector of type __m256 to type __m512; the upper 256 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps256_ps512&expand=623)_mm512_zextps128_ps512/// Cast vector of type __m128 to type __m512; the upper 384 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_zextps128_ps512&expand=6196)_mm512_zextps256_ps512/// Cast vector of type __m256 to type __m512; the upper 256 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_zextps256_ps512&expand=6197)_mm512_castps512_ps128/// Cast vector of type __m512 to type __m128. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps512_ps128&expand=624)_mm512_castps512_ps256/// Cast vector of type __m512 to type __m256. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps512_ps256&expand=625)_mm512_castps_pd/// Cast vector of type __m512 to type __m512d. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps_pd&expand=616)_mm512_castps_si512/// Cast vector of type __m512 to type __m512i. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps_si512&expand=619)_mm512_castpd128_pd512/// Cast vector of type __m128d to type __m512d; the upper 384 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd128_pd512&expand=609)_mm512_castpd256_pd512/// Cast vector of type __m256d to type __m512d; the upper 256 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd256_pd512&expand=611)_mm512_zextpd128_pd512/// Cast vector of type __m128d to type __m512d; the upper 384 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_zextpd128_pd512&expand=6193)_mm512_zextpd256_pd512/// Cast vector of type __m256d to type __m512d; the upper 256 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_zextpd256_pd512&expand=6194)_mm512_castpd512_pd128/// Cast vector of type __m512d to type __m128d. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd512_pd128&expand=612)_mm512_castpd512_pd256/// Cast vector of type __m512d to type __m256d. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd512_pd256&expand=613)_mm512_castpd_ps/// Cast vector of type __m512d to type __m512. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd_ps&expand=604)_mm512_castpd_si512/// Cast vector of type __m512d to type __m512i. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd_si512&expand=607)_mm512_castsi128_si512/// Cast vector of type __m128i to type __m512i; the upper 384 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi128_si512&expand=629)_mm512_castsi256_si512/// Cast vector of type __m256i to type __m512i; the upper 256 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi256_si512&expand=633)_mm512_zextsi128_si512/// Cast vector of type __m128i to type __m512i; the upper 384 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_zextsi128_si512&expand=6199)_mm512_zextsi256_si512/// Cast vector of type __m256i to type __m512i; the upper 256 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_zextsi256_si512&expand=6200)_mm512_castsi512_si128/// Cast vector of type __m512i to type __m128i. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi512_si128&expand=636)_mm512_castsi512_si256/// Cast vector of type __m512i to type __m256i. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi512_si256&expand=637)_mm512_castsi512_ps/// Cast vector of type __m512i to type __m512. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi512_ps&expand=635)_mm512_castsi512_pd/// Cast vector of type __m512i to type __m512d. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi512_pd&expand=634)_mm512_cvtsi512_si32/// Copy the lower 32-bit integer in a to dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsi512_si32&expand=1882)_mm512_cvtss_f32/// Copy the lower single-precision (32-bit) floating-point element of a to dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtss_f32)_mm512_cvtsd_f64/// Copy the lower double-precision (64-bit) floating-point element of a to dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cvtsd_f64)_mm512_broadcastd_epi32/// Broadcast the low packed 32-bit integer from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastd_epi32&expand=545)//should be vpbroadcastd_mm512_mask_broadcastd_epi32/// Broadcast the low packed 32-bit integer from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcastd_epi32&expand=546)_mm512_maskz_broadcastd_epi32/// Broadcast the low packed 32-bit integer from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcastd_epi32&expand=547)_mm256_mask_broadcastd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcastd_epi32&expand=543)_mm256_maskz_broadcastd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcastd_epi32&expand=544)_mm_mask_broadcastd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_broadcastd_epi32&expand=540)_mm_maskz_broadcastd_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_broadcastd_epi32&expand=541)_mm512_broadcastq_epi64/// Broadcast the low packed 64-bit integer from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastq_epi64&expand=560)//should be vpbroadcastq_mm512_mask_broadcastq_epi64/// Broadcast the low packed 64-bit integer from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcastq_epi64&expand=561)_mm512_maskz_broadcastq_epi64/// Broadcast the low packed 64-bit integer from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcastq_epi64&expand=562)_mm256_mask_broadcastq_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcastq_epi64&expand=558)_mm256_maskz_broadcastq_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcastq_epi64&expand=559)_mm_mask_broadcastq_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_broadcastq_epi64&expand=555)_mm_maskz_broadcastq_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_broadcastq_epi64&expand=556)_mm512_broadcastss_ps/// Broadcast the low single-precision (32-bit) floating-point element from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastss_ps&expand=578)_mm512_mask_broadcastss_ps/// Broadcast the low single-precision (32-bit) floating-point element from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcastss_ps&expand=579)_mm512_maskz_broadcastss_ps/// Broadcast the low single-precision (32-bit) floating-point element from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcastss_ps&expand=580)_mm256_mask_broadcastss_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcastss_ps&expand=576)_mm256_maskz_broadcastss_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcastss_ps&expand=577)_mm_mask_broadcastss_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_broadcastss_ps&expand=573)_mm_maskz_broadcastss_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_broadcastss_ps&expand=574)_mm512_broadcastsd_pd/// Broadcast the low double-precision (64-bit) floating-point element from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcastsd_pd&expand=567)_mm512_mask_broadcastsd_pd/// Broadcast the low double-precision (64-bit) floating-point element from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcastsd_pd&expand=568)_mm512_maskz_broadcastsd_pd/// Broadcast the low double-precision (64-bit) floating-point element from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcastsd_pd&expand=569)_mm256_mask_broadcastsd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcastsd_pd&expand=565)_mm256_maskz_broadcastsd_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcastsd_pd&expand=566)_mm512_broadcast_i32x4/// Broadcast the 4 packed 32-bit integers from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_i32x4&expand=510)//msvc: vbroadcasti32x4, linux: vshuf_mm512_mask_broadcast_i32x4/// Broadcast the 4 packed 32-bit integers from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_i32x4&expand=511)_mm512_maskz_broadcast_i32x4/// Broadcast the 4 packed 32-bit integers from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_i32x4&expand=512)_mm256_broadcast_i32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_i32x4&expand=507)_mm256_mask_broadcast_i32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcast_i32x4&expand=508)_mm256_maskz_broadcast_i32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcast_i32x4&expand=509)_mm512_broadcast_i64x4/// Broadcast the 4 packed 64-bit integers from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_i64x4&expand=522)//msvc: vbroadcasti64x4, linux: vperm_mm512_mask_broadcast_i64x4/// Broadcast the 4 packed 64-bit integers from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_i64x4&expand=523)_mm512_maskz_broadcast_i64x4/// Broadcast the 4 packed 64-bit integers from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_i64x4&expand=524)_mm512_broadcast_f32x4/// Broadcast the 4 packed single-precision (32-bit) floating-point elements from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_f32x4&expand=483)//msvc: vbroadcastf32x4, linux: vshuf_mm512_mask_broadcast_f32x4/// Broadcast the 4 packed single-precision (32-bit) floating-point elements from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_f32x4&expand=484)//msvc: vbroadcastf32x4, linux: vshu_mm512_maskz_broadcast_f32x4/// Broadcast the 4 packed single-precision (32-bit) floating-point elements from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_f32x4&expand=485)_mm256_broadcast_f32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_broadcast_f32x4&expand=480)_mm256_mask_broadcast_f32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_broadcast_f32x4&expand=481)_mm256_maskz_broadcast_f32x4/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_broadcast_f32x4&expand=482)_mm512_broadcast_f64x4/// Broadcast the 4 packed double-precision (64-bit) floating-point elements from a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_broadcast_f64x4&expand=495)//msvc: vbroadcastf64x4, linux: vperm_mm512_mask_broadcast_f64x4/// Broadcast the 4 packed double-precision (64-bit) floating-point elements from a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_broadcast_f64x4&expand=496)//msvc: vbroadcastf64x4, linux: vper_mm512_maskz_broadcast_f64x4/// Broadcast the 4 packed double-precision (64-bit) floating-point elements from a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_broadcast_f64x4&expand=497)_mm512_mask_blend_epi32/// Blend packed 32-bit integers from a and b using control mask k, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_blend_epi32&expand=435)//should be vpblendmd_mm256_mask_blend_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_blend_epi32&expand=434)_mm_mask_blend_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_blend_epi32&expand=432)_mm512_mask_blend_epi64/// Blend packed 64-bit integers from a and b using control mask k, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_blend_epi64&expand=438)//should be vpblendmq_mm256_mask_blend_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_blend_epi64&expand=437)_mm_mask_blend_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_blend_epi64&expand=436)_mm512_mask_blend_ps/// Blend packed single-precision (32-bit) floating-point elements from a and b using control mask k, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_blend_ps&expand=451)//should be vpblendmps_mm256_mask_blend_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_blend_ps&expand=450)_mm_mask_blend_ps/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_blend_ps&expand=448)_mm512_mask_blend_pd/// Blend packed double-precision (64-bit) floating-point elements from a and b using control mask k, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_blend_pd&expand=446)//should be vpblendmpd_mm256_mask_blend_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_blend_pd&expand=445)_mm_mask_blend_pd/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_blend_pd&expand=443)_mm512_alignr_epi32/// Concatenate a and b into a 128-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 64 bytes (16 elements) in dst./// <div class="warning">Only lowest <strong>4 bits</strong> are used from the mask (shift at maximum by 60 bytes)!</div>/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_alignr_epi32&expand=245)_mm512_mask_alignr_epi32/// Concatenate a and b into a 128-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 64 bytes (16 elements) in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_alignr_epi32&expand=246)_mm512_maskz_alignr_epi32/// Concatenate a and b into a 128-byte immediate result, shift the result right by imm8 32-bit elements, and stores the low 64 bytes (16 elements) in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_alignr_epi32&expand=247)_mm256_alignr_epi32/// Concatenate a and b into a 64-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 32 bytes (8 elements) in dst./// <div class="warning">Only lowest <strong>3 bits</strong> are used from the mask (shift at maximum by 28 bytes)!</div>/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_alignr_epi32&expand=242)_mm256_mask_alignr_epi32/// Concatenate a and b into a 64-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 32 bytes (8 elements) in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_alignr_epi32&expand=243)_mm256_maskz_alignr_epi32/// Concatenate a and b into a 64-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 32 bytes (8 elements) in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_alignr_epi32&expand=244)_mm_alignr_epi32/// Concatenate a and b into a 32-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 16 bytes (4 elements) in dst./// <div class="warning">Only lowest <strong>2 bits</strong> are used from the mask (shift at maximum by 12 bytes)!</div>/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_alignr_epi32&expand=239)//should be valignd_mm_mask_alignr_epi32/// Concatenate a and b into a 32-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 16 bytes (4 elements) in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_alignr_epi32&expand=240)_mm_maskz_alignr_epi32/// Concatenate a and b into a 32-byte immediate result, shift the result right by imm8 32-bit elements, and store the low 16 bytes (4 elements) in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_alignr_epi32&expand=241)_mm512_alignr_epi64/// Concatenate a and b into a 128-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 64 bytes (8 elements) in dst./// <div class="warning">Only lowest <strong>3 bits</strong> are used from the mask (shift at maximum by 56 bytes)!</div>/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_alignr_epi64&expand=254)_mm512_mask_alignr_epi64/// Concatenate a and b into a 128-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 64 bytes (8 elements) in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_alignr_epi64&expand=255)_mm512_maskz_alignr_epi64/// Concatenate a and b into a 128-byte immediate result, shift the result right by imm8 64-bit elements, and stores the low 64 bytes (8 elements) in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_alignr_epi64&expand=256)_mm256_alignr_epi64/// Concatenate a and b into a 64-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 32 bytes (4 elements) in dst./// <div class="warning">Only lowest <strong>2 bits</strong> are used from the mask (shift at maximum by 24 bytes)!</div>/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_alignr_epi64&expand=251)_mm256_mask_alignr_epi64/// Concatenate a and b into a 64-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 32 bytes (4 elements) in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_alignr_epi64&expand=252)_mm256_maskz_alignr_epi64/// Concatenate a and b into a 64-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 32 bytes (4 elements) in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_alignr_epi64&expand=253)_mm_alignr_epi64/// Concatenate a and b into a 32-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 16 bytes (2 elements) in dst./// <div class="warning">Only lowest <strong>bit</strong> is used from the mask (shift at maximum by 8 bytes)!</div>/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_alignr_epi64&expand=248)//should be valignq_mm_mask_alignr_epi64/// Concatenate a and b into a 32-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 16 bytes (2 elements) in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_alignr_epi64&expand=249)_mm_maskz_alignr_epi64/// Concatenate a and b into a 32-byte immediate result, shift the result right by imm8 64-bit elements, and store the low 16 bytes (2 elements) in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_alignr_epi64&expand=250)_mm512_and_epi32/// Compute the bitwise AND of packed 32-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_and_epi32&expand=272)//should be vpandd, but generate vpandq_mm512_mask_and_epi32/// Performs element-by-element bitwise AND between packed 32-bit integer elements of a and b, storing the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_and_epi32&expand=273)_mm512_maskz_and_epi32/// Compute the bitwise AND of packed 32-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_and_epi32&expand=274)_mm256_mask_and_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_and_epi32&expand=270)_mm256_maskz_and_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_and_epi32&expand=271)_mm_mask_and_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_and_epi32&expand=268)_mm_maskz_and_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_and_epi32&expand=269)_mm512_and_epi64/// Compute the bitwise AND of 512 bits (composed of packed 64-bit integers) in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_and_epi64&expand=279)_mm512_mask_and_epi64/// Compute the bitwise AND of packed 64-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_and_epi64&expand=280)_mm512_maskz_and_epi64/// Compute the bitwise AND of packed 64-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_and_epi64&expand=281)_mm256_mask_and_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_and_epi64&expand=277)_mm256_maskz_and_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_and_epi64&expand=278)_mm_mask_and_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_and_epi64&expand=275)_mm_maskz_and_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_and_epi64&expand=276)_mm512_and_si512/// Compute the bitwise AND of 512 bits (representing integer data) in a and b, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_and_si512&expand=302)_mm512_or_epi32/// Compute the bitwise OR of packed 32-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_or_epi32&expand=4042)_mm512_mask_or_epi32/// Compute the bitwise OR of packed 32-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_or_epi32&expand=4040)_mm512_maskz_or_epi32/// Compute the bitwise OR of packed 32-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_or_epi32&expand=4041)_mm256_or_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_or_epi32&expand=4039)//should be vpord_mm256_mask_or_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_or_epi32&expand=4037)_mm256_maskz_or_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_or_epi32&expand=4038)_mm_or_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_or_epi32&expand=4036)_mm_mask_or_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_or_epi32&expand=4034)_mm_maskz_or_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_or_epi32&expand=4035)_mm512_or_epi64/// Compute the bitwise OR of packed 64-bit integers in a and b, and store the resut in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_or_epi64&expand=4051)_mm512_mask_or_epi64/// Compute the bitwise OR of packed 64-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_or_epi64&expand=4049)_mm512_maskz_or_epi64/// Compute the bitwise OR of packed 64-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_or_epi64&expand=4050)_mm256_or_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_or_epi64&expand=4048)//should be vporq_mm256_mask_or_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_or_epi64&expand=4046)_mm256_maskz_or_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_or_epi64&expand=4047)_mm_or_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_or_epi64&expand=4045)_mm_mask_or_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_or_epi64&expand=4043)_mm_maskz_or_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_or_epi64&expand=4044)_mm512_or_si512/// Compute the bitwise OR of 512 bits (representing integer data) in a and b, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_or_si512&expand=4072)_mm512_xor_epi32/// Compute the bitwise XOR of packed 32-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_xor_epi32&expand=6142)//should be vpxord_mm512_mask_xor_epi32/// Compute the bitwise XOR of packed 32-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_xor_epi32&expand=6140)_mm512_maskz_xor_epi32/// Compute the bitwise XOR of packed 32-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_xor_epi32&expand=6141)_mm256_xor_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_xor_epi32&expand=6139)_mm256_mask_xor_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_xor_epi32&expand=6137)_mm256_maskz_xor_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_xor_epi32&expand=6138)_mm_xor_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_xor_epi32&expand=6136)_mm_mask_xor_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_xor_epi32&expand=6134)_mm_maskz_xor_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_xor_epi32&expand=6135)_mm512_xor_epi64/// Compute the bitwise XOR of packed 64-bit integers in a and b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_xor_epi64&expand=6151)_mm512_mask_xor_epi64/// Compute the bitwise XOR of packed 64-bit integers in a and b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_xor_epi64&expand=6149)_mm512_maskz_xor_epi64/// Compute the bitwise XOR of packed 64-bit integers in a and b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_xor_epi64&expand=6150)_mm256_xor_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_xor_epi64&expand=6148)//should be vpxorq_mm256_mask_xor_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_xor_epi64&expand=6146)_mm256_maskz_xor_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_xor_epi64&expand=6147)_mm_xor_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_xor_epi64&expand=6145)_mm_mask_xor_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_xor_epi64&expand=6143)_mm_maskz_xor_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_xor_epi64&expand=6144)_mm512_xor_si512/// Compute the bitwise XOR of 512 bits (representing integer data) in a and b, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_xor_si512&expand=6172)_mm512_andnot_epi32/// Compute the bitwise NOT of packed 32-bit integers in a and then AND with b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_andnot_epi32&expand=310)//should be vpandnd_mm512_mask_andnot_epi32/// Compute the bitwise NOT of packed 32-bit integers in a and then AND with b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_andnot_epi32&expand=311)_mm512_maskz_andnot_epi32/// Compute the bitwise NOT of packed 32-bit integers in a and then AND with b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_andnot_epi32&expand=312)_mm256_mask_andnot_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_andnot_epi32&expand=308)_mm256_maskz_andnot_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_andnot_epi32&expand=309)_mm_mask_andnot_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_andnot_epi32&expand=306)_mm_maskz_andnot_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_andnot_epi32&expand=307)_mm512_andnot_epi64/// Compute the bitwise NOT of 512 bits (composed of packed 64-bit integers) in a and then AND with b, and store the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_andnot_epi64&expand=317)_mm512_mask_andnot_epi64/// Compute the bitwise NOT of packed 64-bit integers in a and then AND with b, and store the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_andnot_epi64&expand=318)_mm512_maskz_andnot_epi64/// Compute the bitwise NOT of packed 64-bit integers in a and then AND with b, and store the results in dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_andnot_epi64&expand=319)_mm256_mask_andnot_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_andnot_epi64&expand=315)_mm256_maskz_andnot_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_andnot_epi64&expand=316)_mm_mask_andnot_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_andnot_epi64&expand=313)_mm_maskz_andnot_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_andnot_epi64&expand=314)_mm512_andnot_si512/// Compute the bitwise NOT of 512 bits (representing integer data) in a and then AND with b, and store the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_andnot_si512&expand=340)_cvtmask16_u32/// Convert 16-bit mask a into an integer value, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_cvtmask16_u32)_cvtu32_mask16/// Convert 32-bit integer value a to an 16-bit mask and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_cvtu32_mask16)_kand_mask16/// Compute the bitwise AND of 16-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=kand_mask16&expand=3212)// generate normal and code instead of kandw_mm512_kand/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kand&expand=3210)_kor_mask16/// Compute the bitwise OR of 16-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=kor_mask16&expand=3239)// generate normal or code instead of korw_mm512_kor/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kor&expand=3237)_kxor_mask16/// Compute the bitwise XOR of 16-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=kxor_mask16&expand=3291)// generate normal xor code instead of kxorw_mm512_kxor/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kxor&expand=3289)_knot_mask16/// Compute the bitwise NOT of 16-bit mask a, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=knot_mask16&expand=3233)_mm512_knot/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_knot&expand=3231)_kandn_mask16/// Compute the bitwise NOT of 16-bit masks a and then AND with b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=kandn_mask16&expand=3218)// generate normal and, not code instead of kandnw_mm512_kandn/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kandn&expand=3216)_kxnor_mask16/// Compute the bitwise XNOR of 16-bit masks a and b, and store the result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=kxnor_mask16&expand=3285)// generate normal xor, not code instead of kxnorw_mm512_kxnor/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kxnor&expand=3283)_kortest_mask16_u8/// Compute the bitwise OR of 16-bit masks a and b. If the result is all zeros, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortest_mask16_u8)_kortestc_mask16_u8/// Compute the bitwise OR of 16-bit masks a and b. If the result is all ones, store 1 in dst, otherwise/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestc_mask16_u8)_kortestz_mask16_u8/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kortestz_mask16_u8)_kshiftli_mask16/// Shift 16-bit mask a left by count bits while shifting in zeros, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftli_mask16)_kshiftri_mask16/// Shift 16-bit mask a right by count bits while shifting in zeros, and store the result in dst./// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_kshiftri_mask16)_load_mask16/// Load 16-bit mask from memory/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_load_mask16)_store_mask16/// Store 16-bit mask to memory/// [Intel's Documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_store_mask16)_mm512_kmov/// Copy 16-bit mask a to k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm512_kmov&expand=3228)// generate normal and code instead of kmovw_mm512_int2mask/// Converts integer mask into bitmask, storing the result in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_int2mask&expand=3189)_mm512_mask2int/// Converts bit mask k1 into an integer value, storing the results in dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask2int&expand=3544)_mm512_kunpackb/// Unpack and interleave 8 bits from masks a and b, and store the 16-bit result in k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kunpackb&expand=3280)// generate normal and code instead of kunpckbw_mm512_kortestc/// Performs bitwise OR between k1 and k2, storing the result in dst. CF flag is set if dst consists of all 1's./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kortestc&expand=3247)// generate normal and code instead of kortestw_mm512_kortestz/// Performs bitwise OR between k1 and k2, storing the result in dst. ZF flag is set if dst is 0./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_kortestz)_mm512_test_epi32_mask/// Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in result mask k if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_test_epi32_mask&expand=5890)_mm512_mask_test_epi32_mask/// Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_test_epi32_mask&expand=5889)_mm256_test_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_test_epi32_mask&expand=5888)_mm256_mask_test_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_test_epi32_mask&expand=5887)_mm_test_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_test_epi32_mask&expand=5886)_mm_mask_test_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_test_epi32_mask&expand=5885)_mm512_test_epi64_mask/// Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in result mask k if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_test_epi64_mask&expand=5896)_mm512_mask_test_epi64_mask/// Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is non-zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_test_epi64_mask&expand=5895)_mm256_test_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_test_epi64_mask&expand=5894)_mm256_mask_test_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_test_epi64_mask&expand=5893)_mm_test_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_test_epi64_mask&expand=5892)_mm_mask_test_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_test_epi64_mask&expand=5891)_mm512_testn_epi32_mask/// Compute the bitwise NAND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in result mask k if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_testn_epi32_mask&expand=5921)_mm512_mask_testn_epi32_mask/// Compute the bitwise NAND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_testn_epi32_mask&expand=5920)_mm256_testn_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testn_epi32_mask&expand=5919)_mm256_mask_testn_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_testn_epi32_mask&expand=5918)_mm_testn_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testn_epi32_mask&expand=5917)_mm_mask_testn_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_testn_epi32_mask&expand=5916)_mm512_testn_epi64_mask/// Compute the bitwise NAND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in result mask k if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_testn_epi64_mask&expand=5927)_mm512_mask_testn_epi64_mask/// Compute the bitwise NAND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in result mask k (subject to writemask k) if the intermediate value is zero./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_testn_epi64_mask&expand=5926)_mm256_testn_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_testn_epi64_mask&expand=5925)_mm256_mask_testn_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_testn_epi64_mask&expand=5924)_mm_testn_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testn_epi64_mask&expand=5923)_mm_mask_testn_epi64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_testn_epi64_mask&expand=5922)_mm512_stream_ps/// Store 512-bits (composed of 16 packed single-precision (32-bit) floating-point elements) from a into memory using a non-temporal memory hint. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_stream_ps&expand=5671)_mm512_stream_pd/// Store 512-bits (composed of 8 packed double-precision (64-bit) floating-point elements) from a into memory using a non-temporal memory hint. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_stream_pd&expand=5667)_mm512_stream_si512/// Store 512-bits of integer data from a into memory using a non-temporal memory hint. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_stream_si512&expand=5675)_mm512_stream_load_si512/// Load 512-bits of integer data from memory into dst using a non-temporal memory hint. mem_addr/// must be aligned on a 64-byte boundary or a general-protection exception may be generated. To/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_stream_load_si512)_mm512_set_ps/// Sets packed 32-bit integers in `dst` with the supplied values./// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set_ps&expand=4931)_mm512_setr_ps/// Sets packed 32-bit integers in `dst` with the supplied values in/// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr_ps&expand=5008)_mm512_set1_pd/// Broadcast 64-bit float `a` to all elements of `dst`./// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set1_pd&expand=4975)_mm512_set1_ps/// Broadcast 32-bit float `a` to all elements of `dst`./// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set1_ps&expand=4981)_mm512_set_epi32/// [Intel's documentation]( https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set_epi32&expand=4908)_mm512_set1_epi8/// Broadcast 8-bit integer a to all elements of dst./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set1_epi8&expand=4972)_mm512_set1_epi16/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set1_epi16&expand=4944)_mm512_set1_epi32/// Broadcast 32-bit integer `a` to all elements of `dst`./// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_set1_epi32)_mm512_mask_set1_epi32/// Broadcast 32-bit integer a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_set1_epi32&expand=4951)_mm512_maskz_set1_epi32/// Broadcast 32-bit integer a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_set1_epi32&expand=4952)_mm256_mask_set1_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_set1_epi32&expand=4948)_mm256_maskz_set1_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_set1_epi32&expand=4949)_mm_mask_set1_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_set1_epi32&expand=4945)_mm_maskz_set1_epi32/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_set1_epi32&expand=4946)_mm512_set1_epi64/// Broadcast 64-bit integer `a` to all elements of `dst`./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set1_epi64&expand=4961)_mm512_mask_set1_epi64/// Broadcast 64-bit integer a to all elements of dst using writemask k (elements are copied from src when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_set1_epi64&expand=4959)_mm512_maskz_set1_epi64/// Broadcast 64-bit integer a to all elements of dst using zeromask k (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_maskz_set1_epi64&expand=4960)_mm256_mask_set1_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_set1_epi64&expand=4957)_mm256_maskz_set1_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_maskz_set1_epi64&expand=4958)_mm_mask_set1_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_set1_epi64&expand=4954)_mm_maskz_set1_epi64/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskz_set1_epi64&expand=4955)_mm512_set4_epi64/// Set packed 64-bit integers in dst with the repeated 4 element sequence./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_set4_epi64&expand=4983)_mm512_setr4_epi64/// Set packed 64-bit integers in dst with the repeated 4 element sequence in reverse order./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_setr4_epi64&expand=5010)_mm512_cmplt_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_ps_mask&expand=1074)//should be vcmpps_mm512_mask_cmplt_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_ps_mask&expand=1075)_mm512_cmpnlt_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for not-less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpnlt_ps_mask&expand=1154)_mm512_mask_cmpnlt_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for not-less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpnlt_ps_mask&expand=1155)_mm512_cmple_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_ps_mask&expand=1013)_mm512_mask_cmple_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_ps_mask&expand=1014)_mm512_cmpnle_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for not-less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpnle_ps_mask&expand=1146)_mm512_mask_cmpnle_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for not-less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpnle_ps_mask&expand=1147)_mm512_cmpeq_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_ps_mask&expand=828)_mm512_mask_cmpeq_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_ps_mask&expand=829)_mm512_cmpneq_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_ps_mask&expand=1130)_mm512_mask_cmpneq_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_ps_mask&expand=1131)_mm512_cmp_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_ps_mask&expand=749)_mm512_mask_cmp_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_ps_mask&expand=750)_mm256_cmp_ps_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_ps_mask&expand=747)_mm256_mask_cmp_ps_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_ps_mask&expand=748)_mm_cmp_ps_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_ps_mask&expand=745)_mm_mask_cmp_ps_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_ps_mask&expand=746)_mm512_cmp_round_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_round_ps_mask&expand=753)_mm512_mask_cmp_round_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_round_ps_mask&expand=754)_mm512_cmpord_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b to see if neither is NaN, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpord_ps_mask&expand=1162)//should be vcmps_mm512_mask_cmpord_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b to see if neither is NaN, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpord_ps_mask&expand=1163)_mm512_cmpunord_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b to see if either is NaN, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpunord_ps_mask&expand=1170)_mm512_mask_cmpunord_ps_mask/// Compare packed single-precision (32-bit) floating-point elements in a and b to see if either is NaN, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpunord_ps_mask&expand=1171)_mm512_cmplt_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_pd_mask&expand=1071)//should be vcmppd_mm512_mask_cmplt_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_pd_mask&expand=1072)_mm512_cmpnlt_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for not-less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpnlt_pd_mask&expand=1151)_mm512_mask_cmpnlt_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for not-less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpnlt_pd_mask&expand=1152)_mm512_cmple_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_pd_mask&expand=1010)_mm512_mask_cmple_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_pd_mask&expand=1011)_mm512_cmpnle_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for not-less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpnle_pd_mask&expand=1143)_mm512_mask_cmpnle_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for not-less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpnle_pd_mask&expand=1144)_mm512_cmpeq_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_pd_mask&expand=822)_mm512_mask_cmpeq_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_pd_mask&expand=823)_mm512_cmpneq_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_pd_mask&expand=1127)_mm512_mask_cmpneq_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_pd_mask&expand=1128)_mm512_cmp_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_pd_mask&expand=741)_mm512_mask_cmp_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_pd_mask&expand=742)_mm256_cmp_pd_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_pd_mask&expand=739)_mm256_mask_cmp_pd_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_pd_mask&expand=740)_mm_cmp_pd_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_pd_mask&expand=737)_mm_mask_cmp_pd_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_pd_mask&expand=738)_mm512_cmp_round_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_round_pd_mask&expand=751)_mm512_mask_cmp_round_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_round_pd_mask&expand=752)_mm512_cmpord_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b to see if neither is NaN, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpord_pd_mask&expand=1159)_mm512_mask_cmpord_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b to see if neither is NaN, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpord_pd_mask&expand=1160)_mm512_cmpunord_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b to see if either is NaN, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpunord_pd_mask&expand=1167)_mm512_mask_cmpunord_pd_mask/// Compare packed double-precision (64-bit) floating-point elements in a and b to see if either is NaN, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpunord_pd_mask&expand=1168)_mm_cmp_ss_mask/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_ss_mask&expand=763)_mm_mask_cmp_ss_mask/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_ss_mask&expand=764)_mm_cmp_round_ss_mask/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_round_ss_mask&expand=757)_mm_mask_cmp_round_ss_mask/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not seti).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_round_ss_mask&expand=758)_mm_cmp_sd_mask/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_sd_mask&expand=760)_mm_mask_cmp_sd_mask/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_sd_mask&expand=761)_mm_cmp_round_sd_mask/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k.\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_round_sd_mask&expand=755)_mm_mask_cmp_round_sd_mask/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not set).\/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_round_sd_mask&expand=756)_mm512_cmplt_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_epu32_mask&expand=1056)//should be vpcmpud_mm512_mask_cmplt_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epu32_mask&expand=1057)_mm256_cmplt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epu32_mask&expand=1054)_mm256_mask_cmplt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epu32_mask&expand=1055)_mm_cmplt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epu32_mask&expand=1052)_mm_mask_cmplt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epu32_mask&expand=1053)_mm512_cmpgt_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epu32_mask&expand=933)_mm512_mask_cmpgt_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epu32_mask&expand=934)_mm256_cmpgt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epu32_mask&expand=931)_mm256_mask_cmpgt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epu32_mask&expand=932)_mm_cmpgt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epu32_mask&expand=929)_mm_mask_cmpgt_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epu32_mask&expand=930)_mm512_cmple_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epu32_mask&expand=995)_mm512_mask_cmple_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_epu32_mask&expand=996)_mm256_cmple_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmple_epu32_mask&expand=993)_mm256_mask_cmple_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmple_epu32_mask&expand=994)_mm_cmple_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_epu32_mask&expand=991)_mm_mask_cmple_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmple_epu32_mask&expand=992)_mm512_cmpge_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpge_epu32_mask&expand=873)_mm512_mask_cmpge_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpge_epu32_mask&expand=874)_mm256_cmpge_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpge_epu32_mask&expand=871)_mm256_mask_cmpge_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpge_epu32_mask&expand=872)_mm_cmpge_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_epu32_mask&expand=869)_mm_mask_cmpge_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpge_epu32_mask&expand=870)_mm512_cmpeq_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_epu32_mask&expand=807)_mm512_mask_cmpeq_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_epu32_mask&expand=808)_mm256_cmpeq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epu32_mask&expand=805)_mm256_mask_cmpeq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpeq_epu32_mask&expand=806)_mm_cmpeq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epu32_mask&expand=803)_mm_mask_cmpeq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpeq_epu32_mask&expand=804)_mm512_cmpneq_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_epu32_mask&expand=1112)_mm512_mask_cmpneq_epu32_mask/// Compare packed unsigned 32-bit integers in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_epu32_mask&expand=1113)_mm256_cmpneq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpneq_epu32_mask&expand=1110)_mm256_mask_cmpneq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpneq_epu32_mask&expand=1111)_mm_cmpneq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_epu32_mask&expand=1108)_mm_mask_cmpneq_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpneq_epu32_mask&expand=1109)_MM_CMPINT_ENUM_mm512_cmp_epu32_mask/// Compare packed unsigned 32-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_epu32_mask&expand=721)_mm512_mask_cmp_epu32_mask/// Compare packed unsigned 32-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_epu32_mask&expand=722)_mm256_cmp_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmp_epu32_mask&expand=719)_mm256_mask_cmp_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_epu32_mask&expand=720)_mm_cmp_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_epu32_mask&expand=717)_mm_mask_cmp_epu32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_epu32_mask&expand=718)_mm512_cmplt_epi32_mask/// Compare packed signed 32-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_epi32_mask&expand=1029)//should be vpcmpd_mm512_mask_cmplt_epi32_mask/// Compare packed signed 32-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epi32_mask&expand=1031)_mm256_cmplt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epi32_mask&expand=1027)_mm256_mask_cmplt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epi32_mask&expand=1028)_mm_cmplt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epi32_mask&expand=1025)_mm_mask_cmplt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epi32_mask&expand=1026)_mm512_cmpgt_epi32_mask/// Compare packed signed 32-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epi32_mask&expand=905)_mm512_mask_cmpgt_epi32_mask/// Compare packed signed 32-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epi32_mask&expand=906)_mm256_cmpgt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epi32_mask&expand=903)_mm256_mask_cmpgt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epi32_mask&expand=904)_mm_cmpgt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epi32_mask&expand=901)_mm_mask_cmpgt_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epi32_mask&expand=902)_mm512_cmple_epi32_mask/// Compare packed signed 32-bit integers in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epi32_mask&expand=971)_mm512_mask_cmple_epi32_mask/// Compare packed signed 32-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmple_epi32_mask&expand=972)_mm256_cmple_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmple_epi32_mask&expand=969)_mm256_mask_cmple_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmple_epi32_mask&expand=970)_mm_cmple_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_epi32_mask&expand=967)_mm_mask_cmple_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmple_epi32_mask&expand=968)_mm512_cmpge_epi32_mask/// Compare packed signed 32-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpge_epi32_mask&expand=849)_mm512_mask_cmpge_epi32_mask/// Compare packed signed 32-bit integers in a and b for greater-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpge_epi32_mask&expand=850)_mm256_cmpge_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpge_epi32_mask&expand=847)_mm256_mask_cmpge_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpge_epi32_mask&expand=848)_mm_cmpge_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_epi32_mask&expand=845)_mm_mask_cmpge_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpge_epi32_mask&expand=846)_mm512_cmpeq_epi32_mask/// Compare packed 32-bit integers in a and b for equality, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpeq_epi32_mask&expand=779)_mm512_mask_cmpeq_epi32_mask/// Compare packed 32-bit integers in a and b for equality, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpeq_epi32_mask&expand=780)_mm256_cmpeq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpeq_epi32_mask&expand=777)_mm256_mask_cmpeq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpeq_epi32_mask&expand=778)_mm_cmpeq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epi32_mask&expand=775)_mm_mask_cmpeq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpeq_epi32_mask&expand=776)_mm512_cmpneq_epi32_mask/// Compare packed 32-bit integers in a and b for not-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpneq_epi32_mask&expand=1088)_mm512_mask_cmpneq_epi32_mask/// Compare packed 32-bit integers in a and b for not-equal, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpneq_epi32_mask&expand=1089)_mm256_cmpneq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpneq_epi32_mask&expand=1086)_mm256_mask_cmpneq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpneq_epi32_mask&expand=1087)_mm_cmpneq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_epi32_mask&expand=1084)_mm_mask_cmpneq_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpneq_epi32_mask&expand=1085)_mm512_cmp_epi32_mask/// Compare packed signed 32-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmp_epi32_mask&expand=697)_mm512_mask_cmp_epi32_mask/// Compare packed signed 32-bit integers in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmp_epi32_mask&expand=698)_mm256_cmp_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=#text=_mm256_cmp_epi32_mask&expand=695)_mm256_mask_cmp_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmp_epi32_mask&expand=696)_mm_cmp_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmp_epi32_mask&expand=693)_mm_mask_cmp_epi32_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmp_epi32_mask&expand=694)_mm512_cmplt_epu64_mask/// Compare packed unsigned 64-bit integers in a and b for less-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmplt_epu64_mask&expand=1062)//should be vpcmpuq_mm512_mask_cmplt_epu64_mask/// Compare packed unsigned 64-bit integers in a and b for less-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmplt_epu64_mask&expand=1063)_mm256_cmplt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmplt_epu64_mask&expand=1060)_mm256_mask_cmplt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmplt_epu64_mask&expand=1061)_mm_cmplt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epu64_mask&expand=1058)_mm_mask_cmplt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmplt_epu64_mask&expand=1059)_mm512_cmpgt_epu64_mask/// Compare packed unsigned 64-bit integers in a and b for greater-than, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmpgt_epu64_mask&expand=939)_mm512_mask_cmpgt_epu64_mask/// Compare packed unsigned 64-bit integers in a and b for greater-than, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set)./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_mask_cmpgt_epu64_mask&expand=940)_mm256_cmpgt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_cmpgt_epu64_mask&expand=937)_mm256_mask_cmpgt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_mask_cmpgt_epu64_mask&expand=938)_mm_cmpgt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epu64_mask&expand=935)_mm_mask_cmpgt_epu64_mask/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mask_cmpgt_epu64_mask&expand=936)_mm512_cmple_epu64_mask/// Compare packed unsigned 64-bit integers in a and b for less-than-or-equal, and store the results in mask vector k./// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_cmple_epu64_mask&expand=1001)_mm512_mask_cmple_epu64_mask/// Compare packed unsigned 64-bit integers in a and b for less-than-or-equal, and store the results in mask vector k using zeromask k1 (elements are